Major fix for headphone/headset - apparently the prepare op can be

called multiple times - but the setup verbs need to be sent only once,
in particular for headphones/headset.
This should restore headphone/headset working to state before later
kernels, in particular version 6 kernels, with pipewire as the
primary audio daemon.

Author: Src User

patch_cirrus/patch_cirrus_apple.h

@@ -541,6 +541,9 @@ struct cs8409_apple_spec {
 	int play_init;
 	int capture_init;
 
+        int play_init_count;
+        int capture_init_count;
+
 	// new item to limit times we redo unmute/play
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
 	struct timespec64 last_play_time;
@@ -701,9 +704,9 @@ static int cs_8409_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 {
         struct hda_gen_spec *spec = codec->spec;
         int err;
-        mycodec_dbg(codec, "cs_8409_playback_pcm_prepare\n");
+        mycodec_info(codec, "cs_8409_playback_pcm_prepare\n");
 
-        mycodec_dbg(codec, "cs_8409_playback_pcm_prepare: NID=0x%x, stream=0x%x, format=0x%x\n",
+        mycodec_info(codec, "cs_8409_playback_pcm_prepare: NID=0x%x, stream=0x%x, format=0x%x\n",
                   hinfo->nid, stream_tag, format);
 
         cs_8409_pcm_playback_pre_prepare_hook(hinfo, codec, stream_tag, format, substream,
@@ -727,6 +730,7 @@ static int cs_8409_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
         if (!err)
                 if (spec->pcm_playback_hook)
                         spec->pcm_playback_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
+        mycodec_info(codec, "cs_8409_playback_pcm_prepare end\n");
         return err;
 }
 
@@ -747,9 +751,9 @@ static int cs_8409_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 {
         struct cs8409_apple_spec *spec = codec->spec;
 
-        mycodec_dbg(codec, "cs_8409_capture_pcm_prepare\n");
+        mycodec_info(codec, "cs_8409_capture_pcm_prepare\n");
 
-        mycodec_dbg(codec, "cs_8409_capture_pcm_prepare: NID=0x%x, stream=0x%x, format=0x%x\n",
+        mycodec_info(codec, "cs_8409_capture_pcm_prepare: NID=0x%x, stream=0x%x, format=0x%x\n",
                   hinfo->nid, stream_tag, format);
 
 
@@ -803,6 +807,8 @@ static int cs_8409_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
         if (spec->gen.pcm_capture_hook)
                 spec->gen.pcm_capture_hook(hinfo, codec, substream, HDA_GEN_PCM_ACT_PREPARE);
 
+        mycodec_info(codec, "cs_8409_capture_pcm_prepare end\n");
+
         return 0;
 }
 
@@ -3069,6 +3075,9 @@ static int patch_cs8409_apple(struct hda_codec *codec)
        spec->play_init = 0;
        spec->capture_init = 0;
 
+       spec->play_init_count = 0;
+       spec->capture_init_count = 0;
+
        // init the last play time
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
        ktime_get_real_ts64(&(spec->last_play_time));

patch_cirrus/patch_cirrus_new84.h

@@ -1223,6 +1223,23 @@ void cs_8409_capture_cleanup(struct hda_codec *codec)
 
 }
 
+// routine to clear unsol list
+static void cs_8409_clear_external_device_unsolicited_responses(struct hda_codec *codec)
+{
+	struct cs8409_apple_spec *spec = codec->spec;
+	struct unsol_item *unsol_entry = NULL;
+	struct unsol_item *unsol_temp = NULL;
+	if (!list_empty(&spec->unsol_list)) {
+		codec_info(codec, "cs_8409_clear_external_device_unsolicited_responses UNSOL start\n");
+		list_for_each_entry_safe(unsol_entry, unsol_temp, &spec->unsol_list, list)
+		{
+			list_del_init(&unsol_entry->list);
+			spec->unsol_items_prealloc_used[unsol_entry->idx] = 0;
+			memset(unsol_entry, 0, sizeof(struct unsol_item));
+		}
+		codec_info(codec, "cs_8409_clear_external_device_unsolicited_responses UNSOL end\n");
+	}
+}
 
 static void cs_8409_cs42l83_unsolicited_response_finalize(struct hda_codec *codec, unsigned int res);
 
@@ -1486,7 +1503,17 @@ static void cs_8409_pcm_playback_pre_prepare_hook(struct hda_pcm_stream *hinfo,
 		struct timespec curtim;
 		getnstimeofday(&curtim);
 #endif
-		myprintk("snd_hda_intel: command cs_8409_pcm_playback_pre_prepare_hook HOOK PREPARE init %d last %lld cur %lld",spec->play_init,spec->last_play_time.tv_sec,curtim.tv_sec);
+		spec->play_init_count++;
+		myprintk("snd_hda_intel: command cs_8409_pcm_playback_pre_prepare_hook HOOK PREPARE init %d %d last %lld cur %lld",spec->play_init,spec->play_init_count,spec->last_play_time.tv_sec,curtim.tv_sec);
+                //dump_stack();
+		// for some reason this is being called twice within short time so setup is being done twice
+		// with no intervening cleanup
+		// which may be introducing glitches in the headset/headphone stream - which it is!!!
+		// try suppressing any further calls
+		// well great apparently its a feature this function can be called multiple times!!
+		// looking at examples and Alsa driver docs it appears the idea of this function is to set
+		// the stream parameters - so lets let it set the stream parameters every time
+		// but only do the main apple setup once
 		if (1) {
 			struct hda_cvt_setup_apple *p = NULL;
 			//int power_chk = 0;
@@ -1510,6 +1537,10 @@ static void cs_8409_pcm_playback_pre_prepare_hook(struct hda_pcm_stream *hinfo,
 
 			hda_check_power_state(codec, 0x1a, 1);
 			hda_check_power_state(codec, 0x3c, 1);
+		}
+
+		if (spec->play_init_count == 1) {
+			struct hda_cvt_setup_apple *p = NULL;
 
 			// for the moment have junky test here
 			if (spec->jack_present)
@@ -1607,17 +1638,24 @@ static void cs_8409_playback_pcm_hook(struct hda_pcm_stream *hinfo, struct hda_c
 		//struct hda_cvt_setup_apple *p = NULL;
 		myprintk("snd_hda_intel: command cs_8409_playback_pcm_hook open");
 
+		spec->play_init_count = 0;
+
 		myprintk("snd_hda_intel: command cs_8409_playback_pcm_hook open end");
 	} else if (action == HDA_GEN_PCM_ACT_PREPARE) {
 		// so this comes AFTER the stream format, frequency setup verbs are sent for the pcm stream
+		// note that this can be called multiple times apparently
+		// not clear what if any the differences are for those multiple calls
+		// - does mean we need to ensure we only do most operations once
+		// (most of the work is done in the pre prepare function)
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
 		struct timespec64 curtim;
 		ktime_get_real_ts64(&curtim);
 #else
 		struct timespec curtim;
 		getnstimeofday(&curtim);
 #endif
-		myprintk("snd_hda_intel: command cs_8409_playback_pcm_hook HOOK PREPARE init %d last %lld cur %lld",spec->play_init,spec->last_play_time.tv_sec,curtim.tv_sec);
+		myprintk("snd_hda_intel: command cs_8409_playback_pcm_hook HOOK PREPARE init %d %d last %lld cur %lld",spec->play_init,spec->play_init_count,spec->last_play_time.tv_sec,curtim.tv_sec);
+                //dump_stack();
 		//int power_chk = 0;
 		//power_chk = snd_hda_codec_read(codec, codec->core.afg, 0, AC_VERB_GET_POWER_STATE, 0);
 		//myprintk("snd_hda_intel: command cs_8409_playback_pcm_hook power check 0x01 2 %d", power_chk);
@@ -1628,6 +1666,7 @@ static void cs_8409_playback_pcm_hook(struct hda_pcm_stream *hinfo, struct hda_c
 		{
 			codec_info(codec, "cs_8409_playback_pcm_hook - performing UNSOL responses\n");
 			cs_8409_perform_external_device_unsolicited_responses(codec);
+			//cs_8409_clear_external_device_unsolicited_responses(codec);
 		}
 		spec->playing = 1;
 		myprintk("snd_hda_intel: command cs_8409_playback_pcm_hook HOOK PREPARE end");
@@ -1657,6 +1696,7 @@ static void cs_8409_playback_pcm_hook(struct hda_pcm_stream *hinfo, struct hda_c
 			codec_info(codec, "cs_8409_playback_pcm_hook - performing UNSOL responses\n");
 			cs_8409_perform_external_device_unsolicited_responses(codec);
 		}
+		spec->play_init_count = 0;
 		// not sure of this position yet
 		spec->playing = 0;
         	power_chk = snd_hda_codec_read(codec, codec->core.afg, 0, AC_VERB_GET_POWER_STATE, 0);
@@ -1677,7 +1717,14 @@ static void cs_8409_pcm_capture_pre_prepare_hook(struct hda_pcm_stream *hinfo, s
 	struct cs8409_apple_spec *spec = codec->spec;
 
 	if (action == HDA_GEN_PCM_ACT_PREPARE) {
-		myprintk("snd_hda_intel: command cs_8409_pcm_capture_pre_prepare_hook HOOK PREPARE init %d",spec->capture_init);
+		spec->capture_init_count++;
+		myprintk("snd_hda_intel: command cs_8409_pcm_capture_pre_prepare_hook HOOK PREPARE init %d %d",spec->capture_init,spec->capture_init_count);
+
+		// for some reason this is being called twice within short time
+		// well great apparently its a feature this function can be called multiple times!!
+		// looking at examples and Alsa driver docs it appears the idea of this function is to set
+		// the stream parameters - so lets let it set the stream parameters every time
+		// but only do the main apple setup once
 
 		// so the first action for internal mike recording (via Quicktime)
 		// is a headphone sense
@@ -1697,32 +1744,36 @@ static void cs_8409_pcm_capture_pre_prepare_hook(struct hda_pcm_stream *hinfo, s
 		//cs_8409_setup_stream_format(codec, hinfo->nid, stream_tag, format);
 		cs_8409_store_stream_format(codec, hinfo->nid, stream_tag, format);
 
+		// ensure the setup is only done once
+		if (spec->capture_init_count == 1) {
 
-		// for the moment have junky test here
-		if (spec->jack_present) {
-			spec->block_unsol = 1;
-			if (spec->have_mike)
-			{
-				// so it seems if we have a headset mike we always enable the
-				// headphones even if just capturing
-				if (spec->headset_play_format_setup_needed)
-				{
-					cs_8409_headplay_setup(codec);
-					spec->headset_play_format_setup_needed = 0;
-				}
-				if (spec->headset_capture_format_setup_needed)
+			// for the moment have junky test here
+			if (spec->jack_present) {
+				spec->block_unsol = 1;
+				if (spec->have_mike)
 				{
-					cs_8409_headcapture_setup(codec);
-					spec->headset_capture_format_setup_needed = 0;
+					// so it seems if we have a headset mike we always enable the
+					// headphones even if just capturing
+					if (spec->headset_play_format_setup_needed)
+					{
+						cs_8409_headplay_setup(codec);
+						spec->headset_play_format_setup_needed = 0;
+					}
+					if (spec->headset_capture_format_setup_needed)
+					{
+						cs_8409_headcapture_setup(codec);
+						spec->headset_capture_format_setup_needed = 0;
+					}
 				}
+				// I think this is impossible - this would say we tried to capture
+				// using a headset without mike
+				// NOTE - still not fixed linein/lineout working - this may need
+				// changing here
 			}
-			// I think this is impossible - this would say we tried to capture
-			// using a headset without mike
-			// NOTE - still not fixed linein/lineout working - this may need
-			// changing here
+			else
+				cs_8409_capture_setup(codec);
 		}
-		else
-			cs_8409_capture_setup(codec);
+
 		myprintk("snd_hda_intel: command cs_8409_capture_pcm_hook setup capture called");
 
 		spec->capturing = 0;
@@ -1776,10 +1827,15 @@ static void cs_8409_capture_pcm_hook(struct hda_pcm_stream *hinfo, struct hda_co
 	if (action == HDA_GEN_PCM_ACT_OPEN) {
 		//struct hda_cvt_setup_apple *p = NULL;
 		myprintk("snd_hda_intel: command cs_8409_capture_pcm_hook open");
+		spec->capture_init_count = 0;
 
 		myprintk("snd_hda_intel: command cs_8409_capture_pcm_hook open end");
 	} else if (action == HDA_GEN_PCM_ACT_PREPARE) {
 		// so this comes AFTER the stream format, frequency setup verbs are sent for the pcm stream
+		// note that this can be called multiple times apparently
+		// not clear what if any the differences are for those multiple calls
+		// - does mean we need to ensure we only do most operations once
+		// (most of the work is done in the pre prepare function)
 		myprintk("snd_hda_intel: command cs_8409_capture_pcm_hook HOOK PREPARE init %d",spec->capture_init);
 		// this is where we need to finally unset the block_unsol
 		// - which also means this is where we should check for unsolicited responses
@@ -1827,6 +1883,7 @@ static void cs_8409_capture_pcm_hook(struct hda_pcm_stream *hinfo, struct hda_co
 			codec_info(codec, "cs_8409_capture_pcm_hook - performing UNSOL responses\n");
 			cs_8409_perform_external_device_unsolicited_responses(codec);
 		}
+		spec->capture_init_count = 0;
 		// not sure of this position yet
 		spec->capturing = 0;
 		power_chk = snd_hda_codec_read(codec, codec->core.afg, 0, AC_VERB_GET_POWER_STATE, 0);

patch_cirrus/patch_cirrus_real84_i2c.h

@@ -946,6 +946,7 @@ static void cs42l83_configure_int_mclk(struct hda_codec *codec)
 
         cs_8409_vendor_i2cWrite(codec, 0x90, 0x1208, 0x0000, 1); // snd_hda
 
+	mycodec_i2c_local_info(codec, "cs42l83_configure_int_mclk end\n");
 }
 
 static void cs42l83_headset_power_on_on_nouse(struct hda_codec *codec)
@@ -1014,6 +1015,8 @@ static void cs42l83_power_onoff(struct hda_codec *codec, bool onflag)
                 cs_8409_vendor_i2cWrite(codec, 0x90, 0x1107, 0x0000, 1); // snd_hda
                 cs_8409_vendor_i2cWrite(codec, 0x90, 0x1501, 0x0000, 1); // snd_hda
         }
+
+	mycodec_i2c_local_info(codec, "cs42l83_power_onoff end\n");
 }
 
 static void cs42l83_configure_serial_port(struct hda_codec *codec)
@@ -1062,6 +1065,8 @@ static void cs42l83_configure_serial_port(struct hda_codec *codec)
         cs_8409_vendor_i2cRead(codec, 0x90, 0x1208, 1); // snd_hda
         cs_8409_vendor_i2cWrite(codec, 0x90, 0x1208, 0x0002, 1); // snd_hda
 
+
+	mycodec_i2c_local_info(codec, "cs42l83_configure_serial_port end\n");
 }
 
 static void cs42l83_output_set_input_sample_rate(struct hda_codec *codec)

patch_cirrus/patch_cs8409.h

@@ -473,6 +473,9 @@ struct cs8409_spec {
 	int play_init;
 	int capture_init;
 
+	int play_init_count;
+	int capture_init_count;
+
 
 	// new item to limit times we redo unmute/play
 	struct timespec64 last_play_time;

patch_patch_cs8409.h.diff

@@ -430,7 +430,7 @@ index d0b725c..d8b5232 100644
  	unsigned int suspended:1;
  	unsigned int paged:1;
  	unsigned int last_page;
-@@ -339,6 +365,126 @@
+@@ -339,6 +365,129 @@
  	unsigned int init_done:1;
  	unsigned int build_ctrl_done:1;
 
@@ -542,6 +542,9 @@ index d0b725c..d8b5232 100644
 +	int play_init;
 +	int capture_init;
 +
++	int play_init_count;
++	int capture_init_count;
++
 +
 +	// new item to limit times we redo unmute/play
 +	struct timespec64 last_play_time;