1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * linux/sound/soc/pxa/mmp-sspa.c 4 * Base on pxa2xx-ssp.c 5 * 6 * Copyright (C) 2011 Marvell International Ltd. 7 */ 8 #include <linux/init.h> 9 #include <linux/module.h> 10 #include <linux/platform_device.h> 11 #include <linux/delay.h> 12 #include <linux/clk.h> 13 #include <linux/slab.h> 14 #include <linux/pxa2xx_ssp.h> 15 #include <linux/io.h> 16 #include <linux/dmaengine.h> 17 18 #include <sound/core.h> 19 #include <sound/pcm.h> 20 #include <sound/initval.h> 21 #include <sound/pcm_params.h> 22 #include <sound/soc.h> 23 #include <sound/pxa2xx-lib.h> 24 #include <sound/dmaengine_pcm.h> 25 #include "mmp-sspa.h" 26 27 /* 28 * SSPA audio private data 29 */ 30 struct sspa_priv { 31 struct ssp_device *sspa; 32 struct snd_dmaengine_dai_dma_data *dma_params; 33 struct clk *audio_clk; 34 struct clk *sysclk; 35 int dai_fmt; 36 int running_cnt; 37 }; 38 39 static void mmp_sspa_write_reg(struct ssp_device *sspa, u32 reg, u32 val) 40 { 41 __raw_writel(val, sspa->mmio_base + reg); 42 } 43 44 static u32 mmp_sspa_read_reg(struct ssp_device *sspa, u32 reg) 45 { 46 return __raw_readl(sspa->mmio_base + reg); 47 } 48 49 static void mmp_sspa_tx_enable(struct ssp_device *sspa) 50 { 51 unsigned int sspa_sp; 52 53 sspa_sp = mmp_sspa_read_reg(sspa, SSPA_TXSP); 54 sspa_sp |= SSPA_SP_S_EN; 55 sspa_sp |= SSPA_SP_WEN; 56 mmp_sspa_write_reg(sspa, SSPA_TXSP, sspa_sp); 57 } 58 59 static void mmp_sspa_tx_disable(struct ssp_device *sspa) 60 { 61 unsigned int sspa_sp; 62 63 sspa_sp = mmp_sspa_read_reg(sspa, SSPA_TXSP); 64 sspa_sp &= ~SSPA_SP_S_EN; 65 sspa_sp |= SSPA_SP_WEN; 66 mmp_sspa_write_reg(sspa, SSPA_TXSP, sspa_sp); 67 } 68 69 static void mmp_sspa_rx_enable(struct ssp_device *sspa) 70 { 71 unsigned int sspa_sp; 72 73 sspa_sp = mmp_sspa_read_reg(sspa, SSPA_RXSP); 74 sspa_sp |= SSPA_SP_S_EN; 75 sspa_sp |= SSPA_SP_WEN; 76 mmp_sspa_write_reg(sspa, SSPA_RXSP, sspa_sp); 77 } 78 79 static void mmp_sspa_rx_disable(struct ssp_device *sspa) 80 { 81 unsigned int sspa_sp; 82 83 sspa_sp = mmp_sspa_read_reg(sspa, SSPA_RXSP); 84 sspa_sp &= ~SSPA_SP_S_EN; 85 sspa_sp |= SSPA_SP_WEN; 86 mmp_sspa_write_reg(sspa, SSPA_RXSP, sspa_sp); 87 } 88 89 static int mmp_sspa_startup(struct snd_pcm_substream *substream, 90 struct snd_soc_dai *dai) 91 { 92 struct sspa_priv *priv = snd_soc_dai_get_drvdata(dai); 93 94 clk_enable(priv->sysclk); 95 clk_enable(priv->sspa->clk); 96 97 return 0; 98 } 99 100 static void mmp_sspa_shutdown(struct snd_pcm_substream *substream, 101 struct snd_soc_dai *dai) 102 { 103 struct sspa_priv *priv = snd_soc_dai_get_drvdata(dai); 104 105 clk_disable(priv->sspa->clk); 106 clk_disable(priv->sysclk); 107 108 } 109 110 /* 111 * Set the SSP ports SYSCLK. 112 */ 113 static int mmp_sspa_set_dai_sysclk(struct snd_soc_dai *cpu_dai, 114 int clk_id, unsigned int freq, int dir) 115 { 116 struct sspa_priv *priv = snd_soc_dai_get_drvdata(cpu_dai); 117 int ret = 0; 118 119 switch (clk_id) { 120 case MMP_SSPA_CLK_AUDIO: 121 ret = clk_set_rate(priv->audio_clk, freq); 122 if (ret) 123 return ret; 124 break; 125 case MMP_SSPA_CLK_PLL: 126 case MMP_SSPA_CLK_VCXO: 127 /* not support yet */ 128 return -EINVAL; 129 default: 130 return -EINVAL; 131 } 132 133 return 0; 134 } 135 136 static int mmp_sspa_set_dai_pll(struct snd_soc_dai *cpu_dai, int pll_id, 137 int source, unsigned int freq_in, 138 unsigned int freq_out) 139 { 140 struct sspa_priv *priv = snd_soc_dai_get_drvdata(cpu_dai); 141 int ret = 0; 142 143 switch (pll_id) { 144 case MMP_SYSCLK: 145 ret = clk_set_rate(priv->sysclk, freq_out); 146 if (ret) 147 return ret; 148 break; 149 case MMP_SSPA_CLK: 150 ret = clk_set_rate(priv->sspa->clk, freq_out); 151 if (ret) 152 return ret; 153 break; 154 default: 155 return -ENODEV; 156 } 157 158 return 0; 159 } 160 161 /* 162 * Set up the sspa dai format. The sspa port must be inactive 163 * before calling this function as the physical 164 * interface format is changed. 165 */ 166 static int mmp_sspa_set_dai_fmt(struct snd_soc_dai *cpu_dai, 167 unsigned int fmt) 168 { 169 struct sspa_priv *sspa_priv = snd_soc_dai_get_drvdata(cpu_dai); 170 struct ssp_device *sspa = sspa_priv->sspa; 171 u32 sspa_sp, sspa_ctrl; 172 173 /* check if we need to change anything at all */ 174 if (sspa_priv->dai_fmt == fmt) 175 return 0; 176 177 /* we can only change the settings if the port is not in use */ 178 if ((mmp_sspa_read_reg(sspa, SSPA_TXSP) & SSPA_SP_S_EN) || 179 (mmp_sspa_read_reg(sspa, SSPA_RXSP) & SSPA_SP_S_EN)) { 180 dev_err(sspa->dev, 181 "can't change hardware dai format: stream is in use\n"); 182 return -EINVAL; 183 } 184 185 /* reset port settings */ 186 sspa_sp = SSPA_SP_WEN | SSPA_SP_S_RST | SSPA_SP_FFLUSH; 187 sspa_ctrl = 0; 188 189 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 190 case SND_SOC_DAIFMT_CBS_CFS: 191 sspa_sp |= SSPA_SP_MSL; 192 break; 193 case SND_SOC_DAIFMT_CBM_CFM: 194 break; 195 default: 196 return -EINVAL; 197 } 198 199 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 200 case SND_SOC_DAIFMT_NB_NF: 201 sspa_sp |= SSPA_SP_FSP; 202 break; 203 default: 204 return -EINVAL; 205 } 206 207 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 208 case SND_SOC_DAIFMT_I2S: 209 sspa_sp |= SSPA_TXSP_FPER(63); 210 sspa_sp |= SSPA_SP_FWID(31); 211 sspa_ctrl |= SSPA_CTL_XDATDLY(1); 212 break; 213 default: 214 return -EINVAL; 215 } 216 217 mmp_sspa_write_reg(sspa, SSPA_TXSP, sspa_sp); 218 mmp_sspa_write_reg(sspa, SSPA_RXSP, sspa_sp); 219 220 sspa_sp &= ~(SSPA_SP_S_RST | SSPA_SP_FFLUSH); 221 mmp_sspa_write_reg(sspa, SSPA_TXSP, sspa_sp); 222 mmp_sspa_write_reg(sspa, SSPA_RXSP, sspa_sp); 223 224 /* 225 * FIXME: hw issue, for the tx serial port, 226 * can not config the master/slave mode; 227 * so must clean this bit. 228 * The master/slave mode has been set in the 229 * rx port. 230 */ 231 sspa_sp &= ~SSPA_SP_MSL; 232 mmp_sspa_write_reg(sspa, SSPA_TXSP, sspa_sp); 233 234 mmp_sspa_write_reg(sspa, SSPA_TXCTL, sspa_ctrl); 235 mmp_sspa_write_reg(sspa, SSPA_RXCTL, sspa_ctrl); 236 237 /* Since we are configuring the timings for the format by hand 238 * we have to defer some things until hw_params() where we 239 * know parameters like the sample size. 240 */ 241 sspa_priv->dai_fmt = fmt; 242 return 0; 243 } 244 245 /* 246 * Set the SSPA audio DMA parameters and sample size. 247 * Can be called multiple times by oss emulation. 248 */ 249 static int mmp_sspa_hw_params(struct snd_pcm_substream *substream, 250 struct snd_pcm_hw_params *params, 251 struct snd_soc_dai *dai) 252 { 253 struct snd_soc_pcm_runtime *rtd = substream->private_data; 254 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); 255 struct sspa_priv *sspa_priv = snd_soc_dai_get_drvdata(dai); 256 struct ssp_device *sspa = sspa_priv->sspa; 257 struct snd_dmaengine_dai_dma_data *dma_params; 258 u32 sspa_ctrl; 259 260 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 261 sspa_ctrl = mmp_sspa_read_reg(sspa, SSPA_TXCTL); 262 else 263 sspa_ctrl = mmp_sspa_read_reg(sspa, SSPA_RXCTL); 264 265 sspa_ctrl &= ~SSPA_CTL_XFRLEN1_MASK; 266 sspa_ctrl |= SSPA_CTL_XFRLEN1(params_channels(params) - 1); 267 sspa_ctrl &= ~SSPA_CTL_XWDLEN1_MASK; 268 sspa_ctrl |= SSPA_CTL_XWDLEN1(SSPA_CTL_32_BITS); 269 sspa_ctrl &= ~SSPA_CTL_XSSZ1_MASK; 270 271 switch (params_format(params)) { 272 case SNDRV_PCM_FORMAT_S8: 273 sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_8_BITS); 274 break; 275 case SNDRV_PCM_FORMAT_S16_LE: 276 sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_16_BITS); 277 break; 278 case SNDRV_PCM_FORMAT_S24_3LE: 279 sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_24_BITS); 280 break; 281 case SNDRV_PCM_FORMAT_S32_LE: 282 sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_32_BITS); 283 break; 284 default: 285 return -EINVAL; 286 } 287 288 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 289 mmp_sspa_write_reg(sspa, SSPA_TXCTL, sspa_ctrl); 290 mmp_sspa_write_reg(sspa, SSPA_TXFIFO_LL, 0x1); 291 } else { 292 mmp_sspa_write_reg(sspa, SSPA_RXCTL, sspa_ctrl); 293 mmp_sspa_write_reg(sspa, SSPA_RXFIFO_UL, 0x0); 294 } 295 296 dma_params = &sspa_priv->dma_params[substream->stream]; 297 dma_params->addr = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 298 (sspa->phys_base + SSPA_TXD) : 299 (sspa->phys_base + SSPA_RXD); 300 snd_soc_dai_set_dma_data(cpu_dai, substream, dma_params); 301 return 0; 302 } 303 304 static int mmp_sspa_trigger(struct snd_pcm_substream *substream, int cmd, 305 struct snd_soc_dai *dai) 306 { 307 struct sspa_priv *sspa_priv = snd_soc_dai_get_drvdata(dai); 308 struct ssp_device *sspa = sspa_priv->sspa; 309 int ret = 0; 310 311 switch (cmd) { 312 case SNDRV_PCM_TRIGGER_START: 313 case SNDRV_PCM_TRIGGER_RESUME: 314 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 315 /* 316 * whatever playback or capture, must enable rx. 317 * this is a hw issue, so need check if rx has been 318 * enabled or not; if has been enabled by another 319 * stream, do not enable again. 320 */ 321 if (!sspa_priv->running_cnt) 322 mmp_sspa_rx_enable(sspa); 323 324 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 325 mmp_sspa_tx_enable(sspa); 326 327 sspa_priv->running_cnt++; 328 break; 329 330 case SNDRV_PCM_TRIGGER_STOP: 331 case SNDRV_PCM_TRIGGER_SUSPEND: 332 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 333 sspa_priv->running_cnt--; 334 335 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 336 mmp_sspa_tx_disable(sspa); 337 338 /* have no capture stream, disable rx port */ 339 if (!sspa_priv->running_cnt) 340 mmp_sspa_rx_disable(sspa); 341 break; 342 343 default: 344 ret = -EINVAL; 345 } 346 347 return ret; 348 } 349 350 static int mmp_sspa_probe(struct snd_soc_dai *dai) 351 { 352 struct sspa_priv *priv = dev_get_drvdata(dai->dev); 353 354 snd_soc_dai_set_drvdata(dai, priv); 355 return 0; 356 357 } 358 359 #define MMP_SSPA_RATES SNDRV_PCM_RATE_8000_192000 360 #define MMP_SSPA_FORMATS (SNDRV_PCM_FMTBIT_S8 | \ 361 SNDRV_PCM_FMTBIT_S16_LE | \ 362 SNDRV_PCM_FMTBIT_S24_3LE | \ 363 SNDRV_PCM_FMTBIT_S32_LE) 364 365 static const struct snd_soc_dai_ops mmp_sspa_dai_ops = { 366 .startup = mmp_sspa_startup, 367 .shutdown = mmp_sspa_shutdown, 368 .trigger = mmp_sspa_trigger, 369 .hw_params = mmp_sspa_hw_params, 370 .set_sysclk = mmp_sspa_set_dai_sysclk, 371 .set_pll = mmp_sspa_set_dai_pll, 372 .set_fmt = mmp_sspa_set_dai_fmt, 373 }; 374 375 static struct snd_soc_dai_driver mmp_sspa_dai = { 376 .probe = mmp_sspa_probe, 377 .playback = { 378 .channels_min = 1, 379 .channels_max = 128, 380 .rates = MMP_SSPA_RATES, 381 .formats = MMP_SSPA_FORMATS, 382 }, 383 .capture = { 384 .channels_min = 1, 385 .channels_max = 2, 386 .rates = MMP_SSPA_RATES, 387 .formats = MMP_SSPA_FORMATS, 388 }, 389 .ops = &mmp_sspa_dai_ops, 390 }; 391 392 static const struct snd_soc_component_driver mmp_sspa_component = { 393 .name = "mmp-sspa", 394 }; 395 396 static int asoc_mmp_sspa_probe(struct platform_device *pdev) 397 { 398 struct sspa_priv *priv; 399 400 priv = devm_kzalloc(&pdev->dev, 401 sizeof(struct sspa_priv), GFP_KERNEL); 402 if (!priv) 403 return -ENOMEM; 404 405 priv->sspa = devm_kzalloc(&pdev->dev, 406 sizeof(struct ssp_device), GFP_KERNEL); 407 if (priv->sspa == NULL) 408 return -ENOMEM; 409 410 priv->dma_params = devm_kcalloc(&pdev->dev, 411 2, sizeof(struct snd_dmaengine_dai_dma_data), 412 GFP_KERNEL); 413 if (priv->dma_params == NULL) 414 return -ENOMEM; 415 416 priv->sspa->mmio_base = devm_platform_ioremap_resource(pdev, 0); 417 if (IS_ERR(priv->sspa->mmio_base)) 418 return PTR_ERR(priv->sspa->mmio_base); 419 420 priv->sspa->clk = devm_clk_get(&pdev->dev, NULL); 421 if (IS_ERR(priv->sspa->clk)) 422 return PTR_ERR(priv->sspa->clk); 423 424 priv->audio_clk = clk_get(NULL, "mmp-audio"); 425 if (IS_ERR(priv->audio_clk)) 426 return PTR_ERR(priv->audio_clk); 427 428 priv->sysclk = clk_get(NULL, "mmp-sysclk"); 429 if (IS_ERR(priv->sysclk)) { 430 clk_put(priv->audio_clk); 431 return PTR_ERR(priv->sysclk); 432 } 433 clk_enable(priv->audio_clk); 434 priv->dai_fmt = (unsigned int) -1; 435 platform_set_drvdata(pdev, priv); 436 437 return devm_snd_soc_register_component(&pdev->dev, &mmp_sspa_component, 438 &mmp_sspa_dai, 1); 439 } 440 441 static int asoc_mmp_sspa_remove(struct platform_device *pdev) 442 { 443 struct sspa_priv *priv = platform_get_drvdata(pdev); 444 445 clk_disable(priv->audio_clk); 446 clk_put(priv->audio_clk); 447 clk_put(priv->sysclk); 448 return 0; 449 } 450 451 static struct platform_driver asoc_mmp_sspa_driver = { 452 .driver = { 453 .name = "mmp-sspa-dai", 454 }, 455 .probe = asoc_mmp_sspa_probe, 456 .remove = asoc_mmp_sspa_remove, 457 }; 458 459 module_platform_driver(asoc_mmp_sspa_driver); 460 461 MODULE_AUTHOR("Leo Yan <leoy@marvell.com>"); 462 MODULE_DESCRIPTION("MMP SSPA SoC Interface"); 463 MODULE_LICENSE("GPL"); 464 MODULE_ALIAS("platform:mmp-sspa-dai"); 465