// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * ATI/AMD codec support
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/unaligned.h>
#include <sound/core.h>
#include <sound/tlv.h>
#include <sound/hdaudio.h>
#include <sound/hda_codec.h>
#include "hda_local.h"
#include "hdmi_local.h"

#define is_amdhdmi_rev3_or_later(codec) \
        ((codec)->core.vendor_id == 0x1002aa01 && \
         ((codec)->core.revision_id & 0xff00) >= 0x0300)
#define has_amd_full_remap_support(codec) is_amdhdmi_rev3_or_later(codec)

/* ATI/AMD specific HDA pin verbs, see the AMD HDA Verbs specification */
#define ATI_VERB_SET_CHANNEL_ALLOCATION 0x771
#define ATI_VERB_SET_DOWNMIX_INFO       0x772
#define ATI_VERB_SET_MULTICHANNEL_01    0x777
#define ATI_VERB_SET_MULTICHANNEL_23    0x778
#define ATI_VERB_SET_MULTICHANNEL_45    0x779
#define ATI_VERB_SET_MULTICHANNEL_67    0x77a
#define ATI_VERB_SET_HBR_CONTROL        0x77c
#define ATI_VERB_SET_MULTICHANNEL_1     0x785
#define ATI_VERB_SET_MULTICHANNEL_3     0x786
#define ATI_VERB_SET_MULTICHANNEL_5     0x787
#define ATI_VERB_SET_MULTICHANNEL_7     0x788
#define ATI_VERB_SET_MULTICHANNEL_MODE  0x789
#define ATI_VERB_GET_CHANNEL_ALLOCATION 0xf71
#define ATI_VERB_GET_DOWNMIX_INFO       0xf72
#define ATI_VERB_GET_MULTICHANNEL_01    0xf77
#define ATI_VERB_GET_MULTICHANNEL_23    0xf78
#define ATI_VERB_GET_MULTICHANNEL_45    0xf79
#define ATI_VERB_GET_MULTICHANNEL_67    0xf7a
#define ATI_VERB_GET_HBR_CONTROL        0xf7c
#define ATI_VERB_GET_MULTICHANNEL_1     0xf85
#define ATI_VERB_GET_MULTICHANNEL_3     0xf86
#define ATI_VERB_GET_MULTICHANNEL_5     0xf87
#define ATI_VERB_GET_MULTICHANNEL_7     0xf88
#define ATI_VERB_GET_MULTICHANNEL_MODE  0xf89

/* AMD specific HDA cvt verbs */
#define ATI_VERB_SET_RAMP_RATE          0x770
#define ATI_VERB_GET_RAMP_RATE          0xf70

#define ATI_OUT_ENABLE 0x1

#define ATI_MULTICHANNEL_MODE_PAIRED    0
#define ATI_MULTICHANNEL_MODE_SINGLE    1

#define ATI_HBR_CAPABLE 0x01
#define ATI_HBR_ENABLE 0x10

/* ATI/AMD specific ELD emulation */

#define ATI_VERB_SET_AUDIO_DESCRIPTOR   0x776
#define ATI_VERB_SET_SINK_INFO_INDEX    0x780
#define ATI_VERB_GET_SPEAKER_ALLOCATION 0xf70
#define ATI_VERB_GET_AUDIO_DESCRIPTOR   0xf76
#define ATI_VERB_GET_AUDIO_VIDEO_DELAY  0xf7b
#define ATI_VERB_GET_SINK_INFO_INDEX    0xf80
#define ATI_VERB_GET_SINK_INFO_DATA     0xf81

#define ATI_SPKALLOC_SPKALLOC           0x007f
#define ATI_SPKALLOC_TYPE_HDMI          0x0100
#define ATI_SPKALLOC_TYPE_DISPLAYPORT   0x0200

/* first three bytes are just standard SAD */
#define ATI_AUDIODESC_CHANNELS          0x00000007
#define ATI_AUDIODESC_RATES             0x0000ff00
#define ATI_AUDIODESC_LPCM_STEREO_RATES 0xff000000

/* in standard HDMI VSDB format */
#define ATI_DELAY_VIDEO_LATENCY         0x000000ff
#define ATI_DELAY_AUDIO_LATENCY         0x0000ff00

