Lines Matching refs:wil
64 bool wil_is_tx_idle(struct wil6210_priv *wil)
68 int min_ring_id = wil_get_min_tx_ring_id(wil);
71 struct wil_ring *vring = &wil->ring_tx[i];
72 int vring_index = vring - wil->ring_tx;
74 &wil->ring_tx_data[vring_index];
85 if (test_bit(wil_status_napi_en, wil->status)) {
88 wil_dbg_pm(wil,
93 wil_dbg_ratelimited(wil,
96 napi_synchronize(&wil->napi_tx);
110 static int wil_vring_alloc(struct wil6210_priv *wil, struct wil_ring *vring)
112 struct device *dev = wil_to_dev(wil);
116 wil_dbg_misc(wil, "vring_alloc:\n");
140 if (wil->dma_addr_size > 32)
150 if (wil->dma_addr_size > 32)
152 DMA_BIT_MASK(wil->dma_addr_size));
165 wil_dbg_misc(wil, "vring[%d] 0x%p:%pad 0x%p\n", vring->size,
190 static void wil_vring_free(struct wil6210_priv *wil, struct wil_ring *vring)
192 struct device *dev = wil_to_dev(wil);
195 lockdep_assert_held(&wil->mutex);
197 int vring_index = vring - wil->ring_tx;
199 wil_dbg_misc(wil, "free Tx vring %d [%d] 0x%p:%pad 0x%p\n",
203 wil_dbg_misc(wil, "free Rx vring [%d] 0x%p:%pad 0x%p\n",
220 wil_dbg_txrx(wil,
256 static int wil_vring_alloc_skb(struct wil6210_priv *wil, struct wil_ring *vring,
259 struct device *dev = wil_to_dev(wil);
260 unsigned int sz = wil->rx_buf_len + ETH_HLEN + wil_rx_snaplen();
305 static void wil_rx_add_radiotap_header(struct wil6210_priv *wil,
324 struct ieee80211_channel *ch = wil->monitor_chandef.chan;
328 wil_err(wil, "Unable to expand headroom to %d\n", rtap_len);
351 static bool wil_is_rx_idle(struct wil6210_priv *wil)
354 struct wil_ring *ring = &wil->ring_rx;
363 static int wil_rx_get_cid_by_skb(struct wil6210_priv *wil, struct sk_buff *skb)
367 struct wil6210_vif *vif = wil->vifs[mid];
386 wil_err_ratelimited(wil,
394 wil_err_ratelimited(wil, "Short frame, len = %d\n",
402 if (wil->max_assoc_sta <= WIL6210_RX_DESC_MAX_CID)
417 for (i = cid; i < wil->max_assoc_sta; i += WIL6210_RX_DESC_MAX_CID) {
418 if (wil->sta[i].status != wil_sta_unused &&
419 ether_addr_equal(wil->sta[i].addr, ta)) {
424 if (i >= wil->max_assoc_sta) {
425 wil_err_ratelimited(wil, "Could not find cid for frame with transmit addr = %pM, iftype = %d, frametype = %d, len = %d\n",
439 static struct sk_buff *wil_vring_reap_rx(struct wil6210_priv *wil,
442 struct device *dev = wil_to_dev(wil);
450 unsigned int sz = wil->rx_buf_len + ETH_HLEN + snaplen;
474 wil_err(wil, "No Rx skb at [%d]\n", i);
485 wil_dbg_txrx(wil, "Rx[%3d] : %d bytes\n", i, dmalen);
490 vif = wil->vifs[mid];
493 wil_dbg_txrx(wil, "skipped RX descriptor with invalid mid %d",
500 wil_err_ratelimited(wil, "Rx size too large: %d bytes!\n",
512 cid = wil_rx_get_cid_by_skb(wil, skb);
518 stats = &wil->sta[cid].stats;
526 wil_rx_add_radiotap_header(wil, skb);
541 wil_dbg_txrx(wil,
546 wil_dbg_txrx(wil,
549 wil_rx_bar(wil, vif, cid, tid, seq);
554 wil_dbg_txrx(wil,
605 static int wil_rx_refill(struct wil6210_priv *wil, int count)
607 struct net_device *ndev = wil->main_ndev;
608 struct wil_ring *v = &wil->ring_rx;
617 rc = wil_vring_alloc_skb(wil, v, v->swtail, headroom);
619 wil_err_ratelimited(wil, "Error %d in rx refill[%d]\n",
630 wil_w(wil, v->hwtail, v->swtail);
658 static int wil_rx_crypto_check(struct wil6210_priv *wil, struct sk_buff *skb)
665 struct wil_sta_info *s = &wil->sta[cid];
672 wil_err_ratelimited(wil,
679 wil_err_ratelimited(wil,
689 static int wil_rx_error_check(struct wil6210_priv *wil, struct sk_buff *skb,
697 wil_dbg_txrx(wil, "MIC error, dropping packet\n");
719 static struct wil_eapol_key *wil_is_ptk_eapol_key(struct wil6210_priv *wil,
729 wil_err(wil, "mac header was not set\n");
757 static bool wil_skb_is_eap_3(struct wil6210_priv *wil, struct sk_buff *skb)
762 key = wil_is_ptk_eapol_key(wil, skb);
770 wil_dbg_misc(wil, "EAPOL key message 3\n");
774 wil_dbg_misc(wil, "EAPOL key message 1\n");
779 static bool wil_skb_is_eap_4(struct wil6210_priv *wil, struct sk_buff *skb)
784 key = wil_is_ptk_eapol_key(wil, skb);
792 wil_dbg_misc(wil, "EAPOL key message 2\n");
796 wil_dbg_misc(wil, "EAPOL key message 4\n");
805 struct wil6210_priv *wil = vif_to_wil(vif);
810 wil_dbg_misc(wil, "Invalid rekey state = %d\n",
816 cid = wil_find_cid_by_idx(wil, vif->mid, 0);
817 if (!wil_cid_valid(wil, cid)) {
818 wil_err(wil, "Invalid cid = %d\n", cid);
823 wil_dbg_misc(wil, "Apply PTK key after eapol was sent out\n");
824 rc = wmi_add_cipher_key(vif, 0, wil->sta[cid].addr, 0, NULL,
831 wil_err(wil, "Apply PTK key failed %d\n", rc);
836 struct wil6210_priv *wil = vif_to_wil(vif);
841 !test_bit(WMI_FW_CAPABILITY_SPLIT_REKEY, wil->fw_capabilities))
845 if (!wil_skb_is_eap_4(wil, skb))
848 spin_lock_bh(&wil->eap_lock);
860 wil_err(wil, "Unknown rekey state = %d",
863 spin_unlock_bh(&wil->eap_lock);
866 q = queue_work(wil->wmi_wq, &vif->enable_tx_key_worker);
867 wil_dbg_misc(wil, "queue_work of enable_tx_key_worker -> %d\n",
874 struct wil6210_priv *wil = vif_to_wil(vif);
878 !test_bit(WMI_FW_CAPABILITY_SPLIT_REKEY, wil->fw_capabilities))
882 if (!wil_skb_is_eap_3(wil, skb))
897 struct wil6210_priv *wil = ndev_to_wil(ndev);
914 wil_dbg_txrx(wil, "Rx drop %d bytes\n", len);
924 int xmit_cid = wil_find_cid(wil, vif->mid, da);
947 wil_dbg_txrx(wil, "Rx -> Tx %d bytes\n", len);
959 napi_gro_receive(&wil->napi_rx, skb);
974 struct wil6210_priv *wil = ndev_to_wil(ndev);
977 wil->txrx_ops.get_netif_rx_params(skb, &cid, &security);
979 stats = &wil->sta[cid].stats;
983 if (security && (wil->txrx_ops.rx_crypto_check(wil, skb) != 0)) {
984 wil_dbg_txrx(wil, "Rx drop %d bytes\n", skb->len);
993 if (unlikely(wil->txrx_ops.rx_error_check(wil, skb, stats))) {
1005 void wil_rx_handle(struct wil6210_priv *wil, int *quota)
1007 struct net_device *ndev = wil->main_ndev;
1009 struct wil_ring *v = &wil->ring_rx;
1013 wil_err(wil, "Rx IRQ while Rx not yet initialized\n");
1016 wil_dbg_txrx(wil, "rx_handle\n");
1017 while ((*quota > 0) && (NULL != (skb = wil_vring_reap_rx(wil, v)))) {
1029 wil_rx_reorder(wil, skb);
1032 wil_rx_refill(wil, v->size);
1035 static void wil_rx_buf_len_init(struct wil6210_priv *wil)
1037 wil->rx_buf_len = rx_large_buf ?
1039 if (mtu_max > wil->rx_buf_len) {
1044 wil_info(wil, "Override RX buffer to mtu_max(%d)\n", mtu_max);
1045 wil->rx_buf_len = mtu_max;
1049 static int wil_rx_init(struct wil6210_priv *wil, uint order)
1051 struct wil_ring *vring = &wil->ring_rx;
1054 wil_dbg_misc(wil, "rx_init\n");
1057 wil_err(wil, "Rx ring already allocated\n");
1061 wil_rx_buf_len_init(wil);
1065 rc = wil_vring_alloc(wil, vring);
1069 rc = wmi_rx_chain_add(wil, vring);
1073 rc = wil_rx_refill(wil, vring->size);
1079 wil_vring_free(wil, vring);
1084 static void wil_rx_fini(struct wil6210_priv *wil)
1086 struct wil_ring *vring = &wil->ring_rx;
1088 wil_dbg_misc(wil, "rx_fini\n");
1091 wil_vring_free(wil, vring);
1137 struct wil6210_priv *wil = vif_to_wil(vif);
1164 struct wil_ring *vring = &wil->ring_tx[id];
1165 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[id];
1175 wil_dbg_misc(wil, "vring_init_tx: max_mpdu_size %d\n",
1177 lockdep_assert_held(&wil->mutex);
1180 wil_err(wil, "Tx ring [%d] already allocated\n", id);
1188 rc = wil_vring_alloc(wil, vring);
1192 wil->ring2cid_tid[id][0] = cid;
1193 wil->ring2cid_tid[id][1] = tid;
1199 rc = wmi_call(wil, WMI_VRING_CFG_CMDID, vif->mid, &cmd, sizeof(cmd),
1206 wil_err(wil, "Tx config failed, status 0x%02x\n",
1219 wil_addba_tx_request(wil, id, agg_wsize);
1227 wil_vring_free(wil, vring);
1228 wil->ring2cid_tid[id][0] = wil->max_assoc_sta;
1229 wil->ring2cid_tid[id][1] = 0;
1239 struct wil6210_priv *wil = vif_to_wil(vif);
1267 struct wil_ring *vring = &wil->ring_tx[ring_id];
1268 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_id];
1270 wil_dbg_misc(wil, "vring_modify: ring %d cid %d tid %d\n", ring_id,
1272 lockdep_assert_held(&wil->mutex);
1275 wil_err(wil, "Tx ring [%d] not allocated\n", ring_id);
1279 if (wil->ring2cid_tid[ring_id][0] != cid ||
1280 wil->ring2cid_tid[ring_id][1] != tid) {
1281 wil_err(wil, "ring info does not match cid=%u tid=%u\n",
1282 wil->ring2cid_tid[ring_id][0],
1283 wil->ring2cid_tid[ring_id][1]);
1288 rc = wmi_call(wil, WMI_VRING_CFG_CMDID, vif->mid, &cmd, sizeof(cmd),
1295 wil_err(wil, "Tx modify failed, status 0x%02x\n",
1306 wil_addba_tx_request(wil, ring_id, agg_wsize);
1314 wil->ring2cid_tid[ring_id][0] = wil->max_assoc_sta;
1315 wil->ring2cid_tid[ring_id][1] = 0;
1321 struct wil6210_priv *wil = vif_to_wil(vif);
1341 struct wil_ring *vring = &wil->ring_tx[id];
1342 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[id];
1344 wil_dbg_misc(wil, "vring_init_bcast: max_mpdu_size %d\n",
1346 lockdep_assert_held(&wil->mutex);
1349 wil_err(wil, "Tx ring [%d] already allocated\n", id);
1357 rc = wil_vring_alloc(wil, vring);
1361 wil->ring2cid_tid[id][0] = wil->max_assoc_sta; /* CID */
1362 wil->ring2cid_tid[id][1] = 0; /* TID */
1368 rc = wmi_call(wil, WMI_BCAST_VRING_CFG_CMDID, vif->mid,
1376 wil_err(wil, "Tx config failed, status 0x%02x\n",
1394 wil_vring_free(wil, vring);
1400 static struct wil_ring *wil_find_tx_ucast(struct wil6210_priv *wil,
1406 int min_ring_id = wil_get_min_tx_ring_id(wil);
1408 cid = wil_find_cid(wil, vif->mid, da);
1410 if (cid < 0 || cid >= wil->max_assoc_sta)
1414 for (i = min_ring_id; i < ARRAY_SIZE(wil->ring2cid_tid); i++) {
1415 if (!wil->ring_tx_data[i].dot1x_open &&
1418 if (wil->ring2cid_tid[i][0] == cid) {
1419 struct wil_ring *v = &wil->ring_tx[i];
1420 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[i];
1422 wil_dbg_txrx(wil, "find_tx_ucast: (%pM) -> [%d]\n",
1427 wil_dbg_txrx(wil,
1438 static int wil_tx_ring(struct wil6210_priv *wil, struct wil6210_vif *vif,
1441 static struct wil_ring *wil_find_tx_ring_sta(struct wil6210_priv *wil,
1449 int min_ring_id = wil_get_min_tx_ring_id(wil);
1456 ring = &wil->ring_tx[i];
1457 txdata = &wil->ring_tx_data[i];
1461 cid = wil->ring2cid_tid[i][0];
1462 if (cid >= wil->max_assoc_sta) /* skip BCAST */
1465 if (!wil->ring_tx_data[i].dot1x_open &&
1469 wil_dbg_txrx(wil, "Tx -> ring %d\n", i);
1474 wil_dbg_txrx(wil, "Tx while no rings active?\n");
1490 static struct wil_ring *wil_find_tx_bcast_1(struct wil6210_priv *wil,
1500 v = &wil->ring_tx[i];
1501 txdata = &wil->ring_tx_data[i];
1504 if (!wil->ring_tx_data[i].dot1x_open &&
1514 static bool wil_check_multicast_to_unicast(struct wil6210_priv *wil,
1521 if (!wil->multicast_to_unicast)
1540 static void wil_set_da_for_vring(struct wil6210_priv *wil,
1544 int cid = wil->ring2cid_tid[vring_index][0];
1546 ether_addr_copy(da, wil->sta[cid].addr);
1549 static struct wil_ring *wil_find_tx_bcast_2(struct wil6210_priv *wil,
1559 int min_ring_id = wil_get_min_tx_ring_id(wil);
1563 v = &wil->ring_tx[i];
1564 txdata = &wil->ring_tx_data[i];
1568 cid = wil->ring2cid_tid[i][0];
1569 if (cid >= wil->max_assoc_sta) /* skip BCAST */
1571 if (!wil->ring_tx_data[i].dot1x_open &&
1576 if (0 == memcmp(wil->sta[cid].addr, src, ETH_ALEN))
1582 wil_dbg_txrx(wil, "Tx while no vrings active?\n");
1587 wil_dbg_txrx(wil, "BCAST -> ring %d\n", i);
1588 wil_set_da_for_vring(wil, skb, i);
1592 v2 = &wil->ring_tx[i];
1593 txdata2 = &wil->ring_tx_data[i];
1596 cid = wil->ring2cid_tid[i][0];
1597 if (cid >= wil->max_assoc_sta) /* skip BCAST */
1599 if (!wil->ring_tx_data[i].dot1x_open &&
1603 if (0 == memcmp(wil->sta[cid].addr, src, ETH_ALEN))
1608 wil_dbg_txrx(wil, "BCAST DUP -> ring %d\n", i);
1609 wil_set_da_for_vring(wil, skb2, i);
1610 wil_tx_ring(wil, vif, v2, skb2);
1614 wil_err(wil, "skb_copy failed\n");
1725 static int __wil_tx_vring_tso(struct wil6210_priv *wil, struct wil6210_vif *vif,
1728 struct device *dev = wil_to_dev(wil);
1751 int vring_index = vring - wil->ring_tx;
1752 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[vring_index];
1766 wil_dbg_txrx(wil, "tx_vring_tso: %d bytes to vring %d\n", skb->len,
1778 wil_err_ratelimited(wil,
1824 wil_err(wil, "TSO: Skb head DMA map error\n");
1828 wil->txrx_ops.tx_desc_map((union wil_tx_desc *)hdr_desc, pa,
1843 wil_dbg_txrx(wil, "TSO: process skb head, len %u\n",
1848 wil_dbg_txrx(wil, "TSO: frag[%d]: len %u\n", f, len);
1852 wil_dbg_txrx(wil,
1857 wil_err_ratelimited(wil, "TSO: ring overflow\n");
1864 wil_dbg_txrx(wil, "TSO: lenmss %d, i %d\n", lenmss, i);
1882 wil_err(wil, "TSO: DMA map page error\n");
1896 wil->txrx_ops.tx_desc_map((union wil_tx_desc *)d,
1910 wil_dbg_txrx(wil,
1979 if (wil_val_in_range(wil->ring_idle_trsh,
1982 wil_dbg_txrx(wil, "Ring[%2d] not idle %d -> %d\n",
1995 wil_dbg_txrx(wil, "TSO: Tx swhead %d -> %d\n", swhead, vring->swhead);
2002 if (wil->tx_latency)
2007 wil_w(wil, vring->hwtail, vring->swhead);
2028 static int __wil_tx_ring(struct wil6210_priv *wil, struct wil6210_vif *vif,
2031 struct device *dev = wil_to_dev(wil);
2038 int ring_index = ring - wil->ring_tx;
2039 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_index];
2046 wil_dbg_txrx(wil, "tx_ring: %d bytes to ring %d, nr_frags %d\n",
2053 wil_err_ratelimited(wil,
2062 wil_dbg_txrx(wil, "Tx[%2d] skb %d bytes 0x%p -> %pad\n", ring_index,
2071 wil->txrx_ops.tx_desc_map((union wil_tx_desc *)d, pa, len,
2080 wil_err(wil, "Tx[%2d] Failed to set cksum, drop packet\n",
2094 wil_dbg_txrx(wil, "Tx[%2d] desc[%4d]\n", ring_index, i);
2102 wil_err(wil, "Tx[%2d] failed to map fragment\n",
2107 wil->txrx_ops.tx_desc_map((union wil_tx_desc *)d,
2120 wil_dbg_txrx(wil, "Tx[%2d] desc[%4d]\n", ring_index, i);
2132 if (wil_val_in_range(wil->ring_idle_trsh,
2135 wil_dbg_txrx(wil, "Ring[%2d] not idle %d -> %d\n",
2148 wil_dbg_txrx(wil, "Tx[%2d] swhead %d -> %d\n", ring_index, swhead,
2157 if (wil->tx_latency)
2162 wil_w(wil, ring->hwtail, ring->swhead);
2176 wil->txrx_ops.tx_desc_unmap(dev,
2186 static int wil_tx_ring(struct wil6210_priv *wil, struct wil6210_vif *vif,
2189 int ring_index = ring - wil->ring_tx;
2190 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_index];
2195 if (test_bit(wil_status_suspending, wil->status) ||
2196 test_bit(wil_status_suspended, wil->status) ||
2197 test_bit(wil_status_resuming, wil->status)) {
2198 wil_dbg_txrx(wil,
2204 rc = (skb_is_gso(skb) ? wil->txrx_ops.tx_ring_tso : __wil_tx_ring)
2205 (wil, vif, ring, skb);
2228 static inline void __wil_update_net_queues(struct wil6210_priv *wil,
2234 int min_ring_id = wil_get_min_tx_ring_id(wil);
2240 wil_dbg_txrx(wil, "vring %d, mid %d, check_stop=%d, stopped=%d",
2241 (int)(ring - wil->ring_tx), vif->mid, check_stop,
2244 wil_dbg_txrx(wil, "check_stop=%d, mid=%d, stopped=%d",
2260 wil_dbg_txrx(wil, "netif_tx_stop called\n");
2266 if (test_bit(wil_status_suspending, wil->status) ||
2267 test_bit(wil_status_suspended, wil->status))
2272 struct wil_ring *cur_ring = &wil->ring_tx[i];
2273 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[i];
2280 wil_dbg_txrx(wil, "ring %d full, can't wake\n",
2281 (int)(cur_ring - wil->ring_tx));
2288 wil_dbg_txrx(wil, "calling netif_tx_wake\n");
2294 void wil_update_net_queues(struct wil6210_priv *wil, struct wil6210_vif *vif,
2297 spin_lock(&wil->net_queue_lock);
2298 __wil_update_net_queues(wil, vif, ring, check_stop);
2299 spin_unlock(&wil->net_queue_lock);
2302 void wil_update_net_queues_bh(struct wil6210_priv *wil, struct wil6210_vif *vif,
2305 spin_lock_bh(&wil->net_queue_lock);
2306 __wil_update_net_queues(wil, vif, ring, check_stop);
2307 spin_unlock_bh(&wil->net_queue_lock);
2313 struct wil6210_priv *wil = vif_to_wil(vif);
2320 wil_dbg_txrx(wil, "start_xmit\n");
2321 if (unlikely(!test_bit(wil_status_fwready, wil->status))) {
2323 wil_err(wil, "FW not ready\n");
2329 wil_dbg_ratelimited(wil,
2334 wil_err(wil, "Xmit in monitor mode not supported\n");
2342 ring = wil_find_tx_ring_sta(wil, vif, skb);
2344 if (vif->pbss || wil_check_multicast_to_unicast(wil, skb))
2348 ring = wil_find_tx_bcast_2(wil, vif, skb);
2351 ring = wil_find_tx_bcast_1(wil, vif, skb);
2356 ring = wil_find_tx_bcast_2(wil, vif, skb);
2359 ring = wil_find_tx_ucast(wil, vif, skb);
2362 wil_dbg_txrx(wil, "No Tx RING found for %pM\n", da);
2366 rc = wil_tx_ring(wil, vif, ring, skb);
2371 wil_update_net_queues_bh(wil, vif, ring, true);
2389 void wil_tx_latency_calc(struct wil6210_priv *wil, struct sk_buff *skb,
2395 if (!wil->tx_latency)
2402 bin = skb_time_us / wil->tx_latency_res;
2405 wil_dbg_txrx(wil, "skb time %dus => bin %d\n", skb_time_us, bin);
2422 struct wil6210_priv *wil = vif_to_wil(vif);
2424 struct device *dev = wil_to_dev(wil);
2425 struct wil_ring *vring = &wil->ring_tx[ringid];
2426 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ringid];
2428 int cid = wil->ring2cid_tid[ringid][0];
2435 wil_err(wil, "Tx irq[%d]: vring not initialized\n", ringid);
2440 wil_info(wil, "Tx irq[%d]: vring disabled\n", ringid);
2444 wil_dbg_txrx(wil, "tx_complete: (%d)\n", ringid);
2448 if (cid < wil->max_assoc_sta)
2449 stats = &wil->sta[cid].stats;
2480 wil_dbg_txrx(wil,
2487 wil->txrx_ops.tx_desc_unmap(dev,
2499 wil_tx_latency_calc(wil, skb,
2500 &wil->sta[cid]);
2532 if (wil_val_in_range(wil->ring_idle_trsh,
2534 wil_dbg_txrx(wil, "Ring[%2d] idle %d -> %d\n",
2541 wil_update_net_queues(wil, vif, vring, false);
2546 static inline int wil_tx_init(struct wil6210_priv *wil)
2551 static inline void wil_tx_fini(struct wil6210_priv *wil) {}
2553 static void wil_get_reorder_params(struct wil6210_priv *wil,
2567 void wil_init_txrx_ops_legacy_dma(struct wil6210_priv *wil)
2569 wil->txrx_ops.configure_interrupt_moderation =
2572 wil->txrx_ops.tx_desc_map = wil_tx_desc_map;
2573 wil->txrx_ops.tx_desc_unmap = wil_txdesc_unmap;
2574 wil->txrx_ops.tx_ring_tso = __wil_tx_vring_tso;
2575 wil->txrx_ops.ring_init_tx = wil_vring_init_tx;
2576 wil->txrx_ops.ring_fini_tx = wil_vring_free;
2577 wil->txrx_ops.ring_init_bcast = wil_vring_init_bcast;
2578 wil->txrx_ops.tx_init = wil_tx_init;
2579 wil->txrx_ops.tx_fini = wil_tx_fini;
2580 wil->txrx_ops.tx_ring_modify = wil_tx_vring_modify;
2582 wil->txrx_ops.rx_init = wil_rx_init;
2583 wil->txrx_ops.wmi_addba_rx_resp = wmi_addba_rx_resp;
2584 wil->txrx_ops.get_reorder_params = wil_get_reorder_params;
2585 wil->txrx_ops.get_netif_rx_params =
2587 wil->txrx_ops.rx_crypto_check = wil_rx_crypto_check;
2588 wil->txrx_ops.rx_error_check = wil_rx_error_check;
2589 wil->txrx_ops.is_rx_idle = wil_is_rx_idle;
2590 wil->txrx_ops.rx_fini = wil_rx_fini;