Merge branch 'vendor'

Author: usertam

arch/arm64/boot/dts/vendor

@@ -1 +1 @@
-../../../../vendor/qcom/proprietary/devicetree-4.19
+../../../../../../vendor/qcom/proprietary/devicetree-4.19

arch/arm64/configs/vendor/gta4lwifi_eur_open_defconfig

@@ -1896,6 +1896,7 @@ CONFIG_INPUT_EVDEV=y
 # CONFIG_INPUT_EVBUG is not set
 # CONFIG_INPUT_KEYRESET is not set
 # CONFIG_INPUT_KEYCOMBO is not set
+CONFIG_SEC_INPUT_BOOSTER=y
 
 #
 # Input Device Drivers

drivers/input/Kconfig

@@ -151,6 +151,7 @@ config INPUT_JOYDEV
 
 config INPUT_EVDEV
 	tristate "Event interface"
+	select SEC_INPUT_BOOSTER
 	help
 	  Say Y here if you want your input device events be accessible
 	  under char device 13:64+ - /dev/input/eventX in a generic way.
@@ -197,6 +198,15 @@ config INPUT_KEYCOMBO
 	---help---
 	  Say Y here if you want to take action when some keys are pressed;
 
+config SEC_INPUT_BOOSTER
+	bool "SEC INPUT BOOSTER"
+	depends on INPUT_EVDEV
+	default y
+	help
+	  Say Y here if you need to enable Input Booster.
+
+	  It's triggered in evdev module.
+
 comment "Input Device Drivers"
 
 source "drivers/input/keyboard/Kconfig"

drivers/input/Makefile

@@ -17,6 +17,8 @@ obj-$(CONFIG_INPUT_LEDS)	+= input-leds.o
 obj-$(CONFIG_INPUT_MOUSEDEV)	+= mousedev.o
 obj-$(CONFIG_INPUT_JOYDEV)	+= joydev.o
 obj-$(CONFIG_INPUT_EVDEV)	+= evdev.o
+obj-$(CONFIG_SEC_INPUT_BOOSTER)	+= input_booster.o
+obj-$(CONFIG_ARCH_QCOM)	+= input_booster_qc.o
 obj-$(CONFIG_INPUT_EVBUG)	+= evbug.o
 
 obj-$(CONFIG_INPUT_KEYBOARD)	+= keyboard/

drivers/input/evdev.c

@@ -53,9 +53,18 @@ struct evdev_client {
 	bool revoked;
 	unsigned long *evmasks[EV_CNT];
 	unsigned int bufsize;
+#ifdef CONFIG_SEC_INPUT_BOOSTER
+	int device_type;
+	int touch_slot_cnt;
+	int ev_cnt;
+#endif
 	struct input_event buffer[];
 };
 
+#ifdef CONFIG_SEC_INPUT_BOOSTER
+#include <linux/input/input_booster.h>
+#endif
+
 static size_t evdev_get_mask_cnt(unsigned int type)
 {
 	static const size_t counts[EV_CNT] = {
@@ -214,9 +223,281 @@ static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)
 	return 0;
 }
 
+#ifdef CONFIG_SEC_INPUT_BOOSTER
+int chk_next_data(struct evdev_client *dev, int idx, int input_type)
+{
+	int ret_val = 0;
+	int next_type = -1;
+	int next_code = -1;
+
+	int next_idx = (idx+1) & (dev->bufsize - 1);
+
+	next_type = dev->buffer[next_idx].type;
+	next_code = dev->buffer[next_idx].code;
+
+	switch (input_type) {
+	case BTN_TOUCH:
+		if (next_type == EV_ABS && next_code == ABS_PRESSURE)
+			ret_val = 1;
+		break;
+	case EV_KEY:
+		ret_val = 1;
+		break;
+	default:
+		break;
+	}
+
+	return ret_val;
+}
+
+int chk_boost_on_off(struct evdev_client *dev, int idx, int dev_type)
+{
+	int ret_val = -1;
+
+	if (dev_type < 0)
+		return ret_val;
+
+	/* In case of SPEN or HOVER, it must be empty multi event
+	 * Before starting input booster.
+	 */
+	if (dev_type == SPEN || dev_type == HOVER) {
+		if (!evdev_mt_event[dev_type] && dev->buffer[idx].value)
+			ret_val = 1;
+		else if (evdev_mt_event[dev_type] && !dev->buffer[idx].value)
+			ret_val = 0;
+	} else if (dev_type == TOUCH || dev_type == MULTI_TOUCH) {
+		if (dev->buffer[idx].value >= 0)
+			ret_val = 1;
+		else
+			ret_val = 0;
+	} else if (dev->buffer[idx].value > 0)
+		ret_val = 1;
+	else if (dev->buffer[idx].value <= 0)
+		ret_val = 0;
+
+	return ret_val;
+}
+
+/*
+ * get_device_type : Define type of device for input_booster.
+ * dev : Current device that in which input events triggered.
+ * keyId : Each device get given unique keyid using Type, Code, Slot values
+ *  to identify which booster will be triggered.
+ * cur_idx : Pointing current handling index from input booster.
+ *  cur_idx will be updated when cur_idx is same as head.
+ * head : End of events set. Input booster handles from tail event to head events.
+ *  Must check if the event is the last one referring to head.
+ */
+int get_device_type(struct evdev_client *dev, unsigned int *keyId, int *cur_idx, int head)
+{
+	int i;
+	int ret_val = -1;
+	int dev_type = NONE_TYPE_DEVICE;
+	int uniq_slot = 0;
+	int next_idx = 0 ;
+	int target_idx = 0;
+
+	if (dev == NULL || dev->ev_cnt > MAX_EVENTS) {
+		pr_err("evdev client is null and exceed max event number");
+		return ret_val;
+	}
+
+	/* Initializing device type before finding the proper device type. */
+	dev->device_type = dev_type;
+
+	for (i = *cur_idx; i != head; i=(i+1) & (dev->bufsize - 1)) {
+		pr_booster("%s Type : %d, Code : %d, Value : %d, Head : %d, idx : %d\n",
+			"Input Data || ", dev->buffer[i].type,
+			dev->buffer[i].code, dev->buffer[i].value,
+			head, i);
+
+		if ( dev->buffer[i].type == EV_SYN || dev->buffer[i].code == SYN_REPORT) {
+			break;
+		}
+
+		if (dev->buffer[i].type == EV_KEY) {
+			target_idx = i;
+			switch (dev->buffer[i].code) {
+			case BTN_TOUCH:
+				if (!chk_next_data(dev, i, BTN_TOUCH))
+					break;
+				dev_type = SPEN;
+				break;
+			case BTN_TOOL_PEN:
+				dev_type = HOVER;
+				break;
+			case KEY_BACK:
+			case KEY_HOMEPAGE:
+				dev_type = TOUCH_KEY;
+				break;
+			case KEY_VOLUMEUP:
+			case KEY_VOLUMEDOWN:
+			case KEY_POWER:
+				dev_type = KEY;
+				break;
+			default:
+				break;
+			}
+
+		} else if (dev->buffer[i].type == EV_ABS) {
+			target_idx = i;
+			switch (dev->buffer[i].code) {
+			case ABS_MT_TRACKING_ID:
+
+				if (dev->buffer[i].value >= 0) {
+					evdev_mt_slot++;
+				} else {
+					evdev_mt_slot--;
+					if (evdev_mt_slot < 0) {
+						evdev_mt_slot = 0;
+						break;
+					}
+				}
+
+				if (dev->buffer[i].value >= 0) {
+					if (evdev_mt_slot == 1) {
+						dev_type = TOUCH;
+						uniq_slot = 1;
+					} else if (evdev_mt_slot == 2) {
+						dev_type = MULTI_TOUCH;
+						uniq_slot = 2;
+					}
+				} else if (dev->buffer[i].value < 0) {
+					//ret_val = 0;
+					if (evdev_mt_slot == 0) {
+						dev_type = TOUCH;
+						uniq_slot = 1;
+					} else if (evdev_mt_slot == 1) {
+						dev_type = MULTI_TOUCH;
+						uniq_slot = 2;
+					}
+				}
+
+				pr_booster("Touch Booster Trigger(%d), Type(%d), Code(%d), Val(%d), head(%d), Tail(%d), uniq_slot(%d), Idx(%d), Cnt(%d)",
+					evdev_mt_slot, dev->buffer[i].type, dev->buffer[i].code, dev->buffer[i].value, head, dev->tail, uniq_slot, i, dev->ev_cnt);
+
+				break;
+			}
+		} else if (dev->buffer[i].type == EV_MSC &&
+					dev->buffer[i].code == MSC_SCAN) {
+
+			if (!chk_next_data(dev, i, EV_KEY)) {
+				break;
+			}
+			next_idx = (i+1) & (dev->bufsize - 1);
+			target_idx = next_idx;
+			switch (dev->buffer[next_idx].code) {
+			case BTN_LEFT: /* Checking Touch Button Event */
+			case BTN_RIGHT:
+			case BTN_MIDDLE:
+				dev_type = MOUSE;
+				//Remain the last of CODE value as a uniq_slot to recognize BTN Type (LEFT, RIGHT, MIDDLE)
+				uniq_slot = dev->buffer[next_idx].code;
+				break;
+			default: /* Checking Keyboard Event */
+				dev_type = KEYBOARD;
+				uniq_slot = dev->buffer[next_idx].code;
+
+				pr_booster("KBD Booster Trigger(%d), Type(%d), Code(%d), Val(%d), head(%d), Tail(%d), Idx(%d), Cnt(%d)\n",
+						dev->buffer[next_idx].code, dev->buffer[i].type,
+						dev->buffer[i].code, dev->buffer[i].value,
+						head, dev->tail, i, dev->ev_cnt);
+				break;
+			}
+		}
+
+		if (dev_type != NONE_TYPE_DEVICE ) {
+			*keyId = create_uniq_id(dev->buffer[i].type, dev->buffer[i].code, uniq_slot);
+			ret_val = chk_boost_on_off(dev, target_idx, dev_type);
+			pr_booster("Dev type Find(%d), KeyID(%d), enable(%d), Target(%d)\n",
+				dev_type, *keyId, ret_val, target_idx);
+			break;
+		}
+
+	}
+	// if for loop reach the end, cur_idx is set as head value or pointing next one with plus one.
+	// Especially, dev->bufsize has to be set as a 2^n.
+	// In the code that set bufzise, we can see bufsize would be set using roundup_pow_of_two function.
+	// return roundup_pow_of_two(n_events);
+	// which means "A power of two is a number of the form 2n where n is an integer"
+
+	*cur_idx = (i == head) ? head : ((i+1) & (dev->bufsize - 1));
+
+	dev->device_type = dev_type;
+	return ret_val;
+}
+
+// ********** Detect Events ********** //
+void input_booster(struct evdev_client* dev, int dev_head) {
+	int dev_type = 0;
+	int keyId = 0;
+	unsigned int uniqId = 0;
+	int res_type = 0;
+	int cnt = 0;
+	int cur_idx = -1;
+	int head = 0;
+
+	if (dev == NULL) {
+		pr_err(ITAG"dev is Null");
+		return;
+	}
+
+	if (!ib_init_succeed || dev->ev_cnt == 0) {
+		pr_err(ITAG"ev_cnt(%d) dt_infor hasn't mem alloc", dev->ev_cnt);
+		return;
+	}
+
+	head = dev_head;
+	cur_idx = (head- dev->ev_cnt) & (dev->bufsize - 1);
+
+	while (cur_idx != head) {
+		keyId = 0;
+		int enable = get_device_type(dev, &keyId, &cur_idx, head);
+		if (enable < 0 || keyId == 0) {
+			continue;
+		}
+
+		dev_type = dev->device_type;
+		if (dev_type <= NONE_TYPE_DEVICE || dev_type >= MAX_DEVICE_TYPE_NUM) {
+			continue;
+		}
+
+		if (enable == BOOSTER_ON) {
+			evdev_mt_event[dev_type]++;
+		} else {
+			evdev_mt_event[dev_type]--;
+		}
+
+		if (cnt == 0 && dev->evdev->handle.dev != NULL) {
+			while(dev->evdev->handle.dev->name[cnt] != '\0') {
+				ib_trigger[trigger_cnt].dev_name[cnt] = dev->evdev->handle.dev->name[cnt];
+				cnt++;
+			}
+			ib_trigger[trigger_cnt].dev_name[cnt] = '\0';
+		}
+
+		pr_booster("Dev Name : %s(%d), Key Id(%d), IB_Cnt(%d)", ib_trigger[trigger_cnt].dev_name, dev_type, keyId, trigger_cnt);
+
+		ib_trigger[trigger_cnt].key_id = keyId;
+		ib_trigger[trigger_cnt].event_type = enable;
+		ib_trigger[trigger_cnt].dev_type = dev_type;
+
+		queue_work(ev_unbound_wq, &(ib_trigger[trigger_cnt++].ib_trigger_work));
+		trigger_cnt = (trigger_cnt == MAX_IB_COUNT) ? 0 : trigger_cnt;
+	}
+}
+#endif //--CONFIG_SEC_INPUT_BOOSTER
+
 static void __pass_event(struct evdev_client *client,
 			 const struct input_event *event)
 {
+#ifdef CONFIG_SEC_INPUT_BOOSTER
+	unsigned long flags;
+
+	pr_booster("Raw Input Data : %d, code : %d, Val : %d",
+		event->type, event->code, event->value);
+	client->ev_cnt++;
+#endif
 	client->buffer[client->head++] = *event;
 	client->head &= client->bufsize - 1;
 
@@ -240,6 +521,13 @@ static void __pass_event(struct evdev_client *client,
 
 	if (event->type == EV_SYN && event->code == SYN_REPORT) {
 		client->packet_head = client->head;
+#ifdef CONFIG_SEC_INPUT_BOOSTER
+		pr_booster("IB Triggered :: HEAD(%d) TAIL(%d)", client->head, client->tail);
+		spin_lock_irqsave(&ib_type_lock, flags);
+		input_booster(client, client->head);
+		client->ev_cnt = 0;
+		spin_unlock_irqrestore(&ib_type_lock, flags);
+#endif
 		kill_fasync(&client->fasync, SIGIO, POLL_IN);
 	}
 }
@@ -1437,6 +1725,9 @@ static struct input_handler evdev_handler = {
 
 static int __init evdev_init(void)
 {
+#ifdef CONFIG_SEC_INPUT_BOOSTER
+	input_booster_init();
+#endif
 	return input_register_handler(&evdev_handler);
 }