tegrakernel/kernel/nvidia/drivers/input/touchscreen/exc80_ts_usb.c

/*
 *
 * Touch Screen USB Driver for EETI Controller
 *
 * Copyright (C) 2000-2018  eGalax_eMPIA Technology Inc. All rights reserved.
 * Copyright (c) 2018 NVIDIA CORPORATION. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 */

#define RELEASE_DATE "2018/04/27"

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/wait.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/usb.h>
#include <linux/usb/input.h>
#include <linux/hid.h>
#include <linux/uaccess.h>
#include <linux/kfifo.h>
#include <linux/version.h>
#include <linux/input.h>
#include <linux/timer.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/input/mt.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/regulator/consumer.h>

#define EETI_USB_DEVICE_ID	0x0EEF
#define EETI_USB_PRODUCT_ID	0xCC01
#define EETI_USB_BL_PRODUCT_ID	0x79FD

#define MAX_EVENTS		600
#define MAX_USB_LEN		64U
#define FIFO_SIZE		8192
#define MAX_SUPPORT_POINT	16
#define REPORTID_VENDOR		0x03
#define REPORTID_MTOUCH		0x06
#define MAX_RESOLUTION		4095
#define MAX_Z_RESOLUTION	1023

struct tag_mt_contacts {
	unsigned char id;
	signed char status;
	unsigned short x;
	unsigned short y;
	unsigned short z;
};

struct _egalax_usb {
	unsigned char *data;
	dma_addr_t data_dma;
	unsigned char *buffer;
	int buf_len;
	struct urb *irq;
	struct usb_device *udev;
	struct usb_interface *interface;
	unsigned char work_state;
	unsigned char down_cnt;
	char phys[128];
	wait_queue_head_t sysfs_query_queue;
	bool sysfs_query_wait;
	unsigned char sysfs_hook_cmd[3];
	unsigned char sysfs_cmd_result[MAX_USB_LEN];
};

struct egalax_char_dev {
	int open_cnts;
	struct kfifo data_kfifo;
	unsigned char *p_fifo_buf;
	spinlock_t fifo_lock;
	struct semaphore sem;
	wait_queue_head_t fifo_inq;
};

static struct _egalax_usb *p_egalax_usb_dev;
static struct egalax_char_dev *p_char_dev;
static atomic_t egalax_char_available = ATOMIC_INIT(1);
static atomic_t wait_command_ack = ATOMIC_INIT(0);
static struct input_dev *input_dev;
static struct tag_mt_contacts p_contact_buf[MAX_SUPPORT_POINT];
static char fifo_read_buf[MAX_USB_LEN];
static int total_pts_cnt, recv_pts_cnt;
static bool misc_registered;
static bool sysfs_created;

/* DT for platform */
int g_reset_gpio;
bool g_enable_high;
struct regulator *g_regulator_hv;
struct regulator *g_regulator_5v0;
struct regulator *g_regulator_3v3;
struct regulator *g_regulator_1v8;
bool g_flip_x;
bool g_flip_y;

#define DBG_MODULE	0x00000001U
#define DBG_CDEV	0x00000002U
#define DBG_PROC	0x00000004U
#define DBG_POINT	0x00000008U
#define DBG_INT		0x00000010U
#define DBG_USB		0x00000020U
#define DBG_SUSP	0x00000040U
#define DBG_INPUT	0x00000080U
#define DBG_CONST	0x00000100U
#define DBG_IDLE	0x00000200U
#define DBG_WAKEUP	0x00000400U
#define DBG_BUTTON	0x00000800U
static unsigned int dbg_level = DBG_MODULE|DBG_SUSP;

#define PROC_FS_NAME	"egalax_dbg"
#define PROC_FS_MAX_LEN	8
static struct proc_dir_entry *p_dbg_proc_file;

