1 /*- 2 * Copyright (c) 2021-2022 The FreeBSD Foundation 3 * 4 * This software was developed by Björn Zeeb under sponsorship from 5 * the FreeBSD Foundation. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/types.h> 31 #include <sys/kernel.h> 32 #include <sys/errno.h> 33 34 #define LINUXKPI_NET80211 35 #include <net/mac80211.h> 36 37 #include "linux_80211.h" 38 39 /* Could be a different tracing framework later. */ 40 #ifdef LINUXKPI_DEBUG_80211 41 #define LKPI_80211_TRACE_MO(fmt, ...) \ 42 if (linuxkpi_debug_80211 & D80211_TRACE_MO) \ 43 printf("LKPI_80211_TRACE_MO %s:%d: %d %d %u_" fmt "\n", \ 44 __func__, __LINE__, curcpu, curthread->td_tid, \ 45 (unsigned int)ticks, __VA_ARGS__) 46 #else 47 #define LKPI_80211_TRACE_MO(...) do { } while(0) 48 #endif 49 50 int 51 lkpi_80211_mo_start(struct ieee80211_hw *hw) 52 { 53 struct lkpi_hw *lhw; 54 int error; 55 56 lhw = HW_TO_LHW(hw); 57 if (lhw->ops->start == NULL) { 58 error = EOPNOTSUPP; 59 goto out; 60 } 61 62 if ((lhw->sc_flags & LKPI_MAC80211_DRV_STARTED)) { 63 /* Trying to start twice is an error. */ 64 error = EEXIST; 65 goto out; 66 } 67 LKPI_80211_TRACE_MO("hw %p", hw); 68 error = lhw->ops->start(hw); 69 if (error == 0) 70 lhw->sc_flags |= LKPI_MAC80211_DRV_STARTED; 71 72 out: 73 return (error); 74 } 75 76 void 77 lkpi_80211_mo_stop(struct ieee80211_hw *hw, bool suspend) 78 { 79 struct lkpi_hw *lhw; 80 81 lhw = HW_TO_LHW(hw); 82 if (lhw->ops->stop == NULL) 83 return; 84 85 LKPI_80211_TRACE_MO("hw %p suspend %d", hw, suspend); 86 lhw->ops->stop(hw, suspend); 87 lhw->sc_flags &= ~LKPI_MAC80211_DRV_STARTED; 88 } 89 90 int 91 lkpi_80211_mo_get_antenna(struct ieee80211_hw *hw, u32 *txs, u32 *rxs) 92 { 93 struct lkpi_hw *lhw; 94 int error; 95 96 lhw = HW_TO_LHW(hw); 97 if (lhw->ops->get_antenna == NULL) { 98 error = EOPNOTSUPP; 99 goto out; 100 } 101 102 LKPI_80211_TRACE_MO("hw %p", hw); 103 error = lhw->ops->get_antenna(hw, txs, rxs); 104 105 out: 106 return (error); 107 } 108 109 int 110 lkpi_80211_mo_set_frag_threshold(struct ieee80211_hw *hw, uint32_t frag_th) 111 { 112 struct lkpi_hw *lhw; 113 int error; 114 115 lhw = HW_TO_LHW(hw); 116 if (lhw->ops->set_frag_threshold == NULL) { 117 error = EOPNOTSUPP; 118 goto out; 119 } 120 121 LKPI_80211_TRACE_MO("hw %p frag_th %u", hw, frag_th); 122 error = lhw->ops->set_frag_threshold(hw, frag_th); 123 124 out: 125 return (error); 126 } 127 128 int 129 lkpi_80211_mo_set_rts_threshold(struct ieee80211_hw *hw, uint32_t rts_th) 130 { 131 struct lkpi_hw *lhw; 132 int error; 133 134 lhw = HW_TO_LHW(hw); 135 if (lhw->ops->set_rts_threshold == NULL) { 136 error = EOPNOTSUPP; 137 goto out; 138 } 139 140 LKPI_80211_TRACE_MO("hw %p rts_th %u", hw, rts_th); 141 error = lhw->ops->set_rts_threshold(hw, rts_th); 142 143 out: 144 return (error); 145 } 146 147 148 int 149 lkpi_80211_mo_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 150 { 151 struct lkpi_hw *lhw; 152 struct lkpi_vif *lvif; 153 int error; 154 155 lhw = HW_TO_LHW(hw); 156 if (lhw->ops->add_interface == NULL) { 157 error = EOPNOTSUPP; 158 goto out; 159 } 160 161 lvif = VIF_TO_LVIF(vif); 162 LKPI_80211_LVIF_LOCK(lvif); 163 if (lvif->added_to_drv) { 164 LKPI_80211_LVIF_UNLOCK(lvif); 165 /* Trying to add twice is an error. */ 166 error = EEXIST; 167 goto out; 168 } 169 LKPI_80211_LVIF_UNLOCK(lvif); 170 171 LKPI_80211_TRACE_MO("hw %p vif %p", hw, vif); 172 error = lhw->ops->add_interface(hw, vif); 173 if (error == 0) { 174 LKPI_80211_LVIF_LOCK(lvif); 175 lvif->added_to_drv = true; 176 LKPI_80211_LVIF_UNLOCK(lvif); 177 } 178 179 out: 180 return (error); 181 } 182 183 void 184 lkpi_80211_mo_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 185 { 186 struct lkpi_hw *lhw; 187 struct lkpi_vif *lvif; 188 189 lhw = HW_TO_LHW(hw); 190 if (lhw->ops->remove_interface == NULL) 191 return; 192 193 lvif = VIF_TO_LVIF(vif); 194 LKPI_80211_LVIF_LOCK(lvif); 195 if (!lvif->added_to_drv) { 196 LKPI_80211_LVIF_UNLOCK(lvif); 197 return; 198 } 199 LKPI_80211_LVIF_UNLOCK(lvif); 200 201 LKPI_80211_TRACE_MO("hw %p vif %p", hw, vif); 202 lhw->ops->remove_interface(hw, vif); 203 LKPI_80211_LVIF_LOCK(lvif); 204 lvif->added_to_drv = false; 205 LKPI_80211_LVIF_UNLOCK(lvif); 206 } 207 208 209 int 210 lkpi_80211_mo_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 211 struct ieee80211_scan_request *sr) 212 { 213 struct lkpi_hw *lhw; 214 int error; 215 216 /* 217 * MUST NOT return EPERM as that is a "magic number 1" based on rtw88 218 * driver indicating hw_scan is not supported despite the ops call 219 * being available. 220 */ 221 222 lhw = HW_TO_LHW(hw); 223 if (lhw->ops->hw_scan == NULL) { 224 /* Return magic number to use sw scan. */ 225 error = 1; 226 goto out; 227 } 228 229 LKPI_80211_TRACE_MO("CALLING hw %p vif %p sr %p", hw, vif, sr); 230 error = lhw->ops->hw_scan(hw, vif, sr); 231 LKPI_80211_TRACE_MO("RETURNING hw %p vif %p sr %p error %d", hw, vif, sr, error); 232 233 out: 234 return (error); 235 } 236 237 void 238 lkpi_80211_mo_cancel_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 239 { 240 struct lkpi_hw *lhw; 241 242 lhw = HW_TO_LHW(hw); 243 if (lhw->ops->cancel_hw_scan == NULL) 244 return; 245 246 LKPI_80211_TRACE_MO("hw %p vif %p", hw, vif); 247 lhw->ops->cancel_hw_scan(hw, vif); 248 } 249 250 void 251 lkpi_80211_mo_sw_scan_complete(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 252 { 253 struct lkpi_hw *lhw; 254 255 lhw = HW_TO_LHW(hw); 256 if (lhw->ops->sw_scan_complete == NULL) 257 return; 258 259 LKPI_80211_TRACE_MO("hw %p vif %p", hw, vif); 260 lhw->ops->sw_scan_complete(hw, vif); 261 lhw->scan_flags &= ~LKPI_LHW_SCAN_RUNNING; 262 } 263 264 void 265 lkpi_80211_mo_sw_scan_start(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 266 const u8 *addr) 267 { 268 struct lkpi_hw *lhw; 269 270 lhw = HW_TO_LHW(hw); 271 if (lhw->ops->sw_scan_start == NULL) 272 return; 273 274 LKPI_80211_TRACE_MO("hw %p vif %p", hw, vif); 275 lhw->ops->sw_scan_start(hw, vif, addr); 276 } 277 278 279 /* 280 * We keep the Linux type here; it really is an uintptr_t. 281 */ 282 u64 283 lkpi_80211_mo_prepare_multicast(struct ieee80211_hw *hw, 284 struct netdev_hw_addr_list *mc_list) 285 { 286 struct lkpi_hw *lhw; 287 u64 ptr; 288 289 lhw = HW_TO_LHW(hw); 290 if (lhw->ops->prepare_multicast == NULL) 291 return (0); 292 293 LKPI_80211_TRACE_MO("hw %p mc_list %p", hw, mc_list); 294 ptr = lhw->ops->prepare_multicast(hw, mc_list); 295 return (ptr); 296 } 297 298 void 299 lkpi_80211_mo_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags, 300 unsigned int *total_flags, u64 mc_ptr) 301 { 302 struct lkpi_hw *lhw; 303 304 lhw = HW_TO_LHW(hw); 305 if (lhw->ops->configure_filter == NULL) 306 return; 307 308 if (mc_ptr == 0) 309 return; 310 311 LKPI_80211_TRACE_MO("hw %p changed_flags %#x total_flags %p mc_ptr %ju", hw, changed_flags, total_flags, (uintmax_t)mc_ptr); 312 lhw->ops->configure_filter(hw, changed_flags, total_flags, mc_ptr); 313 } 314 315 316 /* 317 * So far we only called sta_{add,remove} as an alternative to sta_state. 318 * Let's keep the implementation simpler and hide sta_{add,remove} under the 319 * hood here calling them if state_state is not available from mo_sta_state. 320 */ 321 static int 322 lkpi_80211_mo_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 323 struct ieee80211_sta *sta) 324 { 325 struct lkpi_hw *lhw; 326 struct lkpi_sta *lsta; 327 int error; 328 329 lhw = HW_TO_LHW(hw); 330 if (lhw->ops->sta_add == NULL) { 331 error = EOPNOTSUPP; 332 goto out; 333 } 334 335 lsta = STA_TO_LSTA(sta); 336 if (lsta->added_to_drv) { 337 error = EEXIST; 338 goto out; 339 } 340 341 LKPI_80211_TRACE_MO("hw %p vif %p sta %p", hw, vif, sta); 342 error = lhw->ops->sta_add(hw, vif, sta); 343 if (error == 0) 344 lsta->added_to_drv = true; 345 346 out: 347 return error; 348 } 349 350 static int 351 lkpi_80211_mo_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 352 struct ieee80211_sta *sta) 353 { 354 struct lkpi_hw *lhw; 355 struct lkpi_sta *lsta; 356 int error; 357 358 lhw = HW_TO_LHW(hw); 359 if (lhw->ops->sta_remove == NULL) { 360 error = EOPNOTSUPP; 361 goto out; 362 } 363 364 lsta = STA_TO_LSTA(sta); 365 if (!lsta->added_to_drv) { 366 /* If we never added the sta, do not complain on cleanup. */ 367 error = 0; 368 goto out; 369 } 370 371 LKPI_80211_TRACE_MO("hw %p vif %p sta %p", hw, vif, sta); 372 error = lhw->ops->sta_remove(hw, vif, sta); 373 if (error == 0) 374 lsta->added_to_drv = false; 375 376 out: 377 return error; 378 } 379 380 int 381 lkpi_80211_mo_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 382 struct lkpi_sta *lsta, enum ieee80211_sta_state nstate) 383 { 384 struct lkpi_hw *lhw; 385 struct ieee80211_sta *sta; 386 int error; 387 388 lhw = HW_TO_LHW(hw); 389 sta = LSTA_TO_STA(lsta); 390 if (lhw->ops->sta_state != NULL) { 391 LKPI_80211_TRACE_MO("hw %p vif %p sta %p nstate %d", hw, vif, sta, nstate); 392 error = lhw->ops->sta_state(hw, vif, sta, lsta->state, nstate); 393 if (error == 0) { 394 if (nstate == IEEE80211_STA_NOTEXIST) 395 lsta->added_to_drv = false; 396 else 397 lsta->added_to_drv = true; 398 lsta->state = nstate; 399 } 400 goto out; 401 } 402 403 /* XXX-BZ is the change state AUTH or ASSOC here? */ 404 if (lsta->state < IEEE80211_STA_ASSOC && nstate == IEEE80211_STA_ASSOC) { 405 error = lkpi_80211_mo_sta_add(hw, vif, sta); 406 if (error == 0) 407 lsta->added_to_drv = true; 408 } else if (lsta->state >= IEEE80211_STA_ASSOC && 409 nstate < IEEE80211_STA_ASSOC) { 410 error = lkpi_80211_mo_sta_remove(hw, vif, sta); 411 if (error == 0) 412 lsta->added_to_drv = false; 413 } else 414 /* Nothing to do. */ 415 error = 0; 416 if (error == 0) 417 lsta->state = nstate; 418 419 out: 420 /* XXX-BZ should we manage state in here? */ 421 return (error); 422 } 423 424 int 425 lkpi_80211_mo_config(struct ieee80211_hw *hw, uint32_t changed) 426 { 427 struct lkpi_hw *lhw; 428 int error; 429 430 lhw = HW_TO_LHW(hw); 431 if (lhw->ops->config == NULL) { 432 error = EOPNOTSUPP; 433 goto out; 434 } 435 436 LKPI_80211_TRACE_MO("hw %p changed %u", hw, changed); 437 error = lhw->ops->config(hw, changed); 438 439 out: 440 return (error); 441 } 442 443 444 int 445 lkpi_80211_mo_assign_vif_chanctx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 446 struct ieee80211_bss_conf *conf, struct ieee80211_chanctx_conf *chanctx_conf) 447 { 448 struct lkpi_hw *lhw; 449 int error; 450 451 lhw = HW_TO_LHW(hw); 452 if (lhw->ops->assign_vif_chanctx == NULL) { 453 error = EOPNOTSUPP; 454 goto out; 455 } 456 457 LKPI_80211_TRACE_MO("hw %p vif %p bss_conf %p chanctx_conf %p", 458 hw, vif, conf, chanctx_conf); 459 error = lhw->ops->assign_vif_chanctx(hw, vif, conf, chanctx_conf); 460 if (error == 0) 461 vif->chanctx_conf = chanctx_conf; 462 463 out: 464 return (error); 465 } 466 467 void 468 lkpi_80211_mo_unassign_vif_chanctx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 469 struct ieee80211_bss_conf *conf, struct ieee80211_chanctx_conf **chanctx_conf) 470 { 471 struct lkpi_hw *lhw; 472 473 lhw = HW_TO_LHW(hw); 474 if (lhw->ops->unassign_vif_chanctx == NULL) 475 return; 476 477 if (*chanctx_conf == NULL) 478 return; 479 480 LKPI_80211_TRACE_MO("hw %p vif %p bss_conf %p chanctx_conf %p", 481 hw, vif, conf, *chanctx_conf); 482 lhw->ops->unassign_vif_chanctx(hw, vif, conf, *chanctx_conf); 483 *chanctx_conf = NULL; 484 } 485 486 487 int 488 lkpi_80211_mo_add_chanctx(struct ieee80211_hw *hw, 489 struct ieee80211_chanctx_conf *chanctx_conf) 490 { 491 struct lkpi_hw *lhw; 492 struct lkpi_chanctx *lchanctx; 493 int error; 494 495 lhw = HW_TO_LHW(hw); 496 if (lhw->ops->add_chanctx == NULL) { 497 error = EOPNOTSUPP; 498 goto out; 499 } 500 501 LKPI_80211_TRACE_MO("hw %p chanctx_conf %p", hw, chanctx_conf); 502 error = lhw->ops->add_chanctx(hw, chanctx_conf); 503 if (error == 0) { 504 lchanctx = CHANCTX_CONF_TO_LCHANCTX(chanctx_conf); 505 lchanctx->added_to_drv = true; 506 } 507 508 out: 509 return (error); 510 } 511 512 void 513 lkpi_80211_mo_change_chanctx(struct ieee80211_hw *hw, 514 struct ieee80211_chanctx_conf *chanctx_conf, uint32_t changed) 515 { 516 struct lkpi_hw *lhw; 517 518 lhw = HW_TO_LHW(hw); 519 if (lhw->ops->change_chanctx == NULL) 520 return; 521 522 LKPI_80211_TRACE_MO("hw %p chanctx_conf %p changed %u", hw, chanctx_conf, changed); 523 lhw->ops->change_chanctx(hw, chanctx_conf, changed); 524 } 525 526 void 527 lkpi_80211_mo_remove_chanctx(struct ieee80211_hw *hw, 528 struct ieee80211_chanctx_conf *chanctx_conf) 529 { 530 struct lkpi_hw *lhw; 531 struct lkpi_chanctx *lchanctx; 532 533 lhw = HW_TO_LHW(hw); 534 if (lhw->ops->remove_chanctx == NULL) 535 return; 536 537 LKPI_80211_TRACE_MO("hw %p chanctx_conf %p", hw, chanctx_conf); 538 lhw->ops->remove_chanctx(hw, chanctx_conf); 539 lchanctx = CHANCTX_CONF_TO_LCHANCTX(chanctx_conf); 540 lchanctx->added_to_drv = false; 541 } 542 543 void 544 lkpi_80211_mo_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 545 struct ieee80211_bss_conf *conf, uint64_t changed) 546 { 547 struct lkpi_hw *lhw; 548 549 lhw = HW_TO_LHW(hw); 550 if (lhw->ops->link_info_changed == NULL && 551 lhw->ops->bss_info_changed == NULL) 552 return; 553 554 LKPI_80211_TRACE_MO("hw %p vif %p conf %p changed %#jx", hw, vif, conf, (uintmax_t)changed); 555 if (lhw->ops->link_info_changed != NULL) 556 lhw->ops->link_info_changed(hw, vif, conf, changed); 557 else 558 lhw->ops->bss_info_changed(hw, vif, conf, changed); 559 } 560 561 int 562 lkpi_80211_mo_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 563 uint32_t link_id, uint16_t ac, const struct ieee80211_tx_queue_params *txqp) 564 { 565 struct lkpi_hw *lhw; 566 int error; 567 568 lhw = HW_TO_LHW(hw); 569 if (lhw->ops->conf_tx == NULL) { 570 error = EOPNOTSUPP; 571 goto out; 572 } 573 574 LKPI_80211_TRACE_MO("hw %p vif %p link_id %u ac %u txpq %p", 575 hw, vif, link_id, ac, txqp); 576 error = lhw->ops->conf_tx(hw, vif, link_id, ac, txqp); 577 578 out: 579 return (error); 580 } 581 582 void 583 lkpi_80211_mo_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 584 uint32_t nqueues, bool drop) 585 { 586 struct lkpi_hw *lhw; 587 588 lhw = HW_TO_LHW(hw); 589 if (lhw->ops->flush == NULL) 590 return; 591 592 LKPI_80211_TRACE_MO("hw %p vif %p nqueues %u drop %d", hw, vif, nqueues, drop); 593 lhw->ops->flush(hw, vif, nqueues, drop); 594 } 595 596 void 597 lkpi_80211_mo_mgd_prepare_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 598 struct ieee80211_prep_tx_info *txinfo) 599 { 600 struct lkpi_hw *lhw; 601 602 lhw = HW_TO_LHW(hw); 603 if (lhw->ops->mgd_prepare_tx == NULL) 604 return; 605 606 LKPI_80211_TRACE_MO("hw %p vif %p txinfo %p", hw, vif, txinfo); 607 lhw->ops->mgd_prepare_tx(hw, vif, txinfo); 608 } 609 610 void 611 lkpi_80211_mo_mgd_complete_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 612 struct ieee80211_prep_tx_info *txinfo) 613 { 614 struct lkpi_hw *lhw; 615 616 lhw = HW_TO_LHW(hw); 617 if (lhw->ops->mgd_complete_tx == NULL) 618 return; 619 620 LKPI_80211_TRACE_MO("hw %p vif %p txinfo %p", hw, vif, txinfo); 621 lhw->ops->mgd_complete_tx(hw, vif, txinfo); 622 } 623 624 void 625 lkpi_80211_mo_tx(struct ieee80211_hw *hw, struct ieee80211_tx_control *txctrl, 626 struct sk_buff *skb) 627 { 628 struct lkpi_hw *lhw; 629 630 lhw = HW_TO_LHW(hw); 631 if (lhw->ops->tx == NULL) 632 return; 633 634 LKPI_80211_TRACE_MO("hw %p txctrl %p skb %p", hw, txctrl, skb); 635 lhw->ops->tx(hw, txctrl, skb); 636 } 637 638 void 639 lkpi_80211_mo_wake_tx_queue(struct ieee80211_hw *hw, struct ieee80211_txq *txq) 640 { 641 struct lkpi_hw *lhw; 642 643 lhw = HW_TO_LHW(hw); 644 if (lhw->ops->wake_tx_queue == NULL) 645 return; 646 647 LKPI_80211_TRACE_MO("hw %p txq %p", hw, txq); 648 lhw->ops->wake_tx_queue(hw, txq); 649 } 650 651 void 652 lkpi_80211_mo_sync_rx_queues(struct ieee80211_hw *hw) 653 { 654 struct lkpi_hw *lhw; 655 656 lhw = HW_TO_LHW(hw); 657 if (lhw->ops->sync_rx_queues == NULL) 658 return; 659 660 LKPI_80211_TRACE_MO("hw %p", hw); 661 lhw->ops->sync_rx_queues(hw); 662 } 663 664 void 665 lkpi_80211_mo_sta_pre_rcu_remove(struct ieee80211_hw *hw, 666 struct ieee80211_vif *vif, struct ieee80211_sta *sta) 667 { 668 struct lkpi_hw *lhw; 669 670 lhw = HW_TO_LHW(hw); 671 if (lhw->ops->sta_pre_rcu_remove == NULL) 672 return; 673 674 LKPI_80211_TRACE_MO("hw %p vif %p sta %p", hw, vif, sta); 675 lhw->ops->sta_pre_rcu_remove(hw, vif, sta); 676 } 677 678 int 679 lkpi_80211_mo_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 680 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 681 struct ieee80211_key_conf *kc) 682 { 683 struct lkpi_hw *lhw; 684 int error; 685 686 lhw = HW_TO_LHW(hw); 687 if (lhw->ops->set_key == NULL) { 688 error = EOPNOTSUPP; 689 goto out; 690 } 691 692 LKPI_80211_TRACE_MO("hw %p cmd %d vif %p sta %p kc %p", hw, cmd, vif, sta, kc); 693 error = lhw->ops->set_key(hw, cmd, vif, sta, kc); 694 695 out: 696 return (error); 697 } 698 699 int 700 lkpi_80211_mo_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 701 struct ieee80211_ampdu_params *params) 702 { 703 struct lkpi_hw *lhw; 704 int error; 705 706 lhw = HW_TO_LHW(hw); 707 if (lhw->ops->ampdu_action == NULL) { 708 error = EOPNOTSUPP; 709 goto out; 710 } 711 712 LKPI_80211_TRACE_MO("hw %p vif %p params %p { %p, %d, %u, %u, %u, %u, %d }", 713 hw, vif, params, params->sta, params->action, params->buf_size, 714 params->timeout, params->ssn, params->tid, params->amsdu); 715 error = lhw->ops->ampdu_action(hw, vif, params); 716 717 out: 718 return (error); 719 } 720