Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 //
0003 // File:         sound/soc/codecs/ssm2602.c
0004 // Author:       Cliff Cai <Cliff.Cai@analog.com>
0005 //
0006 // Created:      Tue June 06 2008
0007 // Description:  Driver for ssm2602 sound chip
0008 //
0009 // Modified:
0010 //               Copyright 2008 Analog Devices Inc.
0011 //
0012 // Bugs:         Enter bugs at http://blackfin.uclinux.org/
0013 
0014 #include <linux/delay.h>
0015 #include <linux/module.h>
0016 #include <linux/regmap.h>
0017 #include <linux/slab.h>
0018 
0019 #include <sound/pcm.h>
0020 #include <sound/pcm_params.h>
0021 #include <sound/soc.h>
0022 #include <sound/tlv.h>
0023 
0024 #include "ssm2602.h"
0025 
0026 /* codec private data */
0027 struct ssm2602_priv {
0028     unsigned int sysclk;
0029     const struct snd_pcm_hw_constraint_list *sysclk_constraints;
0030 
0031     struct regmap *regmap;
0032 
0033     enum ssm2602_type type;
0034     unsigned int clk_out_pwr;
0035 };
0036 
0037 /*
0038  * ssm2602 register cache
0039  * We can't read the ssm2602 register space when we are
0040  * using 2 wire for device control, so we cache them instead.
0041  * There is no point in caching the reset register
0042  */
0043 static const struct reg_default ssm2602_reg[SSM2602_CACHEREGNUM] = {
0044     { .reg = 0x00, .def = 0x0097 },
0045     { .reg = 0x01, .def = 0x0097 },
0046     { .reg = 0x02, .def = 0x0079 },
0047     { .reg = 0x03, .def = 0x0079 },
0048     { .reg = 0x04, .def = 0x000a },
0049     { .reg = 0x05, .def = 0x0008 },
0050     { .reg = 0x06, .def = 0x009f },
0051     { .reg = 0x07, .def = 0x000a },
0052     { .reg = 0x08, .def = 0x0000 },
0053     { .reg = 0x09, .def = 0x0000 }
0054 };
0055 
0056 
0057 /*Appending several "None"s just for OSS mixer use*/
0058 static const char *ssm2602_input_select[] = {
0059     "Line", "Mic",
0060 };
0061 
0062 static const char *ssm2602_deemph[] = {"None", "32Khz", "44.1Khz", "48Khz"};
0063 
0064 static const struct soc_enum ssm2602_enum[] = {
0065     SOC_ENUM_SINGLE(SSM2602_APANA, 2, ARRAY_SIZE(ssm2602_input_select),
0066             ssm2602_input_select),
0067     SOC_ENUM_SINGLE(SSM2602_APDIGI, 1, ARRAY_SIZE(ssm2602_deemph),
0068             ssm2602_deemph),
0069 };
0070 
0071 static const DECLARE_TLV_DB_RANGE(ssm260x_outmix_tlv,
0072     0, 47, TLV_DB_SCALE_ITEM(TLV_DB_GAIN_MUTE, 0, 0),
0073     48, 127, TLV_DB_SCALE_ITEM(-7400, 100, 0)
0074 );
0075 
0076 static const DECLARE_TLV_DB_SCALE(ssm260x_inpga_tlv, -3450, 150, 0);
0077 static const DECLARE_TLV_DB_SCALE(ssm260x_sidetone_tlv, -1500, 300, 0);
0078 
0079 static const struct snd_kcontrol_new ssm260x_snd_controls[] = {
0080 SOC_DOUBLE_R_TLV("Capture Volume", SSM2602_LINVOL, SSM2602_RINVOL, 0, 45, 0,
0081     ssm260x_inpga_tlv),
0082 SOC_DOUBLE_R("Capture Switch", SSM2602_LINVOL, SSM2602_RINVOL, 7, 1, 1),
0083 
0084 SOC_SINGLE("ADC High Pass Filter Switch", SSM2602_APDIGI, 0, 1, 1),
0085 SOC_SINGLE("Store DC Offset Switch", SSM2602_APDIGI, 4, 1, 0),
0086 
0087 SOC_ENUM("Playback De-emphasis", ssm2602_enum[1]),
0088 };
0089 
0090 static const struct snd_kcontrol_new ssm2602_snd_controls[] = {
0091 SOC_DOUBLE_R_TLV("Master Playback Volume", SSM2602_LOUT1V, SSM2602_ROUT1V,
0092     0, 127, 0, ssm260x_outmix_tlv),
0093 SOC_DOUBLE_R("Master Playback ZC Switch", SSM2602_LOUT1V, SSM2602_ROUT1V,
0094     7, 1, 0),
0095 SOC_SINGLE_TLV("Sidetone Playback Volume", SSM2602_APANA, 6, 3, 1,
0096     ssm260x_sidetone_tlv),
0097 
0098 SOC_SINGLE("Mic Boost (+20dB)", SSM2602_APANA, 0, 1, 0),
0099 SOC_SINGLE("Mic Boost2 (+20dB)", SSM2602_APANA, 8, 1, 0),
0100 };
0101 
0102 /* Output Mixer */
0103 static const struct snd_kcontrol_new ssm260x_output_mixer_controls[] = {
0104 SOC_DAPM_SINGLE("Line Bypass Switch", SSM2602_APANA, 3, 1, 0),
0105 SOC_DAPM_SINGLE("HiFi Playback Switch", SSM2602_APANA, 4, 1, 0),
0106 SOC_DAPM_SINGLE("Mic Sidetone Switch", SSM2602_APANA, 5, 1, 0),
0107 };
0108 
0109 static const struct snd_kcontrol_new mic_ctl =
0110     SOC_DAPM_SINGLE("Switch", SSM2602_APANA, 1, 1, 1);
0111 
0112 /* Input mux */
0113 static const struct snd_kcontrol_new ssm2602_input_mux_controls =
0114 SOC_DAPM_ENUM("Input Select", ssm2602_enum[0]);
0115 
0116 static int ssm2602_mic_switch_event(struct snd_soc_dapm_widget *w,
0117                 struct snd_kcontrol *kcontrol, int event)
0118 {
0119     /*
0120      * According to the ssm2603 data sheet (control register sequencing),
0121      * the digital core should be activated only after all necessary bits
0122      * in the power register are enabled, and a delay determined by the
0123      * decoupling capacitor on the VMID pin has passed. If the digital core
0124      * is activated too early, or even before the ADC is powered up, audible
0125      * artifacts appear at the beginning and end of the recorded signal.
0126      *
0127      * In practice, audible artifacts disappear well over 500 ms.
0128      */
0129     msleep(500);
0130 
0131     return 0;
0132 }
0133 
0134 static const struct snd_soc_dapm_widget ssm260x_dapm_widgets[] = {
0135 SND_SOC_DAPM_DAC("DAC", "HiFi Playback", SSM2602_PWR, 3, 1),
0136 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", SSM2602_PWR, 2, 1),
0137 SND_SOC_DAPM_PGA("Line Input", SSM2602_PWR, 0, 1, NULL, 0),
0138 
0139 SND_SOC_DAPM_SUPPLY("Digital Core Power", SSM2602_ACTIVE, 0, 0, NULL, 0),
0140 
0141 SND_SOC_DAPM_OUTPUT("LOUT"),
0142 SND_SOC_DAPM_OUTPUT("ROUT"),
0143 SND_SOC_DAPM_INPUT("RLINEIN"),
0144 SND_SOC_DAPM_INPUT("LLINEIN"),
0145 };
0146 
0147 static const struct snd_soc_dapm_widget ssm2602_dapm_widgets[] = {
0148 SND_SOC_DAPM_MIXER("Output Mixer", SSM2602_PWR, 4, 1,
0149     ssm260x_output_mixer_controls,
0150     ARRAY_SIZE(ssm260x_output_mixer_controls)),
0151 
0152 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, &ssm2602_input_mux_controls),
0153 SND_SOC_DAPM_MICBIAS("Mic Bias", SSM2602_PWR, 1, 1),
0154 
0155 SND_SOC_DAPM_SWITCH_E("Mic Switch", SSM2602_APANA, 1, 1, &mic_ctl,
0156         ssm2602_mic_switch_event, SND_SOC_DAPM_PRE_PMU),
0157 
0158 SND_SOC_DAPM_OUTPUT("LHPOUT"),
0159 SND_SOC_DAPM_OUTPUT("RHPOUT"),
0160 SND_SOC_DAPM_INPUT("MICIN"),
0161 };
0162 
0163 static const struct snd_soc_dapm_widget ssm2604_dapm_widgets[] = {
0164 SND_SOC_DAPM_MIXER("Output Mixer", SND_SOC_NOPM, 0, 0,
0165     ssm260x_output_mixer_controls,
0166     ARRAY_SIZE(ssm260x_output_mixer_controls) - 1), /* Last element is the mic */
0167 };
0168 
0169 static const struct snd_soc_dapm_route ssm260x_routes[] = {
0170     {"DAC", NULL, "Digital Core Power"},
0171     {"ADC", NULL, "Digital Core Power"},
0172 
0173     {"Output Mixer", "Line Bypass Switch", "Line Input"},
0174     {"Output Mixer", "HiFi Playback Switch", "DAC"},
0175 
0176     {"ROUT", NULL, "Output Mixer"},
0177     {"LOUT", NULL, "Output Mixer"},
0178 
0179     {"Line Input", NULL, "LLINEIN"},
0180     {"Line Input", NULL, "RLINEIN"},
0181 };
0182 
0183 static const struct snd_soc_dapm_route ssm2602_routes[] = {
0184     {"Output Mixer", "Mic Sidetone Switch", "Mic Bias"},
0185 
0186     {"RHPOUT", NULL, "Output Mixer"},
0187     {"LHPOUT", NULL, "Output Mixer"},
0188 
0189     {"Input Mux", "Line", "Line Input"},
0190     {"Input Mux", "Mic", "Mic Switch"},
0191     {"ADC", NULL, "Input Mux"},
0192 
0193     {"Mic Switch", NULL, "Mic Bias"},
0194 
0195     {"Mic Bias", NULL, "MICIN"},
0196 };
0197 
0198 static const struct snd_soc_dapm_route ssm2604_routes[] = {
0199     {"ADC", NULL, "Line Input"},
0200 };
0201 
0202 static const unsigned int ssm2602_rates_12288000[] = {
0203     8000, 16000, 32000, 48000, 96000,
0204 };
0205 
0206 static const struct snd_pcm_hw_constraint_list ssm2602_constraints_12288000 = {
0207     .list = ssm2602_rates_12288000,
0208     .count = ARRAY_SIZE(ssm2602_rates_12288000),
0209 };
0210 
0211 static const unsigned int ssm2602_rates_11289600[] = {
0212     8000, 11025, 22050, 44100, 88200,
0213 };
0214 
0215 static const struct snd_pcm_hw_constraint_list ssm2602_constraints_11289600 = {
0216     .list = ssm2602_rates_11289600,
0217     .count = ARRAY_SIZE(ssm2602_rates_11289600),
0218 };
0219 
0220 struct ssm2602_coeff {
0221     u32 mclk;
0222     u32 rate;
0223     u8 srate;
0224 };
0225 
0226 #define SSM2602_COEFF_SRATE(sr, bosr, usb) (((sr) << 2) | ((bosr) << 1) | (usb))
0227 
0228 /* codec mclk clock coefficients */
0229 static const struct ssm2602_coeff ssm2602_coeff_table[] = {
0230     /* 48k */
0231     {12288000, 48000, SSM2602_COEFF_SRATE(0x0, 0x0, 0x0)},
0232     {18432000, 48000, SSM2602_COEFF_SRATE(0x0, 0x1, 0x0)},
0233     {12000000, 48000, SSM2602_COEFF_SRATE(0x0, 0x0, 0x1)},
0234 
0235     /* 32k */
0236     {12288000, 32000, SSM2602_COEFF_SRATE(0x6, 0x0, 0x0)},
0237     {18432000, 32000, SSM2602_COEFF_SRATE(0x6, 0x1, 0x0)},
0238     {12000000, 32000, SSM2602_COEFF_SRATE(0x6, 0x0, 0x1)},
0239 
0240     /* 16k */
0241     {12288000, 16000, SSM2602_COEFF_SRATE(0x5, 0x0, 0x0)},
0242     {18432000, 16000, SSM2602_COEFF_SRATE(0x5, 0x1, 0x0)},
0243     {12000000, 16000, SSM2602_COEFF_SRATE(0xa, 0x0, 0x1)},
0244 
0245     /* 8k */
0246     {12288000, 8000, SSM2602_COEFF_SRATE(0x3, 0x0, 0x0)},
0247     {18432000, 8000, SSM2602_COEFF_SRATE(0x3, 0x1, 0x0)},
0248     {11289600, 8000, SSM2602_COEFF_SRATE(0xb, 0x0, 0x0)},
0249     {16934400, 8000, SSM2602_COEFF_SRATE(0xb, 0x1, 0x0)},
0250     {12000000, 8000, SSM2602_COEFF_SRATE(0x3, 0x0, 0x1)},
0251 
0252     /* 96k */
0253     {12288000, 96000, SSM2602_COEFF_SRATE(0x7, 0x0, 0x0)},
0254     {18432000, 96000, SSM2602_COEFF_SRATE(0x7, 0x1, 0x0)},
0255     {12000000, 96000, SSM2602_COEFF_SRATE(0x7, 0x0, 0x1)},
0256 
0257     /* 11.025k */
0258     {11289600, 11025, SSM2602_COEFF_SRATE(0xc, 0x0, 0x0)},
0259     {16934400, 11025, SSM2602_COEFF_SRATE(0xc, 0x1, 0x0)},
0260     {12000000, 11025, SSM2602_COEFF_SRATE(0xc, 0x1, 0x1)},
0261 
0262     /* 22.05k */
0263     {11289600, 22050, SSM2602_COEFF_SRATE(0xd, 0x0, 0x0)},
0264     {16934400, 22050, SSM2602_COEFF_SRATE(0xd, 0x1, 0x0)},
0265     {12000000, 22050, SSM2602_COEFF_SRATE(0xd, 0x1, 0x1)},
0266 
0267     /* 44.1k */
0268     {11289600, 44100, SSM2602_COEFF_SRATE(0x8, 0x0, 0x0)},
0269     {16934400, 44100, SSM2602_COEFF_SRATE(0x8, 0x1, 0x0)},
0270     {12000000, 44100, SSM2602_COEFF_SRATE(0x8, 0x1, 0x1)},
0271 
0272     /* 88.2k */
0273     {11289600, 88200, SSM2602_COEFF_SRATE(0xf, 0x0, 0x0)},
0274     {16934400, 88200, SSM2602_COEFF_SRATE(0xf, 0x1, 0x0)},
0275     {12000000, 88200, SSM2602_COEFF_SRATE(0xf, 0x1, 0x1)},
0276 };
0277 
0278 static inline int ssm2602_get_coeff(int mclk, int rate)
0279 {
0280     int i;
0281 
0282     for (i = 0; i < ARRAY_SIZE(ssm2602_coeff_table); i++) {
0283         if (ssm2602_coeff_table[i].rate == rate &&
0284             ssm2602_coeff_table[i].mclk == mclk)
0285             return ssm2602_coeff_table[i].srate;
0286     }
0287     return -EINVAL;
0288 }
0289 
0290 static int ssm2602_hw_params(struct snd_pcm_substream *substream,
0291     struct snd_pcm_hw_params *params,
0292     struct snd_soc_dai *dai)
0293 {
0294     struct snd_soc_component *component = dai->component;
0295     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0296     int srate = ssm2602_get_coeff(ssm2602->sysclk, params_rate(params));
0297     unsigned int iface;
0298 
0299     if (srate < 0)
0300         return srate;
0301 
0302     regmap_write(ssm2602->regmap, SSM2602_SRATE, srate);
0303 
0304     /* bit size */
0305     switch (params_width(params)) {
0306     case 16:
0307         iface = 0x0;
0308         break;
0309     case 20:
0310         iface = 0x4;
0311         break;
0312     case 24:
0313         iface = 0x8;
0314         break;
0315     case 32:
0316         iface = 0xc;
0317         break;
0318     default:
0319         return -EINVAL;
0320     }
0321     regmap_update_bits(ssm2602->regmap, SSM2602_IFACE,
0322         IFACE_AUDIO_DATA_LEN, iface);
0323     return 0;
0324 }
0325 
0326 static int ssm2602_startup(struct snd_pcm_substream *substream,
0327                struct snd_soc_dai *dai)
0328 {
0329     struct snd_soc_component *component = dai->component;
0330     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0331 
0332     if (ssm2602->sysclk_constraints) {
0333         snd_pcm_hw_constraint_list(substream->runtime, 0,
0334                    SNDRV_PCM_HW_PARAM_RATE,
0335                    ssm2602->sysclk_constraints);
0336     }
0337 
0338     return 0;
0339 }
0340 
0341 static int ssm2602_mute(struct snd_soc_dai *dai, int mute, int direction)
0342 {
0343     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(dai->component);
0344 
0345     if (mute)
0346         regmap_update_bits(ssm2602->regmap, SSM2602_APDIGI,
0347                     APDIGI_ENABLE_DAC_MUTE,
0348                     APDIGI_ENABLE_DAC_MUTE);
0349     else
0350         regmap_update_bits(ssm2602->regmap, SSM2602_APDIGI,
0351                     APDIGI_ENABLE_DAC_MUTE, 0);
0352     return 0;
0353 }
0354 
0355 static int ssm2602_set_dai_sysclk(struct snd_soc_dai *codec_dai,
0356         int clk_id, unsigned int freq, int dir)
0357 {
0358     struct snd_soc_component *component = codec_dai->component;
0359     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0360 
0361     if (dir == SND_SOC_CLOCK_IN) {
0362         if (clk_id != SSM2602_SYSCLK)
0363             return -EINVAL;
0364 
0365         switch (freq) {
0366         case 12288000:
0367         case 18432000:
0368             ssm2602->sysclk_constraints = &ssm2602_constraints_12288000;
0369             break;
0370         case 11289600:
0371         case 16934400:
0372             ssm2602->sysclk_constraints = &ssm2602_constraints_11289600;
0373             break;
0374         case 12000000:
0375             ssm2602->sysclk_constraints = NULL;
0376             break;
0377         default:
0378             return -EINVAL;
0379         }
0380         ssm2602->sysclk = freq;
0381     } else {
0382         unsigned int mask;
0383 
0384         switch (clk_id) {
0385         case SSM2602_CLK_CLKOUT:
0386             mask = PWR_CLK_OUT_PDN;
0387             break;
0388         case SSM2602_CLK_XTO:
0389             mask = PWR_OSC_PDN;
0390             break;
0391         default:
0392             return -EINVAL;
0393         }
0394 
0395         if (freq == 0)
0396             ssm2602->clk_out_pwr |= mask;
0397         else
0398             ssm2602->clk_out_pwr &= ~mask;
0399 
0400         regmap_update_bits(ssm2602->regmap, SSM2602_PWR,
0401             PWR_CLK_OUT_PDN | PWR_OSC_PDN, ssm2602->clk_out_pwr);
0402     }
0403 
0404     return 0;
0405 }
0406 
0407 static int ssm2602_set_dai_fmt(struct snd_soc_dai *codec_dai,
0408         unsigned int fmt)
0409 {
0410     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(codec_dai->component);
0411     unsigned int iface = 0;
0412 
0413     /* set master/slave audio interface */
0414     switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
0415     case SND_SOC_DAIFMT_CBP_CFP:
0416         iface |= 0x0040;
0417         break;
0418     case SND_SOC_DAIFMT_CBC_CFC:
0419         break;
0420     default:
0421         return -EINVAL;
0422     }
0423 
0424     /* interface format */
0425     switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
0426     case SND_SOC_DAIFMT_I2S:
0427         iface |= 0x0002;
0428         break;
0429     case SND_SOC_DAIFMT_RIGHT_J:
0430         break;
0431     case SND_SOC_DAIFMT_LEFT_J:
0432         iface |= 0x0001;
0433         break;
0434     case SND_SOC_DAIFMT_DSP_A:
0435         iface |= 0x0013;
0436         break;
0437     case SND_SOC_DAIFMT_DSP_B:
0438         iface |= 0x0003;
0439         break;
0440     default:
0441         return -EINVAL;
0442     }
0443 
0444     /* clock inversion */
0445     switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
0446     case SND_SOC_DAIFMT_NB_NF:
0447         break;
0448     case SND_SOC_DAIFMT_IB_IF:
0449         iface |= 0x0090;
0450         break;
0451     case SND_SOC_DAIFMT_IB_NF:
0452         iface |= 0x0080;
0453         break;
0454     case SND_SOC_DAIFMT_NB_IF:
0455         iface |= 0x0010;
0456         break;
0457     default:
0458         return -EINVAL;
0459     }
0460 
0461     /* set iface */
0462     regmap_write(ssm2602->regmap, SSM2602_IFACE, iface);
0463     return 0;
0464 }
0465 
0466 static int ssm2602_set_bias_level(struct snd_soc_component *component,
0467                  enum snd_soc_bias_level level)
0468 {
0469     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0470 
0471     switch (level) {
0472     case SND_SOC_BIAS_ON:
0473         /* vref/mid on, osc and clkout on if enabled */
0474         regmap_update_bits(ssm2602->regmap, SSM2602_PWR,
0475             PWR_POWER_OFF | PWR_CLK_OUT_PDN | PWR_OSC_PDN,
0476             ssm2602->clk_out_pwr);
0477         break;
0478     case SND_SOC_BIAS_PREPARE:
0479         break;
0480     case SND_SOC_BIAS_STANDBY:
0481         /* everything off except vref/vmid, */
0482         regmap_update_bits(ssm2602->regmap, SSM2602_PWR,
0483             PWR_POWER_OFF | PWR_CLK_OUT_PDN | PWR_OSC_PDN,
0484             PWR_CLK_OUT_PDN | PWR_OSC_PDN);
0485         break;
0486     case SND_SOC_BIAS_OFF:
0487         /* everything off */
0488         regmap_update_bits(ssm2602->regmap, SSM2602_PWR,
0489             PWR_POWER_OFF, PWR_POWER_OFF);
0490         break;
0491 
0492     }
0493     return 0;
0494 }
0495 
0496 #define SSM2602_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
0497         SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
0498         SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
0499         SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
0500         SNDRV_PCM_RATE_96000)
0501 
0502 #define SSM2602_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
0503         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
0504 
0505 static const struct snd_soc_dai_ops ssm2602_dai_ops = {
0506     .startup    = ssm2602_startup,
0507     .hw_params  = ssm2602_hw_params,
0508     .mute_stream    = ssm2602_mute,
0509     .set_sysclk = ssm2602_set_dai_sysclk,
0510     .set_fmt    = ssm2602_set_dai_fmt,
0511     .no_capture_mute = 1,
0512 };
0513 
0514 static struct snd_soc_dai_driver ssm2602_dai = {
0515     .name = "ssm2602-hifi",
0516     .playback = {
0517         .stream_name = "Playback",
0518         .channels_min = 2,
0519         .channels_max = 2,
0520         .rates = SSM2602_RATES,
0521         .formats = SSM2602_FORMATS,},
0522     .capture = {
0523         .stream_name = "Capture",
0524         .channels_min = 2,
0525         .channels_max = 2,
0526         .rates = SSM2602_RATES,
0527         .formats = SSM2602_FORMATS,},
0528     .ops = &ssm2602_dai_ops,
0529     .symmetric_rate = 1,
0530     .symmetric_sample_bits = 1,
0531 };
0532 
0533 static int ssm2602_resume(struct snd_soc_component *component)
0534 {
0535     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0536 
0537     regcache_sync(ssm2602->regmap);
0538 
0539     return 0;
0540 }
0541 
0542 static int ssm2602_component_probe(struct snd_soc_component *component)
0543 {
0544     struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
0545     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0546     int ret;
0547 
0548     regmap_update_bits(ssm2602->regmap, SSM2602_LOUT1V,
0549                 LOUT1V_LRHP_BOTH, LOUT1V_LRHP_BOTH);
0550     regmap_update_bits(ssm2602->regmap, SSM2602_ROUT1V,
0551                 ROUT1V_RLHP_BOTH, ROUT1V_RLHP_BOTH);
0552 
0553     ret = snd_soc_add_component_controls(component, ssm2602_snd_controls,
0554             ARRAY_SIZE(ssm2602_snd_controls));
0555     if (ret)
0556         return ret;
0557 
0558     ret = snd_soc_dapm_new_controls(dapm, ssm2602_dapm_widgets,
0559             ARRAY_SIZE(ssm2602_dapm_widgets));
0560     if (ret)
0561         return ret;
0562 
0563     return snd_soc_dapm_add_routes(dapm, ssm2602_routes,
0564             ARRAY_SIZE(ssm2602_routes));
0565 }
0566 
0567 static int ssm2604_component_probe(struct snd_soc_component *component)
0568 {
0569     struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
0570     int ret;
0571 
0572     ret = snd_soc_dapm_new_controls(dapm, ssm2604_dapm_widgets,
0573             ARRAY_SIZE(ssm2604_dapm_widgets));
0574     if (ret)
0575         return ret;
0576 
0577     return snd_soc_dapm_add_routes(dapm, ssm2604_routes,
0578             ARRAY_SIZE(ssm2604_routes));
0579 }
0580 
0581 static int ssm260x_component_probe(struct snd_soc_component *component)
0582 {
0583     struct ssm2602_priv *ssm2602 = snd_soc_component_get_drvdata(component);
0584     int ret;
0585 
0586     ret = regmap_write(ssm2602->regmap, SSM2602_RESET, 0);
0587     if (ret < 0) {
0588         dev_err(component->dev, "Failed to issue reset: %d\n", ret);
0589         return ret;
0590     }
0591 
0592     /* set the update bits */
0593     regmap_update_bits(ssm2602->regmap, SSM2602_LINVOL,
0594                 LINVOL_LRIN_BOTH, LINVOL_LRIN_BOTH);
0595     regmap_update_bits(ssm2602->regmap, SSM2602_RINVOL,
0596                 RINVOL_RLIN_BOTH, RINVOL_RLIN_BOTH);
0597     /*select Line in as default input*/
0598     regmap_write(ssm2602->regmap, SSM2602_APANA, APANA_SELECT_DAC |
0599             APANA_ENABLE_MIC_BOOST);
0600 
0601     switch (ssm2602->type) {
0602     case SSM2602:
0603         ret = ssm2602_component_probe(component);
0604         break;
0605     case SSM2604:
0606         ret = ssm2604_component_probe(component);
0607         break;
0608     }
0609 
0610     return ret;
0611 }
0612 
0613 static const struct snd_soc_component_driver soc_component_dev_ssm2602 = {
0614     .probe          = ssm260x_component_probe,
0615     .resume         = ssm2602_resume,
0616     .set_bias_level     = ssm2602_set_bias_level,
0617     .controls       = ssm260x_snd_controls,
0618     .num_controls       = ARRAY_SIZE(ssm260x_snd_controls),
0619     .dapm_widgets       = ssm260x_dapm_widgets,
0620     .num_dapm_widgets   = ARRAY_SIZE(ssm260x_dapm_widgets),
0621     .dapm_routes        = ssm260x_routes,
0622     .num_dapm_routes    = ARRAY_SIZE(ssm260x_routes),
0623     .suspend_bias_off   = 1,
0624     .idle_bias_on       = 1,
0625     .use_pmdown_time    = 1,
0626     .endianness     = 1,
0627 };
0628 
0629 static bool ssm2602_register_volatile(struct device *dev, unsigned int reg)
0630 {
0631     return reg == SSM2602_RESET;
0632 }
0633 
0634 const struct regmap_config ssm2602_regmap_config = {
0635     .val_bits = 9,
0636     .reg_bits = 7,
0637 
0638     .max_register = SSM2602_RESET,
0639     .volatile_reg = ssm2602_register_volatile,
0640 
0641     .cache_type = REGCACHE_RBTREE,
0642     .reg_defaults = ssm2602_reg,
0643     .num_reg_defaults = ARRAY_SIZE(ssm2602_reg),
0644 };
0645 EXPORT_SYMBOL_GPL(ssm2602_regmap_config);
0646 
0647 int ssm2602_probe(struct device *dev, enum ssm2602_type type,
0648     struct regmap *regmap)
0649 {
0650     struct ssm2602_priv *ssm2602;
0651 
0652     if (IS_ERR(regmap))
0653         return PTR_ERR(regmap);
0654 
0655     ssm2602 = devm_kzalloc(dev, sizeof(*ssm2602), GFP_KERNEL);
0656     if (ssm2602 == NULL)
0657         return -ENOMEM;
0658 
0659     dev_set_drvdata(dev, ssm2602);
0660     ssm2602->type = type;
0661     ssm2602->regmap = regmap;
0662 
0663     return devm_snd_soc_register_component(dev, &soc_component_dev_ssm2602,
0664         &ssm2602_dai, 1);
0665 }
0666 EXPORT_SYMBOL_GPL(ssm2602_probe);
0667 
0668 MODULE_DESCRIPTION("ASoC SSM2602/SSM2603/SSM2604 driver");
0669 MODULE_AUTHOR("Cliff Cai");
0670 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!