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_AUD_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_AUD_ERR("set device: invalid mute status\n");
rc = -EINVAL;
break;
}
dmsg.args.cb_func = -1;
dmsg.args.client_data = 0;
MM_AUD_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);
htc_pwrsink_audio_path_set(dmsg.args.device);
break;
case SND_SET_VOLUME:
if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
MM_AUD_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_AUD_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_AUD_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_AUD_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_AUD_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_AUD_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;
}
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 = cpu_to_be32(0x11111111);
dmsg.args.client_data = cpu_to_be32(0x11223344);
pr_info("snd_set_device %d %d %d\n", dev.device,
dev.ear_mute, dev.mic_mute);
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);
vmsg.args.volume = cpu_to_be32(vol.volume);
vmsg.args.cb_func = cpu_to_be32(0x11111111);
vmsg.args.client_data = cpu_to_be32(0x11223344);
pr_info("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;
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_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;
}
