All of lore.kernel.org
 help / color / mirror / Atom feed
From: "Adil Hüsrev Tepe" <tadilhusrev@gmail.com>
To: Jonathan Cameron <jic23@kernel.org>,
	Rob Herring <robh@kernel.org>,
	Krzysztof Kozlowski <krzk+dt@kernel.org>,
	Conor Dooley <conor+dt@kernel.org>
Cc: "David Lechner" <dlechner@baylibre.com>,
	"Nuno Sá" <nuno.sa@analog.com>,
	"Andy Shevchenko" <andy@kernel.org>,
	linux-iio@vger.kernel.org, devicetree@vger.kernel.org,
	linux-kernel@vger.kernel.org,
	"Adil Hüsrev Tepe" <tadilhusrev@gmail.com>
Subject: [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver
Date: Mon, 16 Nov 2026 10:40:13 +0300	[thread overview]
Message-ID: <20261116074013.355363-3-tadilhusrev@gmail.com> (raw)
In-Reply-To: <20261116074013.355363-1-tadilhusrev@gmail.com>

Add an IIO driver for the Imagis ISG5320A capacitive SAR/grip sensor
(I2C), as fitted on the Samsung Galaxy XCover5. It exposes one
IIO_PROXIMITY channel (the B-channel signal minus its baseline) and a
rising/falling threshold proximity event.

The driver was derived from the Samsung vendor driver during XCover5
mainline bring-up with the help of an AI coding assistant (Claude Code,
Anthropic), which drafted the mainline IIO driver; I reviewed every line
and tested it on hardware.

Signed-off-by: Adil Hüsrev Tepe <tadilhusrev@gmail.com>
---
 drivers/iio/proximity/Kconfig    |  11 +
 drivers/iio/proximity/Makefile   |   1 +
 drivers/iio/proximity/isg5320a.c | 857 +++++++++++++++++++++++++++++++
 3 files changed, 869 insertions(+)
 create mode 100644 drivers/iio/proximity/isg5320a.c

diff --git a/drivers/iio/proximity/Kconfig b/drivers/iio/proximity/Kconfig
index bb77fad2a..c5df6f0e0 100644
--- a/drivers/iio/proximity/Kconfig
+++ b/drivers/iio/proximity/Kconfig
@@ -67,6 +67,17 @@ config IRSD200
 	  To compile this driver as a module, choose M here: the module will be
 	  called irsd200.
 
+config ISG5320A
+	tristate "Imagis ISG5320A SAR proximity sensor"
+	depends on I2C
+	select REGMAP_I2C
+	help
+	  Say Y here to build a driver for the Imagis ISG5320A capacitive
+	  SAR/grip proximity sensor.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called isg5320a.
+
 config ISL29501
 	tristate "Intersil ISL29501 Time Of Flight sensor"
 	depends on I2C
diff --git a/drivers/iio/proximity/Makefile b/drivers/iio/proximity/Makefile
index 4352833dd..6aa606fa5 100644
--- a/drivers/iio/proximity/Makefile
+++ b/drivers/iio/proximity/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_CROS_EC_MKBP_PROXIMITY) += cros_ec_mkbp_proximity.o
 obj-$(CONFIG_D3323AA)		+= d3323aa.o
 obj-$(CONFIG_HX9023S)		+= hx9023s.o
 obj-$(CONFIG_IRSD200)		+= irsd200.o
+obj-$(CONFIG_ISG5320A)		+= isg5320a.o
 obj-$(CONFIG_ISL29501)		+= isl29501.o
 obj-$(CONFIG_LIDAR_LITE_V2)	+= pulsedlight-lidar-lite-v2.o
 obj-$(CONFIG_MB1232)		+= mb1232.o
