~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/sh/rcar/dvc.c

Version: ~ [ linux-5.6 ] ~ [ linux-5.5.13 ] ~ [ linux-5.4.28 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.113 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp