[mirror_ubuntu-hirsute-kernel.git] / sound / soc / sof / ops.h

/* SPDX-License-Identifier: (GPL-2.0-only 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) 2018 Intel Corporation. All rights reserved.
 *
 * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
 */

#ifndef __SOUND_SOC_SOF_IO_H
#define __SOUND_SOC_SOF_IO_H

#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <sound/pcm.h>
#include "sof-priv.h"

#define sof_ops(sdev) \
	((sdev)->pdata->desc->ops)

/* Mandatory operations are verified during probing */

/* init */
static inline int snd_sof_probe(struct snd_sof_dev *sdev)
{
	return sof_ops(sdev)->probe(sdev);
}

static inline int snd_sof_remove(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->remove)
		return sof_ops(sdev)->remove(sdev);

	return 0;
}

/* control */

/*
 * snd_sof_dsp_run returns the core mask of the cores that are available
 * after successful fw boot
 */
static inline int snd_sof_dsp_run(struct snd_sof_dev *sdev)
{
	return sof_ops(sdev)->run(sdev);
}

static inline int snd_sof_dsp_stall(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->stall)
		return sof_ops(sdev)->stall(sdev);

	return 0;
}

static inline int snd_sof_dsp_reset(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->reset)
		return sof_ops(sdev)->reset(sdev);

	return 0;
}

/* dsp core power up/power down */
static inline int snd_sof_dsp_core_power_up(struct snd_sof_dev *sdev,
					    unsigned int core_mask)
{
	if (sof_ops(sdev)->core_power_up)
		return sof_ops(sdev)->core_power_up(sdev, core_mask);

	return 0;
}

static inline int snd_sof_dsp_core_power_down(struct snd_sof_dev *sdev,
					      unsigned int core_mask)
{
	if (sof_ops(sdev)->core_power_down)
		return sof_ops(sdev)->core_power_down(sdev, core_mask);

	return 0;
}

/* pre/post fw load */
static inline int snd_sof_dsp_pre_fw_run(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->pre_fw_run)
		return sof_ops(sdev)->pre_fw_run(sdev);

	return 0;
}

static inline int snd_sof_dsp_post_fw_run(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->post_fw_run)
		return sof_ops(sdev)->post_fw_run(sdev);

	return 0;
}

/* misc */

/**
 * snd_sof_dsp_get_bar_index - Maps a section type with a BAR index
 *
 * @sdev: sof device
 * @type: section type as described by snd_sof_fw_blk_type
 *
 * Returns the corresponding BAR index (a positive integer) or -EINVAL
 * in case there is no mapping
 */
static inline int snd_sof_dsp_get_bar_index(struct snd_sof_dev *sdev, u32 type)
{
	if (sof_ops(sdev)->get_bar_index)
		return sof_ops(sdev)->get_bar_index(sdev, type);

	return sdev->mmio_bar;
}

static inline int snd_sof_dsp_get_mailbox_offset(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->get_mailbox_offset)
		return sof_ops(sdev)->get_mailbox_offset(sdev);

	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	return -ENOTSUPP;
}

static inline int snd_sof_dsp_get_window_offset(struct snd_sof_dev *sdev,
						u32 id)
{
	if (sof_ops(sdev)->get_window_offset)
		return sof_ops(sdev)->get_window_offset(sdev, id);

	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	return -ENOTSUPP;
}
/* power management */
static inline int snd_sof_dsp_resume(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->resume)
		return sof_ops(sdev)->resume(sdev);

	return 0;
}

static inline int snd_sof_dsp_suspend(struct snd_sof_dev *sdev,
				      u32 target_state)
{
	if (sof_ops(sdev)->suspend)
		return sof_ops(sdev)->suspend(sdev, target_state);

	return 0;
}

static inline int snd_sof_dsp_runtime_resume(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->runtime_resume)
		return sof_ops(sdev)->runtime_resume(sdev);

	return 0;
}

static inline int snd_sof_dsp_runtime_suspend(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->runtime_suspend)
		return sof_ops(sdev)->runtime_suspend(sdev);

	return 0;
}

static inline int snd_sof_dsp_runtime_idle(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->runtime_idle)
		return sof_ops(sdev)->runtime_idle(sdev);

	return 0;
}

static inline int snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->set_hw_params_upon_resume)
		return sof_ops(sdev)->set_hw_params_upon_resume(sdev);
	return 0;
}

static inline int snd_sof_dsp_set_clk(struct snd_sof_dev *sdev, u32 freq)
{
	if (sof_ops(sdev)->set_clk)
		return sof_ops(sdev)->set_clk(sdev, freq);

	return 0;
}

