pxa-ssp.c 19.7 KB
Newer Older
M
Mark Brown 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * pxa-ssp.c  --  ALSA Soc Audio Layer
 *
 * Copyright 2005,2008 Wolfson Microelectronics PLC.
 * Author: Liam Girdwood
 *         Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 * TODO:
 *  o Test network mode for > 16bit sample size
 */

#include <linux/init.h>
#include <linux/module.h>
19
#include <linux/slab.h>
M
Mark Brown 已提交
20 21 22
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <linux/io.h>
23
#include <linux/pxa2xx_ssp.h>
24
#include <linux/of.h>
25
#include <linux/dmaengine.h>
M
Mark Brown 已提交
26

27 28
#include <asm/irq.h>

M
Mark Brown 已提交
29 30 31 32 33 34
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/initval.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/pxa2xx-lib.h>
35
#include <sound/dmaengine_pcm.h>
M
Mark Brown 已提交
36 37 38

#include <mach/hardware.h>

H
Haojian Zhuang 已提交
39
#include "../../arm/pxa2xx-pcm.h"
M
Mark Brown 已提交
40 41 42 43 44 45
#include "pxa-ssp.h"

/*
 * SSP audio private data
 */
struct ssp_priv {
46
	struct ssp_device *ssp;
M
Mark Brown 已提交
47 48 49
	unsigned int sysclk;
	int dai_fmt;
#ifdef CONFIG_PM
50 51 52 53
	uint32_t	cr0;
	uint32_t	cr1;
	uint32_t	to;
	uint32_t	psp;
M
Mark Brown 已提交
54 55 56 57 58 59
#endif
};

static void dump_registers(struct ssp_device *ssp)
{
	dev_dbg(&ssp->pdev->dev, "SSCR0 0x%08x SSCR1 0x%08x SSTO 0x%08x\n",
H
Haojian Zhuang 已提交
60 61
		 pxa_ssp_read_reg(ssp, SSCR0), pxa_ssp_read_reg(ssp, SSCR1),
		 pxa_ssp_read_reg(ssp, SSTO));
M
Mark Brown 已提交
62 63

	dev_dbg(&ssp->pdev->dev, "SSPSP 0x%08x SSSR 0x%08x SSACD 0x%08x\n",
H
Haojian Zhuang 已提交
64 65
		 pxa_ssp_read_reg(ssp, SSPSP), pxa_ssp_read_reg(ssp, SSSR),
		 pxa_ssp_read_reg(ssp, SSACD));
M
Mark Brown 已提交
66 67
}

H
Haojian Zhuang 已提交
68
static void pxa_ssp_enable(struct ssp_device *ssp)
69 70 71 72 73 74 75
{
	uint32_t sscr0;

	sscr0 = __raw_readl(ssp->mmio_base + SSCR0) | SSCR0_SSE;
	__raw_writel(sscr0, ssp->mmio_base + SSCR0);
}

H
Haojian Zhuang 已提交
76
static void pxa_ssp_disable(struct ssp_device *ssp)
77 78 79 80 81 82 83
{
	uint32_t sscr0;

	sscr0 = __raw_readl(ssp->mmio_base + SSCR0) & ~SSCR0_SSE;
	__raw_writel(sscr0, ssp->mmio_base + SSCR0);
}

84
static void pxa_ssp_set_dma_params(struct ssp_device *ssp, int width4,
85
			int out, struct snd_dmaengine_dai_dma_data *dma)
86
{
87 88 89 90
	dma->addr_width = width4 ? DMA_SLAVE_BUSWIDTH_4_BYTES :
				   DMA_SLAVE_BUSWIDTH_2_BYTES;
	dma->maxburst = 16;
	dma->addr = ssp->phys_base + SSDR;
91 92
}

93
static int pxa_ssp_startup(struct snd_pcm_substream *substream,
94
			   struct snd_soc_dai *cpu_dai)
M
Mark Brown 已提交
95
{
96
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
97
	struct ssp_device *ssp = priv->ssp;
98
	struct snd_dmaengine_dai_dma_data *dma;
M
Mark Brown 已提交
99 100 101
	int ret = 0;

	if (!cpu_dai->active) {
102
		clk_enable(ssp->clk);
H
Haojian Zhuang 已提交
103
		pxa_ssp_disable(ssp);
M
Mark Brown 已提交
104
	}
105

106
	dma = kzalloc(sizeof(struct snd_dmaengine_dai_dma_data), GFP_KERNEL);
107 108
	if (!dma)
		return -ENOMEM;
109 110 111 112

	dma->filter_data = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
				&ssp->drcmr_tx : &ssp->drcmr_rx;

113
	snd_soc_dai_set_dma_data(cpu_dai, substream, dma);
114

M
Mark Brown 已提交
115 116 117
	return ret;
}

