src.c 22.2 KB
Newer Older
1
/*
2
 * Renesas R-Car SRC support
3 4 5 6 7 8 9 10 11 12
 *
 * Copyright (C) 2013 Renesas Solutions Corp.
 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include "rsnd.h"

13 14
#define SRC_NAME "src"

15 16 17 18 19 20 21
/* SRCx_STATUS */
#define OUF_SRCO	((1 << 12) | (1 << 13))
#define OUF_SRCI	((1 <<  9) | (1 <<  8))

/* SCU_SYSTEM_STATUS0/1 */
#define OUF_SRC(id)	((1 << (id + 16)) | (1 << id))

22 23
struct rsnd_src {
	struct rsnd_src_platform_info *info; /* rcar_snd.h */
24
	struct rsnd_mod mod;
25 26
	struct rsnd_kctrl_cfg_s sen;  /* sync convert enable */
	struct rsnd_kctrl_cfg_s sync; /* sync convert */
27
	u32 convert_rate; /* sampling rate convert */
28
	int err;
29 30
};

31
#define RSND_SRC_NAME_SIZE 16
32

33
#define rsnd_enable_sync_convert(src) ((src)->sen.val)
34 35 36
#define rsnd_src_of_node(priv) \
	of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,src")

37 38
#define rsnd_mod_to_src(_mod)				\
	container_of((_mod), struct rsnd_src, mod)
39

40
#define for_each_rsnd_src(pos, priv, i)				\
41
	for ((i) = 0;						\
42 43
	     ((i) < rsnd_src_nr(priv)) &&			\
	     ((pos) = (struct rsnd_src *)(priv)->src + i);	\
44 45 46
	     i++)


47 48 49 50 51 52 53 54 55
/*
 *		image of SRC (Sampling Rate Converter)
 *
 * 96kHz   <-> +-----+	48kHz	+-----+	 48kHz	+-------+
 * 48kHz   <-> | SRC | <------>	| SSI |	<----->	| codec |
 * 44.1kHz <-> +-----+		+-----+		+-------+
 * ...
 *
 */
56

57
/*
58
 * src.c is caring...
59 60 61 62 63 64 65 66
 *
 * Gen1
 *
 * [mem] -> [SRU] -> [SSI]
 *        |--------|
 *
 * Gen2
 *
67
 * [mem] -> [SRC] -> [SSIU] -> [SSI]
68 69 70
 *        |-----------------|
 */

71 72 73 74 75 76 77 78 79 80 81 82
/*
 *	How to use SRC bypass mode for debugging
 *
 * SRC has bypass mode, and it is useful for debugging.
 * In Gen2 case,
 * SRCm_MODE controls whether SRC is used or not
 * SSI_MODE0 controls whether SSIU which receives SRC data
 * is used or not.
 * Both SRCm_MODE/SSI_MODE0 settings are needed if you use SRC,
 * but SRC bypass mode needs SSI_MODE0 only.
 *
 * This driver request
83
 * struct rsnd_src_platform_info {
84
 *	u32 convert_rate;
85
 *	int dma_id;
86 87
 * }
 *
88
 * rsnd_src_convert_rate() indicates
89 90 91 92
 * above convert_rate, and it controls
 * whether SRC is used or not.
 *
 * ex) doesn't use SRC
93 94
 * static struct rsnd_dai_platform_info rsnd_dai = {
 *	.playback = { .ssi = &rsnd_ssi[0], },
95 96 97
 * };
 *
 * ex) uses SRC
98 99 100 101 102 103
 * static struct rsnd_src_platform_info rsnd_src[] = {
 *	RSND_SCU(48000, 0),
 *	...
 * };
 * static struct rsnd_dai_platform_info rsnd_dai = {
 *	.playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] },
104 105 106
 * };
 *
 * ex) uses SRC bypass mode
107 108 109 110 111 112
 * static struct rsnd_src_platform_info rsnd_src[] = {
 *	RSND_SCU(0, 0),
 *	...
 * };
 * static struct rsnd_dai_platform_info rsnd_dai = {
 *	.playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] },
113 114 115 116
 * };
 *
 */

