Merge "input: it7258_ts_i2c: clean checkpatch errors"

/* drivers/input/touchscreen/it7258_ts_i2c.c

 *

 * Copyright (C) 2014 ITE Tech. Inc.

 * Copyright (c) 2015, The Linux Foundation. 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 version 2 and

#define SCREEN_X_RESOLUTION		320

#define SCREEN_Y_RESOLUTION		320

#define BUF_COMMAND			0x20 /* all commands writes go to this idx */

/* all commands writes go to this idx */

#define BUF_COMMAND			0x20

#define BUF_SYS_COMMAND			0x40

#define BUF_QUERY			0x80 /* "revice ready?" and "wake up please" and "read touch data" reads go to this idx */

#define BUF_RESPONSE			0xA0 /* most command responce reads go to this idx */

/*

 * "device ready?" and "wake up please" and "read touch data" reads

 * go to this idx

 */

#define BUF_QUERY			0x80

/* most command response reads go to this idx */

#define BUF_RESPONSE			0xA0

#define BUF_SYS_RESPONSE		0xC0

#define BUF_POINT_INFO			0xE0 /* reads of "point" go through here and produce 14 bytes of data */

/* reads of "point" go through here and produce 14 bytes of data */

#define BUF_POINT_INFO			0xE0

/* commands and their subcommands. when no subcommands exist, a zero is send as the second byte */

/*

 * commands and their subcommands. when no subcommands exist, a zero

 * is send as the second byte

 */

#define CMD_IDENT_CHIP			0x00

#define CMD_READ_VERSIONS		0x01 /* VERSION_LENGTH bytes of data in response */

/* VERSION_LENGTH bytes of data in response */

#define CMD_READ_VERSIONS		0x01

#define VER_FIRMWARE			0x00

#define VER_CONFIG			0x06

#define VERSION_LENGTH			10

#define CMD_PWR_CTL			0x04 /* subcommand is zero, next byte is power mode */

# define PWR_CTL_LOW_POWER_MODE		0x01 /* idle mode */

# define PWR_CTL_SLEEP_MODE		0x02 /* sleep mode */

#define CMD_UNKNOWN_7			0x07 /* command is not documented in the datasheet v1.0.0.7 */

/* subcommand is zero, next byte is power mode */

#define CMD_PWR_CTL			0x04

/* idle mode */

#define PWR_CTL_LOW_POWER_MODE		0x01

/* sleep mode */

#define PWR_CTL_SLEEP_MODE		0x02

/* command is not documented in the datasheet v1.0.0.7 */

#define CMD_UNKNOWN_7			0x07

#define CMD_FIRMWARE_REINIT_C		0x0C

#define CMD_CALIBRATE			0x13 /* needs to be followed by 4 bytes of zeroes */

/* needs to be followed by 4 bytes of zeroes */

#define CMD_CALIBRATE			0x13

#define CMD_FIRMWARE_UPGRADE		0x60

#define FIRMWARE_MODE_ENTER		0x00

#define FIRMWARE_MODE_EXIT		0x80

#define CMD_SET_START_OFFSET		0x61 /* address for FW read/write */

#define CMD_FW_WRITE			0x62 /* subcommand is number of bytes to write */

#define CMD_FW_READ			0x63 /* subcommand is number of bytes to read */

/* address for FW read/write */

#define CMD_SET_START_OFFSET		0x61

/* subcommand is number of bytes to write */

#define CMD_FW_WRITE			0x62

/* subcommand is number of bytes to read */

#define CMD_FW_READ			0x63

#define CMD_FIRMWARE_REINIT_6F		0x6F

#define FW_WRITE_CHUNK_SIZE		128

#define PT_INFO_BITS			0xF8

#define BT_INFO_NONE			0x00

#define PT_INFO_YES			0x80

#define BT_INFO_NONE_BUT_DOWN		0x08 /* no new data but finder(s) still down */

/* no new data but finder(s) still down */

