Add Invensense ICM42607

From: Chris Morgan <[email protected]>

Add devicetree binding for the Invensense ICM42607 and Invensense ICM42607P inertial measurement unit. This unit is a combined accelerometer, gyroscope, and thermometer available via I2C or SPI.

This device is functionally very similar to the icm42600 series with a very different register layout.

Signed-off-by Chris Morgan <[email protected]>

Acked-by Krzysztof Kozlowski <[email protected]>

---
 .../devicetree/bindings/iio/imu/invensense,icm42600.yaml        | 2 ++
 1 file changed, 2 insertions(+)

Documentation/devicetree/bindings/iio/imu/invensense,icm42600.yaml +2 -0

index 9b2af104f186..b69c6bbb6f6b 100644
@@ -30,6 +30,8 @@ properties:
       - invensense,icm42600
       - invensense,icm42602
       - invensense,icm42605
+      - invensense,icm42607
+      - invensense,icm42607p
       - invensense,icm42622
       - invensense,icm42631
       - invensense,icm42686

Quoted 11 lines · On Mon, 18 May 2026 15:05:17 -0500 Chris Morgan <[email protected]> wrote:

From: Chris Morgan <[email protected]>

Add devicetree binding for the Invensense ICM42607 and Invensense ICM42607P inertial measurement unit. This unit is a combined accelerometer, gyroscope, and thermometer available via I2C or SPI.

This device is functionally very similar to the icm42600 series with a very different register layout.

Signed-off-by Chris Morgan <[email protected]>

Acked-by Krzysztof Kozlowski <[email protected]>

Note that Sashiko has highlighted that the binding this being added to has a potential problem.

interrupts are required but interrupt-names are not. That would be fine but the binding doesn't say there is a default ordering for the interrupts - so if we don't have names we have no idea which interrupt it is.

This needs fixing - probably by adding a default

Quoted 22 lines · Jonathan Cameron

Quoted 11 lines · On Mon, 18 May 2026 15:05:17 -0500 Chris Morgan <[email protected]> wrote:

From: Chris Morgan <[email protected]>

Add devicetree binding for the Invensense ICM42607 and Invensense ICM42607P inertial measurement unit. This unit is a combined accelerometer, gyroscope, and thermometer available via I2C or SPI.

This device is functionally very similar to the icm42600 series with a very different register layout.

Signed-off-by Chris Morgan <[email protected]>

Acked-by Krzysztof Kozlowski <[email protected]>

Note that Sashiko has highlighted that the binding this being added to has a potential problem.

interrupts are required but interrupt-names are not. That would be fine but the binding doesn't say there is a default ordering for the interrupts - so if we don't have names we have no idea which interrupt it is.

Quoted 1 line

This needs fixing - probably by adding a default

Worth pointing out that this isn't an issue with this particular patch, the problem exists in mainline.

Quoted 23 lines · Conor Dooley

Quoted 22 lines · Jonathan Cameron

Quoted 11 lines · On Mon, 18 May 2026 15:05:17 -0500 Chris Morgan <[email protected]> wrote:

From: Chris Morgan <[email protected]>

Add devicetree binding for the Invensense ICM42607 and Invensense ICM42607P inertial measurement unit. This unit is a combined accelerometer, gyroscope, and thermometer available via I2C or SPI.

This device is functionally very similar to the icm42600 series with a very different register layout.

Signed-off-by Chris Morgan <[email protected]>

Acked-by Krzysztof Kozlowski <[email protected]>

Note that Sashiko has highlighted that the binding this being added to has a potential problem.

interrupts are required but interrupt-names are not. That would be fine but the binding doesn't say there is a default ordering for the interrupts - so if we don't have names we have no idea which interrupt it is.

Quoted 4 lines

Quoted 1 line

This needs fixing - probably by adding a default

Worth pointing out that this isn't an issue with this particular patch, the problem exists in mainline.

The driver I lovingly borrowed this code from seems to have fallback logic, basically picking the first interrupt if it couldn't find one named "INT1". I was told early on not to do this that way, so in my case the interrupt-names would be required (but not for the existing driver because of this fallback).

Should I make the requirement conditional just to my compatible strings?

Quoted 29 lines · Chris Morgan

Quoted 27 lines · Conor Dooley

Quoted 17 lines · Jonathan Cameron

Quoted 11 lines · On Mon, 18 May 2026 15:05:17 -0500 Chris Morgan <[email protected]> wrote:

From: Chris Morgan <[email protected]>

Add devicetree binding for the Invensense ICM42607 and Invensense ICM42607P inertial measurement unit. This unit is a combined accelerometer, gyroscope, and thermometer available via I2C or SPI.

This device is functionally very similar to the icm42600 series with a very different register layout.

Signed-off-by Chris Morgan <[email protected]>

Acked-by Krzysztof Kozlowski <[email protected]>

Note that Sashiko has highlighted that the binding this being added to has a potential problem.

Quoted 6 lines

interrupts are required but interrupt-names are not. That would be fine but the binding doesn't say there is a default ordering for the interrupts - so if we don't have names we have no idea which interrupt it is.

This needs fixing - probably by adding a default

Worth pointing out that this isn't an issue with this particular patch, the problem exists in mainline.

Quoted 6 lines

The driver I lovingly borrowed this code from seems to have fallback logic, basically picking the first interrupt if it couldn't find one named "INT1". I was told early on not to do this that way, so in my case the interrupt-names would be required (but not for the existing driver because of this fallback).

Quoted 2 lines

Should I make the requirement conditional just to my compatible strings?

Sure, sounds like a good idea to me

From: Chris Morgan <[email protected]>

Add the core component of a new inv_icm42607 driver. This includes a few setup functions and the full register definition in the header file.

Signed-off-by Chris Morgan <[email protected]>

---
 drivers/iio/imu/inv_icm42607/inv_icm42607.h   | 332 ++++++++++++++++++
 .../iio/imu/inv_icm42607/inv_icm42607_core.c  | 197 +++++++++++
 2 files changed, 529 insertions(+)
 create mode 100644 drivers/iio/imu/inv_icm42607/inv_icm42607.h
 create mode 100644 drivers/iio/imu/inv_icm42607/inv_icm42607_core.c

drivers/iio/imu/inv_icm42607/inv_icm42607.h new file +0 -0

new file mode 100644
index 000000000000..6c5e7d9b08b7