static inline int
snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev,
			    const struct sof_dsp_power_state *target_state)
{
	if (sof_ops(sdev)->set_power_state)
		return sof_ops(sdev)->set_power_state(sdev, target_state);

	/* D0 substate is not supported, do nothing here. */
	return 0;
}

/* debug */
static inline void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, u32 flags)
{
	if (sof_ops(sdev)->dbg_dump)
		return sof_ops(sdev)->dbg_dump(sdev, flags);
}

static inline void snd_sof_ipc_dump(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->ipc_dump)
		return sof_ops(sdev)->ipc_dump(sdev);
}

/* register IO */
static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar,
				     u32 offset, u32 value)
{
	if (sof_ops(sdev)->write) {
		sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value);
		return;
	}

	dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
}

static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar,
				       u32 offset, u64 value)
{
	if (sof_ops(sdev)->write64) {
		sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value);
		return;
	}

	dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
}

static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar,
				   u32 offset)
{
	if (sof_ops(sdev)->read)
		return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset);

	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	return -ENOTSUPP;
}

static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar,
				     u32 offset)
{
	if (sof_ops(sdev)->read64)
		return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset);

	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	return -ENOTSUPP;
}

/* block IO */
static inline void snd_sof_dsp_block_read(struct snd_sof_dev *sdev, u32 bar,
					  u32 offset, void *dest, size_t bytes)
{
	sof_ops(sdev)->block_read(sdev, bar, offset, dest, bytes);
}

static inline void snd_sof_dsp_block_write(struct snd_sof_dev *sdev, u32 bar,
					   u32 offset, void *src, size_t bytes)
{
	sof_ops(sdev)->block_write(sdev, bar, offset, src, bytes);
}

/* ipc */
static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev,
				       struct snd_sof_ipc_msg *msg)
{
	return sof_ops(sdev)->send_msg(sdev, msg);
}

/* host DMA trace */
static inline int snd_sof_dma_trace_init(struct snd_sof_dev *sdev,
					 u32 *stream_tag)
{
	if (sof_ops(sdev)->trace_init)
		return sof_ops(sdev)->trace_init(sdev, stream_tag);

	return 0;
}

static inline int snd_sof_dma_trace_release(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev)->trace_release)
		return sof_ops(sdev)->trace_release(sdev);

	return 0;
}

static inline int snd_sof_dma_trace_trigger(struct snd_sof_dev *sdev, int cmd)
{
	if (sof_ops(sdev)->trace_trigger)
		return sof_ops(sdev)->trace_trigger(sdev, cmd);

	return 0;
}

/* host PCM ops */
static inline int
snd_sof_pcm_platform_open(struct snd_sof_dev *sdev,
			  struct snd_pcm_substream *substream)
{
	if (sof_ops(sdev) && sof_ops(sdev)->pcm_open)
		return sof_ops(sdev)->pcm_open(sdev, substream);

	return 0;
}

/* disconnect pcm substream to a host stream */
static inline int
snd_sof_pcm_platform_close(struct snd_sof_dev *sdev,
			   struct snd_pcm_substream *substream)
{
	if (sof_ops(sdev) && sof_ops(sdev)->pcm_close)
		return sof_ops(sdev)->pcm_close(sdev, substream);

	return 0;
}

/* host stream hw params */
static inline int
snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev,
			       struct snd_pcm_substream *substream,
			       struct snd_pcm_hw_params *params,
			       struct sof_ipc_stream_params *ipc_params)
{
	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params)
		return sof_ops(sdev)->pcm_hw_params(sdev, substream,
						    params, ipc_params);

	return 0;
}

/* host stream hw free */
static inline int
snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev,
			     struct snd_pcm_substream *substream)
{
	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free)
		return sof_ops(sdev)->pcm_hw_free(sdev, substream);

	return 0;
}

/* host stream trigger */
static inline int
snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev,
			     struct snd_pcm_substream *substream, int cmd)
{
	if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger)
		return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd);

	return 0;
}

/* host DSP message data */
static inline void snd_sof_ipc_msg_data(struct snd_sof_dev *sdev,
					struct snd_pcm_substream *substream,
					void *p, size_t sz)
{
	sof_ops(sdev)->ipc_msg_data(sdev, substream, p, sz);
}

/* host configure DSP HW parameters */
static inline int
snd_sof_ipc_pcm_params(struct snd_sof_dev *sdev,
		       struct snd_pcm_substream *substream,
		       const struct sof_ipc_pcm_params_reply *reply)
{
	return sof_ops(sdev)->ipc_pcm_params(sdev, substream, reply);
}

