• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * ALSA SoC codec for HDMI encoder drivers
4  * Copyright (C) 2015 Texas Instruments Incorporated - https://www.ti.com/
5  * Author: Jyri Sarha <jsarha@ti.com>
6  */
7 #include <linux/module.h>
8 #include <linux/string.h>
9 #include <sound/core.h>
10 #include <sound/jack.h>
11 #include <sound/pcm.h>
12 #include <sound/pcm_params.h>
13 #include <sound/soc.h>
14 #include <sound/tlv.h>
15 #include <sound/pcm_drm_eld.h>
16 #include <sound/hdmi-codec.h>
17 #include <sound/pcm_iec958.h>
18 
19 #include <drm/drm_crtc.h> /* This is only to get MAX_ELD_BYTES */
20 
21 #define HDMI_CODEC_CHMAP_IDX_UNKNOWN  -1
22 
23 /*
24  * CEA speaker placement for HDMI 1.4:
25  *
26  *  FL  FLC   FC   FRC   FR   FRW
27  *
28  *                                  LFE
29  *
30  *  RL  RLC   RC   RRC   RR
31  *
32  *  Speaker placement has to be extended to support HDMI 2.0
33  */
34 enum hdmi_codec_cea_spk_placement {
35 	FL  = BIT(0),	/* Front Left           */
36 	FC  = BIT(1),	/* Front Center         */
37 	FR  = BIT(2),	/* Front Right          */
38 	FLC = BIT(3),	/* Front Left Center    */
39 	FRC = BIT(4),	/* Front Right Center   */
40 	RL  = BIT(5),	/* Rear Left            */
41 	RC  = BIT(6),	/* Rear Center          */
42 	RR  = BIT(7),	/* Rear Right           */
43 	RLC = BIT(8),	/* Rear Left Center     */
44 	RRC = BIT(9),	/* Rear Right Center    */
45 	LFE = BIT(10),	/* Low Frequency Effect */
46 };
47 
48 /*
49  * cea Speaker allocation structure
50  */
51 struct hdmi_codec_cea_spk_alloc {
52 	const int ca_id;
53 	unsigned int n_ch;
54 	unsigned long mask;
55 };
56 
57 /* Channel maps  stereo HDMI */
58 static const struct snd_pcm_chmap_elem hdmi_codec_stereo_chmaps[] = {
59 	{ .channels = 2,
60 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
61 	{ }
62 };
63 
64 /* Channel maps for multi-channel playbacks, up to 8 n_ch */
65 static const struct snd_pcm_chmap_elem hdmi_codec_8ch_chmaps[] = {
66 	{ .channels = 2, /* CA_ID 0x00 */
67 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
68 	{ .channels = 4, /* CA_ID 0x01 */
69 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
70 		   SNDRV_CHMAP_NA } },
71 	{ .channels = 4, /* CA_ID 0x02 */
72 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
73 		   SNDRV_CHMAP_FC } },
74 	{ .channels = 4, /* CA_ID 0x03 */
75 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
76 		   SNDRV_CHMAP_FC } },
77 	{ .channels = 6, /* CA_ID 0x04 */
78 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
79 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
80 	{ .channels = 6, /* CA_ID 0x05 */
81 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
82 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
83 	{ .channels = 6, /* CA_ID 0x06 */
84 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
85 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
86 	{ .channels = 6, /* CA_ID 0x07 */
87 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
88 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
89 	{ .channels = 6, /* CA_ID 0x08 */
90 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
91 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
92 	{ .channels = 6, /* CA_ID 0x09 */
93 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
94 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
95 	{ .channels = 6, /* CA_ID 0x0A */
96 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
97 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
98 	{ .channels = 6, /* CA_ID 0x0B */
99 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
100 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
101 	{ .channels = 8, /* CA_ID 0x0C */
102 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
103 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
104 		   SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
105 	{ .channels = 8, /* CA_ID 0x0D */
106 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
107 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
108 		   SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
109 	{ .channels = 8, /* CA_ID 0x0E */
110 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
111 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
112 		   SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
113 	{ .channels = 8, /* CA_ID 0x0F */
114 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
115 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
116 		   SNDRV_CHMAP_RC, SNDRV_CHMAP_NA } },
117 	{ .channels = 8, /* CA_ID 0x10 */
118 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
119 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
120 		   SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
121 	{ .channels = 8, /* CA_ID 0x11 */
122 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
123 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
124 		   SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
125 	{ .channels = 8, /* CA_ID 0x12 */
126 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
127 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
128 		   SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
129 	{ .channels = 8, /* CA_ID 0x13 */
130 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
131 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_RL, SNDRV_CHMAP_RR,
132 		   SNDRV_CHMAP_RLC, SNDRV_CHMAP_RRC } },
133 	{ .channels = 8, /* CA_ID 0x14 */
134 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
135 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
136 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
137 	{ .channels = 8, /* CA_ID 0x15 */
138 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
139 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
140 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
141 	{ .channels = 8, /* CA_ID 0x16 */
142 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
143 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
144 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
145 	{ .channels = 8, /* CA_ID 0x17 */
146 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
147 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
148 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
149 	{ .channels = 8, /* CA_ID 0x18 */
150 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
151 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
152 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
153 	{ .channels = 8, /* CA_ID 0x19 */
154 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
155 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
156 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
157 	{ .channels = 8, /* CA_ID 0x1A */
158 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
159 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
160 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
161 	{ .channels = 8, /* CA_ID 0x1B */
162 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
163 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
164 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
165 	{ .channels = 8, /* CA_ID 0x1C */
166 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
167 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
168 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
169 	{ .channels = 8, /* CA_ID 0x1D */
170 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
171 		   SNDRV_CHMAP_NA, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
172 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
173 	{ .channels = 8, /* CA_ID 0x1E */
174 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_NA,
175 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
176 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
177 	{ .channels = 8, /* CA_ID 0x1F */
178 	  .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR, SNDRV_CHMAP_LFE,
179 		   SNDRV_CHMAP_FC, SNDRV_CHMAP_NA, SNDRV_CHMAP_NA,
180 		   SNDRV_CHMAP_FLC, SNDRV_CHMAP_FRC } },
181 	{ }
182 };
183 
184 /*
185  * hdmi_codec_channel_alloc: speaker configuration available for CEA
186  *
187  * This is an ordered list that must match with hdmi_codec_8ch_chmaps struct
188  * The preceding ones have better chances to be selected by
189  * hdmi_codec_get_ch_alloc_table_idx().
190  */
191 static const struct hdmi_codec_cea_spk_alloc hdmi_codec_channel_alloc[] = {
192 	{ .ca_id = 0x00, .n_ch = 2,
193 	  .mask = FL | FR},
194 	/* 2.1 */
195 	{ .ca_id = 0x01, .n_ch = 4,
196 	  .mask = FL | FR | LFE},
197 	/* Dolby Surround */
198 	{ .ca_id = 0x02, .n_ch = 4,
199 	  .mask = FL | FR | FC },
200 	/* surround51 */
201 	{ .ca_id = 0x0b, .n_ch = 6,
202 	  .mask = FL | FR | LFE | FC | RL | RR},
203 	/* surround40 */
204 	{ .ca_id = 0x08, .n_ch = 6,
205 	  .mask = FL | FR | RL | RR },
206 	/* surround41 */
207 	{ .ca_id = 0x09, .n_ch = 6,
208 	  .mask = FL | FR | LFE | RL | RR },
209 	/* surround50 */
210 	{ .ca_id = 0x0a, .n_ch = 6,
211 	  .mask = FL | FR | FC | RL | RR },
212 	/* 6.1 */
213 	{ .ca_id = 0x0f, .n_ch = 8,
214 	  .mask = FL | FR | LFE | FC | RL | RR | RC },
215 	/* surround71 */
216 	{ .ca_id = 0x13, .n_ch = 8,
217 	  .mask = FL | FR | LFE | FC | RL | RR | RLC | RRC },
218 	/* others */
219 	{ .ca_id = 0x03, .n_ch = 8,
220 	  .mask = FL | FR | LFE | FC },
221 	{ .ca_id = 0x04, .n_ch = 8,
222 	  .mask = FL | FR | RC},
223 	{ .ca_id = 0x05, .n_ch = 8,
224 	  .mask = FL | FR | LFE | RC },
225 	{ .ca_id = 0x06, .n_ch = 8,
226 	  .mask = FL | FR | FC | RC },
227 	{ .ca_id = 0x07, .n_ch = 8,
228 	  .mask = FL | FR | LFE | FC | RC },
229 	{ .ca_id = 0x0c, .n_ch = 8,
230 	  .mask = FL | FR | RC | RL | RR },
231 	{ .ca_id = 0x0d, .n_ch = 8,
232 	  .mask = FL | FR | LFE | RL | RR | RC },
233 	{ .ca_id = 0x0e, .n_ch = 8,
234 	  .mask = FL | FR | FC | RL | RR | RC },
235 	{ .ca_id = 0x10, .n_ch = 8,
236 	  .mask = FL | FR | RL | RR | RLC | RRC },
237 	{ .ca_id = 0x11, .n_ch = 8,
238 	  .mask = FL | FR | LFE | RL | RR | RLC | RRC },
239 	{ .ca_id = 0x12, .n_ch = 8,
240 	  .mask = FL | FR | FC | RL | RR | RLC | RRC },
241 	{ .ca_id = 0x14, .n_ch = 8,
242 	  .mask = FL | FR | FLC | FRC },
243 	{ .ca_id = 0x15, .n_ch = 8,
244 	  .mask = FL | FR | LFE | FLC | FRC },
245 	{ .ca_id = 0x16, .n_ch = 8,
246 	  .mask = FL | FR | FC | FLC | FRC },
247 	{ .ca_id = 0x17, .n_ch = 8,
248 	  .mask = FL | FR | LFE | FC | FLC | FRC },
249 	{ .ca_id = 0x18, .n_ch = 8,
250 	  .mask = FL | FR | RC | FLC | FRC },
251 	{ .ca_id = 0x19, .n_ch = 8,
252 	  .mask = FL | FR | LFE | RC | FLC | FRC },
253 	{ .ca_id = 0x1a, .n_ch = 8,
254 	  .mask = FL | FR | RC | FC | FLC | FRC },
255 	{ .ca_id = 0x1b, .n_ch = 8,
256 	  .mask = FL | FR | LFE | RC | FC | FLC | FRC },
257 	{ .ca_id = 0x1c, .n_ch = 8,
258 	  .mask = FL | FR | RL | RR | FLC | FRC },
259 	{ .ca_id = 0x1d, .n_ch = 8,
260 	  .mask = FL | FR | LFE | RL | RR | FLC | FRC },
261 	{ .ca_id = 0x1e, .n_ch = 8,
262 	  .mask = FL | FR | FC | RL | RR | FLC | FRC },
263 	{ .ca_id = 0x1f, .n_ch = 8,
264 	  .mask = FL | FR | LFE | FC | RL | RR | FLC | FRC },
265 };
266 
267 struct hdmi_codec_priv {
268 	struct hdmi_codec_pdata hcd;
269 	uint8_t eld[MAX_ELD_BYTES];
270 	struct snd_pcm_chmap *chmap_info;
271 	unsigned int chmap_idx;
272 	struct mutex lock;
273 	bool busy;
274 	struct snd_soc_jack *jack;
275 	unsigned int jack_status;
276 	u8 iec_status[AES_IEC958_STATUS_SIZE];
277 };
278 
279 static const struct snd_soc_dapm_widget hdmi_widgets[] = {
280 	SND_SOC_DAPM_OUTPUT("TX"),
281 	SND_SOC_DAPM_OUTPUT("RX"),
282 };
283 
284 enum {
285 	DAI_ID_I2S = 0,
286 	DAI_ID_SPDIF,
287 };
288 
hdmi_eld_ctl_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)289 static int hdmi_eld_ctl_info(struct snd_kcontrol *kcontrol,
290 			     struct snd_ctl_elem_info *uinfo)
291 {
292 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
293 	uinfo->count = sizeof_field(struct hdmi_codec_priv, eld);
294 
295 	return 0;
296 }
297 
hdmi_eld_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)298 static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol,
299 			    struct snd_ctl_elem_value *ucontrol)
300 {
301 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
302 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
303 
304 	memcpy(ucontrol->value.bytes.data, hcp->eld, sizeof(hcp->eld));
305 
306 	return 0;
307 }
308 
hdmi_codec_spk_mask_from_alloc(int spk_alloc)309 static unsigned long hdmi_codec_spk_mask_from_alloc(int spk_alloc)
310 {
311 	int i;
312 	static const unsigned long hdmi_codec_eld_spk_alloc_bits[] = {
313 		[0] = FL | FR, [1] = LFE, [2] = FC, [3] = RL | RR,
314 		[4] = RC, [5] = FLC | FRC, [6] = RLC | RRC,
315 	};
316 	unsigned long spk_mask = 0;
317 
318 	for (i = 0; i < ARRAY_SIZE(hdmi_codec_eld_spk_alloc_bits); i++) {
319 		if (spk_alloc & (1 << i))
320 			spk_mask |= hdmi_codec_eld_spk_alloc_bits[i];
321 	}
322 
323 	return spk_mask;
324 }
325 
hdmi_codec_eld_chmap(struct hdmi_codec_priv * hcp)326 static void hdmi_codec_eld_chmap(struct hdmi_codec_priv *hcp)
327 {
328 	u8 spk_alloc;
329 	unsigned long spk_mask;
330 
331 	spk_alloc = drm_eld_get_spk_alloc(hcp->eld);
332 	spk_mask = hdmi_codec_spk_mask_from_alloc(spk_alloc);
333 
334 	/* Detect if only stereo supported, else return 8 channels mappings */
335 	if ((spk_mask & ~(FL | FR)) && hcp->chmap_info->max_channels > 2)
336 		hcp->chmap_info->chmap = hdmi_codec_8ch_chmaps;
337 	else
338 		hcp->chmap_info->chmap = hdmi_codec_stereo_chmaps;
339 }
340 
hdmi_codec_get_ch_alloc_table_idx(struct hdmi_codec_priv * hcp,unsigned char channels)341 static int hdmi_codec_get_ch_alloc_table_idx(struct hdmi_codec_priv *hcp,
342 					     unsigned char channels)
343 {
344 	int i;
345 	u8 spk_alloc;
346 	unsigned long spk_mask;
347 	const struct hdmi_codec_cea_spk_alloc *cap = hdmi_codec_channel_alloc;
348 
349 	spk_alloc = drm_eld_get_spk_alloc(hcp->eld);
350 	spk_mask = hdmi_codec_spk_mask_from_alloc(spk_alloc);
351 
352 	for (i = 0; i < ARRAY_SIZE(hdmi_codec_channel_alloc); i++, cap++) {
353 		/* If spk_alloc == 0, HDMI is unplugged return stereo config*/
354 		if (!spk_alloc && cap->ca_id == 0)
355 			return i;
356 		if (cap->n_ch != channels)
357 			continue;
358 		if (!(cap->mask == (spk_mask & cap->mask)))
359 			continue;
360 		return i;
361 	}
362 
363 	return -EINVAL;
364 }
hdmi_codec_chmap_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)365 static int hdmi_codec_chmap_ctl_get(struct snd_kcontrol *kcontrol,
366 			      struct snd_ctl_elem_value *ucontrol)
367 {
368 	unsigned const char *map;
369 	unsigned int i;
370 	struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol);
371 	struct hdmi_codec_priv *hcp = info->private_data;
372 
373 	map = info->chmap[hcp->chmap_idx].map;
374 
375 	for (i = 0; i < info->max_channels; i++) {
376 		if (hcp->chmap_idx == HDMI_CODEC_CHMAP_IDX_UNKNOWN)
377 			ucontrol->value.integer.value[i] = 0;
378 		else
379 			ucontrol->value.integer.value[i] = map[i];
380 	}
381 
382 	return 0;
383 }
384 
hdmi_codec_iec958_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)385 static int hdmi_codec_iec958_info(struct snd_kcontrol *kcontrol,
386 				  struct snd_ctl_elem_info *uinfo)
387 {
388 	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
389 	uinfo->count = 1;
390 	return 0;
391 }
392 
hdmi_codec_iec958_default_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)393 static int hdmi_codec_iec958_default_get(struct snd_kcontrol *kcontrol,
394 					 struct snd_ctl_elem_value *ucontrol)
395 {
396 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
397 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
398 
399 	memcpy(ucontrol->value.iec958.status, hcp->iec_status,
400 	       sizeof(hcp->iec_status));
401 
402 	return 0;
403 }
404 
hdmi_codec_iec958_default_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)405 static int hdmi_codec_iec958_default_put(struct snd_kcontrol *kcontrol,
406 					 struct snd_ctl_elem_value *ucontrol)
407 {
408 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
409 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
410 
411 	memcpy(hcp->iec_status, ucontrol->value.iec958.status,
412 	       sizeof(hcp->iec_status));
413 
414 	return 0;
415 }
416 
hdmi_codec_iec958_mask_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)417 static int hdmi_codec_iec958_mask_get(struct snd_kcontrol *kcontrol,
418 				      struct snd_ctl_elem_value *ucontrol)
419 {
420 	memset(ucontrol->value.iec958.status, 0xff,
421 	       sizeof_field(struct hdmi_codec_priv, iec_status));
422 
423 	return 0;
424 }
425 
hdmi_codec_startup(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)426 static int hdmi_codec_startup(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 	bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
431 	int ret = 0;
432 
433 	mutex_lock(&hcp->lock);
434 	if (hcp->busy) {
435 		dev_err(dai->dev, "Only one simultaneous stream supported!\n");
436 		mutex_unlock(&hcp->lock);
437 		return -EINVAL;
438 	}
439 
440 	if (hcp->hcd.ops->audio_startup) {
441 		ret = hcp->hcd.ops->audio_startup(dai->dev->parent, hcp->hcd.data);
442 		if (ret)
443 			goto err;
444 	}
445 
446 	if (tx && hcp->hcd.ops->get_eld) {
447 		ret = hcp->hcd.ops->get_eld(dai->dev->parent, hcp->hcd.data,
448 					    hcp->eld, sizeof(hcp->eld));
449 		if (ret)
450 			goto err;
451 
452 		ret = snd_pcm_hw_constraint_eld(substream->runtime, hcp->eld);
453 		if (ret)
454 			goto err;
455 
456 		/* Select chmap supported */
457 		hdmi_codec_eld_chmap(hcp);
458 	}
459 
460 	hcp->busy = true;
461 
462 err:
463 	mutex_unlock(&hcp->lock);
464 	return ret;
465 }
466 
hdmi_codec_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)467 static void hdmi_codec_shutdown(struct snd_pcm_substream *substream,
468 				struct snd_soc_dai *dai)
469 {
470 	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
471 
472 	hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
473 	hcp->hcd.ops->audio_shutdown(dai->dev->parent, hcp->hcd.data);
474 
475 	mutex_lock(&hcp->lock);
476 	hcp->busy = false;
477 	mutex_unlock(&hcp->lock);
478 }
479 
hdmi_codec_fill_codec_params(struct snd_soc_dai * dai,unsigned int sample_width,unsigned int sample_rate,unsigned int channels,struct hdmi_codec_params * hp)480 static int hdmi_codec_fill_codec_params(struct snd_soc_dai *dai,
481 					unsigned int sample_width,
482 					unsigned int sample_rate,
483 					unsigned int channels,
484 					struct hdmi_codec_params *hp)
485 {
486 	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
487 	int idx;
488 
489 	/* Select a channel allocation that matches with ELD and pcm channels */
490 	idx = hdmi_codec_get_ch_alloc_table_idx(hcp, channels);
491 	if (idx < 0) {
492 		dev_err(dai->dev, "Not able to map channels to speakers (%d)\n",
493 			idx);
494 		hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
495 		return idx;
496 	}
497 
498 	memset(hp, 0, sizeof(*hp));
499 
500 	hdmi_audio_infoframe_init(&hp->cea);
501 	hp->cea.channels = channels;
502 	hp->cea.coding_type = HDMI_AUDIO_CODING_TYPE_STREAM;
503 	hp->cea.sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM;
504 	hp->cea.sample_frequency = HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM;
505 	hp->cea.channel_allocation = hdmi_codec_channel_alloc[idx].ca_id;
506 
507 	hp->sample_width = sample_width;
508 	hp->sample_rate = sample_rate;
509 	hp->channels = channels;
510 
511 	hcp->chmap_idx = hdmi_codec_channel_alloc[idx].ca_id;
512 
513 	return 0;
514 }
515 
hdmi_codec_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)516 static int hdmi_codec_hw_params(struct snd_pcm_substream *substream,
517 				struct snd_pcm_hw_params *params,
518 				struct snd_soc_dai *dai)
519 {
520 	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
521 	struct hdmi_codec_daifmt *cf = dai->playback_dma_data;
522 	struct hdmi_codec_params hp = {
523 		.iec = {
524 			.status = { 0 },
525 			.subcode = { 0 },
526 			.pad = 0,
527 			.dig_subframe = { 0 },
528 		}
529 	};
530 	int ret;
531 
532 	if (!hcp->hcd.ops->hw_params)
533 		return 0;
534 
535 	dev_dbg(dai->dev, "%s() width %d rate %d channels %d\n", __func__,
536 		params_width(params), params_rate(params),
537 		params_channels(params));
538 
539 	ret = hdmi_codec_fill_codec_params(dai,
540 					   params_width(params),
541 					   params_rate(params),
542 					   params_channels(params),
543 					   &hp);
544 	if (ret < 0)
545 		return ret;
546 
547 	memcpy(hp.iec.status, hcp->iec_status, sizeof(hp.iec.status));
548 	ret = snd_pcm_fill_iec958_consumer_hw_params(params, hp.iec.status,
549 						     sizeof(hp.iec.status));
550 	if (ret < 0) {
551 		dev_err(dai->dev, "Creating IEC958 channel status failed %d\n",
552 			ret);
553 		return ret;
554 	}
555 
556 	cf->bit_fmt = params_format(params);
557 	return hcp->hcd.ops->hw_params(dai->dev->parent, hcp->hcd.data,
558 				       cf, &hp);
559 }
560 
hdmi_codec_prepare(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)561 static int hdmi_codec_prepare(struct snd_pcm_substream *substream,
562 			      struct snd_soc_dai *dai)
563 {
564 	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
565 	struct hdmi_codec_daifmt *cf = dai->playback_dma_data;
566 	struct snd_pcm_runtime *runtime = substream->runtime;
567 	unsigned int channels = runtime->channels;
568 	unsigned int width = snd_pcm_format_width(runtime->format);
569 	unsigned int rate = runtime->rate;
570 	struct hdmi_codec_params hp;
571 	int ret;
572 
573 	if (!hcp->hcd.ops->prepare)
574 		return 0;
575 
576 	dev_dbg(dai->dev, "%s() width %d rate %d channels %d\n", __func__,
577 		width, rate, channels);
578 
579 	ret = hdmi_codec_fill_codec_params(dai, width, rate, channels, &hp);
580 	if (ret < 0)
581 		return ret;
582 
583 	memcpy(hp.iec.status, hcp->iec_status, sizeof(hp.iec.status));
584 	ret = snd_pcm_fill_iec958_consumer(runtime, hp.iec.status,
585 					   sizeof(hp.iec.status));
586 	if (ret < 0) {
587 		dev_err(dai->dev, "Creating IEC958 channel status failed %d\n",
588 			ret);
589 		return ret;
590 	}
591 
592 	cf->bit_fmt = runtime->format;
593 	return hcp->hcd.ops->prepare(dai->dev->parent, hcp->hcd.data,
594 				     cf, &hp);
595 }
596 
hdmi_codec_i2s_set_fmt(struct snd_soc_dai * dai,unsigned int fmt)597 static int hdmi_codec_i2s_set_fmt(struct snd_soc_dai *dai,
598 				  unsigned int fmt)
599 {
600 	struct hdmi_codec_daifmt *cf = dai->playback_dma_data;
601 
602 	/* Reset daifmt */
603 	memset(cf, 0, sizeof(*cf));
604 
605 	switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
606 	case SND_SOC_DAIFMT_CBP_CFP:
607 		cf->bit_clk_provider = 1;
608 		cf->frame_clk_provider = 1;
609 		break;
610 	case SND_SOC_DAIFMT_CBC_CFP:
611 		cf->frame_clk_provider = 1;
612 		break;
613 	case SND_SOC_DAIFMT_CBP_CFC:
614 		cf->bit_clk_provider = 1;
615 		break;
616 	case SND_SOC_DAIFMT_CBC_CFC:
617 		break;
618 	default:
619 		return -EINVAL;
620 	}
621 
622 	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
623 	case SND_SOC_DAIFMT_NB_NF:
624 		break;
625 	case SND_SOC_DAIFMT_NB_IF:
626 		cf->frame_clk_inv = 1;
627 		break;
628 	case SND_SOC_DAIFMT_IB_NF:
629 		cf->bit_clk_inv = 1;
630 		break;
631 	case SND_SOC_DAIFMT_IB_IF:
632 		cf->frame_clk_inv = 1;
633 		cf->bit_clk_inv = 1;
634 		break;
635 	}
636 
637 	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
638 	case SND_SOC_DAIFMT_I2S:
639 		cf->fmt = HDMI_I2S;
640 		break;
641 	case SND_SOC_DAIFMT_DSP_A:
642 		cf->fmt = HDMI_DSP_A;
643 		break;
644 	case SND_SOC_DAIFMT_DSP_B:
645 		cf->fmt = HDMI_DSP_B;
646 		break;
647 	case SND_SOC_DAIFMT_RIGHT_J:
648 		cf->fmt = HDMI_RIGHT_J;
649 		break;
650 	case SND_SOC_DAIFMT_LEFT_J:
651 		cf->fmt = HDMI_LEFT_J;
652 		break;
653 	case SND_SOC_DAIFMT_AC97:
654 		cf->fmt = HDMI_AC97;
655 		break;
656 	default:
657 		dev_err(dai->dev, "Invalid DAI interface format\n");
658 		return -EINVAL;
659 	}
660 
661 	return 0;
662 }
663 
hdmi_codec_mute(struct snd_soc_dai * dai,int mute,int direction)664 static int hdmi_codec_mute(struct snd_soc_dai *dai, int mute, int direction)
665 {
666 	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
667 
668 	/*
669 	 * ignore if direction was CAPTURE
670 	 * and it had .no_capture_mute flag
671 	 * see
672 	 *	snd_soc_dai_digital_mute()
673 	 */
674 	if (hcp->hcd.ops->mute_stream &&
675 	    (direction == SNDRV_PCM_STREAM_PLAYBACK ||
676 	     !hcp->hcd.ops->no_capture_mute))
677 		return hcp->hcd.ops->mute_stream(dai->dev->parent,
678 						 hcp->hcd.data,
679 						 mute, direction);
680 
681 	return -ENOTSUPP;
682 }
683 
684 /*
685  * This driver can select all SND_SOC_DAIFMT_CBx_CFx,
686  * but need to be selected from Sound Card, not be auto selected.
687  * Because it might be used from other driver.
688  * For example,
689  *	${LINUX}/drivers/gpu/drm/bridge/synopsys/dw-hdmi-i2s-audio.c
690  */
691 static u64 hdmi_codec_formats =
692 	SND_SOC_POSSIBLE_DAIFMT_NB_NF	|
693 	SND_SOC_POSSIBLE_DAIFMT_NB_IF	|
694 	SND_SOC_POSSIBLE_DAIFMT_IB_NF	|
695 	SND_SOC_POSSIBLE_DAIFMT_IB_IF	|
696 	SND_SOC_POSSIBLE_DAIFMT_I2S	|
697 	SND_SOC_POSSIBLE_DAIFMT_DSP_A	|
698 	SND_SOC_POSSIBLE_DAIFMT_DSP_B	|
699 	SND_SOC_POSSIBLE_DAIFMT_RIGHT_J	|
700 	SND_SOC_POSSIBLE_DAIFMT_LEFT_J	|
701 	SND_SOC_POSSIBLE_DAIFMT_AC97;
702 
703 static const struct snd_soc_dai_ops hdmi_codec_i2s_dai_ops = {
704 	.startup	= hdmi_codec_startup,
705 	.shutdown	= hdmi_codec_shutdown,
706 	.hw_params	= hdmi_codec_hw_params,
707 	.prepare	= hdmi_codec_prepare,
708 	.set_fmt	= hdmi_codec_i2s_set_fmt,
709 	.mute_stream	= hdmi_codec_mute,
710 	.auto_selectable_formats	= &hdmi_codec_formats,
711 	.num_auto_selectable_formats	= 1,
712 };
713 
714 static const struct snd_soc_dai_ops hdmi_codec_spdif_dai_ops = {
715 	.startup	= hdmi_codec_startup,
716 	.shutdown	= hdmi_codec_shutdown,
717 	.hw_params	= hdmi_codec_hw_params,
718 	.mute_stream	= hdmi_codec_mute,
719 };
720 
721 #define HDMI_RATES	(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
722 			 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
723 			 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
724 			 SNDRV_PCM_RATE_192000)
725 
726 #define SPDIF_FORMATS	(SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
727 			 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_LE)
728 
729 /*
730  * This list is only for formats allowed on the I2S bus. So there is
731  * some formats listed that are not supported by HDMI interface. For
732  * instance allowing the 32-bit formats enables 24-precision with CPU
733  * DAIs that do not support 24-bit formats. If the extra formats cause
734  * problems, we should add the video side driver an option to disable
735  * them.
736  */
737 #define I2S_FORMATS	(SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
738 			 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_LE |\
739 			 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
740 
741 static struct snd_kcontrol_new hdmi_codec_controls[] = {
742 	{
743 		.access = SNDRV_CTL_ELEM_ACCESS_READ,
744 		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
745 		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
746 		.info = hdmi_codec_iec958_info,
747 		.get = hdmi_codec_iec958_mask_get,
748 	},
749 	{
750 		.iface = SNDRV_CTL_ELEM_IFACE_PCM,
751 		.name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
752 		.info = hdmi_codec_iec958_info,
753 		.get = hdmi_codec_iec958_default_get,
754 		.put = hdmi_codec_iec958_default_put,
755 	},
756 	{
757 		.access	= (SNDRV_CTL_ELEM_ACCESS_READ |
758 			   SNDRV_CTL_ELEM_ACCESS_VOLATILE),
759 		.iface	= SNDRV_CTL_ELEM_IFACE_PCM,
760 		.name	= "ELD",
761 		.info	= hdmi_eld_ctl_info,
762 		.get	= hdmi_eld_ctl_get,
763 	},
764 };
765 
hdmi_codec_pcm_new(struct snd_soc_pcm_runtime * rtd,struct snd_soc_dai * dai)766 static int hdmi_codec_pcm_new(struct snd_soc_pcm_runtime *rtd,
767 			      struct snd_soc_dai *dai)
768 {
769 	struct snd_soc_dai_driver *drv = dai->driver;
770 	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
771 	unsigned int i;
772 	int ret;
773 
774 	ret =  snd_pcm_add_chmap_ctls(rtd->pcm, SNDRV_PCM_STREAM_PLAYBACK,
775 				      NULL, drv->playback.channels_max, 0,
776 				      &hcp->chmap_info);
777 	if (ret < 0)
778 		return ret;
779 
780 	/* override handlers */
781 	hcp->chmap_info->private_data = hcp;
782 	hcp->chmap_info->kctl->get = hdmi_codec_chmap_ctl_get;
783 
784 	/* default chmap supported is stereo */
785 	hcp->chmap_info->chmap = hdmi_codec_stereo_chmaps;
786 	hcp->chmap_idx = HDMI_CODEC_CHMAP_IDX_UNKNOWN;
787 
788 	for (i = 0; i < ARRAY_SIZE(hdmi_codec_controls); i++) {
789 		struct snd_kcontrol *kctl;
790 
791 		/* add ELD ctl with the device number corresponding to the PCM stream */
792 		kctl = snd_ctl_new1(&hdmi_codec_controls[i], dai->component);
793 		if (!kctl)
794 			return -ENOMEM;
795 
796 		kctl->id.device = rtd->pcm->device;
797 		ret = snd_ctl_add(rtd->card->snd_card, kctl);
798 		if (ret < 0)
799 			return ret;
800 	}
801 
802 	return 0;
803 }
804 
hdmi_dai_probe(struct snd_soc_dai * dai)805 static int hdmi_dai_probe(struct snd_soc_dai *dai)
806 {
807 	struct snd_soc_dapm_context *dapm;
808 	struct hdmi_codec_daifmt *daifmt;
809 	struct snd_soc_dapm_route route[] = {
810 		{
811 			.sink = "TX",
812 			.source = dai->driver->playback.stream_name,
813 		},
814 		{
815 			.sink = dai->driver->capture.stream_name,
816 			.source = "RX",
817 		},
818 	};
819 	int ret;
820 
821 	dapm = snd_soc_component_get_dapm(dai->component);
822 	ret = snd_soc_dapm_add_routes(dapm, route, 2);
823 	if (ret)
824 		return ret;
825 
826 	daifmt = devm_kzalloc(dai->dev, sizeof(*daifmt), GFP_KERNEL);
827 	if (!daifmt)
828 		return -ENOMEM;
829 
830 	dai->playback_dma_data = daifmt;
831 	return 0;
832 }
833 
hdmi_codec_jack_report(struct hdmi_codec_priv * hcp,unsigned int jack_status)834 static void hdmi_codec_jack_report(struct hdmi_codec_priv *hcp,
835 				   unsigned int jack_status)
836 {
837 	if (jack_status != hcp->jack_status) {
838 		if (hcp->jack)
839 			snd_soc_jack_report(hcp->jack, jack_status, SND_JACK_LINEOUT);
840 		hcp->jack_status = jack_status;
841 	}
842 }
843 
plugged_cb(struct device * dev,bool plugged)844 static void plugged_cb(struct device *dev, bool plugged)
845 {
846 	struct hdmi_codec_priv *hcp = dev_get_drvdata(dev);
847 
848 	if (plugged) {
849 		if (hcp->hcd.ops->get_eld) {
850 			hcp->hcd.ops->get_eld(dev->parent, hcp->hcd.data,
851 					    hcp->eld, sizeof(hcp->eld));
852 		}
853 		hdmi_codec_jack_report(hcp, SND_JACK_LINEOUT);
854 	} else {
855 		hdmi_codec_jack_report(hcp, 0);
856 		memset(hcp->eld, 0, sizeof(hcp->eld));
857 	}
858 }
859 
hdmi_codec_set_jack(struct snd_soc_component * component,struct snd_soc_jack * jack,void * data)860 static int hdmi_codec_set_jack(struct snd_soc_component *component,
861 			       struct snd_soc_jack *jack,
862 			       void *data)
863 {
864 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
865 
866 	if (hcp->hcd.ops->hook_plugged_cb) {
867 		hcp->jack = jack;
868 
869 		/*
870 		 * Report the initial jack status which may have been provided
871 		 * by the parent hdmi driver while the hpd hook was registered.
872 		 */
873 		snd_soc_jack_report(jack, hcp->jack_status, SND_JACK_LINEOUT);
874 
875 		return 0;
876 	}
877 
878 	return -ENOTSUPP;
879 }
880 
hdmi_dai_spdif_probe(struct snd_soc_dai * dai)881 static int hdmi_dai_spdif_probe(struct snd_soc_dai *dai)
882 {
883 	struct hdmi_codec_daifmt *cf;
884 	int ret;
885 
886 	ret = hdmi_dai_probe(dai);
887 	if (ret)
888 		return ret;
889 
890 	cf = dai->playback_dma_data;
891 	cf->fmt = HDMI_SPDIF;
892 
893 	return 0;
894 }
895 
896 static const struct snd_soc_dai_driver hdmi_i2s_dai = {
897 	.name = "i2s-hifi",
898 	.id = DAI_ID_I2S,
899 	.probe = hdmi_dai_probe,
900 	.playback = {
901 		.stream_name = "I2S Playback",
902 		.channels_min = 2,
903 		.channels_max = 8,
904 		.rates = HDMI_RATES,
905 		.formats = I2S_FORMATS,
906 		.sig_bits = 24,
907 	},
908 	.capture = {
909 		.stream_name = "Capture",
910 		.channels_min = 2,
911 		.channels_max = 8,
912 		.rates = HDMI_RATES,
913 		.formats = I2S_FORMATS,
914 		.sig_bits = 24,
915 	},
916 	.ops = &hdmi_codec_i2s_dai_ops,
917 	.pcm_new = hdmi_codec_pcm_new,
918 };
919 
920 static const struct snd_soc_dai_driver hdmi_spdif_dai = {
921 	.name = "spdif-hifi",
922 	.id = DAI_ID_SPDIF,
923 	.probe = hdmi_dai_spdif_probe,
924 	.playback = {
925 		.stream_name = "SPDIF Playback",
926 		.channels_min = 2,
927 		.channels_max = 2,
928 		.rates = HDMI_RATES,
929 		.formats = SPDIF_FORMATS,
930 	},
931 	.capture = {
932 		.stream_name = "Capture",
933 		.channels_min = 2,
934 		.channels_max = 2,
935 		.rates = HDMI_RATES,
936 		.formats = SPDIF_FORMATS,
937 	},
938 	.ops = &hdmi_codec_spdif_dai_ops,
939 	.pcm_new = hdmi_codec_pcm_new,
940 };
941 
hdmi_of_xlate_dai_id(struct snd_soc_component * component,struct device_node * endpoint)942 static int hdmi_of_xlate_dai_id(struct snd_soc_component *component,
943 				 struct device_node *endpoint)
944 {
945 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
946 	int ret = -ENOTSUPP; /* see snd_soc_get_dai_id() */
947 
948 	if (hcp->hcd.ops->get_dai_id)
949 		ret = hcp->hcd.ops->get_dai_id(component, endpoint);
950 
951 	return ret;
952 }
953 
hdmi_probe(struct snd_soc_component * component)954 static int hdmi_probe(struct snd_soc_component *component)
955 {
956 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
957 	int ret = 0;
958 
959 	if (hcp->hcd.ops->hook_plugged_cb) {
960 		ret = hcp->hcd.ops->hook_plugged_cb(component->dev->parent,
961 						    hcp->hcd.data,
962 						    plugged_cb,
963 						    component->dev);
964 	}
965 
966 	return ret;
967 }
968 
hdmi_remove(struct snd_soc_component * component)969 static void hdmi_remove(struct snd_soc_component *component)
970 {
971 	struct hdmi_codec_priv *hcp = snd_soc_component_get_drvdata(component);
972 
973 	if (hcp->hcd.ops->hook_plugged_cb)
974 		hcp->hcd.ops->hook_plugged_cb(component->dev->parent,
975 					      hcp->hcd.data, NULL, NULL);
976 }
977 
978 static const struct snd_soc_component_driver hdmi_driver = {
979 	.probe			= hdmi_probe,
980 	.remove			= hdmi_remove,
981 	.dapm_widgets		= hdmi_widgets,
982 	.num_dapm_widgets	= ARRAY_SIZE(hdmi_widgets),
983 	.of_xlate_dai_id	= hdmi_of_xlate_dai_id,
984 	.idle_bias_on		= 1,
985 	.use_pmdown_time	= 1,
986 	.endianness		= 1,
987 	.set_jack		= hdmi_codec_set_jack,
988 };
989 
hdmi_codec_probe(struct platform_device * pdev)990 static int hdmi_codec_probe(struct platform_device *pdev)
991 {
992 	struct hdmi_codec_pdata *hcd = pdev->dev.platform_data;
993 	struct snd_soc_dai_driver *daidrv;
994 	struct device *dev = &pdev->dev;
995 	struct hdmi_codec_priv *hcp;
996 	int dai_count, i = 0;
997 	int ret;
998 
999 	if (!hcd) {
1000 		dev_err(dev, "%s: No platform data\n", __func__);
1001 		return -EINVAL;
1002 	}
1003 
1004 	dai_count = hcd->i2s + hcd->spdif;
1005 	if (dai_count < 1 || !hcd->ops ||
1006 	    (!hcd->ops->hw_params && !hcd->ops->prepare) ||
1007 	    !hcd->ops->audio_shutdown) {
1008 		dev_err(dev, "%s: Invalid parameters\n", __func__);
1009 		return -EINVAL;
1010 	}
1011 
1012 	hcp = devm_kzalloc(dev, sizeof(*hcp), GFP_KERNEL);
1013 	if (!hcp)
1014 		return -ENOMEM;
1015 
1016 	hcp->hcd = *hcd;
1017 	mutex_init(&hcp->lock);
1018 
1019 	ret = snd_pcm_create_iec958_consumer_default(hcp->iec_status,
1020 						     sizeof(hcp->iec_status));
1021 	if (ret < 0)
1022 		return ret;
1023 
1024 	daidrv = devm_kcalloc(dev, dai_count, sizeof(*daidrv), GFP_KERNEL);
1025 	if (!daidrv)
1026 		return -ENOMEM;
1027 
1028 	if (hcd->i2s) {
1029 		daidrv[i] = hdmi_i2s_dai;
1030 		daidrv[i].playback.channels_max = hcd->max_i2s_channels;
1031 		i++;
1032 	}
1033 
1034 	if (hcd->spdif)
1035 		daidrv[i] = hdmi_spdif_dai;
1036 
1037 	dev_set_drvdata(dev, hcp);
1038 
1039 	ret = devm_snd_soc_register_component(dev, &hdmi_driver, daidrv,
1040 					      dai_count);
1041 	if (ret) {
1042 		dev_err(dev, "%s: snd_soc_register_component() failed (%d)\n",
1043 			__func__, ret);
1044 		return ret;
1045 	}
1046 	return 0;
1047 }
1048 
1049 static struct platform_driver hdmi_codec_driver = {
1050 	.driver = {
1051 		.name = HDMI_CODEC_DRV_NAME,
1052 	},
1053 	.probe = hdmi_codec_probe,
1054 };
1055 
1056 module_platform_driver(hdmi_codec_driver);
1057 
1058 MODULE_AUTHOR("Jyri Sarha <jsarha@ti.com>");
1059 MODULE_DESCRIPTION("HDMI Audio Codec Driver");
1060 MODULE_LICENSE("GPL");
1061 MODULE_ALIAS("platform:" HDMI_CODEC_DRV_NAME);
1062