117 118 119
/*
 *		Gen1/Gen2 common functions
 */
120 121 122 123 124 125 126 127 128 129 130
static struct dma_chan *rsnd_src_dma_req(struct rsnd_mod *mod)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
	int is_play = rsnd_io_is_play(io);

	return rsnd_dma_request_channel(rsnd_src_of_node(priv),
					mod,
					is_play ? "rx" : "tx");
}

131 132
int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
			int use_busif)
133
{
134
	struct rsnd_dai_stream *io = rsnd_mod_to_io(ssi_mod);
135
	struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
136
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
137
	int ssi_id = rsnd_mod_id(ssi_mod);
138 139 140 141

	/*
	 * SSI_MODE0
	 */
142
	rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id),
143
		      !use_busif << ssi_id);
144 145 146 147

	/*
	 * SSI_MODE1
	 */
148
	if (rsnd_ssi_is_pin_sharing(ssi_mod)) {
149
		int shift = -1;
150
		switch (ssi_id) {
151 152 153 154 155 156 157 158 159 160 161 162
		case 1:
			shift = 0;
			break;
		case 2:
			shift = 2;
			break;
		case 4:
			shift = 16;
			break;
		}

		if (shift >= 0)
163
			rsnd_mod_bset(ssi_mod, SSI_MODE1,
164
				      0x3 << shift,
165
				      rsnd_rdai_is_clk_master(rdai) ?
166 167 168
				      0x2 << shift : 0x1 << shift);
	}

169 170 171 172
	/*
	 * DMA settings for SSIU
	 */
	if (use_busif) {
173 174 175
		u32 val = 0x76543210;
		u32 mask = ~0;

176 177 178 179
		rsnd_mod_write(ssi_mod, SSI_BUSIF_ADINR,
			       rsnd_get_adinr(ssi_mod));
		rsnd_mod_write(ssi_mod, SSI_BUSIF_MODE,  1);
		rsnd_mod_write(ssi_mod, SSI_CTRL, 0x1);
180 181 182 183 184 185 186 187 188 189 190 191 192 193

		mask <<= runtime->channels * 4;
		val = val & mask;

		switch (runtime->sample_bits) {
		case 16:
			val |= 0x67452301 & ~mask;
			break;
		case 32:
			val |= 0x76543210 & ~mask;
			break;
		}
		rsnd_mod_write(ssi_mod, BUSIF_DALIGN, val);

194 195 196 197 198
	}

	return 0;
}

199
int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod)
200 201 202 203
{
	/*
	 * DMA settings for SSIU
	 */
204
	rsnd_mod_write(ssi_mod, SSI_CTRL, 0);
205

206 207 208
	return 0;
}

209
int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod)
210 211 212
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);

213 214 215 216 217 218 219
	if (rsnd_is_gen1(priv))
		return 0;

	/* enable SSI interrupt if Gen2 */
	if (rsnd_ssi_is_dma_mode(ssi_mod))
		rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0e000000);
	else
220 221 222 223 224
		rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);

	return 0;
}

225
int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod)
226 227 228 229 230 231 232 233 234 235 236 237
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);

	if (rsnd_is_gen1(priv))
		return 0;

	/* disable SSI interrupt if Gen2 */
	rsnd_mod_write(ssi_mod, INT_ENABLE, 0x00000000);

	return 0;
}

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
static u32 rsnd_src_convert_rate(struct rsnd_src *src)
{
	struct rsnd_mod *mod = &src->mod;
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	u32 convert_rate;

	if (!runtime)
		return 0;

	if (!rsnd_enable_sync_convert(src))
		return src->convert_rate;

	convert_rate = src->sync.val;

	if (!convert_rate)
		convert_rate = src->convert_rate;

	if (!convert_rate)
		convert_rate = runtime->rate;

	return convert_rate;
}