enum ati_sink_info_idx {
        ATI_INFO_IDX_MANUFACTURER_ID    = 0,
        ATI_INFO_IDX_PRODUCT_ID         = 1,
        ATI_INFO_IDX_SINK_DESC_LEN      = 2,
        ATI_INFO_IDX_PORT_ID_LOW        = 3,
        ATI_INFO_IDX_PORT_ID_HIGH       = 4,
        ATI_INFO_IDX_SINK_DESC_FIRST    = 5,
        ATI_INFO_IDX_SINK_DESC_LAST     = 22, /* max len 18 bytes */
};

static int get_eld_ati(struct hda_codec *codec, hda_nid_t nid,
                       unsigned char *buf, int *eld_size, bool rev3_or_later)
{
        int spkalloc, ati_sad, aud_synch;
        int sink_desc_len = 0;
        int pos, i;

        /* ATI/AMD does not have ELD, emulate it */

        spkalloc = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SPEAKER_ALLOCATION, 0);

        if (spkalloc <= 0) {
                codec_info(codec, "HDMI ATI/AMD: no speaker allocation for ELD\n");
                return -EINVAL;
        }

        memset(buf, 0, ELD_FIXED_BYTES + ELD_MAX_MNL + ELD_MAX_SAD * 3);

        /* version */
        buf[0] = ELD_VER_CEA_861D << 3;

        /* speaker allocation from EDID */
        buf[7] = spkalloc & ATI_SPKALLOC_SPKALLOC;

        /* is DisplayPort? */
        if (spkalloc & ATI_SPKALLOC_TYPE_DISPLAYPORT)
                buf[5] |= 0x04;

        pos = ELD_FIXED_BYTES;

        if (rev3_or_later) {
                int sink_info;

                snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PORT_ID_LOW);
                sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
                put_unaligned_le32(sink_info, buf + 8);

                snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PORT_ID_HIGH);
                sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
                put_unaligned_le32(sink_info, buf + 12);

                snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_MANUFACTURER_ID);
                sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
                put_unaligned_le16(sink_info, buf + 16);

                snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_PRODUCT_ID);
                sink_info = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
                put_unaligned_le16(sink_info, buf + 18);

                snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_SINK_DESC_LEN);
                sink_desc_len = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);

                if (sink_desc_len > ELD_MAX_MNL) {
                        codec_info(codec, "HDMI ATI/AMD: Truncating HDMI sink description with length %d\n",
                                   sink_desc_len);
                        sink_desc_len = ELD_MAX_MNL;
                }

                buf[4] |= sink_desc_len;

                for (i = 0; i < sink_desc_len; i++) {
                        snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_SINK_INFO_INDEX, ATI_INFO_IDX_SINK_DESC_FIRST + i);
                        buf[pos++] = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_SINK_INFO_DATA, 0);
                }
        }

        for (i = AUDIO_CODING_TYPE_LPCM; i <= AUDIO_CODING_TYPE_WMAPRO; i++) {
                if (i == AUDIO_CODING_TYPE_SACD || i == AUDIO_CODING_TYPE_DST)
                        continue; /* not handled by ATI/AMD */

                snd_hda_codec_write(codec, nid, 0, ATI_VERB_SET_AUDIO_DESCRIPTOR, i << 3);
                ati_sad = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_AUDIO_DESCRIPTOR, 0);

                if (ati_sad <= 0)
                        continue;

                if (ati_sad & ATI_AUDIODESC_RATES) {
                        /* format is supported, copy SAD as-is */
                        buf[pos++] = (ati_sad & 0x0000ff) >> 0;
                        buf[pos++] = (ati_sad & 0x00ff00) >> 8;
                        buf[pos++] = (ati_sad & 0xff0000) >> 16;
                }

                if (i == AUDIO_CODING_TYPE_LPCM
                    && (ati_sad & ATI_AUDIODESC_LPCM_STEREO_RATES)
                    && (ati_sad & ATI_AUDIODESC_LPCM_STEREO_RATES) >> 16 != (ati_sad & ATI_AUDIODESC_RATES)) {
                        /* for PCM there is a separate stereo rate mask */
                        buf[pos++] = ((ati_sad & 0x000000ff) & ~ATI_AUDIODESC_CHANNELS) | 0x1;
                        /* rates from the extra byte */
                        buf[pos++] = (ati_sad & 0xff000000) >> 24;
                        buf[pos++] = (ati_sad & 0x00ff0000) >> 16;
                }
        }

        if (pos == ELD_FIXED_BYTES + sink_desc_len) {
                codec_info(codec, "HDMI ATI/AMD: no audio descriptors for ELD\n");
                return -EINVAL;
        }

        /*
         * HDMI VSDB latency format:
         * separately for both audio and video:
         *  0          field not valid or unknown latency
         *  [1..251]   msecs = (x-1)*2  (max 500ms with x = 251 = 0xfb)
         *  255        audio/video not supported
         *
         * HDA latency format:
         * single value indicating video latency relative to audio:
         *  0          unknown or 0ms
         *  [1..250]   msecs = x*2  (max 500ms with x = 250 = 0xfa)
         *  [251..255] reserved
         */
        aud_synch = snd_hda_codec_read(codec, nid, 0, ATI_VERB_GET_AUDIO_VIDEO_DELAY, 0);
        if ((aud_synch & ATI_DELAY_VIDEO_LATENCY) && (aud_synch & ATI_DELAY_AUDIO_LATENCY)) {
                int video_latency_hdmi = (aud_synch & ATI_DELAY_VIDEO_LATENCY);
                int audio_latency_hdmi = (aud_synch & ATI_DELAY_AUDIO_LATENCY) >> 8;

                if (video_latency_hdmi <= 0xfb && audio_latency_hdmi <= 0xfb &&
                    video_latency_hdmi > audio_latency_hdmi)
                        buf[6] = video_latency_hdmi - audio_latency_hdmi;
                /* else unknown/invalid or 0ms or video ahead of audio, so use zero */
        }

        /* SAD count */
        buf[5] |= ((pos - ELD_FIXED_BYTES - sink_desc_len) / 3) << 4;

        /* Baseline ELD block length is 4-byte aligned */
        pos = round_up(pos, 4);

        /* Baseline ELD length (4-byte header is not counted in) */
        buf[2] = (pos - 4) / 4;

        *eld_size = pos;

        return 0;
}

