src.c 14.7 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
struct rsnd_src {
	struct rsnd_src_platform_info *info; /* rcar_snd.h */
15
	struct rsnd_mod mod;
16
	struct clk *clk;
17 18
};

19
#define RSND_SRC_NAME_SIZE 16
20 21 22 23 24 25 26 27 28 29

/*
 * ADINR
 */
#define OTBL_24		(0 << 16)
#define OTBL_22		(2 << 16)
#define OTBL_20		(4 << 16)
#define OTBL_18		(6 << 16)
#define OTBL_16		(8 << 16)

30 31 32 33 34
#define rsnd_src_convert_rate(p) ((p)->info->convert_rate)
#define rsnd_mod_to_src(_mod)				\
	container_of((_mod), struct rsnd_src, mod)
#define rsnd_src_dma_available(src) \
	rsnd_dma_available(rsnd_mod_to_dma(&(src)->mod))
35

36
#define for_each_rsnd_src(pos, priv, i)				\
37
	for ((i) = 0;						\
38 39
	     ((i) < rsnd_src_nr(priv)) &&			\
	     ((pos) = (struct rsnd_src *)(priv)->src + i);	\
40 41 42
	     i++)


43 44 45 46 47 48 49 50 51
/*
 *		image of SRC (Sampling Rate Converter)
 *
 * 96kHz   <-> +-----+	48kHz	+-----+	 48kHz	+-------+
 * 48kHz   <-> | SRC | <------>	| SSI |	<----->	| codec |
 * 44.1kHz <-> +-----+		+-----+		+-------+
 * ...
 *
 */
52

53
/*
54
 * src.c is caring...
55 56 57 58 59 60 61 62
 *
 * Gen1
 *
 * [mem] -> [SRU] -> [SSI]
 *        |--------|
 *
 * Gen2
 *
63
 * [mem] -> [SRC] -> [SSIU] -> [SSI]
64 65 66
 *        |-----------------|
 */

67 68 69 70 71 72 73 74 75 76 77 78
/*
 *	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
79
 * struct rsnd_src_platform_info {
80
 *	u32 convert_rate;
81
 *	int dma_id;
82 83
 * }
 *
84
 * rsnd_src_convert_rate() indicates
85 86 87 88
 * above convert_rate, and it controls
 * whether SRC is used or not.
 *
 * ex) doesn't use SRC
89 90
 * static struct rsnd_dai_platform_info rsnd_dai = {
 *	.playback = { .ssi = &rsnd_ssi[0], },
91 92 93
 * };
 *
 * ex) uses SRC
94 95 96 97 98 99
 * 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] },
100 101 102
 * };
 *
 * ex) uses SRC bypass mode
103 104 105 106 107 108
 * 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] },
109 110 111 112
 * };
 *
 */

113 114 115
/*
 *		Gen1/Gen2 common functions
 */
116
int rsnd_src_ssi_mode_init(struct rsnd_mod *ssi_mod,
117 118
			   struct rsnd_dai *rdai,
			   struct rsnd_dai_stream *io)
119
{
120
	struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
121
	int ssi_id = rsnd_mod_id(ssi_mod);
122 123 124 125

	/*
	 * SSI_MODE0
	 */
126
	rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id),
127
		      src_mod ? 0 : (1 << ssi_id));
128 129 130 131

	/*
	 * SSI_MODE1
	 */
132
	if (rsnd_ssi_is_pin_sharing(ssi_mod)) {
133
		int shift = -1;
134
		switch (ssi_id) {
135 136 137 138 139 140 141 142 143 144 145 146
		case 1:
			shift = 0;
			break;
		case 2:
			shift = 2;
			break;
		case 4:
			shift = 16;
			break;
		}

		if (shift >= 0)
147
			rsnd_mod_bset(ssi_mod, SSI_MODE1,
148 149 150 151 152 153 154 155
				      0x3 << shift,
				      rsnd_dai_is_clk_master(rdai) ?
				      0x2 << shift : 0x1 << shift);
	}

	return 0;
}

156
int rsnd_src_enable_ssi_irq(struct rsnd_mod *ssi_mod,
157 158 159 160 161 162 163 164 165 166 167 168
			    struct rsnd_dai *rdai,
			    struct rsnd_dai_stream *io)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);

	/* enable PIO interrupt if Gen2 */
	if (rsnd_is_gen2(priv))
		rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);

	return 0;
}

