xref: /openbmc/linux/sound/soc/ux500/mop500_ab8500.c (revision 8466579b)
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 
get_mclk_str(enum mclk mclk_sel)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 
mop500_ab8500_set_mclk(struct device * dev,struct mop500_ab8500_drvdata * drvdata)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(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(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(drvdata->clk_ptr_intclk, 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 
mclk_input_control_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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 
mclk_input_control_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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 
mop500_ab8500_startup(struct snd_pcm_substream * substream)189 static int mop500_ab8500_startup(struct snd_pcm_substream *substream)
190 {
191 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
192 
193 	/* Set audio-clock source */
194 	return mop500_ab8500_set_mclk(rtd->card->dev,
195 				snd_soc_card_get_drvdata(rtd->card));
196 }
197 
mop500_ab8500_shutdown(struct snd_pcm_substream * substream)198 static void mop500_ab8500_shutdown(struct snd_pcm_substream *substream)
199 {
200 	struct snd_soc_pcm_runtime *rtd = asoc_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 
mop500_ab8500_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)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 = asoc_substream_to_rtd(substream);
216 	struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
217 	struct snd_soc_dai *cpu_dai = asoc_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(params) ||
240 		    mop500_ab8500_channels != params_channels(params)) {
241 			mutex_unlock(&mop500_ab8500_params_lock);
242 			return -EBUSY;
243 		}
244 	} else {
245 		mop500_ab8500_rate = params_rate(params);
246 		mop500_ab8500_channels = params_channels(params);
247 	}
248 	__set_bit(cpu_dai->id, &mop500_ab8500_usage);
249 	mutex_unlock(&mop500_ab8500_params_lock);
250 
251 	channels = params_channels(params);
252 
253 	switch (params_format(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, 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(cpu_dai, tx_slots, rx_slots, slots,
323 				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(codec_dai, tx_slots, rx_slots, slots,
330 				sw_codec);
331 	if (ret)
332 		return ret;
333 
334 	return 0;
335 }
336 
mop500_ab8500_hw_free(struct snd_pcm_substream * substream)337 static int mop500_ab8500_hw_free(struct snd_pcm_substream *substream)
338 {
339 	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
340 	struct snd_soc_dai *cpu_dai = asoc_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(&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 
mop500_ab8500_machine_init(struct snd_soc_pcm_runtime * rtd)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, sizeof(struct mop500_ab8500_drvdata),
369 			GFP_KERNEL);
370 
371 	if (!drvdata)
372 		return -ENOMEM;
373 
374 	snd_soc_card_set_drvdata(rtd->card, drvdata);
375 
376 	/* Setup clocks */
377 
378 	drvdata->clk_ptr_sysclk = clk_get(dev, "sysclk");
379 	if (IS_ERR(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, "ulpclk");
383 	if (IS_ERR(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, "intclk");
387 	if (IS_ERR(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(rtd->card, 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, "Earpiece");
410 	ret |= snd_soc_dapm_disable_pin(dapm, "Speaker Left");
411 	ret |= snd_soc_dapm_disable_pin(dapm, "Speaker Right");
412 	ret |= snd_soc_dapm_disable_pin(dapm, "LineOut Left");
413 	ret |= snd_soc_dapm_disable_pin(dapm, "LineOut Right");
414 	ret |= snd_soc_dapm_disable_pin(dapm, "Vibra 1");
415 	ret |= snd_soc_dapm_disable_pin(dapm, "Vibra 2");
416 	ret |= snd_soc_dapm_disable_pin(dapm, "Mic 1");
417 	ret |= snd_soc_dapm_disable_pin(dapm, "Mic 2");
418 	ret |= snd_soc_dapm_disable_pin(dapm, "LineIn Left");
419 	ret |= snd_soc_dapm_disable_pin(dapm, "LineIn Right");
420 	ret |= snd_soc_dapm_disable_pin(dapm, "DMic 1");
421 	ret |= snd_soc_dapm_disable_pin(dapm, "DMic 2");
422 	ret |= snd_soc_dapm_disable_pin(dapm, "DMic 3");
423 	ret |= snd_soc_dapm_disable_pin(dapm, "DMic 4");
424 	ret |= snd_soc_dapm_disable_pin(dapm, "DMic 5");
425 	ret |= snd_soc_dapm_disable_pin(dapm, "DMic 6");
426 
427 	return ret;
428 }
429 
mop500_ab8500_remove(struct snd_soc_card * card)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(drvdata->clk_ptr_sysclk);
435 	clk_put(drvdata->clk_ptr_ulpclk);
436 	clk_put(drvdata->clk_ptr_intclk);
437 
438 	snd_soc_card_set_drvdata(card, drvdata);
439 }
440