/* host stream pointer */
static inline snd_pcm_uframes_t
snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev,
			     struct snd_pcm_substream *substream)
{
	if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer)
		return sof_ops(sdev)->pcm_pointer(sdev, substream);

	return 0;
}

#if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_PROBES)
static inline int
snd_sof_probe_compr_assign(struct snd_sof_dev *sdev,
		struct snd_compr_stream *cstream, struct snd_soc_dai *dai)
{
	return sof_ops(sdev)->probe_assign(sdev, cstream, dai);
}

static inline int
snd_sof_probe_compr_free(struct snd_sof_dev *sdev,
		struct snd_compr_stream *cstream, struct snd_soc_dai *dai)
{
	return sof_ops(sdev)->probe_free(sdev, cstream, dai);
}

static inline int
snd_sof_probe_compr_set_params(struct snd_sof_dev *sdev,
		struct snd_compr_stream *cstream,
		struct snd_compr_params *params, struct snd_soc_dai *dai)
{
	return sof_ops(sdev)->probe_set_params(sdev, cstream, params, dai);
}

static inline int
snd_sof_probe_compr_trigger(struct snd_sof_dev *sdev,
		struct snd_compr_stream *cstream, int cmd,
		struct snd_soc_dai *dai)
{
	return sof_ops(sdev)->probe_trigger(sdev, cstream, cmd, dai);
}

static inline int
snd_sof_probe_compr_pointer(struct snd_sof_dev *sdev,
		struct snd_compr_stream *cstream,
		struct snd_compr_tstamp *tstamp, struct snd_soc_dai *dai)
{
	if (sof_ops(sdev) && sof_ops(sdev)->probe_pointer)
		return sof_ops(sdev)->probe_pointer(sdev, cstream, tstamp, dai);

	return 0;
}
#endif

/* machine driver */
static inline int
snd_sof_machine_register(struct snd_sof_dev *sdev, void *pdata)
{
	if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
		return sof_ops(sdev)->machine_register(sdev, pdata);

	return 0;
}

static inline void
snd_sof_machine_unregister(struct snd_sof_dev *sdev, void *pdata)
{
	if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
		sof_ops(sdev)->machine_unregister(sdev, pdata);
}

static inline void
snd_sof_machine_select(struct snd_sof_dev *sdev)
{
	if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
		sof_ops(sdev)->machine_select(sdev);
}

static inline void
snd_sof_set_mach_params(const struct snd_soc_acpi_mach *mach,
			struct device *dev)
{
	struct snd_sof_dev *sdev = dev_get_drvdata(dev);

	if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
		sof_ops(sdev)->set_mach_params(mach, dev);
}

static inline const struct snd_sof_dsp_ops
*sof_get_ops(const struct sof_dev_desc *d,
	     const struct sof_ops_table mach_ops[], int asize)
{
	int i;

	for (i = 0; i < asize; i++) {
		if (d == mach_ops[i].desc)
			return mach_ops[i].ops;
	}

	/* not found */
	return NULL;
}

/**
 * snd_sof_dsp_register_poll_timeout - Periodically poll an address
 * until a condition is met or a timeout occurs
 * @op: accessor function (takes @addr as its only argument)
 * @addr: Address to poll
 * @val: Variable to read the value into
 * @cond: Break condition (usually involving @val)
 * @sleep_us: Maximum time to sleep between reads in us (0
 *            tight-loops).  Should be less than ~20ms since usleep_range
 *            is used (see Documentation/timers/timers-howto.rst).
 * @timeout_us: Timeout in us, 0 means never timeout
 *
 * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
 * case, the last read value at @addr is stored in @val. Must not
 * be called from atomic context if sleep_us or timeout_us are used.
 *
 * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
 */
#define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
({ \
	u64 __timeout_us = (timeout_us); \
	unsigned long __sleep_us = (sleep_us); \
	ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
	might_sleep_if((__sleep_us) != 0); \
	for (;;) {							\
		(val) = snd_sof_dsp_read(sdev, bar, offset);		\
		if (cond) { \
			dev_dbg(sdev->dev, \
				"FW Poll Status: reg=%#x successful\n", (val)); \
			break; \
		} \
		if (__timeout_us && \
		    ktime_compare(ktime_get(), __timeout) > 0) { \
			(val) = snd_sof_dsp_read(sdev, bar, offset); \
			dev_dbg(sdev->dev, \
				"FW Poll Status: reg=%#x timedout\n", (val)); \
			break; \
		} \
		if (__sleep_us) \
			usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
	} \
	(cond) ? 0 : -ETIMEDOUT; \
})

