projects / openwrt / svn-archive / archive.git / blob
? search:


33a1ea43ff50778bd66a5e6cf5aa263e614d9443
[openwrt/svn-archive/archive.git] / target / linux / imx23 / patches / 100-soc-audio-support.patch
1 diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
2 index 2f45f00..8226a88 100644
3 --- a/sound/soc/codecs/Kconfig
4 +++ b/sound/soc/codecs/Kconfig
5 @@ -125,6 +125,7 @@ config SND_SOC_ALL_CODECS
6 select SND_SOC_WM9705 if SND_SOC_AC97_BUS
7 select SND_SOC_WM9712 if SND_SOC_AC97_BUS
8 select SND_SOC_WM9713 if SND_SOC_AC97_BUS
9 + select SND_SOC_MXS_BUILTIN_CODEC
10 help
11 Normally ASoC codec drivers are only built if a machine driver which
12 uses them is also built since they are only usable with a machine
13 @@ -507,6 +508,9 @@ config SND_SOC_WM9712
14 config SND_SOC_WM9713
15 tristate
16
17 +config SND_SOC_MXS_BUILTIN_CODEC
18 + tristate
19 +
20 # Amp
21 config SND_SOC_LM4857
22 tristate
23 diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
24 index b9e41c9..e3b6654 100644
25 --- a/sound/soc/codecs/Makefile
26 +++ b/sound/soc/codecs/Makefile
27 @@ -118,6 +118,7 @@ snd-soc-wm9705-objs := wm9705.o
28 snd-soc-wm9712-objs := wm9712.o
29 snd-soc-wm9713-objs := wm9713.o
30 snd-soc-wm-hubs-objs := wm_hubs.o
31 +snd-soc-mxs-builtin-codec-objs := mxs-builtin-codec.o
32
33 # Amp
34 snd-soc-max9877-objs := max9877.o
35 @@ -242,6 +243,7 @@ obj-$(CONFIG_SND_SOC_WM9712) += snd-soc-wm9712.o
36 obj-$(CONFIG_SND_SOC_WM9713) += snd-soc-wm9713.o
37 obj-$(CONFIG_SND_SOC_WM_ADSP) += snd-soc-wm-adsp.o
38 obj-$(CONFIG_SND_SOC_WM_HUBS) += snd-soc-wm-hubs.o
39 +obj-$(CONFIG_SND_SOC_MXS_BUILTIN_CODEC) += snd-soc-mxs-builtin-codec.o
40
41 # Amp
42 obj-$(CONFIG_SND_SOC_MAX9877) += snd-soc-max9877.o
43 diff --git a/sound/soc/codecs/mxs-builtin-codec.c b/sound/soc/codecs/mxs-builtin-codec.c
44 new file mode 100644
45 index 0000000..144b225
46 --- /dev/null
47 +++ b/sound/soc/codecs/mxs-builtin-codec.c
48 @@ -0,0 +1,1128 @@
49 +/*
50 + * mxs-builtin-codec.c -- i.MX233 built-in codec ALSA Soc Audio driver
51 + *
52 + * Author: Michal Ulianko <michal.ulianko@gmail.com>
53 + *
54 + * Based on sound/soc/codecs/mxs-adc-codec.c for kernel 2.6.35
55 + * by Vladislav Buzov <vbuzov@embeddedalley.com>
56 + *
57 + * This program is free software; you can redistribute it and/or modify
58 + * it under the terms of the GNU General Public License version 2 as
59 + * published by the Free Software Foundation.
60 + */
61 +
62 +#include <linux/clk.h>
63 +#include <linux/delay.h>
64 +#include <linux/module.h>
65 +#include <linux/platform_device.h>
66 +#include <sound/pcm.h>
67 +#include <sound/pcm_params.h>
68 +#include <sound/soc.h>
69 +
70 +#include "mxs-builtin-codec.h"
71 +
72 +#ifndef BF
73 +#define BF(value, field) (((value) << BP_##field) & BM_##field)
74 +#endif
75 +
76 +/* TODO Delete this and use BM_RTC_PERSISTENT0_RELEASE_GND from header file
77 + * if it works. */
78 +#define BP_RTC_PERSISTENT0_SPARE_ANALOG 18
79 +#define BM_RTC_PERSISTENT0_SPARE_ANALOG 0xFFFC0000
80 +#define BM_RTC_PERSISTENT0_RELEASE_GND BF(0x2, RTC_PERSISTENT0_SPARE_ANALOG)
81 +
82 +/* TODO Use codec IO function soc snd write etc, instead of __writel __readl */
83 +
84 +struct mxs_adc_priv {
85 + void __iomem *ain_base;
86 + void __iomem *aout_base;
87 + void __iomem *rtc_base;
88 + struct clk *clk;
89 +};
90 +
91 +static unsigned int mxs_regmap[] = {
92 + HW_AUDIOOUT_CTRL,
93 + HW_AUDIOOUT_STAT,
94 + HW_AUDIOOUT_DACSRR,
95 + HW_AUDIOOUT_DACVOLUME,
96 + HW_AUDIOOUT_DACDEBUG,
97 + HW_AUDIOOUT_HPVOL,
98 + HW_AUDIOOUT_PWRDN,
99 + HW_AUDIOOUT_REFCTRL,
100 + HW_AUDIOOUT_ANACTRL,
101 + HW_AUDIOOUT_TEST,
102 + HW_AUDIOOUT_BISTCTRL,
103 + HW_AUDIOOUT_BISTSTAT0,
104 + HW_AUDIOOUT_BISTSTAT1,
105 + HW_AUDIOOUT_ANACLKCTRL,
106 + HW_AUDIOOUT_DATA,
107 + HW_AUDIOOUT_SPEAKERCTRL,
108 + HW_AUDIOOUT_VERSION,
109 + HW_AUDIOIN_CTRL,
110 + HW_AUDIOIN_STAT,
111 + HW_AUDIOIN_ADCSRR,
112 + HW_AUDIOIN_ADCVOLUME,
113 + HW_AUDIOIN_ADCDEBUG,
114 + HW_AUDIOIN_ADCVOL,
115 + HW_AUDIOIN_MICLINE,
116 + HW_AUDIOIN_ANACLKCTRL,
117 + HW_AUDIOIN_DATA,
118 +};
119 +
120 +static void __iomem *mxs_getreg(struct mxs_adc_priv *mxs_adc, int i)
121 +{
122 + if (i <= 16)
123 + return mxs_adc->aout_base + mxs_regmap[i];
124 + else if (i < ADC_REGNUM)
125 + return mxs_adc->ain_base + mxs_regmap[i];
126 + else
127 + return NULL;
128 +}
129 +
130 +static u8 dac_volumn_control_word[] = {
131 + 0x37, 0x5e, 0x7e, 0x8e,
132 + 0x9e, 0xae, 0xb6, 0xbe,
133 + 0xc6, 0xce, 0xd6, 0xde,
134 + 0xe6, 0xee, 0xf6, 0xfe,
135 +};
136 +
137 +struct dac_srr {
138 + u32 rate;
139 + u32 basemult;
140 + u32 src_hold;
141 + u32 src_int;
142 + u32 src_frac;
143 +};
144 +
145 +static struct dac_srr srr_values[] = {
146 + {192000, 0x4, 0x0, 0x0F, 0x13FF},
147 + {176400, 0x4, 0x0, 0x11, 0x0037},
148 + {128000, 0x4, 0x0, 0x17, 0x0E00},
149 + {96000, 0x2, 0x0, 0x0F, 0x13FF},
150 + {88200, 0x2, 0x0, 0x11, 0x0037},
151 + {64000, 0x2, 0x0, 0x17, 0x0E00},
152 + {48000, 0x1, 0x0, 0x0F, 0x13FF},
153 + {44100, 0x1, 0x0, 0x11, 0x0037},
154 + {32000, 0x1, 0x0, 0x17, 0x0E00},
155 + {24000, 0x1, 0x1, 0x0F, 0x13FF},
156 + {22050, 0x1, 0x1, 0x11, 0x0037},
157 + {16000, 0x1, 0x1, 0x17, 0x0E00},
158 + {12000, 0x1, 0x3, 0x0F, 0x13FF},
159 + {11025, 0x1, 0x3, 0x11, 0x0037},
160 + {8000, 0x1, 0x3, 0x17, 0x0E00}
161 +};
162 +
163 +static inline int get_srr_values(int rate)
164 +{
165 + int i;
166 +
167 + for (i = 0; i < ARRAY_SIZE(srr_values); i++)
168 + if (srr_values[i].rate == rate)
169 + return i;
170 +
171 + return -1;
172 +}
173 +
174 +/* SoC IO functions */
175 +static void mxs_codec_write_cache(struct snd_soc_codec *codec, unsigned int reg, unsigned int value)
176 +{
177 + u16 *cache = codec->reg_cache;
178 + if (reg < ADC_REGNUM)
179 + cache[reg] = value;
180 +}
181 +
182 +static int mxs_codec_write(struct snd_soc_codec *codec, unsigned int reg, unsigned int value)
183 +{
184 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
185 + unsigned int reg_val;
186 + unsigned int mask = 0xffff;
187 +
188 + if (reg >= ADC_REGNUM)
189 + return -EIO;
190 +
191 + mxs_codec_write_cache(codec, reg, value);
192 +
193 + if (reg & 0x1) {
194 + mask <<= 16;
195 + value <<= 16;
196 + }
197 +
198 + reg_val = __raw_readl(mxs_getreg(mxs_adc, reg >> 1));
199 + reg_val = (reg_val & ~mask) | value;
200 + __raw_writel(reg_val, mxs_getreg(mxs_adc, reg >> 1));
201 +
202 + return 0;
203 +}
204 +
205 +static unsigned int mxs_codec_read(struct snd_soc_codec *codec, unsigned int reg)
206 +{
207 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
208 + unsigned int reg_val;
209 +
210 + if (reg >= ADC_REGNUM)
211 + return -1;
212 +
213 + reg_val = __raw_readl(mxs_getreg(mxs_adc, reg >> 1));
214 + if (reg & 1)
215 + reg_val >>= 16;
216 +
217 + return reg_val & 0xffff;
218 +}
219 +
220 +// static unsigned int mxs_codec_read_cache(struct snd_soc_codec *codec, unsigned int reg)
221 +// {
222 +// u16 *cache = codec->reg_cache;
223 +// if (reg >= ADC_REGNUM)
224 +// return -EINVAL;
225 +// return cache[reg];
226 +// }
227 +
228 +static void mxs_codec_sync_reg_cache(struct snd_soc_codec *codec)
229 +{
230 + int reg;
231 + for (reg = 0; reg < ADC_REGNUM; reg += 1)
232 + mxs_codec_write_cache(codec, reg,
233 + mxs_codec_read(codec, reg));
234 +}
235 +
236 +// static int mxs_codec_restore_reg(struct snd_soc_codec *codec, unsigned int reg)
237 +// {
238 +// unsigned int cached_val, hw_val;
239 +//
240 +// cached_val = mxs_codec_read_cache(codec, reg);
241 +// hw_val = mxs_codec_read(codec, reg);
242 +//
243 +// if (hw_val != cached_val)
244 +// return mxs_codec_write(codec, reg, cached_val);
245 +//
246 +// return 0;
247 +// }
248 +/* END SoC IO functions */
249 +
250 +/* Codec routines */
251 +#define VAG_BASE_VALUE ((1400/2 - 625)/25)
252 +
253 +static void mxs_codec_dac_set_vag(struct mxs_adc_priv *mxs_adc)
254 +{
255 + u32 refctrl_val = __raw_readl(mxs_adc->aout_base + HW_AUDIOOUT_REFCTRL);
256 +
257 + refctrl_val &= ~(BM_AUDIOOUT_REFCTRL_VAG_VAL);
258 + refctrl_val &= ~(BM_AUDIOOUT_REFCTRL_VBG_ADJ);
259 + refctrl_val |= BF(VAG_BASE_VALUE, AUDIOOUT_REFCTRL_VAG_VAL) |
260 + BM_AUDIOOUT_REFCTRL_ADJ_VAG |
261 + BF(0xF, AUDIOOUT_REFCTRL_ADC_REFVAL) |
262 + BM_AUDIOOUT_REFCTRL_ADJ_ADC |
263 + BF(0x3, AUDIOOUT_REFCTRL_VBG_ADJ) | BM_AUDIOOUT_REFCTRL_RAISE_REF;
264 +
265 + __raw_writel(refctrl_val, mxs_adc->aout_base + HW_AUDIOOUT_REFCTRL);
266 +}
267 +
268 +static bool mxs_codec_dac_is_capless(struct mxs_adc_priv *mxs_adc)
269 +{
270 + if ((__raw_readl(mxs_adc->aout_base + HW_AUDIOOUT_PWRDN)
271 + & BM_AUDIOOUT_PWRDN_CAPLESS) == 0)
272 + return false;
273 + else
274 + return true;
275 +}
276 +
277 +static void mxs_codec_dac_arm_short_cm(struct mxs_adc_priv *mxs_adc, bool bShort)
278 +{
279 + __raw_writel(BF(3, AUDIOOUT_ANACTRL_SHORTMODE_CM),
280 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_CLR);
281 + __raw_writel(BM_AUDIOOUT_ANACTRL_SHORT_CM_STS,
282 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_CLR);
283 + if (bShort)
284 + __raw_writel(BF(1, AUDIOOUT_ANACTRL_SHORTMODE_CM),
285 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_SET);
286 +}
287 +
288 +static void mxs_codec_dac_arm_short_lr(struct mxs_adc_priv *mxs_adc, bool bShort)
289 +{
290 + __raw_writel(BF(3, AUDIOOUT_ANACTRL_SHORTMODE_LR),
291 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_CLR);
292 + __raw_writel(BM_AUDIOOUT_ANACTRL_SHORT_LR_STS,
293 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_CLR);
294 + if (bShort)
295 + __raw_writel(BF(1, AUDIOOUT_ANACTRL_SHORTMODE_LR),
296 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_SET);
297 +}
298 +
299 +static void mxs_codec_dac_set_short_trip_level(struct mxs_adc_priv *mxs_adc, u8 u8level)
300 +{
301 + __raw_writel(__raw_readl(mxs_adc->aout_base +
302 + HW_AUDIOOUT_ANACTRL)
303 + & (~BM_AUDIOOUT_ANACTRL_SHORT_LVLADJL)
304 + & (~BM_AUDIOOUT_ANACTRL_SHORT_LVLADJR)
305 + | BF(u8level, AUDIOOUT_ANACTRL_SHORT_LVLADJL)
306 + | BF(u8level, AUDIOOUT_ANACTRL_SHORT_LVLADJR),
307 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL);
308 +}
309 +
310 +static void mxs_codec_dac_arm_short(struct mxs_adc_priv *mxs_adc, bool bLatchCM, bool bLatchLR)
311 +{
312 + if (bLatchCM) {
313 + if (mxs_codec_dac_is_capless(mxs_adc))
314 + mxs_codec_dac_arm_short_cm(mxs_adc, true);
315 + } else
316 + mxs_codec_dac_arm_short_cm(mxs_adc, false);
317 +
318 + if (bLatchLR)
319 + mxs_codec_dac_arm_short_lr(mxs_adc, true);
320 + else
321 + mxs_codec_dac_arm_short_lr(mxs_adc, false);
322 +}
323 +
324 +static void
325 +mxs_codec_dac_power_on(struct mxs_adc_priv *mxs_adc)
326 +{
327 + /* Ungate DAC clocks */
328 + __raw_writel(BM_AUDIOOUT_CTRL_CLKGATE,
329 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_CLR);
330 + __raw_writel(BM_AUDIOOUT_ANACLKCTRL_CLKGATE,
331 + mxs_adc->aout_base + HW_AUDIOOUT_ANACLKCTRL_CLR);
332 +
333 + /* 16 bit word length */
334 + __raw_writel(BM_AUDIOOUT_CTRL_WORD_LENGTH,
335 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_SET);
336 +
337 + /* Arm headphone LR short protect */
338 + mxs_codec_dac_set_short_trip_level(mxs_adc, 0);
339 + mxs_codec_dac_arm_short(mxs_adc, false, true);
340 +
341 + /* Update DAC volume over zero crossings */
342 + __raw_writel(BM_AUDIOOUT_DACVOLUME_EN_ZCD,
343 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_SET);
344 + /* Mute DAC */
345 + __raw_writel(BM_AUDIOOUT_DACVOLUME_MUTE_LEFT |
346 + BM_AUDIOOUT_DACVOLUME_MUTE_RIGHT,
347 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_SET);
348 +
349 + /* Update HP volume over zero crossings */
350 + __raw_writel(BM_AUDIOOUT_HPVOL_EN_MSTR_ZCD,
351 + mxs_adc->aout_base + HW_AUDIOOUT_HPVOL_SET);
352 +
353 + __raw_writel(BM_AUDIOOUT_ANACTRL_HP_CLASSAB,
354 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_SET);
355 +
356 + /* Mute HP output */
357 + __raw_writel(BM_AUDIOOUT_HPVOL_MUTE,
358 + mxs_adc->aout_base + HW_AUDIOOUT_HPVOL_SET);
359 + /* Mute speaker amp */
360 + __raw_writel(BM_AUDIOOUT_SPEAKERCTRL_MUTE,
361 + mxs_adc->aout_base + HW_AUDIOOUT_SPEAKERCTRL_SET);
362 + /* Enable the audioout */
363 + __raw_writel(BM_AUDIOOUT_CTRL_RUN,
364 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_SET);
365 +}
366 +
367 +static void
368 +mxs_codec_dac_power_down(struct mxs_adc_priv *mxs_adc)
369 +{
370 + /* Disable the audioout */
371 + __raw_writel(BM_AUDIOOUT_CTRL_RUN,
372 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_CLR);
373 + /* Disable class AB */
374 + __raw_writel(BM_AUDIOOUT_ANACTRL_HP_CLASSAB,
375 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_CLR);
376 +
377 + /* Set hold to ground */
378 + __raw_writel(BM_AUDIOOUT_ANACTRL_HP_HOLD_GND,
379 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_SET);
380 +
381 + /* Mute HP output */
382 + __raw_writel(BM_AUDIOOUT_HPVOL_MUTE,
383 + mxs_adc->aout_base + HW_AUDIOOUT_HPVOL_SET);
384 + /* Power down HP output */
385 + __raw_writel(BM_AUDIOOUT_PWRDN_HEADPHONE,
386 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_SET);
387 +
388 + /* Mute speaker amp */
389 + __raw_writel(BM_AUDIOOUT_SPEAKERCTRL_MUTE,
390 + mxs_adc->aout_base + HW_AUDIOOUT_SPEAKERCTRL_SET);
391 + /* Power down speaker amp */
392 + __raw_writel(BM_AUDIOOUT_PWRDN_SPEAKER,
393 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_SET);
394 +
395 + /* Mute DAC */
396 + __raw_writel(BM_AUDIOOUT_DACVOLUME_MUTE_LEFT |
397 + BM_AUDIOOUT_DACVOLUME_MUTE_RIGHT,
398 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_SET);
399 + /* Power down DAC */
400 + __raw_writel(BM_AUDIOOUT_PWRDN_DAC,
401 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_SET);
402 +
403 + /* Gate DAC clocks */
404 + __raw_writel(BM_AUDIOOUT_ANACLKCTRL_CLKGATE,
405 + mxs_adc->aout_base + HW_AUDIOOUT_ANACLKCTRL_SET);
406 + __raw_writel(BM_AUDIOOUT_CTRL_CLKGATE,
407 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_SET);
408 +}
409 +
410 +static void
411 +mxs_codec_adc_power_on(struct mxs_adc_priv *mxs_adc)
412 +{
413 + u32 reg;
414 +
415 + /* Ungate ADC clocks */
416 + __raw_writel(BM_AUDIOIN_CTRL_CLKGATE,
417 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_CLR);
418 + __raw_writel(BM_AUDIOIN_ANACLKCTRL_CLKGATE,
419 + mxs_adc->ain_base + HW_AUDIOIN_ANACLKCTRL_CLR);
420 +
421 + /* 16 bit word length */
422 + __raw_writel(BM_AUDIOIN_CTRL_WORD_LENGTH,
423 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_SET);
424 +
425 + /* Unmute ADC channels */
426 + __raw_writel(BM_AUDIOIN_ADCVOL_MUTE,
427 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_CLR);
428 +
429 + /*
430 + * The MUTE_LEFT and MUTE_RIGHT fields need to be cleared.
431 + * They aren't presented in the datasheet, so this is hardcode.
432 + */
433 + __raw_writel(0x01000100, mxs_adc->ain_base + HW_AUDIOIN_ADCVOLUME_CLR);
434 +
435 + /* Set the Input channel gain 3dB */
436 + __raw_writel(BM_AUDIOIN_ADCVOL_GAIN_LEFT,
437 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_CLR);
438 + __raw_writel(BM_AUDIOIN_ADCVOL_GAIN_RIGHT,
439 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_CLR);
440 + __raw_writel(BF(2, AUDIOIN_ADCVOL_GAIN_LEFT),
441 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_SET);
442 + __raw_writel(BF(2, AUDIOIN_ADCVOL_GAIN_RIGHT),
443 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_SET);
444 +
445 + /* Select default input - Microphone */
446 + __raw_writel(BM_AUDIOIN_ADCVOL_SELECT_LEFT,
447 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_CLR);
448 + __raw_writel(BM_AUDIOIN_ADCVOL_SELECT_RIGHT,
449 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_CLR);
450 + __raw_writel(BF
451 + (BV_AUDIOIN_ADCVOL_SELECT__MIC,
452 + AUDIOIN_ADCVOL_SELECT_LEFT),
453 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_SET);
454 + __raw_writel(BF
455 + (BV_AUDIOIN_ADCVOL_SELECT__MIC,
456 + AUDIOIN_ADCVOL_SELECT_RIGHT),
457 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_SET);
458 +
459 + /* Supply bias voltage to microphone */
460 + __raw_writel(BF(1, AUDIOIN_MICLINE_MIC_RESISTOR),
461 + mxs_adc->ain_base + HW_AUDIOIN_MICLINE_SET);
462 + __raw_writel(BM_AUDIOIN_MICLINE_MIC_SELECT,
463 + mxs_adc->ain_base + HW_AUDIOIN_MICLINE_SET);
464 + __raw_writel(BF(1, AUDIOIN_MICLINE_MIC_GAIN),
465 + mxs_adc->ain_base + HW_AUDIOIN_MICLINE_SET);
466 + __raw_writel(BF(7, AUDIOIN_MICLINE_MIC_BIAS),
467 + mxs_adc->ain_base + HW_AUDIOIN_MICLINE_SET);
468 +
469 + /* Set max ADC volume */
470 + reg = __raw_readl(mxs_adc->ain_base + HW_AUDIOIN_ADCVOLUME);
471 + reg &= ~BM_AUDIOIN_ADCVOLUME_VOLUME_LEFT;
472 + reg &= ~BM_AUDIOIN_ADCVOLUME_VOLUME_RIGHT;
473 + reg |= BF(ADC_VOLUME_MAX, AUDIOIN_ADCVOLUME_VOLUME_LEFT);
474 + reg |= BF(ADC_VOLUME_MAX, AUDIOIN_ADCVOLUME_VOLUME_RIGHT);
475 + __raw_writel(reg, mxs_adc->ain_base + HW_AUDIOIN_ADCVOLUME);
476 +}
477 +
478 +static void
479 +mxs_codec_adc_power_down(struct mxs_adc_priv *mxs_adc)
480 +{
481 + /* Mute ADC channels */
482 + __raw_writel(BM_AUDIOIN_ADCVOL_MUTE,
483 + mxs_adc->ain_base + HW_AUDIOIN_ADCVOL_SET);
484 +
485 + /* Power Down ADC */
486 + __raw_writel(BM_AUDIOOUT_PWRDN_ADC | BM_AUDIOOUT_PWRDN_RIGHT_ADC,
487 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_SET);
488 +
489 + /* Gate ADC clocks */
490 + __raw_writel(BM_AUDIOIN_CTRL_CLKGATE,
491 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_SET);
492 + __raw_writel(BM_AUDIOIN_ANACLKCTRL_CLKGATE,
493 + mxs_adc->ain_base + HW_AUDIOIN_ANACLKCTRL_SET);
494 +
495 + /* Disable bias voltage to microphone */
496 + __raw_writel(BF(0, AUDIOIN_MICLINE_MIC_RESISTOR),
497 + mxs_adc->ain_base + HW_AUDIOIN_MICLINE_SET);
498 +}
499 +
500 +static void mxs_codec_dac_enable(struct mxs_adc_priv *mxs_adc)
501 +{
502 + /* Move DAC codec out of reset */
503 + __raw_writel(BM_AUDIOOUT_CTRL_SFTRST,
504 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_CLR);
505 +
506 + /* Reduce analog power */
507 + __raw_writel(BM_AUDIOOUT_TEST_HP_I1_ADJ,
508 + mxs_adc->aout_base + HW_AUDIOOUT_TEST_CLR);
509 + __raw_writel(BF(0x1, AUDIOOUT_TEST_HP_I1_ADJ),
510 + mxs_adc->aout_base + HW_AUDIOOUT_TEST_SET);
511 + __raw_writel(BM_AUDIOOUT_REFCTRL_LOW_PWR,
512 + mxs_adc->aout_base + HW_AUDIOOUT_REFCTRL_SET);
513 + __raw_writel(BM_AUDIOOUT_REFCTRL_XTAL_BGR_BIAS,
514 + mxs_adc->aout_base + HW_AUDIOOUT_REFCTRL_SET);
515 + __raw_writel(BM_AUDIOOUT_REFCTRL_BIAS_CTRL,
516 + mxs_adc->aout_base + HW_AUDIOOUT_REFCTRL_CLR);
517 + __raw_writel(BF(0x1, AUDIOOUT_REFCTRL_BIAS_CTRL),
518 + mxs_adc->aout_base + HW_AUDIOOUT_REFCTRL_CLR);
519 +
520 + /* Set Vag value */
521 + mxs_codec_dac_set_vag(mxs_adc);
522 +
523 + /* Power on DAC codec */
524 + mxs_codec_dac_power_on(mxs_adc);
525 +}
526 +
527 +static void mxs_codec_dac_disable(struct mxs_adc_priv *mxs_adc)
528 +{
529 + mxs_codec_dac_power_down(mxs_adc);
530 +}
531 +
532 +static void mxs_codec_adc_enable(struct mxs_adc_priv *mxs_adc)
533 +{
534 + /* Move ADC codec out of reset */
535 + __raw_writel(BM_AUDIOIN_CTRL_SFTRST,
536 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_CLR);
537 +
538 + /* Power on ADC codec */
539 + mxs_codec_adc_power_on(mxs_adc);
540 +}
541 +
542 +static void mxs_codec_adc_disable(struct mxs_adc_priv *mxs_adc)
543 +{
544 + mxs_codec_adc_power_down(mxs_adc);
545 +}
546 +
547 +static void mxs_codec_startup(struct snd_soc_codec *codec)
548 +{
549 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
550 +
551 + /* Soft reset DAC block */
552 + __raw_writel(BM_AUDIOOUT_CTRL_SFTRST,
553 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_SET);
554 + while (!(__raw_readl(mxs_adc->aout_base + HW_AUDIOOUT_CTRL)
555 + & BM_AUDIOOUT_CTRL_CLKGATE)){
556 + }
557 +
558 + /* Soft reset ADC block */
559 + __raw_writel(BM_AUDIOIN_CTRL_SFTRST,
560 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_SET);
561 + while (!(__raw_readl(mxs_adc->ain_base + HW_AUDIOIN_CTRL)
562 + & BM_AUDIOIN_CTRL_CLKGATE)){
563 + }
564 +
565 + mxs_codec_dac_enable(mxs_adc);
566 + mxs_codec_adc_enable(mxs_adc);
567 +
568 + /* Sync regs and cache */
569 + mxs_codec_sync_reg_cache(codec);
570 +}
571 +
572 +static void mxs_codec_stop(struct snd_soc_codec *codec)
573 +{
574 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
575 +
576 + mxs_codec_dac_disable(mxs_adc);
577 + mxs_codec_adc_disable(mxs_adc);
578 +}
579 +/* END Codec routines */
580 +
581 +/* kcontrol */
582 +static int dac_info_volsw(struct snd_kcontrol *kcontrol,
583 + struct snd_ctl_elem_info *uinfo)
584 +{
585 + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
586 + uinfo->count = 2;
587 + uinfo->value.integer.min = 0;
588 + uinfo->value.integer.max = 0xf;
589 + return 0;
590 +}
591 +
592 +static int dac_get_volsw(struct snd_kcontrol *kcontrol,
593 + struct snd_ctl_elem_value *ucontrol)
594 +{
595 + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
596 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
597 + int reg, l, r;
598 + int i;
599 +
600 + reg = __raw_readl(mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME);
601 +
602 + l = (reg & BM_AUDIOOUT_DACVOLUME_VOLUME_LEFT) >>
603 + BP_AUDIOOUT_DACVOLUME_VOLUME_LEFT;
604 + r = (reg & BM_AUDIOOUT_DACVOLUME_VOLUME_RIGHT) >>
605 + BP_AUDIOOUT_DACVOLUME_VOLUME_RIGHT;
606 + /*Left channel */
607 + i = 0;
608 + while (i < 16) {
609 + if (l == dac_volumn_control_word[i]) {
610 + ucontrol->value.integer.value[0] = i;
611 + break;
612 + }
613 + i++;
614 + }
615 + if (i == 16)
616 + ucontrol->value.integer.value[0] = i;
617 + /*Right channel */
618 + i = 0;
619 + while (i < 16) {
620 + if (r == dac_volumn_control_word[i]) {
621 + ucontrol->value.integer.value[1] = i;
622 + break;
623 + }
624 + i++;
625 + }
626 + if (i == 16)
627 + ucontrol->value.integer.value[1] = i;
628 +
629 + return 0;
630 +}
631 +
632 +static int dac_put_volsw(struct snd_kcontrol *kcontrol,
633 + struct snd_ctl_elem_value *ucontrol)
634 +{
635 + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
636 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
637 + int reg, l, r;
638 + int i;
639 +
640 + i = ucontrol->value.integer.value[0];
641 + l = dac_volumn_control_word[i];
642 + /*Get dac volume for left channel */
643 + reg = BF(l, AUDIOOUT_DACVOLUME_VOLUME_LEFT);
644 +
645 + i = ucontrol->value.integer.value[1];
646 + r = dac_volumn_control_word[i];
647 + /*Get dac volume for right channel */
648 + reg = reg | BF(r, AUDIOOUT_DACVOLUME_VOLUME_RIGHT);
649 +
650 + /*Clear left/right dac volume */
651 + __raw_writel(BM_AUDIOOUT_DACVOLUME_VOLUME_LEFT |
652 + BM_AUDIOOUT_DACVOLUME_VOLUME_RIGHT,
653 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_CLR);
654 + __raw_writel(reg, mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_SET);
655 +
656 + return 0;
657 +}
658 +
659 +static const char *mxs_codec_adc_input_sel[] = {
660 + "Mic", "Line In 1", "Head Phone", "Line In 2" };
661 +
662 +static const char *mxs_codec_hp_output_sel[] = { "DAC Out", "Line In 1" };
663 +
664 +static const char *mxs_codec_adc_3d_sel[] = {
665 + "Off", "Low", "Medium", "High" };
666 +
667 +static const struct soc_enum mxs_codec_enum[] = {
668 + SOC_ENUM_SINGLE(ADC_ADCVOL_L, 12, 4, mxs_codec_adc_input_sel),
669 + SOC_ENUM_SINGLE(ADC_ADCVOL_L, 4, 4, mxs_codec_adc_input_sel),
670 + SOC_ENUM_SINGLE(DAC_HPVOL_H, 0, 2, mxs_codec_hp_output_sel),
671 + SOC_ENUM_SINGLE(DAC_CTRL_L, 8, 4, mxs_codec_adc_3d_sel),
672 +};
673 +
674 +static const struct snd_kcontrol_new mxs_snd_controls[] = {
675 + /* Playback Volume */
676 + {
677 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
678 + .name = "DAC Playback Volume",
679 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
680 + SNDRV_CTL_ELEM_ACCESS_VOLATILE,
681 + .info = dac_info_volsw,
682 + .get = dac_get_volsw,
683 + .put = dac_put_volsw,
684 + },
685 +
686 + SOC_DOUBLE_R("DAC Playback Switch",
687 + DAC_VOLUME_H, DAC_VOLUME_L, 8, 0x01, 1),
688 + SOC_DOUBLE("HP Playback Volume", DAC_HPVOL_L, 8, 0, 0x7F, 1),
689 +
690 + /* Capture Volume */
691 + SOC_DOUBLE_R("ADC Capture Volume",
692 + ADC_VOLUME_H, ADC_VOLUME_L, 0, 0xFF, 0),
693 + SOC_DOUBLE("ADC PGA Capture Volume", ADC_ADCVOL_L, 8, 0, 0x0F, 0),
694 + SOC_SINGLE("ADC PGA Capture Switch", ADC_ADCVOL_H, 8, 0x1, 1),
695 + SOC_SINGLE("Mic PGA Capture Volume", ADC_MICLINE_L, 0, 0x03, 0),
696 +
697 + /* Virtual 3D effect */
698 + SOC_ENUM("3D effect", mxs_codec_enum[3]),
699 +};
700 +/* END kcontrol */
701 +
702 +/* DAPM */
703 +static int pga_event(struct snd_soc_dapm_widget *w,
704 + struct snd_kcontrol *kcontrol, int event)
705 +{
706 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(w->codec);
707 +
708 + switch (event) {
709 + case SND_SOC_DAPM_PRE_PMU:
710 + /* Prepare powering up HP and SPEAKER output */
711 + __raw_writel(BM_AUDIOOUT_ANACTRL_HP_HOLD_GND,
712 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_SET);
713 + __raw_writel(BM_RTC_PERSISTENT0_RELEASE_GND,
714 + mxs_adc->rtc_base + HW_RTC_PERSISTENT0_SET);
715 + msleep(100);
716 + break;
717 + case SND_SOC_DAPM_POST_PMU:
718 + __raw_writel(BM_AUDIOOUT_ANACTRL_HP_HOLD_GND,
719 + mxs_adc->aout_base + HW_AUDIOOUT_ANACTRL_CLR);
720 + break;
721 + case SND_SOC_DAPM_POST_PMD:
722 + __raw_writel(BM_RTC_PERSISTENT0_RELEASE_GND,
723 + mxs_adc->rtc_base + HW_RTC_PERSISTENT0_CLR);
724 + break;
725 + }
726 + return 0;
727 +}
728 +
729 +static int adc_event(struct snd_soc_dapm_widget *w,
730 + struct snd_kcontrol *kcontrol, int event)
731 +{
732 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(w->codec);
733 +
734 + switch (event) {
735 + case SND_SOC_DAPM_PRE_PMU:
736 + __raw_writel(BM_RTC_PERSISTENT0_RELEASE_GND,
737 + mxs_adc->rtc_base + HW_RTC_PERSISTENT0_SET);
738 + msleep(100);
739 + break;
740 + case SND_SOC_DAPM_POST_PMD:
741 + __raw_writel(BM_RTC_PERSISTENT0_RELEASE_GND,
742 + mxs_adc->rtc_base + HW_RTC_PERSISTENT0_CLR);
743 + break;
744 + }
745 + return 0;
746 +}
747 +
748 +/* Left ADC Mux */
749 +static const struct snd_kcontrol_new mxs_left_adc_controls =
750 +SOC_DAPM_ENUM("Route", mxs_codec_enum[0]);
751 +
752 +/* Right ADC Mux */
753 +static const struct snd_kcontrol_new mxs_right_adc_controls =
754 +SOC_DAPM_ENUM("Route", mxs_codec_enum[1]);
755 +
756 +/* Head Phone Mux */
757 +static const struct snd_kcontrol_new mxs_hp_controls =
758 +SOC_DAPM_ENUM("Route", mxs_codec_enum[2]);
759 +
760 +static const struct snd_soc_dapm_widget mxs_dapm_widgets[] = {
761 + SND_SOC_DAPM_ADC_E("ADC", "Capture", DAC_PWRDN_L, 8, 1, adc_event,
762 + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
763 +
764 + SND_SOC_DAPM_DAC("DAC", "Playback", DAC_PWRDN_L, 12, 1),
765 +
766 + SND_SOC_DAPM_MUX("Left ADC Mux", SND_SOC_NOPM, 0, 0,
767 + &mxs_left_adc_controls),
768 + SND_SOC_DAPM_MUX("Right ADC Mux", SND_SOC_NOPM, 0, 0,
769 + &mxs_right_adc_controls),
770 + SND_SOC_DAPM_MUX("HP Mux", SND_SOC_NOPM, 0, 0,
771 + &mxs_hp_controls),
772 + SND_SOC_DAPM_PGA_E("HP AMP", DAC_PWRDN_L, 0, 1, NULL, 0, pga_event,
773 + SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
774 + SND_SOC_DAPM_POST_PMD),
775 + SND_SOC_DAPM_PGA("SPEAKER AMP", DAC_PWRDN_H, 8, 1, NULL, 0),
776 + SND_SOC_DAPM_INPUT("LINE1L"),
777 + SND_SOC_DAPM_INPUT("LINE1R"),
778 + SND_SOC_DAPM_INPUT("LINE2L"),
779 + SND_SOC_DAPM_INPUT("LINE2R"),
780 + SND_SOC_DAPM_INPUT("MIC"),
781 +
782 + SND_SOC_DAPM_OUTPUT("SPEAKER"),
783 + SND_SOC_DAPM_OUTPUT("HPL"),
784 + SND_SOC_DAPM_OUTPUT("HPR"),
785 +};
786 +
787 +/* routes for sgtl5000 */
788 +static const struct snd_soc_dapm_route mxs_dapm_routes[] = {
789 + /* Left ADC Mux */
790 + {"Left ADC Mux", "Mic", "MIC"},
791 + {"Left ADC Mux", "Line In 1", "LINE1L"},
792 + {"Left ADC Mux", "Line In 2", "LINE2L"},
793 + {"Left ADC Mux", "Head Phone", "HPL"},
794 +
795 + /* Right ADC Mux */
796 + {"Right ADC Mux", "Mic", "MIC"},
797 + {"Right ADC Mux", "Line In 1", "LINE1R"},
798 + {"Right ADC Mux", "Line In 2", "LINE2R"},
799 + {"Right ADC Mux", "Head Phone", "HPR"},
800 +
801 + /* ADC */
802 + {"ADC", NULL, "Left ADC Mux"},
803 + {"ADC", NULL, "Right ADC Mux"},
804 +
805 + /* HP Mux */
806 + {"HP Mux", "DAC Out", "DAC"},
807 + {"HP Mux", "Line In 1", "LINE1L"},
808 + {"HP Mux", "Line In 1", "LINE1R"},
809 +
810 + /* HP amp */
811 + {"HP AMP", NULL, "HP Mux"},
812 + /* HP output */
813 + {"HPR", NULL, "HP AMP"},
814 + {"HPL", NULL, "HP AMP"},
815 +
816 + /* Speaker amp */
817 + {"SPEAKER AMP", NULL, "DAC"},
818 + {"SPEAKER", NULL, "SPEAKER AMP"},
819 +};
820 +/* END DAPM */
821 +
822 +static int mxs_set_bias_level(struct snd_soc_codec *codec,
823 + enum snd_soc_bias_level level)
824 +{
825 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
826 +
827 + pr_debug("dapm level %d\n", level);
828 + switch (level) {
829 + case SND_SOC_BIAS_ON: /* full On */
830 + if (codec->dapm.bias_level == SND_SOC_BIAS_ON)
831 + break;
832 + break;
833 +
834 + case SND_SOC_BIAS_PREPARE: /* partial On */
835 + if (codec->dapm.bias_level == SND_SOC_BIAS_PREPARE)
836 + break;
837 + /* Set Capless mode */
838 + __raw_writel(BM_AUDIOOUT_PWRDN_CAPLESS,
839 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_CLR);
840 + break;
841 +
842 + case SND_SOC_BIAS_STANDBY: /* Off, with power */
843 + if (codec->dapm.bias_level == SND_SOC_BIAS_STANDBY)
844 + break;
845 + /* Unset Capless mode */
846 + __raw_writel(BM_AUDIOOUT_PWRDN_CAPLESS,
847 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_SET);
848 + break;
849 +
850 + case SND_SOC_BIAS_OFF: /* Off, without power */
851 + if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
852 + break;
853 + /* Unset Capless mode */
854 + __raw_writel(BM_AUDIOOUT_PWRDN_CAPLESS,
855 + mxs_adc->aout_base + HW_AUDIOOUT_PWRDN_SET);
856 + break;
857 + }
858 +
859 + codec->dapm.bias_level = level;
860 + return 0;
861 +}
862 +
863 +/* MXS-ADC Codec DAI driver */
864 +static int mxs_pcm_hw_params(struct snd_pcm_substream *substream,
865 + struct snd_pcm_hw_params *params,
866 + struct snd_soc_dai *dai)
867 +{
868 + struct snd_soc_codec *codec = dai->codec;
869 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec);
870 + int playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0;
871 + int i;
872 + u32 srr_value = 0;
873 + u32 src_hold = 0;
874 +
875 + i = get_srr_values(params_rate(params));
876 + if (i < 0)
877 + dev_warn(codec->dev, "%s doesn't support rate %d\n",
878 + codec->name, params_rate(params));
879 + else {
880 + src_hold = srr_values[i].src_hold;
881 +
882 + srr_value =
883 + BF(srr_values[i].basemult, AUDIOOUT_DACSRR_BASEMULT) |
884 + BF(srr_values[i].src_int, AUDIOOUT_DACSRR_SRC_INT) |
885 + BF(srr_values[i].src_frac, AUDIOOUT_DACSRR_SRC_FRAC) |
886 + BF(src_hold, AUDIOOUT_DACSRR_SRC_HOLD);
887 +
888 + if (playback)
889 + __raw_writel(srr_value,
890 + mxs_adc->aout_base + HW_AUDIOOUT_DACSRR);
891 + else
892 + __raw_writel(srr_value,
893 + mxs_adc->ain_base + HW_AUDIOIN_ADCSRR);
894 + }
895 +
896 + switch (params_format(params)) {
897 + case SNDRV_PCM_FORMAT_S16_LE:
898 + if (playback)
899 + __raw_writel(BM_AUDIOOUT_CTRL_WORD_LENGTH,
900 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_SET);
901 + else
902 + __raw_writel(BM_AUDIOIN_CTRL_WORD_LENGTH,
903 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_SET);
904 +
905 + break;
906 +
907 + case SNDRV_PCM_FORMAT_S32_LE:
908 + if (playback)
909 + __raw_writel(BM_AUDIOOUT_CTRL_WORD_LENGTH,
910 + mxs_adc->aout_base + HW_AUDIOOUT_CTRL_CLR);
911 + else
912 + __raw_writel(BM_AUDIOIN_CTRL_WORD_LENGTH,
913 + mxs_adc->ain_base + HW_AUDIOIN_CTRL_CLR);
914 +
915 + break;
916 +
917 + default:
918 + dev_warn(codec->dev, "%s doesn't support format %d\n",
919 + codec->name, params_format(params));
920 +
921 + }
922 +
923 + return 0;
924 +}
925 +
926 +/* mute the codec used by alsa core */
927 +static int mxs_codec_dig_mute(struct snd_soc_dai *codec_dai, int mute)
928 +{
929 + struct mxs_adc_priv *mxs_adc = snd_soc_codec_get_drvdata(codec_dai->codec);
930 + int l, r;
931 + int ll, rr;
932 + u32 reg, reg1, reg2;
933 + u32 dac_mask = BM_AUDIOOUT_DACVOLUME_MUTE_LEFT |
934 + BM_AUDIOOUT_DACVOLUME_MUTE_RIGHT;
935 +
936 + if (mute) {
937 + reg = __raw_readl(mxs_adc->aout_base + \
938 + HW_AUDIOOUT_DACVOLUME);
939 +
940 + reg1 = reg & ~BM_AUDIOOUT_DACVOLUME_VOLUME_LEFT;
941 + reg1 = reg1 & ~BM_AUDIOOUT_DACVOLUME_VOLUME_RIGHT;
942 +
943 + l = (reg & BM_AUDIOOUT_DACVOLUME_VOLUME_LEFT) >>
944 + BP_AUDIOOUT_DACVOLUME_VOLUME_LEFT;
945 + r = (reg & BM_AUDIOOUT_DACVOLUME_VOLUME_RIGHT) >>
946 + BP_AUDIOOUT_DACVOLUME_VOLUME_RIGHT;
947 +
948 + /* fade out dac vol */
949 + while ((l > DAC_VOLUME_MIN) || (r > DAC_VOLUME_MIN)) {
950 + l -= 0x8;
951 + r -= 0x8;
952 + ll = l > DAC_VOLUME_MIN ? l : DAC_VOLUME_MIN;
953 + rr = r > DAC_VOLUME_MIN ? r : DAC_VOLUME_MIN;
954 + reg2 = reg1 | BF_AUDIOOUT_DACVOLUME_VOLUME_LEFT(ll)
955 + | BF_AUDIOOUT_DACVOLUME_VOLUME_RIGHT(rr);
956 + __raw_writel(reg2,
957 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME);
958 + msleep(1);
959 + }
960 +
961 + __raw_writel(dac_mask,
962 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_SET);
963 + reg = reg | dac_mask;
964 + __raw_writel(reg,
965 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME);
966 + } else
967 + __raw_writel(dac_mask,
968 + mxs_adc->aout_base + HW_AUDIOOUT_DACVOLUME_CLR);
969 +
970 + return 0;
971 +}
972 +
973 +#define MXS_ADC_RATES SNDRV_PCM_RATE_8000_192000
974 +#define MXS_ADC_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
975 +
976 +static const struct snd_soc_dai_ops mxs_codec_dai_ops = {
977 + .hw_params = mxs_pcm_hw_params,
978 + .digital_mute = mxs_codec_dig_mute,
979 +};
980 +
981 +static struct snd_soc_dai_driver mxs_codec_dai_driver = {
982 + .name = "mxs-builtin-codec-dai",
983 + .playback = {
984 + .stream_name = "Playback",
985 + .channels_min = 2,
986 + .channels_max = 2,
987 + .rates = MXS_ADC_RATES,
988 + .formats = MXS_ADC_FORMATS,
989 + },
990 + .capture = {
991 + .stream_name = "Capture",
992 + .channels_min = 2,
993 + .channels_max = 2,
994 + .rates = MXS_ADC_RATES,
995 + .formats = MXS_ADC_FORMATS,
996 + },
997 + .ops = &mxs_codec_dai_ops,
998 +};
999 +/* END MXS-ADC Codec DAI driver */
1000 +
1001 +/* MXS-ADC Codec driver */
1002 +static int mxs_codec_driver_probe(struct snd_soc_codec *codec)
1003 +{
1004 + int ret = 0;
1005 + /* We don't use snd_soc_codec_set_cache_io because we are using
1006 + * our own IO functions: write, read. */
1007 +
1008 + mxs_codec_startup(codec);
1009 +
1010 + /* leading to standby state */
1011 + ret = mxs_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1012 + if (ret)
1013 + goto err;
1014 +
1015 + return 0;
1016 +
1017 +err:
1018 + mxs_codec_stop(codec);
1019 +
1020 + return ret;
1021 +}
1022 +
1023 +static int mxs_codec_driver_remove(struct snd_soc_codec *codec)
1024 +{
1025 + mxs_codec_stop(codec);
1026 +
1027 + return 0;
1028 +}
1029 +
1030 +// static int mxs_codec_driver_suspend(struct snd_soc_codec *codec)
1031 +// {
1032 +// /* TODO Enable power management. */
1033 +// return 0;
1034 +// }
1035 +
1036 +// static int mxs_codec_driver_resume(struct snd_soc_codec *codec)
1037 +// {
1038 +// /* TODO Enable power management. */
1039 +// return 0;
1040 +// }
1041 +
1042 +static struct snd_soc_codec_driver mxs_codec_driver = {
1043 + .probe = mxs_codec_driver_probe,
1044 + .remove = mxs_codec_driver_remove,
1045 +// .suspend = mxs_codec_driver_suspend,
1046 +// .resume = mxs_codec_driver_resume,
1047 + .set_bias_level = mxs_set_bias_level,
1048 + .reg_cache_size = ADC_REGNUM,
1049 + .reg_word_size = sizeof(u16),
1050 + .reg_cache_step = 1,
1051 +// .reg_cache_default = mxsadc_regs,
1052 +// .volatile_register = sgtl5000_volatile_register,
1053 + .controls = mxs_snd_controls,
1054 + .num_controls = ARRAY_SIZE(mxs_snd_controls),
1055 + .dapm_widgets = mxs_dapm_widgets,
1056 + .num_dapm_widgets = ARRAY_SIZE(mxs_dapm_widgets),
1057 + .dapm_routes = mxs_dapm_routes,
1058 + .num_dapm_routes = ARRAY_SIZE(mxs_dapm_routes),
1059 + .write = mxs_codec_write,
1060 + .read = mxs_codec_read,
1061 +};
1062 +/* END MXS-ADC Codec driver */
1063 +
1064 +/* Underlying platform device that registers codec */
1065 +static int mxs_adc_probe(struct platform_device *pdev)
1066 +{
1067 + struct mxs_adc_priv *mxs_adc;
1068 + struct resource *r;
1069 + int ret;
1070 +
1071 + mxs_adc = devm_kzalloc(&pdev->dev, sizeof(struct mxs_adc_priv), GFP_KERNEL);
1072 + if (!mxs_adc)
1073 + return -ENOMEM;
1074 +
1075 + platform_set_drvdata(pdev, mxs_adc);
1076 +
1077 + /* audio-in IO memory */
1078 + r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audioin");
1079 + if (IS_ERR(r)) {
1080 + dev_err(&pdev->dev, "failed to get resource\n");
1081 + return PTR_ERR(r);
1082 + }
1083 +
1084 + mxs_adc->ain_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
1085 + if (IS_ERR(mxs_adc->ain_base)) {
1086 + dev_err(&pdev->dev, "ioremap failed\n");
1087 + return PTR_ERR(mxs_adc->ain_base);
1088 + }
1089 +
1090 + /* audio-out IO memory */
1091 + r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audioout");
1092 + if (IS_ERR(r)) {
1093 + dev_err(&pdev->dev, "failed to get resource\n");
1094 + return PTR_ERR(r);
1095 + }
1096 +
1097 + mxs_adc->aout_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
1098 + if (IS_ERR(mxs_adc->aout_base)) {
1099 + dev_err(&pdev->dev, "ioremap failed\n");
1100 + return PTR_ERR(mxs_adc->aout_base);
1101 + }
1102 +
1103 + /* rtc IO memory */
1104 + r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rtc");
1105 + if (IS_ERR(r)) {
1106 + dev_err(&pdev->dev, "failed to get resource\n");
1107 + return PTR_ERR(r);
1108 + }
1109 +
1110 + mxs_adc->rtc_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
1111 + if (IS_ERR(mxs_adc->rtc_base)) {
1112 + dev_err(&pdev->dev, "ioremap failed\n");
1113 + return PTR_ERR(mxs_adc->rtc_base);
1114 + }
1115 +
1116 + /* Get audio clock */
1117 + mxs_adc->clk = devm_clk_get(&pdev->dev, "filt");
1118 + if (IS_ERR(mxs_adc->clk)) {
1119 + ret = PTR_ERR(mxs_adc->clk);
1120 + dev_err(&pdev->dev, "%s: Clock initialization failed\n", __func__);
1121 + return ret;
1122 + }
1123 +
1124 + /* Turn on audio clock */
1125 + ret = clk_prepare_enable(mxs_adc->clk);
1126 + if (unlikely(ret != 0)) {
1127 + dev_err(&pdev->dev, "%s: Clock prepare or enable failed\n", __func__);
1128 + return ret;
1129 + }
1130 +
1131 + ret = snd_soc_register_codec(&pdev->dev,
1132 + &mxs_codec_driver,&mxs_codec_dai_driver, 1);
1133 + if (unlikely(ret != 0)) {
1134 + dev_err(&pdev->dev, "Codec registration failed\n");
1135 + goto disable_clk;
1136 + }
1137 +
1138 + return 0;
1139 +
1140 +disable_clk:
1141 + clk_disable_unprepare(mxs_adc->clk);
1142 + return ret;
1143 +}
1144 +
1145 +static int mxs_adc_remove(struct platform_device *pdev)
1146 +{
1147 + struct mxs_adc_priv *mxs_adc = platform_get_drvdata(pdev);
1148 +
1149 + clk_disable_unprepare(mxs_adc->clk);
1150 + snd_soc_unregister_codec(&pdev->dev);
1151 +
1152 + return 0;
1153 +}
1154 +
1155 +static const struct of_device_id mxs_adc_dt_ids[] = {
1156 + { .compatible = "fsl,mxs-builtin-codec", },
1157 + { /* sentinel */ }
1158 +};
1159 +MODULE_DEVICE_TABLE(of, mxs_adc_dt_ids);
1160 +
1161 +static struct platform_driver mxs_adc_driver = {
1162 + .driver = {
1163 + .name = "mxs-builtin-codec",
1164 + .owner = THIS_MODULE,
1165 + .of_match_table = mxs_adc_dt_ids,
1166 + },
1167 + .probe = mxs_adc_probe,
1168 + .remove = mxs_adc_remove,
1169 +};
1170 +
1171 +module_platform_driver(mxs_adc_driver);
1172 +/* END Underlying platform device that registers codec */
1173 +
1174 +MODULE_DESCRIPTION("Freescale MXS ADC/DAC SoC Codec Driver");
1175 +MODULE_AUTHOR("Michal Ulianko <michal.ulianko@gmail.com>");
1176 +MODULE_LICENSE("GPL");
1177 diff --git a/sound/soc/codecs/mxs-builtin-codec.h b/sound/soc/codecs/mxs-builtin-codec.h
1178 new file mode 100644
1179 index 0000000..75dee0b
1180 --- /dev/null
1181 +++ b/sound/soc/codecs/mxs-builtin-codec.h
1182 @@ -0,0 +1,825 @@
1183 +#ifndef __MXS_ADC_CODEC_H
1184 +
1185 +#include <linux/io.h>
1186 +
1187 +/* MXS ADC/DAC registers */
1188 +#define DAC_CTRL_L 0
1189 +#define DAC_CTRL_H 1
1190 +#define DAC_STAT_L 2
1191 +#define DAC_STAT_H 3
1192 +#define DAC_SRR_L 4
1193 +#define DAC_VOLUME_L 6
1194 +#define DAC_VOLUME_H 7
1195 +#define DAC_DEBUG_L 8
1196 +#define DAC_DEBUG_H 9
1197 +#define DAC_HPVOL_L 10
1198 +#define DAC_HPVOL_H 11
1199 +#define DAC_PWRDN_L 12
1200 +#define DAC_PWRDN_H 13
1201 +#define DAC_REFCTRL_L 14
1202 +#define DAC_REFCTRL_H 15
1203 +#define DAC_ANACTRL_L 16
1204 +#define DAC_ANACTRL_H 17
1205 +#define DAC_TEST_L 18
1206 +#define DAC_TEST_H 19
1207 +#define DAC_BISTCTRL_L 20
1208 +#define DAC_BISTCTRL_H 21
1209 +#define DAC_BISTSTAT0_L 22
1210 +#define DAC_BISTSTAT0_H 23
1211 +#define DAC_BISTSTAT1_L 24
1212 +#define DAC_BISTSTAT1_H 25
1213 +#define DAC_ANACLKCTRL_L 26
1214 +#define DAC_ANACLKCTRL_H 27
1215 +#define DAC_DATA_L 28
1216 +#define DAC_DATA_H 29
1217 +#define DAC_SPEAKERCTRL_L 30
1218 +#define DAC_SPEAKERCTRL_H 31
1219 +#define DAC_VERSION_L 32
1220 +#define DAC_VERSION_H 33
1221 +#define ADC_CTRL_L 34
1222 +#define ADC_CTRL_H 35
1223 +#define ADC_STAT_L 36
1224 +#define ADC_STAT_H 37
1225 +#define ADC_SRR_L 38
1226 +#define ADC_SRR_H 39
1227 +#define ADC_VOLUME_L 40
1228 +#define ADC_VOLUME_H 41
1229 +#define ADC_DEBUG_L 42
1230 +#define ADC_DEBUG_H 43
1231 +#define ADC_ADCVOL_L 44
1232 +#define ADC_ADCVOL_H 45
1233 +#define ADC_MICLINE_L 46
1234 +#define ADC_MICLINE_H 47
1235 +#define ADC_ANACLKCTRL_L 48
1236 +#define ADC_ANACLKCTRL_H 49
1237 +#define ADC_DATA_L 50
1238 +#define ADC_DATA_H 51
1239 +
1240 +#define ADC_REGNUM 52
1241 +
1242 +#define DAC_VOLUME_MIN 0x37
1243 +#define DAC_VOLUME_MAX 0xFE
1244 +#define ADC_VOLUME_MIN 0x37
1245 +#define ADC_VOLUME_MAX 0xFE
1246 +#define HP_VOLUME_MAX 0x0
1247 +#define HP_VOLUME_MIN 0x7F
1248 +#define LO_VOLUME_MAX 0x0
1249 +#define LO_VOLUME_MIN 0x1F
1250 +
1251 +/* RTC */
1252 +#define HW_RTC_PERSISTENT0 (0x00000060)
1253 +#define HW_RTC_PERSISTENT0_SET (0x00000064)
1254 +#define HW_RTC_PERSISTENT0_CLR (0x00000068)
1255 +#define HW_RTC_PERSISTENT0_TOG (0x0000006c)
1256 +
1257 +// TODO
1258 +//#define BM_RTC_PERSISTENT0_RELEASE_GND 0x00080000
1259 +
1260 +/* AUDIOOUT */
1261 +#define HW_AUDIOOUT_CTRL (0x00000000)
1262 +#define HW_AUDIOOUT_CTRL_SET (0x00000004)
1263 +#define HW_AUDIOOUT_CTRL_CLR (0x00000008)
1264 +#define HW_AUDIOOUT_CTRL_TOG (0x0000000c)
1265 +
1266 +#define BM_AUDIOOUT_CTRL_SFTRST 0x80000000
1267 +#define BM_AUDIOOUT_CTRL_CLKGATE 0x40000000
1268 +#define BP_AUDIOOUT_CTRL_RSRVD4 21
1269 +#define BM_AUDIOOUT_CTRL_RSRVD4 0x3FE00000
1270 +#define BF_AUDIOOUT_CTRL_RSRVD4(v) \
1271 + (((v) << 21) & BM_AUDIOOUT_CTRL_RSRVD4)
1272 +#define BP_AUDIOOUT_CTRL_DMAWAIT_COUNT 16
1273 +#define BM_AUDIOOUT_CTRL_DMAWAIT_COUNT 0x001F0000
1274 +#define BF_AUDIOOUT_CTRL_DMAWAIT_COUNT(v) \
1275 + (((v) << 16) & BM_AUDIOOUT_CTRL_DMAWAIT_COUNT)
1276 +#define BM_AUDIOOUT_CTRL_RSRVD3 0x00008000
1277 +#define BM_AUDIOOUT_CTRL_LR_SWAP 0x00004000
1278 +#define BM_AUDIOOUT_CTRL_EDGE_SYNC 0x00002000
1279 +#define BM_AUDIOOUT_CTRL_INVERT_1BIT 0x00001000
1280 +#define BP_AUDIOOUT_CTRL_RSRVD2 10
1281 +#define BM_AUDIOOUT_CTRL_RSRVD2 0x00000C00
1282 +#define BF_AUDIOOUT_CTRL_RSRVD2(v) \
1283 + (((v) << 10) & BM_AUDIOOUT_CTRL_RSRVD2)
1284 +#define BP_AUDIOOUT_CTRL_SS3D_EFFECT 8
1285 +#define BM_AUDIOOUT_CTRL_SS3D_EFFECT 0x00000300
1286 +#define BF_AUDIOOUT_CTRL_SS3D_EFFECT(v) \
1287 + (((v) << 8) & BM_AUDIOOUT_CTRL_SS3D_EFFECT)
1288 +#define BM_AUDIOOUT_CTRL_RSRVD1 0x00000080
1289 +#define BM_AUDIOOUT_CTRL_WORD_LENGTH 0x00000040
1290 +#define BM_AUDIOOUT_CTRL_DAC_ZERO_ENABLE 0x00000020
1291 +#define BM_AUDIOOUT_CTRL_LOOPBACK 0x00000010
1292 +#define BM_AUDIOOUT_CTRL_FIFO_UNDERFLOW_IRQ 0x00000008
1293 +#define BM_AUDIOOUT_CTRL_FIFO_OVERFLOW_IRQ 0x00000004
1294 +#define BM_AUDIOOUT_CTRL_FIFO_ERROR_IRQ_EN 0x00000002
1295 +#define BM_AUDIOOUT_CTRL_RUN 0x00000001
1296 +
1297 +#define HW_AUDIOOUT_STAT (0x00000010)
1298 +#define HW_AUDIOOUT_STAT_SET (0x00000014)
1299 +#define HW_AUDIOOUT_STAT_CLR (0x00000018)
1300 +#define HW_AUDIOOUT_STAT_TOG (0x0000001c)
1301 +
1302 +#define BM_AUDIOOUT_STAT_DAC_PRESENT 0x80000000
1303 +#define BP_AUDIOOUT_STAT_RSRVD1 0
1304 +#define BM_AUDIOOUT_STAT_RSRVD1 0x7FFFFFFF
1305 +#define BF_AUDIOOUT_STAT_RSRVD1(v) \
1306 + (((v) << 0) & BM_AUDIOOUT_STAT_RSRVD1)
1307 +
1308 +#define HW_AUDIOOUT_DACSRR (0x00000020)
1309 +#define HW_AUDIOOUT_DACSRR_SET (0x00000024)
1310 +#define HW_AUDIOOUT_DACSRR_CLR (0x00000028)
1311 +#define HW_AUDIOOUT_DACSRR_TOG (0x0000002c)
1312 +
1313 +#define BM_AUDIOOUT_DACSRR_OSR 0x80000000
1314 +#define BV_AUDIOOUT_DACSRR_OSR__OSR6 0x0
1315 +#define BV_AUDIOOUT_DACSRR_OSR__OSR12 0x1
1316 +#define BP_AUDIOOUT_DACSRR_BASEMULT 28
1317 +#define BM_AUDIOOUT_DACSRR_BASEMULT 0x70000000
1318 +#define BF_AUDIOOUT_DACSRR_BASEMULT(v) \
1319 + (((v) << 28) & BM_AUDIOOUT_DACSRR_BASEMULT)
1320 +#define BV_AUDIOOUT_DACSRR_BASEMULT__SINGLE_RATE 0x1
1321 +#define BV_AUDIOOUT_DACSRR_BASEMULT__DOUBLE_RATE 0x2
1322 +#define BV_AUDIOOUT_DACSRR_BASEMULT__QUAD_RATE 0x4
1323 +#define BM_AUDIOOUT_DACSRR_RSRVD2 0x08000000
1324 +#define BP_AUDIOOUT_DACSRR_SRC_HOLD 24
1325 +#define BM_AUDIOOUT_DACSRR_SRC_HOLD 0x07000000
1326 +#define BF_AUDIOOUT_DACSRR_SRC_HOLD(v) \
1327 + (((v) << 24) & BM_AUDIOOUT_DACSRR_SRC_HOLD)
1328 +#define BP_AUDIOOUT_DACSRR_RSRVD1 21
1329 +#define BM_AUDIOOUT_DACSRR_RSRVD1 0x00E00000
1330 +#define BF_AUDIOOUT_DACSRR_RSRVD1(v) \
1331 + (((v) << 21) & BM_AUDIOOUT_DACSRR_RSRVD1)
1332 +#define BP_AUDIOOUT_DACSRR_SRC_INT 16
1333 +#define BM_AUDIOOUT_DACSRR_SRC_INT 0x001F0000
1334 +#define BF_AUDIOOUT_DACSRR_SRC_INT(v) \
1335 + (((v) << 16) & BM_AUDIOOUT_DACSRR_SRC_INT)
1336 +#define BP_AUDIOOUT_DACSRR_RSRVD0 13
1337 +#define BM_AUDIOOUT_DACSRR_RSRVD0 0x0000E000
1338 +#define BF_AUDIOOUT_DACSRR_RSRVD0(v) \
1339 + (((v) << 13) & BM_AUDIOOUT_DACSRR_RSRVD0)
1340 +#define BP_AUDIOOUT_DACSRR_SRC_FRAC 0
1341 +#define BM_AUDIOOUT_DACSRR_SRC_FRAC 0x00001FFF
1342 +#define BF_AUDIOOUT_DACSRR_SRC_FRAC(v) \
1343 + (((v) << 0) & BM_AUDIOOUT_DACSRR_SRC_FRAC)
1344 +
1345 +#define HW_AUDIOOUT_DACVOLUME (0x00000030)
1346 +#define HW_AUDIOOUT_DACVOLUME_SET (0x00000034)
1347 +#define HW_AUDIOOUT_DACVOLUME_CLR (0x00000038)
1348 +#define HW_AUDIOOUT_DACVOLUME_TOG (0x0000003c)
1349 +
1350 +#define BP_AUDIOOUT_DACVOLUME_RSRVD4 29
1351 +#define BM_AUDIOOUT_DACVOLUME_RSRVD4 0xE0000000
1352 +#define BF_AUDIOOUT_DACVOLUME_RSRVD4(v) \
1353 + (((v) << 29) & BM_AUDIOOUT_DACVOLUME_RSRVD4)
1354 +#define BM_AUDIOOUT_DACVOLUME_VOLUME_UPDATE_LEFT 0x10000000
1355 +#define BP_AUDIOOUT_DACVOLUME_RSRVD3 26
1356 +#define BM_AUDIOOUT_DACVOLUME_RSRVD3 0x0C000000
1357 +#define BF_AUDIOOUT_DACVOLUME_RSRVD3(v) \
1358 + (((v) << 26) & BM_AUDIOOUT_DACVOLUME_RSRVD3)
1359 +#define BM_AUDIOOUT_DACVOLUME_EN_ZCD 0x02000000
1360 +#define BM_AUDIOOUT_DACVOLUME_MUTE_LEFT 0x01000000
1361 +#define BP_AUDIOOUT_DACVOLUME_VOLUME_LEFT 16
1362 +#define BM_AUDIOOUT_DACVOLUME_VOLUME_LEFT 0x00FF0000
1363 +#define BF_AUDIOOUT_DACVOLUME_VOLUME_LEFT(v) \
1364 + (((v) << 16) & BM_AUDIOOUT_DACVOLUME_VOLUME_LEFT)
1365 +#define BP_AUDIOOUT_DACVOLUME_RSRVD2 13
1366 +#define BM_AUDIOOUT_DACVOLUME_RSRVD2 0x0000E000
1367 +#define BF_AUDIOOUT_DACVOLUME_RSRVD2(v) \
1368 + (((v) << 13) & BM_AUDIOOUT_DACVOLUME_RSRVD2)
1369 +#define BM_AUDIOOUT_DACVOLUME_VOLUME_UPDATE_RIGHT 0x00001000
1370 +#define BP_AUDIOOUT_DACVOLUME_RSRVD1 9
1371 +#define BM_AUDIOOUT_DACVOLUME_RSRVD1 0x00000E00
1372 +#define BF_AUDIOOUT_DACVOLUME_RSRVD1(v) \
1373 + (((v) << 9) & BM_AUDIOOUT_DACVOLUME_RSRVD1)
1374 +#define BM_AUDIOOUT_DACVOLUME_MUTE_RIGHT 0x00000100
1375 +#define BP_AUDIOOUT_DACVOLUME_VOLUME_RIGHT 0
1376 +#define BM_AUDIOOUT_DACVOLUME_VOLUME_RIGHT 0x000000FF
1377 +#define BF_AUDIOOUT_DACVOLUME_VOLUME_RIGHT(v) \
1378 + (((v) << 0) & BM_AUDIOOUT_DACVOLUME_VOLUME_RIGHT)
1379 +
1380 +#define HW_AUDIOOUT_DACDEBUG (0x00000040)
1381 +#define HW_AUDIOOUT_DACDEBUG_SET (0x00000044)
1382 +#define HW_AUDIOOUT_DACDEBUG_CLR (0x00000048)
1383 +#define HW_AUDIOOUT_DACDEBUG_TOG (0x0000004c)
1384 +
1385 +#define BM_AUDIOOUT_DACDEBUG_ENABLE_DACDMA 0x80000000
1386 +#define BP_AUDIOOUT_DACDEBUG_RSRVD2 12
1387 +#define BM_AUDIOOUT_DACDEBUG_RSRVD2 0x7FFFF000
1388 +#define BF_AUDIOOUT_DACDEBUG_RSRVD2(v) \
1389 + (((v) << 12) & BM_AUDIOOUT_DACDEBUG_RSRVD2)
1390 +#define BP_AUDIOOUT_DACDEBUG_RAM_SS 8
1391 +#define BM_AUDIOOUT_DACDEBUG_RAM_SS 0x00000F00
1392 +#define BF_AUDIOOUT_DACDEBUG_RAM_SS(v) \
1393 + (((v) << 8) & BM_AUDIOOUT_DACDEBUG_RAM_SS)
1394 +#define BP_AUDIOOUT_DACDEBUG_RSRVD1 6
1395 +#define BM_AUDIOOUT_DACDEBUG_RSRVD1 0x000000C0
1396 +#define BF_AUDIOOUT_DACDEBUG_RSRVD1(v) \
1397 + (((v) << 6) & BM_AUDIOOUT_DACDEBUG_RSRVD1)
1398 +#define BM_AUDIOOUT_DACDEBUG_SET_INTERRUPT1_CLK_CROSS 0x00000020
1399 +#define BM_AUDIOOUT_DACDEBUG_SET_INTERRUPT0_CLK_CROSS 0x00000010
1400 +#define BM_AUDIOOUT_DACDEBUG_SET_INTERRUPT1_HAND_SHAKE 0x00000008
1401 +#define BM_AUDIOOUT_DACDEBUG_SET_INTERRUPT0_HAND_SHAKE 0x00000004
1402 +#define BM_AUDIOOUT_DACDEBUG_DMA_PREQ 0x00000002
1403 +#define BM_AUDIOOUT_DACDEBUG_FIFO_STATUS 0x00000001
1404 +
1405 +#define HW_AUDIOOUT_HPVOL (0x00000050)
1406 +#define HW_AUDIOOUT_HPVOL_SET (0x00000054)
1407 +#define HW_AUDIOOUT_HPVOL_CLR (0x00000058)
1408 +#define HW_AUDIOOUT_HPVOL_TOG (0x0000005c)
1409 +
1410 +#define BP_AUDIOOUT_HPVOL_RSRVD5 29
1411 +#define BM_AUDIOOUT_HPVOL_RSRVD5 0xE0000000
1412 +#define BF_AUDIOOUT_HPVOL_RSRVD5(v) \
1413 + (((v) << 29) & BM_AUDIOOUT_HPVOL_RSRVD5)
1414 +#define BM_AUDIOOUT_HPVOL_VOLUME_UPDATE_PENDING 0x10000000
1415 +#define BP_AUDIOOUT_HPVOL_RSRVD4 26
1416 +#define BM_AUDIOOUT_HPVOL_RSRVD4 0x0C000000
1417 +#define BF_AUDIOOUT_HPVOL_RSRVD4(v) \
1418 + (((v) << 26) & BM_AUDIOOUT_HPVOL_RSRVD4)
1419 +#define BM_AUDIOOUT_HPVOL_EN_MSTR_ZCD 0x02000000
1420 +#define BM_AUDIOOUT_HPVOL_MUTE 0x01000000
1421 +#define BP_AUDIOOUT_HPVOL_RSRVD3 17
1422 +#define BM_AUDIOOUT_HPVOL_RSRVD3 0x00FE0000
1423 +#define BF_AUDIOOUT_HPVOL_RSRVD3(v) \
1424 + (((v) << 17) & BM_AUDIOOUT_HPVOL_RSRVD3)
1425 +#define BM_AUDIOOUT_HPVOL_SELECT 0x00010000
1426 +#define BM_AUDIOOUT_HPVOL_RSRVD2 0x00008000
1427 +#define BP_AUDIOOUT_HPVOL_VOL_LEFT 8
1428 +#define BM_AUDIOOUT_HPVOL_VOL_LEFT 0x00007F00
1429 +#define BF_AUDIOOUT_HPVOL_VOL_LEFT(v) \
1430 + (((v) << 8) & BM_AUDIOOUT_HPVOL_VOL_LEFT)
1431 +#define BM_AUDIOOUT_HPVOL_RSRVD1 0x00000080
1432 +#define BP_AUDIOOUT_HPVOL_VOL_RIGHT 0
1433 +#define BM_AUDIOOUT_HPVOL_VOL_RIGHT 0x0000007F
1434 +#define BF_AUDIOOUT_HPVOL_VOL_RIGHT(v) \
1435 + (((v) << 0) & BM_AUDIOOUT_HPVOL_VOL_RIGHT)
1436 +
1437 +#define HW_AUDIOOUT_RESERVED (0x00000060)
1438 +#define HW_AUDIOOUT_RESERVED_SET (0x00000064)
1439 +#define HW_AUDIOOUT_RESERVED_CLR (0x00000068)
1440 +#define HW_AUDIOOUT_RESERVED_TOG (0x0000006c)
1441 +
1442 +#define BP_AUDIOOUT_RESERVED_RSRVD1 0
1443 +#define BM_AUDIOOUT_RESERVED_RSRVD1 0xFFFFFFFF
1444 +#define BF_AUDIOOUT_RESERVED_RSRVD1(v) (v)
1445 +
1446 +#define HW_AUDIOOUT_PWRDN (0x00000070)
1447 +#define HW_AUDIOOUT_PWRDN_SET (0x00000074)
1448 +#define HW_AUDIOOUT_PWRDN_CLR (0x00000078)
1449 +#define HW_AUDIOOUT_PWRDN_TOG (0x0000007c)
1450 +
1451 +#define BP_AUDIOOUT_PWRDN_RSRVD7 25
1452 +#define BM_AUDIOOUT_PWRDN_RSRVD7 0xFE000000
1453 +#define BF_AUDIOOUT_PWRDN_RSRVD7(v) \
1454 + (((v) << 25) & BM_AUDIOOUT_PWRDN_RSRVD7)
1455 +#define BM_AUDIOOUT_PWRDN_SPEAKER 0x01000000
1456 +#define BP_AUDIOOUT_PWRDN_RSRVD6 21
1457 +#define BM_AUDIOOUT_PWRDN_RSRVD6 0x00E00000
1458 +#define BF_AUDIOOUT_PWRDN_RSRVD6(v) \
1459 + (((v) << 21) & BM_AUDIOOUT_PWRDN_RSRVD6)
1460 +#define BM_AUDIOOUT_PWRDN_SELFBIAS 0x00100000
1461 +#define BP_AUDIOOUT_PWRDN_RSRVD5 17
1462 +#define BM_AUDIOOUT_PWRDN_RSRVD5 0x000E0000
1463 +#define BF_AUDIOOUT_PWRDN_RSRVD5(v) \
1464 + (((v) << 17) & BM_AUDIOOUT_PWRDN_RSRVD5)
1465 +#define BM_AUDIOOUT_PWRDN_RIGHT_ADC 0x00010000
1466 +#define BP_AUDIOOUT_PWRDN_RSRVD4 13
1467 +#define BM_AUDIOOUT_PWRDN_RSRVD4 0x0000E000
1468 +#define BF_AUDIOOUT_PWRDN_RSRVD4(v) \
1469 + (((v) << 13) & BM_AUDIOOUT_PWRDN_RSRVD4)
1470 +#define BM_AUDIOOUT_PWRDN_DAC 0x00001000
1471 +#define BP_AUDIOOUT_PWRDN_RSRVD3 9
1472 +#define BM_AUDIOOUT_PWRDN_RSRVD3 0x00000E00
1473 +#define BF_AUDIOOUT_PWRDN_RSRVD3(v) \
1474 + (((v) << 9) & BM_AUDIOOUT_PWRDN_RSRVD3)
1475 +#define BM_AUDIOOUT_PWRDN_ADC 0x00000100
1476 +#define BP_AUDIOOUT_PWRDN_RSRVD2 5
1477 +#define BM_AUDIOOUT_PWRDN_RSRVD2 0x000000E0
1478 +#define BF_AUDIOOUT_PWRDN_RSRVD2(v) \
1479 + (((v) << 5) & BM_AUDIOOUT_PWRDN_RSRVD2)
1480 +#define BM_AUDIOOUT_PWRDN_CAPLESS 0x00000010
1481 +#define BP_AUDIOOUT_PWRDN_RSRVD1 1
1482 +#define BM_AUDIOOUT_PWRDN_RSRVD1 0x0000000E
1483 +#define BF_AUDIOOUT_PWRDN_RSRVD1(v) \
1484 + (((v) << 1) & BM_AUDIOOUT_PWRDN_RSRVD1)
1485 +#define BM_AUDIOOUT_PWRDN_HEADPHONE 0x00000001
1486 +
1487 +#define HW_AUDIOOUT_REFCTRL (0x00000080)
1488 +#define HW_AUDIOOUT_REFCTRL_SET (0x00000084)
1489 +#define HW_AUDIOOUT_REFCTRL_CLR (0x00000088)
1490 +#define HW_AUDIOOUT_REFCTRL_TOG (0x0000008c)
1491 +
1492 +#define BP_AUDIOOUT_REFCTRL_RSRVD4 27
1493 +#define BM_AUDIOOUT_REFCTRL_RSRVD4 0xF8000000
1494 +#define BF_AUDIOOUT_REFCTRL_RSRVD4(v) \
1495 + (((v) << 27) & BM_AUDIOOUT_REFCTRL_RSRVD4)
1496 +#define BM_AUDIOOUT_REFCTRL_FASTSETTLING 0x04000000
1497 +#define BM_AUDIOOUT_REFCTRL_RAISE_REF 0x02000000
1498 +#define BM_AUDIOOUT_REFCTRL_XTAL_BGR_BIAS 0x01000000
1499 +#define BM_AUDIOOUT_REFCTRL_RSRVD3 0x00800000
1500 +#define BP_AUDIOOUT_REFCTRL_VBG_ADJ 20
1501 +#define BM_AUDIOOUT_REFCTRL_VBG_ADJ 0x00700000
1502 +#define BF_AUDIOOUT_REFCTRL_VBG_ADJ(v) \
1503 + (((v) << 20) & BM_AUDIOOUT_REFCTRL_VBG_ADJ)
1504 +#define BM_AUDIOOUT_REFCTRL_LOW_PWR 0x00080000
1505 +#define BM_AUDIOOUT_REFCTRL_LW_REF 0x00040000
1506 +#define BP_AUDIOOUT_REFCTRL_BIAS_CTRL 16
1507 +#define BM_AUDIOOUT_REFCTRL_BIAS_CTRL 0x00030000
1508 +#define BF_AUDIOOUT_REFCTRL_BIAS_CTRL(v) \
1509 + (((v) << 16) & BM_AUDIOOUT_REFCTRL_BIAS_CTRL)
1510 +#define BM_AUDIOOUT_REFCTRL_RSRVD2 0x00008000
1511 +#define BM_AUDIOOUT_REFCTRL_VDDXTAL_TO_VDDD 0x00004000
1512 +#define BM_AUDIOOUT_REFCTRL_ADJ_ADC 0x00002000
1513 +#define BM_AUDIOOUT_REFCTRL_ADJ_VAG 0x00001000
1514 +#define BP_AUDIOOUT_REFCTRL_ADC_REFVAL 8
1515 +#define BM_AUDIOOUT_REFCTRL_ADC_REFVAL 0x00000F00
1516 +#define BF_AUDIOOUT_REFCTRL_ADC_REFVAL(v) \
1517 + (((v) << 8) & BM_AUDIOOUT_REFCTRL_ADC_REFVAL)
1518 +#define BP_AUDIOOUT_REFCTRL_VAG_VAL 4
1519 +#define BM_AUDIOOUT_REFCTRL_VAG_VAL 0x000000F0
1520 +#define BF_AUDIOOUT_REFCTRL_VAG_VAL(v) \
1521 + (((v) << 4) & BM_AUDIOOUT_REFCTRL_VAG_VAL)
1522 +#define BM_AUDIOOUT_REFCTRL_RSRVD1 0x00000008
1523 +#define BP_AUDIOOUT_REFCTRL_DAC_ADJ 0
1524 +#define BM_AUDIOOUT_REFCTRL_DAC_ADJ 0x00000007
1525 +#define BF_AUDIOOUT_REFCTRL_DAC_ADJ(v) \
1526 + (((v) << 0) & BM_AUDIOOUT_REFCTRL_DAC_ADJ)
1527 +
1528 +#define HW_AUDIOOUT_ANACTRL (0x00000090)
1529 +#define HW_AUDIOOUT_ANACTRL_SET (0x00000094)
1530 +#define HW_AUDIOOUT_ANACTRL_CLR (0x00000098)
1531 +#define HW_AUDIOOUT_ANACTRL_TOG (0x0000009c)
1532 +
1533 +#define BP_AUDIOOUT_ANACTRL_RSRVD8 29
1534 +#define BM_AUDIOOUT_ANACTRL_RSRVD8 0xE0000000
1535 +#define BF_AUDIOOUT_ANACTRL_RSRVD8(v) \
1536 + (((v) << 29) & BM_AUDIOOUT_ANACTRL_RSRVD8)
1537 +#define BM_AUDIOOUT_ANACTRL_SHORT_CM_STS 0x10000000
1538 +#define BP_AUDIOOUT_ANACTRL_RSRVD7 25
1539 +#define BM_AUDIOOUT_ANACTRL_RSRVD7 0x0E000000
1540 +#define BF_AUDIOOUT_ANACTRL_RSRVD7(v) \
1541 + (((v) << 25) & BM_AUDIOOUT_ANACTRL_RSRVD7)
1542 +#define BM_AUDIOOUT_ANACTRL_SHORT_LR_STS 0x01000000
1543 +#define BP_AUDIOOUT_ANACTRL_RSRVD6 22
1544 +#define BM_AUDIOOUT_ANACTRL_RSRVD6 0x00C00000
1545 +#define BF_AUDIOOUT_ANACTRL_RSRVD6(v) \
1546 + (((v) << 22) & BM_AUDIOOUT_ANACTRL_RSRVD6)
1547 +#define BP_AUDIOOUT_ANACTRL_SHORTMODE_CM 20
1548 +#define BM_AUDIOOUT_ANACTRL_SHORTMODE_CM 0x00300000
1549 +#define BF_AUDIOOUT_ANACTRL_SHORTMODE_CM(v) \
1550 + (((v) << 20) & BM_AUDIOOUT_ANACTRL_SHORTMODE_CM)
1551 +#define BM_AUDIOOUT_ANACTRL_RSRVD5 0x00080000
1552 +#define BP_AUDIOOUT_ANACTRL_SHORTMODE_LR 17
1553 +#define BM_AUDIOOUT_ANACTRL_SHORTMODE_LR 0x00060000
1554 +#define BF_AUDIOOUT_ANACTRL_SHORTMODE_LR(v) \
1555 + (((v) << 17) & BM_AUDIOOUT_ANACTRL_SHORTMODE_LR)
1556 +#define BP_AUDIOOUT_ANACTRL_RSRVD4 15
1557 +#define BM_AUDIOOUT_ANACTRL_RSRVD4 0x00018000
1558 +#define BF_AUDIOOUT_ANACTRL_RSRVD4(v) \
1559 + (((v) << 15) & BM_AUDIOOUT_ANACTRL_RSRVD4)
1560 +#define BP_AUDIOOUT_ANACTRL_SHORT_LVLADJL 12
1561 +#define BM_AUDIOOUT_ANACTRL_SHORT_LVLADJL 0x00007000
1562 +#define BF_AUDIOOUT_ANACTRL_SHORT_LVLADJL(v) \
1563 + (((v) << 12) & BM_AUDIOOUT_ANACTRL_SHORT_LVLADJL)
1564 +#define BM_AUDIOOUT_ANACTRL_RSRVD3 0x00000800
1565 +#define BP_AUDIOOUT_ANACTRL_SHORT_LVLADJR 8
1566 +#define BM_AUDIOOUT_ANACTRL_SHORT_LVLADJR 0x00000700
1567 +#define BF_AUDIOOUT_ANACTRL_SHORT_LVLADJR(v) \
1568 + (((v) << 8) & BM_AUDIOOUT_ANACTRL_SHORT_LVLADJR)
1569 +#define BP_AUDIOOUT_ANACTRL_RSRVD2 6
1570 +#define BM_AUDIOOUT_ANACTRL_RSRVD2 0x000000C0
1571 +#define BF_AUDIOOUT_ANACTRL_RSRVD2(v) \
1572 + (((v) << 6) & BM_AUDIOOUT_ANACTRL_RSRVD2)
1573 +#define BM_AUDIOOUT_ANACTRL_HP_HOLD_GND 0x00000020
1574 +#define BM_AUDIOOUT_ANACTRL_HP_CLASSAB 0x00000010
1575 +#define BP_AUDIOOUT_ANACTRL_RSRVD1 0
1576 +#define BM_AUDIOOUT_ANACTRL_RSRVD1 0x0000000F
1577 +#define BF_AUDIOOUT_ANACTRL_RSRVD1(v) \
1578 + (((v) << 0) & BM_AUDIOOUT_ANACTRL_RSRVD1)
1579 +
1580 +#define HW_AUDIOOUT_TEST (0x000000a0)
1581 +#define HW_AUDIOOUT_TEST_SET (0x000000a4)
1582 +#define HW_AUDIOOUT_TEST_CLR (0x000000a8)
1583 +#define HW_AUDIOOUT_TEST_TOG (0x000000ac)
1584 +
1585 +#define BM_AUDIOOUT_TEST_RSRVD4 0x80000000
1586 +#define BP_AUDIOOUT_TEST_HP_ANTIPOP 28
1587 +#define BM_AUDIOOUT_TEST_HP_ANTIPOP 0x70000000
1588 +#define BF_AUDIOOUT_TEST_HP_ANTIPOP(v) \
1589 + (((v) << 28) & BM_AUDIOOUT_TEST_HP_ANTIPOP)
1590 +#define BM_AUDIOOUT_TEST_RSRVD3 0x08000000
1591 +#define BM_AUDIOOUT_TEST_TM_ADCIN_TOHP 0x04000000
1592 +#define BM_AUDIOOUT_TEST_TM_LOOP 0x02000000
1593 +#define BM_AUDIOOUT_TEST_TM_HPCOMMON 0x01000000
1594 +#define BP_AUDIOOUT_TEST_HP_I1_ADJ 22
1595 +#define BM_AUDIOOUT_TEST_HP_I1_ADJ 0x00C00000
1596 +#define BF_AUDIOOUT_TEST_HP_I1_ADJ(v) \
1597 + (((v) << 22) & BM_AUDIOOUT_TEST_HP_I1_ADJ)
1598 +#define BP_AUDIOOUT_TEST_HP_IALL_ADJ 20
1599 +#define BM_AUDIOOUT_TEST_HP_IALL_ADJ 0x00300000
1600 +#define BF_AUDIOOUT_TEST_HP_IALL_ADJ(v) \
1601 + (((v) << 20) & BM_AUDIOOUT_TEST_HP_IALL_ADJ)
1602 +#define BP_AUDIOOUT_TEST_RSRVD2 14
1603 +#define BM_AUDIOOUT_TEST_RSRVD2 0x000FC000
1604 +#define BF_AUDIOOUT_TEST_RSRVD2(v) \
1605 + (((v) << 14) & BM_AUDIOOUT_TEST_RSRVD2)
1606 +#define BM_AUDIOOUT_TEST_VAG_CLASSA 0x00002000
1607 +#define BM_AUDIOOUT_TEST_VAG_DOUBLE_I 0x00001000
1608 +#define BP_AUDIOOUT_TEST_RSRVD1 4
1609 +#define BM_AUDIOOUT_TEST_RSRVD1 0x00000FF0
1610 +#define BF_AUDIOOUT_TEST_RSRVD1(v) \
1611 + (((v) << 4) & BM_AUDIOOUT_TEST_RSRVD1)
1612 +#define BM_AUDIOOUT_TEST_ADCTODAC_LOOP 0x00000008
1613 +#define BM_AUDIOOUT_TEST_DAC_CLASSA 0x00000004
1614 +#define BM_AUDIOOUT_TEST_DAC_DOUBLE_I 0x00000002
1615 +#define BM_AUDIOOUT_TEST_DAC_DIS_RTZ 0x00000001
1616 +
1617 +#define HW_AUDIOOUT_BISTCTRL (0x000000b0)
1618 +#define HW_AUDIOOUT_BISTCTRL_SET (0x000000b4)
1619 +#define HW_AUDIOOUT_BISTCTRL_CLR (0x000000b8)
1620 +#define HW_AUDIOOUT_BISTCTRL_TOG (0x000000bc)
1621 +
1622 +#define BP_AUDIOOUT_BISTCTRL_RSVD0 4
1623 +#define BM_AUDIOOUT_BISTCTRL_RSVD0 0xFFFFFFF0
1624 +#define BF_AUDIOOUT_BISTCTRL_RSVD0(v) \
1625 + (((v) << 4) & BM_AUDIOOUT_BISTCTRL_RSVD0)
1626 +#define BM_AUDIOOUT_BISTCTRL_FAIL 0x00000008
1627 +#define BM_AUDIOOUT_BISTCTRL_PASS 0x00000004
1628 +#define BM_AUDIOOUT_BISTCTRL_DONE 0x00000002
1629 +#define BM_AUDIOOUT_BISTCTRL_START 0x00000001
1630 +
1631 +#define HW_AUDIOOUT_BISTSTAT0 (0x000000c0)
1632 +#define HW_AUDIOOUT_BISTSTAT0_SET (0x000000c4)
1633 +#define HW_AUDIOOUT_BISTSTAT0_CLR (0x000000c8)
1634 +#define HW_AUDIOOUT_BISTSTAT0_TOG (0x000000cc)
1635 +
1636 +#define BP_AUDIOOUT_BISTSTAT0_RSVD0 24
1637 +#define BM_AUDIOOUT_BISTSTAT0_RSVD0 0xFF000000
1638 +#define BF_AUDIOOUT_BISTSTAT0_RSVD0(v) \
1639 + (((v) << 24) & BM_AUDIOOUT_BISTSTAT0_RSVD0)
1640 +#define BP_AUDIOOUT_BISTSTAT0_DATA 0
1641 +#define BM_AUDIOOUT_BISTSTAT0_DATA 0x00FFFFFF
1642 +#define BF_AUDIOOUT_BISTSTAT0_DATA(v) \
1643 + (((v) << 0) & BM_AUDIOOUT_BISTSTAT0_DATA)
1644 +
1645 +#define HW_AUDIOOUT_BISTSTAT1 (0x000000d0)
1646 +#define HW_AUDIOOUT_BISTSTAT1_SET (0x000000d4)
1647 +#define HW_AUDIOOUT_BISTSTAT1_CLR (0x000000d8)
1648 +#define HW_AUDIOOUT_BISTSTAT1_TOG (0x000000dc)
1649 +
1650 +#define BP_AUDIOOUT_BISTSTAT1_RSVD1 29
1651 +#define BM_AUDIOOUT_BISTSTAT1_RSVD1 0xE0000000
1652 +#define BF_AUDIOOUT_BISTSTAT1_RSVD1(v) \
1653 + (((v) << 29) & BM_AUDIOOUT_BISTSTAT1_RSVD1)
1654 +#define BP_AUDIOOUT_BISTSTAT1_STATE 24
1655 +#define BM_AUDIOOUT_BISTSTAT1_STATE 0x1F000000
1656 +#define BF_AUDIOOUT_BISTSTAT1_STATE(v) \
1657 + (((v) << 24) & BM_AUDIOOUT_BISTSTAT1_STATE)
1658 +#define BP_AUDIOOUT_BISTSTAT1_RSVD0 8
1659 +#define BM_AUDIOOUT_BISTSTAT1_RSVD0 0x00FFFF00
1660 +#define BF_AUDIOOUT_BISTSTAT1_RSVD0(v) \
1661 + (((v) << 8) & BM_AUDIOOUT_BISTSTAT1_RSVD0)
1662 +#define BP_AUDIOOUT_BISTSTAT1_ADDR 0
1663 +#define BM_AUDIOOUT_BISTSTAT1_ADDR 0x000000FF
1664 +#define BF_AUDIOOUT_BISTSTAT1_ADDR(v) \
1665 + (((v) << 0) & BM_AUDIOOUT_BISTSTAT1_ADDR)
1666 +
1667 +#define HW_AUDIOOUT_ANACLKCTRL (0x000000e0)
1668 +#define HW_AUDIOOUT_ANACLKCTRL_SET (0x000000e4)
1669 +#define HW_AUDIOOUT_ANACLKCTRL_CLR (0x000000e8)
1670 +#define HW_AUDIOOUT_ANACLKCTRL_TOG (0x000000ec)
1671 +
1672 +#define BM_AUDIOOUT_ANACLKCTRL_CLKGATE 0x80000000
1673 +#define BP_AUDIOOUT_ANACLKCTRL_RSRVD3 5
1674 +#define BM_AUDIOOUT_ANACLKCTRL_RSRVD3 0x7FFFFFE0
1675 +#define BF_AUDIOOUT_ANACLKCTRL_RSRVD3(v) \
1676 + (((v) << 5) & BM_AUDIOOUT_ANACLKCTRL_RSRVD3)
1677 +#define BM_AUDIOOUT_ANACLKCTRL_INVERT_DACCLK 0x00000010
1678 +#define BM_AUDIOOUT_ANACLKCTRL_RSRVD2 0x00000008
1679 +#define BP_AUDIOOUT_ANACLKCTRL_DACDIV 0
1680 +#define BM_AUDIOOUT_ANACLKCTRL_DACDIV 0x00000007
1681 +#define BF_AUDIOOUT_ANACLKCTRL_DACDIV(v) \
1682 + (((v) << 0) & BM_AUDIOOUT_ANACLKCTRL_DACDIV)
1683 +
1684 +#define HW_AUDIOOUT_DATA (0x000000f0)
1685 +#define HW_AUDIOOUT_DATA_SET (0x000000f4)
1686 +#define HW_AUDIOOUT_DATA_CLR (0x000000f8)
1687 +#define HW_AUDIOOUT_DATA_TOG (0x000000fc)
1688 +
1689 +#define BP_AUDIOOUT_DATA_HIGH 16
1690 +#define BM_AUDIOOUT_DATA_HIGH 0xFFFF0000
1691 +#define BF_AUDIOOUT_DATA_HIGH(v) \
1692 + (((v) << 16) & BM_AUDIOOUT_DATA_HIGH)
1693 +#define BP_AUDIOOUT_DATA_LOW 0
1694 +#define BM_AUDIOOUT_DATA_LOW 0x0000FFFF
1695 +#define BF_AUDIOOUT_DATA_LOW(v) \
1696 + (((v) << 0) & BM_AUDIOOUT_DATA_LOW)
1697 +
1698 +#define HW_AUDIOOUT_SPEAKERCTRL (0x00000100)
1699 +#define HW_AUDIOOUT_SPEAKERCTRL_SET (0x00000104)
1700 +#define HW_AUDIOOUT_SPEAKERCTRL_CLR (0x00000108)
1701 +#define HW_AUDIOOUT_SPEAKERCTRL_TOG (0x0000010c)
1702 +
1703 +#define BP_AUDIOOUT_SPEAKERCTRL_RSRVD2 25
1704 +#define BM_AUDIOOUT_SPEAKERCTRL_RSRVD2 0xFE000000
1705 +#define BF_AUDIOOUT_SPEAKERCTRL_RSRVD2(v) \
1706 + (((v) << 25) & BM_AUDIOOUT_SPEAKERCTRL_RSRVD2)
1707 +#define BM_AUDIOOUT_SPEAKERCTRL_MUTE 0x01000000
1708 +#define BP_AUDIOOUT_SPEAKERCTRL_I1_ADJ 22
1709 +#define BM_AUDIOOUT_SPEAKERCTRL_I1_ADJ 0x00C00000
1710 +#define BF_AUDIOOUT_SPEAKERCTRL_I1_ADJ(v) \
1711 + (((v) << 22) & BM_AUDIOOUT_SPEAKERCTRL_I1_ADJ)
1712 +#define BP_AUDIOOUT_SPEAKERCTRL_IALL_ADJ 20
1713 +#define BM_AUDIOOUT_SPEAKERCTRL_IALL_ADJ 0x00300000
1714 +#define BF_AUDIOOUT_SPEAKERCTRL_IALL_ADJ(v) \
1715 + (((v) << 20) & BM_AUDIOOUT_SPEAKERCTRL_IALL_ADJ)
1716 +#define BP_AUDIOOUT_SPEAKERCTRL_RSRVD1 16
1717 +#define BM_AUDIOOUT_SPEAKERCTRL_RSRVD1 0x000F0000
1718 +#define BF_AUDIOOUT_SPEAKERCTRL_RSRVD1(v) \
1719 + (((v) << 16) & BM_AUDIOOUT_SPEAKERCTRL_RSRVD1)
1720 +#define BP_AUDIOOUT_SPEAKERCTRL_POSDRIVER 14
1721 +#define BM_AUDIOOUT_SPEAKERCTRL_POSDRIVER 0x0000C000
1722 +#define BF_AUDIOOUT_SPEAKERCTRL_POSDRIVER(v) \
1723 + (((v) << 14) & BM_AUDIOOUT_SPEAKERCTRL_POSDRIVER)
1724 +#define BP_AUDIOOUT_SPEAKERCTRL_NEGDRIVER 12
1725 +#define BM_AUDIOOUT_SPEAKERCTRL_NEGDRIVER 0x00003000
1726 +#define BF_AUDIOOUT_SPEAKERCTRL_NEGDRIVER(v) \
1727 + (((v) << 12) & BM_AUDIOOUT_SPEAKERCTRL_NEGDRIVER)
1728 +#define BP_AUDIOOUT_SPEAKERCTRL_RSRVD0 0
1729 +#define BM_AUDIOOUT_SPEAKERCTRL_RSRVD0 0x00000FFF
1730 +#define BF_AUDIOOUT_SPEAKERCTRL_RSRVD0(v) \
1731 + (((v) << 0) & BM_AUDIOOUT_SPEAKERCTRL_RSRVD0)
1732 +
1733 +#define HW_AUDIOOUT_VERSION (0x00000200)
1734 +
1735 +#define BP_AUDIOOUT_VERSION_MAJOR 24
1736 +#define BM_AUDIOOUT_VERSION_MAJOR 0xFF000000
1737 +#define BF_AUDIOOUT_VERSION_MAJOR(v) \
1738 + (((v) << 24) & BM_AUDIOOUT_VERSION_MAJOR)
1739 +#define BP_AUDIOOUT_VERSION_MINOR 16
1740 +#define BM_AUDIOOUT_VERSION_MINOR 0x00FF0000
1741 +#define BF_AUDIOOUT_VERSION_MINOR(v) \
1742 + (((v) << 16) & BM_AUDIOOUT_VERSION_MINOR)
1743 +#define BP_AUDIOOUT_VERSION_STEP 0
1744 +#define BM_AUDIOOUT_VERSION_STEP 0x0000FFFF
1745 +#define BF_AUDIOOUT_VERSION_STEP(v) \
1746 + (((v) << 0) & BM_AUDIOOUT_VERSION_STEP)
1747 +
1748 +/* AUDIOIN */
1749 +#define HW_AUDIOIN_CTRL (0x00000000)
1750 +#define HW_AUDIOIN_CTRL_SET (0x00000004)
1751 +#define HW_AUDIOIN_CTRL_CLR (0x00000008)
1752 +#define HW_AUDIOIN_CTRL_TOG (0x0000000c)
1753 +
1754 +#define BM_AUDIOIN_CTRL_SFTRST 0x80000000
1755 +#define BM_AUDIOIN_CTRL_CLKGATE 0x40000000
1756 +#define BP_AUDIOIN_CTRL_RSRVD3 21
1757 +#define BM_AUDIOIN_CTRL_RSRVD3 0x3FE00000
1758 +#define BF_AUDIOIN_CTRL_RSRVD3(v) \
1759 + (((v) << 21) & BM_AUDIOIN_CTRL_RSRVD3)
1760 +#define BP_AUDIOIN_CTRL_DMAWAIT_COUNT 16
1761 +#define BM_AUDIOIN_CTRL_DMAWAIT_COUNT 0x001F0000
1762 +#define BF_AUDIOIN_CTRL_DMAWAIT_COUNT(v) \
1763 + (((v) << 16) & BM_AUDIOIN_CTRL_DMAWAIT_COUNT)
1764 +#define BP_AUDIOIN_CTRL_RSRVD1 11
1765 +#define BM_AUDIOIN_CTRL_RSRVD1 0x0000F800
1766 +#define BF_AUDIOIN_CTRL_RSRVD1(v) \
1767 + (((v) << 11) & BM_AUDIOIN_CTRL_RSRVD1)
1768 +#define BM_AUDIOIN_CTRL_LR_SWAP 0x00000400
1769 +#define BM_AUDIOIN_CTRL_EDGE_SYNC 0x00000200
1770 +#define BM_AUDIOIN_CTRL_INVERT_1BIT 0x00000100
1771 +#define BM_AUDIOIN_CTRL_OFFSET_ENABLE 0x00000080
1772 +#define BM_AUDIOIN_CTRL_HPF_ENABLE 0x00000040
1773 +#define BM_AUDIOIN_CTRL_WORD_LENGTH 0x00000020
1774 +#define BM_AUDIOIN_CTRL_LOOPBACK 0x00000010
1775 +#define BM_AUDIOIN_CTRL_FIFO_UNDERFLOW_IRQ 0x00000008
1776 +#define BM_AUDIOIN_CTRL_FIFO_OVERFLOW_IRQ 0x00000004
1777 +#define BM_AUDIOIN_CTRL_FIFO_ERROR_IRQ_EN 0x00000002
1778 +#define BM_AUDIOIN_CTRL_RUN 0x00000001
1779 +
1780 +#define HW_AUDIOIN_STAT (0x00000010)
1781 +#define HW_AUDIOIN_STAT_SET (0x00000014)
1782 +#define HW_AUDIOIN_STAT_CLR (0x00000018)
1783 +#define HW_AUDIOIN_STAT_TOG (0x0000001c)
1784 +
1785 +#define BM_AUDIOIN_STAT_ADC_PRESENT 0x80000000
1786 +#define BP_AUDIOIN_STAT_RSRVD3 0
1787 +#define BM_AUDIOIN_STAT_RSRVD3 0x7FFFFFFF
1788 +#define BF_AUDIOIN_STAT_RSRVD3(v) \
1789 + (((v) << 0) & BM_AUDIOIN_STAT_RSRVD3)
1790 +
1791 +#define HW_AUDIOIN_ADCSRR (0x00000020)
1792 +#define HW_AUDIOIN_ADCSRR_SET (0x00000024)
1793 +#define HW_AUDIOIN_ADCSRR_CLR (0x00000028)
1794 +#define HW_AUDIOIN_ADCSRR_TOG (0x0000002c)
1795 +
1796 +#define BM_AUDIOIN_ADCSRR_OSR 0x80000000
1797 +#define BV_AUDIOIN_ADCSRR_OSR__OSR6 0x0
1798 +#define BV_AUDIOIN_ADCSRR_OSR__OSR12 0x1
1799 +#define BP_AUDIOIN_ADCSRR_BASEMULT 28
1800 +#define BM_AUDIOIN_ADCSRR_BASEMULT 0x70000000
1801 +#define BF_AUDIOIN_ADCSRR_BASEMULT(v) \
1802 + (((v) << 28) & BM_AUDIOIN_ADCSRR_BASEMULT)
1803 +#define BV_AUDIOIN_ADCSRR_BASEMULT__SINGLE_RATE 0x1
1804 +#define BV_AUDIOIN_ADCSRR_BASEMULT__DOUBLE_RATE 0x2
1805 +#define BV_AUDIOIN_ADCSRR_BASEMULT__QUAD_RATE 0x4
1806 +#define BM_AUDIOIN_ADCSRR_RSRVD2 0x08000000
1807 +#define BP_AUDIOIN_ADCSRR_SRC_HOLD 24
1808 +#define BM_AUDIOIN_ADCSRR_SRC_HOLD 0x07000000
1809 +#define BF_AUDIOIN_ADCSRR_SRC_HOLD(v) \
1810 + (((v) << 24) & BM_AUDIOIN_ADCSRR_SRC_HOLD)
1811 +#define BP_AUDIOIN_ADCSRR_RSRVD1 21
1812 +#define BM_AUDIOIN_ADCSRR_RSRVD1 0x00E00000
1813 +#define BF_AUDIOIN_ADCSRR_RSRVD1(v) \
1814 + (((v) << 21) & BM_AUDIOIN_ADCSRR_RSRVD1)
1815 +#define BP_AUDIOIN_ADCSRR_SRC_INT 16
1816 +#define BM_AUDIOIN_ADCSRR_SRC_INT 0x001F0000
1817 +#define BF_AUDIOIN_ADCSRR_SRC_INT(v) \
1818 + (((v) << 16) & BM_AUDIOIN_ADCSRR_SRC_INT)
1819 +#define BP_AUDIOIN_ADCSRR_RSRVD0 13
1820 +#define BM_AUDIOIN_ADCSRR_RSRVD0 0x0000E000
1821 +#define BF_AUDIOIN_ADCSRR_RSRVD0(v) \
1822 + (((v) << 13) & BM_AUDIOIN_ADCSRR_RSRVD0)
1823 +#define BP_AUDIOIN_ADCSRR_SRC_FRAC 0
1824 +#define BM_AUDIOIN_ADCSRR_SRC_FRAC 0x00001FFF
1825 +#define BF_AUDIOIN_ADCSRR_SRC_FRAC(v) \
1826 + (((v) << 0) & BM_AUDIOIN_ADCSRR_SRC_FRAC)
1827 +
1828 +#define HW_AUDIOIN_ADCVOLUME (0x00000030)
1829 +#define HW_AUDIOIN_ADCVOLUME_SET (0x00000034)
1830 +#define HW_AUDIOIN_ADCVOLUME_CLR (0x00000038)
1831 +#define HW_AUDIOIN_ADCVOLUME_TOG (0x0000003c)
1832 +
1833 +#define BP_AUDIOIN_ADCVOLUME_RSRVD5 29
1834 +#define BM_AUDIOIN_ADCVOLUME_RSRVD5 0xE0000000
1835 +#define BF_AUDIOIN_ADCVOLUME_RSRVD5(v) \
1836 + (((v) << 29) & BM_AUDIOIN_ADCVOLUME_RSRVD5)
1837 +#define BM_AUDIOIN_ADCVOLUME_VOLUME_UPDATE_LEFT 0x10000000
1838 +#define BP_AUDIOIN_ADCVOLUME_RSRVD4 26
1839 +#define BM_AUDIOIN_ADCVOLUME_RSRVD4 0x0C000000
1840 +#define BF_AUDIOIN_ADCVOLUME_RSRVD4(v) \
1841 + (((v) << 26) & BM_AUDIOIN_ADCVOLUME_RSRVD4)
1842 +#define BM_AUDIOIN_ADCVOLUME_EN_ZCD 0x02000000
1843 +#define BM_AUDIOIN_ADCVOLUME_RSRVD3 0x01000000
1844 +#define BP_AUDIOIN_ADCVOLUME_VOLUME_LEFT 16
1845 +#define BM_AUDIOIN_ADCVOLUME_VOLUME_LEFT 0x00FF0000
1846 +#define BF_AUDIOIN_ADCVOLUME_VOLUME_LEFT(v) \
1847 + (((v) << 16) & BM_AUDIOIN_ADCVOLUME_VOLUME_LEFT)
1848 +#define BP_AUDIOIN_ADCVOLUME_RSRVD2 13
1849 +#define BM_AUDIOIN_ADCVOLUME_RSRVD2 0x0000E000
1850 +#define BF_AUDIOIN_ADCVOLUME_RSRVD2(v) \
1851 + (((v) << 13) & BM_AUDIOIN_ADCVOLUME_RSRVD2)
1852 +#define BM_AUDIOIN_ADCVOLUME_VOLUME_UPDATE_RIGHT 0x00001000
1853 +#define BP_AUDIOIN_ADCVOLUME_RSRVD1 8
1854 +#define BM_AUDIOIN_ADCVOLUME_RSRVD1 0x00000F00
1855 +#define BF_AUDIOIN_ADCVOLUME_RSRVD1(v) \
1856 + (((v) << 8) & BM_AUDIOIN_ADCVOLUME_RSRVD1)
1857 +#define BP_AUDIOIN_ADCVOLUME_VOLUME_RIGHT 0
1858 +#define BM_AUDIOIN_ADCVOLUME_VOLUME_RIGHT 0x000000FF
1859 +#define BF_AUDIOIN_ADCVOLUME_VOLUME_RIGHT(v) \
1860 + (((v) << 0) & BM_AUDIOIN_ADCVOLUME_VOLUME_RIGHT)
1861 +
1862 +#define HW_AUDIOIN_ADCDEBUG (0x00000040)
1863 +#define HW_AUDIOIN_ADCDEBUG_SET (0x00000044)
1864 +#define HW_AUDIOIN_ADCDEBUG_CLR (0x00000048)
1865 +#define HW_AUDIOIN_ADCDEBUG_TOG (0x0000004c)
1866 +
1867 +#define BM_AUDIOIN_ADCDEBUG_ENABLE_ADCDMA 0x80000000
1868 +#define BP_AUDIOIN_ADCDEBUG_RSRVD1 4
1869 +#define BM_AUDIOIN_ADCDEBUG_RSRVD1 0x7FFFFFF0
1870 +#define BF_AUDIOIN_ADCDEBUG_RSRVD1(v) \
1871 + (((v) << 4) & BM_AUDIOIN_ADCDEBUG_RSRVD1)
1872 +#define BM_AUDIOIN_ADCDEBUG_ADC_DMA_REQ_HAND_SHAKE_CLK_CROSS 0x00000008
1873 +#define BM_AUDIOIN_ADCDEBUG_SET_INTERRUPT3_HAND_SHAKE 0x00000004
1874 +#define BM_AUDIOIN_ADCDEBUG_DMA_PREQ 0x00000002
1875 +#define BM_AUDIOIN_ADCDEBUG_FIFO_STATUS 0x00000001
1876 +
1877 +#define HW_AUDIOIN_ADCVOL (0x00000050)
1878 +#define HW_AUDIOIN_ADCVOL_SET (0x00000054)
1879 +#define HW_AUDIOIN_ADCVOL_CLR (0x00000058)
1880 +#define HW_AUDIOIN_ADCVOL_TOG (0x0000005c)
1881 +
1882 +#define BP_AUDIOIN_ADCVOL_RSRVD4 29
1883 +#define BM_AUDIOIN_ADCVOL_RSRVD4 0xE0000000
1884 +#define BF_AUDIOIN_ADCVOL_RSRVD4(v) \
1885 + (((v) << 29) & BM_AUDIOIN_ADCVOL_RSRVD4)
1886 +#define BM_AUDIOIN_ADCVOL_VOLUME_UPDATE_PENDING 0x10000000
1887 +#define BP_AUDIOIN_ADCVOL_RSRVD3 26
1888 +#define BM_AUDIOIN_ADCVOL_RSRVD3 0x0C000000
1889 +#define BF_AUDIOIN_ADCVOL_RSRVD3(v) \
1890 + (((v) << 26) & BM_AUDIOIN_ADCVOL_RSRVD3)
1891 +#define BM_AUDIOIN_ADCVOL_EN_ADC_ZCD 0x02000000
1892 +#define BM_AUDIOIN_ADCVOL_MUTE 0x01000000
1893 +#define BP_AUDIOIN_ADCVOL_RSRVD2 14
1894 +#define BM_AUDIOIN_ADCVOL_RSRVD2 0x00FFC000
1895 +#define BF_AUDIOIN_ADCVOL_RSRVD2(v) \
1896 + (((v) << 14) & BM_AUDIOIN_ADCVOL_RSRVD2)
1897 +#define BP_AUDIOIN_ADCVOL_SELECT_LEFT 12
1898 +#define BM_AUDIOIN_ADCVOL_SELECT_LEFT 0x00003000
1899 +#define BF_AUDIOIN_ADCVOL_SELECT_LEFT(v) \
1900 + (((v) << 12) & BM_AUDIOIN_ADCVOL_SELECT_LEFT)
1901 +#define BP_AUDIOIN_ADCVOL_GAIN_LEFT 8
1902 +#define BM_AUDIOIN_ADCVOL_GAIN_LEFT 0x00000F00
1903 +#define BF_AUDIOIN_ADCVOL_GAIN_LEFT(v) \
1904 + (((v) << 8) & BM_AUDIOIN_ADCVOL_GAIN_LEFT)
1905 +#define BP_AUDIOIN_ADCVOL_RSRVD1 6
1906 +#define BM_AUDIOIN_ADCVOL_RSRVD1 0x000000C0
1907 +#define BF_AUDIOIN_ADCVOL_RSRVD1(v) \
1908 + (((v) << 6) & BM_AUDIOIN_ADCVOL_RSRVD1)
1909 +#define BP_AUDIOIN_ADCVOL_SELECT_RIGHT 4
1910 +#define BM_AUDIOIN_ADCVOL_SELECT_RIGHT 0x00000030
1911 +#define BF_AUDIOIN_ADCVOL_SELECT_RIGHT(v) \
1912 + (((v) << 4) & BM_AUDIOIN_ADCVOL_SELECT_RIGHT)
1913 +#define BP_AUDIOIN_ADCVOL_GAIN_RIGHT 0
1914 +#define BM_AUDIOIN_ADCVOL_GAIN_RIGHT 0x0000000F
1915 +#define BF_AUDIOIN_ADCVOL_GAIN_RIGHT(v) \
1916 + (((v) << 0) & BM_AUDIOIN_ADCVOL_GAIN_RIGHT)
1917 +
1918 +#define HW_AUDIOIN_MICLINE (0x00000060)
1919 +#define HW_AUDIOIN_MICLINE_SET (0x00000064)
1920 +#define HW_AUDIOIN_MICLINE_CLR (0x00000068)
1921 +#define HW_AUDIOIN_MICLINE_TOG (0x0000006c)
1922 +
1923 +#define BP_AUDIOIN_MICLINE_RSRVD6 30
1924 +#define BM_AUDIOIN_MICLINE_RSRVD6 0xC0000000
1925 +#define BF_AUDIOIN_MICLINE_RSRVD6(v) \
1926 + (((v) << 30) & BM_AUDIOIN_MICLINE_RSRVD6)
1927 +#define BM_AUDIOIN_MICLINE_DIVIDE_LINE1 0x20000000
1928 +#define BM_AUDIOIN_MICLINE_DIVIDE_LINE2 0x10000000
1929 +#define BP_AUDIOIN_MICLINE_RSRVD5 25
1930 +#define BM_AUDIOIN_MICLINE_RSRVD5 0x0E000000
1931 +#define BF_AUDIOIN_MICLINE_RSRVD5(v) \
1932 + (((v) << 25) & BM_AUDIOIN_MICLINE_RSRVD5)
1933 +#define BM_AUDIOIN_MICLINE_MIC_SELECT 0x01000000
1934 +#define BP_AUDIOIN_MICLINE_RSRVD4 22
1935 +#define BM_AUDIOIN_MICLINE_RSRVD4 0x00C00000
1936 +#define BF_AUDIOIN_MICLINE_RSRVD4(v) \
1937 + (((v) << 22) & BM_AUDIOIN_MICLINE_RSRVD4)
1938 +#define BP_AUDIOIN_MICLINE_MIC_RESISTOR 20
1939 +#define BM_AUDIOIN_MICLINE_MIC_RESISTOR 0x00300000
1940 +#define BF_AUDIOIN_MICLINE_MIC_RESISTOR(v) \
1941 + (((v) << 20) & BM_AUDIOIN_MICLINE_MIC_RESISTOR)
1942 +#define BM_AUDIOIN_MICLINE_RSRVD3 0x00080000
1943 +#define BP_AUDIOIN_MICLINE_MIC_BIAS 16
1944 +#define BM_AUDIOIN_MICLINE_MIC_BIAS 0x00070000
1945 +#define BF_AUDIOIN_MICLINE_MIC_BIAS(v) \
1946 + (((v) << 16) & BM_AUDIOIN_MICLINE_MIC_BIAS)
1947 +#define BP_AUDIOIN_MICLINE_RSRVD2 6
1948 +#define BM_AUDIOIN_MICLINE_RSRVD2 0x0000FFC0
1949 +#define BF_AUDIOIN_MICLINE_RSRVD2(v) \
1950 + (((v) << 6) & BM_AUDIOIN_MICLINE_RSRVD2)
1951 +#define BP_AUDIOIN_MICLINE_MIC_CHOPCLK 4
1952 +#define BM_AUDIOIN_MICLINE_MIC_CHOPCLK 0x00000030
1953 +#define BF_AUDIOIN_MICLINE_MIC_CHOPCLK(v) \
1954 + (((v) << 4) & BM_AUDIOIN_MICLINE_MIC_CHOPCLK)
1955 +#define BP_AUDIOIN_MICLINE_RSRVD1 2
1956 +#define BM_AUDIOIN_MICLINE_RSRVD1 0x0000000C
1957 +#define BF_AUDIOIN_MICLINE_RSRVD1(v) \
1958 + (((v) << 2) & BM_AUDIOIN_MICLINE_RSRVD1)
1959 +#define BP_AUDIOIN_MICLINE_MIC_GAIN 0
1960 +#define BM_AUDIOIN_MICLINE_MIC_GAIN 0x00000003
1961 +#define BF_AUDIOIN_MICLINE_MIC_GAIN(v) \
1962 + (((v) << 0) & BM_AUDIOIN_MICLINE_MIC_GAIN)
1963 +
1964 +#define HW_AUDIOIN_ANACLKCTRL (0x00000070)
1965 +#define HW_AUDIOIN_ANACLKCTRL_SET (0x00000074)
1966 +#define HW_AUDIOIN_ANACLKCTRL_CLR (0x00000078)
1967 +#define HW_AUDIOIN_ANACLKCTRL_TOG (0x0000007c)
1968 +
1969 +#define BM_AUDIOIN_ANACLKCTRL_CLKGATE 0x80000000
1970 +#define BP_AUDIOIN_ANACLKCTRL_RSRVD4 11
1971 +#define BM_AUDIOIN_ANACLKCTRL_RSRVD4 0x7FFFF800
1972 +#define BF_AUDIOIN_ANACLKCTRL_RSRVD4(v) \
1973 + (((v) << 11) & BM_AUDIOIN_ANACLKCTRL_RSRVD4)
1974 +#define BM_AUDIOIN_ANACLKCTRL_DITHER_OFF 0x00000400
1975 +#define BM_AUDIOIN_ANACLKCTRL_SLOW_DITHER 0x00000200
1976 +#define BM_AUDIOIN_ANACLKCTRL_INVERT_ADCCLK 0x00000100
1977 +#define BP_AUDIOIN_ANACLKCTRL_RSRVD3 6
1978 +#define BM_AUDIOIN_ANACLKCTRL_RSRVD3 0x000000C0
1979 +#define BF_AUDIOIN_ANACLKCTRL_RSRVD3(v) \
1980 + (((v) << 6) & BM_AUDIOIN_ANACLKCTRL_RSRVD3)
1981 +#define BP_AUDIOIN_ANACLKCTRL_ADCCLK_SHIFT 4
1982 +#define BM_AUDIOIN_ANACLKCTRL_ADCCLK_SHIFT 0x00000030
1983 +#define BF_AUDIOIN_ANACLKCTRL_ADCCLK_SHIFT(v) \
1984 + (((v) << 4) & BM_AUDIOIN_ANACLKCTRL_ADCCLK_SHIFT)
1985 +#define BM_AUDIOIN_ANACLKCTRL_RSRVD2 0x00000008
1986 +#define BP_AUDIOIN_ANACLKCTRL_ADCDIV 0
1987 +#define BM_AUDIOIN_ANACLKCTRL_ADCDIV 0x00000007
1988 +#define BF_AUDIOIN_ANACLKCTRL_ADCDIV(v) \
1989 + (((v) << 0) & BM_AUDIOIN_ANACLKCTRL_ADCDIV)
1990 +
1991 +#define HW_AUDIOIN_DATA (0x00000080)
1992 +#define HW_AUDIOIN_DATA_SET (0x00000084)
1993 +#define HW_AUDIOIN_DATA_CLR (0x00000088)
1994 +#define HW_AUDIOIN_DATA_TOG (0x0000008c)
1995 +
1996 +#define BP_AUDIOIN_DATA_HIGH 16
1997 +#define BM_AUDIOIN_DATA_HIGH 0xFFFF0000
1998 +#define BF_AUDIOIN_DATA_HIGH(v) \
1999 + (((v) << 16) & BM_AUDIOIN_DATA_HIGH)
2000 +#define BP_AUDIOIN_DATA_LOW 0
2001 +#define BM_AUDIOIN_DATA_LOW 0x0000FFFF
2002 +#define BF_AUDIOIN_DATA_LOW(v) \
2003 + (((v) << 0) & BM_AUDIOIN_DATA_LOW)
2004 +
2005 +#define BV_AUDIOIN_ADCVOL_SELECT__MIC 0x00
2006 +
2007 +#endif /* __MXS_ADC_CODEC_H */
2008 diff --git a/sound/soc/mxs/Kconfig b/sound/soc/mxs/Kconfig
2009 index 78d321c..9b8dd7d 100644
2010 --- a/sound/soc/mxs/Kconfig
2011 +++ b/sound/soc/mxs/Kconfig
2012 @@ -18,3 +18,13 @@ config SND_SOC_MXS_SGTL5000
2013 a sgtl5000 codec.
2014
2015 endif # SND_MXS_SOC
2016 +
2017 +
2018 +config SND_MXS_SOC_BUILTIN
2019 + tristate "SoC Audio for Freescale i.MX23 built-in codec"
2020 + depends on ARCH_MXS
2021 + select SND_SOC_GENERIC_DMAENGINE_PCM
2022 + select SND_SOC_MXS_BUILTIN_CODEC
2023 + help
2024 + Say Y or M if you want to add support for codecs attached to
2025 + the MXS SAIF interface.
2026 diff --git a/sound/soc/mxs/Makefile b/sound/soc/mxs/Makefile
2027 index 565b5b5..cd0cf16 100644
2028 --- a/sound/soc/mxs/Makefile
2029 +++ b/sound/soc/mxs/Makefile
2030 @@ -8,3 +8,12 @@ obj-$(CONFIG_SND_MXS_SOC) += snd-soc-mxs.o snd-soc-mxs-pcm.o
2031 snd-soc-mxs-sgtl5000-objs := mxs-sgtl5000.o
2032
2033 obj-$(CONFIG_SND_SOC_MXS_SGTL5000) += snd-soc-mxs-sgtl5000.o
2034 +
2035 +# i.MX23 built-in audio Machine and Platform support
2036 +snd-soc-mxs-builtin-pcm-objs := mxs-builtin-pcm.o
2037 +snd-soc-mxs-builtin-dai-objs := mxs-builtin-dai.o
2038 +snd-soc-mxs-builtin-audio-objs := mxs-builtin-audio.o
2039 +
2040 +obj-$(CONFIG_SND_MXS_SOC_BUILTIN) += snd-soc-mxs-builtin-pcm.o
2041 +obj-$(CONFIG_SND_MXS_SOC_BUILTIN) += snd-soc-mxs-builtin-dai.o
2042 +obj-$(CONFIG_SND_MXS_SOC_BUILTIN) += snd-soc-mxs-builtin-audio.o
2043 diff --git a/sound/soc/mxs/mxs-builtin-audio.c b/sound/soc/mxs/mxs-builtin-audio.c
2044 new file mode 100644
2045 index 0000000..088863e
2046 --- /dev/null
2047 +++ b/sound/soc/mxs/mxs-builtin-audio.c
2048 @@ -0,0 +1,120 @@
2049 +/*
2050 + * mxs-builtin-audio.c -- i.MX233 built-in codec ALSA Soc Audio driver
2051 + *
2052 + * Author: Michal Ulianko <michal.ulianko@gmail.com>
2053 + *
2054 + * This program is free software; you can redistribute it and/or modify
2055 + * it under the terms of the GNU General Public License version 2 as
2056 + * published by the Free Software Foundation.
2057 + */
2058 +
2059 +#include <linux/module.h>
2060 +#include <linux/device.h>
2061 +#include <linux/of.h>
2062 +#include <linux/of_device.h>
2063 +#include <sound/core.h>
2064 +#include <sound/pcm.h>
2065 +#include <sound/soc.h>
2066 +#include <sound/jack.h>
2067 +#include <sound/soc-dapm.h>
2068 +#include <asm/mach-types.h>
2069 +
2070 +static struct snd_soc_dai_link mxs_adc_dai_link[] = {
2071 + {
2072 + .name = "MXS ADC/DAC",
2073 + .stream_name = "MXS ADC/DAC",
2074 + .codec_dai_name = "mxs-builtin-codec-dai",
2075 +// .codec_name = "mxs-builtin-codec",
2076 +// .cpu_dai_name = "mxs-builtin-cpu-dai",
2077 +// .platform_name = "mxs-builtin-cpu-dai",
2078 +// .ops = &mxs_sgtl5000_hifi_ops,
2079 + },
2080 +};
2081 +
2082 +static struct snd_soc_card mxs_adc_audio = {
2083 + .name = "mxs-builtin-audio",
2084 + .owner = THIS_MODULE,
2085 + .dai_link = mxs_adc_dai_link,
2086 + .num_links = ARRAY_SIZE(mxs_adc_dai_link),
2087 +};
2088 +
2089 +static int mxsadc_audio_probe_dt(struct platform_device *pdev)
2090 +{
2091 + struct device_node *np = pdev->dev.of_node;
2092 + struct device_node *cpu_dai_np, *codec_np;
2093 + int ret = 0;
2094 +
2095 + if (!np)
2096 + return 1; /* no device tree */
2097 +
2098 + cpu_dai_np = of_parse_phandle(np, "cpu-dai", 0);
2099 + codec_np = of_parse_phandle(np, "audio-codec", 0);
2100 + if (!cpu_dai_np || !codec_np) {
2101 + dev_err(&pdev->dev, "phandle missing or invalid\n");
2102 + return -EINVAL;
2103 + }
2104 +
2105 + mxs_adc_dai_link[0].codec_name = NULL;
2106 + mxs_adc_dai_link[0].codec_of_node = codec_np;
2107 + mxs_adc_dai_link[0].cpu_dai_name = NULL;
2108 + mxs_adc_dai_link[0].cpu_of_node = cpu_dai_np;
2109 + mxs_adc_dai_link[0].platform_name = NULL;
2110 + mxs_adc_dai_link[0].platform_of_node = cpu_dai_np;
2111 +
2112 +// of_node_put(codec_np);
2113 +// of_node_put(cpu_dai_np);
2114 +
2115 + return ret;
2116 +}
2117 +
2118 +static int mxsadc_audio_probe(struct platform_device *pdev)
2119 +{
2120 + struct snd_soc_card *card = &mxs_adc_audio;
2121 + int ret;
2122 +
2123 + ret = mxsadc_audio_probe_dt(pdev);
2124 + if (ret < 0)
2125 + return ret;
2126 +
2127 + card->dev = &pdev->dev;
2128 + platform_set_drvdata(pdev, card);
2129 +
2130 + ret = snd_soc_register_card(card);
2131 + if (ret) {
2132 + dev_err(&pdev->dev, "snd_soc_register_card failed (%d)\n", ret);
2133 + return ret;
2134 + }
2135 +
2136 + return 0;
2137 +}
2138 +
2139 +static int mxsadc_audio_remove(struct platform_device *pdev)
2140 +{
2141 + struct snd_soc_card *card = platform_get_drvdata(pdev);
2142 +
2143 + snd_soc_unregister_card(card);
2144 +
2145 + return 0;
2146 +}
2147 +
2148 +static const struct of_device_id mxs_adc_audio_dt_ids[] = {
2149 + { .compatible = "fsl,mxs-builtin-audio", },
2150 + { /* sentinel */ }
2151 +};
2152 +MODULE_DEVICE_TABLE(of, mxs_adc_audio_dt_ids);
2153 +
2154 +static struct platform_driver mxs_adc_audio_driver = {
2155 + .driver = {
2156 + .name = "mxs-builtin-audio",
2157 + .owner = THIS_MODULE,
2158 + .of_match_table = mxs_adc_audio_dt_ids,
2159 + },
2160 + .probe = mxsadc_audio_probe,
2161 + .remove = mxsadc_audio_remove,
2162 +};
2163 +
2164 +module_platform_driver(mxs_adc_audio_driver);
2165 +
2166 +MODULE_DESCRIPTION("Freescale MXS ADC/DAC SoC Machine Driver");
2167 +MODULE_AUTHOR("Michal Ulianko <michal.ulianko@gmail.com>");
2168 +MODULE_LICENSE("GPL");
2169 diff --git a/sound/soc/mxs/mxs-builtin-dai.c b/sound/soc/mxs/mxs-builtin-dai.c
2170 new file mode 100644
2171 index 0000000..d12bde7
2172 --- /dev/null
2173 +++ b/sound/soc/mxs/mxs-builtin-dai.c
2174 @@ -0,0 +1,588 @@
2175 +/*
2176 + * mxs-builtin-dai.c -- i.MX233 built-in codec ALSA Soc Audio driver
2177 + *
2178 + * Author: Michal Ulianko <michal.ulianko@gmail.com>
2179 + *
2180 + * Based on sound/soc/mxs/mxs-adc.c for kernel 2.6.35
2181 + * by Vladislav Buzov <vbuzov@embeddedalley.com>
2182 + *
2183 + * This program is free software; you can redistribute it and/or modify
2184 + * it under the terms of the GNU General Public License version 2 as
2185 + * published by the Free Software Foundation.
2186 + */
2187 +
2188 +#include <linux/module.h>
2189 +#include <linux/init.h>
2190 +#include <linux/interrupt.h>
2191 +#include <linux/delay.h>
2192 +#include <linux/dma-mapping.h>
2193 +#include <linux/platform_device.h>
2194 +#include <sound/pcm.h>
2195 +#include <sound/pcm_params.h>
2196 +#include <sound/soc.h>
2197 +
2198 +#include "../codecs/mxs-builtin-codec.h"
2199 +#include "mxs-builtin-pcm.h"
2200 +
2201 +#define ADC_VOLUME_MIN 0x37
2202 +
2203 +/* TODO Use codec IO function soc snd write etc, instead of __writel __readl */
2204 +
2205 +// TODO use container_of
2206 +struct mxs_irq_data {
2207 + struct snd_pcm_substream *substream;
2208 + struct mxs_adc_priv *mxs_adc;
2209 +};
2210 +
2211 +struct mxs_adc_priv {
2212 + struct mxs_irq_data irq_data;
2213 + int dma_adc_err_irq;
2214 + int dma_dac_err_irq;
2215 + int hp_short_irq;
2216 + void __iomem *audioin_base;
2217 + void __iomem *audioout_base;
2218 + void __iomem *rtc_base;
2219 +};
2220 +
2221 +typedef struct {
2222 + struct work_struct work;
2223 + struct timer_list timer;
2224 +
2225 + /* target workqueue and CPU ->timer uses to queue ->work */
2226 + struct workqueue_struct *wq;
2227 + int cpu;
2228 +
2229 + struct mxs_adc_priv *mxs_adc;
2230 +} my_delayed_work_t;
2231 +
2232 +// static struct delayed_work work;
2233 +// static struct delayed_work adc_ramp_work;
2234 +// static struct delayed_work dac_ramp_work;
2235 +// static struct delayed_work test;
2236 +static my_delayed_work_t work;
2237 +static my_delayed_work_t adc_ramp_work;
2238 +static my_delayed_work_t dac_ramp_work;
2239 +static my_delayed_work_t test;
2240 +static bool adc_ramp_done = 1;
2241 +static bool dac_ramp_done = 1;
2242 +
2243 +static inline void mxs_adc_schedule_work(struct delayed_work *work)
2244 +{
2245 + schedule_delayed_work(work, HZ / 10);
2246 +}
2247 +
2248 +static void mxs_adc_work(struct work_struct *work)
2249 +{
2250 + struct mxs_adc_priv *mxs_adc = ((my_delayed_work_t *)work)->mxs_adc;
2251 + /* disable irq */
2252 + disable_irq(mxs_adc->hp_short_irq);
2253 +
2254 + while (true) {
2255 + __raw_writel(BM_AUDIOOUT_PWRDN_HEADPHONE,
2256 + mxs_adc->audioout_base + HW_AUDIOOUT_PWRDN_CLR);
2257 + msleep(10);
2258 + if ((__raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL)
2259 + & BM_AUDIOOUT_ANACTRL_SHORT_LR_STS) != 0) {
2260 + /* rearm the short protection */
2261 + __raw_writel(BM_AUDIOOUT_ANACTRL_SHORTMODE_LR,
2262 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_CLR);
2263 + __raw_writel(BM_AUDIOOUT_ANACTRL_SHORT_LR_STS,
2264 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_CLR);
2265 + __raw_writel(BF_AUDIOOUT_ANACTRL_SHORTMODE_LR(0x1),
2266 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_SET);
2267 +
2268 + __raw_writel(BM_AUDIOOUT_PWRDN_HEADPHONE,
2269 + mxs_adc->audioout_base + HW_AUDIOOUT_PWRDN_SET);
2270 + printk(KERN_WARNING "WARNING : Headphone LR short!\r\n");
2271 + } else {
2272 + printk(KERN_WARNING "INFO : Headphone LR no longer short!\r\n");
2273 + break;
2274 + }
2275 + msleep(1000);
2276 + }
2277 +
2278 + /* power up the HEADPHONE and un-mute the HPVOL */
2279 + __raw_writel(BM_AUDIOOUT_HPVOL_MUTE,
2280 + mxs_adc->audioout_base + HW_AUDIOOUT_HPVOL_CLR);
2281 + __raw_writel(BM_AUDIOOUT_PWRDN_HEADPHONE,
2282 + mxs_adc->audioout_base + HW_AUDIOOUT_PWRDN_CLR);
2283 +
2284 + /* enable irq for next short detect*/
2285 + enable_irq(mxs_adc->hp_short_irq);
2286 +}
2287 +
2288 +static void mxs_adc_schedule_ramp_work(struct delayed_work *work)
2289 +{
2290 + schedule_delayed_work(work, msecs_to_jiffies(2));
2291 + adc_ramp_done = 0;
2292 +}
2293 +
2294 +static void mxs_adc_ramp_work(struct work_struct *work)
2295 +{
2296 + struct mxs_adc_priv *mxs_adc = ((my_delayed_work_t *)work)->mxs_adc;
2297 + u32 reg = 0;
2298 + u32 reg1 = 0;
2299 + u32 reg2 = 0;
2300 + u32 l, r;
2301 + u32 ll, rr;
2302 + int i;
2303 +
2304 + reg = __raw_readl(mxs_adc->audioin_base + \
2305 + HW_AUDIOIN_ADCVOLUME);
2306 +
2307 + reg1 = reg & ~BM_AUDIOIN_ADCVOLUME_VOLUME_LEFT;
2308 + reg1 = reg1 & ~BM_AUDIOIN_ADCVOLUME_VOLUME_RIGHT;
2309 + /* minimize adc volume */
2310 + reg2 = reg1 |
2311 + BF_AUDIOIN_ADCVOLUME_VOLUME_LEFT(ADC_VOLUME_MIN) |
2312 + BF_AUDIOIN_ADCVOLUME_VOLUME_RIGHT(ADC_VOLUME_MIN);
2313 + __raw_writel(reg2,
2314 + mxs_adc->audioin_base + HW_AUDIOIN_ADCVOLUME);
2315 + msleep(1);
2316 +
2317 + l = (reg & BM_AUDIOIN_ADCVOLUME_VOLUME_LEFT) >>
2318 + BP_AUDIOIN_ADCVOLUME_VOLUME_LEFT;
2319 + r = (reg & BM_AUDIOIN_ADCVOLUME_VOLUME_RIGHT) >>
2320 + BP_AUDIOIN_ADCVOLUME_VOLUME_RIGHT;
2321 +
2322 + /* fade in adc vol */
2323 + for (i = ADC_VOLUME_MIN; (i < l) || (i < r);) {
2324 + i += 0x8;
2325 + ll = i < l ? i : l;
2326 + rr = i < r ? i : r;
2327 + reg2 = reg1 |
2328 + BF_AUDIOIN_ADCVOLUME_VOLUME_LEFT(ll) |
2329 + BF_AUDIOIN_ADCVOLUME_VOLUME_RIGHT(rr);
2330 + __raw_writel(reg2,
2331 + mxs_adc->audioin_base + HW_AUDIOIN_ADCVOLUME);
2332 + msleep(1);
2333 + }
2334 + adc_ramp_done = 1;
2335 +}
2336 +
2337 +static void mxs_dac_schedule_ramp_work(struct delayed_work *work)
2338 +{
2339 + schedule_delayed_work(work, msecs_to_jiffies(2));
2340 + dac_ramp_done = 0;
2341 +}
2342 +
2343 +static void mxs_dac_ramp_work(struct work_struct *work)
2344 +{
2345 + struct mxs_adc_priv *mxs_adc = ((my_delayed_work_t *)work)->mxs_adc;
2346 + u32 reg = 0;
2347 + u32 reg1 = 0;
2348 + u32 l, r;
2349 + u32 ll, rr;
2350 + int i;
2351 +
2352 + /* unmute hp and speaker */
2353 + __raw_writel(BM_AUDIOOUT_HPVOL_MUTE,
2354 + mxs_adc->audioout_base + HW_AUDIOOUT_HPVOL_CLR);
2355 + __raw_writel(BM_AUDIOOUT_SPEAKERCTRL_MUTE,
2356 + mxs_adc->audioout_base + HW_AUDIOOUT_SPEAKERCTRL_CLR);
2357 +
2358 + reg = __raw_readl(mxs_adc->audioout_base + \
2359 + HW_AUDIOOUT_HPVOL);
2360 +
2361 + reg1 = reg & ~BM_AUDIOOUT_HPVOL_VOL_LEFT;
2362 + reg1 = reg1 & ~BM_AUDIOOUT_HPVOL_VOL_RIGHT;
2363 +
2364 + l = (reg & BM_AUDIOOUT_HPVOL_VOL_LEFT) >>
2365 + BP_AUDIOOUT_HPVOL_VOL_LEFT;
2366 + r = (reg & BM_AUDIOOUT_HPVOL_VOL_RIGHT) >>
2367 + BP_AUDIOOUT_HPVOL_VOL_RIGHT;
2368 + /* fade in hp vol */
2369 + for (i = 0x7f; i > 0 ;) {
2370 + i -= 0x8;
2371 + ll = i > (int)l ? i : l;
2372 + rr = i > (int)r ? i : r;
2373 + reg = reg1 | BF_AUDIOOUT_HPVOL_VOL_LEFT(ll)
2374 + | BF_AUDIOOUT_HPVOL_VOL_RIGHT(rr);
2375 + __raw_writel(reg,
2376 + mxs_adc->audioout_base + HW_AUDIOOUT_HPVOL);
2377 + msleep(1);
2378 + }
2379 + dac_ramp_done = 1;
2380 +}
2381 +
2382 +/* IRQs */
2383 +static irqreturn_t mxs_short_irq(int irq, void *dev_id)
2384 +{
2385 + struct mxs_adc_priv *mxs_adc = dev_id;
2386 + //struct snd_pcm_substream *substream = mxs_adc->irq_data.substream;
2387 +
2388 + __raw_writel(BM_AUDIOOUT_ANACTRL_SHORTMODE_LR,
2389 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_CLR);
2390 + __raw_writel(BM_AUDIOOUT_ANACTRL_SHORT_LR_STS,
2391 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_CLR);
2392 + __raw_writel(BF_AUDIOOUT_ANACTRL_SHORTMODE_LR(0x1),
2393 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_SET);
2394 +
2395 + __raw_writel(BM_AUDIOOUT_HPVOL_MUTE,
2396 + mxs_adc->audioout_base + HW_AUDIOOUT_HPVOL_SET);
2397 + __raw_writel(BM_AUDIOOUT_PWRDN_HEADPHONE,
2398 + mxs_adc->audioout_base + HW_AUDIOOUT_PWRDN_SET);
2399 + __raw_writel(BM_AUDIOOUT_ANACTRL_HP_CLASSAB,
2400 + mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL_SET);
2401 +
2402 + mxs_adc_schedule_work((struct delayed_work *) &work);
2403 + return IRQ_HANDLED;
2404 +}
2405 +
2406 +static irqreturn_t mxs_err_irq(int irq, void *dev_id)
2407 +{
2408 + struct mxs_adc_priv *mxs_adc = dev_id;
2409 + struct snd_pcm_substream *substream = mxs_adc->irq_data.substream;
2410 + int playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0;
2411 + u32 ctrl_reg;
2412 + u32 overflow_mask;
2413 + u32 underflow_mask;
2414 +
2415 + if (playback) {
2416 + ctrl_reg = __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_CTRL);
2417 + underflow_mask = BM_AUDIOOUT_CTRL_FIFO_UNDERFLOW_IRQ;
2418 + overflow_mask = BM_AUDIOOUT_CTRL_FIFO_OVERFLOW_IRQ;
2419 + } else {
2420 + ctrl_reg = __raw_readl(mxs_adc->audioin_base + HW_AUDIOIN_CTRL);
2421 + underflow_mask = BM_AUDIOIN_CTRL_FIFO_UNDERFLOW_IRQ;
2422 + overflow_mask = BM_AUDIOIN_CTRL_FIFO_OVERFLOW_IRQ;
2423 + }
2424 +
2425 + if (ctrl_reg & underflow_mask) {
2426 + printk(KERN_DEBUG "%s underflow detected\n",
2427 + playback ? "DAC" : "ADC");
2428 +
2429 + if (playback)
2430 + __raw_writel(
2431 + BM_AUDIOOUT_CTRL_FIFO_UNDERFLOW_IRQ,
2432 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_CLR);
2433 + else
2434 + __raw_writel(
2435 + BM_AUDIOIN_CTRL_FIFO_UNDERFLOW_IRQ,
2436 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_CLR);
2437 +
2438 + } else if (ctrl_reg & overflow_mask) {
2439 + printk(KERN_DEBUG "%s overflow detected\n",
2440 + playback ? "DAC" : "ADC");
2441 +
2442 + if (playback)
2443 + __raw_writel(
2444 + BM_AUDIOOUT_CTRL_FIFO_OVERFLOW_IRQ,
2445 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_CLR);
2446 + else
2447 + __raw_writel(BM_AUDIOIN_CTRL_FIFO_OVERFLOW_IRQ,
2448 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_CLR);
2449 + } else
2450 + printk(KERN_WARNING "Unknown DAC error interrupt\n");
2451 +
2452 + return IRQ_HANDLED;
2453 +}
2454 +/* END IRQs */
2455 +
2456 +static int mxs_trigger(struct snd_pcm_substream *substream,
2457 + int cmd,
2458 + struct snd_soc_dai *cpu_dai)
2459 +{
2460 + struct mxs_adc_priv *mxs_adc = snd_soc_dai_get_drvdata(cpu_dai);
2461 + int playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0;
2462 + int ret = 0;
2463 +
2464 + switch (cmd) {
2465 + case SNDRV_PCM_TRIGGER_START:
2466 + case SNDRV_PCM_TRIGGER_RESUME:
2467 + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2468 +
2469 + if (playback) {
2470 + /* enable the fifo error interrupt */
2471 + __raw_writel(BM_AUDIOOUT_CTRL_FIFO_ERROR_IRQ_EN,
2472 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_SET);
2473 + /* write a data to data reg to trigger the transfer */
2474 + __raw_writel(0x0,
2475 + mxs_adc->audioout_base + HW_AUDIOOUT_DATA);
2476 + mxs_dac_schedule_ramp_work((struct delayed_work *) &dac_ramp_work);
2477 + } else {
2478 +// mxs_dma_get_info(prtd->dma_ch, &dma_info);
2479 +// cur_bar1 = dma_info.buf_addr;
2480 +// xfer_count1 = dma_info.xfer_count;
2481 +
2482 + __raw_writel(BM_AUDIOIN_CTRL_RUN,
2483 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_SET);
2484 + udelay(100);
2485 +
2486 +// mxs_dma_get_info(prtd->dma_ch, &dma_info);
2487 +// cur_bar2 = dma_info.buf_addr;
2488 +// xfer_count2 = dma_info.xfer_count;
2489 +//
2490 +// /* check if DMA getting stuck */
2491 +// if ((xfer_count1 == xfer_count2) && (cur_bar1 == cur_bar2))
2492 +// /* read a data from data reg to trigger the receive */
2493 +// reg = __raw_readl(mxs_adc->audioin_base + HW_AUDIOIN_DATA);
2494 +
2495 + mxs_adc_schedule_ramp_work((struct delayed_work *) &adc_ramp_work);
2496 + }
2497 + break;
2498 +
2499 + case SNDRV_PCM_TRIGGER_SUSPEND:
2500 + case SNDRV_PCM_TRIGGER_STOP:
2501 + case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2502 +
2503 + if (playback) {
2504 +// printk(KERN_INFO "SNDRV_PCM_TRIGGER_START\n");
2505 +// printk(KERN_INFO "ctrl:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_CTRL));
2506 +// printk(KERN_INFO "stat:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_STAT));
2507 +// printk(KERN_INFO "srr:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_DACSRR));
2508 +// printk(KERN_INFO "vol:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_DACVOLUME));
2509 +// printk(KERN_INFO "debug:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_DACDEBUG));
2510 +// printk(KERN_INFO "hpvol:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_HPVOL));
2511 +// printk(KERN_INFO "pwrdn:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_PWRDN));
2512 +// printk(KERN_INFO "refc:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_REFCTRL));
2513 +// printk(KERN_INFO "anac:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_ANACTRL));
2514 +// printk(KERN_INFO "test:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_TEST));
2515 +// printk(KERN_INFO "bist:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_BISTCTRL));
2516 +// printk(KERN_INFO "anaclk:%x\n", __raw_readl(mxs_adc->audioout_base + HW_AUDIOOUT_ANACLKCTRL));
2517 +
2518 + if (dac_ramp_done == 0) {
2519 + cancel_delayed_work((struct delayed_work *) &dac_ramp_work);
2520 + dac_ramp_done = 1;
2521 + }
2522 + __raw_writel(BM_AUDIOOUT_HPVOL_MUTE,
2523 + mxs_adc->audioout_base + HW_AUDIOOUT_HPVOL_SET);
2524 + __raw_writel(BM_AUDIOOUT_SPEAKERCTRL_MUTE,
2525 + mxs_adc->audioout_base + HW_AUDIOOUT_SPEAKERCTRL_SET);
2526 + /* disable the fifo error interrupt */
2527 + __raw_writel(BM_AUDIOOUT_CTRL_FIFO_ERROR_IRQ_EN,
2528 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_CLR);
2529 + mdelay(50);
2530 + } else {
2531 + if (adc_ramp_done == 0) {
2532 + cancel_delayed_work((struct delayed_work *) &adc_ramp_work);
2533 + adc_ramp_done = 1;
2534 + }
2535 + __raw_writel(BM_AUDIOIN_CTRL_RUN,
2536 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_CLR);
2537 + }
2538 + break;
2539 +
2540 + default:
2541 + printk(KERN_ERR "TRIGGER ERROR\n");
2542 + ret = -EINVAL;
2543 + }
2544 +
2545 + return ret;
2546 +}
2547 +
2548 +static int mxs_startup(struct snd_pcm_substream *substream,
2549 + struct snd_soc_dai *cpu_dai)
2550 +{
2551 + struct mxs_adc_priv *mxs_adc = snd_soc_dai_get_drvdata(cpu_dai);
2552 + int playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0;
2553 + mxs_adc->irq_data.mxs_adc = mxs_adc;
2554 + mxs_adc->irq_data.substream = substream;
2555 +
2556 + work.mxs_adc = mxs_adc;
2557 + adc_ramp_work.mxs_adc = mxs_adc;
2558 + dac_ramp_work.mxs_adc = mxs_adc;
2559 + test.mxs_adc = mxs_adc;
2560 + INIT_DELAYED_WORK(&work, mxs_adc_work);
2561 + INIT_DELAYED_WORK(&adc_ramp_work, mxs_adc_ramp_work);
2562 + INIT_DELAYED_WORK(&dac_ramp_work, mxs_dac_ramp_work);
2563 +
2564 + /* Enable error interrupt */
2565 + if (playback) {
2566 + __raw_writel(BM_AUDIOOUT_CTRL_FIFO_OVERFLOW_IRQ,
2567 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_CLR);
2568 + __raw_writel(BM_AUDIOOUT_CTRL_FIFO_UNDERFLOW_IRQ,
2569 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_CLR);
2570 + } else {
2571 + __raw_writel(BM_AUDIOIN_CTRL_FIFO_OVERFLOW_IRQ,
2572 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_CLR);
2573 + __raw_writel(BM_AUDIOIN_CTRL_FIFO_UNDERFLOW_IRQ,
2574 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_CLR);
2575 + __raw_writel(BM_AUDIOIN_CTRL_FIFO_ERROR_IRQ_EN,
2576 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_SET);
2577 + }
2578 +
2579 + return 0;
2580 +}
2581 +
2582 +static void mxs_shutdown(struct snd_pcm_substream *substream,
2583 + struct snd_soc_dai *cpu_dai)
2584 +{
2585 + struct mxs_adc_priv *mxs_adc = snd_soc_dai_get_drvdata(cpu_dai);
2586 + int playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0;
2587 +
2588 + /* Disable error interrupt */
2589 + if (playback) {
2590 + __raw_writel(BM_AUDIOOUT_CTRL_FIFO_ERROR_IRQ_EN,
2591 + mxs_adc->audioout_base + HW_AUDIOOUT_CTRL_CLR);
2592 + } else {
2593 + __raw_writel(BM_AUDIOIN_CTRL_FIFO_ERROR_IRQ_EN,
2594 + mxs_adc->audioin_base + HW_AUDIOIN_CTRL_CLR);
2595 + }
2596 +}
2597 +
2598 +#define MXS_ADC_RATES SNDRV_PCM_RATE_8000_192000
2599 +#define MXS_ADC_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
2600 +
2601 +static const struct snd_soc_dai_ops mxs_adc_dai_ops = {
2602 + .startup = mxs_startup,
2603 + .trigger = mxs_trigger,
2604 + .shutdown = mxs_shutdown,
2605 +};
2606 +
2607 +static int mxs_dai_probe(struct snd_soc_dai *dai)
2608 +{
2609 + // TODO This does not make any sense.
2610 + struct mxs_adc_priv *mxs_adc = dev_get_drvdata(dai->dev);
2611 +
2612 + snd_soc_dai_set_drvdata(dai, mxs_adc);
2613 +
2614 + return 0;
2615 +}
2616 +
2617 +static struct snd_soc_dai_driver mxs_adc_dai = {
2618 + .name = "mxs-builtin-cpu-dai",
2619 + .probe = mxs_dai_probe,
2620 + .playback = {
2621 + .channels_min = 2,
2622 + .channels_max = 2,
2623 + .rates = MXS_ADC_RATES,
2624 + .formats = MXS_ADC_FORMATS,
2625 + },
2626 + .capture = {
2627 + .channels_min = 2,
2628 + .channels_max = 2,
2629 + .rates = MXS_ADC_RATES,
2630 + .formats = MXS_ADC_FORMATS,
2631 + },
2632 + .ops = &mxs_adc_dai_ops,
2633 +};
2634 +
2635 +static const struct snd_soc_component_driver mxs_adc_component = {
2636 + .name = "mxs-xxx", //TODO change this name
2637 +};
2638 +
2639 +static int mxs_adc_probe(struct platform_device *pdev)
2640 +{
2641 + struct device_node *np = pdev->dev.of_node;
2642 + struct mxs_adc_priv *mxs_adc;
2643 + int ret = 0;
2644 +
2645 + if (!np)
2646 + return -EINVAL;
2647 +
2648 + mxs_adc = devm_kzalloc(&pdev->dev, sizeof(*mxs_adc), GFP_KERNEL);
2649 + if (!mxs_adc)
2650 + return -ENOMEM;
2651 +
2652 + mxs_adc->audioout_base = devm_ioremap(&pdev->dev, 0x80048000, 0x2000);
2653 + if (IS_ERR(mxs_adc->audioout_base))
2654 + return PTR_ERR(mxs_adc->audioout_base);
2655 +
2656 + mxs_adc->audioin_base = devm_ioremap(&pdev->dev, 0x8004c000, 0x2000);
2657 + if (IS_ERR(mxs_adc->audioin_base))
2658 + return PTR_ERR(mxs_adc->audioin_base);
2659 +
2660 + mxs_adc->rtc_base = devm_ioremap(&pdev->dev, 0x8005c000, 0x2000);
2661 + if (IS_ERR(mxs_adc->rtc_base))
2662 + return PTR_ERR(mxs_adc->rtc_base);
2663 +
2664 + /* Get IRQ numbers */
2665 + mxs_adc->dma_adc_err_irq = platform_get_irq(pdev, 0);
2666 + if (mxs_adc->dma_adc_err_irq < 0) {
2667 + ret = mxs_adc->dma_adc_err_irq;
2668 + dev_err(&pdev->dev, "failed to get ADC DMA ERR irq resource: %d\n", ret);
2669 + return ret;
2670 + }
2671 +
2672 + mxs_adc->dma_dac_err_irq = platform_get_irq(pdev, 1);
2673 + if (mxs_adc->dma_dac_err_irq < 0) {
2674 + ret = mxs_adc->dma_dac_err_irq;
2675 + dev_err(&pdev->dev, "failed to get DAC DMA ERR irq resource: %d\n", ret);
2676 + return ret;
2677 + }
2678 +
2679 + mxs_adc->hp_short_irq = platform_get_irq(pdev, 2);
2680 + if (mxs_adc->hp_short_irq < 0) {
2681 + ret = mxs_adc->hp_short_irq;
2682 + dev_err(&pdev->dev, "failed to get HP_SHORT irq resource: %d\n", ret);
2683 + return ret;
2684 + }
2685 +
2686 + /* Request IRQs */
2687 + ret = devm_request_irq(&pdev->dev, mxs_adc->dma_adc_err_irq, mxs_err_irq, 0, "MXS DAC and ADC Error",
2688 + mxs_adc);
2689 + if (ret) {
2690 + printk(KERN_ERR "%s: Unable to request ADC/DAC error irq %d\n",
2691 + __func__, mxs_adc->dma_adc_err_irq);
2692 + return ret;
2693 + }
2694 +
2695 + ret = devm_request_irq(&pdev->dev, mxs_adc->dma_dac_err_irq, mxs_err_irq, 0, "MXS DAC and ADC Error",
2696 + mxs_adc);
2697 + if (ret) {
2698 + printk(KERN_ERR "%s: Unable to request ADC/DAC error irq %d\n",
2699 + __func__, mxs_adc->dma_dac_err_irq);
2700 + return ret;
2701 + }
2702 +
2703 + ret = devm_request_irq(&pdev->dev, mxs_adc->hp_short_irq, mxs_short_irq,
2704 + IRQF_DISABLED | IRQF_SHARED, "MXS DAC and ADC HP SHORT", mxs_adc);
2705 + if (ret) {
2706 + printk(KERN_ERR "%s: Unable to request ADC/DAC HP SHORT irq %d\n",
2707 + __func__, mxs_adc->hp_short_irq);
2708 + return ret;
2709 + }
2710 +
2711 + platform_set_drvdata(pdev, mxs_adc);
2712 +
2713 + ret = snd_soc_register_component(&pdev->dev, &mxs_adc_component, &mxs_adc_dai, 1);
2714 + if (ret) {
2715 + dev_err(&pdev->dev, "register DAI failed\n");
2716 + return ret;
2717 + }
2718 +
2719 + ret = mxs_adc_pcm_platform_register(&pdev->dev);
2720 + if (ret) {
2721 + dev_err(&pdev->dev, "register PCM failed: %d\n", ret);
2722 + goto failed_pdev_alloc;
2723 + }
2724 +
2725 + return 0;
2726 +
2727 +failed_pdev_alloc:
2728 + snd_soc_unregister_component(&pdev->dev);
2729 +
2730 + return ret;
2731 +}
2732 +
2733 +static int mxs_adc_remove(struct platform_device *pdev)
2734 +{
2735 + mxs_adc_pcm_platform_unregister(&pdev->dev);
2736 + snd_soc_unregister_component(&pdev->dev);
2737 +
2738 + return 0;
2739 +}
2740 +
2741 +static const struct of_device_id mxs_adc_dai_dt_ids[] = {
2742 + { .compatible = "fsl,mxs-builtin-cpu-dai", },
2743 + { /* sentinel */ }
2744 +};
2745 +MODULE_DEVICE_TABLE(of, mxs_adc_dai_dt_ids);
2746 +
2747 +static struct platform_driver mxs_adc_dai_driver = {
2748 + .probe = mxs_adc_probe,
2749 + .remove = mxs_adc_remove,
2750 +
2751 + .driver = {
2752 + .name = "mxs-builtin-cpu-dai",
2753 + .owner = THIS_MODULE,
2754 + .of_match_table = mxs_adc_dai_dt_ids,
2755 + },
2756 +};
2757 +
2758 +module_platform_driver(mxs_adc_dai_driver);
2759 +
2760 +MODULE_DESCRIPTION("Freescale MXS ADC/DAC SoC Codec DAI Driver");
2761 +MODULE_AUTHOR("Michal Ulianko <michal.ulianko@gmail.com>");
2762 +MODULE_LICENSE("GPL");
2763 diff --git a/sound/soc/mxs/mxs-builtin-pcm.c b/sound/soc/mxs/mxs-builtin-pcm.c
2764 new file mode 100644
2765 index 0000000..9f155df
2766 --- /dev/null
2767 +++ b/sound/soc/mxs/mxs-builtin-pcm.c
2768 @@ -0,0 +1,69 @@
2769 +/*
2770 + * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
2771 + *
2772 + * Based on sound/soc/imx/imx-pcm-dma-mx2.c
2773 + *
2774 + * This program is free software; you can redistribute it and/or modify
2775 + * it under the terms of the GNU General Public License as published by
2776 + * the Free Software Foundation; either version 2 of the License, or
2777 + * (at your option) any later version.
2778 + *
2779 + * This program is distributed in the hope that it will be useful,
2780 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2781 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2782 + * GNU General Public License for more details.
2783 + *
2784 + * You should have received a copy of the GNU General Public License along
2785 + * with this program; if not, write to the Free Software Foundation, Inc.,
2786 + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
2787 + */
2788 +
2789 +#include <linux/device.h>
2790 +#include <linux/init.h>
2791 +#include <linux/module.h>
2792 +
2793 +#include <sound/core.h>
2794 +#include <sound/pcm.h>
2795 +#include <sound/soc.h>
2796 +#include <sound/dmaengine_pcm.h>
2797 +
2798 +#include "mxs-builtin-pcm.h"
2799 +
2800 +static const struct snd_pcm_hardware snd_mxs_hardware = {
2801 + .info = SNDRV_PCM_INFO_MMAP |
2802 + SNDRV_PCM_INFO_MMAP_VALID |
2803 + SNDRV_PCM_INFO_PAUSE |
2804 + SNDRV_PCM_INFO_RESUME |
2805 + SNDRV_PCM_INFO_INTERLEAVED,
2806 + .formats = SNDRV_PCM_FMTBIT_S16_LE |
2807 + SNDRV_PCM_FMTBIT_S20_3LE |
2808 + SNDRV_PCM_FMTBIT_S24_LE,
2809 + .channels_min = 2,
2810 + .channels_max = 2,
2811 + .period_bytes_min = 32,
2812 + .period_bytes_max = 8192,
2813 + .periods_min = 1,
2814 + .periods_max = 52,
2815 + .buffer_bytes_max = 64 * 1024,
2816 + .fifo_size = 32,
2817 +};
2818 +
2819 +static const struct snd_dmaengine_pcm_config mxs_dmaengine_pcm_config = {
2820 + .pcm_hardware = &snd_mxs_hardware,
2821 + .prealloc_buffer_size = 64 * 1024,
2822 +};
2823 +
2824 +int mxs_adc_pcm_platform_register(struct device *dev)
2825 +{
2826 + return snd_dmaengine_pcm_register(dev, &mxs_dmaengine_pcm_config,
2827 + SND_DMAENGINE_PCM_FLAG_NO_RESIDUE);
2828 +}
2829 +EXPORT_SYMBOL_GPL(mxs_adc_pcm_platform_register);
2830 +
2831 +void mxs_adc_pcm_platform_unregister(struct device *dev)
2832 +{
2833 + snd_dmaengine_pcm_unregister(dev);
2834 +}
2835 +EXPORT_SYMBOL_GPL(mxs_adc_pcm_platform_unregister);
2836 +
2837 +MODULE_LICENSE("GPL");
2838 diff --git a/sound/soc/mxs/mxs-builtin-pcm.h b/sound/soc/mxs/mxs-builtin-pcm.h
2839 new file mode 100644
2840 index 0000000..2fba109
2841 --- /dev/null
2842 +++ b/sound/soc/mxs/mxs-builtin-pcm.h
2843 @@ -0,0 +1,25 @@
2844 +/*
2845 + * Copyright (C) 2011 Freescale Semiconductor, Inc. All Rights Reserved.
2846 + *
2847 + * This program is free software; you can redistribute it and/or modify
2848 + * it under the terms of the GNU General Public License as published by
2849 + * the Free Software Foundation; either version 2 of the License, or
2850 + * (at your option) any later version.
2851 + *
2852 + * This program is distributed in the hope that it will be useful,
2853 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
2854 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2855 + * GNU General Public License for more details.
2856 + *
2857 + * You should have received a copy of the GNU General Public License along
2858 + * with this program; if not, write to the Free Software Foundation, Inc.,
2859 + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
2860 + */
2861 +
2862 +#ifndef _MXS_PCM_H
2863 +#define _MXS_PCM_H
2864 +
2865 +int mxs_adc_pcm_platform_register(struct device *dev);
2866 +void mxs_adc_pcm_platform_unregister(struct device *dev);
2867 +
2868 +#endif
OpenWrt SVN history