drivers/iio/imu/inv_icm42607/inv_icm42607.h new file +3 -0

+			    inv_icm42607_bus_setup bus_setup);
+
+#endif

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c new file +4 -0

new file mode 100644
index 000000000000..b270d48335ba
@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2026 InvenSense, Inc.
+ */

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c new file +11 -0

+#include "inv_icm42607.h"
 
+/**
+ *  inv_icm42607_setup() - check and setup chip
+ *  @st:	driver internal state
+ *  @bus_setup:	callback for setting up bus specific registers
+ *
+ *  Returns 0 on success, a negative error code otherwise.
+ */
+static int inv_icm42607_setup(struct inv_icm42607_state *st,
+			      inv_icm42607_bus_setup bus_setup)
+{

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c new file +25 -0

+	ret = regmap_read_poll_timeout(st->map, INV_ICM42607_REG_INT_STATUS,
+				       val, val & INV_ICM42607_INT_STATUS_RESET_DONE,
+				       INV_ICM42607_RESET_TIME_MS * 100,
+				       INV_ICM42607_RESET_TIME_MS * 1000);
+	if (ret)
+		return dev_err_probe(dev, ret,
+				     "reset error, reset done bit not set\n");
+
+	ret = bus_setup(st);
+	if (ret)
+		return ret;
+
+	ret = regmap_set_bits(st->map, INV_ICM42607_REG_INTF_CONFIG0,
+			      INV_ICM42607_INTF_CONFIG0_SENSOR_DATA_ENDIAN);
+	if (ret)
+		return ret;
+
+	ret = regmap_update_bits(st->map, INV_ICM42607_REG_INTF_CONFIG1,
+				 INV_ICM42607_INTF_CONFIG1_CLKSEL_MASK,
+				 INV_ICM42607_INTF_CONFIG1_CLKSEL_PLL);
+	if (ret)
+		return ret;
+
+	return inv_icm42607_set_conf(st, st->hw->conf);
+}
 

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c new file +2 -0

+	if (irq < 0)
+		return dev_err_probe(dev, irq, "Unable to get INT1 interrupt\n");

From: Chris Morgan <[email protected]>

Add the core component of a new inv_icm42607 driver. This includes a few setup functions and the full register definition in the header file.

Signed-off-by Chris Morgan <[email protected]>

---

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c new file +1 -0

+int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw *hw,

+

From: Chris Morgan <[email protected]>

Add I2C and SPI driver support for InvenSense ICM-42607 devices. Add necessary Kconfig and Makefile to allow building of (incomplete) driver.

Signed-off-by Chris Morgan <[email protected]>

drivers/iio/imu/inv_icm42607/inv_icm42607.h +0 -0

index 6c5e7d9b08b7..74d8d3d7c890 100644
@@ -13,6 +13,16 @@
 #include <linux/regmap.h>

drivers/iio/imu/inv_icm42607/inv_icm42607.h +0 -0

 int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw *hw,
 			    inv_icm42607_bus_setup bus_setup);

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +0 -0

index b270d48335ba..e9c81b52f9ef 100644
 
 static int inv_icm42607_set_conf(struct inv_icm42607_state *st,
 				 const struct inv_icm42607_conf *conf)
 {

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +3 -0

+	if (ret)
+		return ret;
+
 	ret = bus_setup(st);
 	if (ret)
 		return ret;

drivers/iio/imu/inv_icm42607/inv_icm42607_i2c.c new file +0 -0

new file mode 100644
index 000000000000..8631579a609a

drivers/iio/imu/inv_icm42607/inv_icm42607_i2c.c new file +30 -0

+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, inv_icm42607_id);
+
+static const struct of_device_id inv_icm42607_of_matches[] = {
+	{
+		.compatible = "invensense,icm42607",
+		.data = &inv_icm42607_hw_data,
+	}, {
+		.compatible = "invensense,icm42607p",
+		.data = &inv_icm42607p_hw_data,
+	},
+	{ }
+};
+MODULE_DEVICE_TABLE(of, inv_icm42607_of_matches);
+
+static struct i2c_driver inv_icm42607_driver = {
+	.driver = {
+		.name = "inv-icm42607-i2c",
+		.of_match_table = inv_icm42607_of_matches,
+	},
+	.id_table = inv_icm42607_id,
+	.probe = inv_icm42607_probe,
+};
+module_i2c_driver(inv_icm42607_driver);
+
+MODULE_AUTHOR("InvenSense, Inc.");
+MODULE_DESCRIPTION("InvenSense ICM-42607x I2C driver");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("IIO_ICM42607");

drivers/iio/imu/inv_icm42607/inv_icm42607_spi.c new file +6 -0

new file mode 100644
index 000000000000..960b5d3e9abc
@@ -0,0 +1,101 @@
 
+static const struct of_device_id inv_icm42607_of_matches[] = {
+	{
+		.compatible = "invensense,icm42607",
+		.data = &inv_icm42607_hw_data,
+	},
+	{

drivers/iio/imu/inv_icm42607/inv_icm42607_spi.c new file +18 -0

+	{ }
+};
+MODULE_DEVICE_TABLE(spi, inv_icm42607_spi_id_table);
+
+static struct spi_driver inv_icm42607_driver = {
+	.driver = {
+		.name = "inv-icm42607-spi",
+		.of_match_table = inv_icm42607_of_matches,
+	},
+	.id_table = inv_icm42607_spi_id_table,
+	.probe = inv_icm42607_probe,
+};
+module_spi_driver(inv_icm42607_driver);
+
+MODULE_AUTHOR("InvenSense, Inc.");
+MODULE_DESCRIPTION("InvenSense ICM-42607x SPI driver");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("IIO_ICM42607");

From: Chris Morgan <[email protected]>

Add power management support for the ICM42607 device driver.

Signed-off-by Chris Morgan <[email protected]>

---
 drivers/iio/imu/inv_icm42607/inv_icm42607.h   |  18 +++
 .../iio/imu/inv_icm42607/inv_icm42607_core.c  | 147 ++++++++++++++++++
 .../iio/imu/inv_icm42607/inv_icm42607_i2c.c   |   1 +
 .../iio/imu/inv_icm42607/inv_icm42607_spi.c   |   1 +
 4 files changed, 167 insertions(+)

drivers/iio/imu/inv_icm42607/inv_icm42607.h +9 -0

index 74d8d3d7c890..b05828415053 100644
@@ -10,6 +10,7 @@
 #include <linux/bitops.h>
 #include <linux/iio/iio.h>
 #include <linux/mutex.h>
+#include <linux/pm.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 

@@ -96,24 +97,34 @@ struct inv_icm42607_hw {
 	const struct inv_icm42607_conf *conf;
 };
 
+struct inv_icm42607_suspended {
+	enum inv_icm42607_sensor_mode gyro;
+	enum inv_icm42607_sensor_mode accel;
+	bool temp;
+};
+
 /**
  *  struct inv_icm42607_state - driver state variables
  *  @lock:		lock for serializing multiple registers access.
  *  @hw:		Hardware specific data.
  *  @map:		regmap pointer.
  *  @vddio_supply:	I/O voltage regulator for the chip.
+ *  @vddio_en:		I/O voltage status for runtime PM.
  *  @irq:		chip irq, required to enable/disable and set wakeup
  *  @orientation:	sensor chip orientation relative to main hardware.
  *  @conf:		chip sensors configurations.
+ *  @suspended:		suspended sensors configuration.
  */

drivers/iio/imu/inv_icm42607/inv_icm42607.h +0 -0

 };
 

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +22 -0