/* This is for registers bits with attribute RWC */
bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
			     u32 mask, u32 value);

bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
				      u32 offset, u32 mask, u32 value);

bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
					u32 offset, u64 mask, u64 value);

bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
			     u32 mask, u32 value);

bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
			       u32 offset, u64 mask, u64 value);

void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
				    u32 offset, u32 mask, u32 value);

int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
			      u32 mask, u32 target, u32 timeout_ms,
			      u32 interval_us);

void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset);
#endif
Commit	Line	Data
e149ca29	1	/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */
d1d95fcb LG	2	/*
	3	* This file is provided under a dual BSD/GPLv2 license. When using or
	4	* redistributing this file, you may do so under either license.
	5	*
	6	* Copyright(c) 2018 Intel Corporation. All rights reserved.
	7	*
	8	* Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
	9	*/
	10
	11	#ifndef __SOUND_SOC_SOF_IO_H
	12	#define __SOUND_SOC_SOF_IO_H
	13
	14	#include <linux/device.h>
	15	#include <linux/interrupt.h>
	16	#include <linux/kernel.h>
	17	#include <linux/types.h>
	18	#include <sound/pcm.h>
	19	#include "sof-priv.h"
	20
	21	#define sof_ops(sdev) \
	22	((sdev)->pdata->desc->ops)
	23
	24	/* Mandatory operations are verified during probing */
	25
	26	/* init */
	27	static inline int snd_sof_probe(struct snd_sof_dev *sdev)
	28	{
	29	return sof_ops(sdev)->probe(sdev);
	30	}
	31
	32	static inline int snd_sof_remove(struct snd_sof_dev *sdev)
	33	{
	34	if (sof_ops(sdev)->remove)
	35	return sof_ops(sdev)->remove(sdev);
	36
	37	return 0;
	38	}
	39
	40	/* control */
	41
	42	/*
	43	* snd_sof_dsp_run returns the core mask of the cores that are available
	44	* after successful fw boot
	45	*/
	46	static inline int snd_sof_dsp_run(struct snd_sof_dev *sdev)
	47	{
	48	return sof_ops(sdev)->run(sdev);
	49	}
	50
	51	static inline int snd_sof_dsp_stall(struct snd_sof_dev *sdev)
	52	{
	53	if (sof_ops(sdev)->stall)
	54	return sof_ops(sdev)->stall(sdev);
	55
	56	return 0;
	57	}
	58
	59	static inline int snd_sof_dsp_reset(struct snd_sof_dev *sdev)
	60	{
	61	if (sof_ops(sdev)->reset)
	62	return sof_ops(sdev)->reset(sdev);
	63
	64	return 0;
	65	}
66
67	/* dsp core power up/power down */
68	static inline int snd_sof_dsp_core_power_up(struct snd_sof_dev *sdev,
69	unsigned int core_mask)
70	{
71	if (sof_ops(sdev)->core_power_up)
72	return sof_ops(sdev)->core_power_up(sdev, core_mask);
73
74	return 0;
75	}
76
77	static inline int snd_sof_dsp_core_power_down(struct snd_sof_dev *sdev,
78	unsigned int core_mask)
79	{
80	if (sof_ops(sdev)->core_power_down)
81	return sof_ops(sdev)->core_power_down(sdev, core_mask);
82
83	return 0;
84	}
85
86	/* pre/post fw load */
87	static inline int snd_sof_dsp_pre_fw_run(struct snd_sof_dev *sdev)
88	{
89	if (sof_ops(sdev)->pre_fw_run)
90	return sof_ops(sdev)->pre_fw_run(sdev);
91
92	return 0;
93	}
94
95	static inline int snd_sof_dsp_post_fw_run(struct snd_sof_dev *sdev)
96	{
97	if (sof_ops(sdev)->post_fw_run)
98	return sof_ops(sdev)->post_fw_run(sdev);
99
100	return 0;
101	}
102
ce8234a6 DB	103	/* misc */
	104
	105	/**
	106	* snd_sof_dsp_get_bar_index - Maps a section type with a BAR index
	107	*
	108	* @sdev: sof device
	109	* @type: section type as described by snd_sof_fw_blk_type
	110	*
	111	* Returns the corresponding BAR index (a positive integer) or -EINVAL
	112	* in case there is no mapping
	113	*/
	114	static inline int snd_sof_dsp_get_bar_index(struct snd_sof_dev *sdev, u32 type)
	115	{
	116	if (sof_ops(sdev)->get_bar_index)
	117	return sof_ops(sdev)->get_bar_index(sdev, type);
	118
	119	return sdev->mmio_bar;
	120	}
	121
