 @@ -1,14 +1,14 @@
-/* $NetBSD: hdaudio.c,v 1.8 2010/09/02 01:55:31 jmcneill Exp $ */
+/* $NetBSD: hdaudio.c,v 1.9 2011/01/07 15:30:29 jmcneill 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
 @@ -20,35 +20,36 @@
  * 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 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.c,v 1.8 2010/09/02 01:55:31 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hdaudio.c,v 1.9 2011/01/07 15:30:29 jmcneill Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <sys/bus.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include <dev/pci/hdaudio/hdaudiovar.h>
 #include <dev/pci/hdaudio/hdaudioreg.h>
 #include <dev/pci/hdaudio/hdaudioio.h>
 /* #define	HDAUDIO_DEBUG */
 #define	HDAUDIO_RESET_TIMEOUT	5000
 #define HDAUDIO_CORB_TIMEOUT	1000
 #define	HDAUDIO_RIRB_TIMEOUT	5000
 #define	HDAUDIO_CODEC_DELAY	1000	/* spec calls for 250 */
 @@ -855,26 +856,66 @@ hdaudio_resume(struct hdaudio_softc *sc)
 	if (hdaudio_rirb_config(sc) != 0)
 		return false;
 	if (hdaudio_corb_start(sc) != 0)
 		return false;
 	if (hdaudio_rirb_start(sc) != 0)
 		return false;
 	hdaudio_intr_enable(sc);
 	return true;
+}
 int
 hdaudio_rescan(struct hdaudio_softc *sc, const char *ifattr, const int *locs)
+{
 	struct hdaudio_codec *co;
 	struct hdaudio_function_group *fg;
 	unsigned int codec;
 	if (!ifattr_match(ifattr, "hdaudiobus"))
 		return 0;
 	for (codec = 0; codec < HDAUDIO_MAX_CODECS; codec++) {
 		co = &sc->sc_codec[codec];
 		fg = co->co_fg;
 		if (!co->co_valid || fg == NULL)
 			continue;
 		if (fg->fg_device)
 			continue;
 		hdaudio_attach_fg(fg, NULL);
+	}
 	return 0;
+}
 void
 hdaudio_childdet(struct hdaudio_softc *sc, device_t child)
+{
 	struct hdaudio_codec *co;
 	struct hdaudio_function_group *fg;
 	unsigned int codec;
 	for (codec = 0; codec < HDAUDIO_MAX_CODECS; codec++) {
 		co = &sc->sc_codec[codec];
 		fg = co->co_fg;
 		if (!co->co_valid || fg == NULL)
 			continue;
 		if (fg->fg_device == child)
 			fg->fg_device = NULL;
+	}
+}
 int
 hdaudio_intr(struct hdaudio_softc *sc)
