LXR dpdk/drivers/net/nfp/nfpcore/nfp

   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
  17int
  18nfp_nsp_config_modified(struct nfp_nsp *state)
  19{
  20        return state->modified;
  21}
  22
  23void
  24nfp_nsp_config_set_modified(struct nfp_nsp *state, int modified)
  25{
  26        state->modified = modified;
  27}
  28
  29void *
  30nfp_nsp_config_entries(struct nfp_nsp *state)
  31{
  32        return state->entries;
  33}
  34
  35unsigned int
  36nfp_nsp_config_idx(struct nfp_nsp *state)
  37{
  38        return state->idx;
  39}
  40
  41void
  42nfp_nsp_config_set_state(struct nfp_nsp *state, void *entries, unsigned int idx)
  43{
  44        state->entries = entries;
  45        state->idx = idx;
  46}
  47
  48void
  49nfp_nsp_config_clear_state(struct nfp_nsp *state)
  50{
  51        state->entries = NULL;
  52        state->idx = 0;
  53}
  54
  55static void
  56nfp_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
  68static int
  69nfp_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 */
 109struct nfp_nsp *
 110nfp_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 */
 142void
 143nfp_nsp_close(struct nfp_nsp *state)
 144{
 145        nfp_resource_release(state->res);
 146        free(state);
 147}
 148
 149uint16_t
 150nfp_nsp_get_abi_ver_major(struct nfp_nsp *state)
 151{
 152        return state->ver.major;
 153}
 154
 155uint16_t
 156nfp_nsp_get_abi_ver_minor(struct nfp_nsp *state)
 157{
 158        return state->ver.minor;
 159}
 160
 161static int
 162nfp_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 */
 205static int
 206nfp_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
 280static int
 281nfp_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
 351int
 352nfp_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
 380int
 381nfp_nsp_device_soft_reset(struct nfp_nsp *state)
 382{
 383        return nfp_nsp_command(state, SPCODE_SOFT_RESET, 0, 0, 0);
 384}
 385
 386int
 387nfp_nsp_mac_reinit(struct nfp_nsp *state)
 388{
 389        return nfp_nsp_command(state, SPCODE_MAC_INIT, 0, 0, 0);
 390}
 391
 392int
 393nfp_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
 399int
 400nfp_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
 406int
 407nfp_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
 414int
 415nfp_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
 421int
 422nfp_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