apl.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2//
  3// Copyright(c) 2021-2022 Intel Corporation
  4//
  5// Authors: Cezary Rojewski <cezary.rojewski@intel.com>
  6//          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
  7//
  8
  9#include <linux/devcoredump.h>
 10#include <linux/slab.h>
 11#include <sound/hdaudio_ext.h>
 12#include "avs.h"
 13#include "debug.h"
 14#include "messages.h"
 15#include "path.h"
 16#include "registers.h"
 17#include "topology.h"
 18
 19static irqreturn_t avs_apl_dsp_interrupt(struct avs_dev *adev)
 20{
 21	u32 adspis = snd_hdac_adsp_readl(adev, AVS_ADSP_REG_ADSPIS);
 22	irqreturn_t ret = IRQ_NONE;
 23
 24	if (adspis == UINT_MAX)
 25		return ret;
 26
 27	if (adspis & AVS_ADSP_ADSPIS_IPC) {
 28		avs_skl_ipc_interrupt(adev);
 29		ret = IRQ_HANDLED;
 30	}
 31
 32	return ret;
 33}
 34
 35#ifdef CONFIG_DEBUG_FS
 36int avs_apl_enable_logs(struct avs_dev *adev, enum avs_log_enable enable, u32 aging_period,
 37			u32 fifo_full_period, unsigned long resource_mask, u32 *priorities)
 38{
 39	struct avs_apl_log_state_info *info;
 40	u32 size, num_cores = adev->hw_cfg.dsp_cores;
 41	int ret, i;
 42
 43	if (fls_long(resource_mask) > num_cores)
 44		return -EINVAL;
 45	size = struct_size(info, logs_core, num_cores);
 46	info = kzalloc(size, GFP_KERNEL);
 47	if (!info)
 48		return -ENOMEM;
 49
 50	info->aging_timer_period = aging_period;
 51	info->fifo_full_timer_period = fifo_full_period;
 52	info->core_mask = resource_mask;
 53	if (enable)
 54		for_each_set_bit(i, &resource_mask, num_cores) {
 55			info->logs_core[i].enable = enable;
 56			info->logs_core[i].min_priority = *priorities++;
 57		}
 58	else
 59		for_each_set_bit(i, &resource_mask, num_cores)
 60			info->logs_core[i].enable = enable;
 61
 62	ret = avs_ipc_set_enable_logs(adev, (u8 *)info, size);
 63	kfree(info);
 64	if (ret)
 65		return AVS_IPC_RET(ret);
 66
 67	return 0;
 68}
 69#endif
 70
 71int avs_apl_log_buffer_status(struct avs_dev *adev, union avs_notify_msg *msg)
 72{
 73	struct avs_apl_log_buffer_layout layout;
 74	void __iomem *addr, *buf;
 75
 76	addr = avs_log_buffer_addr(adev, msg->log.core);
 77	if (!addr)
 78		return -ENXIO;
 79
 80	memcpy_fromio(&layout, addr, sizeof(layout));
 81
 82	if (!avs_logging_fw(adev))
 83		/* consume the logs regardless of consumer presence */
 84		goto update_read_ptr;
 85
 86	buf = avs_apl_log_payload_addr(addr);
 87
 88	if (layout.read_ptr > layout.write_ptr) {
 89		avs_dump_fw_log(adev, buf + layout.read_ptr,
 90				avs_apl_log_payload_size(adev) - layout.read_ptr);
 91		layout.read_ptr = 0;
 92	}
 93	avs_dump_fw_log_wakeup(adev, buf + layout.read_ptr, layout.write_ptr - layout.read_ptr);
 94
 95update_read_ptr:
 96	writel(layout.write_ptr, addr);
 97	return 0;
 98}
 99