index e9c81b52f9ef..bc0cefa2fb77 100644
@@ -9,6 +9,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 #include <linux/property.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>

@@ -72,6 +73,62 @@ const struct inv_icm42607_hw inv_icm42607p_hw_data = {
 };
 EXPORT_SYMBOL_NS_GPL(inv_icm42607p_hw_data, "IIO_ICM42607");
 
+static int inv_icm42607_set_pwr_mgmt0(struct inv_icm42607_state *st,
+				      enum inv_icm42607_sensor_mode gyro,
+				      enum inv_icm42607_sensor_mode accel,
+				      bool temp, unsigned int *sleep_ms)
+{
+	enum inv_icm42607_sensor_mode oldgyro = st->conf.gyro.mode;
+	enum inv_icm42607_sensor_mode oldaccel = st->conf.accel.mode;
+	bool oldtemp = st->conf.temp_en;
+	unsigned int sleepval;
+	unsigned int val;
+	int ret;
+
+	if (gyro == oldgyro && accel == oldaccel && temp == oldtemp)
+		return 0;
+
+	val = FIELD_PREP(INV_ICM42607_PWR_MGMT0_GYRO_MODE_MASK, gyro);
+	val |= FIELD_PREP(INV_ICM42607_PWR_MGMT0_ACCEL_MODE_MASK, accel);
+	if (!temp)
+		val |= INV_ICM42607_PWR_MGMT0_ACCEL_LP_CLK_SEL;
+	ret = regmap_write(st->map, INV_ICM42607_REG_PWR_MGMT0, val);
+	if (ret)

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +12 -0

+		} else if (gyro == INV_ICM42607_SENSOR_MODE_OFF) {
+			if (sleepval < INV_ICM42607_GYRO_STARTUP_TIME_MS)
+				sleepval = INV_ICM42607_GYRO_STARTUP_TIME_MS;
+		}
+	}
+
+	if (sleep_ms)
+		*sleep_ms = sleepval;
+	else if (sleepval)
+		msleep(sleepval);
+
+	return 0;

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +11 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_set_pwr_mgmt0(st, INV_ICM42607_SENSOR_MODE_OFF,
+					 INV_ICM42607_SENSOR_MODE_OFF,
+					 false, NULL);
+	if (ret)
+		return ret;
+
+	inv_icm42607_disable_vddio_reg(st);
+

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +12 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_enable_vddio_reg(st);
+	if (ret)
+		return ret;
+
+	/* Nothing else to restore at this time. */
+
+	return 0;
+}
+

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +23 -0

+	if (ret)
+		return ret;
+
+	inv_icm42607_disable_vddio_reg(st);
+
+	return 0;
+}
+
+static int inv_icm42607_runtime_resume(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+
+	guard(mutex)(&st->lock);
+
+	return inv_icm42607_enable_vddio_reg(st);
+}
+
+EXPORT_NS_GPL_DEV_PM_OPS(inv_icm42607_pm_ops, IIO_ICM42607) = {
+	SYSTEM_SLEEP_PM_OPS(inv_icm42607_suspend, inv_icm42607_resume)
+	RUNTIME_PM_OPS(inv_icm42607_runtime_suspend,
+		       inv_icm42607_runtime_resume, NULL)
+};
+

Quoted 5 lines · On Mon, 18 May 2026 15:05:20 -0500 Chris Morgan <[email protected]> wrote:

From: Chris Morgan <[email protected]>

Add power management support for the ICM42607 device driver.

Signed-off-by Chris Morgan <[email protected]>

Hi Chris, runtime PM is my current place to look closest for bugs because we've had a lot of them recently.

Anyhow, took another look and here I think we can optimize things a little more.

Quoted 41 lines

---
 drivers/iio/imu/inv_icm42607/inv_icm42607.h   |  18 +++
 .../iio/imu/inv_icm42607/inv_icm42607_core.c  | 147 ++++++++++++++++++
 .../iio/imu/inv_icm42607/inv_icm42607_i2c.c   |   1 +
 .../iio/imu/inv_icm42607/inv_icm42607_spi.c   |   1 +
 4 files changed, 167 insertions(+)

drivers/iio/imu/inv_icm42607/inv_icm42607.h +9 -0

index 74d8d3d7c890..b05828415053 100644
@@ -10,6 +10,7 @@
 #include <linux/bitops.h>
 #include <linux/iio/iio.h>
 #include <linux/mutex.h>
+#include <linux/pm.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>
 

@@ -96,24 +97,34 @@ struct inv_icm42607_hw {
 	const struct inv_icm42607_conf *conf;
 };
 
+struct inv_icm42607_suspended {
+	enum inv_icm42607_sensor_mode gyro;
+	enum inv_icm42607_sensor_mode accel;
+	bool temp;
+};
+
 /**
  *  struct inv_icm42607_state - driver state variables
  *  @lock:		lock for serializing multiple registers access.
  *  @hw:		Hardware specific data.
  *  @map:		regmap pointer.
  *  @vddio_supply:	I/O voltage regulator for the chip.
+ *  @vddio_en:		I/O voltage status for runtime PM.
  *  @irq:		chip irq, required to enable/disable and set wakeup
  *  @orientation:	sensor chip orientation relative to main hardware.
  *  @conf:		chip sensors configurations.
+ *  @suspended:		suspended sensors configuration.
  */

