sound/soc/sh/rcar/ctu.c

   1 /*
   2  * ctu.c
   3  *
   4  * Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10 #include "rsnd.h"
  11
  12 #define CTU_NAME_SIZE   16
  13 #define CTU_NAME "ctu"
  14
  15 struct rsnd_ctu {
  16         struct rsnd_mod mod;
  17 };
  18
  19 #define rsnd_ctu_nr(priv) ((priv)->ctu_nr)
  20 #define for_each_rsnd_ctu(pos, priv, i)                                 \
  21         for ((i) = 0;                                                   \
  22              ((i) < rsnd_ctu_nr(priv)) &&                               \
  23                      ((pos) = (struct rsnd_ctu *)(priv)->ctu + i);      \
  24              i++)
  25
  26 #define rsnd_ctu_get(priv, id) ((struct rsnd_ctu *)(priv->ctu) + id)
  27
  28 static void rsnd_ctu_activation(struct rsnd_mod *mod)
  29 {
  30         rsnd_mod_write(mod, CTU_SWRSR, 0);
  31         rsnd_mod_write(mod, CTU_SWRSR, 1);
  32 }
  33
  34 static void rsnd_ctu_halt(struct rsnd_mod *mod)
  35 {
  36         rsnd_mod_write(mod, CTU_CTUIR, 1);
  37         rsnd_mod_write(mod, CTU_SWRSR, 0);
  38 }
  39
  40 static int rsnd_ctu_probe_(struct rsnd_mod *mod,
  41                            struct rsnd_dai_stream *io,
  42                            struct rsnd_priv *priv)
  43 {
  44         return rsnd_cmd_attach(io, rsnd_mod_id(mod) / 4);
  45 }
  46
  47 static void rsnd_ctu_value_init(struct rsnd_dai_stream *io,
  48                                struct rsnd_mod *mod)
  49 {
  50         rsnd_mod_write(mod, CTU_CTUIR, 1);
  51
  52         rsnd_mod_write(mod, CTU_ADINR, rsnd_get_adinr_chan(mod, io));
  53
  54         rsnd_mod_write(mod, CTU_CPMDR, 0);
  55         rsnd_mod_write(mod, CTU_SCMDR, 0);
  56         rsnd_mod_write(mod, CTU_SV00R, 0);
  57         rsnd_mod_write(mod, CTU_SV01R, 0);
  58         rsnd_mod_write(mod, CTU_SV02R, 0);
  59         rsnd_mod_write(mod, CTU_SV03R, 0);
  60         rsnd_mod_write(mod, CTU_SV04R, 0);
  61         rsnd_mod_write(mod, CTU_SV05R, 0);
  62         rsnd_mod_write(mod, CTU_SV06R, 0);
  63         rsnd_mod_write(mod, CTU_SV07R, 0);
  64
  65         rsnd_mod_write(mod, CTU_SV10R, 0);
  66         rsnd_mod_write(mod, CTU_SV11R, 0);
  67         rsnd_mod_write(mod, CTU_SV12R, 0);
  68         rsnd_mod_write(mod, CTU_SV13R, 0);
  69         rsnd_mod_write(mod, CTU_SV14R, 0);
  70         rsnd_mod_write(mod, CTU_SV15R, 0);
  71         rsnd_mod_write(mod, CTU_SV16R, 0);
  72         rsnd_mod_write(mod, CTU_SV17R, 0);
  73
  74         rsnd_mod_write(mod, CTU_SV20R, 0);
  75         rsnd_mod_write(mod, CTU_SV21R, 0);
  76         rsnd_mod_write(mod, CTU_SV22R, 0);
  77         rsnd_mod_write(mod, CTU_SV23R, 0);
  78         rsnd_mod_write(mod, CTU_SV24R, 0);
  79         rsnd_mod_write(mod, CTU_SV25R, 0);
  80         rsnd_mod_write(mod, CTU_SV26R, 0);
  81         rsnd_mod_write(mod, CTU_SV27R, 0);
  82
  83         rsnd_mod_write(mod, CTU_SV30R, 0);
  84         rsnd_mod_write(mod, CTU_SV31R, 0);
  85         rsnd_mod_write(mod, CTU_SV32R, 0);
  86         rsnd_mod_write(mod, CTU_SV33R, 0);
  87         rsnd_mod_write(mod, CTU_SV34R, 0);
  88         rsnd_mod_write(mod, CTU_SV35R, 0);
  89         rsnd_mod_write(mod, CTU_SV36R, 0);
  90         rsnd_mod_write(mod, CTU_SV37R, 0);
  91
  92         rsnd_mod_write(mod, CTU_CTUIR, 0);
  93 }
  94
  95 static int rsnd_ctu_init(struct rsnd_mod *mod,
  96                          struct rsnd_dai_stream *io,
  97                          struct rsnd_priv *priv)
  98 {
  99         rsnd_mod_power_on(mod);
 100
 101         rsnd_ctu_activation(mod);
 102
 103         rsnd_ctu_value_init(io, mod);
 104
 105         return 0;
 106 }
 107
 108 static int rsnd_ctu_quit(struct rsnd_mod *mod,
 109                          struct rsnd_dai_stream *io,
 110                          struct rsnd_priv *priv)
 111 {
 112         rsnd_ctu_halt(mod);
 113
 114         rsnd_mod_power_off(mod);
 115
 116         return 0;
 117 }
 118
 119 static struct rsnd_mod_ops rsnd_ctu_ops = {
 120         .name           = CTU_NAME,
 121         .probe          = rsnd_ctu_probe_,
 122         .init           = rsnd_ctu_init,
 123         .quit           = rsnd_ctu_quit,
 124 };
 125
 126 struct rsnd_mod *rsnd_ctu_mod_get(struct rsnd_priv *priv, int id)
 127 {
 128         if (WARN_ON(id < 0 || id >= rsnd_ctu_nr(priv)))
 129                 id = 0;
 130
 131         return rsnd_mod_get(rsnd_ctu_get(priv, id));
 132 }
 133
 134 int rsnd_ctu_probe(struct rsnd_priv *priv)
 135 {
 136         struct device_node *node;
 137         struct device_node *np;
 138         struct device *dev = rsnd_priv_to_dev(priv);
 139         struct rsnd_ctu *ctu;
 140         struct clk *clk;
 141         char name[CTU_NAME_SIZE];
 142         int i, nr, ret;
 143
 144         /* This driver doesn't support Gen1 at this point */
 145         if (rsnd_is_gen1(priv))
 146                 return 0;
 147
 148         node = rsnd_ctu_of_node(priv);
 149         if (!node)
 150                 return 0; /* not used is not error */
 151
 152         nr = of_get_child_count(node);
 153         if (!nr) {
 154                 ret = -EINVAL;
 155                 goto rsnd_ctu_probe_done;
 156         }
 157
 158         ctu = devm_kzalloc(dev, sizeof(*ctu) * nr, GFP_KERNEL);
 159         if (!ctu) {
 160                 ret = -ENOMEM;
 161                 goto rsnd_ctu_probe_done;
 162         }
 163
 164         priv->ctu_nr    = nr;
 165         priv->ctu       = ctu;
 166
 167         i = 0;
 168         ret = 0;
 169         for_each_child_of_node(node, np) {
 170                 ctu = rsnd_ctu_get(priv, i);
 171
 172                 /*
 173                  * CTU00, CTU01, CTU02, CTU03 => CTU0
 174                  * CTU10, CTU11, CTU12, CTU13 => CTU1
 175                  */
 176                 snprintf(name, CTU_NAME_SIZE, "%s.%d",
 177                          CTU_NAME, i / 4);
 178
 179                 clk = devm_clk_get(dev, name);
 180                 if (IS_ERR(clk)) {
 181                         ret = PTR_ERR(clk);
 182                         goto rsnd_ctu_probe_done;
 183                 }
 184
 185                 ret = rsnd_mod_init(priv, rsnd_mod_get(ctu), &rsnd_ctu_ops,
 186                                     clk, rsnd_mod_get_status, RSND_MOD_CTU, i);
 187                 if (ret)
 188                         goto rsnd_ctu_probe_done;
 189
 190                 i++;
 191         }
 192
 193
 194 rsnd_ctu_probe_done:
 195         of_node_put(node);
 196
 197         return ret;
 198 }
 199
 200 void rsnd_ctu_remove(struct rsnd_priv *priv)
 201 {
 202         struct rsnd_ctu *ctu;
 203         int i;
 204
 205         for_each_rsnd_ctu(ctu, priv, i) {
 206                 rsnd_mod_quit(rsnd_mod_get(ctu));
 207         }
 208 }