touch: enable goodix_brl driver

Enable new Goodix touch driver; add notifier from drm display.

Change-Id: Idffa17e7cb41b1685753d58184a0fe6c8f71d2ac

Android.mk

@@ -35,4 +35,15 @@ LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
 include $(DLKM_DIR)/Build_external_kernelmodule.mk
 ###########################################################
 
+###########################################################
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES   := $(wildcard $(LOCAL_PATH)/**/*) $(wildcard $(LOCAL_PATH)/*)
+LOCAL_MODULE              := goodix_ts.ko
+LOCAL_MODULE_KBUILD_NAME  := goodix_ts.ko
+LOCAL_MODULE_TAGS         := optional
+#LOCAL_MODULE_DEBUG_ENABLE := true
+LOCAL_MODULE_PATH         := $(KERNEL_MODULES_OUT)
+include $(DLKM_DIR)/Build_external_kernelmodule.mk
+###########################################################
+
 endif # DLKM check

Kbuild

@@ -86,4 +86,22 @@ ifeq ($(CONFIG_TOUCHSCREEN_NT36XXX_I2C), y)
 	obj-$(CONFIG_MSM_TOUCH) += nt36xxx-i2c.o
 endif
 
+ifeq ($(CONFIG_TOUCHSCREEN_GOODIX_BRL), y)
+	LINUX_INC += -include $(TOUCH_ROOT)/goodix_berlin_driver/goodix_ts_core.h
+
+	goodix_ts-y := \
+		 ./goodix_berlin_driver/goodix_ts_core.o \
+		 ./goodix_berlin_driver/goodix_brl_hw.o \
+		 ./goodix_berlin_driver/goodix_cfg_bin.o \
+		 ./goodix_berlin_driver/goodix_ts_utils.o \
+		 ./goodix_berlin_driver/goodix_brl_fwupdate.o \
+		 ./goodix_berlin_driver/goodix_ts_tools.o \
+		 ./goodix_berlin_driver/goodix_ts_gesture.o \
+		 ./goodix_berlin_driver/goodix_ts_inspect.o \
+		 ./goodix_berlin_driver/goodix_brl_spi.o \
+		 ./goodix_berlin_driver/goodix_brl_i2c.o
+
+	obj-$(CONFIG_MSM_TOUCH) += goodix_ts.o
+endif
+
 CDEFINES += -DBUILD_TIMESTAMP=\"$(shell date -u +'%Y-%m-%dT%H:%M:%SZ')\"

config/gki_kalamatouch.conf

@@ -1,2 +1,3 @@
 export CONFIG_TOUCHSCREEN_NT36XXX_I2C=y
+export CONFIG_TOUCHSCREEN_GOODIX_BRL=y
 export CONFIG_MSM_TOUCH=m

config/gki_kalamatouchconf.h

@@ -4,4 +4,5 @@
  */
 
 #define CONFIG_TOUCHSCREEN_NT36XXX_I2C 1
+#define CONFIG_TOUCHSCREEN_GOODIX_BRL 1
 

goodix_berlin_driver/goodix_ts_core.c

@@ -19,6 +19,7 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/uaccess.h>
+#include <linux/soc/qcom/panel_event_notifier.h>
 
 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 38)
 #include <linux/input/mt.h>
@@ -30,6 +31,32 @@
 #define GOODIX_DEFAULT_CFG_NAME		"goodix_cfg_group.cfg"
 #define GOOIDX_INPUT_PHYS			"goodix_ts/input0"
 
+#if defined(CONFIG_DRM)
+static struct drm_panel *active_panel;
+static void goodix_panel_notifier_callback(enum panel_event_notifier_tag tag,
+		 struct panel_event_notification *event, void *client_data);
+
+static void goodix_register_for_panel_events(struct device_node *dp,
+					struct goodix_ts_core *cd)
+{
+	void *cookie;
+
+	cookie = panel_event_notifier_register(PANEL_EVENT_NOTIFICATION_PRIMARY,
+			PANEL_EVENT_NOTIFIER_CLIENT_PRIMARY_TOUCH, active_panel,
+			&goodix_panel_notifier_callback, cd);
+	if (!cookie) {
+		pr_err("Failed to register for panel events\n");
+		return;
+	}
+
+	ts_debug("registered for panel notifications panel: 0x%x\n",
+			active_panel);
+
+	cd->notifier_cookie = cookie;
+}
+
+#endif
+
 struct goodix_module goodix_modules;
 int core_module_prob_sate = CORE_MODULE_UNPROBED;
 