#define EGALAX_DBG(level, fmt, args...) \
do { if ((level & dbg_level) > 0U) { \
pr_debug("egalax_usb: " fmt, ## args); } \
} while (false)

#define EETI_HID_SET_REPORT_VALUE	0x203
static int send_usb_data(struct _egalax_usb *egalax_usb, unsigned char *buf,
			 int len)
{
	int ret;
	struct usb_interface *intf = egalax_usb->interface;

	ret = usb_control_msg(egalax_usb->udev,
		usb_sndctrlpipe(egalax_usb->udev, 0),
		HID_REQ_SET_REPORT,
		USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE,
		EETI_HID_SET_REPORT_VALUE,
		intf->cur_altsetting->desc.bInterfaceNumber,
		buf, len, USB_CTRL_SET_TIMEOUT);

	if (ret < 0) {
		EGALAX_DBG(DBG_MODULE,
		"Can't send data to device with err:%d\n", ret);
	}
	return ret;
}

static void run_fw_init(struct _egalax_usb *egalax_usb)
{
	unsigned char *buf;
	char retry = 3, ret = 0;

	buf = kzalloc(3, GFP_NOIO);
	if (buf == NULL) {
		EGALAX_DBG(DBG_MODULE, " Can't alloc buffer to do FW init\n");
		return;
	}

	while (retry--) {
		buf[0] = 0x05; buf[1] = 0x02; buf[2] = 0x00;
		ret = send_usb_data(egalax_usb, buf, 3);
		if (ret < 0) {
			EGALAX_DBG(DBG_MODULE,
			" Send FW init command failed!\n");
		} else
			break;
	}

	if (ret < 0)
		EGALAX_DBG(DBG_MODULE, " %s faiiled!\n", __func__);
	else
		EGALAX_DBG(DBG_MODULE, " %s done!\n", __func__);

	kfree(buf);
}

static int egalax_cdev_open(struct inode *inode, struct file *filp)
{
	if (!atomic_dec_and_test(&egalax_char_available)) {
		atomic_inc(&egalax_char_available);
		return -EBUSY;
	}

	p_char_dev->open_cnts++;
	filp->private_data = p_char_dev;

	EGALAX_DBG(DBG_CDEV, " CDev open done!\n");
	try_module_get(THIS_MODULE);
	return 0;
}

static int egalax_cdev_release(struct inode *inode, struct file *filp)
{
	struct egalax_char_dev *cdev = filp->private_data;

	atomic_inc(&egalax_char_available);

	cdev->open_cnts--;

	kfifo_reset(&cdev->data_kfifo);

	EGALAX_DBG(DBG_CDEV, " CDev release done!\n");
	module_put(THIS_MODULE);
	return 0;
}

static ssize_t egalax_cdev_read(struct file *file, char __user *buf,
				size_t count, loff_t *offset)
{
	int read_cnt, ret, fifo_len;
	struct egalax_char_dev *cdev = file->private_data;

	if (down_interruptible(&cdev->sem))
		return -ERESTARTSYS;

	fifo_len = kfifo_len(&cdev->data_kfifo);

	while (fifo_len < 1) {
		/* release the lock */
		up(&cdev->sem);
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;

		if (wait_event_interruptible(cdev->fifo_inq,
					kfifo_len(&cdev->data_kfifo) > 0)) {
			/* signal: tell the fs layer to handle it */
			return -ERESTARTSYS;
		}

		if (down_interruptible(&cdev->sem))
			return -ERESTARTSYS;
	}

	if (count > MAX_USB_LEN)
		count = MAX_USB_LEN;

	read_cnt = kfifo_out_locked(&cdev->data_kfifo, fifo_read_buf, count,
				    &cdev->fifo_lock);

	EGALAX_DBG(DBG_CDEV, " \"%s\" reading fifo data count=%d\n",
		   current->comm, read_cnt);

	ret = copy_to_user(buf, fifo_read_buf, read_cnt) ? -EFAULT : read_cnt;

	up(&cdev->sem);

	return ret;
}

static ssize_t egalax_cdev_write(struct file *file, const char __user *buf,
				 size_t count, loff_t *offset)
{
	struct egalax_char_dev *cdev = file->private_data;
	int ret = 0;
	char *tmp;

	if (p_egalax_usb_dev == NULL)
		return -ENODEV;

	if (down_interruptible(&cdev->sem))
		return -ERESTARTSYS;

	if (count > MAX_USB_LEN)
		count = MAX_USB_LEN;

	tmp = kzalloc(MAX_USB_LEN, GFP_NOIO);
	if (tmp == NULL) {
		up(&cdev->sem);
		return -ENOMEM;
	}

	if (copy_from_user(tmp, buf, count)) {
		up(&cdev->sem);
		kfree(tmp);
		return -EFAULT;
	}

	ret = send_usb_data(p_egalax_usb_dev, tmp, MAX_USB_LEN);

	up(&cdev->sem);
	EGALAX_DBG(DBG_CDEV, " USB writing %d bytes.\n", ret);
	kfree(tmp);

	return (ret < 0 ? -1 : count);
}

static unsigned int egalax_cdev_poll(struct file *filp,
				     struct poll_table_struct *wait)
{
	struct egalax_char_dev *cdev = filp->private_data;
	unsigned int mask = 0;
	int fifo_len;

	down(&cdev->sem);
	poll_wait(filp, &cdev->fifo_inq,  wait);

	fifo_len = kfifo_len(&cdev->data_kfifo);

	if (fifo_len > 0)
		mask |= POLLIN | POLLRDNORM;

	if ((FIFO_SIZE - fifo_len) > MAX_USB_LEN)
		mask |= POLLOUT | POLLWRNORM;

	up(&cdev->sem);
	return mask;
}

static int egalax_proc_show(struct seq_file *seqfilp, void *v)
{
	seq_printf(seqfilp,
	"EETI USB for All Points.\nDebug Level: 0x%08X\nRelease Date: %s\n",
	dbg_level, RELEASE_DATE);

	return 0;
}

static int egalax_proc_open(struct inode *inode, struct file *filp)
{
	EGALAX_DBG(DBG_PROC, " \"%s\" call proc_open\n", current->comm);
	return single_open(filp, egalax_proc_show, NULL);
}

static ssize_t egalax_proc_write(struct file *file, const char __user *buf,
				 size_t count, loff_t *offset)
{
	char procfs_buffer_size = 0;
	unsigned char procfs_buf[PROC_FS_MAX_LEN+1] = {0};
	unsigned int new_level = 0;

	EGALAX_DBG(DBG_PROC, " \"%s\" call proc_write\n", current->comm);

	procfs_buffer_size = count;
	if (procfs_buffer_size > PROC_FS_MAX_LEN)
		procfs_buffer_size = PROC_FS_MAX_LEN+1;

	if (copy_from_user(procfs_buf, buf, procfs_buffer_size)) {
		EGALAX_DBG(DBG_PROC, " proc_write faied at copy_from_user\n");
		return -EFAULT;
	}

	if (!kstrtouint(procfs_buf, 16, &new_level))
		dbg_level = new_level;

	EGALAX_DBG(DBG_PROC, " Switch Debug Level to 0x%08X\n", dbg_level);

	return procfs_buffer_size;
}

static bool sys_sendcmd_wait(unsigned char *by_send_cmd, int n_send_cmd_len,
			     unsigned char *by_hook_cmd, int n_hook_cmd_len,
			     int nTimeOut)
{
	int i;
	bool b_ret = true;

	if (p_egalax_usb_dev == NULL)
		return false;

	memset(p_egalax_usb_dev->sysfs_cmd_result, 0,
		sizeof(p_egalax_usb_dev->sysfs_cmd_result));

	for (i = 0; i < 3; i++) {
		if (i < n_hook_cmd_len)
			p_egalax_usb_dev->sysfs_hook_cmd[i] = by_hook_cmd[i];
		else
			p_egalax_usb_dev->sysfs_hook_cmd[i] = 0xFF;
	}
	p_egalax_usb_dev->sysfs_query_wait = true;

	if (send_usb_data(p_egalax_usb_dev, by_send_cmd, n_send_cmd_len) < 0) {
		b_ret = false;
	} else {
		wait_event_interruptible_timeout(
			p_egalax_usb_dev->sysfs_query_queue,
			!p_egalax_usb_dev->sysfs_query_wait,
			nTimeOut);

		if (p_egalax_usb_dev->sysfs_query_wait)
			b_ret = false;
		else
			b_ret = true;
	}
	p_egalax_usb_dev->sysfs_query_wait = false;
	return b_ret;
}

#define OP_MODE_GET     0x00
#define OP_MODE_SET     0x01
static ssize_t sys_show_version(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x04, 0x36, 0x91, 0x01, OP_MODE_GET};
	bool b_ret = true;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret)
		return snprintf(buf, PAGE_SIZE, "Driver: %s  FW: %s\n",
			RELEASE_DATE, p_egalax_usb_dev->sysfs_cmd_result+6);
	else
		return snprintf(buf, PAGE_SIZE, "Driver: %s  FW: Invalid\n",
			RELEASE_DATE);
}

static ssize_t sys_show_touchevent(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x04, 0x36, 0x91, 0x02, OP_MODE_GET};
	bool b_ret = true;
	int code = 0;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret) {
		code = p_egalax_usb_dev->sysfs_cmd_result[6];
		code += (p_egalax_usb_dev->sysfs_cmd_result[7]<<8);
		code += (p_egalax_usb_dev->sysfs_cmd_result[8]<<16);
		code += (p_egalax_usb_dev->sysfs_cmd_result[9]<<24);
		return snprintf(buf, PAGE_SIZE, "0x%08X\n", code);
	} else
		return snprintf(buf, PAGE_SIZE, "Invalid\n");
}

static ssize_t sys_show_reportmode(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x04, 0x36, 0x91, 0x04, OP_MODE_GET};
	bool b_ret = true;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret)
		return snprintf(buf, PAGE_SIZE, "%02X\n",
			p_egalax_usb_dev->sysfs_cmd_result[6]);
	else
		return snprintf(buf, PAGE_SIZE, "Invalid\n");
}

#define NV_REPORTMODE_MAX  0x06
static ssize_t sys_store_reportmode(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x05, 0x36, 0x91, 0x04, OP_MODE_SET};
	bool b_ret = true;
	char mode;

	if (count != 2)
		return -EINVAL;

	mode = buf[0] - '0';
	if (mode > NV_REPORTMODE_MAX || mode < 0)
		return -EINVAL;

	send_cmd_buf[6] = mode;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret)
		return count;
	else
		return -EIO;
}

static ssize_t sys_show_bypassmode(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x04, 0x36, 0x91, 0x05, OP_MODE_GET};
	bool b_ret = true;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret)
		return snprintf(buf, PAGE_SIZE, "%02X\n",
			p_egalax_usb_dev->sysfs_cmd_result[6]);
	else
	return snprintf(buf, PAGE_SIZE, "Invalid\n");
}

#define NV_BYPASSMODE_MAX  0x02
static ssize_t sys_store_bypassmode(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x05, 0x36, 0x91, 0x05, OP_MODE_SET};
	bool b_ret = true;
	char mode;

	if (count != 2)
		return -EINVAL;

	mode = buf[0]-'0';
	if (mode > NV_BYPASSMODE_MAX || mode < 0)
	return -EINVAL;

	send_cmd_buf[6] = mode;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret)
		return count;
	else
		return -EIO;
}

static ssize_t sys_show_calibration(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
			0x03, 0x02, 0x3F, 0x4E};
	bool b_ret = true;
	unsigned int status = 0;

	b_ret = sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN,
				 send_cmd_buf+2, 3, HZ);
	if (b_ret) {
		status = p_egalax_usb_dev->sysfs_cmd_result[4];
		status += p_egalax_usb_dev->sysfs_cmd_result[5]<<8;
		if (status&0x00000100)
			return sprintf(buf, "0xff\n");
		else
			return sprintf(buf, "0x00\n");
	} else
		return sprintf(buf, "0x00\n");
}

static DEVICE_ATTR(version, 0440, sys_show_version, NULL);
static DEVICE_ATTR(touch_event, 0440, sys_show_touchevent, NULL);
static DEVICE_ATTR(report_mode, 0640, sys_show_reportmode,
		sys_store_reportmode);
static DEVICE_ATTR(bypass_mode, 0640, sys_show_bypassmode,
		sys_store_bypassmode);
static DEVICE_ATTR(calibration, 0440, sys_show_calibration, NULL);

