[1/1] Input: atmel_mxt_ts: split large i2c transfers into blocks

Commit Message

Wang, Jiada July 29, 2020, 9:22 a.m. UTC

From: Jiada wang <[e-mail]>

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 <[e-mail]>
Signed-off-by: Jiada wang <[e-mail]>
---
 drivers/input/touchscreen/atmel_mxt_ts.c | 60 ++++++++++++++++++++++--
 1 file changed, 55 insertions(+), 5 deletions(-)

Comments

Dmitry Torokhov July 30, 2020, 5:54 a.m. UTC | #1

Hi Jiada,

On Wed, Jul 29, 2020 at 06:22:52PM +0900, Jiada Wang wrote:
> From: Jiada wang <[e-mail]>
> 
> 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.

Can we consider implementing this chunking logic in i2c core? Otherwise
we will need to adjust pretty much every driver to do this.

Thanks.

Patch

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 *