rx51.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * rx51.c  --  SoC audio for Nokia RX-51
  4 *
  5 * Copyright (C) 2008 - 2009 Nokia Corporation
  6 *
  7 * Contact: Peter Ujfalusi <peter.ujfalusi@ti.com>
  8 *          Eduardo Valentin <eduardo.valentin@nokia.com>
  9 *          Jarkko Nikula <jarkko.nikula@bitmer.com>
 10 */
 11
 12#include <linux/delay.h>
 13#include <linux/platform_device.h>
 14#include <linux/gpio/consumer.h>
 15#include <linux/module.h>
 16#include <sound/core.h>
 17#include <sound/jack.h>
 18#include <sound/pcm.h>
 19#include <sound/soc.h>
 20#include <linux/platform_data/asoc-ti-mcbsp.h>
 21
 22#include <asm/mach-types.h>
 23
 24#include "omap-mcbsp.h"
 25
 26enum {
 27	RX51_JACK_DISABLED,
 28	RX51_JACK_TVOUT,		/* tv-out with stereo output */
 29	RX51_JACK_HP,			/* headphone: stereo output, no mic */
 30	RX51_JACK_HS,			/* headset: stereo output with mic */
 31};
 32
 33struct rx51_audio_pdata {
 34	struct gpio_desc *tvout_selection_gpio;
 35	struct gpio_desc *eci_sw_gpio;
 36	struct gpio_desc *speaker_amp_gpio;
 37};
 38
 39static int rx51_spk_func;
 40static int rx51_dmic_func;
 41static int rx51_jack_func;
 42
 43static void rx51_ext_control(struct snd_soc_dapm_context *dapm)
 44{
 45	struct snd_soc_card *card = snd_soc_dapm_to_card(dapm);
 46	struct rx51_audio_pdata *pdata = snd_soc_card_get_drvdata(card);
 47	int hp = 0, hs = 0, tvout = 0;
 48
 49	switch (rx51_jack_func) {
 50	case RX51_JACK_TVOUT:
 51		tvout = 1;
 52		hp = 1;
 53		break;
 54	case RX51_JACK_HS:
 55		hs = 1;
 56		fallthrough;
 57	case RX51_JACK_HP:
 58		hp = 1;
 59		break;
 60	}
 61
 62	snd_soc_dapm_mutex_lock(dapm);
 63
 64	if (rx51_spk_func)
 65		snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk");
 66	else
 67		snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk");
 68	if (rx51_dmic_func)
 69		snd_soc_dapm_enable_pin_unlocked(dapm, "DMic");
 70	else
 71		snd_soc_dapm_disable_pin_unlocked(dapm, "DMic");
 72	if (hp)
 73		snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack");
 74	else
 75		snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack");
 76	if (hs)
 77		snd_soc_dapm_enable_pin_unlocked(dapm, "HS Mic");
 78	else
 79		snd_soc_dapm_disable_pin_unlocked(dapm, "HS Mic");
 80
 81	gpiod_set_value(pdata->tvout_selection_gpio, tvout);
 82
 83	snd_soc_dapm_sync_unlocked(dapm);
 84
 85	snd_soc_dapm_mutex_unlock(dapm);
 86}
 87
 88static int rx51_startup(struct snd_pcm_substream *substream)
 89{
 90	struct snd_pcm_runtime *runtime = substream->runtime;
 91	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
 92	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(rtd->card);
 93
 94	snd_pcm_hw_constraint_single(runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 2);
 95	rx51_ext_control(dapm);
 96
 97	return 0;
 98}
 99
