input: synaptics: Add support for new firmware versions (0858fc7e) · Commits · e / devices / android_kernel_sony_msm8994

drivers/input/touchscreen/synaptics_fw_update.c

+226 −76

Original line number	Original line	Diff line number	Diff line
	@@ -35,11 +35,8 @@
	#define INSIDE_FIRMWARE_UPDATE		#define INSIDE_FIRMWARE_UPDATE

	#define FW_IMAGE_OFFSET 0x100		#define FW_IMAGE_OFFSET 0x100
			/* 0 to ignore flash block check to speed up flash time */
	#define BOOTLOADER_ID_OFFSET 0		#define CHECK_FLASH_BLOCK_STATUS 1
	#define FLASH_PROPERTIES_OFFSET 2
	#define BLOCK_SIZE_OFFSET 3
	#define FW_BLOCK_COUNT_OFFSET 5

	#define REG_MAP (1 << 0)		#define REG_MAP (1 << 0)
	#define UNLOCKED (1 << 1)		#define UNLOCKED (1 << 1)
	@@ -49,9 +46,6 @@
	#define HAS_DISP_CONFIG (1 << 5)		#define HAS_DISP_CONFIG (1 << 5)
	#define HAS_CTRL1 (1 << 6)		#define HAS_CTRL1 (1 << 6)

	#define BLOCK_NUMBER_OFFSET 0
	#define BLOCK_DATA_OFFSET 2

	#define RMI4_INFO_MAX_LEN 200		#define RMI4_INFO_MAX_LEN 200

	#define RMI4_STORE_TS_INFO(buf, id, rev, fw_ver) \		#define RMI4_STORE_TS_INFO(buf, id, rev, fw_ver) \
	@@ -91,6 +85,17 @@ enum image_file_option {
	OPTION_CONTAIN_BOOTLOADER = 1,		OPTION_CONTAIN_BOOTLOADER = 1,
	};		};

			enum flash_offset {
			OFFSET_BOOTLOADER_ID,
			OFFSET_FLASH_PROPERTIES,
			OFFSET_BLOCK_SIZE,
			OFFSET_FW_BLOCK_COUNT,
			OFFSET_BLOCK_NUMBER,
			OFFSET_BLOCK_DATA,
			OFFSET_FLASH_CONTROL,
			OFFSET_FLASH_STATUS
			};

	#define SLEEP_MODE_NORMAL (0x00)		#define SLEEP_MODE_NORMAL (0x00)
	#define SLEEP_MODE_SENSOR_SLEEP (0x01)		#define SLEEP_MODE_SENSOR_SLEEP (0x01)
	#define SLEEP_MODE_RESERVED0 (0x02)		#define SLEEP_MODE_RESERVED0 (0x02)
	@@ -101,9 +106,7 @@ enum image_file_option {
	#define ERASE_WAIT_MS (5 * 1000)		#define ERASE_WAIT_MS (5 * 1000)
	#define RESET_WAIT_MS (500)		#define RESET_WAIT_MS (500)

	#define POLLING_MODE 0		#define SLEEP_TIME_US 100

	#define SLEEP_TIME_US 50

	static int fwu_wait_for_idle(int timeout_ms);		static int fwu_wait_for_idle(int timeout_ms);

	@@ -194,11 +197,28 @@ struct f01_device_control {

	struct f34_flash_control {		struct f34_flash_control {
	union {		union {
			/* version 0 */
	struct {		struct {
	unsigned char command:4;		unsigned char command_v0:4;
	unsigned char status:3;		unsigned char status:3;
	unsigned char program_enabled:1;		unsigned char program_enabled:1;
	} __packed;		} __packed;
			/* version 1 */
			struct {
			unsigned char command_v1:6;
			unsigned char reserved:2;
			} __packed;
			unsigned char data[1];
			};
			};

			struct f34_flash_status {
			union {
			struct {
			unsigned char status:6;
			unsigned char reserved:1;
			unsigned char program_enabled:1;
			} __packed;
	unsigned char data[1];		unsigned char data[1];
	};		};
	};		};
	@@ -222,6 +242,8 @@ struct f34_flash_properties {
	struct synaptics_rmi4_fwu_handle {		struct synaptics_rmi4_fwu_handle {
	bool initialized;		bool initialized;
	bool force_update;		bool force_update;
			bool interrupt_flag;
			bool polling_mode;
	char product_id[SYNAPTICS_RMI4_PRODUCT_ID_SIZE + 1];		char product_id[SYNAPTICS_RMI4_PRODUCT_ID_SIZE + 1];
	unsigned int image_size;		unsigned int image_size;
	unsigned int data_pos;		unsigned int data_pos;
	@@ -241,13 +263,11 @@ struct synaptics_rmi4_fwu_handle {
	unsigned short disp_config_block_count;		unsigned short disp_config_block_count;
	unsigned short config_size;		unsigned short config_size;
	unsigned short config_area;		unsigned short config_area;
	unsigned short addr_f34_flash_control;
	unsigned short addr_f01_interrupt_register;		unsigned short addr_f01_interrupt_register;
	struct synaptics_rmi4_fn_desc f01_fd;		struct synaptics_rmi4_fn_desc f01_fd;
	struct synaptics_rmi4_fn_desc f34_fd;		struct synaptics_rmi4_fn_desc f34_fd;
	struct synaptics_rmi4_exp_fn_ptr *fn_ptr;		struct synaptics_rmi4_exp_fn_ptr *fn_ptr;
	struct synaptics_rmi4_data *rmi4_data;		struct synaptics_rmi4_data *rmi4_data;
	struct f34_flash_control flash_control;
	struct f34_flash_properties flash_properties;		struct f34_flash_properties flash_properties;
	struct workqueue_struct *fwu_workqueue;		struct workqueue_struct *fwu_workqueue;
	struct delayed_work fwu_work;		struct delayed_work fwu_work;
	@@ -352,6 +372,62 @@ static int fwu_read_f01_device_status(struct f01_device_status *status)
	return 0;		return 0;
	}		}

			static unsigned short fwu_get_address(enum flash_offset type)
			{
			int offset;
			unsigned short addr = 0;
			struct i2c_client *i2c_client = fwu->rmi4_data->i2c_client;

			switch (type) {
			case OFFSET_BOOTLOADER_ID:
			offset = 0;
			addr = fwu->f34_fd.query_base_addr + offset;
			break;
			case OFFSET_FLASH_PROPERTIES:
			offset = ((fwu->f34_fd.version == 0) ? 2 : 1);
			addr = fwu->f34_fd.query_base_addr + offset;
			break;
			case OFFSET_BLOCK_SIZE:
			offset = ((fwu->f34_fd.version == 0) ? 3 : 2);
			addr = fwu->f34_fd.query_base_addr + offset;
			break;
			case OFFSET_FW_BLOCK_COUNT:
			offset = ((fwu->f34_fd.version == 0) ? 5 : 3);
			addr = fwu->f34_fd.query_base_addr + offset;
			break;
			case OFFSET_BLOCK_NUMBER:
			offset = 0;
			addr = fwu->f34_fd.data_base_addr + offset;
			break;
			case OFFSET_BLOCK_DATA:
			offset = ((fwu->f34_fd.version == 0) ? 2 : 1);
			addr = fwu->f34_fd.data_base_addr + offset;
			break;
			case OFFSET_FLASH_CONTROL:
			offset = ((fwu->f34_fd.version == 0) ?
			2 + (fwu->block_size) : 2);
			addr = fwu->f34_fd.data_base_addr + offset;
			break;
			case OFFSET_FLASH_STATUS:
			if (fwu->f34_fd.version == 1) {
			offset = 3;
			addr = fwu->f34_fd.data_base_addr + offset;
			} else if (fwu->f34_fd.version == 0) {
			dev_warn(&i2c_client->dev,
			"%s: F$34 version 0 does not contain " \
			"flash status register\n",
			__func__);
			}
			break;
			default:
			dev_err(&i2c_client->dev,
			"%s: Unknown flash offset (%d)\n",
			__func__, type);
			break;
			}
			return addr;
			}

	static int fwu_read_f34_queries(void)		static int fwu_read_f34_queries(void)
	{		{
	int retval;		int retval;
	@@ -360,7 +436,7 @@ static int fwu_read_f34_queries(void)
	struct i2c_client *i2c_client = fwu->rmi4_data->i2c_client;		struct i2c_client *i2c_client = fwu->rmi4_data->i2c_client;

	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->f34_fd.query_base_addr + BOOTLOADER_ID_OFFSET,		fwu_get_address(OFFSET_BOOTLOADER_ID),
	fwu->bootloader_id,		fwu->bootloader_id,
	sizeof(fwu->bootloader_id));		sizeof(fwu->bootloader_id));
	if (retval < 0) {		if (retval < 0) {
	@@ -371,7 +447,7 @@ static int fwu_read_f34_queries(void)
	}		}

	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->f34_fd.query_base_addr + FLASH_PROPERTIES_OFFSET,		fwu_get_address(OFFSET_FLASH_PROPERTIES),
	fwu->flash_properties.data,		fwu->flash_properties.data,
	sizeof(fwu->flash_properties.data));		sizeof(fwu->flash_properties.data));
	if (retval < 0) {		if (retval < 0) {
	@@ -397,7 +473,7 @@ static int fwu_read_f34_queries(void)
	count += 2;		count += 2;

	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->f34_fd.query_base_addr + BLOCK_SIZE_OFFSET,		fwu_get_address(OFFSET_BLOCK_SIZE),
	buf,		buf,
	2);		2);
	if (retval < 0) {		if (retval < 0) {
	@@ -410,7 +486,7 @@ static int fwu_read_f34_queries(void)
	batohs(&fwu->block_size, &(buf[0]));		batohs(&fwu->block_size, &(buf[0]));

	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->f34_fd.query_base_addr + FW_BLOCK_COUNT_OFFSET,		fwu_get_address(OFFSET_FW_BLOCK_COUNT),
	buf,		buf,
	count);		count);
	if (retval < 0) {		if (retval < 0) {
	@@ -438,9 +514,6 @@ static int fwu_read_f34_queries(void)
	if (fwu->flash_properties.has_display_config)		if (fwu->flash_properties.has_display_config)
	batohs(&fwu->disp_config_block_count, &(buf[count]));		batohs(&fwu->disp_config_block_count, &(buf[count]));

	fwu->addr_f34_flash_control = fwu->f34_fd.data_base_addr +
	BLOCK_DATA_OFFSET +
	fwu->block_size;
	return 0;		return 0;
	}		}

	@@ -461,18 +534,36 @@ static int fwu_read_interrupt_status(void)
	return interrupt_status;		return interrupt_status;
	}		}

	static int fwu_read_f34_flash_status(void)		static int fwu_read_f34_flash_status(unsigned char *status)
	{		{
	int retval;		int retval;
			struct f34_flash_control flash_control;
			struct f34_flash_status flash_status;

			if (fwu->f34_fd.version == 1) {
	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->addr_f34_flash_control,		fwu_get_address(OFFSET_FLASH_STATUS),
	fwu->flash_control.data,		flash_status.data,
	sizeof(fwu->flash_control.data));		sizeof(flash_status.data));
	if (retval < 0) {		if (retval < 0) {
	dev_err(&fwu->rmi4_data->i2c_client->dev,		dev_err(&fwu->rmi4_data->i2c_client->dev,
	"%s: Failed to read flash status\n",		"%s: Failed to read flash status\n",
	__func__);		__func__);
	return retval;		return -EIO;
			}
			*status = flash_status.status;
			} else {
			retval = fwu->fn_ptr->read(fwu->rmi4_data,
			fwu_get_address(OFFSET_FLASH_CONTROL),
			flash_control.data,
			sizeof(flash_control.data));
			if (retval < 0) {
			dev_err(&fwu->rmi4_data->i2c_client->dev,
			"%s: Failed to read flash status\n",
			__func__);
			return -EIO;
			}
			*status = flash_control.status;
	}		}
	return 0;		return 0;
	}		}
	@@ -492,22 +583,27 @@ static int fwu_reset_device(void)
	__func__);		__func__);
	return retval;		return retval;
	}		}

			fwu->polling_mode = false;

	return 0;		return 0;
	}		}

	static int fwu_write_f34_command(unsigned char cmd)		static int fwu_write_f34_command(unsigned char cmd)
	{		{
	int retval;		int retval;
			struct f34_flash_control flash_control;

	fwu->flash_control.data[0] = cmd;		flash_control.data[0] = cmd;
			fwu->interrupt_flag = false;
	retval = fwu->fn_ptr->write(fwu->rmi4_data,		retval = fwu->fn_ptr->write(fwu->rmi4_data,
	fwu->addr_f34_flash_control,		fwu_get_address(OFFSET_FLASH_CONTROL),
	fwu->flash_control.data,		flash_control.data,
	sizeof(fwu->flash_control.data));		sizeof(flash_control.data));
	if (retval < 0) {		if (retval < 0) {
	dev_err(&fwu->rmi4_data->i2c_client->dev,		dev_err(&fwu->rmi4_data->i2c_client->dev,
	"%s: Failed to write command 0x%02x\n",		"%s: Failed to write command 0x%02x\n",
	__func__, fwu->flash_control.data[0]);		__func__, flash_control.data[0]);
	return retval;		return retval;
	}		}
	return 0;		return 0;
	@@ -518,18 +614,21 @@ static int fwu_wait_for_idle(int timeout_ms)
	int count = 0;		int count = 0;
	int timeout_count = ((timeout_ms * 1000) / SLEEP_TIME_US) + 1;		int timeout_count = ((timeout_ms * 1000) / SLEEP_TIME_US) + 1;
	do {		do {
	#if POLLING_MODE		if (fwu->interrupt_flag)
	fwu_read_f34_flash_status();
	#endif
	if (fwu->flash_control.command == 0x00)
	return 0;		return 0;
			if (fwu->polling_mode)
	usleep_range(SLEEP_TIME_US, SLEEP_TIME_US + 100);		if (fwu->intr_mask & fwu_read_interrupt_status())
			return 0;
			usleep_range(SLEEP_TIME_US, SLEEP_TIME_US + 1);
	} while (count++ < timeout_count);		} while (count++ < timeout_count);

	fwu_read_f34_flash_status();		if (fwu->intr_mask & fwu_read_interrupt_status()) {
	if (fwu->flash_control.command == 0x00)		fwu->polling_mode = true;
			dev_info(&fwu->rmi4_data->i2c_client->dev,
			"%s: Switch to polling mode\n",
			__func__);
	return 0;		return 0;
			}

	dev_err(&fwu->rmi4_data->i2c_client->dev,		dev_err(&fwu->rmi4_data->i2c_client->dev,
	"%s: Timed out waiting for idle status\n",		"%s: Timed out waiting for idle status\n",
	@@ -578,6 +677,28 @@ static enum flash_area fwu_go_nogo(struct image_header *header)
	}		}
	}		}

			/* check firmware size */
			if (fwu->fw_block_count * fwu->block_size != header->image_size) {
			dev_err(&i2c_client->dev,
			"%s: firmware size of device (%d) != .img (%d)\n",
			__func__,
			fwu->config_block_count * fwu->block_size,
			header->image_size);
			flash_area = NONE;
			goto exit;
			}

			/* check config size */
			if (fwu->fw_block_count * fwu->block_size != header->config_size) {
			dev_err(&i2c_client->dev,
			"%s: config size of device (%d) != .img (%d)\n",
			__func__,
			fwu->config_block_count * fwu->block_size,
			header->config_size);
			flash_area = NONE;
			goto exit;
			}

	retval = fwu_read_f01_device_status(&f01_device_status);		retval = fwu_read_f01_device_status(&f01_device_status);
	if (retval < 0) {		if (retval < 0) {
	flash_area = NONE;		flash_area = NONE;
	@@ -593,6 +714,11 @@ static enum flash_area fwu_go_nogo(struct image_header *header)
	goto exit;		goto exit;
	}		}

			if (fwu->ext_data_source) {
			flash_area = UI_FIRMWARE;
			goto exit;
			}

	/* device firmware id */		/* device firmware id */
	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->f01_fd.query_base_addr + 18,		fwu->f01_fd.query_base_addr + 18,
	@@ -771,8 +897,11 @@ static int fwu_write_blocks(unsigned char *block_ptr, unsigned short block_cnt,
	unsigned char command)		unsigned char command)
	{		{
	int retval;		int retval;
			unsigned char flash_status;
	unsigned char block_offset[] = {0, 0};		unsigned char block_offset[] = {0, 0};
	unsigned short block_num;		unsigned short block_num;
			unsigned short addr_block_data = fwu_get_address(OFFSET_BLOCK_DATA);
			unsigned short addr_block_num = fwu_get_address(OFFSET_BLOCK_NUMBER);
	struct i2c_client *i2c_client = fwu->rmi4_data->i2c_client;		struct i2c_client *i2c_client = fwu->rmi4_data->i2c_client;
	#ifdef SHOW_PROGRESS		#ifdef SHOW_PROGRESS
	unsigned int progress = (command == CMD_WRITE_CONFIG_BLOCK) ?		unsigned int progress = (command == CMD_WRITE_CONFIG_BLOCK) ?
	@@ -785,7 +914,7 @@ static int fwu_write_blocks(unsigned char *block_ptr, unsigned short block_cnt,
	command == CMD_WRITE_CONFIG_BLOCK ?		command == CMD_WRITE_CONFIG_BLOCK ?
	"config" : "firmware");		"config" : "firmware");
	retval = fwu->fn_ptr->write(fwu->rmi4_data,		retval = fwu->fn_ptr->write(fwu->rmi4_data,
	fwu->f34_fd.data_base_addr + BLOCK_NUMBER_OFFSET,		addr_block_num,
	block_offset,		block_offset,
	sizeof(block_offset));		sizeof(block_offset));
	if (retval < 0) {		if (retval < 0) {
	@@ -806,7 +935,7 @@ static int fwu_write_blocks(unsigned char *block_ptr, unsigned short block_cnt,
	block_num, block_cnt);		block_num, block_cnt);
	#endif		#endif
	retval = fwu->fn_ptr->write(fwu->rmi4_data,		retval = fwu->fn_ptr->write(fwu->rmi4_data,
	fwu->f34_fd.data_base_addr + BLOCK_DATA_OFFSET,		addr_block_data,
	block_ptr,		block_ptr,
	fwu->block_size);		fwu->block_size);
	if (retval < 0) {		if (retval < 0) {
	@@ -832,13 +961,21 @@ static int fwu_write_blocks(unsigned char *block_ptr, unsigned short block_cnt,
	return retval;		return retval;
	}		}

	if (fwu->flash_control.status != 0x00) {		#if CHECK_FLASH_BLOCK_STATUS
			retval = fwu_read_f34_flash_status(&flash_status);
			if (retval < 0) {
	dev_err(&i2c_client->dev,		dev_err(&i2c_client->dev,
	"%s: Flash block %d failed, status 0x%02X\n",		"%s: Failed to read flash status (block %d)\n",
	__func__, block_num, retval);		__func__, block_num);
	return retval;		return retval;
	}		}
			if (flash_status != 0x00) {
			dev_err(&i2c_client->dev,
			"%s: Flash block %d failed, status 0x%02X\n",
			__func__, block_num, flash_status);
			return -EINVAL;
			}
			#endif
	block_ptr += fwu->block_size;		block_ptr += fwu->block_size;
	}		}
	#ifdef SHOW_PROGRESS		#ifdef SHOW_PROGRESS
	@@ -874,7 +1011,7 @@ static int fwu_write_bootloader_id(void)
	fwu->bootloader_id[1]);		fwu->bootloader_id[1]);

	retval = fwu->fn_ptr->write(fwu->rmi4_data,		retval = fwu->fn_ptr->write(fwu->rmi4_data,
	fwu->f34_fd.data_base_addr + BLOCK_DATA_OFFSET,		fwu_get_address(OFFSET_BLOCK_DATA),
	fwu->bootloader_id,		fwu->bootloader_id,
	sizeof(fwu->bootloader_id));		sizeof(fwu->bootloader_id));
	if (retval < 0) {		if (retval < 0) {
	@@ -961,13 +1098,14 @@ static int fwu_enter_flash_prog(void)
	__func__);		__func__);
	return retval;		return retval;
	}		}
			fwu->polling_mode = false;
	return retval;		return retval;
	}		}

	static int fwu_do_reflash(void)		static int fwu_do_reflash(void)
	{		{
	int retval;		int retval;
			unsigned char flash_status;

	retval = fwu_enter_flash_prog();		retval = fwu_enter_flash_prog();
	if (retval < 0)		if (retval < 0)
	@@ -997,11 +1135,14 @@ static int fwu_do_reflash(void)
	if (retval < 0)		if (retval < 0)
	return retval;		return retval;

	if (fwu->flash_control.status != 0x00) {		retval = fwu_read_f34_flash_status(&flash_status);
			if (retval < 0)
			return retval;
			if (flash_status != 0x00) {
	dev_err(&fwu->rmi4_data->i2c_client->dev,		dev_err(&fwu->rmi4_data->i2c_client->dev,
	"%s: Erase all command failed, status 0x%02X\n",		"%s: Erase all command failed, status 0x%02X\n",
	__func__, retval);		__func__, flash_status);
	return -1;		return -EINVAL;
	}		}

	if (fwu->firmware_data) {		if (fwu->firmware_data) {
	@@ -1195,7 +1336,7 @@ static int fwu_do_read_config(void)
	block_offset[1] \|= (fwu->config_area << 5);		block_offset[1] \|= (fwu->config_area << 5);

	retval = fwu->fn_ptr->write(fwu->rmi4_data,		retval = fwu->fn_ptr->write(fwu->rmi4_data,
	fwu->f34_fd.data_base_addr + BLOCK_NUMBER_OFFSET,		fwu_get_address(OFFSET_BLOCK_NUMBER),
	block_offset,		block_offset,
	sizeof(block_offset));		sizeof(block_offset));
	if (retval < 0) {		if (retval < 0) {
	@@ -1223,7 +1364,7 @@ static int fwu_do_read_config(void)
	}		}

	retval = fwu->fn_ptr->read(fwu->rmi4_data,		retval = fwu->fn_ptr->read(fwu->rmi4_data,
	fwu->f34_fd.data_base_addr + BLOCK_DATA_OFFSET,		fwu_get_address(OFFSET_BLOCK_DATA),
	&fwu->read_config_buf[index],		&fwu->read_config_buf[index],
	fwu->block_size);		fwu->block_size);
	if (retval < 0) {		if (retval < 0) {
	@@ -1253,23 +1394,25 @@ static int fwu_start_reflash(void)

	pr_notice("%s: Start of reflash process\n", __func__);		pr_notice("%s: Start of reflash process\n", __func__);

	if (strnlen(fwu->rmi4_data->fw_image_name, NAME_BUFFER_SIZE) == 0) {		if (fwu->ext_data_source)
			fw_image = fwu->ext_data_source;
			else {
			if (strnlen(fwu->rmi4_data->fw_image_name,
			NAME_BUFFER_SIZE) == 0) {
	dev_err(&fwu->rmi4_data->i2c_client->dev,		dev_err(&fwu->rmi4_data->i2c_client->dev,
	"Firmware image name not given, skipping update\n");		"Firmware image name not given, "\
			"skipping update\n");
	return 0;		return 0;
	}		}

	if (strnlen(fwu->rmi4_data->fw_image_name, NAME_BUFFER_SIZE) ==		if (strnlen(fwu->rmi4_data->fw_image_name, NAME_BUFFER_SIZE) ==
	NAME_BUFFER_SIZE) {		NAME_BUFFER_SIZE) {
	dev_err(&fwu->rmi4_data->i2c_client->dev,		dev_err(&fwu->rmi4_data->i2c_client->dev,
	"Firmware image name exceeds max length (%d), " \		"Firmware image name exceeds max length " \
	"skipping update\n", NAME_BUFFER_SIZE);		"(%d), skipping update\n", NAME_BUFFER_SIZE);
	return 0;		return 0;
	}		}

	if (fwu->ext_data_source)
	fw_image = fwu->ext_data_source;
	else {
	snprintf(fwu->firmware_name, NAME_BUFFER_SIZE, "%s",		snprintf(fwu->firmware_name, NAME_BUFFER_SIZE, "%s",
	fwu->rmi4_data->fw_image_name);		fwu->rmi4_data->fw_image_name);
	dev_info(&fwu->rmi4_data->i2c_client->dev,		dev_info(&fwu->rmi4_data->i2c_client->dev,
	@@ -1303,11 +1446,16 @@ static int fwu_start_reflash(void)
	header.image_size;		header.image_size;
	}		}

	if (fwu->ext_data_source)
	flash_area = UI_FIRMWARE;
	else
	flash_area = fwu_go_nogo(&header);		flash_area = fwu_go_nogo(&header);

			if (fwu->rmi4_data->sensor_sleep) {
			dev_err(&fwu->rmi4_data->i2c_client->dev,
			"%s: Sensor sleeping\n",
			__func__);
			return -ENODEV;
			}
			fwu->rmi4_data->stay_awake = true;

	switch (flash_area) {		switch (flash_area) {
	case NONE:		case NONE:
	case MISMATCH:		case MISMATCH:
	@@ -1362,6 +1510,7 @@ exit:
	release_firmware(fw_entry);		release_firmware(fw_entry);

	pr_notice("%s: End of reflash process\n", __func__);		pr_notice("%s: End of reflash process\n", __func__);
			fwu->rmi4_data->stay_awake = false;
	return retval;		return retval;
	}		}

	@@ -1714,7 +1863,7 @@ static void synaptics_rmi4_fwu_attn(struct synaptics_rmi4_data *rmi4_data,
	unsigned char intr_mask)		unsigned char intr_mask)
	{		{
	if (fwu->intr_mask & intr_mask)		if (fwu->intr_mask & intr_mask)
	fwu_read_f34_flash_status();		fwu->interrupt_flag = true;

	return;		return;
	}		}
	@@ -1851,6 +2000,7 @@ static int synaptics_rmi4_fwu_init(struct synaptics_rmi4_data *rmi4_data)

	fwu->initialized = true;		fwu->initialized = true;
	fwu->force_update = FORCE_UPDATE;		fwu->force_update = FORCE_UPDATE;
			fwu->polling_mode = false;

	retval = sysfs_create_bin_file(&rmi4_data->i2c_client->dev.kobj,		retval = sysfs_create_bin_file(&rmi4_data->i2c_client->dev.kobj,
	&dev_attr_data);		&dev_attr_data);

drivers/input/touchscreen/synaptics_i2c_rmi4.c

+17 −0

Original line number	Original line	Diff line number	Diff line
	@@ -3096,6 +3096,11 @@ static void synaptics_rmi4_early_suspend(struct early_suspend *h)
	container_of(h, struct synaptics_rmi4_data,		container_of(h, struct synaptics_rmi4_data,
	early_suspend);		early_suspend);

			if (rmi4_data->stay_awake)
			rmi4_data->staying_awake = true;
			else
			rmi4_data->staying_awake = false;

	rmi4_data->touch_stopped = true;		rmi4_data->touch_stopped = true;
	wake_up(&rmi4_data->wait);		wake_up(&rmi4_data->wait);
	synaptics_rmi4_irq_enable(rmi4_data, false);		synaptics_rmi4_irq_enable(rmi4_data, false);
	@@ -3122,6 +3127,9 @@ static void synaptics_rmi4_late_resume(struct early_suspend *h)
	container_of(h, struct synaptics_rmi4_data,		container_of(h, struct synaptics_rmi4_data,
	early_suspend);		early_suspend);

			if (rmi4_data->staying_awake)
			return;

	if (rmi4_data->full_pm_cycle)		if (rmi4_data->full_pm_cycle)
	synaptics_rmi4_resume(&(rmi4_data->input_dev->dev));		synaptics_rmi4_resume(&(rmi4_data->input_dev->dev));

	@@ -3266,6 +3274,12 @@ static int synaptics_rmi4_suspend(struct device *dev)
	struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);		struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
	int retval;		int retval;

			if (rmi4_data->stay_awake) {
			rmi4_data->staying_awake = true;
			return 0;
			} else
			rmi4_data->staying_awake = false;

	if (rmi4_data->suspended) {		if (rmi4_data->suspended) {
	dev_info(dev, "Already in suspend state\n");		dev_info(dev, "Already in suspend state\n");
	return 0;		return 0;
	@@ -3317,6 +3331,9 @@ static int synaptics_rmi4_resume(struct device *dev)
	struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);		struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
	int retval;		int retval;

			if (rmi4_data->staying_awake)
			return 0;

	if (!rmi4_data->suspended) {		if (!rmi4_data->suspended) {
	dev_info(dev, "Already in awake state\n");		dev_info(dev, "Already in awake state\n");
	return 0;		return 0;

drivers/input/touchscreen/synaptics_i2c_rmi4.h

+7 −2

Original line number	Original line	Diff line number	Diff line
	@@ -86,9 +86,12 @@ struct synaptics_rmi4_fn_desc {
	unsigned char cmd_base_addr;		unsigned char cmd_base_addr;
	unsigned char ctrl_base_addr;		unsigned char ctrl_base_addr;
	unsigned char data_base_addr;		unsigned char data_base_addr;
	unsigned char intr_src_count;		unsigned char intr_src_count:3;
			unsigned char reserved_b3_b4:2;
			unsigned char version:2;
			unsigned char reserved_b7:1;
	unsigned char fn_number;		unsigned char fn_number;
	};		} __packed;

	/*		/*
	* synaptics_rmi4_fn_full_addr - full 16-bit base addresses		* synaptics_rmi4_fn_full_addr - full 16-bit base addresses
	@@ -236,6 +239,8 @@ struct synaptics_rmi4_data {
	bool fw_updating;		bool fw_updating;
	bool suspended;		bool suspended;
	wait_queue_head_t wait;		wait_queue_head_t wait;
			bool stay_awake;
			bool staying_awake;
	int (i2c_read)(struct synaptics_rmi4_data pdata, unsigned short addr,		int (i2c_read)(struct synaptics_rmi4_data pdata, unsigned short addr,
	unsigned char *data, unsigned short length);		unsigned char *data, unsigned short length);
	int (i2c_write)(struct synaptics_rmi4_data pdata, unsigned short addr,		int (i2c_write)(struct synaptics_rmi4_data pdata, unsigned short addr,