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 
11 struct 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  */
35 static int
36 ice_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  */
82 static int
83 ice_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  */
195 static int
196 ice_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  */
271 static int
272 ice_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  */
361 static int
362 ice_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  */
439 static int
440 ice_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 
499 out_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  */
521 static 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  */
575 static int
576 ice_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  */
632 static 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 
642 static 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  */
667 int 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  */
732 int 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 }
817