1 /* 2 * HD-audio codec driver binding 3 * Copyright (c) Takashi Iwai <tiwai@suse.de> 4 */ 5 6 #include <linux/init.h> 7 #include <linux/slab.h> 8 #include <linux/mutex.h> 9 #include <linux/module.h> 10 #include <linux/export.h> 11 #include <linux/pm.h> 12 #include <linux/pm_runtime.h> 13 #include <sound/core.h> 14 #include "hda_codec.h" 15 #include "hda_local.h" 16 17 /* 18 * find a matching codec preset 19 */ 20 static int hda_codec_match(struct hdac_device *dev, struct hdac_driver *drv) 21 { 22 struct hda_codec *codec = container_of(dev, struct hda_codec, core); 23 struct hda_codec_driver *driver = 24 container_of(drv, struct hda_codec_driver, core); 25 const struct hda_codec_preset *preset; 26 /* check probe_id instead of vendor_id if set */ 27 u32 id = codec->probe_id ? codec->probe_id : codec->core.vendor_id; 28 29 for (preset = driver->preset; preset->id; preset++) { 30 u32 mask = preset->mask; 31 32 if (preset->afg && preset->afg != codec->core.afg) 33 continue; 34 if (preset->mfg && preset->mfg != codec->core.mfg) 35 continue; 36 if (!mask) 37 mask = ~0; 38 if (preset->id == (id & mask) && 39 (!preset->rev || preset->rev == codec->core.revision_id)) { 40 codec->preset = preset; 41 return 1; 42 } 43 } 44 return 0; 45 } 46 47 /* process an unsolicited event */ 48 static void hda_codec_unsol_event(struct hdac_device *dev, unsigned int ev) 49 { 50 struct hda_codec *codec = container_of(dev, struct hda_codec, core); 51 52 if (codec->patch_ops.unsol_event) 53 codec->patch_ops.unsol_event(codec, ev); 54 } 55 56 /* reset the codec name from the preset */ 57 static int codec_refresh_name(struct hda_codec *codec, const char *name) 58 { 59 if (name) { 60 kfree(codec->core.chip_name); 61 codec->core.chip_name = kstrdup(name, GFP_KERNEL); 62 } 63 return codec->core.chip_name ? 0 : -ENOMEM; 64 } 65 66 static int hda_codec_driver_probe(struct device *dev) 67 { 68 struct hda_codec *codec = dev_to_hda_codec(dev); 69 struct module *owner = dev->driver->owner; 70 int err; 71 72 if (WARN_ON(!codec->preset)) 73 return -EINVAL; 74 75 err = codec_refresh_name(codec, codec->preset->name); 76 if (err < 0) 77 goto error; 78 79 if (!try_module_get(owner)) { 80 err = -EINVAL; 81 goto error; 82 } 83 84 err = codec->preset->patch(codec); 85 if (err < 0) 86 goto error_module; 87 88 err = snd_hda_codec_build_pcms(codec); 89 if (err < 0) 90 goto error_module; 91 err = snd_hda_codec_build_controls(codec); 92 if (err < 0) 93 goto error_module; 94 if (codec->card->registered) { 95 err = snd_card_register(codec->card); 96 if (err < 0) 97 goto error_module; 98 snd_hda_codec_register(codec); 99 } 100 101 return 0; 102 103 error_module: 104 module_put(owner); 105 106 error: 107 snd_hda_codec_cleanup_for_unbind(codec); 108 return err; 109 } 110 111 static int hda_codec_driver_remove(struct device *dev) 112 { 113 struct hda_codec *codec = dev_to_hda_codec(dev); 114 115 if (codec->patch_ops.free) 116 codec->patch_ops.free(codec); 117 snd_hda_codec_cleanup_for_unbind(codec); 118 module_put(dev->driver->owner); 119 return 0; 120 } 121 122 static void hda_codec_driver_shutdown(struct device *dev) 123 { 124 struct hda_codec *codec = dev_to_hda_codec(dev); 125 126 if (!pm_runtime_suspended(dev) && codec->patch_ops.reboot_notify) 127 codec->patch_ops.reboot_notify(codec); 128 } 129 130 int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name, 131 struct module *owner) 132 { 133 drv->core.driver.name = name; 134 drv->core.driver.owner = owner; 135 drv->core.driver.bus = &snd_hda_bus_type; 136 drv->core.driver.probe = hda_codec_driver_probe; 137 drv->core.driver.remove = hda_codec_driver_remove; 138 drv->core.driver.shutdown = hda_codec_driver_shutdown; 139 drv->core.driver.pm = &hda_codec_driver_pm; 140 drv->core.type = HDA_DEV_LEGACY; 141 drv->core.match = hda_codec_match; 142 drv->core.unsol_event = hda_codec_unsol_event; 143 return driver_register(&drv->core.driver); 144 } 145 EXPORT_SYMBOL_GPL(__hda_codec_driver_register); 146 147 void hda_codec_driver_unregister(struct hda_codec_driver *drv) 148 { 149 driver_unregister(&drv->core.driver); 150 } 151 EXPORT_SYMBOL_GPL(hda_codec_driver_unregister); 152 153 static inline bool codec_probed(struct hda_codec *codec) 154 { 155 return device_attach(hda_codec_dev(codec)) > 0 && codec->preset; 156 } 157 158 /* try to auto-load and bind the codec module */ 159 static void codec_bind_module(struct hda_codec *codec) 160 { 161 #ifdef MODULE 162 request_module("snd-hda-codec-id:%08x", codec->core.vendor_id); 163 if (codec_probed(codec)) 164 return; 165 request_module("snd-hda-codec-id:%04x*", 166 (codec->core.vendor_id >> 16) & 0xffff); 167 if (codec_probed(codec)) 168 return; 169 #endif 170 } 171 172 #if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI) 173 /* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */ 174 static bool is_likely_hdmi_codec(struct hda_codec *codec) 175 { 176 hda_nid_t nid; 177 178 for_each_hda_codec_node(nid, codec) { 179 unsigned int wcaps = get_wcaps(codec, nid); 180 switch (get_wcaps_type(wcaps)) { 181 case AC_WID_AUD_IN: 182 return false; /* HDMI parser supports only HDMI out */ 183 case AC_WID_AUD_OUT: 184 if (!(wcaps & AC_WCAP_DIGITAL)) 185 return false; 186 break; 187 } 188 } 189 return true; 190 } 191 #else 192 /* no HDMI codec parser support */ 193 #define is_likely_hdmi_codec(codec) false 194 #endif /* CONFIG_SND_HDA_CODEC_HDMI */ 195 196 static int codec_bind_generic(struct hda_codec *codec) 197 { 198 if (codec->probe_id) 199 return -ENODEV; 200 201 if (is_likely_hdmi_codec(codec)) { 202 codec->probe_id = HDA_CODEC_ID_GENERIC_HDMI; 203 #if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI) 204 request_module("snd-hda-codec-hdmi"); 205 #endif 206 if (codec_probed(codec)) 207 return 0; 208 } 209 210 codec->probe_id = HDA_CODEC_ID_GENERIC; 211 #if IS_MODULE(CONFIG_SND_HDA_GENERIC) 212 request_module("snd-hda-codec-generic"); 213 #endif 214 if (codec_probed(codec)) 215 return 0; 216 return -ENODEV; 217 } 218 219 #if IS_ENABLED(CONFIG_SND_HDA_GENERIC) 220 #define is_generic_config(codec) \ 221 (codec->modelname && !strcmp(codec->modelname, "generic")) 222 #else 223 #define is_generic_config(codec) 0 224 #endif 225 226 /** 227 * snd_hda_codec_configure - (Re-)configure the HD-audio codec 228 * @codec: the HDA codec 229 * 230 * Start parsing of the given codec tree and (re-)initialize the whole 231 * patch instance. 232 * 233 * Returns 0 if successful or a negative error code. 234 */ 235 int snd_hda_codec_configure(struct hda_codec *codec) 236 { 237 int err; 238 239 if (is_generic_config(codec)) 240 codec->probe_id = HDA_CODEC_ID_GENERIC; 241 else 242 codec->probe_id = 0; 243 244 err = snd_hdac_device_register(&codec->core); 245 if (err < 0) 246 return err; 247 248 if (!codec->preset) 249 codec_bind_module(codec); 250 if (!codec->preset) { 251 err = codec_bind_generic(codec); 252 if (err < 0) { 253 codec_err(codec, "Unable to bind the codec\n"); 254 goto error; 255 } 256 } 257 258 /* audio codec should override the mixer name */ 259 if (codec->core.afg || !*codec->card->mixername) 260 snprintf(codec->card->mixername, 261 sizeof(codec->card->mixername), "%s %s", 262 codec->core.vendor_name, codec->core.chip_name); 263 return 0; 264 265 error: 266 snd_hdac_device_unregister(&codec->core); 267 return err; 268 } 269 EXPORT_SYMBOL_GPL(snd_hda_codec_configure); 270