118
static void pxa_ssp_shutdown(struct snd_pcm_substream *substream,
119
			     struct snd_soc_dai *cpu_dai)
M
Mark Brown 已提交
120
{
121
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
122
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
123 124

	if (!cpu_dai->active) {
H
Haojian Zhuang 已提交
125
		pxa_ssp_disable(ssp);
126
		clk_disable(ssp->clk);
M
Mark Brown 已提交
127
	}
128

129 130
	kfree(snd_soc_dai_get_dma_data(cpu_dai, substream));
	snd_soc_dai_set_dma_data(cpu_dai, substream, NULL);
M
Mark Brown 已提交
131 132 133 134
}

#ifdef CONFIG_PM

135
static int pxa_ssp_suspend(struct snd_soc_dai *cpu_dai)
M
Mark Brown 已提交
136
{
137
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
138
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
139 140

	if (!cpu_dai->active)
141
		clk_enable(ssp->clk);
M
Mark Brown 已提交
142

143 144 145 146 147
	priv->cr0 = __raw_readl(ssp->mmio_base + SSCR0);
	priv->cr1 = __raw_readl(ssp->mmio_base + SSCR1);
	priv->to  = __raw_readl(ssp->mmio_base + SSTO);
	priv->psp = __raw_readl(ssp->mmio_base + SSPSP);

H
Haojian Zhuang 已提交
148
	pxa_ssp_disable(ssp);
149
	clk_disable(ssp->clk);
M
Mark Brown 已提交
150 151 152
	return 0;
}

153
static int pxa_ssp_resume(struct snd_soc_dai *cpu_dai)
M
Mark Brown 已提交
154
{
155
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
156 157
	struct ssp_device *ssp = priv->ssp;
	uint32_t sssr = SSSR_ROR | SSSR_TUR | SSSR_BCE;
M
Mark Brown 已提交
158

159 160 161 162 163 164 165
	clk_enable(ssp->clk);

	__raw_writel(sssr, ssp->mmio_base + SSSR);
	__raw_writel(priv->cr0 & ~SSCR0_SSE, ssp->mmio_base + SSCR0);
	__raw_writel(priv->cr1, ssp->mmio_base + SSCR1);
	__raw_writel(priv->to,  ssp->mmio_base + SSTO);
	__raw_writel(priv->psp, ssp->mmio_base + SSPSP);
D
Daniel Mack 已提交
166 167

	if (cpu_dai->active)
H
Haojian Zhuang 已提交
168
		pxa_ssp_enable(ssp);
D
Daniel Mack 已提交
169
	else
170
		clk_disable(ssp->clk);
M
Mark Brown 已提交
171 172 173 174 175 176 177 178 179 180 181 182 183

	return 0;
}

#else
#define pxa_ssp_suspend	NULL
#define pxa_ssp_resume	NULL
#endif

/**
 * ssp_set_clkdiv - set SSP clock divider
 * @div: serial clock rate divider
 */
H
Haojian Zhuang 已提交
184
static void pxa_ssp_set_scr(struct ssp_device *ssp, u32 div)
M
Mark Brown 已提交
185
{
H
Haojian Zhuang 已提交
186
	u32 sscr0 = pxa_ssp_read_reg(ssp, SSCR0);
187

188
	if (ssp->type == PXA25x_SSP) {
189 190 191 192 193 194
		sscr0 &= ~0x0000ff00;
		sscr0 |= ((div - 2)/2) << 8; /* 2..512 */
	} else {
		sscr0 &= ~0x000fff00;
		sscr0 |= (div - 1) << 8;     /* 1..4096 */
	}
H
Haojian Zhuang 已提交
195
	pxa_ssp_write_reg(ssp, SSCR0, sscr0);
196 197 198
}

/**
H
Haojian Zhuang 已提交
199
 * pxa_ssp_get_clkdiv - get SSP clock divider
200
 */
H
Haojian Zhuang 已提交
201
static u32 pxa_ssp_get_scr(struct ssp_device *ssp)
202
{
H
Haojian Zhuang 已提交
203
	u32 sscr0 = pxa_ssp_read_reg(ssp, SSCR0);
204
	u32 div;
M
Mark Brown 已提交
205

206
	if (ssp->type == PXA25x_SSP)
207 208 209 210
		div = ((sscr0 >> 8) & 0xff) * 2 + 2;
	else
		div = ((sscr0 >> 8) & 0xfff) + 1;
	return div;
M
Mark Brown 已提交
211 212 213 214 215 216 217 218
}

