Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003 * alc5632.c  --  ALC5632 ALSA SoC Audio Codec
0004 *
0005 * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.lauchpad.net>
0006 *
0007 * Authors:  Leon Romanovsky <leon@leon.nu>
0008 *           Andrey Danin <danindrey@mail.ru>
0009 *           Ilya Petrov <ilya.muromec@gmail.com>
0010 *           Marc Dietrich <marvin24@gmx.de>
0011 *
0012 * Based on alc5623.c by Arnaud Patard
0013 */
0014 
0015 #include <linux/module.h>
0016 #include <linux/kernel.h>
0017 #include <linux/init.h>
0018 #include <linux/delay.h>
0019 #include <linux/pm.h>
0020 #include <linux/i2c.h>
0021 #include <linux/slab.h>
0022 #include <linux/regmap.h>
0023 #include <sound/core.h>
0024 #include <sound/pcm.h>
0025 #include <sound/pcm_params.h>
0026 #include <sound/tlv.h>
0027 #include <sound/soc.h>
0028 #include <sound/initval.h>
0029 
0030 #include "alc5632.h"
0031 
0032 /*
0033  * ALC5632 register cache
0034  */
0035 static const struct reg_default alc5632_reg_defaults[] = {
0036     {   2, 0x8080 },    /* R2   - Speaker Output Volume */
0037     {   4, 0x8080 },    /* R4   - Headphone Output Volume */
0038     {   6, 0x8080 },    /* R6   - AUXOUT Volume */
0039     {   8, 0xC800 },    /* R8   - Phone Input */
0040     {  10, 0xE808 },    /* R10  - LINE_IN Volume */
0041     {  12, 0x1010 },    /* R12  - STEREO DAC Input Volume */
0042     {  14, 0x0808 },    /* R14  - MIC Input Volume */
0043     {  16, 0xEE0F },    /* R16  - Stereo DAC and MIC Routing Control */
0044     {  18, 0xCBCB },    /* R18  - ADC Record Gain */
0045     {  20, 0x7F7F },    /* R20  - ADC Record Mixer Control */
0046     {  24, 0xE010 },    /* R24  - Voice DAC Volume */
0047     {  28, 0x8008 },    /* R28  - Output Mixer Control */
0048     {  34, 0x0000 },    /* R34  - Microphone Control */
0049     {  36, 0x00C0 },    /* R36  - Codec Digital MIC/Digital Boost
0050                            Control */
0051     {  46, 0x0000 },    /* R46  - Stereo DAC/Voice DAC/Stereo ADC
0052                            Function Select */
0053     {  52, 0x8000 },    /* R52  - Main Serial Data Port Control
0054                            (Stereo I2S) */
0055     {  54, 0x0000 },    /* R54  - Extend Serial Data Port Control
0056                            (VoDAC_I2S/PCM) */
0057     {  58, 0x0000 },    /* R58  - Power Management Addition 1 */
0058     {  60, 0x0000 },    /* R60  - Power Management Addition 2 */
0059     {  62, 0x8000 },    /* R62  - Power Management Addition 3 */
0060     {  64, 0x0C0A },    /* R64  - General Purpose Control Register 1 */
0061     {  66, 0x0000 },    /* R66  - General Purpose Control Register 2 */
0062     {  68, 0x0000 },    /* R68  - PLL1 Control */
0063     {  70, 0x0000 },    /* R70  - PLL2 Control */
0064     {  76, 0xBE3E },    /* R76  - GPIO Pin Configuration */
0065     {  78, 0xBE3E },    /* R78  - GPIO Pin Polarity */
0066     {  80, 0x0000 },    /* R80  - GPIO Pin Sticky */
0067     {  82, 0x0000 },    /* R82  - GPIO Pin Wake Up */
0068     {  86, 0x0000 },    /* R86  - Pin Sharing */
0069     {  90, 0x0009 },    /* R90  - Soft Volume Control Setting */
0070     {  92, 0x0000 },    /* R92  - GPIO_Output Pin Control */
0071     {  94, 0x3000 },    /* R94  - MISC Control */
0072     {  96, 0x3075 },    /* R96  - Stereo DAC Clock Control_1 */
0073     {  98, 0x1010 },    /* R98  - Stereo DAC Clock Control_2 */
0074     { 100, 0x3110 },    /* R100 - VoDAC_PCM Clock Control_1 */
0075     { 104, 0x0553 },    /* R104 - Pseudo Stereo and Spatial Effect
0076                            Block Control */
0077     { 106, 0x0000 },    /* R106 - Private Register Address */
0078 };
0079 
0080 /* codec private data */
0081 struct alc5632_priv {
0082     struct regmap *regmap;
0083     u8 id;
0084     unsigned int sysclk;
0085 };
0086 
0087 static bool alc5632_volatile_register(struct device *dev,
0088                             unsigned int reg)
0089 {
0090     switch (reg) {
0091     case ALC5632_RESET:
0092     case ALC5632_PWR_DOWN_CTRL_STATUS:
0093     case ALC5632_GPIO_PIN_STATUS:
0094     case ALC5632_OVER_CURR_STATUS:
0095     case ALC5632_HID_CTRL_DATA:
0096     case ALC5632_EQ_CTRL:
0097     case ALC5632_VENDOR_ID1:
0098     case ALC5632_VENDOR_ID2:
0099         return true;
0100 
0101     default:
0102         break;
0103     }
0104 
0105     return false;
0106 }
0107 
0108 static inline int alc5632_reset(struct regmap *map)
0109 {
0110     return regmap_write(map, ALC5632_RESET, 0x59B4);
0111 }
0112 
0113 static int amp_mixer_event(struct snd_soc_dapm_widget *w,
0114     struct snd_kcontrol *kcontrol, int event)
0115 {
0116     struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
0117 
0118     /* to power-on/off class-d amp generators/speaker */
0119     /* need to write to 'index-46h' register :        */
0120     /* so write index num (here 0x46) to reg 0x6a     */
0121     /* and then 0xffff/0 to reg 0x6c                  */
0122     snd_soc_component_write(component, ALC5632_HID_CTRL_INDEX, 0x46);
0123 
0124     switch (event) {
0125     case SND_SOC_DAPM_PRE_PMU:
0126         snd_soc_component_write(component, ALC5632_HID_CTRL_DATA, 0xFFFF);
0127         break;
0128     case SND_SOC_DAPM_POST_PMD:
0129         snd_soc_component_write(component, ALC5632_HID_CTRL_DATA, 0);
0130         break;
0131     }
0132 
0133     return 0;
0134 }
0135 
0136 /*
0137  * ALC5632 Controls
0138  */
0139 
0140 /* -34.5db min scale, 1.5db steps, no mute */
0141 static const DECLARE_TLV_DB_SCALE(vol_tlv, -3450, 150, 0);
0142 /* -46.5db min scale, 1.5db steps, no mute */
0143 static const DECLARE_TLV_DB_SCALE(hp_tlv, -4650, 150, 0);
0144 /* -16.5db min scale, 1.5db steps, no mute */
0145 static const DECLARE_TLV_DB_SCALE(adc_rec_tlv, -1650, 150, 0);
0146 static const DECLARE_TLV_DB_RANGE(boost_tlv,
0147     0, 1, TLV_DB_SCALE_ITEM(0, 2000, 0),
0148     1, 3, TLV_DB_SCALE_ITEM(2000, 1000, 0)
0149 );
0150 /* 0db min scale, 6 db steps, no mute */
0151 static const DECLARE_TLV_DB_SCALE(dig_tlv, 0, 600, 0);
0152 /* 0db min scalem 0.75db steps, no mute */
0153 static const DECLARE_TLV_DB_SCALE(vdac_tlv, -3525, 75, 0);
0154 
0155 static const struct snd_kcontrol_new alc5632_vol_snd_controls[] = {
0156     /* left starts at bit 8, right at bit 0 */
0157     /* 31 steps (5 bit), -46.5db scale */
0158     SOC_DOUBLE_TLV("Speaker Playback Volume",
0159             ALC5632_SPK_OUT_VOL, 8, 0, 31, 1, hp_tlv),
0160     /* bit 15 mutes left, bit 7 right */
0161     SOC_DOUBLE("Speaker Playback Switch",
0162             ALC5632_SPK_OUT_VOL, 15, 7, 1, 1),
0163     SOC_DOUBLE_TLV("Headphone Playback Volume",
0164             ALC5632_HP_OUT_VOL, 8, 0, 31, 1, hp_tlv),
0165     SOC_DOUBLE("Headphone Playback Switch",
0166             ALC5632_HP_OUT_VOL, 15, 7, 1, 1),
0167 };
0168 
0169 static const struct snd_kcontrol_new alc5632_snd_controls[] = {
0170     SOC_DOUBLE_TLV("Auxout Playback Volume",
0171             ALC5632_AUX_OUT_VOL, 8, 0, 31, 1, hp_tlv),
0172     SOC_DOUBLE("Auxout Playback Switch",
0173             ALC5632_AUX_OUT_VOL, 15, 7, 1, 1),
0174     SOC_SINGLE_TLV("Voice DAC Playback Volume",
0175             ALC5632_VOICE_DAC_VOL, 0, 63, 0, vdac_tlv),
0176     SOC_SINGLE("Voice DAC Playback Switch",
0177             ALC5632_VOICE_DAC_VOL, 12, 1, 1),
0178     SOC_SINGLE_TLV("Phone Playback Volume",
0179             ALC5632_PHONE_IN_VOL, 8, 31, 1, vol_tlv),
0180     SOC_DOUBLE_TLV("LineIn Playback Volume",
0181             ALC5632_LINE_IN_VOL, 8, 0, 31, 1, vol_tlv),
0182     SOC_DOUBLE_TLV("Master Playback Volume",
0183             ALC5632_STEREO_DAC_IN_VOL, 8, 0, 63, 1, vdac_tlv),
0184     SOC_DOUBLE("Master Playback Switch",
0185             ALC5632_STEREO_DAC_IN_VOL, 15, 7, 1, 1),
0186     SOC_SINGLE_TLV("Mic1 Playback Volume",
0187             ALC5632_MIC_VOL, 8, 31, 1, vol_tlv),
0188     SOC_SINGLE_TLV("Mic2 Playback Volume",
0189             ALC5632_MIC_VOL, 0, 31, 1, vol_tlv),
0190     SOC_DOUBLE_TLV("Rec Capture Volume",
0191             ALC5632_ADC_REC_GAIN, 8, 0, 31, 0, adc_rec_tlv),
0192     SOC_SINGLE_TLV("Mic 1 Boost Volume",
0193             ALC5632_MIC_CTRL, 10, 3, 0, boost_tlv),
0194     SOC_SINGLE_TLV("Mic 2 Boost Volume",
0195             ALC5632_MIC_CTRL, 8, 3, 0, boost_tlv),
0196     SOC_SINGLE_TLV("DMIC Boost Capture Volume",
0197             ALC5632_DIGI_BOOST_CTRL, 0, 7, 0, dig_tlv),
0198     SOC_SINGLE("DMIC En Capture Switch",
0199             ALC5632_DIGI_BOOST_CTRL, 15, 1, 0),
0200     SOC_SINGLE("DMIC PreFilter Capture Switch",
0201             ALC5632_DIGI_BOOST_CTRL, 12, 1, 0),
0202 };
0203 
0204 /*
0205  * DAPM Controls
0206  */
0207 static const struct snd_kcontrol_new alc5632_hp_mixer_controls[] = {
0208 SOC_DAPM_SINGLE("LI2HP Playback Switch", ALC5632_LINE_IN_VOL, 15, 1, 1),
0209 SOC_DAPM_SINGLE("PHONE2HP Playback Switch", ALC5632_PHONE_IN_VOL, 15, 1, 1),
0210 SOC_DAPM_SINGLE("MIC12HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 15, 1, 1),
0211 SOC_DAPM_SINGLE("MIC22HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 11, 1, 1),
0212 SOC_DAPM_SINGLE("VOICE2HP Playback Switch", ALC5632_VOICE_DAC_VOL, 15, 1, 1),
0213 };
0214 
0215 static const struct snd_kcontrol_new alc5632_hpl_mixer_controls[] = {
0216 SOC_DAPM_SINGLE("ADC2HP_L Playback Switch", ALC5632_ADC_REC_GAIN, 15, 1, 1),
0217 SOC_DAPM_SINGLE("DACL2HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 3, 1, 1),
0218 };
0219 
0220 static const struct snd_kcontrol_new alc5632_hpr_mixer_controls[] = {
0221 SOC_DAPM_SINGLE("ADC2HP_R Playback Switch", ALC5632_ADC_REC_GAIN, 7, 1, 1),
0222 SOC_DAPM_SINGLE("DACR2HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 2, 1, 1),
0223 };
0224 
0225 static const struct snd_kcontrol_new alc5632_mono_mixer_controls[] = {
0226 SOC_DAPM_SINGLE("ADC2MONO_L Playback Switch", ALC5632_ADC_REC_GAIN, 14, 1, 1),
0227 SOC_DAPM_SINGLE("ADC2MONO_R Playback Switch", ALC5632_ADC_REC_GAIN, 6, 1, 1),
0228 SOC_DAPM_SINGLE("LI2MONO Playback Switch", ALC5632_LINE_IN_VOL, 13, 1, 1),
0229 SOC_DAPM_SINGLE("MIC12MONO Playback Switch",
0230                     ALC5632_MIC_ROUTING_CTRL, 13, 1, 1),
0231 SOC_DAPM_SINGLE("MIC22MONO Playback Switch",
0232                     ALC5632_MIC_ROUTING_CTRL, 9, 1, 1),
0233 SOC_DAPM_SINGLE("DAC2MONO Playback Switch", ALC5632_MIC_ROUTING_CTRL, 0, 1, 1),
0234 SOC_DAPM_SINGLE("VOICE2MONO Playback Switch", ALC5632_VOICE_DAC_VOL, 13, 1, 1),
0235 };
0236 
0237 static const struct snd_kcontrol_new alc5632_speaker_mixer_controls[] = {
0238 SOC_DAPM_SINGLE("LI2SPK Playback Switch", ALC5632_LINE_IN_VOL, 14, 1, 1),
0239 SOC_DAPM_SINGLE("PHONE2SPK Playback Switch", ALC5632_PHONE_IN_VOL, 14, 1, 1),
0240 SOC_DAPM_SINGLE("MIC12SPK Playback Switch",
0241                     ALC5632_MIC_ROUTING_CTRL, 14, 1, 1),
0242 SOC_DAPM_SINGLE("MIC22SPK Playback Switch",
0243                     ALC5632_MIC_ROUTING_CTRL, 10, 1, 1),
0244 SOC_DAPM_SINGLE("DAC2SPK Playback Switch", ALC5632_MIC_ROUTING_CTRL, 1, 1, 1),
0245 SOC_DAPM_SINGLE("VOICE2SPK Playback Switch", ALC5632_VOICE_DAC_VOL, 14, 1, 1),
0246 };
0247 
0248 /* Left Record Mixer */
0249 static const struct snd_kcontrol_new alc5632_captureL_mixer_controls[] = {
0250 SOC_DAPM_SINGLE("MIC12REC_L Capture Switch", ALC5632_ADC_REC_MIXER, 14, 1, 1),
0251 SOC_DAPM_SINGLE("MIC22REC_L Capture Switch", ALC5632_ADC_REC_MIXER, 13, 1, 1),
0252 SOC_DAPM_SINGLE("LIL2REC Capture Switch", ALC5632_ADC_REC_MIXER, 12, 1, 1),
0253 SOC_DAPM_SINGLE("PH2REC_L Capture Switch", ALC5632_ADC_REC_MIXER, 11, 1, 1),
0254 SOC_DAPM_SINGLE("HPL2REC Capture Switch", ALC5632_ADC_REC_MIXER, 10, 1, 1),
0255 SOC_DAPM_SINGLE("SPK2REC_L Capture Switch", ALC5632_ADC_REC_MIXER, 9, 1, 1),
0256 SOC_DAPM_SINGLE("MONO2REC_L Capture Switch", ALC5632_ADC_REC_MIXER, 8, 1, 1),
0257 };
0258 
0259 /* Right Record Mixer */
0260 static const struct snd_kcontrol_new alc5632_captureR_mixer_controls[] = {
0261 SOC_DAPM_SINGLE("MIC12REC_R Capture Switch", ALC5632_ADC_REC_MIXER, 6, 1, 1),
0262 SOC_DAPM_SINGLE("MIC22REC_R Capture Switch", ALC5632_ADC_REC_MIXER, 5, 1, 1),
0263 SOC_DAPM_SINGLE("LIR2REC Capture Switch", ALC5632_ADC_REC_MIXER, 4, 1, 1),
0264 SOC_DAPM_SINGLE("PH2REC_R Capture Switch", ALC5632_ADC_REC_MIXER, 3, 1, 1),
0265 SOC_DAPM_SINGLE("HPR2REC Capture Switch", ALC5632_ADC_REC_MIXER, 2, 1, 1),
0266 SOC_DAPM_SINGLE("SPK2REC_R Capture Switch", ALC5632_ADC_REC_MIXER, 1, 1, 1),
0267 SOC_DAPM_SINGLE("MONO2REC_R Capture Switch", ALC5632_ADC_REC_MIXER, 0, 1, 1),
0268 };
0269 
0270 /* Dmic Mixer */
0271 static const struct snd_kcontrol_new alc5632_dmicl_mixer_controls[] = {
0272 SOC_DAPM_SINGLE("DMICL2ADC Capture Switch", ALC5632_DIGI_BOOST_CTRL, 7, 1, 1),
0273 };
0274 static const struct snd_kcontrol_new alc5632_dmicr_mixer_controls[] = {
0275 SOC_DAPM_SINGLE("DMICR2ADC Capture Switch", ALC5632_DIGI_BOOST_CTRL, 6, 1, 1),
0276 };
0277 
0278 static const char * const alc5632_spk_n_sour_sel[] = {
0279         "RN/-R", "RP/+R", "LN/-R", "Mute"};
0280 static const char * const alc5632_hpl_out_input_sel[] = {
0281         "Vmid", "HP Left Mix"};
0282 static const char * const alc5632_hpr_out_input_sel[] = {
0283         "Vmid", "HP Right Mix"};
0284 static const char * const alc5632_spkout_input_sel[] = {
0285         "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"};
0286 static const char * const alc5632_aux_out_input_sel[] = {
0287         "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"};
0288 static const char * const alc5632_adcr_func_sel[] = {
0289         "Stereo ADC", "Voice ADC"};
0290 static const char * const alc5632_i2s_out_sel[] = {
0291         "ADC LR", "Voice Stereo Digital"};
0292 
0293 /* auxout output mux */
0294 static SOC_ENUM_SINGLE_DECL(alc5632_aux_out_input_enum,
0295                 ALC5632_OUTPUT_MIXER_CTRL, 6,
0296                 alc5632_aux_out_input_sel);
0297 static const struct snd_kcontrol_new alc5632_auxout_mux_controls =
0298 SOC_DAPM_ENUM("AuxOut Mux", alc5632_aux_out_input_enum);
0299 
0300 /* speaker output mux */
0301 static SOC_ENUM_SINGLE_DECL(alc5632_spkout_input_enum,
0302                 ALC5632_OUTPUT_MIXER_CTRL, 10,
0303                 alc5632_spkout_input_sel);
0304 static const struct snd_kcontrol_new alc5632_spkout_mux_controls =
0305 SOC_DAPM_ENUM("SpeakerOut Mux", alc5632_spkout_input_enum);
0306 
0307 /* headphone left output mux */
0308 static SOC_ENUM_SINGLE_DECL(alc5632_hpl_out_input_enum,
0309                 ALC5632_OUTPUT_MIXER_CTRL, 9,
0310                 alc5632_hpl_out_input_sel);
0311 static const struct snd_kcontrol_new alc5632_hpl_out_mux_controls =
0312 SOC_DAPM_ENUM("Left Headphone Mux", alc5632_hpl_out_input_enum);
0313 
0314 /* headphone right output mux */
0315 static SOC_ENUM_SINGLE_DECL(alc5632_hpr_out_input_enum,
0316                 ALC5632_OUTPUT_MIXER_CTRL, 8,
0317                 alc5632_hpr_out_input_sel);
0318 static const struct snd_kcontrol_new alc5632_hpr_out_mux_controls =
0319 SOC_DAPM_ENUM("Right Headphone Mux", alc5632_hpr_out_input_enum);
0320 
0321 /* speaker output N select */
0322 static SOC_ENUM_SINGLE_DECL(alc5632_spk_n_sour_enum,
0323                 ALC5632_OUTPUT_MIXER_CTRL, 14,
0324                 alc5632_spk_n_sour_sel);
0325 static const struct snd_kcontrol_new alc5632_spkoutn_mux_controls =
0326 SOC_DAPM_ENUM("SpeakerOut N Mux", alc5632_spk_n_sour_enum);
0327 
0328 /* speaker amplifier */
0329 static const char *alc5632_amp_names[] = {"AB Amp", "D Amp"};
0330 static SOC_ENUM_SINGLE_DECL(alc5632_amp_enum,
0331                 ALC5632_OUTPUT_MIXER_CTRL, 13,
0332                 alc5632_amp_names);
0333 static const struct snd_kcontrol_new alc5632_amp_mux_controls =
0334     SOC_DAPM_ENUM("AB-D Amp Mux", alc5632_amp_enum);
0335 
0336 /* ADC output select */
0337 static SOC_ENUM_SINGLE_DECL(alc5632_adcr_func_enum,
0338                 ALC5632_DAC_FUNC_SELECT, 5,
0339                 alc5632_adcr_func_sel);
0340 static const struct snd_kcontrol_new alc5632_adcr_func_controls =
0341     SOC_DAPM_ENUM("ADCR Mux", alc5632_adcr_func_enum);
0342 
0343 /* I2S out select */
0344 static SOC_ENUM_SINGLE_DECL(alc5632_i2s_out_enum,
0345                 ALC5632_I2S_OUT_CTL, 5,
0346                 alc5632_i2s_out_sel);
0347 static const struct snd_kcontrol_new alc5632_i2s_out_controls =
0348     SOC_DAPM_ENUM("I2SOut Mux", alc5632_i2s_out_enum);
0349 
0350 static const struct snd_soc_dapm_widget alc5632_dapm_widgets[] = {
0351 /* Muxes */
0352 SND_SOC_DAPM_MUX("AuxOut Mux", SND_SOC_NOPM, 0, 0,
0353     &alc5632_auxout_mux_controls),
0354 SND_SOC_DAPM_MUX("SpeakerOut Mux", SND_SOC_NOPM, 0, 0,
0355     &alc5632_spkout_mux_controls),
0356 SND_SOC_DAPM_MUX("Left Headphone Mux", SND_SOC_NOPM, 0, 0,
0357     &alc5632_hpl_out_mux_controls),
0358 SND_SOC_DAPM_MUX("Right Headphone Mux", SND_SOC_NOPM, 0, 0,
0359     &alc5632_hpr_out_mux_controls),
0360 SND_SOC_DAPM_MUX("SpeakerOut N Mux", SND_SOC_NOPM, 0, 0,
0361     &alc5632_spkoutn_mux_controls),
0362 SND_SOC_DAPM_MUX("ADCR Mux", SND_SOC_NOPM, 0, 0,
0363     &alc5632_adcr_func_controls),
0364 SND_SOC_DAPM_MUX("I2SOut Mux", ALC5632_PWR_MANAG_ADD1, 11, 0,
0365     &alc5632_i2s_out_controls),
0366 
0367 /* output mixers */
0368 SND_SOC_DAPM_MIXER("HP Mix", SND_SOC_NOPM, 0, 0,
0369     &alc5632_hp_mixer_controls[0],
0370     ARRAY_SIZE(alc5632_hp_mixer_controls)),
0371 SND_SOC_DAPM_MIXER("HPR Mix", ALC5632_PWR_MANAG_ADD2, 4, 0,
0372     &alc5632_hpr_mixer_controls[0],
0373     ARRAY_SIZE(alc5632_hpr_mixer_controls)),
0374 SND_SOC_DAPM_MIXER("HPL Mix", ALC5632_PWR_MANAG_ADD2, 5, 0,
0375     &alc5632_hpl_mixer_controls[0],
0376     ARRAY_SIZE(alc5632_hpl_mixer_controls)),
0377 SND_SOC_DAPM_MIXER("HPOut Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
0378 SND_SOC_DAPM_MIXER("Mono Mix", ALC5632_PWR_MANAG_ADD2, 2, 0,
0379     &alc5632_mono_mixer_controls[0],
0380     ARRAY_SIZE(alc5632_mono_mixer_controls)),
0381 SND_SOC_DAPM_MIXER("Speaker Mix", ALC5632_PWR_MANAG_ADD2, 3, 0,
0382     &alc5632_speaker_mixer_controls[0],
0383     ARRAY_SIZE(alc5632_speaker_mixer_controls)),
0384 SND_SOC_DAPM_MIXER("DMICL Mix", SND_SOC_NOPM, 0, 0,
0385     &alc5632_dmicl_mixer_controls[0],
0386     ARRAY_SIZE(alc5632_dmicl_mixer_controls)),
0387 SND_SOC_DAPM_MIXER("DMICR Mix", SND_SOC_NOPM, 0, 0,
0388     &alc5632_dmicr_mixer_controls[0],
0389     ARRAY_SIZE(alc5632_dmicr_mixer_controls)),
0390 
0391 /* input mixers */
0392 SND_SOC_DAPM_MIXER("Left Capture Mix", ALC5632_PWR_MANAG_ADD2, 1, 0,
0393     &alc5632_captureL_mixer_controls[0],
0394     ARRAY_SIZE(alc5632_captureL_mixer_controls)),
0395 SND_SOC_DAPM_MIXER("Right Capture Mix", ALC5632_PWR_MANAG_ADD2, 0, 0,
0396     &alc5632_captureR_mixer_controls[0],
0397     ARRAY_SIZE(alc5632_captureR_mixer_controls)),
0398 
0399 SND_SOC_DAPM_AIF_IN("AIFRXL", "Left HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
0400 SND_SOC_DAPM_AIF_IN("AIFRXR", "Right HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
0401 SND_SOC_DAPM_AIF_OUT("AIFTXL", "Left HiFi Capture", 0, SND_SOC_NOPM, 0, 0),
0402 SND_SOC_DAPM_AIF_OUT("AIFTXR", "Right HiFi Capture", 0, SND_SOC_NOPM, 0, 0),
0403 SND_SOC_DAPM_AIF_IN("VAIFRX", "Voice Playback", 0, SND_SOC_NOPM, 0, 0),
0404 SND_SOC_DAPM_AIF_OUT("VAIFTX", "Voice Capture", 0, SND_SOC_NOPM, 0, 0),
0405 
0406 SND_SOC_DAPM_DAC("Voice DAC", NULL, ALC5632_PWR_MANAG_ADD2, 10, 0),
0407 SND_SOC_DAPM_DAC("Left DAC", NULL, ALC5632_PWR_MANAG_ADD2, 9, 0),
0408 SND_SOC_DAPM_DAC("Right DAC", NULL, ALC5632_PWR_MANAG_ADD2, 8, 0),
0409 SND_SOC_DAPM_ADC("Left ADC", NULL, ALC5632_PWR_MANAG_ADD2, 7, 0),
0410 SND_SOC_DAPM_ADC("Right ADC", NULL, ALC5632_PWR_MANAG_ADD2, 6, 0),
0411 
0412 SND_SOC_DAPM_MIXER("DAC Left Channel", ALC5632_PWR_MANAG_ADD1, 15, 0, NULL, 0),
0413 SND_SOC_DAPM_MIXER("DAC Right Channel",
0414     ALC5632_PWR_MANAG_ADD1, 14, 0, NULL, 0),
0415 SND_SOC_DAPM_MIXER("I2S Mix", ALC5632_PWR_MANAG_ADD1, 11, 0, NULL, 0),
0416 SND_SOC_DAPM_MIXER("Phone Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
0417 SND_SOC_DAPM_MIXER("Line Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
0418 SND_SOC_DAPM_MIXER("Voice Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
0419 SND_SOC_DAPM_MIXER("ADCLR", SND_SOC_NOPM, 0, 0, NULL, 0),
0420 
0421 SND_SOC_DAPM_PGA("Left Headphone", ALC5632_PWR_MANAG_ADD3, 11, 0, NULL, 0),
0422 SND_SOC_DAPM_PGA("Right Headphone", ALC5632_PWR_MANAG_ADD3, 10, 0, NULL, 0),
0423 SND_SOC_DAPM_PGA("Left Speaker", ALC5632_PWR_MANAG_ADD3, 13, 0, NULL, 0),
0424 SND_SOC_DAPM_PGA("Right Speaker", ALC5632_PWR_MANAG_ADD3, 12, 0, NULL, 0),
0425 SND_SOC_DAPM_PGA("Aux Out", ALC5632_PWR_MANAG_ADD3, 14, 0, NULL, 0),
0426 SND_SOC_DAPM_PGA("Left LineIn", ALC5632_PWR_MANAG_ADD3, 7, 0, NULL, 0),
0427 SND_SOC_DAPM_PGA("Right LineIn", ALC5632_PWR_MANAG_ADD3, 6, 0, NULL, 0),
0428 SND_SOC_DAPM_PGA("Phone", ALC5632_PWR_MANAG_ADD3, 5, 0, NULL, 0),
0429 SND_SOC_DAPM_PGA("Phone ADMix", ALC5632_PWR_MANAG_ADD3, 4, 0, NULL, 0),
0430 SND_SOC_DAPM_PGA("MIC1 PGA", ALC5632_PWR_MANAG_ADD3, 3, 0, NULL, 0),
0431 SND_SOC_DAPM_PGA("MIC2 PGA", ALC5632_PWR_MANAG_ADD3, 2, 0, NULL, 0),
0432 SND_SOC_DAPM_PGA("MIC1 Pre Amp", ALC5632_PWR_MANAG_ADD3, 1, 0, NULL, 0),
0433 SND_SOC_DAPM_PGA("MIC2 Pre Amp", ALC5632_PWR_MANAG_ADD3, 0, 0, NULL, 0),
0434 SND_SOC_DAPM_SUPPLY("MICBIAS1", ALC5632_PWR_MANAG_ADD1, 3, 0, NULL, 0),
0435 SND_SOC_DAPM_SUPPLY("MICBIAS2", ALC5632_PWR_MANAG_ADD1, 2, 0, NULL, 0),
0436 
0437 SND_SOC_DAPM_PGA_E("D Amp", ALC5632_PWR_MANAG_ADD2, 14, 0, NULL, 0,
0438     amp_mixer_event, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
0439 SND_SOC_DAPM_PGA("AB Amp", ALC5632_PWR_MANAG_ADD2, 15, 0, NULL, 0),
0440 SND_SOC_DAPM_MUX("AB-D Amp Mux", ALC5632_PWR_MANAG_ADD1, 10, 0,
0441     &alc5632_amp_mux_controls),
0442 
0443 SND_SOC_DAPM_OUTPUT("AUXOUT"),
0444 SND_SOC_DAPM_OUTPUT("HPL"),
0445 SND_SOC_DAPM_OUTPUT("HPR"),
0446 SND_SOC_DAPM_OUTPUT("SPKOUT"),
0447 SND_SOC_DAPM_OUTPUT("SPKOUTN"),
0448 
0449 SND_SOC_DAPM_INPUT("LINEINL"),
0450 SND_SOC_DAPM_INPUT("LINEINR"),
0451 SND_SOC_DAPM_INPUT("PHONEP"),
0452 SND_SOC_DAPM_INPUT("PHONEN"),
0453 SND_SOC_DAPM_INPUT("DMICDAT"),
0454 SND_SOC_DAPM_INPUT("MIC1"),
0455 SND_SOC_DAPM_INPUT("MIC2"),
0456 SND_SOC_DAPM_VMID("Vmid"),
0457 };
0458 
0459 
0460 static const struct snd_soc_dapm_route alc5632_dapm_routes[] = {
0461     /* Playback streams */
0462     {"Left DAC", NULL, "AIFRXL"},
0463     {"Right DAC", NULL, "AIFRXR"},
0464 
0465     /* virtual mixer - mixes left & right channels */
0466     {"I2S Mix", NULL,   "Left DAC"},
0467     {"I2S Mix", NULL,   "Right DAC"},
0468     {"Line Mix",    NULL,   "Right LineIn"},
0469     {"Line Mix",    NULL,   "Left LineIn"},
0470     {"Phone Mix",   NULL,   "Phone"},
0471     {"Phone Mix",   NULL,   "Phone ADMix"},
0472     {"AUXOUT",      NULL,   "Aux Out"},
0473 
0474     /* DAC */
0475     {"DAC Right Channel",   NULL,   "I2S Mix"},
0476     {"DAC Left Channel",    NULL,   "I2S Mix"},
0477 
0478     /* HP mixer */
0479     {"HPL Mix", "ADC2HP_L Playback Switch", "Left Capture Mix"},
0480     {"HPL Mix", NULL,                   "HP Mix"},
0481     {"HPR Mix", "ADC2HP_R Playback Switch", "Right Capture Mix"},
0482     {"HPR Mix", NULL,                   "HP Mix"},
0483     {"HP Mix",  "LI2HP Playback Switch",    "Line Mix"},
0484     {"HP Mix",  "PHONE2HP Playback Switch", "Phone Mix"},
0485     {"HP Mix",  "MIC12HP Playback Switch",  "MIC1 PGA"},
0486     {"HP Mix",  "MIC22HP Playback Switch",  "MIC2 PGA"},
0487     {"HP Mix", "VOICE2HP Playback Switch",  "Voice Mix"},
0488     {"HPR Mix", "DACR2HP Playback Switch",  "DAC Right Channel"},
0489     {"HPL Mix", "DACL2HP Playback Switch",  "DAC Left Channel"},
0490     {"HPOut Mix", NULL, "HP Mix"},
0491     {"HPOut Mix", NULL, "HPR Mix"},
0492     {"HPOut Mix", NULL, "HPL Mix"},
0493 
0494     /* speaker mixer */
0495     {"Speaker Mix", "LI2SPK Playback Switch",   "Line Mix"},
0496     {"Speaker Mix", "PHONE2SPK Playback Switch", "Phone Mix"},
0497     {"Speaker Mix", "MIC12SPK Playback Switch", "MIC1 PGA"},
0498     {"Speaker Mix", "MIC22SPK Playback Switch", "MIC2 PGA"},
0499     {"Speaker Mix", "DAC2SPK Playback Switch",  "DAC Left Channel"},
0500     {"Speaker Mix", "VOICE2SPK Playback Switch",    "Voice Mix"},
0501 
0502     /* mono mixer */
0503     {"Mono Mix", "ADC2MONO_L Playback Switch",  "Left Capture Mix"},
0504     {"Mono Mix", "ADC2MONO_R Playback Switch",  "Right Capture Mix"},
0505     {"Mono Mix", "LI2MONO Playback Switch",     "Line Mix"},
0506     {"Mono Mix", "MIC12MONO Playback Switch",   "MIC1 PGA"},
0507     {"Mono Mix", "MIC22MONO Playback Switch",   "MIC2 PGA"},
0508     {"Mono Mix", "DAC2MONO Playback Switch",    "DAC Left Channel"},
0509     {"Mono Mix", "VOICE2MONO Playback Switch",  "Voice Mix"},
0510 
0511     /* Left record mixer */
0512     {"Left Capture Mix", "LIL2REC Capture Switch", "LINEINL"},
0513     {"Left Capture Mix", "PH2REC_L Capture Switch", "PHONEN"},
0514     {"Left Capture Mix", "MIC12REC_L Capture Switch", "MIC1 Pre Amp"},
0515     {"Left Capture Mix", "MIC22REC_L Capture Switch", "MIC2 Pre Amp"},
0516     {"Left Capture Mix", "HPL2REC Capture Switch", "HPL Mix"},
0517     {"Left Capture Mix", "SPK2REC_L Capture Switch", "Speaker Mix"},
0518     {"Left Capture Mix", "MONO2REC_L Capture Switch", "Mono Mix"},
0519 
0520     /*Right record mixer */
0521     {"Right Capture Mix", "LIR2REC Capture Switch", "LINEINR"},
0522     {"Right Capture Mix", "PH2REC_R Capture Switch", "PHONEP"},
0523     {"Right Capture Mix", "MIC12REC_R Capture Switch", "MIC1 Pre Amp"},
0524     {"Right Capture Mix", "MIC22REC_R Capture Switch", "MIC2 Pre Amp"},
0525     {"Right Capture Mix", "HPR2REC Capture Switch", "HPR Mix"},
0526     {"Right Capture Mix", "SPK2REC_R Capture Switch", "Speaker Mix"},
0527     {"Right Capture Mix", "MONO2REC_R Capture Switch", "Mono Mix"},
0528 
0529     /* headphone left mux */
0530     {"Left Headphone Mux", "HP Left Mix",       "HPL Mix"},
0531     {"Left Headphone Mux", "Vmid",          "Vmid"},
0532 
0533     /* headphone right mux */
0534     {"Right Headphone Mux", "HP Right Mix",     "HPR Mix"},
0535     {"Right Headphone Mux", "Vmid",         "Vmid"},
0536 
0537     /* speaker out mux */
0538     {"SpeakerOut Mux", "Vmid",          "Vmid"},
0539     {"SpeakerOut Mux", "HPOut Mix",         "HPOut Mix"},
0540     {"SpeakerOut Mux", "Speaker Mix",       "Speaker Mix"},
0541     {"SpeakerOut Mux", "Mono Mix",          "Mono Mix"},
0542 
0543     /* Mono/Aux Out mux */
0544     {"AuxOut Mux", "Vmid",              "Vmid"},
0545     {"AuxOut Mux", "HPOut Mix",         "HPOut Mix"},
0546     {"AuxOut Mux", "Speaker Mix",           "Speaker Mix"},
0547     {"AuxOut Mux", "Mono Mix",          "Mono Mix"},
0548 
0549     /* output pga */
0550     {"HPL", NULL,                   "Left Headphone"},
0551     {"Left Headphone", NULL,            "Left Headphone Mux"},
0552     {"HPR", NULL,                   "Right Headphone"},
0553     {"Right Headphone", NULL,           "Right Headphone Mux"},
0554     {"Aux Out", NULL,               "AuxOut Mux"},
0555 
0556     /* input pga */
0557     {"Left LineIn", NULL,               "LINEINL"},
0558     {"Right LineIn", NULL,              "LINEINR"},
0559     {"Phone", NULL,             "PHONEP"},
0560     {"MIC1 Pre Amp", NULL,              "MIC1"},
0561     {"MIC2 Pre Amp", NULL,              "MIC2"},
0562     {"MIC1 PGA", NULL,              "MIC1 Pre Amp"},
0563     {"MIC2 PGA", NULL,              "MIC2 Pre Amp"},
0564 
0565     /* left ADC */
0566     {"Left ADC", NULL,              "Left Capture Mix"},
0567     {"DMICL Mix", "DMICL2ADC Capture Switch", "DMICDAT"},
0568     {"Left ADC", NULL,              "DMICL Mix"},
0569     {"ADCLR", NULL,                 "Left ADC"},
0570 
0571     /* right ADC */
0572     {"Right ADC", NULL, "Right Capture Mix"},
0573     {"DMICR Mix", "DMICR2ADC Capture Switch", "DMICDAT"},
0574     {"Right ADC", NULL, "DMICR Mix"},
0575     {"ADCR Mux", "Stereo ADC", "Right ADC"},
0576     {"ADCR Mux", "Voice ADC", "Right ADC"},
0577     {"ADCLR", NULL, "ADCR Mux"},
0578     {"VAIFTX", NULL, "ADCR Mux"},
0579 
0580     /* Digital I2S out */
0581     {"I2SOut Mux", "ADC LR", "ADCLR"},
0582     {"I2SOut Mux", "Voice Stereo Digital", "VAIFRX"},
0583     {"AIFTXL", NULL, "I2SOut Mux"},
0584     {"AIFTXR", NULL, "I2SOut Mux"},
0585 
0586     /* Voice Mix */
0587     {"Voice DAC", NULL, "VAIFRX"},
0588     {"Voice Mix", NULL, "Voice DAC"},
0589 
0590     /* Speaker Output */
0591     {"SpeakerOut N Mux", "RN/-R",           "Left Speaker"},
0592     {"SpeakerOut N Mux", "RP/+R",           "Left Speaker"},
0593     {"SpeakerOut N Mux", "LN/-R",           "Left Speaker"},
0594     {"SpeakerOut N Mux", "Mute",            "Vmid"},
0595 
0596     {"SpeakerOut N Mux", "RN/-R",           "Right Speaker"},
0597     {"SpeakerOut N Mux", "RP/+R",           "Right Speaker"},
0598     {"SpeakerOut N Mux", "LN/-R",           "Right Speaker"},
0599     {"SpeakerOut N Mux", "Mute",            "Vmid"},
0600 
0601     {"AB Amp", NULL,                "SpeakerOut Mux"},
0602     {"D Amp", NULL,                 "SpeakerOut Mux"},
0603     {"AB-D Amp Mux", "AB Amp",          "AB Amp"},
0604     {"AB-D Amp Mux", "D Amp",           "D Amp"},
0605     {"Left Speaker", NULL,              "AB-D Amp Mux"},
0606     {"Right Speaker", NULL,             "AB-D Amp Mux"},
0607 
0608     {"SPKOUT", NULL,                "Left Speaker"},
0609     {"SPKOUT", NULL,                "Right Speaker"},
0610 
0611     {"SPKOUTN", NULL,               "SpeakerOut N Mux"},
0612 
0613 };
0614 
0615 /* PLL divisors */
0616 struct _pll_div {
0617     u32 pll_in;
0618     u32 pll_out;
0619     u16 regvalue;
0620 };
0621 
0622 /* Note : pll code from original alc5632 driver. Not sure of how good it is */
0623 /* useful only for master mode */
0624 static const struct _pll_div codec_master_pll_div[] = {
0625 
0626     {  2048000,  8192000,   0x0ea0},
0627     {  3686400,  8192000,   0x4e27},
0628     { 12000000,  8192000,   0x456b},
0629     { 13000000,  8192000,   0x495f},
0630     { 13100000,  8192000,   0x0320},
0631     {  2048000,  11289600,  0xf637},
0632     {  3686400,  11289600,  0x2f22},
0633     { 12000000,  11289600,  0x3e2f},
0634     { 13000000,  11289600,  0x4d5b},
0635     { 13100000,  11289600,  0x363b},
0636     {  2048000,  16384000,  0x1ea0},
0637     {  3686400,  16384000,  0x9e27},
0638     { 12000000,  16384000,  0x452b},
0639     { 13000000,  16384000,  0x542f},
0640     { 13100000,  16384000,  0x03a0},
0641     {  2048000,  16934400,  0xe625},
0642     {  3686400,  16934400,  0x9126},
0643     { 12000000,  16934400,  0x4d2c},
0644     { 13000000,  16934400,  0x742f},
0645     { 13100000,  16934400,  0x3c27},
0646     {  2048000,  22579200,  0x2aa0},
0647     {  3686400,  22579200,  0x2f20},
0648     { 12000000,  22579200,  0x7e2f},
0649     { 13000000,  22579200,  0x742f},
0650     { 13100000,  22579200,  0x3c27},
0651     {  2048000,  24576000,  0x2ea0},
0652     {  3686400,  24576000,  0xee27},
0653     { 12000000,  24576000,  0x2915},
0654     { 13000000,  24576000,  0x772e},
0655     { 13100000,  24576000,  0x0d20},
0656 };
0657 
0658 /* FOUT = MCLK*(N+2)/((M+2)*(K+2))
0659    N: bit 15:8 (div 2 .. div 257)
0660    K: bit  6:4 typical 2
0661    M: bit  3:0 (div 2 .. div 17)
0662 
0663    same as for 5623 - thanks!
0664 */
0665 
0666 static const struct _pll_div codec_slave_pll_div[] = {
0667 
0668     {  1024000,  16384000,  0x3ea0},
0669     {  1411200,  22579200,  0x3ea0},
0670     {  1536000,  24576000,  0x3ea0},
0671     {  2048000,  16384000,  0x1ea0},
0672     {  2822400,  22579200,  0x1ea0},
0673     {  3072000,  24576000,  0x1ea0},
0674 
0675 };
0676 
0677 static int alc5632_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
0678         int source, unsigned int freq_in, unsigned int freq_out)
0679 {
0680     int i;
0681     struct snd_soc_component *component = codec_dai->component;
0682     int gbl_clk = 0, pll_div = 0;
0683     u16 reg;
0684 
0685     if (pll_id < ALC5632_PLL_FR_MCLK || pll_id > ALC5632_PLL_FR_VBCLK)
0686         return -EINVAL;
0687 
0688     /* Disable PLL power */
0689     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0690                 ALC5632_PWR_ADD2_PLL1,
0691                 0);
0692     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0693                 ALC5632_PWR_ADD2_PLL2,
0694                 0);
0695 
0696     /* pll is not used in slave mode */
0697     reg = snd_soc_component_read(component, ALC5632_DAI_CONTROL);
0698     if (reg & ALC5632_DAI_SDP_SLAVE_MODE)
0699         return 0;
0700 
0701     if (!freq_in || !freq_out)
0702         return 0;
0703 
0704     switch (pll_id) {
0705     case ALC5632_PLL_FR_MCLK:
0706         for (i = 0; i < ARRAY_SIZE(codec_master_pll_div); i++) {
0707             if (codec_master_pll_div[i].pll_in == freq_in
0708                && codec_master_pll_div[i].pll_out == freq_out) {
0709                 /* PLL source from MCLK */
0710                 pll_div  = codec_master_pll_div[i].regvalue;
0711                 break;
0712             }
0713         }
0714         break;
0715     case ALC5632_PLL_FR_BCLK:
0716         for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) {
0717             if (codec_slave_pll_div[i].pll_in == freq_in
0718                && codec_slave_pll_div[i].pll_out == freq_out) {
0719                 /* PLL source from Bitclk */
0720                 gbl_clk = ALC5632_PLL_FR_BCLK;
0721                 pll_div = codec_slave_pll_div[i].regvalue;
0722                 break;
0723             }
0724         }
0725         break;
0726     case ALC5632_PLL_FR_VBCLK:
0727         for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) {
0728             if (codec_slave_pll_div[i].pll_in == freq_in
0729                && codec_slave_pll_div[i].pll_out == freq_out) {
0730                 /* PLL source from voice clock */
0731                 gbl_clk = ALC5632_PLL_FR_VBCLK;
0732                 pll_div = codec_slave_pll_div[i].regvalue;
0733                 break;
0734             }
0735         }
0736         break;
0737     default:
0738         return -EINVAL;
0739     }
0740 
0741     if (!pll_div)
0742         return -EINVAL;
0743 
0744     /* choose MCLK/BCLK/VBCLK */
0745     snd_soc_component_write(component, ALC5632_GPCR2, gbl_clk);
0746     /* choose PLL1 clock rate */
0747     snd_soc_component_write(component, ALC5632_PLL1_CTRL, pll_div);
0748     /* enable PLL1 */
0749     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0750                 ALC5632_PWR_ADD2_PLL1,
0751                 ALC5632_PWR_ADD2_PLL1);
0752     /* enable PLL2 */
0753     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0754                 ALC5632_PWR_ADD2_PLL2,
0755                 ALC5632_PWR_ADD2_PLL2);
0756     /* use PLL1 as main SYSCLK */
0757     snd_soc_component_update_bits(component, ALC5632_GPCR1,
0758             ALC5632_GPCR1_CLK_SYS_SRC_SEL_PLL1,
0759             ALC5632_GPCR1_CLK_SYS_SRC_SEL_PLL1);
0760 
0761     return 0;
0762 }
0763 
0764 struct _coeff_div {
0765     u16 fs;
0766     u16 regvalue;
0767 };
0768 
0769 /* codec hifi mclk (after PLL) clock divider coefficients */
0770 /* values inspired from column BCLK=32Fs of Appendix A table */
0771 static const struct _coeff_div coeff_div[] = {
0772     {512*1, 0x3075},
0773 };
0774 
0775 static int get_coeff(struct snd_soc_component *component, int rate)
0776 {
0777     struct alc5632_priv *alc5632 = snd_soc_component_get_drvdata(component);
0778     int i;
0779 
0780     for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
0781         if (coeff_div[i].fs * rate == alc5632->sysclk)
0782             return i;
0783     }
0784     return -EINVAL;
0785 }
0786 
0787 /*
0788  * Clock after PLL and dividers
0789  */
0790 static int alc5632_set_dai_sysclk(struct snd_soc_dai *codec_dai,
0791         int clk_id, unsigned int freq, int dir)
0792 {
0793     struct snd_soc_component *component = codec_dai->component;
0794     struct alc5632_priv *alc5632 = snd_soc_component_get_drvdata(component);
0795 
0796     switch (freq) {
0797     case  4096000:
0798     case  8192000:
0799     case 11289600:
0800     case 12288000:
0801     case 16384000:
0802     case 16934400:
0803     case 18432000:
0804     case 22579200:
0805     case 24576000:
0806         alc5632->sysclk = freq;
0807         return 0;
0808     }
0809     return -EINVAL;
0810 }
0811 
0812 static int alc5632_set_dai_fmt(struct snd_soc_dai *codec_dai,
0813         unsigned int fmt)
0814 {
0815     struct snd_soc_component *component = codec_dai->component;
0816     u16 iface = 0;
0817 
0818     /* set audio interface clocking */
0819     switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
0820     case SND_SOC_DAIFMT_CBP_CFP:
0821         iface = ALC5632_DAI_SDP_MASTER_MODE;
0822         break;
0823     case SND_SOC_DAIFMT_CBC_CFC:
0824         iface = ALC5632_DAI_SDP_SLAVE_MODE;
0825         break;
0826     default:
0827         return -EINVAL;
0828     }
0829 
0830     /* interface format */
0831     switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
0832     case SND_SOC_DAIFMT_I2S:
0833         iface |= ALC5632_DAI_I2S_DF_I2S;
0834         break;
0835     case SND_SOC_DAIFMT_LEFT_J:
0836         iface |= ALC5632_DAI_I2S_DF_LEFT;
0837         break;
0838     case SND_SOC_DAIFMT_DSP_A:
0839         iface |= ALC5632_DAI_I2S_DF_PCM_A;
0840         break;
0841     case SND_SOC_DAIFMT_DSP_B:
0842         iface |= ALC5632_DAI_I2S_DF_PCM_B;
0843         break;
0844     default:
0845         return -EINVAL;
0846     }
0847 
0848     /* clock inversion */
0849     switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
0850     case SND_SOC_DAIFMT_NB_NF:
0851         break;
0852     case SND_SOC_DAIFMT_IB_IF:
0853         iface |= ALC5632_DAI_MAIN_I2S_BCLK_POL_CTRL;
0854         break;
0855     case SND_SOC_DAIFMT_IB_NF:
0856         iface |= ALC5632_DAI_MAIN_I2S_BCLK_POL_CTRL;
0857         break;
0858     case SND_SOC_DAIFMT_NB_IF:
0859         break;
0860     default:
0861         return -EINVAL;
0862     }
0863 
0864     return snd_soc_component_write(component, ALC5632_DAI_CONTROL, iface);
0865 }
0866 
0867 static int alc5632_pcm_hw_params(struct snd_pcm_substream *substream,
0868         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
0869 {
0870     struct snd_soc_component *component = dai->component;
0871     int coeff, rate;
0872     u16 iface;
0873 
0874     iface = snd_soc_component_read(component, ALC5632_DAI_CONTROL);
0875     iface &= ~ALC5632_DAI_I2S_DL_MASK;
0876 
0877     /* bit size */
0878     switch (params_width(params)) {
0879     case 16:
0880         iface |= ALC5632_DAI_I2S_DL_16;
0881         break;
0882     case 20:
0883         iface |= ALC5632_DAI_I2S_DL_20;
0884         break;
0885     case 24:
0886         iface |= ALC5632_DAI_I2S_DL_24;
0887         break;
0888     default:
0889         return -EINVAL;
0890     }
0891 
0892     /* set iface & srate */
0893     snd_soc_component_write(component, ALC5632_DAI_CONTROL, iface);
0894     rate = params_rate(params);
0895     coeff = get_coeff(component, rate);
0896     if (coeff < 0)
0897         return -EINVAL;
0898 
0899     coeff = coeff_div[coeff].regvalue;
0900     snd_soc_component_write(component, ALC5632_DAC_CLK_CTRL1, coeff);
0901 
0902     return 0;
0903 }
0904 
0905 static int alc5632_mute(struct snd_soc_dai *dai, int mute, int direction)
0906 {
0907     struct snd_soc_component *component = dai->component;
0908     u16 hp_mute = ALC5632_MISC_HP_DEPOP_MUTE_L
0909                         |ALC5632_MISC_HP_DEPOP_MUTE_R;
0910     u16 mute_reg = snd_soc_component_read(component, ALC5632_MISC_CTRL) & ~hp_mute;
0911 
0912     if (mute)
0913         mute_reg |= hp_mute;
0914 
0915     return snd_soc_component_write(component, ALC5632_MISC_CTRL, mute_reg);
0916 }
0917 
0918 #define ALC5632_ADD2_POWER_EN (ALC5632_PWR_ADD2_VREF)
0919 
0920 #define ALC5632_ADD3_POWER_EN (ALC5632_PWR_ADD3_MIC1_BOOST_AD)
0921 
0922 #define ALC5632_ADD1_POWER_EN \
0923         (ALC5632_PWR_ADD1_DAC_REF \
0924         | ALC5632_PWR_ADD1_SOFTGEN_EN \
0925         | ALC5632_PWR_ADD1_HP_OUT_AMP \
0926         | ALC5632_PWR_ADD1_HP_OUT_ENH_AMP \
0927         | ALC5632_PWR_ADD1_MAIN_BIAS)
0928 
0929 static void enable_power_depop(struct snd_soc_component *component)
0930 {
0931     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD1,
0932                 ALC5632_PWR_ADD1_SOFTGEN_EN,
0933                 ALC5632_PWR_ADD1_SOFTGEN_EN);
0934 
0935     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD3,
0936                 ALC5632_ADD3_POWER_EN,
0937                 ALC5632_ADD3_POWER_EN);
0938 
0939     snd_soc_component_update_bits(component, ALC5632_MISC_CTRL,
0940                 ALC5632_MISC_HP_DEPOP_MODE2_EN,
0941                 ALC5632_MISC_HP_DEPOP_MODE2_EN);
0942 
0943     /* "normal" mode: 0 @ 26 */
0944     /* set all PR0-7 mixers to 0 */
0945     snd_soc_component_update_bits(component, ALC5632_PWR_DOWN_CTRL_STATUS,
0946                 ALC5632_PWR_DOWN_CTRL_STATUS_MASK,
0947                 0);
0948 
0949     msleep(500);
0950 
0951     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0952                 ALC5632_ADD2_POWER_EN,
0953                 ALC5632_ADD2_POWER_EN);
0954 
0955     snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD1,
0956                 ALC5632_ADD1_POWER_EN,
0957                 ALC5632_ADD1_POWER_EN);
0958 
0959     /* disable HP Depop2 */
0960     snd_soc_component_update_bits(component, ALC5632_MISC_CTRL,
0961                 ALC5632_MISC_HP_DEPOP_MODE2_EN,
0962                 0);
0963 
0964 }
0965 
0966 static int alc5632_set_bias_level(struct snd_soc_component *component,
0967                       enum snd_soc_bias_level level)
0968 {
0969     switch (level) {
0970     case SND_SOC_BIAS_ON:
0971         enable_power_depop(component);
0972         break;
0973     case SND_SOC_BIAS_PREPARE:
0974         break;
0975     case SND_SOC_BIAS_STANDBY:
0976         /* everything off except vref/vmid, */
0977         snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD1,
0978                 ALC5632_PWR_MANAG_ADD1_MASK,
0979                 ALC5632_PWR_ADD1_MAIN_BIAS);
0980         snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0981                 ALC5632_PWR_MANAG_ADD2_MASK,
0982                 ALC5632_PWR_ADD2_VREF);
0983         /* "normal" mode: 0 @ 26 */
0984         snd_soc_component_update_bits(component, ALC5632_PWR_DOWN_CTRL_STATUS,
0985                 ALC5632_PWR_DOWN_CTRL_STATUS_MASK,
0986                 0xffff ^ (ALC5632_PWR_VREF_PR3
0987                 | ALC5632_PWR_VREF_PR2));
0988         break;
0989     case SND_SOC_BIAS_OFF:
0990         /* everything off, dac mute, inactive */
0991         snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD2,
0992                 ALC5632_PWR_MANAG_ADD2_MASK, 0);
0993         snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD3,
0994                 ALC5632_PWR_MANAG_ADD3_MASK, 0);
0995         snd_soc_component_update_bits(component, ALC5632_PWR_MANAG_ADD1,
0996                 ALC5632_PWR_MANAG_ADD1_MASK, 0);
0997         break;
0998     }
0999     return 0;
1000 }
1001 
1002 #define ALC5632_FORMATS (SNDRV_PCM_FMTBIT_S16_LE \
1003             | SNDRV_PCM_FMTBIT_S24_LE \
1004             | SNDRV_PCM_FMTBIT_S32_LE)
1005 
1006 static const struct snd_soc_dai_ops alc5632_dai_ops = {
1007         .hw_params = alc5632_pcm_hw_params,
1008         .mute_stream = alc5632_mute,
1009         .set_fmt = alc5632_set_dai_fmt,
1010         .set_sysclk = alc5632_set_dai_sysclk,
1011         .set_pll = alc5632_set_dai_pll,
1012         .no_capture_mute = 1,
1013 };
1014 
1015 static struct snd_soc_dai_driver alc5632_dai = {
1016     .name = "alc5632-hifi",
1017     .playback = {
1018         .stream_name = "HiFi Playback",
1019         .channels_min = 1,
1020         .channels_max = 2,
1021         .rate_min = 8000,
1022         .rate_max = 48000,
1023         .rates = SNDRV_PCM_RATE_8000_48000,
1024         .formats = ALC5632_FORMATS,},
1025     .capture = {
1026         .stream_name = "HiFi Capture",
1027         .channels_min = 1,
1028         .channels_max = 2,
1029         .rate_min = 8000,
1030         .rate_max = 48000,
1031         .rates = SNDRV_PCM_RATE_8000_48000,
1032         .formats = ALC5632_FORMATS,},
1033 
1034     .ops = &alc5632_dai_ops,
1035     .symmetric_rate = 1,
1036 };
1037 
1038 #ifdef CONFIG_PM
1039 static int alc5632_resume(struct snd_soc_component *component)
1040 {
1041     struct alc5632_priv *alc5632 = snd_soc_component_get_drvdata(component);
1042 
1043     regcache_sync(alc5632->regmap);
1044 
1045     return 0;
1046 }
1047 #else
1048 #define alc5632_resume  NULL
1049 #endif
1050 
1051 static int alc5632_probe(struct snd_soc_component *component)
1052 {
1053     struct alc5632_priv *alc5632 = snd_soc_component_get_drvdata(component);
1054 
1055     switch (alc5632->id) {
1056     case 0x5c:
1057         snd_soc_add_component_controls(component, alc5632_vol_snd_controls,
1058             ARRAY_SIZE(alc5632_vol_snd_controls));
1059         break;
1060     default:
1061         return -EINVAL;
1062     }
1063 
1064     return 0;
1065 }
1066 
1067 static const struct snd_soc_component_driver soc_component_device_alc5632 = {
1068     .probe          = alc5632_probe,
1069     .resume         = alc5632_resume,
1070     .set_bias_level     = alc5632_set_bias_level,
1071     .controls       = alc5632_snd_controls,
1072     .num_controls       = ARRAY_SIZE(alc5632_snd_controls),
1073     .dapm_widgets       = alc5632_dapm_widgets,
1074     .num_dapm_widgets   = ARRAY_SIZE(alc5632_dapm_widgets),
1075     .dapm_routes        = alc5632_dapm_routes,
1076     .num_dapm_routes    = ARRAY_SIZE(alc5632_dapm_routes),
1077     .suspend_bias_off   = 1,
1078     .idle_bias_on       = 1,
1079     .use_pmdown_time    = 1,
1080     .endianness     = 1,
1081 };
1082 
1083 static const struct regmap_config alc5632_regmap = {
1084     .reg_bits = 8,
1085     .val_bits = 16,
1086 
1087     .max_register = ALC5632_MAX_REGISTER,
1088     .reg_defaults = alc5632_reg_defaults,
1089     .num_reg_defaults = ARRAY_SIZE(alc5632_reg_defaults),
1090     .volatile_reg = alc5632_volatile_register,
1091     .cache_type = REGCACHE_RBTREE,
1092 };
1093 
1094 static const struct i2c_device_id alc5632_i2c_table[] = {
1095     {"alc5632", 0x5c},
1096     {}
1097 };
1098 MODULE_DEVICE_TABLE(i2c, alc5632_i2c_table);
1099 
1100 /*
1101  * alc5632 2 wire address is determined by A1 pin
1102  * state during powerup.
1103  *    low  = 0x1a
1104  *    high = 0x1b
1105  */
1106 static int alc5632_i2c_probe(struct i2c_client *client)
1107 {
1108     struct alc5632_priv *alc5632;
1109     int ret, ret1, ret2;
1110     unsigned int vid1, vid2;
1111     const struct i2c_device_id *id;
1112 
1113     alc5632 = devm_kzalloc(&client->dev,
1114              sizeof(struct alc5632_priv), GFP_KERNEL);
1115     if (alc5632 == NULL)
1116         return -ENOMEM;
1117 
1118     i2c_set_clientdata(client, alc5632);
1119 
1120     alc5632->regmap = devm_regmap_init_i2c(client, &alc5632_regmap);
1121     if (IS_ERR(alc5632->regmap)) {
1122         ret = PTR_ERR(alc5632->regmap);
1123         dev_err(&client->dev, "regmap_init() failed: %d\n", ret);
1124         return ret;
1125     }
1126 
1127     ret1 = regmap_read(alc5632->regmap, ALC5632_VENDOR_ID1, &vid1);
1128     ret2 = regmap_read(alc5632->regmap, ALC5632_VENDOR_ID2, &vid2);
1129     if (ret1 != 0 || ret2 != 0) {
1130         dev_err(&client->dev,
1131         "Failed to read chip ID: ret1=%d, ret2=%d\n", ret1, ret2);
1132         return -EIO;
1133     }
1134 
1135     vid2 >>= 8;
1136 
1137     id = i2c_match_id(alc5632_i2c_table, client);
1138 
1139     if ((vid1 != 0x10EC) || (vid2 != id->driver_data)) {
1140         dev_err(&client->dev,
1141         "Device is not a ALC5632: VID1=0x%x, VID2=0x%x\n", vid1, vid2);
1142         return -EINVAL;
1143     }
1144 
1145     ret = alc5632_reset(alc5632->regmap);
1146     if (ret < 0) {
1147         dev_err(&client->dev, "Failed to issue reset\n");
1148         return ret;
1149     }
1150 
1151     alc5632->id = vid2;
1152     switch (alc5632->id) {
1153     case 0x5c:
1154         alc5632_dai.name = "alc5632-hifi";
1155         break;
1156     default:
1157         return -EINVAL;
1158     }
1159 
1160     ret = devm_snd_soc_register_component(&client->dev,
1161         &soc_component_device_alc5632, &alc5632_dai, 1);
1162 
1163     if (ret < 0) {
1164         dev_err(&client->dev, "Failed to register component: %d\n", ret);
1165         return ret;
1166     }
1167 
1168     return ret;
1169 }
1170 
1171 #ifdef CONFIG_OF
1172 static const struct of_device_id alc5632_of_match[] = {
1173     { .compatible = "realtek,alc5632", },
1174     { }
1175 };
1176 MODULE_DEVICE_TABLE(of, alc5632_of_match);
1177 #endif
1178 
1179 /* i2c codec control layer */
1180 static struct i2c_driver alc5632_i2c_driver = {
1181     .driver = {
1182         .name = "alc5632",
1183         .of_match_table = of_match_ptr(alc5632_of_match),
1184     },
1185     .probe_new = alc5632_i2c_probe,
1186     .id_table = alc5632_i2c_table,
1187 };
1188 
1189 module_i2c_driver(alc5632_i2c_driver);
1190 
1191 MODULE_DESCRIPTION("ASoC ALC5632 driver");
1192 MODULE_AUTHOR("Leon Romanovsky <leon@leon.nu>");
1193 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!