sound/soc/codecs/hdac_hda.c

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