xref: /linux/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c (revision a4eb44a6435d6d8f9e642407a4a06f65eb90ca04)
1 /* Broadcom NetXtreme-C/E network driver.
2  *
3  * Copyright (c) 2017 Broadcom Limited
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation.
8  */
9 
10 #include <linux/pci.h>
11 #include <linux/netdevice.h>
12 #include <linux/vmalloc.h>
13 #include <net/devlink.h>
14 #include "bnxt_hsi.h"
15 #include "bnxt.h"
16 #include "bnxt_hwrm.h"
17 #include "bnxt_vfr.h"
18 #include "bnxt_devlink.h"
19 #include "bnxt_ethtool.h"
20 #include "bnxt_ulp.h"
21 #include "bnxt_ptp.h"
22 #include "bnxt_coredump.h"
23 
24 static void __bnxt_fw_recover(struct bnxt *bp)
25 {
26 	if (test_bit(BNXT_STATE_FW_FATAL_COND, &bp->state) ||
27 	    test_bit(BNXT_STATE_FW_NON_FATAL_COND, &bp->state))
28 		bnxt_fw_reset(bp);
29 	else
30 		bnxt_fw_exception(bp);
31 }
32 
33 static int
34 bnxt_dl_flash_update(struct devlink *dl,
35 		     struct devlink_flash_update_params *params,
36 		     struct netlink_ext_ack *extack)
37 {
38 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
39 	int rc;
40 
41 	if (!BNXT_PF(bp)) {
42 		NL_SET_ERR_MSG_MOD(extack,
43 				   "flash update not supported from a VF");
44 		return -EPERM;
45 	}
46 
47 	devlink_flash_update_status_notify(dl, "Preparing to flash", NULL, 0, 0);
48 	rc = bnxt_flash_package_from_fw_obj(bp->dev, params->fw, 0);
49 	if (!rc)
50 		devlink_flash_update_status_notify(dl, "Flashing done", NULL, 0, 0);
51 	else
52 		devlink_flash_update_status_notify(dl, "Flashing failed", NULL, 0, 0);
53 	return rc;
54 }
55 
56 static int bnxt_hwrm_remote_dev_reset_set(struct bnxt *bp, bool remote_reset)
57 {
58 	struct hwrm_func_cfg_input *req;
59 	int rc;
60 
61 	if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
62 		return -EOPNOTSUPP;
63 
64 	rc = hwrm_req_init(bp, req, HWRM_FUNC_CFG);
65 	if (rc)
66 		return rc;
67 
68 	req->fid = cpu_to_le16(0xffff);
69 	req->enables = cpu_to_le32(FUNC_CFG_REQ_ENABLES_HOT_RESET_IF_SUPPORT);
70 	if (remote_reset)
71 		req->flags = cpu_to_le32(FUNC_CFG_REQ_FLAGS_HOT_RESET_IF_EN_DIS);
72 
73 	return hwrm_req_send(bp, req);
74 }
75 
76 static char *bnxt_health_severity_str(enum bnxt_health_severity severity)
77 {
78 	switch (severity) {
79 	case SEVERITY_NORMAL: return "normal";
80 	case SEVERITY_WARNING: return "warning";
81 	case SEVERITY_RECOVERABLE: return "recoverable";
82 	case SEVERITY_FATAL: return "fatal";
83 	default: return "unknown";
84 	}
85 }
86 
87 static char *bnxt_health_remedy_str(enum bnxt_health_remedy remedy)
88 {
89 	switch (remedy) {
90 	case REMEDY_DEVLINK_RECOVER: return "devlink recover";
91 	case REMEDY_POWER_CYCLE_DEVICE: return "device power cycle";
92 	case REMEDY_POWER_CYCLE_HOST: return "host power cycle";
93 	case REMEDY_FW_UPDATE: return "update firmware";
94 	case REMEDY_HW_REPLACE: return "replace hardware";
95 	default: return "unknown";
96 	}
97 }
98 
99 static int bnxt_fw_diagnose(struct devlink_health_reporter *reporter,
100 			    struct devlink_fmsg *fmsg,
101 			    struct netlink_ext_ack *extack)
102 {
103 	struct bnxt *bp = devlink_health_reporter_priv(reporter);
104 	struct bnxt_fw_health *h = bp->fw_health;
105 	u32 fw_status, fw_resets;
106 	int rc;
107 
108 	if (test_bit(BNXT_STATE_IN_FW_RESET, &bp->state))
109 		return devlink_fmsg_string_pair_put(fmsg, "Status", "recovering");
110 
111 	if (!h->status_reliable)
112 		return devlink_fmsg_string_pair_put(fmsg, "Status", "unknown");
113 
114 	mutex_lock(&h->lock);
115 	fw_status = bnxt_fw_health_readl(bp, BNXT_FW_HEALTH_REG);
116 	if (BNXT_FW_IS_BOOTING(fw_status)) {
117 		rc = devlink_fmsg_string_pair_put(fmsg, "Status", "initializing");
118 		if (rc)
119 			goto unlock;
120 	} else if (h->severity || fw_status != BNXT_FW_STATUS_HEALTHY) {
121 		if (!h->severity) {
122 			h->severity = SEVERITY_FATAL;
123 			h->remedy = REMEDY_POWER_CYCLE_DEVICE;
124 			h->diagnoses++;
125 			devlink_health_report(h->fw_reporter,
126 					      "FW error diagnosed", h);
127 		}
128 		rc = devlink_fmsg_string_pair_put(fmsg, "Status", "error");
129 		if (rc)
130 			goto unlock;
131 		rc = devlink_fmsg_u32_pair_put(fmsg, "Syndrome", fw_status);
132 		if (rc)
133 			goto unlock;
134 	} else {
135 		rc = devlink_fmsg_string_pair_put(fmsg, "Status", "healthy");
136 		if (rc)
137 			goto unlock;
138 	}
139 
140 	rc = devlink_fmsg_string_pair_put(fmsg, "Severity",
141 					  bnxt_health_severity_str(h->severity));
142 	if (rc)
143 		goto unlock;
144 
145 	if (h->severity) {
146 		rc = devlink_fmsg_string_pair_put(fmsg, "Remedy",
147 						  bnxt_health_remedy_str(h->remedy));
148 		if (rc)
149 			goto unlock;
150 		if (h->remedy == REMEDY_DEVLINK_RECOVER) {
151 			rc = devlink_fmsg_string_pair_put(fmsg, "Impact",
152 							  "traffic+ntuple_cfg");
153 			if (rc)
154 				goto unlock;
155 		}
156 	}
157 
158 unlock:
159 	mutex_unlock(&h->lock);
160 	if (rc || !h->resets_reliable)
161 		return rc;
162 
163 	fw_resets = bnxt_fw_health_readl(bp, BNXT_FW_RESET_CNT_REG);
164 	rc = devlink_fmsg_u32_pair_put(fmsg, "Resets", fw_resets);
165 	if (rc)
166 		return rc;
167 	rc = devlink_fmsg_u32_pair_put(fmsg, "Arrests", h->arrests);
168 	if (rc)
169 		return rc;
170 	rc = devlink_fmsg_u32_pair_put(fmsg, "Survivals", h->survivals);
171 	if (rc)
172 		return rc;
173 	rc = devlink_fmsg_u32_pair_put(fmsg, "Discoveries", h->discoveries);
174 	if (rc)
175 		return rc;
176 	rc = devlink_fmsg_u32_pair_put(fmsg, "Fatalities", h->fatalities);
177 	if (rc)
178 		return rc;
179 	return devlink_fmsg_u32_pair_put(fmsg, "Diagnoses", h->diagnoses);
180 }
181 
182 static int bnxt_fw_dump(struct devlink_health_reporter *reporter,
183 			struct devlink_fmsg *fmsg, void *priv_ctx,
184 			struct netlink_ext_ack *extack)
185 {
186 	struct bnxt *bp = devlink_health_reporter_priv(reporter);
187 	u32 dump_len;
188 	void *data;
189 	int rc;
190 
191 	/* TODO: no firmware dump support in devlink_health_report() context */
192 	if (priv_ctx)
193 		return -EOPNOTSUPP;
194 
195 	dump_len = bnxt_get_coredump_length(bp, BNXT_DUMP_LIVE);
196 	if (!dump_len)
197 		return -EIO;
198 
199 	data = vmalloc(dump_len);
200 	if (!data)
201 		return -ENOMEM;
202 
203 	rc = bnxt_get_coredump(bp, BNXT_DUMP_LIVE, data, &dump_len);
204 	if (!rc) {
205 		rc = devlink_fmsg_pair_nest_start(fmsg, "core");
206 		if (rc)
207 			goto exit;
208 		rc = devlink_fmsg_binary_pair_put(fmsg, "data", data, dump_len);
209 		if (rc)
210 			goto exit;
211 		rc = devlink_fmsg_u32_pair_put(fmsg, "size", dump_len);
212 		if (rc)
213 			goto exit;
214 		rc = devlink_fmsg_pair_nest_end(fmsg);
215 	}
216 
217 exit:
218 	vfree(data);
219 	return rc;
220 }
221 
222 static int bnxt_fw_recover(struct devlink_health_reporter *reporter,
223 			   void *priv_ctx,
224 			   struct netlink_ext_ack *extack)
225 {
226 	struct bnxt *bp = devlink_health_reporter_priv(reporter);
227 
228 	if (bp->fw_health->severity == SEVERITY_FATAL)
229 		return -ENODEV;
230 
231 	set_bit(BNXT_STATE_RECOVER, &bp->state);
232 	__bnxt_fw_recover(bp);
233 
234 	return -EINPROGRESS;
235 }
236 
237 static const struct devlink_health_reporter_ops bnxt_dl_fw_reporter_ops = {
238 	.name = "fw",
239 	.diagnose = bnxt_fw_diagnose,
240 	.dump = bnxt_fw_dump,
241 	.recover = bnxt_fw_recover,
242 };
243 
244 void bnxt_dl_fw_reporters_create(struct bnxt *bp)
245 {
246 	struct bnxt_fw_health *health = bp->fw_health;
247 
248 	if (!health || health->fw_reporter)
249 		return;
250 
251 	health->fw_reporter =
252 		devlink_health_reporter_create(bp->dl, &bnxt_dl_fw_reporter_ops,
253 					       0, bp);
254 	if (IS_ERR(health->fw_reporter)) {
255 		netdev_warn(bp->dev, "Failed to create FW health reporter, rc = %ld\n",
256 			    PTR_ERR(health->fw_reporter));
257 		health->fw_reporter = NULL;
258 		bp->fw_cap &= ~BNXT_FW_CAP_ERROR_RECOVERY;
259 	}
260 }
261 
262 void bnxt_dl_fw_reporters_destroy(struct bnxt *bp, bool all)
263 {
264 	struct bnxt_fw_health *health = bp->fw_health;
265 
266 	if (!health)
267 		return;
268 
269 	if ((bp->fw_cap & BNXT_FW_CAP_ERROR_RECOVERY) && !all)
270 		return;
271 
272 	if (health->fw_reporter) {
273 		devlink_health_reporter_destroy(health->fw_reporter);
274 		health->fw_reporter = NULL;
275 	}
276 }
277 
278 void bnxt_devlink_health_fw_report(struct bnxt *bp)
279 {
280 	struct bnxt_fw_health *fw_health = bp->fw_health;
281 	int rc;
282 
283 	if (!fw_health)
284 		return;
285 
286 	if (!fw_health->fw_reporter) {
287 		__bnxt_fw_recover(bp);
288 		return;
289 	}
290 
291 	mutex_lock(&fw_health->lock);
292 	fw_health->severity = SEVERITY_RECOVERABLE;
293 	fw_health->remedy = REMEDY_DEVLINK_RECOVER;
294 	mutex_unlock(&fw_health->lock);
295 	rc = devlink_health_report(fw_health->fw_reporter, "FW error reported",
296 				   fw_health);
297 	if (rc == -ECANCELED)
298 		__bnxt_fw_recover(bp);
299 }
300 
301 void bnxt_dl_health_fw_status_update(struct bnxt *bp, bool healthy)
302 {
303 	struct bnxt_fw_health *fw_health = bp->fw_health;
304 	u8 state;
305 
306 	mutex_lock(&fw_health->lock);
307 	if (healthy) {
308 		fw_health->severity = SEVERITY_NORMAL;
309 		state = DEVLINK_HEALTH_REPORTER_STATE_HEALTHY;
310 	} else {
311 		fw_health->severity = SEVERITY_FATAL;
312 		fw_health->remedy = REMEDY_POWER_CYCLE_DEVICE;
313 		state = DEVLINK_HEALTH_REPORTER_STATE_ERROR;
314 	}
315 	mutex_unlock(&fw_health->lock);
316 	devlink_health_reporter_state_update(fw_health->fw_reporter, state);
317 }
318 
319 void bnxt_dl_health_fw_recovery_done(struct bnxt *bp)
320 {
321 	struct bnxt_dl *dl = devlink_priv(bp->dl);
322 
323 	devlink_health_reporter_recovery_done(bp->fw_health->fw_reporter);
324 	bnxt_hwrm_remote_dev_reset_set(bp, dl->remote_reset);
325 }
326 
327 static int bnxt_dl_info_get(struct devlink *dl, struct devlink_info_req *req,
328 			    struct netlink_ext_ack *extack);
329 
330 static void
331 bnxt_dl_livepatch_report_err(struct bnxt *bp, struct netlink_ext_ack *extack,
332 			     struct hwrm_fw_livepatch_output *resp)
333 {
334 	int err = ((struct hwrm_err_output *)resp)->cmd_err;
335 
336 	switch (err) {
337 	case FW_LIVEPATCH_CMD_ERR_CODE_INVALID_OPCODE:
338 		netdev_err(bp->dev, "Illegal live patch opcode");
339 		NL_SET_ERR_MSG_MOD(extack, "Invalid opcode");
340 		break;
341 	case FW_LIVEPATCH_CMD_ERR_CODE_NOT_SUPPORTED:
342 		NL_SET_ERR_MSG_MOD(extack, "Live patch operation not supported");
343 		break;
344 	case FW_LIVEPATCH_CMD_ERR_CODE_NOT_INSTALLED:
345 		NL_SET_ERR_MSG_MOD(extack, "Live patch not found");
346 		break;
347 	case FW_LIVEPATCH_CMD_ERR_CODE_NOT_PATCHED:
348 		NL_SET_ERR_MSG_MOD(extack,
349 				   "Live patch deactivation failed. Firmware not patched.");
350 		break;
351 	case FW_LIVEPATCH_CMD_ERR_CODE_AUTH_FAIL:
352 		NL_SET_ERR_MSG_MOD(extack, "Live patch not authenticated");
353 		break;
354 	case FW_LIVEPATCH_CMD_ERR_CODE_INVALID_HEADER:
355 		NL_SET_ERR_MSG_MOD(extack, "Incompatible live patch");
356 		break;
357 	case FW_LIVEPATCH_CMD_ERR_CODE_INVALID_SIZE:
358 		NL_SET_ERR_MSG_MOD(extack, "Live patch has invalid size");
359 		break;
360 	case FW_LIVEPATCH_CMD_ERR_CODE_ALREADY_PATCHED:
361 		NL_SET_ERR_MSG_MOD(extack, "Live patch already applied");
362 		break;
363 	default:
364 		netdev_err(bp->dev, "Unexpected live patch error: %d\n", err);
365 		NL_SET_ERR_MSG_MOD(extack, "Failed to activate live patch");
366 		break;
367 	}
368 }
369 
370 /* Live patch status in NVM */
371 #define BNXT_LIVEPATCH_NOT_INSTALLED	0
372 #define BNXT_LIVEPATCH_INSTALLED	FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL
373 #define BNXT_LIVEPATCH_REMOVED		FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE
374 #define BNXT_LIVEPATCH_MASK		(FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL | \
375 					 FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE)
376 #define BNXT_LIVEPATCH_ACTIVATED	BNXT_LIVEPATCH_MASK
377 
378 #define BNXT_LIVEPATCH_STATE(flags)	((flags) & BNXT_LIVEPATCH_MASK)
379 
380 static int
381 bnxt_dl_livepatch_activate(struct bnxt *bp, struct netlink_ext_ack *extack)
382 {
383 	struct hwrm_fw_livepatch_query_output *query_resp;
384 	struct hwrm_fw_livepatch_query_input *query_req;
385 	struct hwrm_fw_livepatch_output *patch_resp;
386 	struct hwrm_fw_livepatch_input *patch_req;
387 	u16 flags, live_patch_state;
388 	bool activated = false;
389 	u32 installed = 0;
390 	u8 target;
391 	int rc;
392 
393 	if (~bp->fw_cap & BNXT_FW_CAP_LIVEPATCH) {
394 		NL_SET_ERR_MSG_MOD(extack, "Device does not support live patch");
395 		return -EOPNOTSUPP;
396 	}
397 
398 	rc = hwrm_req_init(bp, query_req, HWRM_FW_LIVEPATCH_QUERY);
399 	if (rc)
400 		return rc;
401 	query_resp = hwrm_req_hold(bp, query_req);
402 
403 	rc = hwrm_req_init(bp, patch_req, HWRM_FW_LIVEPATCH);
404 	if (rc) {
405 		hwrm_req_drop(bp, query_req);
406 		return rc;
407 	}
408 	patch_req->loadtype = FW_LIVEPATCH_REQ_LOADTYPE_NVM_INSTALL;
409 	patch_resp = hwrm_req_hold(bp, patch_req);
410 
411 	for (target = 1; target <= FW_LIVEPATCH_REQ_FW_TARGET_LAST; target++) {
412 		query_req->fw_target = target;
413 		rc = hwrm_req_send(bp, query_req);
414 		if (rc) {
415 			NL_SET_ERR_MSG_MOD(extack, "Failed to query packages");
416 			break;
417 		}
418 
419 		flags = le16_to_cpu(query_resp->status_flags);
420 		live_patch_state = BNXT_LIVEPATCH_STATE(flags);
421 
422 		if (live_patch_state == BNXT_LIVEPATCH_NOT_INSTALLED)
423 			continue;
424 
425 		if (live_patch_state == BNXT_LIVEPATCH_ACTIVATED) {
426 			activated = true;
427 			continue;
428 		}
429 
430 		if (live_patch_state == BNXT_LIVEPATCH_INSTALLED)
431 			patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_ACTIVATE;
432 		else if (live_patch_state == BNXT_LIVEPATCH_REMOVED)
433 			patch_req->opcode = FW_LIVEPATCH_REQ_OPCODE_DEACTIVATE;
434 
435 		patch_req->fw_target = target;
436 		rc = hwrm_req_send(bp, patch_req);
437 		if (rc) {
438 			bnxt_dl_livepatch_report_err(bp, extack, patch_resp);
439 			break;
440 		}
441 		installed++;
442 	}
443 
444 	if (!rc && !installed) {
445 		if (activated) {
446 			NL_SET_ERR_MSG_MOD(extack, "Live patch already activated");
447 			rc = -EEXIST;
448 		} else {
449 			NL_SET_ERR_MSG_MOD(extack, "No live patches found");
450 			rc = -ENOENT;
451 		}
452 	}
453 	hwrm_req_drop(bp, query_req);
454 	hwrm_req_drop(bp, patch_req);
455 	return rc;
456 }
457 
458 static int bnxt_dl_reload_down(struct devlink *dl, bool netns_change,
459 			       enum devlink_reload_action action,
460 			       enum devlink_reload_limit limit,
461 			       struct netlink_ext_ack *extack)
462 {
463 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
464 	int rc = 0;
465 
466 	switch (action) {
467 	case DEVLINK_RELOAD_ACTION_DRIVER_REINIT: {
468 		rtnl_lock();
469 		if (bnxt_sriov_cfg(bp)) {
470 			NL_SET_ERR_MSG_MOD(extack,
471 					   "reload is unsupported while VFs are allocated or being configured");
472 			rtnl_unlock();
473 			return -EOPNOTSUPP;
474 		}
475 		if (bp->dev->reg_state == NETREG_UNREGISTERED) {
476 			rtnl_unlock();
477 			return -ENODEV;
478 		}
479 		bnxt_ulp_stop(bp);
480 		if (netif_running(bp->dev)) {
481 			rc = bnxt_close_nic(bp, true, true);
482 			if (rc) {
483 				NL_SET_ERR_MSG_MOD(extack, "Failed to close");
484 				dev_close(bp->dev);
485 				rtnl_unlock();
486 				break;
487 			}
488 		}
489 		bnxt_vf_reps_free(bp);
490 		rc = bnxt_hwrm_func_drv_unrgtr(bp);
491 		if (rc) {
492 			NL_SET_ERR_MSG_MOD(extack, "Failed to deregister");
493 			if (netif_running(bp->dev))
494 				dev_close(bp->dev);
495 			rtnl_unlock();
496 			break;
497 		}
498 		bnxt_cancel_reservations(bp, false);
499 		bnxt_free_ctx_mem(bp);
500 		kfree(bp->ctx);
501 		bp->ctx = NULL;
502 		break;
503 	}
504 	case DEVLINK_RELOAD_ACTION_FW_ACTIVATE: {
505 		if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
506 			return bnxt_dl_livepatch_activate(bp, extack);
507 		if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET) {
508 			NL_SET_ERR_MSG_MOD(extack, "Device not capable, requires reboot");
509 			return -EOPNOTSUPP;
510 		}
511 		if (!bnxt_hwrm_reset_permitted(bp)) {
512 			NL_SET_ERR_MSG_MOD(extack,
513 					   "Reset denied by firmware, it may be inhibited by remote driver");
514 			return -EPERM;
515 		}
516 		rtnl_lock();
517 		if (bp->dev->reg_state == NETREG_UNREGISTERED) {
518 			rtnl_unlock();
519 			return -ENODEV;
520 		}
521 		if (netif_running(bp->dev))
522 			set_bit(BNXT_STATE_FW_ACTIVATE, &bp->state);
523 		rc = bnxt_hwrm_firmware_reset(bp->dev,
524 					      FW_RESET_REQ_EMBEDDED_PROC_TYPE_CHIP,
525 					      FW_RESET_REQ_SELFRST_STATUS_SELFRSTASAP,
526 					      FW_RESET_REQ_FLAGS_RESET_GRACEFUL |
527 					      FW_RESET_REQ_FLAGS_FW_ACTIVATION);
528 		if (rc) {
529 			NL_SET_ERR_MSG_MOD(extack, "Failed to activate firmware");
530 			clear_bit(BNXT_STATE_FW_ACTIVATE, &bp->state);
531 			rtnl_unlock();
532 		}
533 		break;
534 	}
535 	default:
536 		rc = -EOPNOTSUPP;
537 	}
538 
539 	return rc;
540 }
541 
542 static int bnxt_dl_reload_up(struct devlink *dl, enum devlink_reload_action action,
543 			     enum devlink_reload_limit limit, u32 *actions_performed,
544 			     struct netlink_ext_ack *extack)
545 {
546 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
547 	int rc = 0;
548 
549 	*actions_performed = 0;
550 	switch (action) {
551 	case DEVLINK_RELOAD_ACTION_DRIVER_REINIT: {
552 		bnxt_fw_init_one(bp);
553 		bnxt_vf_reps_alloc(bp);
554 		if (netif_running(bp->dev))
555 			rc = bnxt_open_nic(bp, true, true);
556 		bnxt_ulp_start(bp, rc);
557 		if (!rc) {
558 			bnxt_reenable_sriov(bp);
559 			bnxt_ptp_reapply_pps(bp);
560 		}
561 		break;
562 	}
563 	case DEVLINK_RELOAD_ACTION_FW_ACTIVATE: {
564 		unsigned long start = jiffies;
565 		unsigned long timeout = start + BNXT_DFLT_FW_RST_MAX_DSECS * HZ / 10;
566 
567 		if (limit == DEVLINK_RELOAD_LIMIT_NO_RESET)
568 			break;
569 		if (bp->fw_cap & BNXT_FW_CAP_ERROR_RECOVERY)
570 			timeout = start + bp->fw_health->normal_func_wait_dsecs * HZ / 10;
571 		if (!netif_running(bp->dev))
572 			NL_SET_ERR_MSG_MOD(extack,
573 					   "Device is closed, not waiting for reset notice that will never come");
574 		rtnl_unlock();
575 		while (test_bit(BNXT_STATE_FW_ACTIVATE, &bp->state)) {
576 			if (time_after(jiffies, timeout)) {
577 				NL_SET_ERR_MSG_MOD(extack, "Activation incomplete");
578 				rc = -ETIMEDOUT;
579 				break;
580 			}
581 			if (test_bit(BNXT_STATE_ABORT_ERR, &bp->state)) {
582 				NL_SET_ERR_MSG_MOD(extack, "Activation aborted");
583 				rc = -ENODEV;
584 				break;
585 			}
586 			msleep(50);
587 		}
588 		rtnl_lock();
589 		if (!rc)
590 			*actions_performed |= BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT);
591 		clear_bit(BNXT_STATE_FW_ACTIVATE, &bp->state);
592 		break;
593 	}
594 	default:
595 		return -EOPNOTSUPP;
596 	}
597 
598 	if (!rc) {
599 		bnxt_print_device_info(bp);
600 		if (netif_running(bp->dev)) {
601 			mutex_lock(&bp->link_lock);
602 			bnxt_report_link(bp);
603 			mutex_unlock(&bp->link_lock);
604 		}
605 		*actions_performed |= BIT(action);
606 	} else if (netif_running(bp->dev)) {
607 		dev_close(bp->dev);
608 	}
609 	rtnl_unlock();
610 	return rc;
611 }
612 
613 static const struct devlink_ops bnxt_dl_ops = {
614 #ifdef CONFIG_BNXT_SRIOV
615 	.eswitch_mode_set = bnxt_dl_eswitch_mode_set,
616 	.eswitch_mode_get = bnxt_dl_eswitch_mode_get,
617 #endif /* CONFIG_BNXT_SRIOV */
618 	.info_get	  = bnxt_dl_info_get,
619 	.flash_update	  = bnxt_dl_flash_update,
620 	.reload_actions	  = BIT(DEVLINK_RELOAD_ACTION_DRIVER_REINIT) |
621 			    BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
622 	.reload_limits	  = BIT(DEVLINK_RELOAD_LIMIT_NO_RESET),
623 	.reload_down	  = bnxt_dl_reload_down,
624 	.reload_up	  = bnxt_dl_reload_up,
625 };
626 
627 static const struct devlink_ops bnxt_vf_dl_ops;
628 
629 enum bnxt_dl_param_id {
630 	BNXT_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
631 	BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK,
632 };
633 
634 static const struct bnxt_dl_nvm_param nvm_params[] = {
635 	{DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV, NVM_OFF_ENABLE_SRIOV,
636 	 BNXT_NVM_SHARED_CFG, 1, 1},
637 	{DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI, NVM_OFF_IGNORE_ARI,
638 	 BNXT_NVM_SHARED_CFG, 1, 1},
639 	{DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
640 	 NVM_OFF_MSIX_VEC_PER_PF_MAX, BNXT_NVM_SHARED_CFG, 10, 4},
641 	{DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
642 	 NVM_OFF_MSIX_VEC_PER_PF_MIN, BNXT_NVM_SHARED_CFG, 7, 4},
643 	{BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK, NVM_OFF_DIS_GRE_VER_CHECK,
644 	 BNXT_NVM_SHARED_CFG, 1, 1},
645 };
646 
647 union bnxt_nvm_data {
648 	u8	val8;
649 	__le32	val32;
650 };
651 
652 static void bnxt_copy_to_nvm_data(union bnxt_nvm_data *dst,
653 				  union devlink_param_value *src,
654 				  int nvm_num_bits, int dl_num_bytes)
655 {
656 	u32 val32 = 0;
657 
658 	if (nvm_num_bits == 1) {
659 		dst->val8 = src->vbool;
660 		return;
661 	}
662 	if (dl_num_bytes == 4)
663 		val32 = src->vu32;
664 	else if (dl_num_bytes == 2)
665 		val32 = (u32)src->vu16;
666 	else if (dl_num_bytes == 1)
667 		val32 = (u32)src->vu8;
668 	dst->val32 = cpu_to_le32(val32);
669 }
670 
671 static void bnxt_copy_from_nvm_data(union devlink_param_value *dst,
672 				    union bnxt_nvm_data *src,
673 				    int nvm_num_bits, int dl_num_bytes)
674 {
675 	u32 val32;
676 
677 	if (nvm_num_bits == 1) {
678 		dst->vbool = src->val8;
679 		return;
680 	}
681 	val32 = le32_to_cpu(src->val32);
682 	if (dl_num_bytes == 4)
683 		dst->vu32 = val32;
684 	else if (dl_num_bytes == 2)
685 		dst->vu16 = (u16)val32;
686 	else if (dl_num_bytes == 1)
687 		dst->vu8 = (u8)val32;
688 }
689 
690 static int bnxt_hwrm_get_nvm_cfg_ver(struct bnxt *bp, u32 *nvm_cfg_ver)
691 {
692 	struct hwrm_nvm_get_variable_input *req;
693 	u16 bytes = BNXT_NVM_CFG_VER_BYTES;
694 	u16 bits = BNXT_NVM_CFG_VER_BITS;
695 	union devlink_param_value ver;
696 	union bnxt_nvm_data *data;
697 	dma_addr_t data_dma_addr;
698 	int rc, i = 2;
699 	u16 dim = 1;
700 
701 	rc = hwrm_req_init(bp, req, HWRM_NVM_GET_VARIABLE);
702 	if (rc)
703 		return rc;
704 
705 	data = hwrm_req_dma_slice(bp, req, sizeof(*data), &data_dma_addr);
706 	if (!data) {
707 		rc = -ENOMEM;
708 		goto exit;
709 	}
710 
711 	/* earlier devices present as an array of raw bytes */
712 	if (!BNXT_CHIP_P5(bp)) {
713 		dim = 0;
714 		i = 0;
715 		bits *= 3;  /* array of 3 version components */
716 		bytes *= 4; /* copy whole word */
717 	}
718 
719 	hwrm_req_hold(bp, req);
720 	req->dest_data_addr = cpu_to_le64(data_dma_addr);
721 	req->data_len = cpu_to_le16(bits);
722 	req->option_num = cpu_to_le16(NVM_OFF_NVM_CFG_VER);
723 	req->dimensions = cpu_to_le16(dim);
724 
725 	while (i >= 0) {
726 		req->index_0 = cpu_to_le16(i--);
727 		rc = hwrm_req_send_silent(bp, req);
728 		if (rc)
729 			goto exit;
730 		bnxt_copy_from_nvm_data(&ver, data, bits, bytes);
731 
732 		if (BNXT_CHIP_P5(bp)) {
733 			*nvm_cfg_ver <<= 8;
734 			*nvm_cfg_ver |= ver.vu8;
735 		} else {
736 			*nvm_cfg_ver = ver.vu32;
737 		}
738 	}
739 
740 exit:
741 	hwrm_req_drop(bp, req);
742 	return rc;
743 }
744 
745 static int bnxt_dl_info_put(struct bnxt *bp, struct devlink_info_req *req,
746 			    enum bnxt_dl_version_type type, const char *key,
747 			    char *buf)
748 {
749 	if (!strlen(buf))
750 		return 0;
751 
752 	if ((bp->flags & BNXT_FLAG_CHIP_P5) &&
753 	    (!strcmp(key, DEVLINK_INFO_VERSION_GENERIC_FW_NCSI) ||
754 	     !strcmp(key, DEVLINK_INFO_VERSION_GENERIC_FW_ROCE)))
755 		return 0;
756 
757 	switch (type) {
758 	case BNXT_VERSION_FIXED:
759 		return devlink_info_version_fixed_put(req, key, buf);
760 	case BNXT_VERSION_RUNNING:
761 		return devlink_info_version_running_put(req, key, buf);
762 	case BNXT_VERSION_STORED:
763 		return devlink_info_version_stored_put(req, key, buf);
764 	}
765 	return 0;
766 }
767 
768 #define BNXT_FW_SRT_PATCH	"fw.srt.patch"
769 #define BNXT_FW_CRT_PATCH	"fw.crt.patch"
770 
771 static int bnxt_dl_livepatch_info_put(struct bnxt *bp,
772 				      struct devlink_info_req *req,
773 				      const char *key)
774 {
775 	struct hwrm_fw_livepatch_query_input *query;
776 	struct hwrm_fw_livepatch_query_output *resp;
777 	u16 flags;
778 	int rc;
779 
780 	if (~bp->fw_cap & BNXT_FW_CAP_LIVEPATCH)
781 		return 0;
782 
783 	rc = hwrm_req_init(bp, query, HWRM_FW_LIVEPATCH_QUERY);
784 	if (rc)
785 		return rc;
786 
787 	if (!strcmp(key, BNXT_FW_SRT_PATCH))
788 		query->fw_target = FW_LIVEPATCH_QUERY_REQ_FW_TARGET_SECURE_FW;
789 	else if (!strcmp(key, BNXT_FW_CRT_PATCH))
790 		query->fw_target = FW_LIVEPATCH_QUERY_REQ_FW_TARGET_COMMON_FW;
791 	else
792 		goto exit;
793 
794 	resp = hwrm_req_hold(bp, query);
795 	rc = hwrm_req_send(bp, query);
796 	if (rc)
797 		goto exit;
798 
799 	flags = le16_to_cpu(resp->status_flags);
800 	if (flags & FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_ACTIVE) {
801 		resp->active_ver[sizeof(resp->active_ver) - 1] = '\0';
802 		rc = devlink_info_version_running_put(req, key, resp->active_ver);
803 		if (rc)
804 			goto exit;
805 	}
806 
807 	if (flags & FW_LIVEPATCH_QUERY_RESP_STATUS_FLAGS_INSTALL) {
808 		resp->install_ver[sizeof(resp->install_ver) - 1] = '\0';
809 		rc = devlink_info_version_stored_put(req, key, resp->install_ver);
810 		if (rc)
811 			goto exit;
812 	}
813 
814 exit:
815 	hwrm_req_drop(bp, query);
816 	return rc;
817 }
818 
819 #define HWRM_FW_VER_STR_LEN	16
820 
821 static int bnxt_dl_info_get(struct devlink *dl, struct devlink_info_req *req,
822 			    struct netlink_ext_ack *extack)
823 {
824 	struct hwrm_nvm_get_dev_info_output nvm_dev_info;
825 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
826 	struct hwrm_ver_get_output *ver_resp;
827 	char mgmt_ver[FW_VER_STR_LEN];
828 	char roce_ver[FW_VER_STR_LEN];
829 	char ncsi_ver[FW_VER_STR_LEN];
830 	char buf[32];
831 	u32 ver = 0;
832 	int rc;
833 
834 	rc = devlink_info_driver_name_put(req, DRV_MODULE_NAME);
835 	if (rc)
836 		return rc;
837 
838 	if (BNXT_PF(bp) && (bp->flags & BNXT_FLAG_DSN_VALID)) {
839 		sprintf(buf, "%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X",
840 			bp->dsn[7], bp->dsn[6], bp->dsn[5], bp->dsn[4],
841 			bp->dsn[3], bp->dsn[2], bp->dsn[1], bp->dsn[0]);
842 		rc = devlink_info_serial_number_put(req, buf);
843 		if (rc)
844 			return rc;
845 	}
846 
847 	if (strlen(bp->board_serialno)) {
848 		rc = devlink_info_board_serial_number_put(req, bp->board_serialno);
849 		if (rc)
850 			return rc;
851 	}
852 
853 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_FIXED,
854 			      DEVLINK_INFO_VERSION_GENERIC_BOARD_ID,
855 			      bp->board_partno);
856 	if (rc)
857 		return rc;
858 
859 	sprintf(buf, "%X", bp->chip_num);
860 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_FIXED,
861 			      DEVLINK_INFO_VERSION_GENERIC_ASIC_ID, buf);
862 	if (rc)
863 		return rc;
864 
865 	ver_resp = &bp->ver_resp;
866 	sprintf(buf, "%c%d", 'A' + ver_resp->chip_rev, ver_resp->chip_metal);
867 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_FIXED,
868 			      DEVLINK_INFO_VERSION_GENERIC_ASIC_REV, buf);
869 	if (rc)
870 		return rc;
871 
872 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
873 			      DEVLINK_INFO_VERSION_GENERIC_FW_PSID,
874 			      bp->nvm_cfg_ver);
875 	if (rc)
876 		return rc;
877 
878 	buf[0] = 0;
879 	strncat(buf, ver_resp->active_pkg_name, HWRM_FW_VER_STR_LEN);
880 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
881 			      DEVLINK_INFO_VERSION_GENERIC_FW, buf);
882 	if (rc)
883 		return rc;
884 
885 	if (BNXT_PF(bp) && !bnxt_hwrm_get_nvm_cfg_ver(bp, &ver)) {
886 		sprintf(buf, "%d.%d.%d", (ver >> 16) & 0xff, (ver >> 8) & 0xff,
887 			ver & 0xff);
888 		rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
889 				      DEVLINK_INFO_VERSION_GENERIC_FW_PSID,
890 				      buf);
891 		if (rc)
892 			return rc;
893 	}
894 
895 	if (ver_resp->flags & VER_GET_RESP_FLAGS_EXT_VER_AVAIL) {
896 		snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
897 			 ver_resp->hwrm_fw_major, ver_resp->hwrm_fw_minor,
898 			 ver_resp->hwrm_fw_build, ver_resp->hwrm_fw_patch);
899 
900 		snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
901 			 ver_resp->mgmt_fw_major, ver_resp->mgmt_fw_minor,
902 			 ver_resp->mgmt_fw_build, ver_resp->mgmt_fw_patch);
903 
904 		snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
905 			 ver_resp->roce_fw_major, ver_resp->roce_fw_minor,
906 			 ver_resp->roce_fw_build, ver_resp->roce_fw_patch);
907 	} else {
908 		snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
909 			 ver_resp->hwrm_fw_maj_8b, ver_resp->hwrm_fw_min_8b,
910 			 ver_resp->hwrm_fw_bld_8b, ver_resp->hwrm_fw_rsvd_8b);
911 
912 		snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
913 			 ver_resp->mgmt_fw_maj_8b, ver_resp->mgmt_fw_min_8b,
914 			 ver_resp->mgmt_fw_bld_8b, ver_resp->mgmt_fw_rsvd_8b);
915 
916 		snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
917 			 ver_resp->roce_fw_maj_8b, ver_resp->roce_fw_min_8b,
918 			 ver_resp->roce_fw_bld_8b, ver_resp->roce_fw_rsvd_8b);
919 	}
920 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
921 			      DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, mgmt_ver);
922 	if (rc)
923 		return rc;
924 
925 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
926 			      DEVLINK_INFO_VERSION_GENERIC_FW_MGMT_API,
927 			      bp->hwrm_ver_supp);
928 	if (rc)
929 		return rc;
930 
931 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
932 			      DEVLINK_INFO_VERSION_GENERIC_FW_NCSI, ncsi_ver);
933 	if (rc)
934 		return rc;
935 
936 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_RUNNING,
937 			      DEVLINK_INFO_VERSION_GENERIC_FW_ROCE, roce_ver);
938 	if (rc)
939 		return rc;
940 
941 	rc = bnxt_hwrm_nvm_get_dev_info(bp, &nvm_dev_info);
942 	if (rc ||
943 	    !(nvm_dev_info.flags & NVM_GET_DEV_INFO_RESP_FLAGS_FW_VER_VALID)) {
944 		if (!bnxt_get_pkginfo(bp->dev, buf, sizeof(buf)))
945 			return bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
946 						DEVLINK_INFO_VERSION_GENERIC_FW,
947 						buf);
948 		return 0;
949 	}
950 
951 	buf[0] = 0;
952 	strncat(buf, nvm_dev_info.pkg_name, HWRM_FW_VER_STR_LEN);
953 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
954 			      DEVLINK_INFO_VERSION_GENERIC_FW, buf);
955 	if (rc)
956 		return rc;
957 
958 	snprintf(mgmt_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
959 		 nvm_dev_info.hwrm_fw_major, nvm_dev_info.hwrm_fw_minor,
960 		 nvm_dev_info.hwrm_fw_build, nvm_dev_info.hwrm_fw_patch);
961 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
962 			      DEVLINK_INFO_VERSION_GENERIC_FW_MGMT, mgmt_ver);
963 	if (rc)
964 		return rc;
965 
966 	snprintf(ncsi_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
967 		 nvm_dev_info.mgmt_fw_major, nvm_dev_info.mgmt_fw_minor,
968 		 nvm_dev_info.mgmt_fw_build, nvm_dev_info.mgmt_fw_patch);
969 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
970 			      DEVLINK_INFO_VERSION_GENERIC_FW_NCSI, ncsi_ver);
971 	if (rc)
972 		return rc;
973 
974 	snprintf(roce_ver, FW_VER_STR_LEN, "%d.%d.%d.%d",
975 		 nvm_dev_info.roce_fw_major, nvm_dev_info.roce_fw_minor,
976 		 nvm_dev_info.roce_fw_build, nvm_dev_info.roce_fw_patch);
977 	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
978 			      DEVLINK_INFO_VERSION_GENERIC_FW_ROCE, roce_ver);
979 	if (rc)
980 		return rc;
981 
982 	rc = bnxt_dl_livepatch_info_put(bp, req, BNXT_FW_SRT_PATCH);
983 	if (rc)
984 		return rc;
985 	return bnxt_dl_livepatch_info_put(bp, req, BNXT_FW_CRT_PATCH);
986 
987 }
988 
989 static int bnxt_hwrm_nvm_req(struct bnxt *bp, u32 param_id, void *msg,
990 			     union devlink_param_value *val)
991 {
992 	struct hwrm_nvm_get_variable_input *req = msg;
993 	struct bnxt_dl_nvm_param nvm_param;
994 	struct hwrm_err_output *resp;
995 	union bnxt_nvm_data *data;
996 	dma_addr_t data_dma_addr;
997 	int idx = 0, rc, i;
998 
999 	/* Get/Set NVM CFG parameter is supported only on PFs */
1000 	if (BNXT_VF(bp)) {
1001 		hwrm_req_drop(bp, req);
1002 		return -EPERM;
1003 	}
1004 
1005 	for (i = 0; i < ARRAY_SIZE(nvm_params); i++) {
1006 		if (nvm_params[i].id == param_id) {
1007 			nvm_param = nvm_params[i];
1008 			break;
1009 		}
1010 	}
1011 
1012 	if (i == ARRAY_SIZE(nvm_params)) {
1013 		hwrm_req_drop(bp, req);
1014 		return -EOPNOTSUPP;
1015 	}
1016 
1017 	if (nvm_param.dir_type == BNXT_NVM_PORT_CFG)
1018 		idx = bp->pf.port_id;
1019 	else if (nvm_param.dir_type == BNXT_NVM_FUNC_CFG)
1020 		idx = bp->pf.fw_fid - BNXT_FIRST_PF_FID;
1021 
1022 	data = hwrm_req_dma_slice(bp, req, sizeof(*data), &data_dma_addr);
1023 
1024 	if (!data) {
1025 		hwrm_req_drop(bp, req);
1026 		return -ENOMEM;
1027 	}
1028 
1029 	req->dest_data_addr = cpu_to_le64(data_dma_addr);
1030 	req->data_len = cpu_to_le16(nvm_param.nvm_num_bits);
1031 	req->option_num = cpu_to_le16(nvm_param.offset);
1032 	req->index_0 = cpu_to_le16(idx);
1033 	if (idx)
1034 		req->dimensions = cpu_to_le16(1);
1035 
1036 	resp = hwrm_req_hold(bp, req);
1037 	if (req->req_type == cpu_to_le16(HWRM_NVM_SET_VARIABLE)) {
1038 		bnxt_copy_to_nvm_data(data, val, nvm_param.nvm_num_bits,
1039 				      nvm_param.dl_num_bytes);
1040 		rc = hwrm_req_send(bp, msg);
1041 	} else {
1042 		rc = hwrm_req_send_silent(bp, msg);
1043 		if (!rc) {
1044 			bnxt_copy_from_nvm_data(val, data,
1045 						nvm_param.nvm_num_bits,
1046 						nvm_param.dl_num_bytes);
1047 		} else {
1048 			if (resp->cmd_err ==
1049 				NVM_GET_VARIABLE_CMD_ERR_CODE_VAR_NOT_EXIST)
1050 				rc = -EOPNOTSUPP;
1051 		}
1052 	}
1053 	hwrm_req_drop(bp, req);
1054 	if (rc == -EACCES)
1055 		netdev_err(bp->dev, "PF does not have admin privileges to modify NVM config\n");
1056 	return rc;
1057 }
1058 
1059 static int bnxt_dl_nvm_param_get(struct devlink *dl, u32 id,
1060 				 struct devlink_param_gset_ctx *ctx)
1061 {
1062 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1063 	struct hwrm_nvm_get_variable_input *req;
1064 	int rc;
1065 
1066 	rc = hwrm_req_init(bp, req, HWRM_NVM_GET_VARIABLE);
1067 	if (rc)
1068 		return rc;
1069 
1070 	rc = bnxt_hwrm_nvm_req(bp, id, req, &ctx->val);
1071 	if (!rc && id == BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK)
1072 		ctx->val.vbool = !ctx->val.vbool;
1073 
1074 	return rc;
1075 }
1076 
1077 static int bnxt_dl_nvm_param_set(struct devlink *dl, u32 id,
1078 				 struct devlink_param_gset_ctx *ctx)
1079 {
1080 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1081 	struct hwrm_nvm_set_variable_input *req;
1082 	int rc;
1083 
1084 	rc = hwrm_req_init(bp, req, HWRM_NVM_SET_VARIABLE);
1085 	if (rc)
1086 		return rc;
1087 
1088 	if (id == BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK)
1089 		ctx->val.vbool = !ctx->val.vbool;
1090 
1091 	return bnxt_hwrm_nvm_req(bp, id, req, &ctx->val);
1092 }
1093 
1094 static int bnxt_dl_msix_validate(struct devlink *dl, u32 id,
1095 				 union devlink_param_value val,
1096 				 struct netlink_ext_ack *extack)
1097 {
1098 	int max_val = -1;
1099 
1100 	if (id == DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX)
1101 		max_val = BNXT_MSIX_VEC_MAX;
1102 
1103 	if (id == DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN)
1104 		max_val = BNXT_MSIX_VEC_MIN_MAX;
1105 
1106 	if (val.vu32 > max_val) {
1107 		NL_SET_ERR_MSG_MOD(extack, "MSIX value is exceeding the range");
1108 		return -EINVAL;
1109 	}
1110 
1111 	return 0;
1112 }
1113 
1114 static int bnxt_remote_dev_reset_get(struct devlink *dl, u32 id,
1115 				     struct devlink_param_gset_ctx *ctx)
1116 {
1117 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1118 
1119 	if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
1120 		return -EOPNOTSUPP;
1121 
1122 	ctx->val.vbool = bnxt_dl_get_remote_reset(dl);
1123 	return 0;
1124 }
1125 
1126 static int bnxt_remote_dev_reset_set(struct devlink *dl, u32 id,
1127 				     struct devlink_param_gset_ctx *ctx)
1128 {
1129 	struct bnxt *bp = bnxt_get_bp_from_dl(dl);
1130 	int rc;
1131 
1132 	rc = bnxt_hwrm_remote_dev_reset_set(bp, ctx->val.vbool);
1133 	if (rc)
1134 		return rc;
1135 
1136 	bnxt_dl_set_remote_reset(dl, ctx->val.vbool);
1137 	return rc;
1138 }
1139 
1140 static const struct devlink_param bnxt_dl_params[] = {
1141 	DEVLINK_PARAM_GENERIC(ENABLE_SRIOV,
1142 			      BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1143 			      bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1144 			      NULL),
1145 	DEVLINK_PARAM_GENERIC(IGNORE_ARI,
1146 			      BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1147 			      bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1148 			      NULL),
1149 	DEVLINK_PARAM_GENERIC(MSIX_VEC_PER_PF_MAX,
1150 			      BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1151 			      bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1152 			      bnxt_dl_msix_validate),
1153 	DEVLINK_PARAM_GENERIC(MSIX_VEC_PER_PF_MIN,
1154 			      BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1155 			      bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1156 			      bnxt_dl_msix_validate),
1157 	DEVLINK_PARAM_DRIVER(BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK,
1158 			     "gre_ver_check", DEVLINK_PARAM_TYPE_BOOL,
1159 			     BIT(DEVLINK_PARAM_CMODE_PERMANENT),
1160 			     bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
1161 			     NULL),
1162 	/* keep REMOTE_DEV_RESET last, it is excluded based on caps */
1163 	DEVLINK_PARAM_GENERIC(ENABLE_REMOTE_DEV_RESET,
1164 			      BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1165 			      bnxt_remote_dev_reset_get,
1166 			      bnxt_remote_dev_reset_set, NULL),
1167 };
1168 
1169 static int bnxt_dl_params_register(struct bnxt *bp)
1170 {
1171 	int num_params = ARRAY_SIZE(bnxt_dl_params);
1172 	int rc;
1173 
1174 	if (bp->hwrm_spec_code < 0x10600)
1175 		return 0;
1176 
1177 	if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
1178 		num_params--;
1179 
1180 	rc = devlink_params_register(bp->dl, bnxt_dl_params, num_params);
1181 	if (rc)
1182 		netdev_warn(bp->dev, "devlink_params_register failed. rc=%d\n",
1183 			    rc);
1184 	return rc;
1185 }
1186 
1187 static void bnxt_dl_params_unregister(struct bnxt *bp)
1188 {
1189 	int num_params = ARRAY_SIZE(bnxt_dl_params);
1190 
1191 	if (bp->hwrm_spec_code < 0x10600)
1192 		return;
1193 
1194 	if (~bp->fw_cap & BNXT_FW_CAP_HOT_RESET_IF)
1195 		num_params--;
1196 
1197 	devlink_params_unregister(bp->dl, bnxt_dl_params, num_params);
1198 }
1199 
1200 int bnxt_dl_register(struct bnxt *bp)
1201 {
1202 	const struct devlink_ops *devlink_ops;
1203 	struct devlink_port_attrs attrs = {};
1204 	struct bnxt_dl *bp_dl;
1205 	struct devlink *dl;
1206 	int rc;
1207 
1208 	if (BNXT_PF(bp))
1209 		devlink_ops = &bnxt_dl_ops;
1210 	else
1211 		devlink_ops = &bnxt_vf_dl_ops;
1212 
1213 	dl = devlink_alloc(devlink_ops, sizeof(struct bnxt_dl), &bp->pdev->dev);
1214 	if (!dl) {
1215 		netdev_warn(bp->dev, "devlink_alloc failed\n");
1216 		return -ENOMEM;
1217 	}
1218 
1219 	bp->dl = dl;
1220 	bp_dl = devlink_priv(dl);
1221 	bp_dl->bp = bp;
1222 	bnxt_dl_set_remote_reset(dl, true);
1223 
1224 	/* Add switchdev eswitch mode setting, if SRIOV supported */
1225 	if (pci_find_ext_capability(bp->pdev, PCI_EXT_CAP_ID_SRIOV) &&
1226 	    bp->hwrm_spec_code > 0x10803)
1227 		bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
1228 
1229 	if (!BNXT_PF(bp))
1230 		goto out;
1231 
1232 	attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
1233 	attrs.phys.port_number = bp->pf.port_id;
1234 	memcpy(attrs.switch_id.id, bp->dsn, sizeof(bp->dsn));
1235 	attrs.switch_id.id_len = sizeof(bp->dsn);
1236 	devlink_port_attrs_set(&bp->dl_port, &attrs);
1237 	rc = devlink_port_register(dl, &bp->dl_port, bp->pf.port_id);
1238 	if (rc) {
1239 		netdev_err(bp->dev, "devlink_port_register failed\n");
1240 		goto err_dl_free;
1241 	}
1242 
1243 	rc = bnxt_dl_params_register(bp);
1244 	if (rc)
1245 		goto err_dl_port_unreg;
1246 
1247 out:
1248 	devlink_register(dl);
1249 	return 0;
1250 
1251 err_dl_port_unreg:
1252 	devlink_port_unregister(&bp->dl_port);
1253 err_dl_free:
1254 	devlink_free(dl);
1255 	return rc;
1256 }
1257 
1258 void bnxt_dl_unregister(struct bnxt *bp)
1259 {
1260 	struct devlink *dl = bp->dl;
1261 
1262 	devlink_unregister(dl);
1263 	if (BNXT_PF(bp)) {
1264 		bnxt_dl_params_unregister(bp);
1265 		devlink_port_unregister(&bp->dl_port);
1266 	}
1267 	devlink_free(dl);
1268 }
1269