From nobody Mon Sep 28 14:48:34 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E17D5442B3D for ; Thu, 20 Aug 2026 13:10:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231415; cv=none; b=lKknnpnZy3GRNG7XwZhfz3bfCn48Yt8gS3ruyGR7JqsGaoJknNg8U2xF+5EqarqIlCsXi+ZTxdiZwF7NV1e/tN7cIv5XMZkPHKbcNTFTDVfMqAyYIn2429uRAYphd0ukCVUG16h5Aw8Hi7T22xmylw4O1+NwLi+aLtIFFh4sf04= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231415; c=relaxed/simple; bh=PyPQPdKz3OhtBacfFMsQhP2CFNLVRj0RxGqo4UtPA4I=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=AlqmSbEdRCRol5Q+JkVpjKKK6oqbqdX7xvKQon2Jq4vgqx4/acuDMupg0eRCdoYPsTweE3qBU1zJaacxn1UDHhc//5pnR3wytDq+uHBNI8qFSRH+Bk/WoLEbRvpi2pAEauNfL6dgFsSeHezqXs/FtOZcWpBld0ATRtv5zXUnhw0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=JxtYbRtp; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b=tV7yuM/T; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="JxtYbRtp"; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b="tV7yuM/T" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1787231412; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=3YiRPmyoOxA/J2diOjaCkkj9Ix5C+gpQyyXhZIIsszc=; b=JxtYbRtpgCqe0V3oMsoBrHfdlo3nxV/QQzHm66lHPv6nnIzYJVG216uI3SlQ8gvRA7+GXH u6dRdmpmrmoRB2OcGQsWXR9pRdzOcPhh5hoQcYPDsmpivKle5/7xjGeNj5urKJPgYUliU6 Y5df9WO+HOvvxVNi7aRePSAgejbJPRE= Received: from mail-qk1-f197.google.com (mail-qk1-f197.google.com [209.85.222.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-141-Xpdoj62aOwK_sD6qjbbpkQ-1; Thu, 20 Aug 2026 09:10:01 -0400 X-MC-Unique: Xpdoj62aOwK_sD6qjbbpkQ-1 X-Mimecast-MFC-AGG-ID: Xpdoj62aOwK_sD6qjbbpkQ_1787231400 Received: by mail-qk1-f197.google.com with SMTP id af79cd13be357-92e5fc4c7e9so290986185a.3 for ; Thu, 20 Aug 2026 06:10:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=google; t=1787231400; x=1787836200; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=3YiRPmyoOxA/J2diOjaCkkj9Ix5C+gpQyyXhZIIsszc=; b=tV7yuM/TAK27RgmehL7sF3jOK7nFx4fNSGdpoumjOoWDhEF5R2lnG8F1t3is2akJIe 30m5nT3RPI48ypKj0/zHHuFkrsg+7XY3rfaLT3PaST9OENLyYGhAKbi/Qr0RtzvWGEIH kJ4TNBjXZB2XiwBlICJqMjOynY6oMm5zp1QTzDuK5BxPATXPWKNgq0E9cfx8ecjkH2ep 24X9EYDM044t14guCOHN6tcNDhqIiht6S9WD6bEz++34Q7hqH7CqjZL5LacKfavSfEKa Ry7BK8ef51hdc0MmLXPFb/Lpgp2OAx8u4Uwm7CjVLQtr/glt5ecSxZu/wa59PL9clDI5 PIxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787231400; x=1787836200; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=3YiRPmyoOxA/J2diOjaCkkj9Ix5C+gpQyyXhZIIsszc=; b=VLAN1y2gfG2OhwWSIiSKDaJEvvJ8eSZApouJ+VQ7n/BL18DGUDWINPbZ6r1mIbIFu8 X4YbjR+OHJYmgeOigVT6yAYDHHl83jY8Ed1/yAb6i7YaQgZNjLp1YFVvY++Bso8YrS1h DKZkxGyEHwUWSCDMfTpoziyr3KP1zLCjuQFpWc/zj2v6UEhTklbc5GvsIDV3t7JVFboj DwsVxQxBGPIM5xxjii0W3CCDTtYh/Tl2LePPG2M8Z9U5TAhQgFms+2RMhcr6s2hT8/2k Ul44iwEjSaJwvSKrrXTc6LjM+HKljr8Ge3nstG3/pt7w7FBv2EAnpvGU6VgbeGts8kgK GPRw== X-Forwarded-Encrypted: i=1; AHgh+RqnXJJJ6TB+M6/ZEXIGM9c3IzAeF0Ks2cIYx7UwiTHsOYzpBySqA350aBMMSPB4dwxOYAdCPKFqCUGgnh0=@vger.kernel.org X-Gm-Message-State: AOJu0YwSVBMLK78Liu7dv6Ljq4sY1a1tCvVeWAewsase+JCilUB65w+R Lfr6/RgVFy/XX3oKl2sB9EO4G4UnZdrFq37OP4LUp26urhmpkVhpyc1ZcctbSgA5rNF77iQT6uz sCbqRSVKgB61E5UivBLOdv4sFCYSH6++EQhuUrOt9AqpxdPMg9UoGaKCmGwz2A42csw== X-Gm-Gg: AR+sD10BTJkWyO47D5ySP0mQ4zbzNGlibrvOWODl8vw9eWvx7Jfk3X30kau2pQ5gQww M5Qz2XOdV5U9+i6WSEZgQ6KJIh7S9onVtYjVIcO3w5ztaAYgBHfvH8dl+d1e5+1tEpfI/VM2UnM a6VQGocWRjOsquUWOLk4/eWz7cBStmudX7d9TkZXxUVS2wMdMNuQI+Cbln5qTAQ52IEeqYV3yoe 3x245csAwizcfyAGOUA/bF5skUA+uJ2dw2rScltwmpvYEa/k1y0hWXgoDchVSQDvNEwHFYLsOen 8X3oFIVXVcs/2ulvogLkyH6/DGjzAYIlvU7X3WP5tdK7bd4NPj89A74KRL9XTQ8jSeawFRX/FUm JayE+2nMtGvB94agWRMIOSD6xCiKBvBQl X-Received: by 2002:a05:620a:2904:b0:930:a38d:4030 with SMTP id af79cd13be357-9371e6acac8mr1072775385a.29.1787231400377; Thu, 20 Aug 2026 06:10:00 -0700 (PDT) X-Received: by 2002:a05:620a:2904:b0:930:a38d:4030 with SMTP id af79cd13be357-9371e6acac8mr1072765685a.29.1787231399799; Thu, 20 Aug 2026 06:09:59 -0700 (PDT) Received: from jkangas-thinkpadp1gen3.rmtuswa.csb ([2601:1c2:4480:2110:932e:45ef:6b6c:ddd0]) by smtp.gmail.com with ESMTPSA id af79cd13be357-937204ba087sm364217985a.21.2026.08.20.06.09.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Aug 2026 06:09:59 -0700 (PDT) From: Jared Kangas Date: Thu, 20 Aug 2026 06:09:21 -0700 Subject: [PATCH v2 1/4] hwmon: (ina2xx) Acquire hwmon_lock in shunt_resistor_show() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-1-fdce35abc41e@redhat.com> References: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> In-Reply-To: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> To: Guenter Roeck , Tzung-Bi Shih , Lothar Felten Cc: linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org, Jared Kangas , Sashiko X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1787231395; l=1190; i=jkangas@redhat.com; s=20251111; h=from:subject:message-id; bh=PyPQPdKz3OhtBacfFMsQhP2CFNLVRj0RxGqo4UtPA4I=; b=epfLXpF0ZX49t91Ptxb7Uy4m2e3YGQYhE6BToUiYbm6b4nTcH5esDz8oe1/1YDHG/9e5oCJL2 sRhrSZx218/BkQDpObEAluokR6nk7xrMaBCUwTesE45eK6zy9rC+7DK X-Developer-Key: i=jkangas@redhat.com; a=ed25519; pk=eFM2Mqcfarb4qox390655bUATO0fG9gwgaw7kGmOEZQ= shunt_resistor_store() currently acquires hwmon_lock to set data->rshunt, but the corresponding access in shunt_resistor_show() is unprotected. Acquire the lock in shunt_resistor_show() as well to ensure proper synchronization. Fixes: 3ad867001c91 ("hwmon: (ina2xx) fix sysfs shunt resistor read access") Reported-by: Sashiko Closes: https://lore.kernel.org/all/20260729162836.89BDF1F00A3A@smtp.kernel= .org/ Signed-off-by: Jared Kangas --- drivers/hwmon/ina2xx.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/drivers/hwmon/ina2xx.c b/drivers/hwmon/ina2xx.c index c4742e84b999d..f6c63ce1ef193 100644 --- a/drivers/hwmon/ina2xx.c +++ b/drivers/hwmon/ina2xx.c @@ -859,8 +859,12 @@ static ssize_t shunt_resistor_show(struct device *dev, struct device_attribute *da, char *buf) { struct ina2xx_data *data =3D dev_get_drvdata(dev); + long rshunt; =20 - return sysfs_emit(buf, "%li\n", data->rshunt); + scoped_guard(hwmon_lock, dev) { + rshunt =3D data->rshunt; + } + return sysfs_emit(buf, "%li\n", rshunt); } =20 static ssize_t shunt_resistor_store(struct device *dev, --=20 2.55.0 From nobody Mon Sep 28 14:48:34 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 974CC443E3C for ; Thu, 20 Aug 2026 13:10:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231410; cv=none; b=tGAxkZ7zCys2T0QCsgrlfvaXv0jc1c1nhDecYkg+t38SalDaVXqiNMohIgrh49ik5KPMqt/wc6w+fZYb14U7VyUjtEF56qalhJunJQi2K12KtUgmkEn+8OPnfx8AV067ra3oLRfuDcOg8hW/xqRs4GspffMzkyZwyslYSeO4YWM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231410; c=relaxed/simple; bh=taGfuHStS0ThjG6UJrCo4jVzDX9qbsj9mHxTnwiiLkw=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=RHYiQgBQTV7iZo3OdqIIIt37slYQAqy+Yof1AO8V8qWGhyckaoGVuURJ+yQNcSfe1FWiBEbuew6NgwAD4LDW3FCvV0yABe5yQ9I9BDi3kVU3ZIRT3CQdSv3qbMGVeGeH1opaAwWvi0mednWFzyvBs0ulY/G+O+/pCspOV2Ld3dE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=S+hzdlZf; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b=nWGGfOZS; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="S+hzdlZf"; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b="nWGGfOZS" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1787231406; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=yx44r2tBFVRVz1CszXpLBOBK3iXDrxNQXxexA2NClh0=; b=S+hzdlZfwFaJe8JF8AD0Gbu+4WGJfvvPh9EMsUDZscsB7zSx6+5cbg+14x33bOjOZmsloa Zw/NqOvjk9e1Ys0WdNTLnsefzIMNsZwv2WQkIMn61zRf7uDg/7Tj5Yq13NdRWsWnK4QQGt XMVTXApg/ebZYZIa6M7HdJVlS9W8Kuo= Received: from mail-qk1-f199.google.com (mail-qk1-f199.google.com [209.85.222.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-408--WGLKy8oPE2HH4oPtlz0OA-1; Thu, 20 Aug 2026 09:10:02 -0400 X-MC-Unique: -WGLKy8oPE2HH4oPtlz0OA-1 X-Mimecast-MFC-AGG-ID: -WGLKy8oPE2HH4oPtlz0OA_1787231402 Received: by mail-qk1-f199.google.com with SMTP id af79cd13be357-92e5e38fbc5so286234985a.2 for ; Thu, 20 Aug 2026 06:10:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=google; t=1787231402; x=1787836202; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=yx44r2tBFVRVz1CszXpLBOBK3iXDrxNQXxexA2NClh0=; b=nWGGfOZSuPBWtrYPhQtrp/5VMYGUFr4QgimFJfE84AnrU0a3kNFuzrr4awF69/UJXZ 03k8RmRvyoImcwlW6U34MhzbGrcUPTBIj0q/SP6MP2IQoUEZm8dWJZMWOWRW010Fny/1 56VltcSpKylKF4WXa9Z1QG5Nnuoj22gbRzkTBvUTH2pOmvVgBULglmb/jbyWqTE1F0sw P1co+dMT8u4lVJSkGK/gz3S4Me6lWH+CoiOuoR2dfKUfOs9TDyxQkjDFraroIt/S9QKt J130BkU1BhT3l87sLWY0lO4aygOLMmlZH0lrkZyypZ9hVH/Ib/U98udYj+QfZkQDSaug ezvg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787231402; x=1787836202; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=yx44r2tBFVRVz1CszXpLBOBK3iXDrxNQXxexA2NClh0=; b=KmIDPgdEaG2HNm4DRB6gUZKmTFxpeF/t0UjKDPCP+1C9xn4kgS8dK5jPgAtfD5YiSE 5KBSmBphJSGjir55NNLttRKKaAIOwjQOmAZeeVFMh8nO+3kIw9fleRYR9Zmk/+KTu1FA 6ATp2dmnv2rJEBhiFfnHSFmwKz1jHG1ATnsNydzAF8CXwUCY/2gXn9MWi13GQyZ+GszB Rc19XbMCG2B3/EeSbm0kGV9WTuvvRnCA9L3/s/di6xQ1MG5gwGAl7JLA8XpFSJAddtYH VLlG1k88GowIRbZMn9LrGV5Yibwa5CfguwngInE5I4LglnkmvZCQkWfDUe2nbMR3rAa2 IxTA== X-Forwarded-Encrypted: i=1; AHgh+Ro3fYJOzJVch4Be6J2ZEmYS21+2+yGUIh0CxipJkDAeMij9Q/52VpGrENVUl3Y0BwI1PpmAmqBCWTXRris=@vger.kernel.org X-Gm-Message-State: AOJu0YykJK+SqtxRNPqQrxJmUDaghBuQKpaMhz8bGoebwzKEIA7b+0p3 xzsjEs2dPNUua50uKy+p8uBFZEslPJyseok/HwI/OCN0ZTM01VhpxAwqMdKJFnX9dXb7B9aJj+T bWofEu9diT4y53NIbqILEGbeqJaVFbsvKs3eQK6PxSuWlYlM/FOq56fdeHVoAFN3Oug== X-Gm-Gg: AR+sD10jaBDVKxYboB8zNZuqwxgQm4CHFemFyIZj/Kpp2Yas/JqQKKnXKMbdRN9pxul XV3az8Mh1E2KibreS/bP6EobZ66Eytzy6oVk4oArZek3yjmlmZdcC+xEPqYLCPs7dyEWFDZnus2 0GownFSm5xK/aCgraN9sRItxx57ltJoTIqhteYgI9iIzaXsMd5I+rikFBiv5jCdRG3hVm3dxRFW YmFy0smAe+gkY5JgkteXcKapvRPOZ08145PMYSjCgvRCYY9PIOr9evwtb0hLcjgxtGLovoP7Rww 90PaTRPtbh0b7RERfB0CWq8Dip//kEK9pGEDNT+jsZei9NRsPx8IiHayXZxZThSa0fRip/0L8Lg 0XsKUaSblZ2ozUORYBVqEUoxHJMLPxwRg X-Received: by 2002:a05:620a:4054:b0:930:adac:1e99 with SMTP id af79cd13be357-9371e43fc62mr1112274985a.38.1787231401768; Thu, 20 Aug 2026 06:10:01 -0700 (PDT) X-Received: by 2002:a05:620a:4054:b0:930:adac:1e99 with SMTP id af79cd13be357-9371e43fc62mr1112266385a.38.1787231401144; Thu, 20 Aug 2026 06:10:01 -0700 (PDT) Received: from jkangas-thinkpadp1gen3.rmtuswa.csb ([2601:1c2:4480:2110:932e:45ef:6b6c:ddd0]) by smtp.gmail.com with ESMTPSA id af79cd13be357-937204ba087sm364217985a.21.2026.08.20.06.10.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Aug 2026 06:10:00 -0700 (PDT) From: Jared Kangas Date: Thu, 20 Aug 2026 06:09:22 -0700 Subject: [PATCH v2 2/4] hwmon: (ina2xx) Parameterize ina2xx_data in ina226_alert_read() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-2-fdce35abc41e@redhat.com> References: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> In-Reply-To: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> To: Guenter Roeck , Tzung-Bi Shih , Lothar Felten Cc: linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org, Jared Kangas X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1787231395; l=2501; i=jkangas@redhat.com; s=20251111; h=from:subject:message-id; bh=taGfuHStS0ThjG6UJrCo4jVzDX9qbsj9mHxTnwiiLkw=; b=cGM+XryZWLP3Uv7Q5l/8S2Gp1A+um9S4xRHcHYauOb62udkecJWctaHXat89w+qsiijJOIVFg 1U/N2luR3obBIhb2TUYXWLjMLQAOa8LIwoXshk7fM02MGlM1GXgUAif X-Developer-Key: i=jkangas@redhat.com; a=ed25519; pk=eFM2Mqcfarb4qox390655bUATO0fG9gwgaw7kGmOEZQ= Mirror ina226_alert_limit_read/write and use struct ina2xx_data instead of struct regmap in ina226_alert_read's parameters. Signed-off-by: Jared Kangas --- drivers/hwmon/ina2xx.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/drivers/hwmon/ina2xx.c b/drivers/hwmon/ina2xx.c index f6c63ce1ef193..c56e42432673f 100644 --- a/drivers/hwmon/ina2xx.c +++ b/drivers/hwmon/ina2xx.c @@ -476,12 +476,12 @@ static int ina2xx_chip_read(struct device *dev, u32 a= ttr, long *val) return 0; } =20 -static int ina226_alert_read(struct regmap *regmap, u32 mask, long *val) +static int ina226_alert_read(struct ina2xx_data *data, u32 mask, long *val) { unsigned int regval; int ret; =20 - ret =3D regmap_read_bypassed(regmap, INA226_MASK_ENABLE, ®val); + ret =3D regmap_read_bypassed(data->regmap, INA226_MASK_ENABLE, ®val); if (ret) return ret; =20 @@ -516,9 +516,9 @@ static int ina2xx_in_read(struct device *dev, u32 attr,= int channel, long *val) return ina226_alert_limit_read(data, over_voltage_mask, voltage_reg, val); case hwmon_in_lcrit_alarm: - return ina226_alert_read(regmap, under_voltage_mask, val); + return ina226_alert_read(data, under_voltage_mask, val); case hwmon_in_crit_alarm: - return ina226_alert_read(regmap, over_voltage_mask, val); + return ina226_alert_read(data, over_voltage_mask, val); default: return -EOPNOTSUPP; } @@ -573,7 +573,7 @@ static int ina2xx_power_read(struct device *dev, u32 at= tr, long *val) return ina226_alert_limit_read(data, INA226_POWER_OVER_LIMIT_MASK, INA2XX_POWER, val); case hwmon_power_crit_alarm: - return ina226_alert_read(data->regmap, INA226_POWER_OVER_LIMIT_MASK, val= ); + return ina226_alert_read(data, INA226_POWER_OVER_LIMIT_MASK, val); default: return -EOPNOTSUPP; } @@ -615,9 +615,9 @@ static int ina2xx_curr_read(struct device *dev, u32 att= r, long *val) return ina226_alert_limit_read(data, INA226_SHUNT_OVER_VOLTAGE_MASK, INA2XX_CURRENT, val); case hwmon_curr_lcrit_alarm: - return ina226_alert_read(regmap, INA226_SHUNT_UNDER_VOLTAGE_MASK, val); + return ina226_alert_read(data, INA226_SHUNT_UNDER_VOLTAGE_MASK, val); case hwmon_curr_crit_alarm: - return ina226_alert_read(regmap, INA226_SHUNT_OVER_VOLTAGE_MASK, val); + return ina226_alert_read(data, INA226_SHUNT_OVER_VOLTAGE_MASK, val); default: return -EOPNOTSUPP; } --=20 2.55.0 From nobody Mon Sep 28 14:48:34 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E085D43B6D9 for ; Thu, 20 Aug 2026 13:10:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231410; cv=none; b=C2nXSXrNxzASCaMYdWQIZGgdrJ81TydkMLtYqsHNrkTex8eqf2EwGtzEQCP0IQ1kphO4D2kqOGfUlRAE1tQvoMT4Hc6/7x9EK8wpzAfuH1QNfMIQEvAhOKcBBTUnosq0Zb+Ij5PLWliS3WMab50CbbLbQwD71KiOf1b/ZAgAvB0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231410; c=relaxed/simple; bh=Qw0OCF/A3/1KKsA18JpyAkWi2gHh2HovZ6Y84Ie5Uy4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=U9gHSdC/kwGg05lJfUchulqOQ5l1QKSJJE7E8sKIT5Au6nmDcKP6Jg+Ug7tXkPrgB7rntm6KecMKClQA8YeJsRLxZY2PGKZiOL2CEx5QirCm5So7y+ilgU8QzVNwymPmSe7yAhqyEhGqsAGnKscbCgo75TZqNBLyS1k84oIgMuw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=d7FuusW4; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b=Y7kcEBIV; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="d7FuusW4"; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b="Y7kcEBIV" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1787231405; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=xCvjgT2AUAkiOr3ryVhwGHHtYFMb13hihrneybz56Ow=; b=d7FuusW4v+dBnRMK6fyUME7WK35HZnx7E5ghr/A1GUcfxMA9YFHWtViqG/VJK4eVtqua/t tmyiepvKrwgDiVSYEh+2dTqjwCJQiV/fbLxSvnQJ0YDmiIWHKY9MDXmskihOHK/jKzmn5P FCnPyPksjIsRxEMOniNL2nFc5LwBvbE= Received: from mail-qk1-f200.google.com (mail-qk1-f200.google.com [209.85.222.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-386-bkXEO2fENemOwfqdFsZcOQ-1; Thu, 20 Aug 2026 09:10:04 -0400 X-MC-Unique: bkXEO2fENemOwfqdFsZcOQ-1 X-Mimecast-MFC-AGG-ID: bkXEO2fENemOwfqdFsZcOQ_1787231404 Received: by mail-qk1-f200.google.com with SMTP id af79cd13be357-936e393061dso206235985a.2 for ; Thu, 20 Aug 2026 06:10:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=google; t=1787231404; x=1787836204; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=xCvjgT2AUAkiOr3ryVhwGHHtYFMb13hihrneybz56Ow=; b=Y7kcEBIVJMVT3VC0apLMUcW+/m+R43lWFWc/WT1BByyotDxIXdprO8ocsBgacrUH3p GnPqP+NCaZExPsc4ddfKlJWR3LGvjXmUoCq3bMNmaPqq10dc5wCheBrnM3DpaSXqDbj/ RTQprh8Gfr/wrC+agOb/54cnZpUbZcPMBLNjv+3QE+mS9H3qY9/s8+GXpBtSNSE56rQp 9E8F6Wf/ztD4geRw5QuBOAyTVRZAcaaORQCWkyn/jD1ae6hSBvAe8Vc3ae+NuoT6qX6K sTEhZx/QWpk0tcxow6Whlf51h5qKidRamx+LD3DcKa2/7jEp/ZyDfX5GQf9jG5if0eI3 gZ4w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787231404; x=1787836204; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=xCvjgT2AUAkiOr3ryVhwGHHtYFMb13hihrneybz56Ow=; b=lKtyATbbn1/FLke2tp/GzZ+BN5MQGsrdmi3tcCQg8rW+d8dr74ss74WEHhn/UYT+Lr twuEU/etRYrb8Kg7FKoA3+Tx/NNxzPRrXAIOrvZmiwwSt398mZLVqnq2AOVlVqvDWA6/ G08QyhkFUd/WF+8OwjfdazA9D5LnxiHI2M1AuX9hFD6B20kbrgw6+NqrxaAP2/x596pK 3Am7BmAysEuahG8+ONyIYS6n1SeOQeKzg8Ko2YRfve8D4M7fV5Plbhz9sV5AaTWHCwhK 5d0pvpnPEV7x9XI4gdL/C5IxBePcRGjRZpiAnBdaHVe0Wzxt3eovkKYOm8NJMO9EfGlX sZYA== X-Forwarded-Encrypted: i=1; AHgh+RoWQ3vDt3ZcGe4Slg8sGaOfjIKA5sYfdY6UcQiDBLa1Rr2+EzCEu5fRy39DX0TDEaEiCfuKRQz4Jrj7cko=@vger.kernel.org X-Gm-Message-State: AOJu0YyooJzXlO++nkN11zgvDrmj+jtCaqk0BArKd9X2gpxQlHj1iEgy 5Bg6hOofKLUMSrKTkUAzayA8FsFBfoC7axoT2lmQ40kpW6jzdw4QR/auasByGRD5MiFIIjCOsDa 2e0vZHhGmmIp1IqM+K2sH+qOgZs/pyOWrNF56t+CsJUtcWUk6YDJPgcndiykuj28siZ7sjaCTFA == X-Gm-Gg: AR+sD12SLJyuMOxgrNuFlmp4AzG4r6/MN33vs4I1qbdo/CzzeeXhqqdU2CtQ3AgH7ux fTv2Q3SP3wnjc5yIOmSGcjpuOkicYP+INizx2k8KAvSkM9g18JCkaz6EHZwCKGaq5GpayjCcrUO imqphLDpENTgO3Hz8xCPLWCmsrfVqW8Om/xBvxRdb6Sk32EzakqIdag3OP/LgJsSJ5pLuZXKx73 es83HigNx98iIfw9j1VAE8NOoJXdQutIB6j2q464vMfrnTJQDtF1bjCFgp+RspBq9G3h4QPWr+B l8vCK6ZlwwX6QbwYIT4uQPTcdmTN9+b2W5vKKe4VFgMo1jtaMeH9HesGSMTx25QSNLKZNIUB5dV AoC5EdUNWJxu7wNgXlGpHo49689tufDCv X-Received: by 2002:a05:620a:4107:b0:936:a5c3:512f with SMTP id af79cd13be357-9371e3147b6mr948841285a.34.1787231403523; Thu, 20 Aug 2026 06:10:03 -0700 (PDT) X-Received: by 2002:a05:620a:4107:b0:936:a5c3:512f with SMTP id af79cd13be357-9371e3147b6mr948832985a.34.1787231402868; Thu, 20 Aug 2026 06:10:02 -0700 (PDT) Received: from jkangas-thinkpadp1gen3.rmtuswa.csb ([2601:1c2:4480:2110:932e:45ef:6b6c:ddd0]) by smtp.gmail.com with ESMTPSA id af79cd13be357-937204ba087sm364217985a.21.2026.08.20.06.10.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Aug 2026 06:10:02 -0700 (PDT) From: Jared Kangas Date: Thu, 20 Aug 2026 06:09:23 -0700 Subject: [PATCH v2 3/4] hwmon: (ina2xx) Replace masks with enum in alert functions Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-3-fdce35abc41e@redhat.com> References: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> In-Reply-To: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> To: Guenter Roeck , Tzung-Bi Shih , Lothar Felten Cc: linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org, Jared Kangas X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1787231395; l=8705; i=jkangas@redhat.com; s=20251111; h=from:subject:message-id; bh=Qw0OCF/A3/1KKsA18JpyAkWi2gHh2HovZ6Y84Ie5Uy4=; b=gY9Jlx/sztiPgE0PYZQzwyGhp5SkDswfQRZJmf6g5gg6DN0HM5hjIXuH22vj2858rdqdRqqb/ QjXytk8quLcCsCQtoYiI4ykIaFCX0wls072bBzJcqw8mTqtg9ClRwPf X-Developer-Key: i=jkangas@redhat.com; a=ed25519; pk=eFM2Mqcfarb4qox390655bUATO0fG9gwgaw7kGmOEZQ= Instead of passing an explicit mask to alert/limit functions like ina226_alert_read(), introduce an enum ina2xx_alert_type that can be converted to a mask internally. This semantically separates current from shunt voltage in helpers that use function masks, which previously saw the same mask for the two functions. Signed-off-by: Jared Kangas --- drivers/hwmon/ina2xx.c | 90 +++++++++++++++++++++++++++++++++++++---------= ---- 1 file changed, 67 insertions(+), 23 deletions(-) diff --git a/drivers/hwmon/ina2xx.c b/drivers/hwmon/ina2xx.c index c56e42432673f..74c4e3795ac4d 100644 --- a/drivers/hwmon/ina2xx.c +++ b/drivers/hwmon/ina2xx.c @@ -127,6 +127,17 @@ enum ina2xx_ids { sy24655 }; =20 +enum ina2xx_alert_type { + INA2XX_ALERT_NONE, + INA2XX_ALERT_CURRENT_LOW, + INA2XX_ALERT_CURRENT_HIGH, + INA2XX_ALERT_POWER_HIGH, + INA2XX_ALERT_BUS_VOLTAGE_LOW, + INA2XX_ALERT_BUS_VOLTAGE_HIGH, + INA2XX_ALERT_SHUNT_VOLTAGE_LOW, + INA2XX_ALERT_SHUNT_VOLTAGE_HIGH, +}; + struct ina2xx_config { u16 config_default; bool has_alerts; /* chip supports alerts and limits */ @@ -406,16 +417,43 @@ static u16 ina226_alert_to_reg(struct ina2xx_data *da= ta, int reg, long val) } } =20 -static int ina226_alert_limit_read(struct ina2xx_data *data, u32 mask, int= reg, long *val) +static u32 ina2xx_alert_type_to_mask(enum ina2xx_alert_type alert) +{ + switch (alert) { + case INA2XX_ALERT_CURRENT_LOW: + case INA2XX_ALERT_SHUNT_VOLTAGE_LOW: + return INA226_SHUNT_UNDER_VOLTAGE_MASK; + case INA2XX_ALERT_CURRENT_HIGH: + case INA2XX_ALERT_SHUNT_VOLTAGE_HIGH: + return INA226_SHUNT_OVER_VOLTAGE_MASK; + case INA2XX_ALERT_BUS_VOLTAGE_LOW: + return INA226_BUS_UNDER_VOLTAGE_MASK; + case INA2XX_ALERT_BUS_VOLTAGE_HIGH: + return INA226_BUS_OVER_VOLTAGE_MASK; + case INA2XX_ALERT_POWER_HIGH: + return INA226_POWER_OVER_LIMIT_MASK; + case INA2XX_ALERT_NONE: + return 0; + default: + /* programmer error */ + WARN_ON_ONCE(1); + return 0; + } +} + +static int ina226_alert_limit_read(struct ina2xx_data *data, enum ina2xx_a= lert_type alert, + int reg, long *val) { struct regmap *regmap =3D data->regmap; int regval; + u32 mask; int ret; =20 ret =3D regmap_read(regmap, INA226_MASK_ENABLE, ®val); if (ret) return ret; =20 + mask =3D ina2xx_alert_type_to_mask(alert); if (regval & mask) { ret =3D regmap_read(regmap, INA226_ALERT_LIMIT, ®val); if (ret) @@ -427,9 +465,11 @@ static int ina226_alert_limit_read(struct ina2xx_data = *data, u32 mask, int reg, return 0; } =20 -static int ina226_alert_limit_write(struct ina2xx_data *data, u32 mask, in= t reg, long val) +static int ina226_alert_limit_write(struct ina2xx_data *data, enum ina2xx_= alert_type alert, + int reg, long val) { struct regmap *regmap =3D data->regmap; + u32 mask; int ret; =20 if (val < 0) @@ -450,9 +490,11 @@ static int ina226_alert_limit_write(struct ina2xx_data= *data, u32 mask, int reg, if (ret < 0) return ret; =20 - if (val) + if (val) { + mask =3D ina2xx_alert_type_to_mask(alert); return regmap_update_bits(regmap, INA226_MASK_ENABLE, INA226_ALERT_CONFIG_MASK, mask); + } return 0; } =20 @@ -476,15 +518,17 @@ static int ina2xx_chip_read(struct device *dev, u32 a= ttr, long *val) return 0; } =20 -static int ina226_alert_read(struct ina2xx_data *data, u32 mask, long *val) +static int ina226_alert_read(struct ina2xx_data *data, enum ina2xx_alert_t= ype alert, long *val) { unsigned int regval; + u32 mask; int ret; =20 ret =3D regmap_read_bypassed(data->regmap, INA226_MASK_ENABLE, ®val); if (ret) return ret; =20 + mask =3D ina2xx_alert_type_to_mask(alert); *val =3D (regval & mask) && (regval & INA226_ALERT_FUNCTION_FLAG); =20 return 0; @@ -493,10 +537,10 @@ static int ina226_alert_read(struct ina2xx_data *data= , u32 mask, long *val) static int ina2xx_in_read(struct device *dev, u32 attr, int channel, long = *val) { int voltage_reg =3D channel ? INA2XX_BUS_VOLTAGE : INA2XX_SHUNT_VOLTAGE; - u32 under_voltage_mask =3D channel ? INA226_BUS_UNDER_VOLTAGE_MASK - : INA226_SHUNT_UNDER_VOLTAGE_MASK; - u32 over_voltage_mask =3D channel ? INA226_BUS_OVER_VOLTAGE_MASK - : INA226_SHUNT_OVER_VOLTAGE_MASK; + enum ina2xx_alert_type under_voltage_alert =3D channel ? INA2XX_ALERT_BUS= _VOLTAGE_LOW + : INA2XX_ALERT_SHUNT_VOLTAGE_LOW; + enum ina2xx_alert_type over_voltage_alert =3D channel ? INA2XX_ALERT_BUS_= VOLTAGE_HIGH + : INA2XX_ALERT_SHUNT_VOLTAGE_HIGH; struct ina2xx_data *data =3D dev_get_drvdata(dev); struct regmap *regmap =3D data->regmap; unsigned int regval; @@ -510,15 +554,15 @@ static int ina2xx_in_read(struct device *dev, u32 att= r, int channel, long *val) *val =3D ina2xx_get_value(data, voltage_reg, regval); break; case hwmon_in_lcrit: - return ina226_alert_limit_read(data, under_voltage_mask, + return ina226_alert_limit_read(data, under_voltage_alert, voltage_reg, val); case hwmon_in_crit: - return ina226_alert_limit_read(data, over_voltage_mask, + return ina226_alert_limit_read(data, over_voltage_alert, voltage_reg, val); case hwmon_in_lcrit_alarm: - return ina226_alert_read(data, under_voltage_mask, val); + return ina226_alert_read(data, under_voltage_alert, val); case hwmon_in_crit_alarm: - return ina226_alert_read(data, over_voltage_mask, val); + return ina226_alert_read(data, over_voltage_alert, val); default: return -EOPNOTSUPP; } @@ -570,10 +614,10 @@ static int ina2xx_power_read(struct device *dev, u32 = attr, long *val) case hwmon_power_average: return sy24655_average_power_read(data, SY24655_EIN, val); case hwmon_power_crit: - return ina226_alert_limit_read(data, INA226_POWER_OVER_LIMIT_MASK, + return ina226_alert_limit_read(data, INA2XX_ALERT_POWER_HIGH, INA2XX_POWER, val); case hwmon_power_crit_alarm: - return ina226_alert_read(data, INA226_POWER_OVER_LIMIT_MASK, val); + return ina226_alert_read(data, INA2XX_ALERT_POWER_HIGH, val); default: return -EOPNOTSUPP; } @@ -609,15 +653,15 @@ static int ina2xx_curr_read(struct device *dev, u32 a= ttr, long *val) *val =3D ina2xx_get_value(data, INA2XX_CURRENT, regval); return 0; case hwmon_curr_lcrit: - return ina226_alert_limit_read(data, INA226_SHUNT_UNDER_VOLTAGE_MASK, + return ina226_alert_limit_read(data, INA2XX_ALERT_CURRENT_LOW, INA2XX_CURRENT, val); case hwmon_curr_crit: - return ina226_alert_limit_read(data, INA226_SHUNT_OVER_VOLTAGE_MASK, + return ina226_alert_limit_read(data, INA2XX_ALERT_CURRENT_HIGH, INA2XX_CURRENT, val); case hwmon_curr_lcrit_alarm: - return ina226_alert_read(data, INA226_SHUNT_UNDER_VOLTAGE_MASK, val); + return ina226_alert_read(data, INA2XX_ALERT_CURRENT_LOW, val); case hwmon_curr_crit_alarm: - return ina226_alert_read(data, INA226_SHUNT_OVER_VOLTAGE_MASK, val); + return ina226_alert_read(data, INA2XX_ALERT_CURRENT_HIGH, val); default: return -EOPNOTSUPP; } @@ -661,12 +705,12 @@ static int ina2xx_in_write(struct device *dev, u32 at= tr, int channel, long val) switch (attr) { case hwmon_in_lcrit: return ina226_alert_limit_write(data, - channel ? INA226_BUS_UNDER_VOLTAGE_MASK : INA226_SHUNT_UNDER_VOLTAGE_MA= SK, + channel ? INA2XX_ALERT_BUS_VOLTAGE_LOW : INA2XX_ALERT_SHUNT_VOLTAGE_LOW, channel ? INA2XX_BUS_VOLTAGE : INA2XX_SHUNT_VOLTAGE, val); case hwmon_in_crit: return ina226_alert_limit_write(data, - channel ? INA226_BUS_OVER_VOLTAGE_MASK : INA226_SHUNT_OVER_VOLTAGE_MASK, + channel ? INA2XX_ALERT_BUS_VOLTAGE_HIGH : INA2XX_ALERT_SHUNT_VOLTAGE_HI= GH, channel ? INA2XX_BUS_VOLTAGE : INA2XX_SHUNT_VOLTAGE, val); default: @@ -681,7 +725,7 @@ static int ina2xx_power_write(struct device *dev, u32 a= ttr, long val) =20 switch (attr) { case hwmon_power_crit: - return ina226_alert_limit_write(data, INA226_POWER_OVER_LIMIT_MASK, + return ina226_alert_limit_write(data, INA2XX_ALERT_POWER_HIGH, INA2XX_POWER, val); default: return -EOPNOTSUPP; @@ -695,10 +739,10 @@ static int ina2xx_curr_write(struct device *dev, u32 = attr, long val) =20 switch (attr) { case hwmon_curr_lcrit: - return ina226_alert_limit_write(data, INA226_SHUNT_UNDER_VOLTAGE_MASK, + return ina226_alert_limit_write(data, INA2XX_ALERT_CURRENT_LOW, INA2XX_CURRENT, val); case hwmon_curr_crit: - return ina226_alert_limit_write(data, INA226_SHUNT_OVER_VOLTAGE_MASK, + return ina226_alert_limit_write(data, INA2XX_ALERT_CURRENT_HIGH, INA2XX_CURRENT, val); default: return -EOPNOTSUPP; --=20 2.55.0 From nobody Mon Sep 28 14:48:34 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2F1263E44EB for ; Thu, 20 Aug 2026 13:10:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231420; cv=none; b=XHTigYJKYs40ddlwqxo4MVrj/SuCyQDIjmgSqSYlxKIzd2DwSW/oVzToi3TopARQI9Cb1pmMJCRLpQESx/QzQytUPLPOop/BqpSI8GkoY4QWIav9ADmYTp5aXhBAWrZ6LJiLz37fljsxNFEe63BMip9r6DK9umPxYpR6AXSfh14= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1787231420; c=relaxed/simple; bh=vgQfvi+yC13NqVyawNzNE70kFPEC4ei33oSh78KY4r8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=jWRc++wwkV9Qm9CmiVXYXm2ThczF4qnHw+3mCsGVndhqR2zk0E0sxj8cHWWBPiBy8GAlSgEJ9VkVH2RI+FpImeV93yQvBMOYm+R+Msmf50+xXZhmSygJfrbwGtKgr1H2WdB2gtM9EW3aeWHBaZeq6+r2PL6ahfHLlGDqLMjYcAU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=gYxHdZsx; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b=YFOKkunZ; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="gYxHdZsx"; dkim=pass (2048-bit key) header.d=redhat.com header.i=@redhat.com header.b="YFOKkunZ" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1787231417; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=lINEEJ3xppDZS4I+PwwVsfMXDswly1pvwvp6jcZunJ0=; b=gYxHdZsxLevL55FsmKgxuQy/LibrDRnG/FsfQA4CHDsceghfGanC7N18l0x96QGrb6LUaE P6p9tM2+j02KURr3zxGY+t1nruk1rW8EkpsRS9v/V8myVBv3Hg/gRqDB8qWNpuvdd2Jfau GxWu0cVFnotDVybPmQw38PWDSrpFRww= Received: from mail-qv1-f72.google.com (mail-qv1-f72.google.com [209.85.219.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-43-vQEaGSj9NBeLJL5LDCh68w-1; Thu, 20 Aug 2026 09:10:06 -0400 X-MC-Unique: vQEaGSj9NBeLJL5LDCh68w-1 X-Mimecast-MFC-AGG-ID: vQEaGSj9NBeLJL5LDCh68w_1787231405 Received: by mail-qv1-f72.google.com with SMTP id 6a1803df08f44-8eac2620cb0so26167216d6.3 for ; Thu, 20 Aug 2026 06:10:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=google; t=1787231405; x=1787836205; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=lINEEJ3xppDZS4I+PwwVsfMXDswly1pvwvp6jcZunJ0=; b=YFOKkunZEecQt4yJKEdusdieGlHqvHir3fUvHQAGIUjmjviNgzrhkFilQS/scq46CX 68e736XB5e20vYc1qLCX5Tm9kDvk/IkMp1HtLZ+DQhB0k9XWmRgxVsBZUPDZKCh4GG94 l51HySjgFXiHvD8pyi1M80aAFB1/IaQRJ/2hmHwrsPRQweyn9f+4zPkXwKYPt54p3aRf nL6y4a9tMlZ53WD8ZUVi+lZbYZB000N1d8nSSAdZFRSSX1/9bqj4S4qqdQt64ImbZBfU sPs4PqPUF1uXjYzv1ginMSTHTr+k1cCYlfJBWuPQi6erPvRCvmGD8D0uvuazfKEVh+d8 a6Eg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1787231405; x=1787836205; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=lINEEJ3xppDZS4I+PwwVsfMXDswly1pvwvp6jcZunJ0=; b=HZdZdnrUqZIqRYVl7z3fm5oab3wAW/FUnPhxNBGqIfPQLvrCKWMHBRra+QFsaxi5Ug Fo/DyXAioGPyVlVV7vG9U7dRPLDArQeGwH8bRdIWMq+DqZutRGPM2cg5I8Tx/l6AlaWt uSyU3breo6coI5NJvrLWV1QnUIPpBZjAamZLl3cEu+lZiCcUZJ85PMKUyhv1b+BO2mXG /CNVGhT6Th024jlOWNLjXv+z7dDT4kmvzUT4HyPk07NB/JvB18SXjyAwevxiBjTTbP9T eThnfKIhnRtLXYDArEUHaSmyvlvfQ80M96A1D/e7jUTYjq46TbsfMMxz+Ok8lDsKgoEh r+KA== X-Forwarded-Encrypted: i=1; AHgh+RpAqMI4LDKmMf/1Vld1OYWhHY7orGhkR7G6UfjQ96VXwXhk9zliMAC5RpwbhplePDVOCKQXCtyoZs09ZGA=@vger.kernel.org X-Gm-Message-State: AOJu0YxjNNsuIQSGoBdiWepxVsXwJVA4214cV8nL7A94vx/RH+InFy+Y ymv9p0e7EOZ8VrGyAtYQUHnYdp8eyILfrfecmm7NuFSadOT4V9fSF5GmThjxbJSE56JsPX7ECLY nMIvrFHhUC15dtz5TIJxmd9Y1YJbNgOPCMNtSHbRQfEcFJlQll8+Tpv2GHkT29c6xdSDrBEbC3Q == X-Gm-Gg: AR+sD10J8YuG6KgR8WQdQx59JgWrWiL2lFW19u/y3GYj0rKGHyJ52CmeTl3IQGQZ0cy 96m56dmnH8vVOUsogG00YSrsWQ5nlcxn+Z8Y+kwKstUDDsz0YlyDTKmjNeUtUqsn6I1VcegJcJf w1KiHobja0zcHQNwo5h35DgGT/UCGgHuC0MDk0ktRpdCqka3kd6DPJgz4mr9/O9eRVWKIc3+ln+ Jxn66dRo7yorIRU+TFwsoMPCDPT7zeZjWlRwTwA3qXfzxuLDBZd6I8N1A/yejTwAh8I0T7XU6Bh GqyXh0nUsXF8OsikddYpPWRkg2Y/PxhWEBzjo7MgEiWUcoNjTLLWCd228QKXgjfFS/szbYxFSgk UsFnCYIo+SUzLf9iNJrI5Hxs0UL4NJgJL X-Received: by 2002:a05:620a:28d3:b0:92e:4bc9:6ea9 with SMTP id af79cd13be357-9371e11093bmr1084088385a.0.1787231404980; Thu, 20 Aug 2026 06:10:04 -0700 (PDT) X-Received: by 2002:a05:620a:28d3:b0:92e:4bc9:6ea9 with SMTP id af79cd13be357-9371e11093bmr1084077685a.0.1787231404459; Thu, 20 Aug 2026 06:10:04 -0700 (PDT) Received: from jkangas-thinkpadp1gen3.rmtuswa.csb ([2601:1c2:4480:2110:932e:45ef:6b6c:ddd0]) by smtp.gmail.com with ESMTPSA id af79cd13be357-937204ba087sm364217985a.21.2026.08.20.06.10.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 20 Aug 2026 06:10:04 -0700 (PDT) From: Jared Kangas Date: Thu, 20 Aug 2026 06:09:24 -0700 Subject: [PATCH v2 4/4] hwmon: (ina2xx) Decouple in0 and curr1 alarms Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-4-fdce35abc41e@redhat.com> References: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> In-Reply-To: <20260820-upstream-ina2xx-in0-curr1-alarms-v2-0-fdce35abc41e@redhat.com> To: Guenter Roeck , Tzung-Bi Shih , Lothar Felten Cc: linux-hwmon@vger.kernel.org, linux-kernel@vger.kernel.org, Jared Kangas X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1787231395; l=6599; i=jkangas@redhat.com; s=20251111; h=from:subject:message-id; bh=vgQfvi+yC13NqVyawNzNE70kFPEC4ei33oSh78KY4r8=; b=vjhFRJgs5WRVjw6P7wcx/TldbJCkzsiNByLYu6BKRt6JKlqANd0OIY2M30a8U6yx3HuprgsHp +N/LbC3udRPAq9onzuhRXZqzn7QAMQI7rbl1PIdgyIoF7aVgZqpX3LM X-Developer-Key: i=jkangas@redhat.com; a=ed25519; pk=eFM2Mqcfarb4qox390655bUATO0fG9gwgaw7kGmOEZQ= INA2XX current limits are converted into shunt voltage limits internally using the shunt resistor value. Once a current limit's corresponding voltage limit is written to the hardware, shunt voltage and current alarms are indistinguishable from each other. This causes two issues: 1. in0/curr1 alarms may be unintentionally cleared by reading from the opposite input's alarm. 2. When a limit for either in0 (shunt voltage) or curr1 (current) is set, both of their alarms are triggered, and both of their limits read nonzero. An example of this behavior on an INA231: # cd /sys/class/hwmon/hwmon0 # head {curr1,in0}_input =3D=3D> curr1_input <=3D=3D 1713 =3D=3D> in0_input <=3D=3D 2 # echo 1800 >curr1_lcrit # head {curr1,in0}_lcrit_alarm =3D=3D> curr1_lcrit_alarm <=3D=3D 1 =3D=3D> in0_lcrit_alarm <=3D=3D 0 # head {in0,curr1}_lcrit_alarm =3D=3D> in0_lcrit_alarm <=3D=3D 1 =3D=3D> curr1_lcrit_alarm <=3D=3D 0 # head {in0,curr1}_lcrit_alarm =3D=3D> in0_lcrit_alarm <=3D=3D 1 =3D=3D> curr1_lcrit_alarm <=3D=3D 1 This is because curr1 uses the same underlying masks (INA226_SHUNT_*_VOLTAGE_MASK) as in0 on the hardware. As a result, ina2xx_{curr,in}_read() both read the shunt voltage alarms/limits without considering whether the voltage or current is currently set. To fix this, track the active alarm type in ina2xx_data and guard alarm/limit reads with a check that returns zero if the active alarm is for a different type. The new field is initialized based on the MASK_ENABLE register's set function, assuming voltage instead of current when the shunt voltage mask is set. After this fix, the alarms only read back 1 if their corresponding limit is set: # echo 0 >curr1_lcrit # head {curr1,in0}_lcrit_alarm =3D=3D> curr1_lcrit_alarm <=3D=3D 0 =3D=3D> in0_lcrit_alarm <=3D=3D 0 # echo 9999 >curr1_lcrit # head {curr1,in0}_lcrit_alarm =3D=3D> curr1_lcrit_alarm <=3D=3D 1 =3D=3D> in0_lcrit_alarm <=3D=3D 0 # echo 9999 >in0_lcrit # head {curr1,in0}_lcrit_alarm =3D=3D> curr1_lcrit_alarm <=3D=3D 0 =3D=3D> in0_lcrit_alarm <=3D=3D 1 Fixes: 4d5c2d986757 ("hwmon: (ina2xx) Add support for current limits") Signed-off-by: Jared Kangas --- drivers/hwmon/ina2xx.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++= ++-- 1 file changed, 63 insertions(+), 2 deletions(-) diff --git a/drivers/hwmon/ina2xx.c b/drivers/hwmon/ina2xx.c index 74c4e3795ac4d..7e5b412ff47f2 100644 --- a/drivers/hwmon/ina2xx.c +++ b/drivers/hwmon/ina2xx.c @@ -8,6 +8,7 @@ */ =20 #include +#include #include #include #include @@ -157,6 +158,7 @@ struct ina2xx_data { const struct ina2xx_config *config; enum ina2xx_ids chip; =20 + enum ina2xx_alert_type active_alert; long rshunt; long current_lsb_uA; long power_lsb_uW; @@ -441,6 +443,35 @@ static u32 ina2xx_alert_type_to_mask(enum ina2xx_alert= _type alert) } } =20 +static enum ina2xx_alert_type ina2xx_mask_to_alert_type(u32 mask) +{ + int top_bit =3D fls(mask & INA226_ALERT_CONFIG_MASK); + + if (!top_bit) + return INA2XX_ALERT_NONE; + + /* + * Multiple bits may be set, with the highest-set function taking + * precedence according to the datasheet. Shunt voltage masks are + * assumed to map to voltage monitoring rather than current monitoring, + * since the latter isn't directly implemented in the hardware. + */ + switch (BIT(top_bit - 1)) { + case INA226_SHUNT_OVER_VOLTAGE_MASK: + return INA2XX_ALERT_SHUNT_VOLTAGE_HIGH; + case INA226_SHUNT_UNDER_VOLTAGE_MASK: + return INA2XX_ALERT_SHUNT_VOLTAGE_LOW; + case INA226_BUS_OVER_VOLTAGE_MASK: + return INA2XX_ALERT_BUS_VOLTAGE_HIGH; + case INA226_BUS_UNDER_VOLTAGE_MASK: + return INA2XX_ALERT_BUS_VOLTAGE_LOW; + case INA226_POWER_OVER_LIMIT_MASK: + return INA2XX_ALERT_POWER_HIGH; + default: + return INA2XX_ALERT_NONE; + } +} + static int ina226_alert_limit_read(struct ina2xx_data *data, enum ina2xx_a= lert_type alert, int reg, long *val) { @@ -449,6 +480,12 @@ static int ina226_alert_limit_read(struct ina2xx_data = *data, enum ina2xx_alert_t u32 mask; int ret; =20 + /* Avoid nonzero reads from inactive alerts caused by shared limit regist= er */ + if (data->active_alert !=3D alert) { + *val =3D 0; + return 0; + } + ret =3D regmap_read(regmap, INA226_MASK_ENABLE, ®val); if (ret) return ret; @@ -484,6 +521,7 @@ static int ina226_alert_limit_write(struct ina2xx_data = *data, enum ina2xx_alert_ INA226_ALERT_CONFIG_MASK, 0); if (ret < 0) return ret; + data->active_alert =3D INA2XX_ALERT_NONE; =20 ret =3D regmap_write(regmap, INA226_ALERT_LIMIT, ina226_alert_to_reg(data, reg, val)); @@ -492,9 +530,13 @@ static int ina226_alert_limit_write(struct ina2xx_data= *data, enum ina2xx_alert_ =20 if (val) { mask =3D ina2xx_alert_type_to_mask(alert); - return regmap_update_bits(regmap, INA226_MASK_ENABLE, - INA226_ALERT_CONFIG_MASK, mask); + ret =3D regmap_update_bits(regmap, INA226_MASK_ENABLE, + INA226_ALERT_CONFIG_MASK, mask); + if (ret < 0) + return ret; + data->active_alert =3D alert; } + return 0; } =20 @@ -524,6 +566,15 @@ static int ina226_alert_read(struct ina2xx_data *data,= enum ina2xx_alert_type al u32 mask; int ret; =20 + /* + * With alert latching, reading alerts from hardware also clears the + * alert, so return early if the alert is inactive. + */ + if (data->active_alert !=3D alert) { + *val =3D 0; + return 0; + } + ret =3D regmap_read_bypassed(data->regmap, INA226_MASK_ENABLE, ®val); if (ret) return ret; @@ -964,6 +1015,16 @@ static int ina2xx_init(struct device *dev, struct ina= 2xx_data *data) =20 if (data->config->has_alerts) { bool active_high =3D device_property_read_bool(dev, "ti,alert-polarity-a= ctive-high"); + unsigned int mask_enable; + + /* + * Infer active alert from MASK_ENABLE in case it's already + * configured (e.g., by a past probe or firmware) + */ + ret =3D regmap_read(regmap, INA226_MASK_ENABLE, &mask_enable); + if (ret < 0) + return ret; + data->active_alert =3D ina2xx_mask_to_alert_type(mask_enable); =20 regmap_update_bits(regmap, INA226_MASK_ENABLE, INA226_ALERT_LATCH_ENABLE | INA226_ALERT_POLARITY, --=20 2.55.0