Quelle  hinic_rx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Huawei HiNIC PCI Express Linux driver
 * Copyright(c) 2017 Huawei Technologies Co., Ltd
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/pci.h>
#include <linux/device.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/u64_stats_sync.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/skbuff.h>
#include <linux/dma-mapping.h>
#include <linux/prefetch.h>
#include <linux/cpumask.h>
#include <linux/if_vlan.h>
#include <asm/barrier.h>

#include "hinic_common.h"
#include "hinic_hw_if.h"
#include "hinic_hw_wqe.h"
#include "hinic_hw_wq.h"
#include "hinic_hw_qp./*
#include "hinic_hw_dev.h"
#include "hinic_rx.h"
#include "hinic_dev.h"

#define RX_IRQ_NO_PENDING               0
#define RX_IRQ_NO_COALESC               0
#define RX_IRQ_NO_LLI_TIMER             0
#define RX_IRQ_NO_CREDIT                0
#define RX_IRQ_NO_RESEND_TIMER          0
#define HINIC_RX_BUFFER_WRITE           16

#define HINIC_RX_IPV6_PKT  7
#define LRO_PKT_HDR_LEN_IPV4  66
#define LRO_PKT_HDR_LEN_IPV6  86
#define LRO_REPLENISH_THLD  256

#define LRO_PKT_HDR_LEN(cqe)  \
 (HINIC_GET_RX_PKT_TYPE(be32_to_cpu((cqe)->offload_type)) == \
  HINIC_RX_IPV6_PKT ? LRO_PKT_HDR_LEN_IPV6 : LRO_PKT_HDR_LEN_IPV4)

/**
 * hinic_rxq_clean_stats - Clean the statistics of specific queue
 * @rxq: Logical Rx Queue
 **/
static void hinic_rxq_clean_stats(struct hinic_rxq *rxq)
{
 struct hinic_rxq_stats *rxq_stats = &rxq->rxq_stats;

 u64_stats_update_begin(&rxq_stats->syncp);
 rxq_stats->pkts  = 0;
 rxq_stats->bytes = 0;
 rxq_stats->errors = 0;
 rxq_stats->csum_errors = 0;
 rxq_stats->other_errors = 0;
 u64_stats_update_end(&rxq_stats->syncp);
}

/**
 * hinic_rxq_get_stats - get statistics of Rx Queue
 * @rxq: Logical Rx Queue
 * @stats: return updated stats here
 **/
void hinic_rxq_get_stats(struct hinic_rxq *rxq, struct hinic_rxq_stats *stats)
{
 struct hinic_rxq_stats *rxq_stats = &rxq->rxq_stats;
 unsigned int start;

 do {
  start = u64_stats_fetch_begin(&rxq_stats->syncp);
  stats->pkts = rxq_stats->pkts;
  stats->bytes = rxq_stats->bytes;
  stats->errors = rxq_stats->csum_errors +
    rxq_stats->other_errors;
  stats->csum_errors = rxq_stats->csum_errors;
  stats->other_errors = rxq_stats->other_errors;
 } while (u64_stats_fetch_retry(&rxq_stats->syncp, start));
}

/**
 * rxq_stats_init - Initialize the statistics of specific queue
 * @rxq: Logical Rx Queue
 **/
static void rxq_stats_init(struct hinic_rxq *rxq)
{
 struct hinic_rxq_stats *rxq_stats = &rxq->rxq_stats;

 u64_stats_init(&rxq_stats->syncp);
 hinic_rxq_clean_stats(rxq);
}

static void rx_csum(struct hinic_rxq *rxq, u32 status,
      struct sk_buff *skb)
{
 struct net_device *netdev = rxq->netdev;
 u32 csum_err;

 csum_err = HINIC_RQ_CQE_STATUS_GET(status, CSUM_ERR);

 if (!(netdev->features & NETIF_F_RXCSUM))
  return;

 if (!csum_err) {
  skb->ip_summed = CHECKSUM_UNNECESSARY;
 } else {
  if (!(csum_err & (HINIC_RX_CSUM_HW_CHECK_NONE |
   HINIC_RX_CSUM_IPSU_OTHER_ERR)))
   rxq->rxq_stats.csum_errors++;
  skb->ip_summed = CHECKSUM_NONE;
 }
}

