drivers/net/nfp/nfpcore/nfp_rtsym.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Netronome Systems, Inc.
   3  * All rights reserved.
   4  */
   5
   6 /*
   7  * nfp_rtsym.c
   8  * Interface for accessing run-time symbol table
   9  */
  10
  11 #include <stdio.h>
  12 #include <rte_byteorder.h>
  13 #include "nfp_cpp.h"
  14 #include "nfp_mip.h"
  15 #include "nfp_rtsym.h"
  16 #include "nfp6000/nfp6000.h"
  17
  18 /* These need to match the linker */
  19 #define SYM_TGT_LMEM            0
  20 #define SYM_TGT_EMU_CACHE       0x17
  21
  22 struct nfp_rtsym_entry {
  23         uint8_t type;
  24         uint8_t target;
  25         uint8_t island;
  26         uint8_t addr_hi;
  27         uint32_t addr_lo;
  28         uint16_t name;
  29         uint8_t menum;
  30         uint8_t size_hi;
  31         uint32_t size_lo;
  32 };
  33
  34 struct nfp_rtsym_table {
  35         struct nfp_cpp *cpp;
  36         int num;
  37         char *strtab;
  38         struct nfp_rtsym symtab[];
  39 };
  40
  41 static int
  42 nfp_meid(uint8_t island_id, uint8_t menum)
  43 {
  44         return (island_id & 0x3F) == island_id && menum < 12 ?
  45                 (island_id << 4) | (menum + 4) : -1;
  46 }
  47
  48 static void
  49 nfp_rtsym_sw_entry_init(struct nfp_rtsym_table *cache, uint32_t strtab_size,
  50                         struct nfp_rtsym *sw, struct nfp_rtsym_entry *fw)
  51 {
  52         sw->type = fw->type;
  53         sw->name = cache->strtab + rte_le_to_cpu_16(fw->name) % strtab_size;
  54         sw->addr = ((uint64_t)fw->addr_hi << 32) |
  55                    rte_le_to_cpu_32(fw->addr_lo);
  56         sw->size = ((uint64_t)fw->size_hi << 32) |
  57                    rte_le_to_cpu_32(fw->size_lo);
  58
  59 #ifdef DEBUG
  60         printf("rtsym_entry_init\n");
  61         printf("\tname=%s, addr=%" PRIx64 ", size=%" PRIu64 ",target=%d\n",
  62                 sw->name, sw->addr, sw->size, sw->target);
  63 #endif
  64         switch (fw->target) {
  65         case SYM_TGT_LMEM:
  66                 sw->target = NFP_RTSYM_TARGET_LMEM;
  67                 break;
  68         case SYM_TGT_EMU_CACHE:
  69                 sw->target = NFP_RTSYM_TARGET_EMU_CACHE;
  70                 break;
  71         default:
  72                 sw->target = fw->target;
  73                 break;
  74         }
  75
  76         if (fw->menum != 0xff)
  77                 sw->domain = nfp_meid(fw->island, fw->menum);
  78         else if (fw->island != 0xff)
  79                 sw->domain = fw->island;
  80         else
  81                 sw->domain = -1;
  82 }
  83
  84 struct nfp_rtsym_table *
  85 nfp_rtsym_table_read(struct nfp_cpp *cpp)
  86 {
  87         struct nfp_rtsym_table *rtbl;
  88         struct nfp_mip *mip;
  89
  90         mip = nfp_mip_open(cpp);
  91         rtbl = __nfp_rtsym_table_read(cpp, mip);
  92         nfp_mip_close(mip);
  93
  94         return rtbl;
  95 }
  96
  97 /*
  98  * This looks more complex than it should be. But we need to get the type for
  99  * the ~ right in round_down (it needs to be as wide as the result!), and we
 100  * want to evaluate the macro arguments just once each.
 101  */
 102 #define __round_mask(x, y) ((__typeof__(x))((y) - 1))
 103
 104 #define round_up(x, y) \
 105         (__extension__ ({ \
 106                 typeof(x) _x = (x); \
 107                 ((((_x) - 1) | __round_mask(_x, y)) + 1); \
 108         }))
 109
 110 #define round_down(x, y) \
 111         (__extension__ ({ \
 112                 typeof(x) _x = (x); \
 113                 ((_x) & ~__round_mask(_x, y)); \
 114         }))
 115
 116 struct nfp_rtsym_table *
 117 __nfp_rtsym_table_read(struct nfp_cpp *cpp, const struct nfp_mip *mip)
 118 {
 119         uint32_t strtab_addr, symtab_addr, strtab_size, symtab_size;
 120         struct nfp_rtsym_entry *rtsymtab;
 121         struct nfp_rtsym_table *cache;
 122         const uint32_t dram =
 123                 NFP_CPP_ID(NFP_CPP_TARGET_MU, NFP_CPP_ACTION_RW, 0) |
 124                 NFP_ISL_EMEM0;
 125         int err, n, size;
 126
 127         if (!mip)
 128                 return NULL;
 129
 130         nfp_mip_strtab(mip, &strtab_addr, &strtab_size);
 131         nfp_mip_symtab(mip, &symtab_addr, &symtab_size);
 132
 133         if (!symtab_size || !strtab_size || symtab_size % sizeof(*rtsymtab))
 134                 return NULL;
 135
 136         /* Align to 64 bits */
 137         symtab_size = round_up(symtab_size, 8);
 138         strtab_size = round_up(strtab_size, 8);
 139
 140         rtsymtab = malloc(symtab_size);
 141         if (!rtsymtab)
 142                 return NULL;
 143
 144         size = sizeof(*cache);
 145         size += symtab_size / sizeof(*rtsymtab) * sizeof(struct nfp_rtsym);
 146         size += strtab_size + 1;
 147         cache = malloc(size);
 148         if (!cache)
 149                 goto exit_free_rtsym_raw;
 150
 151         cache->cpp = cpp;
 152         cache->num = symtab_size / sizeof(*rtsymtab);
 153         cache->strtab = (void *)&cache->symtab[cache->num];
 154
 155         err = nfp_cpp_read(cpp, dram, symtab_addr, rtsymtab, symtab_size);
 156         if (err != (int)symtab_size)
 157                 goto exit_free_cache;
 158
 159         err = nfp_cpp_read(cpp, dram, strtab_addr, cache->strtab, strtab_size);
 160         if (err != (int)strtab_size)
 161                 goto exit_free_cache;
 162         cache->strtab[strtab_size] = '\0';
 163
 164         for (n = 0; n < cache->num; n++)
 165                 nfp_rtsym_sw_entry_init(cache, strtab_size,
 166                                         &cache->symtab[n], &rtsymtab[n]);
 167
 168         free(rtsymtab);
 169
 170         return cache;
 171
 172 exit_free_cache:
 173         free(cache);
 174 exit_free_rtsym_raw:
 175         free(rtsymtab);
 176         return NULL;
 177 }
 178
 179 /*
 180  * nfp_rtsym_count() - Get the number of RTSYM descriptors
 181  * @rtbl:       NFP RTsym table
 182  *
 183  * Return: Number of RTSYM descriptors
 184  */
 185 int
 186 nfp_rtsym_count(struct nfp_rtsym_table *rtbl)
 187 {
 188         if (!rtbl)
 189                 return -EINVAL;
 190
 191         return rtbl->num;
 192 }
 193
 194 /*
 195  * nfp_rtsym_get() - Get the Nth RTSYM descriptor
 196  * @rtbl:       NFP RTsym table
 197  * @idx:        Index (0-based) of the RTSYM descriptor
 198  *
 199  * Return: const pointer to a struct nfp_rtsym descriptor, or NULL
 200  */
 201 const struct nfp_rtsym *
 202 nfp_rtsym_get(struct nfp_rtsym_table *rtbl, int idx)
 203 {
 204         if (!rtbl)
 205                 return NULL;
 206
 207         if (idx >= rtbl->num)
 208                 return NULL;
 209
 210         return &rtbl->symtab[idx];
 211 }
 212
 213 /*
 214  * nfp_rtsym_lookup() - Return the RTSYM descriptor for a symbol name
 215  * @rtbl:       NFP RTsym table
 216  * @name:       Symbol name
 217  *
 218  * Return: const pointer to a struct nfp_rtsym descriptor, or NULL
 219  */
 220 const struct nfp_rtsym *
 221 nfp_rtsym_lookup(struct nfp_rtsym_table *rtbl, const char *name)
 222 {
 223         int n;
 224
 225         if (!rtbl)
 226                 return NULL;
 227
 228         for (n = 0; n < rtbl->num; n++)
 229                 if (strcmp(name, rtbl->symtab[n].name) == 0)
 230                         return &rtbl->symtab[n];
 231
 232         return NULL;
 233 }
 234
 235 /*
 236  * nfp_rtsym_read_le() - Read a simple unsigned scalar value from symbol
 237  * @rtbl:       NFP RTsym table
 238  * @name:       Symbol name
 239  * @error:      Poniter to error code (optional)
 240  *
 241  * Lookup a symbol, map, read it and return it's value. Value of the symbol
 242  * will be interpreted as a simple little-endian unsigned value. Symbol can
 243  * be 4 or 8 bytes in size.
 244  *
 245  * Return: value read, on error sets the error and returns ~0ULL.
 246  */
 247 uint64_t
 248 nfp_rtsym_read_le(struct nfp_rtsym_table *rtbl, const char *name, int *error)
 249 {
 250         const struct nfp_rtsym *sym;
 251         uint32_t val32, id;
 252         uint64_t val;
 253         int err;
 254
 255         sym = nfp_rtsym_lookup(rtbl, name);
 256         if (!sym) {
 257                 err = -ENOENT;
 258                 goto exit;
 259         }
 260
 261         id = NFP_CPP_ISLAND_ID(sym->target, NFP_CPP_ACTION_RW, 0, sym->domain);
 262
 263 #ifdef DEBUG
 264         printf("Reading symbol %s with size %" PRIu64 " at %" PRIx64 "\n",
 265                 name, sym->size, sym->addr);
 266 #endif
 267         switch (sym->size) {
 268         case 4:
 269                 err = nfp_cpp_readl(rtbl->cpp, id, sym->addr, &val32);
 270                 val = val32;
 271                 break;
 272         case 8:
 273                 err = nfp_cpp_readq(rtbl->cpp, id, sym->addr, &val);
 274                 break;
 275         default:
 276                 printf("rtsym '%s' unsupported size: %" PRId64 "\n",
 277                         name, sym->size);
 278                 err = -EINVAL;
 279                 break;
 280         }
 281
 282         if (err)
 283                 err = -EIO;
 284 exit:
 285         if (error)
 286                 *error = err;
 287
 288         if (err)
 289                 return ~0ULL;
 290
 291         return val;
 292 }
 293
 294 uint8_t *
 295 nfp_rtsym_map(struct nfp_rtsym_table *rtbl, const char *name,
 296               unsigned int min_size, struct nfp_cpp_area **area)
 297 {
 298         const struct nfp_rtsym *sym;
 299         uint8_t *mem;
 300
 301 #ifdef DEBUG
 302         printf("mapping symbol %s\n", name);
 303 #endif
 304         sym = nfp_rtsym_lookup(rtbl, name);
 305         if (!sym) {
 306                 printf("symbol lookup fails for %s\n", name);
 307                 return NULL;
 308         }
 309
 310         if (sym->size < min_size) {
 311                 printf("Symbol %s too small (%" PRIu64 " < %u)\n", name,
 312                         sym->size, min_size);
 313                 return NULL;
 314         }
 315
 316         mem = nfp_cpp_map_area(rtbl->cpp, sym->domain, sym->target, sym->addr,
 317                                sym->size, area);
 318         if (!mem) {
 319                 printf("Failed to map symbol %s\n", name);
 320                 return NULL;
 321         }
 322 #ifdef DEBUG
 323         printf("symbol %s with address %p\n", name, mem);
 324 #endif
 325
 326         return mem;
 327 }