Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright 2008 Juergen Beisert, kernel@pengutronix.de
0004  * Copyright 2009 Sascha Hauer, s.hauer@pengutronix.de
0005  * Copyright 2012 Philippe Retornaz, philippe.retornaz@epfl.ch
0006  *
0007  * Initial development of this code was funded by
0008  * Phytec Messtechnik GmbH, https://www.phytec.de
0009  */
0010 #include <linux/module.h>
0011 #include <linux/device.h>
0012 #include <linux/of.h>
0013 #include <linux/mfd/mc13xxx.h>
0014 #include <linux/slab.h>
0015 #include <sound/core.h>
0016 #include <sound/control.h>
0017 #include <sound/pcm.h>
0018 #include <sound/soc.h>
0019 #include <sound/initval.h>
0020 #include <sound/soc-dapm.h>
0021 #include <linux/regmap.h>
0022 
0023 #include "mc13783.h"
0024 
0025 #define AUDIO_RX0_ALSPEN        (1 << 5)
0026 #define AUDIO_RX0_ALSPSEL       (1 << 7)
0027 #define AUDIO_RX0_ADDCDC        (1 << 21)
0028 #define AUDIO_RX0_ADDSTDC       (1 << 22)
0029 #define AUDIO_RX0_ADDRXIN       (1 << 23)
0030 
0031 #define AUDIO_RX1_PGARXEN       (1 << 0);
0032 #define AUDIO_RX1_PGASTEN       (1 << 5)
0033 #define AUDIO_RX1_ARXINEN       (1 << 10)
0034 
0035 #define AUDIO_TX_AMC1REN        (1 << 5)
0036 #define AUDIO_TX_AMC1LEN        (1 << 7)
0037 #define AUDIO_TX_AMC2EN         (1 << 9)
0038 #define AUDIO_TX_ATXINEN        (1 << 11)
0039 #define AUDIO_TX_RXINREC        (1 << 13)
0040 
0041 #define SSI_NETWORK_CDCTXRXSLOT(x)  (((x) & 0x3) << 2)
0042 #define SSI_NETWORK_CDCTXSECSLOT(x) (((x) & 0x3) << 4)
0043 #define SSI_NETWORK_CDCRXSECSLOT(x) (((x) & 0x3) << 6)
0044 #define SSI_NETWORK_CDCRXSECGAIN(x) (((x) & 0x3) << 8)
0045 #define SSI_NETWORK_CDCSUMGAIN(x)   (1 << 10)
0046 #define SSI_NETWORK_CDCFSDLY(x)     (1 << 11)
0047 #define SSI_NETWORK_DAC_SLOTS_8     (1 << 12)
0048 #define SSI_NETWORK_DAC_SLOTS_4     (2 << 12)
0049 #define SSI_NETWORK_DAC_SLOTS_2     (3 << 12)
0050 #define SSI_NETWORK_DAC_SLOT_MASK   (3 << 12)
0051 #define SSI_NETWORK_DAC_RXSLOT_0_1  (0 << 14)
0052 #define SSI_NETWORK_DAC_RXSLOT_2_3  (1 << 14)
0053 #define SSI_NETWORK_DAC_RXSLOT_4_5  (2 << 14)
0054 #define SSI_NETWORK_DAC_RXSLOT_6_7  (3 << 14)
0055 #define SSI_NETWORK_DAC_RXSLOT_MASK (3 << 14)
0056 #define SSI_NETWORK_STDCRXSECSLOT(x)    (((x) & 0x3) << 16)
0057 #define SSI_NETWORK_STDCRXSECGAIN(x)    (((x) & 0x3) << 18)
0058 #define SSI_NETWORK_STDCSUMGAIN     (1 << 20)
0059 
0060 /*
0061  * MC13783_AUDIO_CODEC and MC13783_AUDIO_DAC mostly share the same
0062  * register layout
0063  */
0064 #define AUDIO_SSI_SEL           (1 << 0)
0065 #define AUDIO_CLK_SEL           (1 << 1)
0066 #define AUDIO_CSM           (1 << 2)
0067 #define AUDIO_BCL_INV           (1 << 3)
0068 #define AUDIO_CFS_INV           (1 << 4)
0069 #define AUDIO_CFS(x)            (((x) & 0x3) << 5)
0070 #define AUDIO_CLK(x)            (((x) & 0x7) << 7)
0071 #define AUDIO_C_EN          (1 << 11)
0072 #define AUDIO_C_CLK_EN          (1 << 12)
0073 #define AUDIO_C_RESET           (1 << 15)
0074 
0075 #define AUDIO_CODEC_CDCFS8K16K      (1 << 10)
0076 #define AUDIO_DAC_CFS_DLY_B     (1 << 10)
0077 
0078 struct mc13783_priv {
0079     struct mc13xxx *mc13xxx;
0080     struct regmap *regmap;
0081 
0082     enum mc13783_ssi_port adc_ssi_port;
0083     enum mc13783_ssi_port dac_ssi_port;
0084 };
0085 
0086 /* Mapping between sample rates and register value */
0087 static unsigned int mc13783_rates[] = {
0088     8000, 11025, 12000, 16000,
0089     22050, 24000, 32000, 44100,
0090     48000, 64000, 96000
0091 };
0092 
0093 static int mc13783_pcm_hw_params_dac(struct snd_pcm_substream *substream,
0094                 struct snd_pcm_hw_params *params,
0095                 struct snd_soc_dai *dai)
0096 {
0097     struct snd_soc_component *component = dai->component;
0098     unsigned int rate = params_rate(params);
0099     int i;
0100 
0101     for (i = 0; i < ARRAY_SIZE(mc13783_rates); i++) {
0102         if (rate == mc13783_rates[i]) {
0103             snd_soc_component_update_bits(component, MC13783_AUDIO_DAC,
0104                     0xf << 17, i << 17);
0105             return 0;
0106         }
0107     }
0108 
0109     return -EINVAL;
0110 }
0111 
0112 static int mc13783_pcm_hw_params_codec(struct snd_pcm_substream *substream,
0113                 struct snd_pcm_hw_params *params,
0114                 struct snd_soc_dai *dai)
0115 {
0116     struct snd_soc_component *component = dai->component;
0117     unsigned int rate = params_rate(params);
0118     unsigned int val;
0119 
0120     switch (rate) {
0121     case 8000:
0122         val = 0;
0123         break;
0124     case 16000:
0125         val = AUDIO_CODEC_CDCFS8K16K;
0126         break;
0127     default:
0128         return -EINVAL;
0129     }
0130 
0131     snd_soc_component_update_bits(component, MC13783_AUDIO_CODEC, AUDIO_CODEC_CDCFS8K16K,
0132             val);
0133 
0134     return 0;
0135 }
0136 
0137 static int mc13783_pcm_hw_params_sync(struct snd_pcm_substream *substream,
0138                 struct snd_pcm_hw_params *params,
0139                 struct snd_soc_dai *dai)
0140 {
0141     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
0142         return mc13783_pcm_hw_params_dac(substream, params, dai);
0143     else
0144         return mc13783_pcm_hw_params_codec(substream, params, dai);
0145 }
0146 
0147 static int mc13783_set_fmt(struct snd_soc_dai *dai, unsigned int fmt,
0148             unsigned int reg)
0149 {
0150     struct snd_soc_component *component = dai->component;
0151     unsigned int val = 0;
0152     unsigned int mask = AUDIO_CFS(3) | AUDIO_BCL_INV | AUDIO_CFS_INV |
0153                 AUDIO_CSM | AUDIO_C_CLK_EN | AUDIO_C_RESET;
0154 
0155 
0156     /* DAI mode */
0157     switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
0158     case SND_SOC_DAIFMT_I2S:
0159         val |= AUDIO_CFS(2);
0160         break;
0161     case SND_SOC_DAIFMT_DSP_A:
0162         val |= AUDIO_CFS(1);
0163         break;
0164     default:
0165         return -EINVAL;
0166     }
0167 
0168     /* DAI clock inversion */
0169     switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
0170     case SND_SOC_DAIFMT_NB_NF:
0171         val |= AUDIO_BCL_INV;
0172         break;
0173     case SND_SOC_DAIFMT_NB_IF:
0174         val |= AUDIO_BCL_INV | AUDIO_CFS_INV;
0175         break;
0176     case SND_SOC_DAIFMT_IB_NF:
0177         break;
0178     case SND_SOC_DAIFMT_IB_IF:
0179         val |= AUDIO_CFS_INV;
0180         break;
0181     }
0182 
0183     /* DAI clock master masks */
0184     switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
0185     case SND_SOC_DAIFMT_CBP_CFP:
0186         val |= AUDIO_C_CLK_EN;
0187         break;
0188     case SND_SOC_DAIFMT_CBC_CFC:
0189         val |= AUDIO_CSM;
0190         break;
0191     default:
0192         return -EINVAL;
0193     }
0194 
0195     val |= AUDIO_C_RESET;
0196 
0197     snd_soc_component_update_bits(component, reg, mask, val);
0198 
0199     return 0;
0200 }
0201 
0202 static int mc13783_set_fmt_async(struct snd_soc_dai *dai, unsigned int fmt)
0203 {
0204     if (dai->id == MC13783_ID_STEREO_DAC)
0205         return mc13783_set_fmt(dai, fmt, MC13783_AUDIO_DAC);
0206     else
0207         return mc13783_set_fmt(dai, fmt, MC13783_AUDIO_CODEC);
0208 }
0209 
0210 static int mc13783_set_fmt_sync(struct snd_soc_dai *dai, unsigned int fmt)
0211 {
0212     int ret;
0213 
0214     ret = mc13783_set_fmt(dai, fmt, MC13783_AUDIO_DAC);
0215     if (ret)
0216         return ret;
0217 
0218     /*
0219      * In synchronous mode force the voice codec into consumer mode
0220      * so that the clock / framesync from the stereo DAC is used
0221      */
0222     fmt &= ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK;
0223     fmt |= SND_SOC_DAIFMT_CBC_CFC;
0224     ret = mc13783_set_fmt(dai, fmt, MC13783_AUDIO_CODEC);
0225 
0226     return ret;
0227 }
0228 
0229 static int mc13783_sysclk[] = {
0230     13000000,
0231     15360000,
0232     16800000,
0233     -1,
0234     26000000,
0235     -1, /* 12000000, invalid for voice codec */
0236     -1, /* 3686400, invalid for voice codec */
0237     33600000,
0238 };
0239 
0240 static int mc13783_set_sysclk(struct snd_soc_dai *dai,
0241                   int clk_id, unsigned int freq, int dir,
0242                   unsigned int reg)
0243 {
0244     struct snd_soc_component *component = dai->component;
0245     int clk;
0246     unsigned int val = 0;
0247     unsigned int mask = AUDIO_CLK(0x7) | AUDIO_CLK_SEL;
0248 
0249     for (clk = 0; clk < ARRAY_SIZE(mc13783_sysclk); clk++) {
0250         if (mc13783_sysclk[clk] < 0)
0251             continue;
0252         if (mc13783_sysclk[clk] == freq)
0253             break;
0254     }
0255 
0256     if (clk == ARRAY_SIZE(mc13783_sysclk))
0257         return -EINVAL;
0258 
0259     if (clk_id == MC13783_CLK_CLIB)
0260         val |= AUDIO_CLK_SEL;
0261 
0262     val |= AUDIO_CLK(clk);
0263 
0264     snd_soc_component_update_bits(component, reg, mask, val);
0265 
0266     return 0;
0267 }
0268 
0269 static int mc13783_set_sysclk_dac(struct snd_soc_dai *dai,
0270                   int clk_id, unsigned int freq, int dir)
0271 {
0272     return mc13783_set_sysclk(dai, clk_id, freq, dir, MC13783_AUDIO_DAC);
0273 }
0274 
0275 static int mc13783_set_sysclk_codec(struct snd_soc_dai *dai,
0276                   int clk_id, unsigned int freq, int dir)
0277 {
0278     return mc13783_set_sysclk(dai, clk_id, freq, dir, MC13783_AUDIO_CODEC);
0279 }
0280 
0281 static int mc13783_set_sysclk_sync(struct snd_soc_dai *dai,
0282                   int clk_id, unsigned int freq, int dir)
0283 {
0284     int ret;
0285 
0286     ret = mc13783_set_sysclk(dai, clk_id, freq, dir, MC13783_AUDIO_DAC);
0287     if (ret)
0288         return ret;
0289 
0290     return mc13783_set_sysclk(dai, clk_id, freq, dir, MC13783_AUDIO_CODEC);
0291 }
0292 
0293 static int mc13783_set_tdm_slot_dac(struct snd_soc_dai *dai,
0294     unsigned int tx_mask, unsigned int rx_mask, int slots,
0295     int slot_width)
0296 {
0297     struct snd_soc_component *component = dai->component;
0298     unsigned int val = 0;
0299     unsigned int mask = SSI_NETWORK_DAC_SLOT_MASK |
0300                 SSI_NETWORK_DAC_RXSLOT_MASK;
0301 
0302     switch (slots) {
0303     case 2:
0304         val |= SSI_NETWORK_DAC_SLOTS_2;
0305         break;
0306     case 4:
0307         val |= SSI_NETWORK_DAC_SLOTS_4;
0308         break;
0309     case 8:
0310         val |= SSI_NETWORK_DAC_SLOTS_8;
0311         break;
0312     default:
0313         return -EINVAL;
0314     }
0315 
0316     switch (rx_mask) {
0317     case 0x03:
0318         val |= SSI_NETWORK_DAC_RXSLOT_0_1;
0319         break;
0320     case 0x0c:
0321         val |= SSI_NETWORK_DAC_RXSLOT_2_3;
0322         break;
0323     case 0x30:
0324         val |= SSI_NETWORK_DAC_RXSLOT_4_5;
0325         break;
0326     case 0xc0:
0327         val |= SSI_NETWORK_DAC_RXSLOT_6_7;
0328         break;
0329     default:
0330         return -EINVAL;
0331     }
0332 
0333     snd_soc_component_update_bits(component, MC13783_SSI_NETWORK, mask, val);
0334 
0335     return 0;
0336 }
0337 
0338 static int mc13783_set_tdm_slot_codec(struct snd_soc_dai *dai,
0339     unsigned int tx_mask, unsigned int rx_mask, int slots,
0340     int slot_width)
0341 {
0342     struct snd_soc_component *component = dai->component;
0343     unsigned int val = 0;
0344     unsigned int mask = 0x3f;
0345 
0346     if (slots != 4)
0347         return -EINVAL;
0348 
0349     if (tx_mask != 0x3)
0350         return -EINVAL;
0351 
0352     val |= (0x00 << 2); /* primary timeslot RX/TX(?) is 0 */
0353     val |= (0x01 << 4); /* secondary timeslot TX is 1 */
0354 
0355     snd_soc_component_update_bits(component, MC13783_SSI_NETWORK, mask, val);
0356 
0357     return 0;
0358 }
0359 
0360 static int mc13783_set_tdm_slot_sync(struct snd_soc_dai *dai,
0361     unsigned int tx_mask, unsigned int rx_mask, int slots,
0362     int slot_width)
0363 {
0364     int ret;
0365 
0366     ret = mc13783_set_tdm_slot_dac(dai, tx_mask, rx_mask, slots,
0367             slot_width);
0368     if (ret)
0369         return ret;
0370 
0371     ret = mc13783_set_tdm_slot_codec(dai, tx_mask, rx_mask, slots,
0372             slot_width);
0373 
0374     return ret;
0375 }
0376 
0377 static const struct snd_kcontrol_new mc1l_amp_ctl =
0378     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 7, 1, 0);
0379 
0380 static const struct snd_kcontrol_new mc1r_amp_ctl =
0381     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 5, 1, 0);
0382 
0383 static const struct snd_kcontrol_new mc2_amp_ctl =
0384     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 9, 1, 0);
0385 
0386 static const struct snd_kcontrol_new atx_amp_ctl =
0387     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_TX, 11, 1, 0);
0388 
0389 
0390 /* Virtual mux. The chip does the input selection automatically
0391  * as soon as we enable one input. */
0392 static const char * const adcl_enum_text[] = {
0393     "MC1L", "RXINL",
0394 };
0395 
0396 static SOC_ENUM_SINGLE_VIRT_DECL(adcl_enum, adcl_enum_text);
0397 
0398 static const struct snd_kcontrol_new left_input_mux =
0399     SOC_DAPM_ENUM("Route", adcl_enum);
0400 
0401 static const char * const adcr_enum_text[] = {
0402     "MC1R", "MC2", "RXINR", "TXIN",
0403 };
0404 
0405 static SOC_ENUM_SINGLE_VIRT_DECL(adcr_enum, adcr_enum_text);
0406 
0407 static const struct snd_kcontrol_new right_input_mux =
0408     SOC_DAPM_ENUM("Route", adcr_enum);
0409 
0410 static const struct snd_kcontrol_new samp_ctl =
0411     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 3, 1, 0);
0412 
0413 static const char * const speaker_amp_source_text[] = {
0414     "CODEC", "Right"
0415 };
0416 static SOC_ENUM_SINGLE_DECL(speaker_amp_source, MC13783_AUDIO_RX0, 4,
0417                 speaker_amp_source_text);
0418 static const struct snd_kcontrol_new speaker_amp_source_mux =
0419     SOC_DAPM_ENUM("Speaker Amp Source MUX", speaker_amp_source);
0420 
0421 static const char * const headset_amp_source_text[] = {
0422     "CODEC", "Mixer"
0423 };
0424 
0425 static SOC_ENUM_SINGLE_DECL(headset_amp_source, MC13783_AUDIO_RX0, 11,
0426                 headset_amp_source_text);
0427 static const struct snd_kcontrol_new headset_amp_source_mux =
0428     SOC_DAPM_ENUM("Headset Amp Source MUX", headset_amp_source);
0429 
0430 static const struct snd_kcontrol_new cdcout_ctl =
0431     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 18, 1, 0);
0432 
0433 static const struct snd_kcontrol_new adc_bypass_ctl =
0434     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_CODEC, 16, 1, 0);
0435 
0436 static const struct snd_kcontrol_new lamp_ctl =
0437     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 5, 1, 0);
0438 
0439 static const struct snd_kcontrol_new hlamp_ctl =
0440     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 10, 1, 0);
0441 
0442 static const struct snd_kcontrol_new hramp_ctl =
0443     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 9, 1, 0);
0444 
0445 static const struct snd_kcontrol_new llamp_ctl =
0446     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 16, 1, 0);
0447 
0448 static const struct snd_kcontrol_new lramp_ctl =
0449     SOC_DAPM_SINGLE("Switch", MC13783_AUDIO_RX0, 15, 1, 0);
0450 
0451 static const struct snd_soc_dapm_widget mc13783_dapm_widgets[] = {
0452 /* Input */
0453     SND_SOC_DAPM_INPUT("MC1LIN"),
0454     SND_SOC_DAPM_INPUT("MC1RIN"),
0455     SND_SOC_DAPM_INPUT("MC2IN"),
0456     SND_SOC_DAPM_INPUT("RXINR"),
0457     SND_SOC_DAPM_INPUT("RXINL"),
0458     SND_SOC_DAPM_INPUT("TXIN"),
0459 
0460     SND_SOC_DAPM_SUPPLY("MC1 Bias", MC13783_AUDIO_TX, 0, 0, NULL, 0),
0461     SND_SOC_DAPM_SUPPLY("MC2 Bias", MC13783_AUDIO_TX, 1, 0, NULL, 0),
0462 
0463     SND_SOC_DAPM_SWITCH("MC1L Amp", MC13783_AUDIO_TX, 7, 0, &mc1l_amp_ctl),
0464     SND_SOC_DAPM_SWITCH("MC1R Amp", MC13783_AUDIO_TX, 5, 0, &mc1r_amp_ctl),
0465     SND_SOC_DAPM_SWITCH("MC2 Amp", MC13783_AUDIO_TX, 9, 0, &mc2_amp_ctl),
0466     SND_SOC_DAPM_SWITCH("TXIN Amp", MC13783_AUDIO_TX, 11, 0, &atx_amp_ctl),
0467 
0468     SND_SOC_DAPM_MUX("PGA Left Input Mux", SND_SOC_NOPM, 0, 0,
0469                   &left_input_mux),
0470     SND_SOC_DAPM_MUX("PGA Right Input Mux", SND_SOC_NOPM, 0, 0,
0471                   &right_input_mux),
0472 
0473     SND_SOC_DAPM_MUX("Speaker Amp Source MUX", SND_SOC_NOPM, 0, 0,
0474              &speaker_amp_source_mux),
0475 
0476     SND_SOC_DAPM_MUX("Headset Amp Source MUX", SND_SOC_NOPM, 0, 0,
0477              &headset_amp_source_mux),
0478 
0479     SND_SOC_DAPM_PGA("PGA Left Input", SND_SOC_NOPM, 0, 0, NULL, 0),
0480     SND_SOC_DAPM_PGA("PGA Right Input", SND_SOC_NOPM, 0, 0, NULL, 0),
0481 
0482     SND_SOC_DAPM_ADC("ADC", "Capture", MC13783_AUDIO_CODEC, 11, 0),
0483     SND_SOC_DAPM_SUPPLY("ADC_Reset", MC13783_AUDIO_CODEC, 15, 0, NULL, 0),
0484 
0485     SND_SOC_DAPM_PGA("Voice CODEC PGA", MC13783_AUDIO_RX1, 0, 0, NULL, 0),
0486     SND_SOC_DAPM_SWITCH("Voice CODEC Bypass", MC13783_AUDIO_CODEC, 16, 0,
0487             &adc_bypass_ctl),
0488 
0489 /* Output */
0490     SND_SOC_DAPM_SUPPLY("DAC_E", MC13783_AUDIO_DAC, 11, 0, NULL, 0),
0491     SND_SOC_DAPM_SUPPLY("DAC_Reset", MC13783_AUDIO_DAC, 15, 0, NULL, 0),
0492     SND_SOC_DAPM_OUTPUT("RXOUTL"),
0493     SND_SOC_DAPM_OUTPUT("RXOUTR"),
0494     SND_SOC_DAPM_OUTPUT("HSL"),
0495     SND_SOC_DAPM_OUTPUT("HSR"),
0496     SND_SOC_DAPM_OUTPUT("LSPL"),
0497     SND_SOC_DAPM_OUTPUT("LSP"),
0498     SND_SOC_DAPM_OUTPUT("SP"),
0499     SND_SOC_DAPM_OUTPUT("CDCOUT"),
0500 
0501     SND_SOC_DAPM_SWITCH("CDCOUT Switch", MC13783_AUDIO_RX0, 18, 0,
0502             &cdcout_ctl),
0503     SND_SOC_DAPM_SWITCH("Speaker Amp Switch", MC13783_AUDIO_RX0, 3, 0,
0504             &samp_ctl),
0505     SND_SOC_DAPM_SWITCH("Loudspeaker Amp", SND_SOC_NOPM, 0, 0, &lamp_ctl),
0506     SND_SOC_DAPM_SWITCH("Headset Amp Left", MC13783_AUDIO_RX0, 10, 0,
0507             &hlamp_ctl),
0508     SND_SOC_DAPM_SWITCH("Headset Amp Right", MC13783_AUDIO_RX0, 9, 0,
0509             &hramp_ctl),
0510     SND_SOC_DAPM_SWITCH("Line out Amp Left", MC13783_AUDIO_RX0, 16, 0,
0511             &llamp_ctl),
0512     SND_SOC_DAPM_SWITCH("Line out Amp Right", MC13783_AUDIO_RX0, 15, 0,
0513             &lramp_ctl),
0514     SND_SOC_DAPM_DAC("DAC", "Playback", MC13783_AUDIO_RX0, 22, 0),
0515     SND_SOC_DAPM_PGA("DAC PGA", MC13783_AUDIO_RX1, 5, 0, NULL, 0),
0516 };
0517 
0518 static struct snd_soc_dapm_route mc13783_routes[] = {
0519 /* Input */
0520     { "MC1L Amp", NULL, "MC1LIN"},
0521     { "MC1R Amp", NULL, "MC1RIN" },
0522     { "MC2 Amp", NULL, "MC2IN" },
0523     { "TXIN Amp", NULL, "TXIN"},
0524 
0525     { "PGA Left Input Mux", "MC1L", "MC1L Amp" },
0526     { "PGA Left Input Mux", "RXINL", "RXINL"},
0527     { "PGA Right Input Mux", "MC1R", "MC1R Amp" },
0528     { "PGA Right Input Mux", "MC2",  "MC2 Amp"},
0529     { "PGA Right Input Mux", "TXIN", "TXIN Amp"},
0530     { "PGA Right Input Mux", "RXINR", "RXINR"},
0531 
0532     { "PGA Left Input", NULL, "PGA Left Input Mux"},
0533     { "PGA Right Input", NULL, "PGA Right Input Mux"},
0534 
0535     { "ADC", NULL, "PGA Left Input"},
0536     { "ADC", NULL, "PGA Right Input"},
0537     { "ADC", NULL, "ADC_Reset"},
0538 
0539     { "Voice CODEC PGA", "Voice CODEC Bypass", "ADC" },
0540 
0541     { "Speaker Amp Source MUX", "CODEC", "Voice CODEC PGA"},
0542     { "Speaker Amp Source MUX", "Right", "DAC PGA"},
0543 
0544     { "Headset Amp Source MUX", "CODEC", "Voice CODEC PGA"},
0545     { "Headset Amp Source MUX", "Mixer", "DAC PGA"},
0546 
0547 /* Output */
0548     { "HSL", NULL, "Headset Amp Left" },
0549     { "HSR", NULL, "Headset Amp Right"},
0550     { "RXOUTL", NULL, "Line out Amp Left"},
0551     { "RXOUTR", NULL, "Line out Amp Right"},
0552     { "SP", "Speaker Amp Switch", "Speaker Amp Source MUX"},
0553     { "LSP", "Loudspeaker Amp", "Speaker Amp Source MUX"},
0554     { "HSL", "Headset Amp Left", "Headset Amp Source MUX"},
0555     { "HSR", "Headset Amp Right", "Headset Amp Source MUX"},
0556     { "Line out Amp Left", NULL, "DAC PGA"},
0557     { "Line out Amp Right", NULL, "DAC PGA"},
0558     { "DAC PGA", NULL, "DAC"},
0559     { "DAC", NULL, "DAC_E"},
0560     { "CDCOUT", "CDCOUT Switch", "Voice CODEC PGA"},
0561 };
0562 
0563 static const char * const mc13783_3d_mixer[] = {"Stereo", "Phase Mix",
0564                         "Mono", "Mono Mix"};
0565 
0566 static SOC_ENUM_SINGLE_DECL(mc13783_enum_3d_mixer,
0567                 MC13783_AUDIO_RX1, 16,
0568                 mc13783_3d_mixer);
0569 
0570 static struct snd_kcontrol_new mc13783_control_list[] = {
0571     SOC_SINGLE("Loudspeaker enable", MC13783_AUDIO_RX0, 5, 1, 0),
0572     SOC_SINGLE("PCM Playback Volume", MC13783_AUDIO_RX1, 6, 15, 0),
0573     SOC_SINGLE("PCM Playback Switch", MC13783_AUDIO_RX1, 5, 1, 0),
0574     SOC_DOUBLE("PCM Capture Volume", MC13783_AUDIO_TX, 19, 14, 31, 0),
0575     SOC_ENUM("3D Control", mc13783_enum_3d_mixer),
0576 
0577     SOC_SINGLE("CDCOUT Switch", MC13783_AUDIO_RX0, 18, 1, 0),
0578     SOC_SINGLE("Earpiece Amp Switch", MC13783_AUDIO_RX0, 3, 1, 0),
0579     SOC_DOUBLE("Headset Amp Switch", MC13783_AUDIO_RX0, 10, 9, 1, 0),
0580     SOC_DOUBLE("Line out Amp Switch", MC13783_AUDIO_RX0, 16, 15, 1, 0),
0581 
0582     SOC_SINGLE("PCM Capture Mixin Switch", MC13783_AUDIO_RX0, 22, 1, 0),
0583     SOC_SINGLE("Line in Capture Mixin Switch", MC13783_AUDIO_RX0, 23, 1, 0),
0584 
0585     SOC_SINGLE("CODEC Capture Volume", MC13783_AUDIO_RX1, 1, 15, 0),
0586     SOC_SINGLE("CODEC Capture Mixin Switch", MC13783_AUDIO_RX0, 21, 1, 0),
0587 
0588     SOC_SINGLE("Line in Capture Volume", MC13783_AUDIO_RX1, 12, 15, 0),
0589     SOC_SINGLE("Line in Capture Switch", MC13783_AUDIO_RX1, 10, 1, 0),
0590 
0591     SOC_SINGLE("MC1 Capture Bias Switch", MC13783_AUDIO_TX, 0, 1, 0),
0592     SOC_SINGLE("MC2 Capture Bias Switch", MC13783_AUDIO_TX, 1, 1, 0),
0593 };
0594 
0595 static int mc13783_probe(struct snd_soc_component *component)
0596 {
0597     struct mc13783_priv *priv = snd_soc_component_get_drvdata(component);
0598 
0599     snd_soc_component_init_regmap(component,
0600                   dev_get_regmap(component->dev->parent, NULL));
0601 
0602     /* these are the reset values */
0603     mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_RX0, 0x25893);
0604     mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_RX1, 0x00d35A);
0605     mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_TX, 0x420000);
0606     mc13xxx_reg_write(priv->mc13xxx, MC13783_SSI_NETWORK, 0x013060);
0607     mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_CODEC, 0x180027);
0608     mc13xxx_reg_write(priv->mc13xxx, MC13783_AUDIO_DAC, 0x0e0004);
0609 
0610     if (priv->adc_ssi_port == MC13783_SSI1_PORT)
0611         mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_CODEC,
0612                 AUDIO_SSI_SEL, 0);
0613     else
0614         mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_CODEC,
0615                 AUDIO_SSI_SEL, AUDIO_SSI_SEL);
0616 
0617     if (priv->dac_ssi_port == MC13783_SSI1_PORT)
0618         mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_DAC,
0619                 AUDIO_SSI_SEL, 0);
0620     else
0621         mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_DAC,
0622                 AUDIO_SSI_SEL, AUDIO_SSI_SEL);
0623 
0624     return 0;
0625 }
0626 
0627 static void mc13783_remove(struct snd_soc_component *component)
0628 {
0629     struct mc13783_priv *priv = snd_soc_component_get_drvdata(component);
0630 
0631     /* Make sure VAUDIOON is off */
0632     mc13xxx_reg_rmw(priv->mc13xxx, MC13783_AUDIO_RX0, 0x3, 0);
0633 }
0634 
0635 #define MC13783_RATES_RECORD (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000)
0636 
0637 #define MC13783_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
0638     SNDRV_PCM_FMTBIT_S24_LE)
0639 
0640 static const struct snd_soc_dai_ops mc13783_ops_dac = {
0641     .hw_params  = mc13783_pcm_hw_params_dac,
0642     .set_fmt    = mc13783_set_fmt_async,
0643     .set_sysclk = mc13783_set_sysclk_dac,
0644     .set_tdm_slot   = mc13783_set_tdm_slot_dac,
0645 };
0646 
0647 static const struct snd_soc_dai_ops mc13783_ops_codec = {
0648     .hw_params  = mc13783_pcm_hw_params_codec,
0649     .set_fmt    = mc13783_set_fmt_async,
0650     .set_sysclk = mc13783_set_sysclk_codec,
0651     .set_tdm_slot   = mc13783_set_tdm_slot_codec,
0652 };
0653 
0654 /*
0655  * The mc13783 has two SSI ports, both of them can be routed either
0656  * to the voice codec or the stereo DAC. When two different SSI ports
0657  * are used for the voice codec and the stereo DAC we can do different
0658  * formats and sysclock settings for playback and capture
0659  * (mc13783-hifi-playback and mc13783-hifi-capture). Using the same port
0660  * forces us to use symmetric rates (mc13783-hifi).
0661  */
0662 static struct snd_soc_dai_driver mc13783_dai_async[] = {
0663     {
0664         .name = "mc13783-hifi-playback",
0665         .id = MC13783_ID_STEREO_DAC,
0666         .playback = {
0667             .stream_name = "Playback",
0668             .channels_min = 2,
0669             .channels_max = 2,
0670             .rates = SNDRV_PCM_RATE_8000_96000,
0671             .formats = MC13783_FORMATS,
0672         },
0673         .ops = &mc13783_ops_dac,
0674     }, {
0675         .name = "mc13783-hifi-capture",
0676         .id = MC13783_ID_STEREO_CODEC,
0677         .capture = {
0678             .stream_name = "Capture",
0679             .channels_min = 2,
0680             .channels_max = 2,
0681             .rates = MC13783_RATES_RECORD,
0682             .formats = MC13783_FORMATS,
0683         },
0684         .ops = &mc13783_ops_codec,
0685     },
0686 };
0687 
0688 static const struct snd_soc_dai_ops mc13783_ops_sync = {
0689     .hw_params  = mc13783_pcm_hw_params_sync,
0690     .set_fmt    = mc13783_set_fmt_sync,
0691     .set_sysclk = mc13783_set_sysclk_sync,
0692     .set_tdm_slot   = mc13783_set_tdm_slot_sync,
0693 };
0694 
0695 static struct snd_soc_dai_driver mc13783_dai_sync[] = {
0696     {
0697         .name = "mc13783-hifi",
0698         .id = MC13783_ID_SYNC,
0699         .playback = {
0700             .stream_name = "Playback",
0701             .channels_min = 2,
0702             .channels_max = 2,
0703             .rates = SNDRV_PCM_RATE_8000_96000,
0704             .formats = MC13783_FORMATS,
0705         },
0706         .capture = {
0707             .stream_name = "Capture",
0708             .channels_min = 2,
0709             .channels_max = 2,
0710             .rates = MC13783_RATES_RECORD,
0711             .formats = MC13783_FORMATS,
0712         },
0713         .ops = &mc13783_ops_sync,
0714         .symmetric_rate = 1,
0715     }
0716 };
0717 
0718 static const struct snd_soc_component_driver soc_component_dev_mc13783 = {
0719     .probe          = mc13783_probe,
0720     .remove         = mc13783_remove,
0721     .controls       = mc13783_control_list,
0722     .num_controls       = ARRAY_SIZE(mc13783_control_list),
0723     .dapm_widgets       = mc13783_dapm_widgets,
0724     .num_dapm_widgets   = ARRAY_SIZE(mc13783_dapm_widgets),
0725     .dapm_routes        = mc13783_routes,
0726     .num_dapm_routes    = ARRAY_SIZE(mc13783_routes),
0727     .idle_bias_on       = 1,
0728     .use_pmdown_time    = 1,
0729     .endianness     = 1,
0730 };
0731 
0732 static int __init mc13783_codec_probe(struct platform_device *pdev)
0733 {
0734     struct mc13783_priv *priv;
0735     struct mc13xxx_codec_platform_data *pdata = pdev->dev.platform_data;
0736     struct device_node *np;
0737     int ret;
0738 
0739     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0740     if (!priv)
0741         return -ENOMEM;
0742 
0743     if (pdata) {
0744         priv->adc_ssi_port = pdata->adc_ssi_port;
0745         priv->dac_ssi_port = pdata->dac_ssi_port;
0746     } else {
0747         np = of_get_child_by_name(pdev->dev.parent->of_node, "codec");
0748         if (!np)
0749             return -ENOSYS;
0750 
0751         ret = of_property_read_u32(np, "adc-port", &priv->adc_ssi_port);
0752         if (ret) {
0753             of_node_put(np);
0754             return ret;
0755         }
0756 
0757         ret = of_property_read_u32(np, "dac-port", &priv->dac_ssi_port);
0758         if (ret) {
0759             of_node_put(np);
0760             return ret;
0761         }
0762 
0763         of_node_put(np);
0764     }
0765 
0766     dev_set_drvdata(&pdev->dev, priv);
0767     priv->mc13xxx = dev_get_drvdata(pdev->dev.parent);
0768 
0769     if (priv->adc_ssi_port == priv->dac_ssi_port)
0770         ret = devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_mc13783,
0771             mc13783_dai_sync, ARRAY_SIZE(mc13783_dai_sync));
0772     else
0773         ret = devm_snd_soc_register_component(&pdev->dev, &soc_component_dev_mc13783,
0774             mc13783_dai_async, ARRAY_SIZE(mc13783_dai_async));
0775 
0776     return ret;
0777 }
0778 
0779 static int mc13783_codec_remove(struct platform_device *pdev)
0780 {
0781     return 0;
0782 }
0783 
0784 static struct platform_driver mc13783_codec_driver = {
0785     .driver = {
0786         .name   = "mc13783-codec",
0787     },
0788     .remove = mc13783_codec_remove,
0789 };
0790 module_platform_driver_probe(mc13783_codec_driver, mc13783_codec_probe);
0791 
0792 MODULE_DESCRIPTION("ASoC MC13783 driver");
0793 MODULE_AUTHOR("Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>");
0794 MODULE_AUTHOR("Philippe Retornaz <philippe.retornaz@epfl.ch>");
0795 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!