Merge remote-tracking branches 'asoc/topic/davinci', 'asoc/topic/drm', 'asoc/topic...
[sfrench/cifs-2.6.git] / sound / soc / codecs / hdmi-codec.c
1 /*
2  * ALSA SoC codec for HDMI encoder drivers
3  * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
4  * Author: Jyri Sarha <jsarha@ti.com>
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * version 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License for more details.
14  */
15 #include <linux/module.h>
16 #include <linux/string.h>
17 #include <sound/core.h>
18 #include <sound/pcm.h>
19 #include <sound/pcm_params.h>
20 #include <sound/soc.h>
21 #include <sound/tlv.h>
22 #include <sound/pcm_drm_eld.h>
23 #include <sound/hdmi-codec.h>
24 #include <sound/pcm_iec958.h>
25
26 #include <drm/drm_crtc.h> /* This is only to get MAX_ELD_BYTES */
27
28 struct hdmi_device {
29         struct device *dev;
30         struct list_head list;
31         int cnt;
32 };
33 #define pos_to_hdmi_device(pos) container_of((pos), struct hdmi_device, list)
34 LIST_HEAD(hdmi_device_list);
35 static DEFINE_MUTEX(hdmi_mutex);
36
37 #define DAI_NAME_SIZE 16
38
39 #define HDMI_CODEC_CHMAP_IDX_UNKNOWN  -1
40
41 struct hdmi_codec_channel_map_table {
42         unsigned char map;      /* ALSA API channel map position */
43         unsigned long spk_mask;         /* speaker position bit mask */
44 };
45
46 /*
47  * CEA speaker placement for HDMI 1.4:
48  *
49  *  FL  FLC   FC   FRC   FR   FRW
50  *
51  *                                  LFE
52  *
53  *  RL  RLC   RC   RRC   RR
54  *
55  *  Speaker placement has to be extended to support HDMI 2.0
56  */
57 enum hdmi_codec_cea_spk_placement {
58         FL  = BIT(0),   /* Front Left           */
59         FC  = BIT(1),   /* Front Center         */
60         FR  = BIT(2),   /* Front Right          */
61         FLC = BIT(3),   /* Front Left Center    */
62         FRC = BIT(4),   /* Front Right Center   */
63         RL  = BIT(5),   /* Rear Left            */
64         RC  = BIT(6),   /* Rear Center          */
65         RR  = BIT(7),   /* Rear Right           */
66         RLC = BIT(8),   /* Rear Left Center     */
67         RRC = BIT(9),   /* Rear Right Center    */
68         LFE = BIT(10),  /* Low Frequency Effect */
69 };
70
71 /*
72  * cea Speaker allocation structure
73  */
74 struct hdmi_codec_cea_spk_alloc {
75         const int ca_id;
76         unsigned int n_ch;
77         unsigned long mask;
78 };
79
80 /* Channel maps  stereo HDMI */
81 const struct snd_pcm_chmap_elem hdmi_codec_stereo_chmaps[] = {
82         { .channels = 2,
83           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
84         { }
85 };
86
87 /* Channel maps for multi-channel playbacks, up to 8 n_ch */
88 const struct snd_pcm_chmap_elem hdmi_codec_8ch_chmaps[] = {
89         { .channels = 2, /* CA_ID 0x00 */
90           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
91         { .channels = 4, /* CA_ID 0x01 */
92           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
93                    SNDRV_CHMAP_NA } },
94         { .channels = 4, /* CA_ID 0x02 */
95           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
96                    SNDRV_CHMAP_FC } },
97         { .channels = 4, /* CA_ID 0x03 */
98           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
99                    SNDRV_CHMAP_FC } },
100         { .channels = 6, /* CA_ID 0x04 */
101           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
102                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
103         { .channels = 6, /* CA_ID 0x05 */
104           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
105                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
106         { .channels = 6, /* CA_ID 0x06 */
107           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
108                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
109         { .channels = 6, /* CA_ID 0x07 */
110           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
111                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
112         { .channels = 6, /* CA_ID 0x08 */
113           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
114                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
115         { .channels = 6, /* CA_ID 0x09 */
116           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
117                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
118         { .channels = 6, /* CA_ID 0x0A */
119           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
120                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
121         { .channels = 6, /* CA_ID 0x0B */
122           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
123                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
124         { .channels = 8, /* CA_ID 0x0C */
125           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
126                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
127                    SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
128         { .channels = 8, /* CA_ID 0x0D */
129           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
130                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
131                    SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
132         { .channels = 8, /* CA_ID 0x0E */
133           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
134                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
135                    SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
136         { .channels = 8, /* CA_ID 0x0F */
137           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
138                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
139                    SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
140         { .channels = 8, /* CA_ID 0x10 */
141           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
142                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
143                    SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
144         { .channels = 8, /* CA_ID 0x11 */
145           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
146                    SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
147                    SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
148         { .channels = 8, /* CA_ID 0x12 */
149           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
150                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
151                    SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
152         { .channels = 8, /* CA_ID 0x13 */
153           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
154                    SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
155                    SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
156         { .channels = 8, /* CA_ID 0x14 */
157           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
158                    SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
159                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
160         { .channels = 8, /* CA_ID 0x15 */
161           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
162                    SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
163                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
164         { .channels = 8, /* CA_ID 0x16 */
165           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
166                    SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
167                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
168         { .channels = 8, /* CA_ID 0x17 */
169           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
170                    SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
171                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
172         { .channels = 8, /* CA_ID 0x18 */
173           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
174                    SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
175                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
176         { .channels = 8, /* CA_ID 0x19 */
177           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
178                    SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
179                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
180         { .channels = 8, /* CA_ID 0x1A */
181           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
182                    SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
183                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
184         { .channels = 8, /* CA_ID 0x1B */
185           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
186                    SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
187                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
188         { .channels = 8, /* CA_ID 0x1C */
189           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
190                    SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
191                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
192         { .channels = 8, /* CA_ID 0x1D */
193           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
194                    SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
195                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
196         { .channels = 8, /* CA_ID 0x1E */
197           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
198                    SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
199                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
200         { .channels = 8, /* CA_ID 0x1F */
201           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
202                    SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
203                    SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
204         { }
205 };
206
207 /*
208  * hdmi_codec_channel_alloc: speaker configuration available for CEA
209  *
210  * This is an ordered list that must match with hdmi_codec_8ch_chmaps struct
211  * The preceding ones have better chances to be selected by
212  * hdmi_codec_get_ch_alloc_table_idx().
213  */
214 static const struct hdmi_codec_cea_spk_alloc hdmi_codec_channel_alloc[] = {
215         { .ca_id = 0x00, .n_ch = 2,
216           .mask = FL | FR},
217         /* 2.1 */
218         { .ca_id = 0x01, .n_ch = 4,
219           .mask = FL | FR | LFE},
220         /* Dolby Surround */
221         { .ca_id = 0x02, .n_ch = 4,
222           .mask = FL | FR | FC },
223         /* surround51 */
224         { .ca_id = 0x0b, .n_ch = 6,
225           .mask = FL | FR | LFE | FC | RL | RR},
226         /* surround40 */
227         { .ca_id = 0x08, .n_ch = 6,
228           .mask = FL | FR | RL | RR },
229         /* surround41 */
230         { .ca_id = 0x09, .n_ch = 6,
231           .mask = FL | FR | LFE | RL | RR },
232         /* surround50 */
233         { .ca_id = 0x0a, .n_ch = 6,
234           .mask = FL | FR | FC | RL | RR },
235         /* 6.1 */
236         { .ca_id = 0x0f, .n_ch = 8,
237           .mask = FL | FR | LFE | FC | RL | RR | RC },
238         /* surround71 */
239         { .ca_id = 0x13, .n_ch = 8,
240           .mask = FL | FR | LFE | FC | RL | RR | RLC | RRC },
241         /* others */
242         { .ca_id = 0x03, .n_ch = 8,
243           .mask = FL | FR | LFE | FC },
244         { .ca_id = 0x04, .n_ch = 8,
245           .mask = FL | FR | RC},
246         { .ca_id = 0x05, .n_ch = 8,
247           .mask = FL | FR | LFE | RC },
248         { .ca_id = 0x06, .n_ch = 8,
249           .mask = FL | FR | FC | RC },
250         { .ca_id = 0x07, .n_ch = 8,
251           .mask = FL | FR | LFE | FC | RC },
252         { .ca_id = 0x0c, .n_ch = 8,
253           .mask = FL | FR | RC | RL | RR },
254         { .ca_id = 0x0d, .n_ch = 8,
255           .mask = FL | FR | LFE | RL | RR | RC },
256         { .ca_id = 0x0e, .n_ch = 8,
257           .mask = FL | FR | FC | RL | RR | RC },
258         { .ca_id = 0x10, .n_ch = 8,
259           .mask = FL | FR | RL | RR | RLC | RRC },
260         { .ca_id = 0x11, .n_ch = 8,
261           .mask = FL | FR | LFE | RL | RR | RLC | RRC },
262         { .ca_id = 0x12, .n_ch = 8,
263           .mask = FL | FR | FC | RL | RR | RLC | RRC },
264         { .ca_id = 0x14, .n_ch = 8,
265           .mask = FL | FR | FLC | FRC },
266         { .ca_id = 0x15, .n_ch = 8,
267           .mask = FL | FR | LFE | FLC | FRC },
268         { .ca_id = 0x16, .n_ch = 8,
269           .mask = FL | FR | FC | FLC | FRC },
270         { .ca_id = 0x17, .n_ch = 8,
271           .mask = FL | FR | LFE | FC | FLC | FRC },
272         { .ca_id = 0x18, .n_ch = 8,
273           .mask = FL | FR | RC | FLC | FRC },
274         { .ca_id = 0x19, .n_ch = 8,
275           .mask = FL | FR | LFE | RC | FLC | FRC },
276         { .ca_id = 0x1a, .n_ch = 8,
277           .mask = FL | FR | RC | FC | FLC | FRC },
278         { .ca_id = 0x1b, .n_ch = 8,
279           .mask = FL | FR | LFE | RC | FC | FLC | FRC },
280         { .ca_id = 0x1c, .n_ch = 8,
281           .mask = FL | FR | RL | RR | FLC | FRC },
282         { .ca_id = 0x1d, .n_ch = 8,
283           .mask = FL | FR | LFE | RL | RR | FLC | FRC },
284         { .ca_id = 0x1e, .n_ch = 8,
285           .mask = FL | FR | FC | RL | RR | FLC | FRC },
286         { .ca_id = 0x1f, .n_ch = 8,
287           .mask = FL | FR | LFE | FC | RL | RR | FLC | FRC },
288 };
289
290 struct hdmi_codec_priv {
291         struct hdmi_codec_pdata hcd;
292         struct snd_soc_dai_driver *daidrv;
293         struct hdmi_codec_daifmt daifmt[2];
294         struct mutex current_stream_lock;
295         struct snd_pcm_substream *current_stream;
296         struct snd_pcm_hw_constraint_list ratec;
297         uint8_t eld[MAX_ELD_BYTES];
298         struct snd_pcm_chmap *chmap_info;
299         unsigned int chmap_idx;
300 };
301
302 static const struct snd_soc_dapm_widget hdmi_widgets[] = {
303         SND_SOC_DAPM_OUTPUT("TX"),
304 };
305
306 static const struct snd_soc_dapm_route hdmi_routes[] = {
307         { "TX", NULL, "Playback" },
308 };
309
310 enum {
311         DAI_ID_I2S = 0,
312         DAI_ID_SPDIF,
313 };
314
315 static int hdmi_eld_ctl_info(struct snd_kcontrol *kcontrol,
316                              struct snd_ctl_elem_info *uinfo)
317 {
318         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
319         struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
320
321         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
322         uinfo->count = sizeof(hcp->eld);
323
324         return 0;
325 }
326
327 static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol,
328                             struct snd_ctl_elem_value *ucontrol)
329 {
330         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
331         struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
332
333         memcpy(ucontrol->value.bytes.data, hcp->eld, sizeof(hcp->eld));
334
335         return 0;
336 }
337
338 static unsigned long hdmi_codec_spk_mask_from_alloc(int spk_alloc)
339 {
340         int i;
341         const unsigned long hdmi_codec_eld_spk_alloc_bits[] = {
342                 [0] = FL | FR, [1] = LFE, [2] = FC, [3] = RL | RR,
343                 [4] = RC, [5] = FLC | FRC, [6] = RLC | RRC,
344         };
345         unsigned long spk_mask = 0;
346
347         for (i = 0; i < ARRAY_SIZE(hdmi_codec_eld_spk_alloc_bits); i++) {
348                 if (spk_alloc & (1 << i))
349                         spk_mask |= hdmi_codec_eld_spk_alloc_bits[i];
350         }
351
352         return spk_mask;
353 }
354
355 void hdmi_codec_eld_chmap(struct hdmi_codec_priv *hcp)
356 {
357         u8 spk_alloc;
358         unsigned long spk_mask;
359
360         spk_alloc = drm_eld_get_spk_alloc(hcp->eld);
361         spk_mask = hdmi_codec_spk_mask_from_alloc(spk_alloc);
362
363         /* Detect if only stereo supported, else return 8 channels mappings */
364         if ((spk_mask & ~(FL | FR)) && hcp->chmap_info->max_channels > 2)
365                 hcp->chmap_info->chmap = hdmi_codec_8ch_chmaps;
366         else
367                 hcp->chmap_info->chmap = hdmi_codec_stereo_chmaps;
368 }
369
370 static int hdmi_codec_get_ch_alloc_table_idx(struct hdmi_codec_priv *hcp,
371                                              unsigned char channels)
372 {
373         int i;
374         u8 spk_alloc;
375         unsigned long spk_mask;
376         const struct hdmi_codec_cea_spk_alloc *cap = hdmi_codec_channel_alloc;
377
378         spk_alloc = drm_eld_get_spk_alloc(hcp->eld);
379         spk_mask = hdmi_codec_spk_mask_from_alloc(spk_alloc);
380
381         for (i = 0; i < ARRAY_SIZE(hdmi_codec_channel_alloc); i++, cap++) {
382                 /* If spk_alloc == 0, HDMI is unplugged return stereo config*/
383                 if (!spk_alloc && cap->ca_id == 0)
384                         return i;
385                 if (cap->n_ch != channels)
386                         continue;
387                 if (!(cap->mask == (spk_mask & cap->mask)))
388                         continue;
389                 return i;
390         }
391
392         return -EINVAL;
393 }
394 static int hdmi_codec_chmap_ctl_get(struct snd_kcontrol *kcontrol,
395                               struct snd_ctl_elem_value *ucontrol)
396 {
397         unsigned const char *map;
398         unsigned int i;
399         struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
400         struct hdmi_codec_priv *hcp = info->private_data;
401
402         map = info->chmap[hcp->chmap_idx].map;
403
404         for (i = 0; i < info->max_channels; i++) {
405                 if (hcp->chmap_idx == HDMI_CODEC_CHMAP_IDX_UNKNOWN)
406                         ucontrol->value.integer.value[i] = 0;
407                 else
408                         ucontrol->value.integer.value[i] = map[i];
409         }
410
411         return 0;
412 }
413
414
415 static const struct snd_kcontrol_new hdmi_controls[] = {
416         {
417                 .access = SNDRV_CTL_ELEM_ACCESS_READ |
418                           SNDRV_CTL_ELEM_ACCESS_VOLATILE,
419                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
420                 .name = "ELD",
421                 .info = hdmi_eld_ctl_info,
422                 .get = hdmi_eld_ctl_get,
423         },
424 };
425
426 static int hdmi_codec_new_stream(struct snd_pcm_substream *substream,
427                                  struct snd_soc_dai *dai)
428 {
429         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
430         int ret = 0;
431
432         mutex_lock(&hcp->current_stream_lock);
433         if (!hcp->current_stream) {
434                 hcp->current_stream = substream;
435         } else if (hcp->current_stream != substream) {
436                 dev_err(dai->dev, "Only one simultaneous stream supported!\n");
437                 ret = -EINVAL;
438         }
439         mutex_unlock(&hcp->current_stream_lock);
440
441         return ret;
442 }
443
444 static int hdmi_codec_startup(struct snd_pcm_substream *substream,
445                               struct snd_soc_dai *dai)
446 {
447         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
448         int ret = 0;
449
450         dev_dbg(dai->dev, "%s()\n", __func__);
451
452         ret = hdmi_codec_new_stream(substream, dai);
453         if (ret)
454                 return ret;
455
456         if (hcp->hcd.ops->audio_startup) {
457                 ret = hcp->hcd.ops->audio_startup(dai->dev->parent, hcp->hcd.data);
458                 if (ret) {
459                         mutex_lock(&hcp->current_stream_lock);
460                         hcp->current_stream = NULL;
461                         mutex_unlock(&hcp->current_stream_lock);
462                         return ret;
463                 }
464         }
465
466         if (hcp->hcd.ops->get_eld) {
467                 ret = hcp->hcd.ops->get_eld(dai->dev->parent, hcp->hcd.data,
468                                             hcp->eld, sizeof(hcp->eld));
469
470                 if (!ret) {
471                         ret = snd_pcm_hw_constraint_eld(substream->runtime,
472                                                         hcp->eld);
473                         if (ret)
474                                 return ret;
475                 }
476                 /* Select chmap supported */
477                 hdmi_codec_eld_chmap(hcp);
478         }
479         return 0;
480 }
481
482 static void hdmi_codec_shutdown(struct snd_pcm_substream *substream,
483                                 struct snd_soc_dai *dai)
484 {
485         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
486
487         dev_dbg(dai->dev, "%s()\n", __func__);
488
489         WARN_ON(hcp->current_stream != substream);
490
491         hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
492         hcp->hcd.ops->audio_shutdown(dai->dev->parent, hcp->hcd.data);
493
494         mutex_lock(&hcp->current_stream_lock);
495         hcp->current_stream = NULL;
496         mutex_unlock(&hcp->current_stream_lock);
497 }
498
499 static int hdmi_codec_hw_params(struct snd_pcm_substream *substream,
500                                 struct snd_pcm_hw_params *params,
501                                 struct snd_soc_dai *dai)
502 {
503         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
504         struct hdmi_codec_params hp = {
505                 .iec = {
506                         .status = { 0 },
507                         .subcode = { 0 },
508                         .pad = 0,
509                         .dig_subframe = { 0 },
510                 }
511         };
512         int ret, idx;
513
514         dev_dbg(dai->dev, "%s() width %d rate %d channels %d\n", __func__,
515                 params_width(params), params_rate(params),
516                 params_channels(params));
517
518         if (params_width(params) > 24)
519                 params->msbits = 24;
520
521         ret = snd_pcm_create_iec958_consumer_hw_params(params, hp.iec.status,
522                                                        sizeof(hp.iec.status));
523         if (ret < 0) {
524                 dev_err(dai->dev, "Creating IEC958 channel status failed %d\n",
525                         ret);
526                 return ret;
527         }
528
529         ret = hdmi_codec_new_stream(substream, dai);
530         if (ret)
531                 return ret;
532
533         hdmi_audio_infoframe_init(&hp.cea);
534         hp.cea.channels = params_channels(params);
535         hp.cea.coding_type = HDMI_AUDIO_CODING_TYPE_STREAM;
536         hp.cea.sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM;
537         hp.cea.sample_frequency = HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM;
538
539         /* Select a channel allocation that matches with ELD and pcm channels */
540         idx = hdmi_codec_get_ch_alloc_table_idx(hcp, hp.cea.channels);
541         if (idx < 0) {
542                 dev_err(dai->dev, "Not able to map channels to speakers (%d)\n",
543                         idx);
544                 hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
545                 return idx;
546         }
547         hp.cea.channel_allocation = hdmi_codec_channel_alloc[idx].ca_id;
548         hcp->chmap_idx = hdmi_codec_channel_alloc[idx].ca_id;
549
550         hp.sample_width = params_width(params);
551         hp.sample_rate = params_rate(params);
552         hp.channels = params_channels(params);
553
554         return hcp->hcd.ops->hw_params(dai->dev->parent, hcp->hcd.data,
555                                        &hcp->daifmt[dai->id], &hp);
556 }
557
558 static int hdmi_codec_set_fmt(struct snd_soc_dai *dai,
559                               unsigned int fmt)
560 {
561         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
562         struct hdmi_codec_daifmt cf = { 0 };
563         int ret = 0;
564
565         dev_dbg(dai->dev, "%s()\n", __func__);
566
567         if (dai->id == DAI_ID_SPDIF) {
568                 cf.fmt = HDMI_SPDIF;
569         } else {
570                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
571                 case SND_SOC_DAIFMT_CBM_CFM:
572                         cf.bit_clk_master = 1;
573                         cf.frame_clk_master = 1;
574                         break;
575                 case SND_SOC_DAIFMT_CBS_CFM:
576                         cf.frame_clk_master = 1;
577                         break;
578                 case SND_SOC_DAIFMT_CBM_CFS:
579                         cf.bit_clk_master = 1;
580                         break;
581                 case SND_SOC_DAIFMT_CBS_CFS:
582                         break;
583                 default:
584                         return -EINVAL;
585                 }
586
587                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
588                 case SND_SOC_DAIFMT_NB_NF:
589                         break;
590                 case SND_SOC_DAIFMT_NB_IF:
591                         cf.frame_clk_inv = 1;
592                         break;
593                 case SND_SOC_DAIFMT_IB_NF:
594                         cf.bit_clk_inv = 1;
595                         break;
596                 case SND_SOC_DAIFMT_IB_IF:
597                         cf.frame_clk_inv = 1;
598                         cf.bit_clk_inv = 1;
599                         break;
600                 }
601
602                 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
603                 case SND_SOC_DAIFMT_I2S:
604                         cf.fmt = HDMI_I2S;
605                         break;
606                 case SND_SOC_DAIFMT_DSP_A:
607                         cf.fmt = HDMI_DSP_A;
608                         break;
609                 case SND_SOC_DAIFMT_DSP_B:
610                         cf.fmt = HDMI_DSP_B;
611                         break;
612                 case SND_SOC_DAIFMT_RIGHT_J:
613                         cf.fmt = HDMI_RIGHT_J;
614                         break;
615                 case SND_SOC_DAIFMT_LEFT_J:
616                         cf.fmt = HDMI_LEFT_J;
617                         break;
618                 case SND_SOC_DAIFMT_AC97:
619                         cf.fmt = HDMI_AC97;
620                         break;
621                 default:
622                         dev_err(dai->dev, "Invalid DAI interface format\n");
623                         return -EINVAL;
624                 }
625         }
626
627         hcp->daifmt[dai->id] = cf;
628
629         return ret;
630 }
631
632 static int hdmi_codec_digital_mute(struct snd_soc_dai *dai, int mute)
633 {
634         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
635
636         dev_dbg(dai->dev, "%s()\n", __func__);
637
638         if (hcp->hcd.ops->digital_mute)
639                 return hcp->hcd.ops->digital_mute(dai->dev->parent,
640                                                   hcp->hcd.data, mute);
641
642         return 0;
643 }
644
645 static const struct snd_soc_dai_ops hdmi_dai_ops = {
646         .startup        = hdmi_codec_startup,
647         .shutdown       = hdmi_codec_shutdown,
648         .hw_params      = hdmi_codec_hw_params,
649         .set_fmt        = hdmi_codec_set_fmt,
650         .digital_mute   = hdmi_codec_digital_mute,
651 };
652
653
654 #define HDMI_RATES      (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
655                          SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
656                          SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
657                          SNDRV_PCM_RATE_192000)
658
659 #define SPDIF_FORMATS   (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |\
660                          SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE |\
661                          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE |\
662                          SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE)
663
664 /*
665  * This list is only for formats allowed on the I2S bus. So there is
666  * some formats listed that are not supported by HDMI interface. For
667  * instance allowing the 32-bit formats enables 24-precision with CPU
668  * DAIs that do not support 24-bit formats. If the extra formats cause
669  * problems, we should add the video side driver an option to disable
670  * them.
671  */
672 #define I2S_FORMATS     (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |\
673                          SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE |\
674                          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE |\
675                          SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE |\
676                          SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE)
677
678 static int hdmi_codec_pcm_new(struct snd_soc_pcm_runtime *rtd,
679                               struct snd_soc_dai *dai)
680 {
681         struct snd_soc_dai_driver *drv = dai->driver;
682         struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
683         int ret;
684
685         dev_dbg(dai->dev, "%s()\n", __func__);
686
687         ret =  snd_pcm_add_chmap_ctls(rtd->pcm, SNDRV_PCM_STREAM_PLAYBACK,
688                                       NULL, drv->playback.channels_max, 0,
689                                       &hcp->chmap_info);
690         if (ret < 0)
691                 return ret;
692
693         /* override handlers */
694         hcp->chmap_info->private_data = hcp;
695         hcp->chmap_info->kctl->get = hdmi_codec_chmap_ctl_get;
696
697         /* default chmap supported is stereo */
698         hcp->chmap_info->chmap = hdmi_codec_stereo_chmaps;
699         hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
700
701         return 0;
702 }
703
704 static struct snd_soc_dai_driver hdmi_i2s_dai = {
705         .id = DAI_ID_I2S,
706         .playback = {
707                 .stream_name = "Playback",
708                 .channels_min = 2,
709                 .channels_max = 8,
710                 .rates = HDMI_RATES,
711                 .formats = I2S_FORMATS,
712                 .sig_bits = 24,
713         },
714         .ops = &hdmi_dai_ops,
715         .pcm_new = hdmi_codec_pcm_new,
716 };
717
718 static const struct snd_soc_dai_driver hdmi_spdif_dai = {
719         .id = DAI_ID_SPDIF,
720         .playback = {
721                 .stream_name = "Playback",
722                 .channels_min = 2,
723                 .channels_max = 2,
724                 .rates = HDMI_RATES,
725                 .formats = SPDIF_FORMATS,
726         },
727         .ops = &hdmi_dai_ops,
728         .pcm_new = hdmi_codec_pcm_new,
729 };
730
731 static char hdmi_dai_name[][DAI_NAME_SIZE] = {
732         "hdmi-hifi.0",
733         "hdmi-hifi.1",
734         "hdmi-hifi.2",
735         "hdmi-hifi.3",
736 };
737
738 static int hdmi_of_xlate_dai_name(struct snd_soc_component *component,
739                                   struct of_phandle_args *args,
740                                   const char **dai_name)
741 {
742         int id;
743
744         if (args->args_count)
745                 id = args->args[0];
746         else
747                 id = 0;
748
749         if (id < ARRAY_SIZE(hdmi_dai_name)) {
750                 *dai_name = hdmi_dai_name[id];
751                 return 0;
752         }
753
754         return -EAGAIN;
755 }
756
757 static struct snd_soc_codec_driver hdmi_codec = {
758         .component_driver = {
759                 .controls               = hdmi_controls,
760                 .num_controls           = ARRAY_SIZE(hdmi_controls),
761                 .dapm_widgets           = hdmi_widgets,
762                 .num_dapm_widgets       = ARRAY_SIZE(hdmi_widgets),
763                 .dapm_routes            = hdmi_routes,
764                 .num_dapm_routes        = ARRAY_SIZE(hdmi_routes),
765                 .of_xlate_dai_name      = hdmi_of_xlate_dai_name,
766         },
767 };
768
769 static int hdmi_codec_probe(struct platform_device *pdev)
770 {
771         struct hdmi_codec_pdata *hcd = pdev->dev.platform_data;
772         struct device *dev = &pdev->dev;
773         struct hdmi_codec_priv *hcp;
774         struct hdmi_device *hd;
775         struct list_head *pos;
776         int dai_count, i = 0;
777         int ret;
778
779         dev_dbg(dev, "%s()\n", __func__);
780
781         if (!hcd) {
782                 dev_err(dev, "%s: No plalform data\n", __func__);
783                 return -EINVAL;
784         }
785
786         dai_count = hcd->i2s + hcd->spdif;
787         if (dai_count < 1 || !hcd->ops || !hcd->ops->hw_params ||
788             !hcd->ops->audio_shutdown) {
789                 dev_err(dev, "%s: Invalid parameters\n", __func__);
790                 return -EINVAL;
791         }
792
793         hcp = devm_kzalloc(dev, sizeof(*hcp), GFP_KERNEL);
794         if (!hcp)
795                 return -ENOMEM;
796
797         hd = NULL;
798         mutex_lock(&hdmi_mutex);
799         list_for_each(pos, &hdmi_device_list) {
800                 struct hdmi_device *tmp = pos_to_hdmi_device(pos);
801
802                 if (tmp->dev == dev->parent) {
803                         hd = tmp;
804                         break;
805                 }
806         }
807
808         if (!hd) {
809                 hd = devm_kzalloc(dev, sizeof(*hd), GFP_KERNEL);
810                 if (!hd) {
811                         mutex_unlock(&hdmi_mutex);
812                         return -ENOMEM;
813                 }
814
815                 hd->dev = dev->parent;
816
817                 list_add_tail(&hd->list, &hdmi_device_list);
818         }
819         mutex_unlock(&hdmi_mutex);
820
821         if (hd->cnt >= ARRAY_SIZE(hdmi_dai_name)) {
822                 dev_err(dev, "too many hdmi codec are deteced\n");
823                 return -EINVAL;
824         }
825
826         hcp->hcd = *hcd;
827         mutex_init(&hcp->current_stream_lock);
828
829         hcp->daidrv = devm_kzalloc(dev, dai_count * sizeof(*hcp->daidrv),
830                                    GFP_KERNEL);
831         if (!hcp->daidrv)
832                 return -ENOMEM;
833
834         if (hcd->i2s) {
835                 hcp->daidrv[i] = hdmi_i2s_dai;
836                 hcp->daidrv[i].playback.channels_max =
837                         hcd->max_i2s_channels;
838                 hcp->daidrv[i].name = hdmi_dai_name[hd->cnt++];
839                 i++;
840         }
841
842         if (hcd->spdif) {
843                 hcp->daidrv[i] = hdmi_spdif_dai;
844                 hcp->daidrv[i].name = hdmi_dai_name[hd->cnt++];
845         }
846
847         ret = snd_soc_register_codec(dev, &hdmi_codec, hcp->daidrv,
848                                      dai_count);
849         if (ret) {
850                 dev_err(dev, "%s: snd_soc_register_codec() failed (%d)\n",
851                         __func__, ret);
852                 return ret;
853         }
854
855         dev_set_drvdata(dev, hcp);
856         return 0;
857 }
858
859 static int hdmi_codec_remove(struct platform_device *pdev)
860 {
861         struct device *dev = &pdev->dev;
862         struct list_head *pos;
863         struct hdmi_codec_priv *hcp;
864
865         mutex_lock(&hdmi_mutex);
866         list_for_each(pos, &hdmi_device_list) {
867                 struct hdmi_device *tmp = pos_to_hdmi_device(pos);
868
869                 if (tmp->dev == dev->parent) {
870                         list_del(pos);
871                         break;
872                 }
873         }
874         mutex_unlock(&hdmi_mutex);
875
876         hcp = dev_get_drvdata(dev);
877         kfree(hcp->chmap_info);
878         snd_soc_unregister_codec(dev);
879
880         return 0;
881 }
882
883 static struct platform_driver hdmi_codec_driver = {
884         .driver = {
885                 .name = HDMI_CODEC_DRV_NAME,
886         },
887         .probe = hdmi_codec_probe,
888         .remove = hdmi_codec_remove,
889 };
890
891 module_platform_driver(hdmi_codec_driver);
892
893 MODULE_AUTHOR("Jyri Sarha <jsarha@ti.com>");
894 MODULE_DESCRIPTION("HDMI Audio Codec Driver");
895 MODULE_LICENSE("GPL");
896 MODULE_ALIAS("platform:" HDMI_CODEC_DRV_NAME);