 @@ -1,14 +1,14 @@
-/* $NetBSD: hdafg.c,v 1.29 2023/01/05 09:57:39 kardel Exp $ */
+/* $NetBSD: hdafg.c,v 1.30 2023/07/18 13:35:57 riastradh Exp $ */
 /*
  * Copyright (c) 2009 Precedence Technologies Ltd <support@precedence.co.uk>
  * Copyright (c) 2009-2011 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Precedence Technologies Ltd
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -50,37 +50,40 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: hdafg.c,v 1.29 2023/01/05 09:57:39 kardel Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hdafg.c,v 1.30 2023/07/18 13:35:57 riastradh Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <sys/bus.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <sys/condvar.h>
 #include <sys/kthread.h>
 #include <sys/mutex.h>
 #include <sys/audioio.h>
 #include <dev/audio/audio_if.h>
 #ifdef _KERNEL_OPT
 #include "opt_hdaudio.h"
 #endif
 #include "hdaudiovar.h"
 #include "hdaudioreg.h"
 #include "hdaudio_mixer.h"
 #include "hdaudioio.h"
 #include "hdaudio_verbose.h"
 @@ -301,28 +304,32 @@ struct hdafg_softc {
 	int				sc_nwidgets;
 	struct hdaudio_widget		*sc_widgets;
 	int				sc_nassocs;
 	struct hdaudio_assoc		*sc_assocs;
 	int				sc_nctls;
 	struct hdaudio_control		*sc_ctls;
 	int				sc_nmixers;
 	struct hdaudio_mixer		*sc_mixers;
 	bool				sc_has_beepgen;
 	int				sc_pchan, sc_rchan;
 	audio_params_t			sc_pparam, sc_rparam;
-	struct callout			sc_jack_callout;
+	kmutex_t			sc_jack_lock;
 	kcondvar_t			sc_jack_cv;
 	struct lwp			*sc_jack_thread;
 	bool				sc_jack_polling;
 	bool				sc_jack_suspended;
 	bool				sc_jack_dying;
 	struct {
 		uint32_t		afg_cap;
 		uint32_t		pcm_size_rate;
 		uint32_t		stream_format;
 		uint32_t		outamp_cap;
 		uint32_t		inamp_cap;
 		uint32_t		power_states;
 		uint32_t		gpio_cnt;
 	} sc_p;
 	struct hdaudio_audiodev		sc_audiodev;
 @@ -3502,36 +3509,38 @@ hdafg_configure_encodings(struct hdafg_s
 		f.channels = 2;
 		f.channel_mask = AUFMT_STEREO;
 		f.frequency_type = 0;
 		f.frequency[0] = f.frequency[1] = sc->sc_fixed_rate ?
 		    sc->sc_fixed_rate : 48000;
 		f.mode = AUMODE_PLAY|AUMODE_RECORD;
 		hdafg_append_formats(&sc->sc_audiodev, &f);
+	}
 	hda_print1(sc, "\n");
+}
 static void
-hdafg_hp_switch_handler(void *opaque)
+hdafg_hp_switch_handler(struct hdafg_softc *sc)
+{
 	struct hdafg_softc *sc = opaque;
 	struct hdaudio_assoc *as = sc->sc_assocs;
 	struct hdaudio_widget *w;
 	uint32_t res = 0;
 	int i, j;
 	KASSERT(sc->sc_jack_polling);
 	KASSERT(mutex_owned(&sc->sc_jack_lock));
 	if (!device_is_active(sc->sc_dev))
-		goto resched;
+		return;
 	for (i = 0; i < sc->sc_nassocs; i++) {
 		if (as[i].as_digital != HDAFG_AS_ANALOG &&
 		    as[i].as_digital != HDAFG_AS_SPDIF)
 			continue;
 		for (j = 0; j < HDAUDIO_MAXPINS; j++) {
 			if (as[i].as_pins[j] == 0)
 				continue;
 			w = hdafg_widget_lookup(sc, as[i].as_pins[j]);
 			if (w == NULL || w->w_enable == false)
 				continue;
 			if (w->w_type != COP_AWCAP_TYPE_PIN_COMPLEX)
 				continue;
 @@ -3570,38 +3579,58 @@ hdafg_hp_switch_handler(void *opaque)
 			case COP_DEVICE_AUX:
 				if (res & COP_GET_PIN_SENSE_PRESENSE_DETECT)
 					w->w_pin.ctrl &= ~COP_PWC_OUT_ENABLE;
 				else
 					w->w_pin.ctrl |= COP_PWC_OUT_ENABLE;
 				hdaudio_command(sc->sc_codec, w->w_nid,
 				    CORB_SET_PIN_WIDGET_CONTROL, w->w_pin.ctrl);
 				break;
 			default:
 				break;
+			}
+		}
+	}
+}
 static void
 hdafg_hp_switch_thread(void *opaque)
+{
 	struct hdafg_softc *sc = opaque;
 	KASSERT(sc->sc_jack_polling);
 	mutex_enter(&sc->sc_jack_lock);
 	while (!sc->sc_jack_dying) {
 		if (sc->sc_jack_suspended) {
 			cv_wait(&sc->sc_jack_cv, &sc->sc_jack_lock);
 			continue;
+		}
 		hdafg_hp_switch_handler(sc);
 		(void)cv_timedwait(&sc->sc_jack_cv, &sc->sc_jack_lock,
 		    HDAUDIO_HP_SENSE_PERIOD);
+	}
 	mutex_exit(&sc->sc_jack_lock);
-resched:
+	kthread_exit(0);
 	callout_schedule(&sc->sc_jack_callout, HDAUDIO_HP_SENSE_PERIOD);
+}
 static void
 hdafg_hp_switch_init(struct hdafg_softc *sc)
+{
 	struct hdaudio_assoc *as = sc->sc_assocs;
 	struct hdaudio_widget *w;
 	bool enable = false;
 	int i, j;
 	int error;
 	for (i = 0; i < sc->sc_nassocs; i++) {
 		if (as[i].as_hpredir < 0 && as[i].as_displaydev == false)
 			continue;
 		if (as[i].as_displaydev == false)
 			w = hdafg_widget_lookup(sc, as[i].as_pins[15]);
 		else {
 			w = NULL;
 			for (j = 0; j < HDAUDIO_MAXPINS; j++) {
 				if (as[i].as_pins[j] == 0)
 					continue;
 				w = hdafg_widget_lookup(sc, as[i].as_pins[j]);
 				if (w && w->w_enable &&
 @@ -3640,55 +3669,64 @@ hdafg_hp_switch_init(struct hdafg_softc
+		}
 		hda_trace(sc, "presence detect [pin=%02X,%s",
 		    w->w_nid,
 		    (w->w_p.aw_cap & COP_AWCAP_UNSOL_CAPABLE) ?
 		     "unsol" : "poll"
 		    );
 		if (w->w_pin.cap & COP_PINCAP_HDMI)
 			hda_trace1(sc, ",hdmi");
 		if (w->w_pin.cap & COP_PINCAP_DP)
 			hda_trace1(sc, ",displayport");
 		hda_trace1(sc, "]\n");
+	}
-	if (enable) {
+	if (!enable) {
 		sc->sc_jack_polling = true;
 		hdafg_hp_switch_handler(sc);
 	} else
 		hda_trace(sc, "jack detect not enabled\n");
 		return;
+	}
 	mutex_init(&sc->sc_jack_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&sc->sc_jack_cv, "hdafghp");
 	sc->sc_jack_polling = true;
 	error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, /*ci*/NULL,
 	    hdafg_hp_switch_thread, sc, &sc->sc_jack_thread,
 	    "%s hotplug detect", device_xname(sc->sc_dev));
 	if (error) {
 		aprint_error_dev(sc->sc_dev, "failed to create hotplug thread:"
 		    " %d", error);
 		sc->sc_jack_polling = false;
 		cv_destroy(&sc->sc_jack_cv);
 		mutex_destroy(&sc->sc_jack_lock);
+	}
+}
 static void
 hdafg_attach(device_t parent, device_t self, void *opaque)
