sound/soc/sh/rcar/cmd.c

   1 /*
   2  * Renesas R-Car CMD support
   3  *
   4  * Copyright (C) 2015 Renesas Solutions Corp.
   5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include "rsnd.h"
  12
  13 struct rsnd_cmd {
  14         struct rsnd_mod mod;
  15 };
  16
  17 #define CMD_NAME "cmd"
  18
  19 #define rsnd_cmd_nr(priv) ((priv)->cmd_nr)
  20 #define for_each_rsnd_cmd(pos, priv, i)                                 \
  21         for ((i) = 0;                                                   \
  22              ((i) < rsnd_cmd_nr(priv)) &&                               \
  23                      ((pos) = (struct rsnd_cmd *)(priv)->cmd + i);      \
  24              i++)
  25
  26 static int rsnd_cmd_init(struct rsnd_mod *mod,
  27                          struct rsnd_dai_stream *io,
  28                          struct rsnd_priv *priv)
  29 {
  30         struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);
  31         struct rsnd_mod *mix = rsnd_io_to_mod_mix(io);
  32         struct device *dev = rsnd_priv_to_dev(priv);
  33         u32 data;
  34         u32 path[] = {
  35                 [1] = 1 << 0,
  36                 [5] = 1 << 8,
  37                 [6] = 1 << 12,
  38                 [9] = 1 << 15,
  39         };
  40
  41         if (!mix && !dvc)
  42                 return 0;
  43
  44         if (ARRAY_SIZE(path) < rsnd_mod_id(mod) + 1)
  45                 return -ENXIO;
  46
  47         if (mix) {
  48                 struct rsnd_dai *rdai;
  49                 struct rsnd_mod *src;
  50                 struct rsnd_dai_stream *tio;
  51                 int i;
  52
  53                 /*
  54                  * it is assuming that integrater is well understanding about
  55                  * data path. Here doesn't check impossible connection,
  56                  * like src2 + src5
  57                  */
  58                 data = 0;
  59                 for_each_rsnd_dai(rdai, priv, i) {
  60                         tio = &rdai->playback;
  61                         src = rsnd_io_to_mod_src(tio);
  62                         if (mix == rsnd_io_to_mod_mix(tio))
  63                                 data |= path[rsnd_mod_id(src)];
  64
  65                         tio = &rdai->capture;
  66                         src = rsnd_io_to_mod_src(tio);
  67                         if (mix == rsnd_io_to_mod_mix(tio))
  68                                 data |= path[rsnd_mod_id(src)];
  69                 }
  70
  71         } else {
  72                 struct rsnd_mod *src = rsnd_io_to_mod_src(io);
  73
  74                 u8 cmd_case[] = {
  75                         [0] = 0x3,
  76                         [1] = 0x3,
  77                         [2] = 0x4,
  78                         [3] = 0x1,
  79                         [4] = 0x2,
  80                         [5] = 0x4,
  81                         [6] = 0x1,
  82                         [9] = 0x2,
  83                 };
  84
  85                 if (unlikely(!src))
  86                         return -EIO;
  87
  88                 data = path[rsnd_mod_id(src)] |
  89                         cmd_case[rsnd_mod_id(src)] << 16;
  90         }
  91
  92         dev_dbg(dev, "ctu/mix path = 0x%08x", data);
  93
  94         rsnd_mod_write(mod, CMD_ROUTE_SLCT, data);
  95         rsnd_mod_write(mod, CMD_BUSIF_DALIGN, rsnd_get_dalign(mod, io));
  96
  97         rsnd_adg_set_cmd_timsel_gen2(mod, io);
  98
  99         return 0;
 100 }
 101
 102 static int rsnd_cmd_start(struct rsnd_mod *mod,
 103                           struct rsnd_dai_stream *io,
 104                           struct rsnd_priv *priv)
 105 {
 106         rsnd_mod_write(mod, CMD_CTRL, 0x10);
 107
 108         return 0;
 109 }
 110
 111 static int rsnd_cmd_stop(struct rsnd_mod *mod,
 112                          struct rsnd_dai_stream *io,
 113                          struct rsnd_priv *priv)
 114 {
 115         rsnd_mod_write(mod, CMD_CTRL, 0);
 116
 117         return 0;
 118 }
 119
 120 static struct rsnd_mod_ops rsnd_cmd_ops = {
 121         .name   = CMD_NAME,
 122         .init   = rsnd_cmd_init,
 123         .start  = rsnd_cmd_start,
 124         .stop   = rsnd_cmd_stop,
 125 };
 126
 127 int rsnd_cmd_attach(struct rsnd_dai_stream *io, int id)
 128 {
 129         struct rsnd_priv *priv = rsnd_io_to_priv(io);
 130         struct rsnd_mod *mod = rsnd_cmd_mod_get(priv, id);
 131
 132         return rsnd_dai_connect(mod, io, mod->type);
 133 }
 134
 135 struct rsnd_mod *rsnd_cmd_mod_get(struct rsnd_priv *priv, int id)
 136 {
 137         if (WARN_ON(id < 0 || id >= rsnd_cmd_nr(priv)))
 138                 id = 0;
 139
 140         return rsnd_mod_get((struct rsnd_cmd *)(priv->cmd) + id);
 141 }
 142
 143 int rsnd_cmd_probe(struct rsnd_priv *priv)
 144 {
 145         struct device *dev = rsnd_priv_to_dev(priv);
 146         struct rsnd_cmd *cmd;
 147         int i, nr, ret;
 148
 149         /* This driver doesn't support Gen1 at this point */
 150         if (rsnd_is_gen1(priv))
 151                 return 0;
 152
 153         /* same number as DVC */
 154         nr = priv->dvc_nr;
 155         if (!nr)
 156                 return 0;
 157
 158         cmd = devm_kzalloc(dev, sizeof(*cmd) * nr, GFP_KERNEL);
 159         if (!cmd)
 160                 return -ENOMEM;
 161
 162         priv->cmd_nr    = nr;
 163         priv->cmd       = cmd;
 164
 165         for_each_rsnd_cmd(cmd, priv, i) {
 166                 ret = rsnd_mod_init(priv, rsnd_mod_get(cmd),
 167                                     &rsnd_cmd_ops, NULL,
 168                                     rsnd_mod_get_status, RSND_MOD_CMD, i);
 169                 if (ret)
 170                         return ret;
 171         }
 172
 173         return 0;
 174 }
 175
 176 void rsnd_cmd_remove(struct rsnd_priv *priv)
 177 {
 178         struct rsnd_cmd *cmd;
 179         int i;
 180
 181         for_each_rsnd_cmd(cmd, priv, i) {
 182                 rsnd_mod_quit(rsnd_mod_get(cmd));
 183         }
 184 }