kernel_samsung_a34x-permissive/drivers/muic/common/vt_muic/vt_muic.c

// SPDX-License-Identifier: GPL-2.0
/*
 *
 * Copyright (C) 2022 Samsung Electronics
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#define pr_fmt(fmt) "[MUIC] vt_muic: " fmt

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/notifier.h>
#include <linux/workqueue.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
#include <linux/power_supply.h>
#include <linux/delay.h>
#include <linux/muic/common/muic.h>
#include <linux/muic/common/muic_notifier.h>
#include <linux/muic/common/muic_sysfs.h>
#include <linux/muic/common/vt_muic/vt_muic.h>
#if IS_ENABLED(CONFIG_PDIC_NOTIFIER) && \
	IS_ENABLED(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
#include <linux/usb/typec/common/pdic_notifier.h>
#include <linux/usb/typec/manager/usb_typec_manager_notifier.h>
#endif /* CONFIG_PDIC_NOTIFIER && CONFIG_USB_TYPEC_MANAGER_NOTIFIER */
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
#include <dt-bindings/battery/sec-battery.h>
#include <../../drivers/battery/common/sec_charging_common.h>
#endif /* CONFIG_BATTERY_SAMSUNG */

extern struct muic_platform_data muic_pdata;

struct vt_muic_pdata {
	int usb_id_gpio;
	int use_psy_nb;
	int use_manager_nb;
};

struct vt_muic_struct {
	int irq;
	int attached_dev;
	int batt_cable;
	int rprd;
	int afc_dev;
	int id_ta;
	int is_afc_started;
	int buck_prev_status;
	unsigned long			irq_debounce_interval;
	struct device			*dev;
	struct vt_muic_pdata		*pdata;
	struct muic_platform_data	*muic_pdata;
	struct vt_muic_ic_data		*ic_data;
	struct power_supply		*ppsy;
	struct work_struct		vt_muic_work;
	struct notifier_block		psy_nb;
	struct notifier_block		manager_nb;
};

static struct vt_muic_struct vt_muic;

static void vt_muic_work_func(struct work_struct *work)
{
	int attached_dev = vt_muic.attached_dev;
	int new_dev = ATTACHED_DEV_NONE_MUIC;
	bool attach_update = false;

	pr_info("%s attached_dev(%d) batt_cable(%d) rprd(%d) afc_dev(%d)\n",
			__func__, attached_dev, vt_muic.batt_cable,
			vt_muic.rprd, vt_muic.afc_dev);
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
	/* 1. update battery cable */
	switch (vt_muic.batt_cable) {
	case SEC_BATTERY_CABLE_USB:
		new_dev = ATTACHED_DEV_USB_MUIC;
		break;
	case SEC_BATTERY_CABLE_USB_CDP:
		new_dev = ATTACHED_DEV_CDP_MUIC;
		break;
	case SEC_BATTERY_CABLE_TA:
		new_dev = ATTACHED_DEV_TA_MUIC;
		break;
	case SEC_BATTERY_CABLE_PREPARE_TA:
		new_dev = ATTACHED_DEV_TA_MUIC;
#if IS_ENABLED(CONFIG_AFC_CHARGER)
		if (!vt_muic.is_afc_started) {
#if IS_ENABLED(CONFIG_CHARGER_SYV660)
			if (vt_muic.ic_data && vt_muic.ic_data->m_ops.afc_dpdm_ctrl)
				vt_muic.ic_data->m_ops.afc_dpdm_ctrl(1);
#endif
			if (vt_muic.id_ta)
				muic_afc_set_voltage(0x9);

			vt_muic.is_afc_started = 1;
		}
#endif
		break;
	case SEC_BATTERY_CABLE_TIMEOUT:
	case SEC_BATTERY_CABLE_UNKNOWN:
		new_dev = ATTACHED_DEV_TIMEOUT_OPEN_MUIC;
		break;
	case SEC_BATTERY_CABLE_NONE:
#if IS_ENABLED(CONFIG_AFC_CHARGER) && IS_ENABLED(CONFIG_CHARGER_SYV660)
		if (vt_muic.ic_data && vt_muic.ic_data->m_ops.afc_dpdm_ctrl)
			vt_muic.ic_data->m_ops.afc_dpdm_ctrl(0);
		/* fallthrough */
#endif
	default:
		new_dev = ATTACHED_DEV_NONE_MUIC;
		vt_muic.afc_dev = ATTACHED_DEV_NONE_MUIC;
		vt_muic.is_afc_started = 0;
		muic_afc_request_cause_clear();
		break;
	}
#endif
	/* 2. update type-c rd cable */
	if (vt_muic.rprd)
		new_dev = ATTACHED_DEV_OTG_MUIC;

	/* 3. update afc cable */
	if (new_dev == ATTACHED_DEV_TA_MUIC &&
			vt_muic.afc_dev != ATTACHED_DEV_NONE_MUIC) {
		new_dev = vt_muic.afc_dev;
		attach_update = true;
	}

	if (attached_dev == new_dev) {
		pr_info("%s: Duplicated(%d), ignore\n", __func__, new_dev);
		return;
	}

	if (new_dev != ATTACHED_DEV_NONE_MUIC) {
		if (!attach_update && attached_dev != ATTACHED_DEV_NONE_MUIC)	
			muic_notifier_detach_attached_dev(attached_dev);

		muic_notifier_attach_attached_dev(new_dev);
	} else {
		if (attached_dev != ATTACHED_DEV_NONE_MUIC)
			muic_notifier_detach_attached_dev(attached_dev);
	}

	vt_muic.attached_dev = new_dev;
}