@@ -1821,25 +1848,51 @@ out:
 	return 0;
 }
 
-/* goodix FB test */
-/*
-void goodix_fb_ext_ctrl(int suspend)
+#if defined(CONFIG_DRM)
+
+static void goodix_panel_notifier_callback(enum panel_event_notifier_tag tag,
+		 struct panel_event_notification *notification, void *client_data)
 {
-	struct goodix_ts_core *cd = goodix_modules.core_data;
+	struct goodix_ts_core *core_data = client_data;
 
-	if (!cd)
+	if (!notification) {
+		pr_err("Invalid notification\n");
 		return;
+	}
 
-	if (suspend)
-		goodix_ts_suspend(cd);
-	else
-		goodix_ts_resume(cd);
+	ts_debug("Notification type:%d, early_trigger:%d",
+			notification->notif_type,
+			notification->notif_data.early_trigger);
+	switch (notification->notif_type) {
+	case DRM_PANEL_EVENT_UNBLANK:
+		if (!notification->notif_data.early_trigger)
+			goodix_ts_resume(core_data);
+		break;
+
+	case DRM_PANEL_EVENT_BLANK:
+		if (notification->notif_data.early_trigger)
+			goodix_ts_suspend(core_data);
+		break;
+
+	case DRM_PANEL_EVENT_BLANK_LP:
+		ts_debug("received lp event\n");
+		break;
+
+	case DRM_PANEL_EVENT_FPS_CHANGE:
+		ts_debug("Received fps change old fps:%d new fps:%d\n",
+				notification->notif_data.old_fps,
+				notification->notif_data.new_fps);
+		break;
+
+	default:
+		ts_debug("notification serviced :%d\n",
+				notification->notif_type);
+		break;
+	}
 }
-EXPORT_SYMBOL(goodix_fb_ext_ctrl);
-*/
 
+#elif IS_ENABLED(CONFIG_FB)
 