#define BT_INFO_NONE_BUT_DOWN		0x08

/* use this to include integers in commands */

#define CMD_UINT16(v)		((uint8_t)(v)) , ((uint8_t)((v) >> 8))

	uint8_t hi;

	uint8_t yLo;

	uint8_t pressure;

} __attribute__((packed));

}  __packed;

struct PointData {

	uint8_t flags;

	uint8_t palm;

	struct FingerData fd[3];

} __attribute__((packed));

}  __packed;

#define PD_FLAGS_DATA_TYPE_BITS		0xF0

/* other types (like chip-detected gestures) exist but we do not care */

#define PD_FLAGS_DATA_TYPE_TOUCH	0x00

#define PD_FLAGS_NOT_PEN		0x08 /* set if pen touched, clear if finger(s) */

#define PD_FLAGS_HAVE_FINGERS		0x07 /* a bit for each finger data that is valid (from lsb to msb) */

/* set if pen touched, clear if finger(s) */

#define PD_FLAGS_NOT_PEN		0x08

/* a bit for each finger data that is valid (from lsb to msb) */

#define PD_FLAGS_HAVE_FINGERS		0x07

#define PD_PALM_FLAG_BIT		0x01

#define FD_PRESSURE_BITS		0x0F

#define FD_PRESSURE_NONE		0x00

	struct input_dev *input_dev;

};

static int8_t fwUploadResult = SYSFS_RESULT_NOT_DONE;

static int8_t calibrationWasSuccessful = SYSFS_RESULT_NOT_DONE;

static bool devicePresent = false;

static int8_t fwUploadResult;

static int8_t calibrationWasSuccessful;

static bool devicePresent;

static DEFINE_MUTEX(sleepModeMutex);

static bool chipAwake = true;

static bool hadFingerDown = false;

static bool isDeviceSleeping = false;

static bool isDeviceSuspend = false;

static bool chipAwake;

static bool hadFingerDown;

static bool isDeviceSuspend;

static struct input_dev *input_dev;

static struct IT7260_ts_data *gl_ts;

#define LOGI(...)	printk(DEVICE_NAME ": " __VA_ARGS__)

/* internal use func - does not make sure chip is ready before read */

static bool i2cReadNoReadyCheck(uint8_t bufferIndex, uint8_t *dataBuffer, uint16_t dataLength)

static bool i2cReadNoReadyCheck(uint8_t bufferIndex, uint8_t *dataBuffer,

							uint16_t dataLength)

