void supersonic_int_mic_enable(int en) { D("%s %d\n", __func__, en); if (en) pmic_mic_en(ON_CMD); else pmic_mic_en(OFF_CMD); }
void incrediblec_int_mic_enable(int en) { D("%s %d\n", __func__, en); if (en) pmic_mic_en(ON_CMD); else pmic_mic_en(OFF_CMD); }
static int pecan_gpio_earsense_work_func(void) { int state; int gpio_value; struct snd_set_hook_param_rep hkrep; struct snd_set_hook_mode_msg hookmsg; int rc; struct msm_rpc_endpoint *ept = msm_rpc_connect_compatible(RPC_SND_PROG, RPC_SND_VERS, 0); if (IS_ERR(ept)) { rc = PTR_ERR(ept); ept = NULL; printk(KERN_ERR"failed to connect snd svc, error %d\n", rc); } hookmsg.args.cb_func = -1; hookmsg.args.client_data = 0; gpio_value = gpio_get_value(GPIO_EAR_SENSE); printk(KERN_INFO"%s: ear sense detected : %s\n", __func__, gpio_value?"injected":"ejected"); if (gpio_value == EAR_EJECT) { state = EAR_STATE_EJECT; pmic_mic_en(0); hookmsg.args.mode = cpu_to_be32(0); } else { state = EAR_STATE_INJECT; pmic_mic_set_volt(MIC_VOLT_1_80V); pmic_mic_en(1); hookmsg.args.mode = cpu_to_be32(1); } if(ept) { rc = msm_rpc_call_reply(ept, SND_SET_HOOK_MODE_PROC, &hookmsg, sizeof(hookmsg),&hkrep, sizeof(hkrep), 5 * HZ); if (rc < 0){ printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc); } else { printk("send success\n"); } } else { printk(KERN_ERR "%s:ext_snd is NULL\n", __func__); } rc = msm_rpc_close(ept); if (rc < 0) printk(KERN_ERR"msm_rpc_close failed\n"); return state; }
static int debug_mic_en(char *buf, int size) { int enable; int cnt; cnt = sscanf(buf, "%d", &enable); if (cnt < 1) { printk(KERN_ERR "%s: sscanf failed cnt=%d" , __func__, cnt); return -EINVAL; } if (pmic_mic_en(enable) < 0) return -EFAULT; return size; }
void audio_opal_spkr_pa_enable(int isIncallmode) { if(isSpkr && (isAudioEn || isIncallmode)) { gpio_set_value(SND_SPKR_PA, 1); if(isIncallmode) { pmic_mic_en(true); } } else { gpio_set_value(SND_SPKR_PA, 0); } }
/* must be called with audio->lock held */ static int audvoicememo_disable(struct audio_voicememo *audio) { struct rpc_request_hdr rhdr; int rc = 0; if (audio->enabled) { msm_rpc_setup_req(&rhdr, audio->rpc_prog, audio->rpc_ver, SND_VOC_REC_STOP_PROC); rc = msm_rpc_write(audio->sndept, &rhdr, sizeof(rhdr)); wait_event_timeout(audio->wait, audio->stopped == 0, 1 * HZ); wake_up(&audio->read_wait); audmgr_disable(&audio->audmgr); audio->enabled = 0; isAudioEn = 0; //JRD added. if(!isIncallMode){ pmic_mic_en(false); } } return 0; }
//Added by JRD for speaker PA control void audio_opal_spkr_pa_enable(void) { if(isSpkr && (isAudioEn || isIncallMode)) { if(pmic_speaker_cmd(SPKR_ON) < 0) printk("==JRD===pmic_speaker_cmd() : SPKR_ON error!\n"); if(pmic_spkr_en_left_chan(1) < 0) printk("==JRD===pmic_spkr_en_left_chan(1) : error!\n"); if(isIncallMode){ if(pmic_mic_en(1) < 0) printk("==JRD===pmic_mic_en(1) : error!\n"); } } else{ if(pmic_spkr_en_left_chan(0) < 0) printk("==JRD===pmic_spkr_en_left_chan(0) : error!\n"); if(pmic_speaker_cmd(SPKR_OFF) < 0) printk("==JRD===pmic_speaker_cmd() : SPKR_OFF error!\n"); } }
void analog_mic_enable(int en) { pmic_mic_en(en); }
enum adie_state_ret_enum_type adie_state_digital_active(u32 dev_type, u32 dev_id) { enum adie_state_ret_enum_type rc; enum adie_codec_path_type_enum path_type; s32 dal_rc; rc = ADIE_STATE_RC_SUCCESS; dal_rc = CAD_RES_SUCCESS; path_type = get_path_type(dev_type); if (adie_state.adie_path_type[dev_type].enable_request == ADIE_TRUE) { /* Prepare the PMIC, if necessary. Configure and power on, but mute it until codec output is ready. */ if (path_type == ADIE_CODEC_TX) if ((dev_id == CAD_HW_DEVICE_ID_HANDSET_MIC) || (dev_id == CAD_HW_DEVICE_ID_HEADSET_MIC) || (dev_id == CAD_HW_DEVICE_ID_SPKR_PHONE_MIC) || (dev_id == CAD_HW_DEVICE_ID_HANDSETMIC_HEADSET_MIC) || (dev_id == CAD_HW_DEVICE_ID_LOOPBACK_SPKR_MIC) || (dev_id == CAD_HW_DEVICE_ID_LOOPBACK_HEADSET_MIC) || (dev_id == CAD_HW_DEVICE_ID_LINE_IN_MIC) ) pmic_mic_en(ON_CMD); else /* need to turn off MIC bias for TTY_HEADSET_MIC */ pmic_mic_en(OFF_CMD); else if ((path_type == ADIE_CODEC_RX) || (path_type == ADIE_CODEC_LB)) { struct spkr_config_mode scm; memset(&scm, 0, sizeof(struct spkr_config_mode)); if (is_speaker_mono(dev_id)) { if (!adie_spkr_mono_ref1_cnt) { if (pmic_is_stereo) { scm.is_right_chan_en = 0; scm.is_left_chan_en = 1; scm.is_stereo_en = 0; scm.is_hpf_en = 1; pmic_spkr_en_mute( LEFT_SPKR, 0); pmic_spkr_en_mute( RIGHT_SPKR, 0); pmic_set_spkr_configuration( &scm); pmic_spkr_en(LEFT_SPKR, 1); pmic_spkr_en(RIGHT_SPKR, 0); } else { pmic_speaker_cmd(SPKR_MUTE_ON); pmic_speaker_cmd(SPKR_ENABLE); } } /* keep a reference for stereo speaker. case when Rx spkr is disabled when LB speaker is already enabled. */ adie_spkr_mono_ref1_cnt++; } else if (is_speaker_stereo(dev_id)) { if (!adie_spkr_stereo_ref1_cnt) { if (pmic_is_stereo) { scm.is_right_chan_en = 1; scm.is_left_chan_en = 1; scm.is_stereo_en = 1; scm.is_hpf_en = 1; pmic_spkr_en_mute( LEFT_SPKR, 0); pmic_spkr_en_mute( RIGHT_SPKR, 0); pmic_set_spkr_configuration( &scm); pmic_spkr_en(LEFT_SPKR, 1); pmic_spkr_en(RIGHT_SPKR, 1); } else { pmic_speaker_cmd(SPKR_MUTE_ON); pmic_speaker_cmd(SPKR_ENABLE); } } /* keep a reference for stereo speaker. case when Rx spkr is disabled when LB speaker is already enabled. */ adie_spkr_stereo_ref1_cnt++; } } else { pr_err("bad path type\n"); } /* Proceed to next stage */ dal_rc = rpc_adie_codec_proceed_to_stage(adie_state.adie_handle, path_type, ADIE_CODEC_DIGITAL_ANALOG_READY); if (dal_rc != CAD_RES_SUCCESS) { pr_err("ARD ADIE Proceed to Stage failed," " dev_type %d\n", dev_type); rc = ADIE_STATE_RC_FAILURE; goto done; } adie_state.adie_path_type[dev_type].state = ADIE_STATE_DIGITAL_ANALOG_ACTIVE; adie_state.adie_path_type[dev_type].enabled = ADIE_TRUE; adie_state.adie_path_type[dev_type].enable_request = ADIE_FALSE; rc = ADIE_STATE_RC_CONTINUE; } else { if (path_type == ADIE_CODEC_TX) pmic_mic_en(OFF_CMD); else if ((path_type == ADIE_CODEC_RX) || (path_type == ADIE_CODEC_LB)) { if (is_speaker_mono(dev_id)) { /* disable a speaker LB or RX */ adie_spkr_mono_ref1_cnt--; /* if no active speaker ref then disable pmic */ if (!adie_spkr_mono_ref1_cnt) { if (pmic_is_stereo) { pmic_spkr_en(LEFT_SPKR, 0); pmic_spkr_en(RIGHT_SPKR, 0); } else pmic_speaker_cmd(SPKR_DISABLE); } } else if (is_speaker_stereo(dev_id)) { /* disable a speaker LB or RX */ adie_spkr_stereo_ref1_cnt--; /* if no active speaker ref then disable pmic */ if (!adie_spkr_stereo_ref1_cnt) { if (pmic_is_stereo) { pmic_spkr_en(LEFT_SPKR, 0); pmic_spkr_en(RIGHT_SPKR, 0); } else pmic_speaker_cmd(SPKR_DISABLE); } } } /* Proceed to digital off stage */ dal_rc = rpc_adie_codec_proceed_to_stage(adie_state.adie_handle, path_type, ADIE_CODEC_DIGITAL_OFF); if (dal_rc != CAD_RES_SUCCESS) { pr_err("ARD ADIE Proceed to Stage failed," " dev_type %d\n", dev_type); rc = ADIE_STATE_RC_FAILURE; goto done; } adie_state.adie_path_type[dev_type].state = ADIE_STATE_RESET; rc = ADIE_STATE_RC_CONTINUE; } done: return rc; }
void analog_mic_enable(int en) { D("en=%d ", en); pmic_mic_en(en); }
void htcleo_mic_enable(int en) { pmic_mic_en(en); }
/* must be called with audio->lock held */ static int audvoicememo_enable(struct audio_voicememo *audio) { struct audmgr_config cfg; struct snd_voc_rec_put_buf_msg bmsg; struct snd_voc_rec_start_msg msg; uint8_t index; uint32_t offset = 0; int rc; if (audio->enabled) return 0; /* Codec / method configure to audmgr client */ cfg.tx_rate = RPC_AUD_DEF_SAMPLE_RATE_8000; cfg.rx_rate = RPC_AUD_DEF_SAMPLE_RATE_NONE; cfg.def_method = RPC_AUD_DEF_METHOD_RECORD; if (audio->voicememo_cfg.capability == RPC_VOC_CAP_IS733) cfg.codec = RPC_AUD_DEF_CODEC_VOC_13K; else if (audio->voicememo_cfg.capability == RPC_VOC_CAP_IS127) cfg.codec = RPC_AUD_DEF_CODEC_VOC_EVRC; else cfg.codec = RPC_AUD_DEF_CODEC_VOC_AMR; /* RPC_VOC_CAP_AMR */ cfg.snd_method = RPC_SND_METHOD_VOICE; rc = audmgr_enable(&audio->audmgr, &cfg); if (rc < 0) return rc; /* Configure VOC Rec buffer */ for (index = 0; index < MAX_REC_BUF_COUNT; index++) { audio->in[index].data = audio->rec_buf_ptr + offset; audio->in[index].addr = audio->phys + offset; audio->in[index].size = audio->rec_buf_size; audio->in[index].used = 0; audio->in[index].numframes = 0; offset += audio->rec_buf_size; bmsg.args.buf = (uint32_t) audio->in[index].data; bmsg.args.num_bytes = cpu_to_be32(audio->in[index].size); MM_DBG("rec_buf_ptr=0x%8x, rec_buf_size = 0x%8x\n", bmsg.args.buf, bmsg.args.num_bytes); msm_rpc_setup_req(&bmsg.hdr, audio->rpc_prog, audio->rpc_ver, SND_VOC_REC_PUT_BUF_PROC); audio->rpc_xid = bmsg.hdr.xid; audio->rpc_status = RPC_STATUS_FAILURE; msm_rpc_write(audio->sndept, &bmsg, sizeof(bmsg)); rc = wait_event_timeout(audio->wait, audio->rpc_status != RPC_STATUS_FAILURE, 1 * HZ); if (rc == 0) goto err; } /* Start Recording */ msg.args.param_status = cpu_to_be32(0x00000001); msg.args.rec_type = cpu_to_be32(audio->voicememo_cfg.rec_type); msg.args.rec_interval_ms = cpu_to_be32(audio->voicememo_cfg.rec_interval_ms); msg.args.auto_stop_ms = cpu_to_be32(audio->voicememo_cfg.auto_stop_ms); msg.args.capability = cpu_to_be32(audio->voicememo_cfg.capability); msg.args.max_rate = cpu_to_be32(audio->voicememo_cfg.max_rate); msg.args.min_rate = cpu_to_be32(audio->voicememo_cfg.min_rate); msg.args.frame_format = cpu_to_be32(audio->voicememo_cfg.frame_format); msg.args.dtx_enable = cpu_to_be32(audio->voicememo_cfg.dtx_enable); msg.args.data_req_ms = cpu_to_be32(audio->voicememo_cfg.data_req_ms); msg.args.rec_client_data = cpu_to_be32(REC_CLIENT_DATA); msg.args.cb_func_id = cpu_to_be32(DATA_CB_FUNC_ID); msg.args.sync_cb_func_id = cpu_to_be32(AV_SYNC_CB_FUNC_ID); msg.args.client_data = cpu_to_be32(CLIENT_DATA); msm_rpc_setup_req(&msg.hdr, audio->rpc_prog, audio->rpc_ver, SND_VOC_REC_START_PROC); audio->rpc_xid = msg.hdr.xid; audio->rpc_status = RPC_STATUS_FAILURE; msm_rpc_write(audio->sndept, &msg, sizeof(msg)); rc = wait_event_timeout(audio->wait, audio->rpc_status != RPC_STATUS_FAILURE, 1 * HZ); if (rc == 0) goto err; audio->rpc_xid = 0; audio->enabled = 1; isAudioEn = 1; //JRD added pmic_mic_en(true); return 0; err: audio->rpc_xid = 0; audmgr_disable(&audio->audmgr); MM_ERR("Fail\n"); return -1; }