lael-labs/linux

include/sound/soc.h+9−2

 	int probe_order;
 	int remove_order;
-	/* signal if the module handling the component cannot be removed */
+	/*
-	unsigned int ignore_module_refcount:1;
+	 * signal if the module handling the component should not be removed
+	 * if a pcm is open. Setting this would prevent the module
+	 * refcount being incremented in probe() but allow it be incremented
+	 * when a pcm is opened and decremented when it is closed.
+	 */
+	unsigned int module_get_upon_open:1;
 	/* bits */
 	unsigned int idle_bias_on:1;
 	struct mutex mutex;
 	struct mutex dapm_mutex;
+	spinlock_t dpcm_lock;
 	bool instantiated;
 	bool topology_shortname_created;

include/uapi/sound/asound.h+1−0

@@ -32,6 +32,7 @@ · 31 unmodified lines
32		32
33	#ifndef __KERNEL__	33	#ifndef __KERNEL__
34	#include <stdlib.h>	34	#include <stdlib.h>
		35	#include <time.h>
35	#endif	36	#endif
36		37
37	/*	38	/*

sound/core/seq/seq_clientmgr.c+3−3

@@ -1252,7 +1252,7 @@ static int snd_seq_ioctl_set_client_info(struct snd_seq_client *client, · 1251 unmodified lines
1252		1252
1253	/* fill the info fields */	1253	/* fill the info fields */
1254	if (client_info->name[0])	1254	if (client_info->name[0])
1255	strlcpy(client->name, client_info->name, sizeof(client->name));	1255	strscpy(client->name, client_info->name, sizeof(client->name));
1256		1256
1257	client->filter = client_info->filter;	1257	client->filter = client_info->filter;
1258	client->event_lost = client_info->event_lost;	1258	client->event_lost = client_info->event_lost;
@@ -1530,7 +1530,7 @@ static int snd_seq_ioctl_create_queue(struct snd_seq_client client, void arg) · 271 unmodified lines
1530	/* set queue name */	1530	/* set queue name */
1531	if (!info->name[0])	1531	if (!info->name[0])
1532	snprintf(info->name, sizeof(info->name), "Queue-%d", q->queue);	1532	snprintf(info->name, sizeof(info->name), "Queue-%d", q->queue);
1533	strlcpy(q->name, info->name, sizeof(q->name));	1533	strscpy(q->name, info->name, sizeof(q->name));
1534	snd_use_lock_free(&q->use_lock);	1534	snd_use_lock_free(&q->use_lock);
1535		1535
1536	return 0;	1536	return 0;
@@ -1592,7 +1592,7 @@ static int snd_seq_ioctl_set_queue_info(struct snd_seq_client *client, · 55 unmodified lines
1592	queuefree(q);	1592	queuefree(q);
1593	return -EPERM;	1593	return -EPERM;
1594	}	1594	}
1595	strlcpy(q->name, info->name, sizeof(q->name));	1595	strscpy(q->name, info->name, sizeof(q->name));
1596	queuefree(q);	1596	queuefree(q);
1597		1597
1598	return 0;	1598	return 0;

sound/hda/ext/hdac_ext_bus.c+0−1

@@ -107,7 +107,6 @@ int snd_hdac_ext_bus_init(struct hdac_bus bus, struct device dev, · 106 unmodified lines
107	INIT_LIST_HEAD(&bus->hlink_list);	107	INIT_LIST_HEAD(&bus->hlink_list);
108	bus->idx = idx++;	108	bus->idx = idx++;
109		109
110	mutex_init(&bus->lock);
111	bus->cmd_dma_state = true;	110	bus->cmd_dma_state = true;
112		111
113	return 0;	112	return 0;

sound/hda/hdac_bus.c+1−0

@@ -38,6 +38,7 @@ int snd_hdac_bus_init(struct hdac_bus bus, struct device dev, · 37 unmodified lines
38	INIT_WORK(&bus->unsol_work, snd_hdac_bus_process_unsol_events);	38	INIT_WORK(&bus->unsol_work, snd_hdac_bus_process_unsol_events);
39	spin_lock_init(&bus->reg_lock);	39	spin_lock_init(&bus->reg_lock);
40	mutex_init(&bus->cmd_mutex);	40	mutex_init(&bus->cmd_mutex);
		41	mutex_init(&bus->lock);
41	bus->irq = -1;	42	bus->irq = -1;
42	return 0;	43	return 0;
43	}	44	}

sound/hda/hdac_component.c+5−1

 	dev_dbg(bus->dev, "display power %s\n",
 		enable ? "enable" : "disable");
+	mutex_lock(&bus->lock);
 	if (enable)
 		set_bit(idx, &bus->display_power_status);
 	else
 		clear_bit(idx, &bus->display_power_status);
 	if (!acomp || !acomp->ops)
-		return;
+		goto unlock;
 	if (bus->display_power_status) {
 		if (!bus->display_power_active) {
 			bus->display_power_active = false;
 		}
 	}
+ unlock:
+	mutex_unlock(&bus->lock);
 }
 EXPORT_SYMBOL_GPL(snd_hdac_display_power);

sound/pci/hda/hda_intel.c+4−0

 	SND_PCI_QUIRK(0x8086, 0x2040, "Intel DZ77BH-55K", 0),
 	/* https://bugzilla.kernel.org/show_bug.cgi?id=199607 */
 	SND_PCI_QUIRK(0x8086, 0x2057, "Intel NUC5i7RYB", 0),
+	/* https://bugs.launchpad.net/bugs/1821663 */
+	SND_PCI_QUIRK(0x8086, 0x2064, "Intel SDP 8086:2064", 0),
 	/* https://bugzilla.redhat.com/show_bug.cgi?id=1520902 */
 	SND_PCI_QUIRK(0x8086, 0x2068, "Intel NUC7i3BNB", 0),
 	/* https://bugzilla.kernel.org/show_bug.cgi?id=198611 */
 	SND_PCI_QUIRK(0x17aa, 0x367b, "Lenovo IdeaCentre B550", 0),
 	/* https://bugzilla.redhat.com/show_bug.cgi?id=1572975 */
 	SND_PCI_QUIRK(0x17aa, 0x36a7, "Lenovo C50 All in one", 0),
+	/* https://bugs.launchpad.net/bugs/1821663 */
+	SND_PCI_QUIRK(0x1631, 0xe017, "Packard Bell NEC IMEDIA 5204", 0),
 	{}
 };
 #endif /* CONFIG_PM */

sound/pci/hda/patch_realtek.c+51−21

 	ALC887_FIXUP_BASS_CHMAP,
 	ALC1220_FIXUP_GB_DUAL_CODECS,
 	ALC1220_FIXUP_CLEVO_P950,
-	ALC1220_FIXUP_SYSTEM76_ORYP5,
+	ALC1220_FIXUP_CLEVO_PB51ED,
-	ALC1220_FIXUP_SYSTEM76_ORYP5_PINS,
+	ALC1220_FIXUP_CLEVO_PB51ED_PINS,
 };
 static void alc889_fixup_coef(struct hda_codec *codec,
 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
 				const struct hda_fixup *fix, int action);
-static void alc1220_fixup_system76_oryp5(struct hda_codec *codec,
+static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
 				     const struct hda_fixup *fix,
 				     int action)
 {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc1220_fixup_clevo_p950,
 	},
