* [PATCH v1 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5)
@ 2026-11-16 7:40 Adil Hüsrev Tepe
2026-11-16 7:40 ` [PATCH v1 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A Adil Hüsrev Tepe
` (3 more replies)
0 siblings, 4 replies; 8+ messages in thread
From: Adil Hüsrev Tepe @ 2026-11-16 7:40 UTC (permalink / raw)
To: Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley
Cc: David Lechner, Nuno Sá,
Andy Shevchenko, linux-iio, devicetree, linux-kernel,
Adil Hüsrev Tepe
This series adds an IIO driver and its binding for the Imagis ISG5320A
capacitive SAR/grip proximity sensor, as fitted on the Samsung Galaxy
XCover5 (Exynos850).
1 dt-bindings: add imagis,isg5320a
2 the IIO proximity driver
The driver exposes one IIO_PROXIMITY channel (the B-channel signal minus
its baseline) and a rising/falling threshold event. Tested on an XCover5:
it probes, registers the IIO device and reads a stable baseline value.
Based on v7.4-rc1.
Tool usage
----------
Derived from the Samsung vendor driver during XCover5 mainline bring-up
with an AI coding assistant (Claude Code, Anthropic), which drafted the
mainline IIO driver and the binding. I reviewed every line and tested
probe and read-back on hardware. Review comments are welcome and I will
answer them myself.
Adil Hüsrev Tepe (2):
dt-bindings: iio: proximity: add Imagis ISG5320A
iio: proximity: add Imagis ISG5320A SAR sensor driver
.../iio/proximity/imagis,isg5320a.yaml | 56 ++
drivers/iio/proximity/Kconfig | 11 +
drivers/iio/proximity/Makefile | 1 +
drivers/iio/proximity/isg5320a.c | 857 ++++++++++++++++++
4 files changed, 925 insertions(+)
create mode 100644 Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml
create mode 100644 drivers/iio/proximity/isg5320a.c
--
2.53.0
^ permalink raw reply [flat|nested] 8+ messages in thread* [PATCH v1 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A 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 ` Adil Hüsrev Tepe 2026-11-16 7:40 ` [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe ` (2 subsequent siblings) 3 siblings, 0 replies; 8+ messages in thread From: Adil Hüsrev Tepe @ 2026-11-16 7:40 UTC (permalink / raw) To: Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley Cc: David Lechner, Nuno Sá, Andy Shevchenko, linux-iio, devicetree, linux-kernel, Adil Hüsrev Tepe Add a binding for the Imagis ISG5320A capacitive SAR/grip proximity sensor (I2C), as fitted on the Samsung Galaxy XCover5. The binding was drafted during XCover5 mainline bring-up with the help of an AI coding assistant (Claude Code, Anthropic) and reviewed and validated (dt_binding_check, yamllint) by me. Signed-off-by: Adil Hüsrev Tepe <tadilhusrev@gmail.com> --- .../iio/proximity/imagis,isg5320a.yaml | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml diff --git a/Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml b/Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml new file mode 100644 index 000000000..b23d6bafd --- /dev/null +++ b/Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml @@ -0,0 +1,56 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/proximity/imagis,isg5320a.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Imagis ISG5320A SAR proximity (grip) sensor + +maintainers: + - Adil Hüsrev Tepe <tadilhusrev@gmail.com> + +description: + Imagis ISG5320A capacitive SAR/grip sensor (I2C), exposed as one IIO + proximity channel (B-channel diff = CDC16_T - BSL16_B). As fitted on the + Samsung Galaxy XCover5. + +properties: + compatible: + const: imagis,isg5320a + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + description: active-low data-ready / proximity interrupt + + vdd-supply: + description: sensor supply + + wakeup-source: true + +required: + - compatible + - reg + - interrupts + +additionalProperties: false + +examples: + - | + #include <dt-bindings/gpio/gpio.h> + #include <dt-bindings/interrupt-controller/irq.h> + i2c { + #address-cells = <1>; + #size-cells = <0>; + grip@28 { + compatible = "imagis,isg5320a"; + reg = <0x28>; + interrupt-parent = <&gpa2>; + interrupts = <0 IRQ_TYPE_LEVEL_LOW>; + vdd-supply = <&grip_vdd>; + wakeup-source; + }; + }; +... -- 2.53.0 ^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver 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:40 ` Adil Hüsrev Tepe 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 3 siblings, 1 reply; 8+ messages in thread From: Adil Hüsrev Tepe @ 2026-11-16 7:40 UTC (permalink / raw) To: Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley Cc: David Lechner, Nuno Sá, Andy Shevchenko, linux-iio, devicetree, linux-kernel, Adil Hüsrev Tepe 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 ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver 2026-11-16 7:40 ` [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe @ 2026-11-16 10:53 ` Andy Shevchenko 0 siblings, 0 replies; 8+ messages in thread From: Andy Shevchenko @ 2026-11-16 10:53 UTC (permalink / raw) To: Adil Hüsrev Tepe Cc: Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, David Lechner, Nuno Sá, Andy Shevchenko, linux-iio, devicetree, linux-kernel On Mon, Nov 16, 2026 at 10:40:13AM +0300, Adil Hüsrev Tepe wrote: > 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. ... > +config ISG5320A > + tristate "Imagis ISG5320A SAR proximity sensor" Make sure this, top level comment and MODULE_DESCRIPTION() have the same or quite similar text. > + 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. ... > +#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> Definitely no. Also, please follow IWYU principle. > +#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> ... Also, take in use *ACQUIRE*() macros, in particular for runtime PM where it makes sense. ... I stopped here. You can now go via mailing list archive (linux-iio@) and check what are the usual comments against new drier. You have many small things to improve, I believe. -- With Best Regards, Andy Shevchenko ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH v1 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5) 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:40 ` [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe @ 2026-11-16 10:48 ` Andy Shevchenko 2026-11-17 10:44 ` [PATCH v2 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A Adil Hüsrev Tepe 3 siblings, 0 replies; 8+ messages in thread From: Andy Shevchenko @ 2026-11-16 10:48 UTC (permalink / raw) To: Adil Hüsrev Tepe Cc: Jonathan Cameron, Rob Herring, Krzysztof Kozlowski, Conor Dooley, David Lechner, Nuno Sá, Andy Shevchenko, linux-iio, devicetree, linux-kernel On Mon, Nov 16, 2026 at 10:40:11AM +0300, Adil Hüsrev Tepe wrote: > This series adds an IIO driver and its binding for the Imagis ISG5320A > capacitive SAR/grip proximity sensor, as fitted on the Samsung Galaxy > XCover5 (Exynos850). > > 1 dt-bindings: add imagis,isg5320a > 2 the IIO proximity driver > > The driver exposes one IIO_PROXIMITY channel (the B-channel signal minus > its baseline) and a rising/falling threshold event. Tested on an XCover5: > it probes, registers the IIO device and reads a stable baseline value. > > Based on v7.4-rc1. > > Tool usage > ---------- > Derived from the Samsung vendor driver during XCover5 mainline bring-up > with an AI coding assistant (Claude Code, Anthropic), which drafted the > mainline IIO driver and the binding. I reviewed every line and tested > probe and read-back on hardware. Review comments are welcome and I will > answer them myself. Why a brand new driver? -- With Best Regards, Andy Shevchenko ^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH v2 1/2] dt-bindings: iio: proximity: add Imagis ISG5320A 2026-11-16 7:40 [PATCH v1 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5) Adil Hüsrev Tepe ` (2 preceding siblings ...) 2026-11-16 10:48 ` [PATCH v1 0/2] iio: proximity: add Imagis ISG5320A (Samsung Galaxy XCover5) Andy Shevchenko @ 2026-11-17 10:44 ` 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 3 siblings, 1 reply; 8+ messages in thread From: Adil Hüsrev Tepe @ 2026-11-17 10:44 UTC (permalink / raw) To: jic23, robh, krzk+dt, conor+dt Cc: dlechner, nuno.sa, andy, linux-iio, devicetree, linux-kernel, Adil Hüsrev Tepe Add a binding for the Imagis ISG5320A capacitive SAR/grip proximity sensor (I2C), as fitted on the Samsung Galaxy XCover5. v1 -> v2 (addressing Sashiko AI's review of v1, https://sashiko.dev/#/patchset/20261116074013.355363-1-tadilhusrev@gmail.com?part=1): - Document int-gpios: the driver optionally reads it during the reset sequence; it was undocumented in v1. - Reword the description to the chip's own characteristics instead of how the Linux IIO channel is exposed. - Simplify vdd-supply to "vdd-supply: true" (left optional: the XCover5's own grip sensor has no vdd-supply node at all, an always-on LDO not modeled in DT, which the driver's devm_regulator_get_enable_optional() already tolerates). - Rename the example node to "proximity@28", drop the unused gpio.h include, and add the blank line dt-check-style wants before the child node. The binding was drafted during XCover5 mainline bring-up with the help of an AI coding assistant (Claude Code, Anthropic) and reviewed and validated (dt_binding_check, yamllint) by me. Signed-off-by: Adil Hüsrev Tepe <tadilhusrev@gmail.com> --- .../iio/proximity/imagis,isg5320a.yaml | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml diff --git a/Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml b/Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml new file mode 100644 index 000000000..ccb84b29f --- /dev/null +++ b/Documentation/devicetree/bindings/iio/proximity/imagis,isg5320a.yaml @@ -0,0 +1,62 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/proximity/imagis,isg5320a.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Imagis ISG5320A SAR proximity (grip) sensor + +maintainers: + - Adil Hüsrev Tepe <tadilhusrev@gmail.com> + +description: + Imagis ISG5320A capacitive SAR/grip proximity sensor, connected over I2C. + As fitted on the Samsung Galaxy XCover5. + +properties: + compatible: + const: imagis,isg5320a + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + description: active-low data-ready / proximity interrupt + + int-gpios: + maxItems: 1 + description: + GPIO connected to the same INT line as the "interrupts" property. When + present it is polled during the reset sequence to observe the INT level, + as the vendor driver does; otherwise the reset falls back to fixed delays. + + vdd-supply: true + + wakeup-source: true + +required: + - compatible + - reg + - interrupts + +additionalProperties: false + +examples: + - | + #include <dt-bindings/interrupt-controller/irq.h> + + i2c { + #address-cells = <1>; + #size-cells = <0>; + + proximity@28 { + compatible = "imagis,isg5320a"; + reg = <0x28>; + interrupt-parent = <&gpa2>; + interrupts = <0 IRQ_TYPE_LEVEL_LOW>; + vdd-supply = <&grip_vdd>; + wakeup-source; + }; + }; +... -- 2.53.0 ^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH v2 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver 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 ` Adil Hüsrev Tepe 2026-11-17 13:56 ` Andy Shevchenko 0 siblings, 1 reply; 8+ messages in thread From: Adil Hüsrev Tepe @ 2026-11-17 10:44 UTC (permalink / raw) To: jic23, robh, krzk+dt, conor+dt Cc: dlechner, nuno.sa, andy, linux-iio, devicetree, linux-kernel, Adil Hüsrev Tepe 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. v1 -> v2 (addressing Andy Shevchenko's and Sashiko AI's review of v1, https://sashiko.dev/#/patchset/20261116074013.355363-1-tadilhusrev@gmail.com?part=2): - Drop the unused #include <linux/kernel.h>; audit includes for the IWYU principle (array_size.h, cleanup.h, errno.h, types.h for symbols actually used). - Use ACQUIRE(pm_runtime_active_auto_try_enabled)/ACQUIRE_ERR() in isg5320a_get_sample() instead of open-coded pm_runtime_resume_and_get()/pm_runtime_put_autosuspend(). - Make the Kconfig prompt, this file's top comment, and MODULE_DESCRIPTION() use the same wording. - Propagate the PROTECT-unlock write failure in isg5320a_reset() instead of only warning (matches the existing SOFTRESET handling). - isg5320a_wait_int() now reads the INT gpio with gpiod_get_value_cansleep() (logical, polarity-aware) instead of _raw_, and returns a real error instead of looping to -ETIMEDOUT on a failed read. - Cache device_may_wakeup() at isg5320a_events_on() time (irq_wake_enabled) and use that cached value in isg5320a_events_off(), instead of re-checking device_may_wakeup() at disable time: toggling /sys/.../power/wakeup between enable and disable no longer produces an unbalanced enable_irq_wake()/disable_irq_wake() pair. - isg5320a_shutdown() now calls isg5320a_events_off() (disables the IRQ and takes data->lock around the IRQFUNC write) instead of writing IRQFUNC unlocked with the IRQ still enabled, and only calls isg5320a_mode_sleep() when the device isn't already runtime-suspended. - Register the isg5320a_teardown() devres action right after isg5320a_mode_normal() succeeds instead of after the IRQ request, so a later probe failure (e.g. devm_request_threaded_irq()) still puts the chip back to sleep instead of leaving it scanning unbound. - Use a named initializer in isg5320a_id[]. 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, built it (arm64, 0 warnings), ran checkpatch --strict (clean), and tested it live on a Samsung Galaxy XCover5 (2026-11-17): the driver binds and registers as iio:device4 "isg5320a", with a live in_proximity0_raw read-back. 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 | 880 +++++++++++++++++++++++++++++++ 3 files changed, 892 insertions(+) create mode 100644 drivers/iio/proximity/isg5320a.c diff --git a/drivers/iio/proximity/Kconfig b/drivers/iio/proximity/Kconfig index bb77fad2a..311a7b9e4 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 capacitive SAR/grip sensor" + depends on I2C + select REGMAP_I2C + help + Say Y here to build a driver for the Imagis ISG5320A capacitive + SAR/grip 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..baa8d07ec --- /dev/null +++ b/drivers/iio/proximity/isg5320a.c @@ -0,0 +1,880 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Imagis ISG5320A capacitive SAR/grip 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/array_size.h> +#include <linux/bits.h> +#include <linux/cleanup.h> +#include <linux/delay.h> +#include <linux/device.h> +#include <linux/errno.h> +#include <linux/gpio/consumer.h> +#include <linux/i2c.h> +#include <linux/interrupt.h> +#include <linux/irq.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/types.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 irq_wake_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, val; + + if (!data->int_gpio) { + msleep(50); + return 0; + } + + for (cnt = 0; cnt < 10; cnt++) { + /* Logical, not raw: honours the GPIO's DT polarity. */ + val = gpiod_get_value_cansleep(data->int_gpio); + if (val < 0) + return val; + if (val == 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) + return dev_err_probe(dev, ret, "unlock protect failed\n"); + + ret = regmap_write(data->regmap, ISG5320A_REG_SOFTRESET, /* :273-276 */ + ISG5320A_SOFTRESET_VAL); + if (ret) + return dev_err_probe(dev, ret, "soft reset write failed\n"); + + 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; + + ACQUIRE(pm_runtime_active_auto_try_enabled, pm)(dev); + ret = ACQUIRE_ERR(pm_runtime_active_auto_try_enabled, &pm); + if (ret < 0) + return ret; + + scoped_guard(mutex, &data->lock) { + ret = isg5320a_read_sample(data); + *cdc = data->cdc; + *base = data->base; + } + if (ret) + return ret; + + /* + * The vendor cal_work (:1640-1647) force-recalibrates when cdc drops + * below cfcal_th. That loop is not ported; only report the condition. + */ + if (*cdc < data->cfcal_th) + dev_warn_ratelimited(dev, "cdc %u below cfcal_th %u (vendor would recalibrate)\n", + *cdc, data->cfcal_th); + + return 0; +} + +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 */ + /* Cache the decision: device_may_wakeup(dev) may change before events_off(). */ + data->irq_wake_enabled = device_may_wakeup(dev); + if (data->irq_wake_enabled) + 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 (data->irq_wake_enabled) { + disable_irq_wake(data->irq); /* :729 */ + data->irq_wake_enabled = false; + } +} + +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"); + + /* + * Registered now, with the chip already active, so that a later + * failure (e.g. the IRQ request below) still puts it back to sleep + * instead of leaving it scanning with nothing bound to it. + */ + 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; + + 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); + } + + 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, synchronized like isg5320a_teardown() */ +static void isg5320a_shutdown(struct i2c_client *client) +{ + struct isg5320a_data *data = iio_priv(i2c_get_clientdata(client)); + struct device *dev = data->dev; + + guard(mutex)(&data->ev_lock); + + if (data->ev_enabled) { + isg5320a_events_off(data); + pm_runtime_put_noidle(dev); + } + + if (!pm_runtime_status_suspended(dev)) + 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[] = { + { .name = "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 SAR/grip sensor"); +MODULE_LICENSE("GPL"); + -- 2.53.0 ^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH v2 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver 2026-11-17 10:44 ` [PATCH v2 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe @ 2026-11-17 13:56 ` Andy Shevchenko 0 siblings, 0 replies; 8+ messages in thread From: Andy Shevchenko @ 2026-11-17 13:56 UTC (permalink / raw) To: Adil Hüsrev Tepe Cc: jic23, robh, krzk+dt, conor+dt, dlechner, nuno.sa, andy, linux-iio, devicetree, linux-kernel On Tue, Nov 17, 2026 at 01:44:14PM +0300, Adil Hüsrev Tepe wrote: > 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. > v1 -> v2 (addressing Andy Shevchenko's and Sashiko AI's review of v1, > https://sashiko.dev/#/patchset/20261116074013.355363-1-tadilhusrev@gmail.com?part=2): > - Drop the unused #include <linux/kernel.h>; audit includes for the > IWYU principle (array_size.h, cleanup.h, errno.h, types.h for > symbols actually used). > - Use ACQUIRE(pm_runtime_active_auto_try_enabled)/ACQUIRE_ERR() in > isg5320a_get_sample() instead of open-coded > pm_runtime_resume_and_get()/pm_runtime_put_autosuspend(). > - Make the Kconfig prompt, this file's top comment, and > MODULE_DESCRIPTION() use the same wording. > - Propagate the PROTECT-unlock write failure in isg5320a_reset() > instead of only warning (matches the existing SOFTRESET handling). > - isg5320a_wait_int() now reads the INT gpio with > gpiod_get_value_cansleep() (logical, polarity-aware) instead of > _raw_, and returns a real error instead of looping to -ETIMEDOUT on > a failed read. > - Cache device_may_wakeup() at isg5320a_events_on() time > (irq_wake_enabled) and use that cached value in > isg5320a_events_off(), instead of re-checking device_may_wakeup() at > disable time: toggling /sys/.../power/wakeup between enable and > disable no longer produces an unbalanced > enable_irq_wake()/disable_irq_wake() pair. > - isg5320a_shutdown() now calls isg5320a_events_off() (disables the > IRQ and takes data->lock around the IRQFUNC write) instead of > writing IRQFUNC unlocked with the IRQ still enabled, and only calls > isg5320a_mode_sleep() when the device isn't already > runtime-suspended. > - Register the isg5320a_teardown() devres action right after > isg5320a_mode_normal() succeeds instead of after the IRQ request, so > a later probe failure (e.g. devm_request_threaded_irq()) still puts > the chip back to sleep instead of leaving it scanning unbound. > - Use a named initializer in isg5320a_id[]. Changelog should be in the comment block, after the '---' line below. > 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, built it (arm64, 0 warnings), ran checkpatch --strict (clean), > and tested it live on a Samsung Galaxy XCover5 (2026-11-17): the driver > binds and registers as iio:device4 "isg5320a", with a live > in_proximity0_raw read-back. This paragraph has to be in the cover letter and not here. ... > +#include <linux/array_size.h> > +#include <linux/bits.h> > +#include <linux/cleanup.h> > +#include <linux/delay.h> > +#include <linux/device.h> > +#include <linux/errno.h> > +#include <linux/gpio/consumer.h> > +#include <linux/i2c.h> > +#include <linux/interrupt.h> > +#include <linux/irq.h> > +#include <linux/mod_devicetable.h> Nope. This should not be included in a new code. > +#include <linux/module.h> > +#include <linux/mutex.h> > +#include <linux/pm.h> > +#include <linux/pm_runtime.h> > +#include <linux/pm_wakeup.h> Have you read what's written in the top of that file? Please, drop it here. > +#include <linux/property.h> > +#include <linux/regmap.h> > +#include <linux/regulator/consumer.h> > +#include <linux/types.h> > + > +#include <linux/iio/events.h> > +#include <linux/iio/iio.h> ... > +#define ISG5320A_RESET_CONDITION 5000 /* reg.h :99, for cfcal_th */ This is a cryptic comment. Either drop it, or better to explain on top of the definition. ... > +#define ISG5320A_AUTOSUSPEND_MS 5000 (5 * MSEC_PER_SEC) will require time.h to be included. ... > +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; One of the above is redundant. > + 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 irq_wake_enabled; > + bool close; If they are protected by the same lock or have no clashes, use bool XXX:1; to pack all of them into a single boolean. Move them to the end, so there will be a chance to reduce a gap. Check with `pahole`. > + u16 cdc; > + u16 base; > + u16 thresh; > + u16 close_hyst; > + u16 far_hyst; > + u32 cfcal_th; Move it upper, before u16 ones. > +}; ... > +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, Why?! This has to be justified in the comment above. > +}; ... > +/* 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, val; > + > + if (!data->int_gpio) { > + msleep(50); All sleeps has to be explained. > + return 0; > + } > + > + for (cnt = 0; cnt < 10; cnt++) { > + /* Logical, not raw: honours the GPIO's DT polarity. */ > + val = gpiod_get_value_cansleep(data->int_gpio); > + if (val < 0) > + return val; > + if (val == level) > + return cnt; > + usleep_range(5000, 5100); > + } In iopoll.h you may find readx_poll_timeout(). > + return -ETIMEDOUT; > +} ... > +static int isg5320a_reset(struct isg5320a_data *data) > +{ > + struct device *dev = data->dev; > + unsigned int val; > + int ret; > + > + usleep_range(5000, 5100); /* :255-256 */ Why?! Also use fsleep(5 * USEC_PER_MSEC). > + 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); Useless. > + 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) > + return dev_err_probe(dev, ret, "unlock protect failed\n"); > + > + ret = regmap_write(data->regmap, ISG5320A_REG_SOFTRESET, /* :273-276 */ > + ISG5320A_SOFTRESET_VAL); > + if (ret) > + return dev_err_probe(dev, ret, "soft reset write failed\n"); > + usleep_range(1000, 1100); /* :278 */ fsleep (1 * USEC_PER_MSEC) and why? > + 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 */ Do all this needs to be under the mutex? > + 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); Don't we have something like reg_defaults_raw field and the respective struct reg_default? > + 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]; We have get_unaligned_?eXX(), we have ?eXX_to_cpu() and cpu_to_?eXX(), use them. > + 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; > +} ... > + /* > + * Registered now, with the chip already active, so that a later > + * failure (e.g. the IRQ request below) still puts it back to sleep > + * instead of leaving it scanning with nothing bound to it. > + */ > + 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; Do you understand how it works? Why don't you use devn_pm_runtime*() calls? ... > + if (data->irq > 0) { > + irqflags = irq_get_trigger_type(data->irq); > + if (!irqflags) > + irqflags = IRQF_TRIGGER_FALLING; /* :1932 */ Why?! It's a new driver, let the firmware to describe thing properly (and you never know if there is a NOT gate in the middle which make the default working in a wrong way (and on top, but I haven't checked this, the shared interrupt case if supported by HW). > + 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"); Read mailing list and IIO Git history to understand what's wrong here. > + > + if (device_property_read_bool(dev, "wakeup-source")) > + device_init_wakeup(dev, true); > + } ... Overall impression, that this driver was written without enough understanding on what's going on. Take your time, check datasheet and corner cases, test them on real HW, et cetera. -- With Best Regards, Andy Shevchenko ^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2026-11-17 13:56 UTC | newest] Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 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:40 ` [PATCH v1 2/2] iio: proximity: add Imagis ISG5320A SAR sensor driver Adil Hüsrev Tepe 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 13:56 ` Andy Shevchenko
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®