[PATCH v7 0/4] Add drivers for Sony Cronos control CPLD

[PATCH v7 0/4] Add drivers for Sony Cronos control CPLD

[Raptor Engineering Development Team]

From: Timothy Pearson <tpearson@raptorengineering.com>

Hello all,

This series adds a driver for the multi-function CPLD found on the Sony
Interactive Entertainment Cronos x86 server platform. It provides a
watchdog timer and an LED controller, both of which will depend on the
MFD parent driver implemented in this series. Device tree bindings are
also included.

Changes in v7:

 * Fix DT binding check errors
 * Minor fixups to MFD driver per maintainer request

Thanks,

Shawn Anastasio (1):
  dt-bindings: mfd: Add sony,cronos-smc

Timothy Pearson (3):
  mfd: sony-cronos-smc: Add driver for Sony Cronos SMC
  led: sony-cronos-smc: Add RGB LED driver for Sony Cronos SMC
  watchdog: sony-cronos-smc: Add watchdog driver for Sony Cronos SMC

 .../bindings/mfd/sony,cronos-smc.yaml         | 128 ++++++
 MAINTAINERS                                   |   7 +
 drivers/leds/Kconfig                          |  19 +
 drivers/leds/Makefile                         |   1 +
 drivers/leds/leds-sony-cronos.c               | 376 ++++++++++++++++++
 drivers/mfd/Kconfig                           |  11 +
 drivers/mfd/Makefile                          |   2 +
 drivers/mfd/sony-cronos-smc.c                 | 204 ++++++++++
 drivers/watchdog/Kconfig                      |  17 +
 drivers/watchdog/Makefile                     |   1 +
 drivers/watchdog/sony-cronos-wdt.c            | 283 +++++++++++++
 include/linux/mfd/sony-cronos.h               |  61 +++
 12 files changed, 1110 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
 create mode 100644 drivers/leds/leds-sony-cronos.c
 create mode 100644 drivers/mfd/sony-cronos-smc.c
 create mode 100644 drivers/watchdog/sony-cronos-wdt.c
 create mode 100644 include/linux/mfd/sony-cronos.h

-- 
2.39.5

[PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Raptor Engineering Development Team]

From: Shawn Anastasio <sanastasio@raptorengineering.com>

The Sony Cronos Platform Controller is a multi-purpose platform controller
that provides both a watchdog timer and an LED controller for the Sony
Interactive Entertainment Cronos x86 server platform. As both functions
are provided by the same CPLD, a multi-function device is exposed as the
parent of both functions.

Add a DT binding for this device.

Signed-off-by: Shawn Anastasio <sanastasio@raptorengineering.com>
Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
---
 .../bindings/mfd/sony,cronos-smc.yaml         | 128 ++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml

diff --git a/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
new file mode 100644
index 000000000000..a7e88fd42d39
--- /dev/null
+++ b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
+# Copyright 2025-2026 Raptor Engineering, LLC
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/mfd/sony,cronos-smc.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: Sony Cronos Platform Controller CPLD multi-function device
+
+maintainers:
+  - Georgy Yakovlev <Georgy.Yakovlev@sony.com>
+
+description:
+  The Sony Cronos Platform Controller CPLD is a multi-purpose platform
+  controller that provides both a watchdog timer and an LED controller for the
+  Sony Interactive Entertainment Cronos x86 server platform. As both functions
+  are provided by the same CPLD, a multi-function device is exposed as the
+  parent of both functions.
+
+properties:
+  compatible:
+    const: sony,cronos-smc
+
+  reg:
+    maxItems: 1
+
+  leds:
+    type: object
+    $ref: /schemas/leds/common.yaml#
+    additionalProperties: false
+    description: |
+      The Cronos LED controller is a subfunction of the Cronos platform
+      controller, which is a multi-function device.
+
+      Each led is represented as a child node of sony,cronos-led. Fifteen RGB
+      LEDs are supported by the platform.
+
+    properties:
+      compatible:
+        const: sony,cronos-led
+
+      reg:
+        maxItems: 1
+
+      "#address-cells":
+        const: 1
+
+      "#size-cells":
+        const: 0
+
+    patternProperties:
+      "^multi-led@[0-9a-f]$":
+        type: object
+        $ref: /schemas/leds/leds-class-multicolor.yaml#
+        unevaluatedProperties: false
+
+        properties:
+          reg:
+            description:
+              LED channel number (0..14)
+            minimum: 0
+            maximum: 14
+
+        required:
+          - reg
+
+    required:
+      - compatible
+      - "#address-cells"
+      - "#size-cells"
+
+  watchdog:
+    type: object
+
+    $ref: /schemas/watchdog/watchdog.yaml
+
+    properties:
+      compatible:
+        const: sony,cronos-watchdog
+
+      timeout-sec: true
+
+    required:
+      - compatible
+
+    additionalProperties: false
+
+required:
+  - compatible
+  - reg
+
+unevaluatedProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/leds/common.h>
+    i2c {
+        #address-cells = <1>;
+        #size-cells = <0>;
+
+        smc@3f {
+            compatible = "sony,cronos-smc";
+            reg = <0x3f>;
+
+            watchdog {
+                compatible = "sony,cronos-watchdog";
+
+                timeout-sec = <20>;
+            };
+
+            leds {
+                compatible = "sony,cronos-led";
+                #address-cells = <1>;
+                #size-cells = <0>;
+
+                multi-led@0 {
+                    /*
+                     * No subnodes are needed, this controller only supports RGB
+                     * LEDs.
+                     */
+                    reg = <0>;
+                    color = <LED_COLOR_ID_MULTI>;
+                    function = LED_FUNCTION_STATUS;
+                };
+            };
+        };
+    };
+
-- 
2.39.5

[PATCH v7 2/4] mfd: sony-cronos-smc: Add driver for Sony Cronos SMC

[Raptor Engineering Development Team]

From: Timothy Pearson <tpearson@raptorengineering.com>

The Sony Cronos Platform Controller is a multi-purpose platform controller
that provides both a watchdog timer and an LED controller for the Sony
Interactive Entertainment Cronos x86 server platform. As both functions
are provided by the same CPLD, a multi-function device is exposed as the
parent of both functions.

Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
Signed-off-by: Shawn Anastasio <sanastasio@raptorengineering.com>
---
 MAINTAINERS                     |   7 ++
 drivers/mfd/Kconfig             |  11 ++
 drivers/mfd/Makefile            |   2 +
 drivers/mfd/sony-cronos-smc.c   | 204 ++++++++++++++++++++++++++++++++
 include/linux/mfd/sony-cronos.h |  61 ++++++++++
 5 files changed, 285 insertions(+)
 create mode 100644 drivers/mfd/sony-cronos-smc.c
 create mode 100644 include/linux/mfd/sony-cronos.h

diff --git a/MAINTAINERS b/MAINTAINERS
index 67db88b04537..a9fce9f72164 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -24298,6 +24298,13 @@ S:	Maintained
 F:	drivers/ssb/
 F:	include/linux/ssb/
 
+SONY CRONOS SMC DRIVER
+M:	Georgy Yakovlev <Georgy.Yakovlev@sony.com>
+S:	Maintained
+F:	Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
+F:	drivers/mfd/sony-cronos-smc.c
+F:	include/linux/mfd/sony-cronos.h
+
 SONY IMX208 SENSOR DRIVER
 M:	Sakari Ailus <sakari.ailus@linux.intel.com>
 L:	linux-media@vger.kernel.org
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index aace5766b38a..559aa64500e6 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -2388,6 +2388,17 @@ config MFD_QCOM_PM8008
 	  under it in the device tree. Additional drivers must be enabled in
 	  order to use the functionality of the device.
 
+config MFD_SONY_CRONOS_SMC
+	tristate "Sony Cronos System Management Controller"
+	select MFD_CORE
+	select REGMAP_I2C
+	depends on I2C && OF
+	help
+      Support for the Sony Cronos system controller. Additional drivers must
+      be enabled in order to use the functionality of the device, including LED
+      control and the system watchdog. The controller itself is a custom design
+      tailored to the specific needs of the Sony Cronos hardware platform.
+
 menu "Multimedia Capabilities Port drivers"
 	depends on ARCH_SA1100
 
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index e75e8045c28a..2e8cf0c7096c 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -301,6 +301,8 @@ obj-$(CONFIG_MFD_QNAP_MCU)	+= qnap-mcu.o
 obj-$(CONFIG_MFD_RSMU_I2C)	+= rsmu_i2c.o rsmu_core.o
 obj-$(CONFIG_MFD_RSMU_SPI)	+= rsmu_spi.o rsmu_core.o
 
+obj-$(CONFIG_MFD_SONY_CRONOS_SMC)	+= sony-cronos-smc.o
+
 obj-$(CONFIG_MFD_UPBOARD_FPGA)	+= upboard-fpga.o
 
 obj-$(CONFIG_MFD_LOONGSON_SE)	+= loongson-se.o