static struct attribute *egalax_attributes[] = {
	&dev_attr_version.attr,
	&dev_attr_touch_event.attr,
	&dev_attr_report_mode.attr,
	&dev_attr_bypass_mode.attr,
	&dev_attr_calibration.attr,
	NULL,
};

static const struct attribute_group egalax_attr_group = {
	.attrs = egalax_attributes,
};

#define STYLUS_MASK 0x10
#define MAX_POINT_PER_PACKET    5U
#define POINT_STRUCT_SIZE   10U
static void ProcessParallelReport(unsigned char *buf,
				  struct _egalax_usb *p_egalax_usb)
{
	unsigned char i, index = 0, cnt_down = 0, cnt_up = 0, shift = 0;
	unsigned char status = 0;
	unsigned short contact_id = 0, x = 0, y = 0, z = 0;

	if (total_pts_cnt <= 0) {
		if (buf[1] == 0 || buf[1] > MAX_SUPPORT_POINT) {
			EGALAX_DBG(DBG_POINT,
				" NumsofContacts mismatch, skip packet\n");
			return;
		}

		total_pts_cnt = buf[1];
		recv_pts_cnt = 0;
	} else if (buf[1] > 0) {
		total_pts_cnt = 0;
		recv_pts_cnt = 0;
		EGALAX_DBG(DBG_POINT,
			" NumsofContacts mismatch, skip packet\n");
		return;
	}

	while (index < MAX_POINT_PER_PACKET) {
		shift = index * POINT_STRUCT_SIZE + 2;
		status = buf[shift];
		contact_id = buf[shift+1];
		x = ((buf[shift+3]<<8) + buf[shift+2]);
		y = ((buf[shift+5]<<8) + buf[shift+4]);
		z = ((buf[shift+7]<<8) + buf[shift+6]);

		if (contact_id >= MAX_SUPPORT_POINT) {
			total_pts_cnt = 0;
			recv_pts_cnt = 0;
			EGALAX_DBG(DBG_POINT, " Get error ContactID.\n");
			return;
		}

		EGALAX_DBG(DBG_POINT,
			"Get Point[%d] Update: Status=%d X=%d Y=%d\n",
			contact_id, status, x, y);

    #ifdef _SWITCH_XY
		short tmp = x;

		x = y;
		y = tmp;
    #endif

		if (g_flip_x)
			x = MAX_RESOLUTION - x;


		if (g_flip_y)
			y = MAX_RESOLUTION - y;

		p_contact_buf[recv_pts_cnt].id = contact_id;
		p_contact_buf[recv_pts_cnt].status = status;
		p_contact_buf[recv_pts_cnt].x = x;
		p_contact_buf[recv_pts_cnt].y = y;
		p_contact_buf[recv_pts_cnt].z = z;

		recv_pts_cnt++;
		index++;

		/* Recv all points, send input report */
		if (recv_pts_cnt == total_pts_cnt) {
			for (i = 0; i < recv_pts_cnt; i++) {
				input_mt_slot(input_dev, p_contact_buf[i].id);
				if ((p_contact_buf[i].status &
					STYLUS_MASK) != 0) {
					input_mt_report_slot_state(input_dev,
						MT_TOOL_PEN,
						((p_contact_buf[i].status&0x01)
						!= 0));
				} else {
					input_mt_report_slot_state(input_dev,
						MT_TOOL_FINGER,
						((p_contact_buf[i].status&0x01)
						!= 0));
				}

				if ((p_contact_buf[i].status & 0x01) != 0) {
					input_report_abs(input_dev,
							ABS_MT_POSITION_X,
							p_contact_buf[i].x);
					input_report_abs(input_dev,
							ABS_MT_POSITION_Y,
							p_contact_buf[i].y);
					input_report_abs(input_dev,
							ABS_MT_PRESSURE,
							p_contact_buf[i].z);
				}

				if (p_contact_buf[i].status)
					cnt_down++;
				else
					cnt_up++;
			}

			input_sync(input_dev);

			EGALAX_DBG(DBG_POINT,
			"Input sync point data done! (Down:%d Up:%d)\n",
			cnt_down, cnt_up);

			total_pts_cnt = 0;
			recv_pts_cnt = 0;
			return;
		}
	}
}

static void egalax_usb_measure(struct _egalax_usb *egalax_usb,
			       unsigned char *buf, int len)
{
	int loop = 3, ret;

	EGALAX_DBG(DBG_USB, " %s\n", __func__);

	if (buf[0] != REPORTID_MTOUCH && buf[0] != REPORTID_VENDOR) {
		EGALAX_DBG(DBG_USB,
		"USB read error data with Len=%d hedaer=%d\n", len, buf[0]);
		return;
	}

	switch (buf[0]) {
	case REPORTID_VENDOR:
		EGALAX_DBG(DBG_USB, " USB get vendor command packet\n");
		atomic_set(&wait_command_ack, 1);
		if (egalax_usb->sysfs_query_wait &&
			egalax_usb->sysfs_hook_cmd[0] == buf[2] &&
			((egalax_usb->sysfs_hook_cmd[1] == 0xFF) ||
			egalax_usb->sysfs_hook_cmd[1] == buf[3]) &&
			((egalax_usb->sysfs_hook_cmd[2] == 0xFF) ||
			egalax_usb->sysfs_hook_cmd[2] == buf[4])) {
			memcpy(egalax_usb->sysfs_cmd_result,
				buf, buf[1]+2);
			egalax_usb->sysfs_query_wait = false;
			wake_up_interruptible(
				&egalax_usb->sysfs_query_queue);
			break;
		}

		/* If someone reading now! put the data into the buffer! */
		if (p_char_dev->open_cnts > 0) {
			loop = 3;
			do {
				ret = wait_event_timeout(p_char_dev->fifo_inq,
				kfifo_avail(
					&p_char_dev->data_kfifo) >= len, HZ);
			} while (ret <= 0 && --loop);

			/* fifo size is ready */
			if (ret > 0) {
				ret = kfifo_in_locked(&p_char_dev->data_kfifo,
					buf, len, &p_char_dev->fifo_lock);
				wake_up_interruptible(&p_char_dev->fifo_inq);
			} else {
				EGALAX_DBG(DBG_CDEV,
				" [Warning] fifo size is overflow.\n");
			}
		}
		break;
	case REPORTID_MTOUCH:
		ProcessParallelReport(buf, egalax_usb);
		break;
	default:
		break;
	}
}

