V2.8.1 candidate

app/boards/intel_adsp_ace15_mtpm.conf

@@ -38,6 +38,7 @@ CONFIG_DMA_DW_LLI_POOL_SIZE=50
 CONFIG_DMA_DW_SUSPEND_DRAIN=y
 CONFIG_INTEL_MODULES=y
 CONFIG_LIBRARY_MANAGER=y
+CONFIG_LIBRARY_AUTH_SUPPORT=y
 CONFIG_INTEL_ADSP_TIMER=y
 CONFIG_MM_DRV_INTEL_ADSP_TLB_REMAP_UNUSED_RAM=y
 CONFIG_AMS=y

app/boards/intel_adsp_ace20_lnl.conf

@@ -32,6 +32,7 @@ CONFIG_DMA=y
 CONFIG_DMA_INTEL_ADSP_GPDMA=n
 CONFIG_INTEL_MODULES=y
 CONFIG_LIBRARY_MANAGER=y
+CONFIG_LIBRARY_AUTH_SUPPORT=y
 CONFIG_INTEL_ADSP_TIMER=y
 CONFIG_MM_DRV_INTEL_ADSP_TLB_REMAP_UNUSED_RAM=y
 CONFIG_AMS=y

src/audio/volume/volume_ipc4.c

@@ -54,10 +54,6 @@ static int set_volume_ipc4(struct vol_data *cd, uint32_t const channel,
 	cd->tvolume[channel] = target_volume;
 	/* init ramp start volume*/
 	cd->rvolume[channel] = 0;
-	/* init muted volume */
-	cd->mvolume[channel] = 0;
-	/* set muted as false*/
-	cd->muted[channel] = false;
 
 	/* ATM there is support for the same ramp for all channels */
 	cd->ramp_type = ipc4_curve_type_convert((enum ipc4_curve_type)curve_type);
@@ -164,6 +160,9 @@ int volume_init(struct processing_module *mod)
 				target_volume[channel_cfg],
 				vol->config[channel_cfg].curve_type,
 				vol->config[channel_cfg].curve_duration);
+
+		/* set muted as false*/
+		cd->muted[channel] = false;
 	}
 
 	init_ramp(cd, vol->config[0].curve_duration, target_volume[0]);
