ASoC: Intel: avs: APL-based platforms support (c8c960c1) · Commits · EulixOS / Software / Kernel

sound/soc/intel/avs/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@
		snd-soc-avs-objs := dsp.o ipc.o messages.o utils.o core.o loader.o \
		topology.o path.o pcm.o board_selection.o
		snd-soc-avs-objs += cldma.o
		snd-soc-avs-objs += skl.o
		snd-soc-avs-objs += skl.o apl.o

		snd-soc-avs-objs += trace.o
		# tell define_trace.h where to find the trace header

sound/soc/intel/avs/apl.c

0 → 100644

+250 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		//
		// Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
		//
		// Authors: Cezary Rojewski <cezary.rojewski@intel.com>
		// Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
		//

		#include <linux/devcoredump.h>
		#include <linux/slab.h>
		#include "avs.h"
		#include "messages.h"
		#include "path.h"
		#include "topology.h"

		static int apl_enable_logs(struct avs_dev *adev, enum avs_log_enable enable, u32 aging_period,
		u32 fifo_full_period, unsigned long resource_mask, u32 *priorities)
		{
		struct apl_log_state_info *info;
		u32 size, num_cores = adev->hw_cfg.dsp_cores;
		int ret, i;

		if (fls_long(resource_mask) > num_cores)
		return -EINVAL;
		size = struct_size(info, logs_core, num_cores);
		info = kzalloc(size, GFP_KERNEL);
		if (!info)
		return -ENOMEM;

		info->aging_timer_period = aging_period;
		info->fifo_full_timer_period = fifo_full_period;
		info->core_mask = resource_mask;
		if (enable)
		for_each_set_bit(i, &resource_mask, num_cores) {
		info->logs_core[i].enable = enable;
		info->logs_core[i].min_priority = *priorities++;
		}
		else
		for_each_set_bit(i, &resource_mask, num_cores)
		info->logs_core[i].enable = enable;

		ret = avs_ipc_set_enable_logs(adev, (u8 *)info, size);
		kfree(info);
		if (ret)
		return AVS_IPC_RET(ret);

		return 0;
		}

		static int apl_log_buffer_status(struct avs_dev adev, union avs_notify_msg msg)
		{
		struct apl_log_buffer_layout layout;
		unsigned long flags;
		void __iomem addr, buf;

		addr = avs_log_buffer_addr(adev, msg->log.core);
		if (!addr)
		return -ENXIO;

		memcpy_fromio(&layout, addr, sizeof(layout));

		spin_lock_irqsave(&adev->dbg.trace_lock, flags);
		if (!kfifo_initialized(&adev->dbg.trace_fifo))
		/* consume the logs regardless of consumer presence */
		goto update_read_ptr;

		buf = apl_log_payload_addr(addr);

		if (layout.read_ptr > layout.write_ptr) {
		__kfifo_fromio_locked(&adev->dbg.trace_fifo, buf + layout.read_ptr,
		apl_log_payload_size(adev) - layout.read_ptr,
		&adev->dbg.fifo_lock);
		layout.read_ptr = 0;
		}
		__kfifo_fromio_locked(&adev->dbg.trace_fifo, buf + layout.read_ptr,
		layout.write_ptr - layout.read_ptr, &adev->dbg.fifo_lock);

		wake_up(&adev->dbg.trace_waitq);

		update_read_ptr:
		spin_unlock_irqrestore(&adev->dbg.trace_lock, flags);
		writel(layout.write_ptr, addr);
		return 0;
		}

		static int apl_wait_log_entry(struct avs_dev adev, u32 core, struct apl_log_buffer_layout layout)
		{
		unsigned long timeout;
		void __iomem *addr;

		addr = avs_log_buffer_addr(adev, core);
		if (!addr)
		return -ENXIO;

		timeout = jiffies + msecs_to_jiffies(10);

		do {
		memcpy_fromio(layout, addr, sizeof(*layout));
		if (layout->read_ptr != layout->write_ptr)
		return 0;
		usleep_range(500, 1000);
		} while (!time_after(jiffies, timeout));

		return -ETIMEDOUT;
		}

		/* reads log header and tests its type */
		#define apl_is_entry_stackdump(addr) ((readl(addr) >> 30) & 0x1)

		static int apl_coredump(struct avs_dev adev, union avs_notify_msg msg)
		{
		struct apl_log_buffer_layout layout;
		void __iomem addr, buf;
		size_t dump_size;
		u16 offset = 0;
		u8 dump, pos;

		dump_size = AVS_FW_REGS_SIZE + msg->ext.coredump.stack_dump_size;
		dump = vzalloc(dump_size);
		if (!dump)
		return -ENOMEM;

		memcpy_fromio(dump, avs_sram_addr(adev, AVS_FW_REGS_WINDOW), AVS_FW_REGS_SIZE);

		if (!msg->ext.coredump.stack_dump_size)
		goto exit;

		/* Dump the registers even if an external error prevents gathering the stack. */
		addr = avs_log_buffer_addr(adev, msg->ext.coredump.core_id);
		if (!addr)
		goto exit;

		buf = apl_log_payload_addr(addr);
		memcpy_fromio(&layout, addr, sizeof(layout));
		if (!apl_is_entry_stackdump(buf + layout.read_ptr)) {
		/*
		* DSP awaits the remaining logs to be
		* gathered before dumping stack
		*/
		msg->log.core = msg->ext.coredump.core_id;
		avs_dsp_op(adev, log_buffer_status, msg);
		}

		pos = dump + AVS_FW_REGS_SIZE;
		/* gather the stack */
		do {
		u32 count;

		if (apl_wait_log_entry(adev, msg->ext.coredump.core_id, &layout))
		break;

		if (layout.read_ptr > layout.write_ptr) {
		count = apl_log_payload_size(adev) - layout.read_ptr;
		memcpy_fromio(pos + offset, buf + layout.read_ptr, count);
		layout.read_ptr = 0;
		offset += count;
		}
		count = layout.write_ptr - layout.read_ptr;
		memcpy_fromio(pos + offset, buf + layout.read_ptr, count);
		offset += count;

		/* update read pointer */
		writel(layout.write_ptr, addr);
		} while (offset < msg->ext.coredump.stack_dump_size);

		exit:
		dev_coredumpv(adev->dev, dump, dump_size, GFP_KERNEL);

		return 0;
		}

		static bool apl_lp_streaming(struct avs_dev *adev)
		{
		struct avs_path *path;

		/* Any gateway without buffer allocated in LP area disqualifies D0IX. */
		list_for_each_entry(path, &adev->path_list, node) {
		struct avs_path_pipeline *ppl;

		list_for_each_entry(ppl, &path->ppl_list, node) {
		struct avs_path_module *mod;

		list_for_each_entry(mod, &ppl->mod_list, node) {
		struct avs_tplg_modcfg_ext *cfg;

		cfg = mod->template->cfg_ext;

		/* only copiers have gateway attributes */
		if (!guid_equal(&cfg->type, &AVS_COPIER_MOD_UUID))
		continue;
		/* non-gateway copiers do not prevent PG */
		if (cfg->copier.dma_type == INVALID_OBJECT_ID)
		continue;

		if (!mod->gtw_attrs.lp_buffer_alloc)
		return false;
		}
		}
		}

		return true;
		}

		static bool apl_d0ix_toggle(struct avs_dev adev, struct avs_ipc_msg tx, bool wake)
		{
		/* wake in all cases */
		if (wake)
		return true;

		/*
		* If no pipelines are running, allow for d0ix schedule.
		* If all gateways have lp=1, allow for d0ix schedule.
		* If any gateway with lp=0 is allocated, abort scheduling d0ix.
		*
		* Note: for cAVS 1.5+ and 1.8, D0IX is LP-firmware transition,
		* not the power-gating mechanism known from cAVS 2.0.
		*/
		return apl_lp_streaming(adev);
		}

		static int apl_set_d0ix(struct avs_dev *adev, bool enable)
		{
		bool streaming = false;
		int ret;

		if (enable)
		/* Either idle or all gateways with lp=1. */
		streaming = !list_empty(&adev->path_list);

		ret = avs_ipc_set_d0ix(adev, enable, streaming);
		return AVS_IPC_RET(ret);
		}

		const struct avs_dsp_ops apl_dsp_ops = {
		.power = avs_dsp_core_power,
		.reset = avs_dsp_core_reset,
		.stall = avs_dsp_core_stall,
		.irq_handler = avs_dsp_irq_handler,
		.irq_thread = avs_dsp_irq_thread,
		.int_control = avs_dsp_interrupt_control,
		.load_basefw = avs_hda_load_basefw,
		.load_lib = avs_hda_load_library,
		.transfer_mods = avs_hda_transfer_modules,
		.enable_logs = apl_enable_logs,
		.log_buffer_offset = skl_log_buffer_offset,
		.log_buffer_status = apl_log_buffer_status,
		.coredump = apl_coredump,
		.d0ix_toggle = apl_d0ix_toggle,
		.set_d0ix = apl_set_d0ix,
		};

