drivers/net/ethernet/intel/ice/ice_virtchnl_allowlist.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2021, Intel Corporation. */
   3
   4 #include "ice_virtchnl_allowlist.h"
   5
   6 /* Purpose of this file is to share functionality to allowlist or denylist
   7  * opcodes used in PF <-> VF communication. Group of opcodes:
   8  * - default -> should be always allowed after creating VF,
   9  *   default_allowlist_opcodes
  10  * - opcodes needed by VF to work correctly, but not associated with caps ->
  11  *   should be allowed after successful VF resources allocation,
  12  *   working_allowlist_opcodes
  13  * - opcodes needed by VF when caps are activated
  14  *
  15  * Caps that don't use new opcodes (no opcodes should be allowed):
  16  * - VIRTCHNL_VF_OFFLOAD_WB_ON_ITR
  17  * - VIRTCHNL_VF_OFFLOAD_CRC
  18  * - VIRTCHNL_VF_OFFLOAD_RX_POLLING
  19  * - VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2
  20  * - VIRTCHNL_VF_OFFLOAD_ENCAP
  21  * - VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM
  22  * - VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM
  23  * - VIRTCHNL_VF_OFFLOAD_USO
  24  */
  25
  26 /* default opcodes to communicate with VF */
  27 static const u32 default_allowlist_opcodes[] = {
  28         VIRTCHNL_OP_GET_VF_RESOURCES, VIRTCHNL_OP_VERSION, VIRTCHNL_OP_RESET_VF,
  29 };
  30
  31 /* opcodes supported after successful VIRTCHNL_OP_GET_VF_RESOURCES */
  32 static const u32 working_allowlist_opcodes[] = {
  33         VIRTCHNL_OP_CONFIG_TX_QUEUE, VIRTCHNL_OP_CONFIG_RX_QUEUE,
  34         VIRTCHNL_OP_CONFIG_VSI_QUEUES, VIRTCHNL_OP_CONFIG_IRQ_MAP,
  35         VIRTCHNL_OP_ENABLE_QUEUES, VIRTCHNL_OP_DISABLE_QUEUES,
  36         VIRTCHNL_OP_GET_STATS, VIRTCHNL_OP_EVENT,
  37 };
  38
  39 /* VIRTCHNL_VF_OFFLOAD_L2 */
  40 static const u32 l2_allowlist_opcodes[] = {
  41         VIRTCHNL_OP_ADD_ETH_ADDR, VIRTCHNL_OP_DEL_ETH_ADDR,
  42         VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
  43 };
  44
  45 /* VIRTCHNL_VF_OFFLOAD_REQ_QUEUES */
  46 static const u32 req_queues_allowlist_opcodes[] = {
  47         VIRTCHNL_OP_REQUEST_QUEUES,
  48 };
  49
  50 /* VIRTCHNL_VF_OFFLOAD_VLAN */
  51 static const u32 vlan_allowlist_opcodes[] = {
  52         VIRTCHNL_OP_ADD_VLAN, VIRTCHNL_OP_DEL_VLAN,
  53         VIRTCHNL_OP_ENABLE_VLAN_STRIPPING, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING,
  54 };
  55
  56 /* VIRTCHNL_VF_OFFLOAD_VLAN_V2 */
  57 static const u32 vlan_v2_allowlist_opcodes[] = {
  58         VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS, VIRTCHNL_OP_ADD_VLAN_V2,
  59         VIRTCHNL_OP_DEL_VLAN_V2, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2,
  60         VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2,
  61         VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2,
  62         VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2,
  63 };
  64
  65 /* VIRTCHNL_VF_OFFLOAD_RSS_PF */
  66 static const u32 rss_pf_allowlist_opcodes[] = {
  67         VIRTCHNL_OP_CONFIG_RSS_KEY, VIRTCHNL_OP_CONFIG_RSS_LUT,
  68         VIRTCHNL_OP_GET_RSS_HENA_CAPS, VIRTCHNL_OP_SET_RSS_HENA,
  69         VIRTCHNL_OP_CONFIG_RSS_HFUNC,
  70 };
  71
  72 /* VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC */
  73 static const u32 rx_flex_desc_allowlist_opcodes[] = {
  74         VIRTCHNL_OP_GET_SUPPORTED_RXDIDS,
  75 };
  76
  77 /* VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF */
  78 static const u32 adv_rss_pf_allowlist_opcodes[] = {
  79         VIRTCHNL_OP_ADD_RSS_CFG, VIRTCHNL_OP_DEL_RSS_CFG,
  80 };
  81
  82 /* VIRTCHNL_VF_OFFLOAD_FDIR_PF */
  83 static const u32 fdir_pf_allowlist_opcodes[] = {
  84         VIRTCHNL_OP_ADD_FDIR_FILTER, VIRTCHNL_OP_DEL_FDIR_FILTER,
  85 };
  86
  87 struct allowlist_opcode_info {
  88         const u32 *opcodes;
  89         size_t size;
  90 };
  91
  92 #define BIT_INDEX(caps) (HWEIGHT((caps) - 1))
  93 #define ALLOW_ITEM(caps, list) \
  94         [BIT_INDEX(caps)] = { \
  95                 .opcodes = list, \
  96                 .size = ARRAY_SIZE(list) \
  97         }
  98 static const struct allowlist_opcode_info allowlist_opcodes[] = {
  99         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_L2, l2_allowlist_opcodes),
 100         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_REQ_QUEUES, req_queues_allowlist_opcodes),
 101         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_VLAN, vlan_allowlist_opcodes),
 102         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_RSS_PF, rss_pf_allowlist_opcodes),
 103         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_RX_FLEX_DESC, rx_flex_desc_allowlist_opcodes),
 104         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF, adv_rss_pf_allowlist_opcodes),
 105         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_FDIR_PF, fdir_pf_allowlist_opcodes),
 106         ALLOW_ITEM(VIRTCHNL_VF_OFFLOAD_VLAN_V2, vlan_v2_allowlist_opcodes),
 107 };
 108
 109 /**
 110  * ice_vc_is_opcode_allowed - check if this opcode is allowed on this VF
 111  * @vf: pointer to VF structure
 112  * @opcode: virtchnl opcode
 113  *
 114  * Return true if message is allowed on this VF
 115  */
 116 bool ice_vc_is_opcode_allowed(struct ice_vf *vf, u32 opcode)
 117 {
 118         if (opcode >= VIRTCHNL_OP_MAX)
 119                 return false;
 120
 121         return test_bit(opcode, vf->opcodes_allowlist);
 122 }
 123
 124 /**
 125  * ice_vc_allowlist_opcodes - allowlist selected opcodes
 126  * @vf: pointer to VF structure
 127  * @opcodes: array of opocodes to allowlist
 128  * @size: size of opcodes array
 129  *
 130  * Function should be called to allowlist opcodes on VF.
 131  */
 132 static void
 133 ice_vc_allowlist_opcodes(struct ice_vf *vf, const u32 *opcodes, size_t size)
 134 {
 135         unsigned int i;
 136
 137         for (i = 0; i < size; i++)
 138                 set_bit(opcodes[i], vf->opcodes_allowlist);
 139 }
 140
 141 /**
 142  * ice_vc_clear_allowlist - clear all allowlist opcodes
 143  * @vf: pointer to VF structure
 144  */
 145 static void ice_vc_clear_allowlist(struct ice_vf *vf)
 146 {
 147         bitmap_zero(vf->opcodes_allowlist, VIRTCHNL_OP_MAX);
 148 }
 149
 150 /**
 151  * ice_vc_set_default_allowlist - allowlist default opcodes for VF
 152  * @vf: pointer to VF structure
 153  */
 154 void ice_vc_set_default_allowlist(struct ice_vf *vf)
 155 {
 156         ice_vc_clear_allowlist(vf);
 157         ice_vc_allowlist_opcodes(vf, default_allowlist_opcodes,
 158                                  ARRAY_SIZE(default_allowlist_opcodes));
 159 }
 160
 161 /**
 162  * ice_vc_set_working_allowlist - allowlist opcodes needed to by VF to work
 163  * @vf: pointer to VF structure
 164  *
 165  * allowlist opcodes that aren't associated with specific caps, but
 166  * are needed by VF to work.
 167  */
 168 void ice_vc_set_working_allowlist(struct ice_vf *vf)
 169 {
 170         ice_vc_allowlist_opcodes(vf, working_allowlist_opcodes,
 171                                  ARRAY_SIZE(working_allowlist_opcodes));
 172 }
 173
 174 /**
 175  * ice_vc_set_caps_allowlist - allowlist VF opcodes according caps
 176  * @vf: pointer to VF structure
 177  */
 178 void ice_vc_set_caps_allowlist(struct ice_vf *vf)
 179 {
 180         unsigned long caps = vf->driver_caps;
 181         unsigned int i;
 182
 183         for_each_set_bit(i, &caps, ARRAY_SIZE(allowlist_opcodes))
 184                 ice_vc_allowlist_opcodes(vf, allowlist_opcodes[i].opcodes,
 185                                          allowlist_opcodes[i].size);
 186 }