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-2024 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, bool suspend);
  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_link_sta_rc_update(struct ieee80211_local *local,
 598                             struct ieee80211_sub_if_data *sdata,
 599                             struct ieee80211_link_sta *link_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         if (!sta->uploaded)
 728                 return;
 729
 730         trace_drv_flush_sta(local, sdata, &sta->sta);
 731         if (local->ops->flush_sta)
 732                 local->ops->flush_sta(&local->hw, &sdata->vif, &sta->sta);
 733         trace_drv_return_void(local);
 734 }
 735
 736 static inline void drv_channel_switch(struct ieee80211_local *local,
 737                                       struct ieee80211_sub_if_data *sdata,
 738                                       struct ieee80211_channel_switch *ch_switch)
 739 {
 740         might_sleep();
 741         lockdep_assert_wiphy(local->hw.wiphy);
 742
 743         trace_drv_channel_switch(local, sdata, ch_switch);
 744         local->ops->channel_switch(&local->hw, &sdata->vif, ch_switch);
 745         trace_drv_return_void(local);
 746 }
 747
 748
 749 static inline int drv_set_antenna(struct ieee80211_local *local,
 750                                   u32 tx_ant, u32 rx_ant)
 751 {
 752         int ret = -EOPNOTSUPP;
 753         might_sleep();
 754         lockdep_assert_wiphy(local->hw.wiphy);
 755         if (local->ops->set_antenna)
 756                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
 757         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
 758         return ret;
 759 }
 760
 761 static inline int drv_get_antenna(struct ieee80211_local *local,
 762                                   u32 *tx_ant, u32 *rx_ant)
 763 {
 764         int ret = -EOPNOTSUPP;
 765         might_sleep();
 766         lockdep_assert_wiphy(local->hw.wiphy);
 767         if (local->ops->get_antenna)
 768                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
 769         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
 770         return ret;
 771 }
 772
 773 static inline int drv_remain_on_channel(struct ieee80211_local *local,
 774                                         struct ieee80211_sub_if_data *sdata,
 775                                         struct ieee80211_channel *chan,
 776                                         unsigned int duration,
 777                                         enum ieee80211_roc_type type)
 778 {
 779         int ret;
 780
 781         might_sleep();
 782         lockdep_assert_wiphy(local->hw.wiphy);
 783
 784         trace_drv_remain_on_channel(local, sdata, chan, duration, type);
 785         ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
 786                                             chan, duration, type);
 787         trace_drv_return_int(local, ret);
 788
 789         return ret;
 790 }
 791
 792 static inline int
 793 drv_cancel_remain_on_channel(struct ieee80211_local *local,
 794                              struct ieee80211_sub_if_data *sdata)
 795 {
 796         int ret;
 797
 798         might_sleep();
 799         lockdep_assert_wiphy(local->hw.wiphy);
 800
 801         trace_drv_cancel_remain_on_channel(local, sdata);
 802         ret = local->ops->cancel_remain_on_channel(&local->hw, &sdata->vif);
 803         trace_drv_return_int(local, ret);
 804
 805         return ret;
 806 }
 807
 808 static inline int drv_set_ringparam(struct ieee80211_local *local,
 809                                     u32 tx, u32 rx)
 810 {
 811         int ret = -EOPNOTSUPP;
 812
 813         might_sleep();
 814         lockdep_assert_wiphy(local->hw.wiphy);
 815
 816         trace_drv_set_ringparam(local, tx, rx);
 817         if (local->ops->set_ringparam)
 818                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
 819         trace_drv_return_int(local, ret);
 820
 821         return ret;
 822 }
 823
 824 static inline void drv_get_ringparam(struct ieee80211_local *local,
 825                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
 826 {
 827         might_sleep();
 828         lockdep_assert_wiphy(local->hw.wiphy);
 829
 830         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
 831         if (local->ops->get_ringparam)
 832                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
 833         trace_drv_return_void(local);
 834 }
 835
 836 static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
 837 {
 838         bool ret = false;
 839
 840         might_sleep();
 841         lockdep_assert_wiphy(local->hw.wiphy);
 842
 843         trace_drv_tx_frames_pending(local);
 844         if (local->ops->tx_frames_pending)
 845                 ret = local->ops->tx_frames_pending(&local->hw);
 846         trace_drv_return_bool(local, ret);
 847
 848         return ret;
 849 }
 850
 851 static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
 852                                        struct ieee80211_sub_if_data *sdata,
 853                                        const struct cfg80211_bitrate_mask *mask)
 854 {
 855         int ret = -EOPNOTSUPP;
 856
 857         might_sleep();
 858         lockdep_assert_wiphy(local->hw.wiphy);
 859
 860         if (!check_sdata_in_driver(sdata))
 861                 return -EIO;
 862
 863         trace_drv_set_bitrate_mask(local, sdata, mask);
 864         if (local->ops->set_bitrate_mask)
 865                 ret = local->ops->set_bitrate_mask(&local->hw,
 866                                                    &sdata->vif, mask);
 867         trace_drv_return_int(local, ret);
 868
 869         return ret;
 870 }
 871
 872 static inline void drv_set_rekey_data(struct ieee80211_local *local,
 873                                       struct ieee80211_sub_if_data *sdata,
 874                                       struct cfg80211_gtk_rekey_data *data)
 875 {
 876         might_sleep();
 877         lockdep_assert_wiphy(local->hw.wiphy);
 878
 879         if (!check_sdata_in_driver(sdata))
 880                 return;
 881
 882         trace_drv_set_rekey_data(local, sdata, data);
 883         if (local->ops->set_rekey_data)
 884                 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
 885         trace_drv_return_void(local);
 886 }
 887
 888 static inline void drv_event_callback(struct ieee80211_local *local,
 889                                       struct ieee80211_sub_if_data *sdata,
 890                                       const struct ieee80211_event *event)
 891 {
 892         trace_drv_event_callback(local, sdata, event);
 893         if (local->ops->event_callback)
 894                 local->ops->event_callback(&local->hw, &sdata->vif, event);
 895         trace_drv_return_void(local);
 896 }
 897
 898 static inline void
 899 drv_release_buffered_frames(struct ieee80211_local *local,
 900                             struct sta_info *sta, u16 tids, int num_frames,
 901                             enum ieee80211_frame_release_type reason,
 902                             bool more_data)
 903 {
 904         trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
 905                                           reason, more_data);
 906         if (local->ops->release_buffered_frames)
 907                 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
 908                                                     num_frames, reason,
 909                                                     more_data);
 910         trace_drv_return_void(local);
 911 }
 912
 913 static inline void
 914 drv_allow_buffered_frames(struct ieee80211_local *local,
 915                           struct sta_info *sta, u16 tids, int num_frames,
 916                           enum ieee80211_frame_release_type reason,
 917                           bool more_data)
 918 {
 919         trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
 920                                         reason, more_data);
 921         if (local->ops->allow_buffered_frames)
 922                 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
 923                                                   tids, num_frames, reason,
 924                                                   more_data);
 925         trace_drv_return_void(local);
 926 }
 927
 928 static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
 929                                       struct ieee80211_sub_if_data *sdata,
 930                                       struct ieee80211_prep_tx_info *info)
 931 {
 932         might_sleep();
 933         lockdep_assert_wiphy(local->hw.wiphy);
 934
 935         if (!check_sdata_in_driver(sdata))
 936                 return;
 937         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 938
 939         info->link_id = info->link_id < 0 ? 0 : info->link_id;
 940         trace_drv_mgd_prepare_tx(local, sdata, info->duration,
 941                                  info->subtype, info->success);
 942         if (local->ops->mgd_prepare_tx)
 943                 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif, info);
 944         trace_drv_return_void(local);
 945 }
 946
 947 static inline void drv_mgd_complete_tx(struct ieee80211_local *local,
 948                                        struct ieee80211_sub_if_data *sdata,
 949                                        struct ieee80211_prep_tx_info *info)
 950 {
 951         might_sleep();
 952         lockdep_assert_wiphy(local->hw.wiphy);
 953
 954         if (!check_sdata_in_driver(sdata))
 955                 return;
 956         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 957
 958         trace_drv_mgd_complete_tx(local, sdata, info->duration,
 959                                   info->subtype, info->success);
 960         if (local->ops->mgd_complete_tx)
 961                 local->ops->mgd_complete_tx(&local->hw, &sdata->vif, info);
 962         trace_drv_return_void(local);
 963 }
 964
 965 static inline void
 966 drv_mgd_protect_tdls_discover(struct ieee80211_local *local,
 967                               struct ieee80211_sub_if_data *sdata,
 968                               int link_id)
 969 {
 970         might_sleep();
 971         lockdep_assert_wiphy(local->hw.wiphy);
 972
 973         if (!check_sdata_in_driver(sdata))
 974                 return;
 975         WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
 976
 977         link_id = link_id > 0 ? link_id : 0;
 978
 979         trace_drv_mgd_protect_tdls_discover(local, sdata);
 980         if (local->ops->mgd_protect_tdls_discover)
 981                 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif,
 982                                                       link_id);
 983         trace_drv_return_void(local);
 984 }
 985
 986 static inline int drv_add_chanctx(struct ieee80211_local *local,
 987                                   struct ieee80211_chanctx *ctx)
 988 {
 989         int ret = -EOPNOTSUPP;
 990
 991         might_sleep();
 992         lockdep_assert_wiphy(local->hw.wiphy);
 993
 994         trace_drv_add_chanctx(local, ctx);
 995         if (local->ops->add_chanctx)
 996                 ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
 997         trace_drv_return_int(local, ret);
 998         if (!ret)
 999                 ctx->driver_present = true;
1000
1001         return ret;
1002 }
1003
1004 static inline void drv_remove_chanctx(struct ieee80211_local *local,
1005                                       struct ieee80211_chanctx *ctx)
1006 {
1007         might_sleep();
1008         lockdep_assert_wiphy(local->hw.wiphy);
1009
1010         if (WARN_ON(!ctx->driver_present))
1011                 return;
1012
1013         trace_drv_remove_chanctx(local, ctx);
1014         if (local->ops->remove_chanctx)
1015                 local->ops->remove_chanctx(&local->hw, &ctx->conf);
1016         trace_drv_return_void(local);
1017         ctx->driver_present = false;
1018 }
1019
1020 static inline void drv_change_chanctx(struct ieee80211_local *local,
1021                                       struct ieee80211_chanctx *ctx,
1022                                       u32 changed)
1023 {
1024         might_sleep();
1025         lockdep_assert_wiphy(local->hw.wiphy);
1026
1027         trace_drv_change_chanctx(local, ctx, changed);
1028         if (local->ops->change_chanctx) {
1029                 WARN_ON_ONCE(!ctx->driver_present);
1030                 local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
1031         }
1032         trace_drv_return_void(local);
1033 }
1034
1035 int drv_assign_vif_chanctx(struct ieee80211_local *local,
1036                            struct ieee80211_sub_if_data *sdata,
1037                            struct ieee80211_bss_conf *link_conf,
1038                            struct ieee80211_chanctx *ctx);
1039 void drv_unassign_vif_chanctx(struct ieee80211_local *local,
1040                               struct ieee80211_sub_if_data *sdata,
1041                               struct ieee80211_bss_conf *link_conf,
1042                               struct ieee80211_chanctx *ctx);
1043 int drv_switch_vif_chanctx(struct ieee80211_local *local,
1044                            struct ieee80211_vif_chanctx_switch *vifs,
1045                            int n_vifs, enum ieee80211_chanctx_switch_mode mode);
1046
1047 static inline int drv_start_ap(struct ieee80211_local *local,
1048                                struct ieee80211_sub_if_data *sdata,
1049                                struct ieee80211_bss_conf *link_conf)
1050 {
1051         int ret = 0;
1052
1053         might_sleep();
1054         lockdep_assert_wiphy(local->hw.wiphy);
1055
1056         if (!check_sdata_in_driver(sdata))
1057                 return -EIO;
1058
1059         trace_drv_start_ap(local, sdata, link_conf);
1060         if (local->ops->start_ap)
1061                 ret = local->ops->start_ap(&local->hw, &sdata->vif, link_conf);
1062         trace_drv_return_int(local, ret);
1063         return ret;
1064 }
1065
1066 static inline void drv_stop_ap(struct ieee80211_local *local,
1067                                struct ieee80211_sub_if_data *sdata,
1068                                struct ieee80211_bss_conf *link_conf)
1069 {
1070         might_sleep();
1071         lockdep_assert_wiphy(local->hw.wiphy);
1072
1073         if (!check_sdata_in_driver(sdata))
1074                 return;
1075
1076         trace_drv_stop_ap(local, sdata, link_conf);
1077         if (local->ops->stop_ap)
1078                 local->ops->stop_ap(&local->hw, &sdata->vif, link_conf);
1079         trace_drv_return_void(local);
1080 }
1081
1082 static inline void
1083 drv_reconfig_complete(struct ieee80211_local *local,
1084                       enum ieee80211_reconfig_type reconfig_type)
1085 {
1086         might_sleep();
1087         lockdep_assert_wiphy(local->hw.wiphy);
1088
1089         trace_drv_reconfig_complete(local, reconfig_type);
1090         if (local->ops->reconfig_complete)
1091                 local->ops->reconfig_complete(&local->hw, reconfig_type);
1092         trace_drv_return_void(local);
1093 }
1094
1095 static inline void
1096 drv_set_default_unicast_key(struct ieee80211_local *local,
1097                             struct ieee80211_sub_if_data *sdata,
1098                             int key_idx)
1099 {
1100         might_sleep();
1101         lockdep_assert_wiphy(local->hw.wiphy);
1102
1103         if (!check_sdata_in_driver(sdata))
1104                 return;
1105
1106         WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
1107
1108         trace_drv_set_default_unicast_key(local, sdata, key_idx);
1109         if (local->ops->set_default_unicast_key)
1110                 local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
1111                                                     key_idx);
1112         trace_drv_return_void(local);
1113 }
1114
1115 #if IS_ENABLED(CONFIG_IPV6)
1116 static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
1117                                         struct ieee80211_sub_if_data *sdata,
1118                                         struct inet6_dev *idev)
1119 {
1120         trace_drv_ipv6_addr_change(local, sdata);
1121         if (local->ops->ipv6_addr_change)
1122                 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1123         trace_drv_return_void(local);
1124 }
1125 #endif
1126
1127 static inline void
1128 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1129                           struct cfg80211_chan_def *chandef)
1130 {
1131         struct ieee80211_local *local = sdata->local;
1132
1133         might_sleep();
1134         lockdep_assert_wiphy(local->hw.wiphy);
1135
1136         if (local->ops->channel_switch_beacon) {
1137                 trace_drv_channel_switch_beacon(local, sdata, chandef);
1138                 local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1139                                                   chandef);
1140         }
1141 }
1142
1143 static inline int
1144 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata,
1145                        struct ieee80211_channel_switch *ch_switch)
1146 {
1147         struct ieee80211_local *local = sdata->local;
1148         int ret = 0;
1149
1150         might_sleep();
1151         lockdep_assert_wiphy(local->hw.wiphy);
1152
1153         if (!check_sdata_in_driver(sdata))
1154                 return -EIO;
1155
1156         if (!ieee80211_vif_link_active(&sdata->vif, ch_switch->link_id))
1157                 return 0;
1158
1159         trace_drv_pre_channel_switch(local, sdata, ch_switch);
1160         if (local->ops->pre_channel_switch)
1161                 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif,
1162                                                      ch_switch);
1163         trace_drv_return_int(local, ret);
1164         return ret;
1165 }
1166
1167 static inline int
1168 drv_post_channel_switch(struct ieee80211_link_data *link)
1169 {
1170         struct ieee80211_sub_if_data *sdata = link->sdata;
1171         struct ieee80211_local *local = sdata->local;
1172         int ret = 0;
1173
1174         might_sleep();
1175         lockdep_assert_wiphy(local->hw.wiphy);
1176
1177         if (!check_sdata_in_driver(sdata))
1178                 return -EIO;
1179
1180         if (!ieee80211_vif_link_active(&sdata->vif, link->link_id))
1181                 return 0;
1182
1183         trace_drv_post_channel_switch(local, sdata);
1184         if (local->ops->post_channel_switch)
1185                 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif,
1186                                                       link->conf);
1187         trace_drv_return_int(local, ret);
1188         return ret;
1189 }
1190
1191 static inline void
1192 drv_abort_channel_switch(struct ieee80211_link_data *link)
1193 {
1194         struct ieee80211_sub_if_data *sdata = link->sdata;
1195         struct ieee80211_local *local = sdata->local;
1196
1197         might_sleep();
1198         lockdep_assert_wiphy(local->hw.wiphy);
1199
1200         if (!check_sdata_in_driver(sdata))
1201                 return;
1202
1203         if (!ieee80211_vif_link_active(&sdata->vif, link->link_id))
1204                 return;
1205
1206         trace_drv_abort_channel_switch(local, sdata);
1207
1208         if (local->ops->abort_channel_switch)
1209                 local->ops->abort_channel_switch(&local->hw, &sdata->vif,
1210                                                  link->conf);
1211 }
1212
1213 static inline void
1214 drv_channel_switch_rx_beacon(struct ieee80211_sub_if_data *sdata,
1215                              struct ieee80211_channel_switch *ch_switch)
1216 {
1217         struct ieee80211_local *local = sdata->local;
1218
1219         might_sleep();
1220         lockdep_assert_wiphy(local->hw.wiphy);
1221
1222         if (!check_sdata_in_driver(sdata))
1223                 return;
1224
1225         if (!ieee80211_vif_link_active(&sdata->vif, ch_switch->link_id))
1226                 return;
1227
1228         trace_drv_channel_switch_rx_beacon(local, sdata, ch_switch);
1229         if (local->ops->channel_switch_rx_beacon)
1230                 local->ops->channel_switch_rx_beacon(&local->hw, &sdata->vif,
1231                                                      ch_switch);
1232 }
1233
1234 static inline int drv_join_ibss(struct ieee80211_local *local,
1235                                 struct ieee80211_sub_if_data *sdata)
1236 {
1237         int ret = 0;
1238
1239         might_sleep();
1240         lockdep_assert_wiphy(local->hw.wiphy);
1241         if (!check_sdata_in_driver(sdata))
1242                 return -EIO;
1243
1244         trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1245         if (local->ops->join_ibss)
1246                 ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1247         trace_drv_return_int(local, ret);
1248         return ret;
1249 }
1250
1251 static inline void drv_leave_ibss(struct ieee80211_local *local,
1252                                   struct ieee80211_sub_if_data *sdata)
1253 {
1254         might_sleep();
1255         lockdep_assert_wiphy(local->hw.wiphy);
1256         if (!check_sdata_in_driver(sdata))
1257                 return;
1258
1259         trace_drv_leave_ibss(local, sdata);
1260         if (local->ops->leave_ibss)
1261                 local->ops->leave_ibss(&local->hw, &sdata->vif);
1262         trace_drv_return_void(local);
1263 }
1264
1265 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1266                                               struct sta_info *sta)
1267 {
1268         u32 ret = 0;
1269
1270         trace_drv_get_expected_throughput(&sta->sta);
1271         if (local->ops->get_expected_throughput && sta->uploaded)
1272                 ret = local->ops->get_expected_throughput(&local->hw, &sta->sta);
1273         trace_drv_return_u32(local, ret);
1274
1275         return ret;
1276 }
1277
1278 static inline int drv_get_txpower(struct ieee80211_local *local,
1279                                   struct ieee80211_sub_if_data *sdata,
1280                                   unsigned int link_id, int *dbm)
1281 {
1282         int ret;
1283
1284         might_sleep();
1285         lockdep_assert_wiphy(local->hw.wiphy);
1286
1287         if (!local->ops->get_txpower)
1288                 return -EOPNOTSUPP;
1289
1290         ret = local->ops->get_txpower(&local->hw, &sdata->vif, link_id, dbm);
1291         trace_drv_get_txpower(local, sdata, link_id, *dbm, ret);
1292
1293         return ret;
1294 }
1295
1296 static inline int
1297 drv_tdls_channel_switch(struct ieee80211_local *local,
1298                         struct ieee80211_sub_if_data *sdata,
1299                         struct ieee80211_sta *sta, u8 oper_class,
1300                         struct cfg80211_chan_def *chandef,
1301                         struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
1302 {
1303         int ret;
1304
1305         might_sleep();
1306         lockdep_assert_wiphy(local->hw.wiphy);
1307         if (!check_sdata_in_driver(sdata))
1308                 return -EIO;
1309
1310         if (!local->ops->tdls_channel_switch)
1311                 return -EOPNOTSUPP;
1312
1313         trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef);
1314         ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta,
1315                                               oper_class, chandef, tmpl_skb,
1316                                               ch_sw_tm_ie);
1317         trace_drv_return_int(local, ret);
1318         return ret;
1319 }
1320
1321 static inline void
1322 drv_tdls_cancel_channel_switch(struct ieee80211_local *local,
1323                                struct ieee80211_sub_if_data *sdata,
1324                                struct ieee80211_sta *sta)
1325 {
1326         might_sleep();
1327         lockdep_assert_wiphy(local->hw.wiphy);
1328         if (!check_sdata_in_driver(sdata))
1329                 return;
1330
1331         if (!local->ops->tdls_cancel_channel_switch)
1332                 return;
1333
1334         trace_drv_tdls_cancel_channel_switch(local, sdata, sta);
1335         local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta);
1336         trace_drv_return_void(local);
1337 }
1338
1339 static inline void
1340 drv_tdls_recv_channel_switch(struct ieee80211_local *local,
1341                              struct ieee80211_sub_if_data *sdata,
1342                              struct ieee80211_tdls_ch_sw_params *params)
1343 {
1344         trace_drv_tdls_recv_channel_switch(local, sdata, params);
1345         if (local->ops->tdls_recv_channel_switch)
1346                 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif,
1347                                                      params);
1348         trace_drv_return_void(local);
1349 }
1350
1351 static inline void drv_wake_tx_queue(struct ieee80211_local *local,
1352                                      struct txq_info *txq)
1353 {
1354         struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif);
1355
1356         /* In reconfig don't transmit now, but mark for waking later */
1357         if (local->in_reconfig) {
1358                 set_bit(IEEE80211_TXQ_DIRTY, &txq->flags);
1359                 return;
1360         }
1361
1362         if (!check_sdata_in_driver(sdata))
1363                 return;
1364
1365         trace_drv_wake_tx_queue(local, sdata, txq);
1366         local->ops->wake_tx_queue(&local->hw, &txq->txq);
1367 }
1368
1369 static inline void schedule_and_wake_txq(struct ieee80211_local *local,
1370                                          struct txq_info *txqi)
1371 {
1372         ieee80211_schedule_txq(&local->hw, &txqi->txq);
1373         drv_wake_tx_queue(local, txqi);
1374 }
1375
1376 static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local,
1377                                              struct sk_buff *head,
1378                                              struct sk_buff *skb)
1379 {
1380         if (!local->ops->can_aggregate_in_amsdu)
1381                 return true;
1382
1383         return local->ops->can_aggregate_in_amsdu(&local->hw, head, skb);
1384 }
1385
1386 static inline int
1387 drv_get_ftm_responder_stats(struct ieee80211_local *local,
1388                             struct ieee80211_sub_if_data *sdata,
1389                             struct cfg80211_ftm_responder_stats *ftm_stats)
1390 {
1391         u32 ret = -EOPNOTSUPP;
1392
1393         might_sleep();
1394         lockdep_assert_wiphy(local->hw.wiphy);
1395         if (!check_sdata_in_driver(sdata))
1396                 return -EIO;
1397
1398         if (local->ops->get_ftm_responder_stats)
1399                 ret = local->ops->get_ftm_responder_stats(&local->hw,
1400                                                          &sdata->vif,
1401                                                          ftm_stats);
1402         trace_drv_get_ftm_responder_stats(local, sdata, ftm_stats);
1403
1404         return ret;
1405 }
1406
1407 static inline int drv_start_pmsr(struct ieee80211_local *local,
1408                                  struct ieee80211_sub_if_data *sdata,
1409                                  struct cfg80211_pmsr_request *request)
1410 {
1411         int ret = -EOPNOTSUPP;
1412
1413         might_sleep();
1414         lockdep_assert_wiphy(local->hw.wiphy);
1415         if (!check_sdata_in_driver(sdata))
1416                 return -EIO;
1417
1418         trace_drv_start_pmsr(local, sdata);
1419
1420         if (local->ops->start_pmsr)
1421                 ret = local->ops->start_pmsr(&local->hw, &sdata->vif, request);
1422         trace_drv_return_int(local, ret);
1423
1424         return ret;
1425 }
1426
1427 static inline void drv_abort_pmsr(struct ieee80211_local *local,
1428                                   struct ieee80211_sub_if_data *sdata,
1429                                   struct cfg80211_pmsr_request *request)
1430 {
1431         trace_drv_abort_pmsr(local, sdata);
1432
1433         might_sleep();
1434         lockdep_assert_wiphy(local->hw.wiphy);
1435         if (!check_sdata_in_driver(sdata))
1436                 return;
1437
1438         if (local->ops->abort_pmsr)
1439                 local->ops->abort_pmsr(&local->hw, &sdata->vif, request);
1440         trace_drv_return_void(local);
1441 }
1442
1443 static inline int drv_start_nan(struct ieee80211_local *local,
1444                                 struct ieee80211_sub_if_data *sdata,
1445                                 struct cfg80211_nan_conf *conf)
1446 {
1447         int ret;
1448
1449         might_sleep();
1450         lockdep_assert_wiphy(local->hw.wiphy);
1451         check_sdata_in_driver(sdata);
1452
1453         trace_drv_start_nan(local, sdata, conf);
1454         ret = local->ops->start_nan(&local->hw, &sdata->vif, conf);
1455         trace_drv_return_int(local, ret);
1456         return ret;
1457 }
1458
1459 static inline void drv_stop_nan(struct ieee80211_local *local,
1460                                 struct ieee80211_sub_if_data *sdata)
1461 {
1462         might_sleep();
1463         lockdep_assert_wiphy(local->hw.wiphy);
1464         check_sdata_in_driver(sdata);
1465
1466         trace_drv_stop_nan(local, sdata);
1467         local->ops->stop_nan(&local->hw, &sdata->vif);
1468         trace_drv_return_void(local);
1469 }
1470
1471 static inline int drv_nan_change_conf(struct ieee80211_local *local,
1472                                        struct ieee80211_sub_if_data *sdata,
1473                                        struct cfg80211_nan_conf *conf,
1474                                        u32 changes)
1475 {
1476         int ret;
1477
1478         might_sleep();
1479         lockdep_assert_wiphy(local->hw.wiphy);
1480         check_sdata_in_driver(sdata);
1481
1482         if (!local->ops->nan_change_conf)
1483                 return -EOPNOTSUPP;
1484
1485         trace_drv_nan_change_conf(local, sdata, conf, changes);
1486         ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf,
1487                                           changes);
1488         trace_drv_return_int(local, ret);
1489
1490         return ret;
1491 }
1492
1493 static inline int drv_add_nan_func(struct ieee80211_local *local,
1494                                    struct ieee80211_sub_if_data *sdata,
1495                                    const struct cfg80211_nan_func *nan_func)
1496 {
1497         int ret;
1498
1499         might_sleep();
1500         lockdep_assert_wiphy(local->hw.wiphy);
1501         check_sdata_in_driver(sdata);
1502
1503         if (!local->ops->add_nan_func)
1504                 return -EOPNOTSUPP;
1505
1506         trace_drv_add_nan_func(local, sdata, nan_func);
1507         ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func);
1508         trace_drv_return_int(local, ret);
1509
1510         return ret;
1511 }
1512
1513 static inline void drv_del_nan_func(struct ieee80211_local *local,
1514                                    struct ieee80211_sub_if_data *sdata,
1515                                    u8 instance_id)
1516 {
1517         might_sleep();
1518         lockdep_assert_wiphy(local->hw.wiphy);
1519         check_sdata_in_driver(sdata);
1520
1521         trace_drv_del_nan_func(local, sdata, instance_id);
1522         if (local->ops->del_nan_func)
1523                 local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id);
1524         trace_drv_return_void(local);
1525 }
1526
1527 static inline int drv_set_tid_config(struct ieee80211_local *local,
1528                                      struct ieee80211_sub_if_data *sdata,
1529                                      struct ieee80211_sta *sta,
1530                                      struct cfg80211_tid_config *tid_conf)
1531 {
1532         int ret;
1533
1534         might_sleep();
1535         lockdep_assert_wiphy(local->hw.wiphy);
1536         ret = local->ops->set_tid_config(&local->hw, &sdata->vif, sta,
1537                                          tid_conf);
1538         trace_drv_return_int(local, ret);
1539
1540         return ret;
1541 }
1542
1543 static inline int drv_reset_tid_config(struct ieee80211_local *local,
1544                                        struct ieee80211_sub_if_data *sdata,
1545                                        struct ieee80211_sta *sta, u8 tids)
1546 {
1547         int ret;
1548
1549         might_sleep();
1550         lockdep_assert_wiphy(local->hw.wiphy);
1551         ret = local->ops->reset_tid_config(&local->hw, &sdata->vif, sta, tids);
1552         trace_drv_return_int(local, ret);
1553
1554         return ret;
1555 }
1556
1557 static inline void drv_update_vif_offload(struct ieee80211_local *local,
1558                                           struct ieee80211_sub_if_data *sdata)
1559 {
1560         might_sleep();
1561         lockdep_assert_wiphy(local->hw.wiphy);
1562         check_sdata_in_driver(sdata);
1563
1564         if (!local->ops->update_vif_offload)
1565                 return;
1566
1567         trace_drv_update_vif_offload(local, sdata);
1568         local->ops->update_vif_offload(&local->hw, &sdata->vif);
1569         trace_drv_return_void(local);
1570 }
1571
1572 static inline void drv_sta_set_4addr(struct ieee80211_local *local,
1573                                      struct ieee80211_sub_if_data *sdata,
1574                                      struct ieee80211_sta *sta, 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_4addr(local, sdata, sta, enabled);
1584         if (local->ops->sta_set_4addr)
1585                 local->ops->sta_set_4addr(&local->hw, &sdata->vif, sta, enabled);
1586         trace_drv_return_void(local);
1587 }
1588
1589 static inline void drv_sta_set_decap_offload(struct ieee80211_local *local,
1590                                              struct ieee80211_sub_if_data *sdata,
1591                                              struct ieee80211_sta *sta,
1592                                              bool enabled)
1593 {
1594         sdata = get_bss_sdata(sdata);
1595
1596         might_sleep();
1597         lockdep_assert_wiphy(local->hw.wiphy);
1598         if (!check_sdata_in_driver(sdata))
1599                 return;
1600
1601         trace_drv_sta_set_decap_offload(local, sdata, sta, enabled);
1602         if (local->ops->sta_set_decap_offload)
1603                 local->ops->sta_set_decap_offload(&local->hw, &sdata->vif, sta,
1604                                                   enabled);
1605         trace_drv_return_void(local);
1606 }
1607
1608 static inline void drv_add_twt_setup(struct ieee80211_local *local,
1609                                      struct ieee80211_sub_if_data *sdata,
1610                                      struct ieee80211_sta *sta,
1611                                      struct ieee80211_twt_setup *twt)
1612 {
1613         struct ieee80211_twt_params *twt_agrt;
1614
1615         might_sleep();
1616         lockdep_assert_wiphy(local->hw.wiphy);
1617
1618         if (!check_sdata_in_driver(sdata))
1619                 return;
1620
1621         twt_agrt = (void *)twt->params;
1622
1623         trace_drv_add_twt_setup(local, sta, twt, twt_agrt);
1624         local->ops->add_twt_setup(&local->hw, sta, twt);
1625         trace_drv_return_void(local);
1626 }
1627
1628 static inline void drv_twt_teardown_request(struct ieee80211_local *local,
1629                                             struct ieee80211_sub_if_data *sdata,
1630                                             struct ieee80211_sta *sta,
1631                                             u8 flowid)
1632 {
1633         might_sleep();
1634         lockdep_assert_wiphy(local->hw.wiphy);
1635         if (!check_sdata_in_driver(sdata))
1636                 return;
1637
1638         if (!local->ops->twt_teardown_request)
1639                 return;
1640
1641         trace_drv_twt_teardown_request(local, sta, flowid);
1642         local->ops->twt_teardown_request(&local->hw, sta, flowid);
1643         trace_drv_return_void(local);
1644 }
1645
1646 static inline int drv_net_fill_forward_path(struct ieee80211_local *local,
1647                                             struct ieee80211_sub_if_data *sdata,
1648                                             struct ieee80211_sta *sta,
1649                                             struct net_device_path_ctx *ctx,
1650                                             struct net_device_path *path)
1651 {
1652         int ret = -EOPNOTSUPP;
1653
1654         sdata = get_bss_sdata(sdata);
1655         if (!check_sdata_in_driver(sdata))
1656                 return -EIO;
1657
1658         trace_drv_net_fill_forward_path(local, sdata, sta);
1659         if (local->ops->net_fill_forward_path)
1660                 ret = local->ops->net_fill_forward_path(&local->hw,
1661                                                         &sdata->vif, sta,
1662                                                         ctx, path);
1663         trace_drv_return_int(local, ret);
1664
1665         return ret;
1666 }
1667
1668 static inline int drv_net_setup_tc(struct ieee80211_local *local,
1669                                    struct ieee80211_sub_if_data *sdata,
1670                                    struct net_device *dev,
1671                                    enum tc_setup_type type, void *type_data)
1672 {
1673         int ret = -EOPNOTSUPP;
1674
1675         might_sleep();
1676
1677         sdata = get_bss_sdata(sdata);
1678         trace_drv_net_setup_tc(local, sdata, type);
1679         if (local->ops->net_setup_tc)
1680                 ret = local->ops->net_setup_tc(&local->hw, &sdata->vif, dev,
1681                                                type, type_data);
1682         trace_drv_return_int(local, ret);
1683
1684         return ret;
1685 }
1686
1687 static inline bool drv_can_activate_links(struct ieee80211_local *local,
1688                                           struct ieee80211_sub_if_data *sdata,
1689                                           u16 active_links)
1690 {
1691         bool ret = true;
1692
1693         lockdep_assert_wiphy(local->hw.wiphy);
1694
1695         if (!check_sdata_in_driver(sdata))
1696                 return false;
1697
1698         trace_drv_can_activate_links(local, sdata, active_links);
1699         if (local->ops->can_activate_links)
1700                 ret = local->ops->can_activate_links(&local->hw, &sdata->vif,
1701                                                      active_links);
1702         trace_drv_return_bool(local, ret);
1703
1704         return ret;
1705 }
1706
1707 int drv_change_vif_links(struct ieee80211_local *local,
1708                          struct ieee80211_sub_if_data *sdata,
1709                          u16 old_links, u16 new_links,
1710                          struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]);
1711 int drv_change_sta_links(struct ieee80211_local *local,
1712                          struct ieee80211_sub_if_data *sdata,
1713                          struct ieee80211_sta *sta,
1714                          u16 old_links, u16 new_links);
1715
1716 static inline enum ieee80211_neg_ttlm_res
1717 drv_can_neg_ttlm(struct ieee80211_local *local,
1718                  struct ieee80211_sub_if_data *sdata,
1719                  struct ieee80211_neg_ttlm *neg_ttlm)
1720 {
1721         enum ieee80211_neg_ttlm_res res = NEG_TTLM_RES_REJECT;
1722
1723         might_sleep();
1724         if (!check_sdata_in_driver(sdata))
1725                 return -EIO;
1726
1727         trace_drv_can_neg_ttlm(local, sdata, neg_ttlm);
1728         if (local->ops->can_neg_ttlm)
1729                 res = local->ops->can_neg_ttlm(&local->hw, &sdata->vif,
1730                                                neg_ttlm);
1731         trace_drv_neg_ttlm_res(local, sdata, res, neg_ttlm);
1732
1733         return res;
1734 }
1735
1736 static inline void
1737 drv_prep_add_interface(struct ieee80211_local *local,
1738                        enum nl80211_iftype type)
1739 {
1740         trace_drv_prep_add_interface(local, type);
1741         if (local->ops->prep_add_interface)
1742                 local->ops->prep_add_interface(&local->hw, type);
1743
1744         trace_drv_return_void(local);
1745 }
1746
1747 #endif /* __MAC80211_DRIVER_OPS */