sys/dev/ice/ice_common_txrx.h

   1 /* SPDX-License-Identifier: BSD-3-Clause */
   2 /*  Copyright (c) 2020, Intel Corporation
   3  *  All rights reserved.
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions are met:
   7  *
   8  *   1. Redistributions of source code must retain the above copyright notice,
   9  *      this list of conditions and the following disclaimer.
  10  *
  11  *   2. Redistributions in binary form must reproduce the above copyright
  12  *      notice, this list of conditions and the following disclaimer in the
  13  *      documentation and/or other materials provided with the distribution.
  14  *
  15  *   3. Neither the name of the Intel Corporation nor the names of its
  16  *      contributors may be used to endorse or promote products derived from
  17  *      this software without specific prior written permission.
  18  *
  19  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  *  POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 /*$FreeBSD$*/
  32
  33 /**
  34  * @file ice_common_txrx.h
  35  * @brief common Tx/Rx utility functions
  36  *
  37  * Contains common utility functions for the Tx/Rx hot path.
  38  *
  39  * The functions do depend on the if_pkt_info_t structure. A suitable
  40  * implementation of this structure must be provided if these functions are to
  41  * be used without the iflib networking stack.
  42  */
  43
  44 #ifndef _ICE_COMMON_TXRX_H_
  45 #define _ICE_COMMON_TXRX_H_
  46
  47 #include <netinet/udp.h>
  48 #include <netinet/sctp.h>
  49
  50 /**
  51  * ice_tso_detect_sparse - detect TSO packets with too many segments
  52  * @pi: packet information
  53  *
  54  * Hardware only transmits packets with a maximum of 8 descriptors. For TSO
  55  * packets, hardware needs to be able to build the split packets using 8 or
  56  * fewer descriptors. Additionally, the header must be contained within at
  57  * most 3 descriptors.
  58  *
  59  * To verify this, we walk the headers to find out how many descriptors the
  60  * headers require (usually 1). Then we ensure that, for each TSO segment, its
  61  * data plus the headers are contained within 8 or fewer descriptors.
  62  */
  63 static inline int
  64 ice_tso_detect_sparse(if_pkt_info_t pi)
  65 {
  66         int count, curseg, i, hlen, segsz, seglen, tsolen, hdrs, maxsegs;
  67         bus_dma_segment_t *segs = pi->ipi_segs;
  68         int nsegs = pi->ipi_nsegs;
  69
  70         curseg = hdrs = 0;
  71
  72         hlen = pi->ipi_ehdrlen + pi->ipi_ip_hlen + pi->ipi_tcp_hlen;
  73         tsolen = pi->ipi_len - hlen;
  74
  75         /* First, count the number of descriptors for the header.
  76          * Additionally, make sure it does not span more than 3 segments.
  77          */
  78         i = 0;
  79         curseg = segs[0].ds_len;
  80         while (hlen > 0) {
  81                 hdrs++;
  82                 if (hdrs > ICE_MAX_TSO_HDR_SEGS)
  83                         return (1);
  84                 if (curseg == 0) {
  85                         i++;
  86                         if (__predict_false(i == nsegs))
  87                                 return (1);
  88
  89                         curseg = segs[i].ds_len;
  90                 }
  91                 seglen = min(curseg, hlen);
  92                 curseg -= seglen;
  93                 hlen -= seglen;
  94         }
  95
  96         maxsegs = ICE_MAX_TX_SEGS - hdrs;
  97
  98         /* We must count the headers, in order to verify that they take up
  99          * 3 or fewer descriptors. However, we don't need to check the data
 100          * if the total segments is small.
 101          */
 102         if (nsegs <= maxsegs)
 103                 return (0);
 104
 105         count = 0;
 106
 107         /* Now check the data to make sure that each TSO segment is made up of
 108          * no more than maxsegs descriptors. This ensures that hardware will
 109          * be capable of performing TSO offload.
 110          */
 111         while (tsolen > 0) {
 112                 segsz = pi->ipi_tso_segsz;
 113                 while (segsz > 0 && tsolen != 0) {
 114                         count++;
 115                         if (count > maxsegs) {
 116                                 return (1);
 117                         }
 118                         if (curseg == 0) {
 119                                 i++;
 120                                 if (__predict_false(i == nsegs)) {
 121                                         return (1);
 122                                 }
 123                                 curseg = segs[i].ds_len;
 124                         }
 125                         seglen = min(curseg, segsz);
 126                         segsz -= seglen;
 127                         curseg -= seglen;
 128                         tsolen -= seglen;
 129                 }
 130                 count = 0;
 131         }
 132
 133         return (0);
 134 }
 135
 136 /**
 137  * ice_tso_setup - Setup a context descriptor to prepare for a TSO packet
 138  * @txq: the Tx queue to use
 139  * @pi: the packet info to prepare for
 140  *
 141  * Setup a context descriptor in preparation for sending a Tx packet that
 142  * requires the TSO offload. Returns the index of the descriptor to use when
 143  * encapsulating the Tx packet data into descriptors.
 144  */
 145 static inline int
 146 ice_tso_setup(struct ice_tx_queue *txq, if_pkt_info_t pi)
 147 {
 148         struct ice_tx_ctx_desc          *txd;
 149         u32                             cmd, mss, type, tsolen;
 150         int                             idx;
 151         u64                             type_cmd_tso_mss;
 152
 153         idx = pi->ipi_pidx;
 154         txd = (struct ice_tx_ctx_desc *)&txq->tx_base[idx];
 155         tsolen = pi->ipi_len - (pi->ipi_ehdrlen + pi->ipi_ip_hlen + pi->ipi_tcp_hlen);
 156
 157         type = ICE_TX_DESC_DTYPE_CTX;
 158         cmd = ICE_TX_CTX_DESC_TSO;
 159         /* TSO MSS must not be less than 64 */
 160         if (pi->ipi_tso_segsz < ICE_MIN_TSO_MSS) {
 161                 txq->stats.mss_too_small++;
 162                 pi->ipi_tso_segsz = ICE_MIN_TSO_MSS;
 163         }
 164         mss = pi->ipi_tso_segsz;
 165
 166         type_cmd_tso_mss = ((u64)type << ICE_TXD_CTX_QW1_DTYPE_S) |
 167             ((u64)cmd << ICE_TXD_CTX_QW1_CMD_S) |
 168             ((u64)tsolen << ICE_TXD_CTX_QW1_TSO_LEN_S) |
 169             ((u64)mss << ICE_TXD_CTX_QW1_MSS_S);
 170         txd->qw1 = htole64(type_cmd_tso_mss);
 171
 172         txd->tunneling_params = htole32(0);
 173         txq->tso++;
 174
 175         return ((idx + 1) & (txq->desc_count-1));
 176 }
 177
 178 /**
 179  * ice_tx_setup_offload - Setup register values for performing a Tx offload
 180  * @txq: The Tx queue, used to track checksum offload stats
 181  * @pi: the packet info to program for
 182  * @cmd: the cmd register value to update
 183  * @off: the off register value to update
 184  *
 185  * Based on the packet info provided, update the cmd and off values for
 186  * enabling Tx offloads. This depends on the packet type and which offloads
 187  * have been requested.
 188  *
 189  * We also track the total number of times that we've requested hardware
 190  * offload a particular type of checksum for debugging purposes.
 191  */
 192 static inline void
 193 ice_tx_setup_offload(struct ice_tx_queue *txq, if_pkt_info_t pi, u32 *cmd, u32 *off)
 194 {
 195         u32 remaining_csum_flags = pi->ipi_csum_flags;
 196
 197         switch (pi->ipi_etype) {
 198 #ifdef INET
 199                 case ETHERTYPE_IP:
 200                         if (pi->ipi_csum_flags & ICE_CSUM_IP) {
 201                                 *cmd |= ICE_TX_DESC_CMD_IIPT_IPV4_CSUM;
 202                                 txq->stats.cso[ICE_CSO_STAT_TX_IP4]++;
 203                                 remaining_csum_flags &= ~CSUM_IP;
 204                         } else
 205                                 *cmd |= ICE_TX_DESC_CMD_IIPT_IPV4;
 206                         break;
 207 #endif
 208 #ifdef INET6
 209                 case ETHERTYPE_IPV6:
 210                         *cmd |= ICE_TX_DESC_CMD_IIPT_IPV6;
 211                         /*
 212                          * This indicates that the IIPT flag was set to the IPV6 value;
 213                          * there's no checksum for IPv6 packets.
 214                          */
 215                         txq->stats.cso[ICE_CSO_STAT_TX_IP6]++;
 216                         break;
 217 #endif
 218                 default:
 219                         txq->stats.cso[ICE_CSO_STAT_TX_L3_ERR]++;
 220                         break;
 221         }
 222
 223         *off |= (pi->ipi_ehdrlen >> 1) << ICE_TX_DESC_LEN_MACLEN_S;
 224         *off |= (pi->ipi_ip_hlen >> 2) << ICE_TX_DESC_LEN_IPLEN_S;
 225
 226         if (!(remaining_csum_flags & ~ICE_RX_CSUM_FLAGS))
 227                 return;
 228
 229         switch (pi->ipi_ipproto) {
 230                 case IPPROTO_TCP:
 231                         if (pi->ipi_csum_flags & ICE_CSUM_TCP) {
 232                                 *cmd |= ICE_TX_DESC_CMD_L4T_EOFT_TCP;
 233                                 *off |= (pi->ipi_tcp_hlen >> 2) <<
 234                                     ICE_TX_DESC_LEN_L4_LEN_S;
 235                                 txq->stats.cso[ICE_CSO_STAT_TX_TCP]++;
 236                         }
 237                         break;
 238                 case IPPROTO_UDP:
 239                         if (pi->ipi_csum_flags & ICE_CSUM_UDP) {
 240                                 *cmd |= ICE_TX_DESC_CMD_L4T_EOFT_UDP;
 241                                 *off |= (sizeof(struct udphdr) >> 2) <<
 242                                     ICE_TX_DESC_LEN_L4_LEN_S;
 243                                 txq->stats.cso[ICE_CSO_STAT_TX_UDP]++;
 244                         }
 245                         break;
 246                 case IPPROTO_SCTP:
 247                         if (pi->ipi_csum_flags & ICE_CSUM_SCTP) {
 248                                 *cmd |= ICE_TX_DESC_CMD_L4T_EOFT_SCTP;
 249                                 *off |= (sizeof(struct sctphdr) >> 2) <<
 250                                     ICE_TX_DESC_LEN_L4_LEN_S;
 251                                 txq->stats.cso[ICE_CSO_STAT_TX_SCTP]++;
 252                         }
 253                         break;
 254                 default:
 255                         txq->stats.cso[ICE_CSO_STAT_TX_L4_ERR]++;
 256                         break;
 257         }
 258 }
 259
 260 /**
 261  * ice_rx_checksum - verify hardware checksum is valid or not
 262  * @rxq: the Rx queue structure
 263  * @flags: checksum flags to update
 264  * @data: checksum data to update
 265  * @status0: descriptor status data
 266  * @ptype: packet type
 267  *
 268  * Determine whether the hardware indicated that the Rx checksum is valid. If
 269  * so, update the checksum flags and data, informing the stack of the status
 270  * of the checksum so that it does not spend time verifying it manually.
 271  */
 272 static void
 273 ice_rx_checksum(struct ice_rx_queue *rxq, uint32_t *flags, uint32_t *data,
 274                 u16 status0, u16 ptype)
 275 {
 276         const u16 l3_error = (BIT(ICE_RX_FLEX_DESC_STATUS0_XSUM_IPE_S) |
 277                               BIT(ICE_RX_FLEX_DESC_STATUS0_XSUM_EIPE_S));
 278         const u16 l4_error = (BIT(ICE_RX_FLEX_DESC_STATUS0_XSUM_L4E_S) |
 279                               BIT(ICE_RX_FLEX_DESC_STATUS0_XSUM_EUDPE_S));
 280         const u16 xsum_errors = (l3_error | l4_error |
 281                                  BIT(ICE_RX_FLEX_DESC_STATUS0_IPV6EXADD_S));
 282         struct ice_rx_ptype_decoded decoded;
 283         bool is_ipv4, is_ipv6;
 284
 285         /* No L3 or L4 checksum was calculated */
 286         if (!(status0 & BIT(ICE_RX_FLEX_DESC_STATUS0_L3L4P_S))) {
 287                 return;
 288         }
 289
 290         decoded = ice_decode_rx_desc_ptype(ptype);
 291         *flags = 0;
 292
 293         if (!(decoded.known && decoded.outer_ip))
 294                 return;
 295
 296         is_ipv4 = (decoded.outer_ip == ICE_RX_PTYPE_OUTER_IP) &&
 297             (decoded.outer_ip_ver == ICE_RX_PTYPE_OUTER_IPV4);
 298         is_ipv6 = (decoded.outer_ip == ICE_RX_PTYPE_OUTER_IP) &&
 299             (decoded.outer_ip_ver == ICE_RX_PTYPE_OUTER_IPV6);
 300
 301         /* No checksum errors were reported */
 302         if (!(status0 & xsum_errors)) {
 303                 if (is_ipv4)
 304                         *flags |= CSUM_L3_CALC | CSUM_L3_VALID;
 305
 306                 switch (decoded.inner_prot) {
 307                 case ICE_RX_PTYPE_INNER_PROT_TCP:
 308                 case ICE_RX_PTYPE_INNER_PROT_UDP:
 309                 case ICE_RX_PTYPE_INNER_PROT_SCTP:
 310                         *flags |= CSUM_L4_CALC | CSUM_L4_VALID;
 311                         *data |= htons(0xffff);
 312                         break;
 313                 default:
 314                         break;
 315                 }
 316
 317                 return;
 318         }
 319
 320         /*
 321          * Certain IPv6 extension headers impact the validity of L4 checksums.
 322          * If one of these headers exist, hardware will set the IPV6EXADD bit
 323          * in the descriptor. If the bit is set then pretend like hardware
 324          * didn't checksum this packet.
 325          */
 326         if (is_ipv6 && (status0 & BIT(ICE_RX_FLEX_DESC_STATUS0_IPV6EXADD_S))) {
 327                 rxq->stats.cso[ICE_CSO_STAT_RX_IP6_ERR]++;
 328                 return;
 329         }
 330
 331         /*
 332          * At this point, status0 must have at least one of the l3_error or
 333          * l4_error bits set.
 334          */
 335
 336         if (status0 & l3_error) {
 337                 if (is_ipv4) {
 338                         rxq->stats.cso[ICE_CSO_STAT_RX_IP4_ERR]++;
 339                         *flags |= CSUM_L3_CALC;
 340                 } else {
 341                         /* Hardware indicated L3 error but this isn't IPv4? */
 342                         rxq->stats.cso[ICE_CSO_STAT_RX_L3_ERR]++;
 343                 }
 344                 /* don't bother reporting L4 errors if we got an L3 error */
 345                 return;
 346         } else if (is_ipv4) {
 347                 *flags |= CSUM_L3_CALC | CSUM_L3_VALID;
 348         }
 349
 350         if (status0 & l4_error) {
 351                 switch (decoded.inner_prot) {
 352                 case ICE_RX_PTYPE_INNER_PROT_TCP:
 353                         rxq->stats.cso[ICE_CSO_STAT_RX_TCP_ERR]++;
 354                         *flags |= CSUM_L4_CALC;
 355                         break;
 356                 case ICE_RX_PTYPE_INNER_PROT_UDP:
 357                         rxq->stats.cso[ICE_CSO_STAT_RX_UDP_ERR]++;
 358                         *flags |= CSUM_L4_CALC;
 359                         break;
 360                 case ICE_RX_PTYPE_INNER_PROT_SCTP:
 361                         rxq->stats.cso[ICE_CSO_STAT_RX_SCTP_ERR]++;
 362                         *flags |= CSUM_L4_CALC;
 363                         break;
 364                 default:
 365                         /*
 366                          * Hardware indicated L4 error, but this isn't one of
 367                          * the expected protocols.
 368                          */
 369                         rxq->stats.cso[ICE_CSO_STAT_RX_L4_ERR]++;
 370                 }
 371         }
 372 }
 373
 374 /**
 375  * ice_ptype_to_hash - Convert packet type to a hash value
 376  * @ptype: the packet type to convert
 377  *
 378  * Given the packet type, convert to a suitable hashtype to report to the
 379  * upper stack via the iri_rsstype value of the if_rxd_info_t structure.
 380  *
 381  * If the hash type is unknown we'll report M_HASHTYPE_OPAQUE.
 382  */
 383 static inline int
 384 ice_ptype_to_hash(u16 ptype)
 385 {
 386         struct ice_rx_ptype_decoded decoded;
 387
 388         if (ptype >= ARRAY_SIZE(ice_ptype_lkup))
 389                 return M_HASHTYPE_OPAQUE;
 390
 391         decoded = ice_decode_rx_desc_ptype(ptype);
 392
 393         if (!decoded.known)
 394                 return M_HASHTYPE_OPAQUE;
 395
 396         if (decoded.outer_ip == ICE_RX_PTYPE_OUTER_L2)
 397                 return M_HASHTYPE_OPAQUE;
 398
 399         /* Note: anything that gets to this point is IP */
 400         if (decoded.outer_ip_ver == ICE_RX_PTYPE_OUTER_IPV6) {
 401                 switch (decoded.inner_prot) {
 402                 case ICE_RX_PTYPE_INNER_PROT_TCP:
 403                         return M_HASHTYPE_RSS_TCP_IPV6;
 404                 case ICE_RX_PTYPE_INNER_PROT_UDP:
 405                         return M_HASHTYPE_RSS_UDP_IPV6;
 406                 default:
 407                         return M_HASHTYPE_RSS_IPV6;
 408                 }
 409         }
 410         if (decoded.outer_ip_ver == ICE_RX_PTYPE_OUTER_IPV4) {
 411                 switch (decoded.inner_prot) {
 412                 case ICE_RX_PTYPE_INNER_PROT_TCP:
 413                         return M_HASHTYPE_RSS_TCP_IPV4;
 414                 case ICE_RX_PTYPE_INNER_PROT_UDP:
 415                         return M_HASHTYPE_RSS_UDP_IPV4;
 416                 default:
 417                         return M_HASHTYPE_RSS_IPV4;
 418                 }
 419         }
 420
 421         /* We should never get here!! */
 422         return M_HASHTYPE_OPAQUE;
 423 }
 424 #endif