/*
 * Set the SSP ports SYSCLK.
 */
static int pxa_ssp_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
	int clk_id, unsigned int freq, int dir)
{
219
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
220
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
221 222
	int val;

H
Haojian Zhuang 已提交
223
	u32 sscr0 = pxa_ssp_read_reg(ssp, SSCR0) &
224
		~(SSCR0_ECS |  SSCR0_NCS | SSCR0_MOD | SSCR0_ACS);
M
Mark Brown 已提交
225 226

	dev_dbg(&ssp->pdev->dev,
227
		"pxa_ssp_set_dai_sysclk id: %d, clk_id %d, freq %u\n",
M
Mark Brown 已提交
228 229 230 231 232 233 234 235
		cpu_dai->id, clk_id, freq);

	switch (clk_id) {
	case PXA_SSP_CLK_NET_PLL:
		sscr0 |= SSCR0_MOD;
		break;
	case PXA_SSP_CLK_PLL:
		/* Internal PLL is fixed */
236
		if (ssp->type == PXA25x_SSP)
M
Mark Brown 已提交
237 238 239 240 241 242 243 244 245 246 247 248 249 250
			priv->sysclk = 1843200;
		else
			priv->sysclk = 13000000;
		break;
	case PXA_SSP_CLK_EXT:
		priv->sysclk = freq;
		sscr0 |= SSCR0_ECS;
		break;
	case PXA_SSP_CLK_NET:
		priv->sysclk = freq;
		sscr0 |= SSCR0_NCS | SSCR0_MOD;
		break;
	case PXA_SSP_CLK_AUDIO:
		priv->sysclk = 0;
H
Haojian Zhuang 已提交
251
		pxa_ssp_set_scr(ssp, 1);
252
		sscr0 |= SSCR0_ACS;
M
Mark Brown 已提交
253 254 255 256 257 258 259
		break;
	default:
		return -ENODEV;
	}

	/* The SSP clock must be disabled when changing SSP clock mode
	 * on PXA2xx.  On PXA3xx it must be enabled when doing so. */
260
	if (ssp->type != PXA3xx_SSP)
261
		clk_disable(ssp->clk);
H
Haojian Zhuang 已提交
262 263
	val = pxa_ssp_read_reg(ssp, SSCR0) | sscr0;
	pxa_ssp_write_reg(ssp, SSCR0, val);
264
	if (ssp->type != PXA3xx_SSP)
265
		clk_enable(ssp->clk);
M
Mark Brown 已提交
266 267 268 269 270 271 272 273 274 275

	return 0;
}

/*
 * Set the SSP clock dividers.
 */
static int pxa_ssp_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
	int div_id, int div)
{
276
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
277
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
278 279 280 281
	int val;

	switch (div_id) {
	case PXA_SSP_AUDIO_DIV_ACDS:
H
Haojian Zhuang 已提交
282 283
		val = (pxa_ssp_read_reg(ssp, SSACD) & ~0x7) | SSACD_ACDS(div);
		pxa_ssp_write_reg(ssp, SSACD, val);
M
Mark Brown 已提交
284 285
		break;
	case PXA_SSP_AUDIO_DIV_SCDB:
H
Haojian Zhuang 已提交
286
		val = pxa_ssp_read_reg(ssp, SSACD);
M
Mark Brown 已提交
287
		val &= ~SSACD_SCDB;
288
		if (ssp->type == PXA3xx_SSP)
M
Mark Brown 已提交
289 290 291 292 293 294 295 296
			val &= ~SSACD_SCDX8;
		switch (div) {
		case PXA_SSP_CLK_SCDB_1:
			val |= SSACD_SCDB;
			break;
		case PXA_SSP_CLK_SCDB_4:
			break;
		case PXA_SSP_CLK_SCDB_8:
297
			if (ssp->type == PXA3xx_SSP)
M
Mark Brown 已提交
298 299 300 301 302 303 304
				val |= SSACD_SCDX8;
			else
				return -EINVAL;
			break;
		default:
			return -EINVAL;
		}
H
Haojian Zhuang 已提交
305
		pxa_ssp_write_reg(ssp, SSACD, val);
M
Mark Brown 已提交
306 307
		break;
	case PXA_SSP_DIV_SCR:
H
Haojian Zhuang 已提交
308
		pxa_ssp_set_scr(ssp, div);
M
Mark Brown 已提交
309 310 311 312 313 314 315 316 317 318 319
		break;
	default:
		return -ENODEV;
	}

	return 0;
}

