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