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