1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved. 4 * 5 * lpass-cpu.c -- ALSA SoC CPU DAI driver for QTi LPASS 6 */ 7 8 #include <linux/clk.h> 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/of_device.h> 13 #include <linux/platform_device.h> 14 #include <sound/pcm.h> 15 #include <sound/pcm_params.h> 16 #include <linux/regmap.h> 17 #include <sound/soc.h> 18 #include <sound/soc-dai.h> 19 #include "lpass-lpaif-reg.h" 20 #include "lpass.h" 21 22 #define LPASS_CPU_MAX_MI2S_LINES 4 23 #define LPASS_CPU_I2S_SD0_MASK BIT(0) 24 #define LPASS_CPU_I2S_SD1_MASK BIT(1) 25 #define LPASS_CPU_I2S_SD2_MASK BIT(2) 26 #define LPASS_CPU_I2S_SD3_MASK BIT(3) 27 #define LPASS_CPU_I2S_SD0_1_MASK GENMASK(1, 0) 28 #define LPASS_CPU_I2S_SD2_3_MASK GENMASK(3, 2) 29 #define LPASS_CPU_I2S_SD0_1_2_MASK GENMASK(2, 0) 30 #define LPASS_CPU_I2S_SD0_1_2_3_MASK GENMASK(3, 0) 31 #define LPASS_REG_READ 1 32 #define LPASS_REG_WRITE 0 33 34 /* 35 * Channel maps for Quad channel playbacks on MI2S Secondary 36 */ 37 static struct snd_pcm_chmap_elem lpass_quad_chmaps[] = { 38 { .channels = 4, 39 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_RL, 40 SNDRV_CHMAP_FR, SNDRV_CHMAP_RR } }, 41 { } 42 }; 43 static int lpass_cpu_init_i2sctl_bitfields(struct device *dev, 44 struct lpaif_i2sctl *i2sctl, struct regmap *map) 45 { 46 struct lpass_data *drvdata = dev_get_drvdata(dev); 47 struct lpass_variant *v = drvdata->variant; 48 49 i2sctl->loopback = devm_regmap_field_alloc(dev, map, v->loopback); 50 i2sctl->spken = devm_regmap_field_alloc(dev, map, v->spken); 51 i2sctl->spkmode = devm_regmap_field_alloc(dev, map, v->spkmode); 52 i2sctl->spkmono = devm_regmap_field_alloc(dev, map, v->spkmono); 53 i2sctl->micen = devm_regmap_field_alloc(dev, map, v->micen); 54 i2sctl->micmode = devm_regmap_field_alloc(dev, map, v->micmode); 55 i2sctl->micmono = devm_regmap_field_alloc(dev, map, v->micmono); 56 i2sctl->wssrc = devm_regmap_field_alloc(dev, map, v->wssrc); 57 i2sctl->bitwidth = devm_regmap_field_alloc(dev, map, v->bitwidth); 58 59 if (IS_ERR(i2sctl->loopback) || IS_ERR(i2sctl->spken) || 60 IS_ERR(i2sctl->spkmode) || IS_ERR(i2sctl->spkmono) || 61 IS_ERR(i2sctl->micen) || IS_ERR(i2sctl->micmode) || 62 IS_ERR(i2sctl->micmono) || IS_ERR(i2sctl->wssrc) || 63 IS_ERR(i2sctl->bitwidth)) 64 return -EINVAL; 65 66 return 0; 67 } 68 69 static int lpass_cpu_daiops_set_sysclk(struct snd_soc_dai *dai, int clk_id, 70 unsigned int freq, int dir) 71 { 72 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 73 int ret; 74 75 ret = clk_set_rate(drvdata->mi2s_osr_clk[dai->driver->id], freq); 76 if (ret) 77 dev_err(dai->dev, "error setting mi2s osrclk to %u: %d\n", 78 freq, ret); 79 80 return ret; 81 } 82 83 static int lpass_cpu_daiops_startup(struct snd_pcm_substream *substream, 84 struct snd_soc_dai *dai) 85 { 86 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 87 int ret; 88 89 ret = clk_prepare_enable(drvdata->mi2s_osr_clk[dai->driver->id]); 90 if (ret) { 91 dev_err(dai->dev, "error in enabling mi2s osr clk: %d\n", ret); 92 return ret; 93 } 94 ret = clk_prepare(drvdata->mi2s_bit_clk[dai->driver->id]); 95 if (ret) { 96 dev_err(dai->dev, "error in enabling mi2s bit clk: %d\n", ret); 97 clk_disable_unprepare(drvdata->mi2s_osr_clk[dai->driver->id]); 98 return ret; 99 } 100 return 0; 101 } 102 103 static void lpass_cpu_daiops_shutdown(struct snd_pcm_substream *substream, 104 struct snd_soc_dai *dai) 105 { 106 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 107 struct lpaif_i2sctl *i2sctl = drvdata->i2sctl; 108 unsigned int id = dai->driver->id; 109 110 clk_disable_unprepare(drvdata->mi2s_osr_clk[dai->driver->id]); 111 /* 112 * Ensure LRCLK is disabled even in device node validation. 113 * Will not impact if disabled in lpass_cpu_daiops_trigger() 114 * suspend. 115 */ 116 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 117 regmap_fields_write(i2sctl->spken, id, LPAIF_I2SCTL_SPKEN_DISABLE); 118 else 119 regmap_fields_write(i2sctl->micen, id, LPAIF_I2SCTL_MICEN_DISABLE); 120 121 /* 122 * BCLK may not be enabled if lpass_cpu_daiops_prepare is called before 123 * lpass_cpu_daiops_shutdown. It's paired with the clk_enable in 124 * lpass_cpu_daiops_prepare. 125 */ 126 if (drvdata->mi2s_was_prepared[dai->driver->id]) { 127 drvdata->mi2s_was_prepared[dai->driver->id] = false; 128 clk_disable(drvdata->mi2s_bit_clk[dai->driver->id]); 129 } 130 131 clk_unprepare(drvdata->mi2s_bit_clk[dai->driver->id]); 132 } 133 134 static int lpass_cpu_daiops_hw_params(struct snd_pcm_substream *substream, 135 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) 136 { 137 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 138 struct lpaif_i2sctl *i2sctl = drvdata->i2sctl; 139 unsigned int id = dai->driver->id; 140 snd_pcm_format_t format = params_format(params); 141 unsigned int channels = params_channels(params); 142 unsigned int rate = params_rate(params); 143 unsigned int mode; 144 unsigned int regval; 145 int bitwidth, ret; 146 147 bitwidth = snd_pcm_format_width(format); 148 if (bitwidth < 0) { 149 dev_err(dai->dev, "invalid bit width given: %d\n", bitwidth); 150 return bitwidth; 151 } 152 153 ret = regmap_fields_write(i2sctl->loopback, id, 154 LPAIF_I2SCTL_LOOPBACK_DISABLE); 155 if (ret) { 156 dev_err(dai->dev, "error updating loopback field: %d\n", ret); 157 return ret; 158 } 159 160 ret = regmap_fields_write(i2sctl->wssrc, id, 161 LPAIF_I2SCTL_WSSRC_INTERNAL); 162 if (ret) { 163 dev_err(dai->dev, "error updating wssrc field: %d\n", ret); 164 return ret; 165 } 166 167 switch (bitwidth) { 168 case 16: 169 regval = LPAIF_I2SCTL_BITWIDTH_16; 170 break; 171 case 24: 172 regval = LPAIF_I2SCTL_BITWIDTH_24; 173 break; 174 case 32: 175 regval = LPAIF_I2SCTL_BITWIDTH_32; 176 break; 177 default: 178 dev_err(dai->dev, "invalid bitwidth given: %d\n", bitwidth); 179 return -EINVAL; 180 } 181 182 ret = regmap_fields_write(i2sctl->bitwidth, id, regval); 183 if (ret) { 184 dev_err(dai->dev, "error updating bitwidth field: %d\n", ret); 185 return ret; 186 } 187 188 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 189 mode = drvdata->mi2s_playback_sd_mode[id]; 190 else 191 mode = drvdata->mi2s_capture_sd_mode[id]; 192 193 if (!mode) { 194 dev_err(dai->dev, "no line is assigned\n"); 195 return -EINVAL; 196 } 197 198 switch (channels) { 199 case 1: 200 case 2: 201 switch (mode) { 202 case LPAIF_I2SCTL_MODE_QUAD01: 203 case LPAIF_I2SCTL_MODE_6CH: 204 case LPAIF_I2SCTL_MODE_8CH: 205 mode = LPAIF_I2SCTL_MODE_SD0; 206 break; 207 case LPAIF_I2SCTL_MODE_QUAD23: 208 mode = LPAIF_I2SCTL_MODE_SD2; 209 break; 210 } 211 212 break; 213 case 4: 214 if (mode < LPAIF_I2SCTL_MODE_QUAD01) { 215 dev_err(dai->dev, "cannot configure 4 channels with mode %d\n", 216 mode); 217 return -EINVAL; 218 } 219 220 switch (mode) { 221 case LPAIF_I2SCTL_MODE_6CH: 222 case LPAIF_I2SCTL_MODE_8CH: 223 mode = LPAIF_I2SCTL_MODE_QUAD01; 224 break; 225 } 226 break; 227 case 6: 228 if (mode < LPAIF_I2SCTL_MODE_6CH) { 229 dev_err(dai->dev, "cannot configure 6 channels with mode %d\n", 230 mode); 231 return -EINVAL; 232 } 233 234 switch (mode) { 235 case LPAIF_I2SCTL_MODE_8CH: 236 mode = LPAIF_I2SCTL_MODE_6CH; 237 break; 238 } 239 break; 240 case 8: 241 if (mode < LPAIF_I2SCTL_MODE_8CH) { 242 dev_err(dai->dev, "cannot configure 8 channels with mode %d\n", 243 mode); 244 return -EINVAL; 245 } 246 break; 247 default: 248 dev_err(dai->dev, "invalid channels given: %u\n", channels); 249 return -EINVAL; 250 } 251 252 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 253 ret = regmap_fields_write(i2sctl->spkmode, id, 254 LPAIF_I2SCTL_SPKMODE(mode)); 255 if (ret) { 256 dev_err(dai->dev, "error writing to i2sctl spkr mode: %d\n", 257 ret); 258 return ret; 259 } 260 if (channels >= 2) 261 ret = regmap_fields_write(i2sctl->spkmono, id, 262 LPAIF_I2SCTL_SPKMONO_STEREO); 263 else 264 ret = regmap_fields_write(i2sctl->spkmono, id, 265 LPAIF_I2SCTL_SPKMONO_MONO); 266 } else { 267 ret = regmap_fields_write(i2sctl->micmode, id, 268 LPAIF_I2SCTL_MICMODE(mode)); 269 if (ret) { 270 dev_err(dai->dev, "error writing to i2sctl mic mode: %d\n", 271 ret); 272 return ret; 273 } 274 if (channels >= 2) 275 ret = regmap_fields_write(i2sctl->micmono, id, 276 LPAIF_I2SCTL_MICMONO_STEREO); 277 else 278 ret = regmap_fields_write(i2sctl->micmono, id, 279 LPAIF_I2SCTL_MICMONO_MONO); 280 } 281 282 if (ret) { 283 dev_err(dai->dev, "error writing to i2sctl channels mode: %d\n", 284 ret); 285 return ret; 286 } 287 288 ret = clk_set_rate(drvdata->mi2s_bit_clk[id], 289 rate * bitwidth * 2); 290 if (ret) { 291 dev_err(dai->dev, "error setting mi2s bitclk to %u: %d\n", 292 rate * bitwidth * 2, ret); 293 return ret; 294 } 295 296 return 0; 297 } 298 299 static int lpass_cpu_daiops_trigger(struct snd_pcm_substream *substream, 300 int cmd, struct snd_soc_dai *dai) 301 { 302 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 303 struct lpaif_i2sctl *i2sctl = drvdata->i2sctl; 304 unsigned int id = dai->driver->id; 305 int ret = -EINVAL; 306 307 switch (cmd) { 308 case SNDRV_PCM_TRIGGER_START: 309 case SNDRV_PCM_TRIGGER_RESUME: 310 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 311 /* 312 * Ensure lpass BCLK/LRCLK is enabled during 313 * device resume as lpass_cpu_daiops_prepare() is not called 314 * after the device resumes. We don't check mi2s_was_prepared before 315 * enable/disable BCLK in trigger events because: 316 * 1. These trigger events are paired, so the BCLK 317 * enable_count is balanced. 318 * 2. the BCLK can be shared (ex: headset and headset mic), 319 * we need to increase the enable_count so that we don't 320 * turn off the shared BCLK while other devices are using 321 * it. 322 */ 323 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 324 ret = regmap_fields_write(i2sctl->spken, id, 325 LPAIF_I2SCTL_SPKEN_ENABLE); 326 } else { 327 ret = regmap_fields_write(i2sctl->micen, id, 328 LPAIF_I2SCTL_MICEN_ENABLE); 329 } 330 if (ret) 331 dev_err(dai->dev, "error writing to i2sctl reg: %d\n", 332 ret); 333 334 ret = clk_enable(drvdata->mi2s_bit_clk[id]); 335 if (ret) { 336 dev_err(dai->dev, "error in enabling mi2s bit clk: %d\n", ret); 337 clk_disable(drvdata->mi2s_osr_clk[id]); 338 return ret; 339 } 340 break; 341 case SNDRV_PCM_TRIGGER_STOP: 342 case SNDRV_PCM_TRIGGER_SUSPEND: 343 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 344 /* 345 * To ensure lpass BCLK/LRCLK is disabled during 346 * device suspend. 347 */ 348 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 349 ret = regmap_fields_write(i2sctl->spken, id, 350 LPAIF_I2SCTL_SPKEN_DISABLE); 351 } else { 352 ret = regmap_fields_write(i2sctl->micen, id, 353 LPAIF_I2SCTL_MICEN_DISABLE); 354 } 355 if (ret) 356 dev_err(dai->dev, "error writing to i2sctl reg: %d\n", 357 ret); 358 359 clk_disable(drvdata->mi2s_bit_clk[dai->driver->id]); 360 361 break; 362 } 363 364 return ret; 365 } 366 367 static int lpass_cpu_daiops_prepare(struct snd_pcm_substream *substream, 368 struct snd_soc_dai *dai) 369 { 370 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 371 struct lpaif_i2sctl *i2sctl = drvdata->i2sctl; 372 unsigned int id = dai->driver->id; 373 int ret; 374 375 /* 376 * Ensure lpass BCLK/LRCLK is enabled bit before playback/capture 377 * data flow starts. This allows other codec to have some delay before 378 * the data flow. 379 * (ex: to drop start up pop noise before capture starts). 380 */ 381 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 382 ret = regmap_fields_write(i2sctl->spken, id, LPAIF_I2SCTL_SPKEN_ENABLE); 383 else 384 ret = regmap_fields_write(i2sctl->micen, id, LPAIF_I2SCTL_MICEN_ENABLE); 385 386 if (ret) { 387 dev_err(dai->dev, "error writing to i2sctl reg: %d\n", ret); 388 return ret; 389 } 390 391 /* 392 * Check mi2s_was_prepared before enabling BCLK as lpass_cpu_daiops_prepare can 393 * be called multiple times. It's paired with the clk_disable in 394 * lpass_cpu_daiops_shutdown. 395 */ 396 if (!drvdata->mi2s_was_prepared[dai->driver->id]) { 397 ret = clk_enable(drvdata->mi2s_bit_clk[id]); 398 if (ret) { 399 dev_err(dai->dev, "error in enabling mi2s bit clk: %d\n", ret); 400 return ret; 401 } 402 drvdata->mi2s_was_prepared[dai->driver->id] = true; 403 } 404 return 0; 405 } 406 407 const struct snd_soc_dai_ops asoc_qcom_lpass_cpu_dai_ops = { 408 .set_sysclk = lpass_cpu_daiops_set_sysclk, 409 .startup = lpass_cpu_daiops_startup, 410 .shutdown = lpass_cpu_daiops_shutdown, 411 .hw_params = lpass_cpu_daiops_hw_params, 412 .trigger = lpass_cpu_daiops_trigger, 413 .prepare = lpass_cpu_daiops_prepare, 414 }; 415 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_dai_ops); 416 417 int lpass_cpu_pcm_new(struct snd_soc_pcm_runtime *rtd, 418 struct snd_soc_dai *dai) 419 { 420 int ret; 421 struct snd_soc_dai_driver *drv = dai->driver; 422 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 423 424 if (drvdata->mi2s_playback_sd_mode[dai->id] == LPAIF_I2SCTL_MODE_QUAD01) { 425 ret = snd_pcm_add_chmap_ctls(rtd->pcm, SNDRV_PCM_STREAM_PLAYBACK, 426 lpass_quad_chmaps, drv->playback.channels_max, 0, 427 NULL); 428 if (ret < 0) 429 return ret; 430 } 431 432 return 0; 433 } 434 EXPORT_SYMBOL_GPL(lpass_cpu_pcm_new); 435 436 int asoc_qcom_lpass_cpu_dai_probe(struct snd_soc_dai *dai) 437 { 438 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 439 int ret; 440 441 /* ensure audio hardware is disabled */ 442 ret = regmap_write(drvdata->lpaif_map, 443 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), 0); 444 if (ret) 445 dev_err(dai->dev, "error writing to i2sctl reg: %d\n", ret); 446 447 return ret; 448 } 449 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_dai_probe); 450 451 static int asoc_qcom_of_xlate_dai_name(struct snd_soc_component *component, 452 const struct of_phandle_args *args, 453 const char **dai_name) 454 { 455 struct lpass_data *drvdata = snd_soc_component_get_drvdata(component); 456 struct lpass_variant *variant = drvdata->variant; 457 int id = args->args[0]; 458 int ret = -EINVAL; 459 int i; 460 461 for (i = 0; i < variant->num_dai; i++) { 462 if (variant->dai_driver[i].id == id) { 463 *dai_name = variant->dai_driver[i].name; 464 ret = 0; 465 break; 466 } 467 } 468 469 return ret; 470 } 471 472 static const struct snd_soc_component_driver lpass_cpu_comp_driver = { 473 .name = "lpass-cpu", 474 .of_xlate_dai_name = asoc_qcom_of_xlate_dai_name, 475 .legacy_dai_naming = 1, 476 }; 477 478 static bool lpass_cpu_regmap_writeable(struct device *dev, unsigned int reg) 479 { 480 struct lpass_data *drvdata = dev_get_drvdata(dev); 481 struct lpass_variant *v = drvdata->variant; 482 int i; 483 484 for (i = 0; i < v->i2s_ports; ++i) 485 if (reg == LPAIF_I2SCTL_REG(v, i)) 486 return true; 487 488 for (i = 0; i < v->irq_ports; ++i) { 489 if (reg == LPAIF_IRQEN_REG(v, i)) 490 return true; 491 if (reg == LPAIF_IRQCLEAR_REG(v, i)) 492 return true; 493 } 494 495 for (i = 0; i < v->rdma_channels; ++i) { 496 if (reg == LPAIF_RDMACTL_REG(v, i)) 497 return true; 498 if (reg == LPAIF_RDMABASE_REG(v, i)) 499 return true; 500 if (reg == LPAIF_RDMABUFF_REG(v, i)) 501 return true; 502 if (reg == LPAIF_RDMAPER_REG(v, i)) 503 return true; 504 } 505 506 for (i = 0; i < v->wrdma_channels; ++i) { 507 if (reg == LPAIF_WRDMACTL_REG(v, i + v->wrdma_channel_start)) 508 return true; 509 if (reg == LPAIF_WRDMABASE_REG(v, i + v->wrdma_channel_start)) 510 return true; 511 if (reg == LPAIF_WRDMABUFF_REG(v, i + v->wrdma_channel_start)) 512 return true; 513 if (reg == LPAIF_WRDMAPER_REG(v, i + v->wrdma_channel_start)) 514 return true; 515 } 516 517 return false; 518 } 519 520 static bool lpass_cpu_regmap_readable(struct device *dev, unsigned int reg) 521 { 522 struct lpass_data *drvdata = dev_get_drvdata(dev); 523 struct lpass_variant *v = drvdata->variant; 524 int i; 525 526 for (i = 0; i < v->i2s_ports; ++i) 527 if (reg == LPAIF_I2SCTL_REG(v, i)) 528 return true; 529 530 for (i = 0; i < v->irq_ports; ++i) { 531 if (reg == LPAIF_IRQCLEAR_REG(v, i)) 532 return true; 533 if (reg == LPAIF_IRQEN_REG(v, i)) 534 return true; 535 if (reg == LPAIF_IRQSTAT_REG(v, i)) 536 return true; 537 } 538 539 for (i = 0; i < v->rdma_channels; ++i) { 540 if (reg == LPAIF_RDMACTL_REG(v, i)) 541 return true; 542 if (reg == LPAIF_RDMABASE_REG(v, i)) 543 return true; 544 if (reg == LPAIF_RDMABUFF_REG(v, i)) 545 return true; 546 if (reg == LPAIF_RDMACURR_REG(v, i)) 547 return true; 548 if (reg == LPAIF_RDMAPER_REG(v, i)) 549 return true; 550 } 551 552 for (i = 0; i < v->wrdma_channels; ++i) { 553 if (reg == LPAIF_WRDMACTL_REG(v, i + v->wrdma_channel_start)) 554 return true; 555 if (reg == LPAIF_WRDMABASE_REG(v, i + v->wrdma_channel_start)) 556 return true; 557 if (reg == LPAIF_WRDMABUFF_REG(v, i + v->wrdma_channel_start)) 558 return true; 559 if (reg == LPAIF_WRDMACURR_REG(v, i + v->wrdma_channel_start)) 560 return true; 561 if (reg == LPAIF_WRDMAPER_REG(v, i + v->wrdma_channel_start)) 562 return true; 563 } 564 565 return false; 566 } 567 568 static bool lpass_cpu_regmap_volatile(struct device *dev, unsigned int reg) 569 { 570 struct lpass_data *drvdata = dev_get_drvdata(dev); 571 struct lpass_variant *v = drvdata->variant; 572 int i; 573 574 for (i = 0; i < v->irq_ports; ++i) { 575 if (reg == LPAIF_IRQCLEAR_REG(v, i)) 576 return true; 577 if (reg == LPAIF_IRQSTAT_REG(v, i)) 578 return true; 579 } 580 581 for (i = 0; i < v->rdma_channels; ++i) 582 if (reg == LPAIF_RDMACURR_REG(v, i)) 583 return true; 584 585 for (i = 0; i < v->wrdma_channels; ++i) 586 if (reg == LPAIF_WRDMACURR_REG(v, i + v->wrdma_channel_start)) 587 return true; 588 589 return false; 590 } 591 592 static struct regmap_config lpass_cpu_regmap_config = { 593 .name = "lpass_cpu", 594 .reg_bits = 32, 595 .reg_stride = 4, 596 .val_bits = 32, 597 .writeable_reg = lpass_cpu_regmap_writeable, 598 .readable_reg = lpass_cpu_regmap_readable, 599 .volatile_reg = lpass_cpu_regmap_volatile, 600 .cache_type = REGCACHE_FLAT, 601 }; 602 603 static int lpass_hdmi_init_bitfields(struct device *dev, struct regmap *map) 604 { 605 struct lpass_data *drvdata = dev_get_drvdata(dev); 606 struct lpass_variant *v = drvdata->variant; 607 unsigned int i; 608 struct lpass_hdmi_tx_ctl *tx_ctl; 609 struct regmap_field *legacy_en; 610 struct lpass_vbit_ctrl *vbit_ctl; 611 struct regmap_field *tx_parity; 612 struct lpass_dp_metadata_ctl *meta_ctl; 613 struct lpass_sstream_ctl *sstream_ctl; 614 struct regmap_field *ch_msb; 615 struct regmap_field *ch_lsb; 616 struct lpass_hdmitx_dmactl *tx_dmactl; 617 int rval; 618 619 tx_ctl = devm_kzalloc(dev, sizeof(*tx_ctl), GFP_KERNEL); 620 if (!tx_ctl) 621 return -ENOMEM; 622 623 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->soft_reset, tx_ctl->soft_reset); 624 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->force_reset, tx_ctl->force_reset); 625 drvdata->tx_ctl = tx_ctl; 626 627 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->legacy_en, legacy_en); 628 drvdata->hdmitx_legacy_en = legacy_en; 629 630 vbit_ctl = devm_kzalloc(dev, sizeof(*vbit_ctl), GFP_KERNEL); 631 if (!vbit_ctl) 632 return -ENOMEM; 633 634 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->replace_vbit, vbit_ctl->replace_vbit); 635 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->vbit_stream, vbit_ctl->vbit_stream); 636 drvdata->vbit_ctl = vbit_ctl; 637 638 639 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->calc_en, tx_parity); 640 drvdata->hdmitx_parity_calc_en = tx_parity; 641 642 meta_ctl = devm_kzalloc(dev, sizeof(*meta_ctl), GFP_KERNEL); 643 if (!meta_ctl) 644 return -ENOMEM; 645 646 rval = devm_regmap_field_bulk_alloc(dev, map, &meta_ctl->mute, &v->mute, 7); 647 if (rval) 648 return rval; 649 drvdata->meta_ctl = meta_ctl; 650 651 sstream_ctl = devm_kzalloc(dev, sizeof(*sstream_ctl), GFP_KERNEL); 652 if (!sstream_ctl) 653 return -ENOMEM; 654 655 rval = devm_regmap_field_bulk_alloc(dev, map, &sstream_ctl->sstream_en, &v->sstream_en, 9); 656 if (rval) 657 return rval; 658 659 drvdata->sstream_ctl = sstream_ctl; 660 661 for (i = 0; i < LPASS_MAX_HDMI_DMA_CHANNELS; i++) { 662 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->msb_bits, ch_msb); 663 drvdata->hdmitx_ch_msb[i] = ch_msb; 664 665 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->lsb_bits, ch_lsb); 666 drvdata->hdmitx_ch_lsb[i] = ch_lsb; 667 668 tx_dmactl = devm_kzalloc(dev, sizeof(*tx_dmactl), GFP_KERNEL); 669 if (!tx_dmactl) 670 return -ENOMEM; 671 672 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->use_hw_chs, tx_dmactl->use_hw_chs); 673 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->use_hw_usr, tx_dmactl->use_hw_usr); 674 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->hw_chs_sel, tx_dmactl->hw_chs_sel); 675 QCOM_REGMAP_FIELD_ALLOC(dev, map, v->hw_usr_sel, tx_dmactl->hw_usr_sel); 676 drvdata->hdmi_tx_dmactl[i] = tx_dmactl; 677 } 678 return 0; 679 } 680 681 static bool lpass_hdmi_regmap_writeable(struct device *dev, unsigned int reg) 682 { 683 struct lpass_data *drvdata = dev_get_drvdata(dev); 684 struct lpass_variant *v = drvdata->variant; 685 int i; 686 687 if (reg == LPASS_HDMI_TX_CTL_ADDR(v)) 688 return true; 689 if (reg == LPASS_HDMI_TX_LEGACY_ADDR(v)) 690 return true; 691 if (reg == LPASS_HDMI_TX_VBIT_CTL_ADDR(v)) 692 return true; 693 if (reg == LPASS_HDMI_TX_PARITY_ADDR(v)) 694 return true; 695 if (reg == LPASS_HDMI_TX_DP_ADDR(v)) 696 return true; 697 if (reg == LPASS_HDMI_TX_SSTREAM_ADDR(v)) 698 return true; 699 if (reg == LPASS_HDMITX_APP_IRQEN_REG(v)) 700 return true; 701 if (reg == LPASS_HDMITX_APP_IRQCLEAR_REG(v)) 702 return true; 703 704 for (i = 0; i < v->hdmi_rdma_channels; i++) { 705 if (reg == LPASS_HDMI_TX_CH_LSB_ADDR(v, i)) 706 return true; 707 if (reg == LPASS_HDMI_TX_CH_MSB_ADDR(v, i)) 708 return true; 709 if (reg == LPASS_HDMI_TX_DMA_ADDR(v, i)) 710 return true; 711 } 712 713 for (i = 0; i < v->hdmi_rdma_channels; ++i) { 714 if (reg == LPAIF_HDMI_RDMACTL_REG(v, i)) 715 return true; 716 if (reg == LPAIF_HDMI_RDMABASE_REG(v, i)) 717 return true; 718 if (reg == LPAIF_HDMI_RDMABUFF_REG(v, i)) 719 return true; 720 if (reg == LPAIF_HDMI_RDMAPER_REG(v, i)) 721 return true; 722 } 723 return false; 724 } 725 726 static bool lpass_hdmi_regmap_readable(struct device *dev, unsigned int reg) 727 { 728 struct lpass_data *drvdata = dev_get_drvdata(dev); 729 struct lpass_variant *v = drvdata->variant; 730 int i; 731 732 if (reg == LPASS_HDMI_TX_CTL_ADDR(v)) 733 return true; 734 if (reg == LPASS_HDMI_TX_LEGACY_ADDR(v)) 735 return true; 736 if (reg == LPASS_HDMI_TX_VBIT_CTL_ADDR(v)) 737 return true; 738 739 for (i = 0; i < v->hdmi_rdma_channels; i++) { 740 if (reg == LPASS_HDMI_TX_CH_LSB_ADDR(v, i)) 741 return true; 742 if (reg == LPASS_HDMI_TX_CH_MSB_ADDR(v, i)) 743 return true; 744 if (reg == LPASS_HDMI_TX_DMA_ADDR(v, i)) 745 return true; 746 } 747 748 if (reg == LPASS_HDMI_TX_PARITY_ADDR(v)) 749 return true; 750 if (reg == LPASS_HDMI_TX_DP_ADDR(v)) 751 return true; 752 if (reg == LPASS_HDMI_TX_SSTREAM_ADDR(v)) 753 return true; 754 if (reg == LPASS_HDMITX_APP_IRQEN_REG(v)) 755 return true; 756 if (reg == LPASS_HDMITX_APP_IRQSTAT_REG(v)) 757 return true; 758 759 for (i = 0; i < v->hdmi_rdma_channels; ++i) { 760 if (reg == LPAIF_HDMI_RDMACTL_REG(v, i)) 761 return true; 762 if (reg == LPAIF_HDMI_RDMABASE_REG(v, i)) 763 return true; 764 if (reg == LPAIF_HDMI_RDMABUFF_REG(v, i)) 765 return true; 766 if (reg == LPAIF_HDMI_RDMAPER_REG(v, i)) 767 return true; 768 if (reg == LPAIF_HDMI_RDMACURR_REG(v, i)) 769 return true; 770 } 771 772 return false; 773 } 774 775 static bool lpass_hdmi_regmap_volatile(struct device *dev, unsigned int reg) 776 { 777 struct lpass_data *drvdata = dev_get_drvdata(dev); 778 struct lpass_variant *v = drvdata->variant; 779 int i; 780 781 if (reg == LPASS_HDMITX_APP_IRQSTAT_REG(v)) 782 return true; 783 if (reg == LPASS_HDMI_TX_LEGACY_ADDR(v)) 784 return true; 785 786 for (i = 0; i < v->hdmi_rdma_channels; ++i) { 787 if (reg == LPAIF_HDMI_RDMACURR_REG(v, i)) 788 return true; 789 } 790 return false; 791 } 792 793 static struct regmap_config lpass_hdmi_regmap_config = { 794 .name = "lpass_hdmi", 795 .reg_bits = 32, 796 .reg_stride = 4, 797 .val_bits = 32, 798 .writeable_reg = lpass_hdmi_regmap_writeable, 799 .readable_reg = lpass_hdmi_regmap_readable, 800 .volatile_reg = lpass_hdmi_regmap_volatile, 801 .cache_type = REGCACHE_FLAT, 802 }; 803 804 static bool __lpass_rxtx_regmap_accessible(struct device *dev, unsigned int reg, bool rw) 805 { 806 struct lpass_data *drvdata = dev_get_drvdata(dev); 807 struct lpass_variant *v = drvdata->variant; 808 int i; 809 810 for (i = 0; i < v->rxtx_irq_ports; ++i) { 811 if (reg == LPAIF_RXTX_IRQCLEAR_REG(v, i)) 812 return true; 813 if (reg == LPAIF_RXTX_IRQEN_REG(v, i)) 814 return true; 815 if (reg == LPAIF_RXTX_IRQSTAT_REG(v, i)) 816 return true; 817 } 818 819 for (i = 0; i < v->rxtx_rdma_channels; ++i) { 820 if (reg == LPAIF_CDC_RXTX_RDMACTL_REG(v, i, LPASS_CDC_DMA_RX0)) 821 return true; 822 if (reg == LPAIF_CDC_RXTX_RDMABASE_REG(v, i, LPASS_CDC_DMA_RX0)) 823 return true; 824 if (reg == LPAIF_CDC_RXTX_RDMABUFF_REG(v, i, LPASS_CDC_DMA_RX0)) 825 return true; 826 if (rw == LPASS_REG_READ) { 827 if (reg == LPAIF_CDC_RXTX_RDMACURR_REG(v, i, LPASS_CDC_DMA_RX0)) 828 return true; 829 } 830 if (reg == LPAIF_CDC_RXTX_RDMAPER_REG(v, i, LPASS_CDC_DMA_RX0)) 831 return true; 832 if (reg == LPAIF_CDC_RXTX_RDMA_INTF_REG(v, i, LPASS_CDC_DMA_RX0)) 833 return true; 834 } 835 836 for (i = 0; i < v->rxtx_wrdma_channels; ++i) { 837 if (reg == LPAIF_CDC_RXTX_WRDMACTL_REG(v, i + v->rxtx_wrdma_channel_start, 838 LPASS_CDC_DMA_TX3)) 839 return true; 840 if (reg == LPAIF_CDC_RXTX_WRDMABASE_REG(v, i + v->rxtx_wrdma_channel_start, 841 LPASS_CDC_DMA_TX3)) 842 return true; 843 if (reg == LPAIF_CDC_RXTX_WRDMABUFF_REG(v, i + v->rxtx_wrdma_channel_start, 844 LPASS_CDC_DMA_TX3)) 845 return true; 846 if (rw == LPASS_REG_READ) { 847 if (reg == LPAIF_CDC_RXTX_WRDMACURR_REG(v, i, LPASS_CDC_DMA_RX0)) 848 return true; 849 } 850 if (reg == LPAIF_CDC_RXTX_WRDMAPER_REG(v, i + v->rxtx_wrdma_channel_start, 851 LPASS_CDC_DMA_TX3)) 852 return true; 853 if (reg == LPAIF_CDC_RXTX_WRDMA_INTF_REG(v, i + v->rxtx_wrdma_channel_start, 854 LPASS_CDC_DMA_TX3)) 855 return true; 856 } 857 return false; 858 } 859 860 static bool lpass_rxtx_regmap_writeable(struct device *dev, unsigned int reg) 861 { 862 return __lpass_rxtx_regmap_accessible(dev, reg, LPASS_REG_WRITE); 863 } 864 865 static bool lpass_rxtx_regmap_readable(struct device *dev, unsigned int reg) 866 { 867 return __lpass_rxtx_regmap_accessible(dev, reg, LPASS_REG_READ); 868 } 869 870 static bool lpass_rxtx_regmap_volatile(struct device *dev, unsigned int reg) 871 { 872 struct lpass_data *drvdata = dev_get_drvdata(dev); 873 struct lpass_variant *v = drvdata->variant; 874 int i; 875 876 for (i = 0; i < v->rxtx_irq_ports; ++i) { 877 if (reg == LPAIF_RXTX_IRQCLEAR_REG(v, i)) 878 return true; 879 if (reg == LPAIF_RXTX_IRQSTAT_REG(v, i)) 880 return true; 881 } 882 883 for (i = 0; i < v->rxtx_rdma_channels; ++i) 884 if (reg == LPAIF_CDC_RXTX_RDMACURR_REG(v, i, LPASS_CDC_DMA_RX0)) 885 return true; 886 887 for (i = 0; i < v->rxtx_wrdma_channels; ++i) 888 if (reg == LPAIF_CDC_RXTX_WRDMACURR_REG(v, i + v->rxtx_wrdma_channel_start, 889 LPASS_CDC_DMA_TX3)) 890 return true; 891 892 return false; 893 } 894 895 static bool __lpass_va_regmap_accessible(struct device *dev, unsigned int reg, bool rw) 896 { 897 struct lpass_data *drvdata = dev_get_drvdata(dev); 898 struct lpass_variant *v = drvdata->variant; 899 int i; 900 901 for (i = 0; i < v->va_irq_ports; ++i) { 902 if (reg == LPAIF_VA_IRQCLEAR_REG(v, i)) 903 return true; 904 if (reg == LPAIF_VA_IRQEN_REG(v, i)) 905 return true; 906 if (reg == LPAIF_VA_IRQSTAT_REG(v, i)) 907 return true; 908 } 909 910 for (i = 0; i < v->va_wrdma_channels; ++i) { 911 if (reg == LPAIF_CDC_VA_WRDMACTL_REG(v, i + v->va_wrdma_channel_start, 912 LPASS_CDC_DMA_VA_TX0)) 913 return true; 914 if (reg == LPAIF_CDC_VA_WRDMABASE_REG(v, i + v->va_wrdma_channel_start, 915 LPASS_CDC_DMA_VA_TX0)) 916 return true; 917 if (reg == LPAIF_CDC_VA_WRDMABUFF_REG(v, i + v->va_wrdma_channel_start, 918 LPASS_CDC_DMA_VA_TX0)) 919 return true; 920 if (rw == LPASS_REG_READ) { 921 if (reg == LPAIF_CDC_VA_WRDMACURR_REG(v, i + v->va_wrdma_channel_start, 922 LPASS_CDC_DMA_VA_TX0)) 923 return true; 924 } 925 if (reg == LPAIF_CDC_VA_WRDMAPER_REG(v, i + v->va_wrdma_channel_start, 926 LPASS_CDC_DMA_VA_TX0)) 927 return true; 928 if (reg == LPAIF_CDC_VA_WRDMA_INTF_REG(v, i + v->va_wrdma_channel_start, 929 LPASS_CDC_DMA_VA_TX0)) 930 return true; 931 } 932 return false; 933 } 934 935 static bool lpass_va_regmap_writeable(struct device *dev, unsigned int reg) 936 { 937 return __lpass_va_regmap_accessible(dev, reg, LPASS_REG_WRITE); 938 } 939 940 static bool lpass_va_regmap_readable(struct device *dev, unsigned int reg) 941 { 942 return __lpass_va_regmap_accessible(dev, reg, LPASS_REG_READ); 943 } 944 945 static bool lpass_va_regmap_volatile(struct device *dev, unsigned int reg) 946 { 947 struct lpass_data *drvdata = dev_get_drvdata(dev); 948 struct lpass_variant *v = drvdata->variant; 949 int i; 950 951 for (i = 0; i < v->va_irq_ports; ++i) { 952 if (reg == LPAIF_VA_IRQCLEAR_REG(v, i)) 953 return true; 954 if (reg == LPAIF_VA_IRQSTAT_REG(v, i)) 955 return true; 956 } 957 958 for (i = 0; i < v->va_wrdma_channels; ++i) { 959 if (reg == LPAIF_CDC_VA_WRDMACURR_REG(v, i + v->va_wrdma_channel_start, 960 LPASS_CDC_DMA_VA_TX0)) 961 return true; 962 } 963 964 return false; 965 } 966 967 static struct regmap_config lpass_rxtx_regmap_config = { 968 .reg_bits = 32, 969 .reg_stride = 4, 970 .val_bits = 32, 971 .writeable_reg = lpass_rxtx_regmap_writeable, 972 .readable_reg = lpass_rxtx_regmap_readable, 973 .volatile_reg = lpass_rxtx_regmap_volatile, 974 .cache_type = REGCACHE_FLAT, 975 }; 976 977 static struct regmap_config lpass_va_regmap_config = { 978 .reg_bits = 32, 979 .reg_stride = 4, 980 .val_bits = 32, 981 .writeable_reg = lpass_va_regmap_writeable, 982 .readable_reg = lpass_va_regmap_readable, 983 .volatile_reg = lpass_va_regmap_volatile, 984 .cache_type = REGCACHE_FLAT, 985 }; 986 987 static unsigned int of_lpass_cpu_parse_sd_lines(struct device *dev, 988 struct device_node *node, 989 const char *name) 990 { 991 unsigned int lines[LPASS_CPU_MAX_MI2S_LINES]; 992 unsigned int sd_line_mask = 0; 993 int num_lines, i; 994 995 num_lines = of_property_read_variable_u32_array(node, name, lines, 0, 996 LPASS_CPU_MAX_MI2S_LINES); 997 if (num_lines < 0) 998 return LPAIF_I2SCTL_MODE_NONE; 999 1000 for (i = 0; i < num_lines; i++) 1001 sd_line_mask |= BIT(lines[i]); 1002 1003 switch (sd_line_mask) { 1004 case LPASS_CPU_I2S_SD0_MASK: 1005 return LPAIF_I2SCTL_MODE_SD0; 1006 case LPASS_CPU_I2S_SD1_MASK: 1007 return LPAIF_I2SCTL_MODE_SD1; 1008 case LPASS_CPU_I2S_SD2_MASK: 1009 return LPAIF_I2SCTL_MODE_SD2; 1010 case LPASS_CPU_I2S_SD3_MASK: 1011 return LPAIF_I2SCTL_MODE_SD3; 1012 case LPASS_CPU_I2S_SD0_1_MASK: 1013 return LPAIF_I2SCTL_MODE_QUAD01; 1014 case LPASS_CPU_I2S_SD2_3_MASK: 1015 return LPAIF_I2SCTL_MODE_QUAD23; 1016 case LPASS_CPU_I2S_SD0_1_2_MASK: 1017 return LPAIF_I2SCTL_MODE_6CH; 1018 case LPASS_CPU_I2S_SD0_1_2_3_MASK: 1019 return LPAIF_I2SCTL_MODE_8CH; 1020 default: 1021 dev_err(dev, "Unsupported SD line mask: %#x\n", sd_line_mask); 1022 return LPAIF_I2SCTL_MODE_NONE; 1023 } 1024 } 1025 1026 static void of_lpass_cpu_parse_dai_data(struct device *dev, 1027 struct lpass_data *data) 1028 { 1029 struct device_node *node; 1030 int ret, id; 1031 1032 /* Allow all channels by default for backwards compatibility */ 1033 for (id = 0; id < data->variant->num_dai; id++) { 1034 data->mi2s_playback_sd_mode[id] = LPAIF_I2SCTL_MODE_8CH; 1035 data->mi2s_capture_sd_mode[id] = LPAIF_I2SCTL_MODE_8CH; 1036 } 1037 1038 for_each_child_of_node(dev->of_node, node) { 1039 ret = of_property_read_u32(node, "reg", &id); 1040 if (ret || id < 0) { 1041 dev_err(dev, "valid dai id not found: %d\n", ret); 1042 continue; 1043 } 1044 if (id == LPASS_DP_RX) { 1045 data->hdmi_port_enable = 1; 1046 } else if (is_cdc_dma_port(id)) { 1047 data->codec_dma_enable = 1; 1048 } else { 1049 data->mi2s_playback_sd_mode[id] = 1050 of_lpass_cpu_parse_sd_lines(dev, node, 1051 "qcom,playback-sd-lines"); 1052 data->mi2s_capture_sd_mode[id] = 1053 of_lpass_cpu_parse_sd_lines(dev, node, 1054 "qcom,capture-sd-lines"); 1055 } 1056 } 1057 } 1058 1059 static int of_lpass_cdc_dma_clks_parse(struct device *dev, 1060 struct lpass_data *data) 1061 { 1062 data->codec_mem0 = devm_clk_get(dev, "audio_cc_codec_mem0"); 1063 if (IS_ERR(data->codec_mem0)) 1064 return PTR_ERR(data->codec_mem0); 1065 1066 data->codec_mem1 = devm_clk_get(dev, "audio_cc_codec_mem1"); 1067 if (IS_ERR(data->codec_mem1)) 1068 return PTR_ERR(data->codec_mem1); 1069 1070 data->codec_mem2 = devm_clk_get(dev, "audio_cc_codec_mem2"); 1071 if (IS_ERR(data->codec_mem2)) 1072 return PTR_ERR(data->codec_mem2); 1073 1074 data->va_mem0 = devm_clk_get(dev, "aon_cc_va_mem0"); 1075 if (IS_ERR(data->va_mem0)) 1076 return PTR_ERR(data->va_mem0); 1077 1078 return 0; 1079 } 1080 1081 int asoc_qcom_lpass_cpu_platform_probe(struct platform_device *pdev) 1082 { 1083 struct lpass_data *drvdata; 1084 struct device_node *dsp_of_node; 1085 struct resource *res; 1086 struct lpass_variant *variant; 1087 struct device *dev = &pdev->dev; 1088 const struct of_device_id *match; 1089 int ret, i, dai_id; 1090 1091 dsp_of_node = of_parse_phandle(pdev->dev.of_node, "qcom,adsp", 0); 1092 if (dsp_of_node) { 1093 dev_err(dev, "DSP exists and holds audio resources\n"); 1094 of_node_put(dsp_of_node); 1095 return -EBUSY; 1096 } 1097 1098 drvdata = devm_kzalloc(dev, sizeof(struct lpass_data), GFP_KERNEL); 1099 if (!drvdata) 1100 return -ENOMEM; 1101 platform_set_drvdata(pdev, drvdata); 1102 1103 match = of_match_device(dev->driver->of_match_table, dev); 1104 if (!match || !match->data) 1105 return -EINVAL; 1106 1107 if (of_device_is_compatible(dev->of_node, "qcom,lpass-cpu-apq8016")) { 1108 dev_warn(dev, "%s compatible is deprecated\n", 1109 match->compatible); 1110 } 1111 1112 drvdata->variant = (struct lpass_variant *)match->data; 1113 variant = drvdata->variant; 1114 1115 of_lpass_cpu_parse_dai_data(dev, drvdata); 1116 1117 if (drvdata->codec_dma_enable) { 1118 drvdata->rxtx_lpaif = 1119 devm_platform_ioremap_resource_byname(pdev, "lpass-rxtx-lpaif"); 1120 if (IS_ERR(drvdata->rxtx_lpaif)) 1121 return PTR_ERR(drvdata->rxtx_lpaif); 1122 1123 drvdata->va_lpaif = devm_platform_ioremap_resource_byname(pdev, "lpass-va-lpaif"); 1124 if (IS_ERR(drvdata->va_lpaif)) 1125 return PTR_ERR(drvdata->va_lpaif); 1126 1127 lpass_rxtx_regmap_config.max_register = LPAIF_CDC_RXTX_WRDMAPER_REG(variant, 1128 variant->rxtx_wrdma_channels + 1129 variant->rxtx_wrdma_channel_start, LPASS_CDC_DMA_TX3); 1130 1131 drvdata->rxtx_lpaif_map = devm_regmap_init_mmio(dev, drvdata->rxtx_lpaif, 1132 &lpass_rxtx_regmap_config); 1133 if (IS_ERR(drvdata->rxtx_lpaif_map)) 1134 return PTR_ERR(drvdata->rxtx_lpaif_map); 1135 1136 lpass_va_regmap_config.max_register = LPAIF_CDC_VA_WRDMAPER_REG(variant, 1137 variant->va_wrdma_channels + 1138 variant->va_wrdma_channel_start, LPASS_CDC_DMA_VA_TX0); 1139 1140 drvdata->va_lpaif_map = devm_regmap_init_mmio(dev, drvdata->va_lpaif, 1141 &lpass_va_regmap_config); 1142 if (IS_ERR(drvdata->va_lpaif_map)) 1143 return PTR_ERR(drvdata->va_lpaif_map); 1144 1145 ret = of_lpass_cdc_dma_clks_parse(dev, drvdata); 1146 if (ret) { 1147 dev_err(dev, "failed to get cdc dma clocks %d\n", ret); 1148 return ret; 1149 } 1150 1151 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpass-rxtx-cdc-dma-lpm"); 1152 drvdata->rxtx_cdc_dma_lpm_buf = res->start; 1153 1154 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpass-va-cdc-dma-lpm"); 1155 drvdata->va_cdc_dma_lpm_buf = res->start; 1156 } 1157 1158 drvdata->lpaif = devm_platform_ioremap_resource_byname(pdev, "lpass-lpaif"); 1159 if (IS_ERR(drvdata->lpaif)) 1160 return PTR_ERR(drvdata->lpaif); 1161 1162 lpass_cpu_regmap_config.max_register = LPAIF_WRDMAPER_REG(variant, 1163 variant->wrdma_channels + 1164 variant->wrdma_channel_start); 1165 1166 drvdata->lpaif_map = devm_regmap_init_mmio(dev, drvdata->lpaif, 1167 &lpass_cpu_regmap_config); 1168 if (IS_ERR(drvdata->lpaif_map)) { 1169 dev_err(dev, "error initializing regmap: %ld\n", 1170 PTR_ERR(drvdata->lpaif_map)); 1171 return PTR_ERR(drvdata->lpaif_map); 1172 } 1173 1174 if (drvdata->hdmi_port_enable) { 1175 drvdata->hdmiif = devm_platform_ioremap_resource_byname(pdev, "lpass-hdmiif"); 1176 if (IS_ERR(drvdata->hdmiif)) 1177 return PTR_ERR(drvdata->hdmiif); 1178 1179 lpass_hdmi_regmap_config.max_register = LPAIF_HDMI_RDMAPER_REG(variant, 1180 variant->hdmi_rdma_channels - 1); 1181 drvdata->hdmiif_map = devm_regmap_init_mmio(dev, drvdata->hdmiif, 1182 &lpass_hdmi_regmap_config); 1183 if (IS_ERR(drvdata->hdmiif_map)) { 1184 dev_err(dev, "error initializing regmap: %ld\n", 1185 PTR_ERR(drvdata->hdmiif_map)); 1186 return PTR_ERR(drvdata->hdmiif_map); 1187 } 1188 } 1189 1190 if (variant->init) { 1191 ret = variant->init(pdev); 1192 if (ret) { 1193 dev_err(dev, "error initializing variant: %d\n", ret); 1194 return ret; 1195 } 1196 } 1197 1198 for (i = 0; i < variant->num_dai; i++) { 1199 dai_id = variant->dai_driver[i].id; 1200 if (dai_id == LPASS_DP_RX || is_cdc_dma_port(dai_id)) 1201 continue; 1202 1203 drvdata->mi2s_osr_clk[dai_id] = devm_clk_get_optional(dev, 1204 variant->dai_osr_clk_names[i]); 1205 drvdata->mi2s_bit_clk[dai_id] = devm_clk_get(dev, 1206 variant->dai_bit_clk_names[i]); 1207 if (IS_ERR(drvdata->mi2s_bit_clk[dai_id])) { 1208 dev_err(dev, 1209 "error getting %s: %ld\n", 1210 variant->dai_bit_clk_names[i], 1211 PTR_ERR(drvdata->mi2s_bit_clk[dai_id])); 1212 return PTR_ERR(drvdata->mi2s_bit_clk[dai_id]); 1213 } 1214 if (drvdata->mi2s_playback_sd_mode[dai_id] == 1215 LPAIF_I2SCTL_MODE_QUAD01) { 1216 variant->dai_driver[dai_id].playback.channels_min = 4; 1217 variant->dai_driver[dai_id].playback.channels_max = 4; 1218 } 1219 } 1220 1221 /* Allocation for i2sctl regmap fields */ 1222 drvdata->i2sctl = devm_kzalloc(&pdev->dev, sizeof(struct lpaif_i2sctl), 1223 GFP_KERNEL); 1224 1225 /* Initialize bitfields for dai I2SCTL register */ 1226 ret = lpass_cpu_init_i2sctl_bitfields(dev, drvdata->i2sctl, 1227 drvdata->lpaif_map); 1228 if (ret) { 1229 dev_err(dev, "error init i2sctl field: %d\n", ret); 1230 return ret; 1231 } 1232 1233 if (drvdata->hdmi_port_enable) { 1234 ret = lpass_hdmi_init_bitfields(dev, drvdata->hdmiif_map); 1235 if (ret) { 1236 dev_err(dev, "%s error hdmi init failed\n", __func__); 1237 return ret; 1238 } 1239 } 1240 ret = devm_snd_soc_register_component(dev, 1241 &lpass_cpu_comp_driver, 1242 variant->dai_driver, 1243 variant->num_dai); 1244 if (ret) { 1245 dev_err(dev, "error registering cpu driver: %d\n", ret); 1246 goto err; 1247 } 1248 1249 ret = asoc_qcom_lpass_platform_register(pdev); 1250 if (ret) { 1251 dev_err(dev, "error registering platform driver: %d\n", ret); 1252 goto err; 1253 } 1254 1255 err: 1256 return ret; 1257 } 1258 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_platform_probe); 1259 1260 int asoc_qcom_lpass_cpu_platform_remove(struct platform_device *pdev) 1261 { 1262 struct lpass_data *drvdata = platform_get_drvdata(pdev); 1263 1264 if (drvdata->variant->exit) 1265 drvdata->variant->exit(pdev); 1266 1267 1268 return 0; 1269 } 1270 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_platform_remove); 1271 1272 void asoc_qcom_lpass_cpu_platform_shutdown(struct platform_device *pdev) 1273 { 1274 struct lpass_data *drvdata = platform_get_drvdata(pdev); 1275 1276 if (drvdata->variant->exit) 1277 drvdata->variant->exit(pdev); 1278 1279 } 1280 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_platform_shutdown); 1281 1282 MODULE_DESCRIPTION("QTi LPASS CPU Driver"); 1283 MODULE_LICENSE("GPL v2"); 1284