-	[ALC1220_FIXUP_SYSTEM76_ORYP5] = {
+	[ALC1220_FIXUP_CLEVO_PB51ED] = {
 		.type = HDA_FIXUP_FUNC,
-		.v.func = alc1220_fixup_system76_oryp5,
+		.v.func = alc1220_fixup_clevo_pb51ed,
 	},
-	[ALC1220_FIXUP_SYSTEM76_ORYP5_PINS] = {
+	[ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 			{ 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
 			{}
 		},
 		.chained = true,
-		.chain_id = ALC1220_FIXUP_SYSTEM76_ORYP5,
+		.chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
 	},
 };
 	SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
 	SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
 	SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
-	SND_PCI_QUIRK(0x1558, 0x96e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_SYSTEM76_ORYP5_PINS),
+	SND_PCI_QUIRK(0x1558, 0x96e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
-	SND_PCI_QUIRK(0x1558, 0x97e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_SYSTEM76_ORYP5_PINS),
+	SND_PCI_QUIRK(0x1558, 0x97e1, "System76 Oryx Pro (oryp5)", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
+	SND_PCI_QUIRK(0x1558, 0x65d1, "Tuxedo Book XC1509", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
 	jack->jack->button_state = report;
 }
-static void alc295_fixup_chromebook(struct hda_codec *codec,
+static void alc_fixup_headset_jack(struct hda_codec *codec,
 				    const struct hda_fixup *fix, int action)
 {
 						    alc_headset_btn_callback);
 		snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
 				      SND_JACK_HEADSET, alc_headset_btn_keymap);
-		switch (codec->core.vendor_id) {
-		case 0x10ec0295:
-			alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
-			alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
-			break;
-		case 0x10ec0236:
-			alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
-			alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
-			break;
-		}
 		break;
 	case HDA_FIXUP_ACT_INIT:
 		switch (codec->core.vendor_id) {
 	}
 }
+static void alc295_fixup_chromebook(struct hda_codec *codec,
+				    const struct hda_fixup *fix, int action)
+{
+	switch (action) {
+	case HDA_FIXUP_ACT_INIT:
+		switch (codec->core.vendor_id) {
+		case 0x10ec0295:
+			alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
+			alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
+			break;
+		case 0x10ec0236:
+			alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
+			alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
+			break;
+		}
+		break;
+	}
+}
 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
 				  const struct hda_fixup *fix, int action)
 {
 	ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
 	ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
 	ALC233_FIXUP_LENOVO_MULTI_CODECS,
+	ALC233_FIXUP_ACER_HEADSET_MIC,
 	ALC294_FIXUP_LENOVO_MIC_LOCATION,
 	ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
 	ALC700_FIXUP_INTEL_REFERENCE,
 	ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
 	ALC255_FIXUP_ACER_HEADSET_MIC,
 	ALC295_FIXUP_CHROME_BOOK,
+	ALC225_FIXUP_HEADSET_JACK,
 	ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
 	ALC225_FIXUP_WYSE_AUTO_MUTE,
 	ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc233_alc662_fixup_lenovo_dual_codecs,
 	},
+	[ALC233_FIXUP_ACER_HEADSET_MIC] = {
+		.type = HDA_FIXUP_VERBS,
+		.v.verbs = (const struct hda_verb[]) {
+			{ 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
+			{ 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
+			{ }
+		},
+		.chained = true,
+		.chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
+	},
 	[ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
 		.type = HDA_FIXUP_PINS,
 		.v.pins = (const struct hda_pintbl[]) {
 	[ALC295_FIXUP_CHROME_BOOK] = {
 		.type = HDA_FIXUP_FUNC,
 		.v.func = alc295_fixup_chromebook,
+		.chained = true,
+		.chain_id = ALC225_FIXUP_HEADSET_JACK
+	},
+	[ALC225_FIXUP_HEADSET_JACK] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc_fixup_headset_jack,
 	},
 	[ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
 		.type = HDA_FIXUP_PINS,
 	SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
+	SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
 	SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
 	{.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
 	{.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
 	{.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
-	{.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-sense-combo"},
+	{.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
+	{.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
 	{.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
 	{}
 };

sound/soc/codecs/Kconfig+1−0

@@ -1151,6 +1151,7 @@ config SND_SOC_WCD9335 · 1150 unmodified lines
1151	tristate "WCD9335 Codec"	1151	tristate "WCD9335 Codec"
1152	depends on SLIMBUS	1152	depends on SLIMBUS
1153	select REGMAP_SLIMBUS	1153	select REGMAP_SLIMBUS
		1154	select REGMAP_IRQ
1154	help	1155	help
1155	The WCD9335 is a standalone Hi-Fi audio CODEC IC, supports	1156	The WCD9335 is a standalone Hi-Fi audio CODEC IC, supports
1156	Qualcomm Technologies, Inc. (QTI) multimedia solutions,	1157	Qualcomm Technologies, Inc. (QTI) multimedia solutions,

sound/soc/codecs/ab8500-codec.c+1−0

@@ -2129,6 +2129,7 @@ static int ab8500_codec_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) · 2128 unmodified lines
2129	dev_err(dai->component->dev,	2129	dev_err(dai->component->dev,
2130	"%s: ERROR: The device is either a master or a slave.\n",	2130	"%s: ERROR: The device is either a master or a slave.\n",
2131	__func__);	2131	__func__);
		2132	/* fall through */
2132	default:	2133	default:
2133	dev_err(dai->component->dev,	2134	dev_err(dai->component->dev,
2134	"%s: ERROR: Unsupporter master mask 0x%x\n",	2135	"%s: ERROR: Unsupporter master mask 0x%x\n",

sound/soc/codecs/cs35l35.c+11−0

 	return ret;
 }
+static int cs35l35_i2c_remove(struct i2c_client *i2c_client)
+{
+	struct cs35l35_private *cs35l35 = i2c_get_clientdata(i2c_client);
+	regulator_bulk_disable(cs35l35->num_supplies, cs35l35->supplies);
+	gpiod_set_value_cansleep(cs35l35->reset_gpio, 0);
+	return 0;
+}
 static const struct of_device_id cs35l35_of_match[] = {
 	{.compatible = "cirrus,cs35l35"},
 	{},
 	},
 	.id_table = cs35l35_id,
 	.probe = cs35l35_i2c_probe,
+	.remove = cs35l35_i2c_remove,
 };
 module_i2c_driver(cs35l35_i2c_driver);

sound/soc/codecs/cs4270.c+1−0

@@ -642,6 +642,7 @@ static const struct regmap_config cs4270_regmap = { · 641 unmodified lines
642	.reg_defaults = cs4270_reg_defaults,	642	.reg_defaults = cs4270_reg_defaults,
643	.num_reg_defaults = ARRAY_SIZE(cs4270_reg_defaults),	643	.num_reg_defaults = ARRAY_SIZE(cs4270_reg_defaults),
644	.cache_type = REGCACHE_RBTREE,	644	.cache_type = REGCACHE_RBTREE,
		645	.write_flag_mask = CS4270_I2C_INCR,
645		646
646	.readable_reg = cs4270_reg_is_readable,	647	.readable_reg = cs4270_reg_is_readable,
647	.volatile_reg = cs4270_reg_is_volatile,	648	.volatile_reg = cs4270_reg_is_volatile,

sound/soc/codecs/hdac_hda.c+39−14

 			       struct snd_soc_dai *dai);
 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream,
 				struct snd_soc_dai *dai);
+static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream,
+				  struct snd_pcm_hw_params *params,
+				  struct snd_soc_dai *dai);
 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
 				struct snd_soc_dai *dai);
 static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai,
 	.startup = hdac_hda_dai_open,
 	.shutdown = hdac_hda_dai_close,
 	.prepare = hdac_hda_dai_prepare,
+	.hw_params = hdac_hda_dai_hw_params,
 	.hw_free = hdac_hda_dai_hw_free,
 	.set_tdm_slot = hdac_hda_dai_set_tdm_slot,
 };
 	return 0;
 }
+static int hdac_hda_dai_hw_params(struct snd_pcm_substream *substream,
+				  struct snd_pcm_hw_params *params,
+				  struct snd_soc_dai *dai)
+{
+	struct snd_soc_component *component = dai->component;
+	struct hdac_hda_priv *hda_pvt;
+	unsigned int format_val;
+	unsigned int maxbps;
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+		maxbps = dai->driver->playback.sig_bits;
+	else
+		maxbps = dai->driver->capture.sig_bits;
+	hda_pvt = snd_soc_component_get_drvdata(component);
+	format_val = snd_hdac_calc_stream_format(params_rate(params),
+						 params_channels(params),
+						 params_format(params),
+						 maxbps,
+						 0);
+	if (!format_val) {
+		dev_err(dai->dev,
+			"invalid format_val, rate=%d, ch=%d, format=%d, maxbps=%d\n",
+			params_rate(params), params_channels(params),
+			params_format(params), maxbps);
+		return -EINVAL;
+	}
+	hda_pvt->pcm[dai->id].format_val[substream->stream] = format_val;
+	return 0;
+}
 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream,
 				struct snd_soc_dai *dai)
 {
 				struct snd_soc_dai *dai)
 {
 	struct snd_soc_component *component = dai->component;
+	struct hda_pcm_stream *hda_stream;
 	struct hdac_hda_priv *hda_pvt;
-	struct snd_pcm_runtime *runtime = substream->runtime;
 	struct hdac_device *hdev;
-	struct hda_pcm_stream *hda_stream;
 	unsigned int format_val;
 	struct hda_pcm *pcm;
 	unsigned int stream;
 	hda_stream = &pcm->stream[substream->stream];
-	format_val = snd_hdac_calc_stream_format(runtime->rate,
-						 runtime->channels,
-						 runtime->format,
-						 hda_stream->maxbps,
-						 0);
-	if (!format_val) {
-		dev_err(&hdev->dev,
-			"invalid format_val, rate=%d, ch=%d, format=%d\n",
-			runtime->rate, runtime->channels, runtime->format);
-		return -EINVAL;
-	}
 	stream = hda_pvt->pcm[dai->id].stream_tag[substream->stream];
+	format_val = hda_pvt->pcm[dai->id].format_val[substream->stream];
 	ret = snd_hda_codec_prepare(&hda_pvt->codec, hda_stream,
 				    stream, format_val, substream);

sound/soc/codecs/hdac_hda.h+1−0

@@ -8,6 +8,7 @@ · 7 unmodified lines
8		8
9	struct hdac_hda_pcm {	9	struct hdac_hda_pcm {
10	int stream_tag[2];	10	int stream_tag[2];
		11	unsigned int format_val[2];
11	};	12	};
12		13
13	struct hdac_hda_priv {	14	struct hdac_hda_priv {

sound/soc/codecs/hdmi-codec.c+59−62

@@ -484,9 +484,6 @@ static int hdmi_codec_hw_params(struct snd_pcm_substream *substream, · 483 unmodified lines
484	params_width(params), params_rate(params),	484	params_width(params), params_rate(params),
485	params_channels(params));	485	params_channels(params));
486		486
487	if (params_width(params) > 24)
488	params->msbits = 24;
489
490	ret = snd_pcm_create_iec958_consumer_hw_params(params, hp.iec.status,	487	ret = snd_pcm_create_iec958_consumer_hw_params(params, hp.iec.status,
491	sizeof(hp.iec.status));	488	sizeof(hp.iec.status));
492	if (ret < 0) {	489	if (ret < 0) {
@@ -529,73 +526,71 @@ static int hdmi_codec_set_fmt(struct snd_soc_dai *dai, · 36 unmodified lines
529	{	526	{
530	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);	527	struct hdmi_codec_priv *hcp = snd_soc_dai_get_drvdata(dai);
531	struct hdmi_codec_daifmt cf = { 0 };	528	struct hdmi_codec_daifmt cf = { 0 };
532	int ret = 0;
533		529
534	dev_dbg(dai->dev, "%s()\n", __func__);	530	dev_dbg(dai->dev, "%s()\n", __func__);
535		531
536	if (dai->id == DAI_ID_SPDIF) {	532	if (dai->id == DAI_ID_SPDIF)
537	cf.fmt = HDMI_SPDIF;	533	return 0;
538	} else {	534
539	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {	535	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
540	case SND_SOC_DAIFMT_CBM_CFM:	536	case SND_SOC_DAIFMT_CBM_CFM:
541	cf.bit_clk_master = 1;	537	cf.bit_clk_master = 1;
542	cf.frame_clk_master = 1;	538	cf.frame_clk_master = 1;
543	break;	539	break;
544	case SND_SOC_DAIFMT_CBS_CFM:	540	case SND_SOC_DAIFMT_CBS_CFM:
545	cf.frame_clk_master = 1;	541	cf.frame_clk_master = 1;
546	break;	542	break;
547	case SND_SOC_DAIFMT_CBM_CFS:	543	case SND_SOC_DAIFMT_CBM_CFS:
548	cf.bit_clk_master = 1;	544	cf.bit_clk_master = 1;
549	break;	545	break;
550	case SND_SOC_DAIFMT_CBS_CFS:	546	case SND_SOC_DAIFMT_CBS_CFS:
551	break;	547	break;
552	default:	548	default:
553	return -EINVAL;	549	return -EINVAL;
554	}	550	}
555		551
556	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {	552	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
557	case SND_SOC_DAIFMT_NB_NF:	553	case SND_SOC_DAIFMT_NB_NF:
558	break;	554	break;
559	case SND_SOC_DAIFMT_NB_IF:	555	case SND_SOC_DAIFMT_NB_IF:
560	cf.frame_clk_inv = 1;	556	cf.frame_clk_inv = 1;
561	break;	557	break;
562	case SND_SOC_DAIFMT_IB_NF:	558	case SND_SOC_DAIFMT_IB_NF:
563	cf.bit_clk_inv = 1;	559	cf.bit_clk_inv = 1;
564	break;	560	break;
565	case SND_SOC_DAIFMT_IB_IF:	561	case SND_SOC_DAIFMT_IB_IF:
566	cf.frame_clk_inv = 1;	562	cf.frame_clk_inv = 1;
567	cf.bit_clk_inv = 1;	563	cf.bit_clk_inv = 1;
568	break;	564	break;
569	}	565	}
570		566
571	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {	567	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
572	case SND_SOC_DAIFMT_I2S:	568	case SND_SOC_DAIFMT_I2S:
573	cf.fmt = HDMI_I2S;	569	cf.fmt = HDMI_I2S;
574	break;	570	break;
575	case SND_SOC_DAIFMT_DSP_A:	571	case SND_SOC_DAIFMT_DSP_A:
576	cf.fmt = HDMI_DSP_A;	572	cf.fmt = HDMI_DSP_A;
577	break;	573	break;
578	case SND_SOC_DAIFMT_DSP_B:	574	case SND_SOC_DAIFMT_DSP_B:
579	cf.fmt = HDMI_DSP_B;	575	cf.fmt = HDMI_DSP_B;
580	break;	576	break;
581	case SND_SOC_DAIFMT_RIGHT_J:	577	case SND_SOC_DAIFMT_RIGHT_J:
582	cf.fmt = HDMI_RIGHT_J;	578	cf.fmt = HDMI_RIGHT_J;
583	break;	579	break;
584	case SND_SOC_DAIFMT_LEFT_J:	580	case SND_SOC_DAIFMT_LEFT_J:
585	cf.fmt = HDMI_LEFT_J;	581	cf.fmt = HDMI_LEFT_J;
586	break;	582	break;
587	case SND_SOC_DAIFMT_AC97:	583	case SND_SOC_DAIFMT_AC97:
588	cf.fmt = HDMI_AC97;	584	cf.fmt = HDMI_AC97;
589	break;	585	break;
590	default:	586	default:
591	dev_err(dai->dev, "Invalid DAI interface format\n");	587	dev_err(dai->dev, "Invalid DAI interface format\n");
592	return -EINVAL;	588	return -EINVAL;
593	}
594	}	589	}
595		590
596	hcp->daifmt[dai->id] = cf;	591	hcp->daifmt[dai->id] = cf;
597		592
598	return ret;	593	return 0;
599	}	594	}
600		595
601	static int hdmi_codec_digital_mute(struct snd_soc_dai *dai, int mute)	596	static int hdmi_codec_digital_mute(struct snd_soc_dai *dai, int mute)
@@ -792,8 +787,10 @@ static int hdmi_codec_probe(struct platform_device *pdev) · 190 unmodified lines
792	i++;	787	i++;
793	}	788	}
794		789
795	if (hcd->spdif)	790	if (hcd->spdif) {
796	hcp->daidrv[i] = hdmi_spdif_dai;	791	hcp->daidrv[i] = hdmi_spdif_dai;
		792	hcp->daifmt[DAI_ID_SPDIF].fmt = HDMI_SPDIF;
		793	}
797		794
798	dev_set_drvdata(dev, hcp);	795	dev_set_drvdata(dev, hcp);
799		796

sound/soc/codecs/nau8810.c+2−2

@@ -411,9 +411,9 @@ static const struct snd_soc_dapm_widget nau8810_dapm_widgets[] = { · 410 unmodified lines
411	SND_SOC_DAPM_MIXER("Mono Mixer", NAU8810_REG_POWER3,	411	SND_SOC_DAPM_MIXER("Mono Mixer", NAU8810_REG_POWER3,
412	NAU8810_MOUTMX_EN_SFT, 0, &nau8810_mono_mixer_controls[0],	412	NAU8810_MOUTMX_EN_SFT, 0, &nau8810_mono_mixer_controls[0],
413	ARRAY_SIZE(nau8810_mono_mixer_controls)),	413	ARRAY_SIZE(nau8810_mono_mixer_controls)),
414	SND_SOC_DAPM_DAC("DAC", "HiFi Playback", NAU8810_REG_POWER3,	414	SND_SOC_DAPM_DAC("DAC", "Playback", NAU8810_REG_POWER3,
415	NAU8810_DAC_EN_SFT, 0),	415	NAU8810_DAC_EN_SFT, 0),
416	SND_SOC_DAPM_ADC("ADC", "HiFi Capture", NAU8810_REG_POWER2,	416	SND_SOC_DAPM_ADC("ADC", "Capture", NAU8810_REG_POWER2,
417	NAU8810_ADC_EN_SFT, 0),	417	NAU8810_ADC_EN_SFT, 0),
418	SND_SOC_DAPM_PGA("SpkN Out", NAU8810_REG_POWER3,	418	SND_SOC_DAPM_PGA("SpkN Out", NAU8810_REG_POWER3,
419	NAU8810_NSPK_EN_SFT, 0, NULL, 0),	419	NAU8810_NSPK_EN_SFT, 0, NULL, 0),

sound/soc/codecs/nau8824.c+38−8

 	SND_SOC_DAPM_ADC("ADCR", NULL, NAU8824_REG_ANALOG_ADC_2,
 		NAU8824_ADCR_EN_SFT, 0),
-	SND_SOC_DAPM_AIF_OUT("AIFTX", "HiFi Capture", 0, SND_SOC_NOPM, 0, 0),
+	SND_SOC_DAPM_AIF_OUT("AIFTX", "Capture", 0, SND_SOC_NOPM, 0, 0),
-	SND_SOC_DAPM_AIF_IN("AIFRX", "HiFi Playback", 0, SND_SOC_NOPM, 0, 0),
+	SND_SOC_DAPM_AIF_IN("AIFRX", "Playback", 0, SND_SOC_NOPM, 0, 0),
 	SND_SOC_DAPM_DAC("DACL", NULL, NAU8824_REG_RDAC,
 		NAU8824_DACL_EN_SFT, 0),
 	}
 }
+static void nau8824_dapm_disable_pin(struct nau8824 *nau8824, const char *pin)
+{
+	struct snd_soc_dapm_context *dapm = nau8824->dapm;
+	const char *prefix = dapm->component->name_prefix;
+	char prefixed_pin[80];
+	if (prefix) {
+		snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s",
+			 prefix, pin);
+		snd_soc_dapm_disable_pin(dapm, prefixed_pin);
+	} else {
+		snd_soc_dapm_disable_pin(dapm, pin);
+	}
+}
+static void nau8824_dapm_enable_pin(struct nau8824 *nau8824, const char *pin)
+{
+	struct snd_soc_dapm_context *dapm = nau8824->dapm;
+	const char *prefix = dapm->component->name_prefix;
+	char prefixed_pin[80];
+	if (prefix) {
+		snprintf(prefixed_pin, sizeof(prefixed_pin), "%s %s",
+			 prefix, pin);
+		snd_soc_dapm_force_enable_pin(dapm, prefixed_pin);
+	} else {
+		snd_soc_dapm_force_enable_pin(dapm, pin);
+	}
+}
 static void nau8824_eject_jack(struct nau8824 *nau8824)
 {
 	struct snd_soc_dapm_context *dapm = nau8824->dapm;
 	/* Clear all interruption status */
 	nau8824_int_status_clear_all(regmap);
-	snd_soc_dapm_disable_pin(dapm, "SAR");
+	nau8824_dapm_disable_pin(nau8824, "SAR");
-	snd_soc_dapm_disable_pin(dapm, "MICBIAS");
+	nau8824_dapm_disable_pin(nau8824, "MICBIAS");
 	snd_soc_dapm_sync(dapm);
 	/* Enable the insertion interruption, disable the ejection
 	struct regmap *regmap = nau8824->regmap;
 	int adc_value, event = 0, event_mask = 0;
-	snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
+	nau8824_dapm_enable_pin(nau8824, "MICBIAS");
-	snd_soc_dapm_force_enable_pin(dapm, "SAR");
+	nau8824_dapm_enable_pin(nau8824, "SAR");
 	snd_soc_dapm_sync(dapm);
 	msleep(100);
 	if (adc_value < HEADSET_SARADC_THD) {
 		event |= SND_JACK_HEADPHONE;
-		snd_soc_dapm_disable_pin(dapm, "SAR");
+		nau8824_dapm_disable_pin(nau8824, "SAR");
-		snd_soc_dapm_disable_pin(dapm, "MICBIAS");
+		nau8824_dapm_disable_pin(nau8824, "MICBIAS");
 		snd_soc_dapm_sync(dapm);
 	} else {
 		event |= SND_JACK_HEADSET;

sound/soc/codecs/rt5682.c+25−31

@@ -910,13 +910,21 @@ static int rt5682_headset_detect(struct snd_soc_component *component, · 909 unmodified lines
910	int jack_insert)	910	int jack_insert)
911	{	911	{
912	struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);	912	struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);
913	struct snd_soc_dapm_context *dapm =
914	snd_soc_component_get_dapm(component);
915	unsigned int val, count;	913	unsigned int val, count;
916		914
917	if (jack_insert) {	915	if (jack_insert) {
918	snd_soc_dapm_force_enable_pin(dapm, "CBJ Power");	916
919	snd_soc_dapm_sync(dapm);	917	snd_soc_component_update_bits(component, RT5682_PWR_ANLG_1,
		918	RT5682_PWR_VREF2 \| RT5682_PWR_MB,
		919	RT5682_PWR_VREF2 \| RT5682_PWR_MB);
		920	snd_soc_component_update_bits(component,
		921	RT5682_PWR_ANLG_1, RT5682_PWR_FV2, 0);
		922	usleep_range(15000, 20000);
		923	snd_soc_component_update_bits(component,
		924	RT5682_PWR_ANLG_1, RT5682_PWR_FV2, RT5682_PWR_FV2);
		925	snd_soc_component_update_bits(component, RT5682_PWR_ANLG_3,
		926	RT5682_PWR_CBJ, RT5682_PWR_CBJ);
		927
920	snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1,	928	snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1,
921	RT5682_TRIG_JD_MASK, RT5682_TRIG_JD_HIGH);	929	RT5682_TRIG_JD_MASK, RT5682_TRIG_JD_HIGH);
922		930
@@ -944,8 +952,10 @@ static int rt5682_headset_detect(struct snd_soc_component *component, · 21 unmodified lines
944	rt5682_enable_push_button_irq(component, false);	952	rt5682_enable_push_button_irq(component, false);
945	snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1,	953	snd_soc_component_update_bits(component, RT5682_CBJ_CTRL_1,
946	RT5682_TRIG_JD_MASK, RT5682_TRIG_JD_LOW);	954	RT5682_TRIG_JD_MASK, RT5682_TRIG_JD_LOW);
947	snd_soc_dapm_disable_pin(dapm, "CBJ Power");	955	snd_soc_component_update_bits(component, RT5682_PWR_ANLG_1,
948	snd_soc_dapm_sync(dapm);	956	RT5682_PWR_VREF2 \| RT5682_PWR_MB, 0);
		957	snd_soc_component_update_bits(component, RT5682_PWR_ANLG_3,
		958	RT5682_PWR_CBJ, 0);
949		959
950	rt5682->jack_type = 0;	960	rt5682->jack_type = 0;
951	}	961	}
@@ -1198,7 +1208,7 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w, · 246 unmodified lines
1198	struct snd_soc_component *component =	1208	struct snd_soc_component *component =
1199	snd_soc_dapm_to_component(w->dapm);	1209	snd_soc_dapm_to_component(w->dapm);
1200	struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);	1210	struct rt5682_priv *rt5682 = snd_soc_component_get_drvdata(component);
1201	int ref, val, reg, sft, mask, idx = -EINVAL;	1211	int ref, val, reg, idx = -EINVAL;
1202	static const int div_f[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48};	1212	static const int div_f[] = {1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48};
1203	static const int div_o[] = {1, 2, 4, 6, 8, 12, 16, 24, 32, 48};	1213	static const int div_o[] = {1, 2, 4, 6, 8, 12, 16, 24, 32, 48};
1204		1214
@@ -1212,15 +1222,10 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w, · 7 unmodified lines
1212		1222
1213	idx = rt5682_div_sel(rt5682, ref, div_f, ARRAY_SIZE(div_f));	1223	idx = rt5682_div_sel(rt5682, ref, div_f, ARRAY_SIZE(div_f));
1214		1224
1215	if (w->shift == RT5682_PWR_ADC_S1F_BIT) {	1225	if (w->shift == RT5682_PWR_ADC_S1F_BIT)
1216	reg = RT5682_PLL_TRACK_3;	1226	reg = RT5682_PLL_TRACK_3;
1217	sft = RT5682_ADC_OSR_SFT;	1227	else
1218	mask = RT5682_ADC_OSR_MASK;
1219	} else {
1220	reg = RT5682_PLL_TRACK_2;	1228	reg = RT5682_PLL_TRACK_2;
1221	sft = RT5682_DAC_OSR_SFT;
1222	mask = RT5682_DAC_OSR_MASK;
1223	}
1224		1229
1225	snd_soc_component_update_bits(component, reg,	1230	snd_soc_component_update_bits(component, reg,
1226	RT5682_FILTER_CLK_DIV_MASK, idx << RT5682_FILTER_CLK_DIV_SFT);	1231	RT5682_FILTER_CLK_DIV_MASK, idx << RT5682_FILTER_CLK_DIV_SFT);
@@ -1232,7 +1237,8 @@ static int set_filter_clk(struct snd_soc_dapm_widget *w, · 5 unmodified lines
1232	}	1237	}
1233		1238
1234	snd_soc_component_update_bits(component, RT5682_ADDA_CLK_1,	1239	snd_soc_component_update_bits(component, RT5682_ADDA_CLK_1,
1235	mask, idx << sft);	1240	RT5682_ADC_OSR_MASK \| RT5682_DAC_OSR_MASK,
		1241	(idx << RT5682_ADC_OSR_SFT) \| (idx << RT5682_DAC_OSR_SFT));
1236		1242
1237	return 0;	1243	return 0;
1238	}	1244	}
@@ -1591,8 +1597,6 @@ static const struct snd_soc_dapm_widget rt5682_dapm_widgets[] = { · 352 unmodified lines
1591	0, NULL, 0),	1597	0, NULL, 0),
1592	SND_SOC_DAPM_SUPPLY("Vref1", RT5682_PWR_ANLG_1, RT5682_PWR_VREF1_BIT, 0,	1598	SND_SOC_DAPM_SUPPLY("Vref1", RT5682_PWR_ANLG_1, RT5682_PWR_VREF1_BIT, 0,
1593	rt5655_set_verf, SND_SOC_DAPM_PRE_PMU \| SND_SOC_DAPM_POST_PMU),	1599	rt5655_set_verf, SND_SOC_DAPM_PRE_PMU \| SND_SOC_DAPM_POST_PMU),
1594	SND_SOC_DAPM_SUPPLY("Vref2", RT5682_PWR_ANLG_1, RT5682_PWR_VREF2_BIT, 0,
1595	rt5655_set_verf, SND_SOC_DAPM_PRE_PMU \| SND_SOC_DAPM_POST_PMU),
1596		1600
1597	/* ASRC */	1601	/* ASRC */
1598	SND_SOC_DAPM_SUPPLY_S("DAC STO1 ASRC", 1, RT5682_PLL_TRACK_1,	1602	SND_SOC_DAPM_SUPPLY_S("DAC STO1 ASRC", 1, RT5682_PLL_TRACK_1,
@@ -1627,9 +1631,6 @@ static const struct snd_soc_dapm_widget rt5682_dapm_widgets[] = { · 28 unmodified lines
1627	SND_SOC_DAPM_PGA("BST1 CBJ", SND_SOC_NOPM,	1631	SND_SOC_DAPM_PGA("BST1 CBJ", SND_SOC_NOPM,
1628	0, 0, NULL, 0),	1632	0, 0, NULL, 0),
1629		1633
1630	SND_SOC_DAPM_SUPPLY("CBJ Power", RT5682_PWR_ANLG_3,
1631	RT5682_PWR_CBJ_BIT, 0, NULL, 0),
1632
1633	/* REC Mixer */	1634	/* REC Mixer */
1634	SND_SOC_DAPM_MIXER("RECMIX1L", SND_SOC_NOPM, 0, 0, rt5682_rec1_l_mix,	1635	SND_SOC_DAPM_MIXER("RECMIX1L", SND_SOC_NOPM, 0, 0, rt5682_rec1_l_mix,
1635	ARRAY_SIZE(rt5682_rec1_l_mix)),	1636	ARRAY_SIZE(rt5682_rec1_l_mix)),
@@ -1792,17 +1793,13 @@ static const struct snd_soc_dapm_route rt5682_dapm_routes[] = { · 156 unmodified lines
1792		1793
1793	/Vref/	1794	/Vref/
1794	{"MICBIAS1", NULL, "Vref1"},	1795	{"MICBIAS1", NULL, "Vref1"},
1795	{"MICBIAS1", NULL, "Vref2"},
1796	{"MICBIAS2", NULL, "Vref1"},	1796	{"MICBIAS2", NULL, "Vref1"},
1797	{"MICBIAS2", NULL, "Vref2"},
1798		1797
1799	{"CLKDET SYS", NULL, "CLKDET"},	1798	{"CLKDET SYS", NULL, "CLKDET"},
1800		1799
1801	{"IN1P", NULL, "LDO2"},	1800	{"IN1P", NULL, "LDO2"},
1802		1801
1803	{"BST1 CBJ", NULL, "IN1P"},	1802	{"BST1 CBJ", NULL, "IN1P"},
1804	{"BST1 CBJ", NULL, "CBJ Power"},
1805	{"CBJ Power", NULL, "Vref2"},
1806		1803
1807	{"RECMIX1L", "CBJ Switch", "BST1 CBJ"},	1804	{"RECMIX1L", "CBJ Switch", "BST1 CBJ"},
1808	{"RECMIX1L", NULL, "RECMIX1L Power"},	1805	{"RECMIX1L", NULL, "RECMIX1L Power"},
@@ -1912,9 +1909,7 @@ static const struct snd_soc_dapm_route rt5682_dapm_routes[] = { · 103 unmodified lines
1912	{"HP Amp", NULL, "Capless"},	1909	{"HP Amp", NULL, "Capless"},
1913	{"HP Amp", NULL, "Charge Pump"},	1910	{"HP Amp", NULL, "Charge Pump"},
1914	{"HP Amp", NULL, "CLKDET SYS"},	1911	{"HP Amp", NULL, "CLKDET SYS"},
1915	{"HP Amp", NULL, "CBJ Power"},
1916	{"HP Amp", NULL, "Vref1"},	1912	{"HP Amp", NULL, "Vref1"},
1917	{"HP Amp", NULL, "Vref2"},
1918	{"HPOL Playback", "Switch", "HP Amp"},	1913	{"HPOL Playback", "Switch", "HP Amp"},
1919	{"HPOR Playback", "Switch", "HP Amp"},	1914	{"HPOR Playback", "Switch", "HP Amp"},
1920	{"HPOL", NULL, "HPOL Playback"},	1915	{"HPOL", NULL, "HPOL Playback"},
@@ -2303,16 +2298,13 @@ static int rt5682_set_bias_level(struct snd_soc_component *component, · 382 unmodified lines
2303	switch (level) {	2298	switch (level) {
2304	case SND_SOC_BIAS_PREPARE:	2299	case SND_SOC_BIAS_PREPARE:
2305	regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1,	2300	regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1,
2306	RT5682_PWR_MB \| RT5682_PWR_BG,	2301	RT5682_PWR_BG, RT5682_PWR_BG);
2307	RT5682_PWR_MB \| RT5682_PWR_BG);
2308	regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1,	2302	regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1,
2309	RT5682_DIG_GATE_CTRL \| RT5682_PWR_LDO,	2303	RT5682_DIG_GATE_CTRL \| RT5682_PWR_LDO,
2310	RT5682_DIG_GATE_CTRL \| RT5682_PWR_LDO);	2304	RT5682_DIG_GATE_CTRL \| RT5682_PWR_LDO);
2311	break;	2305	break;
2312		2306
2313	case SND_SOC_BIAS_STANDBY:	2307	case SND_SOC_BIAS_STANDBY:
2314	regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1,
2315	RT5682_PWR_MB, RT5682_PWR_MB);
2316	regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1,	2308	regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1,
2317	RT5682_DIG_GATE_CTRL, RT5682_DIG_GATE_CTRL);	2309	RT5682_DIG_GATE_CTRL, RT5682_DIG_GATE_CTRL);
2318	break;	2310	break;
@@ -2320,7 +2312,7 @@ static int rt5682_set_bias_level(struct snd_soc_component *component, · 1 unmodified line
2320	regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1,	2312	regmap_update_bits(rt5682->regmap, RT5682_PWR_DIG_1,
2321	RT5682_DIG_GATE_CTRL \| RT5682_PWR_LDO, 0);	2313	RT5682_DIG_GATE_CTRL \| RT5682_PWR_LDO, 0);
2322	regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1,	2314	regmap_update_bits(rt5682->regmap, RT5682_PWR_ANLG_1,
2323	RT5682_PWR_MB \| RT5682_PWR_BG, 0);	2315	RT5682_PWR_BG, 0);
2324	break;	2316	break;
2325		2317
2326	default:	2318	default:
@@ -2363,6 +2355,8 @@ static int rt5682_resume(struct snd_soc_component *component) · 36 unmodified lines
2363	regcache_cache_only(rt5682->regmap, false);	2355	regcache_cache_only(rt5682->regmap, false);
2364	regcache_sync(rt5682->regmap);	2356	regcache_sync(rt5682->regmap);
2365		2357
		2358	rt5682_irq(0, rt5682);
		2359
2366	return 0;	2360	return 0;
2367	}	2361	}
2368	#else	2362	#else

