mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
7.7 KiB
329 lines
7.7 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* HD-audio codec driver binding |
|
* Copyright (c) Takashi Iwai <[email protected]> |
|
*/ |
|
|
|
#include <linux/init.h> |
|
#include <linux/slab.h> |
|
#include <linux/mutex.h> |
|
#include <linux/module.h> |
|
#include <linux/export.h> |
|
#include <linux/pm.h> |
|
#include <linux/pm_runtime.h> |
|
#include <sound/core.h> |
|
#include <sound/hda_codec.h> |
|
#include "hda_local.h" |
|
|
|
/* |
|
* find a matching codec id |
|
*/ |
|
static int hda_codec_match(struct hdac_device *dev, struct hdac_driver *drv) |
|
{ |
|
struct hda_codec *codec = container_of(dev, struct hda_codec, core); |
|
struct hda_codec_driver *driver = |
|
container_of(drv, struct hda_codec_driver, core); |
|
const struct hda_device_id *list; |
|
/* check probe_id instead of vendor_id if set */ |
|
u32 id = codec->probe_id ? codec->probe_id : codec->core.vendor_id; |
|
u32 rev_id = codec->core.revision_id; |
|
|
|
for (list = driver->id; list->vendor_id; list++) { |
|
if (list->vendor_id == id && |
|
(!list->rev_id || list->rev_id == rev_id)) { |
|
codec->preset = list; |
|
return 1; |
|
} |
|
} |
|
return 0; |
|
} |
|
|
|
/* process an unsolicited event */ |
|
static void hda_codec_unsol_event(struct hdac_device *dev, unsigned int ev) |
|
{ |
|
struct hda_codec *codec = container_of(dev, struct hda_codec, core); |
|
|
|
/* ignore unsol events during shutdown */ |
|
if (codec->bus->shutdown) |
|
return; |
|
|
|
/* ignore unsol events during system suspend/resume */ |
|
if (codec->core.dev.power.power_state.event != PM_EVENT_ON) |
|
return; |
|
|
|
if (codec->patch_ops.unsol_event) |
|
codec->patch_ops.unsol_event(codec, ev); |
|
} |
|
|
|
/** |
|
* snd_hda_codec_set_name - set the codec name |
|
* @codec: the HDA codec |
|
* @name: name string to set |
|
*/ |
|
int snd_hda_codec_set_name(struct hda_codec *codec, const char *name) |
|
{ |
|
int err; |
|
|
|
if (!name) |
|
return 0; |
|
err = snd_hdac_device_set_chip_name(&codec->core, name); |
|
if (err < 0) |
|
return err; |
|
|
|
/* update the mixer name */ |
|
if (!*codec->card->mixername || |
|
codec->bus->mixer_assigned >= codec->core.addr) { |
|
snprintf(codec->card->mixername, |
|
sizeof(codec->card->mixername), "%s %s", |
|
codec->core.vendor_name, codec->core.chip_name); |
|
codec->bus->mixer_assigned = codec->core.addr; |
|
} |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(snd_hda_codec_set_name); |
|
|
|
static int hda_codec_driver_probe(struct device *dev) |
|
{ |
|
struct hda_codec *codec = dev_to_hda_codec(dev); |
|
struct module *owner = dev->driver->owner; |
|
hda_codec_patch_t patch; |
|
int err; |
|
|
|
if (codec->bus->core.ext_ops) { |
|
if (WARN_ON(!codec->bus->core.ext_ops->hdev_attach)) |
|
return -EINVAL; |
|
return codec->bus->core.ext_ops->hdev_attach(&codec->core); |
|
} |
|
|
|
if (WARN_ON(!codec->preset)) |
|
return -EINVAL; |
|
|
|
err = snd_hda_codec_set_name(codec, codec->preset->name); |
|
if (err < 0) |
|
goto error; |
|
err = snd_hdac_regmap_init(&codec->core); |
|
if (err < 0) |
|
goto error; |
|
|
|
if (!try_module_get(owner)) { |
|
err = -EINVAL; |
|
goto error; |
|
} |
|
|
|
patch = (hda_codec_patch_t)codec->preset->driver_data; |
|
if (patch) { |
|
err = patch(codec); |
|
if (err < 0) |
|
goto error_module_put; |
|
} |
|
|
|
err = snd_hda_codec_build_pcms(codec); |
|
if (err < 0) |
|
goto error_module; |
|
err = snd_hda_codec_build_controls(codec); |
|
if (err < 0) |
|
goto error_module; |
|
/* only register after the bus probe finished; otherwise it's racy */ |
|
if (!codec->bus->bus_probing && codec->card->registered) { |
|
err = snd_card_register(codec->card); |
|
if (err < 0) |
|
goto error_module; |
|
snd_hda_codec_register(codec); |
|
} |
|
|
|
codec->core.lazy_cache = true; |
|
return 0; |
|
|
|
error_module: |
|
if (codec->patch_ops.free) |
|
codec->patch_ops.free(codec); |
|
error_module_put: |
|
module_put(owner); |
|
|
|
error: |
|
snd_hda_codec_cleanup_for_unbind(codec); |
|
return err; |
|
} |
|
|
|
static int hda_codec_driver_remove(struct device *dev) |
|
{ |
|
struct hda_codec *codec = dev_to_hda_codec(dev); |
|
|
|
if (codec->bus->core.ext_ops) { |
|
if (WARN_ON(!codec->bus->core.ext_ops->hdev_detach)) |
|
return -EINVAL; |
|
return codec->bus->core.ext_ops->hdev_detach(&codec->core); |
|
} |
|
|
|
if (codec->patch_ops.free) |
|
codec->patch_ops.free(codec); |
|
snd_hda_codec_cleanup_for_unbind(codec); |
|
module_put(dev->driver->owner); |
|
return 0; |
|
} |
|
|
|
static void hda_codec_driver_shutdown(struct device *dev) |
|
{ |
|
struct hda_codec *codec = dev_to_hda_codec(dev); |
|
|
|
if (!pm_runtime_suspended(dev) && codec->patch_ops.reboot_notify) |
|
codec->patch_ops.reboot_notify(codec); |
|
} |
|
|
|
int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name, |
|
struct module *owner) |
|
{ |
|
drv->core.driver.name = name; |
|
drv->core.driver.owner = owner; |
|
drv->core.driver.bus = &snd_hda_bus_type; |
|
drv->core.driver.probe = hda_codec_driver_probe; |
|
drv->core.driver.remove = hda_codec_driver_remove; |
|
drv->core.driver.shutdown = hda_codec_driver_shutdown; |
|
drv->core.driver.pm = &hda_codec_driver_pm; |
|
drv->core.type = HDA_DEV_LEGACY; |
|
drv->core.match = hda_codec_match; |
|
drv->core.unsol_event = hda_codec_unsol_event; |
|
return driver_register(&drv->core.driver); |
|
} |
|
EXPORT_SYMBOL_GPL(__hda_codec_driver_register); |
|
|
|
void hda_codec_driver_unregister(struct hda_codec_driver *drv) |
|
{ |
|
driver_unregister(&drv->core.driver); |
|
} |
|
EXPORT_SYMBOL_GPL(hda_codec_driver_unregister); |
|
|
|
static inline bool codec_probed(struct hda_codec *codec) |
|
{ |
|
return device_attach(hda_codec_dev(codec)) > 0 && codec->preset; |
|
} |
|
|
|
/* try to auto-load codec module */ |
|
static void request_codec_module(struct hda_codec *codec) |
|
{ |
|
#ifdef MODULE |
|
char modalias[32]; |
|
const char *mod = NULL; |
|
|
|
switch (codec->probe_id) { |
|
case HDA_CODEC_ID_GENERIC_HDMI: |
|
#if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI) |
|
mod = "snd-hda-codec-hdmi"; |
|
#endif |
|
break; |
|
case HDA_CODEC_ID_GENERIC: |
|
#if IS_MODULE(CONFIG_SND_HDA_GENERIC) |
|
mod = "snd-hda-codec-generic"; |
|
#endif |
|
break; |
|
default: |
|
snd_hdac_codec_modalias(&codec->core, modalias, sizeof(modalias)); |
|
mod = modalias; |
|
break; |
|
} |
|
|
|
if (mod) |
|
request_module(mod); |
|
#endif /* MODULE */ |
|
} |
|
|
|
/* try to auto-load and bind the codec module */ |
|
static void codec_bind_module(struct hda_codec *codec) |
|
{ |
|
#ifdef MODULE |
|
request_codec_module(codec); |
|
if (codec_probed(codec)) |
|
return; |
|
#endif |
|
} |
|
|
|
#if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI) |
|
/* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */ |
|
static bool is_likely_hdmi_codec(struct hda_codec *codec) |
|
{ |
|
hda_nid_t nid; |
|
|
|
for_each_hda_codec_node(nid, codec) { |
|
unsigned int wcaps = get_wcaps(codec, nid); |
|
switch (get_wcaps_type(wcaps)) { |
|
case AC_WID_AUD_IN: |
|
return false; /* HDMI parser supports only HDMI out */ |
|
case AC_WID_AUD_OUT: |
|
if (!(wcaps & AC_WCAP_DIGITAL)) |
|
return false; |
|
break; |
|
} |
|
} |
|
return true; |
|
} |
|
#else |
|
/* no HDMI codec parser support */ |
|
#define is_likely_hdmi_codec(codec) false |
|
#endif /* CONFIG_SND_HDA_CODEC_HDMI */ |
|
|
|
static int codec_bind_generic(struct hda_codec *codec) |
|
{ |
|
if (codec->probe_id) |
|
return -ENODEV; |
|
|
|
if (is_likely_hdmi_codec(codec)) { |
|
codec->probe_id = HDA_CODEC_ID_GENERIC_HDMI; |
|
request_codec_module(codec); |
|
if (codec_probed(codec)) |
|
return 0; |
|
} |
|
|
|
codec->probe_id = HDA_CODEC_ID_GENERIC; |
|
request_codec_module(codec); |
|
if (codec_probed(codec)) |
|
return 0; |
|
return -ENODEV; |
|
} |
|
|
|
#if IS_ENABLED(CONFIG_SND_HDA_GENERIC) |
|
#define is_generic_config(codec) \ |
|
(codec->modelname && !strcmp(codec->modelname, "generic")) |
|
#else |
|
#define is_generic_config(codec) 0 |
|
#endif |
|
|
|
/** |
|
* snd_hda_codec_configure - (Re-)configure the HD-audio codec |
|
* @codec: the HDA codec |
|
* |
|
* Start parsing of the given codec tree and (re-)initialize the whole |
|
* patch instance. |
|
* |
|
* Returns 0 if successful or a negative error code. |
|
*/ |
|
int snd_hda_codec_configure(struct hda_codec *codec) |
|
{ |
|
int err; |
|
|
|
if (is_generic_config(codec)) |
|
codec->probe_id = HDA_CODEC_ID_GENERIC; |
|
else |
|
codec->probe_id = 0; |
|
|
|
err = snd_hdac_device_register(&codec->core); |
|
if (err < 0) |
|
return err; |
|
|
|
if (!codec->preset) |
|
codec_bind_module(codec); |
|
if (!codec->preset) { |
|
err = codec_bind_generic(codec); |
|
if (err < 0) { |
|
codec_err(codec, "Unable to bind the codec\n"); |
|
goto error; |
|
} |
|
} |
|
|
|
return 0; |
|
|
|
error: |
|
snd_hdac_device_unregister(&codec->core); |
|
return err; |
|
} |
|
EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
|
|
|