sound/soc/codecs/sti-sas.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) STMicroelectronics SA 2015
   4  * Authors: Arnaud Pouliquen <[email protected]>
   5  *          for STMicroelectronics.
   6  */
   7
   8 #include <linux/io.h>
   9 #include <linux/module.h>
  10 #include <linux/regmap.h>
  11 #include <linux/reset.h>
  12 #include <linux/mfd/syscon.h>
  13
  14 #include <sound/soc.h>
  15 #include <sound/soc-dapm.h>
  16
  17 /* DAC definitions */
  18
  19 /* stih407 DAC registers */
  20 /* sysconf 5041: Audio-Gue-Control */
  21 #define STIH407_AUDIO_GLUE_CTRL 0x000000A4
  22 /* sysconf 5042: Audio-DAC-Control */
  23 #define STIH407_AUDIO_DAC_CTRL 0x000000A8
  24
  25 /* DAC definitions */
  26 #define STIH407_DAC_SOFTMUTE            0x0
  27 #define STIH407_DAC_STANDBY_ANA         0x1
  28 #define STIH407_DAC_STANDBY             0x2
  29
  30 #define STIH407_DAC_SOFTMUTE_MASK       BIT(STIH407_DAC_SOFTMUTE)
  31 #define STIH407_DAC_STANDBY_ANA_MASK    BIT(STIH407_DAC_STANDBY_ANA)
  32 #define STIH407_DAC_STANDBY_MASK        BIT(STIH407_DAC_STANDBY)
  33
  34 /* SPDIF definitions */
  35 #define SPDIF_BIPHASE_ENABLE            0x6
  36 #define SPDIF_BIPHASE_IDLE              0x7
  37
  38 #define SPDIF_BIPHASE_ENABLE_MASK       BIT(SPDIF_BIPHASE_ENABLE)
  39 #define SPDIF_BIPHASE_IDLE_MASK         BIT(SPDIF_BIPHASE_IDLE)
  40
  41 enum {
  42         STI_SAS_DAI_SPDIF_OUT,
  43         STI_SAS_DAI_ANALOG_OUT,
  44 };
  45
  46 static const struct reg_default stih407_sas_reg_defaults[] = {
  47         { STIH407_AUDIO_DAC_CTRL, 0x000000000 },
  48         { STIH407_AUDIO_GLUE_CTRL, 0x00000040 },
  49 };
  50
  51 struct sti_dac_audio {
  52         struct regmap *regmap;
  53         struct regmap *virt_regmap;
  54         int mclk;
  55 };
  56
  57 struct sti_spdif_audio {
  58         struct regmap *regmap;
  59         int mclk;
  60 };
  61
  62 /* device data structure */
  63 struct sti_sas_dev_data {
  64         const struct regmap_config *regmap;
  65         const struct snd_soc_dai_ops *dac_ops;  /* DAC function callbacks */
  66         const struct snd_soc_dapm_widget *dapm_widgets; /* dapms declaration */
  67         const int num_dapm_widgets; /* dapms declaration */
  68         const struct snd_soc_dapm_route *dapm_routes; /* route declaration */
  69         const int num_dapm_routes; /* route declaration */
  70 };
  71
  72 /* driver data structure */
  73 struct sti_sas_data {
  74         struct device *dev;
  75         const struct sti_sas_dev_data *dev_data;
  76         struct sti_dac_audio dac;
  77         struct sti_spdif_audio spdif;
  78 };
  79
  80 /* Read a register from the sysconf reg bank */
  81 static int sti_sas_read_reg(void *context, unsigned int reg,
  82                             unsigned int *value)
  83 {
  84         struct sti_sas_data *drvdata = context;
  85         int status;
  86         u32 val;
  87
  88         status = regmap_read(drvdata->dac.regmap, reg, &val);
  89         *value = (unsigned int)val;
  90
  91         return status;
  92 }
  93
  94 /* Read a register from the sysconf reg bank */
  95 static int sti_sas_write_reg(void *context, unsigned int reg,
  96                              unsigned int value)
  97 {
  98         struct sti_sas_data *drvdata = context;
  99
 100         return regmap_write(drvdata->dac.regmap, reg, value);
 101 }
 102
 103 static int  sti_sas_init_sas_registers(struct snd_soc_component *component,
 104                                        struct sti_sas_data *data)
 105 {
 106         int ret;
 107         /*
 108          * DAC and SPDIF are activated by default
 109          * put them in IDLE to save power
 110          */
 111
 112         /* Initialise bi-phase formatter to disabled */
 113         ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 114                                   SPDIF_BIPHASE_ENABLE_MASK, 0);
 115
 116         if (!ret)
 117                 /* Initialise bi-phase formatter idle value to 0 */
 118                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 119                                           SPDIF_BIPHASE_IDLE_MASK, 0);
 120         if (ret < 0) {
 121                 dev_err(component->dev, "Failed to update SPDIF registers\n");
 122                 return ret;
 123         }
 124
 125         /* Init DAC configuration */
 126         /* init configuration */
 127         ret =  snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 128                                    STIH407_DAC_STANDBY_MASK,
 129                                    STIH407_DAC_STANDBY_MASK);
 130
 131         if (!ret)
 132                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 133                                           STIH407_DAC_STANDBY_ANA_MASK,
 134                                           STIH407_DAC_STANDBY_ANA_MASK);
 135         if (!ret)
 136                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 137                                           STIH407_DAC_SOFTMUTE_MASK,
 138                                           STIH407_DAC_SOFTMUTE_MASK);
 139
 140         if (ret < 0) {
 141                 dev_err(component->dev, "Failed to update DAC registers\n");
 142                 return ret;
 143         }
 144
 145         return ret;
 146 }
 147
 148 /*
 149  * DAC
 150  */
 151 static int sti_sas_dac_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 152 {
 153         /* Sanity check only */
 154         if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_CBC_CFC) {
 155                 dev_err(dai->component->dev,
 156                         "%s: ERROR: Unsupported clocking 0x%x\n",
 157                         __func__, fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK);
 158                 return -EINVAL;
 159         }
 160
 161         return 0;
 162 }
 163
 164 static const struct snd_soc_dapm_widget stih407_sas_dapm_widgets[] = {
 165         SND_SOC_DAPM_OUT_DRV("DAC standby ana", STIH407_AUDIO_DAC_CTRL,
 166                              STIH407_DAC_STANDBY_ANA, 1, NULL, 0),
 167         SND_SOC_DAPM_DAC("DAC standby",  "dac_p", STIH407_AUDIO_DAC_CTRL,
 168                          STIH407_DAC_STANDBY, 1),
 169         SND_SOC_DAPM_OUTPUT("DAC Output"),
 170 };
 171
 172 static const struct snd_soc_dapm_route stih407_sas_route[] = {
 173         {"DAC Output", NULL, "DAC standby ana"},
 174         {"DAC standby ana", NULL, "DAC standby"},
 175 };
 176
 177
 178 static int stih407_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
 179 {
 180         struct snd_soc_component *component = dai->component;
 181
 182         if (mute) {
 183                 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 184                                             STIH407_DAC_SOFTMUTE_MASK,
 185                                             STIH407_DAC_SOFTMUTE_MASK);
 186         } else {
 187                 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 188                                             STIH407_DAC_SOFTMUTE_MASK,
 189                                             0);
 190         }
 191 }
 192
 193 /*
 194  * SPDIF
 195  */
 196 static int sti_sas_spdif_set_fmt(struct snd_soc_dai *dai,
 197                                  unsigned int fmt)
 198 {
 199         if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_CBC_CFC) {
 200                 dev_err(dai->component->dev,
 201                         "%s: ERROR: Unsupported clocking mask 0x%x\n",
 202                         __func__, fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK);
 203                 return -EINVAL;
 204         }
 205
 206         return 0;
 207 }
 208
 209 /*
 210  * sti_sas_spdif_trigger:
 211  * Trigger function is used to ensure that BiPhase Formater is disabled
 212  * before CPU dai is stopped.
 213  * This is mandatory to avoid that BPF is stalled
 214  */
 215 static int sti_sas_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
 216                                  struct snd_soc_dai *dai)
 217 {
 218         struct snd_soc_component *component = dai->component;
 219
 220         switch (cmd) {
 221         case SNDRV_PCM_TRIGGER_START:
 222         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 223                 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 224                                             SPDIF_BIPHASE_ENABLE_MASK,
 225                                             SPDIF_BIPHASE_ENABLE_MASK);
 226         case SNDRV_PCM_TRIGGER_RESUME:
 227         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 228         case SNDRV_PCM_TRIGGER_STOP:
 229         case SNDRV_PCM_TRIGGER_SUSPEND:
 230                 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 231                                             SPDIF_BIPHASE_ENABLE_MASK,
 232                                             0);
 233         default:
 234                 return -EINVAL;
 235         }
 236 }
 237
 238 static bool sti_sas_volatile_register(struct device *dev, unsigned int reg)
 239 {
 240         if (reg == STIH407_AUDIO_GLUE_CTRL)
 241                 return true;
 242
 243         return false;
 244 }
 245
 246 /*
 247  * CODEC DAIS
 248  */
 249
 250 /*
 251  * sti_sas_set_sysclk:
 252  * get MCLK input frequency to check that MCLK-FS ratio is coherent
 253  */
 254 static int sti_sas_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 255                               unsigned int freq, int dir)
 256 {
 257         struct snd_soc_component *component = dai->component;
 258         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 259
 260         if (dir == SND_SOC_CLOCK_OUT)
 261                 return 0;
 262
 263         if (clk_id != 0)
 264                 return -EINVAL;
 265
 266         switch (dai->id) {
 267         case STI_SAS_DAI_SPDIF_OUT:
 268                 drvdata->spdif.mclk = freq;
 269                 break;
 270
 271         case STI_SAS_DAI_ANALOG_OUT:
 272                 drvdata->dac.mclk = freq;
 273                 break;
 274         }
 275
 276         return 0;
 277 }
 278
 279 static int sti_sas_prepare(struct snd_pcm_substream *substream,
 280                            struct snd_soc_dai *dai)
 281 {
 282         struct snd_soc_component *component = dai->component;
 283         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 284         struct snd_pcm_runtime *runtime = substream->runtime;
 285
 286         switch (dai->id) {
 287         case STI_SAS_DAI_SPDIF_OUT:
 288                 if ((drvdata->spdif.mclk / runtime->rate) != 128) {
 289                         dev_err(component->dev, "unexpected mclk-fs ratio\n");
 290                         return -EINVAL;
 291                 }
 292                 break;
 293         case STI_SAS_DAI_ANALOG_OUT:
 294                 if ((drvdata->dac.mclk / runtime->rate) != 256) {
 295                         dev_err(component->dev, "unexpected mclk-fs ratio\n");
 296                         return -EINVAL;
 297                 }
 298                 break;
 299         }
 300
 301         return 0;
 302 }
 303
 304 static const struct snd_soc_dai_ops stih407_dac_ops = {
 305         .set_fmt = sti_sas_dac_set_fmt,
 306         .mute_stream = stih407_sas_dac_mute,
 307         .prepare = sti_sas_prepare,
 308         .set_sysclk = sti_sas_set_sysclk,
 309 };
 310
 311 static const struct regmap_config stih407_sas_regmap = {
 312         .reg_bits = 32,
 313         .val_bits = 32,
 314         .fast_io = true,
 315         .max_register = STIH407_AUDIO_DAC_CTRL,
 316         .reg_defaults = stih407_sas_reg_defaults,
 317         .num_reg_defaults = ARRAY_SIZE(stih407_sas_reg_defaults),
 318         .volatile_reg = sti_sas_volatile_register,
 319         .cache_type = REGCACHE_MAPLE,
 320         .reg_read = sti_sas_read_reg,
 321         .reg_write = sti_sas_write_reg,
 322 };
 323
 324 static const struct sti_sas_dev_data stih407_data = {
 325         .regmap = &stih407_sas_regmap,
 326         .dac_ops = &stih407_dac_ops,
 327         .dapm_widgets = stih407_sas_dapm_widgets,
 328         .num_dapm_widgets = ARRAY_SIZE(stih407_sas_dapm_widgets),
 329         .dapm_routes =  stih407_sas_route,
 330         .num_dapm_routes = ARRAY_SIZE(stih407_sas_route),
 331 };
 332
 333 static struct snd_soc_dai_driver sti_sas_dai[] = {
 334         {
 335                 .name = "sas-dai-spdif-out",
 336                 .id = STI_SAS_DAI_SPDIF_OUT,
 337                 .playback = {
 338                         .stream_name = "spdif_p",
 339                         .channels_min = 2,
 340                         .channels_max = 2,
 341                         .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
 342                                  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |
 343                                  SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
 344                                  SNDRV_PCM_RATE_192000,
 345                         .formats = SNDRV_PCM_FMTBIT_S16_LE |
 346                                    SNDRV_PCM_FMTBIT_S32_LE,
 347                 },
 348                 .ops = (struct snd_soc_dai_ops[]) {
 349                         {
 350                                 .set_fmt = sti_sas_spdif_set_fmt,
 351                                 .trigger = sti_sas_spdif_trigger,
 352                                 .set_sysclk = sti_sas_set_sysclk,
 353                                 .prepare = sti_sas_prepare,
 354                         }
 355                 },
 356         },
 357         {
 358                 .name = "sas-dai-dac",
 359                 .id = STI_SAS_DAI_ANALOG_OUT,
 360                 .playback = {
 361                         .stream_name = "dac_p",
 362                         .channels_min = 2,
 363                         .channels_max = 2,
 364                         .rates = SNDRV_PCM_RATE_8000_48000,
 365                         .formats = SNDRV_PCM_FMTBIT_S16_LE |
 366                                    SNDRV_PCM_FMTBIT_S32_LE,
 367                 },
 368         },
 369 };
 370
 371 #ifdef CONFIG_PM_SLEEP
 372 static int sti_sas_resume(struct snd_soc_component *component)
 373 {
 374         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 375
 376         return sti_sas_init_sas_registers(component, drvdata);
 377 }
 378 #else
 379 #define sti_sas_resume NULL
 380 #endif
 381
 382 static int sti_sas_component_probe(struct snd_soc_component *component)
 383 {
 384         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 385
 386         return sti_sas_init_sas_registers(component, drvdata);
 387 }
 388
 389 static struct snd_soc_component_driver sti_sas_driver = {
 390         .probe                  = sti_sas_component_probe,
 391         .resume                 = sti_sas_resume,
 392         .idle_bias_on           = 1,
 393         .use_pmdown_time        = 1,
 394         .endianness             = 1,
 395 };
 396
 397 static const struct of_device_id sti_sas_dev_match[] = {
 398         {
 399                 .compatible = "st,stih407-sas-codec",
 400                 .data = &stih407_data,
 401         },
 402         {},
 403 };
 404 MODULE_DEVICE_TABLE(of, sti_sas_dev_match);
 405
 406 static int sti_sas_driver_probe(struct platform_device *pdev)
 407 {
 408         struct device_node *pnode = pdev->dev.of_node;
 409         struct sti_sas_data *drvdata;
 410         const struct of_device_id *of_id;
 411
 412         /* Allocate device structure */
 413         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data),
 414                                GFP_KERNEL);
 415         if (!drvdata)
 416                 return -ENOMEM;
 417
 418         /* Populate data structure depending on compatibility */
 419         of_id = of_match_node(sti_sas_dev_match, pnode);
 420         if (!of_id->data) {
 421                 dev_err(&pdev->dev, "data associated to device is missing\n");
 422                 return -EINVAL;
 423         }
 424
 425         drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data;
 426
 427         /* Initialise device structure */
 428         drvdata->dev = &pdev->dev;
 429
 430         /* Request the DAC & SPDIF registers memory region */
 431         drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata,
 432                                                     drvdata->dev_data->regmap);
 433         if (IS_ERR(drvdata->dac.virt_regmap)) {
 434                 dev_err(&pdev->dev, "audio registers not enabled\n");
 435                 return PTR_ERR(drvdata->dac.virt_regmap);
 436         }
 437
 438         /* Request the syscon region */
 439         drvdata->dac.regmap =
 440                 syscon_regmap_lookup_by_phandle(pnode, "st,syscfg");
 441         if (IS_ERR(drvdata->dac.regmap)) {
 442                 dev_err(&pdev->dev, "syscon registers not available\n");
 443                 return PTR_ERR(drvdata->dac.regmap);
 444         }
 445         drvdata->spdif.regmap = drvdata->dac.regmap;
 446
 447         sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops;
 448
 449         /* Set dapms*/
 450         sti_sas_driver.dapm_widgets = drvdata->dev_data->dapm_widgets;
 451         sti_sas_driver.num_dapm_widgets = drvdata->dev_data->num_dapm_widgets;
 452
 453         sti_sas_driver.dapm_routes = drvdata->dev_data->dapm_routes;
 454         sti_sas_driver.num_dapm_routes = drvdata->dev_data->num_dapm_routes;
 455
 456         /* Store context */
 457         dev_set_drvdata(&pdev->dev, drvdata);
 458
 459         return devm_snd_soc_register_component(&pdev->dev, &sti_sas_driver,
 460                                         sti_sas_dai,
 461                                         ARRAY_SIZE(sti_sas_dai));
 462 }
 463
 464 static struct platform_driver sti_sas_platform_driver = {
 465         .driver = {
 466                 .name = "sti-sas-codec",
 467                 .of_match_table = sti_sas_dev_match,
 468         },
 469         .probe = sti_sas_driver_probe,
 470 };
 471
 472 module_platform_driver(sti_sas_platform_driver);
 473
 474 MODULE_DESCRIPTION("audio codec for STMicroelectronics sti platforms");
 475 MODULE_AUTHOR("[email protected]");
 476 MODULE_LICENSE("GPL v2");