{

	struct i2c_msg msgs[2] = {

		{

	return i2c_transfer(gl_ts->client->adapter, msgs, 2);

}

static bool i2cWriteNoReadyCheck(uint8_t bufferIndex, const uint8_t *dataBuffer, uint16_t dataLength)

static bool i2cWriteNoReadyCheck(uint8_t bufferIndex,

			const uint8_t *dataBuffer, uint16_t dataLength)

{

	uint8_t txbuf[257];

	struct i2c_msg msg = {

}

/*

 * Device is apparently always ready for i2c but not for actual register reads/writes.

 * This function ascertains it is ready for that too. the results of this call often

 * were ignored.

 * Device is apparently always ready for i2c but not for actual

 * register reads/writes. This function ascertains it is ready

 * for that too. the results of this call often were ignored.

 */

static bool waitDeviceReady(bool forever, bool slowly)

{

	return !ucQuery;

}

static bool i2cRead(uint8_t bufferIndex, uint8_t *dataBuffer, uint16_t dataLength)

static bool i2cRead(uint8_t bufferIndex, uint8_t *dataBuffer,

						uint16_t dataLength)

{

	waitDeviceReady(false, false);

	return i2cReadNoReadyCheck(bufferIndex, dataBuffer, dataLength);

}

static bool i2cWrite(uint8_t bufferIndex, const uint8_t *dataBuffer, uint16_t dataLength)

static bool i2cWrite(uint8_t bufferIndex, const uint8_t *dataBuffer,

							uint16_t dataLength)

{

	waitDeviceReady(false, false);

	return i2cWriteNoReadyCheck(bufferIndex, dataBuffer, dataLength);

static bool chipFirmwareUpgradeModeEnterExit(bool enter)

{

	uint8_t cmd[] = {CMD_FIRMWARE_UPGRADE, 0, 'I', 'T', '7', '2', '6', '0', 0x55, 0xAA};

	uint8_t cmd[] = {CMD_FIRMWARE_UPGRADE, 0, 'I', 'T', '7', '2',

						'6', '0', 0x55, 0xAA};

	uint8_t resp[2];

	cmd[1] = enter ? FIRMWARE_MODE_ENTER : FIRMWARE_MODE_EXIT;

/* write fwLength bytes from fwData at chip offset writeStartOffset */

static bool chipFlashWriteAndVerify(unsigned int fwLength, const uint8_t *fwData, uint16_t writeStartOffset)

static bool chipFlashWriteAndVerify(unsigned int fwLength,

			const uint8_t *fwData, uint16_t writeStartOffset)

{

	uint32_t curDataOfst;

	for (curDataOfst = 0; curDataOfst < fwLength; curDataOfst += FW_WRITE_CHUNK_SIZE) {

	for (curDataOfst = 0; curDataOfst < fwLength;

				curDataOfst += FW_WRITE_CHUNK_SIZE) {

		uint8_t cmdWrite[2 + FW_WRITE_CHUNK_SIZE] = {CMD_FW_WRITE};

		uint8_t bufRead[FW_WRITE_CHUNK_SIZE];

		/* prepare the read command */

		cmdRead[1] = curWriteSz;

		for (nRetries = 0; nRetries < FW_WRITE_RETRY_COUNT; nRetries++) {

		for (nRetries = 0; nRetries < FW_WRITE_RETRY_COUNT;

							nRetries++) {

			/* set write offset and write the data */

			chipSetStartOffset(writeStartOffset + curDataOfst);

			i2cRead(BUF_RESPONSE, bufRead, curWriteSz);

			/* verify. If success break out of retry loop */

			for (i = 0; i < curWriteSz && bufRead[i] == cmdWrite[i + 2]; i++);

			i = 0;

			while (i < curWriteSz && bufRead[i] == cmdWrite[i + 2])

				i++;

			if (i == curWriteSz)

				break;

			LOGE("write of data offset %u failed on try %u at byte %u/%u\n", curDataOfst, nRetries, i, curWriteSz);

			pr_err("write of data offset %u failed on try %u at byte %u/%u\n",

				curDataOfst, nRetries, i, curWriteSz);

		}

		/* if we've failed after all the retries, tell the caller */

		if (nRetries == FW_WRITE_RETRY_COUNT)

	return true;

}

static bool chipFirmwareUpload(uint32_t fwLen, const uint8_t *fwData, uint32_t cfgLen, const uint8_t *cfgData)

static bool chipFirmwareUpload(uint32_t fwLen, const uint8_t *fwData,

				uint32_t cfgLen, const uint8_t *cfgData)

{

	bool success = false;

	}

	/* flash config data if requested */

	if (fwLen && fwData && !chipFlashWriteAndVerify(cfgLen, cfgData, CHIP_FLASH_SIZE - cfgLen)) {

	if (fwLen && fwData && !chipFlashWriteAndVerify(cfgLen, cfgData,

						CHIP_FLASH_SIZE - cfgLen)) {

		LOGE("failed to upload touch cfg data\n");

		goto out;

	}

	success = true;

out:

	return chipFirmwareUpgradeModeEnterExit(false) && chipFirmwareReinitialize(CMD_FIRMWARE_REINIT_6F) && success;

	return chipFirmwareUpgradeModeEnterExit(false) &&

		chipFirmwareReinitialize(CMD_FIRMWARE_REINIT_6F) && success;

}

/*

 * both buffers should be VERSION_LENGTH in size,

 * but only a part of them is significant

 */

static bool chipGetVersions(uint8_t *verFw, uint8_t *verCfg, bool logIt)

{

	/* this code to get versions is reproduced as was written, but it does not make sense. Something here *PROBABLY IS* wrong */

	/*

	 * this code to get versions is reproduced as was written, but it does

	 * not make sense. Something here *PROBABLY IS* wrong

	 */

	static const uint8_t cmdReadFwVer[] = {CMD_READ_VERSIONS, VER_FIRMWARE};

	static const uint8_t cmdReadCfgVer[] = {CMD_READ_VERSIONS, VER_CONFIG};

	bool ret = true;

	/* this structure is so that we definitely do all the calls, but still return a status in case anyone cares */

	/*

	 * this structure is so that we definitely do all the calls, but still

	 * return a status in case anyone cares

	 */

	ret = i2cWrite(BUF_COMMAND, cmdReadFwVer, sizeof(cmdReadFwVer)) && ret;

	ret = i2cRead(BUF_RESPONSE, verFw, VERSION_LENGTH) && ret;

	ret = i2cWrite(BUF_COMMAND, cmdReadCfgVer, sizeof(cmdReadCfgVer)) && ret;

	ret = i2cWrite(BUF_COMMAND, cmdReadCfgVer,

					sizeof(cmdReadCfgVer)) && ret;

	ret = i2cRead(BUF_RESPONSE, verCfg, VERSION_LENGTH) && ret;

	if (logIt)

	return ret;

}

static ssize_t sysfsUpgradeStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)

static ssize_t sysfsUpgradeStore(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	const struct firmware *fw, *cfg;

	uint8_t verFw[10], verCfg[10];

	unsigned fwLen = 0, cfgLen = 0;

	bool manualUpgrade, success;

	int mode = 0;

	int mode = 0, ret;

	if (request_firmware(&fw, "it7260.fw", dev))

	ret = request_firmware(&fw, "it7260.fw", dev);

	if (ret)

		LOGE("failed to get firmware for it7260\n");

	else

		fwLen = fw->size;

	if (request_firmware(&cfg, "it7260.cfg", dev))

	ret = request_firmware(&cfg, "it7260.cfg", dev);

	if (ret)

		LOGE("failed to get config data for it7260\n");

	else

		cfgLen = cfg->size;

	sscanf(buf, "%d", &mode);

	ret = kstrtoint(buf, 10, &mode);

	manualUpgrade = mode == SYSFS_FW_UPLOAD_MODE_MANUAL;

	LOGI("firmware found %ub of fw and %ub of config in %s mode\n",

		fwLen, cfgLen, manualUpgrade ? "manual" : "normal");

			verCfg[4] < cfg->data[cfgLen - 5])){

			LOGI("firmware/config will be upgraded\n");

			disable_irq(gl_ts->client->irq);

			success = chipFirmwareUpload(fwLen, fw->data, cfgLen, cfg->data);

			success = chipFirmwareUpload(fwLen, fw->data, cfgLen,

								cfg->data);

			enable_irq(gl_ts->client->irq);

			fwUploadResult = success ? SYSFS_RESULT_SUCCESS : SYSFS_RESULT_FAIL;

			fwUploadResult = success ?

				SYSFS_RESULT_SUCCESS : SYSFS_RESULT_FAIL;

			LOGI("upload %s\n", success ? "success" : "failed");

		}

		else {

		} else {

			LOGI("firmware/config upgrade not needed\n");

		}

	}

	return count;

}

static ssize_t sysfsUpgradeShow(struct device *dev, struct device_attribute *attr, char *buf)

static ssize_t sysfsUpgradeShow(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	return sprintf(buf, "%d", fwUploadResult);

	return snprintf(buf, MAX_BUFFER_SIZE, "%d", fwUploadResult);

}

static ssize_t sysfsCalibrationShow(struct device *dev, struct device_attribute *attr, char *buf)

static ssize_t sysfsCalibrationShow(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	return sprintf(buf, "%d", calibrationWasSuccessful);

	return snprintf(buf, MAX_BUFFER_SIZE, "%d", calibrationWasSuccessful);

}

static bool chipSendCalibrationCmd(bool autoTuneOn)

	return i2cWrite(BUF_COMMAND, cmdCalibrate, sizeof(cmdCalibrate));

}

static ssize_t sysfsCalibrationStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)

static ssize_t sysfsCalibrationStore(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	uint8_t resp;

	if (!chipSendCalibrationCmd(false))

		LOGE("failed to send calibration command\n");

	else {

		calibrationWasSuccessful = i2cRead(BUF_RESPONSE, &resp, sizeof(resp)) ? SYSFS_RESULT_SUCCESS : SYSFS_RESULT_FAIL;

		calibrationWasSuccessful =

			i2cRead(BUF_RESPONSE, &resp, sizeof(resp))

			? SYSFS_RESULT_SUCCESS : SYSFS_RESULT_FAIL;

		/* previous logic that was here never called chipFirmwareReinitialize() due to checking a guaranteed-not-null value against null. We now call it. Hopefully this is OK */

		/*

		 * previous logic that was here never called

		 * chipFirmwareReinitialize() due to checking a

		 * guaranteed-not-null value against null. We now

		 * call it. Hopefully this is OK

		 */

		if (!resp)

			LOGI("chipFirmwareReinitialize -> %s\n", chipFirmwareReinitialize(CMD_FIRMWARE_REINIT_6F) ? "success" : "fail");

			LOGI("chipFirmwareReinitialize -> %s\n",

			chipFirmwareReinitialize(CMD_FIRMWARE_REINIT_6F)

			? "success" : "fail");

	}

	return count;

}

static ssize_t sysfsPointShow(struct device *dev, struct device_attribute *attr, char *buf)

static ssize_t sysfsPointShow(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	uint8_t pointData[sizeof(struct PointData)];

	bool readSuccess;

	ssize_t ret;

	readSuccess = i2cReadNoReadyCheck(BUF_POINT_INFO, pointData, sizeof(pointData));

	ret = sprintf(buf, "point_show read ret[%d]--point[%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x]=\n",

		readSuccess, pointData[0],pointData[1],pointData[2],pointData[3],

		pointData[4],pointData[5],pointData[6],pointData[7],pointData[8],

		pointData[9],pointData[10],pointData[11],pointData[12],pointData[13]);

	readSuccess = i2cReadNoReadyCheck(BUF_POINT_INFO, pointData,

							sizeof(pointData));

	ret = snprintf(buf, MAX_BUFFER_SIZE,

		"point_show read ret[%d]--point[%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x][%x]=\n",

		readSuccess, pointData[0], pointData[1], pointData[2],

		pointData[3], pointData[4], pointData[5], pointData[6],

		pointData[7], pointData[8], pointData[9], pointData[10],

		pointData[11], pointData[12], pointData[13]);

	LOGI("%s", buf);

	return ret;

}

static ssize_t sysfsPointStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)

static ssize_t sysfsPointStore(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	return count;

}

static ssize_t sysfsStatusShow(struct device *dev, struct device_attribute *attr, char *buf)

static ssize_t sysfsStatusShow(struct device *dev,

			struct device_attribute *attr, char *buf)

{

	return sprintf(buf, "%d\n", devicePresent ? 1 : 0);

	return snprintf(buf, MAX_BUFFER_SIZE, "%d\n", devicePresent ? 1 : 0);

}

static ssize_t sysfsStatusStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)