100static int avs_apl_wait_log_entry(struct avs_dev *adev, u32 core,
101				  struct avs_apl_log_buffer_layout *layout)
102{
103	unsigned long timeout;
104	void __iomem *addr;
105
106	addr = avs_log_buffer_addr(adev, core);
107	if (!addr)
108		return -ENXIO;
109
110	timeout = jiffies + msecs_to_jiffies(10);
111
112	do {
113		memcpy_fromio(layout, addr, sizeof(*layout));
114		if (layout->read_ptr != layout->write_ptr)
115			return 0;
116		usleep_range(500, 1000);
117	} while (!time_after(jiffies, timeout));
118
119	return -ETIMEDOUT;
120}
121
122/* reads log header and tests its type */
123#define avs_apl_is_entry_stackdump(addr) ((readl(addr) >> 30) & 0x1)
124
125int avs_apl_coredump(struct avs_dev *adev, union avs_notify_msg *msg)
126{
127	struct avs_apl_log_buffer_layout layout;
128	void __iomem *addr, *buf;
129	size_t dump_size;
130	u32 offset = 0;
131	u8 *dump, *pos;
132
133	dump_size = AVS_FW_REGS_SIZE + msg->ext.coredump.stack_dump_size;
134	dump = vzalloc(dump_size);
135	if (!dump)
136		return -ENOMEM;
137
138	memcpy_fromio(dump, avs_sram_addr(adev, AVS_FW_REGS_WINDOW), AVS_FW_REGS_SIZE);
139
140	if (!msg->ext.coredump.stack_dump_size)
141		goto exit;
142
143	/* Dump the registers even if an external error prevents gathering the stack. */
144	addr = avs_log_buffer_addr(adev, msg->ext.coredump.core_id);
145	if (!addr)
146		goto exit;
147
148	buf = avs_apl_log_payload_addr(addr);
149	memcpy_fromio(&layout, addr, sizeof(layout));
150	if (!avs_apl_is_entry_stackdump(buf + layout.read_ptr)) {
151		union avs_notify_msg lbs_msg = AVS_NOTIFICATION(LOG_BUFFER_STATUS);
152
153		/*
154		 * DSP awaits the remaining logs to be
155		 * gathered before dumping stack
156		 */
157		lbs_msg.log.core = msg->ext.coredump.core_id;
158		avs_log_buffer_status_locked(adev, &lbs_msg);
159	}
160
161	pos = dump + AVS_FW_REGS_SIZE;
162	/* gather the stack */
163	do {
164		u32 count;
165
166		if (avs_apl_wait_log_entry(adev, msg->ext.coredump.core_id, &layout))
167			break;
168
169		if (layout.read_ptr > layout.write_ptr) {
170			count = avs_apl_log_payload_size(adev) - layout.read_ptr;
171			memcpy_fromio(pos + offset, buf + layout.read_ptr, count);
172			layout.read_ptr = 0;
173			offset += count;
174		}
175		count = layout.write_ptr - layout.read_ptr;
176		memcpy_fromio(pos + offset, buf + layout.read_ptr, count);
177		offset += count;
178
179		/* update read pointer */
180		writel(layout.write_ptr, addr);
181	} while (offset < msg->ext.coredump.stack_dump_size);
182
183exit:
184	dev_coredumpv(adev->dev, dump, dump_size, GFP_KERNEL);
185
186	return 0;
187}
188
189static bool avs_apl_lp_streaming(struct avs_dev *adev)
190{
191	struct avs_path *path;
192
193	spin_lock(&adev->path_list_lock);
194	/* Any gateway without buffer allocated in LP area disqualifies D0IX. */
195	list_for_each_entry(path, &adev->path_list, node) {
196		struct avs_path_pipeline *ppl;
197
198		list_for_each_entry(ppl, &path->ppl_list, node) {
199			struct avs_path_module *mod;
200
201			list_for_each_entry(mod, &ppl->mod_list, node) {
202				struct avs_tplg_modcfg_ext *cfg;
203
204				cfg = mod->template->cfg_ext;
205
206				/* only copiers have gateway attributes */
207				if (!guid_equal(&cfg->type, &AVS_COPIER_MOD_UUID))
208					continue;
209				/* non-gateway copiers do not prevent PG */
210				if (cfg->copier.dma_type == INVALID_OBJECT_ID)
211					continue;
212
213				if (!mod->gtw_attrs.lp_buffer_alloc) {
214					spin_unlock(&adev->path_list_lock);
215					return false;
216				}
217			}
218		}
219	}
220	spin_unlock(&adev->path_list_lock);
221
222	return true;
223}
224
225bool avs_apl_d0ix_toggle(struct avs_dev *adev, struct avs_ipc_msg *tx, bool wake)
226{
227	/* wake in all cases */
228	if (wake)
229		return true;
230
231	/*
232	 * If no pipelines are running, allow for d0ix schedule.
233	 * If all gateways have lp=1, allow for d0ix schedule.
234	 * If any gateway with lp=0 is allocated, abort scheduling d0ix.
235	 *
236	 * Note: for cAVS 1.5+ and 1.8, D0IX is LP-firmware transition,
237	 * not the power-gating mechanism known from cAVS 2.0.
238	 */
239	return avs_apl_lp_streaming(adev);
240}
241
242int avs_apl_set_d0ix(struct avs_dev *adev, bool enable)
243{
244	bool streaming = false;
245	int ret;
246
247	if (enable)
248		/* Either idle or all gateways with lp=1. */
249		streaming = !list_empty(&adev->path_list);
250
251	ret = avs_ipc_set_d0ix(adev, enable, streaming);
252	return AVS_IPC_RET(ret);
253}
254
255const struct avs_dsp_ops avs_apl_dsp_ops = {
256	.power = avs_dsp_core_power,
257	.reset = avs_dsp_core_reset,
258	.stall = avs_dsp_core_stall,
259	.dsp_interrupt = avs_apl_dsp_interrupt,
260	.int_control = avs_dsp_interrupt_control,
261	.load_basefw = avs_hda_load_basefw,
262	.load_lib = avs_hda_load_library,
263	.transfer_mods = avs_hda_transfer_modules,
264	.log_buffer_offset = avs_skl_log_buffer_offset,
265	.log_buffer_status = avs_apl_log_buffer_status,
266	.coredump = avs_apl_coredump,
267	.d0ix_toggle = avs_apl_d0ix_toggle,
268	.set_d0ix = avs_apl_set_d0ix,
269	AVS_SET_ENABLE_LOGS_OP(apl)
270};