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