/*
 * Configure the PLL frequency pxa27x and (afaik - pxa320 only)
 */
320 321
static int pxa_ssp_set_dai_pll(struct snd_soc_dai *cpu_dai, int pll_id,
	int source, unsigned int freq_in, unsigned int freq_out)
M
Mark Brown 已提交
322
{
323
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
324
	struct ssp_device *ssp = priv->ssp;
H
Haojian Zhuang 已提交
325
	u32 ssacd = pxa_ssp_read_reg(ssp, SSACD) & ~0x70;
M
Mark Brown 已提交
326

327
	if (ssp->type == PXA3xx_SSP)
H
Haojian Zhuang 已提交
328
		pxa_ssp_write_reg(ssp, SSACDD, 0);
M
Mark Brown 已提交
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355

	switch (freq_out) {
	case 5622000:
		break;
	case 11345000:
		ssacd |= (0x1 << 4);
		break;
	case 12235000:
		ssacd |= (0x2 << 4);
		break;
	case 14857000:
		ssacd |= (0x3 << 4);
		break;
	case 32842000:
		ssacd |= (0x4 << 4);
		break;
	case 48000000:
		ssacd |= (0x5 << 4);
		break;
	case 0:
		/* Disable */
		break;

	default:
		/* PXA3xx has a clock ditherer which can be used to generate
		 * a wider range of frequencies - calculate a value for it.
		 */
356
		if (ssp->type == PXA3xx_SSP) {
M
Mark Brown 已提交
357 358 359 360 361 362
			u32 val;
			u64 tmp = 19968;
			tmp *= 1000000;
			do_div(tmp, freq_out);
			val = tmp;

363
			val = (val << 16) | 64;
H
Haojian Zhuang 已提交
364
			pxa_ssp_write_reg(ssp, SSACDD, val);
M
Mark Brown 已提交
365 366 367 368

			ssacd |= (0x6 << 4);

			dev_dbg(&ssp->pdev->dev,
369
				"Using SSACDD %x to supply %uHz\n",
M
Mark Brown 已提交
370 371 372 373 374 375 376
				val, freq_out);
			break;
		}

		return -EINVAL;
	}

H
Haojian Zhuang 已提交
377
	pxa_ssp_write_reg(ssp, SSACD, ssacd);
M
Mark Brown 已提交
378 379 380 381 382 383 384 385

	return 0;
}

/*
 * Set the active slots in TDM/Network mode
 */
static int pxa_ssp_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
386
	unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
M
Mark Brown 已提交
387
{
388
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
389
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
390 391
	u32 sscr0;

H
Haojian Zhuang 已提交
392
	sscr0 = pxa_ssp_read_reg(ssp, SSCR0);
393
	sscr0 &= ~(SSCR0_MOD | SSCR0_SlotsPerFrm(8) | SSCR0_EDSS | SSCR0_DSS);
M
Mark Brown 已提交
394

395 396 397 398 399 400 401 402 403 404 405 406 407 408
	/* set slot width */
	if (slot_width > 16)
		sscr0 |= SSCR0_EDSS | SSCR0_DataSize(slot_width - 16);
	else
		sscr0 |= SSCR0_DataSize(slot_width);

	if (slots > 1) {
		/* enable network mode */
		sscr0 |= SSCR0_MOD;

		/* set number of active slots */
		sscr0 |= SSCR0_SlotsPerFrm(slots);

		/* set active slot mask */
H
Haojian Zhuang 已提交
409 410
		pxa_ssp_write_reg(ssp, SSTSA, tx_mask);
		pxa_ssp_write_reg(ssp, SSRSA, rx_mask);
411
	}
H
Haojian Zhuang 已提交
412
	pxa_ssp_write_reg(ssp, SSCR0, sscr0);
M
Mark Brown 已提交
413 414 415 416 417 418 419 420 421 422

	return 0;
}

/*
 * Tristate the SSP DAI lines
 */
