net/mac80211/driver-ops.h

   1 /*
   2 * Portions of this file
   3 * Copyright(c) 2016 Intel Deutschland GmbH
   4 */
   5
   6 #ifndef __MAC80211_DRIVER_OPS
   7 #define __MAC80211_DRIVER_OPS
   8
   9 #include <net/mac80211.h>
  10 #include "ieee80211_i.h"
  11 #include "trace.h"
  12
  13 static inline bool check_sdata_in_driver(struct ieee80211_sub_if_data *sdata)
  14 {
  15         return !WARN(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER),
  16                      "%s:  Failed check-sdata-in-driver check, flags: 0x%x\n",
  17                      sdata->dev ? sdata->dev->name : sdata->name, sdata->flags);
  18 }
  19
  20 static inline struct ieee80211_sub_if_data *
  21 get_bss_sdata(struct ieee80211_sub_if_data *sdata)
  22 {
  23         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
  24                 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
  25                                      u.ap);
  26
  27         return sdata;
  28 }
  29
  30 static inline void drv_tx(struct ieee80211_local *local,
  31                           struct ieee80211_tx_control *control,
  32                           struct sk_buff *skb)
  33 {
  34         local->ops->tx(&local->hw, control, skb);
  35 }
  36
  37 static inline void drv_sync_rx_queues(struct ieee80211_local *local,
  38                                       struct sta_info *sta)
  39 {
  40         if (local->ops->sync_rx_queues) {
  41                 trace_drv_sync_rx_queues(local, sta->sdata, &sta->sta);
  42                 local->ops->sync_rx_queues(&local->hw);
  43                 trace_drv_return_void(local);
  44         }
  45 }
  46
  47 static inline void drv_get_et_strings(struct ieee80211_sub_if_data *sdata,
  48                                       u32 sset, u8 *data)
  49 {
  50         struct ieee80211_local *local = sdata->local;
  51         if (local->ops->get_et_strings) {
  52                 trace_drv_get_et_strings(local, sset);
  53                 local->ops->get_et_strings(&local->hw, &sdata->vif, sset, data);
  54                 trace_drv_return_void(local);
  55         }
  56 }
  57
  58 static inline void drv_get_et_stats(struct ieee80211_sub_if_data *sdata,
  59                                     struct ethtool_stats *stats,
  60                                     u64 *data)
  61 {
  62         struct ieee80211_local *local = sdata->local;
  63         if (local->ops->get_et_stats) {
  64                 trace_drv_get_et_stats(local);
  65                 local->ops->get_et_stats(&local->hw, &sdata->vif, stats, data);
  66                 trace_drv_return_void(local);
  67         }
  68 }
  69
  70 static inline int drv_get_et_sset_count(struct ieee80211_sub_if_data *sdata,
  71                                         int sset)
  72 {
  73         struct ieee80211_local *local = sdata->local;
  74         int rv = 0;
  75         if (local->ops->get_et_sset_count) {
  76                 trace_drv_get_et_sset_count(local, sset);
  77                 rv = local->ops->get_et_sset_count(&local->hw, &sdata->vif,
  78                                                    sset);
  79                 trace_drv_return_int(local, rv);
  80         }
  81         return rv;
  82 }
  83
  84 int drv_start(struct ieee80211_local *local);
  85 void drv_stop(struct ieee80211_local *local);
  86
  87 #ifdef CONFIG_PM
  88 static inline int drv_suspend(struct ieee80211_local *local,
  89                               struct cfg80211_wowlan *wowlan)
  90 {
  91         int ret;
  92
  93         might_sleep();
  94
  95         trace_drv_suspend(local);
  96         ret = local->ops->suspend(&local->hw, wowlan);
  97         trace_drv_return_int(local, ret);
  98         return ret;
  99 }
 100
 101 static inline int drv_resume(struct ieee80211_local *local)
 102 {
 103         int ret;
 104
 105         might_sleep();
 106
 107         trace_drv_resume(local);
 108         ret = local->ops->resume(&local->hw);
 109         trace_drv_return_int(local, ret);
 110         return ret;
 111 }
 112
 113 static inline void drv_set_wakeup(struct ieee80211_local *local,
 114                                   bool enabled)
 115 {
 116         might_sleep();
 117
 118         if (!local->ops->set_wakeup)
 119                 return;
 120
 121         trace_drv_set_wakeup(local, enabled);
 122         local->ops->set_wakeup(&local->hw, enabled);
 123         trace_drv_return_void(local);
 124 }
 125 #endif
 126
 127 int drv_add_interface(struct ieee80211_local *local,
 128                       struct ieee80211_sub_if_data *sdata);
 129
 130 int drv_change_interface(struct ieee80211_local *local,
 131                          struct ieee80211_sub_if_data *sdata,
 132                          enum nl80211_iftype type, bool p2p);
 133
 134 void drv_remove_interface(struct ieee80211_local *local,
 135                           struct ieee80211_sub_if_data *sdata);
 136
 137 static inline int drv_config(struct ieee80211_local *local, u32 changed)
 138 {
 139         int ret;
 140
 141         might_sleep();
 142
 143         trace_drv_config(local, changed);
 144         ret = local->ops->config(&local->hw, changed);
 145         trace_drv_return_int(local, ret);
 146         return ret;
 147 }
 148
 149 static inline void drv_bss_info_changed(struct ieee80211_local *local,
 150                                         struct ieee80211_sub_if_data *sdata,
 151                                         struct ieee80211_bss_conf *info,
 152                                         u32 changed)
 153 {
 154         might_sleep();
 155
 156         if (WARN_ON_ONCE(changed & (BSS_CHANGED_BEACON |
 157                                     BSS_CHANGED_BEACON_ENABLED) &&
 158                          sdata->vif.type != NL80211_IFTYPE_AP &&
 159                          sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 160                          sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
 161                          sdata->vif.type != NL80211_IFTYPE_OCB))
 162                 return;
 163
 164         if (WARN_ON_ONCE(sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE ||
 165                          sdata->vif.type == NL80211_IFTYPE_NAN ||
 166                          (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
 167                           !sdata->vif.mu_mimo_owner &&
 168                           !(changed & BSS_CHANGED_TXPOWER))))
 169                 return;
 170
 171         if (!check_sdata_in_driver(sdata))
 172                 return;
 173
 174         trace_drv_bss_info_changed(local, sdata, info, changed);
 175         if (local->ops->bss_info_changed)
 176                 local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
 177         trace_drv_return_void(local);
 178 }
 179
 180 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
 181                                         struct netdev_hw_addr_list *mc_list)
 182 {
 183         u64 ret = 0;
 184
 185         trace_drv_prepare_multicast(local, mc_list->count);
 186
 187         if (local->ops->prepare_multicast)
 188                 ret = local->ops->prepare_multicast(&local->hw, mc_list);
 189
 190         trace_drv_return_u64(local, ret);
 191
 192         return ret;
 193 }
 194
 195 static inline void drv_configure_filter(struct ieee80211_local *local,
 196                                         unsigned int changed_flags,
 197                                         unsigned int *total_flags,
 198                                         u64 multicast)
 199 {
 200         might_sleep();
 201
 202         trace_drv_configure_filter(local, changed_flags, total_flags,
 203                                    multicast);
 204         local->ops->configure_filter(&local->hw, changed_flags, total_flags,
 205                                      multicast);
 206         trace_drv_return_void(local);
 207 }
 208
 209 static inline void drv_config_iface_filter(struct ieee80211_local *local,
 210                                            struct ieee80211_sub_if_data *sdata,
 211                                            unsigned int filter_flags,
 212                                            unsigned int changed_flags)
 213 {
 214         might_sleep();
 215
 216         trace_drv_config_iface_filter(local, sdata, filter_flags,
 217                                       changed_flags);
 218         if (local->ops->config_iface_filter)
 219                 local->ops->config_iface_filter(&local->hw, &sdata->vif,
 220                                                 filter_flags,
 221                                                 changed_flags);
 222         trace_drv_return_void(local);
 223 }
 224
 225 static inline int drv_set_tim(struct ieee80211_local *local,
 226                               struct ieee80211_sta *sta, bool set)
 227 {
 228         int ret = 0;
 229         trace_drv_set_tim(local, sta, set);
 230         if (local->ops->set_tim)
 231                 ret = local->ops->set_tim(&local->hw, sta, set);
 232         trace_drv_return_int(local, ret);
 233         return ret;
 234 }
 235
 236 static inline int drv_set_key(struct ieee80211_local *local,
 237                               enum set_key_cmd cmd,
 238                               struct ieee80211_sub_if_data *sdata,
 239                               struct ieee80211_sta *sta,
 240                               struct ieee80211_key_conf *key)
 241 {
 242         int ret;
 243
 244         might_sleep();
 245
 246         sdata = get_bss_sdata(sdata);
 247         if (!check_sdata_in_driver(sdata))
 248                 return -EIO;
 249
 250         trace_drv_set_key(local, cmd, sdata, sta, key);
 251         ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
 252         trace_drv_return_int(local, ret);
 253         return ret;
 254 }
 255
 256 static inline void drv_update_tkip_key(struct ieee80211_local *local,
 257                                        struct ieee80211_sub_if_data *sdata,
 258                                        struct ieee80211_key_conf *conf,
 259                                        struct sta_info *sta, u32 iv32,
 260                                        u16 *phase1key)
 261 {
 262         struct ieee80211_sta *ista = NULL;
 263
 264         if (sta)
 265                 ista = &sta->sta;
 266
 267         sdata = get_bss_sdata(sdata);
 268         if (!check_sdata_in_driver(sdata))
 269                 return;
 270
 271         trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
 272         if (local->ops->update_tkip_key)
 273                 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
 274                                             ista, iv32, phase1key);
 275         trace_drv_return_void(local);
 276 }
 277
 278 static inline int drv_hw_scan(struct ieee80211_local *local,
 279                               struct ieee80211_sub_if_data *sdata,
 280                               struct ieee80211_scan_request *req)
 281 {
 282         int ret;
 283
 284         might_sleep();
 285
 286         if (!check_sdata_in_driver(sdata))
 287                 return -EIO;
 288
 289         trace_drv_hw_scan(local, sdata);
 290         ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
 291         trace_drv_return_int(local, ret);
 292         return ret;
 293 }
 294
 295 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
 296                                       struct ieee80211_sub_if_data *sdata)
 297 {
 298         might_sleep();
 299
 300         if (!check_sdata_in_driver(sdata))
 301                 return;
 302
 303         trace_drv_cancel_hw_scan(local, sdata);
 304         local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
 305         trace_drv_return_void(local);
 306 }
 307
 308 static inline int
 309 drv_sched_scan_start(struct ieee80211_local *local,
 310                      struct ieee80211_sub_if_data *sdata,
 311                      struct cfg80211_sched_scan_request *req,
 312                      struct ieee80211_scan_ies *ies)
 313 {
 314         int ret;
 315
 316         might_sleep();
 317
 318         if (!check_sdata_in_driver(sdata))
 319                 return -EIO;
 320
 321         trace_drv_sched_scan_start(local, sdata);
 322         ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
 323                                               req, ies);
 324         trace_drv_return_int(local, ret);
 325         return ret;
 326 }
 327
 328 static inline int drv_sched_scan_stop(struct ieee80211_local *local,
 329                                       struct ieee80211_sub_if_data *sdata)
 330 {
 331         int ret;
 332
 333         might_sleep();
 334
 335         if (!check_sdata_in_driver(sdata))
 336                 return -EIO;
 337
 338         trace_drv_sched_scan_stop(local, sdata);
 339         ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
 340         trace_drv_return_int(local, ret);
 341
 342         return ret;
 343 }
 344
 345 static inline void drv_sw_scan_start(struct ieee80211_local *local,
 346                                      struct ieee80211_sub_if_data *sdata,
 347                                      const u8 *mac_addr)
 348 {
 349         might_sleep();
 350
 351         trace_drv_sw_scan_start(local, sdata, mac_addr);
 352         if (local->ops->sw_scan_start)
 353                 local->ops->sw_scan_start(&local->hw, &sdata->vif, mac_addr);
 354         trace_drv_return_void(local);
 355 }
 356
 357 static inline void drv_sw_scan_complete(struct ieee80211_local *local,
 358                                         struct ieee80211_sub_if_data *sdata)
 359 {
 360         might_sleep();
 361
 362         trace_drv_sw_scan_complete(local, sdata);
 363         if (local->ops->sw_scan_complete)
 364                 local->ops->sw_scan_complete(&local->hw, &sdata->vif);
 365         trace_drv_return_void(local);
 366 }
 367
 368 static inline int drv_get_stats(struct ieee80211_local *local,
 369                                 struct ieee80211_low_level_stats *stats)
 370 {
 371         int ret = -EOPNOTSUPP;
 372
 373         might_sleep();
 374
 375         if (local->ops->get_stats)
 376                 ret = local->ops->get_stats(&local->hw, stats);
 377         trace_drv_get_stats(local, stats, ret);
 378
 379         return ret;
 380 }
 381
 382 static inline void drv_get_key_seq(struct ieee80211_local *local,
 383                                    struct ieee80211_key *key,
 384                                    struct ieee80211_key_seq *seq)
 385 {
 386         if (local->ops->get_key_seq)
 387                 local->ops->get_key_seq(&local->hw, &key->conf, seq);
 388         trace_drv_get_key_seq(local, &key->conf);
 389 }
 390
 391 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
 392                                         u32 value)
 393 {
 394         int ret = 0;
 395
 396         might_sleep();
 397
 398         trace_drv_set_frag_threshold(local, value);
 399         if (local->ops->set_frag_threshold)
 400                 ret = local->ops->set_frag_threshold(&local->hw, value);
 401         trace_drv_return_int(local, ret);
 402         return ret;
 403 }
 404
 405 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
 406                                         u32 value)
 407 {
 408         int ret = 0;
 409
 410         might_sleep();
 411
 412         trace_drv_set_rts_threshold(local, value);
 413         if (local->ops->set_rts_threshold)
 414                 ret = local->ops->set_rts_threshold(&local->hw, value);
 415         trace_drv_return_int(local, ret);
 416         return ret;
 417 }
 418
 419 static inline int drv_set_coverage_class(struct ieee80211_local *local,
 420                                          s16 value)
 421 {
 422         int ret = 0;
 423         might_sleep();
 424
 425         trace_drv_set_coverage_class(local, value);
 426         if (local->ops->set_coverage_class)
 427                 local->ops->set_coverage_class(&local->hw, value);
 428         else
 429                 ret = -EOPNOTSUPP;
 430
 431         trace_drv_return_int(local, ret);
 432         return ret;
 433 }
 434
 435 static inline void drv_sta_notify(struct ieee80211_local *local,
 436                                   struct ieee80211_sub_if_data *sdata,
 437                                   enum sta_notify_cmd cmd,
 438                                   struct ieee80211_sta *sta)
 439 {
 440         sdata = get_bss_sdata(sdata);
 441         if (!check_sdata_in_driver(sdata))
 442                 return;
 443
 444         trace_drv_sta_notify(local, sdata, cmd, sta);
 445         if (local->ops->sta_notify)
 446                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
 447         trace_drv_return_void(local);
 448 }
 449
 450 static inline int drv_sta_add(struct ieee80211_local *local,
 451                               struct ieee80211_sub_if_data *sdata,
 452                               struct ieee80211_sta *sta)
 453 {
 454         int ret = 0;
 455
 456         might_sleep();
 457
 458         sdata = get_bss_sdata(sdata);
 459         if (!check_sdata_in_driver(sdata))
 460                 return -EIO;
 461
 462         trace_drv_sta_add(local, sdata, sta);
 463         if (local->ops->sta_add)
 464                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
 465
 466         trace_drv_return_int(local, ret);
 467
 468         return ret;
 469 }
 470
 471 static inline void drv_sta_remove(struct ieee80211_local *local,
 472                                   struct ieee80211_sub_if_data *sdata,
 473                                   struct ieee80211_sta *sta)
 474 {
 475         might_sleep();
 476
 477         sdata = get_bss_sdata(sdata);
 478         if (!check_sdata_in_driver(sdata))
 479                 return;
 480
 481         trace_drv_sta_remove(local, sdata, sta);
 482         if (local->ops->sta_remove)
 483                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
 484
 485         trace_drv_return_void(local);
 486 }
 487
 488 #ifdef CONFIG_MAC80211_DEBUGFS
 489 static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
 490                                        struct ieee80211_sub_if_data *sdata,
 491                                        struct ieee80211_sta *sta,
 492                                        struct dentry *dir)
 493 {
 494         might_sleep();
 495
 496         sdata = get_bss_sdata(sdata);
 497         if (!check_sdata_in_driver(sdata))
 498                 return;
 499
 500         if (local->ops->sta_add_debugfs)
 501                 local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
 502                                             sta, dir);
 503 }
 504 #endif
 505
 506 static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
 507                                           struct ieee80211_sub_if_data *sdata,
 508                                           struct sta_info *sta)
 509 {
 510         might_sleep();
 511
 512         sdata = get_bss_sdata(sdata);
 513         if (!check_sdata_in_driver(sdata))
 514                 return;
 515
 516         trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
 517         if (local->ops->sta_pre_rcu_remove)
 518                 local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
 519                                                &sta->sta);
 520         trace_drv_return_void(local);
 521 }
 522
 523 __must_check
 524 int drv_sta_state(struct ieee80211_local *local,
 525                   struct ieee80211_sub_if_data *sdata,
 526                   struct sta_info *sta,
 527                   enum ieee80211_sta_state old_state,
 528                   enum ieee80211_sta_state new_state);
 529
 530 void drv_sta_rc_update(struct ieee80211_local *local,
 531                        struct ieee80211_sub_if_data *sdata,
 532                        struct ieee80211_sta *sta, u32 changed);
 533
 534 static inline void drv_sta_rate_tbl_update(struct ieee80211_local *local,
 535                                            struct ieee80211_sub_if_data *sdata,
 536                                            struct ieee80211_sta *sta)
 537 {
 538         sdata = get_bss_sdata(sdata);
 539         if (!check_sdata_in_driver(sdata))
 540                 return;
 541
 542         trace_drv_sta_rate_tbl_update(local, sdata, sta);
 543         if (local->ops->sta_rate_tbl_update)
 544                 local->ops->sta_rate_tbl_update(&local->hw, &sdata->vif, sta);
 545
 546         trace_drv_return_void(local);
 547 }
 548
 549 static inline void drv_sta_statistics(struct ieee80211_local *local,
 550                                       struct ieee80211_sub_if_data *sdata,
 551                                       struct ieee80211_sta *sta,
 552                                       struct station_info *sinfo)
 553 {
 554         sdata = get_bss_sdata(sdata);
 555         if (!check_sdata_in_driver(sdata))
 556                 return;
 557
 558         trace_drv_sta_statistics(local, sdata, sta);
 559         if (local->ops->sta_statistics)
 560                 local->ops->sta_statistics(&local->hw, &sdata->vif, sta, sinfo);
 561         trace_drv_return_void(local);
 562 }
 563
 564 int drv_conf_tx(struct ieee80211_local *local,
 565                 struct ieee80211_sub_if_data *sdata, u16 ac,
 566                 const struct ieee80211_tx_queue_params *params);
 567
 568 u64 drv_get_tsf(struct ieee80211_local *local,
 569                 struct ieee80211_sub_if_data *sdata);
 570 void drv_set_tsf(struct ieee80211_local *local,
 571                  struct ieee80211_sub_if_data *sdata,
 572                  u64 tsf);
 573 void drv_offset_tsf(struct ieee80211_local *local,
 574                     struct ieee80211_sub_if_data *sdata,
 575                     s64 offset);
 576 void drv_reset_tsf(struct ieee80211_local *local,
 577                    struct ieee80211_sub_if_data *sdata);
 578
 579 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
 580 {
 581         int ret = 0; /* default unsupported op for less congestion */
 582
 583         might_sleep();
 584
 585         trace_drv_tx_last_beacon(local);
 586         if (local->ops->tx_last_beacon)
 587                 ret = local->ops->tx_last_beacon(&local->hw);
 588         trace_drv_return_int(local, ret);
 589         return ret;
 590 }
 591
 592 int drv_ampdu_action(struct ieee80211_local *local,
 593                      struct ieee80211_sub_if_data *sdata,
 594                      struct ieee80211_ampdu_params *params);
 595
 596 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
 597                                 struct survey_info *survey)
 598 {
 599         int ret = -EOPNOTSUPP;
 600
 601         trace_drv_get_survey(local, idx, survey);
 602
 603         if (local->ops->get_survey)
 604                 ret = local->ops->get_survey(&local->hw, idx, survey);
 605
 606         trace_drv_return_int(local, ret);
 607
 608         return ret;
 609 }
 610
 611 static inline void drv_rfkill_poll(struct ieee80211_local *local)
 612 {
 613         might_sleep();
 614
 615         if (local->ops->rfkill_poll)
 616                 local->ops->rfkill_poll(&local->hw);
 617 }
 618
 619 static inline void drv_flush(struct ieee80211_local *local,
 620                              struct ieee80211_sub_if_data *sdata,
 621                              u32 queues, bool drop)
 622 {
 623         struct ieee80211_vif *vif = sdata ? &sdata->vif : NULL;
 624
 625         might_sleep();
 626
 627         if (sdata && !check_sdata_in_driver(sdata))
 628                 return;
 629
 630         trace_drv_flush(local, queues, drop);
 631         if (local->ops->flush)
 632                 local->ops->flush(&local->hw, vif, queues, drop);
 633         trace_drv_return_void(local);
 634 }
 635
 636 static inline void drv_channel_switch(struct ieee80211_local *local,
 637                                       struct ieee80211_sub_if_data *sdata,
 638                                       struct ieee80211_channel_switch *ch_switch)
 639 {
 640         might_sleep();
 641
 642         trace_drv_channel_switch(local, sdata, ch_switch);
 643         local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch);
 644         trace_drv_return_void(local);
 645 }
 646
 647
 648 static inline int drv_set_antenna(struct ieee80211_local *local,
 649                                   u32 tx_ant, u32 rx_ant)
 650 {
 651         int ret = -EOPNOTSUPP;
 652         might_sleep();
 653         if (local->ops->set_antenna)
 654                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
 655         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
 656         return ret;
 657 }
 658
 659 static inline int drv_get_antenna(struct ieee80211_local *local,
 660                                   u32 *tx_ant, u32 *rx_ant)
 661 {
 662         int ret = -EOPNOTSUPP;
 663         might_sleep();
 664         if (local->ops->get_antenna)
 665                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
 666         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
 667         return ret;
 668 }
 669
 670 static inline int drv_remain_on_channel(struct ieee80211_local *local,
 671                                         struct ieee80211_sub_if_data *sdata,
 672                                         struct ieee80211_channel *chan,
 673                                         unsigned int duration,
 674                                         enum ieee80211_roc_type type)
 675 {
 676         int ret;
 677
 678         might_sleep();
 679
 680         trace_drv_remain_on_channel(local, sdata, chan, duration, type);
 681         ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
 682                                             chan, duration, type);
 683         trace_drv_return_int(local, ret);
 684
 685         return ret;
 686 }
 687
 688 static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
 689 {
 690         int ret;
 691
 692         might_sleep();
 693
 694         trace_drv_cancel_remain_on_channel(local);
 695         ret = local->ops->cancel_remain_on_channel(&local->hw);
 696         trace_drv_return_int(local, ret);
 697
 698         return ret;
 699 }
 700
 701 static inline int drv_set_ringparam(struct ieee80211_local *local,
 702                                     u32 tx, u32 rx)
 703 {
 704         int ret = -ENOTSUPP;
 705
 706         might_sleep();
 707
 708         trace_drv_set_ringparam(local, tx, rx);
 709         if (local->ops->set_ringparam)
 710                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 711         trace_drv_return_int(local, ret);
 712
 713         return ret;
 714 }
 715
 716 static inline void drv_get_ringparam(struct ieee80211_local *local,
 717                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 718 {
 719         might_sleep();
 720
 721         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 722         if (local->ops->get_ringparam)
 723                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 724         trace_drv_return_void(local);
 725 }
 726
 727 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
 728 {
 729         bool ret = false;
 730
 731         might_sleep();
 732
 733         trace_drv_tx_frames_pending(local);
 734         if (local->ops->tx_frames_pending)
 735                 ret = local->ops->tx_frames_pending(&local->hw);
 736         trace_drv_return_bool(local, ret);
 737
 738         return ret;
 739 }
 740
 741 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
 742                                        struct ieee80211_sub_if_data *sdata,
 743                                        const struct cfg80211_bitrate_mask *mask)
 744 {
 745         int ret = -EOPNOTSUPP;
 746
 747         might_sleep();
 748
 749         if (!check_sdata_in_driver(sdata))
 750                 return -EIO;
 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         if (!check_sdata_in_driver(sdata))
 766                 return;
 767
 768         trace_drv_set_rekey_data(local, sdata, data);
 769         if (local->ops->set_rekey_data)
 770                 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
 771         trace_drv_return_void(local);
 772 }
 773
 774 static inline void drv_event_callback(struct ieee80211_local *local,
 775                                       struct ieee80211_sub_if_data *sdata,
 776                                       const struct ieee80211_event *event)
 777 {
 778         trace_drv_event_callback(local, sdata, event);
 779         if (local->ops->event_callback)
 780                 local->ops->event_callback(&local->hw, &sdata->vif, event);
 781         trace_drv_return_void(local);
 782 }
 783
 784 static inline void
 785 drv_release_buffered_frames(struct ieee80211_local *local,
 786                             struct sta_info *sta, u16 tids, int num_frames,
 787                             enum ieee80211_frame_release_type reason,
 788                             bool more_data)
 789 {
 790         trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
 791                                           reason, more_data);
 792         if (local->ops->release_buffered_frames)
 793                 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
 794                                                     num_frames, reason,
 795                                                     more_data);
 796         trace_drv_return_void(local);
 797 }
 798
 799 static inline void
 800 drv_allow_buffered_frames(struct ieee80211_local *local,
 801                           struct sta_info *sta, u16 tids, int num_frames,
 802                           enum ieee80211_frame_release_type reason,
 803                           bool more_data)
 804 {
 805         trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
 806                                         reason, more_data);
 807         if (local->ops->allow_buffered_frames)
 808                 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
 809                                                   tids, num_frames, reason,
 810                                                   more_data);
 811         trace_drv_return_void(local);
 812 }
 813
 814 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
 815                                       struct ieee80211_sub_if_data *sdata)
 816 {
 817         might_sleep();
 818
 819         if (!check_sdata_in_driver(sdata))
 820                 return;
 821         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 822
 823         trace_drv_mgd_prepare_tx(local, sdata);
 824         if (local->ops->mgd_prepare_tx)
 825                 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif);
 826         trace_drv_return_void(local);
 827 }
 828
 829 static inline void
 830 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
 831                               struct ieee80211_sub_if_data *sdata)
 832 {
 833         might_sleep();
 834
 835         if (!check_sdata_in_driver(sdata))
 836                 return;
 837         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 838
 839         trace_drv_mgd_protect_tdls_discover(local, sdata);
 840         if (local->ops->mgd_protect_tdls_discover)
 841                 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif);
 842         trace_drv_return_void(local);
 843 }
 844
 845 static inline int drv_add_chanctx(struct ieee80211_local *local,
 846                                   struct ieee80211_chanctx *ctx)
 847 {
 848         int ret = -EOPNOTSUPP;
 849
 850         might_sleep();
 851
 852         trace_drv_add_chanctx(local, ctx);
 853         if (local->ops->add_chanctx)
 854                 ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
 855         trace_drv_return_int(local, ret);
 856         if (!ret)
 857                 ctx->driver_present = true;
 858
 859         return ret;
 860 }
 861
 862 static inline void drv_remove_chanctx(struct ieee80211_local *local,
 863                                       struct ieee80211_chanctx *ctx)
 864 {
 865         might_sleep();
 866
 867         if (WARN_ON(!ctx->driver_present))
 868                 return;
 869
 870         trace_drv_remove_chanctx(local, ctx);
 871         if (local->ops->remove_chanctx)
 872                 local->ops->remove_chanctx(&local->hw, &ctx->conf);
 873         trace_drv_return_void(local);
 874         ctx->driver_present = false;
 875 }
 876
 877 static inline void drv_change_chanctx(struct ieee80211_local *local,
 878                                       struct ieee80211_chanctx *ctx,
 879                                       u32 changed)
 880 {
 881         might_sleep();
 882
 883         trace_drv_change_chanctx(local, ctx, changed);
 884         if (local->ops->change_chanctx) {
 885                 WARN_ON_ONCE(!ctx->driver_present);
 886                 local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
 887         }
 888         trace_drv_return_void(local);
 889 }
 890
 891 static inline int drv_assign_vif_chanctx(struct ieee80211_local *local,
 892                                          struct ieee80211_sub_if_data *sdata,
 893                                          struct ieee80211_chanctx *ctx)
 894 {
 895         int ret = 0;
 896
 897         if (!check_sdata_in_driver(sdata))
 898                 return -EIO;
 899
 900         trace_drv_assign_vif_chanctx(local, sdata, ctx);
 901         if (local->ops->assign_vif_chanctx) {
 902                 WARN_ON_ONCE(!ctx->driver_present);
 903                 ret = local->ops->assign_vif_chanctx(&local->hw,
 904                                                      &sdata->vif,
 905                                                      &ctx->conf);
 906         }
 907         trace_drv_return_int(local, ret);
 908
 909         return ret;
 910 }
 911
 912 static inline void drv_unassign_vif_chanctx(struct ieee80211_local *local,
 913                                             struct ieee80211_sub_if_data *sdata,
 914                                             struct ieee80211_chanctx *ctx)
 915 {
 916         might_sleep();
 917
 918         if (!check_sdata_in_driver(sdata))
 919                 return;
 920
 921         trace_drv_unassign_vif_chanctx(local, sdata, ctx);
 922         if (local->ops->unassign_vif_chanctx) {
 923                 WARN_ON_ONCE(!ctx->driver_present);
 924                 local->ops->unassign_vif_chanctx(&local->hw,
 925                                                  &sdata->vif,
 926                                                  &ctx->conf);
 927         }
 928         trace_drv_return_void(local);
 929 }
 930
 931 int drv_switch_vif_chanctx(struct ieee80211_local *local,
 932                            struct ieee80211_vif_chanctx_switch *vifs,
 933                            int n_vifs, enum ieee80211_chanctx_switch_mode mode);
 934
 935 static inline int drv_start_ap(struct ieee80211_local *local,
 936                                struct ieee80211_sub_if_data *sdata)
 937 {
 938         int ret = 0;
 939
 940         might_sleep();
 941
 942         if (!check_sdata_in_driver(sdata))
 943                 return -EIO;
 944
 945         trace_drv_start_ap(local, sdata, &sdata->vif.bss_conf);
 946         if (local->ops->start_ap)
 947                 ret = local->ops->start_ap(&local->hw, &sdata->vif);
 948         trace_drv_return_int(local, ret);
 949         return ret;
 950 }
 951
 952 static inline void drv_stop_ap(struct ieee80211_local *local,
 953                                struct ieee80211_sub_if_data *sdata)
 954 {
 955         if (!check_sdata_in_driver(sdata))
 956                 return;
 957
 958         trace_drv_stop_ap(local, sdata);
 959         if (local->ops->stop_ap)
 960                 local->ops->stop_ap(&local->hw, &sdata->vif);
 961         trace_drv_return_void(local);
 962 }
 963
 964 static inline void
 965 drv_reconfig_complete(struct ieee80211_local *local,
 966                       enum ieee80211_reconfig_type reconfig_type)
 967 {
 968         might_sleep();
 969
 970         trace_drv_reconfig_complete(local, reconfig_type);
 971         if (local->ops->reconfig_complete)
 972                 local->ops->reconfig_complete(&local->hw, reconfig_type);
 973         trace_drv_return_void(local);
 974 }
 975
 976 static inline void
 977 drv_set_default_unicast_key(struct ieee80211_local *local,
 978                             struct ieee80211_sub_if_data *sdata,
 979                             int key_idx)
 980 {
 981         if (!check_sdata_in_driver(sdata))
 982                 return;
 983
 984         WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
 985
 986         trace_drv_set_default_unicast_key(local, sdata, key_idx);
 987         if (local->ops->set_default_unicast_key)
 988                 local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
 989                                                     key_idx);
 990         trace_drv_return_void(local);
 991 }
 992
 993 #if IS_ENABLED(CONFIG_IPV6)
 994 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
 995                                         struct ieee80211_sub_if_data *sdata,
 996                                         struct inet6_dev *idev)
 997 {
 998         trace_drv_ipv6_addr_change(local, sdata);
 999         if (local->ops->ipv6_addr_change)
1000                 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1001         trace_drv_return_void(local);
1002 }
1003 #endif
1004
1005 static inline void
1006 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1007                           struct cfg80211_chan_def *chandef)
1008 {
1009         struct ieee80211_local *local = sdata->local;
1010
1011         if (local->ops->channel_switch_beacon) {
1012                 trace_drv_channel_switch_beacon(local, sdata, chandef);
1013                 local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1014                                                   chandef);
1015         }
1016 }
1017
1018 static inline int
1019 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1020                        struct ieee80211_channel_switch *ch_switch)
1021 {
1022         struct ieee80211_local *local = sdata->local;
1023         int ret = 0;
1024
1025         if (!check_sdata_in_driver(sdata))
1026                 return -EIO;
1027
1028         trace_drv_pre_channel_switch(local, sdata, ch_switch);
1029         if (local->ops->pre_channel_switch)
1030                 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1031                                                      ch_switch);
1032         trace_drv_return_int(local, ret);
1033         return ret;
1034 }
1035
1036 static inline int
1037 drv_post_channel_switch(struct ieee80211_sub_if_data *sdata)
1038 {
1039         struct ieee80211_local *local = sdata->local;
1040         int ret = 0;
1041
1042         if (!check_sdata_in_driver(sdata))
1043                 return -EIO;
1044
1045         trace_drv_post_channel_switch(local, sdata);
1046         if (local->ops->post_channel_switch)
1047                 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif);
1048         trace_drv_return_int(local, ret);
1049         return ret;
1050 }
1051
1052 static inline int drv_join_ibss(struct ieee80211_local *local,
1053                                 struct ieee80211_sub_if_data *sdata)
1054 {
1055         int ret = 0;
1056
1057         might_sleep();
1058         if (!check_sdata_in_driver(sdata))
1059                 return -EIO;
1060
1061         trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1062         if (local->ops->join_ibss)
1063                 ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1064         trace_drv_return_int(local, ret);
1065         return ret;
1066 }
1067
1068 static inline void drv_leave_ibss(struct ieee80211_local *local,
1069                                   struct ieee80211_sub_if_data *sdata)
1070 {
1071         might_sleep();
1072         if (!check_sdata_in_driver(sdata))
1073                 return;
1074
1075         trace_drv_leave_ibss(local, sdata);
1076         if (local->ops->leave_ibss)
1077                 local->ops->leave_ibss(&local->hw, &sdata->vif);
1078         trace_drv_return_void(local);
1079 }
1080
1081 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1082                                               struct sta_info *sta)
1083 {
1084         u32 ret = 0;
1085
1086         trace_drv_get_expected_throughput(&sta->sta);
1087         if (local->ops->get_expected_throughput && sta->uploaded)
1088                 ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1089         trace_drv_return_u32(local, ret);
1090
1091         return ret;
1092 }
1093
1094 static inline int drv_get_txpower(struct ieee80211_local *local,
1095                                   struct ieee80211_sub_if_data *sdata, int *dbm)
1096 {
1097         int ret;
1098
1099         if (!local->ops->get_txpower)
1100                 return -EOPNOTSUPP;
1101
1102         ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm);
1103         trace_drv_get_txpower(local, sdata, *dbm, ret);
1104
1105         return ret;
1106 }
1107
1108 static inline int
1109 drv_tdls_channel_switch(struct ieee80211_local *local,
1110                         struct ieee80211_sub_if_data *sdata,
1111                         struct ieee80211_sta *sta, u8 oper_class,
1112                         struct cfg80211_chan_def *chandef,
1113                         struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1114 {
1115         int ret;
1116
1117         might_sleep();
1118         if (!check_sdata_in_driver(sdata))
1119                 return -EIO;
1120
1121         if (!local->ops->tdls_channel_switch)
1122                 return -EOPNOTSUPP;
1123
1124         trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1125         ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1126                                               oper_class, chandef, tmpl_skb,
1127                                               ch_sw_tm_ie);
1128         trace_drv_return_int(local, ret);
1129         return ret;
1130 }
1131
1132 static inline void
1133 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1134                                struct ieee80211_sub_if_data *sdata,
1135                                struct ieee80211_sta *sta)
1136 {
1137         might_sleep();
1138         if (!check_sdata_in_driver(sdata))
1139                 return;
1140
1141         if (!local->ops->tdls_cancel_channel_switch)
1142                 return;
1143
1144         trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1145         local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1146         trace_drv_return_void(local);
1147 }
1148
1149 static inline void
1150 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1151                              struct ieee80211_sub_if_data *sdata,
1152                              struct ieee80211_tdls_ch_sw_params *params)
1153 {
1154         trace_drv_tdls_recv_channel_switch(local, sdata, params);
1155         if (local->ops->tdls_recv_channel_switch)
1156                 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1157                                                      params);
1158         trace_drv_return_void(local);
1159 }
1160
1161 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1162                                      struct txq_info *txq)
1163 {
1164         struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1165
1166         if (local->in_reconfig)
1167                 return;
1168
1169         if (!check_sdata_in_driver(sdata))
1170                 return;
1171
1172         trace_drv_wake_tx_queue(local, sdata, txq);
1173         local->ops->wake_tx_queue(&local->hw, &txq->txq);
1174 }
1175
1176 static inline int drv_start_nan(struct ieee80211_local *local,
1177                                 struct ieee80211_sub_if_data *sdata,
1178                                 struct cfg80211_nan_conf *conf)
1179 {
1180         int ret;
1181
1182         might_sleep();
1183         check_sdata_in_driver(sdata);
1184
1185         trace_drv_start_nan(local, sdata, conf);
1186         ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1187         trace_drv_return_int(local, ret);
1188         return ret;
1189 }
1190
1191 static inline void drv_stop_nan(struct ieee80211_local *local,
1192                                 struct ieee80211_sub_if_data *sdata)
1193 {
1194         might_sleep();
1195         check_sdata_in_driver(sdata);
1196
1197         trace_drv_stop_nan(local, sdata);
1198         local->ops->stop_nan(&local->hw, &sdata->vif);
1199         trace_drv_return_void(local);
1200 }
1201
1202 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1203                                        struct ieee80211_sub_if_data *sdata,
1204                                        struct cfg80211_nan_conf *conf,
1205                                        u32 changes)
1206 {
1207         int ret;
1208
1209         might_sleep();
1210         check_sdata_in_driver(sdata);
1211
1212         if (!local->ops->nan_change_conf)
1213                 return -EOPNOTSUPP;
1214
1215         trace_drv_nan_change_conf(local, sdata, conf, changes);
1216         ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1217                                           changes);
1218         trace_drv_return_int(local, ret);
1219
1220         return ret;
1221 }
1222
1223 static inline int drv_add_nan_func(struct ieee80211_local *local,
1224                                    struct ieee80211_sub_if_data *sdata,
1225                                    const struct cfg80211_nan_func *nan_func)
1226 {
1227         int ret;
1228
1229         might_sleep();
1230         check_sdata_in_driver(sdata);
1231
1232         if (!local->ops->add_nan_func)
1233                 return -EOPNOTSUPP;
1234
1235         trace_drv_add_nan_func(local, sdata, nan_func);
1236         ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1237         trace_drv_return_int(local, ret);
1238
1239         return ret;
1240 }
1241
1242 static inline void drv_del_nan_func(struct ieee80211_local *local,
1243                                    struct ieee80211_sub_if_data *sdata,
1244                                    u8 instance_id)
1245 {
1246         might_sleep();
1247         check_sdata_in_driver(sdata);
1248
1249         trace_drv_del_nan_func(local, sdata, instance_id);
1250         if (local->ops->del_nan_func)
1251                 local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1252         trace_drv_return_void(local);
1253 }
1254
1255 #endif /* __MAC80211_DRIVER_OPS */