sound/soc/codecs/tlv320aic32x4-i2c.c+2−2

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	*	3	*
4	* Copyright 2011 NW Digital Radio	4	* Copyright 2011 NW Digital Radio
5	*	5	*
6	* Author: Jeremy McDermond <nh6z@nh6z.net>	6	* Author: Annaliese McDermond <nh6z@nh6z.net>
7	*	7	*
8	* Based on sound/soc/codecs/wm8974 and TI driver for kernel 2.6.27.	8	* Based on sound/soc/codecs/wm8974 and TI driver for kernel 2.6.27.
9	*	9	*
@@ -72,5 +72,5 @@ static struct i2c_driver aic32x4_i2c_driver = { · 62 unmodified lines
72	module_i2c_driver(aic32x4_i2c_driver);	72	module_i2c_driver(aic32x4_i2c_driver);
73		73
74	MODULE_DESCRIPTION("ASoC TLV320AIC32x4 codec driver I2C");	74	MODULE_DESCRIPTION("ASoC TLV320AIC32x4 codec driver I2C");
75	MODULE_AUTHOR("Jeremy McDermond <nh6z@nh6z.net>");	75	MODULE_AUTHOR("Annaliese McDermond <nh6z@nh6z.net>");
76	MODULE_LICENSE("GPL");	76	MODULE_LICENSE("GPL");

sound/soc/codecs/tlv320aic32x4-spi.c+2−2

@@ -3,7 +3,7 @@ · 2 unmodified lines
3	*	3	*
4	* Copyright 2011 NW Digital Radio	4	* Copyright 2011 NW Digital Radio
5	*	5	*
6	* Author: Jeremy McDermond <nh6z@nh6z.net>	6	* Author: Annaliese McDermond <nh6z@nh6z.net>
7	*	7	*
8	* Based on sound/soc/codecs/wm8974 and TI driver for kernel 2.6.27.	8	* Based on sound/soc/codecs/wm8974 and TI driver for kernel 2.6.27.
9	*	9	*
@@ -74,5 +74,5 @@ static struct spi_driver aic32x4_spi_driver = { · 64 unmodified lines
74	module_spi_driver(aic32x4_spi_driver);	74	module_spi_driver(aic32x4_spi_driver);
75		75
76	MODULE_DESCRIPTION("ASoC TLV320AIC32x4 codec driver SPI");	76	MODULE_DESCRIPTION("ASoC TLV320AIC32x4 codec driver SPI");
77	MODULE_AUTHOR("Jeremy McDermond <nh6z@nh6z.net>");	77	MODULE_AUTHOR("Annaliese McDermond <nh6z@nh6z.net>");
78	MODULE_LICENSE("GPL");	78	MODULE_LICENSE("GPL");

sound/soc/codecs/tlv320aic32x4.c+2−0

@@ -490,6 +490,8 @@ static const struct snd_soc_dapm_widget aic32x4_dapm_widgets[] = { · 489 unmodified lines
490	SND_SOC_DAPM_INPUT("IN2_R"),	490	SND_SOC_DAPM_INPUT("IN2_R"),
491	SND_SOC_DAPM_INPUT("IN3_L"),	491	SND_SOC_DAPM_INPUT("IN3_L"),
492	SND_SOC_DAPM_INPUT("IN3_R"),	492	SND_SOC_DAPM_INPUT("IN3_R"),
		493	SND_SOC_DAPM_INPUT("CM_L"),
		494	SND_SOC_DAPM_INPUT("CM_R"),
493	};	495	};
494		496
495	static const struct snd_soc_dapm_route aic32x4_dapm_routes[] = {	497	static const struct snd_soc_dapm_route aic32x4_dapm_routes[] = {

sound/soc/codecs/tlv320aic3x.c+3−1

 	struct aic3x_priv *aic3x = snd_soc_component_get_drvdata(component);
 	int ret, i;
-	INIT_LIST_HEAD(&aic3x->list);
 	aic3x->component = component;
 	for (i = 0; i < ARRAY_SIZE(aic3x->supplies); i++) {
 	if (ret != 0)
 		goto err_gpio;
+	INIT_LIST_HEAD(&aic3x->list);
 	list_add(&aic3x->list, &reset_list);
 	return 0;
 {
 	struct aic3x_priv *aic3x = i2c_get_clientdata(client);
+	list_del(&aic3x->list);
 	if (gpio_is_valid(aic3x->gpio_reset) &&
 	    !aic3x_is_shared_reset(aic3x)) {
 		gpio_set_value(aic3x->gpio_reset, 0);

sound/soc/codecs/wm_adsp.c+33−7

 		if (wm_adsp_fw[dsp->fw].num_caps != 0)
 			wm_adsp_buffer_free(dsp);
+		dsp->fatal_error = false;
 		mutex_unlock(&dsp->pwr_lock);
 		adsp_dbg(dsp, "Execution stopped\n");
 {
 	struct wm_adsp_compr_buf *buf = NULL, *tmp;
+	if (compr->dsp->fatal_error)
+		return -EINVAL;
 	list_for_each_entry(tmp, &compr->dsp->buffer_list, list) {
 		if (!tmp->name || !strcmp(compr->name, tmp->name)) {
 			buf = tmp;
 	ret = wm_adsp_buffer_read(buf, HOST_BUFFER_FIELD(error), &buf->error);
 	if (ret < 0) {
-		adsp_err(buf->dsp, "Failed to check buffer error: %d\n", ret);
+		compr_err(buf, "Failed to check buffer error: %d\n", ret);
 		return ret;
 	}
 	if (buf->error != 0) {
-		adsp_err(buf->dsp, "Buffer error occurred: %d\n", buf->error);
+		compr_err(buf, "Buffer error occurred: %d\n", buf->error);
 		return -EIO;
 	}
 		if (ret < 0)
 			break;
-		wm_adsp_buffer_clear(compr->buf);
 		/* Trigger the IRQ at one fragment of data */
 		ret = wm_adsp_buffer_write(compr->buf,
 					   HOST_BUFFER_FIELD(high_water_mark),
 		}
 		break;
 	case SNDRV_PCM_TRIGGER_STOP:
+		if (wm_adsp_compr_attached(compr))
+			wm_adsp_buffer_clear(compr->buf);
 		break;
 	default:
 		ret = -EINVAL;
 }
 EXPORT_SYMBOL_GPL(wm_adsp2_lock);
+static void wm_adsp_fatal_error(struct wm_adsp *dsp)
+{
+	struct wm_adsp_compr *compr;
+	dsp->fatal_error = true;
+	list_for_each_entry(compr, &dsp->compr_list, list) {
+		if (compr->stream) {
+			snd_compr_stop_error(compr->stream,
+					     SNDRV_PCM_STATE_XRUN);
+			snd_compr_fragment_elapsed(compr->stream);
+		}
+	}
+}
 irqreturn_t wm_adsp2_bus_error(struct wm_adsp *dsp)
 {
 	unsigned int val;
 	struct regmap *regmap = dsp->regmap;
 	int ret = 0;
+	mutex_lock(&dsp->pwr_lock);
 	ret = regmap_read(regmap, dsp->base + ADSP2_LOCK_REGION_CTRL, &val);
 	if (ret) {
 		adsp_err(dsp,
 			"Failed to read Region Lock Ctrl register: %d\n", ret);
-		return IRQ_HANDLED;
+		goto error;
 	}
 	if (val & ADSP2_WDT_TIMEOUT_STS_MASK) {
 		adsp_err(dsp, "watchdog timeout error\n");
 		wm_adsp_stop_watchdog(dsp);
+		wm_adsp_fatal_error(dsp);
 	}
 	if (val & (ADSP2_SLAVE_ERR_MASK | ADSP2_REGION_LOCK_ERR_MASK)) {
 			adsp_err(dsp,
 				 "Failed to read Bus Err Addr register: %d\n",
 				 ret);
-			return IRQ_HANDLED;
+			goto error;
 		}
 		adsp_err(dsp, "bus error address = 0x%x\n",
 			adsp_err(dsp,
 				 "Failed to read Pmem Xmem Err Addr register: %d\n",
 				 ret);
-			return IRQ_HANDLED;
+			goto error;
 		}
 		adsp_err(dsp, "xmem error address = 0x%x\n",
 	regmap_update_bits(regmap, dsp->base + ADSP2_LOCK_REGION_CTRL,
 			   ADSP2_CTRL_ERR_EINT, ADSP2_CTRL_ERR_EINT);
+error:
+	mutex_unlock(&dsp->pwr_lock);
 	return IRQ_HANDLED;
 }
 EXPORT_SYMBOL_GPL(wm_adsp2_bus_error);

sound/soc/codecs/wm_adsp.h+1−0

@@ -85,6 +85,7 @@ struct wm_adsp { · 84 unmodified lines
85	bool preloaded;	85	bool preloaded;
86	bool booted;	86	bool booted;
87	bool running;	87	bool running;
		88	bool fatal_error;
88		89
89	struct list_head ctl_list;	90	struct list_head ctl_list;
90		91

sound/soc/fsl/fsl_asrc.c+14−0

@@ -445,6 +445,19 @@ struct dma_chan fsl_asrc_get_dma_channel(struct fsl_asrc_pair pair, bool dir) · 444 unmodified lines
445	}	445	}
446	EXPORT_SYMBOL_GPL(fsl_asrc_get_dma_channel);	446	EXPORT_SYMBOL_GPL(fsl_asrc_get_dma_channel);
447		447
		448	static int fsl_asrc_dai_startup(struct snd_pcm_substream *substream,
		449	struct snd_soc_dai *dai)
		450	{
		451	struct fsl_asrc *asrc_priv = snd_soc_dai_get_drvdata(dai);
		452
		453	/* Odd channel number is not valid for older ASRC (channel_bits==3) */
		454	if (asrc_priv->channel_bits == 3)
		455	snd_pcm_hw_constraint_step(substream->runtime, 0,
		456	SNDRV_PCM_HW_PARAM_CHANNELS, 2);
		457
		458	return 0;
		459	}
		460
448	static int fsl_asrc_dai_hw_params(struct snd_pcm_substream *substream,	461	static int fsl_asrc_dai_hw_params(struct snd_pcm_substream *substream,
449	struct snd_pcm_hw_params *params,	462	struct snd_pcm_hw_params *params,
450	struct snd_soc_dai *dai)	463	struct snd_soc_dai *dai)
@@ -539,6 +552,7 @@ static int fsl_asrc_dai_trigger(struct snd_pcm_substream *substream, int cmd, · 88 unmodified lines
539	}	552	}
540		553
541	static const struct snd_soc_dai_ops fsl_asrc_dai_ops = {	554	static const struct snd_soc_dai_ops fsl_asrc_dai_ops = {
		555	.startup = fsl_asrc_dai_startup,
542	.hw_params = fsl_asrc_dai_hw_params,	556	.hw_params = fsl_asrc_dai_hw_params,
543	.hw_free = fsl_asrc_dai_hw_free,	557	.hw_free = fsl_asrc_dai_hw_free,
544	.trigger = fsl_asrc_dai_trigger,	558	.trigger = fsl_asrc_dai_trigger,

sound/soc/fsl/fsl_esai.c+37−10

 	u32 fifo_depth;
 	u32 slot_width;
 	u32 slots;
+	u32 tx_mask;
+	u32 rx_mask;
 	u32 hck_rate[2];
 	u32 sck_rate[2];
 	bool hck_dir[2];
 	regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR,
 			   ESAI_xCCR_xDC_MASK, ESAI_xCCR_xDC(slots));
-	regmap_update_bits(esai_priv->regmap, REG_ESAI_TSMA,
-			   ESAI_xSMA_xS_MASK, ESAI_xSMA_xS(tx_mask));
-	regmap_update_bits(esai_priv->regmap, REG_ESAI_TSMB,
-			   ESAI_xSMB_xS_MASK, ESAI_xSMB_xS(tx_mask));
 	regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR,
 			   ESAI_xCCR_xDC_MASK, ESAI_xCCR_xDC(slots));
-	regmap_update_bits(esai_priv->regmap, REG_ESAI_RSMA,
-			   ESAI_xSMA_xS_MASK, ESAI_xSMA_xS(rx_mask));
-	regmap_update_bits(esai_priv->regmap, REG_ESAI_RSMB,
-			   ESAI_xSMB_xS_MASK, ESAI_xSMB_xS(rx_mask));
 	esai_priv->slot_width = slot_width;
 	esai_priv->slots = slots;
+	esai_priv->tx_mask = tx_mask;
+	esai_priv->rx_mask = rx_mask;
 	return 0;
 }
 	bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 	u8 i, channels = substream->runtime->channels;
 	u32 pins = DIV_ROUND_UP(channels, esai_priv->slots);
+	u32 mask;
 	switch (cmd) {
 	case SNDRV_PCM_TRIGGER_START:
 		for (i = 0; tx && i < channels; i++)
 			regmap_write(esai_priv->regmap, REG_ESAI_ETDR, 0x0);
+		/*
+		 * When set the TE/RE in the end of enablement flow, there
+		 * will be channel swap issue for multi data line case.
+		 * In order to workaround this issue, we switch the bit
+		 * enablement sequence to below sequence
+		 * 1) clear the xSMB & xSMA: which is done in probe and
+		 *                           stop state.
+		 * 2) set TE/RE
+		 * 3) set xSMB
+		 * 4) set xSMA:  xSMA is the last one in this flow, which
+		 *               will trigger esai to start.
+		 */
 		regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx),
 				   tx ? ESAI_xCR_TE_MASK : ESAI_xCR_RE_MASK,
 				   tx ? ESAI_xCR_TE(pins) : ESAI_xCR_RE(pins));
+		mask = tx ? esai_priv->tx_mask : esai_priv->rx_mask;
+		regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMB(tx),
+				   ESAI_xSMB_xS_MASK, ESAI_xSMB_xS(mask));
+		regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMA(tx),
+				   ESAI_xSMA_xS_MASK, ESAI_xSMA_xS(mask));
 		break;
 	case SNDRV_PCM_TRIGGER_SUSPEND:
 	case SNDRV_PCM_TRIGGER_STOP:
 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 		regmap_update_bits(esai_priv->regmap, REG_ESAI_xCR(tx),
 				   tx ? ESAI_xCR_TE_MASK : ESAI_xCR_RE_MASK, 0);
+		regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMA(tx),
+				   ESAI_xSMA_xS_MASK, 0);
+		regmap_update_bits(esai_priv->regmap, REG_ESAI_xSMB(tx),
+				   ESAI_xSMB_xS_MASK, 0);
 		/* Disable and reset FIFO */
 		regmap_update_bits(esai_priv->regmap, REG_ESAI_xFCR(tx),
 		return ret;
 	}
+	esai_priv->tx_mask = 0xFFFFFFFF;
+	esai_priv->rx_mask = 0xFFFFFFFF;
+	/* Clear the TSMA, TSMB, RSMA, RSMB */
+	regmap_write(esai_priv->regmap, REG_ESAI_TSMA, 0);
+	regmap_write(esai_priv->regmap, REG_ESAI_TSMB, 0);
+	regmap_write(esai_priv->regmap, REG_ESAI_RSMA, 0);
+	regmap_write(esai_priv->regmap, REG_ESAI_RSMB, 0);
 	ret = devm_snd_soc_register_component(&pdev->dev, &fsl_esai_component,
 					      &fsl_esai_dai, 1);
 	if (ret) {

sound/soc/generic/audio-graph-card.c+8−3

 #include <linux/string.h>
 #include <sound/simple_card_utils.h>
+#define DPCM_SELECTABLE 1
 struct graph_priv {
 	struct snd_soc_card snd_card;
 	struct graph_dai_props {
 	struct device_node *codec_port;
 	struct device_node *codec_port_old = NULL;
 	struct asoc_simple_card_data adata;
+	uintptr_t dpcm_selectable = (uintptr_t)of_device_get_match_data(dev);
 	int rc, ret;
 	/* loop for all listed CPU port */
 			 * if Codec port has many endpoints,
 			 * or has convert-xxx property
 			 */
-			if ((of_get_child_count(codec_port) > 1) ||
+			if (dpcm_selectable &&
-			    adata.convert_rate || adata.convert_channels)
+			    ((of_get_child_count(codec_port) > 1) ||
+			     adata.convert_rate || adata.convert_channels))
 				ret = func_dpcm(priv, cpu_ep, codec_ep, li,
 						(codec_port_old == codec_port));
 			/* else normal sound */
 static const struct of_device_id graph_of_match[] = {
 	{ .compatible = "audio-graph-card", },
-	{ .compatible = "audio-graph-scu-card", },
+	{ .compatible = "audio-graph-scu-card",
+	  .data = (void *)DPCM_SELECTABLE },
 	{},
 };
 MODULE_DEVICE_TABLE(of, graph_of_match);

sound/soc/generic/simple-card.c+9−3

 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/platform_device.h>
 #include <linux/string.h>
 #include <sound/simple_card.h>
 #include <sound/soc-dai.h>
 #include <sound/soc.h>
+#define DPCM_SELECTABLE 1
 struct simple_priv {
 	struct snd_soc_card snd_card;
 	struct simple_dai_props {
 	struct device *dev = simple_priv_to_dev(priv);
 	struct device_node *top = dev->of_node;
 	struct device_node *node;
+	uintptr_t dpcm_selectable = (uintptr_t)of_device_get_match_data(dev);
 	bool is_top = 0;
 	int ret = 0;
 			 * if it has many CPUs,
 			 * or has convert-xxx property
 			 */
-			if (num > 2 ||
+			if (dpcm_selectable &&
-			    adata.convert_rate || adata.convert_channels)
+			    (num > 2 ||
+			     adata.convert_rate || adata.convert_channels))
 				ret = func_dpcm(priv, np, codec, li, is_top);
 			/* else normal sound */
 			else
 static const struct of_device_id simple_of_match[] = {
 	{ .compatible = "simple-audio-card", },
-	{ .compatible = "simple-scu-audio-card", },
+	{ .compatible = "simple-scu-audio-card",
+	  .data = (void *)DPCM_SELECTABLE },
 	{},
 };
 MODULE_DEVICE_TABLE(of, simple_of_match);

sound/soc/intel/atom/sst-mfld-platform-pcm.c+8−0

 	return sst_dsp_init_v2_dpcm(component);
 }
+static void sst_soc_remove(struct snd_soc_component *component)
+{
+	struct sst_data *drv = dev_get_drvdata(component->dev);
+	drv->soc_card = NULL;
+}
 static const struct snd_soc_component_driver sst_soc_platform_drv  = {
 	.name		= DRV_NAME,
 	.probe		= sst_soc_probe,
+	.remove		= sst_soc_remove,
 	.ops		= &sst_platform_ops,
 	.compr_ops	= &sst_platform_compr_ops,
 	.pcm_new	= sst_pcm_new,

sound/soc/intel/boards/cht_bsw_max98090_ti.c+41−6

 	struct clk *mclk;
 	struct snd_soc_jack jack;
 	bool ts3a227e_present;
+	int quirks;
 };
 static int platform_clock_control(struct snd_soc_dapm_widget *w,
 	struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
 	int ret;
+	/* See the comment in snd_cht_mc_probe() */
+	if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
+		return 0;
 	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");
 			"jack detection gpios not added, error %d\n", ret);
 	}
+	/* See the comment in snd_cht_mc_probe() */
+	if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
+		return 0;
 	/*
 	 * The firmware might enable the clock at
 	 * boot (this information may or may not
 	const char *mclk_name;
 	struct snd_soc_acpi_mach *mach;
 	const char *platform_name;
-	int quirks = 0;
-	dmi_id = dmi_first_match(cht_max98090_quirk_table);
-	if (dmi_id)
-		quirks = (unsigned long)dmi_id->driver_data;
 	drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
 	if (!drv)
 		return -ENOMEM;
+	dmi_id = dmi_first_match(cht_max98090_quirk_table);
+	if (dmi_id)
+		drv->quirks = (unsigned long)dmi_id->driver_data;
 	drv->ts3a227e_present = acpi_dev_found("104C227E");
 	if (!drv->ts3a227e_present) {
 		/* no need probe TI jack detection chip */
 	snd_soc_card_cht.dev = &pdev->dev;
 	snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
-	if (quirks & QUIRK_PMC_PLT_CLK_0)
+	if (drv->quirks & QUIRK_PMC_PLT_CLK_0)
 		mclk_name = "pmc_plt_clk_0";
 	else
 		mclk_name = "pmc_plt_clk_3";
 		return PTR_ERR(drv->mclk);
 	}
+	/*
+	 * Boards which have the MAX98090's clk connected to clk_0 do not seem
+	 * to like it if we muck with the clock. If we disable the clock when
+	 * it is unused we get "max98090 i2c-193C9890:00: PLL unlocked" errors
+	 * and the PLL never seems to lock again.
+	 * So for these boards we enable it here once and leave it at that.
+	 */
+	if (drv->quirks & QUIRK_PMC_PLT_CLK_0) {
+		ret_val = clk_prepare_enable(drv->mclk);
+		if (ret_val < 0) {
+			dev_err(&pdev->dev, "MCLK enable error: %d\n", ret_val);
+			return ret_val;
+		}
+	}
 	ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
 	if (ret_val) {
 		dev_err(&pdev->dev,
 	return ret_val;
 }
+static int snd_cht_mc_remove(struct platform_device *pdev)
+{
+	struct snd_soc_card *card = platform_get_drvdata(pdev);
+	struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
+	if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
+		clk_disable_unprepare(ctx->mclk);
+	return 0;
+}
 static struct platform_driver snd_cht_mc_driver = {
 	.driver = {
 		.name = "cht-bsw-max98090",
 	},
 	.probe = snd_cht_mc_probe,
+	.remove = snd_cht_mc_remove,
 };
 module_platform_driver(snd_cht_mc_driver)

sound/soc/intel/boards/kbl_rt5663_rt5514_max98927.c+1−1

@@ -405,7 +405,7 @@ static const struct snd_pcm_hw_constraint_list constraints_dmic_channels = { · 404 unmodified lines
405	};	405	};
406		406
407	static const unsigned int dmic_2ch[] = {	407	static const unsigned int dmic_2ch[] = {
408	4,	408	2,
409	};	409	};
410		410
411	static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {	411	static const struct snd_pcm_hw_constraint_list constraints_dmic_2ch = {

sound/soc/intel/skylake/skl-messages.c+1−0

@@ -483,6 +483,7 @@ static void skl_set_base_module_format(struct skl_sst *ctx, · 482 unmodified lines
483	base_cfg->audio_fmt.bit_depth = format->bit_depth;	483	base_cfg->audio_fmt.bit_depth = format->bit_depth;
484	base_cfg->audio_fmt.valid_bit_depth = format->valid_bit_depth;	484	base_cfg->audio_fmt.valid_bit_depth = format->valid_bit_depth;
485	base_cfg->audio_fmt.ch_cfg = format->ch_cfg;	485	base_cfg->audio_fmt.ch_cfg = format->ch_cfg;
		486	base_cfg->audio_fmt.sample_type = format->sample_type;
486		487
487	dev_dbg(ctx->dev, "bit_depth=%x valid_bd=%x ch_config=%x\n",	488	dev_dbg(ctx->dev, "bit_depth=%x valid_bd=%x ch_config=%x\n",
488	format->bit_depth, format->valid_bit_depth,	489	format->bit_depth, format->valid_bit_depth,

sound/soc/intel/skylake/skl-pcm.c+22−6

 	struct hdac_stream *hstream;
 	struct hdac_ext_stream *stream;
 	struct hdac_ext_link *link;
+	unsigned char stream_tag;
 	hstream = snd_hdac_get_stream(bus, params->stream,
 					params->link_dma_id + 1);
 	snd_hdac_ext_link_stream_setup(stream, format_val);
-	list_for_each_entry(link, &bus->hlink_list, list) {
+	stream_tag = hstream->stream_tag;
-		if (link->index == params->link_index)
+	if (stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK) {
-			snd_hdac_ext_link_set_stream_id(link,
+		list_for_each_entry(link, &bus->hlink_list, list) {
-					hstream->stream_tag);
+			if (link->index == params->link_index)
+				snd_hdac_ext_link_set_stream_id(link,
+								stream_tag);
+		}
 	}
 	stream->link_prepared = 1;
 	struct hdac_ext_stream *link_dev =
 				snd_soc_dai_get_dma_data(dai, substream);
 	struct hdac_ext_link *link;
+	unsigned char stream_tag;
 	dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
 	if (!link)
 		return -EINVAL;
-	snd_hdac_ext_link_clear_stream_id(link, hdac_stream(link_dev)->stream_tag);
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+		stream_tag = hdac_stream(link_dev)->stream_tag;
+		snd_hdac_ext_link_clear_stream_id(link, stream_tag);
+	}
 	snd_hdac_ext_stream_release(link_dev, HDAC_EXT_STREAM_TYPE_LINK);
 	return 0;
 }
 	return 0;
 }
+static void skl_pcm_remove(struct snd_soc_component *component)
+{
+	/* remove topology */
+	snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
+}
 static const struct snd_soc_component_driver skl_component  = {
 	.name		= "pcm",
 	.probe		= skl_platform_soc_probe,
+	.remove		= skl_pcm_remove,
 	.ops		= &skl_platform_ops,
 	.pcm_new	= skl_pcm_new,
 	.pcm_free	= skl_pcm_free,
-	.ignore_module_refcount = 1, /* do not increase the refcount in core */
+	.module_get_upon_open = 1, /* increment refcount when a pcm is opened */
 };
 int skl_platform_register(struct device *dev)

sound/soc/mediatek/common/mtk-btcvsd.c+68−1

@@ -49,6 +49,7 @@ enum bt_sco_state { · 48 unmodified lines
49	BT_SCO_STATE_IDLE,	49	BT_SCO_STATE_IDLE,
50	BT_SCO_STATE_RUNNING,	50	BT_SCO_STATE_RUNNING,
51	BT_SCO_STATE_ENDING,	51	BT_SCO_STATE_ENDING,
		52	BT_SCO_STATE_LOOPBACK,
52	};	53	};
53		54
54	enum bt_sco_direct {	55	enum bt_sco_direct {
@@ -486,7 +487,8 @@ static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev) · 431 unmodified lines
486	if (bt->rx->state != BT_SCO_STATE_RUNNING &&	487	if (bt->rx->state != BT_SCO_STATE_RUNNING &&
487	bt->rx->state != BT_SCO_STATE_ENDING &&	488	bt->rx->state != BT_SCO_STATE_ENDING &&
488	bt->tx->state != BT_SCO_STATE_RUNNING &&	489	bt->tx->state != BT_SCO_STATE_RUNNING &&
489	bt->tx->state != BT_SCO_STATE_ENDING) {	490	bt->tx->state != BT_SCO_STATE_ENDING &&
		491	bt->tx->state != BT_SCO_STATE_LOOPBACK) {
490	dev_warn(bt->dev, "%s(), in idle state: rx->state: %d, tx->state: %d\n",	492	dev_warn(bt->dev, "%s(), in idle state: rx->state: %d, tx->state: %d\n",
491	__func__, bt->rx->state, bt->tx->state);	493	__func__, bt->rx->state, bt->tx->state);
492	goto irq_handler_exit;	494	goto irq_handler_exit;
@@ -512,6 +514,42 @@ static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev) · 19 unmodified lines
512	buf_cnt_tx = btsco_packet_info[packet_type][2];	514	buf_cnt_tx = btsco_packet_info[packet_type][2];
513	buf_cnt_rx = btsco_packet_info[packet_type][3];	515	buf_cnt_rx = btsco_packet_info[packet_type][3];
514		516
		517	if (bt->tx->state == BT_SCO_STATE_LOOPBACK) {
		518	u8 src, dst;
		519	unsigned long connsys_addr_rx, ap_addr_rx;
		520	unsigned long connsys_addr_tx, ap_addr_tx;
		521
		522	connsys_addr_rx = *bt->bt_reg_pkt_r;
		523	ap_addr_rx = (unsigned long)bt->bt_sram_bank2_base +
		524	(connsys_addr_rx & 0xFFFF);
		525
		526	connsys_addr_tx = *bt->bt_reg_pkt_w;
		527	ap_addr_tx = (unsigned long)bt->bt_sram_bank2_base +
		528	(connsys_addr_tx & 0xFFFF);
		529
		530	if (connsys_addr_tx == 0xdeadfeed \|\|
		531	connsys_addr_rx == 0xdeadfeed) {
		532	/* bt return 0xdeadfeed if read reg during bt sleep */
		533	dev_warn(bt->dev, "%s(), connsys_addr_tx == 0xdeadfeed\n",
		534	__func__);
		535	goto irq_handler_exit;
		536	}
		537
		538	src = (u8 *)ap_addr_rx;
		539	dst = (u8 *)ap_addr_tx;
		540
		541	mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
		542	bt->tx->temp_packet_buf,
		543	packet_length,
		544	packet_num);
		545	mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
		546	bt->tx->temp_packet_buf, dst,
		547	packet_length,
		548	packet_num);
		549	bt->rx->rw_cnt++;
		550	bt->tx->rw_cnt++;
		551	}
		552
515	if (bt->rx->state == BT_SCO_STATE_RUNNING \|\|	553	if (bt->rx->state == BT_SCO_STATE_RUNNING \|\|
516	bt->rx->state == BT_SCO_STATE_ENDING) {	554	bt->rx->state == BT_SCO_STATE_ENDING) {
517	if (bt->rx->xrun) {	555	if (bt->rx->xrun) {
@@ -1067,6 +1105,33 @@ static int btcvsd_band_set(struct snd_kcontrol *kcontrol, · 549 unmodified lines
1067	return 0;	1105	return 0;
1068	}	1106	}
1069		1107
		1108	static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol,
		1109	struct snd_ctl_elem_value *ucontrol)
		1110	{
		1111	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		1112	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
		1113	bool lpbk_en = bt->tx->state == BT_SCO_STATE_LOOPBACK;
		1114
		1115	ucontrol->value.integer.value[0] = lpbk_en;
		1116	return 0;
		1117	}
		1118
		1119	static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol,
		1120	struct snd_ctl_elem_value *ucontrol)
		1121	{
		1122	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		1123	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
		1124
		1125	if (ucontrol->value.integer.value[0]) {
		1126	mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_LOOPBACK);
		1127	mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_LOOPBACK);
		1128	} else {
		1129	mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_RUNNING);
		1130	mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_RUNNING);
		1131	}
		1132	return 0;
		1133	}
		1134
1070	static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,	1135	static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,
1071	struct snd_ctl_elem_value *ucontrol)	1136	struct snd_ctl_elem_value *ucontrol)
1072	{	1137	{
@@ -1202,6 +1267,8 @@ static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol, · 129 unmodified lines
1202	static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = {	1267	static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = {
1203	SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0],	1268	SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0],
1204	btcvsd_band_get, btcvsd_band_set),	1269	btcvsd_band_get, btcvsd_band_set),
		1270	SOC_SINGLE_BOOL_EXT("BTCVSD Loopback Switch", 0,
		1271	btcvsd_loopback_get, btcvsd_loopback_set),
1205	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0,	1272	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0,
1206	btcvsd_tx_mute_get, btcvsd_tx_mute_set),	1273	btcvsd_tx_mute_get, btcvsd_tx_mute_set),
1207	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0,	1274	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0,

