drivers/net/sfc/sfc_dp_rx.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright(c) 2019-2020 Xilinx, Inc.
   4  * Copyright(c) 2017-2019 Solarflare Communications Inc.
   5  *
   6  * This software was jointly developed between OKTET Labs (under contract
   7  * for Solarflare) and Solarflare Communications, Inc.
   8  */
   9
  10 #ifndef _SFC_DP_RX_H
  11 #define _SFC_DP_RX_H
  12
  13 #include <rte_mempool.h>
  14 #include <rte_ethdev_driver.h>
  15
  16 #include "sfc_dp.h"
  17
  18 #ifdef __cplusplus
  19 extern "C" {
  20 #endif
  21
  22 /**
  23  * Generic receive queue information used on data path.
  24  * It must be kept as small as it is possible since it is built into
  25  * the structure used on datapath.
  26  */
  27 struct sfc_dp_rxq {
  28         struct sfc_dp_queue     dpq;
  29 };
  30
  31 /** Datapath receive queue descriptor number limitations */
  32 struct sfc_dp_rx_hw_limits {
  33         unsigned int rxq_max_entries;
  34         unsigned int rxq_min_entries;
  35         unsigned int evq_max_entries;
  36         unsigned int evq_min_entries;
  37 };
  38
  39 /**
  40  * Datapath receive queue creation information.
  41  *
  42  * The structure is used just to pass information from control path to
  43  * datapath. It could be just function arguments, but it would be hardly
  44  * readable.
  45  */
  46 struct sfc_dp_rx_qcreate_info {
  47         /** Memory pool to allocate Rx buffer from */
  48         struct rte_mempool      *refill_mb_pool;
  49         /** Maximum number of pushed Rx descriptors in the queue */
  50         unsigned int            max_fill_level;
  51         /** Minimum number of unused Rx descriptors to do refill */
  52         unsigned int            refill_threshold;
  53         /**
  54          * Usable mbuf data space in accordance with alignment and
  55          * padding requirements imposed by HW.
  56          */
  57         unsigned int            buf_size;
  58
  59         /**
  60          * Maximum number of Rx descriptors completed in one Rx event.
  61          * Just for sanity checks if datapath would like to do.
  62          */
  63         unsigned int            batch_max;
  64
  65         /** Pseudo-header size */
  66         unsigned int            prefix_size;
  67
  68         /** Receive queue flags initializer */
  69         unsigned int            flags;
  70 #define SFC_RXQ_FLAG_RSS_HASH   0x1
  71
  72         /** Rx queue size */
  73         unsigned int            rxq_entries;
  74         /** DMA-mapped Rx descriptors ring */
  75         void                    *rxq_hw_ring;
  76
  77         /** Event queue index in hardware */
  78         unsigned int            evq_hw_index;
  79         /** Associated event queue size */
  80         unsigned int            evq_entries;
  81         /** Hardware event ring */
  82         void                    *evq_hw_ring;
  83
  84         /** The queue index in hardware (required to push right doorbell) */
  85         unsigned int            hw_index;
  86         /**
  87          * Virtual address of the memory-mapped BAR to push Rx refill
  88          * doorbell
  89          */
  90         volatile void           *mem_bar;
  91         /** VI window size shift */
  92         unsigned int            vi_window_shift;
  93 };
  94
  95 /**
  96  * Get Rx datapath specific device info.
  97  *
  98  * @param dev_info              Device info to be adjusted
  99  */
 100 typedef void (sfc_dp_rx_get_dev_info_t)(struct rte_eth_dev_info *dev_info);
 101
 102 /**
 103  * Test if an Rx datapath supports specific mempool ops.
 104  *
 105  * @param pool                  The name of the pool operations to test.
 106  *
 107  * @return Check status.
 108  * @retval      0               Best mempool ops choice.
 109  * @retval      1               Mempool ops are supported.
 110  * @retval      -ENOTSUP        Mempool ops not supported.
 111  */
 112 typedef int (sfc_dp_rx_pool_ops_supported_t)(const char *pool);
 113
 114 /**
 115  * Get size of receive and event queue rings by the number of Rx
 116  * descriptors and mempool configuration.
 117  *
 118  * @param nb_rx_desc            Number of Rx descriptors
 119  * @param mb_pool               mbuf pool with Rx buffers
 120  * @param rxq_entries           Location for number of Rx ring entries
 121  * @param evq_entries           Location for number of event ring entries
 122  * @param rxq_max_fill_level    Location for maximum Rx ring fill level
 123  *
 124  * @return 0 or positive errno.
 125  */
 126 typedef int (sfc_dp_rx_qsize_up_rings_t)(uint16_t nb_rx_desc,
 127                                          struct sfc_dp_rx_hw_limits *limits,
 128                                          struct rte_mempool *mb_pool,
 129                                          unsigned int *rxq_entries,
 130                                          unsigned int *evq_entries,
 131                                          unsigned int *rxq_max_fill_level);
 132
 133 /**
 134  * Allocate and initialize datapath receive queue.
 135  *
 136  * @param port_id       The port identifier
 137  * @param queue_id      The queue identifier
 138  * @param pci_addr      PCI function address
 139  * @param socket_id     Socket identifier to allocate memory
 140  * @param info          Receive queue information
 141  * @param dp_rxqp       Location for generic datapath receive queue pointer
 142  *
 143  * @return 0 or positive errno.
 144  */
 145 typedef int (sfc_dp_rx_qcreate_t)(uint16_t port_id, uint16_t queue_id,
 146                                   const struct rte_pci_addr *pci_addr,
 147                                   int socket_id,
 148                                   const struct sfc_dp_rx_qcreate_info *info,
 149                                   struct sfc_dp_rxq **dp_rxqp);
 150
 151 /**
 152  * Free resources allocated for datapath recevie queue.
 153  */
 154 typedef void (sfc_dp_rx_qdestroy_t)(struct sfc_dp_rxq *dp_rxq);
 155
 156 /**
 157  * Receive queue start callback.
 158  *
 159  * It handovers EvQ to the datapath.
 160  */
 161 typedef int (sfc_dp_rx_qstart_t)(struct sfc_dp_rxq *dp_rxq,
 162                                  unsigned int evq_read_ptr);
 163
 164 /**
 165  * Receive queue stop function called before flush.
 166  */
 167 typedef void (sfc_dp_rx_qstop_t)(struct sfc_dp_rxq *dp_rxq,
 168                                  unsigned int *evq_read_ptr);
 169
 170 /**
 171  * Receive event handler used during queue flush only.
 172  */
 173 typedef bool (sfc_dp_rx_qrx_ev_t)(struct sfc_dp_rxq *dp_rxq, unsigned int id);
 174
 175 /**
 176  * Packed stream receive event handler used during queue flush only.
 177  */
 178 typedef bool (sfc_dp_rx_qrx_ps_ev_t)(struct sfc_dp_rxq *dp_rxq,
 179                                      unsigned int id);
 180
 181 /**
 182  * Receive queue purge function called after queue flush.
 183  *
 184  * Should be used to free unused recevie buffers.
 185  */
 186 typedef void (sfc_dp_rx_qpurge_t)(struct sfc_dp_rxq *dp_rxq);
 187
 188 /** Get packet types recognized/classified */
 189 typedef const uint32_t * (sfc_dp_rx_supported_ptypes_get_t)(
 190                                 uint32_t tunnel_encaps);
 191
 192 /** Get number of pending Rx descriptors */
 193 typedef unsigned int (sfc_dp_rx_qdesc_npending_t)(struct sfc_dp_rxq *dp_rxq);
 194
 195 /** Check Rx descriptor status */
 196 typedef int (sfc_dp_rx_qdesc_status_t)(struct sfc_dp_rxq *dp_rxq,
 197                                        uint16_t offset);
 198 /** Enable Rx interrupts */
 199 typedef int (sfc_dp_rx_intr_enable_t)(struct sfc_dp_rxq *dp_rxq);
 200
 201 /** Disable Rx interrupts */
 202 typedef int (sfc_dp_rx_intr_disable_t)(struct sfc_dp_rxq *dp_rxq);
 203
 204 /** Receive datapath definition */
 205 struct sfc_dp_rx {
 206         struct sfc_dp                           dp;
 207
 208         unsigned int                            features;
 209 #define SFC_DP_RX_FEAT_MULTI_PROCESS            0x1
 210 #define SFC_DP_RX_FEAT_FLOW_FLAG                0x2
 211 #define SFC_DP_RX_FEAT_FLOW_MARK                0x4
 212 #define SFC_DP_RX_FEAT_INTR                     0x8
 213         /**
 214          * Rx offload capabilities supported by the datapath on device
 215          * level only if HW/FW supports it.
 216          */
 217         uint64_t                                dev_offload_capa;
 218         /**
 219          * Rx offload capabilities supported by the datapath per-queue
 220          * if HW/FW supports it.
 221          */
 222         uint64_t                                queue_offload_capa;
 223         sfc_dp_rx_get_dev_info_t                *get_dev_info;
 224         sfc_dp_rx_pool_ops_supported_t          *pool_ops_supported;
 225         sfc_dp_rx_qsize_up_rings_t              *qsize_up_rings;
 226         sfc_dp_rx_qcreate_t                     *qcreate;
 227         sfc_dp_rx_qdestroy_t                    *qdestroy;
 228         sfc_dp_rx_qstart_t                      *qstart;
 229         sfc_dp_rx_qstop_t                       *qstop;
 230         sfc_dp_rx_qrx_ev_t                      *qrx_ev;
 231         sfc_dp_rx_qrx_ps_ev_t                   *qrx_ps_ev;
 232         sfc_dp_rx_qpurge_t                      *qpurge;
 233         sfc_dp_rx_supported_ptypes_get_t        *supported_ptypes_get;
 234         sfc_dp_rx_qdesc_npending_t              *qdesc_npending;
 235         sfc_dp_rx_qdesc_status_t                *qdesc_status;
 236         sfc_dp_rx_intr_enable_t                 *intr_enable;
 237         sfc_dp_rx_intr_disable_t                *intr_disable;
 238         eth_rx_burst_t                          pkt_burst;
 239 };
 240
 241 static inline struct sfc_dp_rx *
 242 sfc_dp_find_rx_by_name(struct sfc_dp_list *head, const char *name)
 243 {
 244         struct sfc_dp *p = sfc_dp_find_by_name(head, SFC_DP_RX, name);
 245
 246         return (p == NULL) ? NULL : container_of(p, struct sfc_dp_rx, dp);
 247 }
 248
 249 static inline struct sfc_dp_rx *
 250 sfc_dp_find_rx_by_caps(struct sfc_dp_list *head, unsigned int avail_caps)
 251 {
 252         struct sfc_dp *p = sfc_dp_find_by_caps(head, SFC_DP_RX, avail_caps);
 253
 254         return (p == NULL) ? NULL : container_of(p, struct sfc_dp_rx, dp);
 255 }
 256
 257 static inline uint64_t
 258 sfc_dp_rx_offload_capa(const struct sfc_dp_rx *dp_rx)
 259 {
 260         return dp_rx->dev_offload_capa | dp_rx->queue_offload_capa;
 261 }
 262
 263 /** Get Rx datapath ops by the datapath RxQ handle */
 264 const struct sfc_dp_rx *sfc_dp_rx_by_dp_rxq(const struct sfc_dp_rxq *dp_rxq);
 265
 266 extern struct sfc_dp_rx sfc_efx_rx;
 267 extern struct sfc_dp_rx sfc_ef10_rx;
 268 extern struct sfc_dp_rx sfc_ef10_essb_rx;
 269
 270 #ifdef __cplusplus
 271 }
 272 #endif
 273 #endif /* _SFC_DP_RX_H */