iio: health: add MAX86150 ECG and PPG biosensor driver

Add the Device Tree binding schema for the Analog Devices MAX86150 integrated biosensor, which combines two photoplethysmography (PPG) channels (Red LED and IR LED) and one electrocardiogram (ECG) channel in a single I2C device. Samples are buffered in a 32-entry hardware FIFO with a configurable almost-full interrupt.

The device requires four independent supply rails per the datasheet power tree: digital core (vdd), analog core (avdd), ECG reference (vref), and LED anode (leds).

Assisted-by Claude:claude-sonnet-5

Signed-off-by Md Shofiqul Islam <[email protected]>

---
 .../bindings/iio/health/adi,max86150.yaml     | 78 +++++++++++++++++++
 MAINTAINERS                                   |  6 ++
 2 files changed, 84 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/health/adi,max86150.yaml

Documentation/devicetree/bindings/iio/health/adi,max86150.yaml new file +10 -0

new file mode 100644
index 0000000000000..da2ff9b0ada2b
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/iio/health/adi,max86150.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Analog Devices MAX86150 ECG and PPG Biosensor
+
+maintainers:
+  - Md Shofiqul Islam <[email protected]>

Documentation/devicetree/bindings/iio/health/adi,max86150.yaml new file +4 -0

+
+  Datasheet:
+    https://www.analog.com/media/en/technical-documentation/data-sheets/MAX86150.pdf
+

Documentation/devicetree/bindings/iio/health/adi,max86150.yaml new file +2 -0

+      Active-low interrupt line.  Asserted when the FIFO almost-full
+      threshold is reached or when a new PPG sample is ready.

Add a new IIO driver for the Analog Devices MAX86150 integrated biosensor, which combines two PPG optical channels (Red/IR LED) and one ECG biopotential channel in a single I2C device.

The device has a 32-entry hardware FIFO with a configurable almost-full interrupt. The driver uses the standard IIO hardware-trigger and triggered-buffer framework: a hard-irq handler reads and clears INT_STATUS1 to de-assert the line before calling iio_trigger_poll(), and the threaded trigger handler drains the FIFO and pushes samples, with timestamps back-calculated from the interrupt arrival time by one sample_period_ns per step.

Relying on the trigger core's own
attach/detach synchronization avoids the need for an explicit iio_buffer_enabled() guard or synchronize_irq() in the interrupt path.

Key implementation details:
- Part ID register (0xFF) verified against 0x1E on probe; mismatched devices are rejected with -ENODEV so the driver cannot bind to the wrong hardware
- Stale A_FULL and PPG_RDY status bits are cleared before arming the interrupt or polling for a sample, so a previously-latched flag cannot fire the handler against garbage state
- 24-bit FIFO words decoded directly from the raw byte buffer
- regmap_set_bits() / regmap_clear_bits() for single-direction writes
- Device remains in shutdown between captures to suppress LED current
- vdd, avdd, vref and leds regulators required per the datasheet power tree
- iio_get_time_ns() used for timestamps so they respect the IIO device's configured clock source
- A_FULL status bit used to detect FIFO exactly full (wr_ptr == rd_ptr with OVF_COUNTER == 0) so valid samples are not silently dropped
- No IRQ trigger-type override: the device has no register to reconfigure interrupt polarity or type, so IRQF_ONESHOT with whatever type firmware provides is sufficient

drivers/iio/health/max86150.c new file +15 -0

+
+/* PPG sample rate (SR field of PPG_CONFIG1) - single-pulse variants */
+#define MAX86150_PPG_SR_SP_10HZ		0
+#define MAX86150_PPG_SR_SP_20HZ		1
+#define MAX86150_PPG_SR_SP_50HZ		2
+#define MAX86150_PPG_SR_SP_84HZ		3
+#define MAX86150_PPG_SR_SP_100HZ	4
+#define MAX86150_PPG_SR_SP_200HZ	5
+#define MAX86150_PPG_SR_SP_400HZ	6
+#define MAX86150_PPG_SR_SP_800HZ	7
+#define MAX86150_PPG_SR_SP_1000HZ	8
+#define MAX86150_PPG_SR_SP_1600HZ	9
+#define MAX86150_PPG_SR_SP_3200HZ	10
+/* Double-pulse variants (two LED pulses averaged per sample) */
+#define MAX86150_PPG_SR_DP_10HZ		11

+/* LED pulse amplitude: 0x00 = 0 mA, step ~0.8 mA, 0x3F ~= 50 mA, 0xFF ~= 200 mA */