diff --git a/drivers/iio/proximity/isg5320a.c b/drivers/iio/proximity/isg5320a.c
new file mode 100644
index 000000000..533267035
--- /dev/null
+++ b/drivers/iio/proximity/isg5320a.c
@@ -0,0 +1,857 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Imagis ISG5320A capacitive grip (SAR proximity) sensor.
+ *
+ * Register map, init table and every write sequence below come from the
+ * Samsung vendor driver (drivers/sensors/isg5320a.c + isg5320a_reg.h,
+ * Galaxy XCover5 5.10 tree, Copyright (C) Imagis Technology). Citations of
+ * the form "vendor :NNN" refer to lines in that isg5320a.c. This driver
+ * writes no register the vendor driver does not write, and only with the
+ * values the vendor writes; regmap enforces that through writeable_reg.
+ *
+ * The chip is used as one proximity channel: the vendor's "diff" value
+ * (CDC16_T - BSL16_B, i.e. the B-channel signal minus its baseline) is
+ * exposed as in_proximity0_raw, and the chip's CLOSE/FAR interrupt is
+ * exposed as IIO threshold events (rising = grip, falling = release).
+ */
+
+#include <linux/bits.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/pm_wakeup.h>
+#include <linux/property.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+
+#include <linux/iio/events.h>
+#include <linux/iio/iio.h>
+
+/* Registers (vendor isg5320a_reg.h :19-79) */
+#define ISG5320A_REG_IRQSRC		0x00	/* read releases the INT line */
+#define ISG5320A_REG_IRQSTS		0x01
+#define   ISG5320A_IRQSTS_PROX		BIT(4)	/* ISG5320A_PROX_STATE, reg.h :81 */
+#define ISG5320A_REG_OSCCON		0x06
+#define   ISG5320A_OSC_SLEEP		0xB0
+#define   ISG5320A_OSC_NORMAL		0xF0
+#define ISG5320A_REG_IRQFUNC		0x07
+#define   ISG5320A_IRQFUNC_ENABLE	0x0D
+#define   ISG5320A_IRQFUNC_DISABLE	0x13
+#define ISG5320A_REG_BS_ON_WD		0x19
+#define   ISG5320A_BS_WD_OFF		0x0A
+#define   ISG5320A_BS_WD_ON		0x8A
+#define ISG5320A_REG_SCANCTRL1		0x38
+#define   ISG5320A_SCAN_STOP		0x00
+#define   ISG5320A_CFCAL_START		0xDD
+#define ISG5320A_REG_SCANCTRL2		0x39
+#define   ISG5320A_SCAN2_RESET		0x00
+#define   ISG5320A_SCAN2_CLEAR		0x60
+#define   ISG5320A_BFCAL_START		0x07
+/* CDC16_T_H, CDC16_T_L, BSL16_B_H, BSL16_B_L (vendor :453) */
+#define ISG5320A_REG_CDC16_T_H		0x5C
+/* B_PROXCTL3..5: threshold, close hysteresis, far hysteresis (vendor :890) */
+#define ISG5320A_REG_B_PROXCTL3		0x9B
+#define ISG5320A_REG_DIGITAL_ACC	0xA4
+#define ISG5320A_REG_PROTECT		0xCD
+#define   ISG5320A_PROTECT_UNLOCK	0xDE
+#define ISG5320A_REG_SOFTRESET		0xFD
+#define   ISG5320A_SOFTRESET_VAL	0xDE
+#define ISG5320A_REG_CHIPID		0xFE
+#define ISG5320A_MAX_REG		0xFE
+
+#define ISG5320A_VENDOR_CHIP_ID		0x32	/* vendor :39, never checked */
+#define ISG5320A_RESET_CONDITION	5000	/* reg.h :99, for cfcal_th */
+
+#define ISG5320A_AUTOSUSPEND_MS		5000
+
+struct isg5320a_reg_data {
+	u8 addr;
+	u8 val;
+};
+
+/*
+ * Vendor setup_reg[] for "XCOVER5 ALL" (isg5320a_reg.h :283-435). The other
+ * table (:130-282) is under CONFIG_SENSORS_ISG5320A_XCOVER5_KOR, which the
+ * stock exynos850-xcover5xx_defconfig leaves unset; it differs only in
+ * 0x9C (threshold low byte), 0xA0 (far hysteresis low byte) and 0xBA.
+ */
+static const struct isg5320a_reg_data isg5320a_setup_reg[] = {
+	{ 0x05, 0xFC }, { 0x06, 0xF1 }, { 0x07, 0x13 }, { 0x08, 0x01 },
+	{ 0x09, 0x80 }, { 0x0A, 0x20 }, { 0x0B, 0x00 }, { 0x0C, 0x00 },
+	{ 0x12, 0x89 }, { 0x19, 0x8A }, { 0x1B, 0x28 }, { 0x1D, 0x20 },
+	{ 0x1E, 0x00 }, { 0x1F, 0x18 }, { 0x20, 0x05 }, { 0x21, 0x10 },
+	{ 0x22, 0x10 }, { 0x23, 0x00 }, { 0x24, 0x00 }, { 0x25, 0x05 },
+	{ 0x26, 0x05 }, { 0x27, 0x10 }, { 0x28, 0x20 }, { 0x29, 0x00 },
+	{ 0x2A, 0x20 }, { 0x2B, 0x00 }, { 0x2C, 0x00 }, { 0x2D, 0x20 },
+	{ 0x2F, 0x18 }, { 0x30, 0xC0 }, { 0x41, 0x11 }, { 0x60, 0xF0 },
+	{ 0x61, 0x8F }, { 0x62, 0x0C }, { 0x63, 0x00 }, { 0x64, 0x00 },
+	{ 0x65, 0x44 }, { 0x66, 0x3C }, { 0x67, 0x01 }, { 0x68, 0x00 },
+	{ 0x69, 0x00 }, { 0x6A, 0x10 }, { 0x6B, 0x00 }, { 0x6C, 0x10 },
+	{ 0x6D, 0x40 }, { 0x6E, 0x22 }, { 0x6F, 0x00 }, { 0x70, 0x01 },
+	{ 0x71, 0x60 }, { 0x72, 0xFF }, { 0x73, 0xFF }, { 0x74, 0xFF },
+	{ 0x7B, 0x08 }, { 0x7C, 0x00 }, { 0x7D, 0x0C }, { 0x7E, 0x00 },
+	{ 0x7F, 0xF8 }, { 0x80, 0xF8 }, { 0x81, 0x00 }, { 0x82, 0xF0 },
+	{ 0x83, 0xF0 }, { 0x84, 0xF0 }, { 0x85, 0xF0 }, { 0x86, 0xF0 },
+	{ 0x87, 0xF0 }, { 0x88, 0x00 }, { 0x89, 0x00 }, { 0x8A, 0x08 },
+	{ 0x8B, 0x00 }, { 0x8C, 0x02 }, { 0x8D, 0x00 }, { 0x99, 0x21 },
+	{ 0x9A, 0x3C }, { 0x9B, 0x01 }, { 0x9C, 0x2C }, { 0x9D, 0x00 },
+	{ 0x9E, 0x00 }, { 0x9F, 0x00 }, { 0xA0, 0x96 }, { 0xA1, 0xC0 },
+	{ 0xA2, 0x22 }, { 0xA3, 0x00 }, { 0xA4, 0x08 }, { 0xA5, 0x60 },
+	{ 0xA6, 0xFF }, { 0xA7, 0xFF }, { 0xA8, 0xFF }, { 0xA9, 0x00 },
+	{ 0xAF, 0x40 }, { 0xB0, 0x00 }, { 0xB1, 0x60 }, { 0xB2, 0x00 },
+	{ 0xB3, 0xD0 }, { 0xB4, 0x10 }, { 0xB5, 0x28 }, { 0xB6, 0xF0 },
+	{ 0xB7, 0xF6 }, { 0xB8, 0xFD }, { 0xB9, 0xDE }, { 0xBA, 0xFD },
+	{ 0xBB, 0xF0 }, { 0xBC, 0x00 }, { 0xBD, 0xFF }, { 0xBE, 0x01 },
+	{ 0xBF, 0x5E }, { 0xC0, 0x00 }, { 0xC1, 0x69 }, { 0xC2, 0xF0 },
+	{ 0xC3, 0x00 }, { 0xC4, 0x00 }, { 0xC5, 0x00 }, { 0x13, 0x3A },
+	{ 0x18, 0xF1 }, /* A ch : CS0, B ch : CS1 */
+	{ 0x1C, 0x18 }, { 0x35, 0x00 }, { 0x36, 0x00 }, { 0x3A, 0x0A },
+	{ 0x3B, 0x50 }, { 0x3C, 0x0A }, { 0x3D, 0x50 }, { 0x3E, 0x60 },
+	{ 0x94, 0x10 }, { 0x95, 0xA9 }, { 0x96, 0x11 }, { 0x2E, 0x14 },
+	{ 0x0E, 0xE0 }, { 0x0F, 0x1E }, { 0x10, 0xC0 }, { 0x11, 0xC1 },
+	{ 0xD0, 0xE0 }, { 0xD1, 0x08 }, { 0xD2, 0x00 }, { 0xD3, 0xFF },
+	{ 0xD4, 0xFF }, { 0xD5, 0x1E }, { 0xD6, 0x32 }, { 0xD7, 0xFF },
+	{ 0xD8, 0x20 }, { 0xD9, 0x70 }, { 0xDA, 0x7F }, { 0xDB, 0xE0 },
+	{ 0xDC, 0x00 }, { 0x76, 0x08 }, { 0x77, 0x00 }, { 0x79, 0x02 },
+	{ 0x7A, 0x00 }, { 0xAA, 0x36 }, { 0xAB, 0xB0 }, { 0xAD, 0x04 },
+	{ 0xAE, 0x00 },
+};
+
+struct isg5320a_data {
+	struct device *dev;
+	struct regmap *regmap;
+	struct gpio_desc *int_gpio;
+	int irq;
+	/* Serialises multi-register chip sequences and the cached sample. */
+	struct mutex lock;
+	/* Serialises event enable/disable (sleeps in disable_irq()). */
+	struct mutex ev_lock;
+	bool ev_enabled;
+	bool close;
+	u16 cdc;
+	u16 base;
+	u16 thresh;
+	u16 close_hyst;
+	u16 far_hyst;
+	u32 cfcal_th;
+};
+
+static bool isg5320a_writeable_reg(struct device *dev, unsigned int reg)
+{
+	unsigned int i;
+
+	switch (reg) {
+	case ISG5320A_REG_OSCCON:
+	case ISG5320A_REG_IRQFUNC:
+	case ISG5320A_REG_BS_ON_WD:
+	case ISG5320A_REG_SCANCTRL1:
+	case ISG5320A_REG_SCANCTRL2:
+	case ISG5320A_REG_PROTECT:
+	case ISG5320A_REG_SOFTRESET:
+		return true;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(isg5320a_setup_reg); i++)
+		if (isg5320a_setup_reg[i].addr == reg)
+			return true;
+
+	return false;
+}
+
+static bool isg5320a_precious_reg(struct device *dev, unsigned int reg)
+{
+	/* Reading IRQSRC acknowledges the interrupt; keep debugfs off it. */
+	return reg == ISG5320A_REG_IRQSRC;
+}
+
+static const struct regmap_config isg5320a_regmap_config = {
+	.reg_bits = 8,
+	.val_bits = 8,
+	.max_register = ISG5320A_MAX_REG,
+	.writeable_reg = isg5320a_writeable_reg,
+	.precious_reg = isg5320a_precious_reg,
+	.cache_type = REGCACHE_NONE,
+};
+
+/* Wait for the INT line to reach @level: up to 10 x 5 ms (vendor :262, :281). */
+static int isg5320a_wait_int(struct isg5320a_data *data, int level)
+{
+	int cnt;
+
+	if (!data->int_gpio) {
+		msleep(50);
+		return 0;
+	}
+
+	for (cnt = 0; cnt < 10; cnt++) {
+		if (gpiod_get_raw_value_cansleep(data->int_gpio) == level)
+			return cnt;
+		usleep_range(5000, 5100);
+	}
+
+	return -ETIMEDOUT;
+}
+
+/* vendor isg5320a_reset(), :247-292, plus a CHIPID read the vendor never does */
+static int isg5320a_reset(struct isg5320a_data *data)
+{
+	struct device *dev = data->dev;
+	unsigned int val;
+	int ret;
+
+	usleep_range(5000, 5100);				/* :255-256 */
+
+	ret = regmap_read(data->regmap, ISG5320A_REG_IRQSRC, &val);	/* :258 */
+	if (ret)
+		return dev_err_probe(dev, ret, "no response at IRQSRC\n");
+
+	ret = regmap_read(data->regmap, ISG5320A_REG_CHIPID, &val);
+	if (ret)
+		return dev_err_probe(dev, ret, "CHIPID read failed\n");
+	if (val == ISG5320A_VENDOR_CHIP_ID)
+		dev_info(dev, "CHIPID 0x%02x\n", val);
+	else
+		dev_warn(dev, "CHIPID 0x%02x (vendor header says 0x%02x; not enforced)\n",
+			 val, ISG5320A_VENDOR_CHIP_ID);
+
+	if (isg5320a_wait_int(data, 1) < 0)			/* :262-266 */
+		dev_warn(dev, "INT did not go high before reset\n");
+
+	ret = regmap_write(data->regmap, ISG5320A_REG_PROTECT,	/* :268-271 */
+			   ISG5320A_PROTECT_UNLOCK);
+	if (ret)
+		dev_warn(dev, "unlock protect failed: %d\n", ret);
+
+	ret = regmap_write(data->regmap, ISG5320A_REG_SOFTRESET,	/* :273-276 */
+			   ISG5320A_SOFTRESET_VAL);
+	if (ret)
+		dev_warn(dev, "soft reset write failed: %d\n", ret);
+
+	usleep_range(1000, 1100);				/* :278 */
+
+	ret = isg5320a_wait_int(data, 0);			/* :280-289 */
+	if (ret < 0)
+		return dev_err_probe(dev, -EIO, "INT not asserted after soft reset\n");
+	dev_dbg(dev, "reset done, wait cnt %d\n", ret);
+
+	return 0;
+}
+
+/* vendor isg5320a_initialize(), :614-660, without the /sdcard override */
+static int isg5320a_initialize(struct isg5320a_data *data)
+{
+	struct device *dev = data->dev;
+	unsigned int i, val, mismatch = 0;
+	u8 buf[6];
+	int ret;
+
+	guard(mutex)(&data->lock);
+
+	ret = regmap_read(data->regmap, ISG5320A_REG_IRQSRC, &val);	/* :625 */
+	if (ret)
+		return ret;
+	ret = regmap_write(data->regmap, ISG5320A_REG_SCANCTRL1,	/* :626 */
+			   ISG5320A_SCAN_STOP);
+	if (ret)
+		return ret;
+	msleep(30);						/* :627 */
+
+	for (i = 0; i < ARRAY_SIZE(isg5320a_setup_reg); i++) {	/* :631-637 */
+		const struct isg5320a_reg_data *r = &isg5320a_setup_reg[i];
+
+		ret = regmap_write(data->regmap, r->addr, r->val);
+		if (ret)
+			return dev_err_probe(dev, ret, "init write 0x%02x failed\n",
+					     r->addr);
+		ret = regmap_read(data->regmap, r->addr, &val);
+		if (ret)
+			return ret;
+		if (val != r->val) {
+			mismatch++;
+			dev_dbg(dev, "reg 0x%02x wrote 0x%02x read 0x%02x\n",
+				r->addr, r->val, val);
+		}
+	}
+	dev_info(dev, "init table: %zu writes, %u read back different\n",
+		 ARRAY_SIZE(isg5320a_setup_reg), mismatch);
+
+	/* :646-650 reads the threshold; :890-897 reads all six bytes */
+	ret = regmap_bulk_read(data->regmap, ISG5320A_REG_B_PROXCTL3, buf,
+			       sizeof(buf));
+	if (ret)
+		return ret;
+	data->thresh = (buf[0] << 8) | buf[1];
+	data->close_hyst = (buf[2] << 8) | buf[3];
+	data->far_hyst = (buf[4] << 8) | buf[5];
+
+	ret = regmap_read(data->regmap, ISG5320A_REG_DIGITAL_ACC, &val);	/* :653-657 */
+	if (ret)
+		return ret;
+	data->cfcal_th = ISG5320A_RESET_CONDITION * val / 8;
+
+	dev_info(dev, "threshold %u, close hyst %u, far hyst %u, cfcal_th %u\n",
+		 data->thresh, data->close_hyst, data->far_hyst, data->cfcal_th);
+
+	return 0;
+}
+
+/* vendor isg5320a_set_mode(SLEEP), :749-755 */
+static int isg5320a_mode_sleep(struct isg5320a_data *data)
+{
+	unsigned int val;
+	int ret;
+
+	guard(mutex)(&data->lock);
+
+	ret = regmap_read(data->regmap, ISG5320A_REG_IRQSRC, &val);
+	if (ret)
+		return ret;
+	ret = regmap_write(data->regmap, ISG5320A_REG_SCANCTRL1, ISG5320A_SCAN_STOP);
+	if (ret)
+		return ret;
+	ret = regmap_write(data->regmap, ISG5320A_REG_OSCCON, ISG5320A_OSC_SLEEP);
+	if (ret)
+		return ret;
+	return regmap_write(data->regmap, ISG5320A_REG_BS_ON_WD, ISG5320A_BS_WD_OFF);
+}
+
+/*
+ * vendor isg5320a_set_mode(NORMAL), :749 + :757-758, which runs
+ * isg5320a_force_calibration(data, false), :302-321.
+ */
+static int isg5320a_mode_normal(struct isg5320a_data *data)
+{
+	struct regmap *map = data->regmap;
+	unsigned int val;
+	int ret;
+
+	guard(mutex)(&data->lock);
+
+	ret = regmap_read(map, ISG5320A_REG_IRQSRC, &val);			/* :749 */
+	if (ret)
+		return ret;
+	ret = regmap_write(map, ISG5320A_REG_BS_ON_WD, ISG5320A_BS_WD_ON);	/* :757 */
+	if (ret)
+		return ret;
+
+	ret = regmap_write(map, ISG5320A_REG_SCANCTRL1, ISG5320A_SCAN_STOP);	/* :303 */
+	if (ret)
+		return ret;
+	msleep(30);								/* :305 */
+	ret = regmap_write(map, ISG5320A_REG_BS_ON_WD, ISG5320A_BS_WD_OFF);	/* :306 */
+	if (ret)
+		return ret;
+	ret = regmap_write(map, ISG5320A_REG_SCANCTRL2, ISG5320A_SCAN2_CLEAR);	/* :307 */
+	if (ret)
+		return ret;
+	msleep(100);								/* :309 */
+	ret = regmap_write(map, ISG5320A_REG_OSCCON, ISG5320A_OSC_NORMAL);	/* :310 */
+	if (ret)
+		return ret;
+	ret = regmap_write(map, ISG5320A_REG_BS_ON_WD, ISG5320A_BS_WD_ON);	/* :312 */
+	if (ret)
+		return ret;
+	ret = regmap_write(map, ISG5320A_REG_SCANCTRL2, ISG5320A_SCAN2_RESET);	/* :313 */
+	if (ret)
+		return ret;
+	ret = regmap_write(map, ISG5320A_REG_SCANCTRL1, ISG5320A_CFCAL_START);	/* :316 */
+	if (ret)
+		return ret;
+	msleep(500);								/* :318 */
+	ret = regmap_write(map, ISG5320A_REG_SCANCTRL2, ISG5320A_BFCAL_START);	/* :321 */
+	if (ret)
+		return ret;
+
+	/* The vendor sw_reset path waits 300 ms after BFCAL before reading (:850-852). */
+	msleep(300);
+
+	return 0;
+}
+
+/* vendor isg5320a_get_raw_data(), :445-466; caller holds data->lock */
+static int isg5320a_read_sample(struct isg5320a_data *data)
+{
+	u8 buf[4];
+	u16 v;
+	int ret;
+
+	lockdep_assert_held(&data->lock);
+
+	ret = regmap_bulk_read(data->regmap, ISG5320A_REG_CDC16_T_H, buf,
+			       sizeof(buf));
+	if (ret)
+		return ret;
+
+	/* 0x0000 and 0xFFFF are discarded and the last value kept (:459-464) */
+	v = (buf[0] << 8) | buf[1];
+	if (v != 0 && v != 0xFFFF)
+		data->cdc = v;
+	v = (buf[2] << 8) | buf[3];
+	if (v != 0 && v != 0xFFFF)
+		data->base = v;
+
+	return 0;
+}
+
+static int isg5320a_get_sample(struct isg5320a_data *data, u16 *cdc, u16 *base)
+{
+	struct device *dev = data->dev;
+	int ret;
+
+	ret = pm_runtime_resume_and_get(dev);
+	if (ret)
+		return ret;
+
+	scoped_guard(mutex, &data->lock) {
+		ret = isg5320a_read_sample(data);
+		*cdc = data->cdc;
+		*base = data->base;
+	}
+
+	pm_runtime_put_autosuspend(dev);
+
+	/*
+	 * The vendor cal_work (:1640-1647) force-recalibrates when cdc drops
+	 * below cfcal_th. That loop is not ported; only report the condition.
+	 */
+	if (!ret && *cdc < data->cfcal_th)
+		dev_warn_ratelimited(dev, "cdc %u below cfcal_th %u (vendor would recalibrate)\n",
+				     *cdc, data->cfcal_th);
+
+	return ret;
+}
+
+static irqreturn_t isg5320a_irq_thread(int irq, void *private)
+{
+	struct iio_dev *indio_dev = private;
+	struct isg5320a_data *data = iio_priv(indio_dev);
+	s64 timestamp = iio_get_time_ns(indio_dev);
+	unsigned int src, sts;
+	bool changed = false;
+	bool close = false;
+	int ret;
+
+	scoped_guard(mutex, &data->lock) {
+		isg5320a_read_sample(data);				/* :581 */
+
+		ret = regmap_read(data->regmap, ISG5320A_REG_IRQSRC, &src);	/* :583 */
+		if (ret)
+			break;
+		ret = regmap_read(data->regmap, ISG5320A_REG_IRQSTS, &sts);	/* :598 */
+		if (ret)
+			break;
+
+		close = sts & ISG5320A_IRQSTS_PROX;			/* :518 */
+		changed = close != data->close;
+		data->close = close;
+	}
+
+	if (ret) {
+		dev_err_ratelimited(data->dev, "irq status read failed: %d\n", ret);
+		return IRQ_HANDLED;
+	}
+
+	dev_dbg(data->dev, "irq src 0x%02x sts 0x%02x cdc %u base %u\n",
+		src, sts, data->cdc, data->base);
+
+	if (changed && READ_ONCE(data->ev_enabled)) {
+		enum iio_event_direction dir;
+
+		dir = close ? IIO_EV_DIR_RISING : IIO_EV_DIR_FALLING;
+		iio_push_event(indio_dev,
+			       IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
+						    IIO_EV_TYPE_THRESH, dir),
+			       timestamp);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int isg5320a_read_raw(struct iio_dev *indio_dev,
+			     const struct iio_chan_spec *chan,
+			     int *val, int *val2, long mask)
+{
+	struct isg5320a_data *data = iio_priv(indio_dev);
+	u16 cdc, base;
+	int ret;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		ret = isg5320a_get_sample(data, &cdc, &base);
+		if (ret)
+			return ret;
+		*val = (int)cdc - (int)base;				/* :465 */
+		return IIO_VAL_INT;
+	default:
+		return -EINVAL;
+	}
+}
+
+static int isg5320a_read_event_config(struct iio_dev *indio_dev,
+				      const struct iio_chan_spec *chan,
+				      enum iio_event_type type,
+				      enum iio_event_direction dir)
+{
+	struct isg5320a_data *data = iio_priv(indio_dev);
+
+	if (type != IIO_EV_TYPE_THRESH || dir != IIO_EV_DIR_EITHER)
+		return -EINVAL;
+
+	return READ_ONCE(data->ev_enabled);
+}
+
+/* vendor isg5320a_set_enable(), :681-742 (minus the work items) */
+static int isg5320a_events_on(struct isg5320a_data *data)
+{
+	struct device *dev = data->dev;
+	unsigned int val;
+	int ret;
+
+	ret = pm_runtime_resume_and_get(dev);
+	if (ret)
+		return ret;
+
+	scoped_guard(mutex, &data->lock) {
+		ret = regmap_read(data->regmap, ISG5320A_REG_IRQSTS, &val);	/* :700 */
+		if (ret)
+			break;
+		data->close = val & ISG5320A_IRQSTS_PROX;		/* :708-713 */
+		isg5320a_read_sample(data);				/* :704 */
+		ret = regmap_read(data->regmap, ISG5320A_REG_IRQSRC, &val);	/* :718 */
+		if (ret)
+			break;
+		ret = regmap_write(data->regmap, ISG5320A_REG_IRQFUNC,	/* :719 */
+				   ISG5320A_IRQFUNC_ENABLE);
+	}
+	if (ret) {
+		pm_runtime_put_autosuspend(dev);
+		return ret;
+	}
+
+	WRITE_ONCE(data->ev_enabled, true);
+	enable_irq(data->irq);						/* :721 */
+	if (device_may_wakeup(dev))
+		enable_irq_wake(data->irq);				/* :722 */
+
+	dev_dbg(dev, "events on, initial state %s\n", data->close ? "close" : "far");
+
+	return 0;
+}
+
+static void isg5320a_events_off(struct isg5320a_data *data)
+{
+	struct device *dev = data->dev;
+	int ret = 0;
+
+	scoped_guard(mutex, &data->lock)
+		ret = regmap_write(data->regmap, ISG5320A_REG_IRQFUNC,	/* :726 */
+				   ISG5320A_IRQFUNC_DISABLE);
+	if (ret)
+		dev_warn(dev, "IRQFUNC disable failed: %d\n", ret);
+
+	WRITE_ONCE(data->ev_enabled, false);
+	disable_irq(data->irq);						/* :728 */
+	if (device_may_wakeup(dev))
+		disable_irq_wake(data->irq);				/* :729 */
+}
+
+static int isg5320a_write_event_config(struct iio_dev *indio_dev,
+				       const struct iio_chan_spec *chan,
+				       enum iio_event_type type,
+				       enum iio_event_direction dir,
+				       bool state)
+{
+	struct isg5320a_data *data = iio_priv(indio_dev);
+
+	if (type != IIO_EV_TYPE_THRESH || dir != IIO_EV_DIR_EITHER)
+		return -EINVAL;
+
+	guard(mutex)(&data->ev_lock);
+
+	if (state == data->ev_enabled)
+		return 0;
+
+	if (state)
+		return isg5320a_events_on(data);
+
+	isg5320a_events_off(data);
+	pm_runtime_put_autosuspend(data->dev);
+
+	return 0;
+}
+
+static int isg5320a_read_event_value(struct iio_dev *indio_dev,
+				     const struct iio_chan_spec *chan,
+				     enum iio_event_type type,
+				     enum iio_event_direction dir,
+				     enum iio_event_info info,
+				     int *val, int *val2)
+{
+	struct isg5320a_data *data = iio_priv(indio_dev);
+
+	if (type != IIO_EV_TYPE_THRESH || info != IIO_EV_INFO_VALUE)
+		return -EINVAL;
+
+	/* vendor normal_threshold_show, :896-897 */
+	switch (dir) {
+	case IIO_EV_DIR_RISING:
+		*val = data->thresh + data->close_hyst;
+		return IIO_VAL_INT;
+	case IIO_EV_DIR_FALLING:
+		*val = (int)data->thresh - (int)data->far_hyst;
+		return IIO_VAL_INT;
+	default:
+		return -EINVAL;
+	}
+}
+
+static const struct iio_event_spec isg5320a_events[] = {
+	{
+		.type = IIO_EV_TYPE_THRESH,
+		.dir = IIO_EV_DIR_RISING,
+		.mask_separate = BIT(IIO_EV_INFO_VALUE),
+	},
+	{
+		.type = IIO_EV_TYPE_THRESH,
+		.dir = IIO_EV_DIR_FALLING,
+		.mask_separate = BIT(IIO_EV_INFO_VALUE),
+	},
+	{
+		/* One chip-level IRQ enable (IRQFUNC) covers both directions. */
+		.type = IIO_EV_TYPE_THRESH,
+		.dir = IIO_EV_DIR_EITHER,
+		.mask_separate = BIT(IIO_EV_INFO_ENABLE),
+	},
+};
+
+#define ISG5320A_CHANNEL(_events, _nevents)			\
+	{							\
+		.type = IIO_PROXIMITY,				\
+		.indexed = 1,					\
+		.channel = 0,					\
+		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),	\
+		.event_spec = _events,				\
+		.num_event_specs = _nevents,			\
+	}
+
+static const struct iio_chan_spec isg5320a_channels[] = {
+	ISG5320A_CHANNEL(isg5320a_events, ARRAY_SIZE(isg5320a_events)),
+};
+
+static const struct iio_chan_spec isg5320a_channels_noirq[] = {
+	ISG5320A_CHANNEL(NULL, 0),
+};
+
+static const struct iio_info isg5320a_info = {
+	.read_raw = isg5320a_read_raw,
+	.read_event_config = isg5320a_read_event_config,
+	.write_event_config = isg5320a_write_event_config,
+	.read_event_value = isg5320a_read_event_value,
+};
+
+static const struct iio_info isg5320a_info_noirq = {
+	.read_raw = isg5320a_read_raw,
+};
+
+/* vendor isg5320a_remove(), :2030-2033 */
+static void isg5320a_teardown(void *arg)
+{
+	struct isg5320a_data *data = arg;
+	struct device *dev = data->dev;
+
+	pm_runtime_disable(dev);
+
+	if (data->ev_enabled) {
+		isg5320a_events_off(data);
+		pm_runtime_put_noidle(dev);
+	}
+
+	if (!pm_runtime_status_suspended(dev))
+		isg5320a_mode_sleep(data);
+
+	pm_runtime_set_suspended(dev);
+	pm_runtime_dont_use_autosuspend(dev);
+}
+
+static int isg5320a_probe(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+	struct isg5320a_data *data;
+	struct iio_dev *indio_dev;
+	unsigned long irqflags;
+	int ret;
+
+	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
+	if (!indio_dev)
+		return -ENOMEM;
+
+	data = iio_priv(indio_dev);
+	data->dev = dev;
+	data->irq = client->irq;
+	i2c_set_clientdata(client, indio_dev);
+
+	ret = devm_mutex_init(dev, &data->lock);
+	if (ret)
+		return ret;
+	ret = devm_mutex_init(dev, &data->ev_lock);
+	if (ret)
+		return ret;
+
+	/* The vendor node has no supply; the board relies on an always-on LDO. */
+	ret = devm_regulator_get_enable_optional(dev, "vdd");
+	if (ret && ret != -ENODEV)
+		return dev_err_probe(dev, ret, "failed to enable vdd\n");
+	/*
+	 * If the rail was just switched on, give the chip time to come out
+	 * of power-on reset. The vendor never switches it, so this value
+	 * (10 ms) is a guess, not from the vendor source.
+	 */
+	if (!ret)
+		usleep_range(10000, 11000);
+
+	data->regmap = devm_regmap_init_i2c(client, &isg5320a_regmap_config);
+	if (IS_ERR(data->regmap))
+		return dev_err_probe(dev, PTR_ERR(data->regmap), "regmap init failed\n");
+
+	/*
+	 * Optional: lets the reset sequence watch the INT level as the vendor
+	 * does. It is requested before the IRQ (same order as vendor :1873 vs
+	 * :1931), since on Samsung pinctrl the IRQ request switches the pin
+	 * back to its EINT function.
+	 */
+	data->int_gpio = devm_gpiod_get_optional(dev, "int", GPIOD_IN);
+	if (IS_ERR(data->int_gpio))
+		return dev_err_probe(dev, PTR_ERR(data->int_gpio), "int gpio\n");
+	if (!data->int_gpio)
+		dev_info(dev, "no int-gpios, reset uses fixed delays\n");
+
+	ret = isg5320a_reset(data);				/* :1915 */
+	if (ret)
+		return ret;
+
+	msleep(300);			/* vendor runs init_work 300 ms later, :1981 */
+
+	ret = isg5320a_initialize(data);			/* :1620 */
+	if (ret)
+		return dev_err_probe(dev, ret, "init failed\n");
+
+	ret = isg5320a_mode_normal(data);			/* :1621 */
+	if (ret)
+		return dev_err_probe(dev, ret, "start failed\n");
+
+	if (data->irq > 0) {
+		irqflags = irq_get_trigger_type(data->irq);
+		if (!irqflags)
+			irqflags = IRQF_TRIGGER_FALLING;	/* :1932 */
+
+		ret = devm_request_threaded_irq(dev, data->irq, NULL,
+						isg5320a_irq_thread,
+						irqflags | IRQF_ONESHOT |
+						IRQF_NO_AUTOEN,
+						"isg5320a", indio_dev);
+		if (ret)
+			return dev_err_probe(dev, ret, "irq request failed\n");
+
+		if (device_property_read_bool(dev, "wakeup-source"))
+			device_init_wakeup(dev, true);
+	}
+
+	pm_runtime_set_autosuspend_delay(dev, ISG5320A_AUTOSUSPEND_MS);
+	pm_runtime_use_autosuspend(dev);
+	pm_runtime_set_active(dev);
+	pm_runtime_get_noresume(dev);
+	pm_runtime_enable(dev);
+	pm_runtime_put_autosuspend(dev);
+
+	ret = devm_add_action_or_reset(dev, isg5320a_teardown, data);
+	if (ret)
+		return ret;
+
+	indio_dev->name = "isg5320a";
+	indio_dev->modes = INDIO_DIRECT_MODE;
+	if (data->irq > 0) {
+		indio_dev->info = &isg5320a_info;
+		indio_dev->channels = isg5320a_channels;
+		indio_dev->num_channels = ARRAY_SIZE(isg5320a_channels);
+	} else {
+		indio_dev->info = &isg5320a_info_noirq;
+		indio_dev->channels = isg5320a_channels_noirq;
+		indio_dev->num_channels = ARRAY_SIZE(isg5320a_channels_noirq);
+	}
+
+	return devm_iio_device_register(dev, indio_dev);
+}
+
+/* vendor isg5320a_shutdown(), :2071-2080 */
+static void isg5320a_shutdown(struct i2c_client *client)
+{
+	struct isg5320a_data *data = iio_priv(i2c_get_clientdata(client));
+
+	guard(mutex)(&data->ev_lock);
+
+	if (data->ev_enabled)
+		regmap_write(data->regmap, ISG5320A_REG_IRQFUNC,
+			     ISG5320A_IRQFUNC_DISABLE);
+	isg5320a_mode_sleep(data);
+}
+
+static int isg5320a_runtime_suspend(struct device *dev)
+{
+	struct isg5320a_data *data = iio_priv(dev_get_drvdata(dev));
+
+	return isg5320a_mode_sleep(data);
+}
+
+static int isg5320a_runtime_resume(struct device *dev)
+{
+	struct isg5320a_data *data = iio_priv(dev_get_drvdata(dev));
+
+	return isg5320a_mode_normal(data);
+}
+
+/*
+ * Runtime PM only. System sleep leaves the chip as it is, as the vendor
+ * does (its suspend/resume only stop and restart the work items), so an
+ * enabled grip event can still wake the system.
+ */
+static const struct dev_pm_ops isg5320a_pm_ops = {
+	RUNTIME_PM_OPS(isg5320a_runtime_suspend, isg5320a_runtime_resume, NULL)
+};
+
+static const struct of_device_id isg5320a_of_match[] = {
+	{ .compatible = "imagis,isg5320a" },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, isg5320a_of_match);
+
+static const struct i2c_device_id isg5320a_id[] = {
+	{ "isg5320a" },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, isg5320a_id);
+
+static struct i2c_driver isg5320a_driver = {
+	.driver = {
+		.name = "isg5320a",
+		.of_match_table = isg5320a_of_match,
+		.pm = pm_ptr(&isg5320a_pm_ops),
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
+	},
+	.probe = isg5320a_probe,
+	.shutdown = isg5320a_shutdown,
+	.id_table = isg5320a_id,
+};
+module_i2c_driver(isg5320a_driver);
+
+MODULE_AUTHOR("Adil Hüsrev Tepe <tadilhusrev@gmail.com>");
+MODULE_DESCRIPTION("Imagis ISG5320A capacitive grip sensor");
+MODULE_LICENSE("GPL");
-- 
2.53.0


  parent reply	other threads:[~2026-11-16  7:40 UTC|newest]

