/* * sound\soc\sunxi\sun8iw18-codec.c * (C) Copyright 2014-2018 * Allwinner Technology Co., Ltd. * huangxin * wolfgang huang * yumingfeng * * some simple description for this code * * 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. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "sunxi_rw_func.h" #include "sun8iw18-codec.h" #include "sun8iw18-sndcodec.h" #ifdef CONFIG_SND_SUNXI_MAD #include "sunxi-mad.h" #endif #ifdef SUNXI_CODEC_MAP_TO_DAUDIO #include "sunxi-daudio.h" #endif #define DRV_NAME "sunxi-internal-codec" /* need optimize */ static int lineout_msleep = 120; module_param(lineout_msleep, int, 0644); MODULE_PARM_DESC(lineout_msleep, "SUNXI codec lineout msleep for pop sound."); static int dac_msleep = 10; module_param(dac_msleep, int, 0644); MODULE_PARM_DESC(dac_msleep, "SUNXI codec dac msleep for pop sound."); static struct label reg_labels[] = { LABEL(SUNXI_DAC_DPC), LABEL(SUNXI_DAC_FIFO_CTL), LABEL(SUNXI_DAC_FIFO_STA), LABEL(SUNXI_DAC_CNT), LABEL(SUNXI_DAC_DG), LABEL(SUNXI_ADC_FIFO_CTL), LABEL(SUNXI_ADC_FIFO_STA), LABEL(SUNXI_ADC_CNT), LABEL(SUNXI_ADC_DG), LABEL(SUNXI_DAC_DAP_CTL), LABEL(SUNXI_ADC_DAP_CTL), LABEL(SUNXI_HP_CTL), LABEL(SUNXI_MIX_DAC_CTL), LABEL(SUNXI_LINEOUT_CTL0), LABEL(SUNXI_LINEOUT_CTL1), LABEL(SUNXI_MIC1_CTL), LABEL(SUNXI_MIC2_MIC3_CTL), LABEL(SUNXI_LADCMIX_SRC), LABEL(SUNXI_RADCMIX_SRC), LABEL(SUNXI_XADCMIX_SRC), LABEL(SUNXI_ADC_CTL), LABEL(SUNXI_MBIAS_CTL), LABEL(SUNXI_APT_REG), LABEL(SUNXI_OP_BIAS_CTL0), LABEL(SUNXI_OP_BIAS_CTL1), LABEL(SUNXI_ZC_VOL_CTL), LABEL(SUNXI_BIAS_CAL_CTRL), LABEL_END, }; static const struct sample_rate sample_rate_conv[] = { {44100, 0}, {48000, 0}, {8000, 5}, {32000, 1}, {22050, 2}, {24000, 2}, {16000, 3}, {11025, 4}, {12000, 4}, {192000, 6}, {96000, 7}, }; static const DECLARE_TLV_DB_SCALE(digital_tlv, -7424, 116, 0); static const DECLARE_TLV_DB_SCALE(adc_gain_tlv, -450, 150, 0); static const unsigned int mic_gain_tlv[] = { TLV_DB_RANGE_HEAD(2), 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0), 1, 7, TLV_DB_SCALE_ITEM(2400, 300, 0), }; static const unsigned int lineout_tlv[] = { TLV_DB_RANGE_HEAD(2), 0, 0, TLV_DB_SCALE_ITEM(0, 0, 1), 1, 31, TLV_DB_SCALE_ITEM(-4350, 150, 1), }; /*lineoutL mux select */ const char * const left_lineout_text[] = { "DACL", "DAC_NULL", }; static const struct soc_enum left_lineout_enum = SOC_ENUM_SINGLE(SUNXI_LINEOUT_CTL0, LINEOUTL_SRC, ARRAY_SIZE(left_lineout_text), left_lineout_text); static const struct snd_kcontrol_new left_lineout_mux = SOC_DAPM_ENUM("Left LINEOUT Mux", left_lineout_enum); /*lineoutR mux select */ const char * const right_lineout_text[] = { "DAC_NULL", "DACL", }; static const struct soc_enum right_lineout_enum = SOC_ENUM_SINGLE(SUNXI_LINEOUT_CTL0, LINEOUTR_SRC, ARRAY_SIZE(right_lineout_text), right_lineout_text); static const struct snd_kcontrol_new right_lineout_mux = SOC_DAPM_ENUM("Right LINEOUT Mux", right_lineout_enum); static void adcdrc_config(struct snd_soc_codec *codec) { /* Left peak filter attack time */ snd_soc_write(codec, AC_ADC_DRC_LPFHAT, (0x000B77BF >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LPFLAT, 0x000B77BF & 0xFFFF); /* Right peak filter attack time */ snd_soc_write(codec, AC_ADC_DRC_RPFHAT, (0x000B77BF >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_RPFLAT, 0x000B77BF & 0xFFFF); /* Left peak filter release time */ snd_soc_write(codec, AC_ADC_DRC_LPFHRT, (0x00FFE1F8 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LPFLRT, 0x00FFE1F8 & 0xFFFF); /* Right peak filter release time */ snd_soc_write(codec, AC_ADC_DRC_RPFHRT, (0x00FFE1F8 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_RPFLRT, 0x00FFE1F8 & 0xFFFF); /* Left RMS filter attack time */ snd_soc_write(codec, AC_ADC_DRC_LPFHAT, (0x00012BAF >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LPFLAT, 0x00012BAF & 0xFFFF); /* Right RMS filter attack time */ snd_soc_write(codec, AC_ADC_DRC_RPFHAT, (0x00012BAF >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_RPFLAT, 0x00012BAF & 0xFFFF); /* smooth filter attack time */ snd_soc_write(codec, AC_ADC_DRC_SFHAT, (0x00025600 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_SFLAT, 0x00025600 & 0xFFFF); /* gain smooth filter release time */ snd_soc_write(codec, AC_ADC_DRC_SFHRT, (0x00000F04 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_SFLRT, 0x00000F04 & 0xFFFF); /* OPL */ snd_soc_write(codec, AC_ADC_DRC_HOPL, (0xFBD8FBA7 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LOPL, 0xFBD8FBA7 & 0xFFFF); /* OPC */ snd_soc_write(codec, AC_ADC_DRC_HOPC, (0xF95B2C3F >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LOPC, 0xF95B2C3F & 0xFFFF); /* OPE */ snd_soc_write(codec, AC_ADC_DRC_HOPE, (0xF45F8D6E >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LOPE, 0xF45F8D6E & 0xFFFF); /* LT */ snd_soc_write(codec, AC_ADC_DRC_HLT, (0x01A934F0 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LLT, 0x01A934F0 & 0xFFFF); /* CT */ snd_soc_write(codec, AC_ADC_DRC_HCT, (0x06A4D3C0 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LCT, 0x06A4D3C0 & 0xFFFF); /* ET */ snd_soc_write(codec, AC_ADC_DRC_HET, (0x0BA07291 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LET, 0x0BA07291 & 0xFFFF); /* Ki */ snd_soc_write(codec, AC_ADC_DRC_HKI, (0x00051EB8 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LKI, 0x00051EB8 & 0xFFFF); /* Kc */ snd_soc_write(codec, AC_ADC_DRC_HKC, (0x00800000 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LKC, 0x00800000 & 0xFFFF); /* Kn */ snd_soc_write(codec, AC_ADC_DRC_HKN, (0x01000000 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LKN, 0x01000000 & 0xFFFF); /* Ke */ snd_soc_write(codec, AC_ADC_DRC_HKE, (0x0000F45F >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LKE, 0x0000F45F & 0xFFFF); } static void adchpf_config(struct snd_soc_codec *codec) { /* HPF */ snd_soc_write(codec, AC_ADC_DRC_HHPFC, (0xFFFAC1 >> 16) & 0xFFFF); snd_soc_write(codec, AC_ADC_DRC_LHPFC, 0xFFE644 & 0xFFFF); } static void adcdrc_enable(struct snd_soc_codec *codec, bool on) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (on) { snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_DRC0_EN | 0x1 << ADC_DRC1_EN), (0x1 << ADC_DRC0_EN | 0x1 << ADC_DRC1_EN)); if (sunxi_codec->adc_dap_enable++ == 0) { snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_DAP0_EN | 0x1 << ADC_DAP1_EN), (0x1 << ADC_DAP0_EN | 0x1 << ADC_DAP1_EN)); } } else { if (--sunxi_codec->adc_dap_enable == 0) { snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_DAP0_EN | 0x1 << ADC_DAP1_EN), (0x0 << ADC_DAP0_EN | 0x0 << ADC_DAP1_EN)); } snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_DRC0_EN | 0x1 << ADC_DRC1_EN), (0x0 << ADC_DRC0_EN | 0x0 << ADC_DRC1_EN)); } } static void adchpf_enable(struct snd_soc_codec *codec, bool on) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (on) { snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_HPF0_EN | 0x1 << ADC_HPF1_EN), (0x1 << ADC_HPF0_EN | 0x1 << ADC_HPF1_EN)); if (sunxi_codec->adc_dap_enable++ == 0) { snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_DAP0_EN | 0x1 << ADC_DAP1_EN), (0x1 << ADC_DAP0_EN | 0x1 << ADC_DAP1_EN)); } } else { if (--sunxi_codec->adc_dap_enable == 0) { snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_DAP0_EN | 0x1 << ADC_DAP1_EN), (0x0 << ADC_DAP0_EN | 0x0 << ADC_DAP1_EN)); } snd_soc_update_bits(codec, SUNXI_ADC_DAP_CTL, (0x1 << ADC_HPF0_EN | 0x1 << ADC_HPF1_EN), (0x0 << ADC_HPF0_EN | 0x0 << ADC_HPF1_EN)); } } static void dacdrc_config(struct snd_soc_codec *codec) { /* Left peak filter attack time */ snd_soc_write(codec, AC_DAC_DRC_LPFHAT, (0x000B77BF >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LPFLAT, 0x000B77BF & 0xFFFF); /* Right peak filter attack time */ snd_soc_write(codec, AC_DAC_DRC_RPFHAT, (0x000B77BF >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_RPFLAT, 0x000B77BF & 0xFFFF); /* Left peak filter release time */ snd_soc_write(codec, AC_DAC_DRC_LPFHRT, (0x00FFE1F8 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LPFLRT, 0x00FFE1F8 & 0xFFFF); /* Right peak filter release time */ snd_soc_write(codec, AC_DAC_DRC_RPFHRT, (0x00FFE1F8 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_RPFLRT, 0x00FFE1F8 & 0xFFFF); /* Left RMS filter attack time */ snd_soc_write(codec, AC_DAC_DRC_LPFHAT, (0x00012BAF >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LPFLAT, 0x00012BAF & 0xFFFF); /* Right RMS filter attack time */ snd_soc_write(codec, AC_DAC_DRC_RPFHAT, (0x00012BAF >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_RPFLAT, 0x00012BAF & 0xFFFF); /* smooth filter attack time */ snd_soc_write(codec, AC_DAC_DRC_SFHAT, (0x00025600 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_SFLAT, 0x00025600 & 0xFFFF); /* gain smooth filter release time */ snd_soc_write(codec, AC_DAC_DRC_SFHRT, (0x00000F04 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_SFLRT, 0x00000F04 & 0xFFFF); /* OPL */ snd_soc_write(codec, AC_DAC_DRC_HOPL, (0xFBD8FBA7 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LOPL, 0xFBD8FBA7 & 0xFFFF); /* OPC */ snd_soc_write(codec, AC_DAC_DRC_HOPC, (0xF95B2C3F >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LOPC, 0xF95B2C3F & 0xFFFF); /* OPE */ snd_soc_write(codec, AC_DAC_DRC_HOPE, (0xF45F8D6E >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LOPE, 0xF45F8D6E & 0xFFFF); /* LT */ snd_soc_write(codec, AC_DAC_DRC_HLT, (0x01A934F0 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LLT, 0x01A934F0 & 0xFFFF); /* CT */ snd_soc_write(codec, AC_DAC_DRC_HCT, (0x06A4D3C0 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LCT, 0x06A4D3C0 & 0xFFFF); /* ET */ snd_soc_write(codec, AC_DAC_DRC_HET, (0x0BA07291 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LET, 0x0BA07291 & 0xFFFF); /* Ki */ snd_soc_write(codec, AC_DAC_DRC_HKI, (0x00051EB8 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LKI, 0x00051EB8 & 0xFFFF); /* Kc */ snd_soc_write(codec, AC_DAC_DRC_HKC, (0x00800000 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LKC, 0x00800000 & 0xFFFF); /* Kn */ snd_soc_write(codec, AC_DAC_DRC_HKN, (0x01000000 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LKN, 0x01000000 & 0xFFFF); /* Ke */ snd_soc_write(codec, AC_DAC_DRC_HKE, (0x0000F45F >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LKE, 0x0000F45F & 0xFFFF); } static void dachpf_config(struct snd_soc_codec *codec) { /* HPF */ snd_soc_write(codec, AC_DAC_DRC_HHPFC, (0xFFFAC1 >> 16) & 0xFFFF); snd_soc_write(codec, AC_DAC_DRC_LHPFC, 0xFFFAC1 & 0xFFFF); } static void dacdrc_enable(struct snd_soc_codec *codec, bool on) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (on) { /* detect noise when ET enable */ snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_CONTROL_DRC_EN), (0x1 << DAC_DRC_CTL_CONTROL_DRC_EN)); /* 0x0:RMS filter; 0x1:Peak filter */ snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_SIGNAL_FUN_SEL), (0x1 << DAC_DRC_CTL_SIGNAL_FUN_SEL)); /* delay function enable */ snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_DEL_FUN_EN), (0x0 << DAC_DRC_CTL_DEL_FUN_EN)); snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_DRC_LT_EN), (0x1 << DAC_DRC_CTL_DRC_LT_EN)); snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_DRC_ET_EN), (0x1 << DAC_DRC_CTL_DRC_ET_EN)); snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_DRC_EN), (0x1 << DDAP_DRC_EN)); if (sunxi_codec->dac_dap_enable++ == 0) snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_EN), (0x1 << DDAP_EN)); } else { if (--sunxi_codec->dac_dap_enable == 0) snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_EN), (0x0 << DDAP_EN)); snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_DRC_EN), (0x0 << DDAP_DRC_EN)); /* detect noise when ET enable */ snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_CONTROL_DRC_EN), (0x0 << DAC_DRC_CTL_CONTROL_DRC_EN)); /* 0x0:RMS filter; 0x1:Peak filter */ snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_SIGNAL_FUN_SEL), (0x1 << DAC_DRC_CTL_SIGNAL_FUN_SEL)); /* delay function enable */ snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_DEL_FUN_EN), (0x0 << DAC_DRC_CTL_DEL_FUN_EN)); snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_DRC_LT_EN), (0x0 << DAC_DRC_CTL_DRC_LT_EN)); snd_soc_update_bits(codec, AC_DAC_DRC_CTL, (0x1 << DAC_DRC_CTL_DRC_ET_EN), (0x0 << DAC_DRC_CTL_DRC_ET_EN)); } } static void dachpf_enable(struct snd_soc_codec *codec, bool on) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (on) { snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_HPF_EN), (0x1 << DDAP_HPF_EN)); if (sunxi_codec->dac_dap_enable++ == 0) snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_EN), (0x1 << DDAP_EN)); } else { if (--sunxi_codec->dac_dap_enable == 0) snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_EN), (0x0 << DDAP_EN)); snd_soc_update_bits(codec, SUNXI_DAC_DAP_CTL, (0x1 << DDAP_HPF_EN), (0x0 << DDAP_HPF_EN)); } } #ifdef SUNXI_CODEC_MAP_TO_DAUDIO static int sunxi_codec_get_i2s_port(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); struct snd_soc_codec *codec = snd_soc_component_to_codec(component); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); ucontrol->value.integer.value[0] = sunxi_codec->i2s_port; return 0; } static int sunxi_codec_set_i2s_port(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); struct snd_soc_codec *codec = snd_soc_component_to_codec(component); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); switch (ucontrol->value.integer.value[0]) { case SUNXI_CODEC_MAP_PORT_NULL: case SUNXI_CODEC_MAP_PORT_I2S0: case SUNXI_CODEC_MAP_PORT_I2S1: case SUNXI_CODEC_MAP_PORT_I2S2: sunxi_codec->i2s_port = ucontrol->value.integer.value[0]; break; default: return -EINVAL; } return 0; } /* sunxi codec hub mdoe select */ static const char * const sunxi_codec_i2s_mux[] = {"I2S_NULL", "I2S0_RX", "I2S1_RX", "I2S2_RX"}; static const struct soc_enum sunxi_codec_i2s_port_enum[] = { SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(sunxi_codec_i2s_mux), sunxi_codec_i2s_mux), }; #endif static int sunxi_codec_get_hub_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); struct snd_soc_codec *codec = snd_soc_component_to_codec(component); unsigned int reg_val; reg_val = snd_soc_read(codec, SUNXI_DAC_DPC); ucontrol->value.integer.value[0] = ((reg_val & (1<value.integer.value[0]) { case 0: case 1: snd_soc_update_bits(codec, SUNXI_DAC_DPC, (0x1 << DAC_HUB_EN), (0x0 << DAC_HUB_EN)); break; case 2: snd_soc_update_bits(codec, SUNXI_DAC_DPC, (0x1 << DAC_HUB_EN), (0x1 << DAC_HUB_EN)); break; default: return -EINVAL; } return 0; } /* sunxi codec hub mdoe select */ static const char * const sunxi_codec_hub_function[] = {"null", "hub_disable", "hub_enable"}; static const struct soc_enum sunxi_codec_hub_mode_enum[] = { SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(sunxi_codec_hub_function), sunxi_codec_hub_function), }; static int sunxi_spk_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); switch (event) { case SND_SOC_DAPM_POST_PMU: snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0, (0x1 << LINEOUTL_EN) | (0x1 << LINEOUTR_EN), (0x1 << LINEOUTL_EN) | (0x1 << LINEOUTR_EN)); if (sunxi_codec->pa_power_cfg.used) { gpio_set_value(sunxi_codec->pa_power_cfg.gpio, 1); } if (sunxi_codec->spk_cfg.used) { gpio_set_value(sunxi_codec->spk_cfg.gpio, sunxi_codec->spk_cfg.pa_ctl_level); /* * time delay to wait spk pa work fine, * general setting 160ms. For pop sound, * maybe set less than it. */ msleep(sunxi_codec->spk_cfg.pa_msleep_time); } break; case SND_SOC_DAPM_PRE_PMD: if (sunxi_codec->pa_power_cfg.used) { gpio_set_value(sunxi_codec->pa_power_cfg.gpio, 0); } if (sunxi_codec->spk_cfg.used) { gpio_set_value(sunxi_codec->spk_cfg.gpio, !(sunxi_codec->spk_cfg.pa_ctl_level)); } snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0, (0x1 << LINEOUTL_EN) | (0x1 << LINEOUTR_EN), (0x0 << LINEOUTL_EN) | (0x0 << LINEOUTR_EN)); break; default: break; } return 0; } static int sunxi_lineout_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); switch (event) { case SND_SOC_DAPM_POST_PMU: snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0, (0x1 << LINEOUTL_EN) | (0x1 << LINEOUTR_EN), (0x1 << LINEOUTL_EN) | (0x1 << LINEOUTR_EN)); msleep(lineout_msleep); break; case SND_SOC_DAPM_PRE_PMD: snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0, (0x1 << LINEOUTL_EN) | (0x1 << LINEOUTR_EN), (0x0 << LINEOUTL_EN) | (0x0 << LINEOUTR_EN)); break; default: break; } return 0; } static int sunxi_playback_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); mutex_lock(&sunxi_codec->dac_mutex); switch (event) { case SND_SOC_DAPM_POST_PMU: if (sunxi_codec->dac_enable++ == 0) { snd_soc_update_bits(codec, SUNXI_DAC_DPC, (0x1 << EN_DAC), (0x1 << EN_DAC)); /* time delay to wait digital dac work fine */ msleep(dac_msleep); } break; case SND_SOC_DAPM_POST_PMD: if (--sunxi_codec->dac_enable == 0) snd_soc_update_bits(codec, SUNXI_DAC_DPC, (0x1 << EN_DAC), (0x0 << EN_DAC)); break; default: break; } mutex_unlock(&sunxi_codec->dac_mutex); return 0; } static int sunxi_capture_event(struct snd_soc_dapm_widget *w, struct snd_kcontrol *k, int event) { struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); mutex_lock(&sunxi_codec->adc_mutex); switch (event) { case SND_SOC_DAPM_POST_PMU: if (sunxi_codec->adc_enable++ == 0) { snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL, (0x1 << EN_AD), (0x1 << EN_AD)); } break; case SND_SOC_DAPM_POST_PMD: if (--sunxi_codec->adc_enable == 0) { snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL, (0x1 << EN_AD), (0x0 << EN_AD)); } break; } mutex_unlock(&sunxi_codec->adc_mutex); return 0; } /* add mixer kcontrol for PA mute */ int sunxi_pashdn_get_data(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); struct snd_soc_codec *codec = snd_soc_component_to_codec(component); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct spk_config *spk_cfg = &(sunxi_codec->spk_cfg); if (spk_cfg->used) ucontrol->value.integer.value[0] = gpio_get_value(spk_cfg->gpio); else ucontrol->value.integer.value[0] = 0; return 0; } int sunxi_pashdn_put_data(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) { struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); struct snd_soc_codec *codec = snd_soc_component_to_codec(component); struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct spk_config *spk_cfg = &(sunxi_codec->spk_cfg); if (spk_cfg->used) { int val = ucontrol->value.integer.value[0]; gpio_set_value(spk_cfg->gpio, val); } return 0; } static const struct snd_kcontrol_new sunxi_codec_controls[] = { SOC_ENUM_EXT("codec hub mode", sunxi_codec_hub_mode_enum[0], sunxi_codec_get_hub_mode, sunxi_codec_set_hub_mode), #ifdef SUNXI_CODEC_MAP_TO_DAUDIO SOC_ENUM_EXT("codec I2S Port", sunxi_codec_i2s_port_enum[0], sunxi_codec_get_i2s_port, sunxi_codec_set_i2s_port), #endif SOC_SINGLE_TLV("digital volume", SUNXI_DAC_DPC, DVOL, 0x3F, 1, digital_tlv), SOC_SINGLE_TLV("MIC1 gain volume", SUNXI_MIC1_CTL, MIC1BOOST, 0x7, 0, mic_gain_tlv), SOC_SINGLE_TLV("MIC2 gain volume", SUNXI_MIC2_MIC3_CTL, MIC2BOOST, 0x7, 0, mic_gain_tlv), SOC_SINGLE_TLV("MIC3 gain volume", SUNXI_MIC2_MIC3_CTL, MIC3BOOST, 0x7, 0, mic_gain_tlv), SOC_SINGLE_TLV("LINEOUT volume", SUNXI_LINEOUT_CTL1, LINEOUT_VOL, 0x1F, 0, lineout_tlv), SOC_SINGLE_TLV("ADC gain volume", SUNXI_ADC_CTL, ADCG, 0x7, 0, adc_gain_tlv), SOC_SINGLE_BOOL_EXT("Spk PA Switch", 0, sunxi_pashdn_get_data, sunxi_pashdn_put_data), }; static const struct snd_kcontrol_new left_input_mixer[] = { SOC_DAPM_SINGLE("MIC3 Boost Switch", SUNXI_LADCMIX_SRC, LADC_MIC3_STAGE, 1, 0), SOC_DAPM_SINGLE("MIC2 Boost Switch", SUNXI_LADCMIX_SRC, LADC_MIC2_STAGE, 1, 0), SOC_DAPM_SINGLE("MIC1 Boost Switch", SUNXI_LADCMIX_SRC, LADC_MIC1_STAGE, 1, 0), SOC_DAPM_SINGLE("DACL Switch", SUNXI_LADCMIX_SRC, LADC_DACL, 1, 0), }; static const struct snd_kcontrol_new right_input_mixer[] = { SOC_DAPM_SINGLE("MIC3 Boost Switch", SUNXI_RADCMIX_SRC, RADC_MIC3_STAGE, 1, 0), SOC_DAPM_SINGLE("MIC2 Boost Switch", SUNXI_RADCMIX_SRC, RADC_MIC2_STAGE, 1, 0), SOC_DAPM_SINGLE("MIC1 Boost Switch", SUNXI_RADCMIX_SRC, RADC_MIC1_STAGE, 1, 0), SOC_DAPM_SINGLE("DACL Switch", SUNXI_RADCMIX_SRC, RADC_DACL, 1, 0), }; static const struct snd_kcontrol_new xadc_input_mixer[] = { SOC_DAPM_SINGLE("MIC3 Boost Switch", SUNXI_XADCMIX_SRC, XADC_MIC3_STAGE, 1, 0), SOC_DAPM_SINGLE("MIC2 Boost Switch", SUNXI_XADCMIX_SRC, XADC_MIC2_STAGE, 1, 0), SOC_DAPM_SINGLE("MIC1 Boost Switch", SUNXI_XADCMIX_SRC, XADC_MIC1_STAGE, 1, 0), SOC_DAPM_SINGLE("DACL Switch", SUNXI_XADCMIX_SRC, XADC_DACL, 1, 0), }; static const struct snd_soc_dapm_widget sunxi_codec_dapm_widgets[] = { SND_SOC_DAPM_AIF_IN_E("DACL", "Playback", 0, SUNXI_MIX_DAC_CTL, DACALEN, 0, sunxi_playback_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), SND_SOC_DAPM_AIF_OUT_E("ADCL", "Capture", 0, SUNXI_ADC_CTL, ADCLEN, 0, sunxi_capture_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), SND_SOC_DAPM_AIF_OUT_E("ADCR", "Capture", 0, SUNXI_ADC_CTL, ADCREN, 0, sunxi_capture_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), SND_SOC_DAPM_AIF_OUT_E("ADCX", "Capture", 0, SUNXI_ADC_CTL, ADCXEN, 0, sunxi_capture_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), SND_SOC_DAPM_MIXER("Left Input Mixer", SND_SOC_NOPM, 0, 0, left_input_mixer, ARRAY_SIZE(left_input_mixer)), SND_SOC_DAPM_MIXER("Right Input Mixer", SND_SOC_NOPM, 0, 0, right_input_mixer, ARRAY_SIZE(right_input_mixer)), SND_SOC_DAPM_MIXER("Xadc Input Mixer", SND_SOC_NOPM, 0, 0, xadc_input_mixer, ARRAY_SIZE(xadc_input_mixer)), SND_SOC_DAPM_MUX("Left LINEOUT Mux", SND_SOC_NOPM, 0, 0, &left_lineout_mux), SND_SOC_DAPM_MUX("Right LINEOUT Mux", SND_SOC_NOPM, 0, 0, &right_lineout_mux), SND_SOC_DAPM_PGA("MIC1 PGA", SUNXI_MIC1_CTL, MIC1AMPEN, 0, NULL, 0), SND_SOC_DAPM_PGA("MIC2 PGA", SUNXI_MIC2_MIC3_CTL, MIC2AMPEN, 0, NULL, 0), SND_SOC_DAPM_PGA("MIC3 PGA", SUNXI_MIC2_MIC3_CTL, MIC3AMPEN, 0, NULL, 0), SND_SOC_DAPM_MICBIAS("MainMic Bias", SUNXI_MBIAS_CTL, MMICBIASEN, 0), SND_SOC_DAPM_INPUT("MIC1"), SND_SOC_DAPM_INPUT("MIC2"), SND_SOC_DAPM_INPUT("MIC3"), SND_SOC_DAPM_OUTPUT("LINEOUTL"), SND_SOC_DAPM_OUTPUT("LINEOUTR"), SND_SOC_DAPM_LINE("Lineout", sunxi_lineout_event), SND_SOC_DAPM_SPK("External Speaker", sunxi_spk_event), }; static const struct snd_soc_dapm_route sunxi_codec_dapm_routes[] = { /* input route */ {"MIC1 PGA", NULL, "MIC1"}, {"MIC2 PGA", NULL, "MIC2"}, {"MIC3 PGA", NULL, "MIC3"}, {"MIC1", NULL, "MainMic Bias"}, {"MIC2", NULL, "MainMic Bias"}, {"MIC3", NULL, "MainMic Bias"}, {"Left Input Mixer", "DACL Switch", "DACL"}, {"Left Input Mixer", "MIC3 Boost Switch", "MIC3 PGA"}, {"Left Input Mixer", "MIC2 Boost Switch", "MIC2 PGA"}, {"Left Input Mixer", "MIC1 Boost Switch", "MIC1 PGA"}, {"Right Input Mixer", "DACL Switch", "DACL"}, {"Right Input Mixer", "MIC3 Boost Switch", "MIC3 PGA"}, {"Right Input Mixer", "MIC2 Boost Switch", "MIC2 PGA"}, {"Right Input Mixer", "MIC1 Boost Switch", "MIC1 PGA"}, {"Xadc Input Mixer", "DACL Switch", "DACL"}, {"Xadc Input Mixer", "MIC3 Boost Switch", "MIC3 PGA"}, {"Xadc Input Mixer", "MIC2 Boost Switch", "MIC2 PGA"}, {"Xadc Input Mixer", "MIC1 Boost Switch", "MIC1 PGA"}, {"ADCL", NULL, "Left Input Mixer"}, {"ADCR", NULL, "Right Input Mixer"}, {"ADCX", NULL, "Xadc Input Mixer"}, /* output route */ {"Left LINEOUT Mux", "DACL", "DACL"}, {"Right LINEOUT Mux", "DACL", "DACL"}, {"Left LINEOUT Mux", "DAC_NULL", "DACL"}, {"Right LINEOUT Mux", "DAC_NULL", "DACL"}, {"LINEOUTL", NULL, "Left LINEOUT Mux"}, {"LINEOUTR", NULL, "Right LINEOUT Mux"}, }; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO static int sunxi_codec_map_i2s_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { /* * pcm_open: * [1] cpu_dai->ops->startup; * [2] platform->ops->open; * [3] codec_dai->ops->startup; */ switch (sunxi_codec->i2s_port) { case SUNXI_CODEC_MAP_PORT_NULL: default: break; case SUNXI_CODEC_MAP_PORT_I2S0: if (clk_prepare_enable(sunxi_codec->daudio[0].i2s_clk)) pr_err("i2s0 module clk enable failed\n"); break; case SUNXI_CODEC_MAP_PORT_I2S1: if (clk_prepare_enable(sunxi_codec->daudio[1].i2s_clk)) pr_err("i2s1 module clk enable failed\n"); break; case SUNXI_CODEC_MAP_PORT_I2S2: if (clk_prepare_enable(sunxi_codec->daudio[2].i2s_clk)) pr_err("i2s2 module clk enable failed\n"); break; } } return 0; } static void sunxi_codec_map_i2s_global_enable(struct sunxi_codec_info *sunxi_codec, bool enable) { struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << LOOP_EN), (enable << LOOP_EN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << GLOBAL_EN), (enable << GLOBAL_EN)); } static void sunxi_codec_map_i2s_txctrl_enable(struct sunxi_codec_info *sunxi_codec, bool enable) { struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } if (enable) { regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << SDO0_EN), (1 << SDO0_EN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_TXEN), (1 << CTL_TXEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_INTCTL, (1 << TXDRQEN), (1 << TXDRQEN)); } else { regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_INTCTL, (1 << TXDRQEN), (0 << TXDRQEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_TXEN), (0 << CTL_TXEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << SDO0_EN), (0 << SDO0_EN)); } } static void sunxi_codec_map_i2s_rxctrl_enable(struct sunxi_codec_info *sunxi_codec, bool enable) { struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } if (enable) { regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_RXEN), (1 << CTL_RXEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_INTCTL, (1 << RXDRQEN), (1 << RXDRQEN)); } else { regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_INTCTL, (1 << RXDRQEN), (0 << RXDRQEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_RXEN), (0 << CTL_RXEN)); } } static int sunxi_codec_map_i2s_dma_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { int ret = 0; struct dmaengine_pcm_runtime_data *prtd; struct dma_slave_config slave_config; int DRQDST_TYPE_ID = 0; struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); sunxi_codec->prtd = kzalloc(sizeof(struct dmaengine_pcm_runtime_data), GFP_KERNEL); if (!sunxi_codec->prtd) { pr_err("[%s] kzalloc prtd failed.\n", __func__); return -ENOMEM; } prtd = sunxi_codec->prtd; ret = sunxi_snd_dmaengine_pcm_open(prtd, NULL, NULL); if (ret) { pr_err("[%s] mad request dma chan failed.[%d]\n", __func__, ret); return ret; } slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; /* codec rx */ slave_config.src_addr = 0x5096000 + SUNXI_ADC_RXDATA; slave_config.src_maxburst = 8; /* i2s tx */ slave_config.dst_maxburst = 8; switch (sunxi_codec->i2s_port) { case SUNXI_CODEC_MAP_PORT_I2S0: default: DRQDST_TYPE_ID = DRQDST_DAUDIO_0_TX; slave_config.dst_addr = sunxi_codec->daudio[0].res.start + SUNXI_DAUDIO_TXFIFO; break; case SUNXI_CODEC_MAP_PORT_I2S1: DRQDST_TYPE_ID = DRQDST_DAUDIO_1_TX; slave_config.dst_addr = sunxi_codec->daudio[1].res.start + SUNXI_DAUDIO_TXFIFO; break; case SUNXI_CODEC_MAP_PORT_I2S2: DRQDST_TYPE_ID = DRQDST_DAUDIO_2_TX; slave_config.dst_addr = sunxi_codec->daudio[2].res.start + SUNXI_DAUDIO_TXFIFO; break; } slave_config.slave_id = sunxi_slave_id(DRQDST_TYPE_ID, DRQSRC_AUDIO_CODEC); slave_config.direction = DMA_DEV_TO_DEV; ret = dmaengine_slave_config(prtd->dma_chan, &slave_config); if (ret < 0) { pr_err("[%s] dma slave config failed with err.[%d]\n", __func__, ret); return ret; } return 0; } static int sunxi_codec_map_i2s_dma_trigger(struct sunxi_codec_info *sunxi_codec, bool enable) { if (enable) { if ((sunxi_codec->i2s_port != SUNXI_CODEC_MAP_PORT_NULL) && (sunxi_codec->i2s_mapdma_trigger == 0)) { sunxi_snd_dmaengine_pcm_trigger(sunxi_codec->prtd, SNDRV_PCM_TRIGGER_START, 0, DMA_DEV_TO_DEV, sunxi_codec->buffer_bytes, sunxi_codec->period_bytes); sunxi_codec->i2s_mapdma_trigger = 1; } } else { if ((sunxi_codec->i2s_port != SUNXI_CODEC_MAP_PORT_NULL) && (sunxi_codec->i2s_mapdma_trigger == 1)) { sunxi_snd_dmaengine_pcm_trigger(sunxi_codec->prtd, SNDRV_PCM_TRIGGER_STOP, 0, DMA_DEV_TO_DEV, 0, 0); sunxi_codec->i2s_mapdma_trigger = 0; } } return 0; } static void sunxi_codec_map_i2s_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { if (sunxi_codec->prtd != NULL) { sunxi_snd_dmaengine_pcm_close(sunxi_codec->prtd); sunxi_codec->prtd = NULL; } /* * pcm_close: * [1] cpu_dai->ops->shutdown; * [2] codec_dai->ops->shutdown; * [3] platform->ops->shutdown; */ switch (sunxi_codec->i2s_port) { case SUNXI_CODEC_MAP_PORT_NULL: default: break; case SUNXI_CODEC_MAP_PORT_I2S0: clk_disable_unprepare(sunxi_codec->daudio[0].i2s_clk); break; case SUNXI_CODEC_MAP_PORT_I2S1: clk_disable_unprepare(sunxi_codec->daudio[1].i2s_clk); break; case SUNXI_CODEC_MAP_PORT_I2S2: clk_disable_unprepare(sunxi_codec->daudio[2].i2s_clk); break; } } } #ifdef CONFIG_SND_SUNXI_MAD static int sunxi_codec_map_i2s_mad_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_card *card = rtd->card; struct sunxi_sndcodec_priv *sndcodec_priv = snd_soc_card_get_drvdata(card); struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) sunxi_codec->mad_priv = &(sndcodec_priv->mad_priv); return 0; } static int sunxi_codec_map_i2s_mad_set_path(struct sunxi_codec_info *sunxi_codec, bool enable) { unsigned int path_sel; switch (sunxi_codec->i2s_port) { case SUNXI_CODEC_MAP_PORT_I2S0: path_sel = MAD_PATH_I2S0; break; case SUNXI_CODEC_MAP_PORT_I2S1: path_sel = MAD_PATH_I2S1; break; case SUNXI_CODEC_MAP_PORT_I2S2: path_sel = MAD_PATH_I2S2; break; default: dev_err(sunxi_codec->dev, "unsupported I2S number!\n"); return -EINVAL; } /* * should set it after sram reset. */ return sunxi_mad_audio_source_sel(path_sel, enable); } static void sunxi_codec_mad_debug_control(struct sunxi_codec_info *sunxi_codec, bool enable) { struct sunxi_mad_priv *mad_priv = sunxi_codec->mad_priv; mutex_lock(&sunxi_codec->mad_clk_mutex); if (enable) { if (!sunxi_codec->mad_clk_enable) { sunxi_mad_module_clk_enable(true); sunxi_codec->mad_clk_enable = true; } /* sunxi_mad_close(); */ sunxi_mad_open(); sunxi_mad_hw_params(mad_priv->audio_src_chan_num, mad_priv->sample_rate); sunxi_mad_audio_src_chan_num(mad_priv->audio_src_chan_num); sunxi_lpsd_chan_sel(mad_priv->lpsd_chan_sel); sunxi_mad_standby_chan_sel(mad_priv->mad_standby_chan_sel); sunxi_mad_dma_type(SUNXI_MAD_DMA_IO); sunxi_sram_ahb1_threshole_init(); sunxi_mad_sram_init(); sunxi_codec_map_i2s_mad_set_path(sunxi_codec, true); } else { sunxi_mad_sram_set_reset_bit(); if (sunxi_codec->mad_clk_enable) { sunxi_mad_module_clk_enable(false); sunxi_codec->mad_clk_enable = false; } } mutex_unlock(&sunxi_codec->mad_clk_mutex); } static void sunxi_codec_mad_debug_reset(struct sunxi_codec_info *sunxi_codec) { struct sunxi_mad_priv *mad_priv = sunxi_codec->mad_priv; /* maybe had been disable because the cpu scheduling */ mutex_lock(&sunxi_codec->mad_clk_mutex); if (sunxi_codec->mad_clk_enable != true) { mutex_unlock(&sunxi_codec->mad_clk_mutex); return; } /* for reset mad module */ sunxi_mad_sram_set_reset_bit(); sunxi_mad_module_clk_enable(false); sunxi_mad_module_clk_enable(true); sunxi_codec->mad_clk_enable = true; /* sunxi_mad_close(); */ sunxi_mad_open(); sunxi_mad_hw_params(mad_priv->audio_src_chan_num, mad_priv->sample_rate); sunxi_mad_audio_src_chan_num(mad_priv->audio_src_chan_num); sunxi_lpsd_chan_sel(mad_priv->lpsd_chan_sel); sunxi_mad_standby_chan_sel(mad_priv->mad_standby_chan_sel); sunxi_mad_dma_type(SUNXI_MAD_DMA_IO); sunxi_sram_ahb1_threshole_init(); sunxi_mad_sram_init(); sunxi_codec_map_i2s_mad_set_path(sunxi_codec, true); mutex_unlock(&sunxi_codec->mad_clk_mutex); } static void sunxi_codec_map_i2s_rxctrl_stop_mad_reset(struct work_struct *work) { struct sunxi_codec_info *sunxi_codec = container_of(work, struct sunxi_codec_info, ws_rx_mad_reset); struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } sunxi_codec_mad_debug_reset(sunxi_codec); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (0x1 << DAUDIO_MAD_DATA_EN), (0x1 << DAUDIO_MAD_DATA_EN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_RXEN), (1 << CTL_RXEN)); #ifdef SUNXI_MAD_SRAM_SUSPEND_RESET sunxi_mad_sram_set_reset_flag(SUNXI_MAD_SRAM_RESET_END); #endif } #if 0 static void sunxi_codec_map_i2s_mad_reset(struct sunxi_codec_info *sunxi_codec, bool enable) { struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } if (enable) { #ifdef SUNXI_MAD_SRAM_SUSPEND_RESET sunxi_mad_sram_set_reset_flag(SUNXI_MAD_SRAM_RESET_START); #endif regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_RXEN), (0 << CTL_RXEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (0x1 << DAUDIO_MAD_DATA_EN), (0x0 << DAUDIO_MAD_DATA_EN)); sunxi_mad_dma_enable(false); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (0x1 << FIFO_CTL_FRX), (0x1 << FIFO_CTL_FRX)); regmap_write(sunxi_daudio->regmap, SUNXI_DAUDIO_RXCNT, 0); schedule_work(&(sunxi_codec->ws_rx_mad_reset)); } } #endif static void sunxi_codec_map_i2s_mad_control(struct sunxi_codec_info *sunxi_codec, bool enable) { struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } if (enable) { regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (0x1 << DAUDIO_MAD_DATA_EN), (0x1 << DAUDIO_MAD_DATA_EN)); sunxi_codec_mad_debug_control(sunxi_codec, true); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_RXEN), (1 << CTL_RXEN)); sunxi_mad_dma_type(SUNXI_MAD_DMA_IO); sunxi_mad_dma_enable(true); } else { sunxi_mad_dma_enable(false); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (0x1 << DAUDIO_MAD_DATA_EN), (0x0 << DAUDIO_MAD_DATA_EN)); } } void sunxi_codec_mad_enter_standby(struct sunxi_codec_info *sunxi_codec) { struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } sunxi_codec->capture_en = 1; sunxi_codec_mad_debug_control(sunxi_codec, false); regmap_update_bits(sunxi_codec->regmap, SUNXI_ADC_FIFO_CTL, (1<regmap, SUNXI_ADC_FIFO_STA, (1 << ADC_RXA_INT | 1 << ADC_RXO_INT)); regmap_write(sunxi_codec->regmap, SUNXI_ADC_CNT, 0); //tx fifo prepare regmap_update_bits(sunxi_codec->sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (1 << FIFO_CTL_FTX), (1 << FIFO_CTL_FTX)); regmap_write(sunxi_codec->sunxi_daudio->regmap, SUNXI_DAUDIO_TXCNT, 0); //rx fifo preapre regmap_update_bits(sunxi_codec->sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (1 << FIFO_CTL_FRX), (1 << FIFO_CTL_FRX)); regmap_write(sunxi_codec->sunxi_daudio->regmap, SUNXI_DAUDIO_RXCNT, 0); sunxi_codec_map_i2s_dma_trigger(sunxi_codec, true); sunxi_codec_map_i2s_txctrl_enable(sunxi_codec, true); regmap_update_bits(sunxi_codec->sunxi_daudio->regmap, SUNXI_DAUDIO_INTCTL, (1 << RXDRQEN), (1 << RXDRQEN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << CTL_RXEN), (1 << CTL_RXEN)); regmap_update_bits(sunxi_codec->regmap, SUNXI_ADC_FIFO_CTL, (1<regmap, SUNXI_DAUDIO_CTL, (0x1 << DAUDIO_MAD_DATA_EN), (0x1 << DAUDIO_MAD_DATA_EN)); sunxi_codec_mad_debug_control(sunxi_codec, true); } EXPORT_SYMBOL_GPL(sunxi_codec_mad_enter_standby); static void sunxi_codec_map_i2s_mad_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; struct sunxi_mad_priv *mad_priv = sunxi_codec->mad_priv; if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) && (mad_priv->mad_bind == 1)) { if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1<regmap, SUNXI_DAUDIO_CTL, (0x1 << DAUDIO_MAD_DATA_EN), (0x0 << DAUDIO_MAD_DATA_EN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << LOOP_EN), (0 << LOOP_EN)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (1 << GLOBAL_EN), (0 << GLOBAL_EN)); /* * pcm_close: * [1] cpu_dai->ops->shutdown; * [2] codec_dai->ops->shutdown; * [3] platform->ops->shutdown; */ mutex_lock(&sunxi_codec->mad_clk_mutex); /* diable daudio src*/ sunxi_codec_map_i2s_mad_set_path(sunxi_codec, false); sunxi_codec->capture_en = 0; sunxi_mad_close(); #ifndef MAD_CLK_ALWAYS_ON /*sunxi_mad_sram_set_reset_bit();*/ if (sunxi_codec->mad_clk_enable) { sunxi_mad_module_clk_enable(false); sunxi_codec->mad_clk_enable = false; } #endif mutex_unlock(&sunxi_codec->mad_clk_mutex); } #endif } static int sunxi_codec_i2s_set_clkdiv(struct snd_soc_dai *dai, int clk_id, int clk_div) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; unsigned int bclk_div, div_ratio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return -EINVAL; } sunxi_daudio->pcm_lrck_period = 64; /* I2S/TDM two channel mode */ div_ratio = clk_div/(2 * sunxi_daudio->pcm_lrck_period); switch (div_ratio) { case 1: bclk_div = SUNXI_DAUDIO_BCLK_DIV_1; break; case 2: bclk_div = SUNXI_DAUDIO_BCLK_DIV_2; break; case 4: bclk_div = SUNXI_DAUDIO_BCLK_DIV_3; break; case 6: bclk_div = SUNXI_DAUDIO_BCLK_DIV_4; break; case 8: bclk_div = SUNXI_DAUDIO_BCLK_DIV_5; break; case 12: bclk_div = SUNXI_DAUDIO_BCLK_DIV_6; break; case 16: bclk_div = SUNXI_DAUDIO_BCLK_DIV_7; break; case 24: bclk_div = SUNXI_DAUDIO_BCLK_DIV_8; break; case 32: bclk_div = SUNXI_DAUDIO_BCLK_DIV_9; break; case 48: bclk_div = SUNXI_DAUDIO_BCLK_DIV_10; break; case 64: bclk_div = SUNXI_DAUDIO_BCLK_DIV_11; break; case 96: bclk_div = SUNXI_DAUDIO_BCLK_DIV_12; break; case 128: bclk_div = SUNXI_DAUDIO_BCLK_DIV_13; break; case 176: bclk_div = SUNXI_DAUDIO_BCLK_DIV_14; break; case 192: bclk_div = SUNXI_DAUDIO_BCLK_DIV_15; break; default: dev_err(sunxi_daudio->dev, "unsupport clk_div\n"); return -EINVAL; } /* setting bclk to driver external codec bit clk */ regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CLKDIV, (SUNXI_DAUDIO_BCLK_DIV_MASK << BCLK_DIV), (bclk_div << BCLK_DIV)); return 0; } static int sunxi_codec_map_i2s_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; unsigned int frame_type = 0; unsigned int slot_width_select = 32; unsigned int msb_lsb_first = 0; unsigned int sign_extend = 0; unsigned int tx_data_mode = 0; unsigned int rx_data_mode = 0; sunxi_daudio->pcm_lrck_period = 64; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return -EINVAL; } /* SND_SOC_DAIFMT_CBS_CFS */ regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (SUNXI_DAUDIO_LRCK_OUT_MASK << LRCK_OUT), (SUNXI_DAUDIO_LRCK_OUT_ENABLE << LRCK_OUT)); /* SND_SOC_DAIFMT_I2S */ regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CTL, (SUNXI_DAUDIO_MODE_CTL_MASK << MODE_SEL), (SUNXI_DAUDIO_MODE_CTL_I2S << MODE_SEL)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_TX0CHSEL, (SUNXI_DAUDIO_TX_OFFSET_MASK << TX_OFFSET), (SUNXI_DAUDIO_TX_OFFSET_1 << TX_OFFSET)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_RXCHSEL, (SUNXI_DAUDIO_RX_OFFSET_MASK << RX_OFFSET), (SUNXI_DAUDIO_TX_OFFSET_1 << RX_OFFSET)); /* SND_SOC_DAIFMT_NB_NF */ regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT0, (1 << LRCK_POLARITY), (SUNXI_DAUDIO_LRCK_POLARITY_NOR << LRCK_POLARITY)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT0, (1<regmap, SUNXI_DAUDIO_FMT0, (1 << LRCK_WIDTH), (frame_type << LRCK_WIDTH)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT0, (SUNXI_DAUDIO_LRCK_PERIOD_MASK) << LRCK_PERIOD, ((sunxi_daudio->pcm_lrck_period - 1) << LRCK_PERIOD)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT0, (SUNXI_DAUDIO_SLOT_WIDTH_MASK << SLOT_WIDTH), (((slot_width_select >> 2) - 1) << SLOT_WIDTH)); /* * MSB on the transmit format, always be first. * default using Linear-PCM, without no companding. * A-law or U-law not working ok. */ regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT1, (0x1 << TX_MLS), (msb_lsb_first << TX_MLS)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT1, (0x1 << RX_MLS), (msb_lsb_first << RX_MLS)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT1, (0x3 << SEXT), (sign_extend << SEXT)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT1, (0x3 << TX_PDM), (tx_data_mode << TX_PDM)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT1, (0x3 << RX_PDM), (rx_data_mode << RX_PDM)); return 0; } static int sunxi_codec_map_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; #ifdef CONFIG_SND_SUNXI_MAD struct sunxi_mad_priv *mad_priv = sunxi_codec->mad_priv; #endif unsigned int SUNXI_DAUDIO_RXCHMAPX = 0; int index = 0; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return -EINVAL; } /* * sample rate * only set 16bit sample resolution. */ switch (params_format(params)) { case SNDRV_PCM_FORMAT_S16_LE: regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT0, (SUNXI_DAUDIO_SR_MASK << DAUDIO_SAMPLE_RESOLUTION), (SUNXI_DAUDIO_SR_16BIT << DAUDIO_SAMPLE_RESOLUTION)); break; case SNDRV_PCM_FORMAT_S32_LE: /* only for the compatible of tinyalsa */ case SNDRV_PCM_FORMAT_S24_LE: regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FMT0, (SUNXI_DAUDIO_SR_MASK << DAUDIO_SAMPLE_RESOLUTION), (SUNXI_DAUDIO_SR_24BIT << DAUDIO_SAMPLE_RESOLUTION)); break; default: pr_err("[%s] params_format[%d] error!\n", __func__, params_format(params)); return -EINVAL; } //TX Input Mode & RX Output Mode regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (SUNXI_DAUDIO_TXIM_MASK << TXIM), (SUNXI_DAUDIO_TXIM_VALID_LSB << TXIM)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (SUNXI_DAUDIO_RXOM_MASK << RXOM), (SUNXI_DAUDIO_RXOM_EXPH << RXOM)); //TX slot regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CHCFG, (SUNXI_DAUDIO_TX_SLOT_MASK << TX_SLOT_NUM), ((params_channels(params) - 1) << TX_SLOT_NUM)); regmap_write(sunxi_daudio->regmap, SUNXI_DAUDIO_TX0CHMAP0, SUNXI_DEFAULT_CHMAP0); regmap_write(sunxi_daudio->regmap, SUNXI_DAUDIO_TX0CHMAP1, SUNXI_DEFAULT_CHMAP1); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_TX0CHSEL, (SUNXI_DAUDIO_TX_CHSEL_MASK << TX_CHSEL), ((params_channels(params) - 1) << TX_CHSEL)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_TX0CHSEL, (SUNXI_DAUDIO_TX_CHEN_MASK << TX_CHEN), ((1 << params_channels(params)) - 1) << TX_CHEN); //RX_SLOT for (index = 0; index < 16; index++) { if (index >= 12) SUNXI_DAUDIO_RXCHMAPX = SUNXI_DAUDIO_RXCHMAP0; else if (index >= 8) SUNXI_DAUDIO_RXCHMAPX = SUNXI_DAUDIO_RXCHMAP1; else if (index >= 4) SUNXI_DAUDIO_RXCHMAPX = SUNXI_DAUDIO_RXCHMAP2; else SUNXI_DAUDIO_RXCHMAPX = SUNXI_DAUDIO_RXCHMAP3; regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_RXCHMAPX, DAUDIO_RXCHMAP(index), DAUDIO_RXCH_DEF_MAP(index)); } regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_CHCFG, (SUNXI_DAUDIO_RX_SLOT_MASK << RX_SLOT_NUM), ((params_channels(params) - 1) << RX_SLOT_NUM)); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_RXCHSEL, (SUNXI_DAUDIO_RX_CHSEL_MASK << RX_CHSEL), ((params_channels(params) - 1) << RX_CHSEL)); /* MAD hw_params */ #ifdef CONFIG_SND_SUNXI_MAD /*mad only supported 16k/48KHz samplerate when capturing*/ if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { if (mad_priv->mad_bind == 1) { /* mad only receive the high 16bit */ regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (SUNXI_DAUDIO_RXOM_MASK << RXOM), (SUNXI_DAUDIO_RXOM_TUNL << RXOM)); /* mad config */ if (params_format(params) != SNDRV_PCM_FORMAT_S16_LE) { dev_err(sunxi_codec->dev, "unsupported mad sample bits\n"); return -EINVAL; } mad_priv->audio_src_chan_num = params_channels(params); mad_priv->sample_rate = params_rate(params); sunxi_mad_audio_src_chan_num(mad_priv->audio_src_chan_num); sunxi_lpsd_chan_sel(mad_priv->lpsd_chan_sel); sunxi_mad_standby_chan_sel(mad_priv->mad_standby_chan_sel); } } #endif return 0; } static void sunxi_mad_codec_i2s_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; if (sunxi_daudio == NULL) { pr_debug("[%s] sunxi_daudio is null.\n", __func__); return; } //tx fifo prepare regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (1 << FIFO_CTL_FTX), (1 << FIFO_CTL_FTX)); regmap_write(sunxi_daudio->regmap, SUNXI_DAUDIO_TXCNT, 0); //rx fifo preapre regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_FIFOCTL, (1 << FIFO_CTL_FRX), (1 << FIFO_CTL_FRX)); regmap_write(sunxi_daudio->regmap, SUNXI_DAUDIO_RXCNT, 0); } #endif static void sunxi_codec_init(struct snd_soc_codec *codec) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); /* Disable DRC function for playback */ snd_soc_write(codec, SUNXI_DAC_DAP_CTL, 0); /* Disable HPF(high passed filter) */ snd_soc_update_bits(codec, SUNXI_DAC_DPC, (1 << HPF_EN), (0x0 << HPF_EN)); /* Enable ADCFDT to overcome niose at the beginning */ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL, (7 << ADCDFEN), (7 << ADCDFEN)); snd_soc_update_bits(codec, SUNXI_DAC_DPC, 0x3f << DVOL, sunxi_codec->gain_cfg.digital_vol << DVOL); snd_soc_update_bits(codec, SUNXI_MIC1_CTL, 0x7 << MIC1BOOST, sunxi_codec->gain_cfg.mic1gain << MIC1BOOST); /* must defautl init: 0x44 */ snd_soc_write(codec, SUNXI_MIC2_MIC3_CTL, 0x44); /* must defautl init: 0x0 */ snd_soc_write(codec, SUNXI_LADCMIX_SRC, 0x0); snd_soc_update_bits(codec, SUNXI_MIC2_MIC3_CTL, 0x7 << MIC2BOOST, sunxi_codec->gain_cfg.mic2gain << MIC2BOOST); snd_soc_update_bits(codec, SUNXI_MIC2_MIC3_CTL, 0x7 << MIC3BOOST, sunxi_codec->gain_cfg.mic3gain << MIC3BOOST); snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL1, 0x1f << LINEOUT_VOL, sunxi_codec->gain_cfg.lineout_vol << LINEOUT_VOL); snd_soc_update_bits(codec, SUNXI_ADC_CTL, 0x1f << ADCG, sunxi_codec->gain_cfg.adcgain << ADCG); if (sunxi_codec->hw_cfg.adcdrc_cfg) adcdrc_config(codec); if (sunxi_codec->hw_cfg.adchpf_cfg) adchpf_config(codec); if (sunxi_codec->hw_cfg.dacdrc_cfg) dacdrc_config(codec); if (sunxi_codec->hw_cfg.dachpf_cfg) dachpf_config(codec); } static int sunxi_codec_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; int i = 0; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); int ret = 0; #endif switch (params_format(params)) { case SNDRV_PCM_FORMAT_S16_LE: if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL, (3<stream == SNDRV_PCM_STREAM_PLAYBACK) { snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL, (3<stream == SNDRV_PCM_STREAM_PLAYBACK) { snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL, (0x7< 48000) return -EINVAL; snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL, (0x7<stream == SNDRV_PCM_STREAM_PLAYBACK) { switch (params_channels(params)) { case 1: snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL, (1<i2s_port == SUNXI_CODEC_MAP_PORT_NULL) { pr_warn("[%s] i2s_port: no use.\n", __func__); return 0; } /* daudio_init */ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { pr_warn("[%s] map_i2s not be used when playback.\n", __func__); return 0; } ret = sunxi_codec_map_i2s_set_fmt(dai, 0); if (ret < 0) { pr_err("[%s] sunxi_codec_map_i2s_set_fmt failed.\n", __func__); return ret; } ret = sunxi_codec_map_i2s_hw_params(substream, params, dai); if (ret < 0) { pr_err("[%s] sunxi_codec_map_i2s_hw_params failed.\n", __func__); return ret; } ret = sunxi_codec_map_i2s_dma_params(substream, params, dai); if (ret < 0) { pr_err("[%s] sunxi_codec_map_i2s_dma_params failed.\n", __func__); return ret; } #endif return 0; } static int sunxi_codec_set_sysclk(struct snd_soc_dai *dai, int clk_id, unsigned int freq, int dir) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (clk_set_rate(sunxi_codec->pllclk, freq)) { dev_err(sunxi_codec->dev, "set pllclk rate failed\n"); return -EINVAL; } return 0; } static int sunxi_codec_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div) { int ret = 0; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (sunxi_codec->i2s_port == SUNXI_CODEC_MAP_PORT_NULL) { pr_warn("[%s] i2s_port: no use.\n", __func__); return 0; } if (div_id == CODEC_DIV_CAPTURE) ret = sunxi_codec_i2s_set_clkdiv(dai, div_id, div); #endif return ret; } static int sunxi_codec_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { if (sunxi_codec->hw_cfg.dacdrc_cfg) dacdrc_enable(codec, 1); if (sunxi_codec->hw_cfg.dachpf_cfg) dachpf_enable(codec, 1); } else { if (sunxi_codec->hw_cfg.adcdrc_cfg) adcdrc_enable(codec, 1); if (sunxi_codec->hw_cfg.adchpf_cfg) adchpf_enable(codec, 1); } #ifdef SUNXI_CODEC_MAP_TO_DAUDIO sunxi_codec_map_i2s_startup(substream, dai); #ifdef CONFIG_SND_SUNXI_MAD sunxi_codec_map_i2s_mad_startup(substream, dai); #endif #endif return 0; } static void sunxi_codec_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { if (sunxi_codec->hw_cfg.dacdrc_cfg) dacdrc_enable(codec, 0); if (sunxi_codec->hw_cfg.dachpf_cfg) dachpf_enable(codec, 0); } else { if (sunxi_codec->hw_cfg.adcdrc_cfg) adcdrc_enable(codec, 0); if (sunxi_codec->hw_cfg.adchpf_cfg) adchpf_enable(codec, 0); } #ifdef SUNXI_CODEC_MAP_TO_DAUDIO sunxi_codec_map_i2s_shutdown(substream, dai); #ifdef CONFIG_SND_SUNXI_MAD sunxi_codec_map_i2s_mad_shutdown(substream, dai); #endif #endif } static int sunxi_codec_digital_mute(struct snd_soc_dai *dai, int mute) { #if 0 struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if ((mute != 0) && sunxi_codec->spk_cfg.used) { msleep(sunxi_codec->spk_cfg.pa_msleep_time); } #endif return 0; } static int sunxi_codec_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); #ifdef CONFIG_SND_SUNXI_MAD struct sunxi_mad_priv *mad_priv = sunxi_codec->mad_priv; #endif #endif if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL, (1<mad_bind && sunxi_codec->capture_en && (substream->runtime->status->state != SNDRV_PCM_STATE_XRUN)) { snd_printd("don't need to flush fifo and clear count.\n"); return 0; } #endif #endif snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL, (1<capture_en = 0; if (mad_priv->mad_bind) { sunxi_codec_mad_debug_control(sunxi_codec, false); } #endif #endif } return 0; } static int sunxi_codec_trigger(struct snd_pcm_substream *substream, int cmd, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO struct sunxi_i2s_params *sunxi_daudio = sunxi_codec->sunxi_daudio; #ifdef CONFIG_SND_SUNXI_MAD struct sunxi_mad_priv *mad_priv = sunxi_codec->mad_priv; #endif #endif switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) regmap_update_bits(sunxi_codec->regmap, SUNXI_DAC_FIFO_CTL, (1<mad_bind && sunxi_codec->capture_en) { pr_warn("====== setup mad dma type & enable ======"); sunxi_mad_dma_type(SUNXI_MAD_DMA_IO); sunxi_mad_dma_enable(true); return 0; } #endif sunxi_codec->buffer_bytes = snd_pcm_lib_buffer_bytes(substream); sunxi_codec->period_bytes = snd_pcm_lib_period_bytes(substream); sunxi_codec_map_i2s_dma_trigger(sunxi_codec, true); sunxi_codec_map_i2s_txctrl_enable(sunxi_codec, true); if (sunxi_daudio != NULL) { pr_warn("====== setup i2s RXDRQ ======"); regmap_update_bits(sunxi_daudio->regmap, SUNXI_DAUDIO_INTCTL, (1 << RXDRQEN), (1 << RXDRQEN)); } #endif regmap_update_bits(sunxi_codec->regmap, SUNXI_ADC_FIFO_CTL, (1 << ADC_DRQ_EN), (1 << ADC_DRQ_EN)); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO sunxi_codec_map_i2s_global_enable(sunxi_codec, true); #ifdef CONFIG_SND_SUNXI_MAD if (mad_priv->mad_bind) { sunxi_codec_map_i2s_mad_control(sunxi_codec, true); sunxi_codec->capture_en = 1; } #endif #endif } break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_PAUSE_PUSH: if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) regmap_update_bits(sunxi_codec->regmap, SUNXI_DAC_FIFO_CTL, (1 << DAC_DRQ_EN), (0 << DAC_DRQ_EN)); else { #ifdef SUNXI_CODEC_MAP_TO_DAUDIO sunxi_codec_map_i2s_global_enable(sunxi_codec, false); sunxi_codec_map_i2s_txctrl_enable(sunxi_codec, false); sunxi_codec_map_i2s_rxctrl_enable(sunxi_codec, false); sunxi_codec_map_i2s_dma_trigger(sunxi_codec, false); #ifdef CONFIG_SND_SUNXI_MAD if (mad_priv->mad_bind) { sunxi_codec_map_i2s_mad_control(sunxi_codec, false); sunxi_codec->capture_en = 0; } #endif #endif regmap_update_bits(sunxi_codec->regmap, SUNXI_ADC_FIFO_CTL, (1 << ADC_DRQ_EN), (0 << ADC_DRQ_EN)); } break; default: return -EINVAL; } return 0; } static const struct snd_soc_dai_ops sunxi_codec_dai_ops = { .hw_params = sunxi_codec_hw_params, .shutdown = sunxi_codec_shutdown, .startup = sunxi_codec_startup, .digital_mute = sunxi_codec_digital_mute, .set_sysclk = sunxi_codec_set_sysclk, .set_clkdiv = sunxi_codec_set_clkdiv, .trigger = sunxi_codec_trigger, .prepare = sunxi_codec_prepare, }; static struct snd_soc_dai_driver sunxi_codec_dai[] = { { .name = "sun8iw18codec", .playback = { .stream_name = "Playback", .channels_min = 1, .channels_max = 2, .rates = SNDRV_PCM_RATE_8000_192000 | SNDRV_PCM_RATE_KNOT, .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE, }, .capture = { .stream_name = "Capture", .channels_min = 1, .channels_max = 4, .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_KNOT, .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE, }, .ops = &sunxi_codec_dai_ops, }, }; static int sunxi_codec_probe(struct snd_soc_codec *codec) { int ret; struct snd_soc_dapm_context *dapm = &codec->component.dapm; struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); sunxi_codec->codec = codec; ret = snd_soc_add_codec_controls(codec, sunxi_codec_controls, ARRAY_SIZE(sunxi_codec_controls)); if (ret) pr_err("failed to register codec controls!\n"); snd_soc_dapm_new_controls(dapm, sunxi_codec_dapm_widgets, ARRAY_SIZE(sunxi_codec_dapm_widgets)); snd_soc_dapm_add_routes(dapm, sunxi_codec_dapm_routes, ARRAY_SIZE(sunxi_codec_dapm_routes)); sunxi_codec_init(codec); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO #ifdef CONFIG_SND_SUNXI_MAD INIT_WORK(&(sunxi_codec->ws_rx_mad_reset), sunxi_codec_map_i2s_rxctrl_stop_mad_reset); mutex_init(&(sunxi_codec->mad_clk_mutex)); #endif #endif mutex_init(&(sunxi_codec->dac_mutex)); mutex_init(&(sunxi_codec->adc_mutex)); sunxi_codec->adc_enable = 0; sunxi_codec->dac_enable = 0; sunxi_codec->dac_dap_enable = 0; sunxi_codec->adc_dap_enable = 0; return 0; } static int sunxi_codec_remove(struct snd_soc_codec *codec) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); mutex_destroy(&(sunxi_codec->adc_mutex)); mutex_destroy(&(sunxi_codec->dac_mutex)); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO #ifdef CONFIG_SND_SUNXI_MAD mutex_destroy(&(sunxi_codec->mad_clk_mutex)); cancel_work_sync(&(sunxi_codec->ws_rx_mad_reset)); #endif #endif return 0; } static int sunxi_gpio_iodisable(u32 gpio) { char pin_name[8]; u32 config, ret; sunxi_gpio_to_name(gpio, pin_name); config = 7 << 16; ret = pin_config_set(SUNXI_PINCTRL, pin_name, config); return ret; } static int save_audio_reg(struct sunxi_codec_info *sunxi_codec) { int i = 0; int reg_group = 0; while (reg_labels[i].name != NULL) { if (reg_labels[i].address == SUNXI_HP_CTL) reg_group++; if (reg_group != 1) { reg_labels[i].value = readl(sunxi_codec->addr_dbase + reg_labels[i].address); } else if (reg_group == 1) { reg_labels[i].value = read_prcm_wvalue( reg_labels[i].address - SUNXI_PR_CFG, sunxi_codec->addr_abase); } i++; } return i; } static int echo_audio_reg(struct sunxi_codec_info *sunxi_codec) { int i = 0; while (reg_labels[i].name != NULL) { snd_soc_write(sunxi_codec->codec, reg_labels[i].address, reg_labels[i].value); i++; } return i; } #ifdef CONFIG_SUNXI_AUDIO_DEBUG void show_audio_all_reg(struct sunxi_codec_info *sunxi_codec) { int i = 0; unsigned int reg_val; pr_warn("dump audio reg:\n"); while (reg_labels[i].name != NULL) { reg_val = snd_soc_read(sunxi_codec->codec, reg_labels[i].address); pr_warn("%-20s[0x%03x]: 0x%-10x\n", reg_labels[i].name, reg_labels[i].address, reg_val); i++; } } #endif static int sunxi_codec_suspend(struct snd_soc_codec *codec) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); pr_debug("Enter %s\n", __func__); /* save the audio reg */ save_audio_reg(sunxi_codec); if (sunxi_codec->pa_power_cfg.used) { gpio_set_value(sunxi_codec->pa_power_cfg.gpio, 0); sunxi_gpio_iodisable(sunxi_codec->pa_power_cfg.gpio); } if (sunxi_codec->spk_cfg.used) { gpio_set_value(sunxi_codec->spk_cfg.gpio, !(sunxi_codec->spk_cfg.pa_ctl_level)); sunxi_gpio_iodisable(sunxi_codec->spk_cfg.gpio); } clk_disable_unprepare(sunxi_codec->moduleclk); clk_disable_unprepare(sunxi_codec->pllclkx4); clk_disable_unprepare(sunxi_codec->pllclk); pr_debug("End %s\n", __func__); return 0; } static int sunxi_codec_resume(struct snd_soc_codec *codec) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); pr_debug("Enter %s\n", __func__); if (clk_prepare_enable(sunxi_codec->pllclk)) { dev_err(sunxi_codec->dev, "enable pllclk failed, resume exit\n"); return -EBUSY; } if (clk_prepare_enable(sunxi_codec->pllclkx4)) { dev_err(sunxi_codec->dev, "enable pllclkx4 failed, resume exit\n"); return -EBUSY; } if (clk_prepare_enable(sunxi_codec->moduleclk)) { dev_err(sunxi_codec->dev, "enable moduleclk failed, resume exit\n"); clk_disable_unprepare(sunxi_codec->pllclkx4); clk_disable_unprepare(sunxi_codec->pllclk); return -EBUSY; } /* for stable the power and clk */ msleep(20); if (sunxi_codec->pa_power_cfg.used) { gpio_direction_output(sunxi_codec->pa_power_cfg.gpio, 1); gpio_set_value(sunxi_codec->pa_power_cfg.gpio, 1); } if (sunxi_codec->spk_cfg.used) { gpio_direction_output(sunxi_codec->spk_cfg.gpio, 1); gpio_set_value(sunxi_codec->spk_cfg.gpio, !sunxi_codec->spk_cfg.pa_ctl_level); } sunxi_codec_init(codec); /* echo the reg that had saved */ echo_audio_reg(sunxi_codec); pr_debug("End %s\n", __func__); return 0; } static unsigned int sunxi_codec_read(struct snd_soc_codec *codec, unsigned int reg) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); unsigned int reg_val; if (reg >= SUNXI_PR_CFG) { /* Analog part */ reg = reg - SUNXI_PR_CFG; return read_prcm_wvalue(reg, sunxi_codec->addr_abase); } else { regmap_read(sunxi_codec->regmap, reg, ®_val); } return reg_val; } static int sunxi_codec_write(struct snd_soc_codec *codec, unsigned int reg, unsigned int val) { struct sunxi_codec_info *sunxi_codec = snd_soc_codec_get_drvdata(codec); if (reg >= SUNXI_PR_CFG) { /* Analog part */ reg = reg - SUNXI_PR_CFG; write_prcm_wvalue(reg, val, sunxi_codec->addr_abase); } else { regmap_write(sunxi_codec->regmap, reg, val); } return 0; }; static struct snd_soc_codec_driver soc_codec_dev_sunxi = { .probe = sunxi_codec_probe, .remove = sunxi_codec_remove, .suspend = sunxi_codec_suspend, .resume = sunxi_codec_resume, .read = sunxi_codec_read, .write = sunxi_codec_write, .ignore_pmdown_time = 1, #if 0 .controls = sunxi_codec_controls, .num_controls = ARRAY_SIZE(sunxi_codec_controls), .dapm_widgets = sunxi_codec_dapm_widgets, .num_dapm_widgets = ARRAY_SIZE(sunxi_codec_dapm_widgets), .dapm_routes = sunxi_codec_dapm_routes, .num_dapm_routes = ARRAY_SIZE(sunxi_codec_dapm_routes), #endif }; static ssize_t show_audio_reg(struct device *dev, struct device_attribute *attr, char *buf) { struct sunxi_codec_info *sunxi_codec = dev_get_drvdata(dev); int count = 0, i = 0; unsigned int reg_val; count += sprintf(buf, "dump audio reg:\n"); while (reg_labels[i].name != NULL) { reg_val = snd_soc_read(sunxi_codec->codec, reg_labels[i].address); count += sprintf(buf + count, "%-20s[0x%03x]: 0x%-10x Save:0x%x\n", reg_labels[i].name, reg_labels[i].address, reg_val, reg_labels[i].value); i++; } return count; } /* ex: * param 1: 0 read;1 write * param 2: 1 digital reg; 2 analog reg * param 3: reg value; * param 4: write value; * read: * echo 0,1,0x00> audio_reg * echo 0,2,0x00> audio_reg * write: * echo 1,1,0x00,0xa > audio_reg * echo 1,2,0x00,0xff > audio_reg */ static ssize_t store_audio_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; int rw_flag; int input_reg_val = 0; int input_reg_group = 0; int input_reg_offset = 0; struct sunxi_codec_info *sunxi_codec = dev_get_drvdata(dev); ret = sscanf(buf, "%d,%d,0x%x,0x%x", &rw_flag, &input_reg_group, &input_reg_offset, &input_reg_val); dev_info(dev, "ret:%d, reg_group:%d, reg_offset:%d, reg_val:0x%x\n", ret, input_reg_group, input_reg_offset, input_reg_val); if (!(input_reg_group == 1 || input_reg_group == 2)) { pr_err("not exist reg group\n"); ret = count; goto out; } if (!(rw_flag == 1 || rw_flag == 0)) { pr_err("not rw_flag\n"); ret = count; goto out; } if (input_reg_group == 1) { if (rw_flag) { regmap_write(sunxi_codec->regmap, input_reg_offset, input_reg_val); } else { regmap_read(sunxi_codec->regmap, input_reg_offset, &input_reg_val); dev_info(dev, "\n\n Reg[0x%x] : 0x%08x\n\n", input_reg_offset, input_reg_val); } } else if (input_reg_group == 2) { if (rw_flag) { write_prcm_wvalue(input_reg_offset, input_reg_val & 0xff, sunxi_codec->addr_abase); } else { input_reg_val = read_prcm_wvalue(input_reg_offset, sunxi_codec->addr_abase); dev_info(dev, "\n\n Reg[0x%02x] : 0x%02x\n\n", input_reg_offset, input_reg_val); } } ret = count; out: return ret; } static DEVICE_ATTR(audio_reg, 0644, show_audio_reg, store_audio_reg); static struct attribute *audio_debug_attrs[] = { &dev_attr_audio_reg.attr, NULL, }; static struct attribute_group audio_debug_attr_group = { .name = "audio_reg_debug", .attrs = audio_debug_attrs, }; static const struct regmap_config sunxi_codec_regmap_config = { .reg_bits = 32, .reg_stride = 4, .val_bits = 32, .max_register = AC_VERSION, .cache_type = REGCACHE_NONE, }; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO static const struct regmap_config sunxi_i2s_regmap_config[] = { { .reg_bits = 32, .reg_stride = 4, .val_bits = 32, .max_register = 0x7c, .cache_type = REGCACHE_NONE, }, { .reg_bits = 32, .reg_stride = 4, .val_bits = 32, .max_register = 0x7c, .cache_type = REGCACHE_NONE, }, { .reg_bits = 32, .reg_stride = 4, .val_bits = 32, .max_register = 0x7c, .cache_type = REGCACHE_NONE, }, }; #endif static int sunxi_codec_dev_probe(struct platform_device *pdev) { struct sunxi_codec_info *sunxi_codec; struct device_node *np = pdev->dev.of_node; struct gpio_config config_gpio; struct resource res; unsigned int temp_val; int ret; sunxi_codec = devm_kzalloc(&pdev->dev, sizeof(struct sunxi_codec_info), GFP_KERNEL); if (!sunxi_codec) { dev_err(&pdev->dev, "Can't allocate sunxi codec memory\n"); ret = -ENOMEM; goto err_node_put; } dev_set_drvdata(&pdev->dev, sunxi_codec); sunxi_codec->dev = &pdev->dev; sunxi_codec->pllclk = of_clk_get(np, 0); if (IS_ERR_OR_NULL(sunxi_codec->pllclk)) { dev_err(&pdev->dev, "pllclk not exist or invaild\n"); ret = PTR_ERR(sunxi_codec->pllclk); goto err_devm_kfree; } sunxi_codec->pllclkx4 = of_clk_get(np, 1); if (IS_ERR_OR_NULL(sunxi_codec->pllclkx4)) { dev_err(&pdev->dev, "pllclkx4 not exist or invaild\n"); ret = PTR_ERR(sunxi_codec->pllclkx4); goto err_pllclk_put; } sunxi_codec->moduleclk = of_clk_get(np, 2); if (IS_ERR_OR_NULL(sunxi_codec->moduleclk)) { dev_err(&pdev->dev, "moduleclk not exist or invaild\n"); ret = PTR_ERR(sunxi_codec->moduleclk); goto err_pllclk_put; } else { if (clk_set_parent(sunxi_codec->moduleclk, sunxi_codec->pllclkx4)) { dev_err(&pdev->dev, "set parent of moduleclk to pllclk failed\n"); ret = -EBUSY; goto err_pllclkx4_put; } } if (clk_prepare_enable(sunxi_codec->pllclk)) { dev_err(&pdev->dev, "pllclk enable failed\n"); ret = -EBUSY; goto err_moduleclk_put; } if (clk_prepare_enable(sunxi_codec->pllclkx4)) { dev_err(&pdev->dev, "pllclkx4 enable failed\n"); ret = -EBUSY; goto err_pllclk_disable; } if (clk_prepare_enable(sunxi_codec->moduleclk)) { dev_err(&pdev->dev, "moduleclk enable failed\n"); ret = -EBUSY; goto err_pllclkx4_disable; } #ifdef SUNXI_CODEC_MAP_TO_DAUDIO /* for i2s0 */ sunxi_codec->daudio[0].i2s_clk = of_clk_get(np, 3); if (IS_ERR_OR_NULL(sunxi_codec->daudio[0].i2s_clk)) { dev_err(&pdev->dev, "i2s0 module clk not exist or invaild\n"); ret = PTR_ERR(sunxi_codec->daudio[0].i2s_clk); goto err_moduleclk_disable; } if (clk_set_parent(sunxi_codec->daudio[0].i2s_clk, sunxi_codec->pllclkx4)) { dev_err(&pdev->dev, "set parent of i2s0 clk to pllclk failed\n"); ret = -EBUSY; goto err_i2s0_clk_put; } /* for i2s1 */ sunxi_codec->daudio[1].i2s_clk = of_clk_get(np, 4); if (IS_ERR_OR_NULL(sunxi_codec->daudio[1].i2s_clk)) { dev_err(&pdev->dev, "i2s1 module clk not exist or invaild\n"); ret = PTR_ERR(sunxi_codec->daudio[1].i2s_clk); goto err_i2s0_clk_put; } if (clk_set_parent(sunxi_codec->daudio[1].i2s_clk, sunxi_codec->pllclkx4)) { dev_err(&pdev->dev, "set parent of i2s1 clk to pllclk failed\n"); ret = -EBUSY; goto err_i2s1_clk_put; } /* for i2s2 */ sunxi_codec->daudio[2].i2s_clk = of_clk_get(np, 5); if (IS_ERR_OR_NULL(sunxi_codec->daudio[2].i2s_clk)) { dev_err(&pdev->dev, "i2s2 module clk not exist or invaild\n"); ret = PTR_ERR(sunxi_codec->daudio[2].i2s_clk); goto err_i2s1_clk_put; } if (clk_set_parent(sunxi_codec->daudio[2].i2s_clk, sunxi_codec->pllclkx4)) { dev_err(&pdev->dev, "set parent of i2s2 clk to pllclk failed\n"); ret = -EBUSY; goto err_i2s2_clk_put; } #endif /* codec reg_base */ ret = of_address_to_resource(np, 0, &res); if (ret) { dev_err(&pdev->dev, "parse device node codec resource failed\n"); ret = -EINVAL; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO goto err_i2s2_clk_put; #else goto err_pllclkx4_disable; #endif } memcpy(&(sunxi_codec->digital_res), &res, sizeof(struct resource)); sunxi_codec->addr_dbase = of_iomap(np, 0); if (sunxi_codec->addr_dbase == NULL) { dev_err(&pdev->dev, "digital register iomap failed\n"); ret = -EINVAL; #ifdef SUNXI_CODEC_MAP_TO_DAUDIO goto err_i2s2_clk_put; #else goto err_moduleclk_disable; #endif } ret = of_address_to_resource(np, 1, &res); if (ret) { dev_err(&pdev->dev, "parse device node codec resource failed\n"); ret = -EINVAL; goto err_dbase_iounmap; } memcpy(&(sunxi_codec->analog_res), &res, sizeof(struct resource)); /* Analog register part, not using regmap */ sunxi_codec->addr_abase = of_iomap(np, 1); if (sunxi_codec->addr_abase == NULL) { dev_err(&pdev->dev, "analog register iomap failed\n"); ret = -EINVAL; goto err_dbase_iounmap; } #ifdef SUNXI_CODEC_MAP_TO_DAUDIO /* I2S0 reg_base */ ret = of_address_to_resource(np, 2, &res); if (ret) { dev_err(&pdev->dev, "parse device node i2s0 resource failed\n"); ret = -EINVAL; goto err_analog_iounmap; } memcpy(&(sunxi_codec->daudio[0].res), &res, sizeof(struct resource)); sunxi_codec->daudio[0].base = of_iomap(np, 2); if (sunxi_codec->daudio[0].base == NULL) { dev_err(&pdev->dev, "i2s0 register iomap failed\n"); ret = -EINVAL; goto err_analog_iounmap; } sunxi_codec->daudio[0].regmap = devm_regmap_init_mmio(&pdev->dev, sunxi_codec->daudio[0].base, &sunxi_i2s_regmap_config[0]); if (IS_ERR(sunxi_codec->daudio[0].regmap)) { dev_err(&pdev->dev, "daudio0 regmap init failed\n"); ret = PTR_ERR(sunxi_codec->daudio[0].regmap); goto err_i2s0_base_iounmap; } /* I2S1 reg_base */ ret = of_address_to_resource(np, 3, &res); if (ret) { dev_err(&pdev->dev, "parse device node i2s1 resource failed\n"); ret = -EINVAL; goto err_i2s0_base_iounmap; } memcpy(&(sunxi_codec->daudio[1].res), &res, sizeof(struct resource)); sunxi_codec->daudio[1].base = of_iomap(np, 3); if (sunxi_codec->daudio[1].base == NULL) { dev_err(&pdev->dev, "i2s1 register iomap failed\n"); ret = -EINVAL; goto err_i2s0_base_iounmap; } sunxi_codec->daudio[1].regmap = devm_regmap_init_mmio(&pdev->dev, sunxi_codec->daudio[1].base, &sunxi_i2s_regmap_config[1]); if (IS_ERR(sunxi_codec->daudio[1].regmap)) { dev_err(&pdev->dev, "daudio1 regmap init failed\n"); ret = PTR_ERR(sunxi_codec->daudio[1].regmap); goto err_i2s1_base_iounmap; } /* I2S2 reg_base */ ret = of_address_to_resource(np, 4, &res); if (ret) { dev_err(&pdev->dev, "parse device node i2s2 resource failed\n"); ret = -EINVAL; goto err_i2s1_base_iounmap; } memcpy(&(sunxi_codec->daudio[2].res), &res, sizeof(struct resource)); sunxi_codec->daudio[2].base = of_iomap(np, 4); if (sunxi_codec->daudio[2].base == NULL) { dev_err(&pdev->dev, "i2s2 register iomap failed\n"); ret = -EINVAL; goto err_i2s1_base_iounmap; } sunxi_codec->daudio[2].regmap = devm_regmap_init_mmio(&pdev->dev, sunxi_codec->daudio[2].base, &sunxi_i2s_regmap_config[2]); if (IS_ERR(sunxi_codec->daudio[2].regmap)) { dev_err(&pdev->dev, "daudio2 regmap init failed\n"); ret = PTR_ERR(sunxi_codec->daudio[2].regmap); goto err_i2s2_base_iounmap; } #endif sunxi_codec->regmap = devm_regmap_init_mmio(&pdev->dev, sunxi_codec->addr_dbase, &sunxi_codec_regmap_config); if (IS_ERR(sunxi_codec->regmap)) { dev_err(&pdev->dev, "regmap init failed\n"); ret = PTR_ERR(sunxi_codec->regmap); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO goto err_i2s2_base_iounmap; #else goto err_analog_iounmap; #endif } ret = of_property_read_u32(np, "digital_vol", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "digital_vol get failed\n"); sunxi_codec->gain_cfg.digital_vol = 0; } else { sunxi_codec->gain_cfg.digital_vol = temp_val; } ret = of_property_read_u32(np, "lineout_vol", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "lineout volume get failed\n"); sunxi_codec->gain_cfg.lineout_vol = 0x1a; } else { sunxi_codec->gain_cfg.lineout_vol = temp_val; } ret = of_property_read_u32(np, "mic1gain", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "mic1 gain get failed\n"); sunxi_codec->gain_cfg.mic1gain = 0x4; } else { sunxi_codec->gain_cfg.mic1gain = temp_val; } ret = of_property_read_u32(np, "mic2gain", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "mic2 gain get failed\n"); sunxi_codec->gain_cfg.mic2gain = 0x4; } else { sunxi_codec->gain_cfg.mic2gain = temp_val; } ret = of_property_read_u32(np, "mic3gain", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "mic3 gain get failed\n"); sunxi_codec->gain_cfg.mic3gain = 0x4; } else { sunxi_codec->gain_cfg.mic3gain = temp_val; } ret = of_property_read_u32(np, "adcgain", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "adc input gain get failed\n"); sunxi_codec->gain_cfg.adcgain = 0x3; } else { sunxi_codec->gain_cfg.adcgain = temp_val; } ret = of_property_read_u32(np, "pa_msleep_time", &temp_val); if (ret < 0) { dev_warn(&pdev->dev, "pa_msleep_time get failed\n"); sunxi_codec->spk_cfg.pa_msleep_time = 160; } else { sunxi_codec->spk_cfg.pa_msleep_time = temp_val; } ret = of_property_read_u32(np, "pa_ctl_level", &temp_val); if (ret < 0) { pr_err("[audio-codec] pa_clt_level config missing or invalid.\n"); sunxi_codec->spk_cfg.pa_ctl_level = 1; } else { sunxi_codec->spk_cfg.pa_ctl_level = temp_val; } pr_debug("[codec init] digital_vol:%d, lineout_vol:%d, pa_msleep_time:%d\n", sunxi_codec->gain_cfg.digital_vol, sunxi_codec->gain_cfg.lineout_vol, sunxi_codec->spk_cfg.pa_msleep_time); pr_debug("[codec init] mic1gain:%d, mic2gain:%d, mic3gain:%d, adcgain:%d\n", sunxi_codec->gain_cfg.mic1gain, sunxi_codec->gain_cfg.mic2gain, sunxi_codec->gain_cfg.mic3gain, sunxi_codec->gain_cfg.adcgain ); ret = of_property_read_u32(np, "adcdrc_cfg", &temp_val); if (ret < 0) { pr_err("[audio-codec] adcdrc_cfg config missing or invalid.\n"); sunxi_codec->hw_cfg.adcdrc_cfg = 0; } else { sunxi_codec->hw_cfg.adcdrc_cfg = temp_val; } ret = of_property_read_u32(np, "adchpf_cfg", &temp_val); if (ret < 0) { pr_err("[audio-codec] adchpf_cfg config missing or invalid.\n"); sunxi_codec->hw_cfg.adchpf_cfg = 0; } else { sunxi_codec->hw_cfg.adchpf_cfg = temp_val; } ret = of_property_read_u32(np, "dacdrc_cfg", &temp_val); if (ret < 0) { pr_err("[audio-codec] dacdrc_cfg config missing or invalid.\n"); sunxi_codec->hw_cfg.dacdrc_cfg = 0; } else { sunxi_codec->hw_cfg.dacdrc_cfg = temp_val; } ret = of_property_read_u32(np, "dachpf_cfg", &temp_val); if (ret < 0) { pr_err("[audio-codec] dachpf_cfg config missing or invalid.\n"); sunxi_codec->hw_cfg.dachpf_cfg = 0; } else { sunxi_codec->hw_cfg.dachpf_cfg = temp_val; } sunxi_codec->spk_cfg.gpio = of_get_named_gpio_flags(np, "gpio-spk", 0, (enum of_gpio_flags *)&config_gpio); if (gpio_is_valid(sunxi_codec->spk_cfg.gpio)) { sunxi_codec->spk_cfg.used = 1; ret = devm_gpio_request(&pdev->dev, sunxi_codec->spk_cfg.gpio, "SPK"); if (ret) { dev_err(&pdev->dev, "failed to request gpio-spk gpio\n"); ret = -EBUSY; goto err_analog_iounmap; } else { gpio_direction_output(sunxi_codec->spk_cfg.gpio, 1); gpio_set_value(sunxi_codec->spk_cfg.gpio, !(sunxi_codec->spk_cfg.pa_ctl_level)); } } else { sunxi_codec->spk_cfg.used = 0; dev_err(&pdev->dev, "gpio-spk is invalid!\n"); } sunxi_codec->pa_power_cfg.gpio = of_get_named_gpio_flags(np, "gpio-pa-power", 0, (enum of_gpio_flags *)&config_gpio); if (gpio_is_valid(sunxi_codec->pa_power_cfg.gpio)) { sunxi_codec->pa_power_cfg.used = 1; ret = devm_gpio_request(&pdev->dev, sunxi_codec->pa_power_cfg.gpio, "PA Power"); if (ret) { dev_err(&pdev->dev, "failed to request gpio-pa-power\n"); ret = -EBUSY; sunxi_codec->pa_power_cfg.used = 0; goto err_devm_gpio_free; } else { gpio_direction_output(sunxi_codec->pa_power_cfg.gpio, 1); gpio_set_value(sunxi_codec->pa_power_cfg.gpio, 0); } } else { sunxi_codec->pa_power_cfg.used = 0; pr_debug("gpio-pa-power is invalid!\n"); } ret = snd_soc_register_codec(&pdev->dev, &soc_codec_dev_sunxi, sunxi_codec_dai, ARRAY_SIZE(sunxi_codec_dai)); if (ret < 0) { dev_err(&pdev->dev, "register codec failed\n"); ret = -EBUSY; goto err_devm_gpio_free; } ret = sysfs_create_group(&pdev->dev.kobj, &audio_debug_attr_group); if (ret < 0) { dev_warn(&pdev->dev, "failed to create attr group\n"); goto err_sysfs_create; } #ifdef SUNXI_CODEC_MAP_TO_DAUDIO sunxi_codec->i2s_port = SUNXI_CODEC_MAP_PORT_NULL; #endif return 0; err_sysfs_create: sysfs_remove_group(&pdev->dev.kobj, &audio_debug_attr_group); err_devm_gpio_free: if (sunxi_codec->pa_power_cfg.used) devm_gpio_free(&pdev->dev, sunxi_codec->pa_power_cfg.gpio); if (sunxi_codec->spk_cfg.used) devm_gpio_free(&pdev->dev, sunxi_codec->spk_cfg.gpio); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO err_i2s2_base_iounmap: iounmap(sunxi_codec->daudio[2].base); err_i2s1_base_iounmap: iounmap(sunxi_codec->daudio[1].base); err_i2s0_base_iounmap: iounmap(sunxi_codec->daudio[0].base); #endif err_analog_iounmap: iounmap(sunxi_codec->addr_abase); err_dbase_iounmap: iounmap(sunxi_codec->addr_dbase); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO err_i2s2_clk_put: clk_put(sunxi_codec->daudio[2].i2s_clk); err_i2s1_clk_put: clk_put(sunxi_codec->daudio[1].i2s_clk); err_i2s0_clk_put: clk_put(sunxi_codec->daudio[0].i2s_clk); #endif err_moduleclk_disable: clk_disable_unprepare(sunxi_codec->moduleclk); err_pllclkx4_disable: clk_disable_unprepare(sunxi_codec->pllclkx4); err_pllclk_disable: clk_disable_unprepare(sunxi_codec->pllclk); err_moduleclk_put: clk_put(sunxi_codec->moduleclk); err_pllclkx4_put: clk_put(sunxi_codec->pllclkx4); err_pllclk_put: clk_put(sunxi_codec->pllclk); err_devm_kfree: devm_kfree(&pdev->dev, sunxi_codec); err_node_put: of_node_put(np); return ret; } static int __exit sunxi_codec_dev_remove(struct platform_device *pdev) { struct sunxi_codec_info *sunxi_codec = dev_get_drvdata(&pdev->dev); struct device_node *np = pdev->dev.of_node; snd_soc_unregister_codec(&pdev->dev); iounmap(sunxi_codec->addr_abase); iounmap(sunxi_codec->addr_dbase); #ifdef SUNXI_CODEC_MAP_TO_DAUDIO clk_put(sunxi_codec->daudio[0].i2s_clk); clk_put(sunxi_codec->daudio[1].i2s_clk); clk_put(sunxi_codec->daudio[2].i2s_clk); #endif clk_disable_unprepare(sunxi_codec->moduleclk); clk_put(sunxi_codec->moduleclk); clk_disable_unprepare(sunxi_codec->pllclkx4); clk_put(sunxi_codec->pllclkx4); clk_disable_unprepare(sunxi_codec->pllclk); clk_put(sunxi_codec->pllclk); if (sunxi_codec->pa_power_cfg.used) devm_gpio_free(&pdev->dev, sunxi_codec->pa_power_cfg.gpio); if (sunxi_codec->spk_cfg.used) devm_gpio_free(&pdev->dev, sunxi_codec->spk_cfg.gpio); sysfs_remove_group(&pdev->dev.kobj, &audio_debug_attr_group); devm_kfree(&pdev->dev, sunxi_codec); of_node_put(np); return 0; } static const struct of_device_id sunxi_internal_codec_of_match[] = { { .compatible = "allwinner,sunxi-internal-codec", }, {}, }; static struct platform_driver sunxi_internal_codec_driver = { .driver = { .name = DRV_NAME, .owner = THIS_MODULE, .of_match_table = sunxi_internal_codec_of_match, }, .probe = sunxi_codec_dev_probe, .remove = __exit_p(sunxi_codec_dev_remove), }; module_platform_driver(sunxi_internal_codec_driver); MODULE_DESCRIPTION("SUNXI Codec ASoC driver"); MODULE_AUTHOR("wolfgang huang "); MODULE_LICENSE("GPL"); MODULE_ALIAS("platform:sunxi-internal-codec");