static int msm_lsm_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct lsm_priv *prtd = runtime->private_data; int ret = 0; if (!prtd->lsm_client) { pr_err("%s: LSM client data ptr is NULL\n", __func__); return -EINVAL; } ret = q6lsm_open(prtd->lsm_client, prtd->lsm_client->app_id); if (ret < 0) { pr_err("%s: lsm open failed, %d\n", __func__, ret); q6lsm_client_free(prtd->lsm_client); kfree(prtd); return ret; } pr_debug("%s: Session ID %d\n", __func__, prtd->lsm_client->session); prtd->lsm_client->started = false; spin_lock_init(&prtd->event_lock); init_waitqueue_head(&prtd->event_wait); runtime->private_data = prtd; return 0; }
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; }
static int msm_lsm_close(struct snd_pcm_substream *substream) { unsigned long flags; struct snd_pcm_runtime *runtime = substream->runtime; struct lsm_priv *prtd = runtime->private_data; int ret = 0; pr_debug("%s\n", __func__); if (prtd->lsm_client->started) { ret = q6lsm_stop(prtd->lsm_client, true); if (ret) pr_err("%s: session stop failed, err = %d\n", __func__, ret); else pr_debug("%s: LSM client session stopped %d\n", __func__, ret); /* * Go Ahead and try de-register sound model, * even if stop failed */ prtd->lsm_client->started = false; ret = q6lsm_deregister_sound_model(prtd->lsm_client); if (ret) pr_err("%s: dereg_snd_model failed, err = %d\n", __func__, ret); else pr_debug("%s: dereg_snd_model succesful\n", __func__); } q6lsm_close(prtd->lsm_client); q6lsm_client_free(prtd->lsm_client); spin_lock_irqsave(&prtd->event_lock, flags); kfree(prtd->event_status); prtd->event_status = NULL; spin_unlock_irqrestore(&prtd->event_lock, flags); kfree(prtd); return 0; }
static int msm_lsm_close(struct snd_pcm_substream *substream) { unsigned long flags; struct snd_pcm_runtime *runtime = substream->runtime; struct lsm_priv *prtd = runtime->private_data; pr_debug("%s\n", __func__); q6lsm_close(prtd->lsm_client); q6lsm_client_free(prtd->lsm_client); spin_lock_irqsave(&prtd->event_lock, flags); kfree(prtd->event_status); prtd->event_status = NULL; spin_unlock_irqrestore(&prtd->event_lock, flags); kfree(prtd); return 0; }
static int msm_lsm_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct lsm_priv *prtd; int ret = 0; pr_debug("%s\n", __func__); prtd = kzalloc(sizeof(struct lsm_priv), GFP_KERNEL); if (!prtd) { pr_err("%s: Failed to allocate memory for lsm_priv\n", __func__); return -ENOMEM; } prtd->substream = substream; prtd->lsm_client = q6lsm_client_alloc( (lsm_app_cb)lsm_event_handler, prtd); if (!prtd->lsm_client) { pr_err("%s: Could not allocate memory\n", __func__); kfree(prtd); return -ENOMEM; } ret = q6lsm_open(prtd->lsm_client); if (ret < 0) { pr_err("%s: lsm open failed, %d\n", __func__, ret); q6lsm_client_free(prtd->lsm_client); kfree(prtd); return ret; } pr_debug("%s: Session ID %d\n", __func__, prtd->lsm_client->session); prtd->lsm_client->started = false; spin_lock_init(&prtd->event_lock); init_waitqueue_head(&prtd->event_wait); runtime->private_data = prtd; return 0; }
static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream, unsigned int cmd, void *arg) { unsigned long flags; int ret; struct snd_lsm_sound_model snd_model; struct snd_lsm_sound_model_v2 snd_model_v2; struct snd_lsm_session_data session_data; int rc = 0; int xchg = 0; u32 size = 0; struct snd_pcm_runtime *runtime = substream->runtime; struct lsm_priv *prtd = runtime->private_data; struct snd_lsm_event_status *user = arg; struct snd_lsm_detection_params det_params; uint8_t *confidence_level = NULL; pr_debug("%s: enter cmd %x\n", __func__, cmd); switch (cmd) { case SNDRV_LSM_SET_SESSION_DATA: pr_debug("%s: set Session data\n", __func__); memcpy(&session_data, arg, sizeof(struct snd_lsm_session_data)); if (prtd) { if (session_data.app_id <= LSM_VOICE_WAKEUP_APP_ID_V2 && session_data.app_id > 0) { prtd->lsm_client->app_id = session_data.app_id; ret = q6lsm_open(prtd->lsm_client, prtd->lsm_client->app_id); if (ret < 0) { pr_err("%s: lsm open failed, %d\n", __func__, ret); q6lsm_client_free(prtd->lsm_client); kfree(prtd); return ret; } pr_debug("%s: Session ID %d\n", __func__, prtd->lsm_client->session); } else { pr_err("%s:Invalid App id for Listen client\n", __func__); rc = -EINVAL; } } else { pr_err("%s: LSM Priv data is NULL\n", __func__); rc = -EINVAL; } break; case SNDRV_LSM_REG_SND_MODEL_V2: pr_debug("%s: Registering sound model V2\n", __func__); memcpy(&snd_model_v2, arg, sizeof(struct snd_lsm_sound_model_v2)); if (snd_model_v2.num_confidence_levels > MAX_NUM_CONFIDENCE) { pr_err("%s: Invalid conf_levels = %d, maximum allowed = %d\n", __func__, snd_model_v2.num_confidence_levels, MAX_NUM_CONFIDENCE); rc = -EINVAL; break; } prtd->lsm_client->snd_model_ver_inuse = SND_MODEL_IN_USE_V2; rc = q6lsm_snd_model_buf_alloc(prtd->lsm_client, snd_model_v2.data_size); if (rc) { pr_err("%s: q6lsm buffer alloc failed V2, size %d\n", __func__, snd_model_v2.data_size); break; } if (copy_from_user(prtd->lsm_client->sound_model.data, snd_model_v2.data, snd_model_v2.data_size)) { pr_err("%s: copy from user data failed\n" "data %p size %d\n", __func__, snd_model_v2.data, snd_model_v2.data_size); q6lsm_snd_model_buf_free(prtd->lsm_client); rc = -EFAULT; break; } pr_debug("SND Model Magic no byte[0] %x,\n" "byte[1] %x, byte[2] %x byte[3] %x\n", snd_model_v2.data[0], snd_model_v2.data[1], snd_model_v2.data[2], snd_model_v2.data[3]); prtd->lsm_client->num_confidence_levels = snd_model_v2.num_confidence_levels; rc = msm_lsm_get_conf_levels(prtd->lsm_client, snd_model_v2.confidence_level); if (rc) { pr_err("%s: get_conf_levels failed, err = %d\n", __func__, rc); break; } rc = q6lsm_register_sound_model(prtd->lsm_client, snd_model_v2.detection_mode, snd_model_v2.detect_failure); if (rc < 0) { pr_err("%s: Register snd Model v2 failed =%d\n", __func__, rc); kfree(confidence_level); q6lsm_snd_model_buf_free(prtd->lsm_client); } kfree(prtd->lsm_client->confidence_levels); prtd->lsm_client->confidence_levels = NULL; break; case SNDRV_LSM_SET_PARAMS: if (!arg) { pr_err("%s: %s Invalid argument\n", __func__, "SNDRV_LSM_SET_PARAMS"); return -EINVAL; } memcpy(&det_params, arg, sizeof(det_params)); if (det_params.num_confidence_levels > MAX_NUM_CONFIDENCE) { rc = -EINVAL; break; } prtd->lsm_client->num_confidence_levels = det_params.num_confidence_levels; rc = msm_lsm_get_conf_levels(prtd->lsm_client, det_params.conf_level); if (rc) { pr_err("%s: Failed to get conf_levels, err = %d\n", __func__, rc); break; } rc = q6lsm_set_data(prtd->lsm_client, det_params.detect_mode, det_params.detect_failure); if (rc) pr_err("%s: Failed to set params, err = %d\n", __func__, rc); kfree(prtd->lsm_client->confidence_levels); prtd->lsm_client->confidence_levels = NULL; break; case SNDRV_LSM_REG_SND_MODEL: pr_debug("%s: Registering sound model\n", __func__); memcpy(&snd_model, arg, sizeof(struct snd_lsm_sound_model)); prtd->lsm_client->snd_model_ver_inuse = SND_MODEL_IN_USE_V1; rc = q6lsm_snd_model_buf_alloc(prtd->lsm_client, snd_model.data_size); if (rc) { pr_err("%s: q6lsm buffer alloc failed, size %d\n", __func__, snd_model.data_size); break; } if (copy_from_user(prtd->lsm_client->sound_model.data, snd_model.data, snd_model.data_size)) { pr_err("%s: copy from user data failed data %p size %d\n", __func__, snd_model.data, snd_model.data_size); rc = -EFAULT; q6lsm_snd_model_buf_free(prtd->lsm_client); break; } rc = q6lsm_set_kw_sensitivity_level(prtd->lsm_client, snd_model.min_keyw_confidence, snd_model.min_user_confidence); if (rc) { pr_err("%s: Error in KW sensitivity %x", __func__, rc); q6lsm_snd_model_buf_free(prtd->lsm_client); break; } rc = q6lsm_register_sound_model(prtd->lsm_client, snd_model.detection_mode, snd_model.detect_failure); if (rc < 0) { pr_err("%s: q6lsm_register_sound_model failed =%d\n", __func__, rc); q6lsm_snd_model_buf_free(prtd->lsm_client); } break; case SNDRV_LSM_DEREG_SND_MODEL: pr_debug("%s: Deregistering sound model\n", __func__); rc = q6lsm_deregister_sound_model(prtd->lsm_client); break; case SNDRV_LSM_EVENT_STATUS: pr_debug("%s: Get event status\n", __func__); atomic_set(&prtd->event_wait_stop, 0); rc = wait_event_freezable(prtd->event_wait, (cmpxchg(&prtd->event_avail, 1, 0) || (xchg = atomic_cmpxchg(&prtd->event_wait_stop, 1, 0)))); pr_debug("%s: wait_event_freezable %d event_wait_stop %d\n", __func__, rc, xchg); if (!rc && !xchg) { pr_debug("%s: New event available %ld\n", __func__, prtd->event_avail); spin_lock_irqsave(&prtd->event_lock, flags); if (prtd->event_status) { size = sizeof(*(prtd->event_status)) + prtd->event_status->payload_size; spin_unlock_irqrestore(&prtd->event_lock, flags); } else { spin_unlock_irqrestore(&prtd->event_lock, flags); rc = -EINVAL; pr_err("%s: prtd->event_status is NULL\n", __func__); break; } if (user->payload_size < prtd->event_status->payload_size) { pr_debug("%s: provided %dbytes isn't enough, needs %dbytes\n", __func__, user->payload_size, prtd->event_status->payload_size); rc = -ENOMEM; } else { memcpy(user, prtd->event_status, size); if (prtd->lsm_client->lab_enable && atomic_read(&prtd->read_abort) && prtd->event_status->status == LSM_VOICE_WAKEUP_STATUS_DETECTED) { atomic_set(&prtd->read_abort, 0); atomic_set(&prtd->buf_count, 0); prtd->appl_cnt = 0; prtd->dma_write = 0; rc = msm_lsm_queue_lab_buffer(prtd, 0); if (rc) pr_err("%s: Queue buffer failed for lab rc = %d\n", __func__, rc); else prtd->lsm_client->lab_started = true; } } } else if (xchg) { pr_debug("%s: Wait aborted\n", __func__); rc = 0; } break; case SNDRV_LSM_ABORT_EVENT: pr_debug("%s: Aborting event status wait\n", __func__); atomic_set(&prtd->event_wait_stop, 1); wake_up(&prtd->event_wait); break; case SNDRV_LSM_START: pr_debug("%s: Starting LSM client session\n", __func__); if (!prtd->lsm_client->started) { if (prtd->lsm_client->lab_enable && !prtd->lsm_client->lab_started) { atomic_set(&prtd->read_abort, 0); /* Push the first period buffer */ ret = msm_lsm_queue_lab_buffer(prtd, 0); if (ret) { pr_err("%s: failed to queue buffers for LAB read %d\n" , __func__, ret); break; } prtd->lsm_client->lab_started = true; } ret = q6lsm_start(prtd->lsm_client, true); if (!ret) { prtd->lsm_client->started = true; pr_debug("%s: LSM client session started\n", __func__); } } break; case SNDRV_LSM_STOP: { pr_debug("%s: Stopping LSM client session\n", __func__); if (prtd->lsm_client->started) { if (prtd->lsm_client->lab_enable) { atomic_set(&prtd->read_abort, 1); if (prtd->lsm_client->lab_started) { ret = q6lsm_stop_lab(prtd->lsm_client); if (ret) pr_err("%s: stop lab failed ret %d\n", __func__, ret); prtd->lsm_client->lab_started = false; } ret = msm_lsm_lab_buffer_alloc(prtd, LAB_BUFFER_DEALLOC); if (ret) pr_err("%s: lab buffer de-alloc failed rc %d", __func__, rc); } ret = q6lsm_stop(prtd->lsm_client, true); if (!ret) pr_debug("%s: LSM client session stopped %d\n", __func__, ret); prtd->lsm_client->started = false; } break; } case SNDRV_LSM_LAB_CONTROL: { u32 *enable = NULL; pr_debug("%s: ioctl %s\n", __func__, "SNDRV_LSM_LAB_CONTROL"); if (!arg) { pr_err("%s: Invalid param arg for ioctl %s session %d\n", __func__, "SNDRV_LSM_LAB_CONTROL", prtd->lsm_client->session); rc = -EINVAL; break; } enable = (int *)arg; if (!prtd->lsm_client->started) { if (prtd->lsm_client->lab_enable == *enable) { pr_info("%s: Lab for session %d already %s\n", __func__, prtd->lsm_client->session, ((*enable) ? "enabled" : "disabled")); rc = 0; break; } rc = q6lsm_lab_control(prtd->lsm_client, *enable); if (rc) pr_err("%s: ioctl %s failed rc %d to %s lab for session %d\n", __func__, "SNDRV_LAB_CONTROL", rc, ((*enable) ? "enable" : "disable"), prtd->lsm_client->session); else { rc = msm_lsm_lab_buffer_alloc(prtd, ((*enable) ? LAB_BUFFER_ALLOC : LAB_BUFFER_DEALLOC)); if (rc) pr_err("%s: msm_lsm_lab_buffer_alloc failed rc %d for %s", __func__, rc, ((*enable) ? "ALLOC" : "DEALLOC")); if (!rc) prtd->lsm_client->lab_enable = *enable; } } else { pr_err("%s: ioctl %s issued after start", __func__ , "SNDRV_LSM_LAB_CONTROL"); rc = -EINVAL; } break; } case SNDRV_LSM_STOP_LAB: if (prtd->lsm_client->lab_enable && prtd->lsm_client->lab_started) { atomic_set(&prtd->read_abort, 1); rc = q6lsm_stop_lab(prtd->lsm_client); if (rc) pr_err("%s: Lab stop failed for session %d rc %d\n" , __func__, prtd->lsm_client->session, rc); prtd->lsm_client->lab_started = false; } break; default: pr_debug("%s: Falling into default snd_lib_ioctl cmd 0x%x\n", __func__, cmd); rc = snd_pcm_lib_ioctl(substream, cmd, arg); break; } if (!rc) pr_debug("%s: leave (%d)\n", __func__, rc); else pr_err("%s: cmd 0x%x failed %d\n", __func__, cmd, rc); return rc; }