~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/hda/hda_bind.c

Version: ~ [ linux-6.0-rc6 ] ~ [ linux-5.19.10 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.69 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.144 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.214 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.259 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.294 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.329 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * HD-audio codec driver binding
  4  * Copyright (c) Takashi Iwai <tiwai@suse.de>
  5  */
  6 
  7 #include <linux/init.h>
  8 #include <linux/slab.h>
  9 #include <linux/mutex.h>
 10 #include <linux/module.h>
 11 #include <linux/export.h>
 12 #include <linux/pm.h>
 13 #include <linux/pm_runtime.h>
 14 #include <sound/core.h>
 15 #include <sound/hda_codec.h>
 16 #include "hda_local.h"
 17 
 18 /*
 19  * find a matching codec id
 20  */
 21 static int hda_codec_match(struct hdac_device *dev, struct hdac_driver *drv)
 22 {
 23         struct hda_codec *codec = container_of(dev, struct hda_codec, core);
 24         struct hda_codec_driver *driver =
 25                 container_of(drv, struct hda_codec_driver, core);
 26         const struct hda_device_id *list;
 27         /* check probe_id instead of vendor_id if set */
 28         u32 id = codec->probe_id ? codec->probe_id : codec->core.vendor_id;
 29         u32 rev_id = codec->core.revision_id;
 30 
 31         for (list = driver->id; list->vendor_id; list++) {
 32                 if (list->vendor_id == id &&
 33                     (!list->rev_id || list->rev_id == rev_id)) {
 34                         codec->preset = list;
 35                         return 1;
 36                 }
 37         }
 38         return 0;
 39 }
 40 
 41 /* process an unsolicited event */
 42 static void hda_codec_unsol_event(struct hdac_device *dev, unsigned int ev)
 43 {
 44         struct hda_codec *codec = container_of(dev, struct hda_codec, core);
 45 
 46         /* ignore unsol events during shutdown */
 47         if (codec->bus->shutdown)
 48                 return;
 49 
 50         /* ignore unsol events during system suspend/resume */
 51         if (codec->core.dev.power.power_state.event != PM_EVENT_ON)
 52                 return;
 53 
 54         if (codec->patch_ops.unsol_event)
 55                 codec->patch_ops.unsol_event(codec, ev);
 56 }
 57 
 58 /**
 59  * snd_hda_codec_set_name - set the codec name
 60  * @codec: the HDA codec
 61  * @name: name string to set
 62  */
 63 int snd_hda_codec_set_name(struct hda_codec *codec, const char *name)
 64 {
 65         int err;
 66 
 67         if (!name)
 68                 return 0;
 69         err = snd_hdac_device_set_chip_name(&codec->core, name);
 70         if (err < 0)
 71                 return err;
 72 
 73         /* update the mixer name */
 74         if (!*codec->card->mixername ||
 75             codec->bus->mixer_assigned >= codec->core.addr) {
 76                 snprintf(codec->card->mixername,
 77                          sizeof(codec->card->mixername), "%s %s",
 78                          codec->core.vendor_name, codec->core.chip_name);
 79                 codec->bus->mixer_assigned = codec->core.addr;
 80         }
 81 
 82         return 0;
 83 }
 84 EXPORT_SYMBOL_GPL(snd_hda_codec_set_name);
 85 
 86 static int hda_codec_driver_probe(struct device *dev)
 87 {
 88         struct hda_codec *codec = dev_to_hda_codec(dev);
 89         struct module *owner = dev->driver->owner;
 90         hda_codec_patch_t patch;
 91         int err;
 92 
 93         if (codec->bus->core.ext_ops) {
 94                 if (WARN_ON(!codec->bus->core.ext_ops->hdev_attach))
 95                         return -EINVAL;
 96                 return codec->bus->core.ext_ops->hdev_attach(&codec->core);
 97         }
 98 
 99         if (WARN_ON(!codec->preset))
100                 return -EINVAL;
101 
102         err = snd_hda_codec_set_name(codec, codec->preset->name);
103         if (err < 0)
104                 goto error;
105         err = snd_hdac_regmap_init(&codec->core);
106         if (err < 0)
107                 goto error;
108 
109         if (!try_module_get(owner)) {
110                 err = -EINVAL;
111                 goto error;
112         }
113 
114         patch = (hda_codec_patch_t)codec->preset->driver_data;
115         if (patch) {
116                 err = patch(codec);
117                 if (err < 0)
118                         goto error_module_put;
119         }
120 
121         err = snd_hda_codec_build_pcms(codec);
122         if (err < 0)
123                 goto error_module;
124         err = snd_hda_codec_build_controls(codec);
125         if (err < 0)
126                 goto error_module;
127         /* only register after the bus probe finished; otherwise it's racy */
128         if (!codec->bus->bus_probing && codec->card->registered) {
129                 err = snd_card_register(codec->card);
130                 if (err < 0)
131                         goto error_module;
132                 snd_hda_codec_register(codec);
133         }
134 
135         codec->core.lazy_cache = true;
136         return 0;
137 
138  error_module:
139         if (codec->patch_ops.free)
140                 codec->patch_ops.free(codec);
141  error_module_put:
142         module_put(owner);
143 
144  error:
145         snd_hda_codec_cleanup_for_unbind(codec);
146         return err;
147 }
148 
149 static int hda_codec_driver_remove(struct device *dev)
150 {
151         struct hda_codec *codec = dev_to_hda_codec(dev);
152 
153         if (codec->bus->core.ext_ops) {
154                 if (WARN_ON(!codec->bus->core.ext_ops->hdev_detach))
155                         return -EINVAL;
156                 return codec->bus->core.ext_ops->hdev_detach(&codec->core);
157         }
158 
159         refcount_dec(&codec->pcm_ref);
160         snd_hda_codec_disconnect_pcms(codec);
161         wait_event(codec->remove_sleep, !refcount_read(&codec->pcm_ref));
162         snd_power_sync_ref(codec->bus->card);
163 
164         if (codec->patch_ops.free)
165                 codec->patch_ops.free(codec);
166         snd_hda_codec_cleanup_for_unbind(codec);
167         module_put(dev->driver->owner);
168         return 0;
169 }
170 
171 static void hda_codec_driver_shutdown(struct device *dev)
172 {
173         snd_hda_codec_shutdown(dev_to_hda_codec(dev));
174 }
175 
176 int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name,
177                                struct module *owner)
178 {
179         drv->core.driver.name = name;
180         drv->core.driver.owner = owner;
181         drv->core.driver.bus = &snd_hda_bus_type;
182         drv->core.driver.probe = hda_codec_driver_probe;
183         drv->core.driver.remove = hda_codec_driver_remove;
184         drv->core.driver.shutdown = hda_codec_driver_shutdown;
185         drv->core.driver.pm = &hda_codec_driver_pm;
186         drv->core.type = HDA_DEV_LEGACY;
187         drv->core.match = hda_codec_match;
188         drv->core.unsol_event = hda_codec_unsol_event;
189         return driver_register(&drv->core.driver);
190 }
191 EXPORT_SYMBOL_GPL(__hda_codec_driver_register);
192 
193 void hda_codec_driver_unregister(struct hda_codec_driver *drv)
194 {
195         driver_unregister(&drv->core.driver);
196 }
197 EXPORT_SYMBOL_GPL(hda_codec_driver_unregister);
198 
199 static inline bool codec_probed(struct hda_codec *codec)
200 {
201         return device_attach(hda_codec_dev(codec)) > 0 && codec->preset;
202 }
203 
204 /* try to auto-load codec module */
205 static void request_codec_module(struct hda_codec *codec)
206 {
207 #ifdef MODULE
208         char modalias[32];
209         const char *mod = NULL;
210 
211         switch (codec->probe_id) {
212         case HDA_CODEC_ID_GENERIC_HDMI:
213 #if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI)
214                 mod = "snd-hda-codec-hdmi";
215 #endif
216                 break;
217         case HDA_CODEC_ID_GENERIC:
218 #if IS_MODULE(CONFIG_SND_HDA_GENERIC)
219                 mod = "snd-hda-codec-generic";
220 #endif
221                 break;
222         default:
223                 snd_hdac_codec_modalias(&codec->core, modalias, sizeof(modalias));
224                 mod = modalias;
225                 break;
226         }
227 
228         if (mod)
229                 request_module(mod);
230 #endif /* MODULE */
231 }
232 
233 /* try to auto-load and bind the codec module */
234 static void codec_bind_module(struct hda_codec *codec)
235 {
236 #ifdef MODULE
237         request_codec_module(codec);
238         if (codec_probed(codec))
239                 return;
240 #endif
241 }
242 
243 #if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
244 /* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */
245 static bool is_likely_hdmi_codec(struct hda_codec *codec)
246 {
247         hda_nid_t nid;
248 
249         for_each_hda_codec_node(nid, codec) {
250                 unsigned int wcaps = get_wcaps(codec, nid);
251                 switch (get_wcaps_type(wcaps)) {
252                 case AC_WID_AUD_IN:
253                         return false; /* HDMI parser supports only HDMI out */
254                 case AC_WID_AUD_OUT:
255                         if (!(wcaps & AC_WCAP_DIGITAL))
256                                 return false;
257                         break;
258                 }
259         }
260         return true;
261 }
262 #else
263 /* no HDMI codec parser support */
264 #define is_likely_hdmi_codec(codec)     false
265 #endif /* CONFIG_SND_HDA_CODEC_HDMI */
266 
267 static int codec_bind_generic(struct hda_codec *codec)
268 {
269         if (codec->probe_id)
270                 return -ENODEV;
271 
272         if (is_likely_hdmi_codec(codec)) {
273                 codec->probe_id = HDA_CODEC_ID_GENERIC_HDMI;
274                 request_codec_module(codec);
275                 if (codec_probed(codec))
276                         return 0;
277         }
278 
279         codec->probe_id = HDA_CODEC_ID_GENERIC;
280         request_codec_module(codec);
281         if (codec_probed(codec))
282                 return 0;
283         return -ENODEV;
284 }
285 
286 #if IS_ENABLED(CONFIG_SND_HDA_GENERIC)
287 #define is_generic_config(codec) \
288         (codec->modelname && !strcmp(codec->modelname, "generic"))
289 #else
290 #define is_generic_config(codec)        0
291 #endif
292 
293 /**
294  * snd_hda_codec_configure - (Re-)configure the HD-audio codec
295  * @codec: the HDA codec
296  *
297  * Start parsing of the given codec tree and (re-)initialize the whole
298  * patch instance.
299  *
300  * Returns 0 if successful or a negative error code.
301  */
302 int snd_hda_codec_configure(struct hda_codec *codec)
303 {
304         int err;
305 
306         if (codec->configured)
307                 return 0;
308 
309         if (is_generic_config(codec))
310                 codec->probe_id = HDA_CODEC_ID_GENERIC;
311         else
312                 codec->probe_id = 0;
313 
314         if (!device_is_registered(&codec->core.dev)) {
315                 err = snd_hdac_device_register(&codec->core);
316                 if (err < 0)
317                         return err;
318         }
319 
320         if (!codec->preset)
321                 codec_bind_module(codec);
322         if (!codec->preset) {
323                 err = codec_bind_generic(codec);
324                 if (err < 0) {
325                         codec_dbg(codec, "Unable to bind the codec\n");
326                         return err;
327                 }
328         }
329 
330         codec->configured = 1;
331         return 0;
332 }
333 EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
334 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp