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