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