projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'selinux/next'
[deliverable/linux.git] / sound / soc / codecs / cs42l56.c
1 /*
2 * cs42l56.c -- CS42L56 ALSA SoC audio driver
3 *
4 * Copyright 2014 CirrusLogic, Inc.
5 *
6 * Author: Brian Austin <brian.austin@cirrus.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 */
13
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/delay.h>
19 #include <linux/pm.h>
20 #include <linux/i2c.h>
21 #include <linux/input.h>
22 #include <linux/regmap.h>
23 #include <linux/slab.h>
24 #include <linux/workqueue.h>
25 #include <linux/platform_device.h>
26 #include <linux/regulator/consumer.h>
27 #include <linux/of_device.h>
28 #include <linux/of_gpio.h>
29 #include <sound/core.h>
30 #include <sound/pcm.h>
31 #include <sound/pcm_params.h>
32 #include <sound/soc.h>
33 #include <sound/soc-dapm.h>
34 #include <sound/initval.h>
35 #include <sound/tlv.h>
36 #include <sound/cs42l56.h>
37 #include "cs42l56.h"
38
39 #define CS42L56_NUM_SUPPLIES 3
40 static const char *const cs42l56_supply_names[CS42L56_NUM_SUPPLIES] = {
41 "VA",
42 "VCP",
43 "VLDO",
44 };
45
46 struct cs42l56_private {
47 struct regmap *regmap;
48 struct snd_soc_codec *codec;
49 struct device *dev;
50 struct cs42l56_platform_data pdata;
51 struct regulator_bulk_data supplies[CS42L56_NUM_SUPPLIES];
52 u32 mclk;
53 u8 mclk_prediv;
54 u8 mclk_div2;
55 u8 mclk_ratio;
56 u8 iface;
57 u8 iface_fmt;
58 u8 iface_inv;
59 #if IS_ENABLED(CONFIG_INPUT)
60 struct input_dev *beep;
61 struct work_struct beep_work;
62 int beep_rate;
63 #endif
64 };
65
66 static const struct reg_default cs42l56_reg_defaults[] = {
67 { 1, 0x56 }, /* r01 - ID 1 */
68 { 2, 0x04 }, /* r02 - ID 2 */
69 { 3, 0x7f }, /* r03 - Power Ctl 1 */
70 { 4, 0xff }, /* r04 - Power Ctl 2 */
71 { 5, 0x00 }, /* ro5 - Clocking Ctl 1 */
72 { 6, 0x0b }, /* r06 - Clocking Ctl 2 */
73 { 7, 0x00 }, /* r07 - Serial Format */
74 { 8, 0x05 }, /* r08 - Class H Ctl */
75 { 9, 0x0c }, /* r09 - Misc Ctl */
76 { 10, 0x80 }, /* r0a - INT Status */
77 { 11, 0x00 }, /* r0b - Playback Ctl */
78 { 12, 0x0c }, /* r0c - DSP Mute Ctl */
79 { 13, 0x00 }, /* r0d - ADCA Mixer Volume */
80 { 14, 0x00 }, /* r0e - ADCB Mixer Volume */
81 { 15, 0x00 }, /* r0f - PCMA Mixer Volume */
82 { 16, 0x00 }, /* r10 - PCMB Mixer Volume */
83 { 17, 0x00 }, /* r11 - Analog Input Advisory Volume */
84 { 18, 0x00 }, /* r12 - Digital Input Advisory Volume */
85 { 19, 0x00 }, /* r13 - Master A Volume */
86 { 20, 0x00 }, /* r14 - Master B Volume */
87 { 21, 0x00 }, /* r15 - Beep Freq / On Time */
88 { 22, 0x00 }, /* r16 - Beep Volume / Off Time */
89 { 23, 0x00 }, /* r17 - Beep Tone Ctl */
90 { 24, 0x88 }, /* r18 - Tone Ctl */
91 { 25, 0x00 }, /* r19 - Channel Mixer & Swap */
92 { 26, 0x00 }, /* r1a - AIN Ref Config / ADC Mux */
93 { 27, 0xa0 }, /* r1b - High-Pass Filter Ctl */
94 { 28, 0x00 }, /* r1c - Misc ADC Ctl */
95 { 29, 0x00 }, /* r1d - Gain & Bias Ctl */
96 { 30, 0x00 }, /* r1e - PGAA Mux & Volume */
97 { 31, 0x00 }, /* r1f - PGAB Mux & Volume */
98 { 32, 0x00 }, /* r20 - ADCA Attenuator */
99 { 33, 0x00 }, /* r21 - ADCB Attenuator */
100 { 34, 0x00 }, /* r22 - ALC Enable & Attack Rate */
101 { 35, 0xbf }, /* r23 - ALC Release Rate */
102 { 36, 0x00 }, /* r24 - ALC Threshold */
103 { 37, 0x00 }, /* r25 - Noise Gate Ctl */
104 { 38, 0x00 }, /* r26 - ALC, Limiter, SFT, ZeroCross */
105 { 39, 0x00 }, /* r27 - Analog Mute, LO & HP Mux */
106 { 40, 0x00 }, /* r28 - HP A Volume */
107 { 41, 0x00 }, /* r29 - HP B Volume */
108 { 42, 0x00 }, /* r2a - LINEOUT A Volume */
109 { 43, 0x00 }, /* r2b - LINEOUT B Volume */
110 { 44, 0x00 }, /* r2c - Limit Threshold Ctl */
111 { 45, 0x7f }, /* r2d - Limiter Ctl & Release Rate */
112 { 46, 0x00 }, /* r2e - Limiter Attack Rate */
113 };
114
115 static bool cs42l56_readable_register(struct device *dev, unsigned int reg)
116 {
117 switch (reg) {
118 case CS42L56_CHIP_ID_1 ... CS42L56_LIM_ATTACK_RATE:
119 return true;
120 default:
121 return false;
122 }
123 }
124
125 static bool cs42l56_volatile_register(struct device *dev, unsigned int reg)
126 {
127 switch (reg) {
128 case CS42L56_INT_STATUS:
129 return true;
130 default:
131 return false;
132 }
133 }
134
135 static DECLARE_TLV_DB_SCALE(beep_tlv, -5000, 200, 0);
136 static DECLARE_TLV_DB_SCALE(hl_tlv, -6000, 50, 0);
137 static DECLARE_TLV_DB_SCALE(adv_tlv, -10200, 50, 0);
138 static DECLARE_TLV_DB_SCALE(adc_tlv, -9600, 100, 0);
139 static DECLARE_TLV_DB_SCALE(tone_tlv, -1050, 150, 0);
140 static DECLARE_TLV_DB_SCALE(preamp_tlv, 0, 1000, 0);
141 static DECLARE_TLV_DB_SCALE(pga_tlv, -600, 50, 0);
142
143 static const DECLARE_TLV_DB_RANGE(ngnb_tlv,
144 0, 1, TLV_DB_SCALE_ITEM(-8200, 600, 0),
145 2, 5, TLV_DB_SCALE_ITEM(-7600, 300, 0)
146 );
147 static const DECLARE_TLV_DB_RANGE(ngb_tlv,
148 0, 2, TLV_DB_SCALE_ITEM(-6400, 600, 0),
149 3, 7, TLV_DB_SCALE_ITEM(-4600, 300, 0)
150 );
151 static const DECLARE_TLV_DB_RANGE(alc_tlv,
152 0, 2, TLV_DB_SCALE_ITEM(-3000, 600, 0),
153 3, 7, TLV_DB_SCALE_ITEM(-1200, 300, 0)
154 );
155
156 static const char * const beep_config_text[] = {
157 "Off", "Single", "Multiple", "Continuous"
158 };
159
160 static const struct soc_enum beep_config_enum =
161 SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 6,
162 ARRAY_SIZE(beep_config_text), beep_config_text);
163
164 static const char * const beep_pitch_text[] = {
165 "C4", "C5", "D5", "E5", "F5", "G5", "A5", "B5",
166 "C6", "D6", "E6", "F6", "G6", "A6", "B6", "C7"
167 };
168
169 static const struct soc_enum beep_pitch_enum =
170 SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_ONTIME, 4,
171 ARRAY_SIZE(beep_pitch_text), beep_pitch_text);
172
173 static const char * const beep_ontime_text[] = {
174 "86 ms", "430 ms", "780 ms", "1.20 s", "1.50 s",
175 "1.80 s", "2.20 s", "2.50 s", "2.80 s", "3.20 s",
176 "3.50 s", "3.80 s", "4.20 s", "4.50 s", "4.80 s", "5.20 s"
177 };
178
179 static const struct soc_enum beep_ontime_enum =
180 SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_ONTIME, 0,
181 ARRAY_SIZE(beep_ontime_text), beep_ontime_text);
182
183 static const char * const beep_offtime_text[] = {
184 "1.23 s", "2.58 s", "3.90 s", "5.20 s",
185 "6.60 s", "8.05 s", "9.35 s", "10.80 s"
186 };
187
188 static const struct soc_enum beep_offtime_enum =
189 SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_OFFTIME, 5,
190 ARRAY_SIZE(beep_offtime_text), beep_offtime_text);
191
192 static const char * const beep_treble_text[] = {
193 "5kHz", "7kHz", "10kHz", "15kHz"
194 };
195
196 static const struct soc_enum beep_treble_enum =
197 SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 3,
198 ARRAY_SIZE(beep_treble_text), beep_treble_text);
199
200 static const char * const beep_bass_text[] = {
201 "50Hz", "100Hz", "200Hz", "250Hz"
202 };
203
204 static const struct soc_enum beep_bass_enum =
205 SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 1,
206 ARRAY_SIZE(beep_bass_text), beep_bass_text);
207
208 static const char * const adc_swap_text[] = {
209 "None", "A+B/2", "A-B/2", "Swap"
210 };
211
212 static const struct soc_enum adc_swap_enum =
213 SOC_ENUM_SINGLE(CS42L56_MISC_ADC_CTL, 3,
214 ARRAY_SIZE(adc_swap_text), adc_swap_text);
215
216 static const char * const pgaa_mux_text[] = {
217 "AIN1A", "AIN2A", "AIN3A"};
218
219 static const struct soc_enum pgaa_mux_enum =
220 SOC_ENUM_SINGLE(CS42L56_PGAA_MUX_VOLUME, 0,
221 ARRAY_SIZE(pgaa_mux_text),
222 pgaa_mux_text);
223
224 static const struct snd_kcontrol_new pgaa_mux =
225 SOC_DAPM_ENUM("Route", pgaa_mux_enum);
226
227 static const char * const pgab_mux_text[] = {
228 "AIN1B", "AIN2B", "AIN3B"};
229
230 static const struct soc_enum pgab_mux_enum =
231 SOC_ENUM_SINGLE(CS42L56_PGAB_MUX_VOLUME, 0,
232 ARRAY_SIZE(pgab_mux_text),
233 pgab_mux_text);
234
235 static const struct snd_kcontrol_new pgab_mux =
236 SOC_DAPM_ENUM("Route", pgab_mux_enum);
237
238 static const char * const adca_mux_text[] = {
239 "PGAA", "AIN1A", "AIN2A", "AIN3A"};
240
241 static const struct soc_enum adca_mux_enum =
242 SOC_ENUM_SINGLE(CS42L56_AIN_REFCFG_ADC_MUX, 0,
243 ARRAY_SIZE(adca_mux_text),
244 adca_mux_text);
245
246 static const struct snd_kcontrol_new adca_mux =
247 SOC_DAPM_ENUM("Route", adca_mux_enum);
248
249 static const char * const adcb_mux_text[] = {
250 "PGAB", "AIN1B", "AIN2B", "AIN3B"};
251
252 static const struct soc_enum adcb_mux_enum =
253 SOC_ENUM_SINGLE(CS42L56_AIN_REFCFG_ADC_MUX, 2,
254 ARRAY_SIZE(adcb_mux_text),
255 adcb_mux_text);
256
257 static const struct snd_kcontrol_new adcb_mux =
258 SOC_DAPM_ENUM("Route", adcb_mux_enum);
259
260 static const char * const left_swap_text[] = {
261 "Left", "LR 2", "Right"};
262
263 static const char * const right_swap_text[] = {
264 "Right", "LR 2", "Left"};
265
266 static const unsigned int swap_values[] = { 0, 1, 3 };
267
268 static const struct soc_enum adca_swap_enum =
269 SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 0, 3,
270 ARRAY_SIZE(left_swap_text),
271 left_swap_text,
272 swap_values);
273 static const struct snd_kcontrol_new adca_swap_mux =
274 SOC_DAPM_ENUM("Route", adca_swap_enum);
275
276 static const struct soc_enum pcma_swap_enum =
277 SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 4, 3,
278 ARRAY_SIZE(left_swap_text),
279 left_swap_text,
280 swap_values);
281 static const struct snd_kcontrol_new pcma_swap_mux =
282 SOC_DAPM_ENUM("Route", pcma_swap_enum);
283
284 static const struct soc_enum adcb_swap_enum =
285 SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 2, 3,
286 ARRAY_SIZE(right_swap_text),
287 right_swap_text,
288 swap_values);
289 static const struct snd_kcontrol_new adcb_swap_mux =
290 SOC_DAPM_ENUM("Route", adcb_swap_enum);
291
292 static const struct soc_enum pcmb_swap_enum =
293 SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 6, 3,
294 ARRAY_SIZE(right_swap_text),
295 right_swap_text,
296 swap_values);
297 static const struct snd_kcontrol_new pcmb_swap_mux =
298 SOC_DAPM_ENUM("Route", pcmb_swap_enum);
299
300 static const struct snd_kcontrol_new hpa_switch =
301 SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 6, 1, 1);
302
303 static const struct snd_kcontrol_new hpb_switch =
304 SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 4, 1, 1);
305
306 static const struct snd_kcontrol_new loa_switch =
307 SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 2, 1, 1);
308
309 static const struct snd_kcontrol_new lob_switch =
310 SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 0, 1, 1);
311
312 static const char * const hploa_input_text[] = {
313 "DACA", "PGAA"};
314
315 static const struct soc_enum lineouta_input_enum =
316 SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 2,
317 ARRAY_SIZE(hploa_input_text),
318 hploa_input_text);
319
320 static const struct snd_kcontrol_new lineouta_input =
321 SOC_DAPM_ENUM("Route", lineouta_input_enum);
322
323 static const struct soc_enum hpa_input_enum =
324 SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 0,
325 ARRAY_SIZE(hploa_input_text),
326 hploa_input_text);
327
328 static const struct snd_kcontrol_new hpa_input =
329 SOC_DAPM_ENUM("Route", hpa_input_enum);
330
331 static const char * const hplob_input_text[] = {
332 "DACB", "PGAB"};
333
334 static const struct soc_enum lineoutb_input_enum =
335 SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 3,
336 ARRAY_SIZE(hplob_input_text),
337 hplob_input_text);
338
339 static const struct snd_kcontrol_new lineoutb_input =
340 SOC_DAPM_ENUM("Route", lineoutb_input_enum);
341
342 static const struct soc_enum hpb_input_enum =
343 SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 1,
344 ARRAY_SIZE(hplob_input_text),
345 hplob_input_text);
346
347 static const struct snd_kcontrol_new hpb_input =
348 SOC_DAPM_ENUM("Route", hpb_input_enum);
349
350 static const char * const dig_mux_text[] = {
351 "ADC", "DSP"};
352
353 static const struct soc_enum dig_mux_enum =
354 SOC_ENUM_SINGLE(CS42L56_MISC_CTL, 7,
355 ARRAY_SIZE(dig_mux_text),
356 dig_mux_text);
357
358 static const struct snd_kcontrol_new dig_mux =
359 SOC_DAPM_ENUM("Route", dig_mux_enum);
360
361 static const char * const hpf_freq_text[] = {
362 "1.8Hz", "119Hz", "236Hz", "464Hz"
363 };
364
365 static const struct soc_enum hpfa_freq_enum =
366 SOC_ENUM_SINGLE(CS42L56_HPF_CTL, 0,
367 ARRAY_SIZE(hpf_freq_text), hpf_freq_text);
368
369 static const struct soc_enum hpfb_freq_enum =
370 SOC_ENUM_SINGLE(CS42L56_HPF_CTL, 2,
371 ARRAY_SIZE(hpf_freq_text), hpf_freq_text);
372
373 static const char * const ng_delay_text[] = {
374 "50ms", "100ms", "150ms", "200ms"
375 };
376
377 static const struct soc_enum ng_delay_enum =
378 SOC_ENUM_SINGLE(CS42L56_NOISE_GATE_CTL, 0,
379 ARRAY_SIZE(ng_delay_text), ng_delay_text);
380
381 static const struct snd_kcontrol_new cs42l56_snd_controls[] = {
382
383 SOC_DOUBLE_R_SX_TLV("Master Volume", CS42L56_MASTER_A_VOLUME,
384 CS42L56_MASTER_B_VOLUME, 0, 0x34, 0xE4, adv_tlv),
385 SOC_DOUBLE("Master Mute Switch", CS42L56_DSP_MUTE_CTL, 0, 1, 1, 1),
386
387 SOC_DOUBLE_R_SX_TLV("ADC Mixer Volume", CS42L56_ADCA_MIX_VOLUME,
388 CS42L56_ADCB_MIX_VOLUME, 0, 0x88, 0x90, hl_tlv),
389 SOC_DOUBLE("ADC Mixer Mute Switch", CS42L56_DSP_MUTE_CTL, 6, 7, 1, 1),
390
391 SOC_DOUBLE_R_SX_TLV("PCM Mixer Volume", CS42L56_PCMA_MIX_VOLUME,
392 CS42L56_PCMB_MIX_VOLUME, 0, 0x88, 0x90, hl_tlv),
393 SOC_DOUBLE("PCM Mixer Mute Switch", CS42L56_DSP_MUTE_CTL, 4, 5, 1, 1),
394
395 SOC_SINGLE_TLV("Analog Advisory Volume",
396 CS42L56_ANAINPUT_ADV_VOLUME, 0, 0x00, 1, adv_tlv),
397 SOC_SINGLE_TLV("Digital Advisory Volume",
398 CS42L56_DIGINPUT_ADV_VOLUME, 0, 0x00, 1, adv_tlv),
399
400 SOC_DOUBLE_R_SX_TLV("PGA Volume", CS42L56_PGAA_MUX_VOLUME,
401 CS42L56_PGAB_MUX_VOLUME, 0, 0x34, 0x24, pga_tlv),
402 SOC_DOUBLE_R_TLV("ADC Volume", CS42L56_ADCA_ATTENUATOR,
403 CS42L56_ADCB_ATTENUATOR, 0, 0x00, 1, adc_tlv),
404 SOC_DOUBLE("ADC Mute Switch", CS42L56_MISC_ADC_CTL, 2, 3, 1, 1),
405 SOC_DOUBLE("ADC Boost Switch", CS42L56_GAIN_BIAS_CTL, 3, 2, 1, 1),
406
407 SOC_DOUBLE_R_SX_TLV("Headphone Volume", CS42L56_HPA_VOLUME,
408 CS42L56_HPB_VOLUME, 0, 0x84, 0x48, hl_tlv),
409 SOC_DOUBLE_R_SX_TLV("LineOut Volume", CS42L56_LOA_VOLUME,
410 CS42L56_LOB_VOLUME, 0, 0x84, 0x48, hl_tlv),
411
412 SOC_SINGLE_TLV("Bass Shelving Volume", CS42L56_TONE_CTL,
413 0, 0x00, 1, tone_tlv),
414 SOC_SINGLE_TLV("Treble Shelving Volume", CS42L56_TONE_CTL,
415 4, 0x00, 1, tone_tlv),
416
417 SOC_DOUBLE_TLV("PGA Preamp Volume", CS42L56_GAIN_BIAS_CTL,
418 4, 6, 0x02, 1, preamp_tlv),
419
420 SOC_SINGLE("DSP Switch", CS42L56_PLAYBACK_CTL, 7, 1, 1),
421 SOC_SINGLE("Gang Playback Switch", CS42L56_PLAYBACK_CTL, 4, 1, 1),
422 SOC_SINGLE("Gang ADC Switch", CS42L56_MISC_ADC_CTL, 7, 1, 1),
423 SOC_SINGLE("Gang PGA Switch", CS42L56_MISC_ADC_CTL, 6, 1, 1),
424
425 SOC_SINGLE("PCMA Invert", CS42L56_PLAYBACK_CTL, 2, 1, 1),
426 SOC_SINGLE("PCMB Invert", CS42L56_PLAYBACK_CTL, 3, 1, 1),
427 SOC_SINGLE("ADCA Invert", CS42L56_MISC_ADC_CTL, 2, 1, 1),
428 SOC_SINGLE("ADCB Invert", CS42L56_MISC_ADC_CTL, 3, 1, 1),
429
430 SOC_DOUBLE("HPF Switch", CS42L56_HPF_CTL, 5, 7, 1, 1),
431 SOC_DOUBLE("HPF Freeze Switch", CS42L56_HPF_CTL, 4, 6, 1, 1),
432 SOC_ENUM("HPFA Corner Freq", hpfa_freq_enum),
433 SOC_ENUM("HPFB Corner Freq", hpfb_freq_enum),
434
435 SOC_SINGLE("Analog Soft Ramp", CS42L56_MISC_CTL, 4, 1, 1),
436 SOC_DOUBLE("Analog Soft Ramp Disable", CS42L56_ALC_LIM_SFT_ZC,
437 7, 5, 1, 1),
438 SOC_SINGLE("Analog Zero Cross", CS42L56_MISC_CTL, 3, 1, 1),
439 SOC_DOUBLE("Analog Zero Cross Disable", CS42L56_ALC_LIM_SFT_ZC,
440 6, 4, 1, 1),
441 SOC_SINGLE("Digital Soft Ramp", CS42L56_MISC_CTL, 2, 1, 1),
442 SOC_SINGLE("Digital Soft Ramp Disable", CS42L56_ALC_LIM_SFT_ZC,
443 3, 1, 1),
444
445 SOC_SINGLE("HL Deemphasis", CS42L56_PLAYBACK_CTL, 6, 1, 1),
446
447 SOC_SINGLE("ALC Switch", CS42L56_ALC_EN_ATTACK_RATE, 6, 1, 1),
448 SOC_SINGLE("ALC Limit All Switch", CS42L56_ALC_RELEASE_RATE, 7, 1, 1),
449 SOC_SINGLE_RANGE("ALC Attack", CS42L56_ALC_EN_ATTACK_RATE,
450 0, 0, 0x3f, 0),
451 SOC_SINGLE_RANGE("ALC Release", CS42L56_ALC_RELEASE_RATE,
452 0, 0x3f, 0, 0),
453 SOC_SINGLE_TLV("ALC MAX", CS42L56_ALC_THRESHOLD,
454 5, 0x07, 1, alc_tlv),
455 SOC_SINGLE_TLV("ALC MIN", CS42L56_ALC_THRESHOLD,
456 2, 0x07, 1, alc_tlv),
457
458 SOC_SINGLE("Limiter Switch", CS42L56_LIM_CTL_RELEASE_RATE, 7, 1, 1),
459 SOC_SINGLE("Limit All Switch", CS42L56_LIM_CTL_RELEASE_RATE, 6, 1, 1),
460 SOC_SINGLE_RANGE("Limiter Attack", CS42L56_LIM_ATTACK_RATE,
461 0, 0, 0x3f, 0),
462 SOC_SINGLE_RANGE("Limiter Release", CS42L56_LIM_CTL_RELEASE_RATE,
463 0, 0x3f, 0, 0),
464 SOC_SINGLE_TLV("Limiter MAX", CS42L56_LIM_THRESHOLD_CTL,
465 5, 0x07, 1, alc_tlv),
466 SOC_SINGLE_TLV("Limiter Cushion", CS42L56_ALC_THRESHOLD,
467 2, 0x07, 1, alc_tlv),
468
469 SOC_SINGLE("NG Switch", CS42L56_NOISE_GATE_CTL, 6, 1, 1),
470 SOC_SINGLE("NG All Switch", CS42L56_NOISE_GATE_CTL, 7, 1, 1),
471 SOC_SINGLE("NG Boost Switch", CS42L56_NOISE_GATE_CTL, 5, 1, 1),
472 SOC_SINGLE_TLV("NG Unboost Threshold", CS42L56_NOISE_GATE_CTL,
473 2, 0x07, 1, ngnb_tlv),
474 SOC_SINGLE_TLV("NG Boost Threshold", CS42L56_NOISE_GATE_CTL,
475 2, 0x07, 1, ngb_tlv),
476 SOC_ENUM("NG Delay", ng_delay_enum),
477
478 SOC_ENUM("Beep Config", beep_config_enum),
479 SOC_ENUM("Beep Pitch", beep_pitch_enum),
480 SOC_ENUM("Beep on Time", beep_ontime_enum),
481 SOC_ENUM("Beep off Time", beep_offtime_enum),
482 SOC_SINGLE_SX_TLV("Beep Volume", CS42L56_BEEP_FREQ_OFFTIME,
483 0, 0x07, 0x23, beep_tlv),
484 SOC_SINGLE("Beep Tone Ctl Switch", CS42L56_BEEP_TONE_CFG, 0, 1, 1),
485 SOC_ENUM("Beep Treble Corner Freq", beep_treble_enum),
486 SOC_ENUM("Beep Bass Corner Freq", beep_bass_enum),
487
488 };
489
490 static const struct snd_soc_dapm_widget cs42l56_dapm_widgets[] = {
491
492 SND_SOC_DAPM_SIGGEN("Beep"),
493 SND_SOC_DAPM_SUPPLY("VBUF", CS42L56_PWRCTL_1, 5, 1, NULL, 0),
494 SND_SOC_DAPM_MICBIAS("MIC1 Bias", CS42L56_PWRCTL_1, 4, 1),
495 SND_SOC_DAPM_SUPPLY("Charge Pump", CS42L56_PWRCTL_1, 3, 1, NULL, 0),
496
497 SND_SOC_DAPM_INPUT("AIN1A"),
498 SND_SOC_DAPM_INPUT("AIN2A"),
499 SND_SOC_DAPM_INPUT("AIN1B"),
500 SND_SOC_DAPM_INPUT("AIN2B"),
501 SND_SOC_DAPM_INPUT("AIN3A"),
502 SND_SOC_DAPM_INPUT("AIN3B"),
503
504 SND_SOC_DAPM_AIF_OUT("SDOUT", NULL, 0,
505 SND_SOC_NOPM, 0, 0),
506
507 SND_SOC_DAPM_AIF_IN("SDIN", NULL, 0,
508 SND_SOC_NOPM, 0, 0),
509
510 SND_SOC_DAPM_MUX("Digital Output Mux", SND_SOC_NOPM,
511 0, 0, &dig_mux),
512
513 SND_SOC_DAPM_PGA("PGAA", SND_SOC_NOPM, 0, 0, NULL, 0),
514 SND_SOC_DAPM_PGA("PGAB", SND_SOC_NOPM, 0, 0, NULL, 0),
515 SND_SOC_DAPM_MUX("PGAA Input Mux",
516 SND_SOC_NOPM, 0, 0, &pgaa_mux),
517 SND_SOC_DAPM_MUX("PGAB Input Mux",
518 SND_SOC_NOPM, 0, 0, &pgab_mux),
519
520 SND_SOC_DAPM_MUX("ADCA Mux", SND_SOC_NOPM,
521 0, 0, &adca_mux),
522 SND_SOC_DAPM_MUX("ADCB Mux", SND_SOC_NOPM,
523 0, 0, &adcb_mux),
524
525 SND_SOC_DAPM_ADC("ADCA", NULL, CS42L56_PWRCTL_1, 1, 1),
526 SND_SOC_DAPM_ADC("ADCB", NULL, CS42L56_PWRCTL_1, 2, 1),
527
528 SND_SOC_DAPM_MUX("ADCA Swap Mux", SND_SOC_NOPM, 0, 0,
529 &adca_swap_mux),
530 SND_SOC_DAPM_MUX("ADCB Swap Mux", SND_SOC_NOPM, 0, 0,
531 &adcb_swap_mux),
532
533 SND_SOC_DAPM_MUX("PCMA Swap Mux", SND_SOC_NOPM, 0, 0,
534 &pcma_swap_mux),
535 SND_SOC_DAPM_MUX("PCMB Swap Mux", SND_SOC_NOPM, 0, 0,
536 &pcmb_swap_mux),
537
538 SND_SOC_DAPM_DAC("DACA", NULL, SND_SOC_NOPM, 0, 0),
539 SND_SOC_DAPM_DAC("DACB", NULL, SND_SOC_NOPM, 0, 0),
540
541 SND_SOC_DAPM_OUTPUT("HPA"),
542 SND_SOC_DAPM_OUTPUT("LOA"),
543 SND_SOC_DAPM_OUTPUT("HPB"),
544 SND_SOC_DAPM_OUTPUT("LOB"),
545
546 SND_SOC_DAPM_SWITCH("Headphone Right",
547 CS42L56_PWRCTL_2, 4, 1, &hpb_switch),
548 SND_SOC_DAPM_SWITCH("Headphone Left",
549 CS42L56_PWRCTL_2, 6, 1, &hpa_switch),
550
551 SND_SOC_DAPM_SWITCH("Lineout Right",
552 CS42L56_PWRCTL_2, 0, 1, &lob_switch),
553 SND_SOC_DAPM_SWITCH("Lineout Left",
554 CS42L56_PWRCTL_2, 2, 1, &loa_switch),
555
556 SND_SOC_DAPM_MUX("LINEOUTA Input Mux", SND_SOC_NOPM,
557 0, 0, &lineouta_input),
558 SND_SOC_DAPM_MUX("LINEOUTB Input Mux", SND_SOC_NOPM,
559 0, 0, &lineoutb_input),
560 SND_SOC_DAPM_MUX("HPA Input Mux", SND_SOC_NOPM,
561 0, 0, &hpa_input),
562 SND_SOC_DAPM_MUX("HPB Input Mux", SND_SOC_NOPM,
563 0, 0, &hpb_input),
564
565 };
566
567 static const struct snd_soc_dapm_route cs42l56_audio_map[] = {
568
569 {"HiFi Capture", "DSP", "Digital Output Mux"},
570 {"HiFi Capture", "ADC", "Digital Output Mux"},
571
572 {"Digital Output Mux", NULL, "ADCA"},
573 {"Digital Output Mux", NULL, "ADCB"},
574
575 {"ADCB", NULL, "ADCB Swap Mux"},
576 {"ADCA", NULL, "ADCA Swap Mux"},
577
578 {"ADCA Swap Mux", NULL, "ADCA"},
579 {"ADCB Swap Mux", NULL, "ADCB"},
580
581 {"DACA", "Left", "ADCA Swap Mux"},
582 {"DACA", "LR 2", "ADCA Swap Mux"},
583 {"DACA", "Right", "ADCA Swap Mux"},
584
585 {"DACB", "Left", "ADCB Swap Mux"},
586 {"DACB", "LR 2", "ADCB Swap Mux"},
587 {"DACB", "Right", "ADCB Swap Mux"},
588
589 {"ADCA Mux", NULL, "AIN3A"},
590 {"ADCA Mux", NULL, "AIN2A"},
591 {"ADCA Mux", NULL, "AIN1A"},
592 {"ADCA Mux", NULL, "PGAA"},
593 {"ADCB Mux", NULL, "AIN3B"},
594 {"ADCB Mux", NULL, "AIN2B"},
595 {"ADCB Mux", NULL, "AIN1B"},
596 {"ADCB Mux", NULL, "PGAB"},
597
598 {"PGAA", "AIN1A", "PGAA Input Mux"},
599 {"PGAA", "AIN2A", "PGAA Input Mux"},
600 {"PGAA", "AIN3A", "PGAA Input Mux"},
601 {"PGAB", "AIN1B", "PGAB Input Mux"},
602 {"PGAB", "AIN2B", "PGAB Input Mux"},
603 {"PGAB", "AIN3B", "PGAB Input Mux"},
604
605 {"PGAA Input Mux", NULL, "AIN1A"},
606 {"PGAA Input Mux", NULL, "AIN2A"},
607 {"PGAA Input Mux", NULL, "AIN3A"},
608 {"PGAB Input Mux", NULL, "AIN1B"},
609 {"PGAB Input Mux", NULL, "AIN2B"},
610 {"PGAB Input Mux", NULL, "AIN3B"},
611
612 {"LOB", "Switch", "LINEOUTB Input Mux"},
613 {"LOA", "Switch", "LINEOUTA Input Mux"},
614
615 {"LINEOUTA Input Mux", "PGAA", "PGAA"},
616 {"LINEOUTB Input Mux", "PGAB", "PGAB"},
617 {"LINEOUTA Input Mux", "DACA", "DACA"},
618 {"LINEOUTB Input Mux", "DACB", "DACB"},
619
620 {"HPA", "Switch", "HPB Input Mux"},
621 {"HPB", "Switch", "HPA Input Mux"},
622
623 {"HPA Input Mux", "PGAA", "PGAA"},
624 {"HPB Input Mux", "PGAB", "PGAB"},
625 {"HPA Input Mux", "DACA", "DACA"},
626 {"HPB Input Mux", "DACB", "DACB"},
627
628 {"DACA", NULL, "PCMA Swap Mux"},
629 {"DACB", NULL, "PCMB Swap Mux"},
630
631 {"PCMB Swap Mux", "Left", "HiFi Playback"},
632 {"PCMB Swap Mux", "LR 2", "HiFi Playback"},
633 {"PCMB Swap Mux", "Right", "HiFi Playback"},
634
635 {"PCMA Swap Mux", "Left", "HiFi Playback"},
636 {"PCMA Swap Mux", "LR 2", "HiFi Playback"},
637 {"PCMA Swap Mux", "Right", "HiFi Playback"},
638
639 };
640
641 struct cs42l56_clk_para {
642 u32 mclk;
643 u32 srate;
644 u8 ratio;
645 };
646
647 static const struct cs42l56_clk_para clk_ratio_table[] = {
648 /* 8k */
649 { 6000000, 8000, CS42L56_MCLK_LRCLK_768 },
650 { 6144000, 8000, CS42L56_MCLK_LRCLK_750 },
651 { 12000000, 8000, CS42L56_MCLK_LRCLK_768 },
652 { 12288000, 8000, CS42L56_MCLK_LRCLK_750 },
653 { 24000000, 8000, CS42L56_MCLK_LRCLK_768 },
654 { 24576000, 8000, CS42L56_MCLK_LRCLK_750 },
655 /* 11.025k */
656 { 5644800, 11025, CS42L56_MCLK_LRCLK_512},
657 { 11289600, 11025, CS42L56_MCLK_LRCLK_512},
658 { 22579200, 11025, CS42L56_MCLK_LRCLK_512 },
659 /* 11.0294k */
660 { 6000000, 110294, CS42L56_MCLK_LRCLK_544 },
661 { 12000000, 110294, CS42L56_MCLK_LRCLK_544 },
662 { 24000000, 110294, CS42L56_MCLK_LRCLK_544 },
663 /* 12k */
664 { 6000000, 12000, CS42L56_MCLK_LRCLK_500 },
665 { 6144000, 12000, CS42L56_MCLK_LRCLK_512 },
666 { 12000000, 12000, CS42L56_MCLK_LRCLK_500 },
667 { 12288000, 12000, CS42L56_MCLK_LRCLK_512 },
668 { 24000000, 12000, CS42L56_MCLK_LRCLK_500 },
669 { 24576000, 12000, CS42L56_MCLK_LRCLK_512 },
670 /* 16k */
671 { 6000000, 16000, CS42L56_MCLK_LRCLK_375 },
672 { 6144000, 16000, CS42L56_MCLK_LRCLK_384 },
673 { 12000000, 16000, CS42L56_MCLK_LRCLK_375 },
674 { 12288000, 16000, CS42L56_MCLK_LRCLK_384 },
675 { 24000000, 16000, CS42L56_MCLK_LRCLK_375 },
676 { 24576000, 16000, CS42L56_MCLK_LRCLK_384 },
677 /* 22.050k */
678 { 5644800, 22050, CS42L56_MCLK_LRCLK_256 },
679 { 11289600, 22050, CS42L56_MCLK_LRCLK_256 },
680 { 22579200, 22050, CS42L56_MCLK_LRCLK_256 },
681 /* 22.0588k */
682 { 6000000, 220588, CS42L56_MCLK_LRCLK_272 },
683 { 12000000, 220588, CS42L56_MCLK_LRCLK_272 },
684 { 24000000, 220588, CS42L56_MCLK_LRCLK_272 },
685 /* 24k */
686 { 6000000, 24000, CS42L56_MCLK_LRCLK_250 },
687 { 6144000, 24000, CS42L56_MCLK_LRCLK_256 },
688 { 12000000, 24000, CS42L56_MCLK_LRCLK_250 },
689 { 12288000, 24000, CS42L56_MCLK_LRCLK_256 },
690 { 24000000, 24000, CS42L56_MCLK_LRCLK_250 },
691 { 24576000, 24000, CS42L56_MCLK_LRCLK_256 },
692 /* 32k */
693 { 6000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
694 { 6144000, 32000, CS42L56_MCLK_LRCLK_192 },
695 { 12000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
696 { 12288000, 32000, CS42L56_MCLK_LRCLK_192 },
697 { 24000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
698 { 24576000, 32000, CS42L56_MCLK_LRCLK_192 },
699 /* 44.118k */
700 { 6000000, 44118, CS42L56_MCLK_LRCLK_136 },
701 { 12000000, 44118, CS42L56_MCLK_LRCLK_136 },
702 { 24000000, 44118, CS42L56_MCLK_LRCLK_136 },
703 /* 44.1k */
704 { 5644800, 44100, CS42L56_MCLK_LRCLK_128 },
705 { 11289600, 44100, CS42L56_MCLK_LRCLK_128 },
706 { 22579200, 44100, CS42L56_MCLK_LRCLK_128 },
707 /* 48k */
708 { 6000000, 48000, CS42L56_MCLK_LRCLK_125 },
709 { 6144000, 48000, CS42L56_MCLK_LRCLK_128 },
710 { 12000000, 48000, CS42L56_MCLK_LRCLK_125 },
711 { 12288000, 48000, CS42L56_MCLK_LRCLK_128 },
712 { 24000000, 48000, CS42L56_MCLK_LRCLK_125 },
713 { 24576000, 48000, CS42L56_MCLK_LRCLK_128 },
714 };
715
716 static int cs42l56_get_mclk_ratio(int mclk, int rate)
717 {
718 int i;
719
720 for (i = 0; i < ARRAY_SIZE(clk_ratio_table); i++) {
721 if (clk_ratio_table[i].mclk == mclk &&
722 clk_ratio_table[i].srate == rate)
723 return clk_ratio_table[i].ratio;
724 }
725 return -EINVAL;
726 }
727
728 static int cs42l56_set_sysclk(struct snd_soc_dai *codec_dai,
729 int clk_id, unsigned int freq, int dir)
730 {
731 struct snd_soc_codec *codec = codec_dai->codec;
732 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
733
734 switch (freq) {
735 case CS42L56_MCLK_5P6448MHZ:
736 case CS42L56_MCLK_6MHZ:
737 case CS42L56_MCLK_6P144MHZ:
738 cs42l56->mclk_div2 = 0;
739 cs42l56->mclk_prediv = 0;
740 break;
741 case CS42L56_MCLK_11P2896MHZ:
742 case CS42L56_MCLK_12MHZ:
743 case CS42L56_MCLK_12P288MHZ:
744 cs42l56->mclk_div2 = CS42L56_MCLK_DIV2;
745 cs42l56->mclk_prediv = 0;
746 break;
747 case CS42L56_MCLK_22P5792MHZ:
748 case CS42L56_MCLK_24MHZ:
749 case CS42L56_MCLK_24P576MHZ:
750 cs42l56->mclk_div2 = CS42L56_MCLK_DIV2;
751 cs42l56->mclk_prediv = CS42L56_MCLK_PREDIV;
752 break;
753 default:
754 return -EINVAL;
755 }
756 cs42l56->mclk = freq;
757
758 snd_soc_update_bits(codec, CS42L56_CLKCTL_1,
759 CS42L56_MCLK_PREDIV_MASK,
760 cs42l56->mclk_prediv);
761 snd_soc_update_bits(codec, CS42L56_CLKCTL_1,
762 CS42L56_MCLK_DIV2_MASK,
763 cs42l56->mclk_div2);
764
765 return 0;
766 }
767
768 static int cs42l56_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
769 {
770 struct snd_soc_codec *codec = codec_dai->codec;
771 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
772
773 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
774 case SND_SOC_DAIFMT_CBM_CFM:
775 cs42l56->iface = CS42L56_MASTER_MODE;
776 break;
777 case SND_SOC_DAIFMT_CBS_CFS:
778 cs42l56->iface = CS42L56_SLAVE_MODE;
779 break;
780 default:
781 return -EINVAL;
782 }
783
784 /* interface format */
785 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
786 case SND_SOC_DAIFMT_I2S:
787 cs42l56->iface_fmt = CS42L56_DIG_FMT_I2S;
788 break;
789 case SND_SOC_DAIFMT_LEFT_J:
790 cs42l56->iface_fmt = CS42L56_DIG_FMT_LEFT_J;
791 break;
792 default:
793 return -EINVAL;
794 }
795
796 /* sclk inversion */
797 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
798 case SND_SOC_DAIFMT_NB_NF:
799 cs42l56->iface_inv = 0;
800 break;
801 case SND_SOC_DAIFMT_IB_NF:
802 cs42l56->iface_inv = CS42L56_SCLK_INV;
803 break;
804 default:
805 return -EINVAL;
806 }
807
808 snd_soc_update_bits(codec, CS42L56_CLKCTL_1,
809 CS42L56_MS_MODE_MASK, cs42l56->iface);
810 snd_soc_update_bits(codec, CS42L56_SERIAL_FMT,
811 CS42L56_DIG_FMT_MASK, cs42l56->iface_fmt);
812 snd_soc_update_bits(codec, CS42L56_CLKCTL_1,
813 CS42L56_SCLK_INV_MASK, cs42l56->iface_inv);
814 return 0;
815 }
816
817 static int cs42l56_digital_mute(struct snd_soc_dai *dai, int mute)
818 {
819 struct snd_soc_codec *codec = dai->codec;
820
821 if (mute) {
822 /* Hit the DSP Mixer first */
823 snd_soc_update_bits(codec, CS42L56_DSP_MUTE_CTL,
824 CS42L56_ADCAMIX_MUTE_MASK |
825 CS42L56_ADCBMIX_MUTE_MASK |
826 CS42L56_PCMAMIX_MUTE_MASK |
827 CS42L56_PCMBMIX_MUTE_MASK |
828 CS42L56_MSTB_MUTE_MASK |
829 CS42L56_MSTA_MUTE_MASK,
830 CS42L56_MUTE_ALL);
831 /* Mute ADC's */
832 snd_soc_update_bits(codec, CS42L56_MISC_ADC_CTL,
833 CS42L56_ADCA_MUTE_MASK |
834 CS42L56_ADCB_MUTE_MASK,
835 CS42L56_MUTE_ALL);
836 /* HP And LO */
837 snd_soc_update_bits(codec, CS42L56_HPA_VOLUME,
838 CS42L56_HP_MUTE_MASK, CS42L56_MUTE_ALL);
839 snd_soc_update_bits(codec, CS42L56_HPB_VOLUME,
840 CS42L56_HP_MUTE_MASK, CS42L56_MUTE_ALL);
841 snd_soc_update_bits(codec, CS42L56_LOA_VOLUME,
842 CS42L56_LO_MUTE_MASK, CS42L56_MUTE_ALL);
843 snd_soc_update_bits(codec, CS42L56_LOB_VOLUME,
844 CS42L56_LO_MUTE_MASK, CS42L56_MUTE_ALL);
845 } else {
846 snd_soc_update_bits(codec, CS42L56_DSP_MUTE_CTL,
847 CS42L56_ADCAMIX_MUTE_MASK |
848 CS42L56_ADCBMIX_MUTE_MASK |
849 CS42L56_PCMAMIX_MUTE_MASK |
850 CS42L56_PCMBMIX_MUTE_MASK |
851 CS42L56_MSTB_MUTE_MASK |
852 CS42L56_MSTA_MUTE_MASK,
853 CS42L56_UNMUTE);
854
855 snd_soc_update_bits(codec, CS42L56_MISC_ADC_CTL,
856 CS42L56_ADCA_MUTE_MASK |
857 CS42L56_ADCB_MUTE_MASK,
858 CS42L56_UNMUTE);
859
860 snd_soc_update_bits(codec, CS42L56_HPA_VOLUME,
861 CS42L56_HP_MUTE_MASK, CS42L56_UNMUTE);
862 snd_soc_update_bits(codec, CS42L56_HPB_VOLUME,
863 CS42L56_HP_MUTE_MASK, CS42L56_UNMUTE);
864 snd_soc_update_bits(codec, CS42L56_LOA_VOLUME,
865 CS42L56_LO_MUTE_MASK, CS42L56_UNMUTE);
866 snd_soc_update_bits(codec, CS42L56_LOB_VOLUME,
867 CS42L56_LO_MUTE_MASK, CS42L56_UNMUTE);
868 }
869 return 0;
870 }
871
872 static int cs42l56_pcm_hw_params(struct snd_pcm_substream *substream,
873 struct snd_pcm_hw_params *params,
874 struct snd_soc_dai *dai)
875 {
876 struct snd_soc_codec *codec = dai->codec;
877 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
878 int ratio;
879
880 ratio = cs42l56_get_mclk_ratio(cs42l56->mclk, params_rate(params));
881 if (ratio >= 0) {
882 snd_soc_update_bits(codec, CS42L56_CLKCTL_2,
883 CS42L56_CLK_RATIO_MASK, ratio);
884 } else {
885 dev_err(codec->dev, "unsupported mclk/sclk/lrclk ratio\n");
886 return -EINVAL;
887 }
888
889 return 0;
890 }
891
892 static int cs42l56_set_bias_level(struct snd_soc_codec *codec,
893 enum snd_soc_bias_level level)
894 {
895 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
896 int ret;
897
898 switch (level) {
899 case SND_SOC_BIAS_ON:
900 break;
901 case SND_SOC_BIAS_PREPARE:
902 snd_soc_update_bits(codec, CS42L56_CLKCTL_1,
903 CS42L56_MCLK_DIS_MASK, 0);
904 snd_soc_update_bits(codec, CS42L56_PWRCTL_1,
905 CS42L56_PDN_ALL_MASK, 0);
906 break;
907 case SND_SOC_BIAS_STANDBY:
908 if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
909 regcache_cache_only(cs42l56->regmap, false);
910 regcache_sync(cs42l56->regmap);
911 ret = regulator_bulk_enable(ARRAY_SIZE(cs42l56->supplies),
912 cs42l56->supplies);
913 if (ret != 0) {
914 dev_err(cs42l56->dev,
915 "Failed to enable regulators: %d\n",
916 ret);
917 return ret;
918 }
919 }
920 snd_soc_update_bits(codec, CS42L56_PWRCTL_1,
921 CS42L56_PDN_ALL_MASK, 1);
922 break;
923 case SND_SOC_BIAS_OFF:
924 snd_soc_update_bits(codec, CS42L56_PWRCTL_1,
925 CS42L56_PDN_ALL_MASK, 1);
926 snd_soc_update_bits(codec, CS42L56_CLKCTL_1,
927 CS42L56_MCLK_DIS_MASK, 1);
928 regcache_cache_only(cs42l56->regmap, true);
929 regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
930 cs42l56->supplies);
931 break;
932 }
933
934 return 0;
935 }
936
937 #define CS42L56_RATES (SNDRV_PCM_RATE_8000_48000)
938
939 #define CS42L56_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S18_3LE | \
940 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE | \
941 SNDRV_PCM_FMTBIT_S32_LE)
942
943
944 static const struct snd_soc_dai_ops cs42l56_ops = {
945 .hw_params = cs42l56_pcm_hw_params,
946 .digital_mute = cs42l56_digital_mute,
947 .set_fmt = cs42l56_set_dai_fmt,
948 .set_sysclk = cs42l56_set_sysclk,
949 };
950
951 static struct snd_soc_dai_driver cs42l56_dai = {
952 .name = "cs42l56",
953 .playback = {
954 .stream_name = "HiFi Playback",
955 .channels_min = 1,
956 .channels_max = 2,
957 .rates = CS42L56_RATES,
958 .formats = CS42L56_FORMATS,
959 },
960 .capture = {
961 .stream_name = "HiFi Capture",
962 .channels_min = 1,
963 .channels_max = 2,
964 .rates = CS42L56_RATES,
965 .formats = CS42L56_FORMATS,
966 },
967 .ops = &cs42l56_ops,
968 };
969
970 static int beep_freq[] = {
971 261, 522, 585, 667, 706, 774, 889, 1000,
972 1043, 1200, 1333, 1412, 1600, 1714, 2000, 2182
973 };
974
975 static void cs42l56_beep_work(struct work_struct *work)
976 {
977 struct cs42l56_private *cs42l56 =
978 container_of(work, struct cs42l56_private, beep_work);
979 struct snd_soc_codec *codec = cs42l56->codec;
980 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
981 int i;
982 int val = 0;
983 int best = 0;
984
985 if (cs42l56->beep_rate) {
986 for (i = 0; i < ARRAY_SIZE(beep_freq); i++) {
987 if (abs(cs42l56->beep_rate - beep_freq[i]) <
988 abs(cs42l56->beep_rate - beep_freq[best]))
989 best = i;
990 }
991
992 dev_dbg(codec->dev, "Set beep rate %dHz for requested %dHz\n",
993 beep_freq[best], cs42l56->beep_rate);
994
995 val = (best << CS42L56_BEEP_RATE_SHIFT);
996
997 snd_soc_dapm_enable_pin(dapm, "Beep");
998 } else {
999 dev_dbg(codec->dev, "Disabling beep\n");
1000 snd_soc_dapm_disable_pin(dapm, "Beep");
1001 }
1002
1003 snd_soc_update_bits(codec, CS42L56_BEEP_FREQ_ONTIME,
1004 CS42L56_BEEP_FREQ_MASK, val);
1005
1006 snd_soc_dapm_sync(dapm);
1007 }
1008
1009 /* For usability define a way of injecting beep events for the device -
1010 * many systems will not have a keyboard.
1011 */
1012 static int cs42l56_beep_event(struct input_dev *dev, unsigned int type,
1013 unsigned int code, int hz)
1014 {
1015 struct snd_soc_codec *codec = input_get_drvdata(dev);
1016 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
1017
1018 dev_dbg(codec->dev, "Beep event %x %x\n", code, hz);
1019
1020 switch (code) {
1021 case SND_BELL:
1022 if (hz)
1023 hz = 261;
1024 case SND_TONE:
1025 break;
1026 default:
1027 return -1;
1028 }
1029
1030 /* Kick the beep from a workqueue */
1031 cs42l56->beep_rate = hz;
1032 schedule_work(&cs42l56->beep_work);
1033 return 0;
1034 }
1035
1036 static ssize_t cs42l56_beep_set(struct device *dev,
1037 struct device_attribute *attr,
1038 const char *buf, size_t count)
1039 {
1040 struct cs42l56_private *cs42l56 = dev_get_drvdata(dev);
1041 long int time;
1042 int ret;
1043
1044 ret = kstrtol(buf, 10, &time);
1045 if (ret != 0)
1046 return ret;
1047
1048 input_event(cs42l56->beep, EV_SND, SND_TONE, time);
1049
1050 return count;
1051 }
1052
1053 static DEVICE_ATTR(beep, 0200, NULL, cs42l56_beep_set);
1054
1055 static void cs42l56_init_beep(struct snd_soc_codec *codec)
1056 {
1057 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
1058 int ret;
1059
1060 cs42l56->beep = devm_input_allocate_device(codec->dev);
1061 if (!cs42l56->beep) {
1062 dev_err(codec->dev, "Failed to allocate beep device\n");
1063 return;
1064 }
1065
1066 INIT_WORK(&cs42l56->beep_work, cs42l56_beep_work);
1067 cs42l56->beep_rate = 0;
1068
1069 cs42l56->beep->name = "CS42L56 Beep Generator";
1070 cs42l56->beep->phys = dev_name(codec->dev);
1071 cs42l56->beep->id.bustype = BUS_I2C;
1072
1073 cs42l56->beep->evbit[0] = BIT_MASK(EV_SND);
1074 cs42l56->beep->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
1075 cs42l56->beep->event = cs42l56_beep_event;
1076 cs42l56->beep->dev.parent = codec->dev;
1077 input_set_drvdata(cs42l56->beep, codec);
1078
1079 ret = input_register_device(cs42l56->beep);
1080 if (ret != 0) {
1081 cs42l56->beep = NULL;
1082 dev_err(codec->dev, "Failed to register beep device\n");
1083 }
1084
1085 ret = device_create_file(codec->dev, &dev_attr_beep);
1086 if (ret != 0) {
1087 dev_err(codec->dev, "Failed to create keyclick file: %d\n",
1088 ret);
1089 }
1090 }
1091
1092 static void cs42l56_free_beep(struct snd_soc_codec *codec)
1093 {
1094 struct cs42l56_private *cs42l56 = snd_soc_codec_get_drvdata(codec);
1095
1096 device_remove_file(codec->dev, &dev_attr_beep);
1097 cancel_work_sync(&cs42l56->beep_work);
1098 cs42l56->beep = NULL;
1099
1100 snd_soc_update_bits(codec, CS42L56_BEEP_TONE_CFG,
1101 CS42L56_BEEP_EN_MASK, 0);
1102 }
1103
1104 static int cs42l56_probe(struct snd_soc_codec *codec)
1105 {
1106 cs42l56_init_beep(codec);
1107
1108 return 0;
1109 }
1110
1111 static int cs42l56_remove(struct snd_soc_codec *codec)
1112 {
1113 cs42l56_free_beep(codec);
1114
1115 return 0;
1116 }
1117
1118 static const struct snd_soc_codec_driver soc_codec_dev_cs42l56 = {
1119 .probe = cs42l56_probe,
1120 .remove = cs42l56_remove,
1121 .set_bias_level = cs42l56_set_bias_level,
1122 .suspend_bias_off = true,
1123
1124 .component_driver = {
1125 .controls = cs42l56_snd_controls,
1126 .num_controls = ARRAY_SIZE(cs42l56_snd_controls),
1127 .dapm_widgets = cs42l56_dapm_widgets,
1128 .num_dapm_widgets = ARRAY_SIZE(cs42l56_dapm_widgets),
1129 .dapm_routes = cs42l56_audio_map,
1130 .num_dapm_routes = ARRAY_SIZE(cs42l56_audio_map),
1131 },
1132 };
1133
1134 static const struct regmap_config cs42l56_regmap = {
1135 .reg_bits = 8,
1136 .val_bits = 8,
1137
1138 .max_register = CS42L56_MAX_REGISTER,
1139 .reg_defaults = cs42l56_reg_defaults,
1140 .num_reg_defaults = ARRAY_SIZE(cs42l56_reg_defaults),
1141 .readable_reg = cs42l56_readable_register,
1142 .volatile_reg = cs42l56_volatile_register,
1143 .cache_type = REGCACHE_RBTREE,
1144 };
1145
1146 static int cs42l56_handle_of_data(struct i2c_client *i2c_client,
1147 struct cs42l56_platform_data *pdata)
1148 {
1149 struct device_node *np = i2c_client->dev.of_node;
1150 u32 val32;
1151
1152 if (of_property_read_bool(np, "cirrus,ain1a-reference-cfg"))
1153 pdata->ain1a_ref_cfg = true;
1154
1155 if (of_property_read_bool(np, "cirrus,ain2a-reference-cfg"))
1156 pdata->ain2a_ref_cfg = true;
1157
1158 if (of_property_read_bool(np, "cirrus,ain1b-reference-cfg"))
1159 pdata->ain1b_ref_cfg = true;
1160
1161 if (of_property_read_bool(np, "cirrus,ain2b-reference-cfg"))
1162 pdata->ain2b_ref_cfg = true;
1163
1164 if (of_property_read_u32(np, "cirrus,micbias-lvl", &val32) >= 0)
1165 pdata->micbias_lvl = val32;
1166
1167 if (of_property_read_u32(np, "cirrus,chgfreq-divisor", &val32) >= 0)
1168 pdata->chgfreq = val32;
1169
1170 if (of_property_read_u32(np, "cirrus,adaptive-pwr-cfg", &val32) >= 0)
1171 pdata->adaptive_pwr = val32;
1172
1173 if (of_property_read_u32(np, "cirrus,hpf-left-freq", &val32) >= 0)
1174 pdata->hpfa_freq = val32;
1175
1176 if (of_property_read_u32(np, "cirrus,hpf-left-freq", &val32) >= 0)
1177 pdata->hpfb_freq = val32;
1178
1179 pdata->gpio_nreset = of_get_named_gpio(np, "cirrus,gpio-nreset", 0);
1180
1181 return 0;
1182 }
1183
1184 static int cs42l56_i2c_probe(struct i2c_client *i2c_client,
1185 const struct i2c_device_id *id)
1186 {
1187 struct cs42l56_private *cs42l56;
1188 struct cs42l56_platform_data *pdata =
1189 dev_get_platdata(&i2c_client->dev);
1190 int ret, i;
1191 unsigned int devid = 0;
1192 unsigned int alpha_rev, metal_rev;
1193 unsigned int reg;
1194
1195 cs42l56 = devm_kzalloc(&i2c_client->dev,
1196 sizeof(struct cs42l56_private),
1197 GFP_KERNEL);
1198 if (cs42l56 == NULL)
1199 return -ENOMEM;
1200 cs42l56->dev = &i2c_client->dev;
1201
1202 cs42l56->regmap = devm_regmap_init_i2c(i2c_client, &cs42l56_regmap);
1203 if (IS_ERR(cs42l56->regmap)) {
1204 ret = PTR_ERR(cs42l56->regmap);
1205 dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret);
1206 return ret;
1207 }
1208
1209 if (pdata) {
1210 cs42l56->pdata = *pdata;
1211 } else {
1212 pdata = devm_kzalloc(&i2c_client->dev,
1213 sizeof(struct cs42l56_platform_data),
1214 GFP_KERNEL);
1215 if (!pdata) {
1216 dev_err(&i2c_client->dev,
1217 "could not allocate pdata\n");
1218 return -ENOMEM;
1219 }
1220 if (i2c_client->dev.of_node) {
1221 ret = cs42l56_handle_of_data(i2c_client,
1222 &cs42l56->pdata);
1223 if (ret != 0)
1224 return ret;
1225 }
1226 cs42l56->pdata = *pdata;
1227 }
1228
1229 if (cs42l56->pdata.gpio_nreset) {
1230 ret = gpio_request_one(cs42l56->pdata.gpio_nreset,
1231 GPIOF_OUT_INIT_HIGH, "CS42L56 /RST");
1232 if (ret < 0) {
1233 dev_err(&i2c_client->dev,
1234 "Failed to request /RST %d: %d\n",
1235 cs42l56->pdata.gpio_nreset, ret);
1236 return ret;
1237 }
1238 gpio_set_value_cansleep(cs42l56->pdata.gpio_nreset, 0);
1239 gpio_set_value_cansleep(cs42l56->pdata.gpio_nreset, 1);
1240 }
1241
1242
1243 i2c_set_clientdata(i2c_client, cs42l56);
1244
1245 for (i = 0; i < ARRAY_SIZE(cs42l56->supplies); i++)
1246 cs42l56->supplies[i].supply = cs42l56_supply_names[i];
1247
1248 ret = devm_regulator_bulk_get(&i2c_client->dev,
1249 ARRAY_SIZE(cs42l56->supplies),
1250 cs42l56->supplies);
1251 if (ret != 0) {
1252 dev_err(&i2c_client->dev,
1253 "Failed to request supplies: %d\n", ret);
1254 return ret;
1255 }
1256
1257 ret = regulator_bulk_enable(ARRAY_SIZE(cs42l56->supplies),
1258 cs42l56->supplies);
1259 if (ret != 0) {
1260 dev_err(&i2c_client->dev,
1261 "Failed to enable supplies: %d\n", ret);
1262 return ret;
1263 }
1264
1265 regcache_cache_bypass(cs42l56->regmap, true);
1266
1267 ret = regmap_read(cs42l56->regmap, CS42L56_CHIP_ID_1, &reg);
1268 devid = reg & CS42L56_CHIP_ID_MASK;
1269 if (devid != CS42L56_DEVID) {
1270 dev_err(&i2c_client->dev,
1271 "CS42L56 Device ID (%X). Expected %X\n",
1272 devid, CS42L56_DEVID);
1273 goto err_enable;
1274 }
1275 alpha_rev = reg & CS42L56_AREV_MASK;
1276 metal_rev = reg & CS42L56_MTLREV_MASK;
1277
1278 dev_info(&i2c_client->dev, "Cirrus Logic CS42L56 ");
1279 dev_info(&i2c_client->dev, "Alpha Rev %X Metal Rev %X\n",
1280 alpha_rev, metal_rev);
1281
1282 regcache_cache_bypass(cs42l56->regmap, false);
1283
1284 if (cs42l56->pdata.ain1a_ref_cfg)
1285 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1286 CS42L56_AIN1A_REF_MASK, 1);
1287
1288 if (cs42l56->pdata.ain1b_ref_cfg)
1289 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1290 CS42L56_AIN1B_REF_MASK, 1);
1291
1292 if (cs42l56->pdata.ain2a_ref_cfg)
1293 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1294 CS42L56_AIN2A_REF_MASK, 1);
1295
1296 if (cs42l56->pdata.ain2b_ref_cfg)
1297 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1298 CS42L56_AIN2B_REF_MASK, 1);
1299
1300 if (cs42l56->pdata.micbias_lvl)
1301 regmap_update_bits(cs42l56->regmap, CS42L56_GAIN_BIAS_CTL,
1302 CS42L56_MIC_BIAS_MASK,
1303 cs42l56->pdata.micbias_lvl);
1304
1305 if (cs42l56->pdata.chgfreq)
1306 regmap_update_bits(cs42l56->regmap, CS42L56_CLASSH_CTL,
1307 CS42L56_CHRG_FREQ_MASK,
1308 cs42l56->pdata.chgfreq);
1309
1310 if (cs42l56->pdata.hpfb_freq)
1311 regmap_update_bits(cs42l56->regmap, CS42L56_HPF_CTL,
1312 CS42L56_HPFB_FREQ_MASK,
1313 cs42l56->pdata.hpfb_freq);
1314
1315 if (cs42l56->pdata.hpfa_freq)
1316 regmap_update_bits(cs42l56->regmap, CS42L56_HPF_CTL,
1317 CS42L56_HPFA_FREQ_MASK,
1318 cs42l56->pdata.hpfa_freq);
1319
1320 if (cs42l56->pdata.adaptive_pwr)
1321 regmap_update_bits(cs42l56->regmap, CS42L56_CLASSH_CTL,
1322 CS42L56_ADAPT_PWR_MASK,
1323 cs42l56->pdata.adaptive_pwr);
1324
1325 ret = snd_soc_register_codec(&i2c_client->dev,
1326 &soc_codec_dev_cs42l56, &cs42l56_dai, 1);
1327 if (ret < 0)
1328 return ret;
1329
1330 return 0;
1331
1332 err_enable:
1333 regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
1334 cs42l56->supplies);
1335 return ret;
1336 }
1337
1338 static int cs42l56_i2c_remove(struct i2c_client *client)
1339 {
1340 struct cs42l56_private *cs42l56 = i2c_get_clientdata(client);
1341
1342 snd_soc_unregister_codec(&client->dev);
1343 regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
1344 cs42l56->supplies);
1345 return 0;
1346 }
1347
1348 static const struct of_device_id cs42l56_of_match[] = {
1349 { .compatible = "cirrus,cs42l56", },
1350 { }
1351 };
1352 MODULE_DEVICE_TABLE(of, cs42l56_of_match);
1353
1354
1355 static const struct i2c_device_id cs42l56_id[] = {
1356 { "cs42l56", 0 },
1357 { }
1358 };
1359 MODULE_DEVICE_TABLE(i2c, cs42l56_id);
1360
1361 static struct i2c_driver cs42l56_i2c_driver = {
1362 .driver = {
1363 .name = "cs42l56",
1364 .of_match_table = cs42l56_of_match,
1365 },
1366 .id_table = cs42l56_id,
1367 .probe = cs42l56_i2c_probe,
1368 .remove = cs42l56_i2c_remove,
1369 };
1370
1371 module_i2c_driver(cs42l56_i2c_driver);
1372
1373 MODULE_DESCRIPTION("ASoC CS42L56 driver");
1374 MODULE_AUTHOR("Brian Austin, Cirrus Logic Inc, <brian.austin@cirrus.com>");
1375 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.05953 seconds and 5 git commands to generate.