net/mac80211/driver-ops.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3 * Portions of this file
   4 * Copyright(c) 2016 Intel Deutschland GmbH
   5 * Copyright (C) 2018 - 2019, 2021 Intel Corporation
   6 */
   7
   8 #ifndef __MAC80211_DRIVER_OPS
   9 #define __MAC80211_DRIVER_OPS
  10
  11 #include <net/mac80211.h>
  12 #include "ieee80211_i.h"
  13 #include "trace.h"
  14
  15 #define check_sdata_in_driver(sdata)    ({                                      \
  16         !WARN_ONCE(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER),                 \
  17                    "%s: Failed check-sdata-in-driver check, flags: 0x%x\n",     \
  18                    sdata->dev ? sdata->dev->name : sdata->name, sdata->flags);  \
  19 })
  20
  21 static inline struct ieee80211_sub_if_data *
  22 get_bss_sdata(struct ieee80211_sub_if_data *sdata)
  23 {
  24         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
  25                 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
  26                                      u.ap);
  27
  28         return sdata;
  29 }
  30
  31 static inline void drv_tx(struct ieee80211_local *local,
  32                           struct ieee80211_tx_control *control,
  33                           struct sk_buff *skb)
  34 {
  35         local->ops->tx(&local->hw, control, skb);
  36 }
  37
  38 static inline void drv_sync_rx_queues(struct ieee80211_local *local,
  39                                       struct sta_info *sta)
  40 {
  41         if (local->ops->sync_rx_queues) {
  42                 trace_drv_sync_rx_queues(local, sta->sdata, &sta->sta);
  43                 local->ops->sync_rx_queues(&local->hw);
  44                 trace_drv_return_void(local);
  45         }
  46 }
  47
  48 static inline void drv_get_et_strings(struct ieee80211_sub_if_data *sdata,
  49                                       u32 sset, u8 *data)
  50 {
  51         struct ieee80211_local *local = sdata->local;
  52         if (local->ops->get_et_strings) {
  53                 trace_drv_get_et_strings(local, sset);
  54                 local->ops->get_et_strings(&local->hw, &sdata->vif, sset, data);
  55                 trace_drv_return_void(local);
  56         }
  57 }
  58
  59 static inline void drv_get_et_stats(struct ieee80211_sub_if_data *sdata,
  60                                     struct ethtool_stats *stats,
  61                                     u64 *data)
  62 {
  63         struct ieee80211_local *local = sdata->local;
  64         if (local->ops->get_et_stats) {
  65                 trace_drv_get_et_stats(local);
  66                 local->ops->get_et_stats(&local->hw, &sdata->vif, stats, data);
  67                 trace_drv_return_void(local);
  68         }
  69 }
  70
  71 static inline int drv_get_et_sset_count(struct ieee80211_sub_if_data *sdata,
  72                                         int sset)
  73 {
  74         struct ieee80211_local *local = sdata->local;
  75         int rv = 0;
  76         if (local->ops->get_et_sset_count) {
  77                 trace_drv_get_et_sset_count(local, sset);
  78                 rv = local->ops->get_et_sset_count(&local->hw, &sdata->vif,
  79                                                    sset);
  80                 trace_drv_return_int(local, rv);
  81         }
  82         return rv;
  83 }
  84
  85 int drv_start(struct ieee80211_local *local);
  86 void drv_stop(struct ieee80211_local *local);
  87
  88 #ifdef CONFIG_PM
  89 static inline int drv_suspend(struct ieee80211_local *local,
  90                               struct cfg80211_wowlan *wowlan)
  91 {
  92         int ret;
  93
  94         might_sleep();
  95
  96         trace_drv_suspend(local);
  97         ret = local->ops->suspend(&local->hw, wowlan);
  98         trace_drv_return_int(local, ret);
  99         return ret;
 100 }
 101
 102 static inline int drv_resume(struct ieee80211_local *local)
 103 {
 104         int ret;
 105
 106         might_sleep();
 107
 108         trace_drv_resume(local);
 109         ret = local->ops->resume(&local->hw);
 110         trace_drv_return_int(local, ret);
 111         return ret;
 112 }
 113
 114 static inline void drv_set_wakeup(struct ieee80211_local *local,
 115                                   bool enabled)
 116 {
 117         might_sleep();
 118
 119         if (!local->ops->set_wakeup)
 120                 return;
 121
 122         trace_drv_set_wakeup(local, enabled);
 123         local->ops->set_wakeup(&local->hw, enabled);
 124         trace_drv_return_void(local);
 125 }
 126 #endif
 127
 128 int drv_add_interface(struct ieee80211_local *local,
 129                       struct ieee80211_sub_if_data *sdata);
 130
 131 int drv_change_interface(struct ieee80211_local *local,
 132                          struct ieee80211_sub_if_data *sdata,
 133                          enum nl80211_iftype type, bool p2p);
 134
 135 void drv_remove_interface(struct ieee80211_local *local,
 136                           struct ieee80211_sub_if_data *sdata);
 137
 138 static inline int drv_config(struct ieee80211_local *local, u32 changed)
 139 {
 140         int ret;
 141
 142         might_sleep();
 143
 144         trace_drv_config(local, changed);
 145         ret = local->ops->config(&local->hw, changed);
 146         trace_drv_return_int(local, ret);
 147         return ret;
 148 }
 149
 150 static inline void drv_vif_cfg_changed(struct ieee80211_local *local,
 151                                        struct ieee80211_sub_if_data *sdata,
 152                                        u64 changed)
 153 {
 154         might_sleep();
 155
 156         if (!check_sdata_in_driver(sdata))
 157                 return;
 158
 159         trace_drv_vif_cfg_changed(local, sdata, changed);
 160         if (local->ops->vif_cfg_changed)
 161                 local->ops->vif_cfg_changed(&local->hw, &sdata->vif, changed);
 162         else if (local->ops->bss_info_changed)
 163                 local->ops->bss_info_changed(&local->hw, &sdata->vif,
 164                                              &sdata->vif.bss_conf, changed);
 165         trace_drv_return_void(local);
 166 }
 167
 168 void drv_link_info_changed(struct ieee80211_local *local,
 169                            struct ieee80211_sub_if_data *sdata,
 170                            struct ieee80211_bss_conf *info,
 171                            int link_id, u64 changed);
 172
 173 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
 174                                         struct netdev_hw_addr_list *mc_list)
 175 {
 176         u64 ret = 0;
 177
 178         trace_drv_prepare_multicast(local, mc_list->count);
 179
 180         if (local->ops->prepare_multicast)
 181                 ret = local->ops->prepare_multicast(&local->hw, mc_list);
 182
 183         trace_drv_return_u64(local, ret);
 184
 185         return ret;
 186 }
 187
 188 static inline void drv_configure_filter(struct ieee80211_local *local,
 189                                         unsigned int changed_flags,
 190                                         unsigned int *total_flags,
 191                                         u64 multicast)
 192 {
 193         might_sleep();
 194
 195         trace_drv_configure_filter(local, changed_flags, total_flags,
 196                                    multicast);
 197         local->ops->configure_filter(&local->hw, changed_flags, total_flags,
 198                                      multicast);
 199         trace_drv_return_void(local);
 200 }
 201
 202 static inline void drv_config_iface_filter(struct ieee80211_local *local,
 203                                            struct ieee80211_sub_if_data *sdata,
 204                                            unsigned int filter_flags,
 205                                            unsigned int changed_flags)
 206 {
 207         might_sleep();
 208
 209         trace_drv_config_iface_filter(local, sdata, filter_flags,
 210                                       changed_flags);
 211         if (local->ops->config_iface_filter)
 212                 local->ops->config_iface_filter(&local->hw, &sdata->vif,
 213                                                 filter_flags,
 214                                                 changed_flags);
 215         trace_drv_return_void(local);
 216 }
 217
 218 static inline int drv_set_tim(struct ieee80211_local *local,
 219                               struct ieee80211_sta *sta, bool set)
 220 {
 221         int ret = 0;
 222         trace_drv_set_tim(local, sta, set);
 223         if (local->ops->set_tim)
 224                 ret = local->ops->set_tim(&local->hw, sta, set);
 225         trace_drv_return_int(local, ret);
 226         return ret;
 227 }
 228
 229 int drv_set_key(struct ieee80211_local *local,
 230                 enum set_key_cmd cmd,
 231                 struct ieee80211_sub_if_data *sdata,
 232                 struct ieee80211_sta *sta,
 233                 struct ieee80211_key_conf *key);
 234
 235 static inline void drv_update_tkip_key(struct ieee80211_local *local,
 236                                        struct ieee80211_sub_if_data *sdata,
 237                                        struct ieee80211_key_conf *conf,
 238                                        struct sta_info *sta, u32 iv32,
 239                                        u16 *phase1key)
 240 {
 241         struct ieee80211_sta *ista = NULL;
 242
 243         if (sta)
 244                 ista = &sta->sta;
 245
 246         sdata = get_bss_sdata(sdata);
 247         if (!check_sdata_in_driver(sdata))
 248                 return;
 249
 250         trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
 251         if (local->ops->update_tkip_key)
 252                 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
 253                                             ista, iv32, phase1key);
 254         trace_drv_return_void(local);
 255 }
 256
 257 static inline int drv_hw_scan(struct ieee80211_local *local,
 258                               struct ieee80211_sub_if_data *sdata,
 259                               struct ieee80211_scan_request *req)
 260 {
 261         int ret;
 262
 263         might_sleep();
 264
 265         if (!check_sdata_in_driver(sdata))
 266                 return -EIO;
 267
 268         trace_drv_hw_scan(local, sdata);
 269         ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
 270         trace_drv_return_int(local, ret);
 271         return ret;
 272 }
 273
 274 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
 275                                       struct ieee80211_sub_if_data *sdata)
 276 {
 277         might_sleep();
 278
 279         if (!check_sdata_in_driver(sdata))
 280                 return;
 281
 282         trace_drv_cancel_hw_scan(local, sdata);
 283         local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
 284         trace_drv_return_void(local);
 285 }
 286
 287 static inline int
 288 drv_sched_scan_start(struct ieee80211_local *local,
 289                      struct ieee80211_sub_if_data *sdata,
 290                      struct cfg80211_sched_scan_request *req,
 291                      struct ieee80211_scan_ies *ies)
 292 {
 293         int ret;
 294
 295         might_sleep();
 296
 297         if (!check_sdata_in_driver(sdata))
 298                 return -EIO;
 299
 300         trace_drv_sched_scan_start(local, sdata);
 301         ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
 302                                               req, ies);
 303         trace_drv_return_int(local, ret);
 304         return ret;
 305 }
 306
 307 static inline int drv_sched_scan_stop(struct ieee80211_local *local,
 308                                       struct ieee80211_sub_if_data *sdata)
 309 {
 310         int ret;
 311
 312         might_sleep();
 313
 314         if (!check_sdata_in_driver(sdata))
 315                 return -EIO;
 316
 317         trace_drv_sched_scan_stop(local, sdata);
 318         ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
 319         trace_drv_return_int(local, ret);
 320
 321         return ret;
 322 }
 323
 324 static inline void drv_sw_scan_start(struct ieee80211_local *local,
 325                                      struct ieee80211_sub_if_data *sdata,
 326                                      const u8 *mac_addr)
 327 {
 328         might_sleep();
 329
 330         trace_drv_sw_scan_start(local, sdata, mac_addr);
 331         if (local->ops->sw_scan_start)
 332                 local->ops->sw_scan_start(&local->hw, &sdata->vif, mac_addr);
 333         trace_drv_return_void(local);
 334 }
 335
 336 static inline void drv_sw_scan_complete(struct ieee80211_local *local,
 337                                         struct ieee80211_sub_if_data *sdata)
 338 {
 339         might_sleep();
 340
 341         trace_drv_sw_scan_complete(local, sdata);
 342         if (local->ops->sw_scan_complete)
 343                 local->ops->sw_scan_complete(&local->hw, &sdata->vif);
 344         trace_drv_return_void(local);
 345 }
 346
 347 static inline int drv_get_stats(struct ieee80211_local *local,
 348                                 struct ieee80211_low_level_stats *stats)
 349 {
 350         int ret = -EOPNOTSUPP;
 351
 352         might_sleep();
 353
 354         if (local->ops->get_stats)
 355                 ret = local->ops->get_stats(&local->hw, stats);
 356         trace_drv_get_stats(local, stats, ret);
 357
 358         return ret;
 359 }
 360
 361 static inline void drv_get_key_seq(struct ieee80211_local *local,
 362                                    struct ieee80211_key *key,
 363                                    struct ieee80211_key_seq *seq)
 364 {
 365         if (local->ops->get_key_seq)
 366                 local->ops->get_key_seq(&local->hw, &key->conf, seq);
 367         trace_drv_get_key_seq(local, &key->conf);
 368 }
 369
 370 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
 371                                         u32 value)
 372 {
 373         int ret = 0;
 374
 375         might_sleep();
 376
 377         trace_drv_set_frag_threshold(local, value);
 378         if (local->ops->set_frag_threshold)
 379                 ret = local->ops->set_frag_threshold(&local->hw, value);
 380         trace_drv_return_int(local, ret);
 381         return ret;
 382 }
 383
 384 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
 385                                         u32 value)
 386 {
 387         int ret = 0;
 388
 389         might_sleep();
 390
 391         trace_drv_set_rts_threshold(local, value);
 392         if (local->ops->set_rts_threshold)
 393                 ret = local->ops->set_rts_threshold(&local->hw, value);
 394         trace_drv_return_int(local, ret);
 395         return ret;
 396 }
 397
 398 static inline int drv_set_coverage_class(struct ieee80211_local *local,
 399                                          s16 value)
 400 {
 401         int ret = 0;
 402         might_sleep();
 403
 404         trace_drv_set_coverage_class(local, value);
 405         if (local->ops->set_coverage_class)
 406                 local->ops->set_coverage_class(&local->hw, value);
 407         else
 408                 ret = -EOPNOTSUPP;
 409
 410         trace_drv_return_int(local, ret);
 411         return ret;
 412 }
 413
 414 static inline void drv_sta_notify(struct ieee80211_local *local,
 415                                   struct ieee80211_sub_if_data *sdata,
 416                                   enum sta_notify_cmd cmd,
 417                                   struct ieee80211_sta *sta)
 418 {
 419         sdata = get_bss_sdata(sdata);
 420         if (!check_sdata_in_driver(sdata))
 421                 return;
 422
 423         trace_drv_sta_notify(local, sdata, cmd, sta);
 424         if (local->ops->sta_notify)
 425                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
 426         trace_drv_return_void(local);
 427 }
 428
 429 static inline int drv_sta_add(struct ieee80211_local *local,
 430                               struct ieee80211_sub_if_data *sdata,
 431                               struct ieee80211_sta *sta)
 432 {
 433         int ret = 0;
 434
 435         might_sleep();
 436
 437         sdata = get_bss_sdata(sdata);
 438         if (!check_sdata_in_driver(sdata))
 439                 return -EIO;
 440
 441         trace_drv_sta_add(local, sdata, sta);
 442         if (local->ops->sta_add)
 443                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
 444
 445         trace_drv_return_int(local, ret);
 446
 447         return ret;
 448 }
 449
 450 static inline void drv_sta_remove(struct ieee80211_local *local,
 451                                   struct ieee80211_sub_if_data *sdata,
 452                                   struct ieee80211_sta *sta)
 453 {
 454         might_sleep();
 455
 456         sdata = get_bss_sdata(sdata);
 457         if (!check_sdata_in_driver(sdata))
 458                 return;
 459
 460         trace_drv_sta_remove(local, sdata, sta);
 461         if (local->ops->sta_remove)
 462                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
 463
 464         trace_drv_return_void(local);
 465 }
 466
 467 #ifdef CONFIG_MAC80211_DEBUGFS
 468 static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
 469                                        struct ieee80211_sub_if_data *sdata,
 470                                        struct ieee80211_sta *sta,
 471                                        struct dentry *dir)
 472 {
 473         might_sleep();
 474
 475         sdata = get_bss_sdata(sdata);
 476         if (!check_sdata_in_driver(sdata))
 477                 return;
 478
 479         if (local->ops->sta_add_debugfs)
 480                 local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
 481                                             sta, dir);
 482 }
 483
 484 static inline void drv_link_sta_add_debugfs(struct ieee80211_local *local,
 485                                             struct ieee80211_sub_if_data *sdata,
 486                                             struct ieee80211_link_sta *link_sta,
 487                                             struct dentry *dir)
 488 {
 489         might_sleep();
 490
 491         sdata = get_bss_sdata(sdata);
 492         if (!check_sdata_in_driver(sdata))
 493                 return;
 494
 495         if (local->ops->link_sta_add_debugfs)
 496                 local->ops->link_sta_add_debugfs(&local->hw, &sdata->vif,
 497                                                  link_sta, dir);
 498 }
 499 #endif
 500
 501 static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
 502                                           struct ieee80211_sub_if_data *sdata,
 503                                           struct sta_info *sta)
 504 {
 505         might_sleep();
 506
 507         sdata = get_bss_sdata(sdata);
 508         if (!check_sdata_in_driver(sdata))
 509                 return;
 510
 511         trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
 512         if (local->ops->sta_pre_rcu_remove)
 513                 local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
 514                                                &sta->sta);
 515         trace_drv_return_void(local);
 516 }
 517
 518 __must_check
 519 int drv_sta_state(struct ieee80211_local *local,
 520                   struct ieee80211_sub_if_data *sdata,
 521                   struct sta_info *sta,
 522                   enum ieee80211_sta_state old_state,
 523                   enum ieee80211_sta_state new_state);
 524
 525 __must_check
 526 int drv_sta_set_txpwr(struct ieee80211_local *local,
 527                       struct ieee80211_sub_if_data *sdata,
 528                       struct sta_info *sta);
 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_link_data *link, 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
 689 drv_cancel_remain_on_channel(struct ieee80211_local *local,
 690                              struct ieee80211_sub_if_data *sdata)
 691 {
 692         int ret;
 693
 694         might_sleep();
 695
 696         trace_drv_cancel_remain_on_channel(local, sdata);
 697         ret = local->ops->cancel_remain_on_channel(&local->hw, &sdata->vif);
 698         trace_drv_return_int(local, ret);
 699
 700         return ret;
 701 }
 702
 703 static inline int drv_set_ringparam(struct ieee80211_local *local,
 704                                     u32 tx, u32 rx)
 705 {
 706         int ret = -ENOTSUPP;
 707
 708         might_sleep();
 709
 710         trace_drv_set_ringparam(local, tx, rx);
 711         if (local->ops->set_ringparam)
 712                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 713         trace_drv_return_int(local, ret);
 714
 715         return ret;
 716 }
 717
 718 static inline void drv_get_ringparam(struct ieee80211_local *local,
 719                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 720 {
 721         might_sleep();
 722
 723         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 724         if (local->ops->get_ringparam)
 725                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 726         trace_drv_return_void(local);
 727 }
 728
 729 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
 730 {
 731         bool ret = false;
 732
 733         might_sleep();
 734
 735         trace_drv_tx_frames_pending(local);
 736         if (local->ops->tx_frames_pending)
 737                 ret = local->ops->tx_frames_pending(&local->hw);
 738         trace_drv_return_bool(local, ret);
 739
 740         return ret;
 741 }
 742
 743 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
 744                                        struct ieee80211_sub_if_data *sdata,
 745                                        const struct cfg80211_bitrate_mask *mask)
 746 {
 747         int ret = -EOPNOTSUPP;
 748
 749         might_sleep();
 750
 751         if (!check_sdata_in_driver(sdata))
 752                 return -EIO;
 753
 754         trace_drv_set_bitrate_mask(local, sdata, mask);
 755         if (local->ops->set_bitrate_mask)
 756                 ret = local->ops->set_bitrate_mask(&local->hw,
 757                                                    &sdata->vif, mask);
 758         trace_drv_return_int(local, ret);
 759
 760         return ret;
 761 }
 762
 763 static inline void drv_set_rekey_data(struct ieee80211_local *local,
 764                                       struct ieee80211_sub_if_data *sdata,
 765                                       struct cfg80211_gtk_rekey_data *data)
 766 {
 767         if (!check_sdata_in_driver(sdata))
 768                 return;
 769
 770         trace_drv_set_rekey_data(local, sdata, data);
 771         if (local->ops->set_rekey_data)
 772                 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
 773         trace_drv_return_void(local);
 774 }
 775
 776 static inline void drv_event_callback(struct ieee80211_local *local,
 777                                       struct ieee80211_sub_if_data *sdata,
 778                                       const struct ieee80211_event *event)
 779 {
 780         trace_drv_event_callback(local, sdata, event);
 781         if (local->ops->event_callback)
 782                 local->ops->event_callback(&local->hw, &sdata->vif, event);
 783         trace_drv_return_void(local);
 784 }
 785
 786 static inline void
 787 drv_release_buffered_frames(struct ieee80211_local *local,
 788                             struct sta_info *sta, u16 tids, int num_frames,
 789                             enum ieee80211_frame_release_type reason,
 790                             bool more_data)
 791 {
 792         trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
 793                                           reason, more_data);
 794         if (local->ops->release_buffered_frames)
 795                 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
 796                                                     num_frames, reason,
 797                                                     more_data);
 798         trace_drv_return_void(local);
 799 }
 800
 801 static inline void
 802 drv_allow_buffered_frames(struct ieee80211_local *local,
 803                           struct sta_info *sta, u16 tids, int num_frames,
 804                           enum ieee80211_frame_release_type reason,
 805                           bool more_data)
 806 {
 807         trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
 808                                         reason, more_data);
 809         if (local->ops->allow_buffered_frames)
 810                 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
 811                                                   tids, num_frames, reason,
 812                                                   more_data);
 813         trace_drv_return_void(local);
 814 }
 815
 816 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
 817                                       struct ieee80211_sub_if_data *sdata,
 818                                       struct ieee80211_prep_tx_info *info)
 819 {
 820         might_sleep();
 821
 822         if (!check_sdata_in_driver(sdata))
 823                 return;
 824         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 825
 826         trace_drv_mgd_prepare_tx(local, sdata, info->duration,
 827                                  info->subtype, info->success);
 828         if (local->ops->mgd_prepare_tx)
 829                 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif, info);
 830         trace_drv_return_void(local);
 831 }
 832
 833 static inline void drv_mgd_complete_tx(struct ieee80211_local *local,
 834                                        struct ieee80211_sub_if_data *sdata,
 835                                        struct ieee80211_prep_tx_info *info)
 836 {
 837         might_sleep();
 838
 839         if (!check_sdata_in_driver(sdata))
 840                 return;
 841         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 842
 843         trace_drv_mgd_complete_tx(local, sdata, info->duration,
 844                                   info->subtype, info->success);
 845         if (local->ops->mgd_complete_tx)
 846                 local->ops->mgd_complete_tx(&local->hw, &sdata->vif, info);
 847         trace_drv_return_void(local);
 848 }
 849
 850 static inline void
 851 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
 852                               struct ieee80211_sub_if_data *sdata)
 853 {
 854         might_sleep();
 855
 856         if (!check_sdata_in_driver(sdata))
 857                 return;
 858         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 859
 860         trace_drv_mgd_protect_tdls_discover(local, sdata);
 861         if (local->ops->mgd_protect_tdls_discover)
 862                 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif);
 863         trace_drv_return_void(local);
 864 }
 865
 866 static inline int drv_add_chanctx(struct ieee80211_local *local,
 867                                   struct ieee80211_chanctx *ctx)
 868 {
 869         int ret = -EOPNOTSUPP;
 870
 871         might_sleep();
 872
 873         trace_drv_add_chanctx(local, ctx);
 874         if (local->ops->add_chanctx)
 875                 ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
 876         trace_drv_return_int(local, ret);
 877         if (!ret)
 878                 ctx->driver_present = true;
 879
 880         return ret;
 881 }
 882
 883 static inline void drv_remove_chanctx(struct ieee80211_local *local,
 884                                       struct ieee80211_chanctx *ctx)
 885 {
 886         might_sleep();
 887
 888         if (WARN_ON(!ctx->driver_present))
 889                 return;
 890
 891         trace_drv_remove_chanctx(local, ctx);
 892         if (local->ops->remove_chanctx)
 893                 local->ops->remove_chanctx(&local->hw, &ctx->conf);
 894         trace_drv_return_void(local);
 895         ctx->driver_present = false;
 896 }
 897
 898 static inline void drv_change_chanctx(struct ieee80211_local *local,
 899                                       struct ieee80211_chanctx *ctx,
 900                                       u32 changed)
 901 {
 902         might_sleep();
 903
 904         trace_drv_change_chanctx(local, ctx, changed);
 905         if (local->ops->change_chanctx) {
 906                 WARN_ON_ONCE(!ctx->driver_present);
 907                 local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
 908         }
 909         trace_drv_return_void(local);
 910 }
 911
 912 static inline void drv_verify_link_exists(struct ieee80211_sub_if_data *sdata,
 913                                           struct ieee80211_bss_conf *link_conf)
 914 {
 915         /* deflink always exists, so need to check only for other links */
 916         if (sdata->deflink.conf != link_conf)
 917                 sdata_assert_lock(sdata);
 918 }
 919
 920 int drv_assign_vif_chanctx(struct ieee80211_local *local,
 921                            struct ieee80211_sub_if_data *sdata,
 922                            struct ieee80211_bss_conf *link_conf,
 923                            struct ieee80211_chanctx *ctx);
 924 void drv_unassign_vif_chanctx(struct ieee80211_local *local,
 925                               struct ieee80211_sub_if_data *sdata,
 926                               struct ieee80211_bss_conf *link_conf,
 927                               struct ieee80211_chanctx *ctx);
 928 int drv_switch_vif_chanctx(struct ieee80211_local *local,
 929                            struct ieee80211_vif_chanctx_switch *vifs,
 930                            int n_vifs, enum ieee80211_chanctx_switch_mode mode);
 931
 932 static inline int drv_start_ap(struct ieee80211_local *local,
 933                                struct ieee80211_sub_if_data *sdata,
 934                                struct ieee80211_bss_conf *link_conf)
 935 {
 936         int ret = 0;
 937
 938         /* make sure link_conf is protected */
 939         drv_verify_link_exists(sdata, link_conf);
 940
 941         might_sleep();
 942
 943         if (!check_sdata_in_driver(sdata))
 944                 return -EIO;
 945
 946         trace_drv_start_ap(local, sdata, link_conf);
 947         if (local->ops->start_ap)
 948                 ret = local->ops->start_ap(&local->hw, &sdata->vif, link_conf);
 949         trace_drv_return_int(local, ret);
 950         return ret;
 951 }
 952
 953 static inline void drv_stop_ap(struct ieee80211_local *local,
 954                                struct ieee80211_sub_if_data *sdata,
 955                                struct ieee80211_bss_conf *link_conf)
 956 {
 957         /* make sure link_conf is protected */
 958         drv_verify_link_exists(sdata, link_conf);
 959
 960         if (!check_sdata_in_driver(sdata))
 961                 return;
 962
 963         trace_drv_stop_ap(local, sdata, link_conf);
 964         if (local->ops->stop_ap)
 965                 local->ops->stop_ap(&local->hw, &sdata->vif, link_conf);
 966         trace_drv_return_void(local);
 967 }
 968
 969 static inline void
 970 drv_reconfig_complete(struct ieee80211_local *local,
 971                       enum ieee80211_reconfig_type reconfig_type)
 972 {
 973         might_sleep();
 974
 975         trace_drv_reconfig_complete(local, reconfig_type);
 976         if (local->ops->reconfig_complete)
 977                 local->ops->reconfig_complete(&local->hw, reconfig_type);
 978         trace_drv_return_void(local);
 979 }
 980
 981 static inline void
 982 drv_set_default_unicast_key(struct ieee80211_local *local,
 983                             struct ieee80211_sub_if_data *sdata,
 984                             int key_idx)
 985 {
 986         if (!check_sdata_in_driver(sdata))
 987                 return;
 988
 989         WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
 990
 991         trace_drv_set_default_unicast_key(local, sdata, key_idx);
 992         if (local->ops->set_default_unicast_key)
 993                 local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
 994                                                     key_idx);
 995         trace_drv_return_void(local);
 996 }
 997
 998 #if IS_ENABLED(CONFIG_IPV6)
 999 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
