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 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 u16 duration) 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, duration); 833 if (local->ops->mgd_prepare_tx) 834 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif, duration); 835 trace_drv_return_void(local); 836 } 837 838 static inline void 839 drv_mgd_protect_tdls_discover(struct ieee80211_local *local, 840 struct ieee80211_sub_if_data *sdata) 841 { 842 might_sleep(); 843 844 if (!check_sdata_in_driver(sdata)) 845 return; 846 WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION); 847 848 trace_drv_mgd_protect_tdls_discover(local, sdata); 849 if (local->ops->mgd_protect_tdls_discover) 850 local->ops->mgd_protect_tdls_discover(&local->hw, &sdata->vif); 851 trace_drv_return_void(local); 852 } 853 854 static inline int drv_add_chanctx(struct ieee80211_local *local, 855 struct ieee80211_chanctx *ctx) 856 { 857 int ret = -EOPNOTSUPP; 858 859 might_sleep(); 860 861 trace_drv_add_chanctx(local, ctx); 862 if (local->ops->add_chanctx) 863 ret = local->ops->add_chanctx(&local->hw, &ctx->conf); 864 trace_drv_return_int(local, ret); 865 if (!ret) 866 ctx->driver_present = true; 867 868 return ret; 869 } 870 871 static inline void drv_remove_chanctx(struct ieee80211_local *local, 872 struct ieee80211_chanctx *ctx) 873 { 874 might_sleep(); 875 876 if (WARN_ON(!ctx->driver_present)) 877 return; 878 879 trace_drv_remove_chanctx(local, ctx); 880 if (local->ops->remove_chanctx) 881 local->ops->remove_chanctx(&local->hw, &ctx->conf); 882 trace_drv_return_void(local); 883 ctx->driver_present = false; 884 } 885 886 static inline void drv_change_chanctx(struct ieee80211_local *local, 887 struct ieee80211_chanctx *ctx, 888 u32 changed) 889 { 890 might_sleep(); 891 892 trace_drv_change_chanctx(local, ctx, changed); 893 if (local->ops->change_chanctx) { 894 WARN_ON_ONCE(!ctx->driver_present); 895 local->ops->change_chanctx(&local->hw, &ctx->conf, changed); 896 } 897 trace_drv_return_void(local); 898 } 899 900 static inline int drv_assign_vif_chanctx(struct ieee80211_local *local, 901 struct ieee80211_sub_if_data *sdata, 902 struct ieee80211_chanctx *ctx) 903 { 904 int ret = 0; 905 906 if (!check_sdata_in_driver(sdata)) 907 return -EIO; 908 909 trace_drv_assign_vif_chanctx(local, sdata, ctx); 910 if (local->ops->assign_vif_chanctx) { 911 WARN_ON_ONCE(!ctx->driver_present); 912 ret = local->ops->assign_vif_chanctx(&local->hw, 913 &sdata->vif, 914 &ctx->conf); 915 } 916 trace_drv_return_int(local, ret); 917 918 return ret; 919 } 920 921 static inline void drv_unassign_vif_chanctx(struct ieee80211_local *local, 922 struct ieee80211_sub_if_data *sdata, 923 struct ieee80211_chanctx *ctx) 924 { 925 might_sleep(); 926 927 if (!check_sdata_in_driver(sdata)) 928 return; 929 930 trace_drv_unassign_vif_chanctx(local, sdata, ctx); 931 if (local->ops->unassign_vif_chanctx) { 932 WARN_ON_ONCE(!ctx->driver_present); 933 local->ops->unassign_vif_chanctx(&local->hw, 934 &sdata->vif, 935 &ctx->conf); 936 } 937 trace_drv_return_void(local); 938 } 939 940 int drv_switch_vif_chanctx(struct ieee80211_local *local, 941 struct ieee80211_vif_chanctx_switch *vifs, 942 int n_vifs, enum ieee80211_chanctx_switch_mode mode); 943 944 static inline int drv_start_ap(struct ieee80211_local *local, 945 struct ieee80211_sub_if_data *sdata) 946 { 947 int ret = 0; 948 949 might_sleep(); 950 951 if (!check_sdata_in_driver(sdata)) 952 return -EIO; 953 954 trace_drv_start_ap(local, sdata, &sdata->vif.bss_conf); 955 if (local->ops->start_ap) 956 ret = local->ops->start_ap(&local->hw, &sdata->vif); 957 trace_drv_return_int(local, ret); 958 return ret; 959 } 960 961 static inline void drv_stop_ap(struct ieee80211_local *local, 962 struct ieee80211_sub_if_data *sdata) 963 { 964 if (!check_sdata_in_driver(sdata)) 965 return; 966 967 trace_drv_stop_ap(local, sdata); 968 if (local->ops->stop_ap) 969 local->ops->stop_ap(&local->hw, &sdata->vif); 970 trace_drv_return_void(local); 971 } 972 973 static inline void 974 drv_reconfig_complete(struct ieee80211_local *local, 975 enum ieee80211_reconfig_type reconfig_type) 976 { 977 might_sleep(); 978 979 trace_drv_reconfig_complete(local, reconfig_type); 980 if (local->ops->reconfig_complete) 981 local->ops->reconfig_complete(&local->hw, reconfig_type); 982 trace_drv_return_void(local); 983 } 984 985 static inline void 986 drv_set_default_unicast_key(struct ieee80211_local *local, 987 struct ieee80211_sub_if_data *sdata, 988 int key_idx) 989 { 990 if (!check_sdata_in_driver(sdata)) 991 return; 992 993 WARN_ON_ONCE(key_idx < -1 || key_idx > 3); 994 995 trace_drv_set_default_unicast_key(local, sdata, key_idx); 996 if (local->ops->set_default_unicast_key) 997 local->ops->set_default_unicast_key(&local->hw, &sdata->vif, 998 key_idx); 999 trace_drv_return_void(local); 1000 } 1001 1002 #if IS_ENABLED(CONFIG_IPV6) 1003 static inline void drv_ipv6_addr_change(struct ieee80211_local *local, 1004 struct ieee80211_sub_if_data *sdata, 1005 struct inet6_dev *idev) 1006 { 1007 trace_drv_ipv6_addr_change(local, sdata); 1008 if (local->ops->ipv6_addr_change) 1009 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev); 1010 trace_drv_return_void(local); 1011 } 1012 #endif 1013 1014 static inline void 1015 drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata, 1016 struct cfg80211_chan_def *chandef) 1017 { 1018 struct ieee80211_local *local = sdata->local; 1019 1020 if (local->ops->channel_switch_beacon) { 1021 trace_drv_channel_switch_beacon(local, sdata, chandef); 1022 local->ops->channel_switch_beacon(&local->hw, &sdata->vif, 1023 chandef); 1024 } 1025 } 1026 1027 static inline int 1028 drv_pre_channel_switch(struct ieee80211_sub_if_data *sdata, 1029 struct ieee80211_channel_switch *ch_switch) 1030 { 1031 struct ieee80211_local *local = sdata->local; 1032 int ret = 0; 1033 1034 if (!check_sdata_in_driver(sdata)) 1035 return -EIO; 1036 1037 trace_drv_pre_channel_switch(local, sdata, ch_switch); 1038 if (local->ops->pre_channel_switch) 1039 ret = local->ops->pre_channel_switch(&local->hw, &sdata->vif, 1040 ch_switch); 1041 trace_drv_return_int(local, ret); 1042 return ret; 1043 } 1044 1045 static inline int 1046 drv_post_channel_switch(struct ieee80211_sub_if_data *sdata) 1047 { 1048 struct ieee80211_local *local = sdata->local; 1049 int ret = 0; 1050 1051 if (!check_sdata_in_driver(sdata)) 1052 return -EIO; 1053 1054 trace_drv_post_channel_switch(local, sdata); 1055 if (local->ops->post_channel_switch) 1056 ret = local->ops->post_channel_switch(&local->hw, &sdata->vif); 1057 trace_drv_return_int(local, ret); 1058 return ret; 1059 } 1060 1061 static inline void 1062 drv_abort_channel_switch(struct ieee80211_sub_if_data *sdata) 1063 { 1064 struct ieee80211_local *local = sdata->local; 1065 1066 if (!check_sdata_in_driver(sdata)) 1067 return; 1068 1069 trace_drv_abort_channel_switch(local, sdata); 1070 1071 if (local->ops->abort_channel_switch) 1072 local->ops->abort_channel_switch(&local->hw, &sdata->vif); 1073 } 1074 1075 static inline void 1076 drv_channel_switch_rx_beacon(struct ieee80211_sub_if_data *sdata, 1077 struct ieee80211_channel_switch *ch_switch) 1078 { 1079 struct ieee80211_local *local = sdata->local; 1080 1081 if (!check_sdata_in_driver(sdata)) 1082 return; 1083 1084 trace_drv_channel_switch_rx_beacon(local, sdata, ch_switch); 1085 if (local->ops->channel_switch_rx_beacon) 1086 local->ops->channel_switch_rx_beacon(&local->hw, &sdata->vif, 1087 ch_switch); 1088 } 1089 1090 static inline int drv_join_ibss(struct ieee80211_local *local, 1091 struct ieee80211_sub_if_data *sdata) 1092 { 1093 int ret = 0; 1094 1095 might_sleep(); 1096 if (!check_sdata_in_driver(sdata)) 1097 return -EIO; 1098 1099 trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf); 1100 if (local->ops->join_ibss) 1101 ret = local->ops->join_ibss(&local->hw, &sdata->vif); 1102 trace_drv_return_int(local, ret); 1103 return ret; 1104 } 1105 1106 static inline void drv_leave_ibss(struct ieee80211_local *local, 1107 struct ieee80211_sub_if_data *sdata) 1108 { 1109 might_sleep(); 1110 if (!check_sdata_in_driver(sdata)) 1111 return; 1112 1113 trace_drv_leave_ibss(local, sdata); 1114 if (local->ops->leave_ibss) 1115 local->ops->leave_ibss(&local->hw, &sdata->vif); 1116 trace_drv_return_void(local); 1117 } 1118 1119 static inline u32 drv_get_expected_throughput(struct ieee80211_local *local, 1120 struct sta_info *sta) 1121 { 1122 u32 ret = 0; 1123 1124 trace_drv_get_expected_throughput(&sta->sta); 1125 if (local->ops->get_expected_throughput && sta->uploaded) 1126 ret = local->ops->get_expected_throughput(&local->hw, &sta->sta); 1127 trace_drv_return_u32(local, ret); 1128 1129 return ret; 1130 } 1131 1132 static inline int drv_get_txpower(struct ieee80211_local *local, 1133 struct ieee80211_sub_if_data *sdata, int *dbm) 1134 { 1135 int ret; 1136 1137 if (!local->ops->get_txpower) 1138 return -EOPNOTSUPP; 1139 1140 ret = local->ops->get_txpower(&local->hw, &sdata->vif, dbm); 1141 trace_drv_get_txpower(local, sdata, *dbm, ret); 1142 1143 return ret; 1144 } 1145 1146 static inline int 1147 drv_tdls_channel_switch(struct ieee80211_local *local, 1148 struct ieee80211_sub_if_data *sdata, 1149 struct ieee80211_sta *sta, u8 oper_class, 1150 struct cfg80211_chan_def *chandef, 1151 struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie) 1152 { 1153 int ret; 1154 1155 might_sleep(); 1156 if (!check_sdata_in_driver(sdata)) 1157 return -EIO; 1158 1159 if (!local->ops->tdls_channel_switch) 1160 return -EOPNOTSUPP; 1161 1162 trace_drv_tdls_channel_switch(local, sdata, sta, oper_class, chandef); 1163 ret = local->ops->tdls_channel_switch(&local->hw, &sdata->vif, sta, 1164 oper_class, chandef, tmpl_skb, 1165 ch_sw_tm_ie); 1166 trace_drv_return_int(local, ret); 1167 return ret; 1168 } 1169 1170 static inline void 1171 drv_tdls_cancel_channel_switch(struct ieee80211_local *local, 1172 struct ieee80211_sub_if_data *sdata, 1173 struct ieee80211_sta *sta) 1174 { 1175 might_sleep(); 1176 if (!check_sdata_in_driver(sdata)) 1177 return; 1178 1179 if (!local->ops->tdls_cancel_channel_switch) 1180 return; 1181 1182 trace_drv_tdls_cancel_channel_switch(local, sdata, sta); 1183 local->ops->tdls_cancel_channel_switch(&local->hw, &sdata->vif, sta); 1184 trace_drv_return_void(local); 1185 } 1186 1187 static inline void 1188 drv_tdls_recv_channel_switch(struct ieee80211_local *local, 1189 struct ieee80211_sub_if_data *sdata, 1190 struct ieee80211_tdls_ch_sw_params *params) 1191 { 1192 trace_drv_tdls_recv_channel_switch(local, sdata, params); 1193 if (local->ops->tdls_recv_channel_switch) 1194 local->ops->tdls_recv_channel_switch(&local->hw, &sdata->vif, 1195 params); 1196 trace_drv_return_void(local); 1197 } 1198 1199 static inline void drv_wake_tx_queue(struct ieee80211_local *local, 1200 struct txq_info *txq) 1201 { 1202 struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->txq.vif); 1203 1204 if (local->in_reconfig) 1205 return; 1206 1207 if (!check_sdata_in_driver(sdata)) 1208 return; 1209 1210 trace_drv_wake_tx_queue(local, sdata, txq); 1211 local->ops->wake_tx_queue(&local->hw, &txq->txq); 1212 } 1213 1214 static inline void schedule_and_wake_txq(struct ieee80211_local *local, 1215 struct txq_info *txqi) 1216 { 1217 ieee80211_schedule_txq(&local->hw, &txqi->txq); 1218 drv_wake_tx_queue(local, txqi); 1219 } 1220 1221 static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local, 1222 struct sk_buff *head, 1223 struct sk_buff *skb) 1224 { 1225 if (!local->ops->can_aggregate_in_amsdu) 1226 return true; 1227 1228 return local->ops->can_aggregate_in_amsdu(&local->hw, head, skb); 1229 } 1230 1231 static inline int 1232 drv_get_ftm_responder_stats(struct ieee80211_local *local, 1233 struct ieee80211_sub_if_data *sdata, 1234 struct cfg80211_ftm_responder_stats *ftm_stats) 1235 { 1236 u32 ret = -EOPNOTSUPP; 1237 1238 if (local->ops->get_ftm_responder_stats) 1239 ret = local->ops->get_ftm_responder_stats(&local->hw, 1240 &sdata->vif, 1241 ftm_stats); 1242 trace_drv_get_ftm_responder_stats(local, sdata, ftm_stats); 1243 1244 return ret; 1245 } 1246 1247 static inline int drv_start_pmsr(struct ieee80211_local *local, 1248 struct ieee80211_sub_if_data *sdata, 1249 struct cfg80211_pmsr_request *request) 1250 { 1251 int ret = -EOPNOTSUPP; 1252 1253 might_sleep(); 1254 if (!check_sdata_in_driver(sdata)) 1255 return -EIO; 1256 1257 trace_drv_start_pmsr(local, sdata); 1258 1259 if (local->ops->start_pmsr) 1260 ret = local->ops->start_pmsr(&local->hw, &sdata->vif, request); 1261 trace_drv_return_int(local, ret); 1262 1263 return ret; 1264 } 1265 1266 static inline void drv_abort_pmsr(struct ieee80211_local *local, 1267 struct ieee80211_sub_if_data *sdata, 1268 struct cfg80211_pmsr_request *request) 1269 { 1270 trace_drv_abort_pmsr(local, sdata); 1271 1272 might_sleep(); 1273 if (!check_sdata_in_driver(sdata)) 1274 return; 1275 1276 if (local->ops->abort_pmsr) 1277 local->ops->abort_pmsr(&local->hw, &sdata->vif, request); 1278 trace_drv_return_void(local); 1279 } 1280 1281 static inline int drv_start_nan(struct ieee80211_local *local, 1282 struct ieee80211_sub_if_data *sdata, 1283 struct cfg80211_nan_conf *conf) 1284 { 1285 int ret; 1286 1287 might_sleep(); 1288 check_sdata_in_driver(sdata); 1289 1290 trace_drv_start_nan(local, sdata, conf); 1291 ret = local->ops->start_nan(&local->hw, &sdata->vif, conf); 1292 trace_drv_return_int(local, ret); 1293 return ret; 1294 } 1295 1296 static inline void drv_stop_nan(struct ieee80211_local *local, 1297 struct ieee80211_sub_if_data *sdata) 1298 { 1299 might_sleep(); 1300 check_sdata_in_driver(sdata); 1301 1302 trace_drv_stop_nan(local, sdata); 1303 local->ops->stop_nan(&local->hw, &sdata->vif); 1304 trace_drv_return_void(local); 1305 } 1306 1307 static inline int drv_nan_change_conf(struct ieee80211_local *local, 1308 struct ieee80211_sub_if_data *sdata, 1309 struct cfg80211_nan_conf *conf, 1310 u32 changes) 1311 { 1312 int ret; 1313 1314 might_sleep(); 1315 check_sdata_in_driver(sdata); 1316 1317 if (!local->ops->nan_change_conf) 1318 return -EOPNOTSUPP; 1319 1320 trace_drv_nan_change_conf(local, sdata, conf, changes); 1321 ret = local->ops->nan_change_conf(&local->hw, &sdata->vif, conf, 1322 changes); 1323 trace_drv_return_int(local, ret); 1324 1325 return ret; 1326 } 1327 1328 static inline int drv_add_nan_func(struct ieee80211_local *local, 1329 struct ieee80211_sub_if_data *sdata, 1330 const struct cfg80211_nan_func *nan_func) 1331 { 1332 int ret; 1333 1334 might_sleep(); 1335 check_sdata_in_driver(sdata); 1336 1337 if (!local->ops->add_nan_func) 1338 return -EOPNOTSUPP; 1339 1340 trace_drv_add_nan_func(local, sdata, nan_func); 1341 ret = local->ops->add_nan_func(&local->hw, &sdata->vif, nan_func); 1342 trace_drv_return_int(local, ret); 1343 1344 return ret; 1345 } 1346 1347 static inline void drv_del_nan_func(struct ieee80211_local *local, 1348 struct ieee80211_sub_if_data *sdata, 1349 u8 instance_id) 1350 { 1351 might_sleep(); 1352 check_sdata_in_driver(sdata); 1353 1354 trace_drv_del_nan_func(local, sdata, instance_id); 1355 if (local->ops->del_nan_func) 1356 local->ops->del_nan_func(&local->hw, &sdata->vif, instance_id); 1357 trace_drv_return_void(local); 1358 } 1359 1360 static inline int drv_set_tid_config(struct ieee80211_local *local, 1361 struct ieee80211_sub_if_data *sdata, 1362 struct ieee80211_sta *sta, 1363 struct cfg80211_tid_config *tid_conf) 1364 { 1365 int ret; 1366 1367 might_sleep(); 1368 ret = local->ops->set_tid_config(&local->hw, &sdata->vif, sta, 1369 tid_conf); 1370 trace_drv_return_int(local, ret); 1371 1372 return ret; 1373 } 1374 1375 static inline int drv_reset_tid_config(struct ieee80211_local *local, 1376 struct ieee80211_sub_if_data *sdata, 1377 struct ieee80211_sta *sta, u8 tids) 1378 { 1379 int ret; 1380 1381 might_sleep(); 1382 ret = local->ops->reset_tid_config(&local->hw, &sdata->vif, sta, tids); 1383 trace_drv_return_int(local, ret); 1384 1385 return ret; 1386 } 1387 #endif /* __MAC80211_DRIVER_OPS */ 1388