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 static inline 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         might_sleep();
 174
 175         if (WARN_ON_ONCE(changed & (BSS_CHANGED_BEACON |
 176                                     BSS_CHANGED_BEACON_ENABLED) &&
 177                          sdata->vif.type != NL80211_IFTYPE_AP &&
 178                          sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 179                          sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
 180                          sdata->vif.type != NL80211_IFTYPE_OCB))
 181                 return;
 182
 183         if (WARN_ON_ONCE(sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE ||
 184                          sdata->vif.type == NL80211_IFTYPE_NAN ||
 185                          (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
 186                           !sdata->vif.bss_conf.mu_mimo_owner &&
 187                           !(changed & BSS_CHANGED_TXPOWER))))
 188                 return;
 189
 190         if (!check_sdata_in_driver(sdata))
 191                 return;
 192
 193         trace_drv_link_info_changed(local, sdata, info, changed);
 194         if (local->ops->link_info_changed)
 195                 local->ops->link_info_changed(&local->hw, &sdata->vif,
 196                                               info, changed);
 197         else if (local->ops->bss_info_changed)
 198                 local->ops->bss_info_changed(&local->hw, &sdata->vif,
 199                                              info, changed);
 200         trace_drv_return_void(local);
 201 }
 202
 203 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
 204                                         struct netdev_hw_addr_list *mc_list)
 205 {
 206         u64 ret = 0;
 207
 208         trace_drv_prepare_multicast(local, mc_list->count);
 209
 210         if (local->ops->prepare_multicast)
 211                 ret = local->ops->prepare_multicast(&local->hw, mc_list);
 212
 213         trace_drv_return_u64(local, ret);
 214
 215         return ret;
 216 }
 217
 218 static inline void drv_configure_filter(struct ieee80211_local *local,
 219                                         unsigned int changed_flags,
 220                                         unsigned int *total_flags,
 221                                         u64 multicast)
 222 {
 223         might_sleep();
 224
 225         trace_drv_configure_filter(local, changed_flags, total_flags,
 226                                    multicast);
 227         local->ops->configure_filter(&local->hw, changed_flags, total_flags,
 228                                      multicast);
 229         trace_drv_return_void(local);
 230 }
 231
 232 static inline void drv_config_iface_filter(struct ieee80211_local *local,
 233                                            struct ieee80211_sub_if_data *sdata,
 234                                            unsigned int filter_flags,
 235                                            unsigned int changed_flags)
 236 {
 237         might_sleep();
 238
 239         trace_drv_config_iface_filter(local, sdata, filter_flags,
 240                                       changed_flags);
 241         if (local->ops->config_iface_filter)
 242                 local->ops->config_iface_filter(&local->hw, &sdata->vif,
 243                                                 filter_flags,
 244                                                 changed_flags);
 245         trace_drv_return_void(local);
 246 }
 247
 248 static inline int drv_set_tim(struct ieee80211_local *local,
 249                               struct ieee80211_sta *sta, bool set)
 250 {
 251         int ret = 0;
 252         trace_drv_set_tim(local, sta, set);
 253         if (local->ops->set_tim)
 254                 ret = local->ops->set_tim(&local->hw, sta, set);
 255         trace_drv_return_int(local, ret);
 256         return ret;
 257 }
 258
 259 static inline int drv_set_key(struct ieee80211_local *local,
 260                               enum set_key_cmd cmd,
 261                               struct ieee80211_sub_if_data *sdata,
 262                               struct ieee80211_sta *sta,
 263                               struct ieee80211_key_conf *key)
 264 {
 265         int ret;
 266
 267         might_sleep();
 268
 269         sdata = get_bss_sdata(sdata);
 270         if (!check_sdata_in_driver(sdata))
 271                 return -EIO;
 272
 273         trace_drv_set_key(local, cmd, sdata, sta, key);
 274         ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
 275         trace_drv_return_int(local, ret);
 276         return ret;
 277 }
 278
 279 static inline void drv_update_tkip_key(struct ieee80211_local *local,
 280                                        struct ieee80211_sub_if_data *sdata,
 281                                        struct ieee80211_key_conf *conf,
 282                                        struct sta_info *sta, u32 iv32,
 283                                        u16 *phase1key)
 284 {
 285         struct ieee80211_sta *ista = NULL;
 286
 287         if (sta)
 288                 ista = &sta->sta;
 289
 290         sdata = get_bss_sdata(sdata);
 291         if (!check_sdata_in_driver(sdata))
 292                 return;
 293
 294         trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
 295         if (local->ops->update_tkip_key)
 296                 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
 297                                             ista, iv32, phase1key);
 298         trace_drv_return_void(local);
 299 }
 300
 301 static inline int drv_hw_scan(struct ieee80211_local *local,
 302                               struct ieee80211_sub_if_data *sdata,
 303                               struct ieee80211_scan_request *req)
 304 {
 305         int ret;
 306
 307         might_sleep();
 308
 309         if (!check_sdata_in_driver(sdata))
 310                 return -EIO;
 311
 312         trace_drv_hw_scan(local, sdata);
 313         ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
 314         trace_drv_return_int(local, ret);
 315         return ret;
 316 }
 317
 318 static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
 319                                       struct ieee80211_sub_if_data *sdata)
 320 {
 321         might_sleep();
 322
 323         if (!check_sdata_in_driver(sdata))
 324                 return;
 325
 326         trace_drv_cancel_hw_scan(local, sdata);
 327         local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
 328         trace_drv_return_void(local);
 329 }
 330
 331 static inline int
 332 drv_sched_scan_start(struct ieee80211_local *local,
 333                      struct ieee80211_sub_if_data *sdata,
 334                      struct cfg80211_sched_scan_request *req,
 335                      struct ieee80211_scan_ies *ies)
 336 {
 337         int ret;
 338
 339         might_sleep();
 340
 341         if (!check_sdata_in_driver(sdata))
 342                 return -EIO;
 343
 344         trace_drv_sched_scan_start(local, sdata);
 345         ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
 346                                               req, ies);
 347         trace_drv_return_int(local, ret);
 348         return ret;
 349 }
 350
 351 static inline int drv_sched_scan_stop(struct ieee80211_local *local,
 352                                       struct ieee80211_sub_if_data *sdata)
 353 {
 354         int ret;
 355
 356         might_sleep();
 357
 358         if (!check_sdata_in_driver(sdata))
 359                 return -EIO;
 360
 361         trace_drv_sched_scan_stop(local, sdata);
 362         ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
 363         trace_drv_return_int(local, ret);
 364
 365         return ret;
 366 }
 367
 368 static inline void drv_sw_scan_start(struct ieee80211_local *local,
 369                                      struct ieee80211_sub_if_data *sdata,
 370                                      const u8 *mac_addr)
 371 {
 372         might_sleep();
 373
 374         trace_drv_sw_scan_start(local, sdata, mac_addr);
 375         if (local->ops->sw_scan_start)
 376                 local->ops->sw_scan_start(&local->hw, &sdata->vif, mac_addr);
 377         trace_drv_return_void(local);
 378 }
 379
 380 static inline void drv_sw_scan_complete(struct ieee80211_local *local,
 381                                         struct ieee80211_sub_if_data *sdata)
 382 {
 383         might_sleep();
 384
 385         trace_drv_sw_scan_complete(local, sdata);
 386         if (local->ops->sw_scan_complete)
 387                 local->ops->sw_scan_complete(&local->hw, &sdata->vif);
 388         trace_drv_return_void(local);
 389 }
 390
 391 static inline int drv_get_stats(struct ieee80211_local *local,
 392                                 struct ieee80211_low_level_stats *stats)
 393 {
 394         int ret = -EOPNOTSUPP;
 395
 396         might_sleep();
 397
 398         if (local->ops->get_stats)
 399                 ret = local->ops->get_stats(&local->hw, stats);
 400         trace_drv_get_stats(local, stats, ret);
 401
 402         return ret;
 403 }
 404
 405 static inline void drv_get_key_seq(struct ieee80211_local *local,
 406                                    struct ieee80211_key *key,
 407                                    struct ieee80211_key_seq *seq)
 408 {
 409         if (local->ops->get_key_seq)
 410                 local->ops->get_key_seq(&local->hw, &key->conf, seq);
 411         trace_drv_get_key_seq(local, &key->conf);
 412 }
 413
 414 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
 415                                         u32 value)
 416 {
 417         int ret = 0;
 418
 419         might_sleep();
 420
 421         trace_drv_set_frag_threshold(local, value);
 422         if (local->ops->set_frag_threshold)
 423                 ret = local->ops->set_frag_threshold(&local->hw, value);
 424         trace_drv_return_int(local, ret);
 425         return ret;
 426 }
 427
 428 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
 429                                         u32 value)
 430 {
 431         int ret = 0;
 432
 433         might_sleep();
 434
 435         trace_drv_set_rts_threshold(local, value);
 436         if (local->ops->set_rts_threshold)
 437                 ret = local->ops->set_rts_threshold(&local->hw, value);
 438         trace_drv_return_int(local, ret);
 439         return ret;
 440 }
 441
 442 static inline int drv_set_coverage_class(struct ieee80211_local *local,
 443                                          s16 value)
 444 {
 445         int ret = 0;
 446         might_sleep();
 447
 448         trace_drv_set_coverage_class(local, value);
 449         if (local->ops->set_coverage_class)
 450                 local->ops->set_coverage_class(&local->hw, value);
 451         else
 452                 ret = -EOPNOTSUPP;
 453
 454         trace_drv_return_int(local, ret);
 455         return ret;
 456 }
 457
 458 static inline void drv_sta_notify(struct ieee80211_local *local,
 459                                   struct ieee80211_sub_if_data *sdata,
 460                                   enum sta_notify_cmd cmd,
 461                                   struct ieee80211_sta *sta)
 462 {
 463         sdata = get_bss_sdata(sdata);
 464         if (!check_sdata_in_driver(sdata))
 465                 return;
 466
 467         trace_drv_sta_notify(local, sdata, cmd, sta);
 468         if (local->ops->sta_notify)
 469                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
 470         trace_drv_return_void(local);
 471 }
 472
 473 static inline int drv_sta_add(struct ieee80211_local *local,
 474                               struct ieee80211_sub_if_data *sdata,
 475                               struct ieee80211_sta *sta)
 476 {
 477         int ret = 0;
 478
 479         might_sleep();
 480
 481         sdata = get_bss_sdata(sdata);
 482         if (!check_sdata_in_driver(sdata))
 483                 return -EIO;
 484
 485         trace_drv_sta_add(local, sdata, sta);
 486         if (local->ops->sta_add)
 487                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
 488
 489         trace_drv_return_int(local, ret);
 490
 491         return ret;
 492 }
 493
 494 static inline void drv_sta_remove(struct ieee80211_local *local,
 495                                   struct ieee80211_sub_if_data *sdata,
 496                                   struct ieee80211_sta *sta)
 497 {
 498         might_sleep();
 499
 500         sdata = get_bss_sdata(sdata);
 501         if (!check_sdata_in_driver(sdata))
 502                 return;
 503
 504         trace_drv_sta_remove(local, sdata, sta);
 505         if (local->ops->sta_remove)
 506                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
 507
 508         trace_drv_return_void(local);
 509 }
 510
 511 #ifdef CONFIG_MAC80211_DEBUGFS
 512 static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
 513                                        struct ieee80211_sub_if_data *sdata,
 514                                        struct ieee80211_sta *sta,
 515                                        struct dentry *dir)
 516 {
 517         might_sleep();
 518
 519         sdata = get_bss_sdata(sdata);
 520         if (!check_sdata_in_driver(sdata))
 521                 return;
 522
 523         if (local->ops->sta_add_debugfs)
 524                 local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
 525                                             sta, dir);
 526 }
 527 #endif
 528
 529 static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
 530                                           struct ieee80211_sub_if_data *sdata,
 531                                           struct sta_info *sta)
 532 {
 533         might_sleep();
 534
 535         sdata = get_bss_sdata(sdata);
 536         if (!check_sdata_in_driver(sdata))
 537                 return;
 538
 539         trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
 540         if (local->ops->sta_pre_rcu_remove)
 541                 local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
 542                                                &sta->sta);
 543         trace_drv_return_void(local);
 544 }
 545
 546 __must_check
 547 int drv_sta_state(struct ieee80211_local *local,
 548                   struct ieee80211_sub_if_data *sdata,
 549                   struct sta_info *sta,
 550                   enum ieee80211_sta_state old_state,
 551                   enum ieee80211_sta_state new_state);
 552
 553 __must_check
 554 int drv_sta_set_txpwr(struct ieee80211_local *local,
 555                       struct ieee80211_sub_if_data *sdata,
 556                       struct sta_info *sta);
 557
 558 void drv_sta_rc_update(struct ieee80211_local *local,
 559                        struct ieee80211_sub_if_data *sdata,
 560                        struct ieee80211_sta *sta, u32 changed);
 561
 562 static inline void drv_sta_rate_tbl_update(struct ieee80211_local *local,
 563                                            struct ieee80211_sub_if_data *sdata,
 564                                            struct ieee80211_sta *sta)
 565 {
 566         sdata = get_bss_sdata(sdata);
 567         if (!check_sdata_in_driver(sdata))
 568                 return;
 569
 570         trace_drv_sta_rate_tbl_update(local, sdata, sta);
 571         if (local->ops->sta_rate_tbl_update)
 572                 local->ops->sta_rate_tbl_update(&local->hw, &sdata->vif, sta);
 573
 574         trace_drv_return_void(local);
 575 }
 576
 577 static inline void drv_sta_statistics(struct ieee80211_local *local,
 578                                       struct ieee80211_sub_if_data *sdata,
 579                                       struct ieee80211_sta *sta,
 580                                       struct station_info *sinfo)
 581 {
 582         sdata = get_bss_sdata(sdata);
 583         if (!check_sdata_in_driver(sdata))
 584                 return;
 585
 586         trace_drv_sta_statistics(local, sdata, sta);
 587         if (local->ops->sta_statistics)
 588                 local->ops->sta_statistics(&local->hw, &sdata->vif, sta, sinfo);
 589         trace_drv_return_void(local);
 590 }
 591
 592 int drv_conf_tx(struct ieee80211_local *local,
 593                 struct ieee80211_link_data *link, u16 ac,
 594                 const struct ieee80211_tx_queue_params *params);
 595
 596 u64 drv_get_tsf(struct ieee80211_local *local,
 597                 struct ieee80211_sub_if_data *sdata);
 598 void drv_set_tsf(struct ieee80211_local *local,
 599                  struct ieee80211_sub_if_data *sdata,
 600                  u64 tsf);
 601 void drv_offset_tsf(struct ieee80211_local *local,
 602                     struct ieee80211_sub_if_data *sdata,
 603                     s64 offset);
 604 void drv_reset_tsf(struct ieee80211_local *local,
 605                    struct ieee80211_sub_if_data *sdata);
 606
 607 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
 608 {
 609         int ret = 0; /* default unsupported op for less congestion */
 610
 611         might_sleep();
 612
 613         trace_drv_tx_last_beacon(local);
 614         if (local->ops->tx_last_beacon)
 615                 ret = local->ops->tx_last_beacon(&local->hw);
 616         trace_drv_return_int(local, ret);
 617         return ret;
 618 }
 619
 620 int drv_ampdu_action(struct ieee80211_local *local,
 621                      struct ieee80211_sub_if_data *sdata,
 622                      struct ieee80211_ampdu_params *params);
 623
 624 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
 625                                 struct survey_info *survey)
 626 {
 627         int ret = -EOPNOTSUPP;
 628
 629         trace_drv_get_survey(local, idx, survey);
 630
 631         if (local->ops->get_survey)
 632                 ret = local->ops->get_survey(&local->hw, idx, survey);
 633
 634         trace_drv_return_int(local, ret);
 635
 636         return ret;
 637 }
 638
 639 static inline void drv_rfkill_poll(struct ieee80211_local *local)
 640 {
 641         might_sleep();
 642
 643         if (local->ops->rfkill_poll)
 644                 local->ops->rfkill_poll(&local->hw);
 645 }
 646
 647 static inline void drv_flush(struct ieee80211_local *local,
 648                              struct ieee80211_sub_if_data *sdata,
 649                              u32 queues, bool drop)
 650 {
 651         struct ieee80211_vif *vif = sdata ? &sdata->vif : NULL;
 652
 653         might_sleep();
 654
 655         if (sdata && !check_sdata_in_driver(sdata))
 656                 return;
 657
 658         trace_drv_flush(local, queues, drop);
 659         if (local->ops->flush)
 660                 local->ops->flush(&local->hw, vif, queues, drop);
 661         trace_drv_return_void(local);
 662 }
 663
 664 static inline void drv_channel_switch(struct ieee80211_local *local,
 665                                       struct ieee80211_sub_if_data *sdata,
 666                                       struct ieee80211_channel_switch *ch_switch)
 667 {
 668         might_sleep();
 669
 670         trace_drv_channel_switch(local, sdata, ch_switch);
 671         local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch);
 672         trace_drv_return_void(local);
 673 }
 674
 675
 676 static inline int drv_set_antenna(struct ieee80211_local *local,
 677                                   u32 tx_ant, u32 rx_ant)
 678 {
 679         int ret = -EOPNOTSUPP;
 680         might_sleep();
 681         if (local->ops->set_antenna)
 682                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
 683         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
 684         return ret;
 685 }
 686
 687 static inline int drv_get_antenna(struct ieee80211_local *local,
 688                                   u32 *tx_ant, u32 *rx_ant)
 689 {
 690         int ret = -EOPNOTSUPP;
 691         might_sleep();
 692         if (local->ops->get_antenna)
 693                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
 694         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
 695         return ret;
 696 }
 697
 698 static inline int drv_remain_on_channel(struct ieee80211_local *local,
 699                                         struct ieee80211_sub_if_data *sdata,
 700                                         struct ieee80211_channel *chan,
 701                                         unsigned int duration,
 702                                         enum ieee80211_roc_type type)
 703 {
 704         int ret;
 705
 706         might_sleep();
 707
 708         trace_drv_remain_on_channel(local, sdata, chan, duration, type);
 709         ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
 710                                             chan, duration, type);
 711         trace_drv_return_int(local, ret);
 712
 713         return ret;
 714 }
 715
 716 static inline int
 717 drv_cancel_remain_on_channel(struct ieee80211_local *local,
 718                              struct ieee80211_sub_if_data *sdata)
 719 {
 720         int ret;
 721
 722         might_sleep();
 723
 724         trace_drv_cancel_remain_on_channel(local, sdata);
 725         ret = local->ops->cancel_remain_on_channel(&local->hw, &sdata->vif);
 726         trace_drv_return_int(local, ret);
 727
 728         return ret;
 729 }
 730
 731 static inline int drv_set_ringparam(struct ieee80211_local *local,
 732                                     u32 tx, u32 rx)
 733 {
 734         int ret = -ENOTSUPP;
 735
 736         might_sleep();
 737
 738         trace_drv_set_ringparam(local, tx, rx);
 739         if (local->ops->set_ringparam)
 740                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 741         trace_drv_return_int(local, ret);
 742
 743         return ret;
 744 }
 745
 746 static inline void drv_get_ringparam(struct ieee80211_local *local,
 747                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 748 {
 749         might_sleep();
 750
 751         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 752         if (local->ops->get_ringparam)
 753                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 754         trace_drv_return_void(local);
 755 }
 756
 757 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
 758 {
 759         bool ret = false;
 760
 761         might_sleep();
 762
 763         trace_drv_tx_frames_pending(local);
 764         if (local->ops->tx_frames_pending)
 765                 ret = local->ops->tx_frames_pending(&local->hw);
 766         trace_drv_return_bool(local, ret);
 767
 768         return ret;
 769 }
 770
 771 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
 772                                        struct ieee80211_sub_if_data *sdata,
 773                                        const struct cfg80211_bitrate_mask *mask)
 774 {
 775         int ret = -EOPNOTSUPP;
 776
 777         might_sleep();
 778
 779         if (!check_sdata_in_driver(sdata))
 780                 return -EIO;
 781
 782         trace_drv_set_bitrate_mask(local, sdata, mask);
 783         if (local->ops->set_bitrate_mask)
 784                 ret = local->ops->set_bitrate_mask(&local->hw,
 785                                                    &sdata->vif, mask);
 786         trace_drv_return_int(local, ret);
 787
 788         return ret;
 789 }
 790
 791 static inline void drv_set_rekey_data(struct ieee80211_local *local,
 792                                       struct ieee80211_sub_if_data *sdata,
 793                                       struct cfg80211_gtk_rekey_data *data)
 794 {
 795         if (!check_sdata_in_driver(sdata))
 796                 return;
 797
 798         trace_drv_set_rekey_data(local, sdata, data);
 799         if (local->ops->set_rekey_data)
 800                 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
 801         trace_drv_return_void(local);
 802 }
 803
 804 static inline void drv_event_callback(struct ieee80211_local *local,
 805                                       struct ieee80211_sub_if_data *sdata,
 806                                       const struct ieee80211_event *event)
 807 {
 808         trace_drv_event_callback(local, sdata, event);
 809         if (local->ops->event_callback)
 810                 local->ops->event_callback(&local->hw, &sdata->vif, event);
 811         trace_drv_return_void(local);
 812 }
 813
 814 static inline void
 815 drv_release_buffered_frames(struct ieee80211_local *local,
 816                             struct sta_info *sta, u16 tids, int num_frames,
 817                             enum ieee80211_frame_release_type reason,
 818                             bool more_data)
 819 {
 820         trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
 821                                           reason, more_data);
 822         if (local->ops->release_buffered_frames)
 823                 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
 824                                                     num_frames, reason,
 825                                                     more_data);
 826         trace_drv_return_void(local);
 827 }
 828
 829 static inline void
 830 drv_allow_buffered_frames(struct ieee80211_local *local,
 831                           struct sta_info *sta, u16 tids, int num_frames,
 832                           enum ieee80211_frame_release_type reason,
 833                           bool more_data)
 834 {
 835         trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
 836                                         reason, more_data);
 837         if (local->ops->allow_buffered_frames)
 838                 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
 839                                                   tids, num_frames, reason,
 840                                                   more_data);
 841         trace_drv_return_void(local);
 842 }
 843
 844 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
 845                                       struct ieee80211_sub_if_data *sdata,
 846                                       struct ieee80211_prep_tx_info *info)
 847 {
 848         might_sleep();
 849
 850         if (!check_sdata_in_driver(sdata))
 851                 return;
 852         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 853
 854         trace_drv_mgd_prepare_tx(local, sdata, info->duration,
 855                                  info->subtype, info->success);
 856         if (local->ops->mgd_prepare_tx)
 857                 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif, info);
 858         trace_drv_return_void(local);
 859 }
 860
 861 static inline void drv_mgd_complete_tx(struct ieee80211_local *local,
 862                                        struct ieee80211_sub_if_data *sdata,
 863                                        struct ieee80211_prep_tx_info *info)
 864 {
 865         might_sleep();
 866
 867         if (!check_sdata_in_driver(sdata))
 868                 return;
 869         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 870
 871         trace_drv_mgd_complete_tx(local, sdata, info->duration,
 872                                   info->subtype, info->success);
 873         if (local->ops->mgd_complete_tx)
 874                 local->ops->mgd_complete_tx(&local->hw, &sdata->vif, info);
 875         trace_drv_return_void(local);
 876 }
 877
 878 static inline void
 879 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
 880                               struct ieee80211_sub_if_data *sdata)
 881 {
 882         might_sleep();
 883
 884         if (!check_sdata_in_driver(sdata))
 885                 return;
 886         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 887
 888         trace_drv_mgd_protect_tdls_discover(local, sdata);
 889         if (local->ops->mgd_protect_tdls_discover)
 890                 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif);
 891         trace_drv_return_void(local);
 892 }
 893
 894 static inline int drv_add_chanctx(struct ieee80211_local *local,
 895                                   struct ieee80211_chanctx *ctx)
 896 {
 897         int ret = -EOPNOTSUPP;
 898
 899         might_sleep();
 900
 901         trace_drv_add_chanctx(local, ctx);
 902         if (local->ops->add_chanctx)
 903                 ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
 904         trace_drv_return_int(local, ret);
 905         if (!ret)
 906                 ctx->driver_present = true;
 907
 908         return ret;
 909 }
 910
 911 static inline void drv_remove_chanctx(struct ieee80211_local *local,
 912                                       struct ieee80211_chanctx *ctx)
 913 {
 914         might_sleep();
 915
 916         if (WARN_ON(!ctx->driver_present))
 917                 return;
 918
 919         trace_drv_remove_chanctx(local, ctx);
 920         if (local->ops->remove_chanctx)
 921                 local->ops->remove_chanctx(&local->hw, &ctx->conf);
 922         trace_drv_return_void(local);
 923         ctx->driver_present = false;
 924 }
 925
 926 static inline void drv_change_chanctx(struct ieee80211_local *local,
 927                                       struct ieee80211_chanctx *ctx,
 928                                       u32 changed)
 929 {
 930         might_sleep();
 931
 932         trace_drv_change_chanctx(local, ctx, changed);
 933         if (local->ops->change_chanctx) {
 934                 WARN_ON_ONCE(!ctx->driver_present);
 935                 local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
 936         }
 937         trace_drv_return_void(local);
 938 }
 939
 940 static inline void drv_verify_link_exists(struct ieee80211_sub_if_data *sdata,
 941                                           struct ieee80211_bss_conf *link_conf)
 942 {
 943         /* deflink always exists, so need to check only for other links */
 944         if (sdata->deflink.conf != link_conf)
 945                 sdata_assert_lock(sdata);
 946 }
 947
 948 static inline int drv_assign_vif_chanctx(struct ieee80211_local *local,
 949                                          struct ieee80211_sub_if_data *sdata,
 950                                          struct ieee80211_bss_conf *link_conf,
 951                                          struct ieee80211_chanctx *ctx)
 952 {
 953         int ret = 0;
 954
 955         drv_verify_link_exists(sdata, link_conf);
 956         if (!check_sdata_in_driver(sdata))
 957                 return -EIO;
 958
 959         trace_drv_assign_vif_chanctx(local, sdata, link_conf, ctx);
 960         if (local->ops->assign_vif_chanctx) {
 961                 WARN_ON_ONCE(!ctx->driver_present);
 962                 ret = local->ops->assign_vif_chanctx(&local->hw,
 963                                                      &sdata->vif,
 964                                                      link_conf,
 965                                                      &ctx->conf);
 966         }
 967         trace_drv_return_int(local, ret);
 968
 969         return ret;
 970 }
 971
 972 static inline void drv_unassign_vif_chanctx(struct ieee80211_local *local,
 973                                             struct ieee80211_sub_if_data *sdata,
 974                                             struct ieee80211_bss_conf *link_conf,
 975                                             struct ieee80211_chanctx *ctx)
 976 {
 977         might_sleep();
 978
 979         drv_verify_link_exists(sdata, link_conf);
 980         if (!check_sdata_in_driver(sdata))
 981                 return;
 982
 983         trace_drv_unassign_vif_chanctx(local, sdata, link_conf, ctx);
 984         if (local->ops->unassign_vif_chanctx) {
 985                 WARN_ON_ONCE(!ctx->driver_present);
 986                 local->ops->unassign_vif_chanctx(&local->hw,
 987                                                  &sdata->vif,
 988                                                  link_conf,
 989                                                  &ctx->conf);
 990         }
 991         trace_drv_return_void(local);
 992 }
 993
 994 int drv_switch_vif_chanctx(struct ieee80211_local *local,
 995                            struct ieee80211_vif_chanctx_switch *vifs,
 996                            int n_vifs, enum ieee80211_chanctx_switch_mode mode);
 997
 998 static inline int drv_start_ap(struct ieee80211_local *local,
 999                                struct ieee80211_sub_if_data *sdata,
1000                                struct ieee80211_bss_conf *link_conf)
1001 {
1002         int ret = 0;
1003
1004         /* make sure link_conf is protected */
1005         drv_verify_link_exists(sdata, link_conf);
1006
1007         might_sleep();
1008
1009         if (!check_sdata_in_driver(sdata))
1010                 return -EIO;
1011
1012         trace_drv_start_ap(local, sdata, link_conf);
1013         if (local->ops->start_ap)
1014                 ret = local->ops->start_ap(&local->hw, &sdata->vif, link_conf);
1015         trace_drv_return_int(local, ret);
1016         return ret;
1017 }
1018
1019 static inline void drv_stop_ap(struct ieee80211_local *local,
1020                                struct ieee80211_sub_if_data *sdata,
1021                                struct ieee80211_bss_conf *link_conf)
1022 {
1023         /* make sure link_conf is protected */
1024         drv_verify_link_exists(sdata, link_conf);
1025
1026         if (!check_sdata_in_driver(sdata))
1027                 return;
1028
1029         trace_drv_stop_ap(local, sdata, link_conf);
1030         if (local->ops->stop_ap)
1031                 local->ops->stop_ap(&local->hw, &sdata->vif, link_conf);
1032         trace_drv_return_void(local);
1033 }
1034
1035 static inline void
1036 drv_reconfig_complete(struct ieee80211_local *local,
1037                       enum ieee80211_reconfig_type reconfig_type)
1038 {
1039         might_sleep();
1040
1041         trace_drv_reconfig_complete(local, reconfig_type);
1042         if (local->ops->reconfig_complete)
1043                 local->ops->reconfig_complete(&local->hw, reconfig_type);
1044         trace_drv_return_void(local);
1045 }
1046
1047 static inline void
1048 drv_set_default_unicast_key(struct ieee80211_local *local,
1049                             struct ieee80211_sub_if_data *sdata,
1050                             int key_idx)
1051 {
1052         if (!check_sdata_in_driver(sdata))
1053                 return;
1054
1055         WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
1056
1057         trace_drv_set_default_unicast_key(local, sdata, key_idx);
1058         if (local->ops->set_default_unicast_key)
1059                 local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
1060                                                     key_idx);
1061         trace_drv_return_void(local);
1062 }
1063
1064 #if IS_ENABLED(CONFIG_IPV6)
1065 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
1066                                         struct ieee80211_sub_if_data *sdata,
1067                                         struct inet6_dev *idev)
1068 {
1069         trace_drv_ipv6_addr_change(local, sdata);
1070         if (local->ops->ipv6_addr_change)
1071                 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1072         trace_drv_return_void(local);
1073 }
1074 #endif
1075
1076 static inline void
1077 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1078                           struct cfg80211_chan_def *chandef)
1079 {
1080         struct ieee80211_local *local = sdata->local;
1081
1082         if (local->ops->channel_switch_beacon) {
1083                 trace_drv_channel_switch_beacon(local, sdata, chandef);
1084                 local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1085                                                   chandef);
1086         }
1087 }
1088
1089 static inline int
1090 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1091                        struct ieee80211_channel_switch *ch_switch)
1092 {
1093         struct ieee80211_local *local = sdata->local;
1094         int ret = 0;
1095
1096         if (!check_sdata_in_driver(sdata))
1097                 return -EIO;
1098
1099         trace_drv_pre_channel_switch(local, sdata, ch_switch);
1100         if (local->ops->pre_channel_switch)
1101                 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1102                                                      ch_switch);
1103         trace_drv_return_int(local, ret);
1104         return ret;
1105 }
1106
1107 static inline int
1108 drv_post_channel_switch(struct ieee80211_sub_if_data *sdata)
1109 {
1110         struct ieee80211_local *local = sdata->local;
1111         int ret = 0;
1112
1113         if (!check_sdata_in_driver(sdata))
1114                 return -EIO;
1115
1116         trace_drv_post_channel_switch(local, sdata);
1117         if (local->ops->post_channel_switch)
1118                 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif);
1119         trace_drv_return_int(local, ret);
1120         return ret;
1121 }
1122
1123 static inline void
1124 drv_abort_channel_switch(struct ieee80211_sub_if_data *sdata)
1125 {
1126         struct ieee80211_local *local = sdata->local;
1127
1128         if (!check_sdata_in_driver(sdata))
1129                 return;
1130
1131         trace_drv_abort_channel_switch(local, sdata);
1132
1133         if (local->ops->abort_channel_switch)
1134                 local->ops->abort_channel_switch(&local->hw, &sdata->vif);
1135 }
1136
1137 static inline void
1138 drv_channel_switch_rx_beacon(struct ieee80211_sub_if_data *sdata,
1139                              struct ieee80211_channel_switch *ch_switch)
1140 {
1141         struct ieee80211_local *local = sdata->local;
1142
1143         if (!check_sdata_in_driver(sdata))
1144                 return;
1145
1146         trace_drv_channel_switch_rx_beacon(local, sdata, ch_switch);
1147         if (local->ops->channel_switch_rx_beacon)
1148                 local->ops->channel_switch_rx_beacon(&local->hw, &sdata->vif,
1149                                                      ch_switch);
1150 }
1151
1152 static inline int drv_join_ibss(struct ieee80211_local *local,
1153                                 struct ieee80211_sub_if_data *sdata)
1154 {
1155         int ret = 0;
1156
1157         might_sleep();
1158         if (!check_sdata_in_driver(sdata))
1159                 return -EIO;
1160
1161         trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1162         if (local->ops->join_ibss)
1163                 ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1164         trace_drv_return_int(local, ret);
1165         return ret;
1166 }
1167
1168 static inline void drv_leave_ibss(struct ieee80211_local *local,
1169                                   struct ieee80211_sub_if_data *sdata)
1170 {
1171         might_sleep();
1172         if (!check_sdata_in_driver(sdata))
1173                 return;
1174
1175         trace_drv_leave_ibss(local, sdata);
1176         if (local->ops->leave_ibss)
1177                 local->ops->leave_ibss(&local->hw, &sdata->vif);
1178         trace_drv_return_void(local);
1179 }
1180
1181 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1182                                               struct sta_info *sta)
1183 {
1184         u32 ret = 0;
1185
1186         trace_drv_get_expected_throughput(&sta->sta);
1187         if (local->ops->get_expected_throughput && sta->uploaded)
1188                 ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1189         trace_drv_return_u32(local, ret);
1190
1191         return ret;
1192 }
1193
1194 static inline int drv_get_txpower(struct ieee80211_local *local,
1195                                   struct ieee80211_sub_if_data *sdata, int *dbm)
1196 {
1197         int ret;
1198
1199         if (!local->ops->get_txpower)
1200                 return -EOPNOTSUPP;
1201
1202         ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm);
1203         trace_drv_get_txpower(local, sdata, *dbm, ret);
1204
1205         return ret;
1206 }
1207
1208 static inline int
1209 drv_tdls_channel_switch(struct ieee80211_local *local,
1210                         struct ieee80211_sub_if_data *sdata,
1211                         struct ieee80211_sta *sta, u8 oper_class,
1212                         struct cfg80211_chan_def *chandef,
1213                         struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1214 {
1215         int ret;
1216
1217         might_sleep();
1218         if (!check_sdata_in_driver(sdata))
1219                 return -EIO;
1220
1221         if (!local->ops->tdls_channel_switch)
1222                 return -EOPNOTSUPP;
1223
1224         trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1225         ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1226                                               oper_class, chandef, tmpl_skb,
1227                                               ch_sw_tm_ie);
1228         trace_drv_return_int(local, ret);
1229         return ret;
1230 }
1231
1232 static inline void
1233 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1234                                struct ieee80211_sub_if_data *sdata,
1235                                struct ieee80211_sta *sta)
1236 {
1237         might_sleep();
1238         if (!check_sdata_in_driver(sdata))
1239                 return;
1240
1241         if (!local->ops->tdls_cancel_channel_switch)
1242                 return;
1243
1244         trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1245         local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1246         trace_drv_return_void(local);
1247 }
1248
1249 static inline void
1250 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1251                              struct ieee80211_sub_if_data *sdata,
1252                              struct ieee80211_tdls_ch_sw_params *params)
1253 {
1254         trace_drv_tdls_recv_channel_switch(local, sdata, params);
1255         if (local->ops->tdls_recv_channel_switch)
1256                 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1257                                                      params);
1258         trace_drv_return_void(local);
1259 }
1260
1261 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1262                                      struct txq_info *txq)
1263 {
1264         struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1265
1266         /* In reconfig don't transmit now, but mark for waking later */
1267         if (local->in_reconfig) {
1268                 set_bit(IEEE80211_TXQ_STOP_NETIF_TX, &txq->flags);
1269                 return;
1270         }
1271
1272         if (!check_sdata_in_driver(sdata))
1273                 return;
1274
1275         trace_drv_wake_tx_queue(local, sdata, txq);
1276         local->ops->wake_tx_queue(&local->hw, &txq->txq);
1277 }
1278
1279 static inline void schedule_and_wake_txq(struct ieee80211_local *local,
1280                                          struct txq_info *txqi)
1281 {
1282         ieee80211_schedule_txq(&local->hw, &txqi->txq);
1283         drv_wake_tx_queue(local, txqi);
1284 }
1285
1286 static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local,
1287                                              struct sk_buff *head,
1288                                              struct sk_buff *skb)
1289 {
1290         if (!local->ops->can_aggregate_in_amsdu)
1291                 return true;
1292
1293         return local->ops->can_aggregate_in_amsdu(&local->hw, head, skb);
1294 }
1295
1296 static inline int
1297 drv_get_ftm_responder_stats(struct ieee80211_local *local,
1298                             struct ieee80211_sub_if_data *sdata,
1299                             struct cfg80211_ftm_responder_stats *ftm_stats)
1300 {
1301         u32 ret = -EOPNOTSUPP;
1302
1303         if (local->ops->get_ftm_responder_stats)
1304                 ret = local->ops->get_ftm_responder_stats(&local->hw,
1305                                                          &sdata->vif,
1306                                                          ftm_stats);
1307         trace_drv_get_ftm_responder_stats(local, sdata, ftm_stats);
1308
1309         return ret;
1310 }
1311
1312 static inline int drv_start_pmsr(struct ieee80211_local *local,
1313                                  struct ieee80211_sub_if_data *sdata,
1314                                  struct cfg80211_pmsr_request *request)
1315 {
1316         int ret = -EOPNOTSUPP;
1317
1318         might_sleep();
1319         if (!check_sdata_in_driver(sdata))
1320                 return -EIO;
1321
1322         trace_drv_start_pmsr(local, sdata);
1323
1324         if (local->ops->start_pmsr)
1325                 ret = local->ops->start_pmsr(&local->hw, &sdata->vif, request);
1326         trace_drv_return_int(local, ret);
1327
1328         return ret;
1329 }
1330
1331 static inline void drv_abort_pmsr(struct ieee80211_local *local,
1332                                   struct ieee80211_sub_if_data *sdata,
1333                                   struct cfg80211_pmsr_request *request)
1334 {
1335         trace_drv_abort_pmsr(local, sdata);
1336
1337         might_sleep();
1338         if (!check_sdata_in_driver(sdata))
1339                 return;
1340
1341         if (local->ops->abort_pmsr)
1342                 local->ops->abort_pmsr(&local->hw, &sdata->vif, request);
1343         trace_drv_return_void(local);
1344 }
1345
1346 static inline int drv_start_nan(struct ieee80211_local *local,
1347                                 struct ieee80211_sub_if_data *sdata,
1348                                 struct cfg80211_nan_conf *conf)
1349 {
1350         int ret;
1351
1352         might_sleep();
1353         check_sdata_in_driver(sdata);
1354
1355         trace_drv_start_nan(local, sdata, conf);
1356         ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1357         trace_drv_return_int(local, ret);
1358         return ret;
1359 }
1360
1361 static inline void drv_stop_nan(struct ieee80211_local *local,
1362                                 struct ieee80211_sub_if_data *sdata)
1363 {
1364         might_sleep();
1365         check_sdata_in_driver(sdata);
1366
1367         trace_drv_stop_nan(local, sdata);
1368         local->ops->stop_nan(&local->hw, &sdata->vif);
1369         trace_drv_return_void(local);
1370 }
1371
1372 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1373                                        struct ieee80211_sub_if_data *sdata,
1374                                        struct cfg80211_nan_conf *conf,
1375                                        u32 changes)
1376 {
1377         int ret;
1378
1379         might_sleep();
1380         check_sdata_in_driver(sdata);
1381
1382         if (!local->ops->nan_change_conf)
1383                 return -EOPNOTSUPP;
1384
1385         trace_drv_nan_change_conf(local, sdata, conf, changes);
1386         ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1387                                           changes);
1388         trace_drv_return_int(local, ret);
1389
1390         return ret;
1391 }
1392
1393 static inline int drv_add_nan_func(struct ieee80211_local *local,
1394                                    struct ieee80211_sub_if_data *sdata,
1395                                    const struct cfg80211_nan_func *nan_func)
1396 {
1397         int ret;
1398
1399         might_sleep();
1400         check_sdata_in_driver(sdata);
1401
1402         if (!local->ops->add_nan_func)
1403                 return -EOPNOTSUPP;
1404
1405         trace_drv_add_nan_func(local, sdata, nan_func);
1406         ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1407         trace_drv_return_int(local, ret);
1408
1409         return ret;
1410 }
1411
1412 static inline void drv_del_nan_func(struct ieee80211_local *local,
1413                                    struct ieee80211_sub_if_data *sdata,
1414                                    u8 instance_id)
1415 {
1416         might_sleep();
1417         check_sdata_in_driver(sdata);
1418
1419         trace_drv_del_nan_func(local, sdata, instance_id);
1420         if (local->ops->del_nan_func)
1421                 local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1422         trace_drv_return_void(local);
1423 }
1424
1425 static inline int drv_set_tid_config(struct ieee80211_local *local,
1426                                      struct ieee80211_sub_if_data *sdata,
1427                                      struct ieee80211_sta *sta,
1428                                      struct cfg80211_tid_config *tid_conf)
1429 {
1430         int ret;
1431
1432         might_sleep();
1433         ret = local->ops->set_tid_config(&local->hw, &sdata->vif, sta,
1434                                          tid_conf);
1435         trace_drv_return_int(local, ret);
1436
1437         return ret;
1438 }
1439
1440 static inline int drv_reset_tid_config(struct ieee80211_local *local,
1441                                        struct ieee80211_sub_if_data *sdata,
1442                                        struct ieee80211_sta *sta, u8 tids)
1443 {
1444         int ret;
1445
1446         might_sleep();
1447         ret = local->ops->reset_tid_config(&local->hw, &sdata->vif, sta, tids);
1448         trace_drv_return_int(local, ret);
1449
1450         return ret;
1451 }
1452
1453 static inline void drv_update_vif_offload(struct ieee80211_local *local,
1454                                           struct ieee80211_sub_if_data *sdata)
1455 {
1456         might_sleep();
1457         check_sdata_in_driver(sdata);
1458
1459         if (!local->ops->update_vif_offload)
1460                 return;
1461
1462         trace_drv_update_vif_offload(local, sdata);
1463         local->ops->update_vif_offload(&local->hw, &sdata->vif);
1464         trace_drv_return_void(local);
1465 }
1466
1467 static inline void drv_sta_set_4addr(struct ieee80211_local *local,
1468                                      struct ieee80211_sub_if_data *sdata,
1469                                      struct ieee80211_sta *sta, bool enabled)
1470 {
1471         sdata = get_bss_sdata(sdata);
1472         if (!check_sdata_in_driver(sdata))
1473                 return;
1474
1475         trace_drv_sta_set_4addr(local, sdata, sta, enabled);
1476         if (local->ops->sta_set_4addr)
1477                 local->ops->sta_set_4addr(&local->hw, &sdata->vif, sta, enabled);
1478         trace_drv_return_void(local);
1479 }
1480
1481 static inline void drv_sta_set_decap_offload(struct ieee80211_local *local,
1482                                              struct ieee80211_sub_if_data *sdata,
1483                                              struct ieee80211_sta *sta,
1484                                              bool enabled)
1485 {
1486         sdata = get_bss_sdata(sdata);
1487         if (!check_sdata_in_driver(sdata))
1488                 return;
1489
1490         trace_drv_sta_set_decap_offload(local, sdata, sta, enabled);
1491         if (local->ops->sta_set_decap_offload)
1492                 local->ops->sta_set_decap_offload(&local->hw, &sdata->vif, sta,
1493                                                   enabled);
1494         trace_drv_return_void(local);
1495 }
1496
1497 static inline void drv_add_twt_setup(struct ieee80211_local *local,
1498                                      struct ieee80211_sub_if_data *sdata,
1499                                      struct ieee80211_sta *sta,
1500                                      struct ieee80211_twt_setup *twt)
1501 {
1502         struct ieee80211_twt_params *twt_agrt;
1503
1504         might_sleep();
1505
1506         if (!check_sdata_in_driver(sdata))
1507                 return;
1508
1509         twt_agrt = (void *)twt->params;
1510
1511         trace_drv_add_twt_setup(local, sta, twt, twt_agrt);
1512         local->ops->add_twt_setup(&local->hw, sta, twt);
1513         trace_drv_return_void(local);
1514 }
1515
1516 static inline void drv_twt_teardown_request(struct ieee80211_local *local,
1517                                             struct ieee80211_sub_if_data *sdata,
1518                                             struct ieee80211_sta *sta,
1519                                             u8 flowid)
1520 {
1521         might_sleep();
1522         if (!check_sdata_in_driver(sdata))
1523                 return;
1524
1525         if (!local->ops->twt_teardown_request)
1526                 return;
1527
1528         trace_drv_twt_teardown_request(local, sta, flowid);
1529         local->ops->twt_teardown_request(&local->hw, sta, flowid);
1530         trace_drv_return_void(local);
1531 }
1532
1533 static inline int drv_net_fill_forward_path(struct ieee80211_local *local,
1534                                             struct ieee80211_sub_if_data *sdata,
1535                                             struct ieee80211_sta *sta,
1536                                             struct net_device_path_ctx *ctx,
1537                                             struct net_device_path *path)
1538 {
1539         int ret = -EOPNOTSUPP;
1540
1541         sdata = get_bss_sdata(sdata);
1542         if (!check_sdata_in_driver(sdata))
1543                 return -EIO;
1544
1545         trace_drv_net_fill_forward_path(local, sdata, sta);
1546         if (local->ops->net_fill_forward_path)
1547                 ret = local->ops->net_fill_forward_path(&local->hw,
1548                                                         &sdata->vif, sta,
1549                                                         ctx, path);
1550         trace_drv_return_int(local, ret);
1551
1552         return ret;
1553 }
1554
1555 static inline int drv_change_vif_links(struct ieee80211_local *local,
1556                                        struct ieee80211_sub_if_data *sdata,
1557                                        u16 old_links, u16 new_links,
1558                                        struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS])
1559 {
1560         int ret = -EOPNOTSUPP;
1561
1562         might_sleep();
1563
1564         if (!check_sdata_in_driver(sdata))
1565                 return -EIO;
1566
1567         trace_drv_change_vif_links(local, sdata, old_links, new_links);
1568         if (local->ops->change_vif_links)
1569                 ret = local->ops->change_vif_links(&local->hw, &sdata->vif,
1570                                                    old_links, new_links, old);
1571         trace_drv_return_int(local, ret);
1572
1573         return ret;
1574 }
1575
1576 static inline int drv_change_sta_links(struct ieee80211_local *local,
1577                                        struct ieee80211_sub_if_data *sdata,
1578                                        struct ieee80211_sta *sta,
1579                                        u16 old_links, u16 new_links)
1580 {
1581         int ret = -EOPNOTSUPP;
1582
1583         might_sleep();
1584
1585         if (!check_sdata_in_driver(sdata))
1586                 return -EIO;
1587
1588         trace_drv_change_sta_links(local, sdata, sta, old_links, new_links);
1589         if (local->ops->change_sta_links)
1590                 ret = local->ops->change_sta_links(&local->hw, &sdata->vif, sta,
1591                                                    old_links, new_links);
1592         trace_drv_return_int(local, ret);
1593
1594         return ret;
1595 }
1596
1597 #endif /* __MAC80211_DRIVER_OPS */