tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ASoC: codecs: lpass-rx-macro: Few code cleanups

Merge series from Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>:

Improve a bit the Qualcomm LPASS RX macro driver and align similar parts
of code with LPASS WSA macro driver for consistency.

No external dependencies.

Mark Brown ecaec47b cabf0b0c

+47 -47
+1 -1
include/sound/soc-dapm.h
··· 457 457 int snd_soc_dapm_put_pin_switch(struct snd_kcontrol *kcontrol, 458 458 struct snd_ctl_elem_value *uncontrol); 459 459 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm, 460 - const struct snd_soc_dapm_widget *widget, int num); 460 + const struct snd_soc_dapm_widget *widget, unsigned int num); 461 461 struct snd_soc_dapm_widget *snd_soc_dapm_new_control(struct snd_soc_dapm_context *dapm, 462 462 const struct snd_soc_dapm_widget *widget); 463 463 struct snd_soc_dapm_widget *snd_soc_dapm_new_control_unlocked(struct snd_soc_dapm_context *dapm,
+5
sound/soc/codecs/lpass-macro-common.h
··· 41 41 void lpass_macro_set_codec_version(enum lpass_codec_version version); 42 42 enum lpass_codec_version lpass_macro_get_codec_version(void); 43 43 44 + static inline void lpass_macro_pds_exit_action(void *pds) 45 + { 46 + lpass_macro_pds_exit(pds); 47 + } 48 + 44 49 static inline const char *lpass_macro_get_codec_version_string(int version) 45 50 { 46 51 switch (version) {
+30 -33
sound/soc/codecs/lpass-rx-macro.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 2 // Copyright (c) 2018-2020, The Linux Foundation. All rights reserved. 3 3 4 + #include <linux/cleanup.h> 4 5 #include <linux/module.h> 5 6 #include <linux/init.h> 6 7 #include <linux/io.h> ··· 1663 1662 return rx_is_rw_register(dev, reg); 1664 1663 } 1665 1664 1666 - static struct regmap_config rx_regmap_config = { 1665 + static const struct regmap_config rx_regmap_config = { 1667 1666 .name = "rx_macro", 1668 1667 .reg_bits = 16, 1669 1668 .val_bits = 32, /* 8 but with 32 bit read/write */ ··· 3612 3611 struct rx_macro *rx = snd_soc_component_get_drvdata(component); 3613 3612 const struct snd_soc_dapm_widget *widgets; 3614 3613 const struct snd_kcontrol_new *controls; 3615 - unsigned int num_controls; 3616 - int ret, num_widgets; 3614 + unsigned int num_controls, num_widgets; 3615 + int ret; 3617 3616 3618 3617 snd_soc_component_init_regmap(component, rx->regmap); 3619 3618 ··· 3765 3764 3766 3765 static int rx_macro_probe(struct platform_device *pdev) 3767 3766 { 3768 - struct reg_default *reg_defaults; 3769 3767 struct device *dev = &pdev->dev; 3770 3768 kernel_ulong_t flags; 3771 3769 struct rx_macro *rx; ··· 3803 3803 if (IS_ERR(rx->pds)) 3804 3804 return PTR_ERR(rx->pds); 3805 3805 3806 + ret = devm_add_action_or_reset(dev, lpass_macro_pds_exit_action, rx->pds); 3807 + if (ret) 3808 + return ret; 3809 + 3806 3810 base = devm_platform_ioremap_resource(pdev, 0); 3807 - if (IS_ERR(base)) { 3808 - ret = PTR_ERR(base); 3809 - goto err; 3810 - } 3811 + if (IS_ERR(base)) 3812 + return PTR_ERR(base); 3813 + 3811 3814 rx->codec_version = lpass_macro_get_codec_version(); 3815 + struct reg_default *reg_defaults __free(kfree) = NULL; 3816 + 3812 3817 switch (rx->codec_version) { 3813 3818 case LPASS_CODEC_VERSION_1_0: 3814 3819 case LPASS_CODEC_VERSION_1_1: ··· 3823 3818 rx->rxn_reg_stride = 0x80; 3824 3819 def_count = ARRAY_SIZE(rx_defaults) + ARRAY_SIZE(rx_pre_2_5_defaults); 3825 3820 reg_defaults = kmalloc_array(def_count, sizeof(struct reg_default), GFP_KERNEL); 3826 - if (!reg_defaults) { 3827 - ret = -ENOMEM; 3828 - goto err; 3829 - } 3821 + if (!reg_defaults) 3822 + return -ENOMEM; 3830 3823 memcpy(&reg_defaults[0], rx_defaults, sizeof(rx_defaults)); 3831 3824 memcpy(&reg_defaults[ARRAY_SIZE(rx_defaults)], 3832 3825 rx_pre_2_5_defaults, sizeof(rx_pre_2_5_defaults)); ··· 3836 3833 rx->rxn_reg_stride = 0xc0; 3837 3834 def_count = ARRAY_SIZE(rx_defaults) + ARRAY_SIZE(rx_2_5_defaults); 3838 3835 reg_defaults = kmalloc_array(def_count, sizeof(struct reg_default), GFP_KERNEL); 3839 - if (!reg_defaults) { 3840 - ret = -ENOMEM; 3841 - goto err; 3842 - } 3836 + if (!reg_defaults) 3837 + return -ENOMEM; 3843 3838 memcpy(&reg_defaults[0], rx_defaults, sizeof(rx_defaults)); 3844 3839 memcpy(&reg_defaults[ARRAY_SIZE(rx_defaults)], 3845 3840 rx_2_5_defaults, sizeof(rx_2_5_defaults)); 3846 3841 break; 3847 3842 default: 3848 3843 dev_err(dev, "Unsupported Codec version (%d)\n", rx->codec_version); 3849 - ret = -EINVAL; 3850 - goto err; 3844 + return -EINVAL; 3851 3845 } 3852 3846 3853 - rx_regmap_config.reg_defaults = reg_defaults; 3854 - rx_regmap_config.num_reg_defaults = def_count; 3847 + struct regmap_config *reg_config __free(kfree) = kmemdup(&rx_regmap_config, 3848 + sizeof(*reg_config), 3849 + GFP_KERNEL); 3850 + if (!reg_config) 3851 + return -ENOMEM; 3855 3852 3856 - rx->regmap = devm_regmap_init_mmio(dev, base, &rx_regmap_config); 3857 - if (IS_ERR(rx->regmap)) { 3858 - ret = PTR_ERR(rx->regmap); 3859 - goto err_ver; 3860 - } 3853 + reg_config->reg_defaults = reg_defaults; 3854 + reg_config->num_reg_defaults = def_count; 3855 + 3856 + rx->regmap = devm_regmap_init_mmio(dev, base, reg_config); 3857 + if (IS_ERR(rx->regmap)) 3858 + return PTR_ERR(rx->regmap); 3861 3859 3862 3860 dev_set_drvdata(dev, rx); 3863 3861 ··· 3870 3866 3871 3867 ret = clk_prepare_enable(rx->macro); 3872 3868 if (ret) 3873 - goto err_ver; 3869 + return ret; 3874 3870 3875 3871 ret = clk_prepare_enable(rx->dcodec); 3876 3872 if (ret) ··· 3916 3912 if (ret) 3917 3913 goto err_clkout; 3918 3914 3919 - kfree(reg_defaults); 3920 3915 return 0; 3921 3916 3922 3917 err_clkout: ··· 3928 3925 clk_disable_unprepare(rx->dcodec); 3929 3926 err_dcodec: 3930 3927 clk_disable_unprepare(rx->macro); 3931 - err_ver: 3932 - kfree(reg_defaults); 3933 - err: 3934 - lpass_macro_pds_exit(rx->pds); 3935 3928 3936 3929 return ret; 3937 3930 } ··· 3941 3942 clk_disable_unprepare(rx->fsgen); 3942 3943 clk_disable_unprepare(rx->macro); 3943 3944 clk_disable_unprepare(rx->dcodec); 3944 - 3945 - lpass_macro_pds_exit(rx->pds); 3946 3945 } 3947 3946 3948 3947 static const struct of_device_id rx_macro_dt_match[] = {
+10 -12
sound/soc/codecs/lpass-wsa-macro.c
··· 1 1 // SPDX-License-Identifier: GPL-2.0-only 2 2 // Copyright (c) 2018-2020, The Linux Foundation. All rights reserved. 3 3 4 + #include <linux/cleanup.h> 4 5 #include <linux/module.h> 5 6 #include <linux/init.h> 6 7 #include <linux/io.h> ··· 2726 2725 static int wsa_macro_probe(struct platform_device *pdev) 2727 2726 { 2728 2727 struct device *dev = &pdev->dev; 2729 - struct reg_default *reg_defaults; 2730 - struct regmap_config *reg_config; 2731 2728 struct wsa_macro *wsa; 2732 2729 kernel_ulong_t flags; 2733 2730 void __iomem *base; ··· 2764 2765 return PTR_ERR(base); 2765 2766 2766 2767 wsa->codec_version = lpass_macro_get_codec_version(); 2768 + struct reg_default *reg_defaults __free(kfree) = NULL; 2769 + 2767 2770 switch (wsa->codec_version) { 2768 2771 case LPASS_CODEC_VERSION_1_0: 2769 2772 case LPASS_CODEC_VERSION_1_1: ··· 2774 2773 case LPASS_CODEC_VERSION_2_1: 2775 2774 wsa->reg_layout = &wsa_codec_v2_1; 2776 2775 def_count = ARRAY_SIZE(wsa_defaults) + ARRAY_SIZE(wsa_defaults_v2_1); 2777 - reg_defaults = devm_kmalloc_array(dev, def_count, 2778 - sizeof(*reg_defaults), 2779 - GFP_KERNEL); 2776 + reg_defaults = kmalloc_array(def_count, sizeof(*reg_defaults), 2777 + GFP_KERNEL); 2780 2778 if (!reg_defaults) 2781 2779 return -ENOMEM; 2782 2780 memcpy(&reg_defaults[0], wsa_defaults, sizeof(wsa_defaults)); ··· 2789 2789 case LPASS_CODEC_VERSION_2_8: 2790 2790 wsa->reg_layout = &wsa_codec_v2_5; 2791 2791 def_count = ARRAY_SIZE(wsa_defaults) + ARRAY_SIZE(wsa_defaults_v2_5); 2792 - reg_defaults = devm_kmalloc_array(dev, def_count, 2793 - sizeof(*reg_defaults), 2794 - GFP_KERNEL); 2792 + reg_defaults = kmalloc_array(def_count, sizeof(*reg_defaults), 2793 + GFP_KERNEL); 2795 2794 if (!reg_defaults) 2796 2795 return -ENOMEM; 2797 2796 memcpy(&reg_defaults[0], wsa_defaults, sizeof(wsa_defaults)); ··· 2803 2804 return -EINVAL; 2804 2805 } 2805 2806 2806 - reg_config = devm_kmemdup(dev, &wsa_regmap_config, 2807 - sizeof(*reg_config), GFP_KERNEL); 2807 + struct regmap_config *reg_config __free(kfree) = kmemdup(&wsa_regmap_config, 2808 + sizeof(*reg_config), 2809 + GFP_KERNEL); 2808 2810 if (!reg_config) 2809 2811 return -ENOMEM; 2810 2812 ··· 2816 2816 if (IS_ERR(wsa->regmap)) 2817 2817 return PTR_ERR(wsa->regmap); 2818 2818 2819 - devm_kfree(dev, reg_config); 2820 - devm_kfree(dev, reg_defaults); 2821 2819 dev_set_drvdata(dev, wsa); 2822 2820 2823 2821 wsa->dev = dev;
+1 -1
sound/soc/soc-dapm.c
··· 3857 3857 */ 3858 3858 int snd_soc_dapm_new_controls(struct snd_soc_dapm_context *dapm, 3859 3859 const struct snd_soc_dapm_widget *widget, 3860 - int num) 3860 + unsigned int num) 3861 3861 { 3862 3862 int i; 3863 3863 int ret = 0;