int q6lsm_snd_model_buf_free(struct lsm_client *client)
{
int rc;
pr_debug("%s: Session id %d\n", __func__, client->session);
if (CHECK_SESSION(client->session))
return -EINVAL;
mutex_lock(&client->cmd_lock);
rc = q6lsm_memory_unmap_regions(client,
client->sound_model.mem_map_handle);
if (rc < 0)
pr_err("%s CMD Memory_unmap_regions failed\n", __func__);
if (client->sound_model.data) {
msm_audio_ion_free(client->sound_model.client,
client->sound_model.handle);
client->sound_model.client = NULL;
client->sound_model.handle = NULL;
client->sound_model.data = NULL;
client->sound_model.phys = 0;
client->lsm_cal_phy_addr = 0;
client->lsm_cal_size = 0;
}
mutex_unlock(&client->cmd_lock);
return rc;
}
int q6lsm_deregister_sound_model(struct lsm_client *client)
{
int rc;
struct lsm_cmd_reg_snd_model cmd;
if (!client || !client->apr) {
pr_err("APR handle NULL\n");
return -EINVAL;
}
pr_debug("%s: session[%d]", __func__, client->session);
if (CHECK_SESSION(client->session))
return -EINVAL;
memset(&cmd, 0, sizeof(cmd));
q6lsm_add_hdr(client, &cmd.hdr, sizeof(cmd.hdr), false);
cmd.hdr.opcode = LSM_SESSION_CMD_DEREGISTER_SOUND_MODEL;
rc = q6lsm_apr_send_pkt(client, client->apr, &cmd.hdr, true, NULL);
if (rc < 0) {
pr_err("%s: Failed cmd opcode 0x%x, rc %d\n", __func__,
cmd.hdr.opcode, rc);
} else {
pr_debug("%s: Deregister sound model succeeded\n", __func__);
}
q6lsm_snd_model_buf_free(client);
return rc;
}
static int q6lsm_send_cal(struct lsm_client *client)
{
int rc;
struct lsm_cmd_set_params params;
struct acdb_cal_block lsm_cal;
pr_debug("%s: Session %d\n", __func__, client->session);
if (CHECK_SESSION(client->session))
return -EINVAL;
memset(&lsm_cal, 0, sizeof(lsm_cal));
get_lsm_cal(&lsm_cal);
lsm_common.common_client[client->session].session = client->session;
q6lsm_add_hdr(client, ¶ms.hdr, sizeof(params), true);
params.hdr.opcode = LSM_SESSION_CMD_SET_PARAMS;
params.data_payload_addr_lsw = lower_32_bits(client->lsm_cal_phy_addr);
params.data_payload_addr_msw = upper_32_bits(client->lsm_cal_phy_addr);
params.mem_map_handle = client->sound_model.mem_map_handle;
params.data_payload_size = lsm_cal.cal_size;
pr_debug("%s: Cal Size = %x", __func__, client->lsm_cal_size);
rc = q6lsm_apr_send_pkt(client, client->apr, ¶ms, true, NULL);
if (rc)
pr_err("%s: Failed set_params opcode 0x%x, rc %d\n",
__func__, params.hdr.opcode, rc);
return rc;
}
static int q6lsm_memory_unmap_regions(struct lsm_client *client,
uint32_t handle)
{
struct avs_cmd_shared_mem_unmap_regions unmap;
int rc = 0;
int cmd_size = 0;
if (CHECK_SESSION(client->session)) {
pr_err("%s: session[%d]", __func__, client->session);
return -EINVAL;
}
cmd_size = sizeof(struct avs_cmd_shared_mem_unmap_regions);
q6lsm_add_mmaphdr(client, &unmap.hdr, cmd_size,
true, (client->session << 8));
unmap.hdr.opcode = LSM_SESSION_CMD_SHARED_MEM_UNMAP_REGIONS;
unmap.mem_map_handle = handle;
pr_debug("%s: unmap handle 0x%x\n", __func__, unmap.mem_map_handle);
rc = q6lsm_apr_send_pkt(client, client->mmap_apr, &unmap, true,
NULL);
if (rc)
pr_err("%s: Failed mmap_regions opcode 0x%x rc %d\n",
__func__, unmap.hdr.opcode, rc);
return rc;
}
static int q6lsm_memory_map_regions(struct lsm_client *client,
dma_addr_t dma_addr_p, uint32_t dma_buf_sz,
uint32_t *mmap_p)
{
struct avs_cmd_shared_mem_map_regions *mmap_regions = NULL;
struct avs_shared_map_region_payload *mregions = NULL;
void *mmap_region_cmd = NULL;
void *payload = NULL;
int rc;
int cmd_size = 0;
pr_debug("%s: dma_addr_p 0x%pa, dma_buf_sz %d, mmap_p 0x%p, session %d\n",
__func__, &dma_addr_p, dma_buf_sz, mmap_p,
client->session);
if (CHECK_SESSION(client->session)) {
pr_err("%s: session[%d]", __func__, client->session);
return -EINVAL;
}
cmd_size = sizeof(struct avs_cmd_shared_mem_map_regions) +
sizeof(struct avs_shared_map_region_payload);
mmap_region_cmd = kzalloc(cmd_size, GFP_KERNEL);
if (!mmap_region_cmd) {
pr_err("%s: memory allocation failed\n", __func__);
return -ENOMEM;
}
mmap_regions = (struct avs_cmd_shared_mem_map_regions *)mmap_region_cmd;
q6lsm_add_mmaphdr(client, &mmap_regions->hdr, cmd_size, true,
(client->session << 8));
mmap_regions->hdr.opcode = LSM_SESSION_CMD_SHARED_MEM_MAP_REGIONS;
mmap_regions->mem_pool_id = ADSP_MEMORY_MAP_SHMEM8_4K_POOL;
mmap_regions->num_regions = 1;
mmap_regions->property_flag = 0x00;
payload = ((u8 *)mmap_region_cmd +
sizeof(struct avs_cmd_shared_mem_map_regions));
mregions = (struct avs_shared_map_region_payload *)payload;
mregions->shm_addr_lsw = lower_32_bits(dma_addr_p);
mregions->shm_addr_msw = upper_32_bits(dma_addr_p);
mregions->mem_size_bytes = dma_buf_sz;
rc = q6lsm_apr_send_pkt(client, client->mmap_apr, mmap_region_cmd,
true, mmap_p);
if (rc)
pr_err("%s: Failed mmap_regions opcode 0x%x, rc %d\n",
__func__, mmap_regions->hdr.opcode, rc);
pr_debug("%s: leave %d\n", __func__, rc);
kfree(mmap_region_cmd);
return rc;
}
static int q6lsm_send_cal(struct lsm_client *client)
{
int rc = 0;
struct lsm_cmd_set_params params;
struct cal_block_data *cal_block = NULL;
pr_debug("%s: Session id %d\n", __func__, client->session);
if (CHECK_SESSION(client->session)) {
pr_err("%s: session[%d]", __func__, client->session);
return -EINVAL;
}
if (lsm_common.cal_data == NULL)
goto done;
mutex_lock(&lsm_common.cal_data->lock);
cal_block = cal_utils_get_only_cal_block(lsm_common.cal_data);
if (cal_block == NULL)
goto unlock;
if (cal_block->cal_data.size <= 0) {
pr_debug("%s: No cal to send!\n", __func__);
rc = -EINVAL;
goto unlock;
}
if (cal_block->cal_data.size != client->lsm_cal_size) {
pr_err("%s: Cal size %zd doesn't match lsm cal size %d\n",
__func__, cal_block->cal_data.size,
client->lsm_cal_size);
rc = -EINVAL;
goto unlock;
}
/* Cache mmap address, only map once or if new addr */
lsm_common.common_client[client->session].session = client->session;
q6lsm_add_hdr(client, ¶ms.hdr, sizeof(params), true);
params.hdr.opcode = LSM_SESSION_CMD_SET_PARAMS;
params.data_payload_addr_lsw = lower_32_bits(client->lsm_cal_phy_addr);
params.data_payload_addr_msw = upper_32_bits(client->lsm_cal_phy_addr);
params.mem_map_handle = client->sound_model.mem_map_handle;
params.data_payload_size = cal_block->cal_data.size;
pr_debug("%s: Cal Size = %zd", __func__, cal_block->cal_data.size);
rc = q6lsm_apr_send_pkt(client, client->apr, ¶ms, true, NULL);
if (rc)
pr_err("%s: Failed set_params opcode 0x%x, rc %d\n",
__func__, params.hdr.opcode, rc);
unlock:
mutex_unlock(&lsm_common.cal_data->lock);
done:
return rc;
}
void q6lsm_client_free(struct lsm_client *client)
{
if (!client)
return;
if (CHECK_SESSION(client->session)) {
pr_err("%s: Invalid Session %d", __func__, client->session);
return;
}
apr_deregister_port(client->apr, ((client->session) << 8 | client->session));
client->mmap_apr = NULL;
q6lsm_session_free(client);
q6lsm_mmap_apr_dereg();
mutex_destroy(&client->cmd_lock);
kfree(client);
}
struct lsm_client *q6lsm_client_alloc(lsm_app_cb cb, void *priv)
{
struct lsm_client *client;
int n;
pr_debug("%s: enter\n", __func__);
client = kzalloc(sizeof(struct lsm_client), GFP_KERNEL);
if (!client)
return NULL;
n = q6lsm_session_alloc(client);
if (n <= 0) {
kfree(client);
return NULL;
}
client->session = n;
client->cb = cb;
client->priv = priv;
pr_debug("%s:Client session %d\n", __func__, client->session);
if (CHECK_SESSION(client->session)) {
kfree(client);
return NULL;
}
pr_debug("%s:Client Session %d\n", __func__, client->session);
client->apr = apr_register("ADSP", "LSM", q6lsm_callback,
((client->session) << 8 | client->session),
client);
if (client->apr == NULL) {
pr_err("%s: Registration with APR failed\n", __func__);
goto fail;
}
pr_debug("%s Registering the common port with APR\n", __func__);
client->mmap_apr = q6lsm_mmap_apr_reg();
if (!client->mmap_apr) {
pr_err("%s: APR registration failed\n", __func__);
goto fail;
}
init_waitqueue_head(&client->cmd_wait);
mutex_init(&client->cmd_lock);
atomic_set(&client->cmd_state, CMD_STATE_CLEARED);
pr_debug("%s: New client allocated\n", __func__);
return client;
fail:
q6lsm_client_free(client);
return NULL;
}