static int pxa_ssp_set_dai_tristate(struct snd_soc_dai *cpu_dai,
	int tristate)
{
423
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
424
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
425 426
	u32 sscr1;

H
Haojian Zhuang 已提交
427
	sscr1 = pxa_ssp_read_reg(ssp, SSCR1);
M
Mark Brown 已提交
428 429 430 431
	if (tristate)
		sscr1 &= ~SSCR1_TTE;
	else
		sscr1 |= SSCR1_TTE;
H
Haojian Zhuang 已提交
432
	pxa_ssp_write_reg(ssp, SSCR1, sscr1);
M
Mark Brown 已提交
433 434 435 436 437 438 439 440 441 442 443 444

	return 0;
}

/*
 * Set up the SSP DAI format.
 * The SSP Port must be inactive before calling this function as the
 * physical interface format is changed.
 */
static int pxa_ssp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
		unsigned int fmt)
{
445
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
446
	struct ssp_device *ssp = priv->ssp;
447
	u32 sscr0, sscr1, sspsp, scfr;
M
Mark Brown 已提交
448

449 450 451 452 453
	/* check if we need to change anything at all */
	if (priv->dai_fmt == fmt)
		return 0;

	/* we can only change the settings if the port is not in use */
H
Haojian Zhuang 已提交
454
	if (pxa_ssp_read_reg(ssp, SSCR0) & SSCR0_SSE) {
455 456 457 458 459
		dev_err(&ssp->pdev->dev,
			"can't change hardware dai format: stream is in use");
		return -EINVAL;
	}

M
Mark Brown 已提交
460
	/* reset port settings */
H
Haojian Zhuang 已提交
461
	sscr0 = pxa_ssp_read_reg(ssp, SSCR0) &
462
		~(SSCR0_ECS |  SSCR0_NCS | SSCR0_MOD | SSCR0_ACS);
M
Mark Brown 已提交
463 464 465 466 467
	sscr1 = SSCR1_RxTresh(8) | SSCR1_TxTresh(7);
	sspsp = 0;

	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	case SND_SOC_DAIFMT_CBM_CFM:
468
		sscr1 |= SSCR1_SCLKDIR | SSCR1_SFRMDIR | SSCR1_SCFR;
M
Mark Brown 已提交
469 470
		break;
	case SND_SOC_DAIFMT_CBM_CFS:
471
		sscr1 |= SSCR1_SCLKDIR | SSCR1_SCFR;
M
Mark Brown 已提交
472 473 474 475 476 477 478
		break;
	case SND_SOC_DAIFMT_CBS_CFS:
		break;
	default:
		return -EINVAL;
	}

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	case SND_SOC_DAIFMT_NB_NF:
		sspsp |= SSPSP_SFRMP;
		break;
	case SND_SOC_DAIFMT_NB_IF:
		break;
	case SND_SOC_DAIFMT_IB_IF:
		sspsp |= SSPSP_SCMODE(2);
		break;
	case SND_SOC_DAIFMT_IB_NF:
		sspsp |= SSPSP_SCMODE(2) | SSPSP_SFRMP;
		break;
	default:
		return -EINVAL;
	}
M
Mark Brown 已提交
494 495 496

	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
497
		sscr0 |= SSCR0_PSP;
M
Mark Brown 已提交
498
		sscr1 |= SSCR1_RWOT | SSCR1_TRAIL;
499
		/* See hw_params() */
M
Mark Brown 已提交
500 501 502 503 504 505 506 507 508 509 510 511 512
		break;

	case SND_SOC_DAIFMT_DSP_A:
		sspsp |= SSPSP_FSRT;
	case SND_SOC_DAIFMT_DSP_B:
		sscr0 |= SSCR0_MOD | SSCR0_PSP;
		sscr1 |= SSCR1_TRAIL | SSCR1_RWOT;
		break;

	default:
		return -EINVAL;
	}

H
Haojian Zhuang 已提交
513 514 515
	pxa_ssp_write_reg(ssp, SSCR0, sscr0);
	pxa_ssp_write_reg(ssp, SSCR1, sscr1);
	pxa_ssp_write_reg(ssp, SSPSP, sspsp);
M
Mark Brown 已提交
516

517 518 519 520 521 522 523 524 525 526 527
	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	case SND_SOC_DAIFMT_CBM_CFM:
	case SND_SOC_DAIFMT_CBM_CFS:
		scfr = pxa_ssp_read_reg(ssp, SSCR1) | SSCR1_SCFR;
		pxa_ssp_write_reg(ssp, SSCR1, scfr);

		while (pxa_ssp_read_reg(ssp, SSSR) & SSSR_BSY)
			cpu_relax();
		break;
	}

