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_link_add_debugfs(struct ieee80211_local *local,
 469                                         struct ieee80211_sub_if_data *sdata,
 470                                         struct ieee80211_bss_conf *link_conf,
 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->link_add_debugfs)
 480                 local->ops->link_add_debugfs(&local->hw, &sdata->vif,
 481                                              link_conf, dir);
 482 }
 483
 484 static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
 485                                        struct ieee80211_sub_if_data *sdata,
 486                                        struct ieee80211_sta *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->sta_add_debugfs)
 496                 local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
 497                                             sta, dir);
 498 }
 499
 500 static inline void drv_link_sta_add_debugfs(struct ieee80211_local *local,
 501                                             struct ieee80211_sub_if_data *sdata,
 502                                             struct ieee80211_link_sta *link_sta,
 503                                             struct dentry *dir)
 504 {
 505         might_sleep();
 506
 507         sdata = get_bss_sdata(sdata);
 508         if (!check_sdata_in_driver(sdata))
 509                 return;
 510
 511         if (local->ops->link_sta_add_debugfs)
 512                 local->ops->link_sta_add_debugfs(&local->hw, &sdata->vif,
 513                                                  link_sta, dir);
 514 }
 515 #endif
 516
 517 static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
 518                                           struct ieee80211_sub_if_data *sdata,
 519                                           struct sta_info *sta)
 520 {
 521         might_sleep();
 522
 523         sdata = get_bss_sdata(sdata);
 524         if (!check_sdata_in_driver(sdata))
 525                 return;
 526
 527         trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
 528         if (local->ops->sta_pre_rcu_remove)
 529                 local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
 530                                                &sta->sta);
 531         trace_drv_return_void(local);
 532 }
 533
 534 __must_check
 535 int drv_sta_state(struct ieee80211_local *local,
 536                   struct ieee80211_sub_if_data *sdata,
 537                   struct sta_info *sta,
 538                   enum ieee80211_sta_state old_state,
 539                   enum ieee80211_sta_state new_state);
 540
 541 __must_check
 542 int drv_sta_set_txpwr(struct ieee80211_local *local,
 543                       struct ieee80211_sub_if_data *sdata,
 544                       struct sta_info *sta);
 545
 546 void drv_sta_rc_update(struct ieee80211_local *local,
 547                        struct ieee80211_sub_if_data *sdata,
 548                        struct ieee80211_sta *sta, u32 changed);
 549
 550 static inline void drv_sta_rate_tbl_update(struct ieee80211_local *local,
 551                                            struct ieee80211_sub_if_data *sdata,
 552                                            struct ieee80211_sta *sta)
 553 {
 554         sdata = get_bss_sdata(sdata);
 555         if (!check_sdata_in_driver(sdata))
 556                 return;
 557
 558         trace_drv_sta_rate_tbl_update(local, sdata, sta);
 559         if (local->ops->sta_rate_tbl_update)
 560                 local->ops->sta_rate_tbl_update(&local->hw, &sdata->vif, sta);
 561
 562         trace_drv_return_void(local);
 563 }
 564
 565 static inline void drv_sta_statistics(struct ieee80211_local *local,
 566                                       struct ieee80211_sub_if_data *sdata,
 567                                       struct ieee80211_sta *sta,
 568                                       struct station_info *sinfo)
 569 {
 570         sdata = get_bss_sdata(sdata);
 571         if (!check_sdata_in_driver(sdata))
 572                 return;
 573
 574         trace_drv_sta_statistics(local, sdata, sta);
 575         if (local->ops->sta_statistics)
 576                 local->ops->sta_statistics(&local->hw, &sdata->vif, sta, sinfo);
 577         trace_drv_return_void(local);
 578 }
 579
 580 int drv_conf_tx(struct ieee80211_local *local,
 581                 struct ieee80211_link_data *link, u16 ac,
 582                 const struct ieee80211_tx_queue_params *params);
 583
 584 u64 drv_get_tsf(struct ieee80211_local *local,
 585                 struct ieee80211_sub_if_data *sdata);
 586 void drv_set_tsf(struct ieee80211_local *local,
 587                  struct ieee80211_sub_if_data *sdata,
 588                  u64 tsf);
 589 void drv_offset_tsf(struct ieee80211_local *local,
 590                     struct ieee80211_sub_if_data *sdata,
 591                     s64 offset);
 592 void drv_reset_tsf(struct ieee80211_local *local,
 593                    struct ieee80211_sub_if_data *sdata);
 594
 595 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
 596 {
 597         int ret = 0; /* default unsupported op for less congestion */
 598
 599         might_sleep();
 600
 601         trace_drv_tx_last_beacon(local);
 602         if (local->ops->tx_last_beacon)
 603                 ret = local->ops->tx_last_beacon(&local->hw);
 604         trace_drv_return_int(local, ret);
 605         return ret;
 606 }
 607
 608 int drv_ampdu_action(struct ieee80211_local *local,
 609                      struct ieee80211_sub_if_data *sdata,
 610                      struct ieee80211_ampdu_params *params);
 611
 612 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
 613                                 struct survey_info *survey)
 614 {
 615         int ret = -EOPNOTSUPP;
 616
 617         trace_drv_get_survey(local, idx, survey);
 618
 619         if (local->ops->get_survey)
 620                 ret = local->ops->get_survey(&local->hw, idx, survey);
 621
 622         trace_drv_return_int(local, ret);
 623
 624         return ret;
 625 }
 626
 627 static inline void drv_rfkill_poll(struct ieee80211_local *local)
 628 {
 629         might_sleep();
 630
 631         if (local->ops->rfkill_poll)
 632                 local->ops->rfkill_poll(&local->hw);
 633 }
 634
 635 static inline void drv_flush(struct ieee80211_local *local,
 636                              struct ieee80211_sub_if_data *sdata,
 637                              u32 queues, bool drop)
 638 {
 639         struct ieee80211_vif *vif = sdata ? &sdata->vif : NULL;
 640
 641         might_sleep();
 642
 643         if (sdata && !check_sdata_in_driver(sdata))
 644                 return;
 645
 646         trace_drv_flush(local, queues, drop);
 647         if (local->ops->flush)
 648                 local->ops->flush(&local->hw, vif, queues, drop);
 649         trace_drv_return_void(local);
 650 }
 651
 652 static inline void drv_flush_sta(struct ieee80211_local *local,
 653                                  struct ieee80211_sub_if_data *sdata,
 654                                  struct sta_info *sta)
 655 {
 656         might_sleep();
 657
 658         if (sdata && !check_sdata_in_driver(sdata))
 659                 return;
 660
 661         trace_drv_flush_sta(local, sdata, &sta->sta);
 662         if (local->ops->flush_sta)
 663                 local->ops->flush_sta(&local->hw, &sdata->vif, &sta->sta);
 664         trace_drv_return_void(local);
 665 }
 666
 667 static inline void drv_channel_switch(struct ieee80211_local *local,
 668                                       struct ieee80211_sub_if_data *sdata,
 669                                       struct ieee80211_channel_switch *ch_switch)
 670 {
 671         might_sleep();
 672
 673         trace_drv_channel_switch(local, sdata, ch_switch);
 674         local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch);
 675         trace_drv_return_void(local);
 676 }
 677
 678
 679 static inline int drv_set_antenna(struct ieee80211_local *local,
 680                                   u32 tx_ant, u32 rx_ant)
 681 {
 682         int ret = -EOPNOTSUPP;
 683         might_sleep();
 684         if (local->ops->set_antenna)
 685                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
 686         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
 687         return ret;
 688 }
 689
 690 static inline int drv_get_antenna(struct ieee80211_local *local,
 691                                   u32 *tx_ant, u32 *rx_ant)
 692 {
 693         int ret = -EOPNOTSUPP;
 694         might_sleep();
 695         if (local->ops->get_antenna)
 696                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
 697         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
 698         return ret;
 699 }
 700
 701 static inline int drv_remain_on_channel(struct ieee80211_local *local,
 702                                         struct ieee80211_sub_if_data *sdata,
 703                                         struct ieee80211_channel *chan,
 704                                         unsigned int duration,
 705                                         enum ieee80211_roc_type type)
 706 {
 707         int ret;
 708
 709         might_sleep();
 710
 711         trace_drv_remain_on_channel(local, sdata, chan, duration, type);
 712         ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
 713                                             chan, duration, type);
 714         trace_drv_return_int(local, ret);
 715
 716         return ret;
 717 }
 718
 719 static inline int
 720 drv_cancel_remain_on_channel(struct ieee80211_local *local,
 721                              struct ieee80211_sub_if_data *sdata)
 722 {
 723         int ret;
 724
 725         might_sleep();
 726
 727         trace_drv_cancel_remain_on_channel(local, sdata);
 728         ret = local->ops->cancel_remain_on_channel(&local->hw, &sdata->vif);
 729         trace_drv_return_int(local, ret);
 730
 731         return ret;
 732 }
 733
 734 static inline int drv_set_ringparam(struct ieee80211_local *local,
 735                                     u32 tx, u32 rx)
 736 {
 737         int ret = -ENOTSUPP;
 738
 739         might_sleep();
 740
 741         trace_drv_set_ringparam(local, tx, rx);
 742         if (local->ops->set_ringparam)
 743                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 744         trace_drv_return_int(local, ret);
 745
 746         return ret;
 747 }
 748
 749 static inline void drv_get_ringparam(struct ieee80211_local *local,
 750                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 751 {
 752         might_sleep();
 753
 754         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 755         if (local->ops->get_ringparam)
 756                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 757         trace_drv_return_void(local);
 758 }
 759
 760 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
 761 {
 762         bool ret = false;
 763
 764         might_sleep();
 765
 766         trace_drv_tx_frames_pending(local);
 767         if (local->ops->tx_frames_pending)
 768                 ret = local->ops->tx_frames_pending(&local->hw);
 769         trace_drv_return_bool(local, ret);
 770
 771         return ret;
 772 }
 773
 774 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
 775                                        struct ieee80211_sub_if_data *sdata,
 776                                        const struct cfg80211_bitrate_mask *mask)
 777 {
 778         int ret = -EOPNOTSUPP;
 779
 780         might_sleep();
 781
 782         if (!check_sdata_in_driver(sdata))
 783                 return -EIO;
 784
 785         trace_drv_set_bitrate_mask(local, sdata, mask);
 786         if (local->ops->set_bitrate_mask)
 787                 ret = local->ops->set_bitrate_mask(&local->hw,
 788                                                    &sdata->vif, mask);
 789         trace_drv_return_int(local, ret);
 790
 791         return ret;
 792 }
 793
 794 static inline void drv_set_rekey_data(struct ieee80211_local *local,
 795                                       struct ieee80211_sub_if_data *sdata,
 796                                       struct cfg80211_gtk_rekey_data *data)
 797 {
 798         if (!check_sdata_in_driver(sdata))
 799                 return;
 800
 801         trace_drv_set_rekey_data(local, sdata, data);
 802         if (local->ops->set_rekey_data)
 803                 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
 804         trace_drv_return_void(local);
 805 }
 806
 807 static inline void drv_event_callback(struct ieee80211_local *local,
 808                                       struct ieee80211_sub_if_data *sdata,
 809                                       const struct ieee80211_event *event)
 810 {
 811         trace_drv_event_callback(local, sdata, event);
 812         if (local->ops->event_callback)
 813                 local->ops->event_callback(&local->hw, &sdata->vif, event);
 814         trace_drv_return_void(local);
 815 }
 816
 817 static inline void
 818 drv_release_buffered_frames(struct ieee80211_local *local,
 819                             struct sta_info *sta, u16 tids, int num_frames,
 820                             enum ieee80211_frame_release_type reason,
 821                             bool more_data)
 822 {
 823         trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
 824                                           reason, more_data);
 825         if (local->ops->release_buffered_frames)
 826                 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
 827                                                     num_frames, reason,
 828                                                     more_data);
 829         trace_drv_return_void(local);
 830 }
 831
 832 static inline void
 833 drv_allow_buffered_frames(struct ieee80211_local *local,
 834                           struct sta_info *sta, u16 tids, int num_frames,
 835                           enum ieee80211_frame_release_type reason,
 836                           bool more_data)
 837 {
 838         trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
 839                                         reason, more_data);
 840         if (local->ops->allow_buffered_frames)
 841                 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
 842                                                   tids, num_frames, reason,
 843                                                   more_data);
 844         trace_drv_return_void(local);
 845 }
 846
 847 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
 848                                       struct ieee80211_sub_if_data *sdata,
 849                                       struct ieee80211_prep_tx_info *info)
 850 {
 851         might_sleep();
 852
 853         if (!check_sdata_in_driver(sdata))
 854                 return;
 855         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 856
 857         trace_drv_mgd_prepare_tx(local, sdata, info->duration,
 858                                  info->subtype, info->success);
 859         if (local->ops->mgd_prepare_tx)
 860                 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif, info);
 861         trace_drv_return_void(local);
 862 }
 863
 864 static inline void drv_mgd_complete_tx(struct ieee80211_local *local,
 865                                        struct ieee80211_sub_if_data *sdata,
 866                                        struct ieee80211_prep_tx_info *info)
 867 {
 868         might_sleep();
 869
 870         if (!check_sdata_in_driver(sdata))
 871                 return;
 872         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 873
 874         trace_drv_mgd_complete_tx(local, sdata, info->duration,
 875                                   info->subtype, info->success);
 876         if (local->ops->mgd_complete_tx)
 877                 local->ops->mgd_complete_tx(&local->hw, &sdata->vif, info);
 878         trace_drv_return_void(local);
 879 }
 880
 881 static inline void
 882 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
 883                               struct ieee80211_sub_if_data *sdata)
 884 {
 885         might_sleep();
 886
 887         if (!check_sdata_in_driver(sdata))
 888                 return;
 889         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 890
 891         trace_drv_mgd_protect_tdls_discover(local, sdata);
 892         if (local->ops->mgd_protect_tdls_discover)
 893                 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif);
 894         trace_drv_return_void(local);
 895 }
 896
 897 static inline int drv_add_chanctx(struct ieee80211_local *local,
 898                                   struct ieee80211_chanctx *ctx)
 899 {
 900         int ret = -EOPNOTSUPP;
 901
 902         might_sleep();
 903
 904         trace_drv_add_chanctx(local, ctx);
 905         if (local->ops->add_chanctx)
 906                 ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
 907         trace_drv_return_int(local, ret);
 908         if (!ret)
 909                 ctx->driver_present = true;
 910
 911         return ret;
 912 }
 913
 914 static inline void drv_remove_chanctx(struct ieee80211_local *local,
 915                                       struct ieee80211_chanctx *ctx)
 916 {
 917         might_sleep();
 918
 919         if (WARN_ON(!ctx->driver_present))
 920                 return;
 921
 922         trace_drv_remove_chanctx(local, ctx);
 923         if (local->ops->remove_chanctx)
 924                 local->ops->remove_chanctx(&local->hw, &ctx->conf);
 925         trace_drv_return_void(local);
 926         ctx->driver_present = false;
 927 }
 928
 929 static inline void drv_change_chanctx(struct ieee80211_local *local,
 930                                       struct ieee80211_chanctx *ctx,
 931                                       u32 changed)
 932 {
 933         might_sleep();
 934
 935         trace_drv_change_chanctx(local, ctx, changed);
 936         if (local->ops->change_chanctx) {
 937                 WARN_ON_ONCE(!ctx->driver_present);
 938                 local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
 939         }
 940         trace_drv_return_void(local);
 941 }
 942
 943 static inline void drv_verify_link_exists(struct ieee80211_sub_if_data *sdata,
 944                                           struct ieee80211_bss_conf *link_conf)
 945 {
 946         /* deflink always exists, so need to check only for other links */
 947         if (sdata->deflink.conf != link_conf)
 948                 sdata_assert_lock(sdata);
 949 }
 950
 951 int drv_assign_vif_chanctx(struct ieee80211_local *local,
 952                            struct ieee80211_sub_if_data *sdata,
 953                            struct ieee80211_bss_conf *link_conf,
 954                            struct ieee80211_chanctx *ctx);
 955 void drv_unassign_vif_chanctx(struct ieee80211_local *local,
 956                               struct ieee80211_sub_if_data *sdata,
 957                               struct ieee80211_bss_conf *link_conf,
 958                               struct ieee80211_chanctx *ctx);
 959 int drv_switch_vif_chanctx(struct ieee80211_local *local,
 960                            struct ieee80211_vif_chanctx_switch *vifs,
 961                            int n_vifs, enum ieee80211_chanctx_switch_mode mode);
 962
 963 static inline int drv_start_ap(struct ieee80211_local *local,
 964                                struct ieee80211_sub_if_data *sdata,
 965                                struct ieee80211_bss_conf *link_conf)
 966 {
 967         int ret = 0;
 968
 969         /* make sure link_conf is protected */
 970         drv_verify_link_exists(sdata, link_conf);
 971
 972         might_sleep();
 973
 974         if (!check_sdata_in_driver(sdata))
 975                 return -EIO;
 976
 977         trace_drv_start_ap(local, sdata, link_conf);
 978         if (local->ops->start_ap)
 979                 ret = local->ops->start_ap(&local->hw, &sdata->vif, link_conf);
 980         trace_drv_return_int(local, ret);
 981         return ret;
 982 }
 983
 984 static inline void drv_stop_ap(struct ieee80211_local *local,
 985                                struct ieee80211_sub_if_data *sdata,
 986                                struct ieee80211_bss_conf *link_conf)
 987 {
 988         /* make sure link_conf is protected */
 989         drv_verify_link_exists(sdata, link_conf);
 990
 991         if (!check_sdata_in_driver(sdata))
 992                 return;
 993
 994         trace_drv_stop_ap(local, sdata, link_conf);
 995         if (local->ops->stop_ap)
 996                 local->ops->stop_ap(&local->hw, &sdata->vif, link_conf);
 997         trace_drv_return_void(local);
 998 }
 999
