1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
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// Generic IPC layer that can work over MMIO and SPI/I2C. PHY layer provided
11// by platform driver code.
12//
13
14#include <linux/mutex.h>
15#include <linux/types.h>
16
17#include "sof-priv.h"
18#include "sof-audio.h"
19#include "ops.h"
20
21/**
22 * sof_ipc_send_msg - generic function to prepare and send one IPC message
23 * @sdev:		pointer to SOF core device struct
24 * @msg_data:		pointer to a message to send
25 * @msg_bytes:		number of bytes in the message
26 * @reply_bytes:	number of bytes available for the reply.
27 *			The buffer for the reply data is not passed to this
28 *			function, the available size is an information for the
29 *			reply handling functions.
30 *
31 * On success the function returns 0, otherwise negative error number.
32 *
33 * Note: higher level sdev->ipc->tx_mutex must be held to make sure that
34 *	 transfers are synchronized.
35 */
36int sof_ipc_send_msg(struct snd_sof_dev *sdev, void *msg_data, size_t msg_bytes,
37		     size_t reply_bytes)
38{
39	struct snd_sof_ipc *ipc = sdev->ipc;
40	struct snd_sof_ipc_msg *msg;
41	int ret;
42
43	if (ipc->disable_ipc_tx || sdev->fw_state != SOF_FW_BOOT_COMPLETE)
44		return -ENODEV;
45
46	/*
47	 * The spin-lock is needed to protect message objects against other
48	 * atomic contexts.
49	 */
50	spin_lock_irq(&sdev->ipc_lock);
51
52	/* initialise the message */
53	msg = &ipc->msg;
54
55	/* attach message data */
56	msg->msg_data = msg_data;
57	msg->msg_size = msg_bytes;
58
59	msg->reply_size = reply_bytes;
60	msg->reply_error = 0;
61
62	sdev->msg = msg;
63
64	ret = snd_sof_dsp_send_msg(sdev, msg);
65	/* Next reply that we receive will be related to this message */
66	if (!ret)
67		msg->ipc_complete = false;
68
69	spin_unlock_irq(&sdev->ipc_lock);
70
71	return ret;
72}
73
74/* send IPC message from host to DSP */
75int sof_ipc_tx_message(struct snd_sof_ipc *ipc, void *msg_data, size_t msg_bytes,
76		       void *reply_data, size_t reply_bytes)
77{
78	if (msg_bytes > ipc->max_payload_size ||
79	    reply_bytes > ipc->max_payload_size)
80		return -ENOBUFS;
81
82	return ipc->ops->tx_msg(ipc->sdev, msg_data, msg_bytes, reply_data,
83				reply_bytes, false);
84}
85EXPORT_SYMBOL(sof_ipc_tx_message);
86
87/* IPC set or get data from host to DSP */
88int sof_ipc_set_get_data(struct snd_sof_ipc *ipc, void *msg_data,
89			 size_t msg_bytes, bool set)
90{
91	return ipc->ops->set_get_data(ipc->sdev, msg_data, msg_bytes, set);
92}
93EXPORT_SYMBOL(sof_ipc_set_get_data);
94
95/*
96 * send IPC message from host to DSP without modifying the DSP state.
97 * This will be used for IPC's that can be handled by the DSP
98 * even in a low-power D0 substate.
99 */
100int sof_ipc_tx_message_no_pm(struct snd_sof_ipc *ipc, void *msg_data, size_t msg_bytes,
101			     void *reply_data, size_t reply_bytes)
102{
103	if (msg_bytes > ipc->max_payload_size ||
104	    reply_bytes > ipc->max_payload_size)
105		return -ENOBUFS;
106
107	return ipc->ops->tx_msg(ipc->sdev, msg_data, msg_bytes, reply_data,
108				reply_bytes, true);
109}
110EXPORT_SYMBOL(sof_ipc_tx_message_no_pm);
111
112/* Generic helper function to retrieve the reply */
113void snd_sof_ipc_get_reply(struct snd_sof_dev *sdev)
114{
115	/*
116	 * Sometimes, there is unexpected reply ipc arriving. The reply
117	 * ipc belongs to none of the ipcs sent from driver.
118	 * In this case, the driver must ignore the ipc.
119	 */
120	if (!sdev->msg) {
121		dev_warn(sdev->dev, "unexpected ipc interrupt raised!\n");
122		return;
123	}
124
125	sdev->msg->reply_error = sdev->ipc->ops->get_reply(sdev);
126}
127EXPORT_SYMBOL(snd_sof_ipc_get_reply);
128
129/* handle reply message from DSP */
130void snd_sof_ipc_reply(struct snd_sof_dev *sdev, u32 msg_id)
131{
132	struct snd_sof_ipc_msg *msg = &sdev->ipc->msg;
133
134	if (msg->ipc_complete) {
135		dev_dbg(sdev->dev,
136			"no reply expected, received 0x%x, will be ignored",
137			msg_id);
138		return;
139	}
140
141	/* wake up and return the error if we have waiters on this message ? */
142	msg->ipc_complete = true;
143	wake_up(&msg->waitq);
144}
145EXPORT_SYMBOL(snd_sof_ipc_reply);
146
147struct snd_sof_ipc *snd_sof_ipc_init(struct snd_sof_dev *sdev)
148{
149	struct snd_sof_ipc *ipc;
150	struct snd_sof_ipc_msg *msg;
151	const struct sof_ipc_ops *ops;
152
153	ipc = devm_kzalloc(sdev->dev, sizeof(*ipc), GFP_KERNEL);
154	if (!ipc)
155		return NULL;
156
157	mutex_init(&ipc->tx_mutex);
158	ipc->sdev = sdev;
159	msg = &ipc->msg;
160
161	/* indicate that we aren't sending a message ATM */
162	msg->ipc_complete = true;
163
164	init_waitqueue_head(&msg->waitq);
165
166	switch (sdev->pdata->ipc_type) {
167#if defined(CONFIG_SND_SOC_SOF_IPC3)
168	case SOF_IPC_TYPE_3:
169		ops = &ipc3_ops;
170		break;
171#endif
172#if defined(CONFIG_SND_SOC_SOF_IPC4)
173	case SOF_IPC_TYPE_4:
174		ops = &ipc4_ops;
175		break;
176#endif
177	default:
178		dev_err(sdev->dev, "Not supported IPC version: %d\n",
179			sdev->pdata->ipc_type);
180		return NULL;
181	}
182
183	/* check for mandatory ops */
184	if (!ops->tx_msg || !ops->rx_msg || !ops->set_get_data || !ops->get_reply) {
185		dev_err(sdev->dev, "Missing IPC message handling ops\n");
186		return NULL;
187	}
188
189	if (!ops->fw_loader || !ops->fw_loader->validate ||
190	    !ops->fw_loader->parse_ext_manifest) {
191		dev_err(sdev->dev, "Missing IPC firmware loading ops\n");
192		return NULL;
193	}
194
195	if (!ops->pcm) {
196		dev_err(sdev->dev, "Missing IPC PCM ops\n");
197		return NULL;
198	}
199
200	if (!ops->tplg || !ops->tplg->widget || !ops->tplg->control) {
201		dev_err(sdev->dev, "Missing IPC topology ops\n");
202		return NULL;
203	}
204
205	if (ops->fw_tracing && (!ops->fw_tracing->init || !ops->fw_tracing->suspend ||
206				!ops->fw_tracing->resume)) {
207		dev_err(sdev->dev, "Missing firmware tracing ops\n");
208		return NULL;
209	}
210
211	if (ops->init && ops->init(sdev))
212		return NULL;
213
214	ipc->ops = ops;
215
216	return ipc;
217}
218EXPORT_SYMBOL(snd_sof_ipc_init);
219
220void snd_sof_ipc_free(struct snd_sof_dev *sdev)
221{
222	struct snd_sof_ipc *ipc = sdev->ipc;
223
224	if (!ipc)
225		return;
226
227	/* disable sending of ipc's */
228	mutex_lock(&ipc->tx_mutex);
229	ipc->disable_ipc_tx = true;
230	mutex_unlock(&ipc->tx_mutex);
231
232	if (ipc->ops->exit)
233		ipc->ops->exit(sdev);
234}
235EXPORT_SYMBOL(snd_sof_ipc_free);
236