Commit | Line | Data |
---|---|---|
a0b03a61 MB |
1 | /* |
2 | * soc-devres.c -- ALSA SoC Audio Layer devres functions | |
3 | * | |
4 | * Copyright (C) 2013 Linaro Ltd | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU General Public License as published by the | |
8 | * Free Software Foundation; either version 2 of the License, or (at your | |
9 | * option) any later version. | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/moduleparam.h> | |
14 | #include <sound/soc.h> | |
21585ee8 | 15 | #include <sound/dmaengine_pcm.h> |
a0b03a61 MB |
16 | |
17 | static void devm_component_release(struct device *dev, void *res) | |
18 | { | |
19 | snd_soc_unregister_component(*(struct device **)res); | |
20 | } | |
21 | ||
22 | /** | |
23 | * devm_snd_soc_register_component - resource managed component registration | |
24 | * @dev: Device used to manage component | |
25 | * @cmpnt_drv: Component driver | |
26 | * @dai_drv: DAI driver | |
27 | * @num_dai: Number of DAIs to register | |
28 | * | |
29 | * Register a component with automatic unregistration when the device is | |
30 | * unregistered. | |
31 | */ | |
32 | int devm_snd_soc_register_component(struct device *dev, | |
33 | const struct snd_soc_component_driver *cmpnt_drv, | |
34 | struct snd_soc_dai_driver *dai_drv, int num_dai) | |
35 | { | |
36 | struct device **ptr; | |
37 | int ret; | |
38 | ||
39 | ptr = devres_alloc(devm_component_release, sizeof(*ptr), GFP_KERNEL); | |
40 | if (!ptr) | |
41 | return -ENOMEM; | |
42 | ||
43 | ret = snd_soc_register_component(dev, cmpnt_drv, dai_drv, num_dai); | |
44 | if (ret == 0) { | |
45 | *ptr = dev; | |
46 | devres_add(dev, ptr); | |
47 | } else { | |
48 | devres_free(ptr); | |
49 | } | |
50 | ||
51 | return ret; | |
52 | } | |
53 | EXPORT_SYMBOL_GPL(devm_snd_soc_register_component); | |
0e4ff5c8 | 54 | |
8931bf62 PU |
55 | static void devm_platform_release(struct device *dev, void *res) |
56 | { | |
57 | snd_soc_unregister_platform(*(struct device **)res); | |
58 | } | |
59 | ||
60 | /** | |
61 | * devm_snd_soc_register_platform - resource managed platform registration | |
62 | * @dev: Device used to manage platform | |
2f1a11e6 | 63 | * @platform_drv: platform to register |
8931bf62 PU |
64 | * |
65 | * Register a platform driver with automatic unregistration when the device is | |
66 | * unregistered. | |
67 | */ | |
68 | int devm_snd_soc_register_platform(struct device *dev, | |
69 | const struct snd_soc_platform_driver *platform_drv) | |
70 | { | |
71 | struct device **ptr; | |
72 | int ret; | |
73 | ||
74 | ptr = devres_alloc(devm_platform_release, sizeof(*ptr), GFP_KERNEL); | |
75 | if (!ptr) | |
76 | return -ENOMEM; | |
77 | ||
78 | ret = snd_soc_register_platform(dev, platform_drv); | |
79 | if (ret == 0) { | |
80 | *ptr = dev; | |
81 | devres_add(dev, ptr); | |
82 | } else { | |
83 | devres_free(ptr); | |
84 | } | |
85 | ||
86 | return ret; | |
87 | } | |
1f23380b | 88 | EXPORT_SYMBOL_GPL(devm_snd_soc_register_platform); |
8931bf62 | 89 | |
0e4ff5c8 MB |
90 | static void devm_card_release(struct device *dev, void *res) |
91 | { | |
92 | snd_soc_unregister_card(*(struct snd_soc_card **)res); | |
93 | } | |
94 | ||
95 | /** | |
96 | * devm_snd_soc_register_card - resource managed card registration | |
97 | * @dev: Device used to manage card | |
98 | * @card: Card to register | |
99 | * | |
100 | * Register a card with automatic unregistration when the device is | |
101 | * unregistered. | |
102 | */ | |
103 | int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card) | |
104 | { | |
ebff6547 | 105 | struct snd_soc_card **ptr; |
0e4ff5c8 MB |
106 | int ret; |
107 | ||
108 | ptr = devres_alloc(devm_card_release, sizeof(*ptr), GFP_KERNEL); | |
109 | if (!ptr) | |
110 | return -ENOMEM; | |
111 | ||
112 | ret = snd_soc_register_card(card); | |
113 | if (ret == 0) { | |
ebff6547 | 114 | *ptr = card; |
0e4ff5c8 MB |
115 | devres_add(dev, ptr); |
116 | } else { | |
117 | devres_free(ptr); | |
118 | } | |
119 | ||
120 | return ret; | |
121 | } | |
122 | EXPORT_SYMBOL_GPL(devm_snd_soc_register_card); | |
21585ee8 LPC |
123 | |
124 | #ifdef CONFIG_SND_SOC_GENERIC_DMAENGINE_PCM | |
125 | ||
126 | static void devm_dmaengine_pcm_release(struct device *dev, void *res) | |
127 | { | |
128 | snd_dmaengine_pcm_unregister(*(struct device **)res); | |
129 | } | |
130 | ||
131 | /** | |
132 | * devm_snd_dmaengine_pcm_register - resource managed dmaengine PCM registration | |
133 | * @dev: The parent device for the PCM device | |
134 | * @config: Platform specific PCM configuration | |
135 | * @flags: Platform specific quirks | |
136 | * | |
137 | * Register a dmaengine based PCM device with automatic unregistration when the | |
138 | * device is unregistered. | |
139 | */ | |
140 | int devm_snd_dmaengine_pcm_register(struct device *dev, | |
141 | const struct snd_dmaengine_pcm_config *config, unsigned int flags) | |
142 | { | |
143 | struct device **ptr; | |
144 | int ret; | |
145 | ||
146 | ptr = devres_alloc(devm_dmaengine_pcm_release, sizeof(*ptr), GFP_KERNEL); | |
147 | if (!ptr) | |
148 | return -ENOMEM; | |
149 | ||
150 | ret = snd_dmaengine_pcm_register(dev, config, flags); | |
151 | if (ret == 0) { | |
152 | *ptr = dev; | |
153 | devres_add(dev, ptr); | |
154 | } else { | |
155 | devres_free(ptr); | |
156 | } | |
157 | ||
158 | return ret; | |
159 | } | |
160 | EXPORT_SYMBOL_GPL(devm_snd_dmaengine_pcm_register); | |
161 | ||
162 | #endif |