1 /* 2 * Copyright (c) 2010-2011,2013-2015 The Linux Foundation. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 and 6 * only version 2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * lpass-cpu.c -- ALSA SoC CPU DAI driver for QTi LPASS 14 */ 15 16 #include <linux/clk.h> 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/of.h> 20 #include <linux/of_device.h> 21 #include <linux/platform_device.h> 22 #include <sound/pcm.h> 23 #include <sound/pcm_params.h> 24 #include <linux/regmap.h> 25 #include <sound/soc.h> 26 #include <sound/soc-dai.h> 27 #include "lpass-lpaif-reg.h" 28 #include "lpass.h" 29 30 static int lpass_cpu_daiops_set_sysclk(struct snd_soc_dai *dai, int clk_id, 31 unsigned int freq, int dir) 32 { 33 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 34 int ret; 35 36 if (IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) 37 return 0; 38 39 ret = clk_set_rate(drvdata->mi2s_osr_clk[dai->driver->id], freq); 40 if (ret) 41 dev_err(dai->dev, "%s() error setting mi2s osrclk to %u: %d\n", 42 __func__, freq, ret); 43 44 return ret; 45 } 46 47 static int lpass_cpu_daiops_startup(struct snd_pcm_substream *substream, 48 struct snd_soc_dai *dai) 49 { 50 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 51 int ret; 52 53 if (!IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) { 54 ret = clk_prepare_enable( 55 drvdata->mi2s_osr_clk[dai->driver->id]); 56 if (ret) { 57 dev_err(dai->dev, "%s() error in enabling mi2s osr clk: %d\n", 58 __func__, ret); 59 return ret; 60 } 61 } 62 63 ret = clk_prepare_enable(drvdata->mi2s_bit_clk[dai->driver->id]); 64 if (ret) { 65 dev_err(dai->dev, "%s() error in enabling mi2s bit clk: %d\n", 66 __func__, ret); 67 if (!IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) 68 clk_disable_unprepare( 69 drvdata->mi2s_osr_clk[dai->driver->id]); 70 return ret; 71 } 72 73 return 0; 74 } 75 76 static void lpass_cpu_daiops_shutdown(struct snd_pcm_substream *substream, 77 struct snd_soc_dai *dai) 78 { 79 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 80 81 clk_disable_unprepare(drvdata->mi2s_bit_clk[dai->driver->id]); 82 83 if (!IS_ERR(drvdata->mi2s_osr_clk[dai->driver->id])) 84 clk_disable_unprepare(drvdata->mi2s_osr_clk[dai->driver->id]); 85 } 86 87 static int lpass_cpu_daiops_hw_params(struct snd_pcm_substream *substream, 88 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) 89 { 90 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 91 snd_pcm_format_t format = params_format(params); 92 unsigned int channels = params_channels(params); 93 unsigned int rate = params_rate(params); 94 unsigned int regval; 95 int bitwidth, ret; 96 97 bitwidth = snd_pcm_format_width(format); 98 if (bitwidth < 0) { 99 dev_err(dai->dev, "%s() invalid bit width given: %d\n", 100 __func__, bitwidth); 101 return bitwidth; 102 } 103 104 regval = LPAIF_I2SCTL_LOOPBACK_DISABLE | 105 LPAIF_I2SCTL_WSSRC_INTERNAL; 106 107 switch (bitwidth) { 108 case 16: 109 regval |= LPAIF_I2SCTL_BITWIDTH_16; 110 break; 111 case 24: 112 regval |= LPAIF_I2SCTL_BITWIDTH_24; 113 break; 114 case 32: 115 regval |= LPAIF_I2SCTL_BITWIDTH_32; 116 break; 117 default: 118 dev_err(dai->dev, "%s() invalid bitwidth given: %d\n", 119 __func__, bitwidth); 120 return -EINVAL; 121 } 122 123 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 124 switch (channels) { 125 case 1: 126 regval |= LPAIF_I2SCTL_SPKMODE_SD0; 127 regval |= LPAIF_I2SCTL_SPKMONO_MONO; 128 break; 129 case 2: 130 regval |= LPAIF_I2SCTL_SPKMODE_SD0; 131 regval |= LPAIF_I2SCTL_SPKMONO_STEREO; 132 break; 133 case 4: 134 regval |= LPAIF_I2SCTL_SPKMODE_QUAD01; 135 regval |= LPAIF_I2SCTL_SPKMONO_STEREO; 136 break; 137 case 6: 138 regval |= LPAIF_I2SCTL_SPKMODE_6CH; 139 regval |= LPAIF_I2SCTL_SPKMONO_STEREO; 140 break; 141 case 8: 142 regval |= LPAIF_I2SCTL_SPKMODE_8CH; 143 regval |= LPAIF_I2SCTL_SPKMONO_STEREO; 144 break; 145 default: 146 dev_err(dai->dev, "%s() invalid channels given: %u\n", 147 __func__, channels); 148 return -EINVAL; 149 } 150 } else { 151 switch (channels) { 152 case 1: 153 regval |= LPAIF_I2SCTL_MICMODE_SD0; 154 regval |= LPAIF_I2SCTL_MICMONO_MONO; 155 break; 156 case 2: 157 regval |= LPAIF_I2SCTL_MICMODE_SD0; 158 regval |= LPAIF_I2SCTL_MICMONO_STEREO; 159 break; 160 case 4: 161 regval |= LPAIF_I2SCTL_MICMODE_QUAD01; 162 regval |= LPAIF_I2SCTL_MICMONO_STEREO; 163 break; 164 case 6: 165 regval |= LPAIF_I2SCTL_MICMODE_6CH; 166 regval |= LPAIF_I2SCTL_MICMONO_STEREO; 167 break; 168 case 8: 169 regval |= LPAIF_I2SCTL_MICMODE_8CH; 170 regval |= LPAIF_I2SCTL_MICMONO_STEREO; 171 break; 172 default: 173 dev_err(dai->dev, "%s() invalid channels given: %u\n", 174 __func__, channels); 175 return -EINVAL; 176 } 177 } 178 179 ret = regmap_write(drvdata->lpaif_map, 180 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), 181 regval); 182 if (ret) { 183 dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n", 184 __func__, ret); 185 return ret; 186 } 187 188 ret = clk_set_rate(drvdata->mi2s_bit_clk[dai->driver->id], 189 rate * bitwidth * 2); 190 if (ret) { 191 dev_err(dai->dev, "%s() error setting mi2s bitclk to %u: %d\n", 192 __func__, rate * bitwidth * 2, ret); 193 return ret; 194 } 195 196 return 0; 197 } 198 199 static int lpass_cpu_daiops_hw_free(struct snd_pcm_substream *substream, 200 struct snd_soc_dai *dai) 201 { 202 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 203 int ret; 204 205 ret = regmap_write(drvdata->lpaif_map, 206 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), 207 0); 208 if (ret) 209 dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n", 210 __func__, ret); 211 212 return ret; 213 } 214 215 static int lpass_cpu_daiops_prepare(struct snd_pcm_substream *substream, 216 struct snd_soc_dai *dai) 217 { 218 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 219 int ret; 220 unsigned int val, mask; 221 222 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 223 val = LPAIF_I2SCTL_SPKEN_ENABLE; 224 mask = LPAIF_I2SCTL_SPKEN_MASK; 225 } else { 226 val = LPAIF_I2SCTL_MICEN_ENABLE; 227 mask = LPAIF_I2SCTL_MICEN_MASK; 228 } 229 230 ret = regmap_update_bits(drvdata->lpaif_map, 231 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), 232 mask, val); 233 if (ret) 234 dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n", 235 __func__, ret); 236 237 return ret; 238 } 239 240 static int lpass_cpu_daiops_trigger(struct snd_pcm_substream *substream, 241 int cmd, struct snd_soc_dai *dai) 242 { 243 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 244 int ret = -EINVAL; 245 unsigned int val, mask; 246 247 switch (cmd) { 248 case SNDRV_PCM_TRIGGER_START: 249 case SNDRV_PCM_TRIGGER_RESUME: 250 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 251 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 252 val = LPAIF_I2SCTL_SPKEN_ENABLE; 253 mask = LPAIF_I2SCTL_SPKEN_MASK; 254 } else { 255 val = LPAIF_I2SCTL_MICEN_ENABLE; 256 mask = LPAIF_I2SCTL_MICEN_MASK; 257 } 258 259 ret = regmap_update_bits(drvdata->lpaif_map, 260 LPAIF_I2SCTL_REG(drvdata->variant, 261 dai->driver->id), 262 mask, val); 263 if (ret) 264 dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n", 265 __func__, ret); 266 break; 267 case SNDRV_PCM_TRIGGER_STOP: 268 case SNDRV_PCM_TRIGGER_SUSPEND: 269 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 270 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 271 val = LPAIF_I2SCTL_SPKEN_DISABLE; 272 mask = LPAIF_I2SCTL_SPKEN_MASK; 273 } else { 274 val = LPAIF_I2SCTL_MICEN_DISABLE; 275 mask = LPAIF_I2SCTL_MICEN_MASK; 276 } 277 278 ret = regmap_update_bits(drvdata->lpaif_map, 279 LPAIF_I2SCTL_REG(drvdata->variant, 280 dai->driver->id), 281 mask, val); 282 if (ret) 283 dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n", 284 __func__, ret); 285 break; 286 } 287 288 return ret; 289 } 290 291 const struct snd_soc_dai_ops asoc_qcom_lpass_cpu_dai_ops = { 292 .set_sysclk = lpass_cpu_daiops_set_sysclk, 293 .startup = lpass_cpu_daiops_startup, 294 .shutdown = lpass_cpu_daiops_shutdown, 295 .hw_params = lpass_cpu_daiops_hw_params, 296 .hw_free = lpass_cpu_daiops_hw_free, 297 .prepare = lpass_cpu_daiops_prepare, 298 .trigger = lpass_cpu_daiops_trigger, 299 }; 300 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_dai_ops); 301 302 int asoc_qcom_lpass_cpu_dai_probe(struct snd_soc_dai *dai) 303 { 304 struct lpass_data *drvdata = snd_soc_dai_get_drvdata(dai); 305 int ret; 306 307 /* ensure audio hardware is disabled */ 308 ret = regmap_write(drvdata->lpaif_map, 309 LPAIF_I2SCTL_REG(drvdata->variant, dai->driver->id), 0); 310 if (ret) 311 dev_err(dai->dev, "%s() error writing to i2sctl reg: %d\n", 312 __func__, ret); 313 314 return ret; 315 } 316 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_dai_probe); 317 318 static const struct snd_soc_component_driver lpass_cpu_comp_driver = { 319 .name = "lpass-cpu", 320 }; 321 322 static bool lpass_cpu_regmap_writeable(struct device *dev, unsigned int reg) 323 { 324 struct lpass_data *drvdata = dev_get_drvdata(dev); 325 struct lpass_variant *v = drvdata->variant; 326 int i; 327 328 for (i = 0; i < v->i2s_ports; ++i) 329 if (reg == LPAIF_I2SCTL_REG(v, i)) 330 return true; 331 332 for (i = 0; i < v->irq_ports; ++i) { 333 if (reg == LPAIF_IRQEN_REG(v, i)) 334 return true; 335 if (reg == LPAIF_IRQCLEAR_REG(v, i)) 336 return true; 337 } 338 339 for (i = 0; i < v->rdma_channels; ++i) { 340 if (reg == LPAIF_RDMACTL_REG(v, i)) 341 return true; 342 if (reg == LPAIF_RDMABASE_REG(v, i)) 343 return true; 344 if (reg == LPAIF_RDMABUFF_REG(v, i)) 345 return true; 346 if (reg == LPAIF_RDMAPER_REG(v, i)) 347 return true; 348 } 349 350 for (i = 0; i < v->wrdma_channels; ++i) { 351 if (reg == LPAIF_WRDMACTL_REG(v, i + v->wrdma_channel_start)) 352 return true; 353 if (reg == LPAIF_WRDMABASE_REG(v, i + v->wrdma_channel_start)) 354 return true; 355 if (reg == LPAIF_WRDMABUFF_REG(v, i + v->wrdma_channel_start)) 356 return true; 357 if (reg == LPAIF_WRDMAPER_REG(v, i + v->wrdma_channel_start)) 358 return true; 359 } 360 361 return false; 362 } 363 364 static bool lpass_cpu_regmap_readable(struct device *dev, unsigned int reg) 365 { 366 struct lpass_data *drvdata = dev_get_drvdata(dev); 367 struct lpass_variant *v = drvdata->variant; 368 int i; 369 370 for (i = 0; i < v->i2s_ports; ++i) 371 if (reg == LPAIF_I2SCTL_REG(v, i)) 372 return true; 373 374 for (i = 0; i < v->irq_ports; ++i) { 375 if (reg == LPAIF_IRQEN_REG(v, i)) 376 return true; 377 if (reg == LPAIF_IRQSTAT_REG(v, i)) 378 return true; 379 } 380 381 for (i = 0; i < v->rdma_channels; ++i) { 382 if (reg == LPAIF_RDMACTL_REG(v, i)) 383 return true; 384 if (reg == LPAIF_RDMABASE_REG(v, i)) 385 return true; 386 if (reg == LPAIF_RDMABUFF_REG(v, i)) 387 return true; 388 if (reg == LPAIF_RDMACURR_REG(v, i)) 389 return true; 390 if (reg == LPAIF_RDMAPER_REG(v, i)) 391 return true; 392 } 393 394 for (i = 0; i < v->wrdma_channels; ++i) { 395 if (reg == LPAIF_WRDMACTL_REG(v, i + v->wrdma_channel_start)) 396 return true; 397 if (reg == LPAIF_WRDMABASE_REG(v, i + v->wrdma_channel_start)) 398 return true; 399 if (reg == LPAIF_WRDMABUFF_REG(v, i + v->wrdma_channel_start)) 400 return true; 401 if (reg == LPAIF_WRDMACURR_REG(v, i + v->wrdma_channel_start)) 402 return true; 403 if (reg == LPAIF_WRDMAPER_REG(v, i + v->wrdma_channel_start)) 404 return true; 405 } 406 407 return false; 408 } 409 410 static bool lpass_cpu_regmap_volatile(struct device *dev, unsigned int reg) 411 { 412 struct lpass_data *drvdata = dev_get_drvdata(dev); 413 struct lpass_variant *v = drvdata->variant; 414 int i; 415 416 for (i = 0; i < v->irq_ports; ++i) 417 if (reg == LPAIF_IRQSTAT_REG(v, i)) 418 return true; 419 420 for (i = 0; i < v->rdma_channels; ++i) 421 if (reg == LPAIF_RDMACURR_REG(v, i)) 422 return true; 423 424 for (i = 0; i < v->wrdma_channels; ++i) 425 if (reg == LPAIF_WRDMACURR_REG(v, i + v->wrdma_channel_start)) 426 return true; 427 428 return false; 429 } 430 431 static struct regmap_config lpass_cpu_regmap_config = { 432 .reg_bits = 32, 433 .reg_stride = 4, 434 .val_bits = 32, 435 .writeable_reg = lpass_cpu_regmap_writeable, 436 .readable_reg = lpass_cpu_regmap_readable, 437 .volatile_reg = lpass_cpu_regmap_volatile, 438 .cache_type = REGCACHE_FLAT, 439 }; 440 441 int asoc_qcom_lpass_cpu_platform_probe(struct platform_device *pdev) 442 { 443 struct lpass_data *drvdata; 444 struct device_node *dsp_of_node; 445 struct resource *res; 446 struct lpass_variant *variant; 447 struct device *dev = &pdev->dev; 448 const struct of_device_id *match; 449 char clk_name[16]; 450 int ret, i, dai_id; 451 452 dsp_of_node = of_parse_phandle(pdev->dev.of_node, "qcom,adsp", 0); 453 if (dsp_of_node) { 454 dev_err(&pdev->dev, "%s() DSP exists and holds audio resources\n", 455 __func__); 456 return -EBUSY; 457 } 458 459 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct lpass_data), 460 GFP_KERNEL); 461 if (!drvdata) 462 return -ENOMEM; 463 platform_set_drvdata(pdev, drvdata); 464 465 match = of_match_device(dev->driver->of_match_table, dev); 466 if (!match || !match->data) 467 return -EINVAL; 468 469 drvdata->variant = (struct lpass_variant *)match->data; 470 variant = drvdata->variant; 471 472 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "lpass-lpaif"); 473 474 drvdata->lpaif = devm_ioremap_resource(&pdev->dev, res); 475 if (IS_ERR((void const __force *)drvdata->lpaif)) { 476 dev_err(&pdev->dev, "%s() error mapping reg resource: %ld\n", 477 __func__, 478 PTR_ERR((void const __force *)drvdata->lpaif)); 479 return PTR_ERR((void const __force *)drvdata->lpaif); 480 } 481 482 lpass_cpu_regmap_config.max_register = LPAIF_WRDMAPER_REG(variant, 483 variant->wrdma_channels + 484 variant->wrdma_channel_start); 485 486 drvdata->lpaif_map = devm_regmap_init_mmio(&pdev->dev, drvdata->lpaif, 487 &lpass_cpu_regmap_config); 488 if (IS_ERR(drvdata->lpaif_map)) { 489 dev_err(&pdev->dev, "%s() error initializing regmap: %ld\n", 490 __func__, PTR_ERR(drvdata->lpaif_map)); 491 return PTR_ERR(drvdata->lpaif_map); 492 } 493 494 if (variant->init) 495 variant->init(pdev); 496 497 for (i = 0; i < variant->num_dai; i++) { 498 dai_id = variant->dai_driver[i].id; 499 if (variant->num_dai > 1) 500 sprintf(clk_name, "mi2s-osr-clk%d", i); 501 else 502 sprintf(clk_name, "mi2s-osr-clk"); 503 504 drvdata->mi2s_osr_clk[dai_id] = devm_clk_get(&pdev->dev, 505 clk_name); 506 if (IS_ERR(drvdata->mi2s_osr_clk[dai_id])) { 507 dev_warn(&pdev->dev, 508 "%s() error getting mi2s-osr-clk: %ld\n", 509 __func__, 510 PTR_ERR(drvdata->mi2s_osr_clk[dai_id])); 511 } 512 513 if (variant->num_dai > 1) 514 sprintf(clk_name, "mi2s-bit-clk%d", i); 515 else 516 sprintf(clk_name, "mi2s-bit-clk"); 517 518 drvdata->mi2s_bit_clk[dai_id] = devm_clk_get(&pdev->dev, 519 clk_name); 520 if (IS_ERR(drvdata->mi2s_bit_clk[dai_id])) { 521 dev_err(&pdev->dev, 522 "%s() error getting mi2s-bit-clk: %ld\n", 523 __func__, 524 PTR_ERR(drvdata->mi2s_bit_clk[dai_id])); 525 return PTR_ERR(drvdata->mi2s_bit_clk[dai_id]); 526 } 527 } 528 529 drvdata->ahbix_clk = devm_clk_get(&pdev->dev, "ahbix-clk"); 530 if (IS_ERR(drvdata->ahbix_clk)) { 531 dev_err(&pdev->dev, "%s() error getting ahbix-clk: %ld\n", 532 __func__, PTR_ERR(drvdata->ahbix_clk)); 533 return PTR_ERR(drvdata->ahbix_clk); 534 } 535 536 ret = clk_set_rate(drvdata->ahbix_clk, LPASS_AHBIX_CLOCK_FREQUENCY); 537 if (ret) { 538 dev_err(&pdev->dev, "%s() error setting rate on ahbix_clk: %d\n", 539 __func__, ret); 540 return ret; 541 } 542 dev_dbg(&pdev->dev, "%s() set ahbix_clk rate to %lu\n", __func__, 543 clk_get_rate(drvdata->ahbix_clk)); 544 545 ret = clk_prepare_enable(drvdata->ahbix_clk); 546 if (ret) { 547 dev_err(&pdev->dev, "%s() error enabling ahbix_clk: %d\n", 548 __func__, ret); 549 return ret; 550 } 551 552 ret = devm_snd_soc_register_component(&pdev->dev, 553 &lpass_cpu_comp_driver, 554 variant->dai_driver, 555 variant->num_dai); 556 if (ret) { 557 dev_err(&pdev->dev, "%s() error registering cpu driver: %d\n", 558 __func__, ret); 559 goto err_clk; 560 } 561 562 ret = asoc_qcom_lpass_platform_register(pdev); 563 if (ret) { 564 dev_err(&pdev->dev, "%s() error registering platform driver: %d\n", 565 __func__, ret); 566 goto err_clk; 567 } 568 569 return 0; 570 571 err_clk: 572 clk_disable_unprepare(drvdata->ahbix_clk); 573 return ret; 574 } 575 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_platform_probe); 576 577 int asoc_qcom_lpass_cpu_platform_remove(struct platform_device *pdev) 578 { 579 struct lpass_data *drvdata = platform_get_drvdata(pdev); 580 581 if (drvdata->variant->exit) 582 drvdata->variant->exit(pdev); 583 584 clk_disable_unprepare(drvdata->ahbix_clk); 585 586 return 0; 587 } 588 EXPORT_SYMBOL_GPL(asoc_qcom_lpass_cpu_platform_remove); 589