projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ASoC: Convert ALC5632 codec to use regmap API
[deliverable/linux.git] / sound / soc / codecs / alc5632.c
CommitLineData
94d5f7c0
LR		 1/*
2* alc5632.c -- ALC5632 ALSA SoC Audio Codec
3*
4* Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.lauchpad.net>
5*
6* Authors: Leon Romanovsky <leon@leon.nu>
7* Andrey Danin <danindrey@mail.ru>
8* Ilya Petrov <ilya.muromec@gmail.com>
9* Marc Dietrich <marvin24@gmx.de>
10*
11* Based on alc5623.c by Arnaud Patard
12*
13* This program is free software; you can redistribute it and/or modify
14* it under the terms of the GNU General Public License version 2 as
15* published by the Free Software Foundation.
16*/
17
18#include <linux/module.h>
19#include <linux/kernel.h>
20#include <linux/init.h>
21#include <linux/delay.h>
22#include <linux/pm.h>
23#include <linux/i2c.h>
24#include <linux/slab.h>
bb39753c 25#include <linux/regmap.h>
94d5f7c0
LR		 26#include <sound/core.h>
27#include <sound/pcm.h>
28#include <sound/pcm_params.h>
29#include <sound/tlv.h>
30#include <sound/soc.h>
31#include <sound/initval.h>
32
33#include "alc5632.h"
34
35/*
36 * ALC5632 register cache
37 */
bb39753c
LR		 38static struct reg_default alc5632_reg_defaults[] = {
39 { 0, 0x59B4 },
40 { 1, 0x0000 },
41 { 2, 0x8080 },
42 { 3, 0x0000 },
43 { 4, 0x8080 },
44 { 5, 0x0000 },
45 { 6, 0x8080 },
46 { 7, 0x0000 },
47 { 8, 0xC800 },
48 { 9, 0x0000 },
49 { 10, 0xE808 },
50 { 11, 0x0000 },
51 { 12, 0x1010 },
52 { 13, 0x0000 },
53 { 14, 0x0808 },
54 { 15, 0x0000 },
55 { 16, 0xEE0F },
56 { 17, 0x0000 },
57 { 18, 0xCBCB },
58 { 19, 0x0000 },
59 { 20, 0x7F7F },
60 { 21, 0x0000 },
61 { 22, 0x0000 },
62 { 23, 0x0000 },
63 { 24, 0xE010 },
64 { 25, 0x0000 },
65 { 26, 0x0000 },
66 { 27, 0x0000 },
67 { 28, 0x8008 },
68 { 29, 0x0000 },
69 { 30, 0x0000 },
70 { 31, 0x0000 },
71 { 32, 0x0000 },
72 { 33, 0x0000 },
73 { 34, 0x0000 },
74 { 35, 0x0000 },
75 { 36, 0x00C0 },
76 { 37, 0x0000 },
77 { 38, 0xEF00 },
78 { 39, 0x0000 },
79 { 40, 0x0000 },
80 { 41, 0x0000 },
81 { 42, 0x0000 },
82 { 43, 0x0000 },
83 { 44, 0x0000 },
84 { 45, 0x0000 },
85 { 46, 0x0000 },
86 { 47, 0x0000 },
87 { 48, 0x0000 },
88 { 49, 0x0000 },
89 { 50, 0x0000 },
90 { 51, 0x0000 },
91 { 52, 0x8000 },
92 { 53, 0x0000 },
93 { 54, 0x0000 },
94 { 55, 0x0000 },
95 { 56, 0x0000 },
96 { 57, 0x0000 },
97 { 58, 0x0000 },
98 { 59, 0x0000 },
99 { 60, 0x0000 },
100 { 61, 0x0000 },
101 { 62, 0x8000 },
102 { 63, 0x0000 },
103 { 64, 0x0C0A },
104 { 65, 0x0000 },
105 { 66, 0x0000 },
106 { 67, 0x0000 },
107 { 68, 0x0000 },
108 { 69, 0x0000 },
109 { 70, 0x0000 },
110 { 71, 0x0000 },
111 { 72, 0x0000 },
112 { 73, 0x0000 },
113 { 74, 0x0000 },
114 { 75, 0x0000 },
115 { 76, 0xBE3E },
116 { 77, 0x0000 },
117 { 78, 0xBE3E },
118 { 79, 0x0000 },
119 { 80, 0x0000 },
120 { 81, 0x0000 },
121 { 82, 0x0000 },
122 { 83, 0x0000 },
123 { 84, 0x803A },
124 { 85, 0x0000 },
125 { 86, 0x0000 },
126 { 87, 0x0000 },
127 { 88, 0x0000 },
128 { 89, 0x0000 },
129 { 90, 0x0009 },
130 { 91, 0x0000 },
131 { 92, 0x0000 },
132 { 93, 0x0000 },
133 { 94, 0x3000 },
134 { 95, 0x0000 },
135 { 96, 0x3075 },
136 { 97, 0x0000 },
137 { 98, 0x1010 },
138 { 99, 0x0000 },
139 { 100, 0x3110 },
140 { 101, 0x0000 },
141 { 102, 0x0000 },
142 { 103, 0x0000 },
143 { 104, 0x0553 },
144 { 105, 0x0000 },
145 { 106, 0x0000 },
146 { 107, 0x0000 },
147 { 108, 0x0000 },
148 { 109, 0x0000 },
149 { 110, 0x0000 },
150 { 111, 0x0000 },
94d5f7c0
LR		 151};
152
153/* codec private data */
154struct alc5632_priv {
bb39753c 155 struct regmap *regmap;
94d5f7c0
LR		 156 u8 id;
157 unsigned int sysclk;
158};
159
bb39753c 160static bool alc5632_volatile_register(struct device *dev,
94d5f7c0
LR		 161 unsigned int reg)
162{
163 switch (reg) {
164 case ALC5632_RESET:
165 case ALC5632_PWR_DOWN_CTRL_STATUS:
166 case ALC5632_GPIO_PIN_STATUS:
167 case ALC5632_OVER_CURR_STATUS:
168 case ALC5632_HID_CTRL_DATA:
169 case ALC5632_EQ_CTRL:
bb39753c 170 return true;
94d5f7c0
LR		 171
172 default:
173 break;
174 }
175
bb39753c 176 return false;
94d5f7c0
LR		 177}
178
bb39753c 179static inline int alc5632_reset(struct regmap *map)
94d5f7c0 180{
bb39753c 181 return regmap_write(map, ALC5632_RESET, 0x59B4);
94d5f7c0
LR		 182}
183
184static int amp_mixer_event(struct snd_soc_dapm_widget *w,
185 struct snd_kcontrol *kcontrol, int event)
186{
187 /* to power-on/off class-d amp generators/speaker */
188 /* need to write to 'index-46h' register : */
189 /* so write index num (here 0x46) to reg 0x6a */
190 /* and then 0xffff/0 to reg 0x6c */
191 snd_soc_write(w->codec, ALC5632_HID_CTRL_INDEX, 0x46);
192
193 switch (event) {
194 case SND_SOC_DAPM_PRE_PMU:
195 snd_soc_write(w->codec, ALC5632_HID_CTRL_DATA, 0xFFFF);
196 break;
197 case SND_SOC_DAPM_POST_PMD:
198 snd_soc_write(w->codec, ALC5632_HID_CTRL_DATA, 0);
199 break;
200 }
201
202 return 0;
203}
204
205/*
206 * ALC5632 Controls
207 */
208
209/* -34.5db min scale, 1.5db steps, no mute */
210static const DECLARE_TLV_DB_SCALE(vol_tlv, -3450, 150, 0);
211/* -46.5db min scale, 1.5db steps, no mute */
212static const DECLARE_TLV_DB_SCALE(hp_tlv, -4650, 150, 0);
213/* -16.5db min scale, 1.5db steps, no mute */
214static const DECLARE_TLV_DB_SCALE(adc_rec_tlv, -1650, 150, 0);
215static const unsigned int boost_tlv[] = {
216 TLV_DB_RANGE_HEAD(3),
217 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
218 1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
219 2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0),
220};
221/* 0db min scale, 6 db steps, no mute */
222static const DECLARE_TLV_DB_SCALE(dig_tlv, 0, 600, 0);
223/* 0db min scalem 0.75db steps, no mute */
224static const DECLARE_TLV_DB_SCALE(vdac_tlv, -3525, 075, 0);
225
226static const struct snd_kcontrol_new alc5632_vol_snd_controls[] = {
227 /* left starts at bit 8, right at bit 0 */
228 /* 31 steps (5 bit), -46.5db scale */
229 SOC_DOUBLE_TLV("Line Playback Volume",
230 ALC5632_SPK_OUT_VOL, 8, 0, 31, 1, hp_tlv),
231 /* bit 15 mutes left, bit 7 right */
232 SOC_DOUBLE("Line Playback Switch",
233 ALC5632_SPK_OUT_VOL, 15, 7, 1, 1),
234 SOC_DOUBLE_TLV("Headphone Playback Volume",
235 ALC5632_HP_OUT_VOL, 8, 0, 31, 1, hp_tlv),
236 SOC_DOUBLE("Headphone Playback Switch",
237 ALC5632_HP_OUT_VOL, 15, 7, 1, 1),
238};
239
240static const struct snd_kcontrol_new alc5632_snd_controls[] = {
241 SOC_DOUBLE_TLV("Auxout Playback Volume",
242 ALC5632_AUX_OUT_VOL, 8, 0, 31, 1, hp_tlv),
243 SOC_DOUBLE("Auxout Playback Switch",
244 ALC5632_AUX_OUT_VOL, 15, 7, 1, 1),
245 SOC_SINGLE_TLV("Voice DAC Playback Volume",
246 ALC5632_VOICE_DAC_VOL, 0, 63, 0, vdac_tlv),
247 SOC_SINGLE_TLV("Phone Capture Volume",
248 ALC5632_PHONE_IN_VOL, 8, 31, 1, vol_tlv),
249 SOC_DOUBLE_TLV("LineIn Capture Volume",
250 ALC5632_LINE_IN_VOL, 8, 0, 31, 1, vol_tlv),
251 SOC_DOUBLE_TLV("Stereo DAC Playback Volume",
252 ALC5632_STEREO_DAC_IN_VOL, 8, 0, 63, 1, vdac_tlv),
253 SOC_DOUBLE("Stereo DAC Playback Switch",
254 ALC5632_STEREO_DAC_IN_VOL, 15, 7, 1, 1),
255 SOC_SINGLE_TLV("Mic1 Capture Volume",
256 ALC5632_MIC_VOL, 8, 31, 1, vol_tlv),
257 SOC_SINGLE_TLV("Mic2 Capture Volume",
258 ALC5632_MIC_VOL, 0, 31, 1, vol_tlv),
259 SOC_DOUBLE_TLV("Rec Capture Volume",
260 ALC5632_ADC_REC_GAIN, 8, 0, 31, 0, adc_rec_tlv),
261 SOC_SINGLE_TLV("Mic 1 Boost Volume",
262 ALC5632_MIC_CTRL, 10, 2, 0, boost_tlv),
263 SOC_SINGLE_TLV("Mic 2 Boost Volume",
264 ALC5632_MIC_CTRL, 8, 2, 0, boost_tlv),
265 SOC_SINGLE_TLV("Digital Boost Volume",
266 ALC5632_DIGI_BOOST_CTRL, 0, 7, 0, dig_tlv),
267};
268
269/*
270 * DAPM Controls
271 */
272static const struct snd_kcontrol_new alc5632_hp_mixer_controls[] = {
273SOC_DAPM_SINGLE("LI2HP Playback Switch", ALC5632_LINE_IN_VOL, 15, 1, 1),
274SOC_DAPM_SINGLE("PHONE2HP Playback Switch", ALC5632_PHONE_IN_VOL, 15, 1, 1),
275SOC_DAPM_SINGLE("MIC12HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 15, 1, 1),
276SOC_DAPM_SINGLE("MIC22HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 11, 1, 1),
277SOC_DAPM_SINGLE("VOICE2HP Playback Switch", ALC5632_VOICE_DAC_VOL, 15, 1, 1),
278};
279
280static const struct snd_kcontrol_new alc5632_hpl_mixer_controls[] = {
281SOC_DAPM_SINGLE("ADC2HP_L Playback Switch", ALC5632_ADC_REC_GAIN, 15, 1, 1),
282SOC_DAPM_SINGLE("DACL2HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 3, 1, 1),
283};
284
285static const struct snd_kcontrol_new alc5632_hpr_mixer_controls[] = {
286SOC_DAPM_SINGLE("ADC2HP_R Playback Switch", ALC5632_ADC_REC_GAIN, 7, 1, 1),
287SOC_DAPM_SINGLE("DACR2HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 2, 1, 1),
288};
289
290static const struct snd_kcontrol_new alc5632_mono_mixer_controls[] = {
291SOC_DAPM_SINGLE("ADC2MONO_L Playback Switch", ALC5632_ADC_REC_GAIN, 14, 1, 1),
292SOC_DAPM_SINGLE("ADC2MONO_R Playback Switch", ALC5632_ADC_REC_GAIN, 6, 1, 1),
293SOC_DAPM_SINGLE("LI2MONO Playback Switch", ALC5632_LINE_IN_VOL, 13, 1, 1),
294SOC_DAPM_SINGLE("MIC12MONO Playback Switch",
295 ALC5632_MIC_ROUTING_CTRL, 13, 1, 1),
296SOC_DAPM_SINGLE("MIC22MONO Playback Switch",
297 ALC5632_MIC_ROUTING_CTRL, 9, 1, 1),
298SOC_DAPM_SINGLE("DAC2MONO Playback Switch", ALC5632_MIC_ROUTING_CTRL, 0, 1, 1),
299SOC_DAPM_SINGLE("VOICE2MONO Playback Switch", ALC5632_VOICE_DAC_VOL, 13, 1, 1),
300};
301
302static const struct snd_kcontrol_new alc5632_speaker_mixer_controls[] = {
303SOC_DAPM_SINGLE("LI2SPK Playback Switch", ALC5632_LINE_IN_VOL, 14, 1, 1),
304SOC_DAPM_SINGLE("PHONE2SPK Playback Switch", ALC5632_PHONE_IN_VOL, 14, 1, 1),
305SOC_DAPM_SINGLE("MIC12SPK Playback Switch",
306 ALC5632_MIC_ROUTING_CTRL, 14, 1, 1),
307SOC_DAPM_SINGLE("MIC22SPK Playback Switch",
308 ALC5632_MIC_ROUTING_CTRL, 10, 1, 1),
309SOC_DAPM_SINGLE("DAC2SPK Playback Switch", ALC5632_MIC_ROUTING_CTRL, 1, 1, 1),
310SOC_DAPM_SINGLE("VOICE2SPK Playback Switch", ALC5632_VOICE_DAC_VOL, 14, 1, 1),
311};
312
313/* Left Record Mixer */
314static const struct snd_kcontrol_new alc5632_captureL_mixer_controls[] = {
315SOC_DAPM_SINGLE("Mic1 Capture Switch", ALC5632_ADC_REC_MIXER, 14, 1, 1),
316SOC_DAPM_SINGLE("Mic2 Capture Switch", ALC5632_ADC_REC_MIXER, 13, 1, 1),
317SOC_DAPM_SINGLE("LineInL Capture Switch", ALC5632_ADC_REC_MIXER, 12, 1, 1),
318SOC_DAPM_SINGLE("Left Phone Capture Switch", ALC5632_ADC_REC_MIXER, 11, 1, 1),
319SOC_DAPM_SINGLE("HPMixerL Capture Switch", ALC5632_ADC_REC_MIXER, 10, 1, 1),
320SOC_DAPM_SINGLE("SPKMixer Capture Switch", ALC5632_ADC_REC_MIXER, 9, 1, 1),
321SOC_DAPM_SINGLE("MonoMixer Capture Switch", ALC5632_ADC_REC_MIXER, 8, 1, 1),
322};
323
324/* Right Record Mixer */
325static const struct snd_kcontrol_new alc5632_captureR_mixer_controls[] = {
326SOC_DAPM_SINGLE("Mic1 Capture Switch", ALC5632_ADC_REC_MIXER, 6, 1, 1),
327SOC_DAPM_SINGLE("Mic2 Capture Switch", ALC5632_ADC_REC_MIXER, 5, 1, 1),
328SOC_DAPM_SINGLE("LineInR Capture Switch", ALC5632_ADC_REC_MIXER, 4, 1, 1),
329SOC_DAPM_SINGLE("Right Phone Capture Switch", ALC5632_ADC_REC_MIXER, 3, 1, 1),
330SOC_DAPM_SINGLE("HPMixerR Capture Switch", ALC5632_ADC_REC_MIXER, 2, 1, 1),
331SOC_DAPM_SINGLE("SPKMixer Capture Switch", ALC5632_ADC_REC_MIXER, 1, 1, 1),
332SOC_DAPM_SINGLE("MonoMixer Capture Switch", ALC5632_ADC_REC_MIXER, 0, 1, 1),
333};
334
335static const char *alc5632_spk_n_sour_sel[] = {
336 "RN/-R", "RP/+R", "LN/-R", "Mute"};
337static const char *alc5632_hpl_out_input_sel[] = {
338 "Vmid", "HP Left Mix"};
339static const char *alc5632_hpr_out_input_sel[] = {
340 "Vmid", "HP Right Mix"};
341static const char *alc5632_spkout_input_sel[] = {
342 "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"};
343static const char *alc5632_aux_out_input_sel[] = {
344 "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"};
345
346/* auxout output mux */
347static const struct soc_enum alc5632_aux_out_input_enum =
348SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 6, 4, alc5632_aux_out_input_sel);
349static const struct snd_kcontrol_new alc5632_auxout_mux_controls =
350SOC_DAPM_ENUM("AuxOut Mux", alc5632_aux_out_input_enum);
351
352/* speaker output mux */
353static const struct soc_enum alc5632_spkout_input_enum =
354SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 10, 4, alc5632_spkout_input_sel);
355static const struct snd_kcontrol_new alc5632_spkout_mux_controls =
356SOC_DAPM_ENUM("SpeakerOut Mux", alc5632_spkout_input_enum);
357
358/* headphone left output mux */
359static const struct soc_enum alc5632_hpl_out_input_enum =
360SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 9, 2, alc5632_hpl_out_input_sel);
361static const struct snd_kcontrol_new alc5632_hpl_out_mux_controls =
362SOC_DAPM_ENUM("Left Headphone Mux", alc5632_hpl_out_input_enum);
363
364/* headphone right output mux */
365static const struct soc_enum alc5632_hpr_out_input_enum =
366SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 8, 2, alc5632_hpr_out_input_sel);
367static const struct snd_kcontrol_new alc5632_hpr_out_mux_controls =
368SOC_DAPM_ENUM("Right Headphone Mux", alc5632_hpr_out_input_enum);
369
370/* speaker output N select */
371static const struct soc_enum alc5632_spk_n_sour_enum =
372SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 14, 4, alc5632_spk_n_sour_sel);
373static const struct snd_kcontrol_new alc5632_spkoutn_mux_controls =
374SOC_DAPM_ENUM("SpeakerOut N Mux", alc5632_spk_n_sour_enum);
375
376/* speaker amplifier */
377static const char *alc5632_amp_names[] = {"AB Amp", "D Amp"};
378static const struct soc_enum alc5632_amp_enum =
379 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 13, 2, alc5632_amp_names);
380static const struct snd_kcontrol_new alc5632_amp_mux_controls =
381 SOC_DAPM_ENUM("AB-D Amp Mux", alc5632_amp_enum);
382
383
384static const struct snd_soc_dapm_widget alc5632_dapm_widgets[] = {
385/* Muxes */
386SND_SOC_DAPM_MUX("AuxOut Mux", SND_SOC_NOPM, 0, 0,
387 &alc5632_auxout_mux_controls),
388SND_SOC_DAPM_MUX("SpeakerOut Mux", SND_SOC_NOPM, 0, 0,
389 &alc5632_spkout_mux_controls),
390SND_SOC_DAPM_MUX("Left Headphone Mux", SND_SOC_NOPM, 0, 0,
391 &alc5632_hpl_out_mux_controls),
392SND_SOC_DAPM_MUX("Right Headphone Mux", SND_SOC_NOPM, 0, 0,
393 &alc5632_hpr_out_mux_controls),
394SND_SOC_DAPM_MUX("SpeakerOut N Mux", SND_SOC_NOPM, 0, 0,
395 &alc5632_spkoutn_mux_controls),
396
397/* output mixers */
398SND_SOC_DAPM_MIXER("HP Mix", SND_SOC_NOPM, 0, 0,
399 &alc5632_hp_mixer_controls[0],
400 ARRAY_SIZE(alc5632_hp_mixer_controls)),
401SND_SOC_DAPM_MIXER("HPR Mix", ALC5632_PWR_MANAG_ADD2, 4, 0,
402 &alc5632_hpr_mixer_controls[0],
403 ARRAY_SIZE(alc5632_hpr_mixer_controls)),
404SND_SOC_DAPM_MIXER("HPL Mix", ALC5632_PWR_MANAG_ADD2, 5, 0,
405 &alc5632_hpl_mixer_controls[0],
406 ARRAY_SIZE(alc5632_hpl_mixer_controls)),
407SND_SOC_DAPM_MIXER("HPOut Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
408SND_SOC_DAPM_MIXER("Mono Mix", ALC5632_PWR_MANAG_ADD2, 2, 0,
409 &alc5632_mono_mixer_controls[0],
410 ARRAY_SIZE(alc5632_mono_mixer_controls)),
411SND_SOC_DAPM_MIXER("Speaker Mix", ALC5632_PWR_MANAG_ADD2, 3, 0,
412 &alc5632_speaker_mixer_controls[0],
413 ARRAY_SIZE(alc5632_speaker_mixer_controls)),
414
415/* input mixers */
416SND_SOC_DAPM_MIXER("Left Capture Mix", ALC5632_PWR_MANAG_ADD2, 1, 0,
417 &alc5632_captureL_mixer_controls[0],
418 ARRAY_SIZE(alc5632_captureL_mixer_controls)),
419SND_SOC_DAPM_MIXER("Right Capture Mix", ALC5632_PWR_MANAG_ADD2, 0, 0,
420 &alc5632_captureR_mixer_controls[0],
421 ARRAY_SIZE(alc5632_captureR_mixer_controls)),
422
423SND_SOC_DAPM_DAC("Left DAC", "HiFi Playback",
424 ALC5632_PWR_MANAG_ADD2, 9, 0),
425SND_SOC_DAPM_DAC("Right DAC", "HiFi Playback",
426 ALC5632_PWR_MANAG_ADD2, 8, 0),
427SND_SOC_DAPM_MIXER("DAC Left Channel", ALC5632_PWR_MANAG_ADD1, 15, 0, NULL, 0),
428SND_SOC_DAPM_MIXER("DAC Right Channel",
429 ALC5632_PWR_MANAG_ADD1, 14, 0, NULL, 0),
430SND_SOC_DAPM_MIXER("I2S Mix", ALC5632_PWR_MANAG_ADD1, 11, 0, NULL, 0),
431SND_SOC_DAPM_MIXER("Phone Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
432SND_SOC_DAPM_MIXER("Line Mix", SND_SOC_NOPM, 0, 0, NULL, 0),
433SND_SOC_DAPM_ADC("Left ADC", "HiFi Capture",
434 ALC5632_PWR_MANAG_ADD2, 7, 0),
435SND_SOC_DAPM_ADC("Right ADC", "HiFi Capture",
436 ALC5632_PWR_MANAG_ADD2, 6, 0),
437SND_SOC_DAPM_PGA("Left Headphone", ALC5632_PWR_MANAG_ADD3, 11, 0, NULL, 0),
438SND_SOC_DAPM_PGA("Right Headphone", ALC5632_PWR_MANAG_ADD3, 10, 0, NULL, 0),
439SND_SOC_DAPM_PGA("Left Speaker", ALC5632_PWR_MANAG_ADD3, 13, 0, NULL, 0),
440SND_SOC_DAPM_PGA("Right Speaker", ALC5632_PWR_MANAG_ADD3, 12, 0, NULL, 0),
441SND_SOC_DAPM_PGA("Aux Out", ALC5632_PWR_MANAG_ADD3, 14, 0, NULL, 0),
442SND_SOC_DAPM_PGA("Left LineIn", ALC5632_PWR_MANAG_ADD3, 7, 0, NULL, 0),
443SND_SOC_DAPM_PGA("Right LineIn", ALC5632_PWR_MANAG_ADD3, 6, 0, NULL, 0),
444SND_SOC_DAPM_PGA("Phone", ALC5632_PWR_MANAG_ADD3, 5, 0, NULL, 0),
445SND_SOC_DAPM_PGA("Phone ADMix", ALC5632_PWR_MANAG_ADD3, 4, 0, NULL, 0),
446SND_SOC_DAPM_PGA("MIC1 PGA", ALC5632_PWR_MANAG_ADD3, 3, 0, NULL, 0),
447SND_SOC_DAPM_PGA("MIC2 PGA", ALC5632_PWR_MANAG_ADD3, 2, 0, NULL, 0),
448SND_SOC_DAPM_PGA("MIC1 Pre Amp", ALC5632_PWR_MANAG_ADD3, 1, 0, NULL, 0),
449SND_SOC_DAPM_PGA("MIC2 Pre Amp", ALC5632_PWR_MANAG_ADD3, 0, 0, NULL, 0),
450SND_SOC_DAPM_SUPPLY("Mic Bias1", ALC5632_PWR_MANAG_ADD1, 3, 0, NULL, 0),
451SND_SOC_DAPM_SUPPLY("Mic Bias2", ALC5632_PWR_MANAG_ADD1, 2, 0, NULL, 0),
452
453SND_SOC_DAPM_PGA_E("D Amp", ALC5632_PWR_MANAG_ADD2, 14, 0, NULL, 0,
454 amp_mixer_event, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
455SND_SOC_DAPM_PGA("AB Amp", ALC5632_PWR_MANAG_ADD2, 15, 0, NULL, 0),
456SND_SOC_DAPM_MUX("AB-D Amp Mux", ALC5632_PWR_MANAG_ADD1, 10, 0,
457 &alc5632_amp_mux_controls),
458
459SND_SOC_DAPM_OUTPUT("AUXOUT"),
460SND_SOC_DAPM_OUTPUT("HPL"),
461SND_SOC_DAPM_OUTPUT("HPR"),
462SND_SOC_DAPM_OUTPUT("SPKOUT"),
463SND_SOC_DAPM_OUTPUT("SPKOUTN"),
464SND_SOC_DAPM_INPUT("LINEINL"),
465SND_SOC_DAPM_INPUT("LINEINR"),
466SND_SOC_DAPM_INPUT("PHONEP"),
467SND_SOC_DAPM_INPUT("PHONEN"),
468SND_SOC_DAPM_INPUT("MIC1"),
469SND_SOC_DAPM_INPUT("MIC2"),
470SND_SOC_DAPM_VMID("Vmid"),
471};
472
473
474static const struct snd_soc_dapm_route alc5632_dapm_routes[] = {
475 /* virtual mixer - mixes left & right channels */
476 {"I2S Mix", NULL, "Left DAC"},
477 {"I2S Mix", NULL, "Right DAC"},
478 {"Line Mix", NULL, "Right LineIn"},
479 {"Line Mix", NULL, "Left LineIn"},
480 {"Phone Mix", NULL, "Phone"},
481 {"Phone Mix", NULL, "Phone ADMix"},
482 {"AUXOUT", NULL, "Aux Out"},
483
484 /* DAC */
485 {"DAC Right Channel", NULL, "I2S Mix"},
486 {"DAC Left Channel", NULL, "I2S Mix"},
487
488 /* HP mixer */
489 {"HPL Mix", "ADC2HP_L Playback Switch", "Left Capture Mix"},
490 {"HPL Mix", NULL, "HP Mix"},
491 {"HPR Mix", "ADC2HP_R Playback Switch", "Right Capture Mix"},
492 {"HPR Mix", NULL, "HP Mix"},
493 {"HP Mix", "LI2HP Playback Switch", "Line Mix"},
494 {"HP Mix", "PHONE2HP Playback Switch", "Phone Mix"},
495 {"HP Mix", "MIC12HP Playback Switch", "MIC1 PGA"},
496 {"HP Mix", "MIC22HP Playback Switch", "MIC2 PGA"},
497
498 {"HPR Mix", "DACR2HP Playback Switch", "DAC Right Channel"},
499 {"HPL Mix", "DACL2HP Playback Switch", "DAC Left Channel"},
500
501 /* speaker mixer */
502 {"Speaker Mix", "LI2SPK Playback Switch", "Line Mix"},
503 {"Speaker Mix", "PHONE2SPK Playback Switch", "Phone Mix"},
504 {"Speaker Mix", "MIC12SPK Playback Switch", "MIC1 PGA"},
505 {"Speaker Mix", "MIC22SPK Playback Switch", "MIC2 PGA"},
506 {"Speaker Mix", "DAC2SPK Playback Switch", "DAC Left Channel"},
507
508
509
510 /* mono mixer */
511 {"Mono Mix", "ADC2MONO_L Playback Switch", "Left Capture Mix"},
512 {"Mono Mix", "ADC2MONO_R Playback Switch", "Right Capture Mix"},
513 {"Mono Mix", "LI2MONO Playback Switch", "Line Mix"},
514 {"Mono Mix", "VOICE2MONO Playback Switch", "Phone Mix"},
515 {"Mono Mix", "MIC12MONO Playback Switch", "MIC1 PGA"},
516 {"Mono Mix", "MIC22MONO Playback Switch", "MIC2 PGA"},
517 {"Mono Mix", "DAC2MONO Playback Switch", "DAC Left Channel"},
518
519 /* Left record mixer */
520 {"Left Capture Mix", "LineInL Capture Switch", "LINEINL"},
521 {"Left Capture Mix", "Left Phone Capture Switch", "PHONEN"},
522 {"Left Capture Mix", "Mic1 Capture Switch", "MIC1 Pre Amp"},
523 {"Left Capture Mix", "Mic2 Capture Switch", "MIC2 Pre Amp"},
524 {"Left Capture Mix", "HPMixerL Capture Switch", "HPL Mix"},
525 {"Left Capture Mix", "SPKMixer Capture Switch", "Speaker Mix"},
526 {"Left Capture Mix", "MonoMixer Capture Switch", "Mono Mix"},
527
528 /*Right record mixer */
529 {"Right Capture Mix", "LineInR Capture Switch", "LINEINR"},
530 {"Right Capture Mix", "Right Phone Capture Switch", "PHONEP"},
531 {"Right Capture Mix", "Mic1 Capture Switch", "MIC1 Pre Amp"},
532 {"Right Capture Mix", "Mic2 Capture Switch", "MIC2 Pre Amp"},
533 {"Right Capture Mix", "HPMixerR Capture Switch", "HPR Mix"},
534 {"Right Capture Mix", "SPKMixer Capture Switch", "Speaker Mix"},
535 {"Right Capture Mix", "MonoMixer Capture Switch", "Mono Mix"},
536
537 /* headphone left mux */
538 {"Left Headphone Mux", "HP Left Mix", "HPL Mix"},
539 {"Left Headphone Mux", "Vmid", "Vmid"},
540
541 /* headphone right mux */
542 {"Right Headphone Mux", "HP Right Mix", "HPR Mix"},
543 {"Right Headphone Mux", "Vmid", "Vmid"},
544
545 /* speaker out mux */
546 {"SpeakerOut Mux", "Vmid", "Vmid"},
547 {"SpeakerOut Mux", "HPOut Mix", "HPOut Mix"},
548 {"SpeakerOut Mux", "Speaker Mix", "Speaker Mix"},
549 {"SpeakerOut Mux", "Mono Mix", "Mono Mix"},
550
551 /* Mono/Aux Out mux */
552 {"AuxOut Mux", "Vmid", "Vmid"},
553 {"AuxOut Mux", "HPOut Mix", "HPOut Mix"},
554 {"AuxOut Mux", "Speaker Mix", "Speaker Mix"},
555 {"AuxOut Mux", "Mono Mix", "Mono Mix"},
556
557 /* output pga */
558 {"HPL", NULL, "Left Headphone"},
559 {"Left Headphone", NULL, "Left Headphone Mux"},
560 {"HPR", NULL, "Right Headphone"},
561 {"Right Headphone", NULL, "Right Headphone Mux"},
562 {"Aux Out", NULL, "AuxOut Mux"},
563
564 /* input pga */
565 {"Left LineIn", NULL, "LINEINL"},
566 {"Right LineIn", NULL, "LINEINR"},
567 {"Phone", NULL, "PHONEP"},
568 {"MIC1 Pre Amp", NULL, "MIC1"},
569 {"MIC2 Pre Amp", NULL, "MIC2"},
570 {"MIC1 PGA", NULL, "MIC1 Pre Amp"},
571 {"MIC2 PGA", NULL, "MIC2 Pre Amp"},
572
573 /* left ADC */
574 {"Left ADC", NULL, "Left Capture Mix"},
575
576 /* right ADC */
577 {"Right ADC", NULL, "Right Capture Mix"},
578
579 {"SpeakerOut N Mux", "RN/-R", "Left Speaker"},
580 {"SpeakerOut N Mux", "RP/+R", "Left Speaker"},
581 {"SpeakerOut N Mux", "LN/-R", "Left Speaker"},
582 {"SpeakerOut N Mux", "Mute", "Vmid"},
583
584 {"SpeakerOut N Mux", "RN/-R", "Right Speaker"},
585 {"SpeakerOut N Mux", "RP/+R", "Right Speaker"},
586 {"SpeakerOut N Mux", "LN/-R", "Right Speaker"},
587 {"SpeakerOut N Mux", "Mute", "Vmid"},
588
589 {"AB Amp", NULL, "SpeakerOut Mux"},
590 {"D Amp", NULL, "SpeakerOut Mux"},
591 {"AB-D Amp Mux", "AB Amp", "AB Amp"},
592 {"AB-D Amp Mux", "D Amp", "D Amp"},
593 {"Left Speaker", NULL, "AB-D Amp Mux"},
594 {"Right Speaker", NULL, "AB-D Amp Mux"},
595
596 {"SPKOUT", NULL, "Left Speaker"},
597 {"SPKOUT", NULL, "Right Speaker"},
598
599 {"SPKOUTN", NULL, "SpeakerOut N Mux"},
600
601};
602
603/* PLL divisors */
604struct _pll_div {
605 u32 pll_in;
606 u32 pll_out;
607 u16 regvalue;
608};
609
610/* Note : pll code from original alc5632 driver. Not sure of how good it is */
611/* usefull only for master mode */
612static const struct _pll_div codec_master_pll_div[] = {
613
614 { 2048000, 8192000, 0x0ea0},
615 { 3686400, 8192000, 0x4e27},
616 { 12000000, 8192000, 0x456b},
617 { 13000000, 8192000, 0x495f},
618 { 13100000, 8192000, 0x0320},
619 { 2048000, 11289600, 0xf637},
620 { 3686400, 11289600, 0x2f22},
621 { 12000000, 11289600, 0x3e2f},
622 { 13000000, 11289600, 0x4d5b},
623 { 13100000, 11289600, 0x363b},
624 { 2048000, 16384000, 0x1ea0},
625 { 3686400, 16384000, 0x9e27},
626 { 12000000, 16384000, 0x452b},
627 { 13000000, 16384000, 0x542f},
628 { 13100000, 16384000, 0x03a0},
629 { 2048000, 16934400, 0xe625},
630 { 3686400, 16934400, 0x9126},
631 { 12000000, 16934400, 0x4d2c},
632 { 13000000, 16934400, 0x742f},
633 { 13100000, 16934400, 0x3c27},
634 { 2048000, 22579200, 0x2aa0},
635 { 3686400, 22579200, 0x2f20},
636 { 12000000, 22579200, 0x7e2f},
637 { 13000000, 22579200, 0x742f},
638 { 13100000, 22579200, 0x3c27},
639 { 2048000, 24576000, 0x2ea0},
640 { 3686400, 24576000, 0xee27},
641 { 12000000, 24576000, 0x2915},
642 { 13000000, 24576000, 0x772e},
643 { 13100000, 24576000, 0x0d20},
644};
645
646/* FOUT = MCLK*(N+2)/((M+2)*(K+2))
647 N: bit 15:8 (div 2 .. div 257)
648 K: bit 6:4 typical 2
649 M: bit 3:0 (div 2 .. div 17)
650
651 same as for 5623 - thanks!
652*/
653
654static const struct _pll_div codec_slave_pll_div[] = {
655
656 { 1024000, 16384000, 0x3ea0},
657 { 1411200, 22579200, 0x3ea0},
658 { 1536000, 24576000, 0x3ea0},
659 { 2048000, 16384000, 0x1ea0},
660 { 2822400, 22579200, 0x1ea0},
661 { 3072000, 24576000, 0x1ea0},
662
663};
664
665static int alc5632_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
666 int source, unsigned int freq_in, unsigned int freq_out)
667{
668 int i;
669 struct snd_soc_codec *codec = codec_dai->codec;
670 int gbl_clk = 0, pll_div = 0;
671 u16 reg;
672
673 if (pll_id < ALC5632_PLL_FR_MCLK || pll_id > ALC5632_PLL_FR_VBCLK)
674 return -EINVAL;
675
676 /* Disable PLL power */
677 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
678 ALC5632_PWR_ADD2_PLL1,
679 0);
680 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
681 ALC5632_PWR_ADD2_PLL2,
682 0);
683
684 /* pll is not used in slave mode */
685 reg = snd_soc_read(codec, ALC5632_DAI_CONTROL);
686 if (reg & ALC5632_DAI_SDP_SLAVE_MODE)
687 return 0;
688
689 if (!freq_in || !freq_out)
690 return 0;
691
692 switch (pll_id) {
693 case ALC5632_PLL_FR_MCLK:
694 for (i = 0; i < ARRAY_SIZE(codec_master_pll_div); i++) {
695 if (codec_master_pll_div[i].pll_in == freq_in
696 && codec_master_pll_div[i].pll_out == freq_out) {
697 /* PLL source from MCLK */
698 pll_div = codec_master_pll_div[i].regvalue;
699 break;
700 }
701 }
702 break;
703 case ALC5632_PLL_FR_BCLK:
704 for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) {
705 if (codec_slave_pll_div[i].pll_in == freq_in
706 && codec_slave_pll_div[i].pll_out == freq_out) {
707 /* PLL source from Bitclk */
708 gbl_clk = ALC5632_PLL_FR_BCLK;
709 pll_div = codec_slave_pll_div[i].regvalue;
710 break;
711 }
712 }
713 break;
714 case ALC5632_PLL_FR_VBCLK:
715 for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) {
716 if (codec_slave_pll_div[i].pll_in == freq_in
717 && codec_slave_pll_div[i].pll_out == freq_out) {
718 /* PLL source from voice clock */
719 gbl_clk = ALC5632_PLL_FR_VBCLK;
720 pll_div = codec_slave_pll_div[i].regvalue;
721 break;
722 }
723 }
724 break;
725 default:
726 return -EINVAL;
727 }
728
729 if (!pll_div)
730 return -EINVAL;
731
732 /* choose MCLK/BCLK/VBCLK */
733 snd_soc_write(codec, ALC5632_GPCR2, gbl_clk);
734 /* choose PLL1 clock rate */
735 snd_soc_write(codec, ALC5632_PLL1_CTRL, pll_div);
736 /* enable PLL1 */
737 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
738 ALC5632_PWR_ADD2_PLL1,
739 ALC5632_PWR_ADD2_PLL1);
740 /* enable PLL2 */
741 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
742 ALC5632_PWR_ADD2_PLL2,
743 ALC5632_PWR_ADD2_PLL2);
744 /* use PLL1 as main SYSCLK */
745 snd_soc_update_bits(codec, ALC5632_GPCR1,
746 ALC5632_GPCR1_CLK_SYS_SRC_SEL_PLL1,
747 ALC5632_GPCR1_CLK_SYS_SRC_SEL_PLL1);
748
749 return 0;
750}
751
752struct _coeff_div {
753 u16 fs;
754 u16 regvalue;
755};
756
757/* codec hifi mclk (after PLL) clock divider coefficients */
758/* values inspired from column BCLK=32Fs of Appendix A table */
759static const struct _coeff_div coeff_div[] = {
760 {512*1, 0x3075},
761};
762
763static int get_coeff(struct snd_soc_codec *codec, int rate)
764{
765 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec);
766 int i;
767
768 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
769 if (coeff_div[i].fs * rate == alc5632->sysclk)
770 return i;
771 }
772 return -EINVAL;
773}
774
775/*
776 * Clock after PLL and dividers
777 */
778static int alc5632_set_dai_sysclk(struct snd_soc_dai *codec_dai,
779 int clk_id, unsigned int freq, int dir)
780{
781 struct snd_soc_codec *codec = codec_dai->codec;
782 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec);
783
784 switch (freq) {
785 case 8192000:
786 case 11289600:
787 case 12288000:
788 case 16384000:
789 case 16934400:
790 case 18432000:
791 case 22579200:
792 case 24576000:
793 alc5632->sysclk = freq;
794 return 0;
795 }
796 return -EINVAL;
797}
798
799static int alc5632_set_dai_fmt(struct snd_soc_dai *codec_dai,
800 unsigned int fmt)
801{
802 struct snd_soc_codec *codec = codec_dai->codec;
803 u16 iface = 0;
804
805 /* set master/slave audio interface */
806 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
807 case SND_SOC_DAIFMT_CBM_CFM:
808 iface = ALC5632_DAI_SDP_MASTER_MODE;
809 break;
810 case SND_SOC_DAIFMT_CBS_CFS:
811 iface = ALC5632_DAI_SDP_SLAVE_MODE;
812 break;
813 default:
814 return -EINVAL;
815 }
816
817 /* interface format */
818 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
819 case SND_SOC_DAIFMT_I2S:
820 iface |= ALC5632_DAI_I2S_DF_I2S;
821 break;
822 case SND_SOC_DAIFMT_LEFT_J:
823 iface |= ALC5632_DAI_I2S_DF_LEFT;
824 break;
825 case SND_SOC_DAIFMT_DSP_A:
826 iface |= ALC5632_DAI_I2S_DF_PCM_A;
827 break;
828 case SND_SOC_DAIFMT_DSP_B:
829 iface |= ALC5632_DAI_I2S_DF_PCM_B;
830 break;
831 default:
832 return -EINVAL;
833 }
834
835 /* clock inversion */
836 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
837 case SND_SOC_DAIFMT_NB_NF:
838 break;
839 case SND_SOC_DAIFMT_IB_IF:
840 iface |= ALC5632_DAI_MAIN_I2S_BCLK_POL_CTRL;
841 break;
842 case SND_SOC_DAIFMT_IB_NF:
843 iface |= ALC5632_DAI_MAIN_I2S_BCLK_POL_CTRL;
844 break;
845 case SND_SOC_DAIFMT_NB_IF:
846 break;
847 default:
848 return -EINVAL;
849 }
850
851 return snd_soc_write(codec, ALC5632_DAI_CONTROL, iface);
852}
853
854static int alc5632_pcm_hw_params(struct snd_pcm_substream *substream,
855 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
856{
857 struct snd_soc_pcm_runtime *rtd = substream->private_data;
858 struct snd_soc_codec *codec = rtd->codec;
859 int coeff, rate;
860 u16 iface;
861
862 iface = snd_soc_read(codec, ALC5632_DAI_CONTROL);
863 iface &= ~ALC5632_DAI_I2S_DL_MASK;
864
865 /* bit size */
866 switch (params_format(params)) {
867 case SNDRV_PCM_FORMAT_S16_LE:
868 iface |= ALC5632_DAI_I2S_DL_16;
869 break;
870 case SNDRV_PCM_FORMAT_S20_3LE:
871 iface |= ALC5632_DAI_I2S_DL_20;
872 break;
873 case SNDRV_PCM_FORMAT_S24_LE:
874 iface |= ALC5632_DAI_I2S_DL_24;
875 break;
876 default:
877 return -EINVAL;
878 }
879
880 /* set iface & srate */
881 snd_soc_write(codec, ALC5632_DAI_CONTROL, iface);
882 rate = params_rate(params);
883 coeff = get_coeff(codec, rate);
884 if (coeff < 0)
885 return -EINVAL;
886
887 coeff = coeff_div[coeff].regvalue;
888 snd_soc_write(codec, ALC5632_DAC_CLK_CTRL1, coeff);
889
890 return 0;
891}
892
893static int alc5632_mute(struct snd_soc_dai *dai, int mute)
894{
895 struct snd_soc_codec *codec = dai->codec;
88c494b9 896 u16 hp_mute = ALC5632_MISC_HP_DEPOP_MUTE_L
94d5f7c0
LR		 897 |ALC5632_MISC_HP_DEPOP_MUTE_R;
898 u16 mute_reg = snd_soc_read(codec, ALC5632_MISC_CTRL) & ~hp_mute;
899
900 if (mute)
901 mute_reg |= hp_mute;
902
903 return snd_soc_write(codec, ALC5632_MISC_CTRL, mute_reg);
904}
905
906#define ALC5632_ADD2_POWER_EN (ALC5632_PWR_ADD2_VREF)
907
908#define ALC5632_ADD3_POWER_EN (ALC5632_PWR_ADD3_MIC1_BOOST_AD)
909
910#define ALC5632_ADD1_POWER_EN \
911 (ALC5632_PWR_ADD1_DAC_REF \
912 | ALC5632_PWR_ADD1_SOFTGEN_EN \
913 | ALC5632_PWR_ADD1_HP_OUT_AMP \
914 | ALC5632_PWR_ADD1_HP_OUT_ENH_AMP \
915 | ALC5632_PWR_ADD1_MAIN_BIAS)
916
917static void enable_power_depop(struct snd_soc_codec *codec)
918{
919 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1,
920 ALC5632_PWR_ADD1_SOFTGEN_EN,
921 ALC5632_PWR_ADD1_SOFTGEN_EN);
922
923 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD3,
924 ALC5632_ADD3_POWER_EN,
925 ALC5632_ADD3_POWER_EN);
926
927 snd_soc_update_bits(codec, ALC5632_MISC_CTRL,
928 ALC5632_MISC_HP_DEPOP_MODE2_EN,
929 ALC5632_MISC_HP_DEPOP_MODE2_EN);
930
931 /* "normal" mode: 0 @ 26 */
932 /* set all PR0-7 mixers to 0 */
933 snd_soc_update_bits(codec, ALC5632_PWR_DOWN_CTRL_STATUS,
934 ALC5632_PWR_DOWN_CTRL_STATUS_MASK,
935 0);
936
937 msleep(500);
938
939 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
940 ALC5632_ADD2_POWER_EN,
941 ALC5632_ADD2_POWER_EN);
942
943 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1,
944 ALC5632_ADD1_POWER_EN,
945 ALC5632_ADD1_POWER_EN);
946
947 /* disable HP Depop2 */
948 snd_soc_update_bits(codec, ALC5632_MISC_CTRL,
949 ALC5632_MISC_HP_DEPOP_MODE2_EN,
950 0);
951
952}
953
954static int alc5632_set_bias_level(struct snd_soc_codec *codec,
955 enum snd_soc_bias_level level)
956{
957 switch (level) {
958 case SND_SOC_BIAS_ON:
959 enable_power_depop(codec);
960 break;
961 case SND_SOC_BIAS_PREPARE:
962 break;
963 case SND_SOC_BIAS_STANDBY:
964 /* everything off except vref/vmid, */
965 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1,
966 ALC5632_PWR_MANAG_ADD1_MASK,
967 ALC5632_PWR_ADD1_MAIN_BIAS);
968 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
969 ALC5632_PWR_MANAG_ADD2_MASK,
970 ALC5632_PWR_ADD2_VREF);
971 /* "normal" mode: 0 @ 26 */
972 snd_soc_update_bits(codec, ALC5632_PWR_DOWN_CTRL_STATUS,
973 ALC5632_PWR_DOWN_CTRL_STATUS_MASK,
974 0xffff ^ (ALC5632_PWR_VREF_PR3
975 | ALC5632_PWR_VREF_PR2));
976 break;
977 case SND_SOC_BIAS_OFF:
978 /* everything off, dac mute, inactive */
979 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2,
980 ALC5632_PWR_MANAG_ADD2_MASK, 0);
981 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD3,
982 ALC5632_PWR_MANAG_ADD3_MASK, 0);
983 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1,
984 ALC5632_PWR_MANAG_ADD1_MASK, 0);
985 break;
986 }
987 codec->dapm.bias_level = level;
988 return 0;
989}
990
991#define ALC5632_FORMATS (SNDRV_PCM_FMTBIT_S16_LE \
992 | SNDRV_PCM_FMTBIT_S24_LE \
993 | SNDRV_PCM_FMTBIT_S32_LE)
994
995static struct snd_soc_dai_ops alc5632_dai_ops = {
996 .hw_params = alc5632_pcm_hw_params,
997 .digital_mute = alc5632_mute,
998 .set_fmt = alc5632_set_dai_fmt,
999 .set_sysclk = alc5632_set_dai_sysclk,
1000 .set_pll = alc5632_set_dai_pll,
1001};
1002
1003static struct snd_soc_dai_driver alc5632_dai = {
1004 .name = "alc5632-hifi",
1005 .playback = {
1006 .stream_name = "HiFi Playback",
1007 .channels_min = 1,
1008 .channels_max = 2,
1009 .rate_min = 8000,
1010 .rate_max = 48000,
1011 .rates = SNDRV_PCM_RATE_8000_48000,
1012 .formats = ALC5632_FORMATS,},
1013 .capture = {
1014 .stream_name = "HiFi Capture",
1015 .channels_min = 1,
1016 .channels_max = 2,
1017 .rate_min = 8000,
1018 .rate_max = 48000,
1019 .rates = SNDRV_PCM_RATE_8000_48000,
1020 .formats = ALC5632_FORMATS,},
1021
1022 .ops = &alc5632_dai_ops,
1023 .symmetric_rates = 1,
1024};
1025
c9be8427 1026#ifdef CONFIG_PM
94d5f7c0
LR		 1027static int alc5632_suspend(struct snd_soc_codec *codec, pm_message_t mesg)
1028{
1029 alc5632_set_bias_level(codec, SND_SOC_BIAS_OFF);
1030 return 0;
1031}
1032
1033static int alc5632_resume(struct snd_soc_codec *codec)
1034{
bb39753c 1035 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec);
94d5f7c0 1036
bb39753c 1037 regcache_sync(alc5632->regmap);
94d5f7c0
LR		 1038
1039 alc5632_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1040 return 0;
1041}
c9be8427
LR		 1042#else
1043#define alc5632_suspend NULL
1044#define alc5632_resume NULL
1045#endif
94d5f7c0 1046
94d5f7c0
LR		 1047static int alc5632_probe(struct snd_soc_codec *codec)
1048{
1049 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec);
1050 int ret;
1051
bb39753c
LR		 1052 codec->control_data = alc5632->regmap;
1053
1054 ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP);
1055 if (ret != 0) {
94d5f7c0
LR		 1056 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
1057 return ret;
1058 }
1059
94d5f7c0
LR		 1060 /* power on device */
1061 alc5632_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1062
1063 switch (alc5632->id) {
1064 case 0x5c:
1065 snd_soc_add_controls(codec, alc5632_vol_snd_controls,
1066 ARRAY_SIZE(alc5632_vol_snd_controls));
1067 break;
1068 default:
1069 return -EINVAL;
1070 }
1071
1072 return ret;
1073}
1074
1075/* power down chip */
1076static int alc5632_remove(struct snd_soc_codec *codec)
1077{
1078 alc5632_set_bias_level(codec, SND_SOC_BIAS_OFF);
1079 return 0;
1080}
1081
1082static struct snd_soc_codec_driver soc_codec_device_alc5632 = {
1083 .probe = alc5632_probe,
1084 .remove = alc5632_remove,
1085 .suspend = alc5632_suspend,
1086 .resume = alc5632_resume,
1087 .set_bias_level = alc5632_set_bias_level,
94d5f7c0
LR		 1088 .controls = alc5632_snd_controls,
1089 .num_controls = ARRAY_SIZE(alc5632_snd_controls),
1090 .dapm_widgets = alc5632_dapm_widgets,
1091 .num_dapm_widgets = ARRAY_SIZE(alc5632_dapm_widgets),
1092 .dapm_routes = alc5632_dapm_routes,
1093 .num_dapm_routes = ARRAY_SIZE(alc5632_dapm_routes),
1094};
1095
bb39753c
LR		 1096static struct regmap_config alc5632_regmap = {
1097 .reg_bits = 8,
1098 .val_bits = 16,
1099
1100 .max_register = ALC5632_MAX_REGISTER,
1101 .reg_defaults = alc5632_reg_defaults,
1102 .num_reg_defaults = ARRAY_SIZE(alc5632_reg_defaults),
1103 .volatile_reg = alc5632_volatile_register,
1104 .cache_type = REGCACHE_RBTREE,
1105};
1106
94d5f7c0
LR		 1107/*
1108 * alc5632 2 wire address is determined by A1 pin
1109 * state during powerup.
1110 * low = 0x1a
1111 * high = 0x1b
1112 */
bb39753c 1113static __devinit int alc5632_i2c_probe(struct i2c_client *client,
94d5f7c0
LR		 1114 const struct i2c_device_id *id)
1115{
1116 struct alc5632_priv *alc5632;
1117 int ret, vid1, vid2;
1118
1119 vid1 = i2c_smbus_read_word_data(client, ALC5632_VENDOR_ID1);
1120 if (vid1 < 0) {
1121 dev_err(&client->dev, "failed to read I2C\n");
1122 return -EIO;
1123 } else {
1124 dev_info(&client->dev, "got vid1: %x\n", vid1);
1125 }
1126 vid1 = ((vid1 & 0xff) << 8) | (vid1 >> 8);
1127
1128 vid2 = i2c_smbus_read_word_data(client, ALC5632_VENDOR_ID2);
1129 if (vid2 < 0) {
1130 dev_err(&client->dev, "failed to read I2C\n");
1131 return -EIO;
1132 } else {
1133 dev_info(&client->dev, "got vid2: %x\n", vid2);
1134 }
1135 vid2 = (vid2 & 0xff);
1136
1137 if ((vid1 != 0x10ec) || (vid2 != id->driver_data)) {
1138 dev_err(&client->dev, "unknown or wrong codec\n");
1139 dev_err(&client->dev, "Expected %x:%lx, got %x:%x\n",
1140 0x10ec, id->driver_data,
1141 vid1, vid2);
1142 return -ENODEV;
1143 }
1144
1145 alc5632 = devm_kzalloc(&client->dev,
1146 sizeof(struct alc5632_priv), GFP_KERNEL);
1147 if (alc5632 == NULL)
1148 return -ENOMEM;
1149
1150 alc5632->id = vid2;
1151 switch (alc5632->id) {
1152 case 0x5c:
1153 alc5632_dai.name = "alc5632-hifi";
1154 break;
1155 default:
1156 return -EINVAL;
1157 }
1158
1159 i2c_set_clientdata(client, alc5632);
bb39753c
LR		 1160
1161 alc5632->regmap = regmap_init_i2c(client, &alc5632_regmap);
1162 if (IS_ERR(alc5632->regmap)) {
1163 ret = PTR_ERR(alc5632->regmap);
1164 dev_err(&client->dev, "regmap_init() failed: %d\n", ret);
1165 return ret;
1166 }
1167
1168 ret = alc5632_reset(alc5632->regmap);
1169 if (ret < 0) {
1170 dev_err(&client->dev, "Failed to issue reset\n");
1171 regmap_exit(alc5632->regmap);
1172 return ret;
1173 }
94d5f7c0
LR		 1174
1175 ret = snd_soc_register_codec(&client->dev,
1176 &soc_codec_device_alc5632, &alc5632_dai, 1);
bb39753c
LR		 1177
1178 if (ret < 0) {
94d5f7c0 1179 dev_err(&client->dev, "Failed to register codec: %d\n", ret);
bb39753c
LR		 1180 regmap_exit(alc5632->regmap);
1181 return ret;
1182 }
94d5f7c0
LR		 1183
1184 return ret;
1185}
1186
1187static int alc5632_i2c_remove(struct i2c_client *client)
1188{
bb39753c 1189 struct alc5632_priv *alc5632 = i2c_get_clientdata(client);
94d5f7c0 1190 snd_soc_unregister_codec(&client->dev);
bb39753c 1191 regmap_exit(alc5632->regmap);
94d5f7c0
LR		 1192 return 0;
1193}
1194
1195static const struct i2c_device_id alc5632_i2c_table[] = {
1196 {"alc5632", 0x5c},
1197 {}
1198};
1199MODULE_DEVICE_TABLE(i2c, alc5632_i2c_table);
1200
1201/* i2c codec control layer */
1202static struct i2c_driver alc5632_i2c_driver = {
1203 .driver = {
1204 .name = "alc5632",
1205 .owner = THIS_MODULE,
1206 },
1207 .probe = alc5632_i2c_probe,
1208 .remove = __devexit_p(alc5632_i2c_remove),
1209 .id_table = alc5632_i2c_table,
1210};
1211
1212static int __init alc5632_modinit(void)
1213{
1214 int ret;
1215
1216 ret = i2c_add_driver(&alc5632_i2c_driver);
1217 if (ret != 0) {
1218 printk(KERN_ERR "%s: can't add i2c driver", __func__);
1219 return ret;
1220 }
1221
1222 return ret;
1223}
1224module_init(alc5632_modinit);
1225
1226static void __exit alc5632_modexit(void)
1227{
1228 i2c_del_driver(&alc5632_i2c_driver);
1229}
1230module_exit(alc5632_modexit);
1231
1232MODULE_DESCRIPTION("ASoC ALC5632 driver");
1233MODULE_AUTHOR("Leon Romanovsky <leon@leon.nu>");
1234MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.099324 seconds and 5 git commands to generate.