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