drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_keys.h

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxsw/core_acl_flex_keys.h
   3  * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2017 Jiri Pirko <jiri@mellanox.com>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  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  * 3. Neither the names of the copyright holders nor the names of its
  15  *    contributors may be used to endorse or promote products derived from
  16  *    this software without specific prior written permission.
  17  *
  18  * Alternatively, this software may be distributed under the terms of the
  19  * GNU General Public License ("GPL") version 2 as published by the Free
  20  * Software Foundation.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #ifndef _MLXSW_CORE_ACL_FLEX_KEYS_H
  36 #define _MLXSW_CORE_ACL_FLEX_KEYS_H
  37
  38 #include <linux/types.h>
  39 #include <linux/bitmap.h>
  40
  41 #include "item.h"
  42
  43 enum mlxsw_afk_element {
  44         MLXSW_AFK_ELEMENT_SRC_SYS_PORT,
  45         MLXSW_AFK_ELEMENT_DMAC,
  46         MLXSW_AFK_ELEMENT_SMAC,
  47         MLXSW_AFK_ELEMENT_ETHERTYPE,
  48         MLXSW_AFK_ELEMENT_IP_PROTO,
  49         MLXSW_AFK_ELEMENT_SRC_IP4,
  50         MLXSW_AFK_ELEMENT_DST_IP4,
  51         MLXSW_AFK_ELEMENT_SRC_IP6_HI,
  52         MLXSW_AFK_ELEMENT_SRC_IP6_LO,
  53         MLXSW_AFK_ELEMENT_DST_IP6_HI,
  54         MLXSW_AFK_ELEMENT_DST_IP6_LO,
  55         MLXSW_AFK_ELEMENT_DST_L4_PORT,
  56         MLXSW_AFK_ELEMENT_SRC_L4_PORT,
  57         MLXSW_AFK_ELEMENT_VID,
  58         MLXSW_AFK_ELEMENT_PCP,
  59         MLXSW_AFK_ELEMENT_TCP_FLAGS,
  60         MLXSW_AFK_ELEMENT_MAX,
  61 };
  62
  63 enum mlxsw_afk_element_type {
  64         MLXSW_AFK_ELEMENT_TYPE_U32,
  65         MLXSW_AFK_ELEMENT_TYPE_BUF,
  66 };
  67
  68 struct mlxsw_afk_element_info {
  69         enum mlxsw_afk_element element; /* element ID */
  70         enum mlxsw_afk_element_type type;
  71         struct mlxsw_item item; /* element geometry in internal storage */
  72 };
  73
  74 #define MLXSW_AFK_ELEMENT_INFO(_type, _element, _offset, _shift, _size)         \
  75         [MLXSW_AFK_ELEMENT_##_element] = {                                      \
  76                 .element = MLXSW_AFK_ELEMENT_##_element,                        \
  77                 .type = _type,                                                  \
  78                 .item = {                                                       \
  79                         .offset = _offset,                                      \
  80                         .shift = _shift,                                        \
  81                         .size = {.bits = _size},                                \
  82                         .name = #_element,                                      \
  83                 },                                                              \
  84         }
  85
  86 #define MLXSW_AFK_ELEMENT_INFO_U32(_element, _offset, _shift, _size)            \
  87         MLXSW_AFK_ELEMENT_INFO(MLXSW_AFK_ELEMENT_TYPE_U32,                      \
  88                                _element, _offset, _shift, _size)
  89
  90 #define MLXSW_AFK_ELEMENT_INFO_BUF(_element, _offset, _size)                    \
  91         MLXSW_AFK_ELEMENT_INFO(MLXSW_AFK_ELEMENT_TYPE_BUF,                      \
  92                                _element, _offset, 0, _size)
  93
  94 /* For the purpose of the driver, define an internal storage scratchpad
  95  * that will be used to store key/mask values. For each defined element type
  96  * define an internal storage geometry.
  97  */
  98 static const struct mlxsw_afk_element_info mlxsw_afk_element_infos[] = {
  99         MLXSW_AFK_ELEMENT_INFO_U32(SRC_SYS_PORT, 0x00, 16, 16),
 100         MLXSW_AFK_ELEMENT_INFO_BUF(DMAC, 0x04, 6),
 101         MLXSW_AFK_ELEMENT_INFO_BUF(SMAC, 0x0A, 6),
 102         MLXSW_AFK_ELEMENT_INFO_U32(ETHERTYPE, 0x00, 0, 16),
 103         MLXSW_AFK_ELEMENT_INFO_U32(IP_PROTO, 0x10, 0, 8),
 104         MLXSW_AFK_ELEMENT_INFO_U32(VID, 0x10, 8, 12),
 105         MLXSW_AFK_ELEMENT_INFO_U32(PCP, 0x10, 20, 3),
 106         MLXSW_AFK_ELEMENT_INFO_U32(TCP_FLAGS, 0x10, 23, 9),
 107         MLXSW_AFK_ELEMENT_INFO_U32(SRC_IP4, 0x18, 0, 32),
 108         MLXSW_AFK_ELEMENT_INFO_U32(DST_IP4, 0x1C, 0, 32),
 109         MLXSW_AFK_ELEMENT_INFO_BUF(SRC_IP6_HI, 0x18, 8),
 110         MLXSW_AFK_ELEMENT_INFO_BUF(SRC_IP6_LO, 0x20, 8),
 111         MLXSW_AFK_ELEMENT_INFO_BUF(DST_IP6_HI, 0x28, 8),
 112         MLXSW_AFK_ELEMENT_INFO_BUF(DST_IP6_LO, 0x30, 8),
 113         MLXSW_AFK_ELEMENT_INFO_U32(DST_L4_PORT, 0x14, 0, 16),
 114         MLXSW_AFK_ELEMENT_INFO_U32(SRC_L4_PORT, 0x14, 16, 16),
 115 };
 116
 117 #define MLXSW_AFK_ELEMENT_STORAGE_SIZE 0x38
 118
 119 struct mlxsw_afk_element_inst { /* element instance in actual block */
 120         const struct mlxsw_afk_element_info *info;
 121         enum mlxsw_afk_element_type type;
 122         struct mlxsw_item item; /* element geometry in block */
 123 };
 124
 125 #define MLXSW_AFK_ELEMENT_INST(_type, _element, _offset, _shift, _size)         \
 126         {                                                                       \
 127                 .info = &mlxsw_afk_element_infos[MLXSW_AFK_ELEMENT_##_element], \
 128                 .type = _type,                                                  \
 129                 .item = {                                                       \
 130                         .offset = _offset,                                      \
 131                         .shift = _shift,                                        \
 132                         .size = {.bits = _size},                                \
 133                         .name = #_element,                                      \
 134                 },                                                              \
 135         }
 136
 137 #define MLXSW_AFK_ELEMENT_INST_U32(_element, _offset, _shift, _size)            \
 138         MLXSW_AFK_ELEMENT_INST(MLXSW_AFK_ELEMENT_TYPE_U32,                      \
 139                                _element, _offset, _shift, _size)
 140
 141 #define MLXSW_AFK_ELEMENT_INST_BUF(_element, _offset, _size)                    \
 142         MLXSW_AFK_ELEMENT_INST(MLXSW_AFK_ELEMENT_TYPE_BUF,                      \
 143                                _element, _offset, 0, _size)
 144
 145 struct mlxsw_afk_block {
 146         u16 encoding; /* block ID */
 147         struct mlxsw_afk_element_inst *instances;
 148         unsigned int instances_count;
 149 };
 150
 151 #define MLXSW_AFK_BLOCK(_encoding, _instances)                                  \
 152         {                                                                       \
 153                 .encoding = _encoding,                                          \
 154                 .instances = _instances,                                        \
 155                 .instances_count = ARRAY_SIZE(_instances),                      \
 156         }
 157
 158 struct mlxsw_afk_element_usage {
 159         DECLARE_BITMAP(usage, MLXSW_AFK_ELEMENT_MAX);
 160 };
 161
 162 #define mlxsw_afk_element_usage_for_each(element, elusage)                      \
 163         for_each_set_bit(element, (elusage)->usage, MLXSW_AFK_ELEMENT_MAX)
 164
 165 static inline void
 166 mlxsw_afk_element_usage_add(struct mlxsw_afk_element_usage *elusage,
 167                             enum mlxsw_afk_element element)
 168 {
 169         __set_bit(element, elusage->usage);
 170 }
 171
 172 static inline void
 173 mlxsw_afk_element_usage_zero(struct mlxsw_afk_element_usage *elusage)
 174 {
 175         bitmap_zero(elusage->usage, MLXSW_AFK_ELEMENT_MAX);
 176 }
 177
 178 static inline void
 179 mlxsw_afk_element_usage_fill(struct mlxsw_afk_element_usage *elusage,
 180                              const enum mlxsw_afk_element *elements,
 181                              unsigned int elements_count)
 182 {
 183         int i;
 184
 185         mlxsw_afk_element_usage_zero(elusage);
 186         for (i = 0; i < elements_count; i++)
 187                 mlxsw_afk_element_usage_add(elusage, elements[i]);
 188 }
 189
 190 static inline bool
 191 mlxsw_afk_element_usage_subset(struct mlxsw_afk_element_usage *elusage_small,
 192                                struct mlxsw_afk_element_usage *elusage_big)
 193 {
 194         int i;
 195
 196         for (i = 0; i < MLXSW_AFK_ELEMENT_MAX; i++)
 197                 if (test_bit(i, elusage_small->usage) &&
 198                     !test_bit(i, elusage_big->usage))
 199                         return false;
 200         return true;
 201 }
 202
 203 struct mlxsw_afk;
 204
 205 struct mlxsw_afk *mlxsw_afk_create(unsigned int max_blocks,
 206                                    const struct mlxsw_afk_block *blocks,
 207                                    unsigned int blocks_count);
 208 void mlxsw_afk_destroy(struct mlxsw_afk *mlxsw_afk);
 209
 210 struct mlxsw_afk_key_info;
 211
 212 struct mlxsw_afk_key_info *
 213 mlxsw_afk_key_info_get(struct mlxsw_afk *mlxsw_afk,
 214                        struct mlxsw_afk_element_usage *elusage);
 215 void mlxsw_afk_key_info_put(struct mlxsw_afk_key_info *key_info);
 216 bool mlxsw_afk_key_info_subset(struct mlxsw_afk_key_info *key_info,
 217                                struct mlxsw_afk_element_usage *elusage);
 218
 219 u16
 220 mlxsw_afk_key_info_block_encoding_get(const struct mlxsw_afk_key_info *key_info,
 221                                       int block_index);
 222 unsigned int
 223 mlxsw_afk_key_info_blocks_count_get(const struct mlxsw_afk_key_info *key_info);
 224
 225 struct mlxsw_afk_element_values {
 226         struct mlxsw_afk_element_usage elusage;
 227         struct {
 228                 char key[MLXSW_AFK_ELEMENT_STORAGE_SIZE];
 229                 char mask[MLXSW_AFK_ELEMENT_STORAGE_SIZE];
 230         } storage;
 231 };
 232
 233 void mlxsw_afk_values_add_u32(struct mlxsw_afk_element_values *values,
 234                               enum mlxsw_afk_element element,
 235                               u32 key_value, u32 mask_value);
 236 void mlxsw_afk_values_add_buf(struct mlxsw_afk_element_values *values,
 237                               enum mlxsw_afk_element element,
 238                               const char *key_value, const char *mask_value,
 239                               unsigned int len);
 240 void mlxsw_afk_encode(struct mlxsw_afk_key_info *key_info,
 241                       struct mlxsw_afk_element_values *values,
 242                       char *key, char *mask);
 243
 244 #endif