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 #ifdef CONFIG_PM
  45 static inline int drv_suspend(struct ieee80211_local *local,
  46                               struct cfg80211_wowlan *wowlan)
  47 {
  48         int ret;
  49
  50         might_sleep();
  51
  52         trace_drv_suspend(local);
  53         ret = local->ops->suspend(&local->hw, wowlan);
  54         trace_drv_return_int(local, ret);
  55         return ret;
  56 }
  57
  58 static inline int drv_resume(struct ieee80211_local *local)
  59 {
  60         int ret;
  61
  62         might_sleep();
  63
  64         trace_drv_resume(local);
  65         ret = local->ops->resume(&local->hw);
  66         trace_drv_return_int(local, ret);
  67         return ret;
  68 }
  69 #endif
  70
  71 static inline int drv_add_interface(struct ieee80211_local *local,
  72                                     struct ieee80211_vif *vif)
  73 {
  74         int ret;
  75
  76         might_sleep();
  77
  78         trace_drv_add_interface(local, vif_to_sdata(vif));
  79         ret = local->ops->add_interface(&local->hw, vif);
  80         trace_drv_return_int(local, ret);
  81         return ret;
  82 }
  83
  84 static inline int drv_change_interface(struct ieee80211_local *local,
  85                                        struct ieee80211_sub_if_data *sdata,
  86                                        enum nl80211_iftype type, bool p2p)
  87 {
  88         int ret;
  89
  90         might_sleep();
  91
  92         trace_drv_change_interface(local, sdata, type, p2p);
  93         ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p);
  94         trace_drv_return_int(local, ret);
  95         return ret;
  96 }
  97
  98 static inline void drv_remove_interface(struct ieee80211_local *local,
  99                                         struct ieee80211_vif *vif)
 100 {
 101         might_sleep();
 102
 103         trace_drv_remove_interface(local, vif_to_sdata(vif));
 104         local->ops->remove_interface(&local->hw, vif);
 105         trace_drv_return_void(local);
 106 }
 107
 108 static inline int drv_config(struct ieee80211_local *local, u32 changed)
 109 {
 110         int ret;
 111
 112         might_sleep();
 113
 114         trace_drv_config(local, changed);
 115         ret = local->ops->config(&local->hw, changed);
 116         trace_drv_return_int(local, ret);
 117         return ret;
 118 }
 119
 120 static inline void drv_bss_info_changed(struct ieee80211_local *local,
 121                                         struct ieee80211_sub_if_data *sdata,
 122                                         struct ieee80211_bss_conf *info,
 123                                         u32 changed)
 124 {
 125         might_sleep();
 126
 127         trace_drv_bss_info_changed(local, sdata, info, changed);
 128         if (local->ops->bss_info_changed)
 129                 local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
 130         trace_drv_return_void(local);
 131 }
 132
 133 static inline int drv_tx_sync(struct ieee80211_local *local,
 134                               struct ieee80211_sub_if_data *sdata,
 135                               const u8 *bssid,
 136                               enum ieee80211_tx_sync_type type)
 137 {
 138         int ret = 0;
 139
 140         might_sleep();
 141
 142         trace_drv_tx_sync(local, sdata, bssid, type);
 143         if (local->ops->tx_sync)
 144                 ret = local->ops->tx_sync(&local->hw, &sdata->vif,
 145                                           bssid, type);
 146         trace_drv_return_int(local, ret);
 147         return ret;
 148 }
 149
 150 static inline void drv_finish_tx_sync(struct ieee80211_local *local,
 151                                       struct ieee80211_sub_if_data *sdata,
 152                                       const u8 *bssid,
 153                                       enum ieee80211_tx_sync_type type)
 154 {
 155         might_sleep();
 156
 157         trace_drv_finish_tx_sync(local, sdata, bssid, type);
 158         if (local->ops->finish_tx_sync)
 159                 local->ops->finish_tx_sync(&local->hw, &sdata->vif,
 160                                            bssid, type);
 161         trace_drv_return_void(local);
 162 }
 163
 164 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
 165                                         struct netdev_hw_addr_list *mc_list)
 166 {
 167         u64 ret = 0;
 168
 169         trace_drv_prepare_multicast(local, mc_list->count);
 170
 171         if (local->ops->prepare_multicast)
 172                 ret = local->ops->prepare_multicast(&local->hw, mc_list);
 173
 174         trace_drv_return_u64(local, ret);
 175
 176         return ret;
 177 }
 178
 179 static inline void drv_configure_filter(struct ieee80211_local *local,
 180                                         unsigned int changed_flags,
 181                                         unsigned int *total_flags,
 182                                         u64 multicast)
 183 {
 184         might_sleep();
 185
 186         trace_drv_configure_filter(local, changed_flags, total_flags,
 187                                    multicast);
 188         local->ops->configure_filter(&local->hw, changed_flags, total_flags,
 189                                      multicast);
 190         trace_drv_return_void(local);
 191 }
 192
 193 static inline int drv_set_tim(struct ieee80211_local *local,
 194                               struct ieee80211_sta *sta, bool set)
 195 {
 196         int ret = 0;
 197         trace_drv_set_tim(local, sta, set);
 198         if (local->ops->set_tim)
 199                 ret = local->ops->set_tim(&local->hw, sta, set);
 200         trace_drv_return_int(local, ret);
 201         return ret;
 202 }
 203
 204 static inline int drv_set_key(struct ieee80211_local *local,
 205                               enum set_key_cmd cmd,
 206                               struct ieee80211_sub_if_data *sdata,
 207                               struct ieee80211_sta *sta,
 208                               struct ieee80211_key_conf *key)
 209 {
 210         int ret;
 211
 212         might_sleep();
 213
 214         trace_drv_set_key(local, cmd, sdata, sta, key);
 215         ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
 216         trace_drv_return_int(local, ret);
 217         return ret;
 218 }
 219
 220 static inline void drv_update_tkip_key(struct ieee80211_local *local,
 221                                        struct ieee80211_sub_if_data *sdata,
 222                                        struct ieee80211_key_conf *conf,
 223                                        struct sta_info *sta, u32 iv32,
 224                                        u16 *phase1key)
 225 {
 226         struct ieee80211_sta *ista = NULL;
 227
 228         if (sta)
 229                 ista = &sta->sta;
 230
 231         trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
 232         if (local->ops->update_tkip_key)
 233                 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
 234                                             ista, iv32, phase1key);
 235         trace_drv_return_void(local);
 236 }
 237
 238 static inline int drv_hw_scan(struct ieee80211_local *local,
 239                               struct ieee80211_sub_if_data *sdata,
 240                               struct cfg80211_scan_request *req)
 241 {
 242         int ret;
 243
 244         might_sleep();
 245
 246         trace_drv_hw_scan(local, sdata);
 247         ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
 248         trace_drv_return_int(local, ret);
 249         return ret;
 250 }
 251
 252 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
 253                                       struct ieee80211_sub_if_data *sdata)
 254 {
 255         might_sleep();
 256
 257         trace_drv_cancel_hw_scan(local, sdata);
 258         local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
 259         trace_drv_return_void(local);
 260 }
 261
 262 static inline int
 263 drv_sched_scan_start(struct ieee80211_local *local,
 264                      struct ieee80211_sub_if_data *sdata,
 265                      struct cfg80211_sched_scan_request *req,
 266                      struct ieee80211_sched_scan_ies *ies)
 267 {
 268         int ret;
 269
 270         might_sleep();
 271
 272         trace_drv_sched_scan_start(local, sdata);
 273         ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
 274                                               req, ies);
 275         trace_drv_return_int(local, ret);
 276         return ret;
 277 }
 278
 279 static inline void drv_sched_scan_stop(struct ieee80211_local *local,
 280                                        struct ieee80211_sub_if_data *sdata)
 281 {
 282         might_sleep();
 283
 284         trace_drv_sched_scan_stop(local, sdata);
 285         local->ops->sched_scan_stop(&local->hw, &sdata->vif);
 286         trace_drv_return_void(local);
 287 }
 288
 289 static inline void drv_sw_scan_start(struct ieee80211_local *local)
 290 {
 291         might_sleep();
 292
 293         trace_drv_sw_scan_start(local);
 294         if (local->ops->sw_scan_start)
 295                 local->ops->sw_scan_start(&local->hw);
 296         trace_drv_return_void(local);
 297 }
 298
 299 static inline void drv_sw_scan_complete(struct ieee80211_local *local)
 300 {
 301         might_sleep();
 302
 303         trace_drv_sw_scan_complete(local);
 304         if (local->ops->sw_scan_complete)
 305                 local->ops->sw_scan_complete(&local->hw);
 306         trace_drv_return_void(local);
 307 }
 308
 309 static inline int drv_get_stats(struct ieee80211_local *local,
 310                                 struct ieee80211_low_level_stats *stats)
 311 {
 312         int ret = -EOPNOTSUPP;
 313
 314         might_sleep();
 315
 316         if (local->ops->get_stats)
 317                 ret = local->ops->get_stats(&local->hw, stats);
 318         trace_drv_get_stats(local, stats, ret);
 319
 320         return ret;
 321 }
 322
 323 static inline void drv_get_tkip_seq(struct ieee80211_local *local,
 324                                     u8 hw_key_idx, u32 *iv32, u16 *iv16)
 325 {
 326         if (local->ops->get_tkip_seq)
 327                 local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
 328         trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
 329 }
 330
 331 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
 332                                         u32 value)
 333 {
 334         int ret = 0;
 335
 336         might_sleep();
 337
 338         trace_drv_set_frag_threshold(local, value);
 339         if (local->ops->set_frag_threshold)
 340                 ret = local->ops->set_frag_threshold(&local->hw, value);
 341         trace_drv_return_int(local, ret);
 342         return ret;
 343 }
 344
 345 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
 346                                         u32 value)
 347 {
 348         int ret = 0;
 349
 350         might_sleep();
 351
 352         trace_drv_set_rts_threshold(local, value);
 353         if (local->ops->set_rts_threshold)
 354                 ret = local->ops->set_rts_threshold(&local->hw, value);
 355         trace_drv_return_int(local, ret);
 356         return ret;
 357 }
 358
 359 static inline int drv_set_coverage_class(struct ieee80211_local *local,
 360                                          u8 value)
 361 {
 362         int ret = 0;
 363         might_sleep();
 364
 365         trace_drv_set_coverage_class(local, value);
 366         if (local->ops->set_coverage_class)
 367                 local->ops->set_coverage_class(&local->hw, value);
 368         else
 369                 ret = -EOPNOTSUPP;
 370
 371         trace_drv_return_int(local, ret);
 372         return ret;
 373 }
 374
 375 static inline void drv_sta_notify(struct ieee80211_local *local,
 376                                   struct ieee80211_sub_if_data *sdata,
 377                                   enum sta_notify_cmd cmd,
 378                                   struct ieee80211_sta *sta)
 379 {
 380         trace_drv_sta_notify(local, sdata, cmd, sta);
 381         if (local->ops->sta_notify)
 382                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
 383         trace_drv_return_void(local);
 384 }
 385
 386 static inline int drv_sta_add(struct ieee80211_local *local,
 387                               struct ieee80211_sub_if_data *sdata,
 388                               struct ieee80211_sta *sta)
 389 {
 390         int ret = 0;
 391
 392         might_sleep();
 393
 394         trace_drv_sta_add(local, sdata, sta);
 395         if (local->ops->sta_add)
 396                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
 397
 398         trace_drv_return_int(local, ret);
 399
 400         return ret;
 401 }
 402
 403 static inline void drv_sta_remove(struct ieee80211_local *local,
 404                                   struct ieee80211_sub_if_data *sdata,
 405                                   struct ieee80211_sta *sta)
 406 {
 407         might_sleep();
 408
 409         trace_drv_sta_remove(local, sdata, sta);
 410         if (local->ops->sta_remove)
 411                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
 412
 413         trace_drv_return_void(local);
 414 }
 415
 416 static inline int drv_conf_tx(struct ieee80211_local *local,
 417                               struct ieee80211_sub_if_data *sdata, u16 queue,
 418                               const struct ieee80211_tx_queue_params *params)
 419 {
 420         int ret = -EOPNOTSUPP;
 421
 422         might_sleep();
 423
 424         trace_drv_conf_tx(local, sdata, queue, params);
 425         if (local->ops->conf_tx)
 426                 ret = local->ops->conf_tx(&local->hw, &sdata->vif,
 427                                           queue, params);
 428         trace_drv_return_int(local, ret);
 429         return ret;
 430 }
 431
 432 static inline u64 drv_get_tsf(struct ieee80211_local *local,
 433                               struct ieee80211_sub_if_data *sdata)
 434 {
 435         u64 ret = -1ULL;
 436
 437         might_sleep();
 438
 439         trace_drv_get_tsf(local, sdata);
 440         if (local->ops->get_tsf)
 441                 ret = local->ops->get_tsf(&local->hw, &sdata->vif);
 442         trace_drv_return_u64(local, ret);
 443         return ret;
 444 }
 445
 446 static inline void drv_set_tsf(struct ieee80211_local *local,
 447                                struct ieee80211_sub_if_data *sdata,
 448                                u64 tsf)
 449 {
 450         might_sleep();
 451
 452         trace_drv_set_tsf(local, sdata, tsf);
 453         if (local->ops->set_tsf)
 454                 local->ops->set_tsf(&local->hw, &sdata->vif, tsf);
 455         trace_drv_return_void(local);
 456 }
 457
 458 static inline void drv_reset_tsf(struct ieee80211_local *local,
 459                                  struct ieee80211_sub_if_data *sdata)
 460 {
 461         might_sleep();
 462
 463         trace_drv_reset_tsf(local, sdata);
 464         if (local->ops->reset_tsf)
 465                 local->ops->reset_tsf(&local->hw, &sdata->vif);
 466         trace_drv_return_void(local);
 467 }
 468
 469 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
 470 {
 471         int ret = 0; /* default unsuported op for less congestion */
 472
 473         might_sleep();
 474
 475         trace_drv_tx_last_beacon(local);
 476         if (local->ops->tx_last_beacon)
 477                 ret = local->ops->tx_last_beacon(&local->hw);
 478         trace_drv_return_int(local, ret);
 479         return ret;
 480 }
 481
 482 static inline int drv_ampdu_action(struct ieee80211_local *local,
 483                                    struct ieee80211_sub_if_data *sdata,
 484                                    enum ieee80211_ampdu_mlme_action action,
 485                                    struct ieee80211_sta *sta, u16 tid,
 486                                    u16 *ssn, u8 buf_size)
 487 {
 488         int ret = -EOPNOTSUPP;
 489
 490         might_sleep();
 491
 492         trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size);
 493
 494         if (local->ops->ampdu_action)
 495                 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
 496                                                sta, tid, ssn, buf_size);
 497
 498         trace_drv_return_int(local, ret);
 499
 500         return ret;
 501 }
 502
 503 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
 504                                 struct survey_info *survey)
 505 {
 506         int ret = -EOPNOTSUPP;
 507
 508         trace_drv_get_survey(local, idx, survey);
 509
 510         if (local->ops->get_survey)
 511                 ret = local->ops->get_survey(&local->hw, idx, survey);
 512
 513         trace_drv_return_int(local, ret);
 514
 515         return ret;
 516 }
 517
 518 static inline void drv_rfkill_poll(struct ieee80211_local *local)
 519 {
 520         might_sleep();
 521
 522         if (local->ops->rfkill_poll)
 523                 local->ops->rfkill_poll(&local->hw);
 524 }
 525
 526 static inline void drv_flush(struct ieee80211_local *local, bool drop)
 527 {
 528         might_sleep();
 529
 530         trace_drv_flush(local, drop);
 531         if (local->ops->flush)
 532                 local->ops->flush(&local->hw, drop);
 533         trace_drv_return_void(local);
 534 }
 535
 536 static inline void drv_channel_switch(struct ieee80211_local *local,
 537                                      struct ieee80211_channel_switch *ch_switch)
 538 {
 539         might_sleep();
 540
 541         trace_drv_channel_switch(local, ch_switch);
 542         local->ops->channel_switch(&local->hw, ch_switch);
 543         trace_drv_return_void(local);
 544 }
 545
 546
 547 static inline int drv_set_antenna(struct ieee80211_local *local,
 548                                   u32 tx_ant, u32 rx_ant)
 549 {
 550         int ret = -EOPNOTSUPP;
 551         might_sleep();
 552         if (local->ops->set_antenna)
 553                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
 554         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
 555         return ret;
 556 }
 557
 558 static inline int drv_get_antenna(struct ieee80211_local *local,
 559                                   u32 *tx_ant, u32 *rx_ant)
 560 {
 561         int ret = -EOPNOTSUPP;
 562         might_sleep();
 563         if (local->ops->get_antenna)
 564                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
 565         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
 566         return ret;
 567 }
 568
 569 static inline int drv_remain_on_channel(struct ieee80211_local *local,
 570                                         struct ieee80211_channel *chan,
 571                                         enum nl80211_channel_type chantype,
 572                                         unsigned int duration)
 573 {
 574         int ret;
 575
 576         might_sleep();
 577
 578         trace_drv_remain_on_channel(local, chan, chantype, duration);
 579         ret = local->ops->remain_on_channel(&local->hw, chan, chantype,
 580                                             duration);
 581         trace_drv_return_int(local, ret);
 582
 583         return ret;
 584 }
 585
 586 static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
 587 {
 588         int ret;
 589
 590         might_sleep();
 591
 592         trace_drv_cancel_remain_on_channel(local);
 593         ret = local->ops->cancel_remain_on_channel(&local->hw);
 594         trace_drv_return_int(local, ret);
 595
 596         return ret;
 597 }
 598
 599 static inline int drv_set_ringparam(struct ieee80211_local *local,
 600                                     u32 tx, u32 rx)
 601 {
 602         int ret = -ENOTSUPP;
 603
 604         might_sleep();
 605
 606         trace_drv_set_ringparam(local, tx, rx);
 607         if (local->ops->set_ringparam)
 608                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 609         trace_drv_return_int(local, ret);
 610
 611         return ret;
 612 }
 613
 614 static inline void drv_get_ringparam(struct ieee80211_local *local,
 615                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 616 {
 617         might_sleep();
 618
 619         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 620         if (local->ops->get_ringparam)
 621                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 622         trace_drv_return_void(local);
 623 }
 624
 625 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
 626 {
 627         bool ret = false;
 628
 629         might_sleep();
 630
 631         trace_drv_tx_frames_pending(local);
 632         if (local->ops->tx_frames_pending)
 633                 ret = local->ops->tx_frames_pending(&local->hw);
 634         trace_drv_return_bool(local, ret);
 635
 636         return ret;
 637 }
 638
 639 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
 640                                        struct ieee80211_sub_if_data *sdata,
 641                                        const struct cfg80211_bitrate_mask *mask)
 642 {
 643         int ret = -EOPNOTSUPP;
 644
 645         might_sleep();
 646
 647         trace_drv_set_bitrate_mask(local, sdata, mask);
 648         if (local->ops->set_bitrate_mask)
 649                 ret = local->ops->set_bitrate_mask(&local->hw,
 650                                                    &sdata->vif, mask);
 651         trace_drv_return_int(local, ret);
 652
 653         return ret;
 654 }
 655
 656 static inline void drv_set_rekey_data(struct ieee80211_local *local,
 657                                       struct ieee80211_sub_if_data *sdata,
 658                                       struct cfg80211_gtk_rekey_data *data)
 659 {
 660         trace_drv_set_rekey_data(local, sdata, data);
 661         if (local->ops->set_rekey_data)
 662                 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
 663         trace_drv_return_void(local);
 664 }
 665
 666 static inline void drv_rssi_callback(struct ieee80211_local *local,
 667                                      const enum ieee80211_rssi_event event)
 668 {
 669         trace_drv_rssi_callback(local, event);
 670         if (local->ops->rssi_callback)
 671                 local->ops->rssi_callback(&local->hw, event);
 672         trace_drv_return_void(local);
 673 }
 674
 675 static inline void
 676 drv_release_buffered_frames(struct ieee80211_local *local,
 677                             struct sta_info *sta, u16 tids, int num_frames,
 678                             enum ieee80211_frame_release_type reason,
 679                             bool more_data)
 680 {
 681         trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
 682                                           reason, more_data);
 683         if (local->ops->release_buffered_frames)
 684                 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
 685                                                     num_frames, reason,
 686                                                     more_data);
 687         trace_drv_return_void(local);
 688 }
 689
 690 static inline void
 691 drv_allow_buffered_frames(struct ieee80211_local *local,
 692                           struct sta_info *sta, u16 tids, int num_frames,
 693                           enum ieee80211_frame_release_type reason,
 694                           bool more_data)
 695 {
 696         trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
 697                                         reason, more_data);
 698         if (local->ops->allow_buffered_frames)
 699                 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
 700                                                   tids, num_frames, reason,
 701                                                   more_data);
 702         trace_drv_return_void(local);
 703 }
 704 #endif /* __MAC80211_DRIVER_OPS */