sound/soc/intel/boards/bdw-rt5677.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ASoC machine driver for Intel Broadwell platforms with RT5677 codec
   4  *
   5  * Copyright (c) 2014, The Chromium OS Authors.  All rights reserved.
   6  */
   7
   8 #include <linux/acpi.h>
   9 #include <linux/module.h>
  10 #include <linux/platform_device.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/delay.h>
  13 #include <sound/core.h>
  14 #include <sound/pcm.h>
  15 #include <sound/soc.h>
  16 #include <sound/pcm_params.h>
  17 #include <sound/jack.h>
  18 #include <sound/soc-acpi.h>
  19
  20 #include "../../codecs/rt5677.h"
  21
  22 struct bdw_rt5677_priv {
  23         struct gpio_desc *gpio_hp_en;
  24         struct snd_soc_component *component;
  25 };
  26
  27 static int bdw_rt5677_event_hp(struct snd_soc_dapm_widget *w,
  28                         struct snd_kcontrol *k, int event)
  29 {
  30         struct snd_soc_dapm_context *dapm = w->dapm;
  31         struct snd_soc_card *card = dapm->card;
  32         struct bdw_rt5677_priv *bdw_rt5677 = snd_soc_card_get_drvdata(card);
  33
  34         if (SND_SOC_DAPM_EVENT_ON(event))
  35                 msleep(70);
  36
  37         gpiod_set_value_cansleep(bdw_rt5677->gpio_hp_en,
  38                 SND_SOC_DAPM_EVENT_ON(event));
  39
  40         return 0;
  41 }
  42
  43 static const struct snd_soc_dapm_widget bdw_rt5677_widgets[] = {
  44         SND_SOC_DAPM_HP("Headphone", bdw_rt5677_event_hp),
  45         SND_SOC_DAPM_SPK("Speaker", NULL),
  46         SND_SOC_DAPM_MIC("Headset Mic", NULL),
  47         SND_SOC_DAPM_MIC("Local DMICs", NULL),
  48         SND_SOC_DAPM_MIC("Remote DMICs", NULL),
  49 };
  50
  51 static const struct snd_soc_dapm_route bdw_rt5677_map[] = {
  52         /* Speakers */
  53         {"Speaker", NULL, "PDM1L"},
  54         {"Speaker", NULL, "PDM1R"},
  55
  56         /* Headset jack connectors */
  57         {"Headphone", NULL, "LOUT1"},
  58         {"Headphone", NULL, "LOUT2"},
  59         {"IN1P", NULL, "Headset Mic"},
  60         {"IN1N", NULL, "Headset Mic"},
  61
  62         /* Digital MICs
  63          * Local DMICs: the two DMICs on the mainboard
  64          * Remote DMICs: the two DMICs on the camera module
  65          */
  66         {"DMIC L1", NULL, "Remote DMICs"},
  67         {"DMIC R1", NULL, "Remote DMICs"},
  68         {"DMIC L2", NULL, "Local DMICs"},
  69         {"DMIC R2", NULL, "Local DMICs"},
  70
  71         /* CODEC BE connections */
  72         {"SSP0 CODEC IN", NULL, "AIF1 Capture"},
  73         {"AIF1 Playback", NULL, "SSP0 CODEC OUT"},
  74         {"DSP Capture", NULL, "DSP Buffer"},
  75
  76         /* DSP Clock Connections */
  77         { "DSP Buffer", NULL, "SSP0 CODEC IN" },
  78         { "SSP0 CODEC IN", NULL, "DSPTX" },
  79 };
  80
  81 static const struct snd_kcontrol_new bdw_rt5677_controls[] = {
  82         SOC_DAPM_PIN_SWITCH("Speaker"),
  83         SOC_DAPM_PIN_SWITCH("Headphone"),
  84         SOC_DAPM_PIN_SWITCH("Headset Mic"),
  85         SOC_DAPM_PIN_SWITCH("Local DMICs"),
  86         SOC_DAPM_PIN_SWITCH("Remote DMICs"),
  87 };
  88
  89
  90 static struct snd_soc_jack headphone_jack;
  91 static struct snd_soc_jack mic_jack;
  92
  93 static struct snd_soc_jack_pin headphone_jack_pin = {
  94         .pin    = "Headphone",
  95         .mask   = SND_JACK_HEADPHONE,
  96 };
  97
  98 static struct snd_soc_jack_pin mic_jack_pin = {
  99         .pin    = "Headset Mic",
 100         .mask   = SND_JACK_MICROPHONE,
 101 };
 102
 103 static struct snd_soc_jack_gpio headphone_jack_gpio = {
 104         .name                   = "plug-det",
 105         .report                 = SND_JACK_HEADPHONE,
 106         .debounce_time          = 200,
 107 };
 108
 109 static struct snd_soc_jack_gpio mic_jack_gpio = {
 110         .name                   = "mic-present",
 111         .report                 = SND_JACK_MICROPHONE,
 112         .debounce_time          = 200,
 113         .invert                 = 1,
 114 };
 115
 116 /* GPIO indexes defined by ACPI */
 117 enum {
 118         RT5677_GPIO_PLUG_DET            = 0,
 119         RT5677_GPIO_MIC_PRESENT_L       = 1,
 120         RT5677_GPIO_HOTWORD_DET_L       = 2,
 121         RT5677_GPIO_DSP_INT             = 3,
 122         RT5677_GPIO_HP_AMP_SHDN_L       = 4,
 123 };
 124
 125 static const struct acpi_gpio_params plug_det_gpio = { RT5677_GPIO_PLUG_DET, 0, false };
 126 static const struct acpi_gpio_params mic_present_gpio = { RT5677_GPIO_MIC_PRESENT_L, 0, false };
 127 static const struct acpi_gpio_params headphone_enable_gpio = { RT5677_GPIO_HP_AMP_SHDN_L, 0, false };
 128
 129 static const struct acpi_gpio_mapping bdw_rt5677_gpios[] = {
 130         { "plug-det-gpios", &plug_det_gpio, 1 },
 131         { "mic-present-gpios", &mic_present_gpio, 1 },
 132         { "headphone-enable-gpios", &headphone_enable_gpio, 1 },
 133         { NULL },
 134 };
 135
 136 static int broadwell_ssp0_fixup(struct snd_soc_pcm_runtime *rtd,
 137                         struct snd_pcm_hw_params *params)
 138 {
 139         struct snd_interval *rate = hw_param_interval(params,
 140                                                       SNDRV_PCM_HW_PARAM_RATE);
 141         struct snd_interval *chan = hw_param_interval(params,
 142                                                       SNDRV_PCM_HW_PARAM_CHANNELS);
 143
 144         /* The ADSP will covert the FE rate to 48k, stereo */
 145         rate->min = rate->max = 48000;
 146         chan->min = chan->max = 2;
 147
 148         /* set SSP0 to 16 bit */
 149         params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
 150         return 0;
 151 }
 152
 153 static int bdw_rt5677_hw_params(struct snd_pcm_substream *substream,
 154         struct snd_pcm_hw_params *params)
 155 {
 156         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 157         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 158         int ret;
 159
 160         ret = snd_soc_dai_set_sysclk(codec_dai, RT5677_SCLK_S_MCLK, 24576000,
 161                 SND_SOC_CLOCK_IN);
 162         if (ret < 0) {
 163                 dev_err(rtd->dev, "can't set codec sysclk configuration\n");
 164                 return ret;
 165         }
 166
 167         return ret;
 168 }
 169
 170 static int bdw_rt5677_dsp_hw_params(struct snd_pcm_substream *substream,
 171         struct snd_pcm_hw_params *params)
 172 {
 173         struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 174         struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
 175         int ret;
 176
 177         ret = snd_soc_dai_set_sysclk(codec_dai, RT5677_SCLK_S_PLL1, 24576000,
 178                 SND_SOC_CLOCK_IN);
 179         if (ret < 0) {
 180                 dev_err(rtd->dev, "can't set codec sysclk configuration\n");
 181                 return ret;
 182         }
 183         ret = snd_soc_dai_set_pll(codec_dai, 0, RT5677_PLL1_S_MCLK,
 184                 24000000, 24576000);
 185         if (ret < 0) {
 186                 dev_err(rtd->dev, "can't set codec pll configuration\n");
 187                 return ret;
 188         }
 189
 190         return 0;
 191 }
 192
 193 static const struct snd_soc_ops bdw_rt5677_ops = {
 194         .hw_params = bdw_rt5677_hw_params,
 195 };
 196
 197 static const struct snd_soc_ops bdw_rt5677_dsp_ops = {
 198         .hw_params = bdw_rt5677_dsp_hw_params,
 199 };
 200
 201 static const unsigned int channels[] = {
 202         2,
 203 };
 204
 205 static const struct snd_pcm_hw_constraint_list constraints_channels = {
 206         .count = ARRAY_SIZE(channels),
 207         .list = channels,
 208         .mask = 0,
 209 };
 210
 211 static int bdw_rt5677_fe_startup(struct snd_pcm_substream *substream)
 212 {
 213         struct snd_pcm_runtime *runtime = substream->runtime;
 214
 215         /* Board supports stereo configuration only */
 216         runtime->hw.channels_max = 2;
 217         return snd_pcm_hw_constraint_list(runtime, 0,
 218                                           SNDRV_PCM_HW_PARAM_CHANNELS,
 219                                           &constraints_channels);
 220 }
 221
 222 static const struct snd_soc_ops bdw_rt5677_fe_ops = {
 223         .startup = bdw_rt5677_fe_startup,
 224 };
 225
 226 static int bdw_rt5677_init(struct snd_soc_pcm_runtime *rtd)
 227 {
 228         struct bdw_rt5677_priv *bdw_rt5677 =
 229                         snd_soc_card_get_drvdata(rtd->card);
 230         struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
 231         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 232         int ret;
 233
 234         ret = devm_acpi_dev_add_driver_gpios(component->dev, bdw_rt5677_gpios);
 235         if (ret)
 236                 dev_warn(component->dev, "Failed to add driver gpios\n");
 237
 238         /* Enable codec ASRC function for Stereo DAC/Stereo1 ADC/DMIC/I2S1.
 239          * The ASRC clock source is clk_i2s1_asrc.
 240          */
 241         rt5677_sel_asrc_clk_src(component, RT5677_DA_STEREO_FILTER |
 242                         RT5677_AD_STEREO1_FILTER | RT5677_I2S1_SOURCE,
 243                         RT5677_CLK_SEL_I2S1_ASRC);
 244         /* Enable codec ASRC function for Mono ADC L.
 245          * The ASRC clock source is clk_sys2_asrc.
 246          */
 247         rt5677_sel_asrc_clk_src(component, RT5677_AD_MONO_L_FILTER,
 248                         RT5677_CLK_SEL_SYS2);
 249
 250         /* Request rt5677 GPIO for headphone amp control */
 251         bdw_rt5677->gpio_hp_en = gpiod_get(component->dev, "headphone-enable",
 252                                            GPIOD_OUT_LOW);
 253         if (IS_ERR(bdw_rt5677->gpio_hp_en)) {
 254                 dev_err(component->dev, "Can't find HP_AMP_SHDN_L gpio\n");
 255                 return PTR_ERR(bdw_rt5677->gpio_hp_en);
 256         }
 257
 258         /* Create and initialize headphone jack */
 259         if (!snd_soc_card_jack_new(rtd->card, "Headphone Jack",
 260                         SND_JACK_HEADPHONE, &headphone_jack,
 261                         &headphone_jack_pin, 1)) {
 262                 headphone_jack_gpio.gpiod_dev = component->dev;
 263                 if (snd_soc_jack_add_gpios(&headphone_jack, 1,
 264                                 &headphone_jack_gpio))
 265                         dev_err(component->dev, "Can't add headphone jack gpio\n");
 266         } else {
 267                 dev_err(component->dev, "Can't create headphone jack\n");
 268         }
 269
 270         /* Create and initialize mic jack */
 271         if (!snd_soc_card_jack_new(rtd->card, "Mic Jack",
 272                         SND_JACK_MICROPHONE, &mic_jack,
 273                         &mic_jack_pin, 1)) {
 274                 mic_jack_gpio.gpiod_dev = component->dev;
 275                 if (snd_soc_jack_add_gpios(&mic_jack, 1, &mic_jack_gpio))
 276                         dev_err(component->dev, "Can't add mic jack gpio\n");
 277         } else {
 278                 dev_err(component->dev, "Can't create mic jack\n");
 279         }
 280         bdw_rt5677->component = component;
 281
 282         snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");
 283         return 0;
 284 }
 285
 286 static void bdw_rt5677_exit(struct snd_soc_pcm_runtime *rtd)
 287 {
 288         struct bdw_rt5677_priv *bdw_rt5677 =
 289                         snd_soc_card_get_drvdata(rtd->card);
 290
 291         /*
 292          * The .exit() can be reached without going through the .init()
 293          * so explicitly test if the gpiod is valid
 294          */
 295         if (!IS_ERR_OR_NULL(bdw_rt5677->gpio_hp_en))
 296                 gpiod_put(bdw_rt5677->gpio_hp_en);
 297 }
 298
 299 /* broadwell digital audio interface glue - connects codec <--> CPU */
 300 SND_SOC_DAILINK_DEF(dummy,
 301         DAILINK_COMP_ARRAY(COMP_DUMMY()));
 302
 303 SND_SOC_DAILINK_DEF(fe,
 304         DAILINK_COMP_ARRAY(COMP_CPU("System Pin")));
 305
 306 SND_SOC_DAILINK_DEF(platform,
 307         DAILINK_COMP_ARRAY(COMP_PLATFORM("haswell-pcm-audio")));
 308
 309 SND_SOC_DAILINK_DEF(be,
 310         DAILINK_COMP_ARRAY(COMP_CODEC("i2c-RT5677CE:00", "rt5677-aif1")));
 311
 312 SND_SOC_DAILINK_DEF(ssp0_port,
 313             DAILINK_COMP_ARRAY(COMP_CPU("ssp0-port")));
 314
 315 /* Wake on voice interface */
 316 SND_SOC_DAILINK_DEFS(dsp,
 317         DAILINK_COMP_ARRAY(COMP_CPU("spi-RT5677AA:00")),
 318         DAILINK_COMP_ARRAY(COMP_CODEC("i2c-RT5677CE:00", "rt5677-dspbuffer")),
 319         DAILINK_COMP_ARRAY(COMP_PLATFORM("spi-RT5677AA:00")));
 320
 321 static struct snd_soc_dai_link bdw_rt5677_dais[] = {
 322         /* Front End DAI links */
 323         {
 324                 .name = "System PCM",
 325                 .stream_name = "System Playback/Capture",
 326                 .nonatomic = 1,
 327                 .dynamic = 1,
 328                 .trigger = {
 329                         SND_SOC_DPCM_TRIGGER_POST,
 330                         SND_SOC_DPCM_TRIGGER_POST
 331                 },
 332                 .dpcm_capture = 1,
 333                 .dpcm_playback = 1,
 334                 .ops = &bdw_rt5677_fe_ops,
 335                 SND_SOC_DAILINK_REG(fe, dummy, platform),
 336         },
 337
 338         /* Non-DPCM links */
 339         {
 340                 .name = "Codec DSP",
 341                 .stream_name = "Wake on Voice",
 342                 .capture_only = 1,
 343                 .ops = &bdw_rt5677_dsp_ops,
 344                 SND_SOC_DAILINK_REG(dsp),
 345         },
 346
 347         /* Back End DAI links */
 348         {
 349                 /* SSP0 - Codec */
 350                 .name = "Codec",
 351                 .id = 0,
 352                 .no_pcm = 1,
 353                 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 354                         SND_SOC_DAIFMT_CBS_CFS,
 355                 .ignore_pmdown_time = 1,
 356                 .be_hw_params_fixup = broadwell_ssp0_fixup,
 357                 .ops = &bdw_rt5677_ops,
 358                 .dpcm_playback = 1,
 359                 .dpcm_capture = 1,
 360                 .init = bdw_rt5677_init,
 361                 .exit = bdw_rt5677_exit,
 362                 SND_SOC_DAILINK_REG(ssp0_port, be, platform),
 363         },
 364 };
 365
 366 static int bdw_rt5677_suspend_pre(struct snd_soc_card *card)
 367 {
 368         struct bdw_rt5677_priv *bdw_rt5677 = snd_soc_card_get_drvdata(card);
 369         struct snd_soc_dapm_context *dapm;
 370
 371         if (bdw_rt5677->component) {
 372                 dapm = snd_soc_component_get_dapm(bdw_rt5677->component);
 373                 snd_soc_dapm_disable_pin(dapm, "MICBIAS1");
 374         }
 375         return 0;
 376 }
 377
 378 static int bdw_rt5677_resume_post(struct snd_soc_card *card)
 379 {
 380         struct bdw_rt5677_priv *bdw_rt5677 = snd_soc_card_get_drvdata(card);
 381         struct snd_soc_dapm_context *dapm;
 382
 383         if (bdw_rt5677->component) {
 384                 dapm = snd_soc_component_get_dapm(bdw_rt5677->component);
 385                 snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1");
 386         }
 387         return 0;
 388 }
 389
 390 /* use space before codec name to simplify card ID, and simplify driver name */
 391 #define SOF_CARD_NAME "bdw rt5677" /* card name will be 'sof-bdw rt5677' */
 392 #define SOF_DRIVER_NAME "SOF"
 393
 394 #define CARD_NAME "bdw-rt5677"
 395 #define DRIVER_NAME NULL /* card name will be used for driver name */
 396
 397 /* ASoC machine driver for Broadwell DSP + RT5677 */
 398 static struct snd_soc_card bdw_rt5677_card = {
 399         .name = CARD_NAME,
 400         .driver_name = DRIVER_NAME,
 401         .owner = THIS_MODULE,
 402         .dai_link = bdw_rt5677_dais,
 403         .num_links = ARRAY_SIZE(bdw_rt5677_dais),
 404         .dapm_widgets = bdw_rt5677_widgets,
 405         .num_dapm_widgets = ARRAY_SIZE(bdw_rt5677_widgets),
 406         .dapm_routes = bdw_rt5677_map,
 407         .num_dapm_routes = ARRAY_SIZE(bdw_rt5677_map),
 408         .controls = bdw_rt5677_controls,
 409         .num_controls = ARRAY_SIZE(bdw_rt5677_controls),
 410         .fully_routed = true,
 411         .suspend_pre = bdw_rt5677_suspend_pre,
 412         .resume_post = bdw_rt5677_resume_post,
 413 };
 414
 415 static int bdw_rt5677_probe(struct platform_device *pdev)
 416 {
 417         struct bdw_rt5677_priv *bdw_rt5677;
 418         struct snd_soc_acpi_mach *mach;
 419         int ret;
 420
 421         bdw_rt5677_card.dev = &pdev->dev;
 422
 423         /* Allocate driver private struct */
 424         bdw_rt5677 = devm_kzalloc(&pdev->dev, sizeof(struct bdw_rt5677_priv),
 425                 GFP_KERNEL);
 426         if (!bdw_rt5677) {
 427                 dev_err(&pdev->dev, "Can't allocate bdw_rt5677\n");
 428                 return -ENOMEM;
 429         }
 430
 431         /* override plaform name, if required */
 432         mach = pdev->dev.platform_data;
 433         ret = snd_soc_fixup_dai_links_platform_name(&bdw_rt5677_card,
 434                                                     mach->mach_params.platform);
 435         if (ret)
 436                 return ret;
 437
 438         /* set card and driver name */
 439         if (snd_soc_acpi_sof_parent(&pdev->dev)) {
 440                 bdw_rt5677_card.name = SOF_CARD_NAME;
 441                 bdw_rt5677_card.driver_name = SOF_DRIVER_NAME;
 442         } else {
 443                 bdw_rt5677_card.name = CARD_NAME;
 444                 bdw_rt5677_card.driver_name = DRIVER_NAME;
 445         }
 446
 447         snd_soc_card_set_drvdata(&bdw_rt5677_card, bdw_rt5677);
 448
 449         return devm_snd_soc_register_card(&pdev->dev, &bdw_rt5677_card);
 450 }
 451
 452 static struct platform_driver bdw_rt5677_audio = {
 453         .probe = bdw_rt5677_probe,
 454         .driver = {
 455                 .name = "bdw-rt5677",
 456                 .pm = &snd_soc_pm_ops
 457         },
 458 };
 459
 460 module_platform_driver(bdw_rt5677_audio)
 461
 462 /* Module information */
 463 MODULE_AUTHOR("Ben Zhang");
 464 MODULE_DESCRIPTION("Intel Broadwell RT5677 machine driver");
 465 MODULE_LICENSE("GPL v2");
 466 MODULE_ALIAS("platform:bdw-rt5677");