0001: /*
0002: * This driver supports the analog controls for the internal codec
0003: * found in Allwinner's A31s, A23, A33 and H3 SoCs.
0004: *
0005: * Copyright 2016 Chen-Yu Tsai <wens@csie.org>
0006: *
0007: * This program is free software; you can redistribute it and/or modify
0008: * it under the terms of the GNU General Public License as published by
0009: * the Free Software Foundation; either version 2 of the License, or
0010: * (at your option) any later version.
0011: *
0012: * This program is distributed in the hope that it will be useful,
0013: * but WITHOUT ANY WARRANTY; without even the implied warranty of
0014: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
0015: * GNU General Public License for more details.
0016: */
0017:
0018: #include <linux/io.h>
0019: #include <linux/kernel.h>
0020: #include <linux/module.h>
0021: #include <linux/of.h>
0022: #include <linux/of_device.h>
0023: #include <linux/platform_device.h>
0024: #include <linux/regmap.h>
0025:
0026: #include <sound/soc.h>
0027: #include <sound/soc-dapm.h>
0028: #include <sound/tlv.h>
0029:
0030: #include <linux/gpio.h>
0031: #include <linux/gpio/consumer.h>
0032:
0033: #include "sun8i-adda-pr-regmap.h"
0034:
0035: /* Codec analog control register offsets and bit fields */
0036: #define SUN8I_ADDA_HP_VOLC 0x00
0037: #define SUN8I_ADDA_HP_VOLC_PA_CLK_GATE 7
0038: #define SUN8I_ADDA_HP_VOLC_HP_VOL 0
0039: #define SUN8I_ADDA_LOMIXSC 0x01
0040: #define SUN8I_ADDA_LOMIXSC_MIC1 6
0041: #define SUN8I_ADDA_LOMIXSC_MIC2 5
0042: #define SUN8I_ADDA_LOMIXSC_PHONE 4
0043: #define SUN8I_ADDA_LOMIXSC_PHONEN 3
0044: #define SUN8I_ADDA_LOMIXSC_LINEINL 2
0045: #define SUN8I_ADDA_LOMIXSC_DACL 1
0046: #define SUN8I_ADDA_LOMIXSC_DACR 0
0047: #define SUN8I_ADDA_ROMIXSC 0x02
0048: #define SUN8I_ADDA_ROMIXSC_MIC1 6
0049: #define SUN8I_ADDA_ROMIXSC_MIC2 5
0050: #define SUN8I_ADDA_ROMIXSC_PHONE 4
0051: #define SUN8I_ADDA_ROMIXSC_PHONEP 3
0052: #define SUN8I_ADDA_ROMIXSC_LINEINR 2
0053: #define SUN8I_ADDA_ROMIXSC_DACR 1
0054: #define SUN8I_ADDA_ROMIXSC_DACL 0
0055: #define SUN8I_ADDA_DAC_PA_SRC 0x03
0056: #define SUN8I_ADDA_DAC_PA_SRC_DACAREN 7
0057: #define SUN8I_ADDA_DAC_PA_SRC_DACALEN 6
0058: #define SUN8I_ADDA_DAC_PA_SRC_RMIXEN 5
0059: #define SUN8I_ADDA_DAC_PA_SRC_LMIXEN 4
0060: #define SUN8I_ADDA_DAC_PA_SRC_RHPPAMUTE 3
0061: #define SUN8I_ADDA_DAC_PA_SRC_LHPPAMUTE 2
0062: #define SUN8I_ADDA_DAC_PA_SRC_RHPIS 1
0063: #define SUN8I_ADDA_DAC_PA_SRC_LHPIS 0
0064: #define SUN8I_ADDA_PHONEIN_GCTRL 0x04
0065: #define SUN8I_ADDA_PHONEIN_GCTRL_PHONEPG 4
0066: #define SUN8I_ADDA_PHONEIN_GCTRL_PHONENG 0
0067: #define SUN8I_ADDA_LINEIN_GCTRL 0x05
0068: #define SUN8I_ADDA_LINEIN_GCTRL_LINEING 4
0069: #define SUN8I_ADDA_LINEIN_GCTRL_PHONEG 0
0070: #define SUN8I_ADDA_MICIN_GCTRL 0x06
0071: #define SUN8I_ADDA_MICIN_GCTRL_MIC1G 4
0072: #define SUN8I_ADDA_MICIN_GCTRL_MIC2G 0
0073: #define SUN8I_ADDA_PAEN_HP_CTRL 0x07
0074: #define SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN 7
0075: #define SUN8I_ADDA_PAEN_HP_CTRL_LINEOUTEN 7 /* H3 specific */
0076: #define SUN8I_ADDA_PAEN_HP_CTRL_HPCOM_FC 5
0077: #define SUN8I_ADDA_PAEN_HP_CTRL_COMPTEN 4
0078: #define SUN8I_ADDA_PAEN_HP_CTRL_PA_ANTI_POP_CTRL 2
0079: #define SUN8I_ADDA_PAEN_HP_CTRL_LTRNMUTE 1
0080: #define SUN8I_ADDA_PAEN_HP_CTRL_RTLNMUTE 0
0081: #define SUN8I_ADDA_PHONEOUT_CTRL 0x08
0082: #define SUN8I_ADDA_PHONEOUT_CTRL_PHONEOUTG 5
0083: #define SUN8I_ADDA_PHONEOUT_CTRL_PHONEOUTEN 4
0084: #define SUN8I_ADDA_PHONEOUT_CTRL_PHONEOUT_MIC1 3
0085: #define SUN8I_ADDA_PHONEOUT_CTRL_PHONEOUT_MIC2 2
0086: #define SUN8I_ADDA_PHONEOUT_CTRL_PHONEOUT_RMIX 1
0087: #define SUN8I_ADDA_PHONEOUT_CTRL_PHONEOUT_LMIX 0
0088: #define SUN8I_ADDA_PHONE_GAIN_CTRL 0x09
0089: #define SUN8I_ADDA_PHONE_GAIN_CTRL_LINEOUT_VOL 3
0090: #define SUN8I_ADDA_PHONE_GAIN_CTRL_PHONEPREG 0
0091: #define SUN8I_ADDA_MIC2G_CTRL 0x0a
0092: #define SUN8I_ADDA_MIC2G_CTRL_MIC2AMPEN 7
0093: #define SUN8I_ADDA_MIC2G_CTRL_MIC2BOOST 4
0094: #define SUN8I_ADDA_MIC2G_CTRL_LINEOUTLEN 3
0095: #define SUN8I_ADDA_MIC2G_CTRL_LINEOUTREN 2
0096: #define SUN8I_ADDA_MIC2G_CTRL_LINEOUTLSRC 1
0097: #define SUN8I_ADDA_MIC2G_CTRL_LINEOUTRSRC 0
0098: #define SUN8I_ADDA_MIC1G_MICBIAS_CTRL 0x0b
0099: #define SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIASEN 7
0100: #define SUN8I_ADDA_MIC1G_MICBIAS_CTRL_MMICBIASEN 6
0101: #define SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIAS_MODE 5
0102: #define SUN8I_ADDA_MIC1G_MICBIAS_CTRL_MIC1AMPEN 3
0103: #define SUN8I_ADDA_MIC1G_MICBIAS_CTRL_MIC1BOOST 0
0104: #define SUN8I_ADDA_LADCMIXSC 0x0c
0105: #define SUN8I_ADDA_LADCMIXSC_MIC1 6
0106: #define SUN8I_ADDA_LADCMIXSC_MIC2 5
0107: #define SUN8I_ADDA_LADCMIXSC_PHONE 4
0108: #define SUN8I_ADDA_LADCMIXSC_PHONEN 3
0109: #define SUN8I_ADDA_LADCMIXSC_LINEINL 2
0110: #define SUN8I_ADDA_LADCMIXSC_OMIXRL 1
0111: #define SUN8I_ADDA_LADCMIXSC_OMIXRR 0
0112: #define SUN8I_ADDA_RADCMIXSC 0x0d
0113: #define SUN8I_ADDA_RADCMIXSC_MIC1 6
0114: #define SUN8I_ADDA_RADCMIXSC_MIC2 5
0115: #define SUN8I_ADDA_RADCMIXSC_PHONE 4
0116: #define SUN8I_ADDA_RADCMIXSC_PHONEP 3
0117: #define SUN8I_ADDA_RADCMIXSC_LINEINR 2
0118: #define SUN8I_ADDA_RADCMIXSC_OMIXR 1
0119: #define SUN8I_ADDA_RADCMIXSC_OMIXL 0
0120: #define SUN8I_ADDA_RES 0x0e
0121: #define SUN8I_ADDA_RES_MMICBIAS_SEL 4
0122: #define SUN8I_ADDA_RES_PA_ANTI_POP_CTRL 0
0123: #define SUN8I_ADDA_ADC_AP_EN 0x0f
0124: #define SUN8I_ADDA_ADC_AP_EN_ADCREN 7
0125: #define SUN8I_ADDA_ADC_AP_EN_ADCLEN 6
0126: #define SUN8I_ADDA_ADC_AP_EN_ADCG 0
0127:
0128: /* mixer controls */
0129: static const struct snd_kcontrol_new sun8i_codec_mixer_controls[] = {
0130: SOC_DAPM_DOUBLE_R("DAC Playback Switch",
0131: SUN8I_ADDA_LOMIXSC,
0132: SUN8I_ADDA_ROMIXSC,
0133: SUN8I_ADDA_LOMIXSC_DACL, 1, 0),
0134: SOC_DAPM_DOUBLE_R("DAC Reversed Playback Switch",
0135: SUN8I_ADDA_LOMIXSC,
0136: SUN8I_ADDA_ROMIXSC,
0137: SUN8I_ADDA_LOMIXSC_DACR, 1, 0),
0138: SOC_DAPM_DOUBLE_R("Line In Playback Switch",
0139: SUN8I_ADDA_LOMIXSC,
0140: SUN8I_ADDA_ROMIXSC,
0141: SUN8I_ADDA_LOMIXSC_LINEINL, 1, 0),
0142: SOC_DAPM_DOUBLE_R("Mic1 Playback Switch",
0143: SUN8I_ADDA_LOMIXSC,
0144: SUN8I_ADDA_ROMIXSC,
0145: SUN8I_ADDA_LOMIXSC_MIC1, 1, 0),
0146: SOC_DAPM_DOUBLE_R("Mic2 Playback Switch",
0147: SUN8I_ADDA_LOMIXSC,
0148: SUN8I_ADDA_ROMIXSC,
0149: SUN8I_ADDA_LOMIXSC_MIC2, 1, 0),
0150: };
0151:
0152: /* mixer controls */
0153: static const struct snd_kcontrol_new sun8i_v3s_codec_mixer_controls[] = {
0154: SOC_DAPM_DOUBLE_R("DAC Playback Switch",
0155: SUN8I_ADDA_LOMIXSC,
0156: SUN8I_ADDA_ROMIXSC,
0157: SUN8I_ADDA_LOMIXSC_DACL, 1, 0),
0158: SOC_DAPM_DOUBLE_R("DAC Reversed Playback Switch",
0159: SUN8I_ADDA_LOMIXSC,
0160: SUN8I_ADDA_ROMIXSC,
0161: SUN8I_ADDA_LOMIXSC_DACR, 1, 0),
0162: SOC_DAPM_DOUBLE_R("Mic1 Playback Switch",
0163: SUN8I_ADDA_LOMIXSC,
0164: SUN8I_ADDA_ROMIXSC,
0165: SUN8I_ADDA_LOMIXSC_MIC1, 1, 0),
0166: };
0167:
0168: /* ADC mixer controls */
0169: static const struct snd_kcontrol_new sun8i_codec_adc_mixer_controls[] = {
0170: SOC_DAPM_DOUBLE_R("Mixer Capture Switch",
0171: SUN8I_ADDA_LADCMIXSC,
0172: SUN8I_ADDA_RADCMIXSC,
0173: SUN8I_ADDA_LADCMIXSC_OMIXRL, 1, 0),
0174: SOC_DAPM_DOUBLE_R("Mixer Reversed Capture Switch",
0175: SUN8I_ADDA_LADCMIXSC,
0176: SUN8I_ADDA_RADCMIXSC,
0177: SUN8I_ADDA_LADCMIXSC_OMIXRR, 1, 0),
0178: SOC_DAPM_DOUBLE_R("Line In Capture Switch",
0179: SUN8I_ADDA_LADCMIXSC,
0180: SUN8I_ADDA_RADCMIXSC,
0181: SUN8I_ADDA_LADCMIXSC_LINEINL, 1, 0),
0182: SOC_DAPM_DOUBLE_R("Mic1 Capture Switch",
0183: SUN8I_ADDA_LADCMIXSC,
0184: SUN8I_ADDA_RADCMIXSC,
0185: SUN8I_ADDA_LADCMIXSC_MIC1, 1, 0),
0186: SOC_DAPM_DOUBLE_R("Mic2 Capture Switch",
0187: SUN8I_ADDA_LADCMIXSC,
0188: SUN8I_ADDA_RADCMIXSC,
0189: SUN8I_ADDA_LADCMIXSC_MIC2, 1, 0),
0190: };
0191:
0192: /* ADC mixer controls */
0193: static const struct snd_kcontrol_new sun8i_v3s_codec_adc_mixer_controls[] = {
0194: SOC_DAPM_DOUBLE_R("Mixer Capture Switch",
0195: SUN8I_ADDA_LADCMIXSC,
0196: SUN8I_ADDA_RADCMIXSC,
0197: SUN8I_ADDA_LADCMIXSC_OMIXRL, 1, 0),
0198: SOC_DAPM_DOUBLE_R("Mixer Reversed Capture Switch",
0199: SUN8I_ADDA_LADCMIXSC,
0200: SUN8I_ADDA_RADCMIXSC,
0201: SUN8I_ADDA_LADCMIXSC_OMIXRR, 1, 0),
0202: SOC_DAPM_DOUBLE_R("Mic1 Capture Switch",
0203: SUN8I_ADDA_LADCMIXSC,
0204: SUN8I_ADDA_RADCMIXSC,
0205: SUN8I_ADDA_LADCMIXSC_MIC1, 1, 0),
0206: };
0207:
0208: /* volume / mute controls */
0209: static const DECLARE_TLV_DB_SCALE(sun8i_codec_out_mixer_pregain_scale,
0210: -450, 150, 0);
0211: static const DECLARE_TLV_DB_RANGE(sun8i_codec_mic_gain_scale,
0212: 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
0213: 1, 7, TLV_DB_SCALE_ITEM(2400, 300, 0),
0214: );
0215:
0216: static const struct snd_kcontrol_new sun8i_codec_common_controls[] = {
0217: /* Mixer pre-gain */
0218: SOC_SINGLE_TLV("Mic1 Playback Volume", SUN8I_ADDA_MICIN_GCTRL,
0219: SUN8I_ADDA_MICIN_GCTRL_MIC1G,
0220: 0x7, 0, sun8i_codec_out_mixer_pregain_scale),
0221:
0222: /* Microphone Amp boost gain */
0223: SOC_SINGLE_TLV("Mic1 Boost Volume", SUN8I_ADDA_MIC1G_MICBIAS_CTRL,
0224: SUN8I_ADDA_MIC1G_MICBIAS_CTRL_MIC1BOOST, 0x7, 0,
0225: sun8i_codec_mic_gain_scale),
0226:
0227: /* ADC */
0228: SOC_SINGLE_TLV("ADC Gain Capture Volume", SUN8I_ADDA_ADC_AP_EN,
0229: SUN8I_ADDA_ADC_AP_EN_ADCG, 0x7, 0,
0230: sun8i_codec_out_mixer_pregain_scale),
0231: };
0232:
0233: static const struct snd_soc_dapm_widget sun8i_codec_common_widgets[] = {
0234: /* ADC */
0235: SND_SOC_DAPM_ADC("Left ADC", NULL, SUN8I_ADDA_ADC_AP_EN,
0236: SUN8I_ADDA_ADC_AP_EN_ADCLEN, 0),
0237: SND_SOC_DAPM_ADC("Right ADC", NULL, SUN8I_ADDA_ADC_AP_EN,
0238: SUN8I_ADDA_ADC_AP_EN_ADCREN, 0),
0239:
0240: /* DAC */
0241: SND_SOC_DAPM_DAC("Left DAC", NULL, SUN8I_ADDA_DAC_PA_SRC,
0242: SUN8I_ADDA_DAC_PA_SRC_DACALEN, 0),
0243: SND_SOC_DAPM_DAC("Right DAC", NULL, SUN8I_ADDA_DAC_PA_SRC,
0244: SUN8I_ADDA_DAC_PA_SRC_DACAREN, 0),
0245: /*
0246: * Due to this component and the codec belonging to separate DAPM
0247: * contexts, we need to manually link the above widgets to their
0248: * stream widgets at the card level.
0249: */
0250:
0251: /* Microphone input */
0252: SND_SOC_DAPM_INPUT("MIC1"),
0253:
0254: /* Mic input path */
0255: SND_SOC_DAPM_PGA("Mic1 Amplifier", SUN8I_ADDA_MIC1G_MICBIAS_CTRL,
0256: SUN8I_ADDA_MIC1G_MICBIAS_CTRL_MIC1AMPEN, 0, NULL, 0),
0257: };
0258:
0259: static const struct snd_soc_dapm_widget sun8i_codec_mixer_widgets[] = {
0260: SND_SOC_DAPM_MIXER("Left Mixer", SUN8I_ADDA_DAC_PA_SRC,
0261: SUN8I_ADDA_DAC_PA_SRC_LMIXEN, 0,
0262: sun8i_codec_mixer_controls,
0263: ARRAY_SIZE(sun8i_codec_mixer_controls)),
0264: SND_SOC_DAPM_MIXER("Right Mixer", SUN8I_ADDA_DAC_PA_SRC,
0265: SUN8I_ADDA_DAC_PA_SRC_RMIXEN, 0,
0266: sun8i_codec_mixer_controls,
0267: ARRAY_SIZE(sun8i_codec_mixer_controls)),
0268: SND_SOC_DAPM_MIXER("Left ADC Mixer", SUN8I_ADDA_ADC_AP_EN,
0269: SUN8I_ADDA_ADC_AP_EN_ADCLEN, 0,
0270: sun8i_codec_adc_mixer_controls,
0271: ARRAY_SIZE(sun8i_codec_adc_mixer_controls)),
0272: SND_SOC_DAPM_MIXER("Right ADC Mixer", SUN8I_ADDA_ADC_AP_EN,
0273: SUN8I_ADDA_ADC_AP_EN_ADCREN, 0,
0274: sun8i_codec_adc_mixer_controls,
0275: ARRAY_SIZE(sun8i_codec_adc_mixer_controls)),
0276: };
0277:
0278: static const struct snd_soc_dapm_widget sun8i_v3s_codec_mixer_widgets[] = {
0279: SND_SOC_DAPM_MIXER("Left Mixer", SUN8I_ADDA_DAC_PA_SRC,
0280: SUN8I_ADDA_DAC_PA_SRC_LMIXEN, 0,
0281: sun8i_v3s_codec_mixer_controls,
0282: ARRAY_SIZE(sun8i_v3s_codec_mixer_controls)),
0283: SND_SOC_DAPM_MIXER("Right Mixer", SUN8I_ADDA_DAC_PA_SRC,
0284: SUN8I_ADDA_DAC_PA_SRC_RMIXEN, 0,
0285: sun8i_v3s_codec_mixer_controls,
0286: ARRAY_SIZE(sun8i_v3s_codec_mixer_controls)),
0287: SND_SOC_DAPM_MIXER("Left ADC Mixer", SUN8I_ADDA_ADC_AP_EN,
0288: SUN8I_ADDA_ADC_AP_EN_ADCLEN, 0,
0289: sun8i_v3s_codec_adc_mixer_controls,
0290: ARRAY_SIZE(sun8i_v3s_codec_adc_mixer_controls)),
0291: SND_SOC_DAPM_MIXER("Right ADC Mixer", SUN8I_ADDA_ADC_AP_EN,
0292: SUN8I_ADDA_ADC_AP_EN_ADCREN, 0,
0293: sun8i_v3s_codec_adc_mixer_controls,
0294: ARRAY_SIZE(sun8i_v3s_codec_adc_mixer_controls)),
0295: };
0296:
0297: static const struct snd_soc_dapm_route sun8i_codec_common_routes[] = {
0298: /* Microphone Routes */
0299: { "Mic1 Amplifier", NULL, "MIC1"},
0300: };
0301:
0302: static const struct snd_soc_dapm_route sun8i_codec_mixer_routes[] = {
0303: /* Left Mixer Routes */
0304: { "Left Mixer", "DAC Playback Switch", "Left DAC" },
0305: { "Left Mixer", "DAC Reversed Playback Switch", "Right DAC" },
0306: { "Left Mixer", "Mic1 Playback Switch", "Mic1 Amplifier" },
0307:
0308: /* Right Mixer Routes */
0309: { "Right Mixer", "DAC Playback Switch", "Right DAC" },
0310: { "Right Mixer", "DAC Reversed Playback Switch", "Left DAC" },
0311: { "Right Mixer", "Mic1 Playback Switch", "Mic1 Amplifier" },
0312:
0313: /* Left ADC Mixer Routes */
0314: { "Left ADC Mixer", "Mixer Capture Switch", "Left Mixer" },
0315: { "Left ADC Mixer", "Mixer Reversed Capture Switch", "Right Mixer" },
0316: { "Left ADC Mixer", "Mic1 Capture Switch", "Mic1 Amplifier" },
0317:
0318: /* Right ADC Mixer Routes */
0319: { "Right ADC Mixer", "Mixer Capture Switch", "Right Mixer" },
0320: { "Right ADC Mixer", "Mixer Reversed Capture Switch", "Left Mixer" },
0321: { "Right ADC Mixer", "Mic1 Capture Switch", "Mic1 Amplifier" },
0322:
0323: /* ADC Routes */
0324: { "Left ADC", NULL, "Left ADC Mixer" },
0325: { "Right ADC", NULL, "Right ADC Mixer" },
0326: };
0327:
0328: /* headphone specific controls, widgets, and routes */
0329: static const DECLARE_TLV_DB_SCALE(sun8i_codec_hp_vol_scale, -6300, 100, 1);
0330: static const struct snd_kcontrol_new sun8i_codec_headphone_controls[] = {
0331: SOC_SINGLE_TLV("Master Playback Volume",
0332: SUN8I_ADDA_HP_VOLC,
0333: SUN8I_ADDA_HP_VOLC_HP_VOL, 0x3f, 0,
0334: sun8i_codec_hp_vol_scale),
0335: SOC_DOUBLE("Headphone Playback Switch",
0336: SUN8I_ADDA_DAC_PA_SRC,
0337: SUN8I_ADDA_DAC_PA_SRC_LHPPAMUTE,
0338: SUN8I_ADDA_DAC_PA_SRC_RHPPAMUTE, 1, 0),
0339: };
0340:
0341: static const char * const sun8i_codec_hp_src_enum_text[] = {
0342: "DAC", "Mixer",
0343: };
0344:
0345: static SOC_ENUM_DOUBLE_DECL(sun8i_codec_hp_src_enum,
0346: SUN8I_ADDA_DAC_PA_SRC,
0347: SUN8I_ADDA_DAC_PA_SRC_LHPIS,
0348: SUN8I_ADDA_DAC_PA_SRC_RHPIS,
0349: sun8i_codec_hp_src_enum_text);
0350:
0351: static const struct snd_kcontrol_new sun8i_codec_hp_src[] = {
0352: SOC_DAPM_ENUM("Headphone Source Playback Route",
0353: sun8i_codec_hp_src_enum),
0354: };
0355:
0356: static int sun8i_headphone_amp_event(struct snd_soc_dapm_widget *w,
0357: struct snd_kcontrol *k, int event)
0358: {
0359: struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0360:
0361: if (SND_SOC_DAPM_EVENT_ON(event)) {
0362: snd_soc_component_update_bits(component, SUN8I_ADDA_PAEN_HP_CTRL,
0363: BIT(SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN),
0364: BIT(SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN));
0365: /*
0366: * Need a delay to have the amplifier up. 700ms seems the best
0367: * compromise between the time to let the amplifier up and the
0368: * time not to feel this delay while playing a sound.
0369: */
0370: msleep(700);
0371: } else if (SND_SOC_DAPM_EVENT_OFF(event)) {
0372: snd_soc_component_update_bits(component, SUN8I_ADDA_PAEN_HP_CTRL,
0373: BIT(SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN),
0374: 0x0);
0375: }
0376:
0377: return 0;
0378: }
0379:
0380: static const struct snd_soc_dapm_widget sun8i_codec_headphone_widgets[] = {
0381: SND_SOC_DAPM_MUX("Headphone Source Playback Route",
0382: SND_SOC_NOPM, 0, 0, sun8i_codec_hp_src),
0383: SND_SOC_DAPM_OUT_DRV_E("Headphone Amp", SUN8I_ADDA_PAEN_HP_CTRL,
0384: SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN, 0, NULL, 0,
0385: sun8i_headphone_amp_event,
0386: SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD),
0387: SND_SOC_DAPM_SUPPLY("HPCOM Protection", SUN8I_ADDA_PAEN_HP_CTRL,
0388: SUN8I_ADDA_PAEN_HP_CTRL_COMPTEN, 0, NULL, 0),
0389: SND_SOC_DAPM_REG(snd_soc_dapm_supply, "HPCOM", SUN8I_ADDA_PAEN_HP_CTRL,
0390: SUN8I_ADDA_PAEN_HP_CTRL_HPCOM_FC, 0x3, 0x3, 0),
0391: SND_SOC_DAPM_OUTPUT("HP"),
0392: };
0393:
0394: static const struct snd_soc_dapm_route sun8i_codec_headphone_routes[] = {
0395: { "Headphone Source Playback Route", "DAC", "Left DAC" },
0396: { "Headphone Source Playback Route", "DAC", "Right DAC" },
0397: { "Headphone Source Playback Route", "Mixer", "Left Mixer" },
0398: { "Headphone Source Playback Route", "Mixer", "Right Mixer" },
0399: { "Headphone Amp", NULL, "Headphone Source Playback Route" },
0400: { "HPCOM", NULL, "HPCOM Protection" },
0401: { "HP", NULL, "Headphone Amp" },
0402: };
0403:
0404: static int sun8i_codec_add_headphone(struct snd_soc_component *cmpnt)
0405: {
0406: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0407: struct device *dev = cmpnt->dev;
0408: int ret;
0409:
0410: ret = snd_soc_add_component_controls(cmpnt,
0411: sun8i_codec_headphone_controls,
0412: ARRAY_SIZE(sun8i_codec_headphone_controls));
0413: if (ret) {
0414: dev_err(dev, "Failed to add Headphone controls: %d\n", ret);
0415: return ret;
0416: }
0417:
0418: ret = snd_soc_dapm_new_controls(dapm, sun8i_codec_headphone_widgets,
0419: ARRAY_SIZE(sun8i_codec_headphone_widgets));
0420: if (ret) {
0421: dev_err(dev, "Failed to add Headphone DAPM widgets: %d\n", ret);
0422: return ret;
0423: }
0424:
0425: ret = snd_soc_dapm_add_routes(dapm, sun8i_codec_headphone_routes,
0426: ARRAY_SIZE(sun8i_codec_headphone_routes));
0427: if (ret) {
0428: dev_err(dev, "Failed to add Headphone DAPM routes: %d\n", ret);
0429: return ret;
0430: }
0431:
0432: return 0;
0433: }
0434:
0435: /* mbias specific widget */
0436: static const struct snd_soc_dapm_widget sun8i_codec_mbias_widgets[] = {
0437: SND_SOC_DAPM_SUPPLY("MBIAS", SUN8I_ADDA_MIC1G_MICBIAS_CTRL,
0438: SUN8I_ADDA_MIC1G_MICBIAS_CTRL_MMICBIASEN,
0439: 0, NULL, 0),
0440: };
0441:
0442: static int sun8i_codec_add_mbias(struct snd_soc_component *cmpnt)
0443: {
0444: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0445: struct device *dev = cmpnt->dev;
0446: int ret;
0447:
0448: ret = snd_soc_dapm_new_controls(dapm, sun8i_codec_mbias_widgets,
0449: ARRAY_SIZE(sun8i_codec_mbias_widgets));
0450: if (ret)
0451: dev_err(dev, "Failed to add MBIAS DAPM widgets: %d\n", ret);
0452:
0453: return ret;
0454: }
0455:
0456: /* hmic specific widget */
0457: static const struct snd_soc_dapm_widget sun8i_codec_hmic_widgets[] = {
0458: SND_SOC_DAPM_SUPPLY("HBIAS", SUN8I_ADDA_MIC1G_MICBIAS_CTRL,
0459: SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIASEN,
0460: 0, NULL, 0),
0461: };
0462:
0463: static int sun8i_codec_add_hmic(struct snd_soc_component *cmpnt)
0464: {
0465: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0466: struct device *dev = cmpnt->dev;
0467: int ret;
0468:
0469: ret = snd_soc_dapm_new_controls(dapm, sun8i_codec_hmic_widgets,
0470: ARRAY_SIZE(sun8i_codec_hmic_widgets));
0471: if (ret)
0472: dev_err(dev, "Failed to add Mic3 DAPM widgets: %d\n", ret);
0473:
0474: return ret;
0475: }
0476:
0477: /* line in specific controls, widgets and rines */
0478: static const struct snd_kcontrol_new sun8i_codec_linein_controls[] = {
0479: /* Mixer pre-gain */
0480: SOC_SINGLE_TLV("Line In Playback Volume", SUN8I_ADDA_LINEIN_GCTRL,
0481: SUN8I_ADDA_LINEIN_GCTRL_LINEING,
0482: 0x7, 0, sun8i_codec_out_mixer_pregain_scale),
0483: };
0484:
0485: static const struct snd_soc_dapm_widget sun8i_codec_linein_widgets[] = {
0486: /* Line input */
0487: SND_SOC_DAPM_INPUT("LINEIN"),
0488: };
0489:
0490: static const struct snd_soc_dapm_route sun8i_codec_linein_routes[] = {
0491: { "Left Mixer", "Line In Playback Switch", "LINEIN" },
0492:
0493: { "Right Mixer", "Line In Playback Switch", "LINEIN" },
0494:
0495: { "Left ADC Mixer", "Line In Capture Switch", "LINEIN" },
0496:
0497: { "Right ADC Mixer", "Line In Capture Switch", "LINEIN" },
0498: };
0499:
0500: static int sun8i_codec_add_linein(struct snd_soc_component *cmpnt)
0501: {
0502: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0503: struct device *dev = cmpnt->dev;
0504: int ret;
0505:
0506: ret = snd_soc_add_component_controls(cmpnt,
0507: sun8i_codec_linein_controls,
0508: ARRAY_SIZE(sun8i_codec_linein_controls));
0509: if (ret) {
0510: dev_err(dev, "Failed to add Line In controls: %d\n", ret);
0511: return ret;
0512: }
0513:
0514: ret = snd_soc_dapm_new_controls(dapm, sun8i_codec_linein_widgets,
0515: ARRAY_SIZE(sun8i_codec_linein_widgets));
0516: if (ret) {
0517: dev_err(dev, "Failed to add Line In DAPM widgets: %d\n", ret);
0518: return ret;
0519: }
0520:
0521: ret = snd_soc_dapm_add_routes(dapm, sun8i_codec_linein_routes,
0522: ARRAY_SIZE(sun8i_codec_linein_routes));
0523: if (ret) {
0524: dev_err(dev, "Failed to add Line In DAPM routes: %d\n", ret);
0525: return ret;
0526: }
0527:
0528: return 0;
0529: }
0530:
0531:
0532: /* line out specific controls, widgets and routes */
0533: static const DECLARE_TLV_DB_RANGE(sun8i_codec_lineout_vol_scale,
0534: 0, 1, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 1),
0535: 2, 31, TLV_DB_SCALE_ITEM(-4350, 150, 0),
0536: );
0537: static const struct snd_kcontrol_new sun8i_codec_lineout_controls[] = {
0538: SOC_SINGLE_TLV("Line Out Playback Volume",
0539: SUN8I_ADDA_PHONE_GAIN_CTRL,
0540: SUN8I_ADDA_PHONE_GAIN_CTRL_LINEOUT_VOL, 0x1f, 0,
0541: sun8i_codec_lineout_vol_scale),
0542: SOC_DOUBLE("Line Out Playback Switch",
0543: SUN8I_ADDA_MIC2G_CTRL,
0544: SUN8I_ADDA_MIC2G_CTRL_LINEOUTLEN,
0545: SUN8I_ADDA_MIC2G_CTRL_LINEOUTREN, 1, 0),
0546: };
0547:
0548: static const char * const sun8i_codec_lineout_src_enum_text[] = {
0549: "Stereo", "Mono Differential",
0550: };
0551:
0552: static SOC_ENUM_DOUBLE_DECL(sun8i_codec_lineout_src_enum,
0553: SUN8I_ADDA_MIC2G_CTRL,
0554: SUN8I_ADDA_MIC2G_CTRL_LINEOUTLSRC,
0555: SUN8I_ADDA_MIC2G_CTRL_LINEOUTRSRC,
0556: sun8i_codec_lineout_src_enum_text);
0557:
0558: static const struct snd_kcontrol_new sun8i_codec_lineout_src[] = {
0559: SOC_DAPM_ENUM("Line Out Source Playback Route",
0560: sun8i_codec_lineout_src_enum),
0561: };
0562:
0563: static const struct snd_soc_dapm_widget sun8i_codec_lineout_widgets[] = {
0564: SND_SOC_DAPM_MUX("Line Out Source Playback Route",
0565: SND_SOC_NOPM, 0, 0, sun8i_codec_lineout_src),
0566: /* It is unclear if this is a buffer or gate, model it as a supply */
0567: SND_SOC_DAPM_SUPPLY("Line Out Enable", SUN8I_ADDA_PAEN_HP_CTRL,
0568: SUN8I_ADDA_PAEN_HP_CTRL_LINEOUTEN, 0, NULL, 0),
0569: SND_SOC_DAPM_OUTPUT("LINEOUT"),
0570: };
0571:
0572: static const struct snd_soc_dapm_route sun8i_codec_lineout_routes[] = {
0573: { "Line Out Source Playback Route", "Stereo", "Left Mixer" },
0574: { "Line Out Source Playback Route", "Stereo", "Right Mixer" },
0575: { "Line Out Source Playback Route", "Mono Differential", "Left Mixer" },
0576: { "Line Out Source Playback Route", "Mono Differential", "Right Mixer" },
0577: { "LINEOUT", NULL, "Line Out Source Playback Route" },
0578: { "LINEOUT", NULL, "Line Out Enable", },
0579: };
0580:
0581: static int sun8i_codec_add_lineout(struct snd_soc_component *cmpnt)
0582: {
0583: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0584: struct device *dev = cmpnt->dev;
0585: int ret;
0586:
0587: ret = snd_soc_add_component_controls(cmpnt,
0588: sun8i_codec_lineout_controls,
0589: ARRAY_SIZE(sun8i_codec_lineout_controls));
0590: if (ret) {
0591: dev_err(dev, "Failed to add Line Out controls: %d\n", ret);
0592: return ret;
0593: }
0594:
0595: ret = snd_soc_dapm_new_controls(dapm, sun8i_codec_lineout_widgets,
0596: ARRAY_SIZE(sun8i_codec_lineout_widgets));
0597: if (ret) {
0598: dev_err(dev, "Failed to add Line Out DAPM widgets: %d\n", ret);
0599: return ret;
0600: }
0601:
0602: ret = snd_soc_dapm_add_routes(dapm, sun8i_codec_lineout_routes,
0603: ARRAY_SIZE(sun8i_codec_lineout_routes));
0604: if (ret) {
0605: dev_err(dev, "Failed to add Line Out DAPM routes: %d\n", ret);
0606: return ret;
0607: }
0608:
0609: return 0;
0610: }
0611:
0612: /* mic2 specific controls, widgets and routes */
0613: static const struct snd_kcontrol_new sun8i_codec_mic2_controls[] = {
0614: /* Mixer pre-gain */
0615: SOC_SINGLE_TLV("Mic2 Playback Volume",
0616: SUN8I_ADDA_MICIN_GCTRL, SUN8I_ADDA_MICIN_GCTRL_MIC2G,
0617: 0x7, 0, sun8i_codec_out_mixer_pregain_scale),
0618:
0619: /* Microphone Amp boost gain */
0620: SOC_SINGLE_TLV("Mic2 Boost Volume", SUN8I_ADDA_MIC2G_CTRL,
0621: SUN8I_ADDA_MIC2G_CTRL_MIC2BOOST, 0x7, 0,
0622: sun8i_codec_mic_gain_scale),
0623: };
0624:
0625: static const struct snd_soc_dapm_widget sun8i_codec_mic2_widgets[] = {
0626: /* Microphone input */
0627: SND_SOC_DAPM_INPUT("MIC2"),
0628:
0629: /* Mic input path */
0630: SND_SOC_DAPM_PGA("Mic2 Amplifier", SUN8I_ADDA_MIC2G_CTRL,
0631: SUN8I_ADDA_MIC2G_CTRL_MIC2AMPEN, 0, NULL, 0),
0632: };
0633:
0634: static const struct snd_soc_dapm_route sun8i_codec_mic2_routes[] = {
0635: { "Mic2 Amplifier", NULL, "MIC2"},
0636:
0637: { "Left Mixer", "Mic2 Playback Switch", "Mic2 Amplifier" },
0638:
0639: { "Right Mixer", "Mic2 Playback Switch", "Mic2 Amplifier" },
0640:
0641: { "Left ADC Mixer", "Mic2 Capture Switch", "Mic2 Amplifier" },
0642:
0643: { "Right ADC Mixer", "Mic2 Capture Switch", "Mic2 Amplifier" },
0644: };
0645:
0646: static int sun8i_codec_add_mic2(struct snd_soc_component *cmpnt)
0647: {
0648: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0649: struct device *dev = cmpnt->dev;
0650: int ret;
0651:
0652: ret = snd_soc_add_component_controls(cmpnt,
0653: sun8i_codec_mic2_controls,
0654: ARRAY_SIZE(sun8i_codec_mic2_controls));
0655: if (ret) {
0656: dev_err(dev, "Failed to add MIC2 controls: %d\n", ret);
0657: return ret;
0658: }
0659:
0660: ret = snd_soc_dapm_new_controls(dapm, sun8i_codec_mic2_widgets,
0661: ARRAY_SIZE(sun8i_codec_mic2_widgets));
0662: if (ret) {
0663: dev_err(dev, "Failed to add MIC2 DAPM widgets: %d\n", ret);
0664: return ret;
0665: }
0666:
0667: ret = snd_soc_dapm_add_routes(dapm, sun8i_codec_mic2_routes,
0668: ARRAY_SIZE(sun8i_codec_mic2_routes));
0669: if (ret) {
0670: dev_err(dev, "Failed to add MIC2 DAPM routes: %d\n", ret);
0671: return ret;
0672: }
0673:
0674: return 0;
0675: }
0676:
0677: struct sun8i_codec_analog_quirks {
0678: bool has_headphone;
0679: bool has_hmic;
0680: bool has_linein;
0681: bool has_lineout;
0682: bool has_mbias;
0683: bool has_mic2;
0684: };
0685:
0686: static const struct sun8i_codec_analog_quirks sun8i_a23_quirks = {
0687: .has_headphone = true,
0688: //.has_hmic = true,
0689: .has_linein = true,
0690: .has_mbias = true,
0691: .has_mic2 = true,
0692: };
0693:
0694: static const struct sun8i_codec_analog_quirks sun8i_h3_quirks = {
0695: .has_linein = true,
0696: .has_lineout = true,
0697: .has_mbias = true,
0698: .has_mic2 = true,
0699: };
0700:
0701: static int sun8i_codec_analog_add_mixer(struct snd_soc_component *cmpnt,
0702: const struct sun8i_codec_analog_quirks *quirks)
0703: {
0704: struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cmpnt);
0705: struct device *dev = cmpnt->dev;
0706: int ret;
0707:
0708: if (!quirks->has_mic2 && !quirks->has_linein) {
0709: /*
0710: * Apply the special widget set which has uses a control
0711: * without MIC2 and Line In, for SoCs without these.
0712: * TODO: not all special cases are supported now, this case
0713: * is present because it's the case of V3s.
0714: */
0715: ret = snd_soc_dapm_new_controls(dapm,
0716: sun8i_v3s_codec_mixer_widgets,
0717: ARRAY_SIZE(sun8i_v3s_codec_mixer_widgets));
0718: if (ret) {
0719: dev_err(dev, "Failed to add V3s Mixer DAPM widgets: %d\n", ret);
0720: return ret;
0721: }
0722: } else {
0723: /* Apply the generic mixer widget set. */
0724: ret = snd_soc_dapm_new_controls(dapm,
0725: sun8i_codec_mixer_widgets,
0726: ARRAY_SIZE(sun8i_codec_mixer_widgets));
0727: if (ret) {
0728: dev_err(dev, "Failed to add Mixer DAPM widgets: %d\n", ret);
0729: return ret;
0730: }
0731: }
0732:
0733: ret = snd_soc_dapm_add_routes(dapm, sun8i_codec_mixer_routes,
0734: ARRAY_SIZE(sun8i_codec_mixer_routes));
0735: if (ret) {
0736: dev_err(dev, "Failed to add Mixer DAPM routes: %d\n", ret);
0737: return ret;
0738: }
0739:
0740: return 0;
0741: }
0742:
0743: static const struct sun8i_codec_analog_quirks sun8i_v3s_quirks = {
0744: .has_headphone = true,
0745: .has_hmic = true,
0746: };
0747:
0748: static int sun8i_codec_analog_cmpnt_probe(struct snd_soc_component *cmpnt)
0749: {
0750: struct device *dev = cmpnt->dev;
0751: const struct sun8i_codec_analog_quirks *quirks;
0752: int ret;
0753:
0754: /*
0755: * This would never return NULL unless someone directly registers a
0756: * platform device matching this driver's name, without specifying a
0757: * device tree node.
0758: */
0759: quirks = of_device_get_match_data(dev);
0760:
0761: /* Add controls, widgets, and routes for individual features */
0762: ret = sun8i_codec_analog_add_mixer(cmpnt, quirks);
0763: if (ret)
0764: return ret;
0765:
0766: if (quirks->has_headphone) {
0767: ret = sun8i_codec_add_headphone(cmpnt);
0768: if (ret)
0769: return ret;
0770: }
0771:
0772: if (quirks->has_hmic) {
0773: ret = sun8i_codec_add_hmic(cmpnt);
0774: if (ret)
0775: return ret;
0776: }
0777:
0778: if (quirks->has_linein) {
0779: ret = sun8i_codec_add_linein(cmpnt);
0780: if (ret)
0781: return ret;
0782: }
0783:
0784: if (quirks->has_lineout) {
0785: ret = sun8i_codec_add_lineout(cmpnt);
0786: if (ret)
0787: return ret;
0788: }
0789:
0790: if (quirks->has_mbias) {
0791: ret = sun8i_codec_add_mbias(cmpnt);
0792: if (ret)
0793: return ret;
0794: }
0795:
0796: if (quirks->has_mic2) {
0797: ret = sun8i_codec_add_mic2(cmpnt);
0798: if (ret)
0799: return ret;
0800: }
0801:
0802: return 0;
0803: }
0804:
0805: static const struct snd_soc_component_driver sun8i_codec_analog_cmpnt_drv = {
0806: .controls = sun8i_codec_common_controls,
0807: .num_controls = ARRAY_SIZE(sun8i_codec_common_controls),
0808: .dapm_widgets = sun8i_codec_common_widgets,
0809: .num_dapm_widgets = ARRAY_SIZE(sun8i_codec_common_widgets),
0810: .dapm_routes = sun8i_codec_common_routes,
0811: .num_dapm_routes = ARRAY_SIZE(sun8i_codec_common_routes),
0812: .probe = sun8i_codec_analog_cmpnt_probe,
0813: };
0814:
0815: static const struct of_device_id sun8i_codec_analog_of_match[] = {
0816: {
0817: .compatible = "allwinner,sun8i-a23-codec-analog",
0818: .data = &sun8i_a23_quirks,
0819: },
0820: {
0821: .compatible = "allwinner,sun8i-h3-codec-analog",
0822: .data = &sun8i_h3_quirks,
0823: },
0824: {
0825: .compatible = "allwinner,sun8i-v3s-codec-analog",
0826: .data = &sun8i_v3s_quirks,
0827: },
0828: {}
0829: };
0830: MODULE_DEVICE_TABLE(of, sun8i_codec_analog_of_match);
0831:
0832: #define SUNXI_HMIC_ENABLE (0x4)
0833: #define SUNXI_HMIC_CTL (0x8)
0834: #define SUNXI_HMIC_DATA (0xc)
0835:
0836: #define HMIC_M (28)
0837: #define HMIC_N (24)
0838: #define HMIC_DIRQ (23)
0839: #define HMIC_TH1_HYS (21)
0840: #define HMIC_EARPHONE_OUT_IRQ_EN (20)
0841: #define HMIC_EARPHONE_IN_IRQ_EN (19)
0842: #define HMIC_KEY_UP_IRQ_EN (18)
0843: #define HMIC_KEY_DOWN_IRQ_EN (17)
0844: #define HMIC_DATA_IRQ_EN (16)
0845: #define HMIC_DS_SAMP (14)
0846: #define HMIC_TH2_HYS (13)
0847: #define HMIC_TH2_KEY (8)
0848: #define HMIC_SF_SMOOTH_FIL (6)
0849: #define KEY_UP_IRQ_PEND (5)
0850: #define HMIC_TH1_EARPHONE (0)
0851:
0852: #define HMIC_EARPHONE_OUT_IRQ_PEND (20)
0853: #define HMIC_EARPHONE_IN_IRQ_PEND (19)
0854: #define HMIC_KEY_UP_IRQ_PEND (18)
0855: #define HMIC_KEY_DOWN_IRQ_PEND (17)
0856: #define HMIC_DATA_IRQ_PEND (16)
0857: #define HMIC_ADC_DATA (0)
0858:
0859: #define HP_VOLC (0x00)
0860: #define LOMIXSC (0x01)
0861: #define ROMIXSC (0x02)
0862: #define DAC_PA_SRC (0x03)
0863: #define PAEN_HP_CTRL (0x07)
0864: #define ADDA_APT2 (0x12)
0865: #define MIC1G_MICBIAS_CTRL (0x0B)
0866: #define PA_ANTI_POP_REG_CTRL (0x0E)
0867: #define PA_SLOPE_SELECT (3)
0868: #define PA_ANTI_POP_EN (0)
0869:
0870: static void __iomem *sun8i_codec_analog_base;
0871: static struct gpio_desc * speaker_amplifier_gpio;
0872:
0873: struct regmap * rmap = 0;
0874:
0875: static int hmic_wrreg_prcm_bits(unsigned short reg, unsigned int mask, unsigned int value)
0876: {
0877: unsigned int old, new;
0878: if( !rmap ) return 0;
0879: regmap_read(rmap, reg, &old);
0880: //adda_reg_read(sun8i_codec_analog_base, reg, &old);
0881: new = (old & ~mask) | value;
0882: //adda_reg_write(sun8i_codec_analog_base, reg,new);
0883: regmap_write(rmap, reg,new);
0884:
0885: return 0;
0886: }
0887:
0888: static int hmic_wr_prcm_control(u32 reg, u32 mask, u32 shift, u32 val)
0889: {
0890: u32 reg_val;
0891: reg_val = val << shift;
0892: mask = mask << shift;
0893: hmic_wrreg_prcm_bits(reg, mask, reg_val);
0894: return 0;
0895: }
0896:
0897: static int hmic_wrreg_bits(unsigned short reg, unsigned int mask, unsigned int value)
0898: {
0899: unsigned int old, new;
0900:
0901: old = readl(sun8i_codec_analog_base + reg);
0902: new = (old & ~mask) | value;
0903:
0904: writel(new, sun8i_codec_analog_base + reg);
0905:
0906: return 0;
0907: }
0908:
0909: static int hmic_wr_control(u32 reg, u32 mask, u32 shift, u32 val)
0910: {
0911: u32 reg_val;
0912: reg_val = val << shift;
0913: mask = mask << shift;
0914: hmic_wrreg_bits(reg, mask, reg_val);
0915: return 0;
0916: }
0917:
0918: static irqreturn_t sunxi_codec_analog_irq(int irq, void *dev_id)
0919: {
0920: u32 tmp;
0921:
0922: hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_KEY_DOWN_IRQ_PEND, 0x1);
0923: hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_EARPHONE_IN_IRQ_PEND, 0x1);
0924: hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_KEY_UP_IRQ_PEND, 0x1);
0925: hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_EARPHONE_OUT_IRQ_PEND, 0x1);
0926: hmic_wr_control(SUNXI_HMIC_DATA, 0x1, HMIC_DATA_IRQ_PEND, 0x1);
0927:
0928: tmp = readl(sun8i_codec_analog_base + SUNXI_HMIC_DATA);
0929: if(tmp & 0x1f)
0930: gpiod_set_value(speaker_amplifier_gpio, 0);
0931: else
0932: gpiod_set_value(speaker_amplifier_gpio, 1);
0933:
0934: return IRQ_HANDLED;
0935: }
0936:
0937: static void sunxi_hppa_enable(void) {
0938: /*fix the resume blaze blaze noise*/
0939: hmic_wr_prcm_control(ADDA_APT2, 0x1, PA_SLOPE_SELECT, 0x0);
0940: hmic_wr_prcm_control(SUN8I_ADDA_PAEN_HP_CTRL, 0x3, SUN8I_ADDA_PAEN_HP_CTRL_PA_ANTI_POP_CTRL, 0x1);
0941: hmic_wr_prcm_control(PA_ANTI_POP_REG_CTRL, 0x7, PA_ANTI_POP_EN, 0x2);
0942: usleep_range(100,200);
0943: /*enable pa*/
0944: hmic_wr_prcm_control(SUN8I_ADDA_PAEN_HP_CTRL, 0x1, SUN8I_ADDA_PAEN_HP_CTRL_HPPAEN, 0x1);
0945: }
0946:
0947: static void sunxi_hbias_enable(void) {
0948: /*audio codec hardware bug. the HBIASADCEN bit must be enable in init*/
0949: hmic_wr_prcm_control(SUN8I_ADDA_MIC1G_MICBIAS_CTRL, 0x1, SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIAS_MODE, 0x1);
0950: hmic_wr_prcm_control(SUN8I_ADDA_MIC1G_MICBIAS_CTRL, 0x1, SUN8I_ADDA_MIC1G_MICBIAS_CTRL_HMICBIASEN, 0x1);
0951: }
0952:
0953: static void codec_init_events(void)
0954: {
0955: /*fix the resume blaze blaze noise*/
0956: sunxi_hppa_enable();
0957: msleep(450);
0958: /*audio codec hardware bug. the HBIASADCEN bit must be enable in init*/
0959: sunxi_hbias_enable();
0960: }
0961:
0962: static int sun8i_codec_analog_probe(struct platform_device *pdev)
0963: {
0964: struct resource *res;
0965: struct regmap *regmap;
0966: void __iomem *base;
0967: int irq, ret;
0968:
0969: res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0970: base = devm_ioremap_resource(&pdev->dev, res);
0971: if (IS_ERR(base)) {
0972: dev_err(&pdev->dev, "Failed to map the registers\n");
0973: return PTR_ERR(base);
0974: }
0975:
0976: sun8i_codec_analog_base = base;
0977:
0978: hmic_wr_control(SUNXI_HMIC_CTL, 0xf, HMIC_M, 0x0); /*0xf should be get from hw_debug 28*/
0979: hmic_wr_control(SUNXI_HMIC_CTL, 0xf, HMIC_N, 0x0); /*0xf should be get from hw_debug 24 0xf*/
0980: // hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_DIRQ, 0x1); /*23*/
0981: hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_EARPHONE_OUT_IRQ_EN, 0x1); /*20*/
0982: hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_EARPHONE_IN_IRQ_EN, 0x1); /*19*/
0983: hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_KEY_UP_IRQ_EN, 0x1); /*18*/
0984: hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_KEY_DOWN_IRQ_EN, 0x1); /*17*/
0985: hmic_wr_control(SUNXI_HMIC_CTL, 0x1, HMIC_DATA_IRQ_EN, 0x1); /*16*/
0986: hmic_wr_control(SUNXI_HMIC_CTL, 0x3, HMIC_DS_SAMP, 0x0); /*14 */
0987: hmic_wr_control(SUNXI_HMIC_CTL, 0x1f, HMIC_TH2_KEY, 0x0); /*0xf should be get from hw_debug 8*/
0988: hmic_wr_control(SUNXI_HMIC_CTL, 0x1f, HMIC_TH1_EARPHONE, 0x1); /*0x1 should be get from hw_debug 0*/
0989:
0990: speaker_amplifier_gpio = devm_gpiod_get_optional(&pdev->dev, "speaker-amplifier", GPIOD_OUT_HIGH);
0991: if (IS_ERR(speaker_amplifier_gpio))
0992: dev_err(&pdev->dev, "Can't get speaker_amplifier_gpio\n");
0993:
0994: irq = platform_get_irq(pdev, 0);
0995: if (irq < 0) {
0996: dev_err(&pdev->dev, "Can't retrieve our interrupt\n");
0997: return irq;
0998: }
0999:
1000: ret = devm_request_irq(&pdev->dev, irq, sunxi_codec_analog_irq, 0, "audio_hmic_irq", NULL);
1001: if (ret) {
1002: dev_err(&pdev->dev, "can't register interrupt handler irq %d: %d\n",
1003: irq, ret);
1004: return ret;
1005: }
1006:
1007: codec_init_events();
1008:
1009: regmap = sun8i_adda_pr_regmap_init(&pdev->dev, base);
1010: if (IS_ERR(regmap)) {
1011: rmap = 0;
1012: dev_err(&pdev->dev, "Failed to create regmap\n");
1013: return PTR_ERR(regmap);
1014: }
1015:
1016: rmap = regmap;
1017:
1018: return devm_snd_soc_register_component(&pdev->dev,
1019: &sun8i_codec_analog_cmpnt_drv,
1020: NULL, 0);
1021: }
1022:
1023: static struct platform_driver sun8i_codec_analog_driver = {
1024: .driver = {
1025: .name = "sun8i-codec-analog",
1026: .of_match_table = sun8i_codec_analog_of_match,
1027: },
1028: .probe = sun8i_codec_analog_probe,
1029: };
1030: module_platform_driver(sun8i_codec_analog_driver);
1031:
1032: MODULE_DESCRIPTION("Allwinner internal codec analog controls driver");
1033: MODULE_AUTHOR("Chen-Yu Tsai <wens@csie.org>");
1034: MODULE_LICENSE("GPL");
1035: MODULE_ALIAS("platform:sun8i-codec-analog");