drivers/net/ethernet/mellanox/mlx5/core/devlink.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /* Copyright (c) 2019 Mellanox Technologies */
   3
   4 #include <devlink.h>
   5
   6 #include "mlx5_core.h"
   7 #include "fw_reset.h"
   8 #include "fs_core.h"
   9 #include "eswitch.h"
  10
  11 static int mlx5_devlink_flash_update(struct devlink *devlink,
  12                                      struct devlink_flash_update_params *params,
  13                                      struct netlink_ext_ack *extack)
  14 {
  15         struct mlx5_core_dev *dev = devlink_priv(devlink);
  16         const struct firmware *fw;
  17         int err;
  18
  19         err = request_firmware_direct(&fw, params->file_name, &dev->pdev->dev);
  20         if (err)
  21                 return err;
  22
  23         err = mlx5_firmware_flash(dev, fw, extack);
  24         release_firmware(fw);
  25
  26         return err;
  27 }
  28
  29 static u8 mlx5_fw_ver_major(u32 version)
  30 {
  31         return (version >> 24) & 0xff;
  32 }
  33
  34 static u8 mlx5_fw_ver_minor(u32 version)
  35 {
  36         return (version >> 16) & 0xff;
  37 }
  38
  39 static u16 mlx5_fw_ver_subminor(u32 version)
  40 {
  41         return version & 0xffff;
  42 }
  43
  44 #define DEVLINK_FW_STRING_LEN 32
  45
  46 static int
  47 mlx5_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
  48                       struct netlink_ext_ack *extack)
  49 {
  50         struct mlx5_core_dev *dev = devlink_priv(devlink);
  51         char version_str[DEVLINK_FW_STRING_LEN];
  52         u32 running_fw, stored_fw;
  53         int err;
  54
  55         err = devlink_info_driver_name_put(req, DRIVER_NAME);
  56         if (err)
  57                 return err;
  58
  59         err = devlink_info_version_fixed_put(req, "fw.psid", dev->board_id);
  60         if (err)
  61                 return err;
  62
  63         err = mlx5_fw_version_query(dev, &running_fw, &stored_fw);
  64         if (err)
  65                 return err;
  66
  67         snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
  68                  mlx5_fw_ver_major(running_fw), mlx5_fw_ver_minor(running_fw),
  69                  mlx5_fw_ver_subminor(running_fw));
  70         err = devlink_info_version_running_put(req, "fw.version", version_str);
  71         if (err)
  72                 return err;
  73
  74         /* no pending version, return running (stored) version */
  75         if (stored_fw == 0)
  76                 stored_fw = running_fw;
  77
  78         snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
  79                  mlx5_fw_ver_major(stored_fw), mlx5_fw_ver_minor(stored_fw),
  80                  mlx5_fw_ver_subminor(stored_fw));
  81         err = devlink_info_version_stored_put(req, "fw.version", version_str);
  82         if (err)
  83                 return err;
  84
  85         return 0;
  86 }
  87
  88 static int mlx5_devlink_reload_fw_activate(struct devlink *devlink, struct netlink_ext_ack *extack)
  89 {
  90         struct mlx5_core_dev *dev = devlink_priv(devlink);
  91         u8 reset_level, reset_type, net_port_alive;
  92         int err;
  93
  94         err = mlx5_fw_reset_query(dev, &reset_level, &reset_type);
  95         if (err)
  96                 return err;
  97         if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL3)) {
  98                 NL_SET_ERR_MSG_MOD(extack, "FW activate requires reboot");
  99                 return -EINVAL;
 100         }
 101
 102         net_port_alive = !!(reset_type & MLX5_MFRL_REG_RESET_TYPE_NET_PORT_ALIVE);
 103         err = mlx5_fw_reset_set_reset_sync(dev, net_port_alive);
 104         if (err)
 105                 goto out;
 106
 107         err = mlx5_fw_reset_wait_reset_done(dev);
 108 out:
 109         if (err)
 110                 NL_SET_ERR_MSG_MOD(extack, "FW activate command failed");
 111         return err;
 112 }
 113
 114 static int mlx5_devlink_reload_down(struct devlink *devlink, bool netns_change,
 115                                     enum devlink_reload_action action,
 116                                     enum devlink_reload_limit limit,
 117                                     struct netlink_ext_ack *extack)
 118 {
 119         struct mlx5_core_dev *dev = devlink_priv(devlink);
 120
 121         switch (action) {
 122         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 123                 mlx5_unload_one(dev, false);
 124                 return 0;
 125         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 126                 return mlx5_devlink_reload_fw_activate(devlink, extack);
 127         default:
 128                 /* Unsupported action should not get to this function */
 129                 WARN_ON(1);
 130                 return -EOPNOTSUPP;
 131         }
 132 }
 133
 134 static int mlx5_devlink_reload_up(struct devlink *devlink, enum devlink_reload_action action,
 135                                   enum devlink_reload_limit limit, u32 *actions_performed,
 136                                   struct netlink_ext_ack *extack)
 137 {
 138         struct mlx5_core_dev *dev = devlink_priv(devlink);
 139
 140         *actions_performed = BIT(action);
 141         switch (action) {
 142         case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 143         case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
 144                 /* On fw_activate action, also driver is reloaded and reinit performed */
 145                 *actions_performed |= BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
 146                 return mlx5_load_one(dev, false);
 147         default:
 148                 /* Unsupported action should not get to this function */
 149                 WARN_ON(1);
 150                 return -EOPNOTSUPP;
 151         }
 152
 153         return 0;
 154 }
 155
 156 static const struct devlink_ops mlx5_devlink_ops = {
 157 #ifdef CONFIG_MLX5_ESWITCH
 158         .eswitch_mode_set = mlx5_devlink_eswitch_mode_set,
 159         .eswitch_mode_get = mlx5_devlink_eswitch_mode_get,
 160         .eswitch_inline_mode_set = mlx5_devlink_eswitch_inline_mode_set,
 161         .eswitch_inline_mode_get = mlx5_devlink_eswitch_inline_mode_get,
 162         .eswitch_encap_mode_set = mlx5_devlink_eswitch_encap_mode_set,
 163         .eswitch_encap_mode_get = mlx5_devlink_eswitch_encap_mode_get,
 164         .port_function_hw_addr_get = mlx5_devlink_port_function_hw_addr_get,
 165         .port_function_hw_addr_set = mlx5_devlink_port_function_hw_addr_set,
 166 #endif
 167         .flash_update = mlx5_devlink_flash_update,
 168         .info_get = mlx5_devlink_info_get,
 169         .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
 170                           BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
 171         .reload_down = mlx5_devlink_reload_down,
 172         .reload_up = mlx5_devlink_reload_up,
 173 };
 174
 175 struct devlink *mlx5_devlink_alloc(void)
 176 {
 177         return devlink_alloc(&mlx5_devlink_ops, sizeof(struct mlx5_core_dev));
 178 }
 179
 180 void mlx5_devlink_free(struct devlink *devlink)
 181 {
 182         devlink_free(devlink);
 183 }
 184
 185 static int mlx5_devlink_fs_mode_validate(struct devlink *devlink, u32 id,
 186                                          union devlink_param_value val,
 187                                          struct netlink_ext_ack *extack)
 188 {
 189         struct mlx5_core_dev *dev = devlink_priv(devlink);
 190         char *value = val.vstr;
 191         int err = 0;
 192
 193         if (!strcmp(value, "dmfs")) {
 194                 return 0;
 195         } else if (!strcmp(value, "smfs")) {
 196                 u8 eswitch_mode;
 197                 bool smfs_cap;
 198
 199                 eswitch_mode = mlx5_eswitch_mode(dev->priv.eswitch);
 200                 smfs_cap = mlx5_fs_dr_is_supported(dev);
 201
 202                 if (!smfs_cap) {
 203                         err = -EOPNOTSUPP;
 204                         NL_SET_ERR_MSG_MOD(extack,
 205                                            "Software managed steering is not supported by current device");
 206                 }
 207
 208                 else if (eswitch_mode == MLX5_ESWITCH_OFFLOADS) {
 209                         NL_SET_ERR_MSG_MOD(extack,
 210                                            "Software managed steering is not supported when eswitch offloads enabled.");
 211                         err = -EOPNOTSUPP;
 212                 }
 213         } else {
 214                 NL_SET_ERR_MSG_MOD(extack,
 215                                    "Bad parameter: supported values are [\"dmfs\", \"smfs\"]");
 216                 err = -EINVAL;
 217         }
 218
 219         return err;
 220 }
 221
 222 static int mlx5_devlink_fs_mode_set(struct devlink *devlink, u32 id,
 223                                     struct devlink_param_gset_ctx *ctx)
 224 {
 225         struct mlx5_core_dev *dev = devlink_priv(devlink);
 226         enum mlx5_flow_steering_mode mode;
 227
 228         if (!strcmp(ctx->val.vstr, "smfs"))
 229                 mode = MLX5_FLOW_STEERING_MODE_SMFS;
 230         else
 231                 mode = MLX5_FLOW_STEERING_MODE_DMFS;
 232         dev->priv.steering->mode = mode;
 233
 234         return 0;
 235 }
 236
 237 static int mlx5_devlink_fs_mode_get(struct devlink *devlink, u32 id,
 238                                     struct devlink_param_gset_ctx *ctx)
 239 {
 240         struct mlx5_core_dev *dev = devlink_priv(devlink);
 241
 242         if (dev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_SMFS)
 243                 strcpy(ctx->val.vstr, "smfs");
 244         else
 245                 strcpy(ctx->val.vstr, "dmfs");
 246         return 0;
 247 }
 248
 249 static int mlx5_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
 250                                              union devlink_param_value val,
 251                                              struct netlink_ext_ack *extack)
 252 {
 253         struct mlx5_core_dev *dev = devlink_priv(devlink);
 254         bool new_state = val.vbool;
 255
 256         if (new_state && !MLX5_CAP_GEN(dev, roce)) {
 257                 NL_SET_ERR_MSG_MOD(extack, "Device doesn't support RoCE");
 258                 return -EOPNOTSUPP;
 259         }
 260
 261         return 0;
 262 }
 263
 264 #ifdef CONFIG_MLX5_ESWITCH
 265 static int mlx5_devlink_large_group_num_validate(struct devlink *devlink, u32 id,
 266                                                  union devlink_param_value val,
 267                                                  struct netlink_ext_ack *extack)
 268 {
 269         int group_num = val.vu32;
 270
 271         if (group_num < 1 || group_num > 1024) {
 272                 NL_SET_ERR_MSG_MOD(extack,
 273                                    "Unsupported group number, supported range is 1-1024");
 274                 return -EOPNOTSUPP;
 275         }
 276
 277         return 0;
 278 }
 279 #endif
 280
 281 static const struct devlink_param mlx5_devlink_params[] = {
 282         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_FLOW_STEERING_MODE,
 283                              "flow_steering_mode", DEVLINK_PARAM_TYPE_STRING,
 284                              BIT(DEVLINK_PARAM_CMODE_RUNTIME),
 285                              mlx5_devlink_fs_mode_get, mlx5_devlink_fs_mode_set,
 286                              mlx5_devlink_fs_mode_validate),
 287         DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 288                               NULL, NULL, mlx5_devlink_enable_roce_validate),
 289 #ifdef CONFIG_MLX5_ESWITCH
 290         DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
 291                              "fdb_large_groups", DEVLINK_PARAM_TYPE_U32,
 292                              BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
 293                              NULL, NULL,
 294                              mlx5_devlink_large_group_num_validate),
 295 #endif
 296 };
 297
 298 static void mlx5_devlink_set_params_init_values(struct devlink *devlink)
 299 {
 300         struct mlx5_core_dev *dev = devlink_priv(devlink);
 301         union devlink_param_value value;
 302
 303         if (dev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_DMFS)
 304                 strcpy(value.vstr, "dmfs");
 305         else
 306                 strcpy(value.vstr, "smfs");
 307         devlink_param_driverinit_value_set(devlink,
 308                                            MLX5_DEVLINK_PARAM_ID_FLOW_STEERING_MODE,
 309                                            value);
 310
 311         value.vbool = MLX5_CAP_GEN(dev, roce);
 312         devlink_param_driverinit_value_set(devlink,
 313                                            DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
 314                                            value);
 315
 316 #ifdef CONFIG_MLX5_ESWITCH
 317         value.vu32 = ESW_OFFLOADS_DEFAULT_NUM_GROUPS;
 318         devlink_param_driverinit_value_set(devlink,
 319                                            MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
 320                                            value);
 321 #endif
 322 }
 323
 324 int mlx5_devlink_register(struct devlink *devlink, struct device *dev)
 325 {
 326         int err;
 327
 328         err = devlink_register(devlink, dev);
 329         if (err)
 330                 return err;
 331
 332         err = devlink_params_register(devlink, mlx5_devlink_params,
 333                                       ARRAY_SIZE(mlx5_devlink_params));
 334         if (err)
 335                 goto params_reg_err;
 336         mlx5_devlink_set_params_init_values(devlink);
 337         devlink_params_publish(devlink);
 338         return 0;
 339
 340 params_reg_err:
 341         devlink_unregister(devlink);
 342         return err;
 343 }
 344
 345 void mlx5_devlink_unregister(struct devlink *devlink)
 346 {
 347         devlink_params_unregister(devlink, mlx5_devlink_params,
 348                                   ARRAY_SIZE(mlx5_devlink_params));
 349         devlink_unregister(devlink);
 350 }