bb9c93f5 DB	122	static inline int snd_sof_dsp_get_mailbox_offset(struct snd_sof_dev *sdev)
	123	{
	124	if (sof_ops(sdev)->get_mailbox_offset)
	125	return sof_ops(sdev)->get_mailbox_offset(sdev);
	126
	127	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	128	return -ENOTSUPP;
	129	}
	130
e17422cd DB	131	static inline int snd_sof_dsp_get_window_offset(struct snd_sof_dev *sdev,
	132	u32 id)
	133	{
	134	if (sof_ops(sdev)->get_window_offset)
	135	return sof_ops(sdev)->get_window_offset(sdev, id);
	136
	137	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	138	return -ENOTSUPP;
	139	}
d1d95fcb LG	140	/* power management */
	141	static inline int snd_sof_dsp_resume(struct snd_sof_dev *sdev)
	142	{
	143	if (sof_ops(sdev)->resume)
	144	return sof_ops(sdev)->resume(sdev);
	145
	146	return 0;
	147	}
	148
61e285ca RS	149	static inline int snd_sof_dsp_suspend(struct snd_sof_dev *sdev,
61e285ca RS	150	u32 target_state)
d1d95fcb LG	151	{
d1d95fcb LG	152	if (sof_ops(sdev)->suspend)
61e285ca	153	return sof_ops(sdev)->suspend(sdev, target_state);
d1d95fcb LG	154
	155	return 0;
	156	}
	157
	158	static inline int snd_sof_dsp_runtime_resume(struct snd_sof_dev *sdev)
	159	{
	160	if (sof_ops(sdev)->runtime_resume)
	161	return sof_ops(sdev)->runtime_resume(sdev);
	162
	163	return 0;
	164	}
	165
1c38c922	166	static inline int snd_sof_dsp_runtime_suspend(struct snd_sof_dev *sdev)
d1d95fcb LG	167	{
d1d95fcb LG	168	if (sof_ops(sdev)->runtime_suspend)
1c38c922	169	return sof_ops(sdev)->runtime_suspend(sdev);
d1d95fcb LG	170
	171	return 0;
	172	}
	173
62fde977 KV	174	static inline int snd_sof_dsp_runtime_idle(struct snd_sof_dev *sdev)
	175	{
	176	if (sof_ops(sdev)->runtime_idle)
	177	return sof_ops(sdev)->runtime_idle(sdev);
	178
	179	return 0;
	180	}
	181
7077a07a	182	static inline int snd_sof_dsp_hw_params_upon_resume(struct snd_sof_dev *sdev)
ed3baacd RS	183	{
ed3baacd RS	184	if (sof_ops(sdev)->set_hw_params_upon_resume)
7077a07a RS	185	return sof_ops(sdev)->set_hw_params_upon_resume(sdev);
7077a07a RS	186	return 0;
ed3baacd RS	187	}
ed3baacd RS	188
d1d95fcb LG	189	static inline int snd_sof_dsp_set_clk(struct snd_sof_dev *sdev, u32 freq)
	190	{
	191	if (sof_ops(sdev)->set_clk)
	192	return sof_ops(sdev)->set_clk(sdev, freq);
	193
	194	return 0;
	195	}
	196
61e285ca RS	197	static inline int
	198	snd_sof_dsp_set_power_state(struct snd_sof_dev *sdev,
	199	const struct sof_dsp_power_state *target_state)
e8f112d8 KJ	200	{
e8f112d8 KJ	201	if (sof_ops(sdev)->set_power_state)
61e285ca	202	return sof_ops(sdev)->set_power_state(sdev, target_state);
e8f112d8	203
61e285ca RS	204	/* D0 substate is not supported, do nothing here. */
61e285ca RS	205	return 0;
e8f112d8 KJ	206	}
e8f112d8 KJ	207
d1d95fcb LG	208	/* debug */
	209	static inline void snd_sof_dsp_dbg_dump(struct snd_sof_dev *sdev, u32 flags)
	210	{
	211	if (sof_ops(sdev)->dbg_dump)
	212	return sof_ops(sdev)->dbg_dump(sdev, flags);
	213	}
	214
5e4a27fd PX	215	static inline void snd_sof_ipc_dump(struct snd_sof_dev *sdev)
	216	{
	217	if (sof_ops(sdev)->ipc_dump)
	218	return sof_ops(sdev)->ipc_dump(sdev);
	219	}
	220
