Commit | Line | Data |
---|---|---|
3be58dbb RK |
1 | /* |
2 | * ASoC codec driver for spear platform | |
3 | * | |
4 | * sound/soc/codecs/sta529.c -- spear ALSA Soc codec driver | |
5 | * | |
6 | * Copyright (C) 2012 ST Microelectronics | |
7 | * Rajeev Kumar <rajeev-dlh.kumar@st.com> | |
8 | * | |
9 | * This file is licensed under the terms of the GNU General Public | |
10 | * License version 2. This program is licensed "as is" without any | |
11 | * warranty of any kind, whether express or implied. | |
12 | */ | |
13 | ||
14 | #include <linux/clk.h> | |
15 | #include <linux/init.h> | |
16 | #include <linux/i2c.h> | |
17 | #include <linux/io.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/moduleparam.h> | |
20 | #include <linux/pm.h> | |
21 | #include <linux/regmap.h> | |
22 | #include <linux/slab.h> | |
23 | ||
24 | #include <sound/core.h> | |
25 | #include <sound/initval.h> | |
26 | #include <sound/pcm.h> | |
27 | #include <sound/pcm_params.h> | |
28 | #include <sound/soc.h> | |
29 | #include <sound/soc-dapm.h> | |
30 | #include <sound/tlv.h> | |
31 | ||
32 | /* STA529 Register offsets */ | |
33 | #define STA529_FFXCFG0 0x00 | |
34 | #define STA529_FFXCFG1 0x01 | |
35 | #define STA529_MVOL 0x02 | |
36 | #define STA529_LVOL 0x03 | |
37 | #define STA529_RVOL 0x04 | |
38 | #define STA529_TTF0 0x05 | |
39 | #define STA529_TTF1 0x06 | |
40 | #define STA529_TTP0 0x07 | |
41 | #define STA529_TTP1 0x08 | |
42 | #define STA529_S2PCFG0 0x0A | |
43 | #define STA529_S2PCFG1 0x0B | |
44 | #define STA529_P2SCFG0 0x0C | |
45 | #define STA529_P2SCFG1 0x0D | |
46 | #define STA529_PLLCFG0 0x14 | |
47 | #define STA529_PLLCFG1 0x15 | |
48 | #define STA529_PLLCFG2 0x16 | |
49 | #define STA529_PLLCFG3 0x17 | |
50 | #define STA529_PLLPFE 0x18 | |
51 | #define STA529_PLLST 0x19 | |
52 | #define STA529_ADCCFG 0x1E /*mic_select*/ | |
53 | #define STA529_CKOCFG 0x1F | |
54 | #define STA529_MISC 0x20 | |
55 | #define STA529_PADST0 0x21 | |
56 | #define STA529_PADST1 0x22 | |
57 | #define STA529_FFXST 0x23 | |
58 | #define STA529_PWMIN1 0x2D | |
59 | #define STA529_PWMIN2 0x2E | |
60 | #define STA529_POWST 0x32 | |
61 | ||
62 | #define STA529_MAX_REGISTER 0x32 | |
63 | ||
64 | #define STA529_RATES (SNDRV_PCM_RATE_8000 | \ | |
65 | SNDRV_PCM_RATE_11025 | \ | |
66 | SNDRV_PCM_RATE_16000 | \ | |
67 | SNDRV_PCM_RATE_22050 | \ | |
68 | SNDRV_PCM_RATE_32000 | \ | |
69 | SNDRV_PCM_RATE_44100 | \ | |
70 | SNDRV_PCM_RATE_48000) | |
71 | ||
72 | #define STA529_FORMAT (SNDRV_PCM_FMTBIT_S16_LE | \ | |
73 | SNDRV_PCM_FMTBIT_S24_LE | \ | |
74 | SNDRV_PCM_FMTBIT_S32_LE) | |
75 | #define S2PC_VALUE 0x98 | |
76 | #define CLOCK_OUT 0x60 | |
ad1937cd AL |
77 | #define DATA_FORMAT_MSK 0x0E |
78 | #define LEFT_J_DATA_FORMAT 0x00 | |
79 | #define I2S_DATA_FORMAT 0x02 | |
80 | #define RIGHT_J_DATA_FORMAT 0x04 | |
3be58dbb RK |
81 | #define CODEC_MUTE_VAL 0x80 |
82 | ||
83 | #define POWER_CNTLMSAK 0x40 | |
84 | #define POWER_STDBY 0x40 | |
85 | #define FFX_MASK 0x80 | |
86 | #define FFX_OFF 0x80 | |
87 | #define POWER_UP 0x00 | |
88 | #define FFX_CLK_ENB 0x01 | |
89 | #define FFX_CLK_DIS 0x00 | |
90 | #define FFX_CLK_MSK 0x01 | |
91 | #define PLAY_FREQ_RANGE_MSK 0x70 | |
92 | #define CAP_FREQ_RANGE_MSK 0x0C | |
93 | #define PDATA_LEN_MSK 0xC0 | |
94 | #define BCLK_TO_FS_MSK 0x30 | |
95 | #define AUDIO_MUTE_MSK 0x80 | |
96 | ||
97 | static const struct reg_default sta529_reg_defaults[] = { | |
98 | { 0, 0x35 }, /* R0 - FFX Configuration reg 0 */ | |
99 | { 1, 0xc8 }, /* R1 - FFX Configuration reg 1 */ | |
100 | { 2, 0x50 }, /* R2 - Master Volume */ | |
101 | { 3, 0x00 }, /* R3 - Left Volume */ | |
102 | { 4, 0x00 }, /* R4 - Right Volume */ | |
103 | { 10, 0xb2 }, /* R10 - S2P Config Reg 0 */ | |
104 | { 11, 0x41 }, /* R11 - S2P Config Reg 1 */ | |
105 | { 12, 0x92 }, /* R12 - P2S Config Reg 0 */ | |
106 | { 13, 0x41 }, /* R13 - P2S Config Reg 1 */ | |
107 | { 30, 0xd2 }, /* R30 - ADC Config Reg */ | |
108 | { 31, 0x40 }, /* R31 - clock Out Reg */ | |
109 | { 32, 0x21 }, /* R32 - Misc Register */ | |
110 | }; | |
111 | ||
112 | struct sta529 { | |
113 | struct regmap *regmap; | |
114 | }; | |
115 | ||
116 | static bool sta529_readable(struct device *dev, unsigned int reg) | |
117 | { | |
118 | switch (reg) { | |
119 | ||
120 | case STA529_FFXCFG0: | |
121 | case STA529_FFXCFG1: | |
122 | case STA529_MVOL: | |
123 | case STA529_LVOL: | |
124 | case STA529_RVOL: | |
125 | case STA529_S2PCFG0: | |
126 | case STA529_S2PCFG1: | |
127 | case STA529_P2SCFG0: | |
128 | case STA529_P2SCFG1: | |
129 | case STA529_ADCCFG: | |
130 | case STA529_CKOCFG: | |
131 | case STA529_MISC: | |
132 | return true; | |
133 | default: | |
134 | return false; | |
135 | } | |
136 | } | |
137 | ||
138 | ||
139 | static const char *pwm_mode_text[] = { "Binary", "Headphone", "Ternary", | |
140 | "Phase-shift"}; | |
141 | ||
142 | static const DECLARE_TLV_DB_SCALE(out_gain_tlv, -9150, 50, 0); | |
143 | static const DECLARE_TLV_DB_SCALE(master_vol_tlv, -12750, 50, 0); | |
f2812054 | 144 | static SOC_ENUM_SINGLE_DECL(pwm_src, STA529_FFXCFG1, 4, pwm_mode_text); |
3be58dbb RK |
145 | |
146 | static const struct snd_kcontrol_new sta529_snd_controls[] = { | |
147 | SOC_DOUBLE_R_TLV("Digital Playback Volume", STA529_LVOL, STA529_RVOL, 0, | |
148 | 127, 0, out_gain_tlv), | |
149 | SOC_SINGLE_TLV("Master Playback Volume", STA529_MVOL, 0, 127, 1, | |
150 | master_vol_tlv), | |
151 | SOC_ENUM("PWM Select", pwm_src), | |
152 | }; | |
153 | ||
154 | static int sta529_set_bias_level(struct snd_soc_codec *codec, enum | |
155 | snd_soc_bias_level level) | |
156 | { | |
157 | struct sta529 *sta529 = snd_soc_codec_get_drvdata(codec); | |
158 | ||
159 | switch (level) { | |
160 | case SND_SOC_BIAS_ON: | |
161 | case SND_SOC_BIAS_PREPARE: | |
162 | snd_soc_update_bits(codec, STA529_FFXCFG0, POWER_CNTLMSAK, | |
163 | POWER_UP); | |
164 | snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK, | |
165 | FFX_CLK_ENB); | |
166 | break; | |
167 | case SND_SOC_BIAS_STANDBY: | |
168 | if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) | |
169 | regcache_sync(sta529->regmap); | |
170 | snd_soc_update_bits(codec, STA529_FFXCFG0, | |
171 | POWER_CNTLMSAK, POWER_STDBY); | |
172 | /* Making FFX output to zero */ | |
173 | snd_soc_update_bits(codec, STA529_FFXCFG0, FFX_MASK, | |
174 | FFX_OFF); | |
175 | snd_soc_update_bits(codec, STA529_MISC, FFX_CLK_MSK, | |
176 | FFX_CLK_DIS); | |
177 | break; | |
178 | case SND_SOC_BIAS_OFF: | |
179 | break; | |
180 | } | |
181 | ||
182 | /* | |
183 | * store the label for powers down audio subsystem for suspend.This is | |
184 | * used by soc core layer | |
185 | */ | |
186 | codec->dapm.bias_level = level; | |
187 | ||
188 | return 0; | |
189 | ||
190 | } | |
191 | ||
192 | static int sta529_hw_params(struct snd_pcm_substream *substream, | |
193 | struct snd_pcm_hw_params *params, | |
194 | struct snd_soc_dai *dai) | |
195 | { | |
ab64246c | 196 | struct snd_soc_codec *codec = dai->codec; |
3be58dbb RK |
197 | int pdata, play_freq_val, record_freq_val; |
198 | int bclk_to_fs_ratio; | |
199 | ||
200 | switch (params_format(params)) { | |
201 | case SNDRV_PCM_FORMAT_S16_LE: | |
202 | pdata = 1; | |
203 | bclk_to_fs_ratio = 0; | |
204 | break; | |
205 | case SNDRV_PCM_FORMAT_S24_LE: | |
206 | pdata = 2; | |
207 | bclk_to_fs_ratio = 1; | |
208 | break; | |
209 | case SNDRV_PCM_FORMAT_S32_LE: | |
210 | pdata = 3; | |
211 | bclk_to_fs_ratio = 2; | |
212 | break; | |
213 | default: | |
214 | dev_err(codec->dev, "Unsupported format\n"); | |
215 | return -EINVAL; | |
216 | } | |
217 | ||
218 | switch (params_rate(params)) { | |
219 | case 8000: | |
220 | case 11025: | |
221 | play_freq_val = 0; | |
222 | record_freq_val = 2; | |
223 | break; | |
224 | case 16000: | |
225 | case 22050: | |
226 | play_freq_val = 1; | |
227 | record_freq_val = 0; | |
228 | break; | |
229 | ||
230 | case 32000: | |
231 | case 44100: | |
232 | case 48000: | |
233 | play_freq_val = 2; | |
234 | record_freq_val = 0; | |
235 | break; | |
236 | default: | |
237 | dev_err(codec->dev, "Unsupported rate\n"); | |
238 | return -EINVAL; | |
239 | } | |
240 | ||
241 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { | |
242 | snd_soc_update_bits(codec, STA529_S2PCFG1, PDATA_LEN_MSK, | |
243 | pdata << 6); | |
244 | snd_soc_update_bits(codec, STA529_S2PCFG1, BCLK_TO_FS_MSK, | |
245 | bclk_to_fs_ratio << 4); | |
246 | snd_soc_update_bits(codec, STA529_MISC, PLAY_FREQ_RANGE_MSK, | |
247 | play_freq_val << 4); | |
248 | } else { | |
249 | snd_soc_update_bits(codec, STA529_P2SCFG1, PDATA_LEN_MSK, | |
250 | pdata << 6); | |
251 | snd_soc_update_bits(codec, STA529_P2SCFG1, BCLK_TO_FS_MSK, | |
252 | bclk_to_fs_ratio << 4); | |
253 | snd_soc_update_bits(codec, STA529_MISC, CAP_FREQ_RANGE_MSK, | |
254 | record_freq_val << 2); | |
255 | } | |
256 | ||
257 | return 0; | |
258 | } | |
259 | ||
260 | static int sta529_mute(struct snd_soc_dai *dai, int mute) | |
261 | { | |
262 | u8 val = 0; | |
263 | ||
264 | if (mute) | |
265 | val |= CODEC_MUTE_VAL; | |
266 | ||
267 | snd_soc_update_bits(dai->codec, STA529_FFXCFG0, AUDIO_MUTE_MSK, val); | |
268 | ||
269 | return 0; | |
270 | } | |
271 | ||
272 | static int sta529_set_dai_fmt(struct snd_soc_dai *codec_dai, u32 fmt) | |
273 | { | |
274 | struct snd_soc_codec *codec = codec_dai->codec; | |
275 | u8 mode = 0; | |
276 | ||
277 | /* interface format */ | |
278 | switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { | |
279 | case SND_SOC_DAIFMT_LEFT_J: | |
280 | mode = LEFT_J_DATA_FORMAT; | |
281 | break; | |
282 | case SND_SOC_DAIFMT_I2S: | |
283 | mode = I2S_DATA_FORMAT; | |
284 | break; | |
285 | case SND_SOC_DAIFMT_RIGHT_J: | |
286 | mode = RIGHT_J_DATA_FORMAT; | |
287 | break; | |
288 | default: | |
289 | return -EINVAL; | |
290 | } | |
291 | ||
ad1937cd | 292 | snd_soc_update_bits(codec, STA529_S2PCFG0, DATA_FORMAT_MSK, mode); |
3be58dbb RK |
293 | |
294 | return 0; | |
295 | } | |
296 | ||
297 | static const struct snd_soc_dai_ops sta529_dai_ops = { | |
298 | .hw_params = sta529_hw_params, | |
299 | .set_fmt = sta529_set_dai_fmt, | |
300 | .digital_mute = sta529_mute, | |
301 | }; | |
302 | ||
303 | static struct snd_soc_dai_driver sta529_dai = { | |
304 | .name = "sta529-audio", | |
305 | .playback = { | |
306 | .stream_name = "Playback", | |
307 | .channels_min = 2, | |
308 | .channels_max = 2, | |
309 | .rates = STA529_RATES, | |
310 | .formats = STA529_FORMAT, | |
311 | }, | |
312 | .capture = { | |
313 | .stream_name = "Capture", | |
314 | .channels_min = 2, | |
315 | .channels_max = 2, | |
316 | .rates = STA529_RATES, | |
317 | .formats = STA529_FORMAT, | |
318 | }, | |
319 | .ops = &sta529_dai_ops, | |
320 | }; | |
321 | ||
322 | static int sta529_probe(struct snd_soc_codec *codec) | |
323 | { | |
3be58dbb RK |
324 | sta529_set_bias_level(codec, SND_SOC_BIAS_STANDBY); |
325 | ||
326 | return 0; | |
327 | } | |
328 | ||
329 | /* power down chip */ | |
330 | static int sta529_remove(struct snd_soc_codec *codec) | |
331 | { | |
332 | sta529_set_bias_level(codec, SND_SOC_BIAS_OFF); | |
333 | ||
334 | return 0; | |
335 | } | |
336 | ||
337 | static int sta529_suspend(struct snd_soc_codec *codec) | |
338 | { | |
339 | sta529_set_bias_level(codec, SND_SOC_BIAS_OFF); | |
340 | ||
341 | return 0; | |
342 | } | |
343 | ||
344 | static int sta529_resume(struct snd_soc_codec *codec) | |
345 | { | |
346 | sta529_set_bias_level(codec, SND_SOC_BIAS_STANDBY); | |
347 | ||
348 | return 0; | |
349 | } | |
350 | ||
1427cc37 | 351 | static const struct snd_soc_codec_driver sta529_codec_driver = { |
3be58dbb RK |
352 | .probe = sta529_probe, |
353 | .remove = sta529_remove, | |
354 | .set_bias_level = sta529_set_bias_level, | |
355 | .suspend = sta529_suspend, | |
356 | .resume = sta529_resume, | |
357 | .controls = sta529_snd_controls, | |
358 | .num_controls = ARRAY_SIZE(sta529_snd_controls), | |
359 | }; | |
360 | ||
361 | static const struct regmap_config sta529_regmap = { | |
362 | .reg_bits = 8, | |
363 | .val_bits = 8, | |
364 | ||
365 | .max_register = STA529_MAX_REGISTER, | |
366 | .readable_reg = sta529_readable, | |
367 | ||
368 | .cache_type = REGCACHE_RBTREE, | |
369 | .reg_defaults = sta529_reg_defaults, | |
370 | .num_reg_defaults = ARRAY_SIZE(sta529_reg_defaults), | |
371 | }; | |
372 | ||
7a79e94e BP |
373 | static int sta529_i2c_probe(struct i2c_client *i2c, |
374 | const struct i2c_device_id *id) | |
3be58dbb RK |
375 | { |
376 | struct sta529 *sta529; | |
377 | int ret; | |
378 | ||
379 | if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | |
380 | return -EINVAL; | |
381 | ||
382 | sta529 = devm_kzalloc(&i2c->dev, sizeof(struct sta529), GFP_KERNEL); | |
383 | if (sta529 == NULL) { | |
384 | dev_err(&i2c->dev, "Can not allocate memory\n"); | |
385 | return -ENOMEM; | |
386 | } | |
387 | ||
388 | sta529->regmap = devm_regmap_init_i2c(i2c, &sta529_regmap); | |
389 | if (IS_ERR(sta529->regmap)) { | |
f96985e3 | 390 | ret = PTR_ERR(sta529->regmap); |
3be58dbb | 391 | dev_err(&i2c->dev, "Failed to allocate regmap: %d\n", ret); |
f96985e3 | 392 | return ret; |
3be58dbb RK |
393 | } |
394 | ||
395 | i2c_set_clientdata(i2c, sta529); | |
396 | ||
397 | ret = snd_soc_register_codec(&i2c->dev, | |
398 | &sta529_codec_driver, &sta529_dai, 1); | |
399 | if (ret != 0) | |
400 | dev_err(&i2c->dev, "Failed to register CODEC: %d\n", ret); | |
401 | ||
402 | return ret; | |
403 | } | |
404 | ||
7a79e94e | 405 | static int sta529_i2c_remove(struct i2c_client *client) |
3be58dbb RK |
406 | { |
407 | snd_soc_unregister_codec(&client->dev); | |
408 | ||
409 | return 0; | |
410 | } | |
411 | ||
412 | static const struct i2c_device_id sta529_i2c_id[] = { | |
413 | { "sta529", 0 }, | |
414 | { } | |
415 | }; | |
416 | MODULE_DEVICE_TABLE(i2c, sta529_i2c_id); | |
417 | ||
418 | static struct i2c_driver sta529_i2c_driver = { | |
419 | .driver = { | |
420 | .name = "sta529", | |
421 | .owner = THIS_MODULE, | |
422 | }, | |
423 | .probe = sta529_i2c_probe, | |
7a79e94e | 424 | .remove = sta529_i2c_remove, |
3be58dbb RK |
425 | .id_table = sta529_i2c_id, |
426 | }; | |
427 | ||
428 | module_i2c_driver(sta529_i2c_driver); | |
429 | ||
430 | MODULE_DESCRIPTION("ASoC STA529 codec driver"); | |
431 | MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>"); | |
432 | MODULE_LICENSE("GPL"); |