M
Mark Brown 已提交
528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
	dump_registers(ssp);

	/* Since we are configuring the timings for the format by hand
	 * we have to defer some things until hw_params() where we
	 * know parameters like the sample size.
	 */
	priv->dai_fmt = fmt;

	return 0;
}

/*
 * Set the SSP audio DMA parameters and sample size.
 * Can be called multiple times by oss emulation.
 */
static int pxa_ssp_hw_params(struct snd_pcm_substream *substream,
544
				struct snd_pcm_hw_params *params,
545
				struct snd_soc_dai *cpu_dai)
M
Mark Brown 已提交
546
{
547
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
548
	struct ssp_device *ssp = priv->ssp;
549
	int chn = params_channels(params);
M
Mark Brown 已提交
550 551 552
	u32 sscr0;
	u32 sspsp;
	int width = snd_pcm_format_physical_width(params_format(params));
H
Haojian Zhuang 已提交
553
	int ttsa = pxa_ssp_read_reg(ssp, SSTSA) & 0xf;
554
	struct snd_dmaengine_dai_dma_data *dma_data;
555

556
	dma_data = snd_soc_dai_get_dma_data(cpu_dai, substream);
M
Mark Brown 已提交
557

558 559 560 561
	/* Network mode with one active slot (ttsa == 1) can be used
	 * to force 16-bit frame width on the wire (for S16_LE), even
	 * with two channels. Use 16-bit DMA transfers for this case.
	 */
562 563 564
	pxa_ssp_set_dma_params(ssp,
		((chn == 2) && (ttsa != 1)) || (width == 32),
		substream->stream == SNDRV_PCM_STREAM_PLAYBACK, dma_data);
565

M
Mark Brown 已提交
566
	/* we can only change the settings if the port is not in use */
H
Haojian Zhuang 已提交
567
	if (pxa_ssp_read_reg(ssp, SSCR0) & SSCR0_SSE)
M
Mark Brown 已提交
568 569 570
		return 0;

	/* clear selected SSP bits */
H
Haojian Zhuang 已提交
571
	sscr0 = pxa_ssp_read_reg(ssp, SSCR0) & ~(SSCR0_DSS | SSCR0_EDSS);
M
Mark Brown 已提交
572 573 574 575

	/* bit size */
	switch (params_format(params)) {
	case SNDRV_PCM_FORMAT_S16_LE:
576
		if (ssp->type == PXA3xx_SSP)
M
Mark Brown 已提交
577 578 579 580 581 582 583 584 585 586
			sscr0 |= SSCR0_FPCKE;
		sscr0 |= SSCR0_DataSize(16);
		break;
	case SNDRV_PCM_FORMAT_S24_LE:
		sscr0 |= (SSCR0_EDSS | SSCR0_DataSize(8));
		break;
	case SNDRV_PCM_FORMAT_S32_LE:
		sscr0 |= (SSCR0_EDSS | SSCR0_DataSize(16));
		break;
	}
H
Haojian Zhuang 已提交
587
	pxa_ssp_write_reg(ssp, SSCR0, sscr0);
M
Mark Brown 已提交
588 589 590

	switch (priv->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
H
Haojian Zhuang 已提交
591
	       sspsp = pxa_ssp_read_reg(ssp, SSPSP);
592

H
Haojian Zhuang 已提交
593
		if ((pxa_ssp_get_scr(ssp) == 4) && (width == 16)) {
594 595 596 597 598 599 600 601
			/* This is a special case where the bitclk is 64fs
			* and we're not dealing with 2*32 bits of audio
			* samples.
			*
			* The SSP values used for that are all found out by
			* trying and failing a lot; some of the registers
			* needed for that mode are only available on PXA3xx.
			*/
602
			if (ssp->type != PXA3xx_SSP)
603 604 605 606 607 608 609
				return -EINVAL;

			sspsp |= SSPSP_SFRMWDTH(width * 2);
			sspsp |= SSPSP_SFRMDLY(width * 4);
			sspsp |= SSPSP_EDMYSTOP(3);
			sspsp |= SSPSP_DMYSTOP(3);
			sspsp |= SSPSP_DMYSTRT(1);
610 611 612 613 614 615 616 617 618 619 620
		} else {
			/* The frame width is the width the LRCLK is
			 * asserted for; the delay is expressed in
			 * half cycle units.  We need the extra cycle
			 * because the data starts clocking out one BCLK
			 * after LRCLK changes polarity.
			 */
			sspsp |= SSPSP_SFRMWDTH(width + 1);
			sspsp |= SSPSP_SFRMDLY((width + 1) * 2);
			sspsp |= SSPSP_DMYSTRT(1);
		}
621

H
Haojian Zhuang 已提交
622
		pxa_ssp_write_reg(ssp, SSPSP, sspsp);
M
Mark Brown 已提交
623 624 625 626 627
		break;
	default:
		break;
	}

628
	/* When we use a network mode, we always require TDM slots
M
Mark Brown 已提交
629 630
	 * - complain loudly and fail if they've not been set up yet.
	 */
631
	if ((sscr0 & SSCR0_MOD) && !ttsa) {
M
Mark Brown 已提交
632 633 634 635 636 637 638 639 640
		dev_err(&ssp->pdev->dev, "No TDM timeslot configured\n");
		return -EINVAL;
	}

	dump_registers(ssp);

	return 0;
}