d1d95fcb LG	221	/* register IO */
	222	static inline void snd_sof_dsp_write(struct snd_sof_dev *sdev, u32 bar,
	223	u32 offset, u32 value)
	224	{
	225	if (sof_ops(sdev)->write) {
	226	sof_ops(sdev)->write(sdev, sdev->bar[bar] + offset, value);
	227	return;
	228	}
	229
	230	dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
	231	}
	232
	233	static inline void snd_sof_dsp_write64(struct snd_sof_dev *sdev, u32 bar,
	234	u32 offset, u64 value)
	235	{
	236	if (sof_ops(sdev)->write64) {
	237	sof_ops(sdev)->write64(sdev, sdev->bar[bar] + offset, value);
	238	return;
	239	}
	240
	241	dev_err_ratelimited(sdev->dev, "error: %s not defined\n", __func__);
	242	}
	243
	244	static inline u32 snd_sof_dsp_read(struct snd_sof_dev *sdev, u32 bar,
	245	u32 offset)
	246	{
	247	if (sof_ops(sdev)->read)
	248	return sof_ops(sdev)->read(sdev, sdev->bar[bar] + offset);
	249
	250	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	251	return -ENOTSUPP;
	252	}
	253
	254	static inline u64 snd_sof_dsp_read64(struct snd_sof_dev *sdev, u32 bar,
	255	u32 offset)
	256	{
	257	if (sof_ops(sdev)->read64)
	258	return sof_ops(sdev)->read64(sdev, sdev->bar[bar] + offset);
	259
	260	dev_err(sdev->dev, "error: %s not defined\n", __func__);
	261	return -ENOTSUPP;
	262	}
	263
	264	/* block IO */
	265	static inline void snd_sof_dsp_block_read(struct snd_sof_dev *sdev, u32 bar,
	266	u32 offset, void *dest, size_t bytes)
	267	{
	268	sof_ops(sdev)->block_read(sdev, bar, offset, dest, bytes);
	269	}
	270
	271	static inline void snd_sof_dsp_block_write(struct snd_sof_dev *sdev, u32 bar,
	272	u32 offset, void *src, size_t bytes)
	273	{
	274	sof_ops(sdev)->block_write(sdev, bar, offset, src, bytes);
	275	}
	276
	277	/* ipc */
	278	static inline int snd_sof_dsp_send_msg(struct snd_sof_dev *sdev,
	279	struct snd_sof_ipc_msg *msg)
	280	{
	281	return sof_ops(sdev)->send_msg(sdev, msg);
	282	}
	283
	284	/* host DMA trace */
285	static inline int snd_sof_dma_trace_init(struct snd_sof_dev *sdev,
286	u32 *stream_tag)
287	{
288	if (sof_ops(sdev)->trace_init)
289	return sof_ops(sdev)->trace_init(sdev, stream_tag);
290
291	return 0;
292	}
293
294	static inline int snd_sof_dma_trace_release(struct snd_sof_dev *sdev)
295	{
296	if (sof_ops(sdev)->trace_release)
297	return sof_ops(sdev)->trace_release(sdev);
298
299	return 0;
300	}
301
302	static inline int snd_sof_dma_trace_trigger(struct snd_sof_dev *sdev, int cmd)
303	{
304	if (sof_ops(sdev)->trace_trigger)
305	return sof_ops(sdev)->trace_trigger(sdev, cmd);
306
307	return 0;
308	}
309
310	/* host PCM ops */
311	static inline int
312	snd_sof_pcm_platform_open(struct snd_sof_dev *sdev,
313	struct snd_pcm_substream *substream)
314	{
315	if (sof_ops(sdev) && sof_ops(sdev)->pcm_open)
316	return sof_ops(sdev)->pcm_open(sdev, substream);
317
318	return 0;
319	}
320
321	/* disconnect pcm substream to a host stream */
322	static inline int
323	snd_sof_pcm_platform_close(struct snd_sof_dev *sdev,
324	struct snd_pcm_substream *substream)
325	{
326	if (sof_ops(sdev) && sof_ops(sdev)->pcm_close)
327	return sof_ops(sdev)->pcm_close(sdev, substream);
328
329	return 0;
330	}
331
332	/* host stream hw params */
333	static inline int
334	snd_sof_pcm_platform_hw_params(struct snd_sof_dev *sdev,
335	struct snd_pcm_substream *substream,
336	struct snd_pcm_hw_params *params,
337	struct sof_ipc_stream_params *ipc_params)
338	{
339	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_params)
340	return sof_ops(sdev)->pcm_hw_params(sdev, substream,
341	params, ipc_params);
342
343	return 0;
344	}
345
93146bc2 RS	346	/* host stream hw free */
	347	static inline int
	348	snd_sof_pcm_platform_hw_free(struct snd_sof_dev *sdev,
	349	struct snd_pcm_substream *substream)
	350	{
	351	if (sof_ops(sdev) && sof_ops(sdev)->pcm_hw_free)
	352	return sof_ops(sdev)->pcm_hw_free(sdev, substream);
	353
	354	return 0;
	355	}
	356
