drivers/net/bnxt/hcapi/cfa/hcapi_cfa_p4.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019-2021 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include <stdint.h>
   7 #include <stdlib.h>
   8 #include <stdbool.h>
   9 #include <string.h>
  10 #include "lookup3.h"
  11 #include "rand.h"
  12
  13 #include "hcapi_cfa.h"
  14 #include "hcapi_cfa_defs.h"
  15
  16 static uint32_t hcapi_cfa_lkup_lkup3_init_cfg;
  17 static uint32_t hcapi_cfa_lkup_em_seed_mem[HCAPI_CFA_LKUP_SEED_MEM_SIZE];
  18 static bool hcapi_cfa_lkup_init;
  19
  20 static inline uint32_t SWAP_WORDS32(uint32_t val32)
  21 {
  22         return (((val32 & 0x0000ffff) << 16) | ((val32 & 0xffff0000) >> 16));
  23 }
  24
  25 static void hcapi_cfa_seeds_init(void)
  26 {
  27         int i;
  28         uint32_t r;
  29
  30         if (hcapi_cfa_lkup_init)
  31                 return;
  32
  33         hcapi_cfa_lkup_init = true;
  34
  35         /* Initialize the lfsr */
  36         rand_init();
  37
  38         /* RX and TX use the same seed values */
  39         hcapi_cfa_lkup_lkup3_init_cfg = SWAP_WORDS32(rand32());
  40
  41         for (i = 0; i < HCAPI_CFA_LKUP_SEED_MEM_SIZE / 2; i++) {
  42                 r = SWAP_WORDS32(rand32());
  43                 hcapi_cfa_lkup_em_seed_mem[i * 2] = r;
  44                 r = SWAP_WORDS32(rand32());
  45                 hcapi_cfa_lkup_em_seed_mem[i * 2 + 1] = (r & 0x1);
  46         }
  47 }
  48
  49 static uint32_t hcapi_cfa_crc32_hash(uint8_t *key)
  50 {
  51         int i;
  52         uint32_t index;
  53         uint32_t val1, val2;
  54         uint8_t temp[4];
  55         uint8_t *kptr = key;
  56
  57         /* Do byte-wise XOR of the 52-byte HASH key first. */
  58         index = *key;
  59         kptr--;
  60
  61         for (i = CFA_P4_EEM_KEY_MAX_SIZE - 2; i >= 0; i--) {
  62                 index = index ^ *kptr;
  63                 kptr--;
  64         }
  65
  66         /* Get seeds */
  67         val1 = hcapi_cfa_lkup_em_seed_mem[index * 2];
  68         val2 = hcapi_cfa_lkup_em_seed_mem[index * 2 + 1];
  69
  70         temp[3] = (uint8_t)(val1 >> 24);
  71         temp[2] = (uint8_t)(val1 >> 16);
  72         temp[1] = (uint8_t)(val1 >> 8);
  73         temp[0] = (uint8_t)(val1 & 0xff);
  74         val1 = 0;
  75
  76         /* Start with seed */
  77         if (!(val2 & 0x1))
  78                 val1 = hcapi_cfa_crc32i(~val1, temp, 4);
  79
  80         val1 = hcapi_cfa_crc32i(~val1, (key - (CFA_P4_EEM_KEY_MAX_SIZE - 1)),
  81                                 CFA_P4_EEM_KEY_MAX_SIZE);
  82
  83         /* End with seed */
  84         if (val2 & 0x1)
  85                 val1 = hcapi_cfa_crc32i(~val1, temp, 4);
  86
  87         return val1;
  88 }
  89
  90 static uint32_t hcapi_cfa_lookup3_hash(uint8_t *in_key)
  91 {
  92         uint32_t val1;
  93
  94         val1 = hashword(((uint32_t *)in_key) + 1,
  95                         CFA_P4_EEM_KEY_MAX_SIZE / (sizeof(uint32_t)),
  96                         hcapi_cfa_lkup_lkup3_init_cfg);
  97
  98         return val1;
  99 }
 100
 101 uint64_t hcapi_get_table_page(struct hcapi_cfa_em_table *mem, uint32_t page)
 102 {
 103         int level = 0;
 104         uint64_t addr;
 105
 106         if (mem == NULL)
 107                 return 0;
 108
 109         /*
 110          * Use the level according to the num_level of page table
 111          */
 112         level = mem->num_lvl - 1;
 113
 114         addr = (uint64_t)mem->pg_tbl[level].pg_va_tbl[page];
 115
 116         return addr;
 117 }
 118
 119 /** Approximation of HCAPI hcapi_cfa_key_hash()
 120  *
 121  * Return:
 122  *
 123  */
 124 uint64_t hcapi_cfa_p4_key_hash(uint64_t *key_data,
 125                                uint16_t bitlen)
 126 {
 127         uint32_t key0_hash;
 128         uint32_t key1_hash;
 129
 130         /*
 131          * Init the seeds if needed
 132          */
 133         if (!hcapi_cfa_lkup_init)
 134                 hcapi_cfa_seeds_init();
 135
 136         key0_hash =
 137                 hcapi_cfa_crc32_hash(((uint8_t *)key_data) + (bitlen / 8) - 1);
 138
 139         key1_hash = hcapi_cfa_lookup3_hash((uint8_t *)key_data);
 140
 141         return ((uint64_t)key0_hash) << 32 | (uint64_t)key1_hash;
 142 }
 143
 144 static int hcapi_cfa_p4_key_hw_op_put(struct hcapi_cfa_hwop *op,
 145                                       struct hcapi_cfa_key_data *key_obj)
 146 {
 147         int rc = 0;
 148
 149         memcpy((uint8_t *)(uintptr_t)op->hw.base_addr + key_obj->offset,
 150                key_obj->data, key_obj->size);
 151
 152         return rc;
 153 }
 154
 155 static int hcapi_cfa_p4_key_hw_op_get(struct hcapi_cfa_hwop *op,
 156                                       struct hcapi_cfa_key_data *key_obj)
 157 {
 158         int rc = 0;
 159
 160         memcpy(key_obj->data,
 161                (uint8_t *)(uintptr_t)op->hw.base_addr + key_obj->offset,
 162                key_obj->size);
 163
 164         return rc;
 165 }
 166
 167 static int hcapi_cfa_p4_key_hw_op_add(struct hcapi_cfa_hwop *op,
 168                                       struct hcapi_cfa_key_data *key_obj)
 169 {
 170         int rc = 0;
 171         struct cfa_p4_eem_64b_entry table_entry;
 172
 173         /*
 174          * Is entry free?
 175          */
 176         memcpy(&table_entry,
 177                (uint8_t *)(uintptr_t)op->hw.base_addr + key_obj->offset,
 178                key_obj->size);
 179
 180         /*
 181          * If this is entry is valid then report failure
 182          */
 183         if (table_entry.hdr.word1 & (1 << CFA_P4_EEM_ENTRY_VALID_SHIFT))
 184                 return -1;
 185
 186         memcpy((uint8_t *)(uintptr_t)op->hw.base_addr + key_obj->offset,
 187                key_obj->data, key_obj->size);
 188
 189         return rc;
 190 }
 191
 192 static int hcapi_cfa_p4_key_hw_op_del(struct hcapi_cfa_hwop *op,
 193                                       struct hcapi_cfa_key_data *key_obj)
 194 {
 195         int rc = 0;
 196         struct cfa_p4_eem_64b_entry table_entry;
 197
 198         /*
 199          * Read entry
 200          */
 201         memcpy(&table_entry,
 202                (uint8_t *)(uintptr_t)op->hw.base_addr + key_obj->offset,
 203                key_obj->size);
 204
 205         /*
 206          * If this is not a valid entry then report failure.
 207          */
 208         if (table_entry.hdr.word1 & (1 << CFA_P4_EEM_ENTRY_VALID_SHIFT)) {
 209                 /*
 210                  * If a key has been provided then verify the key matches
 211                  * before deleting the entry.
 212                  */
 213                 if (key_obj->data != NULL) {
 214                         if (memcmp(&table_entry, key_obj->data,
 215                                    key_obj->size) != 0)
 216                                 return -1;
 217                 }
 218         } else {
 219                 return -1;
 220         }
 221
 222         /*
 223          * Delete entry
 224          */
 225         memset((uint8_t *)(uintptr_t)op->hw.base_addr + key_obj->offset, 0, key_obj->size);
 226
 227         return rc;
 228 }
 229
 230 /** Approximation of hcapi_cfa_key_hw_op()
 231  *
 232  *
 233  */
 234 static int hcapi_cfa_p4_key_hw_op(struct hcapi_cfa_hwop *op,
 235                                   struct hcapi_cfa_key_tbl *key_tbl,
 236                                   struct hcapi_cfa_key_data *key_obj,
 237                                   struct hcapi_cfa_key_loc *key_loc)
 238 {
 239         int rc = 0;
 240         struct hcapi_cfa_em_table *em_tbl;
 241         uint32_t page;
 242
 243         if (op == NULL || key_tbl == NULL || key_obj == NULL || key_loc == NULL)
 244                 return -1;
 245
 246         page = key_obj->offset / key_tbl->page_size;
 247         em_tbl = (struct hcapi_cfa_em_table *)key_tbl->base0;
 248         op->hw.base_addr = hcapi_get_table_page(em_tbl, page);
 249         /* Offset is adjusted to be the offset into the page */
 250         key_obj->offset = key_obj->offset % key_tbl->page_size;
 251
 252         if (op->hw.base_addr == 0)
 253                 return -1;
 254
 255         switch (op->opcode) {
 256         case HCAPI_CFA_HWOPS_PUT: /**< Write to HW operation */
 257                 rc = hcapi_cfa_p4_key_hw_op_put(op, key_obj);
 258                 break;
 259         case HCAPI_CFA_HWOPS_GET: /**< Read from HW operation */
 260                 rc = hcapi_cfa_p4_key_hw_op_get(op, key_obj);
 261                 break;
 262         case HCAPI_CFA_HWOPS_ADD:
 263                 /**< For operations which require more then simple
 264                  * writes to HW, this operation is used.  The
 265                  * distinction with this operation when compared
 266                  * to the PUT ops is that this operation is used
 267                  * in conjunction with the HCAPI_CFA_HWOPS_DEL
 268                  * op to remove the operations issued by the
 269                  * ADD OP.
 270                  */
 271
 272                 rc = hcapi_cfa_p4_key_hw_op_add(op, key_obj);
 273
 274                 break;
 275         case HCAPI_CFA_HWOPS_DEL:
 276                 rc = hcapi_cfa_p4_key_hw_op_del(op, key_obj);
 277                 break;
 278         default:
 279                 rc = -1;
 280                 break;
 281         }
 282
 283         return rc;
 284 }
 285
 286 const struct hcapi_cfa_devops cfa_p4_devops = {
 287         .hcapi_cfa_key_hash = hcapi_cfa_p4_key_hash,
 288         .hcapi_cfa_key_hw_op = hcapi_cfa_p4_key_hw_op,
 289 };