drivers/net/nfp/nfpcore/nfp_nsp.c

   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
  18 nfp_nsp_config_modified(struct nfp_nsp *state)
  19 {
  20         return state->modified;
  21 }
  22
  23 void
  24 nfp_nsp_config_set_modified(struct nfp_nsp *state, int modified)
  25 {
  26         state->modified = modified;
  27 }
  28
  29 void *
  30 nfp_nsp_config_entries(struct nfp_nsp *state)
  31 {
  32         return state->entries;
  33 }
  34
  35 unsigned int
  36 nfp_nsp_config_idx(struct nfp_nsp *state)
  37 {
  38         return state->idx;
  39 }
  40
  41 void
  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
  49 nfp_nsp_config_clear_state(struct nfp_nsp *state)
  50 {
  51         state->entries = NULL;
  52         state->idx = 0;
  53 }
  54
  55 static void
  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
  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, &reg);
  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 *
 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
 143 nfp_nsp_close(struct nfp_nsp *state)
 144 {
 145         nfp_resource_release(state->res);
 146         free(state);
 147 }
 148
 149 uint16_t
 150 nfp_nsp_get_abi_ver_major(struct nfp_nsp *state)
 151 {
 152         return state->ver.major;
 153 }
 154
 155 uint16_t
 156 nfp_nsp_get_abi_ver_minor(struct nfp_nsp *state)
 157 {
 158         return state->ver.minor;
 159 }
 160
 161 static int
 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
 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, &reg, 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, &reg, 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
 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                             &reg);
 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                             &reg);
 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
 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
 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
 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
 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
 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
 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
 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
 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 }