169
unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
170
				   struct rsnd_dai_stream *io,
171 172
				   struct snd_pcm_runtime *runtime)
{
173
	struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
174
	struct rsnd_src *src;
175
	unsigned int rate = 0;
176

177 178 179 180 181 182 183 184 185
	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);
	}
186 187 188 189 190 191 192

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

	return rate;
}

193
static int rsnd_src_set_convert_rate(struct rsnd_mod *mod,
194 195 196 197
				     struct rsnd_dai *rdai,
				     struct rsnd_dai_stream *io)
{
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
198 199
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	u32 convert_rate = rsnd_src_convert_rate(src);
200 201 202 203 204 205 206 207 208 209 210 211
	u32 adinr = runtime->channels;
	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);

	/*
	 * Initialize the operation of the SRC internal circuits
212
	 * see rsnd_src_start()
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
	 */
	rsnd_mod_write(mod, SRC_SRCIR, 1);

	/* Set channel number and output bit length */
	switch (runtime->sample_bits) {
	case 16:
		adinr |= OTBL_16;
		break;
	case 32:
		adinr |= OTBL_24;
		break;
	default:
		return -EIO;
	}
	rsnd_mod_write(mod, SRC_ADINR, adinr);

	/* 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;
}

243
static int rsnd_src_init(struct rsnd_mod *mod,
244 245 246
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io)
{
247
	struct rsnd_src *src = rsnd_mod_to_src(mod);
248

249
	clk_enable(src->clk);
250 251 252 253

	return 0;
}

254
static int rsnd_src_quit(struct rsnd_mod *mod,
255 256 257
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io)
{
258
	struct rsnd_src *src = rsnd_mod_to_src(mod);
259

260
	clk_disable(src->clk);
261 262 263 264

	return 0;
}

265
static int rsnd_src_start(struct rsnd_mod *mod,
266 267 268
			  struct rsnd_dai *rdai,
			  struct rsnd_dai_stream *io)
{
269
	struct rsnd_src *src = rsnd_mod_to_src(mod);
270 271 272

	/*
	 * Cancel the initialization and operate the SRC function
273
	 * see rsnd_src_set_convert_rate()
274 275 276
	 */
	rsnd_mod_write(mod, SRC_SRCIR, 0);

277
	if (rsnd_src_convert_rate(src))
278 279 280 281 282 283
		rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);

	return 0;
}


284
static int rsnd_src_stop(struct rsnd_mod *mod,
285 286 287
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io)
{
288
	struct rsnd_src *src = rsnd_mod_to_src(mod);
289

290
	if (rsnd_src_convert_rate(src))
291 292 293 294 295
		rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0);

	return 0;
}

296 297
static struct rsnd_mod_ops rsnd_src_non_ops = {
	.name	= "src (non)",
298 299 300 301 302 303 304 305
};

/*
 *		Gen1 functions
 */
static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
				   struct rsnd_dai *rdai,
				   struct rsnd_dai_stream *io)
306
{
307
	struct src_route_config {
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
		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);
326
	if (id < 0 || id >= ARRAY_SIZE(routes))
327 328 329 330 331 332 333 334 335 336 337
		return -EIO;

	/*
	 * SRC_ROUTE_SELECT
	 */
	val = rsnd_dai_is_play(rdai, io) ? 0x1 : 0x2;
	val = val		<< routes[id].shift;
	mask = routes[id].mask	<< routes[id].shift;

	rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);

338 339 340
	return 0;
}

341
static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod,
342 343 344 345
					    struct rsnd_dai *rdai,
					    struct rsnd_dai_stream *io)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
346
	struct rsnd_src *src = rsnd_mod_to_src(mod);
347
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
348
	u32 convert_rate = rsnd_src_convert_rate(src);
349 350 351 352 353 354
	u32 mask;
	u32 val;
	int shift;
	int id = rsnd_mod_id(mod);
	int ret;

355 356 357 358 359
	/*
	 * SRC_TIMING_SELECT
	 */
	shift	= (id % 4) * 8;
	mask	= 0x1F << shift;
360 361 362 363 364 365 366

	/*
	 * 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)
	 */
