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 <net/devlink.h>
13 #include "bnxt_hsi.h"
14 #include "bnxt.h"
15 #include "bnxt_vfr.h"
16 #include "bnxt_devlink.h"
17
bnxt_fw_reporter_diagnose(struct devlink_health_reporter * reporter,struct devlink_fmsg * fmsg)18 static int bnxt_fw_reporter_diagnose(struct devlink_health_reporter *reporter,
19 struct devlink_fmsg *fmsg)
20 {
21 struct bnxt *bp = devlink_health_reporter_priv(reporter);
22 struct bnxt_fw_health *health = bp->fw_health;
23 u32 val, health_status;
24 int rc;
25
26 if (!health || test_bit(BNXT_STATE_IN_FW_RESET, &bp->state))
27 return 0;
28
29 val = bnxt_fw_health_readl(bp, BNXT_FW_HEALTH_REG);
30 health_status = val & 0xffff;
31
32 if (health_status < BNXT_FW_STATUS_HEALTHY) {
33 rc = devlink_fmsg_string_pair_put(fmsg, "Description",
34 "Not yet completed initialization");
35 if (rc)
36 return rc;
37 } else if (health_status > BNXT_FW_STATUS_HEALTHY) {
38 rc = devlink_fmsg_string_pair_put(fmsg, "Description",
39 "Encountered fatal error and cannot recover");
40 if (rc)
41 return rc;
42 }
43
44 if (val >> 16) {
45 rc = devlink_fmsg_u32_pair_put(fmsg, "Error code", val >> 16);
46 if (rc)
47 return rc;
48 }
49
50 val = bnxt_fw_health_readl(bp, BNXT_FW_RESET_CNT_REG);
51 rc = devlink_fmsg_u32_pair_put(fmsg, "Reset count", val);
52 if (rc)
53 return rc;
54
55 return 0;
56 }
57
58 static const struct devlink_health_reporter_ops bnxt_dl_fw_reporter_ops = {
59 .name = "fw",
60 .diagnose = bnxt_fw_reporter_diagnose,
61 };
62
bnxt_fw_reset_recover(struct devlink_health_reporter * reporter,void * priv_ctx)63 static int bnxt_fw_reset_recover(struct devlink_health_reporter *reporter,
64 void *priv_ctx)
65 {
66 struct bnxt *bp = devlink_health_reporter_priv(reporter);
67
68 if (!priv_ctx)
69 return -EOPNOTSUPP;
70
71 bnxt_fw_reset(bp);
72 return 0;
73 }
74
75 static const
76 struct devlink_health_reporter_ops bnxt_dl_fw_reset_reporter_ops = {
77 .name = "fw_reset",
78 .recover = bnxt_fw_reset_recover,
79 };
80
bnxt_fw_fatal_recover(struct devlink_health_reporter * reporter,void * priv_ctx)81 static int bnxt_fw_fatal_recover(struct devlink_health_reporter *reporter,
82 void *priv_ctx)
83 {
84 struct bnxt *bp = devlink_health_reporter_priv(reporter);
85 struct bnxt_fw_reporter_ctx *fw_reporter_ctx = priv_ctx;
86 unsigned long event;
87
88 if (!priv_ctx)
89 return -EOPNOTSUPP;
90
91 event = fw_reporter_ctx->sp_event;
92 if (event == BNXT_FW_RESET_NOTIFY_SP_EVENT)
93 bnxt_fw_reset(bp);
94 else if (event == BNXT_FW_EXCEPTION_SP_EVENT)
95 bnxt_fw_exception(bp);
96
97 return 0;
98 }
99
100 static const
101 struct devlink_health_reporter_ops bnxt_dl_fw_fatal_reporter_ops = {
102 .name = "fw_fatal",
103 .recover = bnxt_fw_fatal_recover,
104 };
105
bnxt_dl_fw_reporters_create(struct bnxt * bp)106 static void bnxt_dl_fw_reporters_create(struct bnxt *bp)
107 {
108 struct bnxt_fw_health *health = bp->fw_health;
109
110 if (!health)
111 return;
112
113 health->fw_reporter =
114 devlink_health_reporter_create(bp->dl, &bnxt_dl_fw_reporter_ops,
115 0, false, bp);
116 if (IS_ERR(health->fw_reporter)) {
117 netdev_warn(bp->dev, "Failed to create FW health reporter, rc = %ld\n",
118 PTR_ERR(health->fw_reporter));
119 health->fw_reporter = NULL;
120 }
121
122 health->fw_reset_reporter =
123 devlink_health_reporter_create(bp->dl,
124 &bnxt_dl_fw_reset_reporter_ops,
125 0, true, bp);
126 if (IS_ERR(health->fw_reset_reporter)) {
127 netdev_warn(bp->dev, "Failed to create FW fatal health reporter, rc = %ld\n",
128 PTR_ERR(health->fw_reset_reporter));
129 health->fw_reset_reporter = NULL;
130 }
131
132 health->fw_fatal_reporter =
133 devlink_health_reporter_create(bp->dl,
134 &bnxt_dl_fw_fatal_reporter_ops,
135 0, true, bp);
136 if (IS_ERR(health->fw_fatal_reporter)) {
137 netdev_warn(bp->dev, "Failed to create FW fatal health reporter, rc = %ld\n",
138 PTR_ERR(health->fw_fatal_reporter));
139 health->fw_fatal_reporter = NULL;
140 }
141 }
142
bnxt_dl_fw_reporters_destroy(struct bnxt * bp)143 static void bnxt_dl_fw_reporters_destroy(struct bnxt *bp)
144 {
145 struct bnxt_fw_health *health = bp->fw_health;
146
147 if (!health)
148 return;
149
150 if (health->fw_reporter)
151 devlink_health_reporter_destroy(health->fw_reporter);
152
153 if (health->fw_reset_reporter)
154 devlink_health_reporter_destroy(health->fw_reset_reporter);
155
156 if (health->fw_fatal_reporter)
157 devlink_health_reporter_destroy(health->fw_fatal_reporter);
158 }
159
bnxt_devlink_health_report(struct bnxt * bp,unsigned long event)160 void bnxt_devlink_health_report(struct bnxt *bp, unsigned long event)
161 {
162 struct bnxt_fw_health *fw_health = bp->fw_health;
163 struct bnxt_fw_reporter_ctx fw_reporter_ctx;
164
165 if (!fw_health)
166 return;
167
168 fw_reporter_ctx.sp_event = event;
169 switch (event) {
170 case BNXT_FW_RESET_NOTIFY_SP_EVENT:
171 if (test_bit(BNXT_STATE_FW_FATAL_COND, &bp->state)) {
172 if (!fw_health->fw_fatal_reporter)
173 return;
174
175 devlink_health_report(fw_health->fw_fatal_reporter,
176 "FW fatal async event received",
177 &fw_reporter_ctx);
178 return;
179 }
180 if (!fw_health->fw_reset_reporter)
181 return;
182
183 devlink_health_report(fw_health->fw_reset_reporter,
184 "FW non-fatal reset event received",
185 &fw_reporter_ctx);
186 return;
187
188 case BNXT_FW_EXCEPTION_SP_EVENT:
189 if (!fw_health->fw_fatal_reporter)
190 return;
191
192 devlink_health_report(fw_health->fw_fatal_reporter,
193 "FW fatal error reported",
194 &fw_reporter_ctx);
195 return;
196 }
197 }
198
199 static const struct devlink_ops bnxt_dl_ops = {
200 #ifdef CONFIG_BNXT_SRIOV
201 .eswitch_mode_set = bnxt_dl_eswitch_mode_set,
202 .eswitch_mode_get = bnxt_dl_eswitch_mode_get,
203 #endif /* CONFIG_BNXT_SRIOV */
204 };
205
206 enum bnxt_dl_param_id {
207 BNXT_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
208 BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK,
209 };
210
211 static const struct bnxt_dl_nvm_param nvm_params[] = {
212 {DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV, NVM_OFF_ENABLE_SRIOV,
213 BNXT_NVM_SHARED_CFG, 1, 1},
214 {DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI, NVM_OFF_IGNORE_ARI,
215 BNXT_NVM_SHARED_CFG, 1, 1},
216 {DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX,
217 NVM_OFF_MSIX_VEC_PER_PF_MAX, BNXT_NVM_SHARED_CFG, 10, 4},
218 {DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN,
219 NVM_OFF_MSIX_VEC_PER_PF_MIN, BNXT_NVM_SHARED_CFG, 7, 4},
220 {BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK, NVM_OFF_DIS_GRE_VER_CHECK,
221 BNXT_NVM_SHARED_CFG, 1, 1},
222 };
223
224 union bnxt_nvm_data {
225 u8 val8;
226 __le32 val32;
227 };
228
bnxt_copy_to_nvm_data(union bnxt_nvm_data * dst,union devlink_param_value * src,int nvm_num_bits,int dl_num_bytes)229 static void bnxt_copy_to_nvm_data(union bnxt_nvm_data *dst,
230 union devlink_param_value *src,
231 int nvm_num_bits, int dl_num_bytes)
232 {
233 u32 val32 = 0;
234
235 if (nvm_num_bits == 1) {
236 dst->val8 = src->vbool;
237 return;
238 }
239 if (dl_num_bytes == 4)
240 val32 = src->vu32;
241 else if (dl_num_bytes == 2)
242 val32 = (u32)src->vu16;
243 else if (dl_num_bytes == 1)
244 val32 = (u32)src->vu8;
245 dst->val32 = cpu_to_le32(val32);
246 }
247
bnxt_copy_from_nvm_data(union devlink_param_value * dst,union bnxt_nvm_data * src,int nvm_num_bits,int dl_num_bytes)248 static void bnxt_copy_from_nvm_data(union devlink_param_value *dst,
249 union bnxt_nvm_data *src,
250 int nvm_num_bits, int dl_num_bytes)
251 {
252 u32 val32;
253
254 if (nvm_num_bits == 1) {
255 dst->vbool = src->val8;
256 return;
257 }
258 val32 = le32_to_cpu(src->val32);
259 if (dl_num_bytes == 4)
260 dst->vu32 = val32;
261 else if (dl_num_bytes == 2)
262 dst->vu16 = (u16)val32;
263 else if (dl_num_bytes == 1)
264 dst->vu8 = (u8)val32;
265 }
266
bnxt_hwrm_nvm_req(struct bnxt * bp,u32 param_id,void * msg,int msg_len,union devlink_param_value * val)267 static int bnxt_hwrm_nvm_req(struct bnxt *bp, u32 param_id, void *msg,
268 int msg_len, union devlink_param_value *val)
269 {
270 struct hwrm_nvm_get_variable_input *req = msg;
271 struct bnxt_dl_nvm_param nvm_param;
272 union bnxt_nvm_data *data;
273 dma_addr_t data_dma_addr;
274 int idx = 0, rc, i;
275
276 /* Get/Set NVM CFG parameter is supported only on PFs */
277 if (BNXT_VF(bp))
278 return -EPERM;
279
280 for (i = 0; i < ARRAY_SIZE(nvm_params); i++) {
281 if (nvm_params[i].id == param_id) {
282 nvm_param = nvm_params[i];
283 break;
284 }
285 }
286
287 if (i == ARRAY_SIZE(nvm_params))
288 return -EOPNOTSUPP;
289
290 if (nvm_param.dir_type == BNXT_NVM_PORT_CFG)
291 idx = bp->pf.port_id;
292 else if (nvm_param.dir_type == BNXT_NVM_FUNC_CFG)
293 idx = bp->pf.fw_fid - BNXT_FIRST_PF_FID;
294
295 data = dma_alloc_coherent(&bp->pdev->dev, sizeof(*data),
296 &data_dma_addr, GFP_KERNEL);
297 if (!data)
298 return -ENOMEM;
299
300 req->dest_data_addr = cpu_to_le64(data_dma_addr);
301 req->data_len = cpu_to_le16(nvm_param.nvm_num_bits);
302 req->option_num = cpu_to_le16(nvm_param.offset);
303 req->index_0 = cpu_to_le16(idx);
304 if (idx)
305 req->dimensions = cpu_to_le16(1);
306
307 if (req->req_type == cpu_to_le16(HWRM_NVM_SET_VARIABLE)) {
308 bnxt_copy_to_nvm_data(data, val, nvm_param.nvm_num_bits,
309 nvm_param.dl_num_bytes);
310 rc = hwrm_send_message(bp, msg, msg_len, HWRM_CMD_TIMEOUT);
311 } else {
312 rc = hwrm_send_message_silent(bp, msg, msg_len,
313 HWRM_CMD_TIMEOUT);
314 if (!rc)
315 bnxt_copy_from_nvm_data(val, data,
316 nvm_param.nvm_num_bits,
317 nvm_param.dl_num_bytes);
318 }
319 dma_free_coherent(&bp->pdev->dev, sizeof(*data), data, data_dma_addr);
320 if (rc == -EACCES)
321 netdev_err(bp->dev, "PF does not have admin privileges to modify NVM config\n");
322 return rc;
323 }
324
bnxt_dl_nvm_param_get(struct devlink * dl,u32 id,struct devlink_param_gset_ctx * ctx)325 static int bnxt_dl_nvm_param_get(struct devlink *dl, u32 id,
326 struct devlink_param_gset_ctx *ctx)
327 {
328 struct hwrm_nvm_get_variable_input req = {0};
329 struct bnxt *bp = bnxt_get_bp_from_dl(dl);
330 int rc;
331
332 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_NVM_GET_VARIABLE, -1, -1);
333 rc = bnxt_hwrm_nvm_req(bp, id, &req, sizeof(req), &ctx->val);
334 if (!rc)
335 if (id == BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK)
336 ctx->val.vbool = !ctx->val.vbool;
337
338 return rc;
339 }
340
bnxt_dl_nvm_param_set(struct devlink * dl,u32 id,struct devlink_param_gset_ctx * ctx)341 static int bnxt_dl_nvm_param_set(struct devlink *dl, u32 id,
342 struct devlink_param_gset_ctx *ctx)
343 {
344 struct hwrm_nvm_set_variable_input req = {0};
345 struct bnxt *bp = bnxt_get_bp_from_dl(dl);
346
347 bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_NVM_SET_VARIABLE, -1, -1);
348
349 if (id == BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK)
350 ctx->val.vbool = !ctx->val.vbool;
351
352 return bnxt_hwrm_nvm_req(bp, id, &req, sizeof(req), &ctx->val);
353 }
354
bnxt_dl_msix_validate(struct devlink * dl,u32 id,union devlink_param_value val,struct netlink_ext_ack * extack)355 static int bnxt_dl_msix_validate(struct devlink *dl, u32 id,
356 union devlink_param_value val,
357 struct netlink_ext_ack *extack)
358 {
359 int max_val = -1;
360
361 if (id == DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX)
362 max_val = BNXT_MSIX_VEC_MAX;
363
364 if (id == DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN)
365 max_val = BNXT_MSIX_VEC_MIN_MAX;
366
367 if (val.vu32 > max_val) {
368 NL_SET_ERR_MSG_MOD(extack, "MSIX value is exceeding the range");
369 return -EINVAL;
370 }
371
372 return 0;
373 }
374
375 static const struct devlink_param bnxt_dl_params[] = {
376 DEVLINK_PARAM_GENERIC(ENABLE_SRIOV,
377 BIT(DEVLINK_PARAM_CMODE_PERMANENT),
378 bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
379 NULL),
380 DEVLINK_PARAM_GENERIC(IGNORE_ARI,
381 BIT(DEVLINK_PARAM_CMODE_PERMANENT),
382 bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
383 NULL),
384 DEVLINK_PARAM_GENERIC(MSIX_VEC_PER_PF_MAX,
385 BIT(DEVLINK_PARAM_CMODE_PERMANENT),
386 bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
387 bnxt_dl_msix_validate),
388 DEVLINK_PARAM_GENERIC(MSIX_VEC_PER_PF_MIN,
389 BIT(DEVLINK_PARAM_CMODE_PERMANENT),
390 bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
391 bnxt_dl_msix_validate),
392 DEVLINK_PARAM_DRIVER(BNXT_DEVLINK_PARAM_ID_GRE_VER_CHECK,
393 "gre_ver_check", DEVLINK_PARAM_TYPE_BOOL,
394 BIT(DEVLINK_PARAM_CMODE_PERMANENT),
395 bnxt_dl_nvm_param_get, bnxt_dl_nvm_param_set,
396 NULL),
397 };
398
399 static const struct devlink_param bnxt_dl_port_params[] = {
400 };
401
bnxt_dl_register(struct bnxt * bp)402 int bnxt_dl_register(struct bnxt *bp)
403 {
404 struct devlink *dl;
405 int rc;
406
407 if (bp->hwrm_spec_code < 0x10600) {
408 netdev_warn(bp->dev, "Firmware does not support NVM params");
409 return -ENOTSUPP;
410 }
411
412 dl = devlink_alloc(&bnxt_dl_ops, sizeof(struct bnxt_dl));
413 if (!dl) {
414 netdev_warn(bp->dev, "devlink_alloc failed");
415 return -ENOMEM;
416 }
417
418 bnxt_link_bp_to_dl(bp, dl);
419
420 /* Add switchdev eswitch mode setting, if SRIOV supported */
421 if (pci_find_ext_capability(bp->pdev, PCI_EXT_CAP_ID_SRIOV) &&
422 bp->hwrm_spec_code > 0x10803)
423 bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
424
425 rc = devlink_register(dl, &bp->pdev->dev);
426 if (rc) {
427 netdev_warn(bp->dev, "devlink_register failed. rc=%d", rc);
428 goto err_dl_free;
429 }
430
431 rc = devlink_params_register(dl, bnxt_dl_params,
432 ARRAY_SIZE(bnxt_dl_params));
433 if (rc) {
434 netdev_warn(bp->dev, "devlink_params_register failed. rc=%d",
435 rc);
436 goto err_dl_unreg;
437 }
438
439 devlink_port_attrs_set(&bp->dl_port, DEVLINK_PORT_FLAVOUR_PHYSICAL,
440 bp->pf.port_id, false, 0,
441 bp->switch_id, sizeof(bp->switch_id));
442 rc = devlink_port_register(dl, &bp->dl_port, bp->pf.port_id);
443 if (rc) {
444 netdev_err(bp->dev, "devlink_port_register failed");
445 goto err_dl_param_unreg;
446 }
447 devlink_port_type_eth_set(&bp->dl_port, bp->dev);
448
449 rc = devlink_port_params_register(&bp->dl_port, bnxt_dl_port_params,
450 ARRAY_SIZE(bnxt_dl_port_params));
451 if (rc) {
452 netdev_err(bp->dev, "devlink_port_params_register failed");
453 goto err_dl_port_unreg;
454 }
455
456 devlink_params_publish(dl);
457
458 bnxt_dl_fw_reporters_create(bp);
459
460 return 0;
461
462 err_dl_port_unreg:
463 devlink_port_unregister(&bp->dl_port);
464 err_dl_param_unreg:
465 devlink_params_unregister(dl, bnxt_dl_params,
466 ARRAY_SIZE(bnxt_dl_params));
467 err_dl_unreg:
468 devlink_unregister(dl);
469 err_dl_free:
470 bnxt_link_bp_to_dl(bp, NULL);
471 devlink_free(dl);
472 return rc;
473 }
474
bnxt_dl_unregister(struct bnxt * bp)475 void bnxt_dl_unregister(struct bnxt *bp)
476 {
477 struct devlink *dl = bp->dl;
478
479 if (!dl)
480 return;
481
482 bnxt_dl_fw_reporters_destroy(bp);
483 devlink_port_params_unregister(&bp->dl_port, bnxt_dl_port_params,
484 ARRAY_SIZE(bnxt_dl_port_params));
485 devlink_port_unregister(&bp->dl_port);
486 devlink_params_unregister(dl, bnxt_dl_params,
487 ARRAY_SIZE(bnxt_dl_params));
488 devlink_unregister(dl);
489 devlink_free(dl);
490 }
491