sound/soc/mediatek/mt8183/mt8183-afe-clk.c+4−0

 	int m_sel_id = mck_div[mck_id].m_sel_id;
 	int div_clk_id = mck_div[mck_id].div_clk_id;
+	/* i2s5 mck not support */
+	if (mck_id == MT8183_I2S5_MCK)
+		return;
 	clk_disable_unprepare(afe_priv->clk[div_clk_id]);
 	if (m_sel_id >= 0)
 		clk_disable_unprepare(afe_priv->clk[m_sel_id]);

sound/soc/rockchip/rockchip_pdm.c+3−1

 #include "rockchip_pdm.h"
-#define PDM_DMA_BURST_SIZE	(16) /* size * width: 16*4 = 64 bytes */
+#define PDM_DMA_BURST_SIZE	(8) /* size * width: 8*4 = 32 bytes */
 struct rk_pdm_dev {
 	struct device *dev;
 		return -EINVAL;
 	}
+	pm_runtime_get_sync(cpu_dai->dev);
 	regmap_update_bits(pdm->regmap, PDM_CLK_CTRL, mask, val);
+	pm_runtime_put(cpu_dai->dev);
 	return 0;
 }

sound/soc/samsung/i2s.c+6−4

 };
 static const struct snd_soc_dapm_route samsung_i2s_dapm_routes[] = {
-	{ "Playback Mixer", NULL, "Primary" },
+	{ "Playback Mixer", NULL, "Primary Playback" },
-	{ "Playback Mixer", NULL, "Secondary" },
+	{ "Playback Mixer", NULL, "Secondary Playback" },
 	{ "Mixer DAI TX", NULL, "Playback Mixer" },
-	{ "Playback Mixer", NULL, "Mixer DAI RX" },
+	{ "Primary Capture", NULL, "Mixer DAI RX" },
 };
 static const struct snd_soc_component_driver samsung_i2s_component = {
 			  int num_dais)
 {
 	static const char *dai_names[] = { "samsung-i2s", "samsung-i2s-sec" };
-	static const char *stream_names[] = { "Primary", "Secondary" };
+	static const char *stream_names[] = { "Primary Playback",
+					      "Secondary Playback" };
 	struct snd_soc_dai_driver *dai_drv;
 	struct i2s_dai *dai;
 	int i;
 	dai_drv->capture.channels_max = 2;
 	dai_drv->capture.rates = i2s_dai_data->pcm_rates;
 	dai_drv->capture.formats = SAMSUNG_I2S_FMTS;
+	dai_drv->capture.stream_name = "Primary Capture";
 	return 0;
 }

