/** * sst_get_fw_info - Send msg to query for firmware configurations * @info: out param that holds the firmare configurations * * This function is called when the firmware configurations are queiried for */ int sst_get_fw_info(struct snd_sst_fw_info *info) { int retval = 0; struct ipc_post *msg = NULL; unsigned long irq_flags; pr_debug("sst_get_fw_info called\n"); if (sst_create_short_msg(&msg)) { pr_err("message creation failed\n"); return -ENOMEM; } sst_fill_header(&msg->header, IPC_IA_GET_FW_INFO, 0, 0); sst_drv_ctx->fw_info_blk.condition = false; sst_drv_ctx->fw_info_blk.ret_code = 0; sst_drv_ctx->fw_info_blk.on = true; sst_drv_ctx->fw_info_blk.data = info; spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); sst_drv_ctx->ops->post_message(&sst_drv_ctx->ipc_post_msg_wq); retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->fw_info_blk); if (retval) { pr_err("error in fw_info = %d\n", retval); retval = -EIO; } return retval; }
/* * sst_download_fw - download the audio firmware to DSP * * This function is called when the FW needs to be downloaded to SST DSP engine */ int sst_download_fw(void) { int retval; const struct firmware *fw_sst; char name[20]; if (sst_drv_ctx->sst_state != SST_UN_INIT) return -EPERM; snprintf(name, sizeof(name), "%s%04x%s", "fw_sst_", sst_drv_ctx->pci_id, ".bin"); pr_debug("Downloading %s FW now...\n", name); retval = request_firmware(&fw_sst, name, &sst_drv_ctx->pci->dev); if (retval) { pr_err("request fw failed %d\n", retval); return retval; } sst_drv_ctx->alloc_block[0].sst_id = FW_DWNL_ID; sst_drv_ctx->alloc_block[0].ops_block.condition = false; retval = sst_load_fw(fw_sst, NULL); if (retval) goto end_restore; retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[0]); if (retval) pr_err("fw download failed %d\n" , retval); end_restore: release_firmware(fw_sst); sst_drv_ctx->alloc_block[0].sst_id = BLOCK_UNINIT; return retval; }
int sst_send_probe_bytes(struct intel_sst_drv *sst) { struct ipc_post *msg = NULL; struct sst_block *block; unsigned long irq_flags; int ret_val = 0; ret_val = sst_create_block_and_ipc_msg(&msg, true, sst, &block, IPC_IA_DBG_SET_PROBE_PARAMS, 0); if (ret_val) { pr_err("Can't allocate block/msg: Probe Byte Stream\n"); return ret_val; } sst_fill_header(&msg->header, IPC_IA_DBG_SET_PROBE_PARAMS, 1, 0); msg->header.part.data = sizeof(u32) + sst->probe_bytes->len; memcpy(msg->mailbox_data, &msg->header.full, sizeof(u32)); memcpy(msg->mailbox_data + sizeof(u32), sst->probe_bytes->bytes, sst->probe_bytes->len); spin_lock_irqsave(&sst->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst->ipc_dispatch_list); spin_unlock_irqrestore(&sst->ipc_spin_lock, irq_flags); sst->ops->post_message(&sst->ipc_post_msg_wq); ret_val = sst_wait_timeout(sst, block); sst_free_block(sst, block); if (ret_val) pr_err("set probe stream param..timeout!\n"); return ret_val; }
/** * sst_resume_stream - Send msg for resuming stream * @str_id: stream ID * * This function is called by any function which wants to resume * an already paused stream. */ int sst_resume_stream(int str_id) { int retval = 0; struct ipc_post *msg = NULL; struct stream_info *str_info; struct intel_sst_ops *ops; unsigned long irq_flags; pr_debug("SST DBG:sst_resume_stream for %d\n", str_id); str_info = get_stream_info(str_id); if (!str_info) return -EINVAL; ops = sst_drv_ctx->ops; if (str_info->status == STREAM_RUNNING) return 0; if (str_info->status == STREAM_PAUSED) { if (str_info->ctrl_blk.on == true) { pr_err("SST ERR: control path in use\n"); return -EINVAL; } if (sst_create_short_msg(&msg)) { pr_err("SST ERR: mem allocation failed\n"); return -ENOMEM; } sst_fill_header(&msg->header, IPC_IA_RESUME_STREAM, 0, str_id); str_info->ctrl_blk.condition = false; str_info->ctrl_blk.ret_code = 0; str_info->ctrl_blk.on = true; spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); ops->post_message(&sst_drv_ctx->ipc_post_msg_wq); retval = sst_wait_timeout(sst_drv_ctx, &str_info->ctrl_blk); if (!retval) { if (str_info->prev == STREAM_RUNNING) str_info->status = STREAM_RUNNING; else str_info->status = STREAM_INIT; str_info->prev = STREAM_PAUSED; } else if (retval == -SST_ERR_INVALID_STREAM_ID) { retval = -EINVAL; mutex_lock(&sst_drv_ctx->stream_lock); sst_clean_stream(str_info); mutex_unlock(&sst_drv_ctx->stream_lock); } } else { retval = -EBADRQC; pr_err("SST ERR: BADQRC for stream\n"); } return retval; }
static void sst_save_dsp_context(void) { struct snd_sst_ctxt_params fw_context; unsigned int pvt_id; struct ipc_post *msg = NULL; unsigned long irq_flags; /*check cpu type*/ if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID) return; /*not supported for rest*/ if (sst_drv_ctx->sst_state != SST_FW_RUNNING) { pr_debug("fw not running no context save ...\n"); return; } /*send msg to fw*/ if (sst_create_large_msg(&msg)) return; pvt_id = sst_assign_pvt_id(sst_drv_ctx); sst_drv_ctx->alloc_block[0].sst_id = pvt_id; sst_drv_ctx->alloc_block[0].ops_block.condition = false; sst_drv_ctx->alloc_block[0].ops_block.on = true; sst_fill_header(&msg->header, IPC_IA_GET_FW_CTXT, 1, pvt_id); msg->header.part.data = sizeof(fw_context) + sizeof(u32); fw_context.address = virt_to_phys((void *)sst_drv_ctx->fw_cntx); fw_context.size = FW_CONTEXT_MEM; memcpy(msg->mailbox_data, &msg->header, sizeof(u32)); memcpy(msg->mailbox_data + sizeof(u32), &fw_context, sizeof(fw_context)); spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); sst_post_message(&sst_drv_ctx->ipc_post_msg_wq); /*wait for reply*/ if (sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[0].ops_block)) pr_err("sst: err fw context save timeout ...\n"); sst_drv_ctx->alloc_block[0].sst_id = BLOCK_UNINIT; pr_debug("fw context saved ...\n"); return; }
/* * sst_download_fw - download the audio firmware to DSP * * This function is called when the FW needs to be downloaded to SST DSP engine */ int sst_download_fw(void) { int retval; const struct firmware *fw_sst; char name[20]; if (sst_drv_ctx->sst_state != SST_UN_INIT) return -EPERM; /* Reload firmware is not needed for MRST */ if ( (sst_drv_ctx->pci_id == SST_MRST_PCI_ID) && sst_drv_ctx->fw_downloaded) { pr_debug("FW already downloaded, skip for MRST platform\n"); sst_drv_ctx->sst_state = SST_FW_RUNNING; return 0; } snprintf(name, sizeof(name), "%s%04x%s", "fw_sst_", sst_drv_ctx->pci_id, ".bin"); pr_debug("Downloading %s FW now...\n", name); retval = request_firmware(&fw_sst, name, &sst_drv_ctx->pci->dev); if (retval) { pr_err("request fw failed %d\n", retval); return retval; } sst_drv_ctx->alloc_block[0].sst_id = FW_DWNL_ID; sst_drv_ctx->alloc_block[0].ops_block.condition = false; retval = sst_load_fw(fw_sst, NULL); if (retval) goto end_restore; retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[0]); if (retval) pr_err("fw download failed %d\n" , retval); else sst_drv_ctx->fw_downloaded = 1; end_restore: release_firmware(fw_sst); sst_drv_ctx->alloc_block[0].sst_id = BLOCK_UNINIT; return retval; }
int sst_send_vtsv_data_to_fw(struct intel_sst_drv *ctx) { int retval = 0; struct ipc_post *msg = NULL; struct intel_sst_ops *ops = ctx->ops; unsigned long irq_flags; struct sst_block *block = NULL; /* Download both the data files */ retval = sst_request_vtsv_file("vtsv_net_119a.bin", ctx, &ctx->vcache.file1_in_mem, &ctx->vcache.size1); if (retval) { pr_err("vtsv data file1 request failed %d\n", retval); return retval; } retval = sst_request_vtsv_file("vtsv_grammar_119a.bin", ctx, &ctx->vcache.file2_in_mem, &ctx->vcache.size2); if (retval) { pr_err("vtsv data file2 request failed %d\n", retval); return retval; } retval = sst_format_vtsv_message(ctx, &msg, &block); if (retval) { pr_err("vtsv msg format failed %d\n", retval); return retval; } spin_lock_irqsave(&ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &ctx->ipc_dispatch_list); spin_unlock_irqrestore(&ctx->ipc_spin_lock, irq_flags); ops->post_message(&ctx->ipc_post_msg_wq); retval = sst_wait_timeout(ctx, block); if (retval) pr_err("vtsv msg send to fw failed %d\n", retval); sst_free_block(ctx, block); return retval; }
/*This function is called when any codec/post processing library needs to be downloaded*/ static int sst_download_library(const struct firmware *fw_lib, struct snd_sst_lib_download_info *lib) { /* send IPC message and wait */ int i; u8 pvt_id; struct ipc_post *msg = NULL; union config_status_reg csr; struct snd_sst_str_type str_type = {0}; int retval = 0; if (sst_create_large_msg(&msg)) return -ENOMEM; pvt_id = sst_assign_pvt_id(sst_drv_ctx); i = sst_get_block_stream(sst_drv_ctx); pr_debug("alloc block allocated = %d, pvt_id %d\n", i, pvt_id); if (i < 0) { kfree(msg); return -ENOMEM; } sst_drv_ctx->alloc_block[i].sst_id = pvt_id; sst_fill_header(&msg->header, IPC_IA_PREP_LIB_DNLD, 1, pvt_id); msg->header.part.data = sizeof(u32) + sizeof(str_type); str_type.codec_type = lib->dload_lib.lib_info.lib_type; /*str_type.pvt_id = pvt_id;*/ memcpy(msg->mailbox_data, &msg->header, sizeof(u32)); memcpy(msg->mailbox_data + sizeof(u32), &str_type, sizeof(str_type)); spin_lock(&sst_drv_ctx->list_spin_lock); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock(&sst_drv_ctx->list_spin_lock); sst_post_message(&sst_drv_ctx->ipc_post_msg_wq); retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[i]); if (retval) { /* error */ sst_drv_ctx->alloc_block[i].sst_id = BLOCK_UNINIT; pr_err("Prep codec downloaded failed %d\n", retval); return -EIO; } pr_debug("FW responded, ready for download now...\n"); /* downloading on success */ mutex_lock(&sst_drv_ctx->sst_lock); sst_drv_ctx->sst_state = SST_FW_LOADED; mutex_unlock(&sst_drv_ctx->sst_lock); csr.full = readl(sst_drv_ctx->shim + SST_CSR); csr.part.run_stall = 1; sst_shim_write(sst_drv_ctx->shim, SST_CSR, csr.full); csr.full = sst_shim_read(sst_drv_ctx->shim, SST_CSR); csr.part.bypass = 0x7; sst_shim_write(sst_drv_ctx->shim, SST_CSR, csr.full); sst_parse_fw_image(fw_lib); /* set the FW to running again */ csr.full = sst_shim_read(sst_drv_ctx->shim, SST_CSR); csr.part.bypass = 0x0; sst_shim_write(sst_drv_ctx->shim, SST_CSR, csr.full); csr.full = sst_shim_read(sst_drv_ctx->shim, SST_CSR); csr.part.run_stall = 0; sst_shim_write(sst_drv_ctx->shim, SST_CSR, csr.full); /* send download complete and wait */ if (sst_create_large_msg(&msg)) { sst_drv_ctx->alloc_block[i].sst_id = BLOCK_UNINIT; return -ENOMEM; } sst_fill_header(&msg->header, IPC_IA_LIB_DNLD_CMPLT, 1, pvt_id); sst_drv_ctx->alloc_block[i].sst_id = pvt_id; msg->header.part.data = sizeof(u32) + sizeof(*lib); lib->pvt_id = pvt_id; memcpy(msg->mailbox_data, &msg->header, sizeof(u32)); memcpy(msg->mailbox_data + sizeof(u32), lib, sizeof(*lib)); spin_lock(&sst_drv_ctx->list_spin_lock); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock(&sst_drv_ctx->list_spin_lock); sst_post_message(&sst_drv_ctx->ipc_post_msg_wq); pr_debug("Waiting for FW response Download complete\n"); sst_drv_ctx->alloc_block[i].ops_block.condition = false; retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[i]); if (retval) { /* error */ mutex_lock(&sst_drv_ctx->sst_lock); sst_drv_ctx->sst_state = SST_UN_INIT; mutex_unlock(&sst_drv_ctx->sst_lock); sst_drv_ctx->alloc_block[i].sst_id = BLOCK_UNINIT; return -EIO; } pr_debug("FW success on Download complete\n"); sst_drv_ctx->alloc_block[i].sst_id = BLOCK_UNINIT; mutex_lock(&sst_drv_ctx->sst_lock); sst_drv_ctx->sst_state = SST_FW_RUNNING; mutex_unlock(&sst_drv_ctx->sst_lock); return 0; }
/** * sst_free_stream - Frees a stream * @str_id: stream ID * * This function is called by any function which wants to free * a stream. */ int sst_free_stream(int str_id) { int retval = 0; struct ipc_post *msg = NULL; struct stream_info *str_info; struct intel_sst_ops *ops; unsigned long irq_flags; pr_debug("SST DBG:sst_free_stream for %d\n", str_id); mutex_lock(&sst_drv_ctx->sst_lock); if (sst_drv_ctx->sst_state == SST_UN_INIT) { mutex_unlock(&sst_drv_ctx->sst_lock); return -ENODEV; } mutex_unlock(&sst_drv_ctx->sst_lock); str_info = get_stream_info(str_id); if (!str_info) return -EINVAL; ops = sst_drv_ctx->ops; mutex_lock(&str_info->lock); if (str_info->status != STREAM_UN_INIT) { str_info->prev = str_info->status; str_info->status = STREAM_UN_INIT; mutex_unlock(&str_info->lock); if (str_info->ctrl_blk.on == true) { pr_err("SST ERR: control path in use\n"); return -EINVAL; } if (sst_create_short_msg(&msg)) { pr_err("SST ERR: mem allocation failed\n"); return -ENOMEM; } if (sst_drv_ctx->pci_id == SST_MRFLD_PCI_ID) sst_fill_header_mrfld(&msg->mrfld_header, IPC_IA_FREE_STREAM, 0, str_id); else sst_fill_header(&msg->header, IPC_IA_FREE_STREAM, 0, str_id); spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); if (str_info->data_blk.on == true) { str_info->data_blk.condition = true; str_info->data_blk.ret_code = 0; wake_up(&sst_drv_ctx->wait_queue); } str_info->ctrl_blk.on = true; str_info->ctrl_blk.condition = false; ops->post_message(&sst_drv_ctx->ipc_post_msg_wq); retval = sst_wait_timeout(sst_drv_ctx, &str_info->ctrl_blk); pr_debug("sst: wait for free returned %d\n", retval); mutex_lock(&sst_drv_ctx->stream_lock); sst_clean_stream(str_info); mutex_unlock(&sst_drv_ctx->stream_lock); pr_debug("SST DBG:Stream freed\n"); } else { mutex_unlock(&str_info->lock); retval = -EBADRQC; pr_debug("SST DBG:BADQRC for stream\n"); } return retval; }
int sst_send_byte_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, struct snd_sst_bytes_v2 *bytes) { struct ipc_post *msg = NULL; u32 length; int pvt_id, ret = 0; struct sst_block *block = NULL; dev_dbg(sst_drv_ctx->dev, "type:%u ipc_msg:%u block:%u task_id:%u pipe: %#x length:%#x\n", bytes->type, bytes->ipc_msg, bytes->block, bytes->task_id, bytes->pipe_id, bytes->len); if (sst_create_ipc_msg(&msg, true)) return -ENOMEM; pvt_id = sst_assign_pvt_id(sst_drv_ctx); sst_fill_header_mrfld(&msg->mrfld_header, bytes->ipc_msg, bytes->task_id, 1, pvt_id); msg->mrfld_header.p.header_high.part.res_rqd = bytes->block; length = bytes->len; msg->mrfld_header.p.header_low_payload = length; dev_dbg(sst_drv_ctx->dev, "length is %d\n", length); memcpy(msg->mailbox_data, &bytes->bytes, bytes->len); if (bytes->block) { block = sst_create_block(sst_drv_ctx, bytes->ipc_msg, pvt_id); if (block == NULL) { kfree(msg); ret = -ENOMEM; goto out; } } sst_add_to_dispatch_list_and_post(sst_drv_ctx, msg); dev_dbg(sst_drv_ctx->dev, "msg->mrfld_header.p.header_low_payload:%d", msg->mrfld_header.p.header_low_payload); if (bytes->block) { ret = sst_wait_timeout(sst_drv_ctx, block); if (ret) { dev_err(sst_drv_ctx->dev, "fw returned err %d\n", ret); sst_free_block(sst_drv_ctx, block); goto out; } } if (bytes->type == SND_SST_BYTES_GET) { /* * copy the reply and send back * we need to update only sz and payload */ if (bytes->block) { unsigned char *r = block->data; dev_dbg(sst_drv_ctx->dev, "read back %d bytes", bytes->len); memcpy(bytes->bytes, r, bytes->len); } } if (bytes->block) sst_free_block(sst_drv_ctx, block); out: test_and_clear_bit(pvt_id, &sst_drv_ctx->pvt_id); return 0; }
/** * sst_free_stream - Frees a stream * @str_id: stream ID * * This function is called by any function which wants to free * a stream. */ int sst_free_stream(int str_id) { int retval = 0; unsigned int pvt_id; struct ipc_post *msg = NULL; struct stream_info *str_info; struct intel_sst_ops *ops; unsigned long irq_flags; struct ipc_dsp_hdr dsp_hdr; struct sst_block *block; pr_debug("SST DBG:sst_free_stream for %d\n", str_id); mutex_lock(&sst_drv_ctx->sst_lock); if (sst_drv_ctx->sst_state == SST_UN_INIT) { mutex_unlock(&sst_drv_ctx->sst_lock); return -ENODEV; } mutex_unlock(&sst_drv_ctx->sst_lock); str_info = get_stream_info(str_id); if (!str_info) return -EINVAL; ops = sst_drv_ctx->ops; mutex_lock(&str_info->lock); if (str_info->status != STREAM_UN_INIT) { str_info->prev = str_info->status; str_info->status = STREAM_UN_INIT; mutex_unlock(&str_info->lock); if (!sst_drv_ctx->use_32bit_ops) { pvt_id = sst_assign_pvt_id(sst_drv_ctx); retval = sst_create_block_and_ipc_msg(&msg, true, sst_drv_ctx, &block, IPC_CMD, pvt_id); if (retval) return retval; sst_fill_header_mrfld(&msg->mrfld_header, IPC_CMD, str_info->task_id, 1, pvt_id); msg->mrfld_header.p.header_low_payload = sizeof(dsp_hdr); sst_fill_header_dsp(&dsp_hdr, IPC_IA_FREE_STREAM_MRFLD, str_info->pipe_id, 0); memcpy(msg->mailbox_data, &dsp_hdr, sizeof(dsp_hdr)); } else { retval = sst_create_block_and_ipc_msg(&msg, false, sst_drv_ctx, &block, IPC_IA_FREE_STREAM, str_id); if (retval) return retval; sst_fill_header(&msg->header, IPC_IA_FREE_STREAM, 0, str_id); } spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); if (!sst_drv_ctx->use_32bit_ops) { /*FIXME: do we need to wake up drain stream here, * how to get the pvt_id and msg_id */ } else { sst_wake_up_block(sst_drv_ctx, 0, str_id, IPC_IA_DRAIN_STREAM, NULL, 0); } ops->post_message(&sst_drv_ctx->ipc_post_msg_wq); retval = sst_wait_timeout(sst_drv_ctx, block); pr_debug("sst: wait for free returned %d\n", retval); mutex_lock(&sst_drv_ctx->stream_lock); sst_clean_stream(str_info); mutex_unlock(&sst_drv_ctx->stream_lock); pr_debug("SST DBG:Stream freed\n"); sst_free_block(sst_drv_ctx, block); } else { mutex_unlock(&str_info->lock); retval = -EBADRQC; pr_debug("SST DBG:BADQRC for stream\n"); } return retval; }
/** * sst_resume_stream - Send msg for resuming stream * @str_id: stream ID * * This function is called by any function which wants to resume * an already paused stream. */ int sst_resume_stream(int str_id) { int retval = 0; struct ipc_post *msg = NULL; struct stream_info *str_info; struct intel_sst_ops *ops; unsigned long irq_flags; struct sst_block *block = NULL; int pvt_id, len; struct ipc_dsp_hdr dsp_hdr; pr_debug("SST DBG:sst_resume_stream for %d\n", str_id); str_info = get_stream_info(str_id); if (!str_info) return -EINVAL; ops = sst_drv_ctx->ops; if (str_info->status == STREAM_RUNNING) return 0; if (str_info->status == STREAM_PAUSED) { if (!sst_drv_ctx->use_32bit_ops) { pvt_id = sst_assign_pvt_id(sst_drv_ctx); retval = sst_create_block_and_ipc_msg(&msg, true, sst_drv_ctx, &block, IPC_CMD, pvt_id); if (retval) return retval; sst_fill_header_mrfld(&msg->mrfld_header, IPC_CMD, str_info->task_id, 1, pvt_id); msg->mrfld_header.p.header_high.part.res_rqd = 1; len = sizeof(dsp_hdr); msg->mrfld_header.p.header_low_payload = len; sst_fill_header_dsp(&dsp_hdr, IPC_IA_RESUME_STREAM_MRFLD, str_info->pipe_id, 0); memcpy(msg->mailbox_data, &dsp_hdr, sizeof(dsp_hdr)); } else { retval = sst_create_block_and_ipc_msg(&msg, false, sst_drv_ctx, &block, IPC_IA_RESUME_STREAM, str_id); if (retval) return retval; sst_fill_header(&msg->header, IPC_IA_RESUME_STREAM, 0, str_id); } spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); ops->post_message(&sst_drv_ctx->ipc_post_msg_wq); retval = sst_wait_timeout(sst_drv_ctx, block); sst_free_block(sst_drv_ctx, block); if (!retval) { if (str_info->prev == STREAM_RUNNING) str_info->status = STREAM_RUNNING; else str_info->status = STREAM_INIT; str_info->prev = STREAM_PAUSED; } else if (retval == -SST_ERR_INVALID_STREAM_ID) { retval = -EINVAL; mutex_lock(&sst_drv_ctx->stream_lock); sst_clean_stream(str_info); mutex_unlock(&sst_drv_ctx->stream_lock); } } else { retval = -EBADRQC; pr_err("SST ERR: BADQRC for stream\n"); } return retval; }
int sst_send_byte_stream_mrfld(void *sbytes) { struct ipc_post *msg = NULL; struct snd_sst_bytes_v2 *bytes = (struct snd_sst_bytes_v2 *) sbytes; unsigned long irq_flags; u32 length; int pvt_id, ret = 0; struct sst_block *block = NULL; pr_debug("%s:\ntype:%d\nipc_msg:%x\nblock:%d\ntask_id:%x\npipe: %d\nlength:%d\n", __func__, bytes->type, bytes->ipc_msg, bytes->block, bytes->task_id, bytes->pipe_id, bytes->len); /* need some err check as this is user data, perhpas move this to the * platform driver and pass the struct */ if (sst_create_ipc_msg(&msg, true)) return -ENOMEM; pvt_id = sst_assign_pvt_id(sst_drv_ctx); sst_fill_header_mrfld(&msg->mrfld_header, bytes->ipc_msg, bytes->task_id, 1, pvt_id); msg->mrfld_header.p.header_high.part.res_rqd = bytes->block; length = bytes->len; msg->mrfld_header.p.header_low_payload = length; pr_debug("length is %d\n", length); memcpy(msg->mailbox_data, &bytes->bytes, bytes->len); if (bytes->block) { block = sst_create_block(sst_drv_ctx, bytes->ipc_msg, pvt_id); if (block == NULL) { kfree(msg); return -ENOMEM; } } spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags); list_add_tail(&msg->node, &sst_drv_ctx->ipc_dispatch_list); spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags); sst_drv_ctx->ops->post_message(&sst_drv_ctx->ipc_post_msg_wq); pr_debug("msg->mrfld_header.p.header_low_payload:%d", msg->mrfld_header.p.header_low_payload); if (bytes->block) { ret = sst_wait_timeout(sst_drv_ctx, block); if (ret) { pr_err("%s: fw returned err %d\n", __func__, ret); sst_free_block(sst_drv_ctx, block); return ret; } } if (bytes->type == SND_SST_BYTES_GET) { /* copy the reply and send back * we need to update only sz and payload */ if (bytes->block) { unsigned char *r = block->data; pr_debug("read back %d bytes", bytes->len); memcpy(bytes->bytes, r, bytes->len); } } if (bytes->block) sst_free_block(sst_drv_ctx, block); return 0; }