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