+{
 	struct hdaudio_stream *st;
 	uint32_t intsts, stream_mask;
 	int streamid = 0;
 	uint32_t rirbsts;
 	intsts = hda_read4(sc, HDAUDIO_MMIO_INTSTS);
 	if (!(intsts & HDAUDIO_INTSTS_GIS))
 		return 0;
 	if (intsts & HDAUDIO_INTSTS_CIS) {
 		rirbsts = hda_read4(sc, HDAUDIO_MMIO_RIRBSTS);
 @@ -1338,49 +1379,62 @@ hdaudioioctl_fgrp_setconfig(struct hdaud
+	}
 	hdaudio_attach_fg(fg, config);
 	if (config)
 		prop_object_release(config);
 	return 0;
+}
 static int
 hdaudio_dispatch_fgrp_ioctl(struct hdaudio_softc *sc, u_long cmd,
     prop_dictionary_t request, prop_dictionary_t response)
+{
 	struct hdaudio_function_group *fg;
 	int (*infocb)(void *, prop_dictionary_t, prop_dictionary_t);
 	prop_dictionary_t fgrp_dict;
 	uint64_t info_fn;
 	int16_t codecid, nid;
 	void *fgrp_sc;
 	bool rv;
 	int err;
 	if (!prop_dictionary_get_int16(request, "codecid", &codecid) ||
 	    !prop_dictionary_get_int16(request, "nid", &nid))
 		return EINVAL;
 	fg = hdaudioioctl_fgrp_lookup(sc, codecid, nid);
 	if (fg == NULL)
 		return ENODEV;
 	fgrp_sc = device_private(fg->fg_device);
 	fgrp_dict = device_properties(fg->fg_device);
 	switch (fg->fg_type) {
 	case HDAUDIO_GROUP_TYPE_AFG:
 		switch (cmd) {
 		case HDAUDIO_FGRP_CODEC_INFO:
-			err = hdaudio_afg_codec_info(fgrp_sc,
+			rv = prop_dictionary_get_uint64(fgrp_dict,
-			    request, response);
+			    "codecinfo-callback", &info_fn);
 			if (!rv)
 				return ENXIO;
 			infocb = (void *)(uintptr_t)info_fn;
 			err = infocb(fgrp_sc, request, response);
 			break;
 		case HDAUDIO_FGRP_WIDGET_INFO:
-			err = hdaudio_afg_widget_info(fgrp_sc,
+			rv = prop_dictionary_get_uint64(fgrp_dict,
-			    request, response);
+			    "widgetinfo-callback", &info_fn);
 			if (!rv)
 				return ENXIO;
 			infocb = (void *)(uintptr_t)info_fn;
 			err = infocb(fgrp_sc, request, response);
 			break;
 		default:
 			err = EINVAL;
 			break;
+		}
 		break;
 	default:
 		err = EINVAL;
 		break;
+	}
 	return err;
+}
 @@ -1442,13 +1496,53 @@ hdaudioioctl(dev_t dev, u_long cmd, void
 	default:
 		err = EINVAL;
 		break;
+	}
 	if (!err)
 		err = prop_dictionary_copyout_ioctl(pref, cmd, response);
 	if (response)
 		prop_object_release(response);
 	prop_object_release(request);
 	return err;
+}
 MODULE(MODULE_CLASS_DRIVER, hdaudio, NULL);
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 static int
 hdaudio_modcmd(modcmd_t cmd, void *opaque)