static ssize_t sysfsStatusStore(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	uint8_t verFw[10], verCfg[10];

	return count;

}

static ssize_t sysfsVersionShow(struct device *dev, struct device_attribute *attr, char *buf)

static ssize_t sysfsVersionShow(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	uint8_t verFw[10], verCfg[10];

	chipGetVersions(verFw, verCfg, false);

	return sprintf(buf, "%x,%x,%x,%x # %x,%x,%x,%x\n",verFw[5], verFw[6], verFw[7], verFw[8], verCfg[1], verCfg[2], verCfg[3], verCfg[4]);

	return snprintf(buf, MAX_BUFFER_SIZE, "%x,%x,%x,%x # %x,%x,%x,%x\n",

			verFw[5], verFw[6], verFw[7], verFw[8],

			verCfg[1], verCfg[2], verCfg[3], verCfg[4]);

}

static ssize_t sysfsVersionStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)

static ssize_t sysfsVersionStore(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	return count;

}

static ssize_t sysfsSleepShow(struct device *dev, struct device_attribute *attr, char *buf)

static ssize_t sysfsSleepShow(struct device *dev,

			struct device_attribute *attr, char *buf)

{

	/*

	 * 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

	 * 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

	 */

	if (!mutex_lock_interruptible(&sleepModeMutex)) {

		*buf = chipAwake ? '1' : '0';

		mutex_unlock(&sleepModeMutex);

		return 1;

	}

