From patchwork Sat Feb 21 18:35:51 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aleksandr Shubin X-Patchwork-Id: 431 Received: from mail-lj1-f180.google.com (mail-lj1-f180.google.com [209.85.208.180]) (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 E922D279DA6 for ; Sat, 21 Feb 2026 18:36:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.208.180 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771699004; cv=none; b=ZN1gIOH45ZvXny99TS16FH+vR5wLVi9yuX6ZJ+xOnx5nMGHAElfys9qQdHKm0+61NCQ1wlQXO4THNUdKxehEMcXsLg6LCHiCKiP88p4mIiycOgKL+RGPmRSYEd+NZCqWRzkYTl1ilIFKeUFoUwhXG7sl7SHKHWPE+uVdoO0J9+I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771699004; c=relaxed/simple; bh=/FvXEaGUoGpzEkjnRI9XUIndReaBxEi1jDlYZjxu8lk=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=qP8cAzAeQETi/mKVzpV9CcigwXFS/em+rn4s+CBpjsQ9e9zUIpplIWVSU15iHyG5wI3LPMYmulDp7tU2ib+kVff0x4UMpmAIsxCOiYvQSzz3f6kwESOHN+oxCEPSvuOYwL7ukmTqPc0jQglUFsvPVu9EEeehf4wu7l5OuiaPCYU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=T1iErlbE; arc=none smtp.client-ip=209.85.208.180 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="T1iErlbE" Received: by mail-lj1-f180.google.com with SMTP id 38308e7fff4ca-38707d4c8b9so39189511fa.2 for ; Sat, 21 Feb 2026 10:36:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1771699001; x=1772303801; darn=lists.linux.dev; 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=tuboJBenXywBLFqud7lu9/BOWrHh+KcmgCOX5jvamjk=; b=T1iErlbEZwS9/FwSvNhCnADxIBHEVv+U0T5X3k6GBaZFkduCRaLRzNxHmloyCir5uZ tkArw5VozdEt4FFYc7MM8n1keSiilzysu7Wddkef2MPhCZKr2eDD5VtMvJxrtz3MWSq8 h2KUEF/wj6lXJJu/1gL+PdKwBXchH+KhXqkQrI+T6F1TMuGX6aaUh0lTh4wGvtITAhQh lHyE9pKT5LYAjlTlsPJA45q3haHbFWrhw/gOc5LiLkJbpx8oFJjn6nAuGN+PELMGm8sX YZFABgHRnm5Nkg8JZL96WEqGfylgQOHyXOhyLAaUlOmn1EdBYVHCd8YV+5QPqDSlDHCI KJmg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771699001; x=1772303801; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=tuboJBenXywBLFqud7lu9/BOWrHh+KcmgCOX5jvamjk=; b=iNWr57QfJ1fwMbD7cy/p6v1ho4Wb6cz/2adH79MJhzUmEhFJ6T0S9mbxN9n5afjzsA B3KsGCvPljggVqES3DQFsYfah8jUafUoWVjMJ7DcGUmk55aQ7eZ+miQsFtYYsINb57FQ kJmyVitaNP8yxZocnsWMHKqNtFB6FNPn4Y623UBefbGC5QblU7oy55UpcLNrWHavgOiZ tpLdJ4mn09P5Y6r+Jv3T9+WlvHuG+JSYcDYnGL43BROayWdVvkb6WeEVQkOu1U5x4BDJ Cud/t0eblR1btY6+jnWSdEX1aUj5KXeSyE+6KUX9cKLmxyYAd0jSZdmbALhKesBLKAs0 zncg== X-Forwarded-Encrypted: i=1; AJvYcCVi0+1xikh+74vRU5IjuYNZVXGF1CEDluYP2tx6wWS/im1jDT+N1dIfgx+0jpRCzqh9osDQk+zIFIXt9A==@lists.linux.dev X-Gm-Message-State: AOJu0YwtVnlQYFLAggRUszGN0gfybh3VQWHA25J/nZ9AWNfx3HFuxYzW K1WEVSqRM0nu5fe1QRpm8yac6orDsScG3zknp354K+NQeogTNHY1Ciw= X-Gm-Gg: AZuq6aKMGiKt1HFj6ZyqVdp699Th1w9VxUnJVQil982Wv8WEQ1/IPhSvy5S3okYJY0V UQtcV/x6o2mhDsYvhZltQI2Hivvay8ivF12U9OaqOKxzisoDPI8Ep9HV0UltWX9mljCrAoYLclC iCs8fS0QcpcXs+f3iU4sA/GSe+q+LXIT6a3/9tH0fYpPEEsHRkPc++aCXoaJ+oQVQSA0tb9Y9Lh 4vMXbM+rjWDMXTxbDDPQadC3l2QDUKJoJsbkpK3+MvxYB6KvlclKOQZsOT8ES8RysXmCJqfh4tD 4Nb+GnvifNA9G7XkbxFUJpoTU1uiYwG2ykjtdF0caycn2TlWsBQuxAXQPMtsnpMyIluHrbuK+v6 RMHyJUDoPx9jFyb9jvjmOJonkH3SlWGDdgXeO7nPSoTcLk+ZhN+xyEAXqlBfCF7YpuO3K2QyI1V Rkyjt+8L3H0HNDWExW7aUXu4C5yRa5352vZvdl X-Received: by 2002:a2e:be94:0:b0:386:eadd:9ddf with SMTP id 38308e7fff4ca-389a5cdd595mr8800811fa.12.1771699000922; Sat, 21 Feb 2026 10:36:40 -0800 (PST) Received: from localhost.localdomain ([178.176.177.46]) by smtp.gmail.com with ESMTPSA id 38308e7fff4ca-389a7af19d4sm5006841fa.42.2026.02.21.10.36.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Feb 2026 10:36:40 -0800 (PST) From: Aleksandr Shubin To: linux-kernel@vger.kernel.org Cc: Aleksandr Shubin , =?utf-8?q?Uwe_Kleine-K=C3=B6ni?= =?utf-8?q?g?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Philipp Zabel , Lukas Schmid , Cheo Fusi , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-riscv@lists.infradead.org Subject: [PATCH v13 1/3] dt-bindings: pwm: Add binding for Allwinner D1/T113-S3/R329 PWM controller Date: Sat, 21 Feb 2026 21:35:51 +0300 Message-Id: <20260221183609.95403-2-privatesub2@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20260221183609.95403-1-privatesub2@gmail.com> References: <20260221183609.95403-1-privatesub2@gmail.com> Precedence: bulk X-Mailing-List: linux-sunxi@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Status: O Allwinner's D1, T113-S3 and R329 SoCs have a new pwm controller which is different from the previous pwm-sun4i. The D1 and T113 are identical in terms of peripherals, they differ only in the architecture of the CPU core, and even share the majority of their DT. Because of that, using the same compatible makes sense. The R329 is a different SoC though, and should have a different compatible string added, especially as there is a difference in the number of channels. D1 and T113s SoCs have one PWM controller with 8 channels. R329 SoC has two PWM controllers in both power domains, one of them has 9 channels (CPUX one) and the other has 6 (CPUS one). Add a device tree binding for them. Signed-off-by: Aleksandr Shubin Reviewed-by: Rob Herring (Arm) --- .../bindings/pwm/allwinner,sun20i-d1-pwm.yaml | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 Documentation/devicetree/bindings/pwm/allwinner,sun20i-d1-pwm.yaml diff --git a/Documentation/devicetree/bindings/pwm/allwinner,sun20i-d1-pwm.yaml b/Documentation/devicetree/bindings/pwm/allwinner,sun20i-d1-pwm.yaml new file mode 100644 index 000000000000..306e14a9c4d5 --- /dev/null +++ b/Documentation/devicetree/bindings/pwm/allwinner,sun20i-d1-pwm.yaml @@ -0,0 +1,74 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/pwm/allwinner,sun20i-d1-pwm.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Allwinner D1, T113-S3 and R329 PWM + +maintainers: + - Aleksandr Shubin + - Brandon Cheo Fusi + +properties: + compatible: + oneOf: + - const: allwinner,sun20i-d1-pwm + - items: + - const: allwinner,sun50i-r329-pwm + - const: allwinner,sun20i-d1-pwm + + reg: + maxItems: 1 + + "#pwm-cells": + const: 3 + + clocks: + items: + - description: Bus clock + - description: 24 MHz oscillator + - description: APB clock + + clock-names: + items: + - const: bus + - const: hosc + - const: apb + + resets: + maxItems: 1 + + allwinner,npwms: + $ref: /schemas/types.yaml#/definitions/uint32 + description: The number of PWM channels configured for this instance + minimum: 1 + maximum: 16 + +unevaluatedProperties: false + +required: + - compatible + - reg + - "#pwm-cells" + - clocks + - clock-names + - resets + - allwinner,npwms + +examples: + - | + #include + #include + + pwm: pwm@2000c00 { + compatible = "allwinner,sun20i-d1-pwm"; + reg = <0x02000c00 0x400>; + clocks = <&ccu CLK_BUS_PWM>, <&dcxo>, <&ccu CLK_APB0>; + clock-names = "bus", "hosc", "apb"; + resets = <&ccu RST_BUS_PWM>; + #pwm-cells = <0x3>; + allwinner,npwms = <8>; + }; + +... From patchwork Sat Feb 21 18:35:52 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Aleksandr Shubin X-Patchwork-Id: 430 Received: from mail-lj1-f182.google.com (mail-lj1-f182.google.com [209.85.208.182]) (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 1053C2E62B7 for ; Sat, 21 Feb 2026 18:36:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.208.182 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771699011; cv=none; b=B9MI2NAxcrIY+AlP6cdIA+D/IUDZ+pVGz1yBUhO++/nmFugIWc7r+czpsogTXgFNyJErioY67lQaqKC5ZoQ5rweuAP4nSYPsgx4ek0ezfMfigiZzNKdu03I19rmltNW43c9NLjtBH0k9l2fjToMv0OrX2knyhnFHXJfa5oHmHj4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771699011; c=relaxed/simple; bh=cPuwABD3BxA7XK/nQo/bSpX3OQDmvuaFsDh0+joeV2E=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=Q2LVQER/3t/NPxJzhuVqkFiXsM5EZqEXp1hGxtIMw+INfWO1+jkrYGdTixZDelzPxpeaZ+K7DFimvJqwySG6Wf7b29y8oUhGbJ0dhMZNbSBGj/3cwd6W/WiTHn4mpKx8RAgpcLxkljOpBe1PO3OL36IgKMYFczzCyV2gTFrLTzU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=myPN1cUn; arc=none smtp.client-ip=209.85.208.182 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="myPN1cUn" Received: by mail-lj1-f182.google.com with SMTP id 38308e7fff4ca-386b553c70eso26565141fa.0 for ; Sat, 21 Feb 2026 10:36:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1771699008; x=1772303808; darn=lists.linux.dev; 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=9L52Z43AzVgP7smJzIu46FRnXF7SXcFTv57Ck1avw7s=; b=myPN1cUn3pyOUv5giOHP6g5tCtCIvdc4HkeZPWHaOYAtOO3PpIT38os6R9o87ULhOi MCPIeP5xl5FaRyrvwtXe82gKCd/GbM3fjjhD0t4VLDnfuNV++jkamXtixkby3dmSbcfi sUeMste5DUW7prPk6NfV2mZxBJDsrH+mR5XAvZxo7UqWNKNkclnbxtj7d9k4iEgPnFe1 t+eHj2pfJts/LL0ZMotOaAEHF40HDUk9rPouPY3oftaLM4Ktia7FbvmSxgoxgNbjV5aX FmokyEg5TwCx+AgFw/yrRQtuSKYbZoRCQzQt6c1pDh0HFxh16XqhRgAAeeD78+zhp5dn QrTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771699008; x=1772303808; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=9L52Z43AzVgP7smJzIu46FRnXF7SXcFTv57Ck1avw7s=; b=H8YzellNkKF3q5VRpM58xZx9OFjIIpSrNt5ekOb62OHioKpXgK62HraieGj6BS1XJe LEdHDJXxt2ekbaYaiF65jyaiRlc24LxBOJY1jAJ48EDYQ2mDFD00HBxfKnYnm7wqqP6Y o3cLaUBVXuwayQJFq+hUPnZ5RDggyekiRy8549HAwfJ6lwhmderHkofxlqdHUnt3Pc8I 3D8tr54SH5WHgNIQR7k44spgyWJDH+nif8IlwXshrXoTajCFfjRwtnEV4RWki4o58Vvw MO9zTe+6A6VxgCxbh+TkV4gLLz/wp7U0yjXPS5hbk1ZbWsewcOjvl1okilMYNZhf4wV5 ukbg== X-Forwarded-Encrypted: i=1; AJvYcCWMwaY9TMiqmpVCWExV9zC6G7V8OwGlNziT94G4BN32mJ23pTVtCf84jel4CV7xRRxVkIo2WOuCZL0WTA==@lists.linux.dev X-Gm-Message-State: AOJu0YwWe3G5lVIKVuD70C2Csr9oUJ+L89eEPhIEcSB7CAtXpRQtvhl0 z2vlfHsy6muBuL/G82tkWy3IfCttm53P8WOOuAtE5la9lqwy5tYpYN0= X-Gm-Gg: AZuq6aKDwSFrr7hKy851uZdNE3aKedp3uWiti6c1qZORtEKDvGn7B5LzrDD/AZuyhZf 9QOJXu5GzCZbfD1EbWm8nWQmM+M1CVY+9sNE+rT3ARZfJHCVuyiJomiHQAp7kDhU7DGa7g41XyX AFWOPe4ZAIaJrSLg0dJTKZJ1b1XwRUZnitB/s8c5YIObtZ2sT8UpQHyAq6yzI9N94pPhGVd64Xp h9NIbUJM+qiynKNPtyPAaxpzUel57oOG8FMCrKa/YLXzT+dQXZgwRkn7WyoN7uK5u3YZN0J4yZN LqVUmsEKl6XymSg+lzHjTuG5hidSYMpz0iWodgIs5dA9EKXMwjaETuuYxHEcm5vdAxFUOKjxPj0 fPTyEvmxGIuBmBmzFWnbCNqYrhw9Hvw7ngFn4JfTgjAFMB5pLhlPePBaqt9BVpvpS1q8cXzvs3i 8UwW9AU/K7JanpoesjI/wDAwlipJytjil7kuba X-Received: by 2002:a2e:a99f:0:b0:36b:b0eb:9d64 with SMTP id 38308e7fff4ca-389a5be1c31mr11725601fa.30.1771699007817; Sat, 21 Feb 2026 10:36:47 -0800 (PST) Received: from localhost.localdomain ([178.176.177.46]) by smtp.gmail.com with ESMTPSA id 38308e7fff4ca-389a7af19d4sm5006841fa.42.2026.02.21.10.36.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Feb 2026 10:36:47 -0800 (PST) From: Aleksandr Shubin To: linux-kernel@vger.kernel.org Cc: Aleksandr Shubin , Brandon Cheo Fusi , =?utf-8?q?Uwe_Kleine-K=C3=B6ni?= =?utf-8?q?g?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Philipp Zabel , Lukas Schmid , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-riscv@lists.infradead.org Subject: [PATCH v13 2/3] pwm: Add Allwinner's D1/T113-S3/R329 SoCs PWM support Date: Sat, 21 Feb 2026 21:35:52 +0300 Message-Id: <20260221183609.95403-3-privatesub2@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20260221183609.95403-1-privatesub2@gmail.com> References: <20260221183609.95403-1-privatesub2@gmail.com> Precedence: bulk X-Mailing-List: linux-sunxi@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Status: O Allwinner's D1, T113-S3 and R329 SoCs have a quite different PWM controllers with ones supported by pwm-sun4i driver. This patch adds a PWM controller driver for Allwinner's D1, T113-S3 and R329 SoCs. The main difference between these SoCs is the number of channels defined by the DT property. Co-developed-by: Brandon Cheo Fusi Signed-off-by: Brandon Cheo Fusi Signed-off-by: Aleksandr Shubin --- drivers/pwm/Kconfig | 10 + drivers/pwm/Makefile | 1 + drivers/pwm/pwm-sun8i.c | 393 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 404 insertions(+) create mode 100644 drivers/pwm/pwm-sun8i.c diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig index 6f3147518376..44d844eba589 100644 --- a/drivers/pwm/Kconfig +++ b/drivers/pwm/Kconfig @@ -736,6 +736,16 @@ config PWM_SUN4I To compile this driver as a module, choose M here: the module will be called pwm-sun4i. +config PWM_SUN8I + tristate "Allwinner D1/T113s/R329 PWM support" + depends on ARCH_SUNXI || COMPILE_TEST + depends on COMMON_CLK + help + Generic PWM framework driver for Allwinner D1/T113s/R329 SoCs. + + To compile this driver as a module, choose M here: the module + will be called pwm-sun8i. + config PWM_SUNPLUS tristate "Sunplus PWM support" depends on ARCH_SUNPLUS || COMPILE_TEST diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile index 0dc0d2b69025..ba2e0ec7fc17 100644 --- a/drivers/pwm/Makefile +++ b/drivers/pwm/Makefile @@ -67,6 +67,7 @@ obj-$(CONFIG_PWM_STM32) += pwm-stm32.o obj-$(CONFIG_PWM_STM32_LP) += pwm-stm32-lp.o obj-$(CONFIG_PWM_STMPE) += pwm-stmpe.o obj-$(CONFIG_PWM_SUN4I) += pwm-sun4i.o +obj-$(CONFIG_PWM_SUN8I) += pwm-sun8i.o obj-$(CONFIG_PWM_SUNPLUS) += pwm-sunplus.o obj-$(CONFIG_PWM_TEGRA) += pwm-tegra.o obj-$(CONFIG_PWM_TH1520) += pwm_th1520.o diff --git a/drivers/pwm/pwm-sun8i.c b/drivers/pwm/pwm-sun8i.c new file mode 100644 index 000000000000..6e196f31314b --- /dev/null +++ b/drivers/pwm/pwm-sun8i.c @@ -0,0 +1,393 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * PWM Controller Driver for sunxi platforms (D1, T113-S3 and R329) + * + * Limitations: + * - When the parameters change, the current running period is not completed + * and new settings are applied immediately. + * - The PWM output goes to a HIGH-Z state when the channel is disabled. + * - Changing the clock configuration (SUN8I_PWM_CLK_CFG) + * may cause a brief output glitch. + * + * Copyright (c) 2023 Aleksandr Shubin + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define SUN8I_PWM_CLK_CFG(pair) (0x20 + ((pair) * 0x4)) +#define SUN8I_PWM_CLK_CFG_SRC GENMASK(8, 7) +#define SUN8I_PWM_CLK_SRC_HOSC 0x0 +#define SUN8I_PWM_CLK_SRC_BUS 0x1 +#define SUN8I_PWM_CLK_CFG_DIV_M GENMASK(3, 0) +#define SUN8I_PWM_CLK_DIV_M_MAX 8 + +#define SUN8I_PWM_CLK_GATE 0x40 +#define SUN8I_PWM_CLK_GATE_BYPASS(chan) BIT((chan) + 16) +#define SUN8I_PWM_CLK_GATE_GATING(chan) BIT(chan) + +#define SUN8I_PWM_ENABLE 0x80 +#define SUN8I_PWM_ENABLE_EN(chan) BIT(chan) + +#define SUN8I_PWM_CTL(chan) (0x100 + (chan) * 0x20) +#define SUN8I_PWM_CTL_ACT_STA BIT(8) +#define SUN8I_PWM_CTL_PRESCAL_K GENMASK(7, 0) +#define SUN8I_PWM_CTL_PRESCAL_K_MAX field_max(SUN8I_PWM_CTL_PRESCAL_K) + +#define SUN8I_PWM_PERIOD(chan) (0x104 + (chan) * 0x20) +#define SUN8I_PWM_PERIOD_ENTIRE_CYCLE GENMASK(31, 16) +#define SUN8I_PWM_PERIOD_ACT_CYCLE GENMASK(15, 0) + +#define SUN8I_PWM_PCNTR_SIZE BIT(16) + +/* + * SUN8I_PWM_MAGIC is used to quickly compute the values of the clock dividers + * div_m (SUN8I_PWM_CLK_CFG_DIV_M) & prescale_k (SUN8I_PWM_CTL_PRESCAL_K) + * without using a loop. These dividers limit the # of cycles in a period + * to SUN8I_PWM_PCNTR_SIZE (65536) by applying a scaling factor of + * 1 / (div_m * (prescale_k + 1)) to the clock source. + * + * SUN8I_PWM_MAGIC is derived by solving for div_m and prescale_k + * such that for a given requested period, + * + * i) div_m is minimized for any prescale_k ≤ SUN8I_PWM_CTL_PRESCAL_K_MAX, + * ii) prescale_k is minimized. + * + * The derivation proceeds as follows, with val = # of cycles for requested + * period: + * + * for a given value of div_m we want the smallest prescale_k such that + * + * (val >> div_m) // (prescale_k + 1) ≤ 65536 (= SUN8I_PWM_PCNTR_SIZE) + * + * This is equivalent to: + * + * (val >> div_m) ≤ 65536 * (prescale_k + 1) + prescale_k + * ⟺ (val >> div_m) ≤ 65537 * prescale_k + 65536 + * ⟺ (val >> div_m) - 65536 ≤ 65537 * prescale_k + * ⟺ ((val >> div_m) - 65536) / 65537 ≤ prescale_k + * + * As prescale_k is integer, this becomes + * + * ((val >> div_m) - 65536) // 65537 ≤ prescale_k + * + * And is minimized at + * + * ((val >> div_m) - 65536) // 65537 + * + * Now we pick the smallest div_m that satifies prescale_k ≤ 255 + * (i.e SUN8I_PWM_CTL_PRESCAL_K_MAX), + * + * ((val >> div_m) - 65536) // 65537 ≤ 255 + * ⟺ (val >> div_m) - 65536 ≤ 255 * 65537 + 65536 + * ⟺ val >> div_m ≤ 255 * 65537 + 2 * 65536 + * ⟺ val >> div_m < (255 * 65537 + 2 * 65536 + 1) + * ⟺ div_m = fls((val) / (255 * 65537 + 2 * 65536 + 1)) + * + * Suggested by Uwe Kleine-König + */ +#define SUN8I_PWM_MAGIC (255 * 65537 + 2 * 65536 + 1) +#define SUN8I_PWM_DIV_CONST 65537 + +struct sun8i_pwm_chip { + struct clk *clk_hosc, *clk_apb; + void __iomem *base; +}; + +static inline struct sun8i_pwm_chip *to_sun8i_pwm_chip(struct pwm_chip *chip) +{ + return pwmchip_get_drvdata(chip); +} + +static inline u32 sun8i_pwm_readl(struct sun8i_pwm_chip *chip, + unsigned long offset) +{ + return readl(chip->base + offset); +} + +static inline void sun8i_pwm_writel(struct sun8i_pwm_chip *chip, + u32 val, unsigned long offset) +{ + writel(val, chip->base + offset); +} + +static int sun8i_pwm_get_state(struct pwm_chip *chip, + struct pwm_device *pwm, + struct pwm_state *state) +{ + struct sun8i_pwm_chip *sun8i_chip = to_sun8i_pwm_chip(chip); + u16 ent_cycle, act_cycle, prescale_k; + u64 clk_rate, tmp; + u8 div_m; + u32 val; + + val = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_CLK_CFG(pwm->hwpwm / 2)); + div_m = FIELD_GET(SUN8I_PWM_CLK_CFG_DIV_M, val); + if (div_m > SUN8I_PWM_CLK_DIV_M_MAX) + div_m = SUN8I_PWM_CLK_DIV_M_MAX; + + /* + * If CLK_CFG_SRC is 0, use the hosc clock; + * otherwise (any nonzero value) use the APB clock. + */ + if (FIELD_GET(SUN8I_PWM_CLK_CFG_SRC, val) == 0) + clk_rate = clk_get_rate(sun8i_chip->clk_hosc); + else + clk_rate = clk_get_rate(sun8i_chip->clk_apb); + + val = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_CTL(pwm->hwpwm)); + state->polarity = (SUN8I_PWM_CTL_ACT_STA & val) ? + PWM_POLARITY_NORMAL : PWM_POLARITY_INVERSED; + + prescale_k = FIELD_GET(SUN8I_PWM_CTL_PRESCAL_K, val) + 1; + + val = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_ENABLE); + state->enabled = (SUN8I_PWM_ENABLE_EN(pwm->hwpwm) & val) ? true : false; + + val = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_PERIOD(pwm->hwpwm)); + act_cycle = FIELD_GET(SUN8I_PWM_PERIOD_ACT_CYCLE, val); + + ent_cycle = FIELD_GET(SUN8I_PWM_PERIOD_ENTIRE_CYCLE, val); + + /* + * The duration of the active phase should not be longer + * than the duration of the period + */ + if (act_cycle > ent_cycle) + act_cycle = ent_cycle; + + /* + * We have act_cycle <= ent_cycle <= 0xffff, prescale_k <= 0x100, + * div_m <= 8. So the multiplication fits into an u64 without + * overflow. + */ + tmp = ((u64)(act_cycle) * prescale_k << div_m) * NSEC_PER_SEC; + state->duty_cycle = DIV_ROUND_UP_ULL(tmp, clk_rate); + tmp = ((u64)(ent_cycle) * prescale_k << div_m) * NSEC_PER_SEC; + state->period = DIV_ROUND_UP_ULL(tmp, clk_rate); + + return 0; +} + +static int sun8i_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, + const struct pwm_state *state) +{ + struct sun8i_pwm_chip *sun8i_chip = to_sun8i_pwm_chip(chip); + u64 bus_rate, hosc_rate, val, ent_cycle, act_cycle; + u32 clk_gate, clk_cfg, pwm_en, ctl, reg_period; + u32 prescale_k, div_m; + u64 clk_src_rate; + u8 clk_src; + + pwm_en = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_ENABLE); + clk_gate = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_CLK_GATE); + + if (!state->enabled) { + if (state->enabled != pwm->state.enabled) { + clk_gate &= ~SUN8I_PWM_CLK_GATE_GATING(pwm->hwpwm); + pwm_en &= ~SUN8I_PWM_ENABLE_EN(pwm->hwpwm); + sun8i_pwm_writel(sun8i_chip, pwm_en, SUN8I_PWM_ENABLE); + sun8i_pwm_writel(sun8i_chip, clk_gate, SUN8I_PWM_CLK_GATE); + } + return 0; + } + + ctl = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_CTL(pwm->hwpwm)); + clk_cfg = sun8i_pwm_readl(sun8i_chip, SUN8I_PWM_CLK_CFG(pwm->hwpwm / 2)); + hosc_rate = clk_get_rate(sun8i_chip->clk_hosc); + bus_rate = clk_get_rate(sun8i_chip->clk_apb); + + /* + * Clock selection for a PWM pair: + * + * This PWM controller groups channels in pairs, + * where CLK_SRC and DIV_M are shared between the two channels. + * If the sibling channel is already enabled, + * we must keep the existing clock configuration for this pair. + * + * If the sibling is disabled, we are free to pick a clock + * for the pair. Using the faster clock source + * improves the achievable maximum PWM frequency and generally + * gives better duty_cycle resolution for a given period. + */ + + if (pwm_en & SUN8I_PWM_ENABLE_EN(pwm->hwpwm ^ 1)) { + /* Use the current clock settings */ + clk_src = FIELD_GET(SUN8I_PWM_CLK_CFG_SRC, clk_cfg); + clk_src_rate = clk_src == SUN8I_PWM_CLK_SRC_BUS ? bus_rate : hosc_rate; + val = mul_u64_u64_div_u64(state->period, clk_src_rate, + NSEC_PER_SEC); + + div_m = FIELD_GET(SUN8I_PWM_CLK_CFG_DIV_M, clk_cfg); + } else { + /* Use the faster clock source */ + if (bus_rate > hosc_rate) { + clk_src = SUN8I_PWM_CLK_SRC_BUS; + clk_src_rate = bus_rate; + } else { + clk_src = SUN8I_PWM_CLK_SRC_HOSC; + clk_src_rate = hosc_rate; + } + + val = mul_u64_u64_div_u64(state->period, clk_src_rate, NSEC_PER_SEC); + /* + * If the calculated value is ≤ 1, the period is too short + * for proper PWM operation + */ + if (val <= 1) + return -EINVAL; + + div_m = fls(DIV_ROUND_DOWN_ULL(val, SUN8I_PWM_MAGIC)); + if (div_m > SUN8I_PWM_CLK_DIV_M_MAX) + return -EINVAL; + + /* Set up the CLK_DIV_M and clock CLK_SRC */ + clk_cfg = FIELD_PREP(SUN8I_PWM_CLK_CFG_DIV_M, div_m); + clk_cfg |= FIELD_PREP(SUN8I_PWM_CLK_CFG_SRC, clk_src); + + sun8i_pwm_writel(sun8i_chip, clk_cfg, SUN8I_PWM_CLK_CFG(pwm->hwpwm / 2)); + } + + /* Calculate prescale_k and determine the number of cycles for a full PWM period */ + ent_cycle = val >> div_m; + prescale_k = DIV_ROUND_DOWN_ULL(ent_cycle, SUN8I_PWM_DIV_CONST); + if (prescale_k > SUN8I_PWM_CTL_PRESCAL_K_MAX) + prescale_k = SUN8I_PWM_CTL_PRESCAL_K_MAX; + + do_div(ent_cycle, prescale_k + 1); + + /* ent_cycle must not be zero */ + if (ent_cycle == 0) + return -EINVAL; + + /* For N cycles, PPRx.PWM_ENTIRE_CYCLE = (N-1) */ + reg_period = FIELD_PREP(SUN8I_PWM_PERIOD_ENTIRE_CYCLE, ent_cycle - 1); + + /* Calculate the active cycles (duty cycle) */ + val = mul_u64_u64_div_u64(state->duty_cycle, clk_src_rate, + NSEC_PER_SEC); + act_cycle = val >> div_m; + do_div(act_cycle, prescale_k + 1); + + /* + * The formula of the output period and the duty-cycle for PWM are as follows. + * T period = PWM0_PRESCALE_K / PWM01_CLK * (PPR0.PWM_ENTIRE_CYCLE + 1) + * T high-level = PWM0_PRESCALE_K / PWM01_CLK * PPR0.PWM_ACT_CYCLE + * Duty-cycle = T high-level / T period + */ + reg_period |= FIELD_PREP(SUN8I_PWM_PERIOD_ACT_CYCLE, act_cycle); + sun8i_pwm_writel(sun8i_chip, reg_period, SUN8I_PWM_PERIOD(pwm->hwpwm)); + + ctl = FIELD_PREP(SUN8I_PWM_CTL_PRESCAL_K, prescale_k); + if (state->polarity == PWM_POLARITY_NORMAL) + ctl |= SUN8I_PWM_CTL_ACT_STA; + + sun8i_pwm_writel(sun8i_chip, ctl, SUN8I_PWM_CTL(pwm->hwpwm)); + + if (state->enabled != pwm->state.enabled) { + clk_gate &= ~SUN8I_PWM_CLK_GATE_BYPASS(pwm->hwpwm); + clk_gate |= SUN8I_PWM_CLK_GATE_GATING(pwm->hwpwm); + pwm_en |= SUN8I_PWM_ENABLE_EN(pwm->hwpwm); + sun8i_pwm_writel(sun8i_chip, pwm_en, SUN8I_PWM_ENABLE); + sun8i_pwm_writel(sun8i_chip, clk_gate, SUN8I_PWM_CLK_GATE); + } + + return 0; +} + +static const struct pwm_ops sun8i_pwm_ops = { + .apply = sun8i_pwm_apply, + .get_state = sun8i_pwm_get_state, +}; + +static const struct of_device_id sun8i_pwm_dt_ids[] = { + { .compatible = "allwinner,sun20i-d1-pwm" }, + { } +}; +MODULE_DEVICE_TABLE(of, sun8i_pwm_dt_ids); + +static int sun8i_pwm_probe(struct platform_device *pdev) +{ + struct pwm_chip *chip; + struct sun8i_pwm_chip *sun8i_chip; + struct clk *clk_bus; + struct reset_control *rst; + u32 npwm; + int ret; + + ret = of_property_read_u32(pdev->dev.of_node, "allwinner,npwms", &npwm); + if (ret < 0) + return dev_err_probe(&pdev->dev, ret, + "Failed to get allwinner,npwms\n"); + + if (npwm < 1 || npwm > 16) + return dev_err_probe(&pdev->dev, -EINVAL, + "Invalid allwinner,npwms\n"); + + chip = devm_pwmchip_alloc(&pdev->dev, npwm, sizeof(*sun8i_chip)); + if (IS_ERR(chip)) + return PTR_ERR(chip); + sun8i_chip = to_sun8i_pwm_chip(chip); + + sun8i_chip->base = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(sun8i_chip->base)) + return PTR_ERR(sun8i_chip->base); + + clk_bus = devm_clk_get_enabled(&pdev->dev, "bus"); + if (IS_ERR(clk_bus)) + return dev_err_probe(&pdev->dev, PTR_ERR(clk_bus), + "Failed to get bus clock\n"); + + sun8i_chip->clk_hosc = devm_clk_get_enabled(&pdev->dev, "hosc"); + if (IS_ERR(sun8i_chip->clk_hosc)) + return dev_err_probe(&pdev->dev, PTR_ERR(sun8i_chip->clk_hosc), + "Failed to get hosc clock\n"); + + ret = devm_clk_rate_exclusive_get(&pdev->dev, sun8i_chip->clk_hosc); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to get hosc exclusive rate\n"); + + sun8i_chip->clk_apb = devm_clk_get_enabled(&pdev->dev, "apb"); + if (IS_ERR(sun8i_chip->clk_apb)) + return dev_err_probe(&pdev->dev, PTR_ERR(sun8i_chip->clk_apb), + "Failed to get apb clock\n"); + + ret = devm_clk_rate_exclusive_get(&pdev->dev, sun8i_chip->clk_apb); + if (ret) + return dev_err_probe(&pdev->dev, ret, + "Failed to get apb exclusive rate\n"); + + rst = devm_reset_control_get_exclusive_deasserted(&pdev->dev, NULL); + if (IS_ERR(rst)) + return dev_err_probe(&pdev->dev, PTR_ERR(rst), + "Failed to get reset control\n"); + + chip->ops = &sun8i_pwm_ops; + + ret = devm_pwmchip_add(&pdev->dev, chip); + if (ret < 0) + return dev_err_probe(&pdev->dev, ret, "Failed to add PWM chip\n"); + + return 0; +} + +static struct platform_driver sun8i_pwm_driver = { + .driver = { + .name = "sun8i-pwm", + .of_match_table = sun8i_pwm_dt_ids, + }, + .probe = sun8i_pwm_probe, +}; +module_platform_driver(sun8i_pwm_driver); + +MODULE_AUTHOR("Aleksandr Shubin "); +MODULE_DESCRIPTION("Allwinner sun8i PWM driver"); +MODULE_LICENSE("GPL"); From patchwork Sat Feb 21 18:35:53 2026 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aleksandr Shubin X-Patchwork-Id: 429 Received: from mail-lj1-f179.google.com (mail-lj1-f179.google.com [209.85.208.179]) (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 92AD9279DA6 for ; Sat, 21 Feb 2026 18:36:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.208.179 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771699019; cv=none; b=FUettiCkOQEnUvKzCMe0MQX3Y91vaz9bl5wq+70cjbgnxAF+g8TGhKFtxbytN0pps/vmYDInBS6/r4WCnjITR0w/x0gvTK/NGFePwCJiotu7gTNl14y6G4+84FQREsNDhhoz7W1K8klN8qw1Su5lgrAVgar2WvRnva0fsmKRE7A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771699019; c=relaxed/simple; bh=vIgGOct6ry2KV3592MeOE+vIaVFPywrg89zWQ5z/wbI=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=SgeKPR1JnX+I+jUsuw3RHbNFAEJU45HbZGhFVEnT83Bsjl9zgo0uAVvLD86ZrAvBAKUG8JoKAh8na7FjqTwHHdZ+XjVnOYMb89shf+BvljEzGsptje54Bak1hlYiRGjJOpTDXgxZnNtYHH6FqpbEgPB2Pmjn4cmD610bxnspUXc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=VjYr1uW4; arc=none smtp.client-ip=209.85.208.179 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="VjYr1uW4" Received: by mail-lj1-f179.google.com with SMTP id 38308e7fff4ca-38713b53915so29333281fa.0 for ; Sat, 21 Feb 2026 10:36:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1771699016; x=1772303816; darn=lists.linux.dev; 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=Vi+zTY3v+XYAN7MEQwL4QN54NaCqF12xnryOs65hhBU=; b=VjYr1uW4kZgbJ3VWsqRYWynzPqvM1HEfYoZ/kpgs3iq1TTjiH+6JT23Dom7ieYQ6RC +m2ixDh/ECdsQ8tyEVLBCWYu9nrKzi5SBSnS1dpqjqaWWOScv8aWhghbbXc5V+JYI6wm uLjwCd9045ny2kY9oRO6/IZchBSrWjea2M23UnfxyQemfd/Xz1c2G6L05alArrgQQKx6 y5aTJhoc2gLu57C5A1Jn9KIUIHyLRmRiV8kkOg97HoBPkmuLNNvdaZdFJCod8WYTG2v2 /c0kDCWgKQ5yOhKy/SmQMRrcCnQ6MriM01PwJ5FgkFtdIi7GRehF2kSVuDQib5MuWCG/ ahhg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1771699016; x=1772303816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Vi+zTY3v+XYAN7MEQwL4QN54NaCqF12xnryOs65hhBU=; b=fEAf42WUQJXQ7jT8Noj+b7kvBnbxfRt7sbSCW+C4LcoRkZwnc0fpNg0I7/oi2J4au0 B/IFyO3E8yV6xJJxDzoLiOUEqLiG7MvygRZzH2QGk9kog8qpBqv0Ax4nDFoECYK+zzbH li/9sCMHWSWNnP/t/Y0l5h1t1djvfhlcgSS8u/QEbPeMteEXmdTknDQreBRZwMvoBd76 XJomX8CFbnLfCm2DKAOQRapL9WCGcmOuamTK9UR9BEyquuZLx5iSh5+MX6P2eThTql3j SkHdfgD0oX2OotjoVn5f4QDH3+oTDWJEw35rKApdyMobvwl8ROLVaTwYFAQEtsJUIfLX D2Zw== X-Forwarded-Encrypted: i=1; AJvYcCWZzTI2tW9AccNh7q/TEwllgy+afN8dxPM4LGNVz+nebOHrxNCruotU5ydtAVJToqT9oP+m5UQRqHxLFQ==@lists.linux.dev X-Gm-Message-State: AOJu0YwVGcMO9aEZTBQBtMC2miHYcyZ3cMIKC33aKjsWv8XkyhPFTTwh kGfrtXAhwJ7voIwWDe4maJJhcOBeB+0NRJVkl3/9dncTmUfsSRf7nqo= X-Gm-Gg: AZuq6aJv0P3rRuJYVQxAC3SPP1YNIqXylbPn+q1B4nYNI7x5wNERVjseDJN7eVjX8qk Zu1mYTkNh5Tbl02Aghhy3+RKTH6sUiDGfWWLvpmBQNKdSU2M5i4BoE1y4C4cRM5j9EHItOxptMy qhrB6RvwCes6KWcGhzR7c8aeV8dTefBShz7ir4oKeSF28siAHt6fl/RNV4xsTLEV8BhE10q7iJO zch2F69Y3+44ZwMPxv/thoNFAfPWbVu0FlAycNOIuRSFyea0zm3RptoUqpCLBtroCEsWsLIyiZ5 qe3+AjGW3H0tn7vzxARV2v0ZiFePLjn+6FWS3/kwo2Du96BZi8ZuEzpfBilHWonfTr8DihZHlbK zgiPH3QWCOpVpIwgg9VmA8XD6Mm+ydjM0JA+eDKxci9hYoZWesP3lnwfXyCpoU4p+gzGp8aOxCi 6CG8/kiakfRAlHtzhj7Bv2nxPKMI/sa1CHwRXg X-Received: by 2002:a2e:9853:0:b0:385:b4ef:f667 with SMTP id 38308e7fff4ca-3885335b418mr22967171fa.0.1771699015563; Sat, 21 Feb 2026 10:36:55 -0800 (PST) Received: from localhost.localdomain ([178.176.177.46]) by smtp.gmail.com with ESMTPSA id 38308e7fff4ca-389a7af19d4sm5006841fa.42.2026.02.21.10.36.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 21 Feb 2026 10:36:53 -0800 (PST) From: Aleksandr Shubin To: linux-kernel@vger.kernel.org Cc: Aleksandr Shubin , =?utf-8?q?Uwe_Kleine-K=C3=B6ni?= =?utf-8?q?g?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Philipp Zabel , Lukas Schmid , Cheo Fusi , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-riscv@lists.infradead.org Subject: [PATCH v13 3/3] riscv: dts: allwinner: d1: Add pwm node Date: Sat, 21 Feb 2026 21:35:53 +0300 Message-Id: <20260221183609.95403-4-privatesub2@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20260221183609.95403-1-privatesub2@gmail.com> References: <20260221183609.95403-1-privatesub2@gmail.com> Precedence: bulk X-Mailing-List: linux-sunxi@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Status: O D1 and T113s contain a pwm controller with 8 channels. This controller is supported by the sun8i-pwm driver. Add a device tree node for it. Signed-off-by: Aleksandr Shubin --- arch/riscv/boot/dts/allwinner/sunxi-d1s-t113.dtsi | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/arch/riscv/boot/dts/allwinner/sunxi-d1s-t113.dtsi b/arch/riscv/boot/dts/allwinner/sunxi-d1s-t113.dtsi index 63e252b44973..8e38a0d95f5a 100644 --- a/arch/riscv/boot/dts/allwinner/sunxi-d1s-t113.dtsi +++ b/arch/riscv/boot/dts/allwinner/sunxi-d1s-t113.dtsi @@ -193,6 +193,19 @@ uart3_pb_pins: uart3-pb-pins { }; }; + pwm: pwm@2000c00 { + compatible = "allwinner,sun20i-d1-pwm"; + reg = <0x02000c00 0x400>; + clocks = <&ccu CLK_BUS_PWM>, + <&dcxo>, + <&ccu CLK_APB0>; + clock-names = "bus", "hosc", "apb"; + resets = <&ccu RST_BUS_PWM>; + status = "disabled"; + #pwm-cells = <0x3>; + allwinner,npwms = <8>; + }; + ccu: clock-controller@2001000 { compatible = "allwinner,sun20i-d1-ccu"; reg = <0x2001000 0x1000>;