+{
 	int error = 0;
 #ifdef _MODULE
 	int bmaj = -1, cmaj = -1;
 #endif
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 #ifdef _MODULE
 		error = config_init_component(cfdriver_ioconf_hdaudio,
 		    cfattach_ioconf_hdaudio, cfdata_ioconf_hdaudio);
 		if (error)
 			return error;
 		error = devsw_attach("hdaudio", NULL, &bmaj,
 		    &hdaudio_cdevsw, &cmaj);
 		if (error)
 			config_fini_component(cfdriver_ioconf_hdaudio,
 			    cfattach_ioconf_hdaudio, cfdata_ioconf_hdaudio);
 #endif
 		return error;
 	case MODULE_CMD_FINI:
 #ifdef _MODULE
 		devsw_detach(NULL, &hdaudio_cdevsw);
 		error = config_fini_component(cfdriver_ioconf_hdaudio,
 		    cfattach_ioconf_hdaudio, cfdata_ioconf_hdaudio);
 #endif
 		return error;
 	default:
 		return ENOTTY;
+	}
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: hdaudio_afg.c,v 1.27 2010/09/02 01:55:31 jmcneill Exp $ */
+/* $NetBSD: hdaudio_afg.c,v 1.28 2011/01/07 15:30:29 jmcneill 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,36 +50,37 @@
  * 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.27 2010/09/02 01:55:31 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hdaudio_afg.c,v 1.28 2011/01/07 15:30:29 jmcneill 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/audioio.h>
 #include <dev/audio_if.h>
 #include <dev/auconv.h>
 #include <dev/pci/hdaudio/hdaudiovar.h>
 #include <dev/pci/hdaudio/hdaudioreg.h>
 #include <dev/pci/hdaudio/hdaudio_mixer.h>
 #include <dev/pci/hdaudio/hdaudioio.h>
 #include <dev/pci/hdaudio/hdaudio_ids.h>
 #ifndef AUFMT_SURROUND_7_1
 #define	AUFMT_SURROUND_7_1 (AUFMT_DOLBY_5_1|AUFMT_SIDE_LEFT|AUFMT_SIDE_RIGHT)
 @@ -311,26 +312,31 @@ struct hdaudio_afg_softc {
 		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, const pmf_qual_t *);
 static bool	hdaudio_afg_resume(device_t, const pmf_qual_t *);
 static int	hdaudio_afg_widget_info(void *, prop_dictionary_t,
 					prop_dictionary_t);
 static int	hdaudio_afg_codec_info(void *, prop_dictionary_t,
 				       prop_dictionary_t);
 CFATTACH_DECL2_NEW(
     hdafg,
     sizeof(struct hdaudio_afg_softc),
     hdaudio_afg_match,
     hdaudio_afg_attach,
     hdaudio_afg_detach,
     NULL,
     NULL,
     hdaudio_afg_childdet
 );
 static int	hdaudio_afg_query_encoding(void *, struct audio_encoding *);
 static int	hdaudio_afg_set_params(void *, int, int,
 @@ -368,27 +374,27 @@ static const struct audio_hw_if hdaudio_
 	.halt_output		= hdaudio_afg_halt_output,
 	.halt_input		= hdaudio_afg_halt_input,
 	.getdev			= hdaudio_afg_getdev,
 	.set_port		= hdaudio_afg_set_port,
 	.get_port		= hdaudio_afg_get_port,
 	.query_devinfo		= hdaudio_afg_query_devinfo,
 	.allocm			= hdaudio_afg_allocm,
 	.freem			= hdaudio_afg_freem,
 	.round_buffersize	= hdaudio_afg_round_buffersize,
 	.mappage		= hdaudio_afg_mappage,
 	.get_props		= hdaudio_afg_get_props,
 	.trigger_output		= hdaudio_afg_trigger_output,
 	.trigger_input		= hdaudio_afg_trigger_input,
-	.dev_ioctl		= hdaudio_afg_dev_ioctl
+	.dev_ioctl		= hdaudio_afg_dev_ioctl,
 };
 static int
 hdaudio_afg_append_formats(struct hdaudio_audiodev *ad,
     const struct audio_format *format)
+{
 	if (ad->ad_nformats + 1 >= HDAUDIO_MAXFORMATS) {
 		hda_print1(ad->ad_sc, "[ENOMEM] ");
 		return ENOMEM;
+	}
 	ad->ad_formats[ad->ad_nformats++] = *format;
 	return 0;
 @@ -3719,27 +3725,27 @@ hdaudio_afg_trigger_input(void *opaque,
 		return ENOMEM;
 	ad->ad_captureintr = intr;
 	ad->ad_captureintrarg = intrarg;
 	dmasize = (char *)end - (char *)start;
 	ad->ad_sc->sc_rparam = *param;
 	hdaudio_afg_stream_connect(ad->ad_sc, AUMODE_RECORD);
 	hdaudio_stream_start(ad->ad_capture, blksize, dmasize, param);
 	return 0;
+}
-int
+static int
 hdaudio_afg_widget_info(void *opaque, prop_dictionary_t request,
     prop_dictionary_t response)
+{
 	struct hdaudio_afg_softc *sc = opaque;
 	struct hdaudio_widget *w;
 	prop_array_t connlist;
 	uint32_t config, wcap;
 	uint16_t index;
 	int nid;
 	int i;
 	if (prop_dictionary_get_uint16(request, "index", &index) == false)
 		return EINVAL;
 @@ -3764,27 +3770,27 @@ hdaudio_afg_widget_info(void *opaque, pr
 		return 0;
 	connlist = prop_array_create();
 	for (i = 0; i < w->w_nconns; i++) {
 		if (w->w_conns[i] == 0)
 			continue;
 		prop_array_add(connlist,
 		    prop_number_create_unsigned_integer(w->w_conns[i]));
+	}
 	prop_dictionary_set(response, "connlist", connlist);
 	prop_object_release(connlist);
 	return 0;
+}
-int
+static int
 hdaudio_afg_codec_info(void *opaque, prop_dictionary_t request,
     prop_dictionary_t response)
+{
 	struct hdaudio_afg_softc *sc = opaque;
 	prop_dictionary_set_uint16(response, "vendor-id",
 	    sc->sc_vendor);
 	prop_dictionary_set_uint16(response, "product-id",
 	    sc->sc_product);
 	return 0;
+}
 static int
 hdaudio_afg_dev_ioctl(void *opaque, u_long cmd, void *addr, int flag, lwp_t *l)
 @@ -3815,13 +3821,42 @@ hdaudio_afg_dev_ioctl(void *opaque, u_lo
 	default:
 		err = EINVAL;
 		break;
+	}
 	if (!err)
 		err = prop_dictionary_copyout_ioctl(pref, cmd, response);
 	if (response)
 		prop_object_release(response);
 	prop_object_release(request);
 	return err;
+}
 MODULE(MODULE_CLASS_DRIVER, hdafg, "hdaudio");
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 static int
 hdafg_modcmd(modcmd_t cmd, void *opaque)
+{
 	int error;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 #ifdef _MODULE
 		error = config_init_component(cfdriver_ioconf_hdafg,
 		    cfattach_ioconf_hdafg, cfdata_ioconf_hdafg);
 #endif
 		return error;
 	case MODULE_CMD_FINI:
 #ifdef _MODULE
 		error = config_fini_component(cfdriver_ioconf_hdafg,
 		    cfattach_ioconf_hdafg, cfdata_ioconf_hdafg);
 #endif
 		return error;
 	default:
 		return ENOTTY;
+	}
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: hdaudio_pci.c,v 1.6 2010/08/07 16:59:48 jmcneill Exp $ */
+/* $NetBSD: hdaudio_pci.c,v 1.7 2011/01/07 15:30:30 jmcneill 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
 @@ -24,68 +24,69 @@
  * 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.
  */
 /*
  * Intel High Definition Audio (Revision 1.0) device driver.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: hdaudio_pci.c,v 1.6 2010/08/07 16:59:48 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hdaudio_pci.c,v 1.7 2011/01/07 15:30:30 jmcneill Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <sys/bus.h>
 #include <sys/intr.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/hdaudio/hdaudioreg.h>
 #include <dev/pci/hdaudio/hdaudiovar.h>
 #include <dev/pci/hdaudio/hdaudio_pci.h>
 struct hdaudio_pci_softc {
 	struct hdaudio_softc	sc_hdaudio;	/* must be first */
 	pcitag_t		sc_tag;
 	pci_chipset_tag_t	sc_pc;
 	void			*sc_ih;
 };
 static int		hdaudio_pci_match(device_t, cfdata_t, void *);
 static void		hdaudio_pci_attach(device_t, device_t, void *);
 static int		hdaudio_pci_detach(device_t, int);
 static int		hdaudio_pci_rescan(device_t, const char *, const int *);
 static void		hdaudio_pci_childdet(device_t, device_t);
 static int		hdaudio_pci_intr(void *);
 /* power management */
 static bool		hdaudio_pci_resume(device_t, const pmf_qual_t *);
 CFATTACH_DECL2_NEW(
     hdaudio_pci,
     sizeof(struct hdaudio_pci_softc),
     hdaudio_pci_match,
     hdaudio_pci_attach,
     hdaudio_pci_detach,
     NULL,
-    NULL,
+    hdaudio_pci_rescan,
     hdaudio_pci_childdet
 );
 /*
  * NetBSD autoconfiguration
  */
 static int
 hdaudio_pci_match(device_t parent, cfdata_t match, void *opaque)
