netronome/nfp/nfp_net_ctrl.c

0001 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
0002 /* Copyright (C) 2018 Netronome Systems, Inc. */
0003
0004 #include <linux/bitfield.h>
0005 #include <linux/device.h>
0006 #include <linux/kernel.h>
0007 #include <linux/types.h>
0008
0009 #include "nfp_net_ctrl.h"
0010 #include "nfp_net.h"
0011
0012 static void nfp_net_tlv_caps_reset(struct nfp_net_tlv_caps *caps)
0013 {
0014     memset(caps, 0, sizeof(*caps));
0015     caps->me_freq_mhz = 1200;
0016     caps->mbox_off = NFP_NET_CFG_MBOX_BASE;
0017     caps->mbox_len = NFP_NET_CFG_MBOX_VAL_MAX_SZ;
0018 }
0019
0020 static bool
0021 nfp_net_tls_parse_crypto_ops(struct device *dev, struct nfp_net_tlv_caps *caps,
0022                  u8 __iomem *ctrl_mem, u8 __iomem *data,
0023                  unsigned int length, unsigned int offset,
0024                  bool rx_stream_scan)
0025 {
0026     /* Ignore the legacy TLV if new one was already parsed */
0027     if (caps->tls_resync_ss && !rx_stream_scan)
0028         return true;
0029
0030     if (length < 32) {
0031         dev_err(dev,
0032             "CRYPTO OPS TLV should be at least 32B, is %dB offset:%u\n",
0033             length, offset);
0034         return false;
0035     }
0036
0037     caps->crypto_ops = readl(data);
0038     caps->crypto_enable_off = data - ctrl_mem + 16;
0039     caps->tls_resync_ss = rx_stream_scan;
0040
0041     return true;
0042 }
0043
0044 int nfp_net_tlv_caps_parse(struct device *dev, u8 __iomem *ctrl_mem,
0045                struct nfp_net_tlv_caps *caps)
0046 {
0047     u8 __iomem *data = ctrl_mem + NFP_NET_CFG_TLV_BASE;
0048     u8 __iomem *end = ctrl_mem + NFP_NET_CFG_BAR_SZ;
0049     u32 hdr;
0050
0051     nfp_net_tlv_caps_reset(caps);
0052
0053     hdr = readl(data);
0054     if (!hdr)
0055         return 0;
0056
0057     while (true) {
0058         unsigned int length, offset;
0059         u32 hdr = readl(data);
0060
0061         length = FIELD_GET(NFP_NET_CFG_TLV_HEADER_LENGTH, hdr);
0062         offset = data - ctrl_mem;
0063
0064         /* Advance past the header */
0065         data += 4;
0066
0067         if (length % NFP_NET_CFG_TLV_LENGTH_INC) {
0068             dev_err(dev, "TLV size not multiple of %u offset:%u len:%u\n",
0069                 NFP_NET_CFG_TLV_LENGTH_INC, offset, length);
0070             return -EINVAL;
0071         }
0072         if (data + length > end) {
0073             dev_err(dev, "oversized TLV offset:%u len:%u\n",
0074                 offset, length);
0075             return -EINVAL;
0076         }
0077
0078         switch (FIELD_GET(NFP_NET_CFG_TLV_HEADER_TYPE, hdr)) {
0079         case NFP_NET_CFG_TLV_TYPE_UNKNOWN:
0080             dev_err(dev, "NULL TLV at offset:%u\n", offset);
0081             return -EINVAL;
0082         case NFP_NET_CFG_TLV_TYPE_RESERVED:
0083             break;
0084         case NFP_NET_CFG_TLV_TYPE_END:
0085             if (!length)
0086                 return 0;
0087
0088             dev_err(dev, "END TLV should be empty, has offset:%u len:%d\n",
0089                 offset, length);
0090             return -EINVAL;
0091         case NFP_NET_CFG_TLV_TYPE_ME_FREQ:
0092             if (length != 4) {
0093                 dev_err(dev,
0094                     "ME FREQ TLV should be 4B, is %dB offset:%u\n",
0095                     length, offset);
0096                 return -EINVAL;
0097             }
0098
0099             caps->me_freq_mhz = readl(data);
0100             break;
0101         case NFP_NET_CFG_TLV_TYPE_MBOX:
0102             if (!length) {
0103                 caps->mbox_off = 0;
0104                 caps->mbox_len = 0;
0105             } else {
0106                 caps->mbox_off = data - ctrl_mem;
0107                 caps->mbox_len = length;
0108             }
0109             break;
0110         case NFP_NET_CFG_TLV_TYPE_EXPERIMENTAL0:
0111         case NFP_NET_CFG_TLV_TYPE_EXPERIMENTAL1:
0112             dev_warn(dev,
0113                  "experimental TLV type:%u offset:%u len:%u\n",
0114                  FIELD_GET(NFP_NET_CFG_TLV_HEADER_TYPE, hdr),
0115                  offset, length);
0116             break;
0117         case NFP_NET_CFG_TLV_TYPE_REPR_CAP:
0118             if (length < 4) {
0119                 dev_err(dev, "REPR CAP TLV short %dB < 4B offset:%u\n",
0120                     length, offset);
0121                 return -EINVAL;
0122             }
0123
0124             caps->repr_cap = readl(data);
0125             break;
0126         case NFP_NET_CFG_TLV_TYPE_MBOX_CMSG_TYPES:
0127             if (length >= 4)
0128                 caps->mbox_cmsg_types = readl(data);
0129             break;
0130         case NFP_NET_CFG_TLV_TYPE_CRYPTO_OPS:
0131             if (!nfp_net_tls_parse_crypto_ops(dev, caps, ctrl_mem,
0132                               data, length, offset,
0133                               false))
0134                 return -EINVAL;
0135             break;
0136         case NFP_NET_CFG_TLV_TYPE_VNIC_STATS:
0137             if ((data - ctrl_mem) % 8) {
0138                 dev_warn(dev, "VNIC STATS TLV misaligned, ignoring offset:%u len:%u\n",
0139                      offset, length);
0140                 break;
0141             }
0142             caps->vnic_stats_off = data - ctrl_mem;
0143             caps->vnic_stats_cnt = length / 10;
0144             break;
0145         case NFP_NET_CFG_TLV_TYPE_CRYPTO_OPS_RX_SCAN:
0146             if (!nfp_net_tls_parse_crypto_ops(dev, caps, ctrl_mem,
0147                               data, length, offset,
0148                               true))
0149                 return -EINVAL;
0150             break;
0151         default:
0152             if (!FIELD_GET(NFP_NET_CFG_TLV_HEADER_REQUIRED, hdr))
0153                 break;
0154
0155             dev_err(dev, "unknown TLV type:%u offset:%u len:%u\n",
0156                 FIELD_GET(NFP_NET_CFG_TLV_HEADER_TYPE, hdr),
0157                 offset, length);
0158             return -EINVAL;
0159         }
0160
0161         data += length;
0162         if (data + 4 > end) {
0163             dev_err(dev, "reached end of BAR without END TLV\n");
0164             return -EINVAL;
0165         }
0166     }
0167
0168     /* Not reached */
0169     return -EINVAL;
0170 }