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