1 files changed, 114 insertions, 46 deletions

diff --git a/sound/soc/sh/rcar/ssi.c b/sound/soc/sh/rcar/ssi.c
index 7bb9c087f3dc..2fbe59f7f9b5 100644
--- a/sound/soc/sh/rcar/ssi.c
+++ b/sound/soc/sh/rcar/ssi.c
@@ -66,6 +66,7 @@ struct rsnd_ssi {
 
         u32 cr_own;
         u32 cr_clk;
+        int chan;
         int err;
         unsigned int usrcnt;
 };
@@ -80,16 +81,15 @@ struct rsnd_ssi {
 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
 #define rsnd_dma_to_ssi(dma)  rsnd_mod_to_ssi(rsnd_dma_to_mod(dma))
 #define rsnd_ssi_pio_available(ssi) ((ssi)->info->irq > 0)
-#define rsnd_ssi_clk_from_parent(ssi) ((ssi)->parent)
+#define rsnd_ssi_parent(ssi) ((ssi)->parent)
 #define rsnd_ssi_mode_flags(p) ((p)->info->flags)
 #define rsnd_ssi_dai_id(ssi) ((ssi)->info->dai_id)
 #define rsnd_ssi_of_node(priv) \
         of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,ssi")
 
-int rsnd_ssi_use_busif(struct rsnd_mod *mod)
+int rsnd_ssi_use_busif(struct rsnd_dai_stream *io, struct rsnd_mod *mod)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         int use_busif = 0;
 
         if (!rsnd_ssi_is_dma_mode(mod))
@@ -189,22 +189,26 @@ static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
                 rsnd_mod_hw_start(&ssi->mod);
 
                 if (rsnd_rdai_is_clk_master(rdai)) {
-                        if (rsnd_ssi_clk_from_parent(ssi))
-                                rsnd_ssi_hw_start(ssi->parent, io);
+                        struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi);
+
+                        if (ssi_parent)
+                                rsnd_ssi_hw_start(ssi_parent, io);
                         else
                                 rsnd_ssi_master_clk_start(ssi, io);
                 }
         }
 
-        cr_mode = rsnd_ssi_is_dma_mode(&ssi->mod) ?
-                DMEN :  /* DMA : enable DMA */
-                DIEN;   /* PIO : enable Data interrupt */
-
+        if (rsnd_ssi_is_dma_mode(&ssi->mod)) {
+                cr_mode = UIEN | OIEN | /* over/under run */
+                          DMEN;         /* DMA : enable DMA */
+        } else {
+                cr_mode = DIEN;         /* PIO : enable Data interrupt */
+        }
 
         cr  =   ssi->cr_own     |
                 ssi->cr_clk     |
                 cr_mode         |
-                UIEN | OIEN | EN;
+                EN;
 
         rsnd_mod_write(&ssi->mod, SSICR, cr);
 
@@ -221,16 +225,17 @@ static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
                 rsnd_mod_name(&ssi->mod), rsnd_mod_id(&ssi->mod));
 }
 
-static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi)
+static void rsnd_ssi_hw_stop(struct rsnd_dai_stream *io, struct rsnd_ssi *ssi)
 {
         struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(&ssi->mod);
         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
         struct device *dev = rsnd_priv_to_dev(priv);
         u32 cr;
 
-        if (0 == ssi->usrcnt) /* stop might be called without start */
+        if (0 == ssi->usrcnt) {
+                dev_err(dev, "%s called without starting\n", __func__);
                 return;
+        }
 
         ssi->usrcnt--;
 
@@ -253,13 +258,17 @@ static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi)
                 rsnd_ssi_status_check(&ssi->mod, IIRQ);
 
                 if (rsnd_rdai_is_clk_master(rdai)) {
-                        if (rsnd_ssi_clk_from_parent(ssi))
-                                rsnd_ssi_hw_stop(ssi->parent);
+                        struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi);
+
+                        if (ssi_parent)
+                                rsnd_ssi_hw_stop(io, ssi_parent);
                         else
                                 rsnd_ssi_master_clk_stop(ssi);
                 }
 
                 rsnd_mod_hw_stop(&ssi->mod);