	else

	} else {

		return -EINTR;

	}

}

static ssize_t sysfsSleepStore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)

static ssize_t sysfsSleepStore(struct device *dev,

		struct device_attribute *attr, const char *buf, size_t count)

{

	static const uint8_t cmdGoSleep[] = {CMD_PWR_CTL, 0x00, PWR_CTL_SLEEP_MODE};

	int goToSleepVal;

	static const uint8_t cmdGoSleep[] = {CMD_PWR_CTL,

					0x00, PWR_CTL_SLEEP_MODE};

	int goToSleepVal, ret;

	bool goToWake;

	uint8_t dummy;

	sscanf(buf, "%d", &goToSleepVal);

	goToWake = !goToSleepVal;	/* convert to bool of proper polarity */

	ret = kstrtoint(buf, 10, &goToSleepVal);

	/* convert to bool of proper polarity */

	goToWake = !goToSleepVal;

	if (!mutex_lock_interruptible(&sleepModeMutex)) {

		if ((chipAwake && goToWake) || (!chipAwake && !goToWake))

			LOGE("duplicate request to %s chip\n", goToWake ? "wake" : "sleep");

			LOGE("duplicate request to %s chip\n",

				goToWake ? "wake" : "sleep");

		else if (goToWake) {

			i2cReadNoReadyCheck(BUF_QUERY, &dummy, sizeof(dummy));

			enable_irq(gl_ts->client->irq);

			LOGI("touch is going to wake!\n\n");

			LOGI("touch is going to wake!\n");

		} else {

			disable_irq(gl_ts->client->irq);

			i2cWriteNoReadyCheck(BUF_COMMAND, cmdGoSleep, sizeof(cmdGoSleep));

			LOGI("touch is going to sleep...\n\n");

			i2cWriteNoReadyCheck(BUF_COMMAND, cmdGoSleep,

						sizeof(cmdGoSleep));

			LOGI("touch is going to sleep...\n");

		}

		chipAwake = goToWake;

		mutex_unlock(&sleepModeMutex);

		return count;

	} else

	} else {

		return -EINTR;

	}

}