static void egalax_usb_irq(struct urb *urb)
{
	struct _egalax_usb *egalax_usb = urb->context;
	int retval;

	EGALAX_DBG(DBG_INT, " %s\n", __func__);

	switch (urb->status) {
	case 0:
		/* success */
		break;
	case -ETIME:
		/* this urb is timing out */
		EGALAX_DBG(DBG_INT, " urb timed out\n");
		return;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		EGALAX_DBG(DBG_INT,
		" urb shutting down with status: %d\n", urb->status);
		return;
	default:
		EGALAX_DBG(DBG_INT,
		" urb nonzero urb status received: %d\n", urb->status);
		goto exit;
	}

	egalax_usb_measure(egalax_usb, egalax_usb->data, urb->actual_length);

exit:
	usb_mark_last_busy(egalax_usb->udev);
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		EGALAX_DBG(DBG_INT,
	    " usb_submit_urb failed with result: %d\n", retval);
}

static int exc80_input_open(struct input_dev *dev)
{
	return 0;
}

static void exc80_input_close(struct input_dev *dev)
{
}

static int exc80_input_disable(struct input_dev *dev)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x04, 0x36, 0x67, 0x02, 0x00};

	if (sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN, send_cmd_buf+2, 3, HZ))
		return 0;

	return -EIO;
}

static int exc80_input_enable(struct input_dev *dev)
{
	unsigned char send_cmd_buf[MAX_USB_LEN] = {
		0x03, 0x04, 0x36, 0x67, 0x02, 0x01};

	if (sys_sendcmd_wait(send_cmd_buf, MAX_USB_LEN, send_cmd_buf+2, 3, HZ))
		return 0;

	return -EIO;
}

static struct input_dev *allocate_Input_Dev(struct _egalax_usb *egalax_usb,
					    struct usb_interface *intf)
{
	int ret;
	struct input_dev *p_input_dev = NULL;

	p_input_dev = input_allocate_device();
	if (p_input_dev == NULL) {
		EGALAX_DBG(DBG_MODULE, " Failed to allocate input device\n");
		return NULL;/* -ENOMEM; */
	}

	p_input_dev->name = "eGalax_Touch_Screen";
	p_input_dev->phys = egalax_usb->phys;
	usb_to_input_id(interface_to_usbdev(intf), &p_input_dev->id);
	p_input_dev->dev.parent = &intf->dev;
	p_input_dev->open = exc80_input_open;
	p_input_dev->close = exc80_input_close;
	p_input_dev->enable = exc80_input_enable;
	p_input_dev->disable = exc80_input_disable;
	p_input_dev->enabled = true;
	input_set_drvdata(p_input_dev, egalax_usb);

	set_bit(EV_ABS, p_input_dev->evbit);
	__set_bit(INPUT_PROP_DIRECT, p_input_dev->propbit);
	input_mt_init_slots(p_input_dev, MAX_SUPPORT_POINT, 0);
	input_set_abs_params(p_input_dev, ABS_MT_POSITION_X, 0,
		MAX_RESOLUTION, 0, 0);
	input_set_abs_params(p_input_dev, ABS_MT_POSITION_Y, 0,
		MAX_RESOLUTION, 0, 0);
	input_set_abs_params(p_input_dev, ABS_MT_PRESSURE, 0,
		MAX_Z_RESOLUTION, 0, 0);
	input_set_abs_params(p_input_dev, ABS_MT_TOOL_TYPE, 0,
		MT_TOOL_MAX, 0, 0);

	input_set_events_per_packet(p_input_dev, MAX_EVENTS);

	ret = input_register_device(p_input_dev);
	if (ret) {
		EGALAX_DBG(DBG_MODULE,
		" Unable to register input device, err: %d\n", ret);
		input_free_device(p_input_dev);
		p_input_dev = NULL;
	}

	return p_input_dev;
}

static void egalax_usb_free_buffers(struct usb_device *udev,
				    struct _egalax_usb *egalax_usb)
{
	usb_free_coherent(udev, MAX_USB_LEN, egalax_usb->data,
		egalax_usb->data_dma);
	kfree(egalax_usb->buffer);
}

static const struct file_operations egalax_cdev_fops = {
	.owner  = THIS_MODULE,
	.read   = egalax_cdev_read,
	.write  = egalax_cdev_write,
	.open   = egalax_cdev_open,
	.release = egalax_cdev_release,
	.poll   = egalax_cdev_poll,
};

static struct miscdevice egalax_misc_dev = {
	.minor  = MISC_DYNAMIC_MINOR,
	.name   = "touch",
	.fops   = &egalax_cdev_fops,
};