#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
static int vt_muic_psy_nb_func(struct notifier_block *nb, unsigned long val,
		void *v)
{
	struct power_supply *ppsy = (struct power_supply *)v;
	union power_supply_propval pval;
#if IS_ENABLED(CONFIG_AFC_CHARGER) && IS_ENABLED(CONFIG_CHARGER_SYV660)
	int buck_status;
#endif
	int ret;

	if (val != PSY_EVENT_PROP_CHANGED) {
		pr_debug("%s: not changed(%ld)\n", __func__, val);
		return NOTIFY_DONE;
	}

	if (!ppsy || !ppsy->desc || !ppsy->desc->name) {
		pr_err("%s: ppsy is NULL\n", __func__);
		return NOTIFY_DONE;
	}

	if (strcmp("bc12", ppsy->desc->name)) {
		pr_debug("%s: name is not bc12 (%s)\n", __func__,
				ppsy->desc->name);
		return NOTIFY_DONE;
	}

#if IS_ENABLED(CONFIG_AFC_CHARGER) && IS_ENABLED(CONFIG_CHARGER_SYV660)
	ret = power_supply_get_property(ppsy,
				POWER_SUPPLY_PROP_STATUS, &pval);
	if (ret != 0) {
		pr_err("failed to get psy prop, ret=%d\n", ret);
		return NOTIFY_DONE;
	}
	buck_status = pval.intval;
#endif

	ret = power_supply_get_property(ppsy,
				POWER_SUPPLY_PROP_ONLINE, &pval);
	if (ret != 0) {
		pr_err("failed to get psy prop, ret=%d\n", ret);
		return NOTIFY_DONE;
	}

#if IS_ENABLED(CONFIG_AFC_CHARGER) && IS_ENABLED(CONFIG_CHARGER_SYV660)
	pr_info("%s: buck_status prev=%d new=%d\n", __func__,
				vt_muic.buck_prev_status, buck_status);

	if (vt_muic.buck_prev_status == SEC_BAT_CHG_MODE_BUCK_OFF &&
			(buck_status == SEC_BAT_CHG_MODE_CHARGING ||
			buck_status == SEC_BAT_CHG_MODE_CHARGING_OFF)) {
		if (vt_muic.ic_data && vt_muic.ic_data->m_ops.afc_dpdm_ctrl)
			vt_muic.ic_data->m_ops.afc_dpdm_ctrl(0);
		vt_muic.is_afc_started = 0;
		vt_muic.buck_prev_status = buck_status;
		return NOTIFY_DONE;
	} 
	vt_muic.buck_prev_status = buck_status;
#endif

	pr_info("%s: batt_cable prev=%d new=%d\n", __func__,
				vt_muic.batt_cable, pval.intval);

	vt_muic.batt_cable = pval.intval;
	schedule_work(&vt_muic.vt_muic_work);

	return NOTIFY_DONE;
}
#endif /* CONFIG_BATTERY_SAMSUNG */