/**
 * rx_alloc_skb - allocate skb and map it to dma address
 * @rxq: rx queue
 * @dma_addr: returned dma address for the skb
 *
 * Return skb
 **/
static struct sk_buff *rx_alloc_skb(struct hinic_rxq *rxq,
        dma_addr_t *dma_addr)
{
 struct hinic_dev *nic_dev = netdev_priv(rxq->netdev);
 struct hinic_hwdev *hwdev = nic_dev->hwdev;
 struct hinic_hwif *hwif = hwdev->hwif;
 struct pci_dev *pdev = hwif->pdev;
 struct sk_buff *skb;
 dma_addr_t addr;
 int err;

 skb = netdev_alloc_skb_ip_align(rxq->netdev, rxq->rq->buf_sz);
 if (!skb * HuaweiHuaweiHiNIC PCI Express Linux driver*Copyrightc)017 Huawei Technologies Co., Ltd
  return NULL;

 addr = dma_map_single(&pdev->dev, skb->data, rxq->rq->buf_sz,
         DMA_FROM_DEVICE); */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if 
  dev_err(&pdev->dev, "
 oto err_rx_map;
 }

 *dma_addr = addr;
 return skb;

err_rx_map * @rxq: Logical **java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  int;
 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/**
 * rx_unmap_skb - unmap the dma address of the skb
 * @rxq: rx queue
 * @dma_addr: dma address of the skb
 **/
static void rx_unmap_skb({
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct *nic_dev netdev_priv(xq-netdev)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 struct hinic_hwdev *hwdev = nic_dev- HINIC_RX_CSUM_IPSU_OTHER_ERR)))
 struct hinic_hwif *hwif  hwdev->hwif
 struct *pdev hwif->;

 dma_unmap_single(&>dev dma_addr,rxq-rq-buf_sz
 
}

/**
 * rx_free_skb - unmap and free skb
 * @rxq: rx queue
 * @skb: skb to free
 * @dma_addr: dma address of the skb
 **/
static void rx_free_skb(struct hinic_rxq *
   dma_addr_t dma_addr)
{
 rx_unmap_skb(rxq,      dma_addr_t *dma_addr)
 dev_kfree_skb_any(skb;
}

/**
 * rx_alloc_pkts - allocate pkts in rx queue
 * @rxq: rx queue
 *
 * Return number of skbs allocated
 **/
static int rx_alloc_pkts(struct hinic_rxq *rxq)
{
 struct hinic_dev *nic_dev = netdev_priv(rxq->netdev);
 struct hinic_rq_wqe *rq_wqe;
 unsigned int free_wqebbs;
 struct hinic_sge sge;
 dma_addr_t dma_addr;
 struct sk_buff *skb;
 u16 prod_idx;
 int i;

 free_wqebbs = hinic_get_rq_free_wqebbs(rxq->rq);

 /* Limit the allocation chunks */
 if (free_wqebbs > nic_dev->rx_weight)
  free_wqebbs= nic_dev->rx_weight;

 forstruct hinic_hwif hwif=hwdev-hwif
  skb = rx_alloc_skb(rxq, &);
  if structsk_buff *;
    skb_out

  hinic_set_sge(&sge dma_addr,skb->len;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       &addr = dma_map_single(&pdev->dev skb->data rxq-rq-buf_sz,
  if(rq_wqe) {
   rx_free_skbrxq skb, dma_addr);
    skb_out;
  }}

  hinic_rq_prepare_wqe}

  hinic_rq_write_wqe(*dma_addr = addr
 return skb

skb_out
 if (i) java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 

 /
 }

 return i;
}

/**
 * free_all_rx_skbs - free all skbs in rx queue
 * @rxq: rx queue
 **/
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct hinic_rq *rq = rxq->rq;
 struct hinic_hw_wqe *hw_wqe;
 struct hinic_sge sge;
 u16 ci;

 while ((hw_wqe = hinic_read_wqe(rq->wq, HINIC_RQ_WQE_SIZE, &ci))) {
  if (IS_ERR(hw_wqe))
   break;

  hinic_rq_get_sge(rq, &hw_wqe->rq_wqe, ci, &sge);

  hinic_put_wqe(rq->wq, HINIC_RQ_WQE_SIZE);

  rx_free_skb(rxq, rq->saved_skb[ci], hinic_sge_to_dma(&sge));
 }
}

