1 /*
2 * Copyright (C) 2015-2017 Netronome Systems, Inc.
3 *
4 * This software is dual licensed under the GNU General License Version 2,
5 * June 1991 as shown in the file COPYING in the top-level directory of this
6 * source tree or the BSD 2-Clause License provided below. You have the
7 * option to license this software under the complete terms of either license.
8 *
9 * The BSD 2-Clause License:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * 1. Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * 2. Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34 /* Parse the hwinfo table that the ARM firmware builds in the ARM scratch SRAM
35 * after chip reset.
36 *
37 * Examples of the fields:
38 * me.count = 40
39 * me.mask = 0x7f_ffff_ffff
40 *
41 * me.count is the total number of MEs on the system.
42 * me.mask is the bitmask of MEs that are available for application usage.
43 *
44 * (ie, in this example, ME 39 has been reserved by boardconfig.)
45 */
46
47 #include <asm/byteorder.h>
48 #include <asm/unaligned.h>
49 #include <linux/delay.h>
50 #include <linux/log2.h>
51 #include <linux/kernel.h>
52 #include <linux/module.h>
53 #include <linux/slab.h>
54
55 #define NFP_SUBSYS "nfp_hwinfo"
56
57 #include "crc32.h"
58 #include "nfp.h"
59 #include "nfp_cpp.h"
60 #include "nfp6000/nfp6000.h"
61
62 #define HWINFO_SIZE_MIN 0x100
63 #define HWINFO_WAIT 20 /* seconds */
64
65 /* The Hardware Info Table defines the properties of the system.
66 *
67 * HWInfo v1 Table (fixed size)
68 *
69 * 0x0000: u32 version Hardware Info Table version (1.0)
70 * 0x0004: u32 size Total size of the table, including
71 * the CRC32 (IEEE 802.3)
72 * 0x0008: u32 jumptab Offset of key/value table
73 * 0x000c: u32 keys Total number of keys in the key/value table
74 * NNNNNN: Key/value jump table and string data
75 * (size - 4): u32 crc32 CRC32 (same as IEEE 802.3, POSIX csum, etc)
76 * CRC32("",0) = ~0, CRC32("a",1) = 0x48C279FE
77 *
78 * HWInfo v2 Table (variable size)
79 *
80 * 0x0000: u32 version Hardware Info Table version (2.0)
81 * 0x0004: u32 size Current size of the data area, excluding CRC32
82 * 0x0008: u32 limit Maximum size of the table
83 * 0x000c: u32 reserved Unused, set to zero
84 * NNNNNN: Key/value data
85 * (size - 4): u32 crc32 CRC32 (same as IEEE 802.3, POSIX csum, etc)
86 * CRC32("",0) = ~0, CRC32("a",1) = 0x48C279FE
87 *
88 * If the HWInfo table is in the process of being updated, the low bit
89 * of version will be set.
90 *
91 * HWInfo v1 Key/Value Table
92 * -------------------------
93 *
94 * The key/value table is a set of offsets to ASCIIZ strings which have
95 * been strcmp(3) sorted (yes, please use bsearch(3) on the table).
96 *
97 * All keys are guaranteed to be unique.
98 *
99 * N+0: u32 key_1 Offset to the first key
100 * N+4: u32 val_1 Offset to the first value
101 * N+8: u32 key_2 Offset to the second key
102 * N+c: u32 val_2 Offset to the second value
103 * ...
104 *
105 * HWInfo v2 Key/Value Table
106 * -------------------------
107 *
108 * Packed UTF8Z strings, ie 'key1\000value1\000key2\000value2\000'
109 *
110 * Unsorted.
111 */
112
113 #define NFP_HWINFO_VERSION_1 ('H' << 24 | 'I' << 16 | 1 << 8 | 0 << 1 | 0)
114 #define NFP_HWINFO_VERSION_2 ('H' << 24 | 'I' << 16 | 2 << 8 | 0 << 1 | 0)
115 #define NFP_HWINFO_VERSION_UPDATING BIT(0)
116
117 struct nfp_hwinfo {
118 u8 start[0];
119
120 __le32 version;
121 __le32 size;
122
123 /* v2 specific fields */
124 __le32 limit;
125 __le32 resv;
126
127 char data[];
128 };
129
nfp_hwinfo_is_updating(struct nfp_hwinfo * hwinfo)130 static bool nfp_hwinfo_is_updating(struct nfp_hwinfo *hwinfo)
131 {
132 return le32_to_cpu(hwinfo->version) & NFP_HWINFO_VERSION_UPDATING;
133 }
134
135 static int
hwinfo_db_walk(struct nfp_cpp * cpp,struct nfp_hwinfo * hwinfo,u32 size)136 hwinfo_db_walk(struct nfp_cpp *cpp, struct nfp_hwinfo *hwinfo, u32 size)
137 {
138 const char *key, *val, *end = hwinfo->data + size;
139
140 for (key = hwinfo->data; *key && key < end;
141 key = val + strlen(val) + 1) {
142
143 val = key + strlen(key) + 1;
144 if (val >= end) {
145 nfp_warn(cpp, "Bad HWINFO - overflowing key\n");
146 return -EINVAL;
147 }
148
149 if (val + strlen(val) + 1 > end) {
150 nfp_warn(cpp, "Bad HWINFO - overflowing value\n");
151 return -EINVAL;
152 }
153 }
154
155 return 0;
156 }
157
158 static int
hwinfo_db_validate(struct nfp_cpp * cpp,struct nfp_hwinfo * db,u32 len)159 hwinfo_db_validate(struct nfp_cpp *cpp, struct nfp_hwinfo *db, u32 len)
160 {
161 u32 size, crc;
162
163 size = le32_to_cpu(db->size);
164 if (size > len) {
165 nfp_err(cpp, "Unsupported hwinfo size %u > %u\n", size, len);
166 return -EINVAL;
167 }
168
169 size -= sizeof(u32);
170 crc = crc32_posix(db, size);
171 if (crc != get_unaligned_le32(db->start + size)) {
172 nfp_err(cpp, "Corrupt hwinfo table (CRC mismatch), calculated 0x%x, expected 0x%x\n",
173 crc, get_unaligned_le32(db->start + size));
174
175 return -EINVAL;
176 }
177
178 return hwinfo_db_walk(cpp, db, size);
179 }
180
181 static struct nfp_hwinfo *
hwinfo_try_fetch(struct nfp_cpp * cpp,size_t * cpp_size)182 hwinfo_try_fetch(struct nfp_cpp *cpp, size_t *cpp_size)
183 {
184 struct nfp_hwinfo *header;
185 struct nfp_resource *res;
186 u64 cpp_addr;
187 u32 cpp_id;
188 int err;
189 u8 *db;
190
191 res = nfp_resource_acquire(cpp, NFP_RESOURCE_NFP_HWINFO);
192 if (!IS_ERR(res)) {
193 cpp_id = nfp_resource_cpp_id(res);
194 cpp_addr = nfp_resource_address(res);
195 *cpp_size = nfp_resource_size(res);
196
197 nfp_resource_release(res);
198
199 if (*cpp_size < HWINFO_SIZE_MIN)
200 return NULL;
201 } else if (PTR_ERR(res) == -ENOENT) {
202 /* Try getting the HWInfo table from the 'classic' location */
203 cpp_id = NFP_CPP_ISLAND_ID(NFP_CPP_TARGET_MU,
204 NFP_CPP_ACTION_RW, 0, 1);
205 cpp_addr = 0x30000;
206 *cpp_size = 0x0e000;
207 } else {
208 return NULL;
209 }
210
211 db = kmalloc(*cpp_size + 1, GFP_KERNEL);
212 if (!db)
213 return NULL;
214
215 err = nfp_cpp_read(cpp, cpp_id, cpp_addr, db, *cpp_size);
216 if (err != *cpp_size)
217 goto exit_free;
218
219 header = (void *)db;
220 if (nfp_hwinfo_is_updating(header))
221 goto exit_free;
222
223 if (le32_to_cpu(header->version) != NFP_HWINFO_VERSION_2) {
224 nfp_err(cpp, "Unknown HWInfo version: 0x%08x\n",
225 le32_to_cpu(header->version));
226 goto exit_free;
227 }
228
229 /* NULL-terminate for safety */
230 db[*cpp_size] = '\0';
231
232 return (void *)db;
233 exit_free:
234 kfree(db);
235 return NULL;
236 }
237
hwinfo_fetch(struct nfp_cpp * cpp,size_t * hwdb_size)238 static struct nfp_hwinfo *hwinfo_fetch(struct nfp_cpp *cpp, size_t *hwdb_size)
239 {
240 const unsigned long wait_until = jiffies + HWINFO_WAIT * HZ;
241 struct nfp_hwinfo *db;
242 int err;
243
244 for (;;) {
245 const unsigned long start_time = jiffies;
246
247 db = hwinfo_try_fetch(cpp, hwdb_size);
248 if (db)
249 return db;
250
251 err = msleep_interruptible(100);
252 if (err || time_after(start_time, wait_until)) {
253 nfp_err(cpp, "NFP access error\n");
254 return NULL;
255 }
256 }
257 }
258
nfp_hwinfo_read(struct nfp_cpp * cpp)259 struct nfp_hwinfo *nfp_hwinfo_read(struct nfp_cpp *cpp)
260 {
261 struct nfp_hwinfo *db;
262 size_t hwdb_size = 0;
263 int err;
264
265 db = hwinfo_fetch(cpp, &hwdb_size);
266 if (!db)
267 return NULL;
268
269 err = hwinfo_db_validate(cpp, db, hwdb_size);
270 if (err) {
271 kfree(db);
272 return NULL;
273 }
274
275 return db;
276 }
277
278 /**
279 * nfp_hwinfo_lookup() - Find a value in the HWInfo table by name
280 * @hwinfo: NFP HWinfo table
281 * @lookup: HWInfo name to search for
282 *
283 * Return: Value of the HWInfo name, or NULL
284 */
nfp_hwinfo_lookup(struct nfp_hwinfo * hwinfo,const char * lookup)285 const char *nfp_hwinfo_lookup(struct nfp_hwinfo *hwinfo, const char *lookup)
286 {
287 const char *key, *val, *end;
288
289 if (!hwinfo || !lookup)
290 return NULL;
291
292 end = hwinfo->data + le32_to_cpu(hwinfo->size) - sizeof(u32);
293
294 for (key = hwinfo->data; *key && key < end;
295 key = val + strlen(val) + 1) {
296
297 val = key + strlen(key) + 1;
298
299 if (strcmp(key, lookup) == 0)
300 return val;
301 }
302
303 return NULL;
304 }
305