firmware/br-ext-chip-allwinner/board/v83x/kernel/patches/00000-drivers_input_init-input.c.patch

diff -drupN a/drivers/input/init-input.c b/drivers/input/init-input.c
--- a/drivers/input/init-input.c	1970-01-01 03:00:00.000000000 +0300
+++ b/drivers/input/init-input.c	2022-06-12 05:28:14.000000000 +0300
@@ -0,0 +1,893 @@
+/*
+ * Copyright (c) 2013-2015 liming@allwinnertech.com
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+#include <linux/input.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <linux/clk.h>
+#include <linux/gpio.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/platform_device.h>
+#include "init-input.h"
+
+
+/***************************CTP************************************/
+
+/**
+ * sunxi_ctp_startup() - get config info from sys_config.fex file.
+ *@ctp_type:  sensor type
+ * return value:
+ *                    = 0; success;
+ *                    < 0; err
+ */
+static int sunxi_ctp_startup(enum input_sensor_type *ctp_type)
+{
+	int ret = -1;
+	struct ctp_config_info *data = container_of(ctp_type,
+					struct ctp_config_info, input_type);
+	struct device_node *np = NULL;
+
+	np = of_find_node_by_name(NULL, "ctp");
+	if (!np) {
+		pr_err("ERROR! get ctp_para failed, func:%s, line:%d\n",
+							__func__, __LINE__);
+		goto devicetree_get_item_err;
+	}
+
+	if (!of_device_is_available(np)) {
+		pr_err("%s: ctp is not used\n", __func__);
+		goto devicetree_get_item_err;
+	} else
+		data->ctp_used = 1;
+
+	ret = of_property_read_u32(np, "ctp_twi_id", &data->twi_id);
+	if (ret) {
+		pr_err("get twi_id is fail, %d\n", ret);
+		goto devicetree_get_item_err;
+	}
+
+	ret = of_property_read_string(np,  "ctp_name", &data->name);
+	if (ret)
+		pr_err("get ctp_name is fail, %d\n", ret);
+
+	ret = of_property_read_string(np,  "ctp_power_ldo", &data->ctp_power);
+	if (ret)
+		pr_err("get ctp_power is fail, %d\n", ret);
+
+	ret = of_property_read_u32(np, "ctp_power_ldo_vol",
+							&data->ctp_power_vol);
+	if (ret)
+		pr_err("get ctp_power_ldo_vol is fail, %d\n", ret);
+
+	data->ctp_power_io.gpio = of_get_named_gpio_flags(np, "ctp_power_io", 0,
+				(enum of_gpio_flags *)(&(data->ctp_power_io)));
+	if (!gpio_is_valid(data->ctp_power_io.gpio))
+		pr_err("%s: ctp_power_io is invalid.\n", __func__);
+
+	data->wakeup_gpio.gpio = of_get_named_gpio_flags(np, "ctp_wakeup", 0,
+				(enum of_gpio_flags *)(&(data->wakeup_gpio)));
+	if (!gpio_is_valid(data->wakeup_gpio.gpio))
+		pr_err("%s: wakeup_gpio is invalid.\n", __func__);
+
+	ret = of_property_read_u32(np, "ctp_screen_max_x", &data->screen_max_x);
+	if (ret)
+		pr_err("get ctp_screen_max_x is fail, %d\n", ret);
+
+	ret = of_property_read_u32(np, "ctp_screen_max_y", &data->screen_max_y);
+	if (ret)
+		pr_err("get screen_max_y is fail, %d\n", ret);
+
+	ret = of_property_read_u32(np, "ctp_revert_x_flag",
+							&data->revert_x_flag);
+	if (ret)
+		pr_err("get revert_x_flag is fail, %d\n", ret);
+
+	ret = of_property_read_u32(np, "ctp_revert_y_flag",
+							&data->revert_y_flag);
+	if (ret)
+		pr_err("get revert_y_flag is fail, %d\n", ret);
+
+	ret = of_property_read_u32(np, "ctp_exchange_x_y_flag",
+						&data->exchange_x_y_flag);
+	if (ret)
+		pr_err("get ctp_exchange_x_y_flag is fail, %d\n", ret);
+
+	data->irq_gpio.gpio = of_get_named_gpio_flags(np, "ctp_int_port", 0,
+				(enum of_gpio_flags *)(&(data->irq_gpio)));
+	if (!gpio_is_valid(data->irq_gpio.gpio))
+		pr_err("%s: irq_gpio is invalid.\n", __func__);
+	else
+		data->int_number = data->irq_gpio.gpio;
+
+#ifdef TOUCH_KEY_LIGHT_SUPPORT
+
+	data->key_light_gpio.gpio = of_get_named_gpio(np, "ctp_light", 0);
+	if (!gpio_is_valid(data->key_light_gpio.gpio))
+		pr_err("%s: key_light_gpio is invalid.\n", __func__);
+#endif
+	return 0;
+
+devicetree_get_item_err:
+	pr_notice("=========script_get_item_err============\n");
+	return ret;
+}
+
+/**
+ * sunxi_ctp_free() - free ctp related resource
+ * @ctp_type:sensor type
+ */
+static void sunxi_ctp_free(enum input_sensor_type *ctp_type)
+{
+	struct ctp_config_info *data = container_of(ctp_type,
+					struct ctp_config_info, input_type);
+
+	gpio_free(data->wakeup_gpio.gpio);
+
+#ifdef TOUCH_KEY_LIGHT_SUPPORT
+	gpio_free(data->key_light_gpio.gpio);
+#endif
+	if (data->ctp_power_ldo) {
+		regulator_put(data->ctp_power_ldo);
+		data->ctp_power_ldo = NULL;
+	} else if (gpio_is_valid(data->ctp_power_io.gpio))
+		gpio_free(data->ctp_power_io.gpio);
+
+}
+
+/**
+ * sunxi_ctp_init - initialize platform related resource
+ * @ctp_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+static int sunxi_ctp_init(enum input_sensor_type *ctp_type)
+{
+	int ret = -1;
+	struct ctp_config_info *data = container_of(ctp_type,
+					struct ctp_config_info, input_type);
+
+	if (data->ctp_power) {
+		data->ctp_power_ldo = regulator_get(NULL, data->ctp_power);
+		if (IS_ERR(data->ctp_power_ldo)) {
+			pr_err("%s: could not get ctp ldo '%s' , check",
+						__func__, data->ctp_power);
+			pr_err("if ctp independent power supply by ldo,ignore firstly\n");
+		} else if (data->ctp_power_vol != 0) {
+			regulator_set_voltage(data->ctp_power_ldo,
+					(int)(data->ctp_power_vol)*1000,
+					(int)(data->ctp_power_vol)*1000);
+		}
+	} else if (gpio_is_valid(data->ctp_power_io.gpio)) {
+		if (gpio_request(data->ctp_power_io.gpio, NULL) != 0)
+			pr_err("ctp_power_io gpio_request is failed, check if ctp independent power supply by gpio, ignore firstly\n");
+		else
+			gpio_direction_output(data->ctp_power_io.gpio, 1);
+	}
+	if (gpio_request(data->wakeup_gpio.gpio, NULL) != 0) {
+		pr_err("wakeup gpio_request is failed\n");
+		return ret;
+	}
+	if (gpio_direction_output(data->wakeup_gpio.gpio, 1) != 0) {
+		pr_err("wakeup gpio set err!");
+		return ret;
+	}
+
+#ifdef TOUCH_KEY_LIGHT_SUPPORT
+	if (gpio_request(data->key_light_gpio.gpio, NULL) != 0) {
+		pr_err("key_light gpio_request is failed\n");
+		return ret;
+	}
+
+	if (gpio_direction_output(data->key_light_gpio.gpio, 1) != 0) {
+		pr_err("key_light gpio set err!");
+		return ret;
+	}
+#endif
+	ret = 0;
+	return ret;
+}
+/*************************CTP END************************************/
+
+/*************************GSENSOR************************************/
+
+/*
+ * sunxi_gsensor_free() - free gsensor related resource
+ * @gsensor_type:sensor type
+ */
+static void sunxi_gsensor_free(enum input_sensor_type *gsensor_type)
+{
+	struct sensor_config_info *data = container_of(gsensor_type,
+					struct sensor_config_info, input_type);
+
+	if (data->sensor_power_ldo) {
+		regulator_put(data->sensor_power_ldo);
+		data->sensor_power_ldo = NULL;
+	  }
+}
+
+/**
+ * sunxi_gsensor_init() - initialize platform related resource
+ * @gsensor_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+static int sunxi_gsensor_init(enum input_sensor_type *gsensor_type)
+{
+	struct sensor_config_info *data = container_of(gsensor_type,
+					struct sensor_config_info, input_type);
+
+	if (data->sensor_power) {
+		data->sensor_power_ldo = regulator_get(NULL,
+							data->sensor_power);
+		if (!data->sensor_power_ldo) {
+			pr_err("%s: could not get ctp ldo '%s' ,check"
+					, __func__, data->sensor_power);
+			pr_err("if ctp independent power supply by ldo,ignore firstly\n");
+		} else
+			regulator_set_voltage(data->sensor_power_ldo,
+					(int)(data->sensor_power_vol)*1000,
+					(int)(data->sensor_power_vol)*1000);
+
+	}
+
+	return 0;
+}
+
+/**
+ * sunxi_gsensor_startup() - get config info from sys_config.fex file.
+ * @gsensor_type:sensor type
+ * return value:
+ *                    = 0; success;
+ *                    < 0; err
+ */
+static int sunxi_gsensor_startup(enum input_sensor_type *gsensor_type)
+{
+	int ret = -1;
+	struct sensor_config_info *data = container_of(gsensor_type,
+					struct sensor_config_info, input_type);
+	struct device_node *np = NULL;
+
+	np = of_find_node_by_name(NULL, "gsensor");
+	if (!np) {
+		pr_err("ERROR! get gsensor_para failed, func:%s, line:%d\n",
+							__func__, __LINE__);
+		goto devicetree_get_item_err;
+	}
+
+	if (!of_device_is_available(np)) {
+		pr_err("%s: gsensor is not used\n", __func__);
+		goto devicetree_get_item_err;
+	} else
+		data->sensor_used = 1;
+
+	if (data->sensor_used == 1) {
+		ret = of_property_read_u32(np, "gsensor_twi_id", &data->twi_id);
+		if (ret) {
+			pr_err("get gsensor_twi_id is fail, %d\n", ret);
+			goto devicetree_get_item_err;
+		}
+	} else
+		pr_err("%s gsensor_unused\n", __func__);
+
+	ret = of_property_read_string(np, "gsensor_vcc_io",
+						&data->sensor_power);
+	if (ret) {
+		pr_err("get gsensor_vcc_io is fail, %d\n", ret);
+		goto devicetree_get_item_err;
+	}
+
+	ret = of_property_read_u32(np, "gsensor_vcc_io_val",
+						&data->sensor_power_vol);
+	if (ret) {
+		pr_err("get gsensor_vcc_io_val is fail, %d\n", ret);
+		goto devicetree_get_item_err;
+	  }
+
+	return ret;
+
+devicetree_get_item_err:
+	pr_notice("=========gsensor script_get_err============\n");
+	ret = -1;
+	return ret;
+
+}
+
+/**************************GSENSOR END*********************************/
+
+/*************************** GYR *************************************/
+
+/**
+ * sunxi_gyr_free() - free gyr related resource
+ * @gyr_type:sensor type
+ * return value:
+ */
+static void sunxi_gyr_free(enum input_sensor_type *gyr_type)
+{
+}
+
+/**
+ * sunxi_gyr_init() - initialize platform related resource
+ * @gyr_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+static int sunxi_gyr_init(enum input_sensor_type *gyr_type)
+{
+	return 0;
+}
+
+/**
+ * sunxi_gyr_startup() - get config info from sys_config.fex file.
+ * @gyr_type:sensor type
+ * return value:
+ *                    = 0; success;
+ *                    < 0; err
+ */
+static int sunxi_gyr_startup(enum input_sensor_type *gyr_type)
+{
+	int ret = -1;
+	struct sensor_config_info *data = container_of(gyr_type,
+					struct sensor_config_info, input_type);
+	struct device_node *np = NULL;
+
+	np = of_find_node_by_name(NULL, "gy");
+	if (!np) {
+		pr_err("ERROR! get gy_para failed, func:%s, line:%d\n",
+							__func__, __LINE__);
+		goto devicetree_get_item_err;
+	}
+
+	if (!of_device_is_available(np)) {
+		pr_err("%s: gy is not used\n", __func__);
+		goto devicetree_get_item_err;
+	} else
+		data->sensor_used = 1;
+
+	if (data->sensor_used == 1) {
+		ret = of_property_read_u32(np, "gy_twi_id", &data->twi_id);
+		if (ret) {
+			pr_err("get gy_twi_id is fail, %d\n", ret);
+			goto devicetree_get_item_err;
+		}
+	} else
+		pr_err("%s gy_unused\n", __func__);
+
+	return ret;
+
+devicetree_get_item_err:
+	pr_notice("=========script_get_err============\n");
+	ret = -1;
+	return ret;
+}
+
+/****************************** GYR END **********************************/
+
+/****************************** COMPASS *********************************/
+
+/**
+ * sunxi_ecompass_free() - free e_compass related resource
+ * @e_compass_type:sensor type
+ * return value:
+ */
+static void sunxi_ecompass_free(enum input_sensor_type *e_compass_type)
+{
+}
+
+/**
+ * sunxi_ecompass_init() - initialize platform related resource
+ * @e_compass_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+static int sunxi_ecompass_init(enum input_sensor_type *e_compass_type)
+{
+	return 0;
+}
+
+/**
+ * sunxi_ecompass_staetup() - get config info from sys_config.fex file.
+ * @e_compass_type:sensor type
+ * return value:
+ *                    = 0; success;
+ *                    < 0; err
+ */
+
+static int sunxi_ecompass_startup(enum input_sensor_type *e_compass_type)
+{
+	int ret = -1;
+	struct sensor_config_info *data = container_of(e_compass_type,
+					struct sensor_config_info, input_type);
+	struct device_node *np = NULL;
+
+	np = of_find_node_by_name(NULL, "compass");
+	if (!np) {
+		pr_err("ERROR! get compass_para failed, func:%s, line:%d\n",
+							__func__, __LINE__);
+		goto devicetree_get_item_err;
+	}
+
+	if (!of_device_is_available(np)) {
+		pr_err("%s: compass is not used\n", __func__);
+		goto devicetree_get_item_err;
+	} else
+		data->sensor_used = 1;
+
+	if (data->sensor_used == 1) {
+		ret = of_property_read_u32(np, "compass_twi_id", &data->twi_id);
+		if (ret) {
+			pr_err("get compass_twi_id is fail, %d\n", ret);
+			goto devicetree_get_item_err;
+		}
+	} else
+		pr_err("%s gsensor_unused\n", __func__);
+
+	return ret;
+
+devicetree_get_item_err:
+	pr_notice("=========script_get_err============\n");
+	ret = -1;
+	return ret;
+
+}
+/***************************** COMPASS END ***********************************/
+
+/**************************** LIGHT SENSOR ***********************************/
+
+/**
+ * sunxi_ls_free() - free ls related resource
+ * @ls_type:sensor type
+ * return value:
+ */
+static void sunxi_ls_free(enum input_sensor_type *ls_type)
+{
+	struct regulator *ldo = NULL;
+	struct sensor_config_info *data = container_of(ls_type,
+					struct sensor_config_info, input_type);
+	/* disable ldo if it exist */
+
+	if (data->sensor_power) {
+		ldo = regulator_get(NULL, data->sensor_power);
+		if (!ldo)
+			pr_err("%s:could not get ldo '%s' in remove, something error,ignore it here !\n",
+							__func__, data->sensor_power);
+		else {
+			regulator_disable(ldo);
+			regulator_put(ldo);
+		}
+	}
+}
+
+/**
+ * sunxi_ls_init() - initialize platform related resource
+ * @ls_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+static int sunxi_ls_init(enum input_sensor_type *ls_type)
+{
+	struct sensor_config_info *data = container_of(ls_type,
+					struct sensor_config_info, input_type);
+
+	/* enalbe ldo if it exist */
+	if (data->sensor_power) {
+		data->sensor_power_ldo = regulator_get(NULL, data->sensor_power);
+		if (!data->sensor_power_ldo) {
+			pr_err("%s: could not get sensor power ldo '%s' in probe,",
+							__func__, data->sensor_power);
+			pr_err("maybe config error, ignore firstly !!!!!!!\n");
+		}
+		/*regulator_set_voltage(ldo, 3000000, 3000000);*/
+		if (0 != regulator_enable(data->sensor_power_ldo))
+			pr_err("%s: regulator_enable error!\n", __func__);
+		usleep_range(10000, 15000);
+	}
+	return 0;
+}
+
+/**
+ * sunxi_ls_startup() - get config info from sysconfig.fex file.
+ * @ls_type:sensor type
+ * return value:
+ *                    = 0; success;
+ *                    < 0; err
+ */
+
+static int sunxi_ls_startup(enum input_sensor_type *ls_type)
+{
+	int ret = -1;
+	struct sensor_config_info *data = container_of(ls_type,
+					struct sensor_config_info, input_type);
+	struct device_node *np = NULL;
+
+	np = of_find_node_by_name(NULL, "ls_para");
+	if (!np) {
+		pr_err("ERROR! get ls_para failed, func:%s, line:%d\n",
+							__func__, __LINE__);
+		goto devicetree_get_item_err;
+	}
+
+	if (!of_device_is_available(np)) {
+		pr_err("%s: ls is not used\n", __func__);
+		goto devicetree_get_item_err;
+	} else
+		data->sensor_used = 1;
+
+	if (data->sensor_used == 1) {
+		ret = of_property_read_u32(np, "ls_twi_id", &data->twi_id);
+		if (ret) {
+			pr_err("get ls_twi_idl, %d\n", ret);
+			goto devicetree_get_item_err;
+		}
+
+		pr_err("sensor_twi_id=%d\n", data->twi_id);
+		data->irq_gpio.gpio = of_get_named_gpio(np, "ls_int", 0);
+		if (!gpio_is_valid(data->irq_gpio.gpio))
+			pr_err("%s: irq_gpio is invalid.\n", __func__);
+		else
+			data->int_number = data->irq_gpio.gpio;
+
+		ret = of_property_read_string(np, "ls_vcc", &data->sensor_power);
+		if (ret) {
+		    pr_err("get light sensor vcc is fail, %d\n", ret);
+		}
+
+	} else {
+		pr_err("%s light sensor unused \n", __func__);
+		}
+
+	return ret;
+
+devicetree_get_item_err:
+	pr_err("=========script_get_err============\n");
+	ret = -1;
+	return ret;
+
+}
+/**************** LIGHT SENSOR END ***********************/
+
+/************************ MOTOR *************************/
+
+/**
+ * sunxi_motor_free()- free ths related resource
+ * @motor_type:sensor type
+ * return value:
+ */
+static void sunxi_motor_free(enum input_sensor_type *motor_type)
+{
+	struct motor_config_info *data = container_of(motor_type,
+					struct motor_config_info, input_type);
+
+	if (data->motor_gpio.gpio != 0)
+		gpio_free(data->motor_gpio.gpio);
+}
+
+/**
+ * sunxi_motor_init() - initialize platform related resource
+ * @motor_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+static int sunxi_motor_init(enum input_sensor_type *motor_type)
+{
+	struct motor_config_info *data = container_of(motor_type,
+					struct motor_config_info, input_type);
+
+	if (gpio_is_valid(data->motor_gpio.gpio)) {
+		if (gpio_request(data->motor_gpio.gpio, "vibe") != 0) {
+			pr_err("ERROR: vibe Gpio_request is failed\n");
+			return -1;
+		}
+		gpio_direction_output(data->motor_gpio.gpio, data->vibe_off);
+	}
+
+	return 0;
+}
+
+/**
+ * sunxi_motor_startup() - get config info from sys_config.fex file.
+ * @motor_type:sensor type
+ * return value:
+ *                    = 0; success;
+ *                    < 0; err
+ */
+static int sunxi_motor_startup(enum input_sensor_type *motor_type)
+{
+	struct motor_config_info *data = container_of(motor_type,
+					struct motor_config_info, input_type);
+	struct device_node *np = NULL;
+	int ret = -1;
+
+	np = of_find_node_by_name(NULL, "motor_para");
+	if (!np) {
+		pr_err("ERROR! get motor_para failed, func:%s, line:%d\n",
+			__func__, __LINE__);
+		return -1;
+	}
+
+	if (of_device_is_available(np))
+		data->motor_used = 1;
+	else {
+		pr_err("%s: motor_para is not used\n", __func__);
+		return -1;
+	}
+
+	data->motor_gpio.gpio = of_get_named_gpio_flags(np, "motor_shake", 0,
+				(enum of_gpio_flags *)(&(data->motor_gpio)));
+	if (!gpio_is_valid(data->motor_gpio.gpio))
+		pr_err("%s: motor_shake is invalid\n", __func__);
+
+	ret = of_property_read_string(np, "motor_ldo", &data->ldo);
+	if (ret)
+		pr_err("get motor_ldo is fail, %d\n", ret);
+
+	ret = of_property_read_u32(np, "motor_ldo_voltage", &data->ldo_voltage);
+	if (ret)
+		pr_err("get motor_ldo_voltage is fail, %d\n", ret);
+
+	return 0;
+}
+
+/******************************** MOTOR END ***********************************/
+
+
+static int (* const sunxi_startup[])(enum input_sensor_type *input_type) = {
+	sunxi_ctp_startup,
+	sunxi_gsensor_startup,
+	sunxi_gyr_startup,
+	sunxi_ecompass_startup,
+	sunxi_ls_startup,
+	sunxi_motor_startup,
+};
+
+static int (*sunxi_init[])(enum input_sensor_type *input_type) = {
+	sunxi_ctp_init,
+	sunxi_gsensor_init,
+	sunxi_gyr_init,
+	sunxi_ecompass_init,
+	sunxi_ls_init,
+	sunxi_motor_init,
+};
+
+static void (*sunxi_free[])(enum input_sensor_type *input_type) = {
+	sunxi_ctp_free,
+	sunxi_gsensor_free,
+	sunxi_gyr_free,
+	sunxi_ecompass_free,
+	sunxi_ls_free,
+	sunxi_motor_free,
+};
+
+int input_set_power_enable(enum input_sensor_type *input_type, u32 enable)
+{
+	int ret = -1;
+	struct regulator *ldo = NULL;
+	u32 power_io = 0;
+	void *data = NULL;
+
+	switch (*input_type) {
+	case CTP_TYPE:
+		data = container_of(input_type,
+					struct ctp_config_info, input_type);
+		ldo = ((struct ctp_config_info *)data)->ctp_power_ldo;
+		power_io = ((struct ctp_config_info *)data)->ctp_power_io.gpio;
+		break;
+	case GSENSOR_TYPE:
+		data = container_of(input_type, struct sensor_config_info,
+								input_type);
+		ldo = ((struct sensor_config_info *)data)->sensor_power_ldo;
+		break;
+	case LS_TYPE:
+		break;
+	default:
+		break;
+	}
+	if ((enable != 0) && (enable != 1))
+		return ret;
+
+	if (ldo) {
+		if (enable) {
+			if (regulator_enable(ldo) != 0)
+				pr_err("%s: enable ldo error!\n", __func__);
+		} else {
+			if (regulator_is_enabled(ldo))
+				regulator_disable(ldo);
+		}
+	} else if (gpio_is_valid(power_io)) {
+		if (enable)
+			__gpio_set_value(power_io, 1);
+		else
+			__gpio_set_value(power_io, 0);
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(input_set_power_enable);
+/**
+ * input_set_int_enable() - input set irq enable
+ * Input_type:sensor type
+ *      enable:
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ */
+int input_set_int_enable(enum input_sensor_type *input_type, u32 enable)
+{
+	int ret = -1;
+	u32 irq_number = 0;
+	void *data = NULL;
+
+	switch (*input_type) {
+	case CTP_TYPE:
+		data = container_of(input_type,
+					struct ctp_config_info, input_type);
+		irq_number = gpio_to_irq(((struct ctp_config_info *)data)->int_number);
+		break;
+	case GSENSOR_TYPE:
+		break;
+	case LS_TYPE:
+		data = container_of(input_type,
+					struct sensor_config_info, input_type);
+		irq_number = gpio_to_irq(((struct sensor_config_info *)data)->int_number);
+		break;
+	default:
+		break;
+	}
+
+	if ((enable != 0) && (enable != 1))
+		return ret;
+
+	if (enable == 1)
+		enable_irq(irq_number);
+	else
+		disable_irq_nosync(irq_number);
+
+	return 0;
+}
+EXPORT_SYMBOL(input_set_int_enable);
+
+/**
+ * input_free_int - input free irq
+ * Input_type:sensor type
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ */
+int input_free_int(enum input_sensor_type *input_type, void *para)
+{
+	int irq_number = 0;
+	void *data = NULL;
+	struct device *dev = NULL;
+
+	switch (*input_type) {
+	case CTP_TYPE:
+		data = container_of(input_type,
+					struct ctp_config_info, input_type);
+		irq_number = gpio_to_irq(((struct ctp_config_info *)data)->int_number);
+
+		dev = ((struct ctp_config_info *)data)->dev;
+		break;
+	case GSENSOR_TYPE:
+		break;
+	case LS_TYPE:
+		data = container_of(input_type,
+					struct sensor_config_info, input_type);
+		irq_number = gpio_to_irq(((struct sensor_config_info *)data)->int_number);
+
+		dev = ((struct sensor_config_info *)data)->dev;
+		break;
+	default:
+		break;
+	}
+
+	devm_free_irq(dev, irq_number, para);
+
+	return 0;
+}
+EXPORT_SYMBOL(input_free_int);
+
+/**
+ * input_request_int() - input request irq
+ * Input:
+ *	type:
+ *      handle:
+ *      trig_gype:
+ *      para:
+ * return value: 0 : success
+ *               -EIO :  i/o err.
+ *
+ */
+int input_request_int(enum input_sensor_type *input_type, irq_handler_t handle,
+			unsigned long trig_type, void *para)
+{
+	int ret = -1;
+	int irq_number = 0;
+
+	void *data = NULL;
+	struct device *dev = NULL;
+
+	switch (*input_type) {
+	case CTP_TYPE:
+		data = container_of(input_type,
+					struct ctp_config_info, input_type);
+		irq_number = gpio_to_irq(((struct ctp_config_info *)data)->int_number);
+		if (irq_number < 0) {
+			pr_warn("map gpio to virq failed, errno = %d\n",
+								irq_number);
+			return -EINVAL;
+		}
+
+		dev = ((struct ctp_config_info *)data)->dev;
+		break;
+	case GSENSOR_TYPE:
+		break;
+	case LS_TYPE:
+		data = container_of(input_type,
+					struct sensor_config_info, input_type);
+		irq_number = gpio_to_irq(((struct sensor_config_info *)data)->int_number);
+		if (irq_number < 0) {
+			pr_warn("map gpio to virq failed, errno = %d\n",
+								irq_number);
+			return -EINVAL;
+		}
+
+		dev = ((struct sensor_config_info *)data)->dev;
+		break;
+	default:
+		break;
+	}
+
+	/* request virq, set virq type to high level trigger */
+	ret = devm_request_irq(dev, irq_number, handle,
+						trig_type, "PA3_EINT", para);
+	if (ret < 0) {
+		pr_warn("request virq %d failed, errno = %d\n",
+							irq_number, ret);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(input_request_int);
+
+void input_sensor_free(enum input_sensor_type *input_type)
+{
+	(*sunxi_free[*input_type])(input_type);
+}
+EXPORT_SYMBOL(input_sensor_free);
+
+int input_sensor_init(enum input_sensor_type *input_type)
+{
+	int ret = -1;
+
+	ret = (*sunxi_init[*input_type])(input_type);
+
+	return ret;
+}
+EXPORT_SYMBOL(input_sensor_init);
+
+int input_sensor_startup(enum input_sensor_type *input_type)
+{
+	int ret = -1;
+
+	ret = (*sunxi_startup[*input_type])(input_type);
+
+	return ret;
+}
+EXPORT_SYMBOL(input_sensor_startup);