1d69ea414SJacob Keller // SPDX-License-Identifier: GPL-2.0
2d69ea414SJacob Keller /* Copyright (C) 2018-2019, Intel Corporation. */
3d69ea414SJacob Keller
4d69ea414SJacob Keller #include <asm/unaligned.h>
5d69ea414SJacob Keller #include <linux/uuid.h>
6d69ea414SJacob Keller #include <linux/crc32.h>
7d69ea414SJacob Keller #include <linux/pldmfw.h>
8d69ea414SJacob Keller #include "ice.h"
9d69ea414SJacob Keller #include "ice_fw_update.h"
10d69ea414SJacob Keller
11d69ea414SJacob Keller struct ice_fwu_priv {
12d69ea414SJacob Keller struct pldmfw context;
13d69ea414SJacob Keller
14d69ea414SJacob Keller struct ice_pf *pf;
15d69ea414SJacob Keller struct netlink_ext_ack *extack;
16d69ea414SJacob Keller
17d69ea414SJacob Keller /* Track which NVM banks to activate at the end of the update */
18d69ea414SJacob Keller u8 activate_flags;
19399e27dbSJacob Keller
20399e27dbSJacob Keller /* Track the firmware response of the required reset to complete the
21399e27dbSJacob Keller * flash update.
22399e27dbSJacob Keller *
23399e27dbSJacob Keller * 0 - ICE_AQC_NVM_POR_FLAG - A full power on is required
24399e27dbSJacob Keller * 1 - ICE_AQC_NVM_PERST_FLAG - A cold PCIe reset is required
25399e27dbSJacob Keller * 2 - ICE_AQC_NVM_EMPR_FLAG - An EMP reset is required
26399e27dbSJacob Keller */
27399e27dbSJacob Keller u8 reset_level;
28399e27dbSJacob Keller
29399e27dbSJacob Keller /* Track if EMP reset is available */
30399e27dbSJacob Keller u8 emp_reset_available;
31d69ea414SJacob Keller };
32d69ea414SJacob Keller
33d69ea414SJacob Keller /**
34d69ea414SJacob Keller * ice_send_package_data - Send record package data to firmware
35d69ea414SJacob Keller * @context: PLDM fw update structure
36d69ea414SJacob Keller * @data: pointer to the package data
37d69ea414SJacob Keller * @length: length of the package data
38d69ea414SJacob Keller *
39d69ea414SJacob Keller * Send a copy of the package data associated with the PLDM record matching
40d69ea414SJacob Keller * this device to the firmware.
41d69ea414SJacob Keller *
42d69ea414SJacob Keller * Note that this function sends an AdminQ command that will fail unless the
43d69ea414SJacob Keller * NVM resource has been acquired.
44d69ea414SJacob Keller *
45d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure.
46d69ea414SJacob Keller */
47d69ea414SJacob Keller static int
ice_send_package_data(struct pldmfw * context,const u8 * data,u16 length)48d69ea414SJacob Keller ice_send_package_data(struct pldmfw *context, const u8 *data, u16 length)
49d69ea414SJacob Keller {
50d69ea414SJacob Keller struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
51d69ea414SJacob Keller struct netlink_ext_ack *extack = priv->extack;
52d69ea414SJacob Keller struct device *dev = context->dev;
53d69ea414SJacob Keller struct ice_pf *pf = priv->pf;
54d69ea414SJacob Keller struct ice_hw *hw = &pf->hw;
55d69ea414SJacob Keller u8 *package_data;
565518ac2aSTony Nguyen int status;
57d69ea414SJacob Keller
581e8249ccSJacob Keller dev_dbg(dev, "Sending PLDM record package data to firmware\n");
591e8249ccSJacob Keller
60d69ea414SJacob Keller package_data = kmemdup(data, length, GFP_KERNEL);
61d69ea414SJacob Keller if (!package_data)
62d69ea414SJacob Keller return -ENOMEM;
63d69ea414SJacob Keller
64d69ea414SJacob Keller status = ice_nvm_set_pkg_data(hw, false, package_data, length, NULL);
65d69ea414SJacob Keller
66d69ea414SJacob Keller kfree(package_data);
67d69ea414SJacob Keller
68d69ea414SJacob Keller if (status) {
695f87ec48STony Nguyen dev_err(dev, "Failed to send record package data to firmware, err %d aq_err %s\n",
705518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status));
71d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to record package data to firmware");
72d69ea414SJacob Keller return -EIO;
73d69ea414SJacob Keller }
74d69ea414SJacob Keller
75d69ea414SJacob Keller return 0;
76d69ea414SJacob Keller }
77d69ea414SJacob Keller
78d69ea414SJacob Keller /**
79d69ea414SJacob Keller * ice_check_component_response - Report firmware response to a component
80d69ea414SJacob Keller * @pf: device private data structure
81d69ea414SJacob Keller * @id: component id being checked
82d69ea414SJacob Keller * @response: indicates whether this component can be updated
83d69ea414SJacob Keller * @code: code indicating reason for response
84d69ea414SJacob Keller * @extack: netlink extended ACK structure
85d69ea414SJacob Keller *
86d69ea414SJacob Keller * Check whether firmware indicates if this component can be updated. Report
87d69ea414SJacob Keller * a suitable error message over the netlink extended ACK if the component
88d69ea414SJacob Keller * cannot be updated.
89d69ea414SJacob Keller *
90d69ea414SJacob Keller * Returns: zero if the component can be updated, or -ECANCELED of the
91d69ea414SJacob Keller * firmware indicates the component cannot be updated.
92d69ea414SJacob Keller */
93d69ea414SJacob Keller static int
ice_check_component_response(struct ice_pf * pf,u16 id,u8 response,u8 code,struct netlink_ext_ack * extack)94d69ea414SJacob Keller ice_check_component_response(struct ice_pf *pf, u16 id, u8 response, u8 code,
95d69ea414SJacob Keller struct netlink_ext_ack *extack)
96d69ea414SJacob Keller {
97d69ea414SJacob Keller struct device *dev = ice_pf_to_dev(pf);
98d69ea414SJacob Keller const char *component;
99d69ea414SJacob Keller
100d69ea414SJacob Keller switch (id) {
101d69ea414SJacob Keller case NVM_COMP_ID_OROM:
102d69ea414SJacob Keller component = "fw.undi";
103d69ea414SJacob Keller break;
104d69ea414SJacob Keller case NVM_COMP_ID_NVM:
105d69ea414SJacob Keller component = "fw.mgmt";
106d69ea414SJacob Keller break;
107d69ea414SJacob Keller case NVM_COMP_ID_NETLIST:
108d69ea414SJacob Keller component = "fw.netlist";
109d69ea414SJacob Keller break;
110d69ea414SJacob Keller default:
111d69ea414SJacob Keller WARN(1, "Unexpected unknown component identifier 0x%02x", id);
112d69ea414SJacob Keller return -EINVAL;
113d69ea414SJacob Keller }
114d69ea414SJacob Keller
115d69ea414SJacob Keller dev_dbg(dev, "%s: firmware response 0x%x, code 0x%x\n",
116d69ea414SJacob Keller component, response, code);
117d69ea414SJacob Keller
118d69ea414SJacob Keller switch (response) {
119d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_CAN_BE_UPDATED:
120d69ea414SJacob Keller /* firmware indicated this update is good to proceed */
121d69ea414SJacob Keller return 0;
122d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_CAN_MAY_BE_UPDATEABLE:
123d69ea414SJacob Keller dev_warn(dev, "firmware recommends not updating %s, as it may result in a downgrade. continuing anyways\n", component);
124d69ea414SJacob Keller return 0;
125d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_CAN_NOT_BE_UPDATED:
126d69ea414SJacob Keller dev_info(dev, "firmware has rejected updating %s\n", component);
127d69ea414SJacob Keller break;
128d69ea414SJacob Keller }
129d69ea414SJacob Keller
130d69ea414SJacob Keller switch (code) {
131d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_STAMP_IDENTICAL_CODE:
132d69ea414SJacob Keller dev_err(dev, "Component comparison stamp for %s is identical to the running image\n",
133d69ea414SJacob Keller component);
134d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is identical to running image");
135d69ea414SJacob Keller break;
136d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_STAMP_LOWER:
137d69ea414SJacob Keller dev_err(dev, "Component comparison stamp for %s is lower than the running image\n",
138d69ea414SJacob Keller component);
139d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is lower than running image");
140d69ea414SJacob Keller break;
141d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_INVALID_STAMP_CODE:
142d69ea414SJacob Keller dev_err(dev, "Component comparison stamp for %s is invalid\n",
143d69ea414SJacob Keller component);
144d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component comparison stamp is invalid");
145d69ea414SJacob Keller break;
146d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_CONFLICT_CODE:
147d69ea414SJacob Keller dev_err(dev, "%s conflicts with a previous component table\n",
148d69ea414SJacob Keller component);
149d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component table conflict occurred");
150d69ea414SJacob Keller break;
151d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_PRE_REQ_NOT_MET_CODE:
152d69ea414SJacob Keller dev_err(dev, "Pre-requisites for component %s have not been met\n",
153d69ea414SJacob Keller component);
154d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component pre-requisites not met");
155d69ea414SJacob Keller break;
156d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_NOT_SUPPORTED_CODE:
157d69ea414SJacob Keller dev_err(dev, "%s is not a supported component\n",
158d69ea414SJacob Keller component);
159d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component not supported");
160d69ea414SJacob Keller break;
161d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_CANNOT_DOWNGRADE_CODE:
162d69ea414SJacob Keller dev_err(dev, "Security restrictions prevent %s from being downgraded\n",
163d69ea414SJacob Keller component);
164d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component cannot be downgraded");
165d69ea414SJacob Keller break;
166d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_INCOMPLETE_IMAGE_CODE:
167d69ea414SJacob Keller dev_err(dev, "Received an incomplete component image for %s\n",
168d69ea414SJacob Keller component);
169d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Incomplete component image");
170d69ea414SJacob Keller break;
171d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_VER_STR_IDENTICAL_CODE:
172d69ea414SJacob Keller dev_err(dev, "Component version for %s is identical to the running image\n",
173d69ea414SJacob Keller component);
174d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component version is identical to running image");
175d69ea414SJacob Keller break;
176d69ea414SJacob Keller case ICE_AQ_NVM_PASS_COMP_VER_STR_LOWER_CODE:
177d69ea414SJacob Keller dev_err(dev, "Component version for %s is lower than the running image\n",
178d69ea414SJacob Keller component);
179d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Component version is lower than the running image");
180d69ea414SJacob Keller break;
181d69ea414SJacob Keller default:
182d69ea414SJacob Keller dev_err(dev, "Unexpected response code 0x02%x for %s\n",
183d69ea414SJacob Keller code, component);
184d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Received unexpected response code from firmware");
185d69ea414SJacob Keller break;
186d69ea414SJacob Keller }
187d69ea414SJacob Keller
188d69ea414SJacob Keller return -ECANCELED;
189d69ea414SJacob Keller }
190d69ea414SJacob Keller
191d69ea414SJacob Keller /**
192d69ea414SJacob Keller * ice_send_component_table - Send PLDM component table to firmware
193d69ea414SJacob Keller * @context: PLDM fw update structure
194d69ea414SJacob Keller * @component: the component to process
195d69ea414SJacob Keller * @transfer_flag: relative transfer order of this component
196d69ea414SJacob Keller *
197d69ea414SJacob Keller * Read relevant data from the component and forward it to the device
198d69ea414SJacob Keller * firmware. Check the response to determine if the firmware indicates that
199d69ea414SJacob Keller * the update can proceed.
200d69ea414SJacob Keller *
201d69ea414SJacob Keller * This function sends AdminQ commands related to the NVM, and assumes that
202d69ea414SJacob Keller * the NVM resource has been acquired.
203d69ea414SJacob Keller *
204d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure.
205d69ea414SJacob Keller */
206d69ea414SJacob Keller static int
ice_send_component_table(struct pldmfw * context,struct pldmfw_component * component,u8 transfer_flag)207d69ea414SJacob Keller ice_send_component_table(struct pldmfw *context, struct pldmfw_component *component,
208d69ea414SJacob Keller u8 transfer_flag)
209d69ea414SJacob Keller {
210d69ea414SJacob Keller struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
211d69ea414SJacob Keller struct netlink_ext_ack *extack = priv->extack;
212d69ea414SJacob Keller struct ice_aqc_nvm_comp_tbl *comp_tbl;
213d69ea414SJacob Keller u8 comp_response, comp_response_code;
214d69ea414SJacob Keller struct device *dev = context->dev;
215d69ea414SJacob Keller struct ice_pf *pf = priv->pf;
216d69ea414SJacob Keller struct ice_hw *hw = &pf->hw;
217d69ea414SJacob Keller size_t length;
2185518ac2aSTony Nguyen int status;
219d69ea414SJacob Keller
220d69ea414SJacob Keller switch (component->identifier) {
221d69ea414SJacob Keller case NVM_COMP_ID_OROM:
222d69ea414SJacob Keller case NVM_COMP_ID_NVM:
223d69ea414SJacob Keller case NVM_COMP_ID_NETLIST:
224d69ea414SJacob Keller break;
225d69ea414SJacob Keller default:
226d69ea414SJacob Keller dev_err(dev, "Unable to update due to a firmware component with unknown ID %u\n",
227d69ea414SJacob Keller component->identifier);
228d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Unable to update due to unknown firmware component");
229d69ea414SJacob Keller return -EOPNOTSUPP;
230d69ea414SJacob Keller }
231d69ea414SJacob Keller
232d69ea414SJacob Keller length = struct_size(comp_tbl, cvs, component->version_len);
233d69ea414SJacob Keller comp_tbl = kzalloc(length, GFP_KERNEL);
234d69ea414SJacob Keller if (!comp_tbl)
235d69ea414SJacob Keller return -ENOMEM;
236d69ea414SJacob Keller
237d69ea414SJacob Keller comp_tbl->comp_class = cpu_to_le16(component->classification);
238d69ea414SJacob Keller comp_tbl->comp_id = cpu_to_le16(component->identifier);
239d69ea414SJacob Keller comp_tbl->comp_class_idx = FWU_COMP_CLASS_IDX_NOT_USE;
240d69ea414SJacob Keller comp_tbl->comp_cmp_stamp = cpu_to_le32(component->comparison_stamp);
241d69ea414SJacob Keller comp_tbl->cvs_type = component->version_type;
242d69ea414SJacob Keller comp_tbl->cvs_len = component->version_len;
243d69ea414SJacob Keller memcpy(comp_tbl->cvs, component->version_string, component->version_len);
244d69ea414SJacob Keller
2451e8249ccSJacob Keller dev_dbg(dev, "Sending component table to firmware:\n");
2461e8249ccSJacob Keller
247d69ea414SJacob Keller status = ice_nvm_pass_component_tbl(hw, (u8 *)comp_tbl, length,
248d69ea414SJacob Keller transfer_flag, &comp_response,
249d69ea414SJacob Keller &comp_response_code, NULL);
250d69ea414SJacob Keller
251d69ea414SJacob Keller kfree(comp_tbl);
252d69ea414SJacob Keller
253d69ea414SJacob Keller if (status) {
2545f87ec48STony Nguyen dev_err(dev, "Failed to transfer component table to firmware, err %d aq_err %s\n",
2555518ac2aSTony Nguyen status, ice_aq_str(hw->adminq.sq_last_status));
256d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to transfer component table to firmware");
257d69ea414SJacob Keller return -EIO;
258d69ea414SJacob Keller }
259d69ea414SJacob Keller
260d69ea414SJacob Keller return ice_check_component_response(pf, component->identifier, comp_response,
261d69ea414SJacob Keller comp_response_code, extack);
262d69ea414SJacob Keller }
263d69ea414SJacob Keller
264d69ea414SJacob Keller /**
265d69ea414SJacob Keller * ice_write_one_nvm_block - Write an NVM block and await completion response
266d69ea414SJacob Keller * @pf: the PF data structure
267d69ea414SJacob Keller * @module: the module to write to
268d69ea414SJacob Keller * @offset: offset in bytes
269d69ea414SJacob Keller * @block_size: size of the block to write, up to 4k
270d69ea414SJacob Keller * @block: pointer to block of data to write
271d69ea414SJacob Keller * @last_cmd: whether this is the last command
272399e27dbSJacob Keller * @reset_level: storage for reset level required
273d69ea414SJacob Keller * @extack: netlink extended ACK structure
274d69ea414SJacob Keller *
275d69ea414SJacob Keller * Write a block of data to a flash module, and await for the completion
276d69ea414SJacob Keller * response message from firmware.
277d69ea414SJacob Keller *
278d69ea414SJacob Keller * Note this function assumes the caller has acquired the NVM resource.
279d69ea414SJacob Keller *
280399e27dbSJacob Keller * On successful return, reset level indicates the device reset required to
281399e27dbSJacob Keller * complete the update.
282399e27dbSJacob Keller *
283399e27dbSJacob Keller * 0 - ICE_AQC_NVM_POR_FLAG - A full power on is required
284399e27dbSJacob Keller * 1 - ICE_AQC_NVM_PERST_FLAG - A cold PCIe reset is required
285399e27dbSJacob Keller * 2 - ICE_AQC_NVM_EMPR_FLAG - An EMP reset is required
286399e27dbSJacob Keller *
287d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure.
288d69ea414SJacob Keller */
289d69ea414SJacob Keller static int
ice_write_one_nvm_block(struct ice_pf * pf,u16 module,u32 offset,u16 block_size,u8 * block,bool last_cmd,u8 * reset_level,struct netlink_ext_ack * extack)290d69ea414SJacob Keller ice_write_one_nvm_block(struct ice_pf *pf, u16 module, u32 offset,
291d69ea414SJacob Keller u16 block_size, u8 *block, bool last_cmd,
292399e27dbSJacob Keller u8 *reset_level, struct netlink_ext_ack *extack)
293d69ea414SJacob Keller {
294d69ea414SJacob Keller u16 completion_module, completion_retval;
295d69ea414SJacob Keller struct device *dev = ice_pf_to_dev(pf);
296b214b98aSPrzemek Kitszel struct ice_aq_task task = {};
297d69ea414SJacob Keller struct ice_hw *hw = &pf->hw;
298b214b98aSPrzemek Kitszel struct ice_aq_desc *desc;
299d69ea414SJacob Keller u32 completion_offset;
300d69ea414SJacob Keller int err;
301d69ea414SJacob Keller
3021e8249ccSJacob Keller dev_dbg(dev, "Writing block of %u bytes for module 0x%02x at offset %u\n",
3031e8249ccSJacob Keller block_size, module, offset);
3041e8249ccSJacob Keller
305*fb9840c4SPrzemek Kitszel ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_write);
306*fb9840c4SPrzemek Kitszel
3072ccc1c1cSTony Nguyen err = ice_aq_update_nvm(hw, module, offset, block_size, block,
308d69ea414SJacob Keller last_cmd, 0, NULL);
3092ccc1c1cSTony Nguyen if (err) {
3105f87ec48STony Nguyen dev_err(dev, "Failed to flash module 0x%02x with block of size %u at offset %u, err %d aq_err %s\n",
3112ccc1c1cSTony Nguyen module, block_size, offset, err,
312d69ea414SJacob Keller ice_aq_str(hw->adminq.sq_last_status));
313d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to program flash module");
314d69ea414SJacob Keller return -EIO;
315d69ea414SJacob Keller }
316d69ea414SJacob Keller
3170ec86e8eSJacob Keller /* In most cases, firmware reports a write completion within a few
3180ec86e8eSJacob Keller * milliseconds. However, it has been observed that a completion might
3190ec86e8eSJacob Keller * take more than a second to complete in some cases. The timeout here
3200ec86e8eSJacob Keller * is conservative and is intended to prevent failure to update when
3210ec86e8eSJacob Keller * firmware is slow to respond.
3220ec86e8eSJacob Keller */
323*fb9840c4SPrzemek Kitszel err = ice_aq_wait_for_event(pf, &task, 15 * HZ);
324d69ea414SJacob Keller if (err) {
3251e8249ccSJacob Keller dev_err(dev, "Timed out while trying to flash module 0x%02x with block of size %u at offset %u, err %d\n",
3261e8249ccSJacob Keller module, block_size, offset, err);
327d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
328d69ea414SJacob Keller return -EIO;
329d69ea414SJacob Keller }
330d69ea414SJacob Keller
331b214b98aSPrzemek Kitszel desc = &task.event.desc;
332b214b98aSPrzemek Kitszel completion_module = le16_to_cpu(desc->params.nvm.module_typeid);
333b214b98aSPrzemek Kitszel completion_retval = le16_to_cpu(desc->retval);
334d69ea414SJacob Keller
335b214b98aSPrzemek Kitszel completion_offset = le16_to_cpu(desc->params.nvm.offset_low);
336b214b98aSPrzemek Kitszel completion_offset |= desc->params.nvm.offset_high << 16;
337d69ea414SJacob Keller
338d69ea414SJacob Keller if (completion_module != module) {
339d69ea414SJacob Keller dev_err(dev, "Unexpected module_typeid in write completion: got 0x%x, expected 0x%x\n",
340d69ea414SJacob Keller completion_module, module);
341d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
342d69ea414SJacob Keller return -EIO;
343d69ea414SJacob Keller }
344d69ea414SJacob Keller
345d69ea414SJacob Keller if (completion_offset != offset) {
346d69ea414SJacob Keller dev_err(dev, "Unexpected offset in write completion: got %u, expected %u\n",
347d69ea414SJacob Keller completion_offset, offset);
348d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
349d69ea414SJacob Keller return -EIO;
350d69ea414SJacob Keller }
351d69ea414SJacob Keller
352d69ea414SJacob Keller if (completion_retval) {
3531e8249ccSJacob Keller dev_err(dev, "Firmware failed to flash module 0x%02x with block of size %u at offset %u, err %s\n",
3541e8249ccSJacob Keller module, block_size, offset,
355d69ea414SJacob Keller ice_aq_str((enum ice_aq_err)completion_retval));
356d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Firmware failed to program flash module");
357d69ea414SJacob Keller return -EIO;
358d69ea414SJacob Keller }
359d69ea414SJacob Keller
360399e27dbSJacob Keller /* For the last command to write the NVM bank, newer versions of
361399e27dbSJacob Keller * firmware indicate the required level of reset to complete
362399e27dbSJacob Keller * activation of firmware. If the firmware supports this, cache the
363399e27dbSJacob Keller * response for indicating to the user later. Otherwise, assume that
364399e27dbSJacob Keller * a full power cycle is required.
365399e27dbSJacob Keller */
366399e27dbSJacob Keller if (reset_level && last_cmd && module == ICE_SR_1ST_NVM_BANK_PTR) {
367399e27dbSJacob Keller if (hw->dev_caps.common_cap.pcie_reset_avoidance) {
368b214b98aSPrzemek Kitszel *reset_level = desc->params.nvm.cmd_flags &
369b214b98aSPrzemek Kitszel ICE_AQC_NVM_RESET_LVL_M;
370399e27dbSJacob Keller dev_dbg(dev, "Firmware reported required reset level as %u\n",
371399e27dbSJacob Keller *reset_level);
372399e27dbSJacob Keller } else {
373399e27dbSJacob Keller *reset_level = ICE_AQC_NVM_POR_FLAG;
374399e27dbSJacob Keller dev_dbg(dev, "Firmware doesn't support indicating required reset level. Assuming a power cycle is required\n");
375399e27dbSJacob Keller }
376399e27dbSJacob Keller }
377399e27dbSJacob Keller
378d69ea414SJacob Keller return 0;
379d69ea414SJacob Keller }
380d69ea414SJacob Keller
381d69ea414SJacob Keller /**
382d69ea414SJacob Keller * ice_write_nvm_module - Write data to an NVM module
383d69ea414SJacob Keller * @pf: the PF driver structure
384d69ea414SJacob Keller * @module: the module id to program
385d69ea414SJacob Keller * @component: the name of the component being updated
386d69ea414SJacob Keller * @image: buffer of image data to write to the NVM
387d69ea414SJacob Keller * @length: length of the buffer
388399e27dbSJacob Keller * @reset_level: storage for reset level required
389d69ea414SJacob Keller * @extack: netlink extended ACK structure
390d69ea414SJacob Keller *
391d69ea414SJacob Keller * Loop over the data for a given NVM module and program it in 4 Kb
392d69ea414SJacob Keller * blocks. Notify devlink core of progress after each block is programmed.
393d69ea414SJacob Keller * Loops over a block of data and programs the NVM in 4k block chunks.
394d69ea414SJacob Keller *
395d69ea414SJacob Keller * Note this function assumes the caller has acquired the NVM resource.
396d69ea414SJacob Keller *
397d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure.
398d69ea414SJacob Keller */
399d69ea414SJacob Keller static int
ice_write_nvm_module(struct ice_pf * pf,u16 module,const char * component,const u8 * image,u32 length,u8 * reset_level,struct netlink_ext_ack * extack)400d69ea414SJacob Keller ice_write_nvm_module(struct ice_pf *pf, u16 module, const char *component,
401399e27dbSJacob Keller const u8 *image, u32 length, u8 *reset_level,
402d69ea414SJacob Keller struct netlink_ext_ack *extack)
403d69ea414SJacob Keller {
4041e8249ccSJacob Keller struct device *dev = ice_pf_to_dev(pf);
405d69ea414SJacob Keller struct devlink *devlink;
406d69ea414SJacob Keller u32 offset = 0;
407d69ea414SJacob Keller bool last_cmd;
408d69ea414SJacob Keller u8 *block;
409d69ea414SJacob Keller int err;
410d69ea414SJacob Keller
4111e8249ccSJacob Keller dev_dbg(dev, "Beginning write of flash component '%s', module 0x%02x\n", component, module);
4121e8249ccSJacob Keller
413d69ea414SJacob Keller devlink = priv_to_devlink(pf);
414d69ea414SJacob Keller
415d69ea414SJacob Keller devlink_flash_update_status_notify(devlink, "Flashing",
416d69ea414SJacob Keller component, 0, length);
417d69ea414SJacob Keller
418d69ea414SJacob Keller block = kzalloc(ICE_AQ_MAX_BUF_LEN, GFP_KERNEL);
419d69ea414SJacob Keller if (!block)
420d69ea414SJacob Keller return -ENOMEM;
421d69ea414SJacob Keller
422d69ea414SJacob Keller do {
423d69ea414SJacob Keller u32 block_size;
424d69ea414SJacob Keller
425d69ea414SJacob Keller block_size = min_t(u32, ICE_AQ_MAX_BUF_LEN, length - offset);
426d69ea414SJacob Keller last_cmd = !(offset + block_size < length);
427d69ea414SJacob Keller
428d69ea414SJacob Keller /* ice_aq_update_nvm may copy the firmware response into the
429d69ea414SJacob Keller * buffer, so we must make a copy since the source data is
430d69ea414SJacob Keller * constant.
431d69ea414SJacob Keller */
432d69ea414SJacob Keller memcpy(block, image + offset, block_size);
433d69ea414SJacob Keller
434d69ea414SJacob Keller err = ice_write_one_nvm_block(pf, module, offset, block_size,
435399e27dbSJacob Keller block, last_cmd, reset_level,
436399e27dbSJacob Keller extack);
437d69ea414SJacob Keller if (err)
438d69ea414SJacob Keller break;
439d69ea414SJacob Keller
440d69ea414SJacob Keller offset += block_size;
441d69ea414SJacob Keller
442d69ea414SJacob Keller devlink_flash_update_status_notify(devlink, "Flashing",
443d69ea414SJacob Keller component, offset, length);
444d69ea414SJacob Keller } while (!last_cmd);
445d69ea414SJacob Keller
4461e8249ccSJacob Keller dev_dbg(dev, "Completed write of flash component '%s', module 0x%02x\n", component, module);
4471e8249ccSJacob Keller
448d69ea414SJacob Keller if (err)
449d69ea414SJacob Keller devlink_flash_update_status_notify(devlink, "Flashing failed",
450d69ea414SJacob Keller component, length, length);
451d69ea414SJacob Keller else
452d69ea414SJacob Keller devlink_flash_update_status_notify(devlink, "Flashing done",
453d69ea414SJacob Keller component, length, length);
454d69ea414SJacob Keller
455d69ea414SJacob Keller kfree(block);
456d69ea414SJacob Keller return err;
457d69ea414SJacob Keller }
458d69ea414SJacob Keller
45908e1294dSJacob Keller /* Length in seconds to wait before timing out when erasing a flash module.
46008e1294dSJacob Keller * Yes, erasing really can take minutes to complete.
46108e1294dSJacob Keller */
46208e1294dSJacob Keller #define ICE_FW_ERASE_TIMEOUT 300
46308e1294dSJacob Keller
464d69ea414SJacob Keller /**
465d69ea414SJacob Keller * ice_erase_nvm_module - Erase an NVM module and await firmware completion
466d69ea414SJacob Keller * @pf: the PF data structure
467d69ea414SJacob Keller * @module: the module to erase
468d69ea414SJacob Keller * @component: name of the component being updated
469d69ea414SJacob Keller * @extack: netlink extended ACK structure
470d69ea414SJacob Keller *
471d69ea414SJacob Keller * Erase the inactive NVM bank associated with this module, and await for
472d69ea414SJacob Keller * a completion response message from firmware.
473d69ea414SJacob Keller *
474d69ea414SJacob Keller * Note this function assumes the caller has acquired the NVM resource.
475d69ea414SJacob Keller *
476d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure.
477d69ea414SJacob Keller */
478d69ea414SJacob Keller static int
ice_erase_nvm_module(struct ice_pf * pf,u16 module,const char * component,struct netlink_ext_ack * extack)479d69ea414SJacob Keller ice_erase_nvm_module(struct ice_pf *pf, u16 module, const char *component,
480d69ea414SJacob Keller struct netlink_ext_ack *extack)
481d69ea414SJacob Keller {
482d69ea414SJacob Keller u16 completion_module, completion_retval;
483d69ea414SJacob Keller struct device *dev = ice_pf_to_dev(pf);
484b214b98aSPrzemek Kitszel struct ice_aq_task task = {};
485d69ea414SJacob Keller struct ice_hw *hw = &pf->hw;
486b214b98aSPrzemek Kitszel struct ice_aq_desc *desc;
487d69ea414SJacob Keller struct devlink *devlink;
488d69ea414SJacob Keller int err;
489d69ea414SJacob Keller
4901e8249ccSJacob Keller dev_dbg(dev, "Beginning erase of flash component '%s', module 0x%02x\n", component, module);
4911e8249ccSJacob Keller
492d69ea414SJacob Keller devlink = priv_to_devlink(pf);
493d69ea414SJacob Keller
49408e1294dSJacob Keller devlink_flash_update_timeout_notify(devlink, "Erasing", component, ICE_FW_ERASE_TIMEOUT);
495d69ea414SJacob Keller
496*fb9840c4SPrzemek Kitszel ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_erase);
497*fb9840c4SPrzemek Kitszel
4982ccc1c1cSTony Nguyen err = ice_aq_erase_nvm(hw, module, NULL);
4992ccc1c1cSTony Nguyen if (err) {
5005f87ec48STony Nguyen dev_err(dev, "Failed to erase %s (module 0x%02x), err %d aq_err %s\n",
5012ccc1c1cSTony Nguyen component, module, err,
502d69ea414SJacob Keller ice_aq_str(hw->adminq.sq_last_status));
503d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to erase flash module");
504d69ea414SJacob Keller err = -EIO;
505d69ea414SJacob Keller goto out_notify_devlink;
506d69ea414SJacob Keller }
507d69ea414SJacob Keller
508*fb9840c4SPrzemek Kitszel err = ice_aq_wait_for_event(pf, &task, ICE_FW_ERASE_TIMEOUT * HZ);
509d69ea414SJacob Keller if (err) {
510d69ea414SJacob Keller dev_err(dev, "Timed out waiting for firmware to respond with erase completion for %s (module 0x%02x), err %d\n",
511d69ea414SJacob Keller component, module, err);
512d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
513d69ea414SJacob Keller goto out_notify_devlink;
514d69ea414SJacob Keller }
515d69ea414SJacob Keller
516b214b98aSPrzemek Kitszel desc = &task.event.desc;
517b214b98aSPrzemek Kitszel completion_module = le16_to_cpu(desc->params.nvm.module_typeid);
518b214b98aSPrzemek Kitszel completion_retval = le16_to_cpu(desc->retval);
519d69ea414SJacob Keller
520d69ea414SJacob Keller if (completion_module != module) {
521d69ea414SJacob Keller dev_err(dev, "Unexpected module_typeid in erase completion for %s: got 0x%x, expected 0x%x\n",
522d69ea414SJacob Keller component, completion_module, module);
523d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Unexpected firmware response");
524d69ea414SJacob Keller err = -EIO;
525d69ea414SJacob Keller goto out_notify_devlink;
526d69ea414SJacob Keller }
527d69ea414SJacob Keller
528d69ea414SJacob Keller if (completion_retval) {
529d69ea414SJacob Keller dev_err(dev, "Firmware failed to erase %s (module 0x02%x), aq_err %s\n",
530d69ea414SJacob Keller component, module,
531d69ea414SJacob Keller ice_aq_str((enum ice_aq_err)completion_retval));
532d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Firmware failed to erase flash");
533d69ea414SJacob Keller err = -EIO;
534d69ea414SJacob Keller goto out_notify_devlink;
535d69ea414SJacob Keller }
536d69ea414SJacob Keller
5371e8249ccSJacob Keller dev_dbg(dev, "Completed erase of flash component '%s', module 0x%02x\n", component, module);
5381e8249ccSJacob Keller
539d69ea414SJacob Keller out_notify_devlink:
540d69ea414SJacob Keller if (err)
541d69ea414SJacob Keller devlink_flash_update_status_notify(devlink, "Erasing failed",
542d69ea414SJacob Keller component, 0, 0);
543d69ea414SJacob Keller else
544d69ea414SJacob Keller devlink_flash_update_status_notify(devlink, "Erasing done",
545d69ea414SJacob Keller component, 0, 0);
546d69ea414SJacob Keller
547d69ea414SJacob Keller return err;
548d69ea414SJacob Keller }
549d69ea414SJacob Keller
550d69ea414SJacob Keller /**
551d69ea414SJacob Keller * ice_switch_flash_banks - Tell firmware to switch NVM banks
552d69ea414SJacob Keller * @pf: Pointer to the PF data structure
553d69ea414SJacob Keller * @activate_flags: flags used for the activation command
554399e27dbSJacob Keller * @emp_reset_available: on return, indicates if EMP reset is available
555d69ea414SJacob Keller * @extack: netlink extended ACK structure
556d69ea414SJacob Keller *
557d69ea414SJacob Keller * Notify firmware to activate the newly written flash banks, and wait for the
558d69ea414SJacob Keller * firmware response.
559d69ea414SJacob Keller *
560d69ea414SJacob Keller * Returns: zero on success or an error code on failure.
561d69ea414SJacob Keller */
562399e27dbSJacob Keller static int
ice_switch_flash_banks(struct ice_pf * pf,u8 activate_flags,u8 * emp_reset_available,struct netlink_ext_ack * extack)563399e27dbSJacob Keller ice_switch_flash_banks(struct ice_pf *pf, u8 activate_flags,
564399e27dbSJacob Keller u8 *emp_reset_available, struct netlink_ext_ack *extack)
565d69ea414SJacob Keller {
566d69ea414SJacob Keller struct device *dev = ice_pf_to_dev(pf);
567b214b98aSPrzemek Kitszel struct ice_aq_task task = {};
568d69ea414SJacob Keller struct ice_hw *hw = &pf->hw;
569d69ea414SJacob Keller u16 completion_retval;
570399e27dbSJacob Keller u8 response_flags;
571d69ea414SJacob Keller int err;
572d69ea414SJacob Keller
573*fb9840c4SPrzemek Kitszel ice_aq_prep_for_event(pf, &task, ice_aqc_opc_nvm_write_activate);
574*fb9840c4SPrzemek Kitszel
575399e27dbSJacob Keller err = ice_nvm_write_activate(hw, activate_flags, &response_flags);
5762ccc1c1cSTony Nguyen if (err) {
5775f87ec48STony Nguyen dev_err(dev, "Failed to switch active flash banks, err %d aq_err %s\n",
5782ccc1c1cSTony Nguyen err, ice_aq_str(hw->adminq.sq_last_status));
579d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to switch active flash banks");
580d69ea414SJacob Keller return -EIO;
581d69ea414SJacob Keller }
582d69ea414SJacob Keller
583399e27dbSJacob Keller /* Newer versions of firmware have support to indicate whether an EMP
584399e27dbSJacob Keller * reset to reload firmware is available. For older firmware, EMP
585399e27dbSJacob Keller * reset is always available.
586399e27dbSJacob Keller */
587399e27dbSJacob Keller if (emp_reset_available) {
588399e27dbSJacob Keller if (hw->dev_caps.common_cap.reset_restrict_support) {
589399e27dbSJacob Keller *emp_reset_available = response_flags & ICE_AQC_NVM_EMPR_ENA;
590399e27dbSJacob Keller dev_dbg(dev, "Firmware indicated that EMP reset is %s\n",
591399e27dbSJacob Keller *emp_reset_available ?
592399e27dbSJacob Keller "available" : "not available");
593399e27dbSJacob Keller } else {
594399e27dbSJacob Keller *emp_reset_available = ICE_AQC_NVM_EMPR_ENA;
595399e27dbSJacob Keller dev_dbg(dev, "Firmware does not support restricting EMP reset availability\n");
596399e27dbSJacob Keller }
597399e27dbSJacob Keller }
598399e27dbSJacob Keller
599*fb9840c4SPrzemek Kitszel err = ice_aq_wait_for_event(pf, &task, 30 * HZ);
600d69ea414SJacob Keller if (err) {
601d69ea414SJacob Keller dev_err(dev, "Timed out waiting for firmware to switch active flash banks, err %d\n",
602d69ea414SJacob Keller err);
603d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Timed out waiting for firmware");
604d69ea414SJacob Keller return err;
605d69ea414SJacob Keller }
606d69ea414SJacob Keller
607b214b98aSPrzemek Kitszel completion_retval = le16_to_cpu(task.event.desc.retval);
608d69ea414SJacob Keller if (completion_retval) {
609d69ea414SJacob Keller dev_err(dev, "Firmware failed to switch active flash banks aq_err %s\n",
610d69ea414SJacob Keller ice_aq_str((enum ice_aq_err)completion_retval));
611d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Firmware failed to switch active flash banks");
612d69ea414SJacob Keller return -EIO;
613d69ea414SJacob Keller }
614d69ea414SJacob Keller
615d69ea414SJacob Keller return 0;
616d69ea414SJacob Keller }
617d69ea414SJacob Keller
618d69ea414SJacob Keller /**
619d69ea414SJacob Keller * ice_flash_component - Flash a component of the NVM
620d69ea414SJacob Keller * @context: PLDM fw update structure
621d69ea414SJacob Keller * @component: the component table to program
622d69ea414SJacob Keller *
623d69ea414SJacob Keller * Program the flash contents for a given component. First, determine the
624d69ea414SJacob Keller * module id. Then, erase the secondary bank for this module. Finally, write
625d69ea414SJacob Keller * the contents of the component to the NVM.
626d69ea414SJacob Keller *
627d69ea414SJacob Keller * Note this function assumes the caller has acquired the NVM resource.
628d69ea414SJacob Keller *
629d69ea414SJacob Keller * Returns: zero on success, or a negative error code on failure.
630d69ea414SJacob Keller */
631d69ea414SJacob Keller static int
ice_flash_component(struct pldmfw * context,struct pldmfw_component * component)632d69ea414SJacob Keller ice_flash_component(struct pldmfw *context, struct pldmfw_component *component)
633d69ea414SJacob Keller {
634d69ea414SJacob Keller struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
635d69ea414SJacob Keller struct netlink_ext_ack *extack = priv->extack;
636d69ea414SJacob Keller struct ice_pf *pf = priv->pf;
637d69ea414SJacob Keller const char *name;
638399e27dbSJacob Keller u8 *reset_level;
639d69ea414SJacob Keller u16 module;
640d69ea414SJacob Keller u8 flag;
641d69ea414SJacob Keller int err;
642d69ea414SJacob Keller
643d69ea414SJacob Keller switch (component->identifier) {
644d69ea414SJacob Keller case NVM_COMP_ID_OROM:
645d69ea414SJacob Keller module = ICE_SR_1ST_OROM_BANK_PTR;
646d69ea414SJacob Keller flag = ICE_AQC_NVM_ACTIV_SEL_OROM;
647399e27dbSJacob Keller reset_level = NULL;
648d69ea414SJacob Keller name = "fw.undi";
649d69ea414SJacob Keller break;
650d69ea414SJacob Keller case NVM_COMP_ID_NVM:
651d69ea414SJacob Keller module = ICE_SR_1ST_NVM_BANK_PTR;
652d69ea414SJacob Keller flag = ICE_AQC_NVM_ACTIV_SEL_NVM;
653399e27dbSJacob Keller reset_level = &priv->reset_level;
654d69ea414SJacob Keller name = "fw.mgmt";
655d69ea414SJacob Keller break;
656d69ea414SJacob Keller case NVM_COMP_ID_NETLIST:
657d69ea414SJacob Keller module = ICE_SR_NETLIST_BANK_PTR;
658d69ea414SJacob Keller flag = ICE_AQC_NVM_ACTIV_SEL_NETLIST;
659399e27dbSJacob Keller reset_level = NULL;
660d69ea414SJacob Keller name = "fw.netlist";
661d69ea414SJacob Keller break;
662d69ea414SJacob Keller default:
663d69ea414SJacob Keller /* This should not trigger, since we check the id before
664d69ea414SJacob Keller * sending the component table to firmware.
665d69ea414SJacob Keller */
666d69ea414SJacob Keller WARN(1, "Unexpected unknown component identifier 0x%02x",
667d69ea414SJacob Keller component->identifier);
668d69ea414SJacob Keller return -EINVAL;
669d69ea414SJacob Keller }
670d69ea414SJacob Keller
671d69ea414SJacob Keller /* Mark this component for activating at the end */
672d69ea414SJacob Keller priv->activate_flags |= flag;
673d69ea414SJacob Keller
674d69ea414SJacob Keller err = ice_erase_nvm_module(pf, module, name, extack);
675d69ea414SJacob Keller if (err)
676d69ea414SJacob Keller return err;
677d69ea414SJacob Keller
678d69ea414SJacob Keller return ice_write_nvm_module(pf, module, name, component->component_data,
679399e27dbSJacob Keller component->component_size, reset_level,
680399e27dbSJacob Keller extack);
681d69ea414SJacob Keller }
682d69ea414SJacob Keller
683d69ea414SJacob Keller /**
684d69ea414SJacob Keller * ice_finalize_update - Perform last steps to complete device update
685d69ea414SJacob Keller * @context: PLDM fw update structure
686d69ea414SJacob Keller *
687d69ea414SJacob Keller * Called as the last step of the update process. Complete the update by
688d69ea414SJacob Keller * telling the firmware to switch active banks, and perform a reset of
689d69ea414SJacob Keller * configured.
690d69ea414SJacob Keller *
691d69ea414SJacob Keller * Returns: 0 on success, or an error code on failure.
692d69ea414SJacob Keller */
ice_finalize_update(struct pldmfw * context)693d69ea414SJacob Keller static int ice_finalize_update(struct pldmfw *context)
694d69ea414SJacob Keller {
695d69ea414SJacob Keller struct ice_fwu_priv *priv = container_of(context, struct ice_fwu_priv, context);
696d69ea414SJacob Keller struct netlink_ext_ack *extack = priv->extack;
697d69ea414SJacob Keller struct ice_pf *pf = priv->pf;
698399e27dbSJacob Keller struct devlink *devlink;
699399e27dbSJacob Keller int err;
700d69ea414SJacob Keller
701d69ea414SJacob Keller /* Finally, notify firmware to activate the written NVM banks */
702399e27dbSJacob Keller err = ice_switch_flash_banks(pf, priv->activate_flags,
703399e27dbSJacob Keller &priv->emp_reset_available, extack);
704399e27dbSJacob Keller if (err)
705399e27dbSJacob Keller return err;
706399e27dbSJacob Keller
707399e27dbSJacob Keller devlink = priv_to_devlink(pf);
708399e27dbSJacob Keller
709399e27dbSJacob Keller /* If the required reset is EMPR, but EMPR is disabled, report that
710399e27dbSJacob Keller * a reboot is required instead.
711399e27dbSJacob Keller */
712399e27dbSJacob Keller if (priv->reset_level == ICE_AQC_NVM_EMPR_FLAG &&
713399e27dbSJacob Keller !priv->emp_reset_available) {
714399e27dbSJacob Keller dev_dbg(ice_pf_to_dev(pf), "Firmware indicated EMP reset as sufficient, but EMP reset is disabled\n");
715399e27dbSJacob Keller priv->reset_level = ICE_AQC_NVM_PERST_FLAG;
716399e27dbSJacob Keller }
717399e27dbSJacob Keller
718399e27dbSJacob Keller switch (priv->reset_level) {
719399e27dbSJacob Keller case ICE_AQC_NVM_EMPR_FLAG:
720399e27dbSJacob Keller devlink_flash_update_status_notify(devlink,
721399e27dbSJacob Keller "Activate new firmware by devlink reload",
722399e27dbSJacob Keller NULL, 0, 0);
723399e27dbSJacob Keller break;
724399e27dbSJacob Keller case ICE_AQC_NVM_PERST_FLAG:
725399e27dbSJacob Keller devlink_flash_update_status_notify(devlink,
726399e27dbSJacob Keller "Activate new firmware by rebooting the system",
727399e27dbSJacob Keller NULL, 0, 0);
728399e27dbSJacob Keller break;
729399e27dbSJacob Keller case ICE_AQC_NVM_POR_FLAG:
730399e27dbSJacob Keller default:
731399e27dbSJacob Keller devlink_flash_update_status_notify(devlink,
732399e27dbSJacob Keller "Activate new firmware by power cycling the system",
733399e27dbSJacob Keller NULL, 0, 0);
734399e27dbSJacob Keller break;
735399e27dbSJacob Keller }
736399e27dbSJacob Keller
737399e27dbSJacob Keller pf->fw_emp_reset_disabled = !priv->emp_reset_available;
738399e27dbSJacob Keller
739399e27dbSJacob Keller return 0;
740d69ea414SJacob Keller }
741d69ea414SJacob Keller
742f52d1668SPaul M Stillwell Jr struct ice_pldm_pci_record_id {
743f52d1668SPaul M Stillwell Jr u32 vendor;
744f52d1668SPaul M Stillwell Jr u32 device;
745f52d1668SPaul M Stillwell Jr u32 subsystem_vendor;
746f52d1668SPaul M Stillwell Jr u32 subsystem_device;
747f52d1668SPaul M Stillwell Jr };
748f52d1668SPaul M Stillwell Jr
749f52d1668SPaul M Stillwell Jr /**
750f52d1668SPaul M Stillwell Jr * ice_op_pci_match_record - Check if a PCI device matches the record
751f52d1668SPaul M Stillwell Jr * @context: PLDM fw update structure
752f52d1668SPaul M Stillwell Jr * @record: list of records extracted from the PLDM image
753f52d1668SPaul M Stillwell Jr *
754f52d1668SPaul M Stillwell Jr * Determine if the PCI device associated with this device matches the record
755f52d1668SPaul M Stillwell Jr * data provided.
756f52d1668SPaul M Stillwell Jr *
757f52d1668SPaul M Stillwell Jr * Searches the descriptor TLVs and extracts the relevant descriptor data into
758f52d1668SPaul M Stillwell Jr * a pldm_pci_record_id. This is then compared against the PCI device ID
759f52d1668SPaul M Stillwell Jr * information.
760f52d1668SPaul M Stillwell Jr *
761f52d1668SPaul M Stillwell Jr * Returns: true if the device matches the record, false otherwise.
762f52d1668SPaul M Stillwell Jr */
763f52d1668SPaul M Stillwell Jr static bool
ice_op_pci_match_record(struct pldmfw * context,struct pldmfw_record * record)764f52d1668SPaul M Stillwell Jr ice_op_pci_match_record(struct pldmfw *context, struct pldmfw_record *record)
765f52d1668SPaul M Stillwell Jr {
766f52d1668SPaul M Stillwell Jr struct pci_dev *pdev = to_pci_dev(context->dev);
767f52d1668SPaul M Stillwell Jr struct ice_pldm_pci_record_id id = {
768f52d1668SPaul M Stillwell Jr .vendor = PCI_ANY_ID,
769f52d1668SPaul M Stillwell Jr .device = PCI_ANY_ID,
770f52d1668SPaul M Stillwell Jr .subsystem_vendor = PCI_ANY_ID,
771f52d1668SPaul M Stillwell Jr .subsystem_device = PCI_ANY_ID,
772f52d1668SPaul M Stillwell Jr };
773f52d1668SPaul M Stillwell Jr struct pldmfw_desc_tlv *desc;
774f52d1668SPaul M Stillwell Jr
775f52d1668SPaul M Stillwell Jr list_for_each_entry(desc, &record->descs, entry) {
776f52d1668SPaul M Stillwell Jr u16 value;
777f52d1668SPaul M Stillwell Jr int *ptr;
778f52d1668SPaul M Stillwell Jr
779f52d1668SPaul M Stillwell Jr switch (desc->type) {
780f52d1668SPaul M Stillwell Jr case PLDM_DESC_ID_PCI_VENDOR_ID:
781f52d1668SPaul M Stillwell Jr ptr = &id.vendor;
782f52d1668SPaul M Stillwell Jr break;
783f52d1668SPaul M Stillwell Jr case PLDM_DESC_ID_PCI_DEVICE_ID:
784f52d1668SPaul M Stillwell Jr ptr = &id.device;
785f52d1668SPaul M Stillwell Jr break;
786f52d1668SPaul M Stillwell Jr case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
787f52d1668SPaul M Stillwell Jr ptr = &id.subsystem_vendor;
788f52d1668SPaul M Stillwell Jr break;
789f52d1668SPaul M Stillwell Jr case PLDM_DESC_ID_PCI_SUBDEV_ID:
790f52d1668SPaul M Stillwell Jr ptr = &id.subsystem_device;
791f52d1668SPaul M Stillwell Jr break;
792f52d1668SPaul M Stillwell Jr default:
793f52d1668SPaul M Stillwell Jr /* Skip unrelated TLVs */
794f52d1668SPaul M Stillwell Jr continue;
795f52d1668SPaul M Stillwell Jr }
796f52d1668SPaul M Stillwell Jr
797f52d1668SPaul M Stillwell Jr value = get_unaligned_le16(desc->data);
798f52d1668SPaul M Stillwell Jr /* A value of zero for one of the descriptors is sometimes
799f52d1668SPaul M Stillwell Jr * used when the record should ignore this field when matching
800f52d1668SPaul M Stillwell Jr * device. For example if the record applies to any subsystem
801f52d1668SPaul M Stillwell Jr * device or vendor.
802f52d1668SPaul M Stillwell Jr */
803f52d1668SPaul M Stillwell Jr if (value)
804f52d1668SPaul M Stillwell Jr *ptr = value;
805f52d1668SPaul M Stillwell Jr else
806f52d1668SPaul M Stillwell Jr *ptr = PCI_ANY_ID;
807f52d1668SPaul M Stillwell Jr }
808f52d1668SPaul M Stillwell Jr
809f52d1668SPaul M Stillwell Jr /* the E822 device can have a generic device ID so check for that */
810f52d1668SPaul M Stillwell Jr if ((id.vendor == PCI_ANY_ID || id.vendor == pdev->vendor) &&
811f52d1668SPaul M Stillwell Jr (id.device == PCI_ANY_ID || id.device == pdev->device ||
812f52d1668SPaul M Stillwell Jr id.device == ICE_DEV_ID_E822_SI_DFLT) &&
813f52d1668SPaul M Stillwell Jr (id.subsystem_vendor == PCI_ANY_ID ||
814f52d1668SPaul M Stillwell Jr id.subsystem_vendor == pdev->subsystem_vendor) &&
815f52d1668SPaul M Stillwell Jr (id.subsystem_device == PCI_ANY_ID ||
816f52d1668SPaul M Stillwell Jr id.subsystem_device == pdev->subsystem_device))
817f52d1668SPaul M Stillwell Jr return true;
818f52d1668SPaul M Stillwell Jr
819f52d1668SPaul M Stillwell Jr return false;
820f52d1668SPaul M Stillwell Jr }
821f52d1668SPaul M Stillwell Jr
822f52d1668SPaul M Stillwell Jr static const struct pldmfw_ops ice_fwu_ops_e810 = {
823d69ea414SJacob Keller .match_record = &pldmfw_op_pci_match_record,
824d69ea414SJacob Keller .send_package_data = &ice_send_package_data,
825d69ea414SJacob Keller .send_component_table = &ice_send_component_table,
826d69ea414SJacob Keller .flash_component = &ice_flash_component,
827d69ea414SJacob Keller .finalize_update = &ice_finalize_update,
828d69ea414SJacob Keller };
829d69ea414SJacob Keller
830f52d1668SPaul M Stillwell Jr static const struct pldmfw_ops ice_fwu_ops_e822 = {
831f52d1668SPaul M Stillwell Jr .match_record = &ice_op_pci_match_record,
832f52d1668SPaul M Stillwell Jr .send_package_data = &ice_send_package_data,
833f52d1668SPaul M Stillwell Jr .send_component_table = &ice_send_component_table,
834f52d1668SPaul M Stillwell Jr .flash_component = &ice_flash_component,
835f52d1668SPaul M Stillwell Jr .finalize_update = &ice_finalize_update,
836f52d1668SPaul M Stillwell Jr };
837f52d1668SPaul M Stillwell Jr
838d69ea414SJacob Keller /**
839399e27dbSJacob Keller * ice_get_pending_updates - Check if the component has a pending update
840d69ea414SJacob Keller * @pf: the PF driver structure
841399e27dbSJacob Keller * @pending: on return, bitmap of updates pending
842399e27dbSJacob Keller * @extack: Netlink extended ACK
843d69ea414SJacob Keller *
844399e27dbSJacob Keller * Check if the device has any pending updates on any flash components.
845d69ea414SJacob Keller *
846399e27dbSJacob Keller * Returns: zero on success, or a negative error code on failure. Updates
847399e27dbSJacob Keller * pending with the bitmap of pending updates.
848d69ea414SJacob Keller */
ice_get_pending_updates(struct ice_pf * pf,u8 * pending,struct netlink_ext_ack * extack)849399e27dbSJacob Keller int ice_get_pending_updates(struct ice_pf *pf, u8 *pending,
850d69ea414SJacob Keller struct netlink_ext_ack *extack)
851d69ea414SJacob Keller {
852d69ea414SJacob Keller struct device *dev = ice_pf_to_dev(pf);
853d69ea414SJacob Keller struct ice_hw_dev_caps *dev_caps;
854d69ea414SJacob Keller struct ice_hw *hw = &pf->hw;
855d69ea414SJacob Keller int err;
856d69ea414SJacob Keller
857d69ea414SJacob Keller dev_caps = kzalloc(sizeof(*dev_caps), GFP_KERNEL);
858d69ea414SJacob Keller if (!dev_caps)
859d69ea414SJacob Keller return -ENOMEM;
860d69ea414SJacob Keller
861d69ea414SJacob Keller /* Read the most recent device capabilities from firmware. Do not use
862d69ea414SJacob Keller * the cached values in hw->dev_caps, because the pending update flag
863d69ea414SJacob Keller * may have changed, e.g. if an update was previously completed and
864d69ea414SJacob Keller * the system has not yet rebooted.
865d69ea414SJacob Keller */
8662ccc1c1cSTony Nguyen err = ice_discover_dev_caps(hw, dev_caps);
8672ccc1c1cSTony Nguyen if (err) {
868d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Unable to read device capabilities");
869d69ea414SJacob Keller kfree(dev_caps);
870c1484691STony Nguyen return err;
871d69ea414SJacob Keller }
872d69ea414SJacob Keller
873399e27dbSJacob Keller *pending = 0;
874399e27dbSJacob Keller
875d69ea414SJacob Keller if (dev_caps->common_cap.nvm_update_pending_nvm) {
876d69ea414SJacob Keller dev_info(dev, "The fw.mgmt flash component has a pending update\n");
877399e27dbSJacob Keller *pending |= ICE_AQC_NVM_ACTIV_SEL_NVM;
878d69ea414SJacob Keller }
879d69ea414SJacob Keller
880d69ea414SJacob Keller if (dev_caps->common_cap.nvm_update_pending_orom) {
881d69ea414SJacob Keller dev_info(dev, "The fw.undi flash component has a pending update\n");
882399e27dbSJacob Keller *pending |= ICE_AQC_NVM_ACTIV_SEL_OROM;
883d69ea414SJacob Keller }
884d69ea414SJacob Keller
885d69ea414SJacob Keller if (dev_caps->common_cap.nvm_update_pending_netlist) {
886d69ea414SJacob Keller dev_info(dev, "The fw.netlist flash component has a pending update\n");
887399e27dbSJacob Keller *pending |= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
888d69ea414SJacob Keller }
889d69ea414SJacob Keller
890d69ea414SJacob Keller kfree(dev_caps);
891d69ea414SJacob Keller
892399e27dbSJacob Keller return 0;
893399e27dbSJacob Keller }
894399e27dbSJacob Keller
895399e27dbSJacob Keller /**
896399e27dbSJacob Keller * ice_cancel_pending_update - Cancel any pending update for a component
897399e27dbSJacob Keller * @pf: the PF driver structure
898399e27dbSJacob Keller * @component: if not NULL, the name of the component being updated
899399e27dbSJacob Keller * @extack: Netlink extended ACK structure
900399e27dbSJacob Keller *
901399e27dbSJacob Keller * Cancel any pending update for the specified component. If component is
902399e27dbSJacob Keller * NULL, all device updates will be canceled.
903399e27dbSJacob Keller *
904399e27dbSJacob Keller * Returns: zero on success, or a negative error code on failure.
905399e27dbSJacob Keller */
906399e27dbSJacob Keller static int
ice_cancel_pending_update(struct ice_pf * pf,const char * component,struct netlink_ext_ack * extack)907399e27dbSJacob Keller ice_cancel_pending_update(struct ice_pf *pf, const char *component,
908399e27dbSJacob Keller struct netlink_ext_ack *extack)
909399e27dbSJacob Keller {
910399e27dbSJacob Keller struct devlink *devlink = priv_to_devlink(pf);
911399e27dbSJacob Keller struct device *dev = ice_pf_to_dev(pf);
912399e27dbSJacob Keller struct ice_hw *hw = &pf->hw;
913399e27dbSJacob Keller u8 pending;
914399e27dbSJacob Keller int err;
915399e27dbSJacob Keller
916399e27dbSJacob Keller err = ice_get_pending_updates(pf, &pending, extack);
917399e27dbSJacob Keller if (err)
918399e27dbSJacob Keller return err;
919399e27dbSJacob Keller
920d69ea414SJacob Keller /* If the flash_update request is for a specific component, ignore all
921d69ea414SJacob Keller * of the other components.
922d69ea414SJacob Keller */
923d69ea414SJacob Keller if (component) {
924d69ea414SJacob Keller if (strcmp(component, "fw.mgmt") == 0)
925d69ea414SJacob Keller pending &= ICE_AQC_NVM_ACTIV_SEL_NVM;
926d69ea414SJacob Keller else if (strcmp(component, "fw.undi") == 0)
927d69ea414SJacob Keller pending &= ICE_AQC_NVM_ACTIV_SEL_OROM;
928d69ea414SJacob Keller else if (strcmp(component, "fw.netlist") == 0)
929d69ea414SJacob Keller pending &= ICE_AQC_NVM_ACTIV_SEL_NETLIST;
930d69ea414SJacob Keller else
931d69ea414SJacob Keller WARN(1, "Unexpected flash component %s", component);
932d69ea414SJacob Keller }
933d69ea414SJacob Keller
934d69ea414SJacob Keller /* There is no previous pending update, so this request may continue */
935d69ea414SJacob Keller if (!pending)
936d69ea414SJacob Keller return 0;
937d69ea414SJacob Keller
938d69ea414SJacob Keller /* In order to allow overwriting a previous pending update, notify
939d69ea414SJacob Keller * firmware to cancel that update by issuing the appropriate command.
940d69ea414SJacob Keller */
941d69ea414SJacob Keller devlink_flash_update_status_notify(devlink,
942d69ea414SJacob Keller "Canceling previous pending update",
943d69ea414SJacob Keller component, 0, 0);
944d69ea414SJacob Keller
9452ccc1c1cSTony Nguyen err = ice_acquire_nvm(hw, ICE_RES_WRITE);
9462ccc1c1cSTony Nguyen if (err) {
9475f87ec48STony Nguyen dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
9482ccc1c1cSTony Nguyen err, ice_aq_str(hw->adminq.sq_last_status));
949d69ea414SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
950c1484691STony Nguyen return err;
951d69ea414SJacob Keller }
952d69ea414SJacob Keller
953d69ea414SJacob Keller pending |= ICE_AQC_NVM_REVERT_LAST_ACTIV;
954399e27dbSJacob Keller err = ice_switch_flash_banks(pf, pending, NULL, extack);
955d69ea414SJacob Keller
956d69ea414SJacob Keller ice_release_nvm(hw);
957d69ea414SJacob Keller
958399e27dbSJacob Keller /* Since we've canceled the pending update, we no longer know if EMP
959399e27dbSJacob Keller * reset is restricted.
960399e27dbSJacob Keller */
961399e27dbSJacob Keller pf->fw_emp_reset_disabled = false;
962399e27dbSJacob Keller
963d69ea414SJacob Keller return err;
964d69ea414SJacob Keller }
965c356eaa8SJacob Keller
966c356eaa8SJacob Keller /**
967c9f7a483SJacob Keller * ice_devlink_flash_update - Write a firmware image to the device
968c9f7a483SJacob Keller * @devlink: pointer to devlink associated with the device to update
969c9f7a483SJacob Keller * @params: devlink flash update parameters
970c356eaa8SJacob Keller * @extack: netlink extended ACK structure
971c356eaa8SJacob Keller *
972c356eaa8SJacob Keller * Parse the data for a given firmware file, verifying that it is a valid PLDM
973c356eaa8SJacob Keller * formatted image that matches this device.
974c356eaa8SJacob Keller *
975c356eaa8SJacob Keller * Extract the device record Package Data and Component Tables and send them
976c356eaa8SJacob Keller * to the firmware. Extract and write the flash data for each of the three
977c356eaa8SJacob Keller * main flash components, "fw.mgmt", "fw.undi", and "fw.netlist". Notify
978c356eaa8SJacob Keller * firmware once the data is written to the inactive banks.
979c356eaa8SJacob Keller *
980c356eaa8SJacob Keller * Returns: zero on success or a negative error code on failure.
981c356eaa8SJacob Keller */
ice_devlink_flash_update(struct devlink * devlink,struct devlink_flash_update_params * params,struct netlink_ext_ack * extack)982c9f7a483SJacob Keller int ice_devlink_flash_update(struct devlink *devlink,
983c9f7a483SJacob Keller struct devlink_flash_update_params *params,
984c9f7a483SJacob Keller struct netlink_ext_ack *extack)
985c356eaa8SJacob Keller {
986c9f7a483SJacob Keller struct ice_pf *pf = devlink_priv(devlink);
987c356eaa8SJacob Keller struct device *dev = ice_pf_to_dev(pf);
988c356eaa8SJacob Keller struct ice_hw *hw = &pf->hw;
989c356eaa8SJacob Keller struct ice_fwu_priv priv;
990c9f7a483SJacob Keller u8 preservation;
991c356eaa8SJacob Keller int err;
992c356eaa8SJacob Keller
993c9f7a483SJacob Keller if (!params->overwrite_mask) {
994c9f7a483SJacob Keller /* preserve all settings and identifiers */
995c9f7a483SJacob Keller preservation = ICE_AQC_NVM_PRESERVE_ALL;
996c9f7a483SJacob Keller } else if (params->overwrite_mask == DEVLINK_FLASH_OVERWRITE_SETTINGS) {
997c9f7a483SJacob Keller /* overwrite settings, but preserve the vital device identifiers */
998c9f7a483SJacob Keller preservation = ICE_AQC_NVM_PRESERVE_SELECTED;
999c9f7a483SJacob Keller } else if (params->overwrite_mask == (DEVLINK_FLASH_OVERWRITE_SETTINGS |
1000c9f7a483SJacob Keller DEVLINK_FLASH_OVERWRITE_IDENTIFIERS)) {
1001c9f7a483SJacob Keller /* overwrite both settings and identifiers, preserve nothing */
1002c9f7a483SJacob Keller preservation = ICE_AQC_NVM_NO_PRESERVATION;
1003c9f7a483SJacob Keller } else {
1004c9f7a483SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Requested overwrite mask is not supported");
1005c9f7a483SJacob Keller return -EOPNOTSUPP;
1006c9f7a483SJacob Keller }
1007c9f7a483SJacob Keller
1008c9f7a483SJacob Keller if (!hw->dev_caps.common_cap.nvm_unified_update) {
1009c9f7a483SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Current firmware does not support unified update");
1010c9f7a483SJacob Keller return -EOPNOTSUPP;
1011c356eaa8SJacob Keller }
1012c356eaa8SJacob Keller
1013c356eaa8SJacob Keller memset(&priv, 0, sizeof(priv));
1014c356eaa8SJacob Keller
1015f52d1668SPaul M Stillwell Jr /* the E822 device needs a slightly different ops */
1016f52d1668SPaul M Stillwell Jr if (hw->mac_type == ICE_MAC_GENERIC)
1017f52d1668SPaul M Stillwell Jr priv.context.ops = &ice_fwu_ops_e822;
1018f52d1668SPaul M Stillwell Jr else
1019f52d1668SPaul M Stillwell Jr priv.context.ops = &ice_fwu_ops_e810;
1020c356eaa8SJacob Keller priv.context.dev = dev;
1021c356eaa8SJacob Keller priv.extack = extack;
1022c356eaa8SJacob Keller priv.pf = pf;
1023c356eaa8SJacob Keller priv.activate_flags = preservation;
1024c356eaa8SJacob Keller
1025c9f7a483SJacob Keller devlink_flash_update_status_notify(devlink, "Preparing to flash", NULL, 0, 0);
1026c9f7a483SJacob Keller
1027c9f7a483SJacob Keller err = ice_cancel_pending_update(pf, NULL, extack);
1028c9f7a483SJacob Keller if (err)
1029c9f7a483SJacob Keller return err;
1030c9f7a483SJacob Keller
1031c356eaa8SJacob Keller err = ice_acquire_nvm(hw, ICE_RES_WRITE);
1032c356eaa8SJacob Keller if (err) {
1033c356eaa8SJacob Keller dev_err(dev, "Failed to acquire device flash lock, err %d aq_err %s\n",
1034c356eaa8SJacob Keller err, ice_aq_str(hw->adminq.sq_last_status));
1035c356eaa8SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Failed to acquire device flash lock");
1036c356eaa8SJacob Keller return err;
1037c356eaa8SJacob Keller }
1038c356eaa8SJacob Keller
1039c9f7a483SJacob Keller err = pldmfw_flash_image(&priv.context, params->fw);
1040c356eaa8SJacob Keller if (err == -ENOENT) {
1041c356eaa8SJacob Keller dev_err(dev, "Firmware image has no record matching this device\n");
1042c356eaa8SJacob Keller NL_SET_ERR_MSG_MOD(extack, "Firmware image has no record matching this device");
1043c356eaa8SJacob Keller } else if (err) {
1044c356eaa8SJacob Keller /* Do not set a generic extended ACK message here. A more
1045c356eaa8SJacob Keller * specific message may already have been set by one of our
1046c356eaa8SJacob Keller * ops.
1047c356eaa8SJacob Keller */
1048c356eaa8SJacob Keller dev_err(dev, "Failed to flash PLDM image, err %d", err);
1049c356eaa8SJacob Keller }
1050c356eaa8SJacob Keller
1051c356eaa8SJacob Keller ice_release_nvm(hw);
1052c356eaa8SJacob Keller
1053c356eaa8SJacob Keller return err;
1054c356eaa8SJacob Keller }
1055