mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-15 23:14:31 +08:00
b8265621f4
The pldmfw library is used to implement common logic needed to flash devices based on firmware files using the format described by the PLDM for Firmware Update standard. This library consists of logic to parse the PLDM file format from a firmware file object, as well as common logic for sending the relevant PLDM header data to the device firmware. A simple ops table is provided so that device drivers can implement device specific hardware interactions while keeping the common logic to the pldmfw library. This library will be used by the Intel ice networking driver as part of implementing device flash update via devlink. The library aims to be vendor and device agnostic. For this reason, it has been placed in lib/pldmfw, in the hopes that other devices which use the PLDM firmware file format may benefit from it in the future. However, do note that not all features defined in the PLDM standard have been implemented. Signed-off-by: Jacob Keller <jacob.e.keller@intel.com> Signed-off-by: David S. Miller <davem@davemloft.net>
880 lines
24 KiB
C
880 lines
24 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright (C) 2018-2019, Intel Corporation. */
|
|
|
|
#include <asm/unaligned.h>
|
|
#include <linux/crc32.h>
|
|
#include <linux/device.h>
|
|
#include <linux/firmware.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/pldmfw.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/uuid.h>
|
|
|
|
#include "pldmfw_private.h"
|
|
|
|
/* Internal structure used to store details about the PLDM image file as it is
|
|
* being validated and processed.
|
|
*/
|
|
struct pldmfw_priv {
|
|
struct pldmfw *context;
|
|
const struct firmware *fw;
|
|
|
|
/* current offset of firmware image */
|
|
size_t offset;
|
|
|
|
struct list_head records;
|
|
struct list_head components;
|
|
|
|
/* PLDM Firmware Package Header */
|
|
const struct __pldm_header *header;
|
|
u16 total_header_size;
|
|
|
|
/* length of the component bitmap */
|
|
u16 component_bitmap_len;
|
|
u16 bitmap_size;
|
|
|
|
/* Start of the component image information */
|
|
u16 component_count;
|
|
const u8 *component_start;
|
|
|
|
/* Start pf the firmware device id records */
|
|
const u8 *record_start;
|
|
u8 record_count;
|
|
|
|
/* The CRC at the end of the package header */
|
|
u32 header_crc;
|
|
|
|
struct pldmfw_record *matching_record;
|
|
};
|
|
|
|
/**
|
|
* pldm_check_fw_space - Verify that the firmware image has space left
|
|
* @data: pointer to private data
|
|
* @offset: offset to start from
|
|
* @length: length to check for
|
|
*
|
|
* Verify that the firmware data can hold a chunk of bytes with the specified
|
|
* offset and length.
|
|
*
|
|
* Returns: zero on success, or -EFAULT if the image does not have enough
|
|
* space left to fit the expected length.
|
|
*/
|
|
static int
|
|
pldm_check_fw_space(struct pldmfw_priv *data, size_t offset, size_t length)
|
|
{
|
|
size_t expected_size = offset + length;
|
|
struct device *dev = data->context->dev;
|
|
|
|
if (data->fw->size < expected_size) {
|
|
dev_dbg(dev, "Firmware file size smaller than expected. Got %zu bytes, needed %zu bytes\n",
|
|
data->fw->size, expected_size);
|
|
return -EFAULT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_move_fw_offset - Move the current firmware offset forward
|
|
* @data: pointer to private data
|
|
* @bytes_to_move: number of bytes to move the offset forward by
|
|
*
|
|
* Check that there is enough space past the current offset, and then move the
|
|
* offset forward by this ammount.
|
|
*
|
|
* Returns: zero on success, or -EFAULT if the image is too small to fit the
|
|
* expected length.
|
|
*/
|
|
static int
|
|
pldm_move_fw_offset(struct pldmfw_priv *data, size_t bytes_to_move)
|
|
{
|
|
int err;
|
|
|
|
err = pldm_check_fw_space(data, data->offset, bytes_to_move);
|
|
if (err)
|
|
return err;
|
|
|
|
data->offset += bytes_to_move;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_parse_header - Validate and extract details about the PLDM header
|
|
* @data: pointer to private data
|
|
*
|
|
* Performs initial basic verification of the PLDM image, up to the first
|
|
* firmware record.
|
|
*
|
|
* This includes the following checks and extractions
|
|
*
|
|
* * Verify that the UUID at the start of the header matches the expected
|
|
* value as defined in the DSP0267 PLDM specification
|
|
* * Check that the revision is 0x01
|
|
* * Extract the total header_size and verify that the image is large enough
|
|
* to contain at least the length of this header
|
|
* * Extract the size of the component bitmap length
|
|
* * Extract a pointer to the start of the record area
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int pldm_parse_header(struct pldmfw_priv *data)
|
|
{
|
|
const struct __pldmfw_record_area *record_area;
|
|
struct device *dev = data->context->dev;
|
|
const struct __pldm_header *header;
|
|
size_t header_size;
|
|
int err;
|
|
|
|
err = pldm_move_fw_offset(data, sizeof(*header));
|
|
if (err)
|
|
return err;
|
|
|
|
header = (const struct __pldm_header *)data->fw->data;
|
|
data->header = header;
|
|
|
|
if (!uuid_equal(&header->id, &pldm_firmware_header_id)) {
|
|
dev_dbg(dev, "Invalid package header identifier. Expected UUID %pUB, but got %pUB\n",
|
|
&pldm_firmware_header_id, &header->id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (header->revision != PACKAGE_HEADER_FORMAT_REVISION) {
|
|
dev_dbg(dev, "Invalid package header revision. Expected revision %u but got %u\n",
|
|
PACKAGE_HEADER_FORMAT_REVISION, header->revision);
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
data->total_header_size = get_unaligned_le16(&header->size);
|
|
header_size = data->total_header_size - sizeof(*header);
|
|
|
|
err = pldm_check_fw_space(data, data->offset, header_size);
|
|
if (err)
|
|
return err;
|
|
|
|
data->component_bitmap_len =
|
|
get_unaligned_le16(&header->component_bitmap_len);
|
|
|
|
if (data->component_bitmap_len % 8 != 0) {
|
|
dev_dbg(dev, "Invalid component bitmap length. The length is %u, which is not a multiple of 8\n",
|
|
data->component_bitmap_len);
|
|
return -EINVAL;
|
|
}
|
|
|
|
data->bitmap_size = data->component_bitmap_len / 8;
|
|
|
|
err = pldm_move_fw_offset(data, header->version_len);
|
|
if (err)
|
|
return err;
|
|
|
|
/* extract a pointer to the record area, which just follows the main
|
|
* PLDM header data.
|
|
*/
|
|
record_area = (const struct __pldmfw_record_area *)(data->fw->data +
|
|
data->offset);
|
|
|
|
err = pldm_move_fw_offset(data, sizeof(*record_area));
|
|
if (err)
|
|
return err;
|
|
|
|
data->record_count = record_area->record_count;
|
|
data->record_start = record_area->records;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_check_desc_tlv_len - Check that the length matches expectation
|
|
* @data: pointer to image details
|
|
* @type: the descriptor type
|
|
* @size: the length from the descriptor header
|
|
*
|
|
* If the descriptor type is one of the documented descriptor types according
|
|
* to the standard, verify that the provided length matches.
|
|
*
|
|
* If the type is not recognized or is VENDOR_DEFINED, return zero.
|
|
*
|
|
* Returns: zero on success, or -EINVAL if the specified size of a standard
|
|
* TLV does not match the expected value defined for that TLV.
|
|
*/
|
|
static int
|
|
pldm_check_desc_tlv_len(struct pldmfw_priv *data, u16 type, u16 size)
|
|
{
|
|
struct device *dev = data->context->dev;
|
|
u16 expected_size;
|
|
|
|
switch (type) {
|
|
case PLDM_DESC_ID_PCI_VENDOR_ID:
|
|
case PLDM_DESC_ID_PCI_DEVICE_ID:
|
|
case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
|
|
case PLDM_DESC_ID_PCI_SUBDEV_ID:
|
|
expected_size = 2;
|
|
break;
|
|
case PLDM_DESC_ID_PCI_REVISION_ID:
|
|
expected_size = 1;
|
|
break;
|
|
case PLDM_DESC_ID_PNP_VENDOR_ID:
|
|
expected_size = 3;
|
|
break;
|
|
case PLDM_DESC_ID_IANA_ENTERPRISE_ID:
|
|
case PLDM_DESC_ID_ACPI_VENDOR_ID:
|
|
case PLDM_DESC_ID_PNP_PRODUCT_ID:
|
|
case PLDM_DESC_ID_ACPI_PRODUCT_ID:
|
|
expected_size = 4;
|
|
break;
|
|
case PLDM_DESC_ID_UUID:
|
|
expected_size = 16;
|
|
break;
|
|
case PLDM_DESC_ID_VENDOR_DEFINED:
|
|
return 0;
|
|
default:
|
|
/* Do not report an error on an unexpected TLV */
|
|
dev_dbg(dev, "Found unrecognized TLV type 0x%04x\n", type);
|
|
return 0;
|
|
}
|
|
|
|
if (size != expected_size) {
|
|
dev_dbg(dev, "Found TLV type 0x%04x with unexpected length. Got %u bytes, but expected %u bytes\n",
|
|
type, size, expected_size);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_parse_desc_tlvs - Check and skip past a number of TLVs
|
|
* @data: pointer to private data
|
|
* @record: pointer to the record this TLV belongs too
|
|
* @desc_count: descriptor count
|
|
*
|
|
* From the current offset, read and extract the descriptor TLVs, updating the
|
|
* current offset each time.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int
|
|
pldm_parse_desc_tlvs(struct pldmfw_priv *data, struct pldmfw_record *record, u8 desc_count)
|
|
{
|
|
const struct __pldmfw_desc_tlv *__desc;
|
|
const u8 *desc_start;
|
|
u8 i;
|
|
|
|
desc_start = data->fw->data + data->offset;
|
|
|
|
pldm_for_each_desc_tlv(i, __desc, desc_start, desc_count) {
|
|
struct pldmfw_desc_tlv *desc;
|
|
int err;
|
|
u16 type, size;
|
|
|
|
err = pldm_move_fw_offset(data, sizeof(*__desc));
|
|
if (err)
|
|
return err;
|
|
|
|
type = get_unaligned_le16(&__desc->type);
|
|
|
|
/* According to DSP0267, this only includes the data field */
|
|
size = get_unaligned_le16(&__desc->size);
|
|
|
|
err = pldm_check_desc_tlv_len(data, type, size);
|
|
if (err)
|
|
return err;
|
|
|
|
/* check that we have space and move the offset forward */
|
|
err = pldm_move_fw_offset(data, size);
|
|
if (err)
|
|
return err;
|
|
|
|
desc = kzalloc(sizeof(*desc), GFP_KERNEL);
|
|
if (!desc)
|
|
return -ENOMEM;
|
|
|
|
desc->type = type;
|
|
desc->size = size;
|
|
desc->data = __desc->data;
|
|
|
|
list_add_tail(&desc->entry, &record->descs);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_parse_one_record - Verify size of one PLDM record
|
|
* @data: pointer to image details
|
|
* @__record: pointer to the record to check
|
|
*
|
|
* This function checks that the record size does not exceed either the size
|
|
* of the firmware file or the total length specified in the header section.
|
|
*
|
|
* It also verifies that the recorded length of the start of the record
|
|
* matches the size calculated by adding the static structure length, the
|
|
* component bitmap length, the version string length, the length of all
|
|
* descriptor TLVs, and the length of the package data.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int
|
|
pldm_parse_one_record(struct pldmfw_priv *data,
|
|
const struct __pldmfw_record_info *__record)
|
|
{
|
|
struct pldmfw_record *record;
|
|
size_t measured_length;
|
|
int err;
|
|
const u8 *bitmap_ptr;
|
|
u16 record_len;
|
|
int i;
|
|
|
|
/* Make a copy and insert it into the record list */
|
|
record = kzalloc(sizeof(*record), GFP_KERNEL);
|
|
if (!record)
|
|
return -ENOMEM;
|
|
|
|
INIT_LIST_HEAD(&record->descs);
|
|
list_add_tail(&record->entry, &data->records);
|
|
|
|
/* Then check that we have space and move the offset */
|
|
err = pldm_move_fw_offset(data, sizeof(*__record));
|
|
if (err)
|
|
return err;
|
|
|
|
record_len = get_unaligned_le16(&__record->record_len);
|
|
record->package_data_len = get_unaligned_le16(&__record->package_data_len);
|
|
record->version_len = __record->version_len;
|
|
record->version_type = __record->version_type;
|
|
|
|
bitmap_ptr = data->fw->data + data->offset;
|
|
|
|
/* check that we have space for the component bitmap length */
|
|
err = pldm_move_fw_offset(data, data->bitmap_size);
|
|
if (err)
|
|
return err;
|
|
|
|
record->component_bitmap_len = data->component_bitmap_len;
|
|
record->component_bitmap = bitmap_zalloc(record->component_bitmap_len,
|
|
GFP_KERNEL);
|
|
if (!record->component_bitmap)
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < data->bitmap_size; i++)
|
|
bitmap_set_value8(record->component_bitmap, bitmap_ptr[i], i * 8);
|
|
|
|
record->version_string = data->fw->data + data->offset;
|
|
|
|
err = pldm_move_fw_offset(data, record->version_len);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Scan through the descriptor TLVs and find the end */
|
|
err = pldm_parse_desc_tlvs(data, record, __record->descriptor_count);
|
|
if (err)
|
|
return err;
|
|
|
|
record->package_data = data->fw->data + data->offset;
|
|
|
|
err = pldm_move_fw_offset(data, record->package_data_len);
|
|
if (err)
|
|
return err;
|
|
|
|
measured_length = data->offset - ((const u8 *)__record - data->fw->data);
|
|
if (measured_length != record_len) {
|
|
dev_dbg(data->context->dev, "Unexpected record length. Measured record length is %zu bytes, expected length is %u bytes\n",
|
|
measured_length, record_len);
|
|
return -EFAULT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_parse_records - Locate the start of the component area
|
|
* @data: pointer to private data
|
|
*
|
|
* Extract the record count, and loop through each record, searching for the
|
|
* component area.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int pldm_parse_records(struct pldmfw_priv *data)
|
|
{
|
|
const struct __pldmfw_component_area *component_area;
|
|
const struct __pldmfw_record_info *record;
|
|
int err;
|
|
u8 i;
|
|
|
|
pldm_for_each_record(i, record, data->record_start, data->record_count) {
|
|
err = pldm_parse_one_record(data, record);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
/* Extract a pointer to the component area, which just follows the
|
|
* PLDM device record data.
|
|
*/
|
|
component_area = (const struct __pldmfw_component_area *)(data->fw->data + data->offset);
|
|
|
|
err = pldm_move_fw_offset(data, sizeof(*component_area));
|
|
if (err)
|
|
return err;
|
|
|
|
data->component_count =
|
|
get_unaligned_le16(&component_area->component_image_count);
|
|
data->component_start = component_area->components;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_parse_components - Locate the CRC header checksum
|
|
* @data: pointer to private data
|
|
*
|
|
* Extract the component count, and find the pointer to the component area.
|
|
* Scan through each component searching for the end, which should point to
|
|
* the package header checksum.
|
|
*
|
|
* Extract the package header CRC and save it for verification.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int pldm_parse_components(struct pldmfw_priv *data)
|
|
{
|
|
const struct __pldmfw_component_info *__component;
|
|
struct device *dev = data->context->dev;
|
|
const u8 *header_crc_ptr;
|
|
int err;
|
|
u8 i;
|
|
|
|
pldm_for_each_component(i, __component, data->component_start, data->component_count) {
|
|
struct pldmfw_component *component;
|
|
u32 offset, size;
|
|
|
|
err = pldm_move_fw_offset(data, sizeof(*__component));
|
|
if (err)
|
|
return err;
|
|
|
|
err = pldm_move_fw_offset(data, __component->version_len);
|
|
if (err)
|
|
return err;
|
|
|
|
offset = get_unaligned_le32(&__component->location_offset);
|
|
size = get_unaligned_le32(&__component->size);
|
|
|
|
err = pldm_check_fw_space(data, offset, size);
|
|
if (err)
|
|
return err;
|
|
|
|
component = kzalloc(sizeof(*component), GFP_KERNEL);
|
|
if (!component)
|
|
return -ENOMEM;
|
|
|
|
component->index = i;
|
|
component->classification = get_unaligned_le16(&__component->classification);
|
|
component->identifier = get_unaligned_le16(&__component->identifier);
|
|
component->comparison_stamp = get_unaligned_le32(&__component->comparison_stamp);
|
|
component->options = get_unaligned_le16(&__component->options);
|
|
component->activation_method = get_unaligned_le16(&__component->activation_method);
|
|
component->version_type = __component->version_type;
|
|
component->version_len = __component->version_len;
|
|
component->version_string = __component->version_string;
|
|
component->component_data = data->fw->data + offset;
|
|
component->component_size = size;
|
|
|
|
list_add_tail(&component->entry, &data->components);
|
|
}
|
|
|
|
header_crc_ptr = data->fw->data + data->offset;
|
|
|
|
err = pldm_move_fw_offset(data, sizeof(data->header_crc));
|
|
if (err)
|
|
return err;
|
|
|
|
/* Make sure that we reached the expected offset */
|
|
if (data->offset != data->total_header_size) {
|
|
dev_dbg(dev, "Invalid firmware header size. Expected %u but got %zu\n",
|
|
data->total_header_size, data->offset);
|
|
return -EFAULT;
|
|
}
|
|
|
|
data->header_crc = get_unaligned_le32(header_crc_ptr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_verify_header_crc - Verify that the CRC in the header matches
|
|
* @data: pointer to private data
|
|
*
|
|
* Calculates the 32-bit CRC using the standard IEEE 802.3 CRC polynomial and
|
|
* compares it to the value stored in the header.
|
|
*
|
|
* Returns: zero on success if the CRC matches, or -EBADMSG on an invalid CRC.
|
|
*/
|
|
static int pldm_verify_header_crc(struct pldmfw_priv *data)
|
|
{
|
|
struct device *dev = data->context->dev;
|
|
u32 calculated_crc;
|
|
size_t length;
|
|
|
|
/* Calculate the 32-bit CRC of the header header contents up to but
|
|
* not including the checksum. Note that the Linux crc32_le function
|
|
* does not perform an expected final XOR.
|
|
*/
|
|
length = data->offset - sizeof(data->header_crc);
|
|
calculated_crc = crc32_le(~0, data->fw->data, length) ^ ~0;
|
|
|
|
if (calculated_crc != data->header_crc) {
|
|
dev_dbg(dev, "Invalid CRC in firmware header. Got 0x%08x but expected 0x%08x\n",
|
|
calculated_crc, data->header_crc);
|
|
return -EBADMSG;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldmfw_free_priv - Free memory allocated while parsing the PLDM image
|
|
* @data: pointer to the PLDM data structure
|
|
*
|
|
* Loops through and clears all allocated memory associated with each
|
|
* allocated descriptor, record, and component.
|
|
*/
|
|
static void pldmfw_free_priv(struct pldmfw_priv *data)
|
|
{
|
|
struct pldmfw_component *component, *c_safe;
|
|
struct pldmfw_record *record, *r_safe;
|
|
struct pldmfw_desc_tlv *desc, *d_safe;
|
|
|
|
list_for_each_entry_safe(component, c_safe, &data->components, entry) {
|
|
list_del(&component->entry);
|
|
kfree(component);
|
|
}
|
|
|
|
list_for_each_entry_safe(record, r_safe, &data->records, entry) {
|
|
list_for_each_entry_safe(desc, d_safe, &record->descs, entry) {
|
|
list_del(&desc->entry);
|
|
kfree(desc);
|
|
}
|
|
|
|
if (record->component_bitmap) {
|
|
bitmap_free(record->component_bitmap);
|
|
record->component_bitmap = NULL;
|
|
}
|
|
|
|
list_del(&record->entry);
|
|
kfree(record);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* pldm_parse_image - parse and extract details from PLDM image
|
|
* @data: pointer to private data
|
|
*
|
|
* Verify that the firmware file contains valid data for a PLDM firmware
|
|
* file. Extract useful pointers and data from the firmware file and store
|
|
* them in the data structure.
|
|
*
|
|
* The PLDM firmware file format is defined in DMTF DSP0267 1.0.0. Care
|
|
* should be taken to use get_unaligned_le* when accessing data from the
|
|
* pointers in data.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int pldm_parse_image(struct pldmfw_priv *data)
|
|
{
|
|
int err;
|
|
|
|
if (WARN_ON(!(data->context->dev && data->fw->data && data->fw->size)))
|
|
return -EINVAL;
|
|
|
|
err = pldm_parse_header(data);
|
|
if (err)
|
|
return err;
|
|
|
|
err = pldm_parse_records(data);
|
|
if (err)
|
|
return err;
|
|
|
|
err = pldm_parse_components(data);
|
|
if (err)
|
|
return err;
|
|
|
|
return pldm_verify_header_crc(data);
|
|
}
|
|
|
|
/* these are u32 so that we can store PCI_ANY_ID */
|
|
struct pldm_pci_record_id {
|
|
int vendor;
|
|
int device;
|
|
int subsystem_vendor;
|
|
int subsystem_device;
|
|
};
|
|
|
|
/**
|
|
* pldmfw_op_pci_match_record - Check if a PCI device matches the record
|
|
* @context: PLDM fw update structure
|
|
* @record: list of records extracted from the PLDM image
|
|
*
|
|
* Determine of the PCI device associated with this device matches the record
|
|
* data provided.
|
|
*
|
|
* Searches the descriptor TLVs and extracts the relevant descriptor data into
|
|
* a pldm_pci_record_id. This is then compared against the PCI device ID
|
|
* information.
|
|
*
|
|
* Returns: true if the device matches the record, false otherwise.
|
|
*/
|
|
bool pldmfw_op_pci_match_record(struct pldmfw *context, struct pldmfw_record *record)
|
|
{
|
|
struct pci_dev *pdev = to_pci_dev(context->dev);
|
|
struct pldm_pci_record_id id = {
|
|
.vendor = PCI_ANY_ID,
|
|
.device = PCI_ANY_ID,
|
|
.subsystem_vendor = PCI_ANY_ID,
|
|
.subsystem_device = PCI_ANY_ID,
|
|
};
|
|
struct pldmfw_desc_tlv *desc;
|
|
|
|
list_for_each_entry(desc, &record->descs, entry) {
|
|
u16 value;
|
|
int *ptr;
|
|
|
|
switch (desc->type) {
|
|
case PLDM_DESC_ID_PCI_VENDOR_ID:
|
|
ptr = &id.vendor;
|
|
break;
|
|
case PLDM_DESC_ID_PCI_DEVICE_ID:
|
|
ptr = &id.device;
|
|
break;
|
|
case PLDM_DESC_ID_PCI_SUBVENDOR_ID:
|
|
ptr = &id.subsystem_vendor;
|
|
break;
|
|
case PLDM_DESC_ID_PCI_SUBDEV_ID:
|
|
ptr = &id.subsystem_device;
|
|
break;
|
|
default:
|
|
/* Skip unrelated TLVs */
|
|
continue;
|
|
}
|
|
|
|
value = get_unaligned_le16(desc->data);
|
|
/* A value of zero for one of the descriptors is sometimes
|
|
* used when the record should ignore this field when matching
|
|
* device. For example if the record applies to any subsystem
|
|
* device or vendor.
|
|
*/
|
|
if (value)
|
|
*ptr = (int)value;
|
|
else
|
|
*ptr = PCI_ANY_ID;
|
|
}
|
|
|
|
if ((id.vendor == PCI_ANY_ID || id.vendor == pdev->vendor) &&
|
|
(id.device == PCI_ANY_ID || id.device == pdev->device) &&
|
|
(id.subsystem_vendor == PCI_ANY_ID || id.subsystem_vendor == pdev->subsystem_vendor) &&
|
|
(id.subsystem_device == PCI_ANY_ID || id.subsystem_device == pdev->subsystem_device))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
EXPORT_SYMBOL(pldmfw_op_pci_match_record);
|
|
|
|
/**
|
|
* pldm_find_matching_record - Find the first matching PLDM record
|
|
* @data: pointer to private data
|
|
*
|
|
* Search through PLDM records and find the first matching entry. It is
|
|
* expected that only one entry matches.
|
|
*
|
|
* Store a pointer to the matching record, if found.
|
|
*
|
|
* Returns: zero on success, or -ENOENT if no matching record is found.
|
|
*/
|
|
static int pldm_find_matching_record(struct pldmfw_priv *data)
|
|
{
|
|
struct pldmfw_record *record;
|
|
|
|
list_for_each_entry(record, &data->records, entry) {
|
|
if (data->context->ops->match_record(data->context, record)) {
|
|
data->matching_record = record;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return -ENOENT;
|
|
}
|
|
|
|
/**
|
|
* pldm_send_package_data - Send firmware the package data for the record
|
|
* @data: pointer to private data
|
|
*
|
|
* Send the package data associated with the matching record to the firmware,
|
|
* using the send_pkg_data operation.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int
|
|
pldm_send_package_data(struct pldmfw_priv *data)
|
|
{
|
|
struct pldmfw_record *record = data->matching_record;
|
|
const struct pldmfw_ops *ops = data->context->ops;
|
|
|
|
return ops->send_package_data(data->context, record->package_data,
|
|
record->package_data_len);
|
|
}
|
|
|
|
/**
|
|
* pldm_send_component_tables - Send component table information to firmware
|
|
* @data: pointer to private data
|
|
*
|
|
* Loop over each component, sending the applicable components to the firmware
|
|
* via the send_component_table operation.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int
|
|
pldm_send_component_tables(struct pldmfw_priv *data)
|
|
{
|
|
unsigned long *bitmap = data->matching_record->component_bitmap;
|
|
struct pldmfw_component *component;
|
|
int err;
|
|
|
|
list_for_each_entry(component, &data->components, entry) {
|
|
u8 index = component->index, transfer_flag = 0;
|
|
|
|
/* Skip components which are not intended for this device */
|
|
if (!test_bit(index, bitmap))
|
|
continue;
|
|
|
|
/* determine whether this is the start, middle, end, or both
|
|
* the start and end of the component tables
|
|
*/
|
|
if (index == find_first_bit(bitmap, data->component_bitmap_len))
|
|
transfer_flag |= PLDM_TRANSFER_FLAG_START;
|
|
if (index == find_last_bit(bitmap, data->component_bitmap_len))
|
|
transfer_flag |= PLDM_TRANSFER_FLAG_END;
|
|
if (!transfer_flag)
|
|
transfer_flag = PLDM_TRANSFER_FLAG_MIDDLE;
|
|
|
|
err = data->context->ops->send_component_table(data->context,
|
|
component,
|
|
transfer_flag);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_flash_components - Program each component to device flash
|
|
* @data: pointer to private data
|
|
*
|
|
* Loop through each component that is active for the matching device record,
|
|
* and send it to the device driver for flashing.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
static int pldm_flash_components(struct pldmfw_priv *data)
|
|
{
|
|
unsigned long *bitmap = data->matching_record->component_bitmap;
|
|
struct pldmfw_component *component;
|
|
int err;
|
|
|
|
list_for_each_entry(component, &data->components, entry) {
|
|
u8 index = component->index;
|
|
|
|
/* Skip components which are not intended for this device */
|
|
if (!test_bit(index, bitmap))
|
|
continue;
|
|
|
|
err = data->context->ops->flash_component(data->context, component);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldm_finalize_update - Finalize the device flash update
|
|
* @data: pointer to private data
|
|
*
|
|
* Tell the device driver to perform any remaining logic to complete the
|
|
* device update.
|
|
*
|
|
* Returns: zero on success, or a PLFM_FWU error indicating the reason for
|
|
* failure.
|
|
*/
|
|
static int pldm_finalize_update(struct pldmfw_priv *data)
|
|
{
|
|
if (data->context->ops->finalize_update)
|
|
return data->context->ops->finalize_update(data->context);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* pldmfw_flash_image - Write a PLDM-formatted firmware image to the device
|
|
* @context: ops and data for firmware update
|
|
* @fw: firmware object pointing to the relevant firmware file to program
|
|
*
|
|
* Parse the data for a given firmware file, verifying that it is a valid PLDM
|
|
* formatted image that matches this device.
|
|
*
|
|
* Extract the device record Package Data and Component Tables and send them
|
|
* to the device firmware. Extract and write the flash data for each of the
|
|
* components indicated in the firmware file.
|
|
*
|
|
* Returns: zero on success, or a negative error code on failure.
|
|
*/
|
|
int pldmfw_flash_image(struct pldmfw *context, const struct firmware *fw)
|
|
{
|
|
struct pldmfw_priv *data;
|
|
int err;
|
|
|
|
data = kzalloc(sizeof(*data), GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
INIT_LIST_HEAD(&data->records);
|
|
INIT_LIST_HEAD(&data->components);
|
|
|
|
data->fw = fw;
|
|
data->context = context;
|
|
|
|
err = pldm_parse_image(data);
|
|
if (err)
|
|
goto out_release_data;
|
|
|
|
err = pldm_find_matching_record(data);
|
|
if (err)
|
|
goto out_release_data;
|
|
|
|
err = pldm_send_package_data(data);
|
|
if (err)
|
|
goto out_release_data;
|
|
|
|
err = pldm_send_component_tables(data);
|
|
if (err)
|
|
goto out_release_data;
|
|
|
|
err = pldm_flash_components(data);
|
|
if (err)
|
|
goto out_release_data;
|
|
|
|
err = pldm_finalize_update(data);
|
|
|
|
out_release_data:
|
|
pldmfw_free_priv(data);
|
|
kfree(data);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(pldmfw_flash_image);
|
|
|
|
MODULE_AUTHOR("Jacob Keller <jacob.e.keller@intel.com>");
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_DESCRIPTION("PLDM firmware flash update library");
|