LXR linux/sound/pci/hda/hda

   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 */
  20static 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 */
  48static 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 */
  57static 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
  66static 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        err = snd_hdac_regmap_init(&codec->core);
  79        if (err < 0)
  80                goto error;
  81
  82        if (!try_module_get(owner)) {
  83                err = -EINVAL;
  84                goto error;
  85        }
  86
  87        err = codec->preset->patch(codec);
  88        if (err < 0)
  89                goto error_module;
  90
  91        err = snd_hda_codec_build_pcms(codec);
  92        if (err < 0)
  93                goto error_module;
  94        err = snd_hda_codec_build_controls(codec);
  95        if (err < 0)
  96                goto error_module;
  97        if (codec->card->registered) {
  98                err = snd_card_register(codec->card);
  99                if (err < 0)
 100                        goto error_module;
 101                snd_hda_codec_register(codec);
 102        }
 103
 104        codec->core.lazy_cache = true;
 105        return 0;
 106
 107 error_module:
 108        module_put(owner);
 109
 110 error:
 111        snd_hda_codec_cleanup_for_unbind(codec);
 112        return err;
 113}
 114
 115static int hda_codec_driver_remove(struct device *dev)
 116{
 117        struct hda_codec *codec = dev_to_hda_codec(dev);
 118
 119        if (codec->patch_ops.free)
 120                codec->patch_ops.free(codec);
 121        snd_hda_codec_cleanup_for_unbind(codec);
 122        module_put(dev->driver->owner);
 123        return 0;
 124}
 125
 126static void hda_codec_driver_shutdown(struct device *dev)
 127{
 128        struct hda_codec *codec = dev_to_hda_codec(dev);
 129
 130        if (!pm_runtime_suspended(dev) && codec->patch_ops.reboot_notify)
 131                codec->patch_ops.reboot_notify(codec);
 132}
 133
 134int __hda_codec_driver_register(struct hda_codec_driver *drv, const char *name,
 135                               struct module *owner)
 136{
 137        drv->core.driver.name = name;
 138        drv->core.driver.owner = owner;
 139        drv->core.driver.bus = &snd_hda_bus_type;
 140        drv->core.driver.probe = hda_codec_driver_probe;
 141        drv->core.driver.remove = hda_codec_driver_remove;
 142        drv->core.driver.shutdown = hda_codec_driver_shutdown;
 143        drv->core.driver.pm = &hda_codec_driver_pm;
 144        drv->core.type = HDA_DEV_LEGACY;
 145        drv->core.match = hda_codec_match;
 146        drv->core.unsol_event = hda_codec_unsol_event;
 147        return driver_register(&drv->core.driver);
 148}
 149EXPORT_SYMBOL_GPL(__hda_codec_driver_register);
 150
 151void hda_codec_driver_unregister(struct hda_codec_driver *drv)
 152{
 153        driver_unregister(&drv->core.driver);
 154}
 155EXPORT_SYMBOL_GPL(hda_codec_driver_unregister);
 156
 157static inline bool codec_probed(struct hda_codec *codec)
 158{
 159        return device_attach(hda_codec_dev(codec)) > 0 && codec->preset;
 160}
 161
 162/* try to auto-load and bind the codec module */
 163static void codec_bind_module(struct hda_codec *codec)
 164{
 165#ifdef MODULE
 166        request_module("snd-hda-codec-id:%08x", codec->core.vendor_id);
 167        if (codec_probed(codec))
 168                return;
 169        request_module("snd-hda-codec-id:%04x*",
 170                       (codec->core.vendor_id >> 16) & 0xffff);
 171        if (codec_probed(codec))
 172                return;
 173#endif
 174}
 175
 176#if IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI)
 177/* if all audio out widgets are digital, let's assume the codec as a HDMI/DP */
 178static bool is_likely_hdmi_codec(struct hda_codec *codec)
 179{
 180        hda_nid_t nid;
 181
 182        for_each_hda_codec_node(nid, codec) {
 183                unsigned int wcaps = get_wcaps(codec, nid);
 184                switch (get_wcaps_type(wcaps)) {
 185                case AC_WID_AUD_IN:
 186                        return false; /* HDMI parser supports only HDMI out */
 187                case AC_WID_AUD_OUT:
 188                        if (!(wcaps & AC_WCAP_DIGITAL))
 189                                return false;
 190                        break;
 191                }
 192        }
 193        return true;
 194}
 195#else
 196/* no HDMI codec parser support */
 197#define is_likely_hdmi_codec(codec)     false
 198#endif /* CONFIG_SND_HDA_CODEC_HDMI */
 199
 200static int codec_bind_generic(struct hda_codec *codec)
 201{
 202        if (codec->probe_id)
 203                return -ENODEV;
 204
 205        if (is_likely_hdmi_codec(codec)) {
 206                codec->probe_id = HDA_CODEC_ID_GENERIC_HDMI;
 207#if IS_MODULE(CONFIG_SND_HDA_CODEC_HDMI)
 208                request_module("snd-hda-codec-hdmi");
 209#endif
 210                if (codec_probed(codec))
 211                        return 0;
 212        }
 213
 214        codec->probe_id = HDA_CODEC_ID_GENERIC;
 215#if IS_MODULE(CONFIG_SND_HDA_GENERIC)
 216        request_module("snd-hda-codec-generic");
 217#endif
 218        if (codec_probed(codec))
 219                return 0;
 220        return -ENODEV;
 221}
 222
 223#if IS_ENABLED(CONFIG_SND_HDA_GENERIC)
 224#define is_generic_config(codec) \
 225        (codec->modelname && !strcmp(codec->modelname, "generic"))
 226#else
 227#define is_generic_config(codec)        0
 228#endif
 229
 230/**
 231 * snd_hda_codec_configure - (Re-)configure the HD-audio codec
 232 * @codec: the HDA codec
 233 *
 234 * Start parsing of the given codec tree and (re-)initialize the whole
 235 * patch instance.
 236 *
 237 * Returns 0 if successful or a negative error code.
 238 */
 239int snd_hda_codec_configure(struct hda_codec *codec)
 240{
 241        int err;
 242
 243        if (is_generic_config(codec))
 244                codec->probe_id = HDA_CODEC_ID_GENERIC;
 245        else
 246                codec->probe_id = 0;
 247
 248        err = snd_hdac_device_register(&codec->core);
 249        if (err < 0)
 250                return err;
 251
 252        if (!codec->preset)
 253                codec_bind_module(codec);
 254        if (!codec->preset) {
 255                err = codec_bind_generic(codec);
 256                if (err < 0) {
 257                        codec_err(codec, "Unable to bind the codec\n");
 258                        goto error;
 259                }
 260        }
 261
 262        /* audio codec should override the mixer name */
 263        if (codec->core.afg || !*codec->card->mixername)
 264                snprintf(codec->card->mixername,
 265                         sizeof(codec->card->mixername), "%s %s",
 266                         codec->core.vendor_name, codec->core.chip_name);
 267        return 0;
 268
 269 error:
 270        snd_hdac_device_unregister(&codec->core);
 271        return err;
 272}
 273EXPORT_SYMBOL_GPL(snd_hda_codec_configure);
 274