static int atihdmi_pin_get_eld(struct hda_codec *codec, hda_nid_t nid,
                               int dev_id, unsigned char *buf, int *eld_size)
{
        WARN_ON(dev_id != 0);
        /* call hda_eld.c ATI/AMD-specific function */
        return get_eld_ati(codec, nid, buf, eld_size,
                           is_amdhdmi_rev3_or_later(codec));
}

static void atihdmi_pin_setup_infoframe(struct hda_codec *codec,
                                        hda_nid_t pin_nid, int dev_id, int ca,
                                        int active_channels, int conn_type)
{
        WARN_ON(dev_id != 0);
        snd_hda_codec_write(codec, pin_nid, 0, ATI_VERB_SET_CHANNEL_ALLOCATION, ca);
}

static int atihdmi_paired_swap_fc_lfe(int pos)
{
        /*
         * ATI/AMD have automatic FC/LFE swap built-in
         * when in pairwise mapping mode.
         */

        switch (pos) {
        /* see channel_allocations[].speakers[] */
        case 2: return 3;
        case 3: return 2;
        default: return pos;
        }
}

static int atihdmi_paired_chmap_validate(struct hdac_chmap *chmap,
                        int ca, int chs, unsigned char *map)
{
        struct hdac_cea_channel_speaker_allocation *cap;
        int i, j;

        /* check that only channel pairs need to be remapped on old pre-rev3 ATI/AMD */

        cap = snd_hdac_get_ch_alloc_from_ca(ca);
        for (i = 0; i < chs; ++i) {
                int mask = snd_hdac_chmap_to_spk_mask(map[i]);
                bool ok = false;
                bool companion_ok = false;

                if (!mask)
                        continue;

                for (j = 0 + i % 2; j < 8; j += 2) {
                        int chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j);

                        if (cap->speakers[chan_idx] == mask) {
                                /* channel is in a supported position */
                                ok = true;

                                if (i % 2 == 0 && i + 1 < chs) {
                                        /* even channel, check the odd companion */
                                        int comp_chan_idx = 7 - atihdmi_paired_swap_fc_lfe(j + 1);
                                        int comp_mask_req = snd_hdac_chmap_to_spk_mask(map[i+1]);
                                        int comp_mask_act = cap->speakers[comp_chan_idx];

                                        if (comp_mask_req == comp_mask_act)
                                                companion_ok = true;
                                        else
                                                return -EINVAL;
                                }
                                break;
                        }
                }

                if (!ok)
                        return -EINVAL;

                if (companion_ok)
                        i++; /* companion channel already checked */
        }

        return 0;
}

