diff options
Diffstat (limited to 'ANDROID_3.4.5/sound/soc/codecs/vt1603.c')
| -rwxr-xr-x | ANDROID_3.4.5/sound/soc/codecs/vt1603.c | 1249 |
1 files changed, 1249 insertions, 0 deletions
diff --git a/ANDROID_3.4.5/sound/soc/codecs/vt1603.c b/ANDROID_3.4.5/sound/soc/codecs/vt1603.c new file mode 100755 index 00000000..eaa3d28e --- /dev/null +++ b/ANDROID_3.4.5/sound/soc/codecs/vt1603.c @@ -0,0 +1,1249 @@ +/*++ + * linux/sound/soc/codecs/vt1603.c + * WonderMedia audio driver for ALSA + * + * Copyright c 2010 WonderMedia Technologies, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * 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, see <http://www.gnu.org/licenses/>. + * + * WonderMedia Technologies, Inc. + * 4F, 533, Chung-Cheng Road, Hsin-Tien, Taipei 231, R.O.C +--*/ + +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/init.h> +#include <linux/delay.h> +#include <linux/pm.h> +#include <linux/platform_device.h> +#include <linux/version.h> +#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/pcm_params.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h> +#include <sound/initval.h> +#include <sound/tlv.h> +#include <linux/interrupt.h> +#include <asm/irq.h> +#include <linux/workqueue.h> +#include <linux/switch.h> +#include <linux/slab.h> +#include <linux/proc_fs.h> +#include <linux/notifier.h> +#include <linux/reboot.h> + +#include "vt1603.h" +#include <linux/mfd/vt1603/core.h> + +#define VT1603_TIMER_INTERVAL 100 // ms + +static struct snd_soc_codec *gvt1603_codec = NULL; // + +struct vt1603_priv { + unsigned int sysclk; + struct switch_dev hp_switch; // state of headphone insert or not + struct work_struct work; + struct snd_soc_codec *codec; + struct timer_list timer; // timer for detecting headphone + struct proc_dir_entry *proc; + struct notifier_block reboot_notifier; +}; + +struct vt1603_boardinfo { + int hp_level; // 0: headset level low; 1: high + int ignore_hp_event; + int rec_src; // 0: AMIC-IN; 1: DMIC-IN + + int hpd_rm; //add 2013-11-26 + int hp_debounce; //add 2014-1-14 + int timer_del; //2014-1-20 tvbox + + int out_on; //2014-4-29 av out on for tvbox noisy. hw not good! +}; +static struct vt1603_boardinfo vt1603_boardinfo; + +extern int wmt_getsyspara(char *varname, unsigned char *varval, int *varlen); + +static const u16 vt1603_regs[] = { + 0x0020, 0x00D7, 0x00D7, 0x0004, /* 0-3 */ + 0x0000, 0x0040, 0x0000, 0x00c0, /* 4-7 */ + 0x00c0, 0x0010, 0x0001, 0x0041, /* 8-11 */ + 0x0000, 0x0000, 0x000b, 0x0093, /* 12-15 */ + 0x0004, 0x0016, 0x0026, 0x0060, /* 16-19 */ + 0x001a, 0x0000, 0x0002, 0x0000, /* 20-23 */ + 0x0000, 0x000a, 0x0000, 0x0010, /* 24-27 */ + 0x0000, 0x00e2, 0x0000, 0x0000, /* 28-31 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 32-35 */ + 0x0000, 0x000c, 0x0054, 0x0000, /* 36-39 */ + 0x0001, 0x000c, 0x000c, 0x000c, /* 40-43 */ + 0x000c, 0x000c, 0x00c0, 0x00d5, /* 44-47 */ + 0x00c5, 0x0012, 0x0085, 0x002b, /* 48-51 */ + 0x00cd, 0x00cd, 0x008e, 0x008d, /* 52-55 */ + 0x00e0, 0x00a6, 0x00a5, 0x0050, /* 56-59 */ + 0x00e9, 0x00cf, 0x0040, 0x0000, /* 60-63 */ + 0x0000, 0x0008, 0x0004, 0x0000, /* 64-67 */ + 0x0040, 0x0000, 0x0040, 0x0000, /* 68-71 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 72-75 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 76-79 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 80-83 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 84-87 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 88-91 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 92-95 */ + 0x00c4, 0x0079, 0x000c, 0x0024, /* 96-99 */ + 0x0016, 0x0016, 0x0060, 0x0002, /* 100-103 */ + 0x005b, 0x0003, 0x0039, 0x0039, /* 104-107 */ + 0x00fe, 0x0012, 0x0034, 0x0000, /* 108-111 */ + 0x0004, 0x00f0, 0x0000, 0x0000, /* 112-115 */ + 0x0000, 0x0000, 0x0003, 0x0000, /* 116-119 */ + 0x0000, 0x0000, 0x0000, 0x0000, /* 120-123 */ + 0x00f2, 0x0020, 0x0023, 0x006e, /* 124-127 */ + 0x0019, 0x0040, 0x0000, 0x0004, /* 128-131 */ + 0x000a, 0x0075, 0x0035, 0x00b0, /* 132-135 */ + 0x0040, 0x0000, 0x0000, 0x0000, /* 136-139 */ + 0x0088, 0x0013, 0x000c, 0x0003, /* 140-143 */ + 0x0000, 0x0000, 0x0008, 0x0000, /* 144-147 */ + 0x0003, 0x0020, 0x0030, 0x0018, /* 148-151 */ + 0x001b, +}; + +/*----------------------------------------------------------------------*/ + + +/*---------------------Control Interface Functions----------------------*/ + +static int vt1603_write(struct snd_soc_codec *codec, + unsigned int reg, unsigned int value) +{ + int ret = vt1603_reg_write(codec->control_data, reg, value); + if (ret == 0) + ((u16 *)codec->reg_cache)[reg] = value; + return ret; +} + +static unsigned int vt1603_read(struct snd_soc_codec *codec, + unsigned int reg) +{ + return ((u16 *)codec->reg_cache)[reg]; +} + +static int vt1603_hw_write(struct snd_soc_codec *codec, + unsigned int reg, unsigned int value) +{ + return vt1603_reg_write(codec->control_data, reg, value); +} + +static unsigned int vt1603_hw_read(struct snd_soc_codec *codec, + unsigned int reg) +{ + u8 val; + int ret = vt1603_reg_read(codec->control_data, reg, &val); + if (ret == 0) + return val; + else + return ((u16 *)codec->reg_cache)[reg]; +} + +/*----------------------------------------------------------------------*/ + + +/*----------------------IRQ handle Functions----------------------------*/ + +static void vt1603_set_switch_state(struct snd_soc_codec *codec) +{ + /* Just report hp state, don't switch hw device, app will handle it. */ + + struct vt1603_priv *vt1603 = snd_soc_codec_get_drvdata(codec); + unsigned int val = vt1603_hw_read(codec, VT1603_R21); + + if (vt1603_boardinfo.hp_level) { + if (val & BIT1) { + val &= ~BIT1; + snd_soc_write(codec, VT1603_R21, val); + if (!vt1603_boardinfo.ignore_hp_event) + switch_set_state(&vt1603->hp_switch, 0); + pr_info("<<<vt1603: hp out!\n"); + } + else { + val |= BIT1; + snd_soc_write(codec, VT1603_R21, val); + if (!vt1603_boardinfo.ignore_hp_event) + switch_set_state(&vt1603->hp_switch, 1); + pr_info("<<<vt1603: hp in!\n"); + } + } + else { + if (val & BIT1) { + val &= ~BIT1; + snd_soc_write(codec, VT1603_R21, val); + if (!vt1603_boardinfo.ignore_hp_event) + switch_set_state(&vt1603->hp_switch, 1); + pr_info("<<<vt1603: hp in!\n"); + } + else { + val |= BIT1; + snd_soc_write(codec, VT1603_R21, val); + if (!vt1603_boardinfo.ignore_hp_event) + switch_set_state(&vt1603->hp_switch, 0); + pr_info("<<<vt1603: hp out!\n"); + } + } +} + +static void vt1603_codec_irq_handle(struct work_struct *work) +{ + struct vt1603_priv *priv = container_of(work, struct vt1603_priv, work); + struct snd_soc_codec *codec = priv->codec; + unsigned int val; + static unsigned int count = 0; + int hp_state = 0; //switch_get_state(&priv->hp_switch); + if (!vt1603_boardinfo.hpd_rm) + hp_state = switch_get_state(&priv->hp_switch); + + unsigned int debounce = (hp_state == 0) ? 3 : 1; // sw-debounce for headset plugin + + if (vt1603_boardinfo.hp_debounce > 0) + debounce = (hp_state == 0) ? vt1603_boardinfo.hp_debounce : 1; + + + + val = vt1603_hw_read(codec, VT1603_R51); + if (val & BIT1) { + val = vt1603_hw_read(codec, VT1603_R1b); + val |= BIT1; + snd_soc_write(codec, VT1603_R1b, val); + val &= ~BIT1; + snd_soc_write(codec, VT1603_R1b, val); + count++; + } + else { + count = 0; + } + + if (count == debounce) { + pr_info("vt1603: hpdetect\n"); + vt1603_set_switch_state(codec); + // clear headphone irq mask + val = vt1603_hw_read(codec,VT1603_R1b); + val |= BIT1; + snd_soc_write(codec, VT1603_R1b, val); + val &= ~BIT1; + snd_soc_write(codec, VT1603_R1b, val); + count = 0; + } + + val = vt1603_hw_read(codec, VT1603_R52); + if (val & BIT4) { + pr_info("vt1603: left cld oc\n"); + val = vt1603_hw_read(codec,VT1603_R1c); + val |= BIT4; + snd_soc_write(codec, VT1603_R1c, val); + val &= ~BIT4; + snd_soc_write(codec, VT1603_R1c, val); + } + if (val & BIT3) { + pr_info("vt1603: right cld oc\n"); + val = vt1603_hw_read(codec,VT1603_R1c); + val |= BIT3; + snd_soc_write(codec, VT1603_R1c, val); + val &= ~BIT3; + snd_soc_write(codec, VT1603_R1c, val); + } +} + +static void vt1603_timer_handler(unsigned long data) +{ + struct vt1603_priv *vt1603 = (struct vt1603_priv *)data; + schedule_work(&vt1603->work); + mod_timer(&vt1603->timer, jiffies + msecs_to_jiffies(VT1603_TIMER_INTERVAL)); +} + +/*----------------------------------------------------------------------*/ + + +/*--------------------Mixer controls & dapm-----------------------------*/ + +static const DECLARE_TLV_DB_SCALE(digital_tlv, -9550, 50, 1); +static const DECLARE_TLV_DB_SCALE(digital_clv, -4350, 50, 1); +static const DECLARE_TLV_DB_SCALE(adc_boost_clv, 0, 1000, 1); +static const DECLARE_TLV_DB_SCALE(dac_boost_tlv, 0, 600, 0); +static const DECLARE_TLV_DB_SCALE(adc_pga_clv, -1650, 150, 1); +static const DECLARE_TLV_DB_SCALE(analog_tlv, -2100, 300, 1); +static const DECLARE_TLV_DB_SCALE(hp_mixer_clv, -5700, 100, 1); +static const DECLARE_TLV_DB_SCALE(cld_mixer_clv, -300, 300, 1); + +static const char *adc_cutoff_freq_txt[] = { + "Hi-fi mode", + "Voice mode 1", + "Voice mode 2", + "Voice mode 3", +}; + +static const struct soc_enum adc_cutoff_freq = +SOC_ENUM_SINGLE(VT1603_R00, 3, 4, adc_cutoff_freq_txt); + +static const char *lr_txt[] = { + "Left", "Right" +}; + +static const char *clamper_limit_voltage_txt[] = { + "Vih=2.40V, Vil=0.90V, P=0.63W", + "Vih=2.45V, Vil=0.85V, P=0.72W", + "Vih=2.50V, ViL=0.80V, P=0.81W", + "Vih=2.55V, Vil=0.75V, P=0.91W", + "Vih=2.60V, Vil=0.70V, P=1.02W", + "Vih=2.65V, Vil=0.65V, P=1.12W", + "Vih=2.70V, Vil=0.60V, P=1.24W", + "Vih=2.75V, Vil=0.55V, P=1.36W", + "Vih=2.80V, Vil=0.50V, P=1.49W", + "Vih=2.85V, Vil=0.45V, P=1.62W", + "Vih=2.90V, Vil=0.40V, P=1.76W", + "Vih=2.95V, Vil=0.35V, P=1.90W", + "Vih=3.00V, Vil=0.30V, P=2.05W", + "Vih=3.05V, Vil=0.25V, P=2.20W", + "Vih=3.10V, Vil=0.20V, P=2.37W", + "Vih=3.15V, Vil=0.15V, P=2.53W", +}; + +static const char *clamper_work_voltage_txt[] = { + "Voh=3.10V, Vol=1.90V, P=0.36W", + "Voh=3.25V, Vol=1.75V, P=0.56W", + "Voh=3.40V, Vol=1.60V, P=0.81W", + "Voh=3.55V, Vol=1.45V, P=1.10W", + "Voh=3.70V, Vol=1.30V, P=1.44W", + "Voh=3.85V, Vol=1.15V, P=1.82W", + "Voh=4.00V, Vol=1.00V, P=2.25W", + "Voh=4.15V, Vol=0.85V, P=2.72W", +}; + +static const struct soc_enum dacl_src = +SOC_ENUM_SINGLE(VT1603_R0b, 7, 2, lr_txt); + +static const struct soc_enum dacr_src = +SOC_ENUM_SINGLE(VT1603_R0b, 6, 2, lr_txt); + +static const struct soc_enum adcl_src = +SOC_ENUM_SINGLE(VT1603_R03, 3, 2, lr_txt); + +static const struct soc_enum adcr_src = +SOC_ENUM_SINGLE(VT1603_R03, 2, 2, lr_txt); + +static const struct soc_enum clamper_limit_voltage = +SOC_ENUM_SINGLE(VT1603_R87, 4, 16, clamper_limit_voltage_txt); + +static const struct soc_enum clamper_work_voltage = +SOC_ENUM_SINGLE(VT1603_R87, 0, 8, clamper_work_voltage_txt); + +static const struct snd_kcontrol_new vt1603_snd_controls[] = { +/* Volume */ +SOC_DOUBLE_R_TLV("Digital Capture Volume", VT1603_R01, VT1603_R02, 0, 0x7f, 0, digital_clv), +SOC_DOUBLE_R_TLV("Digital Playback Volume", VT1603_R07, VT1603_R08, 0, 0xc0, 0, digital_tlv), +SOC_DOUBLE_R_TLV("Analog Playback Volume", VT1603_R72, VT1603_R73, 0, 0x07, 1, analog_tlv), +SOC_DOUBLE_R_TLV("Input Boost Volume", VT1603_R64, VT1603_R65, 6, 4, 0, adc_boost_clv), +SOC_DOUBLE_R_TLV("Input PGA Volume", VT1603_R64, VT1603_R65, 1, 0x1f, 0, adc_pga_clv), +SOC_DOUBLE_TLV("Output Boost Volume", VT1603_R06, 0, 3, 7, 0, dac_boost_tlv), +SOC_DOUBLE_TLV("Output CLD Volume", VT1603_R91, 5, 2, 7, 0, cld_mixer_clv), +SOC_DOUBLE_R_TLV("Output HP Volume", VT1603_R6a, VT1603_R6b, 0, 0x3f, 0, hp_mixer_clv), + +/* Switch */ +SOC_SINGLE("EQ Switch", VT1603_R28, 0, 1, 0), + +SOC_SINGLE("DAC Mono Mix Switch", VT1603_R0d, 4, 1, 0), +SOC_SINGLE("Left DAC Switch", VT1603_R62, 5, 1, 0), +SOC_SINGLE("Right DAC Switch", VT1603_R62, 4, 1, 0), + +SOC_ENUM("Left DAC Source", dacl_src), +SOC_ENUM("Right DAC Source", dacr_src), + +SOC_ENUM("Digital Capture Voice Mode", adc_cutoff_freq), +SOC_ENUM("Left ADC Source", adcl_src), +SOC_ENUM("Right ADC Source", adcr_src), + +SOC_DOUBLE("Analog Playback Switch", VT1603_R71, 7, 6, 1, 1), +SOC_SINGLE("Digital Playback Switch", VT1603_R0b, 0, 1, 1), +SOC_DOUBLE("Digital Capture Switch", VT1603_R63, 7, 6, 1, 0), + +SOC_SINGLE("Headset Switch", VT1603_R68, 4, 1, 1), +SOC_SINGLE("Headfree Switch", VT1603_R25, 1, 1, 0), + +SOC_SINGLE("Left CLD Switch", VT1603_R82, 3, 1, 1), +SOC_SINGLE("Right CLD Switch", VT1603_R82, 4, 1, 1), + +SOC_ENUM("Limit Voltage of Power Clamper", clamper_limit_voltage), +SOC_ENUM("Voltage of Clamper Work", clamper_work_voltage), +}; + +/* DAPM Controls */ + +static const struct snd_kcontrol_new linmix_controls[] = { +SOC_DAPM_SINGLE("Left Mic Switch", VT1603_R8e, 5, 1, 0), +SOC_DAPM_SINGLE("Left Linein Switch", VT1603_R8e, 7, 1, 0), +}; + +static const struct snd_kcontrol_new rinmix_controls[] = { +SOC_DAPM_SINGLE("Right Mic Switch", VT1603_R8e, 4, 1, 0), +SOC_DAPM_SINGLE("Right Linein Switch", VT1603_R8e, 6, 1, 0), +}; + +static const struct snd_kcontrol_new loutmix_controls[] = { +SOC_DAPM_SINGLE("Left Input Mixer Switch", VT1603_R71, 3, 1, 0), +SOC_DAPM_SINGLE("DACL Switch", VT1603_R71, 1, 1, 0), +}; + +static const struct snd_kcontrol_new routmix_controls[] = { +SOC_DAPM_SINGLE("Right Input Mixer Switch", VT1603_R71, 2, 1, 0), +SOC_DAPM_SINGLE("DACR Switch", VT1603_R71, 0, 1, 0), +}; + +static const struct snd_kcontrol_new lcld_controls[] = { +SOC_DAPM_SINGLE("Left Output Mixer Switch", VT1603_R90, 5, 1, 0), +SOC_DAPM_SINGLE("DACL Switch", VT1603_R90, 4, 1, 0), +}; + +static const struct snd_kcontrol_new rcld_controls[] = { +SOC_DAPM_SINGLE("Right Output Mixer Switch", VT1603_R90, 3, 1, 0), +SOC_DAPM_SINGLE("DACR Switch", VT1603_R90, 2, 1, 0), +}; + +static const struct snd_kcontrol_new lhp_controls[] = { +SOC_DAPM_SINGLE("Left Output Mixer Switch", VT1603_R69, 5, 1, 0), +SOC_DAPM_SINGLE("DACL Switch", VT1603_R69, 7, 1, 0), +}; + +static const struct snd_kcontrol_new rhp_controls[] = { +SOC_DAPM_SINGLE("Right Output Mixer Switch", VT1603_R69, 2, 1, 0), +SOC_DAPM_SINGLE("DACR Switch", VT1603_R69, 4, 1, 0), +}; + +static const struct snd_soc_dapm_widget vt1603_dapm_widgets[] = { +SND_SOC_DAPM_INPUT("Mic"), +SND_SOC_DAPM_INPUT("Linein"), +SND_SOC_DAPM_INPUT("Internal ADC Source"), + +SND_SOC_DAPM_PGA("Left Input Boost", VT1603_R67, 7, 0, NULL, 0), +SND_SOC_DAPM_PGA("Right Input Boost", VT1603_R67, 6, 0, NULL, 0), + +SND_SOC_DAPM_PGA("Left Input PGA", VT1603_R67, 5, 0, NULL, 0), +SND_SOC_DAPM_PGA("Right Input PGA", VT1603_R67, 4, 0, NULL, 0), + + +SND_SOC_DAPM_MIXER("Left Input Mixer", VT1603_R66, 6, 1, + linmix_controls, ARRAY_SIZE(linmix_controls)), +SND_SOC_DAPM_MIXER("Right Input Mixer", VT1603_R66, 5, 1, + rinmix_controls, ARRAY_SIZE(rinmix_controls)), + +SND_SOC_DAPM_ADC("ADCL", "Left Capture", VT1603_R01, 7, 1), +SND_SOC_DAPM_ADC("ADCR", "Right Capture", VT1603_R02, 7, 1), + +//SND_SOC_DAPM_DAC("DACL", "Left Playback", VT1603_R62, 5, 0), +//SND_SOC_DAPM_DAC("DACR", "Right Playback", VT1603_R62, 4, 0), + +SND_SOC_DAPM_INPUT("DACL"), +SND_SOC_DAPM_INPUT("DACR"), + +SND_SOC_DAPM_MIXER("Left Output Mixer", VT1603_R72, 6, 0, + loutmix_controls, ARRAY_SIZE(loutmix_controls)), +SND_SOC_DAPM_MIXER("Right Output Mixer", VT1603_R73, 6, 0, + routmix_controls, ARRAY_SIZE(routmix_controls)), + +SND_SOC_DAPM_MIXER("Left CLD Mixer", VT1603_R91, 1, 0, + lcld_controls, ARRAY_SIZE(lcld_controls)), +SND_SOC_DAPM_MIXER("Right CLD Mixer", VT1603_R91, 0, 0, + rcld_controls, ARRAY_SIZE(rcld_controls)), + +SND_SOC_DAPM_PGA("Left CLD PGA", VT1603_R82, 3, 1, NULL, 0), +SND_SOC_DAPM_PGA("Right CLD PGA", VT1603_R82, 4, 1, NULL, 0), + +SND_SOC_DAPM_MIXER("Left HP Mixer", VT1603_R68, 1, 1, + lhp_controls, ARRAY_SIZE(lhp_controls)), +SND_SOC_DAPM_MIXER("Right HP Mixer", VT1603_R68, 0, 1, + rhp_controls, ARRAY_SIZE(rhp_controls)), + +SND_SOC_DAPM_OUTPUT("Internal DAC Sink"), +SND_SOC_DAPM_OUTPUT("Left HP"), +SND_SOC_DAPM_OUTPUT("Right HP"), +SND_SOC_DAPM_OUTPUT("Left SPK"), +SND_SOC_DAPM_OUTPUT("Right SPK"), +}; + +static const struct snd_soc_dapm_route audio_map[] = { + /* Make DACs turn on when playing even if not mixed into any outputs */ + //{"Internal DAC Sink", NULL, "DACL"}, + //{"Internal DAC Sink", NULL, "DACR"}, + + /* Make ADCs turn on when recording even if not mixed from any inputs */ + //{"ADCL", NULL, "Internal ADC Source"}, + //{"ADCR", NULL, "Internal ADC Source"}, + + + /* Capture route */ + + { "Left Input Mixer", "Left Linein Switch", "Linein" }, + { "Left Input Mixer", "Left Mic Switch", "Mic" }, + { "Right Input Mixer", "Right Linein Switch", "Linein" }, + { "Right Input Mixer", "Right Mic Switch", "Mic" }, + + { "Left Input Boost", NULL, "Left Input Mixer"}, + { "Right Input Boost", NULL, "Right Input Mixer"}, + + { "Left Input PGA", NULL, "Left Input Boost"}, + { "Right Input PGA", NULL, "Right Input Boost"}, + + { "ADCL", NULL, "Left Input PGA" }, + { "ADCR", NULL, "Right Input PGA" }, + + //{ "Left Input Mixer", NULL, "Left Input PGA" }, + //{ "Right Input Mixer", NULL, "Right Input PGA" }, + + /* Playback route */ + + //{ "Left Output Mixer", "Left Input Mixer Switch", "Left Input Mixer" }, + { "Left Output Mixer", "Left Input Mixer Switch", "Left Input PGA"}, + { "Left Output Mixer", "DACL Switch", "DACL" }, + //{ "Right Output Mixer", "Right Input Mixer Switch", "Right Input Mixer" }, + { "Right Output Mixer", "Right Input Mixer Switch", "Right Input PGA"}, + { "Right Output Mixer", "DACR Switch", "DACR" }, + + { "Left CLD Mixer", "Left Output Mixer Switch", "Left Output Mixer" }, + { "Left CLD Mixer", "DACL Switch", "DACL" }, + { "Right CLD Mixer", "Right Output Mixer Switch", "Right Output Mixer" }, + { "Right CLD Mixer", "DACR Switch", "DACR" }, + + { "Left HP Mixer", "Left Output Mixer Switch", "Left Output Mixer" }, + { "Left HP Mixer", "DACL Switch", "DACL" }, + { "Right HP Mixer", "Right Output Mixer Switch", "Right Output Mixer" }, + { "Right HP Mixer", "DACR Switch", "DACR" }, + + { "Left CLD PGA", NULL, "Left CLD Mixer" }, + { "Right CLD PGA", NULL, "Right CLD Mixer" }, + + { "Left HP", NULL, "Left HP Mixer" }, + { "Right HP", NULL, "Right HP Mixer" }, + + { "Left SPK", NULL, "Left CLD PGA" }, + { "Right SPK", NULL, "Right CLD PGA" }, +}; + +/*----------------------------------------------------------------------*/ + + +/*----------------------codec dai functions-----------------------------*/ + +struct _coeff_div { + u32 mclk; + u32 rate; + u16 fs; + u8 sr; + u8 bclk_div; +}; + +/* codec hifi mclk clock divider coefficients */ +static const struct _coeff_div coeff_div[] = { + /* 8k */ + {12288000, 8000, 1536, 0x4, 0x0}, + /* 11.025k */ + {11289600, 11025, 1024, 0x8, 0x0}, + /* 16k */ + {12288000, 16000, 768, 0x5, 0x0}, + /* 22.05k */ + {11289600, 22050, 512, 0x9, 0x0}, + /* 32k */ + {12288000, 32000, 384, 0x7, 0x0}, + /* 44.1k */ + {11289600, 44100, 256, 0x6, 0x07}, + /* 48k */ + {12288000, 48000, 256, 0x0, 0x07}, + /* 96k */ + {12288000, 96000, 128, 0x1, 0x04}, +}; + +static inline int get_coeff(int mclk, int rate) +{ + int i; + for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { + if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) + return i; + } + return -EINVAL; +} + +static int vt1603_set_dai_sysclk(struct snd_soc_dai *codec_dai, + int clk_id, unsigned int freq, int dir) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct vt1603_priv *vt1603 = snd_soc_codec_get_drvdata(codec); + switch (freq) { + case 11289600: + case 12000000: + case 12288000: + case 16934400: + case 18432000: + vt1603->sysclk = freq; + return 0; + } + return -EINVAL; +} + +static int vt1603_set_dai_fmt(struct snd_soc_dai *codec_dai, + unsigned int fmt) +{ + struct snd_soc_codec *codec = codec_dai->codec; + u16 iface = snd_soc_read(codec, VT1603_R19); + + /* set master/slave audio interface */ + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBM_CFM: + iface |= BIT5 ; + break; + case SND_SOC_DAIFMT_CBS_CFS: + break; + default: + return -EINVAL; + } + + /* interface format */ + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + iface |= 0x0002; + break; + case SND_SOC_DAIFMT_RIGHT_J: + break; + case SND_SOC_DAIFMT_LEFT_J: + iface |= 0x0001; + break; + case SND_SOC_DAIFMT_DSP_A: + iface |= 0x0003; + break; + case SND_SOC_DAIFMT_DSP_B: + iface |= 0x0013; + break; + default: + return -EINVAL; + } + + /* clock inversion */ + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { + case SND_SOC_DAIFMT_NB_NF: + break; + case SND_SOC_DAIFMT_IB_IF: + iface |= 0x0090; + break; + case SND_SOC_DAIFMT_IB_NF: + iface |= 0x0080; + break; + case SND_SOC_DAIFMT_NB_IF: + iface |= 0x0010; + break; + default: + return -EINVAL; + } + + snd_soc_write(codec, VT1603_R19, iface); + return 0; +} + +static int vt1603_pcm_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct snd_soc_codec *codec = rtd->codec; + struct vt1603_priv *vt1603 = snd_soc_codec_get_drvdata(codec); + u16 val; + u16 iface = snd_soc_read(codec, VT1603_R19) & 0x73; + int coeff = get_coeff(vt1603->sysclk, params_rate(params)); + + /* bit size */ + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + break; + case SNDRV_PCM_FORMAT_S20_3LE: + iface |= 0x04; + break; + case SNDRV_PCM_FORMAT_S24_LE: + iface |= 0x08; + break; + case SNDRV_PCM_FORMAT_S32_LE: + iface |= 0x0c; + break; + } + + /* set iface & srate */ + snd_soc_write(codec, VT1603_R19, iface); + + if (coeff >= 0) { + val = snd_soc_read(codec, VT1603_R42); + val &= 0xf0; + val |= coeff_div[coeff].bclk_div; + snd_soc_write(codec, VT1603_R42, val); + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + val = snd_soc_read(codec, VT1603_R05); + val &= 0xf0; + val |= coeff_div[coeff].sr; + snd_soc_write(codec, VT1603_R05, val); + } + + if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + val = snd_soc_read(codec, VT1603_R03); + val &= 0x0f; + val |= ((coeff_div[coeff].sr<<4) & 0xf0); + snd_soc_write(codec, VT1603_R03, val); + } + } + + return 0; +} + +static int vt1603_set_bias_level(struct snd_soc_codec *codec, + enum snd_soc_bias_level level) +{ + u16 val; + + switch (level) { + case SND_SOC_BIAS_ON: + break; + + case SND_SOC_BIAS_PREPARE: + val = snd_soc_read(codec, VT1603_R96); + val |= BIT4+BIT5; + snd_soc_write(codec, VT1603_R96, val); + break; + + case SND_SOC_BIAS_STANDBY: + break; + + case SND_SOC_BIAS_OFF: + break; + } + + codec->dapm.bias_level = level; + return 0; +} + +static struct snd_soc_dai_ops vt1603_dai_ops = { + .hw_params = vt1603_pcm_hw_params, + .set_fmt = vt1603_set_dai_fmt, + .set_sysclk = vt1603_set_dai_sysclk, +}; + +struct snd_soc_dai_driver vt1603_dai = { + .name = "VT1603", + .playback = { + .stream_name = "Playback", + .channels_min = 1, + .channels_max = 2, + .rates = SNDRV_PCM_RATE_8000_96000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + }, + .capture = { + .stream_name = "Capture", + .channels_min = 1, + .channels_max = 2, + .rates = SNDRV_PCM_RATE_8000_96000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + }, + .ops = &vt1603_dai_ops, +}; + +/*----------------------------------------------------------------------*/ + + +/*----------------------------------------------------------------------*/ + +static void vt1603_get_boardinfo(void) +{ + int ret = 0; + unsigned char buf[64]; + int varlen = sizeof(buf); + + memset(buf, 0x0, sizeof(buf)); + ret = wmt_getsyspara("wmt.audio.i2s", buf, &varlen); + if (ret == 0) { + sscanf(buf, "vt1603:%d:%d:%d", + &vt1603_boardinfo.hp_level, + &vt1603_boardinfo.ignore_hp_event, + &vt1603_boardinfo.rec_src); + } + else { + vt1603_boardinfo.hp_level = 0; + vt1603_boardinfo.ignore_hp_event = 0; + vt1603_boardinfo.rec_src = 0; + } + + memset(buf, 0x0, sizeof(buf)); + vt1603_boardinfo.hpd_rm = 0; + ret = wmt_getsyspara("wmt.vt1603.hpd.rm", buf, &varlen); + if (ret == 0) { + sscanf(buf, "%d", + &vt1603_boardinfo.hpd_rm); + } + else { + vt1603_boardinfo.hpd_rm = 0; + + } + printk("<<<<%s hpd_rm %d\n", __func__, vt1603_boardinfo.hpd_rm); + + memset(buf, 0x0, sizeof(buf)); + vt1603_boardinfo.hp_debounce = 0; + ret = wmt_getsyspara("wmt.vt1603.hp.debounce", buf, &varlen); + if (ret == 0) { + sscanf(buf, "%d", + &vt1603_boardinfo.hp_debounce); + } + else { + vt1603_boardinfo.hp_debounce = 0; + + } + printk("<<<<%s hp_debounce %d\n", __func__, vt1603_boardinfo.hp_debounce); + + + memset(buf, 0x0, sizeof(buf)); + vt1603_boardinfo.timer_del = 0; + ret = wmt_getsyspara("wmt.vt1603.timer.del", buf, &varlen); + if (ret == 0) { + sscanf(buf, "%d", + &vt1603_boardinfo.timer_del); + } + else { + vt1603_boardinfo.timer_del = 0; + + } + printk("<<<<%s timer_del %d\n", __func__, vt1603_boardinfo.timer_del); + + memset(buf, 0x0, sizeof(buf)); + vt1603_boardinfo.out_on = 0; + ret = wmt_getsyspara("wmt.vt1603.out_on", buf, &varlen); + if (ret == 0) { + sscanf(buf, "%d", + &vt1603_boardinfo.out_on); + } + else { + vt1603_boardinfo.out_on = 0; + + } + printk("<<<<%s out_on %d\n", __func__, vt1603_boardinfo.out_on); +} + +static int vt1603_readproc(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + struct vt1603_priv *vt1603 = data; + pr_info("\nvt1603 regs dump:\n"); + vt1603_regs_dump(vt1603->codec->control_data); + return 0; +} + +static void vt1603_codec_reset(struct snd_soc_codec *codec) +{ + unsigned int val; + + vt1603_hw_write(codec, 0xc2, 0x01); + + // reset all registers to default settings + vt1603_hw_write(codec, VT1603_REG_RESET, 0xff); + vt1603_hw_write(codec, VT1603_REG_RESET, 0x00); + + val = vt1603_hw_read(codec, VT1603_R60); + val &= ~(BIT6 + BIT7); + vt1603_hw_write(codec, VT1603_R60, val); + val |= BIT6 + BIT7; + vt1603_hw_write(codec, VT1603_R60, val); +} + +static void vt1603_codec_init(struct snd_soc_codec *codec) +{ + unsigned int val; + + // vt1603 touch uses irq low active??? + if (vt1603_boardinfo.hp_level) { + //hp high + snd_soc_write(codec, VT1603_R21, 0xfd); + } + else { + //hp low + snd_soc_write(codec, VT1603_R21, 0xff); + } + + // vt1603 codec irq settings + snd_soc_write(codec, VT1603_R1b, 0xff); + snd_soc_write(codec, VT1603_R1b, 0xfd); + snd_soc_write(codec, VT1603_R1c, 0xff); + snd_soc_write(codec, VT1603_R1d, 0xff); + snd_soc_write(codec, VT1603_R24, 0x04); + + snd_soc_write(codec, VT1603_R95, 0x00); + snd_soc_write(codec, VT1603_R60, 0xc7); + snd_soc_write(codec, VT1603_R93, 0x02); + snd_soc_write(codec, VT1603_R7b, 0x10); + snd_soc_write(codec, VT1603_R92, 0x2c); + + // r4 is reserved, I don't know more about it. + snd_soc_write(codec, VT1603_R04, 0x00); + // r9[5] is reserved, I don't know more about it. + val = snd_soc_read(codec, VT1603_R09); + val |= BIT5; + snd_soc_write(codec, VT1603_R09, val); + // r79 is reserved, I don't know more about it. + val = snd_soc_read(codec, VT1603_R79); + val |= BIT2; + val &= ~(BIT0+BIT1); + snd_soc_write(codec, VT1603_R79, val); + // r7a is reserved, I don't know more about it. + val = snd_soc_read(codec, VT1603_R7a); + val |= BIT3+BIT4+BIT7; + snd_soc_write(codec, VT1603_R7a, val); + // r87 is reserved, I don't know more about it. + snd_soc_write(codec, VT1603_R87, 0x90); + // r88 is reserved, I don't know more about it. + snd_soc_write(codec, VT1603_R88, 0x28); + // r8a is reserved, I don't know more about it. + val = snd_soc_read(codec, VT1603_R8a); + val |= BIT1; + snd_soc_write(codec, VT1603_R8a, val); + // enable CLK_SYS, CLK_DSP, CLK_AIF + val = snd_soc_read(codec, VT1603_R40); + val |= BIT4+BIT5+BIT6; + snd_soc_write(codec, VT1603_R40, val); + // set DAC sample rate divier=CLK_SYS/1, DAC clock divider=DAC_CLK_512X + val = snd_soc_read(codec, VT1603_R41); + val &= ~(BIT3+BIT2+BIT1+BIT0); + val |= BIT1;//add for mclk 24.576M, 10Khz 17kHz sine distortion 2014-6-12 + snd_soc_write(codec, VT1603_R41, val); + // set BCLK rate=CLK_SYS/8 + val = snd_soc_read(codec, VT1603_R42); + val |= BIT0+BIT1+BIT2; + val &= ~BIT3; + snd_soc_write(codec, VT1603_R42, val); + // enable VREF_SC_DA buffer + val = snd_soc_read(codec, VT1603_R61); + val |= BIT7; + snd_soc_write(codec, VT1603_R61, val); + // ADC VREF_SC offset voltage + snd_soc_write(codec, VT1603_R93, 0x20); + // set mic bias voltage = 90% * AVDD + val = snd_soc_read(codec, VT1603_R92); + val |= BIT2; + snd_soc_write(codec, VT1603_R92, val); + // enable bypass for AOW0 parameterized HPF + val = snd_soc_read(codec, VT1603_R0a); + val |= BIT6; + snd_soc_write(codec, VT1603_R0a, val); + // CPVEE=2.2uF, the ripple frequency ON CPVEE above 22kHz, that will reduce HP noise + val = snd_soc_read(codec, VT1603_R7a); + val |= BIT6; + val &= ~BIT5; + snd_soc_write(codec, VT1603_R7a, val); + + // set DAC soft mute mode + val = snd_soc_read(codec, VT1603_R0b); + val |= BIT1+BIT2; + snd_soc_write(codec, VT1603_R0b, val); + // DAC High Voltage Switch Control Signal enable??? + val = snd_soc_read(codec, VT1603_R62); + val |= BIT7+BIT6; + val &= ~BIT3; + snd_soc_write(codec, VT1603_R62, val); + // enable microphone bias + val = snd_soc_read(codec, VT1603_R60); + val |= 0x0f; + snd_soc_write(codec, VT1603_R60, val); + // capture pga settings?? + val = snd_soc_read(codec, VT1603_R8e); + val |= 0x0f; + snd_soc_write(codec, VT1603_R8e, val); + // capture pga settings?? + val = snd_soc_read(codec, VT1603_R66); + val |= BIT1+BIT2+BIT3+BIT4; // + snd_soc_write(codec, VT1603_R66, val); + // PGA Zero Cross Detector Enable, Change gain on zero cross only + val = snd_soc_read(codec, VT1603_R64); + val |= BIT0; + snd_soc_write(codec, VT1603_R64, val); + val = snd_soc_read(codec, VT1603_R65); + val |= BIT0; + snd_soc_write(codec, VT1603_R65, val); + // enable hp output mode + val = snd_soc_read(codec, VT1603_R68); + val |= BIT2; + snd_soc_write(codec, VT1603_R68, val); + // enable class-d, unmute channels + snd_soc_write(codec, VT1603_R7c, 0xe0); + + // set DAC gain update + val = snd_soc_read(codec, VT1603_R05); + val |= BIT6+BIT7; + snd_soc_write(codec, VT1603_R05, val); + // set class-d AC boost gain=1.6 + snd_soc_write(codec, VT1603_R97, 0x1c); + val = snd_soc_read(codec, VT1603_R97); + val = (val & (~0x07)) + 0x04; + snd_soc_write(codec, VT1603_R97, val); + // set ADC gain update, enable ADCDAT output + val = snd_soc_read(codec, VT1603_R00); + val |= BIT5+BIT6+BIT7; + snd_soc_write(codec, VT1603_R00, val); + + if (vt1603_boardinfo.out_on) + { + val = snd_soc_read(codec, VT1603_R68); + val &= ~(1<<4); + snd_soc_write(codec, VT1603_R68, val); + + val = snd_soc_read(codec, VT1603_R69); + val |= BIT2 +BIT5; + snd_soc_write(codec, VT1603_R69, val); + + + val = snd_soc_read(codec, VT1603_R25); + val |= BIT1; + snd_soc_write(codec, VT1603_R25, val); + + val = snd_soc_read(codec, VT1603_R90); + val |= BIT5 +BIT3; + snd_soc_write(codec, VT1603_R90, val); + + } + // DA DRC settings + //snd_soc_write(codec, VT1603_R0e, 0x0b); + //snd_soc_write(codec, VT1603_R0f, 0x94); + //snd_soc_write(codec, VT1603_R10, 0x02); + //snd_soc_write(codec, VT1603_R11, 0x00); + //snd_soc_write(codec, VT1603_R12, 0x60); +} + +static int vt1603_reboot_notify(struct notifier_block *this, + unsigned long code, void *unused) +{ + unsigned int val; + struct vt1603_priv *priv = container_of(this, struct vt1603_priv, reboot_notifier); + struct snd_soc_codec *codec = priv->codec; + + printk("vt1603_reboot_notify [%lu]\n", code); + + // power down headphone + val = snd_soc_read(codec, VT1603_R68); + val |= BIT4; + snd_soc_write(codec, VT1603_R68, val); + + // power down class-d + val = snd_soc_read(codec, VT1603_R25); + val &= ~BIT1; + snd_soc_write(codec, VT1603_R25, val); + + return NOTIFY_DONE; +} + +/*----------------------------------------------------------------------*/ + + +/*---------------------codec driver functions---------------------------*/ + +static int vt1603_codec_suspend(struct snd_soc_codec *codec) +{ + struct vt1603_priv *vt1603 = snd_soc_codec_get_drvdata(codec); + if (!vt1603_boardinfo.timer_del) { //add 2014-1-22 tvbox + del_timer_sync(&vt1603->timer); + } + return 0; +} + +static int vt1603_codec_resume(struct snd_soc_codec *codec) +{ + struct vt1603_priv *vt1603 = snd_soc_codec_get_drvdata(codec); + int reg; + u16 *cache = codec->reg_cache; + unsigned int val; + int state = 0;//switch_get_state(&vt1603->hp_switch); + if (!vt1603_boardinfo.hpd_rm) + state = switch_get_state(&vt1603->hp_switch); + // reset codec + vt1603_codec_reset(codec); + + // restore codec registers + for (reg = 0; reg < ARRAY_SIZE(vt1603_regs); reg++) { + if (reg == VT1603_REG_RESET) + continue; + snd_soc_write(codec, reg, cache[reg]); + } + + // restore headphone irq status + val = vt1603_hw_read(codec, VT1603_R21); + if ((vt1603_boardinfo.hp_level && state) || + (!vt1603_boardinfo.hp_level && !state)) { + val |= BIT1; + snd_soc_write(codec, VT1603_R21, val); + } + else { + val &= ~BIT1; + snd_soc_write(codec, VT1603_R21, val); + } + + // open headphone detect + val = vt1603_hw_read(codec,VT1603_R1b); + val |= BIT1; + snd_soc_write(codec, VT1603_R1b, val); + val &= ~BIT1; + snd_soc_write(codec, VT1603_R1b, val); + + // clear touch interrupt status??? why here??? + snd_soc_write(codec, 0xca, 0x0f); + + if (!vt1603_boardinfo.timer_del) { //add 2014-1-22 tvbox + mod_timer(&vt1603->timer, jiffies + msecs_to_jiffies(50)); + } + + return 0; +} + +static int vt1603_codec_probe(struct snd_soc_codec *codec) +{ + struct vt1603_priv *vt1603; + int ret; + + vt1603 = kzalloc(sizeof(struct vt1603_priv), GFP_KERNEL); + if (vt1603 == NULL) + return -ENOMEM; + + gvt1603_codec = codec;//add 2013-9-2 + snd_soc_codec_set_drvdata(codec, vt1603); + + codec->control_data = dev_get_platdata(codec->dev); + + vt1603->codec = codec; +// need close to use wmt-switch.c 2013-11-27 + if (!vt1603_boardinfo.hpd_rm) { + vt1603->hp_switch.name = "h2w"; + switch_dev_register(&vt1603->hp_switch); + } +//need close + vt1603_codec_reset(codec); + vt1603_codec_init(codec); + vt1603_set_bias_level(codec, SND_SOC_BIAS_PREPARE); + + INIT_WORK(&vt1603->work, vt1603_codec_irq_handle); + if (!vt1603_boardinfo.timer_del) { //add 2014-1-20 tvbox + init_timer(&vt1603->timer); + vt1603->timer.data = (unsigned long)vt1603; + vt1603->timer.function = vt1603_timer_handler; + mod_timer(&vt1603->timer, jiffies + msecs_to_jiffies(2000)); + } + + vt1603->proc = create_proc_read_entry("vt1603_dumpregs", 0666, NULL, + vt1603_readproc, vt1603); + + // register reboot notifier event + vt1603->reboot_notifier.notifier_call = vt1603_reboot_notify; + ret = register_reboot_notifier(&vt1603->reboot_notifier); + if (ret != 0) + pr_err("cannot register reboot notifier (err=%d)\n", ret); + + return 0; +} + +static int vt1603_codec_remove(struct snd_soc_codec *codec) +{ + struct vt1603_priv *vt1603 = snd_soc_codec_get_drvdata(codec); + remove_proc_entry("vt1603_dumpregs", NULL); + if (!vt1603_boardinfo.hpd_rm) { + switch_dev_unregister(&vt1603->hp_switch); + } + del_timer_sync(&vt1603->timer); + vt1603_set_bias_level(codec, SND_SOC_BIAS_OFF); + kfree(vt1603); + return 0; +} + +static struct snd_soc_codec_driver soc_codec_dev_vt1603 = { + .probe = vt1603_codec_probe, + .remove = vt1603_codec_remove, + .suspend = vt1603_codec_suspend, + .resume = vt1603_codec_resume, + .read = vt1603_read, + .write = vt1603_write, + .set_bias_level = vt1603_set_bias_level, + .reg_cache_size = ARRAY_SIZE(vt1603_regs), + .reg_word_size = sizeof(u16), + .reg_cache_default = vt1603_regs, + + .controls = vt1603_snd_controls, + .num_controls = ARRAY_SIZE(vt1603_snd_controls), + .dapm_widgets = vt1603_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(vt1603_dapm_widgets), + .dapm_routes = audio_map, + .num_dapm_routes = ARRAY_SIZE(audio_map), +}; + +static int __devinit vt1603_probe(struct platform_device *pdev) +{ + pr_info("<<<<%s \n", __FUNCTION__); + return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_vt1603, + &vt1603_dai, 1); +} + +static int __devexit vt1603_remove(struct platform_device *pdev) +{ + snd_soc_unregister_codec(&pdev->dev); + return 0; +} + +static struct platform_driver vt1603_codec_driver = { + .driver = { + .name = "vt1603-codec", + .owner = THIS_MODULE, + }, + .probe = vt1603_probe, + .remove = __devexit_p(vt1603_remove), +}; + +static __init int vt1603_init(void) +{ + vt1603_get_boardinfo(); + return platform_driver_register(&vt1603_codec_driver); +} +module_init(vt1603_init); + +static __exit void vt1603_exit(void) +{ + platform_driver_unregister(&vt1603_codec_driver); +} +module_exit(vt1603_exit); + +int vt1603_hwdep_ioctl(u8 rw_flag, u16 offset, u16 value) +{ + struct snd_soc_codec *codec = gvt1603_codec; + if (!codec){ + printk("%s NULL!\n", __FUNCTION__); + return -1; + } + //info("rw_flag=%d, offset=0x%x, value=0x%x", rw_flag, offset, value); + + if (rw_flag) { + if ((offset >= VT1603_R00) && (offset <= VT1603_R97)) { + snd_soc_write(codec, offset, value); + } + else { + printk("write to offset 0x%x is not allowed", offset); + } + return 0; + } + else { + return snd_soc_read(codec, offset); + } +} +EXPORT_SYMBOL(vt1603_hwdep_ioctl); + +MODULE_DESCRIPTION("WMT [ALSA SoC/codec] driver"); +MODULE_AUTHOR("WonderMedia Technologies, Inc."); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:vt1603-codec"); |