sound/soc/intel/avs/avs.h

+13 −0

Original line number	Diff line number	Diff line
		@@ -57,6 +57,7 @@ struct avs_dsp_ops {
		((adev)->spec->dsp_ops->op(adev, ## __VA_ARGS__))

		extern const struct avs_dsp_ops skl_dsp_ops;
		extern const struct avs_dsp_ops apl_dsp_ops;

		#define AVS_PLATATTR_CLDMA BIT_ULL(0)
		#define AVS_PLATATTR_IMR BIT_ULL(1)
		@@ -333,4 +334,16 @@ unsigned int __kfifo_fromio_locked(struct kfifo fifo, const void __iomem src,
		(avs_sram_addr(adev, AVS_DEBUG_WINDOW) + __offset); \
		})

		struct apl_log_buffer_layout {
		u32 read_ptr;
		u32 write_ptr;
		u8 buffer[];
		} __packed;

		#define apl_log_payload_size(adev) \
		(avs_log_buffer_size(adev) - sizeof(struct apl_log_buffer_layout))

		#define apl_log_payload_addr(addr) \
		(addr + sizeof(struct apl_log_buffer_layout))

		#endif /* __SOUND_SOC_INTEL_AVS_H */

sound/soc/intel/avs/core.c

+18 −0

Original line number	Diff line number	Diff line
		@@ -650,9 +650,27 @@ static const struct avs_spec skl_desc = {
		.rom_status = SKL_ADSP_SRAM_BASE_OFFSET,
		};

		static const struct avs_spec apl_desc = {
		.name = "apl",
		.min_fw_version = {
		.major = 9,
		.minor = 22,
		.hotfix = 1,
		.build = 4323,
		},
		.dsp_ops = &apl_dsp_ops,
		.core_init_mask = 3,
		.attributes = AVS_PLATATTR_IMR,
		.sram_base_offset = APL_ADSP_SRAM_BASE_OFFSET,
		.sram_window_size = APL_ADSP_SRAM_WINDOW_SIZE,
		.rom_status = APL_ADSP_SRAM_BASE_OFFSET,
		};

		static const struct pci_device_id avs_ids[] = {
		{ PCI_VDEVICE(INTEL, 0x9d70), (unsigned long)&skl_desc }, /* SKL */
		{ PCI_VDEVICE(INTEL, 0x9d71), (unsigned long)&skl_desc }, /* KBL */
		{ PCI_VDEVICE(INTEL, 0x5a98), (unsigned long)&apl_desc }, /* APL */
		{ PCI_VDEVICE(INTEL, 0x3198), (unsigned long)&apl_desc }, /* GML */
		{ 0 }
		};
		MODULE_DEVICE_TABLE(pci, avs_ids);

sound/soc/intel/avs/loader.c

+4 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,8 @@
		#define AVS_EXT_MANIFEST_MAGIC 0x31454124
		#define SKL_MANIFEST_MAGIC 0x00000006
		#define SKL_ADSPFW_OFFSET 0x284
		#define APL_MANIFEST_MAGIC 0x44504324
		#define APL_ADSPFW_OFFSET 0x2000

		/* Occasionally, engineering (release candidate) firmware is provided for testing. */
		static bool debug_ignore_fw_version;
		@@ -87,6 +89,8 @@ static int avs_fw_manifest_offset(struct firmware *fw)
		switch (magic) {
		case SKL_MANIFEST_MAGIC:
		return SKL_ADSPFW_OFFSET;
		case APL_MANIFEST_MAGIC:
		return APL_ADSPFW_OFFSET;
		default:
		return -EINVAL;
		}