sound/soc/samsung/odroid.c+2−2

@@ -91,11 +91,11 @@ static int odroid_card_be_hw_params(struct snd_pcm_substream *substream, · 90 unmodified lines
91	return ret;	91	return ret;
92		92
93	/*	93	/*
94	* We add 1 to the rclk_freq value in order to avoid too low clock	94	* We add 2 to the rclk_freq value in order to avoid too low clock
95	* frequency values due to the EPLL output frequency not being exact	95	* frequency values due to the EPLL output frequency not being exact
96	* multiple of the audio sampling rate.	96	* multiple of the audio sampling rate.
97	*/	97	*/
98	rclk_freq = params_rate(params) * rfs + 1;	98	rclk_freq = params_rate(params) * rfs + 2;
99		99
100	ret = clk_set_rate(priv->sclk_i2s, rclk_freq);	100	ret = clk_set_rate(priv->sclk_i2s, rclk_freq);
101	if (ret < 0)	101	if (ret < 0)

sound/soc/sh/rcar/core.c+2−0

 	{ .compatible = "renesas,rcar_sound-gen1", .data = (void *)RSND_GEN1 },
 	{ .compatible = "renesas,rcar_sound-gen2", .data = (void *)RSND_GEN2 },
 	{ .compatible = "renesas,rcar_sound-gen3", .data = (void *)RSND_GEN3 },
+	/* Special Handling */
+	{ .compatible = "renesas,rcar_sound-r8a77990", .data = (void *)(RSND_GEN3 | RSND_SOC_E) },
 	{},
 };
 MODULE_DEVICE_TABLE(of, rsnd_of_match);