641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
static void pxa_ssp_set_running_bit(struct snd_pcm_substream *substream,
				    struct ssp_device *ssp, int value)
{
	uint32_t sscr0 = pxa_ssp_read_reg(ssp, SSCR0);
	uint32_t sscr1 = pxa_ssp_read_reg(ssp, SSCR1);
	uint32_t sspsp = pxa_ssp_read_reg(ssp, SSPSP);
	uint32_t sssr = pxa_ssp_read_reg(ssp, SSSR);

	if (value && (sscr0 & SSCR0_SSE))
		pxa_ssp_write_reg(ssp, SSCR0, sscr0 & ~SSCR0_SSE);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		if (value)
			sscr1 |= SSCR1_TSRE;
		else
			sscr1 &= ~SSCR1_TSRE;
	} else {
		if (value)
			sscr1 |= SSCR1_RSRE;
		else
			sscr1 &= ~SSCR1_RSRE;
	}

	pxa_ssp_write_reg(ssp, SSCR1, sscr1);

	if (value) {
		pxa_ssp_write_reg(ssp, SSSR, sssr);
		pxa_ssp_write_reg(ssp, SSPSP, sspsp);
		pxa_ssp_write_reg(ssp, SSCR0, sscr0 | SSCR0_SSE);
	}
}

673
static int pxa_ssp_trigger(struct snd_pcm_substream *substream, int cmd,
674
			   struct snd_soc_dai *cpu_dai)
M
Mark Brown 已提交
675 676
{
	int ret = 0;
677
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai);
678
	struct ssp_device *ssp = priv->ssp;
M
Mark Brown 已提交
679 680 681 682
	int val;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_RESUME:
H
Haojian Zhuang 已提交
683
		pxa_ssp_enable(ssp);
M
Mark Brown 已提交
684 685
		break;
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
686
		pxa_ssp_set_running_bit(substream, ssp, 1);
H
Haojian Zhuang 已提交
687 688
		val = pxa_ssp_read_reg(ssp, SSSR);
		pxa_ssp_write_reg(ssp, SSSR, val);
M
Mark Brown 已提交
689 690
		break;
	case SNDRV_PCM_TRIGGER_START:
691
		pxa_ssp_set_running_bit(substream, ssp, 1);
M
Mark Brown 已提交
692 693
		break;
	case SNDRV_PCM_TRIGGER_STOP:
694
		pxa_ssp_set_running_bit(substream, ssp, 0);
M
Mark Brown 已提交
695 696
		break;
	case SNDRV_PCM_TRIGGER_SUSPEND:
H
Haojian Zhuang 已提交
697
		pxa_ssp_disable(ssp);
M
Mark Brown 已提交
698 699
		break;
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
700
		pxa_ssp_set_running_bit(substream, ssp, 0);
M
Mark Brown 已提交
701 702 703 704 705 706 707 708 709 710 711
		break;

	default:
		ret = -EINVAL;
	}

	dump_registers(ssp);

	return ret;
}