100static int rx51_hw_params(struct snd_pcm_substream *substream,
101	struct snd_pcm_hw_params *params)
102{
103	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
104	struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
105
106	/* Set the codec system clock for DAC and ADC */
107	return snd_soc_dai_set_sysclk(codec_dai, 0, 19200000,
108				      SND_SOC_CLOCK_IN);
109}
110
111static const struct snd_soc_ops rx51_ops = {
112	.startup = rx51_startup,
113	.hw_params = rx51_hw_params,
114};
115
116static int rx51_get_spk(struct snd_kcontrol *kcontrol,
117			struct snd_ctl_elem_value *ucontrol)
118{
119	ucontrol->value.enumerated.item[0] = rx51_spk_func;
120
121	return 0;
122}
123
124static int rx51_set_spk(struct snd_kcontrol *kcontrol,
125			struct snd_ctl_elem_value *ucontrol)
126{
127	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
128	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
129
130	if (rx51_spk_func == ucontrol->value.enumerated.item[0])
131		return 0;
132
133	rx51_spk_func = ucontrol->value.enumerated.item[0];
134	rx51_ext_control(dapm);
135
136	return 1;
137}
138
139static int rx51_spk_event(struct snd_soc_dapm_widget *w,
140			  struct snd_kcontrol *k, int event)
141{
142	struct snd_soc_dapm_context *dapm = w->dapm;
143	struct snd_soc_card *card = snd_soc_dapm_to_card(dapm);
144	struct rx51_audio_pdata *pdata = snd_soc_card_get_drvdata(card);
145
146	gpiod_set_raw_value_cansleep(pdata->speaker_amp_gpio,
147				     !!SND_SOC_DAPM_EVENT_ON(event));
148
149	return 0;
150}
151
152static int rx51_get_input(struct snd_kcontrol *kcontrol,
153			  struct snd_ctl_elem_value *ucontrol)
154{
155	ucontrol->value.enumerated.item[0] = rx51_dmic_func;
156
157	return 0;
158}
159
160static int rx51_set_input(struct snd_kcontrol *kcontrol,
161			  struct snd_ctl_elem_value *ucontrol)
162{
163	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
164	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
165
166	if (rx51_dmic_func == ucontrol->value.enumerated.item[0])
167		return 0;
168
169	rx51_dmic_func = ucontrol->value.enumerated.item[0];
170	rx51_ext_control(dapm);
171
172	return 1;
173}
174
175static int rx51_get_jack(struct snd_kcontrol *kcontrol,
176			 struct snd_ctl_elem_value *ucontrol)
177{
178	ucontrol->value.enumerated.item[0] = rx51_jack_func;
179
180	return 0;
181}
182
183static int rx51_set_jack(struct snd_kcontrol *kcontrol,
184			 struct snd_ctl_elem_value *ucontrol)
185{
186	struct snd_soc_card *card = snd_kcontrol_chip(kcontrol);
187	struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
188
189	if (rx51_jack_func == ucontrol->value.enumerated.item[0])
190		return 0;
191
192	rx51_jack_func = ucontrol->value.enumerated.item[0];
193	rx51_ext_control(dapm);
194
195	return 1;
196}
197
198static struct snd_soc_jack rx51_av_jack;
199
200static struct snd_soc_jack_gpio rx51_av_jack_gpios[] = {
201	{
202		.name = "jack-detection",
203		.report = SND_JACK_HEADSET,
204		.invert = 1,
205		.debounce_time = 200,
206	},
207};
208
209static const struct snd_soc_dapm_widget aic34_dapm_widgets[] = {
210	SND_SOC_DAPM_SPK("Ext Spk", rx51_spk_event),
211	SND_SOC_DAPM_MIC("DMic", NULL),
212	SND_SOC_DAPM_HP("Headphone Jack", NULL),
213	SND_SOC_DAPM_MIC("HS Mic", NULL),
214	SND_SOC_DAPM_LINE("FM Transmitter", NULL),
215	SND_SOC_DAPM_SPK("Earphone", NULL),
216};
217
218static const struct snd_soc_dapm_route audio_map[] = {
219	{"Ext Spk", NULL, "HPLOUT"},
220	{"Ext Spk", NULL, "HPROUT"},
221	{"Ext Spk", NULL, "HPLCOM"},
222	{"Ext Spk", NULL, "HPRCOM"},
223	{"FM Transmitter", NULL, "LLOUT"},
224	{"FM Transmitter", NULL, "RLOUT"},
225
226	{"Headphone Jack", NULL, "TPA6130A2 HPLEFT"},
227	{"Headphone Jack", NULL, "TPA6130A2 HPRIGHT"},
228	{"TPA6130A2 LEFTIN", NULL, "LLOUT"},
229	{"TPA6130A2 RIGHTIN", NULL, "RLOUT"},
230
231	{"DMic Rate 64", NULL, "DMic"},
232	{"DMic", NULL, "Mic Bias"},
233
234	{"b LINE2R", NULL, "MONO_LOUT"},
235	{"Earphone", NULL, "b HPLOUT"},
236
237	{"LINE1L", NULL, "HS Mic"},
238	{"HS Mic", NULL, "b Mic Bias"},
239};
240
241static const char * const spk_function[] = {"Off", "On"};
242static const char * const input_function[] = {"ADC", "Digital Mic"};
243static const char * const jack_function[] = {
244	"Off", "TV-OUT", "Headphone", "Headset"
245};
246
247static const struct soc_enum rx51_enum[] = {
248	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(spk_function), spk_function),
249	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(input_function), input_function),
250	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(jack_function), jack_function),
251};
252
253static const struct snd_kcontrol_new aic34_rx51_controls[] = {
254	SOC_ENUM_EXT("Speaker Function", rx51_enum[0],
255		     rx51_get_spk, rx51_set_spk),
256	SOC_ENUM_EXT("Input Select",  rx51_enum[1],
257		     rx51_get_input, rx51_set_input),
258	SOC_ENUM_EXT("Jack Function", rx51_enum[2],
259		     rx51_get_jack, rx51_set_jack),
260	SOC_DAPM_PIN_SWITCH("FM Transmitter"),
261	SOC_DAPM_PIN_SWITCH("Earphone"),
262};
263
264static int rx51_aic34_init(struct snd_soc_pcm_runtime *rtd)
265{
266	struct snd_soc_card *card = rtd->card;
267	int err;
268
269	snd_soc_limit_volume(card, "TPA6130A2 Headphone Playback Volume", 42);
270
271	err = omap_mcbsp_st_add_controls(rtd, 2);
272	if (err < 0) {
273		dev_err(card->dev, "Failed to add MCBSP controls\n");
274		return err;
275	}
276
277	/* AV jack detection */
278	err = snd_soc_card_jack_new(rtd->card, "AV Jack",
279				    SND_JACK_HEADSET | SND_JACK_VIDEOOUT,
280				    &rx51_av_jack);
281	if (err) {
282		dev_err(card->dev, "Failed to add AV Jack\n");
283		return err;
284	}
285
286	rx51_av_jack_gpios[0].gpiod_dev = card->dev;
287	/* Name is assigned in the struct */
288	rx51_av_jack_gpios[0].idx = 0;
289
290	err = snd_soc_jack_add_gpios(&rx51_av_jack,
291				     ARRAY_SIZE(rx51_av_jack_gpios),
292				     rx51_av_jack_gpios);
293	if (err) {
294		dev_err(card->dev, "Failed to add GPIOs\n");
295		return err;
296	}
297
298	return err;
299}
300
301/* Digital audio interface glue - connects codec <--> CPU */
302SND_SOC_DAILINK_DEFS(aic34,
303	DAILINK_COMP_ARRAY(COMP_CPU("omap-mcbsp.2")),
304	DAILINK_COMP_ARRAY(COMP_CODEC("tlv320aic3x-codec.2-0018",
305				      "tlv320aic3x-hifi")),
306	DAILINK_COMP_ARRAY(COMP_PLATFORM("omap-mcbsp.2")));
307
308static struct snd_soc_dai_link rx51_dai[] = {
309	{
310		.name = "TLV320AIC34",
311		.stream_name = "AIC34",
312		.dai_fmt = SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_IB_NF |
313			   SND_SOC_DAIFMT_CBP_CFP,
314		.init = rx51_aic34_init,
315		.ops = &rx51_ops,
316		SND_SOC_DAILINK_REG(aic34),
317	},
318};
319
320static struct snd_soc_aux_dev rx51_aux_dev[] = {
321	{
322		.dlc = COMP_AUX("tlv320aic3x-codec.2-0019"),
323	},
324	{
325		.dlc = COMP_AUX("tpa6130a2.2-0060"),
326	},
327};
328
329static struct snd_soc_codec_conf rx51_codec_conf[] = {
330	{
331		.dlc = COMP_CODEC_CONF("tlv320aic3x-codec.2-0019"),
332		.name_prefix = "b",
333	},
334	{
335		.dlc = COMP_CODEC_CONF("tpa6130a2.2-0060"),
336		.name_prefix = "TPA6130A2",
337	},
338};
339
340/* Audio card */
341static struct snd_soc_card rx51_sound_card = {
342	.name = "RX-51",
343	.owner = THIS_MODULE,
344	.dai_link = rx51_dai,
345	.num_links = ARRAY_SIZE(rx51_dai),
346	.aux_dev = rx51_aux_dev,
347	.num_aux_devs = ARRAY_SIZE(rx51_aux_dev),
348	.codec_conf = rx51_codec_conf,
349	.num_configs = ARRAY_SIZE(rx51_codec_conf),
350	.fully_routed = true,
351
352	.controls = aic34_rx51_controls,
353	.num_controls = ARRAY_SIZE(aic34_rx51_controls),
354	.dapm_widgets = aic34_dapm_widgets,
355	.num_dapm_widgets = ARRAY_SIZE(aic34_dapm_widgets),
356	.dapm_routes = audio_map,
357	.num_dapm_routes = ARRAY_SIZE(audio_map),
358};
359
360static int rx51_soc_probe(struct platform_device *pdev)
361{
362	struct rx51_audio_pdata *pdata;
363	struct device_node *np = pdev->dev.of_node;
364	struct snd_soc_card *card = &rx51_sound_card;
365	int err;
366
367	if (!machine_is_nokia_rx51() && !of_machine_is_compatible("nokia,omap3-n900"))
368		return -ENODEV;
369
370	card->dev = &pdev->dev;
371
372	if (np) {
373		struct device_node *dai_node;
374
375		dai_node = of_parse_phandle(np, "nokia,cpu-dai", 0);
376		if (!dai_node) {
377			dev_err(card->dev, "McBSP node is not provided\n");
378			return -EINVAL;
379		}
380		rx51_dai[0].cpus->dai_name = NULL;
381		rx51_dai[0].platforms->name = NULL;
382		rx51_dai[0].cpus->of_node = dai_node;
383		rx51_dai[0].platforms->of_node = dai_node;
384
385		dai_node = of_parse_phandle(np, "nokia,audio-codec", 0);
386		if (!dai_node) {
387			dev_err(card->dev, "Codec node is not provided\n");
388			return -EINVAL;
389		}
390		rx51_dai[0].codecs->name = NULL;
391		rx51_dai[0].codecs->of_node = dai_node;
392
393		dai_node = of_parse_phandle(np, "nokia,audio-codec", 1);
394		if (!dai_node) {
395			dev_err(card->dev, "Auxiliary Codec node is not provided\n");
396			return -EINVAL;
397		}
398		rx51_aux_dev[0].dlc.name = NULL;
399		rx51_aux_dev[0].dlc.of_node = dai_node;
400		rx51_codec_conf[0].dlc.name = NULL;
401		rx51_codec_conf[0].dlc.of_node = dai_node;
402
403		dai_node = of_parse_phandle(np, "nokia,headphone-amplifier", 0);
404		if (!dai_node) {
405			dev_err(card->dev, "Headphone amplifier node is not provided\n");
406			return -EINVAL;
407		}
408		rx51_aux_dev[1].dlc.name = NULL;
409		rx51_aux_dev[1].dlc.of_node = dai_node;
410		rx51_codec_conf[1].dlc.name = NULL;
411		rx51_codec_conf[1].dlc.of_node = dai_node;
412	}
413
414	pdata = devm_kzalloc(card->dev, sizeof(*pdata), GFP_KERNEL);
415	if (pdata == NULL)
416		return -ENOMEM;
417
418	snd_soc_card_set_drvdata(card, pdata);
419
420	pdata->tvout_selection_gpio = devm_gpiod_get(card->dev,
421						     "tvout-selection",
422						     GPIOD_OUT_LOW);
423	if (IS_ERR(pdata->tvout_selection_gpio)) {
424		dev_err(card->dev, "could not get tvout selection gpio\n");
425		return PTR_ERR(pdata->tvout_selection_gpio);
426	}
427
428	pdata->eci_sw_gpio = devm_gpiod_get(card->dev, "eci-switch",
429					    GPIOD_OUT_HIGH);
430	if (IS_ERR(pdata->eci_sw_gpio)) {
431		dev_err(card->dev, "could not get eci switch gpio\n");
432		return PTR_ERR(pdata->eci_sw_gpio);
433	}
434
435	pdata->speaker_amp_gpio = devm_gpiod_get(card->dev,
436						 "speaker-amplifier",
437						 GPIOD_OUT_LOW);
438	if (IS_ERR(pdata->speaker_amp_gpio)) {
439		dev_err(card->dev, "could not get speaker enable gpio\n");
440		return PTR_ERR(pdata->speaker_amp_gpio);
441	}
442
443	err = devm_snd_soc_register_card(card->dev, card);
444	if (err) {
445		dev_err(card->dev, "snd_soc_register_card failed (%d)\n", err);
446		return err;
447	}
448
449	return 0;
450}
451
452#if defined(CONFIG_OF)
453static const struct of_device_id rx51_audio_of_match[] = {
454	{ .compatible = "nokia,n900-audio", },
455	{},
456};
457MODULE_DEVICE_TABLE(of, rx51_audio_of_match);
458#endif
459
460static struct platform_driver rx51_soc_driver = {
461	.driver = {
462		.name = "rx51-audio",
463		.of_match_table = of_match_ptr(rx51_audio_of_match),
464	},
465	.probe = rx51_soc_probe,
466};
467
468module_platform_driver(rx51_soc_driver);
469
470MODULE_AUTHOR("Nokia Corporation");
471MODULE_DESCRIPTION("ALSA SoC Nokia RX-51");
472MODULE_LICENSE("GPL");
473MODULE_ALIAS("platform:rx51-audio");