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