367 368 369
	ret = 0;
	if (convert_rate) {
		/* use ADG */
370
		val = 0;
371 372 373 374 375
		ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
						    runtime->rate,
						    convert_rate);
	} else if (8 == id) {
		/* use SSI WS, but SRU8 is special */
376
		val = id << shift;
377 378
	} else {
		/* use SSI WS */
379
		val = (id + 1) << shift;
380 381 382 383
	}

	if (ret < 0)
		return ret;
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399

	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;
}

400
static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod,
401 402
					  struct rsnd_dai *rdai,
					  struct rsnd_dai_stream *io)
403
{
404
	int ret;
405

406
	ret = rsnd_src_set_convert_rate(mod, rdai, io);
407 408
	if (ret < 0)
		return ret;
409

410 411
	/* Select SRC mode (fixed value) */
	rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
412

413 414 415
	/* Set the restriction value of the FS ratio (98%) */
	rsnd_mod_write(mod, SRC_MNFSR,
		       rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
416

417
	/* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
418

419 420 421
	return 0;
}

422
static int rsnd_src_init_gen1(struct rsnd_mod *mod,
423 424
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
425
{
426 427
	int ret;

428
	ret = rsnd_src_init(mod, rdai, io);
429 430 431
	if (ret < 0)
		return ret;

432
	ret = rsnd_src_set_route_gen1(mod, rdai, io);
433 434 435
	if (ret < 0)
		return ret;

436
	ret = rsnd_src_set_convert_rate_gen1(mod, rdai, io);
437 438
	if (ret < 0)
		return ret;
439

440
	ret = rsnd_src_set_convert_timing_gen1(mod, rdai, io);
441 442 443
	if (ret < 0)
		return ret;

444 445 446
	return 0;
}

447
static int rsnd_src_start_gen1(struct rsnd_mod *mod,
448 449
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
450
{
451
	int id = rsnd_mod_id(mod);
452

453
	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
454

455
	return rsnd_src_start(mod, rdai, io);
456 457
}

458
static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
459 460
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
461
{
462
	int id = rsnd_mod_id(mod);
463

464
	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
465

466
	return rsnd_src_stop(mod, rdai, io);
467 468
}

469
static struct rsnd_mod_ops rsnd_src_gen1_ops = {
470
	.name	= "sru (gen1)",
471 472 473 474
	.init	= rsnd_src_init_gen1,
	.quit	= rsnd_src_quit,
	.start	= rsnd_src_start_gen1,
	.stop	= rsnd_src_stop_gen1,
475
};
476

477 478 479
/*
 *		Gen2 functions
 */
480
static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
481 482 483 484 485
					  struct rsnd_dai *rdai,
					  struct rsnd_dai_stream *io)
{
	int ret;

486
	ret = rsnd_src_set_convert_rate(mod, rdai, io);
487 488 489 490 491 492 493 494 495 496 497 498 499 500
	if (ret < 0)
		return ret;

	rsnd_mod_write(mod, SSI_BUSIF_ADINR, rsnd_mod_read(mod, SRC_ADINR));
	rsnd_mod_write(mod, SSI_BUSIF_MODE,  rsnd_mod_read(mod, SRC_BUSIF_MODE));

	rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);

	rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
	rsnd_mod_write(mod, SRC_BSISR, 0x00100060);

	return 0;
}

501
static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod,
502 503 504 505
					    struct rsnd_dai *rdai,
					    struct rsnd_dai_stream *io)
{
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
506 507
	struct rsnd_src *src = rsnd_mod_to_src(mod);
	u32 convert_rate = rsnd_src_convert_rate(src);
508 509 510 511 512 513 514 515 516 517 518 519
	int ret;

	if (convert_rate)
		ret = rsnd_adg_set_convert_clk_gen2(mod, rdai, io,
						    runtime->rate,
						    convert_rate);
	else
		ret = rsnd_adg_set_convert_timing_gen2(mod, rdai, io);

	return ret;
}

520
static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
521 522 523 524
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
525
	struct rsnd_src *src = rsnd_mod_to_src(mod);
526 527 528 529 530
	struct device *dev = rsnd_priv_to_dev(priv);
	int ret;

	ret = rsnd_dma_init(priv,
			    rsnd_mod_to_dma(mod),
531
			    rsnd_info_is_playback(priv, src),
532
			    src->info->dma_id);
533
	if (ret < 0)
