OpenIPC
/
firmware
mirror of https://github.com/OpenIPC/firmware.git
1
0
Fork 0
Code Activity
firmware/br-ext-chip-allwinner/board/v83x/kernel/patches/00000-sound_soc_sunxi_sun8i...

2983 lines
90 KiB
Diff
Raw Blame History

diff -drupN a/sound/soc/sunxi/sun8iw18-codec.c b/sound/soc/sunxi/sun8iw18-codec.c
--- a/sound/soc/sunxi/sun8iw18-codec.c 1970-01-01 03:00:00.000000000 +0300
+++ b/sound/soc/sunxi/sun8iw18-codec.c 2022-06-12 05:28:14.000000000 +0300
@@ -0,0 +1,2978 @@
+/*
+ * sound\soc\sunxi\sun8iw18-codec.c
+ * (C) Copyright 2014-2018
+ * Allwinner Technology Co., Ltd. <www.allwinnertech.com>
+ * huangxin <huangxin@allwinnertech.com>
+ * wolfgang huang <huangjinhui@allwinnertech.com>
+ * yumingfeng <yumingfeng@allwinnertech.com>
+ *
+ * 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 <linux/module.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/pm.h>
+#include <linux/pinctrl/consumer.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/dmaengine_pcm.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+#include <sound/initval.h>
+#include <sound/tlv.h>
+#include <linux/sunxi-gpio.h>
+#include <linux/dma/sunxi-dma.h>
+
+#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<<DAC_HUB_EN)) ? 2 : 1);
+ return 0;
+}
+
+static int sunxi_codec_set_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);
+
+ switch (ucontrol->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 << LINEOUTL_EN));
+ snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0,
+ (0x1 << LINEOUTR_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),
+ (0x0 << LINEOUTL_EN));
+ snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0,
+ (0x1 << LINEOUTR_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 << LINEOUTL_EN));
+ snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0,
+ (0x1 << LINEOUTR_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),
+ (0x0 << LINEOUTL_EN));
+ snd_soc_update_bits(codec, SUNXI_LINEOUT_CTL0,
+ (0x1 << LINEOUTR_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<<ADC_FIFO_FLUSH), (1<<ADC_FIFO_FLUSH));
+ regmap_write(sunxi_codec->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<<ADC_DRQ_EN), (1<<ADC_DRQ_EN));
+ sunxi_codec_map_i2s_global_enable(sunxi_codec, true);
+ 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);
+}
+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<<CTL_RXEN), (0<<CTL_RXEN));
+ regmap_update_bits(sunxi_daudio->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<<BRCK_POLARITY),
+ (SUNXI_DAUDIO_BCLK_POLARITY_NOR << BRCK_POLARITY));
+
+ regmap_update_bits(sunxi_daudio->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<Eourpean standard> or U-law<US-Japan> 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<<FIFO_MODE), (3<<FIFO_MODE));
+ snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL,
+ (1<<TX_SAMPLE_BITS), (0<<TX_SAMPLE_BITS));
+ } else {
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (1<<RX_FIFO_MODE), (1<<RX_FIFO_MODE));
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (1<<RX_SAMPLE_BITS), (0<<RX_SAMPLE_BITS));
+ }
+ break;
+ case SNDRV_PCM_FORMAT_S32_LE:
+ /* only for the compatible of tinyalsa */
+ case SNDRV_PCM_FORMAT_S24_LE:
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL,
+ (3<<FIFO_MODE), (0<<FIFO_MODE));
+ snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL,
+ (1<<TX_SAMPLE_BITS), (1<<TX_SAMPLE_BITS));
+ } else {
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (1<<RX_FIFO_MODE), (0<<RX_FIFO_MODE));
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (1<<RX_SAMPLE_BITS), (1<<RX_SAMPLE_BITS));
+ }
+ break;
+ default:
+ pr_err("[%s] params_format[%d] error!\n", __func__,
+ params_format(params));
+ return -EINVAL;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(sample_rate_conv); i++) {
+ if (sample_rate_conv[i].samplerate == params_rate(params)) {
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL,
+ (0x7<<DAC_FS),
+ (sample_rate_conv[i].rate_bit<<DAC_FS));
+ } else {
+ if (sample_rate_conv[i].samplerate > 48000)
+ return -EINVAL;
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (0x7<<ADC_FS),
+ (sample_rate_conv[i].rate_bit<<ADC_FS));
+ }
+ }
+ }
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ switch (params_channels(params)) {
+ case 1:
+ snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL,
+ (1<<DAC_MONO_EN), 1<<DAC_MONO_EN);
+ break;
+ case 2:
+ snd_soc_update_bits(codec, SUNXI_DAC_FIFO_CTL,
+ (1<<DAC_MONO_EN), (0<<DAC_MONO_EN));
+ break;
+ default:
+ pr_warn("[%s] cannot support the channels:%u.\n",
+ __func__, params_channels(params));
+ return -EINVAL;
+ }
+ } else {
+ switch (params_channels(params)) {
+ case 1:
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (0xf<<ADC_CHAN_SEL), (1<<ADC_CHAN_SEL));
+ break;
+ case 2:
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (0xf<<ADC_CHAN_SEL), (3<<ADC_CHAN_SEL));
+ break;
+ case 3:
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (0xf<<ADC_CHAN_SEL), (7<<ADC_CHAN_SEL));
+ break;
+ case 4:
+ snd_soc_update_bits(codec, SUNXI_ADC_FIFO_CTL,
+ (0xf<<ADC_CHAN_SEL), (0xf<<ADC_CHAN_SEL));
+ break;
+ default:
+ pr_warn("[%s] cannot support the channels:%u.\n",
+ __func__, params_channels(params));
+ return -EINVAL;
+ }
+ }
+
+#ifdef SUNXI_CODEC_MAP_TO_DAUDIO
+ if (sunxi_codec->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<<FIFO_FLUSH), (1<<FIFO_FLUSH));
+ snd_soc_write(codec, SUNXI_DAC_FIFO_STA,
+ (1 << DAC_TXE_INT | 1 << DAC_TXU_INT | 1 << DAC_TXO_INT));
+ snd_soc_write(codec, SUNXI_DAC_CNT, 0);
+ } else {
+#ifdef SUNXI_CODEC_MAP_TO_DAUDIO
+#ifdef CONFIG_SND_SUNXI_MAD
+ if (mad_priv->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<<ADC_FIFO_FLUSH), (1<<ADC_FIFO_FLUSH));
+ snd_soc_write(codec, SUNXI_ADC_FIFO_STA,
+ (1 << ADC_RXA_INT | 1 << ADC_RXO_INT));
+ snd_soc_write(codec, SUNXI_ADC_CNT, 0);
+#ifdef SUNXI_CODEC_MAP_TO_DAUDIO
+ sunxi_mad_codec_i2s_prepare(substream, dai);
+#ifdef CONFIG_SND_SUNXI_MAD
+ sunxi_codec->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<<DAC_DRQ_EN), (1<<DAC_DRQ_EN));
+ else {
+#ifdef SUNXI_CODEC_MAP_TO_DAUDIO
+#ifdef CONFIG_SND_SUNXI_MAD
+ if (mad_priv->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, &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 <huangjinhui@allwinnertech.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:sunxi-internal-codec");
View Git Blame Copy Permalink