diff --git a/patch/kernel/archive/sm8250-6.18/0064-arm64-dts-qcom-sm8250-add-uart16-Signed-off-by-Teguh.patch b/patch/kernel/archive/sm8250-6.18/0064-arm64-dts-qcom-sm8250-add-uart16-Signed-off-by-Teguh.patch
new file mode 100644
index 0000000000..0bccd7f07d
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0064-arm64-dts-qcom-sm8250-add-uart16-Signed-off-by-Teguh.patch
@@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Wed, 20 Nov 2024 22:58:09 +0700
+Subject: arm64: dts: qcom: sm8250: add uart16 Signed-off-by: Teguh Sobirin
+ <teguh@sobir.in>
+
+---
+ arch/arm64/boot/dts/qcom/sm8250.dtsi | 22 ++++++++++
+ 1 file changed, 22 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/qcom/sm8250.dtsi b/arch/arm64/boot/dts/qcom/sm8250.dtsi
+index 111111111111..222222222222 100644
+--- a/arch/arm64/boot/dts/qcom/sm8250.dtsi
++++ b/arch/arm64/boot/dts/qcom/sm8250.dtsi
+@@ -1153,6 +1153,23 @@ spi16: spi@888000 {
+ 				status = "disabled";
+ 			};
+ 
++			uart16: serial@888000 {
++				compatible = "qcom,geni-uart";
++				reg = <0 0x00888000 0 0x4000>;
++				clock-names = "se";
++				clocks = <&gcc GCC_QUPV3_WRAP2_S2_CLK>;
++				pinctrl-names = "default";
++				pinctrl-0 = <&qup_uart16_default>;
++				interrupts = <GIC_SPI 584 IRQ_TYPE_LEVEL_HIGH>;
++				power-domains = <&rpmhpd RPMHPD_CX>;
++				operating-points-v2 = <&qup_opp_table>;
++				interconnects = <&qup_virt MASTER_QUP_CORE_2 0 &qup_virt SLAVE_QUP_CORE_2 0>,
++						<&gem_noc MASTER_AMPSS_M0 0 &config_noc SLAVE_QUP_2 0>;
++				interconnect-names = "qup-core",
++						     "qup-config";
++				status = "disabled";
++			};
++
+ 			i2c17: i2c@88c000 {
+ 				compatible = "qcom,geni-i2c";
+ 				reg = <0 0x0088c000 0 0x4000>;
+@@ -5725,6 +5742,11 @@ qup_uart12_default: qup-uart12-default-state {
+ 				function = "qup12";
+ 			};
+ 
++			qup_uart16_default: qup-uart16-default-state {
++				pins = "gpio50", "gpio51";
++				function = "qup16";
++			};
++
+ 			qup_uart17_default: qup-uart17-default-state {
+ 				pins = "gpio52", "gpio53", "gpio54", "gpio55";
+ 				function = "qup17";
+-- 
+Armbian
+
diff --git a/patch/kernel/archive/sm8250-6.18/0065-drm-panel-Add-DDIC-CH13726A-panel-Signed-off-by-Tegu.patch b/patch/kernel/archive/sm8250-6.18/0065-drm-panel-Add-DDIC-CH13726A-panel-Signed-off-by-Tegu.patch
new file mode 100644
index 0000000000..97baa1590c
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0065-drm-panel-Add-DDIC-CH13726A-panel-Signed-off-by-Tegu.patch
@@ -0,0 +1,396 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Wed, 20 Nov 2024 23:04:35 +0700
+Subject: drm: panel: Add DDIC CH13726A panel Signed-off-by: Teguh Sobirin
+ <teguh@sobir.in>
+
+---
+ drivers/gpu/drm/panel/Kconfig               |  11 +
+ drivers/gpu/drm/panel/Makefile              |   1 +
+ drivers/gpu/drm/panel/panel-ddic-ch13726a.c | 341 ++++++++++
+ 3 files changed, 353 insertions(+)
+
+diff --git a/drivers/gpu/drm/panel/Kconfig b/drivers/gpu/drm/panel/Kconfig
+index 111111111111..222222222222 100644
+--- a/drivers/gpu/drm/panel/Kconfig
++++ b/drivers/gpu/drm/panel/Kconfig
+@@ -87,6 +87,17 @@ config DRM_PANEL_BOE_TV101WUM_NL6
+ 	  Say Y here if you want to support for BOE TV101WUM and AUO KD101N80
+ 	  45NA WUXGA PANEL DSI Video Mode panel
+ 
++config DRM_PANEL_DDIC_CH13726A
++	tristate "DDIC CH13726A-based DSI panel"
++	depends on OF
++	depends on DRM_MIPI_DSI
++	depends on BACKLIGHT_CLASS_DEVICE
++	select DRM_DISPLAY_DP_HELPER
++	select DRM_DISPLAY_HELPER
++	help
++	  Say Y here if you want to enable support for DDIC CH13726A-based
++	  display panels.
++
+ config DRM_PANEL_BOE_TV101WUM_LL2
+ 	tristate "BOE TV101WUM LL2 1200x1920 panel"
+ 	depends on OF
+diff --git a/drivers/gpu/drm/panel/Makefile b/drivers/gpu/drm/panel/Makefile
+index 111111111111..222222222222 100644
+--- a/drivers/gpu/drm/panel/Makefile
++++ b/drivers/gpu/drm/panel/Makefile
+@@ -8,6 +8,7 @@ obj-$(CONFIG_DRM_PANEL_BOE_HIMAX8279D) += panel-boe-himax8279d.o
+ obj-$(CONFIG_DRM_PANEL_BOE_TH101MB31UIG002_28A) += panel-boe-th101mb31ig002-28a.o
+ obj-$(CONFIG_DRM_PANEL_BOE_TV101WUM_LL2) += panel-boe-tv101wum-ll2.o
+ obj-$(CONFIG_DRM_PANEL_BOE_TV101WUM_NL6) += panel-boe-tv101wum-nl6.o
++obj-$(CONFIG_DRM_PANEL_DDIC_CH13726A) += panel-ddic-ch13726a.o
+ obj-$(CONFIG_DRM_PANEL_DSI_CM) += panel-dsi-cm.o
+ obj-$(CONFIG_DRM_PANEL_LVDS) += panel-lvds.o
+ obj-$(CONFIG_DRM_PANEL_SIMPLE) += panel-simple.o
+diff --git a/drivers/gpu/drm/panel/panel-ddic-ch13726a.c b/drivers/gpu/drm/panel/panel-ddic-ch13726a.c
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/drivers/gpu/drm/panel/panel-ddic-ch13726a.c
+@@ -0,0 +1,341 @@
++// SPDX-License-Identifier: GPL-2.0-only
++/*
++ * DDIC CH13726A MIPI-DSI panel driver
++ * Copyright (c) 2024, Teguh Sobirin <teguh@sobir.in>.
++ */
++
++#include <linux/backlight.h>
++#include <linux/delay.h>
++#include <linux/gpio/consumer.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/regulator/consumer.h>
++
++#include <drm/drm_mipi_dsi.h>
++#include <drm/drm_modes.h>
++#include <drm/drm_panel.h>
++
++#include <video/mipi_display.h>
++
++struct ch13726a_panel {
++	struct drm_panel panel;
++	struct mipi_dsi_device *dsi;
++	struct regulator_bulk_data supplies[4];
++	struct gpio_desc *reset_gpio;
++	const struct drm_display_mode *display_mode;
++	enum drm_panel_orientation orientation;
++	bool prepared;
++};
++
++static inline struct ch13726a_panel *to_ch13726a_panel(struct drm_panel *panel)
++{
++	return container_of(panel, struct ch13726a_panel, panel);
++}
++
++static void ch13726a_reset(struct ch13726a_panel *ctx)
++{
++	gpiod_set_value_cansleep(ctx->reset_gpio, 1);
++	usleep_range(10000, 11000);
++	gpiod_set_value_cansleep(ctx->reset_gpio, 0);
++	usleep_range(10000, 11000);
++	gpiod_set_value_cansleep(ctx->reset_gpio, 1);
++	usleep_range(10000, 11000);
++}
++
++static int ch13726a_on(struct ch13726a_panel *ctx)
++{
++	struct mipi_dsi_device *dsi = ctx->dsi;
++	struct device *dev = &dsi->dev;
++	int ret;
++
++	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
++
++	ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
++	if (ret < 0) {
++		dev_err(dev, "Failed to exit sleep mode: %d\n", ret);
++		return ret;
++	}
++	msleep(120);
++
++	ret = mipi_dsi_dcs_set_display_on(dsi);
++	if (ret < 0) {
++		dev_err(dev, "Failed to set display on: %d\n", ret);
++		return ret;
++	}
++	msleep(20);
++
++	return 0;
++}
++
++static int ch13726a_disable(struct drm_panel *panel)
++{
++	struct ch13726a_panel *ctx = to_ch13726a_panel(panel);
++	struct mipi_dsi_device *dsi = ctx->dsi;
++	struct device *dev = &dsi->dev;
++	int ret;
++
++	dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
++
++	ret = mipi_dsi_dcs_set_display_off(dsi);
++	if (ret < 0) {
++		dev_err(dev, "Failed to set display off: %d\n", ret);
++		return ret;
++	}
++
++	ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
++	if (ret < 0) {
++		dev_err(dev, "Failed to enter sleep mode: %d\n", ret);
++		return ret;
++	}
++
++	msleep(100);
++
++	return 0;
++}
++
++static int ch13726a_prepare(struct drm_panel *panel)
++{
++	struct ch13726a_panel *ctx = to_ch13726a_panel(panel);
++	struct device *dev = &ctx->dsi->dev;
++	int ret;
++
++	if (ctx->prepared)
++		return 0;
++
++	ret = regulator_bulk_enable(ARRAY_SIZE(ctx->supplies), ctx->supplies);
++	if (ret < 0) {
++		dev_err(dev, "Failed to enable regulators: %d\n", ret);
++		return ret;
++	}
++
++	ch13726a_reset(ctx);
++
++	ret = ch13726a_on(ctx);
++	if (ret < 0) {
++		dev_err(dev, "Failed to initialize panel: %d\n", ret);
++		gpiod_set_value_cansleep(ctx->reset_gpio, 0);
++		regulator_bulk_disable(ARRAY_SIZE(ctx->supplies), ctx->supplies);
++		return ret;
++	}
++
++	msleep(28);
++
++	ctx->prepared = true;
++
++	return 0;
++}
++
++static int ch13726a_unprepare(struct drm_panel *panel)
++{
++	struct ch13726a_panel *ctx = to_ch13726a_panel(panel);
++
++	if (!ctx->prepared)
++		return 0;
++
++	gpiod_set_value_cansleep(ctx->reset_gpio, 0);
++	regulator_bulk_disable(ARRAY_SIZE(ctx->supplies), ctx->supplies);
++
++	ctx->prepared = false;
++	return 0;
++}
++
++static const struct drm_display_mode rpmini_display_mode = {
++	.clock = (960 + 28 + 4 + 36) * (1280 + 16 + 4 + 8) * 60 / 1000,
++	.hdisplay = 960,
++	.hsync_start = 960 + 28,
++	.hsync_end = 960 + 28 + 4,
++	.htotal = 960 + 28 + 4 + 36,
++	.vdisplay = 1280,
++	.vsync_start = 1280 + 16,
++	.vsync_end = 1280 + 16 + 4,
++	.vtotal = 1280 + 16 + 4 + 8,
++	.width_mm = 65,
++	.height_mm = 75,
++};
++
++static const struct drm_display_mode rp5_display_mode = {
++	.clock = (1080 + 12 + 4 + 12) * (1920 + 12 + 4 + 12) * 60 / 1000,
++	.hdisplay = 1080,
++	.hsync_start = 1080 + 12,
++	.hsync_end = 1080 + 12 + 4,
++	.htotal = 1080 + 12 + 4 + 12,
++	.vdisplay = 1920,
++	.vsync_start = 1920 + 12,
++	.vsync_end = 1920 + 12 + 4,
++	.vtotal = 1920 + 12 + 4 + 12,
++	.width_mm = 68,
++	.height_mm = 121,
++};
++
++static int ch13726a_get_modes(struct drm_panel *panel,
++					struct drm_connector *connector)
++{
++	struct ch13726a_panel *ctx = to_ch13726a_panel(panel);
++	struct drm_display_mode *mode;
++
++	mode = drm_mode_duplicate(connector->dev, ctx->display_mode);
++	if (!mode)
++		return -ENOMEM;
++
++	drm_mode_set_name(mode);
++
++	mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
++	connector->display_info.width_mm = mode->width_mm;
++	connector->display_info.height_mm = mode->height_mm;
++	drm_mode_probed_add(connector, mode);
++
++	return 1;
++}
++
++static enum drm_panel_orientation ch13726a_get_orientation(struct drm_panel *panel)
++{
++	struct ch13726a_panel *ctx = to_ch13726a_panel(panel);
++
++	return ctx->orientation;
++}
++
++static const struct drm_panel_funcs ch13726a_panel_funcs = {
++	.prepare = ch13726a_prepare,
++	.unprepare = ch13726a_unprepare,
++	.disable = ch13726a_disable,
++	.get_modes = ch13726a_get_modes,
++	.get_orientation = ch13726a_get_orientation,
++};
++
++static int ch13726a_bl_update_status(struct backlight_device *bl)
++{
++	struct mipi_dsi_device *dsi = bl_get_data(bl);
++	u16 brightness = backlight_get_brightness(bl);
++	int ret;
++
++	dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
++
++	ret = mipi_dsi_dcs_set_display_brightness(dsi, brightness);
++	if (ret < 0)
++		return ret;
++
++	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
++
++	return 0;
++}
++
++static const struct backlight_ops ch13726a_bl_ops = {
++	.update_status = ch13726a_bl_update_status,
++};
++
++static struct backlight_device *
++ch13726a_create_backlight(struct mipi_dsi_device *dsi)
++{
++	struct device *dev = &dsi->dev;
++	const struct backlight_properties props = {
++		.type = BACKLIGHT_RAW,
++		.brightness = 255,
++		.max_brightness = 255,
++	};
++
++	return devm_backlight_device_register(dev, dev_name(dev), dev, dsi,
++					      &ch13726a_bl_ops, &props);
++}
++
++static int ch13726a_probe(struct mipi_dsi_device *dsi)
++{
++	struct device *dev = &dsi->dev;
++	struct ch13726a_panel *ctx;
++	int rotation;
++	int ret;
++
++	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
++	if (!ctx)
++		return -ENOMEM;
++
++	ctx->display_mode = of_device_get_match_data(dev);
++
++	ctx->supplies[0].supply = "vdd1v2";
++	ctx->supplies[1].supply = "vddio";
++	ctx->supplies[2].supply = "vdd";
++	ctx->supplies[3].supply = "avdd";
++
++	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(ctx->supplies),
++				      ctx->supplies);
++	if (ret < 0)
++		return dev_err_probe(dev, ret, "Failed to get regulators\n");
++
++	ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
++	if (IS_ERR(ctx->reset_gpio))
++		return dev_err_probe(dev, PTR_ERR(ctx->reset_gpio),
++				     "Failed to get reset-gpios\n");
++
++	ret = of_property_read_u32(dev->of_node, "rotation", &rotation);
++	if (ret == -EINVAL) {
++		ctx->orientation = DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
++	}
++
++	if (rotation == 0)
++		ctx->orientation = DRM_MODE_PANEL_ORIENTATION_NORMAL;
++	else if (rotation == 90)
++		ctx->orientation = DRM_MODE_PANEL_ORIENTATION_RIGHT_UP;
++	else if (rotation == 180)
++		ctx->orientation = DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP;
++	else if (rotation == 270)
++		ctx->orientation = DRM_MODE_PANEL_ORIENTATION_LEFT_UP;
++
++	ctx->dsi = dsi;
++	mipi_dsi_set_drvdata(dsi, ctx);
++
++	dsi->lanes = 4;
++	dsi->format = MIPI_DSI_FMT_RGB888;
++	dsi->mode_flags =  MIPI_DSI_MODE_VIDEO_BURST |
++					MIPI_DSI_CLOCK_NON_CONTINUOUS;
++
++	drm_panel_init(&ctx->panel, dev, &ch13726a_panel_funcs,
++		       DRM_MODE_CONNECTOR_DSI);
++	ctx->panel.prepare_prev_first = true;
++
++	ctx->panel.backlight = ch13726a_create_backlight(dsi);
++	if (IS_ERR(ctx->panel.backlight))
++		return dev_err_probe(dev, PTR_ERR(ctx->panel.backlight),
++				     "Failed to create backlight\n");
++
++	drm_panel_add(&ctx->panel);
++
++	ret = mipi_dsi_attach(dsi);
++	if (ret < 0) {
++		dev_err(dev, "Failed to attach to DSI host: %d\n", ret);
++		drm_panel_remove(&ctx->panel);
++		return ret;
++	}
++
++	return 0;
++}
++
++static void ch13726a_remove(struct mipi_dsi_device *dsi)
++{
++	struct ch13726a_panel *ctx = mipi_dsi_get_drvdata(dsi);
++	int ret;
++
++	ret = mipi_dsi_detach(dsi);
++	if (ret < 0)
++		dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret);
++
++	drm_panel_remove(&ctx->panel);
++}
++
++static const struct of_device_id ch13726a_of_match[] = {
++	{ .compatible = "ch13726a,rpmini", .data = &rpmini_display_mode },
++	{ .compatible = "ch13726a,rp5", .data = &rp5_display_mode },
++	{ /* sentinel */ }
++};
++MODULE_DEVICE_TABLE(of, ch13726a_of_match);
++
++static struct mipi_dsi_driver ch13726a_driver = {
++	.probe = ch13726a_probe,
++	.remove = ch13726a_remove,
++	.driver = {
++		.name = "panel-ch13726a-amoled",
++		.of_match_table = ch13726a_of_match,
++	},
++};
++module_mipi_dsi_driver(ch13726a_driver);
++
++MODULE_DESCRIPTION("DRM driver for CH13726A DSI panels");
++MODULE_LICENSE("GPL");
+-- 
+Armbian
+
diff --git a/patch/kernel/archive/sm8250-6.18/0066-leds-Add-driver-for-HEROIC-HTR3212-Signed-off-by-Teg.patch b/patch/kernel/archive/sm8250-6.18/0066-leds-Add-driver-for-HEROIC-HTR3212-Signed-off-by-Teg.patch
new file mode 100644
index 0000000000..12f4023b6e
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0066-leds-Add-driver-for-HEROIC-HTR3212-Signed-off-by-Teg.patch
@@ -0,0 +1,352 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Thu, 21 Nov 2024 00:16:42 +0700
+Subject: leds: Add driver for HEROIC HTR3212 Signed-off-by: Teguh Sobirin
+ <teguh@sobir.in>
+
+---
+ drivers/leds/Kconfig        |  10 +
+ drivers/leds/Makefile       |   1 +
+ drivers/leds/leds-htr3212.c | 298 ++++++++++
+ 3 files changed, 309 insertions(+)
+
+diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
+index 111111111111..222222222222 100644
+--- a/drivers/leds/Kconfig
++++ b/drivers/leds/Kconfig
+@@ -211,6 +211,16 @@ config LEDS_EXPRESSWIRE
+ 	bool
+ 	depends on GPIOLIB
+ 
++config LEDS_HTR3212
++	tristate "HEROIC HTR3212 LED driver"
++	depends on LEDS_CLASS && I2C
++	select REGMAP_I2C
++	help
++	  Driver for HEROIC HTR3212 LED controller.
++
++	  To compile this driver as a module, choose M here: the module
++	  will be called leds-htr3212.
++
+ config LEDS_TURRIS_OMNIA
+ 	tristate "LED support for CZ.NIC's Turris Omnia"
+ 	depends on LEDS_CLASS_MULTICOLOR
+diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
+index 111111111111..222222222222 100644
+--- a/drivers/leds/Makefile
++++ b/drivers/leds/Makefile
+@@ -32,6 +32,7 @@ obj-$(CONFIG_LEDS_DA9052)		+= leds-da9052.o
+ obj-$(CONFIG_LEDS_GPIO)			+= leds-gpio.o
+ obj-$(CONFIG_LEDS_GPIO_REGISTER)	+= leds-gpio-register.o
+ obj-$(CONFIG_LEDS_HP6XX)		+= leds-hp6xx.o
++obj-$(CONFIG_LEDS_HTR3212)		+= leds-htr3212.o
+ obj-$(CONFIG_LEDS_INTEL_SS4200)		+= leds-ss4200.o
+ obj-$(CONFIG_LEDS_IP30)			+= leds-ip30.o
+ obj-$(CONFIG_LEDS_IPAQ_MICRO)		+= leds-ipaq-micro.o
+diff --git a/drivers/leds/leds-htr3212.c b/drivers/leds/leds-htr3212.c
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/drivers/leds/leds-htr3212.c
+@@ -0,0 +1,298 @@
++// SPDX-License-Identifier: GPL-2.0-only
++/*
++ * Driver for HEROIC HTR3212 12-channel 8-bit PWM LED controller
++ *
++ * Copyright (c) 2024 Teguh Sobirin <teguh@sobir.in>
++ *
++ */
++
++#include <linux/delay.h>
++#include <linux/device.h>
++#include <linux/gpio/consumer.h>
++#include <linux/i2c.h>
++#include <linux/kernel.h>
++#include <linux/leds.h>
++#include <linux/module.h>
++#include <linux/of.h>
++
++#define HTR3212_CHANNELS 12
++#define HTR3212_ENABLE_BIT 1
++#define HTR3212_SHUTDOWN 0x00
++#define HTR3212_PWM_REGISTER_BASE 0x0d
++#define HTR3212_PWM_UPDATE 0x25
++#define HTR3212_LED_CONTROL_BASE 0x32
++#define HTR3212_GLOBAL_CONTROL 0x4a
++#define HTR3212_OUTPUT_FREQ 0x4b
++#define HTR3212_RESET 0x4f
++
++struct htr3212_priv;
++
++struct htr3212_led_data {
++	struct led_classdev cdev;
++	struct htr3212_priv *priv;
++	u8 channel;
++};
++
++struct htr3212_priv {
++	struct i2c_client *client;
++	unsigned int num_leds;
++	struct gpio_desc *sdb;
++	struct regulator *vdd;
++	struct htr3212_led_data leds[];
++};
++
++static int htr3212_write(struct htr3212_priv *priv, u8 reg, u8 val)
++{
++	int ret;
++
++	dev_dbg(&priv->client->dev, "writing register 0x%02X=0x%02X", reg, val);
++
++	ret =  i2c_smbus_write_byte_data(priv->client, reg, val);
++	if (ret) {
++		dev_err(&priv->client->dev,
++			"register write to 0x%02X failed (error %d)",
++			reg, ret);
++	}
++	return ret;
++}
++
++static int htr3212_brightness_set(struct led_classdev *led_cdev,
++				     enum led_brightness brightness)
++{
++	const struct htr3212_led_data *led_data =
++		container_of(led_cdev, struct htr3212_led_data, cdev);
++	u8 pwm_register_offset;
++	int ret;
++
++	dev_dbg(led_cdev->dev, "%s: %d\n", __func__, brightness);
++
++	pwm_register_offset = led_data->channel - 1;
++
++	ret = htr3212_write(led_data->priv,
++			       HTR3212_PWM_REGISTER_BASE + pwm_register_offset,
++			       brightness);
++	if (ret)
++		return ret;
++
++	return htr3212_write(led_data->priv, HTR3212_PWM_UPDATE, 0x00);
++}
++
++static int htr3212_reset_regs(struct htr3212_priv *priv)
++{
++	int ret;
++
++	ret = htr3212_write(priv, HTR3212_RESET, 0x00);
++	if (ret)
++		return ret;
++
++	return 0;
++}
++
++static int htr3212_init_regs(struct htr3212_priv *priv)
++{
++	int ret;
++
++	ret = htr3212_reset_regs(priv);
++	if (ret)
++		return ret;
++
++	u8 value = GENMASK(HTR3212_ENABLE_BIT, 0);
++	u8 num_regs = HTR3212_CHANNELS / HTR3212_ENABLE_BIT;
++
++	int i;
++
++	for (i = 0; i < num_regs; i++) {
++		ret = htr3212_write(priv,
++				HTR3212_LED_CONTROL_BASE + i, value);
++		if (ret)
++			return ret;
++	}
++
++	ret = htr3212_write(priv, HTR3212_SHUTDOWN, 0x01);
++	if (ret)
++		return ret;
++
++	ret = htr3212_write(priv, HTR3212_OUTPUT_FREQ, 0x01);
++	if (ret)
++		return ret;
++
++	ret = htr3212_write(priv, HTR3212_GLOBAL_CONTROL, 0x00);
++	if (ret)
++		return ret;
++
++	return 0;
++}
++
++static int htr3212_parse_child_dt(const struct device *dev,
++				     const struct device_node *child,
++				     struct htr3212_led_data *led_data)
++{
++	struct led_classdev *cdev = &led_data->cdev;
++	int ret = 0;
++	u32 reg;
++
++	ret = of_property_read_u32(child, "reg", &reg);
++	if (ret || reg < 1 || reg > HTR3212_CHANNELS) {
++		dev_err(dev,
++			"Child node %pOF does not have a valid reg property\n",
++			child);
++		return -EINVAL;
++	}
++	led_data->channel = reg;
++
++	cdev->brightness_set_blocking = htr3212_brightness_set;
++
++	if (!device_property_read_bool(dev, "always-on"))
++		cdev->flags |= LED_CORE_SUSPENDRESUME;
++
++	return 0;
++}
++
++static struct htr3212_led_data *htr3212_find_led_data(
++					struct htr3212_priv *priv,
++					u8 channel)
++{
++	size_t i;
++
++	for (i = 0; i < priv->num_leds; i++) {
++		if (priv->leds[i].channel == channel)
++			return &priv->leds[i];
++	}
++
++	return NULL;
++}
++
++static int htr3212_parse_dt(struct device *dev,
++			       struct htr3212_priv *priv)
++{
++	int ret = 0;
++
++	for_each_available_child_of_node_scoped(dev_of_node(dev), child) {
++		struct led_init_data init_data = {};
++		struct htr3212_led_data *led_data =
++			&priv->leds[priv->num_leds];
++		const struct htr3212_led_data *other_led_data;
++
++		led_data->priv = priv;
++
++		ret = htr3212_parse_child_dt(dev, child, led_data);
++		if (ret)
++			return ret;
++
++		other_led_data = htr3212_find_led_data(priv,
++							  led_data->channel);
++		if (other_led_data) {
++			dev_err(dev,
++				"Node %pOF 'reg' conflicts with another LED\n",
++				child);
++			return -EINVAL;
++		}
++
++		init_data.fwnode = of_fwnode_handle(child);
++
++		ret = devm_led_classdev_register_ext(dev, &led_data->cdev,
++						     &init_data);
++		if (ret) {
++			dev_err(dev, "Failed to register LED for %pOF: %d\n",
++				child, ret);
++			return ret;
++		}
++
++		priv->num_leds++;
++	}
++
++	return 0;
++}
++
++static const struct of_device_id of_htr3212_match[] = {
++	{ .compatible = "heroic,htr3212", },
++	{ /* sentinel */ }
++};
++
++MODULE_DEVICE_TABLE(of, of_htr3212_match);
++
++static int htr3212_probe(struct i2c_client *client)
++{
++	struct device *dev = &client->dev;
++	struct htr3212_priv *priv;
++	int count;
++	int ret = 0;
++
++	count = of_get_available_child_count(dev_of_node(dev));
++	if (!count)
++		return -EINVAL;
++
++	priv = devm_kzalloc(dev, struct_size(priv, leds, count),
++			    GFP_KERNEL);
++	if (!priv)
++		return -ENOMEM;
++
++	priv->sdb = devm_gpiod_get(dev, "sdb", GPIOD_OUT_HIGH);
++	if (PTR_ERR(priv->sdb) == -EPROBE_DEFER)
++		return -EPROBE_DEFER;
++
++	priv->vdd = devm_regulator_get(dev, "vdd");
++	if (IS_ERR(priv->vdd)) {
++		ret = PTR_ERR(priv->vdd);
++		return ret;
++	}
++
++	ret = regulator_enable(priv->vdd);
++	if (ret < 0) {
++		return ret;
++	}
++
++	gpiod_set_value_cansleep(priv->sdb, 1);
++	usleep_range(10000, 11000);
++
++	priv->client = client;
++	i2c_set_clientdata(client, priv);
++
++	ret = htr3212_init_regs(priv);
++	if (ret)
++		return ret;
++
++	ret = htr3212_parse_dt(dev, priv);
++	if (ret)
++		return ret;
++
++	return 0;
++}
++
++static void htr3212_remove(struct i2c_client *client)
++{
++	struct htr3212_priv *priv = i2c_get_clientdata(client);
++	int ret;
++
++	ret = htr3212_reset_regs(priv);
++	if (ret)
++		dev_err(&client->dev, "Failed to reset registers on removal (%pe)\n",
++			ERR_PTR(ret));
++
++	gpiod_set_value_cansleep(priv->sdb, 0);
++
++	regulator_disable(priv->vdd);
++}
++
++static const struct i2c_device_id htr3212_id[] = {
++	{ "htr3212" },
++	{},
++};
++
++MODULE_DEVICE_TABLE(i2c, htr3212_id);
++
++static struct i2c_driver htr3212_driver = {
++	.driver = {
++		.name	= "htr3212",
++		.of_match_table = of_htr3212_match,
++	},
++	.probe		= htr3212_probe,
++	.remove		= htr3212_remove,
++	.id_table	= htr3212_id,
++};
++
++module_i2c_driver(htr3212_driver);
++
++MODULE_AUTHOR("Teguh Sobirin <teguh@sobir.in");
++MODULE_DESCRIPTION("HEROIC HTR3212 LED Driver");
++MODULE_LICENSE("GPL v2");
+-- 
+Armbian
+
diff --git a/patch/kernel/archive/sm8250-6.18/0067-Input-driver-for-AYN-Odin2-Gamepad.patch b/patch/kernel/archive/sm8250-6.18/0067-Input-driver-for-AYN-Odin2-Gamepad.patch
new file mode 100644
index 0000000000..c839b1e85b
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0067-Input-driver-for-AYN-Odin2-Gamepad.patch
@@ -0,0 +1,362 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Wed, 20 Nov 2024 23:13:18 +0700
+Subject: Input: driver for AYN Odin2 Gamepad
+
+There have been improvements from the original Odin 2 Gamepad driver
+Signed-off-by: Teguh Sobirin <teguh@sobir.in>
+---
+ drivers/input/joystick/Kconfig  |   4 +
+ drivers/input/joystick/Makefile |   1 +
+ drivers/input/joystick/odin2.c  | 313 ++++++++++
+ 3 files changed, 318 insertions(+)
+
+diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig
+index 111111111111..222222222222 100644
+--- a/drivers/input/joystick/Kconfig
++++ b/drivers/input/joystick/Kconfig
+@@ -344,6 +344,10 @@ config JOYSTICK_MAPLE
+ 	  To compile this as a module choose M here: the module will be called
+ 	  maplecontrol.
+ 
++config JOYSTICK_ODIN2
++	tristate "AYN Odin2 gamepad"
++	depends on SERIAL_DEV_BUS
++
+ config JOYSTICK_PSXPAD_SPI
+ 	tristate "PlayStation 1/2 joypads via SPI interface"
+ 	depends on SPI
+diff --git a/drivers/input/joystick/Makefile b/drivers/input/joystick/Makefile
+index 111111111111..222222222222 100644
+--- a/drivers/input/joystick/Makefile
++++ b/drivers/input/joystick/Makefile
+@@ -25,6 +25,7 @@ obj-$(CONFIG_JOYSTICK_JOYDUMP)		+= joydump.o
+ obj-$(CONFIG_JOYSTICK_MAGELLAN)		+= magellan.o
+ obj-$(CONFIG_JOYSTICK_MAPLE)		+= maplecontrol.o
+ obj-$(CONFIG_JOYSTICK_N64)		+= n64joy.o
++obj-$(CONFIG_JOYSTICK_ODIN2)		+= odin2.o
+ obj-$(CONFIG_JOYSTICK_PSXPAD_SPI)	+= psxpad-spi.o
+ obj-$(CONFIG_JOYSTICK_PXRC)		+= pxrc.o
+ obj-$(CONFIG_JOYSTICK_QWIIC)		+= qwiic-joystick.o
+diff --git a/drivers/input/joystick/odin2.c b/drivers/input/joystick/odin2.c
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/drivers/input/joystick/odin2.c
+@@ -0,0 +1,313 @@
++// SPDX-License-Identifier: GPL-2.0-only
++/*
++ * Driver for Ayn Odin 2 Gamepad
++ *
++ * Copyright (C) 2024 Molly Sophia <mollysophia379@gmail.com>
++ * Copyright (C) 2024 BigfootACA <bigfoot@classfun.cn>
++ * Copyright (C) 2024 Teguh Sobirin <teguh@sobir.in>
++ *
++ */
++
++#include <linux/delay.h>
++#include <linux/errno.h>
++#include <linux/gpio/consumer.h>
++#include <linux/init.h>
++#include <linux/input.h>
++#include <linux/kernel.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/serdev.h>
++#include <linux/slab.h>
++#include <uapi/linux/sched/types.h>
++
++#define DRIVER_NAME "odin2-gamepad"
++#define MAX_DATA_LEN 64
++
++#define gamepad_serdev_write_seq(serdev, seq...)                      \
++	do {                                                              \
++		static const u8 d[] = { seq };                                \
++		struct device *dev = &serdev->dev;                            \
++		int ret;                                                      \
++		ret = serdev_device_write_buf(serdev, d, ARRAY_SIZE(d));      \
++		if (ret < 0 || ret < ARRAY_SIZE(d)) {                         \
++			dev_warn_ratelimited(dev, "Unable to write data: %d",     \
++					     ret);                                        \
++			return;                                                   \
++		}                                                             \
++	} while (0)
++
++static const unsigned int keymap[] = {
++	BTN_DPAD_UP, BTN_DPAD_DOWN, BTN_DPAD_LEFT, BTN_DPAD_RIGHT,
++	BTN_NORTH,   BTN_WEST,	    BTN_EAST,	   BTN_SOUTH,
++	BTN_TL,	     BTN_TR,	    BTN_SELECT,	   BTN_START,
++	BTN_THUMBL,  BTN_THUMBR,    BTN_MODE,	   BTN_BACK
++};
++
++struct gamepad_data {
++	u8 header[4];
++	u8 frame_number;
++	u8 command;
++	u16 data_len;
++	u8 data[MAX_DATA_LEN];
++};
++
++struct gamepad_device {
++	struct device *dev;
++	struct gpio_desc *boot_gpio;
++	struct gpio_desc *enable_gpio;
++	struct gpio_desc *reset_gpio;
++	struct input_dev *dev_input;
++};
++
++static u8 gamepad_data_checksum(const u8 *data, size_t count)
++{
++	const u8 *ptr = data;
++	u8 ret = data[4];
++
++	for (int i = 5; i < count - 1; i++)
++		ret ^= ptr[i];
++
++	return ret;
++}
++
++static void gamepad_send_init_sequence(struct serdev_device *serdev)
++{
++	gamepad_serdev_write_seq(serdev, 0xA5, 0xD3, 0x5A, 0x3D, 0x0, 0x1, 0x2,
++				 0x0, 0x7, 0x1, 0x5);
++	msleep(100);
++	gamepad_serdev_write_seq(serdev, 0xA5, 0xD3, 0x5A, 0x3D, 0x1, 0x1, 0x1,
++				 0x0, 0x6, 0x7);
++	msleep(100);
++	gamepad_serdev_write_seq(serdev, 0xA5, 0xD3, 0x5A, 0x3D, 0x2, 0x1, 0x1, 0x0, 0x2, 0x0);
++	msleep(100);
++	gamepad_serdev_write_seq(serdev, 0xa5, 0xd3, 0x5a, 0x3d, 0x3, 0x01,
++				 0x0a, 0x00, 0x05, 0x01, 0x00, 0x00, 0x00, 0x28,
++				 0x00, 0x00, 0x00, 0x07, 0x23);
++	msleep(100);
++	gamepad_serdev_write_seq(serdev, 0xA5, 0xD3, 0x5A, 0x3D, 0x4, 0x1, 0x1,
++				 0x0, 0x6, 0x2);
++	msleep(100);
++	gamepad_serdev_write_seq(serdev, 0xA5, 0xD3, 0x5A, 0x3D, 0x5, 0x1, 0x1,
++				 0x0, 0x2, 0x7);
++	msleep(100);
++}
++
++static void gamepad_input_handler(struct gamepad_device *dev,
++				  struct gamepad_data *data)
++{
++	static unsigned long prev_states;
++	unsigned long keys = data->data[0] | (data->data[1] << 8);
++	unsigned long current_states = keys, changes;
++	int i;
++	struct input_dev *indev;
++
++	indev = dev->dev_input;
++	if (!indev)
++		return;
++
++	bitmap_xor(&changes, &current_states, &prev_states, ARRAY_SIZE(keymap));
++
++	for_each_set_bit(i, &changes, ARRAY_SIZE(keymap)) {
++		input_report_key(indev, keymap[i], (current_states & BIT(i)));
++	}
++
++	input_report_abs(indev, ABS_HAT2X,
++			 0x755 - (data->data[2] | (data->data[3] << 8)));
++	input_report_abs(indev, ABS_HAT2Y,
++			 0x755 - (data->data[4] | (data->data[5] << 8)));
++	input_report_abs(indev, ABS_X,
++			 -(int16_t)(data->data[6] | (data->data[7] << 8)));
++	input_report_abs(indev, ABS_Y,
++			 -(int16_t)(data->data[8] | (data->data[9] << 8)));
++	input_report_abs(indev, ABS_RX,
++			 -(int16_t)(data->data[10] | (data->data[11] << 8)));
++	input_report_abs(indev, ABS_RY,
++			 -(int16_t)(data->data[12] | (data->data[13] << 8)));
++
++	input_sync(indev);
++	prev_states = keys;
++}
++
++static void gamepad_data_handler(struct serdev_device *serdev,
++				 struct gamepad_data *data)
++{
++	struct gamepad_device *dev = serdev_device_get_drvdata(serdev);
++
++	switch (data->command) {
++	case 0x2:
++		gamepad_input_handler(dev, data);
++		break;
++	default:
++		break;
++	}
++}
++
++static size_t gamepad_mcu_uart_rx_bytes(struct serdev_device *serdev,
++					const u8 *data, size_t count)
++{
++	struct device *dev = &serdev->dev;
++	struct gamepad_data recv_data_buffer;
++	u8 checksum;
++
++	if (!data || count < 7) {
++		dev_warn_ratelimited(dev, "invalid packet");
++		return count;
++	}
++
++	checksum = gamepad_data_checksum(data, count);
++	if (checksum != *(data + count - 1)) {
++		dev_warn_ratelimited(dev, "packet checksum failed");
++		return count;
++	}
++
++	memcpy(recv_data_buffer.header, data, 4);
++	recv_data_buffer.frame_number = *(data + 4);
++	recv_data_buffer.command = *(data + 5);
++	recv_data_buffer.data_len = *(data + 6) | (*(data + 7) << 8);
++
++	if (recv_data_buffer.data_len) {
++		memset(&recv_data_buffer.data[0], 0,
++		       sizeof(recv_data_buffer.data));
++		memcpy(&recv_data_buffer.data[0], data + 8,
++		       recv_data_buffer.data_len);
++	}
++
++	gamepad_data_handler(serdev, &recv_data_buffer);
++
++	return count;
++}
++
++static const struct serdev_device_ops gamepad_mcu_uart_client_ops = {
++	.receive_buf = gamepad_mcu_uart_rx_bytes,
++};
++
++static int gamepad_mcu_uart_probe(struct serdev_device *serdev)
++{
++	struct device *dev = &serdev->dev;
++	struct gamepad_device *gamepad_dev;
++	u32 gamepad_bus = 0;
++	u32 gamepad_vid = 0;
++	u32 gamepad_pid = 0;
++	u32 gamepad_rev = 0;
++	int ret;
++
++	gamepad_dev = devm_kzalloc(dev, sizeof(*gamepad_dev), GFP_KERNEL);
++	if (!gamepad_dev)
++		return dev_err_probe(dev, -ENOMEM, "could not allocate memory for device data\n");
++
++	gamepad_dev->boot_gpio =
++		devm_gpiod_get_optional(dev, "boot", GPIOD_OUT_HIGH);
++	if (IS_ERR(gamepad_dev->boot_gpio)) {
++		ret = PTR_ERR(gamepad_dev->boot_gpio);
++		dev_warn(dev, "Unable to get boot gpio: %d\n", ret);
++	}
++
++	gamepad_dev->enable_gpio =
++		devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH);
++	if (IS_ERR(gamepad_dev->enable_gpio)) {
++		ret = PTR_ERR(gamepad_dev->enable_gpio);
++		dev_warn(dev, "Unable to get enable gpio: %d\n", ret);
++	}
++
++	gamepad_dev->reset_gpio =
++		devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
++	if (IS_ERR(gamepad_dev->reset_gpio)) {
++		ret = PTR_ERR(gamepad_dev->reset_gpio);
++		dev_warn(dev, "Unable to get reset gpio: %d\n", ret);
++	}
++
++	if (gamepad_dev->boot_gpio)
++		gpiod_set_value_cansleep(gamepad_dev->boot_gpio, 0);
++
++	if (gamepad_dev->reset_gpio)
++		gpiod_set_value_cansleep(gamepad_dev->reset_gpio, 0);
++
++	msleep(100);
++
++	if (gamepad_dev->enable_gpio)
++		gpiod_set_value_cansleep(gamepad_dev->enable_gpio, 1);
++
++	if (gamepad_dev->reset_gpio)
++		gpiod_set_value_cansleep(gamepad_dev->reset_gpio, 1);
++
++	msleep(100);
++
++	ret = devm_serdev_device_open(dev, serdev);
++	if (ret)
++		return dev_err_probe(dev, ret, "Unable to open UART device\n");
++	gamepad_dev->dev = dev;
++
++	serdev_device_set_drvdata(serdev, gamepad_dev);
++
++	ret = serdev_device_set_baudrate(serdev, 115200);
++	if (ret < 0)
++		return dev_err_probe(dev, ret, "Failed to set up host baud rate\n");
++
++	serdev_device_set_flow_control(serdev, false);
++
++	gamepad_dev->dev_input = devm_input_allocate_device(dev);
++	if (!gamepad_dev->dev_input)
++		return dev_err_probe(dev, -ENOMEM, "Not enough memory for input device\n");
++
++	gamepad_dev->dev_input->phys = DRIVER_NAME"/input0";
++	
++	ret = device_property_read_string(dev, "gamepad-name", &gamepad_dev->dev_input->name);
++	if (ret) {
++		gamepad_dev->dev_input->name = "Ayn Odin2 Gamepad";
++	}
++
++	device_property_read_u32(dev, "gamepad-bus", &gamepad_bus);
++	device_property_read_u32(dev, "gamepad-vid", &gamepad_vid);
++	device_property_read_u32(dev, "gamepad-pid", &gamepad_pid);
++	device_property_read_u32(dev, "gamepad-rev", &gamepad_rev);
++
++	gamepad_dev->dev_input->id.bustype = (u16)gamepad_bus;
++	gamepad_dev->dev_input->id.vendor  = (u16)gamepad_vid;
++	gamepad_dev->dev_input->id.product = (u16)gamepad_pid;
++	gamepad_dev->dev_input->id.version = (u16)gamepad_rev;
++
++	__set_bit(EV_KEY, gamepad_dev->dev_input->evbit);
++	for (int i = 0; i < ARRAY_SIZE(keymap); i++)
++		input_set_capability(gamepad_dev->dev_input, EV_KEY, keymap[i]);
++
++	__set_bit(EV_ABS, gamepad_dev->dev_input->evbit);
++	for (int i = ABS_X; i <= ABS_RZ; i++)
++		input_set_abs_params(gamepad_dev->dev_input, i, -0x580, 0x580,
++				     0, 0);
++
++	input_set_abs_params(gamepad_dev->dev_input, ABS_HAT2X, 0, 1830, 0, 30);
++	input_set_abs_params(gamepad_dev->dev_input, ABS_HAT2Y, 0, 1830, 0, 30);
++
++	ret = input_register_device(gamepad_dev->dev_input);
++	if (ret)
++		return dev_err_probe(dev, ret, "Could not register input device\n");
++
++	serdev_device_set_client_ops(serdev, &gamepad_mcu_uart_client_ops);
++
++	gamepad_send_init_sequence(serdev);
++
++	return 0;
++}
++
++static const struct of_device_id gamepad_mcu_uart_of_match[] = {
++	{ .compatible = "ayn,odin2-gamepad" },
++	{}
++};
++MODULE_DEVICE_TABLE(of, gamepad_mcu_uart_of_match);
++
++static struct serdev_device_driver gamepad_mcu_uart_driver = {
++	.driver = {
++		.name = DRIVER_NAME,
++		.of_match_table = gamepad_mcu_uart_of_match,
++	},
++	.probe = gamepad_mcu_uart_probe,
++};
++
++module_serdev_device_driver(gamepad_mcu_uart_driver);
++
++MODULE_LICENSE("GPL");
++MODULE_DESCRIPTION("Gamepad driver for Ayn Odin2");
++MODULE_AUTHOR("Molly Sophia <mollysophia379@gmail.com>");
++MODULE_AUTHOR("BigfootACA <bigfoot@classfun.cn>");
++MODULE_AUTHOR("Teguh Sobirin <teguh@sobir.in>");
++MODULE_ALIAS("platform:" DRIVER_NAME);
+-- 
+Armbian
+
diff --git a/patch/kernel/archive/sm8250-6.18/0068-input-add-Qualcomm-SPMI-haptics-driver.patch b/patch/kernel/archive/sm8250-6.18/0068-input-add-Qualcomm-SPMI-haptics-driver.patch
new file mode 100644
index 0000000000..2437d2d097
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0068-input-add-Qualcomm-SPMI-haptics-driver.patch
@@ -0,0 +1,1090 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Mon, 25 Nov 2024 02:27:16 +0700
+Subject: input: add Qualcomm SPMI haptics driver
+
+Add support for the haptics found in pmi8998 and related PMICs.
+Based on the ff-memless interface. Currently this driver provides
+a partial implementation of hardware features.
+
+This driver only supports LRAs (Linear Resonant Actuators) in the "buffer"
+mode with a single wave pattern.
+Signed-off-by: Teguh Sobirin <teguh@sobir.in>
+---
+ drivers/input/misc/Kconfig                    |  12 +
+ drivers/input/misc/Makefile                   |   1 +
+ drivers/input/misc/qcom-spmi-haptics.c        | 990 ++++++++++
+ include/dt-bindings/input/qcom,spmi-haptics.h |  31 +
+ 4 files changed, 1034 insertions(+)
+
+diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
+index 111111111111..222222222222 100644
+--- a/drivers/input/misc/Kconfig
++++ b/drivers/input/misc/Kconfig
+@@ -214,6 +214,18 @@ config INPUT_PMIC8XXX_PWRKEY
+ 	  To compile this driver as a module, choose M here: the
+ 	  module will be called pmic8xxx-pwrkey.
+ 
++config INPUT_QCOM_SPMI_HAPTICS
++	tristate "Qualcomm SPMI HAPTICS"
++	depends on ARCH_QCOM
++	depends on SPMI
++	select INPUT_FF_MEMLESS
++	help
++	  This option enables support for the haptics found in pmi8998 and
++	  related PMICs. Based on the ff-memless interface.
++
++	  To compile this driver as module, choose M here: the
++	  module will be called qcom_spmi_haptics.
++
+ config INPUT_SPARCSPKR
+ 	tristate "SPARC Speaker support"
+ 	depends on PCI && SPARC64
+diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
+index 111111111111..222222222222 100644
+--- a/drivers/input/misc/Makefile
++++ b/drivers/input/misc/Makefile
+@@ -41,6 +41,7 @@ obj-$(CONFIG_INPUT_DRV2667_HAPTICS)	+= drv2667.o
+ obj-$(CONFIG_INPUT_GPIO_BEEPER)		+= gpio-beeper.o
+ obj-$(CONFIG_INPUT_GPIO_DECODER)	+= gpio_decoder.o
+ obj-$(CONFIG_INPUT_GPIO_VIBRA)		+= gpio-vibra.o
++obj-$(CONFIG_INPUT_QCOM_SPMI_HAPTICS)	+= qcom-spmi-haptics.o
+ obj-$(CONFIG_INPUT_HISI_POWERKEY)	+= hisi_powerkey.o
+ obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
+ obj-$(CONFIG_INPUT_IBM_PANEL)		+= ibm-panel.o
+diff --git a/drivers/input/misc/qcom-spmi-haptics.c b/drivers/input/misc/qcom-spmi-haptics.c
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/drivers/input/misc/qcom-spmi-haptics.c
+@@ -0,0 +1,990 @@
++// SPDX-License-Identifier: GPL-2.0-only
++/*
++ * Copyright (c) 2021, Caleb Connolly <caleb@connolly.tech>
++ * Qualcomm QPMI haptics driver for pmi8998 and related PMICs.
++ */
++#include <dt-bindings/input/qcom,spmi-haptics.h>
++
++#include <linux/atomic.h>
++#include <linux/bits.h>
++#include <linux/bitfield.h>
++#include <linux/errno.h>
++#include <linux/gpio/consumer.h>
++#include <linux/input.h>
++#include <linux/interrupt.h>
++#include <linux/kernel.h>
++#include <linux/log2.h>
++#include <linux/minmax.h>
++#include <linux/module.h>
++#include <linux/of.h>
++#include <linux/of_device.h>
++#include <linux/platform_device.h>
++#include <linux/regmap.h>
++#include <linux/slab.h>
++#include <linux/time.h>
++#include <linux/types.h>
++
++#define HAP_STATUS_1_REG		0x0A
++#define HAP_BUSY_BIT			BIT(1)
++#define SC_FLAG_BIT			BIT(3)
++#define AUTO_RES_ERROR_BIT		BIT(4)
++
++#define HAP_LRA_AUTO_RES_LO_REG		0x0B
++#define HAP_LRA_AUTO_RES_HI_REG		0x0C
++
++#define HAP_EN_CTL_REG			0x46
++#define HAP_EN_BIT			BIT(7)
++
++#define HAP_EN_CTL2_REG			0x48
++#define BRAKE_EN_BIT			BIT(0)
++
++#define HAP_AUTO_RES_CTRL_REG		0x4B
++#define AUTO_RES_EN_BIT			BIT(7)
++#define AUTO_RES_ERR_RECOVERY_BIT	BIT(3)
++#define AUTO_RES_EN_FLAG_BIT		BIT(0)
++
++#define HAP_CFG1_REG			0x4C
++#define HAP_ACT_TYPE_MASK		BIT(0)
++
++#define HAP_CFG2_REG			0x4D
++#define HAP_LRA_RES_TYPE_MASK		BIT(0)
++
++#define HAP_SEL_REG			0x4E
++#define HAP_WF_SOURCE_MASK		GENMASK(5, 4)
++#define HAP_WF_SOURCE_SHIFT		4
++
++#define HAP_LRA_AUTO_RES_REG		0x4F
++#define LRA_AUTO_RES_MODE_MASK		GENMASK(6, 4)
++#define LRA_AUTO_RES_MODE_SHIFT		4
++#define LRA_HIGH_Z_MASK			GENMASK(3, 2)
++#define LRA_HIGH_Z_SHIFT		2
++#define LRA_RES_CAL_MASK		GENMASK(1, 0)
++#define HAP_RES_CAL_PERIOD_MIN		4
++#define HAP_RES_CAL_PERIOD_MAX		32
++
++#define HAP_VMAX_CFG_REG			0x51
++#define HAP_VMAX_OVD_BIT		BIT(6)
++#define HAP_VMAX_MASK			GENMASK(5, 1)
++#define HAP_VMAX_SHIFT			1
++
++#define HAP_ILIM_CFG_REG			0x52
++#define HAP_ILIM_SEL_MASK		BIT(0)
++#define HAP_ILIM_400_MA			0
++#define HAP_ILIM_800_MA			1
++
++#define HAP_SC_DEB_REG			0x53
++#define HAP_SC_DEB_MASK			GENMASK(2, 0)
++#define HAP_SC_DEB_CYCLES_MIN		0
++#define HAP_DEF_SC_DEB_CYCLES		8
++#define HAP_SC_DEB_CYCLES_MAX		32
++
++#define HAP_RATE_CFG1_REG		0x54
++#define HAP_RATE_CFG1_MASK		GENMASK(7, 0)
++#define HAP_RATE_CFG2_SHIFT		8 // As CFG2 is the most significant byte
++
++#define HAP_RATE_CFG2_REG		0x55
++#define HAP_RATE_CFG2_MASK		GENMASK(3, 0)
++
++#define HAP_SC_CLR_REG			0x59
++#define SC_CLR_BIT			BIT(0)
++
++#define HAP_BRAKE_REG			0x5C
++#define HAP_BRAKE_PAT_MASK		0x3
++
++#define HAP_WF_REPEAT_REG			0x5E
++#define WF_REPEAT_MASK			GENMASK(6, 4)
++#define WF_REPEAT_SHIFT			4
++#define WF_REPEAT_MIN			1
++#define WF_REPEAT_MAX			128
++#define WF_S_REPEAT_MASK		GENMASK(1, 0)
++#define WF_S_REPEAT_MIN			1
++#define WF_S_REPEAT_MAX			8
++
++#define HAP_WF_S1_REG			0x60
++#define HAP_WF_SIGN_BIT			BIT(7)
++#define HAP_WF_OVD_BIT			BIT(6)
++#define HAP_WF_SAMP_MAX			GENMASK(5, 1)
++#define HAP_WF_SAMPLE_LEN		8
++
++#define HAP_PLAY_REG			0x70
++#define HAP_PLAY_BIT			BIT(7)
++#define HAP_PAUSE_BIT			BIT(0)
++
++#define HAP_SEC_ACCESS_REG		0xD0
++#define HAP_SEC_ACCESS_UNLOCK		0xA5
++
++#define HAP_TEST2_REG			0xE3
++
++
++#define HAP_VMAX_MIN_MV			116
++#define HAP_VMAX_MAX_MV			3596
++#define HAP_VMAX_MAX_MV_STRONG		3596
++
++#define HAP_WAVE_PLAY_RATE_MIN_US	0
++#define HAP_WAVE_PLAY_RATE_MAX_US	20475
++#define HAP_WAVE_PLAY_TIME_MAX_MS	15000
++
++#define AUTO_RES_ERR_POLL_TIME_NS	(20 * NSEC_PER_MSEC)
++#define HAPTICS_BACK_EMF_DELAY_US	20000
++
++#define HAP_BRAKE_PAT_LEN		4
++#define HAP_WAVE_SAMP_LEN		8
++#define NUM_WF_SET			4
++#define HAP_WAVE_SAMP_SET_LEN		(HAP_WAVE_SAMP_LEN * NUM_WF_SET)
++#define HAP_RATE_CFG_STEP_US		5
++
++#define SC_MAX_COUNT			5
++#define SC_COUNT_RST_DELAY_US		1000000
++
++enum hap_play_control {
++	HAP_STOP,
++	HAP_PAUSE,
++	HAP_PLAY,
++};
++
++/**
++ * struct spmi_haptics - struct for spmi haptics data.
++ *
++ * @dev: Our device parent.
++ * @regmap: Register map for the hardware block.
++ * @input_dev: The input device used to receive events.
++ * @work: Work struct to play effects.
++ * @base: Base address of the regmap.
++ * @active: Atomic value used to track if haptics are currently playing.
++ * @play_irq: Fired to load the next wave pattern.
++ * @sc_irq: Short circuit irq.
++ * @last_sc_time: Time since the short circuit IRQ last fired.
++ * @sc_count: Number of times the short circuit IRQ has fired in this interval.
++ * @actuator_type: The type of actuator in use.
++ * @wave_shape: The shape of the waves to use (sine or square).
++ * @play_mode: The play mode to use (direct, buffer, pwm, audio).
++ * @magnitude: The strength we should be playing at.
++ * @vmax: Max voltage to use when playing.
++ * @current_limit: The current limit for this hardware (400mA or 800mA).
++ * @play_wave_rate: The wave rate to use for this hardware.
++ * @wave_samp: The array of wave samples to write for buffer mode.
++ * @brake_pat: The pattern to apply when braking.
++ * @play_lock: Lock to be held when updating the hardware state.
++ */
++struct spmi_haptics {
++	struct device *dev;
++	struct regmap *regmap;
++	struct input_dev *haptics_input_dev;
++	struct gpio_desc *boost;
++	struct work_struct work;
++	u32 base;
++
++	atomic_t active;
++
++	int play_irq;
++	int sc_irq;
++	ktime_t last_sc_time;
++	u8 sc_count;
++
++	u8 actuator_type;
++	u8 wave_shape;
++	u8 play_mode;
++	int magnitude;
++	u32 vmax;
++	u32 current_limit;
++	u32 play_wave_rate;
++
++	u32 wave_samp[HAP_WAVE_SAMP_SET_LEN];
++	u8 brake_pat[HAP_BRAKE_PAT_LEN];
++
++	struct mutex play_lock;
++};
++
++static inline bool is_secure_addr(u16 addr)
++{
++	return (addr & 0xFF) > 0xD0;
++}
++
++static int spmi_haptics_read(struct spmi_haptics *haptics,
++	u16 addr, u8 *val, int len)
++{
++	int ret;
++
++	ret = regmap_bulk_read(haptics->regmap, addr, val, len);
++	if (ret < 0)
++		dev_err(haptics->dev, "Error reading address: 0x%x, ret %d\n", addr, ret);
++
++	return ret;
++}
++
++static int spmi_haptics_write(struct spmi_haptics *haptics,
++			      u16 addr, u8 *val, int len)
++{
++	int ret, i;
++
++	if (is_secure_addr(addr)) {
++		for (i = 0; i < len; i++) {
++			dev_dbg(haptics->dev, "%s: unlocking for addr: 0x%x, val: 0x%x", __func__,
++				addr, val[i]);
++			ret = regmap_write(haptics->regmap,
++				haptics->base + HAP_SEC_ACCESS_REG, HAP_SEC_ACCESS_UNLOCK);
++			if (ret < 0) {
++				dev_err(haptics->dev, "Error writing unlock code, ret %d\n",
++					ret);
++				return ret;
++			}
++
++			ret = regmap_write(haptics->regmap, addr + i, val[i]);
++			if (ret < 0) {
++				dev_err(haptics->dev, "Error writing address 0x%x, ret %d\n",
++					addr + i, ret);
++				return ret;
++			}
++		}
++	} else {
++		if (len > 1)
++			ret = regmap_bulk_write(haptics->regmap, addr, val, len);
++		else
++			ret = regmap_write(haptics->regmap, addr, *val);
++	}
++
++	if (ret < 0)
++		dev_err(haptics->dev, "%s: Error writing address: 0x%x, ret %d\n",
++			__func__, addr, ret);
++
++	return ret;
++}
++
++static int spmi_haptics_write_masked(struct spmi_haptics *haptics,
++	u16 addr, u8 mask, u8 val)
++{
++	int ret;
++
++	if (is_secure_addr(addr)) {
++		ret = regmap_write(haptics->regmap,
++			haptics->base + HAP_SEC_ACCESS_REG, HAP_SEC_ACCESS_UNLOCK);
++		if (ret < 0) {
++			dev_err(haptics->dev, "Error writing unlock code - ret %d\n", ret);
++			return ret;
++		}
++	}
++
++	ret = regmap_update_bits(haptics->regmap, addr, mask, val);
++	if (ret < 0)
++		dev_err(haptics->dev, "Error writing address: 0x%x - ret %d\n", addr, ret);
++
++	return ret;
++}
++
++static bool is_haptics_idle(struct spmi_haptics *haptics)
++{
++	int ret;
++	u8 val;
++
++	if (haptics->play_mode == HAP_PLAY_DIRECT ||
++			haptics->play_mode == HAP_PLAY_PWM)
++		return true;
++
++	ret = spmi_haptics_read(haptics, haptics->base + HAP_STATUS_1_REG, &val, 1);
++	if (ret < 0 || (val & HAP_BUSY_BIT))
++		return false;
++
++	return true;
++}
++
++static int spmi_haptics_module_enable(struct spmi_haptics *haptics, bool enable)
++{
++	u8 val;
++
++	dev_dbg(haptics->dev, "Setting module enable: %d", enable);
++
++	val = enable ? HAP_EN_BIT : 0;
++	return spmi_haptics_write(haptics, haptics->base + HAP_EN_CTL_REG, &val, 1);
++}
++
++static int spmi_haptics_write_vmax(struct spmi_haptics *haptics)
++{
++	u8 val = 0;
++	u32 vmax_mv = haptics->vmax;
++
++	vmax_mv = clamp_t(u32, vmax_mv, HAP_VMAX_MIN_MV, HAP_VMAX_MAX_MV);
++
++	dev_dbg(haptics->dev, "Setting vmax to: %d", vmax_mv);
++
++	val = DIV_ROUND_CLOSEST(vmax_mv, HAP_VMAX_MIN_MV);
++	val = FIELD_PREP(HAP_VMAX_MASK, val);
++
++	// TODO: pm660 can enable overdrive here
++
++	return spmi_haptics_write_masked(haptics, haptics->base + HAP_VMAX_CFG_REG,
++					 HAP_VMAX_MASK | HAP_WF_OVD_BIT, val);
++}
++
++static int spmi_haptics_write_current_limit(struct spmi_haptics *haptics)
++{
++	haptics->current_limit = clamp_t(u32, haptics->current_limit,
++					 HAP_ILIM_400_MA, HAP_ILIM_800_MA);
++
++	dev_dbg(haptics->dev, "Setting current_limit to: 0x%x", haptics->current_limit);
++
++	return spmi_haptics_write_masked(haptics, haptics->base + HAP_ILIM_CFG_REG,
++			HAP_ILIM_SEL_MASK, haptics->current_limit);
++}
++
++static int spmi_haptics_write_play_mode(struct spmi_haptics *haptics)
++{
++	u8 val = 0;
++
++	if (!is_haptics_idle(haptics))
++		return -EBUSY;
++
++	dev_dbg(haptics->dev, "Setting play_mode to: 0x%x", haptics->play_mode);
++
++	val = FIELD_PREP(HAP_WF_SOURCE_MASK, haptics->play_mode);
++	return spmi_haptics_write_masked(haptics, haptics->base + HAP_SEL_REG,
++					 HAP_WF_SOURCE_MASK, val);
++
++}
++
++static int spmi_haptics_write_play_rate(struct spmi_haptics *haptics, u16 play_rate)
++{
++	u8 val[2];
++
++	dev_dbg(haptics->dev, "Setting play_rate to: %d", play_rate);
++
++	val[0] = FIELD_PREP(HAP_RATE_CFG1_MASK, play_rate);
++	val[1] = FIELD_PREP(HAP_RATE_CFG2_MASK, play_rate >> HAP_RATE_CFG2_SHIFT);
++	return spmi_haptics_write(haptics, haptics->base + HAP_RATE_CFG1_REG, val, 2);
++}
++
++/*
++ * spmi_haptics_set_auto_res() - Auto resonance
++ * allows the haptics to automatically adjust the
++ * speed of the oscillation in order to maintain
++ * the resonant frequency.
++ */
++static int spmi_haptics_set_auto_res(struct spmi_haptics *haptics, bool enable)
++{
++	u8 val;
++
++	// LRAs are the only type to support auto res
++	if (haptics->actuator_type != HAP_TYPE_LRA)
++		return 0;
++
++	val = enable ? AUTO_RES_EN_BIT : 0;
++
++	return spmi_haptics_write_masked(haptics, haptics->base + HAP_TEST2_REG,
++				       AUTO_RES_EN_BIT, val);
++}
++
++static int spmi_haptics_write_brake(struct spmi_haptics *haptics)
++{
++	int ret, i;
++	u8 val;
++
++	dev_dbg(haptics->dev, "Configuring brake pattern");
++
++	ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_EN_CTL2_REG,
++					BRAKE_EN_BIT, 1);
++	if (ret < 0)
++		return ret;
++
++	for (i = HAP_BRAKE_PAT_LEN - 1, val = 0; i >= 0; i--) {
++		u8 p = haptics->brake_pat[i] & HAP_BRAKE_PAT_MASK;
++
++		val |= p << (i * 2);
++	}
++
++	return spmi_haptics_write(haptics, haptics->base + HAP_BRAKE_REG, &val, 1);
++}
++
++static int spmi_haptics_write_buffer_config(struct spmi_haptics *haptics)
++{
++	u8 buf[HAP_WAVE_SAMP_LEN];
++	int i;
++
++	dev_dbg(haptics->dev, "Writing buffer config");
++
++	for (i = 0; i < HAP_WAVE_SAMP_LEN; i++)
++		buf[i] = haptics->wave_samp[i];
++
++	return spmi_haptics_write(haptics, haptics->base + HAP_WF_S1_REG, buf,
++				  HAP_WAVE_SAMP_LEN);
++}
++
++/*
++ * spmi_haptics_write_wave_repeat() - write wave repeat values.
++ */
++static int spmi_haptics_write_wave_repeat(struct spmi_haptics *haptics)
++{
++	u8 val, mask;
++
++	/* The number of times to repeat each wave */
++	mask = WF_REPEAT_MASK | WF_S_REPEAT_MASK;
++	val = FIELD_PREP(WF_REPEAT_MASK, 0) |
++	      FIELD_PREP(WF_S_REPEAT_MASK, 0);
++
++	return spmi_haptics_write_masked(haptics, haptics->base + HAP_WF_REPEAT_REG,
++					 mask, val);
++}
++
++static int spmi_haptics_write_play_control(struct spmi_haptics *haptics,
++						enum hap_play_control ctrl)
++{
++	u8 val;
++
++	switch (ctrl) {
++	case HAP_STOP:
++		val = 0;
++		break;
++	case HAP_PAUSE:
++		val = HAP_PAUSE_BIT;
++		break;
++	case HAP_PLAY:
++		val = HAP_PLAY_BIT;
++		break;
++	default:
++		return 0;
++	}
++
++	dev_dbg(haptics->dev, "haptics play ctrl: %d\n", ctrl);
++	return spmi_haptics_write(haptics, haptics->base + HAP_PLAY_REG, &val, 1);
++}
++
++/*
++ * This IRQ is fired to tell us to load the next wave sample set.
++ * As we only currently support a single sample set, it's unused.
++ */
++static irqreturn_t spmi_haptics_play_irq_handler(int irq, void *data)
++{
++	struct spmi_haptics *haptics = data;
++
++	dev_dbg(haptics->dev, "play_irq triggered");
++
++	return IRQ_HANDLED;
++}
++
++/*
++ * Fires every ~50ms whilst the haptics are active.
++ * If the SC_FLAG_BIT is set then that means there isn't a short circuit
++ * and we just need to clear the IRQ to indicate that the device should
++ * keep vibrating.
++ *
++ * Otherwise, it means a short circuit situation has occurred.
++ */
++static irqreturn_t spmi_haptics_sc_irq_handler(int irq, void *data)
++{
++	struct spmi_haptics *haptics = data;
++	int ret;
++	u8 val;
++	s64 sc_delta_time_us;
++	ktime_t temp;
++
++	ret = spmi_haptics_read(haptics, haptics->base + HAP_STATUS_1_REG, &val, 1);
++	if (ret < 0)
++		return IRQ_HANDLED;
++
++	if (!(val & SC_FLAG_BIT)) {
++		haptics->sc_count = 0;
++		return IRQ_HANDLED;
++	}
++
++	temp = ktime_get();
++	sc_delta_time_us = ktime_us_delta(temp, haptics->last_sc_time);
++	haptics->last_sc_time = temp;
++
++	if (sc_delta_time_us > SC_COUNT_RST_DELAY_US)
++		haptics->sc_count = 0;
++	else
++		haptics->sc_count++;
++
++	// Clear the interrupt flag
++	val = SC_CLR_BIT;
++	ret = spmi_haptics_write(haptics, haptics->base + HAP_SC_CLR_REG, &val, 1);
++	if (ret < 0)
++		return IRQ_HANDLED;
++
++	if (haptics->sc_count > SC_MAX_COUNT) {
++		dev_crit(haptics->dev, "Short circuit persists, disabling haptics\n");
++		ret = spmi_haptics_module_enable(haptics, false);
++		if (ret < 0)
++			dev_err(haptics->dev, "Error disabling module, rc=%d\n", ret);
++	}
++
++	return IRQ_HANDLED;
++}
++
++
++/**
++ * spmi_haptics_init() - Initialise haptics hardware for use
++ * @haptics: haptics device
++ * Returns: 0 on success, < 0 on error
++ */
++static int spmi_haptics_init(struct spmi_haptics *haptics)
++{
++	int ret;
++	u8 val, mask;
++	u16 play_rate;
++
++	ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_CFG1_REG,
++		HAP_ACT_TYPE_MASK, haptics->actuator_type);
++	if (ret < 0)
++		return ret;
++
++	/*
++	 * Configure auto resonance
++	 * see spmi_haptics_lra_auto_res_config downstream
++	 * This is greatly simplified.
++	 */
++	val = FIELD_PREP(LRA_RES_CAL_MASK, ilog2(32 / HAP_RES_CAL_PERIOD_MIN)) |
++	      FIELD_PREP(LRA_AUTO_RES_MODE_MASK, HAP_AUTO_RES_ZXD_EOP) |
++	      FIELD_PREP(LRA_HIGH_Z_MASK, 1);
++
++	mask = LRA_AUTO_RES_MODE_MASK | LRA_HIGH_Z_MASK | LRA_RES_CAL_MASK;
++
++	ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_LRA_AUTO_RES_REG,
++			mask, val);
++
++	/* Configure the PLAY MODE register */
++	ret = spmi_haptics_write_play_mode(haptics);
++	if (ret < 0)
++		return ret;
++
++	ret = spmi_haptics_write_vmax(haptics);
++	if (ret < 0)
++		return ret;
++
++	/* Configure the ILIM register */
++	ret = spmi_haptics_write_current_limit(haptics);
++	if (ret < 0)
++		return ret;
++
++	// Configure the debounce for short-circuit detection.
++	ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_SC_DEB_REG,
++			HAP_SC_DEB_MASK, HAP_SC_DEB_CYCLES_MAX);
++	if (ret < 0)
++		return ret;
++
++	// write the wave shape
++	ret = spmi_haptics_write_masked(haptics, haptics->base + HAP_CFG2_REG,
++			HAP_LRA_RES_TYPE_MASK, haptics->wave_shape);
++	if (ret < 0)
++		return ret;
++
++	play_rate = haptics->play_wave_rate / HAP_RATE_CFG_STEP_US;
++
++	/*
++	 * Configure RATE_CFG1 and RATE_CFG2 registers.
++	 * Note: For ERM these registers act as play rate and
++	 * for LRA these represent resonance period
++	 */
++	ret = spmi_haptics_write_play_rate(haptics, play_rate);
++	if (ret < 0)
++		return ret;
++
++	ret = spmi_haptics_write_brake(haptics);
++	if (ret < 0)
++		return ret;
++
++	if (haptics->play_mode == HAP_PLAY_BUFFER) {
++		ret = spmi_haptics_write_wave_repeat(haptics);
++		if (ret < 0)
++			return ret;
++
++		ret = spmi_haptics_write_buffer_config(haptics);
++		if (ret < 0)
++			return ret;
++	}
++
++	if (haptics->play_irq >= 0) {
++		dev_dbg(haptics->dev, "%s: Requesting play IRQ, irq: %d", __func__,
++			haptics->play_irq);
++		ret = devm_request_threaded_irq(haptics->dev, haptics->play_irq,
++			NULL, spmi_haptics_play_irq_handler, IRQF_ONESHOT,
++			"haptics_play_irq", haptics);
++
++		if (ret < 0) {
++			dev_err(haptics->dev, "Unable to request play IRQ ret=%d\n", ret);
++			return ret;
++		}
++
++		/* use play_irq only for buffer mode */
++		if (haptics->play_mode != HAP_PLAY_BUFFER)
++			disable_irq(haptics->play_irq);
++	}
++
++	if (haptics->sc_irq >= 0) {
++		dev_dbg(haptics->dev, "%s: Requesting play IRQ, irq: %d", __func__,
++			haptics->play_irq);
++		ret = devm_request_threaded_irq(haptics->dev, haptics->sc_irq,
++			NULL, spmi_haptics_sc_irq_handler, IRQF_ONESHOT,
++			"haptics_sc_irq", haptics);
++
++		if (ret < 0) {
++			dev_err(haptics->dev, "Unable to request sc IRQ ret=%d\n", ret);
++			return ret;
++		}
++	}
++
++	return 0;
++}
++
++/**
++ * spmi_haptics_enable - handler to start/stop vibration
++ * @haptics: pointer to haptics struct
++ * @enable: state to set
++ * Returns: 0 on success, < 0 on failure
++ */
++static int spmi_haptics_enable(struct spmi_haptics *haptics)
++{
++	int ret;
++
++	mutex_lock(&haptics->play_lock);
++	if (haptics->sc_count > SC_MAX_COUNT) {
++		dev_err(haptics->dev, "Can't play while in short circuit");
++		ret = -1;
++		goto out;
++	}
++	ret = spmi_haptics_set_auto_res(haptics, false);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Error disabling auto_res, ret=%d\n", ret);
++		goto out;
++	}
++
++	ret = spmi_haptics_module_enable(haptics, true);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Error enabling module, ret=%d\n", ret);
++		goto out;
++	}
++
++	ret = spmi_haptics_write_play_control(haptics, HAP_PLAY);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Error enabling play, ret=%d\n", ret);
++		goto out;
++	}
++
++	ret = spmi_haptics_set_auto_res(haptics, true);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Error enabling auto_res, ret=%d\n", ret);
++		goto out;
++	}
++
++out:
++	mutex_unlock(&haptics->play_lock);
++	return ret;
++}
++
++/**
++ * spmi_haptics_enable - handler to start/stop vibration
++ * @haptics: pointer to haptics struct
++ * @enable: state to set
++ * Returns: 0 on success, < 0 on failure
++ */
++static int spmi_haptics_disable(struct spmi_haptics *haptics)
++{
++	int ret;
++
++	mutex_lock(&haptics->play_lock);
++
++	ret = spmi_haptics_write_play_control(haptics, HAP_STOP);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Error disabling play, ret=%d\n", ret);
++		goto out;
++	}
++
++	ret = spmi_haptics_module_enable(haptics, false);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Error disabling module, ret=%d\n", ret);
++		goto out;
++	}
++
++out:
++	mutex_unlock(&haptics->play_lock);
++	return ret;
++}
++
++/*
++ * Threaded function to update the haptics state.
++ */
++static void spmi_haptics_work(struct work_struct *work)
++{
++	struct spmi_haptics *haptics = container_of(work, struct spmi_haptics, work);
++
++	int ret;
++	bool enable;
++
++	enable = atomic_read(&haptics->active);
++	dev_dbg(haptics->dev, "%s: state: %d\n", __func__, enable);
++
++	if (enable)
++		ret = spmi_haptics_enable(haptics);
++	else
++		ret = spmi_haptics_disable(haptics);
++	if (ret < 0)
++		dev_err(haptics->dev, "Error setting haptics, ret=%d", ret);
++}
++
++/**
++ * spmi_haptics_close - callback for input device close
++ * @dev: input device pointer
++ *
++ * Turns off the vibrator.
++ */
++static void spmi_haptics_close(struct input_dev *dev)
++{
++	struct spmi_haptics *haptics = input_get_drvdata(dev);
++
++	cancel_work_sync(&haptics->work);
++	if (atomic_read(&haptics->active)) {
++		atomic_set(&haptics->active, 0);
++		schedule_work(&haptics->work);
++	}
++}
++
++/**
++ * spmi_haptics_play_effect - play haptics effects
++ * @dev: input device pointer
++ * @data: data of effect
++ * @effect: effect to play
++ */
++static int spmi_haptics_play_effect(struct input_dev *dev, void *data,
++					struct ff_effect *effect)
++{
++	struct spmi_haptics *haptics = input_get_drvdata(dev);
++
++	dev_dbg(haptics->dev, "%s: Rumbling with strong: %d and weak: %d", __func__,
++		effect->u.rumble.strong_magnitude, effect->u.rumble.weak_magnitude);
++
++	haptics->magnitude = effect->u.rumble.strong_magnitude >> 8;
++	if (!haptics->magnitude)
++		haptics->magnitude = effect->u.rumble.weak_magnitude >> 10;
++
++	if (!haptics->magnitude) {
++		atomic_set(&haptics->active, 0);
++		goto end;
++	}
++
++	atomic_set(&haptics->active, 1);
++
++	haptics->vmax = ((HAP_VMAX_MAX_MV - HAP_VMAX_MIN_MV) * haptics->magnitude) / 100 +
++					HAP_VMAX_MIN_MV;
++
++	dev_dbg(haptics->dev, "%s: magnitude: %d, vmax: %d", __func__,
++		haptics->magnitude, haptics->vmax);
++
++	spmi_haptics_write_vmax(haptics);
++
++end:
++	schedule_work(&haptics->work);
++
++	return 0;
++}
++
++static int spmi_haptics_probe(struct platform_device *pdev)
++{
++	struct spmi_haptics *haptics;
++	struct device_node *node;
++	struct input_dev *input_dev;
++	int ret;
++	u32 val;
++	int i;
++
++	haptics = devm_kzalloc(&pdev->dev, sizeof(*haptics), GFP_KERNEL);
++	if (!haptics)
++		return -ENOMEM;
++
++	haptics->regmap = dev_get_regmap(pdev->dev.parent, NULL);
++	if (!haptics->regmap)
++		return -ENODEV;
++
++	node = pdev->dev.of_node;
++
++	haptics->dev = &pdev->dev;
++
++	ret = of_property_read_u32(node, "reg", &haptics->base);
++	if (ret < 0) {
++		dev_err(haptics->dev, "Couldn't find reg in node = %s ret = %d\n",
++			node->full_name, ret);
++		return ret;
++	}
++
++	haptics->play_irq = platform_get_irq_byname(pdev, "play");
++	if (haptics->play_irq < 0) {
++		dev_err(&pdev->dev, "Unable to get play irq\n");
++		ret = haptics->play_irq;
++		goto register_fail;
++	}
++
++	haptics->sc_irq = platform_get_irq_byname(pdev, "short");
++	if (haptics->sc_irq < 0) {
++		dev_err(&pdev->dev, "Unable to get sc irq\n");
++		ret = haptics->sc_irq;
++		goto register_fail;
++	}
++
++	// We only support LRAs for now
++	haptics->actuator_type = HAP_TYPE_LRA;
++	ret = of_property_read_u32(node, "qcom,actuator-type", &val);
++	if (!ret) {
++		haptics->actuator_type = val;
++	}
++
++	// Only buffer mode is currently supported
++	haptics->play_mode = HAP_PLAY_BUFFER;
++	ret = of_property_read_u32(node, "qcom,play-mode", &val);
++	if (!ret) {
++		if (val != HAP_PLAY_BUFFER) {
++			dev_err(&pdev->dev, "qcom,play-mode (%d) isn't supported\n", val);
++			ret = -EINVAL;
++			goto register_fail;
++		}
++		haptics->play_mode = val;
++	}
++
++	ret = of_property_read_u32(node, "qcom,wave-play-rate-us", &val);
++	if (!ret) {
++		haptics->play_wave_rate = val;
++	} else if (ret != -EINVAL) {
++		dev_err(haptics->dev, "Unable to read play rate ret=%d\n", ret);
++		goto register_fail;
++	}
++
++	haptics->play_wave_rate =
++		clamp_t(u32, haptics->play_wave_rate,
++			HAP_WAVE_PLAY_RATE_MIN_US, HAP_WAVE_PLAY_RATE_MAX_US);
++
++	haptics->wave_shape = HAP_WAVE_SINE;
++	ret = of_property_read_u32(node, "qcom,wave-shape", &val);
++	if (!ret) {
++		if (val != HAP_WAVE_SINE && val != HAP_WAVE_SQUARE) {
++			dev_err(&pdev->dev, "qcom,wave-shape is invalid: %d\n", val);
++			ret = -EINVAL;
++			goto register_fail;
++		}
++		haptics->wave_shape = val;
++	}
++
++	haptics->brake_pat[0] = 0x3;
++	haptics->brake_pat[1] = 0x3;
++	haptics->brake_pat[2] = 0x2;
++	haptics->brake_pat[3] = 0x1;
++
++	ret = of_property_read_u8_array(node, "qcom,brake-pattern", haptics->brake_pat, 4);
++	if (ret < 0 && ret != -EINVAL) {
++		dev_err(&pdev->dev, "qcom,brake-pattern is invalid, ret = %d\n", ret);
++		goto register_fail;
++	}
++
++	haptics->boost =
++		devm_gpiod_get_optional(haptics->dev, "qcom,boost", GPIOD_OUT_HIGH);
++	if (IS_ERR(haptics->boost)) {
++		ret = PTR_ERR(haptics->boost);
++		dev_warn(haptics->dev, "Unable to get boost gpio: %d\n", ret);
++	}
++
++	if (haptics->boost)
++		gpiod_set_value_cansleep(haptics->boost, 1);
++
++	haptics->current_limit = HAP_ILIM_400_MA;
++
++	for (i = 0; i < HAP_WAVE_SAMP_LEN; i++)
++		haptics->wave_samp[i] = HAP_WF_SAMP_MAX;
++
++	ret = spmi_haptics_init(haptics);
++	if (ret < 0) {
++		dev_err(&pdev->dev, "Error initialising haptics, ret=%d\n",
++			ret);
++		goto register_fail;
++	}
++
++	platform_set_drvdata(pdev, haptics);
++
++	input_dev = devm_input_allocate_device(&pdev->dev);
++	if (!input_dev)
++		return -ENOMEM;
++
++	INIT_WORK(&haptics->work, spmi_haptics_work);
++	haptics->haptics_input_dev = input_dev;
++
++	input_dev->name = "spmi_haptics";
++	input_dev->id.version = 1;
++	input_dev->close = spmi_haptics_close;
++	input_set_drvdata(input_dev, haptics);
++	// Figure out how to make this FF_PERIODIC
++	input_set_capability(haptics->haptics_input_dev, EV_FF, FF_RUMBLE);
++
++	ret = input_ff_create_memless(input_dev, NULL,
++					spmi_haptics_play_effect);
++	if (ret) {
++		dev_err(&pdev->dev,
++			"couldn't register vibrator as FF device\n");
++		goto register_fail;
++	}
++
++	ret = input_register_device(input_dev);
++	if (ret) {
++		dev_err(&pdev->dev, "couldn't register input device\n");
++		goto register_fail;
++	}
++
++	return 0;
++
++register_fail:
++	cancel_work_sync(&haptics->work);
++	mutex_destroy(&haptics->play_lock);
++
++	return ret;
++}
++
++static int __maybe_unused spmi_haptics_suspend(struct device *dev)
++{
++	struct spmi_haptics *haptics = dev_get_drvdata(dev);
++
++	cancel_work_sync(&haptics->work);
++	spmi_haptics_disable(haptics);
++
++	return 0;
++}
++
++static SIMPLE_DEV_PM_OPS(spmi_haptics_pm_ops, spmi_haptics_suspend, NULL);
++
++static void spmi_haptics_remove(struct platform_device *pdev)
++{
++	struct spmi_haptics *haptics = dev_get_drvdata(&pdev->dev);
++
++	cancel_work_sync(&haptics->work);
++	mutex_destroy(&haptics->play_lock);
++	input_unregister_device(haptics->haptics_input_dev);
++
++	if (haptics->boost)
++		gpiod_set_value_cansleep(haptics->boost, 0);
++}
++
++static void spmi_haptics_shutdown(struct platform_device *pdev)
++{
++	struct spmi_haptics *haptics = dev_get_drvdata(&pdev->dev);
++
++	cancel_work_sync(&haptics->work);
++
++	spmi_haptics_disable(haptics);
++
++	if (haptics->boost)
++		gpiod_set_value_cansleep(haptics->boost, 0);
++}
++
++static const struct of_device_id spmi_haptics_match_table[] = {
++	{ .compatible = "qcom,spmi-haptics" },
++	{ }
++};
++MODULE_DEVICE_TABLE(of, spmi_haptics_match_table);
++
++static struct platform_driver spmi_haptics_driver = {
++	.probe		= spmi_haptics_probe,
++	.remove		= spmi_haptics_remove,
++	.shutdown	= spmi_haptics_shutdown,
++	.driver		= {
++		.name	= "spmi-haptics",
++		.pm	= &spmi_haptics_pm_ops,
++		.of_match_table = spmi_haptics_match_table,
++	},
++};
++module_platform_driver(spmi_haptics_driver);
++
++MODULE_DESCRIPTION("spmi haptics driver using ff-memless framework");
++MODULE_LICENSE("GPL v2");
++MODULE_AUTHOR("Caleb Connolly <caleb@connolly.tech>");
+diff --git a/include/dt-bindings/input/qcom,spmi-haptics.h b/include/dt-bindings/input/qcom,spmi-haptics.h
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/include/dt-bindings/input/qcom,spmi-haptics.h
+@@ -0,0 +1,31 @@
++/*
++ * This header provides constants for pmi8998 SPMI haptics options.
++ */
++
++#ifndef _DT_BINDINGS_QCOM_PMIC_SPMI_HAPTICS_
++#define _DT_BINDINGS_QCOM_PMIC_SPMI_HAPTICS_
++
++// Actuator types
++#define HAP_TYPE_LRA		0
++#define HAP_TYPE_ERM		1
++
++// LRA Wave type
++#define HAP_WAVE_SINE		0
++#define HAP_WAVE_SQUARE		1
++
++// Play modes
++#define HAP_PLAY_DIRECT		0
++#define HAP_PLAY_BUFFER		1
++#define HAP_PLAY_AUDIO		2
++#define HAP_PLAY_PWM		3
++
++#define HAP_PLAY_MAX		HAP_PLAY_PWM
++
++// Auto resonance type
++#define HAP_AUTO_RES_NONE	0
++#define HAP_AUTO_RES_ZXD	1
++#define HAP_AUTO_RES_QWD	2
++#define HAP_AUTO_RES_MAX_QWD	3
++#define HAP_AUTO_RES_ZXD_EOP	4
++
++#endif /* _DT_BINDINGS_QCOM_PMIC_SPMI_HAPTICS_ */
+-- 
+Armbian
+
diff --git a/patch/kernel/archive/sm8250-6.18/0069-arm64-dts-qcom-pm8150b-introduce-spmi-haptics.patch b/patch/kernel/archive/sm8250-6.18/0069-arm64-dts-qcom-pm8150b-introduce-spmi-haptics.patch
new file mode 100644
index 0000000000..e58dcbf12d
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0069-arm64-dts-qcom-pm8150b-introduce-spmi-haptics.patch
@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Mon, 25 Nov 2024 02:17:47 +0700
+Subject: arm64: dts: qcom: pm8150b: introduce spmi haptics
+
+Add bindings for Qualcomm SPMI haptics on platforms using pm8150b.
+Signed-off-by: Teguh Sobirin <teguh@sobir.in>
+---
+ arch/arm64/boot/dts/qcom/pm8150b.dtsi | 16 ++++++++++
+ 1 file changed, 16 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/qcom/pm8150b.dtsi b/arch/arm64/boot/dts/qcom/pm8150b.dtsi
+index 111111111111..222222222222 100644
+--- a/arch/arm64/boot/dts/qcom/pm8150b.dtsi
++++ b/arch/arm64/boot/dts/qcom/pm8150b.dtsi
+@@ -5,6 +5,7 @@
+  */
+ 
+ #include <dt-bindings/iio/qcom,spmi-vadc.h>
++#include <dt-bindings/input/qcom,spmi-haptics.h>
+ #include <dt-bindings/interrupt-controller/irq.h>
+ #include <dt-bindings/spmi/spmi.h>
+ 
+@@ -216,5 +217,20 @@ pm8150b_lpg: pwm {
+ 
+ 			status = "disabled";
+ 		};
++
++		pm8150b_haptics: haptics@c000 {
++			compatible = "qcom,pmi8998-haptics", "qcom,spmi-haptics";
++			reg = <0xc000>;
++
++			interrupts = <0x3 0xc0 0x0 IRQ_TYPE_EDGE_BOTH>,
++				     <0x3 0xc0 0x1 IRQ_TYPE_EDGE_BOTH>;
++			interrupt-names = "short", "play";
++
++			qcom,wave-shape = <HAP_WAVE_SINE>;
++			qcom,play-mode = <HAP_PLAY_BUFFER>;
++			qcom,brake-pattern = <0x3 0x3 0x2 0x1>;
++
++			status = "disabled";
++		};
+ 	};
+ };
+-- 
+Armbian
+
diff --git a/patch/kernel/archive/sm8250-6.18/0070-arm64-dts-qcom-add-SM8250-Retroid-Pocket-variant-Sig.patch b/patch/kernel/archive/sm8250-6.18/0070-arm64-dts-qcom-add-SM8250-Retroid-Pocket-variant-Sig.patch
new file mode 100644
index 0000000000..b8e0b21a29
--- /dev/null
+++ b/patch/kernel/archive/sm8250-6.18/0070-arm64-dts-qcom-add-SM8250-Retroid-Pocket-variant-Sig.patch
@@ -0,0 +1,1666 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Teguh Sobirin <teguh@sobir.in>
+Date: Mon, 25 Nov 2024 02:19:13 +0700
+Subject: arm64: dts: qcom: add SM8250 Retroid Pocket variant Signed-off-by:
+ Teguh Sobirin <teguh@sobir.in>
+
+---
+ arch/arm64/boot/dts/qcom/sm8250-retroidpocket-common.dtsi | 1435 ++++++++++
+ arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rp5.dts     |  100 +
+ arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rpmini.dts  |   98 +
+ 3 files changed, 1633 insertions(+)
+
+diff --git a/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-common.dtsi b/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-common.dtsi
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-common.dtsi
+@@ -0,0 +1,1435 @@
++// SPDX-License-Identifier: BSD-3-Clause
++/*
++ * Copyright (c) 2024, Retroid Pocket.
++ */
++
++/dts-v1/;
++
++#include <dt-bindings/leds/common.h>
++#include <dt-bindings/regulator/qcom,rpmh-regulator.h>
++#include <dt-bindings/sound/qcom,q6afe.h>
++#include <dt-bindings/sound/qcom,q6asm.h>
++#include <dt-bindings/usb/pd.h>
++#include "sm8250.dtsi"
++#include "pm8150.dtsi"
++#include "pm8150b.dtsi"
++#include "pm8150l.dtsi"
++
++/ {
++	qcom,msm-id = <356 0x20001>;
++	qcom,board-id = <0x01001F 0x01>;
++
++	aliases {
++		serial0 = &uart12;
++		serial1 = &uart6;
++		serial2 = &uart16;
++		sdhc2 = &sdhc_2;
++	};
++
++	battery: battery {
++		compatible = "simple-battery";
++
++		charge-full-design-microamp-hours = <3850000>;
++		voltage-min-design-microvolt = <3600000>;
++		voltage-max-design-microvolt = <4400000>;
++	};
++
++	chosen {
++		stdout-path = "serial0:115200n8";
++	};
++
++	fan: pwm-fan {
++		compatible = "pwm-fan";
++		cooling-levels = <0 32 64 128 255>;
++		#cooling-cells = <2>;
++		fan-supply = <&vreg_fan_pwr>;
++		pwms = <&pm8150l_lpg 3 100000>;
++		pinctrl-names = "default";
++		pinctrl-0 = <&fan_pwm_active>;
++	};
++
++	gpio-keys {
++		compatible = "gpio-keys";
++
++		key-vol-up {
++			label = "Volume Up";
++			linux,code = <KEY_VOLUMEUP>;
++			gpios = <&pm8150_gpios 6 GPIO_ACTIVE_LOW>;
++		};
++	};
++
++	thermal-zones {
++		conn-thermal {
++			thermal-sensors = <&pm8150b_adc_tm 0>;
++
++			trips {
++				active-config0 {
++					temperature = <125000>;
++					hysteresis = <1000>;
++					type = "critical";
++				};
++			};
++		};
++
++		pm8150l-pcb-thermal {
++			thermal-sensors = <&pm8150l_adc_tm 1>;
++
++			trips {
++				active-config0 {
++					temperature = <50000>;
++					hysteresis = <4000>;
++					type = "passive";
++				};
++			};
++		};
++
++		skin-msm-thermal {
++			thermal-sensors = <&pm8150l_adc_tm 0>;
++
++			trips {
++				active-config0 {
++					temperature = <50000>;
++					hysteresis = <4000>;
++					type = "passive";
++				};
++			};
++		};
++
++		wifi-thermal {
++			thermal-sensors = <&pm8150_adc_tm 1>;
++
++			trips {
++				active-config0 {
++					temperature = <52000>;
++					hysteresis = <4000>;
++					type = "passive";
++				};
++			};
++		};
++
++		xo-thermal {
++			thermal-sensors = <&pm8150_adc_tm 0>;
++
++			trips {
++				active-config0 {
++					temperature = <50000>;
++					hysteresis = <4000>;
++					type = "passive";
++				};
++			};
++		};
++	};
++
++	vbat: vbat-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "VBAT";
++		vin-supply = <&vreg_l11c_3p3>;
++		regulator-min-microvolt = <4200000>;
++		regulator-max-microvolt = <4200000>;
++		regulator-always-on;
++	};
++
++	vdc_3v3: vdc-3v3-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "VDC_3V3";
++		vin-supply = <&vreg_l11c_3p3>;
++		regulator-min-microvolt = <3300000>;
++		regulator-max-microvolt = <3300000>;
++		regulator-always-on;
++	};
++
++	vdc_5v: vdc-5v-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "VDC_5V";
++
++		regulator-min-microvolt = <5000000>;
++		regulator-max-microvolt = <5000000>;
++		regulator-always-on;
++		vin-supply = <&vreg_l11c_3p3>;
++	};
++
++	vdda_panel: vdda-panel-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "vdda_panel";
++
++		regulator-min-microvolt = <2800000>;
++		regulator-max-microvolt = <2800000>;
++
++		gpio = <&tlmm 4 GPIO_ACTIVE_HIGH>;
++		enable-active-high;
++		regulator-boot-on;
++	};
++
++	vph_pwr: vph-pwr-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "vph_pwr";
++		regulator-min-microvolt = <3700000>;
++		regulator-max-microvolt = <3700000>;
++		regulator-always-on;
++	};
++
++	vreg_s4a_1p8: vreg-s4a-1p8 {
++		compatible = "regulator-fixed";
++		regulator-name = "vreg_s4a_1p8";
++		regulator-min-microvolt = <1800000>;
++		regulator-max-microvolt = <1800000>;
++		regulator-always-on;
++		regulator-boot-on;
++		vin-supply = <&vph_pwr>;
++	};
++
++	vreg_fan_pwr: vreg-fan-pwr-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "vreg_fan_pwr";
++
++		regulator-min-microvolt = <5000000>;
++		regulator-max-microvolt = <5000000>;
++
++		gpio = <&tlmm 7 GPIO_ACTIVE_HIGH>;
++		enable-active-high;
++
++		regulator-state-mem {
++			regulator-off-in-suspend;
++		};
++	};
++
++	vreg_mcu_3v3: vreg-mcu-3v3-regulator {
++		compatible = "regulator-fixed";
++		regulator-name = "vreg_mcu_3v3";
++
++		regulator-min-microvolt = <3300000>;
++		regulator-max-microvolt = <3300000>;
++
++		gpio = <&tlmm 3 GPIO_ACTIVE_HIGH>;
++		regulator-always-on;
++		regulator-boot-on;
++		enable-active-high;
++	};
++
++	qca6390-pmu {
++		compatible = "qcom,qca6390-pmu";
++
++		pinctrl-names = "default";
++		pinctrl-0 = <&bt_en_state>, <&wlan_en_state>;
++
++		vddaon-supply = <&vreg_s6a_0p95>;
++		vddrfa1p3-supply = <&vreg_s8c_1p3>;
++		vddrfa1p9-supply = <&vreg_s5a_1p9>;
++		vddpcie1p3-supply = <&vreg_s8c_1p3>;
++		vddpcie1p9-supply = <&vreg_s5a_1p9>;
++		vddio-supply = <&vreg_s4a_1p8>;
++
++		wlan-enable-gpios = <&tlmm 20 GPIO_ACTIVE_HIGH>;
++		bt-enable-gpios = <&tlmm 21 GPIO_ACTIVE_HIGH>;
++
++		regulators {
++			vreg_pmu_rfa_cmn: ldo0 {
++				regulator-name = "vreg_pmu_rfa_cmn";
++			};
++
++			vreg_pmu_aon_0p59: ldo1 {
++				regulator-name = "vreg_pmu_aon_0p59";
++			};
++
++			vreg_pmu_wlcx_0p8: ldo2 {
++				regulator-name = "vreg_pmu_wlcx_0p8";
++			};
++
++			vreg_pmu_wlmx_0p85: ldo3 {
++				regulator-name = "vreg_pmu_wlmx_0p85";
++			};
++
++			vreg_pmu_btcmx_0p85: ldo4 {
++				regulator-name = "vreg_pmu_btcmx_0p85";
++			};
++
++			vreg_pmu_rfa_0p8: ldo5 {
++				regulator-name = "vreg_pmu_rfa_0p8";
++			};
++
++			vreg_pmu_rfa_1p2: ldo6 {
++				regulator-name = "vreg_pmu_rfa_1p2";
++			};
++
++			vreg_pmu_rfa_1p7: ldo7 {
++				regulator-name = "vreg_pmu_rfa_1p7";
++			};
++
++			vreg_pmu_pcie_0p9: ldo8 {
++				regulator-name = "vreg_pmu_pcie_0p9";
++			};
++
++			vreg_pmu_pcie_1p8: ldo9 {
++				regulator-name = "vreg_pmu_pcie_1p8";
++			};
++		};
++	};
++
++	wcd938x: audio-codec {
++		compatible = "qcom,wcd9385-codec";
++
++		pinctrl-names = "default";
++		pinctrl-0 = <&wcd_default>;
++
++		reset-gpios = <&tlmm 32 GPIO_ACTIVE_LOW>;
++
++		vdd-buck-supply = <&vreg_s4a_1p8>;
++		vdd-rxtx-supply = <&vreg_s4a_1p8>;
++		vdd-io-supply = <&vreg_s4a_1p8>;
++		vdd-mic-bias-supply = <&vreg_bob>;
++
++		qcom,micbias1-microvolt = <1800000>;
++		qcom,micbias2-microvolt = <1800000>;
++		qcom,micbias3-microvolt = <1800000>;
++		qcom,micbias4-microvolt = <1800000>;
++		qcom,mbhc-buttons-vthreshold-microvolt = <75000 150000 237000 500000 500000 500000 500000 500000>;
++		qcom,mbhc-headset-vthreshold-microvolt = <1700000>;
++		qcom,mbhc-headphone-vthreshold-microvolt = <50000>;
++		qcom,rx-device = <&wcd_rx>;
++		qcom,tx-device = <&wcd_tx>;
++
++		#sound-dai-cells = <1>;
++	};
++
++	reserved-memory {
++		cont_splash_mem: splash_region@9c000000 {
++			reg = <0x0 0x9c000000 0x0 0x2300000>;
++			no-map;
++		};
++	};
++};
++
++&adsp {
++	status = "okay";
++	firmware-name = "qcom/sm8250/adsp.mbn";
++};
++
++&apps_rsc {
++	regulators-0 {
++		compatible = "qcom,pm8150-rpmh-regulators";
++		qcom,pmic-id = "a";
++
++		vdd-s1-supply = <&vph_pwr>;
++		vdd-s2-supply = <&vph_pwr>;
++		vdd-s3-supply = <&vph_pwr>;
++		vdd-s4-supply = <&vph_pwr>;
++		vdd-s5-supply = <&vph_pwr>;
++		vdd-s6-supply = <&vph_pwr>;
++		vdd-s7-supply = <&vph_pwr>;
++		vdd-s8-supply = <&vph_pwr>;
++		vdd-s9-supply = <&vph_pwr>;
++		vdd-s10-supply = <&vph_pwr>;
++		vdd-l2-l10-supply = <&vreg_bob>;
++		vdd-l3-l4-l5-l18-supply = <&vreg_s6a_0p95>;
++		vdd-l6-l9-supply = <&vreg_s8c_1p3>;
++		vdd-l7-l12-l14-l15-supply = <&vreg_s5a_1p9>;
++		vdd-l13-l16-l17-supply = <&vreg_bob>;
++
++		vreg_l2a_3p1: ldo2 {
++			regulator-name = "vreg_l2a_3p1";
++			regulator-min-microvolt = <3072000>;
++			regulator-max-microvolt = <3072000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l3a_0p9: ldo3 {
++			regulator-name = "vreg_l3a_0p9";
++			regulator-min-microvolt = <928000>;
++			regulator-max-microvolt = <932000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l5a_0p88: ldo5 {
++			regulator-name = "vreg_l5a_0p88";
++			regulator-min-microvolt = <880000>;
++			regulator-max-microvolt = <880000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l6a_1p2: ldo6 {
++			regulator-name = "vreg_l6a_1p2";
++			regulator-min-microvolt = <1200000>;
++			regulator-max-microvolt = <1200000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l7a_1p7: ldo7 {
++			regulator-name = "vreg_l7a_1p7";
++			regulator-min-microvolt = <1704000>;
++			regulator-max-microvolt = <1800000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l9a_1p2: ldo9 {
++			regulator-name = "vreg_l9a_1p2";
++			regulator-min-microvolt = <1200000>;
++			regulator-max-microvolt = <1200000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l10a_1p8: ldo10 {
++			regulator-name = "vreg_l10a_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <1800000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l12a_1p8: ldo12 {
++			regulator-name = "vreg_l12a_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <1800000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l13a_ts_3p0: ldo13 {
++			regulator-name = "vreg_l13a_ts_3p0";
++			regulator-min-microvolt = <3008000>;
++			regulator-max-microvolt = <3008000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l14a_1p8: ldo14 {
++			regulator-name = "vreg_l14a_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <1880000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l15a_1p8: ldo15 {
++			regulator-name = "vreg_l15a_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <1800000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l16a_2p7: ldo16 {
++			regulator-name = "vreg_l16a_2p7";
++			regulator-min-microvolt = <2704000>;
++			regulator-max-microvolt = <2960000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l17a_3p0: ldo17 {
++			regulator-name = "vreg_l17a_3p0";
++			regulator-min-microvolt = <2856000>;
++			regulator-max-microvolt = <3008000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l18a_0p92: ldo18 {
++			regulator-name = "vreg_l18a_0p92";
++			regulator-min-microvolt = <800000>;
++			regulator-max-microvolt = <912000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_s5a_1p9: smps5 {
++			regulator-name = "vreg_s5a_1p9";
++			regulator-min-microvolt = <1904000>;
++			regulator-max-microvolt = <2000000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_s6a_0p95: smps6 {
++			regulator-name = "vreg_s6a_0p95";
++			regulator-min-microvolt = <920000>;
++			regulator-max-microvolt = <1128000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++	};
++
++	regulators-1 {
++		compatible = "qcom,pm8150l-rpmh-regulators";
++		qcom,pmic-id = "c";
++
++		vdd-s1-supply = <&vph_pwr>;
++		vdd-s2-supply = <&vph_pwr>;
++		vdd-s3-supply = <&vph_pwr>;
++		vdd-s4-supply = <&vph_pwr>;
++		vdd-s5-supply = <&vph_pwr>;
++		vdd-s6-supply = <&vph_pwr>;
++		vdd-s7-supply = <&vph_pwr>;
++		vdd-s8-supply = <&vph_pwr>;
++		vdd-l1-l8-supply = <&vreg_s4a_1p8>;
++		vdd-l2-l3-supply = <&vreg_s8c_1p3>;
++		vdd-l4-l5-l6-supply = <&vreg_bob>;
++		vdd-l7-l11-supply = <&vreg_bob>;
++		vdd-l9-l10-supply = <&vreg_bob>;
++		vdd-bob-supply = <&vph_pwr>;
++
++		vreg_bob: bob {
++			regulator-name = "vreg_bob";
++			regulator-min-microvolt = <3008000>;
++			regulator-max-microvolt = <4000000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_AUTO>;
++		};
++
++		vreg_l1c_1p8: ldo1 {
++			regulator-name = "vreg_l1c_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <1800000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l2c_1p2: ldo2 {
++			regulator-name = "vreg_l2c_1p2";
++			regulator-min-microvolt = <1200000>;
++			regulator-max-microvolt = <1200000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l3c_1p2: ldo3 {
++			regulator-name = "vreg_l3c_1p2";
++			regulator-min-microvolt = <1200000>;
++			regulator-max-microvolt = <1200000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l4c_1p7: ldo4 {
++			regulator-name = "vreg_l4c_1p7";
++			regulator-min-microvolt = <1704000>;
++			regulator-max-microvolt = <2928000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l5c_1p8: ldo5 {
++			regulator-name = "vreg_l5c_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <2928000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l6c_2p96: ldo6 {
++			regulator-name = "vreg_l6c_2p96";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <2960000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l7c_cam_vcm0_2p85: ldo7 {
++			regulator-name = "vreg_l7c_cam_vcm0_2p85";
++			regulator-min-microvolt = <2856000>;
++			regulator-max-microvolt = <3104000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l8c_1p8: ldo8 {
++			regulator-name = "vreg_l8c_1p8";
++			regulator-min-microvolt = <1800000>;
++			regulator-max-microvolt = <1800000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l9c_2p96: ldo9 {
++			regulator-name = "vreg_l9c_2p96";
++			regulator-min-microvolt = <2704000>;
++			regulator-max-microvolt = <2960000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l10c_3p0: ldo10 {
++			regulator-name = "vreg_l10c_3p0";
++			regulator-min-microvolt = <3000000>;
++			regulator-max-microvolt = <3000000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++
++		vreg_l11c_3p3: ldo11 {
++			regulator-name = "vreg_l11c_3p3";
++			regulator-min-microvolt = <3296000>;
++			regulator-max-microvolt = <3296000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++			regulator-always-on;
++		};
++
++		vreg_s8c_1p3: smps8 {
++			regulator-name = "vreg_s8c_1p3";
++			regulator-min-microvolt = <1352000>;
++			regulator-max-microvolt = <1352000>;
++			regulator-initial-mode = <RPMH_REGULATOR_MODE_HPM>;
++		};
++	};
++};
++
++&cdsp {
++	status = "okay";
++	firmware-name = "qcom/sm8250/cdsp.mbn";
++};
++
++&gmu {
++	status = "okay";
++};
++
++&gpu {
++	status = "okay";
++
++	zap-shader {
++		memory-region = <&gpu_mem>;
++		firmware-name = "qcom/sm8250/a650_zap.mbn";
++	};
++};
++
++&i2c3 {
++	clock-frequency = <400000>;
++	status = "okay";
++
++	htr3212r: led-controller@3c {
++		compatible = "heroic,htr3212";
++		reg = <0x3c>;
++		#address-cells = <1>;
++		#size-cells = <0>;
++		sdb-gpios = <&tlmm 6 GPIO_ACTIVE_HIGH>;
++		vdd-supply = <&vreg_mcu_3v3>;
++
++		ledr_b1: led@1 {
++			reg = <1>;
++			label = "r:b1";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledr_g1: led@2 {
++			reg = <2>;
++			label = "r:g1";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledr_r1: led@3 {
++			reg = <3>;
++			label = "r:r1";
++			color = <LED_COLOR_ID_RED>;
++		};
++		ledr_b2: led@4 {
++			reg = <4>;
++			label = "r:b2";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledr_g2: led@5 {
++			reg = <5>;
++			label = "r:g2";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledr_r2: led@6 {
++			reg = <6>;
++			label = "r:r2";
++ 			color = <LED_COLOR_ID_RED>;
++		};
++		ledr_b3: led@7 {
++			reg = <7>;
++			label = "r:b3";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledr_g3: led@8 {
++			reg = <8>;
++			label = "r:g3";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledr_r3: led@9 {
++			reg = <9>;
++			label = "r:r3";
++			color = <LED_COLOR_ID_RED>;
++		};
++		ledr_b4: led@10 {
++			reg = <10>;
++			label = "r:b4";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledr_g4: led@11 {
++			reg = <11>;
++			label = "r:g4";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledr_r4: led@12 {
++			reg = <12>;
++			label = "r:r4";
++			color = <LED_COLOR_ID_RED>;
++		};
++	};
++};
++
++&i2c5 {
++	clock-frequency = <400000>;
++	status = "okay";
++
++	htr3212l: led-controller@3c {
++		compatible = "heroic,htr3212";
++		reg = <0x3c>;
++		#address-cells = <1>;
++		#size-cells = <0>;
++		sdb-gpios = <&tlmm 5 GPIO_ACTIVE_HIGH>;
++		vdd-supply = <&vreg_mcu_3v3>;
++
++		ledl_b1: led@1 {
++			reg = <1>;
++			label = "l:b1";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledl_g1: led@2 {
++			reg = <2>;
++			label = "l:g1";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledl_r1: led@3 {
++			reg = <3>;
++			label = "l:r1";
++			color = <LED_COLOR_ID_RED>;
++		};
++		ledl_b2: led@4 {
++			reg = <4>;
++			label = "l:b2";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledl_g2: led@5 {
++			reg = <5>;
++			label = "l:g2";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledl_r2: led@6 {
++			reg = <6>;
++			label = "l:r2";
++			color = <LED_COLOR_ID_RED>;
++		};
++		ledl_b3: led@7 {
++			reg = <7>;
++			label = "l:b3";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledl_g3: led@8 {
++			reg = <8>;
++			label = "l:g3";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledl_r3: led@9 {
++			reg = <9>;
++			label = "l:r3";
++			color = <LED_COLOR_ID_RED>;
++		};
++		ledl_b4: led@10 {
++			reg = <10>;
++			label = "l:b4";
++			color = <LED_COLOR_ID_BLUE>;
++		};
++		ledl_g4: led@11 {
++			reg = <11>;
++			label = "l:g4";
++			color = <LED_COLOR_ID_GREEN>;
++		};
++		ledl_r4: led@12 {
++			reg = <12>;
++			label = "l:r4";
++			color = <LED_COLOR_ID_RED>;
++		};
++	};
++};
++
++&i2c13 {
++	status = "okay";
++	clock-frequency = <400000>;
++
++	touchscreen@38 {
++		compatible = "focaltech,ft5452";
++		reg = <0x38>;
++
++		interrupt-parent = <&tlmm>;
++		interrupts = <39 IRQ_TYPE_EDGE_FALLING>;
++		reset-gpios = <&tlmm 38 GPIO_ACTIVE_LOW>;
++
++		vcc-supply = <&vreg_l13a_ts_3p0>;
++		iovcc-supply = <&vreg_l1c_1p8>;
++
++		pinctrl-0 = <&ts_int_active &ts_reset_active>;
++		pinctrl-1 = <&ts_int_suspend &ts_reset_suspend>;
++		pinctrl-names = "default", "sleep";
++
++		touchscreen-size-x = <960>;
++		touchscreen-size-y = <1280>;
++	};
++};
++
++&i2c15 {
++	status = "okay";
++
++	typec-mux@1c {
++		compatible = "onnn,nb7vpq904m";
++		reg = <0x1c>;
++
++	 	enable-gpios = <&tlmm 9 GPIO_ACTIVE_LOW>;
++
++		vcc-supply = <&vreg_s4a_1p8>;
++
++		retimer-switch;
++		orientation-switch;
++
++		ports {
++			#address-cells = <1>;
++			#size-cells = <0>;
++
++			port@0 {
++				reg = <0>;
++
++				redriver_usb_con_ss: endpoint {
++					remote-endpoint = <&pm8150b_typec_mux_in>;
++				};
++			};
++
++			port@1 {
++				reg = <1>;
++
++				redriver_phy_con_ss: endpoint {
++					remote-endpoint = <&usb_1_qmpphy_out>;
++					data-lanes = <0 1 2 3>;
++				};
++			};
++
++			port@2 {
++				reg = <2>;
++
++				redriver_usb_con_sbu: endpoint {
++					remote-endpoint = <&pm8150b_typec_sbu_out>;
++				};
++			};
++		};
++	};
++};
++
++&mdss {
++	status = "okay";
++};
++
++&mdss_dp {
++	status = "okay";
++};
++
++&mdss_dp_out {
++	data-lanes = <0 1>;
++	remote-endpoint = <&usb_1_qmpphy_dp_in>;
++};
++
++&mdss_dsi0 {
++	status = "okay";
++	vdda-supply = <&vreg_l9a_1p2>;
++
++	panel@0 {
++		reg = <0>;
++
++		reset-gpios = <&tlmm 75 GPIO_ACTIVE_HIGH>;
++
++		vdd1v2-supply = <&vreg_l3c_1p2>;
++		vddio-supply = <&vreg_l14a_1p8>;
++		vdd-supply = <&vreg_l11c_3p3>;
++		avdd-supply = <&vdda_panel>;
++
++		ports {
++			#address-cells = <1>;
++			#size-cells = <0>;
++
++			port@0 {
++				reg = <0>;
++
++				panel_in_0: endpoint {
++					remote-endpoint = <&mdss_dsi0_out>;
++				};
++			};
++		};
++	};
++};
++
++&mdss_dsi0_out {
++	data-lanes = <0 1 2 3>;
++	remote-endpoint = <&panel_in_0>;
++};
++
++&mdss_dsi0_phy {
++	status = "okay";
++	vdds-supply = <&vreg_l5a_0p88>;
++};
++
++&pcie0 {
++	status = "okay";
++};
++
++&pcie0_phy {
++	status = "okay";
++	vdda-phy-supply = <&vreg_l5a_0p88>;
++	vdda-pll-supply = <&vreg_l9a_1p2>;
++};
++
++&pcieport0 {
++	wifi@0 {
++		compatible = "pci17cb,1101";
++		reg = <0x10000 0x0 0x0 0x0 0x0>;
++
++		vddrfacmn-supply = <&vreg_pmu_rfa_cmn>;
++		vddaon-supply = <&vreg_pmu_aon_0p59>;
++		vddwlcx-supply = <&vreg_pmu_wlcx_0p8>;
++		vddwlmx-supply = <&vreg_pmu_wlmx_0p85>;
++		vddrfa0p8-supply = <&vreg_pmu_rfa_0p8>;
++		vddrfa1p2-supply = <&vreg_pmu_rfa_1p2>;
++		vddrfa1p7-supply = <&vreg_pmu_rfa_1p7>;
++		vddpcie0p9-supply = <&vreg_pmu_pcie_0p9>;
++		vddpcie1p8-supply = <&vreg_pmu_pcie_1p8>;
++	};
++};
++
++&pm8150_adc {
++	channel@4c {
++		reg = <ADC5_XO_THERM_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time = <200>;
++		label = "xo_therm";
++	};
++
++	channel@4e {
++		reg = <ADC5_AMUX_THM2_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time = <200>;
++		label = "wifi_therm";
++	};
++};
++
++&pm8150_adc_tm {
++	status = "okay";
++
++	xo-therm@0 {
++		reg = <0>;
++		io-channels = <&pm8150_adc ADC5_XO_THERM_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time-us = <200>;
++	};
++
++	wifi-therm@1 {
++		reg = <1>;
++		io-channels = <&pm8150_adc ADC5_AMUX_THM2_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time-us = <200>;
++	};
++};
++
++&pm8150b_adc {
++	channel@4f {
++		reg = <ADC5_AMUX_THM3_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time = <200>;
++		label = "conn_therm";
++	};
++};
++
++&pm8150b_adc_tm {
++	status = "okay";
++
++	conn-therm@0 {
++		reg = <0>;
++		io-channels = <&pm8150b_adc ADC5_AMUX_THM3_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time-us = <200>;
++	};
++};
++
++&pm8150b_charger {
++	monitored-battery = <&battery>;
++	status = "okay";
++};
++
++&pm8150b_fg {
++	status = "okay";
++	monitored-battery = <&battery>;
++	power-supplies = <&pm8150b_charger>;
++};
++
++&pm8150b_haptics {
++	status = "okay";
++	qcom,boost-gpios = <&pm8150b_gpios 5 GPIO_ACTIVE_HIGH>;
++	qcom,wave-play-rate-us = <5882>;
++	qcom,actuator-type = <HAP_TYPE_ERM>;
++};
++
++&pm8150b_typec {
++	status = "okay";
++
++	vdd-pdphy-supply = <&vreg_l2a_3p1>;
++
++	connector {
++		compatible = "usb-c-connector";
++
++		power-role = "dual";
++		data-role = "dual";
++		try-power-role = "sink";
++		self-powered;
++
++		source-pdos = <PDO_FIXED(5000, 3000,
++					 PDO_FIXED_DUAL_ROLE |
++					 PDO_FIXED_USB_COMM |
++					 PDO_FIXED_DATA_SWAP)>;
++
++		sink-pdos = <PDO_FIXED(5000, 3000,
++					 PDO_FIXED_DUAL_ROLE |
++					 PDO_FIXED_USB_COMM |
++					 PDO_FIXED_DATA_SWAP)>;
++
++		op-sink-microwatt = <15000000>;
++
++		altmodes {
++			displayport {
++				svid = /bits/ 16 <0xff01>;
++				vdo = <0x00001c46>;
++			};
++		};
++
++		ports {
++			#address-cells = <1>;
++			#size-cells = <0>;
++
++			port@0 {
++				reg = <0>;
++				pm8150b_hs_in: endpoint {
++					remote-endpoint = <&usb_1_dwc3_hs_out>;
++				};
++			};
++
++			port@1 {
++				reg = <1>;
++				pm8150b_typec_mux_in: endpoint {
++					remote-endpoint = <&redriver_usb_con_ss>;
++				};
++			};
++
++			port@2 {
++				reg = <2>;
++
++				pm8150b_typec_sbu_out: endpoint {
++					remote-endpoint = <&redriver_usb_con_sbu>;
++				};
++			};
++		};
++	};
++};
++
++&pm8150b_vbus {
++	regulator-min-microamp = <500000>;
++	regulator-max-microamp = <3000000>;
++	status = "okay";
++};
++
++&pm8150l_adc {
++	channel@4e {
++		reg = <ADC5_AMUX_THM2_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time = <200>;
++		label = "skin_msm_therm";
++	};
++
++	channel@4f {
++		reg = <ADC5_AMUX_THM3_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time = <200>;
++		label = "pm8150l_therm";
++	};
++};
++
++&pm8150l_adc_tm {
++	status = "okay";
++
++	skin-msm-therm@0 {
++		reg = <0>;
++		io-channels = <&pm8150l_adc ADC5_AMUX_THM2_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time-us = <200>;
++	};
++
++	pm8150l-therm@1 {
++		reg = <1>;
++		io-channels = <&pm8150l_adc ADC5_AMUX_THM3_100K_PU>;
++		qcom,ratiometric;
++		qcom,hw-settle-time-us = <200>;
++	};
++};
++
++&pm8150l_gpios {
++	fan_pwm_active: fan-pwm-active-state {
++		pins = "gpio6";
++		function = "func1";
++        bias-disable;
++        power-source = <0>;
++        output-low;
++        qcom,drive-strength = <3>;
++        drive-push-pull;
++	};
++};
++
++&pm8150l_lpg {
++	status = "okay";
++};
++
++&pon_pwrkey {
++	status = "okay";
++};
++
++&pon_resin {
++	status = "okay";
++
++	linux,code = <KEY_VOLUMEDOWN>;
++};
++
++&q6asmdai {
++	dai@0 {
++		reg = <0>;
++	};
++
++	dai@1 {
++		reg = <1>;
++	};
++
++	dai@2 {
++		reg = <2>;
++	};
++};
++
++&qupv3_id_0 {
++	status = "okay";
++};
++
++&qupv3_id_1 {
++	status = "okay";
++};
++
++&qupv3_id_2 {
++	status = "okay";
++};
++
++&qup_uart16_default {
++	drive-strength = <16>;
++	bias-pull-up;
++};
++
++&rxmacro {
++	status = "okay";
++};
++
++&sdhc_2 {
++	status = "okay";
++	pinctrl-names = "default";
++	pinctrl-0 = <&sdc2_default_state &sdc2_card_det_n>;
++	vmmc-supply = <&vreg_l9c_2p96>;
++	vqmmc-supply = <&vreg_l6c_2p96>;
++	cd-gpios = <&tlmm 77 GPIO_ACTIVE_LOW>;
++	bus-width = <4>;
++	no-sdio;
++	no-mmc;
++};
++
++&sound {
++	compatible = "qcom,sm8250-sndcard";
++	model = "RetroidPocket";
++	audio-routing =
++		"SpkrLeft IN", "WSA_SPK1 OUT",
++		"SpkrRight IN", "WSA_SPK2 OUT",
++		"IN1_HPHL", "HPHL_OUT",
++		"IN2_HPHR", "HPHR_OUT",	
++		"MM_DL1",  "MultiMedia1 Playback",
++		"MM_DL2",  "MultiMedia2 Playback",
++		"MultiMedia3 Capture", "MM_UL3";
++
++	mm1-dai-link {
++		link-name = "MultiMedia1";
++		cpu {
++			sound-dai = <&q6asmdai  MSM_FRONTEND_DAI_MULTIMEDIA1>;
++		};
++	};
++
++	mm2-dai-link {
++		link-name = "MultiMedia2";
++		cpu {
++			sound-dai = <&q6asmdai  MSM_FRONTEND_DAI_MULTIMEDIA2>;
++		};
++	};
++
++	mm3-dai-link {
++		link-name = "MultiMedia3";
++		cpu {
++			sound-dai = <&q6asmdai  MSM_FRONTEND_DAI_MULTIMEDIA3>;
++		};
++	};
++
++	wcd-playback-dai-link {
++		link-name = "WCD Playback";
++		cpu {
++			sound-dai = <&q6afedai RX_CODEC_DMA_RX_0>;
++		};
++		codec {
++			sound-dai = <&wcd938x 0>, <&swr1 0>, <&rxmacro 0>;
++		};
++		platform {
++			sound-dai = <&q6routing>;
++		};
++	};
++
++	wsa-dai-link {
++		link-name = "WSA Playback";
++		cpu {
++			sound-dai = <&q6afedai WSA_CODEC_DMA_RX_0>;
++		};
++
++		codec {
++			sound-dai = <&left_spkr>, <&right_spkr>, <&swr0 0>, <&wsamacro 0>;
++		};
++		platform {
++			sound-dai = <&q6routing>;
++		};
++	};
++
++	wcd-capture-dai-link {
++		link-name = "WCD Capture";
++		cpu {
++			sound-dai = <&q6afedai TX_CODEC_DMA_TX_3>;
++		};
++
++		codec {
++			sound-dai = <&wcd938x 1>, <&swr2 0>, <&txmacro 0>;
++		};
++		platform {
++			sound-dai = <&q6routing>;
++		};
++	};
++};
++
++&swr0 {
++	status = "okay";
++
++	left_spkr: speaker@0,1 {
++		compatible = "sdw10217201000";
++		reg = <0 1>;
++		powerdown-gpios = <&tlmm 129 GPIO_ACTIVE_LOW>;
++		#thermal-sensor-cells = <0>;
++		sound-name-prefix = "SpkrLeft";
++		#sound-dai-cells = <0>;
++	};
++
++	right_spkr: speaker@0,2 {
++		compatible = "sdw10217201000";
++		reg = <0 2>;
++		powerdown-gpios = <&tlmm 127 GPIO_ACTIVE_LOW>;
++		#thermal-sensor-cells = <0>;
++		sound-name-prefix = "SpkrRight";
++		#sound-dai-cells = <0>;
++	};
++};
++
++&swr1 {
++	status = "okay";
++
++	wcd_rx: wcd9385-rx@0,4 {
++		compatible = "sdw20217010d00";
++		reg = <0 4>;
++		qcom,rx-port-mapping = <1 2 3 4 5>;
++	};
++};
++
++&swr2 {
++	status = "okay";
++
++	wcd_tx: wcd9385-tx@0,3 {
++		compatible = "sdw20217010d00";
++		reg = <0 3>;
++		qcom,tx-port-mapping = <2 3 4 5>;
++	};
++};
++
++&tlmm {
++	bt_en_state: bt-default-state {
++		pins = "gpio21";
++		function = "gpio";
++		drive-strength = <16>;
++		output-low;
++		bias-pull-up;
++	};
++
++	mcu_boot_default: mcu-boot-default-state {
++		pins = "gpio110";
++		function = "gpio";
++		bias-pull-down;
++	};
++
++	mcu_en_default: mcu-en-default-state {
++		pins = "gpio111";
++		function = "gpio";
++		bias-pull-down;
++	};
++
++	mcu_rst_default: mcu-rst-default-state {
++		pins = "gpio109";
++		function = "gpio";
++		bias-pull-down;
++	};
++
++	sdc2_default_state: sdc2-default-state {
++		clk-pins {
++			pins = "sdc2_clk";
++			bias-disable;
++			drive-strength = <16>;
++		};
++
++		cmd-pins {
++			pins = "sdc2_cmd";
++			bias-pull-up;
++			drive-strength = <10>;
++		};
++
++		data-pins {
++			pins = "sdc2_data";
++			bias-pull-up;
++			drive-strength = <10>;
++		};
++	};
++
++	sdc2_card_det_n: sd-card-det-n-state {
++		pins = "gpio77";
++		function = "gpio";
++		bias-pull-up;
++	};
++
++	ts_int_active: ts-int-active-state {
++		pins = "gpio39";
++		function = "gpio";
++		drive-strength = <8>;
++		bias-pull-up;
++	};
++
++	ts_int_suspend: ts-int-suspend-state {
++		pins = "gpio39";
++		function = "gpio";
++		drive-strength = <2>;
++		bias-pull-down;
++	};
++
++	ts_reset_active: ts-reset-active-state {
++		pins = "gpio38";
++		function = "gpio";
++		drive-strength = <8>;
++		bias-pull-up;
++	};
++
++	ts_reset_suspend: ts-reset-suspend-state {
++		pins = "gpio38";
++		function = "gpio";
++		drive-strength = <2>;
++		bias-pull-down;
++	};
++
++	wcd_default: wcd-default-state {
++		reset-pins {
++			pins = "gpio32";
++			function = "gpio";
++			bias-disable;
++		};
++	};
++
++	wlan_en_state: wlan-default-state {
++		pins = "gpio20";
++		function = "gpio";
++		drive-strength = <16>;
++		output-low;
++		bias-pull-up;
++	};
++};
++
++&txmacro {
++	status = "okay";
++};
++
++&uart6 {
++	status = "okay";
++
++	bluetooth {
++		compatible = "qcom,qca6390-bt";
++
++		vddrfacmn-supply = <&vreg_pmu_rfa_cmn>;
++		vddaon-supply = <&vreg_pmu_aon_0p59>;
++		vddbtcmx-supply = <&vreg_pmu_btcmx_0p85>;
++		vddrfa0p8-supply = <&vreg_pmu_rfa_0p8>;
++		vddrfa1p2-supply = <&vreg_pmu_rfa_1p2>;
++		vddrfa1p7-supply = <&vreg_pmu_rfa_1p7>;
++	};
++};
++
++&uart12 {
++	status = "okay";
++};
++
++&uart16 {
++	status = "okay";
++
++	gamepad {
++		compatible = "ayn,odin2-gamepad";
++
++		gamepad-name = "Retroid Pocket Controller";
++		gamepad-bus = <0x0003>;
++		gamepad-vid = <0x2020>;
++		gamepad-pid = <0x3001>;
++		gamepad-rev = <0x0001>;
++
++		boot-gpios = <&tlmm 110 GPIO_ACTIVE_HIGH>;
++		enable-gpios = <&tlmm 111 GPIO_ACTIVE_HIGH>;
++		reset-gpios = <&tlmm 109 GPIO_ACTIVE_HIGH>;
++		pinctrl-0 = <&mcu_boot_default &mcu_en_default &mcu_rst_default>;
++		pinctrl-names = "default";
++	};
++};
++
++&ufs_mem_hc {
++	status = "okay";
++
++	vcc-supply = <&vreg_l17a_3p0>;
++	vcc-max-microamp = <800000>;
++	vccq-supply = <&vreg_l6a_1p2>;
++	vccq-max-microamp = <800000>;
++	vccq2-supply = <&vreg_s4a_1p8>;
++	vccq2-max-microamp = <800000>;
++};
++
++&ufs_mem_phy {
++	status = "okay";
++
++	vdda-phy-supply = <&vreg_l5a_0p88>;
++	vdda-pll-supply = <&vreg_l9a_1p2>;
++};
++
++&usb_1 {
++	status = "okay";
++};
++
++&usb_1_dwc3 {
++	dr_mode = "otg";
++	usb-role-switch;
++};
++
++&usb_1_dwc3_hs_out {
++	remote-endpoint = <&pm8150b_hs_in>;
++};
++
++&usb_1_hsphy {
++	status = "okay";
++
++	vdda-pll-supply = <&vreg_l5a_0p88>;
++	vdda33-supply = <&vreg_l2a_3p1>;
++	vdda18-supply = <&vreg_l12a_1p8>;
++};
++
++&usb_1_qmpphy {
++	status = "okay";
++
++	vdda-phy-supply = <&vreg_l9a_1p2>;
++	vdda-pll-supply = <&vreg_l18a_0p92>;
++};
++
++&usb_1_qmpphy_dp_in {
++	remote-endpoint = <&mdss_dp_out>;
++};
++
++&usb_1_qmpphy_out {
++	remote-endpoint = <&redriver_phy_con_ss>;
++};
++
++&venus {
++	status = "okay";
++};
++
++&wsamacro {
++	status = "okay";
++};
+diff --git a/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rp5.dts b/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rp5.dts
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rp5.dts
+@@ -0,0 +1,100 @@
++// SPDX-License-Identifier: BSD-3-Clause
++/*
++ * Copyright (c) 2024, Retroid Pocket.
++ */
++
++/dts-v1/;
++
++#include "sm8250-retroidpocket-common.dtsi"
++
++/ {
++	model = "Retroid Pocket 5";
++	compatible = "retroidpocket,rp5", "qcom,sm8250";
++
++	chosen {
++		#address-cells = <2>;
++		#size-cells = <2>;
++		ranges;
++
++		framebuffer: framebuffer@9c000000 {
++			compatible = "simple-framebuffer";
++			reg = <0x0 0x9c000000 0x0 0x2300000>;
++			width = <1080>;
++			height = <1920>;
++			stride = <(1080 * 4)>;
++			format = "a8r8g8b8";
++		};
++	};
++
++	multi-ledr1 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r1";
++		leds = <&ledr_r4>, <&ledr_g4>, <&ledr_b4>;
++	};
++
++	multi-ledl1 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l1";
++		leds = <&ledl_r4>, <&ledl_g4>, <&ledl_b4>;
++	};
++
++	multi-ledr2 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r2";
++		leds = <&ledr_r1>, <&ledr_g1>, <&ledr_b1>;
++	};
++
++	multi-ledl2 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l2";
++		leds = <&ledl_r1>, <&ledl_g1>, <&ledl_b1>;
++	};
++
++	multi-ledr3 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r3";
++		leds = <&ledr_r2>, <&ledr_g2>, <&ledr_b2>;
++	};
++
++	multi-ledl3 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l3";
++		leds = <&ledl_r2>, <&ledl_g2>, <&ledl_b2>;
++	};
++
++	multi-ledr4 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r4";
++		leds = <&ledr_r3>, <&ledr_g3>, <&ledr_b3>;
++	};
++
++	multi-ledl4 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l4";
++		leds = <&ledl_r3>, <&ledl_g3>, <&ledl_b3>;
++	};
++};
++
++&i2c13 {
++	touchscreen@38 {
++		touchscreen-size-x = <1080>;
++		touchscreen-size-y = <1920>;
++		touchscreen-inverted-x;
++		touchscreen-inverted-y;
++	};
++};
++
++&mdss_dsi0 {
++	panel@0 {
++		compatible = "ch13726a,rp5";
++		rotation = <270>;
++	};
++};
+diff --git a/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rpmini.dts b/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rpmini.dts
+new file mode 100644
+index 000000000000..111111111111
+--- /dev/null
++++ b/arch/arm64/boot/dts/qcom/sm8250-retroidpocket-rpmini.dts
+@@ -0,0 +1,98 @@
++// SPDX-License-Identifier: BSD-3-Clause
++/*
++ * Copyright (c) 2024, Retroid Pocket.
++ */
++
++/dts-v1/;
++
++#include "sm8250-retroidpocket-common.dtsi"
++
++/ {
++	model = "Retroid Pocket Mini";
++	compatible = "retroidpocket,rpmini", "qcom,sm8250";
++
++	chosen {
++		#address-cells = <2>;
++		#size-cells = <2>;
++		ranges;
++
++		framebuffer: framebuffer@9c000000 {
++			compatible = "simple-framebuffer";
++			reg = <0x0 0x9c000000 0x0 0x2300000>;
++			width = <960>;
++			height = <1280>;
++			stride = <(960 * 4)>;
++			format = "a8r8g8b8";
++		};
++	};
++
++	multi-ledr1 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r1";
++		leds = <&ledr_r1>, <&ledr_g1>, <&ledr_b1>;
++	};
++
++	multi-ledl1 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l1";
++		leds = <&ledl_r1>, <&ledl_g1>, <&ledl_b1>;
++	};
++
++	multi-ledr2 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r2";
++		leds = <&ledr_r2>, <&ledr_g2>, <&ledr_b2>;
++	};
++
++	multi-ledl2 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l2";
++		leds = <&ledl_r2>, <&ledl_g2>, <&ledl_b2>;
++	};
++
++	multi-ledr3 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r3";
++		leds = <&ledr_r3>, <&ledr_g3>, <&ledr_b3>;
++	};
++
++	multi-ledl3 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l3";
++		leds = <&ledl_r3>, <&ledl_g3>, <&ledl_b3>;
++	};
++
++	multi-ledr4 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "r4";
++		leds = <&ledr_r4>, <&ledr_g4>, <&ledr_b4>;
++	};
++
++	multi-ledl4 {
++		compatible = "leds-group-multicolor";
++		color = <LED_COLOR_ID_RGB>;
++		function = "l4";
++		leds = <&ledl_r4>, <&ledl_g4>, <&ledl_b4>;
++	};
++};
++
++&i2c13 {
++	touchscreen@38 {
++		touchscreen-size-x = <960>;
++		touchscreen-size-y = <1280>;
++	};
++};
++
++&mdss_dsi0 {
++	panel@0 {
++		compatible = "ch13726a,rpmini";
++		rotation = <90>;
++	};
++};
+-- 
+Armbian
+