1000                                         struct ieee80211_sub_if_data *sdata,
1001                                         struct inet6_dev *idev)
1002 {
1003         trace_drv_ipv6_addr_change(local, sdata);
1004         if (local->ops->ipv6_addr_change)
1005                 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1006         trace_drv_return_void(local);
1007 }
1008 #endif
1009
1010 static inline void
1011 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1012                           struct cfg80211_chan_def *chandef)
1013 {
1014         struct ieee80211_local *local = sdata->local;
1015
1016         if (local->ops->channel_switch_beacon) {
1017                 trace_drv_channel_switch_beacon(local, sdata, chandef);
1018                 local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1019                                                   chandef);
1020         }
1021 }
1022
1023 static inline int
1024 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1025                        struct ieee80211_channel_switch *ch_switch)
1026 {
1027         struct ieee80211_local *local = sdata->local;
1028         int ret = 0;
1029
1030         if (!check_sdata_in_driver(sdata))
1031                 return -EIO;
1032
1033         trace_drv_pre_channel_switch(local, sdata, ch_switch);
1034         if (local->ops->pre_channel_switch)
1035                 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1036                                                      ch_switch);
1037         trace_drv_return_int(local, ret);
1038         return ret;
1039 }
1040
1041 static inline int
1042 drv_post_channel_switch(struct ieee80211_sub_if_data *sdata)
1043 {
1044         struct ieee80211_local *local = sdata->local;
1045         int ret = 0;
1046
1047         if (!check_sdata_in_driver(sdata))
1048                 return -EIO;
1049
1050         trace_drv_post_channel_switch(local, sdata);
1051         if (local->ops->post_channel_switch)
1052                 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif);
1053         trace_drv_return_int(local, ret);
1054         return ret;
1055 }
1056
1057 static inline void
1058 drv_abort_channel_switch(struct ieee80211_sub_if_data *sdata)
1059 {
1060         struct ieee80211_local *local = sdata->local;
1061
1062         if (!check_sdata_in_driver(sdata))
1063                 return;
1064
1065         trace_drv_abort_channel_switch(local, sdata);
1066
1067         if (local->ops->abort_channel_switch)
1068                 local->ops->abort_channel_switch(&local->hw, &sdata->vif);
1069 }
1070
1071 static inline void
1072 drv_channel_switch_rx_beacon(struct ieee80211_sub_if_data *sdata,
1073                              struct ieee80211_channel_switch *ch_switch)
1074 {
1075         struct ieee80211_local *local = sdata->local;
1076
1077         if (!check_sdata_in_driver(sdata))
1078                 return;
1079
1080         trace_drv_channel_switch_rx_beacon(local, sdata, ch_switch);
1081         if (local->ops->channel_switch_rx_beacon)
1082                 local->ops->channel_switch_rx_beacon(&local->hw, &sdata->vif,
1083                                                      ch_switch);
1084 }
1085
1086 static inline int drv_join_ibss(struct ieee80211_local *local,
1087                                 struct ieee80211_sub_if_data *sdata)
1088 {
1089         int ret = 0;
1090
1091         might_sleep();
1092         if (!check_sdata_in_driver(sdata))
1093                 return -EIO;
1094
1095         trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1096         if (local->ops->join_ibss)
1097                 ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1098         trace_drv_return_int(local, ret);
1099         return ret;
1100 }
1101
1102 static inline void drv_leave_ibss(struct ieee80211_local *local,
1103                                   struct ieee80211_sub_if_data *sdata)
1104 {
1105         might_sleep();
1106         if (!check_sdata_in_driver(sdata))
1107                 return;
1108
1109         trace_drv_leave_ibss(local, sdata);
1110         if (local->ops->leave_ibss)
1111                 local->ops->leave_ibss(&local->hw, &sdata->vif);
1112         trace_drv_return_void(local);
1113 }
1114
1115 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1116                                               struct sta_info *sta)
1117 {
1118         u32 ret = 0;
1119
1120         trace_drv_get_expected_throughput(&sta->sta);
1121         if (local->ops->get_expected_throughput && sta->uploaded)
1122                 ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1123         trace_drv_return_u32(local, ret);
1124
1125         return ret;
1126 }
1127
1128 static inline int drv_get_txpower(struct ieee80211_local *local,
1129                                   struct ieee80211_sub_if_data *sdata, int *dbm)
1130 {
1131         int ret;
1132
1133         if (!local->ops->get_txpower)
1134                 return -EOPNOTSUPP;
1135
1136         ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm);
1137         trace_drv_get_txpower(local, sdata, *dbm, ret);
1138
1139         return ret;
1140 }
1141
1142 static inline int
1143 drv_tdls_channel_switch(struct ieee80211_local *local,
1144                         struct ieee80211_sub_if_data *sdata,
1145                         struct ieee80211_sta *sta, u8 oper_class,
1146                         struct cfg80211_chan_def *chandef,
1147                         struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1148 {
1149         int ret;
1150
1151         might_sleep();
1152         if (!check_sdata_in_driver(sdata))
1153                 return -EIO;
1154
1155         if (!local->ops->tdls_channel_switch)
1156                 return -EOPNOTSUPP;
1157
1158         trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1159         ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1160                                               oper_class, chandef, tmpl_skb,
1161                                               ch_sw_tm_ie);
1162         trace_drv_return_int(local, ret);
1163         return ret;
1164 }
1165
1166 static inline void
1167 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1168                                struct ieee80211_sub_if_data *sdata,
1169                                struct ieee80211_sta *sta)
1170 {
1171         might_sleep();
1172         if (!check_sdata_in_driver(sdata))
1173                 return;
1174
1175         if (!local->ops->tdls_cancel_channel_switch)
1176                 return;
1177
1178         trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1179         local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1180         trace_drv_return_void(local);
1181 }
1182
1183 static inline void
1184 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1185                              struct ieee80211_sub_if_data *sdata,
1186                              struct ieee80211_tdls_ch_sw_params *params)
1187 {
1188         trace_drv_tdls_recv_channel_switch(local, sdata, params);
1189         if (local->ops->tdls_recv_channel_switch)
1190                 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1191                                                      params);
1192         trace_drv_return_void(local);
1193 }
1194
1195 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1196                                      struct txq_info *txq)
1197 {
1198         struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1199
1200         /* In reconfig don't transmit now, but mark for waking later */
1201         if (local->in_reconfig) {
1202                 set_bit(IEEE80211_TXQ_DIRTY, &txq->flags);
1203                 return;
1204         }
1205
1206         if (!check_sdata_in_driver(sdata))
1207                 return;
1208
1209         trace_drv_wake_tx_queue(local, sdata, txq);
1210         local->ops->wake_tx_queue(&local->hw, &txq->txq);
1211 }
1212
1213 static inline void schedule_and_wake_txq(struct ieee80211_local *local,
1214                                          struct txq_info *txqi)
1215 {
1216         ieee80211_schedule_txq(&local->hw, &txqi->txq);
1217         drv_wake_tx_queue(local, txqi);
1218 }
1219
1220 static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local,
1221                                              struct sk_buff *head,
1222                                              struct sk_buff *skb)
1223 {
1224         if (!local->ops->can_aggregate_in_amsdu)
1225                 return true;
1226
1227         return local->ops->can_aggregate_in_amsdu(&local->hw, head, skb);
1228 }
1229
1230 static inline int
1231 drv_get_ftm_responder_stats(struct ieee80211_local *local,
1232                             struct ieee80211_sub_if_data *sdata,
1233                             struct cfg80211_ftm_responder_stats *ftm_stats)
1234 {
1235         u32 ret = -EOPNOTSUPP;
1236
1237         if (local->ops->get_ftm_responder_stats)
1238                 ret = local->ops->get_ftm_responder_stats(&local->hw,
1239                                                          &sdata->vif,
1240                                                          ftm_stats);
1241         trace_drv_get_ftm_responder_stats(local, sdata, ftm_stats);
1242
1243         return ret;
1244 }
1245
1246 static inline int drv_start_pmsr(struct ieee80211_local *local,
1247                                  struct ieee80211_sub_if_data *sdata,
1248                                  struct cfg80211_pmsr_request *request)
1249 {
1250         int ret = -EOPNOTSUPP;
1251
1252         might_sleep();
1253         if (!check_sdata_in_driver(sdata))
1254                 return -EIO;
1255
1256         trace_drv_start_pmsr(local, sdata);
1257
1258         if (local->ops->start_pmsr)
1259                 ret = local->ops->start_pmsr(&local->hw, &sdata->vif, request);
1260         trace_drv_return_int(local, ret);
1261
1262         return ret;
1263 }
1264
1265 static inline void drv_abort_pmsr(struct ieee80211_local *local,
1266                                   struct ieee80211_sub_if_data *sdata,
1267                                   struct cfg80211_pmsr_request *request)
1268 {
1269         trace_drv_abort_pmsr(local, sdata);
1270
1271         might_sleep();
1272         if (!check_sdata_in_driver(sdata))
1273                 return;
1274
1275         if (local->ops->abort_pmsr)
1276                 local->ops->abort_pmsr(&local->hw, &sdata->vif, request);
1277         trace_drv_return_void(local);
1278 }
1279
1280 static inline int drv_start_nan(struct ieee80211_local *local,
1281                                 struct ieee80211_sub_if_data *sdata,
1282                                 struct cfg80211_nan_conf *conf)
1283 {
1284         int ret;
1285
1286         might_sleep();
1287         check_sdata_in_driver(sdata);
1288
1289         trace_drv_start_nan(local, sdata, conf);
1290         ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1291         trace_drv_return_int(local, ret);
1292         return ret;
1293 }
1294
1295 static inline void drv_stop_nan(struct ieee80211_local *local,
1296                                 struct ieee80211_sub_if_data *sdata)
1297 {
1298         might_sleep();
1299         check_sdata_in_driver(sdata);
1300
1301         trace_drv_stop_nan(local, sdata);
1302         local->ops->stop_nan(&local->hw, &sdata->vif);
1303         trace_drv_return_void(local);
1304 }
1305
1306 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1307                                        struct ieee80211_sub_if_data *sdata,
1308                                        struct cfg80211_nan_conf *conf,
1309                                        u32 changes)
1310 {
1311         int ret;
1312
1313         might_sleep();
1314         check_sdata_in_driver(sdata);
1315
1316         if (!local->ops->nan_change_conf)
1317                 return -EOPNOTSUPP;
1318
1319         trace_drv_nan_change_conf(local, sdata, conf, changes);
1320         ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1321                                           changes);
1322         trace_drv_return_int(local, ret);
1323
1324         return ret;
1325 }
1326
1327 static inline int drv_add_nan_func(struct ieee80211_local *local,
1328                                    struct ieee80211_sub_if_data *sdata,
1329                                    const struct cfg80211_nan_func *nan_func)
1330 {
1331         int ret;
1332
1333         might_sleep();
1334         check_sdata_in_driver(sdata);
1335
1336         if (!local->ops->add_nan_func)
1337                 return -EOPNOTSUPP;
1338
1339         trace_drv_add_nan_func(local, sdata, nan_func);
1340         ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1341         trace_drv_return_int(local, ret);
1342
1343         return ret;
1344 }
1345
1346 static inline void drv_del_nan_func(struct ieee80211_local *local,
1347                                    struct ieee80211_sub_if_data *sdata,
1348                                    u8 instance_id)
1349 {
1350         might_sleep();
1351         check_sdata_in_driver(sdata);
1352
1353         trace_drv_del_nan_func(local, sdata, instance_id);
1354         if (local->ops->del_nan_func)
1355                 local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1356         trace_drv_return_void(local);
1357 }
1358
1359 static inline int drv_set_tid_config(struct ieee80211_local *local,
1360                                      struct ieee80211_sub_if_data *sdata,
1361                                      struct ieee80211_sta *sta,
1362                                      struct cfg80211_tid_config *tid_conf)
1363 {
1364         int ret;
1365
1366         might_sleep();
1367         ret = local->ops->set_tid_config(&local->hw, &sdata->vif, sta,
1368                                          tid_conf);
1369         trace_drv_return_int(local, ret);
1370
1371         return ret;
1372 }
1373
1374 static inline int drv_reset_tid_config(struct ieee80211_local *local,
1375                                        struct ieee80211_sub_if_data *sdata,
1376                                        struct ieee80211_sta *sta, u8 tids)
1377 {
1378         int ret;
1379
1380         might_sleep();
1381         ret = local->ops->reset_tid_config(&local->hw, &sdata->vif, sta, tids);
1382         trace_drv_return_int(local, ret);
1383
1384         return ret;
1385 }
1386
1387 static inline void drv_update_vif_offload(struct ieee80211_local *local,
1388                                           struct ieee80211_sub_if_data *sdata)
1389 {
1390         might_sleep();
1391         check_sdata_in_driver(sdata);
1392
1393         if (!local->ops->update_vif_offload)
1394                 return;
1395
1396         trace_drv_update_vif_offload(local, sdata);
1397         local->ops->update_vif_offload(&local->hw, &sdata->vif);
1398         trace_drv_return_void(local);
1399 }
1400
1401 static inline void drv_sta_set_4addr(struct ieee80211_local *local,
1402                                      struct ieee80211_sub_if_data *sdata,
1403                                      struct ieee80211_sta *sta, bool enabled)
1404 {
1405         sdata = get_bss_sdata(sdata);
1406         if (!check_sdata_in_driver(sdata))
1407                 return;
1408
1409         trace_drv_sta_set_4addr(local, sdata, sta, enabled);
1410         if (local->ops->sta_set_4addr)
1411                 local->ops->sta_set_4addr(&local->hw, &sdata->vif, sta, enabled);
1412         trace_drv_return_void(local);
1413 }
1414
1415 static inline void drv_sta_set_decap_offload(struct ieee80211_local *local,
1416                                              struct ieee80211_sub_if_data *sdata,
1417                                              struct ieee80211_sta *sta,
1418                                              bool enabled)
1419 {
1420         sdata = get_bss_sdata(sdata);
1421         if (!check_sdata_in_driver(sdata))
1422                 return;
1423
1424         trace_drv_sta_set_decap_offload(local, sdata, sta, enabled);
1425         if (local->ops->sta_set_decap_offload)
1426                 local->ops->sta_set_decap_offload(&local->hw, &sdata->vif, sta,
1427                                                   enabled);
1428         trace_drv_return_void(local);
1429 }
1430
1431 static inline void drv_add_twt_setup(struct ieee80211_local *local,
1432                                      struct ieee80211_sub_if_data *sdata,
1433                                      struct ieee80211_sta *sta,
1434                                      struct ieee80211_twt_setup *twt)
1435 {
1436         struct ieee80211_twt_params *twt_agrt;
1437
1438         might_sleep();
1439
1440         if (!check_sdata_in_driver(sdata))
1441                 return;
1442
1443         twt_agrt = (void *)twt->params;
1444
1445         trace_drv_add_twt_setup(local, sta, twt, twt_agrt);
1446         local->ops->add_twt_setup(&local->hw, sta, twt);
1447         trace_drv_return_void(local);
1448 }
1449
1450 static inline void drv_twt_teardown_request(struct ieee80211_local *local,
1451                                             struct ieee80211_sub_if_data *sdata,
1452                                             struct ieee80211_sta *sta,
1453                                             u8 flowid)
1454 {
1455         might_sleep();
1456         if (!check_sdata_in_driver(sdata))
1457                 return;
1458
1459         if (!local->ops->twt_teardown_request)
1460                 return;
1461
1462         trace_drv_twt_teardown_request(local, sta, flowid);
1463         local->ops->twt_teardown_request(&local->hw, sta, flowid);
1464         trace_drv_return_void(local);
1465 }
1466
1467 static inline int drv_net_fill_forward_path(struct ieee80211_local *local,
1468                                             struct ieee80211_sub_if_data *sdata,
1469                                             struct ieee80211_sta *sta,
1470                                             struct net_device_path_ctx *ctx,
1471                                             struct net_device_path *path)
1472 {
1473         int ret = -EOPNOTSUPP;
1474
1475         sdata = get_bss_sdata(sdata);
1476         if (!check_sdata_in_driver(sdata))
1477                 return -EIO;
1478
1479         trace_drv_net_fill_forward_path(local, sdata, sta);
1480         if (local->ops->net_fill_forward_path)
1481                 ret = local->ops->net_fill_forward_path(&local->hw,
1482                                                         &sdata->vif, sta,
1483                                                         ctx, path);
1484         trace_drv_return_int(local, ret);
1485
1486         return ret;
1487 }
1488
1489 int drv_change_vif_links(struct ieee80211_local *local,
1490                          struct ieee80211_sub_if_data *sdata,
1491                          u16 old_links, u16 new_links,
1492                          struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]);
1493 int drv_change_sta_links(struct ieee80211_local *local,
1494                          struct ieee80211_sub_if_data *sdata,
1495                          struct ieee80211_sta *sta,
1496                          u16 old_links, u16 new_links);
1497
1498 #endif /* __MAC80211_DRIVER_OPS */