hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ASoC: SOF: Fix build 

The recent batch of SOF changes failed to build on some x86
configurations including an allmodconfig, revert the commits:

e150ef4169  ASoC: SOF: Introduce extended manifest
3710914178  ASoC: SOF: ext_manifest: parse firmware version
7c024b948c  ASoC: SOF: ext_manifest: parse compiler version
9e72f13ee5  ASoC: SOF: ext_manifest: parse windows

to fix this.

Reported-by: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Mark Brown 2020-04-22 12:07:10 +01:00
parent 5bf73b1b1d
commit d8e25a10ef
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
2 changed files with 2 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
include/uapi/sound/sof/ext_manifest.h
View File

@ -1,91 +0,0 @@
/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
/*
* This file is provided under a dual BSD/GPLv2 license. When using or
* redistributing this file, you may do so under either license.
*
* Copyright(c) 2020 Intel Corporation. All rights reserved.
*/
/*
* Extended manifest is a place to store metadata about firmware, known during
* compilation time - for example firmware version or used compiler.
* Given information are read on host side before firmware startup.
* This part of output binary is not signed.
*/
#ifndef __SOF_FIRMWARE_EXT_MANIFEST_H__
#define __SOF_FIRMWARE_EXT_MANIFEST_H__
#include <linux/const.h>
#include <sound/sof/info.h>
/* In ASCII `XMan` */
#define SOF_EXT_MAN_MAGIC_NUMBER 0x6e614d58
/* Build u32 number in format MMmmmppp */
#define SOF_EXT_MAN_BUILD_VERSION(MAJOR, MINOR, PATH) ((uint32_t)( \
((MAJOR) << 24) | \
((MINOR) << 12) | \
(PATH)))
/* check extended manifest version consistency */
#define SOF_EXT_MAN_VERSION_INCOMPATIBLE(host_ver, cli_ver) ( \
((host_ver) & GENMASK(31, 24)) != \
((cli_ver) & GENMASK(31, 24)))
/* used extended manifest header version */
#define SOF_EXT_MAN_VERSION SOF_EXT_MAN_BUILD_VERSION(1, 0, 0)
/* extended manifest header, deleting any field breaks backward compatibility */
struct sof_ext_man_header {
uint32_t magic; /*< identification number, */
/*< EXT_MAN_MAGIC_NUMBER */
uint32_t full_size; /*< [bytes] full size of ext_man, */
/*< (header + content + padding) */
uint32_t header_size; /*< [bytes] makes header extensionable, */
/*< after append new field to ext_man header */
/*< then backward compatible won't be lost */
uint32_t header_version; /*< value of EXT_MAN_VERSION */
/*< not related with following content */
uint8_t elements[]; /*< list of ext_man_elem_* elements */
} __packed;
/* Now define extended manifest elements */
/* Extended manifest elements types */
enum sof_ext_man_elem_type {
SOF_EXT_MAN_ELEM_FW_VERSION = 0,
SOF_EXT_MAN_ELEM_WINDOW = SOF_IPC_EXT_WINDOW,
SOF_EXT_MAN_ELEM_CC_VERSION = SOF_IPC_EXT_CC_INFO,
};
/* extended manifest element header */
struct sof_ext_man_elem_header {
uint32_t type; /*< SOF_EXT_MAN_ELEM_ */
uint32_t size; /*< in bytes, including header size */
uint8_t blob[]; /*< type dependent content */
} __packed;
/* FW version */
struct sof_ext_man_fw_version {
struct sof_ext_man_elem_header hdr;
/* use sof_ipc struct because of code re-use */
struct sof_ipc_fw_version version;
uint32_t flags;
} __packed;
/* extended data memory windows for IPC, trace and debug */
struct sof_ext_man_window {
struct sof_ext_man_elem_header hdr;
/* use sof_ipc struct because of code re-use */
struct sof_ipc_window ipc_window;
} __packed;
/* Used C compiler description */
struct sof_ext_man_cc_version {
struct sof_ext_man_elem_header hdr;
/* use sof_ipc struct because of code re-use */
struct sof_ipc_cc_version cc_version;
} __packed;
#endif /* __SOF_FIRMWARE_EXT_MANIFEST_H__ */

189
sound/soc/sof/loader.c
View File

