2 * sst_ipc.c - Intel SST Driver for audio engine
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
20 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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"
35 #include "../../common/sst-dsp.h"
37 struct sst_block
*sst_create_block(struct intel_sst_drv
*ctx
,
38 u32 msg_id
, u32 drv_id
)
40 struct sst_block
*msg
= NULL
;
42 dev_dbg(ctx
->dev
, "Enter\n");
43 msg
= kzalloc(sizeof(*msg
), GFP_KERNEL
);
46 msg
->condition
= false;
50 spin_lock_bh(&ctx
->block_lock
);
51 list_add_tail(&msg
->node
, &ctx
->block_list
);
52 spin_unlock_bh(&ctx
->block_lock
);
58 * while handling the interrupts, we need to check for message status and
59 * then if we are blocking for a message
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
66 * b) when we are actually not able to find the block (bug perhaps)
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
72 int sst_wake_up_block(struct intel_sst_drv
*ctx
, int result
,
73 u32 drv_id
, u32 ipc
, void *data
, u32 size
)
75 struct sst_block
*block
= NULL
;
77 dev_dbg(ctx
->dev
, "Enter\n");
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
,
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
;
88 block
->condition
= true;
89 spin_unlock_bh(&ctx
->block_lock
);
90 wake_up(&ctx
->wait_queue
);
94 spin_unlock_bh(&ctx
->block_lock
);
96 "Block not found or a response received for a short msg for ipc %d, drv_id %d\n",
101 int sst_free_block(struct intel_sst_drv
*ctx
, struct sst_block
*freed
)
103 struct sst_block
*block
= NULL
, *__block
;
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
);
119 spin_unlock_bh(&ctx
->block_lock
);
120 dev_err(ctx
->dev
, "block is already freed!!!\n");
124 int sst_post_message_mrfld(struct intel_sst_drv
*sst_drv_ctx
,
125 struct ipc_post
*ipc_msg
, bool sync
)
127 struct ipc_post
*msg
= ipc_msg
;
128 union ipc_header_mrfld header
;
129 unsigned int loop_count
= 0;
131 unsigned long irq_flags
;
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
);
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");
146 header
.full
= sst_shim_read64(sst_drv_ctx
->shim
, SST_IPCX
);
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");
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");
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
);
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
);
173 if (msg
->mrfld_header
.p
.header_high
.part
.large
)
174 memcpy_toio(sst_drv_ctx
->mailbox
+ SST_MAILBOX_SEND
,
176 msg
->mrfld_header
.p
.header_low_payload
);
178 sst_shim_write64(sst_drv_ctx
->shim
, SST_IPCX
, msg
->mrfld_header
.full
);
181 spin_unlock_irqrestore(&sst_drv_ctx
->ipc_spin_lock
, irq_flags
);
182 kfree(msg
->mailbox_data
);
187 void intel_sst_clear_intr_mrfld(struct intel_sst_drv
*sst_drv_ctx
)
189 union interrupt_reg_mrfld isr
;
190 union interrupt_reg_mrfld imr
;
191 union ipc_header_mrfld clear_ipc
;
192 unsigned long irq_flags
;
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
);
198 /* write 1 to clear*/
199 isr
.part
.busy_interrupt
= 1;
200 sst_shim_write64(sst_drv_ctx
->shim
, SST_ISRX
, isr
.full
);
202 /* Set IA done bit */
203 clear_ipc
.full
= sst_shim_read64(sst_drv_ctx
->shim
, SST_IPCD
);
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
);
217 * process_fw_init - process the FW init msg
219 * @msg: IPC message mailbox data from FW
221 * This function processes the FW init msg from FW
222 * marks FW state and prints debug info of loaded FW
224 static void process_fw_init(struct intel_sst_drv
*sst_drv_ctx
,
227 struct ipc_header_fw_init
*init
=
228 (struct ipc_header_fw_init
*)msg
;
231 dev_dbg(sst_drv_ctx
->dev
, "*** FW Init msg came***\n");
233 sst_set_fw_state_locked(sst_drv_ctx
, SST_RESET
);
234 dev_err(sst_drv_ctx
->dev
, "FW Init failed, Error %x\n",
236 retval
= init
->result
;
241 sst_wake_up_block(sst_drv_ctx
, retval
, FW_DWNL_ID
, 0 , NULL
, 0);
244 static void process_fw_async_msg(struct intel_sst_drv
*sst_drv_ctx
,
245 struct ipc_post
*msg
)
251 struct stream_info
*stream
;
252 union ipc_header_high msg_high
;
253 u32 msg_low
, pipe_id
;
255 msg_high
= msg
->mrfld_header
.p
.header_high
;
256 msg_low
= msg
->mrfld_header
.p
.header_low_payload
;
257 msg_id
= ((struct ipc_dsp_hdr
*)msg
->mailbox_data
)->cmd_id
;
258 data_offset
= (msg
->mailbox_data
+ sizeof(struct ipc_dsp_hdr
));
259 data_size
= msg_low
- (sizeof(struct ipc_dsp_hdr
));
262 case IPC_SST_PERIOD_ELAPSED_MRFLD
:
263 pipe_id
= ((struct ipc_dsp_hdr
*)msg
->mailbox_data
)->pipe_id
;
264 str_id
= get_stream_id_mrfld(sst_drv_ctx
, pipe_id
);
266 dev_dbg(sst_drv_ctx
->dev
,
267 "Period elapsed rcvd for pipe id 0x%x\n",
269 stream
= &sst_drv_ctx
->streams
[str_id
];
270 if (stream
->period_elapsed
)
271 stream
->period_elapsed(stream
->pcm_substream
);
272 if (stream
->compr_cb
)
273 stream
->compr_cb(stream
->compr_cb_param
);
277 case IPC_IA_DRAIN_STREAM_MRFLD
:
278 pipe_id
= ((struct ipc_dsp_hdr
*)msg
->mailbox_data
)->pipe_id
;
279 str_id
= get_stream_id_mrfld(sst_drv_ctx
, pipe_id
);
281 stream
= &sst_drv_ctx
->streams
[str_id
];
282 if (stream
->drain_notify
)
283 stream
->drain_notify(stream
->drain_cb_param
);
287 case IPC_IA_FW_ASYNC_ERR_MRFLD
:
288 dev_err(sst_drv_ctx
->dev
, "FW sent async error msg:\n");
289 for (i
= 0; i
< (data_size
/4); i
++)
290 print_hex_dump(KERN_DEBUG
, NULL
, DUMP_PREFIX_NONE
,
291 16, 4, data_offset
, data_size
, false);
294 case IPC_IA_FW_INIT_CMPLT_MRFLD
:
295 process_fw_init(sst_drv_ctx
, data_offset
);
298 case IPC_IA_BUF_UNDER_RUN_MRFLD
:
299 pipe_id
= ((struct ipc_dsp_hdr
*)msg
->mailbox_data
)->pipe_id
;
300 str_id
= get_stream_id_mrfld(sst_drv_ctx
, pipe_id
);
302 dev_err(sst_drv_ctx
->dev
,
303 "Buffer under-run for pipe:%#x str_id:%d\n",
308 dev_err(sst_drv_ctx
->dev
,
309 "Unrecognized async msg from FW msg_id %#x\n", msg_id
);
313 void sst_process_reply_mrfld(struct intel_sst_drv
*sst_drv_ctx
,
314 struct ipc_post
*msg
)
318 union ipc_header_high msg_high
;
320 struct ipc_dsp_hdr
*dsp_hdr
;
322 msg_high
= msg
->mrfld_header
.p
.header_high
;
323 msg_low
= msg
->mrfld_header
.p
.header_low_payload
;
325 dev_dbg(sst_drv_ctx
->dev
, "IPC process message header %x payload %x\n",
326 msg
->mrfld_header
.p
.header_high
.full
,
327 msg
->mrfld_header
.p
.header_low_payload
);
329 drv_id
= msg_high
.part
.drv_id
;
331 /* Check for async messages first */
332 if (drv_id
== SST_ASYNC_DRV_ID
) {
333 /*FW sent async large message*/
334 process_fw_async_msg(sst_drv_ctx
, msg
);
338 /* FW sent short error response for an IPC */
339 if (msg_high
.part
.result
&& drv_id
&& !msg_high
.part
.large
) {
340 /* 32-bit FW error code in msg_low */
341 dev_err(sst_drv_ctx
->dev
, "FW sent error response 0x%x", msg_low
);
342 sst_wake_up_block(sst_drv_ctx
, msg_high
.part
.result
,
343 msg_high
.part
.drv_id
,
344 msg_high
.part
.msg_id
, NULL
, 0);
349 * Process all valid responses
350 * if it is a large message, the payload contains the size to
353 if (msg_high
.part
.large
) {
354 data
= kmemdup((void *)msg
->mailbox_data
, msg_low
, GFP_KERNEL
);
357 /* Copy command id so that we can use to put sst to reset */
358 dsp_hdr
= (struct ipc_dsp_hdr
*)data
;
359 dev_dbg(sst_drv_ctx
->dev
, "cmd_id %d\n", dsp_hdr
->cmd_id
);
360 if (sst_wake_up_block(sst_drv_ctx
, msg_high
.part
.result
,
361 msg_high
.part
.drv_id
,
362 msg_high
.part
.msg_id
, data
, msg_low
))
365 sst_wake_up_block(sst_drv_ctx
, msg_high
.part
.result
,
366 msg_high
.part
.drv_id
,
367 msg_high
.part
.msg_id
, NULL
, 0);