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