/*
 * Copyright (c) 2018, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/kobject.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/tlv.h>
#include <sound/soc.h>
#include <linux/workqueue.h>
#include "ep92.h"

#define EP92_POLL_INTERVAL_OFF_MSEC 2000
#define EP92_POLL_INTERVAL_ON_MSEC  100


#define EP92_RATES (SNDRV_PCM_RATE_32000 |\
	SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
	SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |\
	SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000)

#define EP92_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)

#define EP92_UEVENT_CTRL_NUM_KEYS  8
#define EP92_UEVENT_AUDIO_NUM_KEYS 9

static const unsigned int ep92_samp_freq_table[8] = {
	32000, 44100, 48000, 88200, 96000, 176400, 192000, 768000
};

static const char hex_to_char[] = {'0', '1', '2', '3', '4', '5', '6', '7',
				   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

struct ep92_uevent_data {
	struct kobject kobj;
	struct kobj_type ktype;
};

static struct kset *ep92_uevent_kset;
static struct ep92_uevent_data *ep92_uevent_ctrl;
static struct ep92_uevent_data *ep92_uevent_audio;

static void ep92_release_uevent_data(struct kobject *kobj)
{
	struct ep92_uevent_data *data = container_of(kobj,
		struct ep92_uevent_data, kobj);

	kfree(data);
}

static int ep92_init_uevent_data(struct ep92_uevent_data *uevent_data,
	char *name)
{
	int ret = -EINVAL;

	if (!uevent_data || !name)
		return ret;

	/* Set kset for kobject before initializing the kobject */
	uevent_data->kobj.kset = ep92_uevent_kset;

	/* Initialize kobject and add it to kernel */
	ret = kobject_init_and_add(&uevent_data->kobj, &uevent_data->ktype,
		NULL, "%s", name);
	if (ret) {
		pr_err("%s: error initializing uevent kernel object: %d",
			__func__, ret);
		kobject_put(&uevent_data->kobj);
		return ret;
	}

	/* Send kobject add event to the system */
	kobject_uevent(&uevent_data->kobj, KOBJ_ADD);

	return ret;
}

/**
 * ep92_destroy_uevent_data - destroy kernel object.
 *
 * @uevent_data: uevent data.
 */
static void ep92_destroy_uevent_data(struct ep92_uevent_data *uevent_data)
{
	if (uevent_data)
		kobject_put(&uevent_data->kobj);
}

static bool ep92_volatile_register(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case EP92_BI_GENERAL_INFO_0:
	case EP92_BI_GENERAL_INFO_1:
	case EP92_BI_GENERAL_INFO_2:
	case EP92_BI_GENERAL_INFO_3:
	case EP92_BI_GENERAL_INFO_4:
	case EP92_BI_GENERAL_INFO_5:
	case EP92_BI_GENERAL_INFO_6:
	case EP92_GENERAL_CONTROL_0:
	case EP92_GENERAL_CONTROL_1:
	case EP92_GENERAL_CONTROL_2:
	case EP92_GENERAL_CONTROL_3:
	case EP92_GENERAL_CONTROL_4:
	case EP92_AUDIO_INFO_SYSTEM_STATUS_0:
	case EP92_AUDIO_INFO_SYSTEM_STATUS_1:
	case EP92_AUDIO_INFO_AUDIO_STATUS:
	case EP92_AUDIO_INFO_CHANNEL_STATUS_0:
	case EP92_AUDIO_INFO_CHANNEL_STATUS_1:
	case EP92_AUDIO_INFO_CHANNEL_STATUS_2:
	case EP92_AUDIO_INFO_CHANNEL_STATUS_3:
	case EP92_AUDIO_INFO_CHANNEL_STATUS_4:
	case EP92_AUDIO_INFO_ADO_INFO_FRAME_0:
	case EP92_AUDIO_INFO_ADO_INFO_FRAME_1:
	case EP92_AUDIO_INFO_ADO_INFO_FRAME_2:
	case EP92_AUDIO_INFO_ADO_INFO_FRAME_3:
	case EP92_AUDIO_INFO_ADO_INFO_FRAME_4:
	case EP92_AUDIO_INFO_ADO_INFO_FRAME_5:
		return true;
	default:
		return false;
	}
}

static bool ep92_writeable_registers(struct device *dev, unsigned int reg)
{
	if (reg >= EP92_ISP_MODE_ENTER_ISP && reg <= EP92_GENERAL_CONTROL_4)
		return true;

	return false;
}

static bool ep92_readable_registers(struct device *dev, unsigned int reg)
{
	if (reg >= EP92_BI_VENDOR_ID_0 && reg <= EP92_MAX_REGISTER_ADDR)
		return true;

	return false;
}

/* codec private data */
struct ep92_pdata {
	struct regmap        *regmap;
	struct snd_soc_codec *codec;
	struct timer_list    timer;
	struct work_struct   read_status_worker;
	int                  irq;

	struct {
		u8 ctl;
		u8 rx_sel;
		u8 cec_volume;
	} gc; /* General Control block */

	struct {
		u8 system_status_0;
		u8 system_status_1;
		u8 audio_status;
		u8 cs[5];
		u8 cc;
		u8 ca;
	} ai; /* Audio Info block */

	u8 old_mode;
};

/*
 * EP92 Controls
 */

/* enumerated controls */
static const char * const ep92_off_on_text[] = {"Off", "On"};
static const char * const ep92_aud_path_text[] = {"TV", "Speaker"};
static const char * const ep92_rx_sel_text[] = {"Port 0", "Port 1", "Port 2",
	"Res 3", "Res 4", "Res 5", "None", "Res 7"};
