Lines Matching defs:lhw
39 * We call the internal versions lxxx (e.g., hw -> lhw, sta -> lsta).
633 lkpi_find_lkpi80211_chan(struct lkpi_hw *lhw,
641 hw = LHW_TO_HW(lhw);
665 struct lkpi_hw *lhw;
678 lhw = ic->ic_softc;
679 chan = lkpi_find_lkpi80211_chan(lhw, c);
716 struct lkpi_hw *lhw;
728 lhw = ic->ic_softc;
729 hw = LHW_TO_HW(lhw);
831 struct lkpi_hw *lhw;
840 lhw = ic->ic_softc;
842 if (lhw->ops->prepare_multicast == NULL ||
843 lhw->ops->configure_filter == NULL)
846 if (!lhw->update_mc && !force)
860 hw = LHW_TO_HW(lhw);
943 lkpi_stop_hw_scan(struct lkpi_hw *lhw, struct ieee80211_vif *vif)
949 LKPI_80211_LHW_SCAN_LOCK(lhw);
950 cancel = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0;
951 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
955 hw = LHW_TO_HW(lhw);
957 IEEE80211_UNLOCK(lhw->ic);
958 LKPI_80211_LHW_LOCK(lhw);
961 LKPI_80211_LHW_UNLOCK(lhw);
964 LKPI_80211_LHW_SCAN_LOCK(lhw);
965 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0)
966 error = msleep(lhw, &lhw->scan_mtx, 0, "lhwscanstop", hz/2);
967 cancel = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0;
968 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
970 IEEE80211_LOCK(lhw->ic);
973 ic_printf(lhw->ic, "%s: failed to cancel scan: %d (%p, %p)\n",
974 __func__, error, lhw, vif);
980 struct lkpi_hw *lhw;
991 lhw = HW_TO_LHW(hw);
992 ic_printf(lhw->ic, "ERROR: %s: config %#0x returned %d\n",
999 struct lkpi_hw *lhw)
1007 lhw->update_mc = true;
1008 lkpi_update_mcast_filter(lhw->ic, true);
1076 lkpi_80211_flush_tx(struct lkpi_hw *lhw, struct lkpi_sta *lsta)
1082 LKPI_80211_LHW_UNLOCK_ASSERT(lhw);
1128 struct lkpi_hw *lhw;
1163 lhw = vap->iv_ic->ic_softc;
1164 chan = lkpi_find_lkpi80211_chan(lhw, ni->ni_chan);
1172 hw = LHW_TO_HW(lhw);
1191 LKPI_80211_LHW_LOCK(lhw);
1382 LKPI_80211_LHW_UNLOCK(lhw);
1427 LKPI_80211_LHW_UNLOCK(lhw);
1442 struct lkpi_hw *lhw;
1452 lhw = vap->iv_ic->ic_softc;
1453 hw = LHW_TO_HW(lhw);
1479 LKPI_80211_LHW_LOCK(lhw);
1557 LKPI_80211_LHW_UNLOCK(lhw);
1576 struct lkpi_hw *lhw;
1584 lhw = vap->iv_ic->ic_softc;
1585 hw = LHW_TO_HW(lhw);
1590 LKPI_80211_LHW_LOCK(lhw);
1656 LKPI_80211_LHW_UNLOCK(lhw);
1665 struct lkpi_hw *lhw;
1673 lhw = vap->iv_ic->ic_softc;
1674 hw = LHW_TO_HW(lhw);
1679 LKPI_80211_LHW_LOCK(lhw);
1723 LKPI_80211_LHW_UNLOCK(lhw);
1732 struct lkpi_hw *lhw;
1743 lhw = vap->iv_ic->ic_softc;
1744 hw = LHW_TO_HW(lhw);
1749 LKPI_80211_LHW_LOCK(lhw);
1785 LKPI_80211_LHW_UNLOCK(lhw);
1799 lkpi_80211_flush_tx(lhw, lsta);
1801 LKPI_80211_LHW_LOCK(lhw);
1841 bss_changed |= lkpi_disassoc(sta, vif, lhw);
1902 LKPI_80211_LHW_UNLOCK(lhw);
1944 struct lkpi_hw *lhw;
1955 lhw = vap->iv_ic->ic_softc;
1956 hw = LHW_TO_HW(lhw);
1961 LKPI_80211_LHW_LOCK(lhw);
2010 bss_changed |= lkpi_wme_update(lhw, vap, true);
2063 lhw->update_mc = true;
2100 LKPI_80211_LHW_UNLOCK(lhw);
2119 struct lkpi_hw *lhw;
2132 lhw = vap->iv_ic->ic_softc;
2133 hw = LHW_TO_HW(lhw);
2159 LKPI_80211_LHW_LOCK(lhw);
2174 LKPI_80211_LHW_UNLOCK(lhw);
2188 lkpi_80211_flush_tx(lhw, lsta);
2190 LKPI_80211_LHW_LOCK(lhw);
2247 lkpi_disassoc(sta, vif, lhw);
2252 LKPI_80211_LHW_UNLOCK(lhw);
2261 struct lkpi_hw *lhw;
2272 lhw = vap->iv_ic->ic_softc;
2273 hw = LHW_TO_HW(lhw);
2278 LKPI_80211_LHW_LOCK(lhw);
2314 LKPI_80211_LHW_UNLOCK(lhw);
2328 lkpi_80211_flush_tx(lhw, lsta);
2330 LKPI_80211_LHW_LOCK(lhw);
2418 bss_changed |= lkpi_disassoc(sta, vif, lhw);
2483 LKPI_80211_LHW_UNLOCK(lhw);
2558 struct lkpi_hw *lhw;
2577 lhw = ic->ic_softc;
2583 lkpi_stop_hw_scan(lhw, vif);
2674 lkpi_wme_update(struct lkpi_hw *lhw, struct ieee80211vap *vap, bool planned)
2697 if (lhw->ops->conf_tx == NULL)
2701 lhw->update_wme = true;
2704 lhw->update_wme = false;
2706 ic = lhw->ic;
2713 hw = LHW_TO_HW(lhw);
2718 LKPI_80211_LHW_LOCK(lhw);
2733 LKPI_80211_LHW_UNLOCK(lhw);
2747 struct lkpi_hw *lhw;
2754 lhw = ic->ic_softc;
2756 lkpi_wme_update(lhw, vap, false);
2798 struct lkpi_hw *lhw;
2812 lhw = ic->ic_softc;
2813 hw = LHW_TO_HW(lhw);
2909 LKPI_80211_LHW_LVIF_LOCK(lhw);
2910 TAILQ_INSERT_TAIL(&lhw->lvif_head, lvif, lvif_entry);
2911 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
2919 LKPI_80211_LHW_LOCK(lhw);
2932 LKPI_80211_LHW_UNLOCK(lhw);
2950 if (lhw->ops->set_key != NULL) {
3004 struct lkpi_hw *lhw;
3012 lhw = ic->ic_softc;
3013 hw = LHW_TO_HW(lhw);
3017 LKPI_80211_LHW_LVIF_LOCK(lhw);
3018 TAILQ_REMOVE(&lhw->lvif_head, lvif, lvif_entry);
3019 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
3061 struct lkpi_hw *lhw;
3070 lhw = ic->ic_softc;
3072 hw = LHW_TO_HW(lhw);
3077 LKPI_80211_LHW_LOCK(lhw);
3089 LKPI_80211_LHW_UNLOCK(lhw);
3225 struct lkpi_hw *lhw;
3234 lhw = ic->ic_softc;
3235 LKPI_80211_LHW_SCAN_LOCK(lhw);
3236 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0) {
3238 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3241 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0;
3242 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3251 hw = LHW_TO_HW(lhw);
3322 s6ghzlen + chan_len + lhw->supbands * lhw->scan_ie_len +
3390 LKPI_80211_LHW_SCAN_LOCK(lhw);
3392 running = (lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0;
3394 KASSERT(lhw->hw_req == NULL, ("%s: ic %p lhw %p hw_req %p "
3395 "!= NULL\n", __func__, ic, lhw, lhw->hw_req));
3397 lhw->scan_flags |= LKPI_LHW_SCAN_RUNNING;
3398 lhw->hw_req = hw_req;
3400 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3424 LKPI_80211_LHW_SCAN_LOCK(lhw);
3425 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) != 0) {
3426 free(lhw->hw_req, M_LKPI80211);
3427 lhw->hw_req = NULL;
3428 lhw->scan_flags &= ~LKPI_LHW_SCAN_RUNNING;
3430 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3438 LKPI_80211_LHW_SCAN_LOCK(lhw);
3439 lhw->scan_flags &= ~LKPI_LHW_SCAN_HW;
3440 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3467 struct lkpi_hw *lhw;
3470 lhw = ic->ic_softc;
3471 LKPI_80211_LHW_SCAN_LOCK(lhw);
3472 if ((lhw->scan_flags & LKPI_LHW_SCAN_RUNNING) == 0) {
3473 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3476 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0;
3477 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3488 hw = LHW_TO_HW(lhw);
3505 struct lkpi_hw *lhw;
3508 lhw = ss->ss_ic->ic_softc;
3509 LKPI_80211_LHW_SCAN_LOCK(lhw);
3510 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0;
3511 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3513 lhw->ic_scan_curchan(ss, maxdwell);
3519 struct lkpi_hw *lhw;
3522 lhw = ss->ss_ic->ic_softc;
3523 LKPI_80211_LHW_SCAN_LOCK(lhw);
3524 is_hw_scan = (lhw->scan_flags & LKPI_LHW_SCAN_HW) != 0;
3525 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3527 lhw->ic_scan_mindwell(ss);
3533 struct lkpi_hw *lhw;
3540 lhw = ic->ic_softc;
3543 if (lhw->ops->config == NULL)
3547 LKPI_80211_LHW_SCAN_LOCK(lhw);
3549 (lhw->scan_flags & (LKPI_LHW_SCAN_RUNNING|LKPI_LHW_SCAN_HW)) ==
3551 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
3558 c, lhw->ops->config);
3562 chan = lkpi_find_lkpi80211_chan(lhw, c);
3572 hw = LHW_TO_HW(lhw);
3587 lhw->rtap_tx.wt_chan_freq = htole16(c->ic_freq);
3588 lhw->rtap_tx.wt_chan_flags = htole16(c->ic_flags);
3589 lhw->rtap_rx.wr_chan_freq = htole16(c->ic_freq);
3590 lhw->rtap_rx.wr_chan_flags = htole16(c->ic_flags);
3611 struct lkpi_hw *lhw;
3617 lhw = ic->ic_softc;
3620 if (lhw->ic_node_alloc == NULL)
3623 ni = lhw->ic_node_alloc(vap, mac);
3627 hw = LHW_TO_HW(lhw);
3630 if (lhw->ic_node_free != NULL)
3631 lhw->ic_node_free(ni);
3642 struct lkpi_hw *lhw;
3646 lhw = ic->ic_softc;
3648 if (lhw->ic_node_init != NULL) {
3649 error = lhw->ic_node_init(ni);
3664 struct lkpi_hw *lhw;
3667 lhw = ic->ic_softc;
3672 if (lhw->ic_node_cleanup != NULL)
3673 lhw->ic_node_cleanup(ni);
3680 struct lkpi_hw *lhw;
3684 lhw = ic->ic_softc;
3695 if (lhw->ic_node_free != NULL)
3696 lhw->ic_node_free(ni);
3751 struct lkpi_hw *lhw;
3787 lhw = ic->ic_softc;
3788 hw = LHW_TO_HW(lhw);
3794 rtap = &lhw->rtap_tx;
3916 LKPI_80211_LHW_LOCK(lhw);
3918 LKPI_80211_LHW_UNLOCK(lhw);
3931 LKPI_80211_LHW_LOCK(lhw);
3933 LKPI_80211_LHW_UNLOCK(lhw);
4009 struct lkpi_hw *lhw;
4012 lhw = ic->ic_softc;
4016 return (lhw->ic_recv_action(ni, wh, frm, efrm));
4023 struct lkpi_hw *lhw;
4026 lhw = ic->ic_softc;
4030 return (lhw->ic_send_action(ni, category, action, sa));
4038 struct lkpi_hw *lhw;
4041 lhw = ic->ic_softc;
4045 return (lhw->ic_ampdu_enable(ni, tap));
4059 struct lkpi_hw *lhw;
4070 lhw = ic->ic_softc;
4071 hw = LHW_TO_HW(lhw);
4094 LKPI_80211_LHW_LOCK(lhw);
4096 LKPI_80211_LHW_UNLOCK(lhw);
4104 return (lhw->ic_addba_request(ni, tap, dialogtoken, baparamset, batimeout));
4119 struct lkpi_hw *lhw;
4130 lhw = ic->ic_softc;
4131 hw = LHW_TO_HW(lhw);
4172 LKPI_80211_LHW_LOCK(lhw);
4174 LKPI_80211_LHW_UNLOCK(lhw);
4184 return (lhw->ic_addba_response(ni, tap, status, baparamset, batimeout));
4195 struct lkpi_hw *lhw;
4206 lhw = ic->ic_softc;
4207 hw = LHW_TO_HW(lhw);
4231 LKPI_80211_LHW_LOCK(lhw);
4233 LKPI_80211_LHW_UNLOCK(lhw);
4244 lhw->ic_addba_stop(ni, tap);
4251 struct lkpi_hw *lhw;
4254 lhw = ic->ic_softc;
4258 lhw->ic_addba_response_timeout(ni, tap);
4266 struct lkpi_hw *lhw;
4269 lhw = ic->ic_softc;
4273 lhw->ic_bar_response(ni, tap, status);
4281 struct lkpi_hw *lhw;
4292 lhw = ic->ic_softc;
4293 hw = LHW_TO_HW(lhw);
4329 LKPI_80211_LHW_LOCK(lhw);
4331 LKPI_80211_LHW_UNLOCK(lhw);
4344 error = lhw->ic_ampdu_rx_start(ni, rap, baparamset, batimeout, baseqctl);
4352 struct lkpi_hw *lhw;
4364 lhw = ic->ic_softc;
4378 hw = LHW_TO_HW(lhw);
4400 LKPI_80211_LHW_LOCK(lhw);
4402 LKPI_80211_LHW_UNLOCK(lhw);
4409 lhw->ic_ampdu_rx_stop(ni, rap);
4470 struct lkpi_hw *lhw;
4477 lhw = ic->ic_softc;
4478 hw = LHW_TO_HW(lhw);
4625 struct lkpi_hw *lhw;
4630 wiphy = wiphy_new(&linuxkpi_mac80211cfgops, sizeof(*lhw) + priv_len);
4634 lhw = wiphy_priv(wiphy);
4635 lhw->ops = ops;
4637 LKPI_80211_LHW_LOCK_INIT(lhw);
4638 LKPI_80211_LHW_SCAN_LOCK_INIT(lhw);
4639 LKPI_80211_LHW_TXQ_LOCK_INIT(lhw);
4640 sx_init_flags(&lhw->lvif_sx, "lhw-lvif", SX_RECURSE | SX_DUPOK);
4641 TAILQ_INIT(&lhw->lvif_head);
4643 lhw->txq_generation[ac] = 1;
4644 TAILQ_INIT(&lhw->scheduled_txqs[ac]);
4648 LKPI_80211_LHW_RXQ_LOCK_INIT(lhw);
4649 TASK_INIT(&lhw->rxq_task, 0, lkpi_80211_lhw_rxq_task, lhw);
4650 mbufq_init(&lhw->rxq, IFQ_MAXLEN);
4651 lhw->rxq_stopped = false;
4657 hw = LHW_TO_HW(lhw);
4660 hw->priv = (void *)(lhw + 1);
4663 lhw->ic = lkpi_ieee80211_ifalloc();
4673 struct lkpi_hw *lhw;
4676 lhw = HW_TO_LHW(hw);
4677 free(lhw->ic, M_LKPI80211);
4678 lhw->ic = NULL;
4683 LKPI_80211_LHW_RXQ_LOCK(lhw);
4684 lhw->rxq_stopped = true;
4685 LKPI_80211_LHW_RXQ_UNLOCK(lhw);
4688 while (taskqueue_cancel(taskqueue_thread, &lhw->rxq_task, NULL) != 0)
4689 taskqueue_drain(taskqueue_thread, &lhw->rxq_task);
4692 m = mbufq_dequeue(&lhw->rxq);
4704 m = mbufq_dequeue(&lhw->rxq);
4706 KASSERT(mbufq_empty(&lhw->rxq), ("%s: lhw %p has rxq len %d != 0\n",
4707 __func__, lhw, mbufq_len(&lhw->rxq)));
4708 LKPI_80211_LHW_RXQ_LOCK_DESTROY(lhw);
4710 /* Cleanup more of lhw here or in wiphy_free()? */
4711 LKPI_80211_LHW_TXQ_LOCK_DESTROY(lhw);
4712 LKPI_80211_LHW_SCAN_LOCK_DESTROY(lhw);
4713 LKPI_80211_LHW_LOCK_DESTROY(lhw);
4714 sx_destroy(&lhw->lvif_sx);
4721 struct lkpi_hw *lhw;
4724 lhw = HW_TO_LHW(hw);
4725 ic = lhw->ic;
4728 ic->ic_softc = lhw;
4737 struct lkpi_hw *lhw;
4739 lhw = wiphy_priv(wiphy);
4740 return (LHW_TO_HW(lhw));
4744 lkpi_radiotap_attach(struct lkpi_hw *lhw)
4748 ic = lhw->ic;
4750 &lhw->rtap_tx.wt_ihdr, sizeof(lhw->rtap_tx),
4752 &lhw->rtap_rx.wr_ihdr, sizeof(lhw->rtap_rx),
4760 struct lkpi_hw *lhw;
4763 lhw = HW_TO_LHW(hw);
4764 ic = lhw->ic;
4767 lhw->workq = alloc_ordered_workqueue(wiphy_name(hw->wiphy), 0);
4768 if (lhw->workq == NULL)
4810 if (lhw->ops->hw_scan) {
4819 lhw->scan_flags |= LKPI_LHW_SCAN_HW;
4866 lhw->ic_scan_curchan = ic->ic_scan_curchan;
4868 lhw->ic_scan_mindwell = ic->ic_scan_mindwell;
4871 lhw->ic_node_alloc = ic->ic_node_alloc;
4873 lhw->ic_node_init = ic->ic_node_init;
4875 lhw->ic_node_cleanup = ic->ic_node_cleanup;
4877 lhw->ic_node_free = ic->ic_node_free;
4885 if (lhw->ops->ampdu_action != NULL) {
4886 lhw->ic_recv_action = ic->ic_recv_action;
4888 lhw->ic_send_action = ic->ic_send_action;
4891 lhw->ic_ampdu_enable = ic->ic_ampdu_enable;
4894 lhw->ic_addba_request = ic->ic_addba_request;
4896 lhw->ic_addba_response = ic->ic_addba_response;
4898 lhw->ic_addba_stop = ic->ic_addba_stop;
4900 lhw->ic_addba_response_timeout = ic->ic_addba_response_timeout;
4903 lhw->ic_bar_response = ic->ic_bar_response;
4906 lhw->ic_ampdu_rx_start = ic->ic_ampdu_rx_start;
4908 lhw->ic_ampdu_rx_stop = ic->ic_ampdu_rx_stop;
4913 lkpi_radiotap_attach(lhw);
4921 lhw->supbands = lhw->max_rates = 0;
4930 lhw->supbands++;
4931 lhw->max_rates = max(lhw->max_rates, supband->n_bitrates);
4955 if (lhw->max_rates > IEEE80211_RATE_MAXSIZE) {
4957 lhw->max_rates, IEEE80211_RATE_MAXSIZE);
4958 lhw->max_rates = IEEE80211_RATE_MAXSIZE;
4968 lhw->scan_ie_len = 2 + IEEE80211_RATE_SIZE;
4969 if (lhw->max_rates > IEEE80211_RATE_SIZE)
4970 lhw->scan_ie_len += 2 + (lhw->max_rates - IEEE80211_RATE_SIZE);
4978 lhw->scan_ie_len += 2 + 1;
4983 lhw->scan_ie_len += sizeof(struct ieee80211_ie_htcap);
4987 lhw->scan_ie_len += 2 + sizeof(struct ieee80211_vht_cap);
4992 if (lhw->scan_ie_len > hw->wiphy->max_scan_ie_len)
4994 hw->wiphy->max_scan_ie_len -= lhw->scan_ie_len;
5009 struct lkpi_hw *lhw;
5012 lhw = HW_TO_LHW(hw);
5013 ic = lhw->ic;
5023 struct lkpi_hw *lhw;
5028 lhw = HW_TO_LHW(hw);
5034 ic_printf(lhw->ic, "XXX TODO %s flags(%#x) not yet supported.\n",
5043 LKPI_80211_LHW_LVIF_LOCK(lhw);
5044 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) {
5076 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
5096 struct lkpi_hw *lhw;
5104 lhw = HW_TO_LHW(hw);
5108 LKPI_80211_LHW_LVIF_LOCK(lhw);
5109 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) {
5121 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
5128 struct lkpi_hw *lhw;
5136 lhw = HW_TO_LHW(hw);
5138 LKPI_80211_LHW_LVIF_LOCK(lhw);
5139 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) {
5150 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
5167 struct lkpi_hw *lhw;
5171 lhw = wiphy_priv(wiphy);
5172 ic = lhw->ic;
5190 struct lkpi_hw *lhw;
5194 lhw = wiphy_priv(hw->wiphy);
5195 ic = lhw->ic;
5200 LKPI_80211_LHW_SCAN_LOCK(lhw);
5201 free(lhw->hw_req, M_LKPI80211);
5202 lhw->hw_req = NULL;
5203 lhw->scan_flags &= ~LKPI_LHW_SCAN_RUNNING;
5204 wakeup(lhw);
5205 LKPI_80211_LHW_SCAN_UNLOCK(lhw);
5211 lkpi_80211_lhw_rxq_rx_one(struct lkpi_hw *lhw, struct mbuf *m)
5232 ok = ieee80211_input_mimo_all(lhw->ic, m);
5245 struct lkpi_hw *lhw;
5249 lhw = ctx;
5253 printf("TRACE-RX: %s: lhw %p pending %d mbuf_qlen %d\n",
5254 __func__, lhw, pending, mbufq_len(&lhw->rxq));
5259 LKPI_80211_LHW_RXQ_LOCK(lhw);
5260 mbufq_concat(&mq, &lhw->rxq);
5261 LKPI_80211_LHW_RXQ_UNLOCK(lhw);
5265 lkpi_80211_lhw_rxq_rx_one(lhw, m);
5276 struct lkpi_hw *lhw;
5389 lhw = HW_TO_LHW(hw);
5390 ic = lhw->ic;
5457 rtap = &lhw->rtap_rx;
5512 LKPI_80211_LHW_RXQ_LOCK(lhw);
5513 if (lhw->rxq_stopped) {
5514 LKPI_80211_LHW_RXQ_UNLOCK(lhw);
5519 mbufq_enqueue(&lhw->rxq, m);
5520 taskqueue_enqueue(taskqueue_thread, &lhw->rxq_task);
5521 LKPI_80211_LHW_RXQ_UNLOCK(lhw);
5791 struct lkpi_hw *lhw;
5797 lhw = wiphy_priv(hw->wiphy);
5800 LKPI_80211_LHW_LVIF_LOCK(lhw);
5801 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) {
5813 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
6058 struct lkpi_hw *lhw;
6063 lhw = HW_TO_LHW(hw);
6064 queue_delayed_work(lhw->workq, w, delay);
6071 struct lkpi_hw *lhw;
6076 lhw = HW_TO_LHW(hw);
6077 queue_work(lhw->workq, w);
6228 struct lkpi_hw *lhw;
6236 lhw = wiphy_priv(hw->wiphy);
6244 LKPI_80211_LHW_LVIF_LOCK(lhw);
6245 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) {
6258 ic_printf(lhw->ic, "%s:%d: lhw %p hw %p "
6261 lhw, hw, lvif, vif, ac, qnum);
6267 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
6284 struct lkpi_hw *lhw;
6295 lhw = wiphy_priv(hw->wiphy);
6298 LKPI_80211_LHW_LVIF_LOCK(lhw);
6299 TAILQ_FOREACH(lvif, &lhw->lvif_head, lvif_entry) {
6316 ic_printf(lhw->ic, "%s:%d: lhw %p hw %p "
6319 lhw, hw, lvif, vif, ac);
6351 LKPI_80211_LHW_LVIF_UNLOCK(lhw);
6378 struct lkpi_hw *lhw;
6380 lhw = HW_TO_LHW(hw);
6384 if (++lhw->txq_generation[ac] == 0)
6385 lhw->txq_generation[ac]++;
6391 struct lkpi_hw *lhw;
6395 lhw = HW_TO_LHW(hw);
6401 if (lhw->txq_generation[ac] == 0)
6404 ltxq = TAILQ_FIRST(&lhw->scheduled_txqs[ac]);
6407 if (ltxq->txq_generation == lhw->txq_generation[ac])
6410 ltxq->txq_generation = lhw->txq_generation[ac];
6411 TAILQ_REMOVE(&lhw->scheduled_txqs[ac], ltxq, txq_entry);
6422 struct lkpi_hw *lhw;
6445 lhw = HW_TO_LHW(hw);
6446 TAILQ_INSERT_TAIL(&lhw->scheduled_txqs[txq->ac], ltxq, txq_entry);
6455 struct lkpi_hw *lhw;
6460 lhw = HW_TO_LHW(hw);
6462 LKPI_80211_LHW_TXQ_LOCK(lhw);
6481 LKPI_80211_LHW_TXQ_UNLOCK(lhw);
6578 struct lkpi_hw *lhw;
6581 lhw = wiphy_priv(wiphy);
6586 ic_printf(lhw->ic, "%s: alloc failed.\n", __func__);
6601 vap = TAILQ_FIRST(&lhw->ic->ic_vaps);
6629 struct lkpi_hw *lhw;
6633 lhw = wiphy_priv(wiphy);
6634 ic = lhw->ic;
6641 (lhw->sc_flags & LKPI_MAC80211_DRV_STARTED) == 0)