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