1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2018-2019, Intel Corporation. */
3
4 #include <asm/unaligned.h>
5 #include <linux/crc32.h>
6 #include <linux/device.h>
7 #include <linux/firmware.h>
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/pci.h>
11 #include <linux/pldmfw.h>
12 #include <linux/slab.h>
13 #include <linux/uuid.h>
14
15 #include "pldmfw_private.h"
16
17 /* Internal structure used to store details about the PLDM image file as it is
18 * being validated and processed.
19 */
20 struct pldmfw_priv {
21 struct pldmfw *context;
22 const struct firmware *fw;
23
24 /* current offset of firmware image */
25 size_t offset;
26
27 struct list_head records;
28 struct list_head components;
29
30 /* PLDM Firmware Package Header */
31 const struct __pldm_header *header;
32 u16 total_header_size;
33
34 /* length of the component bitmap */
35 u16 component_bitmap_len;
36 u16 bitmap_size;
37
38 /* Start of the component image information */
39 u16 component_count;
40 const u8 *component_start;
41
42 /* Start pf the firmware device id records */
43 const u8 *record_start;
44 u8 record_count;
45
46 /* The CRC at the end of the package header */
47 u32 header_crc;
48
49 struct pldmfw_record *matching_record;
50 };
51
52 /**
53 * pldm_check_fw_space - Verify that the firmware image has space left
54 * @data: pointer to private data
55 * @offset: offset to start from
56 * @length: length to check for
57 *
58 * Verify that the firmware data can hold a chunk of bytes with the specified
59 * offset and length.
60 *
61 * Returns: zero on success, or -EFAULT if the image does not have enough
62 * space left to fit the expected length.
63 */
64 static int
65 pldm_check_fw_space(struct pldmfw_priv *data, size_t offset, size_t length)
66 {
67 size_t expected_size = offset + length;
68 struct device *dev = data->context->dev;
69
70 if (data->fw->size < expected_size) {
71 dev_dbg(dev, "Firmware file size smaller than expected. Got %zu bytes, needed %zu bytes\n",
72 data->fw->size, expected_size);
73 return -EFAULT;
74 }
75
76 return 0;
77 }
78
79 /**
80 * pldm_move_fw_offset - Move the current firmware offset forward
81 * @data: pointer to private data
82 * @bytes_to_move: number of bytes to move the offset forward by
83 *
84 * Check that there is enough space past the current offset, and then move the
85 * offset forward by this amount.
86 *
87 * Returns: zero on success, or -EFAULT if the image is too small to fit the
88 * expected length.
89 */
90 static int
91 pldm_move_fw_offset(struct pldmfw_priv *data, size_t bytes_to_move)
92 {
93 int err;
94
95 err = pldm_check_fw_space(data, data->offset, bytes_to_move);
96 if (err)
97 return err;
98
99 data->offset += bytes_to_move;
100
101 return 0;
102 }
103
104 /**
105 * pldm_parse_header - Validate and extract details about the PLDM header
106 * @data: pointer to private data
107 *
108 * Performs initial basic verification of the PLDM image, up to the first
109 * firmware record.
110 *
111 * This includes the following checks and extractions
112 *
113 * * Verify that the UUID at the start of the header matches the expected
114 * value as defined in the DSP0267 PLDM specification
115 * * Check that the revision is 0x01
116 * * Extract the total header_size and verify that the image is large enough
117 * to contain at least the length of this header
118 * * Extract the size of the component bitmap length
119 * * Extract a pointer to the start of the record area
120 *
121 * Returns: zero on success, or a negative error code on failure.
122 */
123 static int pldm_parse_header(struct pldmfw_priv *data)
124 {
125 const struct __pldmfw_record_area *record_area;
126 struct device *dev = data->context->dev;
127 const struct __pldm_header *header;
128 size_t header_size;
129 int err;
130
131 err = pldm_move_fw_offset(data, sizeof(*header));
132 if (err)
133 return err;
134
135 header = (const struct __pldm_header *)data->fw->data;
136 data->header = header;
137
138 if (!uuid_equal(&header->id, &pldm_firmware_header_id)) {
139 dev_dbg(dev, "Invalid package header identifier. Expected UUID %pUB, but got %pUB\n",
140 &pldm_firmware_header_id, &header->id);
141 return -EINVAL;
142 }
143
144 if (header->revision != PACKAGE_HEADER_FORMAT_REVISION) {
145 dev_dbg(dev, "Invalid package header revision. Expected revision %u but got %u\n",
146 PACKAGE_HEADER_FORMAT_REVISION, header->revision);
147 return -EOPNOTSUPP;
148 }
149
150 data->total_header_size = get_unaligned_le16(&header->size);
151 header_size = data->total_header_size - sizeof(*header);
152
153 err = pldm_check_fw_space(data, data->offset, header_size);
154 if (err)
155 return err;
156
157 data->component_bitmap_len =
158 get_unaligned_le16(&header->component_bitmap_len);
159
160 if (data->component_bitmap_len % 8 != 0) {
161 dev_dbg(dev, "Invalid component bitmap length. The length is %u, which is not a multiple of 8\n",
162 data->component_bitmap_len);
163 return -EINVAL;
164 }
165
166 data->bitmap_size = data->component_bitmap_len / 8;
167
168 err = pldm_move_fw_offset(data, header->version_len);
169 if (err)
170 return err;
171
172 /* extract a pointer to the record area, which just follows the main
173 * PLDM header data.
174 */
175 record_area = (const struct __pldmfw_record_area *)(data->fw->data +
176 data->offset);
177
178 err = pldm_move_fw_offset(data, sizeof(*record_area));
179 if (err)
180 return err;
181
182 data->record_count = record_area->record_count;
183 data->record_start = record_area->records;
184
185 return 0;
186 }
187
188 /**
189 * pldm_check_desc_tlv_len - Check that the length matches expectation
190 * @data: pointer to image details
191 * @type: the descriptor type
192 * @size: the length from the descriptor header
193 *
194 * If the descriptor type is one of the documented descriptor types according
195 * to the standard, verify that the provided length matches.
196 *
197 * If the type is not recognized or is VENDOR_DEFINED, return zero.
198 *
199 * Returns: zero on success, or -EINVAL if the specified size of a standard
200 * TLV does not match the expected value defined for that TLV.
201 */
202 static int
203 pldm_check_desc_tlv_len(struct pldmfw_priv *data, u16 type, u16 size)
204 {
205 struct device *dev = data->context->dev;
206 u16 expected_size;
207
208 switch (type) {
209 case PLDM_DESC_ID_PCI_VENDOR_ID:
210 case PLDM_DESC_ID_PCI_DEVICE_ID:
211 case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
212 case PLDM_DESC_ID_PCI_SUBDEV_ID:
213 expected_size = 2;
214 break;
215 case PLDM_DESC_ID_PCI_REVISION_ID:
216 expected_size = 1;
217 break;
218 case PLDM_DESC_ID_PNP_VENDOR_ID:
219 expected_size = 3;
220 break;
221 case PLDM_DESC_ID_IANA_ENTERPRISE_ID:
222 case PLDM_DESC_ID_ACPI_VENDOR_ID:
223 case PLDM_DESC_ID_PNP_PRODUCT_ID:
224 case PLDM_DESC_ID_ACPI_PRODUCT_ID:
225 expected_size = 4;
226 break;
227 case PLDM_DESC_ID_UUID:
228 expected_size = 16;
229 break;
230 case PLDM_DESC_ID_VENDOR_DEFINED:
231 return 0;
232 default:
233 /* Do not report an error on an unexpected TLV */
234 dev_dbg(dev, "Found unrecognized TLV type 0x%04x\n", type);
235 return 0;
236 }
237
238 if (size != expected_size) {
239 dev_dbg(dev, "Found TLV type 0x%04x with unexpected length. Got %u bytes, but expected %u bytes\n",
240 type, size, expected_size);
241 return -EINVAL;
242 }
243
244 return 0;
245 }
246
247 /**
248 * pldm_parse_desc_tlvs - Check and skip past a number of TLVs
249 * @data: pointer to private data
250 * @record: pointer to the record this TLV belongs too
251 * @desc_count: descriptor count
252 *
253 * From the current offset, read and extract the descriptor TLVs, updating the
254 * current offset each time.
255 *
256 * Returns: zero on success, or a negative error code on failure.
257 */
258 static int
259 pldm_parse_desc_tlvs(struct pldmfw_priv *data, struct pldmfw_record *record, u8 desc_count)
260 {
261 const struct __pldmfw_desc_tlv *__desc;
262 const u8 *desc_start;
263 u8 i;
264
265 desc_start = data->fw->data + data->offset;
266
267 pldm_for_each_desc_tlv(i, __desc, desc_start, desc_count) {
268 struct pldmfw_desc_tlv *desc;
269 int err;
270 u16 type, size;
271
272 err = pldm_move_fw_offset(data, sizeof(*__desc));
273 if (err)
274 return err;
275
276 type = get_unaligned_le16(&__desc->type);
277
278 /* According to DSP0267, this only includes the data field */
279 size = get_unaligned_le16(&__desc->size);
280
281 err = pldm_check_desc_tlv_len(data, type, size);
282 if (err)
283 return err;
284
285 /* check that we have space and move the offset forward */
286 err = pldm_move_fw_offset(data, size);
287 if (err)
288 return err;
289
290 desc = kzalloc(sizeof(*desc), GFP_KERNEL);
291 if (!desc)
292 return -ENOMEM;
293
294 desc->type = type;
295 desc->size = size;
296 desc->data = __desc->data;
297
298 list_add_tail(&desc->entry, &record->descs);
299 }
300
301 return 0;
302 }
303
304 /**
305 * pldm_parse_one_record - Verify size of one PLDM record
306 * @data: pointer to image details
307 * @__record: pointer to the record to check
308 *
309 * This function checks that the record size does not exceed either the size
310 * of the firmware file or the total length specified in the header section.
311 *
312 * It also verifies that the recorded length of the start of the record
313 * matches the size calculated by adding the static structure length, the
314 * component bitmap length, the version string length, the length of all
315 * descriptor TLVs, and the length of the package data.
316 *
317 * Returns: zero on success, or a negative error code on failure.
318 */
319 static int
320 pldm_parse_one_record(struct pldmfw_priv *data,
321 const struct __pldmfw_record_info *__record)
322 {
323 struct pldmfw_record *record;
324 size_t measured_length;
325 int err;
326 const u8 *bitmap_ptr;
327 u16 record_len;
328 int i;
329
330 /* Make a copy and insert it into the record list */
331 record = kzalloc(sizeof(*record), GFP_KERNEL);
332 if (!record)
333 return -ENOMEM;
334
335 INIT_LIST_HEAD(&record->descs);
336 list_add_tail(&record->entry, &data->records);
337
338 /* Then check that we have space and move the offset */
339 err = pldm_move_fw_offset(data, sizeof(*__record));
340 if (err)
341 return err;
342
343 record_len = get_unaligned_le16(&__record->record_len);
344 record->package_data_len = get_unaligned_le16(&__record->package_data_len);
345 record->version_len = __record->version_len;
346 record->version_type = __record->version_type;
347
348 bitmap_ptr = data->fw->data + data->offset;
349
350 /* check that we have space for the component bitmap length */
351 err = pldm_move_fw_offset(data, data->bitmap_size);
352 if (err)
353 return err;
354
355 record->component_bitmap_len = data->component_bitmap_len;
356 record->component_bitmap = bitmap_zalloc(record->component_bitmap_len,
357 GFP_KERNEL);
358 if (!record->component_bitmap)
359 return -ENOMEM;
360
361 for (i = 0; i < data->bitmap_size; i++)
362 bitmap_set_value8(record->component_bitmap, bitmap_ptr[i], i * 8);
363
364 record->version_string = data->fw->data + data->offset;
365
366 err = pldm_move_fw_offset(data, record->version_len);
367 if (err)
368 return err;
369
370 /* Scan through the descriptor TLVs and find the end */
371 err = pldm_parse_desc_tlvs(data, record, __record->descriptor_count);
372 if (err)
373 return err;
374
375 record->package_data = data->fw->data + data->offset;
376
377 err = pldm_move_fw_offset(data, record->package_data_len);
378 if (err)
379 return err;
380
381 measured_length = data->offset - ((const u8 *)__record - data->fw->data);
382 if (measured_length != record_len) {
383 dev_dbg(data->context->dev, "Unexpected record length. Measured record length is %zu bytes, expected length is %u bytes\n",
384 measured_length, record_len);
385 return -EFAULT;
386 }
387
388 return 0;
389 }
390
391 /**
392 * pldm_parse_records - Locate the start of the component area
393 * @data: pointer to private data
394 *
395 * Extract the record count, and loop through each record, searching for the
396 * component area.
397 *
398 * Returns: zero on success, or a negative error code on failure.
399 */
400 static int pldm_parse_records(struct pldmfw_priv *data)
401 {
402 const struct __pldmfw_component_area *component_area;
403 const struct __pldmfw_record_info *record;
404 int err;
405 u8 i;
406
407 pldm_for_each_record(i, record, data->record_start, data->record_count) {
408 err = pldm_parse_one_record(data, record);
409 if (err)
410 return err;
411 }
412
413 /* Extract a pointer to the component area, which just follows the
414 * PLDM device record data.
415 */
416 component_area = (const struct __pldmfw_component_area *)(data->fw->data + data->offset);
417
418 err = pldm_move_fw_offset(data, sizeof(*component_area));
419 if (err)
420 return err;
421
422 data->component_count =
423 get_unaligned_le16(&component_area->component_image_count);
424 data->component_start = component_area->components;
425
426 return 0;
427 }
428
429 /**
430 * pldm_parse_components - Locate the CRC header checksum
431 * @data: pointer to private data
432 *
433 * Extract the component count, and find the pointer to the component area.
434 * Scan through each component searching for the end, which should point to
435 * the package header checksum.
436 *
437 * Extract the package header CRC and save it for verification.
438 *
439 * Returns: zero on success, or a negative error code on failure.
440 */
441 static int pldm_parse_components(struct pldmfw_priv *data)
442 {
443 const struct __pldmfw_component_info *__component;
444 struct device *dev = data->context->dev;
445 const u8 *header_crc_ptr;
446 int err;
447 u8 i;
448
449 pldm_for_each_component(i, __component, data->component_start, data->component_count) {
450 struct pldmfw_component *component;
451 u32 offset, size;
452
453 err = pldm_move_fw_offset(data, sizeof(*__component));
454 if (err)
455 return err;
456
457 err = pldm_move_fw_offset(data, __component->version_len);
458 if (err)
459 return err;
460
461 offset = get_unaligned_le32(&__component->location_offset);
462 size = get_unaligned_le32(&__component->size);
463
464 err = pldm_check_fw_space(data, offset, size);
465 if (err)
466 return err;
467
468 component = kzalloc(sizeof(*component), GFP_KERNEL);
469 if (!component)
470 return -ENOMEM;
471
472 component->index = i;
473 component->classification = get_unaligned_le16(&__component->classification);
474 component->identifier = get_unaligned_le16(&__component->identifier);
475 component->comparison_stamp = get_unaligned_le32(&__component->comparison_stamp);
476 component->options = get_unaligned_le16(&__component->options);
477 component->activation_method = get_unaligned_le16(&__component->activation_method);
478 component->version_type = __component->version_type;
479 component->version_len = __component->version_len;
480 component->version_string = __component->version_string;
481 component->component_data = data->fw->data + offset;
482 component->component_size = size;
483
484 list_add_tail(&component->entry, &data->components);
485 }
486
487 header_crc_ptr = data->fw->data + data->offset;
488
489 err = pldm_move_fw_offset(data, sizeof(data->header_crc));
490 if (err)
491 return err;
492
493 /* Make sure that we reached the expected offset */
494 if (data->offset != data->total_header_size) {
495 dev_dbg(dev, "Invalid firmware header size. Expected %u but got %zu\n",
496 data->total_header_size, data->offset);
497 return -EFAULT;
498 }
499
500 data->header_crc = get_unaligned_le32(header_crc_ptr);
501
502 return 0;
503 }
504
505 /**
506 * pldm_verify_header_crc - Verify that the CRC in the header matches
507 * @data: pointer to private data
508 *
509 * Calculates the 32-bit CRC using the standard IEEE 802.3 CRC polynomial and
510 * compares it to the value stored in the header.
511 *
512 * Returns: zero on success if the CRC matches, or -EBADMSG on an invalid CRC.
513 */
514 static int pldm_verify_header_crc(struct pldmfw_priv *data)
515 {
516 struct device *dev = data->context->dev;
517 u32 calculated_crc;
518 size_t length;
519
520 /* Calculate the 32-bit CRC of the header header contents up to but
521 * not including the checksum. Note that the Linux crc32_le function
522 * does not perform an expected final XOR.
523 */
524 length = data->offset - sizeof(data->header_crc);
525 calculated_crc = crc32_le(~0, data->fw->data, length) ^ ~0;
526
527 if (calculated_crc != data->header_crc) {
528 dev_dbg(dev, "Invalid CRC in firmware header. Got 0x%08x but expected 0x%08x\n",
529 calculated_crc, data->header_crc);
530 return -EBADMSG;
531 }
532
533 return 0;
534 }
535
536 /**
537 * pldmfw_free_priv - Free memory allocated while parsing the PLDM image
538 * @data: pointer to the PLDM data structure
539 *
540 * Loops through and clears all allocated memory associated with each
541 * allocated descriptor, record, and component.
542 */
543 static void pldmfw_free_priv(struct pldmfw_priv *data)
544 {
545 struct pldmfw_component *component, *c_safe;
546 struct pldmfw_record *record, *r_safe;
547 struct pldmfw_desc_tlv *desc, *d_safe;
548
549 list_for_each_entry_safe(component, c_safe, &data->components, entry) {
550 list_del(&component->entry);
551 kfree(component);
552 }
553
554 list_for_each_entry_safe(record, r_safe, &data->records, entry) {
555 list_for_each_entry_safe(desc, d_safe, &record->descs, entry) {
556 list_del(&desc->entry);
557 kfree(desc);
558 }
559
560 if (record->component_bitmap) {
561 bitmap_free(record->component_bitmap);
562 record->component_bitmap = NULL;
563 }
564
565 list_del(&record->entry);
566 kfree(record);
567 }
568 }
569
570 /**
571 * pldm_parse_image - parse and extract details from PLDM image
572 * @data: pointer to private data
573 *
574 * Verify that the firmware file contains valid data for a PLDM firmware
575 * file. Extract useful pointers and data from the firmware file and store
576 * them in the data structure.
577 *
578 * The PLDM firmware file format is defined in DMTF DSP0267 1.0.0. Care
579 * should be taken to use get_unaligned_le* when accessing data from the
580 * pointers in data.
581 *
582 * Returns: zero on success, or a negative error code on failure.
583 */
584 static int pldm_parse_image(struct pldmfw_priv *data)
585 {
586 int err;
587
588 if (WARN_ON(!(data->context->dev && data->fw->data && data->fw->size)))
589 return -EINVAL;
590
591 err = pldm_parse_header(data);
592 if (err)
593 return err;
594
595 err = pldm_parse_records(data);
596 if (err)
597 return err;
598
599 err = pldm_parse_components(data);
600 if (err)
601 return err;
602
603 return pldm_verify_header_crc(data);
604 }
605
606 /* these are u32 so that we can store PCI_ANY_ID */
607 struct pldm_pci_record_id {
608 int vendor;
609 int device;
610 int subsystem_vendor;
611 int subsystem_device;
612 };
613
614 /**
615 * pldmfw_op_pci_match_record - Check if a PCI device matches the record
616 * @context: PLDM fw update structure
617 * @record: list of records extracted from the PLDM image
618 *
619 * Determine of the PCI device associated with this device matches the record
620 * data provided.
621 *
622 * Searches the descriptor TLVs and extracts the relevant descriptor data into
623 * a pldm_pci_record_id. This is then compared against the PCI device ID
624 * information.
625 *
626 * Returns: true if the device matches the record, false otherwise.
627 */
628 bool pldmfw_op_pci_match_record(struct pldmfw *context, struct pldmfw_record *record)
629 {
630 struct pci_dev *pdev = to_pci_dev(context->dev);
631 struct pldm_pci_record_id id = {
632 .vendor = PCI_ANY_ID,
633 .device = PCI_ANY_ID,
634 .subsystem_vendor = PCI_ANY_ID,
635 .subsystem_device = PCI_ANY_ID,
636 };
637 struct pldmfw_desc_tlv *desc;
638
639 list_for_each_entry(desc, &record->descs, entry) {
640 u16 value;
641 int *ptr;
642
643 switch (desc->type) {
644 case PLDM_DESC_ID_PCI_VENDOR_ID:
645 ptr = &id.vendor;
646 break;
647 case PLDM_DESC_ID_PCI_DEVICE_ID:
648 ptr = &id.device;
649 break;
650 case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
651 ptr = &id.subsystem_vendor;
652 break;
653 case PLDM_DESC_ID_PCI_SUBDEV_ID:
654 ptr = &id.subsystem_device;
655 break;
656 default:
657 /* Skip unrelated TLVs */
658 continue;
659 }
660
661 value = get_unaligned_le16(desc->data);
662 /* A value of zero for one of the descriptors is sometimes
663 * used when the record should ignore this field when matching
664 * device. For example if the record applies to any subsystem
665 * device or vendor.
666 */
667 if (value)
668 *ptr = (int)value;
669 else
670 *ptr = PCI_ANY_ID;
671 }
672
673 if ((id.vendor == PCI_ANY_ID || id.vendor == pdev->vendor) &&
674 (id.device == PCI_ANY_ID || id.device == pdev->device) &&
675 (id.subsystem_vendor == PCI_ANY_ID || id.subsystem_vendor == pdev->subsystem_vendor) &&
676 (id.subsystem_device == PCI_ANY_ID || id.subsystem_device == pdev->subsystem_device))
677 return true;
678 else
679 return false;
680 }
681 EXPORT_SYMBOL(pldmfw_op_pci_match_record);
682
683 /**
684 * pldm_find_matching_record - Find the first matching PLDM record
685 * @data: pointer to private data
686 *
687 * Search through PLDM records and find the first matching entry. It is
688 * expected that only one entry matches.
689 *
690 * Store a pointer to the matching record, if found.
691 *
692 * Returns: zero on success, or -ENOENT if no matching record is found.
693 */
694 static int pldm_find_matching_record(struct pldmfw_priv *data)
695 {
696 struct pldmfw_record *record;
697
698 list_for_each_entry(record, &data->records, entry) {
699 if (data->context->ops->match_record(data->context, record)) {
700 data->matching_record = record;
701 return 0;
702 }
703 }
704
705 return -ENOENT;
706 }
707
708 /**
709 * pldm_send_package_data - Send firmware the package data for the record
710 * @data: pointer to private data
711 *
712 * Send the package data associated with the matching record to the firmware,
713 * using the send_pkg_data operation.
714 *
715 * Returns: zero on success, or a negative error code on failure.
716 */
717 static int
718 pldm_send_package_data(struct pldmfw_priv *data)
719 {
720 struct pldmfw_record *record = data->matching_record;
721 const struct pldmfw_ops *ops = data->context->ops;
722
723 return ops->send_package_data(data->context, record->package_data,
724 record->package_data_len);
725 }
726
727 /**
728 * pldm_send_component_tables - Send component table information to firmware
729 * @data: pointer to private data
730 *
731 * Loop over each component, sending the applicable components to the firmware
732 * via the send_component_table operation.
733 *
734 * Returns: zero on success, or a negative error code on failure.
735 */
736 static int
737 pldm_send_component_tables(struct pldmfw_priv *data)
738 {
739 unsigned long *bitmap = data->matching_record->component_bitmap;
740 struct pldmfw_component *component;
741 int err;
742
743 list_for_each_entry(component, &data->components, entry) {
744 u8 index = component->index, transfer_flag = 0;
745
746 /* Skip components which are not intended for this device */
747 if (!test_bit(index, bitmap))
748 continue;
749
750 /* determine whether this is the start, middle, end, or both
751 * the start and end of the component tables
752 */
753 if (index == find_first_bit(bitmap, data->component_bitmap_len))
754 transfer_flag |= PLDM_TRANSFER_FLAG_START;
755 if (index == find_last_bit(bitmap, data->component_bitmap_len))
756 transfer_flag |= PLDM_TRANSFER_FLAG_END;
757 if (!transfer_flag)
758 transfer_flag = PLDM_TRANSFER_FLAG_MIDDLE;
759
760 err = data->context->ops->send_component_table(data->context,
761 component,
762 transfer_flag);
763 if (err)
764 return err;
765 }
766
767 return 0;
768 }
769
770 /**
771 * pldm_flash_components - Program each component to device flash
772 * @data: pointer to private data
773 *
774 * Loop through each component that is active for the matching device record,
775 * and send it to the device driver for flashing.
776 *
777 * Returns: zero on success, or a negative error code on failure.
778 */
779 static int pldm_flash_components(struct pldmfw_priv *data)
780 {
781 unsigned long *bitmap = data->matching_record->component_bitmap;
782 struct pldmfw_component *component;
783 int err;
784
785 list_for_each_entry(component, &data->components, entry) {
786 u8 index = component->index;
787
788 /* Skip components which are not intended for this device */
789 if (!test_bit(index, bitmap))
790 continue;
791
792 err = data->context->ops->flash_component(data->context, component);
793 if (err)
794 return err;
795 }
796
797 return 0;
798 }
799
800 /**
801 * pldm_finalize_update - Finalize the device flash update
802 * @data: pointer to private data
803 *
804 * Tell the device driver to perform any remaining logic to complete the
805 * device update.
806 *
807 * Returns: zero on success, or a PLFM_FWU error indicating the reason for
808 * failure.
809 */
810 static int pldm_finalize_update(struct pldmfw_priv *data)
811 {
812 if (data->context->ops->finalize_update)
813 return data->context->ops->finalize_update(data->context);
814
815 return 0;
816 }
817
818 /**
819 * pldmfw_flash_image - Write a PLDM-formatted firmware image to the device
820 * @context: ops and data for firmware update
821 * @fw: firmware object pointing to the relevant firmware file to program
822 *
823 * Parse the data for a given firmware file, verifying that it is a valid PLDM
824 * formatted image that matches this device.
825 *
826 * Extract the device record Package Data and Component Tables and send them
827 * to the device firmware. Extract and write the flash data for each of the
828 * components indicated in the firmware file.
829 *
830 * Returns: zero on success, or a negative error code on failure.
831 */
832 int pldmfw_flash_image(struct pldmfw *context, const struct firmware *fw)
833 {
834 struct pldmfw_priv *data;
835 int err;
836
837 data = kzalloc(sizeof(*data), GFP_KERNEL);
838 if (!data)
839 return -ENOMEM;
840
841 INIT_LIST_HEAD(&data->records);
842 INIT_LIST_HEAD(&data->components);
843
844 data->fw = fw;
845 data->context = context;
846
847 err = pldm_parse_image(data);
848 if (err)
849 goto out_release_data;
850
851 err = pldm_find_matching_record(data);
852 if (err)
853 goto out_release_data;
854
855 err = pldm_send_package_data(data);
856 if (err)
857 goto out_release_data;
858
859 err = pldm_send_component_tables(data);
860 if (err)
861 goto out_release_data;
862
863 err = pldm_flash_components(data);
864 if (err)
865 goto out_release_data;
866
867 err = pldm_finalize_update(data);
868
869 out_release_data:
870 pldmfw_free_priv(data);
871 kfree(data);
872
873 return err;
874 }
875 EXPORT_SYMBOL(pldmfw_flash_image);
876
877 MODULE_AUTHOR("Jacob Keller <jacob.e.keller@intel.com>");
878 MODULE_DESCRIPTION("PLDM firmware flash update library");
879
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.