262
unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
263
				   struct rsnd_dai_stream *io,
264 265
				   struct snd_pcm_runtime *runtime)
{
266
	struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
267
	struct rsnd_src *src;
268
	unsigned int rate = 0;
269

270 271 272 273 274 275 276 277 278
	if (src_mod) {
		src = rsnd_mod_to_src(src_mod);

		/*
		 * return convert rate if SRC is used,
		 * otherwise, return runtime->rate as usual
		 */
		rate = rsnd_src_convert_rate(src);
	}
279 280 281 282 283 284 285

	if (!rate)
		rate = runtime->rate;

	return rate;
}

286
static int rsnd_src_set_convert_rate(struct rsnd_mod *mod)
287
{
288
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
289
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
290 291
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	u32 convert_rate = rsnd_src_convert_rate(src);
292 293 294 295 296 297 298 299 300 301
	u32 fsrate = 0;

	if (convert_rate)
		fsrate = 0x0400000 / convert_rate * runtime->rate;

	/* set/clear soft reset */
	rsnd_mod_write(mod, SRC_SWRSR, 0);
	rsnd_mod_write(mod, SRC_SWRSR, 1);

	/* Set channel number and output bit length */
302
	rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod));
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317

	/* Enable the initial value of IFS */
	if (fsrate) {
		rsnd_mod_write(mod, SRC_IFSCR, 1);

		/* Set initial value of IFS */
		rsnd_mod_write(mod, SRC_IFSVR, fsrate);
	}

	/* use DMA transfer */
	rsnd_mod_write(mod, SRC_BUSIF_MODE, 1);

	return 0;
}

318 319 320 321 322 323 324 325 326 327 328 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
static int rsnd_src_hw_params(struct rsnd_mod *mod,
			      struct snd_pcm_substream *substream,
			      struct snd_pcm_hw_params *fe_params)
{
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	struct snd_soc_pcm_runtime *fe = substream->private_data;

	/* default value (mainly for non-DT) */
	src->convert_rate = src->info->convert_rate;

	/*
	 * SRC assumes that it is used under DPCM if user want to use
	 * sampling rate convert. Then, SRC should be FE.
	 * And then, this function will be called *after* BE settings.
	 * this means, each BE already has fixuped hw_params.
	 * see
	 *	dpcm_fe_dai_hw_params()
	 *	dpcm_be_dai_hw_params()
	 */
	if (fe->dai_link->dynamic) {
		int stream = substream->stream;
		struct snd_soc_dpcm *dpcm;
		struct snd_pcm_hw_params *be_params;

		list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) {
			be_params = &dpcm->hw_params;

			if (params_rate(fe_params) != params_rate(be_params))
				src->convert_rate = params_rate(be_params);
		}
	}

	return 0;
}

static int rsnd_src_init(struct rsnd_mod *mod,
			 struct rsnd_priv *priv)
355
{
356
	struct rsnd_src *src = rsnd_mod_to_src(mod);
357

358
	rsnd_mod_hw_start(mod);
359

360 361
	src->err = 0;

362 363 364
	/* reset sync convert_rate */
	src->sync.val = 0;

365 366 367 368 369 370
	/*
	 * Initialize the operation of the SRC internal circuits
	 * see rsnd_src_start()
	 */
	rsnd_mod_write(mod, SRC_SRCIR, 1);

371 372 373
	return 0;
}

374
static int rsnd_src_quit(struct rsnd_mod *mod,
375
			 struct rsnd_priv *priv)
