1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * sst_ipc.c - Intel SST Driver for audio engine
4 *
5 * Copyright (C) 2008-14 Intel Corporation
6 * Authors: Vinod Koul <vinod.koul@intel.com>
7 * Harsha Priya <priya.harsha@intel.com>
8 * Dharageswari R <dharageswari.r@intel.com>
9 * KP Jeeja <jeeja.kp@intel.com>
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11 *
12 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
13 */
14 #include <linux/pci.h>
15 #include <linux/firmware.h>
16 #include <linux/sched.h>
17 #include <linux/delay.h>
18 #include <sound/core.h>
19 #include <sound/pcm.h>
20 #include <sound/soc.h>
21 #include <sound/compress_driver.h>
22 #include <asm/intel-mid.h>
23 #include <asm/platform_sst_audio.h>
24 #include "../sst-mfld-platform.h"
25 #include "sst.h"
26
sst_create_block(struct intel_sst_drv * ctx,u32 msg_id,u32 drv_id)27 struct sst_block *sst_create_block(struct intel_sst_drv *ctx,
28 u32 msg_id, u32 drv_id)
29 {
30 struct sst_block *msg;
31
32 dev_dbg(ctx->dev, "Enter\n");
33 msg = kzalloc(sizeof(*msg), GFP_KERNEL);
34 if (!msg)
35 return NULL;
36 msg->condition = false;
37 msg->on = true;
38 msg->msg_id = msg_id;
39 msg->drv_id = drv_id;
40 spin_lock_bh(&ctx->block_lock);
41 list_add_tail(&msg->node, &ctx->block_list);
42 spin_unlock_bh(&ctx->block_lock);
43
44 return msg;
45 }
46
47 /*
48 * while handling the interrupts, we need to check for message status and
49 * then if we are blocking for a message
50 *
51 * here we are unblocking the blocked ones, this is based on id we have
52 * passed and search that for block threads.
53 * We will not find block in two cases
54 * a) when its small message and block in not there, so silently ignore
55 * them
56 * b) when we are actually not able to find the block (bug perhaps)
57 *
58 * Since we have bit of small messages we can spam kernel log with err
59 * print on above so need to keep as debug prints which should be enabled
60 * via dynamic debug while debugging IPC issues
61 */
sst_wake_up_block(struct intel_sst_drv * ctx,int result,u32 drv_id,u32 ipc,void * data,u32 size)62 int sst_wake_up_block(struct intel_sst_drv *ctx, int result,
63 u32 drv_id, u32 ipc, void *data, u32 size)
64 {
65 struct sst_block *block;
66
67 dev_dbg(ctx->dev, "Enter\n");
68
69 spin_lock_bh(&ctx->block_lock);
70 list_for_each_entry(block, &ctx->block_list, node) {
71 dev_dbg(ctx->dev, "Block ipc %d, drv_id %d\n", block->msg_id,
72 block->drv_id);
73 if (block->msg_id == ipc && block->drv_id == drv_id) {
74 dev_dbg(ctx->dev, "free up the block\n");
75 block->ret_code = result;
76 block->data = data;
77 block->size = size;
78 block->condition = true;
79 spin_unlock_bh(&ctx->block_lock);
80 wake_up(&ctx->wait_queue);
81 return 0;
82 }
83 }
84 spin_unlock_bh(&ctx->block_lock);
85 dev_dbg(ctx->dev,
86 "Block not found or a response received for a short msg for ipc %d, drv_id %d\n",
87 ipc, drv_id);
88 return -EINVAL;
89 }
90
sst_free_block(struct intel_sst_drv * ctx,struct sst_block * freed)91 int sst_free_block(struct intel_sst_drv *ctx, struct sst_block *freed)
92 {
93 struct sst_block *block, *__block;
94
95 dev_dbg(ctx->dev, "Enter\n");
96 spin_lock_bh(&ctx->block_lock);
97 list_for_each_entry_safe(block, __block, &ctx->block_list, node) {
98 if (block == freed) {
99 pr_debug("pvt_id freed --> %d\n", freed->drv_id);
100 /* toggle the index position of pvt_id */
101 list_del(&freed->node);
102 spin_unlock_bh(&ctx->block_lock);
103 kfree(freed->data);
104 freed->data = NULL;
105 kfree(freed);
106 return 0;
107 }
108 }
109 spin_unlock_bh(&ctx->block_lock);
110 dev_err(ctx->dev, "block is already freed!!!\n");
111 return -EINVAL;
112 }
113
sst_post_message_mrfld(struct intel_sst_drv * sst_drv_ctx,struct ipc_post * ipc_msg,bool sync)114 int sst_post_message_mrfld(struct intel_sst_drv *sst_drv_ctx,
115 struct ipc_post *ipc_msg, bool sync)
116 {
117 struct ipc_post *msg = ipc_msg;
118 union ipc_header_mrfld header;
119 unsigned int loop_count = 0;
120 int retval = 0;
121 unsigned long irq_flags;
122
123 dev_dbg(sst_drv_ctx->dev, "Enter: sync: %d\n", sync);
124 spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags);
125 header.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCX);
126 if (sync) {
127 while (header.p.header_high.part.busy) {
128 if (loop_count > 25) {
129 dev_err(sst_drv_ctx->dev,
130 "sst: Busy wait failed, can't send this msg\n");
131 retval = -EBUSY;
132 goto out;
133 }
134 cpu_relax();
135 loop_count++;
136 header.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCX);
137 }
138 } else {
139 if (list_empty(&sst_drv_ctx->ipc_dispatch_list)) {
140 /* queue is empty, nothing to send */
141 spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
142 dev_dbg(sst_drv_ctx->dev,
143 "Empty msg queue... NO Action\n");
144 return 0;
145 }
146
147 if (header.p.header_high.part.busy) {
148 spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
149 dev_dbg(sst_drv_ctx->dev, "Busy not free... post later\n");
150 return 0;
151 }
152
153 /* copy msg from list */
154 msg = list_entry(sst_drv_ctx->ipc_dispatch_list.next,
155 struct ipc_post, node);
156 list_del(&msg->node);
157 }
158 dev_dbg(sst_drv_ctx->dev, "sst: Post message: header = %x\n",
159 msg->mrfld_header.p.header_high.full);
160 dev_dbg(sst_drv_ctx->dev, "sst: size = 0x%x\n",
161 msg->mrfld_header.p.header_low_payload);
162
163 if (msg->mrfld_header.p.header_high.part.large)
164 memcpy_toio(sst_drv_ctx->mailbox + SST_MAILBOX_SEND,
165 msg->mailbox_data,
166 msg->mrfld_header.p.header_low_payload);
167
168 sst_shim_write64(sst_drv_ctx->shim, SST_IPCX, msg->mrfld_header.full);
169
170 out:
171 spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
172 kfree(msg->mailbox_data);
173 kfree(msg);
174 return retval;
175 }
176
intel_sst_clear_intr_mrfld(struct intel_sst_drv * sst_drv_ctx)177 void intel_sst_clear_intr_mrfld(struct intel_sst_drv *sst_drv_ctx)
178 {
179 union interrupt_reg_mrfld isr;
180 union interrupt_reg_mrfld imr;
181 union ipc_header_mrfld clear_ipc;
182 unsigned long irq_flags;
183
184 spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags);
185 imr.full = sst_shim_read64(sst_drv_ctx->shim, SST_IMRX);
186 isr.full = sst_shim_read64(sst_drv_ctx->shim, SST_ISRX);
187
188 /* write 1 to clear*/
189 isr.part.busy_interrupt = 1;
190 sst_shim_write64(sst_drv_ctx->shim, SST_ISRX, isr.full);
191
192 /* Set IA done bit */
193 clear_ipc.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCD);
194
195 clear_ipc.p.header_high.part.busy = 0;
196 clear_ipc.p.header_high.part.done = 1;
197 clear_ipc.p.header_low_payload = IPC_ACK_SUCCESS;
198 sst_shim_write64(sst_drv_ctx->shim, SST_IPCD, clear_ipc.full);
199 /* un mask busy interrupt */
200 imr.part.busy_interrupt = 0;
201 sst_shim_write64(sst_drv_ctx->shim, SST_IMRX, imr.full);
202 spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
203 }
204
205
206 /*
207 * process_fw_init - process the FW init msg
208 *
209 * @msg: IPC message mailbox data from FW
210 *
211 * This function processes the FW init msg from FW
212 * marks FW state and prints debug info of loaded FW
213 */
process_fw_init(struct intel_sst_drv * sst_drv_ctx,void * msg)214 static void process_fw_init(struct intel_sst_drv *sst_drv_ctx,
215 void *msg)
216 {
217 struct ipc_header_fw_init *init =
218 (struct ipc_header_fw_init *)msg;
219 int retval = 0;
220
221 dev_dbg(sst_drv_ctx->dev, "*** FW Init msg came***\n");
222 if (init->result) {
223 sst_set_fw_state_locked(sst_drv_ctx, SST_RESET);
224 dev_err(sst_drv_ctx->dev, "FW Init failed, Error %x\n",
225 init->result);
226 retval = init->result;
227 goto ret;
228 }
229 if (memcmp(&sst_drv_ctx->fw_version, &init->fw_version,
230 sizeof(init->fw_version)))
231 dev_info(sst_drv_ctx->dev, "FW Version %02x.%02x.%02x.%02x\n",
232 init->fw_version.type, init->fw_version.major,
233 init->fw_version.minor, init->fw_version.build);
234 dev_dbg(sst_drv_ctx->dev, "Build date %s Time %s\n",
235 init->build_info.date, init->build_info.time);
236
237 /* Save FW version */
238 sst_drv_ctx->fw_version.type = init->fw_version.type;
239 sst_drv_ctx->fw_version.major = init->fw_version.major;
240 sst_drv_ctx->fw_version.minor = init->fw_version.minor;
241 sst_drv_ctx->fw_version.build = init->fw_version.build;
242
243 ret:
244 sst_wake_up_block(sst_drv_ctx, retval, FW_DWNL_ID, 0 , NULL, 0);
245 }
246
process_fw_async_msg(struct intel_sst_drv * sst_drv_ctx,struct ipc_post * msg)247 static void process_fw_async_msg(struct intel_sst_drv *sst_drv_ctx,
248 struct ipc_post *msg)
249 {
250 u32 msg_id;
251 int str_id;
252 u32 data_size, i;
253 void *data_offset;
254 struct stream_info *stream;
255 u32 msg_low, pipe_id;
256
257 msg_low = msg->mrfld_header.p.header_low_payload;
258 msg_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->cmd_id;
259 data_offset = (msg->mailbox_data + sizeof(struct ipc_dsp_hdr));
260 data_size = msg_low - (sizeof(struct ipc_dsp_hdr));
261
262 switch (msg_id) {
263 case IPC_SST_PERIOD_ELAPSED_MRFLD:
264 pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
265 str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
266 if (str_id > 0) {
267 dev_dbg(sst_drv_ctx->dev,
268 "Period elapsed rcvd for pipe id 0x%x\n",
269 pipe_id);
270 stream = &sst_drv_ctx->streams[str_id];
271 /* If stream is dropped, skip processing this message*/
272 if (stream->status == STREAM_INIT)
273 break;
274 if (stream->period_elapsed)
275 stream->period_elapsed(stream->pcm_substream);
276 if (stream->compr_cb)
277 stream->compr_cb(stream->compr_cb_param);
278 }
279 break;
280
281 case IPC_IA_DRAIN_STREAM_MRFLD:
282 pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
283 str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
284 if (str_id > 0) {
285 stream = &sst_drv_ctx->streams[str_id];
286 if (stream->drain_notify)
287 stream->drain_notify(stream->drain_cb_param);
288 }
289 break;
290
291 case IPC_IA_FW_ASYNC_ERR_MRFLD:
292 dev_err(sst_drv_ctx->dev, "FW sent async error msg:\n");
293 for (i = 0; i < (data_size/4); i++)
294 print_hex_dump(KERN_DEBUG, NULL, DUMP_PREFIX_NONE,
295 16, 4, data_offset, data_size, false);
296 break;
297
298 case IPC_IA_FW_INIT_CMPLT_MRFLD:
299 process_fw_init(sst_drv_ctx, data_offset);
300 break;
301
302 case IPC_IA_BUF_UNDER_RUN_MRFLD:
303 pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
304 str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
305 if (str_id > 0)
306 dev_err(sst_drv_ctx->dev,
307 "Buffer under-run for pipe:%#x str_id:%d\n",
308 pipe_id, str_id);
309 break;
310
311 default:
312 dev_err(sst_drv_ctx->dev,
313 "Unrecognized async msg from FW msg_id %#x\n", msg_id);
314 }
315 }
316
sst_process_reply_mrfld(struct intel_sst_drv * sst_drv_ctx,struct ipc_post * msg)317 void sst_process_reply_mrfld(struct intel_sst_drv *sst_drv_ctx,
318 struct ipc_post *msg)
319 {
320 unsigned int drv_id;
321 void *data;
322 union ipc_header_high msg_high;
323 u32 msg_low;
324 struct ipc_dsp_hdr *dsp_hdr;
325
326 msg_high = msg->mrfld_header.p.header_high;
327 msg_low = msg->mrfld_header.p.header_low_payload;
328
329 dev_dbg(sst_drv_ctx->dev, "IPC process message header %x payload %x\n",
330 msg->mrfld_header.p.header_high.full,
331 msg->mrfld_header.p.header_low_payload);
332
333 drv_id = msg_high.part.drv_id;
334
335 /* Check for async messages first */
336 if (drv_id == SST_ASYNC_DRV_ID) {
337 /*FW sent async large message*/
338 process_fw_async_msg(sst_drv_ctx, msg);
339 return;
340 }
341
342 /* FW sent short error response for an IPC */
343 if (msg_high.part.result && !msg_high.part.large) {
344 /* 32-bit FW error code in msg_low */
345 dev_err(sst_drv_ctx->dev, "FW sent error response 0x%x", msg_low);
346 sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
347 msg_high.part.drv_id,
348 msg_high.part.msg_id, NULL, 0);
349 return;
350 }
351
352 /*
353 * Process all valid responses
354 * if it is a large message, the payload contains the size to
355 * copy from mailbox
356 **/
357 if (msg_high.part.large) {
358 data = kmemdup((void *)msg->mailbox_data, msg_low, GFP_KERNEL);
359 if (!data)
360 return;
361 /* Copy command id so that we can use to put sst to reset */
362 dsp_hdr = (struct ipc_dsp_hdr *)data;
363 dev_dbg(sst_drv_ctx->dev, "cmd_id %d\n", dsp_hdr->cmd_id);
364 if (sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
365 msg_high.part.drv_id,
366 msg_high.part.msg_id, data, msg_low))
367 kfree(data);
368 } else {
369 sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
370 msg_high.part.drv_id,
371 msg_high.part.msg_id, NULL, 0);
372 }
373
374 }
375