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