drivers/net/ethernet/netronome/nfp/devlink_param.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2019 Netronome Systems, Inc. */
   3
   4 #include <net/devlink.h>
   5
   6 #include "nfpcore/nfp.h"
   7 #include "nfpcore/nfp_nsp.h"
   8 #include "nfp_main.h"
   9
  10 /**
  11  * struct nfp_devlink_param_u8_arg - Devlink u8 parameter get/set arguments
  12  * @hwinfo_name:        HWinfo key name
  13  * @default_hi_val:     Default HWinfo value if HWinfo doesn't exist
  14  * @invalid_dl_val:     Devlink value to use if HWinfo is unknown/invalid.
  15  *                      -errno if there is no unknown/invalid value available
  16  * @hi_to_dl:   HWinfo to devlink value mapping
  17  * @dl_to_hi:   Devlink to hwinfo value mapping
  18  * @max_dl_val: Maximum devlink value supported, for validation only
  19  * @max_hi_val: Maximum HWinfo value supported, for validation only
  20  */
  21 struct nfp_devlink_param_u8_arg {
  22         const char *hwinfo_name;
  23         const char *default_hi_val;
  24         int invalid_dl_val;
  25         u8 hi_to_dl[4];
  26         u8 dl_to_hi[4];
  27         u8 max_dl_val;
  28         u8 max_hi_val;
  29 };
  30
  31 static const struct nfp_devlink_param_u8_arg nfp_devlink_u8_args[] = {
  32         [DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY] = {
  33                 .hwinfo_name = "app_fw_from_flash",
  34                 .default_hi_val = NFP_NSP_APP_FW_LOAD_DEFAULT,
  35                 .invalid_dl_val = -EINVAL,
  36                 .hi_to_dl = {
  37                         [NFP_NSP_APP_FW_LOAD_DISK] =
  38                                 DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DISK,
  39                         [NFP_NSP_APP_FW_LOAD_FLASH] =
  40                                 DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH,
  41                         [NFP_NSP_APP_FW_LOAD_PREF] =
  42                                 DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER,
  43                 },
  44                 .dl_to_hi = {
  45                         [DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER] =
  46                                 NFP_NSP_APP_FW_LOAD_PREF,
  47                         [DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH] =
  48                                 NFP_NSP_APP_FW_LOAD_FLASH,
  49                         [DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DISK] =
  50                                 NFP_NSP_APP_FW_LOAD_DISK,
  51                 },
  52                 .max_dl_val = DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DISK,
  53                 .max_hi_val = NFP_NSP_APP_FW_LOAD_PREF,
  54         },
  55 };
  56
  57 static int
  58 nfp_devlink_param_u8_get(struct devlink *devlink, u32 id,
  59                          struct devlink_param_gset_ctx *ctx)
  60 {
  61         const struct nfp_devlink_param_u8_arg *arg;
  62         struct nfp_pf *pf = devlink_priv(devlink);
  63         struct nfp_nsp *nsp;
  64         char hwinfo[32];
  65         long value;
  66         int err;
  67
  68         if (id >= ARRAY_SIZE(nfp_devlink_u8_args))
  69                 return -EOPNOTSUPP;
  70
  71         arg = &nfp_devlink_u8_args[id];
  72
  73         nsp = nfp_nsp_open(pf->cpp);
  74         if (IS_ERR(nsp)) {
  75                 err = PTR_ERR(nsp);
  76                 nfp_warn(pf->cpp, "can't access NSP: %d\n", err);
  77                 return err;
  78         }
  79
  80         snprintf(hwinfo, sizeof(hwinfo), arg->hwinfo_name);
  81         err = nfp_nsp_hwinfo_lookup_optional(nsp, hwinfo, sizeof(hwinfo),
  82                                              arg->default_hi_val);
  83         if (err) {
  84                 nfp_warn(pf->cpp, "HWinfo lookup failed: %d\n", err);
  85                 goto exit_close_nsp;
  86         }
  87
  88         err = kstrtol(hwinfo, 0, &value);
  89         if (err || value < 0 || value > arg->max_hi_val) {
  90                 nfp_warn(pf->cpp, "HWinfo '%s' value %li invalid\n",
  91                          arg->hwinfo_name, value);
  92
  93                 if (arg->invalid_dl_val >= 0)
  94                         ctx->val.vu8 = arg->invalid_dl_val;
  95                 else
  96                         err = arg->invalid_dl_val;
  97
  98                 goto exit_close_nsp;
  99         }
 100
 101         ctx->val.vu8 = arg->hi_to_dl[value];
 102
 103 exit_close_nsp:
 104         nfp_nsp_close(nsp);
 105         return err;
 106 }
 107
 108 static int
 109 nfp_devlink_param_u8_set(struct devlink *devlink, u32 id,
 110                          struct devlink_param_gset_ctx *ctx)
 111 {
 112         const struct nfp_devlink_param_u8_arg *arg;
 113         struct nfp_pf *pf = devlink_priv(devlink);
 114         struct nfp_nsp *nsp;
 115         char hwinfo[32];
 116         int err;
 117
 118         if (id >= ARRAY_SIZE(nfp_devlink_u8_args))
 119                 return -EOPNOTSUPP;
 120
 121         arg = &nfp_devlink_u8_args[id];
 122
 123         nsp = nfp_nsp_open(pf->cpp);
 124         if (IS_ERR(nsp)) {
 125                 err = PTR_ERR(nsp);
 126                 nfp_warn(pf->cpp, "can't access NSP: %d\n", err);
 127                 return err;
 128         }
 129
 130         /* Note the value has already been validated. */
 131         snprintf(hwinfo, sizeof(hwinfo), "%s=%u",
 132                  arg->hwinfo_name, arg->dl_to_hi[ctx->val.vu8]);
 133         err = nfp_nsp_hwinfo_set(nsp, hwinfo, sizeof(hwinfo));
 134         if (err) {
 135                 nfp_warn(pf->cpp, "HWinfo set failed: %d\n", err);
 136                 goto exit_close_nsp;
 137         }
 138
 139 exit_close_nsp:
 140         nfp_nsp_close(nsp);
 141         return err;
 142 }
 143
 144 static int
 145 nfp_devlink_param_u8_validate(struct devlink *devlink, u32 id,
 146                               union devlink_param_value val,
 147                               struct netlink_ext_ack *extack)
 148 {
 149         const struct nfp_devlink_param_u8_arg *arg;
 150
 151         if (id >= ARRAY_SIZE(nfp_devlink_u8_args))
 152                 return -EOPNOTSUPP;
 153
 154         arg = &nfp_devlink_u8_args[id];
 155
 156         if (val.vu8 > arg->max_dl_val) {
 157                 NL_SET_ERR_MSG_MOD(extack, "parameter out of range");
 158                 return -EINVAL;
 159         }
 160
 161         if (val.vu8 == arg->invalid_dl_val) {
 162                 NL_SET_ERR_MSG_MOD(extack, "unknown/invalid value specified");
 163                 return -EINVAL;
 164         }
 165
 166         return 0;
 167 }
 168
 169 static const struct devlink_param nfp_devlink_params[] = {
 170         DEVLINK_PARAM_GENERIC(FW_LOAD_POLICY,
 171                               BIT(DEVLINK_PARAM_CMODE_PERMANENT),
 172                               nfp_devlink_param_u8_get,
 173                               nfp_devlink_param_u8_set,
 174                               nfp_devlink_param_u8_validate),
 175 };
 176
 177 static int nfp_devlink_supports_params(struct nfp_pf *pf)
 178 {
 179         struct nfp_nsp *nsp;
 180         bool supported;
 181         int err;
 182
 183         nsp = nfp_nsp_open(pf->cpp);
 184         if (IS_ERR(nsp)) {
 185                 err = PTR_ERR(nsp);
 186                 dev_err(&pf->pdev->dev, "Failed to access the NSP: %d\n", err);
 187                 return err;
 188         }
 189
 190         supported = nfp_nsp_has_hwinfo_lookup(nsp) &&
 191                     nfp_nsp_has_hwinfo_set(nsp);
 192
 193         nfp_nsp_close(nsp);
 194         return supported;
 195 }
 196
 197 int nfp_devlink_params_register(struct nfp_pf *pf)
 198 {
 199         struct devlink *devlink = priv_to_devlink(pf);
 200         int err;
 201
 202         err = nfp_devlink_supports_params(pf);
 203         if (err <= 0)
 204                 return err;
 205
 206         err = devlink_params_register(devlink, nfp_devlink_params,
 207                                       ARRAY_SIZE(nfp_devlink_params));
 208         if (err)
 209                 return err;
 210
 211         devlink_params_publish(devlink);
 212         return 0;
 213 }
 214
 215 void nfp_devlink_params_unregister(struct nfp_pf *pf)
 216 {
 217         int err;
 218
 219         err = nfp_devlink_supports_params(pf);
 220         if (err <= 0)
 221                 return;
 222
 223         devlink_params_unregister(priv_to_devlink(pf), nfp_devlink_params,
 224                                   ARRAY_SIZE(nfp_devlink_params));
 225 }