#if IS_ENABLED(CONFIG_PDIC_NOTIFIER) && \
	IS_ENABLED(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
static void vt_muic_handle_pd_attach(PD_NOTI_ATTACH_TYPEDEF *pnoti)
{
	if (pnoti->rprd) {
		vt_muic.rprd = pnoti->rprd;
		schedule_work(&vt_muic.vt_muic_work);
	}
}

static void vt_muic_handle_pd_detach(PD_NOTI_ATTACH_TYPEDEF *pnoti)
{
	if (vt_muic.rprd) {
		vt_muic.rprd = 0;
		schedule_work(&vt_muic.vt_muic_work);
	}

	vt_muic.id_ta = 0;
}

static int vt_muic_manager_nb_func(struct notifier_block *nb,
		unsigned long action, void *data)
{
	PD_NOTI_TYPEDEF *pnoti = (PD_NOTI_TYPEDEF *)data;

	if (pnoti->dest != PDIC_NOTIFY_DEV_MUIC) {
		pr_err("%s: dest is invalid(%d)\n", __func__, pnoti->dest);
		return NOTIFY_DONE;
	}
	pr_info("%s: src:%d dest:%d id:%d sub[%d %d %d]\n", __func__,
		pnoti->src, pnoti->dest, pnoti->id,
		pnoti->sub1, pnoti->sub2, pnoti->sub3);

	switch (pnoti->id) {
	case PDIC_NOTIFY_ID_ATTACH:
		if (pnoti->sub1)
			vt_muic_handle_pd_attach((PD_NOTI_ATTACH_TYPEDEF *)
					pnoti);
		else
			vt_muic_handle_pd_detach((PD_NOTI_ATTACH_TYPEDEF *)
					pnoti);
		break;
	case PDIC_NOTIFY_ID_WATER:
		break;
	case PDIC_NOTIFY_ID_TA:
		if (pnoti->sub1)
			vt_muic.id_ta = 1;
		break;
	default:
		break;
	}

	return NOTIFY_DONE;
}
#endif /* CONFIG_PDIC_NOTIFIER && CONFIG_USB_TYPEC_MANAGER_NOTIFIER */

void vt_muic_set_attached_afc_dev(int attached_afc_dev)
{
	pr_info("%s: (%d)->(%d)\n", __func__, vt_muic.afc_dev, attached_afc_dev);
	if (vt_muic.afc_dev == attached_afc_dev)
		return;
	vt_muic.afc_dev = attached_afc_dev;
	schedule_work(&vt_muic.vt_muic_work);
}
EXPORT_SYMBOL(vt_muic_set_attached_afc_dev);

int vt_muic_get_attached_dev(void)
{
	return vt_muic.attached_dev;
}
EXPORT_SYMBOL(vt_muic_get_attached_dev);

int vt_muic_get_afc_disable(void)
{
	int ret = 0;

	if (vt_muic.muic_pdata)
		ret = vt_muic.muic_pdata->afc_disable;
	return ret;
}
EXPORT_SYMBOL(vt_muic_get_afc_disable);

void vt_muic_register_ic_data(struct vt_muic_ic_data *ic_data)
{
	vt_muic.ic_data = ic_data;
}
EXPORT_SYMBOL(vt_muic_register_ic_data);

static int vt_muic_afc_set_voltage(int voltage)
{
	struct vt_muic_ic_data *ic_data = vt_muic.ic_data;
	int ret = 0;

	if (ic_data && ic_data->m_ops.afc_set_voltage)
		ret = ic_data->m_ops.afc_set_voltage(voltage);

	return ret;
}

#ifdef CONFIG_MUIC_COMMON_SYSFS
static int vt_muic_get_attached_dev_cb(void *data)
{
	return vt_muic.attached_dev;
}

static int vt_muic_get_adc_cb(void *data)
{
	struct vt_muic_ic_data *ic_data = vt_muic.ic_data;
	int ret = 0;

	if (ic_data && ic_data->m_ops.get_adc)
		ret = ic_data->m_ops.get_adc(ic_data->mdata);

	return ret;
}

static int vt_muic_get_vbus_value_cb(void *data)
{
	struct vt_muic_ic_data *ic_data = vt_muic.ic_data;
	int ret = 0;

	if (ic_data && ic_data->m_ops.get_vbus_value)
		ret = ic_data->m_ops.get_vbus_value(ic_data->mdata);

	return ret;
}

static void vt_muic_set_afc_disable_cb(void *data)
{
	struct vt_muic_ic_data *ic_data = vt_muic.ic_data;

	if (ic_data && ic_data->m_ops.set_afc_disable)
		ic_data->m_ops.set_afc_disable(ic_data->mdata);
}

#if IS_ENABLED(CONFIG_HICCUP_CHARGER)
static int vt_muic_set_hiccup_cb(void *data, int en)
{
	struct vt_muic_ic_data *ic_data = vt_muic.ic_data;
	int ret = 0;

	if (ic_data && ic_data->m_ops.set_hiccup_mode)
		ret = ic_data->m_ops.set_hiccup_mode(ic_data->mdata, en);

	return ret;
}

static int vt_muic_set_hiccup_mode_cb(int en)
{
	struct vt_muic_ic_data *ic_data = vt_muic.ic_data;
	int ret = 0;

	if (ic_data && ic_data->m_ops.set_hiccup_mode)
		ret = ic_data->m_ops.set_hiccup_mode(ic_data->mdata, en);

	return ret;
}
#endif

static void vt_muic_fill_muic_sysfs_cb(struct muic_platform_data *pdata)
{
	pdata->sysfs_cb.get_attached_dev = vt_muic_get_attached_dev_cb;
	pdata->sysfs_cb.get_adc = vt_muic_get_adc_cb;
	pdata->sysfs_cb.get_vbus_value = vt_muic_get_vbus_value_cb;
	pdata->sysfs_cb.set_afc_disable = vt_muic_set_afc_disable_cb;
#if IS_ENABLED(CONFIG_HICCUP_CHARGER)
	pdata->sysfs_cb.set_hiccup = vt_muic_set_hiccup_cb;
#endif
}

static void vt_muic_fill_muic_cb(struct muic_platform_data *pdata)
{
#if IS_ENABLED(CONFIG_HICCUP_CHARGER)
	pdata->muic_set_hiccup_mode_cb = vt_muic_set_hiccup_mode_cb;
#endif
}
#endif

#if IS_ENABLED(CONFIG_OF)
static struct vt_muic_pdata *vt_muic_get_dt(struct device *dev)
{
	struct device_node *node;
	struct vt_muic_pdata *pdata;
	int ret = 0;

	node = dev->of_node;
	if (!node) {
		ret = -ENODEV;
		goto err_out;
	}

	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		ret = -ENOMEM;
		goto err_out;
	}

	pdata->usb_id_gpio = of_get_named_gpio(node, "vt_muic,usb_id", 0);
	if (gpio_is_valid(pdata->usb_id_gpio)) {
		ret = gpio_request(pdata->usb_id_gpio, "usb_id");
		if (ret) {
			pr_err("%s: usb_id gpio request fail(%d)\n",
				__func__, ret);
			goto err_out;
		}
	} else {
		pr_info("%s: gpio isn't used\n", __func__);
	}

	if (of_property_read_bool(node, "use_battery_notifier_callback"))
		pdata->use_psy_nb = 1;
	else
		pdata->use_psy_nb = 0;

	if (of_property_read_bool(node, "use_manager_notifier_callback"))
		pdata->use_manager_nb = 1;
	else
		pdata->use_manager_nb = 0;

	pr_info("%s: use_psy_nb(%d) use_manager_nb(%d)\n", __func__,
			pdata->use_psy_nb, pdata->use_manager_nb);

	return pdata;

err_out:
	return ERR_PTR(ret);
}
#endif /* CONFIG_OF */