static int atihdmi_pin_set_slot_channel(struct hdac_device *hdac,
                hda_nid_t pin_nid, int hdmi_slot, int stream_channel)
{
        struct hda_codec *codec = hdac_to_hda_codec(hdac);
        int verb;
        int ati_channel_setup = 0;

        if (hdmi_slot > 7)
                return -EINVAL;

        if (!has_amd_full_remap_support(codec)) {
                hdmi_slot = atihdmi_paired_swap_fc_lfe(hdmi_slot);

                /* In case this is an odd slot but without stream channel, do not
                 * disable the slot since the corresponding even slot could have a
                 * channel. In case neither have a channel, the slot pair will be
                 * disabled when this function is called for the even slot.
                 */
                if (hdmi_slot % 2 != 0 && stream_channel == 0xf)
                        return 0;

                hdmi_slot -= hdmi_slot % 2;

                if (stream_channel != 0xf)
                        stream_channel -= stream_channel % 2;
        }

        verb = ATI_VERB_SET_MULTICHANNEL_01 + hdmi_slot/2 + (hdmi_slot % 2) * 0x00e;

        /* ati_channel_setup format: [7..4] = stream_channel_id, [1] = mute, [0] = enable */

        if (stream_channel != 0xf)
                ati_channel_setup = (stream_channel << 4) | ATI_OUT_ENABLE;

        return snd_hda_codec_write(codec, pin_nid, 0, verb, ati_channel_setup);
}

static int atihdmi_pin_get_slot_channel(struct hdac_device *hdac,
                                hda_nid_t pin_nid, int asp_slot)
{
        struct hda_codec *codec = hdac_to_hda_codec(hdac);
        bool was_odd = false;
        int ati_asp_slot = asp_slot;
        int verb;
        int ati_channel_setup;

        if (asp_slot > 7)
                return -EINVAL;

        if (!has_amd_full_remap_support(codec)) {
                ati_asp_slot = atihdmi_paired_swap_fc_lfe(asp_slot);
                if (ati_asp_slot % 2 != 0) {
                        ati_asp_slot -= 1;
                        was_odd = true;
                }
        }

        verb = ATI_VERB_GET_MULTICHANNEL_01 + ati_asp_slot/2 + (ati_asp_slot % 2) * 0x00e;

        ati_channel_setup = snd_hda_codec_read(codec, pin_nid, 0, verb, 0);

        if (!(ati_channel_setup & ATI_OUT_ENABLE))
                return 0xf;

        return ((ati_channel_setup & 0xf0) >> 4) + !!was_odd;
}

static int atihdmi_paired_chmap_cea_alloc_validate_get_type(
                struct hdac_chmap *chmap,
                struct hdac_cea_channel_speaker_allocation *cap,
                int channels)
{
        int c;

        /*
         * Pre-rev3 ATI/AMD codecs operate in a paired channel mode, so
         * we need to take that into account (a single channel may take 2
         * channel slots if we need to carry a silent channel next to it).
         * On Rev3+ AMD codecs this function is not used.
         */
        int chanpairs = 0;

        /* We only produce even-numbered channel count TLVs */
        if ((channels % 2) != 0)
                return -1;

        for (c = 0; c < 7; c += 2) {
                if (cap->speakers[c] || cap->speakers[c+1])
                        chanpairs++;
        }

        if (chanpairs * 2 != channels)
                return -1;

        return SNDRV_CTL_TLVT_CHMAP_PAIRED;
}

