sound/soc/meson/axg-tdm-formatter.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 //
   3 // Copyright (c) 2018 BayLibre, SAS.
   4 // Author: Jerome Brunet <jbrunet@baylibre.com>
   5
   6 #include <linux/clk.h>
   7 #include <linux/module.h>
   8 #include <linux/of_platform.h>
   9 #include <linux/regmap.h>
  10 #include <linux/reset.h>
  11 #include <sound/soc.h>
  12
  13 #include "axg-tdm-formatter.h"
  14
  15 struct axg_tdm_formatter {
  16         struct list_head list;
  17         struct axg_tdm_stream *stream;
  18         const struct axg_tdm_formatter_driver *drv;
  19         struct clk *pclk;
  20         struct clk *sclk;
  21         struct clk *lrclk;
  22         struct clk *sclk_sel;
  23         struct clk *lrclk_sel;
  24         struct reset_control *reset;
  25         bool enabled;
  26         struct regmap *map;
  27 };
  28
  29 int axg_tdm_formatter_set_channel_masks(struct regmap *map,
  30                                         struct axg_tdm_stream *ts,
  31                                         unsigned int offset)
  32 {
  33         unsigned int ch = ts->channels;
  34         u32 val[AXG_TDM_NUM_LANES];
  35         int i, j, k;
  36
  37         /*
  38          * We need to mimick the slot distribution used by the HW to keep the
  39          * channel placement consistent regardless of the number of channel
  40          * in the stream. This is why the odd algorithm below is used.
  41          */
  42         memset(val, 0, sizeof(*val) * AXG_TDM_NUM_LANES);
  43
  44         /*
  45          * Distribute the channels of the stream over the available slots
  46          * of each TDM lane. We need to go over the 32 slots ...
  47          */
  48         for (i = 0; (i < 32) && ch; i += 2) {
  49                 /* ... of all the lanes ... */
  50                 for (j = 0; j < AXG_TDM_NUM_LANES; j++) {
  51                         /* ... then distribute the channels in pairs */
  52                         for (k = 0; k < 2; k++) {
  53                                 if ((BIT(i + k) & ts->mask[j]) && ch) {
  54                                         val[j] |= BIT(i + k);
  55                                         ch -= 1;
  56                                 }
  57                         }
  58                 }
  59         }
  60
  61         /*
  62          * If we still have channel left at the end of the process, it means
  63          * the stream has more channels than we can accommodate and we should
  64          * have caught this earlier.
  65          */
  66         if (WARN_ON(ch != 0)) {
  67                 pr_err("channel mask error\n");
  68                 return -EINVAL;
  69         }
  70
  71         for (i = 0; i < AXG_TDM_NUM_LANES; i++) {
  72                 regmap_write(map, offset, val[i]);
  73                 offset += regmap_get_reg_stride(map);
  74         }
  75
  76         return 0;
  77 }
  78 EXPORT_SYMBOL_GPL(axg_tdm_formatter_set_channel_masks);
  79
  80 static int axg_tdm_formatter_enable(struct axg_tdm_formatter *formatter)
  81 {
  82         struct axg_tdm_stream *ts = formatter->stream;
  83         bool invert;
  84         int ret;
  85
  86         /* Do nothing if the formatter is already enabled */
  87         if (formatter->enabled)
  88                 return 0;
  89
  90         /*
  91          * On the g12a (and possibly other SoCs), when a stream using
  92          * multiple lanes is restarted, it will sometimes not start
  93          * from the first lane, but randomly from another used one.
  94          * The result is an unexpected and random channel shift.
  95          *
  96          * The hypothesis is that an HW counter is not properly reset
  97          * and the formatter simply starts on the lane it stopped
  98          * before. Unfortunately, there does not seems to be a way to
  99          * reset this through the registers of the block.
 100          *
 101          * However, the g12a has indenpendent reset lines for each audio
 102          * devices. Using this reset before each start solves the issue.
 103          */
 104         ret = reset_control_reset(formatter->reset);
 105         if (ret)
 106                 return ret;
 107
 108         /*
 109          * If sclk is inverted, it means the bit should latched on the
 110          * rising edge which is what our HW expects. If not, we need to
 111          * invert it before the formatter.
 112          */
 113         invert = axg_tdm_sclk_invert(ts->iface->fmt);
 114         ret = clk_set_phase(formatter->sclk, invert ? 0 : 180);
 115         if (ret)
 116                 return ret;
 117
 118         /* Setup the stream parameter in the formatter */
 119         ret = formatter->drv->ops->prepare(formatter->map,
 120                                            formatter->drv->quirks,
 121                                            formatter->stream);
 122         if (ret)
 123                 return ret;
 124
 125         /* Enable the signal clocks feeding the formatter */
 126         ret = clk_prepare_enable(formatter->sclk);
 127         if (ret)
 128                 return ret;
 129
 130         ret = clk_prepare_enable(formatter->lrclk);
 131         if (ret) {
 132                 clk_disable_unprepare(formatter->sclk);
 133                 return ret;
 134         }
 135
 136         /* Finally, actually enable the formatter */
 137         formatter->drv->ops->enable(formatter->map);
 138         formatter->enabled = true;
 139
 140         return 0;
 141 }
 142
 143 static void axg_tdm_formatter_disable(struct axg_tdm_formatter *formatter)
 144 {
 145         /* Do nothing if the formatter is already disabled */
 146         if (!formatter->enabled)
 147                 return;
 148
 149         formatter->drv->ops->disable(formatter->map);
 150         clk_disable_unprepare(formatter->lrclk);
 151         clk_disable_unprepare(formatter->sclk);
 152         formatter->enabled = false;
 153 }
 154
 155 static int axg_tdm_formatter_attach(struct axg_tdm_formatter *formatter)
 156 {
 157         struct axg_tdm_stream *ts = formatter->stream;
 158         int ret = 0;
 159
 160         mutex_lock(&ts->lock);
 161
 162         /* Catch up if the stream is already running when we attach */
 163         if (ts->ready) {
 164                 ret = axg_tdm_formatter_enable(formatter);
 165                 if (ret) {
 166                         pr_err("failed to enable formatter\n");
 167                         goto out;
 168                 }
 169         }
 170
 171         list_add_tail(&formatter->list, &ts->formatter_list);
 172 out:
 173         mutex_unlock(&ts->lock);
 174         return ret;
 175 }
 176
 177 static void axg_tdm_formatter_dettach(struct axg_tdm_formatter *formatter)
 178 {
 179         struct axg_tdm_stream *ts = formatter->stream;
 180
 181         mutex_lock(&ts->lock);
 182         list_del(&formatter->list);
 183         mutex_unlock(&ts->lock);
 184
 185         axg_tdm_formatter_disable(formatter);
 186 }
 187
 188 static int axg_tdm_formatter_power_up(struct axg_tdm_formatter *formatter,
 189                                       struct snd_soc_dapm_widget *w)
 190 {
 191         struct axg_tdm_stream *ts = formatter->drv->ops->get_stream(w);
 192         int ret;
 193
 194         /*
 195          * If we don't get a stream at this stage, it would mean that the
 196          * widget is powering up but is not attached to any backend DAI.
 197          * It should not happen, ever !
 198          */
 199         if (WARN_ON(!ts))
 200                 return -ENODEV;
 201
 202         /* Clock our device */
 203         ret = clk_prepare_enable(formatter->pclk);
 204         if (ret)
 205                 return ret;
 206
 207         /* Reparent the bit clock to the TDM interface */
 208         ret = clk_set_parent(formatter->sclk_sel, ts->iface->sclk);
 209         if (ret)
 210                 goto disable_pclk;
 211
 212         /* Reparent the sample clock to the TDM interface */
 213         ret = clk_set_parent(formatter->lrclk_sel, ts->iface->lrclk);
 214         if (ret)
 215                 goto disable_pclk;
 216
 217         formatter->stream = ts;
 218         ret = axg_tdm_formatter_attach(formatter);
 219         if (ret)
 220                 goto disable_pclk;
 221
 222         return 0;
 223
 224 disable_pclk:
 225         clk_disable_unprepare(formatter->pclk);
 226         return ret;
 227 }
 228
 229 static void axg_tdm_formatter_power_down(struct axg_tdm_formatter *formatter)
 230 {
 231         axg_tdm_formatter_dettach(formatter);
 232         clk_disable_unprepare(formatter->pclk);
 233         formatter->stream = NULL;
 234 }
 235
 236 int axg_tdm_formatter_event(struct snd_soc_dapm_widget *w,
 237                             struct snd_kcontrol *control,
 238                             int event)
 239 {
 240         struct snd_soc_component *c = snd_soc_dapm_to_component(w->dapm);
 241         struct axg_tdm_formatter *formatter = snd_soc_component_get_drvdata(c);
 242         int ret = 0;
 243
 244         switch (event) {
 245         case SND_SOC_DAPM_PRE_PMU:
 246                 ret = axg_tdm_formatter_power_up(formatter, w);
 247                 break;
 248
 249         case SND_SOC_DAPM_PRE_PMD:
 250                 axg_tdm_formatter_power_down(formatter);
 251                 break;
 252
 253         default:
 254                 dev_err(c->dev, "Unexpected event %d\n", event);
 255                 return -EINVAL;
 256         }
 257
 258         return ret;
 259 }
 260 EXPORT_SYMBOL_GPL(axg_tdm_formatter_event);
 261
 262 int axg_tdm_formatter_probe(struct platform_device *pdev)
 263 {
 264         struct device *dev = &pdev->dev;
 265         const struct axg_tdm_formatter_driver *drv;
 266         struct axg_tdm_formatter *formatter;
 267         void __iomem *regs;
 268
 269         drv = of_device_get_match_data(dev);
 270         if (!drv) {
 271                 dev_err(dev, "failed to match device\n");
 272                 return -ENODEV;
 273         }
 274
 275         formatter = devm_kzalloc(dev, sizeof(*formatter), GFP_KERNEL);
 276         if (!formatter)
 277                 return -ENOMEM;
 278         platform_set_drvdata(pdev, formatter);
 279         formatter->drv = drv;
 280
 281         regs = devm_platform_ioremap_resource(pdev, 0);
 282         if (IS_ERR(regs))
 283                 return PTR_ERR(regs);
 284
 285         formatter->map = devm_regmap_init_mmio(dev, regs, drv->regmap_cfg);
 286         if (IS_ERR(formatter->map)) {
 287                 dev_err(dev, "failed to init regmap: %ld\n",
 288                         PTR_ERR(formatter->map));
 289                 return PTR_ERR(formatter->map);
 290         }
 291
 292         /* Peripharal clock */
 293         formatter->pclk = devm_clk_get(dev, "pclk");
 294         if (IS_ERR(formatter->pclk))
 295                 return dev_err_probe(dev, PTR_ERR(formatter->pclk), "failed to get pclk\n");
 296
 297         /* Formatter bit clock */
 298         formatter->sclk = devm_clk_get(dev, "sclk");
 299         if (IS_ERR(formatter->sclk))
 300                 return dev_err_probe(dev, PTR_ERR(formatter->sclk), "failed to get sclk\n");
 301
 302         /* Formatter sample clock */
 303         formatter->lrclk = devm_clk_get(dev, "lrclk");
 304         if (IS_ERR(formatter->lrclk))
 305                 return dev_err_probe(dev, PTR_ERR(formatter->lrclk), "failed to get lrclk\n");
 306
 307         /* Formatter bit clock input multiplexer */
 308         formatter->sclk_sel = devm_clk_get(dev, "sclk_sel");
 309         if (IS_ERR(formatter->sclk_sel))
 310                 return dev_err_probe(dev, PTR_ERR(formatter->sclk_sel), "failed to get sclk_sel\n");
 311
 312         /* Formatter sample clock input multiplexer */
 313         formatter->lrclk_sel = devm_clk_get(dev, "lrclk_sel");
 314         if (IS_ERR(formatter->lrclk_sel))
 315                 return dev_err_probe(dev, PTR_ERR(formatter->lrclk_sel),
 316                                      "failed to get lrclk_sel\n");
 317
 318         /* Formatter dedicated reset line */
 319         formatter->reset = devm_reset_control_get_optional_exclusive(dev, NULL);
 320         if (IS_ERR(formatter->reset))
 321                 return dev_err_probe(dev, PTR_ERR(formatter->reset), "failed to get reset\n");
 322
 323         return devm_snd_soc_register_component(dev, drv->component_drv,
 324                                                NULL, 0);
 325 }
 326 EXPORT_SYMBOL_GPL(axg_tdm_formatter_probe);
 327
 328 int axg_tdm_stream_start(struct axg_tdm_stream *ts)
 329 {
 330         struct axg_tdm_formatter *formatter;
 331         int ret = 0;
 332
 333         mutex_lock(&ts->lock);
 334         ts->ready = true;
 335
 336         /* Start all the formatters attached to the stream */
 337         list_for_each_entry(formatter, &ts->formatter_list, list) {
 338                 ret = axg_tdm_formatter_enable(formatter);
 339                 if (ret) {
 340                         pr_err("failed to start tdm stream\n");
 341                         goto out;
 342                 }
 343         }
 344
 345 out:
 346         mutex_unlock(&ts->lock);
 347         return ret;
 348 }
 349 EXPORT_SYMBOL_GPL(axg_tdm_stream_start);
 350
 351 void axg_tdm_stream_stop(struct axg_tdm_stream *ts)
 352 {
 353         struct axg_tdm_formatter *formatter;
 354
 355         mutex_lock(&ts->lock);
 356         ts->ready = false;
 357
 358         /* Stop all the formatters attached to the stream */
 359         list_for_each_entry(formatter, &ts->formatter_list, list) {
 360                 axg_tdm_formatter_disable(formatter);
 361         }
 362
 363         mutex_unlock(&ts->lock);
 364 }
 365 EXPORT_SYMBOL_GPL(axg_tdm_stream_stop);
 366
 367 struct axg_tdm_stream *axg_tdm_stream_alloc(struct axg_tdm_iface *iface)
 368 {
 369         struct axg_tdm_stream *ts;
 370
 371         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 372         if (ts) {
 373                 INIT_LIST_HEAD(&ts->formatter_list);
 374                 mutex_init(&ts->lock);
 375                 ts->iface = iface;
 376         }
 377
 378         return ts;
 379 }
 380 EXPORT_SYMBOL_GPL(axg_tdm_stream_alloc);
 381
 382 void axg_tdm_stream_free(struct axg_tdm_stream *ts)
 383 {
 384         /*
 385          * If the list is not empty, it would mean that one of the formatter
 386          * widget is still powered and attached to the interface while we
 387          * are removing the TDM DAI. It should not be possible
 388          */
 389         WARN_ON(!list_empty(&ts->formatter_list));
 390         mutex_destroy(&ts->lock);
 391         kfree(ts);
 392 }
 393 EXPORT_SYMBOL_GPL(axg_tdm_stream_free);
 394
 395 MODULE_DESCRIPTION("Amlogic AXG TDM formatter driver");
 396 MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
 397 MODULE_LICENSE("GPL v2");