An error occurred fetching the project authors.
  1. 09 Nov, 2018 1 commit
    • Kuninori Morimoto's avatar
      ASoC: rsnd: use ring buffer for rsnd_mod_name() · 0246c661
      Kuninori Morimoto authored
      commit c0ea089d ("ASoC: rsnd: rsnd_mod_name() handles both name and
      ID") merged "name" and "ID" on rsnd_mod_name() to handle sub-ID
      (= for CTU/BUSIF).
      Then, it decided to share static char to avoid pointless memory.
      But, it doesn't work correctry in below case, because last called
      name will be used.
      
      	dev_xxx(dev, "%s is connected to %s\n",
      		rsnd_mod_name(mod_a),  /* ssiu[00] */
      		rsnd_mod_name(mod_b)); /* ssi[0]   */
      	->
      	rcar_sound ec500000.sound: ssi[0] is connected to ssi[0]
      	                           ~~~~~~                 ~~~~~~
      We still don't want to have pointless memory, so let's use ring buffer.
      16byte x 5 is very enough for this purpose.
      
      	dev_xxx(dev, "%s is connected to %s\n",
      		rsnd_mod_name(mod_a),  /* ssiu[00] */
      		rsnd_mod_name(mod_b)); /* ssi[0]   */
      	->
      	rcar_sound ec500000.sound: ssiu[00] is connected to ssi[0]
      	                           ~~~~~~~~                 ~~~~~~
      Signed-off-by: default avatarKuninori Morimoto <kuninori.morimoto.gx@renesas.com>
      Signed-off-by: default avatarMark Brown <broonie@kernel.org>
      0246c661
  2. 06 Nov, 2018 6 commits
  3. 05 Nov, 2018 3 commits
  4. 10 Oct, 2018 1 commit
  5. 06 Sep, 2018 1 commit
    • Kuninori Morimoto's avatar
      ASoC: rsnd: don't fallback to PIO mode when -EPROBE_DEFER · 6c92d5a2
      Kuninori Morimoto authored
      Current rsnd driver will fallback to PIO mode if it can't get DMA
      handler. But, DMA might return -EPROBE_DEFER when probe timing.
      This driver always fallback to PIO mode especially from
      commit ac6bbf0c ("iommu: Remove IOMMU_OF_DECLARE") because
      of this reason.
      
      The DMA driver will be probed later, but sound driver might be
      probed as PIO mode in such case. This patch fixup this issue.
      Then, -EPROBE_DEFER is not error. Thus, let's don't indicate error
      message in such case.
      And it needs to call rsnd_adg_remove() individually if probe failed,
      because it registers clk which should be unregister.
      
      Maybe PIO fallback feature itself is not needed,
      but let's keep it so far.
      Signed-off-by: default avatarKuninori Morimoto <kuninori.morimoto.gx@renesas.com>
      Signed-off-by: default avatarMark Brown <broonie@kernel.org>
      6c92d5a2
  6. 03 Sep, 2018 7 commits
  7. 18 Jun, 2018 3 commits
  8. 12 Jun, 2018 1 commit
    • Kees Cook's avatar
      treewide: devm_kzalloc() -> devm_kcalloc() · a86854d0
      Kees Cook authored
      The devm_kzalloc() function has a 2-factor argument form, devm_kcalloc().
      This patch replaces cases of:
      
              devm_kzalloc(handle, a * b, gfp)
      
      with:
              devm_kcalloc(handle, a * b, gfp)
      
      as well as handling cases of:
      
              devm_kzalloc(handle, a * b * c, gfp)
      
      with:
      
              devm_kzalloc(handle, array3_size(a, b, c), gfp)
      
      as it's slightly less ugly than:
      
              devm_kcalloc(handle, array_size(a, b), c, gfp)
      
      This does, however, attempt to ignore constant size factors like:
      
              devm_kzalloc(handle, 4 * 1024, gfp)
      
      though any constants defined via macros get caught up in the conversion.
      
      Any factors with a sizeof() of "unsigned char", "char", and "u8" were
      dropped, since they're redundant.
      
      Some manual whitespace fixes were needed in this patch, as Coccinelle
      really liked to write "=devm_kcalloc..." instead of "= devm_kcalloc...".
      
      The Coccinelle script used for this was:
      
      // Fix redundant parens around sizeof().
      @@
      expression HANDLE;
      type TYPE;
      expression THING, E;
      @@
      
      (
        devm_kzalloc(HANDLE,
      -	(sizeof(TYPE)) * E
      +	sizeof(TYPE) * E
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	(sizeof(THING)) * E
      +	sizeof(THING) * E
        , ...)
      )
      
      // Drop single-byte sizes and redundant parens.
      @@
      expression HANDLE;
      expression COUNT;
      typedef u8;
      typedef __u8;
      @@
      
      (
        devm_kzalloc(HANDLE,
      -	sizeof(u8) * (COUNT)
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(__u8) * (COUNT)
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(char) * (COUNT)
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(unsigned char) * (COUNT)
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(u8) * COUNT
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(__u8) * COUNT
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(char) * COUNT
      +	COUNT
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(unsigned char) * COUNT
      +	COUNT
        , ...)
      )
      
      // 2-factor product with sizeof(type/expression) and identifier or constant.
      @@
      expression HANDLE;
      type TYPE;
      expression THING;
      identifier COUNT_ID;
      constant COUNT_CONST;
      @@
      
      (
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(TYPE) * (COUNT_ID)
      +	COUNT_ID, sizeof(TYPE)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(TYPE) * COUNT_ID
      +	COUNT_ID, sizeof(TYPE)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(TYPE) * (COUNT_CONST)
      +	COUNT_CONST, sizeof(TYPE)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(TYPE) * COUNT_CONST
      +	COUNT_CONST, sizeof(TYPE)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(THING) * (COUNT_ID)
      +	COUNT_ID, sizeof(THING)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(THING) * COUNT_ID
      +	COUNT_ID, sizeof(THING)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(THING) * (COUNT_CONST)
      +	COUNT_CONST, sizeof(THING)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(THING) * COUNT_CONST
      +	COUNT_CONST, sizeof(THING)
        , ...)
      )
      
      // 2-factor product, only identifiers.
      @@
      expression HANDLE;
      identifier SIZE, COUNT;
      @@
      
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	SIZE * COUNT
      +	COUNT, SIZE
        , ...)
      
      // 3-factor product with 1 sizeof(type) or sizeof(expression), with
      // redundant parens removed.
      @@
      expression HANDLE;
      expression THING;
      identifier STRIDE, COUNT;
      type TYPE;
      @@
      
      (
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE) * (COUNT) * (STRIDE)
      +	array3_size(COUNT, STRIDE, sizeof(TYPE))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE) * (COUNT) * STRIDE
      +	array3_size(COUNT, STRIDE, sizeof(TYPE))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE) * COUNT * (STRIDE)
      +	array3_size(COUNT, STRIDE, sizeof(TYPE))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE) * COUNT * STRIDE
      +	array3_size(COUNT, STRIDE, sizeof(TYPE))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(THING) * (COUNT) * (STRIDE)
      +	array3_size(COUNT, STRIDE, sizeof(THING))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(THING) * (COUNT) * STRIDE
      +	array3_size(COUNT, STRIDE, sizeof(THING))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(THING) * COUNT * (STRIDE)
      +	array3_size(COUNT, STRIDE, sizeof(THING))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(THING) * COUNT * STRIDE
      +	array3_size(COUNT, STRIDE, sizeof(THING))
        , ...)
      )
      
      // 3-factor product with 2 sizeof(variable), with redundant parens removed.
      @@
      expression HANDLE;
      expression THING1, THING2;
      identifier COUNT;
      type TYPE1, TYPE2;
      @@
      
      (
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE1) * sizeof(TYPE2) * COUNT
      +	array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE1) * sizeof(THING2) * (COUNT)
      +	array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(THING1) * sizeof(THING2) * COUNT
      +	array3_size(COUNT, sizeof(THING1), sizeof(THING2))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(THING1) * sizeof(THING2) * (COUNT)
      +	array3_size(COUNT, sizeof(THING1), sizeof(THING2))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE1) * sizeof(THING2) * COUNT
      +	array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	sizeof(TYPE1) * sizeof(THING2) * (COUNT)
      +	array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
        , ...)
      )
      
      // 3-factor product, only identifiers, with redundant parens removed.
      @@
      expression HANDLE;
      identifier STRIDE, SIZE, COUNT;
      @@
      
      (
        devm_kzalloc(HANDLE,
      -	(COUNT) * STRIDE * SIZE
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	COUNT * (STRIDE) * SIZE
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	COUNT * STRIDE * (SIZE)
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	(COUNT) * (STRIDE) * SIZE
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	COUNT * (STRIDE) * (SIZE)
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	(COUNT) * STRIDE * (SIZE)
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	(COUNT) * (STRIDE) * (SIZE)
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	COUNT * STRIDE * SIZE
      +	array3_size(COUNT, STRIDE, SIZE)
        , ...)
      )
      
      // Any remaining multi-factor products, first at least 3-factor products,
      // when they're not all constants...
      @@
      expression HANDLE;
      expression E1, E2, E3;
      constant C1, C2, C3;
      @@
      
      (
        devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
      |
        devm_kzalloc(HANDLE,
      -	(E1) * E2 * E3
      +	array3_size(E1, E2, E3)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	(E1) * (E2) * E3
      +	array3_size(E1, E2, E3)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	(E1) * (E2) * (E3)
      +	array3_size(E1, E2, E3)
        , ...)
      |
        devm_kzalloc(HANDLE,
      -	E1 * E2 * E3
      +	array3_size(E1, E2, E3)
        , ...)
      )
      
      // And then all remaining 2 factors products when they're not all constants,
      // keeping sizeof() as the second factor argument.
      @@
      expression HANDLE;
      expression THING, E1, E2;
      type TYPE;
      constant C1, C2, C3;
      @@
      
      (
        devm_kzalloc(HANDLE, sizeof(THING) * C2, ...)
      |
        devm_kzalloc(HANDLE, sizeof(TYPE) * C2, ...)
      |
        devm_kzalloc(HANDLE, C1 * C2 * C3, ...)
      |
        devm_kzalloc(HANDLE, C1 * C2, ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(TYPE) * (E2)
      +	E2, sizeof(TYPE)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(TYPE) * E2
      +	E2, sizeof(TYPE)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(THING) * (E2)
      +	E2, sizeof(THING)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	sizeof(THING) * E2
      +	E2, sizeof(THING)
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	(E1) * E2
      +	E1, E2
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	(E1) * (E2)
      +	E1, E2
        , ...)
      |
      - devm_kzalloc
      + devm_kcalloc
        (HANDLE,
      -	E1 * E2
      +	E1, E2
        , ...)
      )
      Signed-off-by: default avatarKees Cook <keescook@chromium.org>
      a86854d0
  9. 16 Apr, 2018 2 commits
  10. 12 Apr, 2018 1 commit
    • Arnd Bergmann's avatar
      ASoC: rsnd: mark PM functions __maybe_unused · 6f542703
      Arnd Bergmann authored
      The suspend/resume callbacks are now optional, leading to a warning
      when they are unused:
      
      sound/soc/sh/rcar/core.c:1548:12: error: 'rsnd_resume' defined but not used [-Werror=unused-function]
       static int rsnd_resume(struct device *dev)
                  ^~~~~~~~~~~
      sound/soc/sh/rcar/core.c:1539:12: error: 'rsnd_suspend' defined but not used [-Werror=unused-function]
       static int rsnd_suspend(struct device *dev)
      
      This marks the as __maybe_unused to avoid the warning.
      
      Fixes: f8a9a29c ("ASoC: rsnd: set pm_ops in hibernate-compatible way")
      Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
      Signed-off-by: default avatarMark Brown <broonie@kernel.org>
      6f542703
  11. 21 Mar, 2018 1 commit
  12. 13 Feb, 2018 1 commit
  13. 12 Feb, 2018 1 commit
  14. 11 Dec, 2017 2 commits
  15. 08 Dec, 2017 1 commit
  16. 29 Nov, 2017 1 commit
  17. 28 Nov, 2017 1 commit
  18. 16 Nov, 2017 1 commit
  19. 01 Nov, 2017 1 commit
    • Kuninori Morimoto's avatar
      ASoC: rsnd: remove NULL check from rsnd_mod_name()/rsnd_mod_id() · 9b6ea250
      Kuninori Morimoto authored
      Current rsnd driver has rsnd_mod_id() which returns mod ID,
      and it returns -1 if mod was NULL.
      In the same time, this driver has rsnd_mod_name() which returns mod
      name, and it returns "unknown" if mod or mod->ops was NULL.
      
      Basically these "mod" never be NULL, but the reason why rsnd driver
      has such behavior is that DMA path finder is assuming memory as
      "mod == NULL".
      Thus, current DMA path debug code prints like below.
      Here "unknown[-1]" means it was memory.
      
      	...
      	rcar_sound ec500000.sound:   unknown[-1] from
      	rcar_sound ec500000.sound:   src[0] to
      	rcar_sound ec500000.sound:   ctu[2]
      	rcar_sound ec500000.sound:   mix[0]
      	rcar_sound ec500000.sound:   dvc[0]
      	rcar_sound ec500000.sound:   ssi[0]
      	rcar_sound ec500000.sound: audmac[0] unknown[-1] -> src[0]
      	...
      
      1st issue is that it is confusable for user.
      2nd issue is rsnd driver has something like below code.
      
      	mask |= 1 << rsnd_mod_id(mod);
      
      Because of this kind of code, some statically code checker will
      reports "Shifting by a negative value is undefined behaviour".
      
      But this "mod" never be NULL, thus negative shift never happen.
      To avoid these issues, this patch adds new dummy "mem" to
      indicate memory, and use it to indicate debug information,
      and, remove unneeded "NULL mod" behavior from rsnd_mod_id() and
      rsnd_mod_name().
      
      The debug information will be like below by this patch
      	...
      	rcar_sound ec500000.sound:   mem[0] from
      	rcar_sound ec500000.sound:   src[0] to
      	rcar_sound ec500000.sound:   ctu[2]
      	rcar_sound ec500000.sound:   mix[0]
      	rcar_sound ec500000.sound:   dvc[0]
      	rcar_sound ec500000.sound:   ssi[0]
      	rcar_sound ec500000.sound: audmac[0] mem[0] -> src[0]
      	...
      Reported-by: default avatarHiroyuki Yokoyama <hiroyuki.yokoyama.vx@renesas.com>
      Signed-off-by: default avatarKuninori Morimoto <kuninori.morimoto.gx@renesas.com>
      Signed-off-by: default avatarMark Brown <broonie@kernel.org>
      9b6ea250
  20. 31 Oct, 2017 4 commits