static const char * const ep92_cec_mute_text[] = {"Normal", "Muted"};

static const char * const ep92_state_text[] = {"Inactive", "Active"};
static const char * const ep92_avmute_text[] = {"Normal", "Muted"};
static const char * const ep92_layout_text[] = {"Layout 0", "Layout 1"};
static const char * const ep92_mode_text[] = {"LPCM", "Compr"};

SOC_ENUM_SINGLE_DECL(ep92_power_enum, EP92_GENERAL_CONTROL_0,
	EP92_GC_POWER_SHIFT, ep92_off_on_text);
SOC_ENUM_SINGLE_DECL(ep92_audio_path_enum, EP92_GENERAL_CONTROL_0,
	EP92_GC_AUDIO_PATH_SHIFT, ep92_aud_path_text);
SOC_ENUM_SINGLE_DECL(ep92_rx_sel_enum, EP92_GENERAL_CONTROL_1,
	EP92_GC_RX_SEL_SHIFT, ep92_rx_sel_text);
SOC_ENUM_SINGLE_DECL(ep92_arc_en_enum, EP92_GENERAL_CONTROL_0,
	EP92_GC_ARC_EN_SHIFT, ep92_off_on_text);
SOC_ENUM_SINGLE_DECL(ep92_cec_mute_enum, EP92_GENERAL_CONTROL_0,
	EP92_GC_CEC_MUTE_SHIFT, ep92_cec_mute_text);

SOC_ENUM_SINGLE_DECL(ep92_state_enum, EP92_AUDIO_INFO_SYSTEM_STATUS_0,
	EP92_AI_MCLK_ON_SHIFT, ep92_state_text);
SOC_ENUM_SINGLE_DECL(ep92_avmute_enum, EP92_AUDIO_INFO_SYSTEM_STATUS_0,
	EP92_AI_AVMUTE_SHIFT, ep92_avmute_text);
SOC_ENUM_SINGLE_DECL(ep92_layout_enum, EP92_AUDIO_INFO_SYSTEM_STATUS_0,
	EP92_AI_LAYOUT_SHIFT, ep92_layout_text);
SOC_ENUM_SINGLE_DECL(ep92_mode_enum, EP92_AUDIO_INFO_AUDIO_STATUS,
	EP92_AI_STD_ADO_SHIFT, ep92_mode_text);

/* get/set functions */
static int ep92_power_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] =
			(val >> e->shift_l) & EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_off_on_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_power_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	val &= ~EP92_GC_POWER_MASK;
	val |= (ucontrol->value.enumerated.item[0] & EP92_2CHOICE_MASK)
			<< e->shift_l;
	snd_soc_write(codec, e->reg, val);
	ep92->gc.ctl &= ~EP92_GC_POWER_MASK;
	ep92->gc.ctl |= val & EP92_GC_POWER_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_off_on_text[ucontrol->value.enumerated.item[0] &
				 EP92_2CHOICE_MASK]);
	return 0;
}

static int ep92_audio_path_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_aud_path_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_audio_path_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	val &= ~EP92_GC_AUDIO_PATH_MASK;
	val |= (ucontrol->value.enumerated.item[0] & EP92_2CHOICE_MASK)
			<< e->shift_l;
	snd_soc_write(codec, e->reg, val);
	ep92->gc.ctl &= ~EP92_GC_AUDIO_PATH_MASK;
	ep92->gc.ctl |= val & EP92_GC_AUDIO_PATH_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_aud_path_text[ucontrol->value.enumerated.item[0] &
				   EP92_2CHOICE_MASK]);
	return 0;
}

static int ep92_cec_mute_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_cec_mute_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_cec_mute_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	val &= ~EP92_GC_CEC_MUTE_MASK;
	val |= (ucontrol->value.enumerated.item[0] & EP92_2CHOICE_MASK)
			<< e->shift_l;
	snd_soc_write(codec, e->reg, val);
	ep92->gc.ctl &= ~EP92_GC_CEC_MUTE_MASK;
	ep92->gc.ctl |= val & EP92_GC_CEC_MUTE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_cec_mute_text[ucontrol->value.enumerated.item[0] &
				   EP92_2CHOICE_MASK]);
	return 0;
}

static int ep92_arc_en_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_off_on_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_arc_en_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	val &= ~EP92_GC_ARC_EN_MASK;
	val |= (ucontrol->value.enumerated.item[0] & EP92_2CHOICE_MASK)
			<< e->shift_l;
	snd_soc_write(codec, e->reg, val);
	ep92->gc.ctl &= ~EP92_GC_ARC_EN_MASK;
	ep92->gc.ctl |= val & EP92_GC_ARC_EN_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_off_on_text[ucontrol->value.enumerated.item[0] & 0x01]);
	return 0;
}

static int ep92_rx_sel_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_GC_RX_SEL_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_rx_sel_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_rx_sel_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	val &= ~EP92_GC_RX_SEL_MASK;
	val |= (ucontrol->value.enumerated.item[0] & EP92_GC_RX_SEL_MASK)
			<< e->shift_l;
	snd_soc_write(codec, e->reg, val);
	ep92->gc.rx_sel &= ~EP92_GC_RX_SEL_MASK;
	ep92->gc.rx_sel |= val & EP92_GC_RX_SEL_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_rx_sel_text[ucontrol->value.enumerated.item[0] &
				 EP92_GC_RX_SEL_MASK]);
	return 0;
}

