1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Netronome Systems, Inc.
3 * All rights reserved.
4 */
5
6 #define NFP_SUBSYS "nfp_nsp"
7
8 #include <stdio.h>
9 #include <time.h>
10
11 #include <rte_common.h>
12
13 #include "nfp_cpp.h"
14 #include "nfp_nsp.h"
15 #include "nfp_resource.h"
16
17 int
nfp_nsp_config_modified(struct nfp_nsp * state)18 nfp_nsp_config_modified(struct nfp_nsp *state)
19 {
20 return state->modified;
21 }
22
23 void
nfp_nsp_config_set_modified(struct nfp_nsp * state,int modified)24 nfp_nsp_config_set_modified(struct nfp_nsp *state, int modified)
25 {
26 state->modified = modified;
27 }
28
29 void *
nfp_nsp_config_entries(struct nfp_nsp * state)30 nfp_nsp_config_entries(struct nfp_nsp *state)
31 {
32 return state->entries;
33 }
34
35 unsigned int
nfp_nsp_config_idx(struct nfp_nsp * state)36 nfp_nsp_config_idx(struct nfp_nsp *state)
37 {
38 return state->idx;
39 }
40
41 void
nfp_nsp_config_set_state(struct nfp_nsp * state,void * entries,unsigned int idx)42 nfp_nsp_config_set_state(struct nfp_nsp *state, void *entries, unsigned int idx)
43 {
44 state->entries = entries;
45 state->idx = idx;
46 }
47
48 void
nfp_nsp_config_clear_state(struct nfp_nsp * state)49 nfp_nsp_config_clear_state(struct nfp_nsp *state)
50 {
51 state->entries = NULL;
52 state->idx = 0;
53 }
54
55 static void
nfp_nsp_print_extended_error(uint32_t ret_val)56 nfp_nsp_print_extended_error(uint32_t ret_val)
57 {
58 int i;
59
60 if (!ret_val)
61 return;
62
63 for (i = 0; i < (int)ARRAY_SIZE(nsp_errors); i++)
64 if (ret_val == (uint32_t)nsp_errors[i].code)
65 printf("err msg: %s\n", nsp_errors[i].msg);
66 }
67
68 static int
nfp_nsp_check(struct nfp_nsp * state)69 nfp_nsp_check(struct nfp_nsp *state)
70 {
71 struct nfp_cpp *cpp = state->cpp;
72 uint64_t nsp_status, reg;
73 uint32_t nsp_cpp;
74 int err;
75
76 nsp_cpp = nfp_resource_cpp_id(state->res);
77 nsp_status = nfp_resource_address(state->res) + NSP_STATUS;
78
79 err = nfp_cpp_readq(cpp, nsp_cpp, nsp_status, ®);
80 if (err < 0)
81 return err;
82
83 if (FIELD_GET(NSP_STATUS_MAGIC, reg) != NSP_MAGIC) {
84 printf("Cannot detect NFP Service Processor\n");
85 return -ENODEV;
86 }
87
88 state->ver.major = FIELD_GET(NSP_STATUS_MAJOR, reg);
89 state->ver.minor = FIELD_GET(NSP_STATUS_MINOR, reg);
90
91 if (state->ver.major != NSP_MAJOR || state->ver.minor < NSP_MINOR) {
92 printf("Unsupported ABI %hu.%hu\n", state->ver.major,
93 state->ver.minor);
94 return -EINVAL;
95 }
96
97 if (reg & NSP_STATUS_BUSY) {
98 printf("Service processor busy!\n");
99 return -EBUSY;
100 }
101
102 return 0;
103 }
104
105 /*
106 * nfp_nsp_open() - Prepare for communication and lock the NSP resource.
107 * @cpp: NFP CPP Handle
108 */
109 struct nfp_nsp *
nfp_nsp_open(struct nfp_cpp * cpp)110 nfp_nsp_open(struct nfp_cpp *cpp)
111 {
112 struct nfp_resource *res;
113 struct nfp_nsp *state;
114 int err;
115
116 res = nfp_resource_acquire(cpp, NFP_RESOURCE_NSP);
117 if (!res)
118 return NULL;
119
120 state = malloc(sizeof(*state));
121 if (!state) {
122 nfp_resource_release(res);
123 return NULL;
124 }
125 memset(state, 0, sizeof(*state));
126 state->cpp = cpp;
127 state->res = res;
128
129 err = nfp_nsp_check(state);
130 if (err) {
131 nfp_nsp_close(state);
132 return NULL;
133 }
134
135 return state;
136 }
137
138 /*
139 * nfp_nsp_close() - Clean up and unlock the NSP resource.
140 * @state: NFP SP state
141 */
142 void
nfp_nsp_close(struct nfp_nsp * state)143 nfp_nsp_close(struct nfp_nsp *state)
144 {
145 nfp_resource_release(state->res);
146 free(state);
147 }
148
149 uint16_t
nfp_nsp_get_abi_ver_major(struct nfp_nsp * state)150 nfp_nsp_get_abi_ver_major(struct nfp_nsp *state)
151 {
152 return state->ver.major;
153 }
154
155 uint16_t
nfp_nsp_get_abi_ver_minor(struct nfp_nsp * state)156 nfp_nsp_get_abi_ver_minor(struct nfp_nsp *state)
157 {
158 return state->ver.minor;
159 }
160
161 static int
nfp_nsp_wait_reg(struct nfp_cpp * cpp,uint64_t * reg,uint32_t nsp_cpp,uint64_t addr,uint64_t mask,uint64_t val)162 nfp_nsp_wait_reg(struct nfp_cpp *cpp, uint64_t *reg, uint32_t nsp_cpp,
163 uint64_t addr, uint64_t mask, uint64_t val)
164 {
165 struct timespec wait;
166 int count;
167 int err;
168
169 wait.tv_sec = 0;
170 wait.tv_nsec = 25000000;
171 count = 0;
172
173 for (;;) {
174 err = nfp_cpp_readq(cpp, nsp_cpp, addr, reg);
175 if (err < 0)
176 return err;
177
178 if ((*reg & mask) == val)
179 return 0;
180
181 nanosleep(&wait, 0);
182 if (count++ > 1000)
183 return -ETIMEDOUT;
184 }
185 }
186
187 /*
188 * nfp_nsp_command() - Execute a command on the NFP Service Processor
189 * @state: NFP SP state
190 * @code: NFP SP Command Code
191 * @option: NFP SP Command Argument
192 * @buff_cpp: NFP SP Buffer CPP Address info
193 * @buff_addr: NFP SP Buffer Host address
194 *
195 * Return: 0 for success with no result
196 *
197 * positive value for NSP completion with a result code
198 *
199 * -EAGAIN if the NSP is not yet present
200 * -ENODEV if the NSP is not a supported model
201 * -EBUSY if the NSP is stuck
202 * -EINTR if interrupted while waiting for completion
203 * -ETIMEDOUT if the NSP took longer than 30 seconds to complete
204 */
205 static int
nfp_nsp_command(struct nfp_nsp * state,uint16_t code,uint32_t option,uint32_t buff_cpp,uint64_t buff_addr)206 nfp_nsp_command(struct nfp_nsp *state, uint16_t code, uint32_t option,
207 uint32_t buff_cpp, uint64_t buff_addr)
208 {
209 uint64_t reg, ret_val, nsp_base, nsp_buffer, nsp_status, nsp_command;
210 struct nfp_cpp *cpp = state->cpp;
211 uint32_t nsp_cpp;
212 int err;
213
214 nsp_cpp = nfp_resource_cpp_id(state->res);
215 nsp_base = nfp_resource_address(state->res);
216 nsp_status = nsp_base + NSP_STATUS;
217 nsp_command = nsp_base + NSP_COMMAND;
218 nsp_buffer = nsp_base + NSP_BUFFER;
219
220 err = nfp_nsp_check(state);
221 if (err)
222 return err;
223
224 if (!FIELD_FIT(NSP_BUFFER_CPP, buff_cpp >> 8) ||
225 !FIELD_FIT(NSP_BUFFER_ADDRESS, buff_addr)) {
226 printf("Host buffer out of reach %08x %" PRIx64 "\n",
227 buff_cpp, buff_addr);
228 return -EINVAL;
229 }
230
231 err = nfp_cpp_writeq(cpp, nsp_cpp, nsp_buffer,
232 FIELD_PREP(NSP_BUFFER_CPP, buff_cpp >> 8) |
233 FIELD_PREP(NSP_BUFFER_ADDRESS, buff_addr));
234 if (err < 0)
235 return err;
236
237 err = nfp_cpp_writeq(cpp, nsp_cpp, nsp_command,
238 FIELD_PREP(NSP_COMMAND_OPTION, option) |
239 FIELD_PREP(NSP_COMMAND_CODE, code) |
240 FIELD_PREP(NSP_COMMAND_START, 1));
241 if (err < 0)
242 return err;
243
244 /* Wait for NSP_COMMAND_START to go to 0 */
245 err = nfp_nsp_wait_reg(cpp, ®, nsp_cpp, nsp_command,
246 NSP_COMMAND_START, 0);
247 if (err) {
248 printf("Error %d waiting for code 0x%04x to start\n",
249 err, code);
250 return err;
251 }
252
253 /* Wait for NSP_STATUS_BUSY to go to 0 */
254 err = nfp_nsp_wait_reg(cpp, ®, nsp_cpp, nsp_status, NSP_STATUS_BUSY,
255 0);
256 if (err) {
257 printf("Error %d waiting for code 0x%04x to complete\n",
258 err, code);
259 return err;
260 }
261
262 err = nfp_cpp_readq(cpp, nsp_cpp, nsp_command, &ret_val);
263 if (err < 0)
264 return err;
265 ret_val = FIELD_GET(NSP_COMMAND_OPTION, ret_val);
266
267 err = FIELD_GET(NSP_STATUS_RESULT, reg);
268 if (err) {
269 printf("Result (error) code set: %d (%d) command: %d\n",
270 -err, (int)ret_val, code);
271 nfp_nsp_print_extended_error(ret_val);
272 return -err;
273 }
274
275 return ret_val;
276 }
277
278 #define SZ_1M 0x00100000
279
280 static int
nfp_nsp_command_buf(struct nfp_nsp * nsp,uint16_t code,uint32_t option,const void * in_buf,unsigned int in_size,void * out_buf,unsigned int out_size)281 nfp_nsp_command_buf(struct nfp_nsp *nsp, uint16_t code, uint32_t option,
282 const void *in_buf, unsigned int in_size, void *out_buf,
283 unsigned int out_size)
284 {
285 struct nfp_cpp *cpp = nsp->cpp;
286 unsigned int max_size;
287 uint64_t reg, cpp_buf;
288 int ret, err;
289 uint32_t cpp_id;
290
291 if (nsp->ver.minor < 13) {
292 printf("NSP: Code 0x%04x with buffer not supported\n", code);
293 printf("\t(ABI %hu.%hu)\n", nsp->ver.major, nsp->ver.minor);
294 return -EOPNOTSUPP;
295 }
296
297 err = nfp_cpp_readq(cpp, nfp_resource_cpp_id(nsp->res),
298 nfp_resource_address(nsp->res) +
299 NSP_DFLT_BUFFER_CONFIG,
300 ®);
301 if (err < 0)
302 return err;
303
304 max_size = RTE_MAX(in_size, out_size);
305 if (FIELD_GET(NSP_DFLT_BUFFER_SIZE_MB, reg) * SZ_1M < max_size) {
306 printf("NSP: default buffer too small for command 0x%04x\n",
307 code);
308 printf("\t(%llu < %u)\n",
309 FIELD_GET(NSP_DFLT_BUFFER_SIZE_MB, reg) * SZ_1M,
310 max_size);
311 return -EINVAL;
312 }
313
314 err = nfp_cpp_readq(cpp, nfp_resource_cpp_id(nsp->res),
315 nfp_resource_address(nsp->res) +
316 NSP_DFLT_BUFFER,
317 ®);
318 if (err < 0)
319 return err;
320
321 cpp_id = FIELD_GET(NSP_BUFFER_CPP, reg) << 8;
322 cpp_buf = FIELD_GET(NSP_BUFFER_ADDRESS, reg);
323
324 if (in_buf && in_size) {
325 err = nfp_cpp_write(cpp, cpp_id, cpp_buf, in_buf, in_size);
326 if (err < 0)
327 return err;
328 }
329 /* Zero out remaining part of the buffer */
330 if (out_buf && out_size && out_size > in_size) {
331 memset(out_buf, 0, out_size - in_size);
332 err = nfp_cpp_write(cpp, cpp_id, cpp_buf + in_size, out_buf,
333 out_size - in_size);
334 if (err < 0)
335 return err;
336 }
337
338 ret = nfp_nsp_command(nsp, code, option, cpp_id, cpp_buf);
339 if (ret < 0)
340 return ret;
341
342 if (out_buf && out_size) {
343 err = nfp_cpp_read(cpp, cpp_id, cpp_buf, out_buf, out_size);
344 if (err < 0)
345 return err;
346 }
347
348 return ret;
349 }
350
351 int
nfp_nsp_wait(struct nfp_nsp * state)352 nfp_nsp_wait(struct nfp_nsp *state)
353 {
354 struct timespec wait;
355 int count;
356 int err;
357
358 wait.tv_sec = 0;
359 wait.tv_nsec = 25000000;
360 count = 0;
361
362 for (;;) {
363 err = nfp_nsp_command(state, SPCODE_NOOP, 0, 0, 0);
364 if (err != -EAGAIN)
365 break;
366
367 nanosleep(&wait, 0);
368
369 if (count++ > 1000) {
370 err = -ETIMEDOUT;
371 break;
372 }
373 }
374 if (err)
375 printf("NSP failed to respond %d\n", err);
376
377 return err;
378 }
379
380 int
nfp_nsp_device_soft_reset(struct nfp_nsp * state)381 nfp_nsp_device_soft_reset(struct nfp_nsp *state)
382 {
383 return nfp_nsp_command(state, SPCODE_SOFT_RESET, 0, 0, 0);
384 }
385
386 int
nfp_nsp_mac_reinit(struct nfp_nsp * state)387 nfp_nsp_mac_reinit(struct nfp_nsp *state)
388 {
389 return nfp_nsp_command(state, SPCODE_MAC_INIT, 0, 0, 0);
390 }
391
392 int
nfp_nsp_load_fw(struct nfp_nsp * state,void * buf,unsigned int size)393 nfp_nsp_load_fw(struct nfp_nsp *state, void *buf, unsigned int size)
394 {
395 return nfp_nsp_command_buf(state, SPCODE_FW_LOAD, size, buf, size,
396 NULL, 0);
397 }
398
399 int
nfp_nsp_read_eth_table(struct nfp_nsp * state,void * buf,unsigned int size)400 nfp_nsp_read_eth_table(struct nfp_nsp *state, void *buf, unsigned int size)
401 {
402 return nfp_nsp_command_buf(state, SPCODE_ETH_RESCAN, size, NULL, 0,
403 buf, size);
404 }
405
406 int
nfp_nsp_write_eth_table(struct nfp_nsp * state,const void * buf,unsigned int size)407 nfp_nsp_write_eth_table(struct nfp_nsp *state, const void *buf,
408 unsigned int size)
409 {
410 return nfp_nsp_command_buf(state, SPCODE_ETH_CONTROL, size, buf, size,
411 NULL, 0);
412 }
413
414 int
nfp_nsp_read_identify(struct nfp_nsp * state,void * buf,unsigned int size)415 nfp_nsp_read_identify(struct nfp_nsp *state, void *buf, unsigned int size)
416 {
417 return nfp_nsp_command_buf(state, SPCODE_NSP_IDENTIFY, size, NULL, 0,
418 buf, size);
419 }
420
421 int
nfp_nsp_read_sensors(struct nfp_nsp * state,unsigned int sensor_mask,void * buf,unsigned int size)422 nfp_nsp_read_sensors(struct nfp_nsp *state, unsigned int sensor_mask, void *buf,
423 unsigned int size)
424 {
425 return nfp_nsp_command_buf(state, SPCODE_NSP_SENSORS, sensor_mask, NULL,
426 0, buf, size);
427 }
428