712
static int pxa_ssp_probe(struct snd_soc_dai *dai)
M
Mark Brown 已提交
713
{
714
	struct device *dev = dai->dev;
M
Mark Brown 已提交
715 716 717 718 719 720 721
	struct ssp_priv *priv;
	int ret;

	priv = kzalloc(sizeof(struct ssp_priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
	if (dev->of_node) {
		struct device_node *ssp_handle;

		ssp_handle = of_parse_phandle(dev->of_node, "port", 0);
		if (!ssp_handle) {
			dev_err(dev, "unable to get 'port' phandle\n");
			return -ENODEV;
		}

		priv->ssp = pxa_ssp_request_of(ssp_handle, "SoC audio");
		if (priv->ssp == NULL) {
			ret = -ENODEV;
			goto err_priv;
		}
	} else {
		priv->ssp = pxa_ssp_request(dai->id + 1, "SoC audio");
		if (priv->ssp == NULL) {
			ret = -ENODEV;
			goto err_priv;
		}
M
Mark Brown 已提交
742 743
	}

744
	priv->dai_fmt = (unsigned int) -1;
745
	snd_soc_dai_set_drvdata(dai, priv);
M
Mark Brown 已提交
746 747 748 749 750 751 752 753

	return 0;

err_priv:
	kfree(priv);
	return ret;
}

754
static int pxa_ssp_remove(struct snd_soc_dai *dai)
M
Mark Brown 已提交
755
{
756 757
	struct ssp_priv *priv = snd_soc_dai_get_drvdata(dai);

H
Haojian Zhuang 已提交
758
	pxa_ssp_free(priv->ssp);
759
	kfree(priv);
760
	return 0;
M
Mark Brown 已提交
761 762 763 764
}

#define PXA_SSP_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
			  SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |	\
765 766
			  SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |	\
			  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |	\
M
Mark Brown 已提交
767 768 769 770 771 772
			  SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)

#define PXA_SSP_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
			    SNDRV_PCM_FMTBIT_S24_LE |	\
			    SNDRV_PCM_FMTBIT_S32_LE)

773
static const struct snd_soc_dai_ops pxa_ssp_dai_ops = {
774 775 776 777 778 779 780 781 782 783 784 785
	.startup	= pxa_ssp_startup,
	.shutdown	= pxa_ssp_shutdown,
	.trigger	= pxa_ssp_trigger,
	.hw_params	= pxa_ssp_hw_params,
	.set_sysclk	= pxa_ssp_set_dai_sysclk,
	.set_clkdiv	= pxa_ssp_set_dai_clkdiv,
	.set_pll	= pxa_ssp_set_dai_pll,
	.set_fmt	= pxa_ssp_set_dai_fmt,
	.set_tdm_slot	= pxa_ssp_set_dai_tdm_slot,
	.set_tristate	= pxa_ssp_set_dai_tristate,
};

786
static struct snd_soc_dai_driver pxa_ssp_dai = {
M
Mark Brown 已提交
787 788 789 790 791 792
		.probe = pxa_ssp_probe,
		.remove = pxa_ssp_remove,
		.suspend = pxa_ssp_suspend,
		.resume = pxa_ssp_resume,
		.playback = {
			.channels_min = 1,
793
			.channels_max = 8,
M
Mark Brown 已提交
794 795 796 797 798
			.rates = PXA_SSP_RATES,
			.formats = PXA_SSP_FORMATS,
		},
		.capture = {
			 .channels_min = 1,
799
			 .channels_max = 8,
M
Mark Brown 已提交
800 801 802
			.rates = PXA_SSP_RATES,
			.formats = PXA_SSP_FORMATS,
		 },
803
		.ops = &pxa_ssp_dai_ops,
804 805
};

806 807 808 809
static const struct snd_soc_component_driver pxa_ssp_component = {
	.name		= "pxa-ssp",
};

810 811 812 813 814 815
#ifdef CONFIG_OF
static const struct of_device_id pxa_ssp_of_ids[] = {
	{ .compatible = "mrvl,pxa-ssp-dai" },
};
#endif

816
static int asoc_ssp_probe(struct platform_device *pdev)
817
{
818 819
	return snd_soc_register_component(&pdev->dev, &pxa_ssp_component,
					  &pxa_ssp_dai, 1);
820 821
}

822
static int asoc_ssp_remove(struct platform_device *pdev)
823
{
824
	snd_soc_unregister_component(&pdev->dev);
825 826 827 828 829
	return 0;
}

static struct platform_driver asoc_ssp_driver = {
	.driver = {
830 831 832
		.name = "pxa-ssp-dai",
		.owner = THIS_MODULE,
		.of_match_table = of_match_ptr(pxa_ssp_of_ids),
M
Mark Brown 已提交
833
	},
834 835

	.probe = asoc_ssp_probe,
836
	.remove = asoc_ssp_remove,
M
Mark Brown 已提交
837 838
};

839
module_platform_driver(asoc_ssp_driver);
M
Mark Brown 已提交
840

M
Mark Brown 已提交
841 842 843 844
/* Module information */
MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
MODULE_DESCRIPTION("PXA SSP/PCM SoC Interface");
MODULE_LICENSE("GPL");