LXR linux/sound/pci/hda/hda

   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/*
   3 * Universal Interface for Intel High Definition Audio Codec
   4 *
   5 * Local helper functions
   6 *
   7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
   8 */
   9
  10#ifndef __SOUND_HDA_LOCAL_H
  11#define __SOUND_HDA_LOCAL_H
  12
  13/* We abuse kcontrol_new.subdev field to pass the NID corresponding to
  14 * the given new control.  If id.subdev has a bit flag HDA_SUBDEV_NID_FLAG,
  15 * snd_hda_ctl_add() takes the lower-bit subdev value as a valid NID.
  16 * 
  17 * Note that the subdevice field is cleared again before the real registration
  18 * in snd_hda_ctl_add(), so that this value won't appear in the outside.
  19 */
  20#define HDA_SUBDEV_NID_FLAG     (1U << 31)
  21#define HDA_SUBDEV_AMP_FLAG     (1U << 30)
  22
  23/*
  24 * for mixer controls
  25 */
  26#define HDA_COMPOSE_AMP_VAL_OFS(nid,chs,idx,dir,ofs)            \
  27        ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19) | ((ofs)<<23))
  28#define HDA_AMP_VAL_MIN_MUTE (1<<29)
  29#define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) \
  30        HDA_COMPOSE_AMP_VAL_OFS(nid, chs, idx, dir, 0)
  31/* mono volume with index (index=0,1,...) (channel=1,2) */
  32#define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, dir, flags) \
  33        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx,  \
  34          .subdevice = HDA_SUBDEV_AMP_FLAG, \
  35          .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
  36                    SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
  37                    SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
  38          .info = snd_hda_mixer_amp_volume_info, \
  39          .get = snd_hda_mixer_amp_volume_get, \
  40          .put = snd_hda_mixer_amp_volume_put, \
  41          .tlv = { .c = snd_hda_mixer_amp_tlv },                \
  42          .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, dir) | flags }
  43/* stereo volume with index */
  44#define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \
  45        HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction, 0)
  46/* mono volume */
  47#define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \
  48        HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction, 0)
  49/* stereo volume */
  50#define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \
  51        HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction)
  52/* stereo volume with min=mute */
  53#define HDA_CODEC_VOLUME_MIN_MUTE(xname, nid, xindex, direction) \
  54        HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, 3, xindex, direction, \
  55                                  HDA_AMP_VAL_MIN_MUTE)
  56/* mono mute switch with index (index=0,1,...) (channel=1,2) */
  57#define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
  58        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
  59          .subdevice = HDA_SUBDEV_AMP_FLAG, \
  60          .info = snd_hda_mixer_amp_switch_info, \
  61          .get = snd_hda_mixer_amp_switch_get, \
  62          .put = snd_hda_mixer_amp_switch_put, \
  63          .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
  64/* stereo mute switch with index */
  65#define HDA_CODEC_MUTE_IDX(xname, xcidx, nid, xindex, direction) \
  66        HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, 3, xindex, direction)
  67/* mono mute switch */
  68#define HDA_CODEC_MUTE_MONO(xname, nid, channel, xindex, direction) \
  69        HDA_CODEC_MUTE_MONO_IDX(xname, 0, nid, channel, xindex, direction)
  70/* stereo mute switch */
  71#define HDA_CODEC_MUTE(xname, nid, xindex, direction) \
  72        HDA_CODEC_MUTE_MONO(xname, nid, 3, xindex, direction)
  73#ifdef CONFIG_SND_HDA_INPUT_BEEP
  74/* special beep mono mute switch with index (index=0,1,...) (channel=1,2) */
  75#define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \
  76        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \
  77          .subdevice = HDA_SUBDEV_AMP_FLAG, \
  78          .info = snd_hda_mixer_amp_switch_info, \
  79          .get = snd_hda_mixer_amp_switch_get_beep, \
  80          .put = snd_hda_mixer_amp_switch_put_beep, \
  81          .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) }
  82#else
  83/* no digital beep - just the standard one */
  84#define HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, xcidx, nid, ch, xidx, dir) \
  85        HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, ch, xidx, dir)
  86#endif /* CONFIG_SND_HDA_INPUT_BEEP */
  87/* special beep mono mute switch */
  88#define HDA_CODEC_MUTE_BEEP_MONO(xname, nid, channel, xindex, direction) \
  89        HDA_CODEC_MUTE_BEEP_MONO_IDX(xname, 0, nid, channel, xindex, direction)
  90/* special beep stereo mute switch */
  91#define HDA_CODEC_MUTE_BEEP(xname, nid, xindex, direction) \
  92        HDA_CODEC_MUTE_BEEP_MONO(xname, nid, 3, xindex, direction)
  93
  94extern const char *snd_hda_pcm_type_name[];
  95
  96int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
  97                                  struct snd_ctl_elem_info *uinfo);
  98int snd_hda_mixer_amp_volume_get(struct snd_kcontrol *kcontrol,
  99                                 struct snd_ctl_elem_value *ucontrol);
 100int snd_hda_mixer_amp_volume_put(struct snd_kcontrol *kcontrol,
 101                                 struct snd_ctl_elem_value *ucontrol);
 102int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 103                          unsigned int size, unsigned int __user *tlv);
 104int snd_hda_mixer_amp_switch_info(struct snd_kcontrol *kcontrol,
 105                                  struct snd_ctl_elem_info *uinfo);
 106int snd_hda_mixer_amp_switch_get(struct snd_kcontrol *kcontrol,
 107                                 struct snd_ctl_elem_value *ucontrol);
 108int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol,
 109                                 struct snd_ctl_elem_value *ucontrol);
 110#ifdef CONFIG_SND_HDA_INPUT_BEEP
 111int snd_hda_mixer_amp_switch_get_beep(struct snd_kcontrol *kcontrol,
 112                                      struct snd_ctl_elem_value *ucontrol);
 113int snd_hda_mixer_amp_switch_put_beep(struct snd_kcontrol *kcontrol,
 114                                      struct snd_ctl_elem_value *ucontrol);
 115#endif
 116/* lowlevel accessor with caching; use carefully */
 117#define snd_hda_codec_amp_read(codec, nid, ch, dir, idx) \
 118        snd_hdac_regmap_get_amp(&(codec)->core, nid, ch, dir, idx)
 119int snd_hda_codec_amp_update(struct hda_codec *codec, hda_nid_t nid,
 120                             int ch, int dir, int idx, int mask, int val);
 121int snd_hda_codec_amp_stereo(struct hda_codec *codec, hda_nid_t nid,
 122                             int dir, int idx, int mask, int val);
 123int snd_hda_codec_amp_init(struct hda_codec *codec, hda_nid_t nid, int ch,
 124                           int direction, int idx, int mask, int val);
 125int snd_hda_codec_amp_init_stereo(struct hda_codec *codec, hda_nid_t nid,
 126                                  int dir, int idx, int mask, int val);
 127void snd_hda_set_vmaster_tlv(struct hda_codec *codec, hda_nid_t nid, int dir,
 128                             unsigned int *tlv);
 129struct snd_kcontrol *snd_hda_find_mixer_ctl(struct hda_codec *codec,
 130                                            const char *name);
 131int __snd_hda_add_vmaster(struct hda_codec *codec, char *name,
 132                          unsigned int *tlv, const char * const *slaves,
 133                          const char *suffix, bool init_slave_vol,
 134                          struct snd_kcontrol **ctl_ret);
 135#define snd_hda_add_vmaster(codec, name, tlv, slaves, suffix) \
 136        __snd_hda_add_vmaster(codec, name, tlv, slaves, suffix, true, NULL)
 137int snd_hda_codec_reset(struct hda_codec *codec);
 138void snd_hda_codec_register(struct hda_codec *codec);
 139void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec);
 140
 141enum {
 142        HDA_VMUTE_OFF,
 143        HDA_VMUTE_ON,
 144        HDA_VMUTE_FOLLOW_MASTER,
 145};
 146
 147struct hda_vmaster_mute_hook {
 148        /* below two fields must be filled by the caller of
 149         * snd_hda_add_vmaster_hook() beforehand
 150         */
 151        struct snd_kcontrol *sw_kctl;
 152        void (*hook)(void *, int);
 153        /* below are initialized automatically */
 154        unsigned int mute_mode; /* HDA_VMUTE_XXX */
 155        struct hda_codec *codec;
 156};
 157
 158int snd_hda_add_vmaster_hook(struct hda_codec *codec,
 159                             struct hda_vmaster_mute_hook *hook,
 160                             bool expose_enum_ctl);
 161void snd_hda_sync_vmaster_hook(struct hda_vmaster_mute_hook *hook);
 162
 163/* amp value bits */
 164#define HDA_AMP_MUTE    0x80
 165#define HDA_AMP_UNMUTE  0x00
 166#define HDA_AMP_VOLMASK 0x7f
 167
 168/*
 169 * SPDIF I/O
 170 */
 171int snd_hda_create_dig_out_ctls(struct hda_codec *codec,
 172                                hda_nid_t associated_nid,
 173                                hda_nid_t cvt_nid, int type);
 174#define snd_hda_create_spdif_out_ctls(codec, anid, cnid) \
 175        snd_hda_create_dig_out_ctls(codec, anid, cnid, HDA_PCM_TYPE_SPDIF)
 176int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid);
 177
 178/*
 179 * input MUX helper
 180 */
 181#define HDA_MAX_NUM_INPUTS      16
 182struct hda_input_mux_item {
 183        char label[32];
 184        unsigned int index;
 185};
 186struct hda_input_mux {
 187        unsigned int num_items;
 188        struct hda_input_mux_item items[HDA_MAX_NUM_INPUTS];
 189};
 190
 191int snd_hda_input_mux_info(const struct hda_input_mux *imux,
 192                           struct snd_ctl_elem_info *uinfo);
 193int snd_hda_input_mux_put(struct hda_codec *codec,
 194                          const struct hda_input_mux *imux,
 195                          struct snd_ctl_elem_value *ucontrol, hda_nid_t nid,
 196                          unsigned int *cur_val);
 197int snd_hda_add_imux_item(struct hda_codec *codec,
 198                          struct hda_input_mux *imux, const char *label,
 199                          int index, int *type_index_ret);
 200
 201/*
 202 * Multi-channel / digital-out PCM helper
 203 */
 204
 205enum { HDA_FRONT, HDA_REAR, HDA_CLFE, HDA_SIDE }; /* index for dac_nidx */
 206enum { HDA_DIG_NONE, HDA_DIG_EXCLUSIVE, HDA_DIG_ANALOG_DUP }; /* dig_out_used */
 207
 208#define HDA_MAX_OUTS    5
 209
 210struct hda_multi_out {
 211        int num_dacs;           /* # of DACs, must be more than 1 */
 212        const hda_nid_t *dac_nids;      /* DAC list */
 213        hda_nid_t hp_nid;       /* optional DAC for HP, 0 when not exists */
 214        hda_nid_t hp_out_nid[HDA_MAX_OUTS];     /* DACs for multiple HPs */
 215        hda_nid_t extra_out_nid[HDA_MAX_OUTS];  /* other (e.g. speaker) DACs */
 216        hda_nid_t dig_out_nid;  /* digital out audio widget */
 217        const hda_nid_t *slave_dig_outs;
 218        int max_channels;       /* currently supported analog channels */
 219        int dig_out_used;       /* current usage of digital out (HDA_DIG_XXX) */
 220        int no_share_stream;    /* don't share a stream with multiple pins */
 221        int share_spdif;        /* share SPDIF pin */
 222        /* PCM information for both analog and SPDIF DACs */
 223        unsigned int analog_rates;
 224        unsigned int analog_maxbps;
 225        u64 analog_formats;
 226        unsigned int spdif_rates;
 227        unsigned int spdif_maxbps;
 228        u64 spdif_formats;
 229};
 230
 231int snd_hda_create_spdif_share_sw(struct hda_codec *codec,
 232                                  struct hda_multi_out *mout);
 233int snd_hda_multi_out_dig_open(struct hda_codec *codec,
 234                               struct hda_multi_out *mout);
 235int snd_hda_multi_out_dig_close(struct hda_codec *codec,
 236                                struct hda_multi_out *mout);
 237int snd_hda_multi_out_dig_prepare(struct hda_codec *codec,
 238                                  struct hda_multi_out *mout,
 239                                  unsigned int stream_tag,
 240                                  unsigned int format,
 241                                  struct snd_pcm_substream *substream);
 242int snd_hda_multi_out_dig_cleanup(struct hda_codec *codec,
 243                                  struct hda_multi_out *mout);
 244int snd_hda_multi_out_analog_open(struct hda_codec *codec,
 245                                  struct hda_multi_out *mout,
 246                                  struct snd_pcm_substream *substream,
 247                                  struct hda_pcm_stream *hinfo);
 248int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
 249                                     struct hda_multi_out *mout,
 250                                     unsigned int stream_tag,
 251                                     unsigned int format,
 252                                     struct snd_pcm_substream *substream);
 253int snd_hda_multi_out_analog_cleanup(struct hda_codec *codec,
 254                                     struct hda_multi_out *mout);
 255
 256/*
 257 * generic proc interface
 258 */
 259#ifdef CONFIG_SND_PROC_FS
 260int snd_hda_codec_proc_new(struct hda_codec *codec);
 261#else
 262static inline int snd_hda_codec_proc_new(struct hda_codec *codec) { return 0; }
 263#endif
 264
 265#define SND_PRINT_BITS_ADVISED_BUFSIZE  16
 266void snd_print_pcm_bits(int pcm, char *buf, int buflen);
 267
 268/*
 269 * Misc
 270 */
 271int snd_hda_add_new_ctls(struct hda_codec *codec,
 272                         const struct snd_kcontrol_new *knew);
 273
 274/*
 275 * Fix-up pin default configurations and add default verbs
 276 */
 277
 278struct hda_pintbl {
 279        hda_nid_t nid;
 280        u32 val;
 281};
 282
 283struct hda_model_fixup {
 284        const int id;
 285        const char *name;
 286};
 287
 288struct hda_fixup {
 289        int type;
 290        bool chained:1;         /* call the chained fixup(s) after this */
 291        bool chained_before:1;  /* call the chained fixup(s) before this */
 292        int chain_id;
 293        union {
 294                const struct hda_pintbl *pins;
 295                const struct hda_verb *verbs;
 296                void (*func)(struct hda_codec *codec,
 297                             const struct hda_fixup *fix,
 298                             int action);
 299        } v;
 300};
 301
 302struct snd_hda_pin_quirk {
 303        unsigned int codec;             /* Codec vendor/device ID */
 304        unsigned short subvendor;       /* PCI subvendor ID */
 305        const struct hda_pintbl *pins;  /* list of matching pins */
 306#ifdef CONFIG_SND_DEBUG_VERBOSE
 307        const char *name;
 308#endif
 309        int value;                      /* quirk value */
 310};
 311
 312#ifdef CONFIG_SND_DEBUG_VERBOSE
 313
 314#define SND_HDA_PIN_QUIRK(_codec, _subvendor, _name, _value, _pins...) \
 315        { .codec = _codec,\
 316          .subvendor = _subvendor,\
 317          .name = _name,\
 318          .value = _value,\
 319          .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \
 320        }
 321#else
 322
 323#define SND_HDA_PIN_QUIRK(_codec, _subvendor, _name, _value, _pins...) \
 324        { .codec = _codec,\
 325          .subvendor = _subvendor,\
 326          .value = _value,\
 327          .pins = (const struct hda_pintbl[]) { _pins, {0, 0}} \
 328        }
 329
 330#endif
 331
 332#define HDA_FIXUP_ID_NOT_SET -1
 333#define HDA_FIXUP_ID_NO_FIXUP -2
 334
 335/* fixup types */
 336enum {
 337        HDA_FIXUP_INVALID,
 338        HDA_FIXUP_PINS,
 339        HDA_FIXUP_VERBS,
 340        HDA_FIXUP_FUNC,
 341        HDA_FIXUP_PINCTLS,
 342};
 343
 344/* fixup action definitions */
 345enum {
 346        HDA_FIXUP_ACT_PRE_PROBE,
 347        HDA_FIXUP_ACT_PROBE,
 348        HDA_FIXUP_ACT_INIT,
 349        HDA_FIXUP_ACT_BUILD,
 350        HDA_FIXUP_ACT_FREE,
 351};
 352
 353int snd_hda_add_verbs(struct hda_codec *codec, const struct hda_verb *list);
 354void snd_hda_apply_verbs(struct hda_codec *codec);
 355void snd_hda_apply_pincfgs(struct hda_codec *codec,
 356                           const struct hda_pintbl *cfg);
 357void snd_hda_apply_fixup(struct hda_codec *codec, int action);
 358void snd_hda_pick_fixup(struct hda_codec *codec,
 359                        const struct hda_model_fixup *models,
 360                        const struct snd_pci_quirk *quirk,
 361                        const struct hda_fixup *fixlist);
 362void snd_hda_pick_pin_fixup(struct hda_codec *codec,
 363                            const struct snd_hda_pin_quirk *pin_quirk,
 364                            const struct hda_fixup *fixlist);
 365
 366/* helper macros to retrieve pin default-config values */
 367#define get_defcfg_connect(cfg) \
 368        ((cfg & AC_DEFCFG_PORT_CONN) >> AC_DEFCFG_PORT_CONN_SHIFT)
 369#define get_defcfg_association(cfg) \
 370        ((cfg & AC_DEFCFG_DEF_ASSOC) >> AC_DEFCFG_ASSOC_SHIFT)
 371#define get_defcfg_location(cfg) \
 372        ((cfg & AC_DEFCFG_LOCATION) >> AC_DEFCFG_LOCATION_SHIFT)
 373#define get_defcfg_sequence(cfg) \
 374        (cfg & AC_DEFCFG_SEQUENCE)
 375#define get_defcfg_device(cfg) \
 376        ((cfg & AC_DEFCFG_DEVICE) >> AC_DEFCFG_DEVICE_SHIFT)
 377#define get_defcfg_misc(cfg) \
 378        ((cfg & AC_DEFCFG_MISC) >> AC_DEFCFG_MISC_SHIFT)
 379
 380/* amp values */
 381#define AMP_IN_MUTE(idx)        (0x7080 | ((idx)<<8))
 382#define AMP_IN_UNMUTE(idx)      (0x7000 | ((idx)<<8))
 383#define AMP_OUT_MUTE            0xb080
 384#define AMP_OUT_UNMUTE          0xb000
 385#define AMP_OUT_ZERO            0xb000
 386/* pinctl values */
 387#define PIN_IN                  (AC_PINCTL_IN_EN)
 388#define PIN_VREFHIZ             (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ)
 389#define PIN_VREF50              (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50)
 390#define PIN_VREFGRD             (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD)
 391#define PIN_VREF80              (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80)
 392#define PIN_VREF100             (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100)
 393#define PIN_OUT                 (AC_PINCTL_OUT_EN)
 394#define PIN_HP                  (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN)
 395#define PIN_HP_AMP              (AC_PINCTL_HP_EN)
 396
 397unsigned int snd_hda_get_default_vref(struct hda_codec *codec, hda_nid_t pin);
 398unsigned int snd_hda_correct_pin_ctl(struct hda_codec *codec,
 399                                     hda_nid_t pin, unsigned int val);
 400int _snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin,
 401                         unsigned int val, bool cached);
 402
 403/**
 404 * _snd_hda_set_pin_ctl - Set a pin-control value safely
 405 * @codec: the codec instance
 406 * @pin: the pin NID to set the control
 407 * @val: the pin-control value (AC_PINCTL_* bits)
 408 *
 409 * This function sets the pin-control value to the given pin, but
 410 * filters out the invalid pin-control bits when the pin has no such
 411 * capabilities.  For example, when PIN_HP is passed but the pin has no
 412 * HP-drive capability, the HP bit is omitted.
 413 *
 414 * The function doesn't check the input VREF capability bits, though.
 415 * Use snd_hda_get_default_vref() to guess the right value.
 416 * Also, this function is only for analog pins, not for HDMI pins.
 417 */
 418static inline int
 419snd_hda_set_pin_ctl(struct hda_codec *codec, hda_nid_t pin, unsigned int val)
 420{
 421        return _snd_hda_set_pin_ctl(codec, pin, val, false);
 422}
 423
 424/**
 425 * snd_hda_set_pin_ctl_cache - Set a pin-control value safely
 426 * @codec: the codec instance
 427 * @pin: the pin NID to set the control
 428 * @val: the pin-control value (AC_PINCTL_* bits)
 429 *
 430 * Just like snd_hda_set_pin_ctl() but write to cache as well.
 431 */
 432static inline int
 433snd_hda_set_pin_ctl_cache(struct hda_codec *codec, hda_nid_t pin,
 434                          unsigned int val)
 435{
 436        return _snd_hda_set_pin_ctl(codec, pin, val, true);
 437}
 438
 439int snd_hda_codec_get_pin_target(struct hda_codec *codec, hda_nid_t nid);
 440int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid,
 441                                 unsigned int val);
 442
 443#define for_each_hda_codec_node(nid, codec) \
 444        for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++)
 445
 446/*
 447 * get widget capabilities
 448 */
 449static inline u32 get_wcaps(struct hda_codec *codec, hda_nid_t nid)
 450{
 451        if (nid < codec->core.start_nid ||
 452            nid >= codec->core.start_nid + codec->core.num_nodes)
 453                return 0;
 454        return codec->wcaps[nid - codec->core.start_nid];
 455}
 456
 457/* get the widget type from widget capability bits */
 458static inline int get_wcaps_type(unsigned int wcaps)
 459{
 460        if (!wcaps)
 461                return -1; /* invalid type */
 462        return (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 463}
 464
 465static inline unsigned int get_wcaps_channels(u32 wcaps)
 466{
 467        unsigned int chans;
 468
 469        chans = (wcaps & AC_WCAP_CHAN_CNT_EXT) >> 13;
 470        chans = ((chans << 1) | 1) + 1;
 471
 472        return chans;
 473}
 474
 475static inline void snd_hda_override_wcaps(struct hda_codec *codec,
 476                                          hda_nid_t nid, u32 val)
 477{
 478        if (nid >= codec->core.start_nid &&
 479            nid < codec->core.start_nid + codec->core.num_nodes)
 480                codec->wcaps[nid - codec->core.start_nid] = val;
 481}
 482
 483u32 query_amp_caps(struct hda_codec *codec, hda_nid_t nid, int direction);
 484int snd_hda_override_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
 485                              unsigned int caps);
 486/**
 487 * snd_hda_query_pin_caps - Query PIN capabilities
 488 * @codec: the HD-auio codec
 489 * @nid: the NID to query
 490 *
 491 * Query PIN capabilities for the given widget.
 492 * Returns the obtained capability bits.
 493 *
 494 * When cap bits have been already read, this doesn't read again but
 495 * returns the cached value.
 496 */
 497static inline u32
 498snd_hda_query_pin_caps(struct hda_codec *codec, hda_nid_t nid)
 499{
 500        return snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
 501
 502}
 503
 504/**
 505 * snd_hda_override_pin_caps - Override the pin capabilities
 506 * @codec: the CODEC
 507 * @nid: the NID to override
 508 * @caps: the capability bits to set
 509 *
 510 * Override the cached PIN capabilitiy bits value by the given one.
 511 *
 512 * Returns zero if successful or a negative error code.
 513 */
 514static inline int
 515snd_hda_override_pin_caps(struct hda_codec *codec, hda_nid_t nid,
 516                          unsigned int caps)
 517{
 518        return snd_hdac_override_parm(&codec->core, nid, AC_PAR_PIN_CAP, caps);
 519}
 520
 521bool snd_hda_check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
 522                           int dir, unsigned int bits);
 523
 524#define nid_has_mute(codec, nid, dir) \
 525        snd_hda_check_amp_caps(codec, nid, dir, (AC_AMPCAP_MUTE | AC_AMPCAP_MIN_MUTE))
 526#define nid_has_volume(codec, nid, dir) \
 527        snd_hda_check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
 528
 529
 530/* flags for hda_nid_item */
 531#define HDA_NID_ITEM_AMP        (1<<0)
 532
 533struct hda_nid_item {
 534        struct snd_kcontrol *kctl;
 535        unsigned int index;
 536        hda_nid_t nid;
 537        unsigned short flags;
 538};
 539
 540int snd_hda_ctl_add(struct hda_codec *codec, hda_nid_t nid,
 541                    struct snd_kcontrol *kctl);
 542int snd_hda_add_nid(struct hda_codec *codec, struct snd_kcontrol *kctl,
 543                    unsigned int index, hda_nid_t nid);
 544void snd_hda_ctls_clear(struct hda_codec *codec);
 545
 546/*
 547 * hwdep interface
 548 */
 549#ifdef CONFIG_SND_HDA_HWDEP
 550int snd_hda_create_hwdep(struct hda_codec *codec);
 551#else
 552static inline int snd_hda_create_hwdep(struct hda_codec *codec) { return 0; }
 553#endif
 554
 555void snd_hda_sysfs_init(struct hda_codec *codec);
 556void snd_hda_sysfs_clear(struct hda_codec *codec);
 557
 558extern const struct attribute_group *snd_hda_dev_attr_groups[];
 559
 560#ifdef CONFIG_SND_HDA_RECONFIG
 561const char *snd_hda_get_hint(struct hda_codec *codec, const char *key);
 562int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key);
 563int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp);
 564#else
 565static inline
 566const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
 567{
 568        return NULL;
 569}
 570
 571static inline
 572int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
 573{
 574        return -ENOENT;
 575}
 576
 577static inline
 578int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
 579{
 580        return -ENOENT;
 581}
 582#endif
 583
 584/*
 585 * power-management
 586 */
 587
 588void snd_hda_schedule_power_save(struct hda_codec *codec);
 589
 590struct hda_amp_list {
 591        hda_nid_t nid;
 592        unsigned char dir;
 593        unsigned char idx;
 594};
 595
 596struct hda_loopback_check {
 597        const struct hda_amp_list *amplist;
 598        int power_on;
 599};
 600
 601int snd_hda_check_amp_list_power(struct hda_codec *codec,
 602                                 struct hda_loopback_check *check,
 603                                 hda_nid_t nid);
 604
 605/* check whether the actual power state matches with the target state */
 606static inline bool
 607snd_hda_check_power_state(struct hda_codec *codec, hda_nid_t nid,
 608                          unsigned int target_state)
 609{
 610        return snd_hdac_check_power_state(&codec->core, nid, target_state);
 611}
 612
 613static inline unsigned int snd_hda_sync_power_state(struct hda_codec *codec,
 614                                                    hda_nid_t nid,
 615                                                    unsigned int target_state)
 616{
 617        return snd_hdac_sync_power_state(&codec->core, nid, target_state);
 618}
 619unsigned int snd_hda_codec_eapd_power_filter(struct hda_codec *codec,
 620                                             hda_nid_t nid,
 621                                             unsigned int power_state);
 622
 623/*
 624 * AMP control callbacks
 625 */
 626/* retrieve parameters from private_value */
 627#define get_amp_nid_(pv)        ((pv) & 0xffff)
 628#define get_amp_nid(kc)         get_amp_nid_((kc)->private_value)
 629#define get_amp_channels(kc)    (((kc)->private_value >> 16) & 0x3)
 630#define get_amp_direction_(pv)  (((pv) >> 18) & 0x1)
 631#define get_amp_direction(kc)   get_amp_direction_((kc)->private_value)
 632#define get_amp_index_(pv)      (((pv) >> 19) & 0xf)
 633#define get_amp_index(kc)       get_amp_index_((kc)->private_value)
 634#define get_amp_offset(kc)      (((kc)->private_value >> 23) & 0x3f)
 635#define get_amp_min_mute(kc)    (((kc)->private_value >> 29) & 0x1)
 636
 637/*
 638 * enum control helper
 639 */
 640int snd_hda_enum_helper_info(struct snd_kcontrol *kcontrol,
 641                             struct snd_ctl_elem_info *uinfo,
 642                             int num_entries, const char * const *texts);
 643#define snd_hda_enum_bool_helper_info(kcontrol, uinfo) \
 644        snd_hda_enum_helper_info(kcontrol, uinfo, 0, NULL)
 645
 646/*
 647 * CEA Short Audio Descriptor data
 648 */
 649struct cea_sad {
 650        int     channels;
 651        int     format;         /* (format == 0) indicates invalid SAD */
 652        int     rates;
 653        int     sample_bits;    /* for LPCM */
 654        int     max_bitrate;    /* for AC3...ATRAC */
 655        int     profile;        /* for WMAPRO */
 656};
 657
 658#define ELD_FIXED_BYTES 20
 659#define ELD_MAX_SIZE    256
 660#define ELD_MAX_MNL     16
 661#define ELD_MAX_SAD     16
 662
 663/*
 664 * ELD: EDID Like Data
 665 */
 666struct parsed_hdmi_eld {
 667        /*
 668         * all fields will be cleared before updating ELD
 669         */
 670        int     baseline_len;
 671        int     eld_ver;
 672        int     cea_edid_ver;
 673        char    monitor_name[ELD_MAX_MNL + 1];
 674        int     manufacture_id;
 675        int     product_id;
 676        u64     port_id;
 677        int     support_hdcp;
 678        int     support_ai;
 679        int     conn_type;
 680        int     aud_synch_delay;
 681        int     spk_alloc;
 682        int     sad_count;
 683        struct cea_sad sad[ELD_MAX_SAD];
 684};
 685
 686struct hdmi_eld {
 687        bool    monitor_present;
 688        bool    eld_valid;
 689        int     eld_size;
 690        char    eld_buffer[ELD_MAX_SIZE];
 691        struct parsed_hdmi_eld info;
 692};
 693
 694int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid);
 695int snd_hdmi_get_eld(struct hda_codec *codec, hda_nid_t nid,
 696                     unsigned char *buf, int *eld_size);
 697int snd_hdmi_parse_eld(struct hda_codec *codec, struct parsed_hdmi_eld *e,
 698                       const unsigned char *buf, int size);
 699void snd_hdmi_show_eld(struct hda_codec *codec, struct parsed_hdmi_eld *e);
 700void snd_hdmi_eld_update_pcm_info(struct parsed_hdmi_eld *e,
 701                              struct hda_pcm_stream *hinfo);
 702
 703int snd_hdmi_get_eld_ati(struct hda_codec *codec, hda_nid_t nid,
 704                         unsigned char *buf, int *eld_size,
 705                         bool rev3_or_later);
 706
 707#ifdef CONFIG_SND_PROC_FS
 708void snd_hdmi_print_eld_info(struct hdmi_eld *eld,
 709                             struct snd_info_buffer *buffer);
 710void snd_hdmi_write_eld_info(struct hdmi_eld *eld,
 711                             struct snd_info_buffer *buffer);
 712#endif
 713
 714#define SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE 80
 715void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen);
 716
 717/*
 718 */
 719#define codec_err(codec, fmt, args...) \
 720        dev_err(hda_codec_dev(codec), fmt, ##args)
 721#define codec_warn(codec, fmt, args...) \
 722        dev_warn(hda_codec_dev(codec), fmt, ##args)
 723#define codec_info(codec, fmt, args...) \
 724        dev_info(hda_codec_dev(codec), fmt, ##args)
 725#define codec_dbg(codec, fmt, args...) \
 726        dev_dbg(hda_codec_dev(codec), fmt, ##args)
 727
 728#endif /* __SOUND_HDA_LOCAL_H */
 729