/*
 * Common codes for Realtek codec quirks
 * included by patch_realtek.c
 */

/*
 * configuration template - to be copied to the spec instance
 */
struct alc_config_preset {
        const struct snd_kcontrol_new *mixers[5]; /* should be identical size
                                             * with spec
                                             */
        const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
        const struct hda_verb *init_verbs[5];
        unsigned int num_dacs;
        const hda_nid_t *dac_nids;
        hda_nid_t dig_out_nid;          /* optional */
        hda_nid_t hp_nid;               /* optional */
        const hda_nid_t *slave_dig_outs;
        unsigned int num_adc_nids;
        const hda_nid_t *adc_nids;
        const hda_nid_t *capsrc_nids;
        hda_nid_t dig_in_nid;
        unsigned int num_channel_mode;
        const struct hda_channel_mode *channel_mode;
        int need_dac_fix;
        int const_channel_count;
        unsigned int num_mux_defs;
        const struct hda_input_mux *input_mux;
        void (*unsol_event)(struct hda_codec *, unsigned int);
        void (*setup)(struct hda_codec *);
        void (*init_hook)(struct hda_codec *);
#ifdef CONFIG_SND_HDA_POWER_SAVE
        const struct hda_amp_list *loopbacks;
        void (*power_hook)(struct hda_codec *codec);
#endif
};

/*
 * channel mode setting
 */
static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
                            struct snd_ctl_elem_info *uinfo)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        struct alc_spec *spec = codec->spec;
        return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
                                    spec->num_channel_mode);
}

static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
                           struct snd_ctl_elem_value *ucontrol)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        struct alc_spec *spec = codec->spec;
        return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
                                   spec->num_channel_mode,
                                   spec->ext_channel_count);
}

static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
                           struct snd_ctl_elem_value *ucontrol)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        struct alc_spec *spec = codec->spec;
        int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
                                      spec->num_channel_mode,
                                      &spec->ext_channel_count);
        if (err >= 0 && !spec->const_channel_count) {
                spec->multiout.max_channels = spec->ext_channel_count;
                if (spec->need_dac_fix)
                        spec->multiout.num_dacs = spec->multiout.max_channels / 2;
        }
        return err;
}

/*
 * Control the mode of pin widget settings via the mixer.  "pc" is used
 * instead of "%" to avoid consequences of accidentally treating the % as
 * being part of a format specifier.  Maximum allowed length of a value is
 * 63 characters plus NULL terminator.
 *
 * Note: some retasking pin complexes seem to ignore requests for input
 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 * are requested.  Therefore order this list so that this behaviour will not
 * cause problems when mixer clients move through the enum sequentially.
 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 * March 2006.
 */
static const char * const alc_pin_mode_names[] = {
        "Mic 50pc bias", "Mic 80pc bias",
        "Line in", "Line out", "Headphone out",
};
static const unsigned char alc_pin_mode_values[] = {
        PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
};
/* The control can present all 5 options, or it can limit the options based
 * in the pin being assumed to be exclusively an input or an output pin.  In
 * addition, "input" pins may or may not process the mic bias option
 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 * accept requests for bias as of chip versions up to March 2006) and/or
 * wiring in the computer.
 */
#define ALC_PIN_DIR_IN              0x00
#define ALC_PIN_DIR_OUT             0x01
#define ALC_PIN_DIR_INOUT           0x02
#define ALC_PIN_DIR_IN_NOMICBIAS    0x03
#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04

/* Info about the pin modes supported by the different pin direction modes.
 * For each direction the minimum and maximum values are given.
 */
static const signed char alc_pin_mode_dir_info[5][2] = {
        { 0, 2 },    /* ALC_PIN_DIR_IN */
        { 3, 4 },    /* ALC_PIN_DIR_OUT */
        { 0, 4 },    /* ALC_PIN_DIR_INOUT */
        { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
        { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
};
#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
#define alc_pin_mode_n_items(_dir) \
        (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)

static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_info *uinfo)
{
        unsigned int item_num = uinfo->value.enumerated.item;
        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;

        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
        uinfo->count = 1;
        uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);

        if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
                item_num = alc_pin_mode_min(dir);
        strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
        return 0;
}

static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
                            struct snd_ctl_elem_value *ucontrol)
{
        unsigned int i;
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
        long *valp = ucontrol->value.integer.value;
        unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
                                                 AC_VERB_GET_PIN_WIDGET_CONTROL,
                                                 0x00);

        /* Find enumerated value for current pinctl setting */
        i = alc_pin_mode_min(dir);
        while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
                i++;
        *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
        return 0;
}