376
{
377
	struct rsnd_src *src = rsnd_mod_to_src(mod);
378
	struct device *dev = rsnd_priv_to_dev(priv);
379

380
	rsnd_mod_hw_stop(mod);
381

382
	if (src->err)
383 384
		dev_warn(dev, "%s[%d] under/over flow err = %d\n",
			 rsnd_mod_name(mod), rsnd_mod_id(mod), src->err);
385

386 387
	src->convert_rate = 0;

388 389 390
	/* reset sync convert_rate */
	src->sync.val = 0;

391 392 393
	return 0;
}

394
static int rsnd_src_start(struct rsnd_mod *mod)
395 396 397
{
	/*
	 * Cancel the initialization and operate the SRC function
398
	 * see rsnd_src_init()
399 400 401 402 403 404
	 */
	rsnd_mod_write(mod, SRC_SRCIR, 0);

	return 0;
}

405
static int rsnd_src_stop(struct rsnd_mod *mod)
406
{
407
	/* nothing to do */
408 409 410 411 412 413
	return 0;
}

/*
 *		Gen1 functions
 */
414
static int rsnd_src_set_route_gen1(struct rsnd_mod *mod)
415
{
416
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
417
	struct src_route_config {
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
		u32 mask;
		int shift;
	} routes[] = {
		{ 0xF,  0, }, /* 0 */
		{ 0xF,  4, }, /* 1 */
		{ 0xF,  8, }, /* 2 */
		{ 0x7, 12, }, /* 3 */
		{ 0x7, 16, }, /* 4 */
		{ 0x7, 20, }, /* 5 */
		{ 0x7, 24, }, /* 6 */
		{ 0x3, 28, }, /* 7 */
		{ 0x3, 30, }, /* 8 */
	};
	u32 mask;
	u32 val;
	int id;

	id = rsnd_mod_id(mod);
436
	if (id < 0 || id >= ARRAY_SIZE(routes))
437 438 439 440 441
		return -EIO;

	/*
	 * SRC_ROUTE_SELECT
	 */
442
	val = rsnd_io_is_play(io) ? 0x1 : 0x2;
443 444 445 446 447
	val = val		<< routes[id].shift;
	mask = routes[id].mask	<< routes[id].shift;

	rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);

448 449 450
	return 0;
}

451
static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod)
452
{
453
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
454
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
455
	struct rsnd_src *src = rsnd_mod_to_src(mod);
456
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
457
	u32 convert_rate = rsnd_src_convert_rate(src);
458 459 460 461 462 463
	u32 mask;
	u32 val;
	int shift;
	int id = rsnd_mod_id(mod);
	int ret;

464 465 466 467 468
	/*
	 * SRC_TIMING_SELECT
	 */
	shift	= (id % 4) * 8;
	mask	= 0x1F << shift;
469 470 471 472 473 474 475

	/*
	 * ADG is used as source clock if SRC was used,
	 * then, SSI WS is used as destination clock.
	 * SSI WS is used as source clock if SRC is not used
	 * (when playback, source/destination become reverse when capture)
	 */
476 477 478
	ret = 0;
	if (convert_rate) {
		/* use ADG */
479
		val = 0;
480 481 482 483 484
		ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
						    runtime->rate,
						    convert_rate);
	} else if (8 == id) {
		/* use SSI WS, but SRU8 is special */
485
		val = id << shift;
486 487
	} else {
		/* use SSI WS */
488
		val = (id + 1) << shift;
489 490 491 492
	}

	if (ret < 0)
		return ret;
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508

	switch (id / 4) {
	case 0:
		rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val);
		break;
	case 1:
		rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val);
		break;
	case 2:
		rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val);
		break;
	}

	return 0;
}