static irqreturn_t vt_muic_irq_thread(int irq, void *data)
{
	pr_info("%s\n", __func__);

	if (time_after(jiffies, vt_muic.irq_debounce_interval)) {
		vt_muic.irq_debounce_interval = jiffies + msecs_to_jiffies(300);
		muic_send_lcd_on_uevent(vt_muic.muic_pdata);
	}

	return IRQ_HANDLED;
}

static int vt_muic_irq_init(void)
{
	struct vt_muic_pdata *pdata = vt_muic.pdata;
	int ret = 0;

	vt_muic.irq_debounce_interval = 0;

	if (!pdata)
		goto out;

	if (!gpio_is_valid(pdata->usb_id_gpio)) {
		pr_info("%s: do not need irq, return\n", __func__);
		goto out;
	}

	if (!IS_ENABLED(CONFIG_SEC_FACTORY))
		goto out;

	vt_muic.irq = gpio_to_irq(pdata->usb_id_gpio);
	ret = request_threaded_irq(vt_muic.irq, NULL, vt_muic_irq_thread,
			(IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT),
			"vt_muic", &vt_muic);
	if (ret) {
		pr_err("%s: failed request irq %d\n", __func__, ret);
		goto out;
	}

	ret = enable_irq_wake(vt_muic.irq);
	if (ret)
		pr_err("%s: failed enable irq %d\n", __func__, ret);

out:
	return ret;
}