static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
                            struct snd_ctl_elem_value *ucontrol)
{
        signed int change;
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
        long val = *ucontrol->value.integer.value;
        unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
                                                 AC_VERB_GET_PIN_WIDGET_CONTROL,
                                                 0x00);

        if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
                val = alc_pin_mode_min(dir);

        change = pinctl != alc_pin_mode_values[val];
        if (change) {
                /* Set pin mode to that requested */
                snd_hda_codec_write_cache(codec, nid, 0,
                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
                                          alc_pin_mode_values[val]);

                /* Also enable the retasking pin's input/output as required
                 * for the requested pin mode.  Enum values of 2 or less are
                 * input modes.
                 *
                 * Dynamically switching the input/output buffers probably
                 * reduces noise slightly (particularly on input) so we'll
                 * do it.  However, having both input and output buffers
                 * enabled simultaneously doesn't seem to be problematic if
                 * this turns out to be necessary in the future.
                 */
                if (val <= 2) {
                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
                                                 HDA_AMP_MUTE, HDA_AMP_MUTE);
                        snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
                                                 HDA_AMP_MUTE, 0);
                } else {
                        snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
                                                 HDA_AMP_MUTE, HDA_AMP_MUTE);
                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
                                                 HDA_AMP_MUTE, 0);
                }
        }
        return change;
}

#define ALC_PIN_MODE(xname, nid, dir) \
        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
          .info = alc_pin_mode_info, \
          .get = alc_pin_mode_get, \
          .put = alc_pin_mode_put, \
          .private_value = nid | (dir<<16) }

/* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 * together using a mask with more than one bit set.  This control is
 * currently used only by the ALC260 test model.  At this stage they are not
 * needed for any "production" models.
 */
#ifdef CONFIG_SND_DEBUG
#define alc_gpio_data_info      snd_ctl_boolean_mono_info

static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_value *ucontrol)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
        long *valp = ucontrol->value.integer.value;
        unsigned int val = snd_hda_codec_read(codec, nid, 0,
                                              AC_VERB_GET_GPIO_DATA, 0x00);

        *valp = (val & mask) != 0;
        return 0;
}
static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
                             struct snd_ctl_elem_value *ucontrol)
{
        signed int change;
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
        long val = *ucontrol->value.integer.value;
        unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
                                                    AC_VERB_GET_GPIO_DATA,
                                                    0x00);

        /* Set/unset the masked GPIO bit(s) as needed */
        change = (val == 0 ? 0 : mask) != (gpio_data & mask);
        if (val == 0)
                gpio_data &= ~mask;
        else
                gpio_data |= mask;
        snd_hda_codec_write_cache(codec, nid, 0,
                                  AC_VERB_SET_GPIO_DATA, gpio_data);

        return change;
}
#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
          .info = alc_gpio_data_info, \
          .get = alc_gpio_data_get, \
          .put = alc_gpio_data_put, \
          .private_value = nid | (mask<<16) }
#endif   /* CONFIG_SND_DEBUG */

/* A switch control to allow the enabling of the digital IO pins on the
 * ALC260.  This is incredibly simplistic; the intention of this control is
 * to provide something in the test model allowing digital outputs to be
 * identified if present.  If models are found which can utilise these
 * outputs a more complete mixer control can be devised for those models if
 * necessary.
 */
#ifdef CONFIG_SND_DEBUG
#define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info

static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
                              struct snd_ctl_elem_value *ucontrol)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
        long *valp = ucontrol->value.integer.value;
        unsigned int val = snd_hda_codec_read(codec, nid, 0,
                                              AC_VERB_GET_DIGI_CONVERT_1, 0x00);

        *valp = (val & mask) != 0;
        return 0;
}
static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
                              struct snd_ctl_elem_value *ucontrol)
{
        signed int change;
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
        long val = *ucontrol->value.integer.value;
        unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
                                                    AC_VERB_GET_DIGI_CONVERT_1,
                                                    0x00);

        /* Set/unset the masked control bit(s) as needed */
        change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
        if (val==0)
                ctrl_data &= ~mask;
        else
                ctrl_data |= mask;
        snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
                                  ctrl_data);

        return change;
}
#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
          .info = alc_spdif_ctrl_info, \
          .get = alc_spdif_ctrl_get, \
          .put = alc_spdif_ctrl_put, \
          .private_value = nid | (mask<<16) }
#endif   /* CONFIG_SND_DEBUG */

/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 * Again, this is only used in the ALC26x test models to help identify when
 * the EAPD line must be asserted for features to work.
 */
#ifdef CONFIG_SND_DEBUG
#define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info

