The HiDeep touchscreen device is a capacitive multi-touch controller
mainly for multi-touch supported devices use. It use I2C interface for
communication to IC and provide axis X, Y, Z locations for ten finger
touch through input event interface to userspace.
It support the Crimson and the Lime two type IC. They are different
the number of channel supported and FW size. But the working protocol
is same.
Signed-off-by: Anthony Kim <anthony.kim@xxxxxxxxxx>
---
.../bindings/input/touchscreen/hideep.txt | 35 +
.../devicetree/bindings/vendor-prefixes.txt | 1 +
drivers/input/touchscreen/Kconfig | 11 +
drivers/input/touchscreen/Makefile | 2 +
drivers/input/touchscreen/hideep.h | 318 +++++++
drivers/input/touchscreen/hideep_core.c | 916 +++++++++++++++++++++
drivers/input/touchscreen/hideep_dbg.c | 405 +++++++++
drivers/input/touchscreen/hideep_dbg.h | 24 +
drivers/input/touchscreen/hideep_isp.c | 592 +++++++++++++
drivers/input/touchscreen/hideep_isp.h | 96 +++
drivers/input/touchscreen/hideep_sysfs.c | 245 ++++++
11 files changed, 2645 insertions(+)
create mode 100644 Documentation/devicetree/bindings/input/touchscreen/hideep.txt
create mode 100644 drivers/input/touchscreen/hideep.h
create mode 100644 drivers/input/touchscreen/hideep_core.c
create mode 100644 drivers/input/touchscreen/hideep_dbg.c
create mode 100644 drivers/input/touchscreen/hideep_dbg.h
create mode 100644 drivers/input/touchscreen/hideep_isp.c
create mode 100644 drivers/input/touchscreen/hideep_isp.h
create mode 100644 drivers/input/touchscreen/hideep_sysfs.c
diff --git a/Documentation/devicetree/bindings/input/touchscreen/hideep.txt b/Documentation/devicetree/bindings/input/touchscreen/hideep.txt
new file mode 100644
index 0000000..76ea8b1
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/hideep.txt
@@ -0,0 +1,35 @@
+* HiDeep Finger and Stylus touchscreen controller
+
+Required properties:
+- compatible : must be "hideep,hideep_crimson"
+ or "hideep,hideep_lime".
+- reg : I2C slave address, (e.g. 0x6C).
+- interrupt-parent : Interrupt controller to which the chip is connected.
+- interrupts : Interrupt to which the chip is connected.
+
+Optional properties:
+- vdd-supply : It is the controller supply for controlling
+ main voltage(3.3V) through the regulator.
+- vid-supply : It is the controller supply for controlling
+ IO voltage(1.8V) through the regulator.
+- reset-gpios : Define for reset gpio pin.
+ It is to use for reset IC.
+- hideep,max_coords : Max value for axis X, Y, W, Z.
+
+Example:
+
+i2c@00000000 {
+
+ /* ... */
+
+ touchscreen@6c {
+ compatible = "hideep,hideep_ts";
+ reg = <0x6c>;
+ interrupt-parent = <&gpx1>;
+ interrupts = <2 0>;
+ vdd-supply = <&ldo15_reg>";
+ vid-supply = <&ldo18_reg>;
+ reset-gpios = <&gpx1 5 0>;
+ hideep,max_coords = <1080 1920 65535 65535>;
+ };
+};
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index c03d201..aa2a301 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -131,6 +131,7 @@ gw Gateworks Corporation
hannstar HannStar Display Corporation
haoyu Haoyu Microelectronic Co. Ltd.
hardkernel Hardkernel Co., Ltd
+hideep HiDeep Inc.
himax Himax Technologies, Inc.
hisilicon Hisilicon Limited.
hit Hitachi Ltd.
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 64b30fe..13e11c7 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -1246,4 +1246,15 @@ config TOUCHSCREEN_ROHM_BU21023
To compile this driver as a module, choose M here: the
module will be called bu21023_ts.
+config TOUCHSCREEN_HIDEEP
+ tristate "HiDeep Touch IC"
+ depends on I2C
+ help
+ Say Y here if you have a touchscreen using HiDeep.
+
+ If unsure, say N.
+
+ To compile this driver as a moudle, choose M here : the
+ module will be called hideep_ts.
+
endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 6badce8..3aab466 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -103,3 +103,5 @@ obj-$(CONFIG_TOUCHSCREEN_ZET6223) += zet6223.o
obj-$(CONFIG_TOUCHSCREEN_ZFORCE) += zforce_ts.o
obj-$(CONFIG_TOUCHSCREEN_COLIBRI_VF50) += colibri-vf50-ts.o
obj-$(CONFIG_TOUCHSCREEN_ROHM_BU21023) += rohm_bu21023.o
+obj-$(CONFIG_TOUCHSCREEN_HIDEEP) += hideep_ts.o
+hideep_ts-$(CONFIG_TOUCHSCREEN_HIDEEP) := hideep_core.o hideep_sysfs.o hideep_isp.o hideep_dbg.o
diff --git a/drivers/input/touchscreen/hideep.h b/drivers/input/touchscreen/hideep.h
new file mode 100644
index 0000000..50306a1
--- /dev/null
+++ b/drivers/input/touchscreen/hideep.h
@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#ifndef _LINUX_HIDEEP_H
+#define _LINUX_HIDEEP_H
+
+/*************************************************************************
+ * this is include special HEAD file.
+ *************************************************************************/
+#ifdef CONFIG_FB
+#include <linux/fb.h>
+#include <linux/notifier.h>
+#endif
+
+/*************************************************************************
+ * this is include normal HEAD file.
+ *************************************************************************/
+#include <linux/of_gpio.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/input.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/regulator/consumer.h>
+#include <linux/firmware.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/pinctrl/machine.h>
+#include <linux/kthread.h>
+#include <linux/random.h>
+#include <linux/slab.h>
+#include <linux/sched.h>
+#include <linux/sched/rt.h>
+#include <linux/task_work.h>
+#include <linux/rtc.h>
+#include <linux/syscalls.h>
+#include <linux/timer.h>
+#include <linux/time.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/hrtimer.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/input/mt.h>
+#include <linux/fs.h>
+#include <linux/completion.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <linux/init.h>
+#include <linux/gfp.h>
+#include <linux/kobject.h>
+#include <linux/string.h>
+#include <linux/sysfs.h>
+#include <linux/module.h>
+#include <linux/poll.h>
+#include <linux/fcntl.h>
+#include <linux/unistd.h>
+#include <linux/version.h>
+#include <linux/acpi.h>
+
+/*************************************************************************
+ * definition part.
+ * define is (open, set, enable) if not, is (close, clear, disable)
+ * some special switch of functions.
+ *************************************************************************/
+
+/* HIDEEP_PROTOCOL_2_0 is for protocol 2.0. */
+#define HIDEEP_PROTOCOL_2_0
+
+/* HIDEEP_TYPE_B_PROTOCOL is for input_dev, if define , using TYPE_B,
+ * otherwise TYPE_A.
+ */
+#define HIDEEP_TYPE_B_PROTOCOL
+
+/* HIDEEP_DWZ_VERSION_CHECK if define, it will check dwz version. */
+#define HIDEEP_DWZ_VERSION_CHECK
+
+/* HIDEEP_SUPPORT_KE if define, it will use key button. */
+#define HIDEEP_SUPPORT_KEY
+
+/* HIDEEP_SUPPORT_STYLUS if define, it will use stylus mode. */
+#define HIDEEP_SUPPORT_STYLUS
+
+/*************************************************************************
+ * Buffer size
+ *************************************************************************/
+#define FRAME_HEADER_SIZE 8
+/* if size of system i2c buffer is smaller than this value, need to modify */
+#define MAX_I2C_BUFFER_SIZE 512
+
+/*************************************************************************
+ * board porting config
+ *************************************************************************/
+#define HIDEEP_DEBUG_DEVICE_NAME "hideep_debug"
+#define HIDEEP_TS_NAME "HiDeep Touchscreen"
+#define HIDEEP_I2C_NAME "hideep_ts"
+
+/*************************************************************************
+ * register addr
+ *************************************************************************/
+/* Touch & key event */
+#define HIDEEP_EVENT_COUNT_ADDR 0x240
+#define HIDEEP_TOUCH_DATA_ADDR 0x242
+#define HIDEEP_KEY_DATA_ADDR 0x2A6
+#define HIDEEP_RAW_DATA_ADDR 0x1000
+
+/* command list */
+#define HIDEEP_RESET_CMD 0x9800
+#define HIDEEP_INTCLR_CMD 0x9802
+#define HIDEEP_OPMODE_CMD 0x9804
+#define HIDEEP_SWTICH_CMD 0x9805
+#define HIDEEP_SLEEP_CMD 0x980D
+
+/*************************************************************************
+ * multi-touch & key definitions.
+ *************************************************************************/
+#define HIDEEP_MT_MAX 10
+#define HIDEEP_KEY_MAX 3
+
+/* multi touch event bit */
+#define HIDEEP_MT_ALWAYS_REPORT 0
+#define HIDEEP_MT_TOUCHED 1
+#define HIDEEP_MT_FIRST_CONTACT 2
+#define HIDEEP_MT_DRAG_MOVE 3
+#define HIDEEP_MT_RELEASED 4
+#define HIDEEP_MT_PINCH 5
+#define HIDEEP_MT_PRESSURE 6
+
+/* key event bit */
+#define HIDEEP_KEY_RELEASED 0x20
+#define HIDEEP_KEY_PRESSED 0x40
+#define HIDEEP_KEY_FIRST_PRESSED 0x80
+#define HIDEEP_KEY_PRESSED_MASK 0xC0
+
+/*************************************************************************
+ * HIDEEP PROTOCOL
+ *************************************************************************/
+#ifdef HIDEEP_PROTOCOL_2_0
+struct hideep_mt_t {
+ unsigned short x;
+ unsigned short y;
+ unsigned short z;
+ unsigned char w;
+ unsigned char flag;
+ unsigned char type;
+ unsigned char index;
+};
+#else
+struct hideep_mt_t {
+ unsigned char flag;
+ unsigned char index;
+ unsigned short x;
+ unsigned short y;
+ unsigned char z;
+ unsigned char w;
+};
+#endif
+
+struct hideep_key_t {
+ unsigned char flag;
+ unsigned int key;
+};
+
+/*************************************************************************
+ * IC State
+ *************************************************************************/
+enum e_dev_state {
+ state_init = 1,
+ state_normal,
+ state_sleep,
+ state_updating,
+ state_debugging,
+};
+
+/*************************************************************************
+ * Firmware info
+ *************************************************************************/
+struct dwz_info_t {
+ unsigned int code_start;
+ unsigned char code_crc[12];
+
+ unsigned int c_code_start;
+ unsigned short c_code_len;
+ unsigned short gen_ver;
+
+ unsigned int vr_start;
+ unsigned short vr_len;
+ unsigned short rsv0;
+
+ unsigned int ft_start;
+ unsigned short ft_len;
+ unsigned short vr_version;
+
+ unsigned short boot_ver;
+ unsigned short core_ver;
+ unsigned short custom_ver;
+ unsigned short release_ver;
+
+ unsigned char factory_id;
+ unsigned char panel_type;
+ unsigned char model_name[6];
+ unsigned short product_code;
+ unsigned short extra_option;
+
+ unsigned short product_id;
+ unsigned short vendor_id;
+};
+
+/*************************************************************************
+ * driver information for hideep_t by device tree
+ *************************************************************************/
+struct hideep_platform_data_t {
+ unsigned int max_x;
+ unsigned int max_y;
+ unsigned int max_z;
+ unsigned int max_w;
+
+#ifdef CONFIG_OF
+ int reset_gpio;
+
+ struct regulator *vcc_vdd;
+ struct regulator *vcc_vid;
+#endif
+};
+
+struct hideep_debug_dev_t {
+ struct miscdevice misc;
+
+ wait_queue_head_t i_packet;
+
+ unsigned int ready;
+ unsigned char *vr_buff;
+ unsigned char *img_buff;
+ unsigned short vr_size;
+ unsigned short img_size;
+
+ bool debug_enable;
+ bool release_flag;
+
+ struct hideep_t *ts;
+};
+
+struct hideep_function_list_t {
+ //core
+ int (*i2c_read)(struct hideep_t *, unsigned short, unsigned short,
+ unsigned char *);
+ int (*i2c_write)(struct hideep_t *, unsigned short, unsigned short,
+ unsigned char *);
+ void (*reset_ic)(struct hideep_t *);
+ void (*power)(struct hideep_t *, int);
+
+ //isp
+ int (*update_all)(struct hideep_t *, const char *);
+ int (*update_part)(struct hideep_t *, unsigned char *, int, int, bool);
+ int (*get_dwz_info)(struct hideep_t *);
+ void (*sp_func)(struct hideep_t *, unsigned char *, int, int);
+};
+
+struct hideep_t {
+ struct i2c_client *client;
+ struct input_dev *input_dev;
+ struct hideep_platform_data_t *p_data;
+
+ struct mutex dev_mutex;
+ struct mutex i2c_mutex;
+
+ struct hideep_debug_dev_t debug_dev;
+ struct hideep_function_list_t *hideep_api;
+
+ struct task_struct *hthread_event;
+
+ bool suspended;
+ enum e_dev_state dev_state;
+
+#ifdef CONFIG_FB
+ struct notifier_block fb_notif;
+#endif
+
+ long tch_bit;
+ unsigned int tch_count;
+ unsigned int key_count;
+ unsigned int lpm_count;
+
+ struct hideep_mt_t touch_evt[HIDEEP_MT_MAX];
+
+#ifdef HIDEEP_SUPPORT_KEY
+ struct hideep_key_t key_evt[HIDEEP_KEY_MAX];
+ int key_codes[HIDEEP_KEY_MAX];
+#endif
+
+ unsigned char i2c_buf[256];
+ struct dwz_info_t *dwz_info;
+
+ int interrupt_state;
+ int fw_size;
+};
+
+/*************************************************************************
+ * function define
+ *************************************************************************/
+int hideep_debug_init(struct hideep_t *ts);
+void hideep_debug_uninit(void);
+
+int hideep_sysfs_init(struct hideep_t *ts);
+int hideep_sysfs_exit(struct hideep_t *ts);
+
+void hideep_isp_init(struct hideep_t *ts);
+
+#endif
diff --git a/drivers/input/touchscreen/hideep_core.c b/drivers/input/touchscreen/hideep_core.c
new file mode 100644
index 0000000..2b71b84d
--- /dev/null
+++ b/drivers/input/touchscreen/hideep_core.c
@@ -0,0 +1,916 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#include "hideep.h"
+
+#define GET_PAYLOAD_SIZE_FROM_HEADER(x) \
+ ((x[1]>>6) ? ((x[2]*256+x[3])*(x[7]+1)):(x[2]*x[3]*(x[7]+1)))
+
+static int hideep_pwr_on(struct hideep_t *ts)
+{
+ struct hideep_platform_data_t *pdata;
+ int ret = 0;
+
+ pdata = ts->p_data;
+
+#ifdef CONFIG_OF
+ if (!IS_ERR(pdata->vcc_vdd)) {
+ dev_info(&ts->client->dev, "hideep:vcc_vdd is enable");
+ ret = regulator_enable(pdata->vcc_vdd);
+ if (ret)
+ dev_err(&ts->client->dev,
+ "Regulator vdd enable failed ret=%d", ret);
+ }
+ usleep_range(999, 1000);
+
+ if (!IS_ERR(pdata->vcc_vid)) {
+ dev_info(&ts->client->dev, "hideep:vcc_vid is enable");
+ ret = regulator_enable(pdata->vcc_vid);
+ if (ret)
+ dev_err(&ts->client->dev,
+ "Regulator vcc_vid enable failed ret=%d", ret);
+ }
+ usleep_range(2999, 3000);
+#endif
+
+ return ret;
+}
+
+static int hideep_pwr_off(struct hideep_t *ts)
+{
+ struct hideep_platform_data_t *pdata;
+ int ret = 0;
+
+ pdata = ts->p_data;
+
+#ifdef CONFIG_OF
+ if (pdata->reset_gpio > 0) {
+ dev_info(&ts->client->dev, "hideep:disable the reset_gpio");
+ gpio_set_value(pdata->reset_gpio, 0);
+ }
+
+ if (!IS_ERR(pdata->vcc_vid)) {
+ dev_info(&ts->client->dev, "hideep:vcc_vid is disable");
+ ret = regulator_disable(pdata->vcc_vid);
+ if (ret)
+ dev_err(&ts->client->dev,
+ "Regulator vcc_vid enable failed ret=%d", ret);
+ }
+
+ if (!IS_ERR(pdata->vcc_vdd)) {
+ dev_info(&ts->client->dev, "hideep:vcc_vdd is disable");
+ ret = regulator_disable(pdata->vcc_vdd);
+ if (ret)
+ dev_err(&ts->client->dev,
+ "Regulator vdd disable failed ret=%d", ret);
+ }
+#endif
+ return ret;
+}
+
+static void hideep_power(struct hideep_t *ts, int on)
+{
+ int ret = 0;
+
+ if (on) {
+ dev_info(&ts->client->dev, "power on");
+ ret = hideep_pwr_on(ts);
+ } else {
+ dev_info(&ts->client->dev, "power off");
+ ret = hideep_pwr_off(ts);
+ }
+}
+
+static int hideep_i2c_read(struct hideep_t *ts, unsigned short addr,
+ unsigned short len, unsigned char *buf)
+{
+ int ret = -1;
+ unsigned short r_len, raddr;
+ int length;
+
+ length = len;
+ raddr = addr;
+
+ dev_dbg(&ts->client->dev, "addr = 0x%02x, len = %d", addr, len);
+
+ mutex_lock(&ts->i2c_mutex);
+
+ do {
+ if (length > MAX_I2C_BUFFER_SIZE)
+ r_len = MAX_I2C_BUFFER_SIZE;
+ else
+ r_len = length;
+
+ dev_dbg(&ts->client->dev, "addr = 0x%02x, len = %d",
+ raddr, r_len);
+
+ ret = i2c_master_send(ts->client, (char *)&raddr, 2);
+
+ if (ret < 0)
+ goto i2c_err;
+
+ ret = i2c_master_recv(ts->client, (char *)buf, r_len);
+ length -= MAX_I2C_BUFFER_SIZE;
+ buf += MAX_I2C_BUFFER_SIZE;
+ raddr += MAX_I2C_BUFFER_SIZE;
+
+ if (ret < 0)
+ goto i2c_err;
+ } while (length > 0);
+
+ mutex_unlock(&ts->i2c_mutex);
+
+ return 0;
+i2c_err:
+ mutex_unlock(&ts->i2c_mutex);
+ return -1;
+}
+
+static int hideep_i2c_write(struct hideep_t *ts, unsigned short addr,
+ unsigned short len, unsigned char *buf)
+{
+ int ret = -1;
+
+ dev_dbg(&ts->client->dev, "addr = 0x%02x, len = %d", addr, len);
+
+ mutex_lock(&ts->i2c_mutex);
+
+ // data mangling..
+ ts->i2c_buf[0] = (addr >> 0) & 0xFF;
+ ts->i2c_buf[1] = (addr >> 8) & 0xFF;
+ memcpy(&ts->i2c_buf[2], buf, len);
+
+ ret = i2c_master_send(ts->client, (char *)ts->i2c_buf, len + 2);
+
+ if (ret < 0)
+ goto i2c_err;
+
+ mutex_unlock(&ts->i2c_mutex);
+ return 0;
+
+i2c_err:
+ mutex_unlock(&ts->i2c_mutex);
+ return -1;
+}
+
+#define __GET_MT_TOOL_TYPE(X) ((X == 0x01) ? MT_TOOL_FINGER : MT_TOOL_PEN)
+
+static void pops_mt(struct hideep_t *ts)
+{
+#ifdef HIDEEP_TYPE_B_PROTOCOL
+ int id;
+ int i;
+
+ for (i = 0; i < ts->tch_count; i++) {
+ id = (ts->touch_evt[i].index >> 0) & 0x0F;
+ input_mt_slot(ts->input_dev, id);
+ input_mt_report_slot_state(ts->input_dev,
+ __GET_MT_TOOL_TYPE(ts->touch_evt[i].type), false);
+ input_report_key(ts->input_dev, BTN_TOUCH, false);
+ }
+#else
+ input_report_key(ts->input_dev, BTN_TOUCH, false);
+ input_mt_sync(ts->input_dev);
+#endif
+
+ input_sync(ts->input_dev);
+}
+
+static void push_mt(struct hideep_t *ts)
+{
+ int id;
+ int i;
+ bool btn_up = 0;
+ bool btn_dn = 0;
+ bool btn_mv = 0;
+ int evt = 0;
+
+ /* load multi-touch event to input system */
+ for (i = 0; i < ts->tch_count; i++) {
+ id = (ts->touch_evt[i].index >> 0) & 0x0F;
+ btn_up = (ts->touch_evt[i].flag >> HIDEEP_MT_RELEASED) & 0x01;
+ btn_dn = (ts->touch_evt[i].flag >> HIDEEP_MT_FIRST_CONTACT)
+ & 0x01;
+ btn_mv = (ts->touch_evt[i].flag >> HIDEEP_MT_DRAG_MOVE) & 0x01;
+
+ if (btn_up)
+ clear_bit(id, &ts->tch_bit);
+ else
+ __set_bit(id, &ts->tch_bit);
+
+ dev_dbg(&ts->client->dev,
+ "type = %d, id = %d, i = %d, x = %d, y = %d, z = %d",
+ ts->touch_evt[i].type, ts->touch_evt[i].index,
+ i, ts->touch_evt[i].x, ts->touch_evt[i].y,
+ ts->touch_evt[i].z);
+
+#ifdef HIDEEP_TYPE_B_PROTOCOL
+ input_mt_slot(ts->input_dev, id);
+ input_mt_report_slot_state(ts->input_dev,
+ __GET_MT_TOOL_TYPE(ts->touch_evt[i].type),
+ (btn_up == 0));
+
+ if (btn_up == 0) {
+ input_report_abs(ts->input_dev, ABS_MT_POSITION_X,
+ ts->touch_evt[i].x);
+ input_report_abs(ts->input_dev, ABS_MT_POSITION_Y,
+ ts->touch_evt[i].y);
+ input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
+ ts->touch_evt[i].z);
+ input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
+ ts->touch_evt[i].w);
+ evt++;
+ }
+#else
+ if (btn_up) {
+ input_mt_sync(ts->input_dev);
+ } else {
+ input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, id);
+ input_report_abs(ts->input_dev, ABS_MT_POSITION_X,
+ ts->touch_evt[i].x);
+ input_report_abs(ts->input_dev, ABS_MT_POSITION_Y,
+ ts->touch_evt[i].y);
+ input_report_abs(ts->input_dev, ABS_MT_PRESSURE,
+ ts->touch_evt[i].z);
+ input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
+ ts->touch_evt[i].w);
+ input_mt_sync(ts->input_dev);
+ evt++;
+ }
+#endif
+ }
+
+ if (ts->tch_bit == 0)
+ evt = 0;
+
+ input_report_key(ts->input_dev, BTN_TOUCH, evt);
+ input_mt_sync_frame(ts->input_dev);
+ input_sync(ts->input_dev);
+}
+
+#ifdef HIDEEP_SUPPORT_KEY
+static void pops_ky(struct hideep_t *ts)
+{
+ int i;
+
+ for (i = 0; i < ts->tch_count; i++) {
+ input_report_key(ts->input_dev, ts->key_codes[i], false);
+ input_report_key(ts->input_dev, BTN_TOUCH, false);
+ }
+
+ input_sync(ts->input_dev);
+}
+
+static void push_ky(struct hideep_t *ts)
+{
+ int i;
+ int pressed;
+ int key_code;
+ int key_status;
+
+ for (i = 0; i < ts->key_count; i++) {
+ key_code = ts->key_evt[i].flag & 0x0F;
+ key_status = ts->key_evt[i].flag & 0xF0;
+ pressed = false;
+
+ if (key_status & HIDEEP_KEY_PRESSED_MASK)
+ pressed = true;
+ else
+ pressed = false;
+
+ input_report_key(ts->input_dev, ts->key_codes[key_code],
+ pressed);
+ input_report_key(ts->input_dev, BTN_TOUCH, pressed);
+ }
+
+ input_sync(ts->input_dev);
+}
+#endif
+
+static void hideep_put_event(struct hideep_t *ts)
+{
+ /* mangling touch information */
+ if (ts->tch_count > 0)
+ push_mt(ts);
+
+#ifdef HIDEEP_SUPPORT_KEY
+ if (ts->key_count > 0)
+ push_ky(ts);
+#endif
+}
+
+static int hideep_get_event(struct hideep_t *ts)
+{
+ int ret;
+ int touch_count;
+ int info_size;
+
+
+ /* get touch event count */
+ dev_dbg(&ts->client->dev, "mt = %d, key = %d, lpm = %02x",
+ ts->tch_count, ts->key_count, ts->lpm_count);
+
+ /* get touch event information */
+ if (ts->tch_count > HIDEEP_MT_MAX)
+ ts->tch_count = 0;
+
+ if (ts->key_count > HIDEEP_KEY_MAX)
+ ts->key_count = 0;
+
+ touch_count = ts->tch_count + ts->key_count;
+
+ if (ts->tch_count > 0) {
+ info_size = ts->tch_count * sizeof(struct hideep_mt_t);
+ ret = hideep_i2c_read(ts, HIDEEP_TOUCH_DATA_ADDR,
+ info_size, (unsigned char *)ts->touch_evt);
+ if (ret < 0) {
+ dev_err(&ts->client->dev, "read I2C error.");
+ return -1;
+ }
+ }
+
+#ifdef HIDEEP_SUPPORT_KEY
+ if (ts->key_count > 0) {
+ info_size = ts->key_count * sizeof(struct hideep_key_t);
+ ret = hideep_i2c_read(ts, HIDEEP_KEY_DATA_ADDR,
+ info_size, (unsigned char *)ts->key_evt);
+ if (ret < 0) {
+ dev_err(&ts->client->dev, "read I2C error.");
+ return -1;
+ }
+ }
+#endif
+
+ return touch_count;
+}
+
+static int hideep_event_thread(void *arg)
+{
+ int t_evt;
+
+ struct hideep_t *ts = arg;
+
+ dev_info(&ts->client->dev, "start event thread");
+
+ while (!kthread_should_stop()) {
+ set_current_state(TASK_INTERRUPTIBLE);
+
+ schedule();
+
+ t_evt = hideep_get_event(ts);
+
+ if (t_evt >= 0)
+ hideep_put_event(ts);
+
+ if (kthread_should_stop())
+ break;
+ }
+
+ dev_info(&ts->client->dev, "end thread");
+ return 0;
+}
+
+static irqreturn_t hideep_irq_task(int irq, void *handle)
+{
+ unsigned char i2c_buff[2];
+ int ret;
+
+ struct hideep_t *ts = (struct hideep_t *) handle;
+
+ dev_dbg(&ts->client->dev, "state = 0x%x, debug = %d",
+ ts->dev_state, ts->debug_dev.debug_enable);
+
+ if (ts->debug_dev.debug_enable == false &&
+ ts->dev_state == state_normal) {
+ ret = hideep_i2c_read(ts, HIDEEP_EVENT_COUNT_ADDR,
+ 2, (u8 *)&i2c_buff);
+ if (ret < 0) {
+ disable_irq(ts->client->irq);
+ ts->interrupt_state = 0;
+ return IRQ_HANDLED;
+ }
+
+ ts->tch_count = i2c_buff[0];
+ ts->key_count = i2c_buff[1] & 0x0f;
+ ts->lpm_count = i2c_buff[1] & 0xf0;
+
+ wake_up_process(ts->hthread_event);
+
+ } else if (ts->debug_dev.debug_enable == true
+ && ts->dev_state == state_debugging) {
+ ret = ts->hideep_api->i2c_read(ts, HIDEEP_RAW_DATA_ADDR,
+ FRAME_HEADER_SIZE + ts->debug_dev.img_size,
+ ts->debug_dev.img_buff);
+ ts->debug_dev.img_size =
+ GET_PAYLOAD_SIZE_FROM_HEADER(ts->debug_dev.img_buff);
+ ts->debug_dev.ready = 1;
+ wake_up_interruptible(&ts->debug_dev.i_packet);
+ }
+ dev_dbg(&ts->client->dev, "end.");
+
+ return IRQ_HANDLED;
+}
+
+static int hideep_capability(struct hideep_t *ts)
+{
+#ifdef HIDEEP_SUPPORT_KEY
+ int i;
+
+ ts->key_codes[0] = KEY_MENU;
+ ts->key_codes[1] = KEY_HOME;
+ ts->key_codes[2] = KEY_BACK;
+
+ for (i = 0; i < HIDEEP_KEY_MAX; i++)
+ set_bit(ts->key_codes[i], ts->input_dev->keybit);
+#endif
+
+ ts->input_dev->name = HIDEEP_TS_NAME;
+ ts->input_dev->id.bustype = BUS_I2C;
+
+ set_bit(EV_ABS, ts->input_dev->evbit);
+ set_bit(EV_KEY, ts->input_dev->evbit);
+ set_bit(EV_SYN, ts->input_dev->evbit);
+ set_bit(BTN_TOUCH, ts->input_dev->keybit);
+ set_bit(MT_TOOL_FINGER, ts->input_dev->keybit);
+ set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
+
+ input_set_abs_params(ts->input_dev, ABS_X, 0, ts->p_data->max_x, 0, 0);
+ input_set_abs_params(ts->input_dev, ABS_Y, 0, ts->p_data->max_y, 0, 0);
+ input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0,
+ ts->p_data->max_z, 0, 0);
+
+#ifdef HIDEEP_TYPE_B_PROTOCOL
+ input_mt_init_slots(ts->input_dev,
+ HIDEEP_MT_MAX, INPUT_MT_DIRECT);
+#else
+ input_set_abs_params(ts->input_dev,
+ ABS_MT_TRACKING_ID, 0, 10, 0, 0);
+#endif
+ input_set_abs_params(ts->input_dev,
+ ABS_MT_TOOL_TYPE, 0, MT_TOOL_MAX, 0, 0);
+ input_set_abs_params(ts->input_dev,
+ ABS_MT_POSITION_X, 0, ts->p_data->max_x - 1, 0, 0);
+ input_set_abs_params(ts->input_dev,
+ ABS_MT_POSITION_Y, 0, ts->p_data->max_y - 1, 0, 0);
+ input_set_abs_params(ts->input_dev,
+ ABS_MT_PRESSURE, 0, ts->p_data->max_z, 0, 0);
+ input_set_abs_params(ts->input_dev,
+ ABS_MT_TOUCH_MAJOR, 0, ts->p_data->max_w, 0, 0);
+
+ return 0;
+}
+
+static void hideep_reset_ic(struct hideep_t *ts)
+{
+ struct hideep_platform_data_t *pdata;
+ int ret;
+ unsigned char cmd = 0x01;
+
+ pdata = ts->p_data;
+
+ dev_info(&ts->client->dev, "start!!");
+
+#ifdef CONFIG_OF
+ if (pdata->reset_gpio > 0) {
+ dev_info(&ts->client->dev, "hideep:enable the reset_gpio");
+ gpio_set_value(pdata->reset_gpio, 0);
+ mdelay(20);
+ gpio_set_value(pdata->reset_gpio, 1);
+ } else
+#endif
+ {
+ ret = hideep_i2c_write(ts, HIDEEP_RESET_CMD, 1, &cmd);
+ }
+ mdelay(50);
+ dev_info(&ts->client->dev, "end!!");
+}
+
+static void hideep_get_info(struct hideep_t *ts)
+{
+ struct hideep_platform_data_t *pdata;
+ unsigned char val[4];
+
+ pdata = ts->p_data;
+ ts->hideep_api->i2c_read(ts, 0x28, 4, val);
+
+ pdata->max_x = val[3] << 8 | val[2];
+ pdata->max_y = val[1] << 8 | val[0];
+ pdata->max_w = 255;
+ pdata->max_z = 255;
+
+ dev_info(&ts->client->dev, "X : %d, Y : %d",
+ pdata->max_x, pdata->max_y);
+}
+
+static void hideep_init_ic(struct hideep_t *ts)
+{
+ struct hideep_platform_data_t *pdata;
+ struct device dev;
+
+ pdata = ts->p_data;
+ dev = ts->client->dev;
+
+ /* power on */
+ ts->hideep_api->power(ts, true);
+ ts->dev_state = state_init;
+ mdelay(30);
+
+ /* ic reset */
+ ts->hideep_api->reset_ic(ts);
+}
+
+static int hideep_resume(struct device *dev)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ unsigned char sleep_cmd = 0x00;
+
+ dev_info(dev, "enter");
+
+ mutex_lock(&ts->dev_mutex);
+
+ if (ts->dev_state == state_normal)
+ goto hideep_resume_exit;
+
+ dev_info(dev, "not waiting.");
+ ts->dev_state = state_normal;
+
+ hideep_i2c_write(ts, HIDEEP_SLEEP_CMD, 1, &sleep_cmd);
+ enable_irq(ts->client->irq);
+ ts->interrupt_state = 1;
+
+hideep_resume_exit:
+ mdelay(10);
+ ts->hideep_api->reset_ic(ts);
+
+ mutex_unlock(&ts->dev_mutex);
+ dev_info(dev, "exit.");
+ return 0;
+}
+
+static int hideep_suspend(struct device *dev)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ unsigned char sleep_cmd = 0x01;
+
+ dev_info(dev, "enter");
+
+ mutex_lock(&ts->dev_mutex);
+ if (ts->dev_state == state_sleep)
+ goto hideep_suspend_exit;
+
+ dev_info(dev, "not waiting.");
+ ts->dev_state = state_sleep;
+
+ /* send sleep command.. */
+ pops_mt(ts);
+#ifdef HIDEEP_SUPPORT_KEY
+ pops_ky(ts);
+#endif
+
+ /* default deep sleep */
+ hideep_i2c_write(ts, HIDEEP_SLEEP_CMD, 1, &sleep_cmd);
+ disable_irq(ts->client->irq);
+ ts->interrupt_state = 0;
+
+hideep_suspend_exit:
+ mutex_unlock(&ts->dev_mutex);
+ dev_info(dev, "exit.");
+ return 0;
+}
+
+#ifdef CONFIG_FB
+static int fb_notifier_callback(struct notifier_block *self,
+ unsigned long event, void *data)
+{
+ struct fb_event *evdata = data;
+ int *blank;
+
+ struct hideep_t *ts = container_of(self, struct hideep_t, fb_notif);
+
+ if ((evdata) && (evdata->data) &&
+ (event == FB_EVENT_BLANK) &&
+ (ts) && (ts->client)) {
+ blank = evdata->data;
+ if (*blank == FB_BLANK_UNBLANK) {
+ dev_info(&ts->client->dev, "resume");
+ if (ts->suspended == 1) {
+ hideep_resume(&ts->client->dev);
+ ts->suspended = 0;
+ }
+ } else if (*blank == FB_BLANK_POWERDOWN) {
+ dev_info(&ts->client->dev, "suspend");
+ if (ts->suspended == 0) {
+ ts->suspended = 1;
+ hideep_suspend(&ts->client->dev);
+ }
+ }
+ }
+
+ return 0;
+}
+#endif
+
+#ifdef CONFIG_OF
+static int hideep_parse_dts(struct device *dev,
+ struct hideep_platform_data_t *pdata)
+{
+ int ret = 0;
+ unsigned int coords[4];
+ struct device_node *np;
+
+ dev_info(dev, "enter");
+ np = dev->of_node;
+
+ ret = of_property_read_u32_array(np, "hideep,max_coords", coords, 4);
+ if (ret) {
+ dev_err(dev, "Failed to get max_coords property\n");
+ return ret;
+ }
+
+ pdata->max_x = coords[0];
+ pdata->max_y = coords[1];
+ pdata->max_w = coords[2];
+ pdata->max_z = coords[3];
+
+ dev_info(dev, "max coord data x : %d\n", pdata->max_x);
+ dev_info(dev, "max coord data y : %d\n", pdata->max_y);
+ dev_info(dev, "max coord data w : %d\n", pdata->max_w);
+ dev_info(dev, "max coord data z : %d\n", pdata->max_z);
+
+ /* device tree information get */
+ pdata->reset_gpio = of_get_named_gpio(np, "reset-gpios", 0);
+ dev_info(dev, "reset_gpio = %d, is %s specified",
+ pdata->reset_gpio, pdata->reset_gpio < 0 ? "not" : "");
+ if (pdata->reset_gpio)
+ ret = gpio_request_one(pdata->reset_gpio, GPIOF_OUT_INIT_HIGH,
+ "reset-gpios");
+
+ pdata->vcc_vdd = regulator_get(dev, "vdd");
+ pdata->vcc_vid = regulator_get(dev, "vid");
+
+ return ret;
+}
+#endif
+
+static int hideep_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ int ret = 0;
+ struct hideep_platform_data_t *p_data;
+ struct dwz_info_t *dwz;
+ struct hideep_function_list_t *function;
+ struct hideep_t *ts;
+
+ dev_info(&client->dev, "enter");
+
+ /* check i2c bus */
+ if (!i2c_check_functionality(client->adapter,
+ I2C_FUNC_I2C)) {
+ dev_err(&client->dev, "check i2c device error");
+ ret = -ENODEV;
+ return ret;
+ }
+
+ /* init platform data */
+ p_data = devm_kzalloc(&client->dev,
+ sizeof(struct hideep_platform_data_t), GFP_KERNEL);
+
+#ifdef CONFIG_OF
+ if (client->dev.of_node) {
+ ret = hideep_parse_dts(&client->dev, p_data);
+ if (ret)
+ return ret;
+ }
+#endif
+
+ /* init hideep_t */
+ ts = devm_kzalloc(&client->dev,
+ sizeof(struct hideep_t), GFP_KERNEL);
+ dwz = devm_kzalloc(&client->dev,
+ sizeof(struct dwz_info_t), GFP_KERNEL);
+ function = devm_kzalloc(&client->dev,
+ sizeof(struct hideep_function_list_t), GFP_KERNEL);
+
+ ts->client = client;
+ ts->p_data = p_data;
+ ts->dwz_info = dwz;
+ ts->hideep_api = function;
+
+ ts->hideep_api->i2c_read = hideep_i2c_read;
+ ts->hideep_api->i2c_write = hideep_i2c_write;
+ ts->hideep_api->reset_ic = hideep_reset_ic;
+ ts->hideep_api->power = hideep_power;
+
+ /* init for isp function */
+ hideep_isp_init(ts);
+
+ i2c_set_clientdata(client, ts);
+
+ mutex_init(&ts->i2c_mutex);
+ mutex_init(&ts->dev_mutex);
+
+ if (!client->dev.of_node)
+ hideep_get_info(ts);
+
+ /* hardware init */
+ hideep_init_ic(ts);
+
+#ifdef HIDEEP_DWZ_VERSION_CHECK
+ /* read info */
+ ret = ts->hideep_api->get_dwz_info(ts);
+ if (ret < 0) {
+ dev_err(&client->dev, "fail to load dwz, ret = 0x%x", ret);
+ goto hideep_probe_read_dwz_err;
+ }
+#endif
+
+ /* init input device */
+ ts->input_dev = devm_input_allocate_device(&client->dev);
+ if (!ts->input_dev) {
+ dev_err(&client->dev, "can't allocate memory for input_dev");
+ ret = -ENOMEM;
+ goto hideep_probe_input_dev_memory_err;
+ }
+
+ hideep_capability(ts);
+
+ ret = input_register_device(ts->input_dev);
+ if (ret) {
+ dev_err(&client->dev, "can't register input_dev");
+ ret = -ENOMEM;
+ goto hideep_probe_register_input_dev_err;
+ }
+
+ input_set_drvdata(ts->input_dev, ts);
+
+ /* init event thread */
+ ts->hthread_event = kthread_run(hideep_event_thread,
+ ts, "hideep_event_thread");
+ if (IS_ERR(ts->hthread_event)) {
+ dev_err(&client->dev, "can't create event thread !!!");
+ ret = PTR_ERR(ts->hthread_event);
+ goto hideep_probe_create_thread_err;
+ }
+
+ dev_info(&ts->client->dev, "ts irq: %d", ts->client->irq);
+ if (ts->client->irq <= 0) {
+ dev_err(&client->dev, "can't be assigned irq");
+ goto hideep_probe_assigned_irq_err;
+ }
+
+ if (ts->client->irq) {
+ ret = request_threaded_irq(ts->client->irq, NULL,
+ hideep_irq_task,
+ (IRQF_TRIGGER_LOW | IRQF_ONESHOT),
+ ts->client->name, ts);
+ disable_irq(ts->client->irq);
+ ts->interrupt_state = 0;
+ if (ret < 0) {
+ dev_err(&client->dev, "fail to get irq, ret = 0x%08x",
+ ret);
+ goto hideep_probe_request_irq_err;
+ }
+ }
+
+ ret = hideep_debug_init(ts);
+ if (ret) {
+ dev_err(&client->dev, "fail init debug, ret = 0x%x", ret);
+ ret = -1;
+ goto hideep_probe_debug_init_err;
+ }
+
+ ret = hideep_sysfs_init(ts);
+ if (ret) {
+ dev_err(&client->dev, "fail init sys, ret = 0x%x", ret);
+ ret = -1;
+ goto hideep_probe_sysfs_init_err;
+ }
+
+#ifdef CONFIG_FB
+ ts->suspended = 0;
+ ts->fb_notif.notifier_call = fb_notifier_callback;
+ ret = fb_register_client(&ts->fb_notif);
+ if (ret) {
+ dev_err(&client->dev, "Unable to register fb_notifier: ret = %d",
+ ret);
+ ret = -1;
+ goto hideep_probe_register_fb_err;
+ }
+#endif
+
+
+ ts->dev_state = state_normal;
+ enable_irq(ts->client->irq);
+ ts->interrupt_state = 1;
+
+ dev_info(&client->dev, "probe is ok!");
+ return 0;
+
+hideep_probe_register_fb_err:
+ hideep_sysfs_exit(ts);
+
+hideep_probe_sysfs_init_err:
+ hideep_debug_uninit();
+
+hideep_probe_debug_init_err:
+hideep_probe_request_irq_err:
+ free_irq(ts->client->irq, ts);
+
+hideep_probe_assigned_irq_err:
+hideep_probe_create_thread_err:
+ input_unregister_device(ts->input_dev);
+
+hideep_probe_register_input_dev_err:
+ if (ts->input_dev)
+ input_free_device(ts->input_dev);
+
+hideep_probe_input_dev_memory_err:
+#ifdef HIDEEP_DWZ_VERSION_CHECK
+hideep_probe_read_dwz_err:
+#endif
+
+#ifdef CONFIG_OF
+ ts->hideep_api->power(ts, false);
+#endif
+ dev_err(&client->dev, "probe err!");
+ return ret;
+}
+
+static int hideep_remove(struct i2c_client *client)
+{
+ struct hideep_t *ts = i2c_get_clientdata(client);
+
+ kthread_stop(ts->hthread_event);
+
+#ifdef CONFIG_FB
+ if (fb_unregister_client(&ts->fb_notif))
+ dev_info(&client->dev,
+ "Error occurred while unregistering fb_notifier");
+#endif
+
+#ifdef CONFIG_OF
+ ts->hideep_api->power(ts, false);
+#endif
+ free_irq(client->irq, ts);
+
+ input_unregister_device(ts->input_dev);
+ hideep_sysfs_exit(ts);
+
+ hideep_debug_uninit();
+ devm_kfree(&client->dev, ts);
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static const struct dev_pm_ops hideep_pm_ops = {
+ .suspend = hideep_suspend,
+ .resume = hideep_resume,
+};
+#endif
+
+static const struct i2c_device_id hideep_dev_idtable[] = {
+ { HIDEEP_I2C_NAME, 0 },
+ {}
+};
+MODULE_DEVICE_TABLE(i2c, hideep_dev_idtable);
+
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id hideep_acpi_id[] = {
+ { "HIDP0001", 0 },
+ {}
+};
+MODULE_DEVICE_TABLE(acpi, hideep_acpi_id);
+#endif
+
+#ifdef CONFIG_OF
+static const struct of_device_id hideep_match_table[] = {
+ { .compatible = "hideep,hideep_lime" },
+ { .compatible = "hideep,hideep_crimson" },
+ {},
+};
+MODULE_DEVICE_TABLE(of, hideep_match_table);
+#endif
+
+static struct i2c_driver hideep_driver = {
+ .probe = hideep_probe,
+ .remove = hideep_remove,
+ .id_table = hideep_dev_idtable,
+ .driver = {
+ .name = HIDEEP_I2C_NAME,
+ .owner = THIS_MODULE,
+ .of_match_table = of_match_ptr(hideep_match_table),
+ .acpi_match_table = ACPI_PTR(hideep_acpi_id),
+ .pm = &hideep_pm_ops,
+ },
+};
+
+module_i2c_driver(hideep_driver);
+
+MODULE_DESCRIPTION("Driver for HiDeep Touchscreen Controller");
+MODULE_AUTHOR("anthony.kim@xxxxxxxxxx");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/hideep_dbg.c b/drivers/input/touchscreen/hideep_dbg.c
new file mode 100644
index 0000000..549f2ad2
--- /dev/null
+++ b/drivers/input/touchscreen/hideep_dbg.c
@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#include "hideep.h"
+#include "hideep_isp.h"
+#include "hideep_dbg.h"
+
+static struct hideep_debug_dev_t *hdd;
+
+static int hideep_i2c_recv(unsigned int len)
+{
+ int ret = 0;
+
+ mutex_lock(&hdd->ts->i2c_mutex);
+ ret = i2c_master_recv(hdd->ts->client, hdd->vr_buff, len);
+ mutex_unlock(&hdd->ts->i2c_mutex);
+ if (ret < 0)
+ goto i2c_err;
+
+ dev_info(&hdd->ts->client->dev, "(%d)", len);
+ return ret;
+
+i2c_err:
+ dev_err(&hdd->ts->client->dev, "i2c_err");
+ return ret;
+}
+
+static int hideep_i2c_send(unsigned int len)
+{
+ int ret = 0;
+ unsigned char *buff = hdd->vr_buff;
+
+ mutex_lock(&hdd->ts->i2c_mutex);
+ ret = i2c_master_send(hdd->ts->client, buff, len);
+ mutex_unlock(&hdd->ts->i2c_mutex);
+ if (ret < 0)
+ goto i2c_err;
+
+ dev_info(&hdd->ts->client->dev, "(%d)", len);
+ return ret;
+
+i2c_err:
+ dev_err(&hdd->ts->client->dev, "i2c_err");
+ return ret;
+}
+
+static int hideep_get_vreg(unsigned int addr, unsigned int len)
+{
+ int ret = 0;
+
+ ret = hdd->ts->hideep_api->i2c_read(hdd->ts, addr, len,
+ hdd->vr_buff);
+ if (ret < 0)
+ goto i2c_err;
+
+ dev_dbg(&hdd->ts->client->dev, "(0x%02x:%d)", addr, len);
+ return ret;
+
+i2c_err:
+ dev_err(&hdd->ts->client->dev, "i2c_err");
+ return ret;
+}
+
+static int hideep_set_vreg(unsigned int addr, unsigned int len)
+{
+ int ret = 0;
+ int wr_remain = len;
+ int vr_addr = addr;
+ int wr_len = len;
+ unsigned char *buff = hdd->vr_buff;
+
+ do {
+ if (wr_remain >= MAX_VR_BUFF)
+ wr_len = MAX_VR_BUFF;
+ else
+ wr_len = wr_remain;
+
+ ret = hdd->ts->hideep_api->i2c_write(hdd->ts, vr_addr,
+ wr_len, buff);
+ if (ret < 0)
+ goto i2c_err;
+
+ wr_remain -= MAX_VR_BUFF;
+ vr_addr += MAX_VR_BUFF;
+ buff += MAX_VR_BUFF;
+ } while (wr_remain > 0);
+
+ dev_dbg(&hdd->ts->client->dev, "(0x%02x:%d)", addr, len);
+ return ret;
+
+i2c_err:
+ dev_err(&hdd->ts->client->dev, "i2c_err");
+ return ret;
+}
+
+static int hideep_download_uc(const char __user *uc, size_t count, int offset)
+{
+ int ret;
+ unsigned char *ucode;
+
+ dev_dbg(&hdd->ts->client->dev, "count = %zu", count);
+
+ if (count > hdd->ts->fw_size) {
+ dev_err(&hdd->ts->client->dev, "over size data!!!");
+ return -1;
+ }
+
+ ucode = kmalloc(count, GFP_KERNEL);
+
+ ret = copy_from_user(ucode + offset, uc, count);
+ if (ret < 0) {
+ dev_err(&hdd->ts->client->dev, "ADDR_UC : copy_to_user");
+ kfree(ucode);
+ return 0;
+ }
+
+ disable_irq(hdd->ts->client->irq);
+ hdd->ts->interrupt_state = 0;
+ hdd->ts->hideep_api->update_part(hdd->ts, ucode, count, offset, false);
+ enable_irq(hdd->ts->client->irq);
+ hdd->ts->interrupt_state = 1;
+ kfree(ucode);
+
+ dev_dbg(&hdd->ts->client->dev, "Download_uc(%zu)", count);
+
+ return count;
+}
+
+static int hideep_debug_open(struct inode *inode, struct file *file)
+{
+ hdd->release_flag = false;
+
+ file->private_data = hdd;
+ dev_dbg(&hdd->ts->client->dev, "hideep_debug_open");
+
+ return 0;
+}
+
+static int hideep_debug_release(struct inode *inode, struct file *file)
+{
+ if (!hdd->release_flag)
+ return -1;
+ hdd->release_flag = false;
+ file->private_data = NULL;
+ return 0;
+}
+
+static unsigned int hideep_debug_poll(struct file *file,
+ struct poll_table_struct *wait)
+{
+ unsigned int mask = 0;
+ struct hideep_debug_dev_t *drv_info;
+
+ if (file->private_data == NULL)
+ return 0;
+
+ drv_info = file->private_data;
+
+ poll_wait(file, &drv_info->i_packet, wait);
+
+ if (drv_info->ready) {
+ disable_irq(drv_info->ts->client->irq);
+ drv_info->ts->interrupt_state = 0;
+ mask |= POLLIN | POLLRDNORM;
+ drv_info->ready = 0;
+ }
+
+ return mask;
+}
+
+static ssize_t hideep_debug_read(struct file *file, char __user *buf,
+ size_t count, loff_t *offset)
+{
+ int ret = -1;
+ ssize_t rd_len = 0;
+ unsigned char *rd_buffer = NULL;
+ unsigned char *data = NULL;
+ struct hideep_debug_dev_t *drv_info = file->private_data;
+
+ dev_dbg(&hdd->ts->client->dev, "count = %zu", count);
+
+ if (file->private_data == NULL)
+ return 0;
+
+ drv_info->vr_size = count;
+ rd_len = count;
+
+ data = kmalloc(rd_len, GFP_KERNEL);
+
+ if (*offset <= HIDEEP_VR_ADDR_LEN) {
+ // if offset is not belong to any special command
+ if ((*offset & HIDEEP_MAX_RAW_LEN) &&
+ (*offset < HIDEEP_MAX_RAW_LEN) &&
+ (drv_info->debug_enable == true)) {
+ mutex_lock(&drv_info->ts->dev_mutex);
+ rd_buffer = drv_info->img_buff;
+ ret = 0;
+ mutex_unlock(&drv_info->ts->dev_mutex);
+ } else {
+ ret = hideep_get_vreg(*offset, rd_len);
+ rd_buffer = drv_info->vr_buff;
+ }
+ if (ret < 0)
+ rd_len = 0;
+ } else if (*offset & (HIDEEP_I2C_BYPASS)) {
+ // if offset is belong to special command "i2c bypass"
+ ret = hideep_i2c_recv(rd_len);
+ if (ret < 0) {
+ dev_err(&hdd->ts->client->dev, "ret = %d", ret);
+ rd_len = 0;
+ } else {
+ rd_buffer = drv_info->vr_buff;
+ }
+ } else if (*offset & HIDEEP_NVM_DOWNLOAD) {
+ // if offset is belong to special command "nvm download"
+ rd_len = count;
+ memset(data, 0x0, rd_len);
+
+ disable_irq(drv_info->ts->client->irq);
+ drv_info->ts->interrupt_state = 0;
+ mutex_lock(&drv_info->ts->dev_mutex);
+ mutex_lock(&drv_info->ts->i2c_mutex);
+
+ drv_info->ts->hideep_api->sp_func(drv_info->ts, data, rd_len,
+ *offset & 0xfffff);
+
+ mutex_unlock(&drv_info->ts->dev_mutex);
+ mutex_unlock(&drv_info->ts->i2c_mutex);
+ enable_irq(drv_info->ts->client->irq);
+ drv_info->ts->interrupt_state = 1;
+
+ rd_buffer = data;
+ } else {
+ dev_err(&hdd->ts->client->dev, "undefined address");
+ kfree(data);
+ return 0;
+ }
+
+ ret = copy_to_user(buf, rd_buffer, rd_len);
+
+ if (drv_info->debug_enable == true && drv_info->ready == 0) {
+ enable_irq(drv_info->ts->client->irq);
+ drv_info->ts->interrupt_state = 1;
+ }
+
+ if (ret < 0) {
+ dev_err(&hdd->ts->client->dev, "error : copy_to_user");
+ kfree(data);
+ return -EFAULT;
+ }
+
+ kfree(data);
+ return rd_len;
+}
+
+static ssize_t hideep_debug_write(struct file *file, const char __user *buf,
+ size_t count, loff_t *offset)
+{
+ int ret;
+ struct hideep_debug_dev_t *drv_info = file->private_data;
+ int wr_len = 0;
+
+ dev_dbg(&hdd->ts->client->dev, "count = %zu", count);
+ if (file->private_data == NULL)
+ return 0;
+
+ if (*offset <= HIDEEP_VR_ADDR_LEN) {
+ // if offset is not belong to any special command
+ wr_len = count;
+
+ ret = copy_from_user(drv_info->vr_buff, buf, wr_len);
+ if (ret < 0) {
+ dev_err(&hdd->ts->client->dev, "error : copy_to_user");
+ return -EFAULT;
+ }
+
+ ret = hideep_set_vreg(*offset, wr_len);
+ if (ret < 0)
+ wr_len = 0;
+ } else if (*offset & (HIDEEP_I2C_BYPASS)) {
+ // if offset is belong to special command "i2c bypass"
+ wr_len = count;
+ ret = copy_from_user(drv_info->vr_buff, buf, wr_len);
+ ret = hideep_i2c_send(wr_len);
+ } else if (*offset & HIDEEP_NVM_DOWNLOAD) {
+ // if offset is belong to special command "nvm download"
+ wr_len = hideep_download_uc(buf, count, *offset & 0xfffff);
+ } else {
+ dev_err(&hdd->ts->client->dev,
+ "hideep_write : undefined address, 0x%08x",
+ (int)*offset);
+ return 0;
+ }
+
+ return wr_len;
+}
+
+static loff_t hideep_debug_llseek(struct file *file, loff_t off, int whence)
+{
+ loff_t newpos;
+ struct hideep_debug_dev_t *drv_info = file->private_data;
+
+ dev_dbg(&hdd->ts->client->dev, "off = 0x%08x, whence = %d",
+ (unsigned int)off, whence);
+ if (file->private_data == NULL)
+ return -EFAULT;
+
+ switch (whence) {
+ /* SEEK_SET */
+ case 0:
+ newpos = off;
+ break;
+ /* SEEK_CUR */
+ case 1:
+ dev_dbg(&hdd->ts->client->dev, "set mode off = 0x%08x",
+ (unsigned int)off);
+ if (off & HIDEEP_RELEASE_FLAG) {
+ dev_dbg(&hdd->ts->client->dev, "set release flag");
+ drv_info->release_flag = true;
+ }
+ newpos = file->f_pos;
+ break;
+ /* SEEK_END */
+ case 2:
+ newpos = file->f_pos;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ if (newpos < 0)
+ return -EINVAL;
+
+ file->f_pos = newpos;
+
+ return newpos;
+}
+
+static const struct file_operations hideep_debug_fops = {
+ .owner = THIS_MODULE,
+ .open = hideep_debug_open,
+ .poll = hideep_debug_poll,
+ .release = hideep_debug_release,
+ .read = hideep_debug_read,
+ .write = hideep_debug_write,
+ .llseek = hideep_debug_llseek,
+};
+
+static struct miscdevice hideep_debug_dev = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = HIDEEP_DEBUG_DEVICE_NAME,
+ .fops = &hideep_debug_fops
+};
+
+void hideep_debug_uninit(void)
+{
+ kfree(hdd->vr_buff);
+ kfree(hdd->img_buff);
+
+ misc_deregister(&hideep_debug_dev);
+}
+
+int hideep_debug_init(struct hideep_t *ts)
+{
+ int ret = 0;
+
+ hdd = &ts->debug_dev;
+
+ ret = misc_register(&hideep_debug_dev);
+ if (ret) {
+ dev_err(&ts->client->dev,
+ "hideep debug device register fail!!!");
+ goto fail;
+ }
+
+ init_waitqueue_head(&hdd->i_packet);
+
+ hdd->ts = ts;
+ hdd->debug_enable = false;
+
+ hdd->img_size = 0;
+ hdd->vr_size = 0;
+
+ hdd->vr_buff = kmalloc(MAX_VR_BUFF, GFP_KERNEL);
+ hdd->img_buff = kmalloc(MAX_RAW_SIZE, GFP_KERNEL);
+
+ memset(hdd->vr_buff, 0x0, MAX_VR_BUFF);
+ memset(hdd->img_buff, 0x0, MAX_RAW_SIZE);
+
+ if (!hdd->vr_buff || !hdd->img_buff)
+ goto fail;
+
+ dev_info(&ts->client->dev, "debug init....");
+ return 0;
+
+fail:
+ kfree(hdd->vr_buff);
+ kfree(hdd->img_buff);
+ return ret;
+}
diff --git a/drivers/input/touchscreen/hideep_dbg.h b/drivers/input/touchscreen/hideep_dbg.h
new file mode 100644
index 0000000..f18a09f
--- /dev/null
+++ b/drivers/input/touchscreen/hideep_dbg.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#ifndef _LINUX_HIDEEP_DBG_H
+#define _LINUX_HIDEEP_DBG_H
+
+/* Device Driver <==> Application */
+/* lseek(), write(), read() command */
+#define HIDEEP_RELEASE_FLAG 0x8000
+#define HIDEEP_VR_ADDR_LEN 0xFFFF
+#define HIDEEP_MAX_RAW_LEN 0x3000
+#define HIDEEP_READ_WRITE_VR 0xF000
+#define HIDEEP_I2C_BYPASS 0x20000000
+
+#define MAX_VR_BUFF 2048
+
+/* max tx * max rx * 2 + 8 + 1, 1 is magin size */
+#define MAX_RAW_SIZE 7369
+#endif /* _LINUX_HIDEEP_DBG_H */
diff --git a/drivers/input/touchscreen/hideep_isp.c b/drivers/input/touchscreen/hideep_isp.c
new file mode 100644
index 0000000..c8d2e932
--- /dev/null
+++ b/drivers/input/touchscreen/hideep_isp.c
@@ -0,0 +1,592 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#include "hideep.h"
+#include "hideep_isp.h"
+
+static struct pgm_packet packet_w;
+static struct pgm_packet packet_r;
+
+static int hideep_pgm_w_mem(struct hideep_t *ts, unsigned int addr,
+ struct pgm_packet *packet, unsigned int len)
+{
+ int ret = 0;
+ int i;
+
+ if ((len % 4) != 0)
+ return -1;
+
+ mutex_lock(&ts->i2c_mutex);
+
+ packet->header.w[0] = htonl((0x80 | (len / 4-1)));
+ packet->header.w[1] = htonl(addr);
+
+ for (i = 0; i < NVM_PAGE_SIZE / sizeof(unsigned int); i++)
+ packet->payload[i] = htonl(packet->payload[i]);
+
+ ret = i2c_master_send(ts->client, (unsigned char *)&packet->header.b[3],
+ (len+5));
+
+ if (ret < 0)
+ goto err;
+
+err:
+ mutex_unlock(&ts->i2c_mutex);
+ return ret;
+}
+
+static int hideep_pgm_r_mem(struct hideep_t *ts, unsigned int addr,
+ struct pgm_packet *packet, unsigned int len)
+{
+ int ret = 0;
+ int i;
+
+ if ((len % 4) != 0)
+ return -1;
+
+ mutex_lock(&ts->i2c_mutex);
+
+ packet->header.w[0] = htonl((0x00 | (len / 4-1)));
+ packet->header.w[1] = htonl(addr);
+
+ ret = i2c_master_send(ts->client, (unsigned char *)&packet->header.b[3],
+ 5);
+
+ if (ret < 0)
+ goto err;
+
+ ret = i2c_master_recv(ts->client, (unsigned char *)packet->payload,
+ len);
+
+ if (ret < 0)
+ goto err;
+
+ for (i = 0; i < NVM_PAGE_SIZE / sizeof(unsigned int); i++)
+ packet->payload[i] = htonl(packet->payload[i]);
+
+err:
+ mutex_unlock(&ts->i2c_mutex);
+ return ret;
+}
+
+static int hideep_pgm_r_reg(struct hideep_t *ts, unsigned int addr,
+ unsigned int *val)
+{
+ int ret = 0;
+ struct pgm_packet packet;
+
+ packet.header.w[0] = htonl(0x00);
+ packet.header.w[1] = htonl(addr);
+
+ ret = hideep_pgm_r_mem(ts, addr, &packet, 4);
+
+ if (ret < 0)
+ goto err;
+
+ *val = packet.payload[0];
+
+err:
+ return ret;
+}
+
+static int hideep_pgm_w_reg(struct hideep_t *ts, unsigned int addr,
+ unsigned int data)
+{
+ int ret = 0;
+ struct pgm_packet packet;
+
+ packet.header.w[0] = htonl(0x80);
+ packet.header.w[1] = htonl(addr);
+ packet.payload[0] = data;
+
+ ret = hideep_pgm_w_mem(ts, addr, &packet, 4);
+
+ return ret;
+}
+
+#define SW_RESET_IN_PGM(CLK) \
+{ \
+ hideep_pgm_w_reg(ts, SYSCON_WDT_CNT, CLK); \
+ hideep_pgm_w_reg(ts, SYSCON_WDT_CON, 0x03); \
+ hideep_pgm_w_reg(ts, SYSCON_WDT_CON, 0x01); \
+}
+
+#define SET_FLASH_PIO(CE) \
+ hideep_pgm_w_reg(ts, FLASH_CON, 0x01 | ((CE) << 1))
+#define SET_PIO_SIG(X, Y) \
+ hideep_pgm_w_reg(ts, FLASH_BASE + PIO_SIG + (X), Y)
+#define SET_FLASH_HWCONTROL() \
+ hideep_pgm_w_reg(ts, FLASH_CON, 0x00000000)
+
+#define NVM_W_SFR(x, y) \
+{ \
+ SET_FLASH_PIO(1); \
+ SET_PIO_SIG(x, y); \
+ SET_FLASH_PIO(0); \
+}
+
+static void get_dwz_from_binary(unsigned char *pres,
+ struct dwz_info_t *dwz_info)
+{
+ memcpy(dwz_info, pres + HIDEEP_DWZ_INFO_OFS,
+ sizeof(struct dwz_info_t));
+}
+
+static void hideep_sw_reset(struct hideep_t *ts, unsigned int food)
+{
+ SW_RESET_IN_PGM(food);
+}
+
+static int hideep_enter_pgm(struct hideep_t *ts)
+{
+ int ret = 0;
+ int retry_count = 10;
+ int retry = 0;
+ unsigned int status;
+ unsigned int pattern = 0xDF9DAF39;
+
+ while (retry < retry_count) {
+ i2c_master_send(ts->client, (unsigned char *)&pattern, 4);
+ mdelay(1);
+
+ /* flush invalid Tx load register */
+ hideep_pgm_w_reg(ts, ESI_TX_INVALID, 0x01);
+
+ hideep_pgm_r_reg(ts, SYSCON_PGM_ID, &status);
+
+ if (status != htonl(pattern)) {
+ retry++;
+ dev_err(&ts->client->dev, "enter_pgm : error(%08x):",
+ status);
+ } else {
+ dev_dbg(&ts->client->dev, "found magic code");
+ break;
+ }
+ }
+
+ if (retry < retry_count) {
+ hideep_pgm_w_reg(ts, SYSCON_WDT_CON, 0x00);
+ hideep_pgm_w_reg(ts, SYSCON_SPC_CON, 0x00);
+ hideep_pgm_w_reg(ts, SYSCON_CLK_ENA, 0xFF);
+ hideep_pgm_w_reg(ts, SYSCON_CLK_CON, 0x01);
+ hideep_pgm_w_reg(ts, SYSCON_PWR_CON, 0x01);
+ hideep_pgm_w_reg(ts, FLASH_TIM, 0x03);
+ hideep_pgm_w_reg(ts, FLASH_CACHE_CFG, 0x00);
+ hideep_pgm_w_reg(ts, FLASH_CACHE_CFG, 0x02);
+
+ mdelay(1);
+ } else {
+ ret = -1;
+ }
+
+ return ret;
+}
+
+static int hideep_load_dwz(struct hideep_t *ts)
+{
+ int ret = 0;
+ struct pgm_packet packet_r;
+
+ ret = hideep_enter_pgm(ts);
+
+ mdelay(50);
+
+ ret = hideep_pgm_r_mem(ts, HIDEEP_DWZ_INFO_OFS, &packet_r,
+ sizeof(struct dwz_info_t));
+
+ memcpy((unsigned char *)ts->dwz_info, packet_r.payload,
+ sizeof(struct dwz_info_t));
+ hideep_sw_reset(ts, 10);
+
+ if (ts->dwz_info->product_code & 0x40) {
+ /* Crimson IC */
+ ts->fw_size = 1024 * 48;
+ } else {
+ /* default fw size */
+ ts->fw_size = 1024 * 64;
+ }
+
+ dev_dbg(&ts->client->dev, "firmware release version : %04x",
+ ts->dwz_info->release_ver);
+
+ mdelay(50);
+
+ return ret;
+}
+
+static int hideep_nvm_unlock(struct hideep_t *ts)
+{
+ int ret = 0;
+ unsigned int unmask_code = 0;
+
+ ret = hideep_pgm_w_reg(ts, FLASH_CFG, NVM_SFR_RPAGE);
+
+ ret = hideep_pgm_r_reg(ts, 0x0000000C, &unmask_code);
+
+ ret = hideep_pgm_w_reg(ts, FLASH_CFG, NVM_DEFAULT_PAGE);
+
+ /* make it unprotected code */
+ unmask_code &= (~_PROT_MODE);
+
+ /* compare unmask code */
+ if (unmask_code != NVM_MASK)
+ dev_dbg(&ts->client->dev, "read mask code different 0x%x",
+ unmask_code);
+
+ ret = hideep_pgm_w_reg(ts, FLASH_CFG, NVM_SFR_WPAGE);
+ SET_FLASH_PIO(0);
+
+ NVM_W_SFR(NVM_MASK_OFS, NVM_MASK);
+ SET_FLASH_HWCONTROL();
+ ret = hideep_pgm_w_reg(ts, FLASH_CFG, NVM_DEFAULT_PAGE);
+
+ return ret;
+}
+
+static int hideep_program_page(struct hideep_t *ts,
+ unsigned int addr, struct pgm_packet *packet_w)
+{
+ int ret = 0;
+ unsigned int pio_cmd = WRONLY;
+ unsigned int pio_cmd_page_erase = PERASE;
+ unsigned int status;
+ int time_out = 0;
+ int inf_en = 0;
+ unsigned int end_flag = 124;
+#ifndef PGM_BURST_WR
+ unsigned int i;
+#endif
+
+ hideep_pgm_r_reg(ts, FLASH_STA, &status);
+ ret = (status == 0) ? -1:0;
+
+ addr = addr & ~(NVM_PAGE_SIZE - 1);
+
+ if (addr > INF_SECTION) {
+ /* added INF flag set in pio_cmd */
+ addr -= INF_SECTION;
+ pio_cmd |= INF;
+ pio_cmd_page_erase |= INF;
+ inf_en = 1;
+ }
+
+ SET_FLASH_PIO(0);
+ SET_FLASH_PIO(1);
+
+ /* first erase */
+ SET_PIO_SIG(pio_cmd_page_erase + addr, 0xFFFFFFFF);
+
+ SET_FLASH_PIO(0);
+ time_out = 0;
+
+ while (1) {
+ mdelay(1);
+ hideep_pgm_r_reg(ts, FLASH_STA, &status);
+ if ((status) != 0)
+ break;
+ if (time_out++ > 100)
+ break;
+ }
+ SET_FLASH_PIO(1);
+ /* first erase end*/
+
+ SET_PIO_SIG(pio_cmd + addr, htonl(packet_w->payload[0]));
+
+#ifdef PGM_BURST_WR
+ hideep_pgm_w_mem(ts, (FLASH_BASE + 0x400000) + pio_cmd,
+ packet_w, NVM_PAGE_SIZE);
+#else
+ for (i = 0; i < NVM_PAGE_SIZE / 4; i++)
+ SET_PIO_SIG(pio_cmd + (i<<2), packet_w->payload[i]);
+#endif
+ if (inf_en == 0)
+ SET_PIO_SIG(end_flag, htonl(packet_w->payload[31]));
+ else
+ SET_PIO_SIG(end_flag | INF, htonl(packet_w->payload[31]));
+
+ SET_FLASH_PIO(0);
+
+ mdelay(1);
+
+ while (1) {
+ hideep_pgm_r_reg(ts, FLASH_STA, &status);
+ if ((status) != 0)
+ break;
+ }
+ /* write routine end */
+
+ SET_FLASH_HWCONTROL();
+
+ return ret;
+}
+
+static int hideep_program_nvm(struct hideep_t *ts, const unsigned char *ucode,
+ int len, int offset, unsigned char *old_fw)
+{
+ int i;
+ int ret = 0;
+ int len_r;
+ int len_w;
+ int addr = 0;
+ unsigned int pages;
+
+ ret = hideep_enter_pgm(ts);
+
+ hideep_nvm_unlock(ts);
+
+ pages = (len + NVM_PAGE_SIZE - 1) / NVM_PAGE_SIZE;
+ addr = offset;
+ len_r = len;
+ len_w = len_r;
+
+ dev_dbg(&ts->client->dev, "pages : %d", pages);
+ for (i = 0; i < pages; i++) {
+ if (len_r >= NVM_PAGE_SIZE)
+ len_w = NVM_PAGE_SIZE;
+
+ /* compare */
+ if (old_fw != NULL)
+ ret = memcmp(&ucode[addr], &old_fw[addr], len_w);
+
+ if (ret != 0 || old_fw == NULL) {
+ /* write page */
+ memcpy(packet_w.payload, &(ucode[addr]), len_w);
+
+ ret = hideep_program_page(ts, addr, &packet_w);
+ mdelay(1);
+ if (ret < 0)
+ dev_err(&ts->client->dev,
+ "hideep_program_nvm : error(%08x):",
+ addr);
+ }
+
+ addr += NVM_PAGE_SIZE;
+ len_r -= NVM_PAGE_SIZE;
+ len_w = len_r;
+ }
+
+ return ret;
+}
+
+static int hideep_verify_nvm(struct hideep_t *ts, const unsigned char *ucode,
+ int len, int offset)
+{
+ int i, j;
+ int ret = 0;
+ unsigned char page_chk = 0;
+ unsigned int addr = offset;
+ unsigned int pages = (len + NVM_PAGE_SIZE - 1) / NVM_PAGE_SIZE;
+ int len_r = len;
+ int len_v = len_r;
+
+ for (i = 0; i < pages; i++) {
+ if (len_r >= NVM_PAGE_SIZE)
+ len_v = NVM_PAGE_SIZE;
+
+#ifdef PGM_BURST_WR
+ hideep_pgm_r_mem(ts, 0x00000000 + addr, &packet_r,
+ NVM_PAGE_SIZE);
+#else
+ for (j = 0; j < (NVM_PAGE_SIZE >> 2); j++)
+ hideep_pgm_r_reg(ts, addr + (j << 2),
+ &(packet_r.payload[j]));
+#endif
+ page_chk = memcmp(&(ucode[addr]), packet_r.payload, len_v);
+
+ if (page_chk != 0) {
+ u8 *read = (u8 *)packet_r.payload;
+
+ for (j = 0; j < NVM_PAGE_SIZE; j++)
+ dev_err(&ts->client->dev, "%02x : %02x",
+ ucode[addr+j], read[j]);
+
+ dev_err(&ts->client->dev, "verify : error(addr : %d)",
+ addr);
+
+ ret = -1;
+ }
+
+ addr += NVM_PAGE_SIZE;
+ len_r -= NVM_PAGE_SIZE;
+ len_v = len_r;
+ }
+
+ return ret;
+}
+
+static void hideep_read_nvm(struct hideep_t *ts, unsigned char *data, int len,
+ int offset)
+{
+ int ret = 0;
+ int pages, i;
+ int len_r, len_v;
+ int addr = offset;
+#ifndef PGM_BURST_WR
+ int j;
+#endif
+
+ pages = (len + NVM_PAGE_SIZE - 1) / NVM_PAGE_SIZE;
+ len_r = len;
+ len_v = len_r;
+
+ ts->hideep_api->reset_ic(ts);
+
+ ret = hideep_enter_pgm(ts);
+
+ hideep_nvm_unlock(ts);
+
+ for (i = 0; i < pages; i++) {
+ if (len_r >= NVM_PAGE_SIZE)
+ len_v = NVM_PAGE_SIZE;
+
+#ifdef PGM_BURST_WR
+ hideep_pgm_r_mem(ts, 0x00000000 + addr, &packet_r,
+ NVM_PAGE_SIZE);
+#else
+ for (j = 0; j < NVM_PAGE_SIZE / 4; j++)
+ hideep_pgm_r_reg(ts, addr + (j << 2),
+ &(packet_r.payload[j]));
+#endif
+ memcpy(&(data[i * NVM_PAGE_SIZE]), &packet_r.payload[0], len_v);
+
+ addr += NVM_PAGE_SIZE;
+ len_r -= NVM_PAGE_SIZE;
+ len_v = len_r;
+ }
+
+ hideep_sw_reset(ts, 1000);
+}
+
+static int hideep_fw_verify_run(struct hideep_t *ts, unsigned char *fw,
+ size_t len, int offset)
+{
+ int ret = 0;
+ int retry = 3;
+
+ while (retry--) {
+ ret = hideep_verify_nvm(ts, fw, len, offset);
+ if (ret == 0) {
+ dev_dbg(&ts->client->dev, "update success");
+ break;
+ }
+ dev_err(&ts->client->dev, "download fw failed(%d)", retry);
+ }
+
+ ret = (retry == 0) ? -1:0;
+
+ return ret;
+}
+
+static int hideep_wr_firmware(struct hideep_t *ts, unsigned char *code,
+ int len, int offset, bool mode)
+{
+ int ret = 0;
+ int firm_len;
+ unsigned char *ic_fw;
+ unsigned char *dwz_info;
+
+ ic_fw = kmalloc(ts->fw_size, GFP_KERNEL);
+ dwz_info = kmalloc(sizeof(struct dwz_info_t) + 64, GFP_KERNEL);
+
+ memset(dwz_info, 0x0, sizeof(struct dwz_info_t) + 64);
+
+ firm_len = len;
+ dev_dbg(&ts->client->dev, "fw len : %d, define size : %d",
+ firm_len, ts->fw_size);
+
+ if (firm_len > ts->fw_size)
+ firm_len = ts->fw_size;
+
+ dev_dbg(&ts->client->dev, "enter");
+ /* memory dump of target IC */
+ hideep_read_nvm(ts, ic_fw, firm_len, offset);
+ /* comparing & programming each page, if the memory of specified
+ * page is exactly same, no need to update.
+ */
+ ret = hideep_program_nvm(ts, code, firm_len, offset, ic_fw);
+
+#ifdef PGM_VERIFY
+ hideep_fw_verify_run(ts, code, firm_len, offset);
+ if (ret < 0) {
+ if (mode == true) {
+ /* clear dwz version, it will be store once again
+ * after update success
+ */
+ ts->dwz_info->release_ver = 0;
+ memcpy(&dwz_info[64], ts->dwz_info,
+ sizeof(struct dwz_info_t));
+ ret = hideep_program_nvm(ts, dwz_info, HIDEEP_DWZ_LEN,
+ 0x280, NULL);
+ }
+ }
+#endif
+ get_dwz_from_binary(code, ts->dwz_info);
+
+ hideep_sw_reset(ts, 1000);
+
+ kfree(ic_fw);
+ kfree(dwz_info);
+
+ return ret;
+}
+
+static int hideep_update_all_firmware(struct hideep_t *ts, const char *fn)
+{
+ int ret = 0;
+ const struct firmware *fw_entry;
+ unsigned char *fw_buf;
+ unsigned int fw_length;
+
+ dev_dbg(&ts->client->dev, "enter");
+ ret = request_firmware(&fw_entry, fn, &ts->client->dev);
+
+ if (ret != 0) {
+ dev_err(&ts->client->dev, "request_firmware : fail(%d)", ret);
+ return ret;
+ }
+
+ fw_buf = (unsigned char *)fw_entry->data;
+ fw_length = (unsigned int)fw_entry->size;
+
+ /* chip specific code for flash fuse */
+ mutex_lock(&ts->dev_mutex);
+
+ ts->dev_state = state_updating;
+
+ ret = hideep_wr_firmware(ts, fw_buf, fw_length, 0, true);
+
+ ts->dev_state = state_normal;
+
+ mutex_unlock(&ts->dev_mutex);
+
+ release_firmware(fw_entry);
+
+ return ret;
+}
+
+static int hideep_update_part_firmware(struct hideep_t *ts,
+ unsigned char *code, int len, int offset, bool mode)
+{
+ int ret = 0;
+
+ mutex_lock(&ts->dev_mutex);
+
+ ret = hideep_wr_firmware(ts, code, len, offset, false);
+
+ mutex_unlock(&ts->dev_mutex);
+
+ return ret;
+}
+
+void hideep_isp_init(struct hideep_t *ts)
+{
+ ts->hideep_api->update_all = hideep_update_all_firmware;
+ ts->hideep_api->update_part = hideep_update_part_firmware;
+ ts->hideep_api->get_dwz_info = hideep_load_dwz;
+ ts->hideep_api->sp_func = hideep_read_nvm;
+}
diff --git a/drivers/input/touchscreen/hideep_isp.h b/drivers/input/touchscreen/hideep_isp.h
new file mode 100644
index 0000000..648f271
--- /dev/null
+++ b/drivers/input/touchscreen/hideep_isp.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#ifndef _LINUX_HIDEEP_ISP_H
+#define _LINUX_HIDEEP_ISP_H
+
+#define PGM_BURST_WR
+#define PGM_VERIFY
+
+#define NVM_DEFAULT_PAGE 0
+#define NVM_SFR_WPAGE 1
+#define NVM_SFR_RPAGE 2
+
+#define PIO_SIG 0x00400000
+#define _PROT_MODE 0x03400000
+
+#define NVM_PAGE_SIZE 128
+
+#define HIDEEP_NVM_DOWNLOAD 0x10000000
+
+/*************************************************************************
+ * register map
+ *************************************************************************/
+#define YRAM_BASE 0x40000000
+#define PERIPHERAL_BASE 0x50000000
+#define ESI_BASE (PERIPHERAL_BASE + 0x00000000)
+#define FLASH_BASE (PERIPHERAL_BASE + 0x01000000)
+#define SYSCON_BASE (PERIPHERAL_BASE + 0x02000000)
+
+#define SYSCON_MOD_CON (SYSCON_BASE + 0x0000)
+#define SYSCON_SPC_CON (SYSCON_BASE + 0x0004)
+#define SYSCON_CLK_CON (SYSCON_BASE + 0x0008)
+#define SYSCON_CLK_ENA (SYSCON_BASE + 0x000C)
+#define SYSCON_RST_CON (SYSCON_BASE + 0x0010)
+#define SYSCON_WDT_CON (SYSCON_BASE + 0x0014)
+#define SYSCON_WDT_CNT (SYSCON_BASE + 0x0018)
+#define SYSCON_PWR_CON (SYSCON_BASE + 0x0020)
+#define SYSCON_PGM_ID (SYSCON_BASE + 0x00F4)
+
+#define FLASH_CON (FLASH_BASE + 0x0000)
+#define FLASH_STA (FLASH_BASE + 0x0004)
+#define FLASH_CFG (FLASH_BASE + 0x0008)
+#define FLASH_TIM (FLASH_BASE + 0x000C)
+#define FLASH_CACHE_CFG (FLASH_BASE + 0x0010)
+
+#define ESI_TX_INVALID (ESI_BASE + 0x0008)
+
+/*************************************************************************
+ * flash commands
+ *************************************************************************/
+#define MERASE 0x00010000
+#define SERASE 0x00020000
+#define PERASE 0x00040000
+#define PROG 0x00080000
+#define WRONLY 0x00100000
+#define INF 0x00200000
+
+/*************************************************************************
+ * NVM Mask
+ *************************************************************************/
+#ifdef CONFIG_TOUCHSCREEN_HIDEEP_CRIMSON
+#define NVM_MASK_OFS 0x0000000C
+#define NVM_MASK 0x00310000
+#define INF_SECTION 0x0000C000
+#endif
+#ifdef CONFIG_TOUCHSCREEN_HIDEEP_LIME
+#define NVM_MASK_OFS 0x0000000C
+#define NVM_MASK 0x0030027B
+#define INF_SECTION 0x00010000
+#endif
+
+/*************************************************************************
+ * DWZ info
+ *************************************************************************/
+#define HIDEEP_BOOT_SECTION 0x00000400
+#define HIDEEP_BOOT_LEN 0x00000400
+#define HIDEEP_DWZ_SECTION 0x00000280
+#define HIDEEP_DWZ_INFO_OFS 0x000002C0
+#define HIDEEP_DWZ_LEN (HIDEEP_BOOT_SECTION \
+ - HIDEEP_DWZ_SECTION)
+
+struct pgm_packet {
+ union {
+ unsigned char b[8];
+ unsigned int w[2];
+ } header;
+
+ unsigned int payload[NVM_PAGE_SIZE / sizeof(unsigned int)];
+};
+
+#endif /* _LINUX_HIDEEP_ISP_H */
diff --git a/drivers/input/touchscreen/hideep_sysfs.c b/drivers/input/touchscreen/hideep_sysfs.c
new file mode 100644
index 0000000..7f28fb4
--- /dev/null
+++ b/drivers/input/touchscreen/hideep_sysfs.c
@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2012-2017 Hideep, 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 Foudation.
+ */
+
+#include "hideep.h"
+
+static ssize_t update_fw(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int mode, ret;
+ char *fw_name;
+
+ ret = kstrtoint(buf, 8, &mode);
+ if (ret)
+ return ret;
+
+ if (mode == 1) {
+ disable_irq(ts->client->irq);
+
+ ts->dev_state = state_updating;
+ fw_name = kasprintf(GFP_KERNEL, "hideep_ts_%04x.bin",
+ ts->dwz_info->product_id);
+ ret = ts->hideep_api->update_all(ts, fw_name);
+
+ kfree(fw_name);
+
+ enable_irq(ts->client->irq);
+
+ ts->dev_state = state_normal;
+ if (ret != 0)
+ dev_err(dev, "The firmware update failed(%d)", ret);
+ }
+
+ return count;
+}
+
+static ssize_t fw_version_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ int len = 0;
+ struct hideep_t *ts = dev_get_drvdata(dev);
+
+ dev_info(dev, "release version : %04x",
+ ts->dwz_info->release_ver);
+
+ mutex_lock(&ts->dev_mutex);
+ len = scnprintf(buf, PAGE_SIZE,
+ "%04x\n", ts->dwz_info->release_ver);
+ mutex_unlock(&ts->dev_mutex);
+
+ return len;
+}
+
+static ssize_t product_id_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ int len = 0;
+ struct hideep_t *ts = dev_get_drvdata(dev);
+
+ dev_info(dev, "product id : %04x",
+ ts->dwz_info->product_id);
+
+ mutex_lock(&ts->dev_mutex);
+ len = scnprintf(buf, PAGE_SIZE,
+ "%04x\n", ts->dwz_info->product_id);
+ mutex_unlock(&ts->dev_mutex);
+
+ return len;
+}
+
+static ssize_t power_status(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int len;
+
+ len = scnprintf(buf, PAGE_SIZE, "power status : %s\n",
+ (ts->dev_state == state_init) ? "off" : "on");
+
+ return len;
+}
+
+static ssize_t power_control(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int on, ret;
+
+ ret = kstrtoint(buf, 8, &on);
+ if (ret)
+ return ret;
+
+ if (on) {
+ ts->hideep_api->power(ts, on);
+ ts->dev_state = state_normal;
+ ts->hideep_api->reset_ic(ts);
+ } else {
+ ts->hideep_api->power(ts, on);
+ ts->dev_state = state_init;
+ }
+
+ return count;
+}
+
+#ifdef HIDEEP_SUPPORT_STYLUS
+static ssize_t stylus_status(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int len;
+ unsigned char status[1];
+
+ ts->hideep_api->i2c_read(ts, 0xB00C, 1, status);
+
+ len = scnprintf(buf, PAGE_SIZE, "stylus mode enable : %s\n",
+ (status[0] == 0x00) ? "off" : "on");
+
+ return len;
+}
+
+static ssize_t stylus_enable(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int on, ret;
+ unsigned char data[2];
+
+ ret = kstrtoint(buf, 8, &on);
+ if (ret)
+ return ret;
+
+ data[0] = 0x04;
+
+ if (on) {
+ data[1] = 0x01;
+ ts->hideep_api->i2c_write(ts, HIDEEP_SWTICH_CMD, 2, data);
+ } else {
+ data[1] = 0x00;
+ ts->hideep_api->i2c_write(ts, HIDEEP_SWTICH_CMD, 2, data);
+ }
+
+ return count;
+}
+#endif
+
+static ssize_t debug_status(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int len;
+
+ len = scnprintf(buf, PAGE_SIZE, "debug mode : %s\n",
+ (ts->debug_dev.debug_enable == 0) ? "off" : "on");
+
+ return len;
+}
+
+static ssize_t debug_mode(struct device *dev, struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct hideep_t *ts = dev_get_drvdata(dev);
+ int on, ret;
+ unsigned char data[2];
+
+ ret = kstrtoint(buf, 8, &on);
+ if (ret)
+ return ret;
+
+ if (on) {
+ ts->debug_dev.debug_enable = 1;
+ ts->dev_state = state_debugging;
+ } else {
+ ts->debug_dev.debug_enable = 0;
+ ts->dev_state = state_normal;
+ /* set touch mode */
+ data[0] = 0x00;
+ data[1] = 0x00;
+ ts->hideep_api->i2c_write(ts, HIDEEP_OPMODE_CMD, 2, data);
+ if (ts->interrupt_state == 0) {
+ data[0] = 0x5A;
+ ts->hideep_api->i2c_write(ts, HIDEEP_INTCLR_CMD, 1,
+ data);
+ enable_irq(ts->client->irq);
+ ts->interrupt_state = 1;
+ }
+ }
+
+ return count;
+}
+
+static DEVICE_ATTR(update_fw, 0664, NULL, update_fw);
+static DEVICE_ATTR(version, 0664, fw_version_show, NULL);
+static DEVICE_ATTR(product_id, 0664, product_id_show, NULL);
+static DEVICE_ATTR(power_en, 0664, power_status, power_control);
+static DEVICE_ATTR(debug_en, 0664, debug_status, debug_mode);
+#ifdef HIDEEP_SUPPORT_STYLUS
+static DEVICE_ATTR(stylus_en, 0664, stylus_status, stylus_enable);
+#endif
+
+static struct attribute *hideep_ts_sysfs_entries[] = {
+ &dev_attr_update_fw.attr,
+ &dev_attr_version.attr,
+ &dev_attr_product_id.attr,
+ &dev_attr_power_en.attr,
+ &dev_attr_debug_en.attr,
+#ifdef HIDEEP_SUPPORT_STYLUS
+ &dev_attr_stylus_en.attr,
+#endif
+ NULL
+};
+
+static struct attribute_group hideep_ts_attr_group = {
+ .attrs = hideep_ts_sysfs_entries,
+};
+
+int hideep_sysfs_init(struct hideep_t *ts)
+{
+ int ret;
+ struct i2c_client *client = ts->client;
+
+ /* Create the files associated with this kobject */
+ ret = sysfs_create_group(&client->dev.kobj, &hideep_ts_attr_group);
+
+ dev_info(&ts->client->dev, "device : %s ", client->dev.kobj.name);
+
+ if (ret)
+ dev_err(&ts->client->dev, "%s: Fail create link error = %d\n",
+ __func__, ret);
+
+ return ret;
+}
+
+int hideep_sysfs_exit(struct hideep_t *ts)
+{
+ struct i2c_client *client = ts->client;
+
+ sysfs_remove_group(&client->dev.kobj, &hideep_ts_attr_group);
+
+ return 0;
+}
--
2.7.4
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