+{
 	struct pci_attach_args *pa = opaque;
 	if (PCI_CLASS(pa->pa_class) != PCI_CLASS_MULTIMEDIA)
 @@ -160,34 +161,40 @@ hdaudio_pci_attach(device_t parent, devi
 		csr = pci_conf_read(sc->sc_pc, sc->sc_tag,
 		    HDAUDIO_NV_REG_SNOOP);
 		csr &= ~HDAUDIO_NV_SNOOP_MASK;
 		csr |= HDAUDIO_NV_SNOOP_ENABLE;
 		pci_conf_write(sc->sc_pc, sc->sc_tag,
 		    HDAUDIO_NV_REG_SNOOP, csr);
 		break;
+	}
 	/* Attach bus-independent HD audio layer */
 	hdaudio_attach(self, &sc->sc_hdaudio);
+}
 static int
 hdaudio_pci_rescan(device_t self, const char *ifattr, const int *locs)
+{
 	struct hdaudio_pci_softc *sc = device_private(self);
 	return hdaudio_rescan(&sc->sc_hdaudio, ifattr, locs);
+}
 void
 hdaudio_pci_childdet(device_t self, device_t child)
+{
 #if notyet
 	struct hdaudio_pci_softc *sc = device_private(self);
 	hdaudio_childdet(&sc->sc_hdaudio, child);
 #endif
+}
 static int
 hdaudio_pci_detach(device_t self, int flags)