@@ -224,21 +223,30 @@ static int volume_set_volume(struct processing_module *mod, const uint8_t *data,
 
 	if (cdata.channel_id == IPC4_ALL_CHANNELS_MASK) {
 		for (i = 0; i < channels_count; i++) {
-			set_volume_ipc4(cd, i, cdata.target_volume,
-					cdata.curve_type,
-					cdata.curve_duration);
-
-			volume_set_chan(mod, i, cd->tvolume[i], true);
+			if (cd->muted[i]) {
+				cd->mvolume[i] = cdata.target_volume;
+			} else {
+				set_volume_ipc4(cd, i, cdata.target_volume,
+						cdata.curve_type,
+						cdata.curve_duration);
+
+				volume_set_chan(mod, i, cd->tvolume[i], true);
+			}
 			if (cd->volume[i] != cd->tvolume[i])
 				cd->ramp_finished = false;
 		}
 	} else {
-		set_volume_ipc4(cd, cdata.channel_id, cdata.target_volume,
-				cdata.curve_type,
-				cdata.curve_duration);
+		if (cd->muted[cdata.channel_id]) {
+			cd->mvolume[cdata.channel_id] = cdata.target_volume;
+		} else {
+			set_volume_ipc4(cd, cdata.channel_id,
+					cdata.target_volume,
+					cdata.curve_type,
+					cdata.curve_duration);
 
-		volume_set_chan(mod, cdata.channel_id, cd->tvolume[cdata.channel_id],
-				true);
+			volume_set_chan(mod, cdata.channel_id,
+					cd->tvolume[cdata.channel_id], true);
+		}
 		if (cd->volume[cdata.channel_id] != cd->tvolume[cdata.channel_id])
 			cd->ramp_finished = false;
 	}
@@ -297,6 +305,53 @@ static int volume_set_attenuation(struct processing_module *mod, const uint8_t *
 	return 0;
 }
 
+static int volume_set_switch(struct processing_module *mod, const uint8_t *data,
+			     int data_size)
+{
+	struct vol_data *cd = module_get_private_data(mod);
+	struct comp_dev *dev = mod->dev;
+	struct sof_ipc4_control_msg_payload *ctl;
+	unsigned int channels_count, num_elems;
+	unsigned int i, val;
+
+	if (data_size < sizeof(struct sof_ipc4_control_msg_payload)) {
+		comp_err(dev, "error: data_size %d should be bigger than %d", data_size,
+			 sizeof(struct sof_ipc4_control_msg_payload));
+		return -EINVAL;
+	}
+
+	ctl = (struct sof_ipc4_control_msg_payload *)data;
+
+	cd->ramp_finished = true;
+
+	channels_count = mod->priv.cfg.base_cfg.audio_fmt.channels_count;
+	if (channels_count > SOF_IPC_MAX_CHANNELS) {
+		comp_err(dev, "Invalid channels count %u", channels_count);
+		return -EINVAL;
+	}
+
+	num_elems = ctl->num_elems;
+	if (num_elems > channels_count) {
+		comp_warn(dev, "limit num_elems %d to %d", num_elems, channels_count);
+		num_elems = channels_count;
+	}
+
+	for (i = 0; i < num_elems; i++) {
+		val = ctl->chanv[i].value;
+		comp_dbg(dev, "channel %i, value %u", i, val);
+
+		if (val)
+			volume_set_chan_unmute(mod, i);
+		else
+			volume_set_chan_mute(mod, i);
+
+		if (cd->volume[i] != cd->tvolume[i])
+			cd->ramp_finished = false;
+	}
+
+	return 0;
+}
+
 int volume_set_config(struct processing_module *mod, uint32_t config_id,
 		      enum module_cfg_fragment_position pos, uint32_t data_offset_size,
 		      const uint8_t *fragment, size_t fragment_size, uint8_t *response,
@@ -323,6 +378,8 @@ int volume_set_config(struct processing_module *mod, uint32_t config_id,
 		return volume_set_volume(mod, fragment, fragment_size);
 	case IPC4_SET_ATTENUATION:
 		return volume_set_attenuation(mod, fragment, fragment_size);
+	case SOF_IPC4_SWITCH_CONTROL_PARAM_ID:
+		return volume_set_switch(mod, fragment, fragment_size);
 	default:
 		comp_err(dev, "unsupported param %d", config_id);
 		return -EINVAL;

src/include/sof/auth_api_iface.h

@@ -0,0 +1,149 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright(c) 2022 Intel Corporation. All rights reserved.
+ *
+ * Author: Jaroslaw Stelter <jaroslaw.stelter@intel.com>
+ *         Pawel Dobrowolski <pawelx.dobrowolski@intel.com>
+ */
+#ifndef __AUTH_API_IFACE_H__
+#define __AUTH_API_IFACE_H__
+
+#include <auth/intel_status_logger_iface.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#define AUTH_API_VERSION_MAJOR (2)
+#define AUTH_API_VERSION_MINOR (0)
+#define AUTH_API_VERSION_PATCH (0)
+
+#define AUTH_SCRATCH_BUFF_SZ (0xA000) // 40kB
+
+/*
+ * Return codes supported by authentication engine:
+ * ADSP_AUTH_IMAGE_UNTRUSTED               = 9040,
+ * ADSP_AUTH_CANNOT_ALLOCATE_SCRATCH_BUFF  = 9041,
+ * ADSP_AUTH_INVALID_AUTH_API_CTX_PTR      = 9042,
+ * ADSP_AUTH_SVN_VERIFICATION_FAIL         = 9043,
+ * ADSP_AUTH_IFWI_PARTITION_FAIL           = 9044,
+ * ADSP_AUTH_VERIFY_IMAGE_TYPE_FAIL        = 9045,
+ * ADSP_AUTH_UNSUPPORTED_VERSION           = 9046,
+ * ADSP_AUTH_INCOMPATIBLE_MANIFEST_VERSION = 9047,
+ */
+
+struct auth_api_version_num {
+	uint8_t patch;
+	uint8_t minor;
+	uint8_t major;
+	uint8_t rsvd;
+} __packed __aligned(4);
+
+enum auth_phase {
+	AUTH_PHASE_FIRST = 0,
+	AUTH_PHASE_MID = 1,
+	AUTH_PHASE_LAST = 2
+};
+
+enum auth_result {
+	AUTH_NOT_COMPLETED = 0,
+	AUTH_IMAGE_TRUSTED = 1,
+	AUTH_IMAGE_UNTRUSTED = 2
+};
+
+enum auth_image_type {
+	IMG_TYPE_ROM_EXT = 0,
+	IMG_TYPE_MAIN_FW = 1,
+	IMG_TYPE_LIB = 2
+};
+
+struct auth_api_ctx;
+
+struct auth_api_version {
+	/* Interface to return authentication API version.
+	 * Return value: version number represented by auth_api_version_num structure.
+	 */
+	struct auth_api_version_num (*version)();
+};
+
+struct auth_api {
+	/* Interface to initialize authentication API and context.
+	 * Parameters:
+	 * ctx - pointer to the context instance of type auth_api_ctx.
+	 * scratch_buff - pointer to scratch buffer.
+	 *    Scratch buffer must be located in L2 Local Memory (SHA Engine limitation).
+	 *    Caller is responsible to power up necessary L2 Local Memory banks.
+	 *    Address alignment must correspond to SHA384_IO_BUF_ALIGNMENT.
+	 * scratch_buff_size – size must be the same as AUTH_SCRATCH_BUFF_SZ.
+	 * Return value:
+	 *    ADSP_SUCCESS - successful initialization.
+	 */
+	int (*init)(struct auth_api_ctx *ctx, void *scratch_buff, size_t scratch_buff_size,
+		    enum auth_image_type image_type);
+
+	/* Interface to cleanup authentication API.
+	 * Parameters:
+	 * ctx - pointer to the context instance of type AuthApiCtx.
+	 */
+	void (*cleanup)(struct auth_api_ctx *ctx);
+
+	/* Interface for initiating signed FW image (async) authentication process.
+	 * Parameters:
+	 * ctx - pointer to the context instance of type AuthApiCtx.
+	 * chunk - pointer to the chunk of signed FW image.
+	 * chunk_size - chunk size in bytes.
+	 * phase - authentication phase.
+	 *    Must corresponds to one of the AuthPhase values.
+	 *    In case of one time FW authentication, where signed FW image size must be
+	 *    less or equal to scratch_buff_size, the caller must pass AUTH_PHASE_LAST.
+	 * Return value: ADSP_SUCCESS when authentication process has been initiated
+	 *    successfully, or one of ADSP_FLV_* error codes in case of failure.
+	 */
+	int (*init_auth_proc)(struct auth_api_ctx *ctx, const void *chunk, size_t chunk_size,
+			      enum auth_phase phase);
+
+	/* Interface to return if authentication process is busy.
+	 * Parameters:
+	 * ctx - pointer to the context instance of type AuthApiCtx.
+	 * This function can be used for authentication process synchronization.
+	 * Return value: true if authentication process is busy.
+	 */
+	bool (*busy)(struct auth_api_ctx *ctx);
+
+	/* Interface to return authentication result
+	 * Parameters:
+	 * ctx - pointer to the context instance of type AuthApiCtx.
+	 * Return value:
+	 *    AUTH_NOT_COMPLETED - authentication is not completed,
+	 *    AUTH_IMAGE_TRUSTED - authentication completed and signed FW image is
+	 *        trusted,
+	 *    AUTH_IMAGE_UNTRUSTED - authentication completed, but signed FW image is
+	 *        untrusted.
+	 */
+	enum auth_result (*result)(struct auth_api_ctx *ctx);
+
+	/* Interface to register status/error code logger.
+	 * Parameters:
+	 * ctx - pointer to the context instance of type AuthApiCtx.
+	 * sts_logger - pointer to status logger.
+	 * Return value: ADSP_SUCCESS when logger has been registered successfully.
+	 */
+	int (*register_status_logger)(struct auth_api_ctx *ctx,
+				      struct status_logger_ctx *status_logger);
+
+	/* Interface to unregister status/error code logger.
+	 * Parameters:
+	 * ctx - pointer to the context instance of type AuthApiCtx.
+	 */
+	void (*unregister_status_logger)(struct auth_api_ctx *ctx);
+};
+
+struct auth_api_ctx {
+	struct auth_api_version *version_api;
+	void *scratch_buff;
+	size_t scratch_buff_size;
+	enum auth_result result;
+	struct auth_api *auth_api;
+	enum auth_image_type image_type;
+	struct status_logger_ctx *status_logger;
+};
+
+#endif /* __SOF_LIB_MANAGER_H__ */

src/include/sof/lib_manager.h

@@ -64,6 +64,9 @@
 
 #include <stdint.h>
 #include <rimage/sof/user/manifest.h>
+#if CONFIG_LIBRARY_AUTH_SUPPORT
+#include <sof/auth_api_iface.h>
+#endif
 
 #define LIB_MANAGER_MAX_LIBS				16
 #define LIB_MANAGER_LIB_ID_SHIFT			12
@@ -86,6 +89,10 @@ struct ext_library {
 	uint32_t lib_notif_count;
 
 	void *runtime_data;
+#if CONFIG_LIBRARY_AUTH_SUPPORT
+	struct auth_api_ctx auth_ctx;
+	void *auth_buffer;
+#endif
 };
 
 /* lib manager context, used by lib_notification */

src/library_manager/Kconfig

@@ -13,4 +13,14 @@ config LIBRARY_MANAGER
 	  Externally developed modules both for SOF and Zephyr
 	  could be used if enabled.
 	  If unsure say N.
+
+config LIBRARY_AUTH_SUPPORT
+	bool "Library Authentication Support"
+	default n
+	help
+	  This is support for dynamic modules authentication.
+	  Externally developed modules both for SOF and Zephyr
+	  could be used if enabled.
+	  If unsure say N.
+
 endmenu