From nobody Fri Dec 19 14:36:13 2025 Received: from mail-pl1-f172.google.com (mail-pl1-f172.google.com [209.85.214.172]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0091B342CBD for ; Wed, 5 Nov 2025 20:14:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762373657; cv=none; b=CUoeA8D/ZNhdNpl2h0s9bI8lBYNpSVcs23Li7IfP7wuXs+tzRaN1R5x8A0qDh2ABbNxpAnWrWU71xzMafdpGPdZuWMZU8c0HNJnhgvTAVUt+QmEQ0HpaY1KKrBWJSOUH8CBIrIwRCctZnI2PW7URPQtYjDCp4QY2W8tRRnEl8aI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762373657; c=relaxed/simple; bh=Ykvay+KbmIz4mfBpsW6reUfGaWR/oBY1ov+y0XO0Gi4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Jszrb2doopBr2oRykdVCOG138SNVUXiRscsyGCMZR6No/Bf1nbxEJZENshf2nuktxAlJCS3Ia2dewJNsV/qbT/NDYveCqLzgCjCC+WQSz5tc2HhpcZjh1UYT/gQ8tQpZlGco/2Dap8TEX5wBOd2cmjIXuSbbix77If/I/08cWE0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=reznichenko.net; spf=none smtp.mailfrom=dpplabs.com; dkim=pass (2048-bit key) header.d=reznichenko.net header.i=@reznichenko.net header.b=anF113TB; arc=none smtp.client-ip=209.85.214.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=reznichenko.net Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=dpplabs.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=reznichenko.net header.i=@reznichenko.net header.b="anF113TB" Received: by mail-pl1-f172.google.com with SMTP id d9443c01a7336-29558061c68so3014385ad.0 for ; Wed, 05 Nov 2025 12:14:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=reznichenko.net; s=google; t=1762373655; x=1762978455; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=M5UUjWOJCMb12I/BWzOWhp+eaG/l4rBJ5tx7KBsTma4=; b=anF113TBFdGCwBVy4exG+TjYZ8rzr6yppxd3TG4JUruavX8aRpZ5242FhEBoqvf9eQ iGRYFsr2GH9kpaZ1sCVXbQ1tZ/J8PBcpnjqN288VE7MxZY9J+ObQRdbBEjyj0E5rlZjx +YUtHGeTfnBNifJ3br6/rTX4suogwBQwF9YCMwRJc05La/D0un4fR42+XlbejBslkXm0 CDxch6lWoPqKR7rpS5HyZmtwAOVAhGoBIvy66bJYdIGCW6gz3YUvIcpCCTPyvfNPh0ZC Hyg5Ge6AYsgTL9UWDwBvhkt0DDuXi1Aee+dqlfXqh1bPOsGjvo6eanPsCYc+F1q0i48o QOCw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762373655; x=1762978455; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=M5UUjWOJCMb12I/BWzOWhp+eaG/l4rBJ5tx7KBsTma4=; b=ZxHx5Nl1Vt5I+3+b29NZk63kX8/9lP03urp2pOKelWtEmW1r49HIaLDTlqOKnGMQMU Y4lJuF4uSFK7zF5sipjlHD9sUZI4A3qzbr4XpsSITCZUmYan7BG8rZG2G0YPWwnQlp2s Bnvjx5Ryvj6DPlELaVO+1uAT/6gT4Nyt+AkmKCTgSLdr1tgyAxTMvMmz79NA5bX00Ur3 I4Qyo1uEoK1xFvGX4Wzsnuzabpf1M/N6UqXpBfQy4FwCJYhQaq7m1LQLKLZNIane/0vz cQojw7aIFt7QzPwHGn2RKkDmV/UWsZ6DB4U/B4WaBLk/+/4XAwIT1/+llpvOO0U1Q9BW Ia0w== X-Forwarded-Encrypted: i=1; AJvYcCWWEsIhRXhvdCy2qBsDV1U3rNrWcdznnxUofiSis66UvJNGIuwO0j8N6S9ezlc/TqjVN+0Y0KKtqpQDVkw=@vger.kernel.org X-Gm-Message-State: AOJu0YwXhQUW62bgQvRbdpdEgkkeh7X+3vw/WWErxh8aEegsasc6ll8n BbWQP/HdgmPFZWodeqtVn5E07MzofXiSmKjXAb6vRRAcwGlJcl1ZD8hZ2PWRZ40QGyM= X-Gm-Gg: ASbGncuz/M87S3/fOVp+ZyCA5WcNSdl2WtL1tBlAGeEMO78EtE8I7i7w8aSccuVHSMx HUdjX2py1azhvQ9U+GVW0vCq+62P7s36uedbXH4waLR+s7aO1on2v/WbcyMvqKcTbBxaFXVUzPY DXAv47MjC2oV1N8GQYnL4CSaXTBI24UgDTwvVyBKg8eb333Stu+EDZ3NB9o2VPK98VE9Ne1qX8W i8+1vmg4CVzcobWj2rAA77i8tlK7mNpsHOO5a5BbhjgrR0bzZ+BmyQTyiZBoPe11TrPqdPdF+Y9 56W57HQ4zXMIDrOel+XWDEhKqKz4glPy+Tk0dljKP0vBYLesxUVC/5ZiR4IYfPM8eSn8MdyCsDj h1lQG2fwa+rb4qRghSWXcY7Q/Er8LmlXAr1qW7ys+Hv34p4Fp+wSd2D/8Ta+mXJxAu4Qz+o3Aml b4VadyS2U= X-Google-Smtp-Source: AGHT+IFsZQ3ivEoCdxUegpplY25ctIsfGAFJ5rAU93tEd/MzTCmdN2ztCF+pwuYG4rHstc9J65so6Q== X-Received: by 2002:a17:902:d2c6:b0:295:1e92:6b6d with SMTP id d9443c01a7336-2962adb2866mr67889775ad.46.1762373655002; Wed, 05 Nov 2025 12:14:15 -0800 (PST) Received: from z440.. ([2601:1c0:4502:2d00:3099:85d6:dec7:dbe0]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2965096b8ddsm4039435ad.5.2025.11.05.12.14.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 05 Nov 2025 12:14:14 -0800 (PST) From: Igor Reznichenko To: linux@roeck-us.net, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, corbet@lwn.net Cc: david.hunter.linux@gmail.com, devicetree@vger.kernel.org, linux-doc@vger.kernel.org, linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org, skhan@linuxfoundation.org Subject: [PATCH v4 1/2] dt-bindings: hwmon: ST TSC1641 power monitor Date: Wed, 5 Nov 2025 12:14:05 -0800 Message-ID: <20251105201406.1210856-2-igor@reznichenko.net> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251105201406.1210856-1-igor@reznichenko.net> References: <20251105201406.1210856-1-igor@reznichenko.net> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add binding for the TSC1641 I2C power monitor. Signed-off-by: Igor Reznichenko Reviewed-by: Krzysztof Kozlowski --- .../devicetree/bindings/hwmon/st,tsc1641.yaml | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Documentation/devicetree/bindings/hwmon/st,tsc1641.yaml diff --git a/Documentation/devicetree/bindings/hwmon/st,tsc1641.yaml b/Docu= mentation/devicetree/bindings/hwmon/st,tsc1641.yaml new file mode 100644 index 000000000000..aaf244790663 --- /dev/null +++ b/Documentation/devicetree/bindings/hwmon/st,tsc1641.yaml @@ -0,0 +1,63 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/hwmon/st,tsc1641.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: ST Microelectronics TSC1641 I2C power monitor + +maintainers: + - Igor Reznichenko + +description: | + TSC1641 is a 60 V, 16-bit high-precision power monitor with I2C and + MIPI I3C interface + + Datasheets: + https://www.st.com/resource/en/datasheet/tsc1641.pdf + +properties: + compatible: + const: st,tsc1641 + + reg: + maxItems: 1 + + interrupts: + description: Optional alert interrupt. + maxItems: 1 + + shunt-resistor-micro-ohms: + description: Shunt resistor value in micro-ohms. Since device has inte= rnal + 16-bit RSHUNT register with 10 uOhm LSB, the maximum value is capped= at + 655.35 mOhm. + minimum: 100 + default: 1000 + maximum: 655350 + + st,alert-polarity-active-high: + $ref: /schemas/types.yaml#/definitions/flag + description: Default value is 0 which configures the normal polarity o= f the + ALERT pin, being active low open-drain. Setting this to 1 configures= the + polarity of the ALERT pin to be inverted and active high open-drain. + Specify this property to set the alert polarity to active-high. + +required: + - compatible + - reg + +additionalProperties: false + +examples: + - | + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + power-sensor@40 { + compatible =3D "st,tsc1641"; + reg =3D <0x40>; + shunt-resistor-micro-ohms =3D <1000>; + st,alert-polarity-active-high; + }; + }; --=20 2.43.0 From nobody Fri Dec 19 14:36:13 2025 Received: from mail-pl1-f170.google.com (mail-pl1-f170.google.com [209.85.214.170]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1A0CF341663 for ; Wed, 5 Nov 2025 20:14:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.170 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762373661; cv=none; b=lfbCWFOe2A+R/aYyB9YTXuuf0IbojHkO2S4UFUdCwc3YYBAQkr9f3FeOkmVK3oka/cpsT0ucq6VjEcEkOSAZFFSdZdUuW36xSHRIMUankhOiMXtGiPc/cdAfjuD2qtSYCJERbzEX69Xmwh3YSwf4eEj5kDh4bYl4TuO8wWBx3no= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762373661; c=relaxed/simple; bh=F/XiqLp62KoXR5XITO8z48Lr01HgLTJqQI58wTlkocA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=KOjtn3+uc51Jbl6i8Iks/imKF3xoq9YAXaOBAP7jsm8lKQ0mKX8fGP42IkOJNyj+l1m2VhFniR/EShPhwlPcFuciPxhODlERb0dSjAVbmy9IN16liF1yQBTm2uim29LNosaSKCji1TqusR1S7/DI9nPsOtmEIAYW76ymPEQnVZI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=reznichenko.net; spf=none smtp.mailfrom=dpplabs.com; dkim=pass (2048-bit key) header.d=reznichenko.net header.i=@reznichenko.net header.b=m7FEDo/f; arc=none smtp.client-ip=209.85.214.170 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=reznichenko.net Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=dpplabs.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=reznichenko.net header.i=@reznichenko.net header.b="m7FEDo/f" Received: by mail-pl1-f170.google.com with SMTP id d9443c01a7336-294fd2ca6acso10519645ad.0 for ; Wed, 05 Nov 2025 12:14:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=reznichenko.net; s=google; t=1762373656; x=1762978456; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ybB+B8xC8iVNcXTs7RmzqOHT/DPShc1ScaBMF53If7Q=; b=m7FEDo/fTh0Gii35K9EE1o2/RO0VG5+hSvuMA+ldl/lzkDZrzihcWf7UbUfbTf/1Dl ICiVP5ZkjZtZw92PdFQKoFsqbCt80q6TujtzxSfHpGyNXh/vmSl5+6/+p33eNKib/bk9 03bB/HYCix7VwQ4e7PtHkrnYr9gjWqJLvWHa/i4f8b4wdwZDk5zic8bSJD5ehwHSkRxA Qe41nbvnytOxINkCtf1AEEcWEGk9H83TMNyJyEBmtHVpB6I7rIhTMejfDB1BGhh3GheU z095SoMsmJPmWJKw1m5dx+JQH5a+vklqTecKwlkM1bTZ6/7HONf2oVbD7LiWj14MStLp /tMA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762373656; x=1762978456; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ybB+B8xC8iVNcXTs7RmzqOHT/DPShc1ScaBMF53If7Q=; b=hq3SuNpqTSWmZvklaI+EQ3+KGd9dBg/L5kYBI3oYqhrHgzyIQlmr/R9vJ3+WcX70cD PH7UoIP+qW1htsCtD2FtGaOu5N/RlmFxhXWPbPkJpaXuy2Oz752uQ7YkW9MLnMElAhKC FN50ZiXYwydu6Z0mQAhvJbmCd99yIhpKsosj9K0ccY47Z9i1onHHLae3aKVTgog39Cz7 G9CJiWcshxq97EgZJQRS6kGSy9jso5dl2Ivj60bV6iOUdNV8x7x8bz/jQh+SDFhpha+U g6qPo0b9JqOyHi2jdxyEwwErrIf9Zrsmv3ZYEpiXx9SwfbS/FClItSTyqa/LRRMnrxO9 uEWA== X-Forwarded-Encrypted: i=1; AJvYcCULS5HH/Bo04RUWecfpNaCdrvQE6pwpAKAB8RlNysZzvD+9r9KbebhoL6tsofRTpiaO9XDIaJNx3LAWddQ=@vger.kernel.org X-Gm-Message-State: AOJu0Yy9qmxQ9tvYUaHSFgBEho424AaSzBRiUzZeSFEYYBvY1NF6rfb4 a+r0sDzg7AkYLgNGwKsztVkOfLevef1negMZTTOVGtF71Y4MMpIRg3cYIKK+7rBoYZM= X-Gm-Gg: ASbGnctj+ccEop0pfEARozede24EHdLQNUcTLd4PeBCl7Lf2/5Kc9SbuePjSU2ZpKYP ca6lMVySPgLBI40KoH6MO6zE97Df9OTof5XpRkA2PBcFJZkNfeSj9L85YyfPdqjAcghoAkMlgVT MxeQBSXyZPJiyzeQcja0sFP1PYu7+FT9q12zUEyIxGPq1BRaB9wNKXDBCqCoE+SABN3qN6jKeVs O0jeFeudIuCDuSEk1reoJ07oawq0jLVH6rBK81LV5/DfYR5qDXTUeYC4MXg1chsvbNfk1drGV+z YYwClf6ZcVjht34+yJ+SaXfFwuIINkCh9iqhMTAgO1s6WT/Zl6ksBSEXvIwkosoZtS5thFxxbO+ ixI2HlPJVlxdMII3gko3vvohqjZ6mB77j0G4Kzrbkj/RJuc0bRxXPqptilToCWAGPoFQSjJilMh 4B2nLx794= X-Google-Smtp-Source: AGHT+IEWaaEmtywcE46k8PNhAMEkO0/slLQm+KVb6psbtB4DhTs2lPKZ7tsRR3r8u5pxJRXmsiHvoQ== X-Received: by 2002:a17:902:da8d:b0:269:b2e5:900d with SMTP id d9443c01a7336-296508521a5mr9011885ad.5.1762373656250; Wed, 05 Nov 2025 12:14:16 -0800 (PST) Received: from z440.. ([2601:1c0:4502:2d00:3099:85d6:dec7:dbe0]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2965096b8ddsm4039435ad.5.2025.11.05.12.14.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 05 Nov 2025 12:14:15 -0800 (PST) From: Igor Reznichenko To: linux@roeck-us.net, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, corbet@lwn.net Cc: david.hunter.linux@gmail.com, devicetree@vger.kernel.org, linux-doc@vger.kernel.org, linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org, skhan@linuxfoundation.org Subject: [PATCH v4 2/2] hwmon: Add TSC1641 I2C power monitor driver Date: Wed, 5 Nov 2025 12:14:06 -0800 Message-ID: <20251105201406.1210856-3-igor@reznichenko.net> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251105201406.1210856-1-igor@reznichenko.net> References: <20251105201406.1210856-1-igor@reznichenko.net> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a driver for the ST Microelectronics TSC1641 16-bit high-precision power monitor. The driver supports reading bus voltage, current, power, and temperature. Sysfs attributes are exposed for shunt resistor and update interval. The driver integrates with the hwmon subsystem and supports optional ALERT pin polarity configuration. Signed-off-by: Igor Reznichenko --- Documentation/hwmon/index.rst | 1 + Documentation/hwmon/tsc1641.rst | 87 ++++ drivers/hwmon/Kconfig | 12 + drivers/hwmon/Makefile | 1 + drivers/hwmon/tsc1641.c | 748 ++++++++++++++++++++++++++++++++ 5 files changed, 849 insertions(+) create mode 100644 Documentation/hwmon/tsc1641.rst create mode 100644 drivers/hwmon/tsc1641.c diff --git a/Documentation/hwmon/index.rst b/Documentation/hwmon/index.rst index 51a5bdf75b08..4fb9f91f83b3 100644 --- a/Documentation/hwmon/index.rst +++ b/Documentation/hwmon/index.rst @@ -253,6 +253,7 @@ Hardware Monitoring Kernel Drivers tps40422 tps53679 tps546d24 + tsc1641 twl4030-madc-hwmon ucd9000 ucd9200 diff --git a/Documentation/hwmon/tsc1641.rst b/Documentation/hwmon/tsc1641.= rst new file mode 100644 index 000000000000..425e25f7a7d1 --- /dev/null +++ b/Documentation/hwmon/tsc1641.rst @@ -0,0 +1,87 @@ +.. SPDX-License-Identifier: GPL-2.0-only + +Kernel driver tsc1641 +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Supported chips: + + * ST TSC1641 + + Prefix: 'tsc1641' + + Addresses scanned: - + + Datasheet: + https://www.st.com/resource/en/datasheet/tsc1641.pdf + +Author: + - Igor Reznichenko + + +Description +----------- + +The TSC1641 is a high-precision current, voltage, power, and temperature +monitoring analog front-end (AFE). It monitors bidirectional current into a +shunt resistor and load voltage up to 60 V in a synchronized way. Digital = bus +interface is I2C/SMbus. The TSC1641 allows the assertion of several alerts +regarding the voltage, current, power and temperature. + +Usage Notes +----------- + +The TSC1641 driver requires the value of the external shunt resistor to +correctly compute current and power measurements. The resistor value, in +micro-ohms, should be provided either through the device tree property +"shunt-resistor-micro-ohms" or via writable sysfs attribute "shunt_resisto= r". +Please refer to the Documentation/devicetree/bindings/hwmon/st,tsc1641.yaml +for bindings if the device tree is used. + +Supported range of shunt resistor values is from 100 uOhm to 655.35 mOhm, = in +10 uOhm steps. +When selecting the value keep in mind device maximum DC power measurement = is +1600W. See datasheet p.22 for ST recommendations on selecting shunt value. + +If the shunt resistor value is not specified in the device tree, the driver +initializes it to 1000 uOhm by default. Users may configure the correct sh= unt +resistor value at runtime by writing to the "shunt_resistor" sysfs attribu= te. + +The driver only supports continuous operating mode. +Measurement ranges: + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D +Current Bidirectional, dependent on shunt +Bus voltage 0-60V +Maximum DC power 1600W +Temperature -40C to +125C +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D + +Sysfs entries +------------- + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D +in0_input bus voltage (mV) +in0_max bus voltage max alarm limit (mV) +in0_max_alarm bus voltage max alarm limit exceeded +in0_min bus voltage min alarm limit (mV) +in0_min_alarm bus voltage min alarm limit exceeded + +curr1_input current measurement (mA) +curr1_max current max alarm limit (mA) +curr1_max_alarm current max alarm limit exceeded +curr1_min current min alarm limit (mA) +curr1_min_alarm current min alarm limit exceeded + +power1_input power measurement (uW) +power1_max power max alarm limit (uW) +power1_max_alarm power max alarm limit exceeded + +shunt_resistor shunt resistor value (uOhms) + +temp1_input temperature measurement (mdegC) +temp1_max temperature max alarm limit (mdegC) +temp1_max_alarm temperature max alarm limit exceeded + +update_interval data conversion time (1 - 33ms), longer conversion ti= me + corresponds to higher effective resolution in bits +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D \ No newline at end of file diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 2760feb9f83b..b9d7b02932a6 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -2434,6 +2434,18 @@ config SENSORS_TMP513 This driver can also be built as a module. If so, the module will be called tmp513. =20 +config SENSORS_TSC1641 + tristate "ST Microelectronics TSC1641 Power Monitor" + depends on I2C + select REGMAP_I2C + help + If you say yes here you get support for TSC1641 power monitor chip. + The TSC1641 driver is configured for the default configuration of + the part except temperature is enabled by default. + + This driver can also be built as a module. If so, the module + will be called tsc1641. + config SENSORS_VEXPRESS tristate "Versatile Express" depends on VEXPRESS_CONFIG diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 73b2abdcc6dd..a8de5bc69f2a 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -233,6 +233,7 @@ obj-$(CONFIG_SENSORS_TMP401) +=3D tmp401.o obj-$(CONFIG_SENSORS_TMP421) +=3D tmp421.o obj-$(CONFIG_SENSORS_TMP464) +=3D tmp464.o obj-$(CONFIG_SENSORS_TMP513) +=3D tmp513.o +obj-$(CONFIG_SENSORS_TSC1641) +=3D tsc1641.o obj-$(CONFIG_SENSORS_VEXPRESS) +=3D vexpress-hwmon.o obj-$(CONFIG_SENSORS_VIA_CPUTEMP)+=3D via-cputemp.o obj-$(CONFIG_SENSORS_VIA686A) +=3D via686a.o diff --git a/drivers/hwmon/tsc1641.c b/drivers/hwmon/tsc1641.c new file mode 100644 index 000000000000..2b5d34bab146 --- /dev/null +++ b/drivers/hwmon/tsc1641.c @@ -0,0 +1,748 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for ST Microelectronics TSC1641 I2C power monitor + * + * 60 V, 16-bit high-precision power monitor with I2C and MIPI I3C interfa= ce + * Datasheet: https://www.st.com/resource/en/datasheet/tsc1641.pdf + * + * Copyright (C) 2025 Igor Reznichenko + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* I2C registers */ +#define TSC1641_CONFIG 0x00 +#define TSC1641_SHUNT_VOLTAGE 0x01 +#define TSC1641_LOAD_VOLTAGE 0x02 +#define TSC1641_POWER 0x03 +#define TSC1641_CURRENT 0x04 +#define TSC1641_TEMP 0x05 +#define TSC1641_MASK 0x06 +#define TSC1641_FLAG 0x07 +#define TSC1641_RSHUNT 0x08 /* Shunt resistance */ +#define TSC1641_SOL 0x09 +#define TSC1641_SUL 0x0A +#define TSC1641_LOL 0x0B +#define TSC1641_LUL 0x0C +#define TSC1641_POL 0x0D +#define TSC1641_TOL 0x0E +#define TSC1641_MANUF_ID 0xFE /* 0x0006 */ +#define TSC1641_DIE_ID 0xFF /* 0x1000 */ +#define TSC1641_MAX_REG 0xFF + +#define TSC1641_RSHUNT_DEFAULT 1000 /* 1mOhm */ +#define TSC1641_CONFIG_DEFAULT 0x003F /* Default mode and temperature sens= or */ +#define TSC1641_MASK_DEFAULT 0xFC00 /* Unmask all alerts */ + +/* Bit mask for conversion time in the configuration register */ +#define TSC1641_CONV_TIME_MASK GENMASK(7, 4) + +#define TSC1641_CONV_TIME_DEFAULT 1024 +#define TSC1641_MIN_UPDATE_INTERVAL 1024 + +/* LSB value of different registers */ +#define TSC1641_VLOAD_LSB_MVOLT 2 +#define TSC1641_POWER_LSB_UWATT 25000 +#define TSC1641_VSHUNT_LSB_NVOLT 2500 /* Use nanovolts to make it integer = */ +#define TSC1641_RSHUNT_LSB_UOHM 10 +#define TSC1641_TEMP_LSB_MDEGC 500 + +/* Limits based on datasheet */ +#define TSC1641_RSHUNT_MIN_UOHM 100 +#define TSC1641_RSHUNT_MAX_UOHM 655350 +#define TSC1641_CURR_ABS_MAX_MAMP 819200 /* Max current at 100uOhm*/ + +#define TSC1641_ALERT_POL_MASK BIT(1) +#define TSC1641_ALERT_LATCH_EN_MASK BIT(0) + +/* Flags indicating alerts in TSC1641_FLAG register*/ +#define TSC1641_SAT_FLAG BIT(13) +#define TSC1641_SHUNT_OV_FLAG BIT(6) +#define TSC1641_SHUNT_UV_FLAG BIT(5) +#define TSC1641_LOAD_OV_FLAG BIT(4) +#define TSC1641_LOAD_UV_FLAG BIT(3) +#define TSC1641_POWER_OVER_FLAG BIT(2) +#define TSC1641_TEMP_OVER_FLAG BIT(1) + +static bool tsc1641_writeable_reg(struct device *dev, unsigned int reg) +{ + switch (reg) { + case TSC1641_CONFIG: + case TSC1641_MASK: + case TSC1641_RSHUNT: + case TSC1641_SOL: + case TSC1641_SUL: + case TSC1641_LOL: + case TSC1641_LUL: + case TSC1641_POL: + case TSC1641_TOL: + return true; + default: + return false; + } +} + +static bool tsc1641_volatile_reg(struct device *dev, unsigned int reg) +{ + switch (reg) { + case TSC1641_SHUNT_VOLTAGE: + case TSC1641_LOAD_VOLTAGE: + case TSC1641_POWER: + case TSC1641_CURRENT: + case TSC1641_TEMP: + case TSC1641_FLAG: + case TSC1641_MANUF_ID: + case TSC1641_DIE_ID: + return true; + default: + return false; + } +} + +static const struct regmap_config tsc1641_regmap_config =3D { + .reg_bits =3D 8, + .val_bits =3D 16, + .use_single_write =3D true, + .use_single_read =3D true, + .max_register =3D TSC1641_MAX_REG, + .cache_type =3D REGCACHE_MAPLE, + .volatile_reg =3D tsc1641_volatile_reg, + .writeable_reg =3D tsc1641_writeable_reg, +}; + +struct tsc1641_data { + long rshunt_uohm; + long current_lsb_ua; + struct regmap *regmap; +}; + +/* + * Upper limit due to chip 16-bit shunt register, lower limit to + * prevent current and power registers overflow + */ +static inline int tsc1641_validate_shunt(u32 val) +{ + if (val < TSC1641_RSHUNT_MIN_UOHM || val > TSC1641_RSHUNT_MAX_UOHM) + return -EINVAL; + return 0; +} + +static int tsc1641_set_shunt(struct tsc1641_data *data, u32 val) +{ + struct regmap *regmap =3D data->regmap; + long rshunt_reg; + + /* RSHUNT register LSB is 10uOhm so need to divide further */ + rshunt_reg =3D DIV_ROUND_CLOSEST(val, TSC1641_RSHUNT_LSB_UOHM); + /* + * Clamp value to the nearest multiple of TSC1641_RSHUNT_LSB_UOHM + * in case shunt value provided was not a multiple + */ + data->rshunt_uohm =3D rshunt_reg * TSC1641_RSHUNT_LSB_UOHM; + data->current_lsb_ua =3D DIV_ROUND_CLOSEST(TSC1641_VSHUNT_LSB_NVOLT * 100= 0, + data->rshunt_uohm); + + return regmap_write(regmap, TSC1641_RSHUNT, rshunt_reg); +} + +/* + * Conversion times in uS, value in CONFIG[CT3:CT0] corresponds to index i= n this array + * See "Table 14. CT3 to CT0: conversion time" in: + * https://www.st.com/resource/en/datasheet/tsc1641.pdf + */ +static const int tsc1641_conv_times[] =3D { 128, 256, 512, 1024, 2048, 409= 6, 8192, 16384, 32768 }; + +static int tsc1641_reg_to_upd_interval(u16 config) +{ + int idx =3D FIELD_GET(TSC1641_CONV_TIME_MASK, config); + + idx =3D clamp_val(idx, 0, ARRAY_SIZE(tsc1641_conv_times) - 1); + int conv_time =3D tsc1641_conv_times[idx]; + + /* Don't support sub-millisecond update interval as it's not supported in= hwmon */ + conv_time =3D max(conv_time, TSC1641_MIN_UPDATE_INTERVAL); + /* Return nearest value in milliseconds */ + return DIV_ROUND_CLOSEST(conv_time, 1000); +} + +static u16 tsc1641_upd_interval_to_reg(long interval) +{ + /* Supported interval is 1ms - 33ms */ + interval =3D clamp_val(interval, 1, 33); + + int conv =3D interval * 1000; + int conv_bits =3D find_closest(conv, tsc1641_conv_times, + ARRAY_SIZE(tsc1641_conv_times)); + + return FIELD_PREP(TSC1641_CONV_TIME_MASK, conv_bits); +} + +static int tsc1641_chip_write(struct device *dev, u32 attr, long val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + + switch (attr) { + case hwmon_chip_update_interval: + return regmap_update_bits(data->regmap, TSC1641_CONFIG, + TSC1641_CONV_TIME_MASK, + tsc1641_upd_interval_to_reg(val)); + default: + return -EOPNOTSUPP; + } +} + +static int tsc1641_chip_read(struct device *dev, u32 attr, long *val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + u32 regval; + int ret; + + switch (attr) { + case hwmon_chip_update_interval: + ret =3D regmap_read(data->regmap, TSC1641_CONFIG, ®val); + if (ret) + return ret; + + *val =3D tsc1641_reg_to_upd_interval(regval); + return 0; + default: + return -EOPNOTSUPP; + } +} + +static int tsc1641_flag_read(struct regmap *regmap, u32 flag, long *val) +{ + unsigned int regval; + int ret; + + ret =3D regmap_read_bypassed(regmap, TSC1641_FLAG, ®val); + if (ret) + return ret; + + *val =3D !!(regval & flag); + return 0; +} + +static int tsc1641_in_read(struct device *dev, u32 attr, long *val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + unsigned int regval; + int ret, reg; + long sat_flag; + + switch (attr) { + case hwmon_in_input: + reg =3D TSC1641_LOAD_VOLTAGE; + break; + case hwmon_in_min: + reg =3D TSC1641_LUL; + break; + case hwmon_in_max: + reg =3D TSC1641_LOL; + break; + case hwmon_in_min_alarm: + return tsc1641_flag_read(regmap, TSC1641_LOAD_UV_FLAG, val); + case hwmon_in_max_alarm: + return tsc1641_flag_read(regmap, TSC1641_LOAD_OV_FLAG, val); + default: + return -EOPNOTSUPP; + } + + ret =3D regmap_read(regmap, reg, ®val); + if (ret) + return ret; + + /* Check if load voltage is out of range */ + if (reg =3D=3D TSC1641_LOAD_VOLTAGE) { + /* Register is 15-bit max */ + if (regval & 0x8000) + return -ENODATA; + + ret =3D tsc1641_flag_read(regmap, TSC1641_SAT_FLAG, &sat_flag); + if (ret) + return ret; + /* Out of range conditions per datasheet */ + if (sat_flag && (regval =3D=3D 0x7FFF || !regval)) + return -ENODATA; + } + + *val =3D regval * TSC1641_VLOAD_LSB_MVOLT; + return 0; +} + +/* Chip supports bidirectional (positive or negative) current */ +static int tsc1641_curr_read(struct device *dev, u32 attr, long *val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + int regval; + int ret, reg; + long sat_flag; + + /* Current limits are the shunt under/over voltage limits */ + switch (attr) { + case hwmon_curr_input: + reg =3D TSC1641_CURRENT; + break; + case hwmon_curr_min: + reg =3D TSC1641_SUL; + break; + case hwmon_curr_max: + reg =3D TSC1641_SOL; + break; + case hwmon_curr_min_alarm: + return tsc1641_flag_read(regmap, TSC1641_SHUNT_UV_FLAG, val); + case hwmon_curr_max_alarm: + return tsc1641_flag_read(regmap, TSC1641_SHUNT_OV_FLAG, val); + default: + return -EOPNOTSUPP; + } + /* + * Current uses shunt voltage, so check if it's out of range. + * We report current register in sysfs to stay consistent with internal + * power calculations which use current register values + */ + if (reg =3D=3D TSC1641_CURRENT) { + ret =3D regmap_read(regmap, TSC1641_SHUNT_VOLTAGE, ®val); + if (ret) + return ret; + + ret =3D tsc1641_flag_read(regmap, TSC1641_SAT_FLAG, &sat_flag); + if (ret) + return ret; + + if (sat_flag && (regval =3D=3D 0x7FFF || regval =3D=3D 0x8000)) + return -ENODATA; + } + + ret =3D regmap_read(regmap, reg, ®val); + if (ret) + return ret; + + /* Current in milliamps, signed */ + *val =3D DIV_ROUND_CLOSEST((s16)regval * data->current_lsb_ua, 1000); + return 0; +} + +static int tsc1641_power_read(struct device *dev, u32 attr, long *val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + unsigned int regval; + int ret, reg; + + switch (attr) { + case hwmon_power_input: + reg =3D TSC1641_POWER; + break; + case hwmon_power_max: + reg =3D TSC1641_POL; + break; + case hwmon_power_max_alarm: + return tsc1641_flag_read(regmap, TSC1641_POWER_OVER_FLAG, val); + default: + return -EOPNOTSUPP; + } + + ret =3D regmap_read(regmap, reg, ®val); + if (ret) + return ret; + + *val =3D regval * TSC1641_POWER_LSB_UWATT; + return 0; +} + +static int tsc1641_temp_read(struct device *dev, u32 attr, long *val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + unsigned int regval; + int ret, reg; + + switch (attr) { + case hwmon_temp_input: + reg =3D TSC1641_TEMP; + break; + case hwmon_temp_max: + reg =3D TSC1641_TOL; + break; + case hwmon_temp_max_alarm: + return tsc1641_flag_read(regmap, TSC1641_TEMP_OVER_FLAG, val); + default: + return -EOPNOTSUPP; + } + + ret =3D regmap_read(regmap, reg, ®val); + if (ret) + return ret; + + /* 0x8000 means that TEMP measurement not enabled */ + if (reg =3D=3D TSC1641_TEMP && regval =3D=3D 0x8000) + return -ENODATA; + + /* Both temperature and limit registers are signed */ + *val =3D (s16)regval * TSC1641_TEMP_LSB_MDEGC; + return 0; +} + +static int tsc1641_in_write(struct device *dev, u32 attr, long val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + unsigned int regval; + int reg; + + switch (attr) { + case hwmon_in_min: + reg =3D TSC1641_LUL; + break; + case hwmon_in_max: + reg =3D TSC1641_LOL; + break; + default: + return -EOPNOTSUPP; + } + /* Clamp to full register range */ + val =3D clamp_val(val, 0, TSC1641_VLOAD_LSB_MVOLT * USHRT_MAX); + regval =3D DIV_ROUND_CLOSEST(val, TSC1641_VLOAD_LSB_MVOLT); + + return regmap_write(regmap, reg, regval); +} + +static int tsc1641_curr_write(struct device *dev, u32 attr, long val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + int reg, regval; + + switch (attr) { + case hwmon_curr_min: + reg =3D TSC1641_SUL; + break; + case hwmon_curr_max: + reg =3D TSC1641_SOL; + break; + default: + return -EOPNOTSUPP; + } + + /* Clamp to prevent over/underflow below */ + val =3D clamp_val(val, -TSC1641_CURR_ABS_MAX_MAMP, TSC1641_CURR_ABS_MAX_M= AMP); + /* Convert val in milliamps to register */ + regval =3D DIV_ROUND_CLOSEST(val * 1000, data->current_lsb_ua); + /* + * Prevent signed 16-bit overflow. + * Integer arithmetic and shunt scaling can quantize values near 0x7FFF/0= x8000, + * so reading and writing back may not preserve the exact original regist= er value. + */ + regval =3D clamp_val(regval, SHRT_MIN, SHRT_MAX); + /* SUL and SOL registers are signed */ + return regmap_write(regmap, reg, regval & 0xFFFF); +} + +static int tsc1641_power_write(struct device *dev, u32 attr, long val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + unsigned int regval; + + switch (attr) { + case hwmon_power_max: + /* Clamp to full register range */ + val =3D clamp_val(val, 0, TSC1641_POWER_LSB_UWATT * USHRT_MAX); + regval =3D DIV_ROUND_CLOSEST(val, TSC1641_POWER_LSB_UWATT); + return regmap_write(regmap, TSC1641_POL, regval); + default: + return -EOPNOTSUPP; + } +} + +static int tsc1641_temp_write(struct device *dev, u32 attr, long val) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + struct regmap *regmap =3D data->regmap; + int regval; + + switch (attr) { + case hwmon_temp_max: + /* Clamp to full register range */ + val =3D clamp_val(val, TSC1641_TEMP_LSB_MDEGC * SHRT_MIN, + TSC1641_TEMP_LSB_MDEGC * SHRT_MAX); + regval =3D DIV_ROUND_CLOSEST(val, TSC1641_TEMP_LSB_MDEGC); + /* TOL register is signed */ + return regmap_write(regmap, TSC1641_TOL, regval & 0xFFFF); + default: + return -EOPNOTSUPP; + } +} + +static umode_t tsc1641_is_visible(const void *data, enum hwmon_sensor_type= s type, + u32 attr, int channel) +{ + switch (type) { + case hwmon_chip: + switch (attr) { + case hwmon_chip_update_interval: + return 0644; + default: + break; + } + break; + case hwmon_in: + switch (attr) { + case hwmon_in_input: + return 0444; + case hwmon_in_min: + case hwmon_in_max: + return 0644; + case hwmon_in_min_alarm: + case hwmon_in_max_alarm: + return 0444; + default: + break; + } + break; + case hwmon_curr: + switch (attr) { + case hwmon_curr_input: + return 0444; + case hwmon_curr_min: + case hwmon_curr_max: + return 0644; + case hwmon_curr_min_alarm: + case hwmon_curr_max_alarm: + return 0444; + default: + break; + } + break; + case hwmon_power: + switch (attr) { + case hwmon_power_input: + return 0444; + case hwmon_power_max: + return 0644; + case hwmon_power_max_alarm: + return 0444; + default: + break; + } + break; + case hwmon_temp: + switch (attr) { + case hwmon_temp_input: + return 0444; + case hwmon_temp_max: + return 0644; + case hwmon_temp_max_alarm: + return 0444; + default: + break; + } + break; + default: + break; + } + return 0; +} + +static int tsc1641_read(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, long *val) +{ + switch (type) { + case hwmon_chip: + return tsc1641_chip_read(dev, attr, val); + case hwmon_in: + return tsc1641_in_read(dev, attr, val); + case hwmon_curr: + return tsc1641_curr_read(dev, attr, val); + case hwmon_power: + return tsc1641_power_read(dev, attr, val); + case hwmon_temp: + return tsc1641_temp_read(dev, attr, val); + default: + return -EOPNOTSUPP; + } +} + +static int tsc1641_write(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, long val) +{ + switch (type) { + case hwmon_chip: + return tsc1641_chip_write(dev, attr, val); + case hwmon_in: + return tsc1641_in_write(dev, attr, val); + case hwmon_curr: + return tsc1641_curr_write(dev, attr, val); + case hwmon_power: + return tsc1641_power_write(dev, attr, val); + case hwmon_temp: + return tsc1641_temp_write(dev, attr, val); + default: + return -EOPNOTSUPP; + } +} + +static const struct hwmon_channel_info * const tsc1641_info[] =3D { + HWMON_CHANNEL_INFO(chip, + HWMON_C_UPDATE_INTERVAL), + HWMON_CHANNEL_INFO(in, + HWMON_I_INPUT | HWMON_I_MAX | HWMON_I_MAX_ALARM | + HWMON_I_MIN | HWMON_I_MIN_ALARM), + HWMON_CHANNEL_INFO(curr, + HWMON_C_INPUT | HWMON_C_MAX | HWMON_C_MAX_ALARM | + HWMON_C_MIN | HWMON_C_MIN_ALARM), + HWMON_CHANNEL_INFO(power, + HWMON_P_INPUT | HWMON_P_MAX | HWMON_P_MAX_ALARM), + HWMON_CHANNEL_INFO(temp, + HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_ALARM), + NULL +}; + +static ssize_t shunt_resistor_show(struct device *dev, + struct device_attribute *da, char *buf) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + + return sysfs_emit(buf, "%li\n", data->rshunt_uohm); +} + +static ssize_t shunt_resistor_store(struct device *dev, + struct device_attribute *da, + const char *buf, size_t count) +{ + struct tsc1641_data *data =3D dev_get_drvdata(dev); + unsigned int val; + int ret; + + ret =3D kstrtouint(buf, 10, &val); + if (ret < 0) + return ret; + + ret =3D tsc1641_validate_shunt(val); + if (ret < 0) + return ret; + + ret =3D tsc1641_set_shunt(data, val); + if (ret < 0) + return ret; + return count; +} + +static const struct hwmon_ops tsc1641_hwmon_ops =3D { + .is_visible =3D tsc1641_is_visible, + .read =3D tsc1641_read, + .write =3D tsc1641_write, +}; + +static const struct hwmon_chip_info tsc1641_chip_info =3D { + .ops =3D &tsc1641_hwmon_ops, + .info =3D tsc1641_info, +}; + +static DEVICE_ATTR_RW(shunt_resistor); + +/* Shunt resistor value is exposed via sysfs attribute */ +static struct attribute *tsc1641_attrs[] =3D { + &dev_attr_shunt_resistor.attr, + NULL, +}; +ATTRIBUTE_GROUPS(tsc1641); + +static int tsc1641_init(struct device *dev, struct tsc1641_data *data) +{ + struct regmap *regmap =3D data->regmap; + bool active_high; + u32 shunt; + int ret; + + if (device_property_read_u32(dev, "shunt-resistor-micro-ohms", &shunt) < = 0) + shunt =3D TSC1641_RSHUNT_DEFAULT; + + if (tsc1641_validate_shunt(shunt) < 0) { + dev_err(dev, "invalid shunt resistor value %u\n", shunt); + return -EINVAL; + } + + ret =3D tsc1641_set_shunt(data, shunt); + if (ret < 0) + return ret; + + ret =3D regmap_write(regmap, TSC1641_CONFIG, TSC1641_CONFIG_DEFAULT); + if (ret < 0) + return ret; + + active_high =3D device_property_read_bool(dev, "st,alert-polarity-active-= high"); + + return regmap_write(regmap, TSC1641_MASK, TSC1641_MASK_DEFAULT | + FIELD_PREP(TSC1641_ALERT_POL_MASK, active_high)); +} + +static int tsc1641_probe(struct i2c_client *client) +{ + struct device *dev =3D &client->dev; + struct tsc1641_data *data; + struct device *hwmon_dev; + int ret; + + data =3D devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + data->regmap =3D devm_regmap_init_i2c(client, &tsc1641_regmap_config); + if (IS_ERR(data->regmap)) + return dev_err_probe(dev, PTR_ERR(data->regmap), + "failed to allocate register map\n"); + + ret =3D tsc1641_init(dev, data); + if (ret < 0) + return dev_err_probe(dev, ret, "failed to configure device\n"); + + hwmon_dev =3D devm_hwmon_device_register_with_info(dev, client->name, + data, &tsc1641_chip_info, tsc1641_groups); + if (IS_ERR(hwmon_dev)) + return PTR_ERR(hwmon_dev); + + dev_info(dev, "power monitor %s (Rshunt =3D %li uOhm)\n", + client->name, data->rshunt_uohm); + + return 0; +} + +static const struct i2c_device_id tsc1641_id[] =3D { + { "tsc1641", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, tsc1641_id); + +static const struct of_device_id __maybe_unused tsc1641_of_match[] =3D { + { .compatible =3D "st,tsc1641" }, + { }, +}; +MODULE_DEVICE_TABLE(of, tsc1641_of_match); + +static struct i2c_driver tsc1641_driver =3D { + .driver =3D { + .name =3D "tsc1641", + .of_match_table =3D of_match_ptr(tsc1641_of_match), + }, + .probe =3D tsc1641_probe, + .id_table =3D tsc1641_id, +}; + +module_i2c_driver(tsc1641_driver); + +MODULE_AUTHOR("Igor Reznichenko "); +MODULE_DESCRIPTION("tsc1641 driver"); +MODULE_LICENSE("GPL"); --=20 2.43.0