diff --git a/src/bach/build.bach/work/libmodem-afe-ctrl/mt2735/src/pcm_ctrl.c b/src/bach/build.bach/work/libmodem-afe-ctrl/mt2735/src/pcm_ctrl.c
index 65b7397..c35c914 100644
--- a/src/bach/build.bach/work/libmodem-afe-ctrl/mt2735/src/pcm_ctrl.c
+++ b/src/bach/build.bach/work/libmodem-afe-ctrl/mt2735/src/pcm_ctrl.c
@@ -156,7 +156,6 @@
 //TBD
 static const Mixer_pair BT_ENABLE_SEQ[] = {
 	/*{mixer name, option name}*/
-	{"ETDM_HD_Mux", "Normal"},
 };
 
 static const Mixer_pair SPK_DISABLE_SEQ[] = {
@@ -189,7 +188,6 @@
 //TBD
 static const Mixer_pair BT_DISABLE_SEQ[] = {
 	/*{mixer name, option name}*/
-	{"ETDM_HD_Mux", "Normal"},
 };
 
 static const Mixer_pair INT_CODEC_INTERCONN_SEQ[] = {
@@ -202,6 +200,10 @@
 
 static const Mixer_pair BT_INTERCONN_SEQ[] = {
 	/*{mixer name, option name}*/
+	{"PCM_2_PB_CH1 PCM_0_CAP_CH1", "1"},
+	{"PCM_2_PB_CH2 PCM_0_CAP_CH2", "1"},
+	{"PCM_0_PB_CH1 PCM_2_CAP_CH1", "1"},
+	{"PCM_0_PB_CH2 PCM_2_CAP_CH1", "1"},
 };
 
 /*external codec seq, should modify if new codec applied*/
diff --git a/src/bsp/lk/platform/mt2735/drivers/ssusb/mtu3.c b/src/bsp/lk/platform/mt2735/drivers/ssusb/mtu3.c
index 9db63b7..c628262 100644
--- a/src/bsp/lk/platform/mt2735/drivers/ssusb/mtu3.c
+++ b/src/bsp/lk/platform/mt2735/drivers/ssusb/mtu3.c
@@ -887,6 +887,10 @@
     g_u3d.is_u3_ip = !!SSUSB_IP_DEV_U3_PORT_NUM(val);
     DBG_C("IP version 0x%x(%s IP)\n", readl(U3D_SSUSB_HW_ID),
           g_u3d.is_u3_ip ? "U3" : "U2");
+    if (g_u3d.is_u3_ip) {
+        DBG_C("fastboot support U2 only, disable U3 by default\n");
+        g_u3d.is_u3_ip = !g_u3d.is_u3_ip;
+    }
 }
 
 static void mu3d_hw_init(void)
diff --git a/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb-ivt-emmc.dts b/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb-ivt-emmc.dts
index 442f46d..6a33422 100644
--- a/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb-ivt-emmc.dts
+++ b/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb-ivt-emmc.dts
@@ -641,6 +641,88 @@
 			bias-pull-down=<MTK_PUPD_SET_R1R0_01>;
 		};
 	};
+
+	aud_gpio_pcm0_off: aud_gpio_pcm0_off {
+		pins_cmd0_dat {
+			pinmux = <PINMUX_GPIO97__FUNC_GPIO97>;
+			input-enable;
+			bias-pull-down;
+		};
+		pins_cmd1_dat {
+			pinmux = <PINMUX_GPIO98__FUNC_GPIO98>;
+			input-enable;
+			bias-pull-down;
+		};
+		pins_cmd2_dat {
+			pinmux = <PINMUX_GPIO99__FUNC_GPIO99>;
+			input-enable;
+			bias-pull-down;
+		};
+		pins_cmd3_dat {
+			pinmux = <PINMUX_GPIO100__FUNC_GPIO100>;
+			input-enable;
+			bias-pull-down;
+		};
+	};
+	aud_gpio_pcm0_on: aud_gpio_pcm0_on {
+		pins_cmd0_dat {
+			pinmux = <PINMUX_GPIO97__FUNC_PCM0_CLK>;
+			bias-disable;
+		};
+		pins_cmd1_dat {
+			pinmux = <PINMUX_GPIO98__FUNC_PCM0_SYNC>;
+			bias-disable;
+		};
+		pins_cmd2_dat {
+			pinmux = <PINMUX_GPIO99__FUNC_PCM0_DI>;
+			bias-disable;
+		};
+		pins_cmd3_dat {
+			pinmux = <PINMUX_GPIO100__FUNC_PCM0_DO>;
+			bias-disable;
+		};
+	};
+
+	aud_gpio_pcm1_off: aud_gpio_pcm1_off {
+		pins_cmd0_dat {
+			pinmux = <PINMUX_GPIO199__FUNC_GPIO199>;
+			input-enable;
+			bias-pull-down;
+		};
+		pins_cmd1_dat {
+			pinmux = <PINMUX_GPIO200__FUNC_GPIO200>;
+			input-enable;
+			bias-pull-down;
+		};
+		pins_cmd2_dat {
+			pinmux = <PINMUX_GPIO201__FUNC_GPIO201>;
+			input-enable;
+			bias-pull-down;
+		};
+		pins_cmd3_dat {
+			pinmux = <PINMUX_GPIO202__FUNC_GPIO202>;
+			input-enable;
+			bias-pull-down;
+		};
+	};
+	aud_gpio_pcm1_on: aud_gpio_pcm1_on {
+		pins_cmd0_dat {
+			pinmux = <PINMUX_GPIO199__FUNC_PCM1_CLK>;
+			bias-disable;
+		};
+		pins_cmd1_dat {
+			pinmux = <PINMUX_GPIO200__FUNC_PCM1_SYNC>;
+			bias-disable;
+		};
+		pins_cmd2_dat {
+			pinmux = <PINMUX_GPIO201__FUNC_PCM1_DI>;
+			bias-disable;
+		};
+		pins_cmd3_dat {
+			pinmux = <PINMUX_GPIO202__FUNC_PCM1_DO>;
+			bias-disable;
+		};
+	};
 };
 
 &pcie0 {
diff --git a/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb.dts b/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb.dts
index db270c9..2e97b3c 100755
--- a/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb.dts
+++ b/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/auto2735evb.dts
@@ -1269,14 +1269,14 @@
 	aud_pins_extamp_high: audexamphigh {
 		pins_cmd0_dat {
 			pinmux = <PINMUX_GPIO27__FUNC_GPIO27>;
-			output-high;
+			output-low;
 		};
 	};
 	aud_pins_extamp_low: audexamplow {
 		pins_cmd0_dat {
 			pinmux = <PINMUX_GPIO27__FUNC_GPIO27>;
-			input-enable;
-			bias-pull-down=<MTK_PUPD_SET_R1R0_01>;
+			//input-enable;
+			//bias-pull-down=<MTK_PUPD_SET_R1R0_01>;
 		};
 	};
 };
diff --git a/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/mt6330.dtsi b/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/mt6330.dtsi
index 48bc13b..3d686dc 100644
--- a/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/mt6330.dtsi
+++ b/src/kernel/linux/v4.19/arch/arm64/boot/dts/mediatek/mt6330.dtsi
@@ -350,6 +350,15 @@
 				bits = <6 1>;
 			};
 		};
+
+		mt6330chrdet: mt6330chrdet {
+			compatible = "mediatek,mt6330-chrdet";
+
+			chr_det: chr_det {
+				enable;
+				wakeup-source;
+			};
+		};
 	};
 };
 
diff --git a/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig b/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig
index 335e5da..b114cf1 100644
--- a/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig
+++ b/src/kernel/linux/v4.19/arch/arm64/configs/auto2735evb_defconfig
@@ -368,7 +368,7 @@
 CONFIG_EXTCON_MTK_USB=y
 CONFIG_MTK_USB_TYPEC_U3_MUX=y
 CONFIG_TCPC_CLASS=y
-# CONFIG_TCPC_RT1711H is not set
+CONFIG_TCPC_RT1711H=y
 CONFIG_MTK_TINYSYS_SSPM_SUPPORT=y
 CONFIG_MTK_TINYSYS_MCUPM_SUPPORT=y
 CONFIG_MTK_TINYSYS_MEDMCU_SUPPORT=y
diff --git a/src/kernel/linux/v4.19/drivers/mfd/mt6330-core.c b/src/kernel/linux/v4.19/drivers/mfd/mt6330-core.c
index 0da7dc7..4dbb81f 100644
--- a/src/kernel/linux/v4.19/drivers/mfd/mt6330-core.c
+++ b/src/kernel/linux/v4.19/drivers/mfd/mt6330-core.c
@@ -81,6 +81,10 @@
 	DEFINE_RES_IRQ_NAMED(MT6330_IRQ_VRFCK_OC, "VRFCK"),
 };
 
+static const struct resource mt6330_chrdet_resources[] = {
+	DEFINE_RES_IRQ(MT6330_IRQ_CHRDET_EDGE),
+};
+
 static const struct mfd_cell mt6330_devs[] = {
 	{
 		.name = "mt635x-auxadc",
@@ -119,6 +123,11 @@
 	}, {
 		.name = "mt63xx-ot-debug",
 		.of_compatible = "mediatek,mt63xx-ot-debug",
+	}, {
+		.name = "mtk-pmic-chrdet",
+		.num_resources = ARRAY_SIZE(mt6330_chrdet_resources),
+		.resources = mt6330_chrdet_resources,
+		.of_compatible = "mediatek,mt6330-chrdet",
 	},
 };
 
@@ -134,44 +143,42 @@
 	.cid_shift = 0,
 };
 
-static int mt6330_spmi_read(void *context, const void *reg, size_t reg_size,
-			    void *val, size_t val_size)
+static int mt6330_spmi_reg_read(void *context,
+				unsigned int reg, unsigned int *val)
+{
+	struct mt6330_chip *data = context;
+	u8 regval = 0;
+	int ret;
+
+	ret = spmi_ext_register_readl(data->sdev, reg, &regval, 1);
+	if (ret < 0)
+		return ret;
+	*val = regval;
+
+	return 0;
+}
+
+static int mt6330_spmi_reg_write(void *context,
+				 unsigned int reg, unsigned int val)
 {
 	struct mt6330_chip *data = context;
 	int ret;
-	u16 addr = cpu_to_be16(*(u16 *)reg);
 
-	ret = spmi_ext_register_readl(data->sdev, addr, val, val_size);
+	ret = spmi_ext_register_writel(data->sdev, reg, (u8 *)&val, 1);
+	if (ret)
+		return ret;
 
-	return ret;
+	return 0;
 }
 
-static int mt6330_spmi_write(void *context, const void *data, size_t count)
-{
-	struct mt6330_chip *ddata = context;
-	u16 addr = cpu_to_be16(*(u16 *)data);
-	u8 *val = (u8 *)data + 2;
-	int val_size = count - 2;
-	int ret;
-
-	ret = spmi_ext_register_writel(ddata->sdev, addr, (u8 *)val, val_size);
-
-	return ret;
-}
-
-static struct regmap_bus mt6330_regmap_bus = {
-	.read = mt6330_spmi_read,
-	.write = mt6330_spmi_write,
-	.max_raw_read = 2,
-	.max_raw_write = 2,
-};
-
 static const struct regmap_config spmi_regmap_config = {
 	.reg_bits	= 16,
 	.val_bits	= 8,
 	.max_register	= 0x22ff,
 	.fast_io	= true,
-	.use_single_rw  = false,
+	.use_single_rw  = true,
+	.reg_read	= mt6330_spmi_reg_read,
+	.reg_write	= mt6330_spmi_reg_write,
 };
 static int mt6330_probe(struct spmi_device *sdev)
 {
@@ -197,8 +204,7 @@
 	 * mt6330 MFD is child device of soc pmic spmi.
 	 * Regmap is set from its parent.
 	 */
-	regmap = devm_regmap_init(&sdev->dev, &mt6330_regmap_bus,
-				pmic, &spmi_regmap_config);
+	regmap = devm_regmap_init(&sdev->dev, NULL, pmic, &spmi_regmap_config);
 	if (IS_ERR(regmap))
 		return PTR_ERR(regmap);
 	pmic->regmap = regmap;
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/Makefile
index 5d0f05e..27c40f3 100644
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/Makefile
+++ b/src/kernel/linux/v4.19/drivers/misc/mediatek/Makefile
@@ -65,6 +65,7 @@
 obj-$(CONFIG_MTK_LEDS) += leds/
 obj-$(CONFIG_MTK_PCIE) += pcie/
 obj-$(CONFIG_EXTCON_MTK_USB) += extcon/
+obj-$(CONFIG_EXTCON_MTK_USB_MICRO_B) += extcon/
 obj-$(CONFIG_MTK_MHCCIF) += mhccif/
 obj-$(CONFIG_MTK_USB_TYPEC) += typec/
 obj-$(CONFIG_USB) += usb_boost/
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Kconfig
index a4637e5..44e631a 100644
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Kconfig
+++ b/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Kconfig
@@ -1,3 +1,10 @@
+choice
+    help
+      Choose MTK Extcon USB Type here.
+      EXTCON_MTK_USB is for USB TypeC
+      EXTCON_MITK_USB_MICRO_B is for USB MicroB
+    prompt "MTK Extcon USB Type Selection"
+    default EXTCON_MTK_USB
 config EXTCON_MTK_USB
 	tristate "MediaTek EXTCON USB Support"
 	select EXTCON
@@ -5,3 +12,12 @@
 	help
 	  Say Y here to enable extcon support for USB cable detection
 	  on the Mediatek PMIC.
+
+config EXTCON_MTK_USB_MICRO_B
+	help
+	  Say Y here to enable extcon support for Micro TypeB USB cable
+	  detection on the Mediatek PMIC.
+	tristate "MediaTek EXTCON USB Micro TypeB Support"
+	select EXTCON
+	select USB_ROLE_SWITCH
+endchoice
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Makefile
index 165c62d..d3f0f60 100644
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Makefile
+++ b/src/kernel/linux/v4.19/drivers/misc/mediatek/extcon/Makefile
@@ -3,3 +3,4 @@
 ccflags-$(CONFIG_TCPC_CLASS) += -I$(srctree)/drivers/misc/mediatek/typec/tcpc/inc
 
 obj-$(CONFIG_EXTCON_MTK_USB) += extcon-mtk-usb.o
+obj-$(CONFIG_EXTCON_MTK_USB_MICRO_B) += extcon-mtk-usb-microb.o mtk-pmic-chrdet.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/Kconfig
deleted file mode 100644
index 1598dc1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/Kconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-config MTK_SENSOR_DRIVERS
-	string "MTK SENSOR DRIVERS"
-    default "test"
-	help
-	  Sensor config for sensor drivers in project.
-	  Please put sensor drives's folder name in it
-	  If unsure, set test.
-
-source "drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Kconfig"
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/Makefile
deleted file mode 100644
index 763abd5..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-#in case the platform does NOT support this type of sensors
-
-obj-y += core/
-
-ifeq ($(CONFIG_CUSTOM_KERNEL_SENSORHUB),y)
-obj-$(CONFIG_NANOHUB) += mtk_nanohub/
-endif
-
-SENSOR_DRIVER_LIST := $(subst ",,$(CONFIG_MTK_SENSOR_DRIVERS))
-obj-y += $(foreach DRIVER,$(SENSOR_DRIVER_LIST),$(DRIVER)/)
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/Makefile
deleted file mode 100644
index 55a1d29..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensor/2.0/core/
-
-obj-y += bmp280_baro.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/bmp280_baro.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/bmp280_baro.c
deleted file mode 100644
index dd9647f..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/bmp280_baro.c
+++ /dev/null
@@ -1,1012 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/delay.h>
-#include <linux/math64.h>
-
-#include "hf_manager.h"
-#include "bmp280_baro.h"
-#include "sensor_list.h"
-
-#define BMP280_BARO_NAME "bmp280_baro"
-//#define DEBUG_DATA 1
-
-#ifdef DEBUG_DATA
-#define	BMP_DATA_LOG(fmt, args...)  pr_info(fmt, ##args)
-#else
-#define	BMP_DATA_LOG(fmt, args...)
-#endif
-
-static unsigned char support_sensors[] = {
-	SENSOR_TYPE_PRESSURE,
-};
-
-/* data type */
-#define BMP280_U16_t u16
-#define BMP280_S16_t s16
-#define BMP280_U32_t u32
-#define BMP280_S32_t s32
-#define BMP280_U64_t u64
-#define BMP280_S64_t s64
-
-#define C_I2C_FIFO_SIZE               8
-#define CHECK_CHIP_ID_TIME_MAX        5
-
-/* power mode */
-enum BMP_POWERMODE_ENUM {
-	BMP280_SLEEP_MODE = 0x00,
-	BMP280_FORCED_MODE = 0x01,
-	BMP280_NORMAL_MODE = 0x03,
-
-	BMP280_UNDEFINED_POWERMODE = 0xff
-};
-
-/* filter */
-enum BMP_FILTER_ENUM {
-	BMP_FILTER_OFF = 0x0,
-	BMP_FILTER_2,
-	BMP_FILTER_4,
-	BMP_FILTER_8,
-	BMP_FILTER_16,
-
-	BMP_UNDEFINED_FILTER = 0xff
-};
-/* oversampling */
-enum BMP_OVERSAMPLING_ENUM {
-	BMP_OVERSAMPLING_SKIPPED = 0x0,
-	BMP_OVERSAMPLING_1X,
-	BMP_OVERSAMPLING_2X,
-	BMP_OVERSAMPLING_4X,
-	BMP_OVERSAMPLING_8X,
-	BMP_OVERSAMPLING_16X,
-
-	BMP_UNDEFINED_OVERSAMPLING = 0xff
-};
-
-/* bmp280 calibration */
-struct bmp280_calibration_data {
-	BMP280_U16_t dig_T1;
-	BMP280_S16_t dig_T2;
-	BMP280_S16_t dig_T3;
-	BMP280_U16_t dig_P1;
-	BMP280_S16_t dig_P2;
-	BMP280_S16_t dig_P3;
-	BMP280_S16_t dig_P4;
-	BMP280_S16_t dig_P5;
-	BMP280_S16_t dig_P6;
-	BMP280_S16_t dig_P7;
-	BMP280_S16_t dig_P8;
-	BMP280_S16_t dig_P9;
-};
-
-#define C_MAX_FIR_LENGTH (32)
-#define BMP_DATA_NUM 1
-
-/* s/w filter */
-struct data_filter {
-	u32 raw[C_MAX_FIR_LENGTH][BMP_DATA_NUM];
-	int sum[BMP_DATA_NUM];
-	int num;
-	int idx;
-};
-
-struct baro_hw {
-	int i2c_num;
-	int direction;
-	int power_id;
-	int power_vol;
-	int firlen;    /*!< the length of low pass filter */
-	int (*power)(struct baro_hw *hw, unsigned int on, char *devname);
-	//unsigned char i2c_addr[B_CUST_I2C_ADDR_NUM];
-
-	/*!< i2c address list,for chips which has different addresses with
-	 * different HW layout
-	 */
-	bool is_batch_supported;
-};
-
-struct bmp280_baro_device {
-	struct hf_device hf_dev;
-	atomic_t raw_enable;
-	enum BMP_POWERMODE_ENUM power_mode;
-	enum BMP_FILTER_ENUM filter_num;
-	enum BMP_OVERSAMPLING_ENUM  ovsampling_p;
-	enum BMP_OVERSAMPLING_ENUM  ovsampling_t;
-	unsigned long last_temp_measurement;
-	unsigned long temp_measurement_period;
-	struct bmp280_calibration_data bmp280_cali;
-
-	/* calculated temperature correction coefficient */
-	s32 t_fine;
-	atomic_t filter;
-	uint8_t placement[3];
-
-#if defined(CONFIG_BMP_LOWPASS)
-	struct baro_hw hw;
-	atomic_t firlen;
-	atomic_t fir_en;
-	struct data_filter fir;
-#endif
-
-};
-
-/* I2C operation functions */
-static int bmp280_baro_i2c_read_block(struct i2c_client *client,
-				u8 addr, u8 *data, u8 len)
-{
-	int err = 0;
-	u8 beg = addr;
-	struct i2c_msg msgs[2] = {
-		{/*.addr = client->addr,*/
-		 .flags = 0,
-		 .len = 1,
-		 .buf = &beg},
-		{
-			/*.addr = client->addr*/
-			.flags = I2C_M_RD,
-			.len = len,
-			.buf = data,
-		} };
-	if (!client)
-		return -EINVAL;
-	msgs[0].addr = client->addr;
-	msgs[1].addr = client->addr;
-
-	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-	if (err != 2) {
-		pr_err_ratelimited("bmp280 i2c_trans err:%x %x (%d %p %d) %d\n",
-				   msgs[0].addr, client->addr, addr, data, len,
-				   err);
-		err = -EIO;
-	} else {
-		err = 0; /*no error*/
-	}
-	return err;
-}
-
-static int bmp280_baro_i2c_write_block(struct i2c_client *client,
-			u8 addr, u8 *data, u8 len)
-{
-	/* because address also occupies one byte,
-	 * the maximum length for write is 7 bytes
-	 */
-	int err = 0, idx = 0, num = 0;
-	char buf[32];
-
-	if (!client)
-		return -EINVAL;
-	else if (len > C_I2C_FIFO_SIZE) {
-		pr_err_ratelimited("bmp280 len %d fi %d\n", len,
-				   C_I2C_FIFO_SIZE);
-		return -EINVAL;
-	}
-	buf[num++] = addr;
-	for (idx = 0; idx < len; idx++)
-		buf[num++] = data[idx];
-
-	err = i2c_master_send(client, buf, num);
-	if (err < 0) {
-		pr_err_ratelimited("bmp280 send command error!!\n");
-		return -EFAULT;
-	}
-
-	return err;
-}
-
-static int bmp280_baro_soft_reset(struct i2c_client *client)
-{
-	int err = -1;
-	uint8_t data = BMP280_BARO_SOFT_RESET_VALUE;
-
-	err = bmp280_baro_i2c_write_block(client,
-			BMP280_BARO_RESET_ADDR, &data, 1);
-
-	return err;
-}
-
-static int bmp280_baro_check_chip_id(struct i2c_client *client)
-{
-	int err = -1;
-	u8 chip_id = 0;
-	u8 read_count = 0;
-
-	while (read_count++ < CHECK_CHIP_ID_TIME_MAX) {
-		bmp280_baro_i2c_read_block(client,
-				BMP280_BARO_CHIP_ID_ADDR, &chip_id, 1);
-
-		if (chip_id != BMP280_BARO_CHIP_ID_VALUE1 &&
-			chip_id != BMP280_BARO_CHIP_ID_VALUE2 &&
-			chip_id != BMP280_BARO_CHIP_ID_VALUE3) {
-			pr_info("bmp280 get chipId fail(0x%2x).\n", chip_id);
-		} else {
-			err = 0;
-			pr_info("bmp280 get chipId success(0x%2x).\n", chip_id);
-			break;
-		}
-	}
-	return err;
-}
-
-static int bmp280_get_calibration_data(struct i2c_client *client)
-{
-	int status = 0;
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-	u8 a_data_u8r[BMP280_CALIBRATION_DATA_LENGTH] = {0};
-
-	status = bmp280_baro_i2c_read_block(
-			client, BMP280_CALIBRATION_DATA_START, a_data_u8r,
-			BMP280_CALIBRATION_DATA_LENGTH);
-	if (status < 0) {
-		pr_info("bmp280 get cali exit: read data fail!");
-		return status;
-	}
-
-	for (status = 0; status < BMP280_CALIBRATION_DATA_LENGTH; status++)
-		BMP_DATA_LOG("bmp280 cali data: data[%d]:0x%x\n", status,
-			     a_data_u8r[status]);
-
-	driver_dev->bmp280_cali.dig_T1 = (BMP280_U16_t)(
-			(((BMP280_U16_t)((unsigned char)a_data_u8r[1]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[0]);
-	driver_dev->bmp280_cali.dig_T2 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[3]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[2]);
-	driver_dev->bmp280_cali.dig_T3 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[5]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[4]);
-	driver_dev->bmp280_cali.dig_P1 = (BMP280_U16_t)(
-			(((BMP280_U16_t)((unsigned char)a_data_u8r[7]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[6]);
-	driver_dev->bmp280_cali.dig_P2 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[9]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[8]);
-	driver_dev->bmp280_cali.dig_P3 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[11]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[10]);
-	driver_dev->bmp280_cali.dig_P4 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[13]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[12]);
-	driver_dev->bmp280_cali.dig_P5 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[15]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[14]);
-	driver_dev->bmp280_cali.dig_P6 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[17]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[16]);
-	driver_dev->bmp280_cali.dig_P7 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[19]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[18]);
-	driver_dev->bmp280_cali.dig_P8 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[21]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[20]);
-	driver_dev->bmp280_cali.dig_P9 = (BMP280_S16_t)(
-			(((BMP280_S16_t)((signed char)a_data_u8r[23]))
-			 << SHIFT_LEFT_8_POSITION) |
-			a_data_u8r[22]);
-
-	return 0;
-}
-
-
-static int bmp280_baro_set_powermode(struct i2c_client *client,
-				     enum BMP_POWERMODE_ENUM power_mode)
-{
-	int err;
-	u8 data = 0;
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-
-	if (power_mode == BMP280_UNDEFINED_POWERMODE) {
-		pr_info("bmp280 power invalid:%d,(old %d)\n",
-			 power_mode, driver_dev->power_mode);
-		err = -1;
-		return err;
-	}
-
-	if (power_mode == driver_dev->power_mode) {
-		pr_info("bmp280 power no change:%d,(old %d)\n",
-			power_mode, driver_dev->power_mode);
-		return 0;
-	}
-
-	err = bmp280_baro_i2c_read_block(client, BMP280_CTRLMEAS_REG_MODE__REG,
-					 &data, 1);
-	data = BMP_SET_BITSLICE(data, BMP280_CTRLMEAS_REG_MODE,
-				power_mode);
-	err += bmp280_baro_i2c_write_block(client,
-					   BMP280_CTRLMEAS_REG_MODE__REG,
-					   &data, 1);
-
-	if (err < 0)
-		pr_err("bmp280 set power mode failed, err = %d\n", err);
-	else
-		driver_dev->power_mode = power_mode;
-
-	return err;
-}
-
-static int bmp280_baro_set_filter(struct i2c_client *client,
-				  enum BMP_FILTER_ENUM filter)
-{
-	int err;
-	u8 data = 0;
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-
-	if (filter == driver_dev->filter_num ||
-	    filter == BMP_UNDEFINED_FILTER) {
-		pr_info("bmp280 filter no change or invalid:%d,(old %d)\n",
-			filter, driver_dev->filter_num);
-		return 0;
-	}
-
-	err = bmp280_baro_i2c_read_block(client, BMP280_CONFIG_REG_FILTER__REG,
-					 &data, 1);
-	data = BMP_SET_BITSLICE(data, BMP280_CONFIG_REG_FILTER, filter);
-	err += bmp280_baro_i2c_write_block(client,
-					   BMP280_CONFIG_REG_FILTER__REG,
-					   &data, 1);
-
-	if (err < 0)
-		pr_err("bmp280 set filter failed, err = %d\n", err);
-	else
-		driver_dev->filter_num = filter;
-
-	return err;
-}
-
-static int bmp280_baro_set_oversampling_p
-				(struct i2c_client *client,
-				enum BMP_OVERSAMPLING_ENUM oversampling_p)
-{
-	int err;
-	u8 data = 0;
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-
-	if (oversampling_p == driver_dev->ovsampling_p ||
-		oversampling_p == BMP_UNDEFINED_OVERSAMPLING) {
-		pr_info("bmp280 ovsampling_p no change or invlid:%d,(old:%d)\n",
-			oversampling_p, driver_dev->ovsampling_p);
-		return 0;
-	}
-
-	err = bmp280_baro_i2c_read_block(client, BMP280_CTRLMEAS_REG_OSRSP__REG,
-					&data, 1);
-	data = BMP_SET_BITSLICE(data, BMP280_CTRLMEAS_REG_OSRSP,
-				oversampling_p);
-	err += bmp280_baro_i2c_write_block(client,
-					   BMP280_CTRLMEAS_REG_OSRSP__REG,
-					   &data, 1);
-
-	if (err < 0)
-		pr_err("bmp280 set oversampling_p failed, err = %d\n", err);
-	else
-		driver_dev->ovsampling_p = oversampling_p;
-
-	return err;
-}
-
-static int bmp280_baro_set_oversampling_t
-		(struct i2c_client *client,
-		 enum BMP_OVERSAMPLING_ENUM oversampling_t)
-{
-	int err;
-	u8 data = 0;
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-
-	if (oversampling_t == driver_dev->ovsampling_t ||
-		oversampling_t == BMP_UNDEFINED_OVERSAMPLING) {
-		pr_info("bmp280 ovsampling_t no change or invlid:%d,(old:%d)\n",
-			oversampling_t, driver_dev->ovsampling_t);
-		return 0;
-	}
-
-	err = bmp280_baro_i2c_read_block(client, BMP280_CTRLMEAS_REG_OSRST__REG,
-					 &data, 1);
-	data = BMP_SET_BITSLICE(data, BMP280_CTRLMEAS_REG_OSRST,
-				oversampling_t);
-	err += bmp280_baro_i2c_write_block(client,
-					   BMP280_CTRLMEAS_REG_OSRST__REG,
-					   &data, 1);
-
-	if (err < 0)
-		pr_err("bmp280 set oversampling_t failed, err = %d\n", err);
-	else
-		driver_dev->ovsampling_t = oversampling_t;
-
-	return err;
-}
-
-static int bmp280_baro_init_device(struct i2c_client *client)
-{
-	int err = 0;
-
-	err = bmp280_get_calibration_data(client);
-	if (err < 0) {
-		pr_err("get calibration data failed, err = %d\n", err);
-		return err;
-	}
-
-	err = bmp280_baro_set_powermode(client, BMP280_SLEEP_MODE);
-	if (err < 0) {
-		pr_err("bmp280 set power mode failed, err = %d\n", err);
-		return err;
-	}
-
-	err = bmp280_baro_set_filter(client, BMP_FILTER_8);
-	if (err < 0) {
-		pr_err("bmp280 set hw filter failed, err = %d\n", err);
-		return err;
-	}
-
-	err = bmp280_baro_set_oversampling_p(client, BMP_OVERSAMPLING_8X);
-	if (err < 0) {
-		pr_err("bmp280 set oversampling_p failed, err = %d\n", err);
-		return err;
-	}
-
-	err = bmp280_baro_set_oversampling_t(client, BMP_OVERSAMPLING_1X);
-	if (err < 0) {
-		pr_err("bmp280 set oversampling_t failed, err = %d\n", err);
-		return err;
-	}
-
-	pr_info("bmp280 baro init device success.\n");
-
-	return err;
-}
-
-static int bmp_read_raw_temperature(struct i2c_client *client,
-				    s32 *temperature)
-{
-	struct bmp280_baro_device *obj;
-	s32 err = 0;
-	unsigned char a_data_u8r[3] = {0};
-
-	if (client == NULL) {
-		err = -EINVAL;
-		return err;
-	}
-
-	obj = i2c_get_clientdata(client);
-
-	err = bmp280_baro_i2c_read_block(client, BMP280_TEMPERATURE_MSB_REG,
-					a_data_u8r, 3);
-	if (err < 0) {
-		pr_err("bmp280 read raw temperature failed, err = %d\n", err);
-		return err;
-	}
-	*temperature = (BMP280_S32_t)((((BMP280_U32_t)(a_data_u8r[0]))
-				       << SHIFT_LEFT_12_POSITION) |
-				      (((BMP280_U32_t)(a_data_u8r[1]))
-				       << SHIFT_LEFT_4_POSITION) |
-				      ((BMP280_U32_t)a_data_u8r[2] >>
-				       SHIFT_RIGHT_4_POSITION));
-
-	obj->last_temp_measurement = jiffies;
-
-	return err;
-}
-
-static int bmp_read_raw_pressure(struct i2c_client *client, s32 *pressure)
-{
-	struct bmp280_baro_device *priv;
-	s32 err = 0;
-	unsigned char a_data_u8r[3] = {0};
-
-	if (client == NULL) {
-		err = -EINVAL;
-		return err;
-	}
-
-	priv = i2c_get_clientdata(client);
-
-	err = bmp280_baro_i2c_read_block(client, BMP280_PRESSURE_MSB_REG,
-					 a_data_u8r, 3);
-	if (err < 0) {
-		pr_err("bmp280 read raw pressure failed, err = %d\n", err);
-		return err;
-	}
-	*pressure = (BMP280_S32_t)((((BMP280_U32_t)(a_data_u8r[0]))
-				    << SHIFT_LEFT_12_POSITION) |
-				   (((BMP280_U32_t)(a_data_u8r[1]))
-				    << SHIFT_LEFT_4_POSITION) |
-				   ((BMP280_U32_t)a_data_u8r[2] >>
-				    SHIFT_RIGHT_4_POSITION));
-
-#ifdef CONFIG_BMP_LOWPASS
-	/*
-	 *Example: firlen = 16, filter buffer = [0] ... [15],
-	 *when 17th data come, replace [0] with this new data.
-	 *Then, average this filter buffer and report average value to upper
-	 *layer.
-	 */
-	if (atomic_read(&priv->filter)) {
-		if (atomic_read(&priv->fir_en) &&
-		    !atomic_read(&priv->suspend)) {
-			int idx, firlen = atomic_read(&priv->firlen);
-
-			if (priv->fir.num < firlen) {
-				priv->fir.raw[priv->fir.num][BMP_PRESSURE] =
-					*pressure;
-				priv->fir.sum[BMP_PRESSURE] += *pressure;
-				if (atomic_read(&priv->trace) &
-				    BAR_TRC_FILTER) {
-					pr_debug("add [%2d] [%5d] => [%5d]\n",
-						priv->fir.num,
-						priv->fir.raw[priv->fir.num]
-							     [BMP_PRESSURE],
-						priv->fir.sum[BMP_PRESSURE]);
-				}
-				priv->fir.num++;
-				priv->fir.idx++;
-			} else {
-				idx = priv->fir.idx % firlen;
-				priv->fir.sum[BMP_PRESSURE] -=
-					priv->fir.raw[idx][BMP_PRESSURE];
-				priv->fir.raw[idx][BMP_PRESSURE] = *pressure;
-				priv->fir.sum[BMP_PRESSURE] += *pressure;
-				priv->fir.idx++;
-				*pressure =
-					priv->fir.sum[BMP_PRESSURE] / firlen;
-				if (atomic_read(&priv->trace) &
-				    BAR_TRC_FILTER) {
-					pr_debug("add[%2d][%5d]=>[%5d]:[%5d]\n",
-						idx,
-						priv->fir
-							.raw[idx][BMP_PRESSURE],
-						priv->fir.sum[BMP_PRESSURE],
-						*pressure);
-				}
-			}
-		}
-	}
-#endif
-
-	return err;
-}
-
-/*
- *get compensated temperature
- *unit:10 degrees centigrade
- */
-static int bmp_get_temperature(struct i2c_client *client, s32 *t_buf)
-{
-	struct bmp280_baro_device *driver_dev;
-	int status;
-	s32 utemp = 0; /* uncompensated temperature */
-	s32 temperature = 0;
-	BMP280_S32_t v_x1_u32r = 0;
-	BMP280_S32_t v_x2_u32r = 0;
-
-	if (client == NULL || t_buf == NULL) {
-		pr_err("bmp280 get temperature fail, invalid parameter\n");
-		return -1;
-	}
-
-	driver_dev = i2c_get_clientdata(client);
-
-	status = bmp_read_raw_temperature(client, &utemp);
-	if (status != 0) {
-		pr_info("bmp280 read raw temperature fail,status:%d\n", status);
-		return status;
-	}
-	v_x1_u32r = ((((utemp >> 3) -
-		    ((BMP280_S32_t)driver_dev->bmp280_cali.dig_T1 << 1))) *
-		    ((BMP280_S32_t)driver_dev->bmp280_cali.dig_T2)) >> 11;
-	v_x2_u32r = (((((utemp >> 4) -
-		    ((BMP280_S32_t)driver_dev->bmp280_cali.dig_T1)) *
-		    ((utemp >> 4) -
-		    ((BMP280_S32_t)driver_dev->bmp280_cali.dig_T1))) >> 12) *
-		    ((BMP280_S32_t)driver_dev->bmp280_cali.dig_T3)) >> 14;
-
-	driver_dev->t_fine = v_x1_u32r + v_x2_u32r;
-
-	temperature = (driver_dev->t_fine * 5 + 128) >> 8;
-
-	*t_buf = temperature;
-
-	BMP_DATA_LOG("bmp280 temperature: %d\n", temperature);
-	BMP_DATA_LOG("bmp280 temperature/100: %d\n", temperature / 100);
-
-	return status;
-}
-
-/*
- *get compensated pressure
- *unit: hectopascal(hPa)
- */
- #define BMP_BUFSIZE	128
-static int bmp_get_pressure(struct i2c_client *client, s32 *p_buf)
-{
-	struct bmp280_baro_device *driver_dev;
-	int status;
-	s32 temperature = 0, upressure = 0, pressure = 0;
-	BMP280_S64_t v_x1_u32r = 0;
-	BMP280_S64_t v_x2_u32r = 0;
-	BMP280_S64_t p = 0;
-
-	BMP_DATA_LOG("bmp280 get pressure\n");
-
-	if (client == NULL || p_buf == NULL) {
-		pr_err("bmp280 get pressure fail, invalid parameter\n");
-		return -1;
-	}
-
-	driver_dev = i2c_get_clientdata(client);
-	/* update the ambient temperature according to the given meas. period */
-	/* below method will have false problem when jiffies wrap around.
-	 *so replace.
-	 */
-
-	if (time_before_eq((unsigned long)(driver_dev->last_temp_measurement +
-			   driver_dev->temp_measurement_period), jiffies)) {
-
-		status = bmp_get_temperature(client, &temperature);
-		if (status != 0) {
-			pr_info("bmp280 get temperature:%d, exit get prssure\n",
-				status);
-			goto exit;
-		}
-	}
-
-	status = bmp_read_raw_pressure(client, &upressure);
-	if (status != 0) {
-		pr_info("bmp280 get raw pressure status:%d, exit get prssure\n",
-			status);
-		goto exit;
-	}
-
-	v_x1_u32r = ((BMP280_S64_t)driver_dev->t_fine) - 128000;
-	v_x2_u32r = v_x1_u32r * v_x1_u32r *
-			(BMP280_S64_t)driver_dev->bmp280_cali.dig_P6;
-	v_x2_u32r = v_x2_u32r +
-		    ((v_x1_u32r * (BMP280_S64_t)driver_dev->bmp280_cali.dig_P5)
-		     << 17);
-	v_x2_u32r = v_x2_u32r +
-			(((BMP280_S64_t)driver_dev->bmp280_cali.dig_P4) << 35);
-	v_x1_u32r = ((v_x1_u32r * v_x1_u32r *
-		     (BMP280_S64_t)driver_dev->bmp280_cali.dig_P3) >> 8) +
-		    ((v_x1_u32r * (BMP280_S64_t)driver_dev->bmp280_cali.dig_P2)
-		    << 12);
-	v_x1_u32r = (((((BMP280_S64_t)1) << 47) + v_x1_u32r)) *
-		    ((BMP280_S64_t)driver_dev->bmp280_cali.dig_P1) >> 33;
-	if (v_x1_u32r == 0) {
-		/* Avoid exception caused by division by zero */
-		pr_info("bmp280 get_pressure v_x1_32=0, exit get pressure\n");
-		return -1;
-	}
-
-	p = 1048576 - upressure;
-	p = div64_s64(((p << 31) - v_x2_u32r) * 3125, v_x1_u32r);
-	v_x1_u32r = (((BMP280_S64_t)driver_dev->bmp280_cali.dig_P9) *
-			(p >> 13) * (p >> 13)) >> 25;
-	v_x2_u32r = (((BMP280_S64_t)driver_dev->bmp280_cali.dig_P8) * p) >> 19;
-	p = ((p + v_x1_u32r + v_x2_u32r) >> 8) +
-	    (((BMP280_S64_t)driver_dev->bmp280_cali.dig_P7) << 4);
-	pressure = (BMP280_U32_t)p / 256;
-
-	*p_buf = pressure;
-	BMP_DATA_LOG("bmp280 pressure: %d\n", pressure);
-	BMP_DATA_LOG("bmp280 pressure/100: %d\n", pressure / 100);
-
-exit:
-	return status;
-}
-
-int bmp280_baro_sample(struct hf_device *hfdev)
-{
-	struct i2c_client *client;
-	struct bmp280_baro_device *driver_dev;
-	struct hf_manager *manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-	int value = 0, temperature = 0;
-	int err = 0;
-
-	BMP_DATA_LOG("Sample bmp280\n");
-
-	if (!hfdev) {
-		pr_err("bmp280 sample failed:invalid hfdev\n");
-		return -1;
-	}
-	client = hf_device_get_private_data(hfdev);
-	driver_dev = i2c_get_clientdata(client);
-	manager = driver_dev->hf_dev.manager;
-
-	err = bmp_get_pressure(client, &value);
-	if (err) {
-		pr_err("bmp280 get compensated pressure failed, err = %d\n",
-			err);
-		return -1;
-	}
-
-	err = bmp_get_temperature(client, &temperature);
-	if (err != 0) {
-		pr_err("bmp280 get temperature:%d, exit get prssure\n",
-			err);
-		return -1;
-	}
-
-	current_time = ktime_get_boot_ns();
-	if (atomic_read(&driver_dev->raw_enable)) {
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_PRESSURE;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.action = RAW_ACTION;
-		event.word[0] = value;
-		event.word[1] = temperature;
-		manager->report(manager, &event);
-	}
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	event.timestamp = current_time;
-	event.sensor_type = SENSOR_TYPE_PRESSURE;
-	event.accurancy = SENSOR_ACCURANCY_HIGH;
-	event.action = DATA_ACTION;
-	event.word[0] = value;
-	event.word[1] = temperature;
-
-	manager->report(manager, &event);
-	manager->complete(manager);
-
-	return 0;
-}
-
-int bmp280_baro_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	struct i2c_client *client;
-	struct bmp280_baro_device *driver_dev;
-	int ret = 0;
-	int retry = 0;
-	enum BMP_POWERMODE_ENUM power;
-
-	pr_info("%s bmp280\n", en?"En":"Dis");
-	if (!hfdev) {
-		pr_err("bmp280 enable failed:invalid hfdev\n");
-		return -1;
-	}
-	client = hf_device_get_private_data(hfdev);
-	driver_dev = i2c_get_clientdata(client);
-
-	if (en)
-		power = BMP280_NORMAL_MODE;
-	else if (!en)
-		power = BMP280_SLEEP_MODE;
-
-	for (retry = 0; retry < 3; retry++) {
-		ret = bmp280_baro_set_powermode(client, power);
-		if (ret >= 0) {
-			pr_info("bmp280 set pwer mode(%d) done(retry:%d)\n",
-				power, retry);
-			break;
-		}
-	}
-	driver_dev->last_temp_measurement =
-		jiffies - driver_dev->temp_measurement_period;
-
-	if (ret < 0) {
-		pr_err("bmp280 set power mode(%d) fail!\n", power);
-		return -1;
-	}
-
-	pr_info("bmp280 (%s) success\n", power?"enable":"disable");
-	return 0;
-}
-
-static int bmp_set_delay(u64 ns)
-{
-	return 0;
-}
-
-int bmp280_baro_batch(struct hf_device *hfdev,
-		      int sensor_type, int64_t delay, int64_t latency)
-{
-	struct i2c_client *client = hf_device_get_private_data(hfdev);
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	current_time = ktime_get_boot_ns();
-	event.timestamp = current_time;
-	event.sensor_type = SENSOR_TYPE_ADDITIONAL_INFO;
-	event.accurancy = SENSOR_ACCURANCY_HIGH;
-	event.reserved = SENSOR_TYPE_PRESSURE;
-	event.action = DATA_ACTION;
-	event.byte[12] = 1;
-	event.byte[3] = driver_dev->placement[0];
-	event.byte[7] = driver_dev->placement[1];
-	event.byte[11] = driver_dev->placement[2];
-
-	manager->report(manager, &event);
-	manager->complete(manager);
-
-	return bmp_set_delay(delay);
-}
-
-static int bmp280_baro_flush(struct hf_device *hfdev, int sensor_type)
-{
-	struct i2c_client *client = hf_device_get_private_data(hfdev);
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	current_time = ktime_get_boot_ns();
-	event.sensor_type = sensor_type;
-	event.timestamp = current_time;
-	event.action = FLUSH_ACTION;
-
-	manager->report(manager, &event);
-	manager->complete(manager);
-
-	return 0;
-}
-
-int bmp280_baro_raw_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	struct i2c_client *client = hf_device_get_private_data(hfdev);
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-
-	atomic_set(&driver_dev->raw_enable, en);
-	return 0;
-}
-
-static int bmp280_baro_remove(struct i2c_client *client)
-{
-	struct bmp280_baro_device *driver_dev = i2c_get_clientdata(client);
-
-	hf_manager_destroy(driver_dev->hf_dev.manager);
-	kfree(driver_dev);
-	return 0;
-}
-
-static int bmp280_baro_probe(struct i2c_client *client,
-		const struct i2c_device_id *id)
-{
-	int err = 0;
-	struct bmp280_baro_device *driver_dev;
-	struct sensorlist_info_t listinfo;
-
-	pr_info("%s enter Slaver 0x76.\n", __func__);
-
-	err = bmp280_baro_soft_reset(client);
-	if (err < 0) {
-		pr_err("bmp280 soft reset fail,exit probe!\n");
-		err = -EINVAL;
-		goto findHW_fail;
-	}
-
-	/* check chip id */
-	err = bmp280_baro_check_chip_id(client);
-	if (err < 0) {
-		pr_err("bmp280 chip id mismatch,exit probe!\n");
-		err = -EINVAL;
-		goto findHW_fail;
-	}
-	mdelay(1);
-
-	driver_dev = kzalloc(sizeof(*driver_dev), GFP_KERNEL);
-	if (!driver_dev) {
-		err = -ENOMEM;
-		goto malloc_fail;
-	}
-
-	if (of_property_read_u8_array(client->dev.of_node, "placement",
-		driver_dev->placement, ARRAY_SIZE(driver_dev->placement))) {
-		pr_err("%s get placement dts fail\n", __func__);
-		err = -EFAULT;
-		goto init_fail;
-	}
-
-	atomic_set(&driver_dev->raw_enable, 0);
-
-	driver_dev->hf_dev.dev_name = BMP280_BARO_NAME;
-	driver_dev->hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	driver_dev->hf_dev.device_bus = HF_DEVICE_IO_SYNC;
-	driver_dev->hf_dev.support_list = support_sensors;
-	driver_dev->hf_dev.support_size = ARRAY_SIZE(support_sensors);
-	driver_dev->hf_dev.sample = bmp280_baro_sample;
-	driver_dev->hf_dev.enable = bmp280_baro_enable;
-	driver_dev->hf_dev.batch = bmp280_baro_batch;
-	driver_dev->hf_dev.flush = bmp280_baro_flush;
-	driver_dev->hf_dev.rawdata = bmp280_baro_raw_enable;
-
-#ifdef CONFIG_BMP_LOWPASS
-	if (driver_dev->hw.firlen > C_MAX_FIR_LENGTH)
-		atomic_set(&driver_dev->firlen, C_MAX_FIR_LENGTH);
-	else
-		atomic_set(&driver_dev->firlen, driver_dev->hw.firlen);
-
-	if (atomic_read(&driver_dev->firlen) > 0)
-		atomic_set(&driver_dev->fir_en, 1);
-#endif
-
-	err = hf_manager_create(&driver_dev->hf_dev);
-	if (err < 0) {
-		pr_err("bmp280 hf_manager_create fail,exit probe!\n");
-		err = -1;
-		goto create_manager_fail;
-	}
-
-	i2c_set_clientdata(client, driver_dev);
-	hf_device_set_private_data(&driver_dev->hf_dev, client);
-
-	driver_dev->power_mode = BMP280_UNDEFINED_POWERMODE;
-	driver_dev->filter_num = BMP_UNDEFINED_FILTER;
-	driver_dev->ovsampling_p = BMP_UNDEFINED_OVERSAMPLING;
-	driver_dev->ovsampling_t = BMP_UNDEFINED_OVERSAMPLING;
-	driver_dev->last_temp_measurement = 0;
-	driver_dev->temp_measurement_period = 1 * HZ;
-
-	err = bmp280_baro_init_device(client);
-	if (err < 0) {
-		pr_err("bmp280 init device fail,exit probe!\n");
-		goto init_fail;
-	}
-
-	memset(&listinfo, 0, sizeof(struct sensorlist_info_t));
-	strlcpy(listinfo.name, BMP280_BARO_NAME, sizeof(listinfo.name));
-	err = sensorlist_register_devinfo(SENSOR_TYPE_PRESSURE, &listinfo);
-	if (err < 0) {
-		pr_err("bmp280 register sensorlist fail,exit probe!\n");
-		goto init_fail;
-	}
-
-	pr_info("%s success!\n", __func__);
-	return 0;
-
-init_fail:
-	hf_manager_destroy(driver_dev->hf_dev.manager);
-create_manager_fail:
-	kfree(driver_dev);
-malloc_fail:
-findHW_fail:
-	return err;
-}
-
-static const struct of_device_id bmp280_baro_of_match[] = {
-	{.compatible = "mediatek,bmp280_baro"},
-	{},
-};
-
-static const struct i2c_device_id bmp280_baro_id[] = {
-					{BMP280_BARO_NAME, 0}, {} };
-
-static struct i2c_driver bmp280_baro_driver = {
-	.driver = {
-		.name = BMP280_BARO_NAME,
-		.bus = &i2c_bus_type,
-		.owner = THIS_MODULE,
-		.of_match_table = bmp280_baro_of_match,
-	},
-	.probe = bmp280_baro_probe,
-	.remove = bmp280_baro_remove,
-	.id_table =  bmp280_baro_id,
-};
-
-module_i2c_driver(bmp280_baro_driver);
-
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("bmp280 baro i2c driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/bmp280_baro.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/bmp280_baro.h
deleted file mode 100644
index b704280..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp280_baro/bmp280_baro.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef __BMP280_BARO_H__
-#define __BMP280_BARO_H__
-
-/* common definition */
-#define BMP_GET_BITSLICE(regvar, bitname)\
-	((regvar & bitname##__MSK) >> bitname##__POS)
-
-#define BMP_SET_BITSLICE(regvar, bitname, val)\
-	((regvar & ~bitname##__MSK) | ((val<<bitname##__POS)&bitname##__MSK))
-
-
-/*Define of registers*/
-/* Chip ID Register  */
-#define BMP280_BARO_CHIP_ID_ADDR       0xD0
-
-#define BMP280_BARO_CHIP_ID_VALUE1    (0x56)
-#define BMP280_BARO_CHIP_ID_VALUE2    (0x57)
-#define BMP280_BARO_CHIP_ID_VALUE3    (0x58)
-
-/* soft reset  */
-#define BMP280_BARO_RESET_ADDR         0xE0
-#define BMP280_BARO_SOFT_RESET_VALUE   0xB6
-
-/* Calibration data */
-#define BMP280_CALIBRATION_DATA_START   0x88
-#define BMP280_CALIBRATION_DATA_LENGTH	24
-
-#define SHIFT_RIGHT_4_POSITION		4
-#define SHIFT_LEFT_2_POSITION           2
-#define SHIFT_LEFT_4_POSITION           4
-#define SHIFT_LEFT_5_POSITION           5
-#define SHIFT_LEFT_8_POSITION           8
-#define SHIFT_LEFT_12_POSITION          12
-#define SHIFT_LEFT_16_POSITION          16
-
-
-/* Ctrl Measure Register */
-#define BMP280_CTRLMEAS_REG             0xF4
-
-#define BMP280_CTRLMEAS_REG_MODE__POS   0
-#define BMP280_CTRLMEAS_REG_MODE__MSK   0x03
-#define BMP280_CTRLMEAS_REG_MODE__LEN   2
-#define BMP280_CTRLMEAS_REG_MODE__REG   BMP280_CTRLMEAS_REG
-
-#define BMP280_CTRLMEAS_REG_OSRSP__POS   2
-#define BMP280_CTRLMEAS_REG_OSRSP__MSK   0x1C
-#define BMP280_CTRLMEAS_REG_OSRSP__LEN   3
-#define BMP280_CTRLMEAS_REG_OSRSP__REG   BMP280_CTRLMEAS_REG
-
-#define BMP280_CTRLMEAS_REG_OSRST__POS   5
-#define BMP280_CTRLMEAS_REG_OSRST__MSK   0xE0
-#define BMP280_CTRLMEAS_REG_OSRST__LEN   3
-#define BMP280_CTRLMEAS_REG_OSRST__REG   BMP280_CTRLMEAS_REG
-
-//#define BMP280_OVERSAMPLING_SKIPPED          0x00
-//#define BMP280_OVERSAMPLING_1X               0x01
-//#define BMP280_OVERSAMPLING_2X               0x02
-//#define BMP280_OVERSAMPLING_4X               0x03
-//#define BMP280_OVERSAMPLING_8X               0x04
-//#define BMP280_OVERSAMPLING_16X              0x05
-
-/* config */
-#define BMP280_CONFIG_REG                    0xF5
-
-#define BMP280_CONFIG_REG_FILTER__POS              2
-#define BMP280_CONFIG_REG_FILTER__MSK              0x1C
-#define BMP280_CONFIG_REG_FILTER__LEN              3
-#define BMP280_CONFIG_REG_FILTER__REG              BMP280_CONFIG_REG
-
-#define BMP280_FILTERCOEFF_OFF               0x00
-#define BMP280_FILTERCOEFF_2                 0x01
-#define BMP280_FILTERCOEFF_4                 0x02
-#define BMP280_FILTERCOEFF_8                 0x03
-#define BMP280_FILTERCOEFF_16                0x04
-
-/* data */
-#define BMP280_PRESSURE_MSB_REG              0xF7  /* Pressure MSB Reg */
-#define BMP280_TEMPERATURE_MSB_REG           0xFA  /* Temperature MSB Reg */
-
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/Kconfig
deleted file mode 100644
index 43b2afc..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/Kconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-config MTK_BMP380_SUPPORT
-	bool " MTK_BMP380_SUPPORT for MediaTek package"
-	default n
-	help
-	  Enable MTK BMP380 support.
-	  BMP380 is a low-power and low-noise
-	  barometric pressure sensor.
-	  If in doubt, say N here.
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/Makefile
deleted file mode 100644
index 46dd553..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensor/2.0/core
-
-obj-y += bmp380.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/bmp380.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/bmp380.c
deleted file mode 100644
index 740b5c1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/bmp380/bmp380.c
+++ /dev/null
@@ -1,505 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2020 MediaTek Inc.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/delay.h>
-
-#include "hf_manager.h"
-
-#define CHECK_CHIP_ID_TIME_MAX          0x05
-#define C_I2C_FIFO_SIZE                 0x08
-#define PRESSURE_SENSOR_NAME            "bmp380"
-#define BOSCH_BMP380_ID                 0x50
-
-#define BOSCH_BMP380_REG_RESET          0x7e
-#define BOSCH_BMP380_REG_DIG_T1         0x31
-#define BOSCH_BMP380_REG_ID             0x00
-#define BOSCH_BMP380_REG_CTRL_ODR       0x1d  //Control the Output Data Rate
-#define BOSCH_BMP380_REG_CTRL_OSR       0x1c  //Control the OverSampling
-#define BOSCH_BMP380_REG_CTRL_PWR       0x1b
-#define BOSCH_BMP380_REG_CONFIG         0x1f  //iir filter coefficents
-#define BOSCH_BMP380_REG_PRESS_LSB      0x04
-#define BOSCH_BMP380_REG_FIFO_WTM_1     0x16
-#define BOSCH_BMP380_REG_FIFO_WTM_0     0x15
-#define BOSCH_BMP380_REG_FIFO_CONFIG_1  0x17
-#define BOSCH_BMP380_REG_FIFO_CONFIG_2  0x18
-
-struct BMP380CompParams {
-    uint16_t par_t1;
-    uint16_t par_t2;
-    int8_t par_t3;
-
-    int16_t par_p1;
-    int16_t par_p2;
-    int8_t par_p3;
-    int8_t par_p4;
-    u16 par_p5;
-    u16 par_p6;
-    int8_t par_p7;
-    int8_t par_p8;
-    int16_t par_p9;
-    int8_t par_p10;
-    int8_t par_p11;
-    s64 t_lin;
-} __attribute__((packed));
-
-static struct sensor_info bmp380_sensor_info[] = {
-	{
-	.sensor_type = SENSOR_TYPE_PRESSURE,
-	.gain = 100,
-	},
-};
-
-struct bmp380_device {
-	struct hf_device hf_dev;
-	uint32_t i2c_num;
-	uint32_t i2c_addr;
-	struct i2c_client *client;
-	struct BMP380CompParams comp;
-	atomic_t raw_enable;
-};
-
-/* I2C operation functions */
-static int bmp_i2c_read_block(struct i2c_client *client,
-				uint8_t addr, uint8_t *data, uint8_t len)
-{
-	int err = 0;
-	uint8_t beg = addr;
-	struct i2c_msg msgs[2] = {
-		{/*.addr = client->addr,*/
-		 .flags = 0,
-		 .len = 1,
-		 .buf = &beg},
-		{
-			/*.addr = client->addr*/
-			.flags = I2C_M_RD,
-			.len = len,
-			.buf = data,
-		} };
-	if (!client)
-		return -EINVAL;
-	msgs[0].addr = client->addr;
-	msgs[1].addr = client->addr;
-
-	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-	if (err != 2) {
-		pr_err_ratelimited("bmp380 i2c_trans err:%x %x (%d %p %d) %d\n",
-				   msgs[0].addr, client->addr, addr, data, len,
-				   err);
-		err = -EIO;
-	} else {
-		err = 0; /*no error*/
-	}
-	return err;
-}
-
-static int bmp_i2c_write_block(struct i2c_client *client,
-				uint8_t addr, uint8_t *data, uint8_t len)
-{
-	/* because address also occupies one byte,
-	 * the maximum length for write is 7 bytes
-	 */
-	int err = 0, idx = 0, num = 0;
-	char buf[32];
-
-	if (!client)
-		return -EINVAL;
-	else if (len > C_I2C_FIFO_SIZE) {
-		pr_err_ratelimited("bmp380 len %d fi %d\n", len,
-				   C_I2C_FIFO_SIZE);
-		return -EINVAL;
-	}
-	buf[num++] = addr;
-	for (idx = 0; idx < len; idx++)
-		buf[num++] = data[idx];
-
-	err = i2c_master_send(client, buf, num);
-	if (err < 0) {
-		pr_err_ratelimited("bmp380 send command error!!\n");
-		return -EFAULT;
-	}
-
-	return err;
-}
-
-static int bmp380_soft_reset(struct i2c_client *client)
-{
-	uint8_t data = 0xb6;
-	return bmp_i2c_write_block(client, BOSCH_BMP380_REG_RESET, &data, 1);
-}
-
-static int bmp380_check_chip_id(struct i2c_client *client)
-{
-	int err = -1;
-	uint8_t chip_id = 0;
-	uint8_t read_count = 0;
-
-	while (read_count++ < CHECK_CHIP_ID_TIME_MAX) {
-		bmp_i2c_read_block(client, BOSCH_BMP380_REG_ID,
-				   &chip_id, 1);
-
-		if (chip_id != BOSCH_BMP380_ID) {
-			mdelay(1);
-			pr_err("%s fail(0x%2x).\n",
-				__func__, chip_id);
-		} else {
-			err = 0;
-			pr_info("%s success(0x%2x).\n",
-				__func__, chip_id);
-			break;
-		}
-	}
-	return err;
-}
-
-static int bmp380_init_device(struct i2c_client *client)
-{
-	int err = -1;
-	uint8_t tx_buf[2] = {0};
- 	uint8_t rx_buf[8] = {0};
-	struct bmp380_device *driver_dev = i2c_get_clientdata(client);
-
-	err = bmp380_soft_reset(client);
-	if (err < 0) {
-		pr_err("bmp380 soft reset fail,exit probe!\n");
-		goto i2c_fail;
-	}
-
-	mdelay(2);
-
-	tx_buf[0] = BOSCH_BMP380_REG_DIG_T1;
-	err = bmp_i2c_read_block(client, tx_buf[0], rx_buf, 0x08);
-	if (err < 0)
-		goto i2c_fail;
-	memcpy((uint8_t*)&driver_dev->comp, rx_buf, 8);
-
-	tx_buf[0] = BOSCH_BMP380_REG_DIG_T1 + 8;
-	err = bmp_i2c_read_block(client, tx_buf[0], rx_buf, 0x08);
-	if (err < 0)
-		goto i2c_fail;
-	memcpy((uint8_t*)((uint8_t*)&driver_dev->comp + 8), rx_buf, 8);
-
-	tx_buf[0] = BOSCH_BMP380_REG_DIG_T1 + 16;
-	err = bmp_i2c_read_block(client, tx_buf[0], rx_buf, 0x05);
-	if (err < 0)
-		goto i2c_fail;
-	memcpy((uint8_t*)((uint8_t*)&driver_dev->comp + 16), rx_buf, 5);
-
-	tx_buf[0] = ((4 << 3) | (1 << 0));//config oversampling: baro:16x, temp:2x
-	err = bmp_i2c_write_block(client, BOSCH_BMP380_REG_CTRL_OSR,
-				  tx_buf, 0x01);
-
-	tx_buf[0] = 4;//config standy time: 62.5ms
-	err = bmp_i2c_write_block(client, BOSCH_BMP380_REG_CTRL_ODR,
-				  tx_buf, 0x01);
-	if (err < 0)
-		goto i2c_fail;
-
-i2c_fail:
-	pr_err("%s fail\n", __func__);
-	return err;
-}
-
-static int64_t compensate_temp(struct i2c_client *client,
-				     uint32_t uncomp_temp)
-{
-
-	uint64_t partial_data1;
-	uint64_t partial_data2;
-	uint64_t partial_data3;
-	int64_t partial_data4;
-	int64_t partial_data5;
-	int64_t partial_data6;
-	int64_t comp_temp;
-	struct bmp380_device *driver_dev;
-
-	driver_dev = i2c_get_clientdata(client);
-	partial_data1 = uncomp_temp - (256 * driver_dev->comp.par_t1);
-	partial_data2 = driver_dev->comp.par_t2 * partial_data1;
-	partial_data3 = partial_data1 * partial_data1;
-	partial_data4 = (int64_t)partial_data3 * driver_dev->comp.par_t3;
-	partial_data5 = ((int64_t)(partial_data2 * 262144) + partial_data4);
-	partial_data6 = partial_data5 / 4294967296;
-	driver_dev->comp.t_lin = partial_data6;
-	comp_temp = (int64_t)((partial_data6 * 25) / 16384);
-
-	//return the tempeature in the unit of 0.01 centigrade.
-	return comp_temp;
-}
-
-static int64_t compensate_baro(struct i2c_client *client,
-				    uint32_t uncomp_press)
-{
-	int64_t partial_data1;
-	int64_t partial_data2;
-	int64_t partial_data3;
-	int64_t partial_data4;
-	int64_t partial_data5;
-	int64_t partial_data6;
-	int64_t offset;
-	int64_t sensitivity;
-	uint64_t comp_press;
-	struct bmp380_device *driver_dev;
-
-	driver_dev = i2c_get_clientdata(client);
-	partial_data1 = driver_dev->comp.t_lin * driver_dev->comp.t_lin;
-	partial_data2 = partial_data1 / 64;
-	partial_data3 = (partial_data2 * driver_dev->comp.t_lin) / 256;
-	partial_data4 = (driver_dev->comp.par_p8 * partial_data3) / 32;
-	partial_data5 = (driver_dev->comp.par_p7 * partial_data1) * 16;
-	partial_data6 = (driver_dev->comp.par_p6 * driver_dev->comp.t_lin)
-		* 4194304;
-	offset = (driver_dev->comp.par_p5 * 140737488355328) + partial_data4
-		+ partial_data5 + partial_data6;
-
-	partial_data2 = (driver_dev->comp.par_p4 * partial_data3) / 32;
-	partial_data4 = (driver_dev->comp.par_p3 * partial_data1) * 4;
-	partial_data5 = (driver_dev->comp.par_p2 - 16384)
-		* driver_dev->comp.t_lin * 2097152;
-	sensitivity = ((driver_dev->comp.par_p1 - 16384) * 70368744177664)
-		+ partial_data2 + partial_data4	+ partial_data5;
-
-	partial_data1 = (sensitivity / 16777216) * uncomp_press;
-	partial_data2 = driver_dev->comp.par_p10 * driver_dev->comp.t_lin;
-	partial_data3 = partial_data2 + (65536 * driver_dev->comp.par_p9);
-	partial_data4 = (partial_data3 * uncomp_press) / 8192;
-	partial_data5 = (partial_data4 * uncomp_press / 10) / 512 * 10;
-	partial_data6 = (int64_t)((uint64_t)uncomp_press
-		* (uint64_t)uncomp_press);
-	partial_data2 = (driver_dev->comp.par_p11 * partial_data6) / 65536;
-	partial_data3 = (partial_data2 * uncomp_press) / 128;
-	partial_data4 = (offset / 4) + partial_data1 + partial_data5
-		+ partial_data3;
-	comp_press = (((uint64_t)partial_data4 * 25)
-		/ (uint64_t)1099511627776);
-
-	//return the press in the unit of the 0.01 Pa.
-	return comp_press;
-}
-
-static int bmp_get_pressure(struct i2c_client *client, s32 *p_buf)
-{
-	uint32_t press_adc;
-	uint32_t temp_adc;
-	int ret = 0;
-	uint32_t data_xlsb;
-	uint32_t data_lsb;
-	uint32_t data_msb;
-	uint8_t tx_buf[1] = {0};
-	uint8_t rx_buf[6] = {0};
-	int64_t temp = 0, press = 0;
-
-	tx_buf[0] = BOSCH_BMP380_REG_PRESS_LSB;
-	ret = bmp_i2c_read_block(client, tx_buf[0], rx_buf, 6);
-	if (ret < 0) {
-		pr_err("%s failed\n", __func__);
-		return ret;
-	}
-
-	data_xlsb = (uint32_t)rx_buf[0];
-	data_lsb = (uint32_t)rx_buf[1] << 8;
-	data_msb = (uint32_t)rx_buf[2] << 16;
-	press_adc  = data_msb | data_lsb | data_xlsb;
-
-	data_xlsb = (uint32_t)rx_buf[3];
-	data_lsb = (uint32_t)rx_buf[4] << 8;
-	data_msb = (uint32_t)rx_buf[5] << 16;
-	temp_adc = data_msb | data_lsb | data_xlsb;
-
-	temp = compensate_temp(client, temp_adc);
-	press = compensate_baro(client, press_adc);
-	*p_buf = (s32)press * bmp380_sensor_info[0].gain / 10000;
-	return 0;
-}
-
-static int bmp380_sample(struct hf_device *hfdev)
-{
-	struct i2c_client *client;
-	struct bmp380_device *driver_dev;
-	struct hf_manager *manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-	s32 value = 0;
-	int err = 0;
-
-	if (!hfdev) {
-		pr_err("bmp380 sample failed:invalid hfdev\n");
-		return -1;
-	}
-	client = hf_device_get_private_data(hfdev);
-	driver_dev = i2c_get_clientdata(client);
-	manager = driver_dev->hf_dev.manager;
-
-	err = bmp_get_pressure(client, &value);
-	if (err) {
-		pr_err("bmp_get_pressure failed\n");
-		return err;
-	}
-
-	current_time = ktime_get_boot_ns();
-	if (atomic_read(&driver_dev->raw_enable)) {
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_PRESSURE;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.action = RAW_ACTION;
-		event.word[0] = value;
-		manager->report(manager, &event);
-	}
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	event.timestamp = current_time;
-	event.sensor_type = SENSOR_TYPE_PRESSURE;
-	event.accurancy = SENSOR_ACCURANCY_HIGH;
-	event.action = DATA_ACTION;
-	event.word[0] = value;
-
-	manager->report(manager, &event);
-	manager->complete(manager);
-
-	return 0;
-}
-
-static int bmp380_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	uint8_t ret = 0;
-	struct i2c_client *client;
-	struct bmp380_device *driver_dev;
-	uint8_t tx_buf[1] = {0};
-	int retry = 0;
-	client = hf_device_get_private_data(hfdev);
-	driver_dev = i2c_get_clientdata(client);
-
-	if (en)
-		tx_buf[0] = (3 << 4 | 1 << 1 | 1 << 0);
-	else
-		tx_buf[0] = (2 << 5 | 5 << 2);
-
-	for (retry = 0; retry < 3; retry++) {
-		ret = bmp_i2c_write_block(client,
-					  BOSCH_BMP380_REG_CTRL_PWR,
-					  tx_buf, 0x01);
-		if (ret >= 0) {
-			pr_debug("bmp380_enable (%d) done(retry:%d)\n",
-				en, retry);
-			break;
-		}
-	}
-
-	return ret;
-}
-
-static int bmp380_batch(struct hf_device *hfdev, int sensor_type,
-		int64_t delay, int64_t latency)
-{
-	pr_debug("%s id:%d delay:%lld latency:%lld\n", __func__, sensor_type,
-			delay, latency);
-	return 0;
-}
-
-int bmp380_raw_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	struct i2c_client *client = hf_device_get_private_data(hfdev);
-	struct bmp380_device *driver_dev = i2c_get_clientdata(client);
-
-	atomic_set(&driver_dev->raw_enable, en);
-	return 0;
-}
-
-static int bmp380_probe(struct i2c_client *client,
-			const struct i2c_device_id *id)
-{
-	int err = 0;
-	struct bmp380_device *driver_dev = NULL;
-
-	err = bmp380_check_chip_id(client);
-	if (err < 0) {
-		pr_err("bmp380 chip id mismatch,exit probe!\n");
-		goto findHW_fail;
-	}
-
-	driver_dev = kzalloc(sizeof(*driver_dev), GFP_KERNEL);
-	if (!driver_dev) {
-		err = -ENOMEM;
-		goto malloc_fail;
-	}
-
-	driver_dev->hf_dev.dev_name = PRESSURE_SENSOR_NAME;
-	driver_dev->hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	driver_dev->hf_dev.device_bus = HF_DEVICE_IO_SYNC;
-	driver_dev->hf_dev.support_list = bmp380_sensor_info;
-	driver_dev->hf_dev.support_size = ARRAY_SIZE(bmp380_sensor_info);
-	driver_dev->hf_dev.sample = bmp380_sample;
-	driver_dev->hf_dev.enable = bmp380_enable;
-	driver_dev->hf_dev.batch = bmp380_batch;
-	driver_dev->hf_dev.rawdata = bmp380_raw_enable;
-
-	err = hf_manager_create(&driver_dev->hf_dev);
-	if (err < 0) {
-		pr_err("%s hf_manager_create fail\n", __func__);
-		err = -1;
-		goto create_manager_fail;
-	}
-
-	i2c_set_clientdata(client, driver_dev);
-	hf_device_set_private_data(&driver_dev->hf_dev, client);
-	err = bmp380_init_device(client);
-	if (err < 0) {
-		pr_err("%s fail\n", __func__);
-		goto init_fail;
-	}
-
-	pr_info("%s success!\n", __func__);
-	return 0;
-
-init_fail:
-create_manager_fail:
-	kfree(driver_dev);
-malloc_fail:
-findHW_fail:
-	pr_err("%s fail!\n", __func__);
-	return err;
-}
-
-static int bmp380_remove(struct i2c_client *client)
-{
-	struct bmp380_device *driver_dev = i2c_get_clientdata(client);
-
-	hf_manager_destroy(driver_dev->hf_dev.manager);
-	kfree(driver_dev);
-	return 0;
-}
-
-static const struct i2c_device_id bmp380_id[] = {
-	{PRESSURE_SENSOR_NAME, 0},
-	{},
-};
-
-static const struct of_device_id bmp380_of_match[] = {
-	{.compatible = "mediatek,barometer"},
-	{},
-};
-
-static struct i2c_driver bmp380_driver = {
-	.driver = {
-		.name = PRESSURE_SENSOR_NAME,
-		.bus = &i2c_bus_type,
-		.owner = THIS_MODULE,
-		.of_match_table = bmp380_of_match,
-	},
-	.probe = bmp380_probe,
-	.remove = bmp380_remove,
-	.id_table = bmp380_id
-};
-
-module_i2c_driver(bmp380_driver);
-
-MODULE_DESCRIPTION("bmp380 driver");
-MODULE_AUTHOR("Mediatek");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/Makefile
deleted file mode 100644
index 71d25c8..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-obj-y += hf_manager.o
-obj-y += sensor_list.o
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_manager.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_manager.c
deleted file mode 100644
index 9e4e870..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_manager.c
+++ /dev/null
@@ -1,1038 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[hf_manager] " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/device.h>
-#include <linux/fs.h>
-#include <linux/cdev.h>
-#include <linux/slab.h>
-#include <linux/list.h>
-#include <linux/poll.h>
-#include <linux/bitmap.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <uapi/linux/sched/types.h>
-#include <linux/sched_clock.h>
-#include <linux/log2.h>
-
-#include "hf_manager.h"
-
-static DECLARE_BITMAP(sensor_list_bitmap, SENSOR_TYPE_SENSOR_MAX);
-static LIST_HEAD(hf_manager_list);
-static DEFINE_MUTEX(hf_manager_list_mtx);
-static LIST_HEAD(hf_client_list);
-static DEFINE_SPINLOCK(hf_client_list_lock);
-static struct sensor_state prev_request[SENSOR_TYPE_SENSOR_MAX];
-
-static struct task_struct *hf_manager_kthread_task;
-static struct kthread_worker hf_manager_kthread_worker;
-
-static int hf_manager_find_client(struct hf_manager_event *event);
-
-static struct coordinate coordinates[] = {
-	{ { 1, 1, 1}, {0, 1, 2} },
-	{ { -1, 1, 1}, {1, 0, 2} },
-	{ { -1, -1, 1}, {0, 1, 2} },
-	{ { 1, -1, 1}, {1, 0, 2} },
-
-	{ { -1, 1, -1}, {0, 1, 2} },
-	{ { 1, 1, -1}, {1, 0, 2} },
-	{ { 1, -1, -1}, {0, 1, 2} },
-	{ { -1, -1, -1}, {1, 0, 2} },
-};
-
-void coordinate_map(unsigned char direction, int32_t *data)
-{
-	int32_t temp[3] = {0};
-
-	if (direction >= ARRAY_SIZE(coordinates))
-		return;
-
-	temp[coordinates[direction].map[0]] =
-		coordinates[direction].sign[0] * data[0];
-	temp[coordinates[direction].map[1]] =
-		coordinates[direction].sign[1] * data[1];
-	temp[coordinates[direction].map[2]] =
-		coordinates[direction].sign[2] * data[2];
-
-	data[0] = temp[0];
-	data[1] = temp[1];
-	data[2] = temp[2];
-}
-
-void get_placement_info(unsigned char direction, int8_t *data)
-{
-	if (direction >= ARRAY_SIZE(coordinates))
-		return;
-
-	data[coordinates[direction].map[0] * 4 + 0] =
-		coordinates[direction].sign[0];
-	data[coordinates[direction].map[1] * 4 + 1] =
-		coordinates[direction].sign[1];
-	data[coordinates[direction].map[2] * 4 + 2] =
-		coordinates[direction].sign[2];
-}
-
-static bool filter_event_by_timestamp(struct hf_client_fifo *hf_fifo,
-		struct hf_manager_event *event)
-{
-	if (hf_fifo->last_time_stamp[event->sensor_type] ==
-			event->timestamp) {
-		return true;
-	}
-	hf_fifo->last_time_stamp[event->sensor_type] = event->timestamp;
-	return false;
-}
-
-static int hf_manager_report_event(struct hf_client *client,
-		struct hf_manager_event *event)
-{
-	unsigned long flags;
-	unsigned int next = 0;
-	struct hf_client_fifo *hf_fifo = &client->hf_fifo;
-
-	spin_lock_irqsave(&hf_fifo->buffer_lock, flags);
-	if (unlikely(hf_fifo->buffull == true)) {
-		pr_err_ratelimited("%s [%s][%d:%d] buffer full, [%d,%lld]\n",
-			__func__, client->proc_comm, client->leader_pid,
-			client->pid, event->sensor_type, event->timestamp);
-		spin_unlock_irqrestore(&hf_fifo->buffer_lock, flags);
-		wake_up_interruptible(&hf_fifo->wait);
-		/*
-		 * must return -1 when buffer full, tell caller retry
-		 * send data some times later.
-		 */
-		return -1;
-	}
-	/* only data action run filter event */
-	if (likely(event->action == DATA_ACTION) &&
-			unlikely(filter_event_by_timestamp(hf_fifo, event))) {
-		pr_err_ratelimited("%s [%s][%d:%d] filterd, [%d,%lld]\n",
-			__func__, client->proc_comm, client->leader_pid,
-			client->pid, event->sensor_type, event->timestamp);
-		spin_unlock_irqrestore(&hf_fifo->buffer_lock, flags);
-		/*
-		 * must return 0 when timestamp filtered, tell caller data
-		 * already in buffer, don't need send again.
-		 */
-		return 0;
-	}
-	hf_fifo->buffer[hf_fifo->head++] = *event;
-	hf_fifo->head &= hf_fifo->bufsize - 1;
-	/* remain 1 count */
-	next = hf_fifo->head + 1;
-	next &= hf_fifo->bufsize - 1;
-	if (unlikely(next == hf_fifo->tail))
-		hf_fifo->buffull = true;
-	spin_unlock_irqrestore(&hf_fifo->buffer_lock, flags);
-
-	wake_up_interruptible(&hf_fifo->wait);
-	return 0;
-}
-
-static void hf_manager_io_schedule(struct hf_manager *manager)
-{
-	if (!atomic_read(&manager->io_enabled))
-		return;
-	if (READ_ONCE(manager->hf_dev->device_bus) == HF_DEVICE_IO_ASYNC)
-		tasklet_schedule(&manager->io_work_tasklet);
-	else if (READ_ONCE(manager->hf_dev->device_bus) == HF_DEVICE_IO_SYNC)
-		kthread_queue_work(&hf_manager_kthread_worker,
-			&manager->io_kthread_work);
-}
-
-static int hf_manager_io_report(struct hf_manager *manager,
-		struct hf_manager_event *event)
-{
-	/* must return 0 when sensor_type exceed and no need to retry */
-	if (unlikely(event->sensor_type >= SENSOR_TYPE_SENSOR_MAX)) {
-		pr_err_ratelimited("%s %d exceed max sensor id\n", __func__,
-			event->sensor_type);
-		return 0;
-	}
-	return hf_manager_find_client(event);
-}
-
-static void hf_manager_io_complete(struct hf_manager *manager)
-{
-	clear_bit(HF_MANAGER_IO_IN_PROGRESS, &(manager->flags));
-	if (test_and_clear_bit(HF_MANAGER_IO_READY, &manager->flags))
-		hf_manager_io_schedule(manager);
-}
-
-static void hf_manager_io_sample(struct hf_manager *manager)
-{
-	int retval;
-
-	if (!manager->hf_dev || !manager->hf_dev->sample)
-		return;
-
-	if (!test_and_set_bit(HF_MANAGER_IO_IN_PROGRESS, &manager->flags)) {
-		retval = manager->hf_dev->sample(manager->hf_dev);
-		if (retval) {
-			clear_bit(HF_MANAGER_IO_IN_PROGRESS,
-				  &manager->flags);
-			hf_manager_io_schedule(manager);
-		}
-	}
-}
-
-static void hf_manager_io_tasklet(unsigned long data)
-{
-	struct hf_manager *manager = (struct hf_manager *)data;
-
-	hf_manager_io_sample(manager);
-}
-
-static void hf_manager_io_kthread_work(struct kthread_work *work)
-{
-	struct hf_manager *manager =
-		container_of(work, struct hf_manager, io_kthread_work);
-
-	hf_manager_io_sample(manager);
-}
-
-static void hf_manager_sched_sample(struct hf_manager *manager)
-{
-	if (!test_bit(HF_MANAGER_IO_IN_PROGRESS, &manager->flags))
-		hf_manager_io_schedule(manager);
-	else
-		set_bit(HF_MANAGER_IO_READY, &manager->flags);
-}
-
-static enum hrtimer_restart hf_manager_io_poll(struct hrtimer *timer)
-{
-	struct hf_manager *manager =
-		(struct hf_manager *)container_of(timer,
-			struct hf_manager, io_poll_timer);
-
-	hf_manager_sched_sample(manager);
-	hrtimer_forward_now(&manager->io_poll_timer,
-		ns_to_ktime(atomic64_read(&manager->io_poll_interval)));
-	return HRTIMER_RESTART;
-}
-
-static void hf_manager_io_interrupt(struct hf_manager *manager)
-{
-	hf_manager_sched_sample(manager);
-}
-
-int hf_manager_create(struct hf_device *device)
-{
-	unsigned char sensor_type = 0;
-	int i = 0;
-	int err = 0;
-	struct hf_manager *manager = NULL;
-
-	if (!device || !device->dev_name ||
-		!device->support_list || !device->support_size)
-		return -EFAULT;
-
-	manager = kzalloc(sizeof(*manager), GFP_KERNEL);
-	if (!manager)
-		return -ENOMEM;
-
-	manager->hf_dev = device;
-	device->manager = manager;
-
-	atomic_set(&manager->io_enabled, 0);
-	atomic64_set(&manager->io_poll_interval, S64_MAX);
-
-	clear_bit(HF_MANAGER_IO_IN_PROGRESS, &manager->flags);
-	clear_bit(HF_MANAGER_IO_READY, &manager->flags);
-
-	if (device->device_poll == HF_DEVICE_IO_POLLING) {
-		hrtimer_init(&manager->io_poll_timer,
-			CLOCK_MONOTONIC, HRTIMER_MODE_REL);
-		manager->io_poll_timer.function = hf_manager_io_poll;
-	} else if (device->device_poll == HF_DEVICE_IO_INTERRUPT) {
-		manager->interrupt = hf_manager_io_interrupt;
-	}
-	manager->report = hf_manager_io_report;
-	manager->complete = hf_manager_io_complete;
-
-	if (device->device_bus == HF_DEVICE_IO_ASYNC)
-		tasklet_init(&manager->io_work_tasklet,
-			hf_manager_io_tasklet, (unsigned long)manager);
-	else if (device->device_bus == HF_DEVICE_IO_SYNC)
-		kthread_init_work(&manager->io_kthread_work,
-			hf_manager_io_kthread_work);
-
-	for (i = 0; i < device->support_size; ++i) {
-		sensor_type = device->support_list[i];
-		if (unlikely(sensor_type >= SENSOR_TYPE_SENSOR_MAX)) {
-			pr_err("%s %s %d exceed max sensor id\n", __func__,
-				device->dev_name, sensor_type);
-			err = -EINVAL;
-			goto out_err;
-		}
-		if (test_and_set_bit(sensor_type, sensor_list_bitmap)) {
-			pr_err("%s %s %d repeat\n", __func__,
-				device->dev_name, sensor_type);
-			err = -EBUSY;
-			goto out_err;
-		}
-	}
-
-	INIT_LIST_HEAD(&manager->list);
-	mutex_lock(&hf_manager_list_mtx);
-	list_add(&manager->list, &hf_manager_list);
-	mutex_unlock(&hf_manager_list_mtx);
-
-	return 0;
-out_err:
-	kfree(manager);
-	return err;
-}
-
-int hf_manager_destroy(struct hf_manager *manager)
-{
-	int i = 0;
-	struct hf_device *device = NULL;
-
-	if (!manager || !manager->hf_dev || !manager->hf_dev->support_list)
-		return -EFAULT;
-
-	device = manager->hf_dev;
-	for (i = 0; i < device->support_size; ++i) {
-		clear_bit(device->support_list[i],
-			sensor_list_bitmap);
-	}
-	mutex_lock(&hf_manager_list_mtx);
-	list_del(&manager->list);
-	mutex_unlock(&hf_manager_list_mtx);
-	if (manager->hf_dev->device_bus == HF_DEVICE_IO_ASYNC)
-		tasklet_kill(&manager->io_work_tasklet);
-
-	kfree(manager);
-	return 0;
-}
-
-static int hf_manager_distinguish_event(struct hf_client *client,
-		struct hf_manager_event *event)
-{
-	int err = 0;
-	unsigned long flags;
-	struct sensor_state *request = &client->request[event->sensor_type];
-
-	switch (event->action) {
-	case DATA_ACTION:
-		/* must relay on enable status client requested */
-		if (READ_ONCE(request->enable) &&
-				(event->timestamp >
-					atomic64_read(&request->start_time)))
-			err = hf_manager_report_event(client, event);
-		break;
-	case FLUSH_ACTION:
-		/*
-		 * flush relay on flush count client requested,
-		 * must not relay on enable status.
-		 * flush may report both by looper thread and disable thread.
-		 * spinlock prevent flush count report more than request.
-		 * sequence:
-		 * flush = 1
-		 * looper thread flush > 0
-		 *    looper thread hf_manager_report_event
-		 *        disable thread flush > 0
-		 *            disable thread hf_manager_report_event
-		 * flush complete report 2 times but request is 1.
-		 */
-		spin_lock_irqsave(&client->request_lock, flags);
-		if (atomic_read(&request->flush) > 0) {
-			err = hf_manager_report_event(client, event);
-			/* return < 0, don't decrease flush count */
-			if (err < 0) {
-				spin_unlock_irqrestore(&client->request_lock,
-					flags);
-				return err;
-			}
-			atomic_dec_if_positive(&request->flush);
-		}
-		spin_unlock_irqrestore(&client->request_lock, flags);
-		break;
-	case BIAS_ACTION:
-		/* relay on status client requested, don't check return */
-		if (READ_ONCE(request->bias))
-			hf_manager_report_event(client, event);
-		break;
-	case CALI_ACTION:
-		/* cali on status client requested, don't check return */
-		if (READ_ONCE(request->cali))
-			hf_manager_report_event(client, event);
-		break;
-	case TEMP_ACTION:
-		/* temp on status  client requested, don't check return */
-		if (READ_ONCE(request->temp))
-			hf_manager_report_event(client, event);
-		break;
-	case TEST_ACTION:
-		/* test on status client requested, don't check return */
-		if (READ_ONCE(request->test))
-			hf_manager_report_event(client, event);
-		break;
-	case RAW_ACTION:
-		/* raw on status client requested, don't check return */
-		if (READ_ONCE(request->raw))
-			hf_manager_report_event(client, event);
-		break;
-	}
-	return err;
-}
-
-static int hf_manager_find_client(struct hf_manager_event *event)
-{
-	int err = 0;
-	unsigned long flags;
-	struct hf_client *client = NULL;
-
-	spin_lock_irqsave(&hf_client_list_lock, flags);
-	list_for_each_entry(client, &hf_client_list, list) {
-		/* must (err |=), collect all err to decide retry */
-		err |= hf_manager_distinguish_event(client, event);
-	}
-	spin_unlock_irqrestore(&hf_client_list_lock, flags);
-
-	return err;
-}
-
-static struct hf_manager *hf_manager_find_manager(uint8_t sensor_type)
-{
-	int i = 0;
-	struct hf_manager *manager = NULL;
-	struct hf_device *device = NULL;
-
-	list_for_each_entry(manager, &hf_manager_list, list) {
-		device = READ_ONCE(manager->hf_dev);
-		if (!device || !device->support_list)
-			continue;
-		for (i = 0; i < device->support_size; ++i) {
-			if (sensor_type == device->support_list[i])
-				return manager;
-		}
-	}
-	return NULL;
-}
-
-static void hf_manager_update_client_param(
-		struct hf_client *client, struct hf_manager_cmd *cmd)
-{
-	struct sensor_state *request = &client->request[cmd->sensor_type];
-
-	/* only enable disable update action delay and latency */
-	if (cmd->action == HF_MANAGER_SENSOR_ENABLE) {
-		if (!request->enable)
-			atomic64_set(&request->start_time,
-				ktime_get_boot_ns());
-		request->enable = true;
-		request->delay = cmd->delay;
-		request->latency = cmd->latency;
-	} else if (cmd->action == HF_MANAGER_SENSOR_DISABLE) {
-		atomic64_set(&request->start_time, S64_MAX);
-		request->enable = false;
-		request->delay = S64_MAX;
-		request->latency = S64_MAX;
-	}
-}
-
-static void hf_manager_find_best_param(uint8_t sensor_type,
-		bool *action, int64_t *delay, int64_t *latency)
-{
-	unsigned long flags;
-	struct hf_client *client = NULL;
-	struct sensor_state *request = NULL;
-	bool tmp_enable = false;
-	int64_t tmp_delay = S64_MAX;
-	int64_t tmp_latency = S64_MAX;
-
-	spin_lock_irqsave(&hf_client_list_lock, flags);
-	list_for_each_entry(client, &hf_client_list, list) {
-		request = &client->request[sensor_type];
-		if (request->enable) {
-			tmp_enable = true;
-			if (request->delay < tmp_delay)
-				tmp_delay = request->delay;
-			if (request->latency < tmp_latency)
-				tmp_latency = request->latency;
-		}
-	}
-	spin_unlock_irqrestore(&hf_client_list_lock, flags);
-	*action = tmp_enable;
-	*delay = tmp_delay;
-	*latency = tmp_latency;
-
-#ifdef HF_MANAGER_DEBUG
-	if (tmp_enable)
-		pr_notice("%s: %d,%d,%lld,%lld\n", __func__,
-			sensor_type, tmp_enable, tmp_delay, tmp_latency);
-	else
-		pr_notice("%s: %d,%d\n", __func__, sensor_type, tmp_enable);
-#endif
-}
-
-static bool device_rebatch(uint8_t sensor_type,
-			int64_t best_delay, int64_t best_latency)
-{
-	if (prev_request[sensor_type].delay != best_delay ||
-			prev_request[sensor_type].latency != best_latency) {
-		prev_request[sensor_type].delay = best_delay;
-		prev_request[sensor_type].latency = best_latency;
-		return true;
-	}
-	return false;
-}
-
-static bool device_reenable(uint8_t sensor_type, bool best_enable)
-{
-	if (prev_request[sensor_type].enable != best_enable) {
-		prev_request[sensor_type].enable = best_enable;
-		return true;
-	}
-	return false;
-}
-
-static bool device_redisable(uint8_t sensor_type, bool best_enable,
-			int64_t best_delay, int64_t best_latency)
-{
-	if (prev_request[sensor_type].enable != best_enable) {
-		prev_request[sensor_type].enable = best_enable;
-		prev_request[sensor_type].delay = best_delay;
-		prev_request[sensor_type].latency = best_latency;
-		return true;
-	}
-	return false;
-}
-
-static int64_t device_poll_min_interval(struct hf_device *device)
-{
-	int i = 0, j = 0;
-	int64_t interval = S64_MAX;
-
-	for (i = 0; i < device->support_size; ++i) {
-		j = device->support_list[i];
-		if (prev_request[j].enable) {
-			if (prev_request[j].delay < interval)
-				interval = prev_request[j].delay;
-		}
-	}
-	return interval;
-}
-
-static void device_poll_trigger(struct hf_device *device, bool enable)
-{
-	int64_t min_interval = S64_MAX;
-	struct hf_manager *manager = device->manager;
-
-	BUG_ON(enable && !atomic_read(&manager->io_enabled));
-	min_interval = device_poll_min_interval(device);
-	BUG_ON(atomic_read(&manager->io_enabled) && min_interval == S64_MAX);
-	if (atomic64_read(&manager->io_poll_interval) == min_interval)
-		return;
-	atomic64_set(&manager->io_poll_interval, min_interval);
-	if (atomic_read(&manager->io_enabled))
-		hrtimer_start(&manager->io_poll_timer,
-			ns_to_ktime(min_interval), HRTIMER_MODE_REL);
-	else
-		hrtimer_cancel(&manager->io_poll_timer);
-}
-
-static int hf_manager_device_enable(struct hf_device *device,
-				uint8_t sensor_type)
-{
-	int err = 0;
-	struct hf_manager *manager = device->manager;
-	bool best_enable = false;
-	int64_t best_delay = S64_MAX;
-	int64_t best_latency = S64_MAX;
-
-	if (!device->enable || !device->batch)
-		return -EINVAL;
-
-	hf_manager_find_best_param(sensor_type, &best_enable,
-		&best_delay, &best_latency);
-
-	if (best_enable) {
-		if (device_rebatch(sensor_type, best_delay, best_latency))
-			err = device->batch(device, sensor_type,
-				best_delay, best_latency);
-		if (device_reenable(sensor_type, best_enable)) {
-			err = device->enable(device, sensor_type, best_enable);
-			/* must update io_enabled before hrtimer_start */
-			atomic_inc(&manager->io_enabled);
-		}
-		if (device->device_poll == HF_DEVICE_IO_POLLING)
-			device_poll_trigger(device, best_enable);
-	} else {
-		if (device_redisable(sensor_type, best_enable,
-				best_delay, best_latency)) {
-			err = device->enable(device, sensor_type, best_enable);
-			atomic_dec_if_positive(&manager->io_enabled);
-		}
-		if (device->device_poll == HF_DEVICE_IO_POLLING)
-			device_poll_trigger(device, best_enable);
-		if (device->device_bus == HF_DEVICE_IO_ASYNC &&
-				!atomic_read(&manager->io_enabled))
-			tasklet_kill(&manager->io_work_tasklet);
-	}
-	return err;
-}
-
-static int hf_manager_device_flush(struct hf_device *device,
-		uint8_t sensor_type)
-{
-	if (!device->flush)
-		return -EINVAL;
-
-	return device->flush(device, sensor_type);
-}
-
-static int hf_manager_device_calibration(struct hf_device *device,
-		uint8_t sensor_type)
-{
-	if (device->calibration)
-		return device->calibration(device, sensor_type);
-	return 0;
-}
-
-static int hf_manager_device_config_cali(struct hf_device *device,
-		uint8_t sensor_type, int32_t *data)
-{
-	if (device->config_cali)
-		return device->config_cali(device, sensor_type, data);
-	return 0;
-}
-
-static int hf_manager_device_selftest(struct hf_device *device,
-		uint8_t sensor_type)
-{
-	if (device->selftest)
-		return device->selftest(device, sensor_type);
-	return 0;
-}
-
-static int hf_manager_device_rawdata(struct hf_device *device,
-		uint8_t sensor_type)
-{
-	unsigned long flags;
-	struct hf_client *client = NULL;
-	struct sensor_state *request = NULL;
-	bool best_enable = false;
-
-	spin_lock_irqsave(&hf_client_list_lock, flags);
-	list_for_each_entry(client, &hf_client_list, list) {
-		request = &client->request[sensor_type];
-		if (request->raw)
-			best_enable = true;
-	}
-	spin_unlock_irqrestore(&hf_client_list_lock, flags);
-
-	if (prev_request[sensor_type].raw == best_enable)
-		return 0;
-	prev_request[sensor_type].raw = best_enable;
-	if (device->rawdata)
-		return device->rawdata(device, sensor_type, best_enable);
-	return 0;
-}
-
-static int hf_manager_drive_device(struct hf_client *client,
-		struct hf_manager_cmd *cmd)
-{
-	int err = 0;
-	struct hf_manager *manager = NULL;
-	struct hf_device *device = NULL;
-	uint8_t sensor_type = cmd->sensor_type;
-
-	if (unlikely(sensor_type >= SENSOR_TYPE_SENSOR_MAX))
-		return -EINVAL;
-
-	mutex_lock(&hf_manager_list_mtx);
-	manager = hf_manager_find_manager(sensor_type);
-	if (!manager) {
-		pr_err("%s: no manager finded\n", __func__);
-		mutex_unlock(&hf_manager_list_mtx);
-		return -EINVAL;
-	}
-	device = manager->hf_dev;
-	if (!device || !device->dev_name) {
-		pr_err("%s: no hf device or important param finded\n",
-			__func__);
-		mutex_unlock(&hf_manager_list_mtx);
-		return -EINVAL;
-	}
-
-#ifdef HF_MANAGER_DEBUG
-	pr_notice("%s: %s: %d,%d,%lld,%lld\n", __func__, device->dev_name,
-		cmd->sensor_type, cmd->action, cmd->delay, cmd->latency);
-#endif
-
-	switch (cmd->action) {
-	case HF_MANAGER_SENSOR_ENABLE:
-	case HF_MANAGER_SENSOR_DISABLE:
-		hf_manager_update_client_param(client, cmd);
-		err = hf_manager_device_enable(device, sensor_type);
-		break;
-	case HF_MANAGER_SENSOR_FLUSH:
-		atomic_inc(&client->request[sensor_type].flush);
-		err = hf_manager_device_flush(device, sensor_type);
-		if (err < 0)
-			atomic_dec_if_positive(
-				&client->request[sensor_type].flush);
-		break;
-	case HF_MANAGER_SENSOR_ENABLE_CALI:
-		err = hf_manager_device_calibration(device, sensor_type);
-		break;
-	case HF_MANAGER_SENSOR_CONFIG_CALI:
-		err = hf_manager_device_config_cali(device,
-			sensor_type, cmd->data);
-		break;
-	case HF_MANAGER_SENSOR_SELFTEST:
-		err = hf_manager_device_selftest(device, sensor_type);
-		break;
-	case HF_MANAGER_SENSOR_RAWDATA:
-		client->request[sensor_type].raw =
-			cmd->data[0] ? true : false;
-		err = hf_manager_device_rawdata(device, sensor_type);
-		break;
-	}
-	mutex_unlock(&hf_manager_list_mtx);
-	return err;
-}
-
-static int hf_manager_open(struct inode *inode, struct file *filp)
-{
-	int err = 0;
-	unsigned long flags;
-	struct hf_client *client = NULL;
-	struct hf_client_fifo *hf_fifo = NULL;
-
-	client = kzalloc(sizeof(*client), GFP_KERNEL);
-	if (!client) {
-		err = -ENOMEM;
-		goto err_out;
-	}
-
-	/* record process id and thread id for debug */
-	strlcpy(client->proc_comm, current->comm, sizeof(client->proc_comm));
-	client->leader_pid = current->group_leader->pid;
-	client->pid = current->pid;
-
-	pr_notice("%s: [%s][%d:%d]\n", __func__, current->comm,
-		current->group_leader->pid, current->pid);
-
-	INIT_LIST_HEAD(&client->list);
-
-	hf_fifo = &client->hf_fifo;
-	hf_fifo->head = 0;
-	hf_fifo->tail = 0;
-	hf_fifo->bufsize = roundup_pow_of_two(HF_CLIENT_FIFO_SIZE);
-	hf_fifo->buffull = false;
-	spin_lock_init(&hf_fifo->buffer_lock);
-	init_waitqueue_head(&hf_fifo->wait);
-	hf_fifo->buffer =
-		kcalloc(hf_fifo->bufsize, sizeof(*hf_fifo->buffer),
-			GFP_KERNEL);
-	if (!hf_fifo->buffer) {
-		err = -ENOMEM;
-		goto err_free;
-	}
-
-	spin_lock_init(&client->request_lock);
-
-	filp->private_data = client;
-
-	spin_lock_irqsave(&hf_client_list_lock, flags);
-	list_add(&client->list, &hf_client_list);
-	spin_unlock_irqrestore(&hf_client_list_lock, flags);
-
-	nonseekable_open(inode, filp);
-	return 0;
-err_free:
-	kfree(client);
-err_out:
-	return err;
-}
-
-static int hf_manager_release(struct inode *inode, struct file *filp)
-{
-	unsigned long flags;
-	struct hf_client *client = filp->private_data;
-
-	pr_notice("%s: [%s][%d:%d]\n", __func__, current->comm,
-		current->group_leader->pid, current->pid);
-
-	filp->private_data = NULL;
-
-	spin_lock_irqsave(&hf_client_list_lock, flags);
-	list_del(&client->list);
-	spin_unlock_irqrestore(&hf_client_list_lock, flags);
-
-	kfree(client->hf_fifo.buffer);
-	kfree(client);
-	return 0;
-}
-
-static int hf_manager_fetch_next(struct hf_client_fifo *hf_fifo,
-				  struct hf_manager_event *event)
-{
-	unsigned long flags;
-	int have_event;
-
-	spin_lock_irqsave(&hf_fifo->buffer_lock, flags);
-	have_event = hf_fifo->head != hf_fifo->tail;
-	if (have_event) {
-		*event = hf_fifo->buffer[hf_fifo->tail++];
-		hf_fifo->tail &= hf_fifo->bufsize - 1;
-		hf_fifo->buffull = false;
-	}
-	spin_unlock_irqrestore(&hf_fifo->buffer_lock, flags);
-	return have_event;
-}
-
-static ssize_t hf_manager_read(struct file *filp,
-		char __user *buf, size_t count, loff_t *f_pos)
-{
-	struct hf_client *client = filp->private_data;
-	struct hf_client_fifo *hf_fifo = &client->hf_fifo;
-	struct hf_manager_event event;
-	size_t read = 0;
-
-	if (count != 0 && count < sizeof(struct hf_manager_event))
-		return -EINVAL;
-
-	for (;;) {
-		if (hf_fifo->head == hf_fifo->tail)
-			return 0;
-		if (count == 0)
-			break;
-		while (read + sizeof(struct hf_manager_event) <= count &&
-			hf_manager_fetch_next(hf_fifo, &event)) {
-			if (copy_to_user(buf + read,
-				&event, sizeof(struct hf_manager_event)))
-				return -EFAULT;
-			read += sizeof(struct hf_manager_event);
-		}
-		if (read)
-			break;
-	}
-	return read;
-}
-
-static ssize_t hf_manager_write(struct file *filp,
-		const char __user *buf, size_t count, loff_t *f_pos)
-{
-	struct hf_manager_cmd cmd;
-	struct hf_client *client = filp->private_data;
-
-	memset(&cmd, 0, sizeof(struct hf_manager_cmd));
-
-	if (count != sizeof(struct hf_manager_cmd))
-		return -EFAULT;
-
-	if (copy_from_user(&cmd, buf, count))
-		return -EFAULT;
-
-	return hf_manager_drive_device(client, &cmd);
-}
-
-static unsigned int hf_manager_poll(struct file *filp,
-		struct poll_table_struct *wait)
-{
-	struct hf_client *client = filp->private_data;
-	struct hf_client_fifo *hf_fifo = &client->hf_fifo;
-	unsigned int mask = 0;
-
-	poll_wait(filp, &hf_fifo->wait, wait);
-
-	if (hf_fifo->head != hf_fifo->tail)
-		mask |= POLLIN | POLLRDNORM;
-
-	return mask;
-}
-
-static long hf_manager_ioctl(struct file *filp,
-			unsigned int cmd, unsigned long arg)
-{
-	struct hf_client *client = filp->private_data;
-	unsigned int size = _IOC_SIZE(cmd);
-	void __user *ubuf = (void __user *)arg;
-	unsigned int sensor_type = 0;
-	struct ioctl_packet packet;
-
-	memset(&packet, 0, sizeof(struct ioctl_packet));
-
-	if (size != sizeof(struct ioctl_packet))
-		return -EINVAL;
-	if (copy_from_user(&packet, ubuf, sizeof(struct ioctl_packet)))
-		return -EFAULT;
-	sensor_type = packet.sensor_type;
-	if (unlikely(sensor_type >= SENSOR_TYPE_SENSOR_MAX))
-		return -EINVAL;
-
-	switch (cmd) {
-	case HF_MANAGER_REQUEST_REGISTER_STATUS:
-		packet.status = test_bit(sensor_type, sensor_list_bitmap);
-		if (copy_to_user(ubuf, &packet, sizeof(struct ioctl_packet)))
-			return -EFAULT;
-		break;
-	case HF_MANAGER_REQUEST_BIAS_DATA:
-		client->request[sensor_type].bias = packet.status;
-		break;
-	case HF_MANAGER_REQUEST_CALI_DATA:
-		client->request[sensor_type].cali = packet.status;
-		break;
-	case HF_MANAGER_REQUEST_TEMP_DATA:
-		client->request[sensor_type].temp = packet.status;
-		break;
-	case HF_MANAGER_REQUEST_TEST_DATA:
-		client->request[sensor_type].test = packet.status;
-		break;
-	}
-	return 0;
-}
-
-static ssize_t client_info_show(struct device *dev,
-		struct device_attribute *attr, char *buf)
-{
-	return 0;
-}
-
-DEVICE_ATTR(client_info, 0644, client_info_show, NULL);
-
-static struct attribute *hf_manager_attrs[] = {
-	&dev_attr_client_info.attr,
-	NULL
-};
-
-static struct attribute_group hf_manager_group = {
-	.attrs = hf_manager_attrs
-};
-
-static const struct file_operations hf_manager_fops = {
-	.owner          = THIS_MODULE,
-	.open           = hf_manager_open,
-	.release        = hf_manager_release,
-	.read           = hf_manager_read,
-	.write          = hf_manager_write,
-	.poll           = hf_manager_poll,
-	.unlocked_ioctl = hf_manager_ioctl,
-	.compat_ioctl   = hf_manager_ioctl,
-};
-
-static int hf_manager_proc_show(struct seq_file *m, void *v)
-{
-	int i = 0, sensor_type = 0;
-	unsigned long flags;
-	struct hf_manager *manager = NULL;
-	struct hf_client *client = NULL;
-	struct hf_device *device = NULL;
-
-	mutex_lock(&hf_manager_list_mtx);
-	list_for_each_entry(manager, &hf_manager_list, list) {
-		device = READ_ONCE(manager->hf_dev);
-		if (!device || !device->support_list)
-			continue;
-		seq_printf(m, "manager: param:[%d,%lld]\n",
-			atomic_read(&manager->io_enabled),
-			(int64_t)atomic64_read(&manager->io_poll_interval));
-		seq_printf(m, "device:%s poll:%s bus:%s online\n",
-			device->dev_name,
-			device->device_poll ? "io_polling" : "io_interrupt",
-			device->device_bus ? "io_async" : "io_sync");
-		for (i = 0; i < device->support_size; ++i) {
-			sensor_type = device->support_list[i];
-			seq_printf(m, "support:%d now param:[%d,%lld,%lld]\n",
-				sensor_type,
-				prev_request[sensor_type].enable,
-				prev_request[sensor_type].delay,
-				prev_request[sensor_type].latency);
-		}
-	}
-	mutex_unlock(&hf_manager_list_mtx);
-
-	spin_lock_irqsave(&hf_client_list_lock, flags);
-	list_for_each_entry(client, &hf_client_list, list) {
-		seq_printf(m, "client:%s pid:[%d:%d] online\n",
-			client->proc_comm,
-			client->leader_pid,
-			client->pid);
-		for (i = 0; i < SENSOR_TYPE_SENSOR_MAX; ++i) {
-			if (!client->request[i].enable)
-				continue;
-			seq_printf(m, "request:%d param:[%d,%lld,%lld,%lld]\n",
-				i,
-				client->request[i].enable,
-				client->request[i].delay,
-				client->request[i].latency,
-				(int64_t)atomic64_read(
-					&client->request[i].start_time));
-		}
-	}
-	spin_unlock_irqrestore(&hf_client_list_lock, flags);
-	return 0;
-}
-
-static int hf_manager_proc_open(struct inode *inode,
-		struct file *filp)
-{
-	return single_open(filp, hf_manager_proc_show, NULL);
-}
-
-static const struct file_operations hf_manager_proc_fops = {
-	.open           = hf_manager_proc_open,
-	.release        = single_release,
-	.read           = seq_read,
-	.llseek         = seq_lseek,
-};
-
-
-static int __init hf_manager_init(void)
-{
-	int major = -1, i = 0;
-	struct class *hf_manager_class;
-	struct device *dev;
-	struct sched_param param = { .sched_priority = MAX_RT_PRIO / 2 };
-
-	for (i = 0; i < SENSOR_TYPE_SENSOR_MAX; ++i) {
-		prev_request[i].delay = S64_MAX;
-		prev_request[i].latency = S64_MAX;
-		atomic64_set(&prev_request[i].start_time, S64_MAX);
-	}
-
-	major = register_chrdev(0, "hf_manager", &hf_manager_fops);
-	if (major < 0) {
-		pr_err("%s unable to get major %d\n", __func__, major);
-		return -1;
-	}
-	hf_manager_class = class_create(THIS_MODULE, "hf_manager");
-	if (IS_ERR(hf_manager_class))
-		return PTR_ERR(hf_manager_class);
-	dev = device_create(hf_manager_class, NULL, MKDEV(major, 0),
-		NULL, "hf_manager");
-	if (IS_ERR(dev))
-		return -1;
-
-	proc_create("hf_manager", 0644, NULL, &hf_manager_proc_fops);
-
-	if (sysfs_create_group(&dev->kobj, &hf_manager_group) < 0)
-		return -1;
-
-	kthread_init_worker(&hf_manager_kthread_worker);
-	hf_manager_kthread_task = kthread_run(kthread_worker_fn,
-			&hf_manager_kthread_worker, "hf_manager");
-	if (IS_ERR(hf_manager_kthread_task)) {
-		pr_err("%s failed to create kthread\n", __func__);
-		return -1;
-	}
-	sched_setscheduler(hf_manager_kthread_task, SCHED_FIFO, &param);
-	return 0;
-}
-subsys_initcall(hf_manager_init);
-
-
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("high freq sensor manaer driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_manager.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_manager.h
deleted file mode 100644
index f92317b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_manager.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef _HF_SENSOR_MANAGER_H_
-#define _HF_SENSOR_MANAGER_H_
-
-#include <linux/hrtimer.h>
-#include <linux/interrupt.h>
-#include <linux/kthread.h>
-#include <linux/ioctl.h>
-#include <linux/types.h>
-
-#include "hf_sensor_type.h"
-#include "hf_sensor_io.h"
-
-#define HF_MANAGER_IO_IN_PROGRESS 0
-#define HF_MANAGER_IO_READY       1
-
-#define HF_DEVICE_IO_SYNC  0
-#define HF_DEVICE_IO_ASYNC 1
-
-#define HF_DEVICE_IO_INTERRUPT 0
-#define HF_DEVICE_IO_POLLING   1
-
-#define HF_CLIENT_FIFO_SIZE 128
-
-struct coordinate {
-	int8_t sign[3];
-	uint8_t map[3];
-};
-
-struct sensor_state {
-	bool enable;
-	bool bias;
-	bool cali;
-	bool temp;
-	bool test;
-	bool raw;
-	int64_t delay;
-	int64_t latency;
-	atomic_t flush;
-	atomic64_t start_time;
-};
-
-struct hf_device {
-	int (*sample)(struct hf_device *hfdev);
-	int (*enable)(struct hf_device *hfdev, int sensor_type, int en);
-	int (*batch)(struct hf_device *hfdev, int sensor_type,
-		int64_t delay, int64_t latency);
-	int (*flush)(struct hf_device *hfdev, int sensor_type);
-	int (*calibration)(struct hf_device *hfdev, int sensor_type);
-	int (*config_cali)(struct hf_device *hfdev,
-		int sensor_type, int32_t *data);
-	int (*selftest)(struct hf_device *hfdev, int sensor_type);
-	int (*rawdata)(struct hf_device *hfdev, int sensor_type, int en);
-
-	char *dev_name;
-	unsigned char device_poll;
-	unsigned char device_bus;
-
-	unsigned char *support_list;
-	unsigned int support_size;
-
-	struct hf_manager *manager;
-	void *private_data;
-};
-
-struct hf_client_fifo {
-	spinlock_t buffer_lock;
-	unsigned int head;
-	unsigned int tail;
-	unsigned int bufsize;
-	unsigned int buffull;
-	int64_t last_time_stamp[SENSOR_TYPE_SENSOR_MAX];
-	struct hf_manager_event *buffer;
-	wait_queue_head_t wait;
-};
-
-struct hf_manager {
-	struct list_head list;
-	struct tasklet_struct io_work_tasklet;
-	struct kthread_work io_kthread_work;
-	struct hrtimer io_poll_timer;
-	atomic64_t io_poll_interval;
-	atomic_t io_enabled;
-	unsigned long flags;
-	struct hf_device *hf_dev;
-
-	int (*report)(struct hf_manager *manager,
-		struct hf_manager_event *event);
-	void (*complete)(struct hf_manager *manager);
-	void (*interrupt)(struct hf_manager *manager);
-};
-
-struct hf_client {
-	struct list_head list;
-	struct hf_client_fifo hf_fifo;
-	struct sensor_state request[SENSOR_TYPE_SENSOR_MAX];
-	spinlock_t request_lock;
-
-	/* record process info */
-	char proc_comm[TASK_COMM_LEN];
-	pid_t leader_pid;
-	pid_t pid;
-};
-
-static inline void hf_device_set_private_data(struct hf_device *device,
-		void *data)
-{
-	device->private_data = data;
-}
-
-static inline void *hf_device_get_private_data(struct hf_device *device)
-{
-	return device->private_data;
-}
-
-int hf_manager_create(struct hf_device *device);
-int hf_manager_destroy(struct hf_manager *manager);
-void coordinate_map(unsigned char direction, int32_t *data);
-void get_placement_info(unsigned char direction, int8_t *data);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_sensor_io.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_sensor_io.h
deleted file mode 100644
index c26fd75..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_sensor_io.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef _HF_SENSOR_IO_H_
-#define _HF_SENSOR_IO_H_
-
-#include <linux/ioctl.h>
-#include <linux/types.h>
-
-enum {
-	HF_MANAGER_SENSOR_DISABLE,
-	HF_MANAGER_SENSOR_ENABLE,
-	HF_MANAGER_SENSOR_FLUSH,
-	HF_MANAGER_SENSOR_ENABLE_CALI,
-	HF_MANAGER_SENSOR_CONFIG_CALI,
-	HF_MANAGER_SENSOR_SELFTEST,
-	HF_MANAGER_SENSOR_RAWDATA,
-};
-
-enum {
-	DATA_ACTION,
-	FLUSH_ACTION,
-	BIAS_ACTION,
-	CALI_ACTION,
-	TEMP_ACTION,
-	TEST_ACTION,
-	RAW_ACTION,
-};
-
-struct hf_manager_cmd {
-	uint8_t sensor_type;
-	uint8_t action;
-	int64_t delay;
-	int64_t latency;
-	int32_t data[12];
-} __packed;
-
-struct hf_manager_event {
-	int64_t timestamp;
-	uint8_t sensor_type;
-	uint8_t accurancy;
-	uint8_t action;
-	uint8_t reserved;
-	union {
-		int32_t word[6];
-		int8_t byte[0];
-	};
-} __packed;
-
-struct ioctl_packet {
-	uint8_t sensor_type;
-	bool status;
-} __packed;
-
-#define HF_MANAGER_REQUEST_REGISTER_STATUS  _IOWR('a', 1, struct ioctl_packet)
-#define HF_MANAGER_REQUEST_BIAS_DATA        _IOW('a', 2, struct ioctl_packet)
-#define HF_MANAGER_REQUEST_CALI_DATA        _IOW('a', 3, struct ioctl_packet)
-#define HF_MANAGER_REQUEST_TEMP_DATA        _IOW('a', 4, struct ioctl_packet)
-#define HF_MANAGER_REQUEST_TEST_DATA        _IOW('a', 5, struct ioctl_packet)
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_sensor_type.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_sensor_type.h
deleted file mode 100644
index 50cd911..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/hf_sensor_type.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef _HF_SENSOR_TYPE_H_
-#define _HF_SENSOR_TYPE_H_
-
-enum {
-	/* follow google default sensor type */
-	SENSOR_TYPE_ACCELEROMETER = 1,
-	SENSOR_TYPE_MAGNETIC_FIELD,
-	SENSOR_TYPE_ORIENTATION,
-	SENSOR_TYPE_GYROSCOPE,
-	SENSOR_TYPE_LIGHT,
-	SENSOR_TYPE_PRESSURE,
-	SENSOR_TYPE_TEMPERATURE,
-	SENSOR_TYPE_PROXIMITY,
-	SENSOR_TYPE_GRAVITY,
-	SENSOR_TYPE_LINEAR_ACCELERATION,
-	SENSOR_TYPE_ROTATION_VECTOR,
-	SENSOR_TYPE_RELATIVE_HUMIDITY,
-	SENSOR_TYPE_AMBIENT_TEMPERATURE,
-	SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED,
-	SENSOR_TYPE_GAME_ROTATION_VECTOR,
-	SENSOR_TYPE_GYROSCOPE_UNCALIBRATED,
-	SENSOR_TYPE_SIGNIFICANT_MOTION,
-	SENSOR_TYPE_STEP_DETECTOR,
-	SENSOR_TYPE_STEP_COUNTER,
-	SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR,
-	SENSOR_TYPE_HEART_RATE,
-	SENSOR_TYPE_TILT_DETECTOR,
-	SENSOR_TYPE_WAKE_GESTURE,
-	SENSOR_TYPE_GLANCE_GESTURE,
-	SENSOR_TYPE_PICK_UP_GESTURE,
-	SENSOR_TYPE_WRIST_TILT_GESTURE,
-	SENSOR_TYPE_DEVICE_ORIENTATION,
-	SENSOR_TYPE_POSE_6DOF,
-	SENSOR_TYPE_STATIONARY_DETECT,
-	SENSOR_TYPE_MOTION_DETECT,
-	SENSOR_TYPE_HEART_BEAT,
-	SENSOR_TYPE_DYNAMIC_SENSOR_META,
-	SENSOR_TYPE_ADDITIONAL_INFO,
-	SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT,
-	SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED,
-
-	/* follow mtk add sensor type */
-	SENSOR_TYPE_PEDOMETER = 55,
-	SENSOR_TYPE_IN_POCKET,
-	SENSOR_TYPE_ACTIVITY,
-	SENSOR_TYPE_PDR,
-	SENSOR_TYPE_FREEFALL,
-	SENSOR_TYPE_FLAT,
-	SENSOR_TYPE_FACE_DOWN,
-	SENSOR_TYPE_SHAKE,
-	SENSOR_TYPE_BRINGTOSEE,
-	SENSOR_TYPE_ANSWER_CALL,
-	SENSOR_TYPE_GEOFENCE,
-	SENSOR_TYPE_FLOOR_COUNTER,
-	SENSOR_TYPE_EKG,
-	SENSOR_TYPE_PPG1,
-	SENSOR_TYPE_PPG2,
-	SENSOR_TYPE_RGBW,
-	SENSOR_TYPE_GYRO_TEMPERATURE,
-	SENSOR_TYPE_SAR,
-	SENSOR_TYPE_GYRO_SECONDARY,
-	SENSOR_TYPE_SENSOR_MAX,
-};
-
-enum {
-	ID_OFFSET = 1,
-
-	/* follow google default sensor type */
-	ID_ACCELEROMETER = 0,
-	ID_MAGNETIC_FIELD,
-	ID_ORIENTATION,
-	ID_GYROSCOPE,
-	ID_LIGHT,
-	ID_PRESSURE,
-	ID_TEMPERATURE,
-	ID_PROXIMITY,
-	ID_GRAVITY,
-	ID_LINEAR_ACCELERATION,
-	ID_ROTATION_VECTOR,
-	ID_RELATIVE_HUMIDITY,
-	ID_AMBIENT_TEMPERATURE,
-	ID_MAGNETIC_FIELD_UNCALIBRATED,
-	ID_GAME_ROTATION_VECTOR,
-	ID_GYROSCOPE_UNCALIBRATED,
-	ID_SIGNIFICANT_MOTION,
-	ID_STEP_DETECTOR,
-	ID_STEP_COUNTER,
-	ID_GEOMAGNETIC_ROTATION_VECTOR,
-	ID_HEART_RATE,
-	ID_TILT_DETECTOR,
-	ID_WAKE_GESTURE,
-	ID_GLANCE_GESTURE,
-	ID_PICK_UP_GESTURE,
-	ID_WRIST_TILT_GESTURE,
-	ID_DEVICE_ORIENTATION,
-	ID_POSE_6DOF,
-	ID_STATIONARY_DETECT,
-	ID_MOTION_DETECT,
-	ID_HEART_BEAT,
-	ID_DYNAMIC_SENSOR_META,
-	ID_ADDITIONAL_INFO,
-	ID_LOW_LATENCY_OFFBODY_DETECT,
-	ID_ACCELEROMETER_UNCALIBRATED,
-
-	/* follow mtk add sensor type */
-	ID_PEDOMETER = SENSOR_TYPE_PEDOMETER - ID_OFFSET,
-	ID_IN_POCKET,
-	ID_ACTIVITY,
-	ID_PDR,
-	ID_FREEFALL,
-	ID_FLAT,
-	ID_FACE_DOWN,
-	ID_SHAKE,
-	ID_BRINGTOSEE,
-	ID_ANSWER_CALL,
-	ID_GEOFENCE,
-	ID_FLOOR_COUNTER,
-	ID_EKG,
-	ID_PPG1,
-	ID_PPG2,
-	ID_RGBW,
-	ID_GYRO_TEMPERATURE,
-	ID_SAR,
-	ID_GYRO_SECONDARY,
-	ID_SENSOR_MAX,
-};
-
-enum {
-	SENSOR_ACCURANCY_UNRELIALE,
-	SENSOR_ACCURANCY_LOW,
-	SENSOR_ACCURANCY_MEDIUM,
-	SENSOR_ACCURANCY_HIGH,
-};
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/sensor_list.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/sensor_list.c
deleted file mode 100644
index 399fcc2..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/sensor_list.c
+++ /dev/null
@@ -1,235 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<sensorlist> " fmt
-
-#include <linux/module.h>
-#include <linux/miscdevice.h>
-#include <linux/types.h>
-#include <linux/spinlock.h>
-#include <linux/uaccess.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-
-#include "sensor_list.h"
-#include "hf_sensor_type.h"
-
-enum sensorlist {
-	accel,
-	gyro,
-	mag,
-	als,
-	ps,
-	baro,
-	sar,
-	maxhandle,
-};
-
-static struct sensorlist_info_t sensorlist_info[maxhandle];
-static struct mag_libinfo_t mag_libinfo;
-static DEFINE_SPINLOCK(sensorlist_info_lock);
-
-int sensorlist_find_sensor(int sensor)
-{
-	int handle = -1;
-
-	switch (sensor) {
-	case SENSOR_TYPE_ACCELEROMETER:
-		handle = accel;
-		break;
-	case SENSOR_TYPE_GYROSCOPE:
-		handle = gyro;
-		break;
-	case SENSOR_TYPE_MAGNETIC_FIELD:
-		handle = mag;
-		break;
-	case SENSOR_TYPE_LIGHT:
-		handle = als;
-		break;
-	case SENSOR_TYPE_PROXIMITY:
-		handle = ps;
-		break;
-	case SENSOR_TYPE_PRESSURE:
-		handle = baro;
-		break;
-	case SENSOR_TYPE_SAR:
-		handle = sar;
-		break;
-	}
-	return handle;
-}
-
-int sensorlist_find_type(int handle)
-{
-	int type = -1;
-
-	switch (handle) {
-	case accel:
-		type = SENSOR_TYPE_ACCELEROMETER;
-		break;
-	case gyro:
-		type = SENSOR_TYPE_GYROSCOPE;
-		break;
-	case mag:
-		type = SENSOR_TYPE_MAGNETIC_FIELD;
-		break;
-	case als:
-		type = SENSOR_TYPE_LIGHT;
-		break;
-	case ps:
-		type = SENSOR_TYPE_PROXIMITY;
-		break;
-	case baro:
-		type = SENSOR_TYPE_PRESSURE;
-		break;
-	case sar:
-		type = SENSOR_TYPE_SAR;
-		break;
-	}
-	return type;
-}
-
-static void init_sensorlist_info(void)
-{
-	int handle = -1;
-
-	spin_lock(&sensorlist_info_lock);
-	for (handle = accel; handle < maxhandle; ++handle)
-		strlcpy(sensorlist_info[handle].name, "NULL",
-			sizeof(sensorlist_info[handle].name));
-	spin_unlock(&sensorlist_info_lock);
-}
-
-int sensorlist_register_devinfo(int sensor,
-		struct sensorlist_info_t *devinfo)
-{
-	int handle = -1;
-
-	handle = sensorlist_find_sensor(sensor);
-	if (handle < 0)
-		return -1;
-	pr_notice("name(%s) type(%d) registered\n", devinfo->name, sensor);
-	spin_lock(&sensorlist_info_lock);
-	strlcpy(sensorlist_info[handle].name, devinfo->name,
-			sizeof(sensorlist_info[handle].name));
-	spin_unlock(&sensorlist_info_lock);
-	return 0;
-}
-
-int sensorlist_register_maginfo(struct mag_libinfo_t *maginfo)
-{
-	spin_lock(&sensorlist_info_lock);
-	memcpy(&mag_libinfo, maginfo, sizeof(struct mag_libinfo_t));
-	spin_unlock(&sensorlist_info_lock);
-	return 0;
-}
-
-static int sensorlist_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static ssize_t
-sensorlist_read(struct file *file, char __user *buf,
-		size_t count, loff_t *ptr)
-{
-	struct sensorlist_info_t temp[maxhandle];
-
-	if (count == 0)
-		return -EINVAL;
-	if (count < sizeof(struct sensorlist_info_t))
-		return -EINVAL;
-	if (count > maxhandle * sizeof(struct sensorlist_info_t))
-		count = maxhandle * sizeof(struct sensorlist_info_t);
-
-	memset(temp, 0, sizeof(temp));
-	spin_lock(&sensorlist_info_lock);
-	memcpy(temp, sensorlist_info, sizeof(temp));
-	spin_unlock(&sensorlist_info_lock);
-	if (copy_to_user(buf, temp, count))
-		return -EFAULT;
-	return count;
-}
-
-static long sensorlist_ioctl(struct file *filp,
-			unsigned int cmd, unsigned long arg)
-{
-	unsigned int size = _IOC_SIZE(cmd);
-	void __user *ubuf = (void __user *)arg;
-	struct mag_libinfo_t temp;
-
-	if (size != sizeof(struct mag_libinfo_t))
-		return -EINVAL;
-
-	switch (cmd) {
-	case SENSOR_LIST_GET_MAG_LIB_INFO:
-		memset(&temp, 0, sizeof(struct mag_libinfo_t));
-		spin_lock(&sensorlist_info_lock);
-		memcpy(&temp, &mag_libinfo, sizeof(struct mag_libinfo_t));
-		spin_unlock(&sensorlist_info_lock);
-		if (copy_to_user(ubuf, &temp, sizeof(struct mag_libinfo_t)))
-			return -EFAULT;
-		break;
-	}
-	return 0;
-}
-
-static const struct file_operations sensorlist_fops = {
-	.owner          = THIS_MODULE,
-	.open           = sensorlist_open,
-	.read           = sensorlist_read,
-	.unlocked_ioctl = sensorlist_ioctl,
-	.compat_ioctl   = sensorlist_ioctl,
-};
-
-static struct miscdevice sensorlist_miscdev = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "sensorlist",
-	.fops = &sensorlist_fops,
-};
-
-static int sensor_list_proc_show(struct seq_file *m, void *v)
-{
-	int handle = -1, type = -1;
-
-	seq_puts(m, "dynamic hardware sensorlist:\n");
-	spin_lock(&sensorlist_info_lock);
-	for (handle = accel; handle < maxhandle; ++handle) {
-		type = sensorlist_find_type(handle);
-		if (type < 0)
-			continue;
-		seq_printf(m, "sensortype:%d chipname:%s\n",
-			type, sensorlist_info[handle].name);
-	}
-	spin_unlock(&sensorlist_info_lock);
-	return 0;
-}
-
-static int sensor_list_proc_open(struct inode *inode,
-		struct file *filp)
-{
-	return single_open(filp, sensor_list_proc_show, NULL);
-}
-
-static const struct file_operations sensor_list_proc_fops = {
-	.open           = sensor_list_proc_open,
-	.release        = single_release,
-	.read           = seq_read,
-	.llseek         = seq_lseek,
-};
-
-static int __init sensorlist_init(void)
-{
-	init_sensorlist_info();
-	if (misc_register(&sensorlist_miscdev) < 0)
-		return -1;
-	proc_create("sensorlist", 0644, NULL, &sensor_list_proc_fops);
-	return 0;
-}
-
-subsys_initcall(sensorlist_init);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("dynamic sensorlist driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/sensor_list.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/sensor_list.h
deleted file mode 100644
index d32cead..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/core/sensor_list.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef _SENSOR_LIST_H_
-#define _SENSOR_LIST_H_
-
-#include <linux/ioctl.h>
-
-struct sensorlist_info_t {
-	char name[16];
-};
-
-struct mag_libinfo_t {
-	char libname[64];
-	int32_t layout;
-	int32_t deviceid;
-};
-
-int sensorlist_register_maginfo(struct mag_libinfo_t *mag_info);
-int sensorlist_register_devinfo(int sensor,
-		struct sensorlist_info_t *devinfo);
-int sensorlist_find_sensor(int sensor);
-
-#define SENSOR_LIST_GET_MAG_LIB_INFO _IOWR('a', 1, struct mag_libinfo_t)
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/Kconfig
deleted file mode 100644
index c4935d9..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/Kconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-config MTK_KXTJ3_SUPPORT
-	bool " MTK_KXTJ3_SUPPORT for MediaTek package"
-	default n
-	help
-	  Enable MTK KXTJ3 support.
-	  KXTJ3 is a low-power and low-noise
-	  barometric pressure sensor.
-	  If in doubt, say N here.
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/Makefile
deleted file mode 100644
index f3bf3e8..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensor/2.0/core/
-
-obj-y += kxtj3_acc_i2c.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/kxtj3_acc_i2c.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/kxtj3_acc_i2c.c
deleted file mode 100644
index 91f143d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/kxtj3_acc_i2c.c
+++ /dev/null
@@ -1,563 +0,0 @@
-/*
- * Copyright (C) 2016 MediaTek Inc.
- *
- * 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.
- *
- * 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 http://www.gnu.org/licenses/gpl-2.0.html for more details.
- */
-
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/delay.h>
-#include <linux/math64.h>
-#include <linux/atomic.h>
-
-#include "hf_manager.h"
-#include "kxtj3_acc_i2c.h"
-#include "sensor_list.h"
-
-#define KXTJ3_ACC_I2C_NAME "kxtj3_acc_i2c"
-#define KXTJ3_ACC_AXES_NUM          3
-#define C_I2C_FIFO_SIZE              8
-
-//#define GRAVITY_EARTH_SCALAR       9.807f
-//#define ACCELEROMETER_INCREASE_NUM_AP	1000
-
-#define KXTJ3_ACC_SOFT_RESET_VALUE  0x80
-#define KXTJ3_ACC_CHIP_ID_VALUE     (0x35)
-#define CHECK_CHIP_ID_TIME_MAX       5
-
-
-
-#define KXTJ3_ACC_ODR_7HZ 0x0b
-#define KXTJ3_ACC_ODR_12HZ 0x00
-#define KXTJ3_ACC_ODR_25HZ 0x01
-#define KXTJ3_ACC_ODR_50HZ 0x02
-#define KXTJ3_ACC_ODR_100HZ 0x03
-
-#define KXTJ3_ACC_ODR_200HZ 0x04
-#define KXTJ3_ACC_ODR_400HZ 0x05
-#define KXTJ3_ACC_ODR_800HZ 0x06
-#define KXTJ3_ACC_ODR_1600HZ 0x0F
-
-
-#define KXTJ3_ACC_RANGE_2G 0x40
-#define KXTJ3_ACC_RANGE_4G 0x48
-#define KXTJ3_ACC_RANGE_8G_1 0x50
-#define KXTJ3_ACC_RANGE_8G_2 0x58
-#define KXTJ3_ACC_RANGE_16G_1 0x44
-#define KXTJ3_ACC_RANGE_16G_2 0x4C
-#define KXTJ3_ACC_RANGE_16G_3 0x54
-#define KXTJ3_ACC_RANGE_16G_4 0x5C
-
-
-
-
-
-//static struct sensor_info support_sensors[] = {
-//	{
-//	.sensor_type = SENSOR_TYPE_ACCELEROMETER,
-//	.gain = 100,
-//	},
-//};
-static unsigned char support_sensors[] = {
-	SENSOR_TYPE_ACCELEROMETER,
-//	SENSOR_TYPE_GYROSCOPE,
-//	SENSOR_TYPE_GYRO_TEMPERATURE,
-};
-struct kxtj3_acc_device {
-	struct hf_device hf_dev;
-	struct i2c_client *acc_client;
-	uint32_t direction;
-	uint8_t placement[3];
-	atomic_t raw_enable;
-	atomic_t acc_enable;
-};
-
-/* I2C operation functions */
-static int kxtj3_acc_i2c_read_block(struct i2c_client *client,
-			u8 addr, u8 *data, u8 len)
-{
-	int err = 0;
-	u8 beg = addr;
-	struct i2c_msg msgs[2] = {
-		{/*.addr = client->addr,*/
-		 .flags = 0,
-		 .len = 1,
-		 .buf = &beg},
-		{
-			/*.addr = client->addr*/
-			.flags = I2C_M_RD,
-			.len = len,
-			.buf = data,
-		} };
-	if (!client)
-		return -EINVAL;
-	msgs[0].addr = client->addr;
-	msgs[1].addr = client->addr;
-pr_info("kxtj3_acc_i2c_read_block.\n");
-	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-	if (err != 2) {
-		pr_err_ratelimited("i2c_trans err: %x %x (%d %p %d) %d\n",
-		       msgs[0].addr, client->addr, addr, data, len, err);
-		err = -EIO;
-	} else {
-		err = 0; /*no error*/
-	}
-	return err;
-}
-
-static int kxtj3_acc_i2c_write_block(struct i2c_client *client,
-			u8 addr, u8 *data, u8 len)
-{
-	/* because address also occupies one byte,
-	 * the maximum length for write is 7 bytes
-	 */
-	int err = 0, idx = 0, num = 0;
-	char buf[32];
-	pr_info("kxtj3_acc_i2c_write_block.\n");
-	if (!client){
-		return -EINVAL;
-	}
-	else if (len > C_I2C_FIFO_SIZE) {
-		pr_err_ratelimited("len %d fi %d\n", len, C_I2C_FIFO_SIZE);
-		return -EINVAL;
-	}
-	buf[num++] = addr;
-	for (idx = 0; idx < len; idx++)
-		buf[num++] = data[idx];
-
-	err = i2c_master_send(client, buf, num);
-	if (err < 0) {
-		pr_err_ratelimited("send command error!!\n");
-		return -EFAULT;
-	}
-
-	return err;
-}
-
-
-static int kxtj3_acc_init_device(struct i2c_client *client)
-{
-	int err = 0;
-	uint8_t data = 0;
-pr_info("kxtj3_acc_init_device.\n");
-	data = KXTJ3_ACC_ODR_100HZ;
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_BW_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-#if 0
-	data = 0x00; //filter and lock enable
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_RATED_HBW_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-#endif
-	data = KXTJ3_ACC_RANGE_4G;
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_RANGE_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //disable int
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_INT_ENABLE1_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-#if 0
-	data = 0x80; //map int
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_INT_MAP_1_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //push-pull, active low
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_INT_OUT_CTRL_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-#endif
-	pr_info("KXTJ3_ACC init OK.\n");
-
-	return err;
-}
-
-static int kxtj3_acc_set_soft_reset(struct i2c_client *client)
-{
-	int err = 0;
-/*	uint8_t data = KXTJ3_ACC_SOFT_RESET_VALUE;
-pr_info("kxtj3_acc_set_soft_reset.\n");
-	err = kxtj3_acc_i2c_write_block(client,
-			KXTJ3_ACC_BGW_SOFTRESET_ADDR, &data, 1);*/
-	return err;
-}
-
-static int kxtj3_acc_check_chip_id(struct i2c_client *client)
-{
-	int err = -1;
-	u8 chip_id = 0;
-	u8 read_count = 0;
-pr_info("kxtj3_acc_check_chip_id\n");
-	while (read_count++ < CHECK_CHIP_ID_TIME_MAX) {
-		kxtj3_acc_i2c_read_block(client,
-				KXTJ3_ACC_CHIP_ID_ADDR, &chip_id, 1);
-
-		if ((chip_id & 0xff) != KXTJ3_ACC_CHIP_ID_VALUE) {
-			continue;
-		} else {
-			err = 0;
-			pr_info("kxtj3_acc_check_chip_id err = 0\n");
-			break;
-		}
-	}
-	return err;
-}
-
-
-
-
-
-
-
-
-
-int kxtj3_acc_sample(struct hf_device *hfdev)
-{
-
-	int err = 0;
-	uint8_t buf[KXTJ3_ACC_AXES_NUM * 2] = {0};
-	int32_t data[KXTJ3_ACC_AXES_NUM] = {0};
-	struct hf_manager_event event;
-	int64_t current_time;
-//	struct i2c_client *client = hf_device_get_private_data(hfdev);
-	struct kxtj3_acc_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-pr_info("kxtj3_acc_sample\n");
-	current_time = ktime_get_boot_ns();
-	if (atomic_read(&driver_dev->acc_enable)) {
-	err = kxtj3_acc_i2c_read_block(driver_dev->acc_client,
-			KXTJ3_ACC_RATE_X_LSB_ADDR,
-			&buf[0], KXTJ3_ACC_AXES_NUM * 2);
-	if (err < 0) {
-		pr_err_ratelimited("read fail\n");
-		return err;
-	}
-
-	data[0] = ((int16_t)(buf[0] | (buf[1] << 8))) >> 4;
-	data[1] = ((int16_t)(buf[2] | (buf[3] << 8))) >> 4;
-	data[2] = ((int16_t)(buf[4] | (buf[5] << 8))) >> 4;
-
-	 pr_err("kxtj3 register :%x, %x, %x %x, %x, %x data: %x, %x, %x\n",
-	  buf[0], buf[1], buf[2],
-	  buf[3], buf[4], buf[5],
-	  data[0], data[1], data[2]);
-	 
-	coordinate_map(driver_dev->direction, data);
-	current_time = ktime_get_boot_ns();
-
-//	if (atomic_read(&driver_dev->raw_enable)) {
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_ACCELEROMETER;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.action = RAW_ACTION;
-		event.word[0] =
-			(int32_t)div64_s64((int64_t)data[0] * 9807, 256);
-		event.word[1] =
-			(int32_t)div64_s64((int64_t)data[1] * 9807, 256);
-		event.word[2] =
-			(int32_t)div64_s64((int64_t)data[2] * 9807, 256);
-		/* pr_err("kxtj3 raw %d, %d, %d,  m/s %d, %d, %d\n",
-		 * data[0], data[1], data[2],
-		 * event.word[0], event.word[1], event.word[2]);
-		 */
-		manager->report(manager, &event);
-	}
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	event.timestamp = current_time;
-	event.sensor_type = SENSOR_TYPE_ACCELEROMETER;
-	event.accurancy = SENSOR_ACCURANCY_HIGH;
-	event.action = DATA_ACTION;
-
-	event.word[0] = (int32_t)div64_s64((int64_t)data[0] * 1000, 512);
-	event.word[1] = (int32_t)div64_s64((int64_t)data[1] * 1000, 512);
-	event.word[2] = (int32_t)div64_s64((int64_t)data[2] * 1000, 512);
-	
-	/* pr_err("kxtj3 raw %d, %d, %d,  m/s %d, %d, %d\n",
-	 * data[0], data[1], data[2],
-	 * event.word[0], event.word[1], event.word[2]);
-	 */
-		
-	manager->report(manager, &event);
-
-	manager->complete(manager);
-
-	return 0;
-}
-
-int kxtj3_acc_raw_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	struct kxtj3_acc_device  *driver_dev = hf_device_get_private_data(hfdev);
-//	struct kxtj3_acc_device *driver_dev = i2c_get_clientdata(client);
-pr_info("kxtj3_acc_raw_enable\n");
-	atomic_set(&driver_dev->raw_enable, en);
-	return 0;
-}
-
-int kxtj3_acc_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	int err = 0;
-	uint8_t data = 0;
-	struct kxtj3_acc_device *driver_dev = hf_device_get_private_data(hfdev);
-
-	pr_info("%s id:%d en:%d\n", __func__, sensor_type, en);
-
-	if (en) {
-		
-		kxtj3_acc_i2c_read_block(driver_dev->acc_client,KXTJ3_ACC_RANGE_ADDR, &data, 1);
-		data |= 1<<7;
-		err = kxtj3_acc_i2c_write_block(driver_dev->acc_client, KXTJ3_ACC_RANGE_ADDR, &data, 1);
-		if (err < 0) {
-			pr_err_ratelimited("write power mode failed.\n");
-			return -1;
-		}
-		mdelay(1);
-		atomic_set(&driver_dev->acc_enable, en);
-	} else {
-		data = 0x00;
-		err = kxtj3_acc_i2c_write_block(driver_dev->acc_client,KXTJ3_ACC_RANGE_ADDR, &data, 1);
-		if (err < 0) {
-			pr_err_ratelimited("write power mode failed.\n");
-			return -1;
-		}
-			atomic_set(&driver_dev->acc_enable, en);
-		mdelay(1);
-	}
-	return 0;
-
-}
-
-int kxtj3_acc_batch(struct hf_device *hfdev, int sensor_type,
-	int64_t delay, int64_t latency)
-{
-
-	int err = 0;
-	uint8_t data = 0;
-	int value = 0;
-	struct kxtj3_acc_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-
-	pr_info("%s id:%d rate:%lld latency:%lld\n",
-		__func__, sensor_type, delay, latency);
-
-	value = div64_s64(1000000000LL, delay);
-
-	if (value <= 7)
-		data = KXTJ3_ACC_ODR_7HZ;
-	else if (value <= 12)
-		data = KXTJ3_ACC_ODR_12HZ;
-	else if (value <= 25)
-		data = KXTJ3_ACC_ODR_25HZ;
-	else if (value <= 100)
-		data = KXTJ3_ACC_ODR_100HZ;
-	else if (value <= 200)
-		data = KXTJ3_ACC_ODR_200HZ;
-	else if (value <= 400)
-		data = KXTJ3_ACC_ODR_400HZ;
-	else if (value <= 800)
-		data = KXTJ3_ACC_ODR_800HZ;
-	else
-		data = KXTJ3_ACC_ODR_1600HZ;
-
-	err = kxtj3_acc_i2c_write_block(driver_dev->acc_client, KXTJ3_ACC_BW_ADDR, &data, 1);
-	if (err < 0) {
-		pr_err_ratelimited("write rate failed.\n");
-		return -1;
-	}
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		current_time = ktime_get_boot_ns();
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_ADDITIONAL_INFO;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.reserved = SENSOR_TYPE_ACCELEROMETER;
-		event.action = DATA_ACTION;
-		get_placement_info(driver_dev->direction, event.byte);
-		event.byte[12] = 1;
-		event.byte[3] = driver_dev->placement[0];
-		event.byte[7] = driver_dev->placement[1];
-		event.byte[11] = driver_dev->placement[2];
-
-		manager->report(manager, &event);
-	mdelay(1);
-	manager->complete(manager);
-	return 0;
-
-}
-
-static int kxtj3_acc_flush(struct hf_device *hfdev, int sensor_type)
-{
-	struct kxtj3_acc_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	current_time = ktime_get_boot_ns();
-	event.sensor_type = sensor_type;
-	event.timestamp = current_time;
-	event.action = FLUSH_ACTION;
-
-	manager->report(manager, &event);
-	manager->complete(manager);
-
-	return 0;
-}
-
-static int kxtj3_acc_i2c_remove(struct i2c_client *client)
-{
-	struct kxtj3_acc_device *driver_dev = i2c_get_clientdata(client);
-pr_info("kxtj3_acc_i2c_remove\n");
-	hf_manager_destroy(driver_dev->hf_dev.manager);
-	kfree(driver_dev);
-	return 0;
-}
-
-static int kxtj3_acc_i2c_probe(struct i2c_client *client,
-			const struct i2c_device_id *id)
-{
-
-	int err = 0;
-	struct kxtj3_acc_device *driver_dev;
-	struct sensorlist_info_t listinfo;
-
-	pr_info("%s\n", __func__);
-
-	driver_dev = devm_kzalloc(&client->dev, sizeof(*driver_dev),
-								GFP_KERNEL);
-	if (!driver_dev)
-		return -ENOMEM;
-
-//	driver_dev->acc_client = client;
-	/* check chip id */
-	err = kxtj3_acc_check_chip_id(client);
-	if (err < 0) {
-		pr_err("Bosch Sensortec Device not found, chip id mismatch\n");
-		err = -EINVAL;
-		goto init_fail;
-	}
-
-	err = kxtj3_acc_set_soft_reset(client);
-	if (err < 0) {
-		pr_err("erro soft reset!\n");
-		err = -EINVAL;
-		goto init_fail;
-	}
-	mdelay(3);
-
-	err = kxtj3_acc_init_device(client);
-	if (err < 0) {
-		pr_err("%s init device fail\n", __func__);
-		goto init_fail;
-	}
-
-	driver_dev = kzalloc(sizeof(*driver_dev), GFP_KERNEL);
-	if (!driver_dev) {
-		err = -ENOMEM;
-		goto malloc_fail;
-	}
-
-	driver_dev->acc_client = client;
-
-	if (of_property_read_u32(client->dev.of_node,
-		"direction", &driver_dev->direction)) {
-		pr_err("%s get direction dts fail\n", __func__);
-		err = -EFAULT;
-		goto dts_fail;
-	}
-if(0){
-	if (of_property_read_u8_array(client->dev.of_node, "placement",
-		driver_dev->placement, ARRAY_SIZE(driver_dev->placement))) {
-		pr_err("%s get placement dts fail\n", __func__);
-		err = -EFAULT;
-		goto dts_fail;
-	}
-}
-	atomic_set(&driver_dev->raw_enable, 0);
-
-	driver_dev->hf_dev.dev_name = KXTJ3_ACC_I2C_NAME;
-	driver_dev->hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	driver_dev->hf_dev.device_bus = HF_DEVICE_IO_SYNC;
-	driver_dev->hf_dev.support_list = support_sensors;
-	driver_dev->hf_dev.support_size = ARRAY_SIZE(support_sensors);
-	driver_dev->hf_dev.enable = kxtj3_acc_enable;
-	driver_dev->hf_dev.batch = kxtj3_acc_batch;
-	driver_dev->hf_dev.flush = kxtj3_acc_flush;
-	driver_dev->hf_dev.sample = kxtj3_acc_sample;
-	driver_dev->hf_dev.rawdata = kxtj3_acc_raw_enable;
-
-	err = hf_manager_create(&driver_dev->hf_dev);
-	if (err < 0) {
-		pr_err("%s hf_manager_create fail\n", __func__);
-		err = -1;
-		goto create_manager_fail;
-	}
-
-	i2c_set_clientdata(client, driver_dev);
-	hf_device_set_private_data(&driver_dev->hf_dev, driver_dev);
-
-	//memset(&listinfo, 0, sizeof(struct sensorlist_info_t));
-	//strlcpy(listinfo.name, KXTJ3_ACC_I2C_NAME, sizeof(listinfo.name));
-	//sensorlist_register_devinfo(SENSOR_TYPE_ACCELEROMETER, &listinfo);
-	memset(&listinfo, 0, sizeof(struct sensorlist_info_t));
-	strlcpy(listinfo.name, KXTJ3_ACC_I2C_NAME, sizeof(listinfo.name));
-	sensorlist_register_devinfo(SENSOR_TYPE_ACCELEROMETER, &listinfo);
-
-	pr_info("%s success!\n", __func__);
-	return 0;
-
-create_manager_fail:
-dts_fail:
-	kfree(driver_dev);
-malloc_fail:
-init_fail:
-	pr_err("%s fail!\n", __func__);
-	return err;
-}
-
-static const struct of_device_id kxtj3_acc_of_match[] = {
-	{.compatible = "mediatek,kxtj3_gsensor"},
-	{},
-};
-static const struct i2c_device_id kxtj3_acc_i2c_id[] = {
-					{KXTJ3_ACC_I2C_NAME, 0}, {} };
-
-static struct i2c_driver kxtj3_acc_i2c_driver = {
-	.driver = {
-		.name = KXTJ3_ACC_I2C_NAME,
-		.bus = &i2c_bus_type,
-		.owner = THIS_MODULE,
-		.of_match_table = kxtj3_acc_of_match,
-	},
-	.probe = kxtj3_acc_i2c_probe,
-	.remove = kxtj3_acc_i2c_remove,
-	.id_table =  kxtj3_acc_i2c_id,
-};
-
-module_i2c_driver(kxtj3_acc_i2c_driver);
-
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("kxtj3 acc i2c driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/kxtj3_acc_i2c.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/kxtj3_acc_i2c.h
deleted file mode 100644
index 5ea7661..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/kxtj3/kxtj3_acc_i2c.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2016 MediaTek Inc.
- *
- * 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.
- *
- * 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 http://www.gnu.org/licenses/gpl-2.0.html for more details.
- */
-
-#ifndef __KXTJ3_ACC_H__
-#define __KXTJ3_ACC_H__
-
-	/*Define of registers*/
-
-	 /* Hard Wired */
-#define KXTJ3_ACC_CHIP_ID_ADDR                     0x0f
-	/**<Address of Chip ID Register*/
-
-	/* Data Register */
-#define KXTJ3_ACC_RATE_X_LSB_ADDR                  0x06
-	/**<	Address of X axis Rate LSB Register	*/
-#define KXTJ3_ACC_RATE_X_MSB_ADDR                  0x07
-	/**<	Address of X axis Rate MSB Register	*/
-#define KXTJ3_ACC_RATE_Y_LSB_ADDR                  0x08
-	/**<	Address of Y axis Rate LSB Register	*/
-#define KXTJ3_ACC_RATE_Y_MSB_ADDR                  0x09
-	/**<	Address of Y axis Rate MSB Register	*/
-#define KXTJ3_ACC_RATE_Z_LSB_ADDR                  0x0a
-	/**<	Address of Z axis Rate LSB Register	*/
-#define KXTJ3_ACC_RATE_Z_MSB_ADDR                  0x0b
-	/**<	Address of Z axis Rate MSB Register	*/
-//#define KXTJ3_ACC_TEMP_ADDR                        0x08
-	/**<   Address of Temperature Data LSB Register */
-
-//#define KXTJ3_ACC_INT_STATUS1_ADDR                 0x0A
-	/**<   Address of Interrupt status Register 1*/
-
-	/* Control Register */
-#define KXTJ3_ACC_RANGE_ADDR                       0x1b
-	/**<	Address of Range address Register */
-#define KXTJ3_ACC_BW_ADDR                          0x21
-	/**<	Address of Bandwidth Register */
-//#define KXTJ3_ACC_RATED_HBW_ADDR                   0x13
-	/**<	Address of Rate HBW Register */
-#define KXTJ3_ACC_BGW_SOFTRESET_ADDR               0x1b
-	/**<	Address of BGW Softreset Register  */
-
-#define KXTJ3_ACC_INT_ENABLE1_ADDR                 0x1e
-	/**<        Address of Interrupt Enable 1  */
-
-//#define KXTJ3_ACC_INT_MAP_1_ADDR                   0x1A
-	/**<	Address of Interrupt MAP 1  */
-
-//#define KXTJ3_ACC_INT_SRC_ADDR                     0x1E
-	/**<	Address of Interrupt SRC 1  */
-
-//#define KXTJ3_ACC_INT_OUT_CTRL_ADDR                0x20
-	/**<	Address of Interrupt MAP 1  */
-
-//#define KXTJ3_ACC_BGW_SPI3_WDT_ADDR                0x34
-	/**<	Address of BGW SPI3,WDT Register  */
-
-//#define KXTJ3_ACC_SELF_TEST_ADDR                   0x32
-	/**<	Address of BGW Self test Register  */
-
-#define KXTJ3_ACC_DATA_INT_EN                      0x28
-
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Kconfig
deleted file mode 100644
index 8b13789..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Kconfig
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Makefile
deleted file mode 100644
index d32fe0e..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensor/2.0/core
-ccflags-y += -I$(srctree)/drivers/staging/nanohub
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp/$(CONFIG_MTK_PLATFORM)
-
-obj-y += mtk_nanohub.o mtk_nanohub_ipi.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub.c
deleted file mode 100644
index 201de38..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub.c
+++ /dev/null
@@ -1,2336 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[mtk_nanohub] " fmt
-
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-#include <linux/kthread.h>
-#include <linux/platform_device.h>
-#include <linux/dma-mapping.h>
-#include <linux/atomic.h>
-#include <linux/types.h>
-#include <linux/module.h>
-#include <linux/suspend.h>
-#include <linux/time.h>
-#include <asm/arch_timer.h>
-#include <linux/math64.h>
-#include <linux/delay.h>
-
-#include "scp_ipi.h"
-#include "scp_helper.h"
-#include "scp_excep.h"
-#include "mtk_nanohub.h"
-#include "comms.h"
-#include "hf_manager.h"
-#include "sensor_list.h"
-#include "mtk_nanohub_ipi.h"
-
-/* ALGIN TO SCP SENSOR_IPI_SIZE AT FILE CONTEXTHUB_FW.H, ALGIN
- * TO SCP_SENSOR_HUB_DATA UNION, ALGIN TO STRUCT DATA_UNIT_T
- * SIZEOF(STRUCT DATA_UNIT_T) = SCP_SENSOR_HUB_DATA = SENSOR_IPI_SIZE
- * BUT AT THE MOMENT AP GET DATA THROUGH IPI, WE ONLY TRANSFER
- * 44 BYTES DATA_UNIT_T, THERE ARE 4 BYTES HEADER IN SCP_SENSOR_HUB_DATA
- * HEAD
- */
-#define SENSOR_IPI_SIZE 48
-/*
- * experience number for delay_count per DELAY_COUNT sensor input delay 10ms
- * msleep(10) system will schedule to hal process then read input node
- */
-#define SENSOR_IPI_HEADER_SIZE 4
-#define SENSOR_IPI_PACKET_SIZE (SENSOR_IPI_SIZE - SENSOR_IPI_HEADER_SIZE)
-#define SENSOR_DATA_SIZE 44
-
-#if SENSOR_DATA_SIZE > SENSOR_IPI_PACKET_SIZE
-#error "SENSOR_DATA_SIZE > SENSOR_IPI_PACKET_SIZE, out of memory"
-#endif
-
-#define SYNC_TIME_CYCLC 10000
-#define SYNC_TIME_START_CYCLC 3000
-
-struct curr_wp_queue {
-	spinlock_t buffer_lock;
-	uint32_t head;
-	uint32_t tail;
-	uint32_t bufsize;
-	uint32_t *ringbuffer;
-};
-
-struct mtk_nanohub_device {
-	struct hf_device hf_dev;
-	struct timer_list sync_time_timer;
-	struct work_struct sync_time_worker;
-	struct wakeup_source time_sync_wakeup_src;
-	struct wakeup_source data_notify_wakeup_src;
-
-	struct sensor_fifo *scp_sensor_fifo;
-	struct curr_wp_queue wp_queue;
-	phys_addr_t shub_dram_phys;
-	phys_addr_t shub_dram_virt;
-	atomic_t traces[ID_SENSOR_MAX];
-
-	atomic_t get_list_first_boot;
-	atomic_t cfg_data_after_reboot;
-	atomic_t start_timesync_first_boot;
-
-	int32_t acc_config_data[6];
-	int32_t gyro_config_data[12];
-	int32_t mag_config_data[9];
-	int32_t light_config_data[1];
-	int32_t proximity_config_data[2];
-};
-
-static uint8_t rtc_compensation_suspend;
-static struct SensorState mSensorState[SENSOR_TYPE_SENSOR_MAX];
-static unsigned char support_sensors[SENSOR_TYPE_SENSOR_MAX];
-static DEFINE_MUTEX(mSensorState_mtx);
-static atomic_t power_status = ATOMIC_INIT(SENSOR_POWER_DOWN);
-static DECLARE_WAIT_QUEUE_HEAD(chre_kthread_wait);
-static DECLARE_WAIT_QUEUE_HEAD(power_reset_wait);
-static uint8_t chre_kthread_wait_condition;
-static DEFINE_SPINLOCK(scp_state_lock);
-static DEFINE_SPINLOCK(config_data_lock);
-static uint8_t scp_system_ready;
-static uint8_t scp_chre_ready;
-static struct mtk_nanohub_device *mtk_nanohub_dev;
-
-static int mtk_nanohub_send_timestamp_to_hub(void);
-static int mtk_nanohub_server_dispatch_data(uint32_t *currWp);
-static int mtk_nanohub_report_to_manager(struct data_unit_t *data);
-
-enum scp_ipi_status __attribute__((weak)) scp_ipi_registration(enum ipi_id id,
-	void (*ipi_handler)(int id, void *data, unsigned int len),
-	const char *name)
-{
-	return SCP_IPI_ERROR;
-}
-
-void __attribute__((weak)) scp_A_register_notify(struct notifier_block *nb)
-{
-
-}
-
-phys_addr_t __attribute__((weak))
-	scp_get_reserve_mem_virt(enum scp_reserve_mem_id_t id)
-{
-	return 0;
-}
-
-phys_addr_t __attribute__((weak))
-	scp_get_reserve_mem_phys(enum scp_reserve_mem_id_t id)
-{
-	return 0;
-}
-
-phys_addr_t __attribute__((weak))
-	scp_get_reserve_mem_size(enum scp_reserve_mem_id_t id)
-{
-	return 0;
-}
-
-void __attribute__((weak)) scp_register_feature(enum feature_id id)
-{
-}
-
-/* arch counter is 13M, mult is 161319385, shift is 21 */
-static inline uint64_t arch_counter_to_ns(uint64_t cyc)
-{
-#define ARCH_TIMER_MULT 161319385
-#define ARCH_TIMER_SHIFT 21
-	return (cyc * ARCH_TIMER_MULT) >> ARCH_TIMER_SHIFT;
-}
-
-#define FILTER_DATAPOINTS	16
-#define FILTER_TIMEOUT		10000000000ULL /* 10 seconds, ~100us drift */
-#define FILTER_FREQ			10000000ULL /* 10 ms */
-struct moving_average {
-	uint64_t last_time;
-	int64_t input[FILTER_DATAPOINTS];
-	atomic64_t output;
-	uint8_t cnt;
-	uint8_t tail;
-};
-static struct moving_average moving_average_algo;
-static uint8_t rtc_compensation_suspend;
-static void moving_average_filter(struct moving_average *filter,
-		uint64_t ap_time, uint64_t hub_time)
-{
-	int i = 0;
-	int64_t avg;
-	int64_t ret_avg = 0;
-
-	if (ap_time > filter->last_time + FILTER_TIMEOUT ||
-		filter->last_time == 0) {
-		filter->tail = 0;
-		filter->cnt = 0;
-	} else if (ap_time < filter->last_time + FILTER_FREQ) {
-		return;
-	}
-	filter->last_time = ap_time;
-
-	filter->input[filter->tail++] = ap_time - hub_time;
-	filter->tail &= (FILTER_DATAPOINTS - 1);
-	if (filter->cnt < FILTER_DATAPOINTS)
-		filter->cnt++;
-
-	/* pr_err("hongxu raw_offset=%lld\n", ap_time - hub_time); */
-
-	for (i = 1, avg = 0; i < filter->cnt; i++)
-		avg += (filter->input[i] - filter->input[0]);
-	ret_avg = div_s64(avg, filter->cnt) + filter->input[0];
-	atomic64_set(&filter->output, ret_avg);
-}
-
-static uint64_t get_filter_output(struct moving_average *filter)
-{
-	return atomic64_read(&filter->output);
-}
-
-struct mtk_nanohub_cmd {
-	uint32_t reason;
-	void (*handler)(union SCP_SENSOR_HUB_DATA *rsp, unsigned int rx_len);
-};
-
-#define MTK_NANOHUB_CMD(_reason, _handler) \
-	{.reason = _reason, .handler = _handler}
-
-#define type_to_id(type) (type - ID_OFFSET)
-#define id_to_type(id) (id + ID_OFFSET)
-
-int mtk_nanohub_req_send(union SCP_SENSOR_HUB_DATA *data)
-{
-	int ret = 0;
-
-	if (data->req.sensorType >= ID_SENSOR_MAX) {
-		pr_err("invalid sensor type %d\n", data->rsp.sensorType);
-		return -1;
-	}
-	ret = mtk_nanohub_ipi_sync((unsigned char *)data,
-		SENSOR_IPI_SIZE);
-	if (ret != 0 || data->rsp.errCode != 0)
-		return -1;
-	return 0;
-}
-
-static void mtk_nanohub_write_wp_queue(union SCP_SENSOR_HUB_DATA *rsp)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	struct curr_wp_queue *wp_queue = &device->wp_queue;
-
-	spin_lock(&wp_queue->buffer_lock);
-	wp_queue->ringbuffer[wp_queue->head++] = rsp->notify_rsp.currWp;
-	wp_queue->head &= wp_queue->bufsize - 1;
-	if (unlikely(wp_queue->head == wp_queue->tail))
-		pr_err("dropped currWp due to ringbuffer is full\n");
-	spin_unlock(&wp_queue->buffer_lock);
-}
-
-static int mtk_nanohub_fetch_next_wp(uint32_t *currWp)
-{
-	int have_event;
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	struct curr_wp_queue *wp_queue = &device->wp_queue;
-
-	spin_lock_irq(&wp_queue->buffer_lock);
-
-	have_event = wp_queue->head != wp_queue->tail;
-	if (have_event) {
-		*currWp = wp_queue->ringbuffer[wp_queue->tail++];
-		wp_queue->tail &= wp_queue->bufsize - 1;
-	}
-	spin_unlock_irq(&wp_queue->buffer_lock);
-	/* pr_err("head:%d, tail:%d, currWp:%d\n",
-	 * wp_queue->head, wp_queue->tail, *currWp);
-	 */
-	return have_event;
-}
-
-static int mtk_nanohub_read_wp_queue(void)
-{
-	uint32_t currWp = 0;
-
-	while (mtk_nanohub_fetch_next_wp(&currWp)) {
-		if (mtk_nanohub_server_dispatch_data(&currWp))
-			return -EFAULT;
-	}
-	return 0;
-}
-
-static void mtk_nanohub_sync_time_work(struct work_struct *work)
-
-{
-	mtk_nanohub_send_timestamp_to_hub();
-}
-
-static void mtk_nanohub_sync_time_func(unsigned long data)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-
-	schedule_work(&device->sync_time_worker);
-
-	mod_timer(&device->sync_time_timer,
-		jiffies +  msecs_to_jiffies(SYNC_TIME_CYCLC));
-}
-
-static int mtk_nanohub_direct_push_work(void *data)
-{
-	for (;;) {
-		wait_event(chre_kthread_wait,
-			READ_ONCE(chre_kthread_wait_condition));
-		WRITE_ONCE(chre_kthread_wait_condition, false);
-		mtk_nanohub_read_wp_queue();
-	}
-	return 0;
-}
-
-static void mtk_nanohub_common_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-					unsigned int rx_len)
-{
-	mtk_nanohub_ipi_complete((unsigned char *)rsp, rx_len);
-}
-
-static void mtk_nanohub_moving_average(union SCP_SENSOR_HUB_DATA *rsp)
-{
-	uint64_t ap_now_time = 0, arch_counter = 0;
-	uint64_t scp_raw_time = 0, scp_now_time = 0;
-	uint64_t ipi_transfer_time = 0;
-
-	if (!timekeeping_rtc_skipresume()) {
-		if (READ_ONCE(rtc_compensation_suspend))
-			return;
-	}
-	ap_now_time = ktime_get_boot_ns();
-	arch_counter = arch_counter_get_cntvct();
-	scp_raw_time = rsp->notify_rsp.scp_timestamp;
-	ipi_transfer_time = arch_counter_to_ns(arch_counter -
-		rsp->notify_rsp.arch_counter);
-	scp_now_time = scp_raw_time + ipi_transfer_time;
-	moving_average_filter(&moving_average_algo, ap_now_time, scp_now_time);
-}
-
-static void mtk_nanohub_notify_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-		unsigned int rx_len)
-{
-	unsigned long flags = 0;
-
-	switch (rsp->notify_rsp.event) {
-	case SCP_DIRECT_PUSH:
-	case SCP_FIFO_FULL:
-		mtk_nanohub_moving_average(rsp);
-		mtk_nanohub_write_wp_queue(rsp);
-		WRITE_ONCE(chre_kthread_wait_condition, true);
-		wake_up(&chre_kthread_wait);
-		break;
-	case SCP_NOTIFY:
-		break;
-	case SCP_INIT_DONE:
-		spin_lock_irqsave(&scp_state_lock, flags);
-		WRITE_ONCE(scp_chre_ready, true);
-		if (READ_ONCE(scp_system_ready) && READ_ONCE(scp_chre_ready)) {
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-			atomic_set(&power_status, SENSOR_POWER_UP);
-			//scp_power_monitor_notify(SENSOR_POWER_UP, NULL);
-			/* schedule_work(&device->power_up_work); */
-			wake_up(&power_reset_wait);
-		} else
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-		break;
-	default:
-		break;
-	}
-}
-
-static const struct mtk_nanohub_cmd mtk_nanohub_cmds[] = {
-	MTK_NANOHUB_CMD(SENSOR_HUB_NOTIFY,
-		mtk_nanohub_notify_cmd),
-	MTK_NANOHUB_CMD(SENSOR_HUB_GET_DATA,
-		mtk_nanohub_common_cmd),
-	MTK_NANOHUB_CMD(SENSOR_HUB_SET_CONFIG,
-		mtk_nanohub_common_cmd),
-	MTK_NANOHUB_CMD(SENSOR_HUB_SET_CUST,
-		mtk_nanohub_common_cmd),
-	MTK_NANOHUB_CMD(SENSOR_HUB_SET_TIMESTAMP,
-		mtk_nanohub_common_cmd),
-	MTK_NANOHUB_CMD(SENSOR_HUB_RAW_DATA,
-		mtk_nanohub_common_cmd),
-};
-
-const struct mtk_nanohub_cmd *
-mtk_nanohub_find_cmd(uint32_t packetReason)
-{
-	int i;
-	const struct mtk_nanohub_cmd *cmd;
-
-	for (i = 0; i < ARRAY_SIZE(mtk_nanohub_cmds); i++) {
-		cmd = &mtk_nanohub_cmds[i];
-		if (cmd->reason == packetReason)
-			return cmd;
-	}
-	return NULL;
-}
-
-static void mtk_nanohub_ipi_handler(int id,
-		void *data, unsigned int len)
-{
-	union SCP_SENSOR_HUB_DATA *rsp = (union SCP_SENSOR_HUB_DATA *)data;
-	const struct mtk_nanohub_cmd *cmd;
-
-	if (len > SENSOR_IPI_SIZE) {
-		pr_err("%s len=%d error\n", __func__, len);
-		return;
-	}
-	/*pr_err("sensorType:%d, action=%d event:%d len:%d\n",
-	 * rsp->rsp.sensorType, rsp->rsp.action, rsp->notify_rsp.event, len);
-	 */
-	cmd = mtk_nanohub_find_cmd(rsp->rsp.action);
-	if (cmd != NULL)
-		cmd->handler(rsp, len);
-	else
-		pr_err("cannot find cmd!\n");
-}
-
-static void mtk_nanohub_init_sensor_state(void)
-{
-	mSensorState[SENSOR_TYPE_ACCELEROMETER].sensorType =
-		SENSOR_TYPE_ACCELEROMETER;
-	mSensorState[SENSOR_TYPE_ACCELEROMETER].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GYROSCOPE].sensorType = SENSOR_TYPE_GYROSCOPE;
-	mSensorState[SENSOR_TYPE_GYROSCOPE].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD].sensorType =
-		SENSOR_TYPE_MAGNETIC_FIELD;
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_LIGHT].sensorType = SENSOR_TYPE_LIGHT;
-	mSensorState[SENSOR_TYPE_LIGHT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_PROXIMITY].sensorType = SENSOR_TYPE_PROXIMITY;
-	mSensorState[SENSOR_TYPE_PROXIMITY].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_PRESSURE].sensorType = SENSOR_TYPE_PRESSURE;
-	mSensorState[SENSOR_TYPE_PRESSURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_ORIENTATION].sensorType =
-		SENSOR_TYPE_ORIENTATION;
-	mSensorState[SENSOR_TYPE_ORIENTATION].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_ROTATION_VECTOR].sensorType =
-		SENSOR_TYPE_ROTATION_VECTOR;
-	mSensorState[SENSOR_TYPE_ROTATION_VECTOR].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GAME_ROTATION_VECTOR].sensorType =
-		SENSOR_TYPE_GAME_ROTATION_VECTOR;
-	mSensorState[SENSOR_TYPE_GAME_ROTATION_VECTOR].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR].sensorType =
-		SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR;
-	mSensorState[SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR].timestamp_filter =
-		true;
-
-	mSensorState[SENSOR_TYPE_LINEAR_ACCELERATION].sensorType =
-		SENSOR_TYPE_LINEAR_ACCELERATION;
-	mSensorState[SENSOR_TYPE_LINEAR_ACCELERATION].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GRAVITY].sensorType = SENSOR_TYPE_GRAVITY;
-	mSensorState[SENSOR_TYPE_GRAVITY].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_SIGNIFICANT_MOTION].sensorType =
-		SENSOR_TYPE_SIGNIFICANT_MOTION;
-	mSensorState[SENSOR_TYPE_SIGNIFICANT_MOTION].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_SIGNIFICANT_MOTION].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_STEP_COUNTER].sensorType =
-		SENSOR_TYPE_STEP_COUNTER;
-	mSensorState[SENSOR_TYPE_STEP_COUNTER].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_STEP_COUNTER].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_STEP_DETECTOR].sensorType =
-		SENSOR_TYPE_STEP_DETECTOR;
-	mSensorState[SENSOR_TYPE_STEP_DETECTOR].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_STEP_DETECTOR].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_TILT_DETECTOR].sensorType =
-		SENSOR_TYPE_TILT_DETECTOR;
-	mSensorState[SENSOR_TYPE_TILT_DETECTOR].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_TILT_DETECTOR].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_IN_POCKET].sensorType = SENSOR_TYPE_IN_POCKET;
-	mSensorState[SENSOR_TYPE_IN_POCKET].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_IN_POCKET].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_ACTIVITY].sensorType = SENSOR_TYPE_ACTIVITY;
-	mSensorState[SENSOR_TYPE_ACTIVITY].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_GLANCE_GESTURE].sensorType =
-		SENSOR_TYPE_GLANCE_GESTURE;
-	mSensorState[SENSOR_TYPE_GLANCE_GESTURE].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_GLANCE_GESTURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_PICK_UP_GESTURE].sensorType =
-		SENSOR_TYPE_PICK_UP_GESTURE;
-	mSensorState[SENSOR_TYPE_PICK_UP_GESTURE].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_PICK_UP_GESTURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_WAKE_GESTURE].sensorType =
-		SENSOR_TYPE_WAKE_GESTURE;
-	mSensorState[SENSOR_TYPE_WAKE_GESTURE].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_WAKE_GESTURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_ANSWER_CALL].sensorType =
-		SENSOR_TYPE_ANSWER_CALL;
-	mSensorState[SENSOR_TYPE_ANSWER_CALL].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_ANSWER_CALL].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_STATIONARY_DETECT].sensorType =
-		SENSOR_TYPE_STATIONARY_DETECT;
-	mSensorState[SENSOR_TYPE_STATIONARY_DETECT].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_STATIONARY_DETECT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_MOTION_DETECT].sensorType =
-		SENSOR_TYPE_MOTION_DETECT;
-	mSensorState[SENSOR_TYPE_MOTION_DETECT].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_MOTION_DETECT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_DEVICE_ORIENTATION].sensorType =
-		SENSOR_TYPE_DEVICE_ORIENTATION;
-	mSensorState[SENSOR_TYPE_DEVICE_ORIENTATION].rate =
-		SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_DEVICE_ORIENTATION].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_GEOFENCE].sensorType = SENSOR_TYPE_GEOFENCE;
-	mSensorState[SENSOR_TYPE_GEOFENCE].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_GEOFENCE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_FLOOR_COUNTER].sensorType =
-		SENSOR_TYPE_FLOOR_COUNTER;
-	mSensorState[SENSOR_TYPE_FLOOR_COUNTER].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_FLOOR_COUNTER].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_FLAT].sensorType = SENSOR_TYPE_FLAT;
-	mSensorState[SENSOR_TYPE_FLAT].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_FLAT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_RGBW].sensorType = SENSOR_TYPE_RGBW;
-	mSensorState[SENSOR_TYPE_RGBW].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_SAR].sensorType = SENSOR_TYPE_SAR;
-	mSensorState[SENSOR_TYPE_SAR].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_SAR].timestamp_filter = false;
-}
-
-static void init_sensor_config_cmd(struct ConfigCmd *cmd,
-		int sensor_type)
-{
-	uint8_t alt = mSensorState[sensor_type].alt;
-	bool enable = 0;
-
-	memset(cmd, 0x00, sizeof(*cmd));
-
-	cmd->evtType = EVT_NO_SENSOR_CONFIG_EVENT;
-	cmd->sensorType = mSensorState[sensor_type].sensorType;
-
-	if (alt && mSensorState[alt].enable &&
-			mSensorState[sensor_type].enable) {
-		cmd->cmd = CONFIG_CMD_ENABLE;
-		if (mSensorState[alt].rate > mSensorState[sensor_type].rate)
-			cmd->rate = mSensorState[alt].rate;
-		else
-			cmd->rate = mSensorState[sensor_type].rate;
-		if (mSensorState[alt].latency <
-				mSensorState[sensor_type].latency)
-			cmd->latency = mSensorState[alt].latency;
-		else
-			cmd->latency = mSensorState[sensor_type].latency;
-	} else if (alt && mSensorState[alt].enable) {
-		enable = mSensorState[alt].enable;
-		cmd->cmd =  enable ? CONFIG_CMD_ENABLE : CONFIG_CMD_DISABLE;
-		cmd->rate = mSensorState[alt].rate;
-		cmd->latency = mSensorState[alt].latency;
-	} else { /* !alt || !mSensorState[alt].enable */
-		enable = mSensorState[sensor_type].enable;
-		cmd->cmd = enable ? CONFIG_CMD_ENABLE : CONFIG_CMD_DISABLE;
-		cmd->rate = mSensorState[sensor_type].rate;
-		cmd->latency = mSensorState[sensor_type].latency;
-	}
-}
-
-static int mtk_nanohub_report_data(struct data_unit_t *data_t)
-{
-	int err = 0, sensor_type = 0, sensor_id = 0;
-
-	sensor_id = data_t->sensor_type;
-	sensor_type = id_to_type(sensor_id);
-	data_t->time_stamp += get_filter_output(&moving_average_algo);
-
-	if (sensor_id >= ID_SENSOR_MAX || sensor_id < 0) {
-		pr_err("invalid sensor id %d\n", sensor_id);
-		return 0;
-	}
-	/* must check report err for retry sending */
-	err = mtk_nanohub_report_to_manager(data_t);
-	/* for flush only !err true we decrease flushcnt */
-	if (data_t->flush_action == FLUSH_ACTION && !err)
-		atomic_dec_if_positive(&mSensorState[sensor_type].flushCnt);
-	return err;
-}
-static int mtk_nanohub_server_dispatch_data(uint32_t *currWp)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	char *pStart, *pEnd, *rp, *wp;
-	struct data_unit_t event, event_copy;
-	uint32_t wp_copy;
-	int err = 0;
-
-	pStart = (char *)READ_ONCE(device->scp_sensor_fifo) +
-		offsetof(struct sensor_fifo, data);
-	pEnd = pStart +  READ_ONCE(device->scp_sensor_fifo->fifo_size);
-	wp_copy = *currWp;
-	rp = pStart + READ_ONCE(device->scp_sensor_fifo->rp);
-	wp = pStart + wp_copy;
-
-
-	if (wp < pStart || pEnd < wp) {
-		pr_err("FIFO wp invalid : %p, %p, %p\n", pStart, pEnd, wp);
-		return -5;
-	}
-	if (rp == wp) {
-		pr_err("FIFO empty\n");
-		return 0;
-	}
-	/*
-	 * opimize for dram,no cache,we should cpy data to cacheable ram
-	 * event and event_copy are cacheable ram, mtk_nanohub_report_data
-	 * will change time_stamp field, so when mtk_nanohub_report_data fail
-	 * we should reinit the time_stamp by memcpy to event_copy;
-	 * why memcpy_fromio(&event_copy), because rp is not cacheable
-	 */
-	if (rp < wp) {
-		while (rp < wp) {
-			memcpy_fromio(&event, rp, SENSOR_DATA_SIZE);
-			/* sleep safe enough, data save in dram and not lost */
-			do {
-				/* init event_copy when retry */
-				event_copy = event;
-				err = mtk_nanohub_report_data(&event_copy);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-			rp += SENSOR_DATA_SIZE;
-		}
-	} else if (rp > wp) {
-		while (rp < pEnd) {
-			memcpy_fromio(&event, rp, SENSOR_DATA_SIZE);
-			do {
-				/* init event_copy when retry */
-				event_copy = event;
-				err = mtk_nanohub_report_data(&event_copy);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-			rp += SENSOR_DATA_SIZE;
-		}
-		rp = pStart;
-		while (rp < wp) {
-			memcpy_fromio(&event, rp, SENSOR_DATA_SIZE);
-			do {
-				/* init event_copy when retry */
-				event_copy = event;
-				err = mtk_nanohub_report_data(&event_copy);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-			rp += SENSOR_DATA_SIZE;
-		}
-	}
-	/*
-	 * must device->scp_sensor_fifo->rp = wp,
-	 * not device->scp_sensor_fifo->rp = device->scp_sensor_fifo->wp
-	 */
-	WRITE_ONCE(device->scp_sensor_fifo->rp, wp_copy);
-	return 0;
-}
-
-static int mtk_nanohub_send_dram_info_to_hub(void)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	union SCP_SENSOR_HUB_DATA data;
-	unsigned int len = 0;
-	int err = 0, retry = 0, total = 10;
-
-	device->shub_dram_phys = scp_get_reserve_mem_phys(SENS_MEM_ID);
-	device->shub_dram_virt = scp_get_reserve_mem_virt(SENS_MEM_ID);
-
-	data.set_config_req.sensorType = 0;
-	data.set_config_req.action = SENSOR_HUB_SET_CONFIG;
-	data.set_config_req.bufferBase =
-		(unsigned int)(device->shub_dram_phys & 0xFFFFFFFF);
-
-	len = sizeof(data.set_config_req);
-	for (retry = 0; retry < total; ++retry) {
-		err = mtk_nanohub_req_send(&data);
-		if (err < 0 || data.rsp.action != SENSOR_HUB_SET_CONFIG) {
-			pr_err("%s fail!\n", __func__);
-			continue;
-		}
-		break;
-	}
-	if (retry < total)
-		pr_notice("%s success\n", __func__);
-	return SCP_SENSOR_HUB_SUCCESS;
-}
-
-static int mtk_nanohub_enable_rawdata_to_hub(int sensor_id,
-		int en)
-{
-	int err = 0;
-	union SCP_SENSOR_HUB_DATA req;
-
-	req.req.sensorType = sensor_id;
-	req.req.action = SENSOR_HUB_RAW_DATA;
-	req.req.data[0] = en;
-
-	err = mtk_nanohub_req_send(&req);
-	if (err < 0 || sensor_id != req.rsp.sensorType ||
-			req.rsp.action != SENSOR_HUB_RAW_DATA) {
-		pr_err("%s fail!\n", __func__);
-		return -1;
-	}
-	return err;
-}
-
-static int mtk_nanohub_send_timestamp_wake_locked(void)
-{
-	union SCP_SENSOR_HUB_DATA req;
-	int len;
-	int err = 0;
-	uint64_t now_time, arch_counter;
-
-	/* send_timestamp_to_hub is process context, disable irq is safe */
-	local_irq_disable();
-	now_time = ktime_get_boot_ns();
-	arch_counter = arch_counter_get_cntvct();
-	local_irq_enable();
-	req.set_config_req.sensorType = 0;
-	req.set_config_req.action = SENSOR_HUB_SET_TIMESTAMP;
-	req.set_config_req.ap_timestamp = now_time;
-	req.set_config_req.arch_counter = arch_counter;
-	/* pr_err("ns=%lld, arch_counter=%lld!\n", now_time, arch_counter); */
-	len = sizeof(req.set_config_req);
-	err = mtk_nanohub_req_send(&req);
-	if (err < 0 || req.rsp.action != SENSOR_HUB_SET_TIMESTAMP) {
-		pr_err("%s fail!\n", __func__);
-		return -1;
-	}
-	return err;
-}
-
-static int mtk_nanohub_send_timestamp_to_hub(void)
-{
-	int err = 0;
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-
-	if (READ_ONCE(rtc_compensation_suspend)) {
-		pr_err("rtc_compensation_suspend suspend,drop time sync\n");
-		return 0;
-	}
-
-	__pm_stay_awake(&device->time_sync_wakeup_src);
-	err = mtk_nanohub_send_timestamp_wake_locked();
-	__pm_relax(&device->time_sync_wakeup_src);
-	return err;
-}
-
-int mtk_nanohub_enable_to_hub(uint8_t sensor_id, int enabledisable)
-{
-	uint8_t sensor_type = id_to_type(sensor_id);
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	if (enabledisable == 1)
-		scp_register_feature(SENS_FEATURE_ID);
-	mutex_lock(&mSensorState_mtx);
-	if (sensor_id >= ID_SENSOR_MAX) {
-		pr_err("invalid id %d\n", sensor_id);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	if (!mSensorState[sensor_type].sensorType) {
-		pr_err("unhandle id %d, is inited?\n", sensor_id);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	mSensorState[sensor_type].enable = enabledisable;
-	init_sensor_config_cmd(&cmd, sensor_type);
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_err("fail enable: [%d,%d]\n", sensor_id, cmd.cmd);
-	}
-	if (!enabledisable && atomic_read(&mSensorState[sensor_type].flushCnt))
-		pr_err("id=%d flush count not 0 when disable\n", sensor_id);
-	mutex_unlock(&mSensorState_mtx);
-	return ret < 0 ? ret : 0;
-}
-
-int mtk_nanohub_batch_to_hub(uint8_t sensor_id,
-		int flag, int64_t samplingPeriodNs,
-		int64_t maxBatchReportLatencyNs)
-{
-	uint8_t sensor_type = id_to_type(sensor_id);
-	struct ConfigCmd cmd;
-	int ret = 0;
-	uint64_t rate = 1024000000000ULL;
-
-	mutex_lock(&mSensorState_mtx);
-	if (sensor_id >= ID_SENSOR_MAX) {
-		pr_err("invalid id %d\n", sensor_id);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	if (!mSensorState[sensor_type].sensorType) {
-		pr_err("unhandle type %d, is inited?\n", sensor_type);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	if (samplingPeriodNs > 0 &&
-		mSensorState[sensor_type].rate != SENSOR_RATE_ONCHANGE &&
-		mSensorState[sensor_type].rate != SENSOR_RATE_ONESHOT) {
-		rate = div64_u64(rate, samplingPeriodNs);
-		mSensorState[sensor_type].rate = rate;
-	}
-	mSensorState[sensor_type].latency = maxBatchReportLatencyNs;
-	init_sensor_config_cmd(&cmd, sensor_type);
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_err("failed batch: [%d,%d,%lld,%d]\n",
-				sensor_id, cmd.rate, cmd.latency, cmd.cmd);
-	}
-	mutex_unlock(&mSensorState_mtx);
-	return ret < 0 ? ret : 0;
-}
-
-int mtk_nanohub_flush_to_hub(uint8_t sensor_id)
-{
-	uint8_t sensor_type = id_to_type(sensor_id);
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	mutex_lock(&mSensorState_mtx);
-	if (sensor_id >= ID_SENSOR_MAX) {
-		pr_err("invalid id %d\n", sensor_id);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	if (!mSensorState[sensor_type].sensorType) {
-		pr_err("unhandle id %d, is inited?\n", sensor_id);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	atomic_inc(&mSensorState[sensor_type].flushCnt);
-	init_sensor_config_cmd(&cmd, sensor_type);
-	cmd.cmd = CONFIG_CMD_FLUSH;
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_err("failed flush: [%d]\n", sensor_id);
-	}
-	mutex_unlock(&mSensorState_mtx);
-	return ret < 0 ? ret : 0;
-}
-
-int mtk_nanohub_cfg_to_hub(uint8_t sensor_id, uint8_t *data, uint8_t count)
-{
-	struct ConfigCmd *cmd = NULL;
-	int ret = 0;
-
-	if (sensor_id >= ID_SENSOR_MAX) {
-		pr_err("invalid id %d\n", sensor_id);
-		return -1;
-	}
-	cmd = vzalloc(sizeof(struct ConfigCmd) + count);
-	if (!cmd)
-		return -1;
-	cmd->evtType = EVT_NO_SENSOR_CONFIG_EVENT;
-	cmd->sensorType = id_to_type(sensor_id);
-	cmd->cmd = CONFIG_CMD_CFG_DATA;
-	memcpy(cmd->data, data, count);
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		ret = nanohub_external_write((const uint8_t *)cmd,
-			sizeof(struct ConfigCmd) + count);
-		if (ret < 0)
-			pr_err("failed cfg: [%d,%d]\n", sensor_id, cmd->cmd);
-	}
-	vfree(cmd);
-	return ret < 0 ? ret : 0;
-}
-
-int mtk_nanohub_calibration_to_hub(uint8_t sensor_id)
-{
-	uint8_t sensor_type = id_to_type(sensor_id);
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	if (sensor_id >= ID_SENSOR_MAX) {
-		pr_err("invalid id %d\n", sensor_id);
-		return -1;
-	}
-	if (!mSensorState[sensor_type].sensorType) {
-		pr_err("unhandle id %d, is inited?\n", sensor_id);
-		return -1;
-	}
-	init_sensor_config_cmd(&cmd, sensor_type);
-	cmd.cmd = CONFIG_CMD_CALIBRATE;
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_err("failed calibration: [%d]\n", sensor_id);
-	}
-	return ret < 0 ? ret : 0;
-}
-
-int mtk_nanohub_selftest_to_hub(uint8_t sensor_id)
-{
-	uint8_t sensor_type = id_to_type(sensor_id);
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	if (sensor_id >= ID_SENSOR_MAX) {
-		pr_err("invalid id %d\n", sensor_id);
-		return -1;
-	}
-	if (!mSensorState[sensor_type].sensorType) {
-		pr_err("unhandle id %d, is inited?\n", sensor_id);
-		return -1;
-	}
-	init_sensor_config_cmd(&cmd, sensor_type);
-	cmd.cmd = CONFIG_CMD_SELF_TEST;
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_err("failed selfttest: [%d]\n", sensor_id);
-	}
-	return ret < 0 ? ret : 0;
-}
-
-int mtk_nanohub_get_data_from_hub(uint8_t sensor_id,
-		struct data_unit_t *data)
-{
-	union SCP_SENSOR_HUB_DATA req;
-	struct data_unit_t *data_t;
-	int len = 0, err = 0;
-
-	if (atomic_read(&power_status) == SENSOR_POWER_DOWN) {
-		pr_err("scp power down, we can not access scp\n");
-		return -1;
-	}
-
-	req.get_data_req.sensorType = sensor_id;
-	req.get_data_req.action = SENSOR_HUB_GET_DATA;
-	len = sizeof(req.get_data_req);
-	err = mtk_nanohub_req_send(&req);
-	if (err < 0) {
-		pr_err("get_data fail:%d!\n", err);
-		return -1;
-	}
-	if (sensor_id != req.get_data_rsp.sensorType ||
-		req.get_data_rsp.action != SENSOR_HUB_GET_DATA ||
-		req.get_data_rsp.errCode != 0) {
-		pr_err("req id: %d, rsp Type:%d action:%d, errcode:%d\n",
-			sensor_id, req.get_data_rsp.sensorType,
-			req.get_data_rsp.action, req.get_data_rsp.errCode);
-
-		return req.get_data_rsp.errCode;
-	}
-
-	data_t = (struct data_unit_t *)req.get_data_rsp.data.int8_Data;
-	switch (sensor_id) {
-	case ID_ACCELEROMETER:
-		data->time_stamp = data_t->time_stamp;
-		data->accelerometer_t.x = data_t->accelerometer_t.x;
-		data->accelerometer_t.y = data_t->accelerometer_t.y;
-		data->accelerometer_t.z = data_t->accelerometer_t.z;
-		data->accelerometer_t.x_bias = data_t->accelerometer_t.x_bias;
-		data->accelerometer_t.y_bias = data_t->accelerometer_t.y_bias;
-		data->accelerometer_t.z_bias = data_t->accelerometer_t.z_bias;
-		data->accelerometer_t.status = data_t->accelerometer_t.status;
-		break;
-	case ID_LIGHT:
-		data->time_stamp = data_t->time_stamp;
-		data->light = data_t->light;
-		break;
-	case ID_PROXIMITY:
-		data->time_stamp = data_t->time_stamp;
-		data->proximity_t.steps = data_t->proximity_t.steps;
-		data->proximity_t.oneshot = data_t->proximity_t.oneshot;
-		break;
-	case ID_PRESSURE:
-		data->time_stamp = data_t->time_stamp;
-		data->pressure_t.pressure = data_t->pressure_t.pressure;
-		data->pressure_t.status = data_t->pressure_t.status;
-		break;
-	case ID_GYROSCOPE:
-		data->time_stamp = data_t->time_stamp;
-		data->gyroscope_t.x = data_t->gyroscope_t.x;
-		data->gyroscope_t.y = data_t->gyroscope_t.y;
-		data->gyroscope_t.z = data_t->gyroscope_t.z;
-		data->gyroscope_t.x_bias = data_t->gyroscope_t.x_bias;
-		data->gyroscope_t.y_bias  = data_t->gyroscope_t.y_bias;
-		data->gyroscope_t.z_bias  = data_t->gyroscope_t.z_bias;
-		data->gyroscope_t.status = data_t->gyroscope_t.status;
-		break;
-	case ID_MAGNETIC_FIELD:
-		data->time_stamp = data_t->time_stamp;
-		data->magnetic_t.x = data_t->magnetic_t.x;
-		data->magnetic_t.y = data_t->magnetic_t.y;
-		data->magnetic_t.z = data_t->magnetic_t.z;
-		data->magnetic_t.x_bias = data_t->magnetic_t.x_bias;
-		data->magnetic_t.y_bias = data_t->magnetic_t.y_bias;
-		data->magnetic_t.z_bias = data_t->magnetic_t.z_bias;
-		data->magnetic_t.status = data_t->magnetic_t.status;
-		break;
-	case ID_SAR:
-		data->time_stamp = data_t->time_stamp;
-		data->sar_event.data[0] = data_t->sar_event.data[0];
-		data->sar_event.data[1] = data_t->sar_event.data[1];
-		data->sar_event.data[2] = data_t->sar_event.data[2];
-		break;
-	default:
-		err = -1;
-		break;
-	}
-	return err;
-}
-
-int mtk_nanohub_set_cmd_to_hub(uint8_t sensor_id,
-		enum CUST_ACTION action, void *data)
-{
-	union SCP_SENSOR_HUB_DATA req;
-	int len = 0, err = 0;
-	struct SCP_SENSOR_HUB_GET_RAW_DATA *pGetRawData;
-
-	req.get_data_req.sensorType = sensor_id;
-	req.get_data_req.action = SENSOR_HUB_SET_CUST;
-
-	if (atomic_read(&power_status) == SENSOR_POWER_DOWN) {
-		pr_err("scp power down, we can not access scp\n");
-		return -1;
-	}
-
-	switch (sensor_id) {
-	case ID_ACCELEROMETER:
-		req.set_cust_req.sensorType = ID_ACCELEROMETER;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_RESET_CALI:
-			req.set_cust_req.resetCali.action =
-				CUST_ACTION_RESET_CALI;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.resetCali);
-			break;
-		case CUST_ACTION_SET_CALI:
-			req.set_cust_req.setCali.action = CUST_ACTION_SET_CALI;
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_X]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_X);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Y]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Y);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Z]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Z);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setCali);
-			break;
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SET_DIRECTION:
-			req.set_cust_req.setDirection.action =
-				CUST_ACTION_SET_DIRECTION;
-			req.set_cust_req.setDirection.direction =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			     custData) + sizeof(req.set_cust_req.setDirection);
-			break;
-		case CUST_ACTION_SET_FACTORY:
-			req.set_cust_req.setFactory.action =
-				CUST_ACTION_SET_FACTORY;
-			req.set_cust_req.setFactory.factory =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setFactory);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_LIGHT:
-		req.set_cust_req.sensorType = ID_LIGHT;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_GET_RAW_DATA:
-			req.set_cust_req.getRawData.action =
-				CUST_ACTION_GET_RAW_DATA;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getRawData);
-			err = mtk_nanohub_req_send(&req);
-			if (err == 0) {
-				if ((req.set_cust_rsp.action !=
-					SENSOR_HUB_SET_CUST)
-					|| (req.set_cust_rsp.errCode != 0)) {
-					pr_err("get_raw fail!\n");
-					return -1;
-				}
-				if (req.set_cust_rsp.getRawData.action !=
-					CUST_ACTION_GET_RAW_DATA) {
-					pr_err("get_raw fail!\n");
-					return -1;
-				}
-				pGetRawData = &req.set_cust_rsp.getRawData;
-				*((uint8_t *) data) =
-					pGetRawData->uint8_data[0];
-			} else {
-				pr_err("get_raw failed!\n");
-			}
-			return 0;
-		case CUST_ACTION_SHOW_ALSLV:
-			req.set_cust_req.showAlslv.action =
-				CUST_ACTION_SHOW_ALSLV;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showAlslv);
-			break;
-		case CUST_ACTION_SHOW_ALSVAL:
-			req.set_cust_req.showAlsval.action =
-				CUST_ACTION_GET_RAW_DATA;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showAlsval);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_PROXIMITY:
-		req.set_cust_req.sensorType = ID_PROXIMITY;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_RESET_CALI:
-			req.set_cust_req.resetCali.action =
-				CUST_ACTION_RESET_CALI;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.resetCali);
-			break;
-		case CUST_ACTION_SET_CALI:
-			req.set_cust_req.setCali.action = CUST_ACTION_SET_CALI;
-			req.set_cust_req.setCali.int32_data[0] =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setCali);
-			break;
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_SET_PS_THRESHOLD:
-			req.set_cust_req.setPSThreshold.action =
-				CUST_ACTION_SET_PS_THRESHOLD;
-			req.set_cust_req.setPSThreshold.threshold[0]
-			    = *((int32_t *) data + 0);
-			req.set_cust_req.setPSThreshold.threshold[1]
-			    = *((int32_t *) data + 1);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			    custData) + sizeof(req.set_cust_req.setPSThreshold);
-			break;
-		case CUST_ACTION_GET_RAW_DATA:
-			req.set_cust_req.getRawData.action =
-				CUST_ACTION_GET_RAW_DATA;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getRawData);
-			err = mtk_nanohub_req_send(&req);
-			if (err == 0) {
-				if ((req.set_cust_rsp.action !=
-					SENSOR_HUB_SET_CUST)
-					|| (req.set_cust_rsp.errCode != 0)) {
-					pr_err("get_raw fail!\n");
-					return -1;
-				}
-				if (req.set_cust_rsp.getRawData.action !=
-					CUST_ACTION_GET_RAW_DATA) {
-					pr_err("get_raw fail!\n");
-					return -1;
-				}
-				pGetRawData = &req.set_cust_rsp.getRawData;
-				*((uint16_t *) data) =
-					pGetRawData->uint16_data[0];
-			} else {
-				pr_err("get_raw failed!\n");
-			}
-			return 0;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_PRESSURE:
-		req.set_cust_req.sensorType = ID_PRESSURE;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_GYROSCOPE:
-		req.set_cust_req.sensorType = ID_GYROSCOPE;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_RESET_CALI:
-			req.set_cust_req.resetCali.action =
-				CUST_ACTION_RESET_CALI;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.resetCali);
-			break;
-		case CUST_ACTION_SET_CALI:
-			req.set_cust_req.setCali.action = CUST_ACTION_SET_CALI;
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_X]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_X);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Y]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Y);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Z]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Z);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setCali);
-			break;
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SET_DIRECTION:
-			req.set_cust_req.setDirection.action =
-				CUST_ACTION_SET_DIRECTION;
-			req.set_cust_req.setDirection.direction =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			     custData) + sizeof(req.set_cust_req.setDirection);
-			break;
-		case CUST_ACTION_SET_FACTORY:
-			req.set_cust_req.setFactory.action =
-				CUST_ACTION_SET_FACTORY;
-			req.set_cust_req.setFactory.factory =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setFactory);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action =
-				CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_MAGNETIC_FIELD:
-		req.set_cust_req.sensorType = ID_MAGNETIC_FIELD;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SET_DIRECTION:
-			req.set_cust_req.setDirection.action =
-				CUST_ACTION_SET_DIRECTION;
-			req.set_cust_req.setDirection.direction =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			     custData) + sizeof(req.set_cust_req.setDirection);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_SAR:
-		req.set_cust_req.sensorType = ID_SAR;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	default:
-		req.set_cust_req.sensorType = sensor_id;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		default:
-			return -1;
-		}
-	}
-	err = mtk_nanohub_req_send(&req);
-	if (err < 0) {
-		pr_err("set_cust fail!\n");
-		return -1;
-	}
-	if (sensor_id != req.get_data_rsp.sensorType
-		|| SENSOR_HUB_SET_CUST != req.get_data_rsp.action
-		|| 0 != req.get_data_rsp.errCode) {
-		pr_err("error : %d\n", req.get_data_rsp.errCode);
-		return req.get_data_rsp.errCode;
-	}
-
-	switch (action) {
-	case CUST_ACTION_GET_SENSOR_INFO:
-		if (req.set_cust_rsp.getInfo.action !=
-			CUST_ACTION_GET_SENSOR_INFO) {
-			pr_info("get_info failed!\n");
-			return -1;
-		}
-		memcpy((struct sensorInfo_t *)data,
-			&req.set_cust_rsp.getInfo.sensorInfo,
-			sizeof(struct sensorInfo_t));
-		break;
-	default:
-		break;
-	}
-	return err;
-}
-
-static void mtk_nanohub_restoring_sensor(int sensor_id)
-{
-	uint8_t sensor_type = id_to_type(sensor_id);
-	int ret = 0;
-	int flush_cnt = 0;
-	struct ConfigCmd cmd;
-
-	if (mSensorState[sensor_type].sensorType &&
-			mSensorState[sensor_type].enable) {
-		init_sensor_config_cmd(&cmd, sensor_type);
-		pr_debug("restoring: [%d,%d,%d,%lld]\n",
-			sensor_id, mSensorState[sensor_type].enable,
-			mSensorState[sensor_type].rate,
-			mSensorState[sensor_type].latency);
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_notice("failed registerlistener [%d,%d]\n",
-				sensor_id, cmd.cmd);
-
-		cmd.cmd = CONFIG_CMD_FLUSH;
-		for (flush_cnt = 0; flush_cnt <
-			atomic_read(&mSensorState[sensor_type].flushCnt);
-				flush_cnt++) {
-			ret = nanohub_external_write((const uint8_t *)&cmd,
-				sizeof(struct ConfigCmd));
-			if (ret < 0)
-				pr_notice("failed flush:%d\n", sensor_id);
-		}
-	}
-}
-
-static void mtk_nanohub_get_devinfo(void)
-{
-	int id = 0, sensor = 0;
-	struct sensorInfo_t hubinfo;
-	struct sensorlist_info_t listinfo;
-	struct mag_libinfo_t maginfo;
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-
-	if (likely(atomic_xchg(&device->get_list_first_boot, 1)))
-		return;
-
-	for (id = 0; id < ID_SENSOR_MAX; ++id) {
-		sensor = id_to_type(id);
-		if (sensorlist_find_sensor(sensor) < 0)
-			continue;
-		memset(&hubinfo, 0, sizeof(struct sensorInfo_t));
-		if (mtk_nanohub_set_cmd_to_hub(id,
-				CUST_ACTION_GET_SENSOR_INFO, &hubinfo) < 0) {
-			pr_err("type(%d) not registered\n", sensor);
-			continue;
-		}
-		memset(&listinfo, 0, sizeof(struct sensorlist_info_t));
-		strlcpy(listinfo.name, hubinfo.name, sizeof(listinfo.name));
-		sensorlist_register_devinfo(sensor, &listinfo);
-		/* restore mag lib info */
-		if (sensor == SENSOR_TYPE_MAGNETIC_FIELD) {
-			memset(&maginfo, 0, sizeof(struct mag_libinfo_t));
-			maginfo.deviceid = hubinfo.mag_dev_info.deviceid;
-			maginfo.layout = hubinfo.mag_dev_info.layout;
-			strlcpy(maginfo.libname, hubinfo.mag_dev_info.libname,
-					sizeof(maginfo.libname));
-			sensorlist_register_maginfo(&maginfo);
-		}
-	}
-}
-
-static void mtk_nanohub_restoring_config(void)
-{
-	int length = 0;
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	uint8_t *data = NULL;
-
-	if (unlikely(!atomic_xchg(&device->cfg_data_after_reboot, 1)))
-		return;
-
-	pr_notice("restoring sensor config\n");
-
-	length = sizeof(device->acc_config_data);
-	data = vzalloc(length);
-	spin_lock(&config_data_lock);
-	memcpy(data, device->acc_config_data, length);
-	spin_unlock(&config_data_lock);
-	mtk_nanohub_cfg_to_hub(ID_ACCELEROMETER, data, length);
-	vfree(data);
-
-	length = sizeof(device->gyro_config_data);
-	data = vzalloc(length);
-	spin_lock(&config_data_lock);
-	memcpy(data, device->gyro_config_data, length);
-	spin_unlock(&config_data_lock);
-	mtk_nanohub_cfg_to_hub(ID_GYROSCOPE, data, length);
-	vfree(data);
-
-	length = sizeof(device->mag_config_data);
-	data = vzalloc(length);
-	spin_lock(&config_data_lock);
-	memcpy(data, device->mag_config_data, length);
-	spin_unlock(&config_data_lock);
-	mtk_nanohub_cfg_to_hub(ID_MAGNETIC_FIELD, data, length);
-	vfree(data);
-
-	length = sizeof(device->light_config_data);
-	data = vzalloc(length);
-	spin_lock(&config_data_lock);
-	memcpy(data, device->light_config_data, length);
-	spin_unlock(&config_data_lock);
-	mtk_nanohub_cfg_to_hub(ID_LIGHT, data, length);
-	vfree(data);
-
-	length = sizeof(device->proximity_config_data);
-	data = vzalloc(length);
-	spin_lock(&config_data_lock);
-	memcpy(data, device->proximity_config_data, length);
-	spin_unlock(&config_data_lock);
-	mtk_nanohub_cfg_to_hub(ID_PROXIMITY, data, length);
-	vfree(data);
-}
-
-static void mtk_nanohub_start_timesync(void)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-
-	if (likely(atomic_xchg(&device->start_timesync_first_boot, 1)))
-		return;
-
-	mod_timer(&device->sync_time_timer,
-		jiffies + msecs_to_jiffies(SYNC_TIME_START_CYCLC));
-}
-
-void mtk_nanohub_power_up_loop(void *data)
-{
-	int id = 0;
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	unsigned long flags = 0;
-
-	wait_event(power_reset_wait,
-		READ_ONCE(scp_system_ready) && READ_ONCE(scp_chre_ready));
-	spin_lock_irqsave(&scp_state_lock, flags);
-	WRITE_ONCE(scp_chre_ready, false);
-	WRITE_ONCE(scp_system_ready, false);
-	spin_unlock_irqrestore(&scp_state_lock, flags);
-
-	/* firstly we should update dram information */
-	/* 1. reset wp queue head and tail */
-	device->wp_queue.head = 0;
-	device->wp_queue.tail = 0;
-	/* 2. init dram information */
-	WRITE_ONCE(device->scp_sensor_fifo,
-		(struct sensor_fifo *)
-		(long)scp_get_reserve_mem_virt(SENS_MEM_ID));
-	WARN_ON(device->scp_sensor_fifo == NULL);
-	WRITE_ONCE(device->scp_sensor_fifo->wp, 0);
-	WRITE_ONCE(device->scp_sensor_fifo->rp, 0);
-	WRITE_ONCE(device->scp_sensor_fifo->fifo_size,
-		((long)scp_get_reserve_mem_size(SENS_MEM_ID) -
-			offsetof(struct sensor_fifo, data)) /
-				SENSOR_DATA_SIZE * SENSOR_DATA_SIZE);
-	pr_debug("scp_sensor_fifo =%p, wp =%d, rp =%d, size =%d\n",
-		READ_ONCE(device->scp_sensor_fifo),
-		READ_ONCE(device->scp_sensor_fifo->wp),
-		READ_ONCE(device->scp_sensor_fifo->rp),
-		READ_ONCE(device->scp_sensor_fifo->fifo_size));
-	/* 3. send dram information to scp */
-	mtk_nanohub_send_dram_info_to_hub();
-	/* 4. get device info for mag lib and dynamic list */
-	mtk_nanohub_get_devinfo();
-	/* 5. start timesync */
-	mtk_nanohub_start_timesync();
-	/* 6. we restore sensor calibration data when scp reboot */
-	mtk_nanohub_restoring_config();
-	/* 7. we enable sensor which sensor is enable by framework */
-	mutex_lock(&mSensorState_mtx);
-	for (id = 0; id < ID_SENSOR_MAX; id++)
-		mtk_nanohub_restoring_sensor(id);
-	mutex_unlock(&mSensorState_mtx);
-}
-
-static int mtk_nanohub_power_up_work(void *data)
-{
-	for (;;)
-		mtk_nanohub_power_up_loop(data);
-	return 0;
-}
-
-static int mtk_nanohub_ready_event(struct notifier_block *this,
-	unsigned long event, void *ptr)
-{
-	unsigned long flags = 0;
-
-	if (event == SCP_EVENT_STOP) {
-		spin_lock_irqsave(&scp_state_lock, flags);
-		WRITE_ONCE(scp_system_ready, false);
-		spin_unlock_irqrestore(&scp_state_lock, flags);
-		atomic_set(&power_status, SENSOR_POWER_DOWN);
-		//scp_power_monitor_notify(SENSOR_POWER_DOWN, ptr);
-	}
-
-	if (event == SCP_EVENT_READY) {
-		spin_lock_irqsave(&scp_state_lock, flags);
-		WRITE_ONCE(scp_system_ready, true);
-		if (READ_ONCE(scp_system_ready) && READ_ONCE(scp_chre_ready)) {
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-			atomic_set(&power_status, SENSOR_POWER_UP);
-			//scp_power_monitor_notify(SENSOR_POWER_UP, ptr);
-			/* schedule_work(&device->power_up_work); */
-			wake_up(&power_reset_wait);
-		} else
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-	}
-
-	return NOTIFY_DONE;
-}
-
-static struct notifier_block mtk_nanohub_ready_notifier = {
-	.notifier_call = mtk_nanohub_ready_event,
-};
-
-static int mtk_nanohub_enable(struct hf_device *hfdev,
-		int sensor_type, int en)
-{
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d,%d]\n", __func__, sensor_type, en);
-	return mtk_nanohub_enable_to_hub(type_to_id(sensor_type), en);
-}
-
-static int mtk_nanohub_batch(struct hf_device *hfdev,
-		int sensor_type, int64_t delay, int64_t latency)
-{
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d,%lld,%lld]\n", __func__, sensor_type, delay, latency);
-	return mtk_nanohub_batch_to_hub(type_to_id(sensor_type),
-		0, delay, latency);
-}
-
-static int mtk_nanohub_flush(struct hf_device *hfdev,
-		int sensor_type)
-{
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d]\n", __func__, sensor_type);
-	return mtk_nanohub_flush_to_hub(type_to_id(sensor_type));
-}
-
-static int mtk_nanohub_calibration(struct hf_device *hfdev,
-		int sensor_type)
-{
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d]\n", __func__, sensor_type);
-	return mtk_nanohub_calibration_to_hub(type_to_id(sensor_type));
-}
-
-static int mtk_nanohub_config(struct hf_device *hfdev,
-		int sensor_type, int32_t *data)
-{
-	int length = 0;
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d]\n", __func__, sensor_type);
-	switch (type_to_id(sensor_type)) {
-	case ID_ACCELEROMETER:
-		length = sizeof(device->acc_config_data);
-		spin_lock(&config_data_lock);
-		memcpy(device->acc_config_data, data, length);
-		spin_unlock(&config_data_lock);
-		break;
-	case ID_GYROSCOPE:
-		length = sizeof(device->gyro_config_data);
-		spin_lock(&config_data_lock);
-		memcpy(device->gyro_config_data, data, length);
-		spin_unlock(&config_data_lock);
-		break;
-	case ID_MAGNETIC_FIELD:
-		length = sizeof(device->mag_config_data);
-		spin_lock(&config_data_lock);
-		memcpy(device->mag_config_data, data, length);
-		spin_unlock(&config_data_lock);
-		break;
-	case ID_LIGHT:
-		length = sizeof(device->light_config_data);
-		spin_lock(&config_data_lock);
-		memcpy(device->light_config_data, data, length);
-		spin_unlock(&config_data_lock);
-		break;
-	case ID_PROXIMITY:
-		length = sizeof(device->proximity_config_data);
-		spin_lock(&config_data_lock);
-		memcpy(device->proximity_config_data, data, length);
-		spin_unlock(&config_data_lock);
-		break;
-	}
-	if (!length) {
-		pr_err("%s type(%d) length fail\n", __func__, sensor_type);
-		return 0;
-	}
-	return mtk_nanohub_cfg_to_hub(type_to_id(sensor_type),
-		(uint8_t *)data, length);
-}
-
-static int mtk_nanohub_selftest(struct hf_device *hfdev,
-		int sensor_type)
-{
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d]\n", __func__, sensor_type);
-	return mtk_nanohub_selftest_to_hub(type_to_id(sensor_type));
-}
-
-static int mtk_nanohub_rawdata(struct hf_device *hfdev,
-		int sensor_type, int en)
-{
-	if (sensor_type <= 0)
-		return 0;
-	pr_notice("%s [%d,%d]\n", __func__, sensor_type, en);
-	return mtk_nanohub_enable_rawdata_to_hub(type_to_id(sensor_type), en);
-}
-
-static int mtk_nanohub_report_to_manager(struct data_unit_t *data)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	struct hf_manager *manager = mtk_nanohub_dev->hf_dev.manager;
-	struct hf_manager_event event;
-
-	if (!manager)
-		return 0;
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	if (data->flush_action == DATA_ACTION) {
-		switch (data->sensor_type) {
-		case ID_ACCELEROMETER:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->accelerometer_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->accelerometer_t.x;
-			event.word[1] = data->accelerometer_t.y;
-			event.word[2] = data->accelerometer_t.z;
-			event.word[3] = data->accelerometer_t.x_bias;
-			event.word[4] = data->accelerometer_t.y_bias;
-			event.word[5] = data->accelerometer_t.z_bias;
-			break;
-		case ID_MAGNETIC_FIELD:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->magnetic_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->magnetic_t.x;
-			event.word[1] = data->magnetic_t.y;
-			event.word[2] = data->magnetic_t.z;
-			event.word[3] = data->magnetic_t.x_bias;
-			event.word[4] = data->magnetic_t.y_bias;
-			event.word[5] = data->magnetic_t.z_bias;
-			break;
-		case ID_GYROSCOPE:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->gyroscope_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->gyroscope_t.x;
-			event.word[1] = data->gyroscope_t.y;
-			event.word[2] = data->gyroscope_t.z;
-			event.word[3] = data->gyroscope_t.x_bias;
-			event.word[4] = data->gyroscope_t.y_bias;
-			event.word[5] = data->gyroscope_t.z_bias;
-			break;
-		case ID_LIGHT:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->light;
-			break;
-		case ID_PROXIMITY:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->proximity_t.oneshot;
-			event.word[1] = data->proximity_t.steps;
-			break;
-		case ID_PRESSURE:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.accurancy = data->pressure_t.status;
-			event.word[0] = data->pressure_t.pressure;
-			break;
-		case ID_ORIENTATION:
-		case ID_ROTATION_VECTOR:
-		case ID_GAME_ROTATION_VECTOR:
-		case ID_GEOMAGNETIC_ROTATION_VECTOR:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->orientation_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->orientation_t.azimuth;
-			event.word[1] = data->orientation_t.pitch;
-			event.word[2] = data->orientation_t.roll;
-			event.word[3] = data->orientation_t.scalar;
-			break;
-		case ID_LINEAR_ACCELERATION:
-		case ID_GRAVITY:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->accelerometer_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->accelerometer_t.x;
-			event.word[1] = data->accelerometer_t.y;
-			event.word[2] = data->accelerometer_t.z;
-			break;
-		case ID_STEP_COUNTER:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] =
-				data->step_counter_t.accumulated_step_count;
-			break;
-		case ID_STEP_DETECTOR:
-		case ID_SIGNIFICANT_MOTION:
-		case ID_ANSWER_CALL:
-		case ID_FLAT:
-		case ID_GLANCE_GESTURE:
-		case ID_IN_POCKET:
-		case ID_MOTION_DETECT:
-		case ID_PICK_UP_GESTURE:
-		case ID_STATIONARY_DETECT:
-		case ID_WAKE_GESTURE:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->smd_t.state;
-			break;
-		case ID_TILT_DETECTOR:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->tilt_event.state;
-			break;
-		case ID_DEVICE_ORIENTATION:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->tilt_event.state;
-			break;
-		case ID_SAR:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->sar_event.data[0];
-			event.word[1] = data->sar_event.data[1];
-			event.word[2] = data->sar_event.data[2];
-			break;
-		default:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->data[0];
-			event.word[1] = data->data[1];
-			event.word[2] = data->data[2];
-			event.word[3] = data->data[3];
-			event.word[4] = data->data[4];
-			event.word[5] = data->data[5];
-			break;
-		}
-	} else if (data->flush_action == FLUSH_ACTION) {
-		event.timestamp = data->time_stamp;
-		event.sensor_type = id_to_type(data->sensor_type);
-		event.action = data->flush_action;
-		event.word[0] = data->data[0];
-		event.word[1] = data->data[1];
-		event.word[2] = data->data[2];
-		event.word[3] = data->data[3];
-		event.word[4] = data->data[4];
-		event.word[5] = data->data[5];
-		pr_notice("%s [%d] flush complete\n",
-					__func__, event.sensor_type);
-	} else if (data->flush_action == BIAS_ACTION) {
-		event.timestamp = data->time_stamp;
-		event.sensor_type = id_to_type(data->sensor_type);
-		event.action = data->flush_action;
-		switch (data->sensor_type) {
-		case ID_ACCELEROMETER:
-			event.word[0] = data->accelerometer_t.x_bias;
-			event.word[1] = data->accelerometer_t.y_bias;
-			event.word[2] = data->accelerometer_t.z_bias;
-			break;
-		case ID_MAGNETIC_FIELD:
-			event.word[0] = data->magnetic_t.x_bias;
-			event.word[1] = data->magnetic_t.y_bias;
-			event.word[2] = data->magnetic_t.z_bias;
-			break;
-		case ID_GYROSCOPE:
-			event.word[0] = data->gyroscope_t.x_bias;
-			event.word[1] = data->gyroscope_t.y_bias;
-			event.word[2] = data->gyroscope_t.z_bias;
-			break;
-		}
-	} else if (data->flush_action == CALI_ACTION) {
-		event.timestamp = data->time_stamp;
-		event.sensor_type = id_to_type(data->sensor_type);
-		event.action = data->flush_action;
-		switch (data->sensor_type) {
-		case ID_ACCELEROMETER:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->accelerometer_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->accelerometer_t.x_bias;
-			event.word[1] = data->accelerometer_t.y_bias;
-			event.word[2] = data->accelerometer_t.z_bias;
-			break;
-		case ID_GYROSCOPE:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->gyroscope_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->gyroscope_t.x_bias;
-			event.word[1] = data->gyroscope_t.y_bias;
-			event.word[2] = data->gyroscope_t.z_bias;
-			break;
-		case ID_PROXIMITY:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->data[0];
-			event.word[1] = data->data[1];
-			break;
-		case ID_LIGHT:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->data[0];
-			break;
-		}
-	} else if (data->flush_action == TEMP_ACTION) {
-		event.timestamp = data->time_stamp;
-		event.sensor_type = id_to_type(data->sensor_type);
-		event.action = data->flush_action;
-		switch (data->sensor_type) {
-		case ID_GYROSCOPE:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.accurancy = data->gyroscope_t.status;
-			event.action = data->flush_action;
-			event.word[0] = data->data[0];
-			event.word[1] = data->data[1];
-			event.word[2] = data->data[2];
-			event.word[3] = data->data[3];
-			event.word[4] = data->data[4];
-			event.word[5] = data->data[5];
-			break;
-		}
-	} else if (data->flush_action == TEST_ACTION) {
-		event.timestamp = data->time_stamp;
-		event.sensor_type = id_to_type(data->sensor_type);
-		event.action = data->flush_action;
-		switch (data->sensor_type) {
-		case ID_ACCELEROMETER:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->accelerometer_t.status;
-			break;
-		case ID_MAGNETIC_FIELD:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->magnetic_t.status;
-			break;
-		case ID_GYROSCOPE:
-			event.timestamp = data->time_stamp;
-			event.sensor_type = id_to_type(data->sensor_type);
-			event.action = data->flush_action;
-			event.word[0] = data->gyroscope_t.status;
-			break;
-		}
-	} else {
-		event.timestamp = data->time_stamp;
-		event.sensor_type = id_to_type(data->sensor_type);
-		event.action = data->flush_action;
-		event.word[0] = data->data[0];
-		event.word[1] = data->data[1];
-		event.word[2] = data->data[2];
-		event.word[3] = data->data[3];
-		event.word[4] = data->data[4];
-		event.word[5] = data->data[5];
-	}
-	/*
-	 * oneshot proximity tiledetect should wakeup source when data action
-	 */
-	if (data->flush_action == DATA_ACTION) {
-		if (data->sensor_type == ID_PROXIMITY ||
-			data->sensor_type == ID_TILT_DETECTOR ||
-			mSensorState[id_to_type(data->sensor_type)].rate ==
-				SENSOR_RATE_ONESHOT) {
-			__pm_wakeup_event(&device->data_notify_wakeup_src,
-				250);
-		}
-	}
-	return manager->report(manager, &event);
-}
-
-static int mtk_nanohub_get_sensor_state(unsigned char *list,
-		int size)
-{
-	int i = 0, j = 0;
-	int count = ARRAY_SIZE(mSensorState);
-
-	count = (count < size) ? count : size;
-	for (i = 0; i < count; ++i) {
-		if (!mSensorState[i].sensorType)
-			continue;
-		list[j++] = mSensorState[i].sensorType;
-	}
-	return j;
-}
-
-static int mtk_nanohub_pm_event(struct notifier_block *notifier,
-	unsigned long pm_event,
-			void *unused)
-{
-	switch (pm_event) {
-	case PM_POST_SUSPEND:
-		pr_debug("resume boottime=%lld\n", ktime_get_boot_ns());
-		WRITE_ONCE(rtc_compensation_suspend, false);
-		mtk_nanohub_send_timestamp_to_hub();
-		return NOTIFY_DONE;
-	case PM_SUSPEND_PREPARE:
-		pr_debug("suspend boottime=%lld\n", ktime_get_boot_ns());
-		WRITE_ONCE(rtc_compensation_suspend, true);
-		return NOTIFY_DONE;
-	default:
-		return NOTIFY_OK;
-	}
-	return NOTIFY_OK;
-}
-
-static struct notifier_block mtk_nanohub_pm_notifier_func = {
-	.notifier_call = mtk_nanohub_pm_event,
-	.priority = 0,
-};
-
-static int mtk_nanohub_create_manager(void)
-{
-	int err = 0;
-	int support_size = 0;
-	struct hf_device *hf_dev = &mtk_nanohub_dev->hf_dev;
-
-	memset(hf_dev, 0, sizeof(*hf_dev));
-
-	support_size = mtk_nanohub_get_sensor_state(support_sensors,
-				ARRAY_SIZE(support_sensors));
-
-	hf_dev->dev_name = "mtk_nanohub";
-	hf_dev->device_poll = HF_DEVICE_IO_INTERRUPT;
-	hf_dev->device_bus = HF_DEVICE_IO_ASYNC;
-	hf_dev->support_list = support_sensors;
-	hf_dev->support_size = support_size;
-	hf_dev->enable = mtk_nanohub_enable;
-	hf_dev->batch = mtk_nanohub_batch;
-	hf_dev->flush = mtk_nanohub_flush;
-	hf_dev->calibration = mtk_nanohub_calibration;
-	hf_dev->config_cali = mtk_nanohub_config;
-	hf_dev->selftest = mtk_nanohub_selftest;
-	hf_dev->rawdata = mtk_nanohub_rawdata;
-
-	err = hf_manager_create(hf_dev);
-	if (err < 0) {
-		pr_err("%s hf_manager_create fail\n", __func__);
-		return err;
-	}
-	return err;
-}
-
-static ssize_t mtk_nanohub_trace_show(struct device_driver *ddri,
-		char *buf)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	int i;
-	ssize_t res = 0;
-
-	for (i = 0; i < ID_SENSOR_MAX; i++)
-		res += snprintf(&buf[res], PAGE_SIZE, "%2d:[%d]\n",
-			i, atomic_read(&device->traces[i]));
-	return res;
-}
-
-static ssize_t mtk_nanohub_trace_store(struct device_driver *ddri,
-		const char *buf, size_t count)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-	int id, trace = 0;
-	int res = 0;
-
-	if (sscanf(buf, "%d,%d", &id, &trace) != 2) {
-		pr_err("invalid content: '%s', length = %zu\n", buf, count);
-		goto err_out;
-	}
-
-	if (id < 0 || id >= ID_SENSOR_MAX) {
-		pr_debug("invalid id value:%d,should be '0<=id<=%d'\n",
-			trace, ID_SENSOR_MAX);
-		goto err_out;
-	}
-
-	if (trace != 0 && trace != 1) {
-		pr_debug("invalid trace value:%d,trace should be '0' or '1'",
-			trace);
-		goto err_out;
-	}
-
-	res = mtk_nanohub_set_cmd_to_hub(id,
-			CUST_ACTION_SET_TRACE, &trace);
-	if (res < 0) {
-		pr_err("cmd_to_hub (ID: %d),(action: %d)err: %d\n", id,
-					CUST_ACTION_SET_TRACE, res);
-	} else
-		atomic_set(&device->traces[id], trace);
-
-err_out:
-	return count;
-}
-
-static DRIVER_ATTR_RW(mtk_nanohub_trace);
-
-static struct driver_attribute *mtk_nanohub_attrs[] = {
-	&driver_attr_mtk_nanohub_trace,
-};
-
-static int mtk_nanohub_create_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(mtk_nanohub_attrs));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, mtk_nanohub_attrs[idx]);
-		if (err) {
-			pr_err("driver_create_file (%s) = %d\n",
-				mtk_nanohub_attrs[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int mtk_nanohub_delete_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(mtk_nanohub_attrs));
-
-	if (!driver)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, mtk_nanohub_attrs[idx]);
-
-	return err;
-}
-
-static int mtk_nanohub_probe(struct platform_device *pdev)
-{
-	int err = 0, index;
-	struct mtk_nanohub_device *device;
-	struct task_struct *task = NULL, *task_power_reset = NULL;
-	struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
-
-	mtk_nanohub_init_sensor_state();
-	device = kzalloc(sizeof(*device), GFP_KERNEL);
-	if (!device) {
-		err = -ENOMEM;
-		goto exit;
-	}
-	mtk_nanohub_dev = device;
-	/* init sensor share dram write pointer event queue */
-	spin_lock_init(&device->wp_queue.buffer_lock);
-	device->wp_queue.head = 0;
-	device->wp_queue.tail = 0;
-	device->wp_queue.bufsize = 32;
-	device->wp_queue.ringbuffer =
-		vzalloc(device->wp_queue.bufsize * sizeof(uint32_t));
-	if (!device->wp_queue.ringbuffer) {
-		err = -ENOMEM;
-		goto exit_kfree;
-	}
-	/* init the debug trace flag */
-	for (index = 0; index < ID_SENSOR_MAX; index++)
-		atomic_set(&device->traces[index], 0);
-	/* init scp boot flags */
-	atomic_set(&device->get_list_first_boot, 0);
-	atomic_set(&device->cfg_data_after_reboot, 0);
-	atomic_set(&device->start_timesync_first_boot, 0);
-	/* init timestamp sync worker */
-	INIT_WORK(&device->sync_time_worker, mtk_nanohub_sync_time_work);
-	device->sync_time_timer.expires =
-		jiffies + msecs_to_jiffies(SYNC_TIME_START_CYCLC);
-	device->sync_time_timer.function = mtk_nanohub_sync_time_func;
-	init_timer(&device->sync_time_timer);
-	/* init wakeup source */
-	wakeup_source_init(&device->time_sync_wakeup_src, "sync_time");
-	wakeup_source_init(&device->data_notify_wakeup_src, "data_notify");
-	/* init nanohub ipi */
-	mtk_nanohub_ipi_init();
-	/* register ipi interrupt handler */
-	scp_ipi_registration(IPI_SENSOR,
-		mtk_nanohub_ipi_handler, "mtk_nanohub");
-	/* this call back can get scp power down status */
-	scp_A_register_notify(&mtk_nanohub_ready_notifier);
-	/* init data path */
-	WRITE_ONCE(chre_kthread_wait_condition, false);
-	task = kthread_run(mtk_nanohub_direct_push_work,
-		NULL, "chre_kthread");
-	if (IS_ERR(task)) {
-		pr_err("mtk_nanohub_direct_push_work create fail!\n");
-		goto exit_scp;
-	}
-	sched_setscheduler(task, SCHED_FIFO, &param);
-	/* this call back can get scp power UP status */
-	task_power_reset = kthread_run(mtk_nanohub_power_up_work,
-		NULL, "scp_power_reset");
-	if (IS_ERR(task_power_reset)) {
-		pr_err("mtk_nanohub_power_up_work create fail!\n");
-		goto exit_scp;
-	}
-	err = mtk_nanohub_create_attr(pdev->dev.driver);
-	if (err < 0) {
-		pr_err("create attribute err\n");
-		goto exit_scp;
-	}
-	err = register_pm_notifier(&mtk_nanohub_pm_notifier_func);
-	if (err < 0) {
-		pr_err("Failed to register PM notifier.\n");
-		goto exit_attr;
-	}
-	/* create mamanger last */
-	err = mtk_nanohub_create_manager();
-	if (err < 0) {
-		pr_err("Failed to create manager.\n");
-		goto exit_manager;
-	}
-
-	pr_info("init done, data_unit_t:%d, SCP_SENSOR_HUB_DATA:%d\n",
-		(int)sizeof(struct data_unit_t),
-		(int)sizeof(union SCP_SENSOR_HUB_DATA));
-	BUG_ON(sizeof(struct data_unit_t) != SENSOR_DATA_SIZE
-		|| sizeof(union SCP_SENSOR_HUB_DATA) != SENSOR_IPI_SIZE);
-	return 0;
-
-exit_manager:
-	unregister_pm_notifier(&mtk_nanohub_pm_notifier_func);
-exit_attr:
-	mtk_nanohub_delete_attr(pdev->dev.driver);
-exit_scp:
-	scp_A_unregister_notify(&mtk_nanohub_ready_notifier);
-	scp_ipi_unregistration(IPI_SENSOR);
-	vfree(device->wp_queue.ringbuffer);
-exit_kfree:
-	kfree(device);
-exit:
-	pr_err("%s: err = %d\n", __func__, err);
-	return err;
-}
-
-static int mtk_nanohub_remove(struct platform_device *pdev)
-{
-	struct mtk_nanohub_device *device = mtk_nanohub_dev;
-
-	del_timer_sync(&device->sync_time_timer);
-	hf_manager_destroy(device->hf_dev.manager);
-	unregister_pm_notifier(&mtk_nanohub_pm_notifier_func);
-	mtk_nanohub_delete_attr(pdev->dev.driver);
-	scp_A_unregister_notify(&mtk_nanohub_ready_notifier);
-	scp_ipi_unregistration(IPI_SENSOR);
-	vfree(device->wp_queue.ringbuffer);
-	kfree(device);
-	return 0;
-}
-
-static void mtk_nanohub_shutdown(struct platform_device *pdev)
-{
-	int id = 0;
-	uint8_t sensor_type;
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	mutex_lock(&mSensorState_mtx);
-	for (id = 0; id < ID_SENSOR_MAX; id++) {
-		sensor_type = id_to_type(id);
-		if (mSensorState[sensor_type].sensorType &&
-				mSensorState[sensor_type].enable) {
-			mSensorState[sensor_type].enable = false;
-			init_sensor_config_cmd(&cmd, sensor_type);
-
-			ret = nanohub_external_write((const uint8_t *)&cmd,
-				sizeof(struct ConfigCmd));
-			if (ret < 0)
-				pr_notice("failed registerlistener [%d,%d]\n",
-					id, cmd.cmd);
-		}
-	}
-	mutex_unlock(&mSensorState_mtx);
-}
-
-static struct platform_device mtk_nanohub_pdev = {
-	.name = "mtk_nanohub",
-	.id = -1,
-};
-
-static struct platform_driver mtk_nanohub_pdrv = {
-	.driver = {
-	   .name = "mtk_nanohub",
-	},
-	.probe = mtk_nanohub_probe,
-	.remove = mtk_nanohub_remove,
-	.shutdown = mtk_nanohub_shutdown,
-};
-
-static int __init mtk_nanohub_init(void)
-{
-	if (platform_device_register(&mtk_nanohub_pdev)) {
-		pr_err("mtk_nanohub platform device error\n");
-		return -1;
-	}
-	if (platform_driver_register(&mtk_nanohub_pdrv)) {
-		pr_err("mtk_nanohub platform driver error\n");
-		return -1;
-	}
-	return 0;
-}
-
-static void __exit mtk_nanohub_exit(void)
-{
-}
-
-module_init(mtk_nanohub_init);
-module_exit(mtk_nanohub_exit);
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("mtk_nanohub driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub.h
deleted file mode 100644
index a3d61a2..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub.h
+++ /dev/null
@@ -1,522 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef SCP_SENSOR_HUB_H
-#define SCP_SENSOR_HUB_H
-
-#include <linux/ioctl.h>
-
-#define EVT_NO_SENSOR_CONFIG_EVENT 0x00000300
-#define SENSOR_RATE_ONCHANGE       0xFFFFFF01UL
-#define SENSOR_RATE_ONESHOT        0xFFFFFF02UL
-
-enum {
-	CONFIG_CMD_DISABLE      = 0,
-	CONFIG_CMD_ENABLE       = 1,
-	CONFIG_CMD_FLUSH        = 2,
-	CONFIG_CMD_CFG_DATA     = 3,
-	CONFIG_CMD_CALIBRATE    = 4,
-	CONFIG_CMD_SELF_TEST    = 5,
-};
-
-struct ConfigCmd {
-	uint32_t evtType;
-	uint64_t latency;
-	uint32_t rate;
-	uint8_t sensorType;
-	uint8_t cmd;
-	uint16_t flags;
-	uint8_t data[];
-} __packed;
-
-struct SensorState {
-	uint64_t latency;
-	uint32_t rate;
-	uint8_t sensorType;
-	uint8_t alt;
-	bool enable;
-	bool timestamp_filter;
-	atomic_t flushCnt;
-};
-
-#define SCP_SENSOR_HUB_SUCCESS       0
-#define SCP_SENSOR_HUB_FAILURE      (-1)
-
-#define SCP_SENSOR_HUB_X             0
-#define SCP_SENSOR_HUB_Y             1
-#define SCP_SENSOR_HUB_Z             2
-#define SCP_SENSOR_HUB_AXES_NUM      3
-
-/* SCP_ACTION */
-#define SENSOR_HUB_ACTIVATE          0
-#define SENSOR_HUB_SET_DELAY         1
-#define SENSOR_HUB_GET_DATA          2
-#define SENSOR_HUB_BATCH             3
-#define SENSOR_HUB_SET_CONFIG        4
-#define SENSOR_HUB_SET_CUST          5
-#define SENSOR_HUB_NOTIFY            6
-#define SENSOR_HUB_BATCH_TIMEOUT     7
-#define SENSOR_HUB_SET_TIMESTAMP     8
-#define SENSOR_HUB_POWER_NOTIFY      9
-#define SENSOR_HUB_RAW_DATA          10
-
-/* SCP_NOTIFY EVENT */
-#define SCP_INIT_DONE                0
-#define SCP_FIFO_FULL                1
-#define SCP_NOTIFY                   2
-#define SCP_BATCH_TIMEOUT            3
-#define SCP_DIRECT_PUSH              4
-
-enum {
-	SENSOR_POWER_UP = 0,
-	SENSOR_POWER_DOWN,
-};
-
-struct sensor_vec_t {
-	union {
-		struct {
-			int32_t x;
-			int32_t y;
-			int32_t z;
-			int32_t x_bias;
-			int32_t y_bias;
-			int32_t z_bias;
-			int32_t reserved : 14;
-			int32_t temp_result : 2;
-			int32_t temperature : 16;
-		};
-		struct {
-			int32_t azimuth;
-			int32_t pitch;
-			int32_t roll;
-			int32_t scalar;
-		};
-	};
-	uint32_t status;
-};
-
-struct heart_rate_event_t {
-	int32_t bpm;
-	int32_t status;
-};
-
-struct significant_motion_event_t {
-	int32_t state;
-};
-
-struct step_counter_event_t {
-	uint32_t accumulated_step_count;
-};
-
-struct step_detector_event_t {
-	uint32_t step_detect;
-};
-
-struct floor_counter_event_t {
-	uint32_t accumulated_floor_count;
-};
-
-enum gesture_type_t {
-	GESTURE_NONE,
-	SHAKE,
-	TAP,
-	TWIST,
-	FLIP,
-	SNAPSHOT,
-	PICKUP,
-	CHECK
-};
-
-struct gesture_t {
-	int32_t probability;
-};
-
-struct pedometer_event_t {
-	uint32_t accumulated_step_count;
-	uint32_t accumulated_step_length;
-	uint32_t step_frequency;
-	uint32_t step_length;
-};
-
-struct pressure_vec_t {
-	int32_t pressure;	/* Pa, i.e. hPa * 100 */
-	int32_t temperature;
-	uint32_t status;
-};
-
-struct proximity_vec_t {
-	uint32_t steps;
-	int32_t oneshot;
-};
-
-struct relative_humidity_vec_t {
-	int32_t relative_humidity;
-	int32_t temperature;
-	uint32_t status;
-};
-
-struct sleepmonitor_event_t {
-	int32_t state;		/* sleep, restless, awake */
-};
-
-enum fall_type {
-	FALL_NONE,
-	FALL,
-	FLOP,
-	FALL_MAX
-};
-
-struct fall_t {
-	uint8_t probability[FALL_MAX];	/* 0~100 */
-};
-
-struct tilt_event_t {
-	int32_t state;		/* 0,1 */
-};
-
-struct in_pocket_event_t {
-	int32_t state;		/* 0,1 */
-};
-
-struct geofence_event_t {
-	uint32_t state;  /* geofence [source, result, operation_mode] */
-};
-
-struct sar_event_t {
-	struct {
-		int32_t data[3];
-		int32_t x_bias;
-		int32_t y_bias;
-		int32_t z_bias;
-	};
-	uint32_t status;
-};
-
-enum activity_type_t {
-	STILL,
-	STANDING,
-	SITTING,
-	LYING,
-	ON_FOOT,
-	WALKING,
-	RUNNING,
-	CLIMBING,
-	ON_BICYCLE,
-	IN_VEHICLE,
-	TILTING,
-	UNKNOWN,
-	ACTIVITY_MAX
-};
-
-struct activity_t {
-	uint8_t probability[ACTIVITY_MAX];	/* 0~100 */
-};
-
-struct data_unit_t {
-	uint8_t sensor_type;
-	uint8_t flush_action;
-	uint8_t reserve[2];
-	uint64_t time_stamp;
-	union {
-		struct sensor_vec_t accelerometer_t;
-		struct sensor_vec_t gyroscope_t;
-		struct sensor_vec_t magnetic_t;
-		struct sensor_vec_t orientation_t;
-		struct sensor_vec_t pdr_event;
-
-		int32_t light;
-		struct proximity_vec_t proximity_t;
-		int32_t temperature;
-		struct pressure_vec_t pressure_t;
-		struct relative_humidity_vec_t relative_humidity_t;
-
-		struct sensor_vec_t uncalibrated_acc_t;
-		struct sensor_vec_t uncalibrated_mag_t;
-		struct sensor_vec_t uncalibrated_gyro_t;
-
-		struct pedometer_event_t pedometer_t;
-
-		struct heart_rate_event_t heart_rate_t;
-		struct significant_motion_event_t smd_t;
-		struct step_detector_event_t step_detector_t;
-		struct step_counter_event_t step_counter_t;
-		struct floor_counter_event_t floor_counter_t;
-		struct activity_t activity_data_t;
-		struct gesture_t gesture_data_t;
-		struct fall_t fall_data_t;
-		struct tilt_event_t tilt_event;
-		struct in_pocket_event_t inpocket_event;
-		struct geofence_event_t geofence_data_t;
-		struct sar_event_t sar_event;
-		int32_t data[8];
-	};
-} __packed;
-
-struct sensor_fifo {
-	uint32_t rp;
-	uint32_t wp;
-	uint32_t fifo_size;
-	uint32_t reserve;
-	struct data_unit_t data[0];
-};
-
-struct SCP_SENSOR_HUB_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	uint32_t data[11];
-};
-
-struct SCP_SENSOR_HUB_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	int8_t errCode;
-	uint8_t reserve[1];
-	/* uint32_t    reserved[9]; */
-};
-
-struct SCP_SENSOR_HUB_ACTIVATE_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	uint32_t enable;	/* 0 : disable ; 1 : enable */
-	/* uint32_t    reserved[9]; */
-};
-
-#define SCP_SENSOR_HUB_ACTIVATE_RSP SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_ACTIVATE_RSP; */
-
-struct SCP_SENSOR_HUB_SET_DELAY_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	uint32_t delay;		/* ms */
-	/* uint32_t    reserved[9]; */
-};
-
-#define SCP_SENSOR_HUB_SET_DELAY_RSP  SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_SET_DELAY_RSP; */
-
-struct SCP_SENSOR_HUB_GET_DATA_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	/* uint32_t    reserved[10]; */
-};
-
-struct SCP_SENSOR_HUB_GET_DATA_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	int8_t errCode;
-	uint8_t reserve[1];
-	/* struct data_unit_t data_t; */
-	union {
-		int8_t int8_Data[0];
-		int16_t int16_Data[0];
-		int32_t int32_Data[0];
-	} data;
-};
-
-struct SCP_SENSOR_HUB_BATCH_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t flag;
-	uint8_t reserve[1];
-	uint32_t period_ms;	/* batch reporting time in ms */
-	uint32_t timeout_ms;	/* sampling time in ms */
-	/* uint32_t    reserved[7]; */
-};
-
-#define SCP_SENSOR_HUB_BATCH_RSP SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_BATCH_RSP; */
-
-struct SCP_SENSOR_HUB_SET_CONFIG_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	/* struct sensorFIFO   *bufferBase; */
-	uint32_t bufferBase;/* use int to store buffer DRAM base LSB 32 bits */
-	uint32_t bufferSize;
-	uint64_t ap_timestamp;
-	uint64_t arch_counter;
-	/* uint32_t    reserved[8]; */
-};
-
-#define SCP_SENSOR_HUB_SET_CONFIG_RSP  SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_SET_CONFIG_RSP; */
-
-enum CUST_ACTION {
-	CUST_ACTION_SET_CUST = 1,
-	CUST_ACTION_SET_CALI,
-	CUST_ACTION_RESET_CALI,
-	CUST_ACTION_SET_TRACE,
-	CUST_ACTION_SET_DIRECTION,
-	CUST_ACTION_SHOW_REG,
-	CUST_ACTION_GET_RAW_DATA,
-	CUST_ACTION_SET_PS_THRESHOLD,
-	CUST_ACTION_SHOW_ALSLV,
-	CUST_ACTION_SHOW_ALSVAL,
-	CUST_ACTION_SET_FACTORY,
-	CUST_ACTION_GET_SENSOR_INFO,
-};
-
-struct SCP_SENSOR_HUB_CUST {
-	enum CUST_ACTION action;
-};
-
-struct SCP_SENSOR_HUB_SET_CUST {
-	enum CUST_ACTION action;
-	int32_t data[0];
-};
-
-struct SCP_SENSOR_HUB_SET_TRACE {
-	enum CUST_ACTION action;
-	int trace;
-};
-
-struct SCP_SENSOR_HUB_SET_DIRECTION {
-	enum CUST_ACTION action;
-	int direction;
-};
-
-struct SCP_SENSOR_HUB_SET_FACTORY {
-	enum CUST_ACTION	action;
-	unsigned int	factory;
-};
-
-struct SCP_SENSOR_HUB_SET_CALI {
-	enum CUST_ACTION action;
-	union {
-		int8_t int8_data[0];
-		uint8_t uint8_data[0];
-		int16_t int16_data[0];
-		uint16_t uint16_data[0];
-		int32_t int32_data[0];
-		uint32_t uint32_data[SCP_SENSOR_HUB_AXES_NUM];
-	};
-};
-
-#define SCP_SENSOR_HUB_RESET_CALI   SCP_SENSOR_HUB_CUST
-/* typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_RESET_CALI; */
-
-struct SCP_SENSOR_HUB_SETPS_THRESHOLD {
-	enum CUST_ACTION action;
-	int32_t threshold[2];
-};
-
-#define SCP_SENSOR_HUB_SHOW_REG    SCP_SENSOR_HUB_CUST
-#define SCP_SENSOR_HUB_SHOW_ALSLV  SCP_SENSOR_HUB_CUST
-#define SCP_SENSOR_HUB_SHOW_ALSVAL SCP_SENSOR_HUB_CUST
-/*
- * typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_SHOW_REG;
- * typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_SHOW_ALSLV;
- * typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_SHOW_ALSVAL;
- */
-
-struct SCP_SENSOR_HUB_GET_RAW_DATA {
-	enum CUST_ACTION action;
-	union {
-		int8_t int8_data[0];
-		uint8_t uint8_data[0];
-		int16_t int16_data[0];
-		uint16_t uint16_data[0];
-		int32_t int32_data[0];
-		uint32_t uint32_data[SCP_SENSOR_HUB_AXES_NUM];
-	};
-};
-
-struct mag_dev_info_t {
-	char libname[16];
-	int8_t layout;
-	int8_t deviceid;
-};
-
-struct sensorInfo_t {
-	char name[16];
-	struct mag_dev_info_t mag_dev_info;
-};
-
-struct scp_sensor_hub_get_sensor_info {
-	enum CUST_ACTION action;
-	union {
-		int32_t int32_data[0];
-		struct sensorInfo_t sensorInfo;
-	};
-};
-
-enum {
-	USE_OUT_FACTORY_MODE = 0,
-	USE_IN_FACTORY_MODE
-};
-
-struct SCP_SENSOR_HUB_SET_CUST_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	union {
-		uint32_t custData[11];
-		struct SCP_SENSOR_HUB_CUST cust;
-		struct SCP_SENSOR_HUB_SET_CUST setCust;
-		struct SCP_SENSOR_HUB_SET_CALI setCali;
-		struct SCP_SENSOR_HUB_RESET_CALI resetCali;
-		struct SCP_SENSOR_HUB_SET_TRACE setTrace;
-		struct SCP_SENSOR_HUB_SET_DIRECTION setDirection;
-		struct SCP_SENSOR_HUB_SHOW_REG showReg;
-		struct SCP_SENSOR_HUB_GET_RAW_DATA getRawData;
-		struct SCP_SENSOR_HUB_SETPS_THRESHOLD setPSThreshold;
-		struct SCP_SENSOR_HUB_SHOW_ALSLV showAlslv;
-		struct SCP_SENSOR_HUB_SHOW_ALSVAL showAlsval;
-		struct SCP_SENSOR_HUB_SET_FACTORY setFactory;
-		struct scp_sensor_hub_get_sensor_info getInfo;
-	};
-};
-
-struct SCP_SENSOR_HUB_SET_CUST_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t errCode;
-	uint8_t reserve[1];
-	union {
-		uint32_t custData[11];
-		struct SCP_SENSOR_HUB_GET_RAW_DATA getRawData;
-		struct scp_sensor_hub_get_sensor_info getInfo;
-	};
-};
-
-struct SCP_SENSOR_HUB_NOTIFY_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t event;
-	uint8_t reserve[1];
-	union {
-		int8_t		int8_Data[0];
-		int16_t		int16_Data[0];
-		int32_t		int32_Data[0];
-		struct {
-			uint32_t	currWp;
-			uint64_t	scp_timestamp;
-			uint64_t	arch_counter;
-		};
-	};
-};
-
-union SCP_SENSOR_HUB_DATA {
-	struct SCP_SENSOR_HUB_REQ req;
-	struct SCP_SENSOR_HUB_RSP rsp;
-	struct SCP_SENSOR_HUB_ACTIVATE_REQ activate_req;
-	struct SCP_SENSOR_HUB_ACTIVATE_RSP activate_rsp;
-	struct SCP_SENSOR_HUB_SET_DELAY_REQ set_delay_req;
-	struct SCP_SENSOR_HUB_SET_DELAY_RSP set_delay_rsp;
-	struct SCP_SENSOR_HUB_GET_DATA_REQ get_data_req;
-	struct SCP_SENSOR_HUB_GET_DATA_RSP get_data_rsp;
-	struct SCP_SENSOR_HUB_BATCH_REQ batch_req;
-	struct SCP_SENSOR_HUB_BATCH_RSP batch_rsp;
-	struct SCP_SENSOR_HUB_SET_CONFIG_REQ set_config_req;
-	struct SCP_SENSOR_HUB_SET_CONFIG_RSP set_config_rsp;
-	struct SCP_SENSOR_HUB_SET_CUST_REQ set_cust_req;
-	struct SCP_SENSOR_HUB_SET_CUST_RSP set_cust_rsp;
-	struct SCP_SENSOR_HUB_NOTIFY_RSP notify_rsp;
-};
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub_ipi.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub_ipi.c
deleted file mode 100644
index a84787b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub_ipi.c
+++ /dev/null
@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[mtk_nanohub_ipi] " fmt
-
-#include <linux/module.h>
-#include <linux/workqueue.h>
-#include <linux/spinlock.h>
-#include <linux/delay.h>
-
-#include "mtk_nanohub_ipi.h"
-#include "scp_ipi.h"
-#include "scp_helper.h"
-#include "scp_excep.h"
-
-enum scp_ipi_status __attribute__((weak)) scp_ipi_send(enum ipi_id id,
-		void *buf, unsigned int  len,
-		unsigned int wait, enum scp_core_id scp_id)
-{
-	return SCP_IPI_ERROR;
-}
-
-struct ipi_hw_master {
-	spinlock_t lock;
-	bool running;
-	struct list_head head;
-	struct workqueue_struct *workqueue;
-	struct work_struct work;
-};
-
-struct ipi_hw_transfer {
-	struct completion done;
-	int count;
-	/* data buffers */
-	const unsigned char *tx;
-	unsigned char *rx;
-	unsigned int tx_len;
-	unsigned int rx_len;
-	void *context;
-};
-
-static struct ipi_hw_master hw_master;
-static struct ipi_hw_transfer hw_transfer;
-static DEFINE_SPINLOCK(hw_transfer_lock);
-
-static int ipi_txrx_bufs(struct ipi_transfer *t)
-{
-	int status = 0, retry = 0;
-	int timeout;
-	unsigned long flags;
-	struct ipi_hw_transfer *hw = &hw_transfer;
-
-	spin_lock_irqsave(&hw_transfer_lock, flags);
-	hw->tx = t->tx_buf;
-	hw->rx = t->rx_buf;
-	hw->tx_len = t->tx_len;
-	hw->rx_len = t->rx_len;
-
-	init_completion(&hw->done);
-	hw->context = &hw->done;
-	spin_unlock_irqrestore(&hw_transfer_lock, flags);
-	do {
-		status = scp_ipi_send(IPI_SENSOR,
-			(unsigned char *)hw->tx, hw->tx_len, 0, SCP_A_ID);
-		if (status == SCP_IPI_ERROR) {
-			pr_err("scp_ipi_send fail\n");
-			return -1;
-		}
-		if (status == SCP_IPI_BUSY) {
-			if (retry++ == 1000) {
-				pr_err("retry fail\n");
-				return -1;
-			}
-			if (retry % 100 == 0)
-				usleep_range(1000, 2000);
-		}
-	} while (status == SCP_IPI_BUSY);
-
-	if (retry >= 100)
-		pr_debug("retry time:%d\n", retry);
-
-	timeout = wait_for_completion_timeout(&hw->done,
-			msecs_to_jiffies(500));
-	spin_lock_irqsave(&hw_transfer_lock, flags);
-	if (!timeout) {
-		pr_err("transfer timeout!");
-		hw->count = -1;
-	}
-	hw->context = NULL;
-	spin_unlock_irqrestore(&hw_transfer_lock, flags);
-	return hw->count;
-}
-
-static void ipi_complete(void *arg)
-{
-	complete(arg);
-}
-
-static void ipi_transfer_messages(void)
-{
-	struct ipi_message *m;
-	struct ipi_transfer *t = NULL;
-	int status = 0;
-	unsigned long flags;
-
-	spin_lock_irqsave(&hw_master.lock, flags);
-	if (list_empty(&hw_master.head) || hw_master.running)
-		goto out;
-	hw_master.running = true;
-	while (!list_empty(&hw_master.head)) {
-		m = list_first_entry(&hw_master.head,
-			struct ipi_message, list);
-		list_del(&m->list);
-		spin_unlock_irqrestore(&hw_master.lock, flags);
-		list_for_each_entry(t, &m->transfers, transfer_list) {
-			if (!t->tx_buf && t->tx_len) {
-				status = -EINVAL;
-				pr_err("transfer param wrong :%d\n",
-					status);
-				break;
-			}
-			if (t->tx_len)
-				status = ipi_txrx_bufs(t);
-			if (status < 0) {
-				status = -EREMOTEIO;
-				/* pr_err("transfer err :%d\n", status); */
-				break;
-			} else if (status != t->rx_len) {
-				pr_err("ack err :%d %d\n", status, t->rx_len);
-				status = -EREMOTEIO;
-				break;
-			}
-			status = 0;
-		}
-		m->status = status;
-		m->complete(m->context);
-		spin_lock_irqsave(&hw_master.lock, flags);
-	}
-	hw_master.running = false;
-out:
-	spin_unlock_irqrestore(&hw_master.lock, flags);
-}
-
-static void ipi_prefetch_messages(void)
-{
-	ipi_transfer_messages();
-}
-
-static void ipi_work(struct work_struct *work)
-{
-	ipi_transfer_messages();
-}
-
-static int __ipi_transfer(struct ipi_message *m)
-{
-	unsigned long flags;
-
-	m->status = -EINPROGRESS;
-
-	spin_lock_irqsave(&hw_master.lock, flags);
-	list_add_tail(&m->list, &hw_master.head);
-	queue_work(hw_master.workqueue, &hw_master.work);
-	spin_unlock_irqrestore(&hw_master.lock, flags);
-	return 0;
-}
-
-static int __ipi_xfer(struct ipi_message *message)
-{
-	DECLARE_COMPLETION_ONSTACK(done);
-	int status;
-
-	message->complete = ipi_complete;
-	message->context = &done;
-
-	status = __ipi_transfer(message);
-
-	if (status == 0) {
-		ipi_prefetch_messages();
-		wait_for_completion(&done);
-		status = message->status;
-	}
-	message->context = NULL;
-	return status;
-}
-
-static int ipi_sync(const unsigned char *txbuf, unsigned int n_tx,
-		unsigned char *rxbuf, unsigned int n_rx)
-{
-	struct ipi_transfer t;
-	struct ipi_message m;
-
-	t.tx_buf = txbuf;
-	t.tx_len = n_tx;
-	t.rx_buf = rxbuf;
-	t.rx_len = n_rx;
-
-	ipi_message_init(&m);
-	ipi_message_add_tail(&t, &m);
-
-	return __ipi_xfer(&m);
-}
-
-static int ipi_async(struct ipi_message *m)
-{
-	return __ipi_transfer(m);
-}
-
-int mtk_nanohub_ipi_sync(unsigned char *buffer, unsigned int len)
-{
-	return ipi_sync(buffer, len, buffer, len);
-}
-
-int mtk_nanohub_ipi_async(struct ipi_message *m)
-{
-	return ipi_async(m);
-}
-
-void mtk_nanohub_ipi_complete(unsigned char *buffer, unsigned int len)
-{
-	struct ipi_hw_transfer *hw = &hw_transfer;
-
-	spin_lock(&hw_transfer_lock);
-	if (!hw->context) {
-		pr_err("after ipi timeout ack occur then dropped this\n");
-		goto out;
-	}
-	/* only copy hw->rx_len bytes to hw->rx to avoid memory corruption */
-	memcpy(hw->rx, buffer, hw->rx_len);
-	/* hw->count give real len */
-	hw->count = len;
-	complete(hw->context);
-out:
-	spin_unlock(&hw_transfer_lock);
-}
-
-int mtk_nanohub_ipi_init(void)
-{
-	INIT_WORK(&hw_master.work, ipi_work);
-	INIT_LIST_HEAD(&hw_master.head);
-	spin_lock_init(&hw_master.lock);
-	hw_master.workqueue = create_singlethread_workqueue("ipi_master");
-	if (hw_master.workqueue == NULL) {
-		pr_err("workqueue fail\n");
-		return -1;
-	}
-
-	return 0;
-}
-
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("mtk_nanohub_ipi driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub_ipi.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub_ipi.h
deleted file mode 100644
index ceadca5..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/mtk_nanohub/mtk_nanohub_ipi.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef _MTK_NANOHUB_IPI_H_
-#define _MTK_NANOHUB_IPI_H_
-
-#include <linux/list.h>
-
-struct ipi_transfer {
-	const unsigned char *tx_buf;
-	unsigned char *rx_buf;
-	unsigned int tx_len;
-	unsigned int rx_len;
-	struct list_head transfer_list;
-};
-
-struct ipi_message {
-	struct list_head transfers;
-	struct list_head list;
-	void *context;
-	int status;
-	void (*complete)(void *context);
-};
-
-static inline void ipi_message_init(struct ipi_message *m)
-{
-	memset(m, 0, sizeof(*m));
-	INIT_LIST_HEAD(&m->transfers);
-}
-
-static inline void ipi_message_add_tail(struct ipi_transfer *t,
-		struct ipi_message *m)
-{
-	list_add_tail(&t->transfer_list, &m->transfers);
-}
-
-int mtk_nanohub_ipi_sync(unsigned char *buffer, unsigned int len);
-int mtk_nanohub_ipi_async(struct ipi_message *m);
-void mtk_nanohub_ipi_complete(unsigned char *buffer, unsigned int len);
-int mtk_nanohub_ipi_init(void);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/Makefile
deleted file mode 100644
index 68a73f0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensor/2.0/core/
-
-obj-y += smi130_i2c.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/smi130_i2c.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/smi130_i2c.c
deleted file mode 100644
index 53f1813..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/smi130_i2c.c
+++ /dev/null
@@ -1,741 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/delay.h>
-#include <linux/math64.h>
-#include <linux/atomic.h>
-
-#include "hf_manager.h"
-#include "smi130_i2c.h"
-#include "sensor_list.h"
-
-#define GYRO_TEMP_AMP    100
-#define SMI130_I2C_NAME "smi130_i2c"
-#define GYRO_ADDR               0x68
-#define SMI130_AXES_NUM          3
-#define C_I2C_FIFO_SIZE              8
-
-#define SMI130_SOFT_RESET_VALUE  0xB6
-#define SMI130_ACC_CHIP_ID_VALUE     (0xfa)
-#define SMI130_GYRO_CHIP_ID_VALUE     (0x0f)
-#define CHECK_CHIP_ID_TIME_MAX       5
-
-#define SMI130_ACC_ODR_7HZ 0x08
-#define SMI130_ACC_ODR_15HZ 0x09
-#define SMI130_ACC_ODR_31HZ 0x0A
-#define SMI130_ACC_ODR_62HZ 0x0B
-#define SMI130_ACC_ODR_125HZ 0x0C
-#define SMI130_ACC_ODR_250HZ 0x0D
-#define SMI130_ACC_ODR_500HZ 0x0E
-#define SMI130_ACC_ODR_1000HZ 0x0F
-#define SMI130_ACC_RANGE_4G 0x03
-#define SMI130_ACC_RANGE_8G 0x05
-#define SMI130_ACC_RANGE_16G 0x08
-#define SMI130_ACC_RANGE_32G 0x0C
-
-#define SMI130_GYRO_ODR_32HZ 0x07
-#define SMI130_GYRO_ODR_64HZ 0x06
-#define SMI130_GYRO_ODR_12HZ 0x05
-#define SMI130_GYRO_ODR_23HZ 0x04
-#define SMI130_GYRO_ODR_47HZ 0x03
-#define SMI130_GYRO_ODR_116HZ 0x02
-#define SMI130_GYRO_ODR_230HZ 0x01
-#define SMI130_GYRO_ODR_523HZ 0x00
-#define SMI130_GYRO_RANGE_2000 0x00
-#define SMI130_GYRO_RANGE_1000 0x01
-#define SMI130_GYRO_RANGE_500 0x02
-#define SMI130_GYRO_RANGE_250 0x03
-#define SMI130_GYRO_RANGE_125 0x04
-
-static unsigned char support_sensors[] = {
-	SENSOR_TYPE_ACCELEROMETER,
-	SENSOR_TYPE_GYROSCOPE,
-	SENSOR_TYPE_GYRO_TEMPERATURE,
-};
-
-struct smi130_device {
-	struct hf_device hf_dev;
-	struct i2c_client *acc_client;
-	struct i2c_client *gyro_client;
-	uint32_t direction;
-	uint8_t placement[3];
-	atomic_t raw_acc_enable;
-	atomic_t raw_gyro_enable;
-	atomic_t acc_enable;
-	atomic_t gyro_enable;
-	atomic_t gyro_temp_enable;
-};
-
-/* I2C operation functions */
-static int smi130_i2c_read_block(struct i2c_client *client,
-			u8 addr, u8 *data, u8 len)
-{
-	int err = 0;
-	u8 beg = addr;
-	struct i2c_msg msgs[2] = {
-		{/*.addr = client->addr,*/
-		 .flags = 0,
-		 .len = 1,
-		 .buf = &beg},
-		{
-			/*.addr = client->addr*/
-			.flags = I2C_M_RD,
-			.len = len,
-			.buf = data,
-		} };
-	if (!client)
-		return -EINVAL;
-	msgs[0].addr = client->addr;
-	msgs[1].addr = client->addr;
-
-	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-	if (err != 2) {
-		pr_err_ratelimited("i2c_trans err: %x %x (%d %p %d) %d\n",
-		       msgs[0].addr, client->addr, addr, data, len, err);
-		err = -EIO;
-	} else {
-		err = 0; /*no error*/
-	}
-	return err;
-}
-
-static int smi130_i2c_write_block(struct i2c_client *client,
-			u8 addr, u8 *data, u8 len)
-{
-	/* because address also occupies one byte,
-	 * the maximum length for write is 7 bytes
-	 */
-	int err = 0, idx = 0, num = 0;
-	char buf[32];
-
-	if (!client)
-		return -EINVAL;
-	else if (len > C_I2C_FIFO_SIZE) {
-		pr_err_ratelimited("len %d fi %d\n", len, C_I2C_FIFO_SIZE);
-		return -EINVAL;
-	}
-	buf[num++] = addr;
-	for (idx = 0; idx < len; idx++)
-		buf[num++] = data[idx];
-
-	err = i2c_master_send(client, buf, num);
-	if (err < 0) {
-		pr_err_ratelimited("send command error!!\n");
-		return -EFAULT;
-	}
-
-	return err;
-}
-
-
-static int smi130_acc_init_device(struct i2c_client *client)
-{
-	int err = 0;
-	uint8_t data = 0;
-
-	data = SMI130_ACC_ODR_7HZ;
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_BW_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //filter and lock enable
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_RATED_HBW_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = SMI130_ACC_RANGE_16G;
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_RANGE_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //disable int
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_INT_ENABLE1_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x80; //map int
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_INT_MAP_1_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //push-pull, active low
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_INT_OUT_CTRL_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	pr_debug("SMI130_ACC init OK.\n");
-
-	return err;
-}
-
-static int smi130_acc_set_soft_reset(struct i2c_client *client)
-{
-	int err = 0;
-	uint8_t data = SMI130_SOFT_RESET_VALUE;
-
-	err = smi130_i2c_write_block(client,
-			SMI130_ACC_BGW_SOFTRESET_ADDR, &data, 1);
-	return err;
-}
-
-static int smi130_acc_check_chip_id(struct i2c_client *client)
-{
-	int err = -1;
-	u8 chip_id = 0;
-	u8 read_count = 0;
-
-	while (read_count++ < CHECK_CHIP_ID_TIME_MAX) {
-		smi130_i2c_read_block(client,
-				SMI130_ACC_CHIP_ID_ADDR, &chip_id, 1);
-
-		if ((chip_id & 0xff) != SMI130_ACC_CHIP_ID_VALUE) {
-			continue;
-		} else {
-			err = 0;
-			break;
-		}
-	}
-	return err;
-}
-
-static int smi130_gyro_init_device(struct i2c_client *client)
-{
-	int err = 0;
-	uint8_t data = 0;
-
-	data = SMI130_GYRO_ODR_32HZ;
-	err = smi130_i2c_write_block(client,
-			SMI130_GYRO_BW_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //filter and lock enable
-	err = smi130_i2c_write_block(client,
-			SMI130_GYRO_RATED_HBW_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = SMI130_GYRO_RANGE_2000;
-	err = smi130_i2c_write_block(client,
-			SMI130_GYRO_RANGE_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //disable int
-	err = smi130_i2c_write_block(client,
-			SMI130_GYRO_INT_ENABLE0_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x01; //map int
-	err = smi130_i2c_write_block(client,
-			SMI130_GYRO_INT_MAP_1_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	data = 0x00; //push-pull, active low
-	err = smi130_i2c_write_block(client,
-			SMI130_GYRO_INT_ENABLE1_ADDR, &data, 1);
-	if (err < 0)
-		return err;
-
-	pr_debug("SMI130 gyro init OK.\n");
-
-	return err;
-}
-
-static int smi130_gyro_check_chip_id(struct i2c_client *client)
-{
-	int err = -1;
-	u8 chip_id = 0;
-	u8 read_count = 0;
-
-	while (read_count++ < CHECK_CHIP_ID_TIME_MAX) {
-		smi130_i2c_read_block(client,
-				SMI130_GYRO_CHIP_ID_ADDR, &chip_id, 1);
-
-		if ((chip_id & 0xff) != SMI130_GYRO_CHIP_ID_VALUE) {
-			continue;
-		} else {
-			err = 0;
-			break;
-		}
-	}
-	return err;
-}
-
-int smi130_sample(struct hf_device *hfdev)
-{
-
-	int err = 0;
-	uint8_t buf[SMI130_AXES_NUM * 2] = {0};
-	int32_t data[SMI130_AXES_NUM] = {0};
-	int8_t gyro_temp[1] = {0};
-	struct hf_manager_event event;
-	int64_t current_time;
-	struct smi130_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-
-	current_time = ktime_get_boot_ns();
-	if (atomic_read(&driver_dev->acc_enable)) {
-		err = smi130_i2c_read_block(driver_dev->acc_client,
-				SMI130_ACC_RATE_X_LSB_ADDR,
-				&buf[0], SMI130_AXES_NUM * 2);
-		if (err < 0) {
-			pr_err_ratelimited("read fail\n");
-			return err;
-		}
-
-		data[0] = ((int16_t)(buf[0] | (buf[1] << 8))) >> 4;
-		data[1] = ((int16_t)(buf[2] | (buf[3] << 8))) >> 4;
-		data[2] = ((int16_t)(buf[4] | (buf[5] << 8))) >> 4;
-
-		coordinate_map(driver_dev->direction, data);
-
-		if (atomic_read(&driver_dev->raw_acc_enable)) {
-			memset(&event, 0, sizeof(struct hf_manager_event));
-			event.timestamp = current_time;
-			event.sensor_type = SENSOR_TYPE_ACCELEROMETER;
-			event.accurancy = SENSOR_ACCURANCY_HIGH;
-			event.action = RAW_ACTION;
-			event.word[0] =
-				(int32_t)div64_s64((int64_t)data[0] * 9807,
-									256);
-			event.word[1] =
-				(int32_t)div64_s64((int64_t)data[1] * 9807,
-									256);
-			event.word[2] =
-				(int32_t)div64_s64((int64_t)data[2] * 9807,
-									256);
-			manager->report(manager, &event);
-		}
-
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_ACCELEROMETER;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.action = DATA_ACTION;
-		event.word[0] = (int32_t)div64_s64((int64_t)data[0] * 9807,
-									256);
-		event.word[1] = (int32_t)div64_s64((int64_t)data[1] * 9807,
-									256);
-		event.word[2] = (int32_t)div64_s64((int64_t)data[2] * 9807,
-									256);
-		manager->report(manager, &event);
-	}
-
-	if (atomic_read(&driver_dev->gyro_enable)) {
-		err = smi130_i2c_read_block(driver_dev->gyro_client,
-			SMI130_GYRO_RATE_X_LSB_ADDR, &buf[0],
-						SMI130_AXES_NUM * 2);
-		if (err < 0) {
-			pr_err_ratelimited("read fail\n");
-			return err;
-		}
-
-		data[0] = (int16_t)(buf[0] | (buf[1] << 8));
-		data[1] = (int16_t)(buf[2] | (buf[3] << 8));
-		data[2] = (int16_t)(buf[4] | (buf[5] << 8));
-
-		coordinate_map(driver_dev->direction, data);
-
-		/* read gyro temp */
-		if (atomic_read(&driver_dev->gyro_temp_enable)) {
-			err = smi130_i2c_read_block(driver_dev->gyro_client,
-				SMI130_GYRO_TEMP_ADDR, &gyro_temp[0], 1);
-			if (err < 0) {
-				pr_err_ratelimited("read gyro temp fail\n");
-				return err;
-			}
-		}
-		if (atomic_read(&driver_dev->raw_gyro_enable)) {
-			memset(&event, 0, sizeof(struct hf_manager_event));
-			event.timestamp = current_time;
-			event.sensor_type = SENSOR_TYPE_GYROSCOPE;
-			event.accurancy = SENSOR_ACCURANCY_HIGH;
-			event.action = RAW_ACTION;
-			event.word[0] =
-				(int32_t)div64_s64((int64_t)data[0] * 1310000,
-									164);
-			event.word[1] =
-				(int32_t)div64_s64((int64_t)data[1] * 1310000,
-									164);
-			event.word[2] =
-				(int32_t)div64_s64((int64_t)data[2] * 1310000,
-									164);
-			manager->report(manager, &event);
-		}
-
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_GYROSCOPE;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.action = DATA_ACTION;
-		event.word[0] = (int32_t)div64_s64((int64_t)data[0] * 1310000,
-									164);
-		event.word[1] = (int32_t)div64_s64((int64_t)data[1] * 1310000,
-									164);
-		event.word[2] = (int32_t)div64_s64((int64_t)data[2] * 1310000,
-									164);
-		manager->report(manager, &event);
-
-		if (atomic_read(&driver_dev->gyro_temp_enable)) {
-			memset(&event, 0, sizeof(struct hf_manager_event));
-			event.timestamp = current_time;
-			event.sensor_type = SENSOR_TYPE_GYRO_TEMPERATURE;
-			event.accurancy = SENSOR_ACCURANCY_HIGH;
-			event.action = DATA_ACTION;
-			event.word[0] = (int32_t)gyro_temp[0] * GYRO_TEMP_AMP /
-						2 + GYRO_TEMP_AMP * 24;
-			manager->report(manager, &event);
-		}
-	}
-
-	manager->complete(manager);
-
-	return 0;
-}
-
-int smi130_raw_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	struct smi130_device *driver_dev = hf_device_get_private_data(hfdev);
-
-	if (sensor_type == SENSOR_TYPE_ACCELEROMETER)
-		atomic_set(&driver_dev->raw_acc_enable, en);
-	else if (sensor_type == SENSOR_TYPE_GYROSCOPE)
-		atomic_set(&driver_dev->raw_gyro_enable, en);
-	return 0;
-}
-
-int smi130_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	int err = 0;
-	uint8_t data = 0;
-	struct smi130_device *driver_dev = hf_device_get_private_data(hfdev);
-
-	pr_debug("%s id:%d en:%d\n", __func__, sensor_type, en);
-
-	if (sensor_type == SENSOR_TYPE_ACCELEROMETER) {
-		if (en) {
-			data = SMI130_ACC_DATA_INT_EN;
-			err = smi130_i2c_write_block(driver_dev->acc_client,
-					SMI130_ACC_INT_ENABLE1_ADDR, &data, 1);
-			if (err < 0) {
-				pr_err_ratelimited("write power mode failed\n");
-				return -1;
-			}
-			atomic_set(&driver_dev->acc_enable, en);
-		} else {
-			data = 0x00;
-			err = smi130_i2c_write_block(driver_dev->acc_client,
-					SMI130_ACC_INT_ENABLE1_ADDR, &data, 1);
-			if (err < 0) {
-				pr_err_ratelimited("write power mode failed\n");
-				return -1;
-			}
-			atomic_set(&driver_dev->acc_enable, en);
-		}
-	} else if (sensor_type == SENSOR_TYPE_GYROSCOPE) {
-		if (en) {
-			data = SMI130_GYRO_DATA_INT_EN;
-			err = smi130_i2c_write_block(driver_dev->gyro_client,
-					SMI130_GYRO_INT_ENABLE0_ADDR, &data, 1);
-			if (err < 0) {
-				pr_err_ratelimited("write power mode failed\n");
-				return -1;
-			}
-			atomic_set(&driver_dev->gyro_enable, en);
-		} else {
-			data = 0x00;
-			err = smi130_i2c_write_block(driver_dev->gyro_client,
-					SMI130_GYRO_INT_ENABLE0_ADDR, &data, 1);
-			if (err < 0) {
-				pr_err_ratelimited("write power mode failed\n");
-				return -1;
-			}
-			atomic_set(&driver_dev->gyro_enable, en);
-		}
-	} else if (sensor_type == SENSOR_TYPE_GYRO_TEMPERATURE)
-		atomic_set(&driver_dev->gyro_temp_enable, en);
-
-	return 0;
-
-}
-
-int smi130_batch(struct hf_device *hfdev, int sensor_type,
-	int64_t delay, int64_t latency)
-{
-
-	int err = 0;
-	uint8_t data = 0;
-	int value = 0;
-	struct smi130_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-
-	pr_debug("%s id:%d rate:%lld latency:%lld\n",
-		__func__, sensor_type, delay, latency);
-
-	value = div64_s64(1000000000LL, delay);
-
-	if (sensor_type == SENSOR_TYPE_ACCELEROMETER) {
-		if (value <= 7)
-			data = SMI130_ACC_ODR_7HZ;
-		else if (value <= 15)
-			data = SMI130_ACC_ODR_15HZ;
-		else if (value <= 31)
-			data = SMI130_ACC_ODR_31HZ;
-		else if (value <= 62)
-			data = SMI130_ACC_ODR_62HZ;
-		else if (value <= 125)
-			data = SMI130_ACC_ODR_125HZ;
-		else if (value <= 250)
-			data = SMI130_ACC_ODR_250HZ;
-		else if (value <= 500)
-			data = SMI130_ACC_ODR_500HZ;
-		else
-			data = SMI130_ACC_ODR_1000HZ;
-
-		err = smi130_i2c_write_block(driver_dev->acc_client,
-					SMI130_ACC_BW_ADDR, &data, 1);
-		if (err < 0) {
-			pr_err_ratelimited("write rate failed.\n");
-			return -1;
-		}
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		current_time = ktime_get_boot_ns();
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_ADDITIONAL_INFO;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.reserved = SENSOR_TYPE_ACCELEROMETER;
-		event.action = DATA_ACTION;
-		get_placement_info(driver_dev->direction, event.byte);
-		event.byte[12] = 1;
-		event.byte[3] = driver_dev->placement[0];
-		event.byte[7] = driver_dev->placement[1];
-		event.byte[11] = driver_dev->placement[2];
-
-		manager->report(manager, &event);
-	} else if (sensor_type == SENSOR_TYPE_GYROSCOPE) {
-		if (value <= 12)
-			data = SMI130_GYRO_ODR_12HZ;
-		else if (value <= 23)
-			data = SMI130_GYRO_ODR_23HZ;
-		else if (value <= 32)
-			data = SMI130_GYRO_ODR_32HZ;
-		else if (value <= 47)
-			data = SMI130_GYRO_ODR_47HZ;
-		else if (value <= 64)
-			data = SMI130_GYRO_ODR_64HZ;
-		else if (value <= 116)
-			data = SMI130_GYRO_ODR_116HZ;
-		else if (value <= 230)
-			data = SMI130_GYRO_ODR_230HZ;
-		else
-			data = SMI130_GYRO_ODR_523HZ;
-
-		err = smi130_i2c_write_block(driver_dev->gyro_client,
-				SMI130_GYRO_BW_ADDR, &data, 1);
-		if (err < 0) {
-			pr_err_ratelimited("write rate failed.\n");
-			return -1;
-		}
-		memset(&event, 0, sizeof(struct hf_manager_event));
-		current_time = ktime_get_boot_ns();
-		event.timestamp = current_time;
-		event.sensor_type = SENSOR_TYPE_ADDITIONAL_INFO;
-		event.accurancy = SENSOR_ACCURANCY_HIGH;
-		event.reserved = SENSOR_TYPE_GYROSCOPE;
-		event.action = DATA_ACTION;
-		get_placement_info(driver_dev->direction, event.byte);
-		event.byte[12] = 1;
-		event.byte[3] = driver_dev->placement[0];
-		event.byte[7] = driver_dev->placement[1];
-		event.byte[11] = driver_dev->placement[2];
-
-		manager->report(manager, &event);
-	}
-
-	manager->complete(manager);
-
-	return 0;
-
-}
-
-static int smi130_flush(struct hf_device *hfdev, int sensor_type)
-{
-	struct smi130_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-	struct hf_manager_event event;
-	int64_t current_time;
-
-	memset(&event, 0, sizeof(struct hf_manager_event));
-	current_time = ktime_get_boot_ns();
-	event.sensor_type = sensor_type;
-	event.timestamp = current_time;
-	event.action = FLUSH_ACTION;
-
-	manager->report(manager, &event);
-	manager->complete(manager);
-
-	return 0;
-}
-
-static int smi130_i2c_remove(struct i2c_client *client)
-{
-	struct smi130_device *driver_dev = i2c_get_clientdata(client);
-
-	hf_manager_destroy(driver_dev->hf_dev.manager);
-	kfree(driver_dev);
-	return 0;
-}
-
-static int smi130_i2c_probe(struct i2c_client *client,
-			const struct i2c_device_id *id)
-{
-
-	int err = 0;
-	struct smi130_device *driver_dev;
-	struct sensorlist_info_t listinfo;
-
-	pr_info("%s\n", __func__);
-
-	driver_dev = devm_kzalloc(&client->dev, sizeof(*driver_dev),
-								GFP_KERNEL);
-	if (!driver_dev)
-		return -ENOMEM;
-
-	driver_dev->acc_client = client;
-	driver_dev->gyro_client = i2c_new_dummy(client->adapter, GYRO_ADDR);
-	if (!driver_dev->gyro_client) {
-		pr_err("Failed to allocate i2c device for gyro\n");
-		return -ENODEV;
-	}
-
-	/* acc init */
-	err = smi130_acc_check_chip_id(client);
-	if (err < 0) {
-		pr_err("smi130 acc chip id mismatch\n");
-		err = -EINVAL;
-		goto init_fail;
-	}
-
-	err = smi130_acc_set_soft_reset(client);
-	if (err < 0) {
-		pr_err("erro soft reset!\n");
-		err = -EINVAL;
-		goto init_fail;
-	}
-
-	err = smi130_acc_init_device(client);
-	if (err < 0) {
-		pr_err("%s init device fail\n", __func__);
-		goto init_fail;
-	}
-
-	/* gyro init */
-	err = smi130_gyro_check_chip_id(driver_dev->gyro_client);
-	if (err < 0) {
-		pr_err("smi130 gyro chip id mismatch\n");
-		err = -EINVAL;
-		goto init_fail;
-	}
-
-	err = smi130_gyro_init_device(driver_dev->gyro_client);
-	if (err < 0) {
-		pr_err("%s init device fail\n", __func__);
-		goto init_fail;
-	}
-
-	if (of_property_read_u32(client->dev.of_node,
-		"direction", &driver_dev->direction)) {
-		pr_err("%s get direction dts fail\n", __func__);
-		err = -EFAULT;
-		goto dts_fail;
-	}
-
-	if (of_property_read_u8_array(client->dev.of_node, "placement",
-		driver_dev->placement, ARRAY_SIZE(driver_dev->placement))) {
-		pr_err("%s get placement dts fail\n", __func__);
-		err = -EFAULT;
-		goto dts_fail;
-	}
-
-	atomic_set(&driver_dev->raw_acc_enable, 0);
-	atomic_set(&driver_dev->raw_gyro_enable, 0);
-
-	driver_dev->hf_dev.dev_name = SMI130_I2C_NAME;
-	driver_dev->hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	driver_dev->hf_dev.device_bus = HF_DEVICE_IO_SYNC;
-	driver_dev->hf_dev.support_list = support_sensors;
-	driver_dev->hf_dev.support_size = ARRAY_SIZE(support_sensors);
-	driver_dev->hf_dev.enable = smi130_enable;
-	driver_dev->hf_dev.batch = smi130_batch;
-	driver_dev->hf_dev.flush = smi130_flush;
-	driver_dev->hf_dev.sample = smi130_sample;
-	driver_dev->hf_dev.rawdata = smi130_raw_enable;
-
-	err = hf_manager_create(&driver_dev->hf_dev);
-	if (err < 0) {
-		pr_err("%s hf_manager_create fail\n", __func__);
-		err = -1;
-		goto create_manager_fail;
-	}
-
-	i2c_set_clientdata(client, driver_dev);
-	hf_device_set_private_data(&driver_dev->hf_dev, driver_dev);
-
-	memset(&listinfo, 0, sizeof(struct sensorlist_info_t));
-	strlcpy(listinfo.name, SMI130_I2C_NAME, sizeof(listinfo.name));
-	sensorlist_register_devinfo(SENSOR_TYPE_ACCELEROMETER, &listinfo);
-	sensorlist_register_devinfo(SENSOR_TYPE_GYROSCOPE, &listinfo);
-
-	pr_info("%s success!\n", __func__);
-	return 0;
-
-create_manager_fail:
-dts_fail:
-init_fail:
-	i2c_unregister_device(driver_dev->gyro_client);
-	return err;
-}
-
-static const struct of_device_id smi130_acc_of_match[] = {
-	{.compatible = "mediatek,smi130_sensor"},
-	{},
-};
-static const struct i2c_device_id smi130_acc_i2c_id[] = {
-					{SMI130_I2C_NAME, 0}, {} };
-
-static struct i2c_driver smi130_acc_i2c_driver = {
-	.driver = {
-		.name = SMI130_I2C_NAME,
-		.bus = &i2c_bus_type,
-		.owner = THIS_MODULE,
-		.of_match_table = smi130_acc_of_match,
-	},
-	.probe = smi130_i2c_probe,
-	.remove = smi130_i2c_remove,
-	.id_table =  smi130_acc_i2c_id,
-};
-
-module_i2c_driver(smi130_acc_i2c_driver);
-
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("smi130 acc i2c driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/smi130_i2c.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/smi130_i2c.h
deleted file mode 100644
index 7287976..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/smi130_i2c/smi130_i2c.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#ifndef __SMI130_ACC_H__
-#define __SMI130_ACC_H__
-
-	/*Define of registers*/
-
-	 /* Hard Wired */
-#define SMI130_ACC_CHIP_ID_ADDR                     0x00
-	/**<Address of Chip ID Register*/
-
-	/* Data Register */
-#define SMI130_ACC_RATE_X_LSB_ADDR                  0x02
-	/**<	Address of X axis Rate LSB Register	*/
-#define SMI130_ACC_RATE_X_MSB_ADDR                  0x03
-	/**<	Address of X axis Rate MSB Register	*/
-#define SMI130_ACC_RATE_Y_LSB_ADDR                  0x04
-	/**<	Address of Y axis Rate LSB Register	*/
-#define SMI130_ACC_RATE_Y_MSB_ADDR                  0x05
-	/**<	Address of Y axis Rate MSB Register	*/
-#define SMI130_ACC_RATE_Z_LSB_ADDR                  0x06
-	/**<	Address of Z axis Rate LSB Register	*/
-#define SMI130_ACC_RATE_Z_MSB_ADDR                  0x07
-	/**<	Address of Z axis Rate MSB Register	*/
-#define SMI130_ACC_TEMP_ADDR                        0x08
-	/**<   Address of Temperature Data LSB Register */
-
-#define SMI130_ACC_INT_STATUS1_ADDR                 0x0A
-	/**<   Address of Interrupt status Register 1*/
-
-	/* Control Register */
-#define SMI130_ACC_RANGE_ADDR                       0x0F
-	/**<	Address of Range address Register */
-#define SMI130_ACC_BW_ADDR                          0x10
-	/**<	Address of Bandwidth Register */
-#define SMI130_ACC_RATED_HBW_ADDR                   0x13
-	/**<	Address of Rate HBW Register */
-#define SMI130_ACC_BGW_SOFTRESET_ADDR               0x14
-	/**<	Address of BGW Softreset Register  */
-
-#define SMI130_ACC_INT_ENABLE1_ADDR                 0x17
-	/**<        Address of Interrupt Enable 1  */
-
-#define SMI130_ACC_INT_MAP_1_ADDR                   0x1A
-	/**<	Address of Interrupt MAP 1  */
-
-#define SMI130_ACC_INT_SRC_ADDR                     0x1E
-	/**<	Address of Interrupt SRC 1  */
-
-#define SMI130_ACC_INT_OUT_CTRL_ADDR                0x20
-	/**<	Address of Interrupt MAP 1  */
-
-#define SMI130_ACC_BGW_SPI3_WDT_ADDR                0x34
-	/**<	Address of BGW SPI3,WDT Register  */
-
-#define SMI130_ACC_SELF_TEST_ADDR                   0x32
-	/**<	Address of BGW Self test Register  */
-
-#define SMI130_ACC_DATA_INT_EN                      0x10
-
-/* gyro reg */
-#define SMI130_GYRO_CHIP_ID_ADDR                     0x00
-	/**<Address of Chip ID Register  */
-
-	/* Data Register */
-#define SMI130_GYRO_RATE_X_LSB_ADDR                  0x02
-	/**<	 Address of X axis Rate LSB Register  */
-#define SMI130_GYRO_RATE_X_MSB_ADDR                  0x03
-	/**<	 Address of X axis Rate MSB Register  */
-#define SMI130_GYRO_RATE_Y_LSB_ADDR                  0x04
-	/**<	 Address of Y axis Rate LSB Register  */
-#define SMI130_GYRO_RATE_Y_MSB_ADDR                  0x05
-	/**<	 Address of Y axis Rate MSB Register  */
-#define SMI130_GYRO_RATE_Z_LSB_ADDR                  0x06
-	/**<	 Address of Z axis Rate LSB Register  */
-#define SMI130_GYRO_RATE_Z_MSB_ADDR                  0x07
-	/**<	 Address of Z axis Rate MSB Register  */
-#define SMI130_GYRO_TEMP_ADDR                        0x08
-	/**<	 Address of Temperature Data LSB Register */
-
-#define SMI130_GYRO_INT_STATUS1_ADDR                 0x0A
-	/**<	 Address of Interrupt status Register 1  */
-
-	/* Control Register */
-#define SMI130_GYRO_RANGE_ADDR                       0x0F
-	/**<	 Address of Range address Register  */
-#define SMI130_GYRO_BW_ADDR                          0x10
-	/**<	 Address of Bandwidth Register  */
-#define SMI130_GYRO_RATED_HBW_ADDR                   0x13
-	/**<	 Address of Rate HBW Register  */
-#define SMI130_GYRO_BGW_SOFTRESET_ADDR               0x14
-	/**<	 Address of BGW Softreset Register  */
-#define SMI130_GYRO_INT_ENABLE0_ADDR                 0x15
-	/**<    Address of Interrupt Enable 0  */
-#define SMI130_GYRO_INT_ENABLE1_ADDR                 0x16
-	/**<    Address of Interrupt Enable 1  */
-
-#define SMI130_GYRO_INT_MAP_1_ADDR                   0x18
-	/**<	Address of Interrupt MAP 0  */
-
-#define SMI130_GYRO_BGW_SPI3_WDT_ADDR                0x34
-	/**<    Address of BGW SPI3,WDT Register  */
-
-#define SMI130_GYRO_SELF_TEST_ADDR                   0x3C
-	/**<	Address of BGW Self test Register  */
-
-
-#define SMI130_GYRO_DATA_INT_EN                      0x80
-
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/Kconfig
deleted file mode 100644
index c9e2325..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-config MTK_HF_TEST_CASE
-	bool "high frequency manager test demo for MediaTek package"
-	help
-	  It support high frequency manager test demo.
-	  If this option is set,
-	  it will support
-	  high frequency manager test demo.
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/Makefile
deleted file mode 100644
index 0a6dae4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensor/2.0/core
-
-obj-y += test.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test.c
deleted file mode 100644
index 6ca6239..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test.c
+++ /dev/null
@@ -1,138 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/of.h>
-
-#include "hf_manager.h"
-
-struct test_device {
-	struct hf_device hf_dev;
-};
-
-struct test_device test_driver1;
-struct test_device test_driver2;
-struct test_device test_driver3;
-struct test_device test_driver4;
-
-static unsigned char support_sensors1[] = {
-	1,
-};
-static unsigned char support_sensors2[] = {
-	2,
-};
-static unsigned char support_sensors3[] = {
-	3,
-};
-static unsigned char support_sensors4[] = {
-	4,
-};
-
-static int test_enable(struct hf_device *hfdev, int sensor_type, int en)
-{
-	pr_debug("%s id:%d en:%d\n", __func__, sensor_type, en);
-	return 0;
-}
-
-static int test_batch(struct hf_device *hfdev, int sensor_type,
-		int64_t delay, int64_t latency)
-{
-	pr_debug("%s id:%d delay:%lld latency:%lld\n", __func__, sensor_type,
-		delay, latency);
-	return 0;
-}
-
-static int test_sample(struct hf_device *hfdev)
-{
-	struct test_device *driver_dev = hf_device_get_private_data(hfdev);
-	struct hf_manager *manager = driver_dev->hf_dev.manager;
-
-	pr_debug("%s %s\n", __func__, driver_dev->hf_dev.dev_name);
-	manager->complete(manager);
-	return 0;
-}
-
-static int tests_init(void)
-{
-	int err = 0;
-
-	test_driver1.hf_dev.dev_name = "test_driver1";
-	test_driver1.hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	test_driver1.hf_dev.device_bus = HF_DEVICE_IO_SYNC;
-	test_driver1.hf_dev.support_list = support_sensors1;
-	test_driver1.hf_dev.support_size = ARRAY_SIZE(support_sensors1);
-	test_driver1.hf_dev.enable = test_enable;
-	test_driver1.hf_dev.batch = test_batch;
-	test_driver1.hf_dev.sample = test_sample;
-
-	err = hf_manager_create(&test_driver1.hf_dev);
-	if (err < 0)
-		pr_err("%s hf_manager_create fail\n", __func__);
-	hf_device_set_private_data(&test_driver1.hf_dev, &test_driver1);
-
-	test_driver2.hf_dev.dev_name = "test_driver2";
-	test_driver2.hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	test_driver2.hf_dev.device_bus = HF_DEVICE_IO_SYNC;
-	test_driver2.hf_dev.support_list = support_sensors2;
-	test_driver2.hf_dev.support_size = ARRAY_SIZE(support_sensors2);
-	test_driver2.hf_dev.enable = test_enable;
-	test_driver2.hf_dev.batch = test_batch;
-	test_driver2.hf_dev.sample = test_sample;
-
-	err = hf_manager_create(&test_driver2.hf_dev);
-	if (err < 0)
-		pr_err("%s hf_manager_create fail\n", __func__);
-	hf_device_set_private_data(&test_driver2.hf_dev, &test_driver2);
-
-	test_driver3.hf_dev.dev_name = "test_driver3";
-	test_driver3.hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	test_driver3.hf_dev.device_bus = HF_DEVICE_IO_ASYNC;
-	test_driver3.hf_dev.support_list = support_sensors3;
-	test_driver3.hf_dev.support_size = ARRAY_SIZE(support_sensors3);
-	test_driver3.hf_dev.enable = test_enable;
-	test_driver3.hf_dev.batch = test_batch;
-	test_driver3.hf_dev.sample = test_sample;
-
-	err = hf_manager_create(&test_driver3.hf_dev);
-	if (err < 0)
-		pr_err("%s hf_manager_create fail\n", __func__);
-	hf_device_set_private_data(&test_driver3.hf_dev, &test_driver3);
-
-	test_driver4.hf_dev.dev_name = "test_driver4";
-	test_driver4.hf_dev.device_poll = HF_DEVICE_IO_POLLING;
-	test_driver4.hf_dev.device_bus = HF_DEVICE_IO_ASYNC;
-	test_driver4.hf_dev.support_list = support_sensors4;
-	test_driver4.hf_dev.support_size = ARRAY_SIZE(support_sensors4);
-	test_driver4.hf_dev.enable = test_enable;
-	test_driver4.hf_dev.batch = test_batch;
-	test_driver4.hf_dev.sample = test_sample;
-
-	err = hf_manager_create(&test_driver4.hf_dev);
-	if (err < 0)
-		pr_err("%s hf_manager_create fail\n", __func__);
-	hf_device_set_private_data(&test_driver4.hf_dev, &test_driver4);
-	return 0;
-}
-
-static int __init test_init(void)
-{
-	tests_init();
-	return 0;
-}
-
-static void __exit test_exit(void)
-{
-
-}
-
-module_init(test_init);
-module_exit(test_exit);
-
-
-MODULE_AUTHOR("Mediatek");
-MODULE_DESCRIPTION("test driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app.c
deleted file mode 100644
index 33713a8..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app.c
+++ /dev/null
@@ -1,181 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2020 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[test_app] " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/kthread.h>
-#include <linux/kobject.h>
-
-#include "hf_manager.h"
-
-struct test_app_t {
-	struct task_struct *task;
-	struct hf_client *client;
-	struct kobject *kobj;
-	int sensor_type;
-	int val1;
-	int val2;
-};
-
-static struct test_app_t test_app;
-
-static int test_app_kthread(void *arg)
-{
-	struct hf_client *client = NULL;
-	struct hf_manager_event data[4];
-	int size = 0, i = 0;
-
-	client = hf_client_create();
-	if (!client) {
-		pr_err("hf_client_create fail\n");
-		return -ENOMEM;
-	}
-	test_app.client = client;
-
-	while (!kthread_should_stop()) {
-		memset(data, 0, sizeof(data));
-		size = hf_client_poll_sensor(client, data, ARRAY_SIZE(data));
-		if (size < 0)
-			continue;
-		for (i = 0; i < size; ++i) {
-			pr_info_ratelimited("[%d,%d,%lld,%d,%d,%d]\n",
-				data[i].sensor_type,
-				data[i].action,
-				data[i].timestamp,
-				data[i].word[0],
-				data[i].word[1],
-				data[i].word[2]);
-
-			/* need derequest sensor cali */
-			switch (data[i].action) {
-			case CALI_ACTION:
-				hf_client_request_sensor_cali(test_app.client,
-					test_app.sensor_type,
-					HF_MANAGER_REQUEST_CALI_DATA,
-					false);
-				break;
-			case TEST_ACTION:
-				hf_client_request_sensor_cali(test_app.client,
-					test_app.sensor_type,
-					HF_MANAGER_REQUEST_TEST_DATA,
-					false);
-				break;
-			}
-		}
-	}
-	return 0;
-}
-
-#define test_app_attr(_name) \
-static struct kobj_attribute _name##_attr = {	\
-	.attr	= {				\
-		.name = __stringify(_name),	\
-		.mode = 0644,			\
-	},					\
-	.show	= _name##_show,			\
-	.store	= _name##_store,		\
-}
-
-static ssize_t control_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return sprintf(buf, "sensor_type=%u,val1=%u,val2=%u\n",
-		test_app.sensor_type,
-		test_app.val1,
-		test_app.val2);
-}
-
-static ssize_t control_store(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		const char *buf, size_t n)
-{
-	int ret = 0;
-	struct hf_manager_cmd cmd;
-
-	if (!test_app.client)
-		goto out;
-
-	ret = sscanf(buf, "%u,%u,%u", &test_app.sensor_type,
-		&test_app.val1, &test_app.val2);
-	if (ret != 3) {
-		pr_err("control store param error\n");
-		goto out;
-	}
-
-	ret = hf_client_find_sensor(test_app.client, test_app.sensor_type);
-	if (ret < 0) {
-		pr_err("hf_client_find_sensor %u fail\n",
-			test_app.sensor_type);
-		goto out;
-	}
-
-	switch (test_app.val1) {
-	case HF_MANAGER_SENSOR_ENABLE_CALI:
-		hf_client_request_sensor_cali(test_app.client,
-			test_app.sensor_type,
-			HF_MANAGER_REQUEST_CALI_DATA,
-			true);
-		break;
-	case HF_MANAGER_SENSOR_SELFTEST:
-		hf_client_request_sensor_cali(test_app.client,
-			test_app.sensor_type,
-			HF_MANAGER_REQUEST_TEST_DATA,
-			true);
-		break;
-	}
-
-	memset(&cmd, 0, sizeof(cmd));
-	cmd.sensor_type = test_app.sensor_type;
-	cmd.action = test_app.val1;
-	cmd.delay = test_app.val2;
-	cmd.latency = 0;
-	ret = hf_client_control_sensor(test_app.client, &cmd);
-	if (ret < 0) {
-		pr_err("hf_client_control_sensor %u fail\n",
-			test_app.sensor_type);
-		goto out;
-	}
-out:
-	return n;
-}
-
-test_app_attr(control);
-
-static struct attribute *attr[] = {
-	&control_attr.attr,
-	NULL,
-};
-
-static const struct attribute_group attr_group = {
-	.attrs = attr,
-};
-
-static int __init test_app_init(void)
-{
-	test_app.task = kthread_run(test_app_kthread,
-		&test_app, "test_app");
-	if (IS_ERR(test_app.task))
-		pr_err("kthread_run create fail\n");
-
-	test_app.kobj = kobject_create_and_add("test_app", NULL);
-	if (!test_app.kobj) {
-		pr_err("kobject create fail\n");
-		return -ENOMEM;
-	}
-	if (sysfs_create_group(test_app.kobj, &attr_group)) {
-		pr_err("sysfs create fail\n");
-		return -EFAULT;
-	}
-	return 0;
-}
-
-module_init(test_app_init);
-
-MODULE_DESCRIPTION("high frequency manager test");
-MODULE_AUTHOR("Hongxu Zhao <hongxu.zhao@mediatek.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app1.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app1.c
deleted file mode 100644
index 994bd60..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app1.c
+++ /dev/null
@@ -1,202 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2020 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[test_app1] " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/kobject.h>
-
-#include "hf_manager.h"
-
-#define test_app_attr(_name) \
-static struct kobj_attribute _name##_attr = {	\
-	.attr	= {				\
-		.name = __stringify(_name),	\
-		.mode = 0644,			\
-	},					\
-	.show	= _name##_show,			\
-}
-
-static ssize_t test_app1_cmd(char *buf, int sensor_type,
-		int action, unsigned int request)
-{
-	ssize_t ret = 0;
-	struct hf_client *client = NULL;
-	struct hf_manager_cmd cmd;
-	struct hf_manager_event data[1];
-
-	client = hf_client_create();
-	if (!client) {
-		pr_err("hf_client_create fail\n");
-		return -ENOMEM;
-	}
-	ret = hf_client_find_sensor(client, sensor_type);
-	if (ret < 0) {
-		pr_err("hf_client_find_sensor %u fail\n", sensor_type);
-		goto out;
-	}
-	hf_client_request_sensor_cali(client, sensor_type,
-		request, true);
-	memset(&cmd, 0, sizeof(cmd));
-	cmd.sensor_type = sensor_type;
-	cmd.action = action;
-	ret = hf_client_control_sensor(client, &cmd);
-	if (ret < 0) {
-		pr_err("hf_client_control_sensor %u %u fail\n",
-			sensor_type, action);
-		goto out;
-	}
-	ret = hf_client_poll_sensor_timeout(client, data, ARRAY_SIZE(data),
-		msecs_to_jiffies(3000));
-	hf_client_request_sensor_cali(client, sensor_type,
-		request, false);
-	if (ret >= 0)
-		ret = sprintf(buf, "[%d,%d,%d,%lld,%d,%d,%d]\n",
-				data[0].sensor_type,
-				data[0].action,
-				data[0].accurancy,
-				data[0].timestamp,
-				data[0].word[0],
-				data[0].word[1],
-				data[0].word[2]);
-out:
-	hf_client_destroy(client);
-	return ret;
-}
-
-static ssize_t test_app1_cust(char *buf, int sensor_type,
-		int action)
-{
-	ssize_t ret = 0;
-	struct hf_client *client = NULL;
-	struct custom_cmd cmd;
-
-	client = hf_client_create();
-	if (!client) {
-		pr_err("hf_client_create fail\n");
-		return -ENOMEM;
-	}
-	ret = hf_client_find_sensor(client, sensor_type);
-	if (ret < 0) {
-		pr_err("hf_client_find_sensor %u fail\n", sensor_type);
-		goto out;
-	}
-	memset(&cmd, 0, sizeof(cmd));
-	cmd.data[0] = action;
-	ret = hf_client_custom_cmd(client, sensor_type, &cmd);
-	if (ret >= 0)
-		ret = sprintf(buf, "[%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d]\n",
-				cmd.data[0],
-				cmd.data[1],
-				cmd.data[2],
-				cmd.data[3],
-				cmd.data[4],
-				cmd.data[5],
-				cmd.data[6],
-				cmd.data[7],
-				cmd.data[8],
-				cmd.data[9],
-				cmd.data[10],
-				cmd.data[11]);
-out:
-	hf_client_destroy(client);
-	return ret;
-}
-
-static ssize_t acc_cali_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return test_app1_cmd(buf, SENSOR_TYPE_ACCELEROMETER,
-			HF_MANAGER_SENSOR_ENABLE_CALI,
-			HF_MANAGER_REQUEST_CALI_DATA);
-}
-
-static ssize_t acc_cust_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return test_app1_cust(buf, SENSOR_TYPE_ACCELEROMETER,
-			CUST_CMD_CALI);
-}
-
-
-static ssize_t acc_seltest_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return test_app1_cmd(buf, SENSOR_TYPE_ACCELEROMETER,
-			HF_MANAGER_SENSOR_SELFTEST,
-			HF_MANAGER_REQUEST_TEST_DATA);
-}
-
-static ssize_t gyro_cali_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return test_app1_cmd(buf, SENSOR_TYPE_GYROSCOPE,
-			HF_MANAGER_SENSOR_ENABLE_CALI,
-			HF_MANAGER_REQUEST_CALI_DATA);
-}
-
-static ssize_t gyro_cust_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return test_app1_cust(buf, SENSOR_TYPE_GYROSCOPE,
-			CUST_CMD_CALI);
-}
-
-static ssize_t gyro_selftest_show(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		char *buf)
-{
-	return test_app1_cmd(buf, SENSOR_TYPE_GYROSCOPE,
-			HF_MANAGER_SENSOR_SELFTEST,
-			HF_MANAGER_REQUEST_TEST_DATA);
-}
-
-test_app_attr(acc_cali);
-test_app_attr(acc_cust);
-test_app_attr(acc_seltest);
-test_app_attr(gyro_cali);
-test_app_attr(gyro_cust);
-test_app_attr(gyro_selftest);
-
-static struct attribute *attr[] = {
-	&acc_cali_attr.attr,
-	&acc_cust_attr.attr,
-	&acc_seltest_attr.attr,
-	&gyro_cali_attr.attr,
-	&gyro_cust_attr.attr,
-	&gyro_selftest_attr.attr,
-	NULL,
-};
-
-static const struct attribute_group attr_group = {
-	.attrs = attr,
-};
-
-static int __init test_app_init(void)
-{
-	struct kobject *kobj = kobject_create_and_add("test_app1", NULL);
-
-	if (!kobj) {
-		pr_err("kobject create fail\n");
-		return -ENOMEM;
-	}
-	if (sysfs_create_group(kobj, &attr_group)) {
-		pr_err("sysfs create fail\n");
-		return -EFAULT;
-	}
-	return 0;
-}
-
-module_init(test_app_init);
-
-MODULE_DESCRIPTION("high frequency manager test");
-MODULE_AUTHOR("Hongxu Zhao <hongxu.zhao@mediatek.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app2.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app2.c
deleted file mode 100644
index 9066f32..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensor/2.0/test/test_app2.c
+++ /dev/null
@@ -1,160 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2020 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[test_app2] " fmt
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/kthread.h>
-#include <linux/kobject.h>
-
-#include "hf_manager.h"
-
-struct test_app_t {
-	struct task_struct *task;
-	struct hf_client *client;
-};
-
-static struct test_app_t test_app;
-
-static int test_app_kthread(void *arg)
-{
-	struct hf_client *client = test_app.client;
-	struct hf_manager_event data[4];
-	int size = 0, i = 0;
-
-	if (!client)
-		return -EINVAL;
-
-	while (!kthread_should_stop()) {
-		memset(data, 0, sizeof(data));
-		/*
-		 * must use timeout api to wakeup kthread and do exit
-		 * otherwise kthread_stop will be blocked forever
-		 */
-		size = hf_client_poll_sensor_timeout(client, data,
-			ARRAY_SIZE(data), msecs_to_jiffies(500));
-		if (size < 0)
-			continue;
-		for (i = 0; i < size; ++i) {
-			pr_info_ratelimited("[%d,%d,%lld,%d,%d,%d]\n",
-				data[i].sensor_type,
-				data[i].action,
-				data[i].timestamp,
-				data[i].word[0],
-				data[i].word[1],
-				data[i].word[2]);
-		}
-	}
-	return 0;
-}
-
-#define test_app_attr(_name) \
-static struct kobj_attribute _name##_attr = {	\
-	.attr	= {				\
-		.name = __stringify(_name),	\
-		.mode = 0644,			\
-	},					\
-	.store	= _name##_store,		\
-}
-
-static ssize_t control_store(struct kobject *kobj,
-		struct kobj_attribute *attr,
-		const char *buf, size_t n)
-{
-	int ret = 0;
-	int sensor_type = 0, val1 = 0, val2 = 0;
-	struct hf_manager_cmd cmd;
-
-	ret = sscanf(buf, "%u,%u,%u", &sensor_type, &val1, &val2);
-	if (ret != 3) {
-		pr_err("control store param error\n");
-		return -EINVAL;
-	}
-
-	if (val1 == HF_MANAGER_SENSOR_ENABLE) {
-		if (test_app.client)
-			return -EINVAL;
-		test_app.client = hf_client_create();
-		if (!test_app.client) {
-			pr_err("hf_client_create fail\n");
-			return -ENOMEM;
-		}
-		if (!test_app.task) {
-			test_app.task = kthread_run(test_app_kthread,
-				&test_app, "test_app2");
-			if (IS_ERR(test_app.task)) {
-				pr_err("kthread_run create fail\n");
-				return -ENOMEM;
-			}
-		}
-		ret = hf_client_find_sensor(test_app.client, sensor_type);
-		if (ret < 0) {
-			pr_err("hf_client_find_sensor %u fail\n",
-				sensor_type);
-			return -EINVAL;
-		}
-		memset(&cmd, 0, sizeof(cmd));
-		cmd.sensor_type = sensor_type;
-		cmd.action = val1;
-		cmd.delay = val2;
-		cmd.latency = 0;
-		ret = hf_client_control_sensor(test_app.client, &cmd);
-		if (ret < 0) {
-			pr_err("hf_client_control_sensor %u fail\n",
-				sensor_type);
-			return -EINVAL;
-		}
-	} else if (val1 == HF_MANAGER_SENSOR_DISABLE) {
-		if (test_app.client) {
-			memset(&cmd, 0, sizeof(cmd));
-			cmd.sensor_type = sensor_type;
-			cmd.action = val1;
-			hf_client_control_sensor(test_app.client, &cmd);
-		}
-		if (test_app.task) {
-			kthread_stop(test_app.task);
-			test_app.task = NULL;
-		}
-		if (test_app.client) {
-			hf_client_destroy(test_app.client);
-			test_app.client = NULL;
-		}
-	}
-
-	return n;
-}
-
-test_app_attr(control);
-
-static struct attribute *attr[] = {
-	&control_attr.attr,
-	NULL,
-};
-
-static const struct attribute_group attr_group = {
-	.attrs = attr,
-};
-
-static int __init test_app_init(void)
-{
-	struct kobject *kobj = kobject_create_and_add("test_app2", NULL);
-
-	if (!kobj) {
-		pr_err("kobject create fail\n");
-		return -ENOMEM;
-	}
-	if (sysfs_create_group(kobj, &attr_group)) {
-		pr_err("sysfs create fail\n");
-		return -EFAULT;
-	}
-	return 0;
-}
-
-module_init(test_app_init);
-
-MODULE_DESCRIPTION("high frequency manager test");
-MODULE_AUTHOR("Hongxu Zhao <hongxu.zhao@mediatek.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/Kconfig
deleted file mode 100644
index ecb7f31..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/Kconfig
+++ /dev/null
@@ -1,18 +0,0 @@
-config MTK_SENSOR_SUPPORT
-	tristate "MTK_SENSOR_SUPPORT"
-	help
-		Sensor config for sensor feature in project.
-		Please say y here if you want to support sensors
-		with mediatek sesnor architecture.
-		If unsure, say N.
-
-source "drivers/misc/mediatek/sensors-1.0/accelerometer/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/alsps/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/gyroscope/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/magnetometer/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/hwmon/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/barometer/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/step_counter/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/sensorHub/Kconfig"
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/Makefile
deleted file mode 100644
index 3e6a9f9..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-ifneq ($(CONFIG_MTK_SENSOR_SUPPORT), n)
-obj-$(CONFIG_CUSTOM_KERNEL_SENSORHUB)	+= sensorHub/
-obj-$(CONFIG_MTK_HWMON)	    += hwmon/
-obj-y += sensor_probe/
-obj-$(CONFIG_CUSTOM_KERNEL_ALSPS) += alsps/
-ifeq ($(CONFIG_CUSTOM_KERNEL_ACCELGYRO),y)
-obj-y += accelgyro/
-else
-obj-$(CONFIG_CUSTOM_KERNEL_ACCELEROMETER) += accelerometer/
-obj-$(CONFIG_CUSTOM_KERNEL_GYROSCOPE) += gyroscope/
-endif
-obj-$(CONFIG_CUSTOM_KERNEL_MAGNETOMETER) += magnetometer/
-obj-$(CONFIG_CUSTOM_KERNEL_BAROMETER) += barometer/
-obj-$(CONFIG_CUSTOM_KERNEL_STEP_COUNTER)	+= step_counter/
-obj-$(CONFIG_CUSTOM_KERNEL_SIGNIFICANT_MOTION_SENSOR)	+= step_counter/
-obj-$(CONFIG_CUSTOM_KERNEL_SITUATION) += situation/
-else
-obj-y += dummy.o
-endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/Kconfig
deleted file mode 100644
index 770be71..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/Kconfig
+++ /dev/null
@@ -1,24 +0,0 @@
-
-config MTK_AUTO_DETECT_ACCELEROMETER
-	bool "MTK AUTO DETECT ACCELEROMETER Sensor"
-	depends on MTK_SENSOR_SUPPORT
-	help
-	  one load to support different accelerometer sensor.
-	  If this option is set, multiple accelerometer driver
-	  can be configured at the same time, but only one
-	  can be probed.
-
-config CUSTOM_KERNEL_ACCELEROMETER
-	bool "CUSTOM KERNEL ACCELEROMETER Config"
-	help
-	  accelerometer sensor to detect accelerometer from x y z axis.
-	  If the platform is supported for acceleometer, this
-	  configuration should be configured, and the acceleometer
-	  driver configuration should be configured as well.
-
-source "drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/accelerometer/bmi160-i2c/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/accelerometer/lis3dh/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/accelerometer/mc3410-i2c/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/accelerometer/mc3433/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/accelerometer/mpu6050g/Kconfig"
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/Makefile
deleted file mode 100644
index 542e4e4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/Makefile
+++ /dev/null
@@ -1,13 +0,0 @@
-# In case the platform does NOT support this type of sensors
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/include
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)   +=  accel_common.o
-accel_common-$(CONFIG_MTK_SENSOR_SUPPORT) := accel.o accel_factory.o
-
-obj-$(CONFIG_MTK_ACCELHUB) += accelhub/
-#obj-$(CONFIG_MTK_BMI160_I2C)   += bmi160-i2c/
-#obj-$(CONFIG_MTK_LIS3DH_NEW) += lis3dh/
-#obj-$(CONFIG_MTK_MC3410_I2C) += mc3410-i2c/
-#obj-$(CONFIG_MTK_MC3433) += mc3433/
-#obj-$(CONFIG_MTK_MPU6050G) += mpu6050g/
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accel.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accel.c
deleted file mode 100644
index 6caf589..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accel.c
+++ /dev/null
@@ -1,871 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<ACCELEROMETER> " fmt
-#include "inc/accel.h"
-#include "inc/accel_factory.h"
-#include "sensor_performance.h"
-#include <linux/vmalloc.h>
-
-struct acc_context *acc_context_obj /* = NULL*/;
-
-static struct acc_init_info *gsensor_init_list[MAX_CHOOSE_G_NUM] = {0};
-
-static int64_t getCurNS(void)
-{
-	int64_t ns;
-	struct timespec time;
-
-	time.tv_sec = time.tv_nsec = 0;
-	get_monotonic_boottime(&time);
-	ns = time.tv_sec * 1000000000LL + time.tv_nsec;
-
-	return ns;
-}
-
-static void initTimer(struct hrtimer *timer,
-		      enum hrtimer_restart (*callback)(struct hrtimer *))
-{
-	hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
-	timer->function = callback;
-}
-
-static void startTimer(struct hrtimer *timer, int delay_ms, bool first)
-{
-	struct acc_context *obj = (struct acc_context *)container_of(timer,
-		struct acc_context, hrTimer);
-	static int count;
-
-	if (obj == NULL) {
-		pr_err("NULL pointer\n");
-		return;
-	}
-
-	if (first) {
-		obj->target_ktime =
-			ktime_add_ns(ktime_get(), (int64_t)delay_ms * 1000000);
-		/* pr_debug("%d, cur_nt = %lld, delay_ms = %d,
-		 * target_nt = %lld\n",count, getCurNT(),
-		 * delay_ms, ktime_to_us(obj->target_ktime));
-		 */
-		count = 0;
-	} else {
-		do {
-			obj->target_ktime = ktime_add_ns(
-				obj->target_ktime, (int64_t)delay_ms * 1000000);
-		} while (ktime_to_ns(obj->target_ktime) <
-			 ktime_to_ns(ktime_get()));
-		/* pr_debug("%d, cur_nt = %lld, delay_ms = %d,
-		 * target_nt = %lld\n",
-		 *  count, getCurNT(), delay_ms,
-		 * ktime_to_us(obj->target_ktime));
-		 */
-		count++;
-	}
-
-	hrtimer_start(timer, obj->target_ktime, HRTIMER_MODE_ABS);
-}
-
-#ifndef CONFIG_NANOHUB
-static void stopTimer(struct hrtimer *timer)
-{
-	hrtimer_cancel(timer);
-}
-#endif
-static void acc_work_func(struct work_struct *work)
-{
-	struct acc_context *cxt = NULL;
-	int x, y, z, status;
-	int64_t pre_ns, cur_ns;
-	int64_t delay_ms;
-	int err;
-
-	cxt = acc_context_obj;
-	delay_ms = atomic_read(&cxt->delay);
-
-	if (cxt->acc_data.get_data == NULL) {
-		pr_err("acc driver not register data path\n");
-		return;
-	}
-
-	cur_ns = getCurNS();
-
-	err = cxt->acc_data.get_data(&x, &y, &z, &status);
-
-	if (err) {
-		pr_err("get acc data fails!!\n");
-		goto acc_loop;
-	} else {
-		if (0 == x && 0 == y && 0 == z)
-			goto acc_loop;
-
-		cxt->drv_data.x = x;
-		cxt->drv_data.y = y;
-		cxt->drv_data.z = z;
-		cxt->drv_data.status = status;
-		pre_ns = cxt->drv_data.timestamp;
-		cxt->drv_data.timestamp = cur_ns;
-	}
-
-	if (true == cxt->is_first_data_after_enable) {
-		pre_ns = cur_ns;
-		cxt->is_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.x == ACC_INVALID_VALUE ||
-		    cxt->drv_data.y == ACC_INVALID_VALUE ||
-		    cxt->drv_data.z == ACC_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto acc_loop;
-		}
-	}
-	/* report data to input device */
-	/* printk("new acc work run....\n"); */
-	/* pr_debug("acc data[%d,%d,%d]\n" ,cxt->drv_data.acc_data.values[0],*/
-	/* cxt->drv_data.acc_data.values[1],cxt->drv_data.acc_data.values[2]);*/
-
-	while ((cur_ns - pre_ns) >= delay_ms * 1800000LL) {
-		struct acc_data tmp_data = cxt->drv_data;
-
-		pre_ns += delay_ms * 1000000LL;
-		tmp_data.timestamp = pre_ns;
-		acc_data_report(&tmp_data);
-	}
-
-	acc_data_report(&cxt->drv_data);
-
-acc_loop:
-	if (true == cxt->is_polling_run)
-		startTimer(&cxt->hrTimer, atomic_read(&cxt->delay), false);
-}
-
-enum hrtimer_restart acc_poll(struct hrtimer *timer)
-{
-	struct acc_context *obj = (struct acc_context *)container_of(timer,
-		struct acc_context, hrTimer);
-
-	queue_work(obj->accel_workqueue, &obj->report);
-
-	/* pr_debug("cur_ns = %lld\n", getCurNS()); */
-
-	return HRTIMER_NORESTART;
-}
-
-static struct acc_context *acc_context_alloc_object(void)
-{
-
-	struct acc_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc accel object error!\n");
-		return NULL;
-	}
-	atomic_set(&obj->delay, 200); /*5Hz,set work queue delay time 200ms */
-	atomic_set(&obj->wake, 0);
-	INIT_WORK(&obj->report, acc_work_func);
-	obj->accel_workqueue = NULL;
-	obj->accel_workqueue = create_workqueue("accel_polling");
-	if (!obj->accel_workqueue) {
-		kfree(obj);
-		return NULL;
-	}
-	initTimer(&obj->hrTimer, acc_poll);
-	obj->is_active_nodata = false;
-	obj->is_active_data = false;
-	obj->is_first_data_after_enable = false;
-	obj->is_polling_run = false;
-	mutex_init(&obj->acc_op_mutex);
-	obj->is_batch_enable = false; /* for batch mode init */
-	obj->cali_sw[ACC_AXIS_X] = 0;
-	obj->cali_sw[ACC_AXIS_Y] = 0;
-	obj->cali_sw[ACC_AXIS_Z] = 0;
-	obj->power = 0;
-	obj->enable = 0;
-	obj->delay_ns = -1;
-	obj->latency_ns = -1;
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-
-#ifndef CONFIG_NANOHUB
-static int acc_enable_and_batch(void)
-{
-	struct acc_context *cxt = acc_context_obj;
-	int err;
-
-	/* power on -> power off */
-	if (cxt->power == 1 && cxt->enable == 0) {
-		pr_debug("ACC disable\n");
-		/* stop polling firstly, if needed */
-		if (cxt->is_active_data == false &&
-		    cxt->acc_ctl.is_report_input_direct == false &&
-		    cxt->is_polling_run == true) {
-			smp_mb(); /* for memory barrier */
-			stopTimer(&cxt->hrTimer);
-			smp_mb(); /* for memory barrier */
-			cancel_work_sync(&cxt->report);
-			cxt->drv_data.x = ACC_INVALID_VALUE;
-			cxt->drv_data.y = ACC_INVALID_VALUE;
-			cxt->drv_data.z = ACC_INVALID_VALUE;
-			cxt->is_polling_run = false;
-			pr_debug("acc stop polling done\n");
-		}
-		/* turn off the power */
-		if (cxt->is_active_data == false &&
-		    cxt->is_active_nodata == false) {
-			err = cxt->acc_ctl.enable_nodata(0);
-			if (err) {
-				pr_err("acc turn off power err:%d\n", err);
-				return -1;
-			}
-			pr_debug("acc turn off power done\n");
-		}
-
-		cxt->power = 0;
-		cxt->delay_ns = -1;
-		pr_debug("ACC disable done\n");
-		return 0;
-	}
-	/* power off -> power on */
-	if (cxt->power == 0 && cxt->enable == 1) {
-		pr_debug("ACC power on\n");
-		if (true == cxt->is_active_data ||
-		    true == cxt->is_active_nodata) {
-			err = cxt->acc_ctl.enable_nodata(1);
-			if (err) {
-				pr_err("acc turn on power err = %d\n", err);
-				return -1;
-			}
-			pr_debug("acc turn on power done\n");
-		}
-		cxt->power = 1;
-		pr_debug("ACC power on done\n");
-	}
-	/* rate change */
-	if (cxt->power == 1 && cxt->delay_ns >= 0) {
-		pr_debug("ACC set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->acc_ctl.is_support_batch)
-			err = cxt->acc_ctl.batch(0, cxt->delay_ns,
-						 cxt->latency_ns);
-		else
-			err = cxt->acc_ctl.batch(0, cxt->delay_ns, 0);
-		if (err) {
-			pr_err("acc set batch(ODR) err %d\n", err);
-			return -1;
-		}
-		pr_debug("acc set ODR, fifo latency done\n");
-		/* start polling, if needed */
-		if (cxt->is_active_data == true &&
-		    cxt->acc_ctl.is_report_input_direct == false) {
-			uint64_t mdelay = cxt->delay_ns;
-
-			do_div(mdelay, 1000000);
-			atomic_set(&cxt->delay, mdelay);
-			/* the first sensor start polling timer */
-			if (cxt->is_polling_run == false) {
-				cxt->is_polling_run = true;
-				cxt->is_first_data_after_enable = true;
-				startTimer(&cxt->hrTimer,
-					   atomic_read(&cxt->delay), true);
-			}
-			pr_debug("acc set polling delay %d ms\n",
-				atomic_read(&cxt->delay));
-		}
-		pr_debug("ACC batch done\n");
-	}
-	return 0;
-}
-#endif
-static ssize_t accenablenodata_store(struct device *dev,
-				       struct device_attribute *attr,
-				       const char *buf, size_t count)
-{
-#if !defined(CONFIG_MTK_SCP_SENSORHUB_V1) && !defined(CONFIG_NANOHUB)
-	struct acc_context *cxt = acc_context_obj;
-	int err = 0;
-
-	pr_debug("acc_store_enable nodata buf=%s\n", buf);
-	mutex_lock(&acc_context_obj->acc_op_mutex);
-	if (!strncmp(buf, "1", 1)) {
-		cxt->enable = 1;
-		cxt->is_active_nodata = true;
-	} else if (!strncmp(buf, "0", 1)) {
-		cxt->enable = 0;
-		cxt->is_active_nodata = false;
-	} else {
-		pr_err(" acc_store enable nodata cmd error !!\n");
-		err = -1;
-		goto err_out;
-	}
-	err = acc_enable_and_batch();
-err_out:
-	mutex_unlock(&acc_context_obj->acc_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-#else
-	return count;
-#endif
-}
-
-static ssize_t accenablenodata_show(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-static ssize_t accactive_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct acc_context *cxt = acc_context_obj;
-	int err = 0;
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&acc_context_obj->acc_op_mutex);
-	if (!strncmp(buf, "1", 1)) {
-		cxt->enable = 1;
-		cxt->is_active_data = true;
-	} else if (!strncmp(buf, "0", 1)) {
-		cxt->enable = 0;
-		cxt->is_active_data = false;
-	} else {
-		pr_err("%s error !!\n", __func__);
-		err = -1;
-		goto err_out;
-	}
-#ifdef CONFIG_NANOHUB
-	if (true == cxt->is_active_data || true == cxt->is_active_nodata) {
-		err = cxt->acc_ctl.enable_nodata(1);
-		if (err) {
-			pr_err("acc turn on power err = %d\n", err);
-			goto err_out;
-		}
-		pr_debug("acc turn on power done\n");
-	} else {
-		err = cxt->acc_ctl.enable_nodata(0);
-		if (err) {
-			pr_err("acc turn off power err = %d\n", err);
-			goto err_out;
-		}
-		pr_debug("acc turn off power done\n");
-	}
-#else
-	err = acc_enable_and_batch();
-#endif
-
-err_out:
-	mutex_unlock(&acc_context_obj->acc_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-/*----------------------------------------------------------------------------*/
-static ssize_t accactive_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	struct acc_context *cxt = acc_context_obj;
-	int div = 0;
-
-	div = cxt->acc_data.vender_div;
-	pr_debug("acc vender_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-/* need work around again */
-static ssize_t accdevnum_show(struct device *dev,
-				     struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t accbatch_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct acc_context *cxt = acc_context_obj;
-	int handle = 0, flag = 0, err = 0;
-
-	pr_debug("%s %s\n", __func__, buf);
-	err = sscanf(buf, "%d,%d,%lld,%lld", &handle, &flag, &cxt->delay_ns,
-		     &cxt->latency_ns);
-	if (err != 4) {
-		pr_err("%s param error: err = %d\n", __func__, err);
-		return -1;
-	}
-
-	mutex_lock(&acc_context_obj->acc_op_mutex);
-
-#ifdef CONFIG_NANOHUB
-	if (cxt->acc_ctl.is_support_batch)
-		err = cxt->acc_ctl.batch(0, cxt->delay_ns, cxt->latency_ns);
-	else
-		err = cxt->acc_ctl.batch(0, cxt->delay_ns, 0);
-	if (err)
-		pr_err("acc set batch(ODR) err %d\n", err);
-#else
-	err = acc_enable_and_batch();
-#endif
-
-	mutex_unlock(&acc_context_obj->acc_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-static ssize_t accbatch_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-static ssize_t accflush_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct acc_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&acc_context_obj->acc_op_mutex);
-	cxt = acc_context_obj;
-	if (cxt->acc_ctl.flush != NULL)
-		err = cxt->acc_ctl.flush();
-	else
-		pr_err("DON'T SUPPORT ACC COMMON VERSION FLUSH\n");
-	if (err < 0)
-		pr_err("acc enable flush err %d\n", err);
-	mutex_unlock(&acc_context_obj->acc_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t accflush_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t acccali_show(struct device *dev, struct device_attribute *attr,
-			     char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t acccali_store(struct device *dev, struct device_attribute *attr,
-			      const char *buf, size_t count)
-{
-	struct acc_context *cxt = NULL;
-	int err = 0;
-	uint8_t *cali_buf = NULL;
-
-	cali_buf = vzalloc(count);
-	if (cali_buf == NULL)
-		return -EFAULT;
-	memcpy(cali_buf, buf, count);
-
-	mutex_lock(&acc_context_obj->acc_op_mutex);
-	cxt = acc_context_obj;
-	if (cxt->acc_ctl.set_cali != NULL)
-		err = cxt->acc_ctl.set_cali(cali_buf, count);
-	else
-		pr_err("DON'T SUPPORT ACC COMMONVERSION FLUSH\n");
-	if (err < 0)
-		pr_err("acc set cali err %d\n", err);
-	mutex_unlock(&acc_context_obj->acc_op_mutex);
-	vfree(cali_buf);
-	return count;
-}
-
-static int gsensor_remove(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int gsensor_probe(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id gsensor_of_match[] = {
-	{
-		.compatible = "mediatek,gsensor",
-	},
-	{},
-};
-#endif
-static struct platform_driver gsensor_driver = {
-	.probe = gsensor_probe,
-	.remove = gsensor_remove,
-	.driver = {
-		.name = "gsensor",
-#ifdef CONFIG_OF
-		.of_match_table = gsensor_of_match,
-#endif
-	}
-};
-
-static int acc_real_driver_init(void)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_G_NUM; i++) {
-		pr_debug(" i=%d\n", i);
-		if (gsensor_init_list[i] != 0) {
-			pr_debug(" acc try to init driver %s\n",
-				gsensor_init_list[i]->name);
-			err = gsensor_init_list[i]->init();
-			if (err == 0) {
-				pr_debug(" acc real driver %s probe ok\n",
-					gsensor_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_G_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-
-static int acc_real_driver_uninit(void)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_G_NUM; i++) {
-		pr_debug(" i=%d\n", i);
-		if (gsensor_init_list[i] != 0) {
-			pr_debug(" acc try to init driver %s\n",
-				gsensor_init_list[i]->name);
-			err = gsensor_init_list[i]->uninit();
-			if (err == 0) {
-				pr_debug(" acc real driver %s uninit ok\n",
-					gsensor_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_G_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-
-int acc_driver_add(struct acc_init_info *obj)
-{
-	int err = 0;
-	int i = 0;
-
-	if (!obj) {
-		pr_err("ACC driver add fail, acc_init_info is NULL\n");
-		return -1;
-	}
-	for (i = 0; i < MAX_CHOOSE_G_NUM; i++) {
-		if ((i == 0) && (gsensor_init_list[0] == NULL)) {
-			pr_debug("register gensor driver for the first time\n");
-			if (platform_driver_register(&gsensor_driver))
-				pr_err("failed: driveralready exist\n");
-		}
-
-		if (gsensor_init_list[i] == NULL) {
-			obj->platform_diver_addr = &gsensor_driver;
-			gsensor_init_list[i] = obj;
-			break;
-		}
-	}
-	if (i >= MAX_CHOOSE_G_NUM) {
-		pr_err("ACC driver add err\n");
-		err = -1;
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(acc_driver_add);
-
-static int accel_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t accel_read(struct file *file, char __user *buffer, size_t count,
-			  loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(acc_context_obj->mdev.minor, file, buffer,
-				     count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int accel_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(acc_context_obj->mdev.minor, file, wait);
-}
-
-static const struct file_operations accel_fops = {
-	.owner = THIS_MODULE,
-	.open = accel_open,
-	.read = accel_read,
-	.poll = accel_poll,
-};
-
-static int acc_misc_init(struct acc_context *cxt)
-{
-	int err = 0;
-
-	cxt->mdev.minor = ID_ACCELEROMETER;
-	cxt->mdev.name = ACC_MISC_DEV_NAME;
-	cxt->mdev.fops = &accel_fops;
-	err = sensor_attr_register(&cxt->mdev);
-	if (err)
-		pr_err("unable to register acc misc device!!\n");
-	return err;
-}
-
-DEVICE_ATTR_RW(accenablenodata);
-DEVICE_ATTR_RW(accactive);
-DEVICE_ATTR_RW(accbatch);
-DEVICE_ATTR_RW(accflush);
-DEVICE_ATTR_RW(acccali);
-DEVICE_ATTR_RO(accdevnum);
-
-static struct attribute *acc_attributes[] = {
-	&dev_attr_accenablenodata.attr,
-	&dev_attr_accactive.attr,
-	&dev_attr_accbatch.attr,
-	&dev_attr_accflush.attr,
-	&dev_attr_acccali.attr,
-	&dev_attr_accdevnum.attr,
-	NULL
-};
-
-static struct attribute_group acc_attribute_group = {
-	.attrs = acc_attributes
-};
-
-int acc_register_data_path(struct acc_data_path *data)
-{
-	struct acc_context *cxt = NULL;
-
-	cxt = acc_context_obj;
-	cxt->acc_data.get_data = data->get_data;
-	cxt->acc_data.get_raw_data = data->get_raw_data;
-	cxt->acc_data.vender_div = data->vender_div;
-	pr_debug("acc register data path vender_div: %d\n",
-		cxt->acc_data.vender_div);
-	if (cxt->acc_data.get_data == NULL) {
-		pr_debug("acc register data path fail\n");
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(acc_register_data_path);
-
-int acc_register_control_path(struct acc_control_path *ctl)
-{
-	struct acc_context *cxt = NULL;
-	int err = 0;
-
-	cxt = acc_context_obj;
-	cxt->acc_ctl.enable_nodata = ctl->enable_nodata;
-	cxt->acc_ctl.batch = ctl->batch;
-	cxt->acc_ctl.flush = ctl->flush;
-	cxt->acc_ctl.set_cali = ctl->set_cali;
-	cxt->acc_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->acc_ctl.is_report_input_direct = ctl->is_report_input_direct;
-
-	if (cxt->acc_ctl.enable_nodata == NULL || cxt->acc_ctl.batch == NULL ||
-	    cxt->acc_ctl.flush == NULL) {
-		pr_debug("acc register control path fail\n");
-		return -1;
-	}
-	/* add misc dev for sensor hal control cmd */
-	err = acc_misc_init(acc_context_obj);
-	if (err) {
-		pr_err("unable to register acc misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&acc_context_obj->mdev.this_device->kobj,
-				 &acc_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create acc attribute file\n");
-		return -3;
-	}
-
-	kobject_uevent(&acc_context_obj->mdev.this_device->kobj, KOBJ_ADD);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(acc_register_control_path);
-
-int acc_data_report(struct acc_data *data)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.time_stamp = data->timestamp;
-	event.flush_action = DATA_ACTION;
-	event.status = data->status;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-	event.reserved = data->reserved[0];
-	/* pr_err("x:%d,y:%d,z:%d,time:%lld\n", data->x, data->y, data->z,
-	 * data->timestamp);
-	 */
-	if (event.reserved == 1)
-		mark_timestamp(ID_ACCELEROMETER, DATA_REPORT,
-			       ktime_get_boot_ns(), event.time_stamp);
-	err = sensor_input_event(acc_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(acc_data_report);
-
-int acc_bias_report(struct acc_data *data)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = BIAS_ACTION;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-	/* pr_err("x:%d,y:%d,z:%d,time:%lld\n", x, y, z, nt); */
-	err = sensor_input_event(acc_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(acc_bias_report);
-
-int acc_cali_report(struct acc_data *data)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = CALI_ACTION;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-	/* pr_err("x:%d,y:%d,z:%d,time:%lld\n", x, y, z, nt); */
-	err = sensor_input_event(acc_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(acc_cali_report);
-
-int acc_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	pr_debug_ratelimited("flush\n");
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(acc_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(acc_flush_report);
-
-int acc_probe(void)
-{
-
-	int err;
-
-	pr_debug("+++++++++++++accel_probe!!\n");
-
-	acc_context_obj = acc_context_alloc_object();
-	if (!acc_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-	/* init real acceleration driver */
-	err = acc_real_driver_init();
-	if (err) {
-		pr_err("acc real driver init fail\n");
-		goto real_driver_init_fail;
-	}
-
-	pr_debug("----accel_probe OK !!\n");
-	return 0;
-
-real_driver_init_fail:
-	kfree(acc_context_obj);
-
-exit_alloc_data_failed:
-
-	pr_err("----accel_probe fail !!!\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(acc_probe);
-
-int acc_remove(void)
-{
-	int err = 0;
-
-	acc_real_driver_uninit();
-
-	sysfs_remove_group(&acc_context_obj->mdev.this_device->kobj,
-			   &acc_attribute_group);
-
-	err = sensor_attr_deregister(&acc_context_obj->mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-	kfree(acc_context_obj);
-
-	platform_driver_unregister(&gsensor_driver);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(acc_remove);
-
-static int __init acc_init(void)
-{
-	pr_debug("%s\n", __func__);
-
-	return 0;
-}
-
-static void __exit acc_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(acc_init);
-module_exit(acc_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("ACCELEROMETER device driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accel_factory.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accel_factory.c
deleted file mode 100644
index 61950c3..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accel_factory.c
+++ /dev/null
@@ -1,271 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<ACCEL_FAC> " fmt
-
-#include "inc/accel_factory.h"
-
-struct accel_factory_private {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct accel_factory_fops *fops;
-};
-
-static struct accel_factory_private accel_factory;
-
-static int acc_factory_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static int acc_factory_release(struct inode *inode, struct file *file)
-{
-	file->private_data = NULL;
-	return 0;
-}
-
-static long acc_factory_unlocked_ioctl(struct file *file, unsigned int cmd,
-				       unsigned long arg)
-{
-	void __user *ptr = (void __user *)arg;
-	int err = 0, status = 0;
-	uint32_t flag = 0;
-	char strbuf[64];
-	int32_t data_buf[3] = {0};
-	struct SENSOR_DATA sensor_data = {0};
-
-	if (_IOC_DIR(cmd) & _IOC_READ)
-		err = !access_ok(VERIFY_WRITE, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-	else if (_IOC_DIR(cmd) & _IOC_WRITE)
-		err = !access_ok(VERIFY_READ, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-
-	if (err) {
-		pr_err("access error: %08X, (%2d, %2d)\n", cmd,
-			   _IOC_DIR(cmd), _IOC_SIZE(cmd));
-		return -EFAULT;
-	}
-
-	switch (cmd) {
-	case GSENSOR_IOCTL_INIT:
-		if (copy_from_user(&flag, ptr, sizeof(flag)))
-			return -EFAULT;
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->enable_sensor != NULL) {
-			err = accel_factory.fops->enable_sensor(flag, 5);
-			if (err < 0) {
-				pr_err("GSENSOR_IOCTL_INIT fail!\n");
-				return -EINVAL;
-			}
-			pr_debug("GSENSOR_IOCTL_INIT, enable: %d, s_p:%dms\n",
-				flag, 5);
-		} else {
-			pr_debug("GSENSOR_IOCTL_INIT NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GSENSOR_IOCTL_READ_CHIPINFO:
-		return 0;
-	case GSENSOR_IOCTL_READ_SENSORDATA:
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->get_data != NULL) {
-			err = accel_factory.fops->get_data(data_buf, &status);
-			if (err < 0) {
-				pr_err(
-					"GSENSOR_READ_SENSORDATA read fail!\n");
-				return -EINVAL;
-			}
-			sprintf(strbuf, "%x %x %x", data_buf[0], data_buf[1],
-				data_buf[2]);
-			pr_debug("GSENSOR_READ_SENSORDATA read strbuf : (%s)!\n",
-				strbuf);
-			if (copy_to_user(ptr, strbuf, strlen(strbuf) + 1))
-				return -EFAULT;
-		} else {
-			pr_debug("GSENSOR_IOCTL_READ_SENSORDATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GSENSOR_IOCTL_READ_RAW_DATA:
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->get_raw_data != NULL) {
-			err = accel_factory.fops->get_raw_data(data_buf);
-			if (err < 0) {
-				pr_err(
-					"GSENSOR_READ_RAW_DATA read fail!\n");
-				return -EINVAL;
-			}
-			sprintf(strbuf, "%x %x %x", data_buf[0], data_buf[1],
-				data_buf[2]);
-			pr_debug("GSENSOR_SENSORDATA_RAW read strbuf : (%s)!\n",
-				strbuf);
-			if (copy_to_user(ptr, strbuf, strlen(strbuf) + 1))
-				return -EFAULT;
-		} else {
-			pr_debug("GSENSOR_IOCTL_READ_SENSORDATA_RAW NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GSENSOR_IOCTL_SET_CALI:
-		if (copy_from_user(&sensor_data, ptr, sizeof(sensor_data)))
-			return -EFAULT;
-		data_buf[0] = sensor_data.x;
-		data_buf[1] = sensor_data.y;
-		data_buf[2] = sensor_data.z;
-		pr_debug("GSENSOR_IOCTL_SET_CALI: (%d, %d, %d)!\n", data_buf[0],
-			data_buf[1], data_buf[2]);
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->set_cali != NULL) {
-			err = accel_factory.fops->set_cali(data_buf);
-			if (err < 0) {
-				pr_err("GSENSOR_IOCTL_SET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_debug("GSENSOR_IOCTL_SET_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GSENSOR_IOCTL_CLR_CALI:
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->clear_cali != NULL) {
-			err = accel_factory.fops->clear_cali();
-			if (err < 0) {
-				pr_err("GSENSOR_IOCTL_CLR_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GSENSOR_IOCTL_CLR_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GSENSOR_IOCTL_GET_CALI:
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->get_cali != NULL) {
-			err = accel_factory.fops->get_cali(data_buf);
-			if (err < 0) {
-				pr_err("GSENSOR_IOCTL_GET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GSENSOR_IOCTL_GET_CALI NULL\n");
-			return -EINVAL;
-		}
-		pr_debug("GSENSOR_IOCTL_GET_CALI: (%d, %d, %d)!\n", data_buf[0],
-			data_buf[1], data_buf[2]);
-		sensor_data.x = data_buf[0];
-		sensor_data.y = data_buf[1];
-		sensor_data.z = data_buf[2];
-		if (copy_to_user(ptr, &sensor_data, sizeof(sensor_data)))
-			return -EFAULT;
-		return 0;
-	case GSENSOR_IOCTL_ENABLE_CALI:
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->enable_calibration != NULL) {
-			err = accel_factory.fops->enable_calibration();
-			if (err < 0) {
-				pr_err("GSENSOR_IOCTL_ENABLE_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GSENSOR_IOCTL_ENABLE_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GSENSOR_IOCTL_SELF_TEST:
-		if (accel_factory.fops != NULL &&
-		    accel_factory.fops->do_self_test != NULL) {
-			err = accel_factory.fops->do_self_test();
-			if (err < 0) {
-				pr_err("GSENSOR_IOCTL_SELF_TEST FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GSENSOR_IOCTL_SELF_TEST NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	default:
-		pr_err("unknown IOCTL: 0x%08x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-
-	return 0;
-}
-
-#if IS_ENABLED(CONFIG_COMPAT)
-static long compat_acc_factory_unlocked_ioctl(struct file *filp,
-					unsigned int cmd, unsigned long arg)
-{
-	if (!filp->f_op || !filp->f_op->unlocked_ioctl) {
-		pr_err(
-			"compat_ioctl has no f_op or no unlocked_ioctl.\n");
-		return -ENOTTY;
-	}
-
-	switch (cmd) {
-	case COMPAT_GSENSOR_IOCTL_INIT:
-	case COMPAT_GSENSOR_IOCTL_READ_CHIPINFO:
-	/* case COMPAT_GSENSOR_IOCTL_READ_GAIN: */
-	case COMPAT_GSENSOR_IOCTL_READ_RAW_DATA:
-	case COMPAT_GSENSOR_IOCTL_READ_SENSORDATA:
-	/* NVRAM will use below ioctl */
-	case COMPAT_GSENSOR_IOCTL_SET_CALI:
-	case COMPAT_GSENSOR_IOCTL_CLR_CALI:
-	case COMPAT_GSENSOR_IOCTL_GET_CALI:
-	case COMPAT_GSENSOR_IOCTL_ENABLE_CALI:
-	case COMPAT_GSENSOR_IOCTL_SELF_TEST:
-		pr_debug("compat_ioctl : GSENSOR_IOCTL command is 0x%x\n", cmd);
-		return filp->f_op->unlocked_ioctl(
-			filp, cmd, (unsigned long)compat_ptr(arg));
-
-	default:
-		pr_err("compat_ion_ioctl : No such command!! 0x%x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-}
-#endif
-/*----------------------------------------------------------------------------*/
-static const struct file_operations acc_factory_fops = {
-	.open = acc_factory_open,
-	.release = acc_factory_release,
-	.unlocked_ioctl = acc_factory_unlocked_ioctl,
-#if IS_ENABLED(CONFIG_COMPAT)
-	.compat_ioctl = compat_acc_factory_unlocked_ioctl,
-#endif
-};
-
-static struct miscdevice accel_factory_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "gsensor",
-	.fops = &acc_factory_fops,
-};
-
-int accel_factory_device_register(struct accel_factory_public *dev)
-{
-	int err = 0;
-
-	if (!dev || !dev->fops)
-		return -1;
-	accel_factory.gain = dev->gain;
-	accel_factory.sensitivity = dev->sensitivity;
-	accel_factory.fops = dev->fops;
-	err = misc_register(&accel_factory_device);
-	if (err) {
-		pr_err("accel_factory_device register failed\n");
-		err = -1;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(accel_factory_device_register);
-
-int accel_factory_device_deregister(struct accel_factory_public *dev)
-{
-	accel_factory.fops = NULL;
-	misc_deregister(&accel_factory_device);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(accel_factory_device_deregister);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Kconfig
deleted file mode 100644
index 8c31fa7..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Kconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-
-config MTK_ACCELHUB
-	bool "accelhub for MediaTek package"
-	help
-	  It support different accelerometer sensor.
-	  If this option is set,
-	  it will support
-	  sensorhub Accelerometer.
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Makefile
deleted file mode 100644
index 71affd7..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/Makefile
+++ /dev/null
@@ -1,7 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/accelerometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)	:=  accelhub.o
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/accelhub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/accelhub.c
deleted file mode 100644
index 46f36b2..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/accelhub.c
+++ /dev/null
@@ -1,921 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[Gsensor] " fmt
-
-#include "accelhub.h"
-#include "SCP_power_monitor.h"
-#include <SCP_sensorHub.h>
-#include <accel.h>
-#include <hwmsensor.h>
-
-#define DEBUG 1
-#define SW_CALIBRATION
-#define ACCELHUB_AXIS_X 0
-#define ACCELHUB_AXIS_Y 1
-#define ACCELHUB_AXIS_Z 2
-#define ACCELHUB_AXES_NUM 3
-#define ACCELHUB_DATA_LEN 6
-#define ACCELHUB_DEV_NAME                                                      \
-	"accel_hub_pl" /* name must different with accel accelhub */
-/* dadadadada */
-enum ACCELHUB_TRC {
-	ACCELHUB_TRC_FILTER = 0x01,
-	ACCELHUB_TRC_RAWDATA = 0x02,
-	ACCELHUB_TRC_IOCTL = 0x04,
-	ACCELHUB_TRC_CALI = 0X08,
-	ACCELHUB_TRC_INFO = 0X10,
-};
-struct accelhub_ipi_data {
-	/*misc */
-	atomic_t trace;
-	atomic_t suspend;
-	atomic_t selftest_status;
-	int32_t static_cali[ACCELHUB_AXES_NUM];
-	uint8_t static_cali_status;
-	int32_t dynamic_cali[ACCELHUB_AXES_NUM];
-	int direction;
-	struct work_struct init_done_work;
-	atomic_t scp_init_done;
-	atomic_t first_ready_after_boot;
-	bool factory_enable;
-	bool android_enable;
-	struct completion calibration_done;
-	struct completion selftest_done;
-};
-
-static struct acc_init_info accelhub_init_info;
-
-static struct accelhub_ipi_data *obj_ipi_data;
-
-static int gsensor_init_flag = -1;
-static DEFINE_SPINLOCK(calibration_lock);
-
-static int gsensor_get_data(int *x, int *y, int *z, int *status);
-
-int accelhub_SetPowerMode(bool enable)
-{
-	int err = 0;
-
-	err = sensor_enable_to_hub(ID_ACCELEROMETER, enable);
-	if (err < 0) {
-		pr_err("SCP_sensorHub_req_send fail!\n");
-		return err;
-	}
-	return err;
-}
-
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-static int accelhub_ReadCalibration(int dat[ACCELHUB_AXES_NUM])
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	dat[ACCELHUB_AXIS_X] = obj->static_cali[ACCELHUB_AXIS_X];
-	dat[ACCELHUB_AXIS_Y] = obj->static_cali[ACCELHUB_AXIS_Y];
-	dat[ACCELHUB_AXIS_Z] = obj->static_cali[ACCELHUB_AXIS_Z];
-
-	return 0;
-}
-
-static int accelhub_ResetCalibration(void)
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-	int err = 0;
-	unsigned char dat[2];
-
-	err = sensor_set_cmd_to_hub(ID_ACCELEROMETER, CUST_ACTION_RESET_CALI,
-				    dat);
-	if (err < 0) {
-		pr_err(
-			"sensor_set_cmd_to_hub fail, (ID: %d),(action: %d)\n",
-			ID_ACCELEROMETER, CUST_ACTION_RESET_CALI);
-	}
-
-	memset(obj->static_cali, 0x00, sizeof(obj->static_cali));
-
-	return err;
-}
-
-static int accelhub_ReadCalibrationEx(int act[ACCELHUB_AXES_NUM],
-				      int raw[ACCELHUB_AXES_NUM])
-{
-	/*raw: the raw calibration data; act: the actual calibration data */
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	raw[ACCELHUB_AXIS_X] = obj->static_cali[ACCELHUB_AXIS_X];
-	raw[ACCELHUB_AXIS_Y] = obj->static_cali[ACCELHUB_AXIS_Y];
-	raw[ACCELHUB_AXIS_Z] = obj->static_cali[ACCELHUB_AXIS_Z];
-
-	act[ACCELHUB_AXIS_X] = raw[ACCELHUB_AXIS_X];
-	act[ACCELHUB_AXIS_Y] = raw[ACCELHUB_AXIS_Y];
-	act[ACCELHUB_AXIS_Z] = raw[ACCELHUB_AXIS_Z];
-
-	return 0;
-}
-
-static int accelhub_WriteCalibration_scp(int dat[ACCELHUB_AXES_NUM])
-{
-	int err = 0;
-
-	err = sensor_set_cmd_to_hub(ID_ACCELEROMETER, CUST_ACTION_SET_CALI,
-				    dat);
-	if (err < 0)
-		pr_err(
-			"sensor_set_cmd_to_hub fail, (ID: %d),(action: %d)\n",
-			ID_ACCELEROMETER, CUST_ACTION_SET_CALI);
-	return err;
-}
-
-static int accelhub_WriteCalibration(int dat[ACCELHUB_AXES_NUM])
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-	int err = 0;
-	int cali[ACCELHUB_AXES_NUM], raw[ACCELHUB_AXES_NUM];
-
-	err = accelhub_ReadCalibrationEx(cali, raw);
-	if (err) {
-		pr_err("read offset fail, %d\n", err);
-		return err;
-	}
-
-	pr_debug("OLDOFF: (%+3d %+3d %+3d), cali: (%+3d %+3d %+3d)\n",
-		raw[ACCELHUB_AXIS_X], raw[ACCELHUB_AXIS_Y],
-		raw[ACCELHUB_AXIS_Z], obj->static_cali[ACCELHUB_AXIS_X],
-		obj->static_cali[ACCELHUB_AXIS_Y],
-		obj->static_cali[ACCELHUB_AXIS_Z]);
-
-	err = accelhub_WriteCalibration_scp(dat);
-	if (err < 0) {
-		pr_err("accelhub_WriteCalibration_scp fail\n");
-		return err;
-	}
-	/*calculate the real offset expected by caller */
-	cali[ACCELHUB_AXIS_X] += dat[ACCELHUB_AXIS_X];
-	cali[ACCELHUB_AXIS_Y] += dat[ACCELHUB_AXIS_Y];
-	cali[ACCELHUB_AXIS_Z] += dat[ACCELHUB_AXIS_Z];
-
-	pr_debug("UPDATE: (%+3d %+3d %+3d)\n", dat[ACCELHUB_AXIS_X],
-		dat[ACCELHUB_AXIS_Y], dat[ACCELHUB_AXIS_Z]);
-
-	obj->static_cali[ACCELHUB_AXIS_X] = cali[ACCELHUB_AXIS_X];
-	obj->static_cali[ACCELHUB_AXIS_Y] = cali[ACCELHUB_AXIS_Y];
-	obj->static_cali[ACCELHUB_AXIS_Z] = cali[ACCELHUB_AXIS_Z];
-
-	return err;
-}
-#endif
-
-static int accelhub_ReadAllReg(char *buf, int bufsize)
-{
-	int err = 0;
-
-	err = accelhub_SetPowerMode(true);
-	if (err) {
-		pr_err("Power on accelhub error %d!\n", err);
-		return err;
-	}
-
-	/* register map */
-	return 0;
-}
-
-static int accelhub_ReadChipInfo(char *buf, int bufsize)
-{
-	u8 databuf[10];
-
-	memset(databuf, 0, sizeof(u8) * 10);
-
-	if ((buf == NULL) || (bufsize <= 30))
-		return -1;
-
-	sprintf(buf, "ACCELHUB Chip");
-	return 0;
-}
-
-static int accelhub_ReadSensorData(char *buf, int bufsize)
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-	uint64_t time_stamp = 0;
-	struct data_unit_t data;
-	int acc[ACCELHUB_AXES_NUM];
-	int err = 0;
-	int status = 0;
-
-	if (atomic_read(&obj->suspend))
-		return -3;
-
-	if (buf == NULL)
-		return -1;
-	err = sensor_get_data_from_hub(ID_ACCELEROMETER, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!\n");
-		return err;
-	}
-	time_stamp = data.time_stamp;
-	acc[ACCELHUB_AXIS_X] = data.accelerometer_t.x;
-	acc[ACCELHUB_AXIS_Y] = data.accelerometer_t.y;
-	acc[ACCELHUB_AXIS_Z] = data.accelerometer_t.z;
-	status = data.accelerometer_t.status;
-
-	sprintf(buf, "%04x %04x %04x %04x", acc[ACCELHUB_AXIS_X],
-		acc[ACCELHUB_AXIS_Y], acc[ACCELHUB_AXIS_Z], status);
-	if (atomic_read(&obj->trace) & ACCELHUB_TRC_IOCTL)
-		pr_debug("gsensor data: %s!\n", buf);
-
-	return 0;
-}
-static ssize_t chipinfo_show(struct device_driver *ddri, char *buf)
-{
-	char strbuf[ACCELHUB_BUFSIZE];
-
-	accelhub_SetPowerMode(true);
-	msleep(50);
-
-	accelhub_ReadAllReg(strbuf, ACCELHUB_BUFSIZE);
-
-	accelhub_ReadChipInfo(strbuf, ACCELHUB_BUFSIZE);
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-
-static ssize_t sensordata_show(struct device_driver *ddri, char *buf)
-{
-	char strbuf[ACCELHUB_BUFSIZE];
-
-	accelhub_ReadSensorData(strbuf, ACCELHUB_BUFSIZE);
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-
-static ssize_t cali_show(struct device_driver *ddri, char *buf)
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-	int len = 0;
-
-	len += snprintf(buf + len, PAGE_SIZE - len,
-			"[SW ][%d] (%+3d, %+3d, %+3d)\n", 1,
-			obj->static_cali[ACCELHUB_AXIS_X],
-			obj->static_cali[ACCELHUB_AXIS_Y],
-			obj->static_cali[ACCELHUB_AXIS_Z]);
-
-	return len;
-}
-
-static ssize_t trace_store(struct device_driver *ddri, const char *buf,
-				 size_t count)
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-	int trace = 0;
-	int res = 0;
-
-	if (obj == NULL) {
-		pr_err("obj is null!!\n");
-		return 0;
-	}
-	if (sscanf(buf, "0x%x", &trace) == 1) {
-		atomic_set(&obj->trace, trace);
-		res = sensor_set_cmd_to_hub(ID_ACCELEROMETER,
-					    CUST_ACTION_SET_TRACE, &trace);
-		if (res < 0) {
-			pr_err(
-				"sensor_set_cmd_to_hub fail, (ID: %d),(action: %d)\n",
-				ID_ACCELEROMETER, CUST_ACTION_SET_TRACE);
-			return 0;
-		}
-	} else {
-		pr_err("invalid content: '%s', length = %zu\n", buf, count);
-		return 0;
-	}
-
-	return count;
-}
-
-static ssize_t chip_orientation_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t _tLength = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	_tLength = snprintf(buf, PAGE_SIZE, "default direction = %d\n",
-			    obj->direction);
-
-	return _tLength;
-}
-
-static ssize_t chip_orientation_store(struct device_driver *ddri,
-				      const char *buf, size_t tCount)
-{
-	int _nDirection = 0, ret = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	if (obj == NULL)
-		return 0;
-	ret = kstrtoint(buf, 10, &_nDirection);
-	if (ret != 0) {
-		pr_debug("kstrtoint fail\n");
-		return 0;
-	}
-	obj->direction = _nDirection;
-	ret = sensor_set_cmd_to_hub(ID_ACCELEROMETER, CUST_ACTION_SET_DIRECTION,
-				    &_nDirection);
-	if (ret < 0) {
-		pr_err(
-			"sensor_set_cmd_to_hub fail, (ID: %d),(action: %d)\n",
-			ID_ACCELEROMETER, CUST_ACTION_SET_DIRECTION);
-		return 0;
-	}
-
-	pr_debug("[%s] set direction: %d\n", __func__, _nDirection);
-
-	return tCount;
-}
-
-static int gsensor_factory_enable_calibration(void);
-static ssize_t test_cali_store(struct device_driver *ddri, const char *buf,
-			       size_t tCount)
-{
-	int enable = 0, ret = 0;
-
-	ret = kstrtoint(buf, 10, &enable);
-	if (ret != 0) {
-		pr_debug("kstrtoint fail\n");
-		return 0;
-	}
-	if (enable == 1)
-		gsensor_factory_enable_calibration();
-	return tCount;
-}
-
-static DRIVER_ATTR_RO(chipinfo);
-static DRIVER_ATTR_RO(sensordata);
-static DRIVER_ATTR_RO(cali);
-static DRIVER_ATTR_WO(trace);
-static DRIVER_ATTR_RW(chip_orientation);
-static DRIVER_ATTR_WO(test_cali);
-
-static struct driver_attribute *accelhub_attr_list[] = {
-	&driver_attr_chipinfo,   /*chip information */
-	&driver_attr_sensordata, /*dump sensor data */
-	&driver_attr_cali,       /*show calibration data */
-	&driver_attr_trace,      /*trace log */
-	&driver_attr_chip_orientation,
-	&driver_attr_test_cali,
-};
-
-static int accelhub_create_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(ARRAY_SIZE(accelhub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, accelhub_attr_list[idx]);
-		if (err != 0) {
-			pr_err("driver_create_file (%s) = %d\n",
-				   accelhub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int accelhub_delete_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(ARRAY_SIZE(accelhub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, accelhub_attr_list[idx]);
-
-	return err;
-}
-
-static void scp_init_work_done(struct work_struct *work)
-{
-	int err = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-#ifndef MTK_OLD_FACTORY_CALIBRATION
-	int32_t cfg_data[6] = {0};
-#endif
-
-	if (atomic_read(&obj->scp_init_done) == 0) {
-		pr_debug("scp is not ready to send cmd\n");
-		return;
-	}
-	if (atomic_xchg(&obj->first_ready_after_boot, 1) == 0)
-		return;
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = accelhub_WriteCalibration_scp(obj->static_cali);
-	if (err < 0)
-		pr_err("accelhub_WriteCalibration_scp fail\n");
-#else
-	spin_lock(&calibration_lock);
-	cfg_data[0] = obj->dynamic_cali[0];
-	cfg_data[1] = obj->dynamic_cali[1];
-	cfg_data[2] = obj->dynamic_cali[2];
-
-	cfg_data[3] = obj->static_cali[0];
-	cfg_data[4] = obj->static_cali[1];
-	cfg_data[5] = obj->static_cali[2];
-	spin_unlock(&calibration_lock);
-	err = sensor_cfg_to_hub(ID_ACCELEROMETER, (uint8_t *)cfg_data,
-				sizeof(cfg_data));
-	if (err < 0)
-		pr_err("sensor_cfg_to_hub fail\n");
-#endif
-}
-
-static int gsensor_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct acc_data data;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	data.x = event->accelerometer_t.x;
-	data.y = event->accelerometer_t.y;
-	data.z = event->accelerometer_t.z;
-	data.status = event->accelerometer_t.status;
-	data.timestamp = (int64_t)event->time_stamp;
-	data.reserved[0] = event->reserve[0];
-
-	if (event->flush_action == DATA_ACTION &&
-	    READ_ONCE(obj->android_enable) == true)
-		err = acc_data_report(&data);
-	else if (event->flush_action == FLUSH_ACTION)
-		err = acc_flush_report();
-	else if (event->flush_action == BIAS_ACTION) {
-		data.x = event->accelerometer_t.x_bias;
-		data.y = event->accelerometer_t.y_bias;
-		data.z = event->accelerometer_t.z_bias;
-		err = acc_bias_report(&data);
-		spin_lock(&calibration_lock);
-		obj->dynamic_cali[ACCELHUB_AXIS_X] =
-			event->accelerometer_t.x_bias;
-		obj->dynamic_cali[ACCELHUB_AXIS_Y] =
-			event->accelerometer_t.y_bias;
-		obj->dynamic_cali[ACCELHUB_AXIS_Z] =
-			event->accelerometer_t.z_bias;
-		spin_unlock(&calibration_lock);
-	} else if (event->flush_action == CALI_ACTION) {
-		data.x = event->accelerometer_t.x_bias;
-		data.y = event->accelerometer_t.y_bias;
-		data.z = event->accelerometer_t.z_bias;
-		if (event->accelerometer_t.status == 0)
-			err = acc_cali_report(&data);
-		spin_lock(&calibration_lock);
-		obj->static_cali[ACCELHUB_AXIS_X] =
-			event->accelerometer_t.x_bias;
-		obj->static_cali[ACCELHUB_AXIS_Y] =
-			event->accelerometer_t.y_bias;
-		obj->static_cali[ACCELHUB_AXIS_Z] =
-			event->accelerometer_t.z_bias;
-		obj->static_cali_status =
-			(uint8_t)event->accelerometer_t.status;
-		spin_unlock(&calibration_lock);
-		complete(&obj->calibration_done);
-	} else if (event->flush_action == TEST_ACTION) {
-		atomic_set(&obj->selftest_status,
-			event->accelerometer_t.status);
-		complete(&obj->selftest_done);
-	}
-	return err;
-}
-static int gsensor_factory_enable_sensor(bool enabledisable,
-					 int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	if (enabledisable == true)
-		WRITE_ONCE(obj->factory_enable, true);
-	else
-		WRITE_ONCE(obj->factory_enable, false);
-	if (enabledisable == true) {
-		err = sensor_set_delay_to_hub(ID_ACCELEROMETER,
-					      sample_periods_ms);
-		if (err) {
-			pr_err("sensor_set_delay_to_hub failed!\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_ACCELEROMETER, enabledisable);
-	if (err) {
-		pr_err("sensor_enable_to_hub failed!\n");
-		return -1;
-	}
-	return 0;
-}
-static int gsensor_factory_get_data(int32_t data[3], int *status)
-{
-	return gsensor_get_data(&data[0], &data[1], &data[2], status);
-}
-static int gsensor_factory_get_raw_data(int32_t data[3])
-{
-	pr_debug("%s don't support!\n", __func__);
-	return 0;
-}
-static int gsensor_factory_enable_calibration(void)
-{
-	return sensor_calibration_to_hub(ID_ACCELEROMETER);
-}
-static int gsensor_factory_clear_cali(void)
-{
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	int err = 0;
-
-	err = accelhub_ResetCalibration();
-	if (err) {
-		pr_err("gsensor_ResetCalibration failed!\n");
-		return -1;
-	}
-#endif
-	return 0;
-}
-static int gsensor_factory_set_cali(int32_t data[3])
-{
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	int err = 0;
-
-	err = accelhub_WriteCalibration(data);
-	if (err) {
-		pr_err("gsensor_WriteCalibration failed!\n");
-		return -1;
-	}
-#endif
-	return 0;
-}
-static int gsensor_factory_get_cali(int32_t data[3])
-{
-	int err = 0;
-#ifndef MTK_OLD_FACTORY_CALIBRATION
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-	uint8_t status = 0;
-#endif
-
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = accelhub_ReadCalibration(data);
-	if (err) {
-		pr_err("gsensor_ReadCalibration failed!\n");
-		return -1;
-	}
-#else
-	err = wait_for_completion_timeout(&obj->calibration_done,
-					  msecs_to_jiffies(3000));
-	if (!err) {
-		pr_err("%s fail!\n", __func__);
-		return -1;
-	}
-	spin_lock(&calibration_lock);
-	data[ACCELHUB_AXIS_X] = obj->static_cali[ACCELHUB_AXIS_X];
-	data[ACCELHUB_AXIS_Y] = obj->static_cali[ACCELHUB_AXIS_Y];
-	data[ACCELHUB_AXIS_Z] = obj->static_cali[ACCELHUB_AXIS_Z];
-	status = obj->static_cali_status;
-	spin_unlock(&calibration_lock);
-	if (status != 0) {
-		pr_debug("gsensor static cali detect shake!\n");
-		return -2;
-	}
-#endif
-	return 0;
-}
-static int gsensor_factory_do_self_test(void)
-{
-	int ret = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	ret = sensor_selftest_to_hub(ID_ACCELEROMETER);
-	if (ret < 0)
-		return -1;
-
-	ret = wait_for_completion_timeout(&obj->selftest_done,
-					  msecs_to_jiffies(3000));
-	if (!ret)
-		return -1;
-	return atomic_read(&obj->selftest_status);
-}
-
-static struct accel_factory_fops gsensor_factory_fops = {
-	.enable_sensor = gsensor_factory_enable_sensor,
-	.get_data = gsensor_factory_get_data,
-	.get_raw_data = gsensor_factory_get_raw_data,
-	.enable_calibration = gsensor_factory_enable_calibration,
-	.clear_cali = gsensor_factory_clear_cali,
-	.set_cali = gsensor_factory_set_cali,
-	.get_cali = gsensor_factory_get_cali,
-	.do_self_test = gsensor_factory_do_self_test,
-};
-
-static struct accel_factory_public gsensor_factory_device = {
-	.gain = 1,
-	.sensitivity = 1,
-	.fops = &gsensor_factory_fops,
-};
-
-static int gsensor_open_report_data(int open)
-{
-
-	return 0;
-}
-
-static int gsensor_enable_nodata(int en)
-{
-	int err = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	if (en == true)
-		WRITE_ONCE(obj->android_enable, true);
-	else
-		WRITE_ONCE(obj->android_enable, false);
-
-	if (atomic_read(&obj->suspend) == 0) {
-		err = accelhub_SetPowerMode(en);
-		if (err < 0) {
-			pr_err("scp_gsensor_enable_nodata fail!\n");
-			return -1;
-		}
-	}
-
-	pr_debug("scp_gsensor_enable_nodata OK!!!\n");
-	return 0;
-}
-
-static int gsensor_set_delay(u64 ns)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	int err = 0;
-	unsigned int delayms = 0;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	delayms = (unsigned int)ns / 1000 / 1000;
-	err = sensor_set_delay_to_hub(ID_ACCELEROMETER, delayms);
-	if (err < 0) {
-		pr_err("%s fail!\n", __func__);
-		return err;
-	}
-	pr_debug("%s (%d)\n", __func__, delayms);
-	return 0;
-#elif defined CONFIG_NANOHUB
-	return 0;
-#else
-	return 0;
-#endif
-}
-
-static int gsensor_batch(int flag, int64_t samplingPeriodNs,
-			 int64_t maxBatchReportLatencyNs)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	gsensor_set_delay(samplingPeriodNs);
-#endif
-	return sensor_batch_to_hub(ID_ACCELEROMETER, flag, samplingPeriodNs,
-				   maxBatchReportLatencyNs);
-}
-
-static int gsensor_flush(void)
-{
-	return sensor_flush_to_hub(ID_ACCELEROMETER);
-}
-
-static int gsensor_set_cali(uint8_t *data, uint8_t count)
-{
-	int32_t *buf = (int32_t *)data;
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	spin_lock(&calibration_lock);
-	obj->dynamic_cali[0] = buf[0];
-	obj->dynamic_cali[1] = buf[1];
-	obj->dynamic_cali[2] = buf[2];
-
-	obj->static_cali[0] = buf[3];
-	obj->static_cali[1] = buf[4];
-	obj->static_cali[2] = buf[5];
-	spin_unlock(&calibration_lock);
-
-	return sensor_cfg_to_hub(ID_ACCELEROMETER, data, count);
-}
-
-static int gsensor_get_data(int *x, int *y, int *z, int *status)
-{
-	int err = 0;
-	char buff[ACCELHUB_BUFSIZE];
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	err = accelhub_ReadSensorData(buff, ACCELHUB_BUFSIZE);
-	if (err < 0) {
-		pr_err("accelhub_ReadSensorData fail!!\n");
-		return -1;
-	}
-	err = sscanf(buff, "%x %x %x %x", x, y, z, status);
-	if (err != 4) {
-		pr_err("sscanf fail!!\n");
-		return -1;
-	}
-
-	if (atomic_read(&obj->trace) & ACCELHUB_TRC_RAWDATA)
-		pr_debug("x = %d, y = %d, z = %d\n", *x, *y, *z);
-
-	return 0;
-}
-
-static int scp_ready_event(uint8_t event, void *ptr)
-{
-	struct accelhub_ipi_data *obj = obj_ipi_data;
-
-	switch (event) {
-	case SENSOR_POWER_UP:
-		atomic_set(&obj->scp_init_done, 1);
-		schedule_work(&obj->init_done_work);
-		break;
-	case SENSOR_POWER_DOWN:
-		atomic_set(&obj->scp_init_done, 0);
-		break;
-	}
-	return 0;
-}
-
-static struct scp_power_monitor scp_ready_notifier = {
-	.name = "accel",
-	.notifier_call = scp_ready_event,
-};
-
-static int accelhub_probe(struct platform_device *pdev)
-{
-	struct accelhub_ipi_data *obj;
-	struct acc_control_path ctl = {0};
-	struct acc_data_path data = {0};
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	if (!obj) {
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	memset(obj, 0, sizeof(struct accelhub_ipi_data));
-
-	INIT_WORK(&obj->init_done_work, scp_init_work_done);
-
-	obj_ipi_data = obj;
-
-	platform_set_drvdata(pdev, obj);
-
-	atomic_set(&obj->trace, 0);
-	atomic_set(&obj->suspend, 0);
-	atomic_set(&obj->scp_init_done, 0);
-	atomic_set(&obj->first_ready_after_boot, 0);
-	atomic_set(&obj->selftest_status, 0);
-	WRITE_ONCE(obj->factory_enable, false);
-	WRITE_ONCE(obj->android_enable, false);
-	init_completion(&obj->calibration_done);
-	init_completion(&obj->selftest_done);
-	scp_power_monitor_register(&scp_ready_notifier);
-	err = scp_sensorHub_data_registration(ID_ACCELEROMETER,
-					      gsensor_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = accel_factory_device_register(&gsensor_factory_device);
-	if (err) {
-		pr_err("gsensor_factory_device register failed\n");
-		goto exit_kfree;
-	}
-	err = accelhub_create_attr(
-		&accelhub_init_info.platform_diver_addr->driver);
-	if (err) {
-		pr_err("create attribute err = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	ctl.open_report_data = gsensor_open_report_data;
-	ctl.enable_nodata = gsensor_enable_nodata;
-	ctl.set_delay = gsensor_set_delay;
-	ctl.batch = gsensor_batch;
-	ctl.flush = gsensor_flush;
-	ctl.set_cali = gsensor_set_cali;
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = false;
-#elif defined CONFIG_NANOHUB
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = true;
-#else
-#endif
-	err = acc_register_control_path(&ctl);
-	if (err) {
-		pr_err("register acc control path err\n");
-		goto exit_create_attr_failed;
-	}
-
-	data.get_data = gsensor_get_data;
-	data.vender_div = 1000;
-	err = acc_register_data_path(&data);
-	if (err) {
-		pr_err("register acc data path err\n");
-		goto exit_create_attr_failed;
-	}
-	gsensor_init_flag = 0;
-	pr_debug("%s: OK\n", __func__);
-	return 0;
-
-exit_create_attr_failed:
-	accelhub_delete_attr(&(accelhub_init_info.platform_diver_addr->driver));
-exit_kfree:
-	kfree(obj);
-	obj_ipi_data = NULL;
-exit:
-	pr_err("%s: err = %d\n", __func__, err);
-	gsensor_init_flag = -1;
-	return err;
-}
-
-static int accelhub_remove(struct platform_device *pdev)
-{
-	int err = 0;
-
-	err = accelhub_delete_attr(
-		&accelhub_init_info.platform_diver_addr->driver);
-	if (err)
-		pr_err("accelhub_delete_attr fail: %d\n", err);
-	accel_factory_device_deregister(&gsensor_factory_device);
-
-	kfree(platform_get_drvdata(pdev));
-	return 0;
-}
-
-static int accelhub_suspend(struct platform_device *pdev, pm_message_t msg)
-{
-	return 0;
-}
-
-static int accelhub_resume(struct platform_device *pdev)
-{
-	return 0;
-}
-
-static struct platform_device accelhub_device = {
-	.name = ACCELHUB_DEV_NAME, .id = -1,
-};
-
-static struct platform_driver accelhub_driver = {
-	.driver = {
-
-			.name = ACCELHUB_DEV_NAME,
-		},
-	.probe = accelhub_probe,
-	.remove = accelhub_remove,
-	.suspend = accelhub_suspend,
-	.resume = accelhub_resume,
-};
-
-static int gsensor_local_init(void)
-{
-	pr_debug("%s\n", __func__);
-
-	if (platform_driver_register(&accelhub_driver)) {
-		pr_err("add driver error\n");
-		return -1;
-	}
-	if (-1 == gsensor_init_flag)
-		return -1;
-	return 0;
-}
-
-static int gsensor_local_remove(void)
-{
-	pr_debug("%s\n", __func__);
-	platform_driver_unregister(&accelhub_driver);
-	return 0;
-}
-
-static struct acc_init_info accelhub_init_info = {
-	.name = "accelhub",
-	.init = gsensor_local_init,
-	.uninit = gsensor_local_remove,
-};
-
-static int __init accelhub_init(void)
-{
-
-	if (platform_device_register(&accelhub_device)) {
-		pr_err("accel platform device error\n");
-		return -1;
-	}
-	acc_driver_add(&accelhub_init_info);
-	return 0;
-}
-
-static void __exit accelhub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-module_init(accelhub_init);
-module_exit(accelhub_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("ACCELHUB gse driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/accelhub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/accelhub.h
deleted file mode 100644
index 35191fe..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/accelhub/accelhub.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef ACCELHUB_H
-#define ACCELHUB_H
-
-#include <linux/ioctl.h>
-
-#define ACCELHUB_BUFSIZE 256
-#define ACCELHUB_AXES_NUM 3
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/accel.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/accel.h
deleted file mode 100644
index 70e6574..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/accel.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __ACC_H__
-#define __ACC_H__
-
-#include "sensor_attr.h"
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/pm_wakeup.h>
-#include <linux/workqueue.h>
-
-#include <linux/atomic.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/ioctl.h>
-#include <linux/irq.h>
-#include <linux/kobject.h>
-#include <linux/uaccess.h>
-
-#include "sensor_event.h"
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-#include <linux/poll.h>
-#include <sensors_io.h>
-
-#include "accel_factory.h"
-
-#define OP_ACC_DELAY 0X01
-#define OP_ACC_ENABLE 0X02
-#define OP_ACC_GET_DATA 0X04
-
-#define ACC_INVALID_VALUE -1
-
-#define ACC_AXIS_X 0
-#define ACC_AXIS_Y 1
-#define ACC_AXIS_Z 2
-
-#define MAX_CHOOSE_G_NUM 5
-#define ACC_AXES_NUM 3
-struct acc_control_path {
-	int (*open_report_data)(int open);
-	int (*enable_nodata)(int en);
-	int (*set_delay)(u64 delay);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		     int64_t maxBatchReportLatencyNs);
-	int (*flush)(void);
-	int (*set_cali)(uint8_t *data, uint8_t count);
-	bool is_report_input_direct;
-	bool is_support_batch;
-	bool is_use_common_factory;
-};
-
-struct acc_data_path {
-	int (*get_data)(int *x, int *y, int *z, int *status);
-	int (*get_raw_data)(int *x, int *y, int *z);
-	int vender_div;
-};
-
-struct acc_init_info {
-	char *name;
-	int (*init)(void);
-	int (*uninit)(void);
-	struct platform_driver *platform_diver_addr;
-};
-
-struct acc_data {
-	int8_t status;
-	int8_t reserved[3];
-	int x;
-	int y;
-	int z;
-	int64_t timestamp;
-	void *reserved1;
-} __packed;
-
-struct acc_drv_obj {
-	void *self;
-	int polling;
-	int (*acc_operate)(void *self, uint32_t command, void *buff_in,
-			   int size_in, void *buff_out, int size_out,
-			   int *actualout);
-};
-
-struct acc_context {
-	struct input_dev *idev;
-	struct sensor_attr_t mdev;
-	struct work_struct report;
-	struct mutex acc_op_mutex;
-	atomic_t delay; /*polling period for reporting input event*/
-	atomic_t wake;  /*user-space request to wake-up, used with stop*/
-	struct timer_list timer; /* polling timer */
-	struct hrtimer hrTimer;
-	ktime_t target_ktime;
-	atomic_t trace;
-	struct workqueue_struct *accel_workqueue;
-
-	atomic_t early_suspend;
-	/* struct acc_drv_obj    drv_obj; */
-	struct acc_data drv_data;
-	int cali_sw[ACC_AXES_NUM + 1];
-	struct acc_control_path acc_ctl;
-	struct acc_data_path acc_data;
-	/* Active, but HAL don't need data sensor. such as orientation need */
-	bool is_active_nodata;
-	bool is_active_data; /* Active and HAL need data . */
-	bool is_first_data_after_enable;
-	bool is_polling_run;
-	bool is_batch_enable; /* v2.judging whether sensor is in batch mode */
-	int power;
-	int enable;
-	int64_t delay_ns;
-	int64_t latency_ns;
-};
-
-/* for auto detect */
-extern int acc_driver_add(struct acc_init_info *obj);
-extern int acc_data_report(struct acc_data *data);
-extern int acc_bias_report(struct acc_data *data);
-extern int acc_cali_report(struct acc_data *data);
-extern int acc_flush_report(void);
-extern int acc_register_control_path(struct acc_control_path *ctl);
-extern int acc_register_data_path(struct acc_data_path *data);
-extern int acc_probe(void);
-extern int acc_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/accel_factory.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/accel_factory.h
deleted file mode 100644
index ba7ebff..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/accel_factory.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __ACC_FACTORY_H__
-#define __ACC_FACTORY_H__
-
-#include <linux/uaccess.h>
-#include <sensors_io.h>
-#include "cust_acc.h"
-#include "accel.h"
-
-struct accel_factory_fops {
-	int (*enable_sensor)(bool enable_disable, int64_t sample_periods_ms);
-	int (*get_data)(int32_t data[3], int *status);
-	int (*get_raw_data)(int32_t data[3]);
-	int (*enable_calibration)(void);
-	int (*clear_cali)(void);
-	int (*set_cali)(int32_t offset[3]);
-	int (*get_cali)(int32_t offset[3]);
-	int (*do_self_test)(void);
-};
-
-struct accel_factory_public {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct accel_factory_fops *fops;
-};
-int accel_factory_device_register(struct accel_factory_public *dev);
-int accel_factory_device_deregister(struct accel_factory_public *dev);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/cust_acc.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/cust_acc.h
deleted file mode 100644
index ac6fea0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/accelerometer/inc/cust_acc.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __CUST_ACC_H__
-#define __CUST_ACC_H__
-
-#include <linux/of.h>
-#include <linux/types.h>
-#define G_CUST_I2C_ADDR_NUM 2
-
-struct acc_hw {
-	int i2c_num;   /*!< the i2c bus used by the chip */
-	int direction; /*!< the direction of the chip */
-	int power_id;  /*!< the VDD LDO ID of the chip */
-	int power_vol; /*!< the VDD Power Voltage used by the chip */
-	int firlen;    /*!< the length of low pass filter */
-	int (*power)(struct acc_hw *hw, unsigned int on, char *devname);
-	/*!< i2c address list,for chips which has different addresses with
-	 * different HW layout.
-	 */
-	unsigned char i2c_addr[G_CUST_I2C_ADDR_NUM];
-	int power_vio_id;  /*!< the VIO LDO ID of the chip */
-	int power_vio_vol; /*!< the VIO Power Voltage used by the chip */
-	bool is_batch_supported;
-};
-
-int get_accel_dts_func(struct device_node *node, struct acc_hw *hw);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/Kconfig
deleted file mode 100644
index e10ff91..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/Kconfig
+++ /dev/null
@@ -1,20 +0,0 @@
-
-config CUSTOM_KERNEL_ALSPS
-	bool "CUSTOM KERNEL ALSPS Config"
-	help
-	  ALSPS sensor driver to detect ambient light and the object is close
-	  or far awary from device. After configure this configuration,
-	  the specific ambient light and proximity sensor driver configuration
-	  should be configured as well.
-
-config MTK_AUTO_DETECT_ALSPS
-	bool "MTK AUTO DETECT ALSPS Sensor"
-	help
-	  This feature Option is used for projects which using more than one
-	  ALSPS sensors, more than one ALSPS drivers can be builded in to
-	  project and be auto detected by setting this option to yes,
-	  usually only one ALSPS driver can be probed.
-
-source "drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/alsps/cm36558/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/alsps/ltr303/Kconfig"
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/Makefile
deleted file mode 100644
index dfb08c9..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-# In case the platform does NOT support this type of sensors
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)   +=  alsps_common.o
-alsps_common-$(CONFIG_MTK_SENSOR_SUPPORT) := alsps.o alsps_factory.o aal_control.o
-
-obj-$(CONFIG_MTK_ALSPSHUB)      +=  alspshub/
-#obj-$(CONFIG_MTK_CM36558)	+=  cm36558/
-#obj-$(CONFIG_MTK_LTR303)	+=  ltr303/
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/aal_control.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/aal_control.c
deleted file mode 100644
index 6246fb0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/aal_control.c
+++ /dev/null
@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[ALS/AAL]" fmt
-
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
-#include <linux/miscdevice.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-
-#include "inc/aal_control.h"
-#include "inc/alsps.h"
-#include <sensors_io.h>
-
-int aal_use /* = 0*/;
-
-static int AAL_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static int AAL_release(struct inode *inode, struct file *file)
-{
-	file->private_data = NULL;
-	return 0;
-}
-
-static long AAL_unlocked_ioctl(struct file *file, unsigned int cmd,
-			       unsigned long arg)
-{
-	long err = 0;
-	void __user *ptr = (void __user *)arg;
-	int dat;
-	uint32_t enable;
-
-	switch (cmd) {
-
-	case AAL_SET_ALS_MODE:
-		if (copy_from_user(&enable, ptr, sizeof(enable))) {
-			err = -EFAULT;
-			goto err_out;
-		}
-
-		if (enable)
-			aal_use = 1;
-		else
-			aal_use = 0;
-
-		err = alsps_aal_enable(enable);
-		if (err)
-			pr_err(
-				"als driver don't support new arch, goto execute old arch: %ld\n",
-				err);
-		break;
-
-	case AAL_GET_ALS_MODE:
-		pr_debug("AAL_GET_ALS_MODE do nothing\n");
-		break;
-
-	case AAL_GET_ALS_DATA:
-		dat = alsps_aal_get_data();
-		/* pr_debug("Get als dat :%d\n", dat); */
-
-		if (copy_to_user(ptr, &dat, sizeof(dat))) {
-			err = -EFAULT;
-			goto err_out;
-		}
-		break;
-
-	default:
-		pr_err("%s not supported = 0x%04x", __func__, cmd);
-		err = -ENOIOCTLCMD;
-		break;
-	}
-
-err_out:
-	return err;
-}
-
-#ifdef CONFIG_COMPAT
-static long AAL_compact_ioctl(struct file *file, unsigned int cmd,
-			      unsigned long arg)
-{
-	void __user *data32;
-
-	data32 = compat_ptr(arg);
-	return AAL_unlocked_ioctl(file, cmd, (unsigned long)data32);
-}
-#endif
-
-static const struct file_operations AAL_fops = {
-	.owner = THIS_MODULE,
-	.open = AAL_open,
-	.release = AAL_release,
-	.unlocked_ioctl = AAL_unlocked_ioctl,
-#ifdef CONFIG_COMPAT
-	.compat_ioctl = AAL_compact_ioctl,
-#endif
-};
-
-static struct miscdevice AAL_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "aal_als",
-	.fops = &AAL_fops,
-};
-
-/*----------------------------------------------------------------------------*/
-int __init AAL_init(void)
-{
-	int err;
-
-	err = misc_register(&AAL_device);
-	if (err)
-		pr_err("AAL_device misc_register failed: %d\n", err);
-
-	pr_debug("OK!\n");
-	return 0;
-}
-
-/*----------------------------------------------------------------------------*/
-void __exit AAL_exit(void)
-{
-	/*int err;*/
-
-	/*err = */ misc_deregister(&AAL_device);
-	/*	if (err)
-	 *	pr_err("AAL_device misc_deregister fail: %d\n", err);
-	 */
-
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alsps.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alsps.c
deleted file mode 100644
index 10b34e4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alsps.c
+++ /dev/null
@@ -1,1321 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<ALS/PS> " fmt
-
-#include "inc/alsps.h"
-#include "inc/aal_control.h"
-struct alsps_context *alsps_context_obj /* = NULL*/;
-struct platform_device *pltfm_dev;
-int last_als_report_data = -1;
-
-/* AAL default delay timer(nano seconds)*/
-#define AAL_DELAY 200000000
-
-static struct alsps_init_info *alsps_init_list[MAX_CHOOSE_ALSPS_NUM] = {0};
-
-int als_data_report_t(int value, int status, int64_t time_stamp)
-{
-	int err = 0;
-	struct alsps_context *cxt = NULL;
-	struct sensor_event event;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	cxt = alsps_context_obj;
-	event.time_stamp = time_stamp;
-	/* pr_debug(" +als_data_report! %d, %d\n", value, status); */
-	/* force trigger data update after sensor enable. */
-	if (cxt->is_get_valid_als_data_after_enable == false) {
-		event.handle = ID_LIGHT;
-		event.flush_action = DATA_ACTION;
-		event.word[0] = value + 1;
-		err = sensor_input_event(cxt->als_mdev.minor, &event);
-		cxt->is_get_valid_als_data_after_enable = true;
-	}
-	if (value != last_als_report_data) {
-		event.handle = ID_LIGHT;
-		event.flush_action = DATA_ACTION;
-		event.word[0] = value;
-		event.status = status;
-		err = sensor_input_event(cxt->als_mdev.minor, &event);
-		if (err >= 0)
-			last_als_report_data = value;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(als_data_report_t);
-
-int als_data_report(int value, int status)
-{
-	return als_data_report_t(value, status, 0);
-}
-EXPORT_SYMBOL_GPL(als_data_report);
-
-int als_cali_report(int *value)
-{
-	int err = 0;
-	struct sensor_event event;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-	event.handle = ID_LIGHT;
-	event.flush_action = CALI_ACTION;
-	event.word[0] = value[0];
-	err = sensor_input_event(alsps_context_obj->als_mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(als_cali_report);
-
-int als_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.handle = ID_LIGHT;
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(alsps_context_obj->als_mdev.minor, &event);
-	pr_debug_ratelimited("flush\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(als_flush_report);
-
-int rgbw_data_report_t(int *value, int64_t time_stamp)
-{
-	int err = 0;
-	struct alsps_context *cxt = alsps_context_obj;
-	struct sensor_event event;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.handle = ID_RGBW;
-	event.flush_action = DATA_ACTION;
-	event.time_stamp = time_stamp;
-	event.word[0] = value[0];
-	event.word[1] = value[1];
-	event.word[2] = value[2];
-	event.word[3] = value[3];
-	err = sensor_input_event(cxt->als_mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(rgbw_data_report_t);
-
-int rgbw_data_report(int *value)
-{
-	return rgbw_data_report_t(value, 0);
-}
-int rgbw_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.handle = ID_RGBW;
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(alsps_context_obj->als_mdev.minor, &event);
-	pr_debug_ratelimited("flush\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(rgbw_flush_report);
-
-int ps_data_report_t(int value, int status, int64_t time_stamp)
-{
-	int err = 0;
-	struct sensor_event event;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	pr_notice("[ALS/PS]%s! %d, %d\n", __func__, value, status);
-	event.flush_action = DATA_ACTION;
-	event.time_stamp = time_stamp;
-	event.word[0] = value + 1;
-	event.status = status;
-	err = sensor_input_event(alsps_context_obj->ps_mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(ps_data_report_t);
-
-int ps_data_report(int value, int status)
-{
-	return ps_data_report_t(value, status, 0);
-}
-EXPORT_SYMBOL_GPL(ps_data_report);
-
-int ps_cali_report(int *value)
-{
-	int err = 0;
-	struct sensor_event event;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = CALI_ACTION;
-	event.word[0] = value[0];
-	event.word[1] = value[1];
-	err = sensor_input_event(alsps_context_obj->ps_mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(ps_cali_report);
-
-int ps_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(alsps_context_obj->ps_mdev.minor, &event);
-	pr_debug_ratelimited("flush\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(ps_flush_report);
-
-static void als_work_func(struct work_struct *work)
-{
-	struct alsps_context *cxt = NULL;
-	int value, status;
-	int64_t nt;
-	struct timespec time;
-	int err;
-
-	cxt = alsps_context_obj;
-	if (cxt->als_data.get_data == NULL) {
-		pr_err("alsps driver not register data path\n");
-		return;
-	}
-
-	time.tv_sec = time.tv_nsec = 0;
-	time = get_monotonic_coarse();
-	nt = time.tv_sec * 1000000000LL + time.tv_nsec;
-	/* add wake lock to make sure data can be read before system suspend */
-	err = cxt->als_data.get_data(&value, &status);
-	if (err) {
-		pr_err("get alsps data fails!!\n");
-		goto als_loop;
-	} else {
-		cxt->drv_data.als_data.values[0] = value;
-		cxt->drv_data.als_data.status = status;
-		cxt->drv_data.als_data.time = nt;
-	}
-
-	if (true == cxt->is_als_first_data_after_enable) {
-		cxt->is_als_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.als_data.values[0] == ALSPS_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto als_loop;
-		}
-	}
-	/* pr_debug(" als data[%d]\n" , cxt->drv_data.als_data.values[0]); */
-	als_data_report(cxt->drv_data.als_data.values[0],
-			cxt->drv_data.als_data.status);
-
-als_loop:
-	if (true == cxt->is_als_polling_run)
-		mod_timer(&cxt->timer_als,
-			  jiffies + atomic_read(&cxt->delay_als) / (1000 / HZ));
-}
-
-static void ps_work_func(struct work_struct *work)
-{
-
-	struct alsps_context *cxt = NULL;
-	int value, status;
-	int64_t nt;
-	struct timespec time;
-	int err = 0;
-
-	cxt = alsps_context_obj;
-	if (cxt->ps_data.get_data == NULL) {
-		pr_err("alsps driver not register data path\n");
-		return;
-	}
-
-	time.tv_sec = time.tv_nsec = 0;
-	time = get_monotonic_coarse();
-	nt = time.tv_sec * 1000000000LL + time.tv_nsec;
-
-	/* add wake lock to make sure data can be read before system suspend */
-	err = cxt->ps_data.get_data(&value, &status);
-	if (err) {
-		pr_err("get alsps data fails!!\n");
-		goto ps_loop;
-	} else {
-		cxt->drv_data.ps_data.values[0] = value;
-		cxt->drv_data.ps_data.status = status;
-		cxt->drv_data.ps_data.time = nt;
-	}
-
-	if (true == cxt->is_ps_first_data_after_enable) {
-		cxt->is_ps_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.ps_data.values[0] == ALSPS_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto ps_loop;
-		}
-	}
-
-	if (cxt->is_get_valid_ps_data_after_enable == false) {
-		if (cxt->drv_data.ps_data.values[0] != ALSPS_INVALID_VALUE)
-			cxt->is_get_valid_ps_data_after_enable = true;
-	}
-
-	ps_data_report(cxt->drv_data.ps_data.values[0],
-		       cxt->drv_data.ps_data.status);
-
-ps_loop:
-	if (true == cxt->is_ps_polling_run) {
-		if (cxt->ps_ctl.is_polling_mode ||
-		    (cxt->is_get_valid_ps_data_after_enable == false))
-			mod_timer(&cxt->timer_ps,
-				  jiffies +
-					  atomic_read(&cxt->delay_ps) /
-						  (1000 / HZ));
-	}
-}
-
-static void als_poll(struct timer_list *t)
-{
-	struct alsps_context *obj = from_timer(obj, t, timer_als);
-
-	if ((obj != NULL) && (obj->is_als_polling_run))
-		schedule_work(&obj->report_als);
-}
-
-static void ps_poll(struct timer_list *t)
-{
-	struct alsps_context *obj = from_timer(obj, t, timer_ps);
-
-	if (obj != NULL)
-		schedule_work(&obj->report_ps);
-}
-
-static struct alsps_context *alsps_context_alloc_object(void)
-{
-	struct alsps_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc alsps object error!\n");
-		return NULL;
-	}
-	atomic_set(&obj->delay_als,
-		   200); /*5Hz, set work queue delay time 200ms */
-	atomic_set(&obj->delay_ps,
-		   200); /* 5Hz,  set work queue delay time 200ms */
-	atomic_set(&obj->wake, 0);
-	INIT_WORK(&obj->report_als, als_work_func);
-	INIT_WORK(&obj->report_ps, ps_work_func);
-	timer_setup(&obj->timer_als, als_poll, 0);
-	timer_setup(&obj->timer_ps, ps_poll, 0);
-	obj->timer_als.expires =
-		jiffies + atomic_read(&obj->delay_als) / (1000 / HZ);
-
-	obj->timer_ps.expires =
-		jiffies + atomic_read(&obj->delay_ps) / (1000 / HZ);
-
-	obj->is_als_first_data_after_enable = false;
-	obj->is_als_polling_run = false;
-	obj->is_ps_first_data_after_enable = false;
-	obj->is_ps_polling_run = false;
-	mutex_init(&obj->alsps_op_mutex);
-	obj->is_als_batch_enable = false; /* for batch mode init */
-	obj->is_ps_batch_enable = false;  /* for batch mode init */
-	obj->als_power = 0;
-	obj->als_enable = 0;
-	obj->als_delay_ns = -1;
-	obj->als_latency_ns = -1;
-	obj->ps_power = 0;
-	obj->ps_enable = 0;
-	obj->ps_delay_ns = -1;
-	obj->ps_latency_ns = -1;
-
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-
-#if !defined(CONFIG_NANOHUB) || !defined(CONFIG_MTK_ALSPSHUB)
-static int als_enable_and_batch(void)
-{
-	struct alsps_context *cxt = alsps_context_obj;
-	int err;
-
-	/* als_power on -> power off */
-	if (cxt->als_power == 1 && cxt->als_enable == 0) {
-		pr_debug("ALSPS disable\n");
-		/* stop polling firstly, if needed */
-		if (cxt->als_ctl.is_report_input_direct == false &&
-		    cxt->is_als_polling_run == true) {
-			smp_mb(); /* for memory barrier */
-			del_timer_sync(&cxt->timer_als);
-			smp_mb(); /* for memory barrier */
-			cancel_work_sync(&cxt->report_als);
-			cxt->drv_data.als_data.values[0] = ALSPS_INVALID_VALUE;
-			cxt->is_als_polling_run = false;
-			pr_debug("als stop polling done\n");
-		}
-		/* turn off the als_power */
-		err = cxt->als_ctl.enable_nodata(0);
-		if (err) {
-			pr_err("als turn off als_power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("als turn off als_power done\n");
-
-		cxt->als_power = 0;
-		cxt->als_delay_ns = -1;
-		pr_debug("ALSPS disable done\n");
-		return 0;
-	}
-	/* als_power off -> power on */
-	if (cxt->als_power == 0 && cxt->als_enable == 1) {
-		pr_debug("ALSPS als_power on\n");
-		err = cxt->als_ctl.enable_nodata(1);
-		if (err) {
-			pr_err("als turn on als_power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("als turn on als_power done\n");
-
-		cxt->als_power = 1;
-		pr_debug("ALSPS als_power on done\n");
-	}
-	/* rate change */
-	if (cxt->als_power == 1 && cxt->als_delay_ns >= 0) {
-		pr_debug("ALSPS set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->als_ctl.is_support_batch)
-			err = cxt->als_ctl.batch(0, cxt->als_delay_ns,
-						 cxt->als_latency_ns);
-		else
-			err = cxt->als_ctl.batch(0, cxt->als_delay_ns, 0);
-		if (err) {
-			pr_err("als set batch(ODR) err %d\n", err);
-			return -1;
-		}
-		pr_debug("als set ODR, fifo latency done\n");
-		/* start polling, if needed */
-		if (cxt->als_ctl.is_report_input_direct == false) {
-			uint64_t mdelay = cxt->als_delay_ns;
-
-			do_div(mdelay, 1000000);
-			/* defaut max polling delay */
-			if (mdelay < 10)
-				mdelay = 10;
-			atomic_set(&cxt->delay_als, mdelay);
-			/* the first sensor start polling timer */
-			if (cxt->is_als_polling_run == false) {
-				mod_timer(&cxt->timer_als,
-					  jiffies +
-						  atomic_read(&cxt->delay_als) /
-							  (1000 / HZ));
-				cxt->is_als_polling_run = true;
-				cxt->is_als_first_data_after_enable = true;
-			}
-			pr_debug("als set polling delay %d ms\n",
-				  atomic_read(&cxt->delay_als));
-		}
-		pr_debug("ALSPS batch done\n");
-	}
-	return 0;
-}
-#endif
-
-static ssize_t alsactive_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct alsps_context *cxt = alsps_context_obj;
-	int err = 0, handle = -1, en = 0;
-
-	err = sscanf(buf, "%d,%d", &handle, &en);
-	if (err < 0) {
-		pr_err("%s param error: err = %d\n", __func__, err);
-		return err;
-	}
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-	if (handle == ID_LIGHT) {
-		if (en) {
-			cxt->als_enable = 1;
-			last_als_report_data = -1;
-		} else if (!en) {
-			cxt->als_enable = 0;
-		} else {
-			pr_err("alsps_store_active error !!\n");
-			err = -1;
-			goto err_out;
-		}
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_ALSPSHUB)
-		if (cxt->als_enable) {
-			err = cxt->als_ctl.enable_nodata(cxt->als_enable);
-			if (err) {
-				pr_err("als turn on err = %d\n", err);
-				goto err_out;
-			}
-		} else {
-			err = cxt->als_ctl.enable_nodata(cxt->als_enable);
-			if (err) {
-				pr_err("als turn off err = %d\n", err);
-				goto err_out;
-			}
-		}
-#else
-		err = als_enable_and_batch();
-#endif
-	} else if (handle == ID_RGBW) {
-		if (en)
-			cxt->rgbw_enable = 1;
-		else if (!en)
-			cxt->rgbw_enable = 0;
-		else {
-			pr_err("alsps_store_active error !!\n");
-			err = -1;
-			goto err_out;
-		}
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_ALSPSHUB)
-		if (cxt->rgbw_enable) {
-			err = cxt->als_ctl.rgbw_enable(cxt->rgbw_enable);
-			if (err) {
-				pr_err("rgbw turn on err = %d\n", err);
-				goto err_out;
-			}
-		} else {
-			err = cxt->als_ctl.rgbw_enable(cxt->rgbw_enable);
-			if (err) {
-				pr_err("rgbw turn off err = %d\n", err);
-				goto err_out;
-			}
-		}
-#endif
-	}
-
-err_out:
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	pr_debug("%s done\n", __func__);
-	if (err)
-		return err;
-	else
-		return count;
-}
-/*----------------------------------------------------------------------------*/
-static ssize_t alsactive_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	struct alsps_context *cxt = NULL;
-	int div = 0;
-
-	cxt = alsps_context_obj;
-	div = cxt->als_data.vender_div;
-	pr_debug("als vender_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-static ssize_t alsbatch_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct alsps_context *cxt = alsps_context_obj;
-	int handle = 0, flag = 0, err = 0;
-	int64_t delay_ns = 0;
-	int64_t latency_ns = 0;
-
-	pr_debug("%s %s\n", __func__, buf);
-	err = sscanf(buf, "%d,%d,%lld,%lld", &handle, &flag, &cxt->als_delay_ns,
-		     &cxt->als_latency_ns);
-	if (err != 4) {
-		pr_err("%s param error: err = %d\n", __func__, err);
-		return -1;
-	}
-
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-	if (handle == ID_LIGHT) {
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_ALSPSHUB)
-		if (cxt->als_ctl.is_support_batch)
-			err = cxt->als_ctl.batch(0, cxt->als_delay_ns,
-				cxt->als_latency_ns);
-		else
-			err = cxt->als_ctl.batch(0, cxt->als_delay_ns, 0);
-#else
-		err = als_enable_and_batch();
-#endif
-	} else if (handle == ID_RGBW) {
-		cxt->rgbw_delay_ns = delay_ns;
-		cxt->rgbw_latency_ns = latency_ns;
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_ALSPSHUB)
-		if (cxt->als_ctl.is_support_batch)
-			err = cxt->als_ctl.rgbw_batch(0, cxt->rgbw_delay_ns,
-				cxt->rgbw_latency_ns);
-		else
-			err = cxt->als_ctl.rgbw_batch(0, cxt->rgbw_delay_ns, 0);
-#endif
-	}
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	pr_debug("%s done: %d\n", __func__, cxt->is_als_batch_enable);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t alsbatch_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t alsflush_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct alsps_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-	cxt = alsps_context_obj;
-	if (handle == ID_LIGHT) {
-		if (cxt->als_ctl.flush != NULL)
-			err = cxt->als_ctl.flush();
-		else
-			pr_err("DON'T SUPPORT ALS COMMON VERSION FLUSH\n");
-		if (err < 0)
-			pr_err("als enable flush err %d\n", err);
-	} else if (handle == ID_RGBW) {
-		if (cxt->als_ctl.rgbw_flush != NULL)
-			err = cxt->als_ctl.rgbw_flush();
-		else
-			pr_err("DON'T SUPPORT RGB COMMON VERSION FLUSH\n");
-		if (err < 0)
-			pr_err("rgbw enable flush err %d\n", err);
-	}
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t alsflush_show(struct device *dev,
-		struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-/* need work around again */
-static ssize_t alsdevnum_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-static ssize_t alscali_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	struct alsps_context *cxt = NULL;
-	int err = 0;
-	uint8_t *cali_buf = NULL;
-
-	cali_buf = vzalloc(count);
-	if (!cali_buf)
-		return -ENOMEM;
-	memcpy(cali_buf, buf, count);
-
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-	cxt = alsps_context_obj;
-	if (cxt->als_ctl.set_cali != NULL)
-		err = cxt->als_ctl.set_cali(cali_buf, count);
-	if (err < 0)
-		pr_err("als set cali err %d\n", err);
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	vfree(cali_buf);
-	return count;
-}
-
-#if !defined(CONFIG_NANOHUB) || !defined(CONFIG_MTK_ALSPSHUB)
-static int ps_enable_and_batch(void)
-{
-	struct alsps_context *cxt = alsps_context_obj;
-	int err;
-
-	/* ps_power on -> power off */
-	if (cxt->ps_power == 1 && cxt->ps_enable == 0) {
-		pr_debug("PS disable\n");
-/* stop polling firstly, if needed */
-/*
- *		if (cxt->ps_ctl.is_report_input_direct == false
- *			&& cxt->is_ps_polling_run == true) {
- *			smp_mb();// for memory barrier
- *			del_timer_sync(&cxt->timer_ps);
- *			smp_mb();// for memory barrier
- *			cancel_work_sync(&cxt->report_ps);
- *			cxt->drv_data.ps_data.values[0] = ALSPS_INVALID_VALUE;
- *			cxt->is_ps_polling_run = false;
- *			pr_debug("ps stop polling done\n");
- *		}
- */
-		/* turn off the ps_power */
-		err = cxt->ps_ctl.enable_nodata(0);
-		if (err) {
-			pr_err("ps turn off ps_power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("ps turn off ps_power done\n");
-
-		cxt->ps_power = 0;
-		cxt->ps_delay_ns = -1;
-		pr_debug("PS disable done\n");
-		return 0;
-	}
-	/* ps_power off -> power on */
-	if (cxt->ps_power == 0 && cxt->ps_enable == 1) {
-		pr_debug("PS ps_power on\n");
-		err = cxt->ps_ctl.enable_nodata(1);
-		if (err) {
-			pr_err("ps turn on ps_power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("ps turn on ps_power done\n");
-
-		cxt->ps_power = 1;
-		pr_debug("PS ps_power on done\n");
-	}
-	/* rate change */
-	if (cxt->ps_power == 1 && cxt->ps_delay_ns >= 0) {
-		pr_debug("PS set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->ps_ctl.is_support_batch)
-			err = cxt->ps_ctl.batch(0, cxt->ps_delay_ns,
-						cxt->ps_latency_ns);
-		else
-			err = cxt->ps_ctl.batch(0, cxt->ps_delay_ns, 0);
-		if (err) {
-			pr_err("ps set batch(ODR) err %d\n", err);
-			return -1;
-		}
-		pr_debug("ps set ODR, fifo latency done\n");
-/* start polling, if needed */
-/*		if (cxt->ps_ctl.is_report_input_direct == false) {
- *			int mdelay = cxt->ps_delay_ns;
- *
- *			do_div(mdelay, 1000000);
- *			atomic_set(&cxt->delay_ps, mdelay);
- *			if (cxt->is_ps_polling_run == false) {
- *				mod_timer(&cxt->timer_ps, jiffies +
- *					atomic_read(&cxt->delay_ps)/(1000/HZ));
- *				cxt->is_ps_polling_run = true;
- *				cxt->is_ps_first_data_after_enable = true;
- *			}
- *		pr_debug("ps delay %d ms\n", atomic_read(&cxt->delay_ps));
- *		} else {
- *			ps_data_report(1, 3);
- *		}
- */
-		pr_debug("PS batch done\n");
-	}
-	return 0;
-}
-#endif
-static ssize_t psactive_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct alsps_context *cxt = alsps_context_obj;
-	int err = 0;
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-
-	if (!strncmp(buf, "1", 1))
-		cxt->ps_enable = 1;
-	else if (!strncmp(buf, "0", 1))
-		cxt->ps_enable = 0;
-	else {
-		pr_err("%s error !!\n", __func__);
-		err = -1;
-		goto err_out;
-	}
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_ALSPSHUB)
-	err = cxt->ps_ctl.enable_nodata(cxt->ps_enable);
-#else
-	err = ps_enable_and_batch();
-#endif
-err_out:
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	pr_debug("%s done\n", __func__);
-	if (err)
-		return err;
-	else
-		return count;
-}
-/*----------------------------------------------------------------------------*/
-static ssize_t psactive_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	struct alsps_context *cxt = NULL;
-	int div = 0;
-
-	cxt = alsps_context_obj;
-	div = cxt->ps_data.vender_div;
-	pr_debug("ps vender_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-static ssize_t psbatch_store(struct device *dev, struct device_attribute *attr,
-			      const char *buf, size_t count)
-{
-	struct alsps_context *cxt = alsps_context_obj;
-	int handle = 0, flag = 0, err = 0;
-
-	pr_debug("%s %s\n", __func__, buf);
-	err = sscanf(buf, "%d,%d,%lld,%lld", &handle, &flag, &cxt->ps_delay_ns,
-		     &cxt->ps_latency_ns);
-	if (err != 4) {
-		pr_err("%s param error: err = %d\n", __func__, err);
-		return -1;
-	}
-
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_ALSPSHUB)
-	if (cxt->ps_ctl.is_support_batch)
-		err = cxt->ps_ctl.batch(0, cxt->ps_delay_ns,
-					cxt->ps_latency_ns);
-	else
-		err = cxt->ps_ctl.batch(0, cxt->ps_delay_ns, 0);
-#else
-	err = ps_enable_and_batch();
-#endif
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	pr_debug("%s done: %d\n", __func__, cxt->is_ps_batch_enable);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t psbatch_show(struct device *dev, struct device_attribute *attr,
-			     char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t psflush_store(struct device *dev, struct device_attribute *attr,
-			      const char *buf, size_t count)
-{
-	struct alsps_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-	cxt = alsps_context_obj;
-	if (cxt->ps_ctl.flush != NULL)
-		err = cxt->ps_ctl.flush();
-	if (err < 0)
-		pr_err("ps enable flush err %d\n", err);
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t psflush_show(struct device *dev, struct device_attribute *attr,
-			     char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-/* need work around again */
-static ssize_t psdevnum_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t pscali_store(struct device *dev, struct device_attribute *attr,
-				  const char *buf, size_t count)
-{
-	struct alsps_context *cxt = NULL;
-	int err = 0;
-	uint8_t *cali_buf = NULL;
-
-	cali_buf = vzalloc(count);
-	if (!cali_buf)
-		return -ENOMEM;
-	memcpy(cali_buf, buf, count);
-
-	mutex_lock(&alsps_context_obj->alsps_op_mutex);
-	cxt = alsps_context_obj;
-	if (cxt->ps_ctl.set_cali != NULL)
-		err = cxt->ps_ctl.set_cali(cali_buf, count);
-	if (err < 0)
-		pr_err("ps set cali err %d\n", err);
-	mutex_unlock(&alsps_context_obj->alsps_op_mutex);
-	vfree(cali_buf);
-	return count;
-}
-
-static int als_ps_remove(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int als_ps_probe(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	pltfm_dev = pdev;
-	return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id als_ps_of_match[] = {
-	{
-		.compatible = "mediatek,als_ps",
-	},
-	{},
-};
-#endif
-
-static struct platform_driver als_ps_driver = {
-	.probe = als_ps_probe,
-	.remove = als_ps_remove,
-	.driver = {
-
-		.name = "als_ps",
-#ifdef CONFIG_OF
-		.of_match_table = als_ps_of_match,
-#endif
-	}
-};
-
-static int alsps_real_driver_init(void)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_ALSPS_NUM; i++) {
-		pr_debug("%s i=%d\n", __func__, i);
-		if (alsps_init_list[i] != 0) {
-			pr_debug(" alsps try to init driver %s\n",
-				  alsps_init_list[i]->name);
-			err = alsps_init_list[i]->init();
-			if (err == 0) {
-				pr_debug(" alsps real driver %s probe ok\n",
-					  alsps_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_ALSPS_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-
-	return err;
-}
-
-int alsps_driver_add(struct alsps_init_info *obj)
-{
-	int err = 0;
-	int i = 0;
-
-	pr_debug("%s\n", __func__);
-
-	if (!obj) {
-		pr_err(
-			"ALSPS driver add fail, alsps_init_info is NULL\n");
-		return -1;
-	}
-
-	for (i = 0; i < MAX_CHOOSE_ALSPS_NUM; i++) {
-		if ((i == 0) && (alsps_init_list[0] == NULL)) {
-			pr_debug("register alsps driver for the first time\n");
-			if (platform_driver_register(&als_ps_driver))
-				pr_err(
-					"failed to register alsps driver already exist\n");
-		}
-
-		if (alsps_init_list[i] == NULL) {
-			obj->platform_diver_addr = &als_ps_driver;
-			alsps_init_list[i] = obj;
-			break;
-		}
-	}
-	if (i >= MAX_CHOOSE_ALSPS_NUM) {
-		pr_err("ALSPS driver add err\n");
-		err = -1;
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(alsps_driver_add);
-struct platform_device *get_alsps_platformdev(void)
-{
-	return pltfm_dev;
-}
-
-int ps_report_interrupt_data(int value)
-{
-	struct alsps_context *cxt = NULL;
-	/* int err =0; */
-	cxt = alsps_context_obj;
-	pr_notice("[ALS/PS] [%s]:value=%d\n", __func__, value);
-	if (cxt->is_get_valid_ps_data_after_enable == false) {
-		if (value != ALSPS_INVALID_VALUE) {
-			cxt->is_get_valid_ps_data_after_enable = true;
-			smp_mb(); /*for memory barriier*/
-			del_timer_sync(&cxt->timer_ps);
-			smp_mb(); /*for memory barriier*/
-			cancel_work_sync(&cxt->report_ps);
-		}
-	}
-
-	if (cxt->is_ps_batch_enable == false)
-		ps_data_report(value, 3);
-
-	return 0;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(ps_report_interrupt_data);
-DEVICE_ATTR_RW(alsactive);
-DEVICE_ATTR_RW(alsbatch);
-DEVICE_ATTR_RW(alsflush);
-DEVICE_ATTR_RO(alsdevnum);
-DEVICE_ATTR_WO(alscali);
-DEVICE_ATTR_RW(psactive);
-DEVICE_ATTR_RW(psbatch);
-DEVICE_ATTR_RW(psflush);
-DEVICE_ATTR_RO(psdevnum);
-DEVICE_ATTR_WO(pscali);
-
-static struct attribute *als_attributes[] = {
-	&dev_attr_alsactive.attr,
-	&dev_attr_alsbatch.attr,
-	&dev_attr_alsflush.attr,
-	&dev_attr_alsdevnum.attr,
-	&dev_attr_alscali.attr,
-	NULL
-};
-
-static struct attribute *ps_attributes[] = {
-	&dev_attr_psactive.attr,
-	&dev_attr_psbatch.attr,
-	&dev_attr_psflush.attr,
-	&dev_attr_psdevnum.attr,
-	&dev_attr_pscali.attr,
-	NULL
-};
-
-static struct attribute_group als_attribute_group = {
-	.attrs = als_attributes
-};
-
-static struct attribute_group ps_attribute_group = {
-	.attrs = ps_attributes
-};
-static int light_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t light_read(struct file *file, char __user *buffer, size_t count,
-			  loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(alsps_context_obj->als_mdev.minor, file,
-				     buffer, count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int light_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(alsps_context_obj->als_mdev.minor, file, wait);
-}
-
-static const struct file_operations light_fops = {
-	.owner = THIS_MODULE,
-	.open = light_open,
-	.read = light_read,
-	.poll = light_poll,
-};
-
-static int als_misc_init(struct alsps_context *cxt)
-{
-	int err = 0;
-
-	cxt->als_mdev.minor = ID_LIGHT;
-	cxt->als_mdev.name = ALS_MISC_DEV_NAME;
-	cxt->als_mdev.fops = &light_fops;
-	err = sensor_attr_register(&cxt->als_mdev);
-	if (err)
-		pr_err("unable to register alsps misc device!!\n");
-
-	return err;
-}
-static int proximity_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t proximity_read(struct file *file, char __user *buffer,
-			      size_t count, loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(alsps_context_obj->ps_mdev.minor, file,
-				     buffer, count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int proximity_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(alsps_context_obj->ps_mdev.minor, file, wait);
-}
-
-static const struct file_operations proximity_fops = {
-	.owner = THIS_MODULE,
-	.open = proximity_open,
-	.read = proximity_read,
-	.poll = proximity_poll,
-};
-
-static int ps_misc_init(struct alsps_context *cxt)
-{
-	int err = 0;
-
-	cxt->ps_mdev.minor = ID_PROXIMITY;
-	cxt->ps_mdev.name = PS_MISC_DEV_NAME;
-	cxt->ps_mdev.fops = &proximity_fops;
-	err = sensor_attr_register(&cxt->ps_mdev);
-	if (err)
-		pr_err("unable to register alsps misc device!!\n");
-
-	return err;
-}
-
-int als_register_data_path(struct als_data_path *data)
-{
-	struct alsps_context *cxt = NULL;
-	/* int err =0; */
-	cxt = alsps_context_obj;
-	cxt->als_data.get_data = data->get_data;
-	cxt->als_data.vender_div = data->vender_div;
-	cxt->als_data.als_get_raw_data = data->als_get_raw_data;
-	pr_debug("alsps register data path vender_div: %d\n",
-		  cxt->als_data.vender_div);
-	if (cxt->als_data.get_data == NULL) {
-		pr_debug("als register data path fail\n");
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(als_register_data_path);
-
-int ps_register_data_path(struct ps_data_path *data)
-{
-	struct alsps_context *cxt = NULL;
-	/* int err =0; */
-	cxt = alsps_context_obj;
-	cxt->ps_data.get_data = data->get_data;
-	cxt->ps_data.vender_div = data->vender_div;
-	cxt->ps_data.ps_get_raw_data = data->ps_get_raw_data;
-	pr_debug("alsps register data path vender_div: %d\n",
-		  cxt->ps_data.vender_div);
-	if (cxt->ps_data.get_data == NULL) {
-		pr_debug("ps register data path fail\n");
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(ps_register_data_path);
-
-int als_register_control_path(struct als_control_path *ctl)
-{
-	struct alsps_context *cxt = NULL;
-	int err = 0;
-
-	cxt = alsps_context_obj;
-	cxt->als_ctl.set_delay = ctl->set_delay;
-	cxt->als_ctl.open_report_data = ctl->open_report_data;
-	cxt->als_ctl.enable_nodata = ctl->enable_nodata;
-	cxt->als_ctl.batch = ctl->batch;
-	cxt->als_ctl.flush = ctl->flush;
-	cxt->als_ctl.set_cali = ctl->set_cali;
-	cxt->als_ctl.rgbw_enable = ctl->rgbw_enable;
-	cxt->als_ctl.rgbw_batch = ctl->rgbw_batch;
-	cxt->als_ctl.rgbw_flush = ctl->rgbw_flush;
-	cxt->als_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->als_ctl.is_report_input_direct = ctl->is_report_input_direct;
-	cxt->als_ctl.is_use_common_factory = ctl->is_use_common_factory;
-
-	if (cxt->als_ctl.enable_nodata == NULL || cxt->als_ctl.batch == NULL ||
-	    cxt->als_ctl.flush == NULL) {
-		pr_debug("als register control path fail\n");
-		return -1;
-	}
-
-	/* add misc dev for sensor hal control cmd */
-	err = als_misc_init(alsps_context_obj);
-	if (err) {
-		pr_err("unable to register alsps misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&alsps_context_obj->als_mdev.this_device->kobj,
-				 &als_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create alsps attribute file\n");
-		return -3;
-	}
-	kobject_uevent(&alsps_context_obj->als_mdev.this_device->kobj,
-		       KOBJ_ADD);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(als_register_control_path);
-
-int ps_register_control_path(struct ps_control_path *ctl)
-{
-	struct alsps_context *cxt = NULL;
-	int err = 0;
-
-	cxt = alsps_context_obj;
-	cxt->ps_ctl.set_delay = ctl->set_delay;
-	cxt->ps_ctl.open_report_data = ctl->open_report_data;
-	cxt->ps_ctl.enable_nodata = ctl->enable_nodata;
-	cxt->ps_ctl.batch = ctl->batch;
-	cxt->ps_ctl.flush = ctl->flush;
-	cxt->ps_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->ps_ctl.is_report_input_direct = ctl->is_report_input_direct;
-	cxt->ps_ctl.ps_calibration = ctl->ps_calibration;
-	cxt->ps_ctl.set_cali = ctl->set_cali;
-	cxt->ps_ctl.is_use_common_factory = ctl->is_use_common_factory;
-	cxt->ps_ctl.is_polling_mode = ctl->is_polling_mode;
-
-	if (cxt->ps_ctl.enable_nodata == NULL || cxt->ps_ctl.batch == NULL ||
-	    cxt->ps_ctl.flush == NULL) {
-		pr_debug("ps register control path fail\n");
-		return -1;
-	}
-
-	err = ps_misc_init(alsps_context_obj);
-	if (err) {
-		pr_err("unable to register alsps misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&alsps_context_obj->ps_mdev.this_device->kobj,
-				 &ps_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create alsps attribute file\n");
-		return -3;
-	}
-	kobject_uevent(&alsps_context_obj->ps_mdev.this_device->kobj, KOBJ_ADD);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(ps_register_control_path);
-
-/* AAL functions**************************************** */
-int alsps_aal_enable(int enable)
-{
-	return 0;
-}
-
-int alsps_aal_get_status(void)
-{
-	return 0;
-}
-
-int alsps_aal_get_data(void)
-{
-	return 0;
-}
-/* *************************************************** */
-
-int alsps_probe(void)
-{
-	int err;
-
-	pr_debug("%s start!!\n", __func__);
-	alsps_context_obj = alsps_context_alloc_object();
-	if (!alsps_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-	/* init real alspseleration driver */
-	err = alsps_real_driver_init();
-	if (err) {
-		pr_err("alsps real driver init fail\n");
-		goto real_driver_init_fail;
-	}
-	pr_debug("%s OK !!\n", __func__);
-	return 0;
-
-real_driver_init_fail:
-	kfree(alsps_context_obj);
-	alsps_context_obj = NULL;
-exit_alloc_data_failed:
-	pr_err("%s fail !!!\n", __func__);
-	return err;
-}
-EXPORT_SYMBOL_GPL(alsps_probe);
-
-int alsps_remove(void)
-{
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-	sysfs_remove_group(&alsps_context_obj->als_mdev.this_device->kobj,
-			   &als_attribute_group);
-	sysfs_remove_group(&alsps_context_obj->ps_mdev.this_device->kobj,
-			   &ps_attribute_group);
-
-	err = sensor_attr_deregister(&alsps_context_obj->als_mdev);
-	err = sensor_attr_deregister(&alsps_context_obj->ps_mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-	kfree(alsps_context_obj);
-
-	platform_driver_unregister(&als_ps_driver);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(alsps_remove);
-
-static int __init alsps_init(void)
-{
-	pr_debug("%s\n", __func__);
-	AAL_init();
-	return 0;
-}
-
-static void __exit alsps_exit(void)
-{
-	pr_debug("%s\n", __func__);
-	AAL_exit();
-}
-
-module_init(alsps_init);
-module_exit(alsps_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("ALSPS device driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alsps_factory.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alsps_factory.c
deleted file mode 100644
index aded6e0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alsps_factory.c
+++ /dev/null
@@ -1,376 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<ALS/PS> " fmt
-
-#include "inc/alsps_factory.h"
-
-struct alsps_factory_private {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct alsps_factory_fops *fops;
-};
-
-static struct alsps_factory_private alsps_factory;
-
-static int alsps_factory_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static int alsps_factory_release(struct inode *inode, struct file *file)
-{
-	file->private_data = NULL;
-	return 0;
-}
-
-static long alsps_factory_unlocked_ioctl(struct file *file, unsigned int cmd,
-					 unsigned long arg)
-{
-	long err = 0;
-	void __user *ptr = (void __user *)arg;
-	int data = 0;
-	uint32_t enable = 0;
-	int threshold_data[2] = {0, 0};
-	int als_cali = 0;
-
-	if (_IOC_DIR(cmd) & _IOC_READ)
-		err = !access_ok(VERIFY_WRITE, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-	else if (_IOC_DIR(cmd) & _IOC_WRITE)
-		err = !access_ok(VERIFY_READ, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-
-	if (err) {
-		pr_debug("access error: %08X, (%2d, %2d)\n", cmd,
-			  _IOC_DIR(cmd), _IOC_SIZE(cmd));
-		return -EFAULT;
-	}
-
-	switch (cmd) {
-	case ALSPS_SET_PS_MODE:
-		if (copy_from_user(&enable, ptr, sizeof(enable)))
-			return -EFAULT;
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_enable_sensor != NULL) {
-			err = alsps_factory.fops->ps_enable_sensor(enable, 200);
-			if (err < 0) {
-				pr_err("ALSPS_SET_PS_MODE fail!\n");
-				return -EINVAL;
-			}
-			pr_debug(
-				"ALSPS_SET_PS_MODE, enable: %d, sample_period:%dms\n",
-				enable, 200);
-		} else {
-			pr_err("ALSPS_SET_PS_MODE NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_GET_PS_RAW_DATA:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_get_raw_data != NULL) {
-			err = alsps_factory.fops->ps_get_raw_data(&data);
-			if (err < 0) {
-				pr_err(
-					"ALSPS_GET_PS_RAW_DATA read data fail!\n");
-				return -EINVAL;
-			}
-			if (copy_to_user(ptr, &data, sizeof(data)))
-				return -EFAULT;
-		} else {
-			pr_err("ALSPS_GET_PS_RAW_DATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_SET_ALS_MODE:
-		if (copy_from_user(&enable, ptr, sizeof(enable)))
-			return -EFAULT;
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->als_enable_sensor != NULL) {
-			err = alsps_factory.fops->als_enable_sensor(enable,
-								    200);
-			if (err < 0) {
-				pr_err("ALSPS_SET_ALS_MODE fail!\n");
-				return -EINVAL;
-			}
-			pr_debug(
-				"ALSPS_SET_ALS_MODE, enable: %d, sample_period:%dms\n",
-				enable, 200);
-		} else {
-			pr_err("ALSPS_SET_ALS_MODE NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_GET_ALS_RAW_DATA:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->als_get_raw_data != NULL) {
-			err = alsps_factory.fops->als_get_raw_data(&data);
-			if (err < 0) {
-				pr_err(
-					"ALSPS_GET_ALS_RAW_DATA read data fail!\n");
-				return -EINVAL;
-			}
-			if (copy_to_user(ptr, &data, sizeof(data)))
-				return -EFAULT;
-		} else {
-			pr_err("ALSPS_GET_ALS_RAW_DATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_ALS_ENABLE_CALI:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->als_enable_calibration != NULL) {
-			err = alsps_factory.fops->als_enable_calibration();
-			if (err < 0) {
-				pr_err("ALSPS_ALS_ENABLE_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_ALS_ENABLE_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_ALS_SET_CALI:
-		if (copy_from_user(&als_cali, ptr, sizeof(als_cali)))
-			return -EFAULT;
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->als_set_cali != NULL) {
-			err = alsps_factory.fops->als_set_cali(als_cali);
-			if (err < 0) {
-				pr_err("ALSPS_ALS_SET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_ALS_SET_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_GET_PS_TEST_RESULT:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_get_data != NULL) {
-			err = alsps_factory.fops->ps_get_data(&data);
-			if (err < 0) {
-				pr_err(
-					"ALSPS_GET_PS_TEST_RESULT read data fail!\n");
-				return -EINVAL;
-			}
-			if (copy_to_user(ptr, &data, sizeof(data)))
-				return -EFAULT;
-		} else {
-			pr_err("ALSPS_GET_PS_TEST_RESULT NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_GET_PS_THRESHOLD_HIGH:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_get_threshold != NULL) {
-			err = alsps_factory.fops->ps_get_threshold(
-				threshold_data);
-			if (err < 0) {
-				pr_err(
-					"ALSPS_GET_PS_THRESHOLD_HIGH read data fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_GET_PS_THRESHOLD_HIGH NULL\n");
-			return -EINVAL;
-		}
-		if (copy_to_user(ptr, &threshold_data[0],
-				 sizeof(threshold_data[0])))
-			return -EFAULT;
-		return 0;
-	case ALSPS_GET_PS_THRESHOLD_LOW:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_get_threshold != NULL) {
-			err = alsps_factory.fops->ps_get_threshold(
-				threshold_data);
-			if (err < 0) {
-				pr_err(
-					"ALSPS_GET_PS_THRESHOLD_HIGH read data fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_GET_PS_THRESHOLD_HIGH NULL\n");
-			return -EINVAL;
-		}
-		if (copy_to_user(ptr, &threshold_data[1],
-				 sizeof(threshold_data[1])))
-			return -EFAULT;
-		return 0;
-	case ALSPS_SET_PS_THRESHOLD:
-		if (copy_from_user(threshold_data, ptr, sizeof(threshold_data)))
-			return -EFAULT;
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_set_threshold != NULL) {
-			err = alsps_factory.fops->ps_set_threshold(
-				threshold_data);
-			if (err < 0) {
-				pr_err("ALSPS_SET_PS_THRESHOLD fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_SET_PS_THRESHOLD NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_IOCTL_SET_CALI:
-		if (copy_from_user(&data, ptr, sizeof(data)))
-			return -EFAULT;
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_set_cali != NULL) {
-			err = alsps_factory.fops->ps_set_cali(data);
-			if (err < 0) {
-				pr_err("ALSPS_IOCTL_SET_CALI fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_IOCTL_SET_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_IOCTL_GET_CALI:
-		if (alsps_factory.fops != NULL &&
-		    alsps_factory.fops->ps_get_cali != NULL) {
-			err = alsps_factory.fops->ps_get_cali(&data);
-			if (err < 0) {
-				pr_err("ALSPS_IOCTL_GET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_IOCTL_GET_CALI NULL\n");
-			return -EINVAL;
-		}
-		if (copy_to_user(ptr, &data, sizeof(data)))
-			return -EFAULT;
-		return 0;
-	case ALSPS_IOCTL_ALS_GET_CALI:
-		if (alsps_factory.fops != NULL &&
-			alsps_factory.fops->als_get_cali != NULL) {
-			err = alsps_factory.fops->als_get_cali(&data);
-			if (err < 0) {
-				pr_err("ALSPS_IOCTL_ALS_GET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_IOCTL_ALS_GET_CALI NULL\n");
-			return -EINVAL;
-		}
-		if (copy_to_user(ptr, &data, sizeof(data)))
-			return -EFAULT;
-		return 0;
-	case ALSPS_IOCTL_CLR_CALI:
-		if (copy_from_user(&data, ptr, sizeof(data)))
-			return -EFAULT;
-		if (alsps_factory.fops != NULL &&
-			alsps_factory.fops->ps_clear_cali != NULL) {
-			err = alsps_factory.fops->ps_clear_cali();
-			if (err < 0) {
-				pr_err("ALSPS_IOCTL_CLR_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_IOCTL_CLR_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case ALSPS_PS_ENABLE_CALI:
-		if (alsps_factory.fops != NULL &&
-			alsps_factory.fops->ps_enable_calibration != NULL) {
-			err = alsps_factory.fops->ps_enable_calibration();
-			if (err < 0) {
-				pr_err("ALSPS_PS_ENABLE_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("ALSPS_PS_ENABLE_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	default:
-		pr_err("unknown IOCTL: 0x%08x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-	return 0;
-}
-#ifdef CONFIG_COMPAT
-static long alsps_factory_compat_ioctl(struct file *file,
-	unsigned int cmd, unsigned long arg)
-{
-	long err = 0;
-
-	void __user *arg32 = compat_ptr(arg);
-
-	if (!file->f_op || !file->f_op->unlocked_ioctl)
-		return -ENOTTY;
-
-	switch (cmd) {
-	case COMPAT_ALSPS_SET_PS_MODE:
-	case COMPAT_ALSPS_GET_PS_RAW_DATA:
-	case COMPAT_ALSPS_SET_ALS_MODE:
-	case COMPAT_ALSPS_GET_ALS_RAW_DATA:
-	case COMPAT_ALSPS_GET_PS_TEST_RESULT:
-	case COMPAT_ALSPS_GET_PS_THRESHOLD_HIGH:
-	case COMPAT_ALSPS_GET_PS_THRESHOLD_LOW:
-	case COMPAT_ALSPS_SET_PS_THRESHOLD:
-	case COMPAT_ALSPS_IOCTL_SET_CALI:
-	case COMPAT_ALSPS_IOCTL_GET_CALI:
-	case COMPAT_ALSPS_IOCTL_ALS_GET_CALI:
-	case COMPAT_ALSPS_IOCTL_CLR_CALI:
-	case COMPAT_ALSPS_ALS_ENABLE_CALI:
-	case COMPAT_ALSPS_PS_ENABLE_CALI:
-	case COMPAT_ALSPS_IOCTL_ALS_SET_CALI:
-		err = file->f_op->unlocked_ioctl(file, cmd,
-						 (unsigned long)arg32);
-		break;
-	default:
-		pr_err("unknown IOCTL: 0x%08x\n", cmd);
-		err = -ENOIOCTLCMD;
-		break;
-	}
-
-	return err;
-}
-#endif
-
-static const struct file_operations _alsps_factory_fops = {
-	.open = alsps_factory_open,
-	.release = alsps_factory_release,
-	.unlocked_ioctl = alsps_factory_unlocked_ioctl,
-#ifdef CONFIG_COMPAT
-	.compat_ioctl = alsps_factory_compat_ioctl,
-#endif
-};
-
-static struct miscdevice alsps_factory_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "als_ps",
-	.fops = &_alsps_factory_fops,
-};
-
-int alsps_factory_device_register(struct alsps_factory_public *dev)
-{
-	int err = 0;
-
-	if (!dev || !dev->fops)
-		return -1;
-	alsps_factory.gain = dev->gain;
-	alsps_factory.sensitivity = dev->sensitivity;
-	alsps_factory.fops = dev->fops;
-	err = misc_register(&alsps_factory_device);
-	if (err) {
-		pr_err("alsps_factory_device register failed\n");
-		err = -1;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(alsps_factory_device_register);
-
-int alsps_factory_device_deregister(struct alsps_factory_public *dev)
-{
-	alsps_factory.fops = NULL;
-	misc_deregister(&alsps_factory_device);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(alsps_factory_device_deregister);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Kconfig
deleted file mode 100644
index 4728c0c..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_ALSPSHUB
-	bool "alspshub for MediaTek package"
-	help
-	  It support different alspshub sensor.
-	  If this option is set,
-	  it will support
-	  sensorhub gyroscope.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Makefile
deleted file mode 100644
index 8569294..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/Makefile
+++ /dev/null
@@ -1,7 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/alsps/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)	:=  alspshub.o
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/alspshub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/alspshub.c
deleted file mode 100644
index 6269e6a..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/alspshub.c
+++ /dev/null
@@ -1,1085 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[ALS/PS] " fmt
-
-#include "alspshub.h"
-#include <alsps.h>
-#include <hwmsensor.h>
-#include <SCP_sensorHub.h>
-#include "SCP_power_monitor.h"
-#include <linux/pm_wakeup.h>
-
-
-#define ALSPSHUB_DEV_NAME     "alsps_hub_pl"
-
-struct alspshub_ipi_data {
-	struct work_struct init_done_work;
-	atomic_t first_ready_after_boot;
-	/*misc */
-	atomic_t	als_suspend;
-	atomic_t	ps_suspend;
-	atomic_t	trace;
-	atomic_t	scp_init_done;
-
-	/*data */
-	u16		als;
-	u8		ps;
-	int		ps_cali;
-	atomic_t	als_cali;
-	atomic_t	ps_thd_val_high;
-	atomic_t	ps_thd_val_low;
-	ulong		enable;
-	ulong		pending_intr;
-	bool als_factory_enable;
-	bool ps_factory_enable;
-	bool als_android_enable;
-	bool ps_android_enable;
-	struct wakeup_source *ps_wake_lock;
-};
-
-static struct alspshub_ipi_data *obj_ipi_data;
-static int ps_get_data(int *value, int *status);
-
-static int alspshub_local_init(void);
-static int alspshub_local_remove(void);
-static int alspshub_init_flag = -1;
-static struct alsps_init_info alspshub_init_info = {
-	.name = "alsps_hub",
-	.init = alspshub_local_init,
-	.uninit = alspshub_local_remove,
-
-};
-
-static DEFINE_MUTEX(alspshub_mutex);
-static DEFINE_SPINLOCK(calibration_lock);
-
-enum {
-	CMC_BIT_ALS = 1,
-	CMC_BIT_PS = 2,
-} CMC_BIT;
-enum {
-	CMC_TRC_ALS_DATA = 0x0001,
-	CMC_TRC_PS_DATA = 0x0002,
-	CMC_TRC_EINT = 0x0004,
-	CMC_TRC_IOCTL = 0x0008,
-	CMC_TRC_I2C = 0x0010,
-	CMC_TRC_CVT_ALS = 0x0020,
-	CMC_TRC_CVT_PS = 0x0040,
-	CMC_TRC_DEBUG = 0x8000,
-} CMC_TRC;
-
-long alspshub_read_ps(u8 *ps)
-{
-	long res;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-	struct data_unit_t data_t;
-
-	res = sensor_get_data_from_hub(ID_PROXIMITY, &data_t);
-	if (res < 0) {
-		*ps = -1;
-		pr_err("sensor_get_data_from_hub fail, (ID: %d)\n",
-			ID_PROXIMITY);
-		return -1;
-	}
-	if (data_t.proximity_t.steps < obj->ps_cali)
-		*ps = 0;
-	else
-		*ps = data_t.proximity_t.steps - obj->ps_cali;
-	return 0;
-}
-
-long alspshub_read_als(u16 *als)
-{
-	long res = 0;
-	struct data_unit_t data_t;
-
-	res = sensor_get_data_from_hub(ID_LIGHT, &data_t);
-	if (res < 0) {
-		*als = -1;
-		pr_err_ratelimited("sensor_get_data_from_hub fail, (ID: %d)\n",
-			ID_LIGHT);
-		return -1;
-	}
-	*als = data_t.light;
-
-	return 0;
-}
-
-static ssize_t trace_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t res = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (!obj_ipi_data) {
-		pr_err("obj_ipi_data is null!!\n");
-		return 0;
-	}
-
-	res = snprintf(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&obj->trace));
-	return res;
-}
-
-static ssize_t trace_store(struct device_driver *ddri,
-				const char *buf, size_t count)
-{
-	int trace = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-	int res = 0;
-	int ret = 0;
-
-	if (!obj) {
-		pr_err("obj_ipi_data is null!!\n");
-		return 0;
-	}
-	ret = sscanf(buf, "0x%x", &trace);
-	if (ret != 1) {
-		pr_err("invalid content: '%s', length = %zu\n", buf, count);
-		return count;
-	}
-	atomic_set(&obj->trace, trace);
-	res = sensor_set_cmd_to_hub(ID_PROXIMITY,
-		CUST_ACTION_SET_TRACE, &trace);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID: %d),(action: %d)\n",
-			ID_PROXIMITY, CUST_ACTION_SET_TRACE);
-		return 0;
-	}
-	return count;
-}
-
-static ssize_t als_show(struct device_driver *ddri, char *buf)
-{
-	int res = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (!obj) {
-		pr_err("obj_ipi_data is null!!\n");
-		return 0;
-	}
-	res = alspshub_read_als(&obj->als);
-	if (res)
-		return snprintf(buf, PAGE_SIZE, "ERROR: %d\n", res);
-	else
-		return snprintf(buf, PAGE_SIZE, "0x%04X\n", obj->als);
-}
-
-static ssize_t ps_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t res = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (!obj) {
-		pr_err("cm3623_obj is null!!\n");
-		return 0;
-	}
-	res = alspshub_read_ps(&obj->ps);
-	if (res)
-		return snprintf(buf, PAGE_SIZE, "ERROR: %d\n", (int)res);
-	else
-		return snprintf(buf, PAGE_SIZE, "0x%04X\n", obj->ps);
-}
-
-static ssize_t reg_show(struct device_driver *ddri, char *buf)
-{
-	int res = 0;
-
-	res = sensor_set_cmd_to_hub(ID_PROXIMITY, CUST_ACTION_SHOW_REG, buf);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID: %d),(action: %d)\n",
-			ID_PROXIMITY, CUST_ACTION_SHOW_REG);
-		return 0;
-	}
-
-	return res;
-}
-
-static ssize_t alslv_show(struct device_driver *ddri, char *buf)
-{
-	int res = 0;
-
-	res = sensor_set_cmd_to_hub(ID_LIGHT, CUST_ACTION_SHOW_ALSLV, buf);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID: %d),(action: %d)\n",
-			ID_LIGHT, CUST_ACTION_SHOW_ALSLV);
-		return 0;
-	}
-
-	return res;
-}
-
-static ssize_t alsval_show(struct device_driver *ddri, char *buf)
-{
-	int res = 0;
-
-	res = sensor_set_cmd_to_hub(ID_LIGHT, CUST_ACTION_SHOW_ALSVAL, buf);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID: %d),(action: %d)\n",
-			ID_LIGHT, CUST_ACTION_SHOW_ALSVAL);
-		return 0;
-	}
-
-	return res;
-}
-
-static DRIVER_ATTR_RO(als);
-static DRIVER_ATTR_RO(ps);
-static DRIVER_ATTR_RO(alslv);
-static DRIVER_ATTR_RO(alsval);
-static DRIVER_ATTR_RW(trace);
-static DRIVER_ATTR_RO(reg);
-static struct driver_attribute *alspshub_attr_list[] = {
-	&driver_attr_als,
-	&driver_attr_ps,
-	&driver_attr_trace,	/*trace log */
-	&driver_attr_alslv,
-	&driver_attr_alsval,
-	&driver_attr_reg,
-};
-
-static int alspshub_create_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(alspshub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, alspshub_attr_list[idx]);
-		if (err) {
-			pr_err("driver_create_file (%s) = %d\n",
-				alspshub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int alspshub_delete_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(alspshub_attr_list));
-
-	if (!driver)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, alspshub_attr_list[idx]);
-
-	return err;
-}
-
-static void alspshub_init_done_work(struct work_struct *work)
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-	int err = 0;
-#ifndef MTK_OLD_FACTORY_CALIBRATION
-	int32_t cfg_data[2] = {0};
-#endif
-
-	if (atomic_read(&obj->scp_init_done) == 0) {
-		pr_err("wait for nvram to set calibration\n");
-		return;
-	}
-	if (atomic_xchg(&obj->first_ready_after_boot, 1) == 0)
-		return;
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = sensor_set_cmd_to_hub(ID_PROXIMITY,
-		CUST_ACTION_SET_CALI, &obj->ps_cali);
-	if (err < 0)
-		pr_err("sensor_set_cmd_to_hub fail,(ID: %d),(action: %d)\n",
-			ID_PROXIMITY, CUST_ACTION_SET_CALI);
-#else
-	spin_lock(&calibration_lock);
-	cfg_data[0] = atomic_read(&obj->ps_thd_val_high);
-	cfg_data[1] = atomic_read(&obj->ps_thd_val_low);
-	spin_unlock(&calibration_lock);
-	err = sensor_cfg_to_hub(ID_PROXIMITY,
-		(uint8_t *)cfg_data, sizeof(cfg_data));
-	if (err < 0)
-		pr_err("sensor_cfg_to_hub ps fail\n");
-
-	spin_lock(&calibration_lock);
-	cfg_data[0] = atomic_read(&obj->als_cali);
-	spin_unlock(&calibration_lock);
-	err = sensor_cfg_to_hub(ID_LIGHT,
-		(uint8_t *)cfg_data, sizeof(cfg_data));
-	if (err < 0)
-		pr_err("sensor_cfg_to_hub als fail\n");
-#endif
-}
-static int ps_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (!obj)
-		return 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = ps_flush_report();
-	else if (event->flush_action == DATA_ACTION &&
-			READ_ONCE(obj->ps_android_enable) == true) {
-		__pm_wakeup_event(obj->ps_wake_lock, msecs_to_jiffies(100));
-		err = ps_data_report_t(event->proximity_t.oneshot,
-			SENSOR_STATUS_ACCURACY_HIGH,
-			(int64_t)event->time_stamp);
-	} else if (event->flush_action == CALI_ACTION) {
-		spin_lock(&calibration_lock);
-		atomic_set(&obj->ps_thd_val_high, event->data[0]);
-		atomic_set(&obj->ps_thd_val_low, event->data[1]);
-		spin_unlock(&calibration_lock);
-		err = ps_cali_report(event->data);
-	}
-	return err;
-}
-static int als_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (!obj)
-		return 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = als_flush_report();
-	else if ((event->flush_action == DATA_ACTION) &&
-			READ_ONCE(obj->als_android_enable) == true)
-		err = als_data_report_t(event->light,
-				SENSOR_STATUS_ACCURACY_MEDIUM,
-				(int64_t)event->time_stamp);
-	else if (event->flush_action == CALI_ACTION) {
-		spin_lock(&calibration_lock);
-		atomic_set(&obj->als_cali, event->data[0]);
-		spin_unlock(&calibration_lock);
-		err = als_cali_report(event->data);
-	}
-	return err;
-}
-
-static int rgbw_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = rgbw_flush_report();
-	else if (event->flush_action == DATA_ACTION)
-		err = rgbw_data_report_t(event->data,
-			(int64_t)event->time_stamp);
-	return err;
-}
-
-static int alshub_factory_enable_sensor(bool enable_disable,
-				int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (enable_disable == true)
-		WRITE_ONCE(obj->als_factory_enable, true);
-	else
-		WRITE_ONCE(obj->als_factory_enable, false);
-
-	if (enable_disable == true) {
-		err = sensor_set_delay_to_hub(ID_LIGHT, sample_periods_ms);
-		if (err) {
-			pr_err("sensor_set_delay_to_hub failed!\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_LIGHT, enable_disable);
-	if (err) {
-		pr_err("sensor_enable_to_hub failed!\n");
-		return -1;
-	}
-	mutex_lock(&alspshub_mutex);
-	if (enable_disable)
-		set_bit(CMC_BIT_ALS, &obj->enable);
-	else
-		clear_bit(CMC_BIT_ALS, &obj->enable);
-	mutex_unlock(&alspshub_mutex);
-	return 0;
-}
-static int alshub_factory_get_data(int32_t *data)
-{
-	int err = 0;
-	struct data_unit_t data_t;
-
-	err = sensor_get_data_from_hub(ID_LIGHT, &data_t);
-	if (err < 0)
-		return -1;
-	*data = data_t.light;
-	return 0;
-}
-static int alshub_factory_get_raw_data(int32_t *data)
-{
-	return alshub_factory_get_data(data);
-}
-static int alshub_factory_enable_calibration(void)
-{
-	return sensor_calibration_to_hub(ID_LIGHT);
-}
-static int alshub_factory_clear_cali(void)
-{
-	return 0;
-}
-static int alshub_factory_set_cali(int32_t offset)
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-	int err = 0;
-	int32_t cfg_data;
-
-	cfg_data = offset;
-	err = sensor_cfg_to_hub(ID_LIGHT,
-		(uint8_t *)&cfg_data, sizeof(cfg_data));
-	if (err < 0)
-		pr_err("sensor_cfg_to_hub fail\n");
-	atomic_set(&obj->als_cali, offset);
-	als_cali_report(&cfg_data);
-
-	return err;
-
-}
-static int alshub_factory_get_cali(int32_t *offset)
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	*offset = atomic_read(&obj->als_cali);
-	return 0;
-}
-static int pshub_factory_enable_sensor(bool enable_disable,
-			int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (enable_disable == true) {
-		err = sensor_set_delay_to_hub(ID_PROXIMITY, sample_periods_ms);
-		if (err) {
-			pr_err("sensor_set_delay_to_hub failed!\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_PROXIMITY, enable_disable);
-	if (err) {
-		pr_err("sensor_enable_to_hub failed!\n");
-		return -1;
-	}
-	mutex_lock(&alspshub_mutex);
-	if (enable_disable)
-		set_bit(CMC_BIT_PS, &obj->enable);
-	else
-		clear_bit(CMC_BIT_PS, &obj->enable);
-	mutex_unlock(&alspshub_mutex);
-	return 0;
-}
-static int pshub_factory_get_data(int32_t *data)
-{
-	int err = 0, status = 0;
-
-	err = ps_get_data(data, &status);
-	if (err < 0)
-		return -1;
-	return 0;
-}
-static int pshub_factory_get_raw_data(int32_t *data)
-{
-	int err = 0;
-	struct data_unit_t data_t;
-
-	err = sensor_get_data_from_hub(ID_PROXIMITY, &data_t);
-	if (err < 0)
-		return -1;
-	*data = data_t.proximity_t.steps;
-	return 0;
-}
-static int pshub_factory_enable_calibration(void)
-{
-	return sensor_calibration_to_hub(ID_PROXIMITY);
-}
-static int pshub_factory_clear_cali(void)
-{
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	int err = 0;
-#endif
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	obj->ps_cali = 0;
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = sensor_set_cmd_to_hub(ID_PROXIMITY,
-			CUST_ACTION_RESET_CALI, &obj->ps_cali);
-	if (err < 0) {
-		pr_err("sensor_set_cmd_to_hub fail, (ID: %d),(action: %d)\n",
-			ID_PROXIMITY, CUST_ACTION_RESET_CALI);
-		return -1;
-	}
-#endif
-	return 0;
-}
-static int pshub_factory_set_cali(int32_t offset)
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	obj->ps_cali = offset;
-	return 0;
-}
-static int pshub_factory_get_cali(int32_t *offset)
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	*offset = obj->ps_cali;
-	return 0;
-}
-static int pshub_factory_set_threshold(int32_t threshold[2])
-{
-	int err = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-#ifndef MTK_OLD_FACTORY_CALIBRATION
-	int32_t cfg_data[2] = {0};
-#endif
-	if (threshold[0] < threshold[1] || threshold[0] <= 0 ||
-		threshold[1] <= 0) {
-		pr_err("PS set threshold fail! invalid value:[%d, %d]\n",
-			threshold[0], threshold[1]);
-		return -1;
-	}
-
-	spin_lock(&calibration_lock);
-	atomic_set(&obj->ps_thd_val_high, (threshold[0] + obj->ps_cali));
-	atomic_set(&obj->ps_thd_val_low, (threshold[1] + obj->ps_cali));
-	spin_unlock(&calibration_lock);
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = sensor_set_cmd_to_hub(ID_PROXIMITY,
-		CUST_ACTION_SET_PS_THRESHOLD, threshold);
-	if (err < 0)
-		pr_err("sensor_set_cmd_to_hub fail, (ID:%d),(action:%d)\n",
-			ID_PROXIMITY, CUST_ACTION_SET_PS_THRESHOLD);
-#else
-	spin_lock(&calibration_lock);
-	cfg_data[0] = atomic_read(&obj->ps_thd_val_high);
-	cfg_data[1] = atomic_read(&obj->ps_thd_val_low);
-	spin_unlock(&calibration_lock);
-	err = sensor_cfg_to_hub(ID_PROXIMITY,
-		(uint8_t *)cfg_data, sizeof(cfg_data));
-	if (err < 0)
-		pr_err("sensor_cfg_to_hub fail\n");
-
-	ps_cali_report(cfg_data);
-#endif
-	return err;
-}
-
-static int pshub_factory_get_threshold(int32_t threshold[2])
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	spin_lock(&calibration_lock);
-	threshold[0] = atomic_read(&obj->ps_thd_val_high) - obj->ps_cali;
-	threshold[1] = atomic_read(&obj->ps_thd_val_low) - obj->ps_cali;
-	spin_unlock(&calibration_lock);
-	return 0;
-}
-
-static struct alsps_factory_fops alspshub_factory_fops = {
-	.als_enable_sensor = alshub_factory_enable_sensor,
-	.als_get_data = alshub_factory_get_data,
-	.als_get_raw_data = alshub_factory_get_raw_data,
-	.als_enable_calibration = alshub_factory_enable_calibration,
-	.als_clear_cali = alshub_factory_clear_cali,
-	.als_set_cali = alshub_factory_set_cali,
-	.als_get_cali = alshub_factory_get_cali,
-
-	.ps_enable_sensor = pshub_factory_enable_sensor,
-	.ps_get_data = pshub_factory_get_data,
-	.ps_get_raw_data = pshub_factory_get_raw_data,
-	.ps_enable_calibration = pshub_factory_enable_calibration,
-	.ps_clear_cali = pshub_factory_clear_cali,
-	.ps_set_cali = pshub_factory_set_cali,
-	.ps_get_cali = pshub_factory_get_cali,
-	.ps_set_threshold = pshub_factory_set_threshold,
-	.ps_get_threshold = pshub_factory_get_threshold,
-};
-
-static struct alsps_factory_public alspshub_factory_device = {
-	.gain = 1,
-	.sensitivity = 1,
-	.fops = &alspshub_factory_fops,
-};
-static int als_open_report_data(int open)
-{
-	return 0;
-}
-
-
-static int als_enable_nodata(int en)
-{
-	int res = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	pr_debug("obj_ipi_data als enable value = %d\n", en);
-
-	if (en == true)
-		WRITE_ONCE(obj->als_android_enable, true);
-	else
-		WRITE_ONCE(obj->als_android_enable, false);
-
-	res = sensor_enable_to_hub(ID_LIGHT, en);
-	if (res < 0) {
-		pr_err("%s is failed!!\n", __func__);
-		return -1;
-	}
-
-	mutex_lock(&alspshub_mutex);
-	if (en)
-		set_bit(CMC_BIT_ALS, &obj_ipi_data->enable);
-	else
-		clear_bit(CMC_BIT_ALS, &obj_ipi_data->enable);
-	mutex_unlock(&alspshub_mutex);
-	return 0;
-}
-
-static int als_set_delay(u64 ns)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	int err = 0;
-	unsigned int delayms = 0;
-
-	delayms = (unsigned int)ns / 1000 / 1000;
-	err = sensor_set_delay_to_hub(ID_LIGHT, delayms);
-	if (err) {
-		pr_err("%s fail!\n", __func__);
-		return err;
-	}
-	pr_debug("%s (%d)\n", __func__, delayms);
-	return 0;
-#elif defined CONFIG_NANOHUB
-	return 0;
-#else
-	return 0;
-#endif
-}
-static int als_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	als_set_delay(samplingPeriodNs);
-#endif
-	return sensor_batch_to_hub(ID_LIGHT, flag,
-		samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int als_flush(void)
-{
-	return sensor_flush_to_hub(ID_LIGHT);
-}
-
-static int als_set_cali(uint8_t *data, uint8_t count)
-{
-	int32_t *buf = (int32_t *)data;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	spin_lock(&calibration_lock);
-	atomic_set(&obj->als_cali, buf[0]);
-	spin_unlock(&calibration_lock);
-	return sensor_cfg_to_hub(ID_LIGHT, data, count);
-}
-
-static int rgbw_enable(int en)
-{
-	int res = 0;
-
-	res = sensor_enable_to_hub(ID_RGBW, en);
-	if (res < 0) {
-		pr_err("%s is failed!!\n", __func__);
-		return -1;
-	}
-	return 0;
-}
-
-static int rgbw_batch(int flag, int64_t samplingPeriodNs,
-		int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_RGBW,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int rgbw_flush(void)
-{
-	return sensor_flush_to_hub(ID_RGBW);
-}
-
-static int als_get_data(int *value, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_LIGHT, &data);
-	if (err) {
-		pr_err("sensor_get_data_from_hub fail!\n");
-	} else {
-		time_stamp = data.time_stamp;
-		*value = data.light;
-		*status = SENSOR_STATUS_ACCURACY_MEDIUM;
-	}
-
-	if (atomic_read(&obj_ipi_data->trace) & CMC_TRC_PS_DATA)
-		pr_debug("value = %d\n", *value);
-	return 0;
-}
-
-static int ps_open_report_data(int open)
-{
-	return 0;
-}
-
-static int ps_enable_nodata(int en)
-{
-	int res = 0;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	pr_debug("obj_ipi_data als enable value = %d\n", en);
-	if (en == true)
-		WRITE_ONCE(obj->ps_android_enable, true);
-	else
-		WRITE_ONCE(obj->ps_android_enable, false);
-
-	res = sensor_enable_to_hub(ID_PROXIMITY, en);
-	if (res < 0) {
-		pr_err("als_enable_nodata is failed!!\n");
-		return -1;
-	}
-
-	mutex_lock(&alspshub_mutex);
-	if (en)
-		set_bit(CMC_BIT_PS, &obj_ipi_data->enable);
-	else
-		clear_bit(CMC_BIT_PS, &obj_ipi_data->enable);
-	mutex_unlock(&alspshub_mutex);
-
-
-	return 0;
-
-}
-
-static int ps_set_delay(u64 ns)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	int err = 0;
-	unsigned int delayms = 0;
-
-	delayms = (unsigned int)ns / 1000 / 1000;
-	err = sensor_set_delay_to_hub(ID_PROXIMITY, delayms);
-	if (err < 0) {
-		pr_err("%s fail!\n", __func__);
-		return err;
-	}
-
-	pr_debug("%s (%d)\n", __func__, delayms);
-	return 0;
-#elif defined CONFIG_NANOHUB
-	return 0;
-#else
-	return 0;
-#endif
-}
-static int ps_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	ps_set_delay(samplingPeriodNs);
-#endif
-	return sensor_batch_to_hub(ID_PROXIMITY, flag,
-		samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int ps_flush(void)
-{
-	return sensor_flush_to_hub(ID_PROXIMITY);
-}
-
-static int ps_get_data(int *value, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_PROXIMITY, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!\n");
-		*value = -1;
-		err = -1;
-	} else {
-		time_stamp = data.time_stamp;
-		*value = data.proximity_t.oneshot;
-		*status = SENSOR_STATUS_ACCURACY_MEDIUM;
-	}
-
-	if (atomic_read(&obj_ipi_data->trace) & CMC_TRC_PS_DATA)
-		pr_debug("value = %d\n", *value);
-
-	return err;
-}
-
-static int ps_set_cali(uint8_t *data, uint8_t count)
-{
-	int32_t *buf = (int32_t *)data;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	spin_lock(&calibration_lock);
-	atomic_set(&obj->ps_thd_val_high, buf[0]);
-	atomic_set(&obj->ps_thd_val_low, buf[1]);
-	spin_unlock(&calibration_lock);
-	return sensor_cfg_to_hub(ID_PROXIMITY, data, count);
-}
-
-static int scp_ready_event(uint8_t event, void *ptr)
-{
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	switch (event) {
-	case SENSOR_POWER_UP:
-	    atomic_set(&obj->scp_init_done, 1);
-		schedule_work(&obj->init_done_work);
-		break;
-	case SENSOR_POWER_DOWN:
-	    atomic_set(&obj->scp_init_done, 0);
-		break;
-	}
-	return 0;
-}
-
-static struct scp_power_monitor scp_ready_notifier = {
-	.name = "alsps",
-	.notifier_call = scp_ready_event,
-};
-
-static int alspshub_probe(struct platform_device *pdev)
-{
-	struct alspshub_ipi_data *obj;
-	struct platform_driver *paddr =
-			alspshub_init_info.platform_diver_addr;
-
-	int err = 0;
-	struct als_control_path als_ctl = { 0 };
-	struct als_data_path als_data = { 0 };
-	struct ps_control_path ps_ctl = { 0 };
-	struct ps_data_path ps_data = { 0 };
-
-	pr_debug("%s\n", __func__);
-	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	if (!obj) {
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	memset(obj, 0, sizeof(*obj));
-	obj_ipi_data = obj;
-
-	INIT_WORK(&obj->init_done_work, alspshub_init_done_work);
-
-	platform_set_drvdata(pdev, obj);
-
-
-	atomic_set(&obj->als_suspend, 0);
-	atomic_set(&obj->scp_init_done, 0);
-	atomic_set(&obj->first_ready_after_boot, 0);
-
-	obj->enable = 0;
-	obj->pending_intr = 0;
-	obj->ps_cali = 0;
-	atomic_set(&obj->ps_thd_val_low, 21);
-	atomic_set(&obj->ps_thd_val_high, 28);
-	WRITE_ONCE(obj->als_factory_enable, false);
-	WRITE_ONCE(obj->als_android_enable, false);
-	WRITE_ONCE(obj->ps_factory_enable, false);
-	WRITE_ONCE(obj->ps_android_enable, false);
-
-	clear_bit(CMC_BIT_ALS, &obj->enable);
-	clear_bit(CMC_BIT_PS, &obj->enable);
-	scp_power_monitor_register(&scp_ready_notifier);
-	err = scp_sensorHub_data_registration(ID_PROXIMITY, ps_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = scp_sensorHub_data_registration(ID_LIGHT, als_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = scp_sensorHub_data_registration(ID_RGBW, rgbw_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = alsps_factory_device_register(&alspshub_factory_device);
-	if (err) {
-		pr_err("alsps_factory_device_register register failed\n");
-		goto exit_kfree;
-	}
-	pr_debug("alspshub_misc_device misc_register OK!\n");
-	als_ctl.is_use_common_factory = false;
-	ps_ctl.is_use_common_factory = false;
-	err = alspshub_create_attr(&paddr->driver);
-	if (err) {
-		pr_err("create attribute err = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-	als_ctl.open_report_data = als_open_report_data;
-	als_ctl.enable_nodata = als_enable_nodata;
-	als_ctl.set_delay = als_set_delay;
-	als_ctl.batch = als_batch;
-	als_ctl.flush = als_flush;
-	als_ctl.set_cali = als_set_cali;
-	als_ctl.rgbw_enable = rgbw_enable;
-	als_ctl.rgbw_batch = rgbw_batch;
-	als_ctl.rgbw_flush = rgbw_flush;
-	als_ctl.is_report_input_direct = false;
-
-	als_ctl.is_support_batch = false;
-
-	err = als_register_control_path(&als_ctl);
-	if (err) {
-		pr_err("register fail = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	als_data.get_data = als_get_data;
-	als_data.vender_div = 100;
-	err = als_register_data_path(&als_data);
-	if (err) {
-		pr_err("tregister fail = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	ps_ctl.open_report_data = ps_open_report_data;
-	ps_ctl.enable_nodata = ps_enable_nodata;
-	ps_ctl.set_delay = ps_set_delay;
-	ps_ctl.batch = ps_batch;
-	ps_ctl.flush = ps_flush;
-	ps_ctl.set_cali = ps_set_cali;
-	ps_ctl.is_report_input_direct = false;
-
-	ps_ctl.is_support_batch = false;
-
-	err = ps_register_control_path(&ps_ctl);
-	if (err) {
-		pr_err("register fail = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	ps_data.get_data = ps_get_data;
-	ps_data.vender_div = 100;
-	err = ps_register_data_path(&ps_data);
-	if (err) {
-		pr_err("tregister fail = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-	obj->ps_wake_lock = wakeup_source_register(NULL, "ps_wake_lock");
-	if (!obj->ps_wake_lock) {
-		pr_err("wakeup source init fail\n");
-		err = -ENOMEM;
-		goto exit_create_attr_failed;
-	}
-
-	alspshub_init_flag = 0;
-	pr_debug("%s: OK\n", __func__);
-	return 0;
-
-exit_create_attr_failed:
-	alspshub_delete_attr(&(alspshub_init_info.platform_diver_addr->driver));
-exit_kfree:
-	kfree(obj);
-	obj_ipi_data = NULL;
-exit:
-	pr_err("%s: err = %d\n", __func__, err);
-	alspshub_init_flag = -1;
-	return err;
-}
-
-static int alspshub_remove(struct platform_device *pdev)
-{
-	int err = 0;
-	struct platform_driver *paddr =
-			alspshub_init_info.platform_diver_addr;
-	struct alspshub_ipi_data *obj = obj_ipi_data;
-
-	if (obj)
-		wakeup_source_unregister(obj->ps_wake_lock);
-	err = alspshub_delete_attr(&paddr->driver);
-	if (err)
-		pr_err("alspshub_delete_attr fail: %d\n", err);
-	alsps_factory_device_deregister(&alspshub_factory_device);
-	kfree(platform_get_drvdata(pdev));
-	return 0;
-
-}
-
-static int alspshub_suspend(struct platform_device *pdev, pm_message_t msg)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int alspshub_resume(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-static struct platform_device alspshub_device = {
-	.name = ALSPSHUB_DEV_NAME,
-	.id = -1,
-};
-
-static struct platform_driver alspshub_driver = {
-	.probe = alspshub_probe,
-	.remove = alspshub_remove,
-	.suspend = alspshub_suspend,
-	.resume = alspshub_resume,
-	.driver = {
-		.name = ALSPSHUB_DEV_NAME,
-	},
-};
-
-static int alspshub_local_init(void)
-{
-
-	if (platform_driver_register(&alspshub_driver)) {
-		pr_err("add driver error\n");
-		return -1;
-	}
-	if (-1 == alspshub_init_flag)
-		return -1;
-	return 0;
-}
-static int alspshub_local_remove(void)
-{
-
-	platform_driver_unregister(&alspshub_driver);
-	return 0;
-}
-
-static int __init alspshub_init(void)
-{
-	if (platform_device_register(&alspshub_device)) {
-		pr_err("alsps platform device error\n");
-		return -1;
-	}
-	alsps_driver_add(&alspshub_init_info);
-	return 0;
-}
-
-static void __exit alspshub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(alspshub_init);
-module_exit(alspshub_exit);
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
-MODULE_DESCRIPTION("alspshub driver");
-MODULE_LICENSE("GPL");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/alspshub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/alspshub.h
deleted file mode 100644
index bd7a6c5..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/alspshub/alspshub.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-/*
- * Definitions for ALSPS als/ps sensor chip.
- */
-#ifndef __ALSPSHUB_H__
-#define __ALSPSHUB_H__
-
-#include <linux/ioctl.h>
-
-
-/*ALSPS related driver tag macro*/
-#define ALSPS_SUCCESS						0
-#define ALSPS_ERR_I2C						-1
-#define ALSPS_ERR_STATUS					-3
-#define ALSPS_ERR_SETUP_FAILURE				-4
-#define ALSPS_ERR_GETGSENSORDATA			-5
-#define ALSPS_ERR_IDENTIFICATION			-6
-
-/*----------------------------------------------------------------------------*/
-enum ALSPS_NOTIFY_TYPE {
-	ALSPS_NOTIFY_PROXIMITY_CHANGE = 0,
-};
-
-#endif
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/aal_control.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/aal_control.h
deleted file mode 100644
index 02e645d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/aal_control.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __AAL_CONTROL_H__
-#define __AAL_CONTROL_H__
-
-#define AAL_TAG                  "[ALS/AAL]"
-
-extern int aal_use;
-int __init AAL_init(void);
-void __exit AAL_exit(void);
-
-#endif
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/alsps.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/alsps.h
deleted file mode 100644
index 69a40a6..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/alsps.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __ALSPS_H__
-#define __ALSPS_H__
-
-#include <linux/atomic.h>
-#include <linux/i2c.h>
-#include <linux/io.h>
-#include <linux/irq.h>
-#include <linux/kobject.h>
-#include <linux/sched.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-//#include <linux/wakelock.h>
-#include "alsps_factory.h"
-#include "sensor_attr.h"
-#include "sensor_event.h"
-#include <hwmsensor.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/poll.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-#include <sensors_io.h>
-
-#define ALSPS_TAG "<ALS/PS> "
-
-#define OP_ALSPS_DELAY 0X01
-#define OP_ALSPS_ENABLE 0X02
-#define OP_ALSPS_GET_DATA 0X04
-
-#define ALSPS_INVALID_VALUE -1
-
-#define EVENT_TYPE_ALS_VALUE ABS_X
-#define EVENT_TYPE_PS_VALUE REL_Z
-#define EVENT_TYPE_ALS_STATUS ABS_WHEEL
-#define EVENT_TYPE_PS_STATUS REL_Y
-
-#define ALSPS_VALUE_MAX (32767)
-#define ALSPS_VALUE_MIN (-32768)
-#define ALSPS_STATUS_MIN (0)
-#define ALSPS_STATUS_MAX (64)
-#define ALSPS_DIV_MAX (32767)
-#define ALSPS_DIV_MIN (1)
-
-#define MAX_CHOOSE_ALSPS_NUM 5
-
-struct als_control_path {
-	int (*open_report_data)(int open); /* open data rerport to HAL */
-	int (*enable_nodata)(int en); /* only enable not report event to HAL */
-	int (*set_delay)(u64 delay);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		int64_t maxBatchReportLatencyNs);
-	int (*flush)(void);	    /* open data rerport to HAL */
-	int (*set_cali)(uint8_t *data, uint8_t count);
-	int (*rgbw_enable)(int en);
-	int (*rgbw_batch)(int flag, int64_t samplingPeriodNs,
-		int64_t maxBatchReportLatencyNs);
-	int (*rgbw_flush)(void);
-	int (*access_data_fifo)(void);
-	bool is_report_input_direct;
-	bool is_support_batch;
-	bool is_polling_mode;
-	bool is_use_common_factory;
-};
-
-struct ps_control_path {
-	int (*open_report_data)(int open); /* open data rerport to HAL */
-	int (*enable_nodata)(int en); /* only enable not report event to HAL */
-	int (*set_delay)(u64 delay);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		     int64_t maxBatchReportLatencyNs);
-	int (*flush)(void);	    /* open data rerport to HAL */
-	int (*access_data_fifo)(void); /* version2.used for flush operate */
-	int (*ps_calibration)(int type, int value);
-	int (*set_cali)(uint8_t *data, uint8_t count);
-	bool is_report_input_direct;
-	bool is_support_batch; /* version2.used for batch mode support flag */
-	bool is_polling_mode;
-	bool is_use_common_factory;
-};
-
-struct als_data_path {
-	int (*get_data)(int *als_value, int *status);
-	int (*als_get_raw_data)(int *als_value);
-	int vender_div;
-};
-
-struct ps_data_path {
-	int (*get_data)(int *ps_value, int *status);
-	int (*ps_get_raw_data)(int *ps_value);
-	int vender_div;
-};
-
-struct alsps_init_info {
-	char *name;
-	int (*init)(void);
-	int (*uninit)(void);
-	struct platform_driver *platform_diver_addr;
-};
-
-struct alsps_data {
-	struct hwm_sensor_data als_data;
-	struct hwm_sensor_data ps_data;
-	int data_updata;
-};
-
-struct alsps_drv_obj {
-	void *self;
-	int polling;
-	int (*alsps_operate)(void *self, uint32_t command, void *buff_in,
-			     int size_in, void *buff_out, int size_out,
-			     int *actualout);
-};
-
-struct alsps_context {
-	struct input_dev *idev;
-	struct sensor_attr_t als_mdev;
-	struct sensor_attr_t ps_mdev;
-	struct work_struct report_ps;
-	struct work_struct report_als;
-	struct mutex alsps_op_mutex;
-	struct timer_list timer_als; /*als polling timer */
-	struct timer_list timer_ps;  /* ps polling timer */
-
-	atomic_t trace;
-	atomic_t delay_als; /*als polling period for reporting input event*/
-	atomic_t delay_ps;  /*ps polling period for reporting input event*/
-	atomic_t wake;      /*user-space request to wake-up, used with stop*/
-
-	atomic_t early_suspend;
-
-	struct alsps_data drv_data;
-	struct als_control_path als_ctl;
-	struct als_data_path als_data;
-	struct ps_control_path ps_ctl;
-	struct ps_data_path ps_data;
-	/* Active, but HAL don't need data sensor.such as orientation need */
-	bool is_als_active_nodata;
-	bool is_als_active_data;   /* Active and HAL need data . */
-	/* Active, but HAL don't need data sensor.such as orientation need */
-	bool is_ps_active_nodata;
-	bool is_ps_active_data;    /* Active and HAL need data . */
-
-	bool is_als_first_data_after_enable;
-	bool is_ps_first_data_after_enable;
-	bool is_als_polling_run;
-	bool is_ps_polling_run;
-	/* v2.judging whether sensor is in batch mode */
-	bool is_als_batch_enable;
-	bool is_ps_batch_enable;
-	bool is_get_valid_ps_data_after_enable;
-	bool is_get_valid_als_data_after_enable;
-	int als_power;
-	int rgbw_power;
-	int als_enable;
-	int rgbw_enable;
-	int64_t als_delay_ns;
-	int64_t als_latency_ns;
-	int64_t rgbw_delay_ns;
-	int64_t rgbw_latency_ns;
-	int ps_power;
-	int ps_enable;
-	int64_t ps_delay_ns;
-	int64_t ps_latency_ns;
-};
-
-/* AAL Functions */
-extern int alsps_aal_enable(int enable);
-extern int alsps_aal_get_status(void);
-extern int alsps_aal_get_data(void);
-
-/* for auto detect */
-extern int alsps_driver_add(struct alsps_init_info *obj);
-extern int ps_report_interrupt_data(int value);
-extern int ps_flush_report(void);
-extern int als_data_report(int value, int status);
-extern int als_data_report_t(int value, int status, int64_t time_stamp);
-extern int ps_cali_report(int *value);
-extern int als_cali_report(int *value);
-extern int als_flush_report(void);
-extern int rgbw_data_report(int value[4]);
-extern int rgbw_data_report_t(int value[4], int64_t time_stamp);
-extern int rgbw_flush_report(void);
-extern int als_register_control_path(struct als_control_path *ctl);
-extern int als_register_data_path(struct als_data_path *data);
-extern int ps_data_report(int value, int status);
-extern int ps_data_report_t(int value, int status, int64_t time_stamp);
-extern int ps_register_control_path(struct ps_control_path *ctl);
-extern int ps_register_data_path(struct ps_data_path *data);
-extern struct platform_device *get_alsps_platformdev(void);
-extern int alsps_probe(void);
-extern int alsps_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/alsps_factory.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/alsps_factory.h
deleted file mode 100644
index ee776a0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/alsps_factory.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __ALSPS_FACTORY_H__
-#define __ALSPS_FACTORY_H__
-
-#include <linux/atomic.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/kobject.h>
-#include <linux/miscdevice.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-#include <linux/workqueue.h>
-
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-#include <sensors_io.h>
-
-/*#include <mach/mt_typedefs.h>*/
-/*#include <mach/mt_gpio.h>*/
-/*#include <mach/mt_pm_ldo.h>*/
-
-#include "alsps.h"
-#include "cust_alsps.h"
-
-struct alsps_factory_fops {
-	int (*als_enable_sensor)(bool enable_disable,
-				 int64_t sample_periods_ms);
-	int (*als_get_data)(int32_t *data);
-	int (*als_get_raw_data)(int32_t *data);
-	int (*als_enable_calibration)(void);
-	int (*als_clear_cali)(void);
-	int (*als_set_cali)(int32_t offset);
-	int (*als_get_cali)(int32_t *offset);
-
-	int (*ps_enable_sensor)(bool enable_disable, int64_t sample_periods_ms);
-	int (*ps_get_data)(int32_t *data);
-	int (*ps_get_raw_data)(int32_t *data);
-	int (*ps_enable_calibration)(void);
-	int (*ps_clear_cali)(void);
-	int (*ps_set_cali)(int32_t offset);
-	int (*ps_get_cali)(int32_t *offset);
-	int (*ps_set_threshold)(int32_t threshold[2]);
-	int (*ps_get_threshold)(int32_t threshold[2]);
-};
-
-struct alsps_factory_public {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct alsps_factory_fops *fops;
-};
-int alsps_factory_device_register(struct alsps_factory_public *dev);
-int alsps_factory_device_deregister(struct alsps_factory_public *dev);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/cust_alsps.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/cust_alsps.h
deleted file mode 100644
index 92d14dc..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/alsps/inc/cust_alsps.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __CUST_ALSPS_H__
-#define __CUST_ALSPS_H__
-
-#include <linux/types.h>
-
-#define C_CUST_ALS_LEVEL 16
-#define C_CUST_I2C_ADDR_NUM 4
-
-#define MAX_THRESHOLD_HIGH 0xffff
-#define MIN_THRESHOLD_LOW 0x0
-
-struct alsps_hw {
-	int i2c_num;	  /*!< the i2c bus used by ALS/PS */
-	int power_id;	 /*!< the VDD power id of the als chip */
-	int power_vol;	/*!< the VDD power voltage of the als chip */
-	int polling_mode;     /*!< 1: polling mode ; 0:interrupt mode*/
-	int polling_mode_ps;  /*!< 1: polling mode ; 0:interrupt mode*/
-	int polling_mode_als; /*!< 1: polling mode ; 0:interrupt mode*/
-	/*!< i2c address list, some chip willhave multiple address*/
-	unsigned char i2c_addr[C_CUST_I2C_ADDR_NUM];
-	/*!< (C_CUST_ALS_LEVEL-1) levels divides all range into C_CUST_ALS_LEVEL
-	 * levels
-	 */
-	unsigned int als_level[C_CUST_ALS_LEVEL - 1];
-	/*!< the value reported in each level */
-	unsigned int als_value[C_CUST_ALS_LEVEL];
-	unsigned int ps_threshold;    /*!< the threshold of proximity sensor */
-	unsigned int als_window_loss; /*!< the window loss  */
-	unsigned int ps_threshold_high;
-	unsigned int ps_threshold_low;
-	unsigned int als_threshold_high;
-	unsigned int als_threshold_low;
-	int als_power_vio_id;  /*!< the VIO power id of the als chip */
-	int als_power_vio_vol; /*!< the VIO power voltage of the als chip */
-	int ps_power_vdd_id;   /*!< the VDD power id of the ps chip */
-	int ps_power_vdd_vol;  /*!< the VDD power voltage of the ps chip */
-	int ps_power_vio_id;   /*!< the VIO power id of the ps chip */
-	int ps_power_vio_vol;  /*!< the VIO power voltage of the ps chip */
-	/*< 1: disable ldo low power mode when psensor enabled ; 0: no action*/
-	int power_lp_mode_ctrl;
-	bool is_batch_supported_ps;
-	bool is_batch_supported_als;
-};
-
-int get_alsps_dts_func(struct device_node *node, struct alsps_hw *hw);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/Kconfig
deleted file mode 100644
index 5aa3de4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/Kconfig
+++ /dev/null
@@ -1,11 +0,0 @@
-
-config CUSTOM_KERNEL_BAROMETER
-	bool "CUSTOM KERNEL BAROMETER Config"
-	help
-	  one load to support different barometer sensor.
-	  This feature Option is used for projects which using more than one
-	  barometer, and be auto detected by setting this option to yes
-	  If unsure, say N.
-
-source "drivers/misc/mediatek/sensors-1.0/barometer/barohub/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/barometer/BMP280-new/Kconfig"
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/Makefile
deleted file mode 100644
index 6d26cb2..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/Makefile
+++ /dev/null
@@ -1,23 +0,0 @@
-#
-# Copyright (C) 2015 MediaTek Inc.
-#
-# 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.
-#
-# 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.
-#
-
-# In case the platform does NOT support this type of sensors
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)  += baro_common.o
-baro_common-$(CONFIG_MTK_SENSOR_SUPPORT) += barometer.o barometer_factory.o
-
-obj-$(CONFIG_MTK_BAROHUB) += barohub/
-ifneq ($(CONFIG_MTK_BAROHUB),y)
-#obj-$(CONFIG_MTK_BMP280_NEW) += BMP280-new/
-endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/Kconfig
deleted file mode 100644
index 93118c6..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_BAROHUB
-	bool "barohub for MediaTek package"
-	help
-	  It support different barohub sensor.
-	  If this option is set,
-	  it will support
-	  sensorhub gyroscope.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/Makefile
deleted file mode 100644
index 61728fd..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/barometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) += barohub.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/barohub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/barohub.c
deleted file mode 100644
index bf34f95..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/barohub.c
+++ /dev/null
@@ -1,559 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-/*
- * History: V1.0 --- [2013.03.14]Driver creation
- *          V1.1 --- [2013.07.03]Re-write I2C function to fix the bug that
- *                               i2c access error on MT6589 platform.
- *          V1.2 --- [2013.07.04]Add self test function.
- *          V1.3 --- [2013.07.04]Support new chip id 0x57 and 0x58.
- */
-
-#define pr_fmt(fmt) "[barometer] " fmt
-
-#include "barohub.h"
-#include <barometer.h>
-#include <hwmsensor.h>
-#include <SCP_sensorHub.h>
-#include "SCP_power_monitor.h"
-
-/* trace */
-enum BAR_TRC {
-	BAR_TRC_READ = 0x01,
-	BAR_TRC_RAWDATA = 0x02,
-	BAR_TRC_IOCTL = 0x04,
-	BAR_TRC_FILTER = 0x08,
-};
-
-/* barohub i2c client data */
-struct barohub_ipi_data {
-	/* sensor info */
-	atomic_t trace;
-	atomic_t suspend;
-	struct work_struct init_done_work;
-	atomic_t scp_init_done;
-	bool factory_enable;
-	bool android_enable;
-};
-
-static struct barohub_ipi_data *obj_ipi_data;
-static int barohub_local_init(void);
-static int barohub_local_remove(void);
-static int barohub_init_flag = -1;
-static struct baro_init_info barohub_init_info = {
-	.name = "barohub",
-	.init = barohub_local_init,
-	.uninit = barohub_local_remove,
-};
-
-static int barohub_set_powermode(bool enable)
-{
-	int err = 0;
-
-	err = sensor_enable_to_hub(ID_PRESSURE, enable);
-	if (err < 0)
-		pr_err("SCP_sensorHub_req_send fail!\n");
-
-	return err;
-}
-
-/*
- *get compensated pressure
- *unit: hectopascal(hPa)
- */
-static int barohub_get_pressure(char *buf, int bufsize)
-{
-	struct barohub_ipi_data *obj = obj_ipi_data;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-	int pressure;
-	int err = 0;
-
-	if (atomic_read(&obj->suspend))
-		return -3;
-
-	if (buf == NULL)
-		return -1;
-	err = sensor_get_data_from_hub(ID_PRESSURE, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!\n");
-		return err;
-	}
-
-	time_stamp		= data.time_stamp;
-	pressure		= data.pressure_t.pressure;
-	sprintf(buf, "%08x", pressure);
-	if (atomic_read(&obj->trace) & BAR_TRC_IOCTL)
-		pr_debug("compensated pressure value: %s\n", buf);
-
-	return err;
-}
-static ssize_t sensordata_show(struct device_driver *ddri, char *buf)
-{
-	char strbuf[BAROHUB_BUFSIZE] = {0};
-	int err = 0;
-
-	err = barohub_set_powermode(true);
-	if (err < 0) {
-		pr_err("barohub_set_powermode fail!!\n");
-		return 0;
-	}
-	err = barohub_get_pressure(strbuf, BAROHUB_BUFSIZE);
-	if (err < 0) {
-		pr_err("barohub_set_powermode fail!!\n");
-		return 0;
-	}
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-static ssize_t trace_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t res = 0;
-	struct barohub_ipi_data *obj = obj_ipi_data;
-
-	if (obj == NULL) {
-		pr_err("pointer is null\n");
-		return 0;
-	}
-
-	res = snprintf(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&obj->trace));
-	return res;
-}
-
-static ssize_t trace_store(struct device_driver *ddri,
-			const char *buf, size_t count)
-{
-	struct barohub_ipi_data *obj = obj_ipi_data;
-	int trace = 0, res = 0;
-
-	if (obj == NULL) {
-		pr_err("obj is null\n");
-		return 0;
-	}
-	res = kstrtoint(buf, 10, &trace);
-	if (res != 0) {
-		pr_err("invalid content: '%s', length = %d\n",
-							buf, (int)count);
-		return count;
-	}
-	atomic_set(&obj->trace, trace);
-	res = sensor_set_cmd_to_hub(ID_PRESSURE, CUST_ACTION_SET_TRACE, &trace);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID: %d),(action: %d)\n",
-			ID_PRESSURE, CUST_ACTION_SET_TRACE);
-		return 0;
-	}
-	return count;
-}
-static DRIVER_ATTR_RO(sensordata);
-static DRIVER_ATTR_RW(trace);
-
-static struct driver_attribute *barohub_attr_list[] = {
-	&driver_attr_sensordata,	/* dump sensor data */
-	&driver_attr_trace,	/* trace log */
-};
-
-static int barohub_create_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(barohub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, barohub_attr_list[idx]);
-		if (err) {
-			pr_err("driver_create_file (%s) = %d\n",
-				barohub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int barohub_delete_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(barohub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, barohub_attr_list[idx]);
-
-	return err;
-}
-
-static int baro_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct barohub_ipi_data *obj = obj_ipi_data;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = baro_flush_report();
-	else if (event->flush_action == DATA_ACTION &&
-			READ_ONCE(obj->android_enable) == true)
-		err = baro_data_report(event->pressure_t.pressure, 2,
-			(int64_t)event->time_stamp);
-	return err;
-}
-static int barohub_factory_enable_sensor(bool enabledisable,
-				int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct barohub_ipi_data *obj = obj_ipi_data;
-
-	if (enabledisable == true)
-		WRITE_ONCE(obj->factory_enable, true);
-	else
-		WRITE_ONCE(obj->factory_enable, false);
-
-	if (enabledisable == true) {
-		err = sensor_set_delay_to_hub(ID_PRESSURE, sample_periods_ms);
-		if (err) {
-			pr_err("sensor_set_delay_to_hub failed!\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_PRESSURE, enabledisable);
-	if (err) {
-		pr_err("sensor_enable_to_hub failed!\n");
-		return -1;
-	}
-	return 0;
-}
-static int barohub_factory_get_data(int32_t *data)
-{
-	int err = 0;
-	char strbuf[BAROHUB_BUFSIZE];
-
-	err = barohub_get_pressure(strbuf, BAROHUB_BUFSIZE);
-	if (err < 0) {
-		pr_err("barohub_get_pressure fail\n");
-		return -1;
-	}
-	err = kstrtoint(strbuf, 16, data);
-	if (err != 0)
-		pr_debug("kstrtoint fail\n");
-
-	return 0;
-}
-static int barohub_factory_get_raw_data(int32_t *data)
-{
-	return 0;
-}
-static int barohub_factory_enable_calibration(void)
-{
-	return sensor_calibration_to_hub(ID_PRESSURE);
-}
-static int barohub_factory_clear_cali(void)
-{
-	return 0;
-}
-static int barohub_factory_set_cali(int32_t offset)
-{
-	return 0;
-}
-static int barohub_factory_get_cali(int32_t *offset)
-{
-	return 0;
-}
-static int barohub_factory_do_self_test(void)
-{
-	return 0;
-}
-
-static struct baro_factory_fops barohub_factory_fops = {
-	.enable_sensor = barohub_factory_enable_sensor,
-	.get_data = barohub_factory_get_data,
-	.get_raw_data = barohub_factory_get_raw_data,
-	.enable_calibration = barohub_factory_enable_calibration,
-	.clear_cali = barohub_factory_clear_cali,
-	.set_cali = barohub_factory_set_cali,
-	.get_cali = barohub_factory_get_cali,
-	.do_self_test = barohub_factory_do_self_test,
-};
-
-static struct baro_factory_public barohub_factory_device = {
-	.gain = 1,
-	.sensitivity = 1,
-	.fops = &barohub_factory_fops,
-};
-
-static int barohub_open_report_data(int open)
-{
-	return 0;
-}
-
-static int barohub_enable_nodata(int en)
-{
-	int res = 0;
-	bool power = false;
-	struct barohub_ipi_data *obj = obj_ipi_data;
-
-	if (en == true)
-		WRITE_ONCE(obj->android_enable, true);
-	else
-		WRITE_ONCE(obj->android_enable, false);
-
-	if (en == 1)
-		power = true;
-	if (en == 0)
-		power = false;
-
-	res = barohub_set_powermode(power);
-	if (res < 0) {
-		pr_debug("barohub_set_powermode fail\n");
-		return res;
-	}
-	pr_debug("barohub_set_powermode OK!\n");
-	return res;
-}
-
-static int barohub_set_delay(u64 ns)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	int err = 0;
-	unsigned int delayms = 0;
-	struct barohub_ipi_data *obj = obj_ipi_data;
-
-	delayms = (unsigned int)ns / 1000 / 1000;
-	err = sensor_set_delay_to_hub(ID_PRESSURE, delayms);
-	if (err < 0) {
-		pr_err("als_set_delay fail!\n");
-		return err;
-	}
-	return 0;
-#elif defined CONFIG_NANOHUB
-	return 0;
-#else
-	return 0;
-#endif
-}
-static int barohub_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	barohub_set_delay(samplingPeriodNs);
-#endif
-	return sensor_batch_to_hub(ID_PRESSURE,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int barohub_flush(void)
-{
-	return sensor_flush_to_hub(ID_PRESSURE);
-}
-static int barohub_get_data(int *value, int *status)
-{
-	char buff[BAROHUB_BUFSIZE] = {0};
-	int err = 0;
-
-	err = barohub_get_pressure(buff, BAROHUB_BUFSIZE);
-
-	if (err) {
-		pr_err("get compensated pressure value failed, err = %d\n",
-			err);
-		return -1;
-	}
-
-	err = kstrtoint(buff, 16, value);
-	if (err == 0)
-		*status = SENSOR_STATUS_ACCURACY_MEDIUM;
-
-	return 0;
-}
-static int scp_ready_event(uint8_t event, void *ptr)
-{
-	struct barohub_ipi_data *obj = obj_ipi_data;
-
-	switch (event) {
-	case SENSOR_POWER_UP:
-	    atomic_set(&obj->scp_init_done, 1);
-		break;
-	case SENSOR_POWER_DOWN:
-	    atomic_set(&obj->scp_init_done, 0);
-		break;
-	}
-	return 0;
-}
-
-static struct scp_power_monitor scp_ready_notifier = {
-	.name = "baro",
-	.notifier_call = scp_ready_event,
-};
-
-static int barohub_probe(struct platform_device *pdev)
-{
-	struct barohub_ipi_data *obj;
-	struct baro_control_path ctl = { 0 };
-	struct baro_data_path data = { 0 };
-	int err = 0;
-	struct platform_driver *paddr =
-				barohub_init_info.platform_diver_addr;
-
-	pr_debug("%s\n", __func__);
-
-	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	if (!obj) {
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	obj_ipi_data = obj;
-	platform_set_drvdata(pdev, obj);
-
-	atomic_set(&obj->trace, 0);
-	atomic_set(&obj->suspend, 0);
-	WRITE_ONCE(obj->factory_enable, false);
-	WRITE_ONCE(obj->android_enable, false);
-
-	atomic_set(&obj->scp_init_done, 0);
-	scp_power_monitor_register(&scp_ready_notifier);
-	err = scp_sensorHub_data_registration(ID_PRESSURE, baro_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = baro_factory_device_register(&barohub_factory_device);
-	if (err) {
-		pr_err("baro_factory_device_register failed, err = %d\n",
-			err);
-		goto exit_kfree;
-	}
-
-	ctl.is_use_common_factory = false;
-	err = barohub_create_attr(&paddr->driver);
-	if (err) {
-		pr_err("create attribute failed, err = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	ctl.open_report_data = barohub_open_report_data;
-	ctl.enable_nodata = barohub_enable_nodata;
-	ctl.set_delay = barohub_set_delay;
-	ctl.batch = barohub_batch;
-	ctl.flush = barohub_flush;
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	ctl.is_report_input_direct = false;
-	ctl.is_support_batch = false;
-#elif defined CONFIG_NANOHUB
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = true;
-#else
-#endif
-	err = baro_register_control_path(&ctl);
-	if (err) {
-		pr_err("register baro control path err\n");
-		goto exit_create_attr_failed;
-	}
-
-	data.get_data = barohub_get_data;
-	data.vender_div = 100;
-	err = baro_register_data_path(&data);
-	if (err) {
-		pr_err("baro_register_data_path failed, err = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	barohub_init_flag = 0;
-	pr_debug("%s: OK\n", __func__);
-	return 0;
-
-exit_create_attr_failed:
-	barohub_delete_attr(&(barohub_init_info.platform_diver_addr->driver));
-exit_kfree:
-	kfree(obj);
-	obj_ipi_data = NULL;
-exit:
-	pr_err("err = %d\n", err);
-	barohub_init_flag = -1;
-	return err;
-}
-
-static int barohub_remove(struct platform_device *pdev)
-{
-	int err = 0;
-	struct platform_driver *paddr =
-				barohub_init_info.platform_diver_addr;
-
-	err = barohub_delete_attr(&paddr->driver);
-	if (err)
-		pr_err("barohub_delete_attr failed, err = %d\n", err);
-
-	baro_factory_device_deregister(&barohub_factory_device);
-
-	obj_ipi_data = NULL;
-	kfree(platform_get_drvdata(pdev));
-
-	return 0;
-}
-static int barohub_suspend(struct platform_device *pdev, pm_message_t msg)
-{
-	return 0;
-}
-
-static int barohub_resume(struct platform_device *pdev)
-{
-	return 0;
-}
-static struct platform_device barohub_device = {
-	.name = BAROHUB_DEV_NAME,
-	.id = -1,
-};
-
-static struct platform_driver barohub_driver = {
-	.driver = {
-		.name = BAROHUB_DEV_NAME,
-	},
-	.probe = barohub_probe,
-	.remove = barohub_remove,
-	.suspend = barohub_suspend,
-	.resume = barohub_resume,
-};
-
-static int barohub_local_remove(void)
-{
-	pr_debug("%s\n", __func__);
-	platform_driver_unregister(&barohub_driver);
-	return 0;
-}
-
-static int barohub_local_init(void)
-{
-	if (platform_driver_register(&barohub_driver)) {
-		pr_err("add driver error\n");
-		return -1;
-	}
-	if (-1 == barohub_init_flag)
-		return -1;
-	return 0;
-}
-
-static int __init barohub_init(void)
-{
-	pr_debug("%s\n", __func__);
-	if (platform_device_register(&barohub_device)) {
-		pr_err("baro platform device error\n");
-		return -1;
-	}
-	baro_driver_add(&barohub_init_info);
-	return 0;
-}
-
-static void __exit barohub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-	platform_driver_unregister(&barohub_driver);
-}
-
-module_init(barohub_init);
-module_exit(barohub_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("BAROHUB Driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
-MODULE_VERSION(BAROHUB_DRIVER_VERSION);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/barohub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/barohub.h
deleted file mode 100644
index 0503328..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barohub/barohub.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _BAROHUB_H
-#define _BAROHUB_H
-
-#include <linux/ioctl.h>
-
-
-#define BAROHUB_DRIVER_VERSION "V0.1"
-
-#define BAROHUB_DEV_NAME        "baro_hub_pl"
-
-#define BAROHUB_DATA_NUM 1
-#define BAROHUB_PRESSURE         0
-#define BAROHUB_BUFSIZE			60
-
-#endif/* BOSCH_BARO_H */
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barometer.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barometer.c
deleted file mode 100644
index e416605..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barometer.c
+++ /dev/null
@@ -1,699 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "Barometer " fmt
-
-#include "inc/barometer.h"
-
-struct baro_context *baro_context_obj /* = NULL*/;
-
-static void initTimer(struct hrtimer *timer,
-		      enum hrtimer_restart (*callback)(struct hrtimer *))
-{
-	hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
-	timer->function = callback;
-}
-
-static void startTimer(struct hrtimer *timer, int delay_ms, bool first)
-{
-	struct baro_context *obj = (struct baro_context *)container_of(timer,
-		struct baro_context, hrTimer);
-
-	if (obj == NULL) {
-		pr_err("NULL pointer\n");
-		return;
-	}
-
-	if (first) {
-		obj->target_ktime =
-			ktime_add_ns(ktime_get(), (int64_t)delay_ms * 1000000);
-
-		/* pr_debug("cur_ns = %lld, first_target_ns = %lld\n",
-		 *	ktime_to_ns(ktime_get()),
-		 * ktime_to_ns(obj->target_ktime));
-		 */
-	} else {
-		do {
-			obj->target_ktime = ktime_add_ns(
-				obj->target_ktime, (int64_t)delay_ms * 1000000);
-		} while (ktime_to_ns(obj->target_ktime) <
-			 ktime_to_ns(ktime_get()));
-
-		/* pr_debug("cur_ns = %lld, target_ns = %lld\n",
-		 *	ktime_to_ns(ktime_get()),
-		 *	ktime_to_ns(obj->target_ktime));
-		 */
-	}
-
-	hrtimer_start(timer, obj->target_ktime, HRTIMER_MODE_ABS);
-}
-
-#if !defined(CONFIG_NANOHUB) || !defined(CONFIG_MTK_BAROHUB)
-static void stopTimer(struct hrtimer *timer)
-{
-	hrtimer_cancel(timer);
-}
-#endif
-static struct baro_init_info *barometer_init_list[MAX_CHOOSE_BARO_NUM] = {0};
-
-static void baro_work_func(struct work_struct *work)
-{
-
-	struct baro_context *cxt = NULL;
-	/* hwm_sensor_data sensor_data; */
-	int value, status;
-	int64_t pre_ns, cur_ns;
-	int64_t delay_ms;
-	struct timespec time;
-	int err;
-
-	cxt = baro_context_obj;
-	delay_ms = atomic_read(&cxt->delay);
-
-	if (cxt->baro_data.get_data == NULL) {
-		pr_debug("baro driver not register data path\n");
-		goto baro_loop;
-	}
-
-	time.tv_sec = time.tv_nsec = 0;
-	get_monotonic_boottime(&time);
-	cur_ns = time.tv_sec * 1000000000LL + time.tv_nsec;
-
-	/* add wake lock to make sure data can be read before system suspend */
-	err = cxt->baro_data.get_data(&value, &status);
-
-	if (err) {
-		pr_err("get baro data fails!!\n");
-		goto baro_loop;
-	} else {
-		{
-			cxt->drv_data.baro_data.values[0] = value;
-			cxt->drv_data.baro_data.status = status;
-			pre_ns = cxt->drv_data.baro_data.time;
-			cxt->drv_data.baro_data.time = cur_ns;
-		}
-	}
-
-	if (true == cxt->is_first_data_after_enable) {
-		pre_ns = cur_ns;
-		cxt->is_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.baro_data.values[0] == BARO_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto baro_loop;
-		}
-	}
-	/* report data to input device */
-	/*pr_debug("new baro work run....\n"); */
-	/*pr_debug("baro data[%d].\n", cxt->drv_data.baro_data.values[0]); */
-
-	while ((cur_ns - pre_ns) >= delay_ms * 1800000LL) {
-		pre_ns += delay_ms * 1000000LL;
-		baro_data_report(cxt->drv_data.baro_data.values[0],
-				 cxt->drv_data.baro_data.status, pre_ns);
-	}
-
-	baro_data_report(cxt->drv_data.baro_data.values[0],
-			 cxt->drv_data.baro_data.status,
-			 cxt->drv_data.baro_data.time);
-
-baro_loop:
-	if (true == cxt->is_polling_run) {
-		{
-			startTimer(&cxt->hrTimer, atomic_read(&cxt->delay),
-				   false);
-		}
-	}
-}
-
-enum hrtimer_restart baro_poll(struct hrtimer *timer)
-{
-	struct baro_context *obj = (struct baro_context *)container_of(timer,
-		struct baro_context, hrTimer);
-
-	queue_work(obj->baro_workqueue, &obj->report);
-
-	return HRTIMER_NORESTART;
-}
-
-static struct baro_context *baro_context_alloc_object(void)
-{
-
-	struct baro_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc baro object error!\n");
-		return NULL;
-	}
-	atomic_set(&obj->delay, 200); /*5Hz set work queue delay time 200 ms */
-	atomic_set(&obj->wake, 0);
-	INIT_WORK(&obj->report, baro_work_func);
-	obj->baro_workqueue = NULL;
-	obj->baro_workqueue = create_workqueue("baro_polling");
-	if (!obj->baro_workqueue) {
-		kfree(obj);
-		return NULL;
-	}
-	initTimer(&obj->hrTimer, baro_poll);
-	obj->is_first_data_after_enable = false;
-	obj->is_polling_run = false;
-	mutex_init(&obj->baro_op_mutex);
-	obj->is_batch_enable = false; /* for batch mode init */
-	obj->power = 0;
-	obj->enable = 0;
-	obj->delay_ns = -1;
-	obj->latency_ns = -1;
-
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-#if !defined(CONFIG_NANOHUB) || !defined(CONFIG_MTK_BAROHUB)
-static int baro_enable_and_batch(void)
-{
-	struct baro_context *cxt = baro_context_obj;
-	int err;
-
-	/* power on -> power off */
-	if (cxt->power == 1 && cxt->enable == 0) {
-		pr_debug("BARO disable\n");
-		/* stop polling firstly, if needed */
-		if (cxt->baro_ctl.is_report_input_direct == false &&
-		    cxt->is_polling_run == true) {
-			smp_mb(); /* for memory barrier */
-			stopTimer(&cxt->hrTimer);
-			smp_mb(); /* for memory barrier */
-			cancel_work_sync(&cxt->report);
-			cxt->drv_data.baro_data.values[0] = BARO_INVALID_VALUE;
-			cxt->is_polling_run = false;
-			pr_debug("baro stop polling done\n");
-		}
-		/* turn off the power */
-		err = cxt->baro_ctl.enable_nodata(0);
-		if (err) {
-			pr_err("baro turn off power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("baro turn off power done\n");
-
-		cxt->power = 0;
-		cxt->delay_ns = -1;
-		pr_debug("BARO disable done\n");
-		return 0;
-	}
-	/* power off -> power on */
-	if (cxt->power == 0 && cxt->enable == 1) {
-		pr_debug("BARO power on\n");
-		err = cxt->baro_ctl.enable_nodata(1);
-		if (err) {
-			pr_err("baro turn on power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("baro turn on power done\n");
-
-		cxt->power = 1;
-		pr_debug("BARO power on done\n");
-	}
-	/* rate change */
-	if (cxt->power == 1 && cxt->delay_ns >= 0) {
-		pr_debug("BARO set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->baro_ctl.is_support_batch)
-			err = cxt->baro_ctl.batch(0, cxt->delay_ns,
-						  cxt->latency_ns);
-		else
-			err = cxt->baro_ctl.batch(0, cxt->delay_ns, 0);
-		if (err) {
-			pr_err("baro set batch(ODR) err %d\n", err);
-			return -1;
-		}
-		pr_debug("baro set ODR, fifo latency done\n");
-		/* start polling, if needed */
-		if (cxt->baro_ctl.is_report_input_direct == false) {
-			uint64_t mdelay = cxt->delay_ns;
-
-			do_div(mdelay, 1000000);
-			atomic_set(&cxt->delay, mdelay);
-			/* the first sensor start polling timer */
-			if (cxt->is_polling_run == false) {
-				cxt->is_polling_run = true;
-				cxt->is_first_data_after_enable = true;
-				startTimer(&cxt->hrTimer,
-					   atomic_read(&cxt->delay), true);
-			}
-			pr_debug("baro set polling delay %d ms\n",
-				 atomic_read(&cxt->delay));
-		}
-		pr_debug("BARO batch done\n");
-	}
-	return 0;
-}
-#endif
-static ssize_t baroactive_store(struct device *dev,
-				 struct device_attribute *attr, const char *buf,
-				 size_t count)
-{
-	struct baro_context *cxt = baro_context_obj;
-	int err = 0;
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&baro_context_obj->baro_op_mutex);
-	if (!strncmp(buf, "1", 1))
-		cxt->enable = 1;
-	else if (!strncmp(buf, "0", 1))
-		cxt->enable = 0;
-	else {
-		pr_err("%s error !!\n", __func__);
-		err = -1;
-		goto err_out;
-	}
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_BAROHUB)
-	err = cxt->baro_ctl.enable_nodata(cxt->enable);
-	if (err) {
-		pr_err("baro turn on power err = %d\n", err);
-		goto err_out;
-	}
-#else
-	err = baro_enable_and_batch();
-#endif
-err_out:
-	mutex_unlock(&baro_context_obj->baro_op_mutex);
-	pr_debug("%s done\n", __func__);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-/*----------------------------------------------------------------------------*/
-static ssize_t baroactive_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	struct baro_context *cxt = NULL;
-	int div;
-
-	cxt = baro_context_obj;
-	div = cxt->baro_data.vender_div;
-
-	pr_debug("baro vender_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-static ssize_t barobatch_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct baro_context *cxt = baro_context_obj;
-	int handle = 0, flag = 0, err = 0;
-
-	err = sscanf(buf, "%d,%d,%lld,%lld", &handle, &flag, &cxt->delay_ns,
-		     &cxt->latency_ns);
-	if (err != 4) {
-		pr_err("grav_store_batch param error: err = %d\n", err);
-		return -1;
-	}
-
-	mutex_lock(&baro_context_obj->baro_op_mutex);
-#if defined(CONFIG_NANOHUB) && defined(CONFIG_MTK_BAROHUB)
-	if (cxt->baro_ctl.is_support_batch)
-		err = cxt->baro_ctl.batch(0, cxt->delay_ns, cxt->latency_ns);
-	else
-		err = cxt->baro_ctl.batch(0, cxt->delay_ns, 0);
-	if (err)
-		pr_err("baro set batch(ODR) err %d\n", err);
-#else
-	err = baro_enable_and_batch();
-#endif
-	mutex_unlock(&baro_context_obj->baro_op_mutex);
-	pr_debug("%s done: %d\n", __func__, cxt->is_batch_enable);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t barobatch_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t baroflush_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct baro_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&baro_context_obj->baro_op_mutex);
-	cxt = baro_context_obj;
-	if (cxt->baro_ctl.flush != NULL)
-		err = cxt->baro_ctl.flush();
-	else
-		pr_err(
-			"BARO DRIVER OLD ARCHITECTURE DON'T SUPPORT BARO COMMON VERSION FLUSH\n");
-	if (err < 0)
-		pr_err("baro enable flush err %d\n", err);
-	mutex_unlock(&baro_context_obj->baro_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t baroflush_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t barodevnum_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static int barometer_remove(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int barometer_probe(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id barometer_of_match[] = {
-	{
-		.compatible = "mediatek,barometer",
-	},
-	{},
-};
-#endif
-
-static struct platform_driver barometer_driver = {
-	.probe = barometer_probe,
-	.remove = barometer_remove,
-	.driver = {
-		.name = "barometer",
-#ifdef CONFIG_OF
-		.of_match_table = barometer_of_match,
-#endif
-	}
-};
-
-static int baro_real_driver_init(void)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_BARO_NUM; i++) {
-		pr_debug(" i=%d\n", i);
-		if (barometer_init_list[i] != 0) {
-			pr_debug(" baro try to init driver %s\n",
-				 barometer_init_list[i]->name);
-			err = barometer_init_list[i]->init();
-			if (err == 0) {
-				pr_debug(" baro real driver %s probe ok\n",
-					 barometer_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_BARO_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-
-int baro_driver_add(struct baro_init_info *obj)
-{
-	int err = 0;
-	int i = 0;
-
-	pr_debug("%s\n", __func__);
-	if (!obj) {
-		pr_err("BARO driver add fail, baro_init_info is NULL\n");
-		return -1;
-	}
-
-	for (i = 0; i < MAX_CHOOSE_BARO_NUM; i++) {
-		if (i == 0) {
-			pr_debug(
-				"register barometer driver for the first time\n");
-			if (platform_driver_register(&barometer_driver))
-				pr_err(
-					"failed to register gensor driver already exist\n");
-		}
-
-		if (barometer_init_list[i] == NULL) {
-			obj->platform_diver_addr = &barometer_driver;
-			barometer_init_list[i] = obj;
-			break;
-		}
-	}
-	if (i >= MAX_CHOOSE_BARO_NUM) {
-		pr_err("BARO driver add err\n");
-		err = -1;
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(baro_driver_add);
-
-static int pressure_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t pressure_read(struct file *file, char __user *buffer,
-			     size_t count, loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(baro_context_obj->mdev.minor, file, buffer,
-				     count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int pressure_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(baro_context_obj->mdev.minor, file, wait);
-}
-
-static const struct file_operations pressure_fops = {
-	.owner = THIS_MODULE,
-	.open = pressure_open,
-	.read = pressure_read,
-	.poll = pressure_poll,
-};
-
-static int baro_misc_init(struct baro_context *cxt)
-{
-
-	int err = 0;
-
-	cxt->mdev.minor = ID_PRESSURE;
-	cxt->mdev.name = BARO_MISC_DEV_NAME;
-	cxt->mdev.fops = &pressure_fops;
-	err = sensor_attr_register(&cxt->mdev);
-	if (err)
-		pr_err("unable to register baro misc device!!\n");
-
-	return err;
-}
-
-DEVICE_ATTR_RW(baroactive);
-DEVICE_ATTR_RW(barobatch);
-DEVICE_ATTR_RW(baroflush);
-DEVICE_ATTR_RO(barodevnum);
-
-static struct attribute *baro_attributes[] = {
-	&dev_attr_baroactive.attr,
-	&dev_attr_barobatch.attr,
-	&dev_attr_baroflush.attr,
-	&dev_attr_barodevnum.attr,
-	NULL
-};
-
-static struct attribute_group baro_attribute_group = {
-	.attrs = baro_attributes
-};
-
-int baro_register_data_path(struct baro_data_path *data)
-{
-	struct baro_context *cxt = NULL;
-
-	cxt = baro_context_obj;
-	cxt->baro_data.get_data = data->get_data;
-	cxt->baro_data.vender_div = data->vender_div;
-	cxt->baro_data.get_raw_data = data->get_raw_data;
-	pr_debug("baro register data path vender_div: %d\n",
-		 cxt->baro_data.vender_div);
-	if (cxt->baro_data.get_data == NULL) {
-		pr_debug("baro register data path fail\n");
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(baro_register_data_path);
-
-int baro_register_control_path(struct baro_control_path *ctl)
-{
-	struct baro_context *cxt = NULL;
-	int err = 0;
-
-	cxt = baro_context_obj;
-	cxt->baro_ctl.set_delay = ctl->set_delay;
-	cxt->baro_ctl.open_report_data = ctl->open_report_data;
-	cxt->baro_ctl.enable_nodata = ctl->enable_nodata;
-	cxt->baro_ctl.batch = ctl->batch;
-	cxt->baro_ctl.flush = ctl->flush;
-	cxt->baro_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->baro_ctl.is_report_input_direct = ctl->is_report_input_direct;
-	cxt->baro_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->baro_ctl.is_use_common_factory = ctl->is_use_common_factory;
-
-	if (cxt->baro_ctl.set_delay == NULL ||
-	    cxt->baro_ctl.open_report_data == NULL ||
-	    cxt->baro_ctl.enable_nodata == NULL) {
-		pr_debug("baro register control path fail\n");
-		return -1;
-	}
-
-	/* add misc dev for sensor hal control cmd */
-	err = baro_misc_init(baro_context_obj);
-	if (err) {
-		pr_err("unable to register baro misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&baro_context_obj->mdev.this_device->kobj,
-				 &baro_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create baro attribute file\n");
-		return -3;
-	}
-
-	kobject_uevent(&baro_context_obj->mdev.this_device->kobj, KOBJ_ADD);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(baro_register_control_path);
-
-int baro_data_report(int value, int status, int64_t nt)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = DATA_ACTION;
-	event.time_stamp = nt;
-	event.word[0] = value;
-	event.status = status;
-
-	err = sensor_input_event(baro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(baro_data_report);
-
-int baro_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	pr_debug_ratelimited("flush\n");
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(baro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(baro_flush_report);
-
-int baro_probe(void)
-{
-	int err;
-
-	pr_debug("%s+++!!\n", __func__);
-
-	baro_context_obj = baro_context_alloc_object();
-	if (!baro_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-
-	/* init real baro driver */
-	err = baro_real_driver_init();
-	if (err) {
-		pr_err("baro real driver init fail\n");
-		goto real_driver_init_fail;
-	}
-
-	pr_debug("%s--- OK !!\n", __func__);
-	return 0;
-
-real_driver_init_fail:
-	kfree(baro_context_obj);
-	baro_context_obj = NULL;
-exit_alloc_data_failed:
-
-	pr_debug("%s----fail !!!\n", __func__);
-	return err;
-}
-EXPORT_SYMBOL_GPL(baro_probe);
-
-int baro_remove(void)
-{
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-
-	sysfs_remove_group(&baro_context_obj->mdev.this_device->kobj,
-			   &baro_attribute_group);
-
-	err = sensor_attr_deregister(&baro_context_obj->mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-	kfree(baro_context_obj);
-
-	platform_driver_unregister(&barometer_driver);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(baro_remove);
-
-static int __init baro_init(void)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static void __exit baro_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(baro_init);
-module_exit(baro_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("BAROMETER device driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barometer_factory.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barometer_factory.c
deleted file mode 100644
index a04f2c0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/barometer_factory.c
+++ /dev/null
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<BARO_FAC> " fmt
-
-#include "inc/barometer_factory.h"
-
-struct baro_factory_private {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct baro_factory_fops *fops;
-};
-
-static struct baro_factory_private baro_factory;
-
-static int baro_factory_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static int baro_factory_release(struct inode *inode, struct file *file)
-{
-	file->private_data = NULL;
-	return 0;
-}
-
-static long baro_factory_unlocked_ioctl(struct file *file, unsigned int cmd,
-					unsigned long arg)
-{
-	long err = 0;
-	void __user *ptr = (void __user *)arg;
-	int data = 0;
-	uint32_t flag = 0;
-
-	if (_IOC_DIR(cmd) & _IOC_READ)
-		err = !access_ok(VERIFY_WRITE, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-	else if (_IOC_DIR(cmd) & _IOC_WRITE)
-		err = !access_ok(VERIFY_READ, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-
-	if (err) {
-		pr_err("access error: %08X, (%2d, %2d)\n", cmd,
-			    _IOC_DIR(cmd), _IOC_SIZE(cmd));
-		return -EFAULT;
-	}
-
-	switch (cmd) {
-	case BAROMETER_IOCTL_INIT:
-		if (copy_from_user(&flag, ptr, sizeof(flag)))
-			return -EFAULT;
-		if (baro_factory.fops != NULL &&
-		    baro_factory.fops->enable_sensor != NULL) {
-			err = baro_factory.fops->enable_sensor(flag, 200);
-			if (err < 0) {
-				pr_err("BAROMETER_IOCTL_INIT fail!\n");
-				return -EINVAL;
-			}
-			pr_debug(
-				"BAROMETER_IOCTL_INIT, enable: %d, sample_period:%dms\n",
-				flag, 200);
-		} else {
-			pr_err("BAROMETER_IOCTL_INIT NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case BAROMETER_GET_PRESS_DATA:
-		if (baro_factory.fops != NULL &&
-		    baro_factory.fops->get_data != NULL) {
-			err = baro_factory.fops->get_data(&data);
-			if (err < 0) {
-				pr_err(
-					"BAROMETER_GET_PRESS_DATA read data fail!\n");
-				return -EINVAL;
-			}
-			if (copy_to_user(ptr, &data, sizeof(data)))
-				return -EFAULT;
-		} else {
-			pr_err("BAROMETER_GET_PRESS_DATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case BAROMETER_IOCTL_ENABLE_CALI:
-		if (baro_factory.fops != NULL &&
-		    baro_factory.fops->enable_calibration != NULL) {
-			err = baro_factory.fops->enable_calibration();
-			if (err < 0) {
-				pr_err(
-					"BAROMETER_IOCTL_ENABLE_CALI fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("BAROMETER_IOCTL_ENABLE_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case BAROMETER_GET_TEMP_DATA:
-		return 0;
-	default:
-		pr_err("unknown IOCTL: 0x%08x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-	return 0;
-}
-
-#if IS_ENABLED(CONFIG_COMPAT)
-static long compat_baro_factory_unlocked_ioctl(struct file *filp,
-					       unsigned int cmd,
-					       unsigned long arg)
-{
-	if (!filp->f_op || !filp->f_op->unlocked_ioctl) {
-		pr_err(
-			"compat_ion_ioctl file has no f_op or no f_op->unlocked_ioctl.\n");
-		return -ENOTTY;
-	}
-
-	switch (cmd) {
-	case COMPAT_BAROMETER_IOCTL_INIT:
-	/* case COMPAT_BAROMETER_IOCTL_READ_CHIPINFO: */
-	case COMPAT_BAROMETER_GET_PRESS_DATA:
-	case COMPAT_BAROMETER_GET_TEMP_DATA:
-	case COMPAT_BAROMETER_IOCTL_ENABLE_CALI: {
-		pr_debug(
-			"compat_ion_ioctl : BAROMETER_IOCTL_XXX command is 0x%x\n",
-			cmd);
-		return filp->f_op->unlocked_ioctl(
-			filp, cmd, (unsigned long)compat_ptr(arg));
-	}
-	default:
-		pr_err("compat_ion_ioctl : No such command!! 0x%x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-}
-#endif
-/*----------------------------------------------------------------------------*/
-static const struct file_operations baro_factory_fops = {
-	.open = baro_factory_open,
-	.release = baro_factory_release,
-	.unlocked_ioctl = baro_factory_unlocked_ioctl,
-#if IS_ENABLED(CONFIG_COMPAT)
-	.compat_ioctl = compat_baro_factory_unlocked_ioctl,
-#endif
-};
-
-static struct miscdevice baro_factory_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "barometer",
-	.fops = &baro_factory_fops,
-};
-
-int baro_factory_device_register(struct baro_factory_public *dev)
-{
-	int err = 0;
-
-	if (!dev || !dev->fops)
-		return -1;
-	baro_factory.gain = dev->gain;
-	baro_factory.sensitivity = dev->sensitivity;
-	baro_factory.fops = dev->fops;
-	err = misc_register(&baro_factory_device);
-	if (err) {
-		pr_err("baro_factory_device register failed\n");
-		err = -1;
-	}
-	return err;
-}
-EXPORT_SYMBOL(baro_factory_device_register);
-
-int baro_factory_device_deregister(struct baro_factory_public *dev)
-{
-	baro_factory.fops = NULL;
-	misc_deregister(&baro_factory_device);
-	return 0;
-}
-EXPORT_SYMBOL(baro_factory_device_deregister);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/barometer.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/barometer.h
deleted file mode 100644
index 7b367ce..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/barometer.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __BARO_H__
-#define __BARO_H__
-
-#include <linux/atomic.h>
-#include <linux/i2c.h>
-#include <linux/io.h>
-#include <linux/irq.h>
-#include <linux/kobject.h>
-#include <linux/sched.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-//#include <linux/wakelock.h>
-#include "barometer_factory.h"
-#include "sensor_attr.h"
-#include "sensor_event.h"
-#include <hwmsensor.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/poll.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
-#include <sensors_io.h>
-
-#define OP_BARO_DELAY 0X01
-#define OP_BARO_ENABLE 0X02
-#define OP_BARO_GET_DATA 0X04
-
-#define BARO_INVALID_VALUE -1
-
-#define EVENT_TYPE_BARO_VALUE REL_X
-#define EVENT_TYPE_BARO_STATUS ABS_WHEEL
-#define EVENT_TYPE_BARO_TIMESTAMP_HI REL_HWHEEL
-#define EVENT_TYPE_BARO_TIMESTAMP_LO REL_DIAL
-
-#define BARO_VALUE_MAX (32767)
-#define BARO_VALUE_MIN (-32768)
-#define BARO_STATUS_MIN (0)
-#define BARO_STATUS_MAX (64)
-#define BARO_DIV_MAX (32767)
-#define BARO_DIV_MIN (1)
-
-#define MAX_CHOOSE_BARO_NUM 5
-
-struct baro_control_path {
-	int (*open_report_data)(int open);
-	int (*enable_nodata)(int en);
-	int (*set_delay)(u64 delay);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		     int64_t maxBatchReportLatencyNs);
-	int (*flush)(void); /* open data rerport to HAL */
-	int (*baroess_data_fifo)(void);
-	bool is_report_input_direct;
-	bool is_support_batch;
-	bool is_use_common_factory;
-};
-
-struct baro_data_path {
-	int (*get_data)(int *value, int *status);
-	int (*get_raw_data)(int type, int *value);
-	int vender_div;
-};
-
-struct baro_init_info {
-	char *name;
-	int (*init)(void);
-	int (*uninit)(void);
-	struct platform_driver *platform_diver_addr;
-};
-
-struct baro_data {
-	struct hwm_sensor_data baro_data;
-	int data_updata;
-};
-
-struct baro_drv_obj {
-	void *self;
-	int polling;
-	int (*baro_operate)(void *self, uint32_t command, void *buff_in,
-			    int size_in, void *buff_out, int size_out,
-			    int *actualout);
-};
-
-struct baro_context {
-	struct input_dev *idev;
-	struct sensor_attr_t mdev;
-	struct work_struct report;
-	struct mutex baro_op_mutex;
-	atomic_t delay;
-	atomic_t wake;
-	struct timer_list timer;
-	struct hrtimer hrTimer;
-	ktime_t target_ktime;
-	atomic_t trace;
-	struct workqueue_struct *baro_workqueue;
-
-	struct baro_data drv_data;
-	struct baro_control_path baro_ctl;
-	struct baro_data_path baro_data;
-	bool is_first_data_after_enable;
-	bool is_polling_run;
-	bool is_batch_enable;
-	int power;
-	int enable;
-	int64_t delay_ns;
-	int64_t latency_ns;
-};
-
-extern int baro_driver_add(struct baro_init_info *obj);
-extern int baro_data_report(int value, int status, int64_t nt);
-extern int baro_flush_report(void);
-extern int baro_register_control_path(struct baro_control_path *ctl);
-extern int baro_register_data_path(struct baro_data_path *data);
-extern int baro_probe(void);
-extern int baro_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/barometer_factory.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/barometer_factory.h
deleted file mode 100644
index 4d2e41a..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/barometer_factory.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __BARO_FACTORY_H__
-#define __BARO_FACTORY_H__
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/types.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include <hwmsen_helper.h>
-
-#include "barometer.h"
-#include "cust_baro.h"
-
-struct baro_factory_fops {
-	int (*enable_sensor)(bool enable_disable, int64_t sample_periods_ms);
-	int (*get_data)(int32_t *data);
-	int (*get_raw_data)(int32_t *data);
-	int (*enable_calibration)(void);
-	int (*clear_cali)(void);
-	int (*set_cali)(int32_t offset);
-	int (*get_cali)(int32_t *offset);
-	int (*do_self_test)(void);
-};
-
-struct baro_factory_public {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct baro_factory_fops *fops;
-};
-int baro_factory_device_register(struct baro_factory_public *dev);
-int baro_factory_device_deregister(struct baro_factory_public *dev);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/cust_baro.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/cust_baro.h
deleted file mode 100644
index 266e315..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/barometer/inc/cust_baro.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __CUST_BARO_H__
-#define __CUST_BARO_H__
-
-#include <linux/types.h>
-
-#define B_CUST_I2C_ADDR_NUM 2
-
-struct baro_hw {
-	int i2c_num;   /*!< the i2c bus used by the chip */
-	int direction; /*!< the direction of the chip */
-	int power_id;  /*!< the LDO ID of the chip, MT6516_POWER_NONE
-			*means the power is always on
-			*/
-	int power_vol; /*!< the Power Voltage used by the chip */
-	int firlen;    /*!< the length of low pass filter */
-	int (*power)(struct baro_hw *hw, unsigned int on, char *devname);
-	unsigned char i2c_addr[B_CUST_I2C_ADDR_NUM];
-	/*!< i2c address list,for chips which has different addresses with
-	 * different HW layout
-	 */
-	bool is_batch_supported;
-};
-
-int get_baro_dts_func(struct device_node *node, struct baro_hw *hw);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/dummy.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/dummy.c
deleted file mode 100644
index 3ba8376..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/dummy.c
+++ /dev/null
@@ -1,9 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-/*
- * this file only when MTK_SENSOR_SUPPORT is not set then build in
- * to resolve build in build error
- */
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/Kconfig
deleted file mode 100644
index d53acb1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/Kconfig
+++ /dev/null
@@ -1,13 +0,0 @@
-
-config CUSTOM_KERNEL_GYROSCOPE
-	bool "CUSTOM KERNEL GYROSCOPE Config"
-	help
-	  gyroscope sensor to detect gyroscope from x y z axis.
-	  If the platform is supported for gyroscope, this
-	  configuration should be configured, and the gyroscope
-	  driver configuration should be configured as well.
-
-source "drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/gyroscope/bmi160gy-i2c/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/gyroscope/ITG1010/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/gyroscope/mpu6050gy/Kconfig"
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/Makefile
deleted file mode 100644
index e61d95d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-# In case the platform does NOT support this type of sensors
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/include
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)   +=  gyro_common.o
-gyro_common-$(CONFIG_MTK_SENSOR_SUPPORT) := gyroscope.o gyro_factory.o
-
-obj-$(CONFIG_MTK_GYROHUB)      +=  gyrohub/
-#obj-$(CONFIG_MTK_BMI160GY_I2C) +=  bmi160gy-i2c/
-#obj-$(CONFIG_MTK_ITG1010)   +=  ITG1010/
-#obj-$(CONFIG_MTK_MPU6050GY)   +=  mpu6050gy/
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyro_factory.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyro_factory.c
deleted file mode 100644
index 7b29b59..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyro_factory.c
+++ /dev/null
@@ -1,282 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<GYRO_FAC> " fmt
-
-#include "inc/gyro_factory.h"
-
-struct gyro_factory_private {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct gyro_factory_fops *fops;
-};
-
-static struct gyro_factory_private gyro_factory;
-static int gyro_factory_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static int gyro_factory_release(struct inode *inode, struct file *file)
-{
-	return 0;
-}
-
-static long gyro_factory_unlocked_ioctl(struct file *file, unsigned int cmd,
-					unsigned long arg)
-{
-	void __user *ptr = (void __user *)arg;
-	long err = 0;
-	uint32_t flag = 0;
-	int smtRes = 0, status = 0;
-	int32_t data_buf[3] = {0};
-	char strbuf[64] = {0};
-	struct SENSOR_DATA sensor_data = {0};
-
-	if (_IOC_DIR(cmd) & _IOC_READ)
-		err = !access_ok(VERIFY_WRITE, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-	else if (_IOC_DIR(cmd) & _IOC_WRITE)
-		err = !access_ok(VERIFY_READ, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-
-	if (err) {
-		pr_err("access error: %08X, (%2d, %2d)\n", cmd,
-			    _IOC_DIR(cmd), _IOC_SIZE(cmd));
-		return -EFAULT;
-	}
-
-	switch (cmd) {
-	case GYROSCOPE_IOCTL_INIT:
-		if (copy_from_user(&flag, ptr, sizeof(flag)))
-			return -EFAULT;
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->enable_sensor != NULL) {
-			err = gyro_factory.fops->enable_sensor(flag,
-							       5); /* 5ms */
-			if (err < 0) {
-				pr_err("GYROSCOPE_IOCTL_INIT fail!\n");
-				return -EINVAL;
-			}
-			pr_debug(
-				"GYROSCOPE_IOCTL_INIT, enable: %d, sample_period:%dms\n",
-				flag, 5);
-		} else {
-			pr_err("GYROSCOPE_IOCTL_INIT NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GYROSCOPE_IOCTL_SMT_DATA:
-		smtRes = 1;
-		if (copy_to_user(ptr, &smtRes, sizeof(smtRes)))
-			return -EFAULT;
-		return 0;
-	case GYROSCOPE_IOCTL_READ_SENSORDATA:
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->get_data != NULL) {
-			err = gyro_factory.fops->get_data(data_buf, &status);
-			if (err < 0) {
-				pr_err(
-					"GYROSCOPE_IOCTL_READ_SENSORDATA read data fail!\n");
-				return -EINVAL;
-			}
-			sprintf(strbuf, "%x %x %x", data_buf[0], data_buf[1],
-				data_buf[2]);
-			pr_debug(
-				"GYROSCOPE_IOCTL_READ_SENSORDATA read strbuf : (%s)!\n",
-				strbuf);
-			if (copy_to_user(ptr, strbuf, strlen(strbuf) + 1))
-				return -EFAULT;
-		} else {
-			pr_err("GYROSCOPE_IOCTL_READ_SENSORDATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GYROSCOPE_IOCTL_READ_SENSORDATA_RAW:
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->get_raw_data != NULL) {
-			err = gyro_factory.fops->get_raw_data(data_buf);
-			if (err < 0) {
-				pr_err(
-					"GSENSOR_IOCTL_READ_RAW_DATA read data fail!\n");
-				return -EINVAL;
-			}
-			sprintf(strbuf, "%x %x %x", data_buf[0], data_buf[1],
-				data_buf[2]);
-			pr_debug(
-				"GYROSCOPE_IOCTL_READ_SENSORDATA_RAW read strbuf : (%s)!\n",
-				strbuf);
-			if (copy_to_user(ptr, strbuf, strlen(strbuf) + 1))
-				return -EFAULT;
-		} else {
-			pr_err(
-				"GYROSCOPE_IOCTL_READ_SENSORDATA_RAW NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GYROSCOPE_IOCTL_SET_CALI:
-		if (copy_from_user(&sensor_data, ptr, sizeof(sensor_data)))
-			return -EFAULT;
-		data_buf[0] = sensor_data.x;
-		data_buf[1] = sensor_data.y;
-		data_buf[2] = sensor_data.z;
-		pr_debug("GYROSCOPE_IOCTL_SET_CALI: (%d, %d, %d)!\n",
-			 data_buf[0], data_buf[1], data_buf[2]);
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->set_cali != NULL) {
-			err = gyro_factory.fops->set_cali(data_buf);
-			if (err < 0) {
-				pr_err("GYROSCOPE_IOCTL_SET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GYROSCOPE_IOCTL_SET_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GYROSCOPE_IOCTL_CLR_CALI:
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->clear_cali != NULL) {
-			err = gyro_factory.fops->clear_cali();
-			if (err < 0) {
-				pr_err("GYROSCOPE_IOCTL_CLR_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GYROSCOPE_IOCTL_CLR_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GYROSCOPE_IOCTL_GET_CALI:
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->get_cali != NULL) {
-			err = gyro_factory.fops->get_cali(data_buf);
-			if (err < 0) {
-				pr_err("GYROSCOPE_IOCTL_GET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GYROSCOPE_IOCTL_GET_CALI NULL\n");
-			return -EINVAL;
-		}
-		pr_debug("GYROSCOPE_IOCTL_GET_CALI: (%d, %d, %d)!\n",
-			 data_buf[0], data_buf[1], data_buf[2]);
-		sensor_data.x = data_buf[0];
-		sensor_data.y = data_buf[1];
-		sensor_data.z = data_buf[2];
-		if (copy_to_user(ptr, &sensor_data, sizeof(sensor_data)))
-			return -EFAULT;
-		return 0;
-	case GYROSCOPE_IOCTL_ENABLE_CALI:
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->enable_calibration != NULL) {
-			err = gyro_factory.fops->enable_calibration();
-			if (err < 0) {
-				pr_err(
-					"GYROSCOPE_IOCTL_ENABLE_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GYROSCOPE_IOCTL_ENABLE_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case GYROSCOPE_IOCTL_SELF_TEST:
-		if (gyro_factory.fops != NULL &&
-		    gyro_factory.fops->do_self_test != NULL) {
-			err = gyro_factory.fops->do_self_test();
-			if (err < 0) {
-				pr_err(
-					"GYROSCOPE_IOCTL_SELF_TEST FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("GYROSCOPE_IOCTL_SELF_TEST NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	default:
-		pr_err("unknown IOCTL: 0x%08x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-
-	return 0;
-}
-
-#if IS_ENABLED(CONFIG_COMPAT)
-static long compat_gyro_factory_unlocked_ioctl(struct file *filp,
-					       unsigned int cmd,
-					       unsigned long arg)
-{
-	if (!filp->f_op || !filp->f_op->unlocked_ioctl) {
-		pr_err(
-			"compat_ion_ioctl file has no f_op or no f_op->unlocked_ioctl.\n");
-		return -ENOTTY;
-	}
-
-	switch (cmd) {
-	case COMPAT_GYROSCOPE_IOCTL_INIT:
-	case COMPAT_GYROSCOPE_IOCTL_SMT_DATA:
-	case COMPAT_GYROSCOPE_IOCTL_READ_SENSORDATA_RAW:
-	case COMPAT_GYROSCOPE_IOCTL_READ_SENSORDATA:
-	/* NVRAM will use below ioctl */
-	case COMPAT_GYROSCOPE_IOCTL_SET_CALI:
-	case COMPAT_GYROSCOPE_IOCTL_CLR_CALI:
-	case COMPAT_GYROSCOPE_IOCTL_GET_CALI:
-	case COMPAT_GYROSCOPE_IOCTL_ENABLE_CALI:
-	case COMPAT_GYROSCOPE_IOCTL_SELF_TEST:
-		pr_debug(
-			"compat_ion_ioctl : GYROSCOPE_IOCTL_XXX command is 0x%x\n",
-			cmd);
-		return filp->f_op->unlocked_ioctl(
-			filp, cmd, (unsigned long)compat_ptr(arg));
-	default:
-		pr_err("compat_ion_ioctl : No such command!! 0x%x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-}
-#endif
-
-/*----------------------------------------------------------------------------*/
-static const struct file_operations gyro_factory_fops = {
-	.open = gyro_factory_open,
-	.release = gyro_factory_release,
-	.unlocked_ioctl = gyro_factory_unlocked_ioctl,
-#if IS_ENABLED(CONFIG_COMPAT)
-	.compat_ioctl = compat_gyro_factory_unlocked_ioctl,
-#endif
-};
-
-static struct miscdevice gyro_factory_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "gyroscope",
-	.fops = &gyro_factory_fops,
-};
-
-int gyro_factory_device_register(struct gyro_factory_public *dev)
-{
-	int err = 0;
-
-	if (!dev || !dev->fops)
-		return -1;
-	gyro_factory.gain = dev->gain;
-	gyro_factory.sensitivity = dev->sensitivity;
-	gyro_factory.fops = dev->fops;
-	err = misc_register(&gyro_factory_device);
-	if (err) {
-		pr_err("gyro_factory_device register failed\n");
-		err = -1;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_factory_device_register);
-
-int gyro_factory_device_deregister(struct gyro_factory_public *dev)
-{
-	gyro_factory.fops = NULL;
-	misc_deregister(&gyro_factory_device);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(gyro_factory_device_deregister);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Kconfig
deleted file mode 100644
index d249dad..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_GYROHUB
-	bool "gyrohub for MediaTek package"
-	help
-	  It support different gyrohub sensor.
-	  If this option is set,
-	  it will support
-	  sensorhub gyroscope.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Makefile
deleted file mode 100644
index 8f4c236..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/Makefile
+++ /dev/null
@@ -1,7 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/gyroscope/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)	:=  gyrohub.o
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/gyrohub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/gyrohub.c
deleted file mode 100644
index e2ef359..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/gyrohub.c
+++ /dev/null
@@ -1,1019 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[GYRO] " fmt
-
-#include <hwmsensor.h>
-#include "gyrohub.h"
-#include <gyroscope.h>
-#include <SCP_sensorHub.h>
-#include "SCP_power_monitor.h"
-
-/* name must different with gsensor gyrohub */
-#define GYROHUB_DEV_NAME    "gyro_hub"
-
-static struct gyro_init_info gyrohub_init_info;
-struct platform_device *gyroPltFmDev;
-static int gyrohub_init_flag = -1;
-static DEFINE_SPINLOCK(calibration_lock);
-
-enum GYRO_TRC {
-	GYRO_TRC_FILTER = 0x01,
-	GYRO_TRC_RAWDATA = 0x02,
-	GYRO_TRC_IOCTL = 0x04,
-	GYRO_TRC_CALI = 0X08,
-	GYRO_TRC_INFO = 0X10,
-	GYRO_TRC_DATA = 0X20,
-};
-struct gyrohub_ipi_data {
-	int direction;
-	atomic_t trace;
-	atomic_t suspend;
-	atomic_t selftest_status;
-	int32_t static_cali[GYROHUB_AXES_NUM];
-	uint8_t static_cali_status;
-	int32_t dynamic_cali[GYROHUB_AXES_NUM];
-	int32_t temperature_cali[6];
-	struct work_struct init_done_work;
-	/*data */
-	atomic_t scp_init_done;
-	atomic_t first_ready_after_boot;
-	bool factory_enable;
-	bool android_enable;
-	struct completion calibration_done;
-	struct completion selftest_done;
-};
-static struct gyrohub_ipi_data *obj_ipi_data;
-
-static int gyrohub_get_data(int *x, int *y, int *z, int *status);
-
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-static int gyrohub_write_rel_calibration(struct gyrohub_ipi_data *obj,
-	int dat[GYROHUB_AXES_NUM])
-{
-	obj->static_cali[GYROHUB_AXIS_X] = dat[GYROHUB_AXIS_X];
-	obj->static_cali[GYROHUB_AXIS_Y] = dat[GYROHUB_AXIS_Y];
-	obj->static_cali[GYROHUB_AXIS_Z] = dat[GYROHUB_AXIS_Z];
-
-
-	if (atomic_read(&obj->trace) & GYRO_TRC_CALI) {
-		pr_debug("write gyro calibration data  (%5d, %5d, %5d)\n",
-			 obj->static_cali[GYROHUB_AXIS_X],
-			 obj->static_cali[GYROHUB_AXIS_Y],
-			 obj->static_cali[GYROHUB_AXIS_Z]);
-	}
-
-	return 0;
-}
-
-static int gyrohub_ResetCalibration(void)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	unsigned char buf[2] = {0};
-	int err = 0;
-
-	err = sensor_set_cmd_to_hub(ID_GYROSCOPE, CUST_ACTION_RESET_CALI, buf);
-	if (err < 0)
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_GYROSCOPE, CUST_ACTION_RESET_CALI);
-
-	memset(obj->static_cali, 0x00, sizeof(obj->static_cali));
-	pr_debug("gyro clear cali\n");
-	return err;
-}
-
-static int gyrohub_ReadCalibration(int dat[GYROHUB_AXES_NUM])
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	dat[GYROHUB_AXIS_X] = obj->static_cali[GYROHUB_AXIS_X];
-	dat[GYROHUB_AXIS_Y] = obj->static_cali[GYROHUB_AXIS_Y];
-	dat[GYROHUB_AXIS_Z] = obj->static_cali[GYROHUB_AXIS_Z];
-
-	pr_debug("Read gyro calibration data  (%5d, %5d, %5d)\n",
-		 dat[GYROHUB_AXIS_X], dat[GYROHUB_AXIS_Y], dat[GYROHUB_AXIS_Z]);
-	return 0;
-}
-
-static int gyrohub_WriteCalibration_scp(int dat[GYROHUB_AXES_NUM])
-{
-	int err = 0;
-
-	err = sensor_set_cmd_to_hub(ID_GYROSCOPE, CUST_ACTION_SET_CALI, dat);
-	if (err < 0)
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_GYROSCOPE, CUST_ACTION_SET_CALI);
-	return err;
-}
-
-static int gyrohub_WriteCalibration(int dat[GYROHUB_AXES_NUM])
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	int err = 0;
-	int cali[GYROHUB_AXES_NUM];
-
-	pr_debug("%s\n", __func__);
-
-	if (!obj || !dat) {
-		pr_err("null ptr!!\n");
-		return -EINVAL;
-	}
-
-	err = gyrohub_WriteCalibration_scp(dat);
-	if (err < 0) {
-		pr_err("gyrohub_WriteCalibration_scp fail\n");
-		return -1;
-	}
-
-	cali[GYROHUB_AXIS_X] = obj->static_cali[GYROHUB_AXIS_X];
-	cali[GYROHUB_AXIS_Y] = obj->static_cali[GYROHUB_AXIS_Y];
-	cali[GYROHUB_AXIS_Z] = obj->static_cali[GYROHUB_AXIS_Z];
-
-	cali[GYROHUB_AXIS_X] += dat[GYROHUB_AXIS_X];
-	cali[GYROHUB_AXIS_Y] += dat[GYROHUB_AXIS_Y];
-	cali[GYROHUB_AXIS_Z] += dat[GYROHUB_AXIS_Z];
-
-	pr_debug("write gyro calibration data (%5d,%5d,%5d)-->(%5d,%5d,%5d)\n",
-		 dat[GYROHUB_AXIS_X], dat[GYROHUB_AXIS_Y], dat[GYROHUB_AXIS_Z],
-		 cali[GYROHUB_AXIS_X], cali[GYROHUB_AXIS_Y],
-		 cali[GYROHUB_AXIS_Z]);
-
-	return gyrohub_write_rel_calibration(obj, cali);
-}
-#endif
-
-static int gyrohub_SetPowerMode(bool enable)
-{
-	int err = 0;
-
-	err = sensor_enable_to_hub(ID_GYROSCOPE, enable);
-	if (err < 0)
-		pr_err("sensor_enable_to_hub fail!\n");
-
-	return err;
-}
-
-static int gyrohub_ReadGyroData(char *buf, int bufsize)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-	int gyro[GYROHUB_AXES_NUM];
-	int err = 0;
-	int status = 0;
-
-	if (atomic_read(&obj->suspend))
-		return -3;
-
-	if (buf == NULL)
-		return -1;
-	err = sensor_get_data_from_hub(ID_GYROSCOPE, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!\n");
-		return err;
-	}
-
-	time_stamp				= data.time_stamp;
-	gyro[GYROHUB_AXIS_X]	= data.gyroscope_t.x;
-	gyro[GYROHUB_AXIS_Y]	= data.gyroscope_t.y;
-	gyro[GYROHUB_AXIS_Z]	= data.gyroscope_t.z;
-	status					= data.gyroscope_t.status;
-	sprintf(buf, "%04x %04x %04x %04x",
-		gyro[GYROHUB_AXIS_X],
-		gyro[GYROHUB_AXIS_Y],
-		gyro[GYROHUB_AXIS_Z],
-		status);
-
-	if (atomic_read(&obj->trace) & GYRO_TRC_DATA)
-		pr_debug("gsensor data: %s!\n", buf);
-
-	return 0;
-
-}
-
-static int gyrohub_ReadChipInfo(char *buf, int bufsize)
-{
-	u8 databuf[10];
-
-	memset(databuf, 0, sizeof(u8) * 10);
-
-	if ((buf == NULL) || (bufsize <= 30))
-		return -1;
-
-	sprintf(buf, "GYROHUB Chip");
-	return 0;
-}
-
-static int gyrohub_ReadAllReg(char *buf, int bufsize)
-{
-	int err = 0;
-
-	err = gyrohub_SetPowerMode(true);
-	if (err)
-		pr_err("Power on mpu6050 error %d!\n", err);
-	msleep(50);
-	err = sensor_set_cmd_to_hub(ID_GYROSCOPE, CUST_ACTION_SHOW_REG, buf);
-	if (err < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_GYROSCOPE, CUST_ACTION_SHOW_REG);
-		return 0;
-	}
-	return 0;
-}
-
-static ssize_t chipinfo_show(struct device_driver *ddri, char *buf)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	char strbuf[GYROHUB_BUFSIZE];
-	int err = 0;
-
-	if (obj == NULL) {
-		pr_err("obj is null!!\n");
-		return 0;
-	}
-	err = gyrohub_ReadAllReg(strbuf, GYROHUB_BUFSIZE);
-	if (err < 0) {
-		pr_debug("gyrohub_ReadAllReg fail!!\n");
-		return 0;
-	}
-	err = gyrohub_ReadChipInfo(strbuf, GYROHUB_BUFSIZE);
-	if (err < 0) {
-		pr_debug("gyrohub_ReadChipInfo fail!!\n");
-		return 0;
-	}
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-
-static ssize_t sensordata_show(struct device_driver *ddri,
-	char *buf)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	char strbuf[GYROHUB_BUFSIZE];
-	int err = 0;
-
-	if (obj == NULL) {
-		pr_err("obj is null!!\n");
-		return 0;
-	}
-
-	err = gyrohub_ReadGyroData(strbuf, GYROHUB_BUFSIZE);
-	if (err < 0) {
-		pr_debug("gyrohub_ReadGyroData fail!!\n");
-		return 0;
-	}
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-
-static ssize_t trace_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t res;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	if (obj == NULL) {
-		pr_err(" obj is null!!\n");
-		return 0;
-	}
-
-	res = snprintf(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&obj->trace));
-	return res;
-}
-
-static ssize_t trace_store(struct device_driver *ddri,
-	const char *buf, size_t count)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	int trace = 0;
-	int res = 0;
-
-	if (obj == NULL) {
-		pr_err("obj is null!!\n");
-		return 0;
-	}
-
-	if (sscanf(buf, "0x%x", &trace) != 1) {
-		pr_err("invalid content:'%s', length =%zu\n", buf, count);
-		return count;
-	}
-
-	atomic_set(&obj->trace, trace);
-	res = sensor_set_cmd_to_hub(ID_GYROSCOPE,
-		CUST_ACTION_SET_TRACE, &trace);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_GYROSCOPE, CUST_ACTION_SET_TRACE);
-		return 0;
-	}
-
-	return count;
-}
-
-static ssize_t status_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t len = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	if (obj == NULL) {
-		pr_err(" obj is null!!\n");
-		return 0;
-	}
-
-	return len;
-}
-
-static ssize_t orientation_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t _tLength = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	_tLength = snprintf(buf, PAGE_SIZE, "default direction = %d\n",
-								obj->direction);
-
-	return _tLength;
-}
-
-static ssize_t orientation_store(struct device_driver *ddri,
-	const char *buf, size_t tCount)
-{
-	int _nDirection = 0, ret = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	if (obj == NULL)
-		return 0;
-	ret = kstrtoint(buf, 10, &_nDirection);
-
-	if (ret != 0) {
-		pr_debug("[%s] set direction: %d\n", __func__, _nDirection);
-		return tCount;
-	}
-
-	obj->direction = _nDirection;
-	ret = sensor_set_cmd_to_hub(ID_GYROSCOPE,
-		CUST_ACTION_SET_DIRECTION, &_nDirection);
-	if (ret < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_GYROSCOPE, CUST_ACTION_SET_DIRECTION);
-		return 0;
-	}
-
-	pr_debug("[%s] set direction: %d\n", __func__, _nDirection);
-
-	return tCount;
-}
-
-static int gyrohub_factory_enable_calibration(void);
-static ssize_t test_cali_store(struct device_driver *ddri,
-	const char *buf, size_t tCount)
-{
-	int enable = 0, ret = 0;
-
-	ret = kstrtoint(buf, 10, &enable);
-	if (ret != 0) {
-		pr_debug("kstrtoint fail\n");
-		return 0;
-	}
-	if (enable == 1)
-		gyrohub_factory_enable_calibration();
-	return tCount;
-}
-
-static DRIVER_ATTR_RO(chipinfo);
-static DRIVER_ATTR_RO(sensordata);
-static DRIVER_ATTR_RW(trace);
-static DRIVER_ATTR_RO(status);
-static DRIVER_ATTR_RW(orientation);
-static DRIVER_ATTR_WO(test_cali);
-
-static struct driver_attribute *gyrohub_attr_list[] = {
-	&driver_attr_chipinfo,	/*chip information */
-	&driver_attr_sensordata,	/*dump sensor data */
-	&driver_attr_trace,	/*trace log */
-	&driver_attr_status,
-	&driver_attr_orientation,
-	&driver_attr_test_cali,
-};
-
-static int gyrohub_create_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(ARRAY_SIZE(gyrohub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, gyrohub_attr_list[idx]);
-		if (err != 0) {
-			pr_err("driver_create_file (%s) = %d\n",
-				gyrohub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int gyrohub_delete_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(ARRAY_SIZE(gyrohub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, gyrohub_attr_list[idx]);
-
-	return err;
-}
-
-static void scp_init_work_done(struct work_struct *work)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	int err = 0;
-#ifndef MTK_OLD_FACTORY_CALIBRATION
-	int32_t cfg_data[12] = {0};
-#endif
-
-	if (atomic_read(&obj->scp_init_done) == 0) {
-		pr_err("scp is not ready to send cmd\n");
-		return;
-	}
-	if (atomic_xchg(&obj->first_ready_after_boot, 1) == 0)
-		return;
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = gyrohub_WriteCalibration_scp(obj->static_cali);
-	if (err < 0)
-		pr_err("gyrohub_WriteCalibration_scp fail\n");
-#else
-	spin_lock(&calibration_lock);
-	cfg_data[0] = obj->dynamic_cali[0];
-	cfg_data[1] = obj->dynamic_cali[1];
-	cfg_data[2] = obj->dynamic_cali[2];
-
-	cfg_data[3] = obj->static_cali[0];
-	cfg_data[4] = obj->static_cali[1];
-	cfg_data[5] = obj->static_cali[2];
-
-	cfg_data[6] = obj->temperature_cali[0];
-	cfg_data[7] = obj->temperature_cali[1];
-	cfg_data[8] = obj->temperature_cali[2];
-	cfg_data[9] = obj->temperature_cali[3];
-	cfg_data[10] = obj->temperature_cali[4];
-	cfg_data[11] = obj->temperature_cali[5];
-	spin_unlock(&calibration_lock);
-	err = sensor_cfg_to_hub(ID_GYROSCOPE,
-		(uint8_t *)cfg_data, sizeof(cfg_data));
-	if (err < 0)
-		pr_err("sensor_cfg_to_hub fail\n");
-#endif
-}
-
-static int gyro_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	struct gyro_data data;
-
-	memset(&data, 0, sizeof(struct gyro_data));
-	if (event->flush_action == DATA_ACTION &&
-		READ_ONCE(obj->android_enable) == true) {
-		if (READ_ONCE(obj->android_enable) == false)
-			return 0;
-		data.x = event->gyroscope_t.x;
-		data.y = event->gyroscope_t.y;
-		data.z = event->gyroscope_t.z;
-		data.status = event->gyroscope_t.status;
-		data.timestamp = (int64_t)event->time_stamp;
-		data.reserved[0] = event->reserve[0];
-		err = gyro_data_report(&data);
-	} else if (event->flush_action == FLUSH_ACTION) {
-		err = gyro_flush_report();
-	} else if (event->flush_action == BIAS_ACTION) {
-		data.x = event->gyroscope_t.x_bias;
-		data.y = event->gyroscope_t.y_bias;
-		data.z = event->gyroscope_t.z_bias;
-		err = gyro_bias_report(&data);
-		spin_lock(&calibration_lock);
-		obj->dynamic_cali[GYROHUB_AXIS_X] = event->gyroscope_t.x_bias;
-		obj->dynamic_cali[GYROHUB_AXIS_Y] = event->gyroscope_t.y_bias;
-		obj->dynamic_cali[GYROHUB_AXIS_Z] = event->gyroscope_t.z_bias;
-		spin_unlock(&calibration_lock);
-	} else if (event->flush_action == CALI_ACTION) {
-		data.x = event->gyroscope_t.x_bias;
-		data.y = event->gyroscope_t.y_bias;
-		data.z = event->gyroscope_t.z_bias;
-		if (event->gyroscope_t.status == 0)
-			err = gyro_cali_report(&data);
-		spin_lock(&calibration_lock);
-		obj->static_cali[GYROHUB_AXIS_X] = event->gyroscope_t.x_bias;
-		obj->static_cali[GYROHUB_AXIS_Y] = event->gyroscope_t.y_bias;
-		obj->static_cali[GYROHUB_AXIS_Z] = event->gyroscope_t.z_bias;
-		obj->static_cali_status = (uint8_t)event->gyroscope_t.status;
-		spin_unlock(&calibration_lock);
-		complete(&obj->calibration_done);
-	} else if (event->flush_action == TEMP_ACTION) {
-		/* temp action occur when gyro disable,
-		 *so we always should send data to userspace
-		 */
-		err = gyro_temp_report(event->data);
-		spin_lock(&calibration_lock);
-		obj->temperature_cali[0] = event->data[0];
-		obj->temperature_cali[1] = event->data[1];
-		obj->temperature_cali[2] = event->data[2];
-		obj->temperature_cali[3] = event->data[3];
-		obj->temperature_cali[4] = event->data[4];
-		obj->temperature_cali[5] = event->data[5];
-		spin_unlock(&calibration_lock);
-	} else if (event->flush_action == TEST_ACTION) {
-		atomic_set(&obj->selftest_status, event->gyroscope_t.status);
-		complete(&obj->selftest_done);
-	}
-	return err;
-}
-static int gyrohub_factory_enable_sensor(bool enabledisable,
-	int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	if (enabledisable == true)
-		WRITE_ONCE(obj->factory_enable, true);
-	else
-		WRITE_ONCE(obj->factory_enable, false);
-
-	if (enabledisable == true) {
-		err = sensor_set_delay_to_hub(ID_GYROSCOPE, sample_periods_ms);
-		if (err) {
-			pr_err("sensor_set_delay_to_hub failed!\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_GYROSCOPE, enabledisable);
-	if (err) {
-		pr_err("sensor_enable_to_hub failed!\n");
-		return -1;
-	}
-	return 0;
-}
-static int gyrohub_factory_get_data(int32_t data[3], int *status)
-{
-	int ret = 0;
-
-	ret = gyrohub_get_data(&data[0], &data[1], &data[2], status);
-	data[0] = data[0] / 1000;
-	data[1] = data[1] / 1000;
-	data[2] = data[2] / 1000;
-
-	return ret;
-}
-static int gyrohub_factory_get_raw_data(int32_t data[3])
-{
-	pr_debug("%s don't support!\n", __func__);
-	return 0;
-}
-static int gyrohub_factory_enable_calibration(void)
-{
-	return sensor_calibration_to_hub(ID_GYROSCOPE);
-}
-static int gyrohub_factory_clear_cali(void)
-{
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	int err = 0;
-
-	err = gyrohub_ResetCalibration();
-	if (err) {
-		pr_err("gyrohub_ResetCalibration failed!\n");
-		return -1;
-	}
-#endif
-	return 0;
-}
-static int gyrohub_factory_set_cali(int32_t data[3])
-{
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	int err = 0;
-
-	err = gyrohub_WriteCalibration(data);
-	if (err) {
-		pr_err("gyrohub_WriteCalibration failed!\n");
-		return -1;
-	}
-#endif
-	return 0;
-}
-static int gyrohub_factory_get_cali(int32_t data[3])
-{
-	int err = 0;
-#ifndef MTK_OLD_FACTORY_CALIBRATION
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-	uint8_t status = 0;
-#endif
-
-#ifdef MTK_OLD_FACTORY_CALIBRATION
-	err = gyrohub_ReadCalibration(data);
-	if (err) {
-		pr_err("gyrohub_ReadCalibration failed!\n");
-		return -1;
-	}
-#else
-	err = wait_for_completion_timeout(&obj->calibration_done,
-		msecs_to_jiffies(3000));
-	if (!err) {
-		pr_err("%s fail!\n", __func__);
-		return -1;
-	}
-	spin_lock(&calibration_lock);
-	data[GYROHUB_AXIS_X] = obj->static_cali[GYROHUB_AXIS_X];
-	data[GYROHUB_AXIS_Y] = obj->static_cali[GYROHUB_AXIS_Y];
-	data[GYROHUB_AXIS_Z] = obj->static_cali[GYROHUB_AXIS_Z];
-	status = obj->static_cali_status;
-	spin_unlock(&calibration_lock);
-	if (status != 0) {
-		pr_debug("gyrohub static cali detect shake!\n");
-		return -2;
-	}
-#endif
-	return err;
-}
-static int gyrohub_factory_do_self_test(void)
-{
-	int ret = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	ret = sensor_selftest_to_hub(ID_GYROSCOPE);
-	if (ret < 0)
-		return -1;
-
-	ret = wait_for_completion_timeout(&obj->selftest_done,
-					  msecs_to_jiffies(3000));
-	if (!ret)
-		return -1;
-	return atomic_read(&obj->selftest_status);
-}
-
-static struct gyro_factory_fops gyrohub_factory_fops = {
-	.enable_sensor = gyrohub_factory_enable_sensor,
-	.get_data = gyrohub_factory_get_data,
-	.get_raw_data = gyrohub_factory_get_raw_data,
-	.enable_calibration = gyrohub_factory_enable_calibration,
-	.clear_cali = gyrohub_factory_clear_cali,
-	.set_cali = gyrohub_factory_set_cali,
-	.get_cali = gyrohub_factory_get_cali,
-	.do_self_test = gyrohub_factory_do_self_test,
-};
-
-static struct gyro_factory_public gyrohub_factory_device = {
-	.gain = 1,
-	.sensitivity = 1,
-	.fops = &gyrohub_factory_fops,
-};
-
-static int gyrohub_open_report_data(int open)
-{
-	return 0;
-}
-
-static int gyrohub_enable_nodata(int en)
-{
-	int res = 0;
-	bool power = false;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	if (en == 1) {
-		power = true;
-		WRITE_ONCE(obj->android_enable, true);
-	}
-	if (en == 0) {
-		power = false;
-		WRITE_ONCE(obj->android_enable, false);
-	}
-
-	res = gyrohub_SetPowerMode(power);
-	if (res < 0) {
-		pr_err("GYROHUB_SetPowerMode fail\n");
-		return res;
-	}
-	pr_debug("%s OK!\n", __func__);
-	return 0;
-
-}
-
-static int gyrohub_set_delay(u64 ns)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	int err = 0;
-	int value = 0;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	value = (int)ns / 1000 / 1000;
-	err = sensor_set_delay_to_hub(ID_GYROSCOPE, value);
-	if (err < 0) {
-		pr_err("sensor_set_delay_to_hub fail!\n");
-		return err;
-	}
-
-	pr_debug("gyro_set_delay (%d)\n", value);
-	return err;
-#elif defined CONFIG_NANOHUB
-	return 0;
-#else
-	return 0;
-#endif
-}
-static int gyrohub_batch(int flag, int64_t samplingPeriodNs,
-	int64_t maxBatchReportLatencyNs)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	gyrohub_set_delay(samplingPeriodNs);
-#endif
-	return sensor_batch_to_hub(ID_GYROSCOPE,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int gyrohub_flush(void)
-{
-	return sensor_flush_to_hub(ID_GYROSCOPE);
-}
-
-static int gyrohub_set_cali(uint8_t *data, uint8_t count)
-{
-	int32_t *buf = (int32_t *)data;
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	spin_lock(&calibration_lock);
-	obj->dynamic_cali[0] = buf[0];
-	obj->dynamic_cali[1] = buf[1];
-	obj->dynamic_cali[2] = buf[2];
-
-	obj->static_cali[0] = buf[3];
-	obj->static_cali[1] = buf[4];
-	obj->static_cali[2] = buf[5];
-
-	obj->temperature_cali[0] = buf[6];
-	obj->temperature_cali[1] = buf[7];
-	obj->temperature_cali[2] = buf[8];
-	obj->temperature_cali[3] = buf[9];
-	obj->temperature_cali[4] = buf[10];
-	obj->temperature_cali[5] = buf[11];
-	spin_unlock(&calibration_lock);
-	return sensor_cfg_to_hub(ID_GYROSCOPE, data, count);
-}
-
-static int gpio_config(void)
-{
-	int ret;
-	struct pinctrl *pinctrl;
-	struct pinctrl_state *pins_default;
-	struct pinctrl_state *pins_cfg;
-
-	if (gyroPltFmDev == NULL) {
-		pr_err("Cannot find gyro device!\n");
-		return 0;
-	}
-
-	pinctrl = devm_pinctrl_get(&gyroPltFmDev->dev);
-	if (IS_ERR(pinctrl)) {
-		ret = PTR_ERR(pinctrl);
-		pr_err("Cannot find gyro pinctrl!\n");
-		return ret;
-	}
-	pins_default = pinctrl_lookup_state(pinctrl, "pin_default");
-	if (IS_ERR(pins_default)) {
-		ret = PTR_ERR(pins_default);
-		pr_err("Cannot find gyro pinctrl default!\n");
-	}
-
-	pins_cfg = pinctrl_lookup_state(pinctrl, "pin_cfg");
-	if (IS_ERR(pins_cfg)) {
-		ret = PTR_ERR(pins_cfg);
-		pr_err("Cannot find gyro pinctrl pin_cfg!\n");
-		return ret;
-	}
-	pinctrl_select_state(pinctrl, pins_cfg);
-
-	return 0;
-}
-
-static int gyrohub_get_data(int *x, int *y, int *z, int *status)
-{
-	char buff[GYROHUB_BUFSIZE];
-	int err = 0;
-
-	err = gyrohub_ReadGyroData(buff, GYROHUB_BUFSIZE);
-	if (err < 0) {
-		pr_err("gyrohub_ReadGyroData fail!!\n");
-		return -1;
-	}
-	err = sscanf(buff, "%x %x %x %x", x, y, z, status);
-	if (err != 4) {
-		pr_err("sscanf fail!!\n");
-		return -1;
-	}
-	return 0;
-}
-static int scp_ready_event(uint8_t event, void *ptr)
-{
-	struct gyrohub_ipi_data *obj = obj_ipi_data;
-
-	switch (event) {
-	case SENSOR_POWER_UP:
-	    atomic_set(&obj->scp_init_done, 1);
-		schedule_work(&obj->init_done_work);
-		break;
-	case SENSOR_POWER_DOWN:
-	    atomic_set(&obj->scp_init_done, 0);
-		break;
-	}
-	return 0;
-}
-static struct scp_power_monitor scp_ready_notifier = {
-	.name = "gyro",
-	.notifier_call = scp_ready_event,
-};
-static int gyrohub_probe(struct platform_device *pdev)
-{
-	struct gyrohub_ipi_data *obj;
-	int err = 0;
-	struct gyro_control_path ctl = { 0 };
-	struct gyro_data_path data = { 0 };
-
-	struct platform_driver *paddr =
-					gyrohub_init_info.platform_diver_addr;
-
-	pr_debug("%s\n", __func__);
-	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	if (!obj) {
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	memset(obj, 0, sizeof(struct gyrohub_ipi_data));
-
-	obj_ipi_data = obj;
-	platform_set_drvdata(pdev, obj);
-
-	atomic_set(&obj->trace, 0);
-	atomic_set(&obj->suspend, 0);
-	atomic_set(&obj->first_ready_after_boot, 0);
-	atomic_set(&obj->scp_init_done, 0);
-	atomic_set(&obj->selftest_status, 0);
-	WRITE_ONCE(obj->factory_enable, false);
-	WRITE_ONCE(obj->android_enable, false);
-	INIT_WORK(&obj->init_done_work, scp_init_work_done);
-	init_completion(&obj->calibration_done);
-	init_completion(&obj->selftest_done);
-
-	err = gpio_config();
-	if (err < 0) {
-		pr_err("gpio_config failed\n");
-		goto exit_kfree;
-	}
-	scp_power_monitor_register(&scp_ready_notifier);
-	err = scp_sensorHub_data_registration(ID_GYROSCOPE, gyro_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = gyro_factory_device_register(&gyrohub_factory_device);
-	if (err) {
-		pr_err("gyro_factory_device_register fail err = %d\n",
-			err);
-		goto exit_kfree;
-	}
-	ctl.is_use_common_factory = true;
-
-	err = gyrohub_create_attr(&paddr->driver);
-	if (err) {
-		pr_err("gyrohub create attribute err = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-
-	ctl.open_report_data = gyrohub_open_report_data;
-	ctl.enable_nodata = gyrohub_enable_nodata;
-	ctl.set_delay = gyrohub_set_delay;
-	ctl.batch = gyrohub_batch;
-	ctl.flush = gyrohub_flush;
-	ctl.set_cali = gyrohub_set_cali;
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = false;
-#elif defined CONFIG_NANOHUB
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = true;
-#else
-#endif
-
-	err = gyro_register_control_path(&ctl);
-	if (err) {
-		pr_err("register gyro control path err\n");
-		goto exit_create_attr_failed;
-	}
-
-	data.get_data = gyrohub_get_data;
-	data.vender_div = DEGREE_TO_RAD;
-	err = gyro_register_data_path(&data);
-	if (err) {
-		pr_err("gyro_register_data_path fail = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-	gyrohub_init_flag = 0;
-
-	pr_debug("%s: OK\n", __func__);
-	return 0;
-exit_create_attr_failed:
-	gyrohub_delete_attr(&(gyrohub_init_info.platform_diver_addr->driver));
-exit_kfree:
-	kfree(obj);
-	obj_ipi_data = NULL;
-exit:
-	gyrohub_init_flag = -1;
-	pr_err("%s: err = %d\n", __func__, err);
-	return err;
-}
-
-static int gyrohub_remove(struct platform_device *pdev)
-{
-	int err = 0;
-	struct platform_driver *paddr =
-				gyrohub_init_info.platform_diver_addr;
-
-	err = gyrohub_delete_attr(&paddr->driver);
-	if (err)
-		pr_err("gyrohub_delete_attr fail: %d\n", err);
-
-	gyro_factory_device_deregister(&gyrohub_factory_device);
-
-	kfree(platform_get_drvdata(pdev));
-	return 0;
-}
-
-static int gyrohub_suspend(struct platform_device *pdev, pm_message_t msg)
-{
-	return 0;
-}
-
-static int gyrohub_resume(struct platform_device *pdev)
-{
-	return 0;
-}
-static struct platform_device gyrohub_device = {
-	.name = GYROHUB_DEV_NAME,
-	.id = -1,
-};
-static struct platform_driver gyrohub_driver = {
-	.driver = {
-		   .name = GYROHUB_DEV_NAME,
-	},
-	.probe = gyrohub_probe,
-	.remove = gyrohub_remove,
-	.suspend = gyrohub_suspend,
-	.resume = gyrohub_resume,
-};
-
-static int gyrohub_local_remove(void)
-{
-	platform_driver_unregister(&gyrohub_driver);
-	return 0;
-}
-
-static int gyrohub_local_init(struct platform_device *pdev)
-{
-	gyroPltFmDev = pdev;
-
-	if (platform_driver_register(&gyrohub_driver)) {
-		pr_err("add driver error\n");
-		return -1;
-	}
-	if (-1 == gyrohub_init_flag)
-		return -1;
-	return 0;
-}
-static struct gyro_init_info gyrohub_init_info = {
-	.name = "gyrohub",
-	.init = gyrohub_local_init,
-	.uninit = gyrohub_local_remove,
-};
-
-static int __init gyrohub_init(void)
-{
-
-	if (platform_device_register(&gyrohub_device)) {
-		pr_err("platform device error\n");
-		return -1;
-	}
-	gyro_driver_add(&gyrohub_init_info);
-
-	return 0;
-}
-
-static void __exit gyrohub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(gyrohub_init);
-module_exit(gyrohub_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("GYROHUB gyroscope driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/gyrohub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/gyrohub.h
deleted file mode 100644
index 50024e4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyrohub/gyrohub.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef GYROHUB_H
-#define GYROHUB_H
-
-#include <linux/ioctl.h>
-#include <linux/pinctrl/consumer.h>
-
-#define GYROHUB_AXIS_X          0
-#define GYROHUB_AXIS_Y          1
-#define GYROHUB_AXIS_Z          2
-#define GYROHUB_AXES_NUM        3
-#define GYROHUB_DATA_LEN        6
-#define GYROHUB_SUCCESS             0
-
-#define GYROHUB_BUFSIZE 60
-
-/* 1 rad = 180/PI degree, MAX_LSB = 131000, */
-/* 180*131000/PI = 7505747 */
-#define DEGREE_TO_RAD	7505747
-
-#endif
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyroscope.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyroscope.c
deleted file mode 100644
index ee41a0a..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/gyroscope.c
+++ /dev/null
@@ -1,917 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<GYROSCOPE> " fmt
-
-#include "inc/gyroscope.h"
-#include "sensor_performance.h"
-#include <linux/vmalloc.h>
-
-struct gyro_context *gyro_context_obj /* = NULL*/;
-static struct platform_device *pltfm_dev;
-
-static struct gyro_init_info *gyroscope_init_list[MAX_CHOOSE_GYRO_NUM] = {0};
-
-static int64_t getCurNS(void)
-{
-	int64_t ns;
-	struct timespec time;
-
-	time.tv_sec = time.tv_nsec = 0;
-	get_monotonic_boottime(&time);
-	ns = time.tv_sec * 1000000000LL + time.tv_nsec;
-
-	return ns;
-}
-
-static void initTimer(struct hrtimer *timer,
-		      enum hrtimer_restart (*callback)(struct hrtimer *))
-{
-	hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
-	timer->function = callback;
-}
-
-static void startTimer(struct hrtimer *timer, int delay_ms, bool first)
-{
-	struct gyro_context *obj = (struct gyro_context *)container_of(timer,
-		struct gyro_context, hrTimer);
-	static int count;
-
-	if (obj == NULL) {
-		pr_err("NULL pointer\n");
-		return;
-	}
-
-	if (first) {
-		obj->target_ktime =
-			ktime_add_ns(ktime_get(), (int64_t)delay_ms * 1000000);
-		count = 0;
-	} else {
-		do {
-			obj->target_ktime = ktime_add_ns(
-				obj->target_ktime, (int64_t)delay_ms * 1000000);
-		} while (ktime_to_ns(obj->target_ktime) <
-			 ktime_to_ns(ktime_get()));
-		count++;
-	}
-
-	hrtimer_start(timer, obj->target_ktime, HRTIMER_MODE_ABS);
-}
-
-#ifndef CONFIG_NANOHUB
-static void stopTimer(struct hrtimer *timer)
-{
-	hrtimer_cancel(timer);
-}
-#endif
-static void gyro_work_func(struct work_struct *work)
-{
-
-	struct gyro_context *cxt = NULL;
-	int x = 0, y = 0, z = 0, status = 0;
-	int temperature = -32768; /* =0xFFFF_8000 */
-	int64_t pre_ns, cur_ns;
-	int64_t delay_ms;
-	int err = 0;
-
-	cxt = gyro_context_obj;
-	delay_ms = atomic_read(&cxt->delay);
-
-	cur_ns = getCurNS();
-
-	/* gyro driver has register temperature path */
-	if (cxt->gyro_data.get_temperature) {
-		err = cxt->gyro_data.get_temperature(&temperature);
-		if (err)
-			pr_info("get gyro temperature fails!!\n");
-		else
-			cxt->drv_data.temperature = temperature;
-	}
-
-	/* add wake lock to make sure data can be read before system suspend */
-	if (cxt->gyro_data.get_data != NULL)
-		err = cxt->gyro_data.get_data(&x, &y, &z, &status);
-	else
-		pr_err("gyro driver not register data path\n");
-
-	if (err) {
-		pr_err("get gyro data fails!!\n");
-		goto gyro_loop;
-	} else {
-		cxt->drv_data.x = x;
-		cxt->drv_data.y = y;
-		cxt->drv_data.z = z;
-		cxt->drv_data.status = status;
-		pre_ns = cxt->drv_data.timestamp;
-		cxt->drv_data.timestamp = cur_ns;
-	}
-
-	if (true == cxt->is_first_data_after_enable) {
-		pre_ns = cur_ns;
-		cxt->is_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.x == GYRO_INVALID_VALUE ||
-		    cxt->drv_data.y == GYRO_INVALID_VALUE ||
-		    cxt->drv_data.z == GYRO_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto gyro_loop;
-		}
-	}
-
-	/* pr_debug("gyro data[%d,%d,%d]\n" ,cxt->drv_data.gyro_data.values[0],
-	 */
-	/* cxt->drv_data.gyro_data.values[1],cxt->drv_data.gyro_data.values[2]);
-	 */
-
-	while ((cur_ns - pre_ns) >= delay_ms * 1800000LL) {
-		struct gyro_data tmp_data = cxt->drv_data;
-
-		pre_ns += delay_ms * 1000000LL;
-		tmp_data.timestamp = pre_ns;
-		gyro_data_report(&tmp_data);
-	}
-
-	gyro_data_report(&cxt->drv_data);
-
-gyro_loop:
-	if (true == cxt->is_polling_run)
-		startTimer(&cxt->hrTimer, atomic_read(&cxt->delay), false);
-}
-
-enum hrtimer_restart gyro_poll(struct hrtimer *timer)
-{
-	struct gyro_context *obj = (struct gyro_context *)container_of(timer,
-		struct gyro_context, hrTimer);
-
-	queue_work(obj->gyro_workqueue, &obj->report);
-
-	/* pr_debug("cur_nt = %lld\n", getCurNT()); */
-
-	return HRTIMER_NORESTART;
-}
-
-static struct gyro_context *gyro_context_alloc_object(void)
-{
-
-	struct gyro_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc gyro object error!\n");
-		return NULL;
-	}
-	atomic_set(&obj->delay, 200); /*5Hz,  set work queue delay time 200ms */
-	atomic_set(&obj->wake, 0);
-	INIT_WORK(&obj->report, gyro_work_func);
-	obj->gyro_workqueue = NULL;
-	obj->gyro_workqueue = create_workqueue("gyro_polling");
-	if (!obj->gyro_workqueue) {
-		kfree(obj);
-		return NULL;
-	}
-	initTimer(&obj->hrTimer, gyro_poll);
-	obj->is_active_nodata = false;
-	obj->is_active_data = false;
-	obj->is_first_data_after_enable = false;
-	obj->is_polling_run = false;
-	obj->is_batch_enable = false;
-	obj->cali_sw[GYRO_AXIS_X] = 0;
-	obj->cali_sw[GYRO_AXIS_Y] = 0;
-	obj->cali_sw[GYRO_AXIS_Z] = 0;
-	obj->power = 0;
-	obj->enable = 0;
-	obj->delay_ns = -1;
-	obj->latency_ns = -1;
-	mutex_init(&obj->gyro_op_mutex);
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-
-#ifndef CONFIG_NANOHUB
-static int gyro_enable_and_batch(void)
-{
-	struct gyro_context *cxt = gyro_context_obj;
-	int err;
-
-	/* power on -> power off */
-	if (cxt->power == 1 && cxt->enable == 0) {
-		pr_debug("GYRO disable\n");
-		/* stop polling firstly, if needed */
-		if (cxt->is_active_data == false &&
-		    cxt->gyro_ctl.is_report_input_direct == false &&
-		    cxt->is_polling_run == true) {
-			smp_mb(); /* for memory barrier */
-			stopTimer(&cxt->hrTimer);
-			smp_mb(); /* for memory barrier */
-			cancel_work_sync(&cxt->report);
-			cxt->drv_data.x = GYRO_INVALID_VALUE;
-			cxt->drv_data.y = GYRO_INVALID_VALUE;
-			cxt->drv_data.z = GYRO_INVALID_VALUE;
-			cxt->drv_data.temperature = 0;
-			cxt->is_polling_run = false;
-			pr_debug("gyro stop polling done\n");
-		}
-		/* turn off the power */
-		if (cxt->is_active_data == false &&
-		    cxt->is_active_nodata == false) {
-			err = cxt->gyro_ctl.enable_nodata(0);
-			if (err) {
-				pr_err("gyro turn off power err = %d\n",
-					    err);
-				return -1;
-			}
-			pr_debug("gyro turn off power done\n");
-		}
-
-		cxt->power = 0;
-		cxt->delay_ns = -1;
-		pr_debug("GYRO disable done\n");
-		return 0;
-	}
-	/* power off -> power on */
-	if (cxt->power == 0 && cxt->enable == 1) {
-		pr_debug("GYRO enable\n");
-		if (true == cxt->is_active_data ||
-		    true == cxt->is_active_nodata) {
-			err = cxt->gyro_ctl.enable_nodata(1);
-			if (err) {
-				pr_err("gyro turn on power err = %d\n",
-					    err);
-				return -1;
-			}
-			pr_debug("gyro turn on power done\n");
-		}
-		cxt->power = 1;
-		pr_debug("GYRO enable done\n");
-	}
-	/* rate change */
-	if (cxt->power == 1 && cxt->delay_ns >= 0) {
-		pr_debug("GYRO set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->gyro_ctl.is_support_batch)
-			err = cxt->gyro_ctl.batch(0, cxt->delay_ns,
-						  cxt->latency_ns);
-		else
-			err = cxt->gyro_ctl.batch(0, cxt->delay_ns, 0);
-		if (err) {
-			pr_err("gyro set batch(ODR) err %d\n", err);
-			return -1;
-		}
-		pr_debug("gyro set ODR, fifo latency done\n");
-		/* start polling, if needed */
-		if (cxt->is_active_data == true &&
-		    cxt->gyro_ctl.is_report_input_direct == false) {
-			uint64_t mdelay = cxt->delay_ns;
-
-			do_div(mdelay, 1000000);
-			atomic_set(&cxt->delay, mdelay);
-			/* the first sensor start polling timer */
-			if (cxt->is_polling_run == false) {
-				cxt->is_polling_run = true;
-				cxt->is_first_data_after_enable = true;
-				startTimer(&cxt->hrTimer,
-					   atomic_read(&cxt->delay), true);
-			}
-			pr_debug("gyro set polling delay %d ms\n",
-				 atomic_read(&cxt->delay));
-		}
-		pr_debug("GYRO batch done\n");
-	}
-	return 0;
-}
-#endif
-static ssize_t gyroenablenodata_show(struct device *dev,
-				       struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-static ssize_t gyroenablenodata_store(struct device *dev,
-					struct device_attribute *attr,
-					const char *buf, size_t count)
-{
-	struct gyro_context *cxt = gyro_context_obj;
-	int err = 0;
-
-	pr_debug("gyro_store_enable nodata buf=%s\n", buf);
-	mutex_lock(&gyro_context_obj->gyro_op_mutex);
-	if (!strncmp(buf, "1", 1)) {
-		cxt->enable = 1;
-		cxt->is_active_nodata = true;
-	} else if (!strncmp(buf, "0", 1)) {
-		cxt->enable = 0;
-		cxt->is_active_nodata = false;
-	} else {
-		pr_info(" gyro_store enable nodata cmd error !!\n");
-		err = -1;
-		goto err_out;
-	}
-#ifdef CONFIG_NANOHUB
-	if (true == cxt->is_active_data || true == cxt->is_active_nodata) {
-		err = cxt->gyro_ctl.enable_nodata(1);
-		if (err) {
-			pr_err("gyro turn on power err = %d\n", err);
-			goto err_out;
-		}
-		pr_debug("gyro turn on power done\n");
-	} else {
-		err = cxt->gyro_ctl.enable_nodata(0);
-		if (err) {
-			pr_err("gyro turn off power err = %d\n", err);
-			goto err_out;
-		}
-		pr_debug("gyro turn off power done\n");
-	}
-#else
-	err = gyro_enable_and_batch();
-#endif
-
-err_out:
-	mutex_unlock(&gyro_context_obj->gyro_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t gyroactive_store(struct device *dev,
-				 struct device_attribute *attr, const char *buf,
-				 size_t count)
-{
-	struct gyro_context *cxt = gyro_context_obj;
-	int err = 0;
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&gyro_context_obj->gyro_op_mutex);
-	if (!strncmp(buf, "1", 1)) {
-		cxt->enable = 1;
-		cxt->is_active_data = true;
-	} else if (!strncmp(buf, "0", 1)) {
-		cxt->enable = 0;
-		cxt->is_active_data = false;
-	} else {
-		pr_err("%s error !!\n", __func__);
-		err = -1;
-		goto err_out;
-	}
-#ifdef CONFIG_NANOHUB
-	if (true == cxt->is_active_data || true == cxt->is_active_nodata) {
-		err = cxt->gyro_ctl.enable_nodata(1);
-		if (err) {
-			pr_err("gyro turn on power err = %d\n", err);
-			goto err_out;
-		}
-		pr_debug("gyro turn on power done\n");
-	} else {
-		err = cxt->gyro_ctl.enable_nodata(0);
-		if (err) {
-			pr_err("gyro turn off power err = %d\n", err);
-			goto err_out;
-		}
-		pr_debug("gyro turn off power done\n");
-	}
-#else
-	err = gyro_enable_and_batch();
-#endif
-err_out:
-	mutex_unlock(&gyro_context_obj->gyro_op_mutex);
-	pr_debug("%s done\n", __func__);
-	if (err)
-		return err;
-	else
-		return count;
-}
-/*----------------------------------------------------------------------------*/
-static ssize_t gyroactive_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	struct gyro_context *cxt = NULL;
-	int div = 0;
-
-	cxt = gyro_context_obj;
-
-	pr_debug("gyro show active not support now\n");
-	div = cxt->gyro_data.vender_div;
-	pr_debug("gyro vender_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-static ssize_t gyrobatch_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct gyro_context *cxt = gyro_context_obj;
-	int handle = 0, flag = 0, err = 0;
-
-	pr_debug("%s %s\n", __func__, buf);
-	err = sscanf(buf, "%d,%d,%lld,%lld", &handle, &flag, &cxt->delay_ns,
-		     &cxt->latency_ns);
-	if (err != 4) {
-		pr_info("%s param error: err = %d\n", __func__, err);
-		return -1;
-	}
-
-	mutex_lock(&gyro_context_obj->gyro_op_mutex);
-#ifdef CONFIG_NANOHUB
-	if (cxt->gyro_ctl.is_support_batch)
-		err = cxt->gyro_ctl.batch(0, cxt->delay_ns, cxt->latency_ns);
-	else
-		err = cxt->gyro_ctl.batch(0, cxt->delay_ns, 0);
-	if (err)
-		pr_err("gyro set batch(ODR) err %d\n", err);
-#else
-	err = gyro_enable_and_batch();
-#endif
-	mutex_unlock(&gyro_context_obj->gyro_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t gyrobatch_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t gyroflush_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct gyro_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_info("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&gyro_context_obj->gyro_op_mutex);
-	cxt = gyro_context_obj;
-	if (cxt->gyro_ctl.flush != NULL)
-		err = cxt->gyro_ctl.flush();
-	else
-		pr_info(
-			"GYRO DRIVER OLD ARCHITECTURE DON'T SUPPORT GYRO COMMON VERSION FLUSH\n");
-	if (err < 0)
-		pr_info("gyro enable flush err %d\n", err);
-	mutex_unlock(&gyro_context_obj->gyro_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t gyroflush_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-static ssize_t gyrocali_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t gyrocali_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct gyro_context *cxt = NULL;
-	int err = 0;
-	uint8_t *cali_buf = NULL;
-
-	cali_buf = vzalloc(count);
-	if (cali_buf == NULL)
-		return -EFAULT;
-	memcpy(cali_buf, buf, count);
-
-	mutex_lock(&gyro_context_obj->gyro_op_mutex);
-	cxt = gyro_context_obj;
-	if (cxt->gyro_ctl.set_cali != NULL)
-		err = cxt->gyro_ctl.set_cali(cali_buf, count);
-	else
-		pr_info(
-			"GYRO DRIVER OLD ARCHITECTURE DON'T SUPPORT GYRO COMMON VERSION FLUSH\n");
-	if (err < 0)
-		pr_info("gyro set cali err %d\n", err);
-	mutex_unlock(&gyro_context_obj->gyro_op_mutex);
-	vfree(cali_buf);
-	return count;
-}
-
-/* need work around again */
-static ssize_t gyrodevnum_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-static int gyroscope_remove(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int gyroscope_probe(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	pltfm_dev = pdev;
-	return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id gyroscope_of_match[] = {
-	{
-		.compatible = "mediatek,gyroscope",
-	},
-	{},
-};
-#endif
-
-static struct platform_driver gyroscope_driver = {
-	.probe = gyroscope_probe,
-	.remove = gyroscope_remove,
-	.driver = {
-		.name = "gyroscope",
-#ifdef CONFIG_OF
-		.of_match_table = gyroscope_of_match,
-#endif
-	}
-};
-
-static int gyro_real_driver_init(struct platform_device *pdev)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_GYRO_NUM; i++) {
-		pr_debug("i=%d\n", i);
-		if (gyroscope_init_list[i] != 0) {
-			pr_debug("gyro try to init driver %s\n",
-				 gyroscope_init_list[i]->name);
-			err = gyroscope_init_list[i]->init(pdev);
-			if (err == 0) {
-				pr_debug("gyro real driver %s probe ok\n",
-					 gyroscope_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_GYRO_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-
-int gyro_driver_add(struct gyro_init_info *obj)
-{
-	int err = 0;
-	int i = 0;
-
-	if (!obj) {
-		pr_err("%s fail, gyro_init_info is NULL\n", __func__);
-		return -1;
-	}
-
-	for (i = 0; i < MAX_CHOOSE_GYRO_NUM; i++) {
-		if ((i == 0) && (gyroscope_init_list[0] == NULL)) {
-			pr_debug("register gyro driver for the first time\n");
-			if (platform_driver_register(&gyroscope_driver))
-				pr_err(
-					"failed to register gyro driver already exist\n");
-		}
-
-		if (gyroscope_init_list[i] == NULL) {
-			obj->platform_diver_addr = &gyroscope_driver;
-			gyroscope_init_list[i] = obj;
-			break;
-		}
-	}
-
-	if (i >= MAX_CHOOSE_GYRO_NUM) {
-		pr_err("gyro driver add err\n");
-		err = -1;
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_driver_add);
-static int gyroscope_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t gyroscope_read(struct file *file, char __user *buffer,
-			      size_t count, loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(gyro_context_obj->mdev.minor, file, buffer,
-				     count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int gyroscope_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(gyro_context_obj->mdev.minor, file, wait);
-}
-
-static const struct file_operations gyroscope_fops = {
-	.owner = THIS_MODULE,
-	.open = gyroscope_open,
-	.read = gyroscope_read,
-	.poll = gyroscope_poll,
-};
-
-static int gyro_misc_init(struct gyro_context *cxt)
-{
-	int err = 0;
-
-	cxt->mdev.minor = ID_GYROSCOPE;
-	cxt->mdev.name = GYRO_MISC_DEV_NAME;
-	cxt->mdev.fops = &gyroscope_fops;
-	err = sensor_attr_register(&cxt->mdev);
-	if (err)
-		pr_err("unable to register gyro misc device!!\n");
-
-	return err;
-}
-DEVICE_ATTR_RW(gyroenablenodata);
-DEVICE_ATTR_RW(gyroactive);
-DEVICE_ATTR_RW(gyrobatch);
-DEVICE_ATTR_RW(gyroflush);
-DEVICE_ATTR_RW(gyrocali);
-DEVICE_ATTR_RO(gyrodevnum);
-
-static struct attribute *gyro_attributes[] = {
-	&dev_attr_gyroenablenodata.attr,
-	&dev_attr_gyroactive.attr,
-	&dev_attr_gyrobatch.attr,
-	&dev_attr_gyroflush.attr,
-	&dev_attr_gyrocali.attr,
-	&dev_attr_gyrodevnum.attr,
-	NULL
-};
-
-static struct attribute_group gyro_attribute_group = {
-	.attrs = gyro_attributes
-};
-
-int gyro_register_data_path(struct gyro_data_path *data)
-{
-	struct gyro_context *cxt = NULL;
-
-	cxt = gyro_context_obj;
-	cxt->gyro_data.get_data = data->get_data;
-	cxt->gyro_data.get_temperature = data->get_temperature;
-	cxt->gyro_data.vender_div = data->vender_div;
-	cxt->gyro_data.get_raw_data = data->get_raw_data;
-	pr_debug("gyro register data path vender_div: %d\n",
-		 cxt->gyro_data.vender_div);
-	if (cxt->gyro_data.get_data == NULL) {
-		pr_debug("gyro register data path fail\n");
-		return -1;
-	}
-	if (cxt->gyro_data.get_temperature == NULL)
-		pr_debug("gyro not register temperature path\n");
-	return 0;
-}
-EXPORT_SYMBOL_GPL(gyro_register_data_path);
-
-int gyro_register_control_path(struct gyro_control_path *ctl)
-{
-	struct gyro_context *cxt = NULL;
-	int err = 0;
-
-	cxt = gyro_context_obj;
-	cxt->gyro_ctl.set_delay = ctl->set_delay;
-	cxt->gyro_ctl.open_report_data = ctl->open_report_data;
-	cxt->gyro_ctl.enable_nodata = ctl->enable_nodata;
-	cxt->gyro_ctl.batch = ctl->batch;
-	cxt->gyro_ctl.flush = ctl->flush;
-	cxt->gyro_ctl.set_cali = ctl->set_cali;
-	cxt->gyro_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->gyro_ctl.is_use_common_factory = ctl->is_use_common_factory;
-	cxt->gyro_ctl.is_report_input_direct = ctl->is_report_input_direct;
-	if (cxt->gyro_ctl.batch == NULL ||
-	    cxt->gyro_ctl.open_report_data == NULL ||
-	    cxt->gyro_ctl.enable_nodata == NULL) {
-		pr_debug("gyro register control path fail\n");
-		return -1;
-	}
-
-	/* add misc dev for sensor hal control cmd */
-	err = gyro_misc_init(gyro_context_obj);
-	if (err) {
-		pr_info("unable to register gyro misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&gyro_context_obj->mdev.this_device->kobj,
-				 &gyro_attribute_group);
-	if (err < 0) {
-		pr_info("unable to create gyro attribute file\n");
-		return -3;
-	}
-
-	kobject_uevent(&gyro_context_obj->mdev.this_device->kobj, KOBJ_ADD);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(gyro_register_control_path);
-
-int x_t /* = 0*/;
-int y_t /* = 0*/;
-int z_t /* = 0*/;
-long pc /* = 0*/;
-
-static int check_repeat_data(int x, int y, int z)
-{
-	if ((x_t == x) && (y_t == y) && (z_t == z))
-		pc++;
-	else
-		pc = 0;
-
-	x_t = x;
-	y_t = y;
-	z_t = z;
-
-	if (pc > 100) {
-		pr_info("Gyro sensor output repeat data\n");
-		pc = 0;
-	}
-
-	return 0;
-}
-
-int gyro_data_report(struct gyro_data *data)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	check_repeat_data(data->x, data->y, data->z);
-	event.time_stamp = data->timestamp;
-	event.flush_action = DATA_ACTION;
-	event.status = data->status;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-	event.word[3] = data->temperature;
-	event.reserved = data->reserved[0];
-
-	if (event.reserved == 1)
-		mark_timestamp(ID_GYROSCOPE, DATA_REPORT, ktime_get_boot_ns(),
-			       event.time_stamp);
-	err = sensor_input_event(gyro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_data_report);
-
-int gyro_bias_report(struct gyro_data *data)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = BIAS_ACTION;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-
-	err = sensor_input_event(gyro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_bias_report);
-
-int gyro_cali_report(struct gyro_data *data)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = CALI_ACTION;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-
-	err = sensor_input_event(gyro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_cali_report);
-
-int gyro_temp_report(int32_t *temp)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = TEMP_ACTION;
-	event.word[0] = temp[0];
-	event.word[1] = temp[1];
-	event.word[2] = temp[2];
-	event.word[3] = temp[3];
-	event.word[4] = temp[4];
-	event.word[5] = temp[5];
-
-	err = sensor_input_event(gyro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_temp_report);
-
-int gyro_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	pr_debug_ratelimited("flush\n");
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(gyro_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_flush_report);
-
-int gyro_probe(void)
-{
-
-	int err;
-
-	pr_debug("%s +++!!\n", __func__);
-
-	gyro_context_obj = gyro_context_alloc_object();
-	if (!gyro_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-
-	/* init real gyroeleration driver */
-	err = gyro_real_driver_init(pltfm_dev);
-	if (err) {
-		pr_err("gyro real driver init fail\n");
-		goto real_driver_init_fail;
-	}
-	pr_debug("%s OK !!\n", __func__);
-	return 0;
-
-real_driver_init_fail:
-	kfree(gyro_context_obj);
-
-exit_alloc_data_failed:
-	pr_err("%s--- fail !!!\n", __func__);
-	return err;
-}
-EXPORT_SYMBOL_GPL(gyro_probe);
-
-int gyro_remove(void)
-{
-	int err = 0;
-
-	sysfs_remove_group(&gyro_context_obj->mdev.this_device->kobj,
-			   &gyro_attribute_group);
-	err = sensor_attr_deregister(&gyro_context_obj->mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-
-	kfree(gyro_context_obj);
-
-	platform_driver_unregister(&gyroscope_driver);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(gyro_remove);
-
-static int __init gyro_init(void)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static void __exit gyro_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(gyro_init);
-module_exit(gyro_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("GYROSCOPE device driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/cust_gyro.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/cust_gyro.h
deleted file mode 100644
index 6c2d76b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/cust_gyro.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __CUST_GYRO_H__
-#define __CUST_GYRO_H__
-
-#include <linux/types.h>
-#include <linux/of.h>
-
-#define GYRO_CUST_I2C_ADDR_NUM 2
-
-struct gyro_hw {
-	unsigned short addr;
-	int i2c_num;	/*!< the i2c bus used by the chip */
-	int direction;  /*!< the direction of the chip */
-	int power_id;
-	int power_vol;  /*!< the Power Voltage used by the chip */
-	int firlen;	 /*!< the length of low pass filter */
-	int (*power)(struct gyro_hw *hw, unsigned int on, char *devname);
-	unsigned char	i2c_addr[GYRO_CUST_I2C_ADDR_NUM];
-	int power_vio_id;
-	int power_vio_vol;  /*!< the Power Voltage used by the chip */
-	bool is_batch_supported;
-};
-
-int get_gyro_dts_func(struct device_node *node, struct gyro_hw *hw);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/gyro_factory.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/gyro_factory.h
deleted file mode 100644
index 666e4d1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/gyro_factory.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __GYRO_FACTORY_H__
-#define __GYRO_FACTORY_H__
-
-#include "cust_gyro.h"
-#include "gyroscope.h"
-
-struct gyro_factory_fops {
-	int (*enable_sensor)(bool enable_disable, int64_t sample_periods_ms);
-	int (*get_data)(int32_t data[3], int *status);
-	int (*get_raw_data)(int32_t data[3]);
-	int (*enable_calibration)(void);
-	int (*clear_cali)(void);
-	int (*set_cali)(int32_t offset[3]);
-	int (*get_cali)(int32_t offset[3]);
-	int (*do_self_test)(void);
-};
-
-struct gyro_factory_public {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct gyro_factory_fops *fops;
-};
-int gyro_factory_device_register(struct gyro_factory_public *dev);
-int gyro_factory_device_deregister(struct gyro_factory_public *dev);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/gyroscope.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/gyroscope.h
deleted file mode 100644
index 99cb38e..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/gyroscope/inc/gyroscope.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __GYROSCOPE_H__
-#define __GYROSCOPE_H__
-
-//#include <linux/wakelock.h>
-#include "sensor_attr.h"
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-#include <linux/atomic.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/kernel.h>
-#include <linux/kobject.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/poll.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/workqueue.h>
-#include <sensors_io.h>
-
-#include "gyro_factory.h"
-#include "sensor_event.h"
-
-#ifndef FALSE
-#define FALSE (0)
-#endif
-#ifndef TRUE
-#define TRUE (1)
-#endif
-
-#define OP_GYRO_DELAY 0X01
-#define OP_GYRO_ENABLE 0X02
-#define OP_GYRO_GET_DATA 0X04
-#define GYRO_INVALID_VALUE -1
-#define EVENT_TYPE_GYRO_X ABS_X
-#define EVENT_TYPE_GYRO_Y ABS_Y
-#define EVENT_TYPE_GYRO_Z ABS_Z
-#define EVENT_TYPE_GYRO_TEMPERATURE ABS_MISC
-#define EVENT_TYPE_GYRO_UPDATE REL_X
-#define EVENT_TYPE_GYRO_STATUS ABS_WHEEL
-#define EVENT_TYPE_GYRO_UPDATE REL_X
-#define EVENT_TYPE_GYRO_TIMESTAMP_HI REL_HWHEEL
-#define EVENT_TYPE_GYRO_TIMESTAMP_LO REL_DIAL
-
-#define GYRO_VALUE_MAX (32767)
-#define GYRO_VALUE_MIN (-32768)
-#define GYRO_STATUS_MIN (0)
-#define GYRO_STATUS_MAX (64)
-#define GYRO_DIV_MAX (32767)
-#define GYRO_DIV_MIN (1)
-#define GYRO_AXIS_X 0
-#define GYRO_AXIS_Y 1
-#define GYRO_AXIS_Z 2
-#define MAX_CHOOSE_GYRO_NUM 5
-#define GYRO_AXES_NUM 3
-
-struct gyro_control_path {
-	int (*open_report_data)(int open);
-	int (*enable_nodata)(int en);
-	int (*set_delay)(u64 delay);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		     int64_t maxBatchReportLatencyNs);
-	int (*flush)(void);
-	int (*set_cali)(uint8_t *data, uint8_t count);
-	bool is_report_input_direct;
-	bool is_support_batch;
-	bool is_use_common_factory;
-};
-
-struct gyro_data_path {
-	int (*get_data)(int *x, int *y, int *z, int *status);
-	int (*get_raw_data)(int *x, int *y, int *z);
-	int (*get_temperature)(int *temperature);
-	int vender_div;
-};
-
-struct gyro_init_info {
-	char *name;
-	int (*init)(struct platform_device *pdev);
-	int (*uninit)(void);
-	struct platform_driver *platform_diver_addr;
-};
-
-struct gyro_data {
-	int8_t status;
-	int8_t reserved[3];
-	int x;
-	int y;
-	int z;
-	int64_t timestamp;
-	int temperature;
-	void *reserved1;
-};
-
-struct gyro_drv_obj {
-	void *self;
-	int polling;
-	int (*gyro_operate)(void *self, uint32_t command, void *buff_in,
-			    int size_in, void *buff_out, int size_out,
-			    int *actualout);
-};
-
-struct gyro_context {
-	struct input_dev *idev;
-	struct sensor_attr_t mdev;
-	struct work_struct report;
-	struct mutex gyro_op_mutex;
-	atomic_t delay; /*polling period for reporting input event*/
-	atomic_t wake;  /*user-space request to wake-up, used with stop*/
-	struct timer_list timer; /* polling timer */
-	struct hrtimer hrTimer;
-	ktime_t target_ktime;
-	atomic_t trace;
-	struct workqueue_struct *gyro_workqueue;
-	struct gyro_data drv_data;
-	int cali_sw[GYRO_AXES_NUM + 1];
-	struct gyro_control_path gyro_ctl;
-	struct gyro_data_path gyro_data;
-	/*Active, but HAL don't need data sensor. such as  orientation need*/
-	bool is_active_nodata;
-	bool is_active_data;   /* Active and HAL need data .*/
-	bool is_first_data_after_enable;
-	bool is_polling_run;
-	bool is_batch_enable;
-	int power;
-	int enable;
-	int64_t delay_ns;
-	int64_t latency_ns;
-};
-
-extern int gyro_driver_add(struct gyro_init_info *obj);
-extern int gyro_data_report(struct gyro_data *data);
-extern int gyro_bias_report(struct gyro_data *data);
-extern int gyro_cali_report(struct gyro_data *data);
-extern int gyro_temp_report(int32_t *temp);
-extern int gyro_flush_report(void);
-extern int gyro_register_control_path(struct gyro_control_path *ctl);
-extern int gyro_register_data_path(struct gyro_data_path *data);
-extern int gyro_probe(void);
-extern int gyro_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/Kconfig
deleted file mode 100644
index 33af1c9..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/Kconfig
+++ /dev/null
@@ -1,4 +0,0 @@
-config MTK_HWMON
-	bool "MTK HWMON Config"
-	help
-	  CONFIG_MTK_HWMON for sensor common util
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/Makefile
deleted file mode 100644
index 07f6552..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/Makefile
+++ /dev/null
@@ -1,15 +0,0 @@
-ifneq ($CONFIG_MTK_SENSOR_SUPPORT), n)
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) += hwmon.o
-hwmon-$(CONFIG_MTK_SENSOR_SUPPORT) := sensor_event/sensor_event.o \
-        sensor_attributes/sensor_attr.o \
-        hwmsen/hwmsen_helper.o \
-        sensor_performance/sensor_performance.o
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) += sensor_list/sensor_list.o
-
-else
-obj-n := hwmsen/
-endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/hwmsen/hwmsen_helper.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/hwmsen/hwmsen_helper.c
deleted file mode 100644
index ba261d8..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/hwmsen/hwmsen_helper.c
+++ /dev/null
@@ -1,599 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<HWMSEN> "fmt
-
-#include <generated/autoconf.h>
-#include <linux/atomic.h>
-#include <linux/ctype.h>
-#include <linux/device.h>
-#include <linux/hwmon-sysfs.h>
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/spinlock.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-
-#define hex2int(c) ((c >= '0') && (c <= '9') ? (c - '0') : ((c & 0xf) + 9))
-
-#define C_MAX_REG_LEN (4)
-
-int hwmsen_set_bits(struct i2c_client *client, u8 addr, u8 bits)
-{
-	int err;
-	u8 cur, nxt;
-
-	err = hwmsen_read_byte(client, addr, &cur);
-	if (err) {
-		pr_debug("read err: 0x%02X\n", addr);
-		return -EFAULT;
-	}
-
-	nxt = (cur | bits);
-
-	if (nxt ^ cur) {
-		err = hwmsen_write_byte(client, addr, nxt);
-		if (err) {
-			pr_debug("write err: 0x%02X\n", addr);
-			return -EFAULT;
-		}
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(hwmsen_set_bits);
-
-int hwmsen_clr_bits(struct i2c_client *client, u8 addr, u8 bits)
-{
-	int err;
-	u8 cur, nxt;
-
-	err = hwmsen_read_byte(client, addr, &cur);
-	if (err) {
-		pr_debug("read err: 0x%02X\n", addr);
-		return -EFAULT;
-	}
-
-	nxt = cur & (~bits);
-
-	if (nxt ^ cur) {
-		err = hwmsen_write_byte(client, addr, nxt);
-		if (err) {
-			pr_debug("write err: 0x%02X\n", addr);
-			return -EFAULT;
-		}
-	}
-	return 0;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_clr_bits);
-/*----------------------------------------------------------------------------*/
-int hwmsen_read_byte(struct i2c_client *client, u8 addr, u8 *data)
-{
-	u8 beg = addr;
-	int err;
-	struct i2c_msg msgs[2] = {
-		{
-			.flags = 0,
-			.len = 1,
-			.buf = &beg
-		},
-		{
-			.flags = I2C_M_RD,
-			.len = 1,
-			.buf = data,
-		}
-	};
-
-	if (!client)
-		return -EINVAL;
-
-	msgs[0].addr = client->addr;
-	msgs[1].addr = client->addr;
-
-	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-	if (err != 2) {
-		pr_debug("i2c_transfer error: (%d %p) %d\n", addr, data, err);
-		err = -EIO;
-	}
-
-	err = 0;
-
-	return err;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_read_byte);
-/*----------------------------------------------------------------------------*/
-int hwmsen_write_byte(struct i2c_client *client, u8 addr, u8 data)
-{
-	u8 buf[] = {addr, data};
-	int ret = 0;
-
-	ret = i2c_master_send(client, (const char *)buf, sizeof(buf));
-	if (ret < 0) {
-		pr_debug("send command error!!\n");
-		return -EFAULT;
-	}
-#if defined(HWMSEN_DEBUG)
-	pr_debug("%s(0x%02X)= %02X\n", __func__, addr, data);
-#endif
-
-	return 0;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_write_byte);
-/*----------------------------------------------------------------------------*/
-int hwmsen_read_block(struct i2c_client *client, u8 addr, u8 *data, u8 len)
-{
-	u8 beg = addr;
-	int err;
-	struct i2c_msg msgs[2] = {{0}, {0} };
-
-	if (!client)
-		return -EINVAL;
-	else if (len > C_I2C_FIFO_SIZE) {
-		pr_debug(" length %d exceeds %d\n", len, C_I2C_FIFO_SIZE);
-		return -EINVAL;
-	}
-
-	if (len == 1)
-		return hwmsen_read_byte(client, addr, data);
-
-	msgs[0].addr = client->addr;
-	msgs[0].flags = 0;
-	msgs[0].len = 1;
-	msgs[0].buf = &beg;
-
-	msgs[1].addr = client->addr;
-	msgs[1].flags = I2C_M_RD;
-	msgs[1].len = len;
-	msgs[1].buf = data;
-
-	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-	if (err != 2) {
-		pr_debug("i2c_transfer error: (%d %p %d) %d\n", addr, data, len,
-			err);
-		err = -EIO;
-	}
-#if defined(HWMSEN_DEBUG)
-	static char buf[128];
-	int idx, buflen = 0;
-
-	for (idx = 0; idx < len; idx++)
-		buflen += snprintf(buf + buflen, sizeof(buf) - buflen, "%02X ",
-				   data[idx]);
-	pr_debug("%s(0x%02X,%2d) = %s\n", __func__, addr, len, buf);
-#endif
-	err = 0; /*no error*/
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(hwmsen_read_block);
-/*----------------------------------------------------------------------------*/
-int hwmsen_write_block(struct i2c_client *client, u8 addr, u8 *data, u8 len)
-{
-	int err, idx, num;
-	char buf[C_I2C_FIFO_SIZE];
-
-	if (!client)
-		return -EINVAL;
-	else if (len >= C_I2C_FIFO_SIZE) {
-		pr_debug(" length %d exceeds %d\n", len, C_I2C_FIFO_SIZE);
-		return -EINVAL;
-	}
-
-	num = 0;
-	buf[num++] = addr;
-	for (idx = 0; idx < len; idx++)
-		buf[num++] = data[idx];
-
-	err = i2c_master_send(client, buf, num);
-	if (err < 0) {
-		pr_debug("send command error!!\n");
-		return -EFAULT;
-	}
-#if defined(HWMSEN_DEBUG)
-	static char buf[128];
-	int idx, buflen = 0;
-
-	for (idx = 0; idx < len; idx++)
-		buflen += snprintf(buf + buflen, sizeof(buf) - buflen, "%02X ",
-				   data[idx]);
-	pr_debug("%s(0x%02X,%2d)= %s\n", __func__, addr, len, buf);
-#endif
-	err = 0; /*no error*/
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(hwmsen_write_block);
-/*----------------------------------------------------------------------------*/
-static int hwmsen_chrs_to_integer(u8 dat[C_MAX_REG_LEN], int datlen)
-{
-	int idx;
-	u32 val = 0;
-
-	for (idx = 0; idx < datlen; idx++)
-		val += (dat[idx] << (8 * idx));
-	return val;
-}
-/*----------------------------------------------------------------------------*/
-static int hwmsen_byte_to_integer(u8 dat, int datlen)
-{
-	int idx;
-	u32 val = 0;
-
-	for (idx = 0; idx < datlen; idx++)
-		val += (dat << (8 * idx));
-	return val;
-}
-/*----------------------------------------------------------------------------*/
-void hwmsen_single_rw(struct i2c_client *client, struct hwmsen_reg *regs,
-		      int reg_num)
-{
-	int idx, pos, num, err = 0, cmp1, cmp2;
-	u8 pattern[] = {0x55, 0xAA};
-	u8 old[C_MAX_REG_LEN], val[C_MAX_REG_LEN], mask;
-	struct hwmsen_reg *ptr;
-
-	for (idx = 0; idx < reg_num; idx++) {
-		if (regs[idx].mode != REG_RW)
-			continue;
-		if (regs[idx].len > C_MAX_REG_LEN) {
-			pr_debug("exceed maximum length\n");
-			continue;
-		}
-		ptr = &regs[idx];
-
-		err = hwmsen_read_block(client, ptr->addr, old, ptr->len);
-		if (err) {
-			pr_debug("read %s fails\n", ptr->name);
-			continue;
-		}
-		for (pos = 0; pos < ARRAY_SIZE(pattern); pos++) {
-			mask = ptr->mask;
-			for (num = 0; num < ptr->len; num++)
-				val[num] = pattern[pos] & mask;
-			err = hwmsen_write_block(client, ptr->addr, val,
-						 ptr->len);
-			if (err) {
-				pr_debug("test: write %s fails, pat[0x%02X]\n",
-					ptr->name, pattern[pos]);
-				continue;
-			}
-			err = hwmsen_read_block(client, ptr->addr, val,
-						ptr->len);
-			if (err) {
-				pr_debug("test: read %s fails\n", ptr->name);
-				continue;
-			}
-
-			cmp1 = hwmsen_chrs_to_integer(val, ptr->len);
-			cmp2 = hwmsen_byte_to_integer(pattern[pos], ptr->len);
-			if ((cmp1 ^ cmp2) & ptr->mask)
-				pr_debug("test: reg %s[%d] 0x%08X <-> 0x%08X\n",
-					ptr->name, num, cmp1, cmp2);
-		}
-
-		err = hwmsen_write_block(client, ptr->addr, old, ptr->len);
-		if (err) {
-			pr_debug("restore: write %s\n", ptr->name);
-			continue;
-		}
-
-		err = hwmsen_read_block(client, ptr->addr, val, ptr->len);
-		if (err) {
-			pr_debug("restore: read %s\n", ptr->name);
-			continue;
-		}
-
-		cmp1 = hwmsen_chrs_to_integer(val, ptr->len);
-		cmp2 = hwmsen_chrs_to_integer(old, ptr->len);
-		if ((cmp1 ^ cmp2) & ptr->mask) {
-			pr_debug("restore %s fails\n", ptr->name);
-			err = -EFAULT;
-		}
-	}
-	if (!err)
-		pr_debug("%s pass!!\n", __func__);
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_single_rw);
-/*----------------------------------------------------------------------------*/
-void hwmsen_multi_rw(struct i2c_client *client, find_reg_t findreg,
-		     struct hwmsen_reg_test_multi *items, int inum)
-{
-	u8 pattern[] = {0x55, 0xAA};
-	u8 buf[C_I2C_FIFO_SIZE], dat[C_I2C_FIFO_SIZE], old[C_I2C_FIFO_SIZE];
-	int pos, idx, p, err = 0;
-
-	for (idx = 0; idx < inum; idx++) {
-		u8 addr = items[idx].addr;
-		u8 len = items[idx].len;
-		u8 mode = items[idx].mode;
-
-		for (pos = 0; pos < ARRAY_SIZE(pattern); pos++) {
-			err = hwmsen_read_block(client, addr, old, len);
-			if (err) {
-				pr_debug("(%d) save block fail!!\n", idx);
-				continue;
-			}
-			if (!(mode & REG_WO))
-				continue;
-
-			memset(buf, pattern[pos], sizeof(buf));
-			for (p = 0; p < len; p++)
-				buf[p] = buf[p] & findreg(addr + p)->mask;
-			err = hwmsen_write_block(client, addr, buf, len);
-			if (err) {
-				pr_debug("(%d) block write fail!!\n", idx);
-				continue;
-			}
-			memset(dat, 0x00, sizeof(dat));
-			err = hwmsen_read_block(client, addr, dat, len);
-			if (err) {
-				pr_debug("(%d) block read fail!!\n", idx);
-				continue;
-			}
-			err = hwmsen_write_block(client, addr, old, len);
-			if (err) {
-				pr_debug("(%d) restore block fail!!\n", idx);
-				continue;
-			}
-
-			if (memcmp(buf, dat, len)) {
-				pr_debug("(%d) data compare fail!!\n", idx);
-				pr_debug("buf:");
-				for (p = 0; p < len; p++)
-					pr_debug("%02X", buf[p]);
-				pr_debug("\n");
-				pr_debug("dat:");
-				for (p = 0; p < len; p++)
-					pr_debug("%02X", dat[p]);
-				pr_debug("\n");
-				err = 1;
-			}
-		}
-	}
-	if (!err)
-		pr_debug("%s success : %d cases\n", __func__, inum);
-	else
-		pr_debug("%s: %d cases\n", __func__, inum);
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_multi_rw);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_show_dump(struct i2c_client *client, u8 startAddr, u8 *regtbl,
-			 u32 regnum, find_reg_t findreg, char *buf, u32 buflen)
-{
-	int err = 0;
-	u8 addr = startAddr;
-	u8 max_len = 8, read_len;
-	const char *name = NULL;
-
-	if (!client)
-		return -EINVAL;
-
-	memset(regtbl, 0x00, regnum);
-
-	do {
-		read_len = ((regnum - addr) > max_len) ? (max_len)
-						       : (regnum - addr);
-		if (!read_len)
-			break;
-
-		err = hwmsen_read_block(client, addr, &regtbl[addr - startAddr],
-					read_len);
-		if (!err)
-			addr += read_len;
-		/* SEN_VER("read block data: %d %d\n", addr, read_len); */
-	} while (!err);
-
-	if (!err) {
-		int idx;
-		ssize_t len = 0;
-
-		for (idx = startAddr; idx < regnum; idx++) {
-			name = findreg(idx)->name;
-			if (name != NULL)
-				len += snprintf(buf + len, buflen - len,
-						"%-16s = 0x%02X\n", name,
-						regtbl[idx - startAddr]);
-		}
-		return len;
-	}
-	return 0;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_show_dump);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_read_all_regs(struct i2c_client *client, struct hwmsen_reg *regs,
-			     u32 num, char *buf, u32 buflen)
-{
-	int err = 0, pos, idx, val;
-	struct hwmsen_reg *ptr;
-	u8 dat[4];
-	ssize_t len = 0;
-
-	if (!client)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		ptr = &regs[idx];
-		memset(dat, 0x00, sizeof(dat));
-		if (ptr->len > sizeof(dat)) {
-			pr_debug("exceeds capacity, %d\n", ptr->len);
-			break;
-		}
-		err = hwmsen_read_block(client, ptr->addr, dat, ptr->len);
-		if (err) {
-			pr_debug("read reg %s (0x%2X) fail!!\n", ptr->name,
-				ptr->addr);
-			break;
-		}
-
-		val = 0;
-		for (pos = 0; pos < ptr->len; pos++)
-			val += (dat[pos] << (8 * pos));
-		len += snprintf(buf + len, buflen - len, "%-16s = %8X\n",
-				ptr->name, val);
-	}
-	return (err) ? (0) : len;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_read_all_regs);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_show_reg(struct i2c_client *client, u8 addr, char *buf,
-			u32 buflen)
-{
-	u8 data = 0;
-	int err;
-
-	err = hwmsen_read_byte(client, addr, &data);
-	if (err) {
-		pr_debug("reading address 0x%02X fail!!", addr);
-		return 0;
-	} else
-		return snprintf(buf, buflen, "0x%02X\n", data);
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_show_reg);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_store_reg(struct i2c_client *client, u8 addr, const char *buf,
-			 size_t count)
-{
-	int err, val;
-	u8 data;
-
-	err = kstrtoint(buf, 16, &val);
-	if (err != 0) {
-		pr_debug("format not match: (0xAB) <-> '%s'\n", buf);
-		return count;
-	}
-	data = (u8)val;
-
-	err = hwmsen_write_byte(client, addr, data);
-	if (err)
-		pr_debug("write address 0x%02X fail!!\n", addr);
-	return count;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_store_reg);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_show_byte(struct device *dev, struct device_attribute *attr,
-			 char *buf, u32 buflen)
-{
-	int err, index = to_sensor_dev_attr(attr)->index;
-	struct i2c_client *client = to_i2c_client(dev);
-	u8 addr = (u8)index;
-	u8 dat;
-
-	err = hwmsen_read_byte(client, addr, &dat);
-	if (err) {
-		pr_debug("reading address 0x%02X fail!!", addr);
-		return 0;
-	}
-	return snprintf(buf, buflen, "0x%02X\n", dat);
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_show_byte);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_store_byte(struct device *dev, struct device_attribute *attr,
-			  const char *buf, size_t count)
-{
-	int err, val;
-	int index = to_sensor_dev_attr(attr)->index;
-	struct i2c_client *client = to_i2c_client(dev);
-	u8 addr = (u8)index;
-	u8 dat;
-
-	err = kstrtoint(buf, 16, &val);
-	if (err != 0) {
-		pr_debug("format not match: (0xAB) <-> '%s'\n", buf);
-		return count;
-	}
-	dat = (u8)val;
-
-	err = hwmsen_write_byte(client, addr, dat);
-	if (err)
-		pr_debug("write address 0x%02X fail!!\n", addr);
-	return count;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_store_byte);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_show_word(struct device *dev, struct device_attribute *attr,
-			 char *buf, u32 buflen)
-{
-	int err, index = to_sensor_dev_attr(attr)->index;
-	struct i2c_client *client = to_i2c_client(dev);
-	u8 addr = (u8)index;
-	u8 dat[2];
-
-	err = hwmsen_read_block(client, addr, dat, sizeof(dat));
-	if (err) {
-		pr_debug("reading address 0x%02X fail!!", addr);
-		return 0;
-	}
-	return snprintf(buf, buflen, "0x%04X\n", (dat[0] | (dat[1] << 8)));
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_show_word);
-/*----------------------------------------------------------------------------*/
-ssize_t hwmsen_store_word(struct device *dev, struct device_attribute *attr,
-			  const char *buf, size_t count)
-{
-	int err, val;
-	int index = to_sensor_dev_attr(attr)->index;
-	struct i2c_client *client = to_i2c_client(dev);
-	u8 addr = (u8)index;
-	u8 dat[2];
-
-	err = kstrtoint(buf, 16, &val);
-	if (err != 0) {
-		pr_debug("format not match: (0xAB) <-> '%s'\n", buf);
-		return count;
-	}
-	dat[0] = (u8)((val & 0x00FF));
-	dat[1] = (u8)((val & 0xFF00) >> 8);
-
-	err = hwmsen_write_block(client, addr, dat, sizeof(dat));
-	if (err)
-		pr_debug("write address 0x%02X fail!!\n", addr);
-	return count;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_store_word);
-/*----------------------------------------------------------------------------*/
-struct hwmsen_convert map[] = {
-	{ { 1, 1, 1}, {0, 1, 2} },
-	{ {-1, 1, 1}, {1, 0, 2} },
-	{ {-1, -1, 1}, {0, 1, 2} },
-	{ { 1, -1, 1}, {1, 0, 2} },
-
-	{ {-1, 1, -1}, {0, 1, 2} },
-	{ { 1, 1, -1}, {1, 0, 2} },
-	{ { 1, -1, -1}, {0, 1, 2} },
-	{ {-1, -1, -1}, {1, 0, 2} },
-
-};
-/*----------------------------------------------------------------------------*/
-int hwmsen_get_convert(int direction, struct hwmsen_convert *cvt)
-{
-	if (!cvt)
-		return -EINVAL;
-	else if (direction >= ARRAY_SIZE(map))
-		return -EINVAL;
-
-	*cvt = map[direction];
-	return 0;
-}
-/*----------------------------------------------------------------------------*/
-EXPORT_SYMBOL_GPL(hwmsen_get_convert);
-/*----------------------------------------------------------------------------*/
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/hwmsen_helper.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/hwmsen_helper.h
deleted file mode 100644
index ff9c39c..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/hwmsen_helper.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#include "hwmsensor.h"
-#include <linux/i2c.h>
-#include <linux/types.h>
-#ifndef __HWMSEN_HELPER_H__
-#define __HWMSEN_HELPER_H__
-
-#define C_I2C_FIFO_SIZE 8 /*according i2c_mt6516.c */
-
-struct hwmsen_reg {
-	const char *name;
-	u16 addr;
-	u16 mode;
-	u16 mask;
-	u16 len;
-};
-/*----------------------------------------------------------------------------*/
-#define HWMSEN_DUMMY_REG(X)                                                    \
-{                                                                      \
-	NULL, X, REG_NA, 0x00, 0                                       \
-}
-/*----------------------------------------------------------------------------*/
-struct hwmsen_reg_test_multi {
-	u8 addr;
-	u8 len;
-	u8 mode;
-	u8 _align;
-};
-/*----------------------------------------------------------------------------*/
-enum {
-REG_NA = 0x0000,
-REG_RO = 0x0001,
-REG_WO = 0x0002,
-REG_LK = 0x0004, /*lcoked, register test will by-pass this register */
-REG_RW = REG_RO | REG_WO,
-};
-/*----------------------------------------------------------------------------*/
-/*
- * @sign, map: only used in accelerometer/magnetic field
- *      sometimes, the sensor output need to be remapped before reporting to
- * framework.
- *      the 'sign' is only -1 or +1 to align the sign for framework's coordinate
- * system
- *      the 'map'  align the value for framework's coordinate system. Take
- * accelerometer
- *      as an example:
- *      assume HAL receives original acceleration: acc[] = {100, 0, 100}
- *      sign[] = {1, -1, 1, 0};
- *      map[]  = {HWM_CODE_ACC_Y, HWM_CODE_ACC_X, HWM_CODE_ACC_Z, 0};
- *      according to the above 'sign' & 'map', the sensor output need to remap
- * as {y, -x, z}:
- *      float resolution = unit_numerator*GRAVITY_EARTH/unit_denominator;
- *      acc_x = sign[0]*acc[map[0]]*resolution;
- *      acc_y = sign[1]*acc[map[1]]*resolution;
- *      acc_z = sign[2]*acc[map[2]]*resolution;
- */
-struct hwmsen_convert {
-	s8 sign[C_MAX_HWMSEN_EVENT_NUM];
-	u8 map[C_MAX_HWMSEN_EVENT_NUM];
-};
-/*----------------------------------------------------------------------------*/
-struct hwmsen_conf {
-	/*output sensitivity of sensor data */
-	s32 sensitivity[C_MAX_HWMSEN_EVENT_NUM];
-	int num;
-};
-/*----------------------------------------------------------------------------*/
-typedef struct hwmsen_reg *(*find_reg_t)(int reg_idx);
-/*----------------------------------------------------------------------------*/
-extern int hwmsen_set_bits(struct i2c_client *client, u8 addr, u8 bits);
-extern int hwmsen_clr_bits(struct i2c_client *client, u8 addr, u8 bits);
-extern int hwmsen_read_byte(struct i2c_client *client, u8 addr, u8 *data);
-extern int hwmsen_write_byte(struct i2c_client *client, u8 addr, u8 data);
-extern int hwmsen_read_block(struct i2c_client *client, u8 addr, u8 *data,
-			     u8 len);
-extern int hwmsen_write_block(struct i2c_client *client, u8 addr, u8 *data,
-			      u8 len);
-extern void hwmsen_single_rw(struct i2c_client *client, struct hwmsen_reg *regs,
-			     int num);
-extern void hwmsen_multi_rw(struct i2c_client *client, find_reg_t findreg,
-			    struct hwmsen_reg_test_multi *items, int inum);
-extern ssize_t hwmsen_show_dump(struct i2c_client *client, u8 startAddr,
-				u8 *regtbl, u32 regnum, find_reg_t findreg,
-				char *buf, u32 buflen);
-extern ssize_t hwmsen_read_all_regs(struct i2c_client *client,
-				    struct hwmsen_reg *regs, u32 num, char *buf,
-				    u32 buflen);
-extern ssize_t hwmsen_show_reg(struct i2c_client *client, u8 addr, char *buf,
-			       u32 buflen);
-extern ssize_t hwmsen_store_reg(struct i2c_client *client, u8 addr,
-				const char *buf, size_t count);
-extern ssize_t hwmsen_show_byte(struct device *dev,
-				struct device_attribute *attr, char *buf,
-				u32 buflen);
-extern ssize_t hwmsen_store_byte(struct device *dev,
-				 struct device_attribute *attr, const char *buf,
-				 size_t count);
-extern ssize_t hwmsen_show_word(struct device *dev,
-				struct device_attribute *attr, char *buf,
-				u32 buflen);
-extern ssize_t hwmsen_store_word(struct device *dev,
-				 struct device_attribute *attr, const char *buf,
-				 size_t count);
-extern int hwmsen_get_convert(int direction, struct hwmsen_convert *cvt);
-/*----------------------------------------------------------------------------*/
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/hwmsensor.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/hwmsensor.h
deleted file mode 100644
index 283b16b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/hwmsensor.h
+++ /dev/null
@@ -1,438 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __HWMSENSOR_H__
-#define __HWMSENSOR_H__
-
-#include <linux/ioctl.h>
-#include <linux/types.h>
-#ifdef CONFIG_COMPAT
-#include <linux/compat.h>
-#endif
-/* follow google default sensor type */
-#define SENSOR_TYPE_ACCELEROMETER                      1
-#define SENSOR_TYPE_MAGNETIC_FIELD                     2
-#define SENSOR_TYPE_ORIENTATION                        3
-#define SENSOR_TYPE_GYROSCOPE                          4
-#define SENSOR_TYPE_LIGHT                              5
-#define SENSOR_TYPE_PRESSURE                           6
-#define SENSOR_TYPE_TEMPERATURE                        7
-#define SENSOR_TYPE_PROXIMITY                          8
-#define SENSOR_TYPE_GRAVITY                            9
-#define SENSOR_TYPE_LINEAR_ACCELERATION                10
-#define SENSOR_TYPE_ROTATION_VECTOR                    11
-#define SENSOR_TYPE_RELATIVE_HUMIDITY                  12
-#define SENSOR_TYPE_AMBIENT_TEMPERATURE                13
-#define SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED        14
-#define SENSOR_TYPE_GAME_ROTATION_VECTOR               15
-#define SENSOR_TYPE_GYROSCOPE_UNCALIBRATED             16
-#define SENSOR_TYPE_SIGNIFICANT_MOTION                 17
-#define SENSOR_TYPE_STEP_DETECTOR                      18
-#define SENSOR_TYPE_STEP_COUNTER                       19
-#define SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR        20
-#define SENSOR_TYPE_HEART_RATE                         21
-#define SENSOR_TYPE_TILT_DETECTOR                      22
-#define SENSOR_TYPE_WAKE_GESTURE                       23
-#define SENSOR_TYPE_GLANCE_GESTURE                     24
-#define SENSOR_TYPE_PICK_UP_GESTURE                    25
-#define SENSOR_TYPE_WRIST_TILT_GESTURE                 26
-#define SENSOR_TYPE_DEVICE_ORIENTATION                 27
-#define SENSOR_TYPE_POSE_6DOF                          28
-#define SENSOR_TYPE_STATIONARY_DETECT                  29
-#define SENSOR_TYPE_MOTION_DETECT                      30
-#define SENSOR_TYPE_HEART_BEAT                         31
-#define SENSOR_TYPE_DYNAMIC_SENSOR_META                32
-#define SENSOR_TYPE_ADDITIONAL_INFO                    33
-#define SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT         34
-#define SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED         35
-
-
-/* follow mtk add sensor type */
-#define SENSOR_TYPE_PEDOMETER                          55
-#define SENSOR_TYPE_IN_POCKET                          56
-#define SENSOR_TYPE_ACTIVITY                           57
-#define SENSOR_TYPE_PDR                                58
-#define SENSOR_TYPE_FREEFALL                           59
-#define SENSOR_TYPE_FLAT                               60
-#define SENSOR_TYPE_FACE_DOWN                          61
-#define SENSOR_TYPE_SHAKE                              62
-#define SENSOR_TYPE_BRINGTOSEE                         63
-#define SENSOR_TYPE_ANSWER_CALL                        64
-#define SENSOR_TYPE_GEOFENCE                           65
-#define SENSOR_TYPE_FLOOR_COUNTER                      66
-#define SENSOR_TYPE_EKG                                67
-#define SENSOR_TYPE_PPG1                               68
-#define SENSOR_TYPE_PPG2                               69
-#define SENSOR_TYPE_RGBW                               70
-#define SENSOR_TYPE_GYRO_TEMPERATURE                   71
-#define SENSOR_TYPE_SAR                                72
-/* end sensor type */
-#define SENSOR_TYPE_MAX_NUM                            SENSOR_TYPE_SAR
-#define SENSOR_TYPE_MAX_NUM_PLUS_ONE                   (SENSOR_TYPE_MAX_NUM + 1)
-
-/*---------------------------------------------------------------------------*/
-#define ID_BASE                 (0)
-#define ID_OFFSET               (1)
-/* follow google default sensor ID */
-#define ID_ACCELEROMETER        (ID_BASE + SENSOR_TYPE_ACCELEROMETER - 1)
-#define ID_MAGNETIC             (ID_BASE + SENSOR_TYPE_MAGNETIC_FIELD - 1)
-#define ID_ORIENTATION          (ID_BASE + SENSOR_TYPE_ORIENTATION - 1)
-#define ID_GYROSCOPE            (ID_BASE + SENSOR_TYPE_GYROSCOPE - 1)
-#define ID_LIGHT                (ID_BASE + SENSOR_TYPE_LIGHT - 1)
-#define ID_PRESSURE             (ID_BASE + SENSOR_TYPE_PRESSURE - 1)
-#define ID_TEMPRERATURE         (ID_BASE + SENSOR_TYPE_TEMPERATURE - 1)
-#define ID_PROXIMITY            (ID_BASE + SENSOR_TYPE_PROXIMITY - 1)
-#define ID_GRAVITY              (ID_BASE + SENSOR_TYPE_GRAVITY - 1)
-#define ID_LINEAR_ACCELERATION  (ID_BASE + SENSOR_TYPE_LINEAR_ACCELERATION - 1)
-#define ID_ROTATION_VECTOR      (ID_BASE + SENSOR_TYPE_ROTATION_VECTOR - 1)
-#define ID_RELATIVE_HUMIDITY    (ID_BASE + SENSOR_TYPE_RELATIVE_HUMIDITY - 1)
-#define ID_AMBIENT_TEMPERATURE  (ID_BASE + SENSOR_TYPE_AMBIENT_TEMPERATURE - 1)
-#define ID_MAGNETIC_UNCALIBRATED        \
-		(ID_BASE + SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED - 1)
-#define ID_GAME_ROTATION_VECTOR         \
-		(ID_BASE + SENSOR_TYPE_GAME_ROTATION_VECTOR - 1)
-#define ID_GYROSCOPE_UNCALIBRATED       \
-		(ID_BASE + SENSOR_TYPE_GYROSCOPE_UNCALIBRATED - 1)
-#define ID_SIGNIFICANT_MOTION           \
-		(ID_BASE + SENSOR_TYPE_SIGNIFICANT_MOTION - 1)
-#define ID_STEP_DETECTOR                \
-		(ID_BASE + SENSOR_TYPE_STEP_DETECTOR - 1)
-#define ID_STEP_COUNTER                 \
-		(ID_BASE + SENSOR_TYPE_STEP_COUNTER - 1)
-#define ID_GEOMAGNETIC_ROTATION_VECTOR  \
-		(ID_BASE + SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR - 1)
-#define ID_HEART_RATE           (ID_BASE + SENSOR_TYPE_HEART_RATE - 1)
-#define ID_TILT_DETECTOR        (ID_BASE + SENSOR_TYPE_TILT_DETECTOR - 1)
-#define ID_WAKE_GESTURE         (ID_BASE + SENSOR_TYPE_WAKE_GESTURE - 1)
-#define ID_GLANCE_GESTURE       (ID_BASE + SENSOR_TYPE_GLANCE_GESTURE - 1)
-#define ID_PICK_UP_GESTURE      (ID_BASE + SENSOR_TYPE_PICK_UP_GESTURE - 1)
-#define ID_WRIST_TITL_GESTURE   (ID_BASE + SENSOR_TYPE_WRIST_TILT_GESTURE - 1)
-#define ID_DEVICE_ORIENTATION   (ID_BASE + SENSOR_TYPE_DEVICE_ORIENTATION - 1)
-#define ID_POSE_6DOF            (ID_BASE + SENSOR_TYPE_POSE_6DOF - 1)
-#define ID_STATIONARY_DETECT    (ID_BASE + SENSOR_TYPE_STATIONARY_DETECT - 1)
-#define ID_MOTION_DETECT        (ID_BASE + SENSOR_TYPE_MOTION_DETECT - 1)
-#define ID_HEART_BEAT           (ID_BASE + SENSOR_TYPE_HEART_BEAT - 1)
-#define ID_DYNAMIC_SENSOR_META  (ID_BASE + SENSOR_TYPE_DYNAMIC_SENSOR_META - 1)
-#define ID_ADDITIONAL_INFO      (ID_BASE + SENSOR_TYPE_ADDITIONAL_INFO - 1)
-#define ID_LOW_LATENCY_OFFBODY_DETECT   \
-		(ID_BASE + SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT - 1)
-#define ID_ACCELEROMETER_UNCALIBRATED   \
-		(ID_BASE + SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED - 1)
-
-
-/* follow mtk add sensor ID */
-#define ID_PEDOMETER            (ID_BASE + SENSOR_TYPE_PEDOMETER - 1)
-#define ID_IN_POCKET            (ID_BASE + SENSOR_TYPE_IN_POCKET - 1)
-#define ID_ACTIVITY             (ID_BASE + SENSOR_TYPE_ACTIVITY - 1)
-#define ID_PDR                  (ID_BASE + SENSOR_TYPE_PDR - 1)
-#define ID_FREEFALL             (ID_BASE + SENSOR_TYPE_FREEFALL - 1)
-#define ID_FLAT                 (ID_BASE + SENSOR_TYPE_FLAT - 1)
-#define ID_FACE_DOWN            (ID_BASE + SENSOR_TYPE_FACE_DOWN - 1)
-#define ID_SHAKE                (ID_BASE + SENSOR_TYPE_SHAKE - 1)
-#define ID_BRINGTOSEE           (ID_BASE + SENSOR_TYPE_BRINGTOSEE - 1)
-#define ID_ANSWER_CALL          (ID_BASE + SENSOR_TYPE_ANSWER_CALL - 1)
-#define ID_GEOFENCE             (ID_BASE + SENSOR_TYPE_GEOFENCE - 1)
-#define ID_FLOOR_COUNTER        (ID_BASE + SENSOR_TYPE_FLOOR_COUNTER - 1)
-#define ID_EKG                  (ID_BASE + SENSOR_TYPE_EKG - 1)
-#define ID_PPG1                 (ID_BASE + SENSOR_TYPE_PPG1 - 1)
-#define ID_PPG2                 (ID_BASE + SENSOR_TYPE_PPG2 - 1)
-#define ID_RGBW                 (ID_BASE + SENSOR_TYPE_RGBW - 1)
-#define ID_GYRO_TEMPERATURE     (ID_BASE + SENSOR_TYPE_GYRO_TEMPERATURE - 1)
-#define ID_SAR                  (ID_BASE + SENSOR_TYPE_SAR - 1)
-/* end sensor ID */
-#define ID_SENSOR_MAX_HANDLE    (ID_SAR)
-#define ID_SENSOR_MAX_HANDLE_PLUS_ONE    (ID_SENSOR_MAX_HANDLE + 1)
-
-#if (ID_SENSOR_MAX_HANDLE_PLUS_ONE != SENSOR_TYPE_MAX_NUM)
-#error ID_SENSOR_MAX_HANDLE not match with SENSOR_TYPE_MAX_NUM
-#endif
-
-#define MAX_SENSOR_DATA_UPDATE_ONCE (20)
-
-/*----------------------------------------------------------------------------*/
-#define HWM_INPUTDEV_NAME "hwmdata"
-#define HWM_SENSOR_DEV_NAME "hwmsensor"
-#define HWM_SENSOR_DEV "/dev/hwmsensor"
-#define C_MAX_HWMSEN_EVENT_NUM 4
-/*----------------------------------------------------------------------------*/
-#define ACC_PL_DEV_NAME "m_acc_pl"
-#define ACC_INPUTDEV_NAME "m_acc_input"
-#define ACC_MISC_DEV_NAME "m_acc_misc"
-#define MAG_PL_DEV_NAME "m_mag_pl"
-#define MAG_INPUTDEV_NAME "m_mag_input"
-#define MAG_MISC_DEV_NAME "m_mag_misc"
-#define UNCALI_MAG_PL_DEV_NAME "m_uncali_mag_pl"
-#define UNCALI_MAG_INPUTDEV_NAME "m_uncali_mag_input"
-#define UNCALI_MAG_MISC_DEV_NAME "m_uncali_mag_misc"
-#define UNCALI_GYRO_PL_DEV_NAME "m_uncali_gyro_pl"
-#define UNCALI_GYRO_INPUTDEV_NAME "m_uncali_gyro_input"
-#define UNCALI_GYRO_MISC_DEV_NAME "m_uncali_gyro_misc"
-#define GYRO_PL_DEV_NAME "m_gyro_pl"
-#define GYRO_INPUTDEV_NAME "m_gyro_input"
-#define GYRO_MISC_DEV_NAME "m_gyro_misc"
-#define ALSPS_PL_DEV_NAME "m_alsps_pl"
-#define ALSPS_INPUTDEV_NAME "m_alsps_input"
-#define ALS_MISC_DEV_NAME "m_als_misc"
-#define PS_MISC_DEV_NAME "m_ps_misc"
-#define BARO_PL_DEV_NAME "m_baro_pl"
-#define BARO_INPUTDEV_NAME "m_baro_input"
-#define BARO_MISC_DEV_NAME "m_baro_misc"
-#define HMDY_PL_DEV_NAME "m_hmdy_pl"
-#define HMDY_INPUTDEV_NAME "m_hmdy_input"
-#define HMDY_MISC_DEV_NAME "m_hmdy_misc"
-
-#define STEP_C_PL_DEV_NAME "m_step_c_pl"
-#define STEP_C_INPUTDEV_NAME "m_step_c_input"
-#define STEP_C_MISC_DEV_NAME "m_step_c_misc"
-
-#define INPK_PL_DEV_NAME "m_inpk_pl"
-#define INPK_INPUTDEV_NAME "m_inpk_input"
-#define INPK_MISC_DEV_NAME "m_inpk_misc"
-
-#define SHK_PL_DEV_NAME "m_shk_pl"
-#define SHK_INPUTDEV_NAME "m_shk_input"
-#define SHK_MISC_DEV_NAME "m_shk_misc"
-
-#define FDN_PL_DEV_NAME "m_fdn_pl"
-#define FDN_INPUTDEV_NAME "m_fdn_input"
-#define FDN_MISC_DEV_NAME "m_fdn_misc"
-
-#define PKUP_PL_DEV_NAME "m_pkup_pl"
-#define PKUP_INPUTDEV_NAME "m_pkup_input"
-#define PKUP_MISC_DEV_NAME "m_pkup_misc"
-
-#define ACT_PL_DEV_NAME "m_act_pl"
-#define ACT_INPUTDEV_NAME "m_act_input"
-#define ACT_MISC_DEV_NAME "m_act_misc"
-
-#define PDR_PL_DEV_NAME "m_pdr_pl"
-#define PDR_INPUTDEV_NAME "m_pdr_input"
-#define PDR_MISC_DEV_NAME "m_pdr_misc"
-
-#define HRM_PL_DEV_NAME "m_hrm_pl"
-#define HRM_INPUTDEV_NAME "m_hrm_input"
-#define HRM_MISC_DEV_NAME "m_hrm_misc"
-
-#define TILT_PL_DEV_NAME "m_tilt_pl"
-#define TILT_INPUTDEV_NAME "m_tilt_input"
-#define TILT_MISC_DEV_NAME "m_tilt_misc"
-
-#define WAG_PL_DEV_NAME "m_wag_pl"
-#define WAG_INPUTDEV_NAME "m_wag_input"
-#define WAG_MISC_DEV_NAME "m_wag_misc"
-
-#define GLG_PL_DEV_NAME "m_glg_pl"
-#define GLG_INPUTDEV_NAME "m_glg_input"
-#define GLG_MISC_DEV_NAME "m_glg_misc"
-
-#define ANSWERCALL_PL_DEV_NAME "m_ancall_pl"
-#define ANSWERCALL_INPUTDEV_NAME "m_ancall_input"
-#define ANSWERCALL_MISC_DEV_NAME "m_ancall_misc"
-
-#define TEMP_PL_DEV_NAME "m_temp_pl"
-#define TEMP_INPUTDEV_NAME "m_temp_input"
-#define TEMP_MISC_DEV_NAME "m_temp_misc"
-
-#define BATCH_PL_DEV_NAME "m_batch_pl"
-#define BATCH_INPUTDEV_NAME "m_batch_input"
-#define BATCH_MISC_DEV_NAME "m_batch_misc"
-
-#define BTS_PL_DEV_NAME "m_bts_pl"
-#define BTS_INPUTDEV_NAME "m_bts_input"
-#define BTS_MISC_DEV_NAME "m_bts_misc"
-
-#define GRV_PL_DEV_NAME "m_grv_pl"
-#define GRV_INPUTDEV_NAME "m_grv_input"
-#define GRV_MISC_DEV_NAME "m_grv_misc"
-
-#define GMRV_PL_DEV_NAME "m_gmrv_pl"
-#define GMRV_INPUTDEV_NAME "m_gmrv_input"
-#define GMRV_MISC_DEV_NAME "m_gmrv_misc"
-
-#define GRAV_PL_DEV_NAME "m_grav_pl"
-#define GRAV_INPUTDEV_NAME "m_grav_input"
-#define GRAV_MISC_DEV_NAME "m_grav_misc"
-
-#define LA_PL_DEV_NAME "m_la_pl"
-#define LA_INPUTDEV_NAME "m_la_input"
-#define LA_MISC_DEV_NAME "m_la_misc"
-
-#define RV_PL_DEV_NAME "m_rv_pl"
-#define RV_INPUTDEV_NAME "m_rv_input"
-#define RV_MISC_DEV_NAME "m_rv_misc"
-
-#define FUSION_PL_DEV_NAME "m_fusion_pl"
-#define FUSION_INPUTDEV_NAME "m_fusion_input"
-#define FUSION_MISC_DEV_NAME "m_fusion_misc"
-
-#define FREEFALL_PL_DEV_NAME "m_frfl_pl"
-#define FREEFALL_INPUTDEV_NAME "m_frfl_input"
-#define FREEFALL_MISC_DEV_NAME "m_frfl_misc"
-
-#define PEDO_PL_DEV_NAME "m_pedo_pl"
-#define PEDO_INPUTDEV_NAME "m_pedo_input"
-#define PEDO_MISC_DEV_NAME "m_pedo_misc"
-
-#define SITU_PL_DEV_NAME "m_situ_pl"
-#define SITU_INPUTDEV_NAME "m_situ_input"
-#define SITU_MISC_DEV_NAME "m_situ_misc"
-
-#define BIO_MISC_DEV_NAME "m_bio_misc"
-
-#define EVENT_TYPE_SENSOR 0x01
-#define EVENT_TYPE_SENSOR_EXT 0x02
-#define EVENT_SENSOR_ACCELERATION SENSOR_ACCELEROMETER
-#define EVENT_SENSOR_MAGNETIC SENSOR_MAGNETIC
-#define EVENT_SENSOR_ORIENTATION SENSOR_ORIENTATION
-#define EVENT_SENSOR_GYROSCOPE SENSOR_GYROSCOPE
-#define EVENT_SENSOR_LIGHT SENSOR_LIGHT
-#define EVENT_SENSOR_PRESSURE SENSOR_PRESSURE
-#define EVENT_SENSOR_TEMPERATURE SENSOR_TEMPRERATURE
-#define EVENT_SENSOR_PROXIMITY SENSOR_PROXIMITY
-#define EVENT_SENSOR_GRAVITY SENSOR_PRESSURE
-#define EVENT_SENSOR_LINEAR_ACCELERATION SENSOR_TEMPRERATURE
-#define EVENT_SENSOR_ROTATION_VECTOR SENSOR_PROXIMITY
-#define EVENT_TYPE_INPK_VALUE 0x1
-#define EVENT_TYPE_STATIONARY_VALUE 0x2
-
-enum { HWM_MODE_DISABLE = 0,
-	HWM_MODE_ENABLE = 1,
-};
-
-struct hwm_sensor_data {
-	/* sensor identifier */
-	int sensor;
-	/* sensor values */
-	union {
-		int values[6];
-		uint8_t probability[12];
-	};
-	/* sensor values divide */
-	uint32_t value_divide;
-	/* sensor accuracy */
-	int8_t status;
-	/* whether updata? */
-	int update;
-	/* time is in nanosecond */
-	int64_t time;
-
-	uint32_t reserved;
-};
-
-#ifdef CONFIG_COMPAT
-struct compat_hwm_sensor_data {
-	/* sensor identifier */
-	compat_int_t sensor;
-	/* sensor values */
-	union {
-		compat_int_t values[6];
-		uint8_t probability[12];
-	};
-	/* sensor values divide */
-	compat_uint_t value_divide;
-	/* sensor accuracy */
-	char status;
-	/* whether updata? */
-	compat_int_t update;
-	/* time is in nanosecond */
-	compat_s64 time;
-
-	compat_uint_t reserved;
-};
-#endif
-
-struct hwm_trans_data {
-	struct hwm_sensor_data data[MAX_SENSOR_DATA_UPDATE_ONCE];
-	uint64_t data_type;
-};
-
-#ifdef CONFIG_COMPAT
-struct compat_hwm_trans_data {
-	struct compat_hwm_sensor_data data[MAX_SENSOR_DATA_UPDATE_ONCE];
-	compat_u64 data_type;
-};
-#endif
-
-#define MAX_BATCH_DATA_PER_QUREY 18
-struct batch_trans_data {
-	int numOfDataReturn;
-	int numOfDataLeft;
-	struct hwm_sensor_data data[MAX_BATCH_DATA_PER_QUREY];
-};
-
-#ifdef CONFIG_COMPAT
-struct compat_batch_trans_data {
-	compat_int_t numOfDataReturn;
-	compat_int_t numOfDataLeft;
-	struct compat_hwm_sensor_data data[MAX_BATCH_DATA_PER_QUREY];
-};
-#endif
-
-/*----------------------------------------------------------------------------*/
-#define HWM_IOC_MAGIC 0x91
-
-/* set delay */
-#define HWM_IO_SET_DELAY _IOW(HWM_IOC_MAGIC, 0x01, uint32_t)
-
-/* wake up */
-#define HWM_IO_SET_WAKE _IO(HWM_IOC_MAGIC, 0x02)
-
-/* Enable/Disable  sensor */
-#define HWM_IO_ENABLE_SENSOR _IOW(HWM_IOC_MAGIC, 0x03, uint32_t)
-#define HWM_IO_DISABLE_SENSOR _IOW(HWM_IOC_MAGIC, 0x04, uint32_t)
-
-/* Enable/Disable sensor */
-#define HWM_IO_ENABLE_SENSOR_NODATA _IOW(HWM_IOC_MAGIC, 0x05, uint32_t)
-#define HWM_IO_DISABLE_SENSOR_NODATA _IOW(HWM_IOC_MAGIC, 0x06, uint32_t)
-/* Get sensors data */
-#define HWM_IO_GET_SENSORS_DATA                                                \
-	_IOWR(HWM_IOC_MAGIC, 0x07, struct hwm_trans_data)
-#ifdef CONFIG_COMPAT
-/* set delay */
-#define COMPAT_HWM_IO_SET_DELAY _IOW(HWM_IOC_MAGIC, 0x01, compat_uint_t)
-
-/* wake up */
-#define COMPAT_HWM_IO_SET_WAKE _IO(HWM_IOC_MAGIC, 0x02)
-
-/* Enable/Disable  sensor */
-#define COMPAT_HWM_IO_ENABLE_SENSOR _IOW(HWM_IOC_MAGIC, 0x03, compat_uint_t)
-#define COMPAT_HWM_IO_DISABLE_SENSOR _IOW(HWM_IOC_MAGIC, 0x04, compat_uint_t)
-
-/* Enable/Disable sensor */
-#define COMPAT_HWM_IO_ENABLE_SENSOR_NODATA                                     \
-	_IOW(HWM_IOC_MAGIC, 0x05, compat_uint_t)
-#define COMPAT_HWM_IO_DISABLE_SENSOR_NODATA                                    \
-	_IOW(HWM_IOC_MAGIC, 0x06, compat_uint_t)
-/* Get sensors data */
-#define COMPAT_HWM_IO_GET_SENSORS_DATA                                         \
-	_IOWR(HWM_IOC_MAGIC, 0x07, struct compat_hwm_trans_data)
-#endif
-/*----------------------------------------------------------------------------*/
-#define BATCH_IOC_MAGIC 0x92
-
-/* Get sensor data */
-#define BATCH_IO_GET_SENSORS_DATA                                              \
-	_IOWR(BATCH_IOC_MAGIC, 0x01, struct batch_trans_data)
-#ifdef CONFIG_COMPAT
-#define COMPAT_BATCH_IO_GET_SENSORS_DATA                                       \
-	_IOWR(BATCH_IOC_MAGIC, 0x01, struct compat_batch_trans_data)
-#endif
-
-#define SENSOR_DELAY 0X01
-#define SENSOR_ENABLE 0X02
-#define SENSOR_GET_DATA 0X04
-
-/**
- * status of each sensor
- */
-
-#define SENSOR_STATUS_UNRELIABLE 0
-#define SENSOR_STATUS_ACCURACY_LOW 1
-#define SENSOR_STATUS_ACCURACY_MEDIUM 2
-#define SENSOR_STATUS_ACCURACY_HIGH 3
-
-#define GRAVITY_EARTH_1000 9807	/* about (9.80665f)*1000 */
-
-#endif				/* __HWMSENSOR_H__ */
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_attr.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_attr.h
deleted file mode 100644
index 7710ce1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_attr.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _SENSOR_ATTR_H
-#define _SENSOR_ATTR_H
-#include <linux/major.h>
-#include <linux/types.h>
-#include <linux/module.h>
-
-struct sensor_attr_t  {
-	unsigned char minor;
-	const char *name;
-	const struct file_operations *fops;
-	struct list_head list;
-	struct device *parent;
-	struct device *this_device;
-};
-struct sensor_attr_dev {
-	struct device *dev;
-};
-extern int sensor_attr_register(struct sensor_attr_t *misc);
-extern int sensor_attr_deregister(struct sensor_attr_t *misc);
-extern int __init sensor_attr_init(void);
-extern void __exit sensor_attr_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_event.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_event.h
deleted file mode 100644
index 5999133..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_event.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _SENSOR_EVENT_H
-#define _SENSOR_EVENT_H
-#include <linux/poll.h>
-#include <linux/ratelimit.h>
-
-#define CONTINUE_SENSOR_BUF_SIZE	2048
-#define BIO_SENSOR_BUF_SIZE	0x20000 /* ((512 + 1024 + 1024) * 60) */
-#define OTHER_SENSOR_BUF_SIZE	16
-enum flushAction {
-	DATA_ACTION,
-	FLUSH_ACTION,
-	BIAS_ACTION,
-	CALI_ACTION,
-	TEMP_ACTION,
-	TEST_ACTION,
-};
-struct sensor_event {
-	int64_t time_stamp;
-	int8_t handle;
-	int8_t flush_action;
-	int8_t status;
-	int8_t reserved;
-	union {
-		int32_t word[6];
-		int8_t byte[0];
-	};
-} __packed;
-ssize_t sensor_event_read(unsigned char handle, struct file *file,
-	char __user *buffer,
-			  size_t count, loff_t *ppos);
-unsigned int sensor_event_poll(unsigned char handle, struct file *file,
-	poll_table *wait);
-int sensor_input_event(unsigned char handle,
-			 const struct sensor_event *event);
-unsigned int sensor_event_register(unsigned char handle);
-unsigned int sensor_event_deregister(unsigned char handle);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_list.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_list.h
deleted file mode 100644
index 16e2d69..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_list.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _SENSOR_LIST_H
-#define _SENSOR_LIST_H
-
-#ifndef CONFIG_CUSTOM_KERNEL_SENSORHUB
-struct sensorInfo_NonHub_t {
-	char name[16];
-};
-int sensorlist_register_deviceinfo(int sensor,
-		struct sensorInfo_NonHub_t *devinfo);
-#endif
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_performance.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_performance.h
deleted file mode 100644
index 3193a79..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensor_performance.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __SENSOR_PERFORMANCE_H__
-#define __SENSOR_PERFORMANCE_H__
-
-#include "hwmsensor.h"
-#include <linux/types.h>
-
-enum SENSOR_STATUS {
-	GOT_IPI,
-	WORK_START,
-	DATA_REPORT,
-	STATUS_MAX,
-};
-
-struct time_records {
-	u64 check_time;
-	u64 sum_kernel_time;
-	u16 count;
-};
-
-#define LIMIT 1000
-
-/* #define DEBUG_PERFORMANCE */
-
-#ifdef DEBUG_PERFORMANCE
-extern void mark_timestamp(u8 sensor_type, enum SENSOR_STATUS status,
-	u64 current_time,
-				  u64 event_time);
-extern void mark_ipi_timestamp(uint64_t cyc);
-#else
-#define mark_timestamp(A, B, C, D)
-#define mark_ipi_timestamp(A)
-#endif
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensors_io.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensors_io.h
deleted file mode 100644
index 5e8d291..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/include/sensors_io.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef SENSORS_IO_H
-#define SENSORS_IO_H
-
-#include <linux/ioctl.h>
-
-#ifdef CONFIG_COMPAT
-#include <linux/compat.h>
-#endif
-
-struct GSENSOR_VECTOR3D {
-	unsigned short x; /**< X axis */
-	unsigned short y; /**< Y axis */
-	unsigned short z; /**< Z axis */
-};
-
-struct SENSOR_DATA {
-	int x;
-	int y;
-	int z;
-};
-
-struct biometric_cali {
-	unsigned int pga6;
-	unsigned int ambdac5_5;
-};
-
-struct biometric_test_data {
-	int ppg_ir;
-	int ppg_r;
-	int ekg;
-};
-
-struct biometric_threshold {
-	int ppg_ir_threshold;
-	int ppg_r_threshold;
-	int ekg_threshold;
-};
-
-#ifdef CONFIG_COMPAT
-
-struct compat_biometric_cali {
-	compat_uint_t pga6;
-	compat_uint_t ambdac5_5;
-};
-
-struct compat_biometric_test_data {
-	compat_int_t ppg_ir;
-	compat_int_t ppg_r;
-	compat_int_t ekg;
-};
-
-struct compat_biometric_threshold {
-	compat_int_t ppg_ir_threshold;
-	compat_int_t ppg_r__threshold;
-	compat_int_t ekg_threshold;
-};
-
-#endif
-
-#define GSENSOR 0x85
-#define GSENSOR_IOCTL_INIT _IO(GSENSOR, 0x01)
-#define GSENSOR_IOCTL_READ_CHIPINFO _IOR(GSENSOR, 0x02, int)
-#define GSENSOR_IOCTL_READ_SENSORDATA _IOR(GSENSOR, 0x03, int)
-#define GSENSOR_IOCTL_READ_RAW_DATA _IOR(GSENSOR, 0x06, int)
-#define GSENSOR_IOCTL_SET_CALI _IOW(GSENSOR, 0x06, struct SENSOR_DATA)
-#define GSENSOR_IOCTL_GET_CALI _IOW(GSENSOR, 0x07, struct SENSOR_DATA)
-#define GSENSOR_IOCTL_CLR_CALI _IO(GSENSOR, 0x08)
-#define GSENSOR_IOCTL_ENABLE_CALI _IO(GSENSOR, 0x09)
-#define GSENSOR_IOCTL_SELF_TEST _IO(GSENSOR, 0x0A)
-
-#ifdef CONFIG_COMPAT
-#define COMPAT_GSENSOR_IOCTL_INIT _IO(GSENSOR, 0x01)
-#define COMPAT_GSENSOR_IOCTL_READ_CHIPINFO _IOR(GSENSOR, 0x02, compat_int_t)
-#define COMPAT_GSENSOR_IOCTL_READ_SENSORDATA _IOR(GSENSOR, 0x03, compat_int_t)
-#define COMPAT_GSENSOR_IOCTL_READ_RAW_DATA _IOR(GSENSOR, 0x06, compat_int_t)
-#define COMPAT_GSENSOR_IOCTL_SET_CALI _IOW(GSENSOR, 0x06, struct SENSOR_DATA)
-#define COMPAT_GSENSOR_IOCTL_GET_CALI _IOW(GSENSOR, 0x07, struct SENSOR_DATA)
-#define COMPAT_GSENSOR_IOCTL_CLR_CALI _IO(GSENSOR, 0x08)
-#define COMPAT_GSENSOR_IOCTL_ENABLE_CALI _IO(GSENSOR, 0x09)
-#define COMPAT_GSENSOR_IOCTL_SELF_TEST _IO(GSENSOR, 0x0A)
-#endif
-
-/* IOCTLs for Msensor misc. device library */
-#define MSENSOR 0x83
-#define MSENSOR_IOCTL_READ_SENSORDATA _IOR(MSENSOR, 0x03, int)
-#define MSENSOR_IOCTL_SELF_TEST _IOW(MSENSOR, 0x0B, int)
-#define MSENSOR_IOCTL_SENSOR_ENABLE _IOW(MSENSOR, 0x51, int)
-
-#ifdef CONFIG_COMPAT
-/*COMPACT IOCTL for 64bit kernel running 32bit daemon*/
-#define COMPAT_MSENSOR_IOCTL_READ_SENSORDATA _IOR(MSENSOR, 0x03, compat_int_t)
-#define COMPAT_MSENSOR_IOCTL_SELF_TEST _IOW(MSENSOR, 0x0B, compat_int_t)
-#define COMPAT_MSENSOR_IOCTL_SENSOR_ENABLE _IOW(MSENSOR, 0x51, compat_int_t)
-#endif
-
-#define ALSPS 0x84
-#define ALSPS_SET_PS_MODE _IOW(ALSPS, 0x01, int)
-#define ALSPS_GET_PS_RAW_DATA _IOR(ALSPS, 0x04, int)
-#define ALSPS_SET_ALS_MODE _IOW(ALSPS, 0x05, int)
-#define ALSPS_GET_ALS_RAW_DATA _IOR(ALSPS, 0x08, int)
-
-/*-------------------MTK add-------------------------------------------*/
-#define ALSPS_GET_PS_TEST_RESULT _IOR(ALSPS, 0x09, int)
-#define ALSPS_GET_PS_THRESHOLD_HIGH _IOR(ALSPS, 0x0B, int)
-#define ALSPS_GET_PS_THRESHOLD_LOW _IOR(ALSPS, 0x0C, int)
-#define ALSPS_IOCTL_CLR_CALI _IOW(ALSPS, 0x0F, int)
-#define ALSPS_IOCTL_GET_CALI _IOR(ALSPS, 0x10, int)
-#define ALSPS_IOCTL_SET_CALI _IOW(ALSPS, 0x11, int)
-#define ALSPS_SET_PS_THRESHOLD _IOW(ALSPS, 0x12, int)
-#define AAL_SET_ALS_MODE _IOW(ALSPS, 0x14, int)
-#define AAL_GET_ALS_MODE _IOR(ALSPS, 0x15, int)
-#define AAL_GET_ALS_DATA _IOR(ALSPS, 0x16, int)
-#define ALSPS_ALS_ENABLE_CALI _IO(ALSPS, 0x17)
-#define ALSPS_PS_ENABLE_CALI _IO(ALSPS, 0x18)
-#define ALSPS_IOCTL_ALS_GET_CALI _IOW(ALSPS, 0x19, int)
-#define ALSPS_ALS_SET_CALI _IOW(ALSPS, 0x20, int)
-
-#ifdef CONFIG_COMPAT
-#define COMPAT_ALSPS_SET_PS_MODE _IOW(ALSPS, 0x01, compat_int_t)
-#define COMPAT_ALSPS_GET_PS_RAW_DATA _IOR(ALSPS, 0x04, compat_int_t)
-#define COMPAT_ALSPS_SET_ALS_MODE _IOW(ALSPS, 0x05, compat_int_t)
-#define COMPAT_ALSPS_GET_ALS_RAW_DATA _IOR(ALSPS, 0x08, compat_int_t)
-
-/*-------------------MTK add-------------------------------------------*/
-#define COMPAT_ALSPS_GET_PS_TEST_RESULT _IOR(ALSPS, 0x09, compat_int_t)
-#define COMPAT_ALSPS_GET_PS_THRESHOLD_HIGH _IOR(ALSPS, 0x0B, compat_int_t)
-#define COMPAT_ALSPS_GET_PS_THRESHOLD_LOW _IOR(ALSPS, 0x0C, compat_int_t)
-#define COMPAT_ALSPS_IOCTL_CLR_CALI _IOW(ALSPS, 0x0F, compat_int_t)
-#define COMPAT_ALSPS_IOCTL_GET_CALI _IOR(ALSPS, 0x10, compat_int_t)
-#define COMPAT_ALSPS_IOCTL_SET_CALI _IOW(ALSPS, 0x11, compat_int_t)
-#define COMPAT_ALSPS_SET_PS_THRESHOLD _IOW(ALSPS, 0x12, compat_int_t)
-#define COMPAT_AAL_SET_ALS_MODE _IOW(ALSPS, 0x14, compat_int_t)
-#define COMPAT_AAL_GET_ALS_MODE _IOR(ALSPS, 0x15, compat_int_t)
-#define COMPAT_AAL_GET_ALS_DATA _IOR(ALSPS, 0x16, compat_int_t)
-#define COMPAT_ALSPS_ALS_ENABLE_CALI _IO(ALSPS, 0x17)
-#define COMPAT_ALSPS_PS_ENABLE_CALI _IO(ALSPS, 0x18)
-#define COMPAT_ALSPS_IOCTL_ALS_GET_CALI _IOR(ALSPS, 0x19, compat_int_t)
-#define COMPAT_ALSPS_IOCTL_ALS_SET_CALI _IOR(ALSPS, 0x20, compat_int_t)
-
-#endif
-
-#define GYROSCOPE 0x86
-#define GYROSCOPE_IOCTL_INIT _IO(GYROSCOPE, 0x01)
-#define GYROSCOPE_IOCTL_SMT_DATA _IOR(GYROSCOPE, 0x02, int)
-#define GYROSCOPE_IOCTL_READ_SENSORDATA _IOR(GYROSCOPE, 0x03, int)
-#define GYROSCOPE_IOCTL_SET_CALI _IOW(GYROSCOPE, 0x04, struct SENSOR_DATA)
-#define GYROSCOPE_IOCTL_GET_CALI _IOW(GYROSCOPE, 0x05, struct SENSOR_DATA)
-#define GYROSCOPE_IOCTL_CLR_CALI _IO(GYROSCOPE, 0x06)
-#define GYROSCOPE_IOCTL_READ_SENSORDATA_RAW _IOR(GYROSCOPE, 0x07, int)
-#define GYROSCOPE_IOCTL_ENABLE_CALI _IO(GYROSCOPE, 0x0A)
-#define GYROSCOPE_IOCTL_SELF_TEST _IO(GYROSCOPE, 0x0B)
-#ifdef CONFIG_COMPAT
-#define COMPAT_GYROSCOPE_IOCTL_INIT _IO(GYROSCOPE, 0x01)
-#define COMPAT_GYROSCOPE_IOCTL_SMT_DATA _IOR(GYROSCOPE, 0x02, compat_int_t)
-#define COMPAT_GYROSCOPE_IOCTL_READ_SENSORDATA                                 \
-	_IOR(GYROSCOPE, 0x03, compat_int_t)
-#define COMPAT_GYROSCOPE_IOCTL_SET_CALI                                        \
-	_IOW(GYROSCOPE, 0x04, struct SENSOR_DATA)
-#define COMPAT_GYROSCOPE_IOCTL_GET_CALI                                        \
-	_IOW(GYROSCOPE, 0x05, struct SENSOR_DATA)
-#define COMPAT_GYROSCOPE_IOCTL_CLR_CALI _IO(GYROSCOPE, 0x06)
-#define COMPAT_GYROSCOPE_IOCTL_READ_SENSORDATA_RAW                             \
-	_IOR(GYROSCOPE, 0x07, compat_int_t)
-#define COMPAT_GYROSCOPE_IOCTL_ENABLE_CALI _IO(GYROSCOPE, 0x0A)
-#define COMPAT_GYROSCOPE_IOCTL_SELF_TEST _IO(GYROSCOPE, 0x0B)
-#endif
-#define BROMETER 0x87
-#define BAROMETER_IOCTL_INIT _IO(BROMETER, 0x01)
-#define BAROMETER_GET_PRESS_DATA _IOR(BROMETER, 0x02, int)
-#define BAROMETER_GET_TEMP_DATA _IOR(BROMETER, 0x03, int)
-#define BAROMETER_IOCTL_ENABLE_CALI _IO(BROMETER, 0x05)
-#ifdef CONFIG_COMPAT
-#define COMPAT_BAROMETER_IOCTL_INIT _IO(BROMETER, 0x01)
-#define COMPAT_BAROMETER_GET_PRESS_DATA _IOR(BROMETER, 0x02, compat_int_t)
-#define COMPAT_BAROMETER_GET_TEMP_DATA _IOR(BROMETER, 0x03, compat_int_t)
-#define COMPAT_BAROMETER_IOCTL_ENABLE_CALI _IO(BROMETER, 0x05)
-#endif
-
-#define BIOMETRIC 0x90
-#define BIOMETRIC_IOCTL_INIT _IO(BIOMETRIC, 0x01)
-#define BIOMETRIC_IOCTL_DO_CALI _IOW(BIOMETRIC, 0x02, struct biometric_cali)
-#define BIOMETRIC_IOCTL_SET_CALI _IOW(BIOMETRIC, 0x03, struct biometric_cali)
-#define BIOMETRIC_IOCTL_GET_CALI _IOW(BIOMETRIC, 0x04, struct biometric_cali)
-#define BIOMETRIC_IOCTL_CLR_CALI _IO(BIOMETRIC, 0x05)
-#define BIOMETRIC_IOCTL_FTM_START _IO(BIOMETRIC, 0x06)
-#define BIOMETRIC_IOCTL_FTM_END _IO(BIOMETRIC, 0x07)
-#define BIOMETRIC_IOCTL_FTM_GET_DATA                                           \
-	_IOW(BIOMETRIC, 0x08, struct biometric_test_data)
-#define BIOMETRIC_IOCTL_FTM_GET_THRESHOLD                                      \
-	_IOW(BIOMETRIC, 0x09, struct biometric_threshold)
-#ifdef CONFIG_COMPAT
-#define COMPAT_BIOMETRIC_IOCTL_INIT _IO(BIOMETRIC, 0x01)
-#define COMPAT_BIOMETRIC_IOCTL_DO_CALI                                         \
-	_IOW(BIOMETRIC, 0x02, struct compat_biometric_cali)
-#define COMPAT_BIOMETRIC_IOCTL_SET_CALI                                        \
-	_IOW(BIOMETRIC, 0x03, struct compat_biometric_cali)
-#define COMPAT_BIOMETRIC_IOCTL_GET_CALI                                        \
-	_IOW(BIOMETRIC, 0x04, struct compat_biometric_cali)
-#define COMPAT_BIOMETRIC_IOCTL_CLR_CALI _IO(BIOMETRIC, 0x05)
-#define COMPAT_BIOMETRIC_IOCTL_FTM_START _IO(BIOMETRIC, 0x06)
-#define COMPAT_BIOMETRIC_IOCTL_FTM_END _IO(BIOMETRIC, 0x07)
-#define COMPAT_BIOMETRIC_IOCTL_FTM_GET_DATA                                    \
-	_IOW(BIOMETRIC, 0x08, struct compat_biometric_test_data)
-#define COMPAT_BIOMETRIC_IOCTL_FTM_GET_THRESHOLD                               \
-	_IOW(BIOMETRIC, 0x09, struct compat_biometric_threshold)
-#endif
-
-#define SAR 0x91
-#define SAR_IOCTL_INIT _IOW(SAR, 0x01, int)
-#define SAR_IOCTL_READ_SENSORDATA _IOR(SAR, 0x02, struct SENSOR_DATA)
-#define SAR_IOCTL_GET_CALI  _IOR(SAR, 0x03, struct SENSOR_DATA)
-#define SAR_IOCTL_ENABLE_CALI _IO(SAR, 0x04)
-#ifdef CONFIG_COMPAT
-#define COMPAT_SAR_IOCTL_INIT _IOW(SAR, 0x01, compat_int_t)
-#define COMPAT_SAR_IOCTL_READ_SENSORDATA _IOR(SAR, 0x02, struct SENSOR_DATA)
-#define COMPAT_SAR_IOCTL_GET_CALI _IOR(SAR, 0x03, struct SENSOR_DATA)
-#define COMPAT_SAR_IOCTL_ENABLE_CALI _IO(SAR, 0x04)
-#endif
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_attributes/sensor_attr.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_attributes/sensor_attr.c
deleted file mode 100644
index 3ea7520..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_attributes/sensor_attr.c
+++ /dev/null
@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<HWMSEN> " fmt
-
-#include "sensor_attr.h"
-#include "sensor_event.h"
-#include <linux/device.h>
-#include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/module.h>
-
-static int sensor_attr_major = -1;
-static struct class *sensor_attr_class;
-
-static LIST_HEAD(sensor_attr_list);
-static DEFINE_MUTEX(sensor_attr_mtx);
-
-static int sensor_attr_open(struct inode *inode, struct file *file)
-{
-	int minor = iminor(inode);
-	struct sensor_attr_t *c;
-	int err = -ENODEV;
-	const struct file_operations *new_fops = NULL;
-
-	mutex_lock(&sensor_attr_mtx);
-
-	list_for_each_entry(c, &sensor_attr_list, list) {
-		if (c->minor == minor) {
-			new_fops = fops_get(c->fops);
-			break;
-		}
-	}
-
-	if (!new_fops) {
-		mutex_unlock(&sensor_attr_mtx);
-		request_module("char-major-%d-%d", sensor_attr_major, minor);
-		mutex_lock(&sensor_attr_mtx);
-
-		list_for_each_entry(c, &sensor_attr_list, list) {
-			if (c->minor == minor) {
-				new_fops = fops_get(c->fops);
-				break;
-			}
-		}
-		if (!new_fops)
-			goto fail;
-	}
-
-	err = 0;
-	replace_fops(file, new_fops);
-	if (file->f_op->open) {
-		file->private_data = c;
-		err = file->f_op->open(inode, file);
-	}
-fail:
-	mutex_unlock(&sensor_attr_mtx);
-	return err;
-}
-
-static const struct file_operations sensor_attr_fops = {
-	.owner = THIS_MODULE,
-	.open = sensor_attr_open,
-};
-
-int sensor_attr_register(struct sensor_attr_t *misc)
-{
-	dev_t dev;
-	int err = 0;
-	struct sensor_attr_t *c;
-
-	mutex_lock(&sensor_attr_mtx);
-	list_for_each_entry(c, &sensor_attr_list, list) {
-		if (c->minor == misc->minor) {
-			err = -EBUSY;
-			goto out;
-		}
-	}
-	dev = MKDEV(sensor_attr_major, misc->minor);
-	misc->this_device = device_create(sensor_attr_class, misc->parent, dev,
-					  misc, "%s", misc->name);
-	if (IS_ERR(misc->this_device))
-		goto out;
-	list_add(&misc->list, &sensor_attr_list);
-	mutex_unlock(&sensor_attr_mtx);
-	err = sensor_event_register(misc->minor);
-	return err;
-out:
-	mutex_unlock(&sensor_attr_mtx);
-	return err;
-}
-EXPORT_SYMBOL_GPL(sensor_attr_register);
-
-int sensor_attr_deregister(struct sensor_attr_t *misc)
-{
-	if (WARN_ON(list_empty(&misc->list)))
-		return -EINVAL;
-
-	mutex_lock(&sensor_attr_mtx);
-	list_del(&misc->list);
-	device_destroy(sensor_attr_class,
-		       MKDEV(sensor_attr_major, misc->minor));
-	mutex_unlock(&sensor_attr_mtx);
-	sensor_event_deregister(misc->minor);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(sensor_attr_deregister);
-
-/*
- *static char *sensor_attr_devnode(struct device *dev, umode_t *mode)
- *{
- *	pr_debug("sensor_attr: name :%s\n", dev_name(dev));
- *	return kasprintf(GFP_KERNEL, "sensor/%s", dev_name(dev));
- *}
- */
-
-int __init sensor_attr_init(void)
-{
-	int err;
-
-	sensor_attr_class = class_create(THIS_MODULE, "sensor");
-	err = PTR_ERR(sensor_attr_class);
-	if (IS_ERR(sensor_attr_class)) {
-		err = -EIO;
-		return err;
-	}
-	sensor_attr_major = register_chrdev(0, "sensor", &sensor_attr_fops);
-	if (sensor_attr_major < 0)
-		goto fail_printk;
-	/* sensor_attr_class->devnode = sensor_attr_devnode; */
-	return 0;
-
-fail_printk:
-	pr_err("unable to get major %d for misc devices\n", sensor_attr_major);
-	class_destroy(sensor_attr_class);
-	return err;
-}
-
-void __exit sensor_attr_exit(void)
-{
-	unregister_chrdev(sensor_attr_major, "sensor");
-	class_destroy(sensor_attr_class);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_dts/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_dts/Makefile
deleted file mode 100644
index 2adb891..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_dts/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/accelerometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/alsps/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/gyroscope/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/accelgyro/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/magnetometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/barometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/humidity/inc
-obj-y := sensor_dts.o
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_dts/sensor_dts.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_dts/sensor_dts.c
deleted file mode 100644
index bd6d04d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_dts/sensor_dts.c
+++ /dev/null
@@ -1,414 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[Sensor dts] " fmt
-
-#include <cust_acc.h>
-#include <cust_accelgyro.h>
-#include <cust_alsps.h>
-#include <cust_baro.h>
-#include <cust_gyro.h>
-//#include <cust_hmdy.h>
-#include <cust_mag.h>
-#include <linux/of.h>
-#include <linux/of_irq.h>
-
-int get_accel_dts_func(struct device_node *node, struct acc_hw *hw)
-{
-	int i, ret;
-	u32 i2c_num[] = {0};
-	u32 i2c_addr[G_CUST_I2C_ADDR_NUM] = {0};
-	u32 direction[] = {0};
-	u32 power_id[] = {0};
-	u32 power_vol[] = {0};
-	u32 firlen[] = {0};
-	u32 is_batch_supported[] = {0};
-
-	pr_debug("Device Tree get accel info!\n");
-	if (node) {
-		ret = of_property_read_u32_array(node, "i2c_num", i2c_num,
-						 ARRAY_SIZE(i2c_num));
-		if (ret == 0)
-			hw->i2c_num = i2c_num[0];
-
-		ret = of_property_read_u32_array(node, "i2c_addr", i2c_addr,
-						 ARRAY_SIZE(i2c_addr));
-		if (ret == 0) {
-			for (i = 0; i < G_CUST_I2C_ADDR_NUM; i++)
-				hw->i2c_addr[i] = i2c_addr[i];
-		}
-
-		ret = of_property_read_u32_array(node, "direction", direction,
-						 ARRAY_SIZE(direction));
-		if (ret == 0)
-			hw->direction = direction[0];
-
-		ret = of_property_read_u32_array(node, "power_id", power_id,
-						 ARRAY_SIZE(power_id));
-		if (ret == 0) {
-			if (power_id[0] == 0xffff)
-				hw->power_id = -1;
-			else
-				hw->power_id = power_id[0];
-		}
-
-		ret = of_property_read_u32_array(node, "power_vol", power_vol,
-						 ARRAY_SIZE(power_vol));
-		if (ret == 0)
-			hw->power_vol = power_vol[0];
-
-		ret = of_property_read_u32_array(node, "firlen", firlen,
-						 ARRAY_SIZE(firlen));
-		if (ret == 0)
-			hw->firlen = firlen[0];
-
-		ret = of_property_read_u32_array(
-			node, "is_batch_supported", is_batch_supported,
-			ARRAY_SIZE(is_batch_supported));
-		if (ret == 0)
-			hw->is_batch_supported = is_batch_supported[0];
-	} else {
-		pr_err(
-			"Device Tree: can not find accel node!. Go to use old cust info\n");
-		return -1;
-	}
-
-	return 0;
-}
-
-int get_alsps_dts_func(struct device_node *node, struct alsps_hw *hw)
-{
-	int i, ret;
-	u32 i2c_num[] = {0};
-	u32 i2c_addr[C_CUST_I2C_ADDR_NUM] = {0};
-	u32 power_id[] = {0};
-	u32 power_vol[] = {0};
-	u32 polling_mode_ps[] = {0};
-	u32 polling_mode_als[] = {0};
-	u32 als_level[C_CUST_ALS_LEVEL - 1] = {0};
-	u32 als_value[C_CUST_ALS_LEVEL] = {0};
-	u32 ps_threshold_high[] = {0};
-	u32 ps_threshold_low[] = {0};
-	u32 is_batch_supported_ps[] = {0};
-	u32 is_batch_supported_als[] = {0};
-
-	pr_debug("Device Tree get alsps info!\n");
-	if (node) {
-		ret = of_property_read_u32_array(node, "i2c_num", i2c_num,
-						 ARRAY_SIZE(i2c_num));
-		if (ret == 0)
-			hw->i2c_num = i2c_num[0];
-
-		ret = of_property_read_u32_array(node, "i2c_addr", i2c_addr,
-						 ARRAY_SIZE(i2c_addr));
-		if (ret == 0) {
-			for (i = 0; i < C_CUST_I2C_ADDR_NUM; i++)
-				hw->i2c_addr[i] = i2c_addr[i];
-		}
-
-		ret = of_property_read_u32_array(node, "power_id", power_id,
-						 ARRAY_SIZE(power_id));
-		if (ret == 0) {
-			if (power_id[0] == 0xffff)
-				hw->power_id = -1;
-			else
-				hw->power_id = power_id[0];
-		}
-
-		ret = of_property_read_u32_array(node, "power_vol", power_vol,
-						 ARRAY_SIZE(power_vol));
-		if (ret == 0)
-			hw->power_vol = power_vol[0];
-
-		ret = of_property_read_u32_array(node, "als_level", als_level,
-						 ARRAY_SIZE(als_level));
-		if (ret == 0) {
-			for (i = 0; i < ARRAY_SIZE(als_level); i++)
-				hw->als_level[i] = als_level[i];
-		}
-
-		ret = of_property_read_u32_array(node, "als_value", als_value,
-						 ARRAY_SIZE(als_value));
-		if (ret == 0) {
-			for (i = 0; i < ARRAY_SIZE(als_value); i++)
-				hw->als_value[i] = als_value[i];
-		}
-
-		ret = of_property_read_u32_array(node, "polling_mode_ps",
-						 polling_mode_ps,
-						 ARRAY_SIZE(polling_mode_ps));
-		if (ret == 0)
-			hw->polling_mode_ps = polling_mode_ps[0];
-
-		ret = of_property_read_u32_array(node, "polling_mode_als",
-						 polling_mode_als,
-						 ARRAY_SIZE(polling_mode_als));
-		if (ret == 0)
-			hw->polling_mode_als = polling_mode_als[0];
-
-		ret = of_property_read_u32_array(node, "ps_threshold_high",
-						 ps_threshold_high,
-						 ARRAY_SIZE(ps_threshold_high));
-		if (ret == 0)
-			hw->ps_threshold_high = ps_threshold_high[0];
-
-		ret = of_property_read_u32_array(node, "ps_threshold_low",
-						 ps_threshold_low,
-						 ARRAY_SIZE(ps_threshold_low));
-		if (ret == 0)
-			hw->ps_threshold_low = ps_threshold_low[0];
-
-		ret = of_property_read_u32_array(
-			node, "is_batch_supported_ps", is_batch_supported_ps,
-			ARRAY_SIZE(is_batch_supported_ps));
-		if (ret == 0)
-			hw->is_batch_supported_ps = is_batch_supported_ps[0];
-
-		ret = of_property_read_u32_array(
-			node, "is_batch_supported_als", is_batch_supported_als,
-			ARRAY_SIZE(is_batch_supported_als));
-		if (ret == 0)
-			hw->is_batch_supported_als = is_batch_supported_als[0];
-	} else {
-		pr_err(
-			"Device Tree: can not find alsps node!. Go to use old cust info\n");
-		return -1;
-	}
-	return 0;
-}
-
-int get_mag_dts_func(struct device_node *node, struct mag_hw *hw)
-{
-	int i, ret;
-	u32 i2c_num[] = {0};
-	u32 i2c_addr[M_CUST_I2C_ADDR_NUM] = {0};
-	u32 direction[] = {0};
-	u32 power_id[] = {0};
-	u32 power_vol[] = {0};
-	u32 is_batch_supported[] = {0};
-
-	pr_debug("Device Tree get mag info!\n");
-	if (node) {
-		ret = of_property_read_u32_array(node, "i2c_num", i2c_num,
-						 ARRAY_SIZE(i2c_num));
-		if (ret == 0)
-			hw->i2c_num = i2c_num[0];
-
-		ret = of_property_read_u32_array(node, "i2c_addr", i2c_addr,
-						 ARRAY_SIZE(i2c_addr));
-		if (ret == 0) {
-			for (i = 0; i < M_CUST_I2C_ADDR_NUM; i++)
-				hw->i2c_addr[i] = i2c_addr[i];
-		}
-
-		ret = of_property_read_u32_array(node, "direction", direction,
-						 ARRAY_SIZE(direction));
-		if (ret == 0)
-			hw->direction = direction[0];
-
-		ret = of_property_read_u32_array(node, "power_id", power_id,
-						 ARRAY_SIZE(power_id));
-		if (ret == 0) {
-			if (power_id[0] == 0xffff)
-				hw->power_id = -1;
-			else
-				hw->power_id = power_id[0];
-		}
-
-		ret = of_property_read_u32_array(node, "power_vol", power_vol,
-						 ARRAY_SIZE(power_vol));
-		if (ret == 0)
-			hw->power_vol = power_vol[0];
-
-		ret = of_property_read_u32_array(
-			node, "is_batch_supported", is_batch_supported,
-			ARRAY_SIZE(is_batch_supported));
-		if (ret == 0)
-			hw->is_batch_supported = is_batch_supported[0];
-	} else {
-		pr_err(
-			"Device Tree: can not find mag node!. Go to use old cust info\n");
-		return -1;
-	}
-	return 0;
-}
-
-int get_gyro_dts_func(struct device_node *node, struct gyro_hw *hw)
-{
-	int i, ret;
-	u32 i2c_num[] = {0};
-	u32 i2c_addr[C_CUST_I2C_ADDR_NUM] = {0};
-	u32 direction[] = {0};
-	u32 power_id[] = {0};
-	u32 power_vol[] = {0};
-	u32 firlen[] = {0};
-	u32 is_batch_supported[] = {0};
-
-	pr_debug("Device Tree get gyro info!\n");
-	if (node) {
-		ret = of_property_read_u32_array(node, "i2c_num", i2c_num,
-						 ARRAY_SIZE(i2c_num));
-		if (ret == 0)
-			hw->i2c_num = i2c_num[0];
-
-		ret = of_property_read_u32_array(node, "i2c_addr", i2c_addr,
-						 ARRAY_SIZE(i2c_addr));
-		if (ret == 0) {
-			for (i = 0; i < GYRO_CUST_I2C_ADDR_NUM; i++)
-				hw->i2c_addr[i] = i2c_addr[i];
-		}
-
-		ret = of_property_read_u32_array(node, "direction", direction,
-						 ARRAY_SIZE(direction));
-		if (ret == 0)
-			hw->direction = direction[0];
-
-		ret = of_property_read_u32_array(node, "power_id", power_id,
-						 ARRAY_SIZE(power_id));
-		if (ret == 0) {
-			if (power_id[0] == 0xffff)
-				hw->power_id = -1;
-			else
-				hw->power_id = power_id[0];
-		}
-
-		ret = of_property_read_u32_array(node, "power_vol", power_vol,
-						 ARRAY_SIZE(power_vol));
-		if (ret == 0)
-			hw->power_vol = power_vol[0];
-
-		ret = of_property_read_u32_array(node, "firlen", firlen,
-						 ARRAY_SIZE(firlen));
-		if (ret == 0)
-			hw->firlen = firlen[0];
-
-		ret = of_property_read_u32_array(
-			node, "is_batch_supported", is_batch_supported,
-			ARRAY_SIZE(is_batch_supported));
-		if (ret == 0)
-			hw->is_batch_supported = is_batch_supported[0];
-	} else {
-		pr_err(
-			"Device Tree: can not find gyro node!. Go to use old cust info\n");
-		return -1;
-	}
-	return 0;
-}
-
-int get_baro_dts_func(struct device_node *node, struct baro_hw *hw)
-{
-	int i, ret;
-	u32 i2c_num[] = {0};
-	u32 i2c_addr[C_CUST_I2C_ADDR_NUM] = {0};
-	u32 direction[] = {0};
-	u32 power_id[] = {0};
-	u32 power_vol[] = {0};
-	u32 firlen[] = {0};
-	u32 is_batch_supported[] = {0};
-
-	pr_debug("Device Tree get gyro info!\n");
-
-	if (node) {
-		ret = of_property_read_u32_array(node, "i2c_num", i2c_num,
-						 ARRAY_SIZE(i2c_num));
-		if (ret == 0)
-			hw->i2c_num = i2c_num[0];
-
-		ret = of_property_read_u32_array(node, "i2c_addr", i2c_addr,
-						 ARRAY_SIZE(i2c_addr));
-		if (ret == 0) {
-			for (i = 0; i < GYRO_CUST_I2C_ADDR_NUM; i++)
-				hw->i2c_addr[i] = i2c_addr[i];
-		}
-
-		ret = of_property_read_u32_array(node, "direction", direction,
-						 ARRAY_SIZE(direction));
-		if (ret == 0)
-			hw->direction = direction[0];
-
-		ret = of_property_read_u32_array(node, "power_id", power_id,
-						 ARRAY_SIZE(power_id));
-		if (ret == 0) {
-			if (power_id[0] == 0xffff)
-				hw->power_id = -1;
-			else
-				hw->power_id = power_id[0];
-		}
-
-		ret = of_property_read_u32_array(node, "power_vol", power_vol,
-						 ARRAY_SIZE(power_vol));
-		if (ret == 0)
-			hw->power_vol = power_vol[0];
-
-		ret = of_property_read_u32_array(node, "firlen", firlen,
-						 ARRAY_SIZE(firlen));
-		if (ret == 0)
-			hw->firlen = firlen[0];
-
-		ret = of_property_read_u32_array(
-			node, "is_batch_supported", is_batch_supported,
-			ARRAY_SIZE(is_batch_supported));
-		if (ret == 0)
-			hw->is_batch_supported = is_batch_supported[0];
-	} else {
-		pr_err(
-			"Device Tree: can not find gyro node!. Go to use old cust info\n");
-		return -1;
-	}
-	return 0;
-}
-
-int get_accelgyro_dts_func(struct device_node *node, struct accelgyro_hw *hw)
-{
-	int ret;
-
-	u32 direction[] = {0};
-	u32 accel_firlen[] = {0};
-	u32 gyro_firlen[] = {0};
-	u32 accel_is_batch_supported[] = {0};
-	u32 gyro_is_batch_supported[] = {0};
-
-	pr_debug("Device Tree get accel info!\n");
-	if (node) {
-		ret = of_property_read_u32_array(node, "direction", direction,
-						 ARRAY_SIZE(direction));
-		if (ret == 0)
-			hw->direction = direction[0];
-
-		ret = of_property_read_u32_array(node, "accel_firlen",
-						 accel_firlen,
-						 ARRAY_SIZE(accel_firlen));
-		if (ret == 0)
-			hw->accel_firlen = accel_firlen[0];
-
-		ret = of_property_read_u32_array(
-			node, "accel_is_batch_supported",
-			accel_is_batch_supported,
-			ARRAY_SIZE(accel_is_batch_supported));
-		if (ret == 0)
-			hw->accel_is_batch_supported =
-				accel_is_batch_supported[0];
-
-		ret = of_property_read_u32_array(node, "gyro_firlen",
-						 gyro_firlen,
-						 ARRAY_SIZE(gyro_firlen));
-		if (ret == 0)
-			hw->gyro_firlen = gyro_firlen[0];
-
-		ret = of_property_read_u32_array(
-			node, "gyro_is_batch_supported",
-			gyro_is_batch_supported,
-			ARRAY_SIZE(gyro_is_batch_supported));
-		if (ret == 0)
-			hw->gyro_is_batch_supported =
-				gyro_is_batch_supported[0];
-	} else {
-		pr_err(
-			"Device Tree: can not find accel node!. Go to use old cust info\n");
-		return -1;
-	}
-
-	return 0;
-}
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_event/sensor_event.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_event/sensor_event.c
deleted file mode 100644
index 75720a0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_event/sensor_event.c
+++ /dev/null
@@ -1,268 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<sensor_event> " fmt
-
-#include "sensor_event.h"
-#include "hwmsensor.h"
-#include "sensor_attr.h"
-#include <linux/init.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-#include <linux/poll.h>
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-
-struct sensor_event_client {
-	spinlock_t buffer_lock;
-	unsigned int head;
-	unsigned int tail;
-	unsigned int bufsize;
-	unsigned int buffull;
-	struct sensor_event *buffer;
-	wait_queue_head_t wait;
-};
-struct sensor_event_obj {
-	struct sensor_event_client client[ID_SENSOR_MAX_HANDLE + 1];
-};
-static struct sensor_event_obj *event_obj;
-static struct lock_class_key buffer_lock_key[ID_SENSOR_MAX_HANDLE + 1];
-/*
- * sensor_input_event only support process context.
- */
-int sensor_input_event(unsigned char handle, const struct sensor_event *event)
-{
-	struct sensor_event_client *client = &event_obj->client[handle];
-	unsigned int dummy = 0;
-
-	/* spin_lock safe, this function don't support interrupt context */
-	spin_lock(&client->buffer_lock);
-	/*
-	 * Reserve below log if need debug LockProve
-	 * SE_ERR("[Lomen]sensor_input_event: printf key handle ID=%d, key
-	 * addr=%p\n",
-	 * handle, (struct
-	 * lock_class_key*)client->buffer_lock.rlock.dep_map.key);
-	 */
-	if (unlikely(client->buffull == true)) {
-		pr_err_ratelimited(
-			"input buffull, handle:%d, head:%d, tail:%d\n", handle,
-			client->head, client->tail);
-		spin_unlock(&client->buffer_lock);
-		wake_up_interruptible(&client->wait);
-		return -1;
-	}
-	client->buffer[client->head++] = *event;
-	client->head &= client->bufsize - 1;
-	/* remain 1 count */
-	dummy = client->head + 1;
-	dummy &= client->bufsize - 1;
-	if (unlikely(dummy == client->tail))
-		client->buffull = true;
-	spin_unlock(&client->buffer_lock);
-
-	wake_up_interruptible(&client->wait);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(sensor_input_event);
-
-static int sensor_event_fetch_next(struct sensor_event_client *client,
-				   struct sensor_event *event)
-{
-	int have_event;
-	/*
-	 * spin_lock safe, sensor_input_event always in process context.
-	 */
-	spin_lock(&client->buffer_lock);
-
-	have_event = client->head != client->tail;
-	if (have_event) {
-		*event = client->buffer[client->tail++];
-		client->tail &= client->bufsize - 1;
-		client->buffull = false;
-	}
-
-	spin_unlock(&client->buffer_lock);
-
-	return have_event;
-}
-
-ssize_t sensor_event_read(unsigned char handle, struct file *file,
-			  char __user *buffer, size_t count, loff_t *ppos)
-{
-	struct sensor_event_client *client = &event_obj->client[handle];
-	struct sensor_event event;
-	size_t read = 0;
-
-	if (count != 0 && count < sizeof(struct sensor_event)) {
-		pr_err("%s handle: %d err count(%d)\n", __func__,
-			  handle, (int)count);
-		return -EINVAL;
-	}
-
-	for (;;) {
-		if (client->head == client->tail)
-			return 0;
-		if (count == 0) {
-			pr_debug("%s count: %d\n", __func__, (int)count);
-			break;
-		}
-
-		while (read + sizeof(struct sensor_event) <= count &&
-		       sensor_event_fetch_next(client, &event)) {
-
-			if (copy_to_user(buffer + read, &event,
-					 sizeof(struct sensor_event)))
-				return -EFAULT;
-
-			read += sizeof(struct sensor_event);
-		}
-
-		if (read)
-			break;
-	}
-
-	return read;
-}
-EXPORT_SYMBOL_GPL(sensor_event_read);
-
-unsigned int sensor_event_poll(unsigned char handle, struct file *file,
-			       poll_table *wait)
-{
-	struct sensor_event_client *client = &event_obj->client[handle];
-	unsigned int mask = 0;
-
-	poll_wait(file, &client->wait, wait);
-
-	if (client->head != client->tail) {
-		/* pr_err("sensor_event_poll handle:%d\n", handle); */
-		mask |= POLLIN | POLLRDNORM;
-	}
-
-	return mask;
-}
-EXPORT_SYMBOL_GPL(sensor_event_poll);
-
-unsigned int sensor_event_register(unsigned char handle)
-{
-	struct sensor_event_obj *obj = event_obj;
-
-	switch (handle) {
-	/* google continues sensor ringbuffer is 2048 for batch flow */
-	case ID_ACCELEROMETER:
-	case ID_MAGNETIC:
-	case ID_MAGNETIC_UNCALIBRATED:
-	case ID_GYROSCOPE:
-	case ID_GYROSCOPE_UNCALIBRATED:
-	case ID_PRESSURE:
-	case ID_ORIENTATION:
-	case ID_ROTATION_VECTOR:
-	case ID_GAME_ROTATION_VECTOR:
-	case ID_GEOMAGNETIC_ROTATION_VECTOR:
-	case ID_GRAVITY:
-	case ID_LINEAR_ACCELERATION:
-	/* mtk add sensor pedometer and activity ringbuffer is 2048 for batch
-	 * flow
-	 */
-	case ID_PEDOMETER:
-	case ID_ACTIVITY:
-		spin_lock_init(&obj->client[handle].buffer_lock);
-		lockdep_set_class(&obj->client[handle].buffer_lock,
-				  &buffer_lock_key[handle]);
-
-		obj->client[handle].head = 0;
-		obj->client[handle].tail = 0;
-		obj->client[handle].bufsize = CONTINUE_SENSOR_BUF_SIZE;
-		obj->client[handle].buffull = false;
-		obj->client[handle].buffer =
-			vzalloc(obj->client[handle].bufsize *
-				sizeof(struct sensor_event));
-		if (!obj->client[handle].buffer) {
-			pr_err("Alloc ringbuffer error!\n");
-			return -1;
-		}
-		init_waitqueue_head(&obj->client[handle].wait);
-		break;
-	case ID_EKG:
-	case ID_PPG1:
-	case ID_PPG2:
-		spin_lock_init(&obj->client[handle].buffer_lock);
-		lockdep_set_class(&obj->client[handle].buffer_lock,
-				  &buffer_lock_key[handle]);
-		obj->client[handle].head = 0;
-		obj->client[handle].tail = 0;
-		obj->client[handle].bufsize = BIO_SENSOR_BUF_SIZE;
-		obj->client[handle].buffull = false;
-		obj->client[handle].buffer =
-			vzalloc(obj->client[handle].bufsize *
-				sizeof(struct sensor_event));
-		if (!obj->client[handle].buffer) {
-			pr_err("Alloc ringbuffer error!\n");
-			return -1;
-		}
-		init_waitqueue_head(&obj->client[handle].wait);
-		break;
-	/*
-	 * other sensor like google onchange and oneshot sensor or mtk add
-	 * oneshot onchange sensor
-	 * ringbuffer is 16 due to no batch flow
-	 */
-	default:
-		spin_lock_init(&obj->client[handle].buffer_lock);
-		lockdep_set_class(&obj->client[handle].buffer_lock,
-				  &buffer_lock_key[handle]);
-
-		obj->client[handle].head = 0;
-		obj->client[handle].tail = 0;
-		obj->client[handle].bufsize = OTHER_SENSOR_BUF_SIZE;
-		obj->client[handle].buffull = false;
-		obj->client[handle].buffer =
-			vzalloc(obj->client[handle].bufsize *
-				sizeof(struct sensor_event));
-		if (!obj->client[handle].buffer) {
-			pr_err("Alloc ringbuffer error!\n");
-			return -1;
-		}
-		init_waitqueue_head(&obj->client[handle].wait);
-		break;
-	}
-	return 0;
-}
-EXPORT_SYMBOL(sensor_event_register);
-
-unsigned int sensor_event_deregister(unsigned char handle)
-{
-	struct sensor_event_obj *obj = event_obj;
-
-	vfree(obj->client[handle].buffer);
-	return 0;
-}
-EXPORT_SYMBOL(sensor_event_deregister);
-
-static int __init sensor_event_entry(void)
-{
-	struct sensor_event_obj *obj =
-		kzalloc(sizeof(struct sensor_event_obj), GFP_KERNEL);
-
-	event_obj = obj;
-
-	sensor_attr_init();
-
-	return 0;
-}
-
-static void __exit sensor_event_exit(void)
-{
-	sensor_attr_exit();
-	kfree(event_obj);
-}
-
-subsys_initcall(sensor_event_entry);
-module_exit(sensor_event_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("sensor event driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_list/sensor_list.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_list/sensor_list.c
deleted file mode 100644
index 8401523..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_list/sensor_list.c
+++ /dev/null
@@ -1,238 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<SEN_LIST> " fmt
-
-#include <linux/module.h>
-#include <linux/miscdevice.h>
-#include <linux/types.h>
-#include <linux/workqueue.h>
-#include <linux/atomic.h>
-#include <linux/spinlock.h>
-#include <linux/uaccess.h>
-
-#include "SCP_sensorHub.h"
-#include "sensor_list.h"
-#include "SCP_power_monitor.h"
-#include "hwmsensor.h"
-
-struct sensorlist_info_t {
-	char name[16];
-};
-
-enum {
-	accel,
-	gyro,
-	mag,
-	als,
-	ps,
-	baro,
-	sar,
-	maxhandle,
-};
-
-#ifdef CONFIG_CUSTOM_KERNEL_SENSORHUB
-static struct work_struct sensorlist_work;
-#endif
-static atomic_t first_ready_after_boot;
-static struct sensorlist_info_t sensorlist_info[maxhandle];
-static DEFINE_SPINLOCK(sensorlist_info_lock);
-
-inline int sensor_to_handle(int sensor)
-{
-	int handle = -1;
-
-	switch (sensor) {
-	case ID_ACCELEROMETER:
-		handle = accel;
-		break;
-	case ID_GYROSCOPE:
-		handle = gyro;
-		break;
-	case ID_MAGNETIC:
-		handle = mag;
-		break;
-	case ID_LIGHT:
-		handle = als;
-		break;
-	case ID_PROXIMITY:
-		handle = ps;
-		break;
-	case ID_PRESSURE:
-		handle = baro;
-		break;
-	case ID_SAR:
-		handle = sar;
-		break;
-	}
-	return handle;
-}
-
-static inline int handle_to_sensor(int handle)
-{
-	int sensor = -1;
-
-	switch (handle) {
-	case accel:
-		sensor = ID_ACCELEROMETER;
-		break;
-	case gyro:
-		sensor = ID_GYROSCOPE;
-		break;
-	case mag:
-		sensor = ID_MAGNETIC;
-		break;
-	case als:
-		sensor = ID_LIGHT;
-		break;
-	case ps:
-		sensor = ID_PROXIMITY;
-		break;
-	case baro:
-		sensor = ID_PRESSURE;
-		break;
-	case sar:
-		sensor = ID_SAR;
-		break;
-	}
-	return sensor;
-}
-
-static void init_sensorlist_info(void)
-{
-	int handle = -1;
-
-	for (handle = accel; handle < maxhandle; ++handle)
-		strlcpy(sensorlist_info[handle].name,
-			"NULL",
-			sizeof(sensorlist_info[handle].name));
-}
-
-#ifdef CONFIG_CUSTOM_KERNEL_SENSORHUB
-static void sensorlist_get_deviceinfo(struct work_struct *work)
-{
-	int err = 0, handle = -1, sensor = -1;
-	struct sensorInfo_t devinfo;
-
-	for (handle = accel; handle < maxhandle; ++handle) {
-		sensor = handle_to_sensor(handle);
-		if (sensor < 0)
-			continue;
-		memset(&devinfo, 0, sizeof(struct sensorInfo_t));
-		err = sensor_set_cmd_to_hub(sensor,
-			CUST_ACTION_GET_SENSOR_INFO, &devinfo);
-		if (err < 0) {
-			pr_err("sensor(%d) not register\n", sensor);
-			continue;
-		}
-		spin_lock(&sensorlist_info_lock);
-		strlcpy(sensorlist_info[handle].name,
-			devinfo.name,
-			sizeof(sensorlist_info[handle].name));
-		spin_unlock(&sensorlist_info_lock);
-	}
-}
-
-static int scp_ready_event(uint8_t event, void *ptr)
-{
-	pr_err("%s, event:%u\n", __func__, event);
-	switch (event) {
-	case SENSOR_POWER_UP:
-		if (likely(atomic_xchg(&first_ready_after_boot, 1)))
-			return 0;
-		schedule_work(&sensorlist_work);
-		break;
-	case SENSOR_POWER_DOWN:
-		break;
-	}
-	return 0;
-}
-
-static struct scp_power_monitor scp_ready_notifier = {
-	.name = "sensorlist",
-	.notifier_call = scp_ready_event,
-};
-#else
-int sensorlist_register_deviceinfo(int sensor,
-		struct sensorInfo_NonHub_t *devinfo)
-{
-	int handle = -1;
-
-	handle = sensor_to_handle(sensor);
-	if (handle < 0)
-		return -1;
-	spin_lock(&sensorlist_info_lock);
-	strlcpy(sensorlist_info[handle].name,
-		devinfo->name,
-		sizeof(sensorlist_info[handle].name));
-	spin_unlock(&sensorlist_info_lock);
-	return 0;
-}
-#endif
-
-static int sensorlist_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static ssize_t
-sensorlist_read(struct file *file, char __user *buf,
-	size_t count, loff_t *ptr)
-{
-	if (!atomic_read(&first_ready_after_boot))
-		return -EINVAL;
-	if (count == 0)
-		return -EINVAL;
-	if (count < sizeof(struct sensorlist_info_t))
-		return -EINVAL;
-	if (count > maxhandle * sizeof(struct sensorlist_info_t))
-		count = maxhandle * sizeof(struct sensorlist_info_t);
-
-	spin_lock(&sensorlist_info_lock);
-	if (copy_to_user(buf, sensorlist_info, count)) {
-		spin_unlock(&sensorlist_info_lock);
-		return -EFAULT;
-	}
-	spin_unlock(&sensorlist_info_lock);
-	return count;
-}
-
-static const struct file_operations sensorlist_fops = {
-	.owner		= THIS_MODULE,
-	.open		= sensorlist_open,
-	.read		= sensorlist_read,
-};
-
-static struct miscdevice sensorlist_miscdev = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "sensorlist",
-	.fops = &sensorlist_fops,
-};
-
-static int __init sensorlist_init(void)
-{
-	int ret = 0;
-
-	init_sensorlist_info();
-	ret = misc_register(&sensorlist_miscdev);
-	if (ret < 0)
-		return -1;
-	atomic_set(&first_ready_after_boot, 0);
-#ifdef CONFIG_CUSTOM_KERNEL_SENSORHUB
-	INIT_WORK(&sensorlist_work, sensorlist_get_deviceinfo);
-	scp_power_monitor_register(&scp_ready_notifier);
-#endif
-	return 0;
-}
-
-static void __exit sensorlist_exit(void)
-{
-
-}
-module_init(sensorlist_init);
-module_exit(sensorlist_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("dynamic sensorlist driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_performance/sensor_performance.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_performance/sensor_performance.c
deleted file mode 100644
index d2df104..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/hwmon/sensor_performance/sensor_performance.c
+++ /dev/null
@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<SEN_PER> " fmt
-
-#include <hwmsensor.h>
-#include <linux/types.h>
-#include <sensor_performance.h>
-
-#ifdef DEBUG_PERFORMANCE
-struct time_records record[STATUS_MAX];
-void mark_timestamp(u8 sensor_type, enum SENSOR_STATUS status, u64 current_time,
-		    u64 event_time)
-{
-	record[status].check_time = current_time;
-	record[status].count++;
-
-	if (status == STATUS_MAX - 1) {
-		int i;
-
-		record[GOT_IPI].sum_kernel_time +=
-			record[GOT_IPI].check_time - event_time;
-		for (i = 1; i < STATUS_MAX; i++)
-			record[i].sum_kernel_time +=
-				record[i].check_time - record[i - 1].check_time;
-		if (record[status].count == LIMIT) {
-			for (i = 0; i < STATUS_MAX; i++) {
-				pr_debug(
-					"Sensor[%d] ====> last event stage[%d] check time:%lld\n",
-					sensor_type, i, record[i].check_time);
-				pr_debug(
-					"sensor[%d] ====> stage[%d] average delta time:%lld on %d events\n",
-					sensor_type, i,
-					record[i].sum_kernel_time / LIMIT,
-					record[i].count);
-				record[i].sum_kernel_time = 0;
-				record[i].count = 0;
-			}
-		}
-	}
-}
-
-struct time_records ipi_time_records;
-void mark_ipi_timestamp(uint64_t cyc)
-{
-#define ARCH_TIMER_MULT 161319385
-#define ARCH_TIMER_SHIFT 21
-	uint64_t time_ns = (cyc * ARCH_TIMER_MULT) >> ARCH_TIMER_SHIFT;
-
-	ipi_time_records.sum_kernel_time += time_ns;
-	ipi_time_records.count++;
-	if (ipi_time_records.count == LIMIT) {
-		pr_debug("Sensor ====> ipi average time on 1000 is :%lld\n",
-			 ipi_time_records.sum_kernel_time / LIMIT);
-		ipi_time_records.sum_kernel_time = 0;
-		ipi_time_records.count = 0;
-	}
-}
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/Kconfig
deleted file mode 100644
index af4317d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/Kconfig
+++ /dev/null
@@ -1,20 +0,0 @@
-
-config MTK_AUTO_DETECT_MAGNETOMETER
-	bool "MTK AUTO DETECT MAGNETOMETER Sensor"
-	help
-	  one load to support different magnetometer sensor.
-	  This feature Option is used for projects which using more than one
-	  magnetometer, more than one ALSPS drivers can be builded in to
-	  project and be auto detected by setting this option to yes
-
-config CUSTOM_KERNEL_MAGNETOMETER
-	bool "CUSTOM KERNEL MAGNETOMETER Config"
-	help
-	  compass driver to detect compass raw data and report orientatino
-	  data. A compass is an instrument used for navigation and
-	  orientation that shows direction relative to the geographic
-	  cardinal directions, or "points".
-
-source "drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/magnetometer/akm09915/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/magnetometer/akm09918/Kconfig"
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/Makefile
deleted file mode 100644
index d34b549..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# In case the platform does NOT support this type of sensors
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/accelerometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/magnetometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/include
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)   +=  mag_common.o
-mag_common-$(CONFIG_MTK_SENSOR_SUPPORT)   +=  mag.o mag_factory.o
-
-obj-$(CONFIG_MTK_MAGHUB)        +=  maghub/
-#obj-$(CONFIG_MTK_AKM09915_NEW)         +=  akm09915/
-#obj-$(CONFIG_MTK_AKM09918)          +=  akm09918/
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/cust_mag.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/cust_mag.h
deleted file mode 100644
index dab0e87..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/cust_mag.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __CUST_MAG_H__
-#define __CUST_MAG_H__
-
-#include <linux/i2c.h>
-#include <linux/device.h>
-#include <linux/types.h>
-
-#define M_CUST_I2C_ADDR_NUM 2
-
-struct mag_hw {
-	int i2c_num;
-	int direction;
-	int power_id;
-	int power_vol;
-	unsigned char	i2c_addr[M_CUST_I2C_ADDR_NUM];
-	int power_vio_id;
-	int power_vio_vol;
-	bool is_batch_supported;
-};
-
-int get_mag_dts_func(struct device_node *node, struct mag_hw *hw);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/mag.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/mag.h
deleted file mode 100644
index ecda53d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/mag.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __MAG_H__
-#define __MAG_H__
-
-//#include <linux/wakelock.h>
-#include <linux/atomic.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/kobject.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/poll.h>
-#include <linux/proc_fs.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/workqueue.h>
-
-#include "mag_factory.h"
-#include "sensor_attr.h"
-#include "sensor_event.h"
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-#include <sensors_io.h>
-
-
-#define OP_MAG_DELAY 0X01
-#define OP_MAG_ENABLE 0X02
-#define OP_MAG_GET_DATA 0X04
-
-#define MAG_INVALID_VALUE -1
-
-#define EVENT_TYPE_MAGEL_X ABS_X
-#define EVENT_TYPE_MAGEL_Y ABS_Y
-#define EVENT_TYPE_MAGEL_Z ABS_Z
-#define EVENT_TYPE_MAGEL_UPDATE REL_X
-#define EVENT_DIV_MAGEL ABS_RUDDER
-#define EVENT_TYPE_MAGEL_STATUS ABS_WHEEL
-#define EVENT_TYPE_MAG_UPDATE REL_X
-#define EVENT_TYPE_MAG_TIMESTAMP_HI REL_HWHEEL
-#define EVENT_TYPE_MAG_TIMESTAMP_LO REL_DIAL
-
-#define MAG_DIV_MAX (32767)
-#define MAG_DIV_MIN (1)
-
-#define MAG_VALUE_MAX (32767)
-#define MAG_VALUE_MIN (-32768)
-#define MAG_STATUS_MIN (0)
-#define MAG_STATUS_MAX (64)
-
-#define MAX_CHOOSE_G_NUM 5
-
-#define MAX_M_V_SENSOR 5
-
-#define ID_M_V_MAGNETIC 0
-
-struct mag_data_path {
-	int div;
-	int (*get_data)(int *x, int *y, int *z, int *status);
-	int (*get_raw_data)(int *x, int *y, int *z);
-};
-
-struct mag_libinfo_t {
-	char libname[64];
-	int32_t layout;
-	int32_t deviceid;
-};
-
-struct mag_control_path {
-	int (*open_report_data)(int en);
-	int (*set_delay)(u64 delay);
-	int (*enable)(int en);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		     int64_t maxBatchReportLatencyNs);
-	int (*flush)(void);
-	int (*set_cali)(uint8_t *data, uint8_t count);
-	bool is_report_input_direct;
-	bool is_support_batch;
-	bool is_use_common_factory;
-	struct mag_libinfo_t libinfo;
-};
-
-struct mag_init_info {
-	char *name;
-	int (*init)(void);
-	int (*uninit)(void);
-	struct platform_driver *platform_diver_addr;
-};
-
-struct mag_data {
-	int8_t status;
-	int8_t reserved[3];
-	int x;
-	int y;
-	int z;
-	int64_t timestamp;
-	void *reserved1;
-};
-
-struct mag_drv_obj {
-	void *self;
-	int polling;
-	int (*mag_operate)(void *self, uint32_t command, void *buff_in,
-			   int size_in, void *buff_out, int size_out,
-			   int *actualout);
-};
-
-struct mag_context {
-	struct sensor_attr_t mdev;
-	struct work_struct report;
-	struct mutex mag_op_mutex;
-	atomic_t delay; /*polling period for reporting input event*/
-	atomic_t wake;  /*user-space request to wake-up, used with stop*/
-	struct timer_list timer; /* polling timer */
-	struct hrtimer hrTimer;
-	ktime_t target_ktime;
-	atomic_t trace;
-	struct workqueue_struct *mag_workqueue;
-
-	struct mag_data_path mag_dev_data;
-	struct mag_control_path mag_ctl;
-	atomic_t early_suspend;
-	struct mag_data drv_data;
-	bool is_first_data_after_enable;
-	bool is_polling_run;
-	bool is_batch_enable;
-	int power;
-	int enable;
-	int64_t delay_ns;
-	int64_t latency_ns;
-};
-
-extern int mag_attach(int sensor, struct mag_drv_obj *obj);
-
-extern int mag_driver_add(struct mag_init_info *obj);
-extern int mag_data_report(struct mag_data *data);
-extern int mag_bias_report(struct mag_data *data);
-extern int mag_flush_report(void);
-extern int mag_info_record(struct mag_libinfo_t *p_mag_info);
-extern int mag_cali_report(int32_t *param);
-extern int mag_register_control_path(struct mag_control_path *ctl);
-extern int mag_register_data_path(struct mag_data_path *ctl);
-extern int mag_probe(void);
-extern int mag_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/mag_factory.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/mag_factory.h
deleted file mode 100644
index fdcb0b6..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/inc/mag_factory.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __MAG_FACTORY_H__
-#define __MAG_FACTORY_H__
-
-#include "mag.h"
-#include "cust_mag.h"
-
-extern struct mag_context *mag_context_obj;
-
-#define SETCALI 1
-#define CLRCALI 2
-#define GETCALI 3
-
-struct mag_factory_fops {
-	int (*enable_sensor)(bool enable_disable, int64_t sample_periods_ms);
-	int (*get_data)(int32_t data[3], int *status);
-	int (*get_raw_data)(int32_t data[3]);
-	int (*enable_calibration)(void);
-	int (*clear_cali)(void);
-	int (*set_cali)(int32_t offset[3]);
-	int (*get_cali)(int32_t offset[3]);
-	int (*do_self_test)(void);
-};
-
-struct mag_factory_public {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct mag_factory_fops *fops;
-};
-int mag_factory_device_register(struct mag_factory_public *dev);
-int mag_factory_device_deregister(struct mag_factory_public *dev);
-
-
-#endif
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/mag.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/mag.c
deleted file mode 100644
index f001726..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/mag.c
+++ /dev/null
@@ -1,824 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<MAG> " fmt
-
-#include "inc/mag.h"
-#include "sensor_performance.h"
-#include <linux/vmalloc.h>
-
-struct mag_context *mag_context_obj /* = NULL*/;
-static struct mag_init_info *msensor_init_list[MAX_CHOOSE_G_NUM] = {0};
-
-static void initTimer(struct hrtimer *timer,
-		      enum hrtimer_restart (*callback)(struct hrtimer *))
-{
-	hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
-	timer->function = callback;
-}
-
-static void startTimer(struct hrtimer *timer, int delay_ms, bool first)
-{
-	struct mag_context *obj = (struct mag_context *)container_of(timer,
-		struct mag_context, hrTimer);
-
-	if (obj == NULL) {
-		pr_err("NULL pointer\n");
-		return;
-	}
-
-	if (first) {
-		obj->target_ktime =
-			ktime_add_ns(ktime_get(), (int64_t)delay_ms * 1000000);
-	} else {
-		do {
-			obj->target_ktime = ktime_add_ns(
-				obj->target_ktime, (int64_t)delay_ms * 1000000);
-		} while (ktime_to_ns(obj->target_ktime) <
-			 ktime_to_ns(ktime_get()));
-	}
-
-	hrtimer_start(timer, obj->target_ktime, HRTIMER_MODE_ABS);
-}
-#ifndef CONFIG_NANOHUB
-static void stopTimer(struct hrtimer *timer)
-{
-	hrtimer_cancel(timer);
-}
-#endif
-static void mag_work_func(struct work_struct *work)
-{
-	struct mag_context *cxt = NULL;
-	struct hwm_sensor_data sensor_data;
-	int64_t m_pre_ns, cur_ns;
-	int64_t delay_ms;
-	struct timespec time;
-	int err;
-	int x, y, z, status;
-
-	cxt = mag_context_obj;
-	delay_ms = atomic_read(&cxt->delay);
-	memset(&sensor_data, 0, sizeof(sensor_data));
-	time.tv_sec = time.tv_nsec = 0;
-	get_monotonic_boottime(&time);
-	cur_ns = time.tv_sec * 1000000000LL + time.tv_nsec;
-
-	err = cxt->mag_dev_data.get_data(&x, &y, &z, &status);
-	if (err) {
-		pr_err("get data fails!!\n");
-		return;
-	}
-	cxt->drv_data.x = x;
-	cxt->drv_data.y = y;
-	cxt->drv_data.z = z;
-	cxt->drv_data.status = status;
-	m_pre_ns = cxt->drv_data.timestamp;
-	cxt->drv_data.timestamp = cur_ns;
-	if (true == cxt->is_first_data_after_enable) {
-		m_pre_ns = cur_ns;
-		cxt->is_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.x == MAG_INVALID_VALUE ||
-		    cxt->drv_data.y == MAG_INVALID_VALUE ||
-		    cxt->drv_data.z == MAG_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto mag_loop;
-		}
-	}
-	while ((cur_ns - m_pre_ns) >= delay_ms * 1800000LL) {
-		struct mag_data tmp_data = cxt->drv_data;
-
-		m_pre_ns += delay_ms * 1000000LL;
-		tmp_data.timestamp = m_pre_ns;
-		mag_data_report(&tmp_data);
-	}
-
-	mag_data_report(&cxt->drv_data);
-
-mag_loop:
-
-	if (true == cxt->is_polling_run)
-		startTimer(&cxt->hrTimer, atomic_read(&cxt->delay), false);
-}
-
-enum hrtimer_restart mag_poll(struct hrtimer *timer)
-{
-	struct mag_context *obj = (struct mag_context *)container_of(timer,
-		struct mag_context, hrTimer);
-
-	queue_work(obj->mag_workqueue, &obj->report);
-
-	return HRTIMER_NORESTART;
-}
-
-static struct mag_context *mag_context_alloc_object(void)
-{
-
-	struct mag_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc magel object error!\n");
-		return NULL;
-	}
-
-	atomic_set(&obj->delay, 200); /* set work queue delay time 200ms */
-	atomic_set(&obj->wake, 0);
-	INIT_WORK(&obj->report, mag_work_func);
-	obj->mag_workqueue = NULL;
-	obj->mag_workqueue = create_workqueue("mag_polling");
-	if (!obj->mag_workqueue) {
-		kfree(obj);
-		return NULL;
-	}
-	initTimer(&obj->hrTimer, mag_poll);
-	obj->is_first_data_after_enable = false;
-	obj->is_polling_run = false;
-	obj->is_batch_enable = false;
-	mutex_init(&obj->mag_op_mutex);
-	obj->power = 0;
-	obj->enable = 0;
-	obj->delay_ns = -1;
-	obj->latency_ns = -1;
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-
-#ifndef CONFIG_NANOHUB
-static int mag_enable_and_batch(void)
-{
-	struct mag_context *cxt = mag_context_obj;
-	int err;
-
-	/* power on -> power off */
-	if (cxt->power == 1 && cxt->enable == 0) {
-		pr_debug("MAG disable\n");
-		/* stop polling firstly, if needed */
-		if (cxt->mag_ctl.is_report_input_direct == false &&
-		    cxt->is_polling_run == true) {
-			smp_mb(); /* for memory barrier */
-			stopTimer(&cxt->hrTimer);
-			smp_mb(); /* for memory barrier */
-			cancel_work_sync(&cxt->report);
-			cxt->drv_data.x = MAG_INVALID_VALUE;
-			cxt->drv_data.y = MAG_INVALID_VALUE;
-			cxt->drv_data.z = MAG_INVALID_VALUE;
-			cxt->is_polling_run = false;
-			pr_debug("mag stop polling done\n");
-		}
-		/* turn off the power */
-		err = cxt->mag_ctl.enable(0);
-		if (err) {
-			pr_err("mag turn off power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("mag turn off power done\n");
-
-		cxt->power = 0;
-		cxt->delay_ns = -1;
-		pr_debug("MAG disable done\n");
-		return 0;
-	}
-	/* power off -> power on */
-	if (cxt->power == 0 && cxt->enable == 1) {
-		pr_debug("MAG power on\n");
-		err = cxt->mag_ctl.enable(1);
-		if (err) {
-			pr_err("mag turn on power err = %d\n", err);
-			return -1;
-		}
-		pr_debug("mag turn on power done\n");
-
-		cxt->power = 1;
-		pr_debug("MAG power on done\n");
-	}
-	/* rate change */
-	if (cxt->power == 1 && cxt->delay_ns >= 0) {
-		pr_debug("MAG set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->mag_ctl.is_support_batch)
-			err = cxt->mag_ctl.batch(0, cxt->delay_ns,
-						 cxt->latency_ns);
-		else
-			err = cxt->mag_ctl.batch(0, cxt->delay_ns, 0);
-		if (err) {
-			pr_err("mag set batch(ODR) err %d\n", err);
-			return -1;
-		}
-		pr_debug("mag set ODR, fifo latency done\n");
-		/* start polling, if needed */
-		if (cxt->mag_ctl.is_report_input_direct == false) {
-			uint64_t mdelay = cxt->delay_ns;
-
-			do_div(mdelay, 1000000);
-			atomic_set(&cxt->delay, mdelay);
-			/* the first sensor start polling timer */
-			if (cxt->is_polling_run == false) {
-				cxt->is_polling_run = true;
-				cxt->is_first_data_after_enable = true;
-				startTimer(&cxt->hrTimer,
-					   atomic_read(&cxt->delay), true);
-			}
-			pr_debug("mag set polling delay %d ms\n",
-				atomic_read(&cxt->delay));
-		}
-		pr_debug("MAG batch done\n");
-	}
-	return 0;
-}
-#endif
-/*----------------------------------------------------------------------------*/
-static ssize_t magdev_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug("sensor test: mag function!\n");
-	return len;
-}
-static ssize_t magactive_store(struct device *dev,
-				struct device_attribute *attr, const char *buf,
-				size_t count)
-{
-	struct mag_context *cxt = mag_context_obj;
-	int err = 0;
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&mag_context_obj->mag_op_mutex);
-
-	if (!strncmp(buf, "1", 1))
-		cxt->enable = 1;
-	else if (!strncmp(buf, "0", 1))
-		cxt->enable = 0;
-	else {
-		pr_err("%s error !!\n", __func__);
-		err = -1;
-		goto err_out;
-	}
-#ifdef CONFIG_NANOHUB
-	err = cxt->mag_ctl.enable(cxt->enable);
-	if (err) {
-		pr_err("mag turn on power err = %d\n", err);
-		goto err_out;
-	}
-#else
-	err = mag_enable_and_batch();
-#endif
-
-err_out:
-	mutex_unlock(&mag_context_obj->mag_op_mutex);
-	pr_debug("%s done\n", __func__);
-	if (err)
-		return err;
-	else
-		return count;
-}
-/*----------------------------------------------------------------------------*/
-static ssize_t magactive_show(struct device *dev,
-			       struct device_attribute *attr, char *buf)
-{
-	struct mag_context *cxt = NULL;
-	int div = 0;
-
-	cxt = mag_context_obj;
-	div = cxt->mag_dev_data.div;
-	pr_debug("mag mag_dev_data m_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-static ssize_t magbatch_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct mag_context *cxt = mag_context_obj;
-	int handle = 0, flag = 0, err = 0;
-
-	pr_debug("%s %s\n", __func__, buf);
-	err = sscanf(buf, "%d,%d,%lld,%lld", &handle, &flag, &cxt->delay_ns,
-		     &cxt->latency_ns);
-	if (err != 4) {
-		pr_err("%s param error: err = %d\n", __func__, err);
-		return -1;
-	}
-
-	mutex_lock(&mag_context_obj->mag_op_mutex);
-#ifdef CONFIG_NANOHUB
-	if (cxt->mag_ctl.is_support_batch)
-		err = cxt->mag_ctl.batch(0, cxt->delay_ns, cxt->latency_ns);
-	else
-		err = cxt->mag_ctl.batch(0, cxt->delay_ns, 0);
-	if (err)
-		pr_err("mag set batch(ODR) err %d\n", err);
-#else
-	err = mag_enable_and_batch();
-#endif
-	mutex_unlock(&mag_context_obj->mag_op_mutex);
-	pr_debug("%s done: %d\n", __func__, cxt->is_batch_enable);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t magbatch_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-static ssize_t magflush_show(struct device *dev, struct device_attribute *attr,
-			      char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t magflush_store(struct device *dev,
-			       struct device_attribute *attr, const char *buf,
-			       size_t count)
-{
-	struct mag_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&mag_context_obj->mag_op_mutex);
-	cxt = mag_context_obj;
-	if (cxt->mag_ctl.flush != NULL)
-		err = cxt->mag_ctl.flush();
-	else
-		pr_debug(
-			"MAG DRIVER OLD ARCHITECTURE DON'T SUPPORT ACC COMMON VERSION FLUSH\n");
-	if (err < 0)
-		pr_err("mag enable flush err %d\n", err);
-	mutex_unlock(&mag_context_obj->mag_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t magcali_show(struct device *dev, struct device_attribute *attr,
-			     char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t magcali_store(struct device *dev, struct device_attribute *attr,
-			      const char *buf, size_t count)
-{
-	struct mag_context *cxt = NULL;
-	int err = 0;
-	uint8_t *cali_buf = NULL;
-
-	cali_buf = vzalloc(count);
-	if (cali_buf == NULL)
-		return -EFAULT;
-	memcpy(cali_buf, buf, count);
-
-	mutex_lock(&mag_context_obj->mag_op_mutex);
-	cxt = mag_context_obj;
-	if (cxt->mag_ctl.set_cali != NULL)
-		err = cxt->mag_ctl.set_cali(cali_buf, count);
-	else
-		pr_debug(
-			"MAG DRIVER OLD ARCHITECTURE DON'T SUPPORT MAG COMMON VERSION FLUSH\n");
-	if (err < 0)
-		pr_err("mag set cali err %d\n", err);
-	mutex_unlock(&mag_context_obj->mag_op_mutex);
-	vfree(cali_buf);
-	return count;
-}
-
-/* need work around again */
-static ssize_t magdevnum_show(struct device *dev,
-				     struct device_attribute *attr, char *buf)
-{
-
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t maglibinfo_show(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	struct mag_context *cxt = mag_context_obj;
-
-	if (!buf)
-		return -1;
-	memcpy(buf, &cxt->mag_ctl.libinfo, sizeof(struct mag_libinfo_t));
-	return sizeof(struct mag_libinfo_t);
-}
-
-static int msensor_remove(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int msensor_probe(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id msensor_of_match[] = {
-	{
-		.compatible = "mediatek,msensor",
-	},
-	{},
-};
-#endif
-
-static struct platform_driver msensor_driver = {
-	.probe = msensor_probe,
-	.remove = msensor_remove,
-	.driver = {
-
-		.name = "msensor",
-#ifdef CONFIG_OF
-		.of_match_table = msensor_of_match,
-#endif
-	}
-};
-
-static int mag_real_driver_init(void)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_G_NUM; i++) {
-		pr_debug(" i=%d\n", i);
-		if (msensor_init_list[i] != 0) {
-			pr_debug(" mag try to init driver %s\n",
-				msensor_init_list[i]->name);
-			err = msensor_init_list[i]->init();
-			if (err == 0) {
-				pr_debug(" mag real driver %s probe ok\n",
-					msensor_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_G_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-
-int mag_driver_add(struct mag_init_info *obj)
-{
-	int err = 0;
-	int i = 0;
-
-	pr_debug("%s\n", __func__);
-	if (!obj) {
-		pr_err("%s fail, mag_init_info is NULL\n", __func__);
-		return -1;
-	}
-
-	for (i = 0; i < MAX_CHOOSE_G_NUM; i++) {
-		if ((i == 0) && (msensor_init_list[0] == NULL)) {
-			pr_debug("register mensor driver for the first time\n");
-			if (platform_driver_register(&msensor_driver))
-				pr_err(
-					"failed to register msensor driver already exist\n");
-		}
-		if (msensor_init_list[i] == NULL) {
-			obj->platform_diver_addr = &msensor_driver;
-			msensor_init_list[i] = obj;
-			break;
-		}
-	}
-
-	if (i >= MAX_CHOOSE_G_NUM) {
-		pr_err("MAG driver add err\n");
-		err = -1;
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_driver_add);
-static int magnetic_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t magnetic_read(struct file *file, char __user *buffer,
-			     size_t count, loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(mag_context_obj->mdev.minor, file, buffer,
-				     count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int magnetic_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(mag_context_obj->mdev.minor, file, wait);
-}
-
-static const struct file_operations mag_fops = {
-	.owner = THIS_MODULE,
-	.open = magnetic_open,
-	.read = magnetic_read,
-	.poll = magnetic_poll,
-};
-
-static int mag_misc_init(struct mag_context *cxt)
-{
-
-	int err = 0;
-
-	cxt->mdev.minor = ID_MAGNETIC;
-	cxt->mdev.name = MAG_MISC_DEV_NAME;
-	cxt->mdev.fops = &mag_fops;
-	err = sensor_attr_register(&cxt->mdev);
-	if (err)
-		pr_err("unable to register mag misc device!!\n");
-
-	return err;
-}
-
-DEVICE_ATTR_RO(magdev);
-DEVICE_ATTR_RW(magactive);
-DEVICE_ATTR_RW(magbatch);
-DEVICE_ATTR_RW(magflush);
-DEVICE_ATTR_RW(magcali);
-DEVICE_ATTR_RO(magdevnum);
-DEVICE_ATTR_RO(maglibinfo);
-
-static struct attribute *mag_attributes[] = {
-	&dev_attr_magdev.attr,
-	&dev_attr_magactive.attr,
-	&dev_attr_magbatch.attr,
-	&dev_attr_magflush.attr,
-	&dev_attr_magcali.attr,
-	&dev_attr_magdevnum.attr,
-	&dev_attr_maglibinfo.attr,
-	NULL
-};
-
-static struct attribute_group mag_attribute_group = {
-	.attrs = mag_attributes
-};
-
-int mag_register_data_path(struct mag_data_path *data)
-{
-	struct mag_context *cxt = NULL;
-
-	cxt = mag_context_obj;
-	cxt->mag_dev_data.div = data->div;
-	cxt->mag_dev_data.get_data = data->get_data;
-	cxt->mag_dev_data.get_raw_data = data->get_raw_data;
-	pr_debug("mag register data path div: %d\n", cxt->mag_dev_data.div);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(mag_register_data_path);
-
-int mag_register_control_path(struct mag_control_path *ctl)
-{
-	struct mag_context *cxt = NULL;
-	int err = 0;
-
-	cxt = mag_context_obj;
-	cxt->mag_ctl.set_delay = ctl->set_delay;
-	cxt->mag_ctl.enable = ctl->enable;
-	cxt->mag_ctl.open_report_data = ctl->open_report_data;
-	cxt->mag_ctl.batch = ctl->batch;
-	cxt->mag_ctl.flush = ctl->flush;
-	cxt->mag_ctl.set_cali = ctl->set_cali;
-	cxt->mag_ctl.is_report_input_direct = ctl->is_report_input_direct;
-	cxt->mag_ctl.is_support_batch = ctl->is_support_batch;
-	cxt->mag_ctl.is_use_common_factory = ctl->is_use_common_factory;
-	memcpy(cxt->mag_ctl.libinfo.libname, ctl->libinfo.libname,
-	       sizeof(cxt->mag_ctl.libinfo.libname));
-	cxt->mag_ctl.libinfo.layout = ctl->libinfo.layout;
-	cxt->mag_ctl.libinfo.deviceid = ctl->libinfo.deviceid;
-
-	if (cxt->mag_ctl.set_delay == NULL || cxt->mag_ctl.enable == NULL ||
-	    cxt->mag_ctl.open_report_data == NULL) {
-		pr_debug("mag register control path fail\n");
-		return -1;
-	}
-
-	/* add misc dev for sensor hal control cmd */
-	err = mag_misc_init(mag_context_obj);
-	if (err) {
-		pr_err("unable to register mag misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&mag_context_obj->mdev.this_device->kobj,
-				 &mag_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create mag attribute file\n");
-		return -3;
-	}
-
-	kobject_uevent(&mag_context_obj->mdev.this_device->kobj, KOBJ_ADD);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(mag_register_control_path);
-
-static int x1, y1, z1;
-static long pc;
-
-static int check_repeat_data(int x, int y, int z)
-{
-	if ((x1 == x) && (y1 == y) && (z1 == z))
-		pc++;
-	else
-		pc = 0;
-
-	x1 = x;
-	y1 = y;
-	z1 = z;
-
-	if (pc > 100) {
-		pr_debug("Mag sensor output repeat data\n");
-		pc = 0;
-	}
-
-	return 0;
-}
-
-int mag_data_report(struct mag_data *data)
-{
-	/* pr_debug("update!valus: %d, %d, %d, %d\n" , x, y, z, status); */
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	check_repeat_data(data->x, data->y, data->z);
-	event.flush_action = DATA_ACTION;
-	event.status = data->status;
-	event.time_stamp = data->timestamp;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-	event.word[3] = data->reserved[0];
-	event.word[4] = data->reserved[1];
-	event.word[5] = data->reserved[2];
-	event.reserved = data->reserved[0];
-
-	if (event.reserved == 1)
-		mark_timestamp(ID_MAGNETIC, DATA_REPORT, ktime_get_boot_ns(),
-			       event.time_stamp);
-	err = sensor_input_event(mag_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_data_report);
-
-int mag_bias_report(struct mag_data *data)
-{
-	/* pr_debug("update!valus: %d, %d, %d, %d\n" , x, y, z, status); */
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = BIAS_ACTION;
-	event.word[0] = data->x;
-	event.word[1] = data->y;
-	event.word[2] = data->z;
-
-	err = sensor_input_event(mag_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_bias_report);
-
-int mag_cali_report(int32_t *param)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.flush_action = CALI_ACTION;
-	event.word[0] = param[0];
-	event.word[1] = param[1];
-	event.word[2] = param[2];
-	event.word[3] = param[3];
-	event.word[4] = param[4];
-	event.word[5] = param[5];
-
-	err = sensor_input_event(mag_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_cali_report);
-
-int mag_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	pr_debug_ratelimited("flush\n");
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(mag_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_flush_report);
-
-int mag_info_record(struct mag_libinfo_t *p_mag_info)
-{
-	struct mag_context *cxt = NULL;
-	int err = 0;
-
-	cxt = mag_context_obj;
-
-	memcpy(cxt->mag_ctl.libinfo.libname,
-		p_mag_info->libname, sizeof(cxt->mag_ctl.libinfo.libname));
-	cxt->mag_ctl.libinfo.layout = p_mag_info->layout;
-	cxt->mag_ctl.libinfo.deviceid = p_mag_info->deviceid;
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_info_record);
-
-int mag_probe(void)
-{
-	int err;
-
-	pr_debug("%s ++++!!\n", __func__);
-	mag_context_obj = mag_context_alloc_object();
-	if (!mag_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-
-	/* init real mageleration driver */
-	err = mag_real_driver_init();
-	if (err) {
-		pr_err("mag_real_driver_init fail\n");
-		goto real_driver_init_fail;
-	}
-
-	pr_debug("%s OK !!\n", __func__);
-	return 0;
-
-real_driver_init_fail:
-	kfree(mag_context_obj);
-
-exit_alloc_data_failed:
-
-	pr_err("%s fail !!!\n", __func__);
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_probe);
-
-int mag_remove(void)
-{
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-	sysfs_remove_group(&mag_context_obj->mdev.this_device->kobj,
-			   &mag_attribute_group);
-
-	err = sensor_attr_deregister(&mag_context_obj->mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-
-	kfree(mag_context_obj);
-	platform_driver_unregister(&msensor_driver);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(mag_remove);
-
-static int __init mag_init(void)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static void __exit mag_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(mag_init);
-module_exit(mag_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("MAGELEROMETER device driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/mag_factory.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/mag_factory.c
deleted file mode 100644
index 7e1619e..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/mag_factory.c
+++ /dev/null
@@ -1,182 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<MAG_FAC> " fmt
-
-#include "inc/mag_factory.h"
-
-struct mag_factory_private {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct mag_factory_fops *fops;
-};
-
-static struct mag_factory_private mag_factory;
-
-static int mag_factory_open(struct inode *inode, struct file *file)
-{
-	file->private_data = mag_context_obj;
-
-	if (file->private_data == NULL) {
-		pr_err("null pointer!!\n");
-		return -EINVAL;
-	}
-	return nonseekable_open(inode, file);
-}
-
-static int mag_factory_release(struct inode *inode, struct file *file)
-{
-	file->private_data = NULL;
-	return 0;
-}
-
-static long mag_factory_unlocked_ioctl(struct file *file, unsigned int cmd,
-				       unsigned long arg)
-{
-	void __user *ptr = (void __user *)arg;
-	int err = 0, status = 0;
-	uint32_t flag = 0;
-	char strbuf[64];
-	int32_t data_buf[3] = {0};
-
-	if (_IOC_DIR(cmd) & _IOC_READ)
-		err = !access_ok(VERIFY_WRITE, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-	else if (_IOC_DIR(cmd) & _IOC_WRITE)
-		err = !access_ok(VERIFY_READ, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-
-	if (err) {
-		pr_err("access error: %08X, (%2d, %2d)\n", cmd,
-			   _IOC_DIR(cmd), _IOC_SIZE(cmd));
-		return -EFAULT;
-	}
-
-	switch (cmd) {
-	case MSENSOR_IOCTL_SENSOR_ENABLE:
-		if (copy_from_user(&flag, ptr, sizeof(flag)))
-			return -EFAULT;
-		if (mag_factory.fops != NULL &&
-		    mag_factory.fops->enable_sensor != NULL) {
-			pr_debug("MSENSOR_ENABLE,en: %d, sample_period:%dms\n",
-				flag, 5);
-			err = mag_factory.fops->enable_sensor(flag, 20);
-			if (err < 0) {
-				pr_err(
-					"MSENSOR_IOCTL_SENSOR_ENABLE fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("MSENSOR_IOCTL_SENSOR_ENABLE NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case MSENSOR_IOCTL_READ_SENSORDATA:
-		if (mag_factory.fops != NULL &&
-		    mag_factory.fops->get_data != NULL) {
-			err = mag_factory.fops->get_data(data_buf, &status);
-			if (err < 0) {
-				pr_err(
-					"MSENSOR_READ_SENSORDATA fail!\n");
-				return -EINVAL;
-			}
-			sprintf(strbuf, "%x %x %x", data_buf[0], data_buf[1],
-				data_buf[2]);
-			pr_debug("MSENSOR_IOCTL_READ_SENSORDATA read:(%s)!\n",
-				strbuf);
-			if (copy_to_user(ptr, strbuf, strlen(strbuf) + 1))
-				return -EFAULT;
-		} else {
-			pr_err("MSENSOR_IOCTL_READ_SENSORDATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case MSENSOR_IOCTL_SELF_TEST:
-		if (mag_factory.fops != NULL &&
-		    mag_factory.fops->do_self_test != NULL) {
-			err = mag_factory.fops->do_self_test();
-			if (err < 0) {
-				pr_err(
-					"MSENSOR_IOCTL_SELF_TEST fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("MSENSOR_IOCTL_SELF_TEST NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	default:
-		pr_debug("unknown IOCTL: 0x%08x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-	return 0;
-}
-
-#if IS_ENABLED(CONFIG_COMPAT)
-static long compat_mag_factory_unlocked_ioctl(struct file *filp,
-					      unsigned int cmd,
-					      unsigned long arg)
-{
-	if (!filp->f_op || !filp->f_op->unlocked_ioctl) {
-		pr_err(
-			"compat_ion_ioctl file has no f_op or no f_op->unlocked_ioctl.\n");
-		return -ENOTTY;
-	}
-
-	switch (cmd) {
-	case COMPAT_MSENSOR_IOCTL_READ_SENSORDATA:
-	case COMPAT_MSENSOR_IOCTL_SENSOR_ENABLE:
-	case COMPAT_MSENSOR_IOCTL_SELF_TEST:
-		pr_debug("compat_ion_ioctl : MSENSOR_IOCTL_XXX is 0x%x\n",
-			cmd);
-		return filp->f_op->unlocked_ioctl(
-			filp, cmd, (unsigned long)compat_ptr(arg));
-	default:
-		pr_err("compat_ion_ioctl : No such command!! 0x%x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-}
-#endif
-
-static const struct file_operations mag_factory_fops = {
-	.open = mag_factory_open,
-	.release = mag_factory_release,
-	.unlocked_ioctl = mag_factory_unlocked_ioctl,
-#if IS_ENABLED(CONFIG_COMPAT)
-	.compat_ioctl = compat_mag_factory_unlocked_ioctl,
-#endif
-};
-
-static struct miscdevice mag_factory_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "msensor",
-	.fops = &mag_factory_fops,
-};
-
-int mag_factory_device_register(struct mag_factory_public *dev)
-{
-	int err = 0;
-
-	if (!dev || !dev->fops)
-		return -1;
-	mag_factory.gain = dev->gain;
-	mag_factory.sensitivity = dev->sensitivity;
-	mag_factory.fops = dev->fops;
-	err = misc_register(&mag_factory_device);
-	if (err) {
-		pr_err("%s register failed\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(mag_factory_device_register);
-
-int mag_factory_device_deregister(struct mag_factory_public *dev)
-{
-	mag_factory.fops = NULL;
-	misc_deregister(&mag_factory_device);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(mag_factory_device_deregister);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Kconfig
deleted file mode 100644
index f8a2772..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_MAGHUB
-	bool "maghub for MediaTek package"
-	help
-	  It support different maghub sensor.
-	  If this option is set,
-	  it will support
-	  sensorhub gyroscope.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Makefile
deleted file mode 100644
index 3ec8fd1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/magnetometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) += maghub.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/maghub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/maghub.c
deleted file mode 100644
index 92e3c0d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/maghub.c
+++ /dev/null
@@ -1,724 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[Msensor] " fmt
-
-#include <hwmsensor.h>
-#include "maghub.h"
-#include "mag.h"
-#include <SCP_sensorHub.h>
-#include "SCP_power_monitor.h"
-
-#define MAGHUB_DEV_NAME         "mag_hub"
-#define DRIVER_VERSION          "1.0.1"
-
-struct maghub_ipi_data *mag_ipi_data;
-static struct mag_init_info maghub_init_info;
-
-static int maghub_init_flag = -1;
-static DEFINE_SPINLOCK(calibration_lock);
-
-enum {
-	MAG_FUN_DEBUG = 0x01,
-	MAG_MDATA_DEBUG = 0X02,
-	MAG_ODATA_DEBUG = 0X04,
-	MAG_CTR_DEBUG = 0X08,
-	MAG_IPI_DEBUG = 0x10,
-};
-struct maghub_ipi_data {
-	int		direction;
-	int32_t dynamic_cali[MAGHUB_AXES_NUM];
-	int32_t parameter_cali[6];
-	atomic_t	trace;
-	atomic_t	suspend;
-	atomic_t	scp_init_done;
-	atomic_t first_ready_after_boot;
-	atomic_t selftest_status;
-	struct work_struct init_done_work;
-	struct data_unit_t m_data_t;
-	bool factory_enable;
-	bool android_enable;
-	struct sensorInfo_t mag_info;
-	struct completion selftest_done;
-};
-static int maghub_m_setPowerMode(bool enable)
-{
-	int res = 0;
-
-	pr_debug("magnetic enable value = %d\n", enable);
-	res = sensor_enable_to_hub(ID_MAGNETIC, enable);
-	if (res < 0)
-		pr_err("%s is failed!!\n", __func__);
-
-	return res;
-}
-
-static int maghub_GetMData(char *buf, int size)
-{
-	struct maghub_ipi_data *obj = mag_ipi_data;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-	int mag_m[MAGHUB_AXES_NUM];
-	int err = 0;
-	unsigned int status = 0;
-
-	if (atomic_read(&obj->suspend))
-		return -3;
-
-	if (buf == NULL)
-		return -1;
-	err = sensor_get_data_from_hub(ID_MAGNETIC, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!\n");
-		return err;
-	}
-
-	time_stamp				= data.time_stamp;
-	mag_m[MAGHUB_AXIS_X]	= data.magnetic_t.x;
-	mag_m[MAGHUB_AXIS_Y]	= data.magnetic_t.y;
-	mag_m[MAGHUB_AXIS_Z]	= data.magnetic_t.z;
-	status					= data.magnetic_t.status;
-
-	sprintf(buf, "%04x %04x %04x %04x", mag_m[MAGHUB_AXIS_X],
-		mag_m[MAGHUB_AXIS_Y], mag_m[MAGHUB_AXIS_Z], status);
-
-	if (atomic_read(&obj->trace) & MAG_MDATA_DEBUG)
-		pr_debug("RAW DATA: %s!\n", buf);
-
-
-	return 0;
-}
-
-static int maghub_ReadChipInfo(char *buf, int bufsize)
-{
-	if ((!buf) || (bufsize <= MAGHUB_BUFSIZE - 1))
-		return -1;
-
-	sprintf(buf, "maghub Chip");
-	return 0;
-}
-
-static ssize_t chipinfo_show(struct device_driver *ddri, char *buf)
-{
-	char strbuf[MAGHUB_BUFSIZE] = {0};
-
-	maghub_ReadChipInfo(strbuf, MAGHUB_BUFSIZE);
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-static ssize_t sensordata_show(struct device_driver *ddri,
-	char *buf)
-{
-	char strbuf[MAGHUB_BUFSIZE] = {0};
-
-	maghub_m_setPowerMode(true);
-	msleep(20);
-	maghub_GetMData(strbuf, MAGHUB_BUFSIZE);
-	return snprintf(buf, PAGE_SIZE, "%s\n", strbuf);
-}
-static ssize_t trace_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t res = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	if (obj == NULL) {
-		pr_err("maghub_ipi_data is null!!\n");
-		return 0;
-	}
-
-	res = snprintf(buf, PAGE_SIZE, "0x%04X\n", atomic_read(&obj->trace));
-	return res;
-}
-static ssize_t trace_store(struct device_driver *ddri,
-	const char *buf, size_t count)
-{
-	struct maghub_ipi_data *obj = mag_ipi_data;
-	int trace = 0;
-	int res = 0;
-
-	if (obj == NULL) {
-		pr_err("maghub_ipi_data is null!!\n");
-		return 0;
-	}
-
-	if (sscanf(buf, "0x%x", &trace) != 1) {
-		pr_err("invalid content: '%s',length = %zu\n", buf, count);
-		return count;
-	}
-	atomic_set(&obj->trace, trace);
-	res = sensor_set_cmd_to_hub(ID_MAGNETIC, CUST_ACTION_SET_TRACE, &trace);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_MAGNETIC, CUST_ACTION_SET_TRACE);
-		return 0;
-	}
-
-	return count;
-}
-
-static ssize_t orientation_show(struct device_driver *ddri, char *buf)
-{
-	ssize_t _tLength = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	pr_debug("[%s] default direction: %d\n", __func__, obj->direction);
-
-	_tLength = snprintf(buf, PAGE_SIZE, "default direction = %d\n",
-		obj->direction);
-
-	return _tLength;
-}
-
-static ssize_t orientation_store(struct device_driver *ddri,
-	const char *buf, size_t tCount)
-{
-	int _nDirection = 0, err = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-	int res = 0;
-
-	if (obj == NULL)
-		return 0;
-	err = kstrtoint(buf, 10, &_nDirection);
-
-	if (err != 0) {
-		pr_debug("[%s] set direction: %d\n", __func__, _nDirection);
-		return tCount;
-	}
-
-	obj->direction = _nDirection;
-	res = sensor_set_cmd_to_hub(ID_MAGNETIC,
-		CUST_ACTION_SET_DIRECTION, &_nDirection);
-	if (res < 0) {
-		pr_err("sensor_set_cmd_to_hub fail,(ID:%d),(action:%d)\n",
-			ID_MAGNETIC, CUST_ACTION_SET_DIRECTION);
-		return 0;
-	}
-
-	pr_debug("[%s] set direction: %d\n", __func__, _nDirection);
-
-	return tCount;
-}
-
-static ssize_t regmap_show(struct device_driver *ddri, char *buf)
-{
-
-	ssize_t _tLength = 0;
-
-	return _tLength;
-}
-static DRIVER_ATTR_RO(chipinfo);
-static DRIVER_ATTR_RO(sensordata);
-static DRIVER_ATTR_RW(trace);
-static DRIVER_ATTR_RW(orientation);
-static DRIVER_ATTR_RO(regmap);
-static struct driver_attribute *maghub_attr_list[] = {
-	&driver_attr_chipinfo,
-	&driver_attr_sensordata,
-	&driver_attr_trace,
-	&driver_attr_orientation,
-	&driver_attr_regmap,
-};
-static int maghub_create_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(maghub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, maghub_attr_list[idx]);
-		if (err) {
-			pr_err("driver_create_file (%s) = %d\n",
-				maghub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-static int maghub_delete_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(maghub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, maghub_attr_list[idx]);
-
-	return err;
-}
-
-static void scp_init_work_done(struct work_struct *work)
-{
-	int32_t cfg_data[9] = {0};
-	struct maghub_ipi_data *obj = mag_ipi_data;
-	int err = 0;
-	struct mag_libinfo_t mag_libinfo;
-
-	if (atomic_read(&obj->scp_init_done) == 0) {
-		pr_err("scp is not ready to send cmd\n");
-		return;
-	}
-	if (atomic_xchg(&obj->first_ready_after_boot, 1) == 0) {
-		err = sensor_set_cmd_to_hub(ID_MAGNETIC,
-			CUST_ACTION_GET_SENSOR_INFO, &obj->mag_info);
-		if (err < 0) {
-			pr_err("set_cmd_to_hub fail, (ID: %d),(action: %d)\n",
-				ID_MAGNETIC, CUST_ACTION_GET_SENSOR_INFO);
-			return;
-		}
-		strlcpy(mag_libinfo.libname,
-			obj->mag_info.mag_dev_info.libname,
-			sizeof(mag_libinfo.libname));
-		mag_libinfo.layout = obj->mag_info.mag_dev_info.layout;
-		mag_libinfo.deviceid = obj->mag_info.mag_dev_info.deviceid;
-
-		err = mag_info_record(&mag_libinfo);
-		return;
-	}
-
-	spin_lock(&calibration_lock);
-	cfg_data[0] = obj->dynamic_cali[0];
-	cfg_data[1] = obj->dynamic_cali[1];
-	cfg_data[2] = obj->dynamic_cali[2];
-
-	cfg_data[3] = obj->parameter_cali[0];
-	cfg_data[4] = obj->parameter_cali[1];
-	cfg_data[5] = obj->parameter_cali[2];
-	cfg_data[6] = obj->parameter_cali[3];
-	cfg_data[7] = obj->parameter_cali[4];
-	cfg_data[8] = obj->parameter_cali[5];
-	spin_unlock(&calibration_lock);
-	err = sensor_cfg_to_hub(ID_MAGNETIC,
-		(uint8_t *)cfg_data, sizeof(cfg_data));
-			if (err < 0)
-				pr_err("sensor_cfg_to_hub fail\n");
-}
-static int mag_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct mag_data data;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	data.x = event->magnetic_t.x;
-	data.y = event->magnetic_t.y;
-	data.z = event->magnetic_t.z;
-	data.status = event->magnetic_t.status;
-	data.timestamp = (int64_t)event->time_stamp;
-	data.reserved[0] = event->reserve[0];
-
-	if (event->flush_action == DATA_ACTION &&
-		READ_ONCE(obj->android_enable) == true)
-		err = mag_data_report(&data);
-	else if (event->flush_action == FLUSH_ACTION)
-		err = mag_flush_report();
-	else if (event->flush_action == BIAS_ACTION) {
-		data.x = event->magnetic_t.x_bias;
-		data.y = event->magnetic_t.y_bias;
-		data.z = event->magnetic_t.z_bias;
-		err = mag_bias_report(&data);
-		spin_lock(&calibration_lock);
-		obj->dynamic_cali[MAGHUB_AXIS_X] = event->magnetic_t.x_bias;
-		obj->dynamic_cali[MAGHUB_AXIS_Y] = event->magnetic_t.y_bias;
-		obj->dynamic_cali[MAGHUB_AXIS_Z] = event->magnetic_t.z_bias;
-		spin_unlock(&calibration_lock);
-	} else if (event->flush_action == TEST_ACTION) {
-		atomic_set(&obj->selftest_status, event->magnetic_t.status);
-		complete(&obj->selftest_done);
-	} else if (event->flush_action == CALI_ACTION) {
-		err = mag_cali_report(event->data);
-		spin_lock(&calibration_lock);
-		obj->parameter_cali[0] = event->data[0];
-		obj->parameter_cali[1] = event->data[1];
-		obj->parameter_cali[2] = event->data[2];
-		obj->parameter_cali[3] = event->data[3];
-		obj->parameter_cali[4] = event->data[4];
-		obj->parameter_cali[5] = event->data[5];
-		spin_unlock(&calibration_lock);
-	}
-	return err;
-}
-static int maghub_enable(int en)
-{
-	int res = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	if (en == true)
-		WRITE_ONCE(obj->android_enable, true);
-	else
-		WRITE_ONCE(obj->android_enable, false);
-
-	res = maghub_m_setPowerMode(en);
-	if (res)
-		pr_err("maghub_m_setPowerMode is failed!!\n");
-	return res;
-}
-
-static int maghub_set_delay(u64 ns)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	int delayms = 0, err = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	delayms = (int)ns / 1000 / 1000;
-	err = sensor_set_delay_to_hub(ID_MAGNETIC, delayms);
-	if (err < 0) {
-		pr_err("maghub_m_set_delay fail!\n");
-		return err;
-	}
-
-	pr_debug("maghub_m_set_delay (%d)\n", delayms);
-	return err;
-#elif defined CONFIG_NANOHUB
-	return 0;
-#else
-	return 0;
-#endif
-}
-static int maghub_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	maghub_set_delay(samplingPeriodNs);
-#endif
-	return sensor_batch_to_hub(ID_MAGNETIC,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int maghub_flush(void)
-{
-	return sensor_flush_to_hub(ID_MAGNETIC);
-}
-
-static int maghub_set_cali(uint8_t *data, uint8_t count)
-{
-	int32_t *buf = (int32_t *)data;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	spin_lock(&calibration_lock);
-	obj->dynamic_cali[0] = buf[0];
-	obj->dynamic_cali[1] = buf[1];
-	obj->dynamic_cali[2] = buf[2];
-
-	obj->parameter_cali[0] = buf[3];
-	obj->parameter_cali[1] = buf[4];
-	obj->parameter_cali[2] = buf[5];
-	obj->parameter_cali[3] = buf[6];
-	obj->parameter_cali[4] = buf[7];
-	obj->parameter_cali[5] = buf[8];
-	spin_unlock(&calibration_lock);
-	return sensor_cfg_to_hub(ID_MAGNETIC, data, count);
-}
-
-static int maghub_open_report_data(int open)
-{
-	return 0;
-}
-
-static int maghub_get_data(int *x, int *y, int *z, int *status)
-{
-	char buff[MAGHUB_BUFSIZE] = { 0 };
-	int ret;
-
-	ret = maghub_GetMData(buff, MAGHUB_BUFSIZE);
-	if (ret < 0) {
-		pr_err("maghub_GetMData fail, ret:%d\n", ret);
-		return ret;
-	}
-
-	if (sscanf(buff, "%x %x %x %x", x, y, z, status) != 4)
-		pr_err("maghub_m_get_data sscanf fail!!\n");
-	return 0;
-}
-static int scp_ready_event(uint8_t event, void *ptr)
-{
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	switch (event) {
-	case SENSOR_POWER_UP:
-	    atomic_set(&obj->scp_init_done, 1);
-		schedule_work(&obj->init_done_work);
-		break;
-	case SENSOR_POWER_DOWN:
-	    atomic_set(&obj->scp_init_done, 0);
-		break;
-	}
-	return 0;
-}
-static struct scp_power_monitor scp_ready_notifier = {
-	.name = "mag",
-	.notifier_call = scp_ready_event,
-};
-static int maghub_factory_enable_sensor(bool enabledisable,
-	int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	if (enabledisable == true)
-		WRITE_ONCE(obj->factory_enable, true);
-	else
-		WRITE_ONCE(obj->factory_enable, false);
-
-	if (enabledisable == 1) {
-		err = sensor_set_delay_to_hub(ID_MAGNETIC, sample_periods_ms);
-		if (err < 0) {
-			pr_err("sensor_set_delay_to_hub fail!\r\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_MAGNETIC, enabledisable == true ? 1 : 0);
-	if (err < 0) {
-		pr_err("sensor_enable_to_hub fail!\r\n");
-		return -1;
-	}
-	return 0;
-}
-static int maghub_factory_get_data(int32_t data[3], int *status)
-{
-	int err = 0;
-
-	/* get raw data */
-	err = maghub_get_data(&data[0], &data[1], &data[2], status);
-	data[0] = data[0] / CONVERT_M_DIV;
-	data[1] = data[1] / CONVERT_M_DIV;
-	data[2] = data[2] / CONVERT_M_DIV;
-
-	return err;
-}
-static int maghub_factory_get_raw_data(int32_t data[3])
-{
-	pr_debug("%s do not support!\n", __func__);
-	return 0;
-}
-static int maghub_factory_enable_calibration(void)
-{
-	return 0;
-}
-static int maghub_factory_clear_cali(void)
-{
-	return 0;
-}
-static int maghub_factory_set_cali(int32_t data[3])
-{
-	return 0;
-}
-static int maghub_factory_get_cali(int32_t data[3])
-{
-	return 0;
-}
-static int maghub_factory_do_self_test(void)
-{
-	int ret = 0;
-	struct maghub_ipi_data *obj = mag_ipi_data;
-
-	ret = sensor_selftest_to_hub(ID_MAGNETIC);
-	if (ret < 0)
-		return -1;
-
-	ret = wait_for_completion_timeout(&obj->selftest_done,
-					  msecs_to_jiffies(3000));
-	if (!ret)
-		return -1;
-	return atomic_read(&obj->selftest_status);
-}
-
-static struct mag_factory_fops maghub_factory_fops = {
-	.enable_sensor = maghub_factory_enable_sensor,
-	.get_data = maghub_factory_get_data,
-	.get_raw_data = maghub_factory_get_raw_data,
-	.enable_calibration = maghub_factory_enable_calibration,
-	.clear_cali = maghub_factory_clear_cali,
-	.set_cali = maghub_factory_set_cali,
-	.get_cali = maghub_factory_get_cali,
-	.do_self_test = maghub_factory_do_self_test,
-};
-
-static struct mag_factory_public maghub_factory_device = {
-	.gain = 1,
-	.sensitivity = 1,
-	.fops = &maghub_factory_fops,
-};
-static int maghub_probe(struct platform_device *pdev)
-{
-	int err = 0;
-	struct maghub_ipi_data *data;
-	struct mag_control_path ctl = { 0 };
-	struct mag_data_path mag_data = { 0 };
-
-	struct platform_driver *paddr =
-					maghub_init_info.platform_diver_addr;
-
-	pr_debug("%s\n", __func__);
-	data = kzalloc(sizeof(struct maghub_ipi_data), GFP_KERNEL);
-	if (!data) {
-		err = -ENOMEM;
-		goto exit;
-	}
-	mag_ipi_data = data;
-	atomic_set(&data->trace, 0);
-	atomic_set(&data->selftest_status, 0);
-	WRITE_ONCE(data->factory_enable, false);
-	WRITE_ONCE(data->android_enable, false);
-	init_completion(&data->selftest_done);
-
-	platform_set_drvdata(pdev, data);
-
-	err = scp_sensorHub_data_registration(ID_MAGNETIC, mag_recv_data);
-	if (err < 0) {
-		pr_err("scp_sensorHub_data_registration failed\n");
-		goto exit_kfree;
-	}
-	err = mag_factory_device_register(&maghub_factory_device);
-	if (err) {
-		pr_err("mag_factory_device_register register failed\n");
-		goto exit_kfree;
-	}
-	/* Register sysfs attribute */
-	err = maghub_create_attr(&paddr->driver);
-	if (err) {
-		pr_err("create attribute err = %d\n", err);
-		goto exit_misc_device_register_failed;
-	}
-	ctl.is_use_common_factory = false;
-	ctl.enable = maghub_enable;
-	ctl.set_delay = maghub_set_delay;
-	ctl.batch = maghub_batch;
-	ctl.flush = maghub_flush;
-	ctl.set_cali = maghub_set_cali;
-	ctl.open_report_data = maghub_open_report_data;
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = false;
-#elif defined CONFIG_NANOHUB
-	ctl.is_report_input_direct = true;
-	ctl.is_support_batch = true;
-#else
-#endif
-
-	err = mag_register_control_path(&ctl);
-	if (err) {
-		pr_err("register mag control path err\n");
-		goto create_attr_failed;
-	}
-
-	mag_data.div = CONVERT_M_DIV;
-	mag_data.get_data = maghub_get_data;
-
-	err = mag_register_data_path(&mag_data);
-	if (err) {
-		pr_err("register data control path err\n");
-		goto create_attr_failed;
-	}
-	pr_debug("%s: OK\n", __func__);
-	maghub_init_flag = 1;
-	/*Mointor scp ready notify,
-	 *need monitor at the end of probe for two function:
-	 * 1.read mag_info from sensorhub,
-	 * write to mag context
-	 * 2.set cali to sensorhub
-	 */
-	INIT_WORK(&data->init_done_work, scp_init_work_done);
-	scp_power_monitor_register(&scp_ready_notifier);
-
-	return 0;
-
-create_attr_failed:
-	maghub_delete_attr(&(maghub_init_info.platform_diver_addr->driver));
-exit_misc_device_register_failed:
-	mag_factory_device_deregister(&maghub_factory_device);
-exit_kfree:
-	kfree(data);
-exit:
-	pr_err("%s: err = %d\n", __func__, err);
-	maghub_init_flag = -1;
-	return err;
-}
-
-/*----------------------------------------------------------------------------*/
-static int maghub_remove(struct platform_device *pdev)
-{
-	int err = 0;
-	struct platform_driver *paddr =
-					maghub_init_info.platform_diver_addr;
-
-	err = maghub_delete_attr(&paddr->driver);
-	if (err)
-		pr_err("maghub_delete_attr fail: %d\n", err);
-
-	kfree(platform_get_drvdata(pdev));
-	mag_factory_device_deregister(&maghub_factory_device);
-	return 0;
-}
-
-static int maghub_suspend(struct platform_device *pdev, pm_message_t msg)
-{
-	return 0;
-}
-
-static int maghub_resume(struct platform_device *pdev)
-{
-	return 0;
-}
-static struct platform_device maghub_device = {
-	.name = MAGHUB_DEV_NAME,
-	.id = -1,
-};
-
-static struct platform_driver maghub_driver = {
-	.driver = {
-		   .name = MAGHUB_DEV_NAME,
-	},
-	.probe = maghub_probe,
-	.remove = maghub_remove,
-	.suspend = maghub_suspend,
-	.resume = maghub_resume,
-};
-
-static int maghub_local_remove(void)
-{
-	platform_driver_unregister(&maghub_driver);
-	return 0;
-}
-
-static int maghub_local_init(void)
-{
-	if (platform_driver_register(&maghub_driver)) {
-		pr_err("add_driver error\n");
-		return -1;
-	}
-	if (-1 == maghub_init_flag)
-		return -1;
-	return 0;
-}
-static struct mag_init_info maghub_init_info = {
-	.name = "maghub",
-	.init = maghub_local_init,
-	.uninit = maghub_local_remove,
-};
-
-static int __init maghub_init(void)
-{
-	if (platform_device_register(&maghub_device)) {
-		pr_err("platform device error\n");
-		return -1;
-	}
-	mag_driver_add(&maghub_init_info);
-	return 0;
-}
-
-static void __exit maghub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(maghub_init);
-module_exit(maghub_exit);
-
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
-MODULE_DESCRIPTION("MAGHUB compass driver");
-MODULE_LICENSE("GPL");
-MODULE_VERSION(DRIVER_VERSION);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/maghub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/maghub.h
deleted file mode 100644
index 87c5eb0..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/magnetometer/maghub/maghub.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-/*
- * Definitions for akm09912 compass chip.
- */
-#ifndef MAGHUB_H
-#define MAGHUB_H
-
-#include <linux/ioctl.h>
-#define MAGHUB_AXIS_X          0
-#define MAGHUB_AXIS_Y          1
-#define MAGHUB_AXIS_Z          2
-#define MAGHUB_STATUS          2
-#define MAGHUB_AXES_NUM        3
-#define MAGHUB_DATA_LEN        6
-
-#define MAGHUB_SUCCESS             0
-
-#define MAGHUB_BUFSIZE 60
-
-#define CONVERT_M_DIV		100
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/Kconfig
deleted file mode 100644
index 03b6094..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/Kconfig
+++ /dev/null
@@ -1,14 +0,0 @@
-
-config CUSTOM_KERNEL_SENSORHUB
-	bool "CUSTOM KERNEL SENSORHUB support"
-	help
-	  Kernel space sensor hub driver.
-	  Define project used all sensor hub
-	  sensors. The value is combination of sensor hub driver(get data...etc)
-	  and sensor hub framework driver(transmit shf info)
-
-#source "drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_sensorHub/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_sensorHub_v1/Kconfig"
-#source "drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_shf/Kconfig"
-
-source "drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/Kconfig"
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/Makefile
deleted file mode 100644
index b77ad0c..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/Makefile
+++ /dev/null
@@ -1,35 +0,0 @@
-#
-# Copyright (C) 2015 MediaTek Inc.
-#
-# 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.
-#
-# 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.
-#
-
-# In case the platform does NOT support this type of sensors
-#obj-$(CONFIG_MTK_SCP_SENSORHUB) += SCP_sensorHub/
-#obj-$(CONFIG_MTK_SENSOR_HUB_SUPPORT) += SCP_shf/
-#obj-$(CONFIG_MTK_SCP_SENSORHUB_V1) += SCP_sensorHub_v1/
-
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-#ccflags-y += -I$(srctree)/arch/arm/mach-mt2601/pike/dct/dct
-
-ifeq ($(CONFIG_NANOHUB), y)
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) += sensorHub.o
-
-sensorHub-$(CONFIG_NANOHUB_MTK_IPI) := nanohub/main.o \
-            nanohub/bl.o nanohub/comms.o
-sensorHub-$(CONFIG_NANOHUB_MTK_IPI) += nanohub/nanohub-mtk.o
-
-sensorHub-$(CONFIG_NANOHUB_MTK_IPI) += SCP_nanoHub/SCP_nanoHub.o \
-        SCP_power_monitor/SCP_power_monitor.o
-endif
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_nanoHub/SCP_nanoHub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_nanoHub/SCP_nanoHub.c
deleted file mode 100644
index ed0292e..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_nanoHub/SCP_nanoHub.c
+++ /dev/null
@@ -1,2534 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[sensorHub] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kthread.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/dma-mapping.h>
-#include <linux/atomic.h>
-#include <linux/types.h>
-#include <linux/module.h>
-#include <asm/arch_timer.h>
-#include <linux/pm_wakeup.h>
-#include <linux/suspend.h>
-#include <linux/time.h>
-#include "include/scp.h"
-#include "cust_sensorHub.h"
-#include "hwmsensor.h"
-#include "sensors_io.h"
-#include "SCP_sensorHub.h"
-#include "hwmsen_helper.h"
-#include "comms.h"
-#include "sensor_event.h"
-#include "sensor_performance.h"
-#include "SCP_power_monitor.h"
-#include <asm/arch_timer.h>
-#include <linux/math64.h>
-#include <linux/timekeeping.h>
-#include <uapi/linux/sched/types.h>
-
-/* ALGIN TO SCP SENSOR_IPI_SIZE AT FILE CONTEXTHUB_FW.H, ALGIN
- * TO SCP_SENSOR_HUB_DATA UNION, ALGIN TO STRUCT DATA_UNIT_T
- * SIZEOF(STRUCT DATA_UNIT_T) = SCP_SENSOR_HUB_DATA = SENSOR_IPI_SIZE
- * BUT AT THE MOMENT AP GET DATA THROUGH IPI, WE ONLY TRANSFER
- * 44 BYTES DATA_UNIT_T, THERE ARE 4 BYTES HEADER IN SCP_SENSOR_HUB_DATA
- * HEAD
- */
-#define SENSOR_IPI_SIZE 48
-/*
- * experience number for delay_count per DELAY_COUNT sensor input delay 10ms
- * msleep(10) system will schedule to hal process then read input node
- */
-#define SENSOR_IPI_HEADER_SIZE 4
-#define SENSOR_IPI_PACKET_SIZE (SENSOR_IPI_SIZE - SENSOR_IPI_HEADER_SIZE)
-#define SENSOR_DATA_SIZE 44
-
-#if SENSOR_DATA_SIZE > SENSOR_IPI_PACKET_SIZE
-#error "SENSOR_DATA_SIZE > SENSOR_IPI_PACKET_SIZE, out of memory"
-#endif
-
-#define SYNC_TIME_CYCLC 10000
-#define SYNC_TIME_START_CYCLC 3000
-#define SCP_sensorHub_DEV_NAME "SCP_sensorHub"
-
-#define CHRE_POWER_RESET_NOTIFY
-
-static int sensor_send_timestamp_to_hub(void);
-static int SCP_sensorHub_server_dispatch_data(uint32_t *currWp);
-static int SCP_sensorHub_init_flag = -1;
-static uint8_t rtc_compensation_suspend;
-struct curr_wp_queue {
-	spinlock_t buffer_lock;
-	uint32_t head;
-	uint32_t tail;
-	uint32_t bufsize;
-	uint32_t *ringbuffer;
-};
-
-struct SCP_sensorHub_data {
-	/* struct work_struct power_up_work; */
-
-	struct sensorHub_hw *hw;
-	struct work_struct direct_push_work;
-	struct workqueue_struct	*direct_push_workqueue;
-	struct timer_list sync_time_timer;
-	struct work_struct sync_time_worker;
-	struct wakeup_source *ws;
-
-	struct sensorFIFO *SCP_sensorFIFO;
-	struct curr_wp_queue wp_queue;
-	phys_addr_t shub_dram_phys;
-	phys_addr_t shub_dram_virt;
-	SCP_sensorHub_handler dispatch_data_cb[ID_SENSOR_MAX_HANDLE_PLUS_ONE];
-	atomic_t traces[ID_SENSOR_MAX_HANDLE_PLUS_ONE];
-};
-static struct SensorState mSensorState[SENSOR_TYPE_MAX_NUM_PLUS_ONE];
-static DEFINE_MUTEX(mSensorState_mtx);
-static DEFINE_MUTEX(flush_mtx);
-static atomic_t power_status = ATOMIC_INIT(SENSOR_POWER_DOWN);
-static DECLARE_WAIT_QUEUE_HEAD(chre_kthread_wait);
-static DECLARE_WAIT_QUEUE_HEAD(power_reset_wait);
-static uint8_t chre_kthread_wait_condition;
-static DEFINE_SPINLOCK(scp_state_lock);
-static uint8_t scp_system_ready;
-static uint8_t scp_chre_ready;
-static struct SCP_sensorHub_data *obj_data;
-
-/* arch counter is 13M, mult is 161319385, shift is 21 */
-static inline uint64_t arch_counter_to_ns(uint64_t cyc)
-{
-#define ARCH_TIMER_MULT 161319385
-#define ARCH_TIMER_SHIFT 21
-	return (cyc * ARCH_TIMER_MULT) >> ARCH_TIMER_SHIFT;
-}
-
-#define FILTER_DATAPOINTS	16
-#define FILTER_TIMEOUT		10000000000ULL /* 10 seconds, ~100us drift */
-#define FILTER_FREQ			10000000ULL /* 10 ms */
-struct moving_average {
-	uint64_t last_time;
-	int64_t input[FILTER_DATAPOINTS];
-	atomic64_t output;
-	uint8_t cnt;
-	uint8_t tail;
-};
-static struct moving_average moving_average_algo;
-static uint8_t rtc_compensation_suspend;
-static void moving_average_filter(struct moving_average *filter,
-		uint64_t ap_time, uint64_t hub_time)
-{
-	int i = 0;
-	int64_t avg = 0;
-	int64_t ret_avg = 0;
-
-	if (ap_time > filter->last_time + FILTER_TIMEOUT ||
-		filter->last_time == 0) {
-		filter->tail = 0;
-		filter->cnt = 0;
-	} else if (ap_time < filter->last_time + FILTER_FREQ) {
-		return;
-	}
-	filter->last_time = ap_time;
-
-	filter->input[filter->tail++] = ap_time - hub_time;
-	filter->tail &= (FILTER_DATAPOINTS - 1);
-	if (filter->cnt < FILTER_DATAPOINTS)
-		filter->cnt++;
-
-	/* pr_err("hongxu raw_offset=%lld\n", ap_time - hub_time); */
-
-	for (i = 1, avg = 0; i < filter->cnt; i++)
-		avg += (filter->input[i] - filter->input[0]);
-	ret_avg = div_s64(avg, filter->cnt) + filter->input[0];
-	atomic64_set(&filter->output, ret_avg);
-}
-
-static uint64_t get_filter_output(struct moving_average *filter)
-{
-	return atomic64_read(&filter->output);
-}
-
-struct SCP_sensorHub_Cmd {
-	uint32_t reason;
-	void (*handler)(union SCP_SENSOR_HUB_DATA *rsp, int rx_len);
-};
-
-#define SCP_SENSORHUB_CMD(_reason, _handler) \
-	{.reason = _reason, .handler = _handler}
-
-struct ipi_master {
-	spinlock_t		    lock;
-	struct list_head	queue;
-	struct workqueue_struct	*workqueue;
-	struct work_struct	work;
-};
-
-struct ipi_transfer {
-	const unsigned char	*tx_buf;
-	unsigned char		rx_buf[SENSOR_IPI_SIZE];
-	unsigned int		len;
-	struct list_head transfer_list;
-};
-
-struct ipi_message {
-	struct list_head	transfers;
-	struct list_head	queue;
-	void			*context;
-	int				status;
-	void			(*complete)(void *context);
-};
-
-struct scp_send_ipi {
-	struct completion	 done;
-	int			 len;
-	int			 count;
-	/* data buffers */
-	const unsigned char	*tx;
-	unsigned char		*rx;
-	void			*context;
-};
-
-static struct scp_send_ipi txrx_cmd;
-static DEFINE_SPINLOCK(txrx_cmd_lock);
-static struct ipi_master master;
-
-static inline void ipi_message_init(struct ipi_message *m)
-{
-	memset(m, 0, sizeof(*m));
-	INIT_LIST_HEAD(&m->transfers);
-}
-
-static inline void ipi_message_add_tail(struct ipi_transfer *t,
-	struct ipi_message *m)
-{
-	list_add_tail(&t->transfer_list, &m->transfers);
-}
-
-static int ipi_txrx_bufs(struct ipi_transfer *t)
-{
-	int status = 0, retry = 0;
-	int timeout;
-	unsigned long flags;
-	struct scp_send_ipi *hw = &txrx_cmd;
-
-	/* union SCP_SENSOR_HUB_DATA *req =
-	 *		(union SCP_SENSOR_HUB_DATA *)t->tx_buf;
-	 * pr_err("sensorType:%d, action:%d\n",
-	 *req->req.sensorType, req->req.action);
-	 */
-	spin_lock_irqsave(&txrx_cmd_lock, flags);
-	hw->tx = t->tx_buf;
-	hw->rx = t->rx_buf;
-	hw->len = t->len;
-
-	init_completion(&hw->done);
-	hw->context = &hw->done;
-	spin_unlock_irqrestore(&txrx_cmd_lock, flags);
-	do {
-		status = scp_ipi_send(IPI_SENSOR,
-			(unsigned char *)hw->tx, hw->len, 0, SCP_A_ID);
-		if (status == SCP_IPI_ERROR) {
-			pr_err("scp_ipi_send fail\n");
-			return -1;
-		}
-		if (status == SCP_IPI_BUSY) {
-			if (retry++ == 1000) {
-				pr_err("retry fail\n");
-				return -1;
-			}
-			if (retry % 100 == 0)
-				usleep_range(1000, 2000);
-		}
-	} while (status == SCP_IPI_BUSY);
-
-	if (retry >= 100)
-		pr_debug("retry time:%d\n", retry);
-
-	timeout = wait_for_completion_timeout(&hw->done, msecs_to_jiffies(500));
-	spin_lock_irqsave(&txrx_cmd_lock, flags);
-	if (!timeout) {
-		pr_err("transfer timeout!");
-		hw->count = -1;
-	}
-	hw->context = NULL;
-	spin_unlock_irqrestore(&txrx_cmd_lock, flags);
-	return hw->count;
-}
-
-static void ipi_complete(void *arg)
-{
-	complete(arg);
-}
-
-static void ipi_work(struct work_struct *work)
-{
-	struct ipi_message	*m, *_m;
-	struct ipi_transfer	*t = NULL;
-	int			status = 0;
-
-	spin_lock(&master.lock);
-	list_for_each_entry_safe(m, _m, &master.queue, queue) {
-		list_del(&m->queue);
-		spin_unlock(&master.lock);
-		list_for_each_entry(t, &m->transfers, transfer_list) {
-			if (!t->tx_buf && t->len) {
-				status = -EINVAL;
-				pr_err("transfer param wrong :%d\n",
-					status);
-				break;
-			}
-			if (t->len)
-				status = ipi_txrx_bufs(t);
-			if (status < 0) {
-				status = -EREMOTEIO;
-				/* pr_err("transfer err :%d\n", status); */
-				break;
-			} else if (status != t->len) {
-				status = -EREMOTEIO;
-				pr_err("ack err :%d\n", status);
-				break;
-			}
-			status = 0;
-		}
-		m->status = status;
-		m->complete(m->context);
-		spin_lock(&master.lock);
-	}
-	spin_unlock(&master.lock);
-}
-
-static int __ipi_transfer(struct ipi_message *m)
-{
-	m->status = -EINPROGRESS;
-
-	spin_lock(&master.lock);
-	list_add_tail(&m->queue, &master.queue);
-	queue_work(master.workqueue, &master.work);
-	spin_unlock(&master.lock);
-	return 0;
-}
-
-static int __ipi_xfer(struct ipi_message *message)
-{
-	DECLARE_COMPLETION_ONSTACK(done);
-	int status;
-
-	message->complete = ipi_complete;
-	message->context = &done;
-
-	status = __ipi_transfer(message);
-
-	if (status == 0) {
-		wait_for_completion(&done);
-		status = message->status;
-	}
-	message->context = NULL;
-	return status;
-}
-
-static int scp_ipi_txrx(const unsigned char *txbuf, unsigned int n_tx,
-	unsigned char *rxbuf, unsigned int n_rx)
-{
-	struct ipi_transfer t;
-	struct ipi_message	m;
-	int status = 0;
-
-	t.tx_buf = txbuf,
-	t.len = n_tx,
-
-	ipi_message_init(&m);
-	ipi_message_add_tail(&t, &m);
-	status =  __ipi_xfer(&m);
-	if (status == 0)
-		memcpy(rxbuf, t.rx_buf, n_rx);
-	return status;
-}
-
-static int SCP_sensorHub_ipi_txrx(unsigned char *txrxbuf)
-{
-	return scp_ipi_txrx(txrxbuf,
-		SENSOR_IPI_SIZE, txrxbuf, SENSOR_IPI_SIZE);
-}
-
-static int SCP_sensorHub_ipi_master_init(void)
-{
-	INIT_WORK(&master.work, ipi_work);
-	INIT_LIST_HEAD(&master.queue);
-	spin_lock_init(&master.lock);
-	master.workqueue = create_singlethread_workqueue("ipi_master");
-	if (master.workqueue == NULL) {
-		pr_err("workqueue fail\n");
-		return -1;
-	}
-
-	return 0;
-}
-
-int scp_sensorHub_req_send(union SCP_SENSOR_HUB_DATA *data,
-	uint *len, unsigned int wait)
-{
-	int ret = 0;
-
-	/* pr_err("sensorType = %d, action = %d\n", data->req.sensorType,
-	 *	data->req.action);
-	 */
-
-	if (*len > SENSOR_IPI_SIZE) {
-		pr_err("over sensor data size!!\n");
-		return -1;
-	}
-
-	if (in_interrupt()) {
-		pr_err("Can't do %s in interrupt context!!\n", __func__);
-		return -1;
-	}
-
-	if (data->rsp.sensorType > ID_SENSOR_MAX_HANDLE) {
-		pr_err("SCP_sensorHub_IPI_handler invalid sensor type %d\n",
-			data->rsp.sensorType);
-		return -1;
-	}
-	ret = SCP_sensorHub_ipi_txrx((unsigned char *)data);
-	if (ret != 0 || data->rsp.errCode != 0)
-		return -1;
-	return 0;
-}
-
-int scp_sensorHub_data_registration(uint8_t sensor,
-	SCP_sensorHub_handler handler)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-
-	if (sensor > ID_SENSOR_MAX_HANDLE) {
-		pr_err("SCP_sensorHub_rsp_registration invalid sensor %d\n",
-			sensor);
-		return -1;
-	}
-
-	if (handler == NULL)
-		pr_err("SCP_sensorHub_rsp_registration null handler\n");
-
-	obj->dispatch_data_cb[sensor] = handler;
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(scp_sensorHub_data_registration);
-
-static void SCP_sensorHub_write_wp_queue(union SCP_SENSOR_HUB_DATA *rsp)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	struct curr_wp_queue *wp_queue = &obj->wp_queue;
-
-	spin_lock(&wp_queue->buffer_lock);
-	wp_queue->ringbuffer[wp_queue->head++] = rsp->notify_rsp.currWp;
-	wp_queue->head &= wp_queue->bufsize - 1;
-	if (unlikely(wp_queue->head == wp_queue->tail))
-		pr_err("dropped currWp due to ringbuffer is full\n");
-	spin_unlock(&wp_queue->buffer_lock);
-}
-static int SCP_sensorHub_fetch_next_wp(uint32_t *currWp)
-{
-	int have_event;
-	struct SCP_sensorHub_data *obj = obj_data;
-	struct curr_wp_queue *wp_queue = &obj->wp_queue;
-
-	spin_lock_irq(&wp_queue->buffer_lock);
-
-	have_event = wp_queue->head != wp_queue->tail;
-	if (have_event) {
-		*currWp = wp_queue->ringbuffer[wp_queue->tail++];
-		wp_queue->tail &= wp_queue->bufsize - 1;
-	}
-	spin_unlock_irq(&wp_queue->buffer_lock);
-	/* pr_err("head:%d, tail:%d, currWp:%d\n",
-	 * wp_queue->head, wp_queue->tail, *currWp);
-	 */
-	return have_event;
-}
-static int SCP_sensorHub_read_wp_queue(void)
-{
-	uint32_t currWp = 0;
-
-	while (SCP_sensorHub_fetch_next_wp(&currWp)) {
-		if (SCP_sensorHub_server_dispatch_data(&currWp))
-			return -EFAULT;
-	}
-	return 0;
-}
-static void SCP_sensorHub_sync_time_work(struct work_struct *work)
-
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-
-	sensor_send_timestamp_to_hub();
-	mod_timer(&obj->sync_time_timer,
-		jiffies +  msecs_to_jiffies(SYNC_TIME_CYCLC));
-}
-
-static void SCP_sensorHub_sync_time_func(struct timer_list *t)
-{
-	struct SCP_sensorHub_data *obj = from_timer(obj, t, sync_time_timer);
-
-	schedule_work(&obj->sync_time_worker);
-}
-
-static int SCP_sensorHub_direct_push_work(void *data)
-{
-	for (;;) {
-		wait_event(chre_kthread_wait,
-			READ_ONCE(chre_kthread_wait_condition));
-		WRITE_ONCE(chre_kthread_wait_condition, false);
-		mark_timestamp(0, WORK_START, ktime_get_boot_ns(), 0);
-		SCP_sensorHub_read_wp_queue();
-	}
-	return 0;
-}
-
-static void SCP_sensorHub_xcmd_putdata(union SCP_SENSOR_HUB_DATA *rsp,
-			int rx_len)
-{
-	union SCP_SENSOR_HUB_DATA *req;
-	struct scp_send_ipi *hw = &txrx_cmd;
-
-	spin_lock(&txrx_cmd_lock);
-	if (!hw->context) {
-		pr_err("after ipi timeout ack occur then dropped this\n");
-		goto out;
-	}
-
-	req = (union SCP_SENSOR_HUB_DATA *)hw->tx;
-
-	if (req->req.sensorType != rsp->rsp.sensorType ||
-		req->req.action != rsp->rsp.action) {
-		pr_debug("req type %d != rsp %d req action %d != rsq %d\n",
-			req->req.sensorType, rsp->rsp.sensorType,
-			req->req.action, rsp->rsp.action);
-	} else {
-		memcpy(hw->rx, rsp, rx_len);
-		hw->count = rx_len;
-		complete(hw->context);
-	}
-out:
-	spin_unlock(&txrx_cmd_lock);
-}
-
-static void SCP_sensorHub_enable_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-					int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void SCP_sensorHub_set_delay_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-						int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void SCP_sensorHub_get_data_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-						int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void SCP_sensorHub_batch_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-					int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void SCP_sensorHub_set_cfg_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-					int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void SCP_sensorHub_set_cust_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-						int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void
-SCP_sensorHub_batch_timeout_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-					int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-static void
-SCP_sensorHub_set_timestamp_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-					int rx_len)
-{
-	SCP_sensorHub_xcmd_putdata(rsp, rx_len);
-}
-
-static void SCP_sensorHub_moving_average(union SCP_SENSOR_HUB_DATA *rsp)
-{
-	uint64_t ap_now_time = 0, arch_counter = 0;
-	uint64_t scp_raw_time = 0, scp_now_time = 0;
-	uint64_t ipi_transfer_time = 0;
-
-	/* if (!timekeeping_rtc_skipresume()) {
-	 *	if (READ_ONCE(rtc_compensation_suspend))
-	 *	return;
-	 * }
-	 */
-	ap_now_time = ktime_get_boot_ns();
-	arch_counter = arch_counter_get_cntvct();
-	scp_raw_time = rsp->notify_rsp.scp_timestamp;
-	ipi_transfer_time = arch_counter_to_ns(arch_counter -
-		rsp->notify_rsp.arch_counter);
-	scp_now_time = scp_raw_time + ipi_transfer_time;
-	moving_average_filter(&moving_average_algo, ap_now_time, scp_now_time);
-}
-static void SCP_sensorHub_notify_cmd(union SCP_SENSOR_HUB_DATA *rsp,
-	int rx_len)
-{
-	/* struct SCP_sensorHub_data *obj = obj_data; */
-	/*
-	 *struct data_unit_t *event;
-	 *int handle = 0;
-	 */
-
-	unsigned long flags = 0;
-
-	switch (rsp->notify_rsp.event) {
-	case SCP_DIRECT_PUSH:
-	case SCP_FIFO_FULL:
-		mark_timestamp(0, GOT_IPI, ktime_get_boot_ns(), 0);
-		mark_ipi_timestamp(arch_counter_get_cntvct() -
-			rsp->notify_rsp.arch_counter);
-#ifdef DEBUG_PERFORMANCE_HW_TICK
-		pr_notice("[Performance] AP_get_ipi Stanley kernel tick:%llu\n",
-			arch_counter_get_cntvct());
-
-#endif
-		SCP_sensorHub_moving_average(rsp);
-		SCP_sensorHub_write_wp_queue(rsp);
-		/* queue_work(obj->direct_push_workqueue,
-		 * &obj->direct_push_work);
-		 */
-		WRITE_ONCE(chre_kthread_wait_condition, true);
-		wake_up(&chre_kthread_wait);
-		break;
-	case SCP_NOTIFY:
-/*
- *		handle = rsp->rsp.sensorType;
- *		if (handle > ID_SENSOR_MAX_HANDLE) {
- *			pr_err("invalid sensor %d\n", handle);
- *		} else {
- *			event = (struct data_unit_t *)rsp->notify_rsp.int8_Data;
- *			if (obj->dispatch_data_cb[handle] != NULL)
- *				obj->dispatch_data_cb[handle](event, NULL);
- *			else
- *				pr_err("type:%d don't support this flow?\n",
- *					handle);
- *			if (event->flush_action == FLUSH_ACTION)
- *				atomic_dec(&mSensorState[handle].flushCnt);
- *		}
- */
-		break;
-	case SCP_INIT_DONE:
-		spin_lock_irqsave(&scp_state_lock, flags);
-		WRITE_ONCE(scp_chre_ready, true);
-		if (READ_ONCE(scp_system_ready) && READ_ONCE(scp_chre_ready)) {
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-			atomic_set(&power_status, SENSOR_POWER_UP);
-			scp_power_monitor_notify(SENSOR_POWER_UP, NULL);
-			/* schedule_work(&obj->power_up_work); */
-			wake_up(&power_reset_wait);
-		} else
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-		break;
-	default:
-		break;
-	}
-}
-
-static const struct SCP_sensorHub_Cmd SCP_sensorHub_Cmds[] = {
-	SCP_SENSORHUB_CMD(SENSOR_HUB_ACTIVATE,
-		SCP_sensorHub_enable_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_SET_DELAY,
-		SCP_sensorHub_set_delay_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_GET_DATA,
-		SCP_sensorHub_get_data_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_BATCH,
-		SCP_sensorHub_batch_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_SET_CONFIG,
-		SCP_sensorHub_set_cfg_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_SET_CUST,
-		SCP_sensorHub_set_cust_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_BATCH_TIMEOUT,
-		SCP_sensorHub_batch_timeout_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_SET_TIMESTAMP,
-		SCP_sensorHub_set_timestamp_cmd),
-	SCP_SENSORHUB_CMD(SENSOR_HUB_NOTIFY,
-		SCP_sensorHub_notify_cmd),
-};
-
-const struct SCP_sensorHub_Cmd *
-	SCP_sensorHub_find_cmd(uint32_t packetReason)
-{
-	int i;
-	const struct SCP_sensorHub_Cmd *cmd;
-
-	for (i = 0; i < ARRAY_SIZE(SCP_sensorHub_Cmds); i++) {
-		cmd = &SCP_sensorHub_Cmds[i];
-		if (cmd->reason == packetReason)
-			return cmd;
-	}
-	return NULL;
-}
-
-static void SCP_sensorHub_IPI_handler(int id,
-	void *data, unsigned int len)
-{
-	union SCP_SENSOR_HUB_DATA *rsp = (union SCP_SENSOR_HUB_DATA *) data;
-	const struct SCP_sensorHub_Cmd *cmd;
-
-	if (len > SENSOR_IPI_SIZE) {
-		pr_err("%s len=%d error\n", __func__, len);
-		return;
-	}
-	/*pr_err("sensorType:%d, action=%d event:%d len:%d\n",
-	 * rsp->rsp.sensorType, rsp->rsp.action, rsp->notify_rsp.event, len);
-	 */
-	cmd = SCP_sensorHub_find_cmd(rsp->rsp.action);
-	if (cmd != NULL)
-		cmd->handler(rsp, len);
-	else
-		pr_err("cannot find cmd!\n");
-}
-
-static void SCP_sensorHub_init_sensor_state(void)
-{
-	mSensorState[SENSOR_TYPE_ACCELEROMETER].sensorType =
-		SENSOR_TYPE_ACCELEROMETER;
-	mSensorState[SENSOR_TYPE_ACCELEROMETER].timestamp_filter = true;
-#ifdef CONFIG_MTK_UNCALI_ACCHUB
-	mSensorState[SENSOR_TYPE_ACCELEROMETER].alt =
-		SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED;
-	mSensorState[SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED].sensorType =
-		SENSOR_TYPE_ACCELEROMETER;
-	mSensorState[SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED].alt =
-		SENSOR_TYPE_ACCELEROMETER;
-	mSensorState[SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED].timestamp_filter =
-		true;
-#endif
-
-	mSensorState[SENSOR_TYPE_GYROSCOPE].sensorType = SENSOR_TYPE_GYROSCOPE;
-	mSensorState[SENSOR_TYPE_GYROSCOPE].timestamp_filter = true;
-#ifdef CONFIG_MTK_UNCALI_GYROHUB
-	mSensorState[SENSOR_TYPE_GYROSCOPE].alt =
-		SENSOR_TYPE_GYROSCOPE_UNCALIBRATED;
-	mSensorState[SENSOR_TYPE_GYROSCOPE_UNCALIBRATED].sensorType =
-		SENSOR_TYPE_GYROSCOPE;
-	mSensorState[SENSOR_TYPE_GYROSCOPE_UNCALIBRATED].alt =
-		SENSOR_TYPE_GYROSCOPE;
-	mSensorState[SENSOR_TYPE_GYROSCOPE_UNCALIBRATED].timestamp_filter =
-		true;
-#endif
-
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD].sensorType =
-		SENSOR_TYPE_MAGNETIC_FIELD;
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD].timestamp_filter = true;
-#ifdef CONFIG_MTK_UNCALI_MAGHUB
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD].alt =
-		SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED;
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED].sensorType =
-		SENSOR_TYPE_MAGNETIC_FIELD;
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED].alt =
-		SENSOR_TYPE_MAGNETIC_FIELD;
-	mSensorState[SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED].timestamp_filter =
-		true;
-#endif
-
-	mSensorState[SENSOR_TYPE_LIGHT].sensorType = SENSOR_TYPE_LIGHT;
-	mSensorState[SENSOR_TYPE_LIGHT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_PROXIMITY].sensorType = SENSOR_TYPE_PROXIMITY;
-	mSensorState[SENSOR_TYPE_PROXIMITY].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_PRESSURE].sensorType = SENSOR_TYPE_PRESSURE;
-	mSensorState[SENSOR_TYPE_PRESSURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_ORIENTATION].sensorType =
-		SENSOR_TYPE_ORIENTATION;
-	mSensorState[SENSOR_TYPE_ORIENTATION].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_ROTATION_VECTOR].sensorType =
-		SENSOR_TYPE_ROTATION_VECTOR;
-	mSensorState[SENSOR_TYPE_ROTATION_VECTOR].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GAME_ROTATION_VECTOR].sensorType =
-		SENSOR_TYPE_GAME_ROTATION_VECTOR;
-	mSensorState[SENSOR_TYPE_GAME_ROTATION_VECTOR].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR].sensorType =
-		SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR;
-	mSensorState[SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR].timestamp_filter =
-		true;
-
-	mSensorState[SENSOR_TYPE_LINEAR_ACCELERATION].sensorType =
-		SENSOR_TYPE_LINEAR_ACCELERATION;
-	mSensorState[SENSOR_TYPE_LINEAR_ACCELERATION].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_GRAVITY].sensorType = SENSOR_TYPE_GRAVITY;
-	mSensorState[SENSOR_TYPE_GRAVITY].timestamp_filter = true;
-
-	mSensorState[SENSOR_TYPE_SIGNIFICANT_MOTION].sensorType =
-		SENSOR_TYPE_SIGNIFICANT_MOTION;
-	mSensorState[SENSOR_TYPE_SIGNIFICANT_MOTION].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_SIGNIFICANT_MOTION].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_STEP_COUNTER].sensorType =
-		SENSOR_TYPE_STEP_COUNTER;
-	mSensorState[SENSOR_TYPE_STEP_COUNTER].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_STEP_COUNTER].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_STEP_DETECTOR].sensorType =
-		SENSOR_TYPE_STEP_DETECTOR;
-	mSensorState[SENSOR_TYPE_STEP_DETECTOR].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_STEP_DETECTOR].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_TILT_DETECTOR].sensorType =
-		SENSOR_TYPE_TILT_DETECTOR;
-	mSensorState[SENSOR_TYPE_TILT_DETECTOR].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_TILT_DETECTOR].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_IN_POCKET].sensorType = SENSOR_TYPE_IN_POCKET;
-	mSensorState[SENSOR_TYPE_IN_POCKET].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_IN_POCKET].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_ACTIVITY].sensorType = SENSOR_TYPE_ACTIVITY;
-	mSensorState[SENSOR_TYPE_ACTIVITY].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_GLANCE_GESTURE].sensorType =
-		SENSOR_TYPE_GLANCE_GESTURE;
-	mSensorState[SENSOR_TYPE_GLANCE_GESTURE].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_GLANCE_GESTURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_PICK_UP_GESTURE].sensorType =
-		SENSOR_TYPE_PICK_UP_GESTURE;
-	mSensorState[SENSOR_TYPE_PICK_UP_GESTURE].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_PICK_UP_GESTURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_WAKE_GESTURE].sensorType =
-		SENSOR_TYPE_WAKE_GESTURE;
-	mSensorState[SENSOR_TYPE_WAKE_GESTURE].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_WAKE_GESTURE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_ANSWER_CALL].sensorType =
-		SENSOR_TYPE_ANSWER_CALL;
-	mSensorState[SENSOR_TYPE_ANSWER_CALL].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_ANSWER_CALL].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_STATIONARY_DETECT].sensorType =
-		SENSOR_TYPE_STATIONARY_DETECT;
-	mSensorState[SENSOR_TYPE_STATIONARY_DETECT].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_STATIONARY_DETECT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_MOTION_DETECT].sensorType =
-		SENSOR_TYPE_MOTION_DETECT;
-	mSensorState[SENSOR_TYPE_MOTION_DETECT].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_MOTION_DETECT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_DEVICE_ORIENTATION].sensorType =
-		SENSOR_TYPE_DEVICE_ORIENTATION;
-	mSensorState[SENSOR_TYPE_DEVICE_ORIENTATION].rate =
-		SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_DEVICE_ORIENTATION].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_GEOFENCE].sensorType = SENSOR_TYPE_GEOFENCE;
-	mSensorState[SENSOR_TYPE_GEOFENCE].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_GEOFENCE].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_FLOOR_COUNTER].sensorType =
-		SENSOR_TYPE_FLOOR_COUNTER;
-	mSensorState[SENSOR_TYPE_FLOOR_COUNTER].rate = SENSOR_RATE_ONCHANGE;
-	mSensorState[SENSOR_TYPE_FLOOR_COUNTER].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_FLAT].sensorType = SENSOR_TYPE_FLAT;
-	mSensorState[SENSOR_TYPE_FLAT].rate = SENSOR_RATE_ONESHOT;
-	mSensorState[SENSOR_TYPE_FLAT].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_RGBW].sensorType = SENSOR_TYPE_RGBW;
-	mSensorState[SENSOR_TYPE_RGBW].timestamp_filter = false;
-
-	mSensorState[SENSOR_TYPE_SAR].sensorType = SENSOR_TYPE_SAR;
-	mSensorState[SENSOR_TYPE_SAR].timestamp_filter = false;
-}
-
-static void init_sensor_config_cmd(struct ConfigCmd *cmd,
-		int sensor_type)
-{
-	uint8_t alt = mSensorState[sensor_type].alt;
-	bool enable = 0;
-
-	memset(cmd, 0x00, sizeof(*cmd));
-
-	cmd->evtType = EVT_NO_SENSOR_CONFIG_EVENT;
-	cmd->sensorType = mSensorState[sensor_type].sensorType;
-
-	if (alt && mSensorState[alt].enable &&
-			mSensorState[sensor_type].enable) {
-		cmd->cmd = CONFIG_CMD_ENABLE;
-		if (mSensorState[alt].rate > mSensorState[sensor_type].rate)
-			cmd->rate = mSensorState[alt].rate;
-		else
-			cmd->rate = mSensorState[sensor_type].rate;
-		if (mSensorState[alt].latency <
-				mSensorState[sensor_type].latency)
-			cmd->latency = mSensorState[alt].latency;
-		else
-			cmd->latency = mSensorState[sensor_type].latency;
-	} else if (alt && mSensorState[alt].enable) {
-		enable = mSensorState[alt].enable;
-		cmd->cmd =  enable ? CONFIG_CMD_ENABLE : CONFIG_CMD_DISABLE;
-		cmd->rate = mSensorState[alt].rate;
-		cmd->latency = mSensorState[alt].latency;
-	} else { /* !alt || !mSensorState[alt].enable */
-		enable = mSensorState[sensor_type].enable;
-		cmd->cmd = enable ? CONFIG_CMD_ENABLE : CONFIG_CMD_DISABLE;
-		cmd->rate = mSensorState[sensor_type].rate;
-		cmd->latency = mSensorState[sensor_type].latency;
-	}
-}
-
-static int SCP_sensorHub_batch(int handle, int flag,
-	long long samplingPeriodNs, long long maxBatchReportLatencyNs)
-{
-	uint8_t sensor_type = handle + ID_OFFSET;
-	struct ConfigCmd cmd;
-	int ret = 0;
-	uint64_t rate = 1024000000000ULL;
-
-	if (mSensorState[sensor_type].sensorType) {
-		if (samplingPeriodNs > 0 && mSensorState[sensor_type].rate !=
-			SENSOR_RATE_ONCHANGE &&
-			mSensorState[sensor_type].rate != SENSOR_RATE_ONESHOT) {
-			rate = div64_u64(rate, samplingPeriodNs);
-			mSensorState[sensor_type].rate = rate;
-		}
-		mSensorState[sensor_type].latency = maxBatchReportLatencyNs;
-		init_sensor_config_cmd(&cmd, sensor_type);
-		if (atomic_read(&power_status) != SENSOR_POWER_UP)
-			return 0;
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0) {
-			pr_err("fail enbatch h:%d, r: %d,l: %lld, cmd:%d\n",
-				handle, cmd.rate, cmd.latency, cmd.cmd);
-			return -1;
-		}
-	} else {
-		pr_err("unhandle handle=%d, is inited?\n", handle);
-		return -1;
-	}
-	return 0;
-}
-
-static int SCP_sensorHub_flush(int handle)
-{
-	uint8_t sensor_type = handle + ID_OFFSET;
-	struct ConfigCmd cmd;
-	int ret = 0;
-	atomic_t *p_flush_count = NULL;
-
-	if (mSensorState[sensor_type].sensorType) {
-		init_sensor_config_cmd(&cmd, sensor_type);
-		cmd.cmd = CONFIG_CMD_FLUSH;
-		/*
-		 * add count must before flush, if we add count after
-		 * flush right return and flush callback directly report
-		 * flush will lose flush complete
-		 */
-		p_flush_count = &mSensorState[sensor_type].flushCnt;
-		mutex_lock(&flush_mtx);
-		atomic_inc(p_flush_count);
-		mutex_unlock(&flush_mtx);
-		if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-			ret = nanohub_external_write((const uint8_t *)&cmd,
-				sizeof(struct ConfigCmd));
-			if (ret < 0) {
-				pr_err("failed flush handle:%d\n", handle);
-				mutex_lock(&flush_mtx);
-				if (atomic_read(p_flush_count) > 0)
-					atomic_dec(p_flush_count);
-				mutex_unlock(&flush_mtx);
-				return -1;
-			}
-		}
-	} else {
-		pr_err("unhandle handle=%d, is inited?\n", handle);
-		return -1;
-	}
-	return 0;
-}
-
-static int SCP_sensorHub_report_raw_data(struct data_unit_t *data_t)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	int err = 0, sensor_type = 0, sensor_id = 0;
-	atomic_t *p_flush_count = NULL;
-	bool raw_enable = 0;
-	int64_t raw_enable_time = 0;
-
-	sensor_id = data_t->sensor_type;
-	sensor_type = sensor_id + ID_OFFSET;
-
-	if (sensor_id < 0 || sensor_id > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid sensor %d\n", sensor_id);
-		return 0;
-	}
-
-	if (obj->dispatch_data_cb[sensor_id] == NULL) {
-		pr_err("type:%d don't support this flow?\n", sensor_id);
-		return 0;
-	}
-
-	raw_enable = READ_ONCE(mSensorState[sensor_type].enable);
-	raw_enable_time = atomic64_read(&mSensorState[sensor_type].enableTime);
-
-	if (raw_enable && data_t->flush_action == DATA_ACTION) {
-		if (data_t->time_stamp > raw_enable_time)
-			err = obj->dispatch_data_cb[sensor_id](data_t, NULL);
-		else
-			pr_info("ac:%d, e:%lld, d:%lld\n", data_t->flush_action,
-				raw_enable_time, data_t->time_stamp);
-	} else if (data_t->flush_action == FLUSH_ACTION) {
-		mutex_lock(&flush_mtx);
-		p_flush_count = &mSensorState[sensor_type].flushCnt;
-		if (atomic_read(p_flush_count) > 0) {
-			err = obj->dispatch_data_cb[sensor_id](data_t, NULL);
-			if (!err)
-				atomic_dec(p_flush_count);
-		}
-		mutex_unlock(&flush_mtx);
-	} else if (data_t->flush_action == BIAS_ACTION ||
-			data_t->flush_action == CALI_ACTION ||
-			data_t->flush_action == TEMP_ACTION ||
-			data_t->flush_action == TEST_ACTION)
-		err = obj->dispatch_data_cb[sensor_id](data_t, NULL);
-	return err;
-}
-
-static int SCP_sensorHub_report_alt_data(struct data_unit_t *data_t)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	int err = 0, sensor_type = 0, sensor_id = 0, alt_id;
-	uint8_t alt = 0;
-	atomic_t *p_flush_count = NULL;
-	bool alt_enable = 0;
-	int64_t alt_enable_time = 0;
-
-	sensor_id = data_t->sensor_type;
-	sensor_type = sensor_id + ID_OFFSET;
-
-	if (sensor_id < 0 || sensor_id > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid sensor %d\n", sensor_id);
-		return 0;
-	}
-
-	alt = READ_ONCE(mSensorState[sensor_type].alt);
-	alt_id = alt - ID_OFFSET;
-
-	if (alt == 0)
-		return 0;
-
-	if (obj->dispatch_data_cb[alt_id] == NULL) {
-		pr_err("alt:%d don't support this flow?\n", alt_id);
-		return 0;
-	}
-
-	alt_enable = READ_ONCE(mSensorState[alt].enable);
-	alt_enable_time = atomic64_read(&mSensorState[alt].enableTime);
-
-	if (alt_enable && data_t->flush_action == DATA_ACTION) {
-		if (data_t->time_stamp > alt_enable_time)
-			err = obj->dispatch_data_cb[alt_id](data_t, NULL);
-		else
-			pr_info("ac:%d, e:%lld, d:%lld\n", data_t->flush_action,
-				alt_enable_time, data_t->time_stamp);
-	} else if (data_t->flush_action == FLUSH_ACTION) {
-		mutex_lock(&flush_mtx);
-		p_flush_count = &mSensorState[alt].flushCnt;
-		if (atomic_read(p_flush_count) > 0) {
-			err = obj->dispatch_data_cb[alt_id](data_t, NULL);
-			if (!err)
-				atomic_dec(p_flush_count);
-		}
-		mutex_unlock(&flush_mtx);
-	}
-
-	return err;
-}
-
-static int SCP_sensorHub_server_dispatch_data(uint32_t *currWp)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	char *pStart, *pEnd, *rp, *wp;
-	struct data_unit_t event;
-	uint32_t wp_copy;
-	int err = 0;
-
-	int64_t scp_time = 0;
-
-	pStart = (char *)READ_ONCE(obj->SCP_sensorFIFO) +
-		offsetof(struct sensorFIFO, data);
-	pEnd = pStart +  READ_ONCE(obj->SCP_sensorFIFO->FIFOSize);
-	wp_copy = *currWp;
-	rp = pStart + READ_ONCE(obj->SCP_sensorFIFO->rp);
-	wp = pStart + wp_copy;
-
-	if (wp < pStart || pEnd < wp) {
-		pr_err("FIFO wp invalid : %p, %p, %p\n", pStart, pEnd, wp);
-		return -5;
-	}
-	if (rp == wp) {
-		pr_err("FIFO empty\n");
-		return 0;
-	}
-	/*
-	 * opimize for dram,no cache,we should cpy data to cacheable ram
-	 * event and event_copy are cacheable ram, SCP_sensorHub_report_data
-	 * will change time_stamp field, so when SCP_sensorHub_report_data fail
-	 * we should reinit the time_stamp by memcpy to event_copy;
-	 * why memcpy_fromio(&event_copy), because rp is not cacheable
-	 */
-	if (rp < wp) {
-		while (rp < wp) {
-			memcpy_fromio(&event, rp, SENSOR_DATA_SIZE);
-
-			scp_time = event.time_stamp;
-			event.time_stamp +=
-				get_filter_output(&moving_average_algo);
-
-			do {
-				err = SCP_sensorHub_report_raw_data(&event);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-
-			do {
-				err = SCP_sensorHub_report_alt_data(&event);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-
-			rp += SENSOR_DATA_SIZE;
-		}
-	} else if (rp > wp) {
-		while (rp < pEnd) {
-			memcpy_fromio(&event, rp, SENSOR_DATA_SIZE);
-			scp_time = event.time_stamp;
-			event.time_stamp +=
-				get_filter_output(&moving_average_algo);
-
-			do {
-				err = SCP_sensorHub_report_raw_data(&event);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-
-			do {
-				err = SCP_sensorHub_report_alt_data(&event);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-
-			rp += SENSOR_DATA_SIZE;
-		}
-		rp = pStart;
-		while (rp < wp) {
-			memcpy_fromio(&event, rp, SENSOR_DATA_SIZE);
-			scp_time = event.time_stamp;
-			event.time_stamp +=
-				get_filter_output(&moving_average_algo);
-
-			do {
-				err = SCP_sensorHub_report_raw_data(&event);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-
-			do {
-				err = SCP_sensorHub_report_alt_data(&event);
-				if (err < 0)
-					usleep_range(2000, 4000);
-			} while (err < 0);
-
-			rp += SENSOR_DATA_SIZE;
-		}
-	}
-	/* must obj->SCP_sensorFIFO->rp = wp,
-	 *there can not obj->SCP_sensorFIFO->rp = obj->SCP_sensorFIFO->wp
-	 */
-	WRITE_ONCE(obj->SCP_sensorFIFO->rp, wp_copy);
-	return 0;
-}
-
-static int sensor_send_dram_info_to_hub(void)
-{				/* call by init done workqueue */
-	struct SCP_sensorHub_data *obj = obj_data;
-	union SCP_SENSOR_HUB_DATA data;
-	unsigned int len = 0;
-	int err = 0, retry = 0, total = 10;
-
-	obj->shub_dram_phys = scp_get_reserve_mem_phys(SENS_MEM_ID);
-	obj->shub_dram_virt = scp_get_reserve_mem_virt(SENS_MEM_ID);
-
-	data.set_config_req.sensorType = 0;
-	data.set_config_req.action = SENSOR_HUB_SET_CONFIG;
-	data.set_config_req.bufferBase =
-		(unsigned int)(obj->shub_dram_phys & 0xFFFFFFFF);
-
-	len = sizeof(data.set_config_req);
-	for (retry = 0; retry < total; ++retry) {
-		err = scp_sensorHub_req_send(&data, &len, 1);
-		if (err < 0) {
-			pr_err("%s fail!\n", __func__);
-			continue;
-		}
-		break;
-	}
-	if (retry < total)
-		pr_notice("[sensorHub] %s success\n", __func__);
-	return SCP_SENSOR_HUB_SUCCESS;
-}
-
-static int sensor_send_timestamp_wake_locked(void)
-{
-	union SCP_SENSOR_HUB_DATA req;
-	int len;
-	int err = 0;
-	uint64_t now_time, arch_counter;
-
-	/* send_timestamp_to_hub is process context, disable irq is safe */
-	local_irq_disable();
-	now_time = ktime_get_boot_ns();
-	arch_counter = arch_counter_get_cntvct();
-	local_irq_enable();
-	req.set_config_req.sensorType = 0;
-	req.set_config_req.action = SENSOR_HUB_SET_TIMESTAMP;
-	req.set_config_req.ap_timestamp = now_time;
-	req.set_config_req.arch_counter = arch_counter;
-	pr_debug("sync ap boottime=%lld\n", now_time);
-	len = sizeof(req.set_config_req);
-	err = scp_sensorHub_req_send(&req, &len, 1);
-	if (err < 0)
-		pr_err("scp_sensorHub_req_send fail!\n");
-	return err;
-}
-
-static int sensor_send_timestamp_to_hub(void)
-{
-	int err = 0;
-	struct SCP_sensorHub_data *obj = obj_data;
-
-	if (READ_ONCE(rtc_compensation_suspend)) {
-		pr_err("rtc_compensation_suspend suspend,drop time sync\n");
-		return 0;
-	}
-
-	__pm_stay_awake(obj->ws);
-	err = sensor_send_timestamp_wake_locked();
-	__pm_relax(obj->ws);
-	return err;
-}
-static void sensor_disable_report_flush(uint8_t handle)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	uint8_t sensor_type = handle + ID_OFFSET;
-	struct data_unit_t data_t;
-	atomic_t *p_flush_count = NULL;
-	SCP_sensorHub_handler func;
-	int ret = 0, retry = 0;
-
-	func = obj->dispatch_data_cb[handle];
-	if (!func)
-		return;
-
-	/*
-	 * disable sensor only check func return err 5 times
-	 */
-	mutex_lock(&flush_mtx);
-	p_flush_count = &mSensorState[sensor_type].flushCnt;
-	while (atomic_read(p_flush_count) > 0) {
-		atomic_dec(p_flush_count);
-		memset(&data_t, 0, sizeof(struct data_unit_t));
-		data_t.sensor_type = handle;
-		data_t.flush_action = FLUSH_ACTION;
-		do {
-			ret = func(&data_t, NULL);
-			if (ret < 0)
-				usleep_range(2000, 4000);
-		} while (ret < 0 && retry++ < 5);
-		if (ret < 0)
-			pr_err("%d flush complete err when disable\n",
-				handle);
-	}
-	mutex_unlock(&flush_mtx);
-}
-int sensor_enable_to_hub(uint8_t handle, int enabledisable)
-{
-	uint8_t sensor_type = handle + ID_OFFSET;
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	if (enabledisable == 1)
-		scp_register_feature(SENS_FEATURE_ID);
-	mutex_lock(&mSensorState_mtx);
-	if (handle > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid handle %d\n", handle);
-		ret = -1;
-		mutex_unlock(&mSensorState_mtx);
-		return ret;
-	}
-	if (mSensorState[sensor_type].sensorType) {
-		mSensorState[sensor_type].enable = enabledisable;
-		if (enabledisable)
-			atomic64_set(&mSensorState[sensor_type].enableTime,
-							ktime_get_boot_ns());
-		init_sensor_config_cmd(&cmd, sensor_type);
-		if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-			ret = nanohub_external_write((const uint8_t *)&cmd,
-				sizeof(struct ConfigCmd));
-			if (ret < 0)
-				pr_err
-				    ("fail registerlistener handle:%d,cmd:%d\n",
-				     handle, cmd.cmd);
-		}
-		if (!enabledisable)
-			sensor_disable_report_flush(handle);
-	} else {
-		pr_err("unhandle handle=%d, is inited?\n", handle);
-		mutex_unlock(&mSensorState_mtx);
-		return -1;
-	}
-	mutex_unlock(&mSensorState_mtx);
-	return ret < 0 ? ret : 0;
-}
-EXPORT_SYMBOL_GPL(sensor_enable_to_hub);
-
-int sensor_set_delay_to_hub(uint8_t handle, unsigned int delayms)
-{
-	int ret = 0;
-	long long samplingPeriodNs = delayms * 1000000ULL;
-
-	mutex_lock(&mSensorState_mtx);
-	if (handle > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid sensor %d\n", handle);
-		ret = -1;
-	} else {
-		ret = SCP_sensorHub_batch(handle, 0, samplingPeriodNs, 0);
-	}
-	mutex_unlock(&mSensorState_mtx);
-	return ret < 0 ? ret : 0;
-}
-EXPORT_SYMBOL_GPL(sensor_set_delay_to_hub);
-
-int sensor_batch_to_hub(uint8_t handle,
-	int flag, int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	int ret = 0;
-
-	mutex_lock(&mSensorState_mtx);
-	if (handle > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid handle %d\n", handle);
-		ret = -1;
-	} else
-		ret = SCP_sensorHub_batch(handle,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-	mutex_unlock(&mSensorState_mtx);
-	return ret;
-}
-EXPORT_SYMBOL_GPL(sensor_batch_to_hub);
-
-int sensor_flush_to_hub(uint8_t handle)
-{
-	int ret = 0;
-
-	mutex_lock(&mSensorState_mtx);
-	if (handle > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid handle %d\n", handle);
-		ret = -1;
-	} else
-		ret = SCP_sensorHub_flush(handle);
-	mutex_unlock(&mSensorState_mtx);
-	return ret;
-}
-EXPORT_SYMBOL_GPL(sensor_flush_to_hub);
-
-int sensor_cfg_to_hub(uint8_t handle, uint8_t *data, uint8_t count)
-{
-	struct ConfigCmd *cmd = NULL;
-	int ret = 0;
-
-	if (handle > ID_SENSOR_MAX_HANDLE) {
-		pr_err("invalid handle %d\n", handle);
-		ret = -1;
-	} else {
-		cmd = vzalloc(sizeof(struct ConfigCmd) + count);
-		if (cmd == NULL)
-			return -1;
-		cmd->evtType = EVT_NO_SENSOR_CONFIG_EVENT;
-		cmd->sensorType = handle + ID_OFFSET;
-		cmd->cmd = CONFIG_CMD_CFG_DATA;
-		memcpy(cmd->data, data, count);
-		ret = nanohub_external_write((const uint8_t *)cmd,
-			sizeof(struct ConfigCmd) + count);
-		if (ret < 0) {
-			pr_err("failed cfg data handle:%d, cmd:%d\n",
-				handle, cmd->cmd);
-			ret =  -1;
-		}
-		vfree(cmd);
-	}
-	return ret;
-}
-EXPORT_SYMBOL_GPL(sensor_cfg_to_hub);
-
-int sensor_calibration_to_hub(uint8_t handle)
-{
-	uint8_t sensor_type = handle + ID_OFFSET;
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	if (mSensorState[sensor_type].sensorType) {
-		init_sensor_config_cmd(&cmd, sensor_type);
-		cmd.cmd = CONFIG_CMD_CALIBRATE;
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0) {
-			pr_err("failed calibration handle:%d\n",
-				handle);
-			return -1;
-		}
-	} else {
-		pr_err("unhandle handle=%d, is inited?\n", handle);
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(sensor_calibration_to_hub);
-
-int sensor_selftest_to_hub(uint8_t handle)
-{
-	uint8_t sensor_type = handle + ID_OFFSET;
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	if (mSensorState[sensor_type].sensorType) {
-		init_sensor_config_cmd(&cmd, sensor_type);
-		cmd.cmd = CONFIG_CMD_SELF_TEST;
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0) {
-			pr_err("failed selfttest handle:%d\n",
-				handle);
-			return -1;
-		}
-	} else {
-		pr_err("unhandle handle=%d, is inited?\n", handle);
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(sensor_selftest_to_hub);
-
-int sensor_get_data_from_hub(uint8_t sensorType,
-	struct data_unit_t *data)
-{
-	union SCP_SENSOR_HUB_DATA req;
-	struct data_unit_t *data_t;
-	int len = 0, err = 0;
-
-	if (atomic_read(&power_status) == SENSOR_POWER_DOWN) {
-		pr_err("scp power down, we can not access scp\n");
-		return -1;
-	}
-
-	req.get_data_req.sensorType = sensorType;
-	req.get_data_req.action = SENSOR_HUB_GET_DATA;
-	len = sizeof(req.get_data_req);
-	err = scp_sensorHub_req_send(&req, &len, 1);
-	if (err < 0) {
-		pr_err("fail :%d!\n", err);
-		return -1;
-	}
-	if (sensorType != req.get_data_rsp.sensorType ||
-		req.get_data_rsp.action != SENSOR_HUB_GET_DATA ||
-		req.get_data_rsp.errCode != 0) {
-		pr_err("req Type: %d, rsp Type:%d action:%d, errcode:%d\n",
-			sensorType, req.get_data_rsp.sensorType,
-			req.get_data_rsp.action, req.get_data_rsp.errCode);
-
-		return req.get_data_rsp.errCode;
-	}
-
-	data_t = (struct data_unit_t *)req.get_data_rsp.data.int8_Data;
-	switch (sensorType) {
-	case ID_ACCELEROMETER:
-		data->time_stamp = data_t->time_stamp;
-		data->accelerometer_t.x = data_t->accelerometer_t.x;
-		data->accelerometer_t.y = data_t->accelerometer_t.y;
-		data->accelerometer_t.z = data_t->accelerometer_t.z;
-		data->accelerometer_t.x_bias = data_t->accelerometer_t.x_bias;
-		data->accelerometer_t.y_bias = data_t->accelerometer_t.y_bias;
-		data->accelerometer_t.z_bias = data_t->accelerometer_t.z_bias;
-		data->accelerometer_t.status = data_t->accelerometer_t.status;
-		break;
-	case ID_GRAVITY:
-		data->time_stamp = data_t->time_stamp;
-		data->accelerometer_t.x = data_t->accelerometer_t.x;
-		data->accelerometer_t.y = data_t->accelerometer_t.y;
-		data->accelerometer_t.z = data_t->accelerometer_t.z;
-		data->accelerometer_t.status = data_t->accelerometer_t.status;
-		break;
-	case ID_LINEAR_ACCELERATION:
-		data->time_stamp = data_t->time_stamp;
-		data->accelerometer_t.x = data_t->accelerometer_t.x;
-		data->accelerometer_t.y = data_t->accelerometer_t.y;
-		data->accelerometer_t.z = data_t->accelerometer_t.z;
-		data->accelerometer_t.status = data_t->accelerometer_t.status;
-		break;
-	case ID_LIGHT:
-		data->time_stamp = data_t->time_stamp;
-		data->light = data_t->light;
-		break;
-	case ID_PROXIMITY:
-		data->time_stamp = data_t->time_stamp;
-		data->proximity_t.steps = data_t->proximity_t.steps;
-		data->proximity_t.oneshot = data_t->proximity_t.oneshot;
-		break;
-	case ID_PRESSURE:
-		data->time_stamp = data_t->time_stamp;
-		data->pressure_t.pressure = data_t->pressure_t.pressure;
-		data->pressure_t.status = data_t->pressure_t.status;
-		break;
-	case ID_GYROSCOPE:
-		data->time_stamp = data_t->time_stamp;
-		data->gyroscope_t.x = data_t->gyroscope_t.x;
-		data->gyroscope_t.y = data_t->gyroscope_t.y;
-		data->gyroscope_t.z = data_t->gyroscope_t.z;
-		data->gyroscope_t.x_bias = data_t->gyroscope_t.x_bias;
-		data->gyroscope_t.y_bias  = data_t->gyroscope_t.y_bias;
-		data->gyroscope_t.z_bias  = data_t->gyroscope_t.z_bias;
-		data->gyroscope_t.status = data_t->gyroscope_t.status;
-		break;
-	case ID_GYROSCOPE_UNCALIBRATED:
-		data->time_stamp = data_t->time_stamp;
-		data->uncalibrated_gyro_t.x = data_t->uncalibrated_gyro_t.x;
-		data->uncalibrated_gyro_t.y = data_t->uncalibrated_gyro_t.y;
-		data->uncalibrated_gyro_t.z = data_t->uncalibrated_gyro_t.z;
-		data->uncalibrated_gyro_t.x_bias =
-			data_t->uncalibrated_gyro_t.x_bias;
-		data->uncalibrated_gyro_t.y_bias  =
-			data_t->uncalibrated_gyro_t.y_bias;
-		data->uncalibrated_gyro_t.z_bias  =
-			data_t->uncalibrated_gyro_t.z_bias;
-		data->uncalibrated_gyro_t.status =
-			data_t->uncalibrated_gyro_t.status;
-		break;
-	case ID_RELATIVE_HUMIDITY:
-		data->time_stamp = data_t->time_stamp;
-		data->relative_humidity_t.relative_humidity =
-		data_t->relative_humidity_t.relative_humidity;
-		data->relative_humidity_t.status =
-			data_t->relative_humidity_t.status;
-		break;
-	case ID_MAGNETIC:
-		data->time_stamp = data_t->time_stamp;
-		data->magnetic_t.x = data_t->magnetic_t.x;
-		data->magnetic_t.y = data_t->magnetic_t.y;
-		data->magnetic_t.z = data_t->magnetic_t.z;
-		data->magnetic_t.x_bias = data_t->magnetic_t.x_bias;
-		data->magnetic_t.y_bias = data_t->magnetic_t.y_bias;
-		data->magnetic_t.z_bias = data_t->magnetic_t.z_bias;
-		data->magnetic_t.status = data_t->magnetic_t.status;
-		break;
-	case ID_MAGNETIC_UNCALIBRATED:
-		data->time_stamp = data_t->time_stamp;
-		data->uncalibrated_mag_t.x = data_t->uncalibrated_mag_t.x;
-		data->uncalibrated_mag_t.y = data_t->uncalibrated_mag_t.y;
-		data->uncalibrated_mag_t.z = data_t->uncalibrated_mag_t.z;
-		data->uncalibrated_mag_t.x_bias =
-			data_t->uncalibrated_mag_t.x_bias;
-		data->uncalibrated_mag_t.y_bias =
-			data_t->uncalibrated_mag_t.y_bias;
-		data->uncalibrated_mag_t.z_bias =
-			data_t->uncalibrated_mag_t.z_bias;
-		data->uncalibrated_mag_t.status =
-			data_t->uncalibrated_mag_t.status;
-		break;
-	case ID_GEOMAGNETIC_ROTATION_VECTOR:
-		data->time_stamp = data_t->time_stamp;
-		data->magnetic_t.x = data_t->magnetic_t.x;
-		data->magnetic_t.y = data_t->magnetic_t.y;
-		data->magnetic_t.z = data_t->magnetic_t.z;
-		data->magnetic_t.scalar = data_t->magnetic_t.scalar;
-		data->magnetic_t.status = data_t->magnetic_t.status;
-		break;
-	case ID_ORIENTATION:
-		data->time_stamp = data_t->time_stamp;
-		data->orientation_t.azimuth = data_t->orientation_t.azimuth;
-		data->orientation_t.pitch = data_t->orientation_t.pitch;
-		data->orientation_t.roll = data_t->orientation_t.roll;
-		data->orientation_t.status = data_t->orientation_t.status;
-		break;
-	case ID_ROTATION_VECTOR:
-		data->time_stamp = data_t->time_stamp;
-		data->orientation_t.azimuth = data_t->orientation_t.azimuth;
-		data->orientation_t.pitch = data_t->orientation_t.pitch;
-		data->orientation_t.roll = data_t->orientation_t.roll;
-		data->orientation_t.scalar = data_t->orientation_t.scalar;
-		data->orientation_t.status = data_t->orientation_t.status;
-		break;
-	case ID_GAME_ROTATION_VECTOR:
-		data->time_stamp = data_t->time_stamp;
-		data->orientation_t.azimuth = data_t->orientation_t.azimuth;
-		data->orientation_t.pitch = data_t->orientation_t.pitch;
-		data->orientation_t.roll = data_t->orientation_t.roll;
-		data->orientation_t.scalar = data_t->orientation_t.scalar;
-		data->orientation_t.status = data_t->orientation_t.status;
-		break;
-	case ID_STEP_COUNTER:
-		data->time_stamp = data_t->time_stamp;
-		data->step_counter_t.accumulated_step_count
-		    = data_t->step_counter_t.accumulated_step_count;
-		break;
-	case ID_STEP_DETECTOR:
-		data->time_stamp = data_t->time_stamp;
-		data->step_detector_t.step_detect =
-			data_t->step_detector_t.step_detect;
-		break;
-	case ID_SIGNIFICANT_MOTION:
-		data->time_stamp = data_t->time_stamp;
-		data->smd_t.state = data_t->smd_t.state;
-		break;
-	case ID_HEART_RATE:
-		data->time_stamp = data_t->time_stamp;
-		data->heart_rate_t.bpm = data_t->heart_rate_t.bpm;
-		data->heart_rate_t.status = data_t->heart_rate_t.status;
-		break;
-	case ID_PEDOMETER:
-		data->time_stamp = data_t->time_stamp;
-		data->pedometer_t.accumulated_step_count =
-		    data_t->pedometer_t.accumulated_step_count;
-		data->pedometer_t.accumulated_step_length =
-		    data_t->pedometer_t.accumulated_step_length;
-		data->pedometer_t.step_frequency =
-			data_t->pedometer_t.step_frequency;
-		data->pedometer_t.step_length =
-			data_t->pedometer_t.step_length;
-		break;
-	case ID_ACTIVITY:
-		data->time_stamp = data_t->time_stamp;
-		data->activity_data_t.probability[STILL] =
-		    data_t->activity_data_t.probability[STILL];
-		data->activity_data_t.probability[STANDING] =
-		    data_t->activity_data_t.probability[STANDING];
-		data->activity_data_t.probability[SITTING] =
-		    data_t->activity_data_t.probability[SITTING];
-		data->activity_data_t.probability[LYING] =
-		    data_t->activity_data_t.probability[LYING];
-		data->activity_data_t.probability[ON_FOOT] =
-		    data_t->activity_data_t.probability[ON_FOOT];
-		data->activity_data_t.probability[WALKING] =
-		    data_t->activity_data_t.probability[WALKING];
-		data->activity_data_t.probability[RUNNING] =
-		    data_t->activity_data_t.probability[RUNNING];
-		data->activity_data_t.probability[CLIMBING] =
-		    data_t->activity_data_t.probability[CLIMBING];
-		data->activity_data_t.probability[ON_BICYCLE] =
-		    data_t->activity_data_t.probability[ON_BICYCLE];
-		data->activity_data_t.probability[IN_VEHICLE] =
-		    data_t->activity_data_t.probability[IN_VEHICLE];
-		data->activity_data_t.probability[TILTING] =
-		    data_t->activity_data_t.probability[TILTING];
-		data->activity_data_t.probability[UNKNOWN] =
-		    data_t->activity_data_t.probability[UNKNOWN];
-		break;
-	case ID_IN_POCKET:
-		data->time_stamp = data_t->time_stamp;
-		data->inpocket_event.state = data_t->inpocket_event.state;
-		break;
-	case ID_PICK_UP_GESTURE:
-		data->time_stamp = data_t->time_stamp;
-		data->gesture_data_t.probability =
-			data_t->gesture_data_t.probability;
-		break;
-	case ID_TILT_DETECTOR:
-		data->time_stamp = data_t->time_stamp;
-		data->tilt_event.state = data_t->tilt_event.state;
-		break;
-	case ID_WAKE_GESTURE:
-		data->time_stamp = data_t->time_stamp;
-		data->gesture_data_t.probability =
-			data_t->gesture_data_t.probability;
-		break;
-	case ID_GLANCE_GESTURE:
-		data->time_stamp = data_t->time_stamp;
-		data->gesture_data_t.probability =
-			data_t->gesture_data_t.probability;
-		break;
-	case ID_PDR:
-		data->time_stamp = data_t->time_stamp;
-		data->pdr_event.x = data_t->pdr_event.x;
-		data->pdr_event.y = data_t->pdr_event.y;
-		data->pdr_event.z = data_t->pdr_event.z;
-		data->pdr_event.status = data_t->pdr_event.status;
-		break;
-	case ID_FLOOR_COUNTER:
-		data->time_stamp = data_t->time_stamp;
-		data->floor_counter_t.accumulated_floor_count
-		    = data_t->floor_counter_t.accumulated_floor_count;
-		break;
-	case ID_SAR:
-		data->time_stamp = data_t->time_stamp;
-		data->sar_event.data[0] = data_t->sar_event.data[0];
-		data->sar_event.data[1] = data_t->sar_event.data[1];
-		data->sar_event.data[2] = data_t->sar_event.data[2];
-		break;
-	default:
-		err = -1;
-		break;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(sensor_get_data_from_hub);
-
-int sensor_set_cmd_to_hub(uint8_t sensorType,
-	enum CUST_ACTION action, void *data)
-{
-	union SCP_SENSOR_HUB_DATA req;
-	int len = 0, err = 0;
-	struct SCP_SENSOR_HUB_GET_RAW_DATA *pGetRawData;
-
-	req.get_data_req.sensorType = sensorType;
-	req.get_data_req.action = SENSOR_HUB_SET_CUST;
-
-	if (atomic_read(&power_status) == SENSOR_POWER_DOWN) {
-		pr_err("scp power down, we can not access scp\n");
-		return -1;
-	}
-
-	switch (sensorType) {
-	case ID_ACCELEROMETER:
-		req.set_cust_req.sensorType = ID_ACCELEROMETER;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_RESET_CALI:
-			req.set_cust_req.resetCali.action =
-				CUST_ACTION_RESET_CALI;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.resetCali);
-			break;
-		case CUST_ACTION_SET_CALI:
-			req.set_cust_req.setCali.action = CUST_ACTION_SET_CALI;
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_X]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_X);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Y]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Y);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Z]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Z);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setCali);
-			break;
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SET_DIRECTION:
-			req.set_cust_req.setDirection.action =
-				CUST_ACTION_SET_DIRECTION;
-			req.set_cust_req.setDirection.direction =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			     custData) + sizeof(req.set_cust_req.setDirection);
-			break;
-		case CUST_ACTION_SET_FACTORY:
-			req.set_cust_req.setFactory.action =
-				CUST_ACTION_SET_FACTORY;
-			req.set_cust_req.setFactory.factory =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setFactory);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_LIGHT:
-		req.set_cust_req.sensorType = ID_LIGHT;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_GET_RAW_DATA:
-			req.set_cust_req.getRawData.action =
-				CUST_ACTION_GET_RAW_DATA;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getRawData);
-			err = scp_sensorHub_req_send(&req, &len, 1);
-			if (err == 0) {
-				if ((req.set_cust_rsp.action !=
-					SENSOR_HUB_SET_CUST)
-					|| (req.set_cust_rsp.errCode != 0)) {
-					pr_err("scp_sHub_req_send fail!\n");
-					return -1;
-				}
-				if (req.set_cust_rsp.getRawData.action !=
-					CUST_ACTION_GET_RAW_DATA) {
-					pr_err("scp_sHub_req_send fail!\n");
-					return -1;
-				}
-				pGetRawData = &req.set_cust_rsp.getRawData;
-				*((uint8_t *) data) =
-					pGetRawData->uint8_data[0];
-			} else {
-				pr_err("scp_sensorHub_req_send failed!\n");
-			}
-			return 0;
-		case CUST_ACTION_SHOW_ALSLV:
-			req.set_cust_req.showAlslv.action =
-				CUST_ACTION_SHOW_ALSLV;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showAlslv);
-			break;
-		case CUST_ACTION_SHOW_ALSVAL:
-			req.set_cust_req.showAlsval.action =
-				CUST_ACTION_GET_RAW_DATA;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showAlsval);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_PROXIMITY:
-		req.set_cust_req.sensorType = ID_PROXIMITY;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_RESET_CALI:
-			req.set_cust_req.resetCali.action =
-				CUST_ACTION_RESET_CALI;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.resetCali);
-			break;
-		case CUST_ACTION_SET_CALI:
-			req.set_cust_req.setCali.action = CUST_ACTION_SET_CALI;
-			req.set_cust_req.setCali.int32_data[0] =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setCali);
-			break;
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_SET_PS_THRESHOLD:
-			req.set_cust_req.setPSThreshold.action =
-				CUST_ACTION_SET_PS_THRESHOLD;
-			req.set_cust_req.setPSThreshold.threshold[0]
-			    = *((int32_t *) data + 0);
-			req.set_cust_req.setPSThreshold.threshold[1]
-			    = *((int32_t *) data + 1);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			    custData) + sizeof(req.set_cust_req.setPSThreshold);
-			break;
-		case CUST_ACTION_GET_RAW_DATA:
-			req.set_cust_req.getRawData.action =
-				CUST_ACTION_GET_RAW_DATA;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getRawData);
-			err = scp_sensorHub_req_send(&req, &len, 1);
-			if (err == 0) {
-				if ((req.set_cust_rsp.action !=
-					SENSOR_HUB_SET_CUST)
-					|| (req.set_cust_rsp.errCode != 0)) {
-					pr_err("scp_sHub_req_send fail!\n");
-					return -1;
-				}
-				if (req.set_cust_rsp.getRawData.action !=
-					CUST_ACTION_GET_RAW_DATA) {
-					pr_err("scp_sHub_req_send fail!\n");
-					return -1;
-				}
-				pGetRawData = &req.set_cust_rsp.getRawData;
-				*((uint16_t *) data) =
-					pGetRawData->uint16_data[0];
-			} else {
-				pr_err("scp_sensorHub_req_send failed!\n");
-			}
-			return 0;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_PRESSURE:
-		req.set_cust_req.sensorType = ID_PRESSURE;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_GYROSCOPE:
-		req.set_cust_req.sensorType = ID_GYROSCOPE;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_RESET_CALI:
-			req.set_cust_req.resetCali.action =
-				CUST_ACTION_RESET_CALI;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.resetCali);
-			break;
-		case CUST_ACTION_SET_CALI:
-			req.set_cust_req.setCali.action = CUST_ACTION_SET_CALI;
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_X]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_X);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Y]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Y);
-			req.set_cust_req.setCali.int32_data[SCP_SENSOR_HUB_Z]
-			    = *((int32_t *) data + SCP_SENSOR_HUB_Z);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setCali);
-			break;
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SET_DIRECTION:
-			req.set_cust_req.setDirection.action =
-				CUST_ACTION_SET_DIRECTION;
-			req.set_cust_req.setDirection.direction =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			     custData) + sizeof(req.set_cust_req.setDirection);
-			break;
-		case CUST_ACTION_SET_FACTORY:
-			req.set_cust_req.setFactory.action =
-				CUST_ACTION_SET_FACTORY;
-			req.set_cust_req.setFactory.factory =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setFactory);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action =
-				CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_RELATIVE_HUMIDITY:
-		req.set_cust_req.sensorType = ID_MAGNETIC;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_MAGNETIC:
-		req.set_cust_req.sensorType = ID_MAGNETIC;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		case CUST_ACTION_SET_DIRECTION:
-			req.set_cust_req.setDirection.action =
-				CUST_ACTION_SET_DIRECTION;
-			req.set_cust_req.setDirection.direction =
-				*((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-			     custData) + sizeof(req.set_cust_req.setDirection);
-			break;
-		case CUST_ACTION_SHOW_REG:
-			req.set_cust_req.showReg.action = CUST_ACTION_SHOW_REG;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.showReg);
-			break;
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	case ID_SAR:
-		req.set_cust_req.sensorType = ID_SAR;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_GET_SENSOR_INFO:
-			req.set_cust_req.getInfo.action =
-				CUST_ACTION_GET_SENSOR_INFO;
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.getInfo);
-			break;
-		default:
-			return -1;
-		}
-		break;
-	default:
-		req.set_cust_req.sensorType = sensorType;
-		req.set_cust_req.action = SENSOR_HUB_SET_CUST;
-		switch (action) {
-		case CUST_ACTION_SET_TRACE:
-			req.set_cust_req.setTrace.action =
-				CUST_ACTION_SET_TRACE;
-			req.set_cust_req.setTrace.trace = *((int32_t *) data);
-			len = offsetof(struct SCP_SENSOR_HUB_SET_CUST_REQ,
-				custData) + sizeof(req.set_cust_req.setTrace);
-			break;
-		default:
-			return -1;
-		}
-	}
-	err = scp_sensorHub_req_send(&req, &len, 1);
-	if (err < 0) {
-		pr_err("scp_sensorHub_req_send fail!\n");
-		return -1;
-	}
-	if (sensorType != req.get_data_rsp.sensorType
-		|| SENSOR_HUB_SET_CUST != req.get_data_rsp.action
-		|| 0 != req.get_data_rsp.errCode) {
-		pr_err("error : %d\n", req.get_data_rsp.errCode);
-		return req.get_data_rsp.errCode;
-	}
-
-	switch (action) {
-	case CUST_ACTION_GET_SENSOR_INFO:
-		if (req.set_cust_rsp.getInfo.action !=
-			CUST_ACTION_GET_SENSOR_INFO) {
-			pr_info("scp_sensorHub_req_send failed action!\n");
-			return -1;
-		}
-		memcpy((struct sensorInfo_t *)data,
-			&req.set_cust_rsp.getInfo.sensorInfo,
-			sizeof(struct sensorInfo_t));
-		break;
-	default:
-		break;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(sensor_set_cmd_to_hub);
-
-static void restoring_enable_sensorHub_sensor(int handle)
-{
-	uint8_t sensor_type = handle + ID_OFFSET;
-	int ret = 0;
-	int i = 0, flush_cnt = 0;
-	struct ConfigCmd cmd;
-
-	if (mSensorState[sensor_type].sensorType &&
-		mSensorState[sensor_type].enable) {
-		init_sensor_config_cmd(&cmd, sensor_type);
-		pr_debug("restoring: handle=%d,enable=%d,rate=%d,latency=%lld\n",
-			handle, mSensorState[sensor_type].enable,
-			mSensorState[sensor_type].rate,
-			mSensorState[sensor_type].latency);
-		ret = nanohub_external_write((const uint8_t *)&cmd,
-			sizeof(struct ConfigCmd));
-		if (ret < 0)
-			pr_notice("failed registerlistener handle:%d, cmd:%d\n",
-				handle, cmd.cmd);
-
-		cmd.cmd = CONFIG_CMD_FLUSH;
-		mutex_lock(&flush_mtx);
-		flush_cnt = atomic_read(&mSensorState[sensor_type].flushCnt);
-		for (i = 0; i < flush_cnt; i++) {
-			ret = nanohub_external_write((const uint8_t *)&cmd,
-				sizeof(struct ConfigCmd));
-			if (ret < 0)
-				pr_notice("failed flush handle:%d\n", handle);
-		}
-		mutex_unlock(&flush_mtx);
-	}
-
-}
-
-void sensorHub_power_up_loop(void *data)
-{
-	int handle = 0;
-	struct SCP_sensorHub_data *obj = obj_data;
-	unsigned long flags = 0;
-
-	wait_event(power_reset_wait,
-		READ_ONCE(scp_system_ready) && READ_ONCE(scp_chre_ready));
-	spin_lock_irqsave(&scp_state_lock, flags);
-	WRITE_ONCE(scp_chre_ready, false);
-	WRITE_ONCE(scp_system_ready, false);
-	spin_unlock_irqrestore(&scp_state_lock, flags);
-
-	/* firstly we should update dram information */
-	/* 1. reset wp queue head and tail */
-	obj->wp_queue.head = 0;
-	obj->wp_queue.tail = 0;
-	/* 2. init dram information */
-	WRITE_ONCE(obj->SCP_sensorFIFO,
-		(struct sensorFIFO *)
-		(long)scp_get_reserve_mem_virt(SENS_MEM_ID));
-	BUG_ON(obj->SCP_sensorFIFO == NULL);
-	WRITE_ONCE(obj->SCP_sensorFIFO->wp, 0);
-	WRITE_ONCE(obj->SCP_sensorFIFO->rp, 0);
-	WRITE_ONCE(obj->SCP_sensorFIFO->FIFOSize,
-		((long)scp_get_reserve_mem_size(SENS_MEM_ID) -
-		offsetof(struct sensorFIFO, data)) /
-		SENSOR_DATA_SIZE * SENSOR_DATA_SIZE);
-	pr_debug("obj->SCP_sensorFIFO =%p, wp =%d, rp =%d, size =%d\n",
-		READ_ONCE(obj->SCP_sensorFIFO),
-		READ_ONCE(obj->SCP_sensorFIFO->wp),
-		READ_ONCE(obj->SCP_sensorFIFO->rp),
-		READ_ONCE(obj->SCP_sensorFIFO->FIFOSize));
-#ifndef CHRE_POWER_RESET_NOTIFY
-	/* 3. wait for chre init done when don't support power reset feature */
-	msleep(2000);
-#endif
-	/* 4. send dram information to scp */
-	sensor_send_dram_info_to_hub();
-	/* secondly we enable sensor which sensor is enable by framework */
-	mutex_lock(&mSensorState_mtx);
-	for (handle = 0; handle < ID_SENSOR_MAX_HANDLE_PLUS_ONE; handle++)
-		restoring_enable_sensorHub_sensor(handle);
-	mutex_unlock(&mSensorState_mtx);
-}
-
-static int sensorHub_power_up_work(void *data)
-{
-	for (;;)
-		sensorHub_power_up_loop(data);
-	return 0;
-}
-
-static int sensorHub_ready_event(struct notifier_block *this,
-	unsigned long event, void *ptr)
-{
-	unsigned long flags = 0;
-
-	if (event == SCP_EVENT_STOP) {
-		spin_lock_irqsave(&scp_state_lock, flags);
-		WRITE_ONCE(scp_system_ready, false);
-		spin_unlock_irqrestore(&scp_state_lock, flags);
-		atomic_set(&power_status, SENSOR_POWER_DOWN);
-		scp_power_monitor_notify(SENSOR_POWER_DOWN, ptr);
-	}
-
-	if (event == SCP_EVENT_READY) {
-		spin_lock_irqsave(&scp_state_lock, flags);
-		WRITE_ONCE(scp_system_ready, true);
-		if (READ_ONCE(scp_system_ready) && READ_ONCE(scp_chre_ready)) {
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-			atomic_set(&power_status, SENSOR_POWER_UP);
-			scp_power_monitor_notify(SENSOR_POWER_UP, ptr);
-			/* schedule_work(&obj->power_up_work); */
-			wake_up(&power_reset_wait);
-		} else
-			spin_unlock_irqrestore(&scp_state_lock, flags);
-	}
-
-	return NOTIFY_DONE;
-}
-
-static struct notifier_block sensorHub_ready_notifier = {
-	.notifier_call = sensorHub_ready_event,
-};
-static int sensorHub_probe(struct platform_device *pdev)
-{
-	struct SCP_sensorHub_data *obj;
-	int err = 0, index;
-	struct task_struct *task = NULL;
-	struct task_struct *task_power_reset = NULL;
-	struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
-
-	pr_debug("%s\n", __func__);
-	SCP_sensorHub_init_sensor_state();
-	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	if (!obj) {
-		pr_err("Allocate SCP_sensorHub_data fail\n");
-		err = -ENOMEM;
-		goto exit;
-	}
-	memset(obj, 0, sizeof(struct SCP_sensorHub_data));
-	obj_data = obj;
-
-	/* init sensor share dram write pointer event queue */
-	spin_lock_init(&obj->wp_queue.buffer_lock);
-	obj->wp_queue.head = 0;
-	obj->wp_queue.tail = 0;
-	obj->wp_queue.bufsize = 32;
-	obj->wp_queue.ringbuffer =
-		vzalloc(obj->wp_queue.bufsize * sizeof(uint32_t));
-	if (!obj->wp_queue.ringbuffer) {
-		pr_err("Alloc ringbuffer error!\n");
-		goto exit;
-	}
-	/* register ipi interrupt handler */
-	scp_ipi_registration(IPI_SENSOR,
-		SCP_sensorHub_IPI_handler, "SCP_sensorHub");
-	/* init receive scp dram data worker */
-	/* INIT_WORK(&obj->direct_push_work, SCP_sensorHub_direct_push_work); */
-	/* obj->direct_push_workqueue = alloc_workqueue("chre_work",
-	 * WQ_MEM_RECLAIM | WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1);
-	 */
-	/* obj->direct_push_workqueue =
-	 *		create_singlethread_workqueue("chre_work");
-	 *	if (obj->direct_push_workqueue == NULL) {
-	 *	pr_err("direct_push_workqueue fail\n");
-	 *	return -1;
-	 *}
-	 */
-
-	WRITE_ONCE(chre_kthread_wait_condition, false);
-	task = kthread_run(SCP_sensorHub_direct_push_work,
-		NULL, "chre_kthread");
-	if (IS_ERR(task)) {
-		pr_err("SCP_sensorHub_direct_push_work create fail!\n");
-		goto exit;
-	}
-	sched_setscheduler(task, SCHED_FIFO, &param);
-	/* init the debug trace flag */
-	for (index = 0; index < ID_SENSOR_MAX_HANDLE_PLUS_ONE; index++)
-		atomic_set(&obj->traces[index], 0);
-	/* init timestamp sync worker */
-	INIT_WORK(&obj->sync_time_worker, SCP_sensorHub_sync_time_work);
-	obj->sync_time_timer.expires =
-		jiffies + msecs_to_jiffies(SYNC_TIME_START_CYCLC);
-	obj->sync_time_timer.function = SCP_sensorHub_sync_time_func;
-	timer_setup(&obj->sync_time_timer, SCP_sensorHub_sync_time_func, 0);
-	mod_timer(&obj->sync_time_timer,
-		jiffies + msecs_to_jiffies(SYNC_TIME_START_CYCLC));
-	obj->ws = wakeup_source_register(NULL, "sync_time");
-	if (!obj->ws) {
-		pr_err("SCP_sensorHub: wakeup source init fail\n");
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	/* this call back can get scp power down status */
-	scp_A_register_notify(&sensorHub_ready_notifier);
-	/* this call back can get scp power UP status */
-	/* INIT_WORK(&obj->power_up_work, sensorHub_power_up_work); */
-	task_power_reset = kthread_run(sensorHub_power_up_work,
-		NULL, "scp_power_reset");
-	if (IS_ERR(task_power_reset)) {
-		pr_err("sensorHub_power_up_work create fail!\n");
-		goto exit;
-	}
-
-	SCP_sensorHub_init_flag = 0;
-	pr_debug("init done, data_unit_t size: %d,SCP_SENSOR_HUB_DATA size:%d\n",
-		(int)sizeof(struct data_unit_t),
-		(int)sizeof(union SCP_SENSOR_HUB_DATA));
-	BUG_ON(sizeof(struct data_unit_t) != SENSOR_DATA_SIZE
-		|| sizeof(union SCP_SENSOR_HUB_DATA) != SENSOR_IPI_SIZE);
-	return 0;
-exit:
-	pr_err("%s: err = %d\n", __func__, err);
-	SCP_sensorHub_init_flag = -1;
-	return err;
-}
-
-static int sensorHub_remove(struct platform_device *pdev)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-
-	if (obj)
-		wakeup_source_unregister(obj->ws);
-
-	return 0;
-}
-
-static int sensorHub_suspend(struct platform_device *pdev,
-	pm_message_t msg)
-{
-	/* sensor_send_timestamp_to_hub(); */
-	return 0;
-}
-
-static int sensorHub_resume(struct platform_device *pdev)
-{
-	/* sensor_send_timestamp_to_hub(); */
-	return 0;
-}
-
-static void sensorHub_shutdown(struct platform_device *pdev)
-{
-	int handle = 0;
-	uint8_t sensor_type;
-	struct ConfigCmd cmd;
-	int ret = 0;
-
-	mutex_lock(&mSensorState_mtx);
-	for (handle = 0; handle < ID_SENSOR_MAX_HANDLE_PLUS_ONE; handle++) {
-		sensor_type = handle + ID_OFFSET;
-		if (mSensorState[sensor_type].sensorType &&
-				mSensorState[sensor_type].enable) {
-			mSensorState[sensor_type].enable = false;
-			init_sensor_config_cmd(&cmd, sensor_type);
-
-			ret = nanohub_external_write((const uint8_t *)&cmd,
-				sizeof(struct ConfigCmd));
-			if (ret < 0)
-				pr_notice("failed registerlistener handle:%d, cmd:%d\n",
-					handle, cmd.cmd);
-		}
-	}
-	mutex_unlock(&mSensorState_mtx);
-}
-static ssize_t nanohub_trace_show(struct device_driver *ddri, char *buf)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	int i;
-	ssize_t res = 0;
-
-	for (i = 0; i < ID_SENSOR_MAX_HANDLE_PLUS_ONE; i++)
-		res += snprintf(&buf[res], PAGE_SIZE, "%2d:[%d]\n",
-			i, atomic_read(&obj->traces[i]));
-	return res;
-}
-
-static ssize_t nanohub_trace_store(struct device_driver *ddri,
-	const char *buf, size_t count)
-{
-	struct SCP_sensorHub_data *obj = obj_data;
-	int handle, trace = 0;
-	int res = 0;
-
-	pr_debug("%s buf:%s\n", __func__, buf);
-	if (sscanf(buf, "%d,%d", &handle, &trace) != 2) {
-		pr_err("invalid content: '%s', length = %zu\n", buf, count);
-		goto err_out;
-	}
-
-	if (handle < 0 || handle > ID_SENSOR_MAX_HANDLE) {
-		pr_debug("invalid handle value:%d,should be '0<=handle<=%d'\n",
-			trace, ID_SENSOR_MAX_HANDLE);
-		goto err_out;
-	}
-
-	if (trace != 0 && trace != 1) {
-		pr_debug("invalid trace value:%d,trace should be '0' or '1'",
-			trace);
-		goto err_out;
-	}
-
-	res = sensor_set_cmd_to_hub(handle, CUST_ACTION_SET_TRACE, &trace);
-	if (res < 0) {
-		pr_err("cmd_to_hub (ID: %d),(action: %d)err: %d\n", handle,
-					CUST_ACTION_SET_TRACE, res);
-	} else
-		atomic_set(&obj->traces[handle], trace);
-
-err_out:
-	return count;
-}
-
-static DRIVER_ATTR_RW(nanohub_trace);
-
-static struct driver_attribute *nanohub_attr_list[] = {
-	&driver_attr_nanohub_trace,	/*trace log */
-};
-
-static int nanohub_create_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(nanohub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, nanohub_attr_list[idx]);
-		if (err) {
-			pr_err("driver_create_file (%s) = %d\n",
-				nanohub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int nanohub_delete_attr(struct device_driver *driver)
-{
-	int idx = 0, err = 0;
-	int num = (int)(ARRAY_SIZE(nanohub_attr_list));
-
-	if (!driver)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, nanohub_attr_list[idx]);
-
-	return err;
-}
-
-static struct platform_device sensorHub_device = {
-	.name = "sensor_hub_pl",
-	.id = -1,
-};
-
-static struct platform_driver sensorHub_driver = {
-	.driver = {
-	   .name = "sensor_hub_pl",
-	},
-	.probe = sensorHub_probe,
-	.remove = sensorHub_remove,
-	.suspend = sensorHub_suspend,
-	.resume = sensorHub_resume,
-	.shutdown = sensorHub_shutdown,
-};
-
-#ifdef CONFIG_PM
-static int sensorHub_pm_event(struct notifier_block *notifier,
-	unsigned long pm_event,
-			void *unused)
-{
-	switch (pm_event) {
-	case PM_POST_SUSPEND:
-		pr_debug("resume ap boottime=%lld\n", ktime_get_boot_ns());
-		WRITE_ONCE(rtc_compensation_suspend, false);
-		sensor_send_timestamp_to_hub();
-		return NOTIFY_DONE;
-	case PM_SUSPEND_PREPARE:
-		pr_debug("suspend ap boottime=%lld\n", ktime_get_boot_ns());
-		WRITE_ONCE(rtc_compensation_suspend, true);
-		return NOTIFY_DONE;
-	default:
-		return NOTIFY_OK;
-	}
-	return NOTIFY_OK;
-}
-
-static struct notifier_block sensorHub_pm_notifier_func = {
-	.notifier_call = sensorHub_pm_event,
-	.priority = 0,
-};
-#endif /* CONFIG_PM */
-
-int __init SCP_sensorHub_init(void)
-{
-	nanohub_init();
-	SCP_sensorHub_ipi_master_init();
-	pr_debug("%s\n", __func__);
-	if (platform_device_register(&sensorHub_device)) {
-		pr_err("SCP_sensorHub platform device error\n");
-		return -1;
-	}
-	if (platform_driver_register(&sensorHub_driver)) {
-		pr_err("SCP_sensorHub platform driver error\n");
-		return -1;
-	}
-	if (nanohub_create_attr(&sensorHub_driver.driver)) {
-		pr_err("create attribute err\n");
-		nanohub_delete_attr(&sensorHub_driver.driver);
-	}
-#ifdef CONFIG_PM
-	if (register_pm_notifier(&sensorHub_pm_notifier_func)) {
-		pr_err("Failed to register PM notifier.\n");
-		return -1;
-	}
-#endif /* CONFIG_PM */
-	return 0;
-}
-
-void __exit SCP_sensorHub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-	nanohub_cleanup();
-}
-module_init(SCP_sensorHub_init);
-module_exit(SCP_sensorHub_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("SCP sensor hub driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_power_monitor/SCP_power_monitor.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_power_monitor/SCP_power_monitor.c
deleted file mode 100644
index 7a9f161..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/SCP_power_monitor/SCP_power_monitor.c
+++ /dev/null
@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#include <linux/module.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include "SCP_power_monitor.h"
-
-static LIST_HEAD(power_monitor_list);
-static DEFINE_SPINLOCK(pm_lock);
-static atomic_t power_status = ATOMIC_INIT(SENSOR_POWER_DOWN);
-void scp_power_monitor_notify(uint8_t action, void *data)
-{
-	struct scp_power_monitor *c;
-	unsigned long flags;
-
-	spin_lock_irqsave(&pm_lock, flags);
-	list_for_each_entry(c, &power_monitor_list, list) {
-		if (c->notifier_call == NULL) {
-			WARN_ON(true);
-			continue;
-		}
-		c->notifier_call(action, data);
-		pr_debug("%s, module name:%s notify\n", __func__, c->name);
-	}
-	switch (action) {
-	case SENSOR_POWER_DOWN:
-		atomic_set(&power_status, SENSOR_POWER_DOWN);
-		break;
-	case SENSOR_POWER_UP:
-		atomic_set(&power_status, SENSOR_POWER_UP);
-		break;
-	}
-	spin_unlock_irqrestore(&pm_lock, flags);
-}
-EXPORT_SYMBOL(scp_power_monitor_notify);
-
-int scp_power_monitor_register(struct scp_power_monitor *monitor)
-{
-	int err = 0;
-	struct scp_power_monitor *c;
-
-	if (monitor->name == NULL || monitor->notifier_call == NULL) {
-		WARN_ON(true);
-		return -1;
-	}
-
-	spin_lock_irq(&pm_lock);
-	list_for_each_entry(c, &power_monitor_list, list) {
-		if (!strcmp(c->name, monitor->name)) {
-			err = -1;
-			goto out;
-		}
-	}
-
-	list_add_tail(&monitor->list, &power_monitor_list);
-	if (atomic_read(&power_status) == SENSOR_POWER_UP) {
-		pr_debug("scp_power_monitor_notify, module name:%s notify\n",
-			monitor->name);
-		monitor->notifier_call(SENSOR_POWER_UP, NULL);
-	}
-	spin_unlock_irq(&pm_lock);
-	return err;
- out:
-	pr_err("%s %s register fail\n", __func__, monitor->name);
-	spin_unlock_irq(&pm_lock);
-	return err;
-}
-EXPORT_SYMBOL(scp_power_monitor_register);
-
-int scp_power_monitor_deregister(struct scp_power_monitor *monitor)
-{
-	if (WARN_ON(list_empty(&monitor->list)))
-		return -1;
-
-	spin_lock_irq(&pm_lock);
-	list_del(&monitor->list);
-	spin_unlock_irq(&pm_lock);
-	return 0;
-}
-EXPORT_SYMBOL(scp_power_monitor_deregister);
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/SCP_power_monitor.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/SCP_power_monitor.h
deleted file mode 100644
index 3d7314f..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/SCP_power_monitor.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _SCP_POWER_MONITOR_H_
-#define _SCP_POWER_MONITOR_H_
-#include <linux/major.h>
-#include <linux/types.h>
-
-enum SCP_SENSOR_POWER {
-	SENSOR_POWER_UP = 0,
-	SENSOR_POWER_DOWN,
-};
-struct scp_power_monitor  {
-	const char *name;
-	struct list_head list;
-	int (*notifier_call)(uint8_t action, void *data);
-};
-extern int scp_power_monitor_register(struct scp_power_monitor *monitor);
-extern int scp_power_monitor_deregister(struct scp_power_monitor *monitor);
-extern void scp_power_monitor_notify(uint8_t action, void *data);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/SCP_sensorHub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/SCP_sensorHub.h
deleted file mode 100644
index 880dccb..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/SCP_sensorHub.h
+++ /dev/null
@@ -1,553 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef SCP_SENSOR_HUB_H
-#define SCP_SENSOR_HUB_H
-
-#include <linux/ioctl.h>
-#include <linux/atomic.h>
-
-#if defined(CONFIG_MTK_SCP_SENSORHUB_V1)
-#error CONFIG_MTK_SCP_SENSORHUB_V1 should not configed
-#elif defined(CONFIG_NANOHUB)
-
-#define EVT_NO_SENSOR_CONFIG_EVENT       0x00000300
-#define SENSOR_RATE_ONCHANGE    0xFFFFFF01UL
-#define SENSOR_RATE_ONESHOT     0xFFFFFF02UL
-
-enum {
-	CONFIG_CMD_DISABLE      = 0,
-	CONFIG_CMD_ENABLE       = 1,
-	CONFIG_CMD_FLUSH        = 2,
-	CONFIG_CMD_CFG_DATA     = 3,
-	CONFIG_CMD_CALIBRATE    = 4,
-	CONFIG_CMD_SELF_TEST    = 5,
-};
-
-struct ConfigCmd {
-	uint32_t evtType;
-	uint64_t latency;
-	uint32_t rate;
-	uint8_t sensorType;
-	uint8_t cmd;
-	uint16_t flags;
-	uint8_t data[];
-} __packed;
-
-struct SensorState {
-	uint64_t latency;
-	uint32_t rate;
-	uint8_t sensorType;
-	uint8_t alt;
-	bool enable;
-	bool timestamp_filter;
-	atomic_t flushCnt;
-	atomic64_t enableTime;
-};
-
-#define SCP_SENSOR_HUB_TEMP_BUFSIZE     256
-
-//#define SCP_SENSOR_HUB_FIFO_SIZE        0x800000
-#define SCP_KFIFO_BUFFER_SIZE			(2048)
-#define SCP_DIRECT_PUSH_FIFO_SIZE       8192
-
-#define SCP_SENSOR_HUB_SUCCESS          0
-#define SCP_SENSOR_HUB_FAILURE          (-1)
-
-#define SCP_SENSOR_HUB_X				0
-#define SCP_SENSOR_HUB_Y				1
-#define SCP_SENSOR_HUB_Z				2
-#define SCP_SENSOR_HUB_AXES_NUM			3
-
-/* SCP_ACTION */
-#define    SENSOR_HUB_ACTIVATE		0
-#define    SENSOR_HUB_SET_DELAY		1
-#define    SENSOR_HUB_GET_DATA		2
-#define    SENSOR_HUB_BATCH			3
-#define    SENSOR_HUB_SET_CONFIG	4
-#define    SENSOR_HUB_SET_CUST		5
-#define    SENSOR_HUB_NOTIFY		6
-#define    SENSOR_HUB_BATCH_TIMEOUT 7
-#define    SENSOR_HUB_SET_TIMESTAMP	8
-#define    SENSOR_HUB_POWER_NOTIFY	9
-
-/* SCP_NOTIFY EVENT */
-#define    SCP_INIT_DONE			0
-#define    SCP_FIFO_FULL			1
-#define    SCP_NOTIFY				2
-#define    SCP_BATCH_TIMEOUT		3
-#define	   SCP_DIRECT_PUSH          4
-
-struct sensor_vec_t {
-	union {
-		struct {
-			int32_t x;
-			int32_t y;
-			int32_t z;
-			int32_t x_bias;
-			int32_t y_bias;
-			int32_t z_bias;
-			int32_t reserved : 14;
-			int32_t temp_result : 2;
-			int32_t temperature : 16;
-		};
-		struct {
-			int32_t azimuth;
-			int32_t pitch;
-			int32_t roll;
-			int32_t scalar;
-		};
-	};
-	uint32_t status;
-};
-
-struct heart_rate_event_t {
-	int32_t bpm;
-	int32_t status;
-};
-
-struct significant_motion_event_t {
-	int32_t state;
-};
-
-struct step_counter_event_t {
-	uint32_t accumulated_step_count;
-};
-
-struct step_detector_event_t {
-	uint32_t step_detect;
-};
-
-struct floor_counter_event_t {
-	uint32_t accumulated_floor_count;
-};
-
-enum gesture_type_t {
-	GESTURE_NONE,
-	SHAKE,
-	TAP,
-	TWIST,
-	FLIP,
-	SNAPSHOT,
-	PICKUP,
-	CHECK
-};
-
-struct gesture_t {
-	int32_t probability;
-};
-
-struct pedometer_event_t {
-	uint32_t accumulated_step_count;
-	uint32_t accumulated_step_length;
-	uint32_t step_frequency;
-	uint32_t step_length;
-};
-
-struct pressure_vec_t {
-	int32_t pressure;	/* Pa, i.e. hPa * 100 */
-	int32_t temperature;
-	uint32_t status;
-};
-
-struct proximity_vec_t {
-	uint32_t steps;
-	int32_t oneshot;
-};
-
-struct relative_humidity_vec_t {
-	int32_t relative_humidity;
-	int32_t temperature;
-	uint32_t status;
-};
-
-struct sleepmonitor_event_t {
-	int32_t state;		/* sleep, restless, awake */
-};
-
-enum fall_type {
-	FALL_NONE,
-	FALL,
-	FLOP,
-	FALL_MAX
-};
-
-struct fall_t {
-	uint8_t probability[FALL_MAX];	/* 0~100 */
-};
-
-struct tilt_event_t {
-	int32_t state;		/* 0,1 */
-};
-
-struct in_pocket_event_t {
-	int32_t state;		/* 0,1 */
-};
-
-struct geofence_event_t {
-	uint32_t state;  /* geofence [source, result, operation_mode] */
-};
-
-struct sar_event_t {
-	struct {
-		int32_t data[3];
-		int32_t x_bias;
-		int32_t y_bias;
-		int32_t z_bias;
-	};
-	uint32_t status;
-};
-
-enum activity_type_t {
-	STILL,
-	STANDING,
-	SITTING,
-	LYING,
-	ON_FOOT,
-	WALKING,
-	RUNNING,
-	CLIMBING,
-	ON_BICYCLE,
-	IN_VEHICLE,
-	TILTING,
-	UNKNOWN,
-	ACTIVITY_MAX
-};
-
-struct activity_t {
-	uint8_t probability[ACTIVITY_MAX];	/* 0~100 */
-};
-
-struct data_unit_t {
-	uint8_t sensor_type;
-	uint8_t flush_action;
-	uint8_t reserve[2];
-	uint64_t time_stamp;
-	union {
-		struct sensor_vec_t accelerometer_t;
-		struct sensor_vec_t gyroscope_t;
-		struct sensor_vec_t magnetic_t;
-		struct sensor_vec_t orientation_t;
-		struct sensor_vec_t pdr_event;
-
-		int32_t light;
-		struct proximity_vec_t proximity_t;
-		int32_t temperature;
-		struct pressure_vec_t pressure_t;
-		struct relative_humidity_vec_t relative_humidity_t;
-
-		struct sensor_vec_t uncalibrated_acc_t;
-		struct sensor_vec_t uncalibrated_mag_t;
-		struct sensor_vec_t uncalibrated_gyro_t;
-
-		struct pedometer_event_t pedometer_t;
-
-		struct heart_rate_event_t heart_rate_t;
-		struct significant_motion_event_t smd_t;
-		struct step_detector_event_t step_detector_t;
-		struct step_counter_event_t step_counter_t;
-		struct floor_counter_event_t floor_counter_t;
-		struct activity_t activity_data_t;
-		struct gesture_t gesture_data_t;
-		struct fall_t fall_data_t;
-		struct tilt_event_t tilt_event;
-		struct in_pocket_event_t inpocket_event;
-		struct geofence_event_t geofence_data_t;
-		struct sar_event_t sar_event;
-		int32_t data[8];
-	};
-} __packed;
-
-struct sensorFIFO {
-	uint32_t rp;	/* use int for store DRAM FIFO LSB 32bit read pointer */
-	uint32_t wp;
-	uint32_t FIFOSize;
-	uint32_t reserve;
-	struct data_unit_t data[0];
-};
-
-struct SCP_SENSOR_HUB_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	uint32_t data[11];
-};
-
-struct SCP_SENSOR_HUB_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	int8_t errCode;
-	uint8_t reserve[1];
-	/* uint32_t    reserved[9]; */
-};
-
-struct SCP_SENSOR_HUB_ACTIVATE_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	uint32_t enable;	/* 0 : disable ; 1 : enable */
-	/* uint32_t    reserved[9]; */
-};
-
-#define SCP_SENSOR_HUB_ACTIVATE_RSP SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_ACTIVATE_RSP; */
-
-struct SCP_SENSOR_HUB_SET_DELAY_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	uint32_t delay;		/* ms */
-	/* uint32_t    reserved[9]; */
-};
-
-#define SCP_SENSOR_HUB_SET_DELAY_RSP  SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_SET_DELAY_RSP; */
-
-struct SCP_SENSOR_HUB_GET_DATA_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	/* uint32_t    reserved[10]; */
-};
-
-struct SCP_SENSOR_HUB_GET_DATA_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	int8_t errCode;
-	uint8_t reserve[1];
-	/* struct data_unit_t data_t; */
-	union {
-		int8_t int8_Data[0];
-		int16_t int16_Data[0];
-		int32_t int32_Data[0];
-	} data;
-};
-
-struct SCP_SENSOR_HUB_BATCH_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t flag;
-	uint8_t reserve[1];
-	uint32_t period_ms;	/* batch reporting time in ms */
-	uint32_t timeout_ms;	/* sampling time in ms */
-	/* uint32_t    reserved[7]; */
-};
-
-#define SCP_SENSOR_HUB_BATCH_RSP SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_BATCH_RSP; */
-
-struct SCP_SENSOR_HUB_SET_CONFIG_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	/* struct sensorFIFO   *bufferBase; */
-	uint32_t bufferBase;/* use int to store buffer DRAM base LSB 32 bits */
-	uint32_t bufferSize;
-	uint64_t ap_timestamp;
-	uint64_t arch_counter;
-	/* uint32_t    reserved[8]; */
-};
-
-#define SCP_SENSOR_HUB_SET_CONFIG_RSP  SCP_SENSOR_HUB_RSP
-/* typedef SCP_SENSOR_HUB_RSP SCP_SENSOR_HUB_SET_CONFIG_RSP; */
-
-enum CUST_ACTION {
-	CUST_ACTION_SET_CUST = 1,
-	CUST_ACTION_SET_CALI,
-	CUST_ACTION_RESET_CALI,
-	CUST_ACTION_SET_TRACE,
-	CUST_ACTION_SET_DIRECTION,
-	CUST_ACTION_SHOW_REG,
-	CUST_ACTION_GET_RAW_DATA,
-	CUST_ACTION_SET_PS_THRESHOLD,
-	CUST_ACTION_SHOW_ALSLV,
-	CUST_ACTION_SHOW_ALSVAL,
-	CUST_ACTION_SET_FACTORY,
-	CUST_ACTION_GET_SENSOR_INFO,
-};
-
-struct SCP_SENSOR_HUB_CUST {
-	enum CUST_ACTION action;
-};
-
-struct SCP_SENSOR_HUB_SET_CUST {
-	enum CUST_ACTION action;
-	int32_t data[0];
-};
-
-struct SCP_SENSOR_HUB_SET_TRACE {
-	enum CUST_ACTION action;
-	int trace;
-};
-
-struct SCP_SENSOR_HUB_SET_DIRECTION {
-	enum CUST_ACTION action;
-	int direction;
-};
-
-struct SCP_SENSOR_HUB_SET_FACTORY {
-	enum CUST_ACTION	action;
-	unsigned int	factory;
-};
-
-struct SCP_SENSOR_HUB_SET_CALI {
-	enum CUST_ACTION action;
-	union {
-		int8_t int8_data[0];
-		uint8_t uint8_data[0];
-		int16_t int16_data[0];
-		uint16_t uint16_data[0];
-		int32_t int32_data[0];
-		uint32_t uint32_data[SCP_SENSOR_HUB_AXES_NUM];
-	};
-};
-
-#define SCP_SENSOR_HUB_RESET_CALI   SCP_SENSOR_HUB_CUST
-/* typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_RESET_CALI; */
-
-struct SCP_SENSOR_HUB_SETPS_THRESHOLD {
-	enum CUST_ACTION action;
-	int32_t threshold[2];
-};
-
-#define SCP_SENSOR_HUB_SHOW_REG    SCP_SENSOR_HUB_CUST
-#define SCP_SENSOR_HUB_SHOW_ALSLV  SCP_SENSOR_HUB_CUST
-#define SCP_SENSOR_HUB_SHOW_ALSVAL SCP_SENSOR_HUB_CUST
-/*
- * typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_SHOW_REG;
- * typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_SHOW_ALSLV;
- * typedef SCP_SENSOR_HUB_CUST SCP_SENSOR_HUB_SHOW_ALSVAL;
- */
-
-struct SCP_SENSOR_HUB_GET_RAW_DATA {
-	enum CUST_ACTION action;
-	union {
-		int8_t int8_data[0];
-		uint8_t uint8_data[0];
-		int16_t int16_data[0];
-		uint16_t uint16_data[0];
-		int32_t int32_data[0];
-		uint32_t uint32_data[SCP_SENSOR_HUB_AXES_NUM];
-	};
-};
-
-struct mag_dev_info_t {
-	char libname[16];
-	int8_t layout;
-	int8_t deviceid;
-};
-
-struct sensorInfo_t {
-	char name[16];
-	struct mag_dev_info_t mag_dev_info;
-};
-
-struct scp_sensor_hub_get_sensor_info {
-	enum CUST_ACTION action;
-	union {
-		int32_t int32_data[0];
-		struct sensorInfo_t sensorInfo;
-	};
-};
-
-enum {
-	USE_OUT_FACTORY_MODE = 0,
-	USE_IN_FACTORY_MODE
-};
-
-struct SCP_SENSOR_HUB_SET_CUST_REQ {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t reserve[2];
-	union {
-		uint32_t custData[11];
-		struct SCP_SENSOR_HUB_CUST cust;
-		struct SCP_SENSOR_HUB_SET_CUST setCust;
-		struct SCP_SENSOR_HUB_SET_CALI setCali;
-		struct SCP_SENSOR_HUB_RESET_CALI resetCali;
-		struct SCP_SENSOR_HUB_SET_TRACE setTrace;
-		struct SCP_SENSOR_HUB_SET_DIRECTION setDirection;
-		struct SCP_SENSOR_HUB_SHOW_REG showReg;
-		struct SCP_SENSOR_HUB_GET_RAW_DATA getRawData;
-		struct SCP_SENSOR_HUB_SETPS_THRESHOLD setPSThreshold;
-		struct SCP_SENSOR_HUB_SHOW_ALSLV showAlslv;
-		struct SCP_SENSOR_HUB_SHOW_ALSVAL showAlsval;
-		struct SCP_SENSOR_HUB_SET_FACTORY setFactory;
-		struct scp_sensor_hub_get_sensor_info getInfo;
-	};
-};
-
-struct SCP_SENSOR_HUB_SET_CUST_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t errCode;
-	uint8_t reserve[1];
-	union {
-		uint32_t custData[11];
-		struct SCP_SENSOR_HUB_GET_RAW_DATA getRawData;
-		struct scp_sensor_hub_get_sensor_info getInfo;
-	};
-};
-
-struct SCP_SENSOR_HUB_NOTIFY_RSP {
-	uint8_t sensorType;
-	uint8_t action;
-	uint8_t event;
-	uint8_t reserve[1];
-	union {
-		int8_t		int8_Data[0];
-		int16_t		int16_Data[0];
-		int32_t		int32_Data[0];
-		struct {
-			uint32_t	currWp;
-			uint64_t	scp_timestamp;
-			uint64_t	arch_counter;
-		};
-	};
-};
-
-union SCP_SENSOR_HUB_DATA {
-	struct SCP_SENSOR_HUB_REQ req;
-	struct SCP_SENSOR_HUB_RSP rsp;
-	struct SCP_SENSOR_HUB_ACTIVATE_REQ activate_req;
-	struct SCP_SENSOR_HUB_ACTIVATE_RSP activate_rsp;
-	struct SCP_SENSOR_HUB_SET_DELAY_REQ set_delay_req;
-	struct SCP_SENSOR_HUB_SET_DELAY_RSP set_delay_rsp;
-	struct SCP_SENSOR_HUB_GET_DATA_REQ get_data_req;
-	struct SCP_SENSOR_HUB_GET_DATA_RSP get_data_rsp;
-	struct SCP_SENSOR_HUB_BATCH_REQ batch_req;
-	struct SCP_SENSOR_HUB_BATCH_RSP batch_rsp;
-	struct SCP_SENSOR_HUB_SET_CONFIG_REQ set_config_req;
-	struct SCP_SENSOR_HUB_SET_CONFIG_RSP set_config_rsp;
-	struct SCP_SENSOR_HUB_SET_CUST_REQ set_cust_req;
-	struct SCP_SENSOR_HUB_SET_CUST_RSP set_cust_rsp;
-	struct SCP_SENSOR_HUB_NOTIFY_RSP notify_rsp;
-};
-
-typedef int (*SCP_sensorHub_handler)(struct data_unit_t *event,
-	void *reserved);
-
-int scp_sensorHub_req_send(union SCP_SENSOR_HUB_DATA *data,
-	uint *len, unsigned int wait);
-int scp_sensorHub_data_registration(uint8_t sensor,
-	SCP_sensorHub_handler handler);
-int sensor_enable_to_hub(uint8_t sensorType, int enabledisable);
-int sensor_set_delay_to_hub(uint8_t sensorType, unsigned int delayms);
-int sensor_get_data_from_hub(uint8_t sensorType,
-	struct data_unit_t *data);
-int sensor_set_cmd_to_hub(uint8_t sensorType,
-	enum CUST_ACTION action, void *data);
-int sensor_batch_to_hub(uint8_t sensorType,
-	int flag, int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs);
-int sensor_flush_to_hub(uint8_t sensorType);
-int sensor_cfg_to_hub(uint8_t sensorType, uint8_t *data, uint8_t count);
-int sensor_calibration_to_hub(uint8_t sensorType);
-int sensor_selftest_to_hub(uint8_t sensorType);
-
-extern int __init nanohub_init(void);
-extern void __exit nanohub_cleanup(void);
-
-#endif
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/cust_sensorHub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/cust_sensorHub.h
deleted file mode 100644
index 8b67ba6..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1/cust_sensorHub.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __CUST_ACC_H__
-#define __CUST_ACC_H__
-
-#define G_CUST_I2C_ADDR_NUM 2
-
-struct sensorHub_hw {
-	int is_batch_enabled;
-};
-
-extern struct sensorHub_hw *get_cust_sensorHub_hw(void);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/Kconfig
deleted file mode 100644
index 744ae3a..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/Kconfig
+++ /dev/null
@@ -1,21 +0,0 @@
-config NANOHUB
-	tristate "Nanohub"
-	default N
-	help
-	  Enable support for the nanohub sensorhub driver.
-	  This driver supports the android nanohub sensorhub.
-	  Set Y to enable this feature.
-	  If in doubt, say N here.
-
-if NANOHUB
-
-config NANOHUB_MTK_IPI
-	bool "Nanohub MTK IPI"
-	default Y
-	help
-	  Enable nanohub MTK IPI support.
-	  Either this or NANOHUB_SPI/NANOHUB_I2C should be selected.
-	  MTK platform only protocol.
-	  If in doubt, say N here.
-
-endif # NANOHUB
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/bl.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/bl.c
deleted file mode 100644
index e59e9c2..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/bl.c
+++ /dev/null
@@ -1,361 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#include <linux/vmalloc.h>
-
-#include "nanohub.h"
-#include "main.h"
-#include "bl.h"
-
-#define MAX_BUFFER_SIZE		1024
-#define MAX_FLASH_BANKS		16
-#define READ_ACK_TIMEOUT	100000
-
-static u8 write_len(struct nanohub_data *data, int len)
-{
-	u8 buffer[sizeof(u8) + 1];
-
-	buffer[0] = len - 1;
-
-	return data->bl.write_data(data, buffer, sizeof(u8));
-}
-
-static u8 write_cnt(struct nanohub_data *data, uint16_t cnt)
-{
-	u8 buffer[sizeof(uint16_t) + 1];
-
-	buffer[0] = (cnt >> 8) & 0xFF;
-	buffer[1] = (cnt >> 0) & 0xFF;
-
-	return data->bl.write_data(data, buffer, sizeof(uint16_t));
-}
-
-static u8 write_addr(struct nanohub_data *data, u32 addr)
-{
-	u8 buffer[sizeof(u32) + 1];
-
-	buffer[0] = (addr >> 24) & 0xFF;
-	buffer[1] = (addr >> 16) & 0xFF;
-	buffer[2] = (addr >> 8) & 0xFF;
-	buffer[3] = addr & 0xFF;
-
-	return data->bl.write_data(data, buffer, sizeof(u32));
-}
-
-/* write length followed by the data */
-static u8 write_len_data(struct nanohub_data *data, int len,
-			 const u8 *buf)
-{
-	u8 buffer[sizeof(u8) + 256 + sizeof(u8)];
-
-	buffer[0] = len - 1;
-
-	memcpy(&buffer[1], buf, len);
-
-	return data->bl.write_data(data, buffer, sizeof(u8) + len);
-}
-
-/* keep checking for ack until we receive a ack or nack */
-static u8 read_ack_loop(struct nanohub_data *data)
-{
-	u8 ret;
-	s32 timeout = READ_ACK_TIMEOUT;
-
-	do {
-		ret = data->bl.read_ack(data);
-		if (ret != CMD_ACK && ret != CMD_NACK)
-			schedule();
-	} while (ret != CMD_ACK && ret != CMD_NACK && timeout-- > 0);
-
-	return ret;
-}
-
-u8 nanohub_bl_sync(struct nanohub_data *data)
-{
-	return data->bl.sync(data);
-}
-
-int nanohub_bl_open(struct nanohub_data *data)
-{
-	int ret = -1;
-
-	data->bl.tx_buffer = kmalloc(MAX_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
-	if (!data->bl.tx_buffer)
-		goto out;
-
-	data->bl.rx_buffer = kmalloc(MAX_BUFFER_SIZE, GFP_KERNEL | GFP_DMA);
-	if (!data->bl.rx_buffer)
-		goto free_tx;
-
-	ret = data->bl.open(data);
-	if (!ret)
-		goto out;
-
-	kfree(data->bl.rx_buffer);
-free_tx:
-	kfree(data->bl.tx_buffer);
-out:
-	return ret;
-}
-
-void nanohub_bl_close(struct nanohub_data *data)
-{
-	data->bl.close(data);
-	kfree(data->bl.tx_buffer);
-	kfree(data->bl.rx_buffer);
-}
-
-static u8 write_bank(struct nanohub_data *data, int bank, u32 addr,
-		     const u8 *buf, size_t length)
-{
-	const struct nanohub_platform_data *pdata = data->pdata;
-	u8 status = CMD_ACK;
-	u32 offset;
-
-	if (addr <= pdata->flash_banks[bank].address) {
-		offset = pdata->flash_banks[bank].address - addr;
-		if (addr + length >
-		    pdata->flash_banks[bank].address +
-		    pdata->flash_banks[bank].length)
-			status = nanohub_bl_write_memory
-				(data, pdata->flash_banks[bank].address,
-				 pdata->flash_banks[bank].length, buf + offset);
-		else
-			status = nanohub_bl_write_memory
-				(data, pdata->flash_banks[bank].address,
-				 length - offset, buf + offset);
-	} else {
-		if (addr + length >
-		    pdata->flash_banks[bank].address +
-		    pdata->flash_banks[bank].length)
-			status = nanohub_bl_write_memory
-				(data, addr, pdata->flash_banks[bank].address +
-				 pdata->flash_banks[bank].length - addr, buf);
-		else
-			status = nanohub_bl_write_memory(data, addr, length,
-							 buf);
-	}
-
-	return status;
-}
-
-u8 nanohub_bl_download(struct nanohub_data *data, u32 addr,
-		       const u8 *image, size_t length)
-{
-	const struct nanohub_platform_data *pdata = data->pdata;
-	u8 *ptr;
-	int i, j;
-	u8 status;
-	u32 offset;
-	u8 erase_mask[MAX_FLASH_BANKS] = { 0 };
-	u8 erase_write_mask[MAX_FLASH_BANKS] = { 0 };
-	u8 write_mask[MAX_FLASH_BANKS] = { 0 };
-
-	if (pdata->num_flash_banks > MAX_FLASH_BANKS) {
-		status = CMD_NACK;
-		goto out;
-	}
-
-	status = nanohub_bl_sync(data);
-
-	if (status != CMD_ACK) {
-		pr_err("%s: sync=%02x\n", __func__, status);
-		goto out;
-	}
-
-	ptr = vmalloc(length);
-	if (!ptr) {
-		status = CMD_NACK;
-		goto out;
-	}
-
-	status = nanohub_bl_read_memory(data, addr, length, ptr);
-	pr_info(
-	    "nanohub: nanohub_bl_read_memory: status=%02x, addr=%08x, length=%zd\n",
-	    status, addr, length);
-
-	for (i = 0; i < pdata->num_flash_banks; i++) {
-		if (addr >= pdata->flash_banks[i].address &&
-		    addr <
-		    pdata->flash_banks[i].address +
-		    pdata->flash_banks[i].length) {
-			break;
-		}
-	}
-
-	offset = (u32)(addr - pdata->flash_banks[i].address);
-	j = 0;
-	while (j < length && i < pdata->num_flash_banks) {
-		if (image[j] != 0xFF)
-			erase_write_mask[i] = true;
-
-		if ((ptr[j] & image[j]) != image[j]) {
-			erase_mask[i] = true;
-			if (erase_write_mask[i]) {
-				j += pdata->flash_banks[i].length - offset;
-				offset = pdata->flash_banks[i].length;
-			} else {
-				j++;
-				offset++;
-			}
-		} else {
-			if (ptr[j] != image[j])
-				write_mask[i] = true;
-			j++;
-			offset++;
-		}
-
-		if (offset == pdata->flash_banks[i].length) {
-			i++;
-			offset = 0;
-			if (i < pdata->num_flash_banks)
-				j += (pdata->flash_banks[i].address -
-				      pdata->flash_banks[i - 1].address -
-				      pdata->flash_banks[i - 1].length);
-			else
-				j = length;
-		}
-	}
-
-	for (i = 0; status == CMD_ACK && i < pdata->num_flash_banks; i++) {
-		pr_info("nanohub: i=%d, erase=%d, erase_write=%d, write=%d\n",
-			i, erase_mask[i], erase_write_mask[i], write_mask[i]);
-		if (erase_mask[i]) {
-			status =
-			    nanohub_bl_erase_sector(data,
-						    pdata->flash_banks[i].bank);
-			if (status == CMD_ACK && erase_write_mask[i])
-				status =
-				    write_bank(data, i, addr, image, length);
-		} else if (write_mask[i]) {
-			status = write_bank(data, i, addr, image, length);
-		}
-	}
-
-	vfree(ptr);
-out:
-	return status;
-}
-
-u8 nanohub_bl_erase_shared(struct nanohub_data *data)
-{
-	const struct nanohub_platform_data *pdata = data->pdata;
-	int i;
-	u8 status;
-
-	if (pdata->num_shared_flash_banks > MAX_FLASH_BANKS) {
-		status = CMD_NACK;
-		goto out;
-	}
-
-	status = nanohub_bl_sync(data);
-
-	if (status != CMD_ACK) {
-		pr_err("%s: sync=%02x\n", __func__, status);
-		goto out;
-	}
-
-	for (i = 0;
-	     status == CMD_ACK && i < pdata->num_shared_flash_banks;
-	     i++) {
-		status = nanohub_bl_erase_sector
-				(data, pdata->shared_flash_banks[i].bank);
-	}
-out:
-	return status;
-}
-
-/* erase a single sector */
-u8 nanohub_bl_erase_sector(struct nanohub_data *data, uint16_t sector)
-{
-	u8 ret;
-
-	data->bl.write_cmd(data, data->bl.cmd_erase);
-	ret = data->bl.read_ack(data);
-	if (ret == CMD_ACK)
-		ret = write_cnt(data, 0x0000);
-	if (ret != CMD_NACK)
-		ret = read_ack_loop(data);
-	if (ret == CMD_ACK)
-		ret = write_cnt(data, sector);
-	if (ret != CMD_NACK)
-		ret = read_ack_loop(data);
-
-	return ret;
-}
-
-/* read memory - this will chop the request into 256 byte reads */
-u8 nanohub_bl_read_memory(struct nanohub_data *data, u32 addr,
-			  u32 length, u8 *buffer)
-{
-	u8 ret = CMD_ACK;
-	u32 offset = 0;
-
-	while (ret == CMD_ACK && length > offset) {
-		data->bl.write_cmd(data, data->bl.cmd_read_memory);
-		ret = data->bl.read_ack(data);
-		if (ret == CMD_ACK) {
-			write_addr(data, addr + offset);
-			ret = read_ack_loop(data);
-			if (ret == CMD_ACK) {
-				if (length - offset >= 256) {
-					write_len(data, 256);
-					ret = read_ack_loop(data);
-					if (ret == CMD_ACK) {
-						data->bl.read_data(data,
-								   &buffer
-								   [offset],
-								   256);
-						offset += 256;
-					}
-				} else {
-					write_len(data, length - offset);
-					ret = read_ack_loop(data);
-					if (ret == CMD_ACK) {
-						data->bl.read_data(data,
-								   &buffer
-								   [offset],
-								   length -
-								   offset);
-						offset = length;
-					}
-				}
-			}
-		}
-	}
-
-	return ret;
-}
-
-/* write memory - this will chop the request into 256 byte writes */
-u8 nanohub_bl_write_memory(struct nanohub_data *data, u32 addr,
-			   u32 length, const u8 *buffer)
-{
-	u8 ret = CMD_ACK;
-	u32 offset = 0;
-
-	while (ret == CMD_ACK && length > offset) {
-		data->bl.write_cmd(data, data->bl.cmd_write_memory);
-		ret = data->bl.read_ack(data);
-		if (ret == CMD_ACK) {
-			write_addr(data, addr + offset);
-			ret = read_ack_loop(data);
-			if (ret == CMD_ACK) {
-				if (length - offset >= 256) {
-					write_len_data(data, 256,
-						       &buffer[offset]);
-					offset += 256;
-				} else {
-					write_len_data(data, length - offset,
-						       &buffer[offset]);
-					offset = length;
-				}
-				ret = read_ack_loop(data);
-			}
-		}
-	}
-
-	return ret;
-}
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/bl.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/bl.h
deleted file mode 100644
index 79eed99..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/bl.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _NANOHUB_BL_H
-#define _NANOHUB_BL_H
-
-#include <linux/i2c.h>
-#include <linux/spi/spi.h>
-#include "nanohub.h"
-
-struct nanohub_data;
-
-struct nanohub_bl {
-	u8 cmd_erase;
-	u8 cmd_read_memory;
-	u8 cmd_write_memory;
-
-	int (*open)(const void *data);
-	void (*close)(const void *data);
-	u8 (*sync)(const void *data);
-	u8 (*write_data)(const void *data, u8 *buf, int size);
-	u8 (*write_cmd)(const void *data, u8 cmd_memory);
-	u8 (*read_data)(const void *data, u8 *buf, int size);
-	u8 (*read_ack)(const void *data);
-
-	u8 *tx_buffer;
-	u8 *rx_buffer;
-};
-
-int nanohub_bl_open(struct nanohub_data *data);
-u8 nanohub_bl_sync(struct nanohub_data *data);
-void nanohub_bl_close(struct nanohub_data *data);
-u8 nanohub_bl_download(struct nanohub_data *data,
-		       u32 addr, const u8 *image, size_t length);
-u8 nanohub_bl_erase_shared(struct nanohub_data *data);
-u8 nanohub_bl_erase_sector(struct nanohub_data *data, uint16_t sector);
-u8 nanohub_bl_read_memory(struct nanohub_data *data, u32 addr,
-			  u32 length, u8 *buffer);
-u8 nanohub_bl_write_memory(struct nanohub_data *data, u32 addr,
-			   u32 length, const u8 *buffer);
-
-/*
- * Bootloader commands
- * _NS versions are no-stretch. (Only valid on I2C)
- * will return CMD_BUSY instead of stretching the clock
- */
-
-#define CMD_GET				0x00
-#define CMD_GET_VERSION			0x01
-#define CMD_GET_ID			0x02
-#define CMD_READ_MEMORY			0x11
-#define CMD_NACK			0x1F
-#define CMD_GO				0x21
-#define CMD_WRITE_MEMORY		0x31
-#define CMD_WRITE_MEMORY_NS		0x32
-#define CMD_ERASE			0x44
-#define CMD_ERASE_NS			0x45
-#define CMD_SOF				0x5A
-#define CMD_WRITE_PROTECT		0x63
-#define CMD_WRITE_PROTECT_NS		0x64
-#define CMD_WRITE_UNPROTECT		0x73
-#define CMD_WRITE_UNPROTECT_NS		0x74
-#define CMD_BUSY			0x76
-#define CMD_ACK				0x79
-#define CMD_READOUT_PROTECT		0x82
-#define CMD_READOUT_PROTECT_NS		0x83
-#define CMD_READOUT_UNPROTECT		0x92
-#define CMD_READOUT_UNPROTECT_NS	0x93
-#define CMD_SOF_ACK			0xA5
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/comms.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/comms.c
deleted file mode 100644
index 26d635c..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/comms.c
+++ /dev/null
@@ -1,525 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/semaphore.h>
-#include <linux/gpio.h>
-
-#include "main.h"
-#include "comms.h"
-
-#define READ_ACK_TIMEOUT_MS	10
-#define READ_MSG_TIMEOUT_MS	70
-
-static const u32 crc_table[] = {
-	0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9,
-	0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005,
-	0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61,
-	0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD
-};
-
-static u32 crc32_word(u32 crc, u32 data, int cnt)
-{
-	int i;
-
-	crc = crc ^ data;
-	for (i = 0; i < cnt; i++)
-		crc = (crc << 4) ^ crc_table[crc >> 28];
-
-	return crc;
-}
-
-u32 crc32(const u8 *buffer, int length, u32 crc)
-{
-	u32 *data = (u32 *)buffer;
-	u32 word;
-	int i;
-
-	/* word by word crc32 */
-	for (i = 0; i < (length >> 2); i++)
-		crc = crc32_word(crc, data[i], 8);
-
-	/* zero pad last word if required */
-	if (length & 0x3) {
-		for (i *= 4, word = 0; i < length; i++)
-			word |= buffer[i] << ((i & 0x3) * 8);
-		crc = crc32_word(crc, word, 8);
-	}
-
-	return crc;
-}
-
-static inline size_t pad(size_t length)
-{
-	return (length + 3) & ~3;
-}
-
-static inline size_t tot_len(size_t length)
-{
-	/* [TYPE:1] [LENGTH:3] [DATA] [PAD:0-3] [CRC:4] */
-	return sizeof(u32) + pad(length) + sizeof(u32);
-}
-
-static struct nanohub_packet_pad *packet_alloc(int flags)
-{
-	int len =
-	    sizeof(struct nanohub_packet_pad) + MAX_UINT8 +
-	    sizeof(struct nanohub_packet_crc);
-	u8 *packet = kmalloc(len, flags);
-
-	if (packet)
-		memset(packet, 0xFF, len);
-	return (struct nanohub_packet_pad *)packet;
-}
-
-static int packet_create(struct nanohub_packet *packet, u32 seq,
-			 u32 reason, u8 len, const u8 *data,
-			 bool user)
-{
-	struct nanohub_packet_crc crc;
-	int ret = sizeof(struct nanohub_packet) + len +
-	    sizeof(struct nanohub_packet_crc);
-
-	if (packet) {
-		packet->sync = COMMS_SYNC;
-		packet->seq = seq;
-		packet->reason = reason;
-		packet->len = len;
-		if (len > 0) {
-			if (user) {
-				if (copy_from_user(packet->data, data, len) !=
-				    0)
-					ret = ERROR_NACK;
-			} else {
-				memcpy(packet->data, data, len);
-			}
-		}
-		crc.crc =
-		    crc32((u8 *)packet,
-			  sizeof(struct nanohub_packet) + len, ~0);
-		memcpy(&packet->data[len], &crc.crc,
-		       sizeof(struct nanohub_packet_crc));
-	} else {
-		ret = ERROR_NACK;
-	}
-
-	return ret;
-}
-
-static int packet_verify(struct nanohub_packet *packet)
-{
-	struct nanohub_packet_crc crc;
-	int cmp;
-
-	crc.crc =
-	    crc32((u8 *)packet,
-		  sizeof(struct nanohub_packet) + packet->len, ~0);
-
-	cmp =
-	    memcmp(&crc.crc, &packet->data[packet->len],
-		   sizeof(struct nanohub_packet_crc));
-
-	if (cmp != 0)
-		pr_debug("nanohub: gen crc: %08x, got crc: %08x\n", crc.crc,
-			 *(u32 *)&packet->data[packet->len]);
-
-	return cmp;
-}
-
-static void packet_free(struct nanohub_packet_pad *packet)
-{
-	kfree(packet);
-}
-
-static int read_ack(struct nanohub_data *data,
-		    struct nanohub_packet *response, int timeout)
-{
-	int ret, i;
-	const int max_size = sizeof(struct nanohub_packet) + MAX_UINT8 +
-	    sizeof(struct nanohub_packet_crc);
-	unsigned long end = jiffies + msecs_to_jiffies(READ_ACK_TIMEOUT_MS);
-
-	for (i = 0; time_before(jiffies, end); i++) {
-		ret =
-		    data->comms.read(data, (u8 *)response, max_size,
-				     timeout);
-
-		if (ret == 0) {
-			pr_debug("nanohub: %s: %d: empty packet\n", __func__,
-				 i);
-			ret = ERROR_NACK;
-			continue;
-		} else if (ret < sizeof(struct nanohub_packet)) {
-			pr_debug("nanohub %s: %d: too small\n", __func__, i);
-			ret = ERROR_NACK;
-			continue;
-		} else if (ret <
-			   sizeof(struct nanohub_packet) + response->len +
-			   sizeof(struct nanohub_packet_crc)) {
-			pr_debug("nanohub %s: %d: too small length\n",
-				 __func__, i);
-			ret = ERROR_NACK;
-			continue;
-		} else if (ret !=
-			   sizeof(struct nanohub_packet) + response->len +
-			   sizeof(struct nanohub_packet_crc)) {
-			pr_debug("nanohub %s: %d: wrong length\n", __func__,
-				 i);
-			ret = ERROR_NACK;
-			break;
-		} else if (packet_verify(response) != 0) {
-			pr_debug("nanohub %s: %d: invalid crc\n", __func__, i);
-			ret = ERROR_NACK;
-			break;
-		}
-		break;
-	}
-
-	return ret;
-}
-
-static int read_msg(struct nanohub_data *data,
-		    struct nanohub_packet *response, int timeout)
-{
-	int ret, i;
-	const int max_size = sizeof(struct nanohub_packet) + MAX_UINT8 +
-	    sizeof(struct nanohub_packet_crc);
-	unsigned long end = jiffies + msecs_to_jiffies(READ_MSG_TIMEOUT_MS);
-
-	for (i = 0; time_before(jiffies, end); i++) {
-		ret =
-		    data->comms.read(data, (u8 *)response, max_size,
-				     timeout);
-
-		if (ret == 0) {
-			pr_debug("nanohub: %s: %d: empty packet\n", __func__,
-				 i);
-			ret = ERROR_NACK;
-			continue;
-		} else if (ret < sizeof(struct nanohub_packet)) {
-			pr_debug("nanohub: %s: %d: too small\n", __func__, i);
-			ret = ERROR_NACK;
-			continue;
-		} else if (ret <
-			   sizeof(struct nanohub_packet) + response->len +
-			   sizeof(struct nanohub_packet_crc)) {
-			pr_debug("nanohub: %s: %d: too small length\n",
-				 __func__, i);
-			ret = ERROR_NACK;
-			continue;
-		} else if (ret !=
-			   sizeof(struct nanohub_packet) + response->len +
-			   sizeof(struct nanohub_packet_crc)) {
-			pr_debug("nanohub: %s: %d: wrong length\n", __func__,
-				 i);
-			ret = ERROR_NACK;
-			break;
-		} else if (packet_verify(response) != 0) {
-			pr_debug("nanohub: %s: %d: invalid crc\n", __func__,
-				 i);
-			ret = ERROR_NACK;
-			break;
-		}
-		break;
-	}
-
-	return ret;
-}
-
-static int get_reply(struct nanohub_data *data,
-		     struct nanohub_packet *response, u32 seq)
-{
-	int ret;
-
-	ret = read_ack(data, response, data->comms.timeout_ack);
-
-	if (ret >= 0 && response->seq == seq) {
-		if (response->reason == CMD_COMMS_ACK) {
-			if (response->len == sizeof(data->interrupts))
-				memcpy(data->interrupts, response->data,
-				       response->len);
-			ret =
-			    read_msg(data, response, data->comms.timeout_reply);
-			if (ret < 0)
-				ret = ERROR_NACK;
-		} else {
-			if (response->reason == CMD_COMMS_NACK)
-				ret = ERROR_NACK;
-			else if (response->reason == CMD_COMMS_BUSY)
-				ret = ERROR_BUSY;
-		}
-
-		if (response->seq != seq)
-			ret = ERROR_NACK;
-	} else {
-		ret = ERROR_NACK;
-	}
-	return ret;
-}
-
-static int nanohub_comms_tx_rx(struct nanohub_data *data,
-			       struct nanohub_packet_pad *pad, int packet_size,
-			       u32 seq, u8 *rx, size_t rx_len)
-{
-	int ret;
-
-	ret = data->comms.write(data, (u8 *)&pad->packet, packet_size,
-				data->comms.timeout_write);
-
-	if (ret == packet_size) {
-		ret = get_reply(data, &pad->packet, seq);
-
-		if (ret >= 0) {
-			if (pad->packet.len > 0) {
-				if (pad->packet.len > rx_len) {
-					memcpy(rx, pad->packet.data, rx_len);
-					ret = rx_len;
-				} else {
-					memcpy(rx, pad->packet.data,
-					       pad->packet.len);
-					ret = pad->packet.len;
-				}
-			} else {
-				ret = 0;
-			}
-		}
-	} else {
-		ret = ERROR_NACK;
-	}
-
-	return ret;
-}
-
-int nanohub_comms_rx_retrans_boottime(struct nanohub_data *data, u32 cmd,
-				      u8 *rx, size_t rx_len,
-				      int retrans_cnt,
-				      int retrans_delay)
-{
-	int packet_size = 0;
-	struct nanohub_packet_pad *pad = packet_alloc(GFP_KERNEL);
-	int delay = 0;
-	int ret;
-	u32 seq;
-	struct timespec ts;
-	s64 boottime;
-
-	if (!pad)
-		return ERROR_NACK;
-
-	seq = data->comms.seq++;
-
-	do {
-		data->comms.open(data);
-		get_monotonic_boottime(&ts);
-		boottime = timespec_to_ns(&ts);
-		packet_size =
-		    packet_create(&pad->packet, seq, cmd, sizeof(boottime),
-				  (u8 *)&boottime, false);
-
-		ret =
-		    nanohub_comms_tx_rx(data, pad, packet_size, seq, rx,
-					rx_len);
-
-		if (nanohub_wakeup_eom(data,
-				       ret == ERROR_BUSY ||
-				       (ret == ERROR_NACK && retrans_cnt >= 0)))
-			ret = -EFAULT;
-
-		data->comms.close(data);
-
-		if (ret == ERROR_NACK) {
-			retrans_cnt--;
-			delay += retrans_delay;
-			if (retrans_cnt >= 0)
-				udelay(retrans_delay);
-		} else if (ret == ERROR_BUSY) {
-			usleep_range(100000, 200000);
-		}
-	} while ((ret == ERROR_BUSY) ||
-		(ret == ERROR_NACK && retrans_cnt >= 0));
-
-	packet_free(pad);
-
-	return ret;
-}
-
-int nanohub_comms_tx_rx_retrans(struct nanohub_data *data, u32 cmd,
-				const u8 *tx, u8 tx_len,
-				u8 *rx, size_t rx_len, bool user,
-				int retrans_cnt, int retrans_delay)
-{
-	int packet_size = 0;
-	struct nanohub_packet_pad *pad = packet_alloc(GFP_KERNEL);
-	int delay = 0;
-	int ret;
-	u32 seq;
-
-	if (!pad)
-		return ERROR_NACK;
-	seq = data->comms.seq++;
-
-	do {
-		packet_size =
-		    packet_create(&pad->packet, seq, cmd, tx_len, tx, user);
-
-		data->comms.open(data);
-		ret =
-		    nanohub_comms_tx_rx(data, pad, packet_size, seq, rx,
-					rx_len);
-
-		if (nanohub_wakeup_eom(data,
-				       ret == ERROR_BUSY ||
-				       (ret == ERROR_NACK && retrans_cnt >= 0)))
-			ret = -EFAULT;
-
-		data->comms.close(data);
-
-		if (ret == ERROR_NACK) {
-			retrans_cnt--;
-			delay += retrans_delay;
-			if (retrans_cnt >= 0)
-				udelay(retrans_delay);
-		} else if (ret == ERROR_BUSY) {
-			usleep_range(100000, 200000);
-		}
-	} while ((ret == ERROR_BUSY) ||
-		(ret == ERROR_NACK && retrans_cnt >= 0));
-
-	packet_free(pad);
-
-	return ret;
-}
-
-struct firmware_header {
-	u32 size;
-	u32 crc;
-	u8 type;
-} __packed;
-
-struct firmware_chunk {
-	u32 offset;
-	u8 data[252 - sizeof(u32)];
-} __packed;
-
-static int nanohub_comms_download(struct nanohub_data *data,
-				  const u8 *image, size_t length,
-				  u8 type)
-{
-	u8 accepted;
-	struct firmware_header header;
-	struct firmware_chunk chunk;
-	int max_chunk_size = sizeof(chunk.data);
-	int chunk_size;
-	u32 offset = 0;
-	int ret;
-	u8 chunk_reply = 0, upload_reply = 0;
-	u32 clear_interrupts[8] = { 0x00000008 };
-
-	header.type = type;
-	header.size = cpu_to_le32(length);
-	header.crc = cpu_to_le32(~crc32(image, length, ~0));
-
-	if (request_wakeup(data))
-		return -ERESTARTSYS;
-	ret = nanohub_comms_tx_rx_retrans(data, CMD_COMMS_START_KERNEL_UPLOAD,
-					  (const u8 *)&header,
-					  sizeof(header), &accepted,
-					  sizeof(accepted), false, 10, 10);
-	release_wakeup(data);
-
-	if (ret == 1 && accepted == 1) {
-		do {
-			if (request_wakeup(data))
-				continue;
-
-			chunk.offset = cpu_to_le32(offset);
-			if (offset + max_chunk_size > length)
-				chunk_size = length - offset;
-			else
-				chunk_size = max_chunk_size;
-			memcpy(chunk.data, image + offset, chunk_size);
-
-			ret =
-			    nanohub_comms_tx_rx_retrans(data,
-							CMD_COMMS_KERNEL_CHUNK,
-							(const u8 *)&chunk,
-							sizeof(u32) +
-							chunk_size,
-							&chunk_reply,
-							sizeof(chunk_reply),
-							false, 10, 10);
-
-			pr_debug("nanohub: ret=%d, chunk_reply=%d, offset=%d\n",
-				 ret, chunk_reply, offset);
-			if (ret == sizeof(chunk_reply)) {
-				if (chunk_reply == CHUNK_REPLY_ACCEPTED) {
-					offset += chunk_size;
-				} else if (chunk_reply == CHUNK_REPLY_WAIT) {
-					ret = nanohub_wait_for_interrupt(data);
-					if (ret < 0) {
-						release_wakeup(data);
-						continue;
-					}
-					nanohub_comms_tx_rx_retrans
-						(data, CMD_COMMS_CLR_GET_INTR,
-						 (u8 *)clear_interrupts,
-						 sizeof(clear_interrupts),
-						 (u8 *)data->interrupts,
-						 sizeof(data->interrupts),
-						 false, 10, 0);
-				} else if (chunk_reply == CHUNK_REPLY_RESEND) {
-					;
-				} else if (chunk_reply == CHUNK_REPLY_RESTART) {
-					offset = 0;
-				} else if (chunk_reply == CHUNK_REPLY_CANCEL ||
-					(chunk_reply ==
-					CHUNK_REPLY_CANCEL_NO_RETRY)) {
-					release_wakeup(data);
-					break;
-				}
-			} else if (ret <= 0) {
-				release_wakeup(data);
-				break;
-			}
-			release_wakeup(data);
-		} while (offset < length);
-	}
-
-	do {
-		if (request_wakeup(data)) {
-			ret = sizeof(upload_reply);
-			upload_reply = UPLOAD_REPLY_PROCESSING;
-			continue;
-		}
-		ret = nanohub_comms_tx_rx_retrans
-			(data,
-			 CMD_COMMS_FINISH_KERNEL_UPLOAD, NULL, 0,
-			 &upload_reply, sizeof(upload_reply), false, 10, 10);
-		release_wakeup(data);
-	} while (ret == sizeof(upload_reply) &&
-		 upload_reply == UPLOAD_REPLY_PROCESSING);
-
-	pr_info("nanohub: %s: ret=%d, upload_reply=%d\n", __func__,
-		ret, upload_reply);
-
-	return 0;
-}
-
-int nanohub_comms_kernel_download(struct nanohub_data *data,
-				  const u8 *image, size_t length)
-{
-	return nanohub_comms_download(data, image, length,
-				      COMMS_FLASH_KERNEL_ID);
-}
-
-int nanohub_comms_app_download(struct nanohub_data *data, const u8 *image,
-			       size_t length)
-{
-	return nanohub_comms_download(data, image, length, COMMS_FLASH_APP_ID);
-}
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/comms.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/comms.h
deleted file mode 100644
index 8fb3d4f..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/comms.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _NANOHUB_COMMS_H
-#define _NANOHUB_COMMS_H
-
-struct __attribute__ ((__packed__)) nanohub_packet {
-	u8 sync;
-	u32 seq;
-	u32 reason;
-	u8 len;
-	u8 data[];
-};
-
-struct __attribute__ ((__packed__)) nanohub_packet_pad {
-	u8 pad[3];
-	struct nanohub_packet
-	 packet;
-};
-
-struct __attribute__ ((__packed__)) nanohub_packet_crc {
-	u32 crc;
-};
-
-struct nanohub_data;
-
-struct nanohub_comms {
-	struct semaphore sem;
-	u32 seq;
-	int timeout_write;
-	int timeout_ack;
-	int timeout_reply;
-	int (*open)(void *data);
-	void (*close)(void *data);
-	int (*write)(void *data, u8 *buf, int size, int timeout_w);
-	int (*read)(void *data, u8 *buf, int size, int timeout_r);
-
-	union {
-		struct i2c_client *i2c_client;
-		struct spi_device *spi_device;
-	};
-
-	u8 *tx_buffer;
-	u8 *rx_buffer;
-};
-
-int nanohub_comms_kernel_download(struct nanohub_data *data,
-				  const u8 *image,
-				  size_t length);
-int nanohub_comms_app_download(struct nanohub_data *data,
-			       const u8 *image, size_t length);
-int nanohub_comms_rx_retrans_boottime(struct nanohub_data *data,
-				      u32 cmd, u8 *rx,
-				      size_t rx_len,
-				      int retrans_cnt,
-				      int retrans_delay);
-int nanohub_comms_tx_rx_retrans(struct nanohub_data *data, u32 cmd,
-				const u8 *tx, u8 tx_len,
-				u8 *rx, size_t rx_len, bool user,
-				int retrans_cnt, int retrans_delay);
-
-#define ERROR_NACK			-1
-#define ERROR_BUSY			-2
-
-#define MAX_UINT8			((1 << (8 * sizeof(u8))) - 1)
-
-#define COMMS_SYNC			0x31
-#define COMMS_FLASH_KERNEL_ID		0x1
-#define COMMS_FLASH_EEDATA_ID		0x2
-#define COMMS_FLASH_APP_ID		0x4
-
-#define CMD_COMMS_ACK			0x00000000
-#define CMD_COMMS_NACK			0x00000001
-#define CMD_COMMS_BUSY			0x00000002
-
-#define CMD_COMMS_GET_OS_HW_VERSIONS	0x00001000
-#define CMD_COMMS_GET_APP_VERSIONS	0x00001001
-#define CMD_COMMS_QUERY_APP_INFO	0x00001002
-
-#define CMD_COMMS_START_KERNEL_UPLOAD	0x00001040
-#define CMD_COMMS_KERNEL_CHUNK		0x00001041
-#define CMD_COMMS_FINISH_KERNEL_UPLOAD	0x00001042
-
-#define CMD_COMMS_START_APP_UPLOAD	0x00001050
-#define CMD_COMMS_APP_CHUNK		0x00001051
-
-#define CMD_COMMS_CLR_GET_INTR		0x00001080
-#define CMD_COMMS_MASK_INTR		0x00001081
-#define CMD_COMMS_UNMASK_INTR		0x00001082
-#define CMD_COMMS_READ			0x00001090
-#define CMD_COMMS_WRITE			0x00001091
-
-#define CHUNK_REPLY_ACCEPTED		0
-#define CHUNK_REPLY_WAIT                1
-#define CHUNK_REPLY_RESEND              2
-#define CHUNK_REPLY_RESTART             3
-#define CHUNK_REPLY_CANCEL              4
-#define CHUNK_REPLY_CANCEL_NO_RETRY     5
-
-#define UPLOAD_REPLY_SUCCESS			0
-#define UPLOAD_REPLY_PROCESSING			1
-#define UPLOAD_REPLY_WAITING_FOR_DATA		2
-#define UPLOAD_REPLY_APP_SEC_KEY_NOT_FOUND	3
-#define UPLOAD_REPLY_APP_SEC_HEADER_ERROR	4
-#define UPLOAD_REPLY_APP_SEC_TOO_MUCH_DATA	5
-#define UPLOAD_REPLY_APP_SEC_TOO_LITTLE_DATA	6
-#define UPLOAD_REPLY_APP_SEC_SIG_VERIFY_FAIL	7
-#define UPLOAD_REPLY_APP_SEC_SIG_DECODE_FAIL	8
-#define UPLOAD_REPLY_APP_SEC_SIG_ROOT_UNKNOWN	9
-#define UPLOAD_REPLY_APP_SEC_MEMORY_ERROR	10
-#define UPLOAD_REPLY_APP_SEC_INVALID_DATA	11
-#define UPLOAD_REPLY_APP_SEC_BAD		12
-
-static inline int nanohub_comms_write(struct nanohub_data *data,
-				      const u8 *buffer, size_t buffer_len)
-{
-	u8 ret;
-
-	if (nanohub_comms_tx_rx_retrans
-	    (data, CMD_COMMS_WRITE, buffer, buffer_len, &ret, sizeof(ret), true,
-	     10, 10) == sizeof(ret)) {
-		if (ret)
-			return buffer_len;
-		else
-			return 0;
-	} else {
-		return ERROR_NACK;
-	}
-}
-
-ssize_t nanohub_external_write(const char *buffer, size_t length);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/main.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/main.c
deleted file mode 100644
index f6e0ccb..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/main.c
+++ /dev/null
@@ -1,1019 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/iio/iio.h>
-#include <linux/firmware.h>
-#include <linux/fs.h>
-#include <linux/cdev.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/of_gpio.h>
-#include <linux/of_irq.h>
-#include <linux/interrupt.h>
-#include <linux/poll.h>
-#include <linux/list.h>
-#include <linux/vmalloc.h>
-#include <linux/spinlock.h>
-#include <linux/semaphore.h>
-#include <linux/sched.h>
-#include <linux/sched/rt.h>
-#include <uapi/linux/sched/types.h>
-
-#include "main.h"
-#include "comms.h"
-#include "bl.h"
-#include "nanohub-mtk.h"
-#include "nanohub.h"
-
-#define READ_QUEUE_DEPTH	10
-#define APP_FROM_HOST_EVENTID	0x000000F8
-#define FIRST_SENSOR_EVENTID	0x00000200
-#define LAST_SENSOR_EVENTID	0x000002FF
-#define APP_TO_HOST_EVENTID	0x00000401
-#define OS_LOG_EVENTID		0x3B474F4C
-#define WAKEUP_INTERRUPT	1
-#define WAKEUP_TIMEOUT_MS	1000
-#define SUSPEND_TIMEOUT_MS	100
-
-struct nanohub_data *g_nanohub_data_p;
-
-/**
- * struct gpio_config - this is a binding between platform data and driver data
- * @label:     for diagnostics
- * @flags:     to pass to gpio_request_one()
- * @options:   one or more of GPIO_OPT_* flags, below
- * @pdata_off: offset of u32 field in platform data with gpio #
- * @data_off:  offset of int field in driver data with irq # (optional)
- */
-struct gpio_config {
-	const char *label;
-	u16 flags;
-	u16 options;
-	u16 pdata_off;
-	u16 data_off;
-};
-
-#define GPIO_OPT_HAS_IRQ	0x0001
-#define GPIO_OPT_OPTIONAL	0x8000
-
-#define PLAT_GPIO_DEF(name, _flags) \
-	.pdata_off = offsetof(struct nanohub_platform_data, name ## _gpio), \
-	.label = "nanohub_" #name, \
-	.flags = _flags
-
-#define PLAT_GPIO_DEF_IRQ(name, _opts) \
-	.data_off = offsetof(struct nanohub_data, name), \
-	.options = GPIO_OPT_HAS_IRQ | (_opts)
-
-static struct class *sensor_class;
-static int major;
-
-static const struct gpio_config gconf[] = {
-	{ PLAT_GPIO_DEF(nreset, GPIOF_OUT_INIT_HIGH) },
-	{ PLAT_GPIO_DEF(wakeup, GPIOF_OUT_INIT_HIGH) },
-	{ PLAT_GPIO_DEF(boot0, GPIOF_OUT_INIT_LOW) },
-	{ PLAT_GPIO_DEF(irq1, GPIOF_DIR_IN),
-	  PLAT_GPIO_DEF_IRQ(irq1, 0)
-	},
-	{ PLAT_GPIO_DEF(irq2, GPIOF_DIR_IN),
-	  PLAT_GPIO_DEF_IRQ(irq2, GPIO_OPT_OPTIONAL)
-	},
-};
-
-static const struct iio_info nanohub_iio_info = {
-};
-
-static const struct file_operations nanohub_fileops = {
-	.owner = THIS_MODULE,
-};
-
-enum {
-	ST_IDLE,
-	ST_ERROR,
-	ST_RUNNING
-};
-
-static inline bool gpio_is_optional(const struct gpio_config *_cfg)
-{
-	return _cfg->options & GPIO_OPT_OPTIONAL;
-}
-
-static inline bool gpio_has_irq(const struct gpio_config *_cfg)
-{
-	return _cfg->options & GPIO_OPT_HAS_IRQ;
-}
-
-static inline bool
-nanohub_has_priority_lock_locked(struct nanohub_data *data)
-{
-	return  atomic_read(&data->wakeup_lock_cnt) >
-		atomic_read(&data->wakeup_cnt);
-}
-
-static inline void nanohub_notify_thread(struct nanohub_data *data)
-{
-	atomic_set(&data->kthread_run, 1);
-	/* wake_up implementation works as memory barrier */
-	wake_up_interruptible_sync(&data->kthread_wait);
-}
-
-static inline void nanohub_io_init(struct nanohub_io *io,
-				   struct nanohub_data *data,
-				   struct device *dev)
-{
-	init_waitqueue_head(&io->buf_wait);
-	INIT_LIST_HEAD(&io->buf_list);
-	io->data = data;
-	io->dev = dev;
-}
-
-static inline bool nanohub_io_has_buf(struct nanohub_io *io)
-{
-	return !list_empty(&io->buf_list);
-}
-
-static struct nanohub_buf *nanohub_io_get_buf(struct nanohub_io *io,
-					      bool wait)
-{
-	struct nanohub_buf *buf = NULL;
-	int ret;
-
-	spin_lock(&io->buf_wait.lock);
-	if (wait) {
-		ret = wait_event_interruptible_locked(io->buf_wait,
-						      nanohub_io_has_buf(io));
-		if (ret < 0) {
-			spin_unlock(&io->buf_wait.lock);
-			return ERR_PTR(ret);
-		}
-	}
-
-	if (nanohub_io_has_buf(io)) {
-		buf = list_first_entry(&io->buf_list, struct nanohub_buf, list);
-		list_del(&buf->list);
-	}
-	spin_unlock(&io->buf_wait.lock);
-
-	return buf;
-}
-
-static void nanohub_io_put_buf(struct nanohub_io *io,
-			       struct nanohub_buf *buf)
-{
-	bool was_empty;
-
-	spin_lock(&io->buf_wait.lock);
-	was_empty = !nanohub_io_has_buf(io);
-	list_add_tail(&buf->list, &io->buf_list);
-	spin_unlock(&io->buf_wait.lock);
-
-	if (was_empty) {
-		if (&io->data->free_pool == io)
-			nanohub_notify_thread(io->data);
-		else
-			wake_up_interruptible(&io->buf_wait);
-	}
-}
-
-static inline bool mcu_wakeup_try_lock(struct nanohub_data *data, int key)
-{
-	/* implementation contains memory barrier */
-	return atomic_cmpxchg(&data->wakeup_acquired, 0, key) == 0;
-}
-
-static inline void mcu_wakeup_unlock(struct nanohub_data *data, int key)
-{
-	WARN(atomic_cmpxchg(&data->wakeup_acquired, key, 0) != key,
-	     "%s: failed to unlock with key %d; current state: %d",
-	     __func__, key, atomic_read(&data->wakeup_acquired));
-}
-
-static inline void nanohub_set_state(struct nanohub_data *data, int state)
-{
-	atomic_set(&data->thread_state, state);
-	smp_mb__after_atomic(); /* updated thread state is now visible */
-}
-
-static inline int nanohub_get_state(struct nanohub_data *data)
-{
-	smp_mb__before_atomic(); /* wait for all updates to finish */
-	return atomic_read(&data->thread_state);
-}
-
-int request_wakeup_ex(struct nanohub_data *data, long timeout_ms,
-		      int key, int lock_mode)
-{
-	return 0;
-}
-
-void release_wakeup_ex(struct nanohub_data *data, int key, int lock_mode)
-{
-}
-
-int nanohub_wait_for_interrupt(struct nanohub_data *data)
-{
-	return 0;
-}
-
-int nanohub_wakeup_eom(struct nanohub_data *data, bool repeat)
-{
-	return 0;
-}
-
-static void __nanohub_interrupt_cfg(struct nanohub_data *data,
-				    u8 interrupt, bool mask)
-{
-	int ret;
-	u8 mask_ret = 0;
-	int cnt = 10;
-	struct device *dev = data->io[ID_NANOHUB_SENSOR].dev;
-	int cmd = mask ? CMD_COMMS_MASK_INTR : CMD_COMMS_UNMASK_INTR;
-
-	do {
-		ret = request_wakeup_timeout(data, WAKEUP_TIMEOUT_MS);
-		if (ret) {
-			dev_err(dev,
-				"%s: interrupt %d %smask failed: ret=%d\n",
-				__func__, interrupt, mask ? "" : "un", ret);
-			return;
-		}
-
-		ret =
-		    nanohub_comms_tx_rx_retrans(data, cmd,
-						&interrupt, sizeof(interrupt),
-						&mask_ret, sizeof(mask_ret),
-						false, 10, 0);
-		release_wakeup(data);
-		dev_dbg(dev,
-			"%smasking interrupt %d, ret=%d, mask_ret=%d\n",
-			mask ? "" : "un",
-			interrupt, ret, mask_ret);
-	} while ((ret != 1 || mask_ret != 1) && --cnt > 0);
-}
-
-static inline void nanohub_mask_interrupt(struct nanohub_data *data,
-					  u8 interrupt)
-{
-	__nanohub_interrupt_cfg(data, interrupt, true);
-}
-
-static inline void nanohub_unmask_interrupt(struct nanohub_data *data,
-					    u8 interrupt)
-{
-	__nanohub_interrupt_cfg(data, interrupt, false);
-}
-
-static ssize_t nanohub_wakeup_query(struct device *dev,
-				    struct device_attribute *attr, char *buf)
-{
-	struct nanohub_data *data = dev_get_nanohub_data(dev);
-	const struct nanohub_platform_data *pdata = data->pdata;
-
-	data->err_cnt = 0;
-	if (nanohub_irq1_fired(data) || nanohub_irq2_fired(data))
-		wake_up_interruptible(&data->wakeup_wait);
-
-	return scnprintf(buf, PAGE_SIZE, "WAKEUP: %d INT1: %d INT2: %d\n",
-			 gpio_get_value(pdata->wakeup_gpio),
-			 gpio_get_value(pdata->irq1_gpio),
-			 data->irq2 ? gpio_get_value(pdata->irq2_gpio) : -1);
-}
-
-static ssize_t nanohub_app_info(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	struct nanohub_data *data = dev_get_nanohub_data(dev);
-	struct {
-		u64 appid;
-		u32 appver;
-		u32 appsize;
-	} __packed buffer;
-	u32 i = 0;
-	int ret;
-	ssize_t len = 0;
-
-	do {
-		if (request_wakeup(data))
-			return -ERESTARTSYS;
-
-		if (nanohub_comms_tx_rx_retrans
-		    (data, CMD_COMMS_QUERY_APP_INFO, (u8 *)&i,
-		     sizeof(i), (u8 *)&buffer, sizeof(buffer),
-		     false, 10, 10) == sizeof(buffer)) {
-			ret =
-			    scnprintf(buf + len, PAGE_SIZE - len,
-				      "app %d id:%016llx ver:%08x size:%08x\n",
-				      i, buffer.appid, buffer.appver,
-				      buffer.appsize);
-			if (ret > 0) {
-				len += ret;
-				i++;
-			}
-		} else {
-			ret = -1;
-		}
-
-		release_wakeup(data);
-	} while (ret > 0);
-
-	return len;
-}
-
-static ssize_t nanohub_firmware_query(struct device *dev,
-				      struct device_attribute *attr, char *buf)
-{
-	struct nanohub_data *data = dev_get_nanohub_data(dev);
-	u16 buffer[6];
-
-	if (request_wakeup(data))
-		return -ERESTARTSYS;
-
-	if (nanohub_comms_tx_rx_retrans
-	    (data, CMD_COMMS_GET_OS_HW_VERSIONS, NULL, 0, (u8 *)&buffer,
-	     sizeof(buffer), false, 10, 10) == sizeof(buffer)) {
-		release_wakeup(data);
-		return scnprintf(buf, PAGE_SIZE,
-			"hw type: %04x hw ver: %04x bl ver: %04x os ver: %04x variant ver: %08x\n",
-			buffer[0], buffer[1], buffer[2], buffer[3],
-			buffer[5] << 16 | buffer[4]);
-	} else {
-		release_wakeup(data);
-		return 0;
-	}
-}
-
-static inline int nanohub_wakeup_lock(struct nanohub_data *data,
-				      int mode)
-{
-	return 0;
-}
-
-/* returns lock mode used to perform this lock */
-static inline int nanohub_wakeup_unlock(struct nanohub_data *data)
-{
-	int mode = atomic_read(&data->lock_mode);
-
-	atomic_set(&data->lock_mode, LOCK_MODE_NONE);
-	if (mode != LOCK_MODE_SUSPEND_RESUME)
-		enable_irq(data->irq1);
-	if (mode == LOCK_MODE_IO)
-		nanohub_bl_close(data);
-	if (data->irq2)
-		enable_irq(data->irq2);
-	release_wakeup_ex(data, KEY_WAKEUP_LOCK, mode);
-	if (!data->irq2)
-		nanohub_unmask_interrupt(data, 2);
-	nanohub_notify_thread(data);
-
-	return mode;
-}
-
-/*
- *static void __nanohub_hw_reset(struct nanohub_data *data, int boot0)
- *{
- *	const struct nanohub_platform_data *pdata = data->pdata;
- *
- *	gpio_set_value(pdata->nreset_gpio, 0);
- *	gpio_set_value(pdata->boot0_gpio, boot0 ? 1 : 0);
- *	usleep_range(30, 40);
- *	gpio_set_value(pdata->nreset_gpio, 1);
- *	if (boot0)
- *		usleep_range(70000, 75000);
- *	else
- *		usleep_range(750000, 800000);
- *}
- */
-static ssize_t nanohub_hw_reset(struct device *dev,
-				struct device_attribute *attr,
-				const char *buf, size_t count)
-{
-	return -EIO;
-/*
- *	struct nanohub_data *data = dev_get_nanohub_data(dev);
- *	int ret;
- *
- *	ret = nanohub_wakeup_lock(data, LOCK_MODE_RESET);
- *	if (!ret) {
- *		data->err_cnt = 0;
- *		__nanohub_hw_reset(data, 0);
- *		nanohub_wakeup_unlock(data);
- *	}
- *
- *	return ret < 0 ? ret : count;
- */
-}
-
-static ssize_t nanohub_erase_shared(struct device *dev,
-				    struct device_attribute *attr,
-				    const char *buf, size_t count)
-{
-	return -EIO;
-/*
- *	struct nanohub_data *data = dev_get_nanohub_data(dev);
- *	u8 status = CMD_ACK;
- *	int ret;
- *
- *	ret = nanohub_wakeup_lock(data, LOCK_MODE_IO);
- *	if (ret < 0)
- *		return ret;
- *
- *	data->err_cnt = 0;
- *	__nanohub_hw_reset(data, 1);
- *
- *	status = nanohub_bl_erase_shared(data);
- *	dev_info(dev, "nanohub_bl_erase_shared: status=%02x\n",
- *		 status);
- *
- *	__nanohub_hw_reset(data, 0);
- *	nanohub_wakeup_unlock(data);
- *
- *	return ret < 0 ? ret : count;
- */
-}
-
-static ssize_t nanohub_download_bl(struct device *dev,
-				   struct device_attribute *attr,
-				   const char *buf, size_t count)
-{
-	return -EIO;
-/*
- *	struct nanohub_data *data = dev_get_nanohub_data(dev);
- *	const struct nanohub_platform_data *pdata = data->pdata;
- *	const struct firmware *fw_entry;
- *	int ret;
- *	u8 status = CMD_ACK;
- *
- *	ret = nanohub_wakeup_lock(data, LOCK_MODE_IO);
- *	if (ret < 0)
- *		return ret;
- *
- *	data->err_cnt = 0;
- *	__nanohub_hw_reset(data, 1);
- *
- *	ret = request_firmware(&fw_entry, "nanohub.full.bin", dev);
- *	if (ret) {
- *		dev_err(dev, "%s: err=%d\n", __func__, ret);
- *	} else {
- *		status = nanohub_bl_download(data, pdata->bl_addr,
- *					     fw_entry->data, fw_entry->size);
- *		dev_info(dev, "%s: status=%02x\n", __func__, status);
- *		release_firmware(fw_entry);
- *	}
- *
- *	__nanohub_hw_reset(data, 0);
- *	nanohub_wakeup_unlock(data);
- *
- *	return ret < 0 ? ret : count;
- */
-}
-
-static ssize_t nanohub_download_kernel(struct device *dev,
-				       struct device_attribute *attr,
-				       const char *buf, size_t count)
-{
-	return -EIO;
-/*
- *	struct nanohub_data *data = dev_get_nanohub_data(dev);
- *	const struct firmware *fw_entry;
- *	int ret;
- *
- *	ret = request_firmware(&fw_entry, "nanohub.update.bin", dev);
- *	if (ret) {
- *		dev_err(dev, "nanohub_download_kernel: err=%d\n", ret);
- *		return -EIO;
- *	}
- *	ret = nanohub_comms_kernel_download(data, fw_entry->data,
- *					    fw_entry->size);
- *
- *	release_firmware(fw_entry);
- *
- *	return count;
- */
-}
-
-static ssize_t nanohub_download_app(struct device *dev,
-				    struct device_attribute *attr,
-				    const char *buf, size_t count)
-{
-	return -EIO;
-/*
- *	struct nanohub_data *data = dev_get_nanohub_data(dev);
- *	const struct firmware *fw_entry;
- *	char buffer[70];
- *	int i, ret, ret1, ret2, file_len = 0, appid_len = 0, ver_len = 0;
- *	const char *appid = NULL, *ver = NULL;
- *	unsigned long version;
- *	u64 id;
- *	u32 cur_version;
- *	bool update = true;
- *
- *	for (i = 0; i < count; i++) {
- *		if (buf[i] == ' ') {
- *			if (i + 1 == count)
- *				break;
- *			if (!appid)
- *				appid = buf + i + 1;
- *			else if (!ver)
- *				ver = buf + i + 1;
- *			else
- *				break;
- *		} else if (buf[i] == '\n' || buf[i] == '\r') {
- *			break;
- *		}
- *		if (ver)
- *			ver_len++;
- *		else if (appid)
- *			appid_len++;
- *		else
- *			file_len++;
- *	}
- *
- *	if (file_len > 64 || appid_len > 16 || ver_len > 8 || file_len < 1)
- *		return -EIO;
- *
- *	memcpy(buffer, buf, file_len);
- *	memcpy(buffer + file_len, ".napp", 5);
- *	buffer[file_len + 5] = '\0';
- *
- *	ret = request_firmware(&fw_entry, buffer, dev);
- *	if (ret) {
- *		dev_err(dev, "nanohub_download_app(%s): err=%d\n",
- *			buffer, ret);
- *		return -EIO;
- *	}
- *	if (appid_len > 0 && ver_len > 0) {
- *		memcpy(buffer, appid, appid_len);
- *		buffer[appid_len] = '\0';
- *
- *		ret1 = kstrtoull(buffer, 16, &id);
- *
- *		memcpy(buffer, ver, ver_len);
- *		buffer[ver_len] = '\0';
- *
- *		ret2 = kstrtoul(buffer, 16, &version);
- *
- *		if (ret1 == 0 && ret2 == 0) {
- *			if (request_wakeup(data))
- *				return -ERESTARTSYS;
- *			if (nanohub_comms_tx_rx_retrans
- *			    (data, CMD_COMMS_GET_APP_VERSIONS,
- *			     (u8 *)&id, sizeof(id),
- *			     (u8 *)&cur_version,
- *			     sizeof(cur_version), false, 10,
- *			     10) == sizeof(cur_version)) {
- *				if (cur_version == version)
- *					update = false;
- *			}
- *			release_wakeup(data);
- *		}
- *	}
- *
- *	if (update)
- *		ret =
- *		    nanohub_comms_app_download(data, fw_entry->data,
- *					       fw_entry->size);
- *
- *	release_firmware(fw_entry);
- *
- *	return count;
- */
-}
-
-static struct device_attribute attributes[] = {
-	__ATTR(wakeup, 0440, nanohub_wakeup_query, NULL),
-	__ATTR(app_info, 0440, nanohub_app_info, NULL),
-	__ATTR(firmware_version, 0440, nanohub_firmware_query, NULL),
-	__ATTR(download_bl, 0220, NULL, nanohub_download_bl),
-	__ATTR(download_kernel, 0220, NULL, nanohub_download_kernel),
-	__ATTR(download_app, 0220, NULL, nanohub_download_app),
-	__ATTR(erase_shared, 0220, NULL, nanohub_erase_shared),
-	__ATTR(reset, 0220, NULL, nanohub_hw_reset),
-};
-
-static inline int nanohub_create_sensor(struct nanohub_data *data)
-{
-	int i, ret;
-	struct device *sensor_dev = data->io[ID_NANOHUB_SENSOR].dev;
-
-	for (i = 0, ret = 0; i < ARRAY_SIZE(attributes); i++) {
-		ret = device_create_file(sensor_dev, &attributes[i]);
-		if (ret) {
-			dev_err(sensor_dev,
-				"create sysfs attr %d [%s] failed; err=%d\n",
-				i, attributes[i].attr.name, ret);
-			goto fail_attr;
-		}
-	}
-
-	ret = sysfs_create_link(&sensor_dev->kobj,
-				&data->iio_dev->dev.kobj, "iio");
-	if (ret) {
-		dev_err(sensor_dev,
-			"sysfs_create_link failed; err=%d\n", ret);
-		goto fail_attr;
-	}
-	goto done;
-
-fail_attr:
-	for (i--; i >= 0; i--)
-		device_remove_file(sensor_dev, &attributes[i]);
-done:
-	return ret;
-}
-
-static int nanohub_create_devices(struct nanohub_data *data)
-{
-	int i, ret;
-	static const char *names[ID_NANOHUB_MAX] = {
-			"nanohub", "nanohub_comms"
-	};
-
-	for (i = 0; i < ID_NANOHUB_MAX; ++i) {
-		struct nanohub_io *io = &data->io[i];
-
-		nanohub_io_init(io, data, device_create(sensor_class, NULL,
-							MKDEV(major, i),
-							io, names[i]));
-		if (IS_ERR(io->dev)) {
-			ret = PTR_ERR(io->dev);
-			pr_err("nanohub: device_create failed for %s; err=%d\n",
-			       names[i], ret);
-			goto fail_dev;
-		}
-	}
-
-	ret = nanohub_create_sensor(data);
-	if (!ret)
-		goto done;
-fail_dev:
-	for (--i; i >= 0; --i)
-		device_destroy(sensor_class, MKDEV(major, i));
-done:
-	return ret;
-}
-
-ssize_t nanohub_external_write(const char *buffer, size_t length)
-{
-	struct nanohub_data *data = g_nanohub_data_p;
-	int ret;
-	u8 ret_data;
-
-	if (request_wakeup(data))
-		return -ERESTARTSYS;
-
-	if (nanohub_comms_tx_rx_retrans
-		(data, CMD_COMMS_WRITE, buffer, length, &ret_data,
-		sizeof(ret_data), false,
-		10, 10) == sizeof(ret_data)) {
-		if (ret_data)
-			ret = length;
-		else
-			ret = 0;
-	} else {
-		ret = ERROR_NACK;
-	}
-
-	release_wakeup(data);
-
-	return ret;
-}
-EXPORT_SYMBOL(nanohub_external_write);
-
-static bool nanohub_os_log(char *buffer, int len)
-{
-	if (le32_to_cpu((((u32 *)buffer)[0]) & 0x7FFFFFFF) ==
-	    OS_LOG_EVENTID) {
-		char *mtype, *mdata = &buffer[5];
-
-		buffer[len - 1] = '\0';
-
-		switch (buffer[4]) {
-		case 'E':
-			mtype = KERN_ERR;
-			break;
-		case 'W':
-			mtype = KERN_WARNING;
-			break;
-		case 'I':
-			mtype = KERN_INFO;
-			break;
-		case 'D':
-			mtype = KERN_DEBUG;
-			break;
-		default:
-			mtype = KERN_DEFAULT;
-			mdata--;
-			break;
-		}
-		pr_debug("%snanohub: %s", mtype, mdata);
-		return true;
-	} else {
-		return false;
-	}
-}
-
-static void nanohub_process_buffer(struct nanohub_data *data,
-				   struct nanohub_buf **buf,
-				   int ret)
-{
-	u32 event_id;
-	u8 interrupt;
-	bool wakeup = false;
-	struct nanohub_io *io = &data->io[ID_NANOHUB_SENSOR];
-
-	data->err_cnt = 0;
-	if (ret < 4 || nanohub_os_log((*buf)->buffer, ret)) {
-		release_wakeup(data);
-		return;
-	}
-
-	(*buf)->length = ret;
-
-	event_id = le32_to_cpu((((u32 *)(*buf)->buffer)[0]) & 0x7FFFFFFF);
-	if (ret >= sizeof(u32) + sizeof(u64) + sizeof(u32) &&
-	    event_id > FIRST_SENSOR_EVENTID &&
-	    event_id <= LAST_SENSOR_EVENTID) {
-		interrupt = (*buf)->buffer[sizeof(u32) +
-					   sizeof(u64) + 3];
-		if (interrupt == WAKEUP_INTERRUPT)
-			wakeup = true;
-	}
-	if (event_id == APP_TO_HOST_EVENTID) {
-		wakeup = true;
-		io = &data->io[ID_NANOHUB_COMMS];
-	}
-
-	nanohub_io_put_buf(io, *buf);
-
-	*buf = NULL;
-	/* (for wakeup interrupts): hold a wake lock for 10ms so the sensor hal
-	 * has time to grab its own wake lock
-	 */
-	if (wakeup)
-		__pm_wakeup_event(data->ws, 10);
-	release_wakeup(data);
-}
-
-static int nanohub_kthread(void *arg)
-{
-	struct nanohub_data *data = (struct nanohub_data *)arg;
-	struct nanohub_buf *buf = NULL;
-	int ret;
-	u32 clear_interrupts[8] = { 0x00000006 };
-	struct device *sensor_dev = data->io[ID_NANOHUB_SENSOR].dev;
-	static const struct sched_param param = {
-		.sched_priority = (MAX_USER_RT_PRIO / 2) - 1,
-	};
-
-	data->err_cnt = 0;
-	sched_setscheduler(current, SCHED_FIFO, &param);
-	nanohub_set_state(data, ST_IDLE);
-
-	while (!kthread_should_stop()) {
-		switch (nanohub_get_state(data)) {
-		case ST_IDLE:
-			if (wait_event_interruptible(
-					data->kthread_wait,
-					atomic_read(&data->kthread_run)))
-				continue;
-			nanohub_set_state(data, ST_RUNNING);
-			break;
-		case ST_ERROR:
-			msleep_interruptible(WAKEUP_TIMEOUT_MS);
-			nanohub_set_state(data, ST_RUNNING);
-			break;
-		case ST_RUNNING:
-			break;
-		}
-		atomic_set(&data->kthread_run, 0);
-		if (!buf)
-			buf = nanohub_io_get_buf(&data->free_pool,
-						 false);
-		if (buf) {
-			ret = request_wakeup_timeout(data, WAKEUP_TIMEOUT_MS);
-			if (ret) {
-				dev_info(sensor_dev,
-					 "%s: request_wakeup_timeout: ret=%d\n",
-					 __func__, ret);
-				continue;
-			}
-
-			ret = nanohub_comms_rx_retrans_boottime(
-			    data, CMD_COMMS_READ, buf->buffer,
-			    sizeof(buf->buffer), 10, 0);
-			if (ret > 0) {
-				nanohub_process_buffer(data, &buf, ret);
-				if (!nanohub_irq1_fired(data) &&
-				    !nanohub_irq2_fired(data)) {
-					nanohub_set_state(data, ST_IDLE);
-					continue;
-				}
-			} else if (ret == 0) {
-				/* queue empty, go to sleep */
-				data->err_cnt = 0;
-				data->interrupts[0] &= ~0x00000006;
-				release_wakeup(data);
-				nanohub_set_state(data, ST_IDLE);
-				continue;
-			} else {
-				release_wakeup(data);
-				if (++data->err_cnt >= 10) {
-					dev_err(sensor_dev,
-						"%s: err_cnt=%d\n",
-						__func__,
-						data->err_cnt);
-					nanohub_set_state(data, ST_ERROR);
-					continue;
-				}
-			}
-		} else {
-			if (!nanohub_irq1_fired(data) &&
-			    !nanohub_irq2_fired(data)) {
-				nanohub_set_state(data, ST_IDLE);
-				continue;
-			}
-			/* pending interrupt, but no room to read data -
-			 * clear interrupts
-			 */
-			if (request_wakeup(data))
-				continue;
-			nanohub_comms_tx_rx_retrans(data,
-						    CMD_COMMS_CLR_GET_INTR,
-						    (u8 *)clear_interrupts,
-						    sizeof(clear_interrupts),
-						    (u8 *)data->interrupts,
-						    sizeof(data->interrupts),
-						    false, 10, 0);
-			release_wakeup(data);
-			nanohub_set_state(data, ST_IDLE);
-		}
-	}
-
-	return 0;
-}
-
-struct iio_dev *nanohub_probe(struct device *dev, struct iio_dev *iio_dev)
-{
-	int ret, i;
-	/* const struct nanohub_platform_data *pdata;*/
-	struct nanohub_data *data;
-	struct nanohub_buf *buf;
-	bool own_iio_dev = !iio_dev;
-
-	if (own_iio_dev) {
-		iio_dev = devm_iio_device_alloc(dev,
-			sizeof(struct nanohub_data));
-		if (!iio_dev)
-			return ERR_PTR(-ENOMEM);
-	}
-	iio_dev->name = "nanohub";
-	iio_dev->dev.parent = dev;
-	iio_dev->info = &nanohub_iio_info;
-	iio_dev->driver_module = THIS_MODULE;
-	iio_dev->channels = NULL;
-	iio_dev->num_channels = 0;
-	data = iio_priv(iio_dev);
-	g_nanohub_data_p = data;
-	data->iio_dev = iio_dev;
-	/* data->pdata = pdata; */
-	data->pdata = devm_kzalloc(dev, sizeof(struct nanohub_platform_data),
-				   GFP_KERNEL);
-	init_waitqueue_head(&data->kthread_wait);
-
-	nanohub_io_init(&data->free_pool, data, dev);
-
-	buf = vmalloc(sizeof(*buf) * READ_QUEUE_DEPTH);
-	data->vbuf = buf;
-	if (!buf) {
-		ret = -ENOMEM;
-		goto fail_vma;
-	}
-
-	for (i = 0; i < READ_QUEUE_DEPTH; i++)
-		nanohub_io_put_buf(&data->free_pool, &buf[i]);
-	atomic_set(&data->kthread_run, 0);
-
-	data->ws = wakeup_source_register(NULL, "nanohub_wakelock_read");
-	if (!data->ws) {
-		pr_err("nanohub: wakeup source init fail\n");
-		ret = -ENOMEM;
-		goto fail_wakeup;
-	}
-
-	atomic_set(&data->lock_mode, LOCK_MODE_NONE);
-	atomic_set(&data->wakeup_cnt, 0);
-	atomic_set(&data->wakeup_lock_cnt, 0);
-	atomic_set(&data->wakeup_acquired, 0);
-	init_waitqueue_head(&data->wakeup_wait);
-	ret = iio_device_register(iio_dev);
-	if (ret) {
-		pr_err("nanohub: iio_device_register failed\n");
-		goto fail_irq;
-	}
-	ret = nanohub_create_devices(data);
-	if (ret)
-		goto fail_dev;
-	data->thread = kthread_run(nanohub_kthread, data, "nanohub");
-
-	usleep_range(25, 30);
-
-	return iio_dev;
-fail_dev:
-	iio_device_unregister(iio_dev);
-
-fail_irq:
-	wakeup_source_unregister(data->ws);
-fail_wakeup:
-	vfree(buf);
-fail_vma:
-	if (own_iio_dev)
-		iio_device_free(iio_dev);
-
-	return ERR_PTR(ret);
-}
-
-int nanohub_reset(struct nanohub_data *data)
-{
-	const struct nanohub_platform_data *pdata = data->pdata;
-
-	gpio_set_value(pdata->nreset_gpio, 1);
-	usleep_range(650000, 700000);
-	enable_irq(data->irq1);
-	if (data->irq2)
-		enable_irq(data->irq2);
-	else
-		nanohub_unmask_interrupt(data, 2);
-
-	return 0;
-}
-
-int nanohub_suspend(struct iio_dev *iio_dev)
-{
-	struct nanohub_data *data = iio_priv(iio_dev);
-
-	nanohub_mask_interrupt(data, 2);
-	return 0;
-}
-
-int nanohub_resume(struct iio_dev *iio_dev)
-{
-	struct nanohub_data *data = iio_priv(iio_dev);
-
-	nanohub_unmask_interrupt(data, 2);
-	return 0;
-}
-
-int __init nanohub_init(void)
-{
-	int ret = 0;
-
-	sensor_class = class_create(THIS_MODULE, "nanohub");
-	if (IS_ERR(sensor_class)) {
-		ret = PTR_ERR(sensor_class);
-		pr_err("nanohub: class_create failed; err=%d\n", ret);
-	}
-	if (!ret)
-		major = __register_chrdev(0, 0, ID_NANOHUB_MAX, "nanohub",
-					  &nanohub_fileops);
-
-	if (major < 0) {
-		ret = major;
-		major = 0;
-		pr_err("nanohub: can't register; err=%d\n", ret);
-	}
-
-#ifdef CONFIG_NANOHUB_I2C
-	if (ret == 0)
-		ret = nanohub_i2c_init();
-#endif
-#ifdef CONFIG_NANOHUB_SPI
-	if (ret == 0)
-		ret = nanohub_spi_init();
-#endif
-#ifdef CONFIG_NANOHUB_MTK_IPI
-		ret = nanohub_ipi_init();
-#endif
-	pr_info("nanohub: loaded; ret=%d\n", ret);
-	return ret;
-}
-
-void __exit nanohub_cleanup(void)
-{
-#ifdef CONFIG_NANOHUB_I2C
-	nanohub_i2c_cleanup();
-#endif
-#ifdef CONFIG_NANOHUB_SPI
-	nanohub_spi_cleanup();
-#endif
-	__unregister_chrdev(major, 0, ID_NANOHUB_MAX, "nanohub");
-	class_destroy(sensor_class);
-	major = 0;
-	sensor_class = 0;
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/main.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/main.h
deleted file mode 100644
index 9ec1655..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/main.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _NANOHUB_MAIN_H
-#define _NANOHUB_MAIN_H
-
-#include <linux/kernel.h>
-#include <linux/cdev.h>
-#include <linux/gpio.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/semaphore.h>
-#include <linux/pm_wakeup.h>
-
-#include "comms.h"
-#include "bl.h"
-
-#define NANOHUB_NAME "nanohub"
-
-struct nanohub_buf {
-	struct list_head list;
-	u8 buffer[255];
-	u8 length;
-};
-
-struct nanohub_data;
-
-struct nanohub_io {
-	struct device *dev;
-	struct nanohub_data *data;
-	wait_queue_head_t buf_wait;
-	struct list_head buf_list;
-};
-
-static inline struct nanohub_data *dev_get_nanohub_data(struct device *dev)
-{
-	struct nanohub_io *io = dev_get_drvdata(dev);
-
-	return io->data;
-}
-
-struct nanohub_data {
-	/* indices for io[] array */
-	#define ID_NANOHUB_SENSOR 0
-	#define ID_NANOHUB_COMMS 1
-	#define ID_NANOHUB_MAX 2
-
-	struct iio_dev *iio_dev;
-	struct nanohub_io io[ID_NANOHUB_MAX];
-
-	struct nanohub_comms comms;
-	struct nanohub_bl bl;
-	const struct nanohub_platform_data *pdata;
-	int irq1;
-	int irq2;
-
-	atomic_t kthread_run;
-	atomic_t thread_state;
-	wait_queue_head_t kthread_wait;
-
-	struct wakeup_source *ws;
-
-	struct nanohub_io free_pool;
-
-	atomic_t lock_mode;
-	/* these 3 vars should be accessed only with wakeup_wait.lock held */
-	atomic_t wakeup_cnt;
-	atomic_t wakeup_lock_cnt;
-	atomic_t wakeup_acquired;
-	wait_queue_head_t wakeup_wait;
-
-	u32 interrupts[8];
-
-	int err_cnt;
-	void *vbuf;
-	struct task_struct *thread;
-};
-
-enum {
-	KEY_WAKEUP_NONE,
-	KEY_WAKEUP,
-	KEY_WAKEUP_LOCK,
-};
-
-enum {
-	LOCK_MODE_NONE,
-	LOCK_MODE_NORMAL,
-	LOCK_MODE_IO,
-	LOCK_MODE_RESET,
-	LOCK_MODE_SUSPEND_RESUME,
-};
-
-int request_wakeup_ex(struct nanohub_data *data, long timeout,
-		      int key, int lock_mode);
-void release_wakeup_ex(struct nanohub_data *data, int key, int lock_mode);
-int nanohub_wait_for_interrupt(struct nanohub_data *data);
-int nanohub_wakeup_eom(struct nanohub_data *data, bool repeat);
-struct iio_dev *nanohub_probe(struct device *dev, struct iio_dev *iio_dev);
-int nanohub_reset(struct nanohub_data *data);
-int nanohub_remove(struct iio_dev *iio_dev);
-int nanohub_suspend(struct iio_dev *iio_dev);
-int nanohub_resume(struct iio_dev *iio_dev);
-
-static inline int nanohub_irq1_fired(struct nanohub_data *data)
-{
-	const struct nanohub_platform_data *pdata = data->pdata;
-
-	return !gpio_get_value(pdata->irq1_gpio);
-}
-
-static inline int nanohub_irq2_fired(struct nanohub_data *data)
-{
-	const struct nanohub_platform_data *pdata = data->pdata;
-
-	return data->irq2 && !gpio_get_value(pdata->irq2_gpio);
-}
-
-static inline int request_wakeup_timeout(struct nanohub_data *data, int timeout)
-{
-	return request_wakeup_ex(data, timeout, KEY_WAKEUP, LOCK_MODE_NORMAL);
-}
-
-static inline int request_wakeup(struct nanohub_data *data)
-{
-	return request_wakeup_ex(data, MAX_SCHEDULE_TIMEOUT, KEY_WAKEUP,
-				 LOCK_MODE_NORMAL);
-}
-
-static inline void release_wakeup(struct nanohub_data *data)
-{
-	release_wakeup_ex(data, KEY_WAKEUP, LOCK_MODE_NORMAL);
-}
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub-mtk.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub-mtk.c
deleted file mode 100644
index b1e72fb..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub-mtk.c
+++ /dev/null
@@ -1,277 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#include <linux/platform_device.h>
-#include <linux/delay.h>
-#include <linux/iio/iio.h>
-#include <linux/module.h>
-#include <linux/completion.h>
-#include <linux/workqueue.h>
-#include "main.h"
-#include "bl.h"
-#include "comms.h"
-#include "nanohub-mtk.h"
-#include "SCP_power_monitor.h"
-
-#define CHRE_IPI_DEBUG	0
-struct nanohub_ipi_rx_st {
-	u8 *buff;
-	int copy_size;
-	struct completion isr_comp;
-};
-
-struct nanohub_ipi_rx_st nanohub_ipi_rx;
-
-struct iio_dev *nanohub_iio_dev;
-struct semaphore scp_nano_ipi_sem;
-
-struct nanohub_ipi_data {
-	struct nanohub_data data;
-	/* todo */
-};
-
-/* scp_nano_ipi_status: 1 :ready to ipi  0:not ready*/
-int scp_nano_ipi_status;
-
-#define NANOHUB_IPI_SEND_RETRY 100
-void mtk_ipi_scp_isr_sim(int got_size)
-{
-	int token = got_size;
-	int ret;
-	int retry = NANOHUB_IPI_SEND_RETRY;
-	/* add retry to avoid SCP busy timeout */
-	while (retry-- && (READ_ONCE(scp_nano_ipi_status) == 1)) {
-		ret = scp_ipi_send(IPI_CHREX, &token, sizeof(token),
-				   0, SCP_A_ID);
-		if (ret != SCP_IPI_BUSY)
-			break;
-		usleep_range(100, 200);
-	}
-}
-
-static void nano_ipi_start(void)
-{
-	pr_info("%s notify\n", __func__);
-	WRITE_ONCE(scp_nano_ipi_status, 1);
-}
-
-static void nano_ipi_stop(void)
-{
-	pr_info("%s notify\n", __func__);
-	WRITE_ONCE(scp_nano_ipi_status, 0);
-}
-
-static int nano_ipi_event(u8 event, void *ptr)
-{
-	switch (event) {
-	case SENSOR_POWER_UP:
-		nano_ipi_start();
-		break;
-	case SENSOR_POWER_DOWN:
-		nano_ipi_stop();
-		break;
-	}
-	return 0;
-}
-
-static struct scp_power_monitor nano_ipi_notifier = {
-	.name = "nanohub_ipi",
-	.notifier_call = nano_ipi_event,
-};
-
-int nanohub_ipi_write(void *data, u8 *tx, int length, int timeout)
-{
-	int ret;
-	int retry = NANOHUB_IPI_SEND_RETRY;
-#if CHRE_IPI_DEBUG
-	int i;
-
-	pr_info("AP->(%d) ", length);
-	for (i = 0; i < length; i++)
-		pr_info("%02x ", tx[i]);
-	pr_info("\n");
-#endif
-	ret = SCP_IPI_ERROR;
-	while (retry-- && (READ_ONCE(scp_nano_ipi_status) == 1)) {
-		ret = scp_ipi_send(IPI_CHRE, tx, length, 0, SCP_A_ID);
-		if (ret != SCP_IPI_BUSY)
-			break;
-		usleep_range(100, 200);
-	}
-
-	if (ret == SCP_IPI_BUSY)
-		pr_info("%s ipi busy, ret=%d\n", __func__, ret);
-
-	if (ret == SCP_IPI_DONE)
-		return length;
-	else
-		return ERROR_NACK;
-}
-
-int nanohub_ipi_read(void *data, u8 *rx, int max_length, int timeout)
-{
-	int ret;
-	const int min_size = sizeof(struct nanohub_packet) +
-		 sizeof(struct nanohub_packet_crc);
-
-	if (max_length < min_size)
-		return -1;
-	/* todo: support interruptible? please check it! */
-	if (wait_for_completion_interruptible_timeout(&nanohub_ipi_rx.isr_comp,
-						      timeout) == 0) {
-		ret = 0;	/* return as empty packet */
-	} else {
-		ret = nanohub_ipi_rx.copy_size;
-		memcpy(rx, g_nanohub_data_p->comms.rx_buffer, ret);
-		/* send back isr sim */
-		mtk_ipi_scp_isr_sim(ret);
-	}
-#if CHRE_IPI_DEBUG
-	pr_info("%s ret %d\n", __func__, ret);
-#endif
-	return ret;	/* return packet size */
-}
-
-static int nanohub_ipi_open(void *data)
-{
-	down(&scp_nano_ipi_sem);
-	reinit_completion(&nanohub_ipi_rx.isr_comp); /*reset when retry start*/
-	return 0;
-}
-
-static void nanohub_ipi_close(void *data)
-{
-	up(&scp_nano_ipi_sem);
-}
-
-void nanohub_ipi_comms_init(struct nanohub_ipi_data *ipi_data)
-{
-	struct nanohub_comms *comms = &ipi_data->data.comms;
-
-	comms->seq = 1;
-	comms->timeout_write = msecs_to_jiffies(512);
-	comms->timeout_ack = msecs_to_jiffies(3);
-	comms->timeout_reply = msecs_to_jiffies(3);
-	comms->open = nanohub_ipi_open;
-	comms->close = nanohub_ipi_close;
-	comms->write = nanohub_ipi_write;
-	comms->read = nanohub_ipi_read;
-/*	comms->tx_buffer = kmalloc(4096, GFP_KERNEL | GFP_DMA); */
-	comms->rx_buffer = kmalloc(4096, GFP_KERNEL | GFP_DMA);
-	nanohub_ipi_rx.buff = comms->rx_buffer;
-	sema_init(&scp_nano_ipi_sem, 1);
-}
-
-static int nanohub_ipi_remove(struct platform_device *pdev);
-
-struct platform_device nanohub_ipi_pdev = {
-	.name = "nanohub_ipi",
-	.id = -1,
-};
-
-int nanohub_ipi_suspend(struct platform_device *dev, pm_message_t state)
-{
-	int ret = 0;
-
-	if (READ_ONCE(scp_nano_ipi_status) == 1)
-		ret = nanohub_suspend(nanohub_iio_dev);
-	else
-		ret = 0;
-
-	return ret;
-}
-
-int nanohub_ipi_resume(struct platform_device *dev)
-{
-	int ret = 0;
-
-	if (READ_ONCE(scp_nano_ipi_status) == 1)
-		ret = nanohub_resume(nanohub_iio_dev);
-	else
-		ret = 0;
-
-	return ret;
-}
-
-void scp_to_ap_ipi_handler(int id, void *data, unsigned int len)
-{
-#if CHRE_IPI_DEBUG
-	int i;
-	unsigned char *data_p = data;
-
-	pr_info("->AP(%d):", len);
-	for (i = 0; i < len; i++)
-		pr_info("%02x ", data_p[i]);
-	pr_info("\n");
-#endif
-	nanohub_ipi_rx.copy_size = len;
-	memcpy(g_nanohub_data_p->comms.rx_buffer, data, len);
-	/*todo: check size ? */
-	complete(&nanohub_ipi_rx.isr_comp);
-}
-
-int nanohub_ipi_probe(struct platform_device *pdev)
-{
-	struct nanohub_ipi_data *ipi_data;
-	struct iio_dev *iio_dev;
-	enum scp_ipi_status status;
-
-	iio_dev = iio_device_alloc(sizeof(struct nanohub_ipi_data));
-	if (!iio_dev)
-		return -ENOMEM;
-	nanohub_iio_dev = iio_dev;
-	/*iio_dev = nanohub_probe(&pdev->dev, iio_dev);*/
-	nanohub_probe(&nanohub_ipi_pdev.dev, iio_dev);
-	ipi_data = iio_priv(iio_dev);
-
-	nanohub_ipi_comms_init(ipi_data);
-	init_completion(&nanohub_ipi_rx.isr_comp);
-	status = scp_ipi_registration(IPI_CHRE,
-				      scp_to_ap_ipi_handler, "chre_ap_rx");
-	/*init nano scp ipi status*/
-	WRITE_ONCE(scp_nano_ipi_status, 1);
-	scp_power_monitor_register(&nano_ipi_notifier);
-
-	return 0;
-}
-
-static int nanohub_ipi_remove(struct platform_device *pdev)
-{
-	return 0;
-}
-
-static struct platform_driver nanohub_ipi_pdrv = {
-	.probe = nanohub_ipi_probe,
-	.remove = nanohub_ipi_remove,
-	.suspend = nanohub_ipi_suspend,
-	.resume = nanohub_ipi_resume,
-	.driver = {
-		.name = "nanohub_ipi",
-		.owner = THIS_MODULE,
-		/*.of_match_table = scpdvfs_of_ids,*/
-	},
-};
-
-int __init nanohub_ipi_init(void)
-{
-	int ret = 0;
-
-	ret = platform_device_register(&nanohub_ipi_pdev);
-	if (ret) {
-		pr_debug("nanohub_ipi_pdev fail\n");
-		goto _nanohub_ipi_init_exit;
-	}
-
-	ret = platform_driver_register(&nanohub_ipi_pdrv);
-	if (ret) {
-		pr_debug("nanohub_ipi_pdrv fail\n");
-		platform_device_unregister(&nanohub_ipi_pdev);
-		goto _nanohub_ipi_init_exit;
-	}
-	platform_set_drvdata(&nanohub_ipi_pdev, g_nanohub_data_p);
-
-_nanohub_ipi_init_exit:
-	return ret;
-}
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub-mtk.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub-mtk.h
deleted file mode 100644
index 67cc15b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub-mtk.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef _NANOHUB_MTK_IPI_H
-#define _NANOHUB_MTK_IPI_H
-
-#include <include/scp.h>
-#include <linux/notifier.h>
-
-int __init nanohub_ipi_init(void);
-extern struct nanohub_data *g_nanohub_data_p;
-void scp_wdt_reset(enum scp_core_id cpu_id);
-
-#endif
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub.h
deleted file mode 100644
index 67bdb83..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensorHub/nanohub/nanohub.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __LINUX_PLATFORM_DATA_NANOHUB_H
-#define __LINUX_PLATFORM_DATA_NANOHUB_H
-
-#include <linux/types.h>
-
-struct nanohub_flash_bank {
-	int bank;
-	u32 address;
-	size_t length;
-};
-
-struct nanohub_platform_data {
-	u32 wakeup_gpio;
-	u32 nreset_gpio;
-	u32 boot0_gpio;
-	u32 irq1_gpio;
-	u32 irq2_gpio;
-	u32 spi_cs_gpio;
-	u32 bl_addr;
-	u32 num_flash_banks;
-	struct nanohub_flash_bank *flash_banks;
-	u32 num_shared_flash_banks;
-	struct nanohub_flash_bank *shared_flash_banks;
-};
-
-#endif /* __LINUX_PLATFORM_DATA_NANOHUB_H */
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensor_probe/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensor_probe/Makefile
deleted file mode 100644
index f51eb5d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensor_probe/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/accelerometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/gyroscope/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/magnetometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/alsps/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/barometer/inc
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/step_counter
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/situation
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) += sensor_probe.o
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensor_probe/sensor_probe.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensor_probe/sensor_probe.c
deleted file mode 100644
index 5b91a11..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/sensor_probe/sensor_probe.c
+++ /dev/null
@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#include <linux/module.h>
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_ACCELEROMETER)
-#include "accel.h"
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_GYROSCOPE)
-#include "gyroscope.h"
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_MAGNETOMETER)
-#include "mag.h"
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_ALSPS)
-#include "alsps.h"
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_BAROMETER)
-#include "barometer.h"
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_STEP_COUNTER)
-#include "step_counter.h"
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_SITUATION)
-#include "situation.h"
-#endif
-
-static int __init sensor_init(void)
-{
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_ACCELEROMETER)
-	if (acc_probe())
-		pr_err("failed to register acc driver\n");
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_GYROSCOPE)
-	if (gyro_probe())
-		pr_err("failed to register gyro driver\n");
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_MAGNETOMETER)
-	if (mag_probe())
-		pr_err("failed to register mag driver\n");
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_ALSPS)
-	if (alsps_probe())
-		pr_err("failed to register alsps driver\n");
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_BAROMETER)
-	if (baro_probe())
-		pr_err("failed to register baro driver\n");
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_STEP_COUNTER)
-	if (step_c_probe())
-		pr_err("failed to register step_c driver\n");
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_SITUATION)
-	if (situation_probe()) {
-		pr_err("failed to register situ driver\n");
-		return -ENODEV;
-	}
-#endif
-
-	return 0;
-}
-
-static void __exit sensor_exit(void)
-{
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_ACCELEROMETER)
-	acc_remove();
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_GYROSCOPE)
-	gyro_remove();
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_MAGNETOMETER)
-	mag_remove();
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_ALSPS)
-	alsps_remove();
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_BAROMETER)
-	baro_remove();
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_STEP_COUNTER)
-	step_c_remove();
-#endif
-
-#if IS_ENABLED(CONFIG_CUSTOM_KERNEL_SITUATION)
-	situation_remove();
-#endif
-
-}
-
-late_initcall(sensor_init);
-module_exit(sensor_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("SensorProbe driver");
-MODULE_AUTHOR("Mediatek");
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/Kconfig
deleted file mode 100644
index 2d88815..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/Kconfig
+++ /dev/null
@@ -1,10 +0,0 @@
-config CUSTOM_KERNEL_SITUATION
-	bool "mediatek situation sensor tag"
-	help
-	  Kernel space support situation sensor driver.
-	  If the platform is supported for gesture, this
-	  configuration should be configured, and the situation
-	  driver configuration should be configured as well.
-
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Kconfig"
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/Makefile
deleted file mode 100644
index 00d3468..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-# In case the platform does NOT support this type of sensors
-
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)	+= situation.o
-obj-y += situation_hub/
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation.c
deleted file mode 100644
index 1803058..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation.c
+++ /dev/null
@@ -1,677 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2016 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<SITUATION> " fmt
-
-#include "situation.h"
-
-static struct situation_context *situation_context_obj;
-
-static struct situation_init_info *
-	situation_init_list[max_situation_support] = {0};
-
-static struct situation_context *situation_context_alloc_object(void)
-{
-	struct situation_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	int index;
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc situ object error!\n");
-		return NULL;
-	}
-	mutex_init(&obj->situation_op_mutex);
-	for (index = inpocket; index < max_situation_support; ++index) {
-		obj->ctl_context[index].power = 0;
-		obj->ctl_context[index].enable = 0;
-		obj->ctl_context[index].delay_ns = -1;
-		obj->ctl_context[index].latency_ns = -1;
-	}
-
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-
-static int handle_to_index(int handle)
-{
-	int index = -1;
-
-	switch (handle) {
-	case ID_IN_POCKET:
-		index = inpocket;
-		break;
-	case ID_STATIONARY_DETECT:
-		index = stationary;
-		break;
-	case ID_WAKE_GESTURE:
-		index = wake_gesture;
-		break;
-	case ID_GLANCE_GESTURE:
-		index = glance_gesture;
-		break;
-	case ID_PICK_UP_GESTURE:
-		index = pickup_gesture;
-		break;
-	case ID_ANSWER_CALL:
-		index = answer_call;
-		break;
-	case ID_MOTION_DETECT:
-		index = motion_detect;
-		break;
-	case ID_DEVICE_ORIENTATION:
-		index = device_orientation;
-		break;
-	case ID_TILT_DETECTOR:
-		index = tilt_detector;
-		break;
-	case ID_FLAT:
-		index = flat;
-		break;
-	case ID_SAR:
-		index = sar;
-		break;
-	default:
-		index = -1;
-		pr_err("%s invalid handle:%d,index:%d\n", __func__,
-			handle, index);
-		return index;
-	}
-	pr_debug("%s handle:%d, index:%d\n", __func__, handle, index);
-	return index;
-}
-
-int situation_data_report_t(int handle, uint32_t one_sample_data,
-	int64_t time_stamp)
-{
-	int err = 0, index = -1;
-	struct sensor_event event;
-	struct situation_context *cxt = situation_context_obj;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err_ratelimited("[%s] invalid index\n", __func__);
-		return -1;
-	}
-
-	pr_debug("situation_notify handle:%d, index:%d\n", handle, index);
-	event.time_stamp = time_stamp;
-	event.handle = handle;
-	event.flush_action = DATA_ACTION;
-	event.word[0] = one_sample_data;
-	err = sensor_input_event(situation_context_obj->mdev.minor, &event);
-	if (cxt->ctl_context[index].situation_ctl.open_report_data != NULL &&
-		cxt->ctl_context[index].situation_ctl.is_support_wake_lock)
-		__pm_wakeup_event(cxt->ws[index], 250);
-	return err;
-}
-EXPORT_SYMBOL_GPL(situation_data_report_t);
-
-int situation_data_report(int handle, uint32_t one_sample_data)
-{
-	return situation_data_report_t(handle, one_sample_data, 0);
-}
-int sar_data_report_t(int32_t value[3], int64_t time_stamp)
-{
-	int err = 0, index = -1;
-	struct sensor_event event;
-	struct situation_context *cxt = situation_context_obj;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	index = handle_to_index(ID_SAR);
-	if (index < 0) {
-		pr_err("[%s] invalid index\n", __func__);
-		return -1;
-	}
-	event.time_stamp = time_stamp;
-	event.handle = ID_SAR;
-	event.flush_action = DATA_ACTION;
-	event.word[0] = value[0];
-	event.word[1] = value[1];
-	event.word[2] = value[2];
-	err = sensor_input_event(situation_context_obj->mdev.minor, &event);
-	if (cxt->ctl_context[index].situation_ctl.open_report_data != NULL &&
-		cxt->ctl_context[index].situation_ctl.is_support_wake_lock)
-		__pm_wakeup_event(cxt->ws[index], 250);
-	return err;
-}
-int sar_data_report(int32_t value[3])
-{
-	return sar_data_report_t(value, 0);
-}
-int situation_notify_t(int handle, int64_t time_stamp)
-{
-	return situation_data_report_t(handle, 1, time_stamp);
-}
-EXPORT_SYMBOL_GPL(situation_notify_t);
-
-int situation_notify(int handle)
-{
-	return situation_data_report_t(handle, 1, 0);
-}
-int situation_flush_report(int handle)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-	pr_debug_ratelimited("flush, handle:%d\n", handle);
-	event.handle = handle;
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(situation_context_obj->mdev.minor, &event);
-	return err;
-}
-EXPORT_SYMBOL_GPL(situation_flush_report);
-
-#ifndef CONFIG_NANOHUB
-static int situation_enable_and_batch(int index)
-{
-	struct situation_context *cxt = situation_context_obj;
-	int err;
-
-	/* power on -> power off */
-	if (cxt->ctl_context[index].power == 1 &&
-		cxt->ctl_context[index].enable == 0) {
-		pr_debug("SITUATION disable\n");
-		/* turn off the power */
-		err = cxt->ctl_context[index].situation_ctl.open_report_data(0);
-		if (err) {
-			pr_err("situation turn off power err = %d\n",
-				err);
-			return -1;
-		}
-		pr_debug("situation turn off power done\n");
-
-		cxt->ctl_context[index].power = 0;
-		cxt->ctl_context[index].delay_ns = -1;
-		pr_debug("SITUATION disable done\n");
-		return 0;
-	}
-	/* power off -> power on */
-	if (cxt->ctl_context[index].power == 0 &&
-		cxt->ctl_context[index].enable == 1) {
-		pr_debug("SITUATION power on\n");
-		err = cxt->ctl_context[index].situation_ctl.open_report_data(1);
-		if (err) {
-			pr_err("situation turn on power err = %d\n",
-				err);
-			return -1;
-		}
-		pr_debug("situation turn on power done\n");
-
-		cxt->ctl_context[index].power = 1;
-		pr_debug("SITUATION power on done\n");
-	}
-	/* rate change */
-	if (cxt->ctl_context[index].power == 1 &&
-		cxt->ctl_context[index].delay_ns >= 0) {
-		pr_debug("SITUATION set batch\n");
-		/* set ODR, fifo timeout latency */
-		if (cxt->ctl_context[index].situation_ctl.is_support_batch)
-			err = cxt->ctl_context[index].situation_ctl.batch(0,
-				cxt->ctl_context[index].delay_ns,
-				cxt->ctl_context[index].latency_ns);
-		else
-			err = cxt->ctl_context[index].situation_ctl.batch(0,
-				cxt->ctl_context[index].delay_ns, 0);
-		if (err) {
-			pr_err("situation set batch(ODR) err %d\n",
-				err);
-			return -1;
-		}
-		pr_debug("situation set ODR, fifo latency done\n");
-	}
-	return 0;
-}
-#endif
-
-static ssize_t situactive_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	struct situation_context *cxt = situation_context_obj;
-	int err = 0, handle = -1, en = 0, index = -1;
-
-	err = sscanf(buf, "%d : %d", &handle, &en);
-	if (err < 0) {
-		pr_debug("%s param error: err = %d\n", __func__, err);
-		return err;
-	}
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err("[%s] invalid index\n", __func__);
-		return -1;
-	}
-	pr_debug("%s handle=%d, en=%d\n", __func__, handle, en);
-
-	mutex_lock(&situation_context_obj->situation_op_mutex);
-	if (en == 1)
-		cxt->ctl_context[index].enable = 1;
-	else if (en == 0)
-		cxt->ctl_context[index].enable = 0;
-	else {
-		pr_err("%s error !!\n", __func__);
-		err = -1;
-		goto err_out;
-	}
-#ifdef CONFIG_NANOHUB
-	if (cxt->ctl_context[index].enable == 1) {
-		if (cxt->ctl_context[index].situation_ctl.open_report_data
-			== NULL) {
-			pr_err("open_report_data() is NULL, %d\n", index);
-			goto err_out;
-		}
-		err = cxt->ctl_context[index].situation_ctl.open_report_data(1);
-		if (err) {
-			pr_err("situation turn on power err = %d\n", err);
-			goto err_out;
-		}
-	} else {
-		if (cxt->ctl_context[index].situation_ctl.open_report_data
-			== NULL) {
-			pr_err("open_report_data() is NULL, %d\n", index);
-			goto err_out;
-		}
-		err = cxt->ctl_context[index].situation_ctl.open_report_data(0);
-		if (err) {
-			pr_err("situation turn off power err = %d\n", err);
-			goto err_out;
-		}
-	}
-#else
-	err = situation_enable_and_batch(index);
-#endif
-	pr_debug("%s done\n", __func__);
-err_out:
-	mutex_unlock(&situation_context_obj->situation_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-/*----------------------------------------------------------------------------*/
-static ssize_t situactive_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	struct situation_context *cxt = NULL;
-	int i;
-	int s_len = 0;
-
-	cxt = situation_context_obj;
-	for (i = 0; i < max_situation_support; i++) {
-		pr_debug("situ handle:%d active: %d\n",
-			i, cxt->ctl_context[i].is_active_data);
-		s_len += snprintf(buf + s_len, PAGE_SIZE, "id:%d, en:%d\n",
-			i, cxt->ctl_context[i].is_active_data);
-	}
-	return s_len;
-}
-
-static ssize_t situbatch_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	struct situation_context *cxt = situation_context_obj;
-	int index = -1, handle = 0, flag = 0, err = 0;
-	int64_t samplingPeriodNs = 0, maxBatchReportLatencyNs = 0;
-
-	err = sscanf(buf, "%d,%d,%lld,%lld",
-		&handle, &flag, &samplingPeriodNs, &maxBatchReportLatencyNs);
-	if (err != 4) {
-		pr_err("%s param error: err =%d\n", __func__, err);
-		return err;
-	}
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err("[%s] invalid handle\n", __func__);
-		return -1;
-	}
-	pr_debug("handle %d, flag:%d, Period:%lld, Latency: %lld\n",
-		handle, flag, samplingPeriodNs, maxBatchReportLatencyNs);
-
-	cxt->ctl_context[index].delay_ns = samplingPeriodNs;
-	cxt->ctl_context[index].latency_ns = maxBatchReportLatencyNs;
-	mutex_lock(&situation_context_obj->situation_op_mutex);
-#ifdef CONFIG_NANOHUB
-	if (cxt->ctl_context[index].delay_ns >= 0) {
-		if (cxt->ctl_context[index].situation_ctl.batch == NULL) {
-			pr_err("batch() is NULL, %d\n", index);
-			goto err_out;
-		}
-		if (cxt->ctl_context[index].situation_ctl.is_support_batch)
-			err = cxt->ctl_context[index].situation_ctl.batch(0,
-				cxt->ctl_context[index].delay_ns,
-				cxt->ctl_context[index].latency_ns);
-		else
-			err = cxt->ctl_context[index].situation_ctl.batch(0,
-				cxt->ctl_context[index].delay_ns, 0);
-		if (err) {
-			pr_err("situation set batch(ODR) err %d\n", err);
-			goto err_out;
-		}
-	} else
-		pr_info("batch state no need change\n");
-#else
-	err = situation_enable_and_batch(index);
-#endif
-	pr_debug("%s done\n", __func__);
-err_out:
-	mutex_unlock(&situation_context_obj->situation_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t situbatch_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-static ssize_t situflush_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	struct situation_context *cxt = NULL;
-	int index = -1, handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err=%d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&situation_context_obj->situation_op_mutex);
-	cxt = situation_context_obj;
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err("[%s] invalid index\n", __func__);
-		mutex_unlock(&situation_context_obj->situation_op_mutex);
-		return  -1;
-	}
-	if (cxt->ctl_context[index].situation_ctl.flush != NULL)
-		err = cxt->ctl_context[index].situation_ctl.flush();
-	else
-		pr_err("SITUATION OLD ARCH NOT SUPPORT COMM FLUSH\n");
-	if (err < 0)
-		pr_err("situation enable flush err %d\n", err);
-	mutex_unlock(&situation_context_obj->situation_op_mutex);
-	if (err)
-		return err;
-	else
-		return count;
-}
-
-static ssize_t situflush_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-static ssize_t situdevnum_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);	/* TODO: why +5? */
-}
-
-
-static int situation_real_driver_init(void)
-{
-	int err = -1, i = 0;
-
-	pr_debug("%s start\n", __func__);
-
-	for (i = 0; i < max_situation_support; i++) {
-		if (situation_init_list[i] != NULL) {
-			pr_debug(" situ try to init driver %s\n",
-				situation_init_list[i]->name);
-			err = situation_init_list[i]->init();
-			if (err == 0)
-				pr_debug(" situ real driver %s probe ok\n",
-				situation_init_list[i]->name);
-		} else
-			continue;
-	}
-	return err;
-}
-
-
-int situation_driver_add(struct situation_init_info *obj, int handle)
-{
-	int err = 0;
-	int index = -1;
-
-	pr_debug("register situation handle=%d\n", handle);
-
-	if (!obj) {
-		pr_err("[%s] fail, situation_init_info is NULL\n",
-			__func__);
-		return -1;
-	}
-
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err("[%s] invalid index\n", __func__);
-		return  -1;
-	}
-
-	if (situation_init_list[index] == NULL)
-		situation_init_list[index] = obj;
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(situation_driver_add);
-static int situation_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t situation_read(struct file *file, char __user *buffer,
-			  size_t count, loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(situation_context_obj->mdev.minor,
-		file, buffer, count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int situation_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(situation_context_obj->mdev.minor, file, wait);
-}
-
-static const struct file_operations situation_fops = {
-	.owner = THIS_MODULE,
-	.open = situation_open,
-	.read = situation_read,
-	.poll = situation_poll,
-};
-
-static int situation_misc_init(struct situation_context *cxt)
-{
-	int err = 0;
-
-	cxt->mdev.minor = ID_WAKE_GESTURE; /* MISC_DYNAMIC_MINOR; */
-	cxt->mdev.name = SITU_MISC_DEV_NAME;
-	cxt->mdev.fops = &situation_fops;
-	err = sensor_attr_register(&cxt->mdev);
-	if (err)
-		pr_err("unable to register situ misc device!!\n");
-
-	return err;
-}
-
-DEVICE_ATTR_RW(situactive);
-DEVICE_ATTR_RW(situbatch);
-DEVICE_ATTR_RW(situflush);
-DEVICE_ATTR_RO(situdevnum);
-
-static struct attribute *situation_attributes[] = {
-	&dev_attr_situactive.attr,
-	&dev_attr_situbatch.attr,
-	&dev_attr_situflush.attr,
-	&dev_attr_situdevnum.attr,
-	NULL
-};
-
-static struct attribute_group situation_attribute_group = {
-	.attrs = situation_attributes
-};
-
-int situation_register_data_path(struct situation_data_path *data,
-	int handle)
-{
-	struct situation_context *cxt = NULL;
-	int index = -1;
-
-	if (NULL == data || NULL == data->get_data) {
-		pr_debug("situ register data path fail\n");
-		return -1;
-	}
-
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err("[%s] invalid handle\n", __func__);
-		return -1;
-	}
-	cxt = situation_context_obj;
-	cxt->ctl_context[index].situation_data.get_data = data->get_data;
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(situation_register_data_path);
-
-int situation_register_control_path(struct situation_control_path *ctl,
-	int handle)
-{
-	struct situation_context *cxt = NULL;
-	int index = -1;
-
-	pr_debug("%s\n", __func__);
-	if (NULL == ctl || NULL == ctl->open_report_data) {
-		pr_debug("situ register control path fail\n");
-		return -1;
-	}
-
-	index = handle_to_index(handle);
-	if (index < 0) {
-		pr_err("[%s] invalid handle\n", __func__);
-		return -1;
-	}
-	cxt = situation_context_obj;
-	cxt->ctl_context[index].situation_ctl.open_report_data =
-		ctl->open_report_data;
-	cxt->ctl_context[index].situation_ctl.batch = ctl->batch;
-	cxt->ctl_context[index].situation_ctl.flush = ctl->flush;
-	cxt->ctl_context[index].situation_ctl.is_support_wake_lock =
-		ctl->is_support_wake_lock;
-	cxt->ctl_context[index].situation_ctl.is_support_batch =
-		ctl->is_support_batch;
-
-	cxt->wake_lock_name[index] = kzalloc(64, GFP_KERNEL);
-	if (!cxt->wake_lock_name[index])
-		return -1;
-	sprintf(cxt->wake_lock_name[index], "situation_wakelock-%d", index);
-	cxt->ws[index] = wakeup_source_register(NULL,
-						cxt->wake_lock_name[index]);
-	if (!cxt->ws[index]) {
-		pr_err("%s: wakeup source init fail\n", __func__);
-		return -ENOMEM;
-	}
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(situation_register_control_path);
-
-int situation_probe(void)
-{
-	int err;
-
-	pr_debug("%s+++!!\n", __func__);
-
-	situation_context_obj = situation_context_alloc_object();
-	if (!situation_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-	/* init real situ driver */
-	err = situation_real_driver_init();
-	if (err) {
-		pr_err("situ real driver init fail\n");
-		goto real_driver_init_fail;
-	}
-
-	/* add misc dev for sensor hal control cmd */
-	err = situation_misc_init(situation_context_obj);
-	if (err) {
-		pr_err("unable to register situ misc device!!\n");
-		goto real_driver_init_fail;
-	}
-	err = sysfs_create_group(&situation_context_obj->mdev.this_device->kobj,
-		&situation_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create situ attribute file\n");
-		goto real_driver_init_fail;
-	}
-	kobject_uevent(&situation_context_obj->mdev.this_device->kobj,
-		KOBJ_ADD);
-
-
-	pr_debug("%s OK !!\n", __func__);
-	return 0;
-
-real_driver_init_fail:
-	kfree(situation_context_obj);
-exit_alloc_data_failed:
-	pr_debug("%s fail !!!\n", __func__);
-	return err;
-}
-EXPORT_SYMBOL_GPL(situation_probe);
-
-int situation_remove(void)
-{
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-	sysfs_remove_group(&situation_context_obj->mdev.this_device->kobj,
-		&situation_attribute_group);
-
-	err = sensor_attr_deregister(&situation_context_obj->mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-
-	kfree(situation_context_obj);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(situation_remove);
-
-static int __init situation_init(void)
-{
-	pr_debug("%s\n", __func__);
-
-	return 0;
-}
-
-static void __exit situation_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-late_initcall(situation_init);
-module_exit(situation_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("situation sensor driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation.h
deleted file mode 100644
index 3e81fc7..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __SITUATION_H__
-#define __SITUATION_H__
-
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <hwmsensor.h>
-#include <linux/poll.h>
-#include "sensor_attr.h"
-#include "sensor_event.h"
-#include <linux/pm_wakeup.h>
-
-enum situation_index_table {
-	inpocket = 0,
-	stationary,
-	wake_gesture,
-	pickup_gesture,
-	glance_gesture,
-	answer_call,
-	motion_detect,
-	device_orientation,
-	tilt_detector,
-	flat,
-	sar,
-	max_situation_support,
-};
-
-struct situation_control_path {
-	int (*open_report_data)(int open);
-	int (*batch)(int flag, int64_t samplingPeriodNs,
-		int64_t maxBatchReportLatencyNs);
-	int (*flush)(void);
-	bool is_support_wake_lock;
-	bool is_support_batch;
-};
-
-struct situation_data_path {
-	int (*get_data)(int *value, int *status);
-};
-
-struct situation_init_info {
-	char *name;
-	int (*init)(void);
-	int (*uninit)(void);
-};
-
-struct situation_data_control_context {
-	struct situation_control_path situation_ctl;
-	struct situation_data_path situation_data;
-	bool is_active_data;
-	bool is_active_nodata;
-	bool is_batch_enable;
-	int power;
-	int enable;
-	int64_t delay_ns;
-	int64_t latency_ns;
-};
-
-struct situation_context {
-	struct sensor_attr_t mdev;
-	struct mutex situation_op_mutex;
-	struct situation_data_control_context
-		ctl_context[max_situation_support];
-	struct wakeup_source *ws[max_situation_support];
-	char *wake_lock_name[max_situation_support];
-};
-
-extern int situation_data_report_t(int handle, uint32_t one_sample_data,
-	int64_t time_stamp);
-extern int situation_data_report(int handle, uint32_t one_sample_data);
-extern int situation_notify_t(int handle, int64_t time_stamp);
-extern int situation_notify(int handle);
-extern int situation_flush_report(int handle);
-extern int situation_driver_add(struct situation_init_info *obj, int handle);
-extern int situation_register_control_path(
-	struct situation_control_path *ctl, int handle);
-extern int situation_register_data_path(struct situation_data_path *data,
-	int handle);
-extern int sar_data_report(int32_t value[3]);
-extern int sar_data_report_t(int32_t value[3], int64_t time_stamp);
-extern int situation_probe(void);
-extern int situation_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Kconfig
deleted file mode 100644
index e5e9218..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Kconfig
+++ /dev/null
@@ -1,11 +0,0 @@
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/Kconfig"
-source "drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/Kconfig"
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Makefile
deleted file mode 100644
index 5a6cc86..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/Makefile
+++ /dev/null
@@ -1,18 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/situation
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp/
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)	+= situationhub.o
-situationhub-y := situation_hub.o
-situationhub-$(CONFIG_MTK_INPKHUB) += inpocket/inpocket.o
-situationhub-$(CONFIG_MTK_STATHUB) += stationary/stationary.o
-situationhub-$(CONFIG_MTK_WAKEHUB) += wake_gesture/wake_gesture.o
-situationhub-$(CONFIG_MTK_GLGHUB) += glance_gesture/glance_gesture.o
-situationhub-$(CONFIG_MTK_PICKUPHUB) += pickup_gesture/pickup_gesture.o
-situationhub-$(CONFIG_MTK_ANSWER_CALL_HUB) += answercall/ancallhub.o
-situationhub-$(CONFIG_MTK_DEVICE_ORIENTATION_HUB) += device_orientation/device_orientation.o
-situationhub-$(CONFIG_MTK_MOTION_DETECT_HUB) += motion_detect/motion_detect.o
-situationhub-$(CONFIG_MTK_TILTDETECTHUB) += tilt_detector/tiltdetecthub.o
-situationhub-$(CONFIG_MTK_FLAT_HUB) += flat/flat.o
-situationhub-$(CONFIG_MTK_SAR_HUB) += sar/sarhub.o sar/sar_factory.o
\ No newline at end of file
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/Kconfig
deleted file mode 100644
index aff9e86..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_ANSWER_CALL_HUB
-	bool "glghub for MediaTek package"
-	help
-	  A answer call is a device,
-	  usually portable and electronic
-	  or electromechanical,
-	  that detect answer call a person takes.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/ancallhub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/ancallhub.c
deleted file mode 100644
index 76a93eb..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/ancallhub.c
+++ /dev/null
@@ -1,138 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[ancallhub] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "ancallhub.h"
-#include <situation.h>
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-
-enum ANCALLHUB_TRC {
-	ANCALLHUBH_TRC_INFO = 0X10,
-};
-
-static struct situation_init_info ancallhub_init_info;
-
-static int answer_call_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_ANSWER_CALL, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int answer_call_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_ANSWER_CALL, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	pr_debug("%s : type=%d, open=%d\n", __func__, ID_ANSWER_CALL, open);
-	ret = sensor_enable_to_hub(ID_ANSWER_CALL, open);
-	return ret;
-}
-static int answer_call_gesture_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_ANSWER_CALL,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int answer_call_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("answer_call do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_ANSWER_CALL,
-				(int64_t)event->time_stamp);
-	return err;
-}
-
-static int ancallhub_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = answer_call_open_report_data;
-	ctl.batch = answer_call_gesture_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_ANSWER_CALL);
-	if (err) {
-		pr_err("register answer_call control path err\n");
-		goto exit;
-	}
-
-	data.get_data = answer_call_get_data;
-	err = situation_register_data_path(&data, ID_ANSWER_CALL);
-	if (err) {
-		pr_err("register answer_call data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_ANSWER_CALL,
-		answer_call_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int ancallhub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info ancallhub_init_info = {
-	.name = "answer_call_hub",
-	.init = ancallhub_local_init,
-	.uninit = ancallhub_local_uninit,
-};
-
-int __init ancallhub_init(void)
-{
-	situation_driver_add(&ancallhub_init_info, ID_ANSWER_CALL);
-	return 0;
-}
-
-void __exit ancallhub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/ancallhub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/ancallhub.h
deleted file mode 100644
index d1588ae..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/answercall/ancallhub.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef ANSWERCALLHUB_H
-#define ANSWERCALLHUB_H
-
-#include <linux/ioctl.h>
-
-int __init ancallhub_init(void);
-void __exit ancallhub_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/Kconfig
deleted file mode 100644
index d5edef4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_DEVICE_ORIENTATION_HUB
-	bool "device orientation hub for MediaTek package"
-	help
-	  A device orientation is a device,
-	  usually portable and
-	  electronic or electromechanical,
-	  that detect device's orientation.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/device_orientation.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/device_orientation.c
deleted file mode 100644
index b5cffb9..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/device_orientation.c
+++ /dev/null
@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[device_orientation] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "situation.h"
-#include "device_orientation.h"
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static struct situation_init_info device_orientation_init_info;
-static int device_orientation_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_DEVICE_ORIENTATION, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int device_orientation_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_DEVICE_ORIENTATION, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	pr_debug("%s : type=%d, open=%d\n",
-		__func__, ID_DEVICE_ORIENTATION, open);
-	ret = sensor_enable_to_hub(ID_DEVICE_ORIENTATION, open);
-	return ret;
-}
-static int device_orientation_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_DEVICE_ORIENTATION,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int device_orientation_flush(void)
-{
-	return sensor_flush_to_hub(ID_DEVICE_ORIENTATION);
-}
-static int device_orientation_recv_data(struct data_unit_t *event,
-	void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = situation_flush_report(ID_DEVICE_ORIENTATION);
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_data_report_t(ID_DEVICE_ORIENTATION,
-			event->tilt_event.state, (int64_t)event->time_stamp);
-	return err;
-}
-
-static int device_orientation_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = device_orientation_open_report_data;
-	ctl.batch = device_orientation_batch;
-	ctl.flush = device_orientation_flush,
-	ctl.is_support_wake_lock = false;
-	ctl.is_support_batch = false;
-	err = situation_register_control_path(&ctl, ID_DEVICE_ORIENTATION);
-	if (err) {
-		pr_err("register stationary control path err\n");
-		goto exit;
-	}
-
-	data.get_data = device_orientation_get_data;
-	err = situation_register_data_path(&data, ID_DEVICE_ORIENTATION);
-	if (err) {
-		pr_err("register stationary data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_DEVICE_ORIENTATION,
-		device_orientation_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int device_orientation_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info device_orientation_init_info = {
-	.name = "device_orientation_hub",
-	.init = device_orientation_local_init,
-	.uninit = device_orientation_local_uninit,
-};
-
-int __init device_orientation_init(void)
-{
-	situation_driver_add(&device_orientation_init_info,
-		ID_DEVICE_ORIENTATION);
-	return 0;
-}
-
-void __exit device_orientation_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/device_orientation.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/device_orientation.h
deleted file mode 100644
index bfb5d37..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/device_orientation/device_orientation.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef DEVICE_ORIENTATION_H
-#define DEVICE_ORIENTATION_H
-
-#include <linux/ioctl.h>
-
-int __init device_orientation_init(void);
-void __exit device_orientation_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/Kconfig
deleted file mode 100644
index 67742bf..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/Kconfig
+++ /dev/null
@@ -1,4 +0,0 @@
-config MTK_FLAT_HUB
-	bool "flat for MediaTek package"
-	help
-	  Put the device lie on the table.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/flat.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/flat.c
deleted file mode 100644
index 69a0488..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/flat.c
+++ /dev/null
@@ -1,138 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "flat.h"
-#include "situation.h"
-
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static int flat_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_FLAT, &data);
-	if (err < 0) {
-		pr_warn("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp = data.time_stamp;
-	*probability = data.gesture_data_t.probability;
-	pr_debug("recv ipi: timestamp: %lld, probability: %d!\n", time_stamp,
-		*probability);
-	return 0;
-}
-
-static int flat_open_report_data(int open)
-{
-	int ret = 0;
-
-	pr_debug("%s : enable=%d\n", __func__, open);
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_FLAT, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-
-	ret = sensor_enable_to_hub(ID_FLAT, open);
-	return ret;
-}
-
-static int flat_batch(int flag, int64_t samplingPeriodNs,
-		int64_t maxBatchReportLatencyNs)
-{
-	pr_debug("%s : flag=%d\n", __func__, flag);
-
-	return sensor_batch_to_hub(ID_FLAT, flag, samplingPeriodNs,
-			maxBatchReportLatencyNs);
-}
-
-static int flat_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_warn("flat do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_FLAT, (int64_t)event->time_stamp);
-	return err;
-}
-
-static int flat_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = flat_open_report_data;
-	ctl.batch = flat_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_FLAT);
-	if (err) {
-		pr_warn("register flat control path err\n");
-		goto exit;
-	}
-
-	data.get_data = flat_get_data;
-	err = situation_register_data_path(&data, ID_FLAT);
-	if (err) {
-		pr_warn("register flat data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_FLAT, flat_recv_data);
-	if (err) {
-		pr_warn("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int flat_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info flat_init_info = {
-	.name = "flat_hub",
-	.init = flat_local_init,
-	.uninit = flat_local_uninit,
-};
-
-int __init flat_init(void)
-{
-	situation_driver_add(&flat_init_info, ID_FLAT);
-	return 0;
-}
-
-void __exit flat_exit(void)
-{
-	pr_debug("flat exit\n");
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/flat.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/flat.h
deleted file mode 100644
index 906f71c..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/flat/flat.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef FLAT_H
-#define FLAT_H
-
-#include <linux/ioctl.h>
-
-int __init flat_init(void);
-void __exit flat_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/Kconfig
deleted file mode 100644
index 8dd75e8..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/Kconfig
+++ /dev/null
@@ -1,7 +0,0 @@
-config MTK_GLGHUB
-	bool "glghub for MediaTek package"
-	help
-	  A glance gesture is a device,
-	  usually portable and electronic
-	  or electromechanical,
-	  that detect glance action a person takes.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/glance_gesture.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/glance_gesture.c
deleted file mode 100644
index 9852e84..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/glance_gesture.c
+++ /dev/null
@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[glghub] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "glance_gesture.h"
-#include <situation.h>
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-enum GLGHUB_TRC {
-	GLGHUBH_TRC_INFO = 0X10,
-};
-
-static struct situation_init_info glghub_init_info;
-
-static int glance_gesture_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_GLANCE_GESTURE, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int glance_gesture_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_GLANCE_GESTURE, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	ret = sensor_enable_to_hub(ID_GLANCE_GESTURE, open);
-	return ret;
-}
-static int glance_gesture_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_GLANCE_GESTURE,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int glance_gesture_recv_data(struct data_unit_t *event,
-	void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("glance_gesture do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_GLANCE_GESTURE,
-				(int64_t)event->time_stamp);
-	return err;
-}
-
-static int glghub_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = glance_gesture_open_report_data;
-	ctl.batch = glance_gesture_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_GLANCE_GESTURE);
-	if (err) {
-		pr_err("register glance_gesture control path err\n");
-		goto exit;
-	}
-
-	data.get_data = glance_gesture_get_data;
-	err = situation_register_data_path(&data, ID_GLANCE_GESTURE);
-	if (err) {
-		pr_err("register glance_gesture data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_GLANCE_GESTURE,
-		glance_gesture_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int glghub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info glghub_init_info = {
-	.name = "glance_gesture_hub",
-	.init = glghub_local_init,
-	.uninit = glghub_local_uninit,
-};
-
-int __init glghub_init(void)
-{
-	situation_driver_add(&glghub_init_info, ID_GLANCE_GESTURE);
-	return 0;
-}
-
-void __exit glghub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/glance_gesture.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/glance_gesture.h
deleted file mode 100644
index 9c4717d..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/glance_gesture/glance_gesture.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef GLGHUB_H
-#define GLGHUB_H
-
-#include <linux/ioctl.h>
-
-int __init glghub_init(void);
-void __exit glghub_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/Kconfig
deleted file mode 100644
index 84c1add..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_INPKHUB
-	bool "inpocket for MediaTek package"
-	help
-	  A in pocket is a device,
-	  usually portable
-	  and electronic or electromechanical,
-	  that detect device's position.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/inpocket.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/inpocket.c
deleted file mode 100644
index db31927..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/inpocket.c
+++ /dev/null
@@ -1,142 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[inpocket] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "inpocket.h"
-#include "situation.h"
-
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static struct situation_init_info inpocket_init_info;
-
-static int inpocket_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_IN_POCKET, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int inpocket_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_IN_POCKET, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	pr_debug("%s : type=%d, open=%d\n", __func__, ID_IN_POCKET, open);
-	ret = sensor_enable_to_hub(ID_IN_POCKET, open);
-	return ret;
-}
-static int inpocket_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_IN_POCKET,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int inpocket_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("inpocket do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_IN_POCKET,
-				(int64_t)event->time_stamp);
-	return err;
-}
-
-static int inpocket_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-
-	ctl.open_report_data = inpocket_open_report_data;
-	ctl.batch = inpocket_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_IN_POCKET);
-	if (err) {
-		pr_err("register in_pocket control path err\n");
-		goto exit;
-	}
-
-	data.get_data = inpocket_get_data;
-	err = situation_register_data_path(&data, ID_IN_POCKET);
-	if (err) {
-		pr_err("register in_pocket data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_IN_POCKET, inpocket_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int inpocket_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info inpocket_init_info = {
-	.name = "in_pocket_hub",
-	.init = inpocket_local_init,
-	.uninit = inpocket_local_uninit,
-};
-
-int __init inpocket_init(void)
-{
-	situation_driver_add(&inpocket_init_info, ID_IN_POCKET);
-	return 0;
-}
-
-void __exit inpocket_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(inpocket_init);
-module_exit(inpocket_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("InPocket driver");
-MODULE_AUTHOR("qiangming.xia@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/inpocket.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/inpocket.h
deleted file mode 100644
index cc69c0b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/inpocket/inpocket.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef INPOCKETHUB_H
-#define INPOCKETHUB_H
-
-#include <linux/ioctl.h>
-
-int __init inpocket_init(void);
-void __exit inpocket_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/Kconfig
deleted file mode 100644
index 16d8287..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_MOTION_DETECT_HUB
-	bool "motion detect hub for MediaTek package"
-	help
-	  A motion detection is a device,
-	  usually portable
-	  and electronic or electromechanical,
-	  that detect device is moved.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/motion_detect.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/motion_detect.c
deleted file mode 100644
index 037bdc8..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/motion_detect.c
+++ /dev/null
@@ -1,136 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[motion_detect] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "situation.h"
-#include "motion_detect.h"
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static struct situation_init_info motion_detect_init_info;
-static int motion_detect_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_MOTION_DETECT, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int motion_detect_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_MOTION_DETECT, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	pr_debug("%s : type=%d, open=%d\n",
-		__func__, ID_MOTION_DETECT, open);
-	ret = sensor_enable_to_hub(ID_MOTION_DETECT, open);
-	return ret;
-}
-static int motion_detect_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_MOTION_DETECT,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int motion_detect_recv_data(struct data_unit_t *event,
-	void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("stat do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_MOTION_DETECT,
-				(int64_t)event->time_stamp);
-	return err;
-}
-
-static int motion_detect_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = motion_detect_open_report_data;
-	ctl.batch = motion_detect_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_MOTION_DETECT);
-	if (err) {
-		pr_err("register stationary control path err\n");
-		goto exit;
-	}
-
-	data.get_data = motion_detect_get_data;
-	err = situation_register_data_path(&data, ID_MOTION_DETECT);
-	if (err) {
-		pr_err("register stationary data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_MOTION_DETECT,
-		motion_detect_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int motion_detect_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info motion_detect_init_info = {
-	.name = "motion_detect_hub",
-	.init = motion_detect_local_init,
-	.uninit = motion_detect_local_uninit,
-};
-
-int __init motion_detect_init(void)
-{
-	situation_driver_add(&motion_detect_init_info, ID_MOTION_DETECT);
-	return 0;
-}
-
-void __exit motion_detect_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/motion_detect.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/motion_detect.h
deleted file mode 100644
index 30a7aec..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/motion_detect/motion_detect.h
+++ /dev/null
@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef MOTION_DETECT_H
-#define MOTION_DETECT_H
-
-#include <linux/ioctl.h>
-
-int __init motion_detect_init(void);
-void __exit motion_detect_exit(void);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/Kconfig
deleted file mode 100644
index ea2af38..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_PICKUPHUB
-	bool "pickuphub for MediaTek package"
-	help
-	  A pick up is a device,
-	  usually portable
-	  and electronic or electromechanical,
-	  that detect device is picked up.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/pickup_gesture.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/pickup_gesture.c
deleted file mode 100644
index bd3edad..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/pickup_gesture.c
+++ /dev/null
@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[pkuphub] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "pickup_gesture.h"
-#include <situation.h>
-#include <hwmsen_helper.h>
-
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-enum PKUPHUB_TRC {
-	PKUPHUB_TRC_INFO = 0X10,
-};
-
-static struct situation_init_info pkuphub_init_info;
-
-static int pickup_gesture_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_PICK_UP_GESTURE, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp = data.time_stamp;
-	*probability = data.gesture_data_t.probability;
-	return 0;
-}
-
-static int pickup_gesture_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_PICK_UP_GESTURE, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	ret = sensor_enable_to_hub(ID_PICK_UP_GESTURE, open);
-	return ret;
-}
-static int pickup_gesture_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_PICK_UP_GESTURE,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int pickup_gesture_recv_data(struct data_unit_t *event,
-	void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("pickup_gesture do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_PICK_UP_GESTURE,
-				(int64_t)event->time_stamp);
-	return err;
-}
-
-static int pkuphub_local_init(void)
-{
-	struct situation_control_path ctl = { 0 };
-	struct situation_data_path data = { 0 };
-	int err = 0;
-
-	ctl.open_report_data = pickup_gesture_open_report_data;
-	ctl.batch = pickup_gesture_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_PICK_UP_GESTURE);
-	if (err) {
-		pr_err("register pickup_gesture control path err\n");
-		goto exit;
-	}
-
-	data.get_data = pickup_gesture_get_data;
-	err = situation_register_data_path(&data, ID_PICK_UP_GESTURE);
-	if (err) {
-		pr_err("register pickup_gesture data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_PICK_UP_GESTURE,
-		pickup_gesture_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-
-static int pkuphub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info pkuphub_init_info = {
-	.name = "pickup_gesture_hub",
-	.init = pkuphub_local_init,
-	.uninit = pkuphub_local_uninit,
-};
-
-int __init pkuphub_init(void)
-{
-	situation_driver_add(&pkuphub_init_info, ID_PICK_UP_GESTURE);
-	return 0;
-}
-
-void __exit pkuphub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/pickup_gesture.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/pickup_gesture.h
deleted file mode 100644
index 1e2d205..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/pickup_gesture/pickup_gesture.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef PICKUPHUB_H
-#define PICKUPHUB_H
-
-#include <linux/ioctl.h>
-
-int __init pkuphub_init(void);
-void __exit pkuphub_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/Kconfig
deleted file mode 100644
index fc0cae7..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/Kconfig
+++ /dev/null
@@ -1,7 +0,0 @@
-config MTK_SAR_HUB
-	bool "sarthub for MediaTek package"
-	help
-	  A sar is a device,
-	  usually portable and electronic
-	  or electromechanical,
-	  that detect distance between the body and device .
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sar_factory.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sar_factory.c
deleted file mode 100644
index 666af4b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sar_factory.c
+++ /dev/null
@@ -1,200 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<SAR_FAC>" fmt
-
-#include "sar_factory.h"
-
-struct sar_factory_private {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct sar_factory_fops *fops;
-};
-
-static struct sar_factory_private sar_factory;
-
-static int sar_factory_open(struct inode *inode, struct file *file)
-{
-	return nonseekable_open(inode, file);
-}
-
-static int sar_factory_release(struct inode *inode, struct file *file)
-{
-	file->private_data = NULL;
-	return 0;
-}
-
-static long sar_factory_unlocked_ioctl(struct file *file, unsigned int cmd,
-					unsigned long arg)
-{
-	long err = 0;
-	void __user *ptr = (void __user *)arg;
-	int32_t data_buf[3] = {0};
-	struct SENSOR_DATA sensor_data = {0};
-	uint32_t flag = 0;
-
-	if (_IOC_DIR(cmd) & _IOC_READ)
-		err = !access_ok(VERIFY_WRITE, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-	else if (_IOC_DIR(cmd) & _IOC_WRITE)
-		err = !access_ok(VERIFY_READ, (void __user *)arg,
-				 _IOC_SIZE(cmd));
-
-	if (err) {
-		pr_err("access error: %08X, (%2d, %2d)\n", cmd,
-			    _IOC_DIR(cmd), _IOC_SIZE(cmd));
-		return -EFAULT;
-	}
-
-	switch (cmd) {
-	case SAR_IOCTL_INIT:
-		if (copy_from_user(&flag, ptr, sizeof(flag)))
-			return -EFAULT;
-		if (sar_factory.fops != NULL &&
-		    sar_factory.fops->enable_sensor != NULL) {
-			err = sar_factory.fops->enable_sensor(flag, 200);
-			if (err < 0) {
-				pr_err("SAR_IOCTL_INIT fail!\n");
-				return -EINVAL;
-			}
-			pr_debug(
-				"SAR_IOCTL_INIT, enable: %d, sample_period:%dms\n",
-				flag, 200);
-		} else {
-			pr_err("SAR_IOCTL_INIT NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case SAR_IOCTL_READ_SENSORDATA:
-		if (sar_factory.fops != NULL &&
-		    sar_factory.fops->get_data != NULL) {
-			err = sar_factory.fops->get_data(data_buf);
-			if (err < 0) {
-				pr_err(
-					"SAR_IOCTL_READ_SENSORDATA read data fail!\n");
-				return -EINVAL;
-			}
-			pr_debug("SAR_IOCTL_READ_SENSORDATA: (%d, %d, %d)!\n",
-				data_buf[0], data_buf[1], data_buf[2]);
-			sensor_data.x = data_buf[0];
-			sensor_data.y = data_buf[1];
-			sensor_data.z = data_buf[2];
-			if (copy_to_user(ptr, &sensor_data,
-							sizeof(sensor_data)))
-				return -EFAULT;
-		} else {
-			pr_err("SAR_IOCTL_READ_SENSORDATA NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case SAR_IOCTL_ENABLE_CALI:
-		if (sar_factory.fops != NULL &&
-		    sar_factory.fops->enable_calibration != NULL) {
-			err = sar_factory.fops->enable_calibration();
-			if (err < 0) {
-				pr_err(
-					"SAR_IOCTL_ENABLE_CALI fail!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("SAR_IOCTL_ENABLE_CALI NULL\n");
-			return -EINVAL;
-		}
-		return 0;
-	case SAR_IOCTL_GET_CALI:
-		if (sar_factory.fops != NULL &&
-		    sar_factory.fops->get_cali != NULL) {
-			err = sar_factory.fops->get_cali(data_buf);
-			if (err < 0) {
-				pr_err("SAR_IOCTL_GET_CALI FAIL!\n");
-				return -EINVAL;
-			}
-		} else {
-			pr_err("SAR_IOCTL_GET_CALI NULL\n");
-			return -EINVAL;
-		}
-
-		pr_debug("SAR_IOCTL_GET_CALI: (%d, %d, %d)!\n",
-			data_buf[0], data_buf[1], data_buf[2]);
-		sensor_data.x = data_buf[0];
-		sensor_data.y = data_buf[1];
-		sensor_data.z = data_buf[2];
-		if (copy_to_user(ptr, &sensor_data, sizeof(sensor_data)))
-			return -EFAULT;
-		return 0;
-	default:
-		pr_err("unknown IOCTL: 0x%08x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-	return 0;
-}
-
-#if IS_ENABLED(CONFIG_COMPAT)
-static long compat_sar_factory_unlocked_ioctl(struct file *filp,
-					       unsigned int cmd,
-					       unsigned long arg)
-{
-	if (!filp->f_op || !filp->f_op->unlocked_ioctl) {
-		pr_err(
-			"compat_ion_ioctl file has no f_op or no f_op->unlocked_ioctl.\n");
-		return -ENOTTY;
-	}
-
-	switch (cmd) {
-	case COMPAT_SAR_IOCTL_INIT:
-	case COMPAT_SAR_IOCTL_READ_SENSORDATA:
-	case COMPAT_SAR_IOCTL_ENABLE_CALI:
-	case COMPAT_SAR_IOCTL_GET_CALI: {
-		pr_debug(
-			"compat_ion_ioctl : SAR_IOCTL_XXX command is 0x%x\n",
-			cmd);
-		return filp->f_op->unlocked_ioctl(
-			filp, cmd, (unsigned long)compat_ptr(arg));
-	}
-	default:
-		pr_err("compat_ion_ioctl : No such command!! 0x%x\n", cmd);
-		return -ENOIOCTLCMD;
-	}
-}
-#endif
-/*----------------------------------------------------------------------------*/
-static const struct file_operations _sar_factory_fops = {
-	.open = sar_factory_open,
-	.release = sar_factory_release,
-	.unlocked_ioctl = sar_factory_unlocked_ioctl,
-#if IS_ENABLED(CONFIG_COMPAT)
-	.compat_ioctl = compat_sar_factory_unlocked_ioctl,
-#endif
-};
-
-static struct miscdevice _sar_factory_device = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name = "sar",
-	.fops = &_sar_factory_fops,
-};
-
-int sar_factory_device_register(struct sar_factory_public *dev)
-{
-	int err = 0;
-
-	if (!dev || !dev->fops)
-		return -1;
-	sar_factory.gain = dev->gain;
-	sar_factory.sensitivity = dev->sensitivity;
-	sar_factory.fops = dev->fops;
-	err = misc_register(&_sar_factory_device);
-	if (err) {
-		pr_err("sar_factory_device register failed\n");
-		err = -1;
-	}
-	return err;
-}
-
-int sar_factory_device_deregister(struct sar_factory_public *dev)
-{
-	sar_factory.fops = NULL;
-	misc_deregister(&_sar_factory_device);
-	return 0;
-}
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sar_factory.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sar_factory.h
deleted file mode 100644
index da5317b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sar_factory.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __SAR_FACTORY_H__
-#define __SAR_FACTORY_H__
-
-#include <linux/atomic.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/input.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/kobject.h>
-#include <linux/miscdevice.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/types.h>
-#include <linux/uaccess.h>
-#include <linux/workqueue.h>
-
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-#include <sensors_io.h>
-
-
-struct sar_factory_fops {
-	int (*enable_sensor)(bool enabledisable,
-			int64_t sample_periods_ms);
-	int (*get_data)(int32_t sensor_data[3]);
-	int (*enable_calibration)(void);
-	int (*get_cali)(int32_t data[3]);
-};
-
-struct sar_factory_public {
-	uint32_t gain;
-	uint32_t sensitivity;
-	struct sar_factory_fops *fops;
-};
-int sar_factory_device_register(struct sar_factory_public *dev);
-int sar_factory_device_deregister(struct sar_factory_public *dev);
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sarhub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sarhub.c
deleted file mode 100644
index e5a946a..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sarhub.c
+++ /dev/null
@@ -1,261 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[sarhub] " fmt
-
-#include <hwmsensor.h>
-#include "sarhub.h"
-#include <situation.h>
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-#include "sar_factory.h"
-
-static struct situation_init_info sarhub_init_info;
-static DEFINE_SPINLOCK(calibration_lock);
-struct sarhub_ipi_data {
-	bool factory_enable;
-
-	int32_t cali_data[3];
-	int8_t cali_status;
-	struct completion calibration_done;
-};
-static struct sarhub_ipi_data *obj_ipi_data;
-
-
-static int sar_factory_enable_sensor(bool enabledisable,
-					 int64_t sample_periods_ms)
-{
-	int err = 0;
-	struct sarhub_ipi_data *obj = obj_ipi_data;
-
-	if (enabledisable == true)
-		WRITE_ONCE(obj->factory_enable, true);
-	else
-		WRITE_ONCE(obj->factory_enable, false);
-	if (enabledisable == true) {
-		err = sensor_set_delay_to_hub(ID_SAR,
-					      sample_periods_ms);
-		if (err) {
-			pr_err("sensor_set_delay_to_hub failed!\n");
-			return -1;
-		}
-	}
-	err = sensor_enable_to_hub(ID_SAR, enabledisable);
-	if (err) {
-		pr_err("sensor_enable_to_hub failed!\n");
-		return -1;
-	}
-	return 0;
-}
-
-static int sar_factory_get_data(int32_t sensor_data[3])
-{
-	int err = 0;
-	struct data_unit_t data;
-
-	err = sensor_get_data_from_hub(ID_SAR, &data);
-	if (err < 0) {
-		pr_err_ratelimited("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	sensor_data[0] = data.sar_event.data[0];
-	sensor_data[1] = data.sar_event.data[1];
-	sensor_data[2] = data.sar_event.data[2];
-
-	return err;
-}
-
-static int sar_factory_enable_calibration(void)
-{
-	return sensor_calibration_to_hub(ID_SAR);
-}
-
-static int sar_factory_get_cali(int32_t data[3])
-{
-	int err = 0;
-	struct sarhub_ipi_data *obj = obj_ipi_data;
-	int8_t status = 0;
-
-	err = wait_for_completion_timeout(&obj->calibration_done,
-					  msecs_to_jiffies(3000));
-	if (!err) {
-		pr_err("sar factory get cali fail!\n");
-		return -1;
-	}
-	spin_lock(&calibration_lock);
-	data[0] = obj->cali_data[0];
-	data[1] = obj->cali_data[1];
-	data[2] = obj->cali_data[2];
-	status = obj->cali_status;
-	spin_unlock(&calibration_lock);
-	if (status != 0) {
-		pr_debug("sar cali fail!\n");
-		return -2;
-	}
-	return 0;
-}
-
-
-static struct sar_factory_fops sarhub_factory_fops = {
-	.enable_sensor = sar_factory_enable_sensor,
-	.get_data = sar_factory_get_data,
-	.enable_calibration = sar_factory_enable_calibration,
-	.get_cali = sar_factory_get_cali,
-};
-
-static struct sar_factory_public sarhub_factory_device = {
-	.gain = 1,
-	.sensitivity = 1,
-	.fops = &sarhub_factory_fops,
-};
-
-static int sar_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_SAR, &data);
-	if (err < 0) {
-		pr_err_ratelimited("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.sar_event.data[0];
-	return 0;
-}
-static int sar_open_report_data(int open)
-{
-	int ret = 0;
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_SAR, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	ret = sensor_enable_to_hub(ID_SAR, open);
-	return ret;
-}
-static int sar_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_SAR,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int sar_flush(void)
-{
-	return sensor_flush_to_hub(ID_SAR);
-}
-
-static int sar_recv_data(struct data_unit_t *event, void *reserved)
-{
-	struct sarhub_ipi_data *obj = obj_ipi_data;
-	int32_t value[3] = {0};
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = situation_flush_report(ID_SAR);
-	else if (event->flush_action == DATA_ACTION) {
-		value[0] = event->sar_event.data[0];
-		value[1] = event->sar_event.data[1];
-		value[2] = event->sar_event.data[2];
-		err = sar_data_report_t(value, (int64_t)event->time_stamp);
-	} else if (event->flush_action == CALI_ACTION) {
-		spin_lock(&calibration_lock);
-		obj->cali_data[0] =
-			event->sar_event.x_bias;
-		obj->cali_data[1] =
-			event->sar_event.y_bias;
-		obj->cali_data[2] =
-			event->sar_event.z_bias;
-		obj->cali_status =
-			(int8_t)event->sar_event.status;
-		spin_unlock(&calibration_lock);
-		complete(&obj->calibration_done);
-	}
-	return err;
-}
-
-
-static int sarhub_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	struct sarhub_ipi_data *obj;
-
-	pr_debug("%s\n", __func__);
-	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-	if (!obj) {
-		err = -ENOMEM;
-		goto exit;
-	}
-
-	memset(obj, 0, sizeof(*obj));
-	obj_ipi_data = obj;
-	WRITE_ONCE(obj->factory_enable, false);
-	init_completion(&obj->calibration_done);
-
-	ctl.open_report_data = sar_open_report_data;
-	ctl.batch = sar_batch;
-	ctl.flush = sar_flush;
-	ctl.is_support_wake_lock = true;
-	ctl.is_support_batch = false;
-	err = situation_register_control_path(&ctl, ID_SAR);
-	if (err) {
-		pr_err("register sar control path err\n");
-		goto exit;
-	}
-
-	data.get_data = sar_get_data;
-	err = situation_register_data_path(&data, ID_SAR);
-	if (err) {
-		pr_err("register sar data path err\n");
-		goto exit;
-	}
-
-	err = sar_factory_device_register(&sarhub_factory_device);
-	if (err) {
-		pr_err("sar_factory_device register failed\n");
-		goto exit;
-	}
-
-	err = scp_sensorHub_data_registration(ID_SAR,
-		sar_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit;
-	}
-	return 0;
-exit:
-	return -1;
-}
-static int sarhub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info sarhub_init_info = {
-	.name = "sar_hub",
-	.init = sarhub_local_init,
-	.uninit = sarhub_local_uninit,
-};
-
-int __init sarhub_init(void)
-{
-	situation_driver_add(&sarhub_init_info, ID_SAR);
-	return 0;
-}
-
-void __exit sarhub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sarhub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sarhub.h
deleted file mode 100644
index 5d719fb..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/sar/sarhub.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef SARHUB_H
-#define SARHUB_H
-
-#include <linux/ioctl.h>
-
-int __init sarhub_init(void);
-void __exit sarhub_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/situation_hub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/situation_hub.c
deleted file mode 100644
index ae558d5..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/situation_hub.c
+++ /dev/null
@@ -1,110 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (C) 2019 MediaTek Inc.
- */
-
-#include "situation_hub.h"
-
-static int __init situation_hub_init(void)
-{
-#if IS_ENABLED(CONFIG_MTK_INPKHUB)
-	inpocket_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_STATHUB)
-	stat_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_WAKEHUB)
-	wakehub_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_GLGHUB)
-	glghub_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_PICKUPHUB)
-	pkuphub_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_ANSWER_CALL_HUB)
-	ancallhub_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_DEVICE_ORIENTATION_HUB)
-	device_orientation_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_MOTION_DETECT_HUB)
-	motion_detect_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_TILTDETECTHUB)
-	tiltdetecthub_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_FLAT_HUB)
-	flat_init();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_SAR_HUB)
-	sarhub_init();
-#endif
-
-	return 0;
-}
-
-static void __exit situation_hub_exit(void)
-{
-#if IS_ENABLED(CONFIG_MTK_INPKHUB)
-	inpocket_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_STATHUB)
-	stat_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_WAKEHUB)
-	wakehub_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_GLGHUB)
-	glghub_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_PICKUPHUB)
-	pkuphub_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_ANSWER_CALL_HUB)
-	ancallhub_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_DEVICE_ORIENTATION_HUB)
-	device_orientation_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_MOTION_DETECT_HUB)
-	motion_detect_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_TILTDETECTHUB)
-	tiltdetecthub_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_FLAT_HUB)
-	flat_exit();
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_SAR_HUB)
-	sarhub_exit();
-#endif
-}
-
-module_init(situation_hub_init);
-module_exit(situation_hub_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("situtation hub driver");
-MODULE_AUTHOR("Mediatek");
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/situation_hub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/situation_hub.h
deleted file mode 100644
index bcd923f..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/situation_hub.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __SITUTATION_HUB_H__
-#define __SITUTATION_HUB_H__
-
-#include <linux/module.h>
-
-#if IS_ENABLED(CONFIG_MTK_INPKHUB)
-#include "inpocket/inpocket.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_STATHUB)
-#include "stationary/stationary.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_WAKEHUB)
-#include "wake_gesture/wake_gesture.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_GLGHUB)
-#include "glance_gesture/glance_gesture.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_PICKUPHUB)
-#include "pickup_gesture/pickup_gesture.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_ANSWER_CALL_HUB)
-#include "answercall/ancallhub.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_DEVICE_ORIENTATION_HUB)
-#include "device_orientation/device_orientation.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_MOTION_DETECT_HUB)
-#include "motion_detect/motion_detect.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_TILTDETECTHUB)
-#include "tilt_detector/tiltdetecthub.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_FLAT_HUB)
-#include "flat/flat.h"
-#endif
-
-#if IS_ENABLED(CONFIG_MTK_SAR_HUB)
-#include "sar/sarhub.h"
-#endif
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/Kconfig
deleted file mode 100644
index 7917f45..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_STATHUB
-	bool "stahub for MediaTek package"
-	help
-	  A stationary is a device,
-	  usually portable
-	  and electronic or electromechanical,
-	  that detect device is kept static.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/stationary.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/stationary.c
deleted file mode 100644
index 04166e4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/stationary.c
+++ /dev/null
@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[stationary] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "situation.h"
-#include "stationary.h"
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static struct situation_init_info stat_init_info;
-static int stat_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_STATIONARY_DETECT, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int stat_open_report_data(int open)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_STATIONARY_DETECT, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	pr_debug("%s : type=%d, open=%d\n",
-		__func__, ID_STATIONARY_DETECT, open);
-	ret = sensor_enable_to_hub(ID_STATIONARY_DETECT, open);
-	return ret;
-}
-static int stat_batch(int flag, int64_t samplingPeriodNs,
-	int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_STATIONARY_DETECT,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int stat_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("stat do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_STATIONARY_DETECT,
-			(int64_t)event->time_stamp);
-	return err;
-}
-
-static int stat_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = stat_open_report_data;
-	ctl.batch = stat_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_STATIONARY_DETECT);
-	if (err) {
-		pr_err("register stationary control path err\n");
-		goto exit;
-	}
-
-	data.get_data = stat_get_data;
-	err = situation_register_data_path(&data, ID_STATIONARY_DETECT);
-	if (err) {
-		pr_err("register stationary data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_STATIONARY_DETECT,
-		stat_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int stat_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info stat_init_info = {
-	.name = "stat_hub",
-	.init = stat_local_init,
-	.uninit = stat_local_uninit,
-};
-
-int __init stat_init(void)
-{
-	situation_driver_add(&stat_init_info, ID_STATIONARY_DETECT);
-	return 0;
-}
-
-void __exit stat_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/stationary.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/stationary.h
deleted file mode 100644
index cc8b60c..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/stationary/stationary.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef STATIONARYHUB_H
-#define STATIONARYHUB_H
-
-#include <linux/ioctl.h>
-
-extern int __init stat_init(void);
-extern void __exit stat_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/Kconfig
deleted file mode 100644
index 7d723b7..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_TILTDETECTHUB
-	bool "tiltdetecthub for MediaTek package"
-	help
-	  A tilt detect is a device,
-	  usually portable and electronic
-	  or electromechanical,
-	  that detect device is picked up with 35 degree.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/tiltdetecthub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/tiltdetecthub.c
deleted file mode 100644
index 4bb7b97..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/tiltdetecthub.c
+++ /dev/null
@@ -1,124 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[tiltdetecthub] " fmt
-
-#include <hwmsensor.h>
-#include "tiltdetecthub.h"
-#include <situation.h>
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static struct situation_init_info tiltdetecthub_init_info;
-
-static int tilt_detect_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_TILT_DETECTOR, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp		= data.time_stamp;
-	*probability	= data.gesture_data_t.probability;
-	return 0;
-}
-static int tilt_detect_open_report_data(int open)
-{
-	int ret = 0;
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_TILT_DETECTOR, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	ret = sensor_enable_to_hub(ID_TILT_DETECTOR, open);
-	return ret;
-}
-static int tilt_detect_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_TILT_DETECTOR,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int tilt_detect_flush(void)
-{
-	return sensor_flush_to_hub(ID_TILT_DETECTOR);
-}
-
-static int tilt_detect_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = situation_flush_report(ID_TILT_DETECTOR);
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_data_report_t(ID_TILT_DETECTOR,
-			event->tilt_event.state, (int64_t)event->time_stamp);
-	return err;
-}
-
-static int tiltdetecthub_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = tilt_detect_open_report_data;
-	ctl.batch = tilt_detect_batch;
-	ctl.flush = tilt_detect_flush;
-	ctl.is_support_wake_lock = true;
-	ctl.is_support_batch = false;
-	err = situation_register_control_path(&ctl, ID_TILT_DETECTOR);
-	if (err) {
-		pr_err("register tilt_detect control path err\n");
-		goto exit;
-	}
-
-	data.get_data = tilt_detect_get_data;
-	err = situation_register_data_path(&data, ID_TILT_DETECTOR);
-	if (err) {
-		pr_err("register tilt_detect data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_TILT_DETECTOR,
-		tilt_detect_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit;
-	}
-	return 0;
-exit:
-	return -1;
-}
-static int tiltdetecthub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info tiltdetecthub_init_info = {
-	.name = "tilt_detect_hub",
-	.init = tiltdetecthub_local_init,
-	.uninit = tiltdetecthub_local_uninit,
-};
-
-int __init tiltdetecthub_init(void)
-{
-	situation_driver_add(&tiltdetecthub_init_info, ID_TILT_DETECTOR);
-	return 0;
-}
-
-void __exit tiltdetecthub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/tiltdetecthub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/tiltdetecthub.h
deleted file mode 100644
index 47869bc..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/tilt_detector/tiltdetecthub.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef TILTDETECTHUB_H
-#define TILTDETECTHUB_H
-
-#include <linux/ioctl.h>
-
-int __init tiltdetecthub_init(void);
-void __exit tiltdetecthub_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/Kconfig
deleted file mode 100644
index a59764f..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/Kconfig
+++ /dev/null
@@ -1,8 +0,0 @@
-
-config MTK_WAKEHUB
-	bool "wakehub for MediaTek package"
-	help
-	  A wake is a device,
-	  usually portable and electronic
-	  or electromechanical,
-	  that detect device is picked up with 35 degree.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/wake_gesture.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/wake_gesture.c
deleted file mode 100644
index 5cbe7c1..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/wake_gesture.c
+++ /dev/null
@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[wakehub] " fmt
-
-#include <linux/interrupt.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>
-#include <linux/irq.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/input.h>
-#include <linux/workqueue.h>
-#include <linux/kobject.h>
-#include <linux/platform_device.h>
-#include <linux/atomic.h>
-
-#include <hwmsensor.h>
-#include <sensors_io.h>
-#include "wake_gesture.h"
-#include "situation.h"
-
-#include <hwmsen_helper.h>
-
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-static int wake_gesture_get_data(int *probability, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_WAKE_GESTURE, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp = data.time_stamp;
-	*probability = data.gesture_data_t.probability;
-	return 0;
-}
-static int wake_gesture_open_report_data(int open)
-{
-	int ret = 0;
-
-	pr_debug("%s : enable=%d\n", __func__, open);
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (open == 1)
-		ret = sensor_set_delay_to_hub(ID_WAKE_GESTURE, 120);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	ret = sensor_enable_to_hub(ID_WAKE_GESTURE, open);
-	return ret;
-}
-static int wake_gesture_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_WAKE_GESTURE,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-static int wake_gesture_recv_data(struct data_unit_t *event,
-	void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_debug("wake_gesture do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = situation_notify_t(ID_WAKE_GESTURE,
-			(int64_t)event->time_stamp);
-	return err;
-}
-
-static int wakehub_local_init(void)
-{
-	struct situation_control_path ctl = {0};
-	struct situation_data_path data = {0};
-	int err = 0;
-
-	ctl.open_report_data = wake_gesture_open_report_data;
-	ctl.batch = wake_gesture_batch;
-	ctl.is_support_wake_lock = true;
-	err = situation_register_control_path(&ctl, ID_WAKE_GESTURE);
-	if (err) {
-		pr_err("register wake_gesture control path err\n");
-		goto exit;
-	}
-
-	data.get_data = wake_gesture_get_data;
-	err = situation_register_data_path(&data, ID_WAKE_GESTURE);
-	if (err) {
-		pr_err("register wake_gesture data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_WAKE_GESTURE,
-		wake_gesture_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-exit_create_attr_failed:
-	return -1;
-}
-static int wakehub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct situation_init_info wakehub_init_info = {
-	.name = "wake_gesture_hub",
-	.init = wakehub_local_init,
-	.uninit = wakehub_local_uninit,
-};
-
-int __init wakehub_init(void)
-{
-	situation_driver_add(&wakehub_init_info, ID_WAKE_GESTURE);
-	return 0;
-}
-
-void __exit wakehub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/wake_gesture.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/wake_gesture.h
deleted file mode 100644
index e11d827..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/situation/situation_hub/wake_gesture/wake_gesture.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef WAKEHUB_H
-#define WAKEHUB_H
-
-#include <linux/ioctl.h>
-
-int __init wakehub_init(void);
-void __exit wakehub_exit(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/Kconfig
deleted file mode 100644
index dbc0fcf..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/Kconfig
+++ /dev/null
@@ -1,13 +0,0 @@
-
-config CUSTOM_KERNEL_STEP_COUNTER
-	bool "CUSTOM_KERNEL_STEP_COUNTER"
-	help
-	  A step counter is a device, usually portable and electronic or electromechanical,
-	  that counts each step a person takes by detecting the motion of the person's hands or hips.
-
-config CUSTOM_KERNEL_SIGNIFICANT_MOTION
-	bool "open significant motion"
-	help
-	  Kernel space sigificant motion sensor driver.
-
-source "drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Kconfig"
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/Makefile
deleted file mode 100644
index 804a56b..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/Makefile
+++ /dev/null
@@ -1,23 +0,0 @@
-#
-# Copyright (C) 2015 MediaTek Inc.
-#
-# 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.
-#
-# 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.
-#
-
-# In case the platform does NOT support this type of sensors
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-
-obj-$(CONFIG_MTK_SENSOR_SUPPORT)	+= step_counter.o
-
-obj-$(CONFIG_MTK_STEPSIGNHUB)		+=	stepsignhub/
-
-ifeq ($(CONFIG_CUSTOM_KERNEL_STEP_COUNTER),"OTHER_VENDOR")
-obj-y += other_vendor/
-endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/step_counter.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/step_counter.c
deleted file mode 100644
index 485e627..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/step_counter.c
+++ /dev/null
@@ -1,1103 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "<STEP_COUNTER> " fmt
-
-#include "step_counter.h"
-
-static struct step_c_context *step_c_context_obj;
-static struct step_c_init_info *
-	step_counter_init_list[MAX_CHOOSE_STEP_C_NUM] = { 0 };
-
-static void step_c_work_func(struct work_struct *work)
-{
-
-	struct step_c_context *cxt = NULL;
-	uint32_t counter;
-	uint32_t counter_floor_c;
-	/* hwm_sensor_data sensor_data; */
-	int status;
-	int64_t nt;
-	struct timespec time;
-	int err = 0;
-
-	cxt = step_c_context_obj;
-
-	if (cxt->step_c_data.get_data == NULL)
-		pr_debug("step_c driver not register data path\n");
-	if (cxt->step_c_data.get_data_floor_c == NULL)
-		pr_debug("floor_c driver not register data path\n");
-
-
-	status = 0;
-	counter = 0;
-	time.tv_sec = time.tv_nsec = 0;
-	time = get_monotonic_coarse();
-	nt = time.tv_sec * 1000000000LL + time.tv_nsec;
-
-	/* add wake lock to make sure data can be read before system suspend */
-	if ((cxt->is_active_data == true) &&
-		(cxt->step_c_data.get_data != NULL))
-		err = cxt->step_c_data.get_data(&counter, &status);
-
-	if (err) {
-		pr_err("get step_c data fails!!\n");
-		goto step_c_loop;
-	} else {
-		{
-			cxt->drv_data.counter = counter;
-			cxt->drv_data.status = status;
-		}
-	}
-
-	status = 0;
-	counter_floor_c = 0;
-	if ((cxt->is_floor_c_active_data == true) &&
-		(cxt->step_c_data.get_data_floor_c != NULL))
-		err = cxt->step_c_data.get_data_floor_c(&counter_floor_c,
-							&status);
-
-	if (err) {
-		pr_err("get floor_c data fails!!\n");
-		goto step_c_loop;
-	} else {
-		{
-			cxt->drv_data.floor_counter = counter_floor_c;
-			cxt->drv_data.floor_c_status = status;
-		}
-	}
-
-	if (true == cxt->is_first_data_after_enable) {
-		cxt->is_first_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.counter == STEP_C_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto step_c_loop;
-
-		}
-	}
-
-	if (true == cxt->is_first_floor_c_data_after_enable) {
-		cxt->is_first_floor_c_data_after_enable = false;
-		/* filter -1 value */
-		if (cxt->drv_data.floor_counter == STEP_C_INVALID_VALUE) {
-			pr_debug(" read invalid data\n");
-			goto step_c_loop;
-
-		}
-	}
-
-	/* report data to input device */
-	/*pr_debug("step_c data[%d]\n", cxt->drv_data.counter);*/
-
-	step_c_data_report(cxt->drv_data.counter, cxt->drv_data.status);
-	floor_c_data_report(cxt->drv_data.floor_counter,
-		cxt->drv_data.floor_c_status);
-
-step_c_loop:
-	if (true == cxt->is_polling_run) {
-		mod_timer(&cxt->timer,
-			jiffies + atomic_read(&cxt->delay) / (1000 / HZ));
-	}
-}
-
-static void step_c_poll(struct timer_list *t)
-{
-	struct step_c_context *obj = from_timer(obj, t, timer);
-
-	if (obj != NULL)
-		schedule_work(&obj->report);
-}
-
-static struct step_c_context *step_c_context_alloc_object(void)
-{
-	struct step_c_context *obj = kzalloc(sizeof(*obj), GFP_KERNEL);
-
-	pr_debug("%s start\n", __func__);
-	if (!obj) {
-		pr_err("Alloc step_c object error!\n");
-		return NULL;
-	}
-	atomic_set(&obj->delay, 2000);	/*0.5Hz */
-	atomic_set(&obj->wake, 0);
-	INIT_WORK(&obj->report, step_c_work_func);
-	timer_setup(&obj->timer, step_c_poll, 0);
-	obj->timer.expires = jiffies + atomic_read(&obj->delay) / (1000 / HZ);
-	obj->is_first_data_after_enable = false;
-	obj->is_polling_run = false;
-	mutex_init(&obj->step_c_op_mutex);
-	obj->is_step_c_batch_enable = false;	/* for batch mode init */
-	obj->is_step_d_batch_enable = false;	/* for batch mode init */
-
-	pr_debug("%s end\n", __func__);
-	return obj;
-}
-
-int step_notify_t(enum STEP_NOTIFY_TYPE type, int64_t time_stamp)
-{
-	int err = 0;
-	struct step_c_context *cxt = NULL;
-	struct sensor_event event;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	cxt = step_c_context_obj;
-	event.time_stamp = time_stamp;
-
-	if (type == TYPE_STEP_DETECTOR) {
-		event.flush_action = DATA_ACTION;
-		event.handle = ID_STEP_DETECTOR;
-		event.word[0] = 1;
-		err = sensor_input_event(step_c_context_obj->mdev.minor,
-			&event);
-
-	}
-	if (type == TYPE_SIGNIFICANT) {
-		pr_debug("fwq TYPE_SIGNIFICANT notify\n");
-		/* cxt->step_c_data.get_data_significant(&value); */
-		event.flush_action = DATA_ACTION;
-		event.handle = ID_SIGNIFICANT_MOTION;
-		event.word[0] = 1;
-		err = sensor_input_event(step_c_context_obj->mdev.minor,
-			&event);
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(step_notify_t);
-
-int step_notify(enum STEP_NOTIFY_TYPE type)
-{
-	return step_notify_t(type, 0);
-}
-static int step_d_real_enable(int enable)
-{
-	int err = 0;
-	unsigned int i = 0;
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	if (enable == 1) {
-
-		for (i = 0; i < 3; i++) {
-			err = cxt->step_c_ctl.enable_step_detect(1);
-			if (err == 0)
-				break;
-			else if (i == 2) {
-				pr_err("step_d E(%d)err 3 = %d\n",
-					enable, err);
-			}
-		}
-
-		pr_debug("step_d real enable\n");
-	}
-	if (enable == 0) {
-
-		err = cxt->step_c_ctl.enable_step_detect(0);
-		if (err)
-			pr_err("step_d enable(%d) err = %d\n",
-				enable, err);
-		pr_debug("step_d real disable\n");
-
-	}
-
-	return err;
-}
-
-static int significant_real_enable(int enable)
-{
-	int err = 0;
-	unsigned int i = 0;
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	if (enable == 1) {
-
-		for (i = 0; i < 3; i++) {
-			err = cxt->step_c_ctl.enable_significant(1);
-			if (err == 0)
-				break;
-			else if (i == 2) {
-				pr_err("significant E(%d)err 3 = %d\n",
-					enable, err);
-			}
-		}
-
-		pr_debug("enable_significant real enable\n");
-	}
-	if (enable == 0) {
-		err = cxt->step_c_ctl.enable_significant(0);
-		if (err)
-			pr_err("enable_significantenable(%d) err = %d\n",
-				enable, err);
-		pr_debug("enable_significant real disable\n");
-
-	}
-	return err;
-}
-
-
-static int step_c_real_enable(int enable)
-{
-	int err = 0;
-	unsigned int i = 0;
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	if (enable == 1) {
-		if (true == cxt->is_active_data ||
-			true == cxt->is_active_nodata) {
-
-			for (i = 0; i < 3; i++) {
-				err = cxt->step_c_ctl.enable_nodata(1);
-				if (err == 0)
-					break;
-				else if (i == 2) {
-					pr_err("step_c E(%d)err 3 =%d\n",
-						enable, err);
-				}
-			}
-
-			pr_debug("step_c real enable\n");
-		}
-	}
-	if (enable == 0) {
-		if (false == cxt->is_active_data &&
-			false == cxt->is_active_nodata) {
-			err = cxt->step_c_ctl.enable_nodata(0);
-			if (err)
-				pr_err("step_c enable(%d) err = %d\n",
-					enable, err);
-			pr_debug("step_c real disable\n");
-		}
-
-	}
-
-	return err;
-}
-
-
-static int floor_c_real_enable(int enable)
-{
-	int err = 0;
-	unsigned int i = 0;
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	if (enable == 1) {
-		for (i = 0; i < 3; i++) {
-			err = cxt->step_c_ctl.enable_floor_c(1);
-			if (err == 0)
-				break;
-			else if (i == 2)
-				pr_err("floor_c enable(%d) err 3 = %d\n",
-					enable, err);
-		}
-
-		pr_debug("floor_c real enable\n");
-	}
-	if (enable == 0) {
-		err = cxt->step_c_ctl.enable_floor_c(0);
-		if (err)
-			pr_err("floor_c enable(%d) err = %d\n",
-				enable, err);
-		pr_debug("floor_c real disable\n");
-
-	}
-
-	return err;
-}
-
-
-
-static int step_c_enable_data(int enable)
-{
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	if (cxt->step_c_ctl.open_report_data == NULL) {
-		pr_err("no step_c control path\n");
-		return -1;
-	}
-
-	if (enable == 1) {
-		pr_debug("STEP_C enable data\n");
-		cxt->is_active_data = true;
-		cxt->is_first_data_after_enable = true;
-		cxt->step_c_ctl.open_report_data(1);
-		if (false == cxt->is_polling_run &&
-			cxt->is_step_c_batch_enable == false) {
-			if (false == cxt->step_c_ctl.is_report_input_direct) {
-				mod_timer(&cxt->timer, jiffies +
-					atomic_read(&cxt->delay) / (1000 / HZ));
-				cxt->is_polling_run = true;
-			}
-		}
-	}
-	if (enable == 0) {
-		pr_debug("STEP_C disable\n");
-		cxt->is_active_data = false;
-		cxt->step_c_ctl.open_report_data(0);
-		if (true == cxt->is_polling_run) {
-			if (false == cxt->step_c_ctl.is_report_input_direct) {
-				cxt->is_polling_run = false;
-				del_timer_sync(&cxt->timer);
-				cancel_work_sync(&cxt->report);
-				cxt->drv_data.counter = STEP_C_INVALID_VALUE;
-			}
-		}
-
-	}
-	step_c_real_enable(enable);
-	return 0;
-}
-
-
-static int floor_c_enable_data(int enable)
-{
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-
-	if (enable == 1) {
-		pr_debug("FLOOR_C enable data\n");
-		cxt->is_floor_c_active_data = true;
-		cxt->is_first_floor_c_data_after_enable = true;
-		floor_c_real_enable(1);
-		if (false == cxt->is_polling_run &&
-			cxt->is_step_c_batch_enable == false) {
-			if (false == cxt->step_c_ctl.is_report_input_direct) {
-				mod_timer(&cxt->timer, jiffies +
-					atomic_read(&cxt->delay) / (1000 / HZ));
-				cxt->is_polling_run = true;
-			}
-		}
-	}
-	if (enable == 0) {
-		pr_debug("FLOOR_C disable\n");
-		cxt->is_floor_c_active_data = false;
-		floor_c_real_enable(0);
-		if (true == cxt->is_polling_run) {
-			if (false == cxt->step_c_ctl.is_report_input_direct) {
-				cxt->is_polling_run = false;
-				del_timer_sync(&cxt->timer);
-				cancel_work_sync(&cxt->report);
-				cxt->drv_data.floor_counter =
-					STEP_C_INVALID_VALUE;
-			}
-		}
-
-	}
-	return 0;
-}
-
-
-
-int step_c_enable_nodata(int enable)
-{
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	if (cxt->step_c_ctl.enable_nodata == NULL) {
-		pr_err("%s:step_c ctl path is NULL\n", __func__);
-		return -1;
-	}
-
-	if (enable == 1)
-		cxt->is_active_nodata = true;
-
-	if (enable == 0)
-		cxt->is_active_nodata = false;
-	step_c_real_enable(enable);
-	return 0;
-}
-
-
-static ssize_t step_cenablenodata_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-static ssize_t step_cenablenodata_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	int err = 0;
-	struct step_c_context *cxt = NULL;
-
-	pr_debug("step_c_store_enable nodata buf=%s\n", buf);
-	mutex_lock(&step_c_context_obj->step_c_op_mutex);
-	cxt = step_c_context_obj;
-	if (cxt->step_c_ctl.enable_nodata == NULL) {
-		pr_debug("step_c_ctl enable nodata NULL\n");
-		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-		return count;
-	}
-	if (!strncmp(buf, "1", 1))
-		err = step_c_enable_nodata(1);
-	else if (!strncmp(buf, "0", 1))
-		err = step_c_enable_nodata(0);
-	else
-		pr_err(" step_c_store enable nodata cmd error !!\n");
-	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-	return err;
-}
-
-static ssize_t step_cactive_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	struct step_c_context *cxt = NULL;
-	int res = 0;
-	int handle = 0;
-	int en = 0;
-
-	pr_debug("%s buf=%s\n", __func__, buf);
-	mutex_lock(&step_c_context_obj->step_c_op_mutex);
-
-	cxt = step_c_context_obj;
-	if (cxt->step_c_ctl.open_report_data == NULL) {
-		pr_debug("step_c_ctl enable NULL\n");
-		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-		return count;
-	}
-	res = sscanf(buf, "%d,%d", &handle, &en);
-	if (res != 2)
-		pr_debug("%s param error: res = %d\n", __func__, res);
-	pr_debug("%s handle=%d ,en=%d\n", __func__, handle, en);
-	switch (handle) {
-	case ID_STEP_COUNTER:
-		if (en == 1)
-			res = step_c_enable_data(1);
-		else if (en == 0)
-			res = step_c_enable_data(0);
-		else
-			pr_err("%s error !!\n", __func__);
-		break;
-	case ID_STEP_DETECTOR:
-		if (en == 1)
-			res = step_d_real_enable(1);
-		else if (en == 0)
-			res = step_d_real_enable(0);
-		else
-			pr_err(" step_d_real_enable error !!\n");
-		break;
-	case ID_SIGNIFICANT_MOTION:
-		if (en == 1)
-			res = significant_real_enable(1);
-		else if (en == 0)
-			res = significant_real_enable(0);
-		else
-			pr_err(" significant_real_enable error !!\n");
-		break;
-	case ID_FLOOR_COUNTER:
-		if (en == 1)
-			res = floor_c_enable_data(1);
-		else if (en == 0)
-			res = floor_c_enable_data(0);
-		else
-			pr_err(" fc_real_enable error !!\n");
-		break;
-
-	}
-	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-	pr_debug("%s done\n", __func__);
-	return res;
-}
-
-/*----------------------------------------------------------------------------*/
-static ssize_t step_cactive_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	struct step_c_context *cxt = NULL;
-	int div;
-
-	cxt = step_c_context_obj;
-	div = cxt->step_c_data.vender_div;
-	pr_debug("step_c vender_div value: %d\n", div);
-	return snprintf(buf, PAGE_SIZE, "%d\n", div);
-}
-
-static ssize_t step_cdelay_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	int delay = 0, err = 0;
-	int mdelay = 0;
-	struct step_c_context *cxt = NULL;
-
-	mutex_lock(&step_c_context_obj->step_c_op_mutex);
-	cxt = step_c_context_obj;
-	if (cxt->step_c_ctl.step_c_set_delay == NULL) {
-		pr_debug("step_c_ctl step_c_set_delay NULL\n");
-		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-		return -1;
-	}
-
-	if (kstrtoint(buf, 10, &delay) != 0) {
-		pr_err("invalid format!!\n");
-		mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-		return -1;
-	}
-
-	if (false == cxt->step_c_ctl.is_report_input_direct) {
-		mdelay = (int)delay / 1000 / 1000;
-		atomic_set(&step_c_context_obj->delay, mdelay);
-	}
-	err = cxt->step_c_ctl.step_c_set_delay(delay);
-	pr_debug(" step_c_delay %d ns\n", delay);
-	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-	return err;
-
-}
-
-static ssize_t step_cdelay_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	int len = 0;
-
-	pr_debug(" not support now\n");
-	return len;
-}
-
-
-static ssize_t step_cbatch_store(struct device *dev,
-	struct device_attribute *attr, const char *buf, size_t count)
-{
-	struct step_c_context *cxt = NULL;
-	int handle = 0, flag = 0, res = 0;
-	int64_t samplingPeriodNs = 0, maxBatchReportLatencyNs = 0;
-
-	res = sscanf(buf, "%d,%d,%lld,%lld",
-		&handle, &flag, &samplingPeriodNs, &maxBatchReportLatencyNs);
-	if (res != 4)
-		pr_err("%s param error: err =%d\n", __func__, res);
-	pr_debug("handle %d, flag:%d PeriodNs:%lld, LatencyNs: %lld\n",
-		handle, flag, samplingPeriodNs, maxBatchReportLatencyNs);
-	mutex_lock(&step_c_context_obj->step_c_op_mutex);
-	cxt = step_c_context_obj;
-	if (handle == ID_STEP_COUNTER) {
-		if (!cxt->step_c_ctl.is_counter_support_batch)
-			maxBatchReportLatencyNs = 0;
-		if (cxt->step_c_ctl.step_c_batch != NULL)
-			res = cxt->step_c_ctl.step_c_batch(flag,
-				samplingPeriodNs, maxBatchReportLatencyNs);
-		else
-			pr_err("SUPPORT STEP COUNTER COM BATCH\n");
-		if (res < 0)
-			pr_err("step counter enable batch err %d\n",
-				res);
-	} else if (handle == ID_STEP_DETECTOR) {
-		if (!cxt->step_c_ctl.is_detector_support_batch)
-			maxBatchReportLatencyNs = 0;
-		if (cxt->step_c_ctl.step_d_batch != NULL)
-			res = cxt->step_c_ctl.step_d_batch(flag,
-				samplingPeriodNs, maxBatchReportLatencyNs);
-		else
-			pr_err("NOT SUPPORT STEP DETECTOR COM BATCH\n");
-		if (res < 0)
-			pr_err("step detector enable batch err %d\n",
-				res);
-	} else if (handle == ID_SIGNIFICANT_MOTION) {
-		if (!cxt->step_c_ctl.is_smd_support_batch)
-			maxBatchReportLatencyNs = 0;
-
-		if (cxt->step_c_ctl.smd_batch != NULL)
-			res = cxt->step_c_ctl.smd_batch(flag,
-			samplingPeriodNs, maxBatchReportLatencyNs);
-		else
-			pr_err("STEP SMD OLD NOT SUPPORT COM BATCH\n");
-		if (res < 0)
-			pr_err("step smd enable batch err %d\n", res);
-	} else if (handle == ID_FLOOR_COUNTER) {
-		if (!cxt->step_c_ctl.is_floor_c_support_batch)
-			maxBatchReportLatencyNs = 0;
-
-		if (cxt->step_c_ctl.floor_c_batch != NULL)
-			res = cxt->step_c_ctl.floor_c_batch(flag,
-				samplingPeriodNs, maxBatchReportLatencyNs);
-		else
-			pr_err("NOT SUPPORT FLOOR COUNT COM BATCH\n");
-		if (res < 0)
-			pr_err("floor count enable batch err %d\n", res);
-	}
-	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-	pr_debug("%s done: %d\n", __func__, cxt->is_step_c_batch_enable);
-	return res;
-}
-
-static ssize_t step_cbatch_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t step_cflush_store(struct device *dev,
-	struct device_attribute *attr,
-				  const char *buf, size_t count)
-{
-	struct step_c_context *cxt = NULL;
-	int handle = 0, err = 0;
-
-	err = kstrtoint(buf, 10, &handle);
-	if (err != 0)
-		pr_err("%s param error: err = %d\n", __func__, err);
-
-	pr_debug("%s param: handle %d\n", __func__, handle);
-
-	mutex_lock(&step_c_context_obj->step_c_op_mutex);
-	cxt = step_c_context_obj;
-	if (handle == ID_STEP_COUNTER) {
-		if (cxt->step_c_ctl.step_c_flush != NULL)
-			err = cxt->step_c_ctl.step_c_flush();
-		else
-			pr_err("NOT SUPPORT STEP COUNTER COM FLUSH\n");
-		if (err < 0)
-			pr_err("step counter enable flush err %d\n",
-				err);
-	} else if (handle == ID_STEP_DETECTOR) {
-		if (cxt->step_c_ctl.step_d_flush != NULL)
-			err = cxt->step_c_ctl.step_d_flush();
-		else
-			pr_err("NOT SUPPORT STEP DETECTOR COM FLUSH\n");
-		if (err < 0)
-			pr_err("step detector enable flush err %d\n",
-				err);
-	} else if (handle == ID_SIGNIFICANT_MOTION) {
-		if (cxt->step_c_ctl.smd_flush != NULL)
-			err = cxt->step_c_ctl.smd_flush();
-		else
-			pr_err("NOT SUPPORT SMD COMMON VERSION FLUSH\n");
-		if (err < 0)
-			pr_err("smd enable flush err %d\n", err);
-	} else if (handle == ID_FLOOR_COUNTER) {
-		if (cxt->step_c_ctl.floor_c_flush != NULL)
-			err = cxt->step_c_ctl.floor_c_flush();
-		else
-			pr_err("NOT SUPPORT FLOOR COUNTER COM FLUSH\n");
-		if (err < 0)
-			pr_err("floor counter enable flush err %d\n",
-				err);
-
-	}
-	mutex_unlock(&step_c_context_obj->step_c_op_mutex);
-	return err;
-}
-
-static ssize_t step_cflush_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static ssize_t step_cdevnum_show(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-}
-
-static int step_counter_remove(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static int step_counter_probe(struct platform_device *pdev)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id step_counter_of_match[] = {
-	{.compatible = "mediatek,step_counter",},
-	{},
-};
-#endif
-
-static struct platform_driver step_counter_driver = {
-	.probe = step_counter_probe,
-	.remove = step_counter_remove,
-	.driver = {
-
-		   .name = "step_counter",
-#ifdef CONFIG_OF
-		   .of_match_table = step_counter_of_match,
-#endif
-		}
-};
-
-static int step_c_real_driver_init(void)
-{
-	int i = 0;
-	int err = 0;
-
-	pr_debug("%s start\n", __func__);
-	for (i = 0; i < MAX_CHOOSE_STEP_C_NUM; i++) {
-		pr_debug(" i=%d\n", i);
-		if (step_counter_init_list[i] != 0) {
-			pr_debug(" step_c try to init driver %s\n",
-				   step_counter_init_list[i]->name);
-			err = step_counter_init_list[i]->init();
-			if (err == 0) {
-				pr_debug(" step_c real driver %s probe ok\n",
-					   step_counter_init_list[i]->name);
-				break;
-			}
-		}
-	}
-
-	if (i == MAX_CHOOSE_STEP_C_NUM) {
-		pr_debug("%s fail\n", __func__);
-		err = -1;
-	}
-	return err;
-}
-
-int step_c_driver_add(struct step_c_init_info *obj)
-{
-	int err = 0;
-	int i = 0;
-
-	pr_debug("%s\n", __func__);
-
-	pr_debug("register step_counter driver for the first time\n");
-	if (platform_driver_register(&step_counter_driver))
-		pr_err("fail to register gensor driver already exist\n");
-	for (i = 0; i < MAX_CHOOSE_STEP_C_NUM; i++) {
-		if (step_counter_init_list[i] == NULL) {
-			obj->platform_diver_addr = &step_counter_driver;
-			step_counter_init_list[i] = obj;
-			break;
-		}
-	}
-	if (i >= MAX_CHOOSE_STEP_C_NUM) {
-		pr_err("STEP_C driver add err\n");
-		err = -1;
-	}
-
-	return err;
-}
-EXPORT_SYMBOL_GPL(step_c_driver_add);
-
-static int step_open(struct inode *inode, struct file *file)
-{
-	nonseekable_open(inode, file);
-	return 0;
-}
-
-static ssize_t step_read(struct file *file, char __user *buffer,
-			  size_t count, loff_t *ppos)
-{
-	ssize_t read_cnt = 0;
-
-	read_cnt = sensor_event_read(step_c_context_obj->mdev.minor,
-		file, buffer, count, ppos);
-
-	return read_cnt;
-}
-
-static unsigned int step_poll(struct file *file, poll_table *wait)
-{
-	return sensor_event_poll(step_c_context_obj->mdev.minor, file, wait);
-}
-
-static const struct file_operations step_fops = {
-	.owner = THIS_MODULE,
-	.open = step_open,
-	.read = step_read,
-	.poll = step_poll,
-};
-
-static int step_c_misc_init(struct step_c_context *cxt)
-{
-
-	int err = 0;
-	/* kernel-3.10\include\linux\Miscdevice.h */
-	/* use MISC_DYNAMIC_MINOR exceed 64 */
-	cxt->mdev.minor = ID_STEP_COUNTER;
-	cxt->mdev.name = STEP_C_MISC_DEV_NAME;
-	cxt->mdev.fops = &step_fops;
-	err = sensor_attr_register(&cxt->mdev);
-	if (err)
-		pr_err("unable to register step_c misc device!!\n");
-	return err;
-}
-
-DEVICE_ATTR_RW(step_cenablenodata);
-DEVICE_ATTR_RW(step_cactive);
-DEVICE_ATTR_RW(step_cdelay);
-DEVICE_ATTR_RW(step_cbatch);
-DEVICE_ATTR_RW(step_cflush);
-DEVICE_ATTR_RO(step_cdevnum);
-
-
-static struct attribute *step_c_attributes[] = {
-	&dev_attr_step_cenablenodata.attr,
-	&dev_attr_step_cactive.attr,
-	&dev_attr_step_cdelay.attr,
-	&dev_attr_step_cbatch.attr,
-	&dev_attr_step_cflush.attr,
-	&dev_attr_step_cdevnum.attr,
-	NULL
-};
-
-static struct attribute_group step_c_attribute_group = {
-	.attrs = step_c_attributes
-};
-
-int step_c_register_data_path(struct step_c_data_path *data)
-{
-	struct step_c_context *cxt = NULL;
-
-	cxt = step_c_context_obj;
-	cxt->step_c_data.get_data = data->get_data;
-	cxt->step_c_data.vender_div = data->vender_div;
-	cxt->step_c_data.get_data_significant = data->get_data_significant;
-	cxt->step_c_data.get_data_step_d = data->get_data_step_d;
-	cxt->step_c_data.get_data_floor_c = data->get_data_floor_c;
-	pr_debug("step_c register data path vender_div: %d\n",
-		cxt->step_c_data.vender_div);
-	if (cxt->step_c_data.get_data == NULL
-	    || cxt->step_c_data.get_data_significant == NULL
-	    || cxt->step_c_data.get_data_step_d == NULL) {
-		pr_debug("step_c register data path fail\n");
-		return -1;
-	}
-	return 0;
-}
-EXPORT_SYMBOL_GPL(step_c_register_data_path);
-
-int step_c_register_control_path(struct step_c_control_path *ctl)
-{
-	struct step_c_context *cxt = NULL;
-	int err = 0;
-
-	cxt = step_c_context_obj;
-	cxt->step_c_ctl.step_c_set_delay = ctl->step_c_set_delay;
-	cxt->step_c_ctl.step_d_set_delay = ctl->step_d_set_delay;
-	cxt->step_c_ctl.floor_c_set_delay = ctl->floor_c_set_delay;
-	cxt->step_c_ctl.open_report_data = ctl->open_report_data;
-	cxt->step_c_ctl.enable_nodata = ctl->enable_nodata;
-	cxt->step_c_ctl.step_c_batch = ctl->step_c_batch;
-	cxt->step_c_ctl.step_c_flush = ctl->step_c_flush;
-	cxt->step_c_ctl.step_d_batch = ctl->step_d_batch;
-	cxt->step_c_ctl.step_d_flush = ctl->step_d_flush;
-	cxt->step_c_ctl.smd_batch = ctl->smd_batch;
-	cxt->step_c_ctl.smd_flush = ctl->smd_flush;
-	cxt->step_c_ctl.floor_c_batch = ctl->floor_c_batch;
-	cxt->step_c_ctl.floor_c_flush = ctl->floor_c_flush;
-	cxt->step_c_ctl.is_counter_support_batch =
-		ctl->is_counter_support_batch;
-	cxt->step_c_ctl.is_detector_support_batch =
-		ctl->is_detector_support_batch;
-	cxt->step_c_ctl.is_smd_support_batch = ctl->is_smd_support_batch;
-	cxt->step_c_ctl.is_floor_c_support_batch =
-		ctl->is_floor_c_support_batch;
-	cxt->step_c_ctl.is_report_input_direct = ctl->is_report_input_direct;
-	cxt->step_c_ctl.enable_significant = ctl->enable_significant;
-	cxt->step_c_ctl.enable_step_detect = ctl->enable_step_detect;
-	cxt->step_c_ctl.enable_floor_c = ctl->enable_floor_c;
-
-	if ((cxt->step_c_ctl.step_c_set_delay == NULL)
-		|| (cxt->step_c_ctl.open_report_data == NULL)
-		|| (cxt->step_c_ctl.enable_nodata == NULL)
-		|| (cxt->step_c_ctl.step_d_set_delay == NULL)
-		|| (cxt->step_c_ctl.enable_significant == NULL)
-		|| (cxt->step_c_ctl.enable_step_detect == NULL)) {
-		pr_debug("step_c register control path fail\n");
-		return -1;
-	}
-
-	/* add misc dev for sensor hal control cmd */
-	err = step_c_misc_init(step_c_context_obj);
-	if (err) {
-		pr_err("unable to register step_c misc device!!\n");
-		return -2;
-	}
-	err = sysfs_create_group(&step_c_context_obj->mdev.this_device->kobj,
-				 &step_c_attribute_group);
-	if (err < 0) {
-		pr_err("unable to create step_c attribute file\n");
-		return -3;
-	}
-
-	kobject_uevent(&step_c_context_obj->mdev.this_device->kobj, KOBJ_ADD);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(step_c_register_control_path);
-
-int step_c_data_report_t(uint32_t new_counter, int status, int64_t time_stamp)
-{
-	int err = 0;
-	struct sensor_event event;
-	static uint32_t last_step_counter;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-	event.time_stamp = time_stamp;
-	if (last_step_counter != new_counter) {
-		event.flush_action = DATA_ACTION;
-		event.handle = ID_STEP_COUNTER;
-		event.word[0] = new_counter;
-		err = sensor_input_event(step_c_context_obj->mdev.minor,
-			&event);
-		if (err >= 0)
-			last_step_counter = new_counter;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(step_c_data_report_t);
-
-int step_c_data_report(uint32_t new_counter, int status)
-{
-	return step_c_data_report_t(new_counter, status, 0);
-}
-
-int floor_c_data_report_t(uint32_t new_counter, int status, int64_t time_stamp)
-{
-	int err = 0;
-	struct sensor_event event;
-	static uint32_t last_floor_counter;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-	event.time_stamp = time_stamp;
-	if (last_floor_counter != new_counter) {
-		event.flush_action = DATA_ACTION;
-		event.handle = ID_FLOOR_COUNTER;
-		event.word[0] = new_counter;
-		err = sensor_input_event(step_c_context_obj->mdev.minor,
-			&event);
-		if (err >= 0)
-			last_floor_counter = new_counter;
-	}
-	return err;
-}
-EXPORT_SYMBOL_GPL(floor_c_data_report_t);
-
-int floor_c_data_report(uint32_t new_counter, int status)
-{
-	return floor_c_data_report_t(new_counter, status, 0);
-}
-EXPORT_SYMBOL_GPL(floor_c_data_report);
-
-int step_c_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.handle = ID_STEP_COUNTER;
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(step_c_context_obj->mdev.minor, &event);
-	pr_debug_ratelimited("flush\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(step_c_flush_report);
-
-int step_d_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.handle = ID_STEP_DETECTOR;
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(step_c_context_obj->mdev.minor, &event);
-	pr_debug_ratelimited("flush\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(step_d_flush_report);
-
-int smd_flush_report(void)
-{
-	return 0;
-}
-
-int floor_c_flush_report(void)
-{
-	struct sensor_event event;
-	int err = 0;
-
-	memset(&event, 0, sizeof(struct sensor_event));
-
-	event.handle = ID_FLOOR_COUNTER;
-	event.flush_action = FLUSH_ACTION;
-	err = sensor_input_event(step_c_context_obj->mdev.minor, &event);
-	pr_debug_ratelimited("flush\n");
-	return err;
-}
-EXPORT_SYMBOL_GPL(floor_c_flush_report);
-
-int step_c_probe(void)
-{
-
-	int err;
-
-	pr_debug("%s+++!!\n", __func__);
-
-	step_c_context_obj = step_c_context_alloc_object();
-	if (!step_c_context_obj) {
-		err = -ENOMEM;
-		pr_err("unable to allocate devobj!\n");
-		goto exit_alloc_data_failed;
-	}
-
-	/* init real step_c driver */
-	err = step_c_real_driver_init();
-	if (err) {
-		pr_err("step_c real driver init fail\n");
-		goto real_driver_init_fail;
-	}
-
-	pr_debug("%s---- OK !!\n", __func__);
-	return 0;
-real_driver_init_fail:
-	kfree(step_c_context_obj);
-exit_alloc_data_failed:
-	pr_debug("%s---- fail !!!\n", __func__);
-	return err;
-}
-EXPORT_SYMBOL_GPL(step_c_probe);
-
-int step_c_remove(void)
-{
-
-	int err = 0;
-
-	pr_debug("%s\n", __func__);
-	sysfs_remove_group(&step_c_context_obj->mdev.this_device->kobj,
-		&step_c_attribute_group);
-
-	err = sensor_attr_deregister(&step_c_context_obj->mdev);
-	if (err)
-		pr_err("misc_deregister fail: %d\n", err);
-	kfree(step_c_context_obj);
-	platform_driver_unregister(&step_counter_driver);
-
-	return 0;
-}
-EXPORT_SYMBOL_GPL(step_c_remove);
-
-static int __init step_c_init(void)
-{
-	pr_debug("%s\n", __func__);
-	return 0;
-}
-
-static void __exit step_c_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(step_c_init);
-module_exit(step_c_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("STEP_CMETER device driver");
-MODULE_AUTHOR("Mediatek");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/step_counter.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/step_counter.h
deleted file mode 100644
index c469fc4..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/step_counter.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef __STEP_C_H__
-#define __STEP_C_H__
-
-
-//#include <linux/pm_wakeup.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/workqueue.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-
-#include <linux/irq.h>
-#include <linux/uaccess.h>
-#include <linux/delay.h>
-#include <linux/kobject.h>
-#include <linux/atomic.h>
-#include <linux/ioctl.h>
-
-#include <sensors_io.h>
-#include <hwmsen_helper.h>
-#include <hwmsensor.h>
-#include <linux/poll.h>
-#include "sensor_attr.h"
-#include "sensor_event.h"
-
-#define	OP_STEP_C_DELAY		0X01
-#define	OP_STEP_C_ENABLE		0X02
-#define	OP_STEP_C_GET_DATA	0X04
-
-#define STEP_C_INVALID_VALUE -1
-
-#define EVENT_TYPE_STEP_C_VALUE				ABS_X
-#define EVENT_TYPE_STEP_C_STATUS			ABS_WHEEL
-#define EVENT_TYPE_STEP_DETECTOR_VALUE		REL_Y
-#define EVENT_TYPE_SIGNIFICANT_VALUE		REL_Z
-
-
-
-#define STEP_C_VALUE_MAX (32767)
-#define STEP_C_VALUE_MIN (-32768)
-#define STEP_C_STATUS_MIN (0)
-#define STEP_C_STATUS_MAX (64)
-#define STEP_C_DIV_MAX (32767)
-#define STEP_C_DIV_MIN (1)
-
-
-#define MAX_CHOOSE_STEP_C_NUM 5
-
-struct step_c_control_path {
-	int (*open_report_data)(int open);/* open data rerport to HAL */
-	int (*enable_nodata)(int en);/* only enable not report event to HAL */
-	int (*enable_step_detect)(int en);
-	int (*enable_significant)(int en);
-	int (*enable_floor_c)(int en);
-	int (*step_c_set_delay)(u64 delay);
-	int (*step_d_set_delay)(u64 delay);
-	int (*floor_c_set_delay)(u64 delay);
-	int (*step_c_batch)(int flag,
-		int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs);
-	int (*step_c_flush)(void);/* open data rerport to HAL */
-	int (*step_d_batch)(int flag,
-		int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs);
-	int (*step_d_flush)(void);/* open data rerport to HAL */
-	int (*smd_batch)(int flag,
-		int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs);
-	int (*smd_flush)(void);/* open data rerport to HAL */
-	int (*floor_c_batch)(int flag,
-		int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs);
-	int (*floor_c_flush)(void);/* open data rerport to HAL */
-	bool is_report_input_direct;
-	bool is_counter_support_batch;/* version2. batch M support flag */
-	bool is_detector_support_batch;/* version2. batch M support flag */
-	bool is_smd_support_batch;/* version2. batch M support flag */
-	bool is_floor_c_support_batch;/* version2. batch M support flag */
-};
-
-struct step_c_data_path {
-	int (*get_data)(uint32_t *value, int *status);
-	int (*get_data_step_d)(uint32_t *value, int *status);
-	int (*get_data_significant)(uint32_t *value, int *status);
-	int (*get_data_floor_c)(uint32_t *value, int *status);
-	int vender_div;
-};
-
-struct step_c_init_info {
-	char *name;
-	int (*init)(void);
-	int (*uninit)(void);
-	struct platform_driver *platform_diver_addr;
-};
-
-struct step_c_data {
-	uint32_t counter;
-	int status;
-	int data_updata;
-	uint32_t floor_counter;
-	int floor_c_status;
-	int floor_c_data_updata;
-};
-
-struct step_c_drv_obj {
-	void *self;
-	int polling;
-	int (*step_c_operate)(void *self, uint32_t command, void *buff_in,
-		int size_in, void *buff_out, int size_out, int *actualout);
-};
-
-struct step_c_context {
-	struct input_dev   *idev;
-	struct sensor_attr_t   mdev;
-	struct work_struct  report;
-	struct mutex step_c_op_mutex;
-	atomic_t delay; /*polling period for reporting input event*/
-	atomic_t wake;  /*user-space request to wake-up, used with stop*/
-	struct timer_list   timer;  /* polling timer */
-	atomic_t            trace;
-
-	atomic_t                early_suspend;
-
-	struct step_c_data       drv_data;
-	struct step_c_control_path   step_c_ctl;
-	struct step_c_data_path   step_c_data;
-	bool is_active_nodata;
-	bool is_active_data;		/* Active and HAL need */
-	bool is_floor_c_active_data;	/* Active and HAL need */
-	bool is_first_data_after_enable;
-	bool is_first_floor_c_data_after_enable;
-	bool is_polling_run;
-	bool is_step_c_batch_enable;	/* v2. judge whether sensor in batch M*/
-	bool is_step_d_batch_enable;	/* v2. judge whether sensor in batch M*/
-	bool is_floor_c_batch_enable;   /* v2. judge whether sensor in batch M*/
-};
-
-/* for auto detect */
-enum STEP_NOTIFY_TYPE {
-	TYPE_STEP_NON   = 0,
-	TYPE_STEP_DETECTOR  = 1,
-	TYPE_SIGNIFICANT = 2
-};
-
-extern int  step_notify_t(enum STEP_NOTIFY_TYPE type, int64_t time_stamp);
-extern int  step_notify(enum STEP_NOTIFY_TYPE type);
-
-extern int step_c_driver_add(struct step_c_init_info *obj);
-extern int step_c_data_report_t(uint32_t new_counter, int status,
-	int64_t time_stamp);
-extern int step_c_data_report(uint32_t new_counter, int status);
-extern int step_c_flush_report(void);
-extern int step_d_flush_report(void);
-extern int smd_flush_report(void);
-extern int floor_c_data_report_t(uint32_t new_counter,
-	int status, int64_t time_stamp);
-int floor_c_data_report(uint32_t new_counter, int status);
-extern int floor_c_flush_report(void);
-extern int step_c_register_control_path(struct step_c_control_path *ctl);
-extern int step_c_register_data_path(struct step_c_data_path *data);
-extern int step_c_probe(void);
-extern int step_c_remove(void);
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Kconfig b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Kconfig
deleted file mode 100644
index f27706e..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Kconfig
+++ /dev/null
@@ -1,9 +0,0 @@
-
-config MTK_STEPSIGNHUB
-	bool "STEPSIGNHUB for MediaTek package"
-	help
-	  A significant motions is a device,
-	  usually portable
-	  and electronic or electromechanical,
-	  that detect each step a person takes
-	  by detecting the motion of the person's hands or hips.
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Makefile b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Makefile
deleted file mode 100644
index 2d26116..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/step_counter
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/hwmon/include
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/sensors-1.0/sensorHub/inc_v1
-ccflags-y += -I$(srctree)/drivers/misc/mediatek/scp
-obj-$(CONFIG_MTK_SENSOR_SUPPORT) +=  stepsignhub.o
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/stepsignhub.c b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/stepsignhub.c
deleted file mode 100644
index bb039c7..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/stepsignhub.c
+++ /dev/null
@@ -1,436 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#define pr_fmt(fmt) "[stepsignhub] " fmt
-
-#include <hwmsensor.h>
-#include "stepsignhub.h"
-#include <step_counter.h>
-#include <SCP_sensorHub.h>
-#include <linux/notifier.h>
-#include "include/scp.h"
-
-enum STEP_CDS_TRC {
-	STEP_CDSH_TRC_INFO = 0X10,
-};
-
-static struct step_c_init_info step_cdshub_init_info;
-
-struct step_chub_ipi_data {
-	atomic_t trace;
-	atomic_t suspend;
-};
-
-static struct step_chub_ipi_data obj_ipi_data;
-
-static ssize_t trace_store(struct device_driver *ddri,
-	const char *buf, size_t count)
-{
-	struct step_chub_ipi_data *obj = &obj_ipi_data;
-	int trace = 0;
-
-	if (obj == NULL) {
-		pr_err("obj is null!!\n");
-		return 0;
-	}
-
-	if (sscanf(buf, "0x%x", &trace) == 1) {
-		atomic_set(&obj->trace, trace);
-	} else {
-		pr_err("invalid content: '%s', length = %zu\n",
-			buf, count);
-		return 0;
-	}
-	return count;
-}
-
-static DRIVER_ATTR_WO(trace);
-
-static struct driver_attribute *step_chub_attr_list[] = {
-	&driver_attr_trace,
-};
-
-static int step_chub_create_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(ARRAY_SIZE(step_chub_attr_list));
-
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++) {
-		err = driver_create_file(driver, step_chub_attr_list[idx]);
-		if (err != 0) {
-			pr_err("driver_create_file (%s) = %d\n",
-				     step_chub_attr_list[idx]->attr.name, err);
-			break;
-		}
-	}
-	return err;
-}
-
-static int step_chub_delete_attr(struct device_driver *driver)
-{
-	int idx, err = 0;
-	int num = (int)(ARRAY_SIZE(step_chub_attr_list));
-
-	if (driver == NULL)
-		return -EINVAL;
-
-	for (idx = 0; idx < num; idx++)
-		driver_remove_file(driver, step_chub_attr_list[idx]);
-
-	return err;
-}
-
-static int step_c_enable_nodata(int en)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (en == 1)
-		ret = sensor_set_delay_to_hub(ID_STEP_COUNTER, 120);
-#endif
-	ret = sensor_enable_to_hub(ID_STEP_COUNTER, en);
-	return ret;
-}
-
-static int step_d_enable_nodata(int en)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (en == 1)
-		ret = sensor_set_delay_to_hub(ID_STEP_DETECTOR, 120);
-#endif
-	ret = sensor_enable_to_hub(ID_STEP_DETECTOR, en);
-	return ret;
-}
-
-static int step_s_enable_nodata(int en)
-{
-	int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	if (en == 1)
-		ret = sensor_set_delay_to_hub(ID_SIGNIFICANT_MOTION, 120);
-#endif
-	ret = sensor_enable_to_hub(ID_SIGNIFICANT_MOTION, en);
-	return ret;
-}
-
-static int floor_c_enable_nodata(int en)
-{
-	int ret = 0;
-
-	ret = sensor_enable_to_hub(ID_FLOOR_COUNTER, en);
-	return ret;
-}
-
-static int step_c_set_delay(u64 delay)
-{
-	unsigned int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	unsigned int delayms = 0;
-
-	delayms = delay / 1000 / 1000;
-	ret = sensor_set_delay_to_hub(ID_STEP_COUNTER, delayms);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	return ret;
-}
-
-static int step_c_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_STEP_COUNTER,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int step_c_flush(void)
-{
-	return sensor_flush_to_hub(ID_STEP_COUNTER);
-}
-
-static int step_d_set_delay(u64 delay)
-{
-	unsigned int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	unsigned int delayms = 0;
-
-	delayms = delay / 1000 / 1000;
-	ret = sensor_set_delay_to_hub(ID_STEP_DETECTOR, delayms);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	return ret;
-}
-
-static int step_d_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_STEP_DETECTOR,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int step_d_flush(void)
-{
-	return sensor_flush_to_hub(ID_STEP_DETECTOR);
-}
-
-static int floor_c_set_delay(u64 delay)
-{
-	unsigned int ret = 0;
-
-#if defined CONFIG_MTK_SCP_SENSORHUB_V1
-	unsigned int delayms = 0;
-
-	delayms = delay / 1000 / 1000;
-	ret = sensor_set_delay_to_hub(ID_FLOOR_COUNTER, delayms);
-#elif defined CONFIG_NANOHUB
-
-#else
-
-#endif
-	return ret;
-}
-static int floor_c_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_FLOOR_COUNTER,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int floor_c_flush(void)
-{
-	return sensor_flush_to_hub(ID_FLOOR_COUNTER);
-}
-
-static int step_counter_get_data(uint32_t *counter, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_STEP_COUNTER, &data);
-	if (err < 0) {
-		pr_err("sensor_get_data_from_hub fail!!\n");
-		return -1;
-	}
-	time_stamp = data.time_stamp;
-	*counter = data.step_counter_t.accumulated_step_count;
-	return 0;
-}
-
-static int step_detector_get_data(uint32_t *counter, int *status)
-{
-	return 0;
-}
-
-static int smd_batch(int flag,
-	int64_t samplingPeriodNs, int64_t maxBatchReportLatencyNs)
-{
-	return sensor_batch_to_hub(ID_SIGNIFICANT_MOTION,
-		flag, samplingPeriodNs, maxBatchReportLatencyNs);
-}
-
-static int smd_flush(void)
-{
-	return sensor_flush_to_hub(ID_SIGNIFICANT_MOTION);
-}
-
-static int significant_get_data(uint32_t *counter, int *status)
-{
-	return 0;
-}
-
-static int floor_counter_get_data(uint32_t *counter, int *status)
-{
-	int err = 0;
-	struct data_unit_t data;
-	uint64_t time_stamp = 0;
-
-	err = sensor_get_data_from_hub(ID_FLOOR_COUNTER, &data);
-	if (err < 0) {
-		pr_err("%s fail!!\n", __func__);
-		return -1;
-	}
-	time_stamp = data.time_stamp;
-	*counter = data.floor_counter_t.accumulated_floor_count;
-	return 0;
-}
-
-static int step_cds_open_report_data(int open)
-{
-	return 0;
-}
-
-static int step_detect_recv_data(struct data_unit_t *event,
-				void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = step_d_flush_report();
-	else if (event->flush_action == DATA_ACTION)
-		err = step_notify_t(TYPE_STEP_DETECTOR,
-			(int64_t)event->time_stamp);
-	return err;
-}
-
-static int step_count_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = step_c_flush_report();
-	else if (event->flush_action == DATA_ACTION)
-		err = step_c_data_report_t(
-			event->step_counter_t.accumulated_step_count,
-			2, (int64_t)event->time_stamp);
-	return err;
-}
-
-static int sign_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-
-	if (event->flush_action == FLUSH_ACTION)
-		pr_err("sign do not support flush\n");
-	else if (event->flush_action == DATA_ACTION)
-		err = step_notify_t(TYPE_SIGNIFICANT,
-			(int64_t)event->time_stamp);
-	return err;
-}
-
-static int floor_count_recv_data(struct data_unit_t *event, void *reserved)
-{
-	int err = 0;
-	struct floor_counter_event_t *pfloor_counter = &event->floor_counter_t;
-
-	if (event->flush_action == FLUSH_ACTION)
-		err = floor_c_flush_report();
-	else if (event->flush_action == DATA_ACTION)
-		err = floor_c_data_report_t(
-			pfloor_counter->accumulated_floor_count, 2,
-			(int64_t)event->time_stamp);
-	return err;
-}
-
-static int step_chub_local_init(void)
-{
-	struct step_c_control_path ctl = { 0 };
-	struct step_c_data_path data = { 0 };
-	int err = 0;
-	struct platform_driver *paddr =
-		step_cdshub_init_info.platform_diver_addr;
-
-	err = step_chub_create_attr(&paddr->driver);
-	if (err) {
-		pr_err("create attribute err = %d\n", err);
-		goto exit_create_attr_failed;
-	}
-	ctl.open_report_data = step_cds_open_report_data;
-	ctl.enable_nodata = step_c_enable_nodata;
-	ctl.enable_step_detect = step_d_enable_nodata;
-	ctl.enable_significant = step_s_enable_nodata;
-	ctl.enable_floor_c = floor_c_enable_nodata;
-	ctl.step_c_set_delay = step_c_set_delay;
-	ctl.step_d_set_delay = step_d_set_delay;
-	ctl.floor_c_set_delay = floor_c_set_delay;
-	ctl.step_c_batch = step_c_batch;
-	ctl.step_c_flush = step_c_flush;
-	ctl.step_d_batch = step_d_batch;
-	ctl.step_d_flush = step_d_flush;
-	ctl.floor_c_batch = floor_c_batch;
-	ctl.floor_c_flush = floor_c_flush;
-	ctl.smd_batch = smd_batch;
-	ctl.smd_flush = smd_flush;
-	ctl.is_report_input_direct = true;
-	ctl.is_counter_support_batch = false;
-	ctl.is_detector_support_batch = true;
-	ctl.is_smd_support_batch = false;
-	err = step_c_register_control_path(&ctl);
-	if (err) {
-		pr_err("register step_cds control path err\n");
-		goto exit;
-	}
-
-	data.get_data = step_counter_get_data;
-	data.get_data_step_d = step_detector_get_data;
-	data.get_data_significant = significant_get_data;
-	data.get_data_floor_c = floor_counter_get_data;
-	err = step_c_register_data_path(&data);
-	if (err) {
-		pr_err("register step_cds data path err\n");
-		goto exit;
-	}
-	err = scp_sensorHub_data_registration(ID_STEP_DETECTOR,
-		step_detect_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	err =
-	    scp_sensorHub_data_registration(ID_SIGNIFICANT_MOTION,
-					   sign_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	err = scp_sensorHub_data_registration(ID_STEP_COUNTER,
-		step_count_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	err = scp_sensorHub_data_registration(ID_FLOOR_COUNTER,
-		floor_count_recv_data);
-	if (err) {
-		pr_err("SCP_sensorHub_data_registration fail!!\n");
-		goto exit_create_attr_failed;
-	}
-	return 0;
-exit:
-	step_chub_delete_attr(&paddr->driver);
-exit_create_attr_failed:
-	return -1;
-}
-
-static int step_chub_local_uninit(void)
-{
-	return 0;
-}
-
-static struct step_c_init_info step_cdshub_init_info = {
-	.name = "step_cds_hub",
-	.init = step_chub_local_init,
-	.uninit = step_chub_local_uninit,
-};
-
-static int __init step_chub_init(void)
-{
-	step_c_driver_add(&step_cdshub_init_info);
-	return 0;
-}
-
-static void __exit step_chub_exit(void)
-{
-	pr_debug("%s\n", __func__);
-}
-
-module_init(step_chub_init);
-module_exit(step_chub_exit);
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("GLANCE_GESTURE_HUB driver");
-MODULE_AUTHOR("hongxu.zhao@mediatek.com");
diff --git a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/stepsignhub.h b/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/stepsignhub.h
deleted file mode 100644
index 1bf97dd..0000000
--- a/src/kernel/linux/v4.19/drivers/misc/mediatek/sensors-1.0/step_counter/stepsignhub/stepsignhub.h
+++ /dev/null
@@ -1,11 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Copyright (c) 2019 MediaTek Inc.
- */
-
-#ifndef STEPSIGNHUB_H
-#define STEPSIGNHUB_H
-
-#include <linux/ioctl.h>
-
-#endif
diff --git a/src/kernel/linux/v4.19/drivers/spi/spidev.c b/src/kernel/linux/v4.19/drivers/spi/spidev.c
index bf189d1..fa34a32 100644
--- a/src/kernel/linux/v4.19/drivers/spi/spidev.c
+++ b/src/kernel/linux/v4.19/drivers/spi/spidev.c
@@ -724,7 +724,7 @@
 	struct spidev_data	*spidev;
 	int			status;
 	unsigned long		minor;
-printk("GLENN\n");
+
 	/*
 	 * spidev should never be referenced in DT without a specific
 	 * compatible string, it is a Linux implementation thing
diff --git a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3.h b/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3.h
index 9606963..0b06a61 100644
--- a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3.h
+++ b/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3.h
@@ -309,6 +309,8 @@
 	bool clk_mgr;
 	PLATFORM_TYPE plat_type;
 	PHY_WORKAROUND_MODE fpga_phy_workaround;
+	struct mutex mutex;
+	bool power_status;
 };
 
 /**
diff --git a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_core1.c b/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_core1.c
deleted file mode 100755
index 0f2cb9b..0000000
--- a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_core1.c
+++ /dev/null
@@ -1,1142 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * mtu3_core.c - hardware access layer and gadget init/exit of
- *                     MediaTek usb3 Dual-Role Controller Driver
- *
- * Copyright (C) 2016 MediaTek Inc.
- *
- * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
- */
-
-#include <linux/dma-mapping.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/of_address.h>
-#include <linux/of_irq.h>
-#include <linux/platform_device.h>
-#include <linux/of_gpio.h>
-#include <linux/gpio.h>
-
-#include "mtu3.h"
-#include "mtu3_debug.h"
-#include "mtu3_trace.h"
-
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-static int total_isr_debug = 1;
-module_param(total_isr_debug, uint, 0644);
-MODULE_PARM_DESC (total_isr_debug, "profile total USB isr");
-extern unsigned long total_isr;
-
-static int ep_fifo_alloc(struct mtu3_ep *mep, u32 seg_size)
-{
-	struct mtu3_fifo_info *fifo = mep->fifo;
-	u32 num_bits = DIV_ROUND_UP(seg_size, MTU3_EP_FIFO_UNIT);
-	u32 start_bit;
-
-	/* ensure that @mep->fifo_seg_size is power of two */
-	num_bits = roundup_pow_of_two(num_bits);
-	if (num_bits > fifo->limit)
-		return -EINVAL;
-
-	mep->fifo_seg_size = num_bits * MTU3_EP_FIFO_UNIT;
-	num_bits = num_bits * (mep->slot + 1);
-	start_bit = bitmap_find_next_zero_area(fifo->bitmap,
-			fifo->limit, 0, num_bits, 0);
-	if (start_bit >= fifo->limit)
-		return -EOVERFLOW;
-
-	bitmap_set(fifo->bitmap, start_bit, num_bits);
-	mep->fifo_size = num_bits * MTU3_EP_FIFO_UNIT;
-	mep->fifo_addr = fifo->base + MTU3_EP_FIFO_UNIT * start_bit;
-
-	dev_dbg(mep->mtu->dev, "%s fifo:%#x/%#x, start_bit: %d\n",
-		__func__, mep->fifo_seg_size, mep->fifo_size, start_bit);
-
-	return mep->fifo_addr;
-}
-#endif
-
-static void ep_fifo_free(struct mtu3_ep *mep)
-{
-	struct mtu3_fifo_info *fifo = mep->fifo;
-	u32 addr = mep->fifo_addr;
-	u32 bits = mep->fifo_size / MTU3_EP_FIFO_UNIT;
-	u32 start_bit;
-
-	if (unlikely(addr < fifo->base || bits > fifo->limit))
-		return;
-
-	start_bit = (addr - fifo->base) / MTU3_EP_FIFO_UNIT;
-	bitmap_clear(fifo->bitmap, start_bit, bits);
-	mep->fifo_size = 0;
-	mep->fifo_seg_size = 0;
-
-	dev_dbg(mep->mtu->dev, "%s size:%#x/%#x, start_bit: %d\n",
-		__func__, mep->fifo_seg_size, mep->fifo_size, start_bit);
-}
-
-/* enable/disable U3D SS function */
-static inline void mtu3_ss_func_set(struct mtu3 *mtu, bool enable)
-{
-	/* If usb3_en==0, LTSSM will go to SS.Disable state */
-	if (enable) {
-		/*
-			Temp Fix:
-			A60931 new DTB has true type-C connector.
-			Phy sends vbus_present and starts to swap lane.
-			It will take about 120ms to swap lane if needed.
-			Device shall wait lane swap and then enable U3 terminator.
-		*/
-		if (mtu->ssusb->plat_type == PLAT_FPGA && mtu->ssusb->fpga_phy_workaround == A60931_WORKAROUND){
-			mdelay(180);
-		}
-		mtu3_setbits(mtu->mac_base, U3D_USB3_CONFIG, USB3_EN);
-	}
-	else
-		mtu3_clrbits(mtu->mac_base, U3D_USB3_CONFIG, USB3_EN);
-
-	dev_info(mtu->dev, "USB3_EN = %d\n", !!enable);
-}
-
-/* set/clear U3D HS device soft connect */
-static inline void mtu3_hs_softconn_set(struct mtu3 *mtu, bool enable)
-{
-	if (enable) {
-		mtu3_setbits(mtu->mac_base, U3D_POWER_MANAGEMENT,
-			SOFT_CONN | SUSPENDM_ENABLE);
-	} else {
-		mtu3_clrbits(mtu->mac_base, U3D_POWER_MANAGEMENT,
-			SOFT_CONN | SUSPENDM_ENABLE);
-	}
-	dev_info(mtu->dev, "SOFTCONN = %d\n", !!enable);
-}
-
-/* only port0 of U2/U3 supports device mode */
-static int mtu3_device_enable(struct mtu3 *mtu)
-{
-	void __iomem *ibase = mtu->ippc_base;
-	u32 check_clk = 0;
-
-	mtu3_clrbits(ibase, U3D_SSUSB_IP_PW_CTRL2, SSUSB_IP_DEV_PDN);
-
-	if (mtu->is_u3_ip) {
-		check_clk = SSUSB_U3_MAC_RST_B_STS;
-		mtu3_clrbits(ibase, SSUSB_U3_CTRL(0),
-			(SSUSB_U3_PORT_DIS | SSUSB_U3_PORT_PDN |
-			SSUSB_U3_PORT_HOST_SEL));
-	}
-	mtu3_clrbits(ibase, SSUSB_U2_CTRL(0),
-		(SSUSB_U2_PORT_DIS | SSUSB_U2_PORT_PDN |
-		SSUSB_U2_PORT_HOST_SEL));
-
-	if (mtu->ssusb->dr_mode == USB_DR_MODE_OTG) {
-		mtu3_setbits(ibase, SSUSB_U2_CTRL(0), SSUSB_U2_PORT_OTG_SEL);
-		if (mtu->is_u3_ip)
-			mtu3_setbits(ibase, SSUSB_U3_CTRL(0),
-				     SSUSB_U3_PORT_DUAL_MODE);
-	}
-
-	return ssusb_check_clocks(mtu->ssusb, check_clk);
-}
-
-static void mtu3_device_disable(struct mtu3 *mtu)
-{
-	void __iomem *ibase = mtu->ippc_base;
-
-	if (mtu->is_u3_ip)
-		mtu3_setbits(ibase, SSUSB_U3_CTRL(0),
-			(SSUSB_U3_PORT_DIS | SSUSB_U3_PORT_PDN));
-
-	mtu3_setbits(ibase, SSUSB_U2_CTRL(0),
-		SSUSB_U2_PORT_DIS | SSUSB_U2_PORT_PDN);
-
-	if (mtu->ssusb->dr_mode == USB_DR_MODE_OTG)
-		mtu3_clrbits(ibase, SSUSB_U2_CTRL(0), SSUSB_U2_PORT_OTG_SEL);
-
-	mtu3_setbits(ibase, U3D_SSUSB_IP_PW_CTRL2, SSUSB_IP_DEV_PDN);
-}
-
-/* reset U3D's device module. */
-static void mtu3_device_reset(struct mtu3 *mtu)
-{
-	void __iomem *ibase = mtu->ippc_base;
-
-	mtu3_setbits(ibase, U3D_SSUSB_DEV_RST_CTRL, SSUSB_DEV_SW_RST);
-	udelay(1);
-	mtu3_clrbits(ibase, U3D_SSUSB_DEV_RST_CTRL, SSUSB_DEV_SW_RST);
-}
-
-/* disable all interrupts */
-static void mtu3_intr_disable(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-
-	/* Disable level 1 interrupts */
-	mtu3_writel(mbase, U3D_LV1IECR, ~0x0);
-	/* Disable endpoint interrupts */
-	mtu3_writel(mbase, U3D_EPIECR, ~0x0);
-}
-
-static void mtu3_intr_status_clear(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-
-	/* Clear EP0 and Tx/Rx EPn interrupts status */
-	mtu3_writel(mbase, U3D_EPISR, ~0x0);
-	/* Clear U2 USB common interrupts status */
-	mtu3_writel(mbase, U3D_COMMON_USB_INTR, ~0x0);
-	/* Clear U3 LTSSM interrupts status */
-	mtu3_writel(mbase, U3D_LTSSM_INTR, ~0x0);
-	/* Clear speed change interrupt status */
-	mtu3_writel(mbase, U3D_DEV_LINK_INTR, ~0x0);
-}
-
-/* enable system global interrupt */
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-static void mtu3_intr_enable(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-	u32 value;
-
-	/*Enable level 1 interrupts (BMU, QMU, MAC3, DMA, MAC2, EPCTL) */
-	value = BMU_INTR | QMU_INTR | MAC3_INTR | MAC2_INTR | EP_CTRL_INTR;
-	mtu3_writel(mbase, U3D_LV1IESR, value);
-
-	/* Enable U2 common USB interrupts */
-	value = SUSPEND_INTR | RESUME_INTR | RESET_INTR | LPM_RESUME_INTR;
-	mtu3_writel(mbase, U3D_COMMON_USB_INTR_ENABLE, value);
-
-	if (mtu->is_u3_ip) {
-		/* Enable U3 LTSSM interrupts */
-		value = HOT_RST_INTR | WARM_RST_INTR |
-			ENTER_U3_INTR | EXIT_U3_INTR;
-		mtu3_writel(mbase, U3D_LTSSM_INTR_ENABLE, value);
-	}
-
-	/* Enable QMU interrupts. */
-	value = TXQ_CSERR_INT | TXQ_LENERR_INT | RXQ_CSERR_INT |
-			RXQ_LENERR_INT | RXQ_ZLPERR_INT;
-	mtu3_writel(mbase, U3D_QIESR1, value);
-
-	/* Enable speed change interrupt */
-	mtu3_writel(mbase, U3D_DEV_LINK_INTR_ENABLE, SSUSB_DEV_SPEED_CHG_INTR);
-}
-#else
-static void mtu3_intr_enable(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-	u32 value;
-
-	/*Enable level 1 interrupts (BMU, QMU, MAC3, DMA, MAC2, EPCTL) */
-	value = QMU_INTR;
-	mtu3_writel(mbase, U3D_LV1IESR, value);
-
-	/* Enable QMU interrupts. */
-	value = TXQ_CSERR_INT | TXQ_LENERR_INT | RXQ_CSERR_INT |
-			RXQ_LENERR_INT | RXQ_ZLPERR_INT;
-	mtu3_writel(mbase, U3D_QIESR1, value);
-}
-
-#endif
-
-/* reset: u2 - data toggle, u3 - SeqN, flow control status etc */
-static void mtu3_ep_reset(struct mtu3_ep *mep)
-{
-	struct mtu3 *mtu = mep->mtu;
-	u32 rst_bit = EP_RST(mep->is_in, mep->epnum);
-
-	mtu3_setbits(mtu->mac_base, U3D_EP_RST, rst_bit);
-	mtu3_clrbits(mtu->mac_base, U3D_EP_RST, rst_bit);
-}
-
-/* set/clear the stall and toggle bits for non-ep0 */
-void mtu3_ep_stall_set(struct mtu3_ep *mep, bool set)
-{
-	struct mtu3 *mtu = mep->mtu;
-	void __iomem *mbase = mtu->mac_base;
-	u8 epnum = mep->epnum;
-	u32 csr;
-
-	if (mep->is_in) {	/* TX */
-		csr = mtu3_readl(mbase, MU3D_EP_TXCR0(epnum)) & TX_W1C_BITS;
-		if (set)
-			csr |= TX_SENDSTALL;
-		else
-			csr = (csr & (~TX_SENDSTALL)) | TX_SENTSTALL;
-		mtu3_writel(mbase, MU3D_EP_TXCR0(epnum), csr);
-	} else {	/* RX */
-		csr = mtu3_readl(mbase, MU3D_EP_RXCR0(epnum)) & RX_W1C_BITS;
-		if (set)
-			csr |= RX_SENDSTALL;
-		else
-			csr = (csr & (~RX_SENDSTALL)) | RX_SENTSTALL;
-		mtu3_writel(mbase, MU3D_EP_RXCR0(epnum), csr);
-	}
-
-	if (!set) {
-		mtu3_ep_reset(mep);
-		mep->flags &= ~MTU3_EP_STALL;
-	} else {
-		mep->flags |= MTU3_EP_STALL;
-	}
-
-	dev_dbg(mtu->dev, "%s: %s\n", mep->name,
-		set ? "SEND STALL" : "CLEAR STALL, with EP RESET");
-}
-
-void mtu3_dev_on_off(struct mtu3 *mtu, int is_on)
-{
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-	if (mtu->is_u3_ip && mtu->max_speed >= USB_SPEED_SUPER)
-		mtu3_ss_func_set(mtu, is_on);
-	else
-		mtu3_hs_softconn_set(mtu, is_on);
-#endif
-
-	dev_info(mtu->dev, "gadget (%s) pullup D%s\n",
-		usb_speed_string(mtu->max_speed), is_on ? "+" : "-");
-}
-
-static void mtu3_set_speed(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-
-	if (!mtu->is_u3_ip && (mtu->max_speed > USB_SPEED_HIGH))
-		mtu->max_speed = USB_SPEED_HIGH;
-
-	if (mtu->max_speed == USB_SPEED_FULL) {
-		/* disable U3 SS function */
-		mtu3_clrbits(mbase, U3D_USB3_CONFIG, USB3_EN);
-		/* disable HS function */
-		mtu3_clrbits(mbase, U3D_POWER_MANAGEMENT, HS_ENABLE);
-	} else if (mtu->max_speed == USB_SPEED_HIGH) {
-		mtu3_clrbits(mbase, U3D_USB3_CONFIG, USB3_EN);
-		/* HS/FS detected by HW */
-		mtu3_setbits(mbase, U3D_POWER_MANAGEMENT, HS_ENABLE);
-	} else if (mtu->max_speed == USB_SPEED_SUPER) {
-		mtu3_clrbits(mtu->ippc_base, SSUSB_U3_CTRL(0),
-			     SSUSB_U3_PORT_SSP_SPEED);
-	}
-
-	dev_info(mtu->dev, "max_speed: %s\n",
-		usb_speed_string(mtu->max_speed));
-}
-
-static void mtu3_regs_init(struct mtu3 *mtu)
-{
-
-	void __iomem *mbase = mtu->mac_base;
-	dev_info(mtu->dev, "%s\n", __func__);
-
-	/* be sure interrupts are disabled before registration of ISR */
-	mtu3_intr_disable(mtu);
-	mtu3_intr_status_clear(mtu);
-
-	if (mtu->is_u3_ip) {
-		/* disable LGO_U1/U2 by default */
-		mtu3_clrbits(mbase, U3D_LINK_POWER_CONTROL,
-				SW_U1_REQUEST_ENABLE | SW_U2_REQUEST_ENABLE);
-		/* enable accept LGO_U1/U2 link command from host */
-		mtu3_setbits(mbase, U3D_LINK_POWER_CONTROL,
-				SW_U1_ACCEPT_ENABLE | SW_U2_ACCEPT_ENABLE);
-		/* device responses to u3_exit from host automatically */
-		mtu3_clrbits(mbase, U3D_LTSSM_CTRL, SOFT_U3_EXIT_EN);
-		/* automatically build U2 link when U3 detect fail */
-		mtu3_setbits(mbase, U3D_USB2_TEST_MODE, U2U3_AUTO_SWITCH);
-		/* auto clear SOFT_CONN when clear USB3_EN if work as HS */
-		mtu3_setbits(mbase, U3D_U3U2_SWITCH_CTRL, SOFTCON_CLR_AUTO_EN);
-	}
-
-	mtu3_set_speed(mtu);
-
-	/* delay about 0.1us from detecting reset to send chirp-K */
-	mtu3_clrbits(mbase, U3D_LINK_RESET_INFO, WTCHRP_MSK);
-	/* U2/U3 detected by HW */
-	mtu3_writel(mbase, U3D_DEVICE_CONF, 0);
-	/* vbus detected by HW */
-	mtu3_clrbits(mbase, U3D_MISC_CTRL, VBUS_FRC_EN | VBUS_ON);
-	/* enable automatical HWRW from L1 */
-	mtu3_setbits(mbase, U3D_POWER_MANAGEMENT, LPM_HRWE);
-
-	//ssusb_set_force_vbus(mtu->ssusb, true);
-	mtu3_writel(mbase, U3D_POWER_MANAGEMENT, (mtu3_readl(mbase, U3D_POWER_MANAGEMENT)| LPM_MODE(1)));
-	dev_info(mtu->dev, "%s, U3D_POWER_MANAGEMENT:0x%x\n", __func__, mtu3_readl(mbase, U3D_POWER_MANAGEMENT));
-	/* use new QMU format when HW version >= 0x1003 */
-	if (mtu->gen2cp)
-		mtu3_writel(mbase, U3D_QFCR, ~0x0);
-}
-
-static irqreturn_t mtu3_vbus_detect_eint_isr(int irq, void *data)
-{
-	struct mtu3 *mtu = data;
-
-	disable_irq_nosync(irq);
-
-	if (!gpio_get_value(mtu->detect_gpio)) {
-		dev_info(mtu->dev, "low-level, vbus plug out\n");
-		ssusb_set_force_vbus(mtu->ssusb, false);
-		irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
-	} else {
-		dev_info(mtu->dev, "high-level, vbus plug in\n");
-		ssusb_set_force_vbus(mtu->ssusb, true);
-		irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
-	}
-	enable_irq(irq);
-	return IRQ_HANDLED;
-}
-
-static int mtu3_usb_vbus_detect_init(struct mtu3 *mtu)
-{
-	struct device_node *node;
-	int ret;
-
-	node = of_find_compatible_node(NULL, NULL,
-					"mediatek,mtu3");
-	if (!node) {
-		dev_err(mtu->dev, "map node failed\n");
-		return -ENODEV;
-	}
-
-	ret = of_get_named_gpio(node, "vbus_detect", 0);
-	if (ret < 0) {
-		dev_err(mtu->dev, "no vbus_detect gpio info\n");
-		return ret;
-	}
-	mtu->detect_gpio= ret;
-
-	ret = devm_gpio_request(mtu->dev, mtu->detect_gpio,
-				   "mtu_vbus_detect");
-	if (ret < 0) {
-		dev_err(mtu->dev, "fail to request gpio%d (%d)\n",
-				   mtu->detect_gpio, ret);
-		return ret;
-	}
-
-	ret = gpio_direction_input(mtu->detect_gpio);
-	if (ret < 0) {
-		dev_err(mtu->dev, "fail to set gpio%d as input pin (%d)\n",
-				   mtu->detect_gpio, ret);
-		return ret;
-	}
-
-	/* 20 ms */
-	gpio_set_debounce(mtu->detect_gpio, 20*1000);
-	if (ret < 0) {
-		dev_err(mtu->dev, "fail to set gpio%d debounce (%d)\n",
-				   mtu->detect_gpio, ret);
-		return ret;
-	}
-
-	mtu->detect_irq = gpio_to_irq(mtu->detect_gpio);
-	if (mtu->detect_irq <= 0) {
-		dev_err(mtu->dev, "gpio%d to irq fail, mtu_vbus_detect(%d)\n",
-				   mtu->detect_irq, ret);
-		return ret;
-	}
-
-	ret = request_irq(mtu->detect_irq, mtu3_vbus_detect_eint_isr,
-				   IRQF_TRIGGER_LOW, "mtu_detect_eint", mtu);
-	if (ret) {
-		dev_err(mtu->dev, "request eint(%d) fail (%d)\n",
-				   mtu->detect_irq, ret);
-		return ret;
-	}
-	return 0;
-}
-
-void mtu3_start(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-
-	dev_dbg(mtu->dev, "%s devctl 0x%x\n", __func__,
-		mtu3_readl(mbase, U3D_DEVICE_CONTROL));
-
-	mtu3_clrbits(mtu->ippc_base, U3D_SSUSB_IP_PW_CTRL2, SSUSB_IP_DEV_PDN);
-
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-	/* Initialize the device capability */
-	mtu3_regs_init(mtu);
-#else
-	/*
-	 * When disable U2 port, USB2_CSR's register will be reset to
-	 * default value after re-enable it again(HS is enabled by default).
-	 * So if force mac to work as FS, disable HS function.
-	 */
-	if (mtu->max_speed == USB_SPEED_FULL)
-		mtu3_clrbits(mbase, U3D_POWER_MANAGEMENT, HS_ENABLE);
-#endif
-
-	/* Initialize the default interrupts */
-	mtu3_intr_enable(mtu);
-	mtu->is_active = 1;
-
-	if (mtu->softconnect)
-		mtu3_dev_on_off(mtu, 1);
-}
-
-void mtu3_stop(struct mtu3 *mtu)
-{
-	dev_dbg(mtu->dev, "%s\n", __func__);
-
-	mtu3_intr_disable(mtu);
-	mtu3_intr_status_clear(mtu);
-
-	if (mtu->softconnect)
-		mtu3_dev_on_off(mtu, 0);
-
-	mtu->is_active = 0;
-	mtu3_setbits(mtu->ippc_base, U3D_SSUSB_IP_PW_CTRL2, SSUSB_IP_DEV_PDN);
-}
-
-/* for non-ep0 */
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-int mtu3_config_ep(struct mtu3 *mtu, struct mtu3_ep *mep,
-			int interval, int burst, int mult)
-{
-	void __iomem *mbase = mtu->mac_base;
-	bool gen2cp = mtu->gen2cp;
-	int epnum = mep->epnum;
-	u32 csr0, csr1, csr2;
-	int fifo_sgsz, fifo_addr;
-	int num_pkts;
-
-	fifo_addr = ep_fifo_alloc(mep, mep->maxp);
-	if (fifo_addr < 0) {
-		dev_err(mtu->dev, "alloc ep fifo failed(%d)\n", mep->maxp);
-		return -ENOMEM;
-	}
-	fifo_sgsz = ilog2(mep->fifo_seg_size);
-	dev_dbg(mtu->dev, "%s fifosz: %x(%x/%x)\n", __func__, fifo_sgsz,
-		mep->fifo_seg_size, mep->fifo_size);
-
-	if (mep->is_in) {
-		csr0 = TX_TXMAXPKTSZ(mep->maxp);
-		csr0 |= TX_DMAREQEN;
-
-		num_pkts = (burst + 1) * (mult + 1) - 1;
-		csr1 = TX_SS_BURST(burst) | TX_SLOT(mep->slot);
-		csr1 |= TX_MAX_PKT(gen2cp, num_pkts) | TX_MULT(gen2cp, mult);
-
-		csr2 = TX_FIFOADDR(fifo_addr >> 4);
-		csr2 |= TX_FIFOSEGSIZE(fifo_sgsz);
-
-		switch (mep->type) {
-		case USB_ENDPOINT_XFER_BULK:
-			csr1 |= TX_TYPE(TYPE_BULK);
-			break;
-		case USB_ENDPOINT_XFER_ISOC:
-			csr1 |= TX_TYPE(TYPE_ISO);
-			csr2 |= TX_BINTERVAL(interval);
-			break;
-		case USB_ENDPOINT_XFER_INT:
-			csr1 |= TX_TYPE(TYPE_INT);
-			csr2 |= TX_BINTERVAL(interval);
-			break;
-		}
-
-		/* Enable QMU Done interrupt */
-		mtu3_setbits(mbase, U3D_QIESR0, QMU_TX_DONE_INT(epnum));
-
-		mtu3_writel(mbase, MU3D_EP_TXCR0(epnum), csr0);
-		mtu3_writel(mbase, MU3D_EP_TXCR1(epnum), csr1);
-		mtu3_writel(mbase, MU3D_EP_TXCR2(epnum), csr2);
-
-		dev_dbg(mtu->dev, "U3D_TX%d CSR0:%#x, CSR1:%#x, CSR2:%#x\n",
-			epnum, mtu3_readl(mbase, MU3D_EP_TXCR0(epnum)),
-			mtu3_readl(mbase, MU3D_EP_TXCR1(epnum)),
-			mtu3_readl(mbase, MU3D_EP_TXCR2(epnum)));
-	} else {
-		csr0 = RX_RXMAXPKTSZ(mep->maxp);
-		csr0 |= RX_DMAREQEN;
-
-		num_pkts = (burst + 1) * (mult + 1) - 1;
-		csr1 = RX_SS_BURST(burst) | RX_SLOT(mep->slot);
-		csr1 |= RX_MAX_PKT(gen2cp, num_pkts) | RX_MULT(gen2cp, mult);
-
-		csr2 = RX_FIFOADDR(fifo_addr >> 4);
-		csr2 |= RX_FIFOSEGSIZE(fifo_sgsz);
-
-		switch (mep->type) {
-		case USB_ENDPOINT_XFER_BULK:
-			csr1 |= RX_TYPE(TYPE_BULK);
-			break;
-		case USB_ENDPOINT_XFER_ISOC:
-			csr1 |= RX_TYPE(TYPE_ISO);
-			csr2 |= RX_BINTERVAL(interval);
-			break;
-		case USB_ENDPOINT_XFER_INT:
-			csr1 |= RX_TYPE(TYPE_INT);
-			csr2 |= RX_BINTERVAL(interval);
-			break;
-		}
-
-		/*Enable QMU Done interrupt */
-		mtu3_setbits(mbase, U3D_QIESR0, QMU_RX_DONE_INT(epnum));
-
-		mtu3_writel(mbase, MU3D_EP_RXCR0(epnum), csr0);
-		mtu3_writel(mbase, MU3D_EP_RXCR1(epnum), csr1);
-		mtu3_writel(mbase, MU3D_EP_RXCR2(epnum), csr2);
-
-		dev_dbg(mtu->dev, "U3D_RX%d CSR0:%#x, CSR1:%#x, CSR2:%#x\n",
-			epnum, mtu3_readl(mbase, MU3D_EP_RXCR0(epnum)),
-			mtu3_readl(mbase, MU3D_EP_RXCR1(epnum)),
-			mtu3_readl(mbase, MU3D_EP_RXCR2(epnum)));
-	}
-
-	dev_dbg(mtu->dev, "csr0:%#x, csr1:%#x, csr2:%#x\n", csr0, csr1, csr2);
-	dev_dbg(mtu->dev, "%s: %s, fifo-addr:%#x, fifo-size:%#x(%#x/%#x)\n",
-		__func__, mep->name, mep->fifo_addr, mep->fifo_size,
-		fifo_sgsz, mep->fifo_seg_size);
-
-	return 0;
-}
-#else
-int mtu3_config_ep(struct mtu3 *mtu, struct mtu3_ep *mep,
-			int interval, int burst, int mult)
-{
-	void __iomem *mbase = mtu->mac_base;
-	int epnum = mep->epnum;
-
-	if (mep->is_in)
-		/* Enable QMU Done interrupt */
-		mtu3_setbits(mbase, U3D_QIESR0, QMU_TX_DONE_INT(epnum));
-	else
-		/*Enable QMU Done interrupt */
-		mtu3_setbits(mbase, U3D_QIESR0, QMU_RX_DONE_INT(epnum));
-	return 0;
-}
-
-#endif
-
-/* for non-ep0 */
-void mtu3_deconfig_ep(struct mtu3 *mtu, struct mtu3_ep *mep)
-{
-	void __iomem *mbase = mtu->mac_base;
-	int epnum = mep->epnum;
-
-	if (mep->is_in) {
-		mtu3_writel(mbase, MU3D_EP_TXCR0(epnum), 0);
-		mtu3_writel(mbase, MU3D_EP_TXCR1(epnum), 0);
-		mtu3_writel(mbase, MU3D_EP_TXCR2(epnum), 0);
-		mtu3_setbits(mbase, U3D_QIECR0, QMU_TX_DONE_INT(epnum));
-	} else {
-		mtu3_writel(mbase, MU3D_EP_RXCR0(epnum), 0);
-		mtu3_writel(mbase, MU3D_EP_RXCR1(epnum), 0);
-		mtu3_writel(mbase, MU3D_EP_RXCR2(epnum), 0);
-		mtu3_setbits(mbase, U3D_QIECR0, QMU_RX_DONE_INT(epnum));
-	}
-
-	mtu3_ep_reset(mep);
-	ep_fifo_free(mep);
-
-	dev_dbg(mtu->dev, "%s: %s\n", __func__, mep->name);
-}
-
-/*
- * Two scenarios:
- * 1. when device IP supports SS, the fifo of EP0, TX EPs, RX EPs
- *	are separated;
- * 2. when supports only HS, the fifo is shared for all EPs, and
- *	the capability registers of @EPNTXFFSZ or @EPNRXFFSZ indicate
- *	the total fifo size of non-ep0, and ep0's is fixed to 64B,
- *	so the total fifo size is 64B + @EPNTXFFSZ;
- *	Due to the first 64B should be reserved for EP0, non-ep0's fifo
- *	starts from offset 64 and are divided into two equal parts for
- *	TX or RX EPs for simplification.
- */
-static void get_ep_fifo_config(struct mtu3 *mtu)
-{
-	struct mtu3_fifo_info *tx_fifo;
-	struct mtu3_fifo_info *rx_fifo;
-	u32 fifosize;
-
-	if (mtu->is_u3_ip) {
-		fifosize = mtu3_readl(mtu->mac_base, U3D_CAP_EPNTXFFSZ);
-		tx_fifo = &mtu->tx_fifo;
-		tx_fifo->base = 0;
-		tx_fifo->limit = fifosize / MTU3_EP_FIFO_UNIT;
-		bitmap_zero(tx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);
-
-		fifosize = mtu3_readl(mtu->mac_base, U3D_CAP_EPNRXFFSZ);
-		rx_fifo = &mtu->rx_fifo;
-		rx_fifo->base = 0;
-		rx_fifo->limit = fifosize / MTU3_EP_FIFO_UNIT;
-		bitmap_zero(rx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);
-		mtu->slot = MTU3_U3_IP_SLOT_DEFAULT;
-	} else {
-		fifosize = mtu3_readl(mtu->mac_base, U3D_CAP_EPNTXFFSZ);
-		tx_fifo = &mtu->tx_fifo;
-		tx_fifo->base = MTU3_U2_IP_EP0_FIFO_SIZE;
-		tx_fifo->limit = (fifosize / MTU3_EP_FIFO_UNIT) >> 1;
-		bitmap_zero(tx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);
-
-		rx_fifo = &mtu->rx_fifo;
-		rx_fifo->base =
-			tx_fifo->base + tx_fifo->limit * MTU3_EP_FIFO_UNIT;
-		rx_fifo->limit = tx_fifo->limit;
-		bitmap_zero(rx_fifo->bitmap, MTU3_FIFO_BIT_SIZE);
-		mtu->slot = MTU3_U2_IP_SLOT_DEFAULT;
-	}
-
-	dev_dbg(mtu->dev, "%s, TX: base-%d, limit-%d; RX: base-%d, limit-%d\n",
-		__func__, tx_fifo->base, tx_fifo->limit,
-		rx_fifo->base, rx_fifo->limit);
-}
-
-void mtu3_ep0_setup(struct mtu3 *mtu)
-{
-	u32 maxpacket = mtu->g.ep0->maxpacket;
-	u32 csr;
-
-	dev_dbg(mtu->dev, "%s maxpacket: %d\n", __func__, maxpacket);
-
-	csr = mtu3_readl(mtu->mac_base, U3D_EP0CSR);
-	csr &= ~EP0_MAXPKTSZ_MSK;
-	csr |= EP0_MAXPKTSZ(maxpacket);
-	csr &= EP0_W1C_BITS;
-	mtu3_writel(mtu->mac_base, U3D_EP0CSR, csr);
-
-	/* Enable EP0 interrupt */
-	mtu3_writel(mtu->mac_base, U3D_EPIESR, EP0ISR | SETUPENDISR);
-}
-
-static int mtu3_mem_alloc(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-	struct mtu3_ep *ep_array;
-	int in_ep_num, out_ep_num;
-	u32 cap_epinfo;
-	int ret;
-	int i;
-
-	cap_epinfo = mtu3_readl(mbase, U3D_CAP_EPINFO);
-	in_ep_num = CAP_TX_EP_NUM(cap_epinfo);
-	out_ep_num = CAP_RX_EP_NUM(cap_epinfo);
-
-	dev_info(mtu->dev, "fifosz/epnum: Tx=%#x/%d, Rx=%#x/%d\n",
-		 mtu3_readl(mbase, U3D_CAP_EPNTXFFSZ), in_ep_num,
-		 mtu3_readl(mbase, U3D_CAP_EPNRXFFSZ), out_ep_num);
-
-	/* one for ep0, another is reserved */
-	mtu->num_eps = min(in_ep_num, out_ep_num) + 1;
-	ep_array = kcalloc(mtu->num_eps * 2, sizeof(*ep_array), GFP_KERNEL);
-	if (ep_array == NULL)
-		return -ENOMEM;
-
-	mtu->ep_array = ep_array;
-	mtu->in_eps = ep_array;
-	mtu->out_eps = &ep_array[mtu->num_eps];
-	/* ep0 uses in_eps[0], out_eps[0] is reserved */
-	mtu->ep0 = mtu->in_eps;
-	mtu->ep0->mtu = mtu;
-	mtu->ep0->epnum = 0;
-
-	for (i = 1; i < mtu->num_eps; i++) {
-		struct mtu3_ep *mep = mtu->in_eps + i;
-
-		mep->fifo = &mtu->tx_fifo;
-		mep = mtu->out_eps + i;
-		mep->fifo = &mtu->rx_fifo;
-	}
-
-	get_ep_fifo_config(mtu);
-
-	ret = mtu3_qmu_init(mtu);
-	if (ret)
-		kfree(mtu->ep_array);
-
-	return ret;
-}
-
-static void mtu3_mem_free(struct mtu3 *mtu)
-{
-	mtu3_qmu_exit(mtu);
-	kfree(mtu->ep_array);
-}
-
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-static irqreturn_t mtu3_link_isr(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-	enum usb_device_speed udev_speed;
-	u32 maxpkt = 64;
-	u32 link;
-	u32 speed;
-
-	link = mtu3_readl(mbase, U3D_DEV_LINK_INTR);
-	link &= mtu3_readl(mbase, U3D_DEV_LINK_INTR_ENABLE);
-	mtu3_writel(mbase, U3D_DEV_LINK_INTR, link); /* W1C */
-	dev_info(mtu->dev, "=== LINK[%x] ===\n", link);
-
-	if (!(link & SSUSB_DEV_SPEED_CHG_INTR))
-		return IRQ_NONE;
-
-	speed = SSUSB_DEV_SPEED(mtu3_readl(mbase, U3D_DEVICE_CONF));
-
-	switch (speed) {
-	case MTU3_SPEED_FULL:
-		udev_speed = USB_SPEED_FULL;
-		/*BESLCK = 4 < BESLCK_U3 = 10 < BESLDCK = 15 */
-		mtu3_writel(mbase, U3D_USB20_LPM_PARAMETER, LPM_BESLDCK(0xf)
-				| LPM_BESLCK(4) | LPM_BESLCK_U3(0xa));
-		mtu3_setbits(mbase, U3D_POWER_MANAGEMENT,
-				LPM_BESL_STALL | LPM_BESLD_STALL);
-		break;
-	case MTU3_SPEED_HIGH:
-		udev_speed = USB_SPEED_HIGH;
-		/*BESLCK = 4 < BESLCK_U3 = 10 < BESLDCK = 15 */
-		mtu3_writel(mbase, U3D_USB20_LPM_PARAMETER, LPM_BESLDCK(0xf)
-				| LPM_BESLCK(4) | LPM_BESLCK_U3(0xa));
-		mtu3_setbits(mbase, U3D_POWER_MANAGEMENT,
-				LPM_BESL_STALL | LPM_BESLD_STALL);
-		break;
-	case MTU3_SPEED_SUPER:
-		udev_speed = USB_SPEED_SUPER;
-		maxpkt = 512;
-		break;
-	case MTU3_SPEED_SUPER_PLUS:
-		udev_speed = USB_SPEED_SUPER_PLUS;
-		maxpkt = 512;
-		break;
-	default:
-		udev_speed = USB_SPEED_UNKNOWN;
-		break;
-	}
-	dev_dbg(mtu->dev, "%s: %s\n", __func__, usb_speed_string(udev_speed));
-	mtu3_dbg_trace(mtu->dev, "link speed %s",
-		       usb_speed_string(udev_speed));
-
-	mtu->g.speed = udev_speed;
-	mtu->g.ep0->maxpacket = maxpkt;
-	mtu->ep0_state = MU3D_EP0_STATE_SETUP;
-
-	if (udev_speed == USB_SPEED_UNKNOWN)
-		mtu3_gadget_disconnect(mtu);
-	else
-		mtu3_ep0_setup(mtu);
-
-	return IRQ_HANDLED;
-}
-
-static irqreturn_t mtu3_u3_ltssm_isr(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-	u32 ltssm;
-
-	ltssm = mtu3_readl(mbase, U3D_LTSSM_INTR);
-	ltssm &= mtu3_readl(mbase, U3D_LTSSM_INTR_ENABLE);
-	mtu3_writel(mbase, U3D_LTSSM_INTR, ltssm); /* W1C */
-	dev_info(mtu->dev, "=== LTSSM[%x] ===\n", ltssm);
-	trace_mtu3_u3_ltssm_isr(ltssm);
-
-	if (ltssm & (HOT_RST_INTR | WARM_RST_INTR))
-		mtu3_gadget_reset(mtu);
-
-	if (ltssm & VBUS_FALL_INTR) {
-		mtu3_ss_func_set(mtu, false);
-		mtu3_gadget_reset(mtu);
-	}
-
-	if (ltssm & VBUS_RISE_INTR)
-		mtu3_ss_func_set(mtu, true);
-
-	if (ltssm & EXIT_U3_INTR)
-		mtu3_gadget_resume(mtu);
-
-	if (ltssm & ENTER_U3_INTR)
-		mtu3_gadget_suspend(mtu);
-
-	return IRQ_HANDLED;
-}
-
-static irqreturn_t mtu3_u2_common_isr(struct mtu3 *mtu)
-{
-	void __iomem *mbase = mtu->mac_base;
-	u32 u2comm;
-
-	u2comm = mtu3_readl(mbase, U3D_COMMON_USB_INTR);
-	u2comm &= mtu3_readl(mbase, U3D_COMMON_USB_INTR_ENABLE);
-	mtu3_writel(mbase, U3D_COMMON_USB_INTR, u2comm); /* W1C */
-	dev_info(mtu->dev, "=== U2COMM[%x] ===\n", u2comm);
-	trace_mtu3_u2_common_isr(u2comm);
-
-	if (u2comm & SUSPEND_INTR)
-		mtu3_gadget_suspend(mtu);
-
-	if (u2comm & RESUME_INTR)
-		mtu3_gadget_resume(mtu);
-
-	if (u2comm & RESET_INTR)
-		mtu3_gadget_reset(mtu);
-
-	if (u2comm & LPM_RESUME_INTR) {
-	    if (!(mtu3_readl(mbase, U3D_POWER_MANAGEMENT) & LPM_HRWE))
-		mtu3_setbits(mbase, U3D_USB20_MISC_CONTROL, LPM_U3_ACK_EN);
-	}
-
-	return IRQ_HANDLED;
-}
-
-static irqreturn_t mtu3_irq(int irq, void *data)
-{
-	struct mtu3 *mtu = (struct mtu3 *)data;
-	unsigned long flags;
-	u32 level1;
-
-	spin_lock_irqsave(&mtu->lock, flags);
-
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-	if (total_isr_debug)
-		total_isr++;
-#endif
-	/* U3D_LV1ISR is RU */
-	level1 = mtu3_readl(mtu->mac_base, U3D_LV1ISR);
-	level1 &= mtu3_readl(mtu->mac_base, U3D_LV1IER);
-//zhengzhou 0318 usb otg */
-	/*if (unlikely(!mtu->softconnect) && (level1 & MAC2_INTR)) {
-		dev_info(mtu->dev, "%s !softconnect MAC2_INTR\n", __func__);
-		u2comm = mtu3_readl(mtu->mac_base, U3D_COMMON_USB_INTR);
-		u2comm &= mtu3_readl(mtu->mac_base, U3D_COMMON_USB_INTR_ENABLE);
-		mtu3_writel(mtu->mac_base, U3D_COMMON_USB_INTR, u2comm);
-		goto done;
-	}
-
-	if (unlikely(!mtu->softconnect) && (level1 & BMU_INTR)) {
-		dev_info(mtu->dev, "%s !softconnect BMU_INTR\n", __func__);
-		int_status = mtu3_readl(mtu->mac_base, U3D_EPISR);
-		int_status &= mtu3_readl(mtu->mac_base, U3D_EPIER);
-		mtu3_writel(mtu->mac_base, U3D_EPISR, int_status);
-		goto done;
-	}
-	*/
-//zhengzhou 0318 usb otg */
-	if (level1 & EP_CTRL_INTR)
-		mtu3_link_isr(mtu);
-
-	if (level1 & MAC2_INTR)
-		mtu3_u2_common_isr(mtu);
-
-	if (level1 & MAC3_INTR)
-		mtu3_u3_ltssm_isr(mtu);
-
-	if (level1 & BMU_INTR)
-		mtu3_ep0_isr(mtu);
-
-	if (level1 & QMU_INTR) {
-#ifndef CONFIG_MTU3_MD_USB_EP0_CTRL
-		if (total_isr_debug)
-			total_isr--;
-#endif
-		mtu3_qmu_isr(mtu);
-	}
-
-//done://zhengzhou 0318 usb otg */
-	spin_unlock_irqrestore(&mtu->lock, flags);
-
-	return IRQ_HANDLED;
-}
-#else
-static irqreturn_t mtu3_irq(int irq, void *data)
-{
-	struct mtu3 *mtu = (struct mtu3 *)data;
-	unsigned long flags;
-	u32 level1;
-
-	spin_lock_irqsave(&mtu->lock, flags);
-
-	/* U3D_LV1ISR is RU */
-	level1 = mtu3_readl(mtu->mac_base, U3D_LV1ISR);
-	level1 &= mtu3_readl(mtu->mac_base, U3D_LV1IER);
-
-	if (level1 & QMU_INTR)
-		mtu3_qmu_isr(mtu);
-
-	spin_unlock_irqrestore(&mtu->lock, flags);
-
-	return IRQ_HANDLED;
-}
-
-#endif
-
-static int mtu3_hw_init(struct mtu3 *mtu)
-{
-	u32 value;
-	int ret;
-
-	value = mtu3_readl(mtu->ippc_base, U3D_SSUSB_IP_TRUNK_VERS);
-	mtu->hw_version = IP_TRUNK_VERS(value);
-	#if 0
-	mtu->gen2cp = !!(mtu->hw_version >= MTU3_TRUNK_VERS_1003);
-	#else
-	mtu->gen2cp = 0;
-	#endif
-
-	value = mtu3_readl(mtu->ippc_base, U3D_SSUSB_IP_DEV_CAP);
-	mtu->is_u3_ip = !!SSUSB_IP_DEV_U3_PORT_NUM(value);
-
-	dev_info(mtu->dev, "IP version 0x%x(%s IP)\n", mtu->hw_version,
-		mtu->is_u3_ip ? "U3" : "U2");
-
-	mtu3_device_reset(mtu);
-
-	ret = mtu3_device_enable(mtu);
-	if (ret) {
-		dev_err(mtu->dev, "device enable failed %d\n", ret);
-		return ret;
-	}
-
-	ret = mtu3_mem_alloc(mtu);
-	if (ret)
-		return -ENOMEM;
-
-	mtu3_regs_init(mtu);
-
-	return 0;
-}
-
-static void mtu3_hw_exit(struct mtu3 *mtu)
-{
-	mtu3_device_disable(mtu);
-	mtu3_mem_free(mtu);
-}
-
-/**
- * we set 32-bit DMA mask by default, here check whether the controller
- * supports 36-bit DMA or not, if it does, set 36-bit DMA mask.
- */
-static int mtu3_set_dma_mask(struct mtu3 *mtu)
-{
-	struct device *dev = mtu->dev;
-	bool is_36bit = false;
-	int ret = 0;
-	u32 value;
-
-	value = mtu3_readl(mtu->mac_base, U3D_MISC_CTRL);
-	if (value & DMA_ADDR_36BIT) {
-		is_36bit = true;
-		ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(36));
-		/* If set 36-bit DMA mask fails, fall back to 32-bit DMA mask */
-		if (ret) {
-			is_36bit = false;
-			ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
-		}
-	}
-	dev_info(dev, "dma mask: %s bits\n", is_36bit ? "36" : "32");
-
-	return ret;
-}
-
-int ssusb_gadget_init(struct ssusb_mtk *ssusb)
-{
-	struct device *dev = ssusb->dev;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mtu3 *mtu = NULL;
-	struct resource *res;
-	int ret = -ENOMEM;
-
-	mtu = devm_kzalloc(dev, sizeof(struct mtu3), GFP_KERNEL);
-	if (mtu == NULL)
-		return -ENOMEM;
-
-	mtu->irq = platform_get_irq(pdev, 0);
-	if (mtu->irq < 0) {
-		dev_err(dev, "fail to get irq number\n");
-		return mtu->irq;
-	}
-	dev_info(dev, "irq %d\n", mtu->irq);
-
-	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mac");
-	mtu->mac_base = devm_ioremap_resource(dev, res);
-	if (IS_ERR(mtu->mac_base)) {
-		dev_err(dev, "error mapping memory for dev mac\n");
-		return PTR_ERR(mtu->mac_base);
-	}
-
-	spin_lock_init(&mtu->lock);
-	mtu->dev = dev;
-	mtu->ippc_base = ssusb->ippc_base;
-	ssusb->mac_base	= mtu->mac_base;
-	ssusb->u3d = mtu;
-	mtu->ssusb = ssusb;
-	mtu->max_speed = usb_get_maximum_speed(dev);
-
-	#ifdef CONFIG_MTU3_MD_USB_EP0_CTRL
-	INIT_DELAYED_WORK(&mtu->forward_to_driver_work, mtu3_forward_to_driver_work);
-	mtu->md_sync_data = devm_kzalloc(dev, sizeof(struct mtu3_md_sync_data), GFP_KERNEL);
-	#endif
-	/* check the max_speed parameter */
-	switch (mtu->max_speed) {
-	case USB_SPEED_FULL:
-	case USB_SPEED_HIGH:
-	case USB_SPEED_SUPER:
-	case USB_SPEED_SUPER_PLUS:
-		break;
-	default:
-		dev_err(dev, "invalid max_speed: %s\n",
-			usb_speed_string(mtu->max_speed));
-		/* fall through */
-	case USB_SPEED_UNKNOWN:
-		/* default as SSP */
-		mtu->max_speed = USB_SPEED_SUPER_PLUS;
-		break;
-	}
-
-	dev_dbg(dev, "mac_base=0x%p, ippc_base=0x%p\n",
-		mtu->mac_base, mtu->ippc_base);
-
-	ret = mtu3_hw_init(mtu);
-	if (ret) {
-		dev_err(dev, "mtu3 hw init failed:%d\n", ret);
-		return ret;
-	}
-
-	ret = mtu3_set_dma_mask(mtu);
-	if (ret) {
-		dev_err(dev, "mtu3 set dma_mask failed:%d\n", ret);
-		goto dma_mask_err;
-	}
-
-	ret = devm_request_irq(dev, mtu->irq, mtu3_irq, 0, dev_name(dev), mtu);
-	if (ret) {
-		dev_err(dev, "request irq %d failed!\n", mtu->irq);
-		goto irq_err;
-	}
-
-	device_init_wakeup(dev, true);
-
-	ret = mtu3_gadget_setup(mtu);
-	if (ret) {
-		dev_err(dev, "mtu3 gadget init failed:%d\n", ret);
-		goto gadget_err;
-	}
-	mtu3_usb_vbus_detect_init(mtu);
-	/* init as host mode, power down device IP for power saving */
-	if (mtu->ssusb->dr_mode == USB_DR_MODE_OTG)
-		mtu3_stop(mtu);
-
-	ssusb_dev_debugfs_init(ssusb);
-
-	dev_dbg(dev, " %s() done...\n", __func__);
-
-	return 0;
-
-gadget_err:
-	device_init_wakeup(dev, false);
-
-dma_mask_err:
-irq_err:
-	mtu3_hw_exit(mtu);
-	ssusb->u3d = NULL;
-	dev_err(dev, " %s() fail...\n", __func__);
-
-	return ret;
-}
-
-void ssusb_gadget_exit(struct ssusb_mtk *ssusb)
-{
-	struct mtu3 *mtu = ssusb->u3d;
-
-	mtu3_gadget_cleanup(mtu);
-	device_init_wakeup(ssusb->dev, false);
-	mtu3_hw_exit(mtu);
-}
diff --git a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_dr_1.c b/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_dr_1.c
deleted file mode 100755
index 3a3ef38..0000000
--- a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_dr_1.c
+++ /dev/null
@@ -1,612 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * mtu3_dr.c - dual role switch and host glue layer
- *
- * Copyright (C) 2016 MediaTek Inc.
- *
- * Author: Chunfeng Yun <chunfeng.yun@mediatek.com>
- */
-
-#include <linux/usb/role.h>
-#include <linux/of_platform.h>
-
-#include "mtu3.h"
-#include "mtu3_dr.h"
-#include "mtu3_debug.h"
-
-#define USB2_PORT 2
-#define USB3_PORT 3
-
-enum mtu3_vbus_id_state {
-	MTU3_ID_FLOAT = 1,
-	MTU3_ID_GROUND,
-	MTU3_VBUS_OFF,
-	MTU3_VBUS_VALID,
-};
-
-static char *mailbox_state_string(enum mtu3_vbus_id_state state)
-{
-	switch (state) {
-	case MTU3_ID_FLOAT:
-		return "ID_FLOAT";
-	case MTU3_ID_GROUND:
-		return "ID_GROUND";
-	case MTU3_VBUS_OFF:
-		return "VBUS_OFF";
-	case MTU3_VBUS_VALID:
-		return "VBUS_VALID";
-	default:
-		return "UNKNOWN";
-	}
-}
-
-static void toggle_opstate(struct ssusb_mtk *ssusb)
-{
-	dev_info(ssusb->dev, "%s\n", __func__);
-	//if (!ssusb->otg_switch.is_u3_drd) {//zhengzhou 0318 usb otg */
-	if (!ssusb->otg_switch.is_u3_drd) {
-		mtu3_setbits(ssusb->mac_base, U3D_DEVICE_CONTROL, DC_SESSION);
-		mtu3_setbits(ssusb->mac_base, U3D_POWER_MANAGEMENT, SOFT_CONN);
-	}
-	//}
-}
-
-/* only port0 supports dual-role mode */
-static int ssusb_port0_switch(struct ssusb_mtk *ssusb,
-	int version, bool tohost)
-{
-	void __iomem *ibase = ssusb->ippc_base;
-	u32 value;
-
-	dev_dbg(ssusb->dev, "%s (switch u%d port0 to %s)\n", __func__,
-		version, tohost ? "host" : "device");
-
-	if (version == USB2_PORT) {
-		/* 1. power off and disable u2 port0 */
-		value = mtu3_readl(ibase, SSUSB_U2_CTRL(0));
-		value |= SSUSB_U2_PORT_PDN | SSUSB_U2_PORT_DIS;
-		mtu3_writel(ibase, SSUSB_U2_CTRL(0), value);
-
-		/* 2. power on, enable u2 port0 and select its mode */
-		value = mtu3_readl(ibase, SSUSB_U2_CTRL(0));
-		value &= ~(SSUSB_U2_PORT_PDN | SSUSB_U2_PORT_DIS);
-		value = tohost ? (value | SSUSB_U2_PORT_HOST_SEL) :
-			(value & (~SSUSB_U2_PORT_HOST_SEL));
-		mtu3_writel(ibase, SSUSB_U2_CTRL(0), value);
-	} else {
-		/* 1. power off and disable u3 port0 */
-		value = mtu3_readl(ibase, SSUSB_U3_CTRL(0));
-		value |= SSUSB_U3_PORT_PDN | SSUSB_U3_PORT_DIS;
-		mtu3_writel(ibase, SSUSB_U3_CTRL(0), value);
-
-		/* 2. power on, enable u3 port0 and select its mode */
-		value = mtu3_readl(ibase, SSUSB_U3_CTRL(0));
-		value &= ~(SSUSB_U3_PORT_PDN | SSUSB_U3_PORT_DIS);
-		value = tohost ? (value | SSUSB_U3_PORT_HOST_SEL) :
-			(value & (~SSUSB_U3_PORT_HOST_SEL));
-		mtu3_writel(ibase, SSUSB_U3_CTRL(0), value);
-	}
-
-	return 0;
-}
-
-static void ssusb_ip_sleep(struct ssusb_mtk *ssusb)
-{
-	void __iomem *ibase = ssusb->ippc_base;
-
-	/* Set below sequence to avoid power leakage */
-	mtu3_setbits(ibase, SSUSB_U3_CTRL(0),
-		(SSUSB_U3_PORT_DIS | SSUSB_U3_PORT_PDN));
-	mtu3_setbits(ibase, SSUSB_U2_CTRL(0),
-		SSUSB_U2_PORT_DIS | SSUSB_U2_PORT_PDN);
-	mtu3_clrbits(ibase, SSUSB_U2_CTRL(0), SSUSB_U2_PORT_OTG_SEL);
-	mtu3_setbits(ibase, U3D_SSUSB_IP_PW_CTRL1, SSUSB_IP_HOST_PDN);
-	mtu3_setbits(ibase, U3D_SSUSB_IP_PW_CTRL2, SSUSB_IP_DEV_PDN);
-	udelay(50);
-	mtu3_setbits(ibase, U3D_SSUSB_IP_PW_CTRL0, SSUSB_IP_SW_RST);
-}
-
-static void switch_port_to_on(struct ssusb_mtk *ssusb, bool on)
-{
-	dev_dbg(ssusb->dev, "%s\n", __func__);
-
-	if (on) {
-		//ssusb_clks_enable(ssusb);//zhengzhou 0318 usb otg */
-		ssusb_phy_power_on(ssusb);
-		ssusb_ip_sw_reset(ssusb);
-	} else {
-		ssusb_ip_sleep(ssusb);
-		ssusb_phy_power_off(ssusb);
-		//ssusb_clks_disable(ssusb);//zhengzhou 0318 usb otg */
-	}
-}
-
-static void switch_port_to_host(struct ssusb_mtk *ssusb)
-{
-	u32 check_clk = 0;
-
-	dev_dbg(ssusb->dev, "%s\n", __func__);
-
-	ssusb_port0_switch(ssusb, USB2_PORT, true);
-
-	if (ssusb->otg_switch.is_u3_drd) {
-		ssusb_port0_switch(ssusb, USB3_PORT, true);
-		check_clk = SSUSB_U3_MAC_RST_B_STS;
-	}
-
-	ssusb_check_clocks(ssusb, check_clk);
-
-	/* after all clocks are stable */
-	toggle_opstate(ssusb);
-}
-
-static void switch_port_to_device(struct ssusb_mtk *ssusb)
-{
-	u32 check_clk = 0;
-
-	dev_info(ssusb->dev, "%s\n", __func__);
-
-	ssusb_port0_switch(ssusb, USB2_PORT, false);
-
-	if (ssusb->otg_switch.is_u3_drd) {
-		ssusb_port0_switch(ssusb, USB3_PORT, false);
-		check_clk = SSUSB_U3_MAC_RST_B_STS;
-	}
-
-	ssusb_check_clocks(ssusb, check_clk);
-}
-
-int ssusb_set_vbus(struct otg_switch_mtk *otg_sx, int is_on)
-{
-	struct ssusb_mtk *ssusb =
-		container_of(otg_sx, struct ssusb_mtk, otg_switch);
-	struct regulator *vbus = otg_sx->vbus;
-	int ret;
-
-	/* vbus is optional */
-	if (!vbus)
-		return 0;
-
-	dev_dbg(ssusb->dev, "%s: turn %s\n", __func__, is_on ? "on" : "off");
-
-	if (is_on) {
-		ret = regulator_enable(vbus);
-		if (ret) {
-			dev_err(ssusb->dev, "vbus regulator enable failed\n");
-			return ret;
-		}
-	} else {
-		regulator_disable(vbus);
-	}
-
-	return 0;
-}
-
-static void ssusb_gadget_disconnect(struct mtu3 *mtu)
-{
-	/* notify gadget driver */
-	if (mtu->g.speed == USB_SPEED_UNKNOWN)
-		return;
-
-	if (mtu->gadget_driver && mtu->gadget_driver->disconnect) {
-		mtu->gadget_driver->disconnect(&mtu->g);
-		mtu->g.speed = USB_SPEED_UNKNOWN;
-	}
-
-	usb_gadget_set_state(&mtu->g, USB_STATE_NOTATTACHED);
-}
-
-/*
- * switch to host: -> MTU3_VBUS_OFF --> MTU3_ID_GROUND
- * switch to device: -> MTU3_ID_FLOAT --> MTU3_VBUS_VALID
- */
-static void ssusb_set_mailbox(struct otg_switch_mtk *otg_sx,
-	enum mtu3_vbus_id_state status)
-{
-	struct ssusb_mtk *ssusb =
-		container_of(otg_sx, struct ssusb_mtk, otg_switch);
-	struct mtu3 *mtu = ssusb->u3d;
-	unsigned long flags;
-
-	dev_info(ssusb->dev, "mailbox %s\n", mailbox_state_string(status));
-	mtu3_dbg_trace(ssusb->dev, "mailbox %s", mailbox_state_string(status));
-
-	switch (status) {
-	case MTU3_ID_GROUND:
-		switch_port_to_host(ssusb);
-		ssusb_set_vbus(otg_sx, 1);
-		ssusb->is_host = true;
-		otg_sx->sw_state |= MTU3_SW_ID_GROUND;
-		break;
-	case MTU3_ID_FLOAT:
-		ssusb->is_host = false;
-		ssusb_set_vbus(otg_sx, 0);
-		switch_port_to_device(ssusb);
-		otg_sx->sw_state &= ~MTU3_SW_ID_GROUND;
-		break;
-	case MTU3_VBUS_OFF:
-		/* killing any outstanding requests */
-		spin_lock_irqsave(&mtu->lock, flags);
-		mtu3_nuke_all_ep(mtu);
-		spin_unlock_irqrestore(&mtu->lock, flags);
-		mtu3_stop(mtu);
-		pm_relax(ssusb->dev);
-		//ssusb_set_force_vbus(ssusb, false);//zhengzhou 0318 usb otg */
-		ssusb_gadget_disconnect(mtu);
-		otg_sx->sw_state &= ~MTU3_SW_VBUS_VALID;
-		break;
-	case MTU3_VBUS_VALID:
-		//ssusb_set_force_vbus(ssusb, true);//zhengzhou 0318 usb otg */
-		/* avoid suspend when works as device */
-		pm_stay_awake(ssusb->dev);
-		mtu3_start(mtu);
-		otg_sx->sw_state |= MTU3_SW_VBUS_VALID;
-		break;
-	default:
-		dev_err(ssusb->dev, "invalid state\n");
-	}
-}
-
-static void ssusb_id_work(struct work_struct *work)
-{
-	struct otg_switch_mtk *otg_sx =
-		container_of(work, struct otg_switch_mtk, id_work);
-		//zhengzhou 0318 usb otg start*/
-	struct ssusb_mtk *ssusb =
-			container_of(otg_sx, struct ssusb_mtk, otg_switch);
-
-	if (otg_sx->id_event){
-		mdelay(500);
-		pm_stay_awake(ssusb->dev);
-		switch_port_to_on(ssusb, true);
-		ssusb_host_enable(ssusb);
-		/* register host driver */
-		of_platform_populate(ssusb->dev->of_node,
-						NULL, NULL, ssusb->dev);
-		ssusb_set_force_mode(ssusb, MTU3_DR_FORCE_HOST);
-		ssusb_set_mailbox(otg_sx, MTU3_ID_GROUND);
-		}
-	else {
-		/* FIXME: debounce time for xhci finish disconnection */
-		//mdelay(200);
-		ssusb_set_force_mode(ssusb, MTU3_DR_FORCE_DEVICE);
-		of_platform_depopulate(ssusb->dev);
-		ssusb_set_mailbox(otg_sx, MTU3_ID_FLOAT);
-		switch_port_to_on(ssusb, false);
-		pm_relax(ssusb->dev);
-		}
-		//zhengzhou 0318 usb otg end*/
-}
-
-static void ssusb_vbus_work(struct work_struct *work)
-{
-	struct otg_switch_mtk *otg_sx =
-		container_of(work, struct otg_switch_mtk, vbus_work);
-			//zhengzhou 0318 usb otg start*/
-	struct ssusb_mtk *ssusb =
-			container_of(otg_sx, struct ssusb_mtk, otg_switch);
-
-	if (otg_sx->vbus_event) {
-		msleep(500);
-		switch_port_to_on(ssusb, true);
-		switch_port_to_device(ssusb);
-		ssusb_set_mailbox(otg_sx, MTU3_VBUS_VALID);
-		}
-	else {
-		ssusb_set_mailbox(otg_sx, MTU3_VBUS_OFF);
-		switch_port_to_on(ssusb, false);
-		}
-			//zhengzhou 0318 usb otg end*/
-}
-
-/*
- * @ssusb_id_notifier is called in atomic context, but @ssusb_set_mailbox
- * may sleep, so use work queue here
- */
-static int ssusb_id_notifier(struct notifier_block *nb,
-	unsigned long event, void *ptr)
-{
-	struct otg_switch_mtk *otg_sx =
-		container_of(nb, struct otg_switch_mtk, id_nb);
-
-	otg_sx->id_event = event;
-	schedule_work(&otg_sx->id_work);
-
-	return NOTIFY_DONE;
-}
-
-static int ssusb_vbus_notifier(struct notifier_block *nb,
-	unsigned long event, void *ptr)
-{
-	struct otg_switch_mtk *otg_sx =
-		container_of(nb, struct otg_switch_mtk, vbus_nb);
-
-	otg_sx->vbus_event = event;
-	schedule_work(&otg_sx->vbus_work);
-
-	return NOTIFY_DONE;
-}
-
-static int ssusb_extcon_register(struct otg_switch_mtk *otg_sx)
-{
-	struct ssusb_mtk *ssusb =
-		container_of(otg_sx, struct ssusb_mtk, otg_switch);
-	struct extcon_dev *edev = otg_sx->edev;
-	int ret;
-
-	/* extcon is optional */
-	if (!edev)
-		return 0;
-
-	otg_sx->vbus_nb.notifier_call = ssusb_vbus_notifier;
-	ret = devm_extcon_register_notifier(ssusb->dev, edev, EXTCON_USB,
-					&otg_sx->vbus_nb);
-	if (ret < 0) {
-		dev_err(ssusb->dev, "failed to register notifier for USB\n");
-		return ret;
-	}
-
-	otg_sx->id_nb.notifier_call = ssusb_id_notifier;
-	ret = devm_extcon_register_notifier(ssusb->dev, edev, EXTCON_USB_HOST,
-					&otg_sx->id_nb);
-	if (ret < 0) {
-		dev_err(ssusb->dev, "failed to register notifier for USB-HOST\n");
-		return ret;
-	}
-
-	dev_dbg(ssusb->dev, "EXTCON_USB: %d, EXTCON_USB_HOST: %d\n",
-		extcon_get_state(edev, EXTCON_USB),
-		extcon_get_state(edev, EXTCON_USB_HOST));
-
-	/* default as host, switch to device mode if needed */
-	if (extcon_get_state(edev, EXTCON_USB_HOST) == false) {
-		of_platform_depopulate(ssusb->dev);	//zhengzhou 0318 usb otg */
-		ssusb_set_mailbox(otg_sx, MTU3_ID_FLOAT);
-		}
-	if (extcon_get_state(edev, EXTCON_USB) == true)
-		ssusb_set_mailbox(otg_sx, MTU3_VBUS_VALID);
-
-	return 0;
-}
-
-/*
- * We provide an interface via debugfs to switch between host and device modes
- * depending on user input.
- * This is useful in special cases, such as uses TYPE-A receptacle but also
- * wants to support dual-role mode.
- */
-void ssusb_mode_switch(struct ssusb_mtk *ssusb, int to_host)
-{
-	struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
-
-	if (to_host) {
-		ssusb_set_force_mode(ssusb, MTU3_DR_FORCE_HOST);
-		ssusb_set_mailbox(otg_sx, MTU3_VBUS_OFF);
-		ssusb_set_mailbox(otg_sx, MTU3_ID_GROUND);
-	} else {
-		ssusb_set_force_mode(ssusb, MTU3_DR_FORCE_DEVICE);
-		ssusb_set_mailbox(otg_sx, MTU3_ID_FLOAT);
-		ssusb_set_mailbox(otg_sx, MTU3_VBUS_VALID);
-	}
-}
-
-void ssusb_set_force_mode(struct ssusb_mtk *ssusb,
-			  enum mtu3_dr_force_mode mode)
-{
-	u32 value;
-
-	value = mtu3_readl(ssusb->ippc_base, SSUSB_U2_CTRL(0));
-	switch (mode) {
-	case MTU3_DR_FORCE_DEVICE:
-		value |= SSUSB_U2_PORT_FORCE_IDDIG | SSUSB_U2_PORT_RG_IDDIG;
-		break;
-	case MTU3_DR_FORCE_HOST:
-		value |= SSUSB_U2_PORT_FORCE_IDDIG;
-		value &= ~SSUSB_U2_PORT_RG_IDDIG;
-		break;
-	case MTU3_DR_FORCE_NONE:
-		value &= ~(SSUSB_U2_PORT_FORCE_IDDIG | SSUSB_U2_PORT_RG_IDDIG);
-		break;
-	default:
-		return;
-	}
-	mtu3_writel(ssusb->ippc_base, SSUSB_U2_CTRL(0), value);
-}
-
-static int ssusb_role_sw_set(struct device *dev, enum usb_role role)
-{
-	struct ssusb_mtk *ssusb = dev_get_drvdata(dev);
-	struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
-	bool id_event, vbus_event;
-
-	dev_info(dev, "role_sw_set role %d\n", role);
-
-	otg_sx->latest_role = role;
-
-	if (otg_sx->op_mode != MTU3_DR_OPERATION_NORMAL) {
-		dev_info(dev, "op_mode %d, skip set role\n", otg_sx->op_mode);
-		return 0;
-	}
-
-	id_event = (role == USB_ROLE_HOST);
-	vbus_event = (role == USB_ROLE_DEVICE);
-
-	if (!!(otg_sx->sw_state & MTU3_SW_VBUS_VALID) ^ vbus_event) {
-		if (vbus_event) {
-			if (ssusb->clk_mgr) {
-				switch_port_to_on(ssusb, true);
-				switch_port_to_device(ssusb);
-			}
-			ssusb_set_mailbox(otg_sx, MTU3_VBUS_VALID);
-		} else {
-			ssusb_set_mailbox(otg_sx, MTU3_VBUS_OFF);
-			if (ssusb->clk_mgr)
-				switch_port_to_on(ssusb, false);
-		}
-	}
-
-	if (!!(otg_sx->sw_state & MTU3_SW_ID_GROUND) ^ id_event) {
-		if (id_event) {
-			if (ssusb->clk_mgr) {
-				pm_stay_awake(ssusb->dev);
-				switch_port_to_on(ssusb, true);
-				ssusb_host_enable(ssusb);
-				/* register host driver */
-				of_platform_populate(dev->of_node,
-						NULL, NULL, dev);
-			}
-			ssusb_set_force_mode(ssusb, MTU3_DR_FORCE_HOST);
-			ssusb_set_mailbox(otg_sx, MTU3_ID_GROUND);
-		} else {
-			/* FIXME: debounce time for xhci finish disconnection */
-			mdelay(200);
-			ssusb_set_force_mode(ssusb, MTU3_DR_FORCE_DEVICE);
-			if (ssusb->clk_mgr) {
-				/* unregister host driver */
-				of_platform_depopulate(dev);
-				ssusb_set_mailbox(otg_sx, MTU3_ID_FLOAT);
-				switch_port_to_on(ssusb, false);
-				pm_relax(ssusb->dev);
-			} else
-				ssusb_set_mailbox(otg_sx, MTU3_ID_FLOAT);
-		}
-	}
-
-	return 0;
-}
-
-static enum usb_role ssusb_role_sw_get(struct device *dev)
-{
-	struct ssusb_mtk *ssusb = dev_get_drvdata(dev);
-	enum usb_role role;
-
-	role = ssusb->is_host ? USB_ROLE_HOST : USB_ROLE_DEVICE;
-
-	return role;
-}
-
-static int ssusb_role_sw_register(struct otg_switch_mtk *otg_sx)
-{
-	struct usb_role_switch_desc role_sx_desc = { 0 };
-	struct ssusb_mtk *ssusb =
-		container_of(otg_sx, struct ssusb_mtk, otg_switch);
-
-	if (!otg_sx->role_sw_used)
-		return 0;
-
-	role_sx_desc.set = ssusb_role_sw_set;
-	role_sx_desc.get = ssusb_role_sw_get;
-	otg_sx->role_sw = usb_role_switch_register(ssusb->dev, &role_sx_desc);
-
-	if (IS_ERR(otg_sx->role_sw))
-		return PTR_ERR(otg_sx->role_sw);
-
-	/* default to role none */
-	ssusb_role_sw_set(ssusb->dev, USB_ROLE_NONE);
-
-	return 0;
-}
-
-
-static ssize_t cmode_store(struct device *dev,
-				 struct device_attribute *attr,
-				 const char *buf, size_t count)
-{
-	struct ssusb_mtk *ssusb = dev_get_drvdata(dev);
-	struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
-	enum usb_role role = otg_sx->latest_role;
-	int mode;
-
-	if (kstrtoint(buf, 10, &mode))
-		return -EINVAL;
-
-	dev_info(dev, "store cmode %d op_mode %d\n", mode, otg_sx->op_mode);
-
-	if (otg_sx->op_mode != mode) {
-		/* set switch role */
-		switch (mode) {
-		case MTU3_DR_OPERATION_NONE:
-			otg_sx->latest_role = USB_ROLE_NONE;
-			break;
-		case MTU3_DR_OPERATION_NORMAL:
-			/* switch usb role to latest role */
-			break;
-		case MTU3_DR_OPERATION_HOST:
-			otg_sx->latest_role = USB_ROLE_HOST;
-			break;
-		case MTU3_DR_OPERATION_DEVICE:
-			otg_sx->latest_role = USB_ROLE_DEVICE;
-			break;
-		default:
-			return -EINVAL;
-		}
-		/* switch operation mode to normal temporarily */
-		otg_sx->op_mode = MTU3_DR_OPERATION_NORMAL;
-		/* switch usb role */
-		ssusb_role_sw_set(ssusb->dev, otg_sx->latest_role);
-		/* update operation mode */
-		otg_sx->op_mode = mode;
-		/* restore role */
-		otg_sx->latest_role = role;
-	}
-
-	return count;
-}
-
-static ssize_t cmode_show(struct device *dev,
-				struct device_attribute *attr,
-				char *buf)
-{
-	struct ssusb_mtk *ssusb = dev_get_drvdata(dev);
-	struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
-
-	return sprintf(buf, "%d\n", otg_sx->op_mode);
-}
-static DEVICE_ATTR_RW(cmode);
-
-static struct attribute *ssusb_dr_attrs[] = {
-	&dev_attr_cmode.attr,
-	NULL
-};
-
-static const struct attribute_group ssusb_dr_group = {
-	.attrs = ssusb_dr_attrs,
-};
-
-int ssusb_otg_switch_init(struct ssusb_mtk *ssusb)
-{
-	struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
-	int ret = 0;
-
-	INIT_WORK(&otg_sx->id_work, ssusb_id_work);
-	INIT_WORK(&otg_sx->vbus_work, ssusb_vbus_work);
-
-	/* default as host, update state */
-	otg_sx->sw_state = ssusb->is_host ?
-				MTU3_SW_ID_GROUND : MTU3_SW_VBUS_VALID;
-	/* initial operation mode */
-	otg_sx->op_mode = MTU3_DR_OPERATION_NORMAL;
-
-	ret = sysfs_create_group(&ssusb->dev->kobj, &ssusb_dr_group);
-	if (ret)
-		dev_info(ssusb->dev, "error creating sysfs attributes\n");
-
-	if (otg_sx->manual_drd_enabled)
-		ssusb_dr_debugfs_init(ssusb);
-	else if (otg_sx->role_sw_used)
-		ret = ssusb_role_sw_register(otg_sx);
-	else
-		ret = ssusb_extcon_register(otg_sx);
-
-	return ret;
-}
-
-void ssusb_otg_switch_exit(struct ssusb_mtk *ssusb)
-{
-	struct otg_switch_mtk *otg_sx = &ssusb->otg_switch;
-
-	cancel_work_sync(&otg_sx->id_work);
-	cancel_work_sync(&otg_sx->vbus_work);
-	usb_role_switch_unregister(otg_sx->role_sw);
-	sysfs_remove_group(&ssusb->dev->kobj, &ssusb_dr_group);
-}
diff --git a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_plat.c b/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_plat.c
index 3005550..7c5bd7a 100644
--- a/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_plat.c
+++ b/src/kernel/linux/v4.19/drivers/usb/mtu3/mtu3_plat.c
@@ -165,19 +165,24 @@
 int ssusb_phy_power_on(struct ssusb_mtk *ssusb)
 {
 	int i;
-	int ret;
+	int ret = 0;
 
+	mutex_lock(&ssusb->mutex);
+	if (ssusb->power_status)
+		goto power_on_phy;
 	for (i = 0; i < ssusb->num_phys; i++) {
 		ret = phy_power_on(ssusb->phys[i]);
 		if (ret)
 			goto power_off_phy;
 	}
-	return 0;
+	ssusb->power_status = true;
+	goto power_on_phy;
 
 power_off_phy:
 	for (; i > 0; i--)
 		phy_power_off(ssusb->phys[i - 1]);
-
+power_on_phy:
+	mutex_unlock(&ssusb->mutex);
 	return ret;
 }
 
@@ -185,8 +190,15 @@
 {
 	unsigned int i;
 
+	mutex_lock(&ssusb->mutex);
+	if (!ssusb->power_status)
+		goto power_off_phy;
+
 	for (i = 0; i < ssusb->num_phys; i++)
 		phy_power_off(ssusb->phys[i]);
+	ssusb->power_status = false;
+power_off_phy:
+	mutex_unlock(&ssusb->mutex);
 }
 
 int ssusb_clks_enable(struct ssusb_mtk *ssusb)
@@ -708,6 +720,11 @@
 	pm_runtime_get_sync(dev);
 	device_enable_async_suspend(dev);
 
+	mutex_init(&ssusb->mutex);
+	mutex_lock(&ssusb->mutex);
+	ssusb->power_status = false;
+	mutex_unlock(&ssusb->mutex);
+
 	ret = ssusb_rscs_init(ssusb);
 	if (ret)
 		goto comm_init_err;
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/common/mtk-afe-platform-driver.c b/src/kernel/linux/v4.19/sound/soc/mediatek/common/mtk-afe-platform-driver.c
index e1b5275..fe4f944 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/common/mtk-afe-platform-driver.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/common/mtk-afe-platform-driver.c
@@ -96,16 +96,26 @@
 /*
 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
 	struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME);
-	struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
-	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
-	const struct mtk_base_memif_data *memif_data = memif->data;
-	struct regmap *regmap = afe->regmap;
-	struct device *dev = afe->dev;
-	int reg_ofs_base = memif_data->reg_ofs_base;
-	int reg_ofs_cur = memif_data->reg_ofs_cur;
+	struct mtk_base_afe *afe;
+	struct mtk_base_afe_memif *memif;
+	const struct mtk_base_memif_data *memif_data;
+	struct regmap *regmap;
+	struct device *dev;
+	int reg_ofs_base;
+	int reg_ofs_cur;
 	unsigned int hw_ptr = 0, hw_base = 0;
 	int ret, pcm_ptr_bytes;
 
+	if (component == NULL)
+		return -EINVAL;
+	afe = snd_soc_component_get_drvdata(component);
+	memif = &afe->memif[rtd->cpu_dai->id];
+	memif_data = memif->data;
+	regmap = afe->regmap;
+	dev = afe->dev;
+	reg_ofs_base = memif_data->reg_ofs_base;
+	reg_ofs_cur = memif_data->reg_ofs_cur;
+
 	ret = regmap_read(regmap, reg_ofs_cur, &hw_ptr);
 	if (ret || hw_ptr == 0) {
 		dev_err(dev, "%s hw_ptr err\n", __func__);
@@ -136,9 +146,13 @@
 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
 	struct snd_soc_component *component =
 		snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME);
-	struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
-	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
+	struct mtk_base_afe *afe;
+	struct mtk_base_afe_memif *memif;
 
+	if (component == NULL)
+		return -EINVAL;
+	afe = snd_soc_component_get_drvdata(component);
+	memif = &afe->memif[rtd->cpu_dai->id];
 	if (!memif->ack_enable)
 		return 0;
 
@@ -163,8 +177,11 @@
 	size_t size;
 	struct snd_pcm *pcm = rtd->pcm;
 	struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME);
-	struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
+	struct mtk_base_afe *afe;
 
+	if (component == NULL)
+		return -EINVAL;
+	afe = snd_soc_component_get_drvdata(component);
 	size = afe->mtk_afe_hardware->buffer_bytes_max;
 	return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
 						     afe->dev,
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-common.h b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-common.h
index 7c083db..0fed739 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-common.h
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-common.h
@@ -47,6 +47,7 @@
 	MT6880_DAI_HW_GAIN_2,
 	MT6880_DAI_SRC_1,
 	MT6880_DAI_SRC_2,
+	MT6880_DAI_PCM_0,
 	MT6880_DAI_PCM_1,
 	MT6880_DAI_PCM_2,
 	MT6880_DAI_TDM,
@@ -59,6 +60,7 @@
 	MT6880_DAI_HOSTLESS_IMPEDANCE,
 	MT6880_DAI_HOSTLESS_SRC_1,	/* just an exmpale */
 	MT6880_DAI_HOSTLESS_SRC_BARGEIN,
+	MT6880_DAI_HOSTLESS_SPEECH_BT,
 	MT6880_DAI_HOSTLESS_UL1,
 	MT6880_DAI_HOSTLESS_UL2,
 	MT6880_DAI_HOSTLESS_UL3,
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-control.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-control.c
index ad2b66b..35c3a4f 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-control.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-control.c
@@ -139,6 +139,7 @@
 	case MT6880_MEMIF_DAI:
 	case MT6880_MEMIF_MOD_DAI:
 		return dai_memif_rate_transform(dev, rate);
+	case MT6880_DAI_PCM_0:
 	case MT6880_DAI_PCM_1:
 	case MT6880_DAI_PCM_2:
 		return pcm_rate_transform(dev, rate);
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-gpio.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-gpio.c
index abca788..ce742a3 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-gpio.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-gpio.c
@@ -33,6 +33,10 @@
 	MT6880_AFE_GPIO_TDM_ON,
 	MT6880_AFE_GPIO_EXTAMP_HIGH,
 	MT6880_AFE_GPIO_EXTAMP_LOW,
+	MT6880_AFE_GPIO_PCM0_OFF,
+	MT6880_AFE_GPIO_PCM0_ON,
+	MT6880_AFE_GPIO_PCM1_OFF,
+	MT6880_AFE_GPIO_PCM1_ON,
 	MT6880_AFE_GPIO_GPIO_NUM
 };
 
@@ -63,6 +67,10 @@
 	[MT6880_AFE_GPIO_TDM_ON] = {"aud_gpio_tdm_on", false, NULL},
 	[MT6880_AFE_GPIO_EXTAMP_HIGH] = {"extamp-pullhigh", false, NULL},
 	[MT6880_AFE_GPIO_EXTAMP_LOW] = {"extamp-pulllow", false, NULL},
+	[MT6880_AFE_GPIO_PCM0_OFF] = {"aud_gpio_pcm0_off", false, NULL},
+	[MT6880_AFE_GPIO_PCM0_ON] = {"aud_gpio_pcm0_on", false, NULL},
+	[MT6880_AFE_GPIO_PCM1_OFF] = {"aud_gpio_pcm1_off", false, NULL},
+	[MT6880_AFE_GPIO_PCM1_ON] = {"aud_gpio_pcm1_on", false, NULL},
 };
 
 static DEFINE_MUTEX(gpio_request_mutex);
@@ -186,6 +194,18 @@
 		else
 			mt6880_afe_gpio_select(afe, MT6880_AFE_GPIO_EXTAMP_LOW);
 		break;
+	case MT6880_DAI_PCM_0:
+		if (enable)
+			mt6880_afe_gpio_select(afe, MT6880_AFE_GPIO_PCM0_ON);
+		else
+			mt6880_afe_gpio_select(afe, MT6880_AFE_GPIO_PCM0_OFF);
+		break;
+	case MT6880_DAI_PCM_1:
+		if (enable)
+			mt6880_afe_gpio_select(afe, MT6880_AFE_GPIO_PCM1_ON);
+		else
+			mt6880_afe_gpio_select(afe, MT6880_AFE_GPIO_PCM1_OFF);
+		break;
 	default:
 		mutex_unlock(&gpio_request_mutex);
 		dev_warn(afe->dev, "%s(), invalid dai %d\n", __func__, dai);
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-pcm.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-pcm.c
index f1bed72..b21df5e 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-pcm.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-afe-pcm.c
@@ -885,6 +885,10 @@
 				    I_ADDA_UL_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN9,
 				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN9,
+				    I_PCM_0_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN9,
+				    I_PCM_1_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new memif_ul1_ch2_mix[] = {
@@ -892,6 +896,10 @@
 				    I_ADDA_UL_CH2, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN10,
 				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH2", AFE_CONN10_1,
+				    I_PCM_0_CAP_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH2", AFE_CONN10,
+				    I_PCM_1_CAP_CH2, 1, 0),
 };
 
 static const struct snd_kcontrol_new memif_ul2_ch1_mix[] = {
@@ -907,6 +915,8 @@
 				    I_DL3_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("DL4_CH1", AFE_CONN5_1,
 				    I_DL4_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN5_1,
+				    I_PCM_0_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN5,
 				    I_PCM_1_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN5,
@@ -936,8 +946,10 @@
 				    I_DL3_CH2, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("DL4_CH2", AFE_CONN6_1,
 				    I_DL4_CH1, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN6,
-				    I_PCM_1_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH2", AFE_CONN6_1,
+				    I_PCM_0_CAP_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH2", AFE_CONN6,
+				    I_PCM_1_CAP_CH2, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN6,
 				    I_PCM_2_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH2", AFE_CONN6,
@@ -959,15 +971,23 @@
 				    I_DL1_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("DL2_CH1", AFE_CONN32,
 				    I_DL2_CH1, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("I2S6_CH3", AFE_CONN6,
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S6_CH3", AFE_CONN32_1,
 					I_I2S6_CH3, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN32_1,
+				    I_PCM_0_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN32,
+				    I_PCM_1_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new memif_ul3_ch2_mix[] = {
 	SOC_DAPM_SINGLE_AUTODISABLE("CONNSYS_I2S_CH2", AFE_CONN33_1,
 				    I_CONNSYS_I2S_CH2, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("I2S6_CH4", AFE_CONN6,
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S6_CH4", AFE_CONN33_1,
 					I_I2S6_CH4, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH2", AFE_CONN33_1,
+				    I_PCM_0_CAP_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH2", AFE_CONN33,
+				    I_PCM_1_CAP_CH2, 1, 0),
 };
 
 static const struct snd_kcontrol_new memif_ul4_ch1_mix[] = {
@@ -1049,11 +1069,27 @@
 				    I_PCM_2_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN12,
 				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH1", AFE_CONN12,
+				    I_I2S0_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH1", AFE_CONN12,
+				    I_I2S2_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN12_1,
+				    I_PCM_0_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new memif_ul_mono_2_mix[] = {
-	SOC_DAPM_SINGLE_AUTODISABLE("ADDA_UL_CH1", AFE_CONN11,
-				    I_ADDA_UL_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN11,
+				    I_PCM_1_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN11,
+				    I_PCM_2_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN11,
+				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH1", AFE_CONN11,
+				    I_I2S0_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH1", AFE_CONN11,
+				    I_I2S2_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN11_1,
+				    I_PCM_0_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new memif_ul_mono_3_mix[] = {
@@ -1121,9 +1157,14 @@
 	{"UL1", NULL, "UL1_CH2"},
 	{"UL1_CH1", "ADDA_UL_CH1", "ADDA_UL_Mux"},
 	{"UL1_CH2", "ADDA_UL_CH2", "ADDA_UL_Mux"},
-	
+
 	{"UL1_CH1", "ETDM_CAP_CH1", "ETDM Capture"},
 	{"UL1_CH2", "ETDM_CAP_CH1", "ETDM Capture"},
+	{"UL1_CH1", "PCM_0_CAP_CH1", "PCM 0 Capture"},
+	{"UL1_CH2", "PCM_0_CAP_CH2", "PCM 0 Capture"},
+	{"UL1_CH1", "PCM_1_CAP_CH1", "PCM 1 Capture"},
+	{"UL1_CH2", "PCM_1_CAP_CH2", "PCM 1 Capture"},
+
 
 	{"UL2", NULL, "UL2_CH1"},
 	{"UL2", NULL, "UL2_CH2"},
@@ -1151,18 +1192,28 @@
 	{"UL2_CH1", "I2S6_CH1", "I2S6"},
 	{"UL2_CH2", "I2S6_CH2", "I2S6"},
 
+	{"UL2_CH1", "PCM_0_CAP_CH1", "PCM 0 Capture"},
+	{"UL2_CH2", "PCM_0_CAP_CH2", "PCM 0 Capture"},
 	{"UL2_CH1", "PCM_1_CAP_CH1", "PCM 1 Capture"},
-	{"UL2_CH2", "PCM_1_CAP_CH1", "PCM 1 Capture"},
+	{"UL2_CH2", "PCM_1_CAP_CH2", "PCM 1 Capture"},
 	{"UL2_CH1", "PCM_2_CAP_CH1", "PCM 2 Capture"},
 	{"UL2_CH2", "PCM_2_CAP_CH1", "PCM 2 Capture"},
 
 	{"UL_MONO_1", NULL, "UL_MONO_1_CH1"},
+	{"UL_MONO_1_CH1", "PCM_0_CAP_CH1", "PCM 0 Capture"},
 	{"UL_MONO_1_CH1", "PCM_1_CAP_CH1", "PCM 1 Capture"},
 	{"UL_MONO_1_CH1", "PCM_2_CAP_CH1", "PCM 2 Capture"},
 	{"UL_MONO_1_CH1", "ETDM_CAP_CH1", "ETDM Capture"},
+	{"UL_MONO_1_CH1", "I2S0_CH1", "I2S0"},
+	{"UL_MONO_1_CH1", "I2S2_CH1", "I2S2"},
 
 	{"UL_MONO_2", NULL, "UL_MONO_2_CH1"},
-	{"UL_MONO_2_CH1", "ADDA_UL_CH1", "ADDA_UL_Mux"},
+	{"UL_MONO_2_CH1", "PCM_0_CAP_CH1", "PCM 0 Capture"},
+	{"UL_MONO_2_CH1", "PCM_1_CAP_CH1", "PCM 1 Capture"},
+	{"UL_MONO_2_CH1", "PCM_2_CAP_CH1", "PCM 2 Capture"},
+	{"UL_MONO_2_CH1", "ETDM_CAP_CH1", "ETDM Capture"},
+	{"UL_MONO_2_CH1", "I2S0_CH1", "I2S0"},
+	{"UL_MONO_2_CH1", "I2S2_CH1", "I2S2"},
 
 	{"UL_MONO_3", NULL, "UL_MONO_3_CH1"},
 	{"UL_MONO_3_CH1", "ADDA_UL_CH1", "ADDA_UL_Mux"},
@@ -1179,6 +1230,10 @@
 	{"UL3_CH2", "CONNSYS_I2S_CH2", "Connsys I2S"},
 	{"UL3_CH1", "I2S6_CH3", "I2S6"},
 	{"UL3_CH2", "I2S6_CH4", "I2S6"},
+	{"UL3_CH1", "PCM_0_CAP_CH1", "PCM 0 Capture"},
+	{"UL3_CH2", "PCM_0_CAP_CH2", "PCM 0 Capture"},
+	{"UL3_CH1", "PCM_1_CAP_CH1", "PCM 1 Capture"},
+	{"UL3_CH2", "PCM_1_CAP_CH2", "PCM 1 Capture"},
 
 	{"UL4", NULL, "UL4_CH1"},
 	{"UL4", NULL, "UL4_CH2"},
@@ -2901,6 +2956,12 @@
 	regmap_read(afe->regmap, AFE_SRAM_DELSEL_CON3, &value);
 	n += scnprintf(buffer + n, size - n,
 		       "AFE_SRAM_DELSEL_CON3 = 0x%x\n", value);
+	regmap_read(afe->regmap, PCM0_INTF_CON1, &value);
+	n += scnprintf(buffer + n, size - n,
+		       "PCM0_INTF_CON1 = 0x%x\n", value);
+	regmap_read(afe->regmap, PCM0_INTF_CON2, &value);
+	n += scnprintf(buffer + n, size - n,
+		       "PCM0_INTF_CON2 = 0x%x\n", value);
 	regmap_read(afe->regmap, PCM_INTF_CON1, &value);
 	n += scnprintf(buffer + n, size - n,
 		       "PCM_INTF_CON1 = 0x%x\n", value);
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-etdm.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-etdm.c
index d27a041..c6a87b7 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-etdm.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-etdm.c
@@ -201,10 +201,16 @@
 				    I_ADDA_UL_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN2,
 				    I_PCM_1_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH2", AFE_CONN2,
+				    I_PCM_1_CAP_CH2, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN2,
 				    I_PCM_2_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH2", AFE_CONN2,
 				    I_PCM_2_CAP_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN2_1,
+				    I_PCM_0_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH2", AFE_CONN2_1,
+				    I_PCM_0_CAP_CH2, 1, 0),
 };
 
 enum {
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-hostless.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-hostless.c
index 92a433d..d021f58 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-hostless.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-hostless.c
@@ -33,12 +33,6 @@
 	{"Hostless LPBK UL", NULL, "ADDA_UL_Mux"},
 
 	/* Hostless Speech */
-	{"ADDA_DL_CH1", "PCM_1_CAP_CH1", "Hostless Speech DL"},
-	{"ADDA_DL_CH2", "PCM_1_CAP_CH1", "Hostless Speech DL"},
-	{"ADDA_DL_CH2", "PCM_1_CAP_CH2", "Hostless Speech DL"},
-	{"ADDA_DL_CH1", "PCM_2_CAP_CH1", "Hostless Speech DL"},
-	{"ADDA_DL_CH2", "PCM_2_CAP_CH1", "Hostless Speech DL"},
-	{"ADDA_DL_CH2", "PCM_2_CAP_CH2", "Hostless Speech DL"},
 	{"ETDM_PB_CH1", "PCM_2_CAP_CH1", "Hostless Speech DL"},
 	{"ETDM_PB_CH1", "PCM_2_CAP_CH2", "Hostless Speech DL"},
 	{"I2S1_CH1", "PCM_1_CAP_CH1", "Hostless Speech DL"},
@@ -59,26 +53,40 @@
 	{"I2S5_CH1", "PCM_2_CAP_CH1", "Hostless Speech DL"},
 	{"I2S5_CH2", "PCM_2_CAP_CH1", "Hostless Speech DL"},
 	{"I2S5_CH2", "PCM_2_CAP_CH2", "Hostless Speech DL"},
-	{"PCM_1_PB_CH1", "ADDA_UL_CH1", "Hostless Speech DL"},
-	{"PCM_1_PB_CH2", "ADDA_UL_CH2", "Hostless Speech DL"},
-	{"PCM_2_PB_CH1", "ADDA_UL_CH1", "Hostless Speech DL"},
-	{"PCM_2_PB_CH2", "ADDA_UL_CH2", "Hostless Speech DL"},
+	{"PCM_0_PB_CH1", "PCM_2_CAP_CH1", "Hostless Speech DL"},
+	{"PCM_0_PB_CH2", "PCM_2_CAP_CH1", "Hostless Speech DL"},
+	{"PCM_1_PB_CH1", "PCM_2_CAP_CH1", "Hostless Speech DL"},
+	{"PCM_1_PB_CH2", "PCM_2_CAP_CH1", "Hostless Speech DL"},
+
 	{"PCM_2_PB_CH1", "ETDM_CAP_CH1", "Hostless Speech DL"},
 	{"PCM_2_PB_CH2", "ETDM_CAP_CH1", "Hostless Speech DL"},
 	{"PCM_2_PB_CH1", "I2S0_CH1", "Hostless Speech DL"},
 	{"PCM_2_PB_CH2", "I2S0_CH2", "Hostless Speech DL"},
+	{"PCM_2_PB_CH1", "I2S2_CH1", "Hostless Speech DL"},
+	{"PCM_2_PB_CH2", "I2S2_CH2", "Hostless Speech DL"},
 
 	{"Hostless Speech UL", NULL, "PCM 1 Capture"},
 	{"Hostless Speech UL", NULL, "PCM 2 Capture"},
 	/*{"Hostless Speech UL", NULL, "ADDA_UL_Mux"},*/
-	{"Hostless Speech UL", NULL, "ETDM Capture"},
+	/*{"Hostless Speech UL", NULL, "ETDM Capture"},*/
 	{"Hostless Speech UL", NULL, "I2S0"},
-	/* Hostless_Sph_Echo_Ref_DAI */
-	{"PCM_1_PB_CH4", "I2S0_CH1", "Hostless_Sph_Echo_Ref_DL"},
-	{"PCM_1_PB_CH4", "I2S0_CH2", "Hostless_Sph_Echo_Ref_DL"},
-	{"PCM_1_PB_CH4", "I2S2_CH1", "Hostless_Sph_Echo_Ref_DL"},
-	{"PCM_1_PB_CH4", "I2S2_CH2", "Hostless_Sph_Echo_Ref_DL"},
 
+	/* Hostless Speech_BT */
+	{"PCM_0_PB_CH1", "PCM_2_CAP_CH1", "Hostless Speech_BT DL"},
+	{"PCM_0_PB_CH2", "PCM_2_CAP_CH1", "Hostless Speech_BT DL"},
+	{"PCM_1_PB_CH1", "PCM_2_CAP_CH1", "Hostless Speech_BT DL"},
+	{"PCM_1_PB_CH1", "PCM_2_CAP_CH1", "Hostless Speech_BT DL"},
+
+	{"PCM_2_PB_CH1", "PCM_0_CAP_CH1", "Hostless Speech_BT DL"},
+	{"PCM_2_PB_CH2", "PCM_0_CAP_CH2", "Hostless Speech_BT DL"},
+	{"PCM_2_PB_CH1", "PCM_1_CAP_CH1", "Hostless Speech_BT DL"},
+	{"PCM_2_PB_CH2", "PCM_1_CAP_CH2", "Hostless Speech_BT DL"},
+
+	{"Hostless Speech_BT UL", NULL, "PCM 0 Capture"},
+	{"Hostless Speech_BT UL", NULL, "PCM 1 Capture"},
+	{"Hostless Speech_BT UL", NULL, "PCM 2 Capture"},
+
+	/* Hostless_Sph_Echo_Ref_DAI */
 	{"PCM_2_PB_CH4", "I2S0_CH1", "Hostless_Sph_Echo_Ref_DL"},
 	{"PCM_2_PB_CH4", "I2S0_CH2", "Hostless_Sph_Echo_Ref_DL"},
 	{"PCM_2_PB_CH4", "I2S2_CH1", "Hostless_Sph_Echo_Ref_DL"},
@@ -309,6 +317,25 @@
 		},
 		.ops = &mtk_dai_hostless_ops,
 	},
+	{
+		.name = "Hostless Speech_BT DAI",
+		.id = MT6880_DAI_HOSTLESS_SPEECH_BT,
+		.playback = {
+			.stream_name = "Hostless Speech_BT DL",
+			.channels_min = 1,
+			.channels_max = 2,
+			.rates = MTK_HOSTLESS_RATES,
+			.formats = MTK_HOSTLESS_FORMATS,
+		},
+		.capture = {
+			.stream_name = "Hostless Speech_BT UL",
+			.channels_min = 1,
+			.channels_max = 2,
+			.rates = MTK_HOSTLESS_RATES,
+			.formats = MTK_HOSTLESS_FORMATS,
+		},
+		.ops = &mtk_dai_hostless_ops,
+	},
 	/* BE dai */
 	{
 		.name = "Hostless_UL1 DAI",
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-pcm.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-pcm.c
index 1bce229..1b66071 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-pcm.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-dai-pcm.c
@@ -7,6 +7,7 @@
 #include <linux/regmap.h>
 #include <sound/pcm_params.h>
 #include "mt6880-afe-common.h"
+#include "mt6880-afe-gpio.h"
 #include "mt6880-interconnection.h"
 
 enum AUD_TX_LCH_RPT {
@@ -77,7 +78,67 @@
 	AUD_PCM_EN_ENABLE = 1
 };
 
+struct mtk_afe_pcm_priv {
+	int id;
+	int rate;
+};
+
+static int get_pcm_id_by_name(struct mtk_base_afe *afe,
+			      const char *name)
+{
+	if (strncmp(name, "PCM_0", 5) == 0)
+		return MT6880_DAI_PCM_0;
+	else if (strncmp(name, "PCM_1", 5) == 0)
+		return MT6880_DAI_PCM_1;
+	else if (strncmp(name, "PCM_2", 5) == 0)
+		return MT6880_DAI_PCM_2;
+	else
+		return -EINVAL;
+}
+
+static struct mtk_afe_pcm_priv *get_pcm_priv_by_name(struct mtk_base_afe *afe,
+						     const char *name)
+{
+	struct mt6880_afe_private *afe_priv = afe->platform_priv;
+	int dai_id = get_pcm_id_by_name(afe, name);
+
+	if (dai_id < 0)
+		return NULL;
+
+	return afe_priv->dai_priv[dai_id];
+}
+
 /* dai component */
+static const struct snd_kcontrol_new mtk_pcm_0_playback_ch1_mix[] = {
+	SOC_DAPM_SINGLE_AUTODISABLE("DL1_CH1", AFE_CONN56,
+				    I_DL1_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("DL2_CH1", AFE_CONN56,
+				    I_DL2_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN56,
+				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH1", AFE_CONN56,
+				    I_I2S0_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH1", AFE_CONN56,
+				    I_I2S2_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN56,
+				    I_PCM_2_CAP_CH1, 1, 0),
+};
+
+static const struct snd_kcontrol_new mtk_pcm_0_playback_ch2_mix[] = {
+	SOC_DAPM_SINGLE_AUTODISABLE("DL1_CH2", AFE_CONN57,
+				    I_DL1_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("DL2_CH2", AFE_CONN57,
+				    I_DL2_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN57,
+				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH2", AFE_CONN57,
+				    I_I2S0_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH2", AFE_CONN57,
+				    I_I2S2_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN56,
+				    I_PCM_2_CAP_CH1, 1, 0),
+};
+
 static const struct snd_kcontrol_new mtk_pcm_1_playback_ch1_mix[] = {
 	SOC_DAPM_SINGLE_AUTODISABLE("ADDA_UL_CH1", AFE_CONN7,
 				    I_ADDA_UL_CH1, 1, 0),
@@ -85,6 +146,12 @@
 				    I_DL2_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("ETDM_CAP_CH1", AFE_CONN7,
 				    I_ETDM_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH1", AFE_CONN57,
+				    I_I2S0_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH1", AFE_CONN57,
+				    I_I2S2_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN57,
+					I_PCM_2_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new mtk_pcm_1_playback_ch2_mix[] = {
@@ -92,19 +159,12 @@
 				    I_ADDA_UL_CH2, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("DL2_CH2", AFE_CONN8,
 				    I_DL2_CH2, 1, 0),
-};
-
-static const struct snd_kcontrol_new mtk_pcm_1_playback_ch4_mix[] = {
-	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH1", AFE_CONN27,
-				    I_I2S0_CH1, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH2", AFE_CONN27,
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH2", AFE_CONN8,
 				    I_I2S0_CH2, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("DL1_CH1", AFE_CONN27,
-				    I_DL1_CH1, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH1", AFE_CONN27,
-				    I_I2S2_CH1, 1, 0),
-	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH2", AFE_CONN27,
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH2", AFE_CONN8,
 				    I_I2S2_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_2_CAP_CH1", AFE_CONN8,
+					I_PCM_2_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new mtk_pcm_2_playback_ch1_mix[] = {
@@ -116,6 +176,12 @@
 				    I_ETDM_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH1", AFE_CONN17,
 				    I_I2S0_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH1", AFE_CONN17,
+				    I_I2S2_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH1", AFE_CONN17_1,
+				    I_PCM_0_CAP_CH1, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH1", AFE_CONN17,
+				    I_PCM_1_CAP_CH1, 1, 0),
 };
 
 static const struct snd_kcontrol_new mtk_pcm_2_playback_ch2_mix[] = {
@@ -127,6 +193,12 @@
 				    I_ETDM_CAP_CH1, 1, 0),
 	SOC_DAPM_SINGLE_AUTODISABLE("I2S0_CH2", AFE_CONN18,
 				    I_I2S0_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("I2S2_CH2", AFE_CONN18,
+				    I_I2S2_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_0_CAP_CH2", AFE_CONN18_1,
+				    I_PCM_0_CAP_CH2, 1, 0),
+	SOC_DAPM_SINGLE_AUTODISABLE("PCM_1_CAP_CH2", AFE_CONN18,
+				    I_PCM_1_CAP_CH2, 1, 0),
 };
 
 static const struct snd_kcontrol_new mtk_pcm_2_playback_ch4_mix[] = {
@@ -148,29 +220,49 @@
 {
 	struct snd_soc_component *cmpnt = snd_soc_dapm_to_component(w->dapm);
 	struct mtk_base_afe *afe = snd_soc_component_get_drvdata(cmpnt);
+	struct mtk_afe_pcm_priv *pcm_priv;
+
+	pcm_priv = get_pcm_priv_by_name(afe, w->name);
+
+	if (!pcm_priv) {
+		dev_warn(afe->dev, "%s(), pcm_priv == NULL", __func__);
+		return 0;
+	}
 
 	dev_info(afe->dev, "%s(), name %s, event 0x%x\n",
 		 __func__, w->name, event);
 
-	if(event == SND_SOC_DAPM_PRE_PMU) {
-		device_init_wakeup(afe->dev, true);
-	} else {
-		device_init_wakeup(afe->dev, false);
+	switch (event) {
+	case SND_SOC_DAPM_PRE_PMU:
+		if (strcmp(w->name, "PCM_2_EN") == 0)
+			device_init_wakeup(afe->dev, true);
+		mt6880_afe_gpio_request(afe, true, pcm_priv->id, 0);
+		break;
+	case SND_SOC_DAPM_POST_PMD:
+		if (strcmp(w->name, "PCM_2_EN") == 0)
+			device_init_wakeup(afe->dev, false);
+		mt6880_afe_gpio_request(afe, false, pcm_priv->id, 0);
+		break;
+	default:
+		break;
 	}
 	return 0;
 }
 
 static const struct snd_soc_dapm_widget mtk_dai_pcm_widgets[] = {
 	/* inter-connections */
+	SND_SOC_DAPM_MIXER("PCM_0_PB_CH1", SND_SOC_NOPM, 0, 0,
+			   mtk_pcm_0_playback_ch1_mix,
+			   ARRAY_SIZE(mtk_pcm_0_playback_ch1_mix)),
+	SND_SOC_DAPM_MIXER("PCM_0_PB_CH2", SND_SOC_NOPM, 0, 0,
+			   mtk_pcm_0_playback_ch2_mix,
+			   ARRAY_SIZE(mtk_pcm_0_playback_ch2_mix)),
 	SND_SOC_DAPM_MIXER("PCM_1_PB_CH1", SND_SOC_NOPM, 0, 0,
 			   mtk_pcm_1_playback_ch1_mix,
 			   ARRAY_SIZE(mtk_pcm_1_playback_ch1_mix)),
 	SND_SOC_DAPM_MIXER("PCM_1_PB_CH2", SND_SOC_NOPM, 0, 0,
 			   mtk_pcm_1_playback_ch2_mix,
 			   ARRAY_SIZE(mtk_pcm_1_playback_ch2_mix)),
-	SND_SOC_DAPM_MIXER("PCM_1_PB_CH4", SND_SOC_NOPM, 0, 0,
-			   mtk_pcm_1_playback_ch4_mix,
-			   ARRAY_SIZE(mtk_pcm_1_playback_ch4_mix)),
 	SND_SOC_DAPM_MIXER("PCM_2_PB_CH1", SND_SOC_NOPM, 0, 0,
 			   mtk_pcm_2_playback_ch1_mix,
 			   ARRAY_SIZE(mtk_pcm_2_playback_ch1_mix)),
@@ -181,46 +273,67 @@
 			   mtk_pcm_2_playback_ch4_mix,
 			   ARRAY_SIZE(mtk_pcm_2_playback_ch4_mix)),
 
-	SND_SOC_DAPM_SUPPLY("PCM_1_EN",
+	SND_SOC_DAPM_SUPPLY("PCM_0_EN",
 			    PCM0_INTF_CON1, PCM_EN_SFT, 0,
 			    mtk_pcm_en_event,
 			    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
 
+	SND_SOC_DAPM_SUPPLY("PCM_1_EN",
+			    PCM_INTF_CON1, PCM_EN_SFT, 0,
+			    mtk_pcm_en_event,
+			    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
+
 	SND_SOC_DAPM_SUPPLY("PCM_2_EN",
 			    PCM2_INTF_CON, PCM2_EN_SFT, 0,
 			    mtk_pcm_en_event,
 			    SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
 
 	SND_SOC_DAPM_INPUT("MD1_TO_AFE"),
-	SND_SOC_DAPM_INPUT("MD2_TO_AFE"),
+	SND_SOC_DAPM_INPUT("BT1_TO_AFE"),
+	SND_SOC_DAPM_INPUT("BT0_TO_AFE"),
 	SND_SOC_DAPM_OUTPUT("AFE_TO_MD1"),
-	SND_SOC_DAPM_OUTPUT("AFE_TO_MD2"),
+	SND_SOC_DAPM_OUTPUT("AFE_TO_BT1"),
+	SND_SOC_DAPM_OUTPUT("AFE_TO_BT0"),
 };
 
 static const struct snd_soc_dapm_route mtk_dai_pcm_routes[] = {
+	{"PCM 0 Playback", NULL, "PCM_0_PB_CH1"},
+	{"PCM 0 Playback", NULL, "PCM_0_PB_CH2"},
 	{"PCM 1 Playback", NULL, "PCM_1_PB_CH1"},
 	{"PCM 1 Playback", NULL, "PCM_1_PB_CH2"},
-	{"PCM 1 Playback", NULL, "PCM_1_PB_CH4"},
 	{"PCM 2 Playback", NULL, "PCM_2_PB_CH1"},
 	{"PCM 2 Playback", NULL, "PCM_2_PB_CH2"},
 	{"PCM 2 Playback", NULL, "PCM_2_PB_CH4"},
 
+	{"PCM 0 Playback", NULL, "PCM_0_EN"},
 	{"PCM 1 Playback", NULL, "PCM_1_EN"},
 	{"PCM 2 Playback", NULL, "PCM_2_EN"},
+	{"PCM 0 Capture", NULL, "PCM_0_EN"},
 	{"PCM 1 Capture", NULL, "PCM_1_EN"},
 	{"PCM 2 Capture", NULL, "PCM_2_EN"},
 
 	{"AFE_TO_MD1", NULL, "PCM 2 Playback"},
-	{"AFE_TO_MD2", NULL, "PCM 1 Playback"},
+	{"AFE_TO_BT1", NULL, "PCM 1 Playback"},
+	{"AFE_TO_BT0", NULL, "PCM 0 Playback"},
 	{"PCM 2 Capture", NULL, "MD1_TO_AFE"},
-	{"PCM 1 Capture", NULL, "MD2_TO_AFE"},
+	{"PCM 1 Capture", NULL, "BT1_TO_AFE"},
+	{"PCM 0 Capture", NULL, "BT0_TO_AFE"},
 
+	{"PCM_0_PB_CH1", "DL2_CH1", "DL2"},
+	{"PCM_0_PB_CH2", "DL2_CH2", "DL2"},
+	{"PCM_0_PB_CH1", "PCM_2_CAP_CH1", "PCM 2 Capture"},
+	{"PCM_0_PB_CH2", "PCM_2_CAP_CH1", "PCM 2 Capture"},
 	{"PCM_1_PB_CH1", "DL2_CH1", "DL2"},
 	{"PCM_1_PB_CH2", "DL2_CH2", "DL2"},
-	{"PCM_1_PB_CH4", "DL1_CH1", "DL1"},
+	{"PCM_1_PB_CH1", "PCM_2_CAP_CH1", "PCM 2 Capture"},
+	{"PCM_1_PB_CH2", "PCM_2_CAP_CH1", "PCM 2 Capture"},
 	{"PCM_2_PB_CH1", "DL2_CH1", "DL2"},
 	{"PCM_2_PB_CH2", "DL2_CH2", "DL2"},
 	{"PCM_2_PB_CH4", "DL1_CH1", "DL1"},
+	{"PCM_2_PB_CH1", "PCM_0_CAP_CH1", "PCM 0 Capture"},
+	{"PCM_2_PB_CH2", "PCM_0_CAP_CH2", "PCM 0 Capture"},
+	{"PCM_2_PB_CH1", "PCM_1_CAP_CH1", "PCM 1 Capture"},
+	{"PCM_2_PB_CH2", "PCM_1_CAP_CH2", "PCM 1 Capture"},
 };
 
 /* dai ops */
@@ -246,22 +359,38 @@
 		return 0;
 
 	switch (dai->id) {
-	case MT6880_DAI_PCM_1:
+	case MT6880_DAI_PCM_0:
 		pcm_con |= AUD_BCLK_OUT_INV_NO_INVERSE << PCM_BCLK_OUT_INV_SFT;
 		pcm_con |= AUD_TX_LCH_RPT_NO_REPEAT << PCM_TX_LCH_RPT_SFT;
 		pcm_con |= AUD_VBT_16K_MODE_DISABLE << PCM_VBT_16K_MODE_SFT;
-		pcm_con |= AUD_EXT_MODEM_SELECT_INTERNAL << PCM_EXT_MODEM_SFT;
+		pcm_con |= AUD_EXT_MODEM_SELECT_EXTERNAL << PCM_EXT_MODEM_SFT;
 		pcm_con |= 0 << PCM_SYNC_LENGTH_SFT;
 		pcm_con |= AUD_PCM_ONE_BCK_CYCLE_SYNC << PCM_SYNC_TYPE_SFT;
 		pcm_con |= AUD_BT_MODE_DUAL_MIC_ON_TX << PCM_BT_MODE_SFT;
 		pcm_con |= AUD_PCM_AFIFO_AFIFO << PCM_BYP_ASRC_SFT;
-		pcm_con |= AUD_PCM_CLOCK_SLAVE_MODE << PCM_SLAVE_SFT;
+		pcm_con |= AUD_PCM_CLOCK_MASTER_MODE << PCM_SLAVE_SFT;
 		pcm_con |= rate_reg << PCM_MODE_SFT;
 		pcm_con |= AUD_PCM_FMT_PCM_MODE_B << PCM_FMT_SFT;
 
 		regmap_update_bits(afe->regmap, PCM0_INTF_CON1,
 				   0xfffffffe, pcm_con);
 		break;
+	case MT6880_DAI_PCM_1:
+		pcm_con |= AUD_BCLK_OUT_INV_NO_INVERSE << PCM_BCLK_OUT_INV_SFT;
+		pcm_con |= AUD_TX_LCH_RPT_NO_REPEAT << PCM_TX_LCH_RPT_SFT;
+		pcm_con |= AUD_VBT_16K_MODE_DISABLE << PCM_VBT_16K_MODE_SFT;
+		pcm_con |= AUD_EXT_MODEM_SELECT_EXTERNAL << PCM_EXT_MODEM_SFT;
+		pcm_con |= 0 << PCM_SYNC_LENGTH_SFT;
+		pcm_con |= AUD_PCM_ONE_BCK_CYCLE_SYNC << PCM_SYNC_TYPE_SFT;
+		pcm_con |= AUD_BT_MODE_DUAL_MIC_ON_TX << PCM_BT_MODE_SFT;
+		pcm_con |= AUD_PCM_AFIFO_AFIFO << PCM_BYP_ASRC_SFT;
+		pcm_con |= AUD_PCM_CLOCK_MASTER_MODE << PCM_SLAVE_SFT;
+		pcm_con |= rate_reg << PCM_MODE_SFT;
+		pcm_con |= AUD_PCM_FMT_PCM_MODE_B << PCM_FMT_SFT;
+
+		regmap_update_bits(afe->regmap, PCM_INTF_CON1,
+				   0xfffffffe, pcm_con);
+		break;
 	case MT6880_DAI_PCM_2:
 		pcm_con |= AUD_TX_LCH_RPT_NO_REPEAT << PCM2_TX_LCH_RPT_SFT;
 		pcm_con |= AUD_VBT_16K_MODE_DISABLE << PCM2_VBT_16K_MODE_SFT;
@@ -300,6 +429,27 @@
 
 static struct snd_soc_dai_driver mtk_dai_pcm_driver[] = {
 	{
+		.name = "PCM 0",
+		.id = MT6880_DAI_PCM_0,
+		.playback = {
+			.stream_name = "PCM 0 Playback",
+			.channels_min = 1,
+			.channels_max = 2,
+			.rates = MTK_PCM_RATES,
+			.formats = MTK_PCM_FORMATS,
+		},
+		.capture = {
+			.stream_name = "PCM 0 Capture",
+			.channels_min = 1,
+			.channels_max = 2,
+			.rates = MTK_PCM_RATES,
+			.formats = MTK_PCM_FORMATS,
+		},
+		.ops = &mtk_dai_pcm_ops,
+		.symmetric_rates = 1,
+		.symmetric_samplebits = 1,
+	},
+	{
 		.name = "PCM 1",
 		.id = MT6880_DAI_PCM_1,
 		.playback = {
@@ -343,9 +493,46 @@
 	},
 };
 
+/* this enum is merely for mtk_afe_pcm_priv declare */
+enum {
+	DAI_PCM0 = 0,
+	DAI_PCM1,
+	DAI_PCM2,
+	DAI_PCM_NUM,
+};
+
+static const struct mtk_afe_pcm_priv mt6880_pcm_priv[DAI_PCM_NUM] = {
+	[DAI_PCM0] = {
+		.id = MT6880_DAI_PCM_0,
+	},
+	[DAI_PCM1] = {
+		.id = MT6880_DAI_PCM_1,
+	},
+	[DAI_PCM2] = {
+		.id = MT6880_DAI_PCM_2,
+	},
+};
+
+int mt6880_dai_pcm_set_priv(struct mtk_base_afe *afe)
+{
+	int i;
+	int ret;
+
+	for (i = 0; i < DAI_PCM_NUM; i++) {
+		ret = mt6880_dai_set_priv(afe, mt6880_pcm_priv[i].id,
+					  sizeof(struct mtk_afe_pcm_priv),
+					  &mt6880_pcm_priv[i]);
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
 int mt6880_dai_pcm_register(struct mtk_base_afe *afe)
 {
 	struct mtk_base_afe_dai *dai;
+	int ret;
 
 	dev_info(afe->dev, "%s()\n", __func__);
 
@@ -362,5 +549,11 @@
 	dai->num_dapm_widgets = ARRAY_SIZE(mtk_dai_pcm_widgets);
 	dai->dapm_routes = mtk_dai_pcm_routes;
 	dai->num_dapm_routes = ARRAY_SIZE(mtk_dai_pcm_routes);
+
+	/* set all dai pcm private data */
+	ret = mt6880_dai_pcm_set_priv(afe);
+	if (ret)
+		return ret;
+
 	return 0;
 }
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-interconnection.h b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-interconnection.h
index 0116bbc..faec42a 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-interconnection.h
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-interconnection.h
@@ -46,7 +46,11 @@
 #define I_SRC_2_OUT_CH2 (39 - I_32_OFFSET)
 #define I_DL4_CH1 (40 - I_32_OFFSET)
 #define I_DL4_CH2 (41 - I_32_OFFSET)
+#define I_DMIC1_CH1 (42 - I_32_OFFSET)
+#define I_DMIC1_CH2 (43 - I_32_OFFSET)
 #define I_I2S6_CH3 (44 - I_32_OFFSET)
 #define I_I2S6_CH4 (45 - I_32_OFFSET)
+#define I_PCM_0_CAP_CH1 (46 - I_32_OFFSET)
+#define I_PCM_0_CAP_CH2 (47 - I_32_OFFSET)
 
 #endif
diff --git a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-mt6359.c b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-mt6359.c
index 56e4612..34bd9d8 100644
--- a/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-mt6359.c
+++ b/src/kernel/linux/v4.19/sound/soc/mediatek/mt6880/mt6880-mt6359.c
@@ -618,6 +618,19 @@
 		.dpcm_capture = 1,
 		.ignore_suspend = 1,
 	},
+	{
+		.name = "Hostless_Speech_BT",
+		.stream_name = "Hostless_Speech_BT",
+		.cpu_dai_name = "Hostless Speech_BT DAI",
+		.codec_name = "snd-soc-dummy",
+		.codec_dai_name = "snd-soc-dummy-dai",
+		.trigger = {SND_SOC_DPCM_TRIGGER_PRE,
+				SND_SOC_DPCM_TRIGGER_PRE},
+		.dynamic = 1,
+		.dpcm_playback = 1,
+		.dpcm_capture = 1,
+		.ignore_suspend = 1,
+	},
 	/* Back End DAI links */
 #if 0
 	{
@@ -826,6 +839,16 @@
 		.ignore_suspend = 1,
 	},
 	{
+		.name = "PCM 0",
+		.cpu_dai_name = "PCM 0",
+		.codec_name = "snd-soc-dummy",
+		.codec_dai_name = "snd-soc-dummy-dai",
+		.no_pcm = 1,
+		.dpcm_playback = 1,
+		.dpcm_capture = 1,
+		.ignore_suspend = 1,
+	},
+	{
 		.name = "PCM 1",
 		.cpu_dai_name = "PCM 1",
 		.codec_name = "snd-soc-dummy",
diff --git a/src/kernel/modules/netsys_driver/nat/hw_nat/hnat_common.c b/src/kernel/modules/netsys_driver/nat/hw_nat/hnat_common.c
index e246473..614eeb0 100644
--- a/src/kernel/modules/netsys_driver/nat/hw_nat/hnat_common.c
+++ b/src/kernel/modules/netsys_driver/nat/hw_nat/hnat_common.c
@@ -132,7 +132,6 @@
 int DP_GMAC2;
 int DP_EDMA0;
 int DP_EDMA1;
-int DP_CCMNI0 = MAX_IF_NUM;
 
 #ifdef CONFIG_RAETH_EDMA
 	struct net_device *aqr_dev1;
@@ -3106,59 +3105,58 @@
 	}
 
 	if (strncmp(dev->name, "ccmni0", 6) == 0) {
-		if (dst_port[8] == NULL) {
-			dst_port[8] = dev;
-			dst_port_type[8] = 0;
-			DP_CCMNI0 = 8;
+		if (dst_port[DP_CCMNI0] == NULL) {
+			dst_port[DP_CCMNI0] = dev;
+			dst_port_type[DP_CCMNI0] = 0;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni1", 6) == 0) {
-		if (dst_port[9] == NULL) {
-			dst_port[9] = dev;
-			dst_port_type[9] = 0;
+		if (dst_port[DP_CCMNI1] == NULL) {
+			dst_port[DP_CCMNI1] = dev;
+			dst_port_type[DP_CCMNI1] = 0;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni2", 6) == 0) {
-		if (dst_port[10] == NULL) {
-			dst_port[10] = dev;
-			dst_port_type[10] = 0;
+		if (dst_port[DP_CCMNI2] == NULL) {
+			dst_port[DP_CCMNI2] = dev;
+			dst_port_type[DP_CCMNI2] = 0;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni3", 6) == 0) {
-		if (dst_port[11] == NULL) {
-			dst_port[11] = dev;
-			dst_port_type[11] = 0;
+		if (dst_port[DP_CCMNI3] == NULL) {
+			dst_port[DP_CCMNI3] = dev;
+			dst_port_type[DP_CCMNI3] = 0;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni4", 6) == 0) {
-		if (dst_port[12] == NULL) {
-			dst_port[12] = dev;
-			dst_port_type[12] = 0;
+		if (dst_port[DP_CCMNI4] == NULL) {
+			dst_port[DP_CCMNI4] = dev;
+			dst_port_type[DP_CCMNI4] = 0;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni5", 6) == 0) {
-		if (dst_port[13] == NULL) {
-			dst_port[13] = dev;
-			dst_port_type[13] = 0;
+		if (dst_port[DP_CCMNI5] == NULL) {
+			dst_port[DP_CCMNI5] = dev;
+			dst_port_type[DP_CCMNI5] = 0;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni6", 6) == 0) {
-		if (dst_port[14] == NULL) {
-			dst_port[14] = dev;
-			dst_port_type[14] = 0;
+		if (dst_port[DP_CCMNI6] == NULL) {
+			dst_port[DP_CCMNI6] = dev;
+			dst_port_type[DP_CCMNI6] = 0;
 			return;
 		}
 	}
-	if (strncmp(dev->name, "ccmni7", 7) == 0) {
-		if (dst_port[15] == NULL) {
-			dst_port[15] = dev;
-			dst_port_type[15] = 0;
+	if (strncmp(dev->name, "ccmni7", 6) == 0) {
+		if (dst_port[DP_CCMNI7] == NULL) {
+			dst_port[DP_CCMNI7] = dev;
+			dst_port_type[DP_CCMNI7] = 0;
 			return;
 		}
 	}
@@ -3185,58 +3183,58 @@
 		return;
 
 	if (strncmp(dev->name, "ccmni0", 6) == 0) {
-		if (dst_port[8] != NULL) {
-			dst_port[8] = NULL;
+		if (dst_port[DP_CCMNI0] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI0] = NULL;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni1", 6) == 0) {
-		if (dst_port[9] != NULL) {
-			dst_port[9] = NULL;
+		if (dst_port[DP_CCMNI1] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI1] = NULL;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni2", 6) == 0) {
-		if (dst_port[10] != NULL) {
-			dst_port[10] = NULL;
+		if (dst_port[DP_CCMNI2] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI2] = NULL;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni3", 6) == 0) {
-		if (dst_port[11] != NULL) {
-			dst_port[11] = NULL;
+		if (dst_port[DP_CCMNI3] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI3] = NULL;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni4", 6) == 0) {
-		if (dst_port[12] != NULL) {
-			dst_port[12] = NULL;
+		if (dst_port[DP_CCMNI4] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI4] = NULL;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni5", 6) == 0) {
-		if (dst_port[13] != NULL) {
-			dst_port[13] = NULL;
+		if (dst_port[DP_CCMNI5] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI5] = NULL;
 			return;
 		}
 	}
 	if (strncmp(dev->name, "ccmni6", 6) == 0) {
-		if (dst_port[14] != NULL) {
-			dst_port[14] = NULL;
+		if (dst_port[DP_CCMNI6] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI6] = NULL;
 			return;
 		}
 	}
-	if (strncmp(dev->name, "ccmni7", 7) == 0) {
-		if (dst_port[15] != NULL) {
-			dst_port[15] = NULL;
+	if (strncmp(dev->name, "ccmni7", 6) == 0) {
+		if (dst_port[DP_CCMNI7] != NULL) {
 			ppe_reset_dev_mib(dev);
+			dst_port[DP_CCMNI7] = NULL;
 			return;
 		}
 	}
@@ -4239,12 +4237,6 @@
 	if (ret)
 		return ret;
 #endif
-	/* avoid LAN-WAN NAT link enters bind state */
-	if (IS_IPV4_HNAT(entry)) {
-		if (debug_level >= 7)
-			pr_notice("%s, NAT entry is not allowed to HWNAT !!\n", __func__);
-		return 1;
-	}
 
 	ret = ppe_fill_table_med(skb, entry, ppe_parse_result);
 
@@ -4950,7 +4942,8 @@
 	} else if(FOE_SP(skb) == ADMA_PSE_PORT) {
 		entry = &ppe_foe_base[FOE_ENTRY_NUM(skb)];
 	} else if(FOE_SP(skb) == QDMA_PSE_PORT) { // QoS
-		entry = (FOE_AI(skb) == PACKET_FORWARD_PATH_WITHOUT_PPE)?
+		entry = ((FOE_AI(skb) == PACKET_FORWARD_PATH_WITHOUT_PPE) &&
+			 (FOE_IF_IDX(skb) >= DP_CCMNI0))?
 			&ppe1_foe_base[FOE_ENTRY_NUM(skb)] : // MDMA
 			&ppe_foe_base[FOE_ENTRY_NUM(skb)];
 	} else {
diff --git a/src/kernel/modules/netsys_driver/nat/hw_nat/ra_nat.h b/src/kernel/modules/netsys_driver/nat/hw_nat/ra_nat.h
index 056f403..1ae61c7 100644
--- a/src/kernel/modules/netsys_driver/nat/hw_nat/ra_nat.h
+++ b/src/kernel/modules/netsys_driver/nat/hw_nat/ra_nat.h
@@ -154,6 +154,16 @@
 
 #define MAX_IF_NUM 64
 
+/* skb head for RXIF_IDX only has 4 bits, so max index should be 15 */
+#define DP_CCMNI0 8
+#define DP_CCMNI1 (DP_CCMNI0 + 1) /* 9 */
+#define DP_CCMNI2 (DP_CCMNI0 + 2) /* 10 */
+#define DP_CCMNI3 (DP_CCMNI0 + 3) /* 11 */
+#define DP_CCMNI4 (DP_CCMNI0 + 4) /* 12 */
+#define DP_CCMNI5 (DP_CCMNI0 + 5) /* 13 */
+#define DP_CCMNI6 (DP_CCMNI0 + 6) /* 14 */
+#define DP_CCMNI7 (DP_CCMNI0 + 7) /* 15 */
+
 /*Colgin head*/
 /*   +----------------------------------------------------------- */
 /*   | entry_idx(15) | cpu_reason(5)|source port(4)|alg(1)|rsv(7) */
diff --git a/src/telephony/tel-demo/src/sms/sms.cpp b/src/telephony/tel-demo/src/sms/sms.cpp
index 903b306..f9f3546 100644
--- a/src/telephony/tel-demo/src/sms/sms.cpp
+++ b/src/telephony/tel-demo/src/sms/sms.cpp
@@ -737,6 +737,13 @@
 //sent status save
 int saveSendedSmsInfo(int charset, char* num, char* msg, char* smsc)
 {
+    if (auto_save_sms_to_sim == false || strlen(msg) > MAX_PDU_SIZE)
+    {
+        RLOGE("%s:auto_save_sms_to_sim is %d, msg len = %d, return directly",
+                __FUNCTION__, auto_save_sms_to_sim, strlen(msg));
+        return 0;
+    }
+
     if(psmsSaveInfo == NULL)
     {
         psmsSaveInfo = (smsSaveInfo*)malloc(sizeof(smsSaveInfo));
diff --git a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/framework/base/RfxDefaultValueTable.cpp b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/framework/base/RfxDefaultValueTable.cpp
index 9d723ec..446a640 100644
--- a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/framework/base/RfxDefaultValueTable.cpp
+++ b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/framework/base/RfxDefaultValueTable.cpp
@@ -1,3 +1,4 @@
+//SPDX-License-Identifier: MediaTekProprietary
 /* Copyright Statement:
  *
  * This software/firmware and related documentation ("MediaTek Software") are
@@ -66,8 +67,8 @@
     RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_ECPIN_STATE, RfxVariant(RFX_ECPIN_DONE)),
     RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_MODEM_SIM_TASK_READY, RfxVariant(false)),
 //    RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_SERVICE_STATE, RfxVariant(RfxNwServiceState())),
-    RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_VOICE_TYPE, RfxVariant()),
-    RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_DATA_TYPE, RfxVariant()),
+    RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_VOICE_TYPE, RfxVariant(0)),
+    RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_DATA_TYPE, RfxVariant(0)),
     RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_RADIO_STATE, RfxVariant()),
     RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_MODEM_POWER_OFF, RfxVariant(false)),
     RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_MODEM_OFF_STATE, RfxVariant(0)),
diff --git a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.cpp b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.cpp
index 6615766..5a920f2 100644
--- a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.cpp
+++ b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.cpp
@@ -1654,6 +1654,9 @@
     int p3 = 0;
     int data_len = 0;
     char* data_ptr = NULL;
+    char *byteData = NULL;
+    uint16_t len = 0;
+    uint16_t bLen = 0;
 
     do {
         if(message->getRilToken() == NULL) {
@@ -1699,10 +1702,15 @@
         data_ptr = strdupReadString(p);
         if(data_ptr && (string(data_ptr).empty())) {
             data_ptr = NULL;
+        } else {
+            if (data_ptr != NULL) {
+                len = strlen(data_ptr);
+                bLen = hexStringToByteArrayEx((unsigned char*)data_ptr, len, (unsigned char **)&byteData);
+            }
         }
-        RFX_LOG_D(mLog_tag.c_str(), "session_id:%d, cla:%d, ins:%d,p1=%d,p2=%d,p3=%d,data=%s", session_id, cla, ins, p1, p2, p3, (data_ptr==NULL? "": data_ptr));
+        RFX_LOG_D(mLog_tag.c_str(), "session_id:%d, cla:%d, ins:%d,p1=%d,p2=%d,p3=%d,data=%s", session_id, cla, ins, p1, p2, p3, (byteData==NULL? "": byteData));
         ret = mipc_sim_extended_channel_generic_access_async(slot_id_to_mipc_sim_id(message->getSlotId()), mipc_sim_extended_channel_generic_access_cb,
-                (void*) message->getRilToken(), session_id, cla, ins, p1, p2, p3, (data_ptr==NULL? 0: strlen(data_ptr)), data_ptr);
+                (void*) message->getRilToken(), session_id, cla, ins, p1, p2, p3, bLen, byteData);
     }while(0);
 
     if(ret != MIPC_API_RESULT_SUCCESS) {
@@ -1713,6 +1721,9 @@
     if(data_ptr) {
         free(data_ptr);
     }
+    if (byteData) {
+        free(byteData);
+    }
     RFX_LOG_D(mLog_tag.c_str(), "%s done", __FUNCTION__);
 }
 
@@ -1760,6 +1771,9 @@
     int p3 = 0;
     int data_len = 0;
     char* data_ptr = NULL;
+    char *byteData = NULL;
+    uint16_t len = 0;
+    uint16_t bLen = 0;
 
     do {
         if(message->getRilToken() == NULL) {
@@ -1808,11 +1822,16 @@
         data_ptr = strdupReadString(p);
         if(data_ptr && (string(data_ptr).empty())) {
             data_ptr = NULL;
+        } else {
+            if (data_ptr != NULL) {
+                len = strlen(data_ptr);
+                bLen = hexStringToByteArrayEx((unsigned char*)data_ptr, len, (unsigned char **)&byteData);
+            }
         }
 
-        RFX_LOG_D(mLog_tag.c_str(), "session_id:%d, cla:%d, ins:%d,p1=%d,p2=%d,p3=%d,data=%s", session_id, cla, ins, p1, p2, p3, (data_ptr==NULL? "": data_ptr));
+        RFX_LOG_D(mLog_tag.c_str(), "session_id:%d, cla:%d, ins:%d,p1=%d,p2=%d,p3=%d,data=%s", session_id, cla, ins, p1, p2, p3, (byteData==NULL? "": byteData));
         ret = mipc_sim_extended_channel_generic_access_async(slot_id_to_mipc_sim_id(message->getSlotId()), mipc_sim_extended_channel_generic_access_cb,
-                (void*) message->getRilToken(), session_id, cla, ins, p1, p2, p3, (data_ptr==NULL? 0: strlen(data_ptr)), data_ptr);
+                (void*) message->getRilToken(), session_id, cla, ins, p1, p2, p3, bLen, byteData);
     }while(0);
 
     if(ret != MIPC_API_RESULT_SUCCESS) {
@@ -1823,6 +1842,9 @@
     if(data_ptr) {
         free(data_ptr);
     }
+    if (byteData) {
+        free(byteData);
+    }
     RFX_LOG_D(mLog_tag.c_str(), "%s done", __FUNCTION__);
 }
 
@@ -2072,3 +2094,34 @@
 
     RFX_LOG_D(mLog_tag.c_str(), "%s done", __FUNCTION__);
 }
+
+int RpSimController::hexStringToByteArrayEx(unsigned char* hexString,
+        int hexStringLen, unsigned char ** byte) {
+    int length = hexStringLen/2;
+    unsigned char* buffer = (unsigned char*)malloc((length + 1)*sizeof(char));
+    int i = 0;
+
+    if (NULL == buffer) {
+        RFX_LOG_E(mLog_tag.c_str(), "%s malloc return NULL.", __FUNCTION__);
+        return 0;
+    }
+    memset(buffer, 0, ((length + 1)*sizeof(char)));
+    for (i = 0 ; i < hexStringLen ; i += 2)
+    {
+        buffer[i / 2] = (unsigned char)((toByte(hexString[i]) << 4) | toByte(hexString[i+1]));
+    }
+
+    *byte = buffer;
+
+    return (hexStringLen/2);
+}
+
+int RpSimController::toByte(char c) {
+    if (c >= '0' && c <= '9') return (c - '0');
+    if (c >= 'A' && c <= 'F') return (c - 'A' + 10);
+    if (c >= 'a' && c <= 'f') return (c - 'a' + 10);
+
+    RFX_LOG_E(mLog_tag.c_str(), "%s toByte, Error: %c", __FUNCTION__, c);
+    return 0;
+}
+
diff --git a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.h b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.h
index eded6b6..7bb6892 100644
--- a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.h
+++ b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sim/RpSimController.h
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: MediaTekProprietary
 /*****************************************************************************
  *  Copyright Statement:
  *  --------------------
@@ -70,6 +71,10 @@
     int setChannelToClassByte(int cla, int channelNumber);
     void handleQueryEid(const android::sp<RfxMessage> &message);
     void handleQuerySimRetryCount(const android::sp<RfxMessage> &message);
+    int hexStringToByteArrayEx(unsigned char* hexString,
+        int hexStringLen, unsigned char ** byte);
+    int toByte(char c);
+
 };
 
 #endif /* SIM_RPSIMCONTROLLER_H_ */
diff --git a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sms/RpSmsController.cpp b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sms/RpSmsController.cpp
index 345ad4a..a4d93ea 100644
--- a/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sms/RpSmsController.cpp
+++ b/src/telephonyware/3.0/hardware/ril/fusion/libril/rilmipc/telephony/sms/RpSmsController.cpp
@@ -1157,27 +1157,27 @@
 
     int32_t count = 0;
     int32_t status = 0;
-    int32_t t = 0;
+    int32_t index = 0;
 
     Parcel *p = request->getParcel();
-    RFX_LOG_D(RFX_LOG_TAG, "enter0 p=%p\n",p);
     if(p != NULL) {
-        RFX_LOG_D(RFX_LOG_TAG, "enter1\n");
         status = p->readInt32 (&count);
         if (status != 0 || count <= 0) {
             RFX_LOG_D(RFX_LOG_TAG,"handleDeleteSMSOnSIMRequest readerror\n");
             return;
         }
-        RFX_LOG_D(RFX_LOG_TAG, "enter2\n");
-        status = p->readInt32(&t);
-        RFX_LOG_D(RFX_LOG_TAG, "enter3 t=%d\n",t);
+        status = p->readInt32(&index);
+        RFX_LOG_D(RFX_LOG_TAG, "handleDeleteSMSOnSIMRequest index=%d\n",index);
     }
-    mipc_sms_delete_async(slot_id_to_mipc_sim_id(request->getSlotId()), mipc_delete_sms_on_sim_cb, (void *)request->getRilToken(), (mipc_sms_flag_enum)MIPC_SMS_FLAG_INDEX,(uint16_t)t);
-#if 0
-    mipc_sms_delete_struct result_ptr;
-    result_ptr.result_code = MIPC_RESULT_SUCCESS;
-    mipc_delete_sms_on_sim_cb(MIPC_API_SIM0,&result_ptr,request->getRilToken());
-#endif
+
+    if (index > 0) {
+        mipc_sms_delete_async(slot_id_to_mipc_sim_id(request->getSlotId()), mipc_delete_sms_on_sim_cb, (void *)request->getRilToken(),
+                (mipc_sms_flag_enum)MIPC_SMS_FLAG_INDEX,(uint16_t)index);
+    } else {
+        RFX_LOG_D(RFX_LOG_TAG, "handleDeleteSMSOnSIMRequest delete all, index=%d\n", index);
+        mipc_sms_delete_async(slot_id_to_mipc_sim_id(request->getSlotId()), mipc_delete_sms_on_sim_cb, (void *)request->getRilToken(),
+                (mipc_sms_flag_enum)MIPC_SMS_FLAG_ALL,(uint16_t)0);
+    }
 }
 
 void mipc_get_smsc_address_cb(
@@ -1635,7 +1635,7 @@
 }
 
 void RpSmsController::handleReportSmsMemStatus(const sp<RfxMessage>& request) {
-    RFX_LOG_D(RFX_LOG_TAG, "handleReportSmsMemStatus with clientId: %d, with token: %d",
+    RFX_LOG_D(RFX_LOG_TAG, "[%s] with clientId: %d, with token: %d", __FUNCTION__,
         request->getClientId(), request->getToken());
     mipc_api_result_enum ret = MIPC_API_RESULT_FAIL;
     status_t status;
@@ -1649,17 +1649,25 @@
         }
         Parcel *p = request->getParcel();
         if(p == NULL) {
-            RFX_LOG_D(RFX_LOG_TAG, "handleGsmSetCbSmsCfg p has no data to transfer\n");
+            RFX_LOG_D(RFX_LOG_TAG, "[%s] p has no data to transfer\n", __FUNCTION__);
             break;
         }
-        RFX_LOG_D(RFX_LOG_TAG, "handleGsmCbSmsActivation p=%p\n",p);
+        RFX_LOG_D(RFX_LOG_TAG, "[%s] p=%p\n", __FUNCTION__, p);
 
+        // Read ints count
+        status = p->readInt32(&t);
+        if (status != android::NO_ERROR) {
+            break;
+        }
+
+        // Read available status
         status = p->readInt32(&t);
         if (status != android::NO_ERROR) {
             break;
         }
         avaiable = (int)t;
-        RFX_LOG_D(RFX_LOG_TAG, "Turn report SMS memory status %s", ((avaiable == 1)? "on" : "off"));
+
+        RFX_LOG_D(RFX_LOG_TAG, "[%s]Turn report SMS memory status %s", __FUNCTION__, ((avaiable == 1)? "on" : "off"));
 
         if (avaiable == 1 || avaiable == 0) {
             ret = mipc_set_host_mem_avaiable_async(slot_id_to_mipc_sim_id(request->getSlotId()), mipc_set_host_mem_avaiable_cb, (void *)request->getRilToken(), avaiable);
diff --git a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/include/api/mipc_sys_api.h b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/include/api/mipc_sys_api.h
index 56b47de..caaefad 100644
--- a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/include/api/mipc_sys_api.h
+++ b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/include/api/mipc_sys_api.h
@@ -1,3 +1,4 @@
+//SPDX-License-Identifier: MediaTekProprietary
 /*****************************************************************************
 *  Copyright Statement:
 *  --------------------
@@ -252,7 +253,7 @@
 } mipc_sys_adpclk_state_enum;
 
 #define MIPC_DEVICEID_MAX_LEN   (15)
-#define MIPC_FIRMWARE_LEN       (30)
+#define MIPC_FIRMWARE_LEN       (64)
 #define MIPC_HARDWAREWARE_LEN   (30)
 #define MIPC_MANUFACTURER_LEN   (32)
 #define MIPC_ESN_LEN   (8)
@@ -321,7 +322,7 @@
     /** @brief Manufacturer id */
     uint8_t manufacturer[MIPC_MANUFACTURER_LEN];
     /** @brief firmware id */
-    uint8_t firmware_info[MIPC_FIRMWARE_LEN];
+    uint8_t firmware_info[MIPC_FIRMWARE_LEN+1];
     /** @brief hardware id */
     uint8_t hardware_info[MIPC_HARDWAREWARE_LEN];
     /** @brief max activated contexts */
@@ -337,7 +338,7 @@
     /** @brief  meid */
     uint8_t meid[MIPC_MEID_LEN+1];
     /** @brief firmware custom id */
-    uint8_t firmware_custom_info[MIPC_FIRMWARE_LEN];
+    uint8_t firmware_custom_info[MIPC_FIRMWARE_LEN+1];
     //
     uint32_t data_sub_class;
 
diff --git a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_call_api.c b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_call_api.c
index 7d1b33a..518d855 100644
--- a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_call_api.c
+++ b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_call_api.c
@@ -401,7 +401,8 @@
             result_ptr->tons[i] = (uint32_t)mipc_msg_get_idx_uint32(msg_cnf_ptr, MIPC_CALL_GET_CALL_STATUS_CNF_T_TON, i, UINT32_MAX);
             val_ptr = mipc_msg_get_idx_ptr(msg_cnf_ptr, MIPC_CALL_GET_CALL_STATUS_CNF_T_NUMBER, i, &val_len);
             if (val_ptr) {
-                MEMCPY(result_ptr->numbers[i], val_ptr, (val_len)*sizeof(char));
+                MEMCPY(result_ptr->numbers[i], val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ?
+                        val_len : MIPC_MAX_CALL_NUMBER_LEN) * sizeof(char));
             }
             result_ptr->call_rats[i] = (mipc_call_rat_const_enum)mipc_msg_get_idx_uint32(msg_cnf_ptr, MIPC_CALL_GET_CALL_STATUS_CNF_T_RAT, i, UINT32_MAX);
             result_ptr->call_types[i] = (mipc_call_type_const_enum)mipc_msg_get_idx_uint32(msg_cnf_ptr, MIPC_CALL_GET_CALL_STATUS_CNF_T_TYPE, i, UINT32_MAX);
@@ -605,7 +606,8 @@
         if (result_ptr->count) {
             val_ptr = mipc_msg_get_val_ptr(msg_cnf_ptr, MIPC_CALL_GET_CONFERENCE_INFO_CNF_T_DIRECTION , &val_len);
             if (NULL == val_ptr) break;
-            MEMCPY(result_ptr->directions, val_ptr, (result_ptr->count)*sizeof(uint32_t));
+            MEMCPY(result_ptr->directions, val_ptr, (result_ptr->count < MIPC_MAX_CALL_CONFERENCE_PARTICIPANT_NUM ?
+                    result_ptr->count : MIPC_MAX_CALL_CONFERENCE_PARTICIPANT_NUM) * sizeof(mipc_call_direction_const_enum));
 
             int tag = 0;
             for(uint32_t i = 0 ; i < result_ptr->count ; i++ ) {
@@ -614,7 +616,8 @@
                     tag = 1;
                     break;
                 }
-                MEMCPY(result_ptr->participant_numbers[i], val_ptr, (val_len)*sizeof(char));
+                MEMCPY(result_ptr->participant_numbers[i], val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ?
+                        val_len : MIPC_MAX_CALL_NUMBER_LEN) * sizeof(char));
             }
             if(tag) {
                 break;
@@ -627,7 +630,8 @@
                     tag = 1;
                     break;
                 }
-                MEMCPY(result_ptr->participant_names[i], val_ptr, (val_len)*sizeof(char));
+                MEMCPY(result_ptr->participant_names[i], val_ptr, (val_len < MIPC_MAX_CALL_NAME_LEN ?
+                        val_len : MIPC_MAX_CALL_NAME_LEN) * sizeof(char));
             }
             if(tag) {
                 break;
@@ -635,7 +639,8 @@
 
             val_ptr = mipc_msg_get_val_ptr(msg_cnf_ptr, MIPC_CALL_GET_CONFERENCE_INFO_CNF_T_PARTICIPANT_STATUS, &val_len);
             if (NULL == val_ptr) break;
-            MEMCPY(result_ptr->conf_participant_status, val_ptr, (result_ptr->count)*sizeof(uint32_t));
+            MEMCPY(result_ptr->conf_participant_status, val_ptr, (result_ptr->count < MIPC_MAX_CALL_CONFERENCE_PARTICIPANT_NUM ?
+                    result_ptr->count : MIPC_MAX_CALL_CONFERENCE_PARTICIPANT_NUM) * sizeof(mipc_conf_participant_status_const_enum));
         }
         result = MIPC_API_RESULT_SUCCESS;
     } while (0);
@@ -728,7 +733,7 @@
         result_ptr->reason = (uint32_t)(*((uint32_t*)val_ptr));
         val_ptr = mipc_msg_get_val_ptr(msg_cnf_ptr, MIPC_CALL_GET_FINISH_REASON_CNF_T_REASON_STR , &val_len);
         if (NULL == val_ptr) break;
-        MEMCPY(result_ptr->reason_str, val_ptr, (val_len<MIPC_MAX_CALL_FINISH_REASON_LEN ? val_len:MIPC_MAX_CALL_FINISH_REASON_LEN));
+        MEMCPY(result_ptr->reason_str, val_ptr, (val_len < MIPC_MAX_CALL_FINISH_REASON_LEN ? val_len : MIPC_MAX_CALL_FINISH_REASON_LEN));
         result = MIPC_API_RESULT_SUCCESS;
     } while (0);
 
@@ -898,7 +903,8 @@
         if (result_ptr->info_count) {
             val_ptr = mipc_msg_get_val_ptr(msg_cnf_ptr, MIPC_CALL_GET_ECC_LIST_CNF_T_INFO_LIST, &val_len);
             if (NULL == val_ptr) break;
-            MEMCPY(result_ptr->info_lists, val_ptr, (result_ptr->info_count)*sizeof(mipc_ecc_info_struct4));
+            MEMCPY(result_ptr->info_lists, val_ptr, (result_ptr->info_count < MIPC_MAX_CALL_ECC_LIST_RECORD_NUM ?
+                    result_ptr->info_count : MIPC_MAX_CALL_ECC_LIST_RECORD_NUM) * sizeof(mipc_ecc_info_struct4));
         }
         result = MIPC_API_RESULT_SUCCESS;
     } while (0);
@@ -1306,7 +1312,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_STATUS_IND_T_TON, NULL)) == NULL) break;
         result_ptr->ton = (uint32_t) * ((uint32_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_STATUS_IND_T_NUMBER, &val_len)) == NULL) break;
-        MEMCPY(result_ptr->number, val_ptr, val_len);
+        MEMCPY(result_ptr->number, val_ptr, val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len : MIPC_MAX_CALL_NUMBER_LEN);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_STATUS_IND_T_TYPE, NULL)) == NULL) break;
         result_ptr->type = (mipc_call_type_const_enum) * ((uint32_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_STATUS_IND_T_DETAIL_INFO, &val_len)) == NULL) break;
@@ -1384,9 +1390,9 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_EVENT_IND_T_REDIRECT_NUMBER, &val_len)) == NULL) {
             (result_ptr->redirect_number)[0] = 0;
         } else {
-            MEMCPY(result_ptr->redirect_number, val_ptr, val_len);
+            MEMCPY(result_ptr->redirect_number, val_ptr, val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len : MIPC_MAX_CALL_NUMBER_LEN);
         }
-        MEMCPY(result_ptr->redirect_number, val_ptr, val_len);
+        MEMCPY(result_ptr->redirect_number, val_ptr, val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len : MIPC_MAX_CALL_NUMBER_LEN);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_EVENT_IND_T_AUDIO_CODEC, NULL)) == NULL) {
             result_ptr->audio_codec = UINT16_MAX;
         } else {
@@ -1557,7 +1563,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_SIP_IND_T_REASON_TEXT, &val_len)) == NULL) {
             result_ptr->reason_text[0] = 0;
         } else {
-            MEMCPY(result_ptr->reason_text, val_ptr, (val_len < MIPC_MAX_SIP_REASON_TEXT_LEN ? val_len: MIPC_MAX_SIP_REASON_TEXT_LEN));
+            MEMCPY(result_ptr->reason_text, val_ptr, (val_len < MIPC_MAX_SIP_REASON_TEXT_LEN ? val_len : MIPC_MAX_SIP_REASON_TEXT_LEN));
         }
 
         api_error = 0;
@@ -1659,7 +1665,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_IMS_EVENT_PACKAGE_IND_T_TYPE, NULL)) == NULL) break;
         result_ptr->type = (mipc_ims_event_package_type_const_enum) * ((uint32_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_IMS_EVENT_PACKAGE_IND_T_DATA, &val_len)) == NULL) break;
-        MEMCPY(result_ptr->data, val_ptr, (val_len < MIPC_MAX_IMS_EVENT_PACKAGE_DATA_LEN ? val_len:MIPC_MAX_IMS_EVENT_PACKAGE_DATA_LEN));
+        MEMCPY(result_ptr->data, val_ptr, (val_len < MIPC_MAX_IMS_EVENT_PACKAGE_DATA_LEN ? val_len : MIPC_MAX_IMS_EVENT_PACKAGE_DATA_LEN));
         api_error = 0;
     } while (0);
 
@@ -1771,7 +1777,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_SS_IND_T_NUMBER, &val_len)) == NULL) {
             (result_ptr->number)[0]=0;
         } else {
-            MEMCPY(result_ptr->number, val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len:MIPC_MAX_CALL_NUMBER_LEN));
+            MEMCPY(result_ptr->number, val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len : MIPC_MAX_CALL_NUMBER_LEN));
         }
 
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_SS_IND_T_TOA, NULL)) == NULL) {
@@ -1783,7 +1789,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_SS_IND_T_SUBADDR, &val_len)) == NULL) {
             (result_ptr->subaddr)[0] = 0;
         } else {
-            MEMCPY(result_ptr->subaddr, val_ptr, (val_len < MIPC_MAX_CALL_SS_SUBADDR_LEN ? val_len:MIPC_MAX_CALL_SS_SUBADDR_LEN));
+            MEMCPY(result_ptr->subaddr, val_ptr, (val_len < MIPC_MAX_CALL_SS_SUBADDR_LEN ? val_len : MIPC_MAX_CALL_SS_SUBADDR_LEN));
         }
 
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_SS_IND_T_SATYPE, NULL)) == NULL) {
@@ -1889,7 +1895,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_CRSS_TYPE, NULL)) == NULL) break;
         result_ptr->crss_type = (mipc_crss_type_const_enum) * ((uint8_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_NUMBER, &val_len)) == NULL) break;
-        MEMCPY(result_ptr->number, val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len:MIPC_MAX_CALL_NUMBER_LEN));
+        MEMCPY(result_ptr->number, val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len : MIPC_MAX_CALL_NUMBER_LEN));
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_CALL_NUMBER_TYPE, NULL)) == NULL) break;
         result_ptr->call_number_type = (mipc_number_type_const_enum) * ((uint8_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_NUMBER_PRESENTATION, NULL)) == NULL) {
@@ -1900,7 +1906,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_SUB_ADDRESS, &val_len)) == NULL) {
             (result_ptr->sub_address)[0]=0;
         } else {
-            MEMCPY(result_ptr->sub_address, val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len:MIPC_MAX_CALL_NUMBER_LEN));
+            MEMCPY(result_ptr->sub_address, val_ptr, (val_len < MIPC_MAX_SUB_ADDRESS_LEN ? val_len : MIPC_MAX_SUB_ADDRESS_LEN));
         }
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_SA_TYPE, NULL)) == NULL) {
             result_ptr->sa_type = 0;
@@ -1910,7 +1916,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_CRSS_IND_T_ALPHAID, &val_len)) == NULL) {
             (result_ptr->alphaid)[0]=0;
         } else {
-            MEMCPY(result_ptr->alphaid, val_ptr, (val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_len:MIPC_MAX_CALL_NUMBER_LEN));
+            MEMCPY(result_ptr->alphaid, val_ptr, (val_len < MIPC_MAX_SUB_ADDRESS_LEN ? val_len : MIPC_MAX_SUB_ADDRESS_LEN));
         }
         api_error = 0;
     } while (0);
@@ -1962,7 +1968,7 @@
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_APPROVE_INCOMING_CMD_T_CALLID, NULL)) == NULL) break;
         result_ptr->callid = (uint32_t) * ((uint32_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_APPROVE_INCOMING_CMD_T_NUMBER, &val_len)) == NULL) break;
-        MEMCPY(result_ptr->number, val_ptr, val_len);
+        MEMCPY(result_ptr->number, val_ptr, val_len < MIPC_MAX_CALL_NUMBER_LEN ? val_ptr : MIPC_MAX_CALL_NUMBER_LEN);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_APPROVE_INCOMING_CMD_T_TOA, NULL)) == NULL) break;
         result_ptr->toa = (uint32_t) * ((uint32_t *)val_ptr);
         if ((val_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_CALL_APPROVE_INCOMING_CMD_T_SEQ_NO, NULL)) == NULL) break;
diff --git a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_ecall_api.c b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_ecall_api.c
index 7c34a20..ba930ca 100644
--- a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_ecall_api.c
+++ b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_ecall_api.c
@@ -607,7 +607,7 @@
     if (NULL == cb) {
         return MIPC_API_RESULT_FAIL;
     }
-    return mipc_ecall_ivs_set_test_addr(cb, cb_priv_ptr, sim_ps_id, reconf_address, address_type, NULL);
+    return mipc_ecall_ivs_set_reconf_addr(cb, cb_priv_ptr, sim_ps_id, reconf_address, address_type, NULL);
 }
 
 static mipc_api_result_enum mipc_ecall_ivs_set_addr_pri_cnf_decode(mipc_msg_t *msg_cnf_ptr, mipc_ecall_ivs_set_addr_pri_struct *result_ptr)
diff --git a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sms_api.c b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sms_api.c
index 4b7be67..bf08283 100644
--- a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sms_api.c
+++ b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sms_api.c
@@ -511,7 +511,11 @@
     mipc_api_result_enum ret;
 
     mipc_msg_add_tlv_uint8(msg_req_ptr, MIPC_SMS_DELETE_REQ_T_FLAG, flag);
-    mipc_msg_add_tlv_uint16(msg_req_ptr, MIPC_SMS_DELETE_REQ_T_MESSAGE_INDEX, message_index);
+    if (message_index > 0) {
+	    mipc_msg_add_tlv_uint16(msg_req_ptr, MIPC_SMS_DELETE_REQ_T_MESSAGE_INDEX, message_index);
+    }
+
+    mtkLogD(LOG_TAG, "[%s] flag=%d, message_index=%d", __FUNCTION__, flag, message_index);
 
     if (cb) {
         mipc_msg_async_api(msg_req_ptr, (void *)mipc_sms_delete_cb, (MIPC_API_CB)cb, cb_priv_ptr);
diff --git a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sys_api.c b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sys_api.c
index 788fce6..6daedfd 100644
--- a/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sys_api.c
+++ b/src/telephonyware/3.0/hardware/ril/platformlib/libmipc/lib/src/api/mipc_sys_api.c
@@ -1,3 +1,4 @@
+//SPDX-License-Identifier: MediaTekProprietary
 /*****************************************************************************
 *  Copyright Statement:
 *  --------------------
@@ -697,25 +698,28 @@
 
         t_result_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_SYS_GET_INFO_CNF_T_DEVICE_ID, &t_systmp_len);
         if (NULL == t_result_ptr) {
-            mtkLogD(LOG_TAG, "cur ptr null\n");
-            break;
+            mtkLogD(LOG_TAG, "device_id - cur ptr null\n");
+        } else {
+            MEMCPY(result_ptr->device_id, t_result_ptr, (t_systmp_len > 15) ? 15 : t_systmp_len);
+            mtkLogD(LOG_TAG, "t_result_ptr = %d \n", *((uint32_t*)t_result_ptr));
+            mtkLogD(LOG_TAG, "device_id = %d \n", result_ptr->device_id[0]);
         }
-        MEMCPY(result_ptr->device_id, t_result_ptr, (t_systmp_len > 15) ? 15 : t_systmp_len);
-        mtkLogD(LOG_TAG, "t_result_ptr = %d \n", *((uint32_t*)t_result_ptr));
-        mtkLogD(LOG_TAG, "device_id = %d \n", result_ptr->device_id[0]);
 
         t_result_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_SYS_GET_INFO_CNF_T_MANUFCTR, &t_systmp_len);
         if (NULL == t_result_ptr) {
-            mtkLogD(LOG_TAG, "cur ptr null\n");
+            mtkLogD(LOG_TAG, "manufacturer - cur ptr null\n");
             break;
         }
         MEMCPY(result_ptr->manufacturer, t_result_ptr, (t_systmp_len > 32) ? 32 : t_systmp_len);
+
         t_result_ptr = mipc_msg_get_val_str(msg_ptr, MIPC_SYS_GET_INFO_CNF_T_FIRMWARE, &t_systmp_len);
         if (NULL == t_result_ptr) {
-            mtkLogD(LOG_TAG, "cur ptr null\n");
+            mtkLogD(LOG_TAG, "firmware_info - cur ptr null\n");
             break;
         }
-        MEMCPY(result_ptr->firmware_info, t_result_ptr, (t_systmp_len > 30) ? 30 : t_systmp_len);
+        mtkLogD(LOG_TAG, "MIPC_SYS_GET_INFO_CNF_T_FIRMWARE: %s\n", t_result_ptr);
+        MEMCPY(result_ptr->firmware_info, t_result_ptr, (t_systmp_len > MIPC_FIRMWARE_LEN) ? MIPC_FIRMWARE_LEN : t_systmp_len);
+
         t_result_ptr = mipc_msg_get_val_ptr(msg_ptr, MIPC_SYS_GET_INFO_CNF_T_HARDWARE, &t_systmp_len);
         if (NULL == t_result_ptr) {
             mtkLogD(LOG_TAG, "cur ptr null\n");
diff --git a/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/framework/include/RfxStatusDefs.h b/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/framework/include/RfxStatusDefs.h
index d6dc835..7a538a7 100644
--- a/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/framework/include/RfxStatusDefs.h
+++ b/src/telephonyware/3.0/libvendor-ril/mtk-rilproxy/framework/include/RfxStatusDefs.h
@@ -1,3 +1,4 @@
+//SPDX-License-Identifier: MediaTekProprietary
 /* Copyright Statement:
  *
  * This software/firmware and related documentation ("MediaTek Software") are
@@ -432,8 +433,8 @@
         RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_CDMA_FILE_READY, RfxVariant(false)),               \
         RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_CT3G_DUALMODE_CARD, RfxVariant(false)),               \
         RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_SERVICE_STATE, RfxVariant()),                 \
-        RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_VOICE_TYPE, RfxVariant()),                    \
-        RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_DATA_TYPE, RfxVariant()),                     \
+        RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_VOICE_TYPE, RfxVariant(0)),                    \
+        RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_DATA_TYPE, RfxVariant(0)),                     \
         RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_MODEM_SIM_TASK_READY, RfxVariant(false)),          \
         RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_SUGGESTED_RADIO_CAPABILITY, RfxVariant()),    \
         RFX_STATUS_DEFAULT_VALUE_ENTRY(RFX_STATUS_KEY_RADIO_CAPABILITY, RfxVariant(0)),              \
diff --git a/src/telephonyware/3.0/mipc/mt2735_ivt_nlwg_wide_temp_custom/mipc.release.tar.gz b/src/telephonyware/3.0/mipc/mt2735_ivt_nlwg_wide_temp_custom/mipc.release.tar.gz
index 268ff16..4dc9eb0 100644
--- a/src/telephonyware/3.0/mipc/mt2735_ivt_nlwg_wide_temp_custom/mipc.release.tar.gz
+++ b/src/telephonyware/3.0/mipc/mt2735_ivt_nlwg_wide_temp_custom/mipc.release.tar.gz
Binary files differ