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