Thread overview: 16+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-16  7:40 [PATCH v1 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5) Adil Hüsrev Tepe
2026-11-16  7:40 ` [PATCH v1 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A Adil Hüsrev Tepe
2026-11-16  7:51   ` sashiko-bot
2026-11-16  7:40 ` Adil Hüsrev Tepe [this message]
2026-11-16  7:58   ` [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver sashiko-bot
2026-11-16 10:53   ` Andy Shevchenko
2026-11-16 10:48 ` [PATCH v1 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5) Andy Shevchenko
2026-11-17 10:44 ` [PATCH v2 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A Adil Hüsrev Tepe
2026-11-17 10:44   ` [PATCH v2 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe
2026-11-17 11:08     ` sashiko-bot
2026-11-17 13:56     ` Andy Shevchenko
2026-11-17 10:54   ` [PATCH v2 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A sashiko-bot
2026-11-17 17:33 ` [PATCH v3 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5) Adil Hüsrev Tepe
2026-11-17 17:33   ` [PATCH v3 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A Adil Hüsrev Tepe
2026-11-17 17:33   ` [PATCH v3 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe
2026-11-17 17:55     ` sashiko-bot

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261116074013.355363-3-tadilhusrev@gmail.com \
    --to=tadilhusrev@gmail.com \
    --cc=andy@kernel.org \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=dlechner@baylibre.com \
    --cc=jic23@kernel.org \
    --cc=krzk+dt@kernel.org \
    --cc=linux-iio@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=nuno.sa@analog.com \
    --cc=robh@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.