dvc.c (d1208404dd477c142680437137c9996b95bfd508) dvc.c (5ba17b42e1755c3c5cfe96370cfd47f34d01f62c)
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
17struct rsnd_dvc {
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
17struct 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
18 struct rsnd_mod mod;
19 struct rsnd_kctrl_cfg_m volume;
20 struct rsnd_kctrl_cfg_m mute;
21 struct rsnd_kctrl_cfg_s ren; /* Ramp Enable */
22 struct rsnd_kctrl_cfg_s rup; /* Ramp Rate Up */
23 struct rsnd_kctrl_cfg_s rdown; /* Ramp Rate Down */
24};
25
26#define rsnd_dvc_get(priv, id) ((struct rsnd_dvc *)(priv->dvc) + id)
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) \

--- 24 unchanged lines hidden (view full) ---

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
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) \

--- 24 unchanged lines hidden (view full) ---

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
67static void rsnd_dvc_soft_reset(struct rsnd_mod *mod)
67static void rsnd_dvc_activation(struct rsnd_mod *mod)
68{
69 rsnd_mod_write(mod, DVC_SWRSR, 0);
70 rsnd_mod_write(mod, DVC_SWRSR, 1);
71}
72
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)
75static void __rsnd_dvc_initialize_lock(struct rsnd_mod *mod, u32 enable)
73static void rsnd_dvc_halt(struct rsnd_mod *mod)
76{
74{
77 rsnd_mod_write(mod, DVC_DVUIR, enable);
75 rsnd_mod_write(mod, DVC_DVUIR, 1);
76 rsnd_mod_write(mod, DVC_SWRSR, 0);
78}
79
77}
78
80static void rsnd_dvc_volume_update(struct rsnd_dai_stream *io,
81 struct rsnd_mod *mod)
79#define rsnd_dvc_get_vrpdr(dvc) (dvc->rup.val << 8 | dvc->rdown.val)
80#define rsnd_dvc_get_vrdbr(dvc) (0x3ff - (dvc->volume.val[0] >> 13))
81
82static void rsnd_dvc_volume_parameter(struct rsnd_dai_stream *io,
83 struct rsnd_mod *mod)
82{
83 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
84 u32 val[RSND_DVC_CHANNELS];
84{
85 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
86 u32 val[RSND_DVC_CHANNELS];
85 u32 dvucr = 0;
86 u32 mute = 0;
87 int i;
88
87 int i;
88
89 for (i = 0; i < dvc->mute.cfg.size; i++)
90 mute |= (!!dvc->mute.cfg.val[i]) << i;
89 /* Enable Ramp */
90 if (dvc->ren.val)
91 for (i = 0; i < RSND_DVC_CHANNELS; i++)
92 val[i] = dvc->volume.cfg.max;
93 else
94 for (i = 0; i < RSND_DVC_CHANNELS; i++)
95 val[i] = dvc->volume.val[i];
91
96
92 /* Disable DVC Register access */
93 rsnd_mod_write(mod, DVC_DVUER, 0);
97 /* Enable Digital Volume */
98 rsnd_mod_write(mod, DVC_VOL0R, val[0]);
99 rsnd_mod_write(mod, DVC_VOL1R, val[1]);
100 rsnd_mod_write(mod, DVC_VOL2R, val[2]);
101 rsnd_mod_write(mod, DVC_VOL3R, val[3]);
102 rsnd_mod_write(mod, DVC_VOL4R, val[4]);
103 rsnd_mod_write(mod, DVC_VOL5R, val[5]);
104 rsnd_mod_write(mod, DVC_VOL6R, val[6]);
105 rsnd_mod_write(mod, DVC_VOL7R, val[7]);
106}
94
107
108static void rsnd_dvc_volume_init(struct rsnd_dai_stream *io,
109 struct rsnd_mod *mod)
110{
111 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
112 u32 adinr = 0;
113 u32 dvucr = 0;
114 u32 vrctr = 0;
115 u32 vrpdr = 0;
116 u32 vrdbr = 0;
117
118 adinr = rsnd_get_adinr_bit(mod, io) |
119 rsnd_get_adinr_chan(mod, io);
120
121 /* Enable Digital Volume, Zero Cross Mute Mode */
122 dvucr |= 0x101;
123
95 /* Enable Ramp */
96 if (dvc->ren.val) {
97 dvucr |= 0x10;
98
124 /* Enable Ramp */
125 if (dvc->ren.val) {
126 dvucr |= 0x10;
127
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 */
128 /*
129 * FIXME !!
130 * use scale-downed Digital Volume
131 * as Volume Ramp
132 * 7F FFFF -> 3FF
133 */
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];
134 vrctr = 0xff;
135 vrpdr = rsnd_dvc_get_vrpdr(dvc);
136 vrdbr = rsnd_dvc_get_vrdbr(dvc);
118 }
119
137 }
138
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]);
139 /* Initialize operation */
140 rsnd_mod_write(mod, DVC_DVUIR, 1);
124
141
125 /* Enable Mute */
126 if (mute) {
127 dvucr |= 0x1;
128 rsnd_mod_write(mod, DVC_ZCMCR, mute);
142 /* General Information */
143 rsnd_mod_write(mod, DVC_ADINR, adinr);
144 rsnd_mod_write(mod, DVC_DVUCR, dvucr);
145
146 /* Volume Ramp Parameter */
147 rsnd_mod_write(mod, DVC_VRCTR, vrctr);
148 rsnd_mod_write(mod, DVC_VRPDR, vrpdr);
149 rsnd_mod_write(mod, DVC_VRDBR, vrdbr);
150
151 /* Digital Volume Function Parameter */
152 rsnd_dvc_volume_parameter(io, mod);
153
154 /* cancel operation */
155 rsnd_mod_write(mod, DVC_DVUIR, 0);
156}
157
158static void rsnd_dvc_volume_update(struct rsnd_dai_stream *io,
159 struct rsnd_mod *mod)
160{
161 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
162 u32 zcmcr = 0;
163 u32 vrpdr = 0;
164 u32 vrdbr = 0;
165 int i;
166
167 for (i = 0; i < dvc->mute.cfg.size; i++)
168 zcmcr |= (!!dvc->mute.cfg.val[i]) << i;
169
170 if (dvc->ren.val) {
171 vrpdr = rsnd_dvc_get_vrpdr(dvc);
172 vrdbr = rsnd_dvc_get_vrdbr(dvc);
129 }
130
173 }
174
131 rsnd_mod_write(mod, DVC_DVUCR, dvucr);
175 /* Disable DVC Register access */
176 rsnd_mod_write(mod, DVC_DVUER, 0);
132
177
178 /* Zero Cross Mute Function */
179 rsnd_mod_write(mod, DVC_ZCMCR, zcmcr);
180
181 /* Volume Ramp Function */
182 rsnd_mod_write(mod, DVC_VRPDR, vrpdr);
183 rsnd_mod_write(mod, DVC_VRDBR, vrdbr);
184 /* add DVC_VRWTR here */
185
186 /* Digital Volume Function Parameter */
187 rsnd_dvc_volume_parameter(io, mod);
188
133 /* Enable DVC Register access */
134 rsnd_mod_write(mod, DVC_DVUER, 1);
135}
136
189 /* Enable DVC Register access */
190 rsnd_mod_write(mod, DVC_DVUER, 1);
191}
192
137static int rsnd_dvc_remove_gen2(struct rsnd_mod *mod,
138 struct rsnd_dai_stream *io,
139 struct rsnd_priv *priv)
193static int rsnd_dvc_probe_(struct rsnd_mod *mod,
194 struct rsnd_dai_stream *io,
195 struct rsnd_priv *priv)
140{
196{
197 return rsnd_cmd_attach(io, rsnd_mod_id(mod));
198}
199
200static int rsnd_dvc_remove_(struct rsnd_mod *mod,
201 struct rsnd_dai_stream *io,
202 struct rsnd_priv *priv)
203{
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
152static 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
204 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
205
206 rsnd_kctrl_remove(dvc->volume);
207 rsnd_kctrl_remove(dvc->mute);
208 rsnd_kctrl_remove(dvc->ren);
209 rsnd_kctrl_remove(dvc->rup);
210 rsnd_kctrl_remove(dvc->rdown);
211
212 return 0;
213}
214
215static int rsnd_dvc_init(struct rsnd_mod *mod,
216 struct rsnd_dai_stream *io,
217 struct rsnd_priv *priv)
218{
219 rsnd_mod_power_on(mod);
220
158 rsnd_dvc_soft_reset(mod);
221 rsnd_dvc_activation(mod);
159
222
160 rsnd_dvc_initialize_lock(mod);
223 rsnd_dvc_volume_init(io, mod);
161
224
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
225 rsnd_dvc_volume_update(io, mod);
226
169 rsnd_adg_set_cmd_timsel_gen2(mod, io);
170
171 return 0;
172}
173
174static int rsnd_dvc_quit(struct rsnd_mod *mod,
175 struct rsnd_dai_stream *io,
176 struct rsnd_priv *priv)
177{
227 return 0;
228}
229
230static int rsnd_dvc_quit(struct rsnd_mod *mod,
231 struct rsnd_dai_stream *io,
232 struct rsnd_priv *priv)
233{
234 rsnd_dvc_halt(mod);
235
178 rsnd_mod_power_off(mod);
179
180 return 0;
181}
182
236 rsnd_mod_power_off(mod);
237
238 return 0;
239}
240
183static 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
194static 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
203static 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);
241static int rsnd_dvc_pcm_new(struct rsnd_mod *mod,
242 struct rsnd_dai_stream *io,
243 struct snd_soc_pcm_runtime *rtd)
244{
245 struct rsnd_dvc *dvc = rsnd_mod_to_dvc(mod);
246 int is_play = rsnd_io_is_play(io);
247 int slots = rsnd_get_slot(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,
248 int ret;
249
250 /* Volume */
251 ret = rsnd_kctrl_new_m(mod, io, rtd,
252 is_play ?
253 "DVC Out Playback Volume" : "DVC In Capture Volume",
254 rsnd_dvc_volume_update,
216 &dvc->volume, 0x00800000 - 1);
255 &dvc->volume, slots,
256 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,
257 if (ret < 0)
258 return ret;
259
260 /* Mute */
261 ret = rsnd_kctrl_new_m(mod, io, rtd,
262 is_play ?
263 "DVC Out Mute Switch" : "DVC In Mute Switch",
264 rsnd_dvc_volume_update,
225 &dvc->mute, 1);
265 &dvc->mute, slots,
266 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,

--- 30 unchanged lines hidden (view full) ---

264
265 return rsnd_dma_request_channel(rsnd_dvc_of_node(priv),
266 mod, "tx");
267}
268
269static struct rsnd_mod_ops rsnd_dvc_ops = {
270 .name = DVC_NAME,
271 .dma_req = rsnd_dvc_dma_req,
267 if (ret < 0)
268 return ret;
269
270 /* Ramp */
271 ret = rsnd_kctrl_new_s(mod, io, rtd,
272 is_play ?
273 "DVC Out Ramp Switch" : "DVC In Ramp Switch",
274 rsnd_dvc_volume_update,

--- 30 unchanged lines hidden (view full) ---

305
306 return rsnd_dma_request_channel(rsnd_dvc_of_node(priv),
307 mod, "tx");
308}
309
310static struct rsnd_mod_ops rsnd_dvc_ops = {
311 .name = DVC_NAME,
312 .dma_req = rsnd_dvc_dma_req,
272 .remove = rsnd_dvc_remove_gen2,
313 .probe = rsnd_dvc_probe_,
314 .remove = rsnd_dvc_remove_,
273 .init = rsnd_dvc_init,
274 .quit = rsnd_dvc_quit,
315 .init = rsnd_dvc_init,
316 .quit = rsnd_dvc_quit,
275 .start = rsnd_dvc_start,
276 .stop = rsnd_dvc_stop,
277 .pcm_new = rsnd_dvc_pcm_new,
278};
279
280struct 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
317 .pcm_new = rsnd_dvc_pcm_new,
318};
319
320struct rsnd_mod *rsnd_dvc_mod_get(struct rsnd_priv *priv, int id)
321{
322 if (WARN_ON(id < 0 || id >= rsnd_dvc_nr(priv)))
323 id = 0;
324
285 return rsnd_mod_get((struct rsnd_dvc *)(priv->dvc) + id);
325 return rsnd_mod_get(rsnd_dvc_get(priv, id));
286}
287
326}
327
288static void rsnd_of_parse_dvc(struct platform_device *pdev,
289 const struct rsnd_of_data *of_data,
290 struct rsnd_priv *priv)
328int rsnd_dvc_probe(struct rsnd_priv *priv)
291{
292 struct device_node *node;
329{
330 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
320rsnd_of_parse_dvc_end:
321 of_node_put(node);
322}
323
324int 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);
331 struct device_node *np;
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
332 struct device *dev = rsnd_priv_to_dev(priv);
333 struct rsnd_dvc *dvc;
334 struct clk *clk;
335 char name[RSND_DVC_NAME_SIZE];
336 int i, nr, ret;
337
338 /* This driver doesn't support Gen1 at this point */
339 if (rsnd_is_gen1(priv))
340 return 0;
341
339 rsnd_of_parse_dvc(pdev, of_data, priv);
342 node = rsnd_dvc_of_node(priv);
343 if (!node)
344 return 0; /* not used is not error */
340
345
341 nr = info->dvc_info_nr;
342 if (!nr)
343 return 0;
346 nr = of_get_child_count(node);
347 if (!nr) {
348 ret = -EINVAL;
349 goto rsnd_dvc_probe_done;
350 }
344
345 dvc = devm_kzalloc(dev, sizeof(*dvc) * nr, GFP_KERNEL);
351
352 dvc = devm_kzalloc(dev, sizeof(*dvc) * nr, GFP_KERNEL);
346 if (!dvc)
347 return -ENOMEM;
353 if (!dvc) {
354 ret = -ENOMEM;
355 goto rsnd_dvc_probe_done;
356 }
348
349 priv->dvc_nr = nr;
350 priv->dvc = dvc;
351
357
358 priv->dvc_nr = nr;
359 priv->dvc = dvc;
360
352 for_each_rsnd_dvc(dvc, priv, i) {
361 i = 0;
362 ret = 0;
363 for_each_child_of_node(node, np) {
364 dvc = rsnd_dvc_get(priv, i);
365
353 snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d",
354 DVC_NAME, i);
355
356 clk = devm_clk_get(dev, name);
366 snprintf(name, RSND_DVC_NAME_SIZE, "%s.%d",
367 DVC_NAME, i);
368
369 clk = devm_clk_get(dev, name);
357 if (IS_ERR(clk))
358 return PTR_ERR(clk);
370 if (IS_ERR(clk)) {
371 ret = PTR_ERR(clk);
372 goto rsnd_dvc_probe_done;
373 }
359
374
360 dvc->info = &info->dvc_info[i];
361
362 ret = rsnd_mod_init(priv, rsnd_mod_get(dvc), &rsnd_dvc_ops,
375 ret = rsnd_mod_init(priv, rsnd_mod_get(dvc), &rsnd_dvc_ops,
363 clk, RSND_MOD_DVC, i);
376 clk, rsnd_mod_get_status, RSND_MOD_DVC, i);
364 if (ret)
377 if (ret)
365 return ret;
378 goto rsnd_dvc_probe_done;
379
380 i++;
366 }
367
381 }
382
368 return 0;
383rsnd_dvc_probe_done:
384 of_node_put(node);
385
386 return ret;
369}
370
387}
388
371void rsnd_dvc_remove(struct platform_device *pdev,
372 struct rsnd_priv *priv)
389void rsnd_dvc_remove(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}
390{
391 struct rsnd_dvc *dvc;
392 int i;
393
394 for_each_rsnd_dvc(dvc, priv, i) {
395 rsnd_mod_quit(rsnd_mod_get(dvc));
396 }
397}