drivers/iio/imu/inv_icm42607/inv_icm42607.h struct inv_icm42607_hw { · line 127

Quoted 10 lines

drivers/iio/imu/inv_icm42607/inv_icm42607.h +2 -0

 struct inv_icm42607_state {
 	struct mutex lock;
 	const struct inv_icm42607_hw *hw;
 	struct regmap *map;
 	struct regulator *vddio_supply;
+	bool vddio_en;
 	int irq;
 	struct iio_mount_matrix orientation;
 	struct inv_icm42607_conf conf;
+	struct inv_icm42607_suspended suspended;

Is this used? If not bring it in only when needed.

Quoted 44 lines

drivers/iio/imu/inv_icm42607/inv_icm42607.h +0 -0

 };
 

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +27 -0

index e9c81b52f9ef..bc0cefa2fb77 100644
@@ -9,6 +9,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 #include <linux/property.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>

@@ -72,6 +73,62 @@ const struct inv_icm42607_hw inv_icm42607p_hw_data = {
 };
 EXPORT_SYMBOL_NS_GPL(inv_icm42607p_hw_data, "IIO_ICM42607");
 
+static int inv_icm42607_set_pwr_mgmt0(struct inv_icm42607_state *st,
+				      enum inv_icm42607_sensor_mode gyro,
+				      enum inv_icm42607_sensor_mode accel,
+				      bool temp, unsigned int *sleep_ms)
+{
+	enum inv_icm42607_sensor_mode oldgyro = st->conf.gyro.mode;
+	enum inv_icm42607_sensor_mode oldaccel = st->conf.accel.mode;
+	bool oldtemp = st->conf.temp_en;
+	unsigned int sleepval;
+	unsigned int val;
+	int ret;
+
+	if (gyro == oldgyro && accel == oldaccel && temp == oldtemp)
+		return 0;
+
+	val = FIELD_PREP(INV_ICM42607_PWR_MGMT0_GYRO_MODE_MASK, gyro);
+	val |= FIELD_PREP(INV_ICM42607_PWR_MGMT0_ACCEL_MODE_MASK, accel);
+	if (!temp)
+		val |= INV_ICM42607_PWR_MGMT0_ACCEL_LP_CLK_SEL;
+	ret = regmap_write(st->map, INV_ICM42607_REG_PWR_MGMT0, val);
+	if (ret)
+		return ret;
+
+	st->conf.gyro.mode = gyro;
+	st->conf.accel.mode = accel;
+	st->conf.temp_en = temp;

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 106

Quoted 5 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +5 -0

+
+	sleepval = 0;
+	if (temp && !oldtemp) {
+		if (sleepval < INV_ICM42607_TEMP_STARTUP_TIME_MS)
+			sleepval = INV_ICM42607_TEMP_STARTUP_TIME_MS;

sleepval = max(sleepval,)
or just assign it here if not later patches add stuff in between the assignment to 0 and here.

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 109

Quoted 3 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +3 -0

+	}
+	if (accel != oldaccel && oldaccel == INV_ICM42607_SENSOR_MODE_OFF) {
+		usleep_range(200, 300);

fsleep() + add a comment on why we are sleeping in here.

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 111

Quoted 2 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +2 -0

+		if (sleepval < INV_ICM42607_ACCEL_STARTUP_TIME_MS)
+			sleepval = INV_ICM42607_ACCEL_STARTUP_TIME_MS;

		sleepval = max(sleepval, INV...);

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 115

Quoted 4 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +4 -0

+	}
+	if (gyro != oldgyro) {
+		if (oldgyro == INV_ICM42607_SENSOR_MODE_OFF) {
+			usleep_range(200, 300);

fsleep()

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 117

Quoted 2 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +2 -0

+			if (sleepval < INV_ICM42607_GYRO_STARTUP_TIME_MS)
+				sleepval = INV_ICM42607_GYRO_STARTUP_TIME_MS;

I'd use max for these as well.

Quoted 12 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +12 -0

+		} else if (gyro == INV_ICM42607_SENSOR_MODE_OFF) {
+			if (sleepval < INV_ICM42607_GYRO_STARTUP_TIME_MS)
+				sleepval = INV_ICM42607_GYRO_STARTUP_TIME_MS;
+		}
+	}
+
+	if (sleep_ms)
+		*sleep_ms = sleepval;
+	else if (sleepval)
+		msleep(sleepval);
+
+	return 0;

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = {

Quoted 10 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +8 -0

+}
 
 
+static int inv_icm42607_suspend(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+	int ret;
+
+	guard(mutex)(&st->lock);
+

Could you use pm_runtime_force_suspend()?

Quoted 18 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +18 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_set_pwr_mgmt0(st, INV_ICM42607_SENSOR_MODE_OFF,
+					 INV_ICM42607_SENSOR_MODE_OFF,
+					 false, NULL);
+	if (ret)
+		return ret;
+
+	inv_icm42607_disable_vddio_reg(st);
+
+	return 0;
+}
+
+static int inv_icm42607_resume(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+	int ret;

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw · line 336

Quoted 3 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +3 -0

+
+	guard(mutex)(&st->lock);
+

Given the bunch of stuff we've run into recently around these I'm getting more paranoid.
Similar to above, could you use pm_runtime_force_resume() You would need to gate stuff added later to not occur though if it wasn't runtime suspended.

Quoted 14 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +12 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_enable_vddio_reg(st);
+	if (ret)
+		return ret;
+
+	/* Nothing else to restore at this time. */
+
+	return 0;
+}
+

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw · line 379

Quoted 10 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +10 -0

+static int inv_icm42607_runtime_suspend(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+	int ret;
+
+	guard(mutex)(&st->lock);
+
+	ret = inv_icm42607_set_pwr_mgmt0(st, INV_ICM42607_SENSOR_MODE_OFF,
+					 INV_ICM42607_SENSOR_MODE_OFF, false,
+					 NULL);

Different alignment to above - aim for consistent choices on this.

Quoted 15 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +15 -0

+	if (ret)
+		return ret;
+
+	inv_icm42607_disable_vddio_reg(st);
+
+	return 0;
+}
+
+static int inv_icm42607_runtime_resume(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+
+	guard(mutex)(&st->lock);
+
+	return inv_icm42607_enable_vddio_reg(st);

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw · line 402

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +8 -0

+}
+
+EXPORT_NS_GPL_DEV_PM_OPS(inv_icm42607_pm_ops, IIO_ICM42607) = {
+	SYSTEM_SLEEP_PM_OPS(inv_icm42607_suspend, inv_icm42607_resume)
+	RUNTIME_PM_OPS(inv_icm42607_runtime_suspend,
+		       inv_icm42607_runtime_resume, NULL)
+};
+

Quoted 44 lines

Quoted 44 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +27 -0

index e9c81b52f9ef..bc0cefa2fb77 100644
@@ -9,6 +9,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 #include <linux/property.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>

@@ -72,6 +73,62 @@ const struct inv_icm42607_hw inv_icm42607p_hw_data = {
 };
 EXPORT_SYMBOL_NS_GPL(inv_icm42607p_hw_data, "IIO_ICM42607");
 
+static int inv_icm42607_set_pwr_mgmt0(struct inv_icm42607_state *st,
+				      enum inv_icm42607_sensor_mode gyro,
+				      enum inv_icm42607_sensor_mode accel,
+				      bool temp, unsigned int *sleep_ms)
+{
+	enum inv_icm42607_sensor_mode oldgyro = st->conf.gyro.mode;
+	enum inv_icm42607_sensor_mode oldaccel = st->conf.accel.mode;
+	bool oldtemp = st->conf.temp_en;
+	unsigned int sleepval;
+	unsigned int val;
+	int ret;
+
+	if (gyro == oldgyro && accel == oldaccel && temp == oldtemp)
+		return 0;
+
+	val = FIELD_PREP(INV_ICM42607_PWR_MGMT0_GYRO_MODE_MASK, gyro);
+	val |= FIELD_PREP(INV_ICM42607_PWR_MGMT0_ACCEL_MODE_MASK, accel);
+	if (!temp)
+		val |= INV_ICM42607_PWR_MGMT0_ACCEL_LP_CLK_SEL;
+	ret = regmap_write(st->map, INV_ICM42607_REG_PWR_MGMT0, val);
+	if (ret)
+		return ret;
+
+	st->conf.gyro.mode = gyro;
+	st->conf.accel.mode = accel;
+	st->conf.temp_en = temp;

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 106

Quoted 5 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +5 -0

+
+	sleepval = 0;
+	if (temp && !oldtemp) {
+		if (sleepval < INV_ICM42607_TEMP_STARTUP_TIME_MS)
+			sleepval = INV_ICM42607_TEMP_STARTUP_TIME_MS;  

sleepval = max(sleepval,)
or just assign it here if not later patches add stuff in between the assignment to 0 and here.

I'm going to assign it to 0 here (unless you think I should define it at the beginning as 0) and then tweak as needed. I think this code here can be further optimized, especially if we make the assumption that START and STOP time for each sensor is comparable (the datasheet doesn't say, so I'm going to go with yes since that greatly simplifies things).

Quoted 4 lines

Quoted 4 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +4 -0

+static int inv_icm42607_resume(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+	int ret;

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw · line 336

Quoted 3 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +3 -0

+
+	guard(mutex)(&st->lock);
+  

Given the bunch of stuff we've run into recently around these I'm getting more paranoid.
Similar to above, could you use pm_runtime_force_resume() You would need to gate stuff added later to not occur though if it wasn't runtime suspended.

This I'm having trouble understanding. If I use pm_force_runtime_resume() I'm assuming that either I got an error (in which case I'd return the error) or the device is runtime resumed after the call completes. If that's the case, wouldn't my suspend and resume steps just be pm_force_runtime_suspend/resume, and enabling the regulator (first for resume) or disabling the regulator (last for suspend) as needed?

Quoted 14 lines

Quoted 14 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +11 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_enable_vddio_reg(st);
+	if (ret)
+		return ret;
+
+	/* Nothing else to restore at this time. */
+
+	return 0;
+}

Quoted 44 lines

Quoted 44 lines

Quoted 44 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +27 -0

index e9c81b52f9ef..bc0cefa2fb77 100644
@@ -9,6 +9,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 #include <linux/property.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>

@@ -72,6 +73,62 @@ const struct inv_icm42607_hw inv_icm42607p_hw_data = {
 };
 EXPORT_SYMBOL_NS_GPL(inv_icm42607p_hw_data, "IIO_ICM42607");
 
+static int inv_icm42607_set_pwr_mgmt0(struct inv_icm42607_state *st,
+				      enum inv_icm42607_sensor_mode gyro,
+				      enum inv_icm42607_sensor_mode accel,
+				      bool temp, unsigned int *sleep_ms)
+{
+	enum inv_icm42607_sensor_mode oldgyro = st->conf.gyro.mode;
+	enum inv_icm42607_sensor_mode oldaccel = st->conf.accel.mode;
+	bool oldtemp = st->conf.temp_en;
+	unsigned int sleepval;
+	unsigned int val;
+	int ret;
+
+	if (gyro == oldgyro && accel == oldaccel && temp == oldtemp)
+		return 0;
+
+	val = FIELD_PREP(INV_ICM42607_PWR_MGMT0_GYRO_MODE_MASK, gyro);
+	val |= FIELD_PREP(INV_ICM42607_PWR_MGMT0_ACCEL_MODE_MASK, accel);
+	if (!temp)
+		val |= INV_ICM42607_PWR_MGMT0_ACCEL_LP_CLK_SEL;
+	ret = regmap_write(st->map, INV_ICM42607_REG_PWR_MGMT0, val);
+	if (ret)
+		return ret;
+
+	st->conf.gyro.mode = gyro;
+	st->conf.accel.mode = accel;
+	st->conf.temp_en = temp;

Quoted 8 lines

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 106

Quoted 5 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +5 -0

+
+	sleepval = 0;
+	if (temp && !oldtemp) {
+		if (sleepval < INV_ICM42607_TEMP_STARTUP_TIME_MS)
+			sleepval = INV_ICM42607_TEMP_STARTUP_TIME_MS;  

sleepval = max(sleepval,)
or just assign it here if not later patches add stuff in between the assignment to 0 and here.

Wow I write some garbage English sometimes (no excuse, it is my native language!)

Quoted 7 lines

I'm going to assign it to 0 here (unless you think I should define it at the beginning as 0) and then tweak as needed. I think this code here can be further optimized, especially if we make the assumption that START and STOP time for each sensor is comparable (the datasheet doesn't say, so I'm going to go with yes since that greatly simplifies things).

I'm a bit lost. Suggestion was just to do

		sleepval = INV_ICM42607_TEMP_STARTUP_TIME_MS;

as we know it is 0. Probably not worth it though as ends up with fragile
code. Fine to keep it to what you have but use max() rather than if()

...

Quoted 13 lines

Quoted 4 lines

Quoted 4 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +4 -0

+static int inv_icm42607_resume(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+	int ret;

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw · line 336

Quoted 3 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +3 -0

+
+	guard(mutex)(&st->lock);
+  

Given the bunch of stuff we've run into recently around these I'm getting more paranoid.
Similar to above, could you use pm_runtime_force_resume() You would need to gate stuff added later to not occur though if it wasn't runtime suspended.

Quoted 7 lines

This I'm having trouble understanding. If I use pm_force_runtime_resume() I'm assuming that either I got an error (in which case I'd return the error) or the device is runtime resumed after the call completes. If that's the case, wouldn't my suspend and resume steps just be pm_force_runtime_suspend/resume, and enabling the regulator (first for resume) or disabling the regulator (last for suspend) as needed?

If you call pm_runtime_force_resume() it will do the right thing wrt to runtime PM state prior to suspend. If it wasn't runtime suspended it will runtime resume - if it was it'll no do anything. It won't directly tell you which one it did though.

The extra stuff that you know can't be the case if runtime pm is on will need some sort of gating. However, looking again it may already be protected by more specific checks.

	pm_runtime_force_resume();

	if (st->fifo.on) { //I'd failed to look at what was added.
		ret = regmap_write(st->map, INV_ICM42607_REG_FIFO_CONFIG1,
				   INV_ICM42607_FIFO_CONFIG1_MODE);
		if (ret)
			return ret;
	}

That if (st->fifo.on) previously didn't get checked if we were runtime suspended because in fifo mode we never are. So I was thinking you'd need that check to be

	if (!pm_runtime_suspended(dev) && st->fifo.on)

but the fifo.on check is sufficient by the same argument that if fifo.on is true we aren't in runtime suspend.

Basically I overthought it and didn't check what got added where the comment is in this patch.

Quoted 16 lines

Quoted 16 lines

Quoted 16 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +11 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_enable_vddio_reg(st);
+	if (ret)
+		return ret;
+
+	/* Nothing else to restore at this time. */
+
+	return 0;
+}

Quoted 117 lines · Jonathan Cameron

Quoted 44 lines

Quoted 44 lines

Quoted 44 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +27 -0

index e9c81b52f9ef..bc0cefa2fb77 100644
@@ -9,6 +9,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 #include <linux/property.h>
 #include <linux/regmap.h>
 #include <linux/regulator/consumer.h>

@@ -72,6 +73,62 @@ const struct inv_icm42607_hw inv_icm42607p_hw_data = {
 };
 EXPORT_SYMBOL_NS_GPL(inv_icm42607p_hw_data, "IIO_ICM42607");
 
+static int inv_icm42607_set_pwr_mgmt0(struct inv_icm42607_state *st,
+				      enum inv_icm42607_sensor_mode gyro,
+				      enum inv_icm42607_sensor_mode accel,
+				      bool temp, unsigned int *sleep_ms)
+{
+	enum inv_icm42607_sensor_mode oldgyro = st->conf.gyro.mode;
+	enum inv_icm42607_sensor_mode oldaccel = st->conf.accel.mode;
+	bool oldtemp = st->conf.temp_en;
+	unsigned int sleepval;
+	unsigned int val;
+	int ret;
+
+	if (gyro == oldgyro && accel == oldaccel && temp == oldtemp)
+		return 0;
+
+	val = FIELD_PREP(INV_ICM42607_PWR_MGMT0_GYRO_MODE_MASK, gyro);
+	val |= FIELD_PREP(INV_ICM42607_PWR_MGMT0_ACCEL_MODE_MASK, accel);
+	if (!temp)
+		val |= INV_ICM42607_PWR_MGMT0_ACCEL_LP_CLK_SEL;
+	ret = regmap_write(st->map, INV_ICM42607_REG_PWR_MGMT0, val);
+	if (ret)
+		return ret;
+
+	st->conf.gyro.mode = gyro;
+	st->conf.accel.mode = accel;
+	st->conf.temp_en = temp;

Quoted 8 lines

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c const struct inv_icm42607_hw inv_icm42607p_hw_data = { · line 106

Quoted 5 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +5 -0

+
+	sleepval = 0;
+	if (temp && !oldtemp) {
+		if (sleepval < INV_ICM42607_TEMP_STARTUP_TIME_MS)
+			sleepval = INV_ICM42607_TEMP_STARTUP_TIME_MS;    

sleepval = max(sleepval,)
or just assign it here if not later patches add stuff in between the assignment to 0 and here.

Wow I write some garbage English sometimes (no excuse, it is my native language!)

Quoted 7 lines

I'm going to assign it to 0 here (unless you think I should define it at the beginning as 0) and then tweak as needed. I think this code here can be further optimized, especially if we make the assumption that START and STOP time for each sensor is comparable (the datasheet doesn't say, so I'm going to go with yes since that greatly simplifies things).

I'm a bit lost. Suggestion was just to do

		sleepval = INV_ICM42607_TEMP_STARTUP_TIME_MS;

as we know it is 0. Probably not worth it though as ends up with fragile
code. Fine to keep it to what you have but use max() rather than if()

...

Quoted 13 lines

Quoted 4 lines

Quoted 4 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +4 -0

+static int inv_icm42607_resume(struct device *dev)
+{
+	struct inv_icm42607_state *st = dev_get_drvdata(dev);
+	int ret;

Quoted 8 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c int inv_icm42607_core_probe(struct regmap *regmap, const struct inv_icm42607_hw · line 336

Quoted 3 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +3 -0

+
+	guard(mutex)(&st->lock);
+    

Given the bunch of stuff we've run into recently around these I'm getting more paranoid.
Similar to above, could you use pm_runtime_force_resume() You would need to gate stuff added later to not occur though if it wasn't runtime suspended.

Quoted 7 lines

This I'm having trouble understanding. If I use pm_force_runtime_resume() I'm assuming that either I got an error (in which case I'd return the error) or the device is runtime resumed after the call completes. If that's the case, wouldn't my suspend and resume steps just be pm_force_runtime_suspend/resume, and enabling the regulator (first for resume) or disabling the regulator (last for suspend) as needed?

If you call pm_runtime_force_resume() it will do the right thing wrt to runtime PM state prior to suspend. If it wasn't runtime suspended it will runtime resume - if it was it'll no do anything. It won't directly tell you which one it did though.

The extra stuff that you know can't be the case if runtime pm is on will need some sort of gating. However, looking again it may already be protected by more specific checks.

	pm_runtime_force_resume();

	if (st->fifo.on) { //I'd failed to look at what was added.
		ret = regmap_write(st->map, INV_ICM42607_REG_FIFO_CONFIG1,
				   INV_ICM42607_FIFO_CONFIG1_MODE);
		if (ret)
			return ret;
	}

That if (st->fifo.on) previously didn't get checked if we were runtime suspended because in fifo mode we never are. So I was thinking you'd need that check to be

	if (!pm_runtime_suspended(dev) && st->fifo.on)

but the fifo.on check is sufficient by the same argument that if fifo.on is true we aren't in runtime suspend.

Quoted 2 lines

Basically I overthought it and didn't check what got added where the comment is in this patch.

I'm still lost here... are you saying the existing logic is sufficient or that we need to do something more (like force the runtime resume/suspend in different places).

Thank you again for all of your help, you've been amazing.

Chris

Quoted 17 lines

Quoted 16 lines

Quoted 16 lines

Quoted 16 lines

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +11 -0

+	if (pm_runtime_suspended(dev))
+		return 0;
+
+	ret = inv_icm42607_enable_vddio_reg(st);
+	if (ret)
+		return ret;
+
+	/* Nothing else to restore at this time. */
+
+	return 0;
+}  

From: Chris Morgan <[email protected]>

Add all FIFO parsing and reading functions to support inv_icm42607 hardware.

Signed-off-by Chris Morgan <[email protected]>

---

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.c new file +19 -0

new file mode 100644
index 000000000000..a011f1f728b9
@@ -0,0 +1,482 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (C) 2026 InvenSense, Inc.
+ */
+
+#include <linux/delay.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/iio.h>
+#include <linux/minmax.h>
+#include <linux/mutex.h>
+#include <linux/pm_runtime.h>
+#include <linux/regmap.h>
+
+#include <linux/iio/common/inv_sensors_timestamp.h>
+
+#include "inv_icm42607.h"
+#include "inv_icm42607_buffer.h"
+
+/* FIFO header: 1 byte */

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.c new file +14 -0

+	s8 temp;
+} __packed;
+
+struct inv_icm42607_fifo_2sensors_packet {
+	u8 header;
+	struct inv_icm42607_fifo_sensor_data accel;
+	struct inv_icm42607_fifo_sensor_data gyro;
+	s8 temp;
+	__be16 timestamp;
+} __packed;
 
 
+int inv_icm42607_buffer_set_fifo_en(struct inv_icm42607_state *st,
+				    unsigned int fifo_en)
+{
+	unsigned int val;

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.c new file +64 -0

+
+	ret = regmap_write(st->map, INV_ICM42607_REG_FIFO_CONFIG1, val);
+	if (ret)
+		return ret;
+
+	st->fifo.en = fifo_en;
+	inv_icm42607_buffer_update_fifo_period(st);
+
+	return 0;
+}
 
+
+/**
+ * inv_icm42607_buffer_update_watermark - update watermark FIFO threshold
+ * @st:	driver internal state
+ *
+ * Returns 0 on success, a negative error code otherwise.
+ */
+int inv_icm42607_buffer_update_watermark(struct inv_icm42607_state *st)
+{
+	const struct device *dev = regmap_get_device(st->map);
+	unsigned int wm_gyro, wm_accel, watermark;
+	u32 latency_gyro, latency_accel, latency;
+	u32 period_gyro, period_accel;
+	size_t packet_size, wm_size;
+	__le16 raw_wm;
+	bool restore;
+	int ret;
+
+	packet_size = inv_icm42607_get_packet_size(st->fifo.en);
+
+	/* compute sensors latency, depending on sensor watermark and odr */
+	wm_gyro = inv_icm42607_wm_truncate(st->fifo.watermark.gyro, packet_size);
+	wm_accel = inv_icm42607_wm_truncate(st->fifo.watermark.accel, packet_size);
+	/* use us for odr to avoid overflow using 32 bits values */
+	period_gyro = inv_icm42607_odr_to_period(st->conf.gyro.odr) / 1000UL;
+	period_accel = inv_icm42607_odr_to_period(st->conf.accel.odr) / 1000UL;
+	latency_gyro = period_gyro * wm_gyro;
+	latency_accel = period_accel * wm_accel;
+
+	/* 0 value for watermark means that the sensor is turned off */
+	if (wm_gyro == 0 && wm_accel == 0)
+		return 0;
+
+	if (latency_gyro == 0) {
+		watermark = wm_accel;
+		st->fifo.watermark.eff_accel = wm_accel;
+	} else if (latency_accel == 0) {
+		watermark = wm_gyro;
+		st->fifo.watermark.eff_gyro = wm_gyro;
+	} else {
+		/* compute the smallest latency that is a multiple of both */
+		if (latency_gyro <= latency_accel)
+			latency = latency_gyro - (latency_accel % latency_gyro);
+		else
+			latency = latency_accel - (latency_gyro % latency_accel);
+		/* all this works because periods are multiple of each others */
+		watermark = latency / min(period_gyro, period_accel);
+		watermark = max(watermark, 1);
+		/* update effective watermark */
+		st->fifo.watermark.eff_gyro = max(latency / period_gyro, 1);
+		st->fifo.watermark.eff_accel = max(latency / period_accel, 1);
+	}
+
+	/* changing FIFO watermark requires to turn off watermark interrupt */

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.c new file +23 -0

+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
 
 
+int inv_icm42607_buffer_fifo_read(struct inv_icm42607_state *st,
+				  unsigned int max)
+{
+	const void *accel, *gyro, *timestamp;
+	size_t i, max_count;
+	const s8 *temp;
+	ssize_t size;
+	int ret;
+
+	guard(mutex)(&st->lock);
+
+	/* reset all samples counters */
+	st->fifo.count = 0;
+	st->fifo.nb.gyro = 0;
+	st->fifo.nb.accel = 0;
+	st->fifo.nb.total = 0;
+

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.c new file +32 -0

+
+	/* check and clamp FIFO count value */
+	if (st->fifo.count == 0)
+		return 0;
+
+	st->fifo.count = min(st->fifo.count, max_count);
+
+	/* read all FIFO data in internal buffer */
+	ret = regmap_noinc_read(st->map, INV_ICM42607_REG_FIFO_DATA,
+				st->fifo.data, st->fifo.count);
+	if (ret)
+		return ret;
+
+	/* compute number of samples for each sensor */
+	for (i = 0; i < st->fifo.count; i += size) {
+		size = inv_icm42607_fifo_decode_packet(&st->fifo.data[i],
+				&accel, &gyro, &temp, &timestamp);
+		/* Make sure the size is at least 1 valid packet. */
+		if (size < INV_ICM42607_FIFO_1SENSOR_PACKET_SIZE)
+			break;
+		/* Error if we are going to overflow the buffer. */
+		if (i + size > st->fifo.count)
+			return -EIO;
+		if (gyro != NULL && inv_icm42607_fifo_is_data_valid(gyro))
+			st->fifo.nb.gyro++;
+		if (accel != NULL && inv_icm42607_fifo_is_data_valid(accel))
+			st->fifo.nb.accel++;
+		st->fifo.nb.total++;
+	}
+
+	return 0;
+}

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.h new file +52 -0

new file mode 100644
index 000000000000..b77deb66f8bd
@@ -0,0 +1,93 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2026 InvenSense, Inc.
+ */
+
+#ifndef INV_ICM42607_BUFFER_H_
+#define INV_ICM42607_BUFFER_H_
+
+#include <linux/bitops.h>
+
+struct inv_icm42607_state;
+
+#define INV_ICM42607_SENSOR_GYRO	BIT(0)
+#define INV_ICM42607_SENSOR_ACCEL	BIT(1)
+#define INV_ICM42607_SENSOR_TEMP	BIT(2)
+
+/**
+ * struct inv_icm42607_fifo - FIFO state variables
+ * @on:		reference counter for FIFO on.
+ * @en:		bits field of INV_ICM42607_SENSOR_* for FIFO EN bits.
+ * @period:	FIFO internal period.
+ * @watermark:	watermark configuration values for accel and gyro.
+ * @count:	number of bytes in the FIFO data buffer.
+ * @nb:		gyro, accel and total samples in the FIFO data buffer.
+ * @data:	FIFO data buffer aligned for DMA (2kB + 32 bytes of read cache).
+ */
+struct inv_icm42607_fifo {
+	unsigned int on;
+	unsigned int en;
+	u32 period;
+	struct {
+		unsigned int gyro;
+		unsigned int accel;
+		unsigned int eff_gyro;
+		unsigned int eff_accel;
+	} watermark;
+	size_t count;
+	struct {
+		size_t gyro;
+		size_t accel;
+		size_t total;
+	} nb;
+	u8 data[2080] __aligned(IIO_DMA_MINALIGN);
+};
+
+/* FIFO data packet */
+struct inv_icm42607_fifo_sensor_data {
+	__be16 x;
+	__be16 y;
+	__be16 z;
+};
+

drivers/iio/imu/inv_icm42607/inv_icm42607_buffer.h new file +31 -0

+
+	if (x == INV_ICM42607_FIFO_DATA_INVALID &&
+	    y == INV_ICM42607_FIFO_DATA_INVALID &&
+	    z == INV_ICM42607_FIFO_DATA_INVALID)
+		return false;
+
+	return true;
+}
+
+ssize_t inv_icm42607_fifo_decode_packet(const void *packet, const void **accel,
+					const void **gyro, const s8 **temp,
+					const void **timestamp);
+
+extern const struct iio_buffer_setup_ops inv_icm42607_buffer_ops;
+
+int inv_icm42607_buffer_init(struct inv_icm42607_state *st);
+
+void inv_icm42607_buffer_update_fifo_period(struct inv_icm42607_state *st);
+
+int inv_icm42607_buffer_set_fifo_en(struct inv_icm42607_state *st,
+				    unsigned int fifo_en);
+
+int inv_icm42607_buffer_update_watermark(struct inv_icm42607_state *st);
+
+int inv_icm42607_buffer_fifo_read(struct inv_icm42607_state *st,
+				  unsigned int max);
+
+int inv_icm42607_buffer_hwfifo_flush(struct inv_icm42607_state *st,
+				     unsigned int count);
+
+#endif

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +1 -0

index bc0cefa2fb77..29573d4fc0f0 100644
@@ -15,6 +15,7 @@
 #include <linux/regulator/consumer.h>
 
 #include "inv_icm42607.h"
+#include "inv_icm42607_buffer.h"
 
 static bool inv_icm42607_is_volatile_reg(struct device *dev, unsigned int reg)
 {

drivers/iio/imu/inv_icm42607/inv_icm42607_core.c +26 -0

+		1250000,
+		/* 400Hz */
+		2500000,
+		/* 200Hz */
+		5000000,
+		/* 100 Hz */
+		10000000,
+		/* 50Hz */
+		20000000,
+		/* 25Hz */
+		40000000,
+		/* 12.5Hz */
+		80000000,
+		/* 6.25Hz */
+		160000000,
+		/* 3.125Hz */
+		320000000,
+		/* 1.5625Hz */
+		640000000,
+	};
+
+	odr = clamp(odr, INV_ICM42607_ODR_1600HZ, INV_ICM42607_ODR_1_5625HZ_LP);
+
+	return odr_periods[odr];
+}
+
 

From: Chris Morgan <[email protected]>

Add icm42607 accelerometer sensor for icm42607.

Signed-off-by Chris Morgan <[email protected]>

drivers/iio/imu/inv_icm42607/inv_icm42607.h +0 -0

index 2542ad1bee51..c646c22b5e0e 100644
@@ -82,12 +82,24 @@ enum inv_icm42607_filter_bw {
 	INV_ICM42607_FILTER_BW_16HZ,