static DEVICE_ATTR(status, S_IRUGO|S_IWUSR|S_IWGRP, sysfsStatusShow, sysfsStatusStore);

static DEVICE_ATTR(version, S_IRUGO|S_IWUSR|S_IWGRP, sysfsVersionShow, sysfsVersionStore);

static DEVICE_ATTR(sleep, S_IRUGO|S_IWUSR|S_IWGRP, sysfsSleepShow, sysfsSleepStore);

static DEVICE_ATTR(status, S_IRUGO|S_IWUSR|S_IWGRP,

				sysfsStatusShow, sysfsStatusStore);

static DEVICE_ATTR(version, S_IRUGO|S_IWUSR|S_IWGRP,

				sysfsVersionShow, sysfsVersionStore);

static DEVICE_ATTR(sleep, S_IRUGO|S_IWUSR|S_IWGRP,

				sysfsSleepShow, sysfsSleepStore);

static struct attribute *it7260_attrstatus[] = {

	&dev_attr_status.attr,

	.attrs = it7260_attrstatus,

};

static DEVICE_ATTR(calibration, S_IRUGO|S_IWUSR|S_IWGRP, sysfsCalibrationShow, sysfsCalibrationStore);

static DEVICE_ATTR(upgrade, S_IRUGO|S_IWUSR|S_IWGRP, sysfsUpgradeShow, sysfsUpgradeStore);