+{
 	struct hdaudio_pci_softc *sc = device_private(self);
 	pcireg_t csr;
 	hdaudio_detach(&sc->sc_hdaudio, flags);
 	if (sc->sc_ih != NULL) {
 		pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
 		sc->sc_ih = NULL;

 @@ -1,14 +1,14 @@
-/* $NetBSD: hdaudiovar.h,v 1.6 2010/08/15 19:39:56 jmcneill Exp $ */
+/* $NetBSD: hdaudiovar.h,v 1.7 2011/01/07 15:30:30 jmcneill 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
 @@ -153,34 +153,34 @@ struct hdaudio_softc {
 	struct hdaudio_dma	sc_rirb;
 	uint16_t		sc_rirbrp;
 	struct hdaudio_codec	sc_codec[HDAUDIO_MAX_CODECS];
 	struct hdaudio_stream	sc_stream[HDAUDIO_MAX_STREAMS];
 	uint32_t		sc_stream_mask;
 	kmutex_t		sc_stream_mtx;
 };
 int	hdaudio_attach(device_t, struct hdaudio_softc *);
 int	hdaudio_detach(struct hdaudio_softc *, int);
 bool	hdaudio_resume(struct hdaudio_softc *);
 int	hdaudio_rescan(struct hdaudio_softc *, const char *, const int *);
 void	hdaudio_childdet(struct hdaudio_softc *, device_t);
 uint32_t hdaudio_command(struct hdaudio_codec *, int, uint32_t, uint32_t);
 int	hdaudio_intr(struct hdaudio_softc *);
 int	hdaudio_dma_alloc(struct hdaudio_softc *, struct hdaudio_dma *, int);
 void	hdaudio_dma_free(struct hdaudio_softc *, struct hdaudio_dma *);
 struct hdaudio_stream *	hdaudio_stream_establish(struct hdaudio_softc *,
 				    enum hdaudio_stream_type,
 				    int (*)(struct hdaudio_stream *), void *);
 void	hdaudio_stream_disestablish(struct hdaudio_stream *);
 void	hdaudio_stream_start(struct hdaudio_stream *, int, bus_size_t,
 			     const audio_params_t *);
 void	hdaudio_stream_stop(struct hdaudio_stream *);
 void	hdaudio_stream_reset(struct hdaudio_stream *);
 int	hdaudio_stream_tag(struct hdaudio_stream *);
 uint16_t hdaudio_stream_param(struct hdaudio_stream *, const audio_params_t *);
 int	hdaudio_afg_widget_info(void *, prop_dictionary_t, prop_dictionary_t);
 int	hdaudio_afg_codec_info(void *, prop_dictionary_t, prop_dictionary_t);
 #endif /* !_HDAUDIOVAR_H */