// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
|
/* Copyright (c) 2017-2019 Mellanox Technologies. All rights reserved */
|
|
#define pr_fmt(fmt) "mlxfw_mfa2: " fmt
|
|
#include <linux/kernel.h>
|
#include <linux/module.h>
|
#include <linux/netlink.h>
|
#include <linux/vmalloc.h>
|
#include <linux/xz.h>
|
#include "mlxfw_mfa2.h"
|
#include "mlxfw_mfa2_file.h"
|
#include "mlxfw_mfa2_tlv.h"
|
#include "mlxfw_mfa2_format.h"
|
#include "mlxfw_mfa2_tlv_multi.h"
|
|
/* MFA2 FILE
|
* +----------------------------------+
|
* | MFA2 finger print |
|
* +----------------------------------+
|
* | package descriptor multi_tlv |
|
* | +------------------------------+ | +-----------------+
|
* | | package descriptor tlv +-----> |num_devices=n |
|
* | +------------------------------+ | |num_components=m |
|
* +----------------------------------+ |CB offset |
|
* | device descriptor multi_tlv | |... |
|
* | +------------------------------+ | | |
|
* | | PSID tlv | | +-----------------+
|
* | +------------------------------+ |
|
* | | component index tlv | |
|
* | +------------------------------+ |
|
* +----------------------------------+
|
* | component descriptor multi_tlv |
|
* | +------------------------------+ | +-----------------+
|
* | | component descriptor tlv +-----> |Among others: |
|
* | +------------------------------+ | |CB offset=o |
|
* +----------------------------------+ |comp index=i |
|
* | | |... |
|
* | | | |
|
* | | +-----------------+
|
* | COMPONENT BLOCK (CB) |
|
* | |
|
* | |
|
* | |
|
* +----------------------------------+
|
*
|
* On the top level, an MFA2 file contains:
|
* - Fingerprint
|
* - Several multi_tlvs (TLVs of type MLXFW_MFA2_TLV_MULTI, as defined in
|
* mlxfw_mfa2_format.h)
|
* - Compresses content block
|
*
|
* The first multi_tlv
|
* -------------------
|
* The first multi TLV is treated as package descriptor, and expected to have a
|
* first TLV child of type MLXFW_MFA2_TLV_PACKAGE_DESCRIPTOR which contains all
|
* the global information needed to parse the file. Among others, it contains
|
* the number of device descriptors and component descriptor following this
|
* multi TLV.
|
*
|
* The device descriptor multi_tlv
|
* -------------------------------
|
* The multi TLVs following the package descriptor are treated as device
|
* descriptor, and are expected to have the following children:
|
* - PSID TLV child of type MLXFW_MFA2_TLV_PSID containing that device PSID.
|
* - Component index of type MLXFW_MFA2_TLV_COMPONENT_PTR that contains that
|
* device component index.
|
*
|
* The component descriptor multi_tlv
|
* ----------------------------------
|
* The multi TLVs following the device descriptor multi TLVs are treated as
|
* component descriptor, and are expected to have a first child of type
|
* MLXFW_MFA2_TLV_COMPONENT_DESCRIPTOR that contains mostly the component index,
|
* needed for the flash process and the offset to the binary within the
|
* component block.
|
*/
|
|
static const u8 mlxfw_mfa2_fingerprint[] = "MLNX.MFA2.XZ.00!";
|
static const int mlxfw_mfa2_fingerprint_len =
|
sizeof(mlxfw_mfa2_fingerprint) - 1;
|
|
static const u8 mlxfw_mfa2_comp_magic[] = "#BIN.COMPONENT!#";
|
static const int mlxfw_mfa2_comp_magic_len = sizeof(mlxfw_mfa2_comp_magic) - 1;
|
|
bool mlxfw_mfa2_check(const struct firmware *fw)
|
{
|
if (fw->size < sizeof(mlxfw_mfa2_fingerprint))
|
return false;
|
|
return memcmp(fw->data, mlxfw_mfa2_fingerprint,
|
mlxfw_mfa2_fingerprint_len) == 0;
|
}
|
|
static bool
|
mlxfw_mfa2_tlv_multi_validate(const struct mlxfw_mfa2_file *mfa2_file,
|
const struct mlxfw_mfa2_tlv_multi *multi)
|
{
|
const struct mlxfw_mfa2_tlv *tlv;
|
u16 idx;
|
|
/* Check that all children are valid */
|
mlxfw_mfa2_tlv_multi_foreach(mfa2_file, tlv, idx, multi) {
|
if (!tlv) {
|
pr_err("Multi has invalid child");
|
return false;
|
}
|
}
|
return true;
|
}
|
|
static bool
|
mlxfw_mfa2_file_dev_validate(const struct mlxfw_mfa2_file *mfa2_file,
|
const struct mlxfw_mfa2_tlv *dev_tlv,
|
u16 dev_idx)
|
{
|
const struct mlxfw_mfa2_tlv_component_ptr *cptr;
|
const struct mlxfw_mfa2_tlv_multi *multi;
|
const struct mlxfw_mfa2_tlv_psid *psid;
|
const struct mlxfw_mfa2_tlv *tlv;
|
u16 cptr_count;
|
u16 cptr_idx;
|
int err;
|
|
pr_debug("Device %d\n", dev_idx);
|
|
multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, dev_tlv);
|
if (!multi) {
|
pr_err("Device %d is not a valid TLV error\n", dev_idx);
|
return false;
|
}
|
|
if (!mlxfw_mfa2_tlv_multi_validate(mfa2_file, multi))
|
return false;
|
|
/* Validate the device has PSID tlv */
|
tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, multi,
|
MLXFW_MFA2_TLV_PSID, 0);
|
if (!tlv) {
|
pr_err("Device %d does not have PSID\n", dev_idx);
|
return false;
|
}
|
|
psid = mlxfw_mfa2_tlv_psid_get(mfa2_file, tlv);
|
if (!psid) {
|
pr_err("Device %d PSID TLV is not valid\n", dev_idx);
|
return false;
|
}
|
|
print_hex_dump_debug(" -- Device PSID ", DUMP_PREFIX_NONE, 16, 16,
|
psid->psid, be16_to_cpu(tlv->len), true);
|
|
/* Validate the device has COMPONENT_PTR */
|
err = mlxfw_mfa2_tlv_multi_child_count(mfa2_file, multi,
|
MLXFW_MFA2_TLV_COMPONENT_PTR,
|
&cptr_count);
|
if (err)
|
return false;
|
|
if (cptr_count == 0) {
|
pr_err("Device %d has no components\n", dev_idx);
|
return false;
|
}
|
|
for (cptr_idx = 0; cptr_idx < cptr_count; cptr_idx++) {
|
tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, multi,
|
MLXFW_MFA2_TLV_COMPONENT_PTR,
|
cptr_idx);
|
if (!tlv)
|
return false;
|
|
cptr = mlxfw_mfa2_tlv_component_ptr_get(mfa2_file, tlv);
|
if (!cptr) {
|
pr_err("Device %d COMPONENT_PTR TLV is not valid\n",
|
dev_idx);
|
return false;
|
}
|
|
pr_debug(" -- Component index %d\n",
|
be16_to_cpu(cptr->component_index));
|
}
|
return true;
|
}
|
|
static bool
|
mlxfw_mfa2_file_comp_validate(const struct mlxfw_mfa2_file *mfa2_file,
|
const struct mlxfw_mfa2_tlv *comp_tlv,
|
u16 comp_idx)
|
{
|
const struct mlxfw_mfa2_tlv_component_descriptor *cdesc;
|
const struct mlxfw_mfa2_tlv_multi *multi;
|
const struct mlxfw_mfa2_tlv *tlv;
|
|
pr_debug("Component %d\n", comp_idx);
|
|
multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, comp_tlv);
|
if (!multi) {
|
pr_err("Component %d is not a valid TLV error\n", comp_idx);
|
return false;
|
}
|
|
if (!mlxfw_mfa2_tlv_multi_validate(mfa2_file, multi))
|
return false;
|
|
/* Check that component have COMPONENT_DESCRIPTOR as first child */
|
tlv = mlxfw_mfa2_tlv_multi_child(mfa2_file, multi);
|
if (!tlv) {
|
pr_err("Component descriptor %d multi TLV error\n", comp_idx);
|
return false;
|
}
|
|
cdesc = mlxfw_mfa2_tlv_component_descriptor_get(mfa2_file, tlv);
|
if (!cdesc) {
|
pr_err("Component %d does not have a valid descriptor\n",
|
comp_idx);
|
return false;
|
}
|
pr_debug(" -- Component type %d\n", be16_to_cpu(cdesc->identifier));
|
pr_debug(" -- Offset 0x%llx and size %d\n",
|
((u64) be32_to_cpu(cdesc->cb_offset_h) << 32)
|
| be32_to_cpu(cdesc->cb_offset_l), be32_to_cpu(cdesc->size));
|
|
return true;
|
}
|
|
static bool mlxfw_mfa2_file_validate(const struct mlxfw_mfa2_file *mfa2_file)
|
{
|
const struct mlxfw_mfa2_tlv *tlv;
|
u16 idx;
|
|
pr_debug("Validating file\n");
|
|
/* check that all the devices exist */
|
mlxfw_mfa2_tlv_foreach(mfa2_file, tlv, idx, mfa2_file->first_dev,
|
mfa2_file->dev_count) {
|
if (!tlv) {
|
pr_err("Device TLV error\n");
|
return false;
|
}
|
|
/* Check each device */
|
if (!mlxfw_mfa2_file_dev_validate(mfa2_file, tlv, idx))
|
return false;
|
}
|
|
/* check that all the components exist */
|
mlxfw_mfa2_tlv_foreach(mfa2_file, tlv, idx, mfa2_file->first_component,
|
mfa2_file->component_count) {
|
if (!tlv) {
|
pr_err("Device TLV error\n");
|
return false;
|
}
|
|
/* Check each component */
|
if (!mlxfw_mfa2_file_comp_validate(mfa2_file, tlv, idx))
|
return false;
|
}
|
return true;
|
}
|
|
struct mlxfw_mfa2_file *mlxfw_mfa2_file_init(const struct firmware *fw)
|
{
|
const struct mlxfw_mfa2_tlv_package_descriptor *pd;
|
const struct mlxfw_mfa2_tlv_multi *multi;
|
const struct mlxfw_mfa2_tlv *multi_child;
|
const struct mlxfw_mfa2_tlv *first_tlv;
|
struct mlxfw_mfa2_file *mfa2_file;
|
const void *first_tlv_ptr;
|
const void *cb_top_ptr;
|
|
mfa2_file = kcalloc(1, sizeof(*mfa2_file), GFP_KERNEL);
|
if (!mfa2_file)
|
return ERR_PTR(-ENOMEM);
|
|
mfa2_file->fw = fw;
|
first_tlv_ptr = fw->data + NLA_ALIGN(mlxfw_mfa2_fingerprint_len);
|
first_tlv = mlxfw_mfa2_tlv_get(mfa2_file, first_tlv_ptr);
|
if (!first_tlv) {
|
pr_err("Could not parse package descriptor TLV\n");
|
goto err_out;
|
}
|
|
multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, first_tlv);
|
if (!multi) {
|
pr_err("First TLV is not of valid multi type\n");
|
goto err_out;
|
}
|
|
multi_child = mlxfw_mfa2_tlv_multi_child(mfa2_file, multi);
|
if (!multi_child)
|
goto err_out;
|
|
pd = mlxfw_mfa2_tlv_package_descriptor_get(mfa2_file, multi_child);
|
if (!pd) {
|
pr_err("Could not parse package descriptor TLV\n");
|
goto err_out;
|
}
|
|
mfa2_file->first_dev = mlxfw_mfa2_tlv_next(mfa2_file, first_tlv);
|
if (!mfa2_file->first_dev) {
|
pr_err("First device TLV is not valid\n");
|
goto err_out;
|
}
|
|
mfa2_file->dev_count = be16_to_cpu(pd->num_devices);
|
mfa2_file->first_component = mlxfw_mfa2_tlv_advance(mfa2_file,
|
mfa2_file->first_dev,
|
mfa2_file->dev_count);
|
mfa2_file->component_count = be16_to_cpu(pd->num_components);
|
mfa2_file->cb = fw->data + NLA_ALIGN(be32_to_cpu(pd->cb_offset));
|
if (!mlxfw_mfa2_valid_ptr(mfa2_file, mfa2_file->cb)) {
|
pr_err("Component block is out side the file\n");
|
goto err_out;
|
}
|
mfa2_file->cb_archive_size = be32_to_cpu(pd->cb_archive_size);
|
cb_top_ptr = mfa2_file->cb + mfa2_file->cb_archive_size - 1;
|
if (!mlxfw_mfa2_valid_ptr(mfa2_file, cb_top_ptr)) {
|
pr_err("Component block size is too big\n");
|
goto err_out;
|
}
|
|
if (!mlxfw_mfa2_file_validate(mfa2_file))
|
goto err_out;
|
return mfa2_file;
|
err_out:
|
kfree(mfa2_file);
|
return ERR_PTR(-EINVAL);
|
}
|
|
static const struct mlxfw_mfa2_tlv_multi *
|
mlxfw_mfa2_tlv_dev_get(const struct mlxfw_mfa2_file *mfa2_file,
|
const char *psid, u16 psid_size)
|
{
|
const struct mlxfw_mfa2_tlv_psid *tlv_psid;
|
const struct mlxfw_mfa2_tlv_multi *dev_multi;
|
const struct mlxfw_mfa2_tlv *dev_tlv;
|
const struct mlxfw_mfa2_tlv *tlv;
|
u32 idx;
|
|
/* for each device tlv */
|
mlxfw_mfa2_tlv_foreach(mfa2_file, dev_tlv, idx, mfa2_file->first_dev,
|
mfa2_file->dev_count) {
|
if (!dev_tlv)
|
return NULL;
|
|
dev_multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, dev_tlv);
|
if (!dev_multi)
|
return NULL;
|
|
/* find psid child and compare */
|
tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, dev_multi,
|
MLXFW_MFA2_TLV_PSID, 0);
|
if (!tlv)
|
return NULL;
|
if (be16_to_cpu(tlv->len) != psid_size)
|
continue;
|
|
tlv_psid = mlxfw_mfa2_tlv_psid_get(mfa2_file, tlv);
|
if (!tlv_psid)
|
return NULL;
|
|
if (memcmp(psid, tlv_psid->psid, psid_size) == 0)
|
return dev_multi;
|
}
|
|
return NULL;
|
}
|
|
int mlxfw_mfa2_file_component_count(const struct mlxfw_mfa2_file *mfa2_file,
|
const char *psid, u32 psid_size,
|
u32 *p_count)
|
{
|
const struct mlxfw_mfa2_tlv_multi *dev_multi;
|
u16 count;
|
int err;
|
|
dev_multi = mlxfw_mfa2_tlv_dev_get(mfa2_file, psid, psid_size);
|
if (!dev_multi)
|
return -EINVAL;
|
|
err = mlxfw_mfa2_tlv_multi_child_count(mfa2_file, dev_multi,
|
MLXFW_MFA2_TLV_COMPONENT_PTR,
|
&count);
|
if (err)
|
return err;
|
|
*p_count = count;
|
return 0;
|
}
|
|
static int mlxfw_mfa2_xz_dec_run(struct xz_dec *xz_dec, struct xz_buf *xz_buf,
|
bool *finished)
|
{
|
enum xz_ret xz_ret;
|
|
xz_ret = xz_dec_run(xz_dec, xz_buf);
|
|
switch (xz_ret) {
|
case XZ_STREAM_END:
|
*finished = true;
|
return 0;
|
case XZ_OK:
|
*finished = false;
|
return 0;
|
case XZ_MEM_ERROR:
|
pr_err("xz no memory\n");
|
return -ENOMEM;
|
case XZ_DATA_ERROR:
|
pr_err("xz file corrupted\n");
|
return -EINVAL;
|
case XZ_FORMAT_ERROR:
|
pr_err("xz format not found\n");
|
return -EINVAL;
|
case XZ_OPTIONS_ERROR:
|
pr_err("unsupported xz option\n");
|
return -EINVAL;
|
case XZ_MEMLIMIT_ERROR:
|
pr_err("xz dictionary too small\n");
|
return -EINVAL;
|
default:
|
pr_err("xz error %d\n", xz_ret);
|
return -EINVAL;
|
}
|
}
|
|
static int mlxfw_mfa2_file_cb_offset_xz(const struct mlxfw_mfa2_file *mfa2_file,
|
off_t off, size_t size, u8 *buf)
|
{
|
struct xz_dec *xz_dec;
|
struct xz_buf dec_buf;
|
off_t curr_off = 0;
|
bool finished;
|
int err;
|
|
xz_dec = xz_dec_init(XZ_DYNALLOC, (u32) -1);
|
if (!xz_dec)
|
return -EINVAL;
|
|
dec_buf.in_size = mfa2_file->cb_archive_size;
|
dec_buf.in = mfa2_file->cb;
|
dec_buf.in_pos = 0;
|
dec_buf.out = buf;
|
|
/* decode up to the offset */
|
do {
|
dec_buf.out_pos = 0;
|
dec_buf.out_size = min_t(size_t, size, off - curr_off);
|
if (dec_buf.out_size == 0)
|
break;
|
|
err = mlxfw_mfa2_xz_dec_run(xz_dec, &dec_buf, &finished);
|
if (err)
|
goto out;
|
if (finished) {
|
pr_err("xz section too short\n");
|
err = -EINVAL;
|
goto out;
|
}
|
curr_off += dec_buf.out_pos;
|
} while (curr_off != off);
|
|
/* decode the needed section */
|
dec_buf.out_pos = 0;
|
dec_buf.out_size = size;
|
err = mlxfw_mfa2_xz_dec_run(xz_dec, &dec_buf, &finished);
|
out:
|
xz_dec_end(xz_dec);
|
return err;
|
}
|
|
static const struct mlxfw_mfa2_tlv_component_descriptor *
|
mlxfw_mfa2_file_component_tlv_get(const struct mlxfw_mfa2_file *mfa2_file,
|
u16 comp_index)
|
{
|
const struct mlxfw_mfa2_tlv_multi *multi;
|
const struct mlxfw_mfa2_tlv *multi_child;
|
const struct mlxfw_mfa2_tlv *comp_tlv;
|
|
if (comp_index > mfa2_file->component_count)
|
return NULL;
|
|
comp_tlv = mlxfw_mfa2_tlv_advance(mfa2_file, mfa2_file->first_component,
|
comp_index);
|
if (!comp_tlv)
|
return NULL;
|
|
multi = mlxfw_mfa2_tlv_multi_get(mfa2_file, comp_tlv);
|
if (!multi)
|
return NULL;
|
|
multi_child = mlxfw_mfa2_tlv_multi_child(mfa2_file, multi);
|
if (!multi_child)
|
return NULL;
|
|
return mlxfw_mfa2_tlv_component_descriptor_get(mfa2_file, multi_child);
|
}
|
|
struct mlxfw_mfa2_comp_data {
|
struct mlxfw_mfa2_component comp;
|
u8 buff[];
|
};
|
|
static const struct mlxfw_mfa2_tlv_component_descriptor *
|
mlxfw_mfa2_file_component_find(const struct mlxfw_mfa2_file *mfa2_file,
|
const char *psid, int psid_size,
|
int component_index)
|
{
|
const struct mlxfw_mfa2_tlv_component_ptr *cptr;
|
const struct mlxfw_mfa2_tlv_multi *dev_multi;
|
const struct mlxfw_mfa2_tlv *cptr_tlv;
|
u16 comp_idx;
|
|
dev_multi = mlxfw_mfa2_tlv_dev_get(mfa2_file, psid, psid_size);
|
if (!dev_multi)
|
return NULL;
|
|
cptr_tlv = mlxfw_mfa2_tlv_multi_child_find(mfa2_file, dev_multi,
|
MLXFW_MFA2_TLV_COMPONENT_PTR,
|
component_index);
|
if (!cptr_tlv)
|
return NULL;
|
|
cptr = mlxfw_mfa2_tlv_component_ptr_get(mfa2_file, cptr_tlv);
|
if (!cptr)
|
return NULL;
|
|
comp_idx = be16_to_cpu(cptr->component_index);
|
return mlxfw_mfa2_file_component_tlv_get(mfa2_file, comp_idx);
|
}
|
|
struct mlxfw_mfa2_component *
|
mlxfw_mfa2_file_component_get(const struct mlxfw_mfa2_file *mfa2_file,
|
const char *psid, int psid_size,
|
int component_index)
|
{
|
const struct mlxfw_mfa2_tlv_component_descriptor *comp;
|
struct mlxfw_mfa2_comp_data *comp_data;
|
u32 comp_buf_size;
|
off_t cb_offset;
|
u32 comp_size;
|
int err;
|
|
comp = mlxfw_mfa2_file_component_find(mfa2_file, psid, psid_size,
|
component_index);
|
if (!comp)
|
return ERR_PTR(-EINVAL);
|
|
cb_offset = (u64) be32_to_cpu(comp->cb_offset_h) << 32 |
|
be32_to_cpu(comp->cb_offset_l);
|
comp_size = be32_to_cpu(comp->size);
|
comp_buf_size = comp_size + mlxfw_mfa2_comp_magic_len;
|
|
comp_data = vzalloc(sizeof(*comp_data) + comp_buf_size);
|
if (!comp_data)
|
return ERR_PTR(-ENOMEM);
|
comp_data->comp.data_size = comp_size;
|
comp_data->comp.index = be16_to_cpu(comp->identifier);
|
err = mlxfw_mfa2_file_cb_offset_xz(mfa2_file, cb_offset, comp_buf_size,
|
comp_data->buff);
|
if (err) {
|
pr_err("Component could not be reached in CB\n");
|
goto err_out;
|
}
|
|
if (memcmp(comp_data->buff, mlxfw_mfa2_comp_magic,
|
mlxfw_mfa2_comp_magic_len) != 0) {
|
pr_err("Component has wrong magic\n");
|
err = -EINVAL;
|
goto err_out;
|
}
|
|
comp_data->comp.data = comp_data->buff + mlxfw_mfa2_comp_magic_len;
|
return &comp_data->comp;
|
err_out:
|
vfree(comp_data);
|
return ERR_PTR(err);
|
}
|
|
void mlxfw_mfa2_file_component_put(struct mlxfw_mfa2_component *comp)
|
{
|
const struct mlxfw_mfa2_comp_data *comp_data;
|
|
comp_data = container_of(comp, struct mlxfw_mfa2_comp_data, comp);
|
vfree(comp_data);
|
}
|
|
void mlxfw_mfa2_file_fini(struct mlxfw_mfa2_file *mfa2_file)
|
{
|
kfree(mfa2_file);
|
}
|
