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

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

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ 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.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0
  2 //
  3 // Renesas R-Car SRC support
  4 //
  5 // Copyright (C) 2013 Renesas Solutions Corp.
  6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
  7 
  8 /*
  9  * you can enable below define if you don't need
 10  * SSI interrupt status debug message when debugging
 11  * see rsnd_dbg_irq_status()
 12  *
 13  * #define RSND_DEBUG_NO_IRQ_STATUS 1
 14  */
 15 
 16 #include "rsnd.h"
 17 
 18 #define SRC_NAME "src"
 19 
 20 /* SCU_SYSTEM_STATUS0/1 */
 21 #define OUF_SRC(id)     ((1 << (id + 16)) | (1 << id))
 22 
 23 struct rsnd_src {
 24         struct rsnd_mod mod;
 25         struct rsnd_mod *dma;
 26         struct rsnd_kctrl_cfg_s sen;  /* sync convert enable */
 27         struct rsnd_kctrl_cfg_s sync; /* sync convert */
 28         int irq;
 29 };
 30 
 31 #define RSND_SRC_NAME_SIZE 16
 32 
 33 #define rsnd_src_get(priv, id) ((struct rsnd_src *)(priv->src) + id)
 34 #define rsnd_src_nr(priv) ((priv)->src_nr)
 35 #define rsnd_src_sync_is_enabled(mod) (rsnd_mod_to_src(mod)->sen.val)
 36 
 37 #define rsnd_mod_to_src(_mod)                           \
 38         container_of((_mod), struct rsnd_src, mod)
 39 
 40 #define for_each_rsnd_src(pos, priv, i)                         \
 41         for ((i) = 0;                                           \
 42              ((i) < rsnd_src_nr(priv)) &&                       \
 43              ((pos) = (struct rsnd_src *)(priv)->src + i);      \
 44              i++)
 45 
 46 
 47 /*
 48  *              image of SRC (Sampling Rate Converter)
 49  *
 50  * 96kHz   <-> +-----+  48kHz   +-----+  48kHz  +-------+
 51  * 48kHz   <-> | SRC | <------> | SSI | <-----> | codec |
 52  * 44.1kHz <-> +-----+          +-----+         +-------+
 53  * ...
 54  *
 55  */
 56 
 57 static void rsnd_src_activation(struct rsnd_mod *mod)
 58 {
 59         rsnd_mod_write(mod, SRC_SWRSR, 0);
 60         rsnd_mod_write(mod, SRC_SWRSR, 1);
 61 }
 62 
 63 static void rsnd_src_halt(struct rsnd_mod *mod)
 64 {
 65         rsnd_mod_write(mod, SRC_SRCIR, 1);
 66         rsnd_mod_write(mod, SRC_SWRSR, 0);
 67 }
 68 
 69 static struct dma_chan *rsnd_src_dma_req(struct rsnd_dai_stream *io,
 70                                          struct rsnd_mod *mod)
 71 {
 72         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 73         int is_play = rsnd_io_is_play(io);
 74 
 75         return rsnd_dma_request_channel(rsnd_src_of_node(priv),
 76                                         mod,
 77                                         is_play ? "rx" : "tx");
 78 }
 79 
 80 static u32 rsnd_src_convert_rate(struct rsnd_dai_stream *io,
 81                                  struct rsnd_mod *mod)
 82 {
 83         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 84         struct rsnd_src *src = rsnd_mod_to_src(mod);
 85         u32 convert_rate;
 86 
 87         if (!runtime)
 88                 return 0;
 89 
 90         if (!rsnd_src_sync_is_enabled(mod))
 91                 return rsnd_io_converted_rate(io);
 92 
 93         convert_rate = src->sync.val;
 94 
 95         if (!convert_rate)
 96                 convert_rate = rsnd_io_converted_rate(io);
 97 
 98         if (!convert_rate)
 99                 convert_rate = runtime->rate;
100 
101         return convert_rate;
102 }
103 
104 unsigned int rsnd_src_get_rate(struct rsnd_priv *priv,
105                                struct rsnd_dai_stream *io,
106                                int is_in)
107 {
108         struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
109         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
110         unsigned int rate = 0;
111         int is_play = rsnd_io_is_play(io);
112 
113         /*
114          * Playback
115          * runtime_rate -> [SRC] -> convert_rate
116          *
117          * Capture
118          * convert_rate -> [SRC] -> runtime_rate
119          */
120 
121         if (is_play == is_in)
122                 return runtime->rate;
123 
124         /*
125          * return convert rate if SRC is used,
126          * otherwise, return runtime->rate as usual
127          */
128         if (src_mod)
129                 rate = rsnd_src_convert_rate(io, src_mod);
130 
131         if (!rate)
132                 rate = runtime->rate;
133 
134         return rate;
135 }
136 
137 static const u32 bsdsr_table_pattern1[] = {
138         0x01800000, /* 6 - 1/6 */
139         0x01000000, /* 6 - 1/4 */
140         0x00c00000, /* 6 - 1/3 */
141         0x00800000, /* 6 - 1/2 */
142         0x00600000, /* 6 - 2/3 */
143         0x00400000, /* 6 - 1   */
144 };
145 
146 static const u32 bsdsr_table_pattern2[] = {
147         0x02400000, /* 6 - 1/6 */
148         0x01800000, /* 6 - 1/4 */
149         0x01200000, /* 6 - 1/3 */
150         0x00c00000, /* 6 - 1/2 */
151         0x00900000, /* 6 - 2/3 */
152         0x00600000, /* 6 - 1   */
153 };
154 
155 static const u32 bsisr_table[] = {
156         0x00100060, /* 6 - 1/6 */
157         0x00100040, /* 6 - 1/4 */
158         0x00100030, /* 6 - 1/3 */
159         0x00100020, /* 6 - 1/2 */
160         0x00100020, /* 6 - 2/3 */
161         0x00100020, /* 6 - 1   */
162 };
163 
164 static const u32 chan288888[] = {
165         0x00000006, /* 1 to 2 */
166         0x000001fe, /* 1 to 8 */
167         0x000001fe, /* 1 to 8 */
168         0x000001fe, /* 1 to 8 */
169         0x000001fe, /* 1 to 8 */
170         0x000001fe, /* 1 to 8 */
171 };
172 
173 static const u32 chan244888[] = {
174         0x00000006, /* 1 to 2 */
175         0x0000001e, /* 1 to 4 */
176         0x0000001e, /* 1 to 4 */
177         0x000001fe, /* 1 to 8 */
178         0x000001fe, /* 1 to 8 */
179         0x000001fe, /* 1 to 8 */
180 };
181 
182 static const u32 chan222222[] = {
183         0x00000006, /* 1 to 2 */
184         0x00000006, /* 1 to 2 */
185         0x00000006, /* 1 to 2 */
186         0x00000006, /* 1 to 2 */
187         0x00000006, /* 1 to 2 */
188         0x00000006, /* 1 to 2 */
189 };
190 
191 static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io,
192                                       struct rsnd_mod *mod)
193 {
194         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
195         struct device *dev = rsnd_priv_to_dev(priv);
196         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
197         int is_play = rsnd_io_is_play(io);
198         int use_src = 0;
199         u32 fin, fout;
200         u32 ifscr, fsrate, adinr;
201         u32 cr, route;
202         u32 i_busif, o_busif, tmp;
203         const u32 *bsdsr_table;
204         const u32 *chptn;
205         uint ratio;
206         int chan;
207         int idx;
208 
209         if (!runtime)
210                 return;
211 
212         fin  = rsnd_src_get_in_rate(priv, io);
213         fout = rsnd_src_get_out_rate(priv, io);
214 
215         chan = rsnd_runtime_channel_original(io);
216 
217         /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
218         if (fin == fout)
219                 ratio = 0;
220         else if (fin > fout)
221                 ratio = 100 * fin / fout;
222         else
223                 ratio = 100 * fout / fin;
224 
225         if (ratio > 600) {
226                 dev_err(dev, "FSO/FSI ratio error\n");
227                 return;
228         }
229 
230         use_src = (fin != fout) | rsnd_src_sync_is_enabled(mod);
231 
232         /*
233          * SRC_ADINR
234          */
235         adinr = rsnd_get_adinr_bit(mod, io) | chan;
236 
237         /*
238          * SRC_IFSCR / SRC_IFSVR
239          */
240         ifscr = 0;
241         fsrate = 0;
242         if (use_src) {
243                 u64 n;
244 
245                 ifscr = 1;
246                 n = (u64)0x0400000 * fin;
247                 do_div(n, fout);
248                 fsrate = n;
249         }
250 
251         /*
252          * SRC_SRCCR / SRC_ROUTE_MODE0
253          */
254         cr      = 0x00011110;
255         route   = 0x0;
256         if (use_src) {
257                 route   = 0x1;
258 
259                 if (rsnd_src_sync_is_enabled(mod)) {
260                         cr |= 0x1;
261                         route |= rsnd_io_is_play(io) ?
262                                 (0x1 << 24) : (0x1 << 25);
263                 }
264         }
265 
266         /*
267          * SRC_BSDSR / SRC_BSISR
268          *
269          * see
270          *      Combination of Register Setting Related to
271          *      FSO/FSI Ratio and Channel, Latency
272          */
273         switch (rsnd_mod_id(mod)) {
274         case 0:
275                 chptn           = chan288888;
276                 bsdsr_table     = bsdsr_table_pattern1;
277                 break;
278         case 1:
279         case 3:
280         case 4:
281                 chptn           = chan244888;
282                 bsdsr_table     = bsdsr_table_pattern1;
283                 break;
284         case 2:
285         case 9:
286                 chptn           = chan222222;
287                 bsdsr_table     = bsdsr_table_pattern1;
288                 break;
289         case 5:
290         case 6:
291         case 7:
292         case 8:
293                 chptn           = chan222222;
294                 bsdsr_table     = bsdsr_table_pattern2;
295                 break;
296         default:
297                 goto convert_rate_err;
298         }
299 
300         /*
301          * E3 need to overwrite
302          */
303         if (rsnd_is_e3(priv))
304                 switch (rsnd_mod_id(mod)) {
305                 case 0:
306                 case 4:
307                         chptn   = chan222222;
308                 }
309 
310         for (idx = 0; idx < ARRAY_SIZE(chan222222); idx++)
311                 if (chptn[idx] & (1 << chan))
312                         break;
313 
314         if (chan > 8 ||
315             idx >= ARRAY_SIZE(chan222222))
316                 goto convert_rate_err;
317 
318         /* BUSIF_MODE */
319         tmp = rsnd_get_busif_shift(io, mod);
320         i_busif = ( is_play ? tmp : 0) | 1;
321         o_busif = (!is_play ? tmp : 0) | 1;
322 
323         rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
324 
325         rsnd_mod_write(mod, SRC_SRCIR, 1);      /* initialize */
326         rsnd_mod_write(mod, SRC_ADINR, adinr);
327         rsnd_mod_write(mod, SRC_IFSCR, ifscr);
328         rsnd_mod_write(mod, SRC_IFSVR, fsrate);
329         rsnd_mod_write(mod, SRC_SRCCR, cr);
330         rsnd_mod_write(mod, SRC_BSDSR, bsdsr_table[idx]);
331         rsnd_mod_write(mod, SRC_BSISR, bsisr_table[idx]);
332         rsnd_mod_write(mod, SRC_SRCIR, 0);      /* cancel initialize */
333 
334         rsnd_mod_write(mod, SRC_I_BUSIF_MODE, i_busif);
335         rsnd_mod_write(mod, SRC_O_BUSIF_MODE, o_busif);
336 
337         rsnd_mod_write(mod, SRC_BUSIF_DALIGN, rsnd_get_dalign(mod, io));
338 
339         rsnd_adg_set_src_timesel_gen2(mod, io, fin, fout);
340 
341         return;
342 
343 convert_rate_err:
344         dev_err(dev, "unknown BSDSR/BSDIR settings\n");
345 }
346 
347 static int rsnd_src_irq(struct rsnd_mod *mod,
348                         struct rsnd_dai_stream *io,
349                         struct rsnd_priv *priv,
350                         int enable)
351 {
352         struct rsnd_src *src = rsnd_mod_to_src(mod);
353         u32 sys_int_val, int_val, sys_int_mask;
354         int irq = src->irq;
355         int id = rsnd_mod_id(mod);
356 
357         sys_int_val =
358         sys_int_mask = OUF_SRC(id);
359         int_val = 0x3300;
360 
361         /*
362          * IRQ is not supported on non-DT
363          * see
364          *      rsnd_src_probe_()
365          */
366         if ((irq <= 0) || !enable) {
367                 sys_int_val = 0;
368                 int_val = 0;
369         }
370 
371         /*
372          * WORKAROUND
373          *
374          * ignore over flow error when rsnd_src_sync_is_enabled()
375          */
376         if (rsnd_src_sync_is_enabled(mod))
377                 sys_int_val = sys_int_val & 0xffff;
378 
379         rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val);
380         rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val);
381         rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);
382 
383         return 0;
384 }
385 
386 static void rsnd_src_status_clear(struct rsnd_mod *mod)
387 {
388         u32 val = OUF_SRC(rsnd_mod_id(mod));
389 
390         rsnd_mod_write(mod, SCU_SYS_STATUS0, val);
391         rsnd_mod_write(mod, SCU_SYS_STATUS1, val);
392 }
393 
394 static bool rsnd_src_error_occurred(struct rsnd_mod *mod)
395 {
396         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
397         struct device *dev = rsnd_priv_to_dev(priv);
398         u32 val0, val1;
399         u32 status0, status1;
400         bool ret = false;
401 
402         val0 = val1 = OUF_SRC(rsnd_mod_id(mod));
403 
404         /*
405          * WORKAROUND
406          *
407          * ignore over flow error when rsnd_src_sync_is_enabled()
408          */
409         if (rsnd_src_sync_is_enabled(mod))
410                 val0 = val0 & 0xffff;
411 
412         status0 = rsnd_mod_read(mod, SCU_SYS_STATUS0);
413         status1 = rsnd_mod_read(mod, SCU_SYS_STATUS1);
414         if ((status0 & val0) || (status1 & val1)) {
415                 rsnd_dbg_irq_status(dev, "%s err status : 0x%08x, 0x%08x\n",
416                         rsnd_mod_name(mod), status0, status1);
417 
418                 ret = true;
419         }
420 
421         return ret;
422 }
423 
424 static int rsnd_src_start(struct rsnd_mod *mod,
425                           struct rsnd_dai_stream *io,
426                           struct rsnd_priv *priv)
427 {
428         u32 val;
429 
430         /*
431          * WORKAROUND
432          *
433          * Enable SRC output if you want to use sync convert together with DVC
434          */
435         val = (rsnd_io_to_mod_dvc(io) && !rsnd_src_sync_is_enabled(mod)) ?
436                 0x01 : 0x11;
437 
438         rsnd_mod_write(mod, SRC_CTRL, val);
439 
440         return 0;
441 }
442 
443 static int rsnd_src_stop(struct rsnd_mod *mod,
444                          struct rsnd_dai_stream *io,
445                          struct rsnd_priv *priv)
446 {
447         rsnd_mod_write(mod, SRC_CTRL, 0);
448 
449         return 0;
450 }
451 
452 static int rsnd_src_init(struct rsnd_mod *mod,
453                          struct rsnd_dai_stream *io,
454                          struct rsnd_priv *priv)
455 {
456         struct rsnd_src *src = rsnd_mod_to_src(mod);
457 
458         /* reset sync convert_rate */
459         src->sync.val = 0;
460 
461         rsnd_mod_power_on(mod);
462 
463         rsnd_src_activation(mod);
464 
465         rsnd_src_set_convert_rate(io, mod);
466 
467         rsnd_src_status_clear(mod);
468 
469         return 0;
470 }
471 
472 static int rsnd_src_quit(struct rsnd_mod *mod,
473                          struct rsnd_dai_stream *io,
474                          struct rsnd_priv *priv)
475 {
476         struct rsnd_src *src = rsnd_mod_to_src(mod);
477 
478         rsnd_src_halt(mod);
479 
480         rsnd_mod_power_off(mod);
481 
482         /* reset sync convert_rate */
483         src->sync.val = 0;
484 
485         return 0;
486 }
487 
488 static void __rsnd_src_interrupt(struct rsnd_mod *mod,
489                                  struct rsnd_dai_stream *io)
490 {
491         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
492         bool stop = false;
493 
494         spin_lock(&priv->lock);
495 
496         /* ignore all cases if not working */
497         if (!rsnd_io_is_working(io))
498                 goto rsnd_src_interrupt_out;
499 
500         if (rsnd_src_error_occurred(mod))
501                 stop = true;
502 
503         rsnd_src_status_clear(mod);
504 rsnd_src_interrupt_out:
505 
506         spin_unlock(&priv->lock);
507 
508         if (stop)
509                 snd_pcm_stop_xrun(io->substream);
510 }
511 
512 static irqreturn_t rsnd_src_interrupt(int irq, void *data)
513 {
514         struct rsnd_mod *mod = data;
515 
516         rsnd_mod_interrupt(mod, __rsnd_src_interrupt);
517 
518         return IRQ_HANDLED;
519 }
520 
521 static int rsnd_src_probe_(struct rsnd_mod *mod,
522                            struct rsnd_dai_stream *io,
523                            struct rsnd_priv *priv)
524 {
525         struct rsnd_src *src = rsnd_mod_to_src(mod);
526         struct device *dev = rsnd_priv_to_dev(priv);
527         int irq = src->irq;
528         int ret;
529 
530         if (irq > 0) {
531                 /*
532                  * IRQ is not supported on non-DT
533                  * see
534                  *      rsnd_src_irq()
535                  */
536                 ret = devm_request_irq(dev, irq,
537                                        rsnd_src_interrupt,
538                                        IRQF_SHARED,
539                                        dev_name(dev), mod);
540                 if (ret)
541                         return ret;
542         }
543 
544         ret = rsnd_dma_attach(io, mod, &src->dma);
545 
546         return ret;
547 }
548 
549 static int rsnd_src_pcm_new(struct rsnd_mod *mod,
550                             struct rsnd_dai_stream *io,
551                             struct snd_soc_pcm_runtime *rtd)
552 {
553         struct rsnd_src *src = rsnd_mod_to_src(mod);
554         int ret;
555 
556         /*
557          * enable SRC sync convert if possible
558          */
559 
560         /*
561          * It can't use SRC Synchronous convert
562          * when Capture if it uses CMD
563          */
564         if (rsnd_io_to_mod_cmd(io) && !rsnd_io_is_play(io))
565                 return 0;
566 
567         /*
568          * enable sync convert
569          */
570         ret = rsnd_kctrl_new_s(mod, io, rtd,
571                                rsnd_io_is_play(io) ?
572                                "SRC Out Rate Switch" :
573                                "SRC In Rate Switch",
574                                rsnd_kctrl_accept_anytime,
575                                rsnd_src_set_convert_rate,
576                                &src->sen, 1);
577         if (ret < 0)
578                 return ret;
579 
580         ret = rsnd_kctrl_new_s(mod, io, rtd,
581                                rsnd_io_is_play(io) ?
582                                "SRC Out Rate" :
583                                "SRC In Rate",
584                                rsnd_kctrl_accept_runtime,
585                                rsnd_src_set_convert_rate,
586                                &src->sync, 192000);
587 
588         return ret;
589 }
590 
591 static struct rsnd_mod_ops rsnd_src_ops = {
592         .name           = SRC_NAME,
593         .dma_req        = rsnd_src_dma_req,
594         .probe          = rsnd_src_probe_,
595         .init           = rsnd_src_init,
596         .quit           = rsnd_src_quit,
597         .start          = rsnd_src_start,
598         .stop           = rsnd_src_stop,
599         .irq            = rsnd_src_irq,
600         .pcm_new        = rsnd_src_pcm_new,
601         .get_status     = rsnd_mod_get_status,
602 };
603 
604 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
605 {
606         if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
607                 id = 0;
608 
609         return rsnd_mod_get(rsnd_src_get(priv, id));
610 }
611 
612 int rsnd_src_probe(struct rsnd_priv *priv)
613 {
614         struct device_node *node;
615         struct device_node *np;
616         struct device *dev = rsnd_priv_to_dev(priv);
617         struct rsnd_src *src;
618         struct clk *clk;
619         char name[RSND_SRC_NAME_SIZE];
620         int i, nr, ret;
621 
622         /* This driver doesn't support Gen1 at this point */
623         if (rsnd_is_gen1(priv))
624                 return 0;
625 
626         node = rsnd_src_of_node(priv);
627         if (!node)
628                 return 0; /* not used is not error */
629 
630         nr = of_get_child_count(node);
631         if (!nr) {
632                 ret = -EINVAL;
633                 goto rsnd_src_probe_done;
634         }
635 
636         src     = devm_kcalloc(dev, nr, sizeof(*src), GFP_KERNEL);
637         if (!src) {
638                 ret = -ENOMEM;
639                 goto rsnd_src_probe_done;
640         }
641 
642         priv->src_nr    = nr;
643         priv->src       = src;
644 
645         i = 0;
646         for_each_child_of_node(node, np) {
647                 if (!of_device_is_available(np))
648                         goto skip;
649 
650                 src = rsnd_src_get(priv, i);
651 
652                 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
653                          SRC_NAME, i);
654 
655                 src->irq = irq_of_parse_and_map(np, 0);
656                 if (!src->irq) {
657                         ret = -EINVAL;
658                         of_node_put(np);
659                         goto rsnd_src_probe_done;
660                 }
661 
662                 clk = devm_clk_get(dev, name);
663                 if (IS_ERR(clk)) {
664                         ret = PTR_ERR(clk);
665                         of_node_put(np);
666                         goto rsnd_src_probe_done;
667                 }
668 
669                 ret = rsnd_mod_init(priv, rsnd_mod_get(src),
670                                     &rsnd_src_ops, clk, RSND_MOD_SRC, i);
671                 if (ret) {
672                         of_node_put(np);
673                         goto rsnd_src_probe_done;
674                 }
675 
676 skip:
677                 i++;
678         }
679 
680         ret = 0;
681 
682 rsnd_src_probe_done:
683         of_node_put(node);
684 
685         return ret;
686 }
687 
688 void rsnd_src_remove(struct rsnd_priv *priv)
689 {
690         struct rsnd_src *src;
691         int i;
692 
693         for_each_rsnd_src(src, priv, i) {
694                 rsnd_mod_quit(rsnd_mod_get(src));
695         }
696 }
697 

~ [ 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