~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/codecs/hdac_hda.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 // Copyright(c) 2015-18 Intel Corporation.
  3 
  4 /*
  5  * hdac_hda.c - ASoC extensions to reuse the legacy HDA codec drivers
  6  * with ASoC platform drivers. These APIs are called by the legacy HDA
  7  * codec drivers using hdac_ext_bus_ops ops.
  8  */
  9 
 10 #include <linux/init.h>
 11 #include <linux/delay.h>
 12 #include <linux/module.h>
 13 #include <linux/pm_runtime.h>
 14 #include <sound/pcm_params.h>
 15 #include <sound/soc.h>
 16 #include <sound/hdaudio_ext.h>
 17 #include <sound/hda_codec.h>
 18 #include <sound/hda_register.h>
 19 #include "hdac_hda.h"
 20 
 21 #define HDAC_ANALOG_DAI_ID              0
 22 #define HDAC_DIGITAL_DAI_ID             1
 23 #define HDAC_ALT_ANALOG_DAI_ID          2
 24 
 25 #define STUB_FORMATS    (SNDRV_PCM_FMTBIT_S8 | \
 26                         SNDRV_PCM_FMTBIT_U8 | \
 27                         SNDRV_PCM_FMTBIT_S16_LE | \
 28                         SNDRV_PCM_FMTBIT_U16_LE | \
 29                         SNDRV_PCM_FMTBIT_S24_LE | \
 30                         SNDRV_PCM_FMTBIT_U24_LE | \
 31                         SNDRV_PCM_FMTBIT_S32_LE | \
 32                         SNDRV_PCM_FMTBIT_U32_LE | \
 33                         SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE)
 34 
 35 static int hdac_hda_dai_open(struct snd_pcm_substream *substream,
 36                              struct snd_soc_dai *dai);
 37 static void hdac_hda_dai_close(struct snd_pcm_substream *substream,
 38                                struct snd_soc_dai *dai);
 39 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
 40                                 struct snd_soc_dai *dai);
 41 static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream,
 42                                   struct snd_pcm_hw_params *params,
 43                                   struct snd_soc_dai *dai);
 44 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
 45                                 struct snd_soc_dai *dai);
 46 static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai,
 47                                      unsigned int tx_mask, unsigned int rx_mask,
 48                                      int slots, int slot_width);
 49 static struct hda_pcm *snd_soc_find_pcm_from_dai(struct hdac_hda_priv *hda_pvt,
 50                                                  struct snd_soc_dai *dai);
 51 
 52 static const struct snd_soc_dai_ops hdac_hda_dai_ops = {
 53         .startup = hdac_hda_dai_open,
 54         .shutdown = hdac_hda_dai_close,
 55         .prepare = hdac_hda_dai_prepare,
 56         .hw_params = hdac_hda_dai_hw_params,
 57         .hw_free = hdac_hda_dai_hw_free,
 58         .set_tdm_slot = hdac_hda_dai_set_tdm_slot,
 59 };
 60 
 61 static struct snd_soc_dai_driver hdac_hda_dais[] = {
 62 {
 63         .id = HDAC_ANALOG_DAI_ID,
 64         .name = "Analog Codec DAI",
 65         .ops = &hdac_hda_dai_ops,
 66         .playback = {
 67                 .stream_name    = "Analog Codec Playback",
 68                 .channels_min   = 1,
 69                 .channels_max   = 16,
 70                 .rates          = SNDRV_PCM_RATE_8000_192000,
 71                 .formats        = STUB_FORMATS,
 72                 .sig_bits       = 24,
 73         },
 74         .capture = {
 75                 .stream_name    = "Analog Codec Capture",
 76                 .channels_min   = 1,
 77                 .channels_max   = 16,
 78                 .rates = SNDRV_PCM_RATE_8000_192000,
 79                 .formats = STUB_FORMATS,
 80                 .sig_bits = 24,
 81         },
 82 },
 83 {
 84         .id = HDAC_DIGITAL_DAI_ID,
 85         .name = "Digital Codec DAI",
 86         .ops = &hdac_hda_dai_ops,
 87         .playback = {
 88                 .stream_name    = "Digital Codec Playback",
 89                 .channels_min   = 1,
 90                 .channels_max   = 16,
 91                 .rates          = SNDRV_PCM_RATE_8000_192000,
 92                 .formats        = STUB_FORMATS,
 93                 .sig_bits = 24,
 94         },
 95         .capture = {
 96                 .stream_name    = "Digital Codec Capture",
 97                 .channels_min   = 1,
 98                 .channels_max   = 16,
 99                 .rates = SNDRV_PCM_RATE_8000_192000,
100                 .formats = STUB_FORMATS,
101                 .sig_bits = 24,
102         },
103 },
104 {
105         .id = HDAC_ALT_ANALOG_DAI_ID,
106         .name = "Alt Analog Codec DAI",
107         .ops = &hdac_hda_dai_ops,
108         .playback = {
109                 .stream_name    = "Alt Analog Codec Playback",
110                 .channels_min   = 1,
111                 .channels_max   = 16,
112                 .rates          = SNDRV_PCM_RATE_8000_192000,
113                 .formats        = STUB_FORMATS,
114                 .sig_bits       = 24,
115         },
116         .capture = {
117                 .stream_name    = "Alt Analog Codec Capture",
118                 .channels_min   = 1,
119                 .channels_max   = 16,
120                 .rates = SNDRV_PCM_RATE_8000_192000,
121                 .formats = STUB_FORMATS,
122                 .sig_bits = 24,
123         },
124 }
125 
126 };
127 
128 static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai,
129                                      unsigned int tx_mask, unsigned int rx_mask,
130                                      int slots, int slot_width)
131 {
132         struct snd_soc_component *component = dai->component;
133         struct hdac_hda_priv *hda_pvt;
134         struct hdac_hda_pcm *pcm;
135 
136         hda_pvt = snd_soc_component_get_drvdata(component);
137         pcm = &hda_pvt->pcm[dai->id];
138         if (tx_mask)
139                 pcm[dai->id].stream_tag[SNDRV_PCM_STREAM_PLAYBACK] = tx_mask;
140         else
141                 pcm[dai->id].stream_tag[SNDRV_PCM_STREAM_CAPTURE] = rx_mask;
142 
143         return 0;
144 }
145 
146 static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream,
147                                   struct snd_pcm_hw_params *params,
148                                   struct snd_soc_dai *dai)
149 {
150         struct snd_soc_component *component = dai->component;
151         struct hdac_hda_priv *hda_pvt;
152         unsigned int format_val;
153         unsigned int maxbps;
154 
155         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
156                 maxbps = dai->driver->playback.sig_bits;
157         else
158                 maxbps = dai->driver->capture.sig_bits;
159 
160         hda_pvt = snd_soc_component_get_drvdata(component);
161         format_val = snd_hdac_calc_stream_format(params_rate(params),
162                                                  params_channels(params),
163                                                  params_format(params),
164                                                  maxbps,
165                                                  0);
166         if (!format_val) {
167                 dev_err(dai->dev,
168                         "invalid format_val, rate=%d, ch=%d, format=%d, maxbps=%d\n",
169                         params_rate(params), params_channels(params),
170                         params_format(params), maxbps);
171 
172                 return -EINVAL;
173         }
174 
175         hda_pvt->pcm[dai->id].format_val[substream->stream] = format_val;
176         return 0;
177 }
178 
179 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
180                                 struct snd_soc_dai *dai)
181 {
182         struct snd_soc_component *component = dai->component;
183         struct hdac_hda_priv *hda_pvt;
184         struct hda_pcm_stream *hda_stream;
185         struct hda_pcm *pcm;
186 
187         hda_pvt = snd_soc_component_get_drvdata(component);
188         pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
189         if (!pcm)
190                 return -EINVAL;
191 
192         hda_stream = &pcm->stream[substream->stream];
193         snd_hda_codec_cleanup(&hda_pvt->codec, hda_stream, substream);
194 
195         return 0;
196 }
197 
198 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
199                                 struct snd_soc_dai *dai)
200 {
201         struct snd_soc_component *component = dai->component;
202         struct hda_pcm_stream *hda_stream;
203         struct hdac_hda_priv *hda_pvt;
204         struct hdac_device *hdev;
205         unsigned int format_val;
206         struct hda_pcm *pcm;
207         unsigned int stream;
208         int ret = 0;
209 
210         hda_pvt = snd_soc_component_get_drvdata(component);
211         hdev = &hda_pvt->codec.core;
212         pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
213         if (!pcm)
214                 return -EINVAL;
215 
216         hda_stream = &pcm->stream[substream->stream];
217 
218         stream = hda_pvt->pcm[dai->id].stream_tag[substream->stream];
219         format_val = hda_pvt->pcm[dai->id].format_val[substream->stream];
220 
221         ret = snd_hda_codec_prepare(&hda_pvt->codec, hda_stream,
222                                     stream, format_val, substream);
223         if (ret < 0)
224                 dev_err(&hdev->dev, "codec prepare failed %d\n", ret);
225 
226         return ret;
227 }
228 
229 static int hdac_hda_dai_open(struct snd_pcm_substream *substream,
230                              struct snd_soc_dai *dai)
231 {
232         struct snd_soc_component *component = dai->component;
233         struct hdac_hda_priv *hda_pvt;
234         struct hda_pcm_stream *hda_stream;
235         struct hda_pcm *pcm;
236         int ret;
237 
238         hda_pvt = snd_soc_component_get_drvdata(component);
239         pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
240         if (!pcm)
241                 return -EINVAL;
242 
243         snd_hda_codec_pcm_get(pcm);
244 
245         hda_stream = &pcm->stream[substream->stream];
246 
247         ret = hda_stream->ops.open(hda_stream, &hda_pvt->codec, substream);
248         if (ret < 0)
249                 snd_hda_codec_pcm_put(pcm);
250 
251         return ret;
252 }
253 
254 static void hdac_hda_dai_close(struct snd_pcm_substream *substream,
255                                struct snd_soc_dai *dai)
256 {
257         struct snd_soc_component *component = dai->component;
258         struct hdac_hda_priv *hda_pvt;
259         struct hda_pcm_stream *hda_stream;
260         struct hda_pcm *pcm;
261 
262         hda_pvt = snd_soc_component_get_drvdata(component);
263         pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai);
264         if (!pcm)
265                 return;
266 
267         hda_stream = &pcm->stream[substream->stream];
268 
269         hda_stream->ops.close(hda_stream, &hda_pvt->codec, substream);
270 
271         snd_hda_codec_pcm_put(pcm);
272 }
273 
274 static struct hda_pcm *snd_soc_find_pcm_from_dai(struct hdac_hda_priv *hda_pvt,
275                                                  struct snd_soc_dai *dai)
276 {
277         struct hda_codec *hcodec = &hda_pvt->codec;
278         struct hda_pcm *cpcm;
279         const char *pcm_name;
280 
281         switch (dai->id) {
282         case HDAC_ANALOG_DAI_ID:
283                 pcm_name = "Analog";
284                 break;
285         case HDAC_DIGITAL_DAI_ID:
286                 pcm_name = "Digital";
287                 break;
288         case HDAC_ALT_ANALOG_DAI_ID:
289                 pcm_name = "Alt Analog";
290                 break;
291         default:
292                 dev_err(&hcodec->core.dev, "invalid dai id %d\n", dai->id);
293                 return NULL;
294         }
295 
296         list_for_each_entry(cpcm, &hcodec->pcm_list_head, list) {
297                 if (strpbrk(cpcm->name, pcm_name))
298                         return cpcm;
299         }
300 
301         dev_err(&hcodec->core.dev, "didn't find PCM for DAI %s\n", dai->name);
302         return NULL;
303 }
304 
305 static int hdac_hda_codec_probe(struct snd_soc_component *component)
306 {
307         struct hdac_hda_priv *hda_pvt =
308                         snd_soc_component_get_drvdata(component);
309         struct snd_soc_dapm_context *dapm =
310                         snd_soc_component_get_dapm(component);
311         struct hdac_device *hdev = &hda_pvt->codec.core;
312         struct hda_codec *hcodec = &hda_pvt->codec;
313         struct hdac_ext_link *hlink;
314         hda_codec_patch_t patch;
315         int ret;
316 
317         hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
318         if (!hlink) {
319                 dev_err(&hdev->dev, "hdac link not found\n");
320                 return -EIO;
321         }
322 
323         snd_hdac_ext_bus_link_get(hdev->bus, hlink);
324 
325         ret = snd_hda_codec_device_new(hcodec->bus, component->card->snd_card,
326                                        hdev->addr, hcodec);
327         if (ret < 0) {
328                 dev_err(&hdev->dev, "failed to create hda codec %d\n", ret);
329                 goto error_no_pm;
330         }
331         /*
332          * Overwrite type to HDA_DEV_ASOC since it is a ASoC driver
333          * hda_codec.c will check this flag to determine if unregister
334          * device is needed.
335          */
336         hdev->type = HDA_DEV_ASOC;
337 
338         /*
339          * snd_hda_codec_device_new decrements the usage count so call get pm
340          * else the device will be powered off
341          */
342         pm_runtime_get_noresume(&hdev->dev);
343 
344         hcodec->bus->card = dapm->card->snd_card;
345 
346         ret = snd_hda_codec_set_name(hcodec, hcodec->preset->name);
347         if (ret < 0) {
348                 dev_err(&hdev->dev, "name failed %s\n", hcodec->preset->name);
349                 goto error;
350         }
351 
352         ret = snd_hdac_regmap_init(&hcodec->core);
353         if (ret < 0) {
354                 dev_err(&hdev->dev, "regmap init failed\n");
355                 goto error;
356         }
357 
358         patch = (hda_codec_patch_t)hcodec->preset->driver_data;
359         if (patch) {
360                 ret = patch(hcodec);
361                 if (ret < 0) {
362                         dev_err(&hdev->dev, "patch failed %d\n", ret);
363                         goto error;
364                 }
365         } else {
366                 dev_dbg(&hdev->dev, "no patch file found\n");
367         }
368 
369         ret = snd_hda_codec_parse_pcms(hcodec);
370         if (ret < 0) {
371                 dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret);
372                 goto error;
373         }
374 
375         ret = snd_hda_codec_build_controls(hcodec);
376         if (ret < 0) {
377                 dev_err(&hdev->dev, "unable to create controls %d\n", ret);
378                 goto error;
379         }
380 
381         hcodec->core.lazy_cache = true;
382 
383         /*
384          * hdac_device core already sets the state to active and calls
385          * get_noresume. So enable runtime and set the device to suspend.
386          * pm_runtime_enable is also called during codec registeration
387          */
388         pm_runtime_put(&hdev->dev);
389         pm_runtime_suspend(&hdev->dev);
390 
391         return 0;
392 
393 error:
394         pm_runtime_put(&hdev->dev);
395 error_no_pm:
396         snd_hdac_ext_bus_link_put(hdev->bus, hlink);
397         return ret;
398 }
399 
400 static void hdac_hda_codec_remove(struct snd_soc_component *component)
401 {
402         struct hdac_hda_priv *hda_pvt =
403                       snd_soc_component_get_drvdata(component);
404         struct hdac_device *hdev = &hda_pvt->codec.core;
405         struct hdac_ext_link *hlink = NULL;
406 
407         hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
408         if (!hlink) {
409                 dev_err(&hdev->dev, "hdac link not found\n");
410                 return;
411         }
412 
413         pm_runtime_disable(&hdev->dev);
414         snd_hdac_ext_bus_link_put(hdev->bus, hlink);
415 }
416 
417 static const struct snd_soc_dapm_route hdac_hda_dapm_routes[] = {
418         {"AIF1TX", NULL, "Codec Input Pin1"},
419         {"AIF2TX", NULL, "Codec Input Pin2"},
420         {"AIF3TX", NULL, "Codec Input Pin3"},
421 
422         {"Codec Output Pin1", NULL, "AIF1RX"},
423         {"Codec Output Pin2", NULL, "AIF2RX"},
424         {"Codec Output Pin3", NULL, "AIF3RX"},
425 };
426 
427 static const struct snd_soc_dapm_widget hdac_hda_dapm_widgets[] = {
428         /* Audio Interface */
429         SND_SOC_DAPM_AIF_IN("AIF1RX", "Analog Codec Playback", 0,
430                             SND_SOC_NOPM, 0, 0),
431         SND_SOC_DAPM_AIF_IN("AIF2RX", "Digital Codec Playback", 0,
432                             SND_SOC_NOPM, 0, 0),
433         SND_SOC_DAPM_AIF_IN("AIF3RX", "Alt Analog Codec Playback", 0,
434                             SND_SOC_NOPM, 0, 0),
435         SND_SOC_DAPM_AIF_OUT("AIF1TX", "Analog Codec Capture", 0,
436                              SND_SOC_NOPM, 0, 0),
437         SND_SOC_DAPM_AIF_OUT("AIF2TX", "Digital Codec Capture", 0,
438                              SND_SOC_NOPM, 0, 0),
439         SND_SOC_DAPM_AIF_OUT("AIF3TX", "Alt Analog Codec Capture", 0,
440                              SND_SOC_NOPM, 0, 0),
441 
442         /* Input Pins */
443         SND_SOC_DAPM_INPUT("Codec Input Pin1"),
444         SND_SOC_DAPM_INPUT("Codec Input Pin2"),
445         SND_SOC_DAPM_INPUT("Codec Input Pin3"),
446 
447         /* Output Pins */
448         SND_SOC_DAPM_OUTPUT("Codec Output Pin1"),
449         SND_SOC_DAPM_OUTPUT("Codec Output Pin2"),
450         SND_SOC_DAPM_OUTPUT("Codec Output Pin3"),
451 };
452 
453 static const struct snd_soc_component_driver hdac_hda_codec = {
454         .probe          = hdac_hda_codec_probe,
455         .remove         = hdac_hda_codec_remove,
456         .idle_bias_on   = false,
457         .dapm_widgets           = hdac_hda_dapm_widgets,
458         .num_dapm_widgets       = ARRAY_SIZE(hdac_hda_dapm_widgets),
459         .dapm_routes            = hdac_hda_dapm_routes,
460         .num_dapm_routes        = ARRAY_SIZE(hdac_hda_dapm_routes),
461 };
462 
463 static int hdac_hda_dev_probe(struct hdac_device *hdev)
464 {
465         struct hdac_ext_link *hlink;
466         struct hdac_hda_priv *hda_pvt;
467         int ret;
468 
469         /* hold the ref while we probe */
470         hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev));
471         if (!hlink) {
472                 dev_err(&hdev->dev, "hdac link not found\n");
473                 return -EIO;
474         }
475         snd_hdac_ext_bus_link_get(hdev->bus, hlink);
476 
477         hda_pvt = hdac_to_hda_priv(hdev);
478         if (!hda_pvt)
479                 return -ENOMEM;
480 
481         /* ASoC specific initialization */
482         ret = devm_snd_soc_register_component(&hdev->dev,
483                                          &hdac_hda_codec, hdac_hda_dais,
484                                          ARRAY_SIZE(hdac_hda_dais));
485         if (ret < 0) {
486                 dev_err(&hdev->dev, "failed to register HDA codec %d\n", ret);
487                 return ret;
488         }
489 
490         dev_set_drvdata(&hdev->dev, hda_pvt);
491         snd_hdac_ext_bus_link_put(hdev->bus, hlink);
492 
493         return ret;
494 }
495 
496 static int hdac_hda_dev_remove(struct hdac_device *hdev)
497 {
498         struct hdac_hda_priv *hda_pvt;
499 
500         hda_pvt = dev_get_drvdata(&hdev->dev);
501         cancel_delayed_work_sync(&hda_pvt->codec.jackpoll_work);
502         return 0;
503 }
504 
505 static struct hdac_ext_bus_ops hdac_ops = {
506         .hdev_attach = hdac_hda_dev_probe,
507         .hdev_detach = hdac_hda_dev_remove,
508 };
509 
510 struct hdac_ext_bus_ops *snd_soc_hdac_hda_get_ops(void)
511 {
512         return &hdac_ops;
513 }
514 EXPORT_SYMBOL_GPL(snd_soc_hdac_hda_get_ops);
515 
516 MODULE_LICENSE("GPL v2");
517 MODULE_DESCRIPTION("ASoC Extensions for legacy HDA Drivers");
518 MODULE_AUTHOR("Rakesh Ughreja<rakesh.a.ughreja@intel.com>");
519 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp