diff --color -u -r -N a/drivers/platform/x86/x86-android-tablets/other.c b/drivers/platform/x86/x86-android-tablets/other.c
--- a/drivers/platform/x86/x86-android-tablets/other.c	2025-04-27 15:56:35.538630075 +0800
+++ b/drivers/platform/x86/x86-android-tablets/other.c	2025-04-27 16:02:29.437301184 +0800
@@ -918,12 +918,45 @@
 			.swnode = &ktd2026_node,
 		},
 		.adapter_path = "\\_SB_.PCI0.I2C3",
+	}, {
+		/* TFA9890A audio amplifier */
+		.board_info = {
+			.type = "tfa9890",
+			.addr = 0x34,
+			.dev_name = "tfa9890:00",
+		},
+		.adapter_path = "\\_SB_.PCI0.I2C2",
+	}, {
+		/* TFA9890A audio amplifier */
+		.board_info = {
+			.type = "tfa9890",
+			.addr = 0x37,
+			.dev_name = "tfa9890:01",
+		},
+		.adapter_path = "\\_SB_.PCI0.I2C2",
 	},
 };
 
+static struct gpiod_lookup_table xiaomi_mipad2_codec_rt5659_gpios = {
+	.dev_id = "i2c-10EC5659:01",
+	.table = {
+		/* INT33FF:00 gpio 81 */
+		GPIO_LOOKUP("INT33FF:00", 593 - 512, "ldo1-en", GPIO_ACTIVE_HIGH),
+		/* INT33FF:01 gpio 46 */
+		GPIO_LOOKUP("INT33FF:01", 656 - 610, "reset", GPIO_ACTIVE_HIGH),
+		{ }
+	},
+};
+
+static struct gpiod_lookup_table * const xiaomi_mipad2_gpios[] = {
+	&xiaomi_mipad2_codec_rt5659_gpios,
+	NULL
+};
+
 const struct x86_dev_info xiaomi_mipad2_info __initconst = {
 	.i2c_client_info = xiaomi_mipad2_i2c_clients,
 	.i2c_client_count = ARRAY_SIZE(xiaomi_mipad2_i2c_clients),
 	.init = xiaomi_mipad2_init,
 	.exit = xiaomi_mipad2_exit,
+	.gpiod_lookup_tables = xiaomi_mipad2_gpios,
 };
diff --color -u -r -N a/sound/soc/codecs/rt5659.c b/sound/soc/codecs/rt5659.c
--- a/sound/soc/codecs/rt5659.c	2025-04-27 15:56:35.707676732 +0800
+++ b/sound/soc/codecs/rt5659.c	2025-04-27 16:13:21.270019374 +0800
@@ -1135,7 +1135,7 @@
 
 static const DECLARE_TLV_DB_SCALE(hp_vol_tlv, -2325, 75, 0);
 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
-static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
+static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -13125, 75, 0);
 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
 static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
 static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
@@ -1329,9 +1329,19 @@
 static irqreturn_t rt5659_irq(int irq, void *data)
 {
 	struct rt5659_priv *rt5659 = data;
+	int entry_is_empty = list_empty(&rt5659->jack_detect_work.work.entry);
 
-	queue_delayed_work(system_power_efficient_wq,
-			   &rt5659->jack_detect_work, msecs_to_jiffies(250));
+ 	printk("rt5659 [%s]: jack_detect_work entry is empty: %s\n", __func__, entry_is_empty? "true":"false");
+ 	if (!entry_is_empty) {
+ 		printk("rt5659 [%s]: jack_detect_work func is %pS\n", __func__, rt5659->jack_detect_work.work.func);
+ 	}
+ 
+ 	if (rt5659->pdata.jd_src == RT5659_JD_NULL) {
+ 		printk("rt5659 [%s]: rt5659->pdata.jd_src = RT5659_JD_NULL, jack_detect_work not init.", __func__);
+ 	} else {
+		queue_delayed_work(system_power_efficient_wq,
+				&rt5659->jack_detect_work, msecs_to_jiffies(250));
+	}
 
 	return IRQ_HANDLED;
 }
diff --color -u -r -N a/sound/soc/codecs/tfa989x.c b/sound/soc/codecs/tfa989x.c
--- a/sound/soc/codecs/tfa989x.c	2025-04-27 15:56:35.708676729 +0800
+++ b/sound/soc/codecs/tfa989x.c	2025-04-27 18:46:08.550702704 +0800
@@ -84,6 +84,7 @@
 static const char * const chsa_text[] = { "Left", "Right", /* "DSP" */ };
 static SOC_ENUM_SINGLE_DECL(chsa_enum, TFA989X_I2SREG, TFA989X_I2SREG_CHSA, chsa_text);
 static const struct snd_kcontrol_new chsa_mux = SOC_DAPM_ENUM("Amp Input", chsa_enum);
+static const struct snd_kcontrol_new chsa_mux1 = SOC_DAPM_ENUM("Amp Input1", chsa_enum);
 
 static const struct snd_soc_dapm_widget tfa989x_dapm_widgets[] = {
 	SND_SOC_DAPM_OUTPUT("OUT"),
@@ -103,6 +104,25 @@
 	{"Amp Input", "Right", "AIFINR"},
 };
 
+// 第二芯片
+static const struct snd_soc_dapm_widget tfa9890_dapm_widgets[] = {
+	SND_SOC_DAPM_OUTPUT("OUT1"),
+	SND_SOC_DAPM_SUPPLY("POWER1", TFA989X_SYS_CTRL, TFA989X_SYS_CTRL_PWDN, 1, NULL, 0),
+	SND_SOC_DAPM_OUT_DRV("AMPE1", TFA989X_SYS_CTRL, TFA989X_SYS_CTRL_AMPE, 0, NULL, 0),
+
+	SND_SOC_DAPM_MUX("Amp Input1", SND_SOC_NOPM, 0, 0, &chsa_mux1),
+	SND_SOC_DAPM_AIF_IN("AIFINL", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
+	SND_SOC_DAPM_AIF_IN("AIFINR", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
+};
+
+static const struct snd_soc_dapm_route tfa9890_dapm_routes[] = {
+	{"OUT1", NULL, "AMPE1"},
+	{"AMPE1", NULL, "POWER1"},
+	{"AMPE1", NULL, "Amp Input1"},
+	{"Amp Input1", "Left", "AIFINL"},
+	{"Amp Input1", "Right", "AIFINR"},
+};
+
 static int tfa989x_put_mode(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 {
 	struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
@@ -139,6 +159,16 @@
 	.use_pmdown_time	= 1,
 	.endianness		= 1,
 };
+// 第二芯片
+static const struct snd_soc_component_driver tfa9890_component = {
+	.probe			= tfa989x_probe,
+	.dapm_widgets		= tfa9890_dapm_widgets,
+	.num_dapm_widgets	= ARRAY_SIZE(tfa9890_dapm_widgets),
+	.dapm_routes		= tfa9890_dapm_routes,
+	.num_dapm_routes	= ARRAY_SIZE(tfa9890_dapm_routes),
+	.use_pmdown_time	= 1,
+	.endianness		= 1,
+};
 
 static const unsigned int tfa989x_rates[] = {
 	8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000
@@ -171,8 +201,59 @@
 					     sr << TFA989X_I2SREG_I2SSR);
 }
 
+/*****************************************************************************/
+ /* Params masks */
+ #define TFA98XX_FORMAT_MASK		(0x7)
+ #define TFA98XX_FORMAT_LSB		(0x4)
+ #define TFA98XX_FORMAT_MSB		(0x2)
+ 
+ static int tfa989x_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
+ {
+ 	struct snd_soc_component *component = codec_dai->component;
+ 	//struct tfa989x *tfa989x = snd_soc_component_get_drvdata(component);
+ 	u16 val;
+ 
+ 	pr_debug("\n");
+    pr_info("tfa989x received fmt: %d\n",fmt);
+ 
+ 	/* set master/slave audio interface */
+ 	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+ 	case SND_SOC_DAIFMT_CBC_CFC:
+ 		/* default value */
+ 		break;
+ 	case SND_SOC_DAIFMT_CBP_CFP:
+ 	default:
+ 		/* only supports Slave mode */
+ 		pr_err("tfa989x: invalid DAI master/slave interface\n");
+ 		return -EINVAL;
+ 	}
+ 	val = snd_soc_component_read(component, TFA989X_I2SREG);
+ 	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+ 	case SND_SOC_DAIFMT_I2S:
+ 		/* default value */
+ 		break;
+ 	case SND_SOC_DAIFMT_RIGHT_J:
+ 		val &= ~(TFA98XX_FORMAT_MASK);
+ 		val |= TFA98XX_FORMAT_LSB;
+ 		break;
+ 	case SND_SOC_DAIFMT_LEFT_J:
+ 		val &= ~(TFA98XX_FORMAT_MASK);
+ 		val |= TFA98XX_FORMAT_MSB;
+ 		break;
+ 	default:
+ 		pr_err("tfa989x: invalid DAI interface format\n");
+ 		return -EINVAL;
+ 	}
+ 
+ 	snd_soc_component_write(component, TFA989X_I2SREG, val);
+ 
+ 	return 0;
+ }
+ /*****************************************************************************/
+
 static const struct snd_soc_dai_ops tfa989x_dai_ops = {
 	.hw_params = tfa989x_hw_params,
+	.set_fmt = tfa989x_set_dai_fmt,
 };
 
 static struct snd_soc_dai_driver tfa989x_dai = {
@@ -322,11 +403,19 @@
 	struct regmap *regmap;
 	unsigned int val;
 	int ret;
+	const char* name = dev_name(dev);
+	const char id = name[13];
+
+	dev_dbg(&i2c->dev, "tfa989x i2c addr is: %x \n", i2c->addr);
 
 	rev = device_get_match_data(dev);
 	if (!rev) {
-		dev_err(dev, "unknown device revision\n");
-		return -ENODEV;
+		if (strstr(name,"i2c-tfa9890")) {
+			rev = &tfa9890_rev;
+		} else {
+			dev_err(dev, "unknown device revision\n");
+			return -ENODEV;
+		}
 	}
 
 	tfa989x = devm_kzalloc(dev, sizeof(*tfa989x), GFP_KERNEL);
@@ -399,6 +488,12 @@
 	}
 	regcache_cache_bypass(regmap, false);
 
+	if (id == '1') {
+		pr_info("tfa989x --> Right\n");
+		return devm_snd_soc_register_component(dev, &tfa9890_component,
+	 				       					&tfa989x_dai, 1);
+	}
+	pr_info("tfa989x --> Left\n");
 	return devm_snd_soc_register_component(dev, &tfa989x_component,
 					       &tfa989x_dai, 1);
 }
@@ -411,12 +506,21 @@
 };
 MODULE_DEVICE_TABLE(of, tfa989x_of_match);
 
+static const struct i2c_device_id tfa989x_i2c_id[] = {
+	{.name = "tfa989x", 0},
+	{.name = "tfa9890", 0},
+	{.name = "i2c-tfa9890", 0},
+	{}
+};
+MODULE_DEVICE_TABLE(i2c, tfa989x_i2c_id);
+
 static struct i2c_driver tfa989x_i2c_driver = {
 	.driver = {
 		.name = "tfa989x",
 		.of_match_table = tfa989x_of_match,
 	},
 	.probe = tfa989x_i2c_probe,
+	.id_table = tfa989x_i2c_id,
 };
 module_i2c_driver(tfa989x_i2c_driver);
 
diff --color -u -r -N a/sound/soc/intel/boards/cht_bsw_rt5659.c b/sound/soc/intel/boards/cht_bsw_rt5659.c
--- a/sound/soc/intel/boards/cht_bsw_rt5659.c	1970-01-01 08:00:00.000000000 +0800
+++ b/sound/soc/intel/boards/cht_bsw_rt5659.c	2025-04-27 18:54:32.827896647 +0800
@@ -0,0 +1,776 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ *  cht_bsw_rt5659.c - ASoc Machine driver for Intel Cherryview-based platforms
+ *                     Cherrytrail and Braswell, with RT5659 codec.
+ *
+ *  Copyright (C) 2014 Intel Corp
+ *  Author: Subhransu S. Prusty <subhransu.s.prusty@intel.com>
+ *          Mengdong Lin <mengdong.lin@intel.com>
+ */
+
+ #include <linux/gpio/consumer.h>
+ #include <linux/input.h>
+ #include <linux/module.h>
+ #include <linux/platform_device.h>
+ #include <linux/slab.h>
+ #include <linux/clk.h>
+ #include <sound/pcm.h>
+ #include <sound/pcm_params.h>
+ #include <sound/soc.h>
+ #include <sound/jack.h>
+ #include <sound/soc-acpi.h>
+ #include <asm/platform_sst_audio.h>
+ #include "../../codecs/rt5659.h"
+ #include "../atom/sst-atom-controls.h"
+ #include "../common/soc-intel-quirks.h"
+ 
+ 
+ /* The platform clock #3 outputs 19.2Mhz clock to codec as I2S MCLK */
+ #define CHT_PLAT_CLK_3_HZ	19200000
+ #define CHT_CODEC_DAI	"rt5659-aif1"
+ #define CHT_CODEC_DAI2	"rt5659-aif2"
+ #define CHT_CODEC_DAI3	"rt5659-aif3"
+ 
+ struct cht_mc_private {
+     struct snd_soc_jack headset;
+     char codec_name[SND_ACPI_I2C_ID_LEN];
+     struct clk *mclk;
+     bool use_ssp0;
+ };
+ 
+ /* Headset jack detection DAPM pins */
+ static struct snd_soc_jack_pin cht_bsw_headset_pins[] = {
+     {
+         .pin = "Headset Mic",
+         .mask = SND_JACK_MICROPHONE,
+     },
+     {
+         .pin = "Headphone",
+         .mask = SND_JACK_HEADPHONE,
+     },
+ };
+ 
+ static int platform_clock_control(struct snd_soc_dapm_widget *w,
+         struct snd_kcontrol *k, int  event)
+ {
+     struct snd_soc_dapm_context *dapm = w->dapm;
+     struct snd_soc_card *card = dapm->card;
+     struct snd_soc_dai *codec_dai;
+     struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
+     int ret;
+ 
+     codec_dai = snd_soc_card_get_codec_dai(card, CHT_CODEC_DAI);
+     if (!codec_dai) {
+         dev_err(card->dev, "Codec dai not found; Unable to set platform clock\n");
+         return -EIO;
+     }
+ 
+     if (SND_SOC_DAPM_EVENT_ON(event)) {
+         if (ctx->mclk) {
+             ret = clk_prepare_enable(ctx->mclk);
+             if (ret < 0) {
+                 dev_err(card->dev,
+                     "could not configure MCLK state");
+                 return ret;
+             }
+         }
+ 
+         /* set codec PLL source to the 19.2MHz platform clock (MCLK) */
+         ret = snd_soc_dai_set_pll(codec_dai, 0, RT5659_PLL1_S_MCLK,
+                 CHT_PLAT_CLK_3_HZ, 48000 * 512);
+         if (ret < 0) {
+             dev_err(card->dev, "can't set codec pll: %d\n", ret);
+             return ret;
+         }
+ 
+         /* set codec sysclk source to PLL */
+         ret = snd_soc_dai_set_sysclk(codec_dai, RT5659_SCLK_S_PLL1,
+             48000 * 512, SND_SOC_CLOCK_IN);
+         if (ret < 0) {
+             dev_err(card->dev, "can't set codec sysclk: %d\n", ret);
+             return ret;
+         }
+     } else {
+         /* Set codec sysclk source to its internal clock because codec
+          * PLL will be off when idle and MCLK will also be off by ACPI
+          * when codec is runtime suspended. Codec needs clock for jack
+          * detection and button press.
+          */
+         ret = snd_soc_dai_set_sysclk(codec_dai, RT5659_SCLK_S_RCCLK,
+                          48000 * 512, SND_SOC_CLOCK_IN);
+         if (ret < 0) {
+             dev_err(card->dev, "failed to set codec sysclk: %d\n", ret);
+             return ret;
+         }
+ 
+         if (ctx->mclk)
+             clk_disable_unprepare(ctx->mclk);
+     }
+     return 0;
+ }
+ 
+ static const struct snd_soc_dapm_widget cht_dapm_widgets[] = {
+     SND_SOC_DAPM_HP("Headphone", NULL),
+     SND_SOC_DAPM_MIC("Headset Mic", NULL),
+     SND_SOC_DAPM_MIC("Int Mic", NULL),
+     SND_SOC_DAPM_SPK("Ext Spk", NULL),
+     SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
+             platform_clock_control, SND_SOC_DAPM_PRE_PMU |
+             SND_SOC_DAPM_POST_PMD),
+ };
+ 
+ static const struct snd_soc_dapm_route cht_audio_map[] = {
+     {"IN1P", NULL, "Headset Mic"},
+     {"IN1N", NULL, "Headset Mic"},
+     {"IN3P", NULL, "Int Mic"},
+     {"IN3N", NULL, "Int Mic"},
+     {"IN4P", NULL, "Int Mic"},
+     {"IN4N", NULL, "Int Mic"},
+     {"Int Mic", NULL, "MICBIAS2"},
+     {"Int Mic", NULL, "MICBIAS3"},
+     {"Headphone", NULL, "HPOL"},
+     {"Headphone", NULL, "HPOR"},
+     {"Ext Spk", NULL, "SPOL"},
+     {"Ext Spk", NULL, "SPOR"},
+ };
+ 
+ static const struct snd_soc_dapm_route cht_audio_ssp0_map[] = {
+     {"AIF1 Playback", NULL, "ssp0 Tx"},
+     {"ssp0 Tx", NULL, "modem_out"},
+     {"modem_in", NULL, "ssp0 Rx"},
+     {"ssp0 Rx", NULL, "AIF1 Capture"},
+ };
+ 
+ static const struct snd_soc_dapm_route cht_audio_ssp2_map[] = {
+     {"AIF1 Playback", NULL, "ssp2 Tx"},
+     {"ssp2 Tx", NULL, "codec_out0"},
+     {"ssp2 Tx", NULL, "codec_out1"},
+     {"codec_in0", NULL, "ssp2 Rx"},
+     {"codec_in1", NULL, "ssp2 Rx"},
+     {"ssp2 Rx", NULL, "AIF1 Capture"},
+     {"AIF1 Playback", NULL, "Platform Clock"},
+     {"AIF1 Capture", NULL, "Platform Clock"},
+ };
+ 
+ static const struct snd_kcontrol_new cht_mc_controls[] = {
+     SOC_DAPM_PIN_SWITCH("Headphone"),
+     SOC_DAPM_PIN_SWITCH("Headset Mic"),
+     SOC_DAPM_PIN_SWITCH("Int Mic"),
+     SOC_DAPM_PIN_SWITCH("Ext Spk"),
+ };
+ 
+ static int cht_aif1_hw_params(struct snd_pcm_substream *substream,
+                     struct snd_pcm_hw_params *params)
+ {
+     struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
+     struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
+     unsigned int fmt;
+     int ret;
+ //////////////////////////////////////////////////////////////////
+     pr_debug("Enter:%s, codec_dai name: %s\n", __func__,codec_dai->name);
+ 
+     /* proceed only if dai is valid */
+     if (strncmp(codec_dai->name, "rt5659-aif1", 11))
+         return 0;
+ 
+     /* TDM 4 slot 24 bit set the Rx and Tx bitmask to
+      * 4 active slots as 0xF
+      */
+     ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0xF, 4,
+             SNDRV_PCM_FORMAT_GSM);
+     if (ret < 0) {
+         pr_err("can't set codec TDM slot %d\n", ret);
+         return ret;
+     }
+ 
+     /* TDM slave Mode */
+     fmt =   SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_IB_NF
+         | SND_SOC_DAIFMT_CBC_CFC;
+ 
+     /* Set codec DAI configuration */
+     ret = snd_soc_dai_set_fmt(codec_dai, fmt);
+     if (ret < 0) {
+         pr_err("can't set codec DAI configuration %d\n", ret);
+         return ret;
+     }
+ ////////////////////////////////////////////////////////////////////
+ 
+     /* set codec PLL source to the 19.2MHz platform clock (MCLK) */
+     ret = snd_soc_dai_set_pll(codec_dai, 0, RT5659_PLL1_S_MCLK,
+                   CHT_PLAT_CLK_3_HZ, params_rate(params) * 512);
+     if (ret < 0) {
+         dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
+         return ret;
+     }
+ 
+     /* set codec sysclk source to PLL */
+     ret = snd_soc_dai_set_sysclk(codec_dai, RT5659_SCLK_S_PLL1,
+                      params_rate(params) * 512,
+                      SND_SOC_CLOCK_IN);
+     if (ret < 0) {
+         dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
+         return ret;
+     }
+     return 0;
+ }
+ 
+ static const struct acpi_gpio_params headset_gpios = { 0, 0, false };
+ 
+ static const struct acpi_gpio_mapping cht_rt5659_gpios[] = {
+     { "headset-gpios", &headset_gpios, 1 },
+     {},
+ };
+ /*
+ static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
+ {
+     int ret;
+     struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(runtime, 0);
+     struct snd_soc_component *component = codec_dai->component;
+     struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
+ 
+     if (devm_acpi_dev_add_driver_gpios(component->dev, cht_rt5659_gpios))
+         dev_warn(runtime->dev, "Unable to add GPIO mapping table\n");
+ 
+     // Select codec ASRC clock source to track I2S1 clock, because codec
+     // is in slave mode and 100fs I2S format (BCLK = 100 * LRCLK) cannot
+     // be supported by RT5672. Otherwise, ASRC will be disabled and cause
+     // noise.
+ 
+     rt5659_sel_asrc_clk_src(component,
+                 RT5659_DA_STEREO_FILTER
+                 | RT5659_DA_MONO_L_FILTER
+                 | RT5659_DA_MONO_R_FILTER
+                 | RT5659_AD_STEREO_FILTER
+                 | RT5659_AD_MONO_L_FILTER
+                 | RT5659_AD_MONO_R_FILTER,
+                 RT5659_CLK_SEL_I2S1_ASRC);
+ 
+     if (ctx->use_ssp0) {
+         ret = snd_soc_dapm_add_routes(&runtime->card->dapm,
+                           cht_audio_ssp0_map,
+                           ARRAY_SIZE(cht_audio_ssp0_map));
+     } else {
+         ret = snd_soc_dapm_add_routes(&runtime->card->dapm,
+                           cht_audio_ssp2_map,
+                           ARRAY_SIZE(cht_audio_ssp2_map));
+     }
+     if (ret)
+         return ret;
+ 
+     ret = snd_soc_card_jack_new_pins(runtime->card, "Headset",
+                      SND_JACK_HEADSET | SND_JACK_BTN_0 |
+                      SND_JACK_BTN_1 | SND_JACK_BTN_2,
+                      &ctx->headset,
+                      cht_bsw_headset_pins,
+                      ARRAY_SIZE(cht_bsw_headset_pins));
+         if (ret)
+                 return ret;
+ 
+     snd_jack_set_key(ctx->headset.jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
+     snd_jack_set_key(ctx->headset.jack, SND_JACK_BTN_1, KEY_VOLUMEUP);
+     snd_jack_set_key(ctx->headset.jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN);
+ 
+     rt5659_set_jack_detect(component, &ctx->headset);
+     if (ctx->mclk) {
+         // The firmware might enable the clock at
+         // boot (this information may or may not
+         // be reflected in the enable clock register).
+         // To change the rate we must disable the clock
+         // first to cover these cases. Due to common
+         // clock framework restrictions that do not allow
+         // to disable a clock that has not been enabled,
+         // we need to enable the clock first.
+         ret = clk_prepare_enable(ctx->mclk);
+         if (!ret)
+             clk_disable_unprepare(ctx->mclk);
+ 
+         ret = clk_set_rate(ctx->mclk, CHT_PLAT_CLK_3_HZ);
+ 
+         if (ret) {
+             dev_err(runtime->dev, "unable to set MCLK rate\n");
+             return ret;
+         }
+     }
+     return 0;
+ }
+ */
+ static int cht_audio_init(struct snd_soc_pcm_runtime *runtime)
+ {
+     struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(runtime, 0);
+     struct snd_soc_component *component = codec_dai->component;
+     struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
+     int ret;
+     struct snd_soc_card *card = runtime->card;
+ 
+     if (ctx->use_ssp0) {
+         ret = snd_soc_dapm_add_routes(&runtime->card->dapm,
+                           cht_audio_ssp0_map,
+                           ARRAY_SIZE(cht_audio_ssp0_map));
+         pr_debug("%s add cht_audio_ssp0_map got ret %d \n", __func__,ret);
+     } else {
+         ret = snd_soc_dapm_add_routes(&runtime->card->dapm,
+                           cht_audio_ssp2_map,
+                           ARRAY_SIZE(cht_audio_ssp2_map));
+         pr_debug("%s add cht_audio_ssp2_map got ret %d \n", __func__,ret);
+     }
+ 
+     int codec_gpio;
+     int pol = 0, val = 0;
+     struct gpio_desc *desc;
+ 
+     pr_debug("Enter:%s", __func__);
+ 
+     /* Set codec bias level */
+     card->dapm.bias_level = SND_SOC_BIAS_OFF;
+     card->dapm.idle_bias_off = true;
+ 
+     desc = devm_gpiod_get_index(component->dev, NULL, 0, 0);
+     if (!IS_ERR(desc)) {
+         codec_gpio = desc_to_gpio(desc);
+         devm_gpiod_put(component->dev, desc);
+         pr_debug("%s: GPIOs - JD/BP-int: %d (pol = %d, val = %d)\n",
+                 __func__, codec_gpio, pol, val);
+ 
+     } else {
+         codec_gpio = -1;
+         pr_err("%s: GPIOs - JD/BP-int: Not present!\n", __func__);
+     }
+ 
+ /*
+     hs_gpio.gpio = codec_gpio;
+ 
+     ctx->intr_debounce = CHT_INTR_DEBOUNCE;
+     ctx->hs_insert_det_delay = CHT_HS_INSERT_DET_DELAY;
+     ctx->hs_remove_det_delay = CHT_HS_REMOVE_DET_DELAY;
+     ctx->button_det_delay = CHT_BUTTON_DET_DELAY;
+     ctx->hs_det_poll_intrvl = CHT_HS_DET_POLL_INTRVL;
+     ctx->hs_det_retry = CHT_HS_DET_RETRY_COUNT;
+     ctx->button_en_delay = CHT_BUTTON_EN_DELAY;
+     ctx->process_button_events = false;
+     //wake_lock_init(&ctx->jack_wake_lock, WAKE_LOCK_SUSPEND, "jack_wakelock");
+ 
+     INIT_DELAYED_WORK(&ctx->hs_insert_work, cht_check_hs_insert_status);
+     INIT_DELAYED_WORK(&ctx->hs_remove_work, cht_check_hs_remove_status);
+     INIT_DELAYED_WORK(&ctx->hs_button_work, cht_check_hs_button_status);
+     INIT_DELAYED_WORK(&ctx->hs_button_en_work, cht_enable_hs_button_events);
+ 
+     mutex_init(&ctx->jack_mlock);
+ 
+     ret = snd_soc_jack_new(codec, "Intel MID Audio Jack",
+                    SND_JACK_HEADSET | SND_JACK_HEADPHONE | SND_JACK_BTN_0 |
+                    SND_JACK_BTN_1 | SND_JACK_BTN_2, &ctx->jack);
+     if (ret) {
+         pr_err("jack creation failed\n");
+         return ret;
+     }
+ 
+     snd_jack_set_key(ctx->jack.jack, SND_JACK_BTN_0, KEY_MEDIA);
+     snd_jack_set_key(ctx->jack.jack, SND_JACK_BTN_1, BTN_1);
+     snd_jack_set_key(ctx->jack.jack, SND_JACK_BTN_2, BTN_2);
+ 
+     ret = snd_soc_jack_add_gpios(&ctx->jack, 1, &hs_gpio);
+     if (ret) {
+         pr_err("adding jack GPIO failed\n");
+         return ret;
+     }
+ */
+     /* Keep the voice call paths active during
+      * suspend. Mark the end points ignore_suspend
+      */
+     /*TODO: CHECK this */
+     snd_soc_dapm_ignore_suspend(&component->dapm, "HPOL");
+     snd_soc_dapm_ignore_suspend(&component->dapm, "HPOR");
+ 
+     snd_soc_dapm_ignore_suspend(&component->dapm, "SPOL");
+     snd_soc_dapm_ignore_suspend(&component->dapm, "SPOR");
+ 
+     snd_soc_dapm_enable_pin(&card->dapm, "Headset Mic");
+     snd_soc_dapm_enable_pin(&card->dapm, "Headphone");
+     snd_soc_dapm_enable_pin(&card->dapm, "Ext Spk");
+     snd_soc_dapm_enable_pin(&card->dapm, "Int Mic");
+ 
+     snd_soc_dapm_sync(&card->dapm);
+     return ret;
+ }
+ 
+ static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd,
+                 struct snd_pcm_hw_params *params)
+ {
+     struct cht_mc_private *ctx = snd_soc_card_get_drvdata(rtd->card);
+     struct snd_interval *rate = hw_param_interval(params,
+             SNDRV_PCM_HW_PARAM_RATE);
+     struct snd_interval *channels = hw_param_interval(params,
+                         SNDRV_PCM_HW_PARAM_CHANNELS);
+     // int ret, bits;
+ 
+     pr_debug("Invoked %s for dailink %s\n", __func__, rtd->dai_link->name);
+ 
+     /* The DSP will covert the FE rate to 48k, stereo, 24bits */
+     rate->min = rate->max = 48000;
+     channels->min = channels->max = 4;
+ 
+     if (ctx->use_ssp0) {
+         // set SSP0 to 16-bit
+         params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
+         // bits = 16;
+     } else {
+         // set SSP2 to 24-bit
+         params_set_format(params, SNDRV_PCM_FORMAT_S24_LE);
+         // bits = 24;
+     }
+ 
+     /*
+      * The default mode for the cpu-dai is TDM 4 slot. The default mode
+      * for the codec-dai is I2S. So we need to either set the cpu-dai to
+      * I2S mode to match the codec-dai, or set the codec-dai to TDM 4 slot
+      * (or program both to yet another mode).
+      * One board, the Lenovo Miix 2 10, uses not 1 but 2 codecs connected
+      * to SSP2. The second piggy-backed, output-only codec is inside the
+      * keyboard-dock (which has extra speakers). Unlike the main rt5672
+      * codec, we cannot configure this codec, it is hard coded to use
+      * 2 channel 24 bit I2S. For this to work we must use I2S mode on this
+      * board. Since we only support 2 channels anyways, there is no need
+      * for TDM on any cht-bsw-rt5659 designs. So we use I2S 2ch everywhere.
+      */
+      /*
+     ret = snd_soc_dai_set_fmt(snd_soc_rtd_to_cpu(rtd, 0),
+                   SND_SOC_DAIFMT_I2S     |
+                   SND_SOC_DAIFMT_NB_NF   |
+                   SND_SOC_DAIFMT_BP_FP);
+     if (ret < 0) {
+         dev_err(rtd->dev, "can't set format to I2S, err %d\n", ret);
+         return ret;
+     }
+ 
+     ret = snd_soc_dai_set_tdm_slot(snd_soc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, bits);
+     if (ret < 0) {
+         dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
+         return ret;
+     }
+     */
+     return 0;
+ }
+ 
+ static int cht_aif1_startup(struct snd_pcm_substream *substream)
+ {
+     struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
+     struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
+     struct snd_soc_dapm_widget_list *list_1;
+     struct snd_soc_dapm_widget *widget;
+     int stream = 0;
+     int paths, i;
+ 
+     pr_info("%s runtime=%p\n", __func__, substream->runtime);
+ 
+     paths = snd_soc_dapm_dai_get_connected_widgets(cpu_dai, stream, &list_1, NULL);
+     pr_info("%d paths got\n", paths);
+ 
+     for_each_dapm_widgets(list_1, i, widget) {
+         pr_info("rt5659 path widget: name=%s, sname=%s\n", widget->name,widget->sname);
+     }
+ 
+     return snd_pcm_hw_constraint_single(substream->runtime,
+             SNDRV_PCM_HW_PARAM_RATE, 48000);
+ }
+ 
+ static const struct snd_soc_ops cht_aif1_ops = {
+     .startup = cht_aif1_startup,
+ };
+ 
+ static const struct snd_soc_ops cht_be_ssp2_ops = {
+     .hw_params = cht_aif1_hw_params,
+ };
+ 
+ SND_SOC_DAILINK_DEF(dummy,
+     DAILINK_COMP_ARRAY(COMP_DUMMY()));
+ 
+ SND_SOC_DAILINK_DEF(media,
+     DAILINK_COMP_ARRAY(COMP_CPU("media-cpu-dai")));
+ 
+ SND_SOC_DAILINK_DEF(deepbuffer,
+     DAILINK_COMP_ARRAY(COMP_CPU("deepbuffer-cpu-dai")));
+ 
+ SND_SOC_DAILINK_DEF(ssp2_port,
+     DAILINK_COMP_ARRAY(COMP_CPU("ssp2-port")));
+ SND_SOC_DAILINK_DEF(ssp2_codec,
+     DAILINK_COMP_ARRAY(COMP_CODEC("i2c-10EC5659:00",
+                       "rt5659-aif1")));
+ 
+ SND_SOC_DAILINK_DEF(platform,
+     DAILINK_COMP_ARRAY(COMP_PLATFORM("sst-mfld-platform")));
+ 
+ SND_SOC_DAILINK_DEF(rt5659_aif2_cpu,
+     DAILINK_COMP_ARRAY(COMP_CPU("rt5659-aif2")));
+ 
+ SND_SOC_DAILINK_DEF(spk_l_codec,
+     DAILINK_COMP_ARRAY(COMP_CODEC("i2c-tfa9890:00",
+                       "tfa989x-hifi")));
+ 
+ SND_SOC_DAILINK_DEF(spk_r_codec,
+     DAILINK_COMP_ARRAY(COMP_CODEC("i2c-tfa9890:01",
+                       "tfa989x-hifi")));
+ 
+ static const struct snd_soc_pcm_stream nxp_tfa989x_params[] = {
+     {
+     .formats = SNDRV_PCM_FMTBIT_S16_LE,
+     .rate_min = 48000,
+     .rate_max = 48000,
+     .channels_min = 2,
+     .channels_max = 2,
+     .rates = SNDRV_PCM_RATE_48000,
+     .sig_bits = 16,
+     },
+ };
+ 
+ static struct snd_soc_dai_link cht_dailink[] = {
+     /* Front End DAI links */
+     [MERR_DPCM_AUDIO] = {
+         .name = "Audio Port",
+         .stream_name = "Audio",
+         .nonatomic = true,
+         .dynamic = 1,
+         .ops = &cht_aif1_ops,
+         SND_SOC_DAILINK_REG(media, dummy, platform),
+     },
+     [MERR_DPCM_DEEP_BUFFER] = {
+         .name = "Deep-Buffer Audio Port",
+         .stream_name = "Deep-Buffer Audio",
+         .nonatomic = true,
+         .dynamic = 1,
+         .playback_only = 1,
+         .ops = &cht_aif1_ops,
+         SND_SOC_DAILINK_REG(deepbuffer, dummy, platform),
+     },
+ 
+     /* Back End DAI links */
+     {
+         /* SSP2 - Codec */
+         .name = "SSP2-Codec",
+         .id = 0,
+         .no_pcm = 1,
+         //.init = cht_codec_init,
+         .init = cht_audio_init,
+         .be_hw_params_fixup = cht_codec_fixup,
+         .ops = &cht_be_ssp2_ops,
+         SND_SOC_DAILINK_REG(ssp2_port, ssp2_codec, platform),
+         .ignore_suspend = 1,
+         .ignore_pmdown_time = 1,
+     },
+     {
+         .name = "rt5659_AIF2-TFA989x_Speaker_L",
+         .stream_name = "aif2-spk_l",
+         SND_SOC_DAILINK_REG(rt5659_aif2_cpu, spk_l_codec),
+         .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+             SND_SOC_DAIFMT_CBC_CFC,
+         .c2c_params = nxp_tfa989x_params,
+         .num_c2c_params = 1,
+     },{
+         .name = "rt5659_AIF2-TFA989x_Speaker_R",
+         .stream_name = "aif2-spk_r",
+         SND_SOC_DAILINK_REG(rt5659_aif2_cpu, spk_r_codec),
+         .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
+             SND_SOC_DAIFMT_CBC_CFC,
+         .c2c_params = nxp_tfa989x_params,
+         .num_c2c_params = 1,
+     },
+ };
+ 
+ static int cht_suspend_pre(struct snd_soc_card *card)
+ {
+     struct snd_soc_component *component;
+     struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
+ 
+     for_each_card_components(card, component) {
+         if (!strncmp(component->name,
+                  ctx->codec_name, sizeof(ctx->codec_name))) {
+ 
+             dev_dbg(component->dev, "disabling jack detect before going to suspend.\n");
+             //rt5659_jack_suspend(component);
+             break;
+         }
+     }
+     return 0;
+ }
+ 
+ static int cht_resume_post(struct snd_soc_card *card)
+ {
+     struct snd_soc_component *component;
+     struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
+ 
+     for_each_card_components(card, component) {
+         if (!strncmp(component->name,
+                  ctx->codec_name, sizeof(ctx->codec_name))) {
+ 
+             dev_dbg(component->dev, "enabling jack detect for resume.\n");
+             //rt5659_jack_resume(component);
+             break;
+         }
+     }
+ 
+     return 0;
+ }
+ 
+ /* use space before codec name to simplify card ID, and simplify driver name */
+ #define SOF_CARD_NAME "bytcht rt5659" /* card name will be 'sof-bytcht rt5659' */
+ #define SOF_DRIVER_NAME "SOF"
+ 
+ #define CARD_NAME "cht-bsw-rt5659"
+ #define DRIVER_NAME NULL /* card name will be used for driver name */
+ 
+ /* SoC card */
+ static struct snd_soc_card snd_soc_card_cht = {
+     .owner = THIS_MODULE,
+     .dai_link = cht_dailink,
+     .num_links = ARRAY_SIZE(cht_dailink),
+     .dapm_widgets = cht_dapm_widgets,
+     .num_dapm_widgets = ARRAY_SIZE(cht_dapm_widgets),
+     .dapm_routes = cht_audio_map,
+     .num_dapm_routes = ARRAY_SIZE(cht_audio_map),
+     .controls = cht_mc_controls,
+     .num_controls = ARRAY_SIZE(cht_mc_controls),
+     .suspend_pre = cht_suspend_pre,
+     .resume_post = cht_resume_post,
+ };
+ 
+ #define RT5659_I2C_DEFAULT	"i2c-10EC5659:00"
+ 
+ static int snd_cht_mc_probe(struct platform_device *pdev)
+ {
+     int ret_val = 0;
+     struct cht_mc_private *drv;
+     struct snd_soc_acpi_mach *mach = pdev->dev.platform_data;
+     struct sst_platform_info *pdata;
+     const char *platform_name;
+     struct acpi_device *adev;
+     bool sof_parent;
+     int dai_index = 0;
+     int i;
+ 
+     pr_info("cht-bsw-rt5659 mach pdev name %s\n", pdev->name);
+ 
+     pr_info("cht-bsw-rt5659 mach id %s\n", mach->id);
+     pr_info("cht-bsw-rt5659 mach drv_name %s\n", mach->drv_name);
+     pr_info("cht-bsw-rt5659 mach fw_filename %s\n", mach->fw_filename);
+ 
+     dev_dbg(&pdev->dev, "cht-bsw-rt5659 mach test 0\n");
+ 
+     drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
+     if (!drv)
+         return -ENOMEM;
+ 
+     strcpy(drv->codec_name, RT5659_I2C_DEFAULT);
+ 
+     /* find index of codec dai */
+     for (i = 0; i < ARRAY_SIZE(cht_dailink); i++) {
+         if (cht_dailink[i].codecs->name &&
+             !strcmp(cht_dailink[i].codecs->name, RT5659_I2C_DEFAULT)) {
+             dai_index = i;
+             break;
+         }
+     }
+     if(i == ARRAY_SIZE(cht_dailink)){
+         pr_info("cht-bsw-rt5659 default codec name %s not found\n", drv->codec_name);
+     }
+     else{
+         pr_info("cht-bsw-rt5659 index %d dai codec name %s\n", dai_index, cht_dailink[dai_index].codecs->name);
+ 
+         /* fixup codec name based on HID */
+         adev = acpi_dev_get_first_match_dev(mach->id, NULL, -1);
+         if (adev) {
+             snprintf(drv->codec_name, sizeof(drv->codec_name),
+                  "i2c-%s", acpi_dev_name(adev));
+             cht_dailink[dai_index].codecs->name = drv->codec_name;
+         }
+         acpi_dev_put(adev);
+ 
+         pr_info("cht-bsw-rt5659 acpi_device name %s\n", acpi_dev_name(adev));
+         pr_info("cht-bsw-rt5659 fixuped index %d dai codec name %s\n", dai_index, cht_dailink[dai_index].codecs->name);
+ 
+         /* Use SSP0 on Bay Trail CR devices */
+         if (soc_intel_is_byt() && mach->mach_params.acpi_ipc_irq_index == 0) {
+             cht_dailink[dai_index].cpus->dai_name = "ssp0-port";
+             drv->use_ssp0 = true;
+         }
+     }
+ 
+     /* override platform name, if required */
+     snd_soc_card_cht.dev = &pdev->dev;
+     platform_name = mach->mach_params.platform;
+     pdata = mach->pdata;
+     //platform_name = padata->platform;
+ 
+     pr_info("cht-bsw-rt5659 mach platform_name %s\n", pdata->platform);
+     pr_info("cht-bsw-rt5659 mach test 1\n");
+ 
+     ret_val = snd_soc_fixup_dai_links_platform_name(&snd_soc_card_cht,
+                             platform_name);
+     if (ret_val)
+         return ret_val;
+ 
+     //snd_soc_card_cht.components = rt5659_components();
+ 
+     drv->mclk = devm_clk_get(&pdev->dev, "pmc_plt_clk_3");
+     if (IS_ERR(drv->mclk)) {
+         dev_err(&pdev->dev,
+             "Failed to get MCLK from pmc_plt_clk_3: %ld\n",
+             PTR_ERR(drv->mclk));
+         return PTR_ERR(drv->mclk);
+     }
+     snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
+ 
+     sof_parent = snd_soc_acpi_sof_parent(&pdev->dev);
+ 
+     pr_info("cht-bsw-rt5659 mach test 2\n");
+ 
+     /* set card and driver name */
+     if (sof_parent) {
+         snd_soc_card_cht.name = SOF_CARD_NAME;
+         snd_soc_card_cht.driver_name = SOF_DRIVER_NAME;
+     } else {
+         snd_soc_card_cht.name = CARD_NAME;
+         snd_soc_card_cht.driver_name = DRIVER_NAME;
+     }
+ 
+     /* set pm ops */
+     if (sof_parent)
+         pdev->dev.driver->pm = &snd_soc_pm_ops;
+ 
+     /* register the soc card */
+     ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
+     if (ret_val) {
+         dev_err(&pdev->dev,
+             "snd_soc_register_card failed %d\n", ret_val);
+         return ret_val;
+     }
+     platform_set_drvdata(pdev, &snd_soc_card_cht);
+ 
+     pr_info("cht-bsw-rt5659 mach test 3\n");
+ 
+     return ret_val;
+ }
+ 
+ static struct platform_driver snd_cht_mc_driver = {
+     .driver = {
+         .name = "cht-bsw-rt5659",
+     },
+     .probe = snd_cht_mc_probe,
+ };
+ 
+ static int __init snd_cht_mc_init(void)
+ {
+     return platform_driver_register(&snd_cht_mc_driver);
+ }
+ late_initcall(snd_cht_mc_init);
+ 
+ static void __exit snd_cht_mc_exit(void)
+ {
+     platform_driver_unregister(&snd_cht_mc_driver);
+ }
+ module_exit(snd_cht_mc_exit);
+ 
+ // module_platform_driver(snd_cht_mc_driver);
+ 
+ MODULE_DESCRIPTION("ASoC Intel(R) Baytrail CR Machine driver");
+ MODULE_AUTHOR("Subhransu S. Prusty, Mengdong Lin");
+ MODULE_LICENSE("GPL v2");
+ MODULE_ALIAS("platform:cht-bsw-rt5659");
diff --color -u -r -N a/sound/soc/intel/boards/Kconfig b/sound/soc/intel/boards/Kconfig
--- a/sound/soc/intel/boards/Kconfig	2025-04-27 15:56:35.712635055 +0800
+++ b/sound/soc/intel/boards/Kconfig	2025-04-27 18:14:54.333346227 +0800
@@ -144,6 +144,20 @@
 	  Say Y if you have such a device.
 	  If unsure select "N".
 
