Loading...
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (C) 2018-2019, Intel Corporation. */
3
4#include <asm/unaligned.h>
5#include <linux/uuid.h>
6#include <linux/crc32.h>
7#include <linux/pldmfw.h>
8#include "ice.h"
9#include "ice_fw_update.h"
10
11struct ice_fwu_priv {
12 struct pldmfw context;
13
14 struct ice_pf *pf;
15 struct netlink_ext_ack *extack;
16
17 /* Track which NVM banks to activate at the end of the update */
18 u8 activate_flags;
19
20 /* Track the firmware response of the required reset to complete the
21 * flash update.
22 *
23 * 0 - ICE_AQC_NVM_POR_FLAG - A full power on is required
24 * 1 - ICE_AQC_NVM_PERST_FLAG - A cold PCIe reset is required
25 * 2 - ICE_AQC_NVM_EMPR_FLAG - An EMP reset is required
26 */
27 u8 reset_level;
28
29 /* Track if EMP reset is available */
30 u8 emp_reset_available;
31};
32
33/**
34 * ice_send_package_data - Send record package data to firmware
35 * @context: PLDM fw update structure
36 * @data: pointer to the package data
37 * @length: length of the package data
38 *
39 * Send a copy of the package data associated with the PLDM record matching
40 * this device to the firmware.
41 *
42 * Note that this function sends an AdminQ command that will fail unless the
43 * NVM resource has been acquired.
44 *
45 * Returns: zero on success, or a negative error code on failure.
46 */
47static int
48ice_send_package_data(struct pldmfw *context, const u8 *data, u16 length)
49{
50 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
51 struct netlink_ext_ack *extack = priv->extack;
52 struct device *dev = context->dev;
53 struct ice_pf *pf = priv->pf;
54 struct ice_hw *hw = &pf->hw;
55 u8 *package_data;
56 int status;
57
58 dev_dbg(dev, "Sending PLDM record package data to firmware\n");
59
60 package_data = kmemdup(data, length, GFP_KERNEL);
61 if (!package_data)
62 return -ENOMEM;
63
64 status = ice_nvm_set_pkg_data(hw, false, package_data, length, NULL);
65
66 kfree(package_data);
67
68 if (status) {
69 dev_err(dev, "Failed to send record package data to firmware, err %d aq_err %s\n",
70 status, ice_aq_str(hw->adminq.sq_last_status));
71 NL_SET_ERR_MSG_MOD(extack, "Failed to record package data to firmware");
72 return -EIO;
73 }
74
75 return 0;
76}
77
78/**
79 * ice_check_component_response - Report firmware response to a component
80 * @pf: device private data structure
81 * @id: component id being checked
82 * @response: indicates whether this component can be updated
83 * @code: code indicating reason for response
84 * @extack: netlink extended ACK structure
85 *
86 * Check whether firmware indicates if this component can be updated. Report
87 * a suitable error message over the netlink extended ACK if the component
88 * cannot be updated.
89 *
90 * Returns: zero if the component can be updated, or -ECANCELED of the
91 * firmware indicates the component cannot be updated.
92 */
93static int
94ice_check_component_response(struct ice_pf *pf, u16 id, u8 response, u8 code,
95 struct netlink_ext_ack *extack)
96{
97 struct device *dev = ice_pf_to_dev(pf);
98 const char *component;
99
100 switch (id) {
101 case NVM_COMP_ID_OROM:
102 component = "fw.undi";
103 break;
104 case NVM_COMP_ID_NVM:
105 component = "fw.mgmt";
106 break;
107 case NVM_COMP_ID_NETLIST:
108 component = "fw.netlist";
109 break;
110 default:
111 WARN(1, "Unexpected unknown component identifier 0x%02x", id);
112 return -EINVAL;
113 }
114
115 dev_dbg(dev, "%s: firmware response 0x%x, code 0x%x\n",
116 component, response, code);
117
118 switch (response) {
119 case ICE_AQ_NVM_PASS_COMP_CAN_BE_UPDATED:
120 /* firmware indicated this update is good to proceed */
121 return 0;
122 case ICE_AQ_NVM_PASS_COMP_CAN_MAY_BE_UPDATEABLE:
123 dev_warn(dev, "firmware recommends not updating %s, as it may result in a downgrade. continuing anyways\n", component);
124 return 0;
125 case ICE_AQ_NVM_PASS_COMP_CAN_NOT_BE_UPDATED:
126 dev_info(dev, "firmware has rejected updating %s\n", component);
127 break;
128 }
129
130 switch (code) {
131 case ICE_AQ_NVM_PASS_COMP_STAMP_IDENTICAL_CODE:
132 dev_err(dev, "Component comparison stamp for %s is identical to the running image\n",
133 component);
134 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is identical to running image");
135 break;
136 case ICE_AQ_NVM_PASS_COMP_STAMP_LOWER:
137 dev_err(dev, "Component comparison stamp for %s is lower than the running image\n",
138 component);
139 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is lower than running image");
140 break;
141 case ICE_AQ_NVM_PASS_COMP_INVALID_STAMP_CODE:
142 dev_err(dev, "Component comparison stamp for %s is invalid\n",
143 component);
144 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is invalid");
145 break;
146 case ICE_AQ_NVM_PASS_COMP_CONFLICT_CODE:
147 dev_err(dev, "%s conflicts with a previous component table\n",
148 component);
149 NL_SET_ERR_MSG_MOD(extack, "Component table conflict occurred");
150 break;
151 case ICE_AQ_NVM_PASS_COMP_PRE_REQ_NOT_MET_CODE:
152 dev_err(dev, "Pre-requisites for component %s have not been met\n",
153 component);
154 NL_SET_ERR_MSG_MOD(extack, "Component pre-requisites not met");
155 break;
156 case ICE_AQ_NVM_PASS_COMP_NOT_SUPPORTED_CODE:
157 dev_err(dev, "%s is not a supported component\n",
158 component);
159 NL_SET_ERR_MSG_MOD(extack, "Component not supported");
160 break;
161 case ICE_AQ_NVM_PASS_COMP_CANNOT_DOWNGRADE_CODE:
162 dev_err(dev, "Security restrictions prevent %s from being downgraded\n",
163 component);
164 NL_SET_ERR_MSG_MOD(extack, "Component cannot be downgraded");
165 break;
166 case ICE_AQ_NVM_PASS_COMP_INCOMPLETE_IMAGE_CODE:
167 dev_err(dev, "Received an incomplete component image for %s\n",
168 component);
169 NL_SET_ERR_MSG_MOD(extack, "Incomplete component image");
170 break;
171 case ICE_AQ_NVM_PASS_COMP_VER_STR_IDENTICAL_CODE:
172 dev_err(dev, "Component version for %s is identical to the running image\n",
173 component);
174 NL_SET_ERR_MSG_MOD(extack, "Component version is identical to running image");
175 break;
176 case ICE_AQ_NVM_PASS_COMP_VER_STR_LOWER_CODE:
177 dev_err(dev, "Component version for %s is lower than the running image\n",
178 component);
179 NL_SET_ERR_MSG_MOD(extack, "Component version is lower than the running image");
180 break;
181 default:
182 dev_err(dev, "Unexpected response code 0x02%x for %s\n",
183 code, component);
184 NL_SET_ERR_MSG_MOD(extack, "Received unexpected response code from firmware");
185 break;
186 }
187
188 return -ECANCELED;
189}
190
191/**
192 * ice_send_component_table - Send PLDM component table to firmware
193 * @context: PLDM fw update structure
194 * @component: the component to process
195 * @transfer_flag: relative transfer order of this component
196 *
197 * Read relevant data from the component and forward it to the device
198 * firmware. Check the response to determine if the firmware indicates that
199 * the update can proceed.
200 *
201 * This function sends AdminQ commands related to the NVM, and assumes that
202 * the NVM resource has been acquired.
203 *
204 * Returns: zero on success, or a negative error code on failure.
205 */
206static int
207ice_send_component_table(struct pldmfw *context, struct pldmfw_component *component,
208 u8 transfer_flag)
209{
210 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
211 struct netlink_ext_ack *extack = priv->extack;
212 struct ice_aqc_nvm_comp_tbl *comp_tbl;
213 u8 comp_response, comp_response_code;
214 struct device *dev = context->dev;
215 struct ice_pf *pf = priv->pf;
216 struct ice_hw *hw = &pf->hw;
217 size_t length;
218 int status;
219
220 switch (component->identifier) {
221 case NVM_COMP_ID_OROM:
222 case NVM_COMP_ID_NVM:
223 case NVM_COMP_ID_NETLIST:
224 break;
225 default:
226 dev_err(dev, "Unable to update due to a firmware component with unknown ID %u\n",
227 component->identifier);
228 NL_SET_ERR_MSG_MOD(extack, "Unable to update due to unknown firmware component");
229 return -EOPNOTSUPP;
230 }
231
232 length = struct_size(comp_tbl, cvs, component->version_len);
233 comp_tbl = kzalloc(length, GFP_KERNEL);
234 if (!comp_tbl)
235 return -ENOMEM;
236
237 comp_tbl->comp_class = cpu_to_le16(component->classification);
238 comp_tbl->comp_id = cpu_to_le16(component->identifier);
239 comp_tbl->comp_class_idx = FWU_COMP_CLASS_IDX_NOT_USE;
240 comp_tbl->comp_cmp_stamp = cpu_to_le32(component->comparison_stamp);
241 comp_tbl->cvs_type = component->version_type;
242 comp_tbl->cvs_len = component->version_len;
243 memcpy(comp_tbl->cvs, component->version_string, component->version_len);
244
245 dev_dbg(dev, "Sending component table to firmware:\n");
246
247 status = ice_nvm_pass_component_tbl(hw, (u8 *)comp_tbl, length,
248 transfer_flag, &comp_response,
249 &comp_response_code, NULL);
250
251 kfree(comp_tbl);
252
253 if (status) {
254 dev_err(dev, "Failed to transfer component table to firmware, err %d aq_err %s\n",
255 status, ice_aq_str(hw->adminq.sq_last_status));
256 NL_SET_ERR_MSG_MOD(extack, "Failed to transfer component table to firmware");
257 return -EIO;
258 }
259
260 return ice_check_component_response(pf, component->identifier, comp_response,
261 comp_response_code, extack);
262}
263
264/**
265 * ice_write_one_nvm_block - Write an NVM block and await completion response
266 * @pf: the PF data structure
267 * @module: the module to write to
268 * @offset: offset in bytes
269 * @block_size: size of the block to write, up to 4k
270 * @block: pointer to block of data to write
271 * @last_cmd: whether this is the last command
272 * @reset_level: storage for reset level required
273 * @extack: netlink extended ACK structure
274 *
275 * Write a block of data to a flash module, and await for the completion
276 * response message from firmware.
277 *
278 * Note this function assumes the caller has acquired the NVM resource.
279 *
280 * On successful return, reset level indicates the device reset required to
281 * complete the update.
282 *
283 * 0 - ICE_AQC_NVM_POR_FLAG - A full power on is required
284 * 1 - ICE_AQC_NVM_PERST_FLAG - A cold PCIe reset is required
285 * 2 - ICE_AQC_NVM_EMPR_FLAG - An EMP reset is required
286 *
287 * Returns: zero on success, or a negative error code on failure.
288 */
289static int
290ice_write_one_nvm_block(struct ice_pf *pf, u16 module, u32 offset,
291 u16 block_size, u8 *block, bool last_cmd,
292 u8 *reset_level, struct netlink_ext_ack *extack)
293{
294 u16 completion_module, completion_retval;
295 struct device *dev = ice_pf_to_dev(pf);
296 struct ice_aq_task task = {};
297 struct ice_hw *hw = &pf->hw;
298 struct ice_aq_desc *desc;
299 u32 completion_offset;
300 int err;
301
302 dev_dbg(dev, "Writing block of %u bytes for module 0x%02x at offset %u\n",
303 block_size, module, offset);
304
305 ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_write);
306
307 err = ice_aq_update_nvm(hw, module, offset, block_size, block,
308 last_cmd, 0, NULL);
309 if (err) {
310 dev_err(dev, "Failed to flash module 0x%02x with block of size %u at offset %u, err %d aq_err %s\n",
311 module, block_size, offset, err,
312 ice_aq_str(hw->adminq.sq_last_status));
313 NL_SET_ERR_MSG_MOD(extack, "Failed to program flash module");
314 return -EIO;
315 }
316
317 /* In most cases, firmware reports a write completion within a few
318 * milliseconds. However, it has been observed that a completion might
319 * take more than a second to complete in some cases. The timeout here
320 * is conservative and is intended to prevent failure to update when
321 * firmware is slow to respond.
322 */
323 err = ice_aq_wait_for_event(pf, &task, 15 * HZ);
324 if (err) {
325 dev_err(dev, "Timed out while trying to flash module 0x%02x with block of size %u at offset %u, err %d\n",
326 module, block_size, offset, err);
327 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
328 return -EIO;
329 }
330
331 desc = &task.event.desc;
332 completion_module = le16_to_cpu(desc->params.nvm.module_typeid);
333 completion_retval = le16_to_cpu(desc->retval);
334
335 completion_offset = le16_to_cpu(desc->params.nvm.offset_low);
336 completion_offset |= desc->params.nvm.offset_high << 16;
337
338 if (completion_module != module) {
339 dev_err(dev, "Unexpected module_typeid in write completion: got 0x%x, expected 0x%x\n",
340 completion_module, module);
341 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
342 return -EIO;
343 }
344
345 if (completion_offset != offset) {
346 dev_err(dev, "Unexpected offset in write completion: got %u, expected %u\n",
347 completion_offset, offset);
348 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
349 return -EIO;
350 }
351
352 if (completion_retval) {
353 dev_err(dev, "Firmware failed to flash module 0x%02x with block of size %u at offset %u, err %s\n",
354 module, block_size, offset,
355 ice_aq_str((enum ice_aq_err)completion_retval));
356 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to program flash module");
357 return -EIO;
358 }
359
360 /* For the last command to write the NVM bank, newer versions of
361 * firmware indicate the required level of reset to complete
362 * activation of firmware. If the firmware supports this, cache the
363 * response for indicating to the user later. Otherwise, assume that
364 * a full power cycle is required.
365 */
366 if (reset_level && last_cmd && module == ICE_SR_1ST_NVM_BANK_PTR) {
367 if (hw->dev_caps.common_cap.pcie_reset_avoidance) {
368 *reset_level = desc->params.nvm.cmd_flags &
369 ICE_AQC_NVM_RESET_LVL_M;
370 dev_dbg(dev, "Firmware reported required reset level as %u\n",
371 *reset_level);
372 } else {
373 *reset_level = ICE_AQC_NVM_POR_FLAG;
374 dev_dbg(dev, "Firmware doesn't support indicating required reset level. Assuming a power cycle is required\n");
375 }
376 }
377
378 return 0;
379}
380
381/**
382 * ice_write_nvm_module - Write data to an NVM module
383 * @pf: the PF driver structure
384 * @module: the module id to program
385 * @component: the name of the component being updated
386 * @image: buffer of image data to write to the NVM
387 * @length: length of the buffer
388 * @reset_level: storage for reset level required
389 * @extack: netlink extended ACK structure
390 *
391 * Loop over the data for a given NVM module and program it in 4 Kb
392 * blocks. Notify devlink core of progress after each block is programmed.
393 * Loops over a block of data and programs the NVM in 4k block chunks.
394 *
395 * Note this function assumes the caller has acquired the NVM resource.
396 *
397 * Returns: zero on success, or a negative error code on failure.
398 */
399static int
400ice_write_nvm_module(struct ice_pf *pf, u16 module, const char *component,
401 const u8 *image, u32 length, u8 *reset_level,
402 struct netlink_ext_ack *extack)
403{
404 struct device *dev = ice_pf_to_dev(pf);
405 struct devlink *devlink;
406 u32 offset = 0;
407 bool last_cmd;
408 u8 *block;
409 int err;
410
411 dev_dbg(dev, "Beginning write of flash component '%s', module 0x%02x\n", component, module);
412
413 devlink = priv_to_devlink(pf);
414
415 devlink_flash_update_status_notify(devlink, "Flashing",
416 component, 0, length);
417
418 block = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
419 if (!block)
420 return -ENOMEM;
421
422 do {
423 u32 block_size;
424
425 block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset);
426 last_cmd = !(offset + block_size < length);
427
428 /* ice_aq_update_nvm may copy the firmware response into the
429 * buffer, so we must make a copy since the source data is
430 * constant.
431 */
432 memcpy(block, image + offset, block_size);
433
434 err = ice_write_one_nvm_block(pf, module, offset, block_size,
435 block, last_cmd, reset_level,
436 extack);
437 if (err)
438 break;
439
440 offset += block_size;
441
442 devlink_flash_update_status_notify(devlink, "Flashing",
443 component, offset, length);
444 } while (!last_cmd);
445
446 dev_dbg(dev, "Completed write of flash component '%s', module 0x%02x\n", component, module);
447
448 if (err)
449 devlink_flash_update_status_notify(devlink, "Flashing failed",
450 component, length, length);
451 else
452 devlink_flash_update_status_notify(devlink, "Flashing done",
453 component, length, length);
454
455 kfree(block);
456 return err;
457}
458
459/* Length in seconds to wait before timing out when erasing a flash module.
460 * Yes, erasing really can take minutes to complete.
461 */
462#define ICE_FW_ERASE_TIMEOUT 300
463
464/**
465 * ice_erase_nvm_module - Erase an NVM module and await firmware completion
466 * @pf: the PF data structure
467 * @module: the module to erase
468 * @component: name of the component being updated
469 * @extack: netlink extended ACK structure
470 *
471 * Erase the inactive NVM bank associated with this module, and await for
472 * a completion response message from firmware.
473 *
474 * Note this function assumes the caller has acquired the NVM resource.
475 *
476 * Returns: zero on success, or a negative error code on failure.
477 */
478static int
479ice_erase_nvm_module(struct ice_pf *pf, u16 module, const char *component,
480 struct netlink_ext_ack *extack)
481{
482 u16 completion_module, completion_retval;
483 struct device *dev = ice_pf_to_dev(pf);
484 struct ice_aq_task task = {};
485 struct ice_hw *hw = &pf->hw;
486 struct ice_aq_desc *desc;
487 struct devlink *devlink;
488 int err;
489
490 dev_dbg(dev, "Beginning erase of flash component '%s', module 0x%02x\n", component, module);
491
492 devlink = priv_to_devlink(pf);
493
494 devlink_flash_update_timeout_notify(devlink, "Erasing", component, ICE_FW_ERASE_TIMEOUT);
495
496 ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_erase);
497
498 err = ice_aq_erase_nvm(hw, module, NULL);
499 if (err) {
500 dev_err(dev, "Failed to erase %s (module 0x%02x), err %d aq_err %s\n",
501 component, module, err,
502 ice_aq_str(hw->adminq.sq_last_status));
503 NL_SET_ERR_MSG_MOD(extack, "Failed to erase flash module");
504 err = -EIO;
505 goto out_notify_devlink;
506 }
507
508 err = ice_aq_wait_for_event(pf, &task, ICE_FW_ERASE_TIMEOUT * HZ);
509 if (err) {
510 dev_err(dev, "Timed out waiting for firmware to respond with erase completion for %s (module 0x%02x), err %d\n",
511 component, module, err);
512 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
513 goto out_notify_devlink;
514 }
515
516 desc = &task.event.desc;
517 completion_module = le16_to_cpu(desc->params.nvm.module_typeid);
518 completion_retval = le16_to_cpu(desc->retval);
519
520 if (completion_module != module) {
521 dev_err(dev, "Unexpected module_typeid in erase completion for %s: got 0x%x, expected 0x%x\n",
522 component, completion_module, module);
523 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
524 err = -EIO;
525 goto out_notify_devlink;
526 }
527
528 if (completion_retval) {
529 dev_err(dev, "Firmware failed to erase %s (module 0x02%x), aq_err %s\n",
530 component, module,
531 ice_aq_str((enum ice_aq_err)completion_retval));
532 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to erase flash");
533 err = -EIO;
534 goto out_notify_devlink;
535 }
536
537 dev_dbg(dev, "Completed erase of flash component '%s', module 0x%02x\n", component, module);
538
539out_notify_devlink:
540 if (err)
541 devlink_flash_update_status_notify(devlink, "Erasing failed",
542 component, 0, 0);
543 else
544 devlink_flash_update_status_notify(devlink, "Erasing done",
545 component, 0, 0);
546
547 return err;
548}
549
550/**
551 * ice_switch_flash_banks - Tell firmware to switch NVM banks
552 * @pf: Pointer to the PF data structure
553 * @activate_flags: flags used for the activation command
554 * @emp_reset_available: on return, indicates if EMP reset is available
555 * @extack: netlink extended ACK structure
556 *
557 * Notify firmware to activate the newly written flash banks, and wait for the
558 * firmware response.
559 *
560 * Returns: zero on success or an error code on failure.
561 */
562static int
563ice_switch_flash_banks(struct ice_pf *pf, u8 activate_flags,
564 u8 *emp_reset_available, struct netlink_ext_ack *extack)
565{
566 struct device *dev = ice_pf_to_dev(pf);
567 struct ice_aq_task task = {};
568 struct ice_hw *hw = &pf->hw;
569 u16 completion_retval;
570 u8 response_flags;
571 int err;
572
573 ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_write_activate);
574
575 err = ice_nvm_write_activate(hw, activate_flags, &response_flags);
576 if (err) {
577 dev_err(dev, "Failed to switch active flash banks, err %d aq_err %s\n",
578 err, ice_aq_str(hw->adminq.sq_last_status));
579 NL_SET_ERR_MSG_MOD(extack, "Failed to switch active flash banks");
580 return -EIO;
581 }
582
583 /* Newer versions of firmware have support to indicate whether an EMP
584 * reset to reload firmware is available. For older firmware, EMP
585 * reset is always available.
586 */
587 if (emp_reset_available) {
588 if (hw->dev_caps.common_cap.reset_restrict_support) {
589 *emp_reset_available = response_flags & ICE_AQC_NVM_EMPR_ENA;
590 dev_dbg(dev, "Firmware indicated that EMP reset is %s\n",
591 *emp_reset_available ?
592 "available" : "not available");
593 } else {
594 *emp_reset_available = ICE_AQC_NVM_EMPR_ENA;
595 dev_dbg(dev, "Firmware does not support restricting EMP reset availability\n");
596 }
597 }
598
599 err = ice_aq_wait_for_event(pf, &task, 30 * HZ);
600 if (err) {
601 dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n",
602 err);
603 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
604 return err;
605 }
606
607 completion_retval = le16_to_cpu(task.event.desc.retval);
608 if (completion_retval) {
609 dev_err(dev, "Firmware failed to switch active flash banks aq_err %s\n",
610 ice_aq_str((enum ice_aq_err)completion_retval));
611 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to switch active flash banks");
612 return -EIO;
613 }
614
615 return 0;
616}
617
618/**
619 * ice_flash_component - Flash a component of the NVM
620 * @context: PLDM fw update structure
621 * @component: the component table to program
622 *
623 * Program the flash contents for a given component. First, determine the
624 * module id. Then, erase the secondary bank for this module. Finally, write
625 * the contents of the component to the NVM.
626 *
627 * Note this function assumes the caller has acquired the NVM resource.
628 *
629 * Returns: zero on success, or a negative error code on failure.
630 */
631static int
632ice_flash_component(struct pldmfw *context, struct pldmfw_component *component)
633{
634 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
635 struct netlink_ext_ack *extack = priv->extack;
636 struct ice_pf *pf = priv->pf;
637 const char *name;
638 u8 *reset_level;
639 u16 module;
640 u8 flag;
641 int err;
642
643 switch (component->identifier) {
644 case NVM_COMP_ID_OROM:
645 module = ICE_SR_1ST_OROM_BANK_PTR;
646 flag = ICE_AQC_NVM_ACTIV_SEL_OROM;
647 reset_level = NULL;
648 name = "fw.undi";
649 break;
650 case NVM_COMP_ID_NVM:
651 module = ICE_SR_1ST_NVM_BANK_PTR;
652 flag = ICE_AQC_NVM_ACTIV_SEL_NVM;
653 reset_level = &priv->reset_level;
654 name = "fw.mgmt";
655 break;
656 case NVM_COMP_ID_NETLIST:
657 module = ICE_SR_NETLIST_BANK_PTR;
658 flag = ICE_AQC_NVM_ACTIV_SEL_NETLIST;
659 reset_level = NULL;
660 name = "fw.netlist";
661 break;
662 default:
663 /* This should not trigger, since we check the id before
664 * sending the component table to firmware.
665 */
666 WARN(1, "Unexpected unknown component identifier 0x%02x",
667 component->identifier);
668 return -EINVAL;
669 }
670
671 /* Mark this component for activating at the end */
672 priv->activate_flags |= flag;
673
674 err = ice_erase_nvm_module(pf, module, name, extack);
675 if (err)
676 return err;
677
678 return ice_write_nvm_module(pf, module, name, component->component_data,
679 component->component_size, reset_level,
680 extack);
681}
682
683/**
684 * ice_finalize_update - Perform last steps to complete device update
685 * @context: PLDM fw update structure
686 *
687 * Called as the last step of the update process. Complete the update by
688 * telling the firmware to switch active banks, and perform a reset of
689 * configured.
690 *
691 * Returns: 0 on success, or an error code on failure.
692 */
693static int ice_finalize_update(struct pldmfw *context)
694{
695 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
696 struct netlink_ext_ack *extack = priv->extack;
697 struct ice_pf *pf = priv->pf;
698 struct devlink *devlink;
699 int err;
700
701 /* Finally, notify firmware to activate the written NVM banks */
702 err = ice_switch_flash_banks(pf, priv->activate_flags,
703 &priv->emp_reset_available, extack);
704 if (err)
705 return err;
706
707 devlink = priv_to_devlink(pf);
708
709 /* If the required reset is EMPR, but EMPR is disabled, report that
710 * a reboot is required instead.
711 */
712 if (priv->reset_level == ICE_AQC_NVM_EMPR_FLAG &&
713 !priv->emp_reset_available) {
714 dev_dbg(ice_pf_to_dev(pf), "Firmware indicated EMP reset as sufficient, but EMP reset is disabled\n");
715 priv->reset_level = ICE_AQC_NVM_PERST_FLAG;
716 }
717
718 switch (priv->reset_level) {
719 case ICE_AQC_NVM_EMPR_FLAG:
720 devlink_flash_update_status_notify(devlink,
721 "Activate new firmware by devlink reload",
722 NULL, 0, 0);
723 break;
724 case ICE_AQC_NVM_PERST_FLAG:
725 devlink_flash_update_status_notify(devlink,
726 "Activate new firmware by rebooting the system",
727 NULL, 0, 0);
728 break;
729 case ICE_AQC_NVM_POR_FLAG:
730 default:
731 devlink_flash_update_status_notify(devlink,
732 "Activate new firmware by power cycling the system",
733 NULL, 0, 0);
734 break;
735 }
736
737 pf->fw_emp_reset_disabled = !priv->emp_reset_available;
738
739 return 0;
740}
741
742struct ice_pldm_pci_record_id {
743 u32 vendor;
744 u32 device;
745 u32 subsystem_vendor;
746 u32 subsystem_device;
747};
748
749/**
750 * ice_op_pci_match_record - Check if a PCI device matches the record
751 * @context: PLDM fw update structure
752 * @record: list of records extracted from the PLDM image
753 *
754 * Determine if the PCI device associated with this device matches the record
755 * data provided.
756 *
757 * Searches the descriptor TLVs and extracts the relevant descriptor data into
758 * a pldm_pci_record_id. This is then compared against the PCI device ID
759 * information.
760 *
761 * Returns: true if the device matches the record, false otherwise.
762 */
763static bool
764ice_op_pci_match_record(struct pldmfw *context, struct pldmfw_record *record)
765{
766 struct pci_dev *pdev = to_pci_dev(context->dev);
767 struct ice_pldm_pci_record_id id = {
768 .vendor = PCI_ANY_ID,
769 .device = PCI_ANY_ID,
770 .subsystem_vendor = PCI_ANY_ID,
771 .subsystem_device = PCI_ANY_ID,
772 };
773 struct pldmfw_desc_tlv *desc;
774
775 list_for_each_entry(desc, &record->descs, entry) {
776 u16 value;
777 int *ptr;
778
779 switch (desc->type) {
780 case PLDM_DESC_ID_PCI_VENDOR_ID:
781 ptr = &id.vendor;
782 break;
783 case PLDM_DESC_ID_PCI_DEVICE_ID:
784 ptr = &id.device;
785 break;
786 case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
787 ptr = &id.subsystem_vendor;
788 break;
789 case PLDM_DESC_ID_PCI_SUBDEV_ID:
790 ptr = &id.subsystem_device;
791 break;
792 default:
793 /* Skip unrelated TLVs */
794 continue;
795 }
796
797 value = get_unaligned_le16(desc->data);
798 /* A value of zero for one of the descriptors is sometimes
799 * used when the record should ignore this field when matching
800 * device. For example if the record applies to any subsystem
801 * device or vendor.
802 */
803 if (value)
804 *ptr = value;
805 else
806 *ptr = PCI_ANY_ID;
807 }
808
809 /* the E822 device can have a generic device ID so check for that */
810 if ((id.vendor == PCI_ANY_ID || id.vendor == pdev->vendor) &&
811 (id.device == PCI_ANY_ID || id.device == pdev->device ||
812 id.device == ICE_DEV_ID_E822_SI_DFLT) &&
813 (id.subsystem_vendor == PCI_ANY_ID ||
814 id.subsystem_vendor == pdev->subsystem_vendor) &&
815 (id.subsystem_device == PCI_ANY_ID ||
816 id.subsystem_device == pdev->subsystem_device))
817 return true;
818
819 return false;
820}
821
822static const struct pldmfw_ops ice_fwu_ops_e810 = {
823 .match_record = &pldmfw_op_pci_match_record,
824 .send_package_data = &ice_send_package_data,
825 .send_component_table = &ice_send_component_table,
826 .flash_component = &ice_flash_component,
827 .finalize_update = &ice_finalize_update,
828};
829
830static const struct pldmfw_ops ice_fwu_ops_e822 = {
831 .match_record = &ice_op_pci_match_record,
832 .send_package_data = &ice_send_package_data,
833 .send_component_table = &ice_send_component_table,
834 .flash_component = &ice_flash_component,
835 .finalize_update = &ice_finalize_update,
836};
837
838/**
839 * ice_get_pending_updates - Check if the component has a pending update
840 * @pf: the PF driver structure
841 * @pending: on return, bitmap of updates pending
842 * @extack: Netlink extended ACK
843 *
844 * Check if the device has any pending updates on any flash components.
845 *
846 * Returns: zero on success, or a negative error code on failure. Updates
847 * pending with the bitmap of pending updates.
848 */
849int ice_get_pending_updates(struct ice_pf *pf, u8 *pending,
850 struct netlink_ext_ack *extack)
851{
852 struct device *dev = ice_pf_to_dev(pf);
853 struct ice_hw_dev_caps *dev_caps;
854 struct ice_hw *hw = &pf->hw;
855 int err;
856
857 dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL);
858 if (!dev_caps)
859 return -ENOMEM;
860
861 /* Read the most recent device capabilities from firmware. Do not use
862 * the cached values in hw->dev_caps, because the pending update flag
863 * may have changed, e.g. if an update was previously completed and
864 * the system has not yet rebooted.
865 */
866 err = ice_discover_dev_caps(hw, dev_caps);
867 if (err) {
868 NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities");
869 kfree(dev_caps);
870 return err;
871 }
872
873 *pending = 0;
874
875 if (dev_caps->common_cap.nvm_update_pending_nvm) {
876 dev_info(dev, "The fw.mgmt flash component has a pending update\n");
877 *pending |= ICE_AQC_NVM_ACTIV_SEL_NVM;
878 }
879
880 if (dev_caps->common_cap.nvm_update_pending_orom) {
881 dev_info(dev, "The fw.undi flash component has a pending update\n");
882 *pending |= ICE_AQC_NVM_ACTIV_SEL_OROM;
883 }
884
885 if (dev_caps->common_cap.nvm_update_pending_netlist) {
886 dev_info(dev, "The fw.netlist flash component has a pending update\n");
887 *pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
888 }
889
890 kfree(dev_caps);
891
892 return 0;
893}
894
895/**
896 * ice_cancel_pending_update - Cancel any pending update for a component
897 * @pf: the PF driver structure
898 * @component: if not NULL, the name of the component being updated
899 * @extack: Netlink extended ACK structure
900 *
901 * Cancel any pending update for the specified component. If component is
902 * NULL, all device updates will be canceled.
903 *
904 * Returns: zero on success, or a negative error code on failure.
905 */
906static int
907ice_cancel_pending_update(struct ice_pf *pf, const char *component,
908 struct netlink_ext_ack *extack)
909{
910 struct devlink *devlink = priv_to_devlink(pf);
911 struct device *dev = ice_pf_to_dev(pf);
912 struct ice_hw *hw = &pf->hw;
913 u8 pending;
914 int err;
915
916 err = ice_get_pending_updates(pf, &pending, extack);
917 if (err)
918 return err;
919
920 /* If the flash_update request is for a specific component, ignore all
921 * of the other components.
922 */
923 if (component) {
924 if (strcmp(component, "fw.mgmt") == 0)
925 pending &= ICE_AQC_NVM_ACTIV_SEL_NVM;
926 else if (strcmp(component, "fw.undi") == 0)
927 pending &= ICE_AQC_NVM_ACTIV_SEL_OROM;
928 else if (strcmp(component, "fw.netlist") == 0)
929 pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
930 else
931 WARN(1, "Unexpected flash component %s", component);
932 }
933
934 /* There is no previous pending update, so this request may continue */
935 if (!pending)
936 return 0;
937
938 /* In order to allow overwriting a previous pending update, notify
939 * firmware to cancel that update by issuing the appropriate command.
940 */
941 devlink_flash_update_status_notify(devlink,
942 "Canceling previous pending update",
943 component, 0, 0);
944
945 err = ice_acquire_nvm(hw, ICE_RES_WRITE);
946 if (err) {
947 dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
948 err, ice_aq_str(hw->adminq.sq_last_status));
949 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
950 return err;
951 }
952
953 pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV;
954 err = ice_switch_flash_banks(pf, pending, NULL, extack);
955
956 ice_release_nvm(hw);
957
958 /* Since we've canceled the pending update, we no longer know if EMP
959 * reset is restricted.
960 */
961 pf->fw_emp_reset_disabled = false;
962
963 return err;
964}
965
966/**
967 * ice_devlink_flash_update - Write a firmware image to the device
968 * @devlink: pointer to devlink associated with the device to update
969 * @params: devlink flash update parameters
970 * @extack: netlink extended ACK structure
971 *
972 * Parse the data for a given firmware file, verifying that it is a valid PLDM
973 * formatted image that matches this device.
974 *
975 * Extract the device record Package Data and Component Tables and send them
976 * to the firmware. Extract and write the flash data for each of the three
977 * main flash components, "fw.mgmt", "fw.undi", and "fw.netlist". Notify
978 * firmware once the data is written to the inactive banks.
979 *
980 * Returns: zero on success or a negative error code on failure.
981 */
982int ice_devlink_flash_update(struct devlink *devlink,
983 struct devlink_flash_update_params *params,
984 struct netlink_ext_ack *extack)
985{
986 struct ice_pf *pf = devlink_priv(devlink);
987 struct device *dev = ice_pf_to_dev(pf);
988 struct ice_hw *hw = &pf->hw;
989 struct ice_fwu_priv priv;
990 u8 preservation;
991 int err;
992
993 if (!params->overwrite_mask) {
994 /* preserve all settings and identifiers */
995 preservation = ICE_AQC_NVM_PRESERVE_ALL;
996 } else if (params->overwrite_mask == DEVLINK_FLASH_OVERWRITE_SETTINGS) {
997 /* overwrite settings, but preserve the vital device identifiers */
998 preservation = ICE_AQC_NVM_PRESERVE_SELECTED;
999 } else if (params->overwrite_mask == (DEVLINK_FLASH_OVERWRITE_SETTINGS |
1000 DEVLINK_FLASH_OVERWRITE_IDENTIFIERS)) {
1001 /* overwrite both settings and identifiers, preserve nothing */
1002 preservation = ICE_AQC_NVM_NO_PRESERVATION;
1003 } else {
1004 NL_SET_ERR_MSG_MOD(extack, "Requested overwrite mask is not supported");
1005 return -EOPNOTSUPP;
1006 }
1007
1008 if (!hw->dev_caps.common_cap.nvm_unified_update) {
1009 NL_SET_ERR_MSG_MOD(extack, "Current firmware does not support unified update");
1010 return -EOPNOTSUPP;
1011 }
1012
1013 memset(&priv, 0, sizeof(priv));
1014
1015 /* the E822 device needs a slightly different ops */
1016 if (hw->mac_type == ICE_MAC_GENERIC)
1017 priv.context.ops = &ice_fwu_ops_e822;
1018 else
1019 priv.context.ops = &ice_fwu_ops_e810;
1020 priv.context.dev = dev;
1021 priv.extack = extack;
1022 priv.pf = pf;
1023 priv.activate_flags = preservation;
1024
1025 devlink_flash_update_status_notify(devlink, "Preparing to flash", NULL, 0, 0);
1026
1027 err = ice_cancel_pending_update(pf, NULL, extack);
1028 if (err)
1029 return err;
1030
1031 err = ice_acquire_nvm(hw, ICE_RES_WRITE);
1032 if (err) {
1033 dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
1034 err, ice_aq_str(hw->adminq.sq_last_status));
1035 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
1036 return err;
1037 }
1038
1039 err = pldmfw_flash_image(&priv.context, params->fw);
1040 if (err == -ENOENT) {
1041 dev_err(dev, "Firmware image has no record matching this device\n");
1042 NL_SET_ERR_MSG_MOD(extack, "Firmware image has no record matching this device");
1043 } else if (err) {
1044 /* Do not set a generic extended ACK message here. A more
1045 * specific message may already have been set by one of our
1046 * ops.
1047 */
1048 dev_err(dev, "Failed to flash PLDM image, err %d", err);
1049 }
1050
1051 ice_release_nvm(hw);
1052
1053 return err;
1054}
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (C) 2018-2019, Intel Corporation. */
3
4#include <asm/unaligned.h>
5#include <linux/uuid.h>
6#include <linux/crc32.h>
7#include <linux/pldmfw.h>
8#include "ice.h"
9#include "ice_fw_update.h"
10
11struct ice_fwu_priv {
12 struct pldmfw context;
13
14 struct ice_pf *pf;
15 struct netlink_ext_ack *extack;
16
17 /* Track which NVM banks to activate at the end of the update */
18 u8 activate_flags;
19};
20
21/**
22 * ice_send_package_data - Send record package data to firmware
23 * @context: PLDM fw update structure
24 * @data: pointer to the package data
25 * @length: length of the package data
26 *
27 * Send a copy of the package data associated with the PLDM record matching
28 * this device to the firmware.
29 *
30 * Note that this function sends an AdminQ command that will fail unless the
31 * NVM resource has been acquired.
32 *
33 * Returns: zero on success, or a negative error code on failure.
34 */
35static int
36ice_send_package_data(struct pldmfw *context, const u8 *data, u16 length)
37{
38 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
39 struct netlink_ext_ack *extack = priv->extack;
40 struct device *dev = context->dev;
41 struct ice_pf *pf = priv->pf;
42 struct ice_hw *hw = &pf->hw;
43 enum ice_status status;
44 u8 *package_data;
45
46 package_data = kmemdup(data, length, GFP_KERNEL);
47 if (!package_data)
48 return -ENOMEM;
49
50 status = ice_nvm_set_pkg_data(hw, false, package_data, length, NULL);
51
52 kfree(package_data);
53
54 if (status) {
55 dev_err(dev, "Failed to send record package data to firmware, err %s aq_err %s\n",
56 ice_stat_str(status),
57 ice_aq_str(hw->adminq.sq_last_status));
58 NL_SET_ERR_MSG_MOD(extack, "Failed to record package data to firmware");
59 return -EIO;
60 }
61
62 return 0;
63}
64
65/**
66 * ice_check_component_response - Report firmware response to a component
67 * @pf: device private data structure
68 * @id: component id being checked
69 * @response: indicates whether this component can be updated
70 * @code: code indicating reason for response
71 * @extack: netlink extended ACK structure
72 *
73 * Check whether firmware indicates if this component can be updated. Report
74 * a suitable error message over the netlink extended ACK if the component
75 * cannot be updated.
76 *
77 * Returns: zero if the component can be updated, or -ECANCELED of the
78 * firmware indicates the component cannot be updated.
79 */
80static int
81ice_check_component_response(struct ice_pf *pf, u16 id, u8 response, u8 code,
82 struct netlink_ext_ack *extack)
83{
84 struct device *dev = ice_pf_to_dev(pf);
85 const char *component;
86
87 switch (id) {
88 case NVM_COMP_ID_OROM:
89 component = "fw.undi";
90 break;
91 case NVM_COMP_ID_NVM:
92 component = "fw.mgmt";
93 break;
94 case NVM_COMP_ID_NETLIST:
95 component = "fw.netlist";
96 break;
97 default:
98 WARN(1, "Unexpected unknown component identifier 0x%02x", id);
99 return -EINVAL;
100 }
101
102 dev_dbg(dev, "%s: firmware response 0x%x, code 0x%x\n",
103 component, response, code);
104
105 switch (response) {
106 case ICE_AQ_NVM_PASS_COMP_CAN_BE_UPDATED:
107 /* firmware indicated this update is good to proceed */
108 return 0;
109 case ICE_AQ_NVM_PASS_COMP_CAN_MAY_BE_UPDATEABLE:
110 dev_warn(dev, "firmware recommends not updating %s, as it may result in a downgrade. continuing anyways\n", component);
111 return 0;
112 case ICE_AQ_NVM_PASS_COMP_CAN_NOT_BE_UPDATED:
113 dev_info(dev, "firmware has rejected updating %s\n", component);
114 break;
115 }
116
117 switch (code) {
118 case ICE_AQ_NVM_PASS_COMP_STAMP_IDENTICAL_CODE:
119 dev_err(dev, "Component comparison stamp for %s is identical to the running image\n",
120 component);
121 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is identical to running image");
122 break;
123 case ICE_AQ_NVM_PASS_COMP_STAMP_LOWER:
124 dev_err(dev, "Component comparison stamp for %s is lower than the running image\n",
125 component);
126 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is lower than running image");
127 break;
128 case ICE_AQ_NVM_PASS_COMP_INVALID_STAMP_CODE:
129 dev_err(dev, "Component comparison stamp for %s is invalid\n",
130 component);
131 NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is invalid");
132 break;
133 case ICE_AQ_NVM_PASS_COMP_CONFLICT_CODE:
134 dev_err(dev, "%s conflicts with a previous component table\n",
135 component);
136 NL_SET_ERR_MSG_MOD(extack, "Component table conflict occurred");
137 break;
138 case ICE_AQ_NVM_PASS_COMP_PRE_REQ_NOT_MET_CODE:
139 dev_err(dev, "Pre-requisites for component %s have not been met\n",
140 component);
141 NL_SET_ERR_MSG_MOD(extack, "Component pre-requisites not met");
142 break;
143 case ICE_AQ_NVM_PASS_COMP_NOT_SUPPORTED_CODE:
144 dev_err(dev, "%s is not a supported component\n",
145 component);
146 NL_SET_ERR_MSG_MOD(extack, "Component not supported");
147 break;
148 case ICE_AQ_NVM_PASS_COMP_CANNOT_DOWNGRADE_CODE:
149 dev_err(dev, "Security restrictions prevent %s from being downgraded\n",
150 component);
151 NL_SET_ERR_MSG_MOD(extack, "Component cannot be downgraded");
152 break;
153 case ICE_AQ_NVM_PASS_COMP_INCOMPLETE_IMAGE_CODE:
154 dev_err(dev, "Received an incomplete component image for %s\n",
155 component);
156 NL_SET_ERR_MSG_MOD(extack, "Incomplete component image");
157 break;
158 case ICE_AQ_NVM_PASS_COMP_VER_STR_IDENTICAL_CODE:
159 dev_err(dev, "Component version for %s is identical to the running image\n",
160 component);
161 NL_SET_ERR_MSG_MOD(extack, "Component version is identical to running image");
162 break;
163 case ICE_AQ_NVM_PASS_COMP_VER_STR_LOWER_CODE:
164 dev_err(dev, "Component version for %s is lower than the running image\n",
165 component);
166 NL_SET_ERR_MSG_MOD(extack, "Component version is lower than the running image");
167 break;
168 default:
169 dev_err(dev, "Unexpected response code 0x02%x for %s\n",
170 code, component);
171 NL_SET_ERR_MSG_MOD(extack, "Received unexpected response code from firmware");
172 break;
173 }
174
175 return -ECANCELED;
176}
177
178/**
179 * ice_send_component_table - Send PLDM component table to firmware
180 * @context: PLDM fw update structure
181 * @component: the component to process
182 * @transfer_flag: relative transfer order of this component
183 *
184 * Read relevant data from the component and forward it to the device
185 * firmware. Check the response to determine if the firmware indicates that
186 * the update can proceed.
187 *
188 * This function sends AdminQ commands related to the NVM, and assumes that
189 * the NVM resource has been acquired.
190 *
191 * Returns: zero on success, or a negative error code on failure.
192 */
193static int
194ice_send_component_table(struct pldmfw *context, struct pldmfw_component *component,
195 u8 transfer_flag)
196{
197 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
198 struct netlink_ext_ack *extack = priv->extack;
199 struct ice_aqc_nvm_comp_tbl *comp_tbl;
200 u8 comp_response, comp_response_code;
201 struct device *dev = context->dev;
202 struct ice_pf *pf = priv->pf;
203 struct ice_hw *hw = &pf->hw;
204 enum ice_status status;
205 size_t length;
206
207 switch (component->identifier) {
208 case NVM_COMP_ID_OROM:
209 case NVM_COMP_ID_NVM:
210 case NVM_COMP_ID_NETLIST:
211 break;
212 default:
213 dev_err(dev, "Unable to update due to a firmware component with unknown ID %u\n",
214 component->identifier);
215 NL_SET_ERR_MSG_MOD(extack, "Unable to update due to unknown firmware component");
216 return -EOPNOTSUPP;
217 }
218
219 length = struct_size(comp_tbl, cvs, component->version_len);
220 comp_tbl = kzalloc(length, GFP_KERNEL);
221 if (!comp_tbl)
222 return -ENOMEM;
223
224 comp_tbl->comp_class = cpu_to_le16(component->classification);
225 comp_tbl->comp_id = cpu_to_le16(component->identifier);
226 comp_tbl->comp_class_idx = FWU_COMP_CLASS_IDX_NOT_USE;
227 comp_tbl->comp_cmp_stamp = cpu_to_le32(component->comparison_stamp);
228 comp_tbl->cvs_type = component->version_type;
229 comp_tbl->cvs_len = component->version_len;
230 memcpy(comp_tbl->cvs, component->version_string, component->version_len);
231
232 status = ice_nvm_pass_component_tbl(hw, (u8 *)comp_tbl, length,
233 transfer_flag, &comp_response,
234 &comp_response_code, NULL);
235
236 kfree(comp_tbl);
237
238 if (status) {
239 dev_err(dev, "Failed to transfer component table to firmware, err %s aq_err %s\n",
240 ice_stat_str(status),
241 ice_aq_str(hw->adminq.sq_last_status));
242 NL_SET_ERR_MSG_MOD(extack, "Failed to transfer component table to firmware");
243 return -EIO;
244 }
245
246 return ice_check_component_response(pf, component->identifier, comp_response,
247 comp_response_code, extack);
248}
249
250/**
251 * ice_write_one_nvm_block - Write an NVM block and await completion response
252 * @pf: the PF data structure
253 * @module: the module to write to
254 * @offset: offset in bytes
255 * @block_size: size of the block to write, up to 4k
256 * @block: pointer to block of data to write
257 * @last_cmd: whether this is the last command
258 * @extack: netlink extended ACK structure
259 *
260 * Write a block of data to a flash module, and await for the completion
261 * response message from firmware.
262 *
263 * Note this function assumes the caller has acquired the NVM resource.
264 *
265 * Returns: zero on success, or a negative error code on failure.
266 */
267static int
268ice_write_one_nvm_block(struct ice_pf *pf, u16 module, u32 offset,
269 u16 block_size, u8 *block, bool last_cmd,
270 struct netlink_ext_ack *extack)
271{
272 u16 completion_module, completion_retval;
273 struct device *dev = ice_pf_to_dev(pf);
274 struct ice_rq_event_info event;
275 struct ice_hw *hw = &pf->hw;
276 enum ice_status status;
277 u32 completion_offset;
278 int err;
279
280 memset(&event, 0, sizeof(event));
281
282 status = ice_aq_update_nvm(hw, module, offset, block_size, block,
283 last_cmd, 0, NULL);
284 if (status) {
285 dev_err(dev, "Failed to program flash module 0x%02x at offset %u, err %s aq_err %s\n",
286 module, offset, ice_stat_str(status),
287 ice_aq_str(hw->adminq.sq_last_status));
288 NL_SET_ERR_MSG_MOD(extack, "Failed to program flash module");
289 return -EIO;
290 }
291
292 /* In most cases, firmware reports a write completion within a few
293 * milliseconds. However, it has been observed that a completion might
294 * take more than a second to complete in some cases. The timeout here
295 * is conservative and is intended to prevent failure to update when
296 * firmware is slow to respond.
297 */
298 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write, 15 * HZ, &event);
299 if (err) {
300 dev_err(dev, "Timed out waiting for firmware write completion for module 0x%02x, err %d\n",
301 module, err);
302 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
303 return -EIO;
304 }
305
306 completion_module = le16_to_cpu(event.desc.params.nvm.module_typeid);
307 completion_retval = le16_to_cpu(event.desc.retval);
308
309 completion_offset = le16_to_cpu(event.desc.params.nvm.offset_low);
310 completion_offset |= event.desc.params.nvm.offset_high << 16;
311
312 if (completion_module != module) {
313 dev_err(dev, "Unexpected module_typeid in write completion: got 0x%x, expected 0x%x\n",
314 completion_module, module);
315 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
316 return -EIO;
317 }
318
319 if (completion_offset != offset) {
320 dev_err(dev, "Unexpected offset in write completion: got %u, expected %u\n",
321 completion_offset, offset);
322 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
323 return -EIO;
324 }
325
326 if (completion_retval) {
327 dev_err(dev, "Firmware failed to program flash module 0x%02x at offset %u, completion err %s\n",
328 module, offset,
329 ice_aq_str((enum ice_aq_err)completion_retval));
330 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to program flash module");
331 return -EIO;
332 }
333
334 return 0;
335}
336
337/**
338 * ice_write_nvm_module - Write data to an NVM module
339 * @pf: the PF driver structure
340 * @module: the module id to program
341 * @component: the name of the component being updated
342 * @image: buffer of image data to write to the NVM
343 * @length: length of the buffer
344 * @extack: netlink extended ACK structure
345 *
346 * Loop over the data for a given NVM module and program it in 4 Kb
347 * blocks. Notify devlink core of progress after each block is programmed.
348 * Loops over a block of data and programs the NVM in 4k block chunks.
349 *
350 * Note this function assumes the caller has acquired the NVM resource.
351 *
352 * Returns: zero on success, or a negative error code on failure.
353 */
354static int
355ice_write_nvm_module(struct ice_pf *pf, u16 module, const char *component,
356 const u8 *image, u32 length,
357 struct netlink_ext_ack *extack)
358{
359 struct devlink *devlink;
360 u32 offset = 0;
361 bool last_cmd;
362 u8 *block;
363 int err;
364
365 devlink = priv_to_devlink(pf);
366
367 devlink_flash_update_status_notify(devlink, "Flashing",
368 component, 0, length);
369
370 block = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
371 if (!block)
372 return -ENOMEM;
373
374 do {
375 u32 block_size;
376
377 block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset);
378 last_cmd = !(offset + block_size < length);
379
380 /* ice_aq_update_nvm may copy the firmware response into the
381 * buffer, so we must make a copy since the source data is
382 * constant.
383 */
384 memcpy(block, image + offset, block_size);
385
386 err = ice_write_one_nvm_block(pf, module, offset, block_size,
387 block, last_cmd, extack);
388 if (err)
389 break;
390
391 offset += block_size;
392
393 devlink_flash_update_status_notify(devlink, "Flashing",
394 component, offset, length);
395 } while (!last_cmd);
396
397 if (err)
398 devlink_flash_update_status_notify(devlink, "Flashing failed",
399 component, length, length);
400 else
401 devlink_flash_update_status_notify(devlink, "Flashing done",
402 component, length, length);
403
404 kfree(block);
405 return err;
406}
407
408/**
409 * ice_erase_nvm_module - Erase an NVM module and await firmware completion
410 * @pf: the PF data structure
411 * @module: the module to erase
412 * @component: name of the component being updated
413 * @extack: netlink extended ACK structure
414 *
415 * Erase the inactive NVM bank associated with this module, and await for
416 * a completion response message from firmware.
417 *
418 * Note this function assumes the caller has acquired the NVM resource.
419 *
420 * Returns: zero on success, or a negative error code on failure.
421 */
422static int
423ice_erase_nvm_module(struct ice_pf *pf, u16 module, const char *component,
424 struct netlink_ext_ack *extack)
425{
426 u16 completion_module, completion_retval;
427 struct device *dev = ice_pf_to_dev(pf);
428 struct ice_rq_event_info event;
429 struct ice_hw *hw = &pf->hw;
430 struct devlink *devlink;
431 enum ice_status status;
432 int err;
433
434 memset(&event, 0, sizeof(event));
435
436 devlink = priv_to_devlink(pf);
437
438 devlink_flash_update_status_notify(devlink, "Erasing", component, 0, 0);
439
440 status = ice_aq_erase_nvm(hw, module, NULL);
441 if (status) {
442 dev_err(dev, "Failed to erase %s (module 0x%02x), err %s aq_err %s\n",
443 component, module, ice_stat_str(status),
444 ice_aq_str(hw->adminq.sq_last_status));
445 NL_SET_ERR_MSG_MOD(extack, "Failed to erase flash module");
446 err = -EIO;
447 goto out_notify_devlink;
448 }
449
450 /* Yes, this really can take minutes to complete */
451 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_erase, 300 * HZ, &event);
452 if (err) {
453 dev_err(dev, "Timed out waiting for firmware to respond with erase completion for %s (module 0x%02x), err %d\n",
454 component, module, err);
455 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
456 goto out_notify_devlink;
457 }
458
459 completion_module = le16_to_cpu(event.desc.params.nvm.module_typeid);
460 completion_retval = le16_to_cpu(event.desc.retval);
461
462 if (completion_module != module) {
463 dev_err(dev, "Unexpected module_typeid in erase completion for %s: got 0x%x, expected 0x%x\n",
464 component, completion_module, module);
465 NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
466 err = -EIO;
467 goto out_notify_devlink;
468 }
469
470 if (completion_retval) {
471 dev_err(dev, "Firmware failed to erase %s (module 0x02%x), aq_err %s\n",
472 component, module,
473 ice_aq_str((enum ice_aq_err)completion_retval));
474 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to erase flash");
475 err = -EIO;
476 goto out_notify_devlink;
477 }
478
479out_notify_devlink:
480 if (err)
481 devlink_flash_update_status_notify(devlink, "Erasing failed",
482 component, 0, 0);
483 else
484 devlink_flash_update_status_notify(devlink, "Erasing done",
485 component, 0, 0);
486
487 return err;
488}
489
490/**
491 * ice_switch_flash_banks - Tell firmware to switch NVM banks
492 * @pf: Pointer to the PF data structure
493 * @activate_flags: flags used for the activation command
494 * @extack: netlink extended ACK structure
495 *
496 * Notify firmware to activate the newly written flash banks, and wait for the
497 * firmware response.
498 *
499 * Returns: zero on success or an error code on failure.
500 */
501static int ice_switch_flash_banks(struct ice_pf *pf, u8 activate_flags,
502 struct netlink_ext_ack *extack)
503{
504 struct device *dev = ice_pf_to_dev(pf);
505 struct ice_rq_event_info event;
506 struct ice_hw *hw = &pf->hw;
507 enum ice_status status;
508 u16 completion_retval;
509 int err;
510
511 memset(&event, 0, sizeof(event));
512
513 status = ice_nvm_write_activate(hw, activate_flags);
514 if (status) {
515 dev_err(dev, "Failed to switch active flash banks, err %s aq_err %s\n",
516 ice_stat_str(status),
517 ice_aq_str(hw->adminq.sq_last_status));
518 NL_SET_ERR_MSG_MOD(extack, "Failed to switch active flash banks");
519 return -EIO;
520 }
521
522 err = ice_aq_wait_for_event(pf, ice_aqc_opc_nvm_write_activate, 30 * HZ,
523 &event);
524 if (err) {
525 dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n",
526 err);
527 NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
528 return err;
529 }
530
531 completion_retval = le16_to_cpu(event.desc.retval);
532 if (completion_retval) {
533 dev_err(dev, "Firmware failed to switch active flash banks aq_err %s\n",
534 ice_aq_str((enum ice_aq_err)completion_retval));
535 NL_SET_ERR_MSG_MOD(extack, "Firmware failed to switch active flash banks");
536 return -EIO;
537 }
538
539 return 0;
540}
541
542/**
543 * ice_flash_component - Flash a component of the NVM
544 * @context: PLDM fw update structure
545 * @component: the component table to program
546 *
547 * Program the flash contents for a given component. First, determine the
548 * module id. Then, erase the secondary bank for this module. Finally, write
549 * the contents of the component to the NVM.
550 *
551 * Note this function assumes the caller has acquired the NVM resource.
552 *
553 * Returns: zero on success, or a negative error code on failure.
554 */
555static int
556ice_flash_component(struct pldmfw *context, struct pldmfw_component *component)
557{
558 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
559 struct netlink_ext_ack *extack = priv->extack;
560 struct ice_pf *pf = priv->pf;
561 const char *name;
562 u16 module;
563 u8 flag;
564 int err;
565
566 switch (component->identifier) {
567 case NVM_COMP_ID_OROM:
568 module = ICE_SR_1ST_OROM_BANK_PTR;
569 flag = ICE_AQC_NVM_ACTIV_SEL_OROM;
570 name = "fw.undi";
571 break;
572 case NVM_COMP_ID_NVM:
573 module = ICE_SR_1ST_NVM_BANK_PTR;
574 flag = ICE_AQC_NVM_ACTIV_SEL_NVM;
575 name = "fw.mgmt";
576 break;
577 case NVM_COMP_ID_NETLIST:
578 module = ICE_SR_NETLIST_BANK_PTR;
579 flag = ICE_AQC_NVM_ACTIV_SEL_NETLIST;
580 name = "fw.netlist";
581 break;
582 default:
583 /* This should not trigger, since we check the id before
584 * sending the component table to firmware.
585 */
586 WARN(1, "Unexpected unknown component identifier 0x%02x",
587 component->identifier);
588 return -EINVAL;
589 }
590
591 /* Mark this component for activating at the end */
592 priv->activate_flags |= flag;
593
594 err = ice_erase_nvm_module(pf, module, name, extack);
595 if (err)
596 return err;
597
598 return ice_write_nvm_module(pf, module, name, component->component_data,
599 component->component_size, extack);
600}
601
602/**
603 * ice_finalize_update - Perform last steps to complete device update
604 * @context: PLDM fw update structure
605 *
606 * Called as the last step of the update process. Complete the update by
607 * telling the firmware to switch active banks, and perform a reset of
608 * configured.
609 *
610 * Returns: 0 on success, or an error code on failure.
611 */
612static int ice_finalize_update(struct pldmfw *context)
613{
614 struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
615 struct netlink_ext_ack *extack = priv->extack;
616 struct ice_pf *pf = priv->pf;
617 int err;
618
619 /* Finally, notify firmware to activate the written NVM banks */
620 err = ice_switch_flash_banks(pf, priv->activate_flags, extack);
621 if (err)
622 return err;
623
624 return 0;
625}
626
627static const struct pldmfw_ops ice_fwu_ops = {
628 .match_record = &pldmfw_op_pci_match_record,
629 .send_package_data = &ice_send_package_data,
630 .send_component_table = &ice_send_component_table,
631 .flash_component = &ice_flash_component,
632 .finalize_update = &ice_finalize_update,
633};
634
635/**
636 * ice_flash_pldm_image - Write a PLDM-formatted firmware image to the device
637 * @pf: private device driver structure
638 * @fw: firmware object pointing to the relevant firmware file
639 * @extack: netlink extended ACK structure
640 *
641 * Parse the data for a given firmware file, verifying that it is a valid PLDM
642 * formatted image that matches this device.
643 *
644 * Extract the device record Package Data and Component Tables and send them
645 * to the firmware. Extract and write the flash data for each of the three
646 * main flash components, "fw.mgmt", "fw.undi", and "fw.netlist". Notify
647 * firmware once the data is written to the inactive banks.
648 *
649 * Returns: zero on success or a negative error code on failure.
650 */
651int ice_flash_pldm_image(struct ice_pf *pf, const struct firmware *fw,
652 struct netlink_ext_ack *extack)
653{
654 struct device *dev = ice_pf_to_dev(pf);
655 struct ice_hw *hw = &pf->hw;
656 struct ice_fwu_priv priv;
657 enum ice_status status;
658 int err;
659
660 memset(&priv, 0, sizeof(priv));
661
662 priv.context.ops = &ice_fwu_ops;
663 priv.context.dev = dev;
664 priv.extack = extack;
665 priv.pf = pf;
666 priv.activate_flags = ICE_AQC_NVM_PRESERVE_ALL;
667
668 status = ice_acquire_nvm(hw, ICE_RES_WRITE);
669 if (status) {
670 dev_err(dev, "Failed to acquire device flash lock, err %s aq_err %s\n",
671 ice_stat_str(status),
672 ice_aq_str(hw->adminq.sq_last_status));
673 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
674 return -EIO;
675 }
676
677 err = pldmfw_flash_image(&priv.context, fw);
678
679 ice_release_nvm(hw);
680
681 return err;
682}
683
684/**
685 * ice_check_for_pending_update - Check for a pending flash update
686 * @pf: the PF driver structure
687 * @component: if not NULL, the name of the component being updated
688 * @extack: Netlink extended ACK structure
689 *
690 * Check whether the device already has a pending flash update. If such an
691 * update is found, cancel it so that the requested update may proceed.
692 *
693 * Returns: zero on success, or a negative error code on failure.
694 */
695int ice_check_for_pending_update(struct ice_pf *pf, const char *component,
696 struct netlink_ext_ack *extack)
697{
698 struct devlink *devlink = priv_to_devlink(pf);
699 struct device *dev = ice_pf_to_dev(pf);
700 struct ice_hw_dev_caps *dev_caps;
701 struct ice_hw *hw = &pf->hw;
702 enum ice_status status;
703 u8 pending = 0;
704 int err;
705
706 dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL);
707 if (!dev_caps)
708 return -ENOMEM;
709
710 /* Read the most recent device capabilities from firmware. Do not use
711 * the cached values in hw->dev_caps, because the pending update flag
712 * may have changed, e.g. if an update was previously completed and
713 * the system has not yet rebooted.
714 */
715 status = ice_discover_dev_caps(hw, dev_caps);
716 if (status) {
717 NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities");
718 kfree(dev_caps);
719 return -EIO;
720 }
721
722 if (dev_caps->common_cap.nvm_update_pending_nvm) {
723 dev_info(dev, "The fw.mgmt flash component has a pending update\n");
724 pending |= ICE_AQC_NVM_ACTIV_SEL_NVM;
725 }
726
727 if (dev_caps->common_cap.nvm_update_pending_orom) {
728 dev_info(dev, "The fw.undi flash component has a pending update\n");
729 pending |= ICE_AQC_NVM_ACTIV_SEL_OROM;
730 }
731
732 if (dev_caps->common_cap.nvm_update_pending_netlist) {
733 dev_info(dev, "The fw.netlist flash component has a pending update\n");
734 pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
735 }
736
737 kfree(dev_caps);
738
739 /* If the flash_update request is for a specific component, ignore all
740 * of the other components.
741 */
742 if (component) {
743 if (strcmp(component, "fw.mgmt") == 0)
744 pending &= ICE_AQC_NVM_ACTIV_SEL_NVM;
745 else if (strcmp(component, "fw.undi") == 0)
746 pending &= ICE_AQC_NVM_ACTIV_SEL_OROM;
747 else if (strcmp(component, "fw.netlist") == 0)
748 pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
749 else
750 WARN(1, "Unexpected flash component %s", component);
751 }
752
753 /* There is no previous pending update, so this request may continue */
754 if (!pending)
755 return 0;
756
757 /* In order to allow overwriting a previous pending update, notify
758 * firmware to cancel that update by issuing the appropriate command.
759 */
760 devlink_flash_update_status_notify(devlink,
761 "Canceling previous pending update",
762 component, 0, 0);
763
764 status = ice_acquire_nvm(hw, ICE_RES_WRITE);
765 if (status) {
766 dev_err(dev, "Failed to acquire device flash lock, err %s aq_err %s\n",
767 ice_stat_str(status),
768 ice_aq_str(hw->adminq.sq_last_status));
769 NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
770 return -EIO;
771 }
772
773 pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV;
774 err = ice_switch_flash_banks(pf, pending, extack);
775
776 ice_release_nvm(hw);
777
778 return err;
779}