drivers/net/ethernet/sfc/ef100_rx.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /****************************************************************************
   3  * Driver for Solarflare network controllers and boards
   4  * Copyright 2005-2019 Solarflare Communications Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation, incorporated herein by reference.
   9  */
  10
  11 #include "net_driver.h"
  12 #include "ef100_rx.h"
  13 #include "rx_common.h"
  14 #include "efx.h"
  15 #include "nic_common.h"
  16 #include "mcdi_functions.h"
  17 #include "ef100_regs.h"
  18 #include "ef100_nic.h"
  19 #include "io.h"
  20
  21 /* Get the value of a field in the RX prefix */
  22 #define PREFIX_OFFSET_W(_f)     (ESF_GZ_RX_PREFIX_ ## _f ## _LBN / 32)
  23 #define PREFIX_OFFSET_B(_f)     (ESF_GZ_RX_PREFIX_ ## _f ## _LBN % 32)
  24 #define PREFIX_WIDTH_MASK(_f)   ((1ULL << ESF_GZ_RX_PREFIX_ ## _f ## _WIDTH) - 1)
  25 #define PREFIX_WORD(_p, _f)     le32_to_cpu((__force __le32)(_p)[PREFIX_OFFSET_W(_f)])
  26 #define PREFIX_FIELD(_p, _f)    ((PREFIX_WORD(_p, _f) >> PREFIX_OFFSET_B(_f)) & \
  27                                  PREFIX_WIDTH_MASK(_f))
  28
  29 #define ESF_GZ_RX_PREFIX_NT_OR_INNER_L3_CLASS_LBN       \
  30                 (ESF_GZ_RX_PREFIX_CLASS_LBN + ESF_GZ_RX_PREFIX_HCLASS_NT_OR_INNER_L3_CLASS_LBN)
  31 #define ESF_GZ_RX_PREFIX_NT_OR_INNER_L3_CLASS_WIDTH     \
  32                 ESF_GZ_RX_PREFIX_HCLASS_NT_OR_INNER_L3_CLASS_WIDTH
  33
  34 bool ef100_rx_buf_hash_valid(const u8 *prefix)
  35 {
  36         return PREFIX_FIELD(prefix, RSS_HASH_VALID);
  37 }
  38
  39 static bool ef100_has_fcs_error(struct efx_channel *channel, u32 *prefix)
  40 {
  41         u16 rxclass;
  42         u8 l2status;
  43
  44         rxclass = le16_to_cpu((__force __le16)PREFIX_FIELD(prefix, CLASS));
  45         l2status = PREFIX_FIELD(&rxclass, HCLASS_L2_STATUS);
  46
  47         if (likely(l2status == ESE_GZ_RH_HCLASS_L2_STATUS_OK))
  48                 /* Everything is ok */
  49                 return false;
  50
  51         if (l2status == ESE_GZ_RH_HCLASS_L2_STATUS_FCS_ERR)
  52                 channel->n_rx_eth_crc_err++;
  53         return true;
  54 }
  55
  56 void __ef100_rx_packet(struct efx_channel *channel)
  57 {
  58         struct efx_rx_queue *rx_queue = efx_channel_get_rx_queue(channel);
  59         struct efx_rx_buffer *rx_buf = efx_rx_buffer(rx_queue,
  60                                                      channel->rx_pkt_index);
  61         struct efx_nic *efx = channel->efx;
  62         struct ef100_nic_data *nic_data;
  63         u8 *eh = efx_rx_buf_va(rx_buf);
  64         __wsum csum = 0;
  65         u16 ing_port;
  66         u32 *prefix;
  67
  68         prefix = (u32 *)(eh - ESE_GZ_RX_PKT_PREFIX_LEN);
  69
  70         if (channel->type->receive_raw) {
  71                 u32 mark = PREFIX_FIELD(prefix, USER_MARK);
  72
  73                 if (channel->type->receive_raw(rx_queue, mark))
  74                         return; /* packet was consumed */
  75         }
  76
  77         if (ef100_has_fcs_error(channel, prefix) &&
  78             unlikely(!(efx->net_dev->features & NETIF_F_RXALL)))
  79                 goto out;
  80
  81         rx_buf->len = le16_to_cpu((__force __le16)PREFIX_FIELD(prefix, LENGTH));
  82         if (rx_buf->len <= sizeof(struct ethhdr)) {
  83                 if (net_ratelimit())
  84                         netif_err(channel->efx, rx_err, channel->efx->net_dev,
  85                                   "RX packet too small (%d)\n", rx_buf->len);
  86                 ++channel->n_rx_frm_trunc;
  87                 goto out;
  88         }
  89
  90         ing_port = le16_to_cpu((__force __le16) PREFIX_FIELD(prefix, INGRESS_MPORT));
  91
  92         nic_data = efx->nic_data;
  93
  94         if (nic_data->have_mport && ing_port != nic_data->base_mport) {
  95 #ifdef CONFIG_SFC_SRIOV
  96                 struct efx_rep *efv;
  97
  98                 rcu_read_lock();
  99                 efv = efx_ef100_find_rep_by_mport(efx, ing_port);
 100                 if (efv) {
 101                         if (efv->net_dev->flags & IFF_UP)
 102                                 efx_ef100_rep_rx_packet(efv, rx_buf);
 103                         rcu_read_unlock();
 104                         /* Representor Rx doesn't care about PF Rx buffer
 105                          * ownership, it just makes a copy. So, we are done
 106                          * with the Rx buffer from PF point of view and should
 107                          * free it.
 108                          */
 109                         goto free_rx_buffer;
 110                 }
 111                 rcu_read_unlock();
 112 #endif
 113                 if (net_ratelimit())
 114                         netif_warn(efx, drv, efx->net_dev,
 115                                    "Unrecognised ing_port %04x (base %04x), dropping\n",
 116                                    ing_port, nic_data->base_mport);
 117                 channel->n_rx_mport_bad++;
 118                 goto free_rx_buffer;
 119         }
 120
 121         if (likely(efx->net_dev->features & NETIF_F_RXCSUM)) {
 122                 if (PREFIX_FIELD(prefix, NT_OR_INNER_L3_CLASS) == 1) {
 123                         ++channel->n_rx_ip_hdr_chksum_err;
 124                 } else {
 125                         u16 sum = be16_to_cpu((__force __be16)PREFIX_FIELD(prefix, CSUM_FRAME));
 126
 127                         csum = (__force __wsum) sum;
 128                 }
 129         }
 130
 131         if (channel->type->receive_skb) {
 132                 /* no support for special channels yet, so just discard */
 133                 WARN_ON_ONCE(1);
 134                 goto free_rx_buffer;
 135         }
 136
 137         ++rx_queue->rx_packets;
 138         rx_queue->rx_bytes += rx_buf->len;
 139
 140         efx_rx_packet_gro(channel, rx_buf, channel->rx_pkt_n_frags, eh, csum);
 141         goto out;
 142
 143 free_rx_buffer:
 144         efx_free_rx_buffers(rx_queue, rx_buf, 1);
 145 out:
 146         channel->rx_pkt_n_frags = 0;
 147 }
 148
 149 static void ef100_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index)
 150 {
 151         struct efx_rx_buffer *rx_buf = efx_rx_buffer(rx_queue, index);
 152         struct efx_channel *channel = efx_rx_queue_channel(rx_queue);
 153         struct efx_nic *efx = rx_queue->efx;
 154
 155         netif_vdbg(efx, rx_status, efx->net_dev,
 156                    "RX queue %d received id %x\n",
 157                    efx_rx_queue_index(rx_queue), index);
 158
 159         efx_sync_rx_buffer(efx, rx_buf, efx->rx_dma_len);
 160
 161         prefetch(efx_rx_buf_va(rx_buf));
 162
 163         rx_buf->page_offset += efx->rx_prefix_size;
 164
 165         efx_recycle_rx_pages(channel, rx_buf, 1);
 166
 167         efx_rx_flush_packet(channel);
 168         channel->rx_pkt_n_frags = 1;
 169         channel->rx_pkt_index = index;
 170 }
 171
 172 void efx_ef100_ev_rx(struct efx_channel *channel, const efx_qword_t *p_event)
 173 {
 174         struct efx_rx_queue *rx_queue = efx_channel_get_rx_queue(channel);
 175         unsigned int n_packets =
 176                 EFX_QWORD_FIELD(*p_event, ESF_GZ_EV_RXPKTS_NUM_PKT);
 177         int i;
 178
 179         WARN_ON_ONCE(!n_packets);
 180         if (n_packets > 1)
 181                 ++channel->n_rx_merge_events;
 182
 183         channel->irq_mod_score += 2 * n_packets;
 184
 185         for (i = 0; i < n_packets; ++i) {
 186                 ef100_rx_packet(rx_queue,
 187                                 rx_queue->removed_count & rx_queue->ptr_mask);
 188                 ++rx_queue->removed_count;
 189         }
 190 }
 191
 192 void ef100_rx_write(struct efx_rx_queue *rx_queue)
 193 {
 194         unsigned int notified_count = rx_queue->notified_count;
 195         struct efx_rx_buffer *rx_buf;
 196         unsigned int idx;
 197         efx_qword_t *rxd;
 198         efx_dword_t rxdb;
 199
 200         while (notified_count != rx_queue->added_count) {
 201                 idx = notified_count & rx_queue->ptr_mask;
 202                 rx_buf = efx_rx_buffer(rx_queue, idx);
 203                 rxd = efx_rx_desc(rx_queue, idx);
 204
 205                 EFX_POPULATE_QWORD_1(*rxd, ESF_GZ_RX_BUF_ADDR, rx_buf->dma_addr);
 206
 207                 ++notified_count;
 208         }
 209         if (notified_count == rx_queue->notified_count)
 210                 return;
 211
 212         wmb();
 213         EFX_POPULATE_DWORD_1(rxdb, ERF_GZ_RX_RING_PIDX,
 214                              rx_queue->added_count & rx_queue->ptr_mask);
 215         efx_writed_page(rx_queue->efx, &rxdb,
 216                         ER_GZ_RX_RING_DOORBELL, efx_rx_queue_index(rx_queue));
 217         if (rx_queue->grant_credits)
 218                 wmb();
 219         rx_queue->notified_count = notified_count;
 220         if (rx_queue->grant_credits)
 221                 schedule_work(&rx_queue->grant_work);
 222 }