static int ep92_cec_volume_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, mc->reg);
	ucontrol->value.integer.value[0] = (val >> mc->shift) &
			EP92_GC_CEC_VOLUME_MASK;

	pr_debug("%s: volume = %ld\n", __func__,
		ucontrol->value.integer.value[0]);
	return 0;
}

static int ep92_cec_volume_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = ucontrol->value.integer.value[0] & EP92_GC_CEC_VOLUME_MASK;
	if (val > EP92_GC_CEC_VOLUME_MAX)
		val = EP92_GC_CEC_VOLUME_MAX;
	snd_soc_write(codec, mc->reg, val);
	ep92->gc.cec_volume = val;

	pr_debug("%s: volume = %ld\n", __func__,
		ucontrol->value.integer.value[0]);
	return 0;
}

static int ep92_state_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_state_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_avmute_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_avmute_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_layout_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	ucontrol->value.enumerated.item[0] = (val >> e->shift_l) &
			EP92_2CHOICE_MASK;

	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_layout_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_mode_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);
	unsigned int val;

	val = snd_soc_read(codec, e->reg);
	if (val & EP92_AI_STD_ADO_MASK) {
		val = snd_soc_read(codec, EP92_AUDIO_INFO_CHANNEL_STATUS_0);
		if (val & EP92_AI_NPCM_MASK)
			ucontrol->value.enumerated.item[0] = 1; /* Compr */
		else
			ucontrol->value.enumerated.item[0] = 0; /* LPCM */
	} else if (val & EP92_AI_HBR_ADO_MASK) {
		ucontrol->value.enumerated.item[0] = 1; /* Compr */
	} else {
		ucontrol->value.enumerated.item[0] = ep92->old_mode;
	}
	pr_debug("%s: item = %d (%s)\n", __func__,
		ucontrol->value.enumerated.item[0],
		ep92_mode_text[ucontrol->value.enumerated.item[0]]);
	return 0;
}

static int ep92_rate_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, mc->reg);
	val &= EP92_AI_RATE_MASK;
	val = ep92_samp_freq_table[val];
	ucontrol->value.integer.value[0] = val;

	pr_debug("%s: rate = %ld\n", __func__,
		ucontrol->value.integer.value[0]);
	return 0;
}

static int ep92_ch_count_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, mc->reg) & EP92_AI_CH_COUNT_MASK;
	/* mapping is ch_count = reg_val + 1, with exception: 0 = unknown */
	if (val > 0)
		val += 1;

	ucontrol->value.integer.value[0] = val;

	pr_debug("%s: ch_count = %ld\n", __func__,
		ucontrol->value.integer.value[0]);
	return 0;
}

static int ep92_ch_alloc_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct soc_mixer_control *mc =
		(struct soc_mixer_control *)kcontrol->private_value;
	struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
	unsigned int val;

	val = snd_soc_read(codec, mc->reg);
	ucontrol->value.integer.value[0] = (val >> mc->shift) &
			EP92_AI_CH_ALLOC_MASK;

	pr_debug("%s: ch_alloc = 0x%02lx\n", __func__,
		ucontrol->value.integer.value[0]);
	return 0;
}

static const struct snd_kcontrol_new ep92_snd_controls[] = {

	SOC_ENUM_EXT("HDMI_IN POWER", ep92_power_enum,
		ep92_power_get, ep92_power_put),
	SOC_ENUM_EXT("HDMI_IN AUDIO_PATH", ep92_audio_path_enum,
		ep92_audio_path_get, ep92_audio_path_put),
	SOC_ENUM_EXT("HDMI_IN RX_SEL", ep92_rx_sel_enum,
		ep92_rx_sel_get, ep92_rx_sel_put),
	SOC_ENUM_EXT("HDMI_IN ARC_EN", ep92_arc_en_enum,
		ep92_arc_en_get, ep92_arc_en_put),
	SOC_ENUM_EXT("HDMI_IN CEC_MUTE", ep92_cec_mute_enum,
		ep92_cec_mute_get, ep92_cec_mute_put),
	SOC_SINGLE_EXT("HDMI_IN CEC_VOLUME", EP92_GENERAL_CONTROL_3,
		EP92_GC_CEC_VOLUME_MIN, EP92_GC_CEC_VOLUME_MAX,
		0, ep92_cec_volume_get, ep92_cec_volume_put),

	SOC_ENUM_EXT("HDMI_IN STATE", ep92_state_enum, ep92_state_get, NULL),
	SOC_ENUM_EXT("HDMI_IN AVMUTE", ep92_avmute_enum, ep92_avmute_get, NULL),
	SOC_ENUM_EXT("HDMI_IN LAYOUT", ep92_layout_enum, ep92_layout_get, NULL),
	SOC_ENUM_EXT("HDMI_IN MODE", ep92_mode_enum, ep92_mode_get, NULL),
	SOC_SINGLE_EXT("HDMI_IN RATE", EP92_AUDIO_INFO_AUDIO_STATUS,
		EP92_AI_RATE_MIN, EP92_AI_RATE_MAX, 0, ep92_rate_get, NULL),
	SOC_SINGLE_EXT("HDMI_IN CH_COUNT", EP92_AUDIO_INFO_ADO_INFO_FRAME_1,
		EP92_AI_CH_COUNT_MIN, EP92_AI_CH_COUNT_MAX,
		0, ep92_ch_count_get, NULL),
	SOC_SINGLE_EXT("HDMI_IN CH_ALLOC", EP92_AUDIO_INFO_ADO_INFO_FRAME_4,
		EP92_AI_CH_ALLOC_MIN, EP92_AI_CH_ALLOC_MAX, 0,
		ep92_ch_alloc_get, NULL),
};