d1d95fcb LG	357	/* host stream trigger */
	358	static inline int
	359	snd_sof_pcm_platform_trigger(struct snd_sof_dev *sdev,
	360	struct snd_pcm_substream *substream, int cmd)
	361	{
	362	if (sof_ops(sdev) && sof_ops(sdev)->pcm_trigger)
	363	return sof_ops(sdev)->pcm_trigger(sdev, substream, cmd);
	364
	365	return 0;
	366	}
	367
	368	/* host DSP message data */
	369	static inline void snd_sof_ipc_msg_data(struct snd_sof_dev *sdev,
	370	struct snd_pcm_substream *substream,
	371	void *p, size_t sz)
	372	{
	373	sof_ops(sdev)->ipc_msg_data(sdev, substream, p, sz);
	374	}
	375
	376	/* host configure DSP HW parameters */
	377	static inline int
	378	snd_sof_ipc_pcm_params(struct snd_sof_dev *sdev,
	379	struct snd_pcm_substream *substream,
	380	const struct sof_ipc_pcm_params_reply *reply)
	381	{
	382	return sof_ops(sdev)->ipc_pcm_params(sdev, substream, reply);
	383	}
	384
	385	/* host stream pointer */
	386	static inline snd_pcm_uframes_t
	387	snd_sof_pcm_platform_pointer(struct snd_sof_dev *sdev,
	388	struct snd_pcm_substream *substream)
	389	{
	390	if (sof_ops(sdev) && sof_ops(sdev)->pcm_pointer)
	391	return sof_ops(sdev)->pcm_pointer(sdev, substream);
	392
	393	return 0;
	394	}
	395
e145e9af CR	396	#if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_PROBES)
	397	static inline int
	398	snd_sof_probe_compr_assign(struct snd_sof_dev *sdev,
	399	struct snd_compr_stream cstream, struct snd_soc_dai dai)
	400	{
	401	return sof_ops(sdev)->probe_assign(sdev, cstream, dai);
	402	}
	403
	404	static inline int
	405	snd_sof_probe_compr_free(struct snd_sof_dev *sdev,
	406	struct snd_compr_stream cstream, struct snd_soc_dai dai)
	407	{
	408	return sof_ops(sdev)->probe_free(sdev, cstream, dai);
	409	}
	410
	411	static inline int
	412	snd_sof_probe_compr_set_params(struct snd_sof_dev *sdev,
	413	struct snd_compr_stream *cstream,
	414	struct snd_compr_params params, struct snd_soc_dai dai)
	415	{
	416	return sof_ops(sdev)->probe_set_params(sdev, cstream, params, dai);
	417	}
	418
	419	static inline int
	420	snd_sof_probe_compr_trigger(struct snd_sof_dev *sdev,
	421	struct snd_compr_stream *cstream, int cmd,
	422	struct snd_soc_dai *dai)
	423	{
	424	return sof_ops(sdev)->probe_trigger(sdev, cstream, cmd, dai);
	425	}
	426
	427	static inline int
	428	snd_sof_probe_compr_pointer(struct snd_sof_dev *sdev,
	429	struct snd_compr_stream *cstream,
	430	struct snd_compr_tstamp tstamp, struct snd_soc_dai dai)
	431	{
	432	if (sof_ops(sdev) && sof_ops(sdev)->probe_pointer)
	433	return sof_ops(sdev)->probe_pointer(sdev, cstream, tstamp, dai);
	434
	435	return 0;
	436	}
	437	#endif
	438