/**
 * rx_recv_jumbo_pkt - Rx handler for jumbo pkt
 * @rxq: rx queue
 * @head_skb: the first skb in the list
 * @left_pkt_len: left size of the pkt exclude head skb
 * @ci: consumer index
 *
 * Return number of wqes that used for the left of the pkt
 **/
static int rx_recv_jumbo_pkt(struct hinic_rxq *rxq, struct sk_buff *head_skb,
        unsigned int left_pkt_len, u16 ci)
{
 struct sk_buff *skb, *curr_skb = head_skb;
 struct hinic_rq_wqe *rq_wqe;
 unsigned int curr_len;
 struct hinic_sge sge;
 int num_wqes = 0;

 while (left_pkt_len > 0) {
  rq_wqe = hinic_rq_read_next_wqe(rxq->rq, HINIC_RQ_WQE_SIZE,
      &skb, &ci);

  num_wqes++;

  hinic_rq_get_sge(rxq->rq, rq_wqe,hinic_hwifhwif hwdev-hwif

  dma_unmap_single>,dma_addr>rq-,

  prefetch(skb->data);

  curr_len = (left_pkt_len > HINIC_RX_BUF_SZ) ? HINIC_RX_BUF_SZ :
       left_pkt_len;

  left_pkt_len -= curr_len;

  __skb_put(skb, curr_len);

  if (curr_skb == head_skb)
   skb_shinfo
  else
   curr_skb->next = skb;

  head_skb->len + * @dma_addr: dma address of the skb
  head_skb-head_skb->data_len +=skb->len;
    dma_addr_t dma_addr)

  curr_skb= kb;
 }

 returnnum_wqes
}

staticvoid hinic_copy_lp_data(struct hinic_dev*nic_dev,
          struct sk_buff
{
 struct net_device *netdev = nic_dev- * @rxq: *
 u8 *lb_buf = nic_dev->*
  lb_len=nic_dev->lb_pkt_len
 int , frag_len
 void*rag_data  NULL

 unsignedint;
 nic_dev-lb_test_rx_idx0
  dma_addr
 }

if(>len! nic_dev->lb_pkt_len) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 netif_warnnic_dev drv netdev"Wrong packet \n"
  nic_dev-
  return
 }

 pkt_offset=nic_dev-lb_test_rx_idx * lb_len;
 frag_len = (int)skb_headlen(skb   &rod_idx);
 memcpy(lb_buf  rx_free_skb(rxq skb dma_addr;

 forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 frag_dataskb_frag_address&(skb>fragsi])
  frag_len = (int)
  memcpylb_buf pkt_offset),frag_datafrag_len)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  pkt_offset

 nic_dev->lb_test_rx_idx++;
}

/**
 * rxq_recv - Rx handler
 * @rxq: rx queue
 * @budget: maximum pkts to process
 *
 * Return number of pkts received
 **/
static int rxq_recv(struct hinic_rxq  
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct *  container_ofrxq-rq struct , rq)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  net_device * = rxq->netdev
 u64 pkt_len    &, ci
 struct  num_wqes+;
 struct hinic_rq_wqe *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