static int ep92_startup(struct snd_pcm_substream *substream,
	struct snd_soc_dai *dai)
{
	return 0;
}

static void ep92_shutdown(struct snd_pcm_substream *substream,
	struct snd_soc_dai *dai)
{
}

static int ep92_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
{
	return 0;
}

static struct snd_soc_dai_ops ep92_dai_ops = {
	.startup = ep92_startup,
	.shutdown = ep92_shutdown,
	.hw_params = ep92_hw_params,
};

static struct snd_soc_dai_driver ep92_dai[] = {
	{
		.name = "ep92-hdmi",
		.id = 1,
		.capture = {
			.stream_name = "HDMI Capture",
			.rate_max = 192000,
			.rate_min = 32000,
			.channels_min = 1,
			.channels_max = 8,
			.rates = EP92_RATES,
			.formats = EP92_FORMATS,
		},
		.ops = &ep92_dai_ops, /* callbacks */
	},
	{
		.name = "ep92-arc",
		.id = 2,
		.capture = {
			.stream_name = "ARC Capture",
			.rate_max = 192000,
			.rate_min = 32000,
			.channels_min = 1,
			.channels_max = 2,
			.rates = EP92_RATES,
			.formats = EP92_FORMATS,
		},
		.ops = &ep92_dai_ops, /* callbacks */
	},
};

static const char * const ep92_event_power_text[] = {
	"POWER=Off",
	"POWER=On",
};

static const char * const ep92_event_arc_en_text[] = {
	"ARC_EN=Off",
	"ARC_EN=On",
};

static const char * const ep92_event_audio_path_text[] = {
	"AUDIO_PATH=TV",
	"AUDIO_PATH=Speaker",
};

static const char *const ep92_event_rx_sel_text[] = {
	"RX_SEL=Port0",
	"RX_SEL=Port1",
	"RX_SEL=Port2",
	"RX_SEL=Res3",
	"RX_SEL=Res4",
	"RX_SEL=Res5",
	"RX_SEL=None",
	"RX_SEL=Res7",
};

static const char *const ep92_event_cec_mute_text[] = {
	"CEC_MUTE=Normal",
	"CEC_MUTE=Muted",
};

static int ep92_send_uevent_ctrl(struct ep92_pdata *ep92)
{
	char *env[EP92_UEVENT_CTRL_NUM_KEYS];
	u8 idx = 0;
	u8 cec_volume;
	char cec_volume_text[] = "CEC_VOLUME=0x00";
	char *ptr;

	env[idx++] = "HDMI_CONTROL=TRUE";

	if ((ep92->gc.ctl >> EP92_GC_POWER_SHIFT) &
		EP92_2CHOICE_MASK)
		env[idx++] = (char *)ep92_event_power_text[1];
	else
		env[idx++] = (char *)ep92_event_power_text[0];

	if (ep92->gc.ctl & EP92_2CHOICE_MASK)
		env[idx++] = (char *)ep92_event_arc_en_text[1];
	else
		env[idx++] = (char *)ep92_event_arc_en_text[0];

	if ((ep92->gc.ctl >> EP92_GC_AUDIO_PATH_SHIFT) &
		EP92_2CHOICE_MASK)
		env[idx++] = (char *)ep92_event_audio_path_text[1];
	else
		env[idx++] = (char *)ep92_event_audio_path_text[0];

	switch (ep92->gc.rx_sel & EP92_GC_RX_SEL_MASK) {
	case 0:
		env[idx++] = (char *)ep92_event_rx_sel_text[0];
		break;
	case 1:
		env[idx++] = (char *)ep92_event_rx_sel_text[1];
		break;
	case 2:
		env[idx++] = (char *)ep92_event_rx_sel_text[2];
		break;
	case 3:
		env[idx++] = (char *)ep92_event_rx_sel_text[3];
		break;
	case 4:
		env[idx++] = (char *)ep92_event_rx_sel_text[4];
		break;
	case 5:
		env[idx++] = (char *)ep92_event_rx_sel_text[5];
		break;
	case 6:
		env[idx++] = (char *)ep92_event_rx_sel_text[6];
		break;
	case 7:
		env[idx++] = (char *)ep92_event_rx_sel_text[7];
		break;
	default:
		env[idx++] = (char *)ep92_event_rx_sel_text[0];
	}

	if ((ep92->gc.ctl >> EP92_GC_CEC_MUTE_SHIFT) &
		EP92_2CHOICE_MASK)
		env[idx++] = (char *)ep92_event_cec_mute_text[1];
	else
		env[idx++] = (char *)ep92_event_cec_mute_text[0];

	ptr = &cec_volume_text[strlen(cec_volume_text)-2];
	cec_volume = (ep92->ai.ca) & EP92_GC_CEC_VOLUME_MASK;
	*ptr++ = hex_to_char[(cec_volume >> 4) & 0x0f];
	*ptr++ = hex_to_char[cec_volume & 0x0f];
	env[idx++] = (char *)cec_volume_text;

	env[idx++] = NULL;

	if (idx != EP92_UEVENT_CTRL_NUM_KEYS) {
		pr_err("ep92 wrong number of audio uevent keys (%d).\n",
			idx);
		return -EINVAL;
	}

	return kobject_uevent_env(&ep92_uevent_ctrl->kobj, KOBJ_CHANGE, env);
}

static const char * const ep92_event_state_text[] = {
	"STATE=Inactive",
	"STATE=Active",
};

