| // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) |
| /* Copyright (C) 2015-2017 Netronome Systems, Inc. */ |
| |
| /* Parse the hwinfo table that the ARM firmware builds in the ARM scratch SRAM |
| * after chip reset. |
| * |
| * Examples of the fields: |
| * me.count = 40 |
| * me.mask = 0x7f_ffff_ffff |
| * |
| * me.count is the total number of MEs on the system. |
| * me.mask is the bitmask of MEs that are available for application usage. |
| * |
| * (ie, in this example, ME 39 has been reserved by boardconfig.) |
| */ |
| |
| #include <asm/byteorder.h> |
| #include <asm/unaligned.h> |
| #include <linux/delay.h> |
| #include <linux/log2.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| |
| #define NFP_SUBSYS "nfp_hwinfo" |
| |
| #include "crc32.h" |
| #include "nfp.h" |
| #include "nfp_cpp.h" |
| #include "nfp6000/nfp6000.h" |
| |
| #define HWINFO_SIZE_MIN 0x100 |
| #define HWINFO_WAIT 20 /* seconds */ |
| |
| /* The Hardware Info Table defines the properties of the system. |
| * |
| * HWInfo v1 Table (fixed size) |
| * |
| * 0x0000: u32 version Hardware Info Table version (1.0) |
| * 0x0004: u32 size Total size of the table, including |
| * the CRC32 (IEEE 802.3) |
| * 0x0008: u32 jumptab Offset of key/value table |
| * 0x000c: u32 keys Total number of keys in the key/value table |
| * NNNNNN: Key/value jump table and string data |
| * (size - 4): u32 crc32 CRC32 (same as IEEE 802.3, POSIX csum, etc) |
| * CRC32("",0) = ~0, CRC32("a",1) = 0x48C279FE |
| * |
| * HWInfo v2 Table (variable size) |
| * |
| * 0x0000: u32 version Hardware Info Table version (2.0) |
| * 0x0004: u32 size Current size of the data area, excluding CRC32 |
| * 0x0008: u32 limit Maximum size of the table |
| * 0x000c: u32 reserved Unused, set to zero |
| * NNNNNN: Key/value data |
| * (size - 4): u32 crc32 CRC32 (same as IEEE 802.3, POSIX csum, etc) |
| * CRC32("",0) = ~0, CRC32("a",1) = 0x48C279FE |
| * |
| * If the HWInfo table is in the process of being updated, the low bit |
| * of version will be set. |
| * |
| * HWInfo v1 Key/Value Table |
| * ------------------------- |
| * |
| * The key/value table is a set of offsets to ASCIIZ strings which have |
| * been strcmp(3) sorted (yes, please use bsearch(3) on the table). |
| * |
| * All keys are guaranteed to be unique. |
| * |
| * N+0: u32 key_1 Offset to the first key |
| * N+4: u32 val_1 Offset to the first value |
| * N+8: u32 key_2 Offset to the second key |
| * N+c: u32 val_2 Offset to the second value |
| * ... |
| * |
| * HWInfo v2 Key/Value Table |
| * ------------------------- |
| * |
| * Packed UTF8Z strings, ie 'key1\000value1\000key2\000value2\000' |
| * |
| * Unsorted. |
| */ |
| |
| #define NFP_HWINFO_VERSION_1 ('H' << 24 | 'I' << 16 | 1 << 8 | 0 << 1 | 0) |
| #define NFP_HWINFO_VERSION_2 ('H' << 24 | 'I' << 16 | 2 << 8 | 0 << 1 | 0) |
| #define NFP_HWINFO_VERSION_UPDATING BIT(0) |
| |
| struct nfp_hwinfo { |
| u8 start[0]; |
| |
| __le32 version; |
| __le32 size; |
| |
| /* v2 specific fields */ |
| __le32 limit; |
| __le32 resv; |
| |
| char data[]; |
| }; |
| |
| static bool nfp_hwinfo_is_updating(struct nfp_hwinfo *hwinfo) |
| { |
| return le32_to_cpu(hwinfo->version) & NFP_HWINFO_VERSION_UPDATING; |
| } |
| |
| static int |
| hwinfo_db_walk(struct nfp_cpp *cpp, struct nfp_hwinfo *hwinfo, u32 size) |
| { |
| const char *key, *val, *end = hwinfo->data + size; |
| |
| for (key = hwinfo->data; *key && key < end; |
| key = val + strlen(val) + 1) { |
| |
| val = key + strlen(key) + 1; |
| if (val >= end) { |
| nfp_warn(cpp, "Bad HWINFO - overflowing key\n"); |
| return -EINVAL; |
| } |
| |
| if (val + strlen(val) + 1 > end) { |
| nfp_warn(cpp, "Bad HWINFO - overflowing value\n"); |
| return -EINVAL; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int |
| hwinfo_db_validate(struct nfp_cpp *cpp, struct nfp_hwinfo *db, u32 len) |
| { |
| u32 size, crc; |
| |
| size = le32_to_cpu(db->size); |
| if (size > len) { |
| nfp_err(cpp, "Unsupported hwinfo size %u > %u\n", size, len); |
| return -EINVAL; |
| } |
| |
| size -= sizeof(u32); |
| crc = crc32_posix(db, size); |
| if (crc != get_unaligned_le32(db->start + size)) { |
| nfp_err(cpp, "Corrupt hwinfo table (CRC mismatch), calculated 0x%x, expected 0x%x\n", |
| crc, get_unaligned_le32(db->start + size)); |
| |
| return -EINVAL; |
| } |
| |
| return hwinfo_db_walk(cpp, db, size); |
| } |
| |
| static struct nfp_hwinfo * |
| hwinfo_try_fetch(struct nfp_cpp *cpp, size_t *cpp_size) |
| { |
| struct nfp_hwinfo *header; |
| struct nfp_resource *res; |
| u64 cpp_addr; |
| u32 cpp_id; |
| int err; |
| u8 *db; |
| |
| res = nfp_resource_acquire(cpp, NFP_RESOURCE_NFP_HWINFO); |
| if (!IS_ERR(res)) { |
| cpp_id = nfp_resource_cpp_id(res); |
| cpp_addr = nfp_resource_address(res); |
| *cpp_size = nfp_resource_size(res); |
| |
| nfp_resource_release(res); |
| |
| if (*cpp_size < HWINFO_SIZE_MIN) |
| return NULL; |
| } else if (PTR_ERR(res) == -ENOENT) { |
| /* Try getting the HWInfo table from the 'classic' location */ |
| cpp_id = NFP_CPP_ISLAND_ID(NFP_CPP_TARGET_MU, |
| NFP_CPP_ACTION_RW, 0, 1); |
| cpp_addr = 0x30000; |
| *cpp_size = 0x0e000; |
| } else { |
| return NULL; |
| } |
| |
| db = kmalloc(*cpp_size + 1, GFP_KERNEL); |
| if (!db) |
| return NULL; |
| |
| err = nfp_cpp_read(cpp, cpp_id, cpp_addr, db, *cpp_size); |
| if (err != *cpp_size) |
| goto exit_free; |
| |
| header = (void *)db; |
| if (nfp_hwinfo_is_updating(header)) |
| goto exit_free; |
| |
| if (le32_to_cpu(header->version) != NFP_HWINFO_VERSION_2) { |
| nfp_err(cpp, "Unknown HWInfo version: 0x%08x\n", |
| le32_to_cpu(header->version)); |
| goto exit_free; |
| } |
| |
| /* NULL-terminate for safety */ |
| db[*cpp_size] = '\0'; |
| |
| return (void *)db; |
| exit_free: |
| kfree(db); |
| return NULL; |
| } |
| |
| static struct nfp_hwinfo *hwinfo_fetch(struct nfp_cpp *cpp, size_t *hwdb_size) |
| { |
| const unsigned long wait_until = jiffies + HWINFO_WAIT * HZ; |
| struct nfp_hwinfo *db; |
| int err; |
| |
| for (;;) { |
| const unsigned long start_time = jiffies; |
| |
| db = hwinfo_try_fetch(cpp, hwdb_size); |
| if (db) |
| return db; |
| |
| err = msleep_interruptible(100); |
| if (err || time_after(start_time, wait_until)) { |
| nfp_err(cpp, "NFP access error\n"); |
| return NULL; |
| } |
| } |
| } |
| |
| struct nfp_hwinfo *nfp_hwinfo_read(struct nfp_cpp *cpp) |
| { |
| struct nfp_hwinfo *db; |
| size_t hwdb_size = 0; |
| int err; |
| |
| db = hwinfo_fetch(cpp, &hwdb_size); |
| if (!db) |
| return NULL; |
| |
| err = hwinfo_db_validate(cpp, db, hwdb_size); |
| if (err) { |
| kfree(db); |
| return NULL; |
| } |
| |
| return db; |
| } |
| |
| /** |
| * nfp_hwinfo_lookup() - Find a value in the HWInfo table by name |
| * @hwinfo: NFP HWinfo table |
| * @lookup: HWInfo name to search for |
| * |
| * Return: Value of the HWInfo name, or NULL |
| */ |
| const char *nfp_hwinfo_lookup(struct nfp_hwinfo *hwinfo, const char *lookup) |
| { |
| const char *key, *val, *end; |
| |
| if (!hwinfo || !lookup) |
| return NULL; |
| |
| end = hwinfo->data + le32_to_cpu(hwinfo->size) - sizeof(u32); |
| |
| for (key = hwinfo->data; *key && key < end; |
| key = val + strlen(val) + 1) { |
| |
| val = key + strlen(key) + 1; |
| |
| if (strcmp(key, lookup) == 0) |
| return val; |
| } |
| |
| return NULL; |
| } |
| |
| char *nfp_hwinfo_get_packed_strings(struct nfp_hwinfo *hwinfo) |
| { |
| return hwinfo->data; |
| } |
| |
| u32 nfp_hwinfo_get_packed_str_size(struct nfp_hwinfo *hwinfo) |
| { |
| return le32_to_cpu(hwinfo->size) - sizeof(u32); |
| } |