Skip to contentSkip to conversation

Input: atmel_mxt_ts: split large i2c transfers into blocks

PATCH In review Jiada Wang 2 participants 2 messages Jul 29, 2020 – Jul 30, 2020

Subsystems (3)
lore
Share & tools
lore

Jiada Wang

author
#0 lore raw

PATCH 1/1 Input: atmel_mxt_ts: split large i2c transfers into blocks

From: Jiada wang <[email protected]>

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 <[email protected]>
---
 drivers/input/touchscreen/atmel_mxt_ts.c | 60 ++++++++++++++++++++++--
 1 file changed, 55 insertions(+), 5 deletions(-)
drivers/input/touchscreen/atmel_mxt_ts.c +55 -5
index a2189739e30f..d7c3c24aa663 100644
@@ -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 *
Signature · 1 line
2.17.1
maintainer
#1 lore raw

Hi Jiada,

Quoted 10 lines · Jiada Wang

From: Jiada wang <[email protected]>

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.

Signature · 1 line
Dmitry