static long snd_cad_dev_enable(const char *arg)
{
struct snd_cad_sys_ctxt *snd_cad_sys = &the_snd_cad_sys;
struct snd_cad_set_device_msg dmsg;
struct msm_cad_device_config dev;
int rc = 0;
rc = sscanf(arg, "%d %d %d %d", &dev.device.rx_device,
&dev.device.tx_device, &dev.ear_mute, &dev.mic_mute);
if (rc != 4) {
MM_ERR("Invalid arguments. Usage: <rx_device> <tx_device> "\
"<ear_mute> <mic_mute>\n");
rc = -EINVAL;
return rc;
}
dmsg.args.device.rx_device = cpu_to_be32(dev.device.rx_device);
dmsg.args.device.tx_device = cpu_to_be32(dev.device.tx_device);
dmsg.args.device.pathtype = cpu_to_be32(CAD_DEVICE_PATH_RX_TX);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("snd_cad_ioctl set device: invalid mute status\n");
rc = -EINVAL;
return rc;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
curr_dev.tx_dev = dev.device.tx_device;
curr_dev.rx_dev = dev.device.rx_device;
MM_INFO("snd_cad_set_device %d %d %d %d\n", dev.device.rx_device,
dev.device.tx_device, dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd_cad_sys->ept,
SND_CAD_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
struct msm_snd_set_voccal_param voccal;
struct snd_set_voccal_param_msg cmsg;
struct msm_snd_set_voccal_iir_param voccaliir;
struct snd_set_voccal_iir_param_msg cimsg;
struct msm_snd_set_next_ec_param nextec;
struct snd_set_next_ec_param_msg nmsg;
struct msm_snd_set_rx_volume_param rxvol;
struct snd_set_rx_volume_param_msg rmsg;
struct msm_snd_set_dtmf_volume_param dtmfvol;
struct snd_set_dtmf_volume_param_msg fmsg;
struct msm_snd_set_pad_value_param padvalue;
struct snd_set_pad_value_param_msg pmsg;
struct msm_snd_set_loopback_mode_param loopback;
struct snd_set_loopback_mode_msg lmsg;
struct snd_write_efs_msg wmsg;
struct msm_snd_set_micamp_gain_param micampgain;
struct snd_set_micamp_gain_param_msg mamsg;
struct msm_snd_set_amp_gain_param ampgain;
struct snd_set_set_amp_gain_param_msg amsg;
struct msm_snd_set_fm_radio_vol_param fmradiovol;
struct snd_set_fm_radio_vol_msg fmrmsg;
struct msm_snd_set_voice_clarity_param voiceclarity;
struct snd_set_voice_clarity_msg vcmsg;
//int fm_radio_vol;
int wefs;
struct snd_set_voccal_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_voccal;
}crep;
struct snd_set_voccal_iir_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_voccal_iir;
}cirep;
struct snd_set_nextec_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_nextec;
}nrep;
struct snd_set_rxvol_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_rxvol;
}rrep;
struct snd_set_dtmfvol_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_dtmfvol;
}frep;
struct snd_set_padvalue_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_padvalue;
}prep;
struct snd_set_loopback_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_mode;
}lrep;
struct snd_write_efs_rep {
struct rpc_reply_hdr hdr;
uint32_t result;
}wrep;
struct snd_set_amp_gain_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_gainvalue;
}arep;
struct snd_set_voice_clarity_param_rep {
struct rpc_reply_hdr hdr;
uint32_t get_mode;
}vcrep;
int rc = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
#if defined (CONFIG_MACH_MSM7X27_SWIFT)
case SND_SET_VOCCAL_PARAM:
if (copy_from_user(&voccal, (void __user*) arg, sizeof(voccal))){
pr_err("snd_ioctl set vocal_param: invalid pointer.\n");
rc = -EFAULT;
break;
}
cmsg.args.voc_codec = cpu_to_be32(voccal.voc_codec);
cmsg.args.voccal_param_type = cpu_to_be32(voccal.voccal_param_type);
cmsg.args.get_flag = cpu_to_be32(voccal.get_flag);
cmsg.args.param_val = cpu_to_be32(voccal.param_val);
cmsg.args.cb_func = -1;
cmsg.args.client_data = 0;
pr_info("snd_set_voccal_param %d %d %d %d\n", voccal.voc_codec,
voccal.voccal_param_type, voccal.get_flag, voccal.param_val);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_VOCCAL_PARAM_PROC,
&cmsg, sizeof(cmsg), &crep, sizeof(crep), 5*HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
voccal.get_param = be32_to_cpu(crep.get_voccal);
printk(KERN_INFO "%s:voccal ->%d\n", __func__, voccal.get_param);
if (copy_to_user((void __user*)arg, &voccal, sizeof(voccal))){
pr_err("snd_ioctl get voccal: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_VOCCAL_IIR_PARAM:
if (copy_from_user(&voccaliir, (void __user *) arg, sizeof(voccaliir))) {
pr_err("snd_ioctl set_voccal_iir_param: invalid pointer.\n");
rc = -EFAULT;
break;
}
cimsg.args.voc_codec = cpu_to_be32(voccaliir.voc_codec);
cimsg.args.voccal_iir_param_type = cpu_to_be32(voccaliir.voccal_iir_param_type);
cimsg.args.get_flag = cpu_to_be32(voccaliir.get_flag);
cimsg.args.param_val = cpu_to_be32(voccaliir.param_val);
cimsg.args.cb_func = -1;
cimsg.args.client_data = 0;
pr_info("set_voccal_iir_param %d %d %d\n", voccaliir.voc_codec,
voccaliir.voccal_iir_param_type, voccaliir.param_val);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_VOCCAL_IIR_PARAM_PROC,
&cimsg, sizeof(cimsg),&cirep, sizeof(cirep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
voccaliir.get_param = be32_to_cpu(cirep.get_voccal_iir);
printk(KERN_INFO "%s:voccal_iir ->%d\n", __func__, voccaliir.get_param);
if (copy_to_user((void __user *)arg, &voccaliir, sizeof(voccaliir))) {
pr_err("snd_ioctl get voccal iir: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_NEXT_EC_PARAM:
if (copy_from_user(&nextec, (void __user *) arg, sizeof(nextec))) {
pr_err("snd_ioctl set_next_ec_param: invalid pointer.\n");
rc = -EFAULT;
break;
}
nmsg.args.ec_mode = cpu_to_be32(nextec.ec_mode);
nmsg.args.ec_param_type = cpu_to_be32(nextec.ec_param_type);
nmsg.args.get_flag = cpu_to_be32(nextec.get_flag);
nmsg.args.param_val = cpu_to_be32(nextec.param_val);
nmsg.args.cb_func = -1;
nmsg.args.client_data = 0;
pr_info("set_next_ec_param %d %d %d\n", nextec.ec_mode,
nextec.ec_param_type, nextec.param_val);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_NEXT_EC_PARAM_PROC,
&nmsg, sizeof(nmsg),&nrep, sizeof(nrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
nextec.get_param = be32_to_cpu(nrep.get_nextec);
printk(KERN_INFO "%s:nextec ->%d\n", __func__, nextec.get_param);
if (copy_to_user((void __user *)arg, &nextec, sizeof(nextec))) {
pr_err("snd_ioctl get next ec: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_RX_VOLUME:
if (copy_from_user(&rxvol, (void __user *) arg, sizeof(rxvol))) {
pr_err("snd_ioctl set_rx_volume: invalid pointer.\n");
rc = -EFAULT;
break;
}
rmsg.args.device = cpu_to_be32(rxvol.device);
rmsg.args.method = cpu_to_be32(rxvol.method);
rmsg.args.idx = cpu_to_be32(rxvol.idx);
rmsg.args.get_flag = cpu_to_be32(rxvol.get_flag);
rmsg.args.param_val = cpu_to_be32(rxvol.param_val);
rmsg.args.cb_func = -1;
rmsg.args.client_data = 0;
pr_info("set_rx_volume %d %d %d %d\n", rxvol.device,
rxvol.method, rxvol.idx, rxvol.param_val);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_RX_VOLUME_PROC,
&rmsg, sizeof(rmsg),&rrep, sizeof(rrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
rxvol.get_param = be32_to_cpu(rrep.get_rxvol);
printk(KERN_INFO "%s:rx vol ->%d\n", __func__, rxvol.get_param);
if (copy_to_user((void __user *)arg, &rxvol, sizeof(rxvol))) {
pr_err("snd_ioctl get rx vol: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_DTMF_VOLUME:
if (copy_from_user(&dtmfvol, (void __user *) arg, sizeof(dtmfvol))) {
pr_err("snd_ioctl set_dtmf_volume: invalid pointer.\n");
rc = -EFAULT;
break;
}
fmsg.args.device = cpu_to_be32(dtmfvol.device);
fmsg.args.method = cpu_to_be32(dtmfvol.method);
fmsg.args.idx = cpu_to_be32(dtmfvol.idx);
fmsg.args.get_flag = cpu_to_be32(dtmfvol.get_flag);
fmsg.args.param_val = cpu_to_be32(dtmfvol.param_val);
fmsg.args.cb_func = -1;
fmsg.args.client_data = 0;
pr_info("set_dtmf_volume %d %d %d %d\n", dtmfvol.device,
dtmfvol.method, dtmfvol.idx, dtmfvol.param_val);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_DTMF_VOLUME_PROC,
&fmsg, sizeof(fmsg),&frep, sizeof(frep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
dtmfvol.get_param = be32_to_cpu(frep.get_dtmfvol);
printk(KERN_INFO "%s:rx vol ->%d\n", __func__, dtmfvol.get_param);
if (copy_to_user((void __user *)arg, &dtmfvol, sizeof(dtmfvol))) {
pr_err("snd_ioctl get dtmf vol: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_PAD_VALUE:
if (copy_from_user(&padvalue, (void __user *) arg, sizeof(padvalue))) {
pr_err("snd_ioctl set_pad_value: invalid pointer.\n");
rc = -EFAULT;
break;
}
pmsg.args.device = cpu_to_be32(padvalue.device);
pmsg.args.method = cpu_to_be32(padvalue.method);
pmsg.args.idx = cpu_to_be32(padvalue.idx);
pmsg.args.get_flag = cpu_to_be32(padvalue.get_flag);
pmsg.args.param_val = cpu_to_be32(padvalue.param_val);
pmsg.args.cb_func = -1;
pmsg.args.client_data = 0;
pr_info("set_pad_value %d %d %d %d\n", padvalue.device,
padvalue.method, padvalue.idx, padvalue.param_val);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_PAD_VALUE_PROC,
&pmsg, sizeof(pmsg),&prep, sizeof(prep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
padvalue.get_param = be32_to_cpu(prep.get_padvalue);
printk(KERN_INFO "%s:rx vol ->%d\n", __func__, padvalue.get_param);
if (copy_to_user((void __user *)arg, &padvalue, sizeof(padvalue))) {
pr_err("snd_ioctl get pad value: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_LOOPBACK_MODE:
if (copy_from_user(&loopback, (void __user *) arg, sizeof(loopback))) {
pr_err("snd_ioctl set amp_gain: invalid pointer.\n");
rc = -EFAULT;
break;
}
lmsg.args.mode = cpu_to_be32(loopback.mode);
lmsg.args.cb_func = -1;
lmsg.args.client_data = 0;
pr_info("set_loopback_mode %d \n", loopback.mode);
rc = msm_rpc_call(snd->ept,
SND_SET_LOOPBACK_MODE_PROC,
&lmsg, sizeof(lmsg), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
loopback.get_param = be32_to_cpu(lrep.get_mode);
printk(KERN_INFO "%s:loopback mode ->%d\n", __func__, loopback.get_param);
if (copy_to_user((void __user *)arg, &loopback, sizeof(loopback))) {
pr_err("snd_ioctl get loopback mode: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_WRITE_EFS:
wmsg.args.cb_func = -1;
wmsg.args.client_data = 0;
pr_info("set_write_efs \n");
rc = msm_rpc_call_reply(snd->ept,
SND_WRITE_EFS_PROC,
&wmsg, sizeof(wmsg),&wrep, sizeof(wrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
wefs = be32_to_cpu(wrep.result);
printk(KERN_INFO "%s:loopback mode ->%d\n", __func__, wefs);
if (copy_to_user((void __user *)arg, &wefs, sizeof(wefs))) {
pr_err("snd_ioctl write efs: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_MICAMP_GAIN:
if (copy_from_user(&micampgain, (void __user *) arg, sizeof(micampgain))) {
pr_err("snd_ioctl set_pad_value: invalid pointer.\n");
rc = -EFAULT;
break;
}
mamsg.args.voc_codec = cpu_to_be32(micampgain.voc_codec);
mamsg.args.mic_channel = cpu_to_be32(micampgain.mic_channel);
mamsg.args.get_flag = cpu_to_be32(micampgain.get_flag);
mamsg.args.get_param = cpu_to_be32(micampgain.value);
mamsg.args.cb_func = -1;
mamsg.args.client_data = 0;
pr_info("SND_SET_MICAMP_GAIN %d %d %d %d\n", micampgain.voc_codec,
micampgain.mic_channel, micampgain.get_flag, micampgain.get_param);
rc = msm_rpc_call_reply(snd->ept,
SND_SET_MICAMP_GAIN_PROC,
&mamsg, sizeof(mamsg),&mrep, sizeof(mrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
micampgain.get_param = be32_to_cpu(mrep.get_gainvalue);
printk(KERN_INFO "%s:rx vol ->%d\n", __func__, micampgain.get_param);
if (copy_to_user((void __user *)arg, &micampgain, sizeof(micampgain))) {
pr_err("snd_ioctl get pad value: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_AMP_GAIN:
if (copy_from_user(&gain, (void __user *) arg, sizeof(ampgain))) {
pr_err("snd_ioctl set amp_gain: invalid pointer.\n");
rc = -EFAULT;
break;
}
amsg.args.voc_codec = cpu_to_be32(ampgain.voc_codec);
amsg.args.gain_type = cpu_to_be32(ampgain.gain_type);
amsg.args.get_flag = cpu_to_be32(ampgain.get_flag);
amsg.args.get_param = cpu_to_be32(ampgain.value);
amsg.args.cb_func = -1;
amsg.args.client_data = 0;
rc = msm_rpc_call_reply(snd->ept,
SND_SET_AMP_GAIN_PROC,
&amsg, sizeof(amsg),&arep, sizeof(arep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
ampgain.get_param = be32_to_cpu(arep.get_gainvalue);
printk(KERN_INFO "%s:rx vol ->%d\n", __func__, ampgain.get_param);
if (copy_to_user((void __user *)arg, &gain, sizeof(ampgain))) {
pr_err("snd_ioctl get pad value: invalid write pointer.\n");
rc = -EFAULT;
}
}
if (copy_to_user((void __user *)arg, &gain, sizeof(ampgain))) {
pr_err("snd_ioctl get amp gain: invalid write pointer.\n");
rc = -EFAULT;
}
break;
case SND_WRITE_MEM:
wmsg.args.cb_func = -1;
wmsg.args.client_data = 0;
pr_info("set_write_efs \n");
rc = msm_rpc_call_reply(snd->ept,
SND_WRITE_MEM_PROC,
&wmsg, sizeof(wmsg),&wrep, sizeof(wrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
wefs = be32_to_cpu(wrep.result);
printk(KERN_INFO "%s:loopback mode ->%d\n", __func__, wefs);
if (copy_to_user((void __user *)arg, &wefs, sizeof(wefs))) {
pr_err("snd_ioctl write efs: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_FM_RADIO_VOLUME:
if (copy_from_user(&fmradiovol, (void __user *) arg, sizeof(fmradiovol))) {
pr_err("snd_ioctl set amp_gain: invalid pointer.\n");
rc = -EFAULT;
break;
}
fmrmsg.args.volume = cpu_to_be32(fmradiovol.volume);
fmrmsg.args.cb_func = -1;
fmrmsg.args.client_data = 0;
pr_info("snd_set_fm_radio_volume %d\n", fmradiovol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_FM_RADIO_VOLUME_PROC,
&fmrmsg, sizeof(fmrmsg), 5 * HZ);
break;
case SND_SET_VOICE_CLARITY:
if (copy_from_user(&voiceclarity, (void __user *) arg, sizeof(voiceclarity))) {
pr_err("snd_ioctl set amp_gain: invalid pointer.\n");
rc = -EFAULT;
break;
}
vcmsg.args.mode = cpu_to_be32(voiceclarity.mode);
vcmsg.args.cb_func = -1;
vcmsg.args.client_data = 0;
pr_info("set_loopback_mode %d \n", voiceclarity.mode);
rc = msm_rpc_call(snd->ept,
SND_SET_VOICE_CLARITY_PROC,
&vcmsg, sizeof(vcmsg), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
voiceclarity.get_param = be32_to_cpu(vcrep.get_mode);
printk(KERN_INFO "%s:voice clarity mode ->%d\n", __func__, voiceclarity.get_param);
if (copy_to_user((void __user *)arg, &voiceclarity, sizeof(voiceclarity))) {
pr_err("snd_ioctl get loopback mode: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_POWER_OFF:
wmsg.args.cb_func = -1;
wmsg.args.client_data = 0;
pr_info("set_power_off \n");
rc = msm_rpc_call_reply(snd->ept,
SND_SET_POWER_OFF_PROC,
&wmsg, sizeof(wmsg),&wrep, sizeof(wrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
wefs = be32_to_cpu(wrep.result);
if (copy_to_user((void __user *)arg, &wefs, sizeof(wefs))) {
pr_err("snd_ioctl write efs: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_SET_FM_RADIO_MULTI_SOUND:
wmsg.args.cb_func = -1;
wmsg.args.client_data = 0;
pr_info("set_fm_radio_multi_sound \n");
rc = msm_rpc_call_reply(snd->ept,
SND_SET_FM_RADIO_MULTI_SOUND_PROC,
&wmsg, sizeof(wmsg),&wrep, sizeof(wrep), 5 * HZ);
if (rc < 0){
printk(KERN_ERR "%s:rpc err because of %d\n", __func__, rc);
}
else
{
wefs = be32_to_cpu(wrep.result);
if (copy_to_user((void __user *)arg, &wefs, sizeof(wefs))) {
pr_err("snd_ioctl set_fm_radio_multi_sound: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
#endif
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
pr_err("snd_ioctl set device: invalid pointer.\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
pr_err("snd_ioctl set device: invalid mute status.\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
pr_info("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
pr_err("snd_ioctl set volume: invalid pointer.\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
pr_err("snd_ioctl set volume: invalid method.\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
pr_info("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
pr_err("snd_ioctl get endpoint: invalid pointer.\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
pr_err("snd_ioctl unknown command.\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
#ifdef CONFIG_HUAWEI_KERNEL
if (vol.method != SND_METHOD_VOICE&&vol.method != SND_METHOD_MIDI) {
#else
if (vol.method != SND_METHOD_VOICE) {
#endif
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static int snd_release(struct inode *inode, struct file *file)
{
struct snd_ctxt *snd = file->private_data;
int rc;
mutex_lock(&snd->lock);
rc = msm_rpc_close(snd->ept);
if (rc < 0)
MM_ERR("msm_rpc_close failed\n");
snd->ept = NULL;
snd->opened = 0;
mutex_unlock(&snd->lock);
return 0;
}
static int snd_sys_release(void)
{
struct snd_sys_ctxt *snd_sys = &the_snd_sys;
int rc = 0;
mutex_lock(&snd_sys->lock);
rc = msm_rpc_close(snd_sys->ept);
if (rc < 0)
MM_ERR("msm_rpc_close failed\n");
snd_sys->ept = NULL;
mutex_unlock(&snd_sys->lock);
return rc;
}
static int snd_open(struct inode *inode, struct file *file)
{
struct snd_ctxt *snd = &the_snd;
int rc = 0;
mutex_lock(&snd->lock);
if (snd->opened == 0) {
if (snd->ept == NULL) {
snd->ept = msm_rpc_connect_compatible(RPC_SND_PROG,
RPC_SND_VERS, 0);
if (IS_ERR(snd->ept)) {
rc = PTR_ERR(snd->ept);
snd->ept = NULL;
MM_ERR("failed to connect snd svc\n");
goto err;
}
}
file->private_data = snd;
snd->opened = 1;
} else {
MM_ERR("snd already opened\n");
rc = -EBUSY;
}
err:
mutex_unlock(&snd->lock);
return rc;
}
static int snd_sys_open(void)
{
struct snd_sys_ctxt *snd_sys = &the_snd_sys;
int rc = 0;
mutex_lock(&snd_sys->lock);
if (snd_sys->ept == NULL) {
snd_sys->ept = msm_rpc_connect_compatible(RPC_SND_PROG,
RPC_SND_VERS, 0);
if (IS_ERR(snd_sys->ept)) {
rc = PTR_ERR(snd_sys->ept);
snd_sys->ept = NULL;
MM_ERR("failed to connect snd svc\n");
goto err;
}
} else
MM_DBG("snd already opened\n");
err:
mutex_unlock(&snd_sys->lock);
return rc;
}
static struct file_operations snd_fops = {
.owner = THIS_MODULE,
.open = snd_open,
.release = snd_release,
.unlocked_ioctl = snd_ioctl,
};
struct miscdevice snd_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "msm_snd",
.fops = &snd_fops,
};
static long snd_agc_enable(unsigned long arg)
{
struct snd_sys_ctxt *snd_sys = &the_snd_sys;
struct snd_agc_ctl_msg agc_msg;
int rc = 0;
if ((arg != 1) && (arg != 0))
return -EINVAL;
agc_msg.args.agc_ctl = cpu_to_be32(arg);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_DBG("snd_agc_ctl %ld,%d\n", arg, agc_msg.args.agc_ctl);
rc = msm_rpc_call(snd_sys->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
return rc;
}
static long snd_avc_enable(unsigned long arg)
{
struct snd_sys_ctxt *snd_sys = &the_snd_sys;
struct snd_avc_ctl_msg avc_msg;
int rc = 0;
if ((arg != 1) && (arg != 0))
return -EINVAL;
avc_msg.args.avc_ctl = cpu_to_be32(arg);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_DBG("snd_avc_ctl %ld,%d\n", arg, avc_msg.args.avc_ctl);
rc = msm_rpc_call(snd_sys->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
return rc;
}
static ssize_t snd_agc_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
ssize_t status;
struct snd_sys_ctxt *snd_sys = &the_snd_sys;
int rc = 0;
rc = snd_sys_open();
if (rc)
return rc;
mutex_lock(&snd_sys->lock);
if (sysfs_streq(buf, "enable"))
status = snd_agc_enable(1);
else if (sysfs_streq(buf, "disable"))
status = snd_agc_enable(0);
else
status = -EINVAL;
mutex_unlock(&snd_sys->lock);
rc = snd_sys_release();
if (rc)
return rc;
return status ? : size;
}
static ssize_t snd_avc_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
ssize_t status;
struct snd_sys_ctxt *snd_sys = &the_snd_sys;
int rc = 0;
rc = snd_sys_open();
if (rc)
return rc;
mutex_lock(&snd_sys->lock);
if (sysfs_streq(buf, "enable"))
status = snd_avc_enable(1);
else if (sysfs_streq(buf, "disable"))
status = snd_avc_enable(0);
else
status = -EINVAL;
mutex_unlock(&snd_sys->lock);
rc = snd_sys_release();
if (rc)
return rc;
return status ? : size;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
#if defined(CONFIG_MACH_KYLE_CHN) || defined(CONFIG_MACH_KYLE_I)
if (vol.method != SND_METHOD_MIDI){
#endif
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
#if defined(CONFIG_MACH_KYLE_CHN) || defined(CONFIG_MACH_KYLE_I)
}
#endif
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
//jrd add
int spkr_param = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
//JRD add for speaker pa control
case SND_SET_PA:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
}
spkr_param = avc;
isSpkr = (spkr_param > 1) ? true:false;
isIncallMode = spkr_param%2;
MM_INFO("snd_avc_ctl %d; isIncallMode: %d;spkr_param : %d; ===\n", avc,isIncallMode,spkr_param);
audio_opal_spkr_pa_enable();
rc = 0;
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
/*++ Kevin Shiu - 20120612 implement secondary mic test ++*/
struct msm_snd_info_config info;
struct snd_set_info_msg imsg;
/*-- Kevin Shiu - 20120612 implement secondary mic test --*/
/*++ Kevin Shiu - 20121002 voip mute and change path ++*/
struct msm_snd_voip_config voip;
struct snd_set_voip_msg voipmsg;
/*-- Kevin Shiu - 20121002 voip mute and change path --*/
/*++ Kvein Shiu - 20121103 always enable hesd bias when TTY turn on ++*/
struct msm_snd_tty_config tty;
struct snd_set_tty_msg ttymsg;
/*-- Kvein Shiu - 20121103 always enable hesd bias when TTY turn on --*/
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
/*++ Kevin Shiu - 20120612 implement secondary mic test ++*/
case SND_SET_INFO:
if (copy_from_user(&info, (void __user *) arg, sizeof(info))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
imsg.args.secondary_mic = cpu_to_be32(info.secondary_mic);
imsg.args.reserved_1 = cpu_to_be32(info.reserved_1);
imsg.args.reserved_2 = cpu_to_be32(info.reserved_2);
imsg.args.cb_func = -1;
imsg.args.client_data = 0;
MM_INFO("snd_set_info %d %d %d\n",imsg.args.secondary_mic, imsg.args.reserved_1, imsg.args.reserved_2);
rc = msm_rpc_call(snd->ept,
SND_SET_INFO_PROC,&imsg,
sizeof(imsg), 5 * HZ);
break;
/*-- Kevin Shiu - 20120612 implement secondary mic test --*/
/*++ Kevin Shiu - 20121002 voip mute and change path ++*/
case SND_SET_VOIP:
if (copy_from_user(&voip, (void __user *) arg, sizeof(voip))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
voipmsg.args.audiopath = cpu_to_be32(voip.audiopath);
voipmsg.args.voip_mute = cpu_to_be32(voip.voip_mute);
voipmsg.args.reserved_2 = cpu_to_be32(voip.reserved_2);
voipmsg.args.cb_func = -1;
voipmsg.args.client_data = 0;
MM_INFO("snd_set_voip %d %d %d\n",voipmsg.args.audiopath, voipmsg.args.voip_mute, voipmsg.args.reserved_2);
rc = msm_rpc_call(snd->ept,
SND_SET_VOIP_PROC,&voipmsg,
sizeof(voipmsg), 5 * HZ);
break;
/*-- Kevin Shiu - 20121002 voip mute and change path --*/
/*++ Kvein Shiu - 20121103 always enable hesd bias when TTY turn on ++*/
case SND_SET_TTY:
if (copy_from_user(&tty, (void __user *) arg, sizeof(tty))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
ttymsg.args.tty_mode = cpu_to_be32(tty.tty_mode);
ttymsg.args.cb_func = -1;
ttymsg.args.client_data = 0x0;
MM_INFO("snd_set_tty %d\n",ttymsg.args.tty_mode);
rc = msm_rpc_call(snd->ept,
SND_SET_TTY_PROC,&ttymsg,
sizeof(ttymsg), 5 * HZ);
break;
/*-- Kvein Shiu - 20121103 always enable hesd bias when TTY turn on --*/
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct snd_set_lb_msg lb_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
uint32_t set_lb;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
// FM_STEREO_HEADSET -> HEADSET
if(SND_DEVICE_FM_STEREO_HEADSET_ZTE == dev.device)
dev.device = 3;
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
#if 0
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
#else
if(SND_DEVICE_FM_STEREO_HEADSET_ZTE == dev.device)
{
rc = msm_rpc_call(snd->ept,
SND_SET_FM_HEADSET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
}
else
{
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
}
#endif
if (dev.device != 28)
{
keep_snd_dev_info[SND_DEV] = dev.device;
}
keep_snd_dev_info[EAR_MUTE] = dev.ear_mute;
keep_snd_dev_info[MIC_MUTE] = dev.mic_mute;
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
case SND_SET_AUDIO_LOOPBACK:
if (get_user(set_lb, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((set_lb != 1) && (set_lb != 0)) {
rc = -EINVAL;
break;
}
lb_msg.args.lb_ctl = cpu_to_be32(set_lb);
lb_msg.args.cb_func = -1;
lb_msg.args.client_data = 0;
pr_info("snd_lb_ctl %d\n", set_lb);
rc = msm_rpc_call(snd->ept,
SND_AUDIO_LOOPBACK_PROC,
&lb_msg, sizeof(lb_msg), 5 * HZ);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_cad_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct snd_cad_set_device_msg dmsg;
struct snd_cad_set_volume_msg vmsg;
struct msm_cad_device_config dev;
struct msm_cad_volume_config vol;
struct snd_cad_ctxt *snd = file->private_data;
int rc = 0;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device.rx_device = cpu_to_be32(dev.device.rx_device);
dmsg.args.device.tx_device = cpu_to_be32(dev.device.tx_device);
dmsg.args.device.pathtype = cpu_to_be32(dev.device.pathtype);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
curr_dev.tx_dev = dev.device.tx_device;
curr_dev.rx_dev = dev.device.rx_device;
MM_ERR("snd_cad_set_device %d %d %d %d\n", dev.device.rx_device,
dev.device.tx_device, dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_CAD_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device.rx_device = cpu_to_be32(dev.device.rx_device);
vmsg.args.device.tx_device = cpu_to_be32(dev.device.tx_device);
vmsg.args.method = cpu_to_be32(vol.method);
#if !defined(CONFIG_MACH_ARUBA_OPEN) && !defined(CONFIG_MACH_ARUBASLIM_OPEN) && !defined(CONFIG_MACH_ARUBA_DUOS_CTC) \
&& !defined(CONFIG_MACH_KYLEPLUS_CTC) && !defined(CONFIG_MACH_INFINITE_DUOS_CTC) \
&& !defined(CONFIG_MACH_KYLEPLUS_OPEN) && !defined(CONFIG_MACH_BAFFIN_DUOS_CTC) && !defined(CONFIG_MACH_DELOS_DUOS_CTC)
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
#endif
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_ERR("snd_cad_set_volume %d %d %d %d\n", vol.device.rx_device,
vol.device.tx_device, vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_CAD_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->cad_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
case CAD_SET_MUTE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device.rx_device = cpu_to_be32(dev.device.rx_device);
dmsg.args.device.tx_device = cpu_to_be32(dev.device.tx_device);
dmsg.args.device.pathtype = cpu_to_be32(dev.device.pathtype);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_ERR("snd_cad_set_mute %d %d %d %d\n", dev.device.rx_device,
dev.device.tx_device, dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_CAD_SET_MUTE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct snd_set_extamp_msg emsg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct msm_snd_extamp_config extamp;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
#ifdef FEATURE_MAX8899_AMP_OFF
int data1 = 0;
int data2 = 0;
#endif
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_ERR("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_ERR("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
case SND_SET_EXTAMP:
if (copy_from_user(&extamp, (void __user *) arg, sizeof(extamp))) {
MM_ERR("set extamp: invalid pointer\n");
rc = -EFAULT;
break;
}
emsg.args.device = cpu_to_be32(extamp.device);
emsg.args.speaker_volume = cpu_to_be32(extamp.speaker_volume);
emsg.args.headset_volume = cpu_to_be32(extamp.headset_volume);
emsg.args.cb_func = -1;
emsg.args.client_data = 0;
MM_ERR("snd_set_extamp %d %d %d\n", extamp.device,
extamp.speaker_volume, extamp.headset_volume);
rc = msm_rpc_call(snd->ept,
SND_SET_EXTAMP_PROC,
&emsg, sizeof(emsg), 5 * HZ);
break;
#ifdef CONFIG_MACH_FLIPBOOK
case SND_SET_MAIN_MIC:
if(board_hw_revision>=1)
rc = gpio_direction_output(89, 0);
else
rc = gpio_direction_output(89, 1);
break;
case SND_SET_SUB_MIC:
if(board_hw_revision>=1)
rc = gpio_direction_output(89, 1);
else
rc = gpio_direction_output(89, 0);
break;
#else
case SND_SET_MAIN_MIC:
rc = gpio_direction_output(89, 1);
break;
case SND_SET_SUB_MIC:
rc = gpio_direction_output(89, 0);
break;
#endif
#ifdef FEATURE_MAX8899_AMP_OFF
case SND_MAX8899_AMP_OFF:
if (copy_from_user(&data1, (void __user *) arg, sizeof(data1))) {
MM_ERR("amp off: invalid pointer\n");
rc = -EFAULT;
break;
}
rc = msm_proc_comm(SMEM_PROC_COMM_AMP_OFF, &data1, &data2);
if(rc < 0)
{
printk("%s max8899 amp off proccomm fail\n", __func__);
return rc;
}
MM_ERR("snd_max8899_amp_off %d\n", data1);
break;
#endif
default:
MM_ERR("unknown command %d\n", cmd);
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
int data1, data2;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
dev.bluetooth_id = 0;
dmsg.args.bluetooth_id = cpu_to_be32(dev.bluetooth_id);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
//printk("[Aaron][%s] snd_set_device %d %d %d\r\n", __func__, dev.device,
// dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
//printk("[Aaron][%s] rc=%x\r\n", __func__, rc);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
// Uper layer will send volume as 0,1,3,4,6,7
// But L1 level is 0~6, 6=7.
// We do not want 0 as mute, so shift 0 to 1.
// Aaron Chen 2010.08.23
if ((vol.device != 33) && (vol.device != 34))//FM needs volume 0 for mute brad
{
if (vol.volume == 0)
{
vol.volume = 1;
}
else if (vol.volume == 1)
{
vol.volume = 2;
}
else if (vol.volume == 6)
{
vol.volume = 5;
}
else if (vol.volume == 7)
{
vol.volume = 6;
}
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
//printk("[Aaron][%s] snd_set_volume %d %d %d %d\r\n", __func__, vol.device, vol.method, vol.volume, vmsg.args.volume);
//printk("[Aaron][%s] PCOM_CCI_SET_AUX_PGA_GAIN(138)=%d\r\n", __func__, PCOM_CCI_SET_AUX_PGA_GAIN);
if ((vol.device == 33) || (vol.device == 34))
{
#if 0
data1 = 0;
data2 = 3000;
rc = msm_proc_comm(PCOM_CCI_VIBRATE, &data1, &data2);
printk("[Aaron][%s] msm_proc_comm(PCOM_CCI_VIBRATE, 7, 0) rc=%d\r\n", __func__, rc);
#endif
data1 = vol.volume;
data2 = vol.volume;
rc = msm_proc_comm(PCOM_CCI_SET_AUX_PGA_GAIN, &data1, &data2);
//printk("[Aaron][%s] msm_proc_comm(PCOM_CCI_SET_AUX_PGA_GAIN, 7, 0) rc=%d\r\n", __func__, rc);
}
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_device_config dev;
struct snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void *) arg, sizeof(dev))) {
rc = -EFAULT;
break;
}
if (check_mute(dev.ear_mute) ||
check_mute(dev.mic_mute) ) {
pr_err("snd_ioctl set device: invalid mute status.\n");
rc = -EINVAL;
break;
}
/* Prevent wrong device to make the snd processor crashing */
check_device(&dev.device);
if(force_headset && (force_headset==2))
dev.device=2;
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
//pr_info("snd_set_device %d %d %d\n", dev.device, dev.ear_mute, dev.mic_mute);
printk("TEST snd_set_device %d %d %d\n", dev.device, dev.ear_mute, dev.mic_mute);
if(!snd->ept) {
pr_err("No sound endpoint found, can't set snd_device");
return -EIO;
}
msm_rpc_setup_req(&dmsg.hdr, RPC_SND_PROG, RPC_SND_VERS,
SND_SET_DEVICE_PROC);
rc = msm_rpc_write(snd->ept, &dmsg, sizeof(dmsg));
htc_pwrsink_audio_path_set(dmsg.args.device);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void *) arg, sizeof(vol))) {
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE && vol.method != SND_METHOD_AUDIO) {
pr_err("snd_ioctl set volume: invalid method.\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
//pr_info("snd_set_volume %d %d %d\n", vol.device, vol.method, vol.volume);
printk("snd_set_volume %d %d %d\n", vol.device, vol.method, vol.volume);
msm_rpc_setup_req(&vmsg.hdr, RPC_SND_PROG, RPC_SND_VERS, SND_SET_VOLUME_PROC);
rc = msm_rpc_write(snd->ept, &vmsg, sizeof(vmsg));
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
pr_err("snd_ioctl get endpoint: invalid pointer.\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
pr_err("snd_ioctl unknown command.\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
//SW2-6-MM-RC-Audio_Porting-00*{
#ifndef CONFIG_NK_AUDIO
/* FIH, Karen Liao, 2009/10/23 { */
/* [F0X.FC-663], Allow user to use the normal headset.*/
if((dev.device == 3) && EnableAbnormalHS) // 3: SND_DEVICE_STEREO_HEADSET
dev.device = 27; // 27: SND_DEVICE_STEREO_HEADSET_WITH_INNER_MIC
/* } FIH, Karen Liao, 2009/10/23 */
#else
//a.This is the solution for headset detect while inserting 4-ring headset during device boot
// snd_set_device to 3 to enable mic_bias in AudioHardware is too late to update mHeadphone.
//b.For headset detect in phone call, insert 4-ring headset and then inserting 3-ring headset
// mHeadphone is updated too late, so update mHeadphone here to switch to the correct path.
//MM_ERR("set device[1]: ptt gpio(21) = %d , mHeadphone=%d\n", gpio_get_value(21), mHeadphone);
if ((dev.device == 3) &&(gpio_get_value(21) == 0))
{
mHeadphone = false;
}
else if ((dev.device == 3) &&(gpio_get_value(21) == 1))
{
mHeadphone = true;
}
if((dev.device == 3) && mHeadphone)
dev.device = 27;
#endif
//SW2-6-MM-RC-Audio_Porting-00*}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct snd_set_device_msg dmsg;
struct snd_set_volume_msg vmsg;
struct snd_avc_ctl_msg avc_msg;
struct snd_agc_ctl_msg agc_msg;
//LGE_SND_UPDATE_S [
struct snd_72xx_rpc_extcmd_msg rpc_extcmd_msg;
struct snd_audio_cal_msg cal_msg;
//LGE_SND_UPDATE_E ]
struct msm_snd_device_config dev;
struct msm_snd_volume_config vol;
//LGE_SND_UPDATE_S [
struct msm_snd_72xx_rpc_extcmd_config rpc_extcmd_conf;
struct msm_snd_audio_cal_config snd_audio_cal_conf;
//LGE_SND_UPDATE_E ]
struct snd_ctxt *snd = file->private_data;
int rc = 0;
uint32_t avc, agc;
mutex_lock(&snd->lock);
switch (cmd) {
case SND_SET_DEVICE:
if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
MM_ERR("set device: invalid pointer\n");
rc = -EFAULT;
break;
}
dmsg.args.device = cpu_to_be32(dev.device);
dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
if (check_mute(dev.ear_mute) < 0 ||
check_mute(dev.mic_mute) < 0) {
MM_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_INFO("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
rc = msm_rpc_call(snd->ept,
SND_SET_DEVICE_PROC,
&dmsg, sizeof(dmsg), 5 * HZ);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_ERR("set volume: invalid pointer\n");
rc = -EFAULT;
break;
}
vmsg.args.device = cpu_to_be32(vol.device);
vmsg.args.method = cpu_to_be32(vol.method);
if (vol.method != SND_METHOD_VOICE) {
MM_ERR("set volume: invalid method\n");
rc = -EINVAL;
break;
}
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = -1;
vmsg.args.client_data = 0;
MM_INFO("snd_set_volume %d %d %d\n", vol.device,
vol.method, vol.volume);
rc = msm_rpc_call(snd->ept,
SND_SET_VOLUME_PROC,
&vmsg, sizeof(vmsg), 5 * HZ);
break;
case SND_AVC_CTL:
if (get_user(avc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((avc != 1) && (avc != 0)) {
rc = -EINVAL;
break;
}
avc_msg.args.avc_ctl = cpu_to_be32(avc);
avc_msg.args.cb_func = -1;
avc_msg.args.client_data = 0;
MM_INFO("snd_avc_ctl %d\n", avc);
rc = msm_rpc_call(snd->ept,
SND_AVC_CTL_PROC,
&avc_msg, sizeof(avc_msg), 5 * HZ);
break;
case SND_AGC_CTL:
if (get_user(agc, (uint32_t __user *) arg)) {
rc = -EFAULT;
break;
} else if ((agc != 1) && (agc != 0)) {
rc = -EINVAL;
break;
}
agc_msg.args.agc_ctl = cpu_to_be32(agc);
agc_msg.args.cb_func = -1;
agc_msg.args.client_data = 0;
MM_INFO("snd_agc_ctl %d\n", agc);
rc = msm_rpc_call(snd->ept,
SND_AGC_CTL_PROC,
&agc_msg, sizeof(agc_msg), 5 * HZ);
break;
case SND_GET_NUM_ENDPOINTS:
if (copy_to_user((void __user *)arg,
&snd->snd_epts->num, sizeof(unsigned))) {
MM_ERR("get endpoint: invalid pointer\n");
rc = -EFAULT;
}
break;
case SND_GET_ENDPOINT:
rc = get_endpoint(snd, arg);
break;
//LGE_SND_UPDATE_S [
case SND_72XX_RPC_EXTCMD:
if (copy_from_user(&rpc_extcmd_conf, (void __user *) arg, sizeof(rpc_extcmd_conf))) {
MM_ERR("SND_72XX_RPC_EXTCMD: invalid pointer\n");
rc = -EFAULT;
break;
}
rpc_extcmd_msg.args.rpc_extcmd = cpu_to_be32(rpc_extcmd_conf.rpc_extcmd);
rpc_extcmd_msg.args.option = cpu_to_be32(rpc_extcmd_conf.option);
rpc_extcmd_msg.args.cb_func = -1;
rpc_extcmd_msg.args.client_data = 0;
MM_INFO("SND_72XX_RPC_EXTCMD %d %d \n", rpc_extcmd_conf.rpc_extcmd, rpc_extcmd_conf.option);
rc = msm_rpc_call_reply(snd->ept,
SND_72XX_RPC_EXTCMD_PROC,
&rpc_extcmd_msg, sizeof(rpc_extcmd_msg), &(extcmd_msg_rep), sizeof (extcmd_msg_rep), 5 * HZ);
if (rc < 0){
MM_ERR("rpc err because");
}
else {
rpc_extcmd_conf.result = be32_to_cpu(extcmd_msg_rep.result);
MM_INFO("snd 72xx rpc extcmd result=[%d]\n", rpc_extcmd_conf.result);
if (copy_to_user((void __user *)arg, &rpc_extcmd_conf, sizeof(rpc_extcmd_conf))) {
MM_INFO("snd_ioctl get voccal: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
case SND_AUDIO_CAL:
if (copy_from_user(&snd_audio_cal_conf, (void __user *) arg, sizeof(snd_audio_cal_conf))) {
MM_ERR("SND_AUDIO_CAL: invalid pointer\n");
rc = -EFAULT;
break;
}
cal_msg.args.nCalType = cpu_to_be32(snd_audio_cal_conf.nCalType);
cal_msg.args.nCmd = cpu_to_be32(snd_audio_cal_conf.nCmd);
cal_msg.args.nDevice = cpu_to_be32(snd_audio_cal_conf.nDevice);
cal_msg.args.nIndex = cpu_to_be32(snd_audio_cal_conf.nIndex);
cal_msg.args.nSubIndex = cpu_to_be32(snd_audio_cal_conf.nSubIndex);
cal_msg.args.nItem = cpu_to_be32(snd_audio_cal_conf.nItem);
cal_msg.args.cb_func = -1;
cal_msg.args.client_data = 0;
MM_INFO("SND_AUDIO_CAL %d %d %d %d %d %d\n", snd_audio_cal_conf.nCalType, snd_audio_cal_conf.nCmd,
snd_audio_cal_conf.nDevice, snd_audio_cal_conf.nIndex, snd_audio_cal_conf.nSubIndex, snd_audio_cal_conf.nItem);
rc = msm_rpc_call_reply(snd->ept,
SND_AUDIO_CAL_PROC,
&cal_msg, sizeof(cal_msg), &(cal_msg_rep), sizeof (cal_msg_rep), 5 * HZ);
if (rc < 0){
MM_ERR("rpc err because");
}
else {
snd_audio_cal_conf.result = be32_to_cpu(cal_msg_rep.result);
MM_INFO("snd audio cal result=[%d]\n", snd_audio_cal_conf.result);
if (copy_to_user((void __user *)arg, &snd_audio_cal_conf, sizeof(snd_audio_cal_conf))) {
MM_INFO("snd_ioctl get voccal: invalid write pointer.\n");
rc = -EFAULT;
}
}
break;
//LGE_SND_UPDATE_E ]
default:
MM_ERR("unknown command\n");
rc = -EINVAL;
break;
}
mutex_unlock(&snd->lock);
return rc;
}
