Initial file dump from open source releaseHEADmaster

1 files changed, 1134 insertions, 0 deletions

diff --git a/drivers/input/touchscreen/mms134s/mms134s.c b/drivers/input/touchscreen/mms134s/mms134s.c
new file mode 100644
index 00000000..883ffdd6
--- /dev/null
+++ b/drivers/input/touchscreen/mms134s/mms134s.c
@@ -0,0 +1,1134 @@
+/*
+ *  Copyright (C) 2014 Samsung Electronics Co. Ltd. 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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/firmware.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/mt.h>
+#include <linux/input/mms134s.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include <asm/unaligned.h>
+#include <linux/regulator/consumer.h>
+//#include <linux/platform_data/mv_usb.h>
+#ifdef CONFIG_OF
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#endif
+#ifdef CONFIG_PM_RUNTIME
+#include <linux/pm_runtime.h>
+#endif
+
+#include "mms134s_fw.h"
+
+//#define dev_info(fmt, args...) printk(KERN_DEBUG "[TSP] %s: " fmt,__func__,## args)
+//#define dev_err(fmt, args...) printk(KERN_DEBUG "[TSP] err: %s: " fmt,__func__,## args)
+//#ifdef CONFIG_OF
+//static struct regulator *mms_vdd_regulator;
+static bool power_onoff_state = false;
+
+static int mms_setup_power(struct mms_info *info, bool onoff)
+{
+
+    int ret=0;
+	struct regulator *touch_regulator_1v8 =  NULL;
+	struct regulator *touch_regulator_3v3 =  NULL;
+
+	pr_info("[TSP] %s \n", __func__);
+
+	touch_regulator_1v8 = regulator_get(NULL,"vddsim2");
+	if (IS_ERR(touch_regulator_1v8)) {
+		touch_regulator_1v8 = NULL;
+		pr_info("get touch_regulator_1v8 regulator error\n");
+		return;
+	}
+
+	touch_regulator_3v3 = regulator_get(NULL,"vddcon");
+
+	if (IS_ERR(touch_regulator_3v3)) {
+		touch_regulator_1v8 = NULL;
+		pr_info("get touch_regulator_3v3 regulator error\n");
+		return;
+																    }
+
+	if(onoff) {
+		regulator_set_voltage(touch_regulator_1v8, 1800000, 1800000);
+		ret = regulator_enable(touch_regulator_1v8);
+		if (ret) {
+			pr_info(KERN_ERR "%s: touch_regulator_1v8 enable failed (%d)\n",__func__, ret);
+		}
+
+		regulator_set_voltage(touch_regulator_3v3, 3000000, 3000000);
+		ret = regulator_enable(touch_regulator_3v3);
+		if (ret) {
+			pr_info(KERN_ERR "%s: touch_regulator_3v3 enable failed (%d)\n",__func__, ret);
+																											        }
+	}
+	else
+	{
+		ret = regulator_disable(touch_regulator_1v8);
+		if (ret) {
+			pr_info(KERN_ERR "%s: touch_regulator_3v0 disable failed (%d)\n",__func__, ret);
+		}
+
+		ret = regulator_disable(touch_regulator_3v3);
+		if (ret) {
+			pr_info(KERN_ERR "%s: touch_regulator_3v0 disable failed (%d)\n",__func__, ret);
+																	        }
+	}
+
+
+#if 0	
+	struct device dev = info->client->dev;
+	int min_uv, max_uv;
+	int ret = 0;
+
+	if (onoff) {
+		if (!mms_vdd_regulator) {
+			mms_vdd_regulator = regulator_get(&dev, "vddcammot");
+
+			if (IS_ERR(mms_vdd_regulator)) {
+				ret = PTR_ERR(mms_vdd_regulator);
+				dev_err(&dev, "Failed to get mms_vdd_regulator (%d)\n", ret);
+				printk("[TSP] mms_setup_power  Failed to get mms_vdd_regulator (%d)\n", ret);
+				return ret;
+			}
+
+			min_uv = max_uv = info->pdata->vdd_regulator_volt;
+			printk("[TSP] mms_setup_power before regulator_set_voltage \n");
+			ret = regulator_set_voltage(mms_vdd_regulator, min_uv, max_uv);
+			if (ret < 0) {
+				dev_err(&dev, "Failed to set mms_vdd_regulator to \
+					%d, %d uV (%d)\n", min_uv, max_uv, ret);
+				printk("[TSP] mms_setup_power  Failed to set regulator_set_voltage (%d)\n", ret);
+				regulator_put(mms_vdd_regulator);
+				return ret;
+			}
+
+			dev_info(&dev, "Set mms_vdd_regulator to %d, %d uV\n",
+				min_uv, max_uv);
+			printk("[TSP] mms_setup_power Set mms_vdd_regulator to %d, %d uV\n",min_uv, max_uv);
+		}
+	}
+	else {
+		if (mms_vdd_regulator) {
+			regulator_put(mms_vdd_regulator);
+			dev_info(&dev, "Put mms_vdd_regulator\n");
+			printk( "[TSP] mms_setup_power Put mms_vdd_regulator\n");
+		}
+	}
+#endif
+	return ret;
+}
+
+static int mms_onoff_power(struct mms_info *info, bool onoff)
+{   
+	int ret = 0;
+
+	if (onoff != power_onoff_state)
+	{
+		pr_info("%s()\n", __func__);
+		msleep(5);
+
+		ret = mms_setup_power(info, onoff);
+		msleep(100);
+		power_onoff_state = onoff;
+
+	}
+#if 0
+	struct device dev = info->client->dev;
+	int ret = 0;
+
+	if (!mms_vdd_regulator) {
+		dev_err(&dev, "%s : no regulator\n", __func__);
+		printk("[TSP] %s : no regulator\n", __func__);
+		return -1;
+	}
+
+	if (onoff)
+		regulator_enable(mms_vdd_regulator);
+	else
+		regulator_disable(mms_vdd_regulator);
+
+	dev_info(&dev, "%s : %s\n", __func__, (onoff) ? "on" : "off");
+	printk("[TSP]%s : %s\n", __func__, (onoff) ? "on" : "off");
+#endif
+
+	return ret;
+}
+//#endif
+
+/* mms_enable - wake-up func (VDD on)  */
+static void mms_enable(struct mms_info *info)
+{
+	if (info->enabled) {
+		dev_err(&info->client->dev, "%s : Already enable\n", __func__);
+		return;
+	}
+
+	/* use vdd control instead */
+	mms_onoff_power(info, true);
+	msleep(50);
+
+	info->enabled = true;
+	enable_irq(info->irq);
+}
+
+/* mms_disable - sleep func (VDD off) */
+static void mms_disable(struct mms_info *info)
+{
+	if (!info->enabled) {
+		dev_err(&info->client->dev, "%s : Already disable\n", __func__);
+		return;
+	}
+
+	i2c_smbus_write_byte_data(info->client, MMS_POWER_CONTROL, 1);
+
+	disable_irq(info->irq);
+
+	/* use vdd control instead */
+	msleep(50);
+	mms_onoff_power(info, false);
+	msleep(50);
+
+	info->enabled = false;
+}
+
+/* mms_reboot - IC reset */
+static void mms_reboot(struct mms_info *info)
+{
+	struct i2c_adapter *adapter = to_i2c_adapter(info->client->dev.parent);
+
+	i2c_smbus_write_byte_data(info->client, MMS_POWER_CONTROL, 1);
+	i2c_lock_adapter(adapter);
+
+	msleep(50);
+	mms_onoff_power(info, false);
+	msleep(150);
+
+	mms_onoff_power(info, true);
+	msleep(50);
+
+	i2c_unlock_adapter(adapter);
+}
+
+/*
+ * mms_clear_input_data - all finger point release
+ */
+static void mms_clear_input_data(struct mms_info *info)
+{
+	int i;
+
+	for (i = 0; i < MAX_FINGER_NUM; i++) {
+		input_mt_slot(info->input_dev, i);
+
+		if (!info->finger_state[i])
+			continue;
+
+		info->finger_state[i] = false;
+		input_mt_report_slot_state(info->input_dev, MT_TOOL_FINGER, false);
+		dev_info(&info->client->dev, "[R][%d] : forced clear\n", i);
+	}
+
+	input_sync(info->input_dev);
+
+	return;
+}
+
+/* mms_report_input_data - The position of a touch send to platfrom  */
+static void mms_report_input_data(struct mms_info *info, u8 sz, u8 *buf)
+{
+	struct i2c_client *client = info->client;
+	static int esd_cnt = 0;
+	int x, y, id, i;
+	int major;
+	int pressure;
+	int key_code;
+	int key_state;
+	u8 *tmp;
+
+	if (buf[0] == MMS_LOG_EVENT) {
+		dev_info(&client->dev, "TSP Log evnet (%d)\n", buf[1]);
+		goto out;
+	} else if (buf[0] == MMS_NOTIFY_EVENT) {
+		dev_info(&client->dev, "TSP mode changed (%d)\n", buf[1]);
+		goto out;
+	} else if (buf[0] == MMS_ERROR_EVENT) {
+		dev_info(&client->dev, "Error detected, restarting TSP\n");
+		mms_clear_input_data(info);
+		mms_reboot(info);
+		esd_cnt++;
+
+		if (esd_cnt >= ESD_DETECT_COUNT) {
+			i2c_smbus_write_byte_data(info->client, MMS_MODE_CONTROL, 0x04);
+			esd_cnt =0;
+		}
+
+		goto out;
+	}
+
+	for (i = 0; i < sz; i += FINGER_EVENT_SZ) {
+		tmp = buf + i;
+		esd_cnt = 0;
+		dev_info(&client->dev, "%d's event is 0x%x\n", i, tmp[0]);
+		if (tmp[0] & MMS_TOUCH_KEY_EVENT) {
+			switch (tmp[0] & 0xf) {
+			case 1:
+				key_code = KEY_MENU;
+				break;
+			case 2:
+				key_code = KEY_BACK;
+				break;
+			default:
+				dev_err(&client->dev, "Unknown key type\n");
+				goto out;
+			}
+
+			key_state = (tmp[0] & 0x80) ? 1 : 0;
+			input_report_key(info->input_dev, key_code, key_state);
+#ifndef CONFIG_SAMSUNG_PRODUCT_SHIP
+			dev_info(&client->dev, "key[%3d] is %s\n", key_code,
+				key_state ? "pressed" : "releaseed");
+#else
+			dev_info(&client->dev,
+				"key is %s\n", key_state ? "pressed" : "releaseed");
+#endif
+
+		} else {
+			id = (tmp[0] & 0xf) - 1;
+
+			x = tmp[2] | ((tmp[1] & 0xf) << 8);
+			y = tmp[3] | (((tmp[1] >> 4 ) & 0xf) << 8);
+			major = tmp[4];
+			pressure = tmp[5];
+
+			input_mt_slot(info->input_dev, id);
+
+			if (!(tmp[0] & 0x80)) {
+				if (info->finger_state[id]) {
+					info->finger_state[id] = false;
+					input_mt_report_slot_state(info->input_dev,
+						MT_TOOL_FINGER, false);
+
+#ifndef CONFIG_SAMSUNG_PRODUCT_SHIP
+					dev_info(&client->dev, "[R][%d]: X[%d], Y[%d]\n", id, x, y);
+#else
+					dev_info(&client->dev, "[R][%d]\n");
+#endif
+				}
+				continue;
+			}
+
+			input_mt_report_slot_state(info->input_dev, MT_TOOL_FINGER, true);
+			input_report_abs(info->input_dev, ABS_MT_POSITION_X, x);
+			input_report_abs(info->input_dev, ABS_MT_POSITION_Y, y);
+			input_report_abs(info->input_dev, ABS_MT_TOUCH_MAJOR, major);
+			input_report_abs(info->input_dev, ABS_MT_PRESSURE, pressure);
+
+			if (!info->finger_state[id]) {
+				info->finger_state[id] = true;
+#ifndef CONFIG_SAMSUNG_PRODUCT_SHIP
+				dev_info(&client->dev,
+					"[P][%d]: X[%d], Y[%d], W[%d], Z[%d]\n",
+					id, x, y, major, pressure);
+#else
+				dev_info(&client->dev, "[P][%d]\n",id);
+#endif
+			}
+		}
+	}
+
+	input_sync(info->input_dev);
+
+out:
+	dev_info(&client->dev, "end of %s\n", __func__);
+	return;
+}
+
+/* mms_interrupt - interrupt thread */
+static irqreturn_t mms_interrupt(int irq, void *dev_id)
+{
+	struct mms_info *info = (struct mms_info *)dev_id;
+	struct i2c_client *client = info->client;
+	u8 reg = MMS_EVENT_PKT;
+	u8 buf[MAX_FINGER_NUM * FINGER_EVENT_SZ] = {0, };
+	int ret, sz;
+	dev_info(&client->dev, "[TSP] %s: irq=%d",  __func__,irq);
+	struct i2c_msg msg[] = {
+		{
+			.addr = client->addr,
+			.flags = 0,
+			.buf = &reg,
+			.len = 1,
+		},
+		{
+			.addr = client->addr,
+			.flags = I2C_M_RD,
+			.buf = buf,
+		},
+	};
+
+	dev_info(&client->dev,"[TSP] %s client:", __func__, client+MMS_EVENT_PKT_SZ);
+	sz = i2c_smbus_read_byte_data(client, MMS_EVENT_PKT_SZ);
+	if (sz < 0) {
+		dev_err(&client->dev,
+			"%s : Failed to read event packet size(%d)\n", __func__, sz);
+		goto out;
+	}
+	msg[1].len = sz;
+
+	ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
+	dev_info(&client->dev, "event is 0x%x, packet size is %d\n", buf[0], sz);
+	if (ret != ARRAY_SIZE(msg))
+		dev_err(&client->dev,
+			"Failed to read %d bytes of touch data (%d)\n", sz, ret);
+	else
+		mms_report_input_data(info, sz, buf);
+
+out:
+	dev_info(&client->dev, "end of %s\n", __func__);
+	return IRQ_HANDLED;
+}
+/*
+static int mms_usb_switch_nofify(struct notifer_block *nb, unsigned long val,
+									void *dev)
+{
+	struct mms_info *info = container_of(nb, struct mms_info, nb);
+	struct i2c_client *client = info->client;
+
+	dev_info(&client->dev, "%s : val = %d\n", __func__, val);
+}
+*/
+static int mms_config(struct mms_info *info)
+{
+	struct i2c_client *client = info->client;
+	int ret = 0;
+
+/*	info->nb.notifier_call = mms_usb_switch_nofify;
+	pxa_usb_register_notifier(PXA_USB_DEV_OTG, &info->nb);*/
+
+	info->enabled = true;
+
+out:
+	return ret;
+}
+
+/*
+ * mms_isc_read_status - Check erase state function
+ */
+static int mms_isc_read_status(struct mms_info *info, u32 val)
+{
+	struct i2c_client *client = info->client;
+	u8 cmd = ISC_CMD_READ_STATUS;
+	u32 result = 0;
+	int cnt = 100;
+	int ret = 0;
+
+	do {
+		i2c_smbus_read_i2c_block_data(client, cmd, 4, (u8 *)&result);
+
+		if (result == val)
+			break;
+
+		msleep(1);
+	} while (--cnt);
+
+	if (!cnt) {
+		dev_err(&client->dev,
+			"Failed to read status. cnt : %d, val : 0x%x != 0x%x\n",
+			cnt, result, val);
+	}
+
+	return ret;
+}
+
+static int mms_isc_transfer_cmd(struct mms_info *info, int cmd)
+{
+	struct i2c_client *client = info->client;
+	struct isc_packet pkt = { ISC_ADDR, cmd };
+	struct i2c_msg msg = {
+		.addr = client->addr,
+		.flags = 0,
+		.len = sizeof(struct isc_packet),
+		.buf = (u8 *)&pkt,
+	};
+
+	return i2c_transfer(client->adapter, &msg, 1) != 1;
+}
+
+/*
+ * mms_isc_erase_page - ic page erase(1 kbyte)
+ */
+static int mms_isc_erase_page(struct mms_info *info, int page)
+{
+	return mms_isc_transfer_cmd(info, ISC_CMD_PAGE_ERASE | page) ||
+		mms_isc_read_status(
+			info, ISC_PAGE_ERASE_DONE | ISC_PAGE_ERASE_ENTER | page
+		);
+}
+
+/*
+ * mms_isc_enter - isc enter command
+ */
+static int mms_isc_enter(struct mms_info *info)
+{
+	return i2c_smbus_write_byte_data(info->client, MMS_CMD_ENTER_ISC, true);
+}
+
+static int mms_isc_exit(struct mms_info *info)
+{
+	return mms_isc_transfer_cmd(info, ISC_CMD_EXIT);
+}
+
+/*
+ * mms_get_fw_version - f/w version read
+ */
+static int mms_get_fw_version(struct i2c_client *client, u8 *buf)
+{
+	u8 cmd = MMS_FW_VERSION;
+	struct i2c_msg msg[2] = {
+		{
+			.addr = client->addr,
+			.flags = 0,
+			.buf = &cmd,
+			.len = 1,
+		}, {
+			.addr = client->addr,
+			.flags = I2C_M_RD,
+			.buf = buf,
+			.len = MAX_SECTION_NUM,
+		},
+	};
+
+	return i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg))
+				!= ARRAY_SIZE(msg);
+}
+
+/*
+ * mms_flash_section - f/w section(boot,core,config) download func
+ */
+static int mms_flash_section(struct mms_info *info, struct mms_fw_img *img,
+			const u8 *data)
+{
+	struct i2c_client *client = info->client;
+	struct isc_packet *isc_packet;
+	struct i2c_msg msg[2] = {
+		{
+			.addr = client->addr,
+			.flags = 0,
+		},
+		{
+			.addr = client->addr,
+			.flags = I2C_M_RD,
+			.len = ISC_XFER_LEN,
+		},
+	};
+	int ptr = img->offset;
+	int ret;
+	int page, i;
+	u32 tmp;
+
+	isc_packet = kzalloc(sizeof(struct isc_packet) + ISC_XFER_LEN, GFP_KERNEL);
+	isc_packet->cmd = ISC_ADDR;
+
+	msg[0].buf = (u8 *)isc_packet;
+	msg[1].buf = kzalloc(ISC_XFER_LEN, GFP_KERNEL);
+
+	for (page = img->start_page; page <= img->end_page; page++) {
+		mms_isc_erase_page(info, page);
+
+		for (i = 0; i < ISC_BLOCK_NUM; i++, ptr += ISC_XFER_LEN) {
+			/* flash firmware */
+			tmp = page * 256 + i * (ISC_XFER_LEN / 4);
+			put_unaligned_le32(tmp, &isc_packet->addr);
+			msg[0].len = sizeof(struct isc_packet) + ISC_XFER_LEN;
+
+			memcpy(isc_packet->data, data + ptr, ISC_XFER_LEN);
+
+			if (i2c_transfer(client->adapter, msg, 1) != 1)
+				goto i2c_err;
+
+			/* verify firmware */
+			tmp |= ISC_CMD_READ;
+			put_unaligned_le32(tmp, &isc_packet->addr);
+			msg[0].len = sizeof(struct isc_packet);
+
+			if (i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg))
+					!= ARRAY_SIZE(msg))
+				goto i2c_err;
+
+			if (memcmp(isc_packet->data, msg[1].buf, ISC_XFER_LEN)) {
+#if FLASH_VERBOSE_DEBUG
+				print_hex_dump(KERN_ERR, "mms134s fw wr : ",
+						DUMP_PREFIX_OFFSET, 16, 1,
+						isc_packet->data, ISC_XFER_LEN, false);
+
+				print_hex_dump(KERN_ERR, "mms134s fw rd : ",
+						DUMP_PREFIX_OFFSET, 16, 1,
+						msg[1].buf, ISC_XFER_LEN, false);
+#endif
+				dev_err(&client->dev, "Failed to flash verify\n");
+				ret = -1;
+				goto out;
+			}
+		}
+	}
+
+	dev_info(&client->dev, "Section [%d] update succeeded\n", img->type);
+
+	ret = 0;
+	goto out;
+
+i2c_err:
+	dev_err(&client->dev, "%s : i2c failed\n", __func__);
+	ret = -1;
+
+out:
+	kfree(isc_packet);
+	kfree(msg[1].buf);
+
+	return ret;
+}
+
+/*
+ * mms_flash_fw -flash_section of parent function
+ * this function is IC version binary version compare and Download
+ */
+static int mms_flash_fw(const struct firmware *fw, struct mms_info *info)
+{
+	int ret = 0;
+	int i;
+	struct mms_bin_hdr *fw_hdr = (struct mms_bin_hdr *)fw->data;
+	struct mms_fw_img **img;
+	struct i2c_client *client = info->client;
+	u8 ver[MAX_SECTION_NUM];
+	u8 target[MAX_SECTION_NUM];
+	int offset = sizeof(struct mms_bin_hdr);
+	int retires = 3;
+	bool update_flag = false;
+	bool isc_flag = true;
+
+	img = kzalloc(
+			sizeof(struct mms_fw_img *) * fw_hdr->section_num, GFP_KERNEL);
+
+	while (retires--) {
+		if (!mms_get_fw_version(client, ver))
+			break;
+		else
+			mms_reboot(info);
+	}
+
+	if (retires < 0) {
+		dev_err(&client->dev, "Failed to obtain ver. info\n");
+		isc_flag = false;
+		memset(ver, 0xff, sizeof(ver));
+	} else {
+		print_hex_dump(KERN_INFO, "mms134s fw ver : ", DUMP_PREFIX_NONE, 16, 1,
+				ver, MAX_SECTION_NUM, false);
+	}
+
+	for (i = 0; i < fw_hdr->section_num; i++,
+				offset += sizeof(struct mms_fw_img)) {
+		img[i] = (struct mms_fw_img *)(fw->data + offset);
+		target[i] = img[i]->version;
+
+		if (ver[img[i]->type] != target[i]) {
+			if(isc_flag){
+				mms_isc_enter(info);
+				isc_flag = false;
+			}
+
+			update_flag = true;
+			dev_info(&client->dev,
+				"Section [%d] is need to be updated. ver : 0x%x, bin : 0x%x\n",
+				img[i]->type, ver[img[i]->type], target[i]);
+
+			if (ret = mms_flash_section(
+						info, img[i], fw->data + fw_hdr->binary_offset)) {
+				mms_reboot(info);
+				goto out;
+			}
+		} else {
+			dev_info(&client->dev, "Section [%d] is up to date\n", i);
+		}
+	}
+
+	if (update_flag) {
+		mms_isc_exit(info);
+		msleep(5);
+		mms_reboot(info);
+	}
+
+	if (mms_get_fw_version(client, ver)) {
+		dev_err(&client->dev, "Failed to obtain version after flash\n");
+		ret = -1;
+		goto out;
+	} else {
+		for (i = 0; i < fw_hdr->section_num; i++) {
+			if (ver[img[i]->type] != target[i]) {
+				dev_info(&client->dev,
+					"Version mismatch after flash. [%d] 0x%x != 0x%x\n",
+					i, ver[img[i]->type], target[i]);
+
+				ret = -1;
+				goto out;
+			}
+		}
+	}
+
+out:
+	kfree(img);
+
+	return ret;
+}
+
+/*
+ * mms_fw_update_controller - firmware check & update
+ */
+#if 0
+static int mms_fw_update_controller(struct mms_info *info)
+{
+	struct i2c_client *client = info->client;
+	struct firmware *fw;
+	int retires = 3;
+	int ret = 0;
+
+	ret = request_firmware(&fw, MMS_FW_NAME, &client->dev);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to requesting firmware\n");
+		goto out;
+	}
+
+	do {
+		ret = mms_flash_fw(fw, info);
+	} while (ret && --retires);
+
+	if (!retires)
+		dev_err(&info->client->dev, "Failed to flash fw after retires\n");
+
+	release_firmware(fw);
+
+out:
+	return ret;
+}
+#else
+static void mms_fw_update_controller(const struct firmware *fw, void * context)
+{
+		struct mms_info *info = context;
+		int retires = 3;
+		int ret;
+
+		if (!fw) {
+			dev_err(&info->client->dev, "failed to read firmware\n");
+			return;
+		}
+
+		do {
+			ret = mms_flash_fw(fw, info);
+		} while (ret && --retires);
+
+		if (!retires) {
+			dev_err(&info->client->dev, "failed to flash firmware after retires\n");
+		}
+		mms_config(info);
+		release_firmware(fw);
+}
+#endif
+
+#ifdef CONFIG_OF
+static struct of_device_id mms_dt_ids[] = {
+	{ .compatible = "melfas,mms134s", },
+	{}
+};
+MODULE_DEVICE_TABLE(of, mms_dt_ids);
+
+static int mms_probe_dt(struct device_node *np, struct device *dev,
+			struct mms_platform_data *pdata)
+{
+	struct of_device_id *match;
+	int ret = 0;
+
+	if (!np) {
+		dev_err(dev, "Device node not found\n");
+		return -EINVAL;
+	}
+
+	match = of_match_device(mms_dt_ids, dev);
+	if (!match) {
+		dev_err(dev, "Compatible mismatch\n");
+		return -EINVAL;
+	}
+
+	ret = of_property_read_u32(np, "melfas,max_x", &pdata->max_x);
+	if (ret) {
+		dev_err(dev, "Failed to get property max_x from node(%d)\n", ret);
+		goto out;
+	}
+
+	ret = of_property_read_u32(np, "melfas,max_y", &pdata->max_y);
+	if (ret) {
+		dev_err(dev, "Failed to get property max_y from node(%d)\n", ret);
+		goto out;
+	}
+
+	ret = of_property_read_u32(np, "melfas,irqflags", &pdata->irqflags);
+	if (ret) {
+		dev_err(dev, "Failed to get property irqflags from node(%d)\n", ret);
+		goto out;
+	}
+
+	pdata->gpio_int = of_get_named_gpio(np, "melfas,gpio_int", 0);
+	if (pdata->gpio_int < 0) {
+		dev_err(dev, "Failed to get property gpio_int(%d)\n", pdata->gpio_int);
+		ret = pdata->gpio_int;
+		goto out;
+	}
+
+	ret = of_property_read_u32(np,
+			"melfas,vdd_regulator_volt", &pdata->vdd_regulator_volt);
+	if (ret) {
+		dev_err(dev,
+			"Failed to get property vdd_regulator_volt from node(%d)\n", ret);
+		goto out;
+	}
+
+	ret = of_property_read_string(np, "melfas,inkernel_fw_name",
+				&pdata->inkernel_fw_name);
+	if (ret) {
+		dev_err(dev,
+			"Failed to get property inkernel_fw_name from node(%d)\n", ret);
+		goto out;
+	}
+
+	ret = of_property_read_string(np, "melfas,ums_fw_name",
+				&pdata->ums_fw_name);
+	if (ret) {
+		dev_err(dev,
+			"Failed to get property ums_fw_name from node(%d)\n", ret);
+		goto out;
+	}
+
+out:
+	return ret;
+}
+#endif
+
+#if TSP_SEC_FACTORY
+#include "mms134s_sec.c"
+#endif
+
+static int mms_probe(struct i2c_client *client, struct i2c_device_id *id)
+{
+	struct mms_platform_data *pdata = client->dev.platform_data;
+	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+	struct device_node *np = client->dev.of_node;
+	struct mms_info *info;
+	struct input_dev *input_dev;
+	int ret = 0;
+
+	printk("[TSP] start mms_probe\n");
+
+	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+		dev_err(&client->dev, "Not compatible i2c function\n");
+		printk("[TSP] %s Not compatible i2c function\n",__func__);
+		return -EIO;
+	}
+#ifdef CONFIG_OF
+	pdata = kzalloc(sizeof(struct mms_platform_data), GFP_KERNEL);
+	if (!pdata) {
+		dev_err(&client->dev, "Failed to allocate memory\n");
+		pirntk("[TSP] %s Failed to allocate memory\n",__func__);
+		return -ENOMEM;
+	}
+
+	ret = mms_probe_dt(np, &client->dev, pdata);
+	if (ret < 0) {
+		dev_err(&client->dev, "Failed to get platform data from node\n");
+		printk("[TSP] %s Failed to get platform data from node\n",__func__);
+		goto err_probe_dt;
+	}
+#else
+	
+	if (!pdata) {
+		dev_err(&client->dev, "Platform data not found\n");
+		printk("[TSP] %s Platform data not found\n",__func__);
+		return -EINVAL;
+	}
+#endif
+
+	info = kzalloc(sizeof(struct mms_info), GFP_KERNEL);
+	if (!info) {
+		dev_err(&client->dev, "Failed to allocate memory\n");
+		printk("[TSP] Failed to allocate memory\n");
+		ret = -ENOMEM;
+		goto err_data_alloc;
+	}
+
+	info->client = client;
+	info->pdata = pdata;
+
+	/*set vdd regulator*/
+	mms_setup_power(info, true);
+	mms_onoff_power(info, true);
+
+	/*upload firmware file*/
+	dev_info(&client->dev, "%s  enable FW %d\n",__func__,__LINE__);
+	info->pdata->inkernel_fw_name = kstrdup(MMS_FW_NAME, GFP_KERNEL);
+	dev_info(&client->dev, "firmware name: %s\n", info->pdata->inkernel_fw_name);
+	dev_info(&client->dev, "%s  enable tsp  %d\n",__func__,__LINE__);
+	ret = request_firmware_nowait(THIS_MODULE, true, MMS_FW_NAME, &client->dev,
+			GFP_KERNEL, info, mms_fw_update_controller);
+
+	if (ret) {
+		dev_err(&client->dev, "failed to schedule firmware update\n");
+		kfree(info);
+		goto err_data_alloc;
+	}
+
+	dev_info(&client->dev, "firmware request done\n");
+
+	input_dev = input_allocate_device();
+	if (!input_dev) {
+		dev_err(&client->dev, "Failed to allocate memory\n");
+		printk("[TSP] Failed to allocate memory\n");
+		ret = -ENOMEM;
+		goto err_input_alloc;
+	}
+
+	info->input_dev = input_dev;
+
+	snprintf(info->phys, sizeof(info->phys), "%s/input0",
+				dev_name(&client->dev));
+
+	dev_info(&client->dev, "[TSP] %s/input0",dev_name(&client->dev));
+	input_dev->name = "Melfas MMS134s Touch Screen";
+	input_dev->phys = info->phys;
+	input_dev->id.bustype = BUS_I2C;
+	input_dev->dev.parent = &client->dev;
+
+	__set_bit(EV_ABS, input_dev->evbit);
+	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
+
+#if MMS_HAS_TOUCH_KEY
+	__set_bit(EV_KEY, input_dev->evbit);
+	__set_bit(KEY_MENU, input_dev->keybit);
+	__set_bit(KEY_BACK, input_dev->keybit);
+#endif
+
+	input_mt_init_slots(input_dev, MAX_FINGER_NUM, 0);
+	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, MAX_WIDTH, 0, 0);
+	input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, MAX_PRESSURE, 0, 0);
+	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
+							info->pdata->max_x, 0, 0);
+	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
+							info->pdata->max_y, 0, 0);
+
+	ret = input_register_device(input_dev);
+	if (ret) {
+		dev_err(&client->dev, "Failed to register input dev(%d)\n", ret);
+		printk("[TSP] Failed to register input dev(%d)\n", ret);
+		goto err_input_register;
+	}
+
+	input_set_drvdata(input_dev, info);
+	i2c_set_clientdata(client, info);
+
+	mms_enable(info);
+	info->enabled = true;
+
+	info->finger_state = kzalloc(sizeof(bool) * MAX_FINGER_NUM, GFP_KERNEL);
+	if (!info->finger_state) {
+		dev_err(&client->dev, "Failed to allocate memory\n");
+		printk("[TSP] Failed to allocate memory\n");
+		ret = -ENOMEM;
+		goto err_state_alloc;
+	}
+	memset(info->finger_state, 0x00, sizeof(bool) * MAX_FINGER_NUM);
+
+	/* configure touchscreen interrupt gpio */
+	ret = gpio_request(52, "mms134s_irq_gpio");
+	if (ret) {
+		dev_err(&client->dev, "[TSP]unable to request gpio.\n");
+		goto err_init_drv;
+	}								    
+	client->irq = gpio_to_irq(52);
+	info->irq = gpio_to_irq(52);
+
+	dev_info(&client->dev,"[TSP] client-> irq = %d \n",client->irq);
+	ret = request_threaded_irq(client->irq, NULL, mms_interrupt,
+				IRQF_TRIGGER_LOW  | IRQF_ONESHOT,"mms134s", info);
+
+	if (ret) {
+		dev_err(&client->dev, "Failed to register irq(%d)\n", ret);
+		printk("[TSP] Failed to register irq(%d)\n", ret);
+		goto err_request_irq;
+	}
+
+	ret = mms_config(info);
+	if (ret) {
+		dev_err(&client->dev, "Failed mms134 configuration\n");
+		printk("[TSP] Failed mms134 configuration\n");
+		goto err_mms_config;
+	}
+
+#ifdef CONFIG_PM_RUNTIME
+	pm_runtime_enable(&client->dev);
+#endif
+
+#if TSP_SEC_FACTORY
+	ret = init_sec(info);
+	if (ret) {
+		dev_err(&client->dev, "Failed to initialize SEC_FACTORY\n");
+		printk("[TSP] Failed to initialize SEC_FACTORY\n");
+		goto err_init_sec;
+	}
+#endif
+
+	dev_info(&client->dev, "mms134s initialized\n");
+	printk("[TSP] mms134s initialized\n");
+
+	return 0;
+
+err_init_drv:
+err_init_sec:
+err_mms_config:
+err_request_irq:
+	kfree(info->finger_state);
+err_state_alloc:
+	input_unregister_device(input_dev);
+err_input_register:
+	input_free_device(input_dev);
+err_input_alloc:
+	kfree(info);
+err_data_alloc:
+#ifdef CONFIG_OF
+err_probe_dt:
+	kfree(pdata);
+#endif
+	dev_info(&client->dev, "Failed to initialization\n");
+	printk("[TSP] Failed to initialization\n");
+
+	return ret;
+}
+
+static int mms_remove(struct i2c_client *client)
+{
+	struct mms_info *info = i2c_get_clientdata(client);
+
+	kfree(info->finger_state);
+	input_unregister_device(info->input_dev);
+	input_free_device(info->input_dev);
+#ifdef CONIFG_OF
+	kfree(info->pdata);
+#endif
+	kfree(info);
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int mms_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct mms_info *info = i2c_get_clientdata(client);
+
+	mutex_lock(&info->input_dev->mutex);
+
+	if (info->input_dev->users) {
+		mms_clear_input_data(info);
+		mms_disable(info);
+	}
+
+	mutex_unlock(&info->input_dev->mutex);
+
+	return 0;
+}
+
+static int mms_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct mms_info *info = i2c_get_clientdata(client);
+
+	mutex_lock(&info->input_dev->mutex);
+
+	if (info->input_dev->users)
+		mms_enable(info);
+
+	mutex_unlock(&info->input_dev->mutex);
+
+	return 0;
+}
+#endif
+
+static struct i2c_device_id mms_id[] = {
+	{MMS_DEV_NAME, 0},
+};
+MODULE_DEVICE_TABLE(i2c, mms_id);
+
+#ifdef CONFIG_PM
+static struct dev_pm_ops mms_pm_ops = {
+#ifdef CONFIG_PM_RUNTIME
+		SET_RUNTIME_PM_OPS(mms_suspend, mms_resume, NULL)
+#else
+		.suspend	= mms_suspend,
+		.resume		= mms_resume,
+#endif
+};
+#endif
+
+static struct i2c_driver mms_driver = {
+	.id_table	= mms_id,
+	.probe		= mms_probe,
+	.remove		= mms_remove,
+	.driver		= {
+			.owner	= THIS_MODULE,
+			.name	= MMS_DEV_NAME,
+#ifdef CONFIG_OF
+			.of_match_table	= of_match_ptr(mms_dt_ids),
+#endif
+#ifdef CONFIG_PM
+			.pm	= &mms_pm_ops,
+#endif
+	},
+};
+
+static int __init mms134s_init(void)
+{
+   	//  #if PRINT_TSP_LOG
+    printk("[TSP] mms134s_init\n");
+	//  #endif
+	
+	
+	     return i2c_add_driver(&mms_driver);
+ }
+	
+	
+ static void __exit mms134s_exit(void)
+ {
+   	 i2c_del_driver(&mms_driver);
+ }
+
+ module_init(mms134s_init);
+ module_exit(mms134s_exit);
+
+
+MODULE_DESCRIPTION("Touchscreen driver for MELFAS MMS134S");
+MODULE_LICENSE("GPL");