sound/soc/sh/rcar/rsnd.h+5−0

 #define RSND_GEN1	(1 << 0)
 #define RSND_GEN2	(2 << 0)
 #define RSND_GEN3	(3 << 0)
+#define RSND_SOC_MASK	(0xFF << 4)
+#define RSND_SOC_E	(1 << 4) /* E1/E2/E3 */
 	/*
 	 * below value will be filled on rsnd_gen_probe()
 #define rsnd_is_gen1(priv)	(((priv)->flags & RSND_GEN_MASK) == RSND_GEN1)
 #define rsnd_is_gen2(priv)	(((priv)->flags & RSND_GEN_MASK) == RSND_GEN2)
 #define rsnd_is_gen3(priv)	(((priv)->flags & RSND_GEN_MASK) == RSND_GEN3)
+#define rsnd_is_e3(priv)	(((priv)->flags & \
+					(RSND_GEN_MASK | RSND_SOC_MASK)) == \
+					(RSND_GEN3 | RSND_SOC_E))
 #define rsnd_flags_has(p, f) ((p)->flags & (f))
 #define rsnd_flags_set(p, f) ((p)->flags |= (f))

sound/soc/sh/rcar/src.c+7−14

  */
 #include "rsnd.h"
-#include <linux/sys_soc.h>
 #define SRC_NAME "src"
 	return rate;
 }