static const struct file_operations egalax_proc_fops = {
	.owner      = THIS_MODULE,
	.open       = egalax_proc_open,
	.read       = seq_read,
	.write      = egalax_proc_write,
	.llseek     = seq_lseek,
	.release    = single_release,
};

static struct egalax_char_dev *setup_chardev(void)
{
	struct egalax_char_dev *p_char_dev;

	p_char_dev = kzalloc(1*sizeof(struct egalax_char_dev), GFP_KERNEL);
	if (p_char_dev == NULL)
		goto fail_cdev;

	spin_lock_init(&p_char_dev->fifo_lock);
	p_char_dev->p_fifo_buf = kzalloc(sizeof(unsigned char)*FIFO_SIZE,
				GFP_KERNEL);
	if (p_char_dev->p_fifo_buf == NULL)
		goto fail_fifobuf;

	kfifo_init(&p_char_dev->data_kfifo, p_char_dev->p_fifo_buf, FIFO_SIZE);
	if (!kfifo_initialized(&p_char_dev->data_kfifo))
		goto fail_kfifo;

	p_char_dev->open_cnts = 0;
	sema_init(&p_char_dev->sem, 1);
	init_waitqueue_head(&p_char_dev->fifo_inq);

	return p_char_dev;

fail_kfifo:
	kfree(p_char_dev->p_fifo_buf);
fail_fifobuf:
	kfree(p_char_dev);
fail_cdev:
	return NULL;
}

static void egalax_usb_add_ncb(struct usb_device *udev)
{
	int result;
	struct usb_interface *intf;
	struct _egalax_usb *egalax_usb;
	struct usb_endpoint_descriptor *endpoint;

	EGALAX_DBG(DBG_MODULE,
		" USB device probe (VID=%04X PID=%04X)\n",
		le16_to_cpu(udev->descriptor.idVendor),
		le16_to_cpu(udev->descriptor.idProduct));

	if (udev->descriptor.idVendor != EETI_USB_DEVICE_ID ||
	    (udev->descriptor.idProduct != EETI_USB_PRODUCT_ID &&
	     udev->descriptor.idProduct != EETI_USB_BL_PRODUCT_ID)) {
		EGALAX_DBG(DBG_MODULE, " No support this device.\n");
		return;
	}

	intf = usb_ifnum_to_if(udev, 0);
	if (intf == NULL)
		return;

	endpoint = &intf->cur_altsetting->endpoint[0].desc;
	egalax_usb = kzalloc(sizeof(struct _egalax_usb), GFP_KERNEL);
	if (egalax_usb == NULL)
		goto out_free;

	p_egalax_usb_dev = egalax_usb;

	egalax_usb->data = usb_alloc_coherent(udev,
			MAX_USB_LEN, GFP_KERNEL,
			&egalax_usb->data_dma);

	if (egalax_usb->data == NULL) {
		EGALAX_DBG(DBG_MODULE, " usb_buffer_alloc failed!\n");
		goto out_free;
	}

	egalax_usb->buffer = kzalloc(MAX_USB_LEN, GFP_KERNEL);
	if (egalax_usb->buffer == NULL) {
		EGALAX_DBG(DBG_MODULE, " Can't alloc USB buffer!\n");
		goto out_free_buffers;
	}

	egalax_usb->irq = usb_alloc_urb(0, GFP_KERNEL);
	if (egalax_usb->irq == NULL) {
		EGALAX_DBG(DBG_MODULE, " usb_alloc_urb failed!\n");
		goto out_free_buffers;
	}

	egalax_usb->udev = udev;
	egalax_usb->interface = intf;

	usb_make_path(udev, egalax_usb->phys, sizeof(egalax_usb->phys));
	strlcat(egalax_usb->phys, "/input0", sizeof(egalax_usb->phys));

	if (input_dev == NULL &&
	    udev->descriptor.idProduct == EETI_USB_PRODUCT_ID) {
		input_dev = allocate_Input_Dev(egalax_usb, intf);
		if (input_dev == NULL) {
			EGALAX_DBG(DBG_MODULE, " allocate_Input_Dev failed\n");
			goto out_free_buffers;
		}
		EGALAX_DBG(DBG_MODULE, " Register input device done\n");
	} else
		EGALAX_DBG(DBG_MODULE, " Input device already created!\n");

	usb_fill_int_urb(egalax_usb->irq, egalax_usb->udev,
			usb_rcvintpipe(egalax_usb->udev,
			endpoint->bEndpointAddress),
			egalax_usb->data, MAX_USB_LEN, egalax_usb_irq,
			egalax_usb, endpoint->bInterval);

	egalax_usb->irq->dev = egalax_usb->udev;
	egalax_usb->irq->transfer_dma = egalax_usb->data_dma;
	egalax_usb->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	usb_set_intfdata(intf, egalax_usb);

	/* start USB function */
	if (usb_submit_urb(egalax_usb->irq, GFP_KERNEL)) {
		EGALAX_DBG(DBG_MODULE, " usb_submit_urb failed\n");
		goto out_unregister_input;
	}

	result = misc_register(&egalax_misc_dev);
	if (result) {
		EGALAX_DBG(DBG_MODULE,
				" misc device register failed\n");
		goto out_unregister_input;
	}
	misc_registered = true;

	result = sysfs_create_group(&egalax_misc_dev.this_device->kobj,
		&egalax_attr_group);
	if (result) {
		EGALAX_DBG(DBG_MODULE,
		" Failed to create sysfs attributes:%d\n", result);
		goto out_misc_deregister;
	}
	sysfs_created = true;

	/* allocate the character device */
	p_char_dev = setup_chardev();
	if (p_char_dev == NULL) {
		result = -ENOMEM;
		goto out_sysfs_remove_group;
	}

	init_waitqueue_head(&p_egalax_usb_dev->sysfs_query_queue);
	p_egalax_usb_dev->sysfs_query_wait = false;
	p_egalax_usb_dev->sysfs_hook_cmd[0] = 0xFF;
	p_egalax_usb_dev->sysfs_hook_cmd[1] = 0xFF;
	p_egalax_usb_dev->sysfs_hook_cmd[2] = 0xFF;

	if (udev->descriptor.idProduct != EETI_USB_BL_PRODUCT_ID)
		run_fw_init(egalax_usb);

	EGALAX_DBG(DBG_MODULE, " USB device probe done\n");

	return;

out_sysfs_remove_group:
	sysfs_remove_group(&egalax_misc_dev.this_device->kobj,
			   &egalax_attr_group);
out_misc_deregister:
	misc_deregister(&egalax_misc_dev);
out_unregister_input:
	input_unregister_device(input_dev);
	input_dev = NULL;
out_free_buffers:
	p_egalax_usb_dev = NULL;
	egalax_usb_free_buffers(udev, egalax_usb);
out_free:
	kfree(egalax_usb);
}