drivers/iio/health/max86150.c new file +4 -0

+#define MAX86150_FIFO_DEPTH		32
+#define MAX86150_BYTES_PER_SLOT		3
+#define MAX86150_NUM_SLOTS		3
+#define MAX86150_SAMPLE_BYTES		(MAX86150_NUM_SLOTS * MAX86150_BYTES_PER_SLOT)

+/**
+ * struct max86150_data - driver private state
+ * @regmap: register map for this device
+ * @trig: IIO hardware trigger backed by the device interrupt line
+ * @sample_period_ns: sample period in nanoseconds (set from configured rate)

+ * @fifo_raw:         scratch buffer for regmap_noinc_read() FIFO bursts; kept
+ *                    in struct (heap) rather than on the stack, since stack
+ *                    memory isn't guaranteed DMA-safe (e.g. CONFIG_VMAP_STACK)
+ *                    and some I2C host controllers DMA the read buffer
+ * @scan:             IIO push buffer; channels[] packed per active_scan_mask,

+ * with a trailing aligned_s64 slot for the timestamp

+ */

drivers/iio/health/max86150.c new file +7 -0

+struct max86150_data {
+	struct regmap		*regmap;
+	struct iio_trigger	*trig;
+	u32			 sample_period_ns;
+	u8			 fifo_raw[MAX86150_SAMPLE_BYTES];
+	IIO_DECLARE_DMA_BUFFER_WITH_TS(s32, scan, MAX86150_NUM_SLOTS);
+};

+};

(quoted diff) +2 -0

+	return 0;
+}

+}

drivers/iio/health/max86150.c new file +5 -0

+		switch (chan->scan_index) {
+		case MAX86150_IDX_PPG_RED:
+			*val = ppg_red;
+			break;
+		case MAX86150_IDX_PPG_IR:

drivers/iio/health/max86150.c new file +3 -0

+	return regmap_set_bits(data->regmap, MAX86150_REG_SYS_CTRL,
+			       MAX86150_SYS_SHDN);
+}

(quoted diff) +2 -0

+	return max86150_trigger_disable(data);
+}

drivers/iio/health/max86150.c new file +24 -0

