#include <asm/byteorder.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if.h>
#include <net/ip.h>
#include <net/tcp.h>
#include <net/gro.h>
#include <linux/skbuff.h>
#include <net/page_pool/helpers.h>
#include <linux/if_vlan.h>
#include <net/udp_tunnel.h>
#include <net/dst_metadata.h>
#include <net/netdev_queues.h>
#include "bnge.h"
#include "bnge_hwrm.h"
#include "bnge_hwrm_lib.h"
#include "bnge_netdev.h"
#include "bnge_rmem.h"
#include "bnge_txrx.h"
irqreturn_t bnge_msix(int irq, void *dev_instance)
{
struct bnge_napi *bnapi = dev_instance;
struct bnge_nq_ring_info *nqr;
struct bnge_net *bn;
u32 cons;
bn = bnapi->bn;
nqr = &bnapi->nq_ring;
cons = RING_CMP(bn, nqr->nq_raw_cons);
prefetch(&nqr->desc_ring[CP_RING(cons)][CP_IDX(cons)]);
napi_schedule(&bnapi->napi);
return IRQ_HANDLED;
}
static struct rx_agg_cmp *bnge_get_tpa_agg(struct bnge_net *bn,
struct bnge_rx_ring_info *rxr,
u16 agg_id, u16 curr)
{
struct bnge_tpa_info *tpa_info = &rxr->rx_tpa[agg_id];
return &tpa_info->agg_arr[curr];
}
static struct rx_agg_cmp *bnge_get_agg(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
u16 cp_cons, u16 curr)
{
struct rx_agg_cmp *agg;
cp_cons = RING_CMP(bn, ADV_RAW_CMP(cp_cons, curr));
agg = (struct rx_agg_cmp *)
&cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
return agg;
}
static void bnge_reuse_rx_agg_bufs(struct bnge_cp_ring_info *cpr, u16 idx,
u16 start, u32 agg_bufs, bool tpa)
{
struct bnge_napi *bnapi = cpr->bnapi;
struct bnge_net *bn = bnapi->bn;
struct bnge_rx_ring_info *rxr;
u16 prod, sw_prod;
u32 i;
rxr = bnapi->rx_ring;
sw_prod = rxr->rx_sw_agg_prod;
prod = rxr->rx_agg_prod;
for (i = 0; i < agg_bufs; i++) {
struct bnge_sw_rx_agg_bd *cons_rx_buf, *prod_rx_buf;
struct rx_agg_cmp *agg;
struct rx_bd *prod_bd;
netmem_ref netmem;
u16 cons;
if (tpa)
agg = bnge_get_tpa_agg(bn, rxr, idx, start + i);
else
agg = bnge_get_agg(bn, cpr, idx, start + i);
cons = agg->rx_agg_cmp_opaque;
__clear_bit(cons, rxr->rx_agg_bmap);
if (unlikely(test_bit(sw_prod, rxr->rx_agg_bmap)))
sw_prod = bnge_find_next_agg_idx(rxr, sw_prod);
__set_bit(sw_prod, rxr->rx_agg_bmap);
prod_rx_buf = &rxr->rx_agg_buf_ring[sw_prod];
cons_rx_buf = &rxr->rx_agg_buf_ring[cons];
netmem = cons_rx_buf->netmem;
cons_rx_buf->netmem = 0;
prod_rx_buf->netmem = netmem;
prod_rx_buf->offset = cons_rx_buf->offset;
prod_rx_buf->mapping = cons_rx_buf->mapping;
prod_bd = &rxr->rx_agg_desc_ring[RX_AGG_RING(bn, prod)]
[RX_IDX(prod)];
prod_bd->rx_bd_haddr = cpu_to_le64(cons_rx_buf->mapping);
prod_bd->rx_bd_opaque = sw_prod;
prod = NEXT_RX_AGG(prod);
sw_prod = RING_RX_AGG(bn, NEXT_RX_AGG(sw_prod));
}
rxr->rx_agg_prod = prod;
rxr->rx_sw_agg_prod = sw_prod;
}
static int bnge_agg_bufs_valid(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
u8 agg_bufs, u32 *raw_cons)
{
struct rx_agg_cmp *agg;
u16 last;
*raw_cons = ADV_RAW_CMP(*raw_cons, agg_bufs);
last = RING_CMP(bn, *raw_cons);
agg = (struct rx_agg_cmp *)
&cpr->desc_ring[CP_RING(last)][CP_IDX(last)];
return RX_AGG_CMP_VALID(bn, agg, *raw_cons);
}
static int bnge_discard_rx(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
u32 *raw_cons, void *cmp)
{
u32 tmp_raw_cons = *raw_cons;
struct rx_cmp *rxcmp = cmp;
u8 cmp_type, agg_bufs = 0;
cmp_type = RX_CMP_TYPE(rxcmp);
if (cmp_type == CMP_TYPE_RX_L2_CMP) {
agg_bufs = (le32_to_cpu(rxcmp->rx_cmp_misc_v1) &
RX_CMP_AGG_BUFS) >>
RX_CMP_AGG_BUFS_SHIFT;
} else if (cmp_type == CMP_TYPE_RX_L2_TPA_END_CMP) {
return 0;
}
if (agg_bufs) {
if (!bnge_agg_bufs_valid(bn, cpr, agg_bufs, &tmp_raw_cons))
return -EBUSY;
}
*raw_cons = tmp_raw_cons;
return 0;
}
static u32 __bnge_rx_agg_netmems(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
u16 idx, u32 agg_bufs, bool tpa,
struct sk_buff *skb)
{
struct bnge_napi *bnapi = cpr->bnapi;
struct skb_shared_info *shinfo;
struct bnge_rx_ring_info *rxr;
u32 i, total_frag_len = 0;
u16 prod;
rxr = bnapi->rx_ring;
prod = rxr->rx_agg_prod;
shinfo = skb_shinfo(skb);
for (i = 0; i < agg_bufs; i++) {
struct bnge_sw_rx_agg_bd *cons_rx_buf;
struct rx_agg_cmp *agg;
u16 cons, frag_len;
netmem_ref netmem;
if (tpa)
agg = bnge_get_tpa_agg(bn, rxr, idx, i);
else
agg = bnge_get_agg(bn, cpr, idx, i);
cons = agg->rx_agg_cmp_opaque;
frag_len = (le32_to_cpu(agg->rx_agg_cmp_len_flags_type) &
RX_AGG_CMP_LEN) >> RX_AGG_CMP_LEN_SHIFT;
cons_rx_buf = &rxr->rx_agg_buf_ring[cons];
skb_add_rx_frag_netmem(skb, i, cons_rx_buf->netmem,
cons_rx_buf->offset,
frag_len, BNGE_RX_PAGE_SIZE);
__clear_bit(cons, rxr->rx_agg_bmap);
netmem = cons_rx_buf->netmem;
cons_rx_buf->netmem = 0;
if (bnge_alloc_rx_netmem(bn, rxr, prod, GFP_ATOMIC) != 0) {
skb->len -= frag_len;
skb->data_len -= frag_len;
skb->truesize -= BNGE_RX_PAGE_SIZE;
--shinfo->nr_frags;
cons_rx_buf->netmem = netmem;
rxr->rx_agg_prod = prod;
bnge_reuse_rx_agg_bufs(cpr, idx, i, agg_bufs - i, tpa);
return 0;
}
page_pool_dma_sync_netmem_for_cpu(rxr->page_pool, netmem, 0,
BNGE_RX_PAGE_SIZE);
total_frag_len += frag_len;
prod = NEXT_RX_AGG(prod);
}
rxr->rx_agg_prod = prod;
return total_frag_len;
}
static struct sk_buff *bnge_rx_agg_netmems_skb(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
struct sk_buff *skb, u16 idx,
u32 agg_bufs, bool tpa)
{
u32 total_frag_len;
total_frag_len = __bnge_rx_agg_netmems(bn, cpr, idx, agg_bufs,
tpa, skb);
if (!total_frag_len) {
skb_mark_for_recycle(skb);
dev_kfree_skb(skb);
return NULL;
}
return skb;
}
static void bnge_sched_reset_rxr(struct bnge_net *bn,
struct bnge_rx_ring_info *rxr)
{
if (!rxr->bnapi->in_reset) {
rxr->bnapi->in_reset = true;
}
rxr->rx_next_cons = 0xffff;
}
static void bnge_sched_reset_txr(struct bnge_net *bn,
struct bnge_tx_ring_info *txr,
u16 curr)
{
struct bnge_napi *bnapi = txr->bnapi;
if (bnapi->tx_fault)
return;
netdev_err(bn->netdev, "Invalid Tx completion (ring:%d tx_hw_cons:%u cons:%u prod:%u curr:%u)",
txr->txq_index, txr->tx_hw_cons,
txr->tx_cons, txr->tx_prod, curr);
WARN_ON_ONCE(1);
bnapi->tx_fault = 1;
}
static u16 bnge_tpa_alloc_agg_idx(struct bnge_rx_ring_info *rxr, u16 agg_id)
{
struct bnge_tpa_idx_map *map = rxr->rx_tpa_idx_map;
u16 idx = agg_id & MAX_TPA_MASK;
if (test_bit(idx, map->agg_idx_bmap)) {
idx = find_first_zero_bit(map->agg_idx_bmap, MAX_TPA);
if (idx >= MAX_TPA)
return INVALID_HW_RING_ID;
}
__set_bit(idx, map->agg_idx_bmap);
map->agg_id_tbl[agg_id] = idx;
return idx;
}
static void bnge_free_agg_idx(struct bnge_rx_ring_info *rxr, u16 idx)
{
struct bnge_tpa_idx_map *map = rxr->rx_tpa_idx_map;
__clear_bit(idx, map->agg_idx_bmap);
}
static u16 bnge_lookup_agg_idx(struct bnge_rx_ring_info *rxr, u16 agg_id)
{
struct bnge_tpa_idx_map *map = rxr->rx_tpa_idx_map;
return map->agg_id_tbl[agg_id];
}
static void bnge_tpa_metadata(struct bnge_tpa_info *tpa_info,
struct rx_tpa_start_cmp *tpa_start,
struct rx_tpa_start_cmp_ext *tpa_start1)
{
tpa_info->cfa_code_valid = 1;
tpa_info->cfa_code = TPA_START_CFA_CODE(tpa_start1);
tpa_info->vlan_valid = 0;
if (tpa_info->flags2 & RX_CMP_FLAGS2_META_FORMAT_VLAN) {
tpa_info->vlan_valid = 1;
tpa_info->metadata =
le32_to_cpu(tpa_start1->rx_tpa_start_cmp_metadata);
}
}
static void bnge_tpa_metadata_v2(struct bnge_tpa_info *tpa_info,
struct rx_tpa_start_cmp *tpa_start,
struct rx_tpa_start_cmp_ext *tpa_start1)
{
tpa_info->vlan_valid = 0;
if (TPA_START_VLAN_VALID(tpa_start)) {
u32 tpid_sel = TPA_START_VLAN_TPID_SEL(tpa_start);
u32 vlan_proto = ETH_P_8021Q;
tpa_info->vlan_valid = 1;
if (tpid_sel == RX_TPA_START_METADATA1_TPID_8021AD)
vlan_proto = ETH_P_8021AD;
tpa_info->metadata = vlan_proto << 16 |
TPA_START_METADATA0_TCI(tpa_start1);
}
}
static void bnge_tpa_start(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
u8 cmp_type, struct rx_tpa_start_cmp *tpa_start,
struct rx_tpa_start_cmp_ext *tpa_start1)
{
struct bnge_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
struct bnge_tpa_info *tpa_info;
u16 cons, prod, agg_id;
struct rx_bd *prod_bd;
dma_addr_t mapping;
agg_id = TPA_START_AGG_ID(tpa_start);
agg_id = bnge_tpa_alloc_agg_idx(rxr, agg_id);
if (unlikely(agg_id == INVALID_HW_RING_ID)) {
netdev_warn(bn->netdev, "Unable to allocate agg ID for ring %d, agg 0x%lx\n",
rxr->bnapi->index, TPA_START_AGG_ID(tpa_start));
bnge_sched_reset_rxr(bn, rxr);
return;
}
cons = tpa_start->rx_tpa_start_cmp_opaque;
prod = rxr->rx_prod;
cons_rx_buf = &rxr->rx_buf_ring[cons];
prod_rx_buf = &rxr->rx_buf_ring[RING_RX(bn, prod)];
tpa_info = &rxr->rx_tpa[agg_id];
if (unlikely(cons != rxr->rx_next_cons ||
TPA_START_ERROR(tpa_start))) {
netdev_warn(bn->netdev, "TPA cons %x, expected cons %x, error code %lx\n",
cons, rxr->rx_next_cons,
TPA_START_ERROR_CODE(tpa_start1));
bnge_sched_reset_rxr(bn, rxr);
return;
}
prod_rx_buf->data = tpa_info->data;
prod_rx_buf->data_ptr = tpa_info->data_ptr;
mapping = tpa_info->mapping;
prod_rx_buf->mapping = mapping;
prod_bd = &rxr->rx_desc_ring[RX_RING(bn, prod)][RX_IDX(prod)];
prod_bd->rx_bd_haddr = cpu_to_le64(mapping);
tpa_info->data = cons_rx_buf->data;
tpa_info->data_ptr = cons_rx_buf->data_ptr;
cons_rx_buf->data = NULL;
tpa_info->mapping = cons_rx_buf->mapping;
tpa_info->len =
le32_to_cpu(tpa_start->rx_tpa_start_cmp_len_flags_type) >>
RX_TPA_START_CMP_LEN_SHIFT;
if (likely(TPA_START_HASH_VALID(tpa_start))) {
tpa_info->hash_type = PKT_HASH_TYPE_L4;
if (TPA_START_IS_IPV6(tpa_start1))
tpa_info->gso_type = SKB_GSO_TCPV6;
else
tpa_info->gso_type = SKB_GSO_TCPV4;
tpa_info->rss_hash =
le32_to_cpu(tpa_start->rx_tpa_start_cmp_rss_hash);
} else {
tpa_info->hash_type = PKT_HASH_TYPE_NONE;
tpa_info->gso_type = 0;
netif_warn(bn, rx_err, bn->netdev, "TPA packet without valid hash\n");
}
tpa_info->flags2 = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_flags2);
tpa_info->hdr_info = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_hdr_info);
if (cmp_type == CMP_TYPE_RX_L2_TPA_START_CMP)
bnge_tpa_metadata(tpa_info, tpa_start, tpa_start1);
else
bnge_tpa_metadata_v2(tpa_info, tpa_start, tpa_start1);
tpa_info->agg_count = 0;
rxr->rx_prod = NEXT_RX(prod);
cons = RING_RX(bn, NEXT_RX(cons));
rxr->rx_next_cons = RING_RX(bn, NEXT_RX(cons));
cons_rx_buf = &rxr->rx_buf_ring[cons];
bnge_reuse_rx_data(rxr, cons, cons_rx_buf->data);
rxr->rx_prod = NEXT_RX(rxr->rx_prod);
cons_rx_buf->data = NULL;
}
static void bnge_abort_tpa(struct bnge_cp_ring_info *cpr, u16 idx, u32 agg_bufs)
{
if (agg_bufs)
bnge_reuse_rx_agg_bufs(cpr, idx, 0, agg_bufs, true);
}
static void bnge_tpa_agg(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
struct rx_agg_cmp *rx_agg)
{
u16 agg_id = TPA_AGG_AGG_ID(rx_agg);
struct bnge_tpa_info *tpa_info;
agg_id = bnge_lookup_agg_idx(rxr, agg_id);
tpa_info = &rxr->rx_tpa[agg_id];
if (unlikely(tpa_info->agg_count >= MAX_SKB_FRAGS)) {
netdev_warn(bn->netdev,
"TPA completion count %d exceeds limit for ring %d\n",
tpa_info->agg_count, rxr->bnapi->index);
bnge_sched_reset_rxr(bn, rxr);
return;
}
tpa_info->agg_arr[tpa_info->agg_count++] = *rx_agg;
}
void bnge_reuse_rx_data(struct bnge_rx_ring_info *rxr, u16 cons, void *data)
{
struct bnge_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
struct bnge_net *bn = rxr->bnapi->bn;
struct rx_bd *cons_bd, *prod_bd;
u16 prod = rxr->rx_prod;
prod_rx_buf = &rxr->rx_buf_ring[RING_RX(bn, prod)];
cons_rx_buf = &rxr->rx_buf_ring[cons];
prod_rx_buf->data = data;
prod_rx_buf->data_ptr = cons_rx_buf->data_ptr;
prod_rx_buf->mapping = cons_rx_buf->mapping;
prod_bd = &rxr->rx_desc_ring[RX_RING(bn, prod)][RX_IDX(prod)];
cons_bd = &rxr->rx_desc_ring[RX_RING(bn, cons)][RX_IDX(cons)];
prod_bd->rx_bd_haddr = cons_bd->rx_bd_haddr;
}
static void bnge_deliver_skb(struct bnge_net *bn, struct bnge_napi *bnapi,
struct sk_buff *skb)
{
skb_mark_for_recycle(skb);
skb_record_rx_queue(skb, bnapi->index);
napi_gro_receive(&bnapi->napi, skb);
}
static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
unsigned int len, dma_addr_t mapping)
{
struct bnge_net *bn = bnapi->bn;
struct bnge_dev *bd = bn->bd;
struct sk_buff *skb;
skb = napi_alloc_skb(&bnapi->napi, len);
if (!skb)
return NULL;
dma_sync_single_for_cpu(bd->dev, mapping, len, bn->rx_dir);
memcpy(skb->data - NET_IP_ALIGN, data - NET_IP_ALIGN,
len + NET_IP_ALIGN);
dma_sync_single_for_device(bd->dev, mapping, len, bn->rx_dir);
skb_put(skb, len);
return skb;
}
#ifdef CONFIG_INET
static void bnge_gro_tunnel(struct sk_buff *skb, __be16 ip_proto)
{
struct udphdr *uh = NULL;
if (ip_proto == htons(ETH_P_IP)) {
struct iphdr *iph = (struct iphdr *)skb->data;
if (iph->protocol == IPPROTO_UDP)
uh = (struct udphdr *)(iph + 1);
} else {
struct ipv6hdr *iph = (struct ipv6hdr *)skb->data;
if (iph->nexthdr == IPPROTO_UDP)
uh = (struct udphdr *)(iph + 1);
}
if (uh) {
if (uh->check)
skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
else
skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
}
}
static struct sk_buff *bnge_gro_func(struct bnge_tpa_info *tpa_info,
int payload_off, int tcp_ts,
struct sk_buff *skb)
{
u16 outer_ip_off, inner_ip_off, inner_mac_off;
u32 hdr_info = tpa_info->hdr_info;
int iphdr_len, nw_off;
inner_ip_off = BNGE_TPA_INNER_L3_OFF(hdr_info);
inner_mac_off = BNGE_TPA_INNER_L2_OFF(hdr_info);
outer_ip_off = BNGE_TPA_OUTER_L3_OFF(hdr_info);
nw_off = inner_ip_off - ETH_HLEN;
skb_set_network_header(skb, nw_off);
iphdr_len = (tpa_info->flags2 & RX_TPA_START_CMP_FLAGS2_IP_TYPE) ?
sizeof(struct ipv6hdr) : sizeof(struct iphdr);
skb_set_transport_header(skb, nw_off + iphdr_len);
if (inner_mac_off) {
__be16 proto = *((__be16 *)(skb->data + outer_ip_off -
ETH_HLEN - 2));
bnge_gro_tunnel(skb, proto);
}
return skb;
}
static struct sk_buff *bnge_gro_skb(struct bnge_net *bn,
struct bnge_tpa_info *tpa_info,
struct rx_tpa_end_cmp *tpa_end,
struct rx_tpa_end_cmp_ext *tpa_end1,
struct sk_buff *skb)
{
int payload_off;
u16 segs;
segs = TPA_END_TPA_SEGS(tpa_end);
if (segs == 1)
return skb;
NAPI_GRO_CB(skb)->count = segs;
skb_shinfo(skb)->gso_size =
le32_to_cpu(tpa_end1->rx_tpa_end_cmp_seg_len);
skb_shinfo(skb)->gso_type = tpa_info->gso_type;
payload_off = TPA_END_PAYLOAD_OFF(tpa_end1);
skb = bnge_gro_func(tpa_info, payload_off,
TPA_END_GRO_TS(tpa_end), skb);
if (likely(skb))
tcp_gro_complete(skb);
return skb;
}
#endif
static struct sk_buff *bnge_tpa_end(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
u32 *raw_cons,
struct rx_tpa_end_cmp *tpa_end,
struct rx_tpa_end_cmp_ext *tpa_end1,
u8 *event)
{
struct bnge_napi *bnapi = cpr->bnapi;
struct net_device *dev = bn->netdev;
struct bnge_tpa_info *tpa_info;
struct bnge_rx_ring_info *rxr;
u8 *data_ptr, agg_bufs;
struct sk_buff *skb;
u16 idx = 0, agg_id;
dma_addr_t mapping;
unsigned int len;
void *data;
if (unlikely(bnapi->in_reset)) {
int rc = bnge_discard_rx(bn, cpr, raw_cons, tpa_end);
if (rc < 0)
return ERR_PTR(-EBUSY);
return NULL;
}
rxr = bnapi->rx_ring;
agg_id = TPA_END_AGG_ID(tpa_end);
agg_id = bnge_lookup_agg_idx(rxr, agg_id);
agg_bufs = TPA_END_AGG_BUFS(tpa_end1);
tpa_info = &rxr->rx_tpa[agg_id];
if (unlikely(agg_bufs != tpa_info->agg_count)) {
netdev_warn(bn->netdev, "TPA end agg_buf %d != expected agg_bufs %d\n",
agg_bufs, tpa_info->agg_count);
agg_bufs = tpa_info->agg_count;
}
tpa_info->agg_count = 0;
*event |= BNGE_AGG_EVENT;
bnge_free_agg_idx(rxr, agg_id);
idx = agg_id;
data = tpa_info->data;
data_ptr = tpa_info->data_ptr;
prefetch(data_ptr);
len = tpa_info->len;
mapping = tpa_info->mapping;
if (unlikely(agg_bufs > MAX_SKB_FRAGS || TPA_END_ERRORS(tpa_end1))) {
bnge_abort_tpa(cpr, idx, agg_bufs);
if (agg_bufs > MAX_SKB_FRAGS)
netdev_warn(bn->netdev, "TPA frags %d exceeded MAX_SKB_FRAGS %d\n",
agg_bufs, (int)MAX_SKB_FRAGS);
return NULL;
}
if (len <= bn->rx_copybreak) {
skb = bnge_copy_skb(bnapi, data_ptr, len, mapping);
if (!skb) {
bnge_abort_tpa(cpr, idx, agg_bufs);
return NULL;
}
} else {
dma_addr_t new_mapping;
u8 *new_data;
new_data = __bnge_alloc_rx_frag(bn, &new_mapping, rxr,
GFP_ATOMIC);
if (!new_data) {
bnge_abort_tpa(cpr, idx, agg_bufs);
return NULL;
}
tpa_info->data = new_data;
tpa_info->data_ptr = new_data + bn->rx_offset;
tpa_info->mapping = new_mapping;
skb = napi_build_skb(data, bn->rx_buf_size);
dma_sync_single_for_cpu(bn->bd->dev, mapping,
bn->rx_buf_use_size, bn->rx_dir);
if (!skb) {
page_pool_free_va(rxr->head_pool, data, true);
bnge_abort_tpa(cpr, idx, agg_bufs);
return NULL;
}
skb_mark_for_recycle(skb);
skb_reserve(skb, bn->rx_offset);
skb_put(skb, len);
}
if (agg_bufs) {
skb = bnge_rx_agg_netmems_skb(bn, cpr, skb, idx, agg_bufs,
true);
if (!skb)
return NULL;
}
skb->protocol = eth_type_trans(skb, dev);
if (tpa_info->hash_type != PKT_HASH_TYPE_NONE)
skb_set_hash(skb, tpa_info->rss_hash, tpa_info->hash_type);
if (tpa_info->vlan_valid &&
(dev->features & BNGE_HW_FEATURE_VLAN_ALL_RX)) {
__be16 vlan_proto = htons(tpa_info->metadata >>
RX_CMP_FLAGS2_METADATA_TPID_SFT);
u16 vtag = tpa_info->metadata & RX_CMP_FLAGS2_METADATA_TCI_MASK;
if (eth_type_vlan(vlan_proto)) {
__vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
} else {
dev_kfree_skb(skb);
return NULL;
}
}
skb_checksum_none_assert(skb);
if (likely(tpa_info->flags2 & RX_TPA_START_CMP_FLAGS2_L4_CS_CALC)) {
skb->ip_summed = CHECKSUM_UNNECESSARY;
skb->csum_level =
(tpa_info->flags2 & RX_CMP_FLAGS2_T_L4_CS_CALC) >> 3;
}
#ifdef CONFIG_INET
if (bn->priv_flags & BNGE_NET_EN_GRO)
skb = bnge_gro_skb(bn, tpa_info, tpa_end, tpa_end1, skb);
#endif
return skb;
}
static enum pkt_hash_types bnge_rss_ext_op(struct bnge_net *bn,
struct rx_cmp *rxcmp)
{
u8 ext_op = RX_CMP_V3_HASH_TYPE(bn->bd, rxcmp);
switch (ext_op) {
case EXT_OP_INNER_4:
case EXT_OP_OUTER_4:
case EXT_OP_INNFL_3:
case EXT_OP_OUTFL_3:
return PKT_HASH_TYPE_L4;
default:
return PKT_HASH_TYPE_L3;
}
}
static struct sk_buff *bnge_rx_vlan(struct sk_buff *skb, u8 cmp_type,
struct rx_cmp *rxcmp,
struct rx_cmp_ext *rxcmp1)
{
__be16 vlan_proto;
u16 vtag;
if (cmp_type == CMP_TYPE_RX_L2_CMP) {
__le32 flags2 = rxcmp1->rx_cmp_flags2;
u32 meta_data;
if (!(flags2 & cpu_to_le32(RX_CMP_FLAGS2_META_FORMAT_VLAN)))
return skb;
meta_data = le32_to_cpu(rxcmp1->rx_cmp_meta_data);
vtag = meta_data & RX_CMP_FLAGS2_METADATA_TCI_MASK;
vlan_proto =
htons(meta_data >> RX_CMP_FLAGS2_METADATA_TPID_SFT);
if (eth_type_vlan(vlan_proto))
__vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
else
goto vlan_err;
} else if (cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
if (RX_CMP_VLAN_VALID(rxcmp)) {
u32 tpid_sel = RX_CMP_VLAN_TPID_SEL(rxcmp);
if (tpid_sel == RX_CMP_METADATA1_TPID_8021Q)
vlan_proto = htons(ETH_P_8021Q);
else if (tpid_sel == RX_CMP_METADATA1_TPID_8021AD)
vlan_proto = htons(ETH_P_8021AD);
else
goto vlan_err;
vtag = RX_CMP_METADATA0_TCI(rxcmp1);
__vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
}
}
return skb;
vlan_err:
skb_mark_for_recycle(skb);
dev_kfree_skb(skb);
return NULL;
}
static struct sk_buff *bnge_rx_skb(struct bnge_net *bn,
struct bnge_rx_ring_info *rxr, u16 cons,
void *data, u8 *data_ptr,
dma_addr_t dma_addr,
unsigned int len)
{
struct bnge_dev *bd = bn->bd;
u16 prod = rxr->rx_prod;
struct sk_buff *skb;
int err;
err = bnge_alloc_rx_data(bn, rxr, prod, GFP_ATOMIC);
if (unlikely(err)) {
bnge_reuse_rx_data(rxr, cons, data);
return NULL;
}
dma_sync_single_for_cpu(bd->dev, dma_addr, len, bn->rx_dir);
skb = napi_build_skb(data, bn->rx_buf_size);
if (!skb) {
page_pool_free_va(rxr->head_pool, data, true);
return NULL;
}
skb_mark_for_recycle(skb);
skb_reserve(skb, bn->rx_offset);
skb_put(skb, len);
return skb;
}
static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
u32 *raw_cons, u8 *event)
{
struct bnge_napi *bnapi = cpr->bnapi;
struct net_device *dev = bn->netdev;
struct bnge_rx_ring_info *rxr;
u32 tmp_raw_cons, flags, misc;
struct bnge_sw_rx_bd *rx_buf;
struct rx_cmp_ext *rxcmp1;
u16 cons, prod, cp_cons;
u8 *data_ptr, cmp_type;
struct rx_cmp *rxcmp;
dma_addr_t dma_addr;
struct sk_buff *skb;
unsigned int len;
u8 agg_bufs;
void *data;
int rc = 0;
rxr = bnapi->rx_ring;
tmp_raw_cons = *raw_cons;
cp_cons = RING_CMP(bn, tmp_raw_cons);
rxcmp = (struct rx_cmp *)
&cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
cmp_type = RX_CMP_TYPE(rxcmp);
if (cmp_type == CMP_TYPE_RX_TPA_AGG_CMP) {
bnge_tpa_agg(bn, rxr, (struct rx_agg_cmp *)rxcmp);
goto next_rx_no_prod_no_len;
}
tmp_raw_cons = NEXT_RAW_CMP(tmp_raw_cons);
cp_cons = RING_CMP(bn, tmp_raw_cons);
rxcmp1 = (struct rx_cmp_ext *)
&cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
if (!RX_CMP_VALID(bn, rxcmp1, tmp_raw_cons))
return -EBUSY;
dma_rmb();
prod = rxr->rx_prod;
if (cmp_type == CMP_TYPE_RX_L2_TPA_START_CMP ||
cmp_type == CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
bnge_tpa_start(bn, rxr, cmp_type,
(struct rx_tpa_start_cmp *)rxcmp,
(struct rx_tpa_start_cmp_ext *)rxcmp1);
*event |= BNGE_RX_EVENT;
goto next_rx_no_prod_no_len;
} else if (cmp_type == CMP_TYPE_RX_L2_TPA_END_CMP) {
skb = bnge_tpa_end(bn, cpr, &tmp_raw_cons,
(struct rx_tpa_end_cmp *)rxcmp,
(struct rx_tpa_end_cmp_ext *)rxcmp1, event);
if (IS_ERR(skb))
return -EBUSY;
rc = -ENOMEM;
if (likely(skb)) {
bnge_deliver_skb(bn, bnapi, skb);
rc = 1;
}
*event |= BNGE_RX_EVENT;
goto next_rx_no_prod_no_len;
}
cons = rxcmp->rx_cmp_opaque;
if (unlikely(cons != rxr->rx_next_cons)) {
int rc1 = bnge_discard_rx(bn, cpr, &tmp_raw_cons, rxcmp);
if (rxr->rx_next_cons != 0xffff)
netdev_warn(bn->netdev, "RX cons %x != expected cons %x\n",
cons, rxr->rx_next_cons);
bnge_sched_reset_rxr(bn, rxr);
if (rc1)
return rc1;
goto next_rx_no_prod_no_len;
}
rx_buf = &rxr->rx_buf_ring[cons];
data = rx_buf->data;
data_ptr = rx_buf->data_ptr;
prefetch(data_ptr);
misc = le32_to_cpu(rxcmp->rx_cmp_misc_v1);
agg_bufs = (misc & RX_CMP_AGG_BUFS) >> RX_CMP_AGG_BUFS_SHIFT;
if (agg_bufs) {
if (!bnge_agg_bufs_valid(bn, cpr, agg_bufs, &tmp_raw_cons))
return -EBUSY;
cp_cons = NEXT_CMP(bn, cp_cons);
*event |= BNGE_AGG_EVENT;
}
*event |= BNGE_RX_EVENT;
rx_buf->data = NULL;
if (rxcmp1->rx_cmp_cfa_code_errors_v2 & RX_CMP_L2_ERRORS) {
bnge_reuse_rx_data(rxr, cons, data);
if (agg_bufs)
bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0, agg_bufs,
false);
rc = -EIO;
goto next_rx_no_len;
}
flags = le32_to_cpu(rxcmp->rx_cmp_len_flags_type);
len = flags >> RX_CMP_LEN_SHIFT;
dma_addr = rx_buf->mapping;
if (len <= bn->rx_copybreak) {
skb = bnge_copy_skb(bnapi, data_ptr, len, dma_addr);
bnge_reuse_rx_data(rxr, cons, data);
} else {
skb = bnge_rx_skb(bn, rxr, cons, data, data_ptr, dma_addr, len);
}
if (!skb) {
if (agg_bufs)
bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0,
agg_bufs, false);
goto oom_next_rx;
}
if (agg_bufs) {
skb = bnge_rx_agg_netmems_skb(bn, cpr, skb, cp_cons,
agg_bufs, false);
if (!skb)
goto oom_next_rx;
}
if (RX_CMP_HASH_VALID(rxcmp)) {
enum pkt_hash_types type;
if (cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
type = bnge_rss_ext_op(bn, rxcmp);
} else {
u32 itypes = RX_CMP_ITYPES(rxcmp);
if (itypes == RX_CMP_FLAGS_ITYPE_TCP ||
itypes == RX_CMP_FLAGS_ITYPE_UDP)
type = PKT_HASH_TYPE_L4;
else
type = PKT_HASH_TYPE_L3;
}
skb_set_hash(skb, le32_to_cpu(rxcmp->rx_cmp_rss_hash), type);
}
skb->protocol = eth_type_trans(skb, dev);
if (skb->dev->features & BNGE_HW_FEATURE_VLAN_ALL_RX) {
skb = bnge_rx_vlan(skb, cmp_type, rxcmp, rxcmp1);
if (!skb)
goto next_rx;
}
skb_checksum_none_assert(skb);
if (RX_CMP_L4_CS_OK(rxcmp1)) {
if (dev->features & NETIF_F_RXCSUM) {
skb->ip_summed = CHECKSUM_UNNECESSARY;
skb->csum_level = RX_CMP_ENCAP(rxcmp1);
}
}
bnge_deliver_skb(bn, bnapi, skb);
rc = 1;
next_rx:
next_rx_no_len:
rxr->rx_prod = NEXT_RX(prod);
rxr->rx_next_cons = RING_RX(bn, NEXT_RX(cons));
next_rx_no_prod_no_len:
*raw_cons = tmp_raw_cons;
return rc;
oom_next_rx:
rc = -ENOMEM;
goto next_rx;
}
static int bnge_force_rx_discard(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
u32 *raw_cons, u8 *event)
{
u32 tmp_raw_cons = *raw_cons;
struct rx_cmp_ext *rxcmp1;
struct rx_cmp *rxcmp;
u16 cp_cons;
u8 cmp_type;
int rc;
cp_cons = RING_CMP(bn, tmp_raw_cons);
rxcmp = (struct rx_cmp *)
&cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
tmp_raw_cons = NEXT_RAW_CMP(tmp_raw_cons);
cp_cons = RING_CMP(bn, tmp_raw_cons);
rxcmp1 = (struct rx_cmp_ext *)
&cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
if (!RX_CMP_VALID(bn, rxcmp1, tmp_raw_cons))
return -EBUSY;
dma_rmb();
cmp_type = RX_CMP_TYPE(rxcmp);
if (cmp_type == CMP_TYPE_RX_L2_CMP ||
cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
rxcmp1->rx_cmp_cfa_code_errors_v2 |=
cpu_to_le32(RX_CMPL_ERRORS_CRC_ERROR);
} else if (cmp_type == CMP_TYPE_RX_L2_TPA_END_CMP) {
struct rx_tpa_end_cmp_ext *tpa_end1;
tpa_end1 = (struct rx_tpa_end_cmp_ext *)rxcmp1;
tpa_end1->rx_tpa_end_cmp_errors_v2 |=
cpu_to_le32(RX_TPA_END_CMP_ERRORS);
}
rc = bnge_rx_pkt(bn, cpr, raw_cons, event);
return rc;
}
static void __bnge_tx_int(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
int budget)
{
u16 hw_cons = txr->tx_hw_cons;
struct bnge_dev *bd = bn->bd;
unsigned int tx_bytes = 0;
unsigned int tx_pkts = 0;
struct netdev_queue *txq;
u16 cons = txr->tx_cons;
skb_frag_t *frag;
txq = netdev_get_tx_queue(bn->netdev, txr->txq_index);
while (SW_TX_RING(bn, cons) != hw_cons) {
struct bnge_sw_tx_bd *tx_buf;
struct sk_buff *skb;
int j, last;
tx_buf = &txr->tx_buf_ring[SW_TX_RING(bn, cons)];
skb = tx_buf->skb;
if (unlikely(!skb)) {
bnge_sched_reset_txr(bn, txr, cons);
return;
}
cons = NEXT_TX(cons);
tx_pkts++;
tx_bytes += skb->len;
tx_buf->skb = NULL;
dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
skb_headlen(skb), DMA_TO_DEVICE);
last = tx_buf->nr_frags;
for (j = 0; j < last; j++) {
frag = &skb_shinfo(skb)->frags[j];
cons = NEXT_TX(cons);
tx_buf = &txr->tx_buf_ring[SW_TX_RING(bn, cons)];
netmem_dma_unmap_page_attrs(bd->dev,
dma_unmap_addr(tx_buf,
mapping),
skb_frag_size(frag),
DMA_TO_DEVICE, 0);
}
cons = NEXT_TX(cons);
napi_consume_skb(skb, budget);
}
WRITE_ONCE(txr->tx_cons, cons);
__netif_txq_completed_wake(txq, tx_pkts, tx_bytes,
bnge_tx_avail(bn, txr), bn->tx_wake_thresh,
(READ_ONCE(txr->dev_state) ==
BNGE_DEV_STATE_CLOSING));
}
static void bnge_tx_int(struct bnge_net *bn, struct bnge_napi *bnapi,
int budget)
{
struct bnge_tx_ring_info *txr;
int i;
bnge_for_each_napi_tx(i, bnapi, txr) {
if (txr->tx_hw_cons != SW_TX_RING(bn, txr->tx_cons))
__bnge_tx_int(bn, txr, budget);
}
bnapi->events &= ~BNGE_TX_CMP_EVENT;
}
static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
int budget)
{
struct bnge_rx_ring_info *rxr = bnapi->rx_ring;
if ((bnapi->events & BNGE_TX_CMP_EVENT) && !bnapi->tx_fault)
bnge_tx_int(bn, bnapi, budget);
if ((bnapi->events & BNGE_RX_EVENT)) {
bnge_db_write(bn->bd, &rxr->rx_db, rxr->rx_prod);
bnapi->events &= ~BNGE_RX_EVENT;
}
if (bnapi->events & BNGE_AGG_EVENT) {
bnge_db_write(bn->bd, &rxr->rx_agg_db, rxr->rx_agg_prod);
bnapi->events &= ~BNGE_AGG_EVENT;
}
}
static void
bnge_hwrm_update_token(struct bnge_dev *bd, u16 seq_id,
enum bnge_hwrm_wait_state state)
{
struct bnge_hwrm_wait_token *token;
rcu_read_lock();
hlist_for_each_entry_rcu(token, &bd->hwrm_pending_list, node) {
if (token->seq_id == seq_id) {
WRITE_ONCE(token->state, state);
rcu_read_unlock();
return;
}
}
rcu_read_unlock();
dev_err(bd->dev, "Invalid hwrm seq id %d\n", seq_id);
}
static int bnge_hwrm_handler(struct bnge_dev *bd, struct tx_cmp *txcmp)
{
struct hwrm_cmpl *h_cmpl = (struct hwrm_cmpl *)txcmp;
u16 cmpl_type = TX_CMP_TYPE(txcmp), seq_id;
switch (cmpl_type) {
case CMPL_BASE_TYPE_HWRM_DONE:
seq_id = le16_to_cpu(h_cmpl->sequence_id);
bnge_hwrm_update_token(bd, seq_id, BNGE_HWRM_COMPLETE);
break;
case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
default:
break;
}
return 0;
}
static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
int budget)
{
struct bnge_napi *bnapi = cpr->bnapi;
u32 raw_cons = cpr->cp_raw_cons;
struct tx_cmp *txcmp;
int rx_pkts = 0;
u8 event = 0;
u32 cons;
cpr->has_more_work = 0;
cpr->had_work_done = 1;
while (1) {
u8 cmp_type;
int rc;
cons = RING_CMP(bn, raw_cons);
txcmp = &cpr->desc_ring[CP_RING(cons)][CP_IDX(cons)];
if (!TX_CMP_VALID(bn, txcmp, raw_cons))
break;
dma_rmb();
cmp_type = TX_CMP_TYPE(txcmp);
if (cmp_type == CMP_TYPE_TX_L2_CMP ||
cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
u32 opaque = txcmp->tx_cmp_opaque;
struct bnge_tx_ring_info *txr;
u16 tx_freed;
txr = bnapi->tx_ring[TX_OPAQUE_RING(opaque)];
event |= BNGE_TX_CMP_EVENT;
if (cmp_type == CMP_TYPE_TX_L2_COAL_CMP)
txr->tx_hw_cons = TX_CMP_SQ_CONS_IDX(txcmp);
else
txr->tx_hw_cons = TX_OPAQUE_PROD(bn, opaque);
tx_freed = ((txr->tx_hw_cons - txr->tx_cons) &
bn->tx_ring_mask);
if (unlikely(tx_freed >= bn->tx_wake_thresh)) {
rx_pkts = budget;
raw_cons = NEXT_RAW_CMP(raw_cons);
if (budget)
cpr->has_more_work = 1;
break;
}
} else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
if (likely(budget))
rc = bnge_rx_pkt(bn, cpr, &raw_cons, &event);
else
rc = bnge_force_rx_discard(bn, cpr, &raw_cons,
&event);
if (likely(rc >= 0))
rx_pkts += rc;
else if (rc == -ENOMEM && budget)
rx_pkts++;
else if (rc == -EBUSY)
break;
} else if (unlikely(cmp_type == CMPL_BASE_TYPE_HWRM_DONE ||
cmp_type == CMPL_BASE_TYPE_HWRM_FWD_REQ ||
cmp_type == CMPL_BA_TY_HWRM_ASY_EVT)) {
bnge_hwrm_handler(bn->bd, txcmp);
}
raw_cons = NEXT_RAW_CMP(raw_cons);
if (rx_pkts && rx_pkts == budget) {
cpr->has_more_work = 1;
break;
}
}
cpr->cp_raw_cons = raw_cons;
bnapi->events |= event;
return rx_pkts;
}
static void __bnge_poll_cqs_done(struct bnge_net *bn, struct bnge_napi *bnapi,
u64 dbr_type, int budget)
{
struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
int i;
for (i = 0; i < nqr->cp_ring_count; i++) {
struct bnge_cp_ring_info *cpr = &nqr->cp_ring_arr[i];
struct bnge_db_info *db;
if (cpr->had_work_done) {
u32 tgl = 0;
if (dbr_type == DBR_TYPE_CQ_ARMALL) {
cpr->had_nqe_notify = 0;
tgl = cpr->toggle;
}
db = &cpr->cp_db;
bnge_writeq(bn->bd,
db->db_key64 | dbr_type | DB_TOGGLE(tgl) |
DB_RING_IDX(db, cpr->cp_raw_cons),
db->doorbell);
cpr->had_work_done = 0;
}
}
__bnge_poll_work_done(bn, bnapi, budget);
}
static int __bnge_poll_cqs(struct bnge_net *bn, struct bnge_napi *bnapi,
int budget)
{
struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
int i, work_done = 0;
for (i = 0; i < nqr->cp_ring_count; i++) {
struct bnge_cp_ring_info *cpr = &nqr->cp_ring_arr[i];
if (cpr->had_nqe_notify) {
work_done += __bnge_poll_work(bn, cpr,
budget - work_done);
nqr->has_more_work |= cpr->has_more_work;
}
}
return work_done;
}
int bnge_napi_poll(struct napi_struct *napi, int budget)
{
struct bnge_napi *bnapi = container_of(napi, struct bnge_napi, napi);
struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
u32 raw_cons = nqr->nq_raw_cons;
struct bnge_net *bn = bnapi->bn;
struct bnge_dev *bd = bn->bd;
struct nqe_cn *nqcmp;
int work_done = 0;
u32 cons;
if (nqr->has_more_work) {
nqr->has_more_work = 0;
work_done = __bnge_poll_cqs(bn, bnapi, budget);
}
while (1) {
u16 type;
cons = RING_CMP(bn, raw_cons);
nqcmp = &nqr->desc_ring[CP_RING(cons)][CP_IDX(cons)];
if (!NQ_CMP_VALID(bn, nqcmp, raw_cons)) {
if (nqr->has_more_work)
break;
__bnge_poll_cqs_done(bn, bnapi, DBR_TYPE_CQ_ARMALL,
budget);
nqr->nq_raw_cons = raw_cons;
if (napi_complete_done(napi, work_done))
BNGE_DB_NQ_ARM(bd, &nqr->nq_db,
nqr->nq_raw_cons);
goto poll_done;
}
dma_rmb();
type = le16_to_cpu(nqcmp->type);
if (NQE_CN_TYPE(type) == NQ_CN_TYPE_CQ_NOTIFICATION) {
u32 idx = le32_to_cpu(nqcmp->cq_handle_low);
u32 cq_type = BNGE_NQ_HDL_TYPE(idx);
struct bnge_cp_ring_info *cpr;
if (budget && work_done >= budget &&
cq_type == BNGE_NQ_HDL_TYPE_RX)
break;
idx = BNGE_NQ_HDL_IDX(idx);
cpr = &nqr->cp_ring_arr[idx];
cpr->had_nqe_notify = 1;
cpr->toggle = NQE_CN_TOGGLE(type);
work_done += __bnge_poll_work(bn, cpr,
budget - work_done);
nqr->has_more_work |= cpr->has_more_work;
} else {
bnge_hwrm_handler(bn->bd, (struct tx_cmp *)nqcmp);
}
raw_cons = NEXT_RAW_CMP(raw_cons);
}
__bnge_poll_cqs_done(bn, bnapi, DBR_TYPE_CQ, budget);
if (raw_cons != nqr->nq_raw_cons) {
nqr->nq_raw_cons = raw_cons;
BNGE_DB_NQ(bd, &nqr->nq_db, raw_cons);
}
poll_done:
return work_done;
}
static u16 bnge_xmit_get_cfa_action(struct sk_buff *skb)
{
struct metadata_dst *md_dst = skb_metadata_dst(skb);
if (!md_dst || md_dst->type != METADATA_HW_PORT_MUX)
return 0;
return md_dst->u.port_info.port_id;
}
static const u16 bnge_lhint_arr[] = {
TX_BD_FLAGS_LHINT_512_AND_SMALLER,
TX_BD_FLAGS_LHINT_512_TO_1023,
TX_BD_FLAGS_LHINT_1024_TO_2047,
TX_BD_FLAGS_LHINT_1024_TO_2047,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
TX_BD_FLAGS_LHINT_2048_AND_LARGER,
};
static void bnge_txr_db_kick(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
u16 prod)
{
wmb();
bnge_db_write(bn->bd, &txr->tx_db, prod);
txr->kick_pending = 0;
}
static u32 bnge_get_gso_hdr_len(struct sk_buff *skb)
{
bool udp_gso = !!(skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4);
u32 hdr_len;
if (skb->encapsulation) {
if (udp_gso)
hdr_len = skb_inner_transport_offset(skb) +
sizeof(struct udphdr);
else
hdr_len = skb_inner_tcp_all_headers(skb);
} else if (udp_gso) {
hdr_len = skb_transport_offset(skb) + sizeof(struct udphdr);
} else {
hdr_len = skb_tcp_all_headers(skb);
}
return hdr_len;
}
netdev_tx_t bnge_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
u32 len, free_size, vlan_tag_flags, cfa_action, flags;
struct bnge_net *bn = netdev_priv(dev);
struct bnge_tx_ring_info *txr;
struct bnge_dev *bd = bn->bd;
struct bnge_sw_tx_bd *tx_buf;
struct tx_bd *txbd, *txbd0;
struct netdev_queue *txq;
struct tx_bd_ext *txbd1;
u16 prod, last_frag;
unsigned int length;
dma_addr_t mapping;
__le32 lflags = 0;
skb_frag_t *frag;
int i;
i = skb_get_queue_mapping(skb);
txq = netdev_get_tx_queue(dev, i);
txr = &bn->tx_ring[bn->tx_ring_map[i]];
prod = txr->tx_prod;
free_size = bnge_tx_avail(bn, txr);
if (unlikely(free_size < skb_shinfo(skb)->nr_frags + 2)) {
if (net_ratelimit() && txr->kick_pending)
netif_warn(bn, tx_err, dev,
"bnge: ring busy w/ flush pending!\n");
if (!netif_txq_try_stop(txq, bnge_tx_avail(bn, txr),
bn->tx_wake_thresh))
return NETDEV_TX_BUSY;
}
last_frag = skb_shinfo(skb)->nr_frags;
txbd = &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
tx_buf = &txr->tx_buf_ring[SW_TX_RING(bn, prod)];
tx_buf->skb = skb;
tx_buf->nr_frags = last_frag;
vlan_tag_flags = 0;
cfa_action = bnge_xmit_get_cfa_action(skb);
if (skb_vlan_tag_present(skb)) {
vlan_tag_flags = TX_BD_CFA_META_KEY_VLAN |
skb_vlan_tag_get(skb);
if (skb->vlan_proto == htons(ETH_P_8021Q))
vlan_tag_flags |= 1 << TX_BD_CFA_META_TPID_SHIFT;
}
if (unlikely(skb->no_fcs))
lflags |= cpu_to_le32(TX_BD_FLAGS_NO_CRC);
if (eth_skb_pad(skb))
goto tx_kick_pending;
len = skb_headlen(skb);
mapping = dma_map_single(bd->dev, skb->data, len, DMA_TO_DEVICE);
if (unlikely(dma_mapping_error(bd->dev, mapping)))
goto tx_free;
dma_unmap_addr_set(tx_buf, mapping, mapping);
flags = (len << TX_BD_LEN_SHIFT) | TX_BD_TYPE_LONG_TX_BD |
TX_BD_CNT(last_frag + 2);
txbd->tx_bd_haddr = cpu_to_le64(mapping);
txbd->tx_bd_opaque = SET_TX_OPAQUE(bn, txr, prod, 2 + last_frag);
prod = NEXT_TX(prod);
txbd1 = (struct tx_bd_ext *)
&txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
if (skb_is_gso(skb)) {
u32 hdr_len = bnge_get_gso_hdr_len(skb);
lflags |= cpu_to_le32(TX_BD_FLAGS_LSO | TX_BD_FLAGS_T_IPID |
(hdr_len << (TX_BD_HSIZE_SHIFT - 1)));
length = skb_shinfo(skb)->gso_size;
txbd1->tx_bd_mss = cpu_to_le32(length);
length += hdr_len;
} else {
length = skb->len;
if (skb->ip_summed == CHECKSUM_PARTIAL) {
lflags |= cpu_to_le32(TX_BD_FLAGS_TCP_UDP_CHKSUM);
txbd1->tx_bd_mss = 0;
}
}
flags |= bnge_lhint_arr[length >> 9];
txbd->tx_bd_len_flags_type = cpu_to_le32(flags);
txbd1->tx_bd_hsize_lflags = lflags;
txbd1->tx_bd_cfa_meta = cpu_to_le32(vlan_tag_flags);
txbd1->tx_bd_cfa_action =
cpu_to_le32(cfa_action << TX_BD_CFA_ACTION_SHIFT);
txbd0 = txbd;
for (i = 0; i < last_frag; i++) {
frag = &skb_shinfo(skb)->frags[i];
prod = NEXT_TX(prod);
txbd = &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
len = skb_frag_size(frag);
mapping = skb_frag_dma_map(bd->dev, frag, 0, len,
DMA_TO_DEVICE);
if (unlikely(dma_mapping_error(bd->dev, mapping)))
goto tx_dma_error;
tx_buf = &txr->tx_buf_ring[SW_TX_RING(bn, prod)];
netmem_dma_unmap_addr_set(skb_frag_netmem(frag), tx_buf,
mapping, mapping);
txbd->tx_bd_haddr = cpu_to_le64(mapping);
flags = len << TX_BD_LEN_SHIFT;
txbd->tx_bd_len_flags_type = cpu_to_le32(flags);
}
flags &= ~TX_BD_LEN;
txbd->tx_bd_len_flags_type =
cpu_to_le32(((len) << TX_BD_LEN_SHIFT) | flags |
TX_BD_FLAGS_PACKET_END);
netdev_tx_sent_queue(txq, skb->len);
prod = NEXT_TX(prod);
WRITE_ONCE(txr->tx_prod, prod);
if (!netdev_xmit_more() || netif_xmit_stopped(txq)) {
bnge_txr_db_kick(bn, txr, prod);
} else {
if (free_size >= bn->tx_wake_thresh)
txbd0->tx_bd_len_flags_type |=
cpu_to_le32(TX_BD_FLAGS_NO_CMPL);
txr->kick_pending = 1;
}
if (unlikely(bnge_tx_avail(bn, txr) <= MAX_SKB_FRAGS + 1)) {
if (netdev_xmit_more()) {
txbd0->tx_bd_len_flags_type &=
cpu_to_le32(~TX_BD_FLAGS_NO_CMPL);
bnge_txr_db_kick(bn, txr, prod);
}
netif_txq_try_stop(txq, bnge_tx_avail(bn, txr),
bn->tx_wake_thresh);
}
return NETDEV_TX_OK;
tx_dma_error:
last_frag = i;
prod = txr->tx_prod;
tx_buf = &txr->tx_buf_ring[SW_TX_RING(bn, prod)];
dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
skb_headlen(skb), DMA_TO_DEVICE);
prod = NEXT_TX(prod);
for (i = 0; i < last_frag; i++) {
prod = NEXT_TX(prod);
tx_buf = &txr->tx_buf_ring[SW_TX_RING(bn, prod)];
frag = &skb_shinfo(skb)->frags[i];
netmem_dma_unmap_page_attrs(bd->dev,
dma_unmap_addr(tx_buf, mapping),
skb_frag_size(frag),
DMA_TO_DEVICE, 0);
}
tx_free:
dev_kfree_skb_any(skb);
tx_kick_pending:
if (txr->kick_pending)
bnge_txr_db_kick(bn, txr, txr->tx_prod);
txr->tx_buf_ring[SW_TX_RING(bn, txr->tx_prod)].skb = NULL;
dev_core_stats_tx_dropped_inc(dev);
return NETDEV_TX_OK;
}
netdev_features_t bnge_features_check(struct sk_buff *skb,
struct net_device *dev,
netdev_features_t features)
{
u32 len;
features = vlan_features_check(skb, features);
#if (MAX_SKB_FRAGS > TX_MAX_FRAGS)
if (skb_shinfo(skb)->nr_frags > TX_MAX_FRAGS)
features &= ~NETIF_F_SG;
#endif
if (skb_is_gso(skb))
len = bnge_get_gso_hdr_len(skb) + skb_shinfo(skb)->gso_size;
else
len = skb->len;
len >>= 9;
if (unlikely(len >= ARRAY_SIZE(bnge_lhint_arr)))
features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
return features;
}
