Loading...
1// SPDX-License-Identifier: GPL-2.0
2//
3// soc-card.c
4//
5// Copyright (C) 2019 Renesas Electronics Corp.
6// Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7//
8
9#include <linux/lockdep.h>
10#include <linux/rwsem.h>
11#include <sound/soc.h>
12#include <sound/jack.h>
13
14#define soc_card_ret(dai, ret) _soc_card_ret(dai, __func__, ret)
15static inline int _soc_card_ret(struct snd_soc_card *card,
16 const char *func, int ret)
17{
18 switch (ret) {
19 case -EPROBE_DEFER:
20 case -ENOTSUPP:
21 case 0:
22 break;
23 default:
24 dev_err(card->dev,
25 "ASoC: error at %s on %s: %d\n",
26 func, card->name, ret);
27 }
28
29 return ret;
30}
31
32struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
33 const char *name)
34{
35 if (unlikely(!name))
36 return NULL;
37
38 return snd_ctl_find_id_mixer(soc_card->snd_card, name);
39}
40EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
41
42static int jack_new(struct snd_soc_card *card, const char *id, int type,
43 struct snd_soc_jack *jack, bool initial_kctl)
44{
45 mutex_init(&jack->mutex);
46 jack->card = card;
47 INIT_LIST_HEAD(&jack->pins);
48 INIT_LIST_HEAD(&jack->jack_zones);
49 BLOCKING_INIT_NOTIFIER_HEAD(&jack->notifier);
50
51 return snd_jack_new(card->snd_card, id, type, &jack->jack, initial_kctl, false);
52}
53
54/**
55 * snd_soc_card_jack_new - Create a new jack without pins
56 * @card: ASoC card
57 * @id: an identifying string for this jack
58 * @type: a bitmask of enum snd_jack_type values that can be detected by
59 * this jack
60 * @jack: structure to use for the jack
61 *
62 * Creates a new jack object without pins. If adding pins later,
63 * snd_soc_card_jack_new_pins() should be used instead with 0 as num_pins
64 * argument.
65 *
66 * Returns zero if successful, or a negative error code on failure.
67 * On success jack will be initialised.
68 */
69int snd_soc_card_jack_new(struct snd_soc_card *card, const char *id, int type,
70 struct snd_soc_jack *jack)
71{
72 return soc_card_ret(card, jack_new(card, id, type, jack, true));
73}
74EXPORT_SYMBOL_GPL(snd_soc_card_jack_new);
75
76/**
77 * snd_soc_card_jack_new_pins - Create a new jack with pins
78 * @card: ASoC card
79 * @id: an identifying string for this jack
80 * @type: a bitmask of enum snd_jack_type values that can be detected by
81 * this jack
82 * @jack: structure to use for the jack
83 * @pins: Array of jack pins to be added to the jack or NULL
84 * @num_pins: Number of elements in the @pins array
85 *
86 * Creates a new jack object with pins. If not adding pins,
87 * snd_soc_card_jack_new() should be used instead.
88 *
89 * Returns zero if successful, or a negative error code on failure.
90 * On success jack will be initialised.
91 */
92int snd_soc_card_jack_new_pins(struct snd_soc_card *card, const char *id,
93 int type, struct snd_soc_jack *jack,
94 struct snd_soc_jack_pin *pins,
95 unsigned int num_pins)
96{
97 int ret;
98
99 ret = jack_new(card, id, type, jack, false);
100 if (ret)
101 goto end;
102
103 if (num_pins)
104 ret = snd_soc_jack_add_pins(jack, num_pins, pins);
105end:
106 return soc_card_ret(card, ret);
107}
108EXPORT_SYMBOL_GPL(snd_soc_card_jack_new_pins);
109
110int snd_soc_card_suspend_pre(struct snd_soc_card *card)
111{
112 int ret = 0;
113
114 if (card->suspend_pre)
115 ret = card->suspend_pre(card);
116
117 return soc_card_ret(card, ret);
118}
119
120int snd_soc_card_suspend_post(struct snd_soc_card *card)
121{
122 int ret = 0;
123
124 if (card->suspend_post)
125 ret = card->suspend_post(card);
126
127 return soc_card_ret(card, ret);
128}
129
130int snd_soc_card_resume_pre(struct snd_soc_card *card)
131{
132 int ret = 0;
133
134 if (card->resume_pre)
135 ret = card->resume_pre(card);
136
137 return soc_card_ret(card, ret);
138}
139
140int snd_soc_card_resume_post(struct snd_soc_card *card)
141{
142 int ret = 0;
143
144 if (card->resume_post)
145 ret = card->resume_post(card);
146
147 return soc_card_ret(card, ret);
148}
149
150int snd_soc_card_probe(struct snd_soc_card *card)
151{
152 if (card->probe) {
153 int ret = card->probe(card);
154
155 if (ret < 0)
156 return soc_card_ret(card, ret);
157
158 /*
159 * It has "card->probe" and "card->late_probe" callbacks.
160 * So, set "probed" flag here, because it needs to care
161 * about "late_probe".
162 *
163 * see
164 * snd_soc_bind_card()
165 * snd_soc_card_late_probe()
166 */
167 card->probed = 1;
168 }
169
170 return 0;
171}
172
173int snd_soc_card_late_probe(struct snd_soc_card *card)
174{
175 if (card->late_probe) {
176 int ret = card->late_probe(card);
177
178 if (ret < 0)
179 return soc_card_ret(card, ret);
180 }
181
182 /*
183 * It has "card->probe" and "card->late_probe" callbacks,
184 * and "late_probe" callback is called after "probe".
185 * This means, we can set "card->probed" flag afer "late_probe"
186 * for all cases.
187 *
188 * see
189 * snd_soc_bind_card()
190 * snd_soc_card_probe()
191 */
192 card->probed = 1;
193
194 return 0;
195}
196
197void snd_soc_card_fixup_controls(struct snd_soc_card *card)
198{
199 if (card->fixup_controls)
200 card->fixup_controls(card);
201}
202
203int snd_soc_card_remove(struct snd_soc_card *card)
204{
205 int ret = 0;
206
207 if (card->probed &&
208 card->remove)
209 ret = card->remove(card);
210
211 card->probed = 0;
212
213 return soc_card_ret(card, ret);
214}
215
216int snd_soc_card_set_bias_level(struct snd_soc_card *card,
217 struct snd_soc_dapm_context *dapm,
218 enum snd_soc_bias_level level)
219{
220 int ret = 0;
221
222 if (card && card->set_bias_level)
223 ret = card->set_bias_level(card, dapm, level);
224
225 return soc_card_ret(card, ret);
226}
227
228int snd_soc_card_set_bias_level_post(struct snd_soc_card *card,
229 struct snd_soc_dapm_context *dapm,
230 enum snd_soc_bias_level level)
231{
232 int ret = 0;
233
234 if (card && card->set_bias_level_post)
235 ret = card->set_bias_level_post(card, dapm, level);
236
237 return soc_card_ret(card, ret);
238}
239
240int snd_soc_card_add_dai_link(struct snd_soc_card *card,
241 struct snd_soc_dai_link *dai_link)
242{
243 int ret = 0;
244
245 if (card->add_dai_link)
246 ret = card->add_dai_link(card, dai_link);
247
248 return soc_card_ret(card, ret);
249}
250EXPORT_SYMBOL_GPL(snd_soc_card_add_dai_link);
251
252void snd_soc_card_remove_dai_link(struct snd_soc_card *card,
253 struct snd_soc_dai_link *dai_link)
254{
255 if (card->remove_dai_link)
256 card->remove_dai_link(card, dai_link);
257}
258EXPORT_SYMBOL_GPL(snd_soc_card_remove_dai_link);
1// SPDX-License-Identifier: GPL-2.0
2//
3// soc-card.c
4//
5// Copyright (C) 2019 Renesas Electronics Corp.
6// Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7//
8
9#include <linux/lockdep.h>
10#include <linux/rwsem.h>
11#include <sound/soc.h>
12#include <sound/jack.h>
13
14#define soc_card_ret(dai, ret) _soc_card_ret(dai, __func__, ret)
15static inline int _soc_card_ret(struct snd_soc_card *card,
16 const char *func, int ret)
17{
18 switch (ret) {
19 case -EPROBE_DEFER:
20 case -ENOTSUPP:
21 case 0:
22 break;
23 default:
24 dev_err(card->dev,
25 "ASoC: error at %s on %s: %d\n",
26 func, card->name, ret);
27 }
28
29 return ret;
30}
31
32struct snd_kcontrol *snd_soc_card_get_kcontrol_locked(struct snd_soc_card *soc_card,
33 const char *name)
34{
35 struct snd_card *card = soc_card->snd_card;
36 struct snd_kcontrol *kctl;
37
38 /* must be held read or write */
39 lockdep_assert_held(&card->controls_rwsem);
40
41 if (unlikely(!name))
42 return NULL;
43
44 list_for_each_entry(kctl, &card->controls, list)
45 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
46 return kctl;
47 return NULL;
48}
49EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol_locked);
50
51struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
52 const char *name)
53{
54 struct snd_card *card = soc_card->snd_card;
55 struct snd_kcontrol *kctl;
56
57 down_read(&card->controls_rwsem);
58 kctl = snd_soc_card_get_kcontrol_locked(soc_card, name);
59 up_read(&card->controls_rwsem);
60
61 return kctl;
62}
63EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
64
65static int jack_new(struct snd_soc_card *card, const char *id, int type,
66 struct snd_soc_jack *jack, bool initial_kctl)
67{
68 mutex_init(&jack->mutex);
69 jack->card = card;
70 INIT_LIST_HEAD(&jack->pins);
71 INIT_LIST_HEAD(&jack->jack_zones);
72 BLOCKING_INIT_NOTIFIER_HEAD(&jack->notifier);
73
74 return snd_jack_new(card->snd_card, id, type, &jack->jack, initial_kctl, false);
75}
76
77/**
78 * snd_soc_card_jack_new - Create a new jack without pins
79 * @card: ASoC card
80 * @id: an identifying string for this jack
81 * @type: a bitmask of enum snd_jack_type values that can be detected by
82 * this jack
83 * @jack: structure to use for the jack
84 *
85 * Creates a new jack object without pins. If adding pins later,
86 * snd_soc_card_jack_new_pins() should be used instead with 0 as num_pins
87 * argument.
88 *
89 * Returns zero if successful, or a negative error code on failure.
90 * On success jack will be initialised.
91 */
92int snd_soc_card_jack_new(struct snd_soc_card *card, const char *id, int type,
93 struct snd_soc_jack *jack)
94{
95 return soc_card_ret(card, jack_new(card, id, type, jack, true));
96}
97EXPORT_SYMBOL_GPL(snd_soc_card_jack_new);
98
99/**
100 * snd_soc_card_jack_new_pins - Create a new jack with pins
101 * @card: ASoC card
102 * @id: an identifying string for this jack
103 * @type: a bitmask of enum snd_jack_type values that can be detected by
104 * this jack
105 * @jack: structure to use for the jack
106 * @pins: Array of jack pins to be added to the jack or NULL
107 * @num_pins: Number of elements in the @pins array
108 *
109 * Creates a new jack object with pins. If not adding pins,
110 * snd_soc_card_jack_new() should be used instead.
111 *
112 * Returns zero if successful, or a negative error code on failure.
113 * On success jack will be initialised.
114 */
115int snd_soc_card_jack_new_pins(struct snd_soc_card *card, const char *id,
116 int type, struct snd_soc_jack *jack,
117 struct snd_soc_jack_pin *pins,
118 unsigned int num_pins)
119{
120 int ret;
121
122 ret = jack_new(card, id, type, jack, false);
123 if (ret)
124 goto end;
125
126 if (num_pins)
127 ret = snd_soc_jack_add_pins(jack, num_pins, pins);
128end:
129 return soc_card_ret(card, ret);
130}
131EXPORT_SYMBOL_GPL(snd_soc_card_jack_new_pins);
132
133int snd_soc_card_suspend_pre(struct snd_soc_card *card)
134{
135 int ret = 0;
136
137 if (card->suspend_pre)
138 ret = card->suspend_pre(card);
139
140 return soc_card_ret(card, ret);
141}
142
143int snd_soc_card_suspend_post(struct snd_soc_card *card)
144{
145 int ret = 0;
146
147 if (card->suspend_post)
148 ret = card->suspend_post(card);
149
150 return soc_card_ret(card, ret);
151}
152
153int snd_soc_card_resume_pre(struct snd_soc_card *card)
154{
155 int ret = 0;
156
157 if (card->resume_pre)
158 ret = card->resume_pre(card);
159
160 return soc_card_ret(card, ret);
161}
162
163int snd_soc_card_resume_post(struct snd_soc_card *card)
164{
165 int ret = 0;
166
167 if (card->resume_post)
168 ret = card->resume_post(card);
169
170 return soc_card_ret(card, ret);
171}
172
173int snd_soc_card_probe(struct snd_soc_card *card)
174{
175 if (card->probe) {
176 int ret = card->probe(card);
177
178 if (ret < 0)
179 return soc_card_ret(card, ret);
180
181 /*
182 * It has "card->probe" and "card->late_probe" callbacks.
183 * So, set "probed" flag here, because it needs to care
184 * about "late_probe".
185 *
186 * see
187 * snd_soc_bind_card()
188 * snd_soc_card_late_probe()
189 */
190 card->probed = 1;
191 }
192
193 return 0;
194}
195
196int snd_soc_card_late_probe(struct snd_soc_card *card)
197{
198 if (card->late_probe) {
199 int ret = card->late_probe(card);
200
201 if (ret < 0)
202 return soc_card_ret(card, ret);
203 }
204
205 /*
206 * It has "card->probe" and "card->late_probe" callbacks,
207 * and "late_probe" callback is called after "probe".
208 * This means, we can set "card->probed" flag afer "late_probe"
209 * for all cases.
210 *
211 * see
212 * snd_soc_bind_card()
213 * snd_soc_card_probe()
214 */
215 card->probed = 1;
216
217 return 0;
218}
219
220void snd_soc_card_fixup_controls(struct snd_soc_card *card)
221{
222 if (card->fixup_controls)
223 card->fixup_controls(card);
224}
225
226int snd_soc_card_remove(struct snd_soc_card *card)
227{
228 int ret = 0;
229
230 if (card->probed &&
231 card->remove)
232 ret = card->remove(card);
233
234 card->probed = 0;
235
236 return soc_card_ret(card, ret);
237}
238
239int snd_soc_card_set_bias_level(struct snd_soc_card *card,
240 struct snd_soc_dapm_context *dapm,
241 enum snd_soc_bias_level level)
242{
243 int ret = 0;
244
245 if (card && card->set_bias_level)
246 ret = card->set_bias_level(card, dapm, level);
247
248 return soc_card_ret(card, ret);
249}
250
251int snd_soc_card_set_bias_level_post(struct snd_soc_card *card,
252 struct snd_soc_dapm_context *dapm,
253 enum snd_soc_bias_level level)
254{
255 int ret = 0;
256
257 if (card && card->set_bias_level_post)
258 ret = card->set_bias_level_post(card, dapm, level);
259
260 return soc_card_ret(card, ret);
261}
262
263int snd_soc_card_add_dai_link(struct snd_soc_card *card,
264 struct snd_soc_dai_link *dai_link)
265{
266 int ret = 0;
267
268 if (card->add_dai_link)
269 ret = card->add_dai_link(card, dai_link);
270
271 return soc_card_ret(card, ret);
272}
273EXPORT_SYMBOL_GPL(snd_soc_card_add_dai_link);
274
275void snd_soc_card_remove_dai_link(struct snd_soc_card *card,
276 struct snd_soc_dai_link *dai_link)
277{
278 if (card->remove_dai_link)
279 card->remove_dai_link(card, dai_link);
280}
281EXPORT_SYMBOL_GPL(snd_soc_card_remove_dai_link);