2013-07-22 12:36:35 +08:00
|
|
|
/*
|
2014-03-04 12:51:21 +08:00
|
|
|
* Renesas R-Car SRC support
|
2013-07-22 12:36:35 +08:00
|
|
|
*
|
|
|
|
* 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"
|
|
|
|
|
2014-05-23 14:25:43 +08:00
|
|
|
#define SRC_NAME "src"
|
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
/* 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))
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src {
|
|
|
|
struct rsnd_src_platform_info *info; /* rcar_snd.h */
|
2013-07-22 12:36:35 +08:00
|
|
|
struct rsnd_mod mod;
|
2015-01-08 09:52:36 +08:00
|
|
|
int err;
|
2013-07-22 12:36:35 +08:00
|
|
|
};
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
#define RSND_SRC_NAME_SIZE 16
|
2013-07-29 09:59:12 +08:00
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
#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))
|
2014-01-24 10:40:47 +08:00
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
#define for_each_rsnd_src(pos, priv, i) \
|
2014-01-24 10:40:47 +08:00
|
|
|
for ((i) = 0; \
|
2014-03-04 12:51:21 +08:00
|
|
|
((i) < rsnd_src_nr(priv)) && \
|
|
|
|
((pos) = (struct rsnd_src *)(priv)->src + i); \
|
2014-01-24 10:40:47 +08:00
|
|
|
i++)
|
|
|
|
|
|
|
|
|
2013-12-20 11:28:51 +08:00
|
|
|
/*
|
|
|
|
* image of SRC (Sampling Rate Converter)
|
|
|
|
*
|
|
|
|
* 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+
|
|
|
|
* 48kHz <-> | SRC | <------> | SSI | <-----> | codec |
|
|
|
|
* 44.1kHz <-> +-----+ +-----+ +-------+
|
|
|
|
* ...
|
|
|
|
*
|
|
|
|
*/
|
2013-07-29 09:59:12 +08:00
|
|
|
|
2014-01-24 10:40:41 +08:00
|
|
|
/*
|
2014-03-04 12:51:21 +08:00
|
|
|
* src.c is caring...
|
2014-01-24 10:40:41 +08:00
|
|
|
*
|
|
|
|
* Gen1
|
|
|
|
*
|
|
|
|
* [mem] -> [SRU] -> [SSI]
|
|
|
|
* |--------|
|
|
|
|
*
|
|
|
|
* Gen2
|
|
|
|
*
|
2014-03-04 12:51:21 +08:00
|
|
|
* [mem] -> [SRC] -> [SSIU] -> [SSI]
|
2014-01-24 10:40:41 +08:00
|
|
|
* |-----------------|
|
|
|
|
*/
|
|
|
|
|
2014-01-24 10:39:56 +08:00
|
|
|
/*
|
|
|
|
* 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
|
2014-03-04 12:51:21 +08:00
|
|
|
* struct rsnd_src_platform_info {
|
2014-01-24 10:39:56 +08:00
|
|
|
* u32 convert_rate;
|
2014-05-08 16:59:26 +08:00
|
|
|
* int dma_id;
|
2014-01-24 10:39:56 +08:00
|
|
|
* }
|
|
|
|
*
|
2014-03-04 12:51:21 +08:00
|
|
|
* rsnd_src_convert_rate() indicates
|
2014-01-24 10:39:56 +08:00
|
|
|
* above convert_rate, and it controls
|
|
|
|
* whether SRC is used or not.
|
|
|
|
*
|
|
|
|
* ex) doesn't use SRC
|
2014-05-08 16:59:26 +08:00
|
|
|
* static struct rsnd_dai_platform_info rsnd_dai = {
|
|
|
|
* .playback = { .ssi = &rsnd_ssi[0], },
|
2014-01-24 10:39:56 +08:00
|
|
|
* };
|
|
|
|
*
|
|
|
|
* ex) uses SRC
|
2014-05-08 16:59:26 +08:00
|
|
|
* 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] },
|
2014-01-24 10:39:56 +08:00
|
|
|
* };
|
|
|
|
*
|
|
|
|
* ex) uses SRC bypass mode
|
2014-05-08 16:59:26 +08:00
|
|
|
* 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] },
|
2014-01-24 10:39:56 +08:00
|
|
|
* };
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
/*
|
|
|
|
* Gen1/Gen2 common functions
|
|
|
|
*/
|
2014-06-23 08:56:23 +08:00
|
|
|
int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod,
|
|
|
|
int use_busif)
|
2014-01-24 10:39:32 +08:00
|
|
|
{
|
2014-07-31 14:52:26 +08:00
|
|
|
struct rsnd_dai_stream *io = rsnd_mod_to_io(ssi_mod);
|
2015-01-15 16:07:19 +08:00
|
|
|
struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
|
2014-07-31 14:52:26 +08:00
|
|
|
struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
|
2014-03-03 15:43:03 +08:00
|
|
|
int ssi_id = rsnd_mod_id(ssi_mod);
|
2014-01-24 10:39:32 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SSI_MODE0
|
|
|
|
*/
|
2014-03-04 12:50:24 +08:00
|
|
|
rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id),
|
2014-06-23 08:56:23 +08:00
|
|
|
!use_busif << ssi_id);
|
2014-01-24 10:39:32 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* SSI_MODE1
|
|
|
|
*/
|
2014-03-03 15:43:03 +08:00
|
|
|
if (rsnd_ssi_is_pin_sharing(ssi_mod)) {
|
2014-01-24 10:39:32 +08:00
|
|
|
int shift = -1;
|
2014-03-03 15:43:03 +08:00
|
|
|
switch (ssi_id) {
|
2014-01-24 10:39:32 +08:00
|
|
|
case 1:
|
|
|
|
shift = 0;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
shift = 2;
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
shift = 16;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (shift >= 0)
|
2014-03-04 12:50:24 +08:00
|
|
|
rsnd_mod_bset(ssi_mod, SSI_MODE1,
|
2014-01-24 10:39:32 +08:00
|
|
|
0x3 << shift,
|
2015-01-15 16:04:51 +08:00
|
|
|
rsnd_rdai_is_clk_master(rdai) ?
|
2014-01-24 10:39:32 +08:00
|
|
|
0x2 << shift : 0x1 << shift);
|
|
|
|
}
|
|
|
|
|
2014-06-23 08:56:23 +08:00
|
|
|
/*
|
|
|
|
* DMA settings for SSIU
|
|
|
|
*/
|
|
|
|
if (use_busif) {
|
2014-07-31 14:52:26 +08:00
|
|
|
u32 val = 0x76543210;
|
|
|
|
u32 mask = ~0;
|
|
|
|
|
2014-06-23 08:56:23 +08:00
|
|
|
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);
|
2014-07-31 14:52:26 +08:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2014-06-23 08:56:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod)
|
2014-06-23 08:56:23 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* DMA settings for SSIU
|
|
|
|
*/
|
2014-11-27 16:03:39 +08:00
|
|
|
rsnd_mod_write(ssi_mod, SSI_CTRL, 0);
|
2014-06-23 08:56:23 +08:00
|
|
|
|
2014-01-24 10:39:32 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod)
|
2014-03-04 12:50:08 +08:00
|
|
|
{
|
|
|
|
struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
|
|
|
|
|
2014-11-27 16:05:09 +08:00
|
|
|
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
|
2014-03-04 12:50:08 +08:00
|
|
|
rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod)
|
2014-11-27 16:05:09 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
|
2014-03-03 15:43:03 +08:00
|
|
|
struct rsnd_dai_stream *io,
|
2014-01-24 10:41:36 +08:00
|
|
|
struct snd_pcm_runtime *runtime)
|
|
|
|
{
|
2014-03-24 12:23:42 +08:00
|
|
|
struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src;
|
2014-03-24 12:23:42 +08:00
|
|
|
unsigned int rate = 0;
|
2014-01-24 10:41:36 +08:00
|
|
|
|
2014-03-24 12:23:42 +08:00
|
|
|
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);
|
|
|
|
}
|
2014-01-24 10:41:36 +08:00
|
|
|
|
|
|
|
if (!rate)
|
|
|
|
rate = runtime->rate;
|
|
|
|
|
|
|
|
return rate;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_set_convert_rate(struct rsnd_mod *mod)
|
2014-01-24 10:41:36 +08:00
|
|
|
{
|
2014-05-09 08:44:29 +08:00
|
|
|
struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
|
2014-01-24 10:41:36 +08:00
|
|
|
struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
|
|
|
u32 convert_rate = rsnd_src_convert_rate(src);
|
2014-01-24 10:41:36 +08:00
|
|
|
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 */
|
2014-05-09 08:44:14 +08:00
|
|
|
rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod));
|
2014-01-24 10:41:36 +08:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_init(struct rsnd_mod *mod)
|
2014-01-24 10:41:36 +08:00
|
|
|
{
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
2014-01-24 10:41:36 +08:00
|
|
|
|
2015-01-15 16:03:22 +08:00
|
|
|
rsnd_mod_hw_start(mod);
|
2014-01-24 10:41:36 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
src->err = 0;
|
|
|
|
|
2014-11-27 16:06:43 +08:00
|
|
|
/*
|
|
|
|
* Initialize the operation of the SRC internal circuits
|
|
|
|
* see rsnd_src_start()
|
|
|
|
*/
|
|
|
|
rsnd_mod_write(mod, SRC_SRCIR, 1);
|
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_quit(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-01-24 10:41:36 +08:00
|
|
|
{
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
2015-01-08 09:52:36 +08:00
|
|
|
struct device *dev = rsnd_priv_to_dev(priv);
|
2014-01-24 10:41:36 +08:00
|
|
|
|
2015-01-15 16:03:22 +08:00
|
|
|
rsnd_mod_hw_stop(mod);
|
2014-01-24 10:41:36 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
if (src->err)
|
|
|
|
dev_warn(dev, "src under/over flow err = %d\n", src->err);
|
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-27 16:07:28 +08:00
|
|
|
static int rsnd_src_start(struct rsnd_mod *mod)
|
2014-01-24 10:41:36 +08:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Cancel the initialization and operate the SRC function
|
2014-11-27 16:06:43 +08:00
|
|
|
* see rsnd_src_init()
|
2014-01-24 10:41:36 +08:00
|
|
|
*/
|
|
|
|
rsnd_mod_write(mod, SRC_SRCIR, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-27 16:07:28 +08:00
|
|
|
static int rsnd_src_stop(struct rsnd_mod *mod)
|
2014-01-24 10:41:36 +08:00
|
|
|
{
|
2014-11-27 16:07:07 +08:00
|
|
|
/* nothing to do */
|
2014-01-24 10:41:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Gen1 functions
|
|
|
|
*/
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_set_route_gen1(struct rsnd_mod *mod)
|
2013-07-29 09:59:12 +08:00
|
|
|
{
|
2014-05-09 08:44:29 +08:00
|
|
|
struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
|
2014-03-04 12:51:21 +08:00
|
|
|
struct src_route_config {
|
2013-07-29 09:59:12 +08:00
|
|
|
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);
|
2013-11-08 17:46:10 +08:00
|
|
|
if (id < 0 || id >= ARRAY_SIZE(routes))
|
2013-07-29 09:59:12 +08:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SRC_ROUTE_SELECT
|
|
|
|
*/
|
2015-01-15 16:06:49 +08:00
|
|
|
val = rsnd_io_is_play(io) ? 0x1 : 0x2;
|
2013-07-29 09:59:12 +08:00
|
|
|
val = val << routes[id].shift;
|
|
|
|
mask = routes[id].mask << routes[id].shift;
|
|
|
|
|
|
|
|
rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);
|
|
|
|
|
2014-01-24 10:41:10 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod)
|
2014-01-24 10:41:10 +08:00
|
|
|
{
|
2014-05-09 08:44:29 +08:00
|
|
|
struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
|
2014-01-24 10:41:10 +08:00
|
|
|
struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
2014-01-24 10:41:10 +08:00
|
|
|
struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
|
2014-03-04 12:51:21 +08:00
|
|
|
u32 convert_rate = rsnd_src_convert_rate(src);
|
2014-01-24 10:41:10 +08:00
|
|
|
u32 mask;
|
|
|
|
u32 val;
|
|
|
|
int shift;
|
|
|
|
int id = rsnd_mod_id(mod);
|
|
|
|
int ret;
|
|
|
|
|
2013-07-29 09:59:12 +08:00
|
|
|
/*
|
|
|
|
* SRC_TIMING_SELECT
|
|
|
|
*/
|
|
|
|
shift = (id % 4) * 8;
|
|
|
|
mask = 0x1F << shift;
|
2013-12-20 11:28:51 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
*/
|
2014-01-24 10:41:10 +08:00
|
|
|
ret = 0;
|
|
|
|
if (convert_rate) {
|
|
|
|
/* use ADG */
|
2013-12-20 11:28:51 +08:00
|
|
|
val = 0;
|
2014-01-24 10:41:10 +08:00
|
|
|
ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
|
|
|
|
runtime->rate,
|
|
|
|
convert_rate);
|
|
|
|
} else if (8 == id) {
|
|
|
|
/* use SSI WS, but SRU8 is special */
|
2013-07-29 09:59:12 +08:00
|
|
|
val = id << shift;
|
2014-01-24 10:41:10 +08:00
|
|
|
} else {
|
|
|
|
/* use SSI WS */
|
2013-07-29 09:59:12 +08:00
|
|
|
val = (id + 1) << shift;
|
2014-01-24 10:41:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2013-07-29 09:59:12 +08:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod)
|
2013-07-29 09:59:12 +08:00
|
|
|
{
|
2014-11-27 16:07:07 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
2014-01-24 10:41:36 +08:00
|
|
|
int ret;
|
2013-12-20 11:28:51 +08:00
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_convert_rate(mod);
|
2014-01-24 10:41:36 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2013-12-20 11:28:51 +08:00
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
/* Select SRC mode (fixed value) */
|
|
|
|
rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
|
2013-12-20 11:28:51 +08:00
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
/* Set the restriction value of the FS ratio (98%) */
|
|
|
|
rsnd_mod_write(mod, SRC_MNFSR,
|
|
|
|
rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
|
2013-12-20 11:28:51 +08:00
|
|
|
|
2014-11-27 16:07:07 +08:00
|
|
|
/* Gen1/Gen2 are not compatible */
|
|
|
|
if (rsnd_src_convert_rate(src))
|
|
|
|
rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
|
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
/* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
|
2013-12-20 11:28:51 +08:00
|
|
|
|
2013-07-29 09:59:12 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-23 14:25:43 +08:00
|
|
|
static int rsnd_src_probe_gen1(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-05-23 14:25:43 +08:00
|
|
|
{
|
|
|
|
struct device *dev = rsnd_priv_to_dev(priv);
|
|
|
|
|
2014-11-10 12:00:30 +08:00
|
|
|
dev_dbg(dev, "%s[%d] (Gen1) is probed\n",
|
|
|
|
rsnd_mod_name(mod), rsnd_mod_id(mod));
|
2014-05-23 14:25:43 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_init_gen1(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2013-07-22 12:36:35 +08:00
|
|
|
{
|
2013-07-29 09:59:12 +08:00
|
|
|
int ret;
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_init(mod);
|
2014-01-24 10:39:32 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_route_gen1(mod);
|
2013-07-29 09:59:12 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_convert_rate_gen1(mod);
|
2013-07-29 09:59:12 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2013-07-22 12:36:35 +08:00
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_convert_timing_gen1(mod);
|
2014-01-24 10:41:10 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2014-01-24 10:38:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_start_gen1(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-01-24 10:38:33 +08:00
|
|
|
{
|
2014-01-24 10:41:36 +08:00
|
|
|
int id = rsnd_mod_id(mod);
|
2014-01-24 10:38:33 +08:00
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
|
2013-07-29 09:59:12 +08:00
|
|
|
|
2014-11-27 16:07:28 +08:00
|
|
|
return rsnd_src_start(mod);
|
2013-07-22 12:36:35 +08:00
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-01-24 10:38:33 +08:00
|
|
|
{
|
2014-01-24 10:38:50 +08:00
|
|
|
int id = rsnd_mod_id(mod);
|
2014-01-24 10:38:33 +08:00
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
|
2014-01-24 10:38:50 +08:00
|
|
|
|
2014-11-27 16:07:28 +08:00
|
|
|
return rsnd_src_stop(mod);
|
2014-01-24 10:38:33 +08:00
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static struct rsnd_mod_ops rsnd_src_gen1_ops = {
|
2014-05-23 14:25:43 +08:00
|
|
|
.name = SRC_NAME,
|
|
|
|
.probe = rsnd_src_probe_gen1,
|
2014-03-04 12:51:21 +08:00
|
|
|
.init = rsnd_src_init_gen1,
|
|
|
|
.quit = rsnd_src_quit,
|
|
|
|
.start = rsnd_src_start_gen1,
|
|
|
|
.stop = rsnd_src_stop_gen1,
|
2014-01-24 10:41:36 +08:00
|
|
|
};
|
2014-01-24 10:38:50 +08:00
|
|
|
|
2014-01-24 10:41:36 +08:00
|
|
|
/*
|
|
|
|
* Gen2 functions
|
|
|
|
*/
|
2015-01-08 09:52:36 +08:00
|
|
|
#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;
|
|
|
|
struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
|
|
|
|
|
|
|
|
if (!io)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
|
|
|
if (rsnd_src_error_record_gen2(mod)) {
|
|
|
|
struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
|
|
|
|
struct device *dev = rsnd_priv_to_dev(priv);
|
|
|
|
|
|
|
|
_rsnd_src_stop_gen2(mod);
|
|
|
|
_rsnd_src_start_gen2(mod);
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s[%d] restart\n",
|
|
|
|
rsnd_mod_name(mod), rsnd_mod_id(mod));
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod)
|
2014-01-24 10:42:00 +08:00
|
|
|
{
|
2014-07-31 14:52:04 +08:00
|
|
|
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);
|
2014-11-27 16:06:34 +08:00
|
|
|
u32 convert_rate = rsnd_src_convert_rate(src);
|
2014-07-31 14:52:04 +08:00
|
|
|
uint ratio;
|
2014-01-24 10:42:00 +08:00
|
|
|
int ret;
|
|
|
|
|
2014-07-31 14:52:04 +08:00
|
|
|
/* 6 - 1/6 are very enough ratio for SRC_BSDSR */
|
2014-11-27 16:06:34 +08:00
|
|
|
if (!convert_rate)
|
2014-07-31 14:52:04 +08:00
|
|
|
ratio = 0;
|
2014-11-27 16:06:34 +08:00
|
|
|
else if (convert_rate > runtime->rate)
|
|
|
|
ratio = 100 * convert_rate / runtime->rate;
|
2014-07-31 14:52:04 +08:00
|
|
|
else
|
2014-11-27 16:06:34 +08:00
|
|
|
ratio = 100 * runtime->rate / convert_rate;
|
2014-07-31 14:52:04 +08:00
|
|
|
|
|
|
|
if (ratio > 600) {
|
|
|
|
dev_err(dev, "FSO/FSI ratio error\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_convert_rate(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);
|
|
|
|
|
2014-11-27 16:07:07 +08:00
|
|
|
if (convert_rate) {
|
|
|
|
/* Gen1/Gen2 are not compatible */
|
|
|
|
rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
|
|
|
|
}
|
|
|
|
|
2014-07-31 14:52:04 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-01-24 10:42:00 +08:00
|
|
|
rsnd_mod_write(mod, SRC_BSISR, 0x00100060);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod)
|
2014-01-24 10:42:00 +08:00
|
|
|
{
|
2014-05-09 08:44:29 +08:00
|
|
|
struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
|
|
|
u32 convert_rate = rsnd_src_convert_rate(src);
|
2014-01-24 10:42:00 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (convert_rate)
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_adg_set_convert_clk_gen2(mod, io,
|
2014-01-24 10:42:00 +08:00
|
|
|
runtime->rate,
|
|
|
|
convert_rate);
|
|
|
|
else
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_adg_set_convert_timing_gen2(mod, io);
|
2014-01-24 10:42:00 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-03-04 12:50:41 +08:00
|
|
|
{
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src = rsnd_mod_to_src(mod);
|
2014-03-04 12:50:41 +08:00
|
|
|
struct device *dev = rsnd_priv_to_dev(priv);
|
2015-01-08 09:52:36 +08:00
|
|
|
int irq = src->info->irq;
|
2014-03-04 12:50:41 +08:00
|
|
|
int ret;
|
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
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)
|
|
|
|
goto rsnd_src_probe_gen2_fail;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:50:41 +08:00
|
|
|
ret = rsnd_dma_init(priv,
|
|
|
|
rsnd_mod_to_dma(mod),
|
2014-05-08 16:59:26 +08:00
|
|
|
rsnd_info_is_playback(priv, src),
|
2014-03-04 12:51:21 +08:00
|
|
|
src->info->dma_id);
|
2015-01-08 09:52:36 +08:00
|
|
|
if (ret)
|
|
|
|
goto rsnd_src_probe_gen2_fail;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
|
|
|
|
rsnd_mod_name(mod), rsnd_mod_id(mod));
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
rsnd_src_probe_gen2_fail:
|
|
|
|
dev_err(dev, "%s[%d] (Gen2) failed\n",
|
|
|
|
rsnd_mod_name(mod), rsnd_mod_id(mod));
|
2014-05-23 14:25:43 +08:00
|
|
|
|
2014-03-04 12:50:41 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-03-04 12:50:41 +08:00
|
|
|
{
|
2015-01-15 16:07:47 +08:00
|
|
|
rsnd_dma_quit(priv, rsnd_mod_to_dma(mod));
|
2014-03-04 12:50:41 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_init_gen2(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-01-24 10:42:00 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_init(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_convert_rate_gen2(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2015-01-15 16:07:19 +08:00
|
|
|
ret = rsnd_src_set_convert_timing_gen2(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_start_gen2(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-01-24 10:42:00 +08:00
|
|
|
{
|
2015-01-08 09:52:36 +08:00
|
|
|
rsnd_dma_start(rsnd_mod_to_dma(mod));
|
2014-01-24 10:42:00 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
return _rsnd_src_start_gen2(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
|
2015-01-15 16:07:47 +08:00
|
|
|
struct rsnd_priv *priv)
|
2014-01-24 10:42:00 +08:00
|
|
|
{
|
2015-01-08 09:52:36 +08:00
|
|
|
int ret;
|
2014-01-24 10:42:00 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
ret = _rsnd_src_stop_gen2(mod);
|
2014-01-24 10:42:00 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
rsnd_dma_stop(rsnd_mod_to_dma(mod));
|
2014-01-24 10:42:00 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
return ret;
|
2014-01-24 10:42:00 +08:00
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
static struct rsnd_mod_ops rsnd_src_gen2_ops = {
|
2014-05-23 14:25:43 +08:00
|
|
|
.name = SRC_NAME,
|
2014-03-04 12:51:21 +08:00
|
|
|
.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,
|
2014-01-24 10:42:00 +08:00
|
|
|
};
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
|
2013-07-22 12:36:35 +08:00
|
|
|
{
|
2014-03-04 12:51:21 +08:00
|
|
|
if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
|
2013-11-06 01:40:05 +08:00
|
|
|
id = 0;
|
2013-07-22 12:36:35 +08:00
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
return &((struct rsnd_src *)(priv->src) + id)->mod;
|
2013-07-22 12:36:35 +08:00
|
|
|
}
|
|
|
|
|
2014-03-18 10:29:55 +08:00
|
|
|
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;
|
2015-01-08 09:52:36 +08:00
|
|
|
struct device_node *np;
|
2014-03-18 10:29:55 +08:00
|
|
|
struct rcar_snd_info *info = rsnd_priv_to_info(priv);
|
|
|
|
struct rsnd_src_platform_info *src_info;
|
|
|
|
struct device *dev = &pdev->dev;
|
2015-01-08 09:52:36 +08:00
|
|
|
int nr, i;
|
2014-03-18 10:29:55 +08:00
|
|
|
|
|
|
|
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)
|
2014-05-23 14:24:59 +08:00
|
|
|
goto rsnd_of_parse_src_end;
|
2014-03-18 10:29:55 +08:00
|
|
|
|
|
|
|
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");
|
2014-05-23 14:24:59 +08:00
|
|
|
goto rsnd_of_parse_src_end;
|
2014-03-18 10:29:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
info->src_info = src_info;
|
|
|
|
info->src_info_nr = nr;
|
2014-05-23 14:24:59 +08:00
|
|
|
|
2015-01-08 09:52:36 +08:00
|
|
|
i = 0;
|
|
|
|
for_each_child_of_node(src_node, np) {
|
|
|
|
src_info[i].irq = irq_of_parse_and_map(np, 0);
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
2014-05-23 14:24:59 +08:00
|
|
|
rsnd_of_parse_src_end:
|
|
|
|
of_node_put(src_node);
|
2014-03-18 10:29:55 +08:00
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
int rsnd_src_probe(struct platform_device *pdev,
|
2014-03-18 10:29:55 +08:00
|
|
|
const struct rsnd_of_data *of_data,
|
2013-07-22 12:36:35 +08:00
|
|
|
struct rsnd_priv *priv)
|
|
|
|
{
|
2014-02-25 14:15:00 +08:00
|
|
|
struct rcar_snd_info *info = rsnd_priv_to_info(priv);
|
2013-07-22 12:36:35 +08:00
|
|
|
struct device *dev = rsnd_priv_to_dev(priv);
|
2014-03-04 12:51:21 +08:00
|
|
|
struct rsnd_src *src;
|
2014-01-24 10:38:26 +08:00
|
|
|
struct rsnd_mod_ops *ops;
|
2013-12-20 11:28:51 +08:00
|
|
|
struct clk *clk;
|
2014-03-04 12:51:21 +08:00
|
|
|
char name[RSND_SRC_NAME_SIZE];
|
2013-07-22 12:36:35 +08:00
|
|
|
int i, nr;
|
|
|
|
|
2014-05-23 14:25:37 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-03-18 10:29:55 +08:00
|
|
|
rsnd_of_parse_src(pdev, of_data, priv);
|
|
|
|
|
2013-07-22 12:36:35 +08:00
|
|
|
/*
|
2014-03-04 12:51:21 +08:00
|
|
|
* init SRC
|
2013-07-22 12:36:35 +08:00
|
|
|
*/
|
2014-03-04 12:51:21 +08:00
|
|
|
nr = info->src_info_nr;
|
2014-03-04 12:50:00 +08:00
|
|
|
if (!nr)
|
|
|
|
return 0;
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL);
|
|
|
|
if (!src) {
|
|
|
|
dev_err(dev, "SRC allocate failed\n");
|
2013-07-22 12:36:35 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
priv->src_nr = nr;
|
|
|
|
priv->src = src;
|
2013-07-22 12:36:35 +08:00
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
for_each_rsnd_src(src, priv, i) {
|
2014-05-23 14:25:43 +08:00
|
|
|
snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
|
|
|
|
SRC_NAME, i);
|
2013-12-20 11:28:51 +08:00
|
|
|
|
|
|
|
clk = devm_clk_get(dev, name);
|
|
|
|
if (IS_ERR(clk))
|
|
|
|
return PTR_ERR(clk);
|
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
src->info = &info->src_info[i];
|
2013-07-22 12:36:35 +08:00
|
|
|
|
2015-01-15 16:08:34 +08:00
|
|
|
rsnd_mod_init(&src->mod, ops, clk, RSND_MOD_SRC, i);
|
2014-01-24 10:38:26 +08:00
|
|
|
|
2014-03-04 12:51:21 +08:00
|
|
|
dev_dbg(dev, "SRC%d probed\n", i);
|
2013-07-29 09:59:12 +08:00
|
|
|
}
|
2013-07-22 12:36:35 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|