1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Atlantic Network Driver 3 * 4 * Copyright (C) 2014-2019 aQuantia Corporation 5 * Copyright (C) 2019-2020 Marvell International Ltd. 6 */ 7 8 /* File aq_ring.c: Definition of functions for Rx/Tx rings. */ 9 10 #include "aq_nic.h" 11 #include "aq_hw.h" 12 #include "aq_hw_utils.h" 13 #include "aq_ptp.h" 14 #include "aq_vec.h" 15 #include "aq_main.h" 16 17 #include <net/xdp.h> 18 #include <linux/filter.h> 19 #include <linux/bpf_trace.h> 20 #include <linux/netdevice.h> 21 #include <linux/etherdevice.h> 22 23 static void aq_get_rxpages_xdp(struct aq_ring_buff_s *buff, 24 struct xdp_buff *xdp) 25 { 26 struct skb_shared_info *sinfo; 27 int i; 28 29 if (xdp_buff_has_frags(xdp)) { 30 sinfo = xdp_get_shared_info_from_buff(xdp); 31 32 for (i = 0; i < sinfo->nr_frags; i++) { 33 skb_frag_t *frag = &sinfo->frags[i]; 34 35 page_ref_inc(skb_frag_page(frag)); 36 } 37 } 38 page_ref_inc(buff->rxdata.page); 39 } 40 41 static inline void aq_free_rxpage(struct aq_rxpage *rxpage, struct device *dev) 42 { 43 unsigned int len = PAGE_SIZE << rxpage->order; 44 45 dma_unmap_page(dev, rxpage->daddr, len, DMA_FROM_DEVICE); 46 47 /* Drop the ref for being in the ring. */ 48 __free_pages(rxpage->page, rxpage->order); 49 rxpage->page = NULL; 50 } 51 52 static int aq_alloc_rxpages(struct aq_rxpage *rxpage, struct aq_ring_s *rx_ring) 53 { 54 struct device *dev = aq_nic_get_dev(rx_ring->aq_nic); 55 unsigned int order = rx_ring->page_order; 56 struct page *page; 57 int ret = -ENOMEM; 58 dma_addr_t daddr; 59 60 page = dev_alloc_pages(order); 61 if (unlikely(!page)) 62 goto err_exit; 63 64 daddr = dma_map_page(dev, page, 0, PAGE_SIZE << order, 65 DMA_FROM_DEVICE); 66 67 if (unlikely(dma_mapping_error(dev, daddr))) 68 goto free_page; 69 70 rxpage->page = page; 71 rxpage->daddr = daddr; 72 rxpage->order = order; 73 rxpage->pg_off = rx_ring->page_offset; 74 75 return 0; 76 77 free_page: 78 __free_pages(page, order); 79 80 err_exit: 81 return ret; 82 } 83 84 static int aq_get_rxpages(struct aq_ring_s *self, struct aq_ring_buff_s *rxbuf) 85 { 86 unsigned int order = self->page_order; 87 u16 page_offset = self->page_offset; 88 u16 frame_max = self->frame_max; 89 u16 tail_size = self->tail_size; 90 int ret; 91 92 if (rxbuf->rxdata.page) { 93 /* One means ring is the only user and can reuse */ 94 if (page_ref_count(rxbuf->rxdata.page) > 1) { 95 /* Try reuse buffer */ 96 rxbuf->rxdata.pg_off += frame_max + page_offset + 97 tail_size; 98 if (rxbuf->rxdata.pg_off + frame_max + tail_size <= 99 (PAGE_SIZE << order)) { 100 u64_stats_update_begin(&self->stats.rx.syncp); 101 self->stats.rx.pg_flips++; 102 u64_stats_update_end(&self->stats.rx.syncp); 103 104 } else { 105 /* Buffer exhausted. We have other users and 106 * should release this page and realloc 107 */ 108 aq_free_rxpage(&rxbuf->rxdata, 109 aq_nic_get_dev(self->aq_nic)); 110 u64_stats_update_begin(&self->stats.rx.syncp); 111 self->stats.rx.pg_losts++; 112 u64_stats_update_end(&self->stats.rx.syncp); 113 } 114 } else { 115 rxbuf->rxdata.pg_off = page_offset; 116 u64_stats_update_begin(&self->stats.rx.syncp); 117 self->stats.rx.pg_reuses++; 118 u64_stats_update_end(&self->stats.rx.syncp); 119 } 120 } 121 122 if (!rxbuf->rxdata.page) { 123 ret = aq_alloc_rxpages(&rxbuf->rxdata, self); 124 if (ret) { 125 u64_stats_update_begin(&self->stats.rx.syncp); 126 self->stats.rx.alloc_fails++; 127 u64_stats_update_end(&self->stats.rx.syncp); 128 } 129 return ret; 130 } 131 132 return 0; 133 } 134 135 static struct aq_ring_s *aq_ring_alloc(struct aq_ring_s *self, 136 struct aq_nic_s *aq_nic) 137 { 138 int err = 0; 139 140 self->buff_ring = 141 kcalloc(self->size, sizeof(struct aq_ring_buff_s), GFP_KERNEL); 142 143 if (!self->buff_ring) { 144 err = -ENOMEM; 145 goto err_exit; 146 } 147 148 self->dx_ring = dma_alloc_coherent(aq_nic_get_dev(aq_nic), 149 self->size * self->dx_size, 150 &self->dx_ring_pa, GFP_KERNEL); 151 if (!self->dx_ring) { 152 err = -ENOMEM; 153 goto err_exit; 154 } 155 156 err_exit: 157 if (err < 0) { 158 aq_ring_free(self); 159 self = NULL; 160 } 161 162 return self; 163 } 164 165 struct aq_ring_s *aq_ring_tx_alloc(struct aq_ring_s *self, 166 struct aq_nic_s *aq_nic, 167 unsigned int idx, 168 struct aq_nic_cfg_s *aq_nic_cfg) 169 { 170 int err = 0; 171 172 self->aq_nic = aq_nic; 173 self->idx = idx; 174 self->size = aq_nic_cfg->txds; 175 self->dx_size = aq_nic_cfg->aq_hw_caps->txd_size; 176 177 self = aq_ring_alloc(self, aq_nic); 178 if (!self) { 179 err = -ENOMEM; 180 goto err_exit; 181 } 182 183 err_exit: 184 if (err < 0) { 185 aq_ring_free(self); 186 self = NULL; 187 } 188 189 return self; 190 } 191 192 struct aq_ring_s *aq_ring_rx_alloc(struct aq_ring_s *self, 193 struct aq_nic_s *aq_nic, 194 unsigned int idx, 195 struct aq_nic_cfg_s *aq_nic_cfg) 196 { 197 int err = 0; 198 199 self->aq_nic = aq_nic; 200 self->idx = idx; 201 self->size = aq_nic_cfg->rxds; 202 self->dx_size = aq_nic_cfg->aq_hw_caps->rxd_size; 203 self->xdp_prog = aq_nic->xdp_prog; 204 self->frame_max = AQ_CFG_RX_FRAME_MAX; 205 206 /* Only order-2 is allowed if XDP is enabled */ 207 if (READ_ONCE(self->xdp_prog)) { 208 self->page_offset = AQ_XDP_HEADROOM; 209 self->page_order = AQ_CFG_XDP_PAGEORDER; 210 self->tail_size = AQ_XDP_TAILROOM; 211 } else { 212 self->page_offset = 0; 213 self->page_order = fls(self->frame_max / PAGE_SIZE + 214 (self->frame_max % PAGE_SIZE ? 1 : 0)) - 1; 215 if (aq_nic_cfg->rxpageorder > self->page_order) 216 self->page_order = aq_nic_cfg->rxpageorder; 217 self->tail_size = 0; 218 } 219 220 self = aq_ring_alloc(self, aq_nic); 221 if (!self) { 222 err = -ENOMEM; 223 goto err_exit; 224 } 225 226 err_exit: 227 if (err < 0) { 228 aq_ring_free(self); 229 self = NULL; 230 } 231 232 return self; 233 } 234 235 struct aq_ring_s * 236 aq_ring_hwts_rx_alloc(struct aq_ring_s *self, struct aq_nic_s *aq_nic, 237 unsigned int idx, unsigned int size, unsigned int dx_size) 238 { 239 struct device *dev = aq_nic_get_dev(aq_nic); 240 size_t sz = size * dx_size + AQ_CFG_RXDS_DEF; 241 242 memset(self, 0, sizeof(*self)); 243 244 self->aq_nic = aq_nic; 245 self->idx = idx; 246 self->size = size; 247 self->dx_size = dx_size; 248 249 self->dx_ring = dma_alloc_coherent(dev, sz, &self->dx_ring_pa, 250 GFP_KERNEL); 251 if (!self->dx_ring) { 252 aq_ring_free(self); 253 return NULL; 254 } 255 256 return self; 257 } 258 259 int aq_ring_init(struct aq_ring_s *self, const enum atl_ring_type ring_type) 260 { 261 self->hw_head = 0; 262 self->sw_head = 0; 263 self->sw_tail = 0; 264 self->ring_type = ring_type; 265 266 if (self->ring_type == ATL_RING_RX) 267 u64_stats_init(&self->stats.rx.syncp); 268 else 269 u64_stats_init(&self->stats.tx.syncp); 270 271 return 0; 272 } 273 274 static inline bool aq_ring_dx_in_range(unsigned int h, unsigned int i, 275 unsigned int t) 276 { 277 return (h < t) ? ((h < i) && (i < t)) : ((h < i) || (i < t)); 278 } 279 280 void aq_ring_update_queue_state(struct aq_ring_s *ring) 281 { 282 if (aq_ring_avail_dx(ring) <= AQ_CFG_SKB_FRAGS_MAX) 283 aq_ring_queue_stop(ring); 284 else if (aq_ring_avail_dx(ring) > AQ_CFG_RESTART_DESC_THRES) 285 aq_ring_queue_wake(ring); 286 } 287 288 void aq_ring_queue_wake(struct aq_ring_s *ring) 289 { 290 struct net_device *ndev = aq_nic_get_ndev(ring->aq_nic); 291 292 if (__netif_subqueue_stopped(ndev, 293 AQ_NIC_RING2QMAP(ring->aq_nic, 294 ring->idx))) { 295 netif_wake_subqueue(ndev, 296 AQ_NIC_RING2QMAP(ring->aq_nic, ring->idx)); 297 u64_stats_update_begin(&ring->stats.tx.syncp); 298 ring->stats.tx.queue_restarts++; 299 u64_stats_update_end(&ring->stats.tx.syncp); 300 } 301 } 302 303 void aq_ring_queue_stop(struct aq_ring_s *ring) 304 { 305 struct net_device *ndev = aq_nic_get_ndev(ring->aq_nic); 306 307 if (!__netif_subqueue_stopped(ndev, 308 AQ_NIC_RING2QMAP(ring->aq_nic, 309 ring->idx))) 310 netif_stop_subqueue(ndev, 311 AQ_NIC_RING2QMAP(ring->aq_nic, ring->idx)); 312 } 313 314 bool aq_ring_tx_clean(struct aq_ring_s *self) 315 { 316 struct device *dev = aq_nic_get_dev(self->aq_nic); 317 unsigned int budget; 318 319 for (budget = AQ_CFG_TX_CLEAN_BUDGET; 320 budget && self->sw_head != self->hw_head; budget--) { 321 struct aq_ring_buff_s *buff = &self->buff_ring[self->sw_head]; 322 323 if (likely(buff->is_mapped)) { 324 if (unlikely(buff->is_sop)) { 325 if (!buff->is_eop && 326 buff->eop_index != 0xffffU && 327 (!aq_ring_dx_in_range(self->sw_head, 328 buff->eop_index, 329 self->hw_head))) 330 break; 331 332 dma_unmap_single(dev, buff->pa, buff->len, 333 DMA_TO_DEVICE); 334 } else { 335 dma_unmap_page(dev, buff->pa, buff->len, 336 DMA_TO_DEVICE); 337 } 338 } 339 340 if (likely(!buff->is_eop)) 341 goto out; 342 343 if (buff->skb) { 344 u64_stats_update_begin(&self->stats.tx.syncp); 345 ++self->stats.tx.packets; 346 self->stats.tx.bytes += buff->skb->len; 347 u64_stats_update_end(&self->stats.tx.syncp); 348 dev_kfree_skb_any(buff->skb); 349 } else if (buff->xdpf) { 350 u64_stats_update_begin(&self->stats.tx.syncp); 351 ++self->stats.tx.packets; 352 self->stats.tx.bytes += xdp_get_frame_len(buff->xdpf); 353 u64_stats_update_end(&self->stats.tx.syncp); 354 xdp_return_frame_rx_napi(buff->xdpf); 355 } 356 357 out: 358 buff->skb = NULL; 359 buff->xdpf = NULL; 360 buff->pa = 0U; 361 buff->eop_index = 0xffffU; 362 self->sw_head = aq_ring_next_dx(self, self->sw_head); 363 } 364 365 return !!budget; 366 } 367 368 static void aq_rx_checksum(struct aq_ring_s *self, 369 struct aq_ring_buff_s *buff, 370 struct sk_buff *skb) 371 { 372 if (!(self->aq_nic->ndev->features & NETIF_F_RXCSUM)) 373 return; 374 375 if (unlikely(buff->is_cso_err)) { 376 u64_stats_update_begin(&self->stats.rx.syncp); 377 ++self->stats.rx.errors; 378 u64_stats_update_end(&self->stats.rx.syncp); 379 skb->ip_summed = CHECKSUM_NONE; 380 return; 381 } 382 if (buff->is_ip_cso) { 383 __skb_incr_checksum_unnecessary(skb); 384 } else { 385 skb->ip_summed = CHECKSUM_NONE; 386 } 387 388 if (buff->is_udp_cso || buff->is_tcp_cso) 389 __skb_incr_checksum_unnecessary(skb); 390 } 391 392 int aq_xdp_xmit(struct net_device *dev, int num_frames, 393 struct xdp_frame **frames, u32 flags) 394 { 395 struct aq_nic_s *aq_nic = netdev_priv(dev); 396 unsigned int vec, i, drop = 0; 397 int cpu = smp_processor_id(); 398 struct aq_nic_cfg_s *aq_cfg; 399 struct aq_ring_s *ring; 400 401 aq_cfg = aq_nic_get_cfg(aq_nic); 402 vec = cpu % aq_cfg->vecs; 403 ring = aq_nic->aq_ring_tx[AQ_NIC_CFG_TCVEC2RING(aq_cfg, 0, vec)]; 404 405 for (i = 0; i < num_frames; i++) { 406 struct xdp_frame *xdpf = frames[i]; 407 408 if (aq_nic_xmit_xdpf(aq_nic, ring, xdpf) == NETDEV_TX_BUSY) 409 drop++; 410 } 411 412 return num_frames - drop; 413 } 414 415 static struct sk_buff *aq_xdp_run_prog(struct aq_nic_s *aq_nic, 416 struct xdp_buff *xdp, 417 struct aq_ring_s *rx_ring, 418 struct aq_ring_buff_s *buff) 419 { 420 int result = NETDEV_TX_BUSY; 421 struct aq_ring_s *tx_ring; 422 struct xdp_frame *xdpf; 423 struct bpf_prog *prog; 424 u32 act = XDP_ABORTED; 425 struct sk_buff *skb; 426 427 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 428 ++rx_ring->stats.rx.packets; 429 rx_ring->stats.rx.bytes += xdp_get_buff_len(xdp); 430 u64_stats_update_end(&rx_ring->stats.rx.syncp); 431 432 prog = READ_ONCE(rx_ring->xdp_prog); 433 if (!prog) 434 goto pass; 435 436 prefetchw(xdp->data_hard_start); /* xdp_frame write */ 437 438 /* single buffer XDP program, but packet is multi buffer, aborted */ 439 if (xdp_buff_has_frags(xdp) && !prog->aux->xdp_has_frags) 440 goto out_aborted; 441 442 act = bpf_prog_run_xdp(prog, xdp); 443 switch (act) { 444 case XDP_PASS: 445 pass: 446 xdpf = xdp_convert_buff_to_frame(xdp); 447 if (unlikely(!xdpf)) 448 goto out_aborted; 449 skb = xdp_build_skb_from_frame(xdpf, aq_nic->ndev); 450 if (!skb) 451 goto out_aborted; 452 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 453 ++rx_ring->stats.rx.xdp_pass; 454 u64_stats_update_end(&rx_ring->stats.rx.syncp); 455 aq_get_rxpages_xdp(buff, xdp); 456 return skb; 457 case XDP_TX: 458 xdpf = xdp_convert_buff_to_frame(xdp); 459 if (unlikely(!xdpf)) 460 goto out_aborted; 461 tx_ring = aq_nic->aq_ring_tx[rx_ring->idx]; 462 result = aq_nic_xmit_xdpf(aq_nic, tx_ring, xdpf); 463 if (result == NETDEV_TX_BUSY) 464 goto out_aborted; 465 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 466 ++rx_ring->stats.rx.xdp_tx; 467 u64_stats_update_end(&rx_ring->stats.rx.syncp); 468 aq_get_rxpages_xdp(buff, xdp); 469 break; 470 case XDP_REDIRECT: 471 if (xdp_do_redirect(aq_nic->ndev, xdp, prog) < 0) 472 goto out_aborted; 473 xdp_do_flush(); 474 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 475 ++rx_ring->stats.rx.xdp_redirect; 476 u64_stats_update_end(&rx_ring->stats.rx.syncp); 477 aq_get_rxpages_xdp(buff, xdp); 478 break; 479 default: 480 fallthrough; 481 case XDP_ABORTED: 482 out_aborted: 483 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 484 ++rx_ring->stats.rx.xdp_aborted; 485 u64_stats_update_end(&rx_ring->stats.rx.syncp); 486 trace_xdp_exception(aq_nic->ndev, prog, act); 487 bpf_warn_invalid_xdp_action(aq_nic->ndev, prog, act); 488 break; 489 case XDP_DROP: 490 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 491 ++rx_ring->stats.rx.xdp_drop; 492 u64_stats_update_end(&rx_ring->stats.rx.syncp); 493 break; 494 } 495 496 return ERR_PTR(-result); 497 } 498 499 static bool aq_add_rx_fragment(struct device *dev, 500 struct aq_ring_s *ring, 501 struct aq_ring_buff_s *buff, 502 struct xdp_buff *xdp) 503 { 504 struct skb_shared_info *sinfo = xdp_get_shared_info_from_buff(xdp); 505 struct aq_ring_buff_s *buff_ = buff; 506 507 memset(sinfo, 0, sizeof(*sinfo)); 508 do { 509 skb_frag_t *frag; 510 511 if (unlikely(sinfo->nr_frags >= MAX_SKB_FRAGS)) 512 return true; 513 514 frag = &sinfo->frags[sinfo->nr_frags++]; 515 buff_ = &ring->buff_ring[buff_->next]; 516 dma_sync_single_range_for_cpu(dev, 517 buff_->rxdata.daddr, 518 buff_->rxdata.pg_off, 519 buff_->len, 520 DMA_FROM_DEVICE); 521 skb_frag_off_set(frag, buff_->rxdata.pg_off); 522 skb_frag_size_set(frag, buff_->len); 523 sinfo->xdp_frags_size += buff_->len; 524 __skb_frag_set_page(frag, buff_->rxdata.page); 525 526 buff_->is_cleaned = 1; 527 528 buff->is_ip_cso &= buff_->is_ip_cso; 529 buff->is_udp_cso &= buff_->is_udp_cso; 530 buff->is_tcp_cso &= buff_->is_tcp_cso; 531 buff->is_cso_err |= buff_->is_cso_err; 532 533 if (page_is_pfmemalloc(buff_->rxdata.page)) 534 xdp_buff_set_frag_pfmemalloc(xdp); 535 536 } while (!buff_->is_eop); 537 538 xdp_buff_set_frags_flag(xdp); 539 540 return false; 541 } 542 543 static int __aq_ring_rx_clean(struct aq_ring_s *self, struct napi_struct *napi, 544 int *work_done, int budget) 545 { 546 struct net_device *ndev = aq_nic_get_ndev(self->aq_nic); 547 int err = 0; 548 549 for (; (self->sw_head != self->hw_head) && budget; 550 self->sw_head = aq_ring_next_dx(self, self->sw_head), 551 --budget, ++(*work_done)) { 552 struct aq_ring_buff_s *buff = &self->buff_ring[self->sw_head]; 553 bool is_ptp_ring = aq_ptp_ring(self->aq_nic, self); 554 struct aq_ring_buff_s *buff_ = NULL; 555 struct sk_buff *skb = NULL; 556 unsigned int next_ = 0U; 557 unsigned int i = 0U; 558 u16 hdr_len; 559 560 if (buff->is_cleaned) 561 continue; 562 563 if (!buff->is_eop) { 564 unsigned int frag_cnt = 0U; 565 buff_ = buff; 566 do { 567 bool is_rsc_completed = true; 568 569 if (buff_->next >= self->size) { 570 err = -EIO; 571 goto err_exit; 572 } 573 574 frag_cnt++; 575 next_ = buff_->next, 576 buff_ = &self->buff_ring[next_]; 577 is_rsc_completed = 578 aq_ring_dx_in_range(self->sw_head, 579 next_, 580 self->hw_head); 581 582 if (unlikely(!is_rsc_completed) || 583 frag_cnt > MAX_SKB_FRAGS) { 584 err = 0; 585 goto err_exit; 586 } 587 588 buff->is_error |= buff_->is_error; 589 buff->is_cso_err |= buff_->is_cso_err; 590 591 } while (!buff_->is_eop); 592 593 if (buff->is_error || 594 (buff->is_lro && buff->is_cso_err)) { 595 buff_ = buff; 596 do { 597 if (buff_->next >= self->size) { 598 err = -EIO; 599 goto err_exit; 600 } 601 next_ = buff_->next, 602 buff_ = &self->buff_ring[next_]; 603 604 buff_->is_cleaned = true; 605 } while (!buff_->is_eop); 606 607 u64_stats_update_begin(&self->stats.rx.syncp); 608 ++self->stats.rx.errors; 609 u64_stats_update_end(&self->stats.rx.syncp); 610 continue; 611 } 612 } 613 614 if (buff->is_error) { 615 u64_stats_update_begin(&self->stats.rx.syncp); 616 ++self->stats.rx.errors; 617 u64_stats_update_end(&self->stats.rx.syncp); 618 continue; 619 } 620 621 dma_sync_single_range_for_cpu(aq_nic_get_dev(self->aq_nic), 622 buff->rxdata.daddr, 623 buff->rxdata.pg_off, 624 buff->len, DMA_FROM_DEVICE); 625 626 skb = napi_alloc_skb(napi, AQ_CFG_RX_HDR_SIZE); 627 if (unlikely(!skb)) { 628 u64_stats_update_begin(&self->stats.rx.syncp); 629 self->stats.rx.skb_alloc_fails++; 630 u64_stats_update_end(&self->stats.rx.syncp); 631 err = -ENOMEM; 632 goto err_exit; 633 } 634 if (is_ptp_ring) 635 buff->len -= 636 aq_ptp_extract_ts(self->aq_nic, skb, 637 aq_buf_vaddr(&buff->rxdata), 638 buff->len); 639 640 hdr_len = buff->len; 641 if (hdr_len > AQ_CFG_RX_HDR_SIZE) 642 hdr_len = eth_get_headlen(skb->dev, 643 aq_buf_vaddr(&buff->rxdata), 644 AQ_CFG_RX_HDR_SIZE); 645 646 memcpy(__skb_put(skb, hdr_len), aq_buf_vaddr(&buff->rxdata), 647 ALIGN(hdr_len, sizeof(long))); 648 649 if (buff->len - hdr_len > 0) { 650 skb_add_rx_frag(skb, i++, buff->rxdata.page, 651 buff->rxdata.pg_off + hdr_len, 652 buff->len - hdr_len, 653 self->frame_max); 654 page_ref_inc(buff->rxdata.page); 655 } 656 657 if (!buff->is_eop) { 658 buff_ = buff; 659 do { 660 next_ = buff_->next; 661 buff_ = &self->buff_ring[next_]; 662 663 dma_sync_single_range_for_cpu(aq_nic_get_dev(self->aq_nic), 664 buff_->rxdata.daddr, 665 buff_->rxdata.pg_off, 666 buff_->len, 667 DMA_FROM_DEVICE); 668 skb_add_rx_frag(skb, i++, 669 buff_->rxdata.page, 670 buff_->rxdata.pg_off, 671 buff_->len, 672 self->frame_max); 673 page_ref_inc(buff_->rxdata.page); 674 buff_->is_cleaned = 1; 675 676 buff->is_ip_cso &= buff_->is_ip_cso; 677 buff->is_udp_cso &= buff_->is_udp_cso; 678 buff->is_tcp_cso &= buff_->is_tcp_cso; 679 buff->is_cso_err |= buff_->is_cso_err; 680 681 } while (!buff_->is_eop); 682 } 683 684 if (buff->is_vlan) 685 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), 686 buff->vlan_rx_tag); 687 688 skb->protocol = eth_type_trans(skb, ndev); 689 690 aq_rx_checksum(self, buff, skb); 691 692 skb_set_hash(skb, buff->rss_hash, 693 buff->is_hash_l4 ? PKT_HASH_TYPE_L4 : 694 PKT_HASH_TYPE_NONE); 695 /* Send all PTP traffic to 0 queue */ 696 skb_record_rx_queue(skb, 697 is_ptp_ring ? 0 698 : AQ_NIC_RING2QMAP(self->aq_nic, 699 self->idx)); 700 701 u64_stats_update_begin(&self->stats.rx.syncp); 702 ++self->stats.rx.packets; 703 self->stats.rx.bytes += skb->len; 704 u64_stats_update_end(&self->stats.rx.syncp); 705 706 napi_gro_receive(napi, skb); 707 } 708 709 err_exit: 710 return err; 711 } 712 713 static int __aq_ring_xdp_clean(struct aq_ring_s *rx_ring, 714 struct napi_struct *napi, int *work_done, 715 int budget) 716 { 717 int frame_sz = rx_ring->page_offset + rx_ring->frame_max + 718 rx_ring->tail_size; 719 struct aq_nic_s *aq_nic = rx_ring->aq_nic; 720 bool is_rsc_completed = true; 721 struct device *dev; 722 int err = 0; 723 724 dev = aq_nic_get_dev(aq_nic); 725 for (; (rx_ring->sw_head != rx_ring->hw_head) && budget; 726 rx_ring->sw_head = aq_ring_next_dx(rx_ring, rx_ring->sw_head), 727 --budget, ++(*work_done)) { 728 struct aq_ring_buff_s *buff = &rx_ring->buff_ring[rx_ring->sw_head]; 729 bool is_ptp_ring = aq_ptp_ring(rx_ring->aq_nic, rx_ring); 730 struct aq_ring_buff_s *buff_ = NULL; 731 struct sk_buff *skb = NULL; 732 unsigned int next_ = 0U; 733 struct xdp_buff xdp; 734 void *hard_start; 735 736 if (buff->is_cleaned) 737 continue; 738 739 if (!buff->is_eop) { 740 buff_ = buff; 741 do { 742 if (buff_->next >= rx_ring->size) { 743 err = -EIO; 744 goto err_exit; 745 } 746 next_ = buff_->next; 747 buff_ = &rx_ring->buff_ring[next_]; 748 is_rsc_completed = 749 aq_ring_dx_in_range(rx_ring->sw_head, 750 next_, 751 rx_ring->hw_head); 752 753 if (unlikely(!is_rsc_completed)) 754 break; 755 756 buff->is_error |= buff_->is_error; 757 buff->is_cso_err |= buff_->is_cso_err; 758 } while (!buff_->is_eop); 759 760 if (!is_rsc_completed) { 761 err = 0; 762 goto err_exit; 763 } 764 if (buff->is_error || 765 (buff->is_lro && buff->is_cso_err)) { 766 buff_ = buff; 767 do { 768 if (buff_->next >= rx_ring->size) { 769 err = -EIO; 770 goto err_exit; 771 } 772 next_ = buff_->next; 773 buff_ = &rx_ring->buff_ring[next_]; 774 775 buff_->is_cleaned = true; 776 } while (!buff_->is_eop); 777 778 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 779 ++rx_ring->stats.rx.errors; 780 u64_stats_update_end(&rx_ring->stats.rx.syncp); 781 continue; 782 } 783 } 784 785 if (buff->is_error) { 786 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 787 ++rx_ring->stats.rx.errors; 788 u64_stats_update_end(&rx_ring->stats.rx.syncp); 789 continue; 790 } 791 792 dma_sync_single_range_for_cpu(dev, 793 buff->rxdata.daddr, 794 buff->rxdata.pg_off, 795 buff->len, DMA_FROM_DEVICE); 796 hard_start = page_address(buff->rxdata.page) + 797 buff->rxdata.pg_off - rx_ring->page_offset; 798 799 if (is_ptp_ring) 800 buff->len -= 801 aq_ptp_extract_ts(rx_ring->aq_nic, skb, 802 aq_buf_vaddr(&buff->rxdata), 803 buff->len); 804 805 xdp_init_buff(&xdp, frame_sz, &rx_ring->xdp_rxq); 806 xdp_prepare_buff(&xdp, hard_start, rx_ring->page_offset, 807 buff->len, false); 808 if (!buff->is_eop) { 809 if (aq_add_rx_fragment(dev, rx_ring, buff, &xdp)) { 810 u64_stats_update_begin(&rx_ring->stats.rx.syncp); 811 ++rx_ring->stats.rx.packets; 812 rx_ring->stats.rx.bytes += xdp_get_buff_len(&xdp); 813 ++rx_ring->stats.rx.xdp_aborted; 814 u64_stats_update_end(&rx_ring->stats.rx.syncp); 815 continue; 816 } 817 } 818 819 skb = aq_xdp_run_prog(aq_nic, &xdp, rx_ring, buff); 820 if (IS_ERR(skb) || !skb) 821 continue; 822 823 if (buff->is_vlan) 824 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), 825 buff->vlan_rx_tag); 826 827 aq_rx_checksum(rx_ring, buff, skb); 828 829 skb_set_hash(skb, buff->rss_hash, 830 buff->is_hash_l4 ? PKT_HASH_TYPE_L4 : 831 PKT_HASH_TYPE_NONE); 832 /* Send all PTP traffic to 0 queue */ 833 skb_record_rx_queue(skb, 834 is_ptp_ring ? 0 835 : AQ_NIC_RING2QMAP(rx_ring->aq_nic, 836 rx_ring->idx)); 837 838 napi_gro_receive(napi, skb); 839 } 840 841 err_exit: 842 return err; 843 } 844 845 int aq_ring_rx_clean(struct aq_ring_s *self, 846 struct napi_struct *napi, 847 int *work_done, 848 int budget) 849 { 850 if (static_branch_unlikely(&aq_xdp_locking_key)) 851 return __aq_ring_xdp_clean(self, napi, work_done, budget); 852 else 853 return __aq_ring_rx_clean(self, napi, work_done, budget); 854 } 855 856 void aq_ring_hwts_rx_clean(struct aq_ring_s *self, struct aq_nic_s *aq_nic) 857 { 858 #if IS_REACHABLE(CONFIG_PTP_1588_CLOCK) 859 while (self->sw_head != self->hw_head) { 860 u64 ns; 861 862 aq_nic->aq_hw_ops->extract_hwts(aq_nic->aq_hw, 863 self->dx_ring + 864 (self->sw_head * self->dx_size), 865 self->dx_size, &ns); 866 aq_ptp_tx_hwtstamp(aq_nic, ns); 867 868 self->sw_head = aq_ring_next_dx(self, self->sw_head); 869 } 870 #endif 871 } 872 873 int aq_ring_rx_fill(struct aq_ring_s *self) 874 { 875 struct aq_ring_buff_s *buff = NULL; 876 int err = 0; 877 int i = 0; 878 879 if (aq_ring_avail_dx(self) < min_t(unsigned int, AQ_CFG_RX_REFILL_THRES, 880 self->size / 2)) 881 return err; 882 883 for (i = aq_ring_avail_dx(self); i--; 884 self->sw_tail = aq_ring_next_dx(self, self->sw_tail)) { 885 buff = &self->buff_ring[self->sw_tail]; 886 887 buff->flags = 0U; 888 buff->len = self->frame_max; 889 890 err = aq_get_rxpages(self, buff); 891 if (err) 892 goto err_exit; 893 894 buff->pa = aq_buf_daddr(&buff->rxdata); 895 buff = NULL; 896 } 897 898 err_exit: 899 return err; 900 } 901 902 void aq_ring_rx_deinit(struct aq_ring_s *self) 903 { 904 if (!self) 905 return; 906 907 for (; self->sw_head != self->sw_tail; 908 self->sw_head = aq_ring_next_dx(self, self->sw_head)) { 909 struct aq_ring_buff_s *buff = &self->buff_ring[self->sw_head]; 910 911 aq_free_rxpage(&buff->rxdata, aq_nic_get_dev(self->aq_nic)); 912 } 913 } 914 915 void aq_ring_free(struct aq_ring_s *self) 916 { 917 if (!self) 918 return; 919 920 kfree(self->buff_ring); 921 922 if (self->dx_ring) 923 dma_free_coherent(aq_nic_get_dev(self->aq_nic), 924 self->size * self->dx_size, self->dx_ring, 925 self->dx_ring_pa); 926 } 927 928 unsigned int aq_ring_fill_stats_data(struct aq_ring_s *self, u64 *data) 929 { 930 unsigned int count; 931 unsigned int start; 932 933 if (self->ring_type == ATL_RING_RX) { 934 /* This data should mimic aq_ethtool_queue_rx_stat_names structure */ 935 do { 936 count = 0; 937 start = u64_stats_fetch_begin(&self->stats.rx.syncp); 938 data[count] = self->stats.rx.packets; 939 data[++count] = self->stats.rx.jumbo_packets; 940 data[++count] = self->stats.rx.lro_packets; 941 data[++count] = self->stats.rx.errors; 942 data[++count] = self->stats.rx.alloc_fails; 943 data[++count] = self->stats.rx.skb_alloc_fails; 944 data[++count] = self->stats.rx.polls; 945 data[++count] = self->stats.rx.pg_flips; 946 data[++count] = self->stats.rx.pg_reuses; 947 data[++count] = self->stats.rx.pg_losts; 948 data[++count] = self->stats.rx.xdp_aborted; 949 data[++count] = self->stats.rx.xdp_drop; 950 data[++count] = self->stats.rx.xdp_pass; 951 data[++count] = self->stats.rx.xdp_tx; 952 data[++count] = self->stats.rx.xdp_invalid; 953 data[++count] = self->stats.rx.xdp_redirect; 954 } while (u64_stats_fetch_retry(&self->stats.rx.syncp, start)); 955 } else { 956 /* This data should mimic aq_ethtool_queue_tx_stat_names structure */ 957 do { 958 count = 0; 959 start = u64_stats_fetch_begin(&self->stats.tx.syncp); 960 data[count] = self->stats.tx.packets; 961 data[++count] = self->stats.tx.queue_restarts; 962 } while (u64_stats_fetch_retry(&self->stats.tx.syncp, start)); 963 } 964 965 return ++count; 966 } 967