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

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

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

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