Lines Matching refs:wil
47 static int wil_find_free_sring(struct wil6210_priv *wil)
52 if (!wil->srings[i].va)
59 static void wil_sring_free(struct wil6210_priv *wil,
62 struct device *dev = wil_to_dev(wil);
70 wil_dbg_misc(wil, "status_ring_free, size(bytes)=%zu, 0x%p:%pad\n",
78 static int wil_sring_alloc(struct wil6210_priv *wil,
81 struct device *dev = wil_to_dev(wil);
84 wil_dbg_misc(wil, "status_ring_alloc: size=%zu\n", sz);
87 wil_err(wil, "Cannot allocate a zero size status ring\n");
100 wil_dbg_misc(wil, "status_ring[%d] 0x%p:%pad\n", sring->size, sring->va,
106 static int wil_tx_init_edma(struct wil6210_priv *wil)
108 int ring_id = wil_find_free_sring(wil);
113 if (wil->tx_status_ring_order < WIL_SRING_SIZE_ORDER_MIN ||
114 wil->tx_status_ring_order > WIL_SRING_SIZE_ORDER_MAX)
115 wil->tx_status_ring_order = WIL_TX_SRING_SIZE_ORDER_DEFAULT;
117 status_ring_size = 1 << wil->tx_status_ring_order;
119 wil_dbg_misc(wil, "init TX sring: size=%u, ring_id=%u\n",
128 sring = &wil->srings[ring_id];
133 rc = wil_sring_alloc(wil, sring);
137 rc = wil_wmi_tx_sring_cfg(wil, ring_id);
142 wil->tx_sring_idx = ring_id;
146 wil_sring_free(wil, sring);
151 static int wil_ring_alloc_skb_edma(struct wil6210_priv *wil,
154 struct device *dev = wil_to_dev(wil);
155 unsigned int sz = wil->rx_buf_len;
158 struct list_head *active = &wil->rx_buff_mgmt.active;
159 struct list_head *free = &wil->rx_buff_mgmt.free;
161 struct wil_rx_buff *buff_arr = wil->rx_buff_mgmt.buff_arr;
168 wil->rx_buff_mgmt.free_list_empty_cnt++;
231 static int wil_rx_refill_edma(struct wil6210_priv *wil)
233 struct wil_ring *ring = &wil->ring_rx;
241 rc = wil_ring_alloc_skb_edma(wil, ring, ring->swhead);
244 wil_dbg_txrx(wil, "No free buffer ID found\n");
246 wil_err_ratelimited(wil,
258 wil_w(wil, ring->hwtail, ring->swhead);
263 static void wil_move_all_rx_buff_to_free_list(struct wil6210_priv *wil,
266 struct device *dev = wil_to_dev(wil);
267 struct list_head *active = &wil->rx_buff_mgmt.active;
270 if (!wil->rx_buff_mgmt.buff_arr)
279 wil_err(wil, "No Rx skb at buff_id %d\n", rx_buff->id);
283 dma_unmap_single(dev, pa, wil->rx_buf_len,
289 list_move(&rx_buff->list, &wil->rx_buff_mgmt.free);
293 static void wil_free_rx_buff_arr(struct wil6210_priv *wil)
295 struct wil_ring *ring = &wil->ring_rx;
297 if (!wil->rx_buff_mgmt.buff_arr)
303 wil_move_all_rx_buff_to_free_list(wil, ring);
305 kfree(wil->rx_buff_mgmt.buff_arr);
306 wil->rx_buff_mgmt.buff_arr = NULL;
309 static int wil_init_rx_buff_arr(struct wil6210_priv *wil,
313 struct list_head *active = &wil->rx_buff_mgmt.active;
314 struct list_head *free = &wil->rx_buff_mgmt.free;
317 wil->rx_buff_mgmt.buff_arr = kcalloc(size + 1,
320 if (!wil->rx_buff_mgmt.buff_arr)
330 buff_arr = wil->rx_buff_mgmt.buff_arr;
336 wil->rx_buff_mgmt.size = size + 1;
341 static int wil_init_rx_sring(struct wil6210_priv *wil,
346 struct wil_status_ring *sring = &wil->srings[ring_id];
349 wil_dbg_misc(wil, "init RX sring: size=%u, ring_id=%u\n",
357 rc = wil_sring_alloc(wil, sring);
361 rc = wil_wmi_rx_sring_add(wil, ring_id);
369 wil_sring_free(wil, sring);
373 static int wil_ring_alloc_desc_ring(struct wil6210_priv *wil,
376 struct device *dev = wil_to_dev(wil);
379 wil_dbg_misc(wil, "alloc_desc_ring:\n");
402 wil_dbg_misc(wil, "%s ring[%d] 0x%p:%pad 0x%p\n",
418 static void wil_ring_free_edma(struct wil6210_priv *wil, struct wil_ring *ring)
420 struct device *dev = wil_to_dev(wil);
429 lockdep_assert_held(&wil->mutex);
431 wil_dbg_misc(wil, "free Rx ring [%d] 0x%p:%pad 0x%p\n",
435 wil_move_all_rx_buff_to_free_list(wil, ring);
443 ring_index = ring - wil->ring_tx;
445 wil_dbg_misc(wil, "free Tx ring %d [%d] 0x%p:%pad 0x%p\n",
459 wil_dbg_txrx(wil,
480 static int wil_init_rx_desc_ring(struct wil6210_priv *wil, u16 desc_ring_size,
483 struct wil_ring *ring = &wil->ring_rx;
486 wil_dbg_misc(wil, "init RX desc ring\n");
490 rc = wil_ring_alloc_desc_ring(wil, ring);
494 rc = wil_wmi_rx_desc_ring_add(wil, status_ring_id);
500 wil_ring_free_edma(wil, ring);
504 static void wil_get_reorder_params_edma(struct wil6210_priv *wil,
514 *seq = le16_to_cpu(wil_rx_status_get_seq(wil, s));
528 static int wil_rx_crypto_check_edma(struct wil6210_priv *wil,
539 if (wil->use_rx_hw_reordering)
548 s = &wil->sta[cid];
554 wil_err_ratelimited(wil,
561 wil_err_ratelimited(wil,
571 static bool wil_is_rx_idle_edma(struct wil6210_priv *wil)
579 for (i = 0; i < wil->num_rx_status_rings; i++) {
580 sring = &wil->srings[i];
594 static void wil_rx_buf_len_init_edma(struct wil6210_priv *wil)
597 wil->rx_buf_len = rx_large_buf ?
601 static int wil_rx_init_edma(struct wil6210_priv *wil, uint desc_ring_order)
604 struct wil_ring *ring = &wil->ring_rx;
606 size_t elem_size = wil->use_compressed_rx_status ?
612 if (wil->use_compressed_rx_status && !wil->use_rx_hw_reordering) {
613 wil_err(wil,
617 if (wil->rx_status_ring_order <= desc_ring_order)
619 wil->rx_status_ring_order = desc_ring_order + 1;
620 if (wil->rx_buff_id_count <= desc_ring_size)
622 wil->rx_buff_id_count = desc_ring_size + 512;
623 if (wil->rx_status_ring_order < WIL_SRING_SIZE_ORDER_MIN ||
624 wil->rx_status_ring_order > WIL_SRING_SIZE_ORDER_MAX)
625 wil->rx_status_ring_order = WIL_RX_SRING_SIZE_ORDER_DEFAULT;
627 status_ring_size = 1 << wil->rx_status_ring_order;
629 wil_dbg_misc(wil,
633 wil_rx_buf_len_init_edma(wil);
636 if (wil->num_rx_status_rings > WIL6210_MAX_STATUS_RINGS - 1)
637 wil->num_rx_status_rings = WIL6210_MAX_STATUS_RINGS - 1;
639 wil_dbg_misc(wil, "rx_init: allocate %d status rings\n",
640 wil->num_rx_status_rings);
642 rc = wil_wmi_cfg_def_rx_offload(wil, wil->rx_buf_len);
647 for (i = 0; i < wil->num_rx_status_rings; i++) {
648 int sring_id = wil_find_free_sring(wil);
654 rc = wil_init_rx_sring(wil, status_ring_size, elem_size,
661 rc = wil_init_rx_desc_ring(wil, desc_ring_size,
666 if (wil->rx_buff_id_count >= status_ring_size) {
667 wil_info(wil,
669 wil->rx_buff_id_count, status_ring_size,
671 wil->rx_buff_id_count = status_ring_size - 1;
675 rc = wil_init_rx_buff_arr(wil, wil->rx_buff_id_count);
680 rc = wil_rx_refill_edma(wil);
686 wil_free_rx_buff_arr(wil);
688 wil_ring_free_edma(wil, ring);
690 for (i = 0; i < wil->num_rx_status_rings; i++)
691 wil_sring_free(wil, &wil->srings[i]);
699 struct wil6210_priv *wil = vif_to_wil(vif);
701 struct wil_ring *ring = &wil->ring_tx[ring_id];
702 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_id];
704 lockdep_assert_held(&wil->mutex);
706 wil_dbg_misc(wil,
708 ring_id, cid, tid, wil->tx_sring_idx);
712 rc = wil_ring_alloc_desc_ring(wil, ring);
716 wil->ring2cid_tid[ring_id][0] = cid;
717 wil->ring2cid_tid[ring_id][1] = tid;
723 wil_err(wil, "WMI_TX_DESC_RING_ADD_CMD failed\n");
728 wil_addba_tx_request(wil, ring_id, agg_wsize);
736 wil_ring_free_edma(wil, ring);
737 wil->ring2cid_tid[ring_id][0] = wil->max_assoc_sta;
738 wil->ring2cid_tid[ring_id][1] = 0;
747 struct wil6210_priv *wil = vif_to_wil(vif);
749 wil_err(wil, "ring modify is not supported for EDMA\n");
755 static int wil_check_bar(struct wil6210_priv *wil, void *msg, int cid,
765 ftype = wil_rx_status_get_frame_type(wil, msg);
769 fc1 = wil_rx_status_get_fc1(wil, msg);
772 seq = le16_to_cpu(wil_rx_status_get_seq(wil, msg));
773 vif = wil->vifs[mid];
776 wil_dbg_txrx(wil, "RX descriptor with invalid mid %d", mid);
780 wil_dbg_txrx(wil,
786 wil_dbg_txrx(wil,
789 wil_rx_bar(wil, vif, cid, tid, seq);
791 u32 sz = wil->use_compressed_rx_status ?
798 wil_dbg_txrx(wil,
810 static int wil_rx_error_check_edma(struct wil6210_priv *wil,
819 wil_dbg_txrx(wil, "L2 RX error, l2_rx_status=0x%x\n",
823 wil_err_ratelimited(wil,
828 wil_err_ratelimited(wil,
833 wil_err_ratelimited(wil,
838 wil_err_ratelimited(wil,
850 static struct sk_buff *wil_sring_reap_rx_edma(struct wil6210_priv *wil,
853 struct device *dev = wil_to_dev(wil);
860 unsigned int sz = wil->rx_buf_len;
869 u16 sring_idx = sring - wil->srings;
888 wil_dbg_txrx(wil,
901 if (unlikely(!wil_val_in_range(buff_id, 1, wil->rx_buff_mgmt.size))) {
902 wil_err(wil, "Corrupt buff_id=%d, sring->swhead=%d\n",
905 msg, wil->use_compressed_rx_status ?
916 skb = wil->rx_buff_mgmt.buff_arr[buff_id].skb;
917 wil->rx_buff_mgmt.buff_arr[buff_id].skb = NULL;
919 wil_err(wil, "No Rx skb at buff_id %d\n", buff_id);
922 list_move_tail(&wil->rx_buff_mgmt.buff_arr[buff_id].list,
923 &wil->rx_buff_mgmt.free);
936 trace_wil6210_rx_status(wil, wil->use_compressed_rx_status, buff_id,
938 wil_dbg_txrx(wil, "Rx, buff_id=%u, sring_idx=%u, dmalen=%u bytes\n",
941 (const void *)msg, wil->use_compressed_rx_status ?
946 list_move_tail(&wil->rx_buff_mgmt.buff_arr[buff_id].list,
947 &wil->rx_buff_mgmt.free);
952 if (unlikely(!wil_val_in_range(cid, 0, wil->max_assoc_sta))) {
953 wil_err(wil, "Corrupt cid=%d, sring->swhead=%d\n",
958 stats = &wil->sta[cid].stats;
961 wil_dbg_txrx(wil, "Short frame, len = %d\n", dmalen);
968 wil_err(wil, "Rx size too large: %d bytes!\n", dmalen);
970 msg, wil->use_compressed_rx_status ?
1008 wil_err(wil, "failed to merge skbs!\n");
1035 if (!wil->use_rx_hw_reordering && !wil->use_compressed_rx_status &&
1036 wil_check_bar(wil, msg, cid, skb, stats) == -EAGAIN) {
1047 wil_err(wil, "Unexpected data offset %d\n", data_offset);
1066 void wil_rx_handle_edma(struct wil6210_priv *wil, int *quota)
1069 struct wil_ring *ring = &wil->ring_rx;
1075 wil_err(wil, "Rx IRQ while Rx not yet initialized\n");
1078 wil_dbg_txrx(wil, "rx_handle\n");
1080 for (i = 0; i < wil->num_rx_status_rings; i++) {
1081 sring = &wil->srings[i];
1083 wil_err(wil,
1091 wil_sring_reap_rx_edma(wil, sring)))) {
1093 if (wil->use_rx_hw_reordering) {
1096 struct wil6210_vif *vif = wil->vifs[mid];
1099 wil_dbg_txrx(wil,
1108 wil_rx_reorder(wil, skb);
1112 wil_w(wil, sring->hwtail, (sring->swhead - 1) % sring->size);
1115 wil_rx_refill_edma(wil);
1158 int wil_tx_sring_handler(struct wil6210_priv *wil,
1162 struct device *dev = wil_to_dev(wil);
1185 wil_err(wil, "invalid num_descs 0\n");
1193 wil_err(wil, "invalid ring id %d\n", ring_id);
1196 ring = &wil->ring_tx[ring_id];
1198 wil_err(wil, "Tx irq[%d]: ring not initialized\n",
1202 txdata = &wil->ring_tx_data[ring_id];
1204 wil_info(wil, "Tx irq[%d]: ring disabled\n", ring_id);
1207 vif = wil->vifs[txdata->mid];
1209 wil_dbg_txrx(wil, "invalid MID %d for ring %d\n",
1216 cid = wil->ring2cid_tid[ring_id][0];
1217 stats = (cid < wil->max_assoc_sta) ? &wil->sta[cid].stats :
1220 wil_dbg_txrx(wil,
1238 wil_dbg_txrx(wil,
1258 wil_tx_latency_calc(wil, skb,
1259 &wil->sta[cid]);
1287 if (wil_val_in_range(wil->ring_idle_trsh,
1289 wil_dbg_txrx(wil, "Ring[%2d] idle %d -> %d\n",
1298 wil_w(wil, sring->hwtail, sring->swhead);
1307 wil_update_net_queues(wil, vif, NULL, false);
1311 wil_w(wil, sring->hwtail, (sring->swhead - 1) % sring->size);
1351 static int wil_tx_tso_gen_desc(struct wil6210_priv *wil, void *buff_addr,
1358 struct device *dev = wil_to_dev(wil);
1362 int ring_index = ring - wil->ring_tx;
1376 wil_err(wil, "TSO: Skb DMA map error\n");
1380 wil->txrx_ops.tx_desc_map((union wil_tx_desc *)d, pa,
1402 static int __wil_tx_ring_tso_edma(struct wil6210_priv *wil,
1407 int ring_index = ring - wil->ring_tx;
1408 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_index];
1422 wil_dbg_txrx(wil, "tx_ring_tso: %d bytes to ring %d\n", skb->len,
1429 wil_err_ratelimited(wil,
1460 wil_dbg_txrx(wil, "TSO: process header descriptor, hdrlen %u\n",
1462 rc = wil_tx_tso_gen_desc(wil, skb->data, hdrlen, swhead,
1471 wil_dbg_txrx(wil, "TSO: process skb head, headlen %u\n", headlen);
1472 rc = wil_tx_tso_gen_desc(wil, skb->data + hdrlen, headlen,
1486 wil_dbg_txrx(wil, "TSO: frag[%d]: len %u, descs_used %d\n", f,
1489 rc = wil_tx_tso_gen_desc(wil, NULL, len,
1502 if (wil_val_in_range(wil->ring_idle_trsh,
1505 wil_dbg_txrx(wil, "Ring[%2d] not idle %d -> %d\n",
1511 wil_dbg_txrx(wil, "TSO: Tx swhead %d -> %d\n", swhead, ring->swhead);
1518 if (wil->tx_latency)
1523 wil_w(wil, ring->hwtail, ring->swhead);
1529 struct device *dev = wil_to_dev(wil);
1549 struct wil6210_priv *wil = vif_to_wil(vif);
1550 struct wil_ring *ring = &wil->ring_tx[ring_id];
1552 struct wil_ring_tx_data *txdata = &wil->ring_tx_data[ring_id];
1554 wil_dbg_misc(wil, "init bcast: ring_id=%d, sring_id=%d\n",
1555 ring_id, wil->tx_sring_idx);
1557 lockdep_assert_held(&wil->mutex);
1562 rc = wil_ring_alloc_desc_ring(wil, ring);
1566 wil->ring2cid_tid[ring_id][0] = WIL6210_MAX_CID; /* CID */
1567 wil->ring2cid_tid[ring_id][1] = 0; /* TID */
1582 wil_ring_free_edma(wil, ring);
1588 static void wil_tx_fini_edma(struct wil6210_priv *wil)
1590 struct wil_status_ring *sring = &wil->srings[wil->tx_sring_idx];
1592 wil_dbg_misc(wil, "free TX sring\n");
1594 wil_sring_free(wil, sring);
1606 static void wil_rx_fini_edma(struct wil6210_priv *wil)
1608 struct wil_ring *ring = &wil->ring_rx;
1611 wil_dbg_misc(wil, "rx_fini_edma\n");
1613 wil_ring_free_edma(wil, ring);
1615 for (i = 0; i < wil->num_rx_status_rings; i++) {
1616 wil_rx_data_free(&wil->srings[i]);
1617 wil_sring_free(wil, &wil->srings[i]);
1620 wil_free_rx_buff_arr(wil);
1623 void wil_init_txrx_ops_edma(struct wil6210_priv *wil)
1625 wil->txrx_ops.configure_interrupt_moderation =
1628 wil->txrx_ops.ring_init_tx = wil_ring_init_tx_edma;
1629 wil->txrx_ops.ring_fini_tx = wil_ring_free_edma;
1630 wil->txrx_ops.ring_init_bcast = wil_ring_init_bcast_edma;
1631 wil->txrx_ops.tx_init = wil_tx_init_edma;
1632 wil->txrx_ops.tx_fini = wil_tx_fini_edma;
1633 wil->txrx_ops.tx_desc_map = wil_tx_desc_map_edma;
1634 wil->txrx_ops.tx_desc_unmap = wil_tx_desc_unmap_edma;
1635 wil->txrx_ops.tx_ring_tso = __wil_tx_ring_tso_edma;
1636 wil->txrx_ops.tx_ring_modify = wil_tx_ring_modify_edma;
1638 wil->txrx_ops.rx_init = wil_rx_init_edma;
1639 wil->txrx_ops.wmi_addba_rx_resp = wmi_addba_rx_resp_edma;
1640 wil->txrx_ops.get_reorder_params = wil_get_reorder_params_edma;
1641 wil->txrx_ops.get_netif_rx_params = wil_get_netif_rx_params_edma;
1642 wil->txrx_ops.rx_crypto_check = wil_rx_crypto_check_edma;
1643 wil->txrx_ops.rx_error_check = wil_rx_error_check_edma;
1644 wil->txrx_ops.is_rx_idle = wil_is_rx_idle_edma;
1645 wil->txrx_ops.rx_fini = wil_rx_fini_edma;