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