285880a2 DB	439	/* machine driver */
	440	static inline int
	441	snd_sof_machine_register(struct snd_sof_dev sdev, void pdata)
	442	{
	443	if (sof_ops(sdev) && sof_ops(sdev)->machine_register)
	444	return sof_ops(sdev)->machine_register(sdev, pdata);
	445
	446	return 0;
	447	}
	448
	449	static inline void
	450	snd_sof_machine_unregister(struct snd_sof_dev sdev, void pdata)
	451	{
	452	if (sof_ops(sdev) && sof_ops(sdev)->machine_unregister)
	453	sof_ops(sdev)->machine_unregister(sdev, pdata);
	454	}
	455
	456	static inline void
	457	snd_sof_machine_select(struct snd_sof_dev *sdev)
	458	{
	459	if (sof_ops(sdev) && sof_ops(sdev)->machine_select)
	460	sof_ops(sdev)->machine_select(sdev);
	461	}
	462
	463	static inline void
	464	snd_sof_set_mach_params(const struct snd_soc_acpi_mach *mach,
	465	struct device *dev)
	466	{
	467	struct snd_sof_dev *sdev = dev_get_drvdata(dev);
	468
	469	if (sof_ops(sdev) && sof_ops(sdev)->set_mach_params)
	470	sof_ops(sdev)->set_mach_params(mach, dev);
	471	}
	472
d1d95fcb LG	473	static inline const struct snd_sof_dsp_ops
	474	sof_get_ops(const struct sof_dev_desc d,
	475	const struct sof_ops_table mach_ops[], int asize)
	476	{
	477	int i;
	478
	479	for (i = 0; i < asize; i++) {
	480	if (d == mach_ops[i].desc)
	481	return mach_ops[i].ops;
	482	}
	483
	484	/* not found */
	485	return NULL;
	486	}
	487
	488	/**
	489	* snd_sof_dsp_register_poll_timeout - Periodically poll an address
	490	* until a condition is met or a timeout occurs
	491	* @op: accessor function (takes @addr as its only argument)
	492	* @addr: Address to poll
	493	* @val: Variable to read the value into
	494	* @cond: Break condition (usually involving @val)
	495	* @sleep_us: Maximum time to sleep between reads in us (0
	496	* tight-loops). Should be less than ~20ms since usleep_range
458f69ef	497	* is used (see Documentation/timers/timers-howto.rst).
d1d95fcb LG	498	* @timeout_us: Timeout in us, 0 means never timeout
	499	*
	500	* Returns 0 on success and -ETIMEDOUT upon a timeout. In either
	501	* case, the last read value at @addr is stored in @val. Must not
	502	* be called from atomic context if sleep_us or timeout_us are used.
	503	*
	504	* This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
	505	*/
	506	#define snd_sof_dsp_read_poll_timeout(sdev, bar, offset, val, cond, sleep_us, timeout_us) \
	507	({ \
	508	u64 __timeout_us = (timeout_us); \
	509	unsigned long __sleep_us = (sleep_us); \
	510	ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
	511	might_sleep_if((__sleep_us) != 0); \
	512	for (;;) { \
	513	(val) = snd_sof_dsp_read(sdev, bar, offset); \
	514	if (cond) { \
	515	dev_dbg(sdev->dev, \
	516	"FW Poll Status: reg=%#x successful\n", (val)); \
	517	break; \
	518	} \
	519	if (__timeout_us && \
	520	ktime_compare(ktime_get(), __timeout) > 0) { \
	521	(val) = snd_sof_dsp_read(sdev, bar, offset); \
	522	dev_dbg(sdev->dev, \
	523	"FW Poll Status: reg=%#x timedout\n", (val)); \
	524	break; \
	525	} \
	526	if (__sleep_us) \
	527	usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
	528	} \
	529	(cond) ? 0 : -ETIMEDOUT; \
	530	})
	531
	532	/* This is for registers bits with attribute RWC */
	533	bool snd_sof_pci_update_bits(struct snd_sof_dev *sdev, u32 offset,
	534	u32 mask, u32 value);
	535
	536	bool snd_sof_dsp_update_bits_unlocked(struct snd_sof_dev *sdev, u32 bar,
	537	u32 offset, u32 mask, u32 value);
	538
	539	bool snd_sof_dsp_update_bits64_unlocked(struct snd_sof_dev *sdev, u32 bar,
	540	u32 offset, u64 mask, u64 value);
	541
	542	bool snd_sof_dsp_update_bits(struct snd_sof_dev *sdev, u32 bar, u32 offset,
	543	u32 mask, u32 value);
	544
	545	bool snd_sof_dsp_update_bits64(struct snd_sof_dev *sdev, u32 bar,
	546	u32 offset, u64 mask, u64 value);
	547
	548	void snd_sof_dsp_update_bits_forced(struct snd_sof_dev *sdev, u32 bar,
	549	u32 offset, u32 mask, u32 value);
	550
	551	int snd_sof_dsp_register_poll(struct snd_sof_dev *sdev, u32 bar, u32 offset,
	552	u32 mask, u32 target, u32 timeout_ms,
	553	u32 interval_us);
	554
	555	void snd_sof_dsp_panic(struct snd_sof_dev *sdev, u32 offset);
	556	#endif