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_drain_stream - Send msg for draining stream * @str_id: stream ID * * This function is called by any function which wants to drain * a stream. */ int sst_drain_stream(int str_id, bool partial_drain) { int retval = 0, pvt_id, len; struct ipc_post *msg = NULL; struct stream_info *str_info; struct intel_sst_ops *ops; unsigned long irq_flags; struct sst_block *block = NULL; struct ipc_dsp_hdr dsp_hdr; pr_debug("SST DBG:sst_drain_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 && str_info->status != STREAM_INIT && str_info->status != STREAM_PAUSED) { pr_err("SST ERR: BADQRC for stream = %d\n", str_info->status); return -EBADRQC; } 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); pr_debug("header:%x\n", (unsigned int)msg->mrfld_header.p.header_high.full); msg->mrfld_header.p.header_high.part.res_rqd = 1; len = sizeof(u8) + sizeof(dsp_hdr); msg->mrfld_header.p.header_low_payload = len; sst_fill_header_dsp(&dsp_hdr, IPC_IA_DRAIN_STREAM_MRFLD, str_info->pipe_id, sizeof(u8)); memcpy(msg->mailbox_data, &dsp_hdr, sizeof(dsp_hdr)); memcpy(msg->mailbox_data + sizeof(dsp_hdr), &partial_drain, sizeof(u8)); } else { retval = sst_create_block_and_ipc_msg(&msg, false, sst_drv_ctx, &block, IPC_IA_DRAIN_STREAM, str_id); if (retval) return retval; sst_fill_header(&msg->header, IPC_IA_DRAIN_STREAM, 0, str_id); msg->header.part.data = partial_drain; } 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_interruptible(sst_drv_ctx, block); sst_free_block(sst_drv_ctx, block); 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; }
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; }