linux-kernel - [PATCH 1/1] Input: atmel_mxt_ts: split large i2c transfers into blocks

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [thread-next>] [day] [month] [year] [list]

Message-ID: <20200729092252.6394-1-jiada_wang@mentor.com>
Date:   Wed, 29 Jul 2020 18:22:52 +0900
From:   Jiada Wang <jiada_wang@...tor.com>
To:     <nick@...anahar.org>, <dmitry.torokhov@...il.com>
CC:     <linux-input@...r.kernel.org>, <linux-kernel@...r.kernel.org>,
        <erosca@...adit-jv.com>, <Andrew_Gabbasov@...tor.com>,
        <digetx@...il.com>, <jiada_wang@...tor.com>
Subject: [PATCH 1/1] Input: atmel_mxt_ts: split large i2c transfers into blocks

From: Jiada wang <jiada_wang@...tor.com>

Some I2C controllers constrain maximum transferred data in an I2C
transaction by set max_[read|write]_len of i2c_adapter_quirk.
Large i2c transfer transaction beyond this limitation may fail to complete,
cause I2C controller driver aborts the transaction and returns failure.

Therefore this patch was created to split large i2c transaction into
smaller chunks which can complete within max_[read|write]_len defined
by I2C controller driver.

CC: Dmitry Osipenko <digetx@...il.com>
Signed-off-by: Jiada wang <jiada_wang@...tor.com>
---
 drivers/input/touchscreen/atmel_mxt_ts.c | 60 ++++++++++++++++++++++--
 1 file changed, 55 insertions(+), 5 deletions(-)

diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index a2189739e30f..d7c3c24aa663 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -620,8 +620,8 @@ static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
 	return 0;
 }
 
-static int __mxt_read_reg(struct i2c_client *client,
-			       u16 reg, u16 len, void *val)
+static int __mxt_read_chunk(struct i2c_client *client,
+			    u16 reg, u16 len, void *val)
 {
 	struct i2c_msg xfer[2];
 	u8 buf[2];
@@ -655,8 +655,33 @@ static int __mxt_read_reg(struct i2c_client *client,
 	return ret;
 }
 
-static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
-			   const void *val)
+static int __mxt_read_reg(struct i2c_client *client,
+			  u16 reg, u16 len, void *buf)
+{
+	const struct i2c_adapter_quirks *quirks = client->adapter->quirks;
+	u16 size, offset = 0, max_read_len = len;
+	int ret;
+
+	if (quirks && quirks->max_read_len)
+		max_read_len = quirks->max_read_len;
+
+	while (offset < len) {
+		size = min_t(u16, max_read_len, len - offset);
+
+		ret = __mxt_read_chunk(client,
+				       reg + offset,
+				       size, buf + offset);
+		if (ret)
+			return ret;
+
+		offset += size;
+	}
+
+	return 0;
+}
+
+static int __mxt_write_chunk(struct i2c_client *client, u16 reg, u16 len,
+			     const void *val)
 {
 	u8 *buf;
 	size_t count;
@@ -685,9 +710,34 @@ static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 	return ret;
 }
 
+static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
+			   const void *val)
+{
+	const struct i2c_adapter_quirks *quirks = client->adapter->quirks;
+	u16 size, offset = 0, max_write_len = len;
+	int ret;
+
+	if (quirks && quirks->max_write_len)
+		max_write_len = quirks->max_write_len;
+
+	while (offset < len) {
+		size = min_t(u16, max_write_len, len - offset);
+
+		ret = __mxt_write_chunk(client,
+					reg + offset,
+					size, val + offset);
+		if (ret)
+			return ret;
+
+		offset += size;
+	}
+
+	return 0;
+}
+
 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 {
-	return __mxt_write_reg(client, reg, 1, &val);
+	return __mxt_write_chunk(client, reg, 1, &val);
 }
 
 static struct mxt_object *
-- 
2.17.1