static void egalax_usb_rm_ncb(struct usb_device *udev)
{
	if (udev->descriptor.idVendor != EETI_USB_DEVICE_ID ||
	    (udev->descriptor.idProduct != EETI_USB_PRODUCT_ID &&
	     udev->descriptor.idProduct != EETI_USB_BL_PRODUCT_ID))
		return;

	if (p_egalax_usb_dev == NULL || (p_egalax_usb_dev->udev != udev))
		return;

	EGALAX_DBG(DBG_MODULE, " USB device disconnect!\n");

	if (sysfs_created)
		sysfs_remove_group(&egalax_misc_dev.this_device->kobj,
				&egalax_attr_group);
	sysfs_created = false;

	if (misc_registered)
		misc_deregister(&egalax_misc_dev);
	misc_registered = false;

	if (p_char_dev != NULL) {
		kfree(p_char_dev->p_fifo_buf);
		kfree(p_char_dev);
		p_char_dev = NULL;
	}

	usb_kill_urb(p_egalax_usb_dev->irq);
	usb_free_urb(p_egalax_usb_dev->irq);
	egalax_usb_free_buffers(udev, p_egalax_usb_dev);
	kfree(p_egalax_usb_dev);
	p_egalax_usb_dev = NULL;
	input_dev = NULL;
}

int egalax_usb_ncb(struct notifier_block *nb, unsigned long usb_event,
		   void *udev)
{
	int result = NOTIFY_OK;

	switch (usb_event) {
	case USB_DEVICE_ADD:
		egalax_usb_add_ncb(udev);
		break;
	case USB_DEVICE_REMOVE:
		egalax_usb_rm_ncb(udev);
		break;
	case USB_BUS_ADD:
	case USB_BUS_REMOVE:
		break;
	default:
		result = NOTIFY_BAD;
	}
	return result;
}

static struct notifier_block egalax_usb_notifier = {
	.notifier_call = egalax_usb_ncb,
	.priority = INT_MAX	/* Need to be called first of all */
};

static int request_dt(struct device *dev)
{
	int result, val;
	struct device_node *devnode;

	g_reset_gpio = 0;
	g_enable_high = false;
	g_flip_x = false;
	g_flip_y = false;
	g_regulator_hv = NULL;
	g_regulator_5v0 = NULL;
	g_regulator_3v3 = NULL;
	g_regulator_1v8 = NULL;

	devnode = dev->of_node;
	if (devnode) {
		/* Touch orientation */
		result = of_property_read_u32(devnode, "flip-x", &val);
		if (result < 0)
			val = 0;
		g_flip_x = val != 0 ? true : false;
		result = of_property_read_u32(devnode, "flip-y", &val);
		if (result < 0)
			val = 0;
		g_flip_y = val != 0 ? true : false;

		if (of_property_read_bool(devnode, "enable-active-high"))
			g_enable_high = true;

		g_reset_gpio = of_get_named_gpio(devnode,
							"reset-gpio", 0);
		/* regulator */
		g_regulator_hv = devm_regulator_get(
						dev, "vdd-ts-hv");
		if (IS_ERR(g_regulator_hv)) {
			EGALAX_DBG(DBG_MODULE,
				"vdd-12v regulator_get failed: %ld\n",
				PTR_ERR(g_regulator_hv));
			return -EINVAL;
		}
		g_regulator_5v0 = devm_regulator_get(
						dev, "vdd-ts-5v0");
		if (IS_ERR(g_regulator_5v0)) {
			EGALAX_DBG(DBG_MODULE,
				"vdd-5v regulator_get failed: %ld\n",
				PTR_ERR(g_regulator_5v0));
			return -EINVAL;
		}
		g_regulator_3v3 = devm_regulator_get(
						dev, "vdd-ts-3v3");
		if (IS_ERR(g_regulator_3v3)) {
			EGALAX_DBG(DBG_MODULE,
				"vdd 3v3 regulator_get failed: %ld\n",
				PTR_ERR(g_regulator_3v3));
			return -EINVAL;
		}
		g_regulator_1v8 = devm_regulator_get(
						dev, "vdd-ts-1v8");
		if (IS_ERR(g_regulator_1v8)) {
			EGALAX_DBG(DBG_MODULE,
				"vdd 18v regulator_get failed: %ld\n",
				PTR_ERR(g_regulator_1v8));
			return -EINVAL;
		}
	}

	if (!gpio_is_valid(g_reset_gpio)) {
		EGALAX_DBG(DBG_MODULE, " gpio[%d] is not valid\n",
			   g_reset_gpio);
		return -EINVAL;
	}

	result = gpio_request(g_reset_gpio, "rest-gpio");
	if (result < 0) {
		EGALAX_DBG(DBG_MODULE, " gpio_request[%d] failed: %d\n",
			   g_reset_gpio, result);
		return -EINVAL;
	}

	return 0;
}

