static int snddev_icodec_set_device_volume_impl( struct msm_snddev_info *dev_info, u32 volume) { struct snddev_icodec_state *icodec; u8 afe_path_id; int rc = 0; icodec = dev_info->private_data; if (icodec->data->capability & SNDDEV_CAP_RX) { if (support_aic3254) return rc; afe_path_id = AFE_HW_PATH_CODEC_RX; } else afe_path_id = AFE_HW_PATH_CODEC_TX; if (icodec->data->dev_vol_type & SNDDEV_DEV_VOL_DIGITAL) { if (support_adie) { rc = adie_codec_set_device_digital_volume(icodec->adie_path, icodec->data->channel_mode == REAL_STEREO_CHANNEL_MODE ? 2 : icodec->data->channel_mode, volume); if (rc < 0) { pr_aud_err("%s: unable to set_device_digital_volume for" "%s volume in percentage = %u\n", __func__, dev_info->name, volume); return rc; } } } else if (icodec->data->dev_vol_type & SNDDEV_DEV_VOL_ANALOG) { if (support_adie) { rc = adie_codec_set_device_analog_volume(icodec->adie_path, icodec->data->channel_mode == REAL_STEREO_CHANNEL_MODE ? 2 : icodec->data->channel_mode, volume); if (rc < 0) { pr_aud_err("%s: unable to set_device_analog_volume for" "%s volume in percentage = %u\n", __func__, dev_info->name, volume); return rc; } } } else { pr_aud_err("%s: Invalid device volume control\n", __func__); return -EPERM; } return rc; }
static int __init elite_audio_init(void) { int ret; #ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION int retval = 0; #endif pr_aud_info("%s", __func__); msm8960_snd_device = platform_device_alloc("soc-audio", 0); if (!msm8960_snd_device) { pr_aud_err("%s, Platform device allocation failed\n", __func__); return -ENOMEM; } platform_set_drvdata(msm8960_snd_device, &snd_soc_card_msm8960); ret = platform_device_add(msm8960_snd_device); if (ret) { pr_aud_err("%s, Platform device add failed\n", __func__); platform_device_put(msm8960_snd_device); return ret; } mutex_init(&audio_notifier_lock); pr_aud_info("%s: register cable detect func for dock", __func__); ret = cable_detect_register_notifier(&audio_dock_notifier); #ifdef CONFIG_AUDIO_USAGE_FOR_POWER_CONSUMPTION /* Create two audio status file nodes, audio_speaker_t and * audio_headset_t under /sys/audio_stats/ */ if (audio_stat_kobj == NULL) { audio_stat_kobj = kobject_create_and_add("audio_stats", NULL); retval = sysfs_create_file(audio_stat_kobj, attrs[0]); if (!retval) { pr_err("Speaker file node creation failed under kobject\n"); } retval = sysfs_create_file(audio_stat_kobj, attrs[1]); if (!retval) { pr_err("Headset file node creation failed under kobject\n"); } } #endif htc_8960_register_q6asm_ops(&qops); htc_8960_register_pcm_routing_ops(&rops); acoustic_register_ops(&acoustic); return ret; }
static int audio_mvs_stop(struct audio_mvs_info_type *audio) { int rc = 0; struct audio_mvs_release_msg release_msg; pr_aud_info("%s:\n", __func__); /* Release MVS. */ memset(&release_msg, 0, sizeof(release_msg)); release_msg.client_id = cpu_to_be32(MVS_CLIENT_ID_VOIP); msm_rpc_setup_req(&release_msg.rpc_hdr, audio->rpc_prog, audio->rpc_ver, MVS_RELEASE_PROC); audio->rpc_status = RPC_STATUS_FAILURE; rc = msm_rpc_write(audio->rpc_endpt, &release_msg, sizeof(release_msg)); if (rc >= 0) { pr_debug("%s: RPC write for release done\n", __func__); rc = wait_event_timeout(audio->wait, (audio->rpc_status != RPC_STATUS_FAILURE), 1 * HZ); if (rc > 0) { pr_debug("%s: Wait event for release succeeded\n", __func__); audio->state = AUDIO_MVS_STOPPED; /* Un-block read in case it is waiting for data. */ wake_up(&audio->out_wait); rc = 0; } else { pr_aud_err("%s: Wait event for release failed %d\n", __func__, rc); } } else { pr_aud_err("%s: RPC write for release failed %d\n", __func__, rc); } /* Allow sleep. */ wake_unlock(&audio->suspend_lock); wake_unlock(&audio->idle_lock); return rc; }
static int audio_mvs_setup_voc(struct audio_mvs_info_type *audio) { int rc = 0; struct audio_mvs_set_voc_mode_msg set_voc_mode_msg; pr_debug("%s:\n", __func__); /* Set EVRC mode. */ memset(&set_voc_mode_msg, 0, sizeof(set_voc_mode_msg)); set_voc_mode_msg.min_rate = cpu_to_be32(audio->rate_type); set_voc_mode_msg.max_rate = cpu_to_be32(audio->rate_type); msm_rpc_setup_req(&set_voc_mode_msg.rpc_hdr, audio->rpc_prog, audio->rpc_ver, MVS_VOC_SET_FRAME_RATE_PROC); audio->rpc_status = RPC_STATUS_FAILURE; rc = msm_rpc_write(audio->rpc_endpt, &set_voc_mode_msg, sizeof(set_voc_mode_msg)); if (rc >= 0) { pr_debug("%s: RPC write for set voc mode done\n", __func__); rc = wait_event_timeout(audio->wait, (audio->rpc_status != RPC_STATUS_FAILURE), 1 * HZ); if (rc > 0) { pr_debug("%s: Wait event for set voc mode succeeded\n", __func__); /* Save the MVS configuration information. */ audio->frame_mode = MVS_FRAME_MODE_VOC_RX; rc = 0; } else { pr_aud_err("%s: Wait event for set voc mode failed %d\n", __func__, rc); } } else { pr_aud_err("%s: RPC write for set voc mode failed %d\n", __func__, rc); } return rc; }
static int msm_device_volume_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { int rc = -EPERM; struct msm_snddev_info *dev_info; int dev_id = ucontrol->value.integer.value[0]; int volume = ucontrol->value.integer.value[1]; MM_DBG("dev_id = %d, volume = %d\n", dev_id, volume); pr_aud_info("[ALSA] msm_set_device_volume: dev %d, volume %d\n", dev_id, volume); dev_info = audio_dev_ctrl_find_dev(dev_id); if (IS_ERR(dev_info)) { rc = PTR_ERR(dev_info); pr_aud_err("%s: audio_dev_ctrl_find_dev failed. %ld \n", __func__, PTR_ERR(dev_info)); return rc; } MM_DBG("dev_name = %s dev_id = %d, volume = %d\n", dev_info->name, dev_id, volume); if (dev_info->dev_ops.set_device_volume) rc = dev_info->dev_ops.set_device_volume(dev_info, volume); else { pr_aud_info("%s : device %s does not support device volume " "control.", __func__, dev_info->name); return -EPERM; } return rc; }
void shooter_u_snddev_bmic_pamp_on(int en) { int ret; pr_aud_info("%s %d\n", __func__, en); if (en) { ret = pm8058_micbias_enable(OTHC_MICBIAS_1, OTHC_SIGNAL_ALWAYS_ON); if (ret) pr_aud_err("%s: Enabling back mic power failed\n", __func__); } else { ret = pm8058_micbias_enable(OTHC_MICBIAS_1, OTHC_SIGNAL_OFF); if (ret) pr_aud_err("%s: Enabling back mic power failed\n", __func__); } }
static void audio_out_listener(u32 evt_id, union auddev_evt_data *evt_payload, void *private_data) { struct audio *audio = private_data; switch (evt_id) { case AUDDEV_EVT_DEV_RDY: MM_DBG(":AUDDEV_EVT_DEV_RDY\n"); audio->source |= (0x1 << evt_payload->routing_id); if (audio->running == 1 && audio->enabled == 1) audpp_route_stream(audio->dec_id, audio->source); break; case AUDDEV_EVT_DEV_RLS: MM_DBG(":AUDDEV_EVT_DEV_RLS\n"); audio->source &= ~(0x1 << evt_payload->routing_id); if (audio->running == 1 && audio->enabled == 1) audpp_route_stream(audio->dec_id, audio->source); break; case AUDDEV_EVT_STREAM_VOL_CHG: audio->vol_pan.volume = evt_payload->session_vol; MM_DBG(":AUDDEV_EVT_STREAM_VOL_CHG, stream vol %d\n", audio->vol_pan.volume); if (audio->running) audpp_dsp_set_vol_pan(audio->dec_id, &audio->vol_pan, POPP); break; default: pr_aud_err("ERROR:wrong event\n"); break; } }
static long fm_audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct audio *audio = file->private_data; int rc = -EINVAL; mutex_lock(&audio->lock); switch (cmd) { case AUDIO_START: pr_aud_info("%s: AUDIO_START\n", __func__); rc = fm_audio_enable(audio); break; case AUDIO_STOP: pr_aud_info("%s: AUDIO_STOP\n", __func__); rc = fm_audio_disable(audio); audio->running = 0; audio->enabled = 0; break; case AUDIO_GET_SESSION_ID: if (copy_to_user((void *) arg, &audio->dec_id, sizeof(unsigned short))) rc = -EFAULT; else rc = 0; break; default: rc = -EINVAL; pr_aud_err("%s: Un supported IOCTL\n", __func__); } mutex_unlock(&audio->lock); return rc; }
int msm_clear_all_session() { int rc = 0; int i = 0, j = 0; pr_aud_info("%s:\n", __func__); mutex_lock(&routing_info.adm_mutex); mutex_lock(&routing_info.copp_list_mutex); for (j = 1; j < MAX_SESSIONS; j++) { for (i = 0; i < AFE_MAX_PORTS; i++) { if (routing_info.copp_list[j][i] != DEVICE_IGNORE) { rc = adm_close( routing_info.copp_list[j][i]); if (rc < 0) { pr_aud_err("%s: adm close fail copp[%d]" "session[%d] rc[%d]\n", __func__, routing_info.copp_list[j][i], j, rc); continue; } routing_info.copp_list[j][i] = DEVICE_IGNORE; rc = 0; } } } mutex_unlock(&routing_info.copp_list_mutex); mutex_unlock(&routing_info.adm_mutex); return rc; }
int adie_codec_set_device_analog_volume(struct adie_codec_path *path_ptr, u32 num_channels, u32 volume /* in percentage */) { pr_aud_err("%s: analog device volume not supported\n", __func__); return -EPERM; }
void verdi_lte_reset_timpani(void) { pr_aud_err("hard reset timpani\n"); gpio_set_value(VERDI_LTE_AUD_QTR_RESET, 0); mdelay(10); gpio_set_value(VERDI_LTE_AUD_QTR_RESET, 1); }
void verdi_lte_reset_3254(void) { pr_aud_err("hard reset aic3254\n"); gpio_set_value(PM8058_GPIO_PM_TO_SYS(VERDI_LTE_AUD_CODEC_RST), 0); mdelay(1); gpio_set_value(PM8058_GPIO_PM_TO_SYS(VERDI_LTE_AUD_CODEC_RST), 1); }
int msm_clear_session_id(int session_id) { int rc = 0; int i = 0; if (session_id < 1 || session_id > 8) return -EINVAL; pr_debug("%s: session[%d]\n", __func__, session_id); mutex_lock(&routing_info.adm_mutex); mutex_lock(&routing_info.copp_list_mutex); for (i = 0; i < AFE_MAX_PORTS; i++) { if (routing_info.copp_list[session_id][i] != DEVICE_IGNORE) { rc = adm_close(routing_info.copp_list[session_id][i]); if (rc < 0) { pr_aud_err("%s: adm close fail port[%d] rc[%d]\n", __func__, routing_info.copp_list[session_id][i], rc); continue; } routing_info.copp_list[session_id][i] = DEVICE_IGNORE; rc = 0; } } mutex_unlock(&routing_info.copp_list_mutex); mutex_unlock(&routing_info.adm_mutex); return rc; }
int msm8960_enable_codec_ext_clk( struct snd_soc_codec *codec, int enable) { pr_debug("%s: enable = %d\n", __func__, enable); if (enable) { clk_users++; pr_debug("%s: clk_users = %d\n", __func__, clk_users); if (clk_users != 1) return 0; codec_clk = clk_get(NULL, "i2s_spkr_osr_clk"); if (codec_clk) { clk_set_rate(codec_clk, TABLA_EXT_CLK_RATE); clk_enable(codec_clk); tabla_mclk_enable(codec, 1); } else { pr_aud_err("%s: Error setting Tabla MCLK\n", __func__); clk_users--; return -EINVAL; } } else { pr_debug("%s: clk_users = %d\n", __func__, clk_users); if (clk_users == 0) return 0; clk_users--; if (!clk_users) { pr_debug("%s: disabling MCLK. clk_users = %d\n", __func__, clk_users); clk_disable(codec_clk); clk_put(codec_clk); tabla_mclk_enable(codec, 0); } } return 0; }
/* must be called with audio->lock held */ static int audio_enable(struct audio *audio) { pr_aud_info("audio_enable\n"); if (audio->enabled) return 0; /* refuse to start if we're not ready */ if (!audio->out[0].used || !audio->out[1].used) return -EIO; /* we start buffers 0 and 1, so buffer 0 will be the * next one the dsp will want */ audio->out_tail = 0; audio->out_needed = 0; audio_prevent_sleep(audio); if (audpp_enable(-1, audio_dsp_event, audio)) { pr_aud_err("audpp_enable() failed\n"); audio_allow_sleep(audio); return -ENODEV; } audio->enabled = 1; htc_pwrsink_set(PWRSINK_AUDIO, 100); return 0; }
static int snddev_mi2s_probe(struct platform_device *pdev) { int rc = 0; struct snddev_mi2s_data *pdata; struct msm_snddev_info *dev_info; if (!pdev || !pdev->dev.platform_data) { printk(KERN_ALERT "Invalid caller\n"); return -ENODEV; } pdata = pdev->dev.platform_data; dev_info = kzalloc(sizeof(struct msm_snddev_info), GFP_KERNEL); if (!dev_info) { pr_aud_err("%s: uneable to allocate memeory for msm_snddev_info\n", __func__); return -ENOMEM; } dev_info->name = pdata->name; dev_info->copp_id = pdata->copp_id; dev_info->dev_ops.open = snddev_mi2s_open; dev_info->dev_ops.close = snddev_mi2s_close; dev_info->private_data = (void *)pdata; dev_info->dev_ops.set_freq = snddev_mi2s_set_freq; dev_info->capability = pdata->capability; dev_info->opened = 0; dev_info->sample_rate = pdata->sample_rate; msm_snddev_register(dev_info); pr_aud_info("%s: probe done for %s\n", __func__, pdata->name); return rc; }
/* ------------------- dsp preproc event handler--------------------- */ static void audpreproc_dsp_event(void *data, unsigned id, void *msg) { struct audio_in *audio = data; switch (id) { case AUDPREPROC_ERROR_MSG: { struct audpreproc_err_msg *err_msg = msg; pr_aud_err("ERROR_MSG: stream id %d err idx %d\n", err_msg->stream_id, err_msg->aud_preproc_err_idx); /* Error case */ wake_up(&audio->wait_enable); break; } case AUDPREPROC_CMD_CFG_DONE_MSG: { MM_DBG("CMD_CFG_DONE_MSG \n"); break; } case AUDPREPROC_CMD_ENC_CFG_DONE_MSG: { struct audpreproc_cmd_enc_cfg_done_msg *enc_cfg_msg = msg; MM_DBG("CMD_ENC_CFG_DONE_MSG: stream id %d enc type \ 0x%8x\n", enc_cfg_msg->stream_id, enc_cfg_msg->rec_enc_type); /* Encoder enable success */ if (enc_cfg_msg->rec_enc_type & ENCODE_ENABLE) audamrnb_in_param_config(audio); else { /* Encoder disable success */ audio->running = 0; audamrnb_in_record_config(audio, 0); } break; } case AUDPREPROC_CMD_ENC_PARAM_CFG_DONE_MSG: { MM_DBG("CMD_ENC_PARAM_CFG_DONE_MSG \n"); audamrnb_in_mem_config(audio); break; } case AUDPREPROC_AFE_CMD_AUDIO_RECORD_CFG_DONE_MSG: { MM_DBG("AFE_CMD_AUDIO_RECORD_CFG_DONE_MSG \n"); wake_up(&audio->wait_enable); break; } default: pr_aud_err("Unknown Event id %d\n", id); } }
int auddev_register_evt_listner(u32 evt_id, u32 clnt_type, u32 clnt_id, void (*listner)(u32 evt_id, union auddev_evt_data *evt_payload, void *private_data), void *private_data) { int rc; struct msm_snd_evt_listner *callback = NULL; struct msm_snd_evt_listner *new_cb; #ifdef CONFIG_MACH_SHOOTER_U pr_aud_info("%s(%d) ++\n", __func__, __LINE__); #endif new_cb = kzalloc(sizeof(struct msm_snd_evt_listner), GFP_KERNEL); #ifdef CONFIG_MACH_SHOOTER_U pr_aud_info("%s(%d) \n", __func__, __LINE__); #endif if (!new_cb) { pr_aud_err("No memory to add new listener node\n"); return -ENOMEM; } mutex_lock(&session_lock); #ifdef CONFIG_MACH_SHOOTER_U pr_aud_info("%s(%d) \n", __func__, __LINE__); #endif new_cb->cb_next = NULL; new_cb->auddev_evt_listener = listner; new_cb->evt_id = evt_id; new_cb->clnt_type = clnt_type; new_cb->clnt_id = clnt_id; new_cb->private_data = private_data; if (event.cb == NULL) { event.cb = new_cb; new_cb->cb_prev = NULL; } else { callback = event.cb; for (; ;) { if (callback->cb_next == NULL) break; else { callback = callback->cb_next; continue; } } #ifdef CONFIG_MACH_SHOOTER_U pr_aud_info("%s(%d) \n", __func__, __LINE__); #endif callback->cb_next = new_cb; new_cb->cb_prev = callback; } event.num_listner++; mutex_unlock(&session_lock); #ifdef CONFIG_MACH_SHOOTER_U pr_aud_info("%s(%d) --\n", __func__, __LINE__); #endif rc = 0; return rc; }
static int __init spi_aic3254_init(void) { int ret = 0; struct ecodec_aic3254_state *codec_drv = &codec_clk; pr_aud_info("%s\n", __func__); mutex_init(&lock); ret = spi_register_driver(&spi_aic3254); if (ret < 0) { pr_aud_err("%s:failed to register spi driver(%d)\n", __func__, ret); return ret; } ret = misc_register(&aic3254_misc); if (ret < 0) { pr_aud_err("%s:failed to register misc device\n", __func__); spi_unregister_driver(&spi_aic3254); return ret; } #if defined(CONFIG_ARCH_MSM7X30) codec_drv->rx_mclk = clk_get(NULL, "mi2s_codec_rx_m_clk"); if (IS_ERR(codec_drv->rx_mclk)) { pr_aud_err("%s:failed to get mi2s mclk\n", __func__); misc_deregister(&aic3254_misc); spi_unregister_driver(&spi_aic3254); return -ENODEV; } codec_drv->rx_sclk = clk_get(NULL, "mi2s_codec_rx_s_clk"); if (IS_ERR(codec_drv->rx_sclk)) { pr_aud_err("%s:failed to get mi2s sclk\n", __func__); misc_deregister(&aic3254_misc); spi_unregister_driver(&spi_aic3254); clk_put(codec_drv->rx_mclk); return -ENODEV; } #endif pm_qos_add_request(&codec_drv->pm_qos_req, PM_QOS_CPU_DMA_LATENCY, PM_QOS_DEFAULT_VALUE); wake_lock_init(&codec_drv->wakelock, WAKE_LOCK_SUSPEND, "aic3254_suspend_lock"); return 0; }
void doubleshot_snddev_bmic_pamp_on(int en) { int ret; pr_aud_info("%s %d\n", __func__, en); if (en) { ret = pm8058_micbias_enable(OTHC_MICBIAS_1, OTHC_SIGNAL_ALWAYS_ON); if (ret) pr_aud_err("%s: Enabling back mic power failed\n", __func__); gpio_direction_output(PM8058_GPIO_PM_TO_SYS(DOUBLESHOT_AUD_MIC_SEL), 0); } else { ret = pm8058_micbias_enable(OTHC_MICBIAS_1, OTHC_SIGNAL_OFF); if (ret) pr_aud_err("%s: Enabling back mic power failed\n", __func__); } }
static void msm_snddev_dmic_sec_power(int en) { pr_aud_err("%s", __func__); if (en) msm_snddev_enable_dmic_sec_power(); else msm_snddev_disable_dmic_sec_power(); }
int msm_set_voc_route(struct msm_snddev_info *dev_info, int stream_type, int dev_id) { int rc = 0; u64 session_mask = 0; if (dev_info == NULL) { pr_aud_err("%s: invalid param\n", __func__); return -EINVAL; } mutex_lock(&session_lock); switch (stream_type) { case AUDIO_ROUTE_STREAM_VOICE_RX: if (audio_dev_ctrl.voice_rx_dev) audio_dev_ctrl.voice_rx_dev->sessions &= ~0xFFFF; if (!(dev_info->capability & SNDDEV_CAP_RX) | !(dev_info->capability & SNDDEV_CAP_VOICE)) { rc = -EINVAL; break; } audio_dev_ctrl.voice_rx_dev = dev_info; if (audio_dev_ctrl.voice_rx_dev) { session_mask = ((u64)0x1) << (MAX_BIT_PER_CLIENT * \ ((int)AUDDEV_CLNT_VOC-1)); audio_dev_ctrl.voice_rx_dev->sessions |= session_mask; } routing_info.voice_rx_dev_id = dev_id; break; case AUDIO_ROUTE_STREAM_VOICE_TX: if (audio_dev_ctrl.voice_tx_dev) audio_dev_ctrl.voice_tx_dev->sessions &= ~0xFFFF; if (!(dev_info->capability & SNDDEV_CAP_TX) | !(dev_info->capability & SNDDEV_CAP_VOICE)) { rc = -EINVAL; break; } audio_dev_ctrl.voice_tx_dev = dev_info; if (audio_dev_ctrl.voice_rx_dev) { session_mask = ((u64)0x1) << (MAX_BIT_PER_CLIENT * \ ((int)AUDDEV_CLNT_VOC-1)); audio_dev_ctrl.voice_tx_dev->sessions |= session_mask; } routing_info.voice_tx_dev_id = dev_id; break; default: rc = -EINVAL; } mutex_unlock(&session_lock); return rc; }
static int snddev_icodec_close(struct msm_snddev_info *dev_info) { int rc = 0; struct snddev_icodec_state *icodec; struct snddev_icodec_drv_state *drv = &snddev_icodec_drv; if (!dev_info) { rc = -EINVAL; goto error; } icodec = dev_info->private_data; if (icodec->data->capability & SNDDEV_CAP_RX) { mutex_lock(&drv->rx_lock); if (!drv->rx_active) { mutex_unlock(&drv->rx_lock); pr_aud_err("%s: rx_active not set, return\n", __func__); rc = -EPERM; goto error; } rc = snddev_icodec_close_rx(icodec); if (!IS_ERR_VALUE(rc)) drv->rx_active = 0; else pr_aud_err("%s: close rx failed, rc = %d\n", __func__, rc); mutex_unlock(&drv->rx_lock); } else { mutex_lock(&drv->tx_lock); if (!drv->tx_active) { mutex_unlock(&drv->tx_lock); pr_aud_err("%s: tx_active not set, return\n", __func__); rc = -EPERM; goto error; } rc = snddev_icodec_close_tx(icodec); if (!IS_ERR_VALUE(rc)) drv->tx_active = 0; else pr_aud_err("%s: close tx failed, rc = %d\n", __func__, rc); mutex_unlock(&drv->tx_lock); } error: return rc; }
static int msm8960_spkramp_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { pr_aud_info("%s() name = %s, %x\n", __func__, w->name, SND_SOC_DAPM_EVENT_ON(event)); if (SND_SOC_DAPM_EVENT_ON(event)) { if (!strncmp(w->name, "Ext Spk Bottom Pos", 18)) msm8960_ext_spk_power_amp_on(BOTTOM_SPK_AMP_POS); else if (!strncmp(w->name, "Ext Spk Bottom Neg", 18)) msm8960_ext_spk_power_amp_on(BOTTOM_SPK_AMP_NEG); else if (!strncmp(w->name, "Ext Spk Top Pos", 15)) msm8960_ext_spk_power_amp_on(TOP_SPK_AMP_POS); else if (!strncmp(w->name, "Ext Spk Top Neg", 15)) msm8960_ext_spk_power_amp_on(TOP_SPK_AMP_NEG); else if (!strncmp(w->name, "Dock Spk Pos", 12)) msm8960_ext_spk_power_amp_on(DOCK_SPK_AMP_POS); else if (!strncmp(w->name, "Dock Spk Neg", 12)) msm8960_ext_spk_power_amp_on(DOCK_SPK_AMP_NEG); else { pr_aud_err("%s() Invalid Speaker Widget = %s\n", __func__, w->name); return -EINVAL; } } else { if (!strncmp(w->name, "Ext Spk Bottom Pos", 18)) msm8960_ext_spk_power_amp_off(BOTTOM_SPK_AMP_POS); else if (!strncmp(w->name, "Ext Spk Bottom Neg", 18)) msm8960_ext_spk_power_amp_off(BOTTOM_SPK_AMP_NEG); else if (!strncmp(w->name, "Ext Spk Top Pos", 15)) msm8960_ext_spk_power_amp_off(TOP_SPK_AMP_POS); else if (!strncmp(w->name, "Ext Spk Top Neg", 15)) msm8960_ext_spk_power_amp_off(TOP_SPK_AMP_NEG); else if (!strncmp(w->name, "Dock Spk Pos", 12)) msm8960_ext_spk_power_amp_off(DOCK_SPK_AMP_POS); else if (!strncmp(w->name, "Dock Spk Neg", 12)) msm8960_ext_spk_power_amp_off(DOCK_SPK_AMP_NEG); else { pr_aud_err("%s() Invalid Speaker Widget = %s\n", __func__, w->name); return -EINVAL; } } return 0; }
int msm_snddev_set_enc(int popp_id, int copp_id, int set, int rate, int mode) { int topology; int tbl_idx; int rc = 0, i = 0; mutex_lock(&routing_info.adm_mutex); if (set) { mutex_lock(&adm_tx_topology_tbl.lock); tbl_idx = check_tx_copp_topology(popp_id); if (tbl_idx == -ENOENT) topology = DEFAULT_COPP_TOPOLOGY; else { topology = adm_tx_topology_tbl.topolog_id[tbl_idx]; rate = 16000; } mutex_unlock(&adm_tx_topology_tbl.lock); rc = adm_open(copp_id, popp_id, LIVE_RECORDING, rate, mode, topology); if (rc < 0) { pr_aud_err("%s: adm open fail rc[%d]\n", __func__, rc); rc = -EINVAL; goto fail_cmd; } msm_set_copp_id(popp_id, copp_id); } else { for (i = 0; i < AFE_MAX_PORTS; i++) { if (routing_info.copp_list[popp_id][i] == copp_id) { rc = adm_close(copp_id); if (rc < 0) { pr_aud_err("%s: adm close fail copp[%d]" "rc[%d]\n", __func__, copp_id, rc); rc = -EINVAL; goto fail_cmd; } msm_clear_copp_id(popp_id, copp_id); break; } } } fail_cmd: mutex_unlock(&routing_info.adm_mutex); return rc; }
static int msm8960_aux_pcm_get_gpios(void) { int ret = 0; pr_debug("%s\n", __func__); ret = gpio_request(GPIO_AUX_PCM_DOUT, "AUX PCM DOUT"); if (ret < 0) { pr_aud_err("%s: Failed to request gpio(%d): AUX PCM DOUT", __func__, GPIO_AUX_PCM_DOUT); goto fail_dout; } ret = gpio_request(GPIO_AUX_PCM_DIN, "AUX PCM DIN"); if (ret < 0) { pr_aud_err("%s: Failed to request gpio(%d): AUX PCM DIN", __func__, GPIO_AUX_PCM_DIN); goto fail_din; } ret = gpio_request(GPIO_AUX_PCM_SYNC, "AUX PCM SYNC"); if (ret < 0) { pr_aud_err("%s: Failed to request gpio(%d): AUX PCM SYNC", __func__, GPIO_AUX_PCM_SYNC); goto fail_sync; } ret = gpio_request(GPIO_AUX_PCM_CLK, "AUX PCM CLK"); if (ret < 0) { pr_aud_err("%s: Failed to request gpio(%d): AUX PCM CLK", __func__, GPIO_AUX_PCM_CLK); goto fail_clk; } return 0; fail_clk: gpio_free(GPIO_AUX_PCM_SYNC); fail_sync: gpio_free(GPIO_AUX_PCM_DIN); fail_din: gpio_free(GPIO_AUX_PCM_DOUT); fail_dout: return ret; }
static void msm_snddev_disable_dmic_sec_power(void) { pr_aud_err("%s", __func__); msm_snddev_disable_dmic_power(); #ifdef CONFIG_PMIC8058_OTHC pm8058_micbias_enable(OTHC_MICBIAS_2, OTHC_SIGNAL_OFF); #endif }
void holiday_imic_pamp_on_without_audience(int en) { int ret; pr_aud_info("%s %d\n", __func__, en); holiday_snddev_bmic_pamp_on(en); if (en) { ret = pm8058_micbias_enable(OTHC_MICBIAS_0, OTHC_SIGNAL_ALWAYS_ON); if (ret) pr_aud_err("%s: Enabling int mic power failed\n", __func__); } else { ret = pm8058_micbias_enable(OTHC_MICBIAS_0, OTHC_SIGNAL_OFF); if (ret) pr_aud_err("%s: Enabling int mic power failed\n", __func__); } }
/* ------------------- dsp audrec event handler--------------------- */ static void audrec_dsp_event(void *data, unsigned id, size_t len, void (*getevent)(void *ptr, size_t len)) { struct audio_in *audio = data; switch (id) { case AUDREC_CMD_MEM_CFG_DONE_MSG: { MM_DBG("CMD_MEM_CFG_DONE MSG DONE\n"); audio->running = 1; if ((!audio->in_call && (audio->dev_cnt > 0)) || (audio->in_call && (audio->voice_state == VOICE_STATE_INCALL))) audamrnb_in_record_config(audio, 1); break; } case AUDREC_FATAL_ERR_MSG: { struct audrec_fatal_err_msg fatal_err_msg; getevent(&fatal_err_msg, AUDREC_FATAL_ERR_MSG_LEN); pr_aud_err("FATAL_ERR_MSG: err id %d\n", fatal_err_msg.audrec_err_id); /* Error stop the encoder */ audio->stopped = 1; wake_up(&audio->wait); break; } case AUDREC_UP_PACKET_READY_MSG: { struct audrec_up_pkt_ready_msg pkt_ready_msg; getevent(&pkt_ready_msg, AUDREC_UP_PACKET_READY_MSG_LEN); MM_DBG("UP_PACKET_READY_MSG: write cnt lsw %d \ write cnt msw %d read cnt lsw %d read cnt msw %d \n",\ pkt_ready_msg.audrec_packet_write_cnt_lsw, \ pkt_ready_msg.audrec_packet_write_cnt_msw, \ pkt_ready_msg.audrec_up_prev_read_cnt_lsw, \ pkt_ready_msg.audrec_up_prev_read_cnt_msw); audamrnb_in_get_dsp_frames(audio); break; } default: pr_aud_err("Unknown Event id %d\n", id); } }
static int __init spi_aic3254_init(void) { int ret = 0; struct ecodec_aic3254_state *codec_drv = &codec_clk; pr_aud_info("%s\n", __func__); mutex_init(&lock); ret = spi_register_driver(&spi_aic3254); if (ret < 0) { pr_aud_err("%s:failed to register spi driver(%d)\n", __func__, ret); return ret; } ret = misc_register(&aic3254_misc); if (ret < 0) { pr_aud_err("%s:failed to register misc device\n", __func__); spi_unregister_driver(&spi_aic3254); return ret; } #if defined(CONFIG_ARCH_MSM7X30) codec_drv->rx_mclk = clk_get(NULL, "mi2s_codec_rx_m_clk"); if (IS_ERR(codec_drv->rx_mclk)) { pr_aud_err("%s:failed to get mi2s mclk\n", __func__); misc_deregister(&aic3254_misc); spi_unregister_driver(&spi_aic3254); return -ENODEV; } codec_drv->rx_sclk = clk_get(NULL, "mi2s_codec_rx_s_clk"); if (IS_ERR(codec_drv->rx_sclk)) { pr_aud_err("%s:failed to get mi2s sclk\n", __func__); misc_deregister(&aic3254_misc); spi_unregister_driver(&spi_aic3254); clk_put(codec_drv->rx_mclk); return -ENODEV; } #endif wake_lock_init(&codec_drv->idlelock, WAKE_LOCK_IDLE, "aic3254_lock"); return 0; }