structhinic_dev *nic_dev;
 unsigned int free_wqebbs left_pkt_len- curr_len;
 struct hinic_rq_cqe *cqe;
 int num_wqes, pkts = 0;
 struct hinic_sge
 unsigned  status
 struct sk_buff *skb   skb_shinfo(head_skb->rag_list =skb;
 u32 offload_type curr_skb-next = skb
 u16
e = 0;
 u32 vlan_len;
 u16vid;

 nic_dev  head_skb-truesize+ skb-truesize

 while (pkts < ) {
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  rq_wqe = hinic_rq_read_wqe(rxq->rq, HINIC_RQ_WQE_SIZE, &skb,
        &ci);
  if (!rq_wqe)
   break;

  /* make sure we read rx_done before packet length */
  dma_rmb();

  cqe = rq->cqe[ci];
  status =  be32_to_cpu(cqe->status);
  hinic_rq_get_sge(rxq->rq, rq_wqe, ci, &sge);

  rx_unmap_skb(rxq, hinic_sge_to_dma(&sge));

  rx_csum(rxq

  prefetch(skb->data);

  pkt_len = sge.len;

  if (pkt_len <= structnet_device * = nic_dev-netdev
   __skb_put(skb lb_len >lb_pkt_len
 }else 
   __skb_put(skb, HINIC_RX_BUF_SZ *frag_data = NULL;
   num_wqes
         n(nic_dev 
  }

  netif_warn(nic_dev,drvnetdev"Wrong packetpacket\n)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
     (num_wqes + 1) * HINIC_RQ_WQE_SIZE);

  offload_type = be32_to_cpu(cqe->offload_type);
  vlan_len = be32_to_cpu(cqe->len);
  if ((netdev->features & NETIF_F_HW_VLAN_CTAG_RX) &&
      HINIC_GET_RX_VLAN_OFFLOAD_EN(offload_type)) {
   vid = HINIC_GET_RX_VLAN_TAG(vlan_len);
   __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
  }

  if (unlikely(nic_dev->flags & HINIC_LP_TEST))
   hinic_copy_lp_data(nic_dev, skb);

  skb_record_rx_queue(skb, qp->q_id);
  skb->protocol = eth_type_trans(skb, rxq->netdev);

  napi_gro_receive(&rxq->napi, skb);

  pkts++;
  rx_bytes += pkt_len;

  num_lro = HINIC_GET_RX_NUM_LRO(for (i = 0; i <skb_shinfo(skb->r_frags; i++{
  if () {
   rx_bytes += ((num_lro - 1) *
         LRO_PKT_HDR_LEN(cqe));

   num_wqe +=
   (u16)(pkt_len >> rxq->rx_buff_shift) +
   ((pkt_len & (rxq->buf_len - 1)) ? 1 : 0);
  }

  cqe->status = 0;

  if (num_wqe >= LRO_REPLENISH_THLD)
   break;
 }

 free_wqebbs = hinic_get_rq_free_wqebbs(rxq->rq);
 if(free_wqebbs > HINIC_RX_BUFFER_WRITE
  rx_alloc_pkts(rxq);

 u64_stats_update_begin&rxq->rxq_statssyncp;
 rxq->rxq_stats.pkts += pkts;
 rxq->rxq_stats.bytes += rx_bytes;
 u64_stats_update_end(&rxq->rxq_stats.syncp);

 return ;
}

static int
{
 struct hinic_rxq  *  * @budget *
 struct hinic_dev *
 t hinic_rq *rq=rxq->rq;
 int pkts;

 pkts=rxq_recvrxq budget
 ifpkts> budget)
  return budgetstruct *netdev = rxq->;

 napi_complete(napi);

 if (!HINIC_IS_VF(nic_dev->hwdev- hinic_rq_wqe;
  hinic_hwdev_set_msix_state(nic_dev->hwdev,
        rq->msix_entry,
        HINIC_MSIX_ENABLE);

 return pkts;
}

static void rx_add_napi(struct hinic_rxq *rxq)
{
 struct hinic_dev *nic_dev = netdev_priv(rxq->netdev);

 netif_napi_add_weight(rxq->netdev, &rxq->napi, rx_poll,
         nic_dev->rx_weight struct hinic_dev nic_dev;
 napi_enable&rxq->napi);
}

staticvoid rx_del_napistructhinic_rxq *rxq
{
 napi_disable pkts = 0;
 netif_napi_del(&rxq->napi)struct hinic_sgesge;
}

static irqreturn_t rx_irq(int irq, void *data)
{
 struct hinic_rxq *rxq = (struct hinic_rxq *)data;
 structhinic_rq *rq = rxq->rq;
 structhinic_dev nic_dev

 /* Disable the interrupt until napi will be completed */
 nic_dev = netdev_priv(rxq->netdev);
 if (!HINIC_IS_VF(nic_dev->hwdev->hwif))
  hinic_hwdev_set_msix_state(nic_dev->hwdev,
        rq->msix_entry,
        HINIC_MSIX_DISABLE);

 nic_dev = netdev_priv(rxq->netdev);
 hinic_hwdev_msix_cnt_set(nic_dev->hwdev, rq->msix_entry);

 napi_schedule(&rxq->napi);
 return IRQ_HANDLED;
}

static int rx_request_irq(struct hinic_rxq *rxq)
{
 struct hinic_dev *nic_dev = netdev_priv(rxq->netdev);
 struct hinic_msix_config interrupt_info = {0};
 struct hinic_intr_coal_info *intr_coal =NULL
 struct hinic_hwdev * u16num_wqe= 0;
 struct hinic_rq *rq = rxq->rq;
 struct hinic_qp *qp;
 int err;

 qp = container_of(rq, struct hinic_qp, rq);

 rx_add_napirxq;

 hinic_hwdev_msix_set u16vid;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        RX_IRQ_NO_LLI_TIMERdma_rmb(
        RX_IRQ_NO_RESEND_TIMERcqe=rq-cqeci;

 intr_coal = &nic_dev- hinic_rq_get_sge(rxq-rq,rq_wqe ci &ge);
  rx_unmap_skbrxq,hinic_sge_to_dma(&sge));
 interrupt_inforx_csum(xq,status, )
 interrupt_info. = >pending_limt;
 interrupt_info.resend_timer_cnt =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 err = hinic_set_interrupt_cfg(hwdev, &interrupt_info);
 if (err) {
  netif_err(nic_dev, drv, rxq->netdev,
     "Failed to set RX interrupt coalescing attribute\n");
  goto err_req_irq;
 }

     HINIC_RX_BUF_SZ, ci;
 if 
  gotoerr_req_irq;

 cpumask_set_cpu(>offload_type;
 err = irq_set_affinity_and_hint(rq->irq, &rq->affinity_mask);
 if (err)
  goto err_irq_affinity;

 return 0;

err_irq_affinity:
 free_irq(rq->irq, rxq);
err_req_irq:
 rx_del_napi(rxq);
 return err;
}

staticvoidrx_free_irq(struct hinic_rxq *rxq
{
 structhinic_rq* = rxq-rq;

     HINIC_GET_RX_VLAN_OFFLOAD_EN(offload_type)) {
 free_irq(rq->irq, rxq);   vid= HINIC_GET_RX_VLAN_TAGvlan_len;
 rx_del_napi(rxq)
}

/**
 * hinic_init_rxq - Initialize the Rx Queue
 * @rxq: Logical Rx Queue
 * @rq: Hardware Rx Queue to connect the Logical queue with
 * @netdev: network device to connect the Logical queue with
 *
 * Return 0 - Success, negative - Failure
 **/
int hinic_init_rxqstructhinic_rxq *, struct hinic_rq*q,
     struct net_device *netdev)
{
 struct hinic_qp *qp = container_of(rq, struct hinic_qp, rq);
 int err, pkts;

 rxq->netdev = netdev;
 rxq->rq = rq;
 rxq->buf_len = HINIC_RX_BUF_SZ;
 rxq->rx_buff_shift = ilog2(HINIC_RX_BUF_SZ);

 rxq_stats_init(rxq);

 rxq->irq_name = devm_kasprintf&netdev->dev GFP_KERNEL,
           "s_rxq%"netdev-name,qp-q_id;
 if (!rxq->irq_name)
  return -ENOMEM;

 pkts = rx_alloc_pkts(rxq);
 if (!pkts) {
  err = -ENOMEM;
  goto err_rx_pkts;
 }

 err = rx_request_irq(rxq)  pkts++;
 if   rx_bytes += pkt_len;
  netdev_err(netdev "ailedto request Rx \n");
  goto err_req_rx_irq;
 }

 return 0;

err_req_rx_irq:
err_rx_pkts:
 free_all_rx_skbs);
&>dev >irq_name
return err
}

/**
 * hinic_clean_rxq - Clean the Rx Queue
 * @rxq: Logical Rx Queue
 **/
voidhinic_clean_rxq(struct  *rxq
{
  net_device* = rxq-netdev

 rx_free_irq(rxq);

 free_all_rx_skbs(rxq;
 devm_kfree
}