ASoC: SOF: Fix build (d8e25a10) · Commits · 戴 / test

include/uapi/sound/sof/ext_manifest.h

deleted100644 → 0

+0 −91

Original line number	Diff line number	Diff line
		/* 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__ */

sound/soc/sof/loader.c

+2 −187

Original line number	Diff line number	Diff line
		@@ -12,7 +12,6 @@

		#include <linux/firmware.h>
		#include <sound/sof.h>
		#include <uapi/sound/sof/ext_manifest.h>
		#include "ops.h"

		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 =
		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)
		return -EINVAL;

		/* 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)
		return -ENOMEM;

		@@ -49,14 +40,6 @@ static int get_cc_info(struct snd_sof_dev *sdev,
		const struct sof_ipc_cc_version *cc =
		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",
		cc->name, cc->major, cc->minor, cc->micro, cc->desc,
		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);

		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.
		*/
		@@ -635,7 +473,6 @@ int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev)
		{
		struct snd_sof_pdata *plat_data = sdev->pdata;
		const char *fw_filename;
		ssize_t ext_man_size;
		int ret;

		/* 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) {
		dev_err(sdev->dev, "error: request firmware %s failed err: %d\n",
		fw_filename, ret);
		goto err;
		} else {
		dev_dbg(sdev->dev, "request_firmware %s successful\n",
		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);

		return ret;

Admin message