1000 static inline void
1001 drv_reconfig_complete(struct ieee80211_local *local,
1002                       enum ieee80211_reconfig_type reconfig_type)
1003 {
1004         might_sleep();
1005
1006         trace_drv_reconfig_complete(local, reconfig_type);
1007         if (local->ops->reconfig_complete)
1008                 local->ops->reconfig_complete(&local->hw, reconfig_type);
1009         trace_drv_return_void(local);
1010 }
1011
1012 static inline void
1013 drv_set_default_unicast_key(struct ieee80211_local *local,
1014                             struct ieee80211_sub_if_data *sdata,
1015                             int key_idx)
1016 {
1017         if (!check_sdata_in_driver(sdata))
1018                 return;
1019
1020         WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
1021
1022         trace_drv_set_default_unicast_key(local, sdata, key_idx);
1023         if (local->ops->set_default_unicast_key)
1024                 local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
1025                                                     key_idx);
1026         trace_drv_return_void(local);
1027 }
1028
1029 #if IS_ENABLED(CONFIG_IPV6)
1030 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
1031                                         struct ieee80211_sub_if_data *sdata,
1032                                         struct inet6_dev *idev)
1033 {
1034         trace_drv_ipv6_addr_change(local, sdata);
1035         if (local->ops->ipv6_addr_change)
1036                 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1037         trace_drv_return_void(local);
1038 }
1039 #endif
1040
1041 static inline void
1042 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1043                           struct cfg80211_chan_def *chandef)
1044 {
1045         struct ieee80211_local *local = sdata->local;
1046
1047         if (local->ops->channel_switch_beacon) {
1048                 trace_drv_channel_switch_beacon(local, sdata, chandef);
1049                 local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1050                                                   chandef);
1051         }
1052 }
1053
1054 static inline int
1055 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1056                        struct ieee80211_channel_switch *ch_switch)
1057 {
1058         struct ieee80211_local *local = sdata->local;
1059         int ret = 0;
1060
1061         if (!check_sdata_in_driver(sdata))
1062                 return -EIO;
1063
1064         trace_drv_pre_channel_switch(local, sdata, ch_switch);
1065         if (local->ops->pre_channel_switch)
1066                 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1067                                                      ch_switch);
1068         trace_drv_return_int(local, ret);
1069         return ret;
1070 }
1071
1072 static inline int
1073 drv_post_channel_switch(struct ieee80211_sub_if_data *sdata)
1074 {
1075         struct ieee80211_local *local = sdata->local;
1076         int ret = 0;
1077
1078         if (!check_sdata_in_driver(sdata))
1079                 return -EIO;
1080
1081         trace_drv_post_channel_switch(local, sdata);
1082         if (local->ops->post_channel_switch)
1083                 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif);
1084         trace_drv_return_int(local, ret);
1085         return ret;
1086 }
1087
1088 static inline void
1089 drv_abort_channel_switch(struct ieee80211_sub_if_data *sdata)
1090 {
1091         struct ieee80211_local *local = sdata->local;
1092
1093         if (!check_sdata_in_driver(sdata))
1094                 return;
1095
1096         trace_drv_abort_channel_switch(local, sdata);
1097
1098         if (local->ops->abort_channel_switch)
1099                 local->ops->abort_channel_switch(&local->hw, &sdata->vif);
1100 }
1101
1102 static inline void
1103 drv_channel_switch_rx_beacon(struct ieee80211_sub_if_data *sdata,
1104                              struct ieee80211_channel_switch *ch_switch)
1105 {
1106         struct ieee80211_local *local = sdata->local;
1107
1108         if (!check_sdata_in_driver(sdata))
1109                 return;
1110
1111         trace_drv_channel_switch_rx_beacon(local, sdata, ch_switch);
1112         if (local->ops->channel_switch_rx_beacon)
1113                 local->ops->channel_switch_rx_beacon(&local->hw, &sdata->vif,
1114                                                      ch_switch);
1115 }
1116
1117 static inline int drv_join_ibss(struct ieee80211_local *local,
1118                                 struct ieee80211_sub_if_data *sdata)
1119 {
1120         int ret = 0;
1121
1122         might_sleep();
1123         if (!check_sdata_in_driver(sdata))
1124                 return -EIO;
1125
1126         trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1127         if (local->ops->join_ibss)
1128                 ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1129         trace_drv_return_int(local, ret);
1130         return ret;
1131 }
1132
1133 static inline void drv_leave_ibss(struct ieee80211_local *local,
1134                                   struct ieee80211_sub_if_data *sdata)
1135 {
1136         might_sleep();
1137         if (!check_sdata_in_driver(sdata))
1138                 return;
1139
1140         trace_drv_leave_ibss(local, sdata);
1141         if (local->ops->leave_ibss)
1142                 local->ops->leave_ibss(&local->hw, &sdata->vif);
1143         trace_drv_return_void(local);
1144 }
1145
1146 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1147                                               struct sta_info *sta)
1148 {
1149         u32 ret = 0;
1150
1151         trace_drv_get_expected_throughput(&sta->sta);
1152         if (local->ops->get_expected_throughput && sta->uploaded)
1153                 ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1154         trace_drv_return_u32(local, ret);
1155
1156         return ret;
1157 }
1158
1159 static inline int drv_get_txpower(struct ieee80211_local *local,
1160                                   struct ieee80211_sub_if_data *sdata, int *dbm)
1161 {
1162         int ret;
1163
1164         if (!local->ops->get_txpower)
1165                 return -EOPNOTSUPP;
1166
1167         ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm);
1168         trace_drv_get_txpower(local, sdata, *dbm, ret);
1169
1170         return ret;
1171 }
1172
1173 static inline int
1174 drv_tdls_channel_switch(struct ieee80211_local *local,
1175                         struct ieee80211_sub_if_data *sdata,
1176                         struct ieee80211_sta *sta, u8 oper_class,
1177                         struct cfg80211_chan_def *chandef,
1178                         struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1179 {
1180         int ret;
1181
1182         might_sleep();
1183         if (!check_sdata_in_driver(sdata))
1184                 return -EIO;
1185
1186         if (!local->ops->tdls_channel_switch)
1187                 return -EOPNOTSUPP;
1188
1189         trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1190         ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1191                                               oper_class, chandef, tmpl_skb,
1192                                               ch_sw_tm_ie);
1193         trace_drv_return_int(local, ret);
1194         return ret;
1195 }
1196
1197 static inline void
1198 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1199                                struct ieee80211_sub_if_data *sdata,
1200                                struct ieee80211_sta *sta)
1201 {
1202         might_sleep();
1203         if (!check_sdata_in_driver(sdata))
1204                 return;
1205
1206         if (!local->ops->tdls_cancel_channel_switch)
1207                 return;
1208
1209         trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1210         local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1211         trace_drv_return_void(local);
1212 }
1213
1214 static inline void
1215 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1216                              struct ieee80211_sub_if_data *sdata,
1217                              struct ieee80211_tdls_ch_sw_params *params)
1218 {
1219         trace_drv_tdls_recv_channel_switch(local, sdata, params);
1220         if (local->ops->tdls_recv_channel_switch)
1221                 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1222                                                      params);
1223         trace_drv_return_void(local);
1224 }
1225
1226 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1227                                      struct txq_info *txq)
1228 {
1229         struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1230
1231         /* In reconfig don't transmit now, but mark for waking later */
1232         if (local->in_reconfig) {
1233                 set_bit(IEEE80211_TXQ_DIRTY, &txq->flags);
1234                 return;
1235         }
1236
1237         if (!check_sdata_in_driver(sdata))
1238                 return;
1239
1240         trace_drv_wake_tx_queue(local, sdata, txq);
1241         local->ops->wake_tx_queue(&local->hw, &txq->txq);
1242 }
1243
1244 static inline void schedule_and_wake_txq(struct ieee80211_local *local,
1245                                          struct txq_info *txqi)
1246 {
1247         ieee80211_schedule_txq(&local->hw, &txqi->txq);
1248         drv_wake_tx_queue(local, txqi);
1249 }
1250
1251 static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local,
1252                                              struct sk_buff *head,
1253                                              struct sk_buff *skb)
1254 {
1255         if (!local->ops->can_aggregate_in_amsdu)
1256                 return true;
1257
1258         return local->ops->can_aggregate_in_amsdu(&local->hw, head, skb);
1259 }
1260
1261 static inline int
1262 drv_get_ftm_responder_stats(struct ieee80211_local *local,
1263                             struct ieee80211_sub_if_data *sdata,
1264                             struct cfg80211_ftm_responder_stats *ftm_stats)
1265 {
1266         u32 ret = -EOPNOTSUPP;
1267
1268         if (local->ops->get_ftm_responder_stats)
1269                 ret = local->ops->get_ftm_responder_stats(&local->hw,
1270                                                          &sdata->vif,
1271                                                          ftm_stats);
1272         trace_drv_get_ftm_responder_stats(local, sdata, ftm_stats);
1273
1274         return ret;
1275 }
1276
1277 static inline int drv_start_pmsr(struct ieee80211_local *local,
1278                                  struct ieee80211_sub_if_data *sdata,
1279                                  struct cfg80211_pmsr_request *request)
1280 {
1281         int ret = -EOPNOTSUPP;
1282
1283         might_sleep();
1284         if (!check_sdata_in_driver(sdata))
1285                 return -EIO;
1286
1287         trace_drv_start_pmsr(local, sdata);
1288
1289         if (local->ops->start_pmsr)
1290                 ret = local->ops->start_pmsr(&local->hw, &sdata->vif, request);
1291         trace_drv_return_int(local, ret);
1292
1293         return ret;
1294 }
1295
1296 static inline void drv_abort_pmsr(struct ieee80211_local *local,
1297                                   struct ieee80211_sub_if_data *sdata,
1298                                   struct cfg80211_pmsr_request *request)
1299 {
1300         trace_drv_abort_pmsr(local, sdata);
1301
1302         might_sleep();
1303         if (!check_sdata_in_driver(sdata))
1304                 return;
1305
1306         if (local->ops->abort_pmsr)
1307                 local->ops->abort_pmsr(&local->hw, &sdata->vif, request);
1308         trace_drv_return_void(local);
1309 }
1310
1311 static inline int drv_start_nan(struct ieee80211_local *local,
1312                                 struct ieee80211_sub_if_data *sdata,
1313                                 struct cfg80211_nan_conf *conf)
1314 {
1315         int ret;
1316
1317         might_sleep();
1318         check_sdata_in_driver(sdata);
1319
1320         trace_drv_start_nan(local, sdata, conf);
1321         ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1322         trace_drv_return_int(local, ret);
1323         return ret;
1324 }
1325
1326 static inline void drv_stop_nan(struct ieee80211_local *local,
1327                                 struct ieee80211_sub_if_data *sdata)
1328 {
1329         might_sleep();
1330         check_sdata_in_driver(sdata);
1331
1332         trace_drv_stop_nan(local, sdata);
1333         local->ops->stop_nan(&local->hw, &sdata->vif);
1334         trace_drv_return_void(local);
1335 }
1336
1337 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1338                                        struct ieee80211_sub_if_data *sdata,
1339                                        struct cfg80211_nan_conf *conf,
1340                                        u32 changes)
1341 {
1342         int ret;
1343
1344         might_sleep();
1345         check_sdata_in_driver(sdata);
1346
1347         if (!local->ops->nan_change_conf)
1348                 return -EOPNOTSUPP;
1349
1350         trace_drv_nan_change_conf(local, sdata, conf, changes);
1351         ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1352                                           changes);
1353         trace_drv_return_int(local, ret);
1354
1355         return ret;
1356 }
1357
1358 static inline int drv_add_nan_func(struct ieee80211_local *local,
1359                                    struct ieee80211_sub_if_data *sdata,
1360                                    const struct cfg80211_nan_func *nan_func)
1361 {
1362         int ret;
1363
1364         might_sleep();
1365         check_sdata_in_driver(sdata);
1366
1367         if (!local->ops->add_nan_func)
1368                 return -EOPNOTSUPP;
1369
1370         trace_drv_add_nan_func(local, sdata, nan_func);
1371         ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1372         trace_drv_return_int(local, ret);
1373
1374         return ret;
1375 }
1376
1377 static inline void drv_del_nan_func(struct ieee80211_local *local,
1378                                    struct ieee80211_sub_if_data *sdata,
1379                                    u8 instance_id)
1380 {
1381         might_sleep();
1382         check_sdata_in_driver(sdata);
1383
1384         trace_drv_del_nan_func(local, sdata, instance_id);
1385         if (local->ops->del_nan_func)
1386                 local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1387         trace_drv_return_void(local);
1388 }
1389
1390 static inline int drv_set_tid_config(struct ieee80211_local *local,
1391                                      struct ieee80211_sub_if_data *sdata,
1392                                      struct ieee80211_sta *sta,
1393                                      struct cfg80211_tid_config *tid_conf)
1394 {
1395         int ret;
1396
1397         might_sleep();
1398         ret = local->ops->set_tid_config(&local->hw, &sdata->vif, sta,
1399                                          tid_conf);
1400         trace_drv_return_int(local, ret);
1401
1402         return ret;
1403 }
1404
1405 static inline int drv_reset_tid_config(struct ieee80211_local *local,
1406                                        struct ieee80211_sub_if_data *sdata,
1407                                        struct ieee80211_sta *sta, u8 tids)
1408 {
1409         int ret;
1410
1411         might_sleep();
1412         ret = local->ops->reset_tid_config(&local->hw, &sdata->vif, sta, tids);
1413         trace_drv_return_int(local, ret);
1414
1415         return ret;
1416 }
1417
1418 static inline void drv_update_vif_offload(struct ieee80211_local *local,
1419                                           struct ieee80211_sub_if_data *sdata)
1420 {
1421         might_sleep();
1422         check_sdata_in_driver(sdata);
1423
1424         if (!local->ops->update_vif_offload)
1425                 return;
1426
1427         trace_drv_update_vif_offload(local, sdata);
1428         local->ops->update_vif_offload(&local->hw, &sdata->vif);
1429         trace_drv_return_void(local);
1430 }
1431
1432 static inline void drv_sta_set_4addr(struct ieee80211_local *local,
1433                                      struct ieee80211_sub_if_data *sdata,
1434                                      struct ieee80211_sta *sta, bool enabled)
1435 {
1436         sdata = get_bss_sdata(sdata);
1437         if (!check_sdata_in_driver(sdata))
1438                 return;
1439
1440         trace_drv_sta_set_4addr(local, sdata, sta, enabled);
1441         if (local->ops->sta_set_4addr)
1442                 local->ops->sta_set_4addr(&local->hw, &sdata->vif, sta, enabled);
1443         trace_drv_return_void(local);
1444 }
1445
1446 static inline void drv_sta_set_decap_offload(struct ieee80211_local *local,
1447                                              struct ieee80211_sub_if_data *sdata,
1448                                              struct ieee80211_sta *sta,
1449                                              bool enabled)
1450 {
1451         sdata = get_bss_sdata(sdata);
1452         if (!check_sdata_in_driver(sdata))
1453                 return;
1454
1455         trace_drv_sta_set_decap_offload(local, sdata, sta, enabled);
1456         if (local->ops->sta_set_decap_offload)
1457                 local->ops->sta_set_decap_offload(&local->hw, &sdata->vif, sta,
1458                                                   enabled);
1459         trace_drv_return_void(local);
1460 }
1461
1462 static inline void drv_add_twt_setup(struct ieee80211_local *local,
1463                                      struct ieee80211_sub_if_data *sdata,
1464                                      struct ieee80211_sta *sta,
1465                                      struct ieee80211_twt_setup *twt)
1466 {
1467         struct ieee80211_twt_params *twt_agrt;
1468
1469         might_sleep();
1470
1471         if (!check_sdata_in_driver(sdata))
1472                 return;
1473
1474         twt_agrt = (void *)twt->params;
1475
1476         trace_drv_add_twt_setup(local, sta, twt, twt_agrt);
1477         local->ops->add_twt_setup(&local->hw, sta, twt);
1478         trace_drv_return_void(local);
1479 }
1480
1481 static inline void drv_twt_teardown_request(struct ieee80211_local *local,
1482                                             struct ieee80211_sub_if_data *sdata,
1483                                             struct ieee80211_sta *sta,
1484                                             u8 flowid)
1485 {
1486         might_sleep();
1487         if (!check_sdata_in_driver(sdata))
1488                 return;
1489
1490         if (!local->ops->twt_teardown_request)
1491                 return;
1492
1493         trace_drv_twt_teardown_request(local, sta, flowid);
1494         local->ops->twt_teardown_request(&local->hw, sta, flowid);
1495         trace_drv_return_void(local);
1496 }
1497
1498 static inline int drv_net_fill_forward_path(struct ieee80211_local *local,
1499                                             struct ieee80211_sub_if_data *sdata,
1500                                             struct ieee80211_sta *sta,
1501                                             struct net_device_path_ctx *ctx,
1502                                             struct net_device_path *path)
1503 {
1504         int ret = -EOPNOTSUPP;
1505
1506         sdata = get_bss_sdata(sdata);
1507         if (!check_sdata_in_driver(sdata))
1508                 return -EIO;
1509
1510         trace_drv_net_fill_forward_path(local, sdata, sta);
1511         if (local->ops->net_fill_forward_path)
1512                 ret = local->ops->net_fill_forward_path(&local->hw,
1513                                                         &sdata->vif, sta,
1514                                                         ctx, path);
1515         trace_drv_return_int(local, ret);
1516
1517         return ret;
1518 }
1519
1520 static inline int drv_net_setup_tc(struct ieee80211_local *local,
1521                                    struct ieee80211_sub_if_data *sdata,
1522                                    struct net_device *dev,
1523                                    enum tc_setup_type type, void *type_data)
1524 {
1525         int ret = -EOPNOTSUPP;
1526
1527         sdata = get_bss_sdata(sdata);
1528         trace_drv_net_setup_tc(local, sdata, type);
1529         if (local->ops->net_setup_tc)
1530                 ret = local->ops->net_setup_tc(&local->hw, &sdata->vif, dev,
1531                                                type, type_data);
1532         trace_drv_return_int(local, ret);
1533
1534         return ret;
1535 }
1536
1537 int drv_change_vif_links(struct ieee80211_local *local,
1538                          struct ieee80211_sub_if_data *sdata,
1539                          u16 old_links, u16 new_links,
1540                          struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]);
1541 int drv_change_sta_links(struct ieee80211_local *local,
1542                          struct ieee80211_sub_if_data *sdata,
1543                          struct ieee80211_sta *sta,
1544                          u16 old_links, u16 new_links);
1545
1546 #endif /* __MAC80211_DRIVER_OPS */