input: touchscreen: remove global variable from ITE tech touch driver

Remove the use of global variable from ITE tech touch driver,
and use the internal driver structure passed as function argument.
This change makes the driver complied to kernel coding standards
and similar to other touch driver.

This is a propagated patch from 3.18 patch 'commit 041f90ddeb5e ("input:
touchscreen: remove global variable from ITE tech touch driver")'

CRs-Fixed: 982219
Change-Id: Ib609d6e76ea70cd3b49c4ea6f09c75bf52521aa8
Signed-off-by: Shantanu Jain <shjain@codeaurora.org>

1 files changed, 442 insertions, 390 deletions

diff --git a/drivers/input/touchscreen/it7258_ts_i2c.c b/drivers/input/touchscreen/it7258_ts_i2c.c
index 542f45ba1479..a09256949eda 100644
--- a/drivers/input/touchscreen/it7258_ts_i2c.c
+++ b/drivers/input/touchscreen/it7258_ts_i2c.c
@@ -206,21 +206,25 @@ static int fb_notifier_callback(struct notifier_block *self,
 static int IT7260_ts_resume(struct device *dev);
 static int IT7260_ts_suspend(struct device *dev);
 
-static struct IT7260_ts_data *gl_ts;
-
 static int IT7260_debug_suspend_set(void *_data, u64 val)
 {
+	struct IT7260_ts_data *ts_data = _data;
+
 	if (val)
-		IT7260_ts_suspend(&gl_ts->client->dev);
+		IT7260_ts_suspend(&ts_data->client->dev);
 	else
-		IT7260_ts_resume(&gl_ts->client->dev);
+		IT7260_ts_resume(&ts_data->client->dev);
 
 	return 0;
 }
 
 static int IT7260_debug_suspend_get(void *_data, u64 *val)
 {
-	*val = gl_ts->suspended;
+	struct IT7260_ts_data *ts_data = _data;
+
+	mutex_lock(&ts_data->input_dev->mutex);
+	*val = ts_data->suspended;
+	mutex_lock(&ts_data->input_dev->mutex);
 
 	return 0;
 }
@@ -229,19 +233,19 @@ DEFINE_SIMPLE_ATTRIBUTE(debug_suspend_fops, IT7260_debug_suspend_get,
 				IT7260_debug_suspend_set, "%lld\n");
 
 /* internal use func - does not make sure chip is ready before read */
-static bool IT7260_i2cReadNoReadyCheck(uint8_t buf_index, uint8_t *buffer,
-							uint16_t buf_len)
+static bool IT7260_i2cReadNoReadyCheck(struct IT7260_ts_data *ts_data,
+			uint8_t buf_index, uint8_t *buffer, uint16_t buf_len)
 {
 	int ret;
 	struct i2c_msg msgs[2] = {
 		{
-			.addr = gl_ts->client->addr,
+			.addr = ts_data->client->addr,
 			.flags = I2C_M_NOSTART,
 			.len = 1,
 			.buf = &buf_index
 		},
 		{
-			.addr = gl_ts->client->addr,
+			.addr = ts_data->client->addr,
 			.flags = I2C_M_RD,
 			.len = buf_len,
 			.buf = buffer
@@ -250,22 +254,22 @@ static bool IT7260_i2cReadNoReadyCheck(uint8_t buf_index, uint8_t *buffer,
 
 	memset(buffer, 0xFF, buf_len);
 
-	ret = i2c_transfer(gl_ts->client->adapter, msgs, 2);
+	ret = i2c_transfer(ts_data->client->adapter, msgs, 2);
 	if (ret < 0) {
-		dev_err(&gl_ts->client->dev, "i2c read failed %d\n", ret);
+		dev_err(&ts_data->client->dev, "i2c read failed %d\n", ret);
 		return false;
 	}
 
 	return (ret == 2) ? true : false;
 }
 
-static bool IT7260_i2cWriteNoReadyCheck(uint8_t buf_index,
-			const uint8_t *buffer, uint16_t buf_len)
+static bool IT7260_i2cWriteNoReadyCheck(struct IT7260_ts_data *ts_data,
+		uint8_t buf_index, const uint8_t *buffer, uint16_t buf_len)
 {
 	uint8_t txbuf[257];
 	int ret;
 	struct i2c_msg msg = {
-		.addr = gl_ts->client->addr,
+		.addr = ts_data->client->addr,
 		.flags = 0,
 		.len = buf_len + 1,
 		.buf = txbuf
@@ -273,16 +277,16 @@ static bool IT7260_i2cWriteNoReadyCheck(uint8_t buf_index,
 
 	/* just to be careful */
 	if (buf_len > sizeof(txbuf) - 1) {
-		dev_err(&gl_ts->client->dev, "buf length is out of limit\n");
+		dev_err(&ts_data->client->dev, "buf length is out of limit\n");
 		return false;
 	}
 
 	txbuf[0] = buf_index;
 	memcpy(txbuf + 1, buffer, buf_len);
 
-	ret = i2c_transfer(gl_ts->client->adapter, &msg, 1);
+	ret = i2c_transfer(ts_data->client->adapter, &msg, 1);
 	if (ret < 0) {
-		dev_err(&gl_ts->client->dev, "i2c write failed %d\n", ret);
+		dev_err(&ts_data->client->dev, "i2c write failed %d\n", ret);
 		return false;
 	}
 
@@ -298,17 +302,18 @@ static bool IT7260_i2cWriteNoReadyCheck(uint8_t buf_index,
  * If slowly is set to TRUE, then add sleep of 50 ms in each retry,
  * otherwise don't sleep.
  */
-static bool IT7260_waitDeviceReady(bool forever, bool slowly)
+static bool IT7260_waitDeviceReady(struct IT7260_ts_data *ts_data, bool forever,
+							bool slowly)
 {
 	uint8_t query;
 	uint32_t count = DEVICE_READY_COUNT_20;
 	bool ret;
 
-	if (gl_ts->fw_cfg_uploading || forever)
+	if (ts_data->fw_cfg_uploading || forever)
 		count = DEVICE_READY_COUNT_MAX;
 
 	do {
-		ret = IT7260_i2cReadNoReadyCheck(BUF_QUERY, &query,
+		ret = IT7260_i2cReadNoReadyCheck(ts_data, BUF_QUERY, &query,
 						sizeof(query));
 		if (ret == false && ((query & CMD_STATUS_BITS)
 						== CMD_STATUS_NO_CONN))
@@ -325,46 +330,48 @@ static bool IT7260_waitDeviceReady(bool forever, bool slowly)
 	return !(query & CMD_STATUS_BITS);
 }
 
-static bool IT7260_i2cRead(uint8_t buf_index, uint8_t *buffer,
-						uint16_t buf_len)
+static bool IT7260_i2cRead(struct IT7260_ts_data *ts_data, uint8_t buf_index,
+				uint8_t *buffer, uint16_t buf_len)
 {
 	bool ret;
 
-	ret = IT7260_waitDeviceReady(false, false);
+	ret = IT7260_waitDeviceReady(ts_data, false, false);
 	if (ret == false)
 		return ret;
 
-	return IT7260_i2cReadNoReadyCheck(buf_index, buffer, buf_len);
+	return IT7260_i2cReadNoReadyCheck(ts_data, buf_index, buffer, buf_len);
 }
 
-static bool IT7260_i2cWrite(uint8_t buf_index, const uint8_t *buffer,
-							uint16_t buf_len)
+static bool IT7260_i2cWrite(struct IT7260_ts_data *ts_data, uint8_t buf_index,
+			const uint8_t *buffer, uint16_t buf_len)
 {
 	bool ret;
 
-	ret = IT7260_waitDeviceReady(false, false);
+	ret = IT7260_waitDeviceReady(ts_data, false, false);
 	if (ret == false)
 		return ret;
 
-	return IT7260_i2cWriteNoReadyCheck(buf_index, buffer, buf_len);
+	return IT7260_i2cWriteNoReadyCheck(ts_data, buf_index, buffer, buf_len);
 }
 
-static bool IT7260_firmware_reinitialize(u8 command)
+static bool IT7260_firmware_reinitialize(struct IT7260_ts_data *ts_data,
+						u8 command)
 {
 	uint8_t cmd[] = {command};
 	uint8_t rsp[2];
 
-	if (!IT7260_i2cWrite(BUF_COMMAND, cmd, sizeof(cmd)))
+	if (!IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd, sizeof(cmd)))
 		return false;
 
-	if (!IT7260_i2cRead(BUF_RESPONSE, rsp, sizeof(rsp)))
+	if (!IT7260_i2cRead(ts_data, BUF_RESPONSE, rsp, sizeof(rsp)))
 		return false;
 
 	/* a reply of two zero bytes signifies success */
 	return !rsp[0] && !rsp[1];
 }
 
-static bool IT7260_enter_exit_fw_ugrade_mode(bool enter)
+static bool IT7260_enter_exit_fw_ugrade_mode(struct IT7260_ts_data *ts_data,
+							bool enter)
 {
 	uint8_t cmd[] = {CMD_FIRMWARE_UPGRADE, 0, 'I', 'T', '7', '2',
 						'6', '0', 0x55, 0xAA};
@@ -372,27 +379,28 @@ static bool IT7260_enter_exit_fw_ugrade_mode(bool enter)
 
 	cmd[1] = enter ? SUB_CMD_ENTER_FW_UPGRADE_MODE :
 				SUB_CMD_EXIT_FW_UPGRADE_MODE;
-	if (!IT7260_i2cWrite(BUF_COMMAND, cmd, sizeof(cmd)))
+	if (!IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd, sizeof(cmd)))
 		return false;
 
-	if (!IT7260_i2cRead(BUF_RESPONSE, resp, sizeof(resp)))
+	if (!IT7260_i2cRead(ts_data, BUF_RESPONSE, resp, sizeof(resp)))
 		return false;
 
 	/* a reply of two zero bytes signifies success */
 	return !resp[0] && !resp[1];
 }
 
-static bool IT7260_chipSetStartOffset(uint16_t offset)
+static bool IT7260_chipSetStartOffset(struct IT7260_ts_data *ts_data,
+					uint16_t offset)
 {
 	uint8_t cmd[] = {CMD_SET_START_OFFSET, 0, ((uint8_t)(offset)),
 				((uint8_t)((offset) >> 8))};
 	uint8_t resp[2];
 
-	if (!IT7260_i2cWrite(BUF_COMMAND, cmd, 4))
+	if (!IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd, 4))
 		return false;
 
 
-	if (!IT7260_i2cRead(BUF_RESPONSE, resp, sizeof(resp)))
+	if (!IT7260_i2cRead(ts_data, BUF_RESPONSE, resp, sizeof(resp)))
 		return false;
 
 
@@ -402,8 +410,9 @@ static bool IT7260_chipSetStartOffset(uint16_t offset)
 
 
 /* write fw_length bytes from fw_data at chip offset wr_start_offset */
-static bool IT7260_fw_flash_write_verify(unsigned int fw_length,
-			const uint8_t *fw_data, uint16_t wr_start_offset)
+static bool IT7260_fw_flash_write_verify(struct IT7260_ts_data *ts_data,
+			unsigned int fw_length,	const uint8_t *fw_data,
+			uint16_t wr_start_offset)
 {
 	uint32_t cur_data_off;
 
@@ -433,17 +442,18 @@ static bool IT7260_fw_flash_write_verify(unsigned int fw_length,
 							retries++) {
 
 			/* set write offset and write the data */
-			IT7260_chipSetStartOffset(
+			IT7260_chipSetStartOffset(ts_data,
 					wr_start_offset + cur_data_off);
-			IT7260_i2cWrite(BUF_COMMAND, cmd_write,
+			IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd_write,
 					cur_wr_size + 2);
 
 			/* set offset and read the data back */
-			IT7260_chipSetStartOffset(
+			IT7260_chipSetStartOffset(ts_data,
 					wr_start_offset + cur_data_off);
-			IT7260_i2cWrite(BUF_COMMAND, cmd_read,
+			IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd_read,
 					sizeof(cmd_read));
-			IT7260_i2cRead(BUF_RESPONSE, buf_read, cur_wr_size);
+			IT7260_i2cRead(ts_data, BUF_RESPONSE, buf_read,
+								cur_wr_size);
 
 			/* verify. If success break out of retry loop */
 			i = 0;
@@ -455,7 +465,7 @@ static bool IT7260_fw_flash_write_verify(unsigned int fw_length,
 		}
 		/* if we've failed after all the retries, tell the caller */
 		if (retries == FW_WRITE_RETRY_COUNT) {
-			dev_err(&gl_ts->client->dev,
+			dev_err(&ts_data->client->dev,
 				"write of data offset %u failed on try %u at byte %u/%u\n",
 				cur_data_off, retries, i, cur_wr_size);
 			return false;
@@ -469,7 +479,7 @@ static bool IT7260_fw_flash_write_verify(unsigned int fw_length,
  * this code to get versions from the chip via i2c transactions, and save
  * them in driver data structure.
  */
-static void IT7260_get_chip_versions(struct device *dev)
+static void IT7260_get_chip_versions(struct IT7260_ts_data *ts_data)
 {
 	static const u8 cmd_read_fw_ver[] = {CMD_READ_VERSIONS,
 						SUB_CMD_READ_FIRMWARE_VERSION};
@@ -478,62 +488,65 @@ static void IT7260_get_chip_versions(struct device *dev)
 	u8 ver_fw[VERSION_LENGTH], ver_cfg[VERSION_LENGTH];
 	bool ret = true;
 
-	ret = IT7260_i2cWrite(BUF_COMMAND, cmd_read_fw_ver,
+	ret = IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd_read_fw_ver,
 					sizeof(cmd_read_fw_ver));
 	if (ret) {
 		/*
 		 * Sometimes, the controller may not respond immediately after
 		 * writing the command, so wait for device to get ready.
 		 */
-		ret = IT7260_waitDeviceReady(true, false);
+		ret = IT7260_waitDeviceReady(ts_data, true, false);
 		if (ret == false)
-			dev_err(dev, "failed to read from chip\n");
+			dev_err(&ts_data->client->dev, "failed to read chip status\n");
 
-		ret = IT7260_i2cReadNoReadyCheck(BUF_RESPONSE, ver_fw,
+		ret = IT7260_i2cReadNoReadyCheck(ts_data, BUF_RESPONSE, ver_fw,
 					VERSION_LENGTH);
 		if (ret)
-			memcpy(gl_ts->fw_ver, ver_fw + (5 * sizeof(u8)),
+			memcpy(ts_data->fw_ver, ver_fw + (5 * sizeof(u8)),
 					VER_BUFFER_SIZE * sizeof(u8));
 	}
 	if (!ret)
-		dev_err(dev, "failed to read fw version from chip\n");
+		dev_err(&ts_data->client->dev,
+				"failed to read fw version from chip\n");
 
-	ret = IT7260_i2cWrite(BUF_COMMAND, cmd_read_cfg_ver,
+	ret = IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd_read_cfg_ver,
 					sizeof(cmd_read_cfg_ver));
 	if (ret) {
 		/*
 		 * Sometimes, the controller may not respond immediately after
 		 * writing the command, so wait for device to get ready.
 		 */
-		ret = IT7260_waitDeviceReady(true, false);
+		ret = IT7260_waitDeviceReady(ts_data, true, false);
 		if (ret == false)
-			dev_err(dev, "failed to read from chip\n");
+			dev_err(&ts_data->client->dev, "failed to read chip status\n");
 
-		ret = IT7260_i2cReadNoReadyCheck(BUF_RESPONSE, ver_cfg,
+		ret = IT7260_i2cReadNoReadyCheck(ts_data, BUF_RESPONSE, ver_cfg,
 					VERSION_LENGTH);
 		if (ret)
-			memcpy(gl_ts->cfg_ver, ver_cfg + (1 * sizeof(u8)),
+			memcpy(ts_data->cfg_ver, ver_cfg + (1 * sizeof(u8)),
 					VER_BUFFER_SIZE * sizeof(u8));
 	}
 	if (!ret)
-		dev_err(dev, "failed to read cfg version from chip\n");
+		dev_err(&ts_data->client->dev,
+				"failed to read cfg version from chip\n");
 
-	dev_info(dev, "Current fw{%X.%X.%X.%X} cfg{%X.%X.%X.%X}\n",
-		gl_ts->fw_ver[0], gl_ts->fw_ver[1], gl_ts->fw_ver[2],
-		gl_ts->fw_ver[3], gl_ts->cfg_ver[0], gl_ts->cfg_ver[1],
-		gl_ts->cfg_ver[2], gl_ts->cfg_ver[3]);
+	dev_info(&ts_data->client->dev, "Current fw{%X.%X.%X.%X} cfg{%X.%X.%X.%X}\n",
+		ts_data->fw_ver[0], ts_data->fw_ver[1], ts_data->fw_ver[2],
+		ts_data->fw_ver[3], ts_data->cfg_ver[0], ts_data->cfg_ver[1],
+		ts_data->cfg_ver[2], ts_data->cfg_ver[3]);
 }
 
-static int IT7260_cfg_upload(struct device *dev, bool force)
+static int IT7260_cfg_upload(struct IT7260_ts_data *ts_data, bool force)
 {
 	const struct firmware *cfg = NULL;
 	int ret;
 	bool success, cfg_upgrade = false;
+	struct device *dev = &ts_data->client->dev;
 
-	ret = request_firmware(&cfg, gl_ts->cfg_name, dev);
+	ret = request_firmware(&cfg, ts_data->cfg_name, dev);
 	if (ret) {
 		dev_err(dev, "failed to get config data %s for it7260 %d\n",
-					gl_ts->cfg_name, ret);
+					ts_data->cfg_name, ret);
 		return ret;
 	}
 
@@ -544,7 +557,7 @@ static int IT7260_cfg_upload(struct device *dev, bool force)
 	 */
 	if (force)
 		cfg_upgrade = true;
-	else if (IT_CFG_CHECK(gl_ts->cfg_ver, cfg))
+	else if (IT_CFG_CHECK(ts_data->cfg_ver, cfg))
 		cfg_upgrade = true;
 
 	if (!cfg_upgrade) {
@@ -554,33 +567,34 @@ static int IT7260_cfg_upload(struct device *dev, bool force)
 	} else {
 		dev_info(dev, "Config upgrading...\n");
 
-		disable_irq(gl_ts->client->irq);
+		disable_irq(ts_data->client->irq);
 		/* enter cfg upload mode */
-		success = IT7260_enter_exit_fw_ugrade_mode(true);
+		success = IT7260_enter_exit_fw_ugrade_mode(ts_data, true);
 		if (!success) {
 			dev_err(dev, "Can't enter cfg upgrade mode\n");
 			ret = -EIO;
 			goto out;
 		}
 		/* flash config data if requested */
-		success  = IT7260_fw_flash_write_verify(cfg->size, cfg->data,
-						CHIP_FLASH_SIZE - cfg->size);
+		success  = IT7260_fw_flash_write_verify(ts_data, cfg->size,
+					cfg->data, CHIP_FLASH_SIZE - cfg->size);
 		if (!success) {
 			dev_err(dev, "failed to upgrade touch cfg data\n");
-			IT7260_enter_exit_fw_ugrade_mode(false);
-			IT7260_firmware_reinitialize(CMD_FIRMWARE_REINIT_6F);
+			IT7260_enter_exit_fw_ugrade_mode(ts_data, false);
+			IT7260_firmware_reinitialize(ts_data,
+						CMD_FIRMWARE_REINIT_6F);
 			ret = -EIO;
 			goto out;
 		} else {
-			memcpy(gl_ts->cfg_ver, cfg->data +
+			memcpy(ts_data->cfg_ver, cfg->data +
 					(cfg->size - 8 * sizeof(u8)),
 					VER_BUFFER_SIZE * sizeof(u8));
 			dev_info(dev, "CFG upgrade is success. New cfg ver: %X.%X.%X.%X\n",
-					gl_ts->cfg_ver[0], gl_ts->cfg_ver[1],
-					gl_ts->cfg_ver[2], gl_ts->cfg_ver[3]);
+				ts_data->cfg_ver[0], ts_data->cfg_ver[1],
+				ts_data->cfg_ver[2], ts_data->cfg_ver[3]);
 
 		}
-		enable_irq(gl_ts->client->irq);
+		enable_irq(ts_data->client->irq);
 	}
 
 out:
@@ -589,16 +603,17 @@ out:
 	return ret;
 }
 
-static int IT7260_fw_upload(struct device *dev, bool force)
+static int IT7260_fw_upload(struct IT7260_ts_data *ts_data, bool force)
 {
 	const struct firmware *fw = NULL;
 	int ret;
 	bool success, fw_upgrade = false;
+	struct device *dev = &ts_data->client->dev;
 
-	ret = request_firmware(&fw, gl_ts->fw_name, dev);
+	ret = request_firmware(&fw, ts_data->fw_name, dev);
 	if (ret) {
 		dev_err(dev, "failed to get firmware %s for it7260 %d\n",
-					gl_ts->fw_name, ret);
+					ts_data->fw_name, ret);
 		return ret;
 	}
 
@@ -609,7 +624,7 @@ static int IT7260_fw_upload(struct device *dev, bool force)
 	 */
 	if (force)
 		fw_upgrade = true;
-	else if (IT_FW_CHECK(gl_ts->fw_ver, fw))
+	else if (IT_FW_CHECK(ts_data->fw_ver, fw))
 		fw_upgrade = true;
 
 	if (!fw_upgrade) {
@@ -619,30 +634,32 @@ static int IT7260_fw_upload(struct device *dev, bool force)
 	} else {
 		dev_info(dev, "Firmware upgrading...\n");
 
-		disable_irq(gl_ts->client->irq);
+		disable_irq(ts_data->client->irq);
 		/* enter fw upload mode */
-		success = IT7260_enter_exit_fw_ugrade_mode(true);
+		success = IT7260_enter_exit_fw_ugrade_mode(ts_data, true);
 		if (!success) {
 			dev_err(dev, "Can't enter fw upgrade mode\n");
 			ret = -EIO;
 			goto out;
 		}
 		/* flash the firmware if requested */
-		success = IT7260_fw_flash_write_verify(fw->size, fw->data, 0);
+		success = IT7260_fw_flash_write_verify(ts_data, fw->size,
+							fw->data, 0);
 		if (!success) {
 			dev_err(dev, "failed to upgrade touch firmware\n");
-			IT7260_enter_exit_fw_ugrade_mode(false);
-			IT7260_firmware_reinitialize(CMD_FIRMWARE_REINIT_6F);
+			IT7260_enter_exit_fw_ugrade_mode(ts_data, false);
+			IT7260_firmware_reinitialize(ts_data,
+						CMD_FIRMWARE_REINIT_6F);
 			ret = -EIO;
 			goto out;
 		} else {
-			memcpy(gl_ts->fw_ver, fw->data + (8 * sizeof(u8)),
+			memcpy(ts_data->fw_ver, fw->data + (8 * sizeof(u8)),
 					VER_BUFFER_SIZE * sizeof(u8));
 			dev_info(dev, "FW upgrade is success. New fw ver: %X.%X.%X.%X\n",
-					gl_ts->fw_ver[0], gl_ts->fw_ver[1],
-					gl_ts->fw_ver[2], gl_ts->fw_ver[3]);
+					ts_data->fw_ver[0], ts_data->fw_ver[1],
+					ts_data->fw_ver[2], ts_data->fw_ver[3]);
 		}
-		enable_irq(gl_ts->client->irq);
+		enable_irq(ts_data->client->irq);
 	}
 
 out:
@@ -651,16 +668,18 @@ out:
 	return ret;
 }
 
-static int IT7260_ts_chipLowPowerMode(const u8 sleep_type)
+static int IT7260_ts_chipLowPowerMode(struct IT7260_ts_data *ts_data,
+					const u8 sleep_type)
 {
 	const uint8_t cmd_sleep[] = {CMD_PWR_CTL, 0x00, sleep_type};
 	uint8_t dummy;
 
 	if (sleep_type)
-		IT7260_i2cWriteNoReadyCheck(BUF_COMMAND, cmd_sleep,
+		IT7260_i2cWriteNoReadyCheck(ts_data, BUF_COMMAND, cmd_sleep,
 					sizeof(cmd_sleep));
 	else
-		IT7260_i2cReadNoReadyCheck(BUF_QUERY, &dummy, sizeof(dummy));
+		IT7260_i2cReadNoReadyCheck(ts_data, BUF_QUERY, &dummy,
+						sizeof(dummy));
 
 	msleep(WAIT_CHANGE_MODE);
 	return 0;
@@ -669,9 +688,10 @@ static int IT7260_ts_chipLowPowerMode(const u8 sleep_type)
 static ssize_t sysfs_fw_upgrade_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int mode = 0, ret;
 
-	if (gl_ts->suspended) {
+	if (ts_data->suspended) {
 		dev_err(dev, "Device is suspended, can't flash fw!!!\n");
 		return -EBUSY;
 	}
@@ -682,19 +702,19 @@ static ssize_t sysfs_fw_upgrade_store(struct device *dev,
 		return -EINVAL;
 	}
 
-	mutex_lock(&gl_ts->fw_cfg_mutex);
+	mutex_lock(&ts_data->fw_cfg_mutex);
 	if (mode == 1) {
-		gl_ts->fw_cfg_uploading = true;
-		ret = IT7260_fw_upload(dev, false);
+		ts_data->fw_cfg_uploading = true;
+		ret = IT7260_fw_upload(ts_data, false);
 		if (ret) {
 			dev_err(dev, "Failed to flash fw: %d", ret);
-			gl_ts->fw_upgrade_result = false;
+			ts_data->fw_upgrade_result = false;
 		 } else {
-			gl_ts->fw_upgrade_result = true;
+			ts_data->fw_upgrade_result = true;
 		}
-		gl_ts->fw_cfg_uploading = false;
+		ts_data->fw_cfg_uploading = false;
 	}
-	mutex_unlock(&gl_ts->fw_cfg_mutex);
+	mutex_unlock(&ts_data->fw_cfg_mutex);
 
 	return count;
 }
@@ -702,9 +722,10 @@ static ssize_t sysfs_fw_upgrade_store(struct device *dev,
 static ssize_t sysfs_cfg_upgrade_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int mode = 0, ret;
 
-	if (gl_ts->suspended) {
+	if (ts_data->suspended) {
 		dev_err(dev, "Device is suspended, can't flash cfg!!!\n");
 		return -EBUSY;
 	}
@@ -715,19 +736,19 @@ static ssize_t sysfs_cfg_upgrade_store(struct device *dev,
 		return -EINVAL;
 	}
 
-	mutex_lock(&gl_ts->fw_cfg_mutex);
+	mutex_lock(&ts_data->fw_cfg_mutex);
 	if (mode == 1) {
-		gl_ts->fw_cfg_uploading = true;
-		ret = IT7260_cfg_upload(dev, false);
+		ts_data->fw_cfg_uploading = true;
+		ret = IT7260_cfg_upload(ts_data, false);
 		if (ret) {
 			dev_err(dev, "Failed to flash cfg: %d", ret);
-			gl_ts->cfg_upgrade_result = false;
+			ts_data->cfg_upgrade_result = false;
 		} else {
-			gl_ts->cfg_upgrade_result = true;
+			ts_data->cfg_upgrade_result = true;
 		}
-		gl_ts->fw_cfg_uploading = false;
+		ts_data->fw_cfg_uploading = false;
 	}
-	mutex_unlock(&gl_ts->fw_cfg_mutex);
+	mutex_unlock(&ts_data->fw_cfg_mutex);
 
 	return count;
 }
@@ -735,23 +756,28 @@ static ssize_t sysfs_cfg_upgrade_store(struct device *dev,
 static ssize_t sysfs_fw_upgrade_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
 	return scnprintf(buf, MAX_BUFFER_SIZE, "%d\n",
-				gl_ts->fw_upgrade_result);
+				ts_data->fw_upgrade_result);
 }
 
 static ssize_t sysfs_cfg_upgrade_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
 	return scnprintf(buf, MAX_BUFFER_SIZE, "%d\n",
-				gl_ts->cfg_upgrade_result);
+				ts_data->cfg_upgrade_result);
 }
 
 static ssize_t sysfs_force_fw_upgrade_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int mode = 0, ret;
 
-	if (gl_ts->suspended) {
+	if (ts_data->suspended) {
 		dev_err(dev, "Device is suspended, can't flash fw!!!\n");
 		return -EBUSY;
 	}
@@ -762,19 +788,19 @@ static ssize_t sysfs_force_fw_upgrade_store(struct device *dev,
 		return -EINVAL;
 	}
 
-	mutex_lock(&gl_ts->fw_cfg_mutex);
+	mutex_lock(&ts_data->fw_cfg_mutex);
 	if (mode == 1) {
-		gl_ts->fw_cfg_uploading = true;
-		ret = IT7260_fw_upload(dev, true);
+		ts_data->fw_cfg_uploading = true;
+		ret = IT7260_fw_upload(ts_data, true);
 		if (ret) {
 			dev_err(dev, "Failed to force flash fw: %d", ret);
-			gl_ts->fw_upgrade_result = false;
+			ts_data->fw_upgrade_result = false;
 		} else {
-			gl_ts->fw_upgrade_result = true;
+			ts_data->fw_upgrade_result = true;
 		}
-		gl_ts->fw_cfg_uploading = false;
+		ts_data->fw_cfg_uploading = false;
 	}
-	mutex_unlock(&gl_ts->fw_cfg_mutex);
+	mutex_unlock(&ts_data->fw_cfg_mutex);
 
 	return count;
 }
@@ -782,9 +808,10 @@ static ssize_t sysfs_force_fw_upgrade_store(struct device *dev,
 static ssize_t sysfs_force_cfg_upgrade_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int mode = 0, ret;
 
-	if (gl_ts->suspended) {
+	if (ts_data->suspended) {
 		dev_err(dev, "Device is suspended, can't flash cfg!!!\n");
 		return -EBUSY;
 	}
@@ -795,19 +822,19 @@ static ssize_t sysfs_force_cfg_upgrade_store(struct device *dev,
 		return -EINVAL;
 	}
 
-	mutex_lock(&gl_ts->fw_cfg_mutex);
+	mutex_lock(&ts_data->fw_cfg_mutex);
 	if (mode == 1) {
-		gl_ts->fw_cfg_uploading = true;
-		ret = IT7260_cfg_upload(dev, true);
+		ts_data->fw_cfg_uploading = true;
+		ret = IT7260_cfg_upload(ts_data, true);
 		if (ret) {
 			dev_err(dev, "Failed to force flash cfg: %d", ret);
-			gl_ts->cfg_upgrade_result = false;
+			ts_data->cfg_upgrade_result = false;
 		} else {
-			gl_ts->cfg_upgrade_result = true;
+			ts_data->cfg_upgrade_result = true;
 		}
-		gl_ts->fw_cfg_uploading = false;
+		ts_data->fw_cfg_uploading = false;
 	}
-	mutex_unlock(&gl_ts->fw_cfg_mutex);
+	mutex_unlock(&ts_data->fw_cfg_mutex);
 
 	return count;
 }
@@ -815,40 +842,51 @@ static ssize_t sysfs_force_cfg_upgrade_store(struct device *dev,
 static ssize_t sysfs_force_fw_upgrade_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
-	return snprintf(buf, MAX_BUFFER_SIZE, "%d", gl_ts->fw_upgrade_result);
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
+	return snprintf(buf, MAX_BUFFER_SIZE, "%d", ts_data->fw_upgrade_result);
 }
 
 static ssize_t sysfs_force_cfg_upgrade_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
-	return snprintf(buf, MAX_BUFFER_SIZE, "%d", gl_ts->cfg_upgrade_result);
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
+	return snprintf(buf, MAX_BUFFER_SIZE, "%d",
+				ts_data->cfg_upgrade_result);
 }
 
 static ssize_t sysfs_calibration_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
 	return scnprintf(buf, MAX_BUFFER_SIZE, "%d\n",
-				gl_ts->calibration_success);
+				ts_data->calibration_success);
 }
 
-static bool IT7260_chipSendCalibrationCmd(bool auto_tune_on)
+static bool IT7260_chipSendCalibrationCmd(struct IT7260_ts_data *ts_data,
+						bool auto_tune_on)
 {
 	uint8_t cmd_calibrate[] = {CMD_CALIBRATE, 0,
 					auto_tune_on ? 1 : 0, 0, 0};
-	return IT7260_i2cWrite(BUF_COMMAND, cmd_calibrate,
+
+	return IT7260_i2cWrite(ts_data, BUF_COMMAND, cmd_calibrate,
 					sizeof(cmd_calibrate));
 }
 
 static ssize_t sysfs_calibration_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	uint8_t resp;
 
-	if (!IT7260_chipSendCalibrationCmd(false)) {
+	if (!IT7260_chipSendCalibrationCmd(ts_data, false)) {
 		dev_err(dev, "failed to send calibration command\n");
 	} else {
-		gl_ts->calibration_success =
-			IT7260_i2cRead(BUF_RESPONSE, &resp, sizeof(resp));
+		ts_data->calibration_success =
+			IT7260_i2cRead(ts_data, BUF_RESPONSE, &resp,
+							sizeof(resp));
 
 		/*
 		 * previous logic that was here never called
@@ -858,8 +896,8 @@ static ssize_t sysfs_calibration_store(struct device *dev,
 		 */
 		if (!resp)
 			dev_dbg(dev, "IT7260_firmware_reinitialize-> %s\n",
-			IT7260_firmware_reinitialize(CMD_FIRMWARE_REINIT_6F)
-			? "success" : "fail");
+				IT7260_firmware_reinitialize(ts_data,
+				CMD_FIRMWARE_REINIT_6F) ? "success" : "fail");
 	}
 
 	return count;
@@ -868,12 +906,13 @@ static ssize_t sysfs_calibration_store(struct device *dev,
 static ssize_t sysfs_point_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	uint8_t point_data[sizeof(struct PointData)];
 	bool readSuccess;
 	ssize_t ret;
 
-	readSuccess = IT7260_i2cReadNoReadyCheck(BUF_POINT_INFO, point_data,
-							sizeof(point_data));
+	readSuccess = IT7260_i2cReadNoReadyCheck(ts_data, BUF_POINT_INFO,
+					point_data, sizeof(point_data));
 
 	if (readSuccess) {
 		ret = scnprintf(buf, MAX_BUFFER_SIZE,
@@ -895,51 +934,57 @@ static ssize_t sysfs_point_show(struct device *dev,
 static ssize_t sysfs_version_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
 	return scnprintf(buf, MAX_BUFFER_SIZE,
 			"fw{%X.%X.%X.%X} cfg{%X.%X.%X.%X}\n",
-			gl_ts->fw_ver[0], gl_ts->fw_ver[1], gl_ts->fw_ver[2],
-			gl_ts->fw_ver[3], gl_ts->cfg_ver[0], gl_ts->cfg_ver[1],
-			gl_ts->cfg_ver[2], gl_ts->cfg_ver[3]);
+			ts_data->fw_ver[0], ts_data->fw_ver[1],
+			ts_data->fw_ver[2], ts_data->fw_ver[3],
+			ts_data->cfg_ver[0], ts_data->cfg_ver[1],
+			ts_data->cfg_ver[2], ts_data->cfg_ver[3]);
 }
 
 static ssize_t sysfs_sleep_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	/*
 	 * The usefulness of this was questionable at best - we were at least
 	 * leaking a byte of kernel data (by claiming to return a byte but not
 	 * writing to buf. To fix this now we actually return the sleep status
 	 */
-	*buf = gl_ts->suspended ? '1' : '0';
+	*buf = ts_data->suspended ? '1' : '0';
+
 	return 1;
 }
 
 static ssize_t sysfs_sleep_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int go_to_sleep, ret;
 
 	ret = kstrtoint(buf, 10, &go_to_sleep);
 
-	/* (gl_ts->suspended == true && goToSleepVal > 0) means
+	/* (ts_data->suspended == true && goToSleepVal > 0) means
 	 * device is already suspended and you want it to be in sleep,
-	 * (gl_ts->suspended == false && goToSleepVal == 0) means
+	 * (ts_data->suspended == false && goToSleepVal == 0) means
 	 * device is already active and you also want it to be active.
 	 */
-	if ((gl_ts->suspended && go_to_sleep > 0) ||
-			(!gl_ts->suspended && go_to_sleep == 0))
+	if ((ts_data->suspended && go_to_sleep > 0) ||
+			(!ts_data->suspended && go_to_sleep == 0))
 		dev_err(dev, "duplicate request to %s chip\n",
 			go_to_sleep ? "sleep" : "wake");
 	else if (go_to_sleep) {
-		disable_irq(gl_ts->client->irq);
-		IT7260_ts_chipLowPowerMode(PWR_CTL_SLEEP_MODE);
+		disable_irq(ts_data->client->irq);
+		IT7260_ts_chipLowPowerMode(ts_data, PWR_CTL_SLEEP_MODE);
 		dev_dbg(dev, "touch is going to sleep...\n");
 	} else {
-		IT7260_ts_chipLowPowerMode(PWR_CTL_ACTIVE_MODE);
-		enable_irq(gl_ts->client->irq);
+		IT7260_ts_chipLowPowerMode(ts_data, PWR_CTL_ACTIVE_MODE);
+		enable_irq(ts_data->client->irq);
 		dev_dbg(dev, "touch is going to wake!\n");
 	}
-	gl_ts->suspended = go_to_sleep;
+	ts_data->suspended = go_to_sleep;
 
 	return count;
 }
@@ -947,6 +992,7 @@ static ssize_t sysfs_sleep_store(struct device *dev,
 static ssize_t sysfs_cfg_name_store(struct device *dev,
 	struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	char *strptr;
 
 	if (count >= MAX_BUFFER_SIZE) {
@@ -960,7 +1006,7 @@ static ssize_t sysfs_cfg_name_store(struct device *dev,
 		return -EINVAL;
 	}
 
-	strlcpy(gl_ts->cfg_name, buf, count);
+	strlcpy(ts_data->cfg_name, buf, count);
 
 	return count;
 }
@@ -968,9 +1014,11 @@ static ssize_t sysfs_cfg_name_store(struct device *dev,
 static ssize_t sysfs_cfg_name_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
-	if (strnlen(gl_ts->cfg_name, MAX_BUFFER_SIZE) > 0)
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
+	if (strnlen(ts_data->cfg_name, MAX_BUFFER_SIZE) > 0)
 		return scnprintf(buf, MAX_BUFFER_SIZE, "%s\n",
-				gl_ts->cfg_name);
+				ts_data->cfg_name);
 	else
 		return scnprintf(buf, MAX_BUFFER_SIZE,
 			"No config file name given\n");
@@ -979,6 +1027,7 @@ static ssize_t sysfs_cfg_name_show(struct device *dev,
 static ssize_t sysfs_fw_name_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t count)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	char *strptr;
 
 	if (count >= MAX_BUFFER_SIZE) {
@@ -992,16 +1041,18 @@ static ssize_t sysfs_fw_name_store(struct device *dev,
 		return -EINVAL;
 	}
 
-	strlcpy(gl_ts->fw_name, buf, count);
+	strlcpy(ts_data->fw_name, buf, count);
 	return count;
 }
 
 static ssize_t sysfs_fw_name_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
-	if (strnlen(gl_ts->fw_name, MAX_BUFFER_SIZE) > 0)
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
+
+	if (strnlen(ts_data->fw_name, MAX_BUFFER_SIZE) > 0)
 		return scnprintf(buf, MAX_BUFFER_SIZE, "%s\n",
-			gl_ts->fw_name);
+			ts_data->fw_name);
 	else
 		return scnprintf(buf, MAX_BUFFER_SIZE,
 			"No firmware file name given\n");
@@ -1048,53 +1099,38 @@ static const struct attribute_group it7260_attr_group = {
 	.attrs = it7260_attributes,
 };
 
-static void IT7260_chipExternalCalibration(bool autoTuneEnabled)
-{
-	uint8_t resp[2];
-
-	dev_dbg(&gl_ts->client->dev, "sent calibration command -> %d\n",
-			IT7260_chipSendCalibrationCmd(autoTuneEnabled));
-	IT7260_waitDeviceReady(true, true);
-	IT7260_i2cReadNoReadyCheck(BUF_RESPONSE, resp, sizeof(resp));
-	IT7260_firmware_reinitialize(CMD_FIRMWARE_REINIT_C);
-}
-
-void IT7260_sendCalibrationCmd(void)
-{
-	IT7260_chipExternalCalibration(false);
-}
-EXPORT_SYMBOL(IT7260_sendCalibrationCmd);
-
-static void IT7260_ts_release_all(void)
+static void IT7260_ts_release_all(struct IT7260_ts_data *ts_data)
 {
 	int finger;
 
-	for (finger = 0; finger < gl_ts->pdata->num_of_fingers; finger++) {
-		input_mt_slot(gl_ts->input_dev, finger);
-		input_mt_report_slot_state(gl_ts->input_dev,
+	for (finger = 0; finger < ts_data->pdata->num_of_fingers; finger++) {
+		input_mt_slot(ts_data->input_dev, finger);
+		input_mt_report_slot_state(ts_data->input_dev,
 				MT_TOOL_FINGER, 0);
 	}
 
-	input_report_key(gl_ts->input_dev, BTN_TOUCH, 0);
-	input_sync(gl_ts->input_dev);
+	input_report_key(ts_data->input_dev, BTN_TOUCH, 0);
+	input_sync(ts_data->input_dev);
 }
 
 static irqreturn_t IT7260_ts_threaded_handler(int irq, void *devid)
 {
 	struct PointData point_data;
-	struct input_dev *input_dev = gl_ts->input_dev;
+	struct IT7260_ts_data *ts_data = devid;
+	struct input_dev *input_dev = ts_data->input_dev;
 	u8 dev_status, finger, touch_count = 0, finger_status;
 	u8 pressure = FD_PRESSURE_NONE;
 	u16 x, y;
 	bool palm_detected;
 
 	/* verify there is point data to read & it is readable and valid */
-	IT7260_i2cReadNoReadyCheck(BUF_QUERY, &dev_status, sizeof(dev_status));
+	IT7260_i2cReadNoReadyCheck(ts_data, BUF_QUERY, &dev_status,
+						sizeof(dev_status));
 	if (!((dev_status & PT_INFO_BITS) & PT_INFO_YES))
 		return IRQ_HANDLED;
-	if (!IT7260_i2cReadNoReadyCheck(BUF_POINT_INFO, (void *)&point_data,
-						sizeof(point_data))) {
-		dev_err(&gl_ts->client->dev,
+	if (!IT7260_i2cReadNoReadyCheck(ts_data, BUF_POINT_INFO,
+				(void *)&point_data, sizeof(point_data))) {
+		dev_err(&ts_data->client->dev,
 			"failed to read point data buffer\n");
 		return IRQ_HANDLED;
 	}
@@ -1112,28 +1148,28 @@ static irqreturn_t IT7260_ts_threaded_handler(int irq, void *devid)
 		 * schedule a work that tells the pm core to relax once the CPU
 		 * cores are up.
 		 */
-		if (gl_ts->device_needs_wakeup) {
-			pm_stay_awake(&gl_ts->client->dev);
+		if (ts_data->device_needs_wakeup) {
+			pm_stay_awake(&ts_data->client->dev);
 			input_report_key(input_dev, KEY_WAKEUP, 1);
 			input_sync(input_dev);
 			input_report_key(input_dev, KEY_WAKEUP, 0);
 			input_sync(input_dev);
-			schedule_work(&gl_ts->work_pm_relax);
+			schedule_work(&ts_data->work_pm_relax);
 			return IRQ_HANDLED;
 		}
 	}
 
 	palm_detected = point_data.palm & PD_PALM_FLAG_BIT;
-	if (palm_detected && gl_ts->pdata->palm_detect_en) {
+	if (palm_detected && ts_data->pdata->palm_detect_en) {
 		input_report_key(input_dev,
-				gl_ts->pdata->palm_detect_keycode, 1);
+				ts_data->pdata->palm_detect_keycode, 1);
 		input_sync(input_dev);
 		input_report_key(input_dev,
-				gl_ts->pdata->palm_detect_keycode, 0);
+				ts_data->pdata->palm_detect_keycode, 0);
 		input_sync(input_dev);
 	}
 
-	for (finger = 0; finger < gl_ts->pdata->num_of_fingers; finger++) {
+	for (finger = 0; finger < ts_data->pdata->num_of_fingers; finger++) {
 		finger_status = point_data.flags & (0x01 << finger);
 
 		input_mt_slot(input_dev, finger);
@@ -1167,10 +1203,13 @@ static irqreturn_t IT7260_ts_threaded_handler(int irq, void *devid)
 
 static void IT7260_ts_work_func(struct work_struct *work)
 {
-	pm_relax(&gl_ts->client->dev);
+	struct IT7260_ts_data *ts_data = container_of(work,
+				struct IT7260_ts_data, work_pm_relax);
+
+	pm_relax(&ts_data->client->dev);
 }
 
-static int IT7260_chipIdentify(void)
+static int IT7260_chipIdentify(struct IT7260_ts_data *ts_data)
 {
 	static const uint8_t cmd_ident[] = {CMD_IDENT_CHIP};
 	static const uint8_t expected_id[] = {0x0A, 'I', 'T', 'E', '7',
@@ -1183,14 +1222,14 @@ static int IT7260_chipIdentify(void)
 	 * FALSE means to retry 20 times at max to read the chip status.
 	 * TRUE means to add delay in each retry.
 	 */
-	if (!IT7260_waitDeviceReady(false, true)) {
-		dev_err(&gl_ts->client->dev, "can't read from the chip\n");
+	if (!IT7260_waitDeviceReady(ts_data, false, true)) {
+		dev_err(&ts_data->client->dev, "failed to read chip status\n");
 		return -ENODEV;
 	}
 
-	if (!IT7260_i2cWriteNoReadyCheck(BUF_COMMAND, cmd_ident,
+	if (!IT7260_i2cWriteNoReadyCheck(ts_data, BUF_COMMAND, cmd_ident,
 							sizeof(cmd_ident))) {
-		dev_err(&gl_ts->client->dev, "failed to write CMD_IDENT_CHIP\n");
+		dev_err(&ts_data->client->dev, "failed to write CMD_IDENT_CHIP\n");
 		return -ENODEV;
 	}
 
@@ -1200,18 +1239,18 @@ static int IT7260_chipIdentify(void)
 	 * TRUE means to retry 500 times at max to read the chip status.
 	 * FALSE means to avoid unnecessary delays in each retry.
 	 */
-	if (!IT7260_waitDeviceReady(true, false)) {
-		dev_err(&gl_ts->client->dev, "failed to read chip status\n");
+	if (!IT7260_waitDeviceReady(ts_data, true, false)) {
+		dev_err(&ts_data->client->dev, "failed to read chip status\n");
 		return -ENODEV;
 	}
 
 
-	if (!IT7260_i2cReadNoReadyCheck(BUF_RESPONSE, chip_id,
+	if (!IT7260_i2cReadNoReadyCheck(ts_data, BUF_RESPONSE, chip_id,
 							sizeof(chip_id))) {
-		dev_err(&gl_ts->client->dev, "failed to read chip-id\n");
+		dev_err(&ts_data->client->dev, "failed to read chip-id\n");
 		return -ENODEV;
 	}
-	dev_info(&gl_ts->client->dev,
+	dev_info(&ts_data->client->dev,
 		"IT7260_chipIdentify read id: %02X %c%c%c%c%c%c%c %c%c\n",
 		chip_id[0], chip_id[1], chip_id[2], chip_id[3], chip_id[4],
 		chip_id[5], chip_id[6], chip_id[7], chip_id[8], chip_id[9]);
@@ -1220,11 +1259,11 @@ static int IT7260_chipIdentify(void)
 		return -EINVAL;
 
 	if (chip_id[8] == '5' && chip_id[9] == '6')
-		dev_info(&gl_ts->client->dev, "rev BX3 found\n");
+		dev_info(&ts_data->client->dev, "rev BX3 found\n");
 	else if (chip_id[8] == '6' && chip_id[9] == '6')
-		dev_info(&gl_ts->client->dev, "rev BX4 found\n");
+		dev_info(&ts_data->client->dev, "rev BX4 found\n");
 	else
-		dev_info(&gl_ts->client->dev, "unknown revision (0x%02X 0x%02X) found\n",
+		dev_info(&ts_data->client->dev, "unknown revision (0x%02X 0x%02X) found\n",
 						chip_id[8], chip_id[9]);
 
 	return 0;
@@ -1236,44 +1275,44 @@ static int reg_set_optimum_mode_check(struct regulator *reg, int load_uA)
 		regulator_set_optimum_mode(reg, load_uA) : 0;
 }
 
-static int IT7260_regulator_configure(bool on)
+static int IT7260_regulator_configure(struct IT7260_ts_data *ts_data, bool on)
 {
 	int retval;
 
 	if (on == false)
 		goto hw_shutdown;
 
-	gl_ts->vdd = devm_regulator_get(&gl_ts->client->dev, "vdd");
-	if (IS_ERR(gl_ts->vdd)) {
-		dev_err(&gl_ts->client->dev,
+	ts_data->vdd = devm_regulator_get(&ts_data->client->dev, "vdd");
+	if (IS_ERR(ts_data->vdd)) {
+		dev_err(&ts_data->client->dev,
 				"%s: Failed to get vdd regulator\n", __func__);
-		return PTR_ERR(gl_ts->vdd);
+		return PTR_ERR(ts_data->vdd);
 	}
 
-	if (regulator_count_voltages(gl_ts->vdd) > 0) {
-		retval = regulator_set_voltage(gl_ts->vdd,
+	if (regulator_count_voltages(ts_data->vdd) > 0) {
+		retval = regulator_set_voltage(ts_data->vdd,
 			IT_VTG_MIN_UV, IT_VTG_MAX_UV);
 		if (retval) {
-			dev_err(&gl_ts->client->dev,
+			dev_err(&ts_data->client->dev,
 				"regulator set_vtg failed retval =%d\n",
 				retval);
 			goto err_set_vtg_vdd;
 		}
 	}
 
-	gl_ts->avdd = devm_regulator_get(&gl_ts->client->dev, "avdd");
-	if (IS_ERR(gl_ts->avdd)) {
-		dev_err(&gl_ts->client->dev,
+	ts_data->avdd = devm_regulator_get(&ts_data->client->dev, "avdd");
+	if (IS_ERR(ts_data->avdd)) {
+		dev_err(&ts_data->client->dev,
 				"%s: Failed to get i2c regulator\n", __func__);
-		retval = PTR_ERR(gl_ts->avdd);
+		retval = PTR_ERR(ts_data->avdd);
 		goto err_get_vtg_i2c;
 	}
 
-	if (regulator_count_voltages(gl_ts->avdd) > 0) {
-		retval = regulator_set_voltage(gl_ts->avdd,
+	if (regulator_count_voltages(ts_data->avdd) > 0) {
+		retval = regulator_set_voltage(ts_data->avdd,
 			IT_I2C_VTG_MIN_UV, IT_I2C_VTG_MAX_UV);
 		if (retval) {
-			dev_err(&gl_ts->client->dev,
+			dev_err(&ts_data->client->dev,
 				"reg set i2c vtg failed retval =%d\n",
 				retval);
 		goto err_set_vtg_i2c;
@@ -1284,55 +1323,55 @@ static int IT7260_regulator_configure(bool on)
 
 err_set_vtg_i2c:
 err_get_vtg_i2c:
-	if (regulator_count_voltages(gl_ts->vdd) > 0)
-		regulator_set_voltage(gl_ts->vdd, 0, IT_VTG_MAX_UV);
+	if (regulator_count_voltages(ts_data->vdd) > 0)
+		regulator_set_voltage(ts_data->vdd, 0, IT_VTG_MAX_UV);
 err_set_vtg_vdd:
 	return retval;
 
 hw_shutdown:
-	if (regulator_count_voltages(gl_ts->vdd) > 0)
-		regulator_set_voltage(gl_ts->vdd, 0, IT_VTG_MAX_UV);
-	if (regulator_count_voltages(gl_ts->avdd) > 0)
-		regulator_set_voltage(gl_ts->avdd, 0, IT_I2C_VTG_MAX_UV);
+	if (regulator_count_voltages(ts_data->vdd) > 0)
+		regulator_set_voltage(ts_data->vdd, 0, IT_VTG_MAX_UV);
+	if (regulator_count_voltages(ts_data->avdd) > 0)
+		regulator_set_voltage(ts_data->avdd, 0, IT_I2C_VTG_MAX_UV);
 	return 0;
 };
 
-static int IT7260_power_on(bool on)
+static int IT7260_power_on(struct IT7260_ts_data *ts_data, bool on)
 {
 	int retval;
 
 	if (on == false)
 		goto power_off;
 
-	retval = reg_set_optimum_mode_check(gl_ts->vdd,
+	retval = reg_set_optimum_mode_check(ts_data->vdd,
 		IT_ACTIVE_LOAD_UA);
 	if (retval < 0) {
-		dev_err(&gl_ts->client->dev,
+		dev_err(&ts_data->client->dev,
 			"Regulator vdd set_opt failed rc=%d\n",
 			retval);
 		return retval;
 	}
 
-	retval = regulator_enable(gl_ts->vdd);
+	retval = regulator_enable(ts_data->vdd);
 	if (retval) {
-		dev_err(&gl_ts->client->dev,
+		dev_err(&ts_data->client->dev,
 			"Regulator vdd enable failed rc=%d\n",
 			retval);
 		goto error_reg_en_vdd;
 	}
 
-	retval = reg_set_optimum_mode_check(gl_ts->avdd,
+	retval = reg_set_optimum_mode_check(ts_data->avdd,
 		IT_I2C_ACTIVE_LOAD_UA);
 	if (retval < 0) {
-		dev_err(&gl_ts->client->dev,
+		dev_err(&ts_data->client->dev,
 			"Regulator avdd set_opt failed rc=%d\n",
 			retval);
 		goto error_reg_opt_i2c;
 	}
 
-	retval = regulator_enable(gl_ts->avdd);
+	retval = regulator_enable(ts_data->avdd);
 	if (retval) {
-		dev_err(&gl_ts->client->dev,
+		dev_err(&ts_data->client->dev,
 			"Regulator avdd enable failed rc=%d\n",
 			retval);
 		goto error_reg_en_avdd;
@@ -1341,111 +1380,112 @@ static int IT7260_power_on(bool on)
 	return 0;
 
 error_reg_en_avdd:
-	reg_set_optimum_mode_check(gl_ts->avdd, 0);
+	reg_set_optimum_mode_check(ts_data->avdd, 0);
 error_reg_opt_i2c:
-	regulator_disable(gl_ts->vdd);
+	regulator_disable(ts_data->vdd);
 error_reg_en_vdd:
-	reg_set_optimum_mode_check(gl_ts->vdd, 0);
+	reg_set_optimum_mode_check(ts_data->vdd, 0);
 	return retval;
 
 power_off:
-	reg_set_optimum_mode_check(gl_ts->vdd, 0);
-	regulator_disable(gl_ts->vdd);
-	reg_set_optimum_mode_check(gl_ts->avdd, 0);
-	regulator_disable(gl_ts->avdd);
+	reg_set_optimum_mode_check(ts_data->vdd, 0);
+	regulator_disable(ts_data->vdd);
+	reg_set_optimum_mode_check(ts_data->avdd, 0);
+	regulator_disable(ts_data->avdd);
 
 	return 0;
 }
 
-static int IT7260_gpio_configure(bool on)
+static int IT7260_gpio_configure(struct IT7260_ts_data *ts_data, bool on)
 {
 	int retval = 0;
 
 	if (on) {
-		if (gpio_is_valid(gl_ts->pdata->irq_gpio)) {
+		if (gpio_is_valid(ts_data->pdata->irq_gpio)) {
 			/* configure touchscreen irq gpio */
-			retval = gpio_request(gl_ts->pdata->irq_gpio,
+			retval = gpio_request(ts_data->pdata->irq_gpio,
 					"ite_irq_gpio");
 			if (retval) {
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"unable to request irq gpio [%d]\n",
 					retval);
 				goto err_irq_gpio_req;
 			}
 
-			retval = gpio_direction_input(gl_ts->pdata->irq_gpio);
+			retval = gpio_direction_input(ts_data->pdata->irq_gpio);
 			if (retval) {
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"unable to set direction for irq gpio [%d]\n",
 					retval);
 				goto err_irq_gpio_dir;
 			}
 		} else {
-			dev_err(&gl_ts->client->dev,
+			dev_err(&ts_data->client->dev,
 				"irq gpio not provided\n");
 				goto err_irq_gpio_req;
 		}
 
-		if (gpio_is_valid(gl_ts->pdata->reset_gpio)) {
+		if (gpio_is_valid(ts_data->pdata->reset_gpio)) {
 			/* configure touchscreen reset out gpio */
-			retval = gpio_request(gl_ts->pdata->reset_gpio,
+			retval = gpio_request(ts_data->pdata->reset_gpio,
 					"ite_reset_gpio");
 			if (retval) {
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"unable to request reset gpio [%d]\n",
 					retval);
 					goto err_reset_gpio_req;
 			}
 
 			retval = gpio_direction_output(
-					gl_ts->pdata->reset_gpio, 1);
+					ts_data->pdata->reset_gpio, 1);
 			if (retval) {
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"unable to set direction for reset gpio [%d]\n",
 					retval);
 				goto err_reset_gpio_dir;
 			}
 
-			if (gl_ts->pdata->low_reset)
-				gpio_set_value(gl_ts->pdata->reset_gpio, 0);
+			if (ts_data->pdata->low_reset)
+				gpio_set_value(ts_data->pdata->reset_gpio, 0);
 			else
-				gpio_set_value(gl_ts->pdata->reset_gpio, 1);
+				gpio_set_value(ts_data->pdata->reset_gpio, 1);
 
-			msleep(gl_ts->pdata->reset_delay);
+			msleep(ts_data->pdata->reset_delay);
 		} else {
-			dev_err(&gl_ts->client->dev,
+			dev_err(&ts_data->client->dev,
 				"reset gpio not provided\n");
 				goto err_reset_gpio_req;
 		}
 	} else {
-		if (gpio_is_valid(gl_ts->pdata->irq_gpio))
-			gpio_free(gl_ts->pdata->irq_gpio);
-		if (gpio_is_valid(gl_ts->pdata->reset_gpio)) {
+		if (gpio_is_valid(ts_data->pdata->irq_gpio))
+			gpio_free(ts_data->pdata->irq_gpio);
+		if (gpio_is_valid(ts_data->pdata->reset_gpio)) {
 			/*
 			 * This is intended to save leakage current
 			 * only. Even if the call(gpio_direction_input)
 			 * fails, only leakage current will be more but
 			 * functionality will not be affected.
 			 */
-			retval = gpio_direction_input(gl_ts->pdata->reset_gpio);
+			retval = gpio_direction_input(
+					ts_data->pdata->reset_gpio);
 			if (retval) {
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"unable to set direction for gpio reset [%d]\n",
 					retval);
 			}
-			gpio_free(gl_ts->pdata->reset_gpio);
+			gpio_free(ts_data->pdata->reset_gpio);
 		}
 	}
 
 	return 0;
 
 err_reset_gpio_dir:
-	if (gpio_is_valid(gl_ts->pdata->reset_gpio))
-		gpio_free(gl_ts->pdata->reset_gpio);
+	if (gpio_is_valid(ts_data->pdata->reset_gpio))
+		gpio_free(ts_data->pdata->reset_gpio);
 err_reset_gpio_req:
 err_irq_gpio_dir:
-	if (gpio_is_valid(gl_ts->pdata->irq_gpio))
-		gpio_free(gl_ts->pdata->irq_gpio);
+	if (gpio_is_valid(ts_data->pdata->irq_gpio))
+		gpio_free(ts_data->pdata->irq_gpio);
 err_irq_gpio_req:
 	return retval;
 }
@@ -1508,6 +1548,7 @@ static int IT7260_get_dt_coords(struct device *dev, char *name,
 static int IT7260_parse_dt(struct device *dev,
 				struct IT7260_ts_platform_data *pdata)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	struct device_node *np = dev->of_node;
 	u32 temp_val;
 	int rc;
@@ -1551,9 +1592,9 @@ static int IT7260_parse_dt(struct device *dev,
 		return rc;
 	}
 
-	snprintf(gl_ts->fw_name, MAX_BUFFER_SIZE, "%s",
+	snprintf(ts_data->fw_name, MAX_BUFFER_SIZE, "%s",
 		(pdata->fw_name != NULL) ? pdata->fw_name : FW_NAME);
-	snprintf(gl_ts->cfg_name, MAX_BUFFER_SIZE, "%s",
+	snprintf(ts_data->cfg_name, MAX_BUFFER_SIZE, "%s",
 		(pdata->cfg_name != NULL) ? pdata->cfg_name : CFG_NAME);
 
 	rc = of_property_read_u32(np, "ite,reset-delay", &temp_val);
@@ -1650,6 +1691,7 @@ static int IT7260_ts_probe(struct i2c_client *client,
 				const struct i2c_device_id *id)
 {
 	static const uint8_t cmd_start[] = {CMD_UNKNOWN_7};
+	struct IT7260_ts_data *ts_data;
 	struct IT7260_ts_platform_data *pdata;
 	uint8_t rsp[2];
 	int ret = -1, err;
@@ -1660,12 +1702,12 @@ static int IT7260_ts_probe(struct i2c_client *client,
 		return -ENODEV;
 	}
 
-	gl_ts = devm_kzalloc(&client->dev, sizeof(*gl_ts), GFP_KERNEL);
-	if (!gl_ts)
+	ts_data = devm_kzalloc(&client->dev, sizeof(*ts_data), GFP_KERNEL);
+	if (!ts_data)
 		return -ENOMEM;
 
-	gl_ts->client = client;
-	i2c_set_clientdata(client, gl_ts);
+	ts_data->client = client;
+	i2c_set_clientdata(client, ts_data);
 
 	if (client->dev.of_node) {
 		pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
@@ -1684,15 +1726,15 @@ static int IT7260_ts_probe(struct i2c_client *client,
 		return -ENOMEM;
 	}
 
-	gl_ts->pdata = pdata;
+	ts_data->pdata = pdata;
 
-	ret = IT7260_regulator_configure(true);
+	ret = IT7260_regulator_configure(ts_data, true);
 	if (ret < 0) {
 		dev_err(&client->dev, "Failed to configure regulators\n");
 		goto err_reg_configure;
 	}
 
-	ret = IT7260_power_on(true);
+	ret = IT7260_power_on(ts_data, true);
 	if (ret < 0) {
 		dev_err(&client->dev, "Failed to power on\n");
 		goto err_power_device;
@@ -1704,81 +1746,82 @@ static int IT7260_ts_probe(struct i2c_client *client,
 	 */
 	msleep(DELAY_VTG_REG_EN);
 
-	ret = IT7260_ts_pinctrl_init(gl_ts);
-	if (!ret && gl_ts->ts_pinctrl) {
+	ret = IT7260_ts_pinctrl_init(ts_data);
+	if (!ret && ts_data->ts_pinctrl) {
 		/*
 		 * Pinctrl handle is optional. If pinctrl handle is found
 		 * let pins to be configured in active state. If not
 		 * found continue further without error.
 		 */
-		ret = pinctrl_select_state(gl_ts->ts_pinctrl,
-					gl_ts->pinctrl_state_active);
+		ret = pinctrl_select_state(ts_data->ts_pinctrl,
+					ts_data->pinctrl_state_active);
 		if (ret < 0) {
-			dev_err(&gl_ts->client->dev,
+			dev_err(&ts_data->client->dev,
 				"failed to select pin to active state %d",
 				ret);
 		}
 	} else {
-		ret = IT7260_gpio_configure(true);
+		ret = IT7260_gpio_configure(ts_data, true);
 		if (ret < 0) {
 			dev_err(&client->dev, "Failed to configure gpios\n");
 			goto err_gpio_config;
 		}
 	}
 
-	ret = IT7260_chipIdentify();
+	ret = IT7260_chipIdentify(ts_data);
 	if (ret) {
 		dev_err(&client->dev, "Failed to identify chip %d!!!", ret);
 		goto err_identification_fail;
 	}
 
-	IT7260_get_chip_versions(&client->dev);
+	IT7260_get_chip_versions(ts_data);
 
-	gl_ts->input_dev = input_allocate_device();
-	if (!gl_ts->input_dev) {
+	ts_data->input_dev = input_allocate_device();
+	if (!ts_data->input_dev) {
 		dev_err(&client->dev, "failed to allocate input device\n");
 		ret = -ENOMEM;
 		goto err_input_alloc;
 	}
 
 	/* Initialize mutex for fw and cfg upgrade */
-	mutex_init(&gl_ts->fw_cfg_mutex);
-
-	gl_ts->input_dev->name = DEVICE_NAME;
-	gl_ts->input_dev->phys = "I2C";
-	gl_ts->input_dev->id.bustype = BUS_I2C;
-	gl_ts->input_dev->id.vendor = 0x0001;
-	gl_ts->input_dev->id.product = 0x7260;
-	set_bit(EV_SYN, gl_ts->input_dev->evbit);
-	set_bit(EV_KEY, gl_ts->input_dev->evbit);
-	set_bit(EV_ABS, gl_ts->input_dev->evbit);
-	set_bit(INPUT_PROP_DIRECT, gl_ts->input_dev->propbit);
-	set_bit(BTN_TOUCH, gl_ts->input_dev->keybit);
-	input_set_abs_params(gl_ts->input_dev, ABS_MT_POSITION_X,
-		gl_ts->pdata->disp_minx, gl_ts->pdata->disp_maxx, 0, 0);
-	input_set_abs_params(gl_ts->input_dev, ABS_MT_POSITION_Y,
-		gl_ts->pdata->disp_miny, gl_ts->pdata->disp_maxy, 0, 0);
-	input_mt_init_slots(gl_ts->input_dev, gl_ts->pdata->num_of_fingers, 0);
-
-	input_set_drvdata(gl_ts->input_dev, gl_ts);
+	mutex_init(&ts_data->fw_cfg_mutex);
+
+	ts_data->input_dev->name = DEVICE_NAME;
+	ts_data->input_dev->phys = "I2C";
+	ts_data->input_dev->id.bustype = BUS_I2C;
+	ts_data->input_dev->id.vendor = 0x0001;
+	ts_data->input_dev->id.product = 0x7260;
+	set_bit(EV_SYN, ts_data->input_dev->evbit);
+	set_bit(EV_KEY, ts_data->input_dev->evbit);
+	set_bit(EV_ABS, ts_data->input_dev->evbit);
+	set_bit(INPUT_PROP_DIRECT, ts_data->input_dev->propbit);
+	set_bit(BTN_TOUCH, ts_data->input_dev->keybit);
+	input_set_abs_params(ts_data->input_dev, ABS_MT_POSITION_X,
+		ts_data->pdata->disp_minx, ts_data->pdata->disp_maxx, 0, 0);
+	input_set_abs_params(ts_data->input_dev, ABS_MT_POSITION_Y,
+		ts_data->pdata->disp_miny, ts_data->pdata->disp_maxy, 0, 0);
+	input_mt_init_slots(ts_data->input_dev,
+					ts_data->pdata->num_of_fingers, 0);
+
+	input_set_drvdata(ts_data->input_dev, ts_data);
 
 	if (pdata->wakeup) {
-		set_bit(KEY_WAKEUP, gl_ts->input_dev->keybit);
-		INIT_WORK(&gl_ts->work_pm_relax, IT7260_ts_work_func);
+		set_bit(KEY_WAKEUP, ts_data->input_dev->keybit);
+		INIT_WORK(&ts_data->work_pm_relax, IT7260_ts_work_func);
 		device_init_wakeup(&client->dev, pdata->wakeup);
 	}
 
 	if (pdata->palm_detect_en)
-		set_bit(gl_ts->pdata->palm_detect_keycode,
-					gl_ts->input_dev->keybit);
+		set_bit(ts_data->pdata->palm_detect_keycode,
+					ts_data->input_dev->keybit);
 
-	if (input_register_device(gl_ts->input_dev)) {
+	if (input_register_device(ts_data->input_dev)) {
 		dev_err(&client->dev, "failed to register input device\n");
 		goto err_input_register;
 	}
 
 	if (request_threaded_irq(client->irq, NULL, IT7260_ts_threaded_handler,
-		IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->name, gl_ts)) {
+		IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->name, ts_data)) {
 		dev_err(&client->dev, "request_irq failed\n");
 		goto err_irq_reg;
 	}
@@ -1789,30 +1832,31 @@ static int IT7260_ts_probe(struct i2c_client *client,
 	}
 
 #if defined(CONFIG_FB)
-	gl_ts->fb_notif.notifier_call = fb_notifier_callback;
+	ts_data->fb_notif.notifier_call = fb_notifier_callback;
 
-	ret = fb_register_client(&gl_ts->fb_notif);
+	ret = fb_register_client(&ts_data->fb_notif);
 	if (ret)
 		dev_err(&client->dev, "Unable to register fb_notifier %d\n",
 					ret);
 #endif
 	
-	IT7260_i2cWriteNoReadyCheck(BUF_COMMAND, cmd_start, sizeof(cmd_start));
+	IT7260_i2cWriteNoReadyCheck(ts_data, BUF_COMMAND, cmd_start,
+							sizeof(cmd_start));
 	msleep(pdata->reset_delay);
-	IT7260_i2cReadNoReadyCheck(BUF_RESPONSE, rsp, sizeof(rsp));
+	IT7260_i2cReadNoReadyCheck(ts_data, BUF_RESPONSE, rsp, sizeof(rsp));
 	msleep(pdata->reset_delay);
 
-	gl_ts->dir = debugfs_create_dir(DEBUGFS_DIR_NAME, NULL);
-	if (gl_ts->dir == NULL || IS_ERR(gl_ts->dir)) {
+	ts_data->dir = debugfs_create_dir(DEBUGFS_DIR_NAME, NULL);
+	if (ts_data->dir == NULL || IS_ERR(ts_data->dir)) {
 		dev_err(&client->dev,
 			"%s: Failed to create debugfs directory, ret = %ld\n",
-			__func__, PTR_ERR(gl_ts->dir));
-		ret = PTR_ERR(gl_ts->dir);
+			__func__, PTR_ERR(ts_data->dir));
+		ret = PTR_ERR(ts_data->dir);
 		goto err_create_debugfs_dir;
 	}
 
-	temp = debugfs_create_file("suspend", S_IRUSR | S_IWUSR, gl_ts->dir,
-					gl_ts, &debug_suspend_fops);
+	temp = debugfs_create_file("suspend", S_IRUSR | S_IWUSR, ts_data->dir,
+					ts_data, &debug_suspend_fops);
 	if (temp == NULL || IS_ERR(temp)) {
 		dev_err(&client->dev,
 			"%s: Failed to create suspend debugfs file, ret = %ld\n",
@@ -1824,40 +1868,40 @@ static int IT7260_ts_probe(struct i2c_client *client,
 	return 0;
 
 err_create_debugfs_file:
-	debugfs_remove_recursive(gl_ts->dir);
+	debugfs_remove_recursive(ts_data->dir);
 err_create_debugfs_dir:
 #if defined(CONFIG_FB)
-	if (fb_unregister_client(&gl_ts->fb_notif))
+	if (fb_unregister_client(&ts_data->fb_notif))
 		dev_err(&client->dev, "Error occurred while unregistering fb_notifier.\n");
 #endif
 	sysfs_remove_group(&(client->dev.kobj), &it7260_attr_group);
 
 err_sysfs_grp_create:
-	free_irq(client->irq, gl_ts);
+	free_irq(client->irq, ts_data);
 
 err_irq_reg:
-	input_unregister_device(gl_ts->input_dev);
+	input_unregister_device(ts_data->input_dev);
 
 err_input_register:
 	if (pdata->wakeup) {
-		cancel_work_sync(&gl_ts->work_pm_relax);
+		cancel_work_sync(&ts_data->work_pm_relax);
 		device_init_wakeup(&client->dev, false);
 	}
-	if (gl_ts->input_dev)
-		input_free_device(gl_ts->input_dev);
-	gl_ts->input_dev = NULL;
+	if (ts_data->input_dev)
+		input_free_device(ts_data->input_dev);
+	ts_data->input_dev = NULL;
 
 err_input_alloc:
 err_identification_fail:
-	if (gl_ts->ts_pinctrl) {
-		if (IS_ERR_OR_NULL(gl_ts->pinctrl_state_release)) {
-			devm_pinctrl_put(gl_ts->ts_pinctrl);
-			gl_ts->ts_pinctrl = NULL;
+	if (ts_data->ts_pinctrl) {
+		if (IS_ERR_OR_NULL(ts_data->pinctrl_state_release)) {
+			devm_pinctrl_put(ts_data->ts_pinctrl);
+			ts_data->ts_pinctrl = NULL;
 		} else {
-			err = pinctrl_select_state(gl_ts->ts_pinctrl,
-					gl_ts->pinctrl_state_release);
+			err = pinctrl_select_state(ts_data->ts_pinctrl,
+					ts_data->pinctrl_state_release);
 			if (err)
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"failed to select relase pinctrl state %d\n",
 					err);
 		}
@@ -1869,10 +1913,10 @@ err_identification_fail:
 	}
 
 err_gpio_config:
-	IT7260_power_on(false);
+	IT7260_power_on(ts_data, false);
 
 err_power_device:
-	IT7260_regulator_configure(false);
+	IT7260_regulator_configure(ts_data, false);
 
 err_reg_configure:
 	return ret;
@@ -1880,43 +1924,44 @@ err_reg_configure:
 
 static int IT7260_ts_remove(struct i2c_client *client)
 {
+	struct IT7260_ts_data *ts_data = i2c_get_clientdata(client);
 	int ret;
 
-	debugfs_remove_recursive(gl_ts->dir);
+	debugfs_remove_recursive(ts_data->dir);
 #if defined(CONFIG_FB)
-	if (fb_unregister_client(&gl_ts->fb_notif))
+	if (fb_unregister_client(&ts_data->fb_notif))
 		dev_err(&client->dev, "Error occurred while unregistering fb_notifier.\n");
 #endif
 	sysfs_remove_group(&(client->dev.kobj), &it7260_attr_group);
-	free_irq(client->irq, gl_ts);
-	input_unregister_device(gl_ts->input_dev);
-	if (gl_ts->input_dev)
-		input_free_device(gl_ts->input_dev);
-	gl_ts->input_dev = NULL;
-	if (gl_ts->pdata->wakeup) {
-		cancel_work_sync(&gl_ts->work_pm_relax);
+	free_irq(client->irq, ts_data);
+	input_unregister_device(ts_data->input_dev);
+	if (ts_data->input_dev)
+		input_free_device(ts_data->input_dev);
+	ts_data->input_dev = NULL;
+	if (ts_data->pdata->wakeup) {
+		cancel_work_sync(&ts_data->work_pm_relax);
 		device_init_wakeup(&client->dev, false);
 	}
-	if (gl_ts->ts_pinctrl) {
-		if (IS_ERR_OR_NULL(gl_ts->pinctrl_state_release)) {
-			devm_pinctrl_put(gl_ts->ts_pinctrl);
-			gl_ts->ts_pinctrl = NULL;
+	if (ts_data->ts_pinctrl) {
+		if (IS_ERR_OR_NULL(ts_data->pinctrl_state_release)) {
+			devm_pinctrl_put(ts_data->ts_pinctrl);
+			ts_data->ts_pinctrl = NULL;
 		} else {
-			ret = pinctrl_select_state(gl_ts->ts_pinctrl,
-					gl_ts->pinctrl_state_release);
+			ret = pinctrl_select_state(ts_data->ts_pinctrl,
+					ts_data->pinctrl_state_release);
 			if (ret)
-				dev_err(&gl_ts->client->dev,
+				dev_err(&ts_data->client->dev,
 					"failed to select relase pinctrl state %d\n",
 					ret);
 		}
 	} else {
-		if (gpio_is_valid(gl_ts->pdata->reset_gpio))
-			gpio_free(gl_ts->pdata->reset_gpio);
-		if (gpio_is_valid(gl_ts->pdata->irq_gpio))
-			gpio_free(gl_ts->pdata->irq_gpio);
+		if (gpio_is_valid(ts_data->pdata->reset_gpio))
+			gpio_free(ts_data->pdata->reset_gpio);
+		if (gpio_is_valid(ts_data->pdata->irq_gpio))
+			gpio_free(ts_data->pdata->irq_gpio);
 	}
-	IT7260_power_on(false);
-	IT7260_regulator_configure(false);
+	IT7260_power_on(ts_data, false);
+	IT7260_regulator_configure(ts_data, false);
 
 	return 0;
 }
@@ -1925,17 +1970,19 @@ static int IT7260_ts_remove(struct i2c_client *client)
 static int fb_notifier_callback(struct notifier_block *self,
 			unsigned long event, void *data)
 {
+	struct IT7260_ts_data *ts_data = container_of(self,
+					struct IT7260_ts_data, fb_notif);
 	struct fb_event *evdata = data;
 	int *blank;
 
-	if (evdata && evdata->data && gl_ts && gl_ts->client) {
+	if (evdata && evdata->data && ts_data && ts_data->client) {
 		if (event == FB_EVENT_BLANK) {
 			blank = evdata->data;
 			if (*blank == FB_BLANK_UNBLANK)
-				IT7260_ts_resume(&(gl_ts->client->dev));
+				IT7260_ts_resume(&(ts_data->client->dev));
 			else if (*blank == FB_BLANK_POWERDOWN ||
 					*blank == FB_BLANK_VSYNC_SUSPEND)
-				IT7260_ts_suspend(&(gl_ts->client->dev));
+				IT7260_ts_suspend(&(ts_data->client->dev));
 		}
 	}
 
@@ -1946,28 +1993,30 @@ static int fb_notifier_callback(struct notifier_block *self,
 #ifdef CONFIG_PM
 static int IT7260_ts_resume(struct device *dev)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int retval;
 
 	if (device_may_wakeup(dev)) {
-		if (gl_ts->device_needs_wakeup) {
+		if (ts_data->device_needs_wakeup) {
 			/* Set active current for the avdd regulator */
-			if (gl_ts->pdata->avdd_lpm_cur) {
-				retval = reg_set_optimum_mode_check(gl_ts->avdd,
+			if (ts_data->pdata->avdd_lpm_cur) {
+				retval = reg_set_optimum_mode_check(
+						ts_data->avdd,
 						IT_I2C_ACTIVE_LOAD_UA);
 				if (retval < 0)
 					dev_err(dev, "Regulator avdd set_opt failed at resume rc=%d\n",
 					retval);
 			}
 
-			gl_ts->device_needs_wakeup = false;
-			disable_irq_wake(gl_ts->client->irq);
+			ts_data->device_needs_wakeup = false;
+			disable_irq_wake(ts_data->client->irq);
 		}
 		return 0;
 	}
 
-	if (gl_ts->ts_pinctrl) {
-		retval = pinctrl_select_state(gl_ts->ts_pinctrl,
-				gl_ts->pinctrl_state_active);
+	if (ts_data->ts_pinctrl) {
+		retval = pinctrl_select_state(ts_data->ts_pinctrl,
+				ts_data->pinctrl_state_active);
 		if (retval < 0) {
 			dev_err(dev, "Cannot get default pinctrl state %d\n",
 				retval);
@@ -1975,8 +2024,8 @@ static int IT7260_ts_resume(struct device *dev)
 		}
 	}
 
-	enable_irq(gl_ts->client->irq);
-	gl_ts->suspended = false;
+	enable_irq(ts_data->client->irq);
+	ts_data->suspended = false;
 	return 0;
 
 err_pinctrl_select_suspend:
@@ -1985,40 +2034,43 @@ err_pinctrl_select_suspend:
 
 static int IT7260_ts_suspend(struct device *dev)
 {
+	struct IT7260_ts_data *ts_data = dev_get_drvdata(dev);
 	int retval;
 
-	if (gl_ts->fw_cfg_uploading) {
+	if (ts_data->fw_cfg_uploading) {
 		dev_dbg(dev, "Fw/cfg uploading. Can't go to suspend.\n");
 		return -EBUSY;
 	}
 
 	if (device_may_wakeup(dev)) {
-		if (!gl_ts->device_needs_wakeup) {
+		if (!ts_data->device_needs_wakeup) {
 			/* put the device in low power idle mode */
-			IT7260_ts_chipLowPowerMode(PWR_CTL_LOW_POWER_MODE);
+			IT7260_ts_chipLowPowerMode(ts_data,
+						PWR_CTL_LOW_POWER_MODE);
 
 			/* Set lpm current for avdd regulator */
-			if (gl_ts->pdata->avdd_lpm_cur) {
-				retval = reg_set_optimum_mode_check(gl_ts->avdd,
-						gl_ts->pdata->avdd_lpm_cur);
+			if (ts_data->pdata->avdd_lpm_cur) {
+				retval = reg_set_optimum_mode_check(
+						ts_data->avdd,
+						ts_data->pdata->avdd_lpm_cur);
 				if (retval < 0)
 					dev_err(dev, "Regulator avdd set_opt failed at suspend rc=%d\n",
 						retval);
 			}
 
-			gl_ts->device_needs_wakeup = true;
-			enable_irq_wake(gl_ts->client->irq);
+			ts_data->device_needs_wakeup = true;
+			enable_irq_wake(ts_data->client->irq);
 		}
 		return 0;
 	}
 
-	disable_irq(gl_ts->client->irq);
+	disable_irq(ts_data->client->irq);
 
-	IT7260_ts_release_all();
+	IT7260_ts_release_all(ts_data);
 
-	if (gl_ts->ts_pinctrl) {
-		retval = pinctrl_select_state(gl_ts->ts_pinctrl,
-				gl_ts->pinctrl_state_suspend);
+	if (ts_data->ts_pinctrl) {
+		retval = pinctrl_select_state(ts_data->ts_pinctrl,
+				ts_data->pinctrl_state_suspend);
 		if (retval < 0) {
 			dev_err(dev, "Cannot get idle pinctrl state %d\n",
 				retval);
@@ -2026,7 +2078,7 @@ static int IT7260_ts_suspend(struct device *dev)
 		}
 	}
 
-	gl_ts->suspended = true;
+	ts_data->suspended = true;
 
 	return 0;