+{
 	struct hdafg_softc *sc = device_private(self);
 	audio_params_t defparams;
 	prop_dictionary_t args = opaque;
 	uint64_t fgptr = 0;
 	uint32_t astype = 0;
 	uint8_t nid = 0;
 	int i;
 	bool rv;
 	aprint_naive("\n");
 	sc->sc_dev = self;
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED);
 	callout_init(&sc->sc_jack_callout, 0);
 	callout_setfunc(&sc->sc_jack_callout,
 	    hdafg_hp_switch_handler, sc);
 	if (!pmf_device_register(self, hdafg_suspend, hdafg_resume))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	sc->sc_config = prop_dictionary_get(args, "pin-config");
 	if (sc->sc_config && prop_object_type(sc->sc_config) != PROP_TYPE_ARRAY)
 		sc->sc_config = NULL;
 	prop_dictionary_get_uint16(args, "vendor-id", &sc->sc_vendor);
 	prop_dictionary_get_uint16(args, "product-id", &sc->sc_product);
 	hdaudio_findvendor(sc->sc_name, sizeof(sc->sc_name), sc->sc_vendor);
 	hdaudio_findproduct(sc->sc_version, sizeof(sc->sc_version), sc->sc_vendor,
 	    sc->sc_product);
 	hda_print1(sc, ": %s %s%s\n", sc->sc_name, sc->sc_version,
 @@ -3815,28 +3853,36 @@ hdafg_attach(device_t parent, device_t s
 	    &sc->sc_audiodev, self);
+}
 static int
 hdafg_detach(device_t self, int flags)