509
static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod)
510
{
511
	struct rsnd_src *src = rsnd_mod_to_src(mod);
512
	int ret;
513

514
	ret = rsnd_src_set_convert_rate(mod);
515 516
	if (ret < 0)
		return ret;
517

518 519
	/* Select SRC mode (fixed value) */
	rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
520

521 522 523
	/* Set the restriction value of the FS ratio (98%) */
	rsnd_mod_write(mod, SRC_MNFSR,
		       rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
524

525 526 527 528
	/* Gen1/Gen2 are not compatible */
	if (rsnd_src_convert_rate(src))
		rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);

529
	/* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
530

531 532 533
	return 0;
}

534
static int rsnd_src_init_gen1(struct rsnd_mod *mod,
535
			      struct rsnd_priv *priv)
536
{
537 538
	int ret;

539
	ret = rsnd_src_init(mod, priv);
540 541 542
	if (ret < 0)
		return ret;

543
	ret = rsnd_src_set_route_gen1(mod);
544 545 546
	if (ret < 0)
		return ret;

547
	ret = rsnd_src_set_convert_rate_gen1(mod);
548 549
	if (ret < 0)
		return ret;
550

551
	ret = rsnd_src_set_convert_timing_gen1(mod);
552 553 554
	if (ret < 0)
		return ret;

555 556 557
	return 0;
}

558
static int rsnd_src_start_gen1(struct rsnd_mod *mod,
559
			       struct rsnd_priv *priv)
560
{
561
	int id = rsnd_mod_id(mod);
562

563
	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
564

565
	return rsnd_src_start(mod);
566 567
}

568
static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
569
			      struct rsnd_priv *priv)
570
{
571
	int id = rsnd_mod_id(mod);
572

573
	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
574

575
	return rsnd_src_stop(mod);
576 577
}

578
static struct rsnd_mod_ops rsnd_src_gen1_ops = {
579
	.name	= SRC_NAME,
580
	.dma_req = rsnd_src_dma_req,
581 582 583 584
	.init	= rsnd_src_init_gen1,
	.quit	= rsnd_src_quit,
	.start	= rsnd_src_start_gen1,
	.stop	= rsnd_src_stop_gen1,
585
	.hw_params = rsnd_src_hw_params,
586
};
587

588 589 590
/*
 *		Gen2 functions
 */
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 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 673 674 675
#define rsnd_src_irq_enable_gen2(mod)  rsnd_src_irq_ctrol_gen2(mod, 1)
#define rsnd_src_irq_disable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 0)
static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable)
{
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	u32 sys_int_val, int_val, sys_int_mask;
	int irq = src->info->irq;
	int id = rsnd_mod_id(mod);

	sys_int_val =
	sys_int_mask = OUF_SRC(id);
	int_val = 0x3300;

	/*
	 * IRQ is not supported on non-DT
	 * see
	 *	rsnd_src_probe_gen2()
	 */
	if ((irq <= 0) || !enable) {
		sys_int_val = 0;
		int_val = 0;
	}

	rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val);
	rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val);
	rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);
}

static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod)
{
	u32 val = OUF_SRC(rsnd_mod_id(mod));

	rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val);
	rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val);
}

static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod)
{
	u32 val = OUF_SRC(rsnd_mod_id(mod));
	bool ret = false;

	if ((rsnd_mod_read(mod, SCU_SYS_STATUS0) & val) ||
	    (rsnd_mod_read(mod, SCU_SYS_STATUS1) & val)) {
		struct rsnd_src *src = rsnd_mod_to_src(mod);

		src->err++;
		ret = true;
	}

	/* clear error static */
	rsnd_src_error_clear_gen2(mod);

	return ret;
}

static int _rsnd_src_start_gen2(struct rsnd_mod *mod)
{
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
	u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11;

	rsnd_mod_write(mod, SRC_CTRL, val);

	rsnd_src_error_clear_gen2(mod);

	rsnd_src_start(mod);

	rsnd_src_irq_enable_gen2(mod);

	return 0;
}

static int _rsnd_src_stop_gen2(struct rsnd_mod *mod)
{
	rsnd_src_irq_disable_gen2(mod);

	rsnd_mod_write(mod, SRC_CTRL, 0);

	rsnd_src_error_record_gen2(mod);

	return rsnd_src_stop(mod);
}

