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