+config SND_SOC_INTEL_CHT_BSW_RT5659_MACH
+	tristate "Cherrytrail & Braswell with RT5659 codec"
+	depends on I2C && ACPI
+	depends on X86_INTEL_LPSS || COMPILE_TEST
+	depends on GPIOLIB || COMPILE_TEST
+	select SND_SOC_ACPI
+	select SND_SOC_RT5659
+	help
+	  This adds support for ASoC machine driver for Intel(R) Cherrytrail & Braswell
+	  platforms with RT5659 audio codec.
+	  Say Y or m if you have such a device. This is a recommended option.
+	  If unsure select "N".
+
+
 config SND_SOC_INTEL_CHT_BSW_RT5672_MACH
 	tristate "Cherrytrail & Braswell with RT5672 codec"
 	depends on I2C && ACPI
diff --color -u -r -N a/sound/soc/intel/boards/Makefile b/sound/soc/intel/boards/Makefile
--- a/sound/soc/intel/boards/Makefile	2025-04-27 15:56:35.712635055 +0800
+++ b/sound/soc/intel/boards/Makefile	2025-04-27 18:16:21.774925627 +0800
@@ -8,6 +8,7 @@
 snd-soc-sst-bytcr-rt5640-y := bytcr_rt5640.o
 snd-soc-sst-bytcr-rt5651-y := bytcr_rt5651.o
 snd-soc-sst-bytcr-wm5102-y := bytcr_wm5102.o
