示例#1
0
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;
}
示例#4
0
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;
}
示例#7
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");
	}
}
示例#8
0
void analog_mic_enable(int en)
{
	pmic_mic_en(en);
}
示例#9
0
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;
}