-#if IS_ENABLED(CONFIG_FB)
 /**
  * goodix_ts_fb_notifier_callback - Framebuffer notifier callback
  * Called by kernel during framebuffer blanck/unblank phrase
@@ -1868,8 +1921,9 @@ int goodix_ts_fb_notifier_callback(struct notifier_block *self,
 }
 #endif
 
-#if IS_ENABLED(CONFIG_PM)
-#if !IS_ENABLED(CONFIG_FB) && !IS_ENABLED(CONFIG_HAS_EARLYSUSPEND)
+
+#if defined(CONFIG_PM) && !defined(CONFIG_DRM)
+#if !defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND)
 /**
  * goodix_ts_pm_suspend - PM suspend function
  * Called by kernel during system suspend phrase
@@ -1952,7 +2006,11 @@ int goodix_ts_stage2_init(struct goodix_ts_core *cd)
 	}
 	ts_info("success register irq");
 
-#if IS_ENABLED(CONFIG_FB)
+#if defined(CONFIG_DRM)
+	if (cd->touch_environment && !strcmp(cd->touch_environment, "pvm"))
+		goodix_register_for_panel_events(cd->bus->dev->of_node, cd);
+
+#elif defined(CONFIG_FB)
 	cd->fb_notifier.notifier_call = goodix_ts_fb_notifier_callback;
 	if (fb_register_client(&cd->fb_notifier))
 		ts_err("Failed to register fb notifier client:%d", ret);
@@ -2107,6 +2165,77 @@ static int goodix_start_later_init(struct goodix_ts_core *ts_core)
 	return 0;
 }
 
+#if defined(CONFIG_DRM)
+static int goodix_check_dt(struct device_node *np)
+{
+	int i;
+	int count;
+	struct device_node *node;
+	struct drm_panel *panel;
+
+	count = of_count_phandle_with_args(np, "panel", NULL);
+	if (count <= 0)
+		return 0;
+
+	for (i = 0; i < count; i++) {
+		node = of_parse_phandle(np, "panel", i);
+		panel = of_drm_find_panel(node);
+		of_node_put(node);
+		if (!IS_ERR(panel)) {
+			active_panel = panel;
+			return 0;
+		}
+	}
+
+	return PTR_ERR(panel);
+}
+
+static int goodix_check_default_tp(struct device_node *dt, const char *prop)
+{
+	const char **active_tp = NULL;
+	int count, tmp, score = 0;
+	const char *active;
+	int ret, i;
+
+	count = of_property_count_strings(dt->parent, prop);
+	if (count <= 0 || count > 3)
+		return -ENODEV;
+
+	active_tp = kcalloc(count, sizeof(char *),  GFP_KERNEL);
+	if (!active_tp) {
+		ts_err("FTS alloc failed\n");
+		return -ENOMEM;
+	}
+
+	ret = of_property_read_string_array(dt->parent, prop,
+			active_tp, count);
+	if (ret < 0) {
+		ts_err("fail to read %s %d\n", prop, ret);
+		ret = -ENODEV;
+		goto out;
+	}
+
+	for (i = 0; i < count; i++) {
+		active = active_tp[i];
+		if (active != NULL) {
+			tmp = of_device_is_compatible(dt, active);
+			if (tmp > 0)
+				score++;
+		}
+	}
+
+	if (score <= 0) {
+		ts_err("not match this driver\n");
+		ret = -ENODEV;
+		goto out;
+	}
+	ret = 0;
+out:
+	kfree(active_tp);
+	return ret;
+}
+
+#endif
 /**
  * goodix_ts_probe - called by kernel when Goodix touch
  *  platform driver is added.
@@ -2116,8 +2245,9 @@ static int goodix_ts_probe(struct platform_device *pdev)
 	struct goodix_ts_core *core_data = NULL;
 	struct goodix_bus_interface *bus_interface;
 	int ret;
+	struct device_node *node;
 
-	ts_info("IN");
+	ts_info("goodix_ts_probe IN");
 
 	bus_interface = pdev->dev.platform_data;
 	if (!bus_interface) {
@@ -2125,6 +2255,22 @@ static int goodix_ts_probe(struct platform_device *pdev)
 		core_module_prob_sate = CORE_MODULE_PROB_FAILED;
 		return -ENODEV;
 	}
+	node = bus_interface->dev->of_node;
+
+#if defined(CONFIG_DRM)
+	ret = goodix_check_dt(node);
+	if (ret == -EPROBE_DEFER)
+		return ret;
+
+	if (ret) {
+		if (!goodix_check_default_tp(node, "qcom,touch-active"))
+			ret = -EPROBE_DEFER;
+		else
+			ret = -ENODEV;
+
+		return ret;
+	}
+#endif
 
 	core_data = devm_kzalloc(&pdev->dev,
 			sizeof(struct goodix_ts_core), GFP_KERNEL);
@@ -2135,8 +2281,7 @@ static int goodix_ts_probe(struct platform_device *pdev)
 
 	if (IS_ENABLED(CONFIG_OF) && bus_interface->dev->of_node) {
 		/* parse devicetree property */
-		ret = goodix_parse_dt(bus_interface->dev->of_node,
-					&core_data->board_data);
+		ret = goodix_parse_dt(node, &core_data->board_data);
 		if (ret) {
 			ts_err("failed parse device info form dts, %d", ret);
 			return -EINVAL;
@@ -2214,7 +2359,11 @@ static int goodix_ts_remove(struct platform_device *pdev)
 		gesture_module_exit();
 		inspect_module_exit();
 		hw_ops->irq_enable(core_data, false);
-	#if IS_ENABLED(CONFIG_FB)
+
+	#if defined(CONFIG_DRM)
+		if (core_data->notifier_cookie)
+			panel_event_notifier_unregister(core_data->notifier_cookie);
+	#elif IS_ENABLED(CONFIG_FB)
 		fb_unregister_client(&core_data->fb_notifier);
 	#endif
 		core_module_prob_sate = CORE_MODULE_REMOVED;
@@ -2233,9 +2382,9 @@ static int goodix_ts_remove(struct platform_device *pdev)
 	return 0;
 }
 