static const char *const ep92_event_rate_text[] = {
	"RATE=32000",
	"RATE=44100",
	"RATE=48000",
	"RATE=88200",
	"RATE=96000",
	"RATE=176400",
	"RATE=192000",
	"RATE=768000",
};

static const char *const ep92_event_format_text[] = {
	"FORMAT=LPCM",
	"FORMAT=Compr",
};

static const char *const ep92_event_layout_text[] = {
	"LAYOUT=2ch",
	"LAYOUT=8ch",
};

static const char *const ep92_event_avmute_text[] = {
	"AVMUTE=Normal",
	"AVMUTE=Muted",
};

static const char *const ep92_event_ch_count_text[] = {
	"CH_COUNT=One",
	"CH_COUNT=Two",
	"CH_COUNT=Three",
	"CH_COUNT=Four",
	"CH_COUNT=Five",
	"CH_COUNT=Six",
	"CH_COUNT=Seven",
	"CH_COUNT=Eight",
};

static int ep92_send_uevent_audio(struct ep92_pdata *ep92)
{
	char *env[EP92_UEVENT_AUDIO_NUM_KEYS];
	u8 idx = 0;
	u8 ch_alloc;
	char ch_alloc_text[] = "CH_ALLOC=0x00";
	char *ptr;

	env[idx++] = "HDMI_FMT_UPDATE=TRUE";

	if (((ep92->ai.system_status_0 >> EP92_AI_MCLK_ON_SHIFT) &
		EP92_2CHOICE_MASK) == EP92_STATUS_AUDIO_ACTIVE)
		env[idx++] = (char *)ep92_event_state_text[1];
	else
		env[idx++] = (char *)ep92_event_state_text[0];

	switch (ep92->ai.audio_status & EP92_AI_RATE_MASK) {
	case 0:
		env[idx++] = (char *)ep92_event_rate_text[0];
		break;
	case 1:
		env[idx++] = (char *)ep92_event_rate_text[1];
		break;
	case 2:
		env[idx++] = (char *)ep92_event_rate_text[2];
		break;
	case 3:
		env[idx++] = (char *)ep92_event_rate_text[3];
		break;
	case 4:
		env[idx++] = (char *)ep92_event_rate_text[4];
		break;
	case 5:
		env[idx++] = (char *)ep92_event_rate_text[5];
		break;
	case 6:
		env[idx++] = (char *)ep92_event_rate_text[6];
		break;
	case 7:
		env[idx++] = (char *)ep92_event_rate_text[7];
		break;
	default:
		env[idx++] = (char *)ep92_event_rate_text[2];
	}

	if (ep92->old_mode)
		env[idx++] = (char *)ep92_event_format_text[1];
	else
		env[idx++] = (char *)ep92_event_format_text[0];

	if (ep92->ai.system_status_0 & EP92_2CHOICE_MASK)
		env[idx++] = (char *)ep92_event_layout_text[1];
	else
		env[idx++] = (char *)ep92_event_layout_text[0];

	if ((ep92->ai.system_status_0 >> EP92_AI_AVMUTE_SHIFT) &
		EP92_2CHOICE_MASK)
		env[idx++] = (char *)ep92_event_avmute_text[1];
	else
		env[idx++] = (char *)ep92_event_avmute_text[0];

	/* cc==0 signals n/a and is treated as stereo */
	switch (ep92->ai.cc & EP92_AI_CH_COUNT_MASK) {
	case 0:
		env[idx++] = (char *)ep92_event_ch_count_text[1];
		break;
	case 1:
		env[idx++] = (char *)ep92_event_ch_count_text[1];
		break;
	case 2:
		env[idx++] = (char *)ep92_event_ch_count_text[2];
		break;
	case 3:
		env[idx++] = (char *)ep92_event_ch_count_text[3];
		break;
	case 4:
		env[idx++] = (char *)ep92_event_ch_count_text[4];
		break;
	case 5:
		env[idx++] = (char *)ep92_event_ch_count_text[5];
		break;
	case 6:
		env[idx++] = (char *)ep92_event_ch_count_text[6];
		break;
	case 7:
		env[idx++] = (char *)ep92_event_ch_count_text[7];
		break;
	default:
		env[idx++] = (char *)ep92_event_ch_count_text[1];
	}

	ptr = &ch_alloc_text[strlen(ch_alloc_text)-2];
	ch_alloc = (ep92->ai.ca) & EP92_AI_CH_ALLOC_MASK;
	*ptr++ = hex_to_char[(ch_alloc >> 4) & 0x0f];
	*ptr++ = hex_to_char[ch_alloc & 0x0f];
	env[idx++] = (char *)ch_alloc_text;

	env[idx++] = NULL;

	if (idx != EP92_UEVENT_AUDIO_NUM_KEYS) {
		pr_err("ep92 wrong number of audio uevent keys (%d).\n",
			idx);
		return -EINVAL;
	}

	return kobject_uevent_env(&ep92_uevent_audio->kobj, KOBJ_CHANGE, env);
}

static void ep92_read_general_control(struct snd_soc_codec *codec,
	struct ep92_pdata *ep92)
{
	u8 old, change;
	bool send_uevent = false;