534
		dev_err(dev, "SRC DMA failed\n");
535 536 537 538

	return ret;
}

539
static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
540 541 542 543 544 545 546 547
				struct rsnd_dai *rdai,
				struct rsnd_dai_stream *io)
{
	rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod));

	return 0;
}

548
static int rsnd_src_init_gen2(struct rsnd_mod *mod,
549 550 551 552 553
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
{
	int ret;

554
	ret = rsnd_src_init(mod, rdai, io);
555 556 557
	if (ret < 0)
		return ret;

558
	ret = rsnd_src_set_convert_rate_gen2(mod, rdai, io);
559 560 561
	if (ret < 0)
		return ret;

562
	ret = rsnd_src_set_convert_timing_gen2(mod, rdai, io);
563 564 565 566 567 568
	if (ret < 0)
		return ret;

	return 0;
}

569
static int rsnd_src_start_gen2(struct rsnd_mod *mod,
570 571 572
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
{
573
	struct rsnd_src *src = rsnd_mod_to_src(mod);
574

575
	rsnd_dma_start(rsnd_mod_to_dma(&src->mod));
576 577 578 579

	rsnd_mod_write(mod, SSI_CTRL, 0x1);
	rsnd_mod_write(mod, SRC_CTRL, 0x11);

580
	return rsnd_src_start(mod, rdai, io);
581 582
}

583
static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
584 585 586
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
{
587
	struct rsnd_src *src = rsnd_mod_to_src(mod);
588 589 590 591

	rsnd_mod_write(mod, SSI_CTRL, 0);
	rsnd_mod_write(mod, SRC_CTRL, 0);

592
	rsnd_dma_stop(rsnd_mod_to_dma(&src->mod));
593

594
	return rsnd_src_stop(mod, rdai, io);
595 596
}

597 598 599 600 601 602 603 604
static struct rsnd_mod_ops rsnd_src_gen2_ops = {
	.name	= "src (gen2)",
	.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,
605 606
};

607
struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
608
{
609
	if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
610
		id = 0;
611

612
	return &((struct rsnd_src *)(priv->src) + id)->mod;
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
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;
	struct rcar_snd_info *info = rsnd_priv_to_info(priv);
	struct rsnd_src_platform_info *src_info;
	struct device *dev = &pdev->dev;
	int nr;

	if (!of_data)
		return;

	src_node = of_get_child_by_name(dev->of_node, "rcar_sound,src");
	if (!src_node)
		return;

	nr = of_get_child_count(src_node);
	if (!nr)
		return;

	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");
		return;
	}

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

648
int rsnd_src_probe(struct platform_device *pdev,
649
		   const struct rsnd_of_data *of_data,
650 651
		   struct rsnd_priv *priv)
{
652
	struct rcar_snd_info *info = rsnd_priv_to_info(priv);
653
	struct device *dev = rsnd_priv_to_dev(priv);
654
	struct rsnd_src *src;
655
	struct rsnd_mod_ops *ops;
656
	struct clk *clk;
657
	char name[RSND_SRC_NAME_SIZE];
658 659
	int i, nr;

660 661
	rsnd_of_parse_src(pdev, of_data, priv);

662
	/*
663
	 * init SRC
664
	 */
665
	nr	= info->src_info_nr;
666 667 668
	if (!nr)
		return 0;

669 670 671
	src	= devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL);
	if (!src) {
		dev_err(dev, "SRC allocate failed\n");
672 673 674
		return -ENOMEM;
	}

675 676
	priv->src_nr	= nr;
	priv->src	= src;
677

678 679
	for_each_rsnd_src(src, priv, i) {
		snprintf(name, RSND_SRC_NAME_SIZE, "src.%d", i);
680 681 682 683 684

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

685 686
		src->info = &info->src_info[i];
		src->clk = clk;
687

688
		ops = &rsnd_src_non_ops;
689 690 691 692
		if (rsnd_is_gen1(priv))
			ops = &rsnd_src_gen1_ops;
		if (rsnd_is_gen2(priv))
			ops = &rsnd_src_gen2_ops;
693

694
		rsnd_mod_init(priv, &src->mod, ops, RSND_MOD_SRC, i);
695

696
		dev_dbg(dev, "SRC%d probed\n", i);
697
	}
698 699 700

	return 0;
}