-const static u32 bsdsr_table_pattern1[] = {
+static const u32 bsdsr_table_pattern1[] = {
 	0x01800000, /* 6 - 1/6 */
 	0x01000000, /* 6 - 1/4 */
 	0x00c00000, /* 6 - 1/3 */
 	0x00400000, /* 6 - 1   */
 };
-const static u32 bsdsr_table_pattern2[] = {
+static const u32 bsdsr_table_pattern2[] = {
 	0x02400000, /* 6 - 1/6 */
 	0x01800000, /* 6 - 1/4 */
 	0x01200000, /* 6 - 1/3 */
 	0x00600000, /* 6 - 1   */
 };
-const static u32 bsisr_table[] = {
+static const u32 bsisr_table[] = {
 	0x00100060, /* 6 - 1/6 */
 	0x00100040, /* 6 - 1/4 */
 	0x00100030, /* 6 - 1/3 */
 	0x00100020, /* 6 - 1   */
 };
-const static u32 chan288888[] = {
+static const u32 chan288888[] = {
 	0x00000006, /* 1 to 2 */
 	0x000001fe, /* 1 to 8 */
 	0x000001fe, /* 1 to 8 */
 	0x000001fe, /* 1 to 8 */
 };
-const static u32 chan244888[] = {
+static const u32 chan244888[] = {
 	0x00000006, /* 1 to 2 */
 	0x0000001e, /* 1 to 4 */
 	0x0000001e, /* 1 to 4 */
 	0x000001fe, /* 1 to 8 */
 };
-const static u32 chan222222[] = {
+static const u32 chan222222[] = {
 	0x00000006, /* 1 to 2 */
 	0x00000006, /* 1 to 2 */
 	0x00000006, /* 1 to 2 */
 	0x00000006, /* 1 to 2 */
 };
-static const struct soc_device_attribute ov_soc[] = {
-	{ .soc_id = "r8a77990" }, /* E3 */
-	{ /* sentinel */ }
-};
 static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io,
 				      struct rsnd_mod *mod)
 {
 	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 	struct device *dev = rsnd_priv_to_dev(priv);
 	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
-	const struct soc_device_attribute *soc = soc_device_match(ov_soc);
 	int is_play = rsnd_io_is_play(io);
 	int use_src = 0;
 	u32 fin, fout;
 	/*
 	 * E3 need to overwrite
 	 */
-	if (soc)
+	if (rsnd_is_e3(priv))
 		switch (rsnd_mod_id(mod)) {
 		case 0:
 		case 4:

sound/soc/soc-core.c+4−2

 	snd_soc_dapm_free(snd_soc_component_get_dapm(component));
 	soc_cleanup_component_debugfs(component);
 	component->card = NULL;
-	if (!component->driver->ignore_module_refcount)
+	if (!component->driver->module_get_upon_open)
 		module_put(component->dev->driver->owner);
 }
 		return 0;
 	}
-	if (!component->driver->ignore_module_refcount &&
+	if (!component->driver->module_get_upon_open &&
 	    !try_module_get(component->dev->driver->owner))
 		return -ENODEV;
 		ret = soc_init_dai_link(card, link);
 		if (ret) {
+			soc_cleanup_platform(card);
 			dev_err(card->dev, "ASoC: failed to init link %s\n",
 				link->name);
 			mutex_unlock(&client_mutex);
 	card->instantiated = 0;
 	mutex_init(&card->mutex);
 	mutex_init(&card->dapm_mutex);
+	spin_lock_init(&card->dpcm_lock);
 	return snd_soc_bind_card(card);
 }

sound/soc/soc-dapm.c+11−0

 	case snd_soc_dapm_dac:
 	case snd_soc_dapm_aif_in:
 	case snd_soc_dapm_pga:
+	case snd_soc_dapm_buffer:
+	case snd_soc_dapm_scheduler:
+	case snd_soc_dapm_effect:
+	case snd_soc_dapm_src:
+	case snd_soc_dapm_asrc:
+	case snd_soc_dapm_encoder:
+	case snd_soc_dapm_decoder:
 	case snd_soc_dapm_out_drv:
 	case snd_soc_dapm_micbias:
 	case snd_soc_dapm_line:
 	int count;
 	devm_kfree(card->dev, (void *)*private_value);
+	if (!w_param_text)
+		return;
 	for (count = 0 ; count < num_params; count++)
 		devm_kfree(card->dev, (void *)w_param_text[count]);
 	devm_kfree(card->dev, w_param_text);

sound/soc/soc-pcm.c+55−11

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/delay.h>	15	#include <linux/delay.h>
16	#include <linux/pinctrl/consumer.h>	16	#include <linux/pinctrl/consumer.h>
17	#include <linux/pm_runtime.h>	17	#include <linux/pm_runtime.h>
		18	#include <linux/module.h>
18	#include <linux/slab.h>	19	#include <linux/slab.h>
19	#include <linux/workqueue.h>	20	#include <linux/workqueue.h>
20	#include <linux/export.h>	21	#include <linux/export.h>
@@ -463,6 +464,9 @@ static int soc_pcm_components_close(struct snd_pcm_substream *substream, · 442 unmodified lines
463	continue;	464	continue;
464		465
465	component->driver->ops->close(substream);	466	component->driver->ops->close(substream);
		467
		468	if (component->driver->module_get_upon_open)
		469	module_put(component->dev->driver->owner);
466	}	470	}
467		471
468	return 0;	472	return 0;
@@ -513,6 +517,12 @@ static int soc_pcm_open(struct snd_pcm_substream *substream) · 44 unmodified lines
513	!component->driver->ops->open)	517	!component->driver->ops->open)
514	continue;	518	continue;
515		519
		520	if (component->driver->module_get_upon_open &&
		521	!try_module_get(component->dev->driver->owner)) {
		522	ret = -ENODEV;
		523	goto module_err;
		524	}
		525
516	ret = component->driver->ops->open(substream);	526	ret = component->driver->ops->open(substream);
517	if (ret < 0) {	527	if (ret < 0) {
518	dev_err(component->dev,	528	dev_err(component->dev,
@@ -628,7 +638,7 @@ codec_dai_err: · 109 unmodified lines
628		638
629	component_err:	639	component_err:
630	soc_pcm_components_close(substream, component);	640	soc_pcm_components_close(substream, component);
631		641	module_err:
632	if (cpu_dai->driver->ops->shutdown)	642	if (cpu_dai->driver->ops->shutdown)
633	cpu_dai->driver->ops->shutdown(substream, cpu_dai);	643	cpu_dai->driver->ops->shutdown(substream, cpu_dai);
634	out:	644	out:
@@ -954,10 +964,13 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream, · 319 unmodified lines
954	codec_params = *params;	964	codec_params = *params;
955		965
956	/* fixup params based on TDM slot masks */	966	/* fixup params based on TDM slot masks */
957	if (codec_dai->tx_mask)	967	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
		968	codec_dai->tx_mask)
958	soc_pcm_codec_params_fixup(&codec_params,	969	soc_pcm_codec_params_fixup(&codec_params,
959	codec_dai->tx_mask);	970	codec_dai->tx_mask);
960	if (codec_dai->rx_mask)	971
		972	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
		973	codec_dai->rx_mask)
961	soc_pcm_codec_params_fixup(&codec_params,	974	soc_pcm_codec_params_fixup(&codec_params,
962	codec_dai->rx_mask);	975	codec_dai->rx_mask);
963		976
@@ -1213,6 +1226,7 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe, · 249 unmodified lines
1213	struct snd_soc_pcm_runtime *be, int stream)	1226	struct snd_soc_pcm_runtime *be, int stream)
1214	{	1227	{
1215	struct snd_soc_dpcm *dpcm;	1228	struct snd_soc_dpcm *dpcm;
		1229	unsigned long flags;
1216		1230
1217	/* only add new dpcms */	1231	/* only add new dpcms */
1218	for_each_dpcm_be(fe, stream, dpcm) {	1232	for_each_dpcm_be(fe, stream, dpcm) {
@@ -1228,8 +1242,10 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe, · 9 unmodified lines
1228	dpcm->fe = fe;	1242	dpcm->fe = fe;
1229	be->dpcm[stream].runtime = fe->dpcm[stream].runtime;	1243	be->dpcm[stream].runtime = fe->dpcm[stream].runtime;
1230	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;	1244	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
		1245	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
1231	list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);	1246	list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
1232	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);	1247	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
		1248	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
1233		1249
1234	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",	1250	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
1235	stream ? "capture" : "playback", fe->dai_link->name,	1251	stream ? "capture" : "playback", fe->dai_link->name,
@@ -1275,6 +1291,7 @@ static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe, · 39 unmodified lines
1275	void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)	1291	void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
1276	{	1292	{
1277	struct snd_soc_dpcm dpcm, d;	1293	struct snd_soc_dpcm dpcm, d;
		1294	unsigned long flags;
1278		1295
1279	for_each_dpcm_be_safe(fe, stream, dpcm, d) {	1296	for_each_dpcm_be_safe(fe, stream, dpcm, d) {
1280	dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",	1297	dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
@@ -1294,8 +1311,10 @@ void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream) · 13 unmodified lines
1294	#ifdef CONFIG_DEBUG_FS	1311	#ifdef CONFIG_DEBUG_FS
1295	debugfs_remove(dpcm->debugfs_state);	1312	debugfs_remove(dpcm->debugfs_state);
1296	#endif	1313	#endif
		1314	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
1297	list_del(&dpcm->list_be);	1315	list_del(&dpcm->list_be);
1298	list_del(&dpcm->list_fe);	1316	list_del(&dpcm->list_fe);
		1317	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
1299	kfree(dpcm);	1318	kfree(dpcm);
1300	}	1319	}
1301	}	1320	}
@@ -1547,10 +1566,13 @@ int dpcm_process_paths(struct snd_soc_pcm_runtime *fe, · 245 unmodified lines
1547	void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)	1566	void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
1548	{	1567	{
1549	struct snd_soc_dpcm *dpcm;	1568	struct snd_soc_dpcm *dpcm;
		1569	unsigned long flags;
1550		1570
		1571	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
1551	for_each_dpcm_be(fe, stream, dpcm)	1572	for_each_dpcm_be(fe, stream, dpcm)
1552	dpcm->be->dpcm[stream].runtime_update =	1573	dpcm->be->dpcm[stream].runtime_update =
1553	SND_SOC_DPCM_UPDATE_NO;	1574	SND_SOC_DPCM_UPDATE_NO;
		1575	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
1554	}	1576	}
1555		1577
1556	static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime *fe,	1578	static void dpcm_be_dai_startup_unwind(struct snd_soc_pcm_runtime *fe,
@@ -1899,10 +1921,15 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream, · 342 unmodified lines
1899	struct snd_soc_pcm_runtime *be = dpcm->be;	1921	struct snd_soc_pcm_runtime *be = dpcm->be;
1900	struct snd_pcm_substream *be_substream =	1922	struct snd_pcm_substream *be_substream =
1901	snd_soc_dpcm_get_substream(be, stream);	1923	snd_soc_dpcm_get_substream(be, stream);
1902	struct snd_soc_pcm_runtime *rtd = be_substream->private_data;	1924	struct snd_soc_pcm_runtime *rtd;
1903	struct snd_soc_dai *codec_dai;	1925	struct snd_soc_dai *codec_dai;
1904	int i;	1926	int i;
1905		1927
		1928	/* A backend may not have the requested substream */
		1929	if (!be_substream)
		1930	continue;
		1931
		1932	rtd = be_substream->private_data;
1906	if (rtd->dai_link->be_hw_params_fixup)	1933	if (rtd->dai_link->be_hw_params_fixup)
1907	continue;	1934	continue;
1908		1935
@@ -2571,6 +2598,7 @@ static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream) · 662 unmodified lines
2571	struct snd_soc_dpcm *dpcm;	2598	struct snd_soc_dpcm *dpcm;
2572	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];	2599	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2573	int ret;	2600	int ret;
		2601	unsigned long flags;
2574		2602
2575	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",	2603	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
2576	stream ? "capture" : "playback", fe->dai_link->name);	2604	stream ? "capture" : "playback", fe->dai_link->name);
@@ -2640,11 +2668,13 @@ close: · 63 unmodified lines
2640	dpcm_be_dai_shutdown(fe, stream);	2668	dpcm_be_dai_shutdown(fe, stream);
2641	disconnect:	2669	disconnect:
2642	/* disconnect any non started BEs */	2670	/* disconnect any non started BEs */
		2671	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
2643	for_each_dpcm_be(fe, stream, dpcm) {	2672	for_each_dpcm_be(fe, stream, dpcm) {
2644	struct snd_soc_pcm_runtime *be = dpcm->be;	2673	struct snd_soc_pcm_runtime *be = dpcm->be;
2645	if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)	2674	if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2646	dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;	2675	dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2647	}	2676	}
		2677	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
2648		2678
2649	return ret;	2679	return ret;
2650	}	2680	}
@@ -3221,7 +3251,10 @@ int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe, · 570 unmodified lines
3221	{	3251	{
3222	struct snd_soc_dpcm *dpcm;	3252	struct snd_soc_dpcm *dpcm;
3223	int state;	3253	int state;
		3254	int ret = 1;
		3255	unsigned long flags;
3224		3256
		3257	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
3225	for_each_dpcm_fe(be, stream, dpcm) {	3258	for_each_dpcm_fe(be, stream, dpcm) {
3226		3259
3227	if (dpcm->fe == fe)	3260	if (dpcm->fe == fe)
@@ -3230,12 +3263,15 @@ int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe, · 2 unmodified lines
3230	state = dpcm->fe->dpcm[stream].state;	3263	state = dpcm->fe->dpcm[stream].state;
3231	if (state == SND_SOC_DPCM_STATE_START \|\|	3264	if (state == SND_SOC_DPCM_STATE_START \|\|
3232	state == SND_SOC_DPCM_STATE_PAUSED \|\|	3265	state == SND_SOC_DPCM_STATE_PAUSED \|\|
3233	state == SND_SOC_DPCM_STATE_SUSPEND)	3266	state == SND_SOC_DPCM_STATE_SUSPEND) {
3234	return 0;	3267	ret = 0;
		3268	break;
		3269	}
3235	}	3270	}
		3271	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
3236		3272
3237	/* it's safe to free/stop this BE DAI */	3273	/* it's safe to free/stop this BE DAI */
3238	return 1;	3274	return ret;
3239	}	3275	}
3240	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);	3276	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);
3241		3277
@@ -3248,7 +3284,10 @@ int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe, · 6 unmodified lines
3248	{	3284	{
3249	struct snd_soc_dpcm *dpcm;	3285	struct snd_soc_dpcm *dpcm;
3250	int state;	3286	int state;
		3287	int ret = 1;
		3288	unsigned long flags;
3251		3289
		3290	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
3252	for_each_dpcm_fe(be, stream, dpcm) {	3291	for_each_dpcm_fe(be, stream, dpcm) {
3253		3292
3254	if (dpcm->fe == fe)	3293	if (dpcm->fe == fe)
@@ -3258,12 +3297,15 @@ int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe, · 3 unmodified lines
3258	if (state == SND_SOC_DPCM_STATE_START \|\|	3297	if (state == SND_SOC_DPCM_STATE_START \|\|
3259	state == SND_SOC_DPCM_STATE_PAUSED \|\|	3298	state == SND_SOC_DPCM_STATE_PAUSED \|\|
3260	state == SND_SOC_DPCM_STATE_SUSPEND \|\|	3299	state == SND_SOC_DPCM_STATE_SUSPEND \|\|
3261	state == SND_SOC_DPCM_STATE_PREPARE)	3300	state == SND_SOC_DPCM_STATE_PREPARE) {
3262	return 0;	3301	ret = 0;
		3302	break;
		3303	}
3263	}	3304	}
		3305	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
3264		3306
3265	/* it's safe to change hw_params */	3307	/* it's safe to change hw_params */
3266	return 1;	3308	return ret;
3267	}	3309	}
3268	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);	3310	EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
3269		3311
@@ -3302,6 +3344,7 @@ static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, · 32 unmodified lines
3302	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;	3344	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
3303	struct snd_soc_dpcm *dpcm;	3345	struct snd_soc_dpcm *dpcm;
3304	ssize_t offset = 0;	3346	ssize_t offset = 0;
		3347	unsigned long flags;
3305		3348
3306	/* FE state */	3349	/* FE state */
3307	offset += snprintf(buf + offset, size - offset,	3350	offset += snprintf(buf + offset, size - offset,
@@ -3329,6 +3372,7 @@ static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, · 21 unmodified lines
3329	goto out;	3372	goto out;
3330	}	3373	}
3331		3374
		3375	spin_lock_irqsave(&fe->card->dpcm_lock, flags);
3332	for_each_dpcm_be(fe, stream, dpcm) {	3376	for_each_dpcm_be(fe, stream, dpcm) {
3333	struct snd_soc_pcm_runtime *be = dpcm->be;	3377	struct snd_soc_pcm_runtime *be = dpcm->be;
3334	params = &dpcm->hw_params;	3378	params = &dpcm->hw_params;
@@ -3349,7 +3393,7 @@ static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe, · 14 unmodified lines
3349	params_channels(params),	3393	params_channels(params),
3350	params_rate(params));	3394	params_rate(params));
3351	}	3395	}
3352		3396	spin_unlock_irqrestore(&fe->card->dpcm_lock, flags);
3353	out:	3397	out:
3354	return offset;	3398	return offset;
3355	}	3399	}

sound/soc/soc-topology.c+4−3

 			snd_ctl_remove(card, kcontrol);
-			kfree(dobj->control.dvalues);
+			/* free enum kcontrol's dvalues and dtexts */
+			kfree(se->dobj.control.dvalues);
 			for (j = 0; j < se->items; j++)
-				kfree(dobj->control.dtexts[j]);
+				kfree(se->dobj.control.dtexts[j]);
-			kfree(dobj->control.dtexts);
+			kfree(se->dobj.control.dtexts);
 			kfree(se);
 			kfree(w->kcontrol_news[i].name);

sound/soc/stm/stm32_adfsdm.c+34−4

 #include <linux/clk.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 	/* PCM buffer */
 	unsigned char *pcm_buff;
 	unsigned int pos;