	old = ep92->gc.ctl;
	ep92->gc.ctl = snd_soc_read(codec, EP92_GENERAL_CONTROL_0);
	change = ep92->gc.ctl ^ old;
	if (change & EP92_GC_POWER_MASK) {
		pr_debug("ep92 power changed to %d (%s)\n",
			(ep92->gc.ctl >> EP92_GC_POWER_SHIFT) &
			EP92_2CHOICE_MASK,
			ep92_off_on_text[(ep92->gc.ctl
			>> EP92_GC_POWER_SHIFT) & EP92_2CHOICE_MASK]);
		send_uevent = true;
	}
	if (change & EP92_GC_AUDIO_PATH_MASK) {
		pr_debug("ep92 audio_path changed to %d (%s)\n",
			(ep92->gc.ctl >> EP92_GC_AUDIO_PATH_SHIFT) &
			EP92_2CHOICE_MASK,
			ep92_aud_path_text[(ep92->gc.ctl
			>> EP92_GC_AUDIO_PATH_SHIFT) & EP92_2CHOICE_MASK]);
		send_uevent = true;
	}
	if (change & EP92_GC_CEC_MUTE_MASK) {
		pr_debug("ep92 cec_mute changed to %d (%s)\n",
			(ep92->gc.ctl >> EP92_GC_CEC_MUTE_SHIFT) &
			EP92_2CHOICE_MASK,
			ep92_cec_mute_text[(ep92->gc.ctl
			>> EP92_GC_CEC_MUTE_SHIFT) & EP92_2CHOICE_MASK]);
		send_uevent = true;
	}
	if (change & EP92_GC_ARC_EN_MASK) {
		pr_debug("ep92 arc_en changed to %d (%s)\n",
			ep92->gc.ctl & EP92_2CHOICE_MASK,
			ep92_off_on_text[ep92->gc.ctl & EP92_2CHOICE_MASK]);
		send_uevent = true;
	}

	old = ep92->gc.rx_sel;
	ep92->gc.rx_sel = snd_soc_read(codec, EP92_GENERAL_CONTROL_1);
	change = ep92->gc.rx_sel ^ old;
	if (change & EP92_GC_RX_SEL_MASK) {
		pr_debug("ep92 rx_sel changed to %d (%s)\n",
			ep92->gc.rx_sel & EP92_GC_RX_SEL_MASK,
			ep92_rx_sel_text[ep92->gc.rx_sel &
			EP92_GC_RX_SEL_MASK]);
		send_uevent = true;
	}

	old = ep92->gc.cec_volume;
	ep92->gc.cec_volume = snd_soc_read(codec, EP92_GENERAL_CONTROL_3);
	change = ep92->gc.cec_volume ^ old;
	if (change & EP92_GC_CEC_VOLUME_MASK) {
		pr_debug("ep92 cec_volume changed to %d\n",
			ep92->gc.cec_volume & EP92_GC_CEC_VOLUME_MASK);
		send_uevent = true;
	}

	if (send_uevent)
		ep92_send_uevent_ctrl(ep92);
}

static void ep92_read_audio_info(struct snd_soc_codec *codec,
	struct ep92_pdata *ep92)
{
	u8 old, change;
	u8 new_mode;
	bool send_uevent = false;

	old = ep92->ai.system_status_0;
	ep92->ai.system_status_0 = snd_soc_read(codec,
		EP92_AUDIO_INFO_SYSTEM_STATUS_0);
	change = ep92->ai.system_status_0 ^ old;
	if (change & EP92_AI_MCLK_ON_MASK) {
		pr_debug("ep92 status changed to %d (%s)\n",
			(ep92->ai.system_status_0 >> EP92_AI_MCLK_ON_SHIFT) &
			EP92_2CHOICE_MASK,
			ep92_state_text[(ep92->ai.system_status_0
			>> EP92_AI_MCLK_ON_SHIFT) & EP92_2CHOICE_MASK]);
		send_uevent = true;
	}
	if (change & EP92_AI_AVMUTE_MASK) {
		pr_debug("ep92 avmute changed to %d (%s)\n",
			(ep92->ai.system_status_0 >> EP92_AI_AVMUTE_SHIFT) &
			EP92_2CHOICE_MASK,
			ep92_avmute_text[(ep92->ai.system_status_0
			>> EP92_AI_AVMUTE_SHIFT) & EP92_2CHOICE_MASK]);
		send_uevent = true;
	}
	if (change & EP92_AI_LAYOUT_MASK) {
		pr_debug("ep92 layout changed to %d (%s)\n",
			(ep92->ai.system_status_0) & EP92_2CHOICE_MASK,
			ep92_layout_text[(ep92->ai.system_status_0) &
			EP92_2CHOICE_MASK]);
		send_uevent = true;
	}

	old = ep92->ai.audio_status;
	ep92->ai.audio_status = snd_soc_read(codec,
		EP92_AUDIO_INFO_AUDIO_STATUS);
	change = ep92->ai.audio_status ^ old;
	if (change & EP92_AI_RATE_MASK) {
		pr_debug("ep92 rate changed to %d\n",
			ep92_samp_freq_table[(ep92->ai.audio_status) &
			EP92_AI_RATE_MASK]);
		send_uevent = true;
	}

	new_mode = ep92->old_mode;
	if (ep92->ai.audio_status & EP92_AI_STD_ADO_MASK) {
		ep92->ai.cs[0] = snd_soc_read(codec,
			EP92_AUDIO_INFO_CHANNEL_STATUS_0);
		if (ep92->ai.cs[0] & EP92_AI_NPCM_MASK)
			new_mode = 1; /* Compr */
		else
			new_mode = 0; /* LPCM */
	} else if (ep92->ai.audio_status & EP92_AI_HBR_ADO_MASK)
		new_mode = 1; /* Compr */