+	int ret;
+
+	/*
+	 * INT_STATUS1 was already read (and the interrupt de-asserted) by
+	 * max86150_irq_handler().  Read only the FIFO pointers here.
+	 */
+	ret = regmap_read(data->regmap, MAX86150_REG_FIFO_WR_PTR, &wr_ptr);
+	if (ret)
+		goto done;
+	ret = regmap_read(data->regmap, MAX86150_REG_FIFO_RD_PTR, &rd_ptr);
+	if (ret)
+		goto done;
+	ret = regmap_read(data->regmap, MAX86150_REG_OVF_COUNTER, &ovf);
+	if (ret)
+		goto done;
+
+	if (ovf > 0) {
+		n_avail = MAX86150_FIFO_DEPTH;
+		t_drain = iio_get_time_ns(idev);
+	} else {
+		n_avail = (wr_ptr - rd_ptr) & (MAX86150_FIFO_DEPTH - 1);
+		/*
+		 * wr_ptr == rd_ptr with no overflow means either empty or
+		 * exactly 32 slots filled (pointer wrapped).  Since this

drivers/iio/health/max86150.c new file +30 -0

+		s64 ts;
+
+		if (ovf > 0)
+			ts = t_drain -
+			     (s64)(n_avail - 1 - i) * data->sample_period_ns;
+		else
+			ts = pf->timestamp +
+			     ((s64)i - (MAX86150_FIFO_A_FULL_SAMPLES - 1)) *
+			     data->sample_period_ns;
+
+		ret = max86150_read_one_sample(data, &ppg_red, &ppg_ir, &ecg);
+		if (ret)
+			break;
+
+		memset(data->scan, 0, sizeof(data->scan));
+
+		if (test_bit(MAX86150_IDX_PPG_RED, idev->active_scan_mask))
+			data->scan[j++] = ppg_red;
+		if (test_bit(MAX86150_IDX_PPG_IR, idev->active_scan_mask))
+			data->scan[j++] = ppg_ir;
+		if (test_bit(MAX86150_IDX_ECG, idev->active_scan_mask))
+			data->scan[j++] = ecg;
+
+		iio_push_to_buffers_with_timestamp(idev, data->scan, ts);
+	}
+
+done:
+	iio_trigger_notify_done(idev->trig);
+	return IRQ_HANDLED;
+}

drivers/iio/health/max86150.c new file +4 -0

+static void max86150_powerdown(void *arg)
+{
+	struct max86150_data *data = arg;
+	struct device *dev = regmap_get_device(data->regmap);

drivers/iio/health/max86150.c new file +11 -0

+}
+
+static int max86150_chip_init(struct max86150_data *data)
+{
+	int ret;
+
+	ret = regmap_write(data->regmap, MAX86150_REG_SYS_CTRL,
+			   MAX86150_SYS_RESET);
+	if (ret)
+		return ret;
+

drivers/iio/health/max86150.c new file +16 -0

+				      MAX86150_FIFO_DEPTH -
+				      MAX86150_FIFO_A_FULL_SAMPLES));
+	if (ret)
+		return ret;
+
+	ret = regmap_write(data->regmap, MAX86150_REG_FIFO_DCTRL1,
+			   FIELD_PREP(MAX86150_FIFO_FD1, MAX86150_FD_LED1) |
+			   FIELD_PREP(MAX86150_FIFO_FD2, MAX86150_FD_LED2));
+	if (ret)
+		return ret;
+
+	ret = regmap_write(data->regmap, MAX86150_REG_FIFO_DCTRL2,
+			   FIELD_PREP(MAX86150_FIFO_FD3, MAX86150_FD_ECG) |
+			   FIELD_PREP(MAX86150_FIFO_FD4, MAX86150_FD_NONE));
+	if (ret)
+		return ret;

drivers/iio/health/max86150.c new file +13 -0

+	ret = regmap_write(data->regmap, MAX86150_REG_LED1_PA,
+			   MAX86150_LED_PA_DEFAULT);
+	if (ret)
+		return ret;
+
+	ret = regmap_write(data->regmap, MAX86150_REG_LED2_PA,
+			   MAX86150_LED_PA_DEFAULT);
+	if (ret)
+		return ret;
+
+	return regmap_write(data->regmap, MAX86150_REG_SYS_CTRL,
+			    MAX86150_SYS_SHDN);
+}

drivers/iio/health/max86150.c new file +4 -0

+						IRQF_ONESHOT,
+						"max86150", data->trig);
+		if (ret)
+			return ret;

(quoted diff) +2 -0

+	{ }
+};

On Fri, Jul 17, 2026 at 11:11:37PM +0300, Md Shofiqul Islam wrote:

Quoted 6 lines

drivers/iio/health/max86150.c new file +6 -0

+static int max86150_read_one_sample(struct max86150_data *data,
+				    u32 *ppg_red, u32 *ppg_ir, s32 *ecg)
+{
+	int ret;
+
+	ret = regmap_noinc_read(data->regmap, MAX86150_REG_FIFO_DATA,

drivers/iio/health/max86150.c line 210

Quoted 6 lines

drivers/iio/health/max86150.c new file +6 -0

+				data->fifo_raw, MAX86150_SAMPLE_BYTES);
+	if (ret)
+		return ret;
+
+	*ppg_red = (data->fifo_raw[0] & 0x07) << 16 |
+		    data->fifo_raw[1] << 8 | data->fifo_raw[2];

Use get_unaligned_be16()

drivers/iio/health/max86150.c line 212

Quoted 2 lines

drivers/iio/health/max86150.c new file +2 -0

+	*ppg_ir  = (data->fifo_raw[3] & 0x07) << 16 |
+		    data->fifo_raw[4] << 8 | data->fifo_raw[5];

Ditto.

drivers/iio/health/max86150.c line 214

Quoted 2 lines

drivers/iio/health/max86150.c new file +2 -0

+	*ecg = sign_extend32((data->fifo_raw[6] & 0x03) << 16 |
+			      data->fifo_raw[7] << 8 | data->fifo_raw[8], 17);

Ditto.

Quoted 2 lines

(quoted diff) +2 -0

+	return 0;
+}

Add a new IIO driver for the Analog Devices MAX86150 integrated biosensor, which combines two PPG optical channels (Red/IR LED) and one ECG biopotential channel in a single I2C device.

The device has a 32-entry hardware FIFO with a configurable almost-full interrupt. The driver uses the standard IIO hardware-trigger and triggered-buffer framework: a hard-irq handler reads and clears INT_STATUS1 to de-assert the line before calling iio_trigger_poll(), and the threaded trigger handler drains the FIFO and pushes samples, with timestamps back-calculated from the interrupt arrival time by one sample_period_ns per step. Relying on the trigger core's own attach/detach synchronization avoids the need for an explicit iio_buffer_enabled() guard or synchronize_irq() in the interrupt path.

Key implementation details:
- Part ID register (0xFF) verified against 0x1E on probe; mismatched devices are rejected with -ENODEV so the driver cannot bind to the wrong hardware
- Stale A_FULL and PPG_RDY status bits are cleared before arming the interrupt or polling for a sample, so a previously-latched flag cannot fire the handler against garbage state
- 24-bit FIFO words decoded directly from the raw byte buffer
- regmap_set_bits() / regmap_clear_bits() for single-direction writes
- Device remains in shutdown between captures to suppress LED current
- vdd, avdd, vref and leds regulators required per the datasheet power tree
- iio_get_time_ns() used for timestamps so they respect the IIO device's configured clock source
- A_FULL status bit used to detect FIFO exactly full (wr_ptr == rd_ptr with OVF_COUNTER == 0) so valid samples are not silently dropped
- No IRQ trigger-type override: the device has no register to reconfigure interrupt polarity or type, so IRQF_ONESHOT with whatever type firmware provides is sufficient

Suggested-by Jonathan Cameron <[email protected]>

Suggested-by Joshua Crofts <[email protected]>

Assisted-by Claude:claude-sonnet-5

Signed-off-by Md Shofiqul Islam <[email protected]>

drivers/iio/health/max86150.c new file +2 -0

new file mode 100644
index 0000000000000..47d96570a95fc
 
 
 
+static int max86150_chip_init(struct max86150_data *data)
+{

drivers/iio/health/max86150.c new file +20 -0

+
+static int max86150_probe(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+	struct iio_dev *indio_dev;
+	struct max86150_data *data;
+	unsigned int part_id;
+	int ret;
+
+	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
+	if (!indio_dev)
+		return -ENOMEM;
+
+	data = iio_priv(indio_dev);
+
+	ret = devm_regulator_get_enable(dev, "vdd");
+	if (ret)
+		return dev_err_probe(dev, ret, "Failed to enable vdd supply\n");
+
+	ret = devm_regulator_get_enable(dev, "avdd");

drivers/iio/health/max86150.c new file +4 -0

+
+	data->regmap = devm_regmap_init_i2c(client, &max86150_regmap_config);
+	if (IS_ERR(data->regmap))
+		return dev_err_probe(dev, PTR_ERR(data->regmap),

drivers/iio/health/max86150.c new file +19 -0

+
+	ret = max86150_chip_init(data);
+	if (ret)
+		return dev_err_probe(dev, ret, "Chip initialisation failed\n");
+
+	ret = devm_add_action_or_reset(dev, max86150_powerdown, data);
+	if (ret)
+		return ret;
+
+	indio_dev->name         = "max86150";
+	indio_dev->channels     = max86150_channels;
+	indio_dev->num_channels = ARRAY_SIZE(max86150_channels);
+	indio_dev->info         = &max86150_iio_info;
+	indio_dev->modes        = INDIO_DIRECT_MODE;
+
+	if (client->irq > 0) {
+		data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
+						    indio_dev->name,
+						    iio_device_id(indio_dev));

drivers/iio/health/max86150.c new file +11 -0

+		if (ret)
+			return ret;
+
+		ret = devm_iio_trigger_register(dev, data->trig);
+		if (ret)
+			return dev_err_probe(dev, ret,
+					     "Failed to register trigger\n");
+	}
+
+	ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
+					      iio_pollfunc_store_time,

drivers/iio/health/max86150.c new file +6 -0

+	 */
+	if (data->trig)
+		indio_dev->trig = iio_trigger_get(data->trig);
+
+	return devm_iio_device_register(dev, indio_dev);
+}

Sorry for the long gap since v9. Between then and now the driver's buffer implementation was rewritten from the kfifo-based design onto the standard IIO hardware-trigger and triggered-buffer framework, and I read through every open comment from every reviewer before sending this rather than sending again too quickly.

Changes since v9:
- Rewrote the buffer implementation around devm_iio_trigger_alloc() + devm_iio_triggered_buffer_setup() instead of the kfifo buffer and manual postenable/predisable pair. The hard-irq handler now only reads and clears INT_STATUS1 before calling iio_trigger_poll(); the threaded trigger handler does the FIFO drain. This relies on the trigger core's own attach/detach synchronization instead of an explicit iio_buffer_enabled() guard or synchronize_irq(), which the old design needed to avoid a NULL active_scan_mask race on teardown (Sashiko, both HIGH severity findings)

--
2.51.1