 @@ -1,14 +1,14 @@
-/* $NetBSD: hdaudio_afg.c,v 1.14.2.2 2009/09/26 19:52:10 snj Exp $ */
+/* $NetBSD: hdaudio_afg.c,v 1.14.2.3 2009/09/28 00:40:21 snj Exp $ */
 /*
  * Copyright (c) 2009 Precedence Technologies Ltd <support@precedence.co.uk>
  * Copyright (c) 2009 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,27 +50,27 @@
  * 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: hdaudio_afg.c,v 1.14.2.2 2009/09/26 19:52:10 snj Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hdaudio_afg.c,v 1.14.2.3 2009/09/28 00:40:21 snj 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/audioio.h>
 #include <dev/audio_if.h>
 #include <dev/auconv.h>
 @@ -96,27 +96,27 @@ static int hdaudio_afg_debug = 0;
 	if (hdaudio_afg_debug) hda_print(sc, __VA_ARGS__)
 #define HDAUDIO_MIXER_CLASS_OUTPUTS	0
 #define	HDAUDIO_MIXER_CLASS_INPUTS	1
 #define	HDAUDIO_MIXER_CLASS_RECORD	2
 #define	HDAUDIO_MIXER_CLASS_LAST	HDAUDIO_MIXER_CLASS_RECORD
 #define	HDAUDIO_GPIO_MASK	0
 #define	HDAUDIO_GPIO_DIR	1
 #define	HDAUDIO_GPIO_DATA	2
 #define	HDAUDIO_UNSOLTAG_EVENT_HP	0x00
-#define	HDAUDIO_HP_SENSE_PERIOD		(hz / 2)
+#define	HDAUDIO_HP_SENSE_PERIOD		hz
 static const char *hdaudio_afg_mixer_names[] = HDAUDIO_DEVICE_NAMES;
 static const char *hdaudio_afg_port_connectivity[] = {
 	"Jack",
 	"Unconnected",
 	"Fixed Function",
 	"Jack & Fixed Function"
 };
 static const char *hdaudio_afg_default_device[] = {
 	"Line Out",
 	"Speaker",
 	"HP Out",
 @@ -280,44 +280,46 @@ struct hdaudio_afg_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;
 	int				sc_pchan, sc_rchan;
 	audio_params_t			sc_pparam, sc_rparam;
 	struct callout			sc_jack_callout;
 	bool				sc_jack_polling;
 	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;
 };
 static int	hdaudio_afg_match(device_t, cfdata_t, void *);
 static void	hdaudio_afg_attach(device_t, device_t, void *);
 static int	hdaudio_afg_detach(device_t, int);
 static void	hdaudio_afg_childdet(device_t, device_t);
 static bool	hdaudio_afg_suspend(device_t PMF_FN_PROTO);
 static bool	hdaudio_afg_resume(device_t PMF_FN_PROTO);
 CFATTACH_DECL2_NEW(
     hdafg,
     sizeof(struct hdaudio_afg_softc),
     hdaudio_afg_match,
     hdaudio_afg_attach,
     hdaudio_afg_detach,
     NULL,
     NULL,
     hdaudio_afg_childdet
 );
 @@ -2974,26 +2976,29 @@ hdaudio_afg_configure_encodings(struct h
 	hda_print1(sc, "\n");
+}
 static void
 hdaudio_afg_hp_switch_handler(void *opaque)
+{
 	struct hdaudio_afg_softc *sc = opaque;
 	struct hdaudio_assoc *as = sc->sc_assocs;
 	struct hdaudio_widget *w;
 	uint32_t res = 0;
 	int i, j;
 	if (!device_is_active(sc->sc_dev))
 		goto resched;
 	for (i = 0; i < sc->sc_nassocs; i++)
 		for (j = 0; j < HDAUDIO_MAXPINS; j++) {
 			w = hdaudio_afg_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;
 			if (COP_CFG_DEFAULT_DEVICE(w->w_pin.config) !=
 			    COP_DEVICE_HP_OUT)
 				continue;
 			res |= hdaudio_command(sc->sc_codec, as[i].as_pins[j],
 			    CORB_GET_PIN_SENSE, 0) &
 			    COP_GET_PIN_SENSE_PRESENSE_DETECT;
 @@ -3020,26 +3025,27 @@ hdaudio_afg_hp_switch_handler(void *opaq
 			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;
+			}
+		}
 resched:
 	callout_schedule(&sc->sc_jack_callout, HDAUDIO_HP_SENSE_PERIOD);
+}
 static void
 hdaudio_afg_hp_switch_init(struct hdaudio_afg_softc *sc)
+{
 	struct hdaudio_assoc *as = sc->sc_assocs;
 	struct hdaudio_widget *w;
 	bool enable = false;
 	int i;
 	for (i = 0; i < sc->sc_nassocs; i++) {
 		if (as[i].as_hpredir < 0)
 @@ -3060,50 +3066,50 @@ hdaudio_afg_hp_switch_init(struct hdaudi
 		if (w->w_p.aw_cap & COP_AWCAP_UNSOL_CAPABLE)
 			hdaudio_command(sc->sc_codec, w->w_nid,
 			    CORB_SET_UNSOLICITED_RESPONSE,
 			    COP_SET_UNSOLICITED_RESPONSE_ENABLE |
 			    HDAUDIO_UNSOLTAG_EVENT_HP);
 		hda_trace(sc, "jack detect supported on pin %02X [%s]\n",
 		    as[i].as_pins[15],
 		    (w->w_p.aw_cap & COP_AWCAP_UNSOL_CAPABLE) ?
 		    "unsol" : "poll");
+	}
 	if (enable) {
 		sc->sc_jack_polling = true;
 		hdaudio_afg_hp_switch_handler(sc);
 		callout_schedule(&sc->sc_jack_callout, HDAUDIO_HP_SENSE_PERIOD);
 	} else
 		hda_trace(sc, "jack detect not enabled\n");
+}
 static void
 hdaudio_afg_attach(device_t parent, device_t self, void *opaque)
+{
 	struct hdaudio_afg_softc *sc = device_private(self);
 	audio_params_t defparams;
 	prop_dictionary_t args = opaque;
 	uint64_t fgptr = 0;
 	uint8_t nid = 0;
 	int err;
 	bool rv;
 	sc->sc_dev = self;
 	callout_init(&sc->sc_jack_callout, 0);
 	callout_setfunc(&sc->sc_jack_callout,
 	    hdaudio_afg_hp_switch_handler, sc);
-	if (!pmf_device_register(self, NULL, hdaudio_afg_resume))
+	if (!pmf_device_register(self, hdaudio_afg_suspend, hdaudio_afg_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;
 	hda_print1(sc, " (%s configuration)\n", sc->sc_config ?
 	    "custom" : "firmware");
 	rv = prop_dictionary_get_uint64(args, "function-group", &fgptr);
 	if (rv == false || fgptr == 0) {
 		hda_error(sc, "missing function-group property\n");
 		return;
+	}
 @@ -3231,43 +3237,56 @@ hdaudio_afg_detach(device_t self, int fl
 	return 0;
+}
 static void
 hdaudio_afg_childdet(device_t self, device_t child)
+{
 	struct hdaudio_afg_softc *sc = device_private(self);
 	if (child == sc->sc_audiodev.ad_audiodev)
 		sc->sc_audiodev.ad_audiodev = NULL;
+}
 static bool
 hdaudio_afg_suspend(device_t self PMF_FN_ARGS)
+{
 	struct hdaudio_afg_softc *sc = device_private(self);
 	callout_halt(&sc->sc_jack_callout, NULL);
 	return true;
+}
 static bool
 hdaudio_afg_resume(device_t self PMF_FN_ARGS)
+{
 	struct hdaudio_afg_softc *sc = device_private(self);
 	int nid;
 	hdaudio_command(sc->sc_codec, sc->sc_nid,
 	    CORB_SET_POWER_STATE, COP_POWER_STATE_D0);
 	hda_delay(100);
 	for (nid = sc->sc_startnode; nid < sc->sc_endnode; nid++)
 		hdaudio_command(sc->sc_codec, nid,
 		    CORB_SET_POWER_STATE, COP_POWER_STATE_D0);
 	hda_delay(1000);
 	hdaudio_afg_commit(sc);
 	hdaudio_afg_stream_connect(sc, AUMODE_PLAY);
 	hdaudio_afg_stream_connect(sc, AUMODE_RECORD);
 	if (sc->sc_jack_polling)
 		hdaudio_afg_hp_switch_handler(sc);
 	return true;
+}
 static int
 hdaudio_afg_query_encoding(void *opaque, struct audio_encoding *ae)
+{
 	struct hdaudio_audiodev *ad = opaque;
 	return auconv_query_encoding(ad->ad_encodings, ae);
+}
 static int
 hdaudio_afg_set_params(void *opaque, int setmode, int usemode,
     audio_params_t *play, audio_params_t *rec,