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