static void vt_muic_data_init(void)
{
	vt_muic.attached_dev = ATTACHED_DEV_NONE_MUIC;
	vt_muic.batt_cable = -1;
	vt_muic.rprd = 0;
	vt_muic.afc_dev = ATTACHED_DEV_NONE_MUIC;
	vt_muic.id_ta = 0;
	vt_muic.buck_prev_status = -1;
	vt_muic.is_afc_started = 0;
}

static int vt_muic_probe(struct platform_device *pdev)
{
	struct vt_muic_pdata *pdata = pdev->dev.platform_data;
	int ret = 0;

	pr_info("%s\n", __func__);
	if (!pdata) {
#if IS_ENABLED(CONFIG_OF)
		pdata = vt_muic_get_dt(&pdev->dev);
		if (IS_ERR(pdata)) {
			pr_err("there is no device tree!\n");
			ret = -ENODEV;
			goto out;
		}
#else
		ret = -ENODEV;
		pr_err("there is no platform data!\n");
		goto out;
#endif /* CONFIG_OF */
	}
	vt_muic.dev = &pdev->dev;
	vt_muic.pdata = pdata;
	vt_muic_data_init();
	ret = vt_muic_irq_init();
	if (ret)
		goto out;

	vt_muic.muic_pdata = &muic_pdata;
	muic_pdata.drv_data = &vt_muic;

	vt_muic.muic_pdata->muic_afc_set_voltage_cb
			= vt_muic_afc_set_voltage;

#ifdef CONFIG_MUIC_COMMON_SYSFS
	vt_muic_fill_muic_sysfs_cb(vt_muic.muic_pdata);
	vt_muic_fill_muic_cb(vt_muic.muic_pdata);

	ret = muic_sysfs_init(vt_muic.muic_pdata);
	if (ret) {
		pr_err("%s: failed to create sysfs\n", __func__);
		goto err_free_irq;
	}
#endif

#if IS_MODULE(CONFIG_MUIC_NOTIFIER)
	if (vt_muic.muic_pdata->init_gpio_cb)
		ret = vt_muic.muic_pdata->init_gpio_cb(get_switch_sel());
#else
	if (vt_muic.muic_pdata->init_gpio_cb)
		ret = vt_muic.muic_pdata->init_gpio_cb();
#endif
	if (vt_muic.muic_pdata && vt_muic.muic_pdata->init_switch_dev_cb)
		vt_muic.muic_pdata->init_switch_dev_cb();

	if (pdata->use_psy_nb || pdata->use_manager_nb) {
		muic_notifier_detach_attached_dev(ATTACHED_DEV_UNKNOWN_MUIC);
		INIT_WORK(&vt_muic.vt_muic_work, vt_muic_work_func);
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
		if (pdata->use_psy_nb) {
			vt_muic.batt_cable = SEC_BATTERY_CABLE_NONE;
			vt_muic.psy_nb.notifier_call = vt_muic_psy_nb_func;
			vt_muic.psy_nb.priority = 0;
			ret = power_supply_reg_notifier(&vt_muic.psy_nb);
			if (ret < 0)
				pr_err("%s: register power supply notifier fail\n",
						__func__);
		}
#endif /* CONFIG_BATTERY_SAMSUNG */
#if IS_ENABLED(CONFIG_PDIC_NOTIFIER) && \
	IS_ENABLED(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
		if (pdata->use_manager_nb) {
			ret = manager_notifier_register(&vt_muic.manager_nb,
					vt_muic_manager_nb_func,
					MANAGER_NOTIFY_PDIC_MUIC);
			if (ret < 0)
				pr_err("%s: register manager notifier fail\n",
						__func__);
		}
#endif /* CONFIG_PDIC_NOTIFIER && CONFIG_USB_TYPEC_MANAGER_NOTIFIER */
	}

	pr_info("%s: done\n", __func__);

	return ret;
#ifdef CONFIG_MUIC_COMMON_SYSFS
err_free_irq:
	if (vt_muic.irq) {
		disable_irq_wake(vt_muic.irq);
		free_irq(vt_muic.irq, &vt_muic);
	}
#endif
out:
	if (gpio_is_valid(pdata->usb_id_gpio))
		gpio_free(pdata->usb_id_gpio);

	return ret;
}

static int vt_muic_remove(struct platform_device *pdev)
{
	struct vt_muic_pdata *pdata = pdev->dev.platform_data;

	if (pdata) {
#if IS_ENABLED(CONFIG_PDIC_NOTIFIER) && \
		IS_ENABLED(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
		if (pdata->use_manager_nb)
			manager_notifier_unregister(&vt_muic.manager_nb);
#endif /* CONFIG_PDIC_NOTIFIER && CONFIG_USB_TYPEC_MANAGER_NOTIFIER */
#if IS_ENABLED(CONFIG_BATTERY_SAMSUNG)
		if (pdata->use_psy_nb)
			power_supply_unreg_notifier(&vt_muic.psy_nb);
#endif /* CONFIG_BATTERY_SAMSUNG */

		if (vt_muic.muic_pdata && vt_muic.muic_pdata->cleanup_switch_dev_cb)
			vt_muic.muic_pdata->cleanup_switch_dev_cb();

		if (vt_muic.irq) {
			disable_irq_wake(vt_muic.irq);
			free_irq(vt_muic.irq, &vt_muic);
		}

		if (gpio_is_valid(pdata->usb_id_gpio))
			gpio_free(pdata->usb_id_gpio);
	}

	return 0;
}

#if IS_ENABLED(CONFIG_OF)
static const struct of_device_id vt_muic_dt_ids[] = {
	{ .compatible = "samsung,vt_muic" },
	{ }
};
MODULE_DEVICE_TABLE(of, vt_muic_dt_ids);
#endif /* CONFIG_OF */

static struct platform_driver vt_muic_driver = {
	.probe		= vt_muic_probe,
	.remove		= vt_muic_remove,
	.driver		= {
		.name		= "vt_muic",
		.owner		= THIS_MODULE,
#if IS_ENABLED(CONFIG_OF)
		.of_match_table	= of_match_ptr(vt_muic_dt_ids),
#endif /* CONFIG_OF */
	},
};

static int vt_muic_init(void)
{
	return platform_driver_register(&vt_muic_driver);
}

static void __exit vt_muic_exit(void)
{
	platform_driver_unregister(&vt_muic_driver);
}

device_initcall(vt_muic_init);
module_exit(vt_muic_exit);

MODULE_AUTHOR("Samsung USB Team");
MODULE_DESCRIPTION("Virtual Muic");
MODULE_LICENSE("GPL");