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 <arnaud.pouliquen@st.com>
   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         int status;
 100
 101         status = regmap_write(drvdata->dac.regmap, reg, value);
 102
 103         return status;
 104 }
 105
 106 static int  sti_sas_init_sas_registers(struct snd_soc_component *component,
 107                                        struct sti_sas_data *data)
 108 {
 109         int ret;
 110         /*
 111          * DAC and SPDIF are activated by default
 112          * put them in IDLE to save power
 113          */
 114
 115         /* Initialise bi-phase formatter to disabled */
 116         ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 117                                   SPDIF_BIPHASE_ENABLE_MASK, 0);
 118
 119         if (!ret)
 120                 /* Initialise bi-phase formatter idle value to 0 */
 121                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 122                                           SPDIF_BIPHASE_IDLE_MASK, 0);
 123         if (ret < 0) {
 124                 dev_err(component->dev, "Failed to update SPDIF registers\n");
 125                 return ret;
 126         }
 127
 128         /* Init DAC configuration */
 129         /* init configuration */
 130         ret =  snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 131                                    STIH407_DAC_STANDBY_MASK,
 132                                    STIH407_DAC_STANDBY_MASK);
 133
 134         if (!ret)
 135                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 136                                           STIH407_DAC_STANDBY_ANA_MASK,
 137                                           STIH407_DAC_STANDBY_ANA_MASK);
 138         if (!ret)
 139                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 140                                           STIH407_DAC_SOFTMUTE_MASK,
 141                                           STIH407_DAC_SOFTMUTE_MASK);
 142
 143         if (ret < 0) {
 144                 dev_err(component->dev, "Failed to update DAC registers\n");
 145                 return ret;
 146         }
 147
 148         return ret;
 149 }
 150
 151 /*
 152  * DAC
 153  */
 154 static int sti_sas_dac_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 155 {
 156         /* Sanity check only */
 157         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
 158                 dev_err(dai->component->dev,
 159                         "%s: ERROR: Unsupporter master mask 0x%x\n",
 160                         __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
 161                 return -EINVAL;
 162         }
 163
 164         return 0;
 165 }
 166
 167 static const struct snd_soc_dapm_widget stih407_sas_dapm_widgets[] = {
 168         SND_SOC_DAPM_OUT_DRV("DAC standby ana", STIH407_AUDIO_DAC_CTRL,
 169                              STIH407_DAC_STANDBY_ANA, 1, NULL, 0),
 170         SND_SOC_DAPM_DAC("DAC standby",  "dac_p", STIH407_AUDIO_DAC_CTRL,
 171                          STIH407_DAC_STANDBY, 1),
 172         SND_SOC_DAPM_OUTPUT("DAC Output"),
 173 };
 174
 175 static const struct snd_soc_dapm_route stih407_sas_route[] = {
 176         {"DAC Output", NULL, "DAC standby ana"},
 177         {"DAC standby ana", NULL, "DAC standby"},
 178 };
 179
 180
 181 static int stih407_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
 182 {
 183         struct snd_soc_component *component = dai->component;
 184
 185         if (mute) {
 186                 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 187                                             STIH407_DAC_SOFTMUTE_MASK,
 188                                             STIH407_DAC_SOFTMUTE_MASK);
 189         } else {
 190                 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
 191                                             STIH407_DAC_SOFTMUTE_MASK,
 192                                             0);
 193         }
 194 }
 195
 196 /*
 197  * SPDIF
 198  */
 199 static int sti_sas_spdif_set_fmt(struct snd_soc_dai *dai,
 200                                  unsigned int fmt)
 201 {
 202         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
 203                 dev_err(dai->component->dev,
 204                         "%s: ERROR: Unsupporter master mask 0x%x\n",
 205                         __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
 206                 return -EINVAL;
 207         }
 208
 209         return 0;
 210 }
 211
 212 /*
 213  * sti_sas_spdif_trigger:
 214  * Trigger function is used to ensure that BiPhase Formater is disabled
 215  * before CPU dai is stopped.
 216  * This is mandatory to avoid that BPF is stalled
 217  */
 218 static int sti_sas_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
 219                                  struct snd_soc_dai *dai)
 220 {
 221         struct snd_soc_component *component = dai->component;
 222
 223         switch (cmd) {
 224         case SNDRV_PCM_TRIGGER_START:
 225         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 226                 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 227                                             SPDIF_BIPHASE_ENABLE_MASK,
 228                                             SPDIF_BIPHASE_ENABLE_MASK);
 229         case SNDRV_PCM_TRIGGER_RESUME:
 230         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 231         case SNDRV_PCM_TRIGGER_STOP:
 232         case SNDRV_PCM_TRIGGER_SUSPEND:
 233                 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
 234                                             SPDIF_BIPHASE_ENABLE_MASK,
 235                                             0);
 236         default:
 237                 return -EINVAL;
 238         }
 239 }
 240
 241 static bool sti_sas_volatile_register(struct device *dev, unsigned int reg)
 242 {
 243         if (reg == STIH407_AUDIO_GLUE_CTRL)
 244                 return true;
 245
 246         return false;
 247 }
 248
 249 /*
 250  * CODEC DAIS
 251  */
 252
 253 /*
 254  * sti_sas_set_sysclk:
 255  * get MCLK input frequency to check that MCLK-FS ratio is coherent
 256  */
 257 static int sti_sas_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 258                               unsigned int freq, int dir)
 259 {
 260         struct snd_soc_component *component = dai->component;
 261         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 262
 263         if (dir == SND_SOC_CLOCK_OUT)
 264                 return 0;
 265
 266         if (clk_id != 0)
 267                 return -EINVAL;
 268
 269         switch (dai->id) {
 270         case STI_SAS_DAI_SPDIF_OUT:
 271                 drvdata->spdif.mclk = freq;
 272                 break;
 273
 274         case STI_SAS_DAI_ANALOG_OUT:
 275                 drvdata->dac.mclk = freq;
 276                 break;
 277         }
 278
 279         return 0;
 280 }
 281
 282 static int sti_sas_prepare(struct snd_pcm_substream *substream,
 283                            struct snd_soc_dai *dai)
 284 {
 285         struct snd_soc_component *component = dai->component;
 286         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 287         struct snd_pcm_runtime *runtime = substream->runtime;
 288
 289         switch (dai->id) {
 290         case STI_SAS_DAI_SPDIF_OUT:
 291                 if ((drvdata->spdif.mclk / runtime->rate) != 128) {
 292                         dev_err(component->dev, "unexpected mclk-fs ratio\n");
 293                         return -EINVAL;
 294                 }
 295                 break;
 296         case STI_SAS_DAI_ANALOG_OUT:
 297                 if ((drvdata->dac.mclk / runtime->rate) != 256) {
 298                         dev_err(component->dev, "unexpected mclk-fs ratio\n");
 299                         return -EINVAL;
 300                 }
 301                 break;
 302         }
 303
 304         return 0;
 305 }
 306
 307 static const struct snd_soc_dai_ops stih407_dac_ops = {
 308         .set_fmt = sti_sas_dac_set_fmt,
 309         .mute_stream = stih407_sas_dac_mute,
 310         .prepare = sti_sas_prepare,
 311         .set_sysclk = sti_sas_set_sysclk,
 312 };
 313
 314 static const struct regmap_config stih407_sas_regmap = {
 315         .reg_bits = 32,
 316         .val_bits = 32,
 317         .fast_io = true,
 318         .max_register = STIH407_AUDIO_DAC_CTRL,
 319         .reg_defaults = stih407_sas_reg_defaults,
 320         .num_reg_defaults = ARRAY_SIZE(stih407_sas_reg_defaults),
 321         .volatile_reg = sti_sas_volatile_register,
 322         .cache_type = REGCACHE_RBTREE,
 323         .reg_read = sti_sas_read_reg,
 324         .reg_write = sti_sas_write_reg,
 325 };
 326
 327 static const struct sti_sas_dev_data stih407_data = {
 328         .regmap = &stih407_sas_regmap,
 329         .dac_ops = &stih407_dac_ops,
 330         .dapm_widgets = stih407_sas_dapm_widgets,
 331         .num_dapm_widgets = ARRAY_SIZE(stih407_sas_dapm_widgets),
 332         .dapm_routes =  stih407_sas_route,
 333         .num_dapm_routes = ARRAY_SIZE(stih407_sas_route),
 334 };
 335
 336 static struct snd_soc_dai_driver sti_sas_dai[] = {
 337         {
 338                 .name = "sas-dai-spdif-out",
 339                 .id = STI_SAS_DAI_SPDIF_OUT,
 340                 .playback = {
 341                         .stream_name = "spdif_p",
 342                         .channels_min = 2,
 343                         .channels_max = 2,
 344                         .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
 345                                  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |
 346                                  SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
 347                                  SNDRV_PCM_RATE_192000,
 348                         .formats = SNDRV_PCM_FMTBIT_S16_LE |
 349                                    SNDRV_PCM_FMTBIT_S32_LE,
 350                 },
 351                 .ops = (struct snd_soc_dai_ops[]) {
 352                         {
 353                                 .set_fmt = sti_sas_spdif_set_fmt,
 354                                 .trigger = sti_sas_spdif_trigger,
 355                                 .set_sysclk = sti_sas_set_sysclk,
 356                                 .prepare = sti_sas_prepare,
 357                         }
 358                 },
 359         },
 360         {
 361                 .name = "sas-dai-dac",
 362                 .id = STI_SAS_DAI_ANALOG_OUT,
 363                 .playback = {
 364                         .stream_name = "dac_p",
 365                         .channels_min = 2,
 366                         .channels_max = 2,
 367                         .rates = SNDRV_PCM_RATE_8000_48000,
 368                         .formats = SNDRV_PCM_FMTBIT_S16_LE |
 369                                    SNDRV_PCM_FMTBIT_S32_LE,
 370                 },
 371         },
 372 };
 373
 374 #ifdef CONFIG_PM_SLEEP
 375 static int sti_sas_resume(struct snd_soc_component *component)
 376 {
 377         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 378
 379         return sti_sas_init_sas_registers(component, drvdata);
 380 }
 381 #else
 382 #define sti_sas_resume NULL
 383 #endif
 384
 385 static int sti_sas_component_probe(struct snd_soc_component *component)
 386 {
 387         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
 388         int ret;
 389
 390         ret = sti_sas_init_sas_registers(component, drvdata);
 391
 392         return ret;
 393 }
 394
 395 static struct snd_soc_component_driver sti_sas_driver = {
 396         .probe                  = sti_sas_component_probe,
 397         .resume                 = sti_sas_resume,
 398         .idle_bias_on           = 1,
 399         .use_pmdown_time        = 1,
 400         .endianness             = 1,
 401         .non_legacy_dai_naming  = 1,
 402 };
 403
 404 static const struct of_device_id sti_sas_dev_match[] = {
 405         {
 406                 .compatible = "st,stih407-sas-codec",
 407                 .data = &stih407_data,
 408         },
 409         {},
 410 };
 411 MODULE_DEVICE_TABLE(of, sti_sas_dev_match);
 412
 413 static int sti_sas_driver_probe(struct platform_device *pdev)
 414 {
 415         struct device_node *pnode = pdev->dev.of_node;
 416         struct sti_sas_data *drvdata;
 417         const struct of_device_id *of_id;
 418
 419         /* Allocate device structure */
 420         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data),
 421                                GFP_KERNEL);
 422         if (!drvdata)
 423                 return -ENOMEM;
 424
 425         /* Populate data structure depending on compatibility */
 426         of_id = of_match_node(sti_sas_dev_match, pnode);
 427         if (!of_id->data) {
 428                 dev_err(&pdev->dev, "data associated to device is missing\n");
 429                 return -EINVAL;
 430         }
 431
 432         drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data;
 433
 434         /* Initialise device structure */
 435         drvdata->dev = &pdev->dev;
 436
 437         /* Request the DAC & SPDIF registers memory region */
 438         drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata,
 439                                                     drvdata->dev_data->regmap);
 440         if (IS_ERR(drvdata->dac.virt_regmap)) {
 441                 dev_err(&pdev->dev, "audio registers not enabled\n");
 442                 return PTR_ERR(drvdata->dac.virt_regmap);
 443         }
 444
 445         /* Request the syscon region */
 446         drvdata->dac.regmap =
 447                 syscon_regmap_lookup_by_phandle(pnode, "st,syscfg");
 448         if (IS_ERR(drvdata->dac.regmap)) {
 449                 dev_err(&pdev->dev, "syscon registers not available\n");
 450                 return PTR_ERR(drvdata->dac.regmap);
 451         }
 452         drvdata->spdif.regmap = drvdata->dac.regmap;
 453
 454         sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops;
 455
 456         /* Set dapms*/
 457         sti_sas_driver.dapm_widgets = drvdata->dev_data->dapm_widgets;
 458         sti_sas_driver.num_dapm_widgets = drvdata->dev_data->num_dapm_widgets;
 459
 460         sti_sas_driver.dapm_routes = drvdata->dev_data->dapm_routes;
 461         sti_sas_driver.num_dapm_routes = drvdata->dev_data->num_dapm_routes;
 462
 463         /* Store context */
 464         dev_set_drvdata(&pdev->dev, drvdata);
 465
 466         return devm_snd_soc_register_component(&pdev->dev, &sti_sas_driver,
 467                                         sti_sas_dai,
 468                                         ARRAY_SIZE(sti_sas_dai));
 469 }
 470
 471 static struct platform_driver sti_sas_platform_driver = {
 472         .driver = {
 473                 .name = "sti-sas-codec",
 474                 .of_match_table = sti_sas_dev_match,
 475         },
 476         .probe = sti_sas_driver_probe,
 477 };
 478
 479 module_platform_driver(sti_sas_platform_driver);
 480
 481 MODULE_DESCRIPTION("audio codec for STMicroelectronics sti platforms");
 482 MODULE_AUTHOR("Arnaud.pouliquen@st.com");
 483 MODULE_LICENSE("GPL v2");