static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
                              struct snd_ctl_elem_value *ucontrol)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
        long *valp = ucontrol->value.integer.value;
        unsigned int val = snd_hda_codec_read(codec, nid, 0,
                                              AC_VERB_GET_EAPD_BTLENABLE, 0x00);

        *valp = (val & mask) != 0;
        return 0;
}

static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
                              struct snd_ctl_elem_value *ucontrol)
{
        int change;
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
        hda_nid_t nid = kcontrol->private_value & 0xffff;
        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
        long val = *ucontrol->value.integer.value;
        unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
                                                    AC_VERB_GET_EAPD_BTLENABLE,
                                                    0x00);

        /* Set/unset the masked control bit(s) as needed */
        change = (!val ? 0 : mask) != (ctrl_data & mask);
        if (!val)
                ctrl_data &= ~mask;
        else
                ctrl_data |= mask;
        snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
                                  ctrl_data);

        return change;
}

#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
          .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
          .info = alc_eapd_ctrl_info, \
          .get = alc_eapd_ctrl_get, \
          .put = alc_eapd_ctrl_put, \
          .private_value = nid | (mask<<16) }
#endif   /* CONFIG_SND_DEBUG */

static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
{
        struct alc_spec *spec = codec->spec;
        struct auto_pin_cfg *cfg = &spec->autocfg;

        if (!cfg->line_outs) {
                while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
                       cfg->line_out_pins[cfg->line_outs])
                        cfg->line_outs++;
        }
        if (!cfg->speaker_outs) {
                while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
                       cfg->speaker_pins[cfg->speaker_outs])
                        cfg->speaker_outs++;
        }
        if (!cfg->hp_outs) {
                while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
                       cfg->hp_pins[cfg->hp_outs])
                        cfg->hp_outs++;
        }
}

/*
 * set up from the preset table
 */
static void setup_preset(struct hda_codec *codec,
                         const struct alc_config_preset *preset)
{
        struct alc_spec *spec = codec->spec;
        int i;

        for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
                add_mixer(spec, preset->mixers[i]);
        spec->cap_mixer = preset->cap_mixer;
        for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
             i++)
                add_verb(spec, preset->init_verbs[i]);

        spec->channel_mode = preset->channel_mode;
        spec->num_channel_mode = preset->num_channel_mode;
        spec->need_dac_fix = preset->need_dac_fix;
        spec->const_channel_count = preset->const_channel_count;

        if (preset->const_channel_count)
                spec->multiout.max_channels = preset->const_channel_count;
        else
                spec->multiout.max_channels = spec->channel_mode[0].channels;
        spec->ext_channel_count = spec->channel_mode[0].channels;

        spec->multiout.num_dacs = preset->num_dacs;
        spec->multiout.dac_nids = preset->dac_nids;
        spec->multiout.dig_out_nid = preset->dig_out_nid;
        spec->multiout.slave_dig_outs = preset->slave_dig_outs;
        spec->multiout.hp_nid = preset->hp_nid;

        spec->num_mux_defs = preset->num_mux_defs;
        if (!spec->num_mux_defs)
                spec->num_mux_defs = 1;
        spec->input_mux = preset->input_mux;

        spec->num_adc_nids = preset->num_adc_nids;
        spec->adc_nids = preset->adc_nids;
        spec->capsrc_nids = preset->capsrc_nids;
        spec->dig_in_nid = preset->dig_in_nid;

        spec->unsol_event = preset->unsol_event;
        spec->init_hook = preset->init_hook;
#ifdef CONFIG_SND_HDA_POWER_SAVE
        spec->power_hook = preset->power_hook;
        spec->loopback.amplist = preset->loopbacks;
#endif

        if (preset->setup)
                preset->setup(codec);

        alc_fixup_autocfg_pin_nums(codec);
}

static void alc_simple_setup_automute(struct alc_spec *spec, int mode)
{
        int lo_pin = spec->autocfg.line_out_pins[0];

        if (lo_pin == spec->autocfg.speaker_pins[0] ||
                lo_pin == spec->autocfg.hp_pins[0])
                lo_pin = 0;
        spec->automute_mode = mode;
        spec->detect_hp = !!spec->autocfg.hp_pins[0];
        spec->detect_lo = !!lo_pin;
        spec->automute_lo = spec->automute_lo_possible = !!lo_pin;
        spec->automute_speaker = spec->automute_speaker_possible = !!spec->autocfg.speaker_pins[0];
}

/* auto-toggle front mic */
static void alc88x_simple_mic_automute(struct hda_codec *codec)
{
        unsigned int present;
        unsigned char bits;

        present = snd_hda_jack_detect(codec, 0x18);
        bits = present ? HDA_AMP_MUTE : 0;
        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
}