static void atihdmi_paired_cea_alloc_to_tlv_chmap(struct hdac_chmap *hchmap,
                struct hdac_cea_channel_speaker_allocation *cap,
                unsigned int *chmap, int channels)
{
        /* produce paired maps for pre-rev3 ATI/AMD codecs */
        int count = 0;
        int c;

        for (c = 7; c >= 0; c--) {
                int chan = 7 - atihdmi_paired_swap_fc_lfe(7 - c);
                int spk = cap->speakers[chan];

                if (!spk) {
                        /* add N/A channel if the companion channel is occupied */
                        if (cap->speakers[chan + (chan % 2 ? -1 : 1)])
                                chmap[count++] = SNDRV_CHMAP_NA;

                        continue;
                }

                chmap[count++] = snd_hdac_spk_to_chmap(spk);
        }

        WARN_ON(count != channels);
}

static int atihdmi_pin_hbr_setup(struct hda_codec *codec, hda_nid_t pin_nid,
                                 int dev_id, bool hbr)
{
        int hbr_ctl, hbr_ctl_new;

        WARN_ON(dev_id != 0);

        hbr_ctl = snd_hda_codec_read(codec, pin_nid, 0, ATI_VERB_GET_HBR_CONTROL, 0);
        if (hbr_ctl >= 0 && (hbr_ctl & ATI_HBR_CAPABLE)) {
                if (hbr)
                        hbr_ctl_new = hbr_ctl | ATI_HBR_ENABLE;
                else
                        hbr_ctl_new = hbr_ctl & ~ATI_HBR_ENABLE;

                codec_dbg(codec,
                          "%s: NID=0x%x, %shbr-ctl=0x%x\n",
                          __func__,
                          pin_nid,
                          hbr_ctl == hbr_ctl_new ? "" : "new-",
                          hbr_ctl_new);

                if (hbr_ctl != hbr_ctl_new)
                        snd_hda_codec_write(codec, pin_nid, 0,
                                                ATI_VERB_SET_HBR_CONTROL,
                                                hbr_ctl_new);

        } else if (hbr)
                return -EINVAL;

        return 0;
}

static int atihdmi_setup_stream(struct hda_codec *codec, hda_nid_t cvt_nid,
                                hda_nid_t pin_nid, int dev_id,
                                u32 stream_tag, int format)
{
        if (is_amdhdmi_rev3_or_later(codec)) {
                int ramp_rate = 180; /* default as per AMD spec */
                /* disable ramp-up/down for non-pcm as per AMD spec */
                if (format & AC_FMT_TYPE_NON_PCM)
                        ramp_rate = 0;

                snd_hda_codec_write(codec, cvt_nid, 0, ATI_VERB_SET_RAMP_RATE, ramp_rate);
        }

        return snd_hda_hdmi_setup_stream(codec, cvt_nid, pin_nid, dev_id,
                                         stream_tag, format);
}


static int atihdmi_init(struct hda_codec *codec)
{
        struct hdmi_spec *spec = codec->spec;
        int pin_idx, err;

        err = snd_hda_hdmi_generic_init(codec);

        if (err)
                return err;

        for (pin_idx = 0; pin_idx < spec->num_pins; pin_idx++) {
                struct hdmi_spec_per_pin *per_pin = get_pin(spec, pin_idx);

                /* make sure downmix information in infoframe is zero */
                snd_hda_codec_write(codec, per_pin->pin_nid, 0, ATI_VERB_SET_DOWNMIX_INFO, 0);

                /* enable channel-wise remap mode if supported */
                if (has_amd_full_remap_support(codec))
                        snd_hda_codec_write(codec, per_pin->pin_nid, 0,
                                            ATI_VERB_SET_MULTICHANNEL_MODE,
                                            ATI_MULTICHANNEL_MODE_SINGLE);
        }
        codec->auto_runtime_pm = 1;

        return 0;
}

/* map from pin NID to port; port is 0-based */
/* for AMD: assume widget NID starting from 3, with step 2 (3, 5, 7, ...) */
static int atihdmi_pin2port(void *audio_ptr, int pin_nid)
{
        return pin_nid / 2 - 1;
}