	if (ep92->old_mode != new_mode) {
		pr_debug("ep92 mode changed to %d (%s)\n", new_mode,
			ep92_mode_text[new_mode]);
		send_uevent = true;
	}
	ep92->old_mode = new_mode;

	old = ep92->ai.cc;
	ep92->ai.cc = snd_soc_read(codec, EP92_AUDIO_INFO_ADO_INFO_FRAME_1);
	change = ep92->ai.cc ^ old;
	if (change & EP92_AI_CH_COUNT_MASK) {
		pr_debug("ep92 ch_count changed to %d (%d)\n",
			ep92->ai.cc & EP92_AI_CH_COUNT_MASK,
			(ep92->ai.cc & EP92_AI_CH_COUNT_MASK) == 0 ? 0 :
			(ep92->ai.cc & EP92_AI_CH_COUNT_MASK) + 1);
		send_uevent = true;
	}

	old = ep92->ai.ca;
	ep92->ai.ca = snd_soc_read(codec, EP92_AUDIO_INFO_ADO_INFO_FRAME_4);
	change = ep92->ai.ca ^ old;
	if (change & EP92_AI_CH_ALLOC_MASK) {
		pr_debug("ep92 ch_alloc changed to 0x%02x\n",
			(ep92->ai.ca) & EP92_AI_CH_ALLOC_MASK);
		send_uevent = true;
	}

	if (send_uevent)
		ep92_send_uevent_audio(ep92);
}

static void ep92_init(struct snd_soc_codec *codec, struct ep92_pdata *ep92)
{
	/* update the format information in mixer controls */
	ep92_read_general_control(codec, ep92);
	ep92_read_audio_info(codec, ep92);
}

static int ep92_probe(struct snd_soc_codec *codec)
{
	struct ep92_pdata *ep92 = snd_soc_codec_get_drvdata(codec);

	ep92->codec = codec;
	ep92_init(codec, ep92);

	return 0;
}

static int ep92_remove(struct snd_soc_codec *codec)
{
	return 0;
}

static struct regmap *ep92_get_regmap(struct device *dev)
{
	struct ep92_pdata *ep92_ctrl = dev_get_drvdata(dev);

	if (!ep92_ctrl)
		return NULL;

	return ep92_ctrl->regmap;
}

static struct snd_soc_codec_driver soc_codec_drv_ep92 = {
	.probe  = ep92_probe,
	.remove = ep92_remove,
	.get_regmap = ep92_get_regmap,
	.component_driver = {
		.controls = ep92_snd_controls,
		.num_controls = ARRAY_SIZE(ep92_snd_controls),
	},
};

static struct regmap_config ep92_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.cache_type = REGCACHE_RBTREE,
	.reg_defaults = ep92_reg_defaults,
	.num_reg_defaults = ARRAY_SIZE(ep92_reg_defaults),
	.max_register = EP92_MAX_REGISTER_ADDR,
	.volatile_reg = ep92_volatile_register,
	.writeable_reg = ep92_writeable_registers,
	.readable_reg = ep92_readable_registers,
};

void ep92_read_status(struct work_struct *work)
{
	struct ep92_pdata *ep92 = container_of(work, struct ep92_pdata,
		read_status_worker);
	struct snd_soc_codec *codec = ep92->codec;
	u8 val;

	/* No polling before codec is initialized */
	if (codec == NULL)
		return;

	/* check ADO_CHF that is set when audio format has changed */
	val = snd_soc_read(codec, EP92_BI_GENERAL_INFO_1);
	if (val == 0xff) {
		/* workaround for Nak'ed first read */
		val = snd_soc_read(codec, EP92_BI_GENERAL_INFO_1);
		if (val == 0xff)
			return;	/* assume device not present */
	}

	if (val & EP92_GI_ADO_CHF_MASK)
		pr_debug("ep92 audio mode change trigger.\n");

	if (val & EP92_GI_CEC_ECF_MASK)
		pr_debug("ep92 CEC change trigger.\n");

	/* check for general control changes */
	ep92_read_general_control(codec, ep92);

	/* update the format information in mixer controls */
	ep92_read_audio_info(codec, ep92);
}

static irqreturn_t ep92_irq(int irq, void *data)
{
	struct ep92_pdata *ep92 = data;
	struct snd_soc_codec *codec = ep92->codec;

	/* Treat interrupt before codec is initialized as spurious */
	if (codec == NULL)
		return IRQ_NONE;

	dev_dbg(codec->dev, "ep92_interrupt\n");

	schedule_work(&ep92->read_status_worker);

	return IRQ_HANDLED;
};

void ep92_poll_status(unsigned long data)
{
	struct ep92_pdata *ep92 = (struct ep92_pdata *)data;
	u32 poll_msec;

	if ((ep92->gc.ctl & EP92_GC_POWER_MASK) == 0)
		poll_msec = EP92_POLL_INTERVAL_OFF_MSEC;
	else
		poll_msec = EP92_POLL_INTERVAL_ON_MSEC;

	mod_timer(&ep92->timer, jiffies + msecs_to_jiffies(poll_msec));

	schedule_work(&ep92->read_status_worker);
}

static const struct of_device_id ep92_of_match[] = {
	{ .compatible = "explore,ep92a6", },
	{ }
};
MODULE_DEVICE_TABLE(of, ep92_of_match);

