1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) ST-Ericsson SA 2012 |
4 | * |
5 | * Author: Ola Lilja <ola.o.lilja@stericsson.com>, |
6 | * Kristoffer Karlsson <kristoffer.karlsson@stericsson.com> |
7 | * for ST-Ericsson. |
8 | */ |
9 | |
10 | #include <linux/module.h> |
11 | #include <linux/device.h> |
12 | #include <linux/io.h> |
13 | #include <linux/clk.h> |
14 | #include <linux/mutex.h> |
15 | |
16 | #include <sound/soc.h> |
17 | #include <sound/soc-dapm.h> |
18 | #include <sound/pcm.h> |
19 | #include <sound/pcm_params.h> |
20 | |
21 | #include "ux500_pcm.h" |
22 | #include "ux500_msp_dai.h" |
23 | #include "mop500_ab8500.h" |
24 | #include "../codecs/ab8500-codec.h" |
25 | |
26 | #define TX_SLOT_MONO 0x0008 |
27 | #define TX_SLOT_STEREO 0x000a |
28 | #define RX_SLOT_MONO 0x0001 |
29 | #define RX_SLOT_STEREO 0x0003 |
30 | #define TX_SLOT_8CH 0x00FF |
31 | #define RX_SLOT_8CH 0x00FF |
32 | |
33 | #define DEF_TX_SLOTS TX_SLOT_STEREO |
34 | #define DEF_RX_SLOTS RX_SLOT_MONO |
35 | |
36 | #define DRIVERMODE_NORMAL 0 |
37 | #define DRIVERMODE_CODEC_ONLY 1 |
38 | |
39 | /* Slot configuration */ |
40 | static unsigned int tx_slots = DEF_TX_SLOTS; |
41 | static unsigned int rx_slots = DEF_RX_SLOTS; |
42 | |
43 | /* Configuration consistency parameters */ |
44 | static DEFINE_MUTEX(mop500_ab8500_params_lock); |
45 | static unsigned long mop500_ab8500_usage; |
46 | static int mop500_ab8500_rate; |
47 | static int mop500_ab8500_channels; |
48 | |
49 | /* Clocks */ |
50 | static const char * const enum_mclk[] = { |
51 | "SYSCLK" , |
52 | "ULPCLK" |
53 | }; |
54 | enum mclk { |
55 | MCLK_SYSCLK, |
56 | MCLK_ULPCLK, |
57 | }; |
58 | |
59 | static SOC_ENUM_SINGLE_EXT_DECL(soc_enum_mclk, enum_mclk); |
60 | |
61 | /* Private data for machine-part MOP500<->AB8500 */ |
62 | struct mop500_ab8500_drvdata { |
63 | /* Clocks */ |
64 | enum mclk mclk_sel; |
65 | struct clk *clk_ptr_intclk; |
66 | struct clk *clk_ptr_sysclk; |
67 | struct clk *clk_ptr_ulpclk; |
68 | }; |
69 | |
70 | static inline const char *get_mclk_str(enum mclk mclk_sel) |
71 | { |
72 | switch (mclk_sel) { |
73 | case MCLK_SYSCLK: |
74 | return "SYSCLK" ; |
75 | case MCLK_ULPCLK: |
76 | return "ULPCLK" ; |
77 | default: |
78 | return "Unknown" ; |
79 | } |
80 | } |
81 | |
82 | static int mop500_ab8500_set_mclk(struct device *dev, |
83 | struct mop500_ab8500_drvdata *drvdata) |
84 | { |
85 | int status; |
86 | struct clk *clk_ptr; |
87 | |
88 | if (IS_ERR(ptr: drvdata->clk_ptr_intclk)) { |
89 | dev_err(dev, |
90 | "%s: ERROR: intclk not initialized!\n" , __func__); |
91 | return -EIO; |
92 | } |
93 | |
94 | switch (drvdata->mclk_sel) { |
95 | case MCLK_SYSCLK: |
96 | clk_ptr = drvdata->clk_ptr_sysclk; |
97 | break; |
98 | case MCLK_ULPCLK: |
99 | clk_ptr = drvdata->clk_ptr_ulpclk; |
100 | break; |
101 | default: |
102 | return -EINVAL; |
103 | } |
104 | |
105 | if (IS_ERR(ptr: clk_ptr)) { |
106 | dev_err(dev, "%s: ERROR: %s not initialized!\n" , __func__, |
107 | get_mclk_str(drvdata->mclk_sel)); |
108 | return -EIO; |
109 | } |
110 | |
111 | status = clk_set_parent(clk: drvdata->clk_ptr_intclk, parent: clk_ptr); |
112 | if (status) |
113 | dev_err(dev, |
114 | "%s: ERROR: Setting intclk parent to %s failed (ret = %d)!" , |
115 | __func__, get_mclk_str(drvdata->mclk_sel), status); |
116 | else |
117 | dev_dbg(dev, |
118 | "%s: intclk parent changed to %s.\n" , |
119 | __func__, get_mclk_str(drvdata->mclk_sel)); |
120 | |
121 | return status; |
122 | } |
123 | |
124 | /* |
125 | * Control-events |
126 | */ |
127 | |
128 | static int mclk_input_control_get(struct snd_kcontrol *kcontrol, |
129 | struct snd_ctl_elem_value *ucontrol) |
130 | { |
131 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
132 | struct mop500_ab8500_drvdata *drvdata = |
133 | snd_soc_card_get_drvdata(card); |
134 | |
135 | ucontrol->value.enumerated.item[0] = drvdata->mclk_sel; |
136 | |
137 | return 0; |
138 | } |
139 | |
140 | static int mclk_input_control_put(struct snd_kcontrol *kcontrol, |
141 | struct snd_ctl_elem_value *ucontrol) |
142 | { |
143 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
144 | struct mop500_ab8500_drvdata *drvdata = |
145 | snd_soc_card_get_drvdata(card); |
146 | unsigned int val = ucontrol->value.enumerated.item[0]; |
147 | |
148 | if (val > (unsigned int)MCLK_ULPCLK) |
149 | return -EINVAL; |
150 | if (drvdata->mclk_sel == val) |
151 | return 0; |
152 | |
153 | drvdata->mclk_sel = val; |
154 | |
155 | return 1; |
156 | } |
157 | |
158 | /* |
159 | * Controls |
160 | */ |
161 | |
162 | static struct snd_kcontrol_new mop500_ab8500_ctrls[] = { |
163 | SOC_ENUM_EXT("Master Clock Select" , |
164 | soc_enum_mclk, |
165 | mclk_input_control_get, mclk_input_control_put), |
166 | SOC_DAPM_PIN_SWITCH("Headset Left" ), |
167 | SOC_DAPM_PIN_SWITCH("Headset Right" ), |
168 | SOC_DAPM_PIN_SWITCH("Earpiece" ), |
169 | SOC_DAPM_PIN_SWITCH("Speaker Left" ), |
170 | SOC_DAPM_PIN_SWITCH("Speaker Right" ), |
171 | SOC_DAPM_PIN_SWITCH("LineOut Left" ), |
172 | SOC_DAPM_PIN_SWITCH("LineOut Right" ), |
173 | SOC_DAPM_PIN_SWITCH("Vibra 1" ), |
174 | SOC_DAPM_PIN_SWITCH("Vibra 2" ), |
175 | SOC_DAPM_PIN_SWITCH("Mic 1" ), |
176 | SOC_DAPM_PIN_SWITCH("Mic 2" ), |
177 | SOC_DAPM_PIN_SWITCH("LineIn Left" ), |
178 | SOC_DAPM_PIN_SWITCH("LineIn Right" ), |
179 | SOC_DAPM_PIN_SWITCH("DMic 1" ), |
180 | SOC_DAPM_PIN_SWITCH("DMic 2" ), |
181 | SOC_DAPM_PIN_SWITCH("DMic 3" ), |
182 | SOC_DAPM_PIN_SWITCH("DMic 4" ), |
183 | SOC_DAPM_PIN_SWITCH("DMic 5" ), |
184 | SOC_DAPM_PIN_SWITCH("DMic 6" ), |
185 | }; |
186 | |
187 | /* ASoC */ |
188 | |
189 | static int mop500_ab8500_startup(struct snd_pcm_substream *substream) |
190 | { |
191 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
192 | |
193 | /* Set audio-clock source */ |
194 | return mop500_ab8500_set_mclk(dev: rtd->card->dev, |
195 | drvdata: snd_soc_card_get_drvdata(card: rtd->card)); |
196 | } |
197 | |
198 | static void mop500_ab8500_shutdown(struct snd_pcm_substream *substream) |
199 | { |
200 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
201 | struct device *dev = rtd->card->dev; |
202 | |
203 | dev_dbg(dev, "%s: Enter\n" , __func__); |
204 | |
205 | /* Reset slots configuration to default(s) */ |
206 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
207 | tx_slots = DEF_TX_SLOTS; |
208 | else |
209 | rx_slots = DEF_RX_SLOTS; |
210 | } |
211 | |
212 | static int mop500_ab8500_hw_params(struct snd_pcm_substream *substream, |
213 | struct snd_pcm_hw_params *params) |
214 | { |
215 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
216 | struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); |
217 | struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); |
218 | struct device *dev = rtd->card->dev; |
219 | unsigned int fmt; |
220 | int channels, ret = 0, driver_mode, slots; |
221 | unsigned int sw_codec, sw_cpu; |
222 | bool is_playback; |
223 | |
224 | dev_dbg(dev, "%s: Enter\n" , __func__); |
225 | |
226 | dev_dbg(dev, "%s: substream->pcm->name = %s\n" |
227 | "substream->pcm->id = %s.\n" |
228 | "substream->name = %s.\n" |
229 | "substream->number = %d.\n" , |
230 | __func__, |
231 | substream->pcm->name, |
232 | substream->pcm->id, |
233 | substream->name, |
234 | substream->number); |
235 | |
236 | /* Ensure configuration consistency between DAIs */ |
237 | mutex_lock(&mop500_ab8500_params_lock); |
238 | if (mop500_ab8500_usage) { |
239 | if (mop500_ab8500_rate != params_rate(p: params) || |
240 | mop500_ab8500_channels != params_channels(p: params)) { |
241 | mutex_unlock(lock: &mop500_ab8500_params_lock); |
242 | return -EBUSY; |
243 | } |
244 | } else { |
245 | mop500_ab8500_rate = params_rate(p: params); |
246 | mop500_ab8500_channels = params_channels(p: params); |
247 | } |
248 | __set_bit(cpu_dai->id, &mop500_ab8500_usage); |
249 | mutex_unlock(lock: &mop500_ab8500_params_lock); |
250 | |
251 | channels = params_channels(p: params); |
252 | |
253 | switch (params_format(p: params)) { |
254 | case SNDRV_PCM_FORMAT_S32_LE: |
255 | sw_cpu = 32; |
256 | break; |
257 | |
258 | case SNDRV_PCM_FORMAT_S16_LE: |
259 | sw_cpu = 16; |
260 | break; |
261 | |
262 | default: |
263 | return -EINVAL; |
264 | } |
265 | |
266 | /* Setup codec depending on driver-mode */ |
267 | if (channels == 8) |
268 | driver_mode = DRIVERMODE_CODEC_ONLY; |
269 | else |
270 | driver_mode = DRIVERMODE_NORMAL; |
271 | dev_dbg(dev, "%s: Driver-mode: %s.\n" , __func__, |
272 | (driver_mode == DRIVERMODE_NORMAL) ? "NORMAL" : "CODEC_ONLY" ); |
273 | |
274 | /* Setup format */ |
275 | |
276 | if (driver_mode == DRIVERMODE_NORMAL) { |
277 | fmt = SND_SOC_DAIFMT_DSP_A | |
278 | SND_SOC_DAIFMT_CBM_CFM | |
279 | SND_SOC_DAIFMT_NB_NF | |
280 | SND_SOC_DAIFMT_CONT; |
281 | } else { |
282 | fmt = SND_SOC_DAIFMT_DSP_A | |
283 | SND_SOC_DAIFMT_CBM_CFM | |
284 | SND_SOC_DAIFMT_NB_NF | |
285 | SND_SOC_DAIFMT_GATED; |
286 | } |
287 | |
288 | ret = snd_soc_runtime_set_dai_fmt(rtd, dai_fmt: fmt); |
289 | if (ret) |
290 | return ret; |
291 | |
292 | /* Setup TDM-slots */ |
293 | |
294 | is_playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK); |
295 | switch (channels) { |
296 | case 1: |
297 | slots = 16; |
298 | tx_slots = (is_playback) ? TX_SLOT_MONO : 0; |
299 | rx_slots = (is_playback) ? 0 : RX_SLOT_MONO; |
300 | break; |
301 | case 2: |
302 | slots = 16; |
303 | tx_slots = (is_playback) ? TX_SLOT_STEREO : 0; |
304 | rx_slots = (is_playback) ? 0 : RX_SLOT_STEREO; |
305 | break; |
306 | case 8: |
307 | slots = 16; |
308 | tx_slots = (is_playback) ? TX_SLOT_8CH : 0; |
309 | rx_slots = (is_playback) ? 0 : RX_SLOT_8CH; |
310 | break; |
311 | default: |
312 | return -EINVAL; |
313 | } |
314 | |
315 | if (driver_mode == DRIVERMODE_NORMAL) |
316 | sw_codec = sw_cpu; |
317 | else |
318 | sw_codec = 20; |
319 | |
320 | dev_dbg(dev, "%s: CPU-DAI TDM: TX=0x%04X RX=0x%04x\n" , __func__, |
321 | tx_slots, rx_slots); |
322 | ret = snd_soc_dai_set_tdm_slot(dai: cpu_dai, tx_mask: tx_slots, rx_mask: rx_slots, slots, |
323 | slot_width: sw_cpu); |
324 | if (ret) |
325 | return ret; |
326 | |
327 | dev_dbg(dev, "%s: CODEC-DAI TDM: TX=0x%04X RX=0x%04x\n" , __func__, |
328 | tx_slots, rx_slots); |
329 | ret = snd_soc_dai_set_tdm_slot(dai: codec_dai, tx_mask: tx_slots, rx_mask: rx_slots, slots, |
330 | slot_width: sw_codec); |
331 | if (ret) |
332 | return ret; |
333 | |
334 | return 0; |
335 | } |
336 | |
337 | static int mop500_ab8500_hw_free(struct snd_pcm_substream *substream) |
338 | { |
339 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
340 | struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); |
341 | |
342 | mutex_lock(&mop500_ab8500_params_lock); |
343 | __clear_bit(cpu_dai->id, &mop500_ab8500_usage); |
344 | mutex_unlock(lock: &mop500_ab8500_params_lock); |
345 | |
346 | return 0; |
347 | } |
348 | |
349 | const struct snd_soc_ops mop500_ab8500_ops[] = { |
350 | { |
351 | .hw_params = mop500_ab8500_hw_params, |
352 | .hw_free = mop500_ab8500_hw_free, |
353 | .startup = mop500_ab8500_startup, |
354 | .shutdown = mop500_ab8500_shutdown, |
355 | } |
356 | }; |
357 | |
358 | int mop500_ab8500_machine_init(struct snd_soc_pcm_runtime *rtd) |
359 | { |
360 | struct snd_soc_dapm_context *dapm = &rtd->card->dapm; |
361 | struct device *dev = rtd->card->dev; |
362 | struct mop500_ab8500_drvdata *drvdata; |
363 | int ret; |
364 | |
365 | dev_dbg(dev, "%s Enter.\n" , __func__); |
366 | |
367 | /* Create driver private-data struct */ |
368 | drvdata = devm_kzalloc(dev, size: sizeof(struct mop500_ab8500_drvdata), |
369 | GFP_KERNEL); |
370 | |
371 | if (!drvdata) |
372 | return -ENOMEM; |
373 | |
374 | snd_soc_card_set_drvdata(card: rtd->card, data: drvdata); |
375 | |
376 | /* Setup clocks */ |
377 | |
378 | drvdata->clk_ptr_sysclk = clk_get(dev, id: "sysclk" ); |
379 | if (IS_ERR(ptr: drvdata->clk_ptr_sysclk)) |
380 | dev_warn(dev, "%s: WARNING: clk_get failed for 'sysclk'!\n" , |
381 | __func__); |
382 | drvdata->clk_ptr_ulpclk = clk_get(dev, id: "ulpclk" ); |
383 | if (IS_ERR(ptr: drvdata->clk_ptr_ulpclk)) |
384 | dev_warn(dev, "%s: WARNING: clk_get failed for 'ulpclk'!\n" , |
385 | __func__); |
386 | drvdata->clk_ptr_intclk = clk_get(dev, id: "intclk" ); |
387 | if (IS_ERR(ptr: drvdata->clk_ptr_intclk)) |
388 | dev_warn(dev, "%s: WARNING: clk_get failed for 'intclk'!\n" , |
389 | __func__); |
390 | |
391 | /* Set intclk default parent to ulpclk */ |
392 | drvdata->mclk_sel = MCLK_ULPCLK; |
393 | ret = mop500_ab8500_set_mclk(dev, drvdata); |
394 | if (ret < 0) |
395 | dev_warn(dev, "%s: WARNING: mop500_ab8500_set_mclk!\n" , |
396 | __func__); |
397 | |
398 | drvdata->mclk_sel = MCLK_ULPCLK; |
399 | |
400 | /* Add controls */ |
401 | ret = snd_soc_add_card_controls(soc_card: rtd->card, controls: mop500_ab8500_ctrls, |
402 | ARRAY_SIZE(mop500_ab8500_ctrls)); |
403 | if (ret < 0) { |
404 | pr_err("%s: Failed to add machine-controls (%d)!\n" , |
405 | __func__, ret); |
406 | return ret; |
407 | } |
408 | |
409 | ret = snd_soc_dapm_disable_pin(dapm, pin: "Earpiece" ); |
410 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "Speaker Left" ); |
411 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "Speaker Right" ); |
412 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "LineOut Left" ); |
413 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "LineOut Right" ); |
414 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "Vibra 1" ); |
415 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "Vibra 2" ); |
416 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "Mic 1" ); |
417 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "Mic 2" ); |
418 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "LineIn Left" ); |
419 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "LineIn Right" ); |
420 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "DMic 1" ); |
421 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "DMic 2" ); |
422 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "DMic 3" ); |
423 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "DMic 4" ); |
424 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "DMic 5" ); |
425 | ret |= snd_soc_dapm_disable_pin(dapm, pin: "DMic 6" ); |
426 | |
427 | return ret; |
428 | } |
429 | |
430 | void mop500_ab8500_remove(struct snd_soc_card *card) |
431 | { |
432 | struct mop500_ab8500_drvdata *drvdata = snd_soc_card_get_drvdata(card); |
433 | |
434 | clk_put(clk: drvdata->clk_ptr_sysclk); |
435 | clk_put(clk: drvdata->clk_ptr_ulpclk); |
436 | clk_put(clk: drvdata->clk_ptr_intclk); |
437 | |
438 | snd_soc_card_set_drvdata(card, data: drvdata); |
439 | } |
440 | |