static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data)
{
	struct rsnd_mod *mod = data;
676 677 678
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);

	spin_lock(&priv->lock);
679

680 681 682
	/* ignore all cases if not working */
	if (!rsnd_mod_is_working(mod))
		goto rsnd_src_interrupt_gen2_out;
683 684 685

	if (rsnd_src_error_record_gen2(mod)) {
		struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
686
		struct rsnd_src *src = rsnd_mod_to_src(mod);
687 688 689 690
		struct device *dev = rsnd_priv_to_dev(priv);

		dev_dbg(dev, "%s[%d] restart\n",
			rsnd_mod_name(mod), rsnd_mod_id(mod));
691 692 693 694 695 696

		_rsnd_src_stop_gen2(mod);
		if (src->err < 1024)
			_rsnd_src_start_gen2(mod);
		else
			dev_warn(dev, "no more SRC restart\n");
697
	}
698 699
rsnd_src_interrupt_gen2_out:
	spin_unlock(&priv->lock);
700 701 702 703

	return IRQ_HANDLED;
}

704
static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod)
705
{
706 707 708 709 710
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	struct rsnd_src *src = rsnd_mod_to_src(mod);
711
	u32 convert_rate = rsnd_src_convert_rate(src);
712
	u32 cr, route;
713
	uint ratio;
714 715
	int ret;

716
	/* 6 - 1/6 are very enough ratio for SRC_BSDSR */
717
	if (!convert_rate)
718
		ratio = 0;
719 720
	else if (convert_rate > runtime->rate)
		ratio = 100 * convert_rate / runtime->rate;
721
	else
722
		ratio = 100 * runtime->rate / convert_rate;
723 724 725 726 727 728

	if (ratio > 600) {
		dev_err(dev, "FSO/FSI ratio error\n");
		return -EINVAL;
	}

729
	ret = rsnd_src_set_convert_rate(mod);
730 731 732
	if (ret < 0)
		return ret;

733 734
	cr	= 0x00011110;
	route	= 0x0;
735
	if (convert_rate) {
736 737 738 739 740 741 742
		route	= 0x1;

		if (rsnd_enable_sync_convert(src)) {
			cr |= 0x1;
			route |= rsnd_io_is_play(io) ?
				(0x1 << 24) : (0x1 << 25);
		}
743 744
	}

745 746 747
	rsnd_mod_write(mod, SRC_SRCCR, cr);
	rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);

748 749 750 751 752 753 754 755 756 757 758 759
	switch (rsnd_mod_id(mod)) {
	case 5:
	case 6:
	case 7:
	case 8:
		rsnd_mod_write(mod, SRC_BSDSR, 0x02400000);
		break;
	default:
		rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
		break;
	}

760 761 762 763 764
	rsnd_mod_write(mod, SRC_BSISR, 0x00100060);

	return 0;
}

765
static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod)
766
{
767
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
768
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
769 770
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	u32 convert_rate = rsnd_src_convert_rate(src);
771 772 773
	int ret;

	if (convert_rate)
774
		ret = rsnd_adg_set_convert_clk_gen2(mod, io,
775 776 777
						    runtime->rate,
						    convert_rate);
	else
778
		ret = rsnd_adg_set_convert_timing_gen2(mod, io);
779 780 781 782

	return ret;
}

783
static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
784
			       struct rsnd_priv *priv)
785
{
786
	struct rsnd_src *src = rsnd_mod_to_src(mod);
787
	struct device *dev = rsnd_priv_to_dev(priv);
788
	int irq = src->info->irq;
789 790
	int ret;

791 792 793 794 795 796 797 798 799 800 801
	if (irq > 0) {
		/*
		 * IRQ is not supported on non-DT
		 * see
		 *	rsnd_src_irq_enable_gen2()
		 */
		ret = devm_request_irq(dev, irq,
				       rsnd_src_interrupt_gen2,
				       IRQF_SHARED,
				       dev_name(dev), mod);
		if (ret)
802
			return ret;
803 804
	}

805 806
	ret = rsnd_dma_init(priv,
			    rsnd_mod_to_dma(mod),
807
			    src->info->dma_id);
808

809 810 811
	return ret;
}

