projects/linux·blob master · refs

558 lines · 15.4 KiB

1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (c) 2025, Intel Corporation. */
3
4#include "ixgbe.h"
5#include "devlink.h"
6#include "ixgbe_fw_update.h"
7
8struct ixgbe_info_ctx {
9 char buf[128];
10 struct ixgbe_orom_info pending_orom;
11 struct ixgbe_nvm_info pending_nvm;
12 struct ixgbe_netlist_info pending_netlist;
13 struct ixgbe_hw_dev_caps dev_caps;
14};
15
16enum ixgbe_devlink_version_type {
17 IXGBE_DL_VERSION_RUNNING,
18 IXGBE_DL_VERSION_STORED
19};
20
21static void ixgbe_info_get_dsn(struct ixgbe_adapter *adapter,
22 struct ixgbe_info_ctx *ctx)
23{
24 u8 dsn[8];
25
26 /* Copy the DSN into an array in Big Endian format */
27 put_unaligned_be64(pci_get_dsn(adapter->pdev), dsn);
28
29 snprintf(ctx->buf, sizeof(ctx->buf), "%8phD", dsn);
30}
31
32static void ixgbe_info_orom_ver(struct ixgbe_adapter *adapter,
33 struct ixgbe_info_ctx *ctx,
34 enum ixgbe_devlink_version_type type)
35{
36 struct ixgbe_hw *hw = &adapter->hw;
37 struct ixgbe_nvm_version nvm_ver;
38
39 ctx->buf[0] = '\0';
40
41 if (hw->mac.type == ixgbe_mac_e610) {
42 struct ixgbe_orom_info *orom = &adapter->hw.flash.orom;
43
44 if (type == IXGBE_DL_VERSION_STORED &&
45 ctx->dev_caps.common_cap.nvm_update_pending_orom)
46 orom = &ctx->pending_orom;
47
48 snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
49 orom->major, orom->build, orom->patch);
50 return;
51 }
52
53 ixgbe_get_oem_prod_version(hw, &nvm_ver);
54 if (nvm_ver.oem_valid) {
55 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%x.%x",
56 nvm_ver.oem_major, nvm_ver.oem_minor,
57 nvm_ver.oem_release);
58
59 return;
60 }
61
62 ixgbe_get_orom_version(hw, &nvm_ver);
63 if (nvm_ver.or_valid)
64 snprintf(ctx->buf, sizeof(ctx->buf), "%d.%d.%d",
65 nvm_ver.or_major, nvm_ver.or_build, nvm_ver.or_patch);
66}
67
68static void ixgbe_info_eetrack(struct ixgbe_adapter *adapter,
69 struct ixgbe_info_ctx *ctx,
70 enum ixgbe_devlink_version_type type)
71{
72 struct ixgbe_hw *hw = &adapter->hw;
73 struct ixgbe_nvm_version nvm_ver;
74
75 if (hw->mac.type == ixgbe_mac_e610) {
76 u32 eetrack = hw->flash.nvm.eetrack;
77
78 if (type == IXGBE_DL_VERSION_STORED &&
79 ctx->dev_caps.common_cap.nvm_update_pending_nvm)
80 eetrack = ctx->pending_nvm.eetrack;
81
82 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", eetrack);
83 return;
84 }
85
86 ixgbe_get_oem_prod_version(hw, &nvm_ver);
87
88 /* No ETRACK version for OEM */
89 if (nvm_ver.oem_valid) {
90 ctx->buf[0] = '\0';
91 return;
92 }
93
94 ixgbe_get_etk_id(hw, &nvm_ver);
95 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", nvm_ver.etk_id);
96}
97
98static void ixgbe_info_fw_api(struct ixgbe_adapter *adapter,
99 struct ixgbe_info_ctx *ctx)
100{
101 struct ixgbe_hw *hw = &adapter->hw;
102
103 snprintf(ctx->buf, sizeof(ctx->buf), "%u.%u.%u",
104 hw->api_maj_ver, hw->api_min_ver, hw->api_patch);
105}
106
107static void ixgbe_info_fw_build(struct ixgbe_adapter *adapter,
108 struct ixgbe_info_ctx *ctx)
109{
110 struct ixgbe_hw *hw = &adapter->hw;
111
112 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", hw->fw_build);
113}
114
115static void ixgbe_info_fw_srev(struct ixgbe_adapter *adapter,
116 struct ixgbe_info_ctx *ctx,
117 enum ixgbe_devlink_version_type type)
118{
119 struct ixgbe_nvm_info *nvm = &adapter->hw.flash.nvm;
120
121 if (type == IXGBE_DL_VERSION_STORED &&
122 ctx->dev_caps.common_cap.nvm_update_pending_nvm)
123 nvm = &ctx->pending_nvm;
124
125 snprintf(ctx->buf, sizeof(ctx->buf), "%u", nvm->srev);
126}
127
128static void ixgbe_info_orom_srev(struct ixgbe_adapter *adapter,
129 struct ixgbe_info_ctx *ctx,
130 enum ixgbe_devlink_version_type type)
131{
132 struct ixgbe_orom_info *orom = &adapter->hw.flash.orom;
133
134 if (type == IXGBE_DL_VERSION_STORED &&
135 ctx->dev_caps.common_cap.nvm_update_pending_orom)
136 orom = &ctx->pending_orom;
137
138 snprintf(ctx->buf, sizeof(ctx->buf), "%u", orom->srev);
139}
140
141static void ixgbe_info_nvm_ver(struct ixgbe_adapter *adapter,
142 struct ixgbe_info_ctx *ctx,
143 enum ixgbe_devlink_version_type type)
144{
145 struct ixgbe_nvm_info *nvm = &adapter->hw.flash.nvm;
146
147 if (type == IXGBE_DL_VERSION_STORED &&
148 ctx->dev_caps.common_cap.nvm_update_pending_nvm)
149 nvm = &ctx->pending_nvm;
150
151 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%02x", nvm->major, nvm->minor);
152}
153
154static void ixgbe_info_netlist_ver(struct ixgbe_adapter *adapter,
155 struct ixgbe_info_ctx *ctx,
156 enum ixgbe_devlink_version_type type)
157{
158 struct ixgbe_netlist_info *netlist = &adapter->hw.flash.netlist;
159
160 if (type == IXGBE_DL_VERSION_STORED &&
161 ctx->dev_caps.common_cap.nvm_update_pending_netlist)
162 netlist = &ctx->pending_netlist;
163
164 /* The netlist version fields are BCD formatted */
165 snprintf(ctx->buf, sizeof(ctx->buf), "%x.%x.%x-%x.%x.%x",
166 netlist->major, netlist->minor,
167 netlist->type >> 16, netlist->type & 0xFFFF,
168 netlist->rev, netlist->cust_ver);
169}
170
171static void ixgbe_info_netlist_build(struct ixgbe_adapter *adapter,
172 struct ixgbe_info_ctx *ctx,
173 enum ixgbe_devlink_version_type type)
174{
175 struct ixgbe_netlist_info *netlist = &adapter->hw.flash.netlist;
176
177 if (type == IXGBE_DL_VERSION_STORED &&
178 ctx->dev_caps.common_cap.nvm_update_pending_netlist)
179 netlist = &ctx->pending_netlist;
180
181 snprintf(ctx->buf, sizeof(ctx->buf), "0x%08x", netlist->hash);
182}
183
184static int ixgbe_set_ctx_dev_caps(struct ixgbe_hw *hw,
185 struct ixgbe_info_ctx *ctx,
186 struct netlink_ext_ack *extack)
187{
188 bool *pending_orom, *pending_nvm, *pending_netlist;
189 int err;
190
191 err = ixgbe_discover_dev_caps(hw, &ctx->dev_caps);
192 if (err) {
193 NL_SET_ERR_MSG_MOD(extack,
194 "Unable to discover device capabilities");
195 return err;
196 }
197
198 pending_orom = &ctx->dev_caps.common_cap.nvm_update_pending_orom;
199 pending_nvm = &ctx->dev_caps.common_cap.nvm_update_pending_nvm;
200 pending_netlist = &ctx->dev_caps.common_cap.nvm_update_pending_netlist;
201
202 if (*pending_orom) {
203 err = ixgbe_get_inactive_orom_ver(hw, &ctx->pending_orom);
204 if (err)
205 *pending_orom = false;
206 }
207
208 if (*pending_nvm) {
209 err = ixgbe_get_inactive_nvm_ver(hw, &ctx->pending_nvm);
210 if (err)
211 *pending_nvm = false;
212 }
213
214 if (*pending_netlist) {
215 err = ixgbe_get_inactive_netlist_ver(hw, &ctx->pending_netlist);
216 if (err)
217 *pending_netlist = false;
218 }
219
220 return 0;
221}
222
223static int ixgbe_devlink_info_get_e610(struct ixgbe_adapter *adapter,
224 struct devlink_info_req *req,
225 struct ixgbe_info_ctx *ctx)
226{
227 int err;
228
229 ixgbe_info_fw_api(adapter, ctx);
230 err = devlink_info_version_running_put(req,
231 DEVLINK_INFO_VERSION_GENERIC_FW_MGMT_API,
232 ctx->buf);
233 if (err)
234 return err;
235
236 ixgbe_info_fw_build(adapter, ctx);
237 err = devlink_info_version_running_put(req, "fw.mgmt.build", ctx->buf);
238 if (err)
239 return err;
240
241 ixgbe_info_fw_srev(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
242 err = devlink_info_version_running_put(req, "fw.mgmt.srev", ctx->buf);
243 if (err)
244 return err;
245
246 ixgbe_info_orom_srev(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
247 err = devlink_info_version_running_put(req, "fw.undi.srev", ctx->buf);
248 if (err)
249 return err;
250
251 ixgbe_info_nvm_ver(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
252 err = devlink_info_version_running_put(req, "fw.psid.api", ctx->buf);
253 if (err)
254 return err;
255
256 ixgbe_info_netlist_ver(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
257 err = devlink_info_version_running_put(req, "fw.netlist", ctx->buf);
258 if (err)
259 return err;
260
261 ixgbe_info_netlist_build(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
262 return devlink_info_version_running_put(req, "fw.netlist.build",
263 ctx->buf);
264}
265
266static int
267ixgbe_devlink_pending_info_get_e610(struct ixgbe_adapter *adapter,
268 struct devlink_info_req *req,
269 struct ixgbe_info_ctx *ctx)
270{
271 int err;
272
273 ixgbe_info_orom_ver(adapter, ctx, IXGBE_DL_VERSION_STORED);
274 err = devlink_info_version_stored_put(req,
275 DEVLINK_INFO_VERSION_GENERIC_FW_UNDI,
276 ctx->buf);
277 if (err)
278 return err;
279
280 ixgbe_info_eetrack(adapter, ctx, IXGBE_DL_VERSION_STORED);
281 err = devlink_info_version_stored_put(req,
282 DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID,
283 ctx->buf);
284 if (err)
285 return err;
286
287 ixgbe_info_fw_srev(adapter, ctx, IXGBE_DL_VERSION_STORED);
288 err = devlink_info_version_stored_put(req, "fw.mgmt.srev", ctx->buf);
289 if (err)
290 return err;
291
292 ixgbe_info_orom_srev(adapter, ctx, IXGBE_DL_VERSION_STORED);
293 err = devlink_info_version_stored_put(req, "fw.undi.srev", ctx->buf);
294 if (err)
295 return err;
296
297 ixgbe_info_nvm_ver(adapter, ctx, IXGBE_DL_VERSION_STORED);
298 err = devlink_info_version_stored_put(req, "fw.psid.api", ctx->buf);
299 if (err)
300 return err;
301
302 ixgbe_info_netlist_ver(adapter, ctx, IXGBE_DL_VERSION_STORED);
303 err = devlink_info_version_stored_put(req, "fw.netlist", ctx->buf);
304 if (err)
305 return err;
306
307 ixgbe_info_netlist_build(adapter, ctx, IXGBE_DL_VERSION_STORED);
308 return devlink_info_version_stored_put(req, "fw.netlist.build",
309 ctx->buf);
310}
311
312static int ixgbe_devlink_info_get(struct devlink *devlink,
313 struct devlink_info_req *req,
314 struct netlink_ext_ack *extack)
315{
316 struct ixgbe_adapter *adapter = devlink_priv(devlink);
317 struct ixgbe_hw *hw = &adapter->hw;
318 struct ixgbe_info_ctx *ctx;
319 int err;
320
321 ctx = kmalloc_obj(*ctx);
322 if (!ctx)
323 return -ENOMEM;
324
325 if (hw->mac.type == ixgbe_mac_e610)
326 ixgbe_refresh_fw_version(adapter);
327
328 ixgbe_info_get_dsn(adapter, ctx);
329 err = devlink_info_serial_number_put(req, ctx->buf);
330 if (err)
331 goto free_ctx;
332
333 err = hw->eeprom.ops.read_pba_string(hw, ctx->buf, sizeof(ctx->buf));
334 if (err)
335 goto free_ctx;
336
337 err = devlink_info_version_fixed_put(req,
338 DEVLINK_INFO_VERSION_GENERIC_BOARD_ID,
339 ctx->buf);
340 if (err)
341 goto free_ctx;
342
343 ixgbe_info_orom_ver(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
344 err = devlink_info_version_running_put(req,
345 DEVLINK_INFO_VERSION_GENERIC_FW_UNDI,
346 ctx->buf);
347 if (err)
348 goto free_ctx;
349
350 ixgbe_info_eetrack(adapter, ctx, IXGBE_DL_VERSION_RUNNING);
351 err = devlink_info_version_running_put(req,
352 DEVLINK_INFO_VERSION_GENERIC_FW_BUNDLE_ID,
353 ctx->buf);
354 if (err || hw->mac.type != ixgbe_mac_e610)
355 goto free_ctx;
356
357 err = ixgbe_set_ctx_dev_caps(hw, ctx, extack);
358 if (err)
359 goto free_ctx;
360
361 err = ixgbe_devlink_info_get_e610(adapter, req, ctx);
362 if (err)
363 goto free_ctx;
364
365 err = ixgbe_devlink_pending_info_get_e610(adapter, req, ctx);
366free_ctx:
367 kfree(ctx);
368 return err;
369}
370
371/**
372 * ixgbe_devlink_reload_empr_start - Start EMP reset to activate new firmware
373 * @devlink: pointer to the devlink instance to reload
374 * @netns_change: if true, the network namespace is changing
375 * @action: the action to perform. Must be DEVLINK_RELOAD_ACTION_FW_ACTIVATE
376 * @limit: limits on what reload should do, such as not resetting
377 * @extack: netlink extended ACK structure
378 *
379 * Allow user to activate new Embedded Management Processor firmware by
380 * issuing device specific EMP reset. Called in response to
381 * a DEVLINK_CMD_RELOAD with the DEVLINK_RELOAD_ACTION_FW_ACTIVATE.
382 *
383 * Note that teardown and rebuild of the driver state happens automatically as
384 * part of an interrupt and watchdog task. This is because all physical
385 * functions on the device must be able to reset when an EMP reset occurs from
386 * any source.
387 *
388 * Return: the exit code of the operation.
389 */
390static int ixgbe_devlink_reload_empr_start(struct devlink *devlink,
391 bool netns_change,
392 enum devlink_reload_action action,
393 enum devlink_reload_limit limit,
394 struct netlink_ext_ack *extack)
395{
396 struct ixgbe_adapter *adapter = devlink_priv(devlink);
397 struct ixgbe_hw *hw = &adapter->hw;
398 u8 pending;
399 int err;
400
401 if (hw->mac.type != ixgbe_mac_e610)
402 return -EOPNOTSUPP;
403
404 err = ixgbe_get_pending_updates(adapter, &pending, extack);
405 if (err)
406 return err;
407
408 /* Pending is a bitmask of which flash banks have a pending update,
409 * including the main NVM bank, the Option ROM bank, and the netlist
410 * bank. If any of these bits are set, then there is a pending update
411 * waiting to be activated.
412 */
413 if (!pending) {
414 NL_SET_ERR_MSG_MOD(extack, "No pending firmware update");
415 return -ECANCELED;
416 }
417
418 if (adapter->fw_emp_reset_disabled) {
419 NL_SET_ERR_MSG_MOD(extack,
420 "EMP reset is not available. To activate firmware, a reboot or power cycle is needed");
421 return -ECANCELED;
422 }
423
424 err = ixgbe_aci_nvm_update_empr(hw);
425 if (err)
426 NL_SET_ERR_MSG_MOD(extack,
427 "Failed to trigger EMP device reset to reload firmware");
428
429 return err;
430}
431
432/*Wait for 10 sec with 0.5 sec tic. EMPR takes no less than half of a sec */
433#define IXGBE_DEVLINK_RELOAD_TIMEOUT_SEC 20
434
435/**
436 * ixgbe_devlink_reload_empr_finish - finishes EMP reset
437 * @devlink: pointer to the devlink instance
438 * @action: the action to perform.
439 * @limit: limits on what reload should do
440 * @actions_performed: actions performed
441 * @extack: netlink extended ACK structure
442 *
443 * Wait for new NVM to be loaded during EMP reset.
444 *
445 * Return: -ETIME when timer is exceeded, 0 on success.
446 */
447static int ixgbe_devlink_reload_empr_finish(struct devlink *devlink,
448 enum devlink_reload_action action,
449 enum devlink_reload_limit limit,
450 u32 *actions_performed,
451 struct netlink_ext_ack *extack)
452{
453 struct ixgbe_adapter *adapter = devlink_priv(devlink);
454 struct ixgbe_hw *hw = &adapter->hw;
455 int i = 0;
456 u32 fwsm;
457
458 do {
459 /* Just right away after triggering EMP reset the FWSM register
460 * may be not cleared yet, so begin the loop with the delay
461 * in order to not check the not updated register.
462 */
463 mdelay(500);
464
465 fwsm = IXGBE_READ_REG(hw, IXGBE_FWSM(hw));
466
467 if (i++ >= IXGBE_DEVLINK_RELOAD_TIMEOUT_SEC)
468 return -ETIME;
469
470 } while (!(fwsm & IXGBE_FWSM_FW_VAL_BIT));
471
472 *actions_performed = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE);
473
474 adapter->flags2 &= ~(IXGBE_FLAG2_API_MISMATCH |
475 IXGBE_FLAG2_FW_ROLLBACK);
476
477 return ixgbe_refresh_fw_version(adapter);
478}
479
480static const struct devlink_ops ixgbe_devlink_ops = {
481 .info_get = ixgbe_devlink_info_get,
482 .supported_flash_update_params =
483 DEVLINK_SUPPORT_FLASH_UPDATE_OVERWRITE_MASK,
484 .flash_update = ixgbe_flash_pldm_image,
485 .reload_actions = BIT(DEVLINK_RELOAD_ACTION_FW_ACTIVATE),
486 .reload_down = ixgbe_devlink_reload_empr_start,
487 .reload_up = ixgbe_devlink_reload_empr_finish,
488};
489
490/**
491 * ixgbe_allocate_devlink - Allocate devlink instance
492 * @dev: device to allocate devlink for
493 *
494 * Allocate a devlink instance for this physical function.
495 *
496 * Return: pointer to the device adapter structure on success,
497 * ERR_PTR(-ENOMEM) when allocation failed.
498 */
499struct ixgbe_adapter *ixgbe_allocate_devlink(struct device *dev)
500{
501 struct ixgbe_adapter *adapter;
502 struct devlink *devlink;
503
504 devlink = devlink_alloc(&ixgbe_devlink_ops, sizeof(*adapter), dev);
505 if (!devlink)
506 return ERR_PTR(-ENOMEM);
507
508 adapter = devlink_priv(devlink);
509 adapter->devlink = devlink;
510
511 return adapter;
512}
513
514/**
515 * ixgbe_devlink_set_switch_id - Set unique switch ID based on PCI DSN
516 * @adapter: pointer to the device adapter structure
517 * @ppid: struct with switch id information
518 */
519static void ixgbe_devlink_set_switch_id(struct ixgbe_adapter *adapter,
520 struct netdev_phys_item_id *ppid)
521{
522 u64 id = pci_get_dsn(adapter->pdev);
523
524 ppid->id_len = sizeof(id);
525 put_unaligned_be64(id, &ppid->id);
526}
527
528/**
529 * ixgbe_devlink_register_port - Register devlink port
530 * @adapter: pointer to the device adapter structure
531 *
532 * Create and register a devlink_port for this physical function.
533 *
534 * Return: 0 on success, error code on failure.
535 */
536int ixgbe_devlink_register_port(struct ixgbe_adapter *adapter)
537{
538 struct devlink_port *devlink_port = &adapter->devlink_port;
539 struct devlink *devlink = adapter->devlink;
540 struct device *dev = &adapter->pdev->dev;
541 struct devlink_port_attrs attrs = {};
542 int err;
543
544 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
545 attrs.phys.port_number = adapter->hw.bus.func;
546 attrs.no_phys_port_name = 1;
547 ixgbe_devlink_set_switch_id(adapter, &attrs.switch_id);
548
549 devlink_port_attrs_set(devlink_port, &attrs);
550
551 err = devl_port_register(devlink, devlink_port, 0);
552 if (err) {
553 dev_err(dev,
554 "devlink port registration failed, err %d\n", err);
555 }
556
557 return err;
558}