static DEVICE_ATTR(point, S_IRUGO|S_IWUSR|S_IWGRP, sysfsPointShow, sysfsPointStore);

static DEVICE_ATTR(calibration, S_IRUGO|S_IWUSR|S_IWGRP,

			sysfsCalibrationShow, sysfsCalibrationStore);

static DEVICE_ATTR(upgrade, S_IRUGO|S_IWUSR|S_IWGRP,

			sysfsUpgradeShow, sysfsUpgradeStore);

static DEVICE_ATTR(point, S_IRUGO|S_IWUSR|S_IWGRP,

			sysfsPointShow, sysfsPointStore);

static struct attribute *it7260_attributes[] = {

	&dev_attr_calibration.attr,

{

	uint8_t resp[2];

	LOGI("sent calibration command -> %d\n", chipSendCalibrationCmd(autoTuneEnabled));

	LOGI("sent calibration command -> %d\n",

			chipSendCalibrationCmd(autoTuneEnabled));

	waitDeviceReady(true, true);

	i2cReadNoReadyCheck(BUF_RESPONSE, resp, sizeof(resp));

	chipFirmwareReinitialize(CMD_FIRMWARE_REINIT_C);

}

EXPORT_SYMBOL(sendCalibrationCmd);

static void readFingerData(uint16_t *xP, uint16_t *yP, uint8_t *pressureP, const struct FingerData *fd)

static void readFingerData(uint16_t *xP, uint16_t *yP, uint8_t *pressureP,

						const struct FingerData *fd)

{

	uint16_t x = fd->xLo;

	uint16_t y = fd->yLo;

	/* verify there is point data to read & it is readable and valid */

	i2cReadNoReadyCheck(BUF_QUERY, &devStatus, sizeof(devStatus));

	if (!((devStatus & PT_INFO_BITS) & PT_INFO_YES)) {

		LOGE("readTouchDataPoint() called when no data available (0x%02X)\n", devStatus);

		pr_err("readTouchDataPoint() called when no data available (0x%02X)\n",

								devStatus);

		return;

	}

	if (!i2cReadNoReadyCheck(BUF_POINT_INFO, (void*)&pointData, sizeof(pointData))) {

		LOGE("readTouchDataPoint() failed to read point data buffer\n");

	if (!i2cReadNoReadyCheck(BUF_POINT_INFO, (void *)&pointData,

						sizeof(pointData))) {

		pr_err("readTouchDataPoint() failed to read point data buffer\n");

		return;

	}

	if ((pointData.flags & PD_FLAGS_DATA_TYPE_BITS) != PD_FLAGS_DATA_TYPE_TOUCH) {

		LOGE("readTouchDataPoint() dropping non-point data of type 0x%02X\n", pointData.flags);

	if ((pointData.flags & PD_FLAGS_DATA_TYPE_BITS) !=

					PD_FLAGS_DATA_TYPE_TOUCH) {

		pr_err("readTouchDataPoint() dropping non-point data of type 0x%02X\n",

							pointData.flags);

		return;

	}

static irqreturn_t IT7260_ts_threaded_handler(int irq, void *devid)

{

	smp_rmb();

	if (isDeviceSleeping) {

		smp_wmb();