// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
|
/* Copyright (C) 2015-2018 Netronome Systems, Inc. */
|
|
/*
|
* nfp_rtsym.c
|
* Interface for accessing run-time symbol table
|
* Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
|
* Jason McMullan <jason.mcmullan@netronome.com>
|
* Espen Skoglund <espen.skoglund@netronome.com>
|
* Francois H. Theron <francois.theron@netronome.com>
|
*/
|
|
#include <asm/unaligned.h>
|
#include <linux/kernel.h>
|
#include <linux/module.h>
|
#include <linux/slab.h>
|
#include <linux/io-64-nonatomic-hi-lo.h>
|
|
#include "nfp.h"
|
#include "nfp_cpp.h"
|
#include "nfp_nffw.h"
|
#include "nfp6000/nfp6000.h"
|
|
/* These need to match the linker */
|
#define SYM_TGT_LMEM 0
|
#define SYM_TGT_EMU_CACHE 0x17
|
|
struct nfp_rtsym_entry {
|
u8 type;
|
u8 target;
|
u8 island;
|
u8 addr_hi;
|
__le32 addr_lo;
|
__le16 name;
|
u8 menum;
|
u8 size_hi;
|
__le32 size_lo;
|
};
|
|
struct nfp_rtsym_table {
|
struct nfp_cpp *cpp;
|
int num;
|
char *strtab;
|
struct nfp_rtsym symtab[];
|
};
|
|
static int nfp_meid(u8 island_id, u8 menum)
|
{
|
return (island_id & 0x3F) == island_id && menum < 12 ?
|
(island_id << 4) | (menum + 4) : -1;
|
}
|
|
static void
|
nfp_rtsym_sw_entry_init(struct nfp_rtsym_table *cache, u32 strtab_size,
|
struct nfp_rtsym *sw, struct nfp_rtsym_entry *fw)
|
{
|
sw->type = fw->type;
|
sw->name = cache->strtab + le16_to_cpu(fw->name) % strtab_size;
|
sw->addr = ((u64)fw->addr_hi << 32) | le32_to_cpu(fw->addr_lo);
|
sw->size = ((u64)fw->size_hi << 32) | le32_to_cpu(fw->size_lo);
|
|
switch (fw->target) {
|
case SYM_TGT_LMEM:
|
sw->target = NFP_RTSYM_TARGET_LMEM;
|
break;
|
case SYM_TGT_EMU_CACHE:
|
sw->target = NFP_RTSYM_TARGET_EMU_CACHE;
|
break;
|
default:
|
sw->target = fw->target;
|
break;
|
}
|
|
if (fw->menum != 0xff)
|
sw->domain = nfp_meid(fw->island, fw->menum);
|
else if (fw->island != 0xff)
|
sw->domain = fw->island;
|
else
|
sw->domain = -1;
|
}
|
|
struct nfp_rtsym_table *nfp_rtsym_table_read(struct nfp_cpp *cpp)
|
{
|
struct nfp_rtsym_table *rtbl;
|
const struct nfp_mip *mip;
|
|
mip = nfp_mip_open(cpp);
|
rtbl = __nfp_rtsym_table_read(cpp, mip);
|
nfp_mip_close(mip);
|
|
return rtbl;
|
}
|
|
struct nfp_rtsym_table *
|
__nfp_rtsym_table_read(struct nfp_cpp *cpp, const struct nfp_mip *mip)
|
{
|
const u32 dram = NFP_CPP_ID(NFP_CPP_TARGET_MU, NFP_CPP_ACTION_RW, 0) |
|
NFP_ISL_EMEM0;
|
u32 strtab_addr, symtab_addr, strtab_size, symtab_size;
|
struct nfp_rtsym_entry *rtsymtab;
|
struct nfp_rtsym_table *cache;
|
int err, n, size;
|
|
if (!mip)
|
return NULL;
|
|
nfp_mip_strtab(mip, &strtab_addr, &strtab_size);
|
nfp_mip_symtab(mip, &symtab_addr, &symtab_size);
|
|
if (!symtab_size || !strtab_size || symtab_size % sizeof(*rtsymtab))
|
return NULL;
|
|
/* Align to 64 bits */
|
symtab_size = round_up(symtab_size, 8);
|
strtab_size = round_up(strtab_size, 8);
|
|
rtsymtab = kmalloc(symtab_size, GFP_KERNEL);
|
if (!rtsymtab)
|
return NULL;
|
|
size = sizeof(*cache);
|
size += symtab_size / sizeof(*rtsymtab) * sizeof(struct nfp_rtsym);
|
size += strtab_size + 1;
|
cache = kmalloc(size, GFP_KERNEL);
|
if (!cache)
|
goto exit_free_rtsym_raw;
|
|
cache->cpp = cpp;
|
cache->num = symtab_size / sizeof(*rtsymtab);
|
cache->strtab = (void *)&cache->symtab[cache->num];
|
|
err = nfp_cpp_read(cpp, dram, symtab_addr, rtsymtab, symtab_size);
|
if (err != symtab_size)
|
goto exit_free_cache;
|
|
err = nfp_cpp_read(cpp, dram, strtab_addr, cache->strtab, strtab_size);
|
if (err != strtab_size)
|
goto exit_free_cache;
|
cache->strtab[strtab_size] = '\0';
|
|
for (n = 0; n < cache->num; n++)
|
nfp_rtsym_sw_entry_init(cache, strtab_size,
|
&cache->symtab[n], &rtsymtab[n]);
|
|
kfree(rtsymtab);
|
|
return cache;
|
|
exit_free_cache:
|
kfree(cache);
|
exit_free_rtsym_raw:
|
kfree(rtsymtab);
|
return NULL;
|
}
|
|
/**
|
* nfp_rtsym_count() - Get the number of RTSYM descriptors
|
* @rtbl: NFP RTsym table
|
*
|
* Return: Number of RTSYM descriptors
|
*/
|
int nfp_rtsym_count(struct nfp_rtsym_table *rtbl)
|
{
|
if (!rtbl)
|
return -EINVAL;
|
return rtbl->num;
|
}
|
|
/**
|
* nfp_rtsym_get() - Get the Nth RTSYM descriptor
|
* @rtbl: NFP RTsym table
|
* @idx: Index (0-based) of the RTSYM descriptor
|
*
|
* Return: const pointer to a struct nfp_rtsym descriptor, or NULL
|
*/
|
const struct nfp_rtsym *nfp_rtsym_get(struct nfp_rtsym_table *rtbl, int idx)
|
{
|
if (!rtbl)
|
return NULL;
|
if (idx >= rtbl->num)
|
return NULL;
|
|
return &rtbl->symtab[idx];
|
}
|
|
/**
|
* nfp_rtsym_lookup() - Return the RTSYM descriptor for a symbol name
|
* @rtbl: NFP RTsym table
|
* @name: Symbol name
|
*
|
* Return: const pointer to a struct nfp_rtsym descriptor, or NULL
|
*/
|
const struct nfp_rtsym *
|
nfp_rtsym_lookup(struct nfp_rtsym_table *rtbl, const char *name)
|
{
|
int n;
|
|
if (!rtbl)
|
return NULL;
|
|
for (n = 0; n < rtbl->num; n++)
|
if (strcmp(name, rtbl->symtab[n].name) == 0)
|
return &rtbl->symtab[n];
|
|
return NULL;
|
}
|
|
u64 nfp_rtsym_size(const struct nfp_rtsym *sym)
|
{
|
switch (sym->type) {
|
case NFP_RTSYM_TYPE_NONE:
|
pr_err("rtsym '%s': type NONE\n", sym->name);
|
return 0;
|
default:
|
pr_warn("rtsym '%s': unknown type: %d\n", sym->name, sym->type);
|
fallthrough;
|
case NFP_RTSYM_TYPE_OBJECT:
|
case NFP_RTSYM_TYPE_FUNCTION:
|
return sym->size;
|
case NFP_RTSYM_TYPE_ABS:
|
return sizeof(u64);
|
}
|
}
|
|
static int
|
nfp_rtsym_to_dest(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, u32 *cpp_id, u64 *addr)
|
{
|
if (sym->type != NFP_RTSYM_TYPE_OBJECT) {
|
nfp_err(cpp, "rtsym '%s': direct access to non-object rtsym\n",
|
sym->name);
|
return -EINVAL;
|
}
|
|
*addr = sym->addr + off;
|
|
if (sym->target == NFP_RTSYM_TARGET_EMU_CACHE) {
|
int locality_off = nfp_cpp_mu_locality_lsb(cpp);
|
|
*addr &= ~(NFP_MU_ADDR_ACCESS_TYPE_MASK << locality_off);
|
*addr |= NFP_MU_ADDR_ACCESS_TYPE_DIRECT << locality_off;
|
|
*cpp_id = NFP_CPP_ISLAND_ID(NFP_CPP_TARGET_MU, action, token,
|
sym->domain);
|
} else if (sym->target < 0) {
|
nfp_err(cpp, "rtsym '%s': unhandled target encoding: %d\n",
|
sym->name, sym->target);
|
return -EINVAL;
|
} else {
|
*cpp_id = NFP_CPP_ISLAND_ID(sym->target, action, token,
|
sym->domain);
|
}
|
|
return 0;
|
}
|
|
int __nfp_rtsym_read(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, void *buf, size_t len)
|
{
|
u64 sym_size = nfp_rtsym_size(sym);
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
if (off > sym_size) {
|
nfp_err(cpp, "rtsym '%s': read out of bounds: off: %lld + len: %zd > size: %lld\n",
|
sym->name, off, len, sym_size);
|
return -ENXIO;
|
}
|
len = min_t(size_t, len, sym_size - off);
|
|
if (sym->type == NFP_RTSYM_TYPE_ABS) {
|
u8 tmp[8];
|
|
put_unaligned_le64(sym->addr, tmp);
|
memcpy(buf, &tmp[off], len);
|
|
return len;
|
}
|
|
err = nfp_rtsym_to_dest(cpp, sym, action, token, off, &cpp_id, &addr);
|
if (err)
|
return err;
|
|
return nfp_cpp_read(cpp, cpp_id, addr, buf, len);
|
}
|
|
int nfp_rtsym_read(struct nfp_cpp *cpp, const struct nfp_rtsym *sym, u64 off,
|
void *buf, size_t len)
|
{
|
return __nfp_rtsym_read(cpp, sym, NFP_CPP_ACTION_RW, 0, off, buf, len);
|
}
|
|
int __nfp_rtsym_readl(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, u32 *value)
|
{
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
if (off + 4 > nfp_rtsym_size(sym)) {
|
nfp_err(cpp, "rtsym '%s': readl out of bounds: off: %lld + 4 > size: %lld\n",
|
sym->name, off, nfp_rtsym_size(sym));
|
return -ENXIO;
|
}
|
|
err = nfp_rtsym_to_dest(cpp, sym, action, token, off, &cpp_id, &addr);
|
if (err)
|
return err;
|
|
return nfp_cpp_readl(cpp, cpp_id, addr, value);
|
}
|
|
int nfp_rtsym_readl(struct nfp_cpp *cpp, const struct nfp_rtsym *sym, u64 off,
|
u32 *value)
|
{
|
return __nfp_rtsym_readl(cpp, sym, NFP_CPP_ACTION_RW, 0, off, value);
|
}
|
|
int __nfp_rtsym_readq(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, u64 *value)
|
{
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
if (off + 8 > nfp_rtsym_size(sym)) {
|
nfp_err(cpp, "rtsym '%s': readq out of bounds: off: %lld + 8 > size: %lld\n",
|
sym->name, off, nfp_rtsym_size(sym));
|
return -ENXIO;
|
}
|
|
if (sym->type == NFP_RTSYM_TYPE_ABS) {
|
*value = sym->addr;
|
return 0;
|
}
|
|
err = nfp_rtsym_to_dest(cpp, sym, action, token, off, &cpp_id, &addr);
|
if (err)
|
return err;
|
|
return nfp_cpp_readq(cpp, cpp_id, addr, value);
|
}
|
|
int nfp_rtsym_readq(struct nfp_cpp *cpp, const struct nfp_rtsym *sym, u64 off,
|
u64 *value)
|
{
|
return __nfp_rtsym_readq(cpp, sym, NFP_CPP_ACTION_RW, 0, off, value);
|
}
|
|
int __nfp_rtsym_write(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, void *buf, size_t len)
|
{
|
u64 sym_size = nfp_rtsym_size(sym);
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
if (off > sym_size) {
|
nfp_err(cpp, "rtsym '%s': write out of bounds: off: %lld + len: %zd > size: %lld\n",
|
sym->name, off, len, sym_size);
|
return -ENXIO;
|
}
|
len = min_t(size_t, len, sym_size - off);
|
|
err = nfp_rtsym_to_dest(cpp, sym, action, token, off, &cpp_id, &addr);
|
if (err)
|
return err;
|
|
return nfp_cpp_write(cpp, cpp_id, addr, buf, len);
|
}
|
|
int nfp_rtsym_write(struct nfp_cpp *cpp, const struct nfp_rtsym *sym, u64 off,
|
void *buf, size_t len)
|
{
|
return __nfp_rtsym_write(cpp, sym, NFP_CPP_ACTION_RW, 0, off, buf, len);
|
}
|
|
int __nfp_rtsym_writel(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, u32 value)
|
{
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
if (off + 4 > nfp_rtsym_size(sym)) {
|
nfp_err(cpp, "rtsym '%s': writel out of bounds: off: %lld + 4 > size: %lld\n",
|
sym->name, off, nfp_rtsym_size(sym));
|
return -ENXIO;
|
}
|
|
err = nfp_rtsym_to_dest(cpp, sym, action, token, off, &cpp_id, &addr);
|
if (err)
|
return err;
|
|
return nfp_cpp_writel(cpp, cpp_id, addr, value);
|
}
|
|
int nfp_rtsym_writel(struct nfp_cpp *cpp, const struct nfp_rtsym *sym, u64 off,
|
u32 value)
|
{
|
return __nfp_rtsym_writel(cpp, sym, NFP_CPP_ACTION_RW, 0, off, value);
|
}
|
|
int __nfp_rtsym_writeq(struct nfp_cpp *cpp, const struct nfp_rtsym *sym,
|
u8 action, u8 token, u64 off, u64 value)
|
{
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
if (off + 8 > nfp_rtsym_size(sym)) {
|
nfp_err(cpp, "rtsym '%s': writeq out of bounds: off: %lld + 8 > size: %lld\n",
|
sym->name, off, nfp_rtsym_size(sym));
|
return -ENXIO;
|
}
|
|
err = nfp_rtsym_to_dest(cpp, sym, action, token, off, &cpp_id, &addr);
|
if (err)
|
return err;
|
|
return nfp_cpp_writeq(cpp, cpp_id, addr, value);
|
}
|
|
int nfp_rtsym_writeq(struct nfp_cpp *cpp, const struct nfp_rtsym *sym, u64 off,
|
u64 value)
|
{
|
return __nfp_rtsym_writeq(cpp, sym, NFP_CPP_ACTION_RW, 0, off, value);
|
}
|
|
/**
|
* nfp_rtsym_read_le() - Read a simple unsigned scalar value from symbol
|
* @rtbl: NFP RTsym table
|
* @name: Symbol name
|
* @error: Poniter to error code (optional)
|
*
|
* Lookup a symbol, map, read it and return it's value. Value of the symbol
|
* will be interpreted as a simple little-endian unsigned value. Symbol can
|
* be 4 or 8 bytes in size.
|
*
|
* Return: value read, on error sets the error and returns ~0ULL.
|
*/
|
u64 nfp_rtsym_read_le(struct nfp_rtsym_table *rtbl, const char *name,
|
int *error)
|
{
|
const struct nfp_rtsym *sym;
|
u32 val32;
|
u64 val;
|
int err;
|
|
sym = nfp_rtsym_lookup(rtbl, name);
|
if (!sym) {
|
err = -ENOENT;
|
goto exit;
|
}
|
|
switch (nfp_rtsym_size(sym)) {
|
case 4:
|
err = nfp_rtsym_readl(rtbl->cpp, sym, 0, &val32);
|
val = val32;
|
break;
|
case 8:
|
err = nfp_rtsym_readq(rtbl->cpp, sym, 0, &val);
|
break;
|
default:
|
nfp_err(rtbl->cpp,
|
"rtsym '%s': unsupported or non-scalar size: %lld\n",
|
name, nfp_rtsym_size(sym));
|
err = -EINVAL;
|
break;
|
}
|
|
exit:
|
if (error)
|
*error = err;
|
|
if (err)
|
return ~0ULL;
|
return val;
|
}
|
|
/**
|
* nfp_rtsym_write_le() - Write an unsigned scalar value to a symbol
|
* @rtbl: NFP RTsym table
|
* @name: Symbol name
|
* @value: Value to write
|
*
|
* Lookup a symbol and write a value to it. Symbol can be 4 or 8 bytes in size.
|
* If 4 bytes then the lower 32-bits of 'value' are used. Value will be
|
* written as simple little-endian unsigned value.
|
*
|
* Return: 0 on success or error code.
|
*/
|
int nfp_rtsym_write_le(struct nfp_rtsym_table *rtbl, const char *name,
|
u64 value)
|
{
|
const struct nfp_rtsym *sym;
|
int err;
|
|
sym = nfp_rtsym_lookup(rtbl, name);
|
if (!sym)
|
return -ENOENT;
|
|
switch (nfp_rtsym_size(sym)) {
|
case 4:
|
err = nfp_rtsym_writel(rtbl->cpp, sym, 0, value);
|
break;
|
case 8:
|
err = nfp_rtsym_writeq(rtbl->cpp, sym, 0, value);
|
break;
|
default:
|
nfp_err(rtbl->cpp,
|
"rtsym '%s': unsupported or non-scalar size: %lld\n",
|
name, nfp_rtsym_size(sym));
|
err = -EINVAL;
|
break;
|
}
|
|
return err;
|
}
|
|
u8 __iomem *
|
nfp_rtsym_map(struct nfp_rtsym_table *rtbl, const char *name, const char *id,
|
unsigned int min_size, struct nfp_cpp_area **area)
|
{
|
const struct nfp_rtsym *sym;
|
u8 __iomem *mem;
|
u32 cpp_id;
|
u64 addr;
|
int err;
|
|
sym = nfp_rtsym_lookup(rtbl, name);
|
if (!sym)
|
return (u8 __iomem *)ERR_PTR(-ENOENT);
|
|
err = nfp_rtsym_to_dest(rtbl->cpp, sym, NFP_CPP_ACTION_RW, 0, 0,
|
&cpp_id, &addr);
|
if (err) {
|
nfp_err(rtbl->cpp, "rtsym '%s': mapping failed\n", name);
|
return (u8 __iomem *)ERR_PTR(err);
|
}
|
|
if (sym->size < min_size) {
|
nfp_err(rtbl->cpp, "rtsym '%s': too small\n", name);
|
return (u8 __iomem *)ERR_PTR(-EINVAL);
|
}
|
|
mem = nfp_cpp_map_area(rtbl->cpp, id, cpp_id, addr, sym->size, area);
|
if (IS_ERR(mem)) {
|
nfp_err(rtbl->cpp, "rtysm '%s': failed to map: %ld\n",
|
name, PTR_ERR(mem));
|
return mem;
|
}
|
|
return mem;
|
}
|
