Some devices fail to cope in disastrous ways with the small command
turn-around times enabled by in-kernel device drivers.
Introduce per-client throttling of transfers to avoid these issues.
Signed-off-by: Andrew Jeffery <andrew@xxxxxxxx>
---
drivers/i2c/i2c-core-base.c | 8 +-
drivers/i2c/i2c-core-smbus.c | 149 ++++++++++++++++++++++++++++-------
drivers/i2c/i2c-core.h | 22 ++++++
include/linux/i2c.h | 3 +
4 files changed, 151 insertions(+), 31 deletions(-)
diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c
index 5ec082e2039d..d5a519bcadf9 100644
--- a/drivers/i2c/i2c-core-base.c
+++ b/drivers/i2c/i2c-core-base.c
@@ -867,13 +867,17 @@ int i2c_dev_irq_from_resources(const struct resource *resources,
struct i2c_client *
i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
+ struct i2c_client_priv *priv;
struct i2c_client *client;
int status;
- client = kzalloc(sizeof *client, GFP_KERNEL);
- if (!client)
+ priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+ if (!priv)
return ERR_PTR(-ENOMEM);
+ mutex_init(&priv->throttle_lock);
+ client = &priv->client;
+
client->adapter = adap;
client->dev.platform_data = info->platform_data;
diff --git a/drivers/i2c/i2c-core-smbus.c b/drivers/i2c/i2c-core-smbus.c
index f5c9787992e9..4a9692a37e1e 100644
--- a/drivers/i2c/i2c-core-smbus.c
+++ b/drivers/i2c/i2c-core-smbus.c
@@ -10,6 +10,7 @@
* SMBus 2.0 support by Mark Studebaker <mdsxyz123@xxxxxxxxx> and
* Jean Delvare <jdelvare@xxxxxxx>
*/
+#include <linux/delay.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/i2c.h>
@@ -21,6 +22,9 @@
#define CREATE_TRACE_POINTS
#include <trace/events/smbus.h>
+static s32 i2c_smbus_throttle_xfer(const struct i2c_client *client,
+ char read_write, u8 command, int protocol,
+ union i2c_smbus_data *data);
/* The SMBus parts */
@@ -95,9 +99,9 @@ s32 i2c_smbus_read_byte(const struct i2c_client *client)
union i2c_smbus_data data;
int status;
- status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_READ, 0,
- I2C_SMBUS_BYTE, &data);
+ status = i2c_smbus_throttle_xfer(client, I2C_SMBUS_READ, 0,
+ I2C_SMBUS_BYTE, &data);
+
return (status < 0) ? status : data.byte;
}
EXPORT_SYMBOL(i2c_smbus_read_byte);
@@ -112,8 +116,8 @@ EXPORT_SYMBOL(i2c_smbus_read_byte);
*/
s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
{
- return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
+ return i2c_smbus_throttle_xfer(client, I2C_SMBUS_WRITE, value,
+ I2C_SMBUS_BYTE, NULL);
}
EXPORT_SYMBOL(i2c_smbus_write_byte);
@@ -130,9 +134,9 @@ s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
union i2c_smbus_data data;
int status;
- status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_READ, command,
- I2C_SMBUS_BYTE_DATA, &data);
+ status = i2c_smbus_throttle_xfer(client, I2C_SMBUS_READ, command,
+ I2C_SMBUS_BYTE_DATA, &data);
+
return (status < 0) ? status : data.byte;
}
EXPORT_SYMBOL(i2c_smbus_read_byte_data);
@@ -150,10 +154,10 @@ s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
u8 value)
{
union i2c_smbus_data data;
+
data.byte = value;
- return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_WRITE, command,
- I2C_SMBUS_BYTE_DATA, &data);
+ return i2c_smbus_throttle_xfer(client, I2C_SMBUS_WRITE, command,
+ I2C_SMBUS_BYTE_DATA, &data);
}
EXPORT_SYMBOL(i2c_smbus_write_byte_data);
@@ -170,9 +174,9 @@ s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
union i2c_smbus_data data;
int status;
- status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_READ, command,
- I2C_SMBUS_WORD_DATA, &data);
+ status = i2c_smbus_throttle_xfer(client, I2C_SMBUS_READ, command,
+ I2C_SMBUS_WORD_DATA, &data);
+
return (status < 0) ? status : data.word;
}
EXPORT_SYMBOL(i2c_smbus_read_word_data);
@@ -190,10 +194,10 @@ s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
u16 value)
{
union i2c_smbus_data data;
+
data.word = value;
- return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_WRITE, command,
- I2C_SMBUS_WORD_DATA, &data);
+ return i2c_smbus_throttle_xfer(client, I2C_SMBUS_WRITE, command,
+ I2C_SMBUS_WORD_DATA, &data);
}
EXPORT_SYMBOL(i2c_smbus_write_word_data);
@@ -218,9 +222,9 @@ s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
union i2c_smbus_data data;
int status;
- status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_READ, command,
- I2C_SMBUS_BLOCK_DATA, &data);
+ status = i2c_smbus_throttle_xfer(client, I2C_SMBUS_READ, command,
+ I2C_SMBUS_BLOCK_DATA, &data);
+
if (status)
return status;
@@ -248,9 +252,8 @@ s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
length = I2C_SMBUS_BLOCK_MAX;
data.block[0] = length;
memcpy(&data.block[1], values, length);
- return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_WRITE, command,
- I2C_SMBUS_BLOCK_DATA, &data);
+ return i2c_smbus_throttle_xfer(client, I2C_SMBUS_WRITE, command,
+ I2C_SMBUS_BLOCK_DATA, &data);
}
EXPORT_SYMBOL(i2c_smbus_write_block_data);
@@ -264,9 +267,9 @@ s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
if (length > I2C_SMBUS_BLOCK_MAX)
length = I2C_SMBUS_BLOCK_MAX;
data.block[0] = length;
- status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_READ, command,
- I2C_SMBUS_I2C_BLOCK_DATA, &data);
+ status = i2c_smbus_throttle_xfer(client, I2C_SMBUS_READ, command,
+ I2C_SMBUS_I2C_BLOCK_DATA, &data);
+
if (status < 0)
return status;
@@ -284,9 +287,8 @@ s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
length = I2C_SMBUS_BLOCK_MAX;
data.block[0] = length;
memcpy(data.block + 1, values, length);
- return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
- I2C_SMBUS_WRITE, command,
- I2C_SMBUS_I2C_BLOCK_DATA, &data);
+ return i2c_smbus_throttle_xfer(client, I2C_SMBUS_WRITE, command,
+ I2C_SMBUS_I2C_BLOCK_DATA, &data);
}
EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
@@ -547,6 +549,71 @@ s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
}
EXPORT_SYMBOL(i2c_smbus_xfer);
+static int i2c_smbus_throttle_enter(const struct i2c_client *client)
+ __acquires(&priv->throttle_lock)
+{
+ struct i2c_client_priv *priv;
+ ktime_t earliest;
+ int rc;
+
+ priv = to_i2c_client_priv(client);
+
+ if (i2c_in_atomic_xfer_mode()) {
+ if (!mutex_trylock(&priv->throttle_lock))
+ return -EAGAIN;
+ } else {
+ rc = mutex_lock_interruptible(&priv->throttle_lock);
+ if (rc)
+ return rc;
+ }
+ earliest = ktime_add_us(priv->last, priv->delay_us);
+
+ if (priv->delay_us && ktime_before(ktime_get(), earliest)) {
+ if (i2c_in_atomic_xfer_mode()) {
+ mutex_unlock(&priv->throttle_lock);
+ return -EAGAIN;
+ }
+
+ usleep_range(priv->delay_us, 2 * priv->delay_us);
+ }
+
+ return 0;
+}
+
+static void i2c_smbus_throttle_exit(const struct i2c_client *client)
+ __releases(&priv->throttle_lock)
+{
+ struct i2c_client_priv *priv;
+
+ priv = to_i2c_client_priv(client);
+
+ if (priv->delay_us)
+ priv->last = ktime_get();
+ mutex_unlock(&priv->throttle_lock);
+}
+
+static s32 i2c_smbus_throttle_xfer(const struct i2c_client *client,
+ char read_write, u8 command, int protocol,
+ union i2c_smbus_data *data)
+{
+ s32 res;
+
+ res = i2c_smbus_throttle_enter(client);
+ if (res)
+ return res;
+
+ res = __i2c_lock_bus_helper(client->adapter);
+ if (!res)
+ res = __i2c_smbus_xfer(client->adapter, client->addr,
+ client->flags, read_write, command,
+ protocol, data);
+ i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
+
+ i2c_smbus_throttle_exit(client);
+
+ return res;
+}
+
s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
unsigned short flags, char read_write,
u8 command, int protocol, union i2c_smbus_data *data)
@@ -715,3 +782,27 @@ int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
}
EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
#endif
+
+int i2c_smbus_throttle_client(struct i2c_client *client,
+ unsigned long delay_us)
+{
+ struct i2c_client_priv *priv;
+ int rc;
+
+ priv = to_i2c_client_priv(client);
+
+ if (i2c_in_atomic_xfer_mode()) {
+ if (!mutex_trylock(&priv->throttle_lock))
+ return -EAGAIN;
+ } else {
+ rc = mutex_lock_interruptible(&priv->throttle_lock);
+ if (rc)
+ return rc;
+ }
+ priv->delay_us = delay_us;
+ priv->last = ktime_get();
+ mutex_unlock(&priv->throttle_lock);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(i2c_smbus_throttle_client);
diff --git a/drivers/i2c/i2c-core.h b/drivers/i2c/i2c-core.h
index 8ce261167a2d..c763c6c431f9 100644
--- a/drivers/i2c/i2c-core.h
+++ b/drivers/i2c/i2c-core.h
@@ -4,6 +4,28 @@
*/
#include <linux/rwsem.h>
+#include <linux/i2c.h>
+#include <linux/timekeeping.h>
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+
+struct i2c_client_priv {
+ struct i2c_client client;
+
+ /*
+ * Per-client access throttling, described in terms of microsecond
+ * delay between the end of the nth transfer and the start of the
+ * (n+1)th transfer. Used to manage devices which respond poorly to
+ * rapid back-to-back commands.
+ *
+ * Do it in a wrapper struct to preserve const-ness of the i2c_smbus_*
+ * interfaces.
+ */
+ struct mutex throttle_lock;
+ unsigned long delay_us;
+ ktime_t last;
+};
+#define to_i2c_client_priv(c) container_of(c, struct i2c_client_priv, client)
struct i2c_devinfo {
struct list_head list;
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index fc55ea41d323..adc91587d7fa 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -181,8 +181,11 @@ s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
u8 command, u8 length,
u8 *values);
+int i2c_smbus_throttle_client(struct i2c_client *client,
+ unsigned long delay_us);
int i2c_get_device_id(const struct i2c_client *client,
struct i2c_device_identity *id);
+
#endif /* I2C */
/**
--
2.25.1