-#if IS_ENABLED(CONFIG_PM)
+#if defined(CONFIG_PM) && !defined(CONFIG_DRM)
 static const struct dev_pm_ops dev_pm_ops = {
-#if !IS_ENABLED(CONFIG_FB) && !IS_ENABLED(CONFIG_HAS_EARLYSUSPEND)
+#if !defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND)
 	.suspend = goodix_ts_pm_suspend,
 	.resume = goodix_ts_pm_resume,
 #endif
@@ -2252,7 +2401,7 @@ static struct platform_driver goodix_ts_driver = {
 	.driver = {
 		.name = GOODIX_CORE_DRIVER_NAME,
 		.owner = THIS_MODULE,
-#if IS_ENABLED(CONFIG_PM)
+#if defined(CONFIG_PM) && !defined(CONFIG_DRM)
 		.pm = &dev_pm_ops,
 #endif
 	},
@@ -2263,14 +2412,12 @@ static struct platform_driver goodix_ts_driver = {
 
 static int __init goodix_ts_core_init(void)
 {
-	int ret;
+	int ret = 0;
 
 	ts_info("Core layer init:%s", GOODIX_DRIVER_VERSION);
-#ifdef CONFIG_TOUCHSCREEN_GOODIX_BRL_SPI
+
 	ret = goodix_spi_bus_init();
-#else
-	ret = goodix_i2c_bus_init();
-#endif
+	ret |= goodix_i2c_bus_init();
 	if (ret) {
 		ts_err("failed add bus driver");
 		return ret;
@@ -2282,11 +2429,10 @@ static void __exit goodix_ts_core_exit(void)
 {
 	ts_info("Core layer exit");
 	platform_driver_unregister(&goodix_ts_driver);
-#ifdef CONFIG_TOUCHSCREEN_GOODIX_BRL_SPI
+
 	goodix_spi_bus_exit();
-#else
+
 	goodix_i2c_bus_exit();
-#endif
 }
 
 late_initcall(goodix_ts_core_init);

goodix_berlin_driver/goodix_ts_core.h

@@ -500,9 +500,28 @@ struct goodix_ts_core {
 	struct notifier_block ts_notifier;
 	struct goodix_ts_esd ts_esd;
 
-#if IS_ENABLED(CONFIG_FB)
+#if defined(CONFIG_DRM)
+	struct notifier_block fb_notifier;
+	void *notifier_cookie;
+	const char *touch_environment;
+#elif defined(CONFIG_FB)
 	struct notifier_block fb_notifier;
 #endif
+
+#ifdef CONFIG_GOODIX_TRUSTED_TOUCH
+	struct trusted_touch_vm_info *vm_info;
+	struct mutex fts_clk_io_ctrl_mutex;
+	struct completion trusted_touch_powerdown;
+	struct clk *core_clk;
+	struct clk *iface_clk;
+	atomic_t trusted_touch_initialized;
+	atomic_t trusted_touch_enabled;
+	atomic_t trusted_touch_transition;
+	atomic_t trusted_touch_event;
+	atomic_t trusted_touch_abort_status;
+	atomic_t delayed_vm_probe_pending;
+	atomic_t trusted_touch_mode;
+#endif
 };
 
 /* external module structures */

touch_driver_board.mk

@@ -1,6 +1,7 @@
 
 ifneq ($(TARGET_BOARD_AUTO),true)
 	ifeq ($(call is-board-platform-in-list,$(TARGET_BOARD_PLATFORM)),true)
-		BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/nt36xxx-i2c.ko
+		BOARD_VENDOR_KERNEL_MODULES += $(KERNEL_MODULES_OUT)/nt36xxx-i2c.ko \
+			$(KERNEL_MODULES_OUT)/goodix_ts.ko
 	endif
 endif

touch_driver_product.mk

@@ -1,2 +1,3 @@
 
-PRODUCT_PACKAGES += $(KERNEL_MODULES_OUT)/nt36xxx-i2c.ko
+PRODUCT_PACKAGES += $(KERNEL_MODULES_OUT)/nt36xxx-i2c.ko \
+	$(KERNEL_MODULES_OUT)/goodix_ts.ko