+
+                ssi->chan = 0;
         }
 
         dev_dbg(dev, "%s[%d] hw stopped\n",
@@ -270,10 +279,10 @@ static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi)
  *      SSI mod common functions
  */
 static int rsnd_ssi_init(struct rsnd_mod *mod,
+                         struct rsnd_dai_stream *io,
                          struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
         u32 cr;
@@ -321,6 +330,7 @@ static int rsnd_ssi_init(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_quit(struct rsnd_mod *mod,
+                         struct rsnd_dai_stream *io,
                          struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
@@ -336,6 +346,37 @@ static int rsnd_ssi_quit(struct rsnd_mod *mod,
         return 0;
 }
 
+static int rsnd_ssi_hw_params(struct rsnd_mod *mod,
+                              struct rsnd_dai_stream *io,
+                              struct snd_pcm_substream *substream,
+                              struct snd_pcm_hw_params *params)
+{
+        struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
+        struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi);
+        int chan = params_channels(params);
+
+        /*
+         * Already working.
+         * It will happen if SSI has parent/child connection.
+         */
+        if (ssi->usrcnt) {
+                /*
+                 * it is error if child <-> parent SSI uses
+                 * different channels.
+                 */
+                if (ssi->chan != chan)
+                        return -EIO;
+        }
+
+        /* It will be removed on rsnd_ssi_hw_stop */
+        ssi->chan = chan;
+        if (ssi_parent)
+                return rsnd_ssi_hw_params(&ssi_parent->mod, io,
+                                          substream, params);
+
+        return 0;
+}
+
 static void rsnd_ssi_record_error(struct rsnd_ssi *ssi, u32 status)
 {
         /* under/over flow error */
@@ -348,12 +389,12 @@ static void rsnd_ssi_record_error(struct rsnd_ssi *ssi, u32 status)
 }
 
 static int rsnd_ssi_start(struct rsnd_mod *mod,
+                          struct rsnd_dai_stream *io,
                           struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 
-        rsnd_src_ssiu_start(mod, rsnd_ssi_use_busif(mod));
+        rsnd_src_ssiu_start(mod, io, rsnd_ssi_use_busif(io, mod));
 
         rsnd_ssi_hw_start(ssi, io);
 
@@ -363,6 +404,7 @@ static int rsnd_ssi_start(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_stop(struct rsnd_mod *mod,
+                         struct rsnd_dai_stream *io,
                          struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
@@ -371,24 +413,29 @@ static int rsnd_ssi_stop(struct rsnd_mod *mod,
 
         rsnd_ssi_record_error(ssi, rsnd_mod_read(mod, SSISR));
 
-        rsnd_ssi_hw_stop(ssi);
+        rsnd_ssi_hw_stop(io, ssi);
 
-        rsnd_src_ssiu_stop(mod);
+        rsnd_src_ssiu_stop(mod, io);
 
         return 0;
 }
 
-static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
+static void __rsnd_ssi_interrupt(struct rsnd_mod *mod,
+                                 struct rsnd_dai_stream *io)
 {
-        struct rsnd_ssi *ssi = data;
-        struct rsnd_mod *mod = &ssi->mod;
+        struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
-        struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
         int is_dma = rsnd_ssi_is_dma_mode(mod);
-        u32 status = rsnd_mod_read(mod, SSISR);
+        u32 status;
+        bool elapsed = false;
+
+        spin_lock(&priv->lock);
+
+        /* ignore all cases if not working */
+        if (!rsnd_io_is_working(io))
+                goto rsnd_ssi_interrupt_out;
 
-        if (!io)
-                return IRQ_NONE;
+        status = rsnd_mod_read(mod, SSISR);
 
         /* PIO only */
         if (!is_dma && (status & DIRQ)) {
@@ -406,11 +453,11 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
                 else
                         *buf = rsnd_mod_read(mod, SSIRDR);
 
-                rsnd_dai_pointer_update(io, sizeof(*buf));
+                elapsed = rsnd_dai_pointer_update(io, sizeof(*buf));
         }
 
-        /* PIO / DMA */
-        if (status & (UIRQ | OIRQ)) {
+        /* DMA only */
+        if (is_dma && (status & (UIRQ | OIRQ))) {
                 struct device *dev = rsnd_priv_to_dev(priv);
 
                 /*
@@ -419,15 +466,28 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
                 dev_dbg(dev, "%s[%d] restart\n",
                         rsnd_mod_name(mod), rsnd_mod_id(mod));
 
-                rsnd_ssi_stop(mod, priv);
+                rsnd_ssi_stop(mod, io, priv);
                 if (ssi->err < 1024)
-                        rsnd_ssi_start(mod, priv);
+                        rsnd_ssi_start(mod, io, priv);
                 else
                         dev_warn(dev, "no more SSI restart\n");
         }
 
         rsnd_ssi_record_error(ssi, status);
 
+rsnd_ssi_interrupt_out:
+        spin_unlock(&priv->lock);
+
+        if (elapsed)
+                rsnd_dai_period_elapsed(io);
+}
+
+static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
+{
+        struct rsnd_mod *mod = data;
+
+        rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt);
+
         return IRQ_HANDLED;
 }
 
@@ -435,6 +495,7 @@ static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
  *              SSI PIO
  */
 static int rsnd_ssi_pio_probe(struct rsnd_mod *mod,
+                              struct rsnd_dai_stream *io,
                               struct rsnd_priv *priv)
 {
         struct device *dev = rsnd_priv_to_dev(priv);
@@ -444,7 +505,7 @@ static int rsnd_ssi_pio_probe(struct rsnd_mod *mod,
         ret = devm_request_irq(dev, ssi->info->irq,
                                rsnd_ssi_interrupt,
                                IRQF_SHARED,
-                               dev_name(dev), ssi);
+                               dev_name(dev), mod);
 
         return ret;
 }
@@ -456,9 +517,11 @@ static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
         .quit   = rsnd_ssi_quit,
         .start  = rsnd_ssi_start,
         .stop   = rsnd_ssi_stop,
+        .hw_params = rsnd_ssi_hw_params,
 };
 
 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
+                              struct rsnd_dai_stream *io,
                               struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
@@ -469,25 +532,26 @@ static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
         ret = devm_request_irq(dev, ssi->info->irq,
                                rsnd_ssi_interrupt,
                                IRQF_SHARED,
-                               dev_name(dev), ssi);
+                               dev_name(dev), mod);
         if (ret)
                 return ret;
 
         ret = rsnd_dma_init(
-                priv, rsnd_mod_to_dma(mod),
+                io, rsnd_mod_to_dma(mod),
                 dma_id);
 
         return ret;
 }
 
 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
+                               struct rsnd_dai_stream *io,
                                struct rsnd_priv *priv)
 {
         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
         struct device *dev = rsnd_priv_to_dev(priv);
         int irq = ssi->info->irq;
 
-        rsnd_dma_quit(rsnd_mod_to_dma(mod));
+        rsnd_dma_quit(io, rsnd_mod_to_dma(mod));
 
         /* PIO will request IRQ again */
         devm_free_irq(dev, irq, ssi);
@@ -496,6 +560,7 @@ static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_fallback(struct rsnd_mod *mod,
+                             struct rsnd_dai_stream *io,
                              struct rsnd_priv *priv)
 {
         struct device *dev = rsnd_priv_to_dev(priv);
@@ -516,37 +581,39 @@ static int rsnd_ssi_fallback(struct rsnd_mod *mod,
 }
 
 static int rsnd_ssi_dma_start(struct rsnd_mod *mod,
+                              struct rsnd_dai_stream *io,
                               struct rsnd_priv *priv)
 {
         struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
 
-        rsnd_dma_start(dma);
+        rsnd_dma_start(io, dma);
 
-        rsnd_ssi_start(mod, priv);
+        rsnd_ssi_start(mod, io, priv);
 
         return 0;
 }
 
 static int rsnd_ssi_dma_stop(struct rsnd_mod *mod,
+                             struct rsnd_dai_stream *io,
                              struct rsnd_priv *priv)
 {
         struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
 
-        rsnd_ssi_stop(mod, priv);
+        rsnd_ssi_stop(mod, io, priv);
 
-        rsnd_dma_stop(dma);
+        rsnd_dma_stop(io, dma);
 
         return 0;
 }
 
-static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_mod *mod)
+static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io,
+                                         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);
         char *name;
 
-        if (rsnd_ssi_use_busif(mod))
+        if (rsnd_ssi_use_busif(io, mod))
                 name = is_play ? "rxu" : "txu";
         else
                 name = is_play ? "rx" : "tx";
@@ -565,6 +632,7 @@ static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
         .start  = rsnd_ssi_dma_start,
         .stop   = rsnd_ssi_dma_stop,
         .fallback = rsnd_ssi_fallback,
+        .hw_params = rsnd_ssi_hw_params,
 };
 
 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod)
@@ -598,7 +666,7 @@ int rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod)
         return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE);
 }
 
-static void rsnd_ssi_parent_clk_setup(struct rsnd_priv *priv, struct rsnd_ssi *ssi)
+static void rsnd_ssi_parent_setup(struct rsnd_priv *priv, struct rsnd_ssi *ssi)
 {
         if (!rsnd_ssi_is_pin_sharing(&ssi->mod))
                 return;
@@ -728,11 +796,11 @@ int rsnd_ssi_probe(struct platform_device *pdev,
                 else if (rsnd_ssi_pio_available(ssi))
                         ops = &rsnd_ssi_pio_ops;
 
-                ret = rsnd_mod_init(&ssi->mod, ops, clk, RSND_MOD_SSI, i);
+                ret = rsnd_mod_init(priv, &ssi->mod, ops, clk, RSND_MOD_SSI, i);
                 if (ret)
                         return ret;
 
-                rsnd_ssi_parent_clk_setup(priv, ssi);
+                rsnd_ssi_parent_setup(priv, ssi);
         }
 
         return 0;