static int ep92_i2c_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	struct ep92_pdata *ep92;
	int ret;

	ep92 = devm_kzalloc(&client->dev, sizeof(struct ep92_pdata),
		GFP_KERNEL);
	if (ep92 == NULL)
		return -ENOMEM;

	ep92->regmap = devm_regmap_init_i2c(client, &ep92_regmap_config);
	if (IS_ERR(ep92->regmap)) {
		ret = PTR_ERR(ep92->regmap);
		dev_err(&client->dev,
			"%s %d: Failed to allocate regmap for I2C device: %d\n",
			__func__,  __LINE__, ret);
		return ret;
	}

	i2c_set_clientdata(client, ep92);

	/* register interrupt handler */
	INIT_WORK(&ep92->read_status_worker, ep92_read_status);
	ep92->irq = client->irq;
	if (ep92->irq) {
		ret = devm_request_threaded_irq(&client->dev, ep92->irq,
			NULL, ep92_irq, IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
			"ep92_irq", ep92);
		if (ret) {
			dev_err(&client->dev,
				"%s: Failed to request IRQ %d: %d\n",
				__func__, ep92->irq, ret);
			ep92->irq = 0;
		}
	}
	/* poll status if IRQ is not configured */
	if (ep92->irq == 0) {
		setup_timer(&ep92->timer, ep92_poll_status,
			(unsigned long)ep92);
		mod_timer(&ep92->timer, jiffies +
			msecs_to_jiffies(EP92_POLL_INTERVAL_OFF_MSEC));
	}

	/* register codec */
	ret = snd_soc_register_codec(&client->dev, &soc_codec_drv_ep92,
		ep92_dai, ARRAY_SIZE(ep92_dai));
	if (ret) {
		dev_err(&client->dev,
			"%s %d: Failed to register CODEC: %d\n",
			__func__,  __LINE__, ret);
		goto err_reg;
	}

	/* Create a kset under /sys/kernel/ */
	ep92_uevent_kset = kset_create_and_add("ep92-hdmi", NULL, kernel_kobj);
	if (!ep92_uevent_kset) {
		pr_err("%s: error creating uevent kernel set", __func__);
		ret = -EINVAL;
		goto err_kset;
	}

	/* uevent to signal control changes */
	ep92_uevent_ctrl = devm_kzalloc(&client->dev,
		sizeof(*ep92_uevent_ctrl), GFP_KERNEL);
	if (!ep92_uevent_ctrl) {
		ret = -ENOMEM;
		goto err_ue_ctrl;
	}

	ep92_uevent_ctrl->ktype.release = ep92_release_uevent_data;
	ret = ep92_init_uevent_data(ep92_uevent_ctrl, "ctrl-uevent");
	if (ret) {
		dev_err(&client->dev,
			"%s: Failed to init ctrl-uevent: %d\n",
			__func__, ret);
		goto err_ue_init_ctrl;
	}

	/* uevent to signal audio format changes */
	ep92_uevent_audio = devm_kzalloc(&client->dev,
		sizeof(*ep92_uevent_audio), GFP_KERNEL);
	if (!ep92_uevent_audio) {
		ret = -ENOMEM;
		goto err_ue_audio;
	}

	ep92_uevent_audio->ktype.release = ep92_release_uevent_data;
	ret = ep92_init_uevent_data(ep92_uevent_audio, "audio-uevent");
	if (ret) {
		dev_err(&client->dev,
			"%s: Failed to init ctrl-uevent: %d\n",
			__func__, ret);
		goto err_ue_init_audio;
	}
	return 0;

err_ue_init_audio:
	devm_kfree(&client->dev, ep92_uevent_audio);
err_ue_audio:
	ep92_destroy_uevent_data(ep92_uevent_ctrl);
err_ue_init_ctrl:
	devm_kfree(&client->dev, ep92_uevent_ctrl);
err_ue_ctrl:
	kset_unregister(ep92_uevent_kset);
err_kset:
	snd_soc_unregister_codec(&client->dev);
err_reg:
	if (ep92->irq == 0)
		del_timer(&ep92->timer);

	return ret;
}

static int ep92_i2c_remove(struct i2c_client *client)
{
	struct ep92_pdata *ep92;

	ep92 = i2c_get_clientdata(client);
	if ((ep92 != NULL) && (ep92->irq == 0))
		del_timer(&ep92->timer);

	snd_soc_unregister_codec(&client->dev);

	ep92_destroy_uevent_data(ep92_uevent_ctrl);
	devm_kfree(&client->dev, ep92_uevent_ctrl);

	ep92_destroy_uevent_data(ep92_uevent_audio);
	devm_kfree(&client->dev, ep92_uevent_audio);

	if (ep92_uevent_kset) {
		kset_unregister(ep92_uevent_kset);
		ep92_uevent_kset = NULL;
	}

	return 0;
}

static const struct i2c_device_id ep92_i2c_id[] = {
	{ "ep92-dev", 0},
	{ }
};
MODULE_DEVICE_TABLE(i2c, ep92_i2c_id);

static struct i2c_driver ep92_i2c_driver = {
	.probe =    ep92_i2c_probe,
	.remove =   ep92_i2c_remove,
	.id_table = ep92_i2c_id,
	.driver = {
		.name = "ep92",
		.owner = THIS_MODULE,
		.of_match_table = ep92_of_match
	},
};

static int __init ep92_codec_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&ep92_i2c_driver);
	if (ret)
		pr_err("Failed to register EP92 I2C driver: %d\n", ret);

	return ret;
}
module_init(ep92_codec_init);

static void __exit ep92_codec_exit(void)
{
	i2c_del_driver(&ep92_i2c_driver);
}
module_exit(ep92_codec_exit);

MODULE_DESCRIPTION("EP92 HDMI repeater/switch driver");
MODULE_LICENSE("GPL v2");