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 	/* 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  */
47 static int
48 ice_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  */
93 static int
94 ice_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  */
206 static int
207 ice_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  */
289 static int
290 ice_write_one_nvm_block(struct ice_pf *pf, u16 module, u32 offset,
291 			u16 block_size, u8 *block, bool last_cmd,
292 			u8 *reset_level, struct netlink_ext_ack *extack)
293 {
294 	u16 completion_module, completion_retval;
295 	struct device *dev = ice_pf_to_dev(pf);
296 	struct ice_aq_task task = {};
297 	struct ice_hw *hw = &pf->hw;
298 	struct ice_aq_desc *desc;
299 	u32 completion_offset;
300 	int err;
301 
302 	dev_dbg(dev, "Writing block of %u bytes for module 0x%02x at offset %u\n",
303 		block_size, module, offset);
304 
305 	ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_write);
306 
307 	err = ice_aq_update_nvm(hw, module, offset, block_size, block,
308 				last_cmd, 0, NULL);
309 	if (err) {
310 		dev_err(dev, "Failed to flash module 0x%02x with block of size %u at offset %u, err %d aq_err %s\n",
311 			module, block_size, offset, err,
312 			ice_aq_str(hw->adminq.sq_last_status));
313 		NL_SET_ERR_MSG_MOD(extack, "Failed to program flash module");
314 		return -EIO;
315 	}
316 
317 	/* In most cases, firmware reports a write completion within a few
318 	 * milliseconds. However, it has been observed that a completion might
319 	 * take more than a second to complete in some cases. The timeout here
320 	 * is conservative and is intended to prevent failure to update when
321 	 * firmware is slow to respond.
322 	 */
323 	err = ice_aq_wait_for_event(pf, &task, 15 * HZ);
324 	if (err) {
325 		dev_err(dev, "Timed out while trying to flash module 0x%02x with block of size %u at offset %u, err %d\n",
326 			module, block_size, offset, err);
327 		NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
328 		return -EIO;
329 	}
330 
331 	desc = &task.event.desc;
332 	completion_module = le16_to_cpu(desc->params.nvm.module_typeid);
333 	completion_retval = le16_to_cpu(desc->retval);
334 
335 	completion_offset = le16_to_cpu(desc->params.nvm.offset_low);
336 	completion_offset |= desc->params.nvm.offset_high << 16;
337 
338 	if (completion_module != module) {
339 		dev_err(dev, "Unexpected module_typeid in write completion: got 0x%x, expected 0x%x\n",
340 			completion_module, module);
341 		NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
342 		return -EIO;
343 	}
344 
345 	if (completion_offset != offset) {
346 		dev_err(dev, "Unexpected offset in write completion: got %u, expected %u\n",
347 			completion_offset, offset);
348 		NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
349 		return -EIO;
350 	}
351 
352 	if (completion_retval) {
353 		dev_err(dev, "Firmware failed to flash module 0x%02x with block of size %u at offset %u, err %s\n",
354 			module, block_size, offset,
355 			ice_aq_str((enum ice_aq_err)completion_retval));
356 		NL_SET_ERR_MSG_MOD(extack, "Firmware failed to program flash module");
357 		return -EIO;
358 	}
359 
360 	/* For the last command to write the NVM bank, newer versions of
361 	 * firmware indicate the required level of reset to complete
362 	 * activation of firmware. If the firmware supports this, cache the
363 	 * response for indicating to the user later. Otherwise, assume that
364 	 * a full power cycle is required.
365 	 */
366 	if (reset_level && last_cmd && module == ICE_SR_1ST_NVM_BANK_PTR) {
367 		if (hw->dev_caps.common_cap.pcie_reset_avoidance) {
368 			*reset_level = desc->params.nvm.cmd_flags &
369 				       ICE_AQC_NVM_RESET_LVL_M;
370 			dev_dbg(dev, "Firmware reported required reset level as %u\n",
371 				*reset_level);
372 		} else {
373 			*reset_level = ICE_AQC_NVM_POR_FLAG;
374 			dev_dbg(dev, "Firmware doesn't support indicating required reset level. Assuming a power cycle is required\n");
375 		}
376 	}
377 
378 	return 0;
379 }
380 
381 /**
382  * ice_write_nvm_module - Write data to an NVM module
383  * @pf: the PF driver structure
384  * @module: the module id to program
385  * @component: the name of the component being updated
386  * @image: buffer of image data to write to the NVM
387  * @length: length of the buffer
388  * @reset_level: storage for reset level required
389  * @extack: netlink extended ACK structure
390  *
391  * Loop over the data for a given NVM module and program it in 4 Kb
392  * blocks. Notify devlink core of progress after each block is programmed.
393  * Loops over a block of data and programs the NVM in 4k block chunks.
394  *
395  * Note this function assumes the caller has acquired the NVM resource.
396  *
397  * Returns: zero on success, or a negative error code on failure.
398  */
399 static int
400 ice_write_nvm_module(struct ice_pf *pf, u16 module, const char *component,
401 		     const u8 *image, u32 length, u8 *reset_level,
402 		     struct netlink_ext_ack *extack)
403 {
404 	struct device *dev = ice_pf_to_dev(pf);
405 	struct devlink *devlink;
406 	u32 offset = 0;
407 	bool last_cmd;
408 	u8 *block;
409 	int err;
410 
411 	dev_dbg(dev, "Beginning write of flash component '%s', module 0x%02x\n", component, module);
412 
413 	devlink = priv_to_devlink(pf);
414 
415 	devlink_flash_update_status_notify(devlink, "Flashing",
416 					   component, 0, length);
417 
418 	block = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
419 	if (!block)
420 		return -ENOMEM;
421 
422 	do {
423 		u32 block_size;
424 
425 		block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset);
426 		last_cmd = !(offset + block_size < length);
427 
428 		/* ice_aq_update_nvm may copy the firmware response into the
429 		 * buffer, so we must make a copy since the source data is
430 		 * constant.
431 		 */
432 		memcpy(block, image + offset, block_size);
433 
434 		err = ice_write_one_nvm_block(pf, module, offset, block_size,
435 					      block, last_cmd, reset_level,
436 					      extack);
437 		if (err)
438 			break;
439 
440 		offset += block_size;
441 
442 		devlink_flash_update_status_notify(devlink, "Flashing",
443 						   component, offset, length);
444 	} while (!last_cmd);
445 
446 	dev_dbg(dev, "Completed write of flash component '%s', module 0x%02x\n", component, module);
447 
448 	if (err)
449 		devlink_flash_update_status_notify(devlink, "Flashing failed",
450 						   component, length, length);
451 	else
452 		devlink_flash_update_status_notify(devlink, "Flashing done",
453 						   component, length, length);
454 
455 	kfree(block);
456 	return err;
457 }
458 
459 /* Length in seconds to wait before timing out when erasing a flash module.
460  * Yes, erasing really can take minutes to complete.
461  */
462 #define ICE_FW_ERASE_TIMEOUT 300
463 
464 /**
465  * ice_erase_nvm_module - Erase an NVM module and await firmware completion
466  * @pf: the PF data structure
467  * @module: the module to erase
468  * @component: name of the component being updated
469  * @extack: netlink extended ACK structure
470  *
471  * Erase the inactive NVM bank associated with this module, and await for
472  * a completion response message from firmware.
473  *
474  * Note this function assumes the caller has acquired the NVM resource.
475  *
476  * Returns: zero on success, or a negative error code on failure.
477  */
478 static int
479 ice_erase_nvm_module(struct ice_pf *pf, u16 module, const char *component,
480 		     struct netlink_ext_ack *extack)
481 {
482 	u16 completion_module, completion_retval;
483 	struct device *dev = ice_pf_to_dev(pf);
484 	struct ice_aq_task task = {};
485 	struct ice_hw *hw = &pf->hw;
486 	struct ice_aq_desc *desc;
487 	struct devlink *devlink;
488 	int err;
489 
490 	dev_dbg(dev, "Beginning erase of flash component '%s', module 0x%02x\n", component, module);
491 
492 	devlink = priv_to_devlink(pf);
493 
494 	devlink_flash_update_timeout_notify(devlink, "Erasing", component, ICE_FW_ERASE_TIMEOUT);
495 
496 	ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_erase);
497 
498 	err = ice_aq_erase_nvm(hw, module, NULL);
499 	if (err) {
500 		dev_err(dev, "Failed to erase %s (module 0x%02x), err %d aq_err %s\n",
501 			component, module, err,
502 			ice_aq_str(hw->adminq.sq_last_status));
503 		NL_SET_ERR_MSG_MOD(extack, "Failed to erase flash module");
504 		err = -EIO;
505 		goto out_notify_devlink;
506 	}
507 
508 	err = ice_aq_wait_for_event(pf, &task, ICE_FW_ERASE_TIMEOUT * HZ);
509 	if (err) {
510 		dev_err(dev, "Timed out waiting for firmware to respond with erase completion for %s (module 0x%02x), err %d\n",
511 			component, module, err);
512 		NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
513 		goto out_notify_devlink;
514 	}
515 
516 	desc = &task.event.desc;
517 	completion_module = le16_to_cpu(desc->params.nvm.module_typeid);
518 	completion_retval = le16_to_cpu(desc->retval);
519 
520 	if (completion_module != module) {
521 		dev_err(dev, "Unexpected module_typeid in erase completion for %s: got 0x%x, expected 0x%x\n",
522 			component, completion_module, module);
523 		NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
524 		err = -EIO;
525 		goto out_notify_devlink;
526 	}
527 
528 	if (completion_retval) {
529 		dev_err(dev, "Firmware failed to erase %s (module 0x02%x), aq_err %s\n",
530 			component, module,
531 			ice_aq_str((enum ice_aq_err)completion_retval));
532 		NL_SET_ERR_MSG_MOD(extack, "Firmware failed to erase flash");
533 		err = -EIO;
534 		goto out_notify_devlink;
535 	}
536 
537 	dev_dbg(dev, "Completed erase of flash component '%s', module 0x%02x\n", component, module);
538 
539 out_notify_devlink:
540 	if (err)
541 		devlink_flash_update_status_notify(devlink, "Erasing failed",
542 						   component, 0, 0);
543 	else
544 		devlink_flash_update_status_notify(devlink, "Erasing done",
545 						   component, 0, 0);
546 
547 	return err;
548 }
549 
550 /**
551  * ice_switch_flash_banks - Tell firmware to switch NVM banks
552  * @pf: Pointer to the PF data structure
553  * @activate_flags: flags used for the activation command
554  * @emp_reset_available: on return, indicates if EMP reset is available
555  * @extack: netlink extended ACK structure
556  *
557  * Notify firmware to activate the newly written flash banks, and wait for the
558  * firmware response.
559  *
560  * Returns: zero on success or an error code on failure.
561  */
562 static int
563 ice_switch_flash_banks(struct ice_pf *pf, u8 activate_flags,
564 		       u8 *emp_reset_available, struct netlink_ext_ack *extack)
565 {
566 	struct device *dev = ice_pf_to_dev(pf);
567 	struct ice_aq_task task = {};
568 	struct ice_hw *hw = &pf->hw;
569 	u16 completion_retval;
570 	u8 response_flags;
571 	int err;
572 
573 	ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_write_activate);
574 
575 	err = ice_nvm_write_activate(hw, activate_flags, &response_flags);
576 	if (err) {
577 		dev_err(dev, "Failed to switch active flash banks, err %d aq_err %s\n",
578 			err, ice_aq_str(hw->adminq.sq_last_status));
579 		NL_SET_ERR_MSG_MOD(extack, "Failed to switch active flash banks");
580 		return -EIO;
581 	}
582 
583 	/* Newer versions of firmware have support to indicate whether an EMP
584 	 * reset to reload firmware is available. For older firmware, EMP
585 	 * reset is always available.
586 	 */
587 	if (emp_reset_available) {
588 		if (hw->dev_caps.common_cap.reset_restrict_support) {
589 			*emp_reset_available = response_flags & ICE_AQC_NVM_EMPR_ENA;
590 			dev_dbg(dev, "Firmware indicated that EMP reset is %s\n",
591 				*emp_reset_available ?
592 				"available" : "not available");
593 		} else {
594 			*emp_reset_available = ICE_AQC_NVM_EMPR_ENA;
595 			dev_dbg(dev, "Firmware does not support restricting EMP reset availability\n");
596 		}
597 	}
598 
599 	err = ice_aq_wait_for_event(pf, &task, 30 * HZ);
600 	if (err) {
601 		dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n",
602 			err);
603 		NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
604 		return err;
605 	}
606 
607 	completion_retval = le16_to_cpu(task.event.desc.retval);
608 	if (completion_retval) {
609 		dev_err(dev, "Firmware failed to switch active flash banks aq_err %s\n",
610 			ice_aq_str((enum ice_aq_err)completion_retval));
611 		NL_SET_ERR_MSG_MOD(extack, "Firmware failed to switch active flash banks");
612 		return -EIO;
613 	}
614 
615 	return 0;
616 }
617 
618 /**
619  * ice_flash_component - Flash a component of the NVM
620  * @context: PLDM fw update structure
621  * @component: the component table to program
622  *
623  * Program the flash contents for a given component. First, determine the
624  * module id. Then, erase the secondary bank for this module. Finally, write
625  * the contents of the component to the NVM.
626  *
627  * Note this function assumes the caller has acquired the NVM resource.
628  *
629  * Returns: zero on success, or a negative error code on failure.
630  */
631 static int
632 ice_flash_component(struct pldmfw *context, struct pldmfw_component *component)
633 {
634 	struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
635 	struct netlink_ext_ack *extack = priv->extack;
636 	struct ice_pf *pf = priv->pf;
637 	const char *name;
638 	u8 *reset_level;
639 	u16 module;
640 	u8 flag;
641 	int err;
642 
643 	switch (component->identifier) {
644 	case NVM_COMP_ID_OROM:
645 		module = ICE_SR_1ST_OROM_BANK_PTR;
646 		flag = ICE_AQC_NVM_ACTIV_SEL_OROM;
647 		reset_level = NULL;
648 		name = "fw.undi";
649 		break;
650 	case NVM_COMP_ID_NVM:
651 		module = ICE_SR_1ST_NVM_BANK_PTR;
652 		flag = ICE_AQC_NVM_ACTIV_SEL_NVM;
653 		reset_level = &priv->reset_level;
654 		name = "fw.mgmt";
655 		break;
656 	case NVM_COMP_ID_NETLIST:
657 		module = ICE_SR_NETLIST_BANK_PTR;
658 		flag = ICE_AQC_NVM_ACTIV_SEL_NETLIST;
659 		reset_level = NULL;
660 		name = "fw.netlist";
661 		break;
662 	default:
663 		/* This should not trigger, since we check the id before
664 		 * sending the component table to firmware.
665 		 */
666 		WARN(1, "Unexpected unknown component identifier 0x%02x",
667 		     component->identifier);
668 		return -EINVAL;
669 	}
670 
671 	/* Mark this component for activating at the end */
672 	priv->activate_flags |= flag;
673 
674 	err = ice_erase_nvm_module(pf, module, name, extack);
675 	if (err)
676 		return err;
677 
678 	return ice_write_nvm_module(pf, module, name, component->component_data,
679 				    component->component_size, reset_level,
680 				    extack);
681 }
682 
683 /**
684  * ice_finalize_update - Perform last steps to complete device update
685  * @context: PLDM fw update structure
686  *
687  * Called as the last step of the update process. Complete the update by
688  * telling the firmware to switch active banks, and perform a reset of
689  * configured.
690  *
691  * Returns: 0 on success, or an error code on failure.
692  */
693 static int ice_finalize_update(struct pldmfw *context)
694 {
695 	struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
696 	struct netlink_ext_ack *extack = priv->extack;
697 	struct ice_pf *pf = priv->pf;
698 	struct devlink *devlink;
699 	int err;
700 
701 	/* Finally, notify firmware to activate the written NVM banks */
702 	err = ice_switch_flash_banks(pf, priv->activate_flags,
703 				     &priv->emp_reset_available, extack);
704 	if (err)
705 		return err;
706 
707 	devlink = priv_to_devlink(pf);
708 
709 	/* If the required reset is EMPR, but EMPR is disabled, report that
710 	 * a reboot is required instead.
711 	 */
712 	if (priv->reset_level == ICE_AQC_NVM_EMPR_FLAG &&
713 	    !priv->emp_reset_available) {
714 		dev_dbg(ice_pf_to_dev(pf), "Firmware indicated EMP reset as sufficient, but EMP reset is disabled\n");
715 		priv->reset_level = ICE_AQC_NVM_PERST_FLAG;
716 	}
717 
718 	switch (priv->reset_level) {
719 	case ICE_AQC_NVM_EMPR_FLAG:
720 		devlink_flash_update_status_notify(devlink,
721 						   "Activate new firmware by devlink reload",
722 						   NULL, 0, 0);
723 		break;
724 	case ICE_AQC_NVM_PERST_FLAG:
725 		devlink_flash_update_status_notify(devlink,
726 						   "Activate new firmware by rebooting the system",
727 						   NULL, 0, 0);
728 		break;
729 	case ICE_AQC_NVM_POR_FLAG:
730 	default:
731 		devlink_flash_update_status_notify(devlink,
732 						   "Activate new firmware by power cycling the system",
733 						   NULL, 0, 0);
734 		break;
735 	}
736 
737 	pf->fw_emp_reset_disabled = !priv->emp_reset_available;
738 
739 	return 0;
740 }
741 
742 struct ice_pldm_pci_record_id {
743 	u32 vendor;
744 	u32 device;
745 	u32 subsystem_vendor;
746 	u32 subsystem_device;
747 };
748 
749 /**
750  * ice_op_pci_match_record - Check if a PCI device matches the record
751  * @context: PLDM fw update structure
752  * @record: list of records extracted from the PLDM image
753  *
754  * Determine if the PCI device associated with this device matches the record
755  * data provided.
756  *
757  * Searches the descriptor TLVs and extracts the relevant descriptor data into
758  * a pldm_pci_record_id. This is then compared against the PCI device ID
759  * information.
760  *
761  * Returns: true if the device matches the record, false otherwise.
762  */
763 static bool
764 ice_op_pci_match_record(struct pldmfw *context, struct pldmfw_record *record)
765 {
766 	struct pci_dev *pdev = to_pci_dev(context->dev);
767 	struct ice_pldm_pci_record_id id = {
768 		.vendor = PCI_ANY_ID,
769 		.device = PCI_ANY_ID,
770 		.subsystem_vendor = PCI_ANY_ID,
771 		.subsystem_device = PCI_ANY_ID,
772 	};
773 	struct pldmfw_desc_tlv *desc;
774 
775 	list_for_each_entry(desc, &record->descs, entry) {
776 		u16 value;
777 		int *ptr;
778 
779 		switch (desc->type) {
780 		case PLDM_DESC_ID_PCI_VENDOR_ID:
781 			ptr = &id.vendor;
782 			break;
783 		case PLDM_DESC_ID_PCI_DEVICE_ID:
784 			ptr = &id.device;
785 			break;
786 		case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
787 			ptr = &id.subsystem_vendor;
788 			break;
789 		case PLDM_DESC_ID_PCI_SUBDEV_ID:
790 			ptr = &id.subsystem_device;
791 			break;
792 		default:
793 			/* Skip unrelated TLVs */
794 			continue;
795 		}
796 
797 		value = get_unaligned_le16(desc->data);
798 		/* A value of zero for one of the descriptors is sometimes
799 		 * used when the record should ignore this field when matching
800 		 * device. For example if the record applies to any subsystem
801 		 * device or vendor.
802 		 */
803 		if (value)
804 			*ptr = value;
805 		else
806 			*ptr = PCI_ANY_ID;
807 	}
808 
809 	/* the E822 device can have a generic device ID so check for that */
810 	if ((id.vendor == PCI_ANY_ID || id.vendor == pdev->vendor) &&
811 	    (id.device == PCI_ANY_ID || id.device == pdev->device ||
812 	    id.device == ICE_DEV_ID_E822_SI_DFLT) &&
813 	    (id.subsystem_vendor == PCI_ANY_ID ||
814 	    id.subsystem_vendor == pdev->subsystem_vendor) &&
815 	    (id.subsystem_device == PCI_ANY_ID ||
816 	    id.subsystem_device == pdev->subsystem_device))
817 		return true;
818 
819 	return false;
820 }
821 
822 static const struct pldmfw_ops ice_fwu_ops_e810 = {
823 	.match_record = &pldmfw_op_pci_match_record,
824 	.send_package_data = &ice_send_package_data,
825 	.send_component_table = &ice_send_component_table,
826 	.flash_component = &ice_flash_component,
827 	.finalize_update = &ice_finalize_update,
828 };
829 
830 static const struct pldmfw_ops ice_fwu_ops_e822 = {
831 	.match_record = &ice_op_pci_match_record,
832 	.send_package_data = &ice_send_package_data,
833 	.send_component_table = &ice_send_component_table,
834 	.flash_component = &ice_flash_component,
835 	.finalize_update = &ice_finalize_update,
836 };
837 
838 /**
839  * ice_get_pending_updates - Check if the component has a pending update
840  * @pf: the PF driver structure
841  * @pending: on return, bitmap of updates pending
842  * @extack: Netlink extended ACK
843  *
844  * Check if the device has any pending updates on any flash components.
845  *
846  * Returns: zero on success, or a negative error code on failure. Updates
847  * pending with the bitmap of pending updates.
848  */
849 int ice_get_pending_updates(struct ice_pf *pf, u8 *pending,
850 			    struct netlink_ext_ack *extack)
851 {
852 	struct device *dev = ice_pf_to_dev(pf);
853 	struct ice_hw_dev_caps *dev_caps;
854 	struct ice_hw *hw = &pf->hw;
855 	int err;
856 
857 	dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL);
858 	if (!dev_caps)
859 		return -ENOMEM;
860 
861 	/* Read the most recent device capabilities from firmware. Do not use
862 	 * the cached values in hw->dev_caps, because the pending update flag
863 	 * may have changed, e.g. if an update was previously completed and
864 	 * the system has not yet rebooted.
865 	 */
866 	err = ice_discover_dev_caps(hw, dev_caps);
867 	if (err) {
868 		NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities");
869 		kfree(dev_caps);
870 		return err;
871 	}
872 
873 	*pending = 0;
874 
875 	if (dev_caps->common_cap.nvm_update_pending_nvm) {
876 		dev_info(dev, "The fw.mgmt flash component has a pending update\n");
877 		*pending |= ICE_AQC_NVM_ACTIV_SEL_NVM;
878 	}
879 
880 	if (dev_caps->common_cap.nvm_update_pending_orom) {
881 		dev_info(dev, "The fw.undi flash component has a pending update\n");
882 		*pending |= ICE_AQC_NVM_ACTIV_SEL_OROM;
883 	}
884 
885 	if (dev_caps->common_cap.nvm_update_pending_netlist) {
886 		dev_info(dev, "The fw.netlist flash component has a pending update\n");
887 		*pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
888 	}
889 
890 	kfree(dev_caps);
891 
892 	return 0;
893 }
894 
895 /**
896  * ice_cancel_pending_update - Cancel any pending update for a component
897  * @pf: the PF driver structure
898  * @component: if not NULL, the name of the component being updated
899  * @extack: Netlink extended ACK structure
900  *
901  * Cancel any pending update for the specified component. If component is
902  * NULL, all device updates will be canceled.
903  *
904  * Returns: zero on success, or a negative error code on failure.
905  */
906 static int
907 ice_cancel_pending_update(struct ice_pf *pf, const char *component,
908 			  struct netlink_ext_ack *extack)
909 {
910 	struct devlink *devlink = priv_to_devlink(pf);
911 	struct device *dev = ice_pf_to_dev(pf);
912 	struct ice_hw *hw = &pf->hw;
913 	u8 pending;
914 	int err;
915 
916 	err = ice_get_pending_updates(pf, &pending, extack);
917 	if (err)
918 		return err;
919 
920 	/* If the flash_update request is for a specific component, ignore all
921 	 * of the other components.
922 	 */
923 	if (component) {
924 		if (strcmp(component, "fw.mgmt") == 0)
925 			pending &= ICE_AQC_NVM_ACTIV_SEL_NVM;
926 		else if (strcmp(component, "fw.undi") == 0)
927 			pending &= ICE_AQC_NVM_ACTIV_SEL_OROM;
928 		else if (strcmp(component, "fw.netlist") == 0)
929 			pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
930 		else
931 			WARN(1, "Unexpected flash component %s", component);
932 	}
933 
934 	/* There is no previous pending update, so this request may continue */
935 	if (!pending)
936 		return 0;
937 
938 	/* In order to allow overwriting a previous pending update, notify
939 	 * firmware to cancel that update by issuing the appropriate command.
940 	 */
941 	devlink_flash_update_status_notify(devlink,
942 					   "Canceling previous pending update",
943 					   component, 0, 0);
944 
945 	err = ice_acquire_nvm(hw, ICE_RES_WRITE);
946 	if (err) {
947 		dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
948 			err, ice_aq_str(hw->adminq.sq_last_status));
949 		NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
950 		return err;
951 	}
952 
953 	pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV;
954 	err = ice_switch_flash_banks(pf, pending, NULL, extack);
955 
956 	ice_release_nvm(hw);
957 
958 	/* Since we've canceled the pending update, we no longer know if EMP
959 	 * reset is restricted.
960 	 */
961 	pf->fw_emp_reset_disabled = false;
962 
963 	return err;
964 }
965 
966 /**
967  * ice_devlink_flash_update - Write a firmware image to the device
968  * @devlink: pointer to devlink associated with the device to update
969  * @params: devlink flash update parameters
970  * @extack: netlink extended ACK structure
971  *
972  * Parse the data for a given firmware file, verifying that it is a valid PLDM
973  * formatted image that matches this device.
974  *
975  * Extract the device record Package Data and Component Tables and send them
976  * to the firmware. Extract and write the flash data for each of the three
977  * main flash components, "fw.mgmt", "fw.undi", and "fw.netlist". Notify
978  * firmware once the data is written to the inactive banks.
979  *
980  * Returns: zero on success or a negative error code on failure.
981  */
982 int ice_devlink_flash_update(struct devlink *devlink,
983 			     struct devlink_flash_update_params *params,
984 			     struct netlink_ext_ack *extack)
985 {
986 	struct ice_pf *pf = devlink_priv(devlink);
987 	struct device *dev = ice_pf_to_dev(pf);
988 	struct ice_hw *hw = &pf->hw;
989 	struct ice_fwu_priv priv;
990 	u8 preservation;
991 	int err;
992 
993 	if (!params->overwrite_mask) {
994 		/* preserve all settings and identifiers */
995 		preservation = ICE_AQC_NVM_PRESERVE_ALL;
996 	} else if (params->overwrite_mask == DEVLINK_FLASH_OVERWRITE_SETTINGS) {
997 		/* overwrite settings, but preserve the vital device identifiers */
998 		preservation = ICE_AQC_NVM_PRESERVE_SELECTED;
999 	} else if (params->overwrite_mask == (DEVLINK_FLASH_OVERWRITE_SETTINGS |
1000 					      DEVLINK_FLASH_OVERWRITE_IDENTIFIERS)) {
1001 		/* overwrite both settings and identifiers, preserve nothing */
1002 		preservation = ICE_AQC_NVM_NO_PRESERVATION;
1003 	} else {
1004 		NL_SET_ERR_MSG_MOD(extack, "Requested overwrite mask is not supported");
1005 		return -EOPNOTSUPP;
1006 	}
1007 
1008 	if (!hw->dev_caps.common_cap.nvm_unified_update) {
1009 		NL_SET_ERR_MSG_MOD(extack, "Current firmware does not support unified update");
1010 		return -EOPNOTSUPP;
1011 	}
1012 
1013 	memset(&priv, 0, sizeof(priv));
1014 
1015 	/* the E822 device needs a slightly different ops */
1016 	if (hw->mac_type == ICE_MAC_GENERIC)
1017 		priv.context.ops = &ice_fwu_ops_e822;
1018 	else
1019 		priv.context.ops = &ice_fwu_ops_e810;
1020 	priv.context.dev = dev;
1021 	priv.extack = extack;
1022 	priv.pf = pf;
1023 	priv.activate_flags = preservation;
1024 
1025 	devlink_flash_update_status_notify(devlink, "Preparing to flash", NULL, 0, 0);
1026 
1027 	err = ice_cancel_pending_update(pf, NULL, extack);
1028 	if (err)
1029 		return err;
1030 
1031 	err = ice_acquire_nvm(hw, ICE_RES_WRITE);
1032 	if (err) {
1033 		dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
1034 			err, ice_aq_str(hw->adminq.sq_last_status));
1035 		NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
1036 		return err;
1037 	}
1038 
1039 	err = pldmfw_flash_image(&priv.context, params->fw);
1040 	if (err == -ENOENT) {
1041 		dev_err(dev, "Firmware image has no record matching this device\n");
1042 		NL_SET_ERR_MSG_MOD(extack, "Firmware image has no record matching this device");
1043 	} else if (err) {
1044 		/* Do not set a generic extended ACK message here. A more
1045 		 * specific message may already have been set by one of our
1046 		 * ops.
1047 		 */
1048 		dev_err(dev, "Failed to flash PLDM image, err %d", err);
1049 	}
1050 
1051 	ice_release_nvm(hw);
1052 
1053 	return err;
1054 }
1055