diff --git a/drivers/mfd/sony-cronos-smc.c b/drivers/mfd/sony-cronos-smc.c
new file mode 100644
index 000000000000..c1c67acf9319
--- /dev/null
+++ b/drivers/mfd/sony-cronos-smc.c
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Device driver for Sony Cronos SMCs
+ * Copyright (C) 2015-2017  Dialog Semiconductor
+ * Copyright (C) 2022-2025  Raptor Engineering, LLC
+ */
+
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/sony-cronos.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+
+static const struct mfd_cell cronos_smc_devs[] = {
+	{
+		.name = "cronos-watchdog",
+		.of_compatible = "sony,cronos-watchdog",
+	},
+	{
+		.name = "cronos-led",
+		.of_compatible = "sony,cronos-led",
+	},
+};
+
+static int sony_cronos_get_device_type(struct sony_cronos_smc *ddata)
+{
+	int device_id;
+	int byte_high;
+	int byte_low;
+	int ret;
+
+	ret = regmap_read(ddata->regmap, CRONOS_SMC_DEVICE_ID_HIGH_REG, &byte_high);
+	if (ret) {
+		dev_err(ddata->dev, "Cannot read ddata ID high byte.\n");
+		return -EIO;
+	}
+	ret = regmap_read(ddata->regmap, CRONOS_SMC_DEVICE_ID_LOW_REG, &byte_low);
+	if (ret) {
+		dev_err(ddata->dev, "Cannot read ddata ID low byte.\n");
+		return -EIO;
+	}
+
+	device_id = byte_high << 8;
+	device_id |= byte_low;
+
+	if (device_id != CRONOS_SMC_DEVICE_ID) {
+		dev_err(ddata->dev, "Unsupported device ID 0x%04x\n", device_id);
+		return -ENODEV;
+	}
+
+	return ret;
+}
+
+static bool cronos_smc_is_writeable_reg(struct device *dev, unsigned int reg)
+{
+	switch (reg) {
+	case CRONOS_SMC_BRIGHTNESS_RED_REG:
+	case CRONOS_SMC_BRIGHTNESS_GREEN_REG:
+	case CRONOS_SMC_BRIGHTNESS_BLUE_REG:
+	case CRONOS_LEDS_SMC_STATUS_REG:
+	case CRONOS_LEDS_SWITCH_STATUS_REG:
+	case CRONOS_LEDS_CCM1_STATUS_REG:
+	case CRONOS_LEDS_CCM2_STATUS_REG:
+	case CRONOS_LEDS_CCM3_STATUS_REG:
+	case CRONOS_LEDS_CCM4_STATUS_REG:
+	case CRONOS_LEDS_CCM_POWER_REG:
+
+	case CRONOS_WDT_CTL_REG:
+	case CRONOS_WDT_CLR_REG:
+
+	case CRONOS_SMC_UART_MUX_REG:
+	case CRONOS_SMC_SWITCH_BOOT_FLASH_SELECT_REG:
+	case CRONOS_SMC_SWITCH_RESET_CMD_REG:
+	case CRONOS_SMC_BMC_BOOT_FLASH_SELECT_REG:
+	case CRONOS_SMC_PAYLOAD_POWER_CTL_REG:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static bool cronos_smc_is_readable_reg(struct device *dev, unsigned int reg)
+{
+	switch (reg) {
+	case CRONOS_SMC_REVISION_HIGH_REG:
+	case CRONOS_SMC_REVISION_LOW_REG:
+	case CRONOS_SMC_DEVICE_ID_HIGH_REG:
+	case CRONOS_SMC_DEVICE_ID_LOW_REG:
+
+	case CRONOS_SMC_BRIGHTNESS_RED_REG:
+	case CRONOS_SMC_BRIGHTNESS_GREEN_REG:
+	case CRONOS_SMC_BRIGHTNESS_BLUE_REG:
+	case CRONOS_LEDS_SMC_STATUS_REG:
+	case CRONOS_LEDS_SWITCH_STATUS_REG:
+	case CRONOS_LEDS_CCM1_STATUS_REG:
+	case CRONOS_LEDS_CCM2_STATUS_REG:
+	case CRONOS_LEDS_CCM3_STATUS_REG:
+	case CRONOS_LEDS_CCM4_STATUS_REG:
+	case CRONOS_LEDS_CCM_POWER_REG:
+
+	case CRONOS_WDT_CTL_REG:
+	case CRONOS_WDT_CLR_REG:
+
+	case CRONOS_SMC_STATUS_2_REG:
+	case CRONOS_SMC_UART_MUX_REG:
+	case CRONOS_SMC_SWITCH_BOOT_FLASH_SELECT_REG:
+	case CRONOS_SMC_SWITCH_RESET_CMD_REG:
+	case CRONOS_SMC_BMC_BOOT_FLASH_SELECT_REG:
+	case CRONOS_SMC_PAYLOAD_POWER_CTL_REG:
+
+	case CRONOS_SMC_BMC_MAC_LOW_REG ... CRONOS_SMC_BMC_MAC_HIGH_REG:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static bool cronos_smc_is_volatile_reg(struct device *dev, unsigned int reg)
+{
+	switch (reg) {
+	case CRONOS_SMC_REVISION_HIGH_REG:
+	case CRONOS_SMC_REVISION_LOW_REG:
+
+	case CRONOS_SMC_SWITCH_BOOT_FLASH_SELECT_REG:
+	case CRONOS_SMC_SWITCH_RESET_CMD_REG:
+	case CRONOS_SMC_BMC_BOOT_FLASH_SELECT_REG:
+	case CRONOS_SMC_PAYLOAD_POWER_CTL_REG:
+
+	case CRONOS_WDT_CTL_REG:
+	case CRONOS_WDT_CLR_REG:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static struct regmap_config cronos_smc_regmap_config = {
+	.reg_bits = 8,
+	.val_bits = 8,
+	.max_register = CRONOS_SMC_REVISION_HIGH_REG,
+	.writeable_reg = cronos_smc_is_writeable_reg,
+	.readable_reg = cronos_smc_is_readable_reg,
+	.volatile_reg = cronos_smc_is_volatile_reg,
+	.use_single_read = true,
+	.use_single_write = true,
+	.cache_type = REGCACHE_MAPLE,
+};
+
+static int sony_cronos_i2c_probe(struct i2c_client *i2c)
+{
+	struct sony_cronos_smc *ddata;
+	int ret;
+
+	ddata = devm_kzalloc(&i2c->dev, sizeof(*ddata), GFP_KERNEL);
+	if (!ddata)
+		return -ENOMEM;
+
+	i2c_set_clientdata(i2c, ddata);
+	ddata->dev = &i2c->dev;
+
+	ddata->regmap = devm_regmap_init_i2c(i2c, &cronos_smc_regmap_config);
+	if (IS_ERR(ddata->regmap)) {
+		return dev_err_probe(ddata->dev, PTR_ERR(ddata->regmap),
+				     "Failed to allocate register map\n");
+	}
+
+	ret = sony_cronos_get_device_type(ddata);
+	if (ret)
+		return ret;
+
+	ret = mfd_add_devices(ddata->dev, PLATFORM_DEVID_AUTO, cronos_smc_devs,
+			      ARRAY_SIZE(cronos_smc_devs), NULL, 0, NULL);
+	if (ret) {
+		return dev_err_probe(ddata->dev, ret,
+				     "Failed to register child devices\n");
+	}
+
+	return ret;
+}
+
+static void sony_cronos_i2c_remove(struct i2c_client *i2c)
+{
+	struct sony_cronos_smc *ddata = i2c_get_clientdata(i2c);
+
+	mfd_remove_devices(ddata->dev);
+}
+
+static struct i2c_driver sony_cronos_i2c_driver = {
+	.driver = {
+		.name = "sony-cronos-smc",
+	},
+	.probe = sony_cronos_i2c_probe,
+	.remove = sony_cronos_i2c_remove,
+};
+module_i2c_driver(sony_cronos_i2c_driver);
+
+MODULE_DESCRIPTION("Device driver for the Sony Cronos system management controller");
+MODULE_AUTHOR("Raptor Engineering, LLC <tpearson@raptorengineering.com>");
+MODULE_LICENSE("GPL");
+
diff --git a/include/linux/mfd/sony-cronos.h b/include/linux/mfd/sony-cronos.h
new file mode 100644
index 000000000000..d82e46176bf7
--- /dev/null
+++ b/include/linux/mfd/sony-cronos.h
@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Copyright (C) 2015-2017  Dialog Semiconductor
+ * Copyright (C) 2022  Raptor Engineering, LLC
+ */
+
+#ifndef __MFD_SONY_CRONOS_H__
+#define __MFD_SONY_CRONOS_H__
+
+#define CRONOS_SMC_DEVICE_ID				0x0134
+
+#define CRONOS_SMC_SWITCH_BOOT_FLASH_SELECT_REG		0x00
+#define CRONOS_SMC_SWITCH_RESET_CMD_REG			0x01
+#define CRONOS_SMC_BMC_BOOT_FLASH_SELECT_REG		0x02
+#define CRONOS_BMC_RESET_REG				0x03
+#define CRONOS_WDT_CLR_REG				0x03
+#define CRONOS_SMC_STATUS_2_REG				0x05
+#define CRONOS_SMC_PAYLOAD_POWER_CTL_REG		0x0a
+#define CRONOS_WDT_CTL_REG				0x0c
+#define CRONOS_SMC_UART_MUX_REG				0x0e
+
+#define CRONOS_SMC_BRIGHTNESS_RED_REG			0x17
+#define CRONOS_SMC_BRIGHTNESS_GREEN_REG			0x18
+#define CRONOS_SMC_BRIGHTNESS_BLUE_REG			0x19
+
+#define CRONOS_LEDS_SMC_STATUS_REG			0x10
+#define CRONOS_LEDS_SWITCH_STATUS_REG			0x11
+
+#define CRONOS_LEDS_CCM3_STATUS_REG			0x12
+#define CRONOS_LEDS_CCM2_STATUS_REG			0x13
+#define CRONOS_LEDS_CCM4_STATUS_REG			0x14
+#define CRONOS_LEDS_CCM1_STATUS_REG			0x15
+
+#define CRONOS_LEDS_CCM_POWER_REG			0x16
+
+#define CRONOS_SMC_BMC_MAC_LOW_REG			0x30
+#define CRONOS_SMC_BMC_MAC_HIGH_REG			0x35
+
+#define CRONOS_SMC_DEVICE_ID_LOW_REG			0x70
+#define CRONOS_SMC_DEVICE_ID_HIGH_REG			0x71
+#define CRONOS_SMC_REVISION_LOW_REG			0x72
+#define CRONOS_SMC_REVISION_HIGH_REG			0x73
+
+#define CRONOS_SMC_LEDS_BRIGHTNESS_SET_MASK		0x7F
+#define CRONOS_LEDS_MAX_BRIGHTNESS			0x7F
+
+#define CRONOS_BMC_RESET_VAL				0xc2
+
+#define CRONOS_WDT_CLR_VAL				0xc3
+#define CRONOS_WDT_ENABLE_MASK				0x80
+#define CRONOS_WDT_ENABLE_VAL				0x80
+#define CRONOS_WDT_DISABLE_VAL				0x00
+#define CRONOS_WDT_TIMEOUT_MASK				0x07
+#define CRONOS_WDT_CTL_RESET_VAL			0x00
+
+struct sony_cronos_smc {
+	struct device *dev;
+	struct regmap *regmap;
+};
+
+#endif /* __MFD_SONY_CRONOS_H__ */
-- 
2.39.5

[PATCH v7 3/4] led: sony-cronos-smc: Add RGB LED driver for Sony Cronos SMC

[Raptor Engineering Development Team]

From: Timothy Pearson <tpearson@raptorengineering.com>

The Sony Cronos Platform Controller is a multi-purpose platform controller with
an integrated multi-channel RGB LED controller.  The LED controller is a
pseudo-RGB device with only two states for each of the RGB subcomponents of
each LED, but is exposed as a full RGB device for ease of integration with
userspace software.  Internal thresholding is used to convert the color values
to the required on/off RGB subcomponent controls.

Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
---
 drivers/leds/Kconfig            |  19 ++
 drivers/leds/Makefile           |   1 +
 drivers/leds/leds-sony-cronos.c | 376 ++++++++++++++++++++++++++++++++
 3 files changed, 396 insertions(+)
 create mode 100644 drivers/leds/leds-sony-cronos.c

diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 11e7282dc297..18bad7c643f3 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -1009,6 +1009,25 @@ config LEDS_IP30
 	  To compile this driver as a module, choose M here: the module
 	  will be called leds-ip30.
 
+config LEDS_SONY_CRONOS
+	tristate "LED support for the Sony Cronos SMC"
+	depends on ARCH_ASPEED || COMPILE_TEST
+	depends on LEDS_CLASS && I2C
+	depends on LEDS_CLASS_MULTICOLOR
+	depends on MFD_SONY_CRONOS_SMC
+
+	help
+	  Say Y here to include support for LEDs for the
+	  Sony Cronos system management controller.
+
+	  All known Cronos systems use the ASpeed AST2600 SoC,
+	  therefore the configuration option is gated on
+	  ARCH_ASPEED selection.  If this changes, add the new
+	  SoCs to the selection list.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called leds-sony-cronos.
+
 config LEDS_ACER_A500
 	tristate "Power button LED support for Acer Iconia Tab A500"
 	depends on LEDS_CLASS && MFD_ACER_A500_EC
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 9a0333ec1a86..6dbcf747cab6 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -84,6 +84,7 @@ obj-$(CONFIG_LEDS_POWERNV)		+= leds-powernv.o
 obj-$(CONFIG_LEDS_PWM)			+= leds-pwm.o
 obj-$(CONFIG_LEDS_QNAP_MCU)		+= leds-qnap-mcu.o
 obj-$(CONFIG_LEDS_REGULATOR)		+= leds-regulator.o
+obj-$(CONFIG_LEDS_SONY_CRONOS)		+= leds-sony-cronos.o
 obj-$(CONFIG_LEDS_SC27XX_BLTC)		+= leds-sc27xx-bltc.o
 obj-$(CONFIG_LEDS_ST1202)		+= leds-st1202.o
 obj-$(CONFIG_LEDS_SUN50I_A100)		+= leds-sun50i-a100.o
diff --git a/drivers/leds/leds-sony-cronos.c b/drivers/leds/leds-sony-cronos.c
new file mode 100644
index 000000000000..e2b40a27421e
--- /dev/null
+++ b/drivers/leds/leds-sony-cronos.c
@@ -0,0 +1,376 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * LED driver for Sony Cronos SMCs
+ * Copyright (C) 2012 Dialog Semiconductor Ltd.
+ * Copyright (C) 2023 Sony Interactive Entertainment
+ * Copyright (C) 2025 Raptor Engineering, LLC
+ */
+
+#include <linux/kernel.h>
+#include <linux/leds.h>
+#include <linux/led-class-multicolor.h>
+#include <linux/mfd/sony-cronos.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+
+/* Masks and Bit shifts */
+#define CRONOS_LEDS_STATUS_FLASHING_MASK	0x40
+#define CRONOS_LEDS_STATUS_FLASHING_SHIFT	6
+#define CRONOS_LEDS_STATUS_COLOR_MASK		0x07
+#define CRONOS_LEDS_STATUS_COLOR_SHIFT		0
+
+#define CRONOS_LEDS_LINK_FLASHING_MASK		0x80
+#define CRONOS_LEDS_LINK_FLASHING_SHIFT		7
+#define CRONOS_LEDS_LINK_COLOR_MASK		0x38
+#define CRONOS_LEDS_LINK_COLOR_SHIFT		3
+
+#define CRONOS_LEDS_CCM1_POWER_COLOR_MASK	0x03
+#define CRONOS_LEDS_CCM1_POWER_COLOR_SHIFT	0
+#define CRONOS_LEDS_CCM2_POWER_COLOR_MASK	0x0C
+#define CRONOS_LEDS_CCM2_POWER_COLOR_SHIFT	2
+#define CRONOS_LEDS_CCM3_POWER_COLOR_MASK	0x30
+#define CRONOS_LEDS_CCM3_POWER_COLOR_SHIFT	4
+#define CRONOS_LEDS_CCM4_POWER_COLOR_MASK	0xC0
+#define CRONOS_LEDS_CCM4_POWER_COLOR_SHIFT	6
+
+/* LED Color mapping - Links and status LEDs */
+#define LED_COLOR_OFF		0x00
+#define LED_COLOR_BLUE		0x01
+#define LED_COLOR_GREEN		0x02
+#define LED_COLOR_RED		0x04
+
+/* LED Color mapping - Power state LEDs */
+#define LED_COLOR_POWER_OFF	0x00
+#define LED_COLOR_POWER_RED	0x02
+#define LED_COLOR_POWER_GREEN	0x01
+
+/* Number of LEDs per type */
+#define LED_COUNT_STATUS	6
+#define LED_COUNT_LINK		5
+#define LED_COUNT_POWER		4
+#define LED_COUNT_ALL (LED_COUNT_STATUS + LED_COUNT_LINK + LED_COUNT_POWER)
+
+enum sony_cronos_led_id {
+	LED_ID_CCM1_STATUS = 0x00,
+	LED_ID_CCM2_STATUS,
+	LED_ID_CCM3_STATUS,
+	LED_ID_CCM4_STATUS,
+	LED_ID_SWITCH_STATUS,
+	LED_ID_SMC_STATUS,
+
+	LED_ID_CCM1_LINK,
+	LED_ID_CCM2_LINK,
+	LED_ID_CCM3_LINK,
+	LED_ID_CCM4_LINK,
+	LED_ID_SWITCH_LINK,
+
+	LED_ID_CCM1_POWER,
+	LED_ID_CCM2_POWER,
+	LED_ID_CCM3_POWER,
+	LED_ID_CCM4_POWER
+};
+
+enum sony_cronos_led_type {
+	LED_TYPE_STATUS,
+	LED_TYPE_LINK,
+	LED_TYPE_POWER,
+};
+
+/**
+ * struct sony_cronos_led - per-LED part of driver private data structure
+ * @mc_cdev:		multi-color LED class device
+ * @subled_info:	per-channel information
+ * @led_register:	led register in the MFD regmap
+ * @led_type:		sie_cronos_led_type
+ * @led_id:		sie_cronos_led_id
+ */
+struct sony_cronos_led {
+	struct led_classdev_mc mc_cdev;
+	struct mc_subled subled_info[LED_COUNT_ALL];
+	u8 led_register;
+	enum sony_cronos_led_type led_type;
+	enum sony_cronos_led_id led_id;
+};
+
+#define to_cronos_led(l) container_of(l, struct sony_cronos_led, mc_cdev)
+
+/**
+ * struct sony_cronos_leds - driver private data structure
+ * @hw:				handle to hw device
+ * @leds:			flexible array of per-LED data
+ */
+struct sony_cronos_leds {
+	struct sony_cronos_smc *hw;
+	struct sony_cronos_led leds[];
+};
+
+static int cronos_led_color_store(struct sony_cronos_smc *chip, struct sony_cronos_led *led)
+{
+	u8 byte;
+	u8 color_mask;
+	u8 color_shift;
+	u8 color_key_red;
+	u8 color_key_green;
+	u8 color_key_blue;
+	int ret;
+
+	if (led->led_type == LED_TYPE_STATUS) {
+		color_mask = CRONOS_LEDS_STATUS_COLOR_MASK;
+		color_shift = CRONOS_LEDS_STATUS_COLOR_SHIFT;
+	} else if (led->led_type == LED_TYPE_LINK) {
+		color_mask = CRONOS_LEDS_LINK_COLOR_MASK;
+		color_shift = CRONOS_LEDS_LINK_COLOR_SHIFT;
+	} else if (led->led_id == LED_ID_CCM1_POWER) {
+		color_mask = CRONOS_LEDS_CCM1_POWER_COLOR_MASK;
+		color_shift = CRONOS_LEDS_CCM1_POWER_COLOR_SHIFT;
+	} else if (led->led_id == LED_ID_CCM2_POWER) {
+		color_mask = CRONOS_LEDS_CCM2_POWER_COLOR_MASK;
+		color_shift = CRONOS_LEDS_CCM2_POWER_COLOR_SHIFT;
+	} else if (led->led_id == LED_ID_CCM3_POWER) {
+		color_mask = CRONOS_LEDS_CCM3_POWER_COLOR_MASK;
+		color_shift = CRONOS_LEDS_CCM3_POWER_COLOR_SHIFT;
+	} else if (led->led_id == LED_ID_CCM4_POWER) {
+		color_mask = CRONOS_LEDS_CCM4_POWER_COLOR_MASK;
+		color_shift = CRONOS_LEDS_CCM4_POWER_COLOR_SHIFT;
+	} else
+		return -EINVAL;
+
+	switch (led->led_type) {
+	case LED_TYPE_POWER:
+		color_key_red = LED_COLOR_POWER_RED;
+		color_key_green = LED_COLOR_POWER_GREEN;
+		/* Blue channel does not exist for CCM power LEDs */
+		color_key_blue = LED_COLOR_POWER_OFF;
+		break;
+	default:
+		color_key_red = LED_COLOR_RED;
+		color_key_green = LED_COLOR_GREEN;
+		color_key_blue = LED_COLOR_BLUE;
+	}
+
+	/* Assemble SMC color command code */
+	byte = LED_COLOR_POWER_OFF;
+	if (led->subled_info[0].brightness > 128)
+		byte |= color_key_red;
+	if (led->subled_info[1].brightness > 128)
+		byte |= color_key_green;
+	if (led->subled_info[2].brightness > 128)
+		byte |= color_key_blue;
+
+	ret = regmap_update_bits(chip->regmap, led->led_register, color_mask, byte << color_shift);
+	if (ret) {
+		dev_err(chip->dev, "Failed to set color value 0x%02x to LED register 0x%02x\n", byte,
+			led->led_register);
+		return ret;
+	}
+	return 0;
+}
+
+static int cronos_led_set_brightness(struct led_classdev *cdev, enum led_brightness brightness)
+{
+	struct led_classdev_mc *mc_cdev = lcdev_to_mccdev(cdev);
+	struct sony_cronos_leds *leds = dev_get_drvdata(cdev->dev->parent);
+	struct sony_cronos_led *led = to_cronos_led(mc_cdev);
+
+	led_mc_calc_color_components(mc_cdev, brightness ?: cdev->max_brightness);
+
+	return cronos_led_color_store(leds->hw, led);
+}
+
+static int sony_cronos_led_register(struct device *dev, struct sony_cronos_leds *leds,
+				    struct sony_cronos_led *led, struct device_node *np)
+{
+	struct led_init_data init_data = {};
+	struct led_classdev *cdev;
+	int led_index;
+	int ret, color;
+
+	ret = of_property_read_u32(np, "reg", &led_index);
+	if (ret || led_index >= LED_COUNT_ALL) {
+		dev_err(dev, "'reg' property is out of range (0-%i)\n", LED_COUNT_ALL - 1);
+		return -EINVAL;
+	}
+
+	switch (led_index) {
+	case 0:
+		led->led_register = CRONOS_LEDS_CCM1_STATUS_REG;
+		led->led_type = LED_TYPE_STATUS;
+		led->led_id = LED_ID_CCM1_STATUS;
+		break;
+	case 1:
+		led->led_register = CRONOS_LEDS_CCM2_STATUS_REG;
+		led->led_type = LED_TYPE_STATUS;
+		led->led_id = LED_ID_CCM2_STATUS;
+		break;
+	case 2:
+		led->led_register = CRONOS_LEDS_CCM3_STATUS_REG;
+		led->led_type = LED_TYPE_STATUS;
+		led->led_id = LED_ID_CCM3_STATUS;
+		break;
+	case 3:
+		led->led_register = CRONOS_LEDS_CCM4_STATUS_REG;
+		led->led_type = LED_TYPE_STATUS;
+		led->led_id = LED_ID_CCM4_STATUS;
+		break;
+	case 4:
+		led->led_register = CRONOS_LEDS_SWITCH_STATUS_REG;
+		led->led_type = LED_TYPE_STATUS;
+		led->led_id = LED_ID_SWITCH_STATUS;
+		break;
+	case 5:
+		led->led_register = CRONOS_LEDS_SMC_STATUS_REG;
+		led->led_type = LED_TYPE_STATUS;
+		led->led_id = LED_ID_SMC_STATUS;
+		break;
+	case 6:
+		led->led_register = CRONOS_LEDS_CCM1_STATUS_REG;
+		led->led_type = LED_TYPE_LINK;
+		led->led_id = LED_ID_CCM1_LINK;
+		break;
+	case 7:
+		led->led_register = CRONOS_LEDS_CCM2_STATUS_REG;
+		led->led_type = LED_TYPE_LINK;
+		led->led_id = LED_ID_CCM1_LINK;
+		break;
+	case 8:
+		led->led_register = CRONOS_LEDS_CCM3_STATUS_REG;
+		led->led_type = LED_TYPE_LINK;
+		led->led_id = LED_ID_CCM2_LINK;
+		break;
+	case 9:
+		led->led_register = CRONOS_LEDS_CCM4_STATUS_REG;
+		led->led_type = LED_TYPE_LINK;
+		led->led_id = LED_ID_CCM3_LINK;
+		break;
+	case 10:
+		led->led_register = CRONOS_LEDS_SWITCH_STATUS_REG;
+		led->led_type = LED_TYPE_LINK;
+		led->led_id = LED_ID_CCM4_LINK;
+		break;
+	case 11:
+		led->led_register = CRONOS_LEDS_CCM_POWER_REG;
+		led->led_type = LED_TYPE_POWER;
+		led->led_id = LED_ID_CCM1_POWER;
+		break;
+	case 12:
+		led->led_register = CRONOS_LEDS_CCM_POWER_REG;
+		led->led_type = LED_TYPE_POWER;
+		led->led_id = LED_ID_CCM2_POWER;
+		break;
+	case 13:
+		led->led_register = CRONOS_LEDS_CCM_POWER_REG;
+		led->led_type = LED_TYPE_POWER;
+		led->led_id = LED_ID_CCM3_POWER;
+		break;
+	case 14:
+		led->led_register = CRONOS_LEDS_CCM_POWER_REG;
+		led->led_type = LED_TYPE_POWER;
+		led->led_id = LED_ID_CCM4_POWER;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	ret = of_property_read_u32(np, "color", &color);
+	if (ret || color != LED_COLOR_ID_RGB) {
+		dev_warn(dev,
+			 "Node %pOF: must contain 'color' property with value LED_COLOR_ID_RGB\n",
+			 np);
+		return -EINVAL;
+	}
+
+	led->subled_info[0].color_index = LED_COLOR_ID_RED;
+	led->subled_info[1].color_index = LED_COLOR_ID_GREEN;
+	led->subled_info[2].color_index = LED_COLOR_ID_BLUE;
+
+	/* Initial color is white */
+	for (int i = 0; i < LED_COUNT_ALL; i++) {
+		led->subled_info[i].intensity = 255;
+		led->subled_info[i].brightness = 255;
+		led->subled_info[i].channel = i;
+	}
+
+	led->mc_cdev.subled_info = led->subled_info;
+	led->mc_cdev.num_colors = LED_COUNT_ALL;
+
+	init_data.fwnode = &np->fwnode;
+
+	cdev = &led->mc_cdev.led_cdev;
+	cdev->max_brightness = 255;
+	cdev->brightness_set_blocking = cronos_led_set_brightness;
+
+	/* Set initial color */
+	ret = cronos_led_color_store(leds->hw, led);
+	if (ret < 0)
+		return dev_err_probe(dev, ret, "Cannot set LED %pOF initial color\n", np);
+
+	ret = devm_led_classdev_multicolor_register_ext(dev, &led->mc_cdev, &init_data);
+	if (ret)
+		return dev_err_probe(dev, ret, "Cannot register LED %pOF\n", np);
+
+	/* Set global brightness for all LEDs */
+	ret = regmap_write(leds->hw->regmap, CRONOS_SMC_BRIGHTNESS_RED_REG, 0x00);
+	ret = regmap_write(leds->hw->regmap, CRONOS_SMC_BRIGHTNESS_GREEN_REG, 0x00);
+	ret = regmap_write(leds->hw->regmap, CRONOS_SMC_BRIGHTNESS_BLUE_REG, 0x00);
+
+	return 0;
+}
+
+static int sony_cronos_leds_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct device_node *np = dev_of_node(dev);
+	struct sony_cronos_smc *chip;
+	struct sony_cronos_leds *leds;
+	struct sony_cronos_led *led;
+	int ret, count;
+
+	chip = dev_get_drvdata(dev->parent);
+	if (!chip)
+		return -EINVAL;
+
+	count = of_get_available_child_count(np);
+	if (count == 0)
+		return dev_err_probe(dev, -ENODEV, "LEDs are not defined in device tree!\n");
+	if (count > LED_COUNT_ALL)
+		return dev_err_probe(dev, -EINVAL, "Too many LEDs defined in device tree!\n");
+
+	leds = devm_kzalloc(dev, struct_size(leds, leds, count), GFP_KERNEL);
+	if (!leds)
+		return -ENOMEM;
+
+	leds->hw = chip;
+
+	led = &leds->leds[0];
+	for_each_available_child_of_node_scoped(np, child) {
+		ret = sony_cronos_led_register(dev, leds, led, child);
+		if (ret)
+			return ret;
+
+		led++;
+	}
+
+	return 0;
+}
+
+static const struct of_device_id sony_cronos_led_of_id_table[] = {
+	{ .compatible = "sie,cronos-led" },
+	{},
+};
+MODULE_DEVICE_TABLE(of, sony_cronos_led_of_id_table);
+
+static struct platform_driver sony_cronos_led_driver = {
+	.driver = {
+		.name = "sie-cronos-led",
+		.of_match_table = sony_cronos_led_of_id_table,
+	},
+	.probe = sony_cronos_leds_probe,
+};
+module_platform_driver(sony_cronos_led_driver);
+
+MODULE_DESCRIPTION("LED driver for SIE Cronos SMCs");
+MODULE_AUTHOR("Timothy Pearson <tpearson@raptorengineering.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:sony-cronos-leds");
-- 
2.39.5

[PATCH v7 4/4] watchdog: sony-cronos-smc: Add watchdog driver for Sony Cronos SMC

[Raptor Engineering Development Team]

From: Timothy Pearson <tpearson@raptorengineering.com>

The Sony Cronos Platform Controller is a multi-purpose platform controller with
an integrated watchdog.  Add the watchdog driver for the Cronos SMC.

Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
---
 drivers/watchdog/Kconfig           |  17 ++
 drivers/watchdog/Makefile          |   1 +
 drivers/watchdog/sony-cronos-wdt.c | 283 +++++++++++++++++++++++++++++
 3 files changed, 301 insertions(+)
 create mode 100644 drivers/watchdog/sony-cronos-wdt.c

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index d3b9df7d466b..9001e4184e9d 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -416,6 +416,23 @@ config SL28CPLD_WATCHDOG
 	  To compile this driver as a module, choose M here: the
 	  module will be called sl28cpld_wdt.
 
+config SONY_CRONOS_WATCHDOG
+	tristate "Sony Cronos CPLD Watchdog"
+	depends on ARCH_ASPEED || COMPILE_TEST
+	depends on I2C
+	select WATCHDOG_CORE
+	help
+	  Say Y here to include support for the watchdog timer
+	  for the Sony Cronos control CPLD.
+
+	  All known Cronos systems use the ASpeed AST2600 SoC,
+	  therefore the configuration option is gated on
+	  ARCH_ASPEED selection.  If this changes, add the new
+	  SoCs to the selection list.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called sony-cronos-wdt.
+
 # ALPHA Architecture
 
 # ARM Architecture
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index ba52099b1253..aa4d7aa15613 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -244,3 +244,4 @@ obj-$(CONFIG_MENZ069_WATCHDOG) += menz69_wdt.o
 obj-$(CONFIG_RAVE_SP_WATCHDOG) += rave-sp-wdt.o
 obj-$(CONFIG_STPMIC1_WATCHDOG) += stpmic1_wdt.o
 obj-$(CONFIG_SL28CPLD_WATCHDOG) += sl28cpld_wdt.o
+obj-$(CONFIG_SONY_CRONOS_WATCHDOG) += sony-cronos-wdt.o
diff --git a/drivers/watchdog/sony-cronos-wdt.c b/drivers/watchdog/sony-cronos-wdt.c
new file mode 100644
index 000000000000..650fcee28885
--- /dev/null
+++ b/drivers/watchdog/sony-cronos-wdt.c
@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Watchdog device driver for Sony Cronos SMCs
+ * Copyright (C) 2015 Dialog Semiconductor Ltd.
+ * Copyright (C) 2022-2025 Raptor Engineering, LLC
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/mfd/sony-cronos.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/property.h>
+#include <linux/regmap.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/watchdog.h>
+
+static const unsigned int wdt_timeout[] = { 10, 80 };
+static const unsigned int wdt_timeout_ctl_bits[] = { 0x1, 0x0 };
+#define CRONOS_TWDSCALE_DISABLE 0
+#define CRONOS_TWDSCALE_MIN 1
+#define CRONOS_TWDSCALE_MAX (ARRAY_SIZE(wdt_timeout) - 1)
+#define CRONOS_WDT_MIN_TIMEOUT wdt_timeout[CRONOS_TWDSCALE_MIN]
+#define CRONOS_WDT_MAX_TIMEOUT wdt_timeout[CRONOS_TWDSCALE_MAX]
+#define CRONOS_WDG_DEFAULT_TIMEOUT wdt_timeout[CRONOS_TWDSCALE_MAX]
+
+struct sony_cronos_watchdog {
+	struct sony_cronos_smc *hw;
+	struct watchdog_device wdtdev;
+};
+
+static unsigned int sony_cronos_wdt_read_timeout(struct sony_cronos_watchdog *wdt)
+{
+	unsigned int i;
+	unsigned int val;
+
+	regmap_read(wdt->hw->regmap, CRONOS_WDT_CTL_REG, &val);
+
+	for (i = CRONOS_TWDSCALE_MIN; i <= CRONOS_TWDSCALE_MAX; i++) {
+		if (wdt_timeout_ctl_bits[i] == (val & CRONOS_WDT_TIMEOUT_MASK))
+			return wdt_timeout[i];
+	}
+
+	dev_err(wdt->hw->dev, "Invalid configuration data present in watchdog control register!\n");
+	return wdt_timeout[CRONOS_WDT_MIN_TIMEOUT];
+}
+
+static unsigned int sony_cronos_wdt_timeout_to_sel(unsigned int secs)
+{
+	unsigned int i;
+
+	for (i = CRONOS_TWDSCALE_MIN; i <= CRONOS_TWDSCALE_MAX; i++) {
+		if (wdt_timeout[i] >= secs)
+			return wdt_timeout_ctl_bits[i];
+	}
+
+	return wdt_timeout_ctl_bits[CRONOS_TWDSCALE_MAX];
+}
+
+static int sony_cronos_reset_watchdog_timer(struct sony_cronos_watchdog *wdt)
+{
+	return regmap_write(wdt->hw->regmap, CRONOS_WDT_CLR_REG, CRONOS_WDT_CLR_VAL);
+}
+
+static int sony_cronos_wdt_update_timeout_register(struct sony_cronos_watchdog *wdt,
+						   unsigned int regval)
+{
+	int ret;
+
+	struct sony_cronos_smc *chip = wdt->hw;
+
+	ret = sony_cronos_reset_watchdog_timer(wdt);
+	if (ret) {
+		dev_err(wdt->hw->dev, "Watchdog failed to reset (err = %d)\n", ret);
+		goto done;
+	}
+
+	return regmap_update_bits(chip->regmap, CRONOS_WDT_CTL_REG, CRONOS_WDT_TIMEOUT_MASK,
+				  regval);
+
+done:
+	return ret;
+}
+
+static int sony_cronos_wdt_start(struct watchdog_device *wdd)
+{
+	struct sony_cronos_watchdog *wdt = watchdog_get_drvdata(wdd);
+	struct sony_cronos_smc *chip = wdt->hw;
+	unsigned int selector;
+	int ret;
+
+	selector = sony_cronos_wdt_timeout_to_sel(wdt->wdtdev.timeout);
+	ret = sony_cronos_wdt_update_timeout_register(wdt, selector);
+	if (ret) {
+		dev_err(wdt->hw->dev, "Watchdog prestart configuration failed (err = %d)\n", ret);
+		goto done;
+	}
+
+	ret = regmap_update_bits(chip->regmap, CRONOS_WDT_CTL_REG, CRONOS_WDT_ENABLE_MASK, 1);
+
+	if (ret)
+		dev_err(wdt->hw->dev, "Watchdog failed to start (err = %d)\n", ret);
+
+done:
+	return ret;
+}
+
+static int sony_cronos_wdt_stop(struct watchdog_device *wdd)
+{
+	struct sony_cronos_watchdog *wdt = watchdog_get_drvdata(wdd);
+	struct sony_cronos_smc *chip = wdt->hw;
+	int ret;
+
+	ret = regmap_update_bits(chip->regmap, CRONOS_WDT_CTL_REG, CRONOS_WDT_ENABLE_MASK, 1);
+	if (ret)
+		dev_err(wdt->hw->dev, "Watchdog failed to stop (err = %d)\n", ret);
+
+	return ret;
+}
+
+static int sony_cronos_wdt_ping(struct watchdog_device *wdd)
+{
+	struct sony_cronos_watchdog *wdt = watchdog_get_drvdata(wdd);
+	int ret;
+
+	/*
+	 * Prevent pings from occurring late in system poweroff/reboot sequence
+	 * and possibly locking out restart handler from accessing i2c bus.
+	 */
+	if (system_state > SYSTEM_RUNNING)
+		return 0;
+
+	ret = sony_cronos_reset_watchdog_timer(wdt);
+	if (ret)
+		dev_err(wdt->hw->dev, "Failed to ping the watchdog (err = %d)\n", ret);
+
+	return ret;
+}
+
+static int sony_cronos_wdt_set_timeout(struct watchdog_device *wdd, unsigned int timeout)
+{
+	struct sony_cronos_watchdog *wdt = watchdog_get_drvdata(wdd);
+	unsigned int selector;
+	int ret;
+
+	selector = sony_cronos_wdt_timeout_to_sel(timeout);
+	ret = sony_cronos_wdt_update_timeout_register(wdt, selector);
+	if (ret)
+		dev_err(wdt->hw->dev, "Failed to set watchdog timeout (err = %d)\n", ret);
+	else
+		wdd->timeout = wdt_timeout[selector];
+
+	return ret;
+}
+
+static int sony_cronos_wdt_restart(struct watchdog_device *wdd, unsigned long action, void *data)
+{
+	struct sony_cronos_watchdog *wdt = watchdog_get_drvdata(wdd);
+	struct i2c_client *client = to_i2c_client(wdt->hw->dev);
+	int ret;
+
+	/* Don't use regmap because it is not atomic safe */
+	ret = i2c_smbus_write_byte_data(client, CRONOS_WDT_CTL_REG, CRONOS_WDT_CTL_RESET_VAL);
+	ret = i2c_smbus_write_byte_data(client, CRONOS_BMC_RESET_REG, CRONOS_BMC_RESET_VAL);
+	if (ret < 0)
+		dev_alert(wdt->hw->dev, "Failed to shutdown (err = %d)\n", ret);
+
+	/* wait for reset to assert... */
+	mdelay(500);
+
+	return ret;
+}
+
+static const struct watchdog_info sony_cronos_watchdog_info = {
+	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+	.identity = "Sony Cronos WDT",
+};
+
+static const struct watchdog_ops sony_cronos_watchdog_ops = {
+	.owner = THIS_MODULE,
+	.start = sony_cronos_wdt_start,
+	.stop = sony_cronos_wdt_stop,
+	.ping = sony_cronos_wdt_ping,
+	.set_timeout = sony_cronos_wdt_set_timeout,
+	.restart = sony_cronos_wdt_restart,
+};
+
+static const struct of_device_id sony_cronos_compatible_id_table[] = {
+	{
+		.compatible = "sony,cronos-watchdog",
+	},
+	{},
+};
+
+MODULE_DEVICE_TABLE(of, sony_cronos_compatible_id_table);
+
+static int sony_cronos_wdt_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	unsigned int timeout;
+	struct sony_cronos_smc *chip;
+	struct sony_cronos_watchdog *wdt;
+
+	chip = dev_get_drvdata(dev->parent);
+	if (!chip)
+		return -EINVAL;
+
+	wdt = devm_kzalloc(dev, sizeof(*wdt), GFP_KERNEL);
+	if (!wdt)
+		return -ENOMEM;
+
+	wdt->hw = chip;
+
+	wdt->wdtdev.info = &sony_cronos_watchdog_info;
+	wdt->wdtdev.ops = &sony_cronos_watchdog_ops;
+	wdt->wdtdev.min_timeout = CRONOS_WDT_MIN_TIMEOUT;
+	wdt->wdtdev.max_timeout = CRONOS_WDT_MAX_TIMEOUT;
+	wdt->wdtdev.min_hw_heartbeat_ms = 0;
+	wdt->wdtdev.timeout = CRONOS_WDG_DEFAULT_TIMEOUT;
+	wdt->wdtdev.status = WATCHDOG_NOWAYOUT_INIT_STATUS;
+	wdt->wdtdev.parent = dev;
+
+	watchdog_set_restart_priority(&wdt->wdtdev, 128);
+
+	watchdog_set_drvdata(&wdt->wdtdev, wdt);
+	dev_set_drvdata(dev, &wdt->wdtdev);
+
+	timeout = sony_cronos_wdt_read_timeout(wdt);
+	if (timeout)
+		wdt->wdtdev.timeout = timeout;
+
+	/* Set timeout from DT value if available */
+	watchdog_init_timeout(&wdt->wdtdev, 0, dev->parent);
+
+	if (timeout) {
+		sony_cronos_wdt_set_timeout(&wdt->wdtdev, wdt->wdtdev.timeout);
+		set_bit(WDOG_HW_RUNNING, &wdt->wdtdev.status);
+	}
+
+	return devm_watchdog_register_device(dev, &wdt->wdtdev);
+}
+
+static int __maybe_unused sony_cronos_wdt_suspend(struct device *dev)
+{
+	struct watchdog_device *wdd = dev_get_drvdata(dev);
+
+	if (watchdog_active(wdd))
+		return sony_cronos_wdt_stop(wdd);
+
+	return 0;
+}
+
+static int __maybe_unused sony_cronos_wdt_resume(struct device *dev)
+{
+	struct watchdog_device *wdd = dev_get_drvdata(dev);
+
+	if (watchdog_active(wdd))
+		return sony_cronos_wdt_start(wdd);
+
+	return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(sony_cronos_wdt_pm_ops, sony_cronos_wdt_suspend, sony_cronos_wdt_resume);
+
+static struct platform_driver sony_cronos_wdt_driver = {
+	.probe = sony_cronos_wdt_probe,
+	.driver = {
+		.name = "sony-cronos-watchdog",
+		.pm = &sony_cronos_wdt_pm_ops,
+		.of_match_table = sony_cronos_compatible_id_table,
+	},
+};
+module_platform_driver(sony_cronos_wdt_driver);
+
+MODULE_AUTHOR("Raptor Engineering, LLC <tpearson@raptorengineering.com>");
+MODULE_DESCRIPTION("WDT device driver for Sony Cronos SMCs");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:sony-cronos-watchdog");
-- 
2.39.5

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Rob Herring]

On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team wrote:
> From: Shawn Anastasio <sanastasio@raptorengineering.com>
> 
> The Sony Cronos Platform Controller is a multi-purpose platform controller
> that provides both a watchdog timer and an LED controller for the Sony
> Interactive Entertainment Cronos x86 server platform. As both functions
> are provided by the same CPLD, a multi-function device is exposed as the
> parent of both functions.

Why do we have DT bindings for a x86 server platform?

Rob

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Lee Jones]

On Mon, 09 Feb 2026, Rob Herring wrote:

> On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team wrote:
> > From: Shawn Anastasio <sanastasio@raptorengineering.com>
> > 
> > The Sony Cronos Platform Controller is a multi-purpose platform controller
> > that provides both a watchdog timer and an LED controller for the Sony
> > Interactive Entertainment Cronos x86 server platform. As both functions
> > are provided by the same CPLD, a multi-function device is exposed as the
> > parent of both functions.
> 
> Why do we have DT bindings for a x86 server platform?

This looks like an ARM device that connects to an x86 platform.

Note: The drivers look okay, but we need a DT Ack to merged them.

-- 
Lee Jones [李琼斯]

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Conor Dooley]

[-- Attachment #1: Type: text/plain, Size: 1393 bytes --]

On Fri, Mar 06, 2026 at 08:31:01AM +0000, Lee Jones wrote:
> On Mon, 09 Feb 2026, Rob Herring wrote:
> 
> > On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team wrote:
> > > From: Shawn Anastasio <sanastasio@raptorengineering.com>
> > > 
> > > The Sony Cronos Platform Controller is a multi-purpose platform controller
> > > that provides both a watchdog timer and an LED controller for the Sony
> > > Interactive Entertainment Cronos x86 server platform. As both functions
> > > are provided by the same CPLD, a multi-function device is exposed as the
> > > parent of both functions.
> > 
> > Why do we have DT bindings for a x86 server platform?
> 
> This looks like an ARM device that connects to an x86 platform.

I dunno. The text talks about "this" being a cpld, so at best it would
have to be connected to an arm SoC that's on the x86 platform's board,
acting as a BMC or something similar.
Unless by "this" you don't mean the device in the binding, but rather
the platform that the device in the binding is connected to.

I've kept this in my mailbox for the last month, because I was wondering
the same thing as Rob, and there's been no engagement from the submitter
at all. I don't think that that should be rewarded by trying to give the
benefit of the doubt.

> Note: The drivers look okay, but we need a DT Ack to merged them.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Timothy Pearson]

----- Original Message -----
> From: "Conor Dooley" <conor@kernel.org>
> To: "Lee Jones" <lee@kernel.org>
> Cc: "robh" <robh@kernel.org>, "Raptor Engineering Development Team" <support@raptorengineering.com>, "devicetree"
> <devicetree@vger.kernel.org>, "linux-kernel" <linux-kernel@vger.kernel.org>, "Conor Dooley" <conor+dt@kernel.org>,
> "Krzysztof Kozlowski" <krzysztof.kozlowski+dt@linaro.org>, "Georgy Yakovlev" <Georgy.Yakovlev@sony.com>, "Shawn
> Anastasio" <sanastasio@raptorengineering.com>, "Timothy Pearson" <tpearson@raptorengineering.com>
> Sent: Friday, March 6, 2026 10:49:56 AM
> Subject: Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

> On Fri, Mar 06, 2026 at 08:31:01AM +0000, Lee Jones wrote:
>> On Mon, 09 Feb 2026, Rob Herring wrote:
>> 
>> > On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team
>> > wrote:
>> > > From: Shawn Anastasio <sanastasio@raptorengineering.com>
>> > > 
>> > > The Sony Cronos Platform Controller is a multi-purpose platform controller
>> > > that provides both a watchdog timer and an LED controller for the Sony
>> > > Interactive Entertainment Cronos x86 server platform. As both functions
>> > > are provided by the same CPLD, a multi-function device is exposed as the
>> > > parent of both functions.
>> > 
>> > Why do we have DT bindings for a x86 server platform?
>> 
>> This looks like an ARM device that connects to an x86 platform.
> 
> I dunno. The text talks about "this" being a cpld, so at best it would
> have to be connected to an arm SoC that's on the x86 platform's board,
> acting as a BMC or something similar.
> Unless by "this" you don't mean the device in the binding, but rather
> the platform that the device in the binding is connected to.
> 
> I've kept this in my mailbox for the last month, because I was wondering
> the same thing as Rob, and there's been no engagement from the submitter
> at all. I don't think that that should be rewarded by trying to give the
> benefit of the doubt.

Apologies for the lack of response, I hadn't seen the initial Email.

As suspected, this patch set is required to enable the ARM-based BMC SoC on the custom x86 server platform.  The peripherals in question are attached directly to the BMC, hence the need to have DT bindings for their drivers.  The BMC runs the OpenBMC firmware stack, which does not accept downstream patches to the Linux kernel and thus the Linux kernel itself ends up as a gate for new BMC platform enablement.

Thank you!

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Conor Dooley]

[-- Attachment #1: Type: text/plain, Size: 5026 bytes --]

On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team wrote:
> From: Shawn Anastasio <sanastasio@raptorengineering.com>
> 
> The Sony Cronos Platform Controller is a multi-purpose platform controller
> that provides both a watchdog timer and an LED controller for the Sony
> Interactive Entertainment Cronos x86 server platform. As both functions
> are provided by the same CPLD, a multi-function device is exposed as the
> parent of both functions.
> 
> Add a DT binding for this device.
> 
> Signed-off-by: Shawn Anastasio <sanastasio@raptorengineering.com>
> Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
> ---
>  .../bindings/mfd/sony,cronos-smc.yaml         | 128 ++++++++++++++++++
>  1 file changed, 128 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> 
> diff --git a/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> new file mode 100644
> index 000000000000..a7e88fd42d39
> --- /dev/null
> +++ b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> @@ -0,0 +1,128 @@
> +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
> +# Copyright 2025-2026 Raptor Engineering, LLC
> +%YAML 1.2
> +---
> +$id: http://devicetree.org/schemas/mfd/sony,cronos-smc.yaml#
> +$schema: http://devicetree.org/meta-schemas/core.yaml#
> +
> +title: Sony Cronos Platform Controller CPLD multi-function device
> +
> +maintainers:
> +  - Georgy Yakovlev <Georgy.Yakovlev@sony.com>
> +
> +description:
> +  The Sony Cronos Platform Controller CPLD is a multi-purpose platform
> +  controller that provides both a watchdog timer and an LED controller for the
> +  Sony Interactive Entertainment Cronos x86 server platform. As both functions
> +  are provided by the same CPLD, a multi-function device is exposed as the
> +  parent of both functions.
> +
> +properties:
> +  compatible:
> +    const: sony,cronos-smc
> +
> +  reg:
> +    maxItems: 1
> +
> +  leds:
> +    type: object
> +    $ref: /schemas/leds/common.yaml#
> +    additionalProperties: false
> +    description: |
> +      The Cronos LED controller is a subfunction of the Cronos platform
> +      controller, which is a multi-function device.
> +
> +      Each led is represented as a child node of sony,cronos-led. Fifteen RGB
> +      LEDs are supported by the platform.
> +
> +    properties:
> +      compatible:
> +        const: sony,cronos-led
> +
> +      reg:
> +        maxItems: 1
> +
> +      "#address-cells":
> +        const: 1
> +
> +      "#size-cells":
> +        const: 0
> +
> +    patternProperties:
> +      "^multi-led@[0-9a-f]$":
> +        type: object
> +        $ref: /schemas/leds/leds-class-multicolor.yaml#
> +        unevaluatedProperties: false
> +
> +        properties:
> +          reg:
> +            description:
> +              LED channel number (0..14)
> +            minimum: 0
> +            maximum: 14
> +
> +        required:
> +          - reg
> +
> +    required:
> +      - compatible
> +      - "#address-cells"
> +      - "#size-cells"
> +
> +  watchdog:
> +    type: object
> +
> +    $ref: /schemas/watchdog/watchdog.yaml
> +
> +    properties:
> +      compatible:
> +        const: sony,cronos-watchdog
> +
> +      timeout-sec: true

Why is there a child node to just add timeout-sec? Didn't Krzysztof ask
you to come up with a generic node name for the mfd to use instead of
"smc", and to modify watchdog.yaml to accept the new node name? See
here:
https://lore.kernel.org/all/c7630eb1-2686-491e-81ed-fb43fff2dd31@linaro.org/

Something like "platform-controller" sounds generic to me, in a way that
"smc" doesn't.

Cheers,
Conor.

> +
> +    required:
> +      - compatible
> +
> +    additionalProperties: false
> +
> +required:
> +  - compatible
> +  - reg
> +
> +unevaluatedProperties: false
> +
> +examples:
> +  - |
> +    #include <dt-bindings/leds/common.h>
> +    i2c {
> +        #address-cells = <1>;
> +        #size-cells = <0>;
> +
> +        smc@3f {
> +            compatible = "sony,cronos-smc";
> +            reg = <0x3f>;
> +
> +            watchdog {
> +                compatible = "sony,cronos-watchdog";
> +
> +                timeout-sec = <20>;
> +            };
> +
> +            leds {
> +                compatible = "sony,cronos-led";
> +                #address-cells = <1>;
> +                #size-cells = <0>;
> +
> +                multi-led@0 {
> +                    /*
> +                     * No subnodes are needed, this controller only supports RGB
> +                     * LEDs.
> +                     */
> +                    reg = <0>;
> +                    color = <LED_COLOR_ID_MULTI>;
> +                    function = LED_FUNCTION_STATUS;
> +                };
> +            };
> +        };
> +    };
> +
> -- 
> 2.39.5
> 

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Timothy Pearson]

----- Original Message -----
> From: "Conor Dooley" <conor@kernel.org>
> To: "Raptor Engineering Development Team" <support@raptorengineering.com>
> Cc: "devicetree" <devicetree@vger.kernel.org>, "linux-kernel" <linux-kernel@vger.kernel.org>, "Rob Herring"
> <robh+dt@kernel.org>, "Conor Dooley" <conor+dt@kernel.org>, "Krzysztof Kozlowski" <krzysztof.kozlowski+dt@linaro.org>,
> "Lee Jones" <lee@kernel.org>, "Georgy Yakovlev" <Georgy.Yakovlev@sony.com>, "Shawn Anastasio"
> <sanastasio@raptorengineering.com>, "Timothy Pearson" <tpearson@raptorengineering.com>
> Sent: Friday, March 6, 2026 11:49:18 AM
> Subject: Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

> On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team
> wrote:
>> From: Shawn Anastasio <sanastasio@raptorengineering.com>
>> 
>> The Sony Cronos Platform Controller is a multi-purpose platform controller
>> that provides both a watchdog timer and an LED controller for the Sony
>> Interactive Entertainment Cronos x86 server platform. As both functions
>> are provided by the same CPLD, a multi-function device is exposed as the
>> parent of both functions.
>> 
>> Add a DT binding for this device.
>> 
>> Signed-off-by: Shawn Anastasio <sanastasio@raptorengineering.com>
>> Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
>> ---
>>  .../bindings/mfd/sony,cronos-smc.yaml         | 128 ++++++++++++++++++
>>  1 file changed, 128 insertions(+)
>>  create mode 100644 Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> 
>> diff --git a/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> new file mode 100644
>> index 000000000000..a7e88fd42d39
>> --- /dev/null
>> +++ b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> @@ -0,0 +1,128 @@
>> +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
>> +# Copyright 2025-2026 Raptor Engineering, LLC
>> +%YAML 1.2
>> +---
>> +$id: http://devicetree.org/schemas/mfd/sony,cronos-smc.yaml#
>> +$schema: http://devicetree.org/meta-schemas/core.yaml#
>> +
>> +title: Sony Cronos Platform Controller CPLD multi-function device
>> +
>> +maintainers:
>> +  - Georgy Yakovlev <Georgy.Yakovlev@sony.com>
>> +
>> +description:
>> +  The Sony Cronos Platform Controller CPLD is a multi-purpose platform
>> +  controller that provides both a watchdog timer and an LED controller for the
>> +  Sony Interactive Entertainment Cronos x86 server platform. As both functions
>> +  are provided by the same CPLD, a multi-function device is exposed as the
>> +  parent of both functions.
>> +
>> +properties:
>> +  compatible:
>> +    const: sony,cronos-smc
>> +
>> +  reg:
>> +    maxItems: 1
>> +
>> +  leds:
>> +    type: object
>> +    $ref: /schemas/leds/common.yaml#
>> +    additionalProperties: false
>> +    description: |
>> +      The Cronos LED controller is a subfunction of the Cronos platform
>> +      controller, which is a multi-function device.
>> +
>> +      Each led is represented as a child node of sony,cronos-led. Fifteen RGB
>> +      LEDs are supported by the platform.
>> +
>> +    properties:
>> +      compatible:
>> +        const: sony,cronos-led
>> +
>> +      reg:
>> +        maxItems: 1
>> +
>> +      "#address-cells":
>> +        const: 1
>> +
>> +      "#size-cells":
>> +        const: 0
>> +
>> +    patternProperties:
>> +      "^multi-led@[0-9a-f]$":
>> +        type: object
>> +        $ref: /schemas/leds/leds-class-multicolor.yaml#
>> +        unevaluatedProperties: false
>> +
>> +        properties:
>> +          reg:
>> +            description:
>> +              LED channel number (0..14)
>> +            minimum: 0
>> +            maximum: 14
>> +
>> +        required:
>> +          - reg
>> +
>> +    required:
>> +      - compatible
>> +      - "#address-cells"
>> +      - "#size-cells"
>> +
>> +  watchdog:
>> +    type: object
>> +
>> +    $ref: /schemas/watchdog/watchdog.yaml
>> +
>> +    properties:
>> +      compatible:
>> +        const: sony,cronos-watchdog
>> +
>> +      timeout-sec: true
> 
> Why is there a child node to just add timeout-sec?

When I tried Krzysztof's solution, the validation tools threw an error, and this was the only way I found to get them to stop throwing errors.

> Didn't Krzysztof ask
> you to come up with a generic node name for the mfd to use instead of
> "smc", and to modify watchdog.yaml to accept the new node name? See
> here:
> https://lore.kernel.org/all/c7630eb1-2686-491e-81ed-fb43fff2dd31@linaro.org/
> 
> Something like "platform-controller" sounds generic to me, in a way that
> "smc" doesn't.

SMC is the name of the hardware block in question.  platform-controller generates some other confusion as there would be multiple separate hardware blocks that could fit that name.

> 
>> +
>> +    required:
>> +      - compatible
>> +
>> +    additionalProperties: false
>> +
>> +required:
>> +  - compatible
>> +  - reg
>> +
>> +unevaluatedProperties: false
>> +
>> +examples:
>> +  - |
>> +    #include <dt-bindings/leds/common.h>
>> +    i2c {
>> +        #address-cells = <1>;
>> +        #size-cells = <0>;
>> +
>> +        smc@3f {
>> +            compatible = "sony,cronos-smc";
>> +            reg = <0x3f>;
>> +
>> +            watchdog {
>> +                compatible = "sony,cronos-watchdog";
>> +
>> +                timeout-sec = <20>;
>> +            };
>> +
>> +            leds {
>> +                compatible = "sony,cronos-led";
>> +                #address-cells = <1>;
>> +                #size-cells = <0>;
>> +
>> +                multi-led@0 {
>> +                    /*
>> +                     * No subnodes are needed, this controller only supports
>> RGB
>> +                     * LEDs.
>> +                     */
>> +                    reg = <0>;
>> +                    color = <LED_COLOR_ID_MULTI>;
>> +                    function = LED_FUNCTION_STATUS;
>> +                };
>> +            };
>> +        };
>> +    };
>> +
>> --
>> 2.39.5

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Conor Dooley]

[-- Attachment #1: Type: text/plain, Size: 7420 bytes --]

On Fri, Mar 06, 2026 at 11:52:23AM -0600, Timothy Pearson wrote:
> 
> 
> ----- Original Message -----
> > From: "Conor Dooley" <conor@kernel.org>
> > To: "Raptor Engineering Development Team" <support@raptorengineering.com>
> > Cc: "devicetree" <devicetree@vger.kernel.org>, "linux-kernel" <linux-kernel@vger.kernel.org>, "Rob Herring"
> > <robh+dt@kernel.org>, "Conor Dooley" <conor+dt@kernel.org>, "Krzysztof Kozlowski" <krzysztof.kozlowski+dt@linaro.org>,
> > "Lee Jones" <lee@kernel.org>, "Georgy Yakovlev" <Georgy.Yakovlev@sony.com>, "Shawn Anastasio"
> > <sanastasio@raptorengineering.com>, "Timothy Pearson" <tpearson@raptorengineering.com>
> > Sent: Friday, March 6, 2026 11:49:18 AM
> > Subject: Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc
> 
> > On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team
> > wrote:
> >> From: Shawn Anastasio <sanastasio@raptorengineering.com>
> >> 
> >> The Sony Cronos Platform Controller is a multi-purpose platform controller
> >> that provides both a watchdog timer and an LED controller for the Sony
> >> Interactive Entertainment Cronos x86 server platform. As both functions
> >> are provided by the same CPLD, a multi-function device is exposed as the
> >> parent of both functions.
> >> 
> >> Add a DT binding for this device.
> >> 
> >> Signed-off-by: Shawn Anastasio <sanastasio@raptorengineering.com>
> >> Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
> >> ---
> >>  .../bindings/mfd/sony,cronos-smc.yaml         | 128 ++++++++++++++++++
> >>  1 file changed, 128 insertions(+)
> >>  create mode 100644 Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> >> 
> >> diff --git a/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> >> b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> >> new file mode 100644
> >> index 000000000000..a7e88fd42d39
> >> --- /dev/null
> >> +++ b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
> >> @@ -0,0 +1,128 @@
> >> +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
> >> +# Copyright 2025-2026 Raptor Engineering, LLC
> >> +%YAML 1.2
> >> +---
> >> +$id: http://devicetree.org/schemas/mfd/sony,cronos-smc.yaml#
> >> +$schema: http://devicetree.org/meta-schemas/core.yaml#
> >> +
> >> +title: Sony Cronos Platform Controller CPLD multi-function device
> >> +
> >> +maintainers:
> >> +  - Georgy Yakovlev <Georgy.Yakovlev@sony.com>
> >> +
> >> +description:
> >> +  The Sony Cronos Platform Controller CPLD is a multi-purpose platform
> >> +  controller that provides both a watchdog timer and an LED controller for the
> >> +  Sony Interactive Entertainment Cronos x86 server platform. As both functions
> >> +  are provided by the same CPLD, a multi-function device is exposed as the
> >> +  parent of both functions.
> >> +
> >> +properties:
> >> +  compatible:
> >> +    const: sony,cronos-smc
> >> +
> >> +  reg:
> >> +    maxItems: 1
> >> +
> >> +  leds:
> >> +    type: object
> >> +    $ref: /schemas/leds/common.yaml#
> >> +    additionalProperties: false
> >> +    description: |
> >> +      The Cronos LED controller is a subfunction of the Cronos platform
> >> +      controller, which is a multi-function device.
> >> +
> >> +      Each led is represented as a child node of sony,cronos-led. Fifteen RGB
> >> +      LEDs are supported by the platform.
> >> +
> >> +    properties:
> >> +      compatible:
> >> +        const: sony,cronos-led
> >> +
> >> +      reg:
> >> +        maxItems: 1
> >> +
> >> +      "#address-cells":
> >> +        const: 1
> >> +
> >> +      "#size-cells":
> >> +        const: 0
> >> +
> >> +    patternProperties:
> >> +      "^multi-led@[0-9a-f]$":
> >> +        type: object
> >> +        $ref: /schemas/leds/leds-class-multicolor.yaml#
> >> +        unevaluatedProperties: false
> >> +
> >> +        properties:
> >> +          reg:
> >> +            description:
> >> +              LED channel number (0..14)
> >> +            minimum: 0
> >> +            maximum: 14
> >> +
> >> +        required:
> >> +          - reg
> >> +
> >> +    required:
> >> +      - compatible
> >> +      - "#address-cells"
> >> +      - "#size-cells"
> >> +
> >> +  watchdog:
> >> +    type: object
> >> +
> >> +    $ref: /schemas/watchdog/watchdog.yaml
> >> +
> >> +    properties:
> >> +      compatible:
> >> +        const: sony,cronos-watchdog
> >> +
> >> +      timeout-sec: true
> > 
> > Why is there a child node to just add timeout-sec?
> 
> When I tried Krzysztof's solution, the validation tools threw an error, and this was the only way I found to get them to stop throwing errors.

So you were not able to do what he did, and modify watchdog.yaml?
What did you try, and what were the errors?

> 
> > Didn't Krzysztof ask
> > you to come up with a generic node name for the mfd to use instead of
> > "smc", and to modify watchdog.yaml to accept the new node name? See
> > here:
> > https://lore.kernel.org/all/c7630eb1-2686-491e-81ed-fb43fff2dd31@linaro.org/
> > 
> > Something like "platform-controller" sounds generic to me, in a way that
> > "smc" doesn't.
> 
> SMC is the name of the hardware block in question.  platform-controller generates some other confusion as there would be multiple separate hardware blocks that could fit that name.

Node names do not have to be unique. If there are 10 platform controllers
on the platform, then having 10 platform-controller@<foo> nodes would be
fine. We explicitly want node-names to describe the type of device, not
be a unique identifier. That's what compatible strings are for.
I'm unsure why there would be any confusion caused by the node name,
can you elaborate on that? What other devices connected to the BMC would
be considered "platform controllers"?

There's no explanation anywhere here where "smc" even comes from, none
of the description text or commit message has something that I would
expect "smc" to be shorthand for.

> 
> > 
> >> +
> >> +    required:
> >> +      - compatible
> >> +
> >> +    additionalProperties: false
> >> +
> >> +required:
> >> +  - compatible
> >> +  - reg
> >> +
> >> +unevaluatedProperties: false
> >> +
> >> +examples:
> >> +  - |
> >> +    #include <dt-bindings/leds/common.h>
> >> +    i2c {
> >> +        #address-cells = <1>;
> >> +        #size-cells = <0>;
> >> +
> >> +        smc@3f {
> >> +            compatible = "sony,cronos-smc";
> >> +            reg = <0x3f>;
> >> +
> >> +            watchdog {
> >> +                compatible = "sony,cronos-watchdog";
> >> +
> >> +                timeout-sec = <20>;
> >> +            };
> >> +
> >> +            leds {
> >> +                compatible = "sony,cronos-led";
> >> +                #address-cells = <1>;
> >> +                #size-cells = <0>;
> >> +
> >> +                multi-led@0 {
> >> +                    /*
> >> +                     * No subnodes are needed, this controller only supports
> >> RGB
> >> +                     * LEDs.
> >> +                     */
> >> +                    reg = <0>;
> >> +                    color = <LED_COLOR_ID_MULTI>;
> >> +                    function = LED_FUNCTION_STATUS;
> >> +                };
> >> +            };
> >> +        };
> >> +    };
> >> +
> >> --
> >> 2.39.5

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

[Timothy Pearson]

----- Original Message -----
> From: "Conor Dooley" <conor@kernel.org>
> To: "Timothy Pearson" <tpearson@raptorengineering.com>
> Cc: "Raptor Engineering Development Team" <support@raptorengineering.com>, "devicetree" <devicetree@vger.kernel.org>,
> "linux-kernel" <linux-kernel@vger.kernel.org>, "Rob Herring" <robh+dt@kernel.org>, "Conor Dooley"
> <conor+dt@kernel.org>, "Krzysztof Kozlowski" <krzysztof.kozlowski+dt@linaro.org>, "Lee Jones" <lee@kernel.org>, "Georgy
> Yakovlev" <Georgy.Yakovlev@sony.com>, "Shawn Anastasio" <sanastasio@raptorengineering.com>
> Sent: Friday, March 6, 2026 12:14:19 PM
> Subject: Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc

> On Fri, Mar 06, 2026 at 11:52:23AM -0600, Timothy Pearson wrote:
>> 
>> 
>> ----- Original Message -----
>> > From: "Conor Dooley" <conor@kernel.org>
>> > To: "Raptor Engineering Development Team" <support@raptorengineering.com>
>> > Cc: "devicetree" <devicetree@vger.kernel.org>, "linux-kernel"
>> > <linux-kernel@vger.kernel.org>, "Rob Herring"
>> > <robh+dt@kernel.org>, "Conor Dooley" <conor+dt@kernel.org>, "Krzysztof
>> > Kozlowski" <krzysztof.kozlowski+dt@linaro.org>,
>> > "Lee Jones" <lee@kernel.org>, "Georgy Yakovlev" <Georgy.Yakovlev@sony.com>,
>> > "Shawn Anastasio"
>> > <sanastasio@raptorengineering.com>, "Timothy Pearson"
>> > <tpearson@raptorengineering.com>
>> > Sent: Friday, March 6, 2026 11:49:18 AM
>> > Subject: Re: [PATCH v7 1/4] dt-bindings: mfd: Add sony,cronos-smc
>> 
>> > On Thu, Jan 29, 2026 at 01:20:44PM -0600, Raptor Engineering Development Team
>> > wrote:
>> >> From: Shawn Anastasio <sanastasio@raptorengineering.com>
>> >> 
>> >> The Sony Cronos Platform Controller is a multi-purpose platform controller
>> >> that provides both a watchdog timer and an LED controller for the Sony
>> >> Interactive Entertainment Cronos x86 server platform. As both functions
>> >> are provided by the same CPLD, a multi-function device is exposed as the
>> >> parent of both functions.
>> >> 
>> >> Add a DT binding for this device.
>> >> 
>> >> Signed-off-by: Shawn Anastasio <sanastasio@raptorengineering.com>
>> >> Signed-off-by: Timothy Pearson <tpearson@raptorengineering.com>
>> >> ---
>> >>  .../bindings/mfd/sony,cronos-smc.yaml         | 128 ++++++++++++++++++
>> >>  1 file changed, 128 insertions(+)
>> >>  create mode 100644 Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> >> 
>> >> diff --git a/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> >> b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> >> new file mode 100644
>> >> index 000000000000..a7e88fd42d39
>> >> --- /dev/null
>> >> +++ b/Documentation/devicetree/bindings/mfd/sony,cronos-smc.yaml
>> >> @@ -0,0 +1,128 @@
>> >> +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
>> >> +# Copyright 2025-2026 Raptor Engineering, LLC
>> >> +%YAML 1.2
>> >> +---
>> >> +$id: http://devicetree.org/schemas/mfd/sony,cronos-smc.yaml#
>> >> +$schema: http://devicetree.org/meta-schemas/core.yaml#
>> >> +
>> >> +title: Sony Cronos Platform Controller CPLD multi-function device
>> >> +
>> >> +maintainers:
>> >> +  - Georgy Yakovlev <Georgy.Yakovlev@sony.com>
>> >> +
>> >> +description:
>> >> +  The Sony Cronos Platform Controller CPLD is a multi-purpose platform
>> >> +  controller that provides both a watchdog timer and an LED controller for the
>> >> +  Sony Interactive Entertainment Cronos x86 server platform. As both functions
>> >> +  are provided by the same CPLD, a multi-function device is exposed as the
>> >> +  parent of both functions.
>> >> +
>> >> +properties:
>> >> +  compatible:
>> >> +    const: sony,cronos-smc
>> >> +
>> >> +  reg:
>> >> +    maxItems: 1
>> >> +
>> >> +  leds:
>> >> +    type: object
>> >> +    $ref: /schemas/leds/common.yaml#
>> >> +    additionalProperties: false
>> >> +    description: |
>> >> +      The Cronos LED controller is a subfunction of the Cronos platform
>> >> +      controller, which is a multi-function device.
>> >> +
>> >> +      Each led is represented as a child node of sony,cronos-led. Fifteen RGB
>> >> +      LEDs are supported by the platform.
>> >> +
>> >> +    properties:
>> >> +      compatible:
>> >> +        const: sony,cronos-led
>> >> +
>> >> +      reg:
>> >> +        maxItems: 1
>> >> +
>> >> +      "#address-cells":
>> >> +        const: 1
>> >> +
>> >> +      "#size-cells":
>> >> +        const: 0
>> >> +
>> >> +    patternProperties:
>> >> +      "^multi-led@[0-9a-f]$":
>> >> +        type: object
>> >> +        $ref: /schemas/leds/leds-class-multicolor.yaml#
>> >> +        unevaluatedProperties: false
>> >> +
>> >> +        properties:
>> >> +          reg:
>> >> +            description:
>> >> +              LED channel number (0..14)
>> >> +            minimum: 0
>> >> +            maximum: 14
>> >> +
>> >> +        required:
>> >> +          - reg
>> >> +
>> >> +    required:
>> >> +      - compatible
>> >> +      - "#address-cells"
>> >> +      - "#size-cells"
>> >> +
>> >> +  watchdog:
>> >> +    type: object
>> >> +
>> >> +    $ref: /schemas/watchdog/watchdog.yaml
>> >> +
>> >> +    properties:
>> >> +      compatible:
>> >> +        const: sony,cronos-watchdog
>> >> +
>> >> +      timeout-sec: true
>> > 
>> > Why is there a child node to just add timeout-sec?
>> 
>> When I tried Krzysztof's solution, the validation tools threw an error, and this
>> was the only way I found to get them to stop throwing errors.
> 
> So you were not able to do what he did, and modify watchdog.yaml?
> What did you try, and what were the errors?
> 
>> 
>> > Didn't Krzysztof ask
>> > you to come up with a generic node name for the mfd to use instead of
>> > "smc", and to modify watchdog.yaml to accept the new node name? See
>> > here:
>> > https://lore.kernel.org/all/c7630eb1-2686-491e-81ed-fb43fff2dd31@linaro.org/
>> > 
>> > Something like "platform-controller" sounds generic to me, in a way that
>> > "smc" doesn't.
>> 
>> SMC is the name of the hardware block in question.  platform-controller
>> generates some other confusion as there would be multiple separate hardware
>> blocks that could fit that name.
> 
> Node names do not have to be unique. If there are 10 platform controllers
> on the platform, then having 10 platform-controller@<foo> nodes would be
> fine. We explicitly want node-names to describe the type of device, not
> be a unique identifier. That's what compatible strings are for.
> I'm unsure why there would be any confusion caused by the node name,
> can you elaborate on that? What other devices connected to the BMC would
> be considered "platform controllers"?
> 
> There's no explanation anywhere here where "smc" even comes from, none
> of the description text or commit message has something that I would
> expect "smc" to be shorthand for.

Understood.  Let me rework.  I'll see if I can provoke the error regarding the watchdog YAML again as well.  It may be a couple of weeks before I respond as I have other active projects at this time.

Thanks!