812
static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
813
				struct rsnd_priv *priv)
814
{
815
	rsnd_dma_quit(rsnd_mod_to_dma(mod));
816 817 818 819

	return 0;
}

820
static int rsnd_src_init_gen2(struct rsnd_mod *mod,
821
			      struct rsnd_priv *priv)
822 823 824
{
	int ret;

825
	ret = rsnd_src_init(mod, priv);
826 827 828
	if (ret < 0)
		return ret;

829
	ret = rsnd_src_set_convert_rate_gen2(mod);
830 831 832
	if (ret < 0)
		return ret;

833
	ret = rsnd_src_set_convert_timing_gen2(mod);
834 835 836 837 838 839
	if (ret < 0)
		return ret;

	return 0;
}

840
static int rsnd_src_start_gen2(struct rsnd_mod *mod,
841
			       struct rsnd_priv *priv)
842
{
843
	rsnd_dma_start(rsnd_mod_to_dma(mod));
844

845
	return _rsnd_src_start_gen2(mod);
846 847
}

848
static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
849
			      struct rsnd_priv *priv)
850
{
851
	int ret;
852

853
	ret = _rsnd_src_stop_gen2(mod);
854

855
	rsnd_dma_stop(rsnd_mod_to_dma(mod));
856

857
	return ret;
858 859
}

860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
static void rsnd_src_reconvert_update(struct rsnd_mod *mod)
{
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	u32 convert_rate = rsnd_src_convert_rate(src);
	u32 fsrate;

	if (!runtime)
		return;

	if (!convert_rate)
		convert_rate = runtime->rate;

	fsrate = 0x0400000 / convert_rate * runtime->rate;

	/* update IFS */
	rsnd_mod_write(mod, SRC_IFSVR, fsrate);
}

static int rsnd_src_pcm_new(struct rsnd_mod *mod,
			    struct snd_soc_pcm_runtime *rtd)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
	struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	int ret;

	/*
	 * enable SRC sync convert if possible
	 */

	/*
	 * Gen1 is not supported
	 */
	if (rsnd_is_gen1(priv))
		return 0;

	/*
	 * SRC sync convert needs clock master
	 */
	if (!rsnd_rdai_is_clk_master(rdai))
		return 0;

	/*
	 * We can't use SRC sync convert
	 * if it has DVC
	 */
	if (rsnd_io_to_mod_dvc(io))
		return 0;

	/*
	 * enable sync convert
	 */
	ret = rsnd_kctrl_new_s(mod, rtd,
			       rsnd_io_is_play(io) ?
			       "SRC Out Rate Switch" :
			       "SRC In Rate Switch",
			       rsnd_src_reconvert_update,
			       &src->sen, 1);
	if (ret < 0)
		return ret;

	ret = rsnd_kctrl_new_s(mod, rtd,
			       rsnd_io_is_play(io) ?
			       "SRC Out Rate" :
			       "SRC In Rate",
			       rsnd_src_reconvert_update,
			       &src->sync, 192000);

	return ret;
}

934
static struct rsnd_mod_ops rsnd_src_gen2_ops = {
935
	.name	= SRC_NAME,
936
	.dma_req = rsnd_src_dma_req,
937 938 939 940 941 942
	.probe	= rsnd_src_probe_gen2,
	.remove	= rsnd_src_remove_gen2,
	.init	= rsnd_src_init_gen2,
	.quit	= rsnd_src_quit,
	.start	= rsnd_src_start_gen2,
	.stop	= rsnd_src_stop_gen2,
943
	.hw_params = rsnd_src_hw_params,
944
	.pcm_new = rsnd_src_pcm_new,
945 946
};

