438 lines · 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 15struct 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 29int 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 the39 * channel placement consistent regardless of the number of channel40 * 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 slots46 * 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 means63 * the stream has more channels than we can accommodate and we should64 * 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}78EXPORT_SYMBOL_GPL(axg_tdm_formatter_set_channel_masks);79 80static 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 using92 * multiple lanes is restarted, it will sometimes not start93 * 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 reset97 * and the formatter simply starts on the lane it stopped98 * before. Unfortunately, there does not seems to be a way to99 * reset this through the registers of the block.100 *101 * However, the g12a has indenpendent reset lines for each audio102 * 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 the110 * rising edge which is what our HW expects. If not, we need to111 * 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 143static 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 155static 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);172out:173 mutex_unlock(&ts->lock);174 return ret;175}176 177static 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 188static 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 the196 * 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 224disable_pclk:225 clk_disable_unprepare(formatter->pclk);226 return ret;227}228 229static 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 236int 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}260EXPORT_SYMBOL_GPL(axg_tdm_formatter_event);261 262int 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}326EXPORT_SYMBOL_GPL(axg_tdm_formatter_probe);327 328int 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 345out:346 mutex_unlock(&ts->lock);347 return ret;348}349EXPORT_SYMBOL_GPL(axg_tdm_stream_start);350 351void 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}365EXPORT_SYMBOL_GPL(axg_tdm_stream_stop);366 367struct 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}380EXPORT_SYMBOL_GPL(axg_tdm_stream_alloc);381 382void 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 formatter386 * widget is still powered and attached to the interface while we387 * are removing the TDM DAI. It should not be possible388 */389 WARN_ON(!list_empty(&ts->formatter_list));390 mutex_destroy(&ts->lock);391 kfree(ts);392}393EXPORT_SYMBOL_GPL(axg_tdm_stream_free);394 395int axg_tdm_stream_set_cont_clocks(struct axg_tdm_stream *ts,396 unsigned int fmt)397{398 int ret = 0;399 400 if (fmt & SND_SOC_DAIFMT_CONT) {401 /* Clock are already enabled - skipping */402 if (ts->clk_enabled)403 return 0;404 405 ret = clk_prepare_enable(ts->iface->mclk);406 if (ret)407 return ret;408 409 ret = clk_prepare_enable(ts->iface->sclk);410 if (ret)411 goto err_sclk;412 413 ret = clk_prepare_enable(ts->iface->lrclk);414 if (ret)415 goto err_lrclk;416 417 ts->clk_enabled = true;418 return 0;419 }420 421 /* Clocks are already disabled - skipping */422 if (!ts->clk_enabled)423 return 0;424 425 clk_disable_unprepare(ts->iface->lrclk);426err_lrclk:427 clk_disable_unprepare(ts->iface->sclk);428err_sclk:429 clk_disable_unprepare(ts->iface->mclk);430 ts->clk_enabled = false;431 return ret;432}433EXPORT_SYMBOL_GPL(axg_tdm_stream_set_cont_clocks);434 435MODULE_DESCRIPTION("Amlogic AXG TDM formatter driver");436MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");437MODULE_LICENSE("GPL v2");438