+snd-soc-sst-cht-bsw-rt5659-y := cht_bsw_rt5659.o
 snd-soc-sst-cht-bsw-rt5672-y := cht_bsw_rt5672.o
 snd-soc-sst-cht-bsw-rt5645-y := cht_bsw_rt5645.o
 snd-soc-sst-cht-bsw-max98090_ti-y := cht_bsw_max98090_ti.o
@@ -40,6 +41,7 @@
 obj-$(CONFIG_SND_SOC_INTEL_BYTCR_RT5640_MACH) += snd-soc-sst-bytcr-rt5640.o
 obj-$(CONFIG_SND_SOC_INTEL_BYTCR_RT5651_MACH) += snd-soc-sst-bytcr-rt5651.o
 obj-$(CONFIG_SND_SOC_INTEL_BYTCR_WM5102_MACH) += snd-soc-sst-bytcr-wm5102.o
+obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5659_MACH) += snd-soc-sst-cht-bsw-rt5659.o
 obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5672_MACH) += snd-soc-sst-cht-bsw-rt5672.o
 obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_RT5645_MACH) += snd-soc-sst-cht-bsw-rt5645.o
 obj-$(CONFIG_SND_SOC_INTEL_CHT_BSW_MAX98090_TI_MACH) += snd-soc-sst-cht-bsw-max98090_ti.o
diff --color -u -r -N a/sound/soc/intel/common/soc-acpi-intel-cht-match.c b/sound/soc/intel/common/soc-acpi-intel-cht-match.c
--- a/sound/soc/intel/common/soc-acpi-intel-cht-match.c	2025-04-27 15:56:35.713034742 +0800
+++ b/sound/soc/intel/common/soc-acpi-intel-cht-match.c	2025-04-27 17:10:58.170494018 +0800
@@ -131,6 +131,11 @@
 /* Cherryview-based platforms: CherryTrail and Braswell */
 struct snd_soc_acpi_mach  snd_soc_acpi_intel_cherrytrail_machines[] = {
 	{
+		.id = "10EC5659",
+		.drv_name = "cht-bsw-rt5659",
+		.fw_filename = "intel/fw_sst_22a8.bin",
+	},
+	{
 		.comp_ids = &rt5670_comp_ids,
 		.drv_name = "cht-bsw-rt5672",
 		.fw_filename = "intel/fw_sst_22a8.bin",
