~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/intel/atom/sst/sst_ipc.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 37 struct 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  */
 72 int 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 
101 int 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 
124 int 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 
180 out:
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 
187 void 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  */
224 static 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 
240 ret:
241         sst_wake_up_block(sst_drv_ctx, retval, FW_DWNL_ID, 0 , NULL, 0);
242 }
243 
244 static void process_fw_async_msg(struct intel_sst_drv *sst_drv_ctx,
245                         struct ipc_post *msg)
246 {
247         u32 msg_id;
248         int str_id;
249         u32 data_size, i;
250         void *data_offset;
251         struct stream_info *stream;
252         union ipc_header_high msg_high;
253         u32 msg_low, pipe_id;
254 
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));
260 
261         switch (msg_id) {
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);
265                 if (str_id > 0) {
266                         dev_dbg(sst_drv_ctx->dev,
267                                 "Period elapsed rcvd for pipe id 0x%x\n",
268                                 pipe_id);
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);
274                 }
275                 break;
276 
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);
280                 if (str_id > 0) {
281                         stream = &sst_drv_ctx->streams[str_id];
282                         if (stream->drain_notify)
283                                 stream->drain_notify(stream->drain_cb_param);
284                 }
285                 break;
286 
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);
292                 break;
293 
294         case IPC_IA_FW_INIT_CMPLT_MRFLD:
295                 process_fw_init(sst_drv_ctx, data_offset);
296                 break;
297 
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);
301                 if (str_id > 0)
302                         dev_err(sst_drv_ctx->dev,
303                                 "Buffer under-run for pipe:%#x str_id:%d\n",
304                                 pipe_id, str_id);
305                 break;
306 
307         default:
308                 dev_err(sst_drv_ctx->dev,
309                         "Unrecognized async msg from FW msg_id %#x\n", msg_id);
310         }
311 }
312 
313 void sst_process_reply_mrfld(struct intel_sst_drv *sst_drv_ctx,
314                 struct ipc_post *msg)
315 {
316         unsigned int drv_id;
317         void *data;
318         union ipc_header_high msg_high;
319         u32 msg_low;
320         struct ipc_dsp_hdr *dsp_hdr;
321         unsigned int cmd_id;
322 
323         msg_high = msg->mrfld_header.p.header_high;
324         msg_low = msg->mrfld_header.p.header_low_payload;
325 
326         dev_dbg(sst_drv_ctx->dev, "IPC process message header %x payload %x\n",
327                         msg->mrfld_header.p.header_high.full,
328                         msg->mrfld_header.p.header_low_payload);
329 
330         drv_id = msg_high.part.drv_id;
331 
332         /* Check for async messages first */
333         if (drv_id == SST_ASYNC_DRV_ID) {
334                 /*FW sent async large message*/
335                 process_fw_async_msg(sst_drv_ctx, msg);
336                 return;
337         }
338 
339         /* FW sent short error response for an IPC */
340         if (msg_high.part.result && drv_id && !msg_high.part.large) {
341                 /* 32-bit FW error code in msg_low */
342                 dev_err(sst_drv_ctx->dev, "FW sent error response 0x%x", msg_low);
343                 sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
344                         msg_high.part.drv_id,
345                         msg_high.part.msg_id, NULL, 0);
346                 return;
347         }
348 
349         /*
350          * Process all valid responses
351          * if it is a large message, the payload contains the size to
352          * copy from mailbox
353          **/
354         if (msg_high.part.large) {
355                 data = kzalloc(msg_low, GFP_KERNEL);
356                 if (!data)
357                         return;
358                 memcpy(data, (void *) msg->mailbox_data, msg_low);
359                 /* Copy command id so that we can use to put sst to reset */
360                 dsp_hdr = (struct ipc_dsp_hdr *)data;
361                 cmd_id = dsp_hdr->cmd_id;
362                 dev_dbg(sst_drv_ctx->dev, "cmd_id %d\n", dsp_hdr->cmd_id);
363                 if (sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
364                                 msg_high.part.drv_id,
365                                 msg_high.part.msg_id, data, msg_low))
366                         kfree(data);
367         } else {
368                 sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
369                                 msg_high.part.drv_id,
370                                 msg_high.part.msg_id, NULL, 0);
371         }
372 
373 }
374 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp