sound/soc/sh/rcar/dvc.c

   1 /*
   2  * Renesas R-Car DVC support
   3  *
   4  * Copyright (C) 2014 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
  12 /*
  13  * Playback Volume
  14  *      amixer set "DVC Out" 100%
  15  *
  16  * Capture Volume
  17  *      amixer set "DVC In" 100%
  18  *
  19  * Playback Mute
  20  *      amixer set "DVC Out Mute" on
  21  *
  22  * Capture Mute
  23  *      amixer set "DVC In Mute" on
  24  *
  25  * Volume Ramp
  26  *      amixer set "DVC Out Ramp Up Rate"   "0.125 dB/64 steps"
  27  *      amixer set "DVC Out Ramp Down Rate" "0.125 dB/512 steps"
  28  *      amixer set "DVC Out Ramp" on
  29  *      aplay xxx.wav &
  30  *      amixer set "DVC Out"  80%  // Volume Down
  31  *      amixer set "DVC Out" 100%  // Volume Up
  32  */
  33
  34 #include "rsnd.h"
  35
  36 #define RSND_DVC_NAME_SIZE      16
  37
  38 #define DVC_NAME "dvc"
  39
  40 struct rsnd_dvc {
  41         struct rsnd_mod mod;
  42         struct rsnd_kctrl_cfg_m volume;
  43         struct rsnd_kctrl_cfg_m mute;
  44         struct rsnd_kctrl_cfg_s ren;    /* Ramp Enable */
  45         struct rsnd_kctrl_cfg_s rup;    /* Ramp Rate Up */
  46         struct rsnd_kctrl_cfg_s rdown;  /* Ramp Rate Down */
  47 };
  48
  49 #define rsnd_dvc_get(priv, id) ((struct rsnd_dvc *)(priv->dvc) + id)
  50 #define rsnd_dvc_nr(priv) ((priv)->dvc_nr)
  51
  52 #define rsnd_mod_to_dvc(_mod)   \
  53         container_of((_mod), struct rsnd_dvc, mod)
  54
  55 #define for_each_rsnd_dvc(pos, priv, i)                         \
  56         for ((i) = 0;                                           \
  57              ((i) < rsnd_dvc_nr(priv)) &&                       \
  58              ((pos) = (struct rsnd_dvc *)(priv)->dvc + i);      \
  59              i++)
  60
  61 static const char * const dvc_ramp_rate[] = {
  62         "128 dB/1 step",         /* 00000 */
  63         "64 dB/1 step",          /* 00001 */
  64         "32 dB/1 step",          /* 00010 */
  65         "16 dB/1 step",          /* 00011 */
  66         "8 dB/1 step",           /* 00100 */
  67         "4 dB/1 step",           /* 00101 */
  68         "2 dB/1 step",           /* 00110 */
  69         "1 dB/1 step",           /* 00111 */
  70         "0.5 dB/1 step",         /* 01000 */
  71         "0.25 dB/1 step",        /* 01001 */
  72         "0.125 dB/1 step",       /* 01010 */
  73         "0.125 dB/2 steps",      /* 01011 */
  74         "0.125 dB/4 steps",      /* 01100 */
  75         "0.125 dB/8 steps",      /* 01101 */
  76         "0.125 dB/16 steps",     /* 01110 */
  77         "0.125 dB/32 steps",     /* 01111 */
  78         "0.125 dB/64 steps",     /* 10000 */
  79         "0.125 dB/128 steps",    /* 10001 */
  80         "0.125 dB/256 steps",    /* 10010 */
  81         "0.125 dB/512 steps",    /* 10011 */
  82         "0.125 dB/1024 steps",   /* 10100 */
  83         "0.125 dB/2048 steps",   /* 10101 */
  84         "0.125 dB/4096 steps",   /* 10110 */
  85         "0.125 dB/8192 steps",   /* 10111 */
  86 };
  87
  88 static void rsnd_dvc_activation(struct rsnd_mod *mod)
  89 {
  90         rsnd_mod_write(mod, DVC_SWRSR, 0);
  91         rsnd_mod_write(mod, DVC_SWRSR, 1);
  92 }
  93
  94 static void rsnd_dvc_halt(struct rsnd_mod *mod)
  95 {
  96         rsnd_mod_write(mod, DVC_DVUIR, 1);
  97         rsnd_mod_write(mod, DVC_SWRSR, 0);
  98 }
  99
 100 #define rsnd_dvc_get_vrpdr(dvc) (dvc->rup.val << 8 | dvc->rdown.val)
 101 #define rsnd_dvc_get_vrdbr(dvc) (0x3ff - (dvc->volume.val[0] >> 13))
 102
 103 static void rsnd_dvc_volume_parameter(struct rsnd_dai_stream *io,
 104                                               struct rsnd_mod *mod)
 105 {
 106         struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
 107         u32 val[RSND_MAX_CHANNELS];
 108         int i;
 109
 110         /* Enable Ramp */
 111         if (dvc->ren.val)
 112                 for (i = 0; i < RSND_MAX_CHANNELS; i++)
 113                         val[i] = dvc->volume.cfg.max;
 114         else
 115                 for (i = 0; i < RSND_MAX_CHANNELS; i++)
 116                         val[i] = dvc->volume.val[i];
 117
 118         /* Enable Digital Volume */
 119         rsnd_mod_write(mod, DVC_VOL0R, val[0]);
 120         rsnd_mod_write(mod, DVC_VOL1R, val[1]);
 121         rsnd_mod_write(mod, DVC_VOL2R, val[2]);
 122         rsnd_mod_write(mod, DVC_VOL3R, val[3]);
 123         rsnd_mod_write(mod, DVC_VOL4R, val[4]);
 124         rsnd_mod_write(mod, DVC_VOL5R, val[5]);
 125         rsnd_mod_write(mod, DVC_VOL6R, val[6]);
 126         rsnd_mod_write(mod, DVC_VOL7R, val[7]);
 127 }
 128
 129 static void rsnd_dvc_volume_init(struct rsnd_dai_stream *io,
 130                                  struct rsnd_mod *mod)
 131 {
 132         struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
 133         u32 adinr = 0;
 134         u32 dvucr = 0;
 135         u32 vrctr = 0;
 136         u32 vrpdr = 0;
 137         u32 vrdbr = 0;
 138
 139         adinr = rsnd_get_adinr_bit(mod, io) |
 140                 rsnd_runtime_channel_after_ctu(io);
 141
 142         /* Enable Digital Volume, Zero Cross Mute Mode */
 143         dvucr |= 0x101;
 144
 145         /* Enable Ramp */
 146         if (dvc->ren.val) {
 147                 dvucr |= 0x10;
 148
 149                 /*
 150                  * FIXME !!
 151                  * use scale-downed Digital Volume
 152                  * as Volume Ramp
 153                  * 7F FFFF -> 3FF
 154                  */
 155                 vrctr = 0xff;
 156                 vrpdr = rsnd_dvc_get_vrpdr(dvc);
 157                 vrdbr = rsnd_dvc_get_vrdbr(dvc);
 158         }
 159
 160         /* Initialize operation */
 161         rsnd_mod_write(mod, DVC_DVUIR, 1);
 162
 163         /* General Information */
 164         rsnd_mod_write(mod, DVC_ADINR, adinr);
 165         rsnd_mod_write(mod, DVC_DVUCR, dvucr);
 166
 167         /* Volume Ramp Parameter */
 168         rsnd_mod_write(mod, DVC_VRCTR, vrctr);
 169         rsnd_mod_write(mod, DVC_VRPDR, vrpdr);
 170         rsnd_mod_write(mod, DVC_VRDBR, vrdbr);
 171
 172         /* Digital Volume Function Parameter */
 173         rsnd_dvc_volume_parameter(io, mod);
 174
 175         /* cancel operation */
 176         rsnd_mod_write(mod, DVC_DVUIR, 0);
 177 }
 178
 179 static void rsnd_dvc_volume_update(struct rsnd_dai_stream *io,
 180                                    struct rsnd_mod *mod)
 181 {
 182         struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
 183         u32 zcmcr = 0;
 184         u32 vrpdr = 0;
 185         u32 vrdbr = 0;
 186         int i;
 187
 188         for (i = 0; i < dvc->mute.cfg.size; i++)
 189                 zcmcr |= (!!dvc->mute.cfg.val[i]) << i;
 190
 191         if (dvc->ren.val) {
 192                 vrpdr = rsnd_dvc_get_vrpdr(dvc);
 193                 vrdbr = rsnd_dvc_get_vrdbr(dvc);
 194         }
 195
 196         /* Disable DVC Register access */
 197         rsnd_mod_write(mod, DVC_DVUER, 0);
 198
 199         /* Zero Cross Mute Function */
 200         rsnd_mod_write(mod, DVC_ZCMCR, zcmcr);
 201
 202         /* Volume Ramp Function */
 203         rsnd_mod_write(mod, DVC_VRPDR, vrpdr);
 204         rsnd_mod_write(mod, DVC_VRDBR, vrdbr);
 205         /* add DVC_VRWTR here */
 206
 207         /* Digital Volume Function Parameter */
 208         rsnd_dvc_volume_parameter(io, mod);
 209
 210         /* Enable DVC Register access */
 211         rsnd_mod_write(mod, DVC_DVUER, 1);
 212 }
 213
 214 static int rsnd_dvc_probe_(struct rsnd_mod *mod,
 215                            struct rsnd_dai_stream *io,
 216                            struct rsnd_priv *priv)
 217 {
 218         return rsnd_cmd_attach(io, rsnd_mod_id(mod));
 219 }
 220
 221 static int rsnd_dvc_remove_(struct rsnd_mod *mod,
 222                             struct rsnd_dai_stream *io,
 223                             struct rsnd_priv *priv)
 224 {
 225         struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
 226
 227         rsnd_kctrl_remove(dvc->volume);
 228         rsnd_kctrl_remove(dvc->mute);
 229         rsnd_kctrl_remove(dvc->ren);
 230         rsnd_kctrl_remove(dvc->rup);
 231         rsnd_kctrl_remove(dvc->rdown);
 232
 233         return 0;
 234 }
 235
 236 static int rsnd_dvc_init(struct rsnd_mod *mod,
 237                          struct rsnd_dai_stream *io,
 238                          struct rsnd_priv *priv)
 239 {
 240         rsnd_mod_power_on(mod);
 241
 242         rsnd_dvc_activation(mod);
 243
 244         rsnd_dvc_volume_init(io, mod);
 245
 246         rsnd_dvc_volume_update(io, mod);
 247
 248         return 0;
 249 }
 250
 251 static int rsnd_dvc_quit(struct rsnd_mod *mod,
 252                          struct rsnd_dai_stream *io,
 253                          struct rsnd_priv *priv)
 254 {
 255         rsnd_dvc_halt(mod);
 256
 257         rsnd_mod_power_off(mod);
 258
 259         return 0;
 260 }
 261
 262 static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
 263                             struct rsnd_dai_stream *io,
 264                             struct snd_soc_pcm_runtime *rtd)
 265 {
 266         struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
 267         int is_play = rsnd_io_is_play(io);
 268         int slots = rsnd_get_slot(io);
 269         int ret;
 270
 271         /* Volume */
 272         ret = rsnd_kctrl_new_m(mod, io, rtd,
 273                         is_play ?
 274                         "DVC Out Playback Volume" : "DVC In Capture Volume",
 275                         rsnd_dvc_volume_update,
 276                         &dvc->volume, slots,
 277                         0x00800000 - 1);
 278         if (ret < 0)
 279                 return ret;
 280
 281         /* Mute */
 282         ret = rsnd_kctrl_new_m(mod, io, rtd,
 283                         is_play ?
 284                         "DVC Out Mute Switch" : "DVC In Mute Switch",
 285                         rsnd_dvc_volume_update,
 286                         &dvc->mute,  slots,
 287                         1);
 288         if (ret < 0)
 289                 return ret;
 290
 291         /* Ramp */
 292         ret = rsnd_kctrl_new_s(mod, io, rtd,
 293                         is_play ?
 294                         "DVC Out Ramp Switch" : "DVC In Ramp Switch",
 295                         rsnd_dvc_volume_update,
 296                         &dvc->ren, 1);
 297         if (ret < 0)
 298                 return ret;
 299
 300         ret = rsnd_kctrl_new_e(mod, io, rtd,
 301                         is_play ?
 302                         "DVC Out Ramp Up Rate" : "DVC In Ramp Up Rate",
 303                         &dvc->rup,
 304                         rsnd_dvc_volume_update,
 305                         dvc_ramp_rate, ARRAY_SIZE(dvc_ramp_rate));
 306         if (ret < 0)
 307                 return ret;
 308
 309         ret = rsnd_kctrl_new_e(mod, io, rtd,
 310                         is_play ?
 311                         "DVC Out Ramp Down Rate" : "DVC In Ramp Down Rate",
 312                         &dvc->rdown,
 313                         rsnd_dvc_volume_update,
 314                         dvc_ramp_rate, ARRAY_SIZE(dvc_ramp_rate));
 315
 316         if (ret < 0)
 317                 return ret;
 318
 319         return 0;
 320 }
 321
 322 static struct dma_chan *rsnd_dvc_dma_req(struct rsnd_dai_stream *io,
 323                                          struct rsnd_mod *mod)
 324 {
 325         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 326
 327         return rsnd_dma_request_channel(rsnd_dvc_of_node(priv),
 328                                         mod, "tx");
 329 }
 330
 331 static struct rsnd_mod_ops rsnd_dvc_ops = {
 332         .name           = DVC_NAME,
 333         .dma_req        = rsnd_dvc_dma_req,
 334         .probe          = rsnd_dvc_probe_,
 335         .remove         = rsnd_dvc_remove_,
 336         .init           = rsnd_dvc_init,
 337         .quit           = rsnd_dvc_quit,
 338         .pcm_new        = rsnd_dvc_pcm_new,
 339 };
 340
 341 struct rsnd_mod *rsnd_dvc_mod_get(struct rsnd_priv *priv, int id)
 342 {
 343         if (WARN_ON(id < 0 || id >= rsnd_dvc_nr(priv)))
 344                 id = 0;
 345
 346         return rsnd_mod_get(rsnd_dvc_get(priv, id));
 347 }
 348
 349 int rsnd_dvc_probe(struct rsnd_priv *priv)
 350 {
 351         struct device_node *node;
 352         struct device_node *np;
 353         struct device *dev = rsnd_priv_to_dev(priv);
 354         struct rsnd_dvc *dvc;
 355         struct clk *clk;
 356         char name[RSND_DVC_NAME_SIZE];
 357         int i, nr, ret;
 358
 359         /* This driver doesn't support Gen1 at this point */
 360         if (rsnd_is_gen1(priv))
 361                 return 0;
 362
 363         node = rsnd_dvc_of_node(priv);
 364         if (!node)
 365                 return 0; /* not used is not error */
 366
 367         nr = of_get_child_count(node);
 368         if (!nr) {
 369                 ret = -EINVAL;
 370                 goto rsnd_dvc_probe_done;
 371         }
 372
 373         dvc     = devm_kzalloc(dev, sizeof(*dvc) * nr, GFP_KERNEL);
 374         if (!dvc) {
 375                 ret = -ENOMEM;
 376                 goto rsnd_dvc_probe_done;
 377         }
 378
 379         priv->dvc_nr    = nr;
 380         priv->dvc       = dvc;
 381
 382         i = 0;
 383         ret = 0;
 384         for_each_child_of_node(node, np) {
 385                 dvc = rsnd_dvc_get(priv, i);
 386
 387                 snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d",
 388                          DVC_NAME, i);
 389
 390                 clk = devm_clk_get(dev, name);
 391                 if (IS_ERR(clk)) {
 392                         ret = PTR_ERR(clk);
 393                         goto rsnd_dvc_probe_done;
 394                 }
 395
 396                 ret = rsnd_mod_init(priv, rsnd_mod_get(dvc), &rsnd_dvc_ops,
 397                                     clk, rsnd_mod_get_status, RSND_MOD_DVC, i);
 398                 if (ret)
 399                         goto rsnd_dvc_probe_done;
 400
 401                 i++;
 402         }
 403
 404 rsnd_dvc_probe_done:
 405         of_node_put(node);
 406
 407         return ret;
 408 }
 409
 410 void rsnd_dvc_remove(struct rsnd_priv *priv)
 411 {
 412         struct rsnd_dvc *dvc;
 413         int i;
 414
 415         for_each_rsnd_dvc(dvc, priv, i) {
 416                 rsnd_mod_quit(rsnd_mod_get(dvc));
 417         }
 418 }