Initial Contribution
msm-2.6.38: tag AU_LINUX_ANDROID_GINGERBREAD.02.03.04.00.142
Signed-off-by: Bryan Huntsman <bryanh@codeaurora.org>
diff --git a/sound/soc/msm/msm7x30.c b/sound/soc/msm/msm7x30.c
new file mode 100644
index 0000000..94e37ca
--- /dev/null
+++ b/sound/soc/msm/msm7x30.c
@@ -0,0 +1,1004 @@
+/* Copyright (c) 2008-2011, Code Aurora Forum. All rights reserved.
+ *
+ * All source code in this file is licensed under the following license except
+ * where indicated.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See the GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you can find it at http://www.fsf.org.
+ */
+
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/time.h>
+#include <linux/wait.h>
+#include <linux/platform_device.h>
+#include <sound/core.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/pcm.h>
+#include <sound/tlv.h>
+#include <sound/initval.h>
+#include <sound/control.h>
+#include <asm/dma.h>
+#include <linux/dma-mapping.h>
+#include <linux/msm_audio.h>
+
+#include "msm7kv2-pcm.h"
+#include <asm/mach-types.h>
+#include <mach/qdsp5v2/audio_dev_ctl.h>
+#include <mach/debug_mm.h>
+#include <mach/qdsp5v2/afe.h>
+
+static struct platform_device *msm_audio_snd_device;
+struct audio_locks the_locks;
+EXPORT_SYMBOL(the_locks);
+struct msm_volume msm_vol_ctl;
+EXPORT_SYMBOL(msm_vol_ctl);
+static struct snd_kcontrol_new snd_msm_controls[];
+
+char snddev_name[AUDIO_DEV_CTL_MAX_DEV][44];
+#define MSM_MAX_VOLUME 0x2000
+#define MSM_VOLUME_STEP ((MSM_MAX_VOLUME+17)/100) /* 17 added to avoid
+ more deviation */
+#define LOOPBACK_ENABLE 0x1
+#define LOOPBACK_DISABLE 0x0
+
+static int device_index; /* Count of Device controls */
+static int simple_control; /* Count of simple controls*/
+static int src_dev;
+static int dst_dev;
+static int loopback_status;
+
+
+static int msm_scontrol_count_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 1;
+ return 0;
+}
+
+static int msm_scontrol_count_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = simple_control;
+ return 0;
+}
+
+static int msm_v_call_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 1;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = 1;
+ return 0;
+}
+
+static int msm_v_call_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ return 0;
+}
+
+static int msm_v_call_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int start = ucontrol->value.integer.value[0];
+ if (start)
+ broadcast_event(AUDDEV_EVT_START_VOICE, DEVICE_IGNORE,
+ SESSION_IGNORE);
+ else
+ broadcast_event(AUDDEV_EVT_END_VOICE, DEVICE_IGNORE,
+ SESSION_IGNORE);
+ return 0;
+}
+
+static int msm_v_mute_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = 2;
+ return 0;
+}
+
+static int msm_v_mute_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ return 0;
+}
+
+static int msm_v_mute_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int dir = ucontrol->value.integer.value[0];
+ int mute = ucontrol->value.integer.value[1];
+ return msm_set_voice_mute(dir, mute);
+}
+
+static int msm_v_volume_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2; /* Volume */
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = 100;
+ return 0;
+}
+
+static int msm_v_volume_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ return 0;
+}
+
+static int msm_v_volume_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int dir = ucontrol->value.integer.value[0];
+ int volume = ucontrol->value.integer.value[1];
+
+ return msm_set_voice_vol(dir, volume);
+}
+
+static int msm_volume_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 3; /* Volume and 10-base multiply factor*/
+ uinfo->value.integer.min = 0;
+
+ /* limit the muliply factor to 4 decimal digit */
+ uinfo->value.integer.max = 1000000;
+ return 0;
+}
+static int msm_volume_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ return 0;
+}
+
+static int msm_volume_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int ret = 0;
+ int session_id = ucontrol->value.integer.value[0];
+ int volume = ucontrol->value.integer.value[1];
+ int factor = ucontrol->value.integer.value[2];
+ u32 session_mask = 0;
+
+
+ if (factor > 10000)
+ return -EINVAL;
+
+ if ((volume < 0) || (volume/factor > 100))
+ return -EINVAL;
+
+ volume = (MSM_VOLUME_STEP * volume);
+
+ /* Convert back to original decimal point by removing the 10-base factor
+ * and discard the fractional portion
+ */
+
+ volume = volume/factor;
+
+ if (volume > MSM_MAX_VOLUME)
+ volume = MSM_MAX_VOLUME;
+
+ /* Only Decoder volume control supported */
+ session_mask = (0x1 << (session_id) << (8 * ((int)AUDDEV_CLNT_DEC-1)));
+ msm_vol_ctl.volume = volume;
+ MM_DBG("session_id %d, volume %d", session_id, volume);
+ broadcast_event(AUDDEV_EVT_STREAM_VOL_CHG, DEVICE_IGNORE,
+ session_mask);
+
+ return ret;
+}
+
+static int msm_voice_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 3; /* Device */
+
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = msm_snddev_devcount();
+ return 0;
+}
+
+static int msm_voice_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int rc = 0;
+ uint32_t rx_dev_id;
+ uint32_t tx_dev_id;
+ struct msm_snddev_info *rx_dev_info;
+ struct msm_snddev_info *tx_dev_info;
+ int set = ucontrol->value.integer.value[2];
+ u32 session_mask;
+
+ if (!set)
+ return -EPERM;
+ /* Rx Device Routing */
+ rx_dev_id = ucontrol->value.integer.value[0];
+ rx_dev_info = audio_dev_ctrl_find_dev(rx_dev_id);
+
+ if (IS_ERR(rx_dev_info)) {
+ MM_ERR("pass invalid dev_id\n");
+ rc = PTR_ERR(rx_dev_info);
+ return rc;
+ }
+
+ if (!(rx_dev_info->capability & SNDDEV_CAP_RX)) {
+ MM_ERR("First Dev is supposed to be RX\n");
+ return -EFAULT;
+ }
+
+ MM_DBG("route cfg %d STREAM_VOICE_RX type\n",
+ rx_dev_id);
+
+ msm_set_voc_route(rx_dev_info, AUDIO_ROUTE_STREAM_VOICE_RX,
+ rx_dev_id);
+
+ session_mask = 0x1 << (8 * ((int)AUDDEV_CLNT_VOC-1));
+
+ broadcast_event(AUDDEV_EVT_DEV_CHG_VOICE, rx_dev_id, session_mask);
+
+
+ /* Tx Device Routing */
+ tx_dev_id = ucontrol->value.integer.value[1];
+ tx_dev_info = audio_dev_ctrl_find_dev(tx_dev_id);
+
+ if (IS_ERR(tx_dev_info)) {
+ MM_ERR("pass invalid dev_id\n");
+ rc = PTR_ERR(tx_dev_info);
+ return rc;
+ }
+
+ if (!(tx_dev_info->capability & SNDDEV_CAP_TX)) {
+ MM_ERR("Second Dev is supposed to be Tx\n");
+ return -EFAULT;
+ }
+
+ MM_DBG("route cfg %d %d type\n",
+ tx_dev_id, AUDIO_ROUTE_STREAM_VOICE_TX);
+
+ msm_set_voc_route(tx_dev_info, AUDIO_ROUTE_STREAM_VOICE_TX,
+ tx_dev_id);
+
+ broadcast_event(AUDDEV_EVT_DEV_CHG_VOICE, tx_dev_id, session_mask);
+
+ if (rx_dev_info->opened)
+ broadcast_event(AUDDEV_EVT_DEV_RDY, rx_dev_id, session_mask);
+
+ if (tx_dev_info->opened)
+ broadcast_event(AUDDEV_EVT_DEV_RDY, tx_dev_id, session_mask);
+
+ return rc;
+}
+
+static int msm_voice_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ /* TODO: query Device list */
+ return 0;
+}
+
+static int msm_device_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 1; /* Device */
+
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = msm_snddev_devcount();
+ return 0;
+}
+
+static int msm_device_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int rc = 0;
+ int set = 0;
+ struct msm_audio_route_config route_cfg;
+ struct msm_snddev_info *dev_info;
+ struct msm_snddev_info *dst_dev_info;
+ struct msm_snddev_info *src_dev_info;
+ int tx_freq = 0;
+ int rx_freq = 0;
+ u32 set_freq = 0;
+
+ set = ucontrol->value.integer.value[0];
+ route_cfg.dev_id = ucontrol->id.numid - device_index;
+ dev_info = audio_dev_ctrl_find_dev(route_cfg.dev_id);
+ if (IS_ERR(dev_info)) {
+ MM_ERR("pass invalid dev_id\n");
+ rc = PTR_ERR(dev_info);
+ return rc;
+ }
+ MM_INFO("device %s set %d\n", dev_info->name, set);
+
+ if (set) {
+ if (!dev_info->opened) {
+ set_freq = dev_info->sample_rate;
+ if (!msm_device_is_voice(route_cfg.dev_id)) {
+ msm_get_voc_freq(&tx_freq, &rx_freq);
+ if (dev_info->capability & SNDDEV_CAP_TX)
+ set_freq = tx_freq;
+
+ if (set_freq == 0)
+ set_freq = dev_info->sample_rate;
+ } else
+ set_freq = dev_info->sample_rate;
+
+
+ MM_ERR("device freq =%d\n", set_freq);
+ rc = dev_info->dev_ops.set_freq(dev_info, set_freq);
+ if (rc < 0) {
+ MM_ERR("device freq failed!\n");
+ return rc;
+ }
+ dev_info->set_sample_rate = rc;
+ rc = 0;
+ rc = dev_info->dev_ops.open(dev_info);
+ if (rc < 0) {
+ MM_ERR("Enabling %s failed", dev_info->name);
+ return rc;
+ }
+ dev_info->opened = 1;
+ broadcast_event(AUDDEV_EVT_DEV_RDY, route_cfg.dev_id,
+ SESSION_IGNORE);
+ /* Event to notify client for device info */
+ broadcast_event(AUDDEV_EVT_DEVICE_INFO,
+ route_cfg.dev_id, SESSION_IGNORE);
+ if ((route_cfg.dev_id == src_dev) ||
+ (route_cfg.dev_id == dst_dev)) {
+ dst_dev_info = audio_dev_ctrl_find_dev(
+ dst_dev);
+ if (IS_ERR(dst_dev_info)) {
+ pr_err("dst_dev:%s:pass invalid"
+ "dev_id\n", __func__);
+ rc = PTR_ERR(dst_dev_info);
+ return rc;
+ }
+ src_dev_info = audio_dev_ctrl_find_dev(
+ src_dev);
+ if (IS_ERR(src_dev_info)) {
+ pr_err("src_dev:%s:pass invalid"
+ "dev_id\n", __func__);
+ rc = PTR_ERR(src_dev_info);
+ return rc;
+ }
+ if ((dst_dev_info->opened) &&
+ (src_dev_info->opened)) {
+ pr_debug("%d: Enable afe_loopback\n",
+ __LINE__);
+ afe_ext_loopback(LOOPBACK_ENABLE,
+ dst_dev_info->copp_id,
+ src_dev_info->copp_id);
+ loopback_status = 1;
+ }
+ }
+ }
+ } else {
+ if (dev_info->opened) {
+ broadcast_event(AUDDEV_EVT_REL_PENDING,
+ route_cfg.dev_id,
+ SESSION_IGNORE);
+ rc = dev_info->dev_ops.close(dev_info);
+ if (rc < 0) {
+ MM_ERR("Snd device failed close!\n");
+ return rc;
+ } else {
+ dev_info->opened = 0;
+ broadcast_event(AUDDEV_EVT_DEV_RLS,
+ route_cfg.dev_id,
+ SESSION_IGNORE);
+ }
+ if (loopback_status == 1) {
+ if ((route_cfg.dev_id == src_dev) ||
+ (route_cfg.dev_id == dst_dev)) {
+ dst_dev_info = audio_dev_ctrl_find_dev(
+ dst_dev);
+ if (IS_ERR(dst_dev_info)) {
+ pr_err("dst_dev:%s:pass invalid"
+ "dev_id\n", __func__);
+ rc = PTR_ERR(dst_dev_info);
+ return rc;
+ }
+ src_dev_info = audio_dev_ctrl_find_dev(
+ src_dev);
+ if (IS_ERR(src_dev_info)) {
+ pr_err("dst_dev:%s:pass invalid"
+ "dev_id\n", __func__);
+ rc = PTR_ERR(src_dev_info);
+ return rc;
+ }
+ pr_debug("%d: Disable afe_loopback\n",
+ __LINE__);
+ afe_ext_loopback(LOOPBACK_DISABLE,
+ dst_dev_info->copp_id,
+ src_dev_info->copp_id);
+ loopback_status = 0;
+ }
+ }
+ }
+
+ }
+ return rc;
+}
+
+static int msm_device_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int rc = 0;
+ struct msm_audio_route_config route_cfg;
+ struct msm_snddev_info *dev_info;
+
+ route_cfg.dev_id = ucontrol->id.numid - device_index;
+ dev_info = audio_dev_ctrl_find_dev(route_cfg.dev_id);
+
+ if (IS_ERR(dev_info)) {
+ MM_ERR("pass invalid dev_id\n");
+ rc = PTR_ERR(dev_info);
+ return rc;
+ }
+
+ ucontrol->value.integer.value[0] = dev_info->copp_id;
+ ucontrol->value.integer.value[1] = dev_info->capability;
+
+ return 0;
+}
+
+static int msm_route_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 3; /* Device */
+
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = msm_snddev_devcount();
+ return 0;
+}
+
+static int msm_route_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ /* TODO: query Device list */
+ return 0;
+}
+
+static int msm_route_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int rc = 0;
+ int enc_freq = 0;
+ int requested_freq = 0;
+ struct msm_audio_route_config route_cfg;
+ struct msm_snddev_info *dev_info;
+ int session_id = ucontrol->value.integer.value[0];
+ int set = ucontrol->value.integer.value[2];
+ u32 session_mask = 0;
+ route_cfg.dev_id = ucontrol->value.integer.value[1];
+
+ if (ucontrol->id.numid == 2)
+ route_cfg.stream_type = AUDIO_ROUTE_STREAM_PLAYBACK;
+ else
+ route_cfg.stream_type = AUDIO_ROUTE_STREAM_REC;
+
+ MM_DBG("route cfg %d %d type for popp %d set value %d\n",
+ route_cfg.dev_id, route_cfg.stream_type, session_id, set);
+ dev_info = audio_dev_ctrl_find_dev(route_cfg.dev_id);
+
+ if (IS_ERR(dev_info)) {
+ MM_ERR("pass invalid dev_id\n");
+ rc = PTR_ERR(dev_info);
+ return rc;
+ }
+ if (route_cfg.stream_type == AUDIO_ROUTE_STREAM_PLAYBACK) {
+ rc = msm_snddev_set_dec(session_id, dev_info->copp_id, set);
+ session_mask =
+ (0x1 << (session_id) << (8 * ((int)AUDDEV_CLNT_DEC-1)));
+ if (!set) {
+ if (dev_info->opened) {
+ broadcast_event(AUDDEV_EVT_REL_PENDING,
+ route_cfg.dev_id,
+ session_mask);
+
+ broadcast_event(AUDDEV_EVT_DEV_RLS,
+ route_cfg.dev_id,
+ session_mask);
+ }
+ dev_info->sessions &= ~(session_mask);
+ } else {
+ dev_info->sessions = dev_info->sessions | session_mask;
+ if (dev_info->opened) {
+ broadcast_event(AUDDEV_EVT_DEV_RDY,
+ route_cfg.dev_id,
+ session_mask);
+ /* Event to notify client for device info */
+ broadcast_event(AUDDEV_EVT_DEVICE_INFO,
+ route_cfg.dev_id,
+ session_mask);
+ }
+ }
+ } else {
+ rc = msm_snddev_set_enc(session_id, dev_info->copp_id, set);
+ session_mask =
+ (0x1 << (session_id)) << (8 * ((int)AUDDEV_CLNT_ENC-1));
+ if (!set) {
+ if (dev_info->opened)
+ broadcast_event(AUDDEV_EVT_DEV_RLS,
+ route_cfg.dev_id,
+ session_mask);
+ dev_info->sessions &= ~(session_mask);
+ } else {
+ dev_info->sessions = dev_info->sessions | session_mask;
+ enc_freq = msm_snddev_get_enc_freq(session_id);
+ requested_freq = enc_freq;
+ if (enc_freq > 0) {
+ rc = msm_snddev_request_freq(&enc_freq,
+ session_id,
+ SNDDEV_CAP_TX,
+ AUDDEV_CLNT_ENC);
+ MM_DBG("sample rate configured %d"
+ "sample rate requested %d\n",
+ enc_freq, requested_freq);
+ if ((rc <= 0) || (enc_freq != requested_freq)) {
+ MM_DBG("msm_snddev_withdraw_freq\n");
+ rc = msm_snddev_withdraw_freq
+ (session_id,
+ SNDDEV_CAP_TX, AUDDEV_CLNT_ENC);
+ broadcast_event(AUDDEV_EVT_FREQ_CHG,
+ route_cfg.dev_id,
+ SESSION_IGNORE);
+ }
+ }
+ if (dev_info->opened) {
+ broadcast_event(AUDDEV_EVT_DEV_RDY,
+ route_cfg.dev_id,
+ session_mask);
+ /* Event to notify client for device info */
+ broadcast_event(AUDDEV_EVT_DEVICE_INFO,
+ route_cfg.dev_id,
+ session_mask);
+ }
+ }
+ }
+
+ if (rc < 0) {
+ MM_ERR("device could not be assigned!\n");
+ return -EFAULT;
+ }
+
+ return rc;
+}
+
+static int msm_device_volume_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = 100;
+ return 0;
+}
+
+static int msm_device_volume_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct msm_snddev_info *dev_info;
+
+ int dev_id = ucontrol->value.integer.value[0];
+
+ dev_info = audio_dev_ctrl_find_dev(dev_id);
+ ucontrol->value.integer.value[0] = dev_info->dev_volume;
+
+ return 0;
+}
+
+static int msm_device_volume_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int rc = -EPERM;
+ struct msm_snddev_info *dev_info;
+
+ int dev_id = ucontrol->value.integer.value[0];
+ int volume = ucontrol->value.integer.value[1];
+
+ MM_DBG("dev_id = %d, volume = %d\n", dev_id, volume);
+
+ dev_info = audio_dev_ctrl_find_dev(dev_id);
+
+ if (IS_ERR(dev_info)) {
+ rc = PTR_ERR(dev_info);
+ MM_ERR("audio_dev_ctrl_find_dev failed. %ld\n",
+ PTR_ERR(dev_info));
+ return rc;
+ }
+
+ MM_DBG("dev_name = %s dev_id = %d, volume = %d\n",
+ dev_info->name, dev_id, volume);
+
+ if (dev_info->dev_ops.set_device_volume)
+ rc = dev_info->dev_ops.set_device_volume(dev_info, volume);
+ else {
+ MM_INFO("device %s does not support device volume "
+ "control.", dev_info->name);
+ return -EPERM;
+ }
+
+ return rc;
+}
+
+static int msm_reset_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 1;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = 0;
+ return 0;
+}
+
+static int msm_reset_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ return 0;
+}
+
+static int msm_reset_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ MM_DBG("Resetting all devices\n");
+ return msm_reset_all_device();
+}
+
+
+static int msm_dual_mic_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2;
+ uinfo->value.integer.min = 0;
+ /*Max value is decided based on MAX ENC sessions*/
+ uinfo->value.integer.max = MAX_AUDREC_SESSIONS - 1;
+ return 0;
+}
+
+static int msm_dual_mic_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int enc_session_id = ucontrol->value.integer.value[0];
+ ucontrol->value.integer.value[1] =
+ msm_get_dual_mic_config(enc_session_id);
+ MM_DBG("session id = %d, config = %ld\n", enc_session_id,
+ ucontrol->value.integer.value[1]);
+ return 0;
+}
+
+static int msm_dual_mic_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int enc_session_id = ucontrol->value.integer.value[0];
+ int dual_mic_config = ucontrol->value.integer.value[1];
+ MM_DBG("session id = %d, config = %d\n", enc_session_id,
+ dual_mic_config);
+ return msm_set_dual_mic_config(enc_session_id, dual_mic_config);
+}
+
+static int msm_device_mute_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 2;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = msm_snddev_devcount();
+ return 0;
+}
+
+static int msm_device_mute_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ return 0;
+}
+
+static int msm_device_mute_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int dev_id = ucontrol->value.integer.value[0];
+ int mute = ucontrol->value.integer.value[1];
+ struct msm_snddev_info *dev_info;
+ int afe_dev_id = 0;
+ int volume = 0x4000;
+
+ dev_info = audio_dev_ctrl_find_dev(dev_id);
+ if (IS_ERR(dev_info)) {
+ MM_ERR("pass invalid dev_id %d\n", dev_id);
+ return PTR_ERR(dev_info);
+ }
+
+ if (dev_info->capability & SNDDEV_CAP_RX)
+ return -EPERM;
+
+ MM_DBG("Muting device id %d(%s)\n", dev_id, dev_info->name);
+
+ if (dev_info->copp_id == 0)
+ afe_dev_id = AFE_HW_PATH_CODEC_TX;
+ if (dev_info->copp_id == 1)
+ afe_dev_id = AFE_HW_PATH_AUXPCM_TX;
+ if (dev_info->copp_id == 2)
+ afe_dev_id = AFE_HW_PATH_MI2S_TX;
+ if (mute)
+ volume = 0;
+ afe_device_volume_ctrl(afe_dev_id, volume);
+ return 0;
+}
+
+static int msm_loopback_info(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
+{
+ uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+ uinfo->count = 3;
+ uinfo->value.integer.min = 0;
+ uinfo->value.integer.max = msm_snddev_devcount();
+ return 0;
+}
+
+static int msm_loopback_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ ucontrol->value.integer.value[0] = 0;
+ return 0;
+}
+
+static int msm_loopback_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ int rc = 0;
+ struct msm_snddev_info *src_dev_info = NULL; /* TX device */
+ struct msm_snddev_info *dst_dev_info = NULL; /* RX device */
+ int dst_dev_id = ucontrol->value.integer.value[0];
+ int src_dev_id = ucontrol->value.integer.value[1];
+ int set = ucontrol->value.integer.value[2];
+
+ pr_debug("%s: set=%d\n", __func__, set);
+
+ dst_dev_info = audio_dev_ctrl_find_dev(dst_dev_id);
+ if (IS_ERR(dst_dev_info)) {
+ pr_err("dst_dev:%s:pass invalid dev_id\n", __func__);
+ rc = PTR_ERR(dst_dev_info);
+ return rc;
+ }
+ if (!(dst_dev_info->capability & SNDDEV_CAP_RX)) {
+ pr_err("Destination device %d is not RX device\n",
+ dst_dev_id);
+ return -EFAULT;
+ }
+
+ src_dev_info = audio_dev_ctrl_find_dev(src_dev_id);
+ if (IS_ERR(src_dev_info)) {
+ pr_err("src_dev:%s:pass invalid dev_id\n", __func__);
+ rc = PTR_ERR(src_dev_info);
+ return rc;
+ }
+ if (!(src_dev_info->capability & SNDDEV_CAP_TX)) {
+ pr_err("Source device %d is not TX device\n", src_dev_id);
+ return -EFAULT;
+ }
+
+ if (set) {
+ pr_debug("%s:%d:Enabling AFE_Loopback\n", __func__, __LINE__);
+ src_dev = src_dev_id;
+ dst_dev = dst_dev_id;
+ loopback_status = 1;
+ if ((dst_dev_info->opened) && (src_dev_info->opened))
+ afe_ext_loopback(LOOPBACK_ENABLE,
+ dst_dev_info->copp_id,
+ src_dev_info->copp_id);
+ } else {
+ pr_debug("%s:%d:Disabling AFE_Loopback\n", __func__, __LINE__);
+ src_dev = DEVICE_IGNORE;
+ dst_dev = DEVICE_IGNORE;
+ loopback_status = 0;
+ afe_ext_loopback(LOOPBACK_DISABLE,
+ dst_dev_info->copp_id,
+ src_dev_info->copp_id);
+ }
+ return 0;
+}
+
+static struct snd_kcontrol_new snd_dev_controls[AUDIO_DEV_CTL_MAX_DEV];
+
+static int snd_dev_ctl_index(int idx)
+{
+ struct msm_snddev_info *dev_info;
+
+ dev_info = audio_dev_ctrl_find_dev(idx);
+ if (IS_ERR(dev_info)) {
+ MM_ERR("pass invalid dev_id\n");
+ return PTR_ERR(dev_info);
+ }
+ if (sizeof(dev_info->name) <= 44)
+ sprintf(&snddev_name[idx][0] , "%s", dev_info->name);
+
+ snd_dev_controls[idx].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+ snd_dev_controls[idx].access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
+ snd_dev_controls[idx].name = &snddev_name[idx][0];
+ snd_dev_controls[idx].index = idx;
+ snd_dev_controls[idx].info = msm_device_info;
+ snd_dev_controls[idx].get = msm_device_get;
+ snd_dev_controls[idx].put = msm_device_put;
+ snd_dev_controls[idx].private_value = 0;
+ return 0;
+
+}
+
+#define MSM_EXT(xname, fp_info, fp_get, fp_put, addr) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
+ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+ .name = xname, \
+ .info = fp_info,\
+ .get = fp_get, .put = fp_put, \
+ .private_value = addr, \
+}
+
+static struct snd_kcontrol_new snd_msm_controls[] = {
+ MSM_EXT("Count", msm_scontrol_count_info, msm_scontrol_count_get, \
+ NULL, 0),
+ MSM_EXT("Stream", msm_route_info, msm_route_get, \
+ msm_route_put, 0),
+ MSM_EXT("Record", msm_route_info, msm_route_get, \
+ msm_route_put, 0),
+ MSM_EXT("Voice", msm_voice_info, msm_voice_get, \
+ msm_voice_put, 0),
+ MSM_EXT("Volume", msm_volume_info, msm_volume_get, \
+ msm_volume_put, 0),
+ MSM_EXT("VoiceVolume", msm_v_volume_info, msm_v_volume_get, \
+ msm_v_volume_put, 0),
+ MSM_EXT("VoiceMute", msm_v_mute_info, msm_v_mute_get, \
+ msm_v_mute_put, 0),
+ MSM_EXT("Voice Call", msm_v_call_info, msm_v_call_get, \
+ msm_v_call_put, 0),
+ MSM_EXT("Device_Volume", msm_device_volume_info,
+ msm_device_volume_get, msm_device_volume_put, 0),
+ MSM_EXT("Reset", msm_reset_info,
+ msm_reset_get, msm_reset_put, 0),
+ MSM_EXT("DualMic Switch", msm_dual_mic_info,
+ msm_dual_mic_get, msm_dual_mic_put, 0),
+ MSM_EXT("Device_Mute", msm_device_mute_info,
+ msm_device_mute_get, msm_device_mute_put, 0),
+ MSM_EXT("Sound Device Loopback", msm_loopback_info,
+ msm_loopback_get, msm_loopback_put, 0),
+};
+
+static int msm_new_mixer(struct snd_soc_codec *codec)
+{
+ unsigned int idx;
+ int err;
+ int dev_cnt;
+
+ strcpy(codec->card->snd_card->mixername, "MSM Mixer");
+ for (idx = 0; idx < ARRAY_SIZE(snd_msm_controls); idx++) {
+ err = snd_ctl_add(codec->card->snd_card,
+ snd_ctl_new1(&snd_msm_controls[idx], NULL));
+ if (err < 0)
+ MM_ERR("ERR adding ctl\n");
+ }
+ dev_cnt = msm_snddev_devcount();
+
+ for (idx = 0; idx < dev_cnt; idx++) {
+ if (!snd_dev_ctl_index(idx)) {
+ err = snd_ctl_add(codec->card->snd_card,
+ snd_ctl_new1(&snd_dev_controls[idx], NULL));
+ if (err < 0)
+ MM_ERR("ERR adding ctl\n");
+ } else
+ return 0;
+ }
+ simple_control = ARRAY_SIZE(snd_msm_controls);
+ device_index = simple_control + 1;
+ return 0;
+}
+
+static int msm_soc_dai_init(
+ struct snd_soc_pcm_runtime *rtd)
+{
+ int ret = 0;
+ struct snd_soc_codec *codec = rtd->codec;
+ ret = msm_new_mixer(codec);
+ if (ret < 0)
+ MM_ERR("msm_soc: ALSA MSM Mixer Fail\n");
+
+ mutex_init(&the_locks.lock);
+ mutex_init(&the_locks.write_lock);
+ mutex_init(&the_locks.read_lock);
+ spin_lock_init(&the_locks.read_dsp_lock);
+ spin_lock_init(&the_locks.write_dsp_lock);
+ spin_lock_init(&the_locks.mixer_lock);
+ init_waitqueue_head(&the_locks.enable_wait);
+ init_waitqueue_head(&the_locks.eos_wait);
+ init_waitqueue_head(&the_locks.write_wait);
+ init_waitqueue_head(&the_locks.read_wait);
+ src_dev = DEVICE_IGNORE;
+ dst_dev = DEVICE_IGNORE;
+
+ return ret;
+}
+
+static struct snd_soc_dai_link msm_dai[] = {
+{
+ .name = "MSM Primary I2S",
+ .stream_name = "DSP 1",
+ .cpu_dai_name = "msm-cpu-dai.0",
+ .platform_name = "msm-dsp-audio.0",
+ .codec_name = "msm-codec-dai.0",
+ .codec_dai_name = "msm-codec-dai",
+ .init = &msm_soc_dai_init,
+},
+#ifdef CONFIG_SND_MVS_SOC
+{
+ .name = "MSM Primary Voip",
+ .stream_name = "MVS",
+ .cpu_dai_name = "mvs-cpu-dai.0",
+ .platform_name = "msm-mvs-audio.0",
+ .codec_name = "mvs-codec-dai.0",
+ .codec_dai_name = "mvs-codec-dai",
+},
+#endif
+};
+
+static struct snd_soc_card snd_soc_card_msm = {
+ .name = "msm-audio",
+ .dai_link = msm_dai,
+ .num_links = ARRAY_SIZE(msm_dai),
+};
+
+static int __init msm_audio_init(void)
+{
+ int ret;
+
+ msm_audio_snd_device = platform_device_alloc("soc-audio", -1);
+ if (!msm_audio_snd_device)
+ return -ENOMEM;
+
+ platform_set_drvdata(msm_audio_snd_device, &snd_soc_card_msm);
+ ret = platform_device_add(msm_audio_snd_device);
+ if (ret) {
+ platform_device_put(msm_audio_snd_device);
+ return ret;
+ }
+
+ return ret;
+}
+
+static void __exit msm_audio_exit(void)
+{
+ platform_device_unregister(msm_audio_snd_device);
+}
+
+module_init(msm_audio_init);
+module_exit(msm_audio_exit);
+
+MODULE_DESCRIPTION("PCM module");
+MODULE_LICENSE("GPL v2");