+{
 	struct hdafg_softc *sc = device_private(self);
 	struct hdaudio_widget *wl, *w = sc->sc_widgets;
 	struct hdaudio_assoc *as = sc->sc_assocs;
 	struct hdaudio_control *ctl = sc->sc_ctls;
 	struct hdaudio_mixer *mx = sc->sc_mixers;
 	int nid;
-	callout_halt(&sc->sc_jack_callout, NULL);
+	if (sc->sc_jack_polling) {
-	callout_destroy(&sc->sc_jack_callout);
+		int error __diagused;
 		mutex_enter(&sc->sc_jack_lock);
 		sc->sc_jack_dying = true;
 		cv_broadcast(&sc->sc_jack_cv);
 		mutex_exit(&sc->sc_jack_lock);
 		error = kthread_join(sc->sc_jack_thread);
 		KASSERTMSG(error == 0, "error=%d", error);
+	}
 	if (sc->sc_config)
 		prop_object_release(sc->sc_config);
 	if (sc->sc_audiodev.ad_audiodev)
 		config_detach(sc->sc_audiodev.ad_audiodev, flags);
 	if (sc->sc_audiodev.ad_playback)
 		hdaudio_stream_disestablish(sc->sc_audiodev.ad_playback);
 	if (sc->sc_audiodev.ad_capture)
 		hdaudio_stream_disestablish(sc->sc_audiodev.ad_capture);
 	/* restore bios pin widget configuration */
 	for (nid = sc->sc_startnode; nid < sc->sc_endnode; nid++) {
 		wl = hdafg_widget_lookup(sc, nid);
 @@ -3866,27 +3912,32 @@ static void
 hdafg_childdet(device_t self, device_t child)
+{
 	struct hdafg_softc *sc = device_private(self);
 	if (child == sc->sc_audiodev.ad_audiodev)
 		sc->sc_audiodev.ad_audiodev = NULL;
+}
 static bool
 hdafg_suspend(device_t self, const pmf_qual_t *qual)
+{
 	struct hdafg_softc *sc = device_private(self);
-	callout_halt(&sc->sc_jack_callout, NULL);
+	if (sc->sc_jack_polling) {
 		mutex_enter(&sc->sc_jack_lock);
 		KASSERT(!sc->sc_jack_suspended);
 		sc->sc_jack_suspended = true;
 		mutex_exit(&sc->sc_jack_lock);
+	}
 	return true;
+}
 static bool
 hdafg_resume(device_t self, const pmf_qual_t *qual)
+{
 	struct hdafg_softc *sc = device_private(self);
 	struct hdaudio_widget *w;
 	int nid;
 	hdaudio_command(sc->sc_codec, sc->sc_nid,
 	    CORB_SET_POWER_STATE, COP_POWER_STATE_D0);
 @@ -3897,28 +3948,33 @@ hdafg_resume(device_t self, const pmf_qu
 		w = hdafg_widget_lookup(sc, nid);
 		/* restore pin widget configuration */
 		if (w == NULL || w->w_type != COP_AWCAP_TYPE_PIN_COMPLEX)
 			continue;
 		hdafg_widget_setconfig(w, w->w_pin.config);
+	}
 	hda_delay(1000);
 	hdafg_commit(sc);
 	hdafg_stream_connect(sc, AUMODE_PLAY);
 	hdafg_stream_connect(sc, AUMODE_RECORD);
-	if (sc->sc_jack_polling)
+	if (sc->sc_jack_polling) {
-		hdafg_hp_switch_handler(sc);
+		mutex_enter(&sc->sc_jack_lock);
 		KASSERT(sc->sc_jack_suspended);
 		sc->sc_jack_suspended = false;
 		cv_broadcast(&sc->sc_jack_cv);
 		mutex_exit(&sc->sc_jack_lock);
+	}
 	return true;
+}
 static int
 hdafg_query_format(void *opaque, audio_format_query_t *afp)
+{
 	struct hdaudio_audiodev *ad = opaque;
 	return audio_query_format(ad->ad_formats, ad->ad_nformats, afp);
+}
 static int