+	struct mutex lock; /* protect against race condition on iio state */
 };
 static const struct snd_pcm_hardware stm32_adfsdm_pcm_hw = {
 {
 	struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
+	mutex_lock(&priv->lock);
 	if (priv->iio_active) {
 		iio_channel_stop_all_cb(priv->iio_cb);
 		priv->iio_active = false;
 	}
+	mutex_unlock(&priv->lock);
 }
 static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream,
 	struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
 	int ret;
+	mutex_lock(&priv->lock);
+	if (priv->iio_active) {
+		iio_channel_stop_all_cb(priv->iio_cb);
+		priv->iio_active = false;
+	}
 	ret = iio_write_channel_attribute(priv->iio_ch,
 					  substream->runtime->rate, 0,
 					  IIO_CHAN_INFO_SAMP_FREQ);
 	if (ret < 0) {
 		dev_err(dai->dev, "%s: Failed to set %d sampling rate\n",
 			__func__, substream->runtime->rate);
-		return ret;
+		goto out;
 	}
 	if (!priv->iio_active) {
 				__func__, ret);
 	}
+out:
+	mutex_unlock(&priv->lock);
 	return ret;
 }
 static int stm32_adfsdm_probe(struct platform_device *pdev)
 {
 	struct stm32_adfsdm_priv *priv;
+	struct snd_soc_component *component;
 	int ret;
 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 	priv->dev = &pdev->dev;
 	priv->dai_drv = stm32_adfsdm_dai;
+	mutex_init(&priv->lock);
 	dev_set_drvdata(&pdev->dev, priv);
 	if (IS_ERR(priv->iio_cb))
 		return PTR_ERR(priv->iio_cb);
-	ret = devm_snd_soc_register_component(&pdev->dev,
+	component = devm_kzalloc(&pdev->dev, sizeof(*component), GFP_KERNEL);
-					      &stm32_adfsdm_soc_platform,
+	if (!component)
-					      NULL, 0);
+		return -ENOMEM;
+#ifdef CONFIG_DEBUG_FS
+	component->debugfs_prefix = "pcm";
+#endif
+	ret = snd_soc_add_component(&pdev->dev, component,
+				    &stm32_adfsdm_soc_platform, NULL, 0);
 	if (ret < 0)
 		dev_err(&pdev->dev, "%s: Failed to register PCM platform\n",
 			__func__);
 	return ret;
 }
+static int stm32_adfsdm_remove(struct platform_device *pdev)
+{
+	snd_soc_unregister_component(&pdev->dev);
+	return 0;
+}
 static struct platform_driver stm32_adfsdm_driver = {
 	.driver = {
 		   .name = STM32_ADFSDM_DRV_NAME,
 		   .of_match_table = stm32_adfsdm_of_match,
 		   },
 	.probe = stm32_adfsdm_probe,
+	.remove = stm32_adfsdm_remove,
 };
 module_platform_driver(stm32_adfsdm_driver);

sound/soc/stm/stm32_i2s.c+1−2

 	case STM32_I2S_CFG2_REG:
 	case STM32_I2S_IER_REG:
 	case STM32_I2S_SR_REG:
-	case STM32_I2S_TXDR_REG:
 	case STM32_I2S_RXDR_REG:
 	case STM32_I2S_CGFR_REG:
 		return true;
 static bool stm32_i2s_volatile_reg(struct device *dev, unsigned int reg)
 {
 	switch (reg) {
-	case STM32_I2S_TXDR_REG:
+	case STM32_I2S_SR_REG:
 	case STM32_I2S_RXDR_REG:
 		return true;
 	default:

sound/soc/stm/stm32_sai.c+5−3

 	if (!pdev) {
 		dev_err(&sai_client->pdev->dev,
 			"Device not found for node %pOFn\n", np_provider);
+		of_node_put(np_provider);
 		return -ENODEV;
 	}
 		dev_err(&sai_client->pdev->dev,
 			"SAI sync provider data not found\n");
 		ret = -EINVAL;
-		goto out_put_dev;
+		goto error;
 	}
 	/* Configure sync client */
 	ret = stm32_sai_sync_conf_client(sai_client, synci);
 	if (ret < 0)
-		goto out_put_dev;
+		goto error;
 	/* Configure sync provider */
 	ret = stm32_sai_sync_conf_provider(sai_provider, synco);
-out_put_dev:
+error:
 	put_device(&pdev->dev);
+	of_node_put(np_provider);
 	return ret;
 }

sound/soc/stm/stm32_sai_sub.c+86−28

 #define SAI_IEC60958_STATUS_BYTES	24
 #define SAI_MCLK_NAME_LEN		32
+#define SAI_RATE_11K			11025
 /**
  * struct stm32_sai_sub_data - private data of SAI sub block (block A or B)
  * @slot_mask: rx or tx active slots mask. set at init or at runtime
  * @data_size: PCM data width. corresponds to PCM substream width.
  * @spdif_frm_cnt: S/PDIF playback frame counter
- * @snd_aes_iec958: iec958 data
+ * @iec958: iec958 data
  * @ctrl_lock: control lock
+ * @irq_lock: prevent race condition with IRQ
  */
 struct stm32_sai_sub_data {
 	struct platform_device *pdev;
 	unsigned int spdif_frm_cnt;
 	struct snd_aes_iec958 iec958;
 	struct mutex ctrl_lock; /* protect resources accessed by controls */
+	spinlock_t irq_lock; /* used to prevent race condition with IRQ */
 };
 enum stm32_sai_fifo_th {
 	return ret;
 }
+static int stm32_sai_set_parent_clock(struct stm32_sai_sub_data *sai,
+				      unsigned int rate)
+{
+	struct platform_device *pdev = sai->pdev;
+	struct clk *parent_clk = sai->pdata->clk_x8k;
+	int ret;
+	if (!(rate % SAI_RATE_11K))
+		parent_clk = sai->pdata->clk_x11k;
+	ret = clk_set_parent(sai->sai_ck, parent_clk);
+	if (ret)
+		dev_err(&pdev->dev, " Error %d setting sai_ck parent clock. %s",
+			ret, ret == -EBUSY ?
+			"Active stream rates conflict\n" : "\n");
+	return ret;
+}
 static long stm32_sai_mclk_round_rate(struct clk_hw *hw, unsigned long rate,
 				      unsigned long *prate)
 {
 		status = SNDRV_PCM_STATE_XRUN;
 	}
-	if (status != SNDRV_PCM_STATE_RUNNING)
+	spin_lock(&sai->irq_lock);
+	if (status != SNDRV_PCM_STATE_RUNNING && sai->substream)
 		snd_pcm_stop_xrun(sai->substream);
+	spin_unlock(&sai->irq_lock);
 	return IRQ_HANDLED;
 }
 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 	int ret;
-	if (dir == SND_SOC_CLOCK_OUT) {
+	if (dir == SND_SOC_CLOCK_OUT && sai->sai_mclk) {
 		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX,
 					 SAI_XCR1_NODIV,
 					 (unsigned int)~SAI_XCR1_NODIV);
 		if (ret < 0)
 			return ret;
-		dev_dbg(cpu_dai->dev, "SAI MCLK frequency is %uHz\n", freq);
+		/* If master clock is used, set parent clock now */
-		sai->mclk_rate = freq;
+		ret = stm32_sai_set_parent_clock(sai, freq);
+		if (ret)
+			return ret;
-		if (sai->sai_mclk) {
+		ret = clk_set_rate_exclusive(sai->sai_mclk, freq);
-			ret = clk_set_rate_exclusive(sai->sai_mclk,
+		if (ret) {
-						     sai->mclk_rate);
+			dev_err(cpu_dai->dev,
-			if (ret) {
+				ret == -EBUSY ?
-				dev_err(cpu_dai->dev,
+				"Active streams have incompatible rates" :
-					"Could not set mclk rate\n");
+				"Could not set mclk rate\n");
-				return ret;
+			return ret;
-			}
 		}
+		dev_dbg(cpu_dai->dev, "SAI MCLK frequency is %uHz\n", freq);
+		sai->mclk_rate = freq;
 	}
 	return 0;
 {
 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
 	int imr, cr2, ret;
+	unsigned long flags;
+	spin_lock_irqsave(&sai->irq_lock, flags);
 	sai->substream = substream;
+	spin_unlock_irqrestore(&sai->irq_lock, flags);
+	if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
+		snd_pcm_hw_constraint_mask64(substream->runtime,
+					     SNDRV_PCM_HW_PARAM_FORMAT,
+					     SNDRV_PCM_FMTBIT_S32_LE);
+		snd_pcm_hw_constraint_single(substream->runtime,
+					     SNDRV_PCM_HW_PARAM_CHANNELS, 2);
+	}
 	ret = clk_prepare_enable(sai->sai_ck);
 	if (ret < 0) {
 				     struct snd_pcm_hw_params *params)
 {
 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
-	int div = 0;
+	int div = 0, cr1 = 0;
 	int sai_clk_rate, mclk_ratio, den;
 	unsigned int rate = params_rate(params);
+	int ret;
-	if (!(rate % 11025))
+	if (!sai->sai_mclk) {
-		clk_set_parent(sai->sai_ck, sai->pdata->clk_x11k);
+		ret = stm32_sai_set_parent_clock(sai, rate);
-	else
+		if (ret)
-		clk_set_parent(sai->sai_ck, sai->pdata->clk_x8k);
+			return ret;
+	}
 	sai_clk_rate = clk_get_rate(sai->sai_ck);
 	if (STM_SAI_IS_F4(sai->pdata)) {
 		} else {
 			if (sai->mclk_rate) {
 				mclk_ratio = sai->mclk_rate / rate;
-				if ((mclk_ratio != 512) &&
+				if (mclk_ratio == 512) {
-				    (mclk_ratio != 256)) {
+					cr1 = SAI_XCR1_OSR;
+				} else if (mclk_ratio != 256) {
 					dev_err(cpu_dai->dev,
 						"Wrong mclk ratio %d\n",
 						mclk_ratio);
 					return -EINVAL;
 				}
+				regmap_update_bits(sai->regmap,
+						   STM_SAI_CR1_REGX,
+						   SAI_XCR1_OSR, cr1);
 				div = stm32_sai_get_clk_div(sai, sai_clk_rate,
 							    sai->mclk_rate);
 				if (div < 0)
 			       struct snd_soc_dai *cpu_dai)
 {
 	struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
+	unsigned long flags;
 	regmap_update_bits(sai->regmap, STM_SAI_IMR_REGX, SAI_XIMR_MASK, 0);
 	regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, SAI_XCR1_NODIV,
 			   SAI_XCR1_NODIV);
-	clk_disable_unprepare(sai->sai_ck);
+	/* Release mclk rate only if rate was actually set */
+	if (sai->mclk_rate) {
+		clk_rate_exclusive_put(sai->sai_mclk);
+		sai->mclk_rate = 0;
+	}
-	clk_rate_exclusive_put(sai->sai_mclk);
+	clk_disable_unprepare(sai->sai_ck);
+	spin_lock_irqsave(&sai->irq_lock, flags);
 	sai->substream = NULL;
+	spin_unlock_irqrestore(&sai->irq_lock, flags);
 }
 static int stm32_sai_pcm_new(struct snd_soc_pcm_runtime *rtd,
 			     struct snd_soc_dai *cpu_dai)
 {
 	struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
+	struct snd_kcontrol_new knew = iec958_ctls;
 	if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
 		dev_dbg(&sai->pdev->dev, "%s: register iec controls", __func__);
-		return snd_ctl_add(rtd->pcm->card,
+		knew.device = rtd->pcm->device;
-				   snd_ctl_new1(&iec958_ctls, sai));
+		return snd_ctl_add(rtd->pcm->card, snd_ctl_new1(&knew, sai));
 	}
 	return 0;
 static int stm32_sai_dai_probe(struct snd_soc_dai *cpu_dai)
 {
 	struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
-	int cr1 = 0, cr1_mask;
+	int cr1 = 0, cr1_mask, ret;
 	sai->cpu_dai = cpu_dai;
 	/* Configure synchronization */
 	if (sai->sync == SAI_SYNC_EXTERNAL) {
 		/* Configure synchro client and provider */
-		sai->pdata->set_sync(sai->pdata, sai->np_sync_provider,
+		ret = sai->pdata->set_sync(sai->pdata, sai->np_sync_provider,
-				     sai->synco, sai->synci);
+					   sai->synco, sai->synci);
+		if (ret)
+			return ret;
 	}
 	cr1_mask |= SAI_XCR1_SYNCEN_MASK;
 	if (!sai->cpu_dai_drv)
 		return -ENOMEM;
-	sai->cpu_dai_drv->name = dev_name(&pdev->dev);
 	if (STM_SAI_IS_PLAYBACK(sai)) {
 		memcpy(sai->cpu_dai_drv, &stm32_sai_playback_dai,
 		       sizeof(stm32_sai_playback_dai));
 		       sizeof(stm32_sai_capture_dai));
 		sai->cpu_dai_drv->capture.stream_name = sai->cpu_dai_drv->name;
 	}
+	sai->cpu_dai_drv->name = dev_name(&pdev->dev);
 	return 0;
 }
 	sai->pdev = pdev;
 	mutex_init(&sai->ctrl_lock);
+	spin_lock_init(&sai->irq_lock);
 	platform_set_drvdata(pdev, sai);
 	sai->pdata = dev_get_drvdata(pdev->dev.parent);

sound/xen/xen_snd_front_alsa.c+1−1

@@ -441,7 +441,7 @@ static int shbuf_setup_backstore(struct xen_snd_front_pcm_stream_info *stream, · 440 unmodified lines
441	{	441	{
442	int i;	442	int i;
443		443
444	stream->buffer = alloc_pages_exact(stream->buffer_sz, GFP_KERNEL);	444	stream->buffer = alloc_pages_exact(buffer_sz, GFP_KERNEL);
445	if (!stream->buffer)	445	if (!stream->buffer)
446	return -ENOMEM;	446	return -ENOMEM;
447		447