@ -12,7 +12,6 @@
#include <linux/firmware.h> #include <linux/firmware.h>
#include <sound/sof.h> #include <sound/sof.h>
#include <uapi/sound/sof/ext_manifest.h>
#include "ops.h" #include "ops.h"
static int get_ext_windows(struct snd_sof_dev *sdev, static int get_ext_windows(struct snd_sof_dev *sdev,
@ -20,21 +19,13 @@ static int get_ext_windows(struct snd_sof_dev *sdev,
{ {
const struct sof_ipc_window *w = const struct sof_ipc_window *w =
container_of(ext_hdr, struct sof_ipc_window, ext_hdr); container_of(ext_hdr, struct sof_ipc_window, ext_hdr);
size_t w_size = struct_size(w, window, w->num_windows);
if (sdev->info_window) {
if (memcmp(sdev->info_window, w, w_size)) {
dev_err(sdev->dev, "error: mistmatch between window descriptor from extended manifest and mailbox");
return -EINVAL;
}
return 0;
}
if (w->num_windows == 0 || w->num_windows > SOF_IPC_MAX_ELEMS) if (w->num_windows == 0 || w->num_windows > SOF_IPC_MAX_ELEMS)
return -EINVAL; return -EINVAL;
/* keep a local copy of the data */ /* keep a local copy of the data */
sdev->info_window = kmemdup(w, w_size, GFP_KERNEL); sdev->info_window = kmemdup(w, struct_size(w, window, w->num_windows),
GFP_KERNEL);
if (!sdev->info_window) if (!sdev->info_window)
return -ENOMEM; return -ENOMEM;
@ -49,14 +40,6 @@ static int get_cc_info(struct snd_sof_dev *sdev,
const struct sof_ipc_cc_version *cc = const struct sof_ipc_cc_version *cc =
container_of(ext_hdr, struct sof_ipc_cc_version, ext_hdr); container_of(ext_hdr, struct sof_ipc_cc_version, ext_hdr);
if (sdev->cc_version) {
if (memcmp(sdev->cc_version, cc, cc->ext_hdr.hdr.size)) {
dev_err(sdev->dev, "error: receive diverged cc_version descriptions");
return -EINVAL;
}
return 0;
}
dev_dbg(sdev->dev, "Firmware info: used compiler %s %d:%d:%d%s used optimization flags %s\n", dev_dbg(sdev->dev, "Firmware info: used compiler %s %d:%d:%d%s used optimization flags %s\n",
cc->name, cc->major, cc->minor, cc->micro, cc->desc, cc->name, cc->major, cc->minor, cc->micro, cc->desc,
cc->optim); cc->optim);
@ -143,151 +126,6 @@ int snd_sof_fw_parse_ext_data(struct snd_sof_dev *sdev, u32 bar, u32 offset)
} }
EXPORT_SYMBOL(snd_sof_fw_parse_ext_data); EXPORT_SYMBOL(snd_sof_fw_parse_ext_data);
static int ext_man_get_fw_version(struct snd_sof_dev *sdev,
const struct sof_ext_man_elem_header *hdr)
{
const struct sof_ext_man_fw_version *v;
v = container_of(hdr, struct sof_ext_man_fw_version, hdr);
memcpy(&sdev->fw_ready.version, &v->version, sizeof(v->version));
sdev->fw_ready.flags = v->flags;
/* log ABI versions and check FW compatibility */
return snd_sof_ipc_valid(sdev);
}
static int ext_man_get_windows(struct snd_sof_dev *sdev,
const struct sof_ext_man_elem_header *hdr)
{
const struct sof_ipc_ext_data_hdr *w_ipc;
const struct sof_ext_man_window *w;
w = container_of(hdr, struct sof_ext_man_window, hdr);
w_ipc = (const struct sof_ipc_ext_data_hdr *)&w->ipc_window;
return get_ext_windows(sdev, w_ipc);
}
static int ext_man_get_cc_info(struct snd_sof_dev *sdev,
const struct sof_ext_man_elem_header *hdr)
{
const struct sof_ext_man_cc_version *cc;
const struct sof_ipc_ext_data_hdr *cc_version;
cc = container_of(hdr, struct sof_ext_man_cc_version, hdr);
cc_version = (const struct sof_ipc_ext_data_hdr *)&cc->cc_version;
return get_cc_info(sdev, cc_version);
}
static ssize_t snd_sof_ext_man_size(const struct firmware *fw)
{
const struct sof_ext_man_header *head = (void *)fw->data;
/*
* assert fw size is big enough to contain extended manifest header,
* it prevents from reading unallocated memory from `head` in following
* step.
*/
if (fw->size < sizeof(*head))
return -EINVAL;
/*
* When fw points to extended manifest,
* then first u32 must be equal SOF_EXT_MAN_MAGIC_NUMBER.
*/
if (head->magic == SOF_EXT_MAN_MAGIC_NUMBER)
return head->full_size;
/* otherwise given fw don't have an extended manifest */
return 0;
}
/* parse extended FW manifest data structures */
static int snd_sof_fw_ext_man_parse(struct snd_sof_dev *sdev,
const struct firmware *fw)
{
const struct sof_ext_man_elem_header *elem_hdr;
const struct sof_ext_man_header *head;
ssize_t ext_man_size;
ssize_t remaining;
uintptr_t iptr;
int ret = 0;
head = (struct sof_ext_man_header *)fw->data;
remaining = head->full_size - head->header_size;
ext_man_size = snd_sof_ext_man_size(fw);
/* Assert firmware starts with extended manifest */
if (ext_man_size < 0) {
dev_err(sdev->dev, "error: exception while reading firmware extended manifest, code %d\n",
(int)ext_man_size);
return ext_man_size;
} else if (!ext_man_size) {
dev_err(sdev->dev, "error: can't parse extended manifest when it's not present\n");
return -EINVAL;
}
/* incompatible version */
if (SOF_EXT_MAN_VERSION_INCOMPATIBLE(SOF_EXT_MAN_VERSION,
head->header_version)) {
dev_err(sdev->dev, "error: extended manifest version 0x%X differ from used 0x%X\n",
head->header_version, SOF_EXT_MAN_VERSION);
return -EINVAL;
}
/* get first extended manifest element header */
iptr = (uintptr_t)fw->data + head->header_size;
while (remaining > sizeof(*elem_hdr)) {
elem_hdr = (struct sof_ext_man_elem_header *)iptr;
dev_dbg(sdev->dev, "found sof_ext_man header type %d size 0x%X\n",
elem_hdr->type, elem_hdr->size);
if (elem_hdr->size < sizeof(*elem_hdr) ||
elem_hdr->size > remaining) {
dev_err(sdev->dev, "error: invalid sof_ext_man header size, type %d size 0x%X\n",
elem_hdr->type, elem_hdr->size);
break;
}
/* process structure data */
switch (elem_hdr->type) {
case SOF_EXT_MAN_ELEM_FW_VERSION:
ret = ext_man_get_fw_version(sdev, elem_hdr);
break;
case SOF_EXT_MAN_ELEM_WINDOW:
ret = ext_man_get_windows(sdev, elem_hdr);
break;
case SOF_EXT_MAN_ELEM_CC_VERSION:
ret = ext_man_get_cc_info(sdev, elem_hdr);
break;
default:
dev_warn(sdev->dev, "warning: unknown sof_ext_man header type %d size 0x%X\n",
elem_hdr->type, elem_hdr->size);
break;
}
if (ret < 0) {
dev_err(sdev->dev, "error: failed to parse sof_ext_man header type %d size 0x%X\n",
elem_hdr->type, elem_hdr->size);
break;
}
remaining -= elem_hdr->size;
iptr += elem_hdr->size;
}
if (remaining) {
dev_err(sdev->dev, "error: sof_ext_man header is inconsistent\n");
ret = -EINVAL;
}
return ret;
}
/* /*
* IPC Firmware ready. * IPC Firmware ready.
*/ */
@ -635,7 +473,6 @@ int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev)
{ {
struct snd_sof_pdata *plat_data = sdev->pdata; struct snd_sof_pdata *plat_data = sdev->pdata;
const char *fw_filename; const char *fw_filename;
ssize_t ext_man_size;
int ret; int ret;
/* Don't request firmware again if firmware is already requested */ /* Don't request firmware again if firmware is already requested */
@ -653,33 +490,11 @@ int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev)
if (ret < 0) { if (ret < 0) {
dev_err(sdev->dev, "error: request firmware %s failed err: %d\n", dev_err(sdev->dev, "error: request firmware %s failed err: %d\n",
fw_filename, ret); fw_filename, ret);
goto err;
} else { } else {
dev_dbg(sdev->dev, "request_firmware %s successful\n", dev_dbg(sdev->dev, "request_firmware %s successful\n",
fw_filename); fw_filename);
} }
/* check for extended manifest */
ext_man_size = snd_sof_ext_man_size(plat_data->fw);
if (ext_man_size > 0) {
ret = snd_sof_fw_ext_man_parse(sdev, plat_data->fw);
/* when no error occurred, drop extended manifest */
if (!ret)
plat_data->fw_offset = ext_man_size;
else
dev_err(sdev->dev, "error: firmware %s contains unsupported or invalid extended manifest: %d\n",
fw_filename, ret);
} else if (!ext_man_size) {
/* No extended manifest, so nothing to skip during FW load */
dev_dbg(sdev->dev, "firmware doesn't contain extended manifest\n");
} else {
ret = ext_man_size;
dev_err(sdev->dev, "error: firmware %s contains unsupported or invalid extended manifest: %d\n",
fw_filename, ret);
}
err:
kfree(fw_filename); kfree(fw_filename);
return ret; return ret;