947
struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
948
{
949
	if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
950
		id = 0;
951

952
	return &((struct rsnd_src *)(priv->src) + id)->mod;
953 954
}

955 956 957 958 959
static void rsnd_of_parse_src(struct platform_device *pdev,
			      const struct rsnd_of_data *of_data,
			      struct rsnd_priv *priv)
{
	struct device_node *src_node;
960
	struct device_node *np;
961 962 963
	struct rcar_snd_info *info = rsnd_priv_to_info(priv);
	struct rsnd_src_platform_info *src_info;
	struct device *dev = &pdev->dev;
964
	int nr, i;
965 966 967 968

	if (!of_data)
		return;

969
	src_node = rsnd_src_of_node(priv);
970 971 972 973 974
	if (!src_node)
		return;

	nr = of_get_child_count(src_node);
	if (!nr)
975
		goto rsnd_of_parse_src_end;
976 977 978 979 980 981

	src_info = devm_kzalloc(dev,
				sizeof(struct rsnd_src_platform_info) * nr,
				GFP_KERNEL);
	if (!src_info) {
		dev_err(dev, "src info allocation error\n");
982
		goto rsnd_of_parse_src_end;
983 984 985 986
	}

	info->src_info		= src_info;
	info->src_info_nr	= nr;
987

988 989 990 991 992 993 994
	i = 0;
	for_each_child_of_node(src_node, np) {
		src_info[i].irq = irq_of_parse_and_map(np, 0);

		i++;
	}

995 996
rsnd_of_parse_src_end:
	of_node_put(src_node);
997 998
}

999
int rsnd_src_probe(struct platform_device *pdev,
1000
		   const struct rsnd_of_data *of_data,
1001 1002
		   struct rsnd_priv *priv)
{
1003
	struct rcar_snd_info *info = rsnd_priv_to_info(priv);
1004
	struct device *dev = rsnd_priv_to_dev(priv);
1005
	struct rsnd_src *src;
1006
	struct rsnd_mod_ops *ops;
1007
	struct clk *clk;
1008
	char name[RSND_SRC_NAME_SIZE];
1009
	int i, nr, ret;
1010

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
	ops = NULL;
	if (rsnd_is_gen1(priv))
		ops = &rsnd_src_gen1_ops;
	if (rsnd_is_gen2(priv))
		ops = &rsnd_src_gen2_ops;
	if (!ops) {
		dev_err(dev, "unknown Generation\n");
		return -EIO;
	}

1021 1022
	rsnd_of_parse_src(pdev, of_data, priv);

1023
	/*
1024
	 * init SRC
1025
	 */
1026
	nr	= info->src_info_nr;
1027 1028 1029
	if (!nr)
		return 0;

1030 1031 1032
	src	= devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL);
	if (!src) {
		dev_err(dev, "SRC allocate failed\n");
1033 1034 1035
		return -ENOMEM;
	}

1036 1037
	priv->src_nr	= nr;
	priv->src	= src;
1038

1039
	for_each_rsnd_src(src, priv, i) {
1040 1041
		snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
			 SRC_NAME, i);
1042 1043 1044 1045 1046

		clk = devm_clk_get(dev, name);
		if (IS_ERR(clk))
			return PTR_ERR(clk);

1047
		src->info = &info->src_info[i];
1048

1049 1050 1051
		ret = rsnd_mod_init(&src->mod, ops, clk, RSND_MOD_SRC, i);
		if (ret)
			return ret;
1052
	}
1053 1054 1055

	return 0;
}
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066

void rsnd_src_remove(struct platform_device *pdev,
		     struct rsnd_priv *priv)
{
	struct rsnd_src *src;
	int i;

	for_each_rsnd_src(src, priv, i) {
		rsnd_mod_quit(&src->mod);
	}
}