/* reverse-map from port to pin NID: see above */
static int atihdmi_port2pin(struct hda_codec *codec, int port)
{
        return port * 2 + 3;
}

static const struct drm_audio_component_audio_ops atihdmi_audio_ops = {
        .pin2port = atihdmi_pin2port,
        .pin_eld_notify = snd_hda_hdmi_acomp_pin_eld_notify,
        .master_bind = snd_hda_hdmi_acomp_master_bind,
        .master_unbind = snd_hda_hdmi_acomp_master_unbind,
};

static int atihdmi_probe(struct hda_codec *codec, const struct hda_device_id *id)
{
        struct hdmi_spec *spec;
        struct hdmi_spec_per_cvt *per_cvt;
        int err, cvt_idx;

        err = snd_hda_hdmi_generic_probe(codec);
        if (err)
                return err;

        spec = codec->spec;

        spec->static_pcm_mapping = true;

        spec->ops.pin_get_eld = atihdmi_pin_get_eld;
        spec->ops.pin_setup_infoframe = atihdmi_pin_setup_infoframe;
        spec->ops.pin_hbr_setup = atihdmi_pin_hbr_setup;
        spec->ops.setup_stream = atihdmi_setup_stream;

        spec->chmap.ops.pin_get_slot_channel = atihdmi_pin_get_slot_channel;
        spec->chmap.ops.pin_set_slot_channel = atihdmi_pin_set_slot_channel;

        if (!has_amd_full_remap_support(codec)) {
                /* override to ATI/AMD-specific versions with pairwise mapping */
                spec->chmap.ops.chmap_cea_alloc_validate_get_type =
                        atihdmi_paired_chmap_cea_alloc_validate_get_type;
                spec->chmap.ops.cea_alloc_to_tlv_chmap =
                                atihdmi_paired_cea_alloc_to_tlv_chmap;
                spec->chmap.ops.chmap_validate = atihdmi_paired_chmap_validate;
        }

        /* ATI/AMD converters do not advertise all of their capabilities */
        for (cvt_idx = 0; cvt_idx < spec->num_cvts; cvt_idx++) {
                per_cvt = get_cvt(spec, cvt_idx);
                per_cvt->channels_max = max(per_cvt->channels_max, 8u);
                per_cvt->rates |= SUPPORTED_RATES;
                per_cvt->formats |= SUPPORTED_FORMATS;
                per_cvt->maxbps = max(per_cvt->maxbps, 24u);
        }

        spec->chmap.channels_max = max(spec->chmap.channels_max, 8u);

        /* AMD GPUs have neither EPSS nor CLKSTOP bits, hence preventing
         * the link-down as is.  Tell the core to allow it.
         */
        codec->link_down_at_suspend = 1;

        snd_hda_hdmi_acomp_init(codec, &atihdmi_audio_ops, atihdmi_port2pin);

        return 0;
}

static const struct hda_codec_ops atihdmi_codec_ops = {
        .probe = atihdmi_probe,
        .remove = snd_hda_hdmi_generic_remove,
        .init = atihdmi_init,
        .build_pcms = snd_hda_hdmi_generic_build_pcms,
        .build_controls = snd_hda_hdmi_generic_build_controls,
        .unsol_event = snd_hda_hdmi_generic_unsol_event,
        .suspend = snd_hda_hdmi_generic_suspend,
        .resume  = snd_hda_hdmi_generic_resume,
};

/*
 * driver entries
 */
static const struct hda_device_id snd_hda_id_atihdmi[] = {
        HDA_CODEC_ID(0x1002793c, "RS600 HDMI"),
        HDA_CODEC_ID(0x10027919, "RS600 HDMI"),
        HDA_CODEC_ID(0x1002791a, "RS690/780 HDMI"),
        HDA_CODEC_ID(0x1002aa01, "R6xx HDMI"),
        {} /* terminator */
};
MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_atihdmi);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("AMD/ATI HDMI HD-audio codec");
MODULE_IMPORT_NS("SND_HDA_CODEC_HDMI");

static struct hda_codec_driver atihdmi_driver = {
        .id = snd_hda_id_atihdmi,
        .ops = &atihdmi_codec_ops,
};

module_hda_codec_driver(atihdmi_driver);