From nobody Sun Feb 8 15:30:53 2026 Received: from mx0a-00128a01.pphosted.com (mx0a-00128a01.pphosted.com [148.163.135.77]) (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 E6EAD3016E1; Tue, 6 Jan 2026 05:27:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=148.163.135.77 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767677254; cv=none; b=bdds27LFMTtVogG+rRVKCnHLX7XIrMSlnQM+2E51t3sCnyzF5fSajPp0lh0hFysJ/zUrq5aoltyWVfgRaiIwzFLNvhvPl26IuIUawDI42K6zXhGTKbuZh/G8N1Le9jTGsk7Vsw5AbnSye1paAw2t90B/WYLErQMgqPy8EaNg+K0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767677254; c=relaxed/simple; bh=wWy6XVXMKyoNbVQDkJjitMOVNd+SXWPueKiMQhemg5I=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=AvqBlVd4Z62Ol4wqMRHyDnWnFu66Rf8HpqzV23ia68VHupPAJBpgELhuPtEhl7uamB6D6+t1wXk99BtTOS3giyRF09/igeLfNbFLq0lIp9ZeXirMc+yow9RzKL28RpJ9T0KWS3n13sNp8JnqXlx0LWhL3WZ8e2noTLIWr+5vCw4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=analog.com; spf=pass smtp.mailfrom=analog.com; dkim=pass (2048-bit key) header.d=analog.com header.i=@analog.com header.b=kf09v8fl; arc=none smtp.client-ip=148.163.135.77 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=analog.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=analog.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=analog.com header.i=@analog.com header.b="kf09v8fl" Received: from pps.filterd (m0167088.ppops.net [127.0.0.1]) by mx0a-00128a01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 6064UCNe2428927; Tue, 6 Jan 2026 00:27:30 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=analog.com; h=cc :content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=DKIM; bh=PQswp 2UQ2H2bPCddlObJerrfk/FFc4yjJhv0vFYytDs=; b=kf09v8flkj8rWUWujbQSx Mwj7BvSvPahNL91yDZn+a/2p12sTdsQuIlCINTU+EyrCfgAgpU2VVaX0O4K9nIk7 KZhzDI4RLLUXuZqsn+TkL4W1q4vkny3Y+4uU4DOu8cbI/uk6wQ+22S+xw/5i1Yvd O8i/cBdD5f4zz4GUPBg9ZKkKWsbXYawUTdh/JmIoxY1xhz7WPJ8yVud125K+pILv pWAkZFeCNb7Tz5GzbHKaKOPG5kDgk5RcTsR8bGeWuzmij0XRo4bbdHbNds7CIDL/ zCufwmwtrt88zv1x6mjVZRkA53Xe1pU3xCgAn0sdNhGrL7N3UHuzq7G1MAjjIwhy Q== Received: from nwd2mta4.analog.com ([137.71.173.58]) by mx0a-00128a01.pphosted.com (PPS) with ESMTPS id 4bggewk03w-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 06 Jan 2026 00:27:30 -0500 (EST) Received: from ASHBMBX9.ad.analog.com (ASHBMBX9.ad.analog.com [10.64.17.10]) by nwd2mta4.analog.com (8.14.7/8.14.7) with ESMTP id 6065RT6o021549 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Tue, 6 Jan 2026 00:27:29 -0500 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBMBX9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.37; Tue, 6 Jan 2026 00:27:28 -0500 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.1748.37 via Frontend Transport; Tue, 6 Jan 2026 00:27:28 -0500 Received: from HYB-7P5GeKnsiiX.ad.analog.com (HYB-7P5GeKnsiiX.ad.analog.com [10.118.4.58]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 6065RF6p016126; Tue, 6 Jan 2026 00:27:23 -0500 From: Edelweise Escala Date: Tue, 6 Jan 2026 13:27:07 +0800 Subject: [PATCH 1/2] dt-bindings: leds: Document LTC3220 18 channel LED Driver 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: <20260106-ltc3220-driver-v1-1-73601d6f1649@analog.com> References: <20260106-ltc3220-driver-v1-0-73601d6f1649@analog.com> In-Reply-To: <20260106-ltc3220-driver-v1-0-73601d6f1649@analog.com> To: Lee Jones , Pavel Machek , Rob Herring , Krzysztof Kozlowski , Conor Dooley CC: , , , Edelweise Escala X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1767677235; l=4811; i=edelweise.escala@analog.com; s=20260106; h=from:subject:message-id; bh=wWy6XVXMKyoNbVQDkJjitMOVNd+SXWPueKiMQhemg5I=; b=fbPDgYwxTwAFnXm4ZIJ63eqRtTYn0FaELVvH1SrUbY5WP7wqCooRXRwh2Mamkrf+HB9UPuGXK 6KhZlcmJfp/CIH7XMbC4/FKntG0kRKKWtwuYDVSXISPfhDSCsMrjeke X-Developer-Key: i=edelweise.escala@analog.com; a=ed25519; pk=lf5HLFe8ZeQjXZgkBkFMK+u9qH5/tqZhCIushTKduNQ= X-ADIRuleOP-NewSCL: Rule Triggered X-Authority-Analysis: v=2.4 cv=O+U0fR9W c=1 sm=1 tr=0 ts=695c9d42 cx=c_pps a=3WNzaoukacrqR9RwcOSAdA==:117 a=3WNzaoukacrqR9RwcOSAdA==:17 a=IkcTkHD0fZMA:10 a=vUbySO9Y5rIA:10 a=VkNPw1HP01LnGYTKEx00:22 a=gEfo2CItAAAA:8 a=gAnH3GRIAAAA:8 a=VwQbUJbxAAAA:8 a=aAgv4lQJR7UpHq8YIzQA:9 a=QEXdDO2ut3YA:10 a=x-rrmlpudb0A:10 a=V5hIW_BCtU8A:10 a=sptkURWiP4Gy88Gu7hUp:22 X-Proofpoint-ORIG-GUID: x3wwndvuS6Tdh-40RXdoW1dx5wd6caeV X-Proofpoint-GUID: x3wwndvuS6Tdh-40RXdoW1dx5wd6caeV X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMTA2MDA0MyBTYWx0ZWRfX/zKs1MYBXzPT NVmubOX+tn9d5KNAOf+dXAmRkfGndNzISVGtmXDNFfUQDVB+fN+HqzqBnAfKJlU/dJcWUZe19xJ Y132hs8TwH/znut6PKkbKmC7+S7vNehdx+dB3lUrzxRmNIsGzX1D8kq7eqrpobDDcbNXIUe6Zls JoEYK9OZvzPE+oXMh7YHRq1tpLbQGvXkrX6Z8hqzBajP2nPtfjhvyhVprDbuRFrGQlfD+swuVth rmpDfWr8YDNQQQHrPrPNKivjmVtdDyrASUDZZxQKa4eRvHIV/+VUJRFdtAQ0o7NNpCMRY+TdjzA sZvs/JdDTVWpVxINKWvmHFHUvK6Ho1wirUFXdzkpUjMIuaPVqQN57CFAB2KSfqVOZPFijwdyjWa IuVkkIxYY1gah7c4gp6WVlAL8VbqwD8R+lrJAC28jDtU4sCqbIre55374SVxn9UYuyCL+ZnK4eN 6js5zxh75GpQf7iYpZA== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.9,FMLib:17.12.100.49 definitions=2026-01-05_02,2026-01-05_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 bulkscore=0 impostorscore=0 suspectscore=0 phishscore=0 priorityscore=1501 malwarescore=0 lowpriorityscore=0 spamscore=0 clxscore=1011 adultscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2512120000 definitions=main-2601060043 Add dt-binding for ltc3220. LTC3220 18 Channel LED driver Signed-off-by: Edelweise Escala --- .../devicetree/bindings/leds/leds-ltc3220.yaml | 131 +++++++++++++++++= ++++ MAINTAINERS | 7 ++ 2 files changed, 138 insertions(+) diff --git a/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml b/Doc= umentation/devicetree/bindings/leds/leds-ltc3220.yaml new file mode 100644 index 000000000000..33285a7ac7a3 --- /dev/null +++ b/Documentation/devicetree/bindings/leds/leds-ltc3220.yaml @@ -0,0 +1,131 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/leds/leds-ltc3220.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Analog Devices LTC3220 LED Drivers + +maintainers: + - Edelweise Escala + +description: Bindings for the Analog Devices LTC3220 18 channel LED Driver= s. + + For more product information please see the link below + https://www.analog.com/en/products/ltc3220.html + +properties: + compatible: + enum: + - adi,ltc3220 + - adi,ltc3220-1 + + reg: + maxItems: 1 + + '#address-cells': + const: 1 + + '#size-cells': + const: 0 + + reset-gpios: + maxItems: 1 + description: GPIO attached to the chip's reset pin + + adi,force-cpo-level: + $ref: /schemas/types.yaml#/definitions/string + description: Forces the Charge Pump Output to a specified multiplier. + enum: + - "0" # Auto(default) - Automatically selects optimal charge pump mo= de + - "1.5" + - "2" + - "1" + default: "0" + + adi,quick-write: + type: boolean + description: If present, LED 1 output becomes a master control that + simultaneously updates all 18 LED outputs using the hardware's quick= -write + mode. When enabled, led@1 must be defined in the device tree to prov= ide + the control interface, even if no physical LED is connected to the D1 + output pin. When disabled or not present, LED 1 operates as a normal + independent LED output. + +patternProperties: + "^led@([1-9]|1[0-8])$": + type: object + $ref: /schemas/leds/common.yaml# + unevaluatedProperties: false + properties: + reg: + description: Output channel for the LED (1-18 maps to LED outputs = D1-D18). + minimum: 1 + maximum: 18 + + required: + - reg + +required: + - compatible + - reg + +additionalProperties: false + +examples: + - | + #include + #include + + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + led-controller@1c { + compatible =3D "adi,ltc3220"; + reg =3D <0x1c>; + #address-cells =3D <1>; + #size-cells =3D <0>; + reset-gpios =3D <&gpio 17 GPIO_ACTIVE_LOW>; + adi,force-cpo-level =3D "0"; + adi,quick-write; + + led@1 { + reg =3D <1>; + function =3D LED_FUNCTION_INDICATOR; + function-enumerator =3D <1>; + }; + + led@2 { + reg =3D <2>; + function =3D LED_FUNCTION_INDICATOR; + function-enumerator =3D <2>; + }; + + led@3 { + reg =3D <3>; + function =3D LED_FUNCTION_INDICATOR; + function-enumerator =3D <3>; + }; + + led@4 { + reg =3D <4>; + function =3D LED_FUNCTION_INDICATOR; + function-enumerator =3D <4>; + }; + + led@5 { + reg =3D <5>; + function =3D LED_FUNCTION_INDICATOR; + function-enumerator =3D <5>; + }; + + led@6 { + reg =3D <6>; + function =3D LED_FUNCTION_INDICATOR; + function-enumerator =3D <6>; + }; + }; + }; + +... diff --git a/MAINTAINERS b/MAINTAINERS index 327d74ca7ecb..d640c35d1f93 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -14955,6 +14955,13 @@ W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/temperature/adi,ltc2983.yaml F: drivers/iio/temperature/ltc2983.c =20 +LTC3220 LED DRIVER +M: Edelweise Escala +L: linux-leds@vger.kernel.org +S: Maintained +W: https://ez.analog.com/linux-software-drivers +F: Documentation/devicetree/bindings/leds/leds-ltc3220.yaml + LTC4282 HARDWARE MONITOR DRIVER M: Nuno Sa L: linux-hwmon@vger.kernel.org --=20 2.43.0 From nobody Sun Feb 8 15:30:53 2026 Received: from mx0b-00128a01.pphosted.com (mx0a-00128a01.pphosted.com [148.163.135.77]) (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 998313009C7; Tue, 6 Jan 2026 05:27:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=148.163.135.77 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767677260; cv=none; b=Lrpq895Q6TRm2wPbSlgP06mWvMrRBVh/ldZSm8SZ0Oj51wFrHS0yxKSRWT4VoQVOWTl1bX868gUOc4J1kTrghkNB+GTsJzbYK5tFyQUEuBuwXL2IkkPb9X+PdhU+uqMgMEAU5ORkGr4NPPuFv04ddAdQQFyGI61RpXAnnRzKlzM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1767677260; c=relaxed/simple; bh=MdGTtdtZ/xQlExP4aqIo/JlDQJiufgdrrIt2+F2bz4Q=; h=From:Date:Subject:MIME-Version:Content-Type:Message-ID:References: In-Reply-To:To:CC; b=SoPsgvqyjH309hL27GOPUgu3eDdt7di69kl/c+jNbr9dInBKqSNU8Dq2cTYNbW8GMkVFIkoXeh4nGxqmozDAKr8hIaUe9ueIbyOHKob2Nl6ZeadAxwYUQXyxFjvaciQH82V1lGQLaI7dE7XmSvFfqzxmkv+CB+YrfxNx7e/qsbo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=analog.com; spf=pass smtp.mailfrom=analog.com; dkim=pass (2048-bit key) header.d=analog.com header.i=@analog.com header.b=iVzxqT6j; arc=none smtp.client-ip=148.163.135.77 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=analog.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=analog.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=analog.com header.i=@analog.com header.b="iVzxqT6j" Received: from pps.filterd (m0375855.ppops.net [127.0.0.1]) by mx0b-00128a01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 60644hK13806569; Tue, 6 Jan 2026 00:27:35 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=analog.com; h=cc :content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=DKIM; bh=R99yp Yng00IUl7AqVEmfvlrgx2l+W45lFtI+yTMkNmI=; b=iVzxqT6joF41FUyGI88dr m72Q8aIWqDw/HFoRB9l3g9VXZA/1T3X3vNiM1fslUhChhkeLH/zQ8d7rbB5gsO+0 ingeVKh879H/ztmUSBixWIaGnW4YTU80Ssmk6sWxGJQYUNlsPfbCuZOvQX1mDYbK IeJbbHIXoFlXYFS1Az6vN0F4rZlMkcoBKRG1dQ1g3yBk1yDWav4mdM0V+ZvTPJO7 o/GRrzQukUWS35gZXmeyUE3W0/ovxoOwGZBBIoa7j65VmkY0zhLAYoYggfIoFb+Y Hm1h6qfp0fYda6jipyWxsUEwGu9qow15gND4tJK6efDwNcFGj9JSE2RpPI9tHb0/ Q== Received: from nwd2mta4.analog.com ([137.71.173.58]) by mx0b-00128a01.pphosted.com (PPS) with ESMTPS id 4bgbcem98j-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 06 Jan 2026 00:27:35 -0500 (EST) Received: from ASHBMBX8.ad.analog.com (ASHBMBX8.ad.analog.com [10.64.17.5]) by nwd2mta4.analog.com (8.14.7/8.14.7) with ESMTP id 6065RY8e021555 (version=TLSv1/SSLv3 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL); Tue, 6 Jan 2026 00:27:34 -0500 Received: from ASHBCASHYB4.ad.analog.com (10.64.17.132) by ASHBMBX8.ad.analog.com (10.64.17.5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.37; Tue, 6 Jan 2026 00:27:34 -0500 Received: from ASHBMBX9.ad.analog.com (10.64.17.10) by ASHBCASHYB4.ad.analog.com (10.64.17.132) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1748.37; Tue, 6 Jan 2026 00:27:34 -0500 Received: from zeus.spd.analog.com (10.66.68.11) by ashbmbx9.ad.analog.com (10.64.17.10) with Microsoft SMTP Server id 15.2.1748.37 via Frontend Transport; Tue, 6 Jan 2026 00:27:34 -0500 Received: from HYB-7P5GeKnsiiX.ad.analog.com (HYB-7P5GeKnsiiX.ad.analog.com [10.118.4.58]) by zeus.spd.analog.com (8.15.1/8.15.1) with ESMTP id 6065RF6q016126; Tue, 6 Jan 2026 00:27:26 -0500 From: Edelweise Escala Date: Tue, 6 Jan 2026 13:27:08 +0800 Subject: [PATCH 2/2] leds: ltc3220: add driver 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: <20260106-ltc3220-driver-v1-2-73601d6f1649@analog.com> References: <20260106-ltc3220-driver-v1-0-73601d6f1649@analog.com> In-Reply-To: <20260106-ltc3220-driver-v1-0-73601d6f1649@analog.com> To: Lee Jones , Pavel Machek , Rob Herring , Krzysztof Kozlowski , Conor Dooley CC: , , , Edelweise Escala X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1767677235; l=15921; i=edelweise.escala@analog.com; s=20260106; h=from:subject:message-id; bh=MdGTtdtZ/xQlExP4aqIo/JlDQJiufgdrrIt2+F2bz4Q=; b=WX3shOh4RfC1D0SXoUQL0LP7UcR1DHpYc6lzg54NcBp5uqHCxEK6hhjk1dsA+CE9belea++Z/ Km2DPTkdeT2CKuNxqpN2QQBdbTkQmklBrVcf0e9UVwLcmEDqa61kgSR X-Developer-Key: i=edelweise.escala@analog.com; a=ed25519; pk=lf5HLFe8ZeQjXZgkBkFMK+u9qH5/tqZhCIushTKduNQ= X-ADIRuleOP-NewSCL: Rule Triggered X-Authority-Analysis: v=2.4 cv=b4C/I9Gx c=1 sm=1 tr=0 ts=695c9d47 cx=c_pps a=3WNzaoukacrqR9RwcOSAdA==:117 a=3WNzaoukacrqR9RwcOSAdA==:17 a=IkcTkHD0fZMA:10 a=vUbySO9Y5rIA:10 a=VkNPw1HP01LnGYTKEx00:22 a=gAnH3GRIAAAA:8 a=VwQbUJbxAAAA:8 a=hYaNXiyfE8bdEU5phHsA:9 a=QEXdDO2ut3YA:10 X-Proofpoint-GUID: Xzyj0sLVWw2-VQ1XjoVUmFnB5hBr_fdr X-Proofpoint-ORIG-GUID: Xzyj0sLVWw2-VQ1XjoVUmFnB5hBr_fdr X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMTA2MDA0MyBTYWx0ZWRfXx3J2tscwbfOb ofDJpQZbs+bCMXH3a/ig8MkjBgmOLIUtS+K+SWcPbbTMUlv0HrJCaHu17PiNEjVPtV21RM0sAZY t8KgX2NsdE3HPiTjvoAK81jGtsoJaC8Ukl9SHaI1QerUEOceXhZNJW+FPbekiajzUJMScJ64e+n mTNQTUAmB7ZOkJ1yZOCGiUIRE8FcxWoQkmuRmhn33RxfRFgl22D7P4xnaSCmJN6vVYNZKaa32AF lxvRztKwO5RVi1mClzKeJr6vFaEVGF0LQAxA0FAQcKMKct+J1oJtDTQQMxiYbx7AXbGDchPenRs nT42aeJDzrN9F1ZbDpjr+xVndRqDD+gqGvLqduSTf/j51BLDSOXEURa5m9p7kJAL2RGPGqlbqux QU1kQUKu//w0V4GCCKjoeuQC1m1T+cRJpG7desG1GHqrqQmLejgzh/Lklzuu9ITmENNJuGTMvXy 4Zo+UekEFxAwkjG7KdA== X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.9,FMLib:17.12.100.49 definitions=2026-01-05_02,2026-01-05_01,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 bulkscore=0 malwarescore=0 adultscore=0 lowpriorityscore=0 phishscore=0 suspectscore=0 clxscore=1015 priorityscore=1501 impostorscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2512120000 definitions=main-2601060043 Add driver for ltc3220. LTC3220 18 Channel LED Driver Signed-off-by: Edelweise Escala --- MAINTAINERS | 1 + drivers/leds/Kconfig | 10 + drivers/leds/Makefile | 1 + drivers/leds/leds-ltc3220.c | 465 ++++++++++++++++++++++++++++++++++++++++= ++++ 4 files changed, 477 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index d640c35d1f93..fda0d2963c4f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -14961,6 +14961,7 @@ L: linux-leds@vger.kernel.org S: Maintained W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/leds/leds-ltc3220.yaml +F: drivers/leds/leds-ltc3220.c =20 LTC4282 HARDWARE MONITOR DRIVER M: Nuno Sa diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig index 597d7a79c988..a1c34b2deded 100644 --- a/drivers/leds/Kconfig +++ b/drivers/leds/Kconfig @@ -1001,6 +1001,16 @@ config LEDS_ST1202 Say Y to enable support for LEDs connected to LED1202 LED driver chips accessed via the I2C bus. =20 +config LEDS_LTC3220 + tristate "LED Driver for LTC3220/LTC3220-1" + depends on I2C && LEDS_CLASS + help + If you have an 18-Channel LED Driver connected to LTC3220, or LTC3220-1 + say Y here to enable this driver. + + To compile this driver as a module, choose M here: the module will + be called ltc3220. + config LEDS_TPS6105X tristate "LED support for TI TPS6105X" depends on LEDS_CLASS diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile index 8fdb45d5b439..5301568d9e00 100644 --- a/drivers/leds/Makefile +++ b/drivers/leds/Makefile @@ -61,6 +61,7 @@ obj-$(CONFIG_LEDS_LP8788) +=3D leds-lp8788.o obj-$(CONFIG_LEDS_LP8860) +=3D leds-lp8860.o obj-$(CONFIG_LEDS_LP8864) +=3D leds-lp8864.o obj-$(CONFIG_LEDS_LT3593) +=3D leds-lt3593.o +obj-$(CONFIG_LEDS_LTC3220) +=3D leds-ltc3220.o obj-$(CONFIG_LEDS_MAX5970) +=3D leds-max5970.o obj-$(CONFIG_LEDS_MAX77650) +=3D leds-max77650.o obj-$(CONFIG_LEDS_MAX77705) +=3D leds-max77705.o diff --git a/drivers/leds/leds-ltc3220.c b/drivers/leds/leds-ltc3220.c new file mode 100644 index 000000000000..588074464165 --- /dev/null +++ b/drivers/leds/leds-ltc3220.c @@ -0,0 +1,465 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * LTC3220 18-Channel LED Driver + * + * Copyright 2026 Analog Devices Inc. + * + * Author: Edelweise Escala + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* LTC3220 Registers */ +#define LTC3220_COMMAND 0x00 +#define LTC3220_ULED(x) (0x01 + (x)) +#define LTC3220_GRAD_BLINK 0x13 + +#define LTC3220_GRAD_COUNT_UP BIT(0) +#define LTC3220_COMMAND_QUICK_WRITE BIT(0) +#define LTC3220_COMMAND_SHUTDOWN BIT(3) + +#define LTC3220_LED_CURRENT_MASK GENMASK(5, 0) +#define LTC3220_LED_MODE_MASK GENMASK(7, 6) +#define LTC3220_BLINK_MASK GENMASK(4, 3) +#define LTC3220_GRADATION_MASK GENMASK(2, 1) +#define LTC3220_CPO_COMMAND_MASK GENMASK(2, 1) + +#define LTC3220_NUM_LEDS 18 + +static const char * const ltc3220_cpo_levels[] =3D { "0", "1.5", "2", "1" = }; + +struct ltc3220_command_cfg { + bool quick_write; + bool is_shutdown; + u8 force_cpo_level; +}; + +struct ltc3220_uled_cfg { + struct ltc3220_state *ltc3220_state; + struct led_classdev led_cdev; + u8 reg_value; + u8 led_index; +}; + +struct ltc3220_grad_cfg { + bool is_increasing; + u8 gradation_period_ms; +}; + +struct ltc3220_state { + struct ltc3220_command_cfg command_cfg; + struct ltc3220_uled_cfg uled_cfg[LTC3220_NUM_LEDS]; + struct ltc3220_grad_cfg grad_cfg; + struct i2c_client *client; + u8 blink_mode; +}; + +static int ltc3220_set_command(struct ltc3220_state *ltc3220_state) +{ + struct i2c_client *client =3D ltc3220_state->client; + u8 reg_val; + + reg_val =3D FIELD_PREP(LTC3220_COMMAND_SHUTDOWN, ltc3220_state->command_c= fg.is_shutdown); + reg_val |=3D FIELD_PREP(LTC3220_CPO_COMMAND_MASK, + ltc3220_state->command_cfg.force_cpo_level); + reg_val |=3D FIELD_PREP(LTC3220_COMMAND_QUICK_WRITE, + ltc3220_state->command_cfg.quick_write); + + return i2c_smbus_write_byte_data(client, LTC3220_COMMAND, reg_val); +} + +static int ltc3220_shutdown(struct ltc3220_state *ltc3220_state) +{ + struct i2c_client *client =3D ltc3220_state->client; + u8 reg_val; + int ret; + + reg_val =3D FIELD_PREP(LTC3220_COMMAND_SHUTDOWN, 1); + reg_val |=3D FIELD_PREP(LTC3220_CPO_COMMAND_MASK, + ltc3220_state->command_cfg.force_cpo_level); + + ret =3D i2c_smbus_write_byte_data(client, LTC3220_COMMAND, reg_val); + if (ret =3D=3D 0) + ltc3220_state->command_cfg.is_shutdown =3D true; + + return ret; +} + +static int ltc3220_resume_from_shutdown(struct ltc3220_state *ltc3220_stat= e) +{ + int ret; + + ltc3220_state->command_cfg.is_shutdown =3D false; + ret =3D ltc3220_set_command(ltc3220_state); + if (ret < 0) + ltc3220_state->command_cfg.is_shutdown =3D true; + + return ret; +} + +/* + * Set LED brightness and mode. + * The brightness value determines both the LED current and operating mode: + * 0-63: Normal mode - LED current from 0-63 (off to full brightness) + * 64-127: Blink mode - LED blinks with current level (brightness - 64) + * 128-191: Gradation mode - LED gradually changes brightness (brightness = - 128) + * 192-255: GPO mode - LED operates as general purpose output (brightness = - 192) + */ +static int ltc3220_set_led_data(struct led_classdev *led_cdev, + enum led_brightness brightness) +{ + struct ltc3220_state *ltc3220_state; + struct ltc3220_uled_cfg *uled_cfg; + int ret; + int i; + + uled_cfg =3D container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev); + ltc3220_state =3D uled_cfg->ltc3220_state; + + ret =3D i2c_smbus_write_byte_data(ltc3220_state->client, + LTC3220_ULED(uled_cfg->led_index), brightness); + if (ret < 0) + return ret; + + uled_cfg->reg_value =3D brightness; + + /* + * When quick-write is enabled, writing to LED 1 updates all + * LEDs simultaneously via quick-write mode. Update cached values for + * all LEDs to reflect the synchronized state. + */ + if (ltc3220_state->command_cfg.quick_write && uled_cfg->led_index =3D=3D = 0) { + for (i =3D 0; i < LTC3220_NUM_LEDS; i++) + ltc3220_state->uled_cfg[i].reg_value =3D brightness; + } + + return 0; +} + +static enum led_brightness ltc3220_get_led_data(struct led_classdev *led_c= dev) +{ + struct ltc3220_uled_cfg *uled_cfg; + + uled_cfg =3D container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev); + + return uled_cfg->reg_value; +} + +static int ltc3220_set_blink_and_gradation(struct ltc3220_state *ltc3220_s= tate, + u8 blink_cfg, u8 gradation_period_ms, bool is_increasing) +{ + struct i2c_client *client =3D ltc3220_state->client; + u8 reg_val; + + reg_val =3D FIELD_PREP(LTC3220_BLINK_MASK, blink_cfg); + reg_val |=3D FIELD_PREP(LTC3220_GRADATION_MASK, gradation_period_ms); + reg_val |=3D FIELD_PREP(LTC3220_GRAD_COUNT_UP, is_increasing); + + return i2c_smbus_write_byte_data(client, LTC3220_GRAD_BLINK, reg_val); +} + +/* + * LTC3220 pattern support for hardware-assisted breathing/gradation. + * The hardware supports 3 gradation ramp time 240ms, 480ms, 960ms) + * and can ramp up or down. + * + * Pattern array interpretation: + * pattern[0].brightness =3D start brightness (0-63) + * pattern[0].delta_t =3D ramp time in milliseconds + * pattern[1].brightness =3D end brightness (0-63) + * pattern[1].delta_t =3D (optional, can be 0 or same as pattern[0].delt= a_t) + */ +static int ltc3220_pattern_set(struct led_classdev *led_cdev, + struct led_pattern *pattern, + u32 len, int repeat) +{ + struct ltc3220_state *ltc3220_state; + struct ltc3220_uled_cfg *uled_cfg; + u8 gradation_period; + u8 start_brightness; + u8 end_brightness; + bool is_increasing; + int ret; + + if (len !=3D 2) + return -EINVAL; + + uled_cfg =3D container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev); + ltc3220_state =3D uled_cfg->ltc3220_state; + + start_brightness =3D pattern[0].brightness & LTC3220_LED_CURRENT_MASK; + end_brightness =3D pattern[1].brightness & LTC3220_LED_CURRENT_MASK; + + is_increasing =3D end_brightness > start_brightness; + + if (pattern[0].delta_t =3D=3D 0) + gradation_period =3D 0; + else if (pattern[0].delta_t <=3D 240) + gradation_period =3D 1; + else if (pattern[0].delta_t <=3D 480) + gradation_period =3D 2; + else + gradation_period =3D 3; + + ret =3D ltc3220_set_blink_and_gradation(ltc3220_state, + ltc3220_state->blink_mode, + gradation_period, + is_increasing); + if (ret < 0) + return ret; + + ltc3220_state->grad_cfg.gradation_period_ms =3D gradation_period; + ltc3220_state->grad_cfg.is_increasing =3D is_increasing; + + ret =3D ltc3220_set_led_data(led_cdev, start_brightness); + if (ret < 0) + return ret; + + return ltc3220_set_led_data(led_cdev, 128 + end_brightness); +} + +static int ltc3220_pattern_clear(struct led_classdev *led_cdev) +{ + struct ltc3220_state *ltc3220_state; + struct ltc3220_uled_cfg *uled_cfg; + int ret; + + uled_cfg =3D container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev); + ltc3220_state =3D uled_cfg->ltc3220_state; + + ret =3D ltc3220_set_blink_and_gradation(ltc3220_state, + ltc3220_state->blink_mode, + 0, false); + if (ret < 0) + return ret; + + ltc3220_state->grad_cfg.gradation_period_ms =3D 0; + ltc3220_state->grad_cfg.is_increasing =3D false; + + return 0; +} + +/* + * LTC3220 has a global blink configuration that affects all LEDs. + * This implementation allows per-LED blink requests, but the blink timing + * will be shared across all LEDs. The delay values are mapped to the + * hardware's discrete blink rates. + */ +static int ltc3220_blink_set(struct led_classdev *led_cdev, + unsigned long *delay_on, + unsigned long *delay_off) +{ + struct ltc3220_state *ltc3220_state; + struct ltc3220_uled_cfg *uled_cfg; + unsigned long period; + u8 blink_mode; + int ret; + + uled_cfg =3D container_of(led_cdev, struct ltc3220_uled_cfg, led_cdev); + ltc3220_state =3D uled_cfg->ltc3220_state; + + if (*delay_on =3D=3D 0 && *delay_off =3D=3D 0) { + blink_mode =3D 1; + *delay_on =3D 500; + *delay_off =3D 500; + } else { + period =3D *delay_on + *delay_off; + + if (period <=3D 750) { + blink_mode =3D 0; + *delay_on =3D 250; + *delay_off =3D 250; + } else if (period <=3D 1500) { + blink_mode =3D 1; + *delay_on =3D 500; + *delay_off =3D 500; + } else if (period <=3D 3000) { + blink_mode =3D 2; + *delay_on =3D 1000; + *delay_off =3D 1000; + } else { + blink_mode =3D 3; + *delay_on =3D 2000; + *delay_off =3D 2000; + } + } + + ret =3D ltc3220_set_blink_and_gradation(ltc3220_state, blink_mode, + ltc3220_state->grad_cfg.gradation_period_ms, + ltc3220_state->grad_cfg.is_increasing); + if (ret < 0) + return ret; + + ltc3220_state->blink_mode =3D blink_mode; + + return 0; +} + +static void ltc3220_reset_gpio_action(void *data) +{ + struct gpio_desc *reset_gpio =3D data; + + gpiod_set_value_cansleep(reset_gpio, 1); +} + +static int ltc3220_reset(struct ltc3220_state *ltc3220_state, struct i2c_c= lient *client) +{ + struct gpio_desc *reset_gpio; + int ret; + int i; + + reset_gpio =3D devm_gpiod_get_optional(&client->dev, "reset", GPIOD_OUT_H= IGH); + if (IS_ERR(reset_gpio)) + return dev_err_probe(&client->dev, PTR_ERR(reset_gpio), + "Failed to set reset GPIO\n"); + + if (reset_gpio) { + gpiod_set_value_cansleep(reset_gpio, 0); + + ret =3D devm_add_action_or_reset(&client->dev, ltc3220_reset_gpio_action= , reset_gpio); + if (ret) + return ret; + + } else { + ret =3D ltc3220_set_command(ltc3220_state); + if (ret < 0) + return ret; + + for (i =3D 0; i < LTC3220_NUM_LEDS; i++) { + ret =3D i2c_smbus_write_byte_data(client, LTC3220_ULED(i), 0); + if (ret < 0) + return ret; + } + + ret =3D ltc3220_set_blink_and_gradation(ltc3220_state, 0, 0, 0); + if (ret < 0) + return ret; + } + + return 0; +} + +static int ltc3220_suspend(struct device *dev) +{ + struct i2c_client *client =3D to_i2c_client(dev); + struct ltc3220_state *ltc3220_state =3D i2c_get_clientdata(client); + + return ltc3220_shutdown(ltc3220_state); +} + +static int ltc3220_resume(struct device *dev) +{ + struct i2c_client *client =3D to_i2c_client(dev); + struct ltc3220_state *ltc3220_state =3D i2c_get_clientdata(client); + + return ltc3220_resume_from_shutdown(ltc3220_state); +} + +static SIMPLE_DEV_PM_OPS(ltc3220_pm_ops, ltc3220_suspend, ltc3220_resume); + +static int ltc3220_probe(struct i2c_client *client) +{ + struct ltc3220_state *ltc3220_state; + u8 i =3D 0; + int ret; + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_BYTE_DATA)) + return dev_err_probe(&client->dev, -EIO, + "SMBUS Byte Data not Supported\n"); + + ltc3220_state =3D devm_kzalloc(&client->dev, sizeof(*ltc3220_state), GFP_= KERNEL); + if (!ltc3220_state) + return -ENOMEM; + + ltc3220_state->client =3D client; + i2c_set_clientdata(client, ltc3220_state); + + if (device_property_read_bool(&client->dev, "adi,quick-write")) + ltc3220_state->command_cfg.quick_write =3D true; + + ret =3D ltc3220_reset(ltc3220_state, client); + if (ret) + return dev_err_probe(&client->dev, ret, + "Failed to reset device\n"); + + ret =3D device_property_match_property_string(&client->dev, "adi,force-cp= o-level", + ltc3220_cpo_levels, ARRAY_SIZE(ltc3220_cpo_levels)); + if (ret >=3D 0) + ltc3220_state->command_cfg.force_cpo_level =3D ret; + + ret =3D ltc3220_set_command(ltc3220_state); + if (ret < 0) + return dev_err_probe(&client->dev, ret, + "Failed to set command\n"); + + device_for_each_child_node_scoped(&client->dev, child) { + struct led_init_data init_data =3D {}; + struct ltc3220_uled_cfg *led; + u32 source; + + ret =3D fwnode_property_read_u32(child, "reg", &source); + if (ret) + return dev_err_probe(&client->dev, ret, + "Couldn't read LED address\n"); + + if (!source || source > LTC3220_NUM_LEDS) + return dev_err_probe(&client->dev, -EINVAL, + "LED address out of range\n"); + + init_data.fwnode =3D child; + init_data.devicename =3D "ltc3220"; + init_data.devname_mandatory =3D true; + + /* LED node reg/index/address goes from 1 to 18 */ + i =3D source - 1; + led =3D <c3220_state->uled_cfg[i]; + led->led_index =3D i; + led->reg_value =3D 0; + led->ltc3220_state =3D ltc3220_state; + led->led_cdev.brightness_set_blocking =3D ltc3220_set_led_data; + led->led_cdev.brightness_get =3D ltc3220_get_led_data; + led->led_cdev.max_brightness =3D 255; + led->led_cdev.blink_set =3D ltc3220_blink_set; + led->led_cdev.pattern_set =3D ltc3220_pattern_set; + led->led_cdev.pattern_clear =3D ltc3220_pattern_clear; + + ret =3D devm_led_classdev_register_ext(&client->dev, + &led->led_cdev, + &init_data); + if (ret) + return dev_err_probe(&client->dev, ret, + "Failed to register LED class device\n"); + } + + return 0; +} + +static const struct of_device_id ltc3220_of_match[] =3D { + { .compatible =3D "adi,ltc3220", }, + { .compatible =3D "adi,ltc3220-1", }, + { } +}; +MODULE_DEVICE_TABLE(of, ltc3220_of_match); + +static struct i2c_driver ltc3220_led_driver =3D { + .driver =3D { + .name =3D "ltc3220", + .of_match_table =3D ltc3220_of_match, + .pm =3D pm_sleep_ptr(<c3220_pm_ops), + }, + .probe =3D ltc3220_probe, +}; +module_i2c_driver(ltc3220_led_driver); + +MODULE_AUTHOR("Edelweise Escala "); +MODULE_DESCRIPTION("LED driver for LTC3220 controllers"); +MODULE_LICENSE("GPL"); --=20 2.43.0