static void egalax_power_on(void)
{
	int error = 0;

	if (g_enable_high)
		gpio_direction_output(g_reset_gpio, 1);
	else
		gpio_direction_output(g_reset_gpio, 0);

	error = regulator_enable(g_regulator_hv);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	error = regulator_enable(g_regulator_5v0);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	error = regulator_enable(g_regulator_1v8);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	error = regulator_enable(g_regulator_3v3);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	usleep_range(1000, 5000);
	if (g_enable_high)
		gpio_direction_output(g_reset_gpio, 0);
	else
		gpio_direction_output(g_reset_gpio, 1);
	EGALAX_DBG(DBG_MODULE, " Device power on!\n");

}

static void egalax_power_off(void)
{
	int error = 0;

	if (g_enable_high)
		gpio_direction_output(g_reset_gpio, 0);
	else
		gpio_direction_output(g_reset_gpio, 1);

	error = regulator_disable(g_regulator_hv);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	error = regulator_disable(g_regulator_5v0);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	error = regulator_disable(g_regulator_1v8);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	error = regulator_disable(g_regulator_3v3);
	if (error < 0)
		EGALAX_DBG(DBG_MODULE, " regulator enable failed: %d\n",
			error);
	usleep_range(1000, 5000);
	if (g_enable_high)
		gpio_direction_output(g_reset_gpio, 1);
	else
		gpio_direction_output(g_reset_gpio, 0);

	EGALAX_DBG(DBG_MODULE, " Device power on!\n");
}

static int egalax_platform_probe(struct platform_device *pdev)
{
	int i, result;

	p_egalax_usb_dev = NULL;
	p_char_dev = NULL;
	input_dev = NULL;
	total_pts_cnt = 0;
	recv_pts_cnt = 0;

	for (i = 0; i < MAX_SUPPORT_POINT; i++) {
		p_contact_buf[i].status = -1;
		p_contact_buf[i].id = 0;
		p_contact_buf[i].x = p_contact_buf[i].y =
				     p_contact_buf[i].z = 0;
	}

	if (request_dt(&(pdev->dev)) != 0)
		return -EINVAL;

	egalax_power_on();

	p_dbg_proc_file = proc_create(PROC_FS_NAME, 0660, NULL,
			&egalax_proc_fops);
	if (p_dbg_proc_file == NULL) {
		remove_proc_entry(PROC_FS_NAME, NULL);
		EGALAX_DBG(DBG_MODULE, " Could not initialize /proc/%s\n",
		PROC_FS_NAME);
		result = -EINVAL;
		goto out_fail;
	}

	usb_register_notify(&egalax_usb_notifier);
	return 0;

out_fail:
	return result;
}

static int egalax_platform_remove(struct platform_device *pdev)
{
	if (p_dbg_proc_file != NULL)
		remove_proc_entry(PROC_FS_NAME, NULL);

	if (sysfs_created)
		sysfs_remove_group(&egalax_misc_dev.this_device->kobj,
				&egalax_attr_group);
	sysfs_created = false;

	if (misc_registered)
		misc_deregister(&egalax_misc_dev);
	misc_registered = false;

	if (p_char_dev != NULL) {
		kfree(p_char_dev->p_fifo_buf);
		kfree(p_char_dev);
		p_char_dev = NULL;
	}

	egalax_power_off();

	gpio_free(g_reset_gpio);

	usb_unregister_notify(&egalax_usb_notifier);
	return 0;
}

static void egalax_platform_shutdown(struct platform_device *pdev)
{
	egalax_power_off();
}

static const struct of_device_id egalax_usb_idtable[] = {
	{ .compatible = "eeti,exc80_ts_usb" },
	{ },
};
MODULE_DEVICE_TABLE(of, egalax_usb_idtable);

static struct platform_driver egalax_platform_driver = {
	.driver = {
		.name = "exc80_ts_usb",
		.owner = THIS_MODULE,
		.of_match_table = egalax_usb_idtable,
	},
	.probe = egalax_platform_probe,
	.remove = egalax_platform_remove,
	.shutdown = egalax_platform_shutdown,
};

static void egalax_usb_ts_exit(void)
{
	EGALAX_DBG(DBG_MODULE, " Driver exit!\n");
	platform_driver_unregister(&egalax_platform_driver);
}

static int egalax_usb_ts_init(void)
{
	EGALAX_DBG(DBG_MODULE, " Driver init!\n");
	return platform_driver_register(&egalax_platform_driver);
}

module_init(egalax_usb_ts_init);
module_exit(egalax_usb_ts_exit);

MODULE_AUTHOR("EETI <touch_fae@eeti.com>");
MODULE_DESCRIPTION("egalax touch screen usb driver");
MODULE_LICENSE("GPL");