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 #include "sf/dev/dev.h"
11 #include "sf/sf.h"
12
mlx5_devlink_flash_update(struct devlink * devlink,struct devlink_flash_update_params * params,struct netlink_ext_ack * extack)13 static int mlx5_devlink_flash_update(struct devlink *devlink,
14 struct devlink_flash_update_params *params,
15 struct netlink_ext_ack *extack)
16 {
17 struct mlx5_core_dev *dev = devlink_priv(devlink);
18
19 return mlx5_firmware_flash(dev, params->fw, extack);
20 }
21
mlx5_fw_ver_major(u32 version)22 static u8 mlx5_fw_ver_major(u32 version)
23 {
24 return (version >> 24) & 0xff;
25 }
26
mlx5_fw_ver_minor(u32 version)27 static u8 mlx5_fw_ver_minor(u32 version)
28 {
29 return (version >> 16) & 0xff;
30 }
31
mlx5_fw_ver_subminor(u32 version)32 static u16 mlx5_fw_ver_subminor(u32 version)
33 {
34 return version & 0xffff;
35 }
36
37 #define DEVLINK_FW_STRING_LEN 32
38
39 static int
mlx5_devlink_info_get(struct devlink * devlink,struct devlink_info_req * req,struct netlink_ext_ack * extack)40 mlx5_devlink_info_get(struct devlink *devlink, struct devlink_info_req *req,
41 struct netlink_ext_ack *extack)
42 {
43 struct mlx5_core_dev *dev = devlink_priv(devlink);
44 char version_str[DEVLINK_FW_STRING_LEN];
45 u32 running_fw, stored_fw;
46 int err;
47
48 err = devlink_info_driver_name_put(req, KBUILD_MODNAME);
49 if (err)
50 return err;
51
52 err = devlink_info_version_fixed_put(req, "fw.psid", dev->board_id);
53 if (err)
54 return err;
55
56 err = mlx5_fw_version_query(dev, &running_fw, &stored_fw);
57 if (err)
58 return err;
59
60 snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
61 mlx5_fw_ver_major(running_fw), mlx5_fw_ver_minor(running_fw),
62 mlx5_fw_ver_subminor(running_fw));
63 err = devlink_info_version_running_put(req, "fw.version", version_str);
64 if (err)
65 return err;
66
67 /* no pending version, return running (stored) version */
68 if (stored_fw == 0)
69 stored_fw = running_fw;
70
71 snprintf(version_str, sizeof(version_str), "%d.%d.%04d",
72 mlx5_fw_ver_major(stored_fw), mlx5_fw_ver_minor(stored_fw),
73 mlx5_fw_ver_subminor(stored_fw));
74 err = devlink_info_version_stored_put(req, "fw.version", version_str);
75 if (err)
76 return err;
77
78 return 0;
79 }
80
mlx5_devlink_reload_fw_activate(struct devlink * devlink,struct netlink_ext_ack * extack)81 static int mlx5_devlink_reload_fw_activate(struct devlink *devlink, struct netlink_ext_ack *extack)
82 {
83 struct mlx5_core_dev *dev = devlink_priv(devlink);
84 u8 reset_level, reset_type, net_port_alive;
85 int err;
86
87 err = mlx5_fw_reset_query(dev, &reset_level, &reset_type);
88 if (err)
89 return err;
90 if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL3)) {
91 NL_SET_ERR_MSG_MOD(extack, "FW activate requires reboot");
92 return -EINVAL;
93 }
94
95 net_port_alive = !!(reset_type & MLX5_MFRL_REG_RESET_TYPE_NET_PORT_ALIVE);
96 err = mlx5_fw_reset_set_reset_sync(dev, net_port_alive);
97 if (err)
98 goto out;
99
100 err = mlx5_fw_reset_wait_reset_done(dev);
101 out:
102 if (err)
103 NL_SET_ERR_MSG_MOD(extack, "FW activate command failed");
104 return err;
105 }
106
mlx5_devlink_trigger_fw_live_patch(struct devlink * devlink,struct netlink_ext_ack * extack)107 static int mlx5_devlink_trigger_fw_live_patch(struct devlink *devlink,
108 struct netlink_ext_ack *extack)
109 {
110 struct mlx5_core_dev *dev = devlink_priv(devlink);
111 u8 reset_level;
112 int err;
113
114 err = mlx5_fw_reset_query(dev, &reset_level, NULL);
115 if (err)
116 return err;
117 if (!(reset_level & MLX5_MFRL_REG_RESET_LEVEL0)) {
118 NL_SET_ERR_MSG_MOD(extack,
119 "FW upgrade to the stored FW can't be done by FW live patching");
120 return -EINVAL;
121 }
122
123 return mlx5_fw_reset_set_live_patch(dev);
124 }
125
mlx5_devlink_reload_down(struct devlink * devlink,bool netns_change,enum devlink_reload_action action,enum devlink_reload_limit limit,struct netlink_ext_ack * extack)126 static int mlx5_devlink_reload_down(struct devlink *devlink, bool netns_change,
127 enum devlink_reload_action action,
128 enum devlink_reload_limit limit,
129 struct netlink_ext_ack *extack)
130 {
131 struct mlx5_core_dev *dev = devlink_priv(devlink);
132 bool sf_dev_allocated;
133
134 sf_dev_allocated = mlx5_sf_dev_allocated(dev);
135 if (sf_dev_allocated) {
136 /* Reload results in deleting SF device which further results in
137 * unregistering devlink instance while holding devlink_mutext.
138 * Hence, do not support reload.
139 */
140 NL_SET_ERR_MSG_MOD(extack, "reload is unsupported when SFs are allocated");
141 return -EOPNOTSUPP;
142 }
143
144 if (mlx5_lag_is_active(dev)) {
145 NL_SET_ERR_MSG_MOD(extack, "reload is unsupported in Lag mode");
146 return -EOPNOTSUPP;
147 }
148
149 switch (action) {
150 case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
151 mlx5_unload_one(dev);
152 return 0;
153 case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
154 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
155 return mlx5_devlink_trigger_fw_live_patch(devlink, extack);
156 return mlx5_devlink_reload_fw_activate(devlink, extack);
157 default:
158 /* Unsupported action should not get to this function */
159 WARN_ON(1);
160 return -EOPNOTSUPP;
161 }
162 }
163
mlx5_devlink_reload_up(struct devlink * devlink,enum devlink_reload_action action,enum devlink_reload_limit limit,u32 * actions_performed,struct netlink_ext_ack * extack)164 static int mlx5_devlink_reload_up(struct devlink *devlink, enum devlink_reload_action action,
165 enum devlink_reload_limit limit, u32 *actions_performed,
166 struct netlink_ext_ack *extack)
167 {
168 struct mlx5_core_dev *dev = devlink_priv(devlink);
169
170 *actions_performed = BIT(action);
171 switch (action) {
172 case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
173 return mlx5_load_one(dev);
174 case DEVLINK_RELOAD_ACTION_FW_ACTIVATE:
175 if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
176 break;
177 /* On fw_activate action, also driver is reloaded and reinit performed */
178 *actions_performed |= BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
179 return mlx5_load_one(dev);
180 default:
181 /* Unsupported action should not get to this function */
182 WARN_ON(1);
183 return -EOPNOTSUPP;
184 }
185
186 return 0;
187 }
188
mlx5_find_trap_by_id(struct mlx5_core_dev * dev,int trap_id)189 static struct mlx5_devlink_trap *mlx5_find_trap_by_id(struct mlx5_core_dev *dev, int trap_id)
190 {
191 struct mlx5_devlink_trap *dl_trap;
192
193 list_for_each_entry(dl_trap, &dev->priv.traps, list)
194 if (dl_trap->trap.id == trap_id)
195 return dl_trap;
196
197 return NULL;
198 }
199
mlx5_devlink_trap_init(struct devlink * devlink,const struct devlink_trap * trap,void * trap_ctx)200 static int mlx5_devlink_trap_init(struct devlink *devlink, const struct devlink_trap *trap,
201 void *trap_ctx)
202 {
203 struct mlx5_core_dev *dev = devlink_priv(devlink);
204 struct mlx5_devlink_trap *dl_trap;
205
206 dl_trap = kzalloc(sizeof(*dl_trap), GFP_KERNEL);
207 if (!dl_trap)
208 return -ENOMEM;
209
210 dl_trap->trap.id = trap->id;
211 dl_trap->trap.action = DEVLINK_TRAP_ACTION_DROP;
212 dl_trap->item = trap_ctx;
213
214 if (mlx5_find_trap_by_id(dev, trap->id)) {
215 kfree(dl_trap);
216 mlx5_core_err(dev, "Devlink trap: Trap 0x%x already found", trap->id);
217 return -EEXIST;
218 }
219
220 list_add_tail(&dl_trap->list, &dev->priv.traps);
221 return 0;
222 }
223
mlx5_devlink_trap_fini(struct devlink * devlink,const struct devlink_trap * trap,void * trap_ctx)224 static void mlx5_devlink_trap_fini(struct devlink *devlink, const struct devlink_trap *trap,
225 void *trap_ctx)
226 {
227 struct mlx5_core_dev *dev = devlink_priv(devlink);
228 struct mlx5_devlink_trap *dl_trap;
229
230 dl_trap = mlx5_find_trap_by_id(dev, trap->id);
231 if (!dl_trap) {
232 mlx5_core_err(dev, "Devlink trap: Missing trap id 0x%x", trap->id);
233 return;
234 }
235 list_del(&dl_trap->list);
236 kfree(dl_trap);
237 }
238
mlx5_devlink_trap_action_set(struct devlink * devlink,const struct devlink_trap * trap,enum devlink_trap_action action,struct netlink_ext_ack * extack)239 static int mlx5_devlink_trap_action_set(struct devlink *devlink,
240 const struct devlink_trap *trap,
241 enum devlink_trap_action action,
242 struct netlink_ext_ack *extack)
243 {
244 struct mlx5_core_dev *dev = devlink_priv(devlink);
245 enum devlink_trap_action action_orig;
246 struct mlx5_devlink_trap *dl_trap;
247 int err = 0;
248
249 if (is_mdev_switchdev_mode(dev)) {
250 NL_SET_ERR_MSG_MOD(extack, "Devlink traps can't be set in switchdev mode");
251 return -EOPNOTSUPP;
252 }
253
254 dl_trap = mlx5_find_trap_by_id(dev, trap->id);
255 if (!dl_trap) {
256 mlx5_core_err(dev, "Devlink trap: Set action on invalid trap id 0x%x", trap->id);
257 err = -EINVAL;
258 goto out;
259 }
260
261 if (action != DEVLINK_TRAP_ACTION_DROP && action != DEVLINK_TRAP_ACTION_TRAP) {
262 err = -EOPNOTSUPP;
263 goto out;
264 }
265
266 if (action == dl_trap->trap.action)
267 goto out;
268
269 action_orig = dl_trap->trap.action;
270 dl_trap->trap.action = action;
271 err = mlx5_blocking_notifier_call_chain(dev, MLX5_DRIVER_EVENT_TYPE_TRAP,
272 &dl_trap->trap);
273 if (err)
274 dl_trap->trap.action = action_orig;
275 out:
276 return err;
277 }
278
279 static const struct devlink_ops mlx5_devlink_ops = {
280 #ifdef CONFIG_MLX5_ESWITCH
281 .eswitch_mode_set = mlx5_devlink_eswitch_mode_set,
282 .eswitch_mode_get = mlx5_devlink_eswitch_mode_get,
283 .eswitch_inline_mode_set = mlx5_devlink_eswitch_inline_mode_set,
284 .eswitch_inline_mode_get = mlx5_devlink_eswitch_inline_mode_get,
285 .eswitch_encap_mode_set = mlx5_devlink_eswitch_encap_mode_set,
286 .eswitch_encap_mode_get = mlx5_devlink_eswitch_encap_mode_get,
287 .port_function_hw_addr_get = mlx5_devlink_port_function_hw_addr_get,
288 .port_function_hw_addr_set = mlx5_devlink_port_function_hw_addr_set,
289 #endif
290 #ifdef CONFIG_MLX5_SF_MANAGER
291 .port_new = mlx5_devlink_sf_port_new,
292 .port_del = mlx5_devlink_sf_port_del,
293 .port_fn_state_get = mlx5_devlink_sf_port_fn_state_get,
294 .port_fn_state_set = mlx5_devlink_sf_port_fn_state_set,
295 #endif
296 .flash_update = mlx5_devlink_flash_update,
297 .info_get = mlx5_devlink_info_get,
298 .reload_actions = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
299 BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
300 .reload_limits = BIT(DEVLINK_RELOAD_LIMIT_NO_RESET),
301 .reload_down = mlx5_devlink_reload_down,
302 .reload_up = mlx5_devlink_reload_up,
303 .trap_init = mlx5_devlink_trap_init,
304 .trap_fini = mlx5_devlink_trap_fini,
305 .trap_action_set = mlx5_devlink_trap_action_set,
306 };
307
mlx5_devlink_trap_report(struct mlx5_core_dev * dev,int trap_id,struct sk_buff * skb,struct devlink_port * dl_port)308 void mlx5_devlink_trap_report(struct mlx5_core_dev *dev, int trap_id, struct sk_buff *skb,
309 struct devlink_port *dl_port)
310 {
311 struct devlink *devlink = priv_to_devlink(dev);
312 struct mlx5_devlink_trap *dl_trap;
313
314 dl_trap = mlx5_find_trap_by_id(dev, trap_id);
315 if (!dl_trap) {
316 mlx5_core_err(dev, "Devlink trap: Report on invalid trap id 0x%x", trap_id);
317 return;
318 }
319
320 if (dl_trap->trap.action != DEVLINK_TRAP_ACTION_TRAP) {
321 mlx5_core_dbg(dev, "Devlink trap: Trap id %d has action %d", trap_id,
322 dl_trap->trap.action);
323 return;
324 }
325 devlink_trap_report(devlink, skb, dl_trap->item, dl_port, NULL);
326 }
327
mlx5_devlink_trap_get_num_active(struct mlx5_core_dev * dev)328 int mlx5_devlink_trap_get_num_active(struct mlx5_core_dev *dev)
329 {
330 struct mlx5_devlink_trap *dl_trap;
331 int count = 0;
332
333 list_for_each_entry(dl_trap, &dev->priv.traps, list)
334 if (dl_trap->trap.action == DEVLINK_TRAP_ACTION_TRAP)
335 count++;
336
337 return count;
338 }
339
mlx5_devlink_traps_get_action(struct mlx5_core_dev * dev,int trap_id,enum devlink_trap_action * action)340 int mlx5_devlink_traps_get_action(struct mlx5_core_dev *dev, int trap_id,
341 enum devlink_trap_action *action)
342 {
343 struct mlx5_devlink_trap *dl_trap;
344
345 dl_trap = mlx5_find_trap_by_id(dev, trap_id);
346 if (!dl_trap) {
347 mlx5_core_err(dev, "Devlink trap: Get action on invalid trap id 0x%x",
348 trap_id);
349 return -EINVAL;
350 }
351
352 *action = dl_trap->trap.action;
353 return 0;
354 }
355
mlx5_devlink_alloc(void)356 struct devlink *mlx5_devlink_alloc(void)
357 {
358 return devlink_alloc(&mlx5_devlink_ops, sizeof(struct mlx5_core_dev));
359 }
360
mlx5_devlink_free(struct devlink * devlink)361 void mlx5_devlink_free(struct devlink *devlink)
362 {
363 devlink_free(devlink);
364 }
365
mlx5_devlink_fs_mode_validate(struct devlink * devlink,u32 id,union devlink_param_value val,struct netlink_ext_ack * extack)366 static int mlx5_devlink_fs_mode_validate(struct devlink *devlink, u32 id,
367 union devlink_param_value val,
368 struct netlink_ext_ack *extack)
369 {
370 struct mlx5_core_dev *dev = devlink_priv(devlink);
371 char *value = val.vstr;
372 int err = 0;
373
374 if (!strcmp(value, "dmfs")) {
375 return 0;
376 } else if (!strcmp(value, "smfs")) {
377 u8 eswitch_mode;
378 bool smfs_cap;
379
380 eswitch_mode = mlx5_eswitch_mode(dev);
381 smfs_cap = mlx5_fs_dr_is_supported(dev);
382
383 if (!smfs_cap) {
384 err = -EOPNOTSUPP;
385 NL_SET_ERR_MSG_MOD(extack,
386 "Software managed steering is not supported by current device");
387 }
388
389 else if (eswitch_mode == MLX5_ESWITCH_OFFLOADS) {
390 NL_SET_ERR_MSG_MOD(extack,
391 "Software managed steering is not supported when eswitch offloads enabled.");
392 err = -EOPNOTSUPP;
393 }
394 } else {
395 NL_SET_ERR_MSG_MOD(extack,
396 "Bad parameter: supported values are [\"dmfs\", \"smfs\"]");
397 err = -EINVAL;
398 }
399
400 return err;
401 }
402
mlx5_devlink_fs_mode_set(struct devlink * devlink,u32 id,struct devlink_param_gset_ctx * ctx)403 static int mlx5_devlink_fs_mode_set(struct devlink *devlink, u32 id,
404 struct devlink_param_gset_ctx *ctx)
405 {
406 struct mlx5_core_dev *dev = devlink_priv(devlink);
407 enum mlx5_flow_steering_mode mode;
408
409 if (!strcmp(ctx->val.vstr, "smfs"))
410 mode = MLX5_FLOW_STEERING_MODE_SMFS;
411 else
412 mode = MLX5_FLOW_STEERING_MODE_DMFS;
413 dev->priv.steering->mode = mode;
414
415 return 0;
416 }
417
mlx5_devlink_fs_mode_get(struct devlink * devlink,u32 id,struct devlink_param_gset_ctx * ctx)418 static int mlx5_devlink_fs_mode_get(struct devlink *devlink, u32 id,
419 struct devlink_param_gset_ctx *ctx)
420 {
421 struct mlx5_core_dev *dev = devlink_priv(devlink);
422
423 if (dev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_SMFS)
424 strcpy(ctx->val.vstr, "smfs");
425 else
426 strcpy(ctx->val.vstr, "dmfs");
427 return 0;
428 }
429
mlx5_devlink_enable_roce_validate(struct devlink * devlink,u32 id,union devlink_param_value val,struct netlink_ext_ack * extack)430 static int mlx5_devlink_enable_roce_validate(struct devlink *devlink, u32 id,
431 union devlink_param_value val,
432 struct netlink_ext_ack *extack)
433 {
434 struct mlx5_core_dev *dev = devlink_priv(devlink);
435 bool new_state = val.vbool;
436
437 if (new_state && !MLX5_CAP_GEN(dev, roce)) {
438 NL_SET_ERR_MSG_MOD(extack, "Device doesn't support RoCE");
439 return -EOPNOTSUPP;
440 }
441 if (mlx5_core_is_mp_slave(dev) || mlx5_lag_is_active(dev)) {
442 NL_SET_ERR_MSG_MOD(extack, "Multi port slave/Lag device can't configure RoCE");
443 return -EOPNOTSUPP;
444 }
445
446 return 0;
447 }
448
449 #ifdef CONFIG_MLX5_ESWITCH
mlx5_devlink_large_group_num_validate(struct devlink * devlink,u32 id,union devlink_param_value val,struct netlink_ext_ack * extack)450 static int mlx5_devlink_large_group_num_validate(struct devlink *devlink, u32 id,
451 union devlink_param_value val,
452 struct netlink_ext_ack *extack)
453 {
454 int group_num = val.vu32;
455
456 if (group_num < 1 || group_num > 1024) {
457 NL_SET_ERR_MSG_MOD(extack,
458 "Unsupported group number, supported range is 1-1024");
459 return -EOPNOTSUPP;
460 }
461
462 return 0;
463 }
464
mlx5_devlink_esw_port_metadata_set(struct devlink * devlink,u32 id,struct devlink_param_gset_ctx * ctx)465 static int mlx5_devlink_esw_port_metadata_set(struct devlink *devlink, u32 id,
466 struct devlink_param_gset_ctx *ctx)
467 {
468 struct mlx5_core_dev *dev = devlink_priv(devlink);
469
470 if (!MLX5_ESWITCH_MANAGER(dev))
471 return -EOPNOTSUPP;
472
473 return mlx5_esw_offloads_vport_metadata_set(dev->priv.eswitch, ctx->val.vbool);
474 }
475
mlx5_devlink_esw_port_metadata_get(struct devlink * devlink,u32 id,struct devlink_param_gset_ctx * ctx)476 static int mlx5_devlink_esw_port_metadata_get(struct devlink *devlink, u32 id,
477 struct devlink_param_gset_ctx *ctx)
478 {
479 struct mlx5_core_dev *dev = devlink_priv(devlink);
480
481 if (!MLX5_ESWITCH_MANAGER(dev))
482 return -EOPNOTSUPP;
483
484 ctx->val.vbool = mlx5_eswitch_vport_match_metadata_enabled(dev->priv.eswitch);
485 return 0;
486 }
487
mlx5_devlink_esw_port_metadata_validate(struct devlink * devlink,u32 id,union devlink_param_value val,struct netlink_ext_ack * extack)488 static int mlx5_devlink_esw_port_metadata_validate(struct devlink *devlink, u32 id,
489 union devlink_param_value val,
490 struct netlink_ext_ack *extack)
491 {
492 struct mlx5_core_dev *dev = devlink_priv(devlink);
493 u8 esw_mode;
494
495 if (!MLX5_ESWITCH_MANAGER(dev)) {
496 NL_SET_ERR_MSG_MOD(extack, "E-Switch is unsupported");
497 return -EOPNOTSUPP;
498 }
499 esw_mode = mlx5_eswitch_mode(dev);
500 if (esw_mode == MLX5_ESWITCH_OFFLOADS) {
501 NL_SET_ERR_MSG_MOD(extack,
502 "E-Switch must either disabled or non switchdev mode");
503 return -EBUSY;
504 }
505 return 0;
506 }
507
508 #endif
509
mlx5_devlink_enable_remote_dev_reset_set(struct devlink * devlink,u32 id,struct devlink_param_gset_ctx * ctx)510 static int mlx5_devlink_enable_remote_dev_reset_set(struct devlink *devlink, u32 id,
511 struct devlink_param_gset_ctx *ctx)
512 {
513 struct mlx5_core_dev *dev = devlink_priv(devlink);
514
515 mlx5_fw_reset_enable_remote_dev_reset_set(dev, ctx->val.vbool);
516 return 0;
517 }
518
mlx5_devlink_enable_remote_dev_reset_get(struct devlink * devlink,u32 id,struct devlink_param_gset_ctx * ctx)519 static int mlx5_devlink_enable_remote_dev_reset_get(struct devlink *devlink, u32 id,
520 struct devlink_param_gset_ctx *ctx)
521 {
522 struct mlx5_core_dev *dev = devlink_priv(devlink);
523
524 ctx->val.vbool = mlx5_fw_reset_enable_remote_dev_reset_get(dev);
525 return 0;
526 }
527
528 static const struct devlink_param mlx5_devlink_params[] = {
529 DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_FLOW_STEERING_MODE,
530 "flow_steering_mode", DEVLINK_PARAM_TYPE_STRING,
531 BIT(DEVLINK_PARAM_CMODE_RUNTIME),
532 mlx5_devlink_fs_mode_get, mlx5_devlink_fs_mode_set,
533 mlx5_devlink_fs_mode_validate),
534 DEVLINK_PARAM_GENERIC(ENABLE_ROCE, BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
535 NULL, NULL, mlx5_devlink_enable_roce_validate),
536 #ifdef CONFIG_MLX5_ESWITCH
537 DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
538 "fdb_large_groups", DEVLINK_PARAM_TYPE_U32,
539 BIT(DEVLINK_PARAM_CMODE_DRIVERINIT),
540 NULL, NULL,
541 mlx5_devlink_large_group_num_validate),
542 DEVLINK_PARAM_DRIVER(MLX5_DEVLINK_PARAM_ID_ESW_PORT_METADATA,
543 "esw_port_metadata", DEVLINK_PARAM_TYPE_BOOL,
544 BIT(DEVLINK_PARAM_CMODE_RUNTIME),
545 mlx5_devlink_esw_port_metadata_get,
546 mlx5_devlink_esw_port_metadata_set,
547 mlx5_devlink_esw_port_metadata_validate),
548 #endif
549 DEVLINK_PARAM_GENERIC(ENABLE_REMOTE_DEV_RESET, BIT(DEVLINK_PARAM_CMODE_RUNTIME),
550 mlx5_devlink_enable_remote_dev_reset_get,
551 mlx5_devlink_enable_remote_dev_reset_set, NULL),
552 };
553
mlx5_devlink_set_params_init_values(struct devlink * devlink)554 static void mlx5_devlink_set_params_init_values(struct devlink *devlink)
555 {
556 struct mlx5_core_dev *dev = devlink_priv(devlink);
557 union devlink_param_value value;
558
559 if (dev->priv.steering->mode == MLX5_FLOW_STEERING_MODE_DMFS)
560 strcpy(value.vstr, "dmfs");
561 else
562 strcpy(value.vstr, "smfs");
563 devlink_param_driverinit_value_set(devlink,
564 MLX5_DEVLINK_PARAM_ID_FLOW_STEERING_MODE,
565 value);
566
567 value.vbool = MLX5_CAP_GEN(dev, roce);
568 devlink_param_driverinit_value_set(devlink,
569 DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
570 value);
571
572 #ifdef CONFIG_MLX5_ESWITCH
573 value.vu32 = ESW_OFFLOADS_DEFAULT_NUM_GROUPS;
574 devlink_param_driverinit_value_set(devlink,
575 MLX5_DEVLINK_PARAM_ID_ESW_LARGE_GROUP_NUM,
576 value);
577
578 if (MLX5_ESWITCH_MANAGER(dev)) {
579 if (mlx5_esw_vport_match_metadata_supported(dev->priv.eswitch)) {
580 dev->priv.eswitch->flags |= MLX5_ESWITCH_VPORT_MATCH_METADATA;
581 value.vbool = true;
582 } else {
583 value.vbool = false;
584 }
585 devlink_param_driverinit_value_set(devlink,
586 MLX5_DEVLINK_PARAM_ID_ESW_PORT_METADATA,
587 value);
588 }
589 #endif
590 }
591
592 #define MLX5_TRAP_DROP(_id, _group_id) \
593 DEVLINK_TRAP_GENERIC(DROP, DROP, _id, \
594 DEVLINK_TRAP_GROUP_GENERIC_ID_##_group_id, \
595 DEVLINK_TRAP_METADATA_TYPE_F_IN_PORT)
596
597 static const struct devlink_trap mlx5_traps_arr[] = {
598 MLX5_TRAP_DROP(INGRESS_VLAN_FILTER, L2_DROPS),
599 MLX5_TRAP_DROP(DMAC_FILTER, L2_DROPS),
600 };
601
602 static const struct devlink_trap_group mlx5_trap_groups_arr[] = {
603 DEVLINK_TRAP_GROUP_GENERIC(L2_DROPS, 0),
604 };
605
mlx5_devlink_traps_register(struct devlink * devlink)606 static int mlx5_devlink_traps_register(struct devlink *devlink)
607 {
608 struct mlx5_core_dev *core_dev = devlink_priv(devlink);
609 int err;
610
611 err = devlink_trap_groups_register(devlink, mlx5_trap_groups_arr,
612 ARRAY_SIZE(mlx5_trap_groups_arr));
613 if (err)
614 return err;
615
616 err = devlink_traps_register(devlink, mlx5_traps_arr, ARRAY_SIZE(mlx5_traps_arr),
617 &core_dev->priv);
618 if (err)
619 goto err_trap_group;
620 return 0;
621
622 err_trap_group:
623 devlink_trap_groups_unregister(devlink, mlx5_trap_groups_arr,
624 ARRAY_SIZE(mlx5_trap_groups_arr));
625 return err;
626 }
627
mlx5_devlink_traps_unregister(struct devlink * devlink)628 static void mlx5_devlink_traps_unregister(struct devlink *devlink)
629 {
630 devlink_traps_unregister(devlink, mlx5_traps_arr, ARRAY_SIZE(mlx5_traps_arr));
631 devlink_trap_groups_unregister(devlink, mlx5_trap_groups_arr,
632 ARRAY_SIZE(mlx5_trap_groups_arr));
633 }
634
mlx5_devlink_register(struct devlink * devlink,struct device * dev)635 int mlx5_devlink_register(struct devlink *devlink, struct device *dev)
636 {
637 int err;
638
639 err = devlink_register(devlink, dev);
640 if (err)
641 return err;
642
643 err = devlink_params_register(devlink, mlx5_devlink_params,
644 ARRAY_SIZE(mlx5_devlink_params));
645 if (err)
646 goto params_reg_err;
647 mlx5_devlink_set_params_init_values(devlink);
648 devlink_params_publish(devlink);
649
650 err = mlx5_devlink_traps_register(devlink);
651 if (err)
652 goto traps_reg_err;
653
654 return 0;
655
656 traps_reg_err:
657 devlink_params_unregister(devlink, mlx5_devlink_params,
658 ARRAY_SIZE(mlx5_devlink_params));
659 params_reg_err:
660 devlink_unregister(devlink);
661 return err;
662 }
663
mlx5_devlink_unregister(struct devlink * devlink)664 void mlx5_devlink_unregister(struct devlink *devlink)
665 {
666 mlx5_devlink_traps_unregister(devlink);
667 devlink_params_unregister(devlink, mlx5_devlink_params,
668 ARRAY_SIZE(mlx5_devlink_params));
669 devlink_unregister(devlink);
670 }
671