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); 282