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