kobjify.

this gives us several benefits, including:

* easier extensibility- new optional methods can be added to
  ac97/mixer/channel classes without having to fixup every driver.

* forward compatibility for drivers, provided no new mandatory methods are
  added.

40 files changed, 2802 insertions, 2832 deletions

diff --git a/sys/conf/files b/sys/conf/files
index ce1f2a1..35d7e28 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -460,13 +460,17 @@ dev/sound/pci/solo.c	optional pcm pci
 dev/sound/pci/t4dwave.c	optional pcm pci
 dev/sound/pci/via82c686.c	optional pcm pci
 dev/sound/pcm/ac97.c	optional pcm
+dev/sound/pcm/ac97_if.m	optional pcm
 dev/sound/pcm/channel.c	optional pcm
+dev/sound/pcm/channel_if.m	optional pcm
 dev/sound/pcm/dsp.c	optional pcm
 dev/sound/pcm/fake.c	optional pcm
 dev/sound/pcm/feeder.c	optional pcm
+dev/sound/pcm/feeder_if.m	optional pcm
 dev/sound/pcm/feeder_fmt.c	optional pcm
 #dev/sound/pcm/feeder_rate.c	optional pcm
 dev/sound/pcm/mixer.c	optional pcm
+dev/sound/pcm/mixer_if.m	optional pcm
 dev/sound/pcm/sound.c	optional pcm
 #dev/sound/usb/upcm.c	optional pcm usb
 dev/streams/streams.c	optional streams
diff --git a/sys/conf/kmod.mk b/sys/conf/kmod.mk
index 23ddd50..03fa4ed 100644
--- a/sys/conf/kmod.mk
+++ b/sys/conf/kmod.mk
@@ -34,10 +34,10 @@
 #
 # NOMAN		KLD does not have a manual page if set.
 #
-# PROG          The name of the kernel module to build. 
+# PROG          The name of the kernel module to build.
 #		If not supplied, ${KMOD}.o is used.
 #
-# SRCS          List of source files 
+# SRCS          List of source files
 #
 # SUBDIR        A list of subdirectories that should be built as well.
 #               Each of the targets will execute the same target in the
@@ -64,7 +64,7 @@
 #               actions immediately before and after the install target
 #		is executed.
 #
-# 	load:	
+# 	load:
 #		Load KLD.
 #
 # 	unload:
@@ -261,7 +261,8 @@ MFILES?= kern/bus_if.m kern/device_if.m dev/iicbus/iicbb_if.m \
     dev/iicbus/iicbus_if.m isa/isa_if.m dev/mii/miibus_if.m \
     dev/pccard/card_if.m dev/pccard/power_if.m dev/pci/pci_if.m \
     dev/pci/pcib_if.m dev/ppbus/ppbus_if.m dev/smbus/smbus_if.m \
-    dev/usb/usb_if.m
+    dev/usb/usb_if.m dev/sound/pcm/ac97_if.m dev/sound/pcm/channel_if.m \
+    dev/sound/pcm/feeder_if.m dev/sound/pcm/mixer_if.m
 
 .for _srcsrc in ${MFILES}
 .for _ext in c h
diff --git a/sys/dev/sound/isa/ad1816.c b/sys/dev/sound/isa/ad1816.c
index 3184dd8..d6e1dd7 100644
--- a/sys/dev/sound/isa/ad1816.c
+++ b/sys/dev/sound/isa/ad1816.c
@@ -31,6 +31,8 @@
 #include <dev/sound/pcm/sound.h>
 #include <dev/sound/isa/ad1816.h>
 
+#include "mixer_if.h"
+
 struct ad1816_info;
 
 struct ad1816_chinfo {
@@ -64,30 +66,8 @@ static int      	ad1816_wait_init(struct ad1816_info *ad1816, int x);
 static u_short		ad1816_read(struct ad1816_info *ad1816, u_int reg);
 static void     	ad1816_write(struct ad1816_info *ad1816, u_int reg, u_short data);
 
-static int ad1816mix_init(snd_mixer *m);
-static int ad1816mix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int ad1816mix_setrecsrc(snd_mixer *m, u_int32_t src);
-static snd_mixer ad1816_mixer = {
-    	"ad1816 mixer",
-    	ad1816mix_init,
-	NULL,
-	NULL,
-    	ad1816mix_set,
-    	ad1816mix_setrecsrc,
-};
-
 static devclass_t pcm_devclass;
 
-/* channel interface */
-static void *ad1816chan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int ad1816chan_setdir(void *data, int dir);
-static int ad1816chan_setformat(void *data, u_int32_t format);
-static int ad1816chan_setspeed(void *data, u_int32_t speed);
-static int ad1816chan_setblocksize(void *data, u_int32_t blocksize);
-static int ad1816chan_trigger(void *data, int go);
-static int ad1816chan_getptr(void *data);
-static pcmchan_caps *ad1816chan_getcaps(void *data);
-
 static u_int32_t ad1816_fmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -102,25 +82,6 @@ static u_int32_t ad1816_fmt[] = {
 
 static pcmchan_caps ad1816_caps = {4000, 55200, ad1816_fmt, 0};
 
-static pcm_channel ad1816_chantemplate = {
-	ad1816chan_init,
-	ad1816chan_setdir,
-	ad1816chan_setformat,
-	ad1816chan_setspeed,
-	ad1816chan_setblocksize,
-	ad1816chan_trigger,
-	ad1816chan_getptr,
-	ad1816chan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 #define AD1816_MUTE 31		/* value for mute */
 
 static int
@@ -232,6 +193,8 @@ ad1816_write(struct ad1816_info *ad1816, unsigned int reg, unsigned short data)
     	splx(flags);
 }
 
+/* -------------------------------------------------------------------- */
+
 static int
 ad1816mix_init(snd_mixer *m)
 {
@@ -329,9 +292,18 @@ ad1816mix_setrecsrc(snd_mixer *m, u_int32_t src)
     	return src;
 }
 
+static kobj_method_t ad1816mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		ad1816mix_init),
+    	KOBJMETHOD(mixer_set,		ad1816mix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	ad1816mix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(ad1816mixer);
+
+/* -------------------------------------------------------------------- */
 /* channel interface */
 static void *
-ad1816chan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+ad1816chan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct ad1816_info *ad1816 = devinfo;
 	struct ad1816_chinfo *ch = (dir == PCMDIR_PLAY)? &ad1816->pch : &ad1816->rch;
@@ -345,7 +317,7 @@ ad1816chan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-ad1816chan_setdir(void *data, int dir)
+ad1816chan_setdir(kobj_t obj, void *data, int dir)
 {
 	struct ad1816_chinfo *ch = data;
   	struct ad1816_info *ad1816 = ch->parent;
@@ -357,7 +329,7 @@ ad1816chan_setdir(void *data, int dir)
 }
 
 static int
-ad1816chan_setformat(void *data, u_int32_t format)
+ad1816chan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct ad1816_chinfo *ch = data;
   	struct ad1816_info *ad1816 = ch->parent;
@@ -399,7 +371,7 @@ ad1816chan_setformat(void *data, u_int32_t format)
 }
 
 static int
-ad1816chan_setspeed(void *data, u_int32_t speed)
+ad1816chan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct ad1816_chinfo *ch = data;
     	struct ad1816_info *ad1816 = ch->parent;
@@ -410,13 +382,13 @@ ad1816chan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-ad1816chan_setblocksize(void *data, u_int32_t blocksize)
+ad1816chan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-ad1816chan_trigger(void *data, int go)
+ad1816chan_trigger(kobj_t obj, void *data, int go)
 {
 	struct ad1816_chinfo *ch = data;
     	struct ad1816_info *ad1816 = ch->parent;
@@ -466,18 +438,33 @@ ad1816chan_trigger(void *data, int go)
 }
 
 static int
-ad1816chan_getptr(void *data)
+ad1816chan_getptr(kobj_t obj, void *data)
 {
 	struct ad1816_chinfo *ch = data;
 	return buf_isadmaptr(ch->buffer);
 }
 
 static pcmchan_caps *
-ad1816chan_getcaps(void *data)
+ad1816chan_getcaps(kobj_t obj, void *data)
 {
 	return &ad1816_caps;
 }
 
+static kobj_method_t ad1816chan_methods[] = {
+    	KOBJMETHOD(channel_init,		ad1816chan_init),
+    	KOBJMETHOD(channel_setdir,		ad1816chan_setdir),
+    	KOBJMETHOD(channel_setformat,		ad1816chan_setformat),
+    	KOBJMETHOD(channel_setspeed,		ad1816chan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	ad1816chan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		ad1816chan_trigger),
+    	KOBJMETHOD(channel_getptr,		ad1816chan_getptr),
+    	KOBJMETHOD(channel_getcaps,		ad1816chan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(ad1816chan);
+
+/* -------------------------------------------------------------------- */
+
 static void
 ad1816_release_resources(struct ad1816_info *ad1816, device_t dev)
 {
@@ -596,7 +583,8 @@ ad1816_attach(device_t dev)
 
     	if (!ad1816_alloc_resources(ad1816, dev)) goto no;
     	ad1816_init(ad1816, dev);
-    	mixer_init(dev, &ad1816_mixer, ad1816);
+    	if (mixer_init(dev, &ad1816mixer_class, ad1816)) goto no;
+
 	bus_setup_intr(dev, ad1816->irq, INTR_TYPE_TTY, ad1816_intr, ad1816, &ad1816->ih);
     	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
 			/*lowaddr*/BUS_SPACE_MAXADDR_24BIT,
@@ -617,8 +605,8 @@ ad1816_attach(device_t dev)
 		rman_get_start(ad1816->drq2));
 
     	if (pcm_register(dev, ad1816, 1, 1)) goto no;
-    	pcm_addchan(dev, PCMDIR_REC, &ad1816_chantemplate, ad1816);
-    	pcm_addchan(dev, PCMDIR_PLAY, &ad1816_chantemplate, ad1816);
+    	pcm_addchan(dev, PCMDIR_REC, &ad1816chan_class, ad1816);
+    	pcm_addchan(dev, PCMDIR_PLAY, &ad1816chan_class, ad1816);
     	pcm_setstatus(dev, status);
 
     	return 0;
diff --git a/sys/dev/sound/isa/ess.c b/sys/dev/sound/isa/ess.c
index 7841e35..f353289 100644
--- a/sys/dev/sound/isa/ess.c
+++ b/sys/dev/sound/isa/ess.c
@@ -36,6 +36,8 @@
 #include  <dev/sound/isa/sb.h>
 #include  <dev/sound/chip.h>
 
+#include "mixer_if.h"
+
 #define ESS_BUFFSIZE (4096)
 #define ABS(x) (((x) < 0)? -(x) : (x))
 
@@ -45,15 +47,6 @@
 /* more accurate clocks and split audio1/audio2 rates */
 #define ESS18XX_NEWSPEED
 
-/* channel interface for ESS */
-static void *esschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int esschan_setformat(void *data, u_int32_t format);
-static int esschan_setspeed(void *data, u_int32_t speed);
-static int esschan_setblocksize(void *data, u_int32_t blocksize);
-static int esschan_trigger(void *data, int go);
-static int esschan_getptr(void *data);
-static pcmchan_caps *esschan_getcaps(void *data);
-
 static u_int32_t ess_pfmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -82,32 +75,13 @@ static u_int32_t ess_rfmt[] = {
 
 static pcmchan_caps ess_reccaps = {5000, 49000, ess_rfmt, 0};
 
-static pcm_channel ess_chantemplate = {
-	esschan_init,
-	NULL, 			/* setdir */
-	esschan_setformat,
-	esschan_setspeed,
-	esschan_setblocksize,
-	esschan_trigger,
-	esschan_getptr,
-	esschan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 struct ess_info;
 
 struct ess_chinfo {
 	struct ess_info *parent;
 	pcm_channel *channel;
 	snd_dbuf *buffer;
-	int dir, hwch, stopping;
+	int dir, hwch, stopping, run;
 	u_int32_t fmt, spd;
 };
 
@@ -142,19 +116,6 @@ static int ess_setupch(struct ess_info *sc, int ch, int dir, int spd, u_int32_t
 static int ess_start(struct ess_chinfo *ch);
 static int ess_stop(struct ess_chinfo *ch);
 
-static int essmix_init(snd_mixer *m);
-static int essmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int essmix_setrecsrc(snd_mixer *m, u_int32_t src);
-
-static snd_mixer ess_mixer = {
-    	"ESS mixer",
-    	essmix_init,
-	NULL,
-	NULL,
-    	essmix_set,
-    	essmix_setrecsrc,
-};
-
 static devclass_t pcm_devclass;
 
 /*
@@ -377,94 +338,6 @@ ess_alloc_resources(struct ess_info *sc, device_t dev)
 	} else return ENXIO;
 }
 
-static int
-ess_doattach(device_t dev, struct ess_info *sc)
-{
-    	char status[SND_STATUSLEN], buf[64];
-	int ver;
-
-    	if (ess_alloc_resources(sc, dev))
-		goto no;
-    	if (ess_reset_dsp(sc))
-		goto no;
-    	mixer_init(dev, &ess_mixer, sc);
-
-	sc->duplex = 0;
-	sc->newspeed = 0;
-	ver = (ess_getmixer(sc, 0x40) << 8) | ess_rd(sc, SB_MIX_DATA);
-	snprintf(buf, sizeof buf, "ESS %x DSP", ver);
-	device_set_desc_copy(dev, buf);
-	if (bootverbose)
-		device_printf(dev, "ESS%x detected", ver);
-
-	switch (ver) {
-	case 0x1869:
-	case 0x1879:
-#ifdef ESS18XX_DUPLEX
-		sc->duplex = sc->drq2? 1 : 0;
-#endif
-#ifdef ESS18XX_NEWSPEED
-		sc->newspeed = 1;
-#endif
-		break;
-	}
-	if (bootverbose)
-		printf("%s%s\n", sc->duplex? ", duplex" : "",
-				 sc->newspeed? ", newspeed" : "");
-
-	if (sc->newspeed)
-		ess_setmixer(sc, 0x71, 0x22);
-
-	bus_setup_intr(dev, sc->irq, INTR_TYPE_TTY, ess_intr, sc, &sc->ih);
-    	if (!sc->duplex)
-		pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX);
-
-    	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
-			/*lowaddr*/BUS_SPACE_MAXADDR_24BIT,
-			/*highaddr*/BUS_SPACE_MAXADDR,
-			/*filter*/NULL, /*filterarg*/NULL,
-			/*maxsize*/ESS_BUFFSIZE, /*nsegments*/1,
-			/*maxsegz*/0x3ffff,
-			/*flags*/0, &sc->parent_dmat) != 0) {
-		device_printf(dev, "unable to create dma tag\n");
-		goto no;
-    	}
-
-    	snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld drq %ld",
-    	     	rman_get_start(sc->io_base), rman_get_start(sc->irq),
-		rman_get_start(sc->drq1));
-    	if (sc->drq2)
-		snprintf(status + strlen(status), SND_STATUSLEN - strlen(status),
-			":%ld", rman_get_start(sc->drq2));
-
-    	if (pcm_register(dev, sc, 1, 1))
-		goto no;
-      	pcm_addchan(dev, PCMDIR_REC, &ess_chantemplate, sc);
-	pcm_addchan(dev, PCMDIR_PLAY, &ess_chantemplate, sc);
-	pcm_setstatus(dev, status);
-
-    	return 0;
-
-no:
-    	ess_release_resources(sc, dev);
-    	return ENXIO;
-}
-
-static int
-ess_detach(device_t dev)
-{
-	int r;
-	struct ess_info *sc;
-
-	r = pcm_unregister(dev);
-	if (r)
-		return r;
-
-	sc = pcm_getdevinfo(dev);
-    	ess_release_resources(sc, dev);
-	return 0;
-}
-
 static void
 ess_intr(void *arg)
 {
@@ -481,7 +354,10 @@ ess_intr(void *arg)
 	rirq = (src & sc->rch.hwch)? 1 : 0;
 
 	if (pirq) {
+		if (!sc->pch.run)
+			printf("ess: play intr while not running\n");
 		if (sc->pch.stopping) {
+			sc->pch.run = 0;
 			buf_isadma(sc->pch.buffer, PCMTRIG_STOP);
 			sc->pch.stopping = 0;
 			if (sc->pch.hwch == 1)
@@ -493,7 +369,10 @@ ess_intr(void *arg)
 	}
 
 	if (rirq) {
+		if (!sc->rch.run)
+			printf("ess: record intr while not running\n");
 		if (sc->rch.stopping) {
+			sc->rch.run = 0;
 			buf_isadma(sc->rch.buffer, PCMTRIG_STOP);
 			sc->rch.stopping = 0;
 			/* XXX: will this stop audio2? */
@@ -657,9 +536,10 @@ ess_stop(struct ess_chinfo *ch)
 	return 0;
 }
 
+/* -------------------------------------------------------------------- */
 /* channel interface for ESS18xx */
 static void *
-esschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+esschan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct ess_info *sc = devinfo;
 	struct ess_chinfo *ch = (dir == PCMDIR_PLAY)? &sc->pch : &sc->rch;
@@ -679,7 +559,7 @@ esschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-esschan_setformat(void *data, u_int32_t format)
+esschan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct ess_chinfo *ch = data;
 
@@ -688,7 +568,7 @@ esschan_setformat(void *data, u_int32_t format)
 }
 
 static int
-esschan_setspeed(void *data, u_int32_t speed)
+esschan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct ess_chinfo *ch = data;
 	struct ess_info *sc = ch->parent;
@@ -702,13 +582,13 @@ esschan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-esschan_setblocksize(void *data, u_int32_t blocksize)
+esschan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-esschan_trigger(void *data, int go)
+esschan_trigger(kobj_t obj, void *data, int go)
 {
 	struct ess_chinfo *ch = data;
 
@@ -717,6 +597,7 @@ esschan_trigger(void *data, int go)
 
 	switch (go) {
 	case PCMTRIG_START:
+		ch->run = 1;
 		buf_isadma(ch->buffer, go);
 		ess_start(ch);
 		break;
@@ -731,7 +612,7 @@ esschan_trigger(void *data, int go)
 }
 
 static int
-esschan_getptr(void *data)
+esschan_getptr(kobj_t obj, void *data)
 {
 	struct ess_chinfo *ch = data;
 
@@ -739,13 +620,25 @@ esschan_getptr(void *data)
 }
 
 static pcmchan_caps *
-esschan_getcaps(void *data)
+esschan_getcaps(kobj_t obj, void *data)
 {
 	struct ess_chinfo *ch = data;
 
 	return (ch->dir == PCMDIR_PLAY)? &ess_playcaps : &ess_reccaps;
 }
 
+static kobj_method_t esschan_methods[] = {
+    	KOBJMETHOD(channel_init,		esschan_init),
+    	KOBJMETHOD(channel_setformat,		esschan_setformat),
+    	KOBJMETHOD(channel_setspeed,		esschan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	esschan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		esschan_trigger),
+    	KOBJMETHOD(channel_getptr,		esschan_getptr),
+    	KOBJMETHOD(channel_getcaps,		esschan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(esschan);
+
 /************************************************************/
 
 static int
@@ -856,6 +749,16 @@ essmix_setrecsrc(snd_mixer *m, u_int32_t src)
 	return src;
 }
 
+static kobj_method_t essmixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		essmix_init),
+    	KOBJMETHOD(mixer_set,		essmix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	essmix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(essmixer);
+
+/************************************************************/
+
 static int
 ess_probe(device_t dev)
 {
@@ -880,13 +783,95 @@ static int
 ess_attach(device_t dev)
 {
     	struct ess_info *sc;
+    	char status[SND_STATUSLEN], buf[64];
+	int ver;
 
     	sc = (struct ess_info *)malloc(sizeof *sc, M_DEVBUF, M_NOWAIT);
     	if (!sc)
 		return ENXIO;
     	bzero(sc, sizeof *sc);
 
-    	return ess_doattach(dev, sc);
+    	if (ess_alloc_resources(sc, dev))
+		goto no;
+    	if (ess_reset_dsp(sc))
+		goto no;
+    	if (mixer_init(dev, &essmixer_class, sc))
+		goto no;
+
+	sc->duplex = 0;
+	sc->newspeed = 0;
+	ver = (ess_getmixer(sc, 0x40) << 8) | ess_rd(sc, SB_MIX_DATA);
+	snprintf(buf, sizeof buf, "ESS %x DSP", ver);
+	device_set_desc_copy(dev, buf);
+	if (bootverbose)
+		device_printf(dev, "ESS%x detected", ver);
+
+	switch (ver) {
+	case 0x1869:
+	case 0x1879:
+#ifdef ESS18XX_DUPLEX
+		sc->duplex = sc->drq2? 1 : 0;
+#endif
+#ifdef ESS18XX_NEWSPEED
+		sc->newspeed = 1;
+#endif
+		break;
+	}
+	if (bootverbose)
+		printf("%s%s\n", sc->duplex? ", duplex" : "",
+				 sc->newspeed? ", newspeed" : "");
+
+	if (sc->newspeed)
+		ess_setmixer(sc, 0x71, 0x22);
+
+	bus_setup_intr(dev, sc->irq, INTR_TYPE_TTY, ess_intr, sc, &sc->ih);
+    	if (!sc->duplex)
+		pcm_setflags(dev, pcm_getflags(dev) | SD_F_SIMPLEX);
+
+    	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
+			/*lowaddr*/BUS_SPACE_MAXADDR_24BIT,
+			/*highaddr*/BUS_SPACE_MAXADDR,
+			/*filter*/NULL, /*filterarg*/NULL,
+			/*maxsize*/ESS_BUFFSIZE, /*nsegments*/1,
+			/*maxsegz*/0x3ffff,
+			/*flags*/0, &sc->parent_dmat) != 0) {
+		device_printf(dev, "unable to create dma tag\n");
+		goto no;
+    	}
+
+    	snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld drq %ld",
+    	     	rman_get_start(sc->io_base), rman_get_start(sc->irq),
+		rman_get_start(sc->drq1));
+    	if (sc->drq2)
+		snprintf(status + strlen(status), SND_STATUSLEN - strlen(status),
+			":%ld", rman_get_start(sc->drq2));
+
+    	if (pcm_register(dev, sc, 1, 1))
+		goto no;
+      	pcm_addchan(dev, PCMDIR_REC, &esschan_class, sc);
+	pcm_addchan(dev, PCMDIR_PLAY, &esschan_class, sc);
+	pcm_setstatus(dev, status);
+
+    	return 0;
+
+no:
+    	ess_release_resources(sc, dev);
+    	return ENXIO;
+}
+
+static int
+ess_detach(device_t dev)
+{
+	int r;
+	struct ess_info *sc;
+
+	r = pcm_unregister(dev);
+	if (r)
+		return r;
+
+	sc = pcm_getdevinfo(dev);
+    	ess_release_resources(sc, dev);
+	return 0;
 }
 
 static device_method_t ess_methods[] = {
@@ -908,6 +893,7 @@ DRIVER_MODULE(snd_ess, sbc, ess_driver, pcm_devclass, 0, 0);
 MODULE_DEPEND(snd_ess, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
 MODULE_VERSION(snd_ess, 1);
 
+/************************************************************/
 
 static devclass_t esscontrol_devclass;
 
diff --git a/sys/dev/sound/isa/mss.c b/sys/dev/sound/isa/mss.c
index 3b24a75..3c6a126 100644
--- a/sys/dev/sound/isa/mss.c
+++ b/sys/dev/sound/isa/mss.c
@@ -34,6 +34,8 @@
 #include <dev/sound/isa/mss.h>
 #include <dev/sound/chip.h>
 
+#include "mixer_if.h"
+
 #define MSS_BUFFSIZE (4096)
 #define	abs(x)	(((x) < 0) ? -(x) : (x))
 #define MSS_INDEXED_REGS 0x20
@@ -105,42 +107,8 @@ static int 		pnpmss_attach(device_t dev);
 
 static driver_intr_t 	opti931_intr;
 
-static int mssmix_init(snd_mixer *m);
-static int mssmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int mssmix_setrecsrc(snd_mixer *m, u_int32_t src);
-static snd_mixer mss_mixer = {
-    	"MSS mixer",
-    	mssmix_init,
-	NULL,
-	NULL,
-    	mssmix_set,
-    	mssmix_setrecsrc,
-};
-
-static int ymmix_init(snd_mixer *m);
-static int ymmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int ymmix_setrecsrc(snd_mixer *m, u_int32_t src);
-static snd_mixer yamaha_mixer = {
-    	"OPL3-SAx mixer",
-    	ymmix_init,
-	NULL,
-	NULL,
-    	ymmix_set,
-    	ymmix_setrecsrc,
-};
-
 static devclass_t pcm_devclass;
 
-/* channel interface */
-static void *msschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int msschan_setdir(void *data, int dir);
-static int msschan_setformat(void *data, u_int32_t format);
-static int msschan_setspeed(void *data, u_int32_t speed);
-static int msschan_setblocksize(void *data, u_int32_t blocksize);
-static int msschan_trigger(void *data, int go);
-static int msschan_getptr(void *data);
-static pcmchan_caps *msschan_getcaps(void *data);
-
 static u_int32_t mss_fmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -174,25 +142,6 @@ static u_int32_t opti931_fmt[] = {
 };
 static pcmchan_caps opti931_caps = {4000, 48000, opti931_fmt, 0};
 
-static pcm_channel mss_chantemplate = {
-	msschan_init,
-	msschan_setdir,
-	msschan_setformat,
-	msschan_setspeed,
-	msschan_setblocksize,
-	msschan_trigger,
-	msschan_getptr,
-	msschan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 #define MD_AD1848	0x91
 #define MD_AD1845	0x92
 #define MD_CS42XX	0xA1
@@ -361,6 +310,214 @@ mss_alloc_resources(struct mss_info *mss, device_t dev)
     	return ok;
 }
 
+/* -------------------------------------------------------------------- */
+/* only one source can be set... */
+static int
+mss_set_recsrc(struct mss_info *mss, int mask)
+{
+    	u_char   recdev;
+
+    	switch (mask) {
+    	case SOUND_MASK_LINE:
+    	case SOUND_MASK_LINE3:
+		recdev = 0;
+		break;
+
+    	case SOUND_MASK_CD:
+    	case SOUND_MASK_LINE1:
+		recdev = 0x40;
+		break;
+
+    	case SOUND_MASK_IMIX:
+		recdev = 0xc0;
+		break;
+
+    	case SOUND_MASK_MIC:
+    	default:
+		mask = SOUND_MASK_MIC;
+		recdev = 0x80;
+    	}
+    	ad_write(mss, 0, (ad_read(mss, 0) & 0x3f) | recdev);
+    	ad_write(mss, 1, (ad_read(mss, 1) & 0x3f) | recdev);
+    	return mask;
+}
+
+/* there are differences in the mixer depending on the actual sound card. */
+static int
+mss_mixer_set(struct mss_info *mss, int dev, int left, int right)
+{
+    	int        regoffs;
+    	mixer_tab *mix_d = (mss->bd_id == MD_OPTI931)? &opti931_devices : &mix_devices;
+    	u_char     old, val;
+
+    	if ((*mix_d)[dev][LEFT_CHN].nbits == 0) {
+		DEB(printf("nbits = 0 for dev %d\n", dev));
+		return -1;
+    	}
+
+    	if ((*mix_d)[dev][RIGHT_CHN].nbits == 0) right = left; /* mono */
+
+    	/* Set the left channel */
+
+    	regoffs = (*mix_d)[dev][LEFT_CHN].regno;
+    	old = val = ad_read(mss, regoffs);
+    	/* if volume is 0, mute chan. Otherwise, unmute. */
+    	if (regoffs != 0) val = (left == 0)? old | 0x80 : old & 0x7f;
+    	change_bits(mix_d, &val, dev, LEFT_CHN, left);
+    	ad_write(mss, regoffs, val);
+
+    	DEB(printf("LEFT: dev %d reg %d old 0x%02x new 0x%02x\n",
+		dev, regoffs, old, val));
+
+    	if ((*mix_d)[dev][RIGHT_CHN].nbits != 0) { /* have stereo */
+		/* Set the right channel */
+		regoffs = (*mix_d)[dev][RIGHT_CHN].regno;
+		old = val = ad_read(mss, regoffs);
+		if (regoffs != 1) val = (right == 0)? old | 0x80 : old & 0x7f;
+		change_bits(mix_d, &val, dev, RIGHT_CHN, right);
+		ad_write(mss, regoffs, val);
+
+		DEB(printf("RIGHT: dev %d reg %d old 0x%02x new 0x%02x\n",
+	    	dev, regoffs, old, val));
+    	}
+    	return 0; /* success */
+}
+
+/* -------------------------------------------------------------------- */
+
+static int
+mssmix_init(snd_mixer *m)
+{
+	struct mss_info *mss = mix_getdevinfo(m);
+
+	mix_setdevs(m, MODE2_MIXER_DEVICES);
+	mix_setrecdevs(m, MSS_REC_DEVICES);
+	switch(mss->bd_id) {
+	case MD_OPTI931:
+		mix_setdevs(m, OPTI931_MIXER_DEVICES);
+		ad_write(mss, 20, 0x88);
+		ad_write(mss, 21, 0x88);
+		break;
+
+	case MD_AD1848:
+		mix_setdevs(m, MODE1_MIXER_DEVICES);
+		break;
+
+	case MD_GUSPNP:
+	case MD_GUSMAX:
+		/* this is only necessary in mode 3 ... */
+		ad_write(mss, 22, 0x88);
+		ad_write(mss, 23, 0x88);
+		break;
+	}
+	return 0;
+}
+
+static int
+mssmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right)
+{
+	struct mss_info *mss = mix_getdevinfo(m);
+
+	mss_mixer_set(mss, dev, left, right);
+
+	return left | (right << 8);
+}
+
+static int
+mssmix_setrecsrc(snd_mixer *m, u_int32_t src)
+{
+	struct mss_info *mss = mix_getdevinfo(m);
+
+	src = mss_set_recsrc(mss, src);
+	return src;
+}
+
+static kobj_method_t mssmix_mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		mssmix_init),
+    	KOBJMETHOD(mixer_set,		mssmix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	mssmix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(mssmix_mixer);
+
+/* -------------------------------------------------------------------- */
+
+static int
+ymmix_init(snd_mixer *m)
+{
+	struct mss_info *mss = mix_getdevinfo(m);
+
+	mssmix_init(m);
+	mix_setdevs(m, mix_getdevs(m) | SOUND_MASK_VOLUME | SOUND_MASK_MIC
+				      | SOUND_MASK_BASS | SOUND_MASK_TREBLE);
+	/* Set master volume */
+	conf_wr(mss, OPL3SAx_VOLUMEL, 7);
+	conf_wr(mss, OPL3SAx_VOLUMER, 7);
+
+	return 0;
+}
+
+static int
+ymmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right)
+{
+	struct mss_info *mss = mix_getdevinfo(m);
+	int t, l, r;
+
+	switch (dev) {
+	case SOUND_MIXER_VOLUME:
+		if (left) t = 15 - (left * 15) / 100;
+		else t = 0x80; /* mute */
+		conf_wr(mss, OPL3SAx_VOLUMEL, t);
+		if (right) t = 15 - (right * 15) / 100;
+		else t = 0x80; /* mute */
+		conf_wr(mss, OPL3SAx_VOLUMER, t);
+		break;
+
+	case SOUND_MIXER_MIC:
+		t = left;
+		if (left) t = 31 - (left * 31) / 100;
+		else t = 0x80; /* mute */
+		conf_wr(mss, OPL3SAx_MIC, t);
+		break;
+
+	case SOUND_MIXER_BASS:
+		l = (left * 7) / 100;
+		r = (right * 7) / 100;
+		t = (r << 4) | l;
+		conf_wr(mss, OPL3SAx_BASS, t);
+		break;
+
+	case SOUND_MIXER_TREBLE:
+		l = (left * 7) / 100;
+		r = (right * 7) / 100;
+		t = (r << 4) | l;
+		conf_wr(mss, OPL3SAx_TREBLE, t);
+		break;
+
+	default:
+		mss_mixer_set(mss, dev, left, right);
+	}
+
+	return left | (right << 8);
+}
+
+static int
+ymmix_setrecsrc(snd_mixer *m, u_int32_t src)
+{
+	struct mss_info *mss = mix_getdevinfo(m);
+	src = mss_set_recsrc(mss, src);
+	return src;
+}
+
+static kobj_method_t ymmix_mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		ymmix_init),
+    	KOBJMETHOD(mixer_set,		ymmix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	ymmix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(ymmix_mixer);
+
+/* -------------------------------------------------------------------- */
 /*
  * XXX This might be better off in the gusc driver.
  */
@@ -503,6 +660,464 @@ mss_init(struct mss_info *mss, device_t dev)
 	return 0;
 }
 
+
+/*
+ * main irq handler for the CS423x. The OPTi931 code is
+ * a separate one.
+ * The correct way to operate for a device with multiple internal
+ * interrupt sources is to loop on the status register and ack
+ * interrupts until all interrupts are served and none are reported. At
+ * this point the IRQ line to the ISA IRQ controller should go low
+ * and be raised at the next interrupt.
+ *
+ * Since the ISA IRQ controller is sent EOI _before_ passing control
+ * to the isr, it might happen that we serve an interrupt early, in
+ * which case the status register at the next interrupt should just
+ * say that there are no more interrupts...
+ */
+
+static void
+mss_intr(void *arg)
+{
+    	struct mss_info *mss = arg;
+    	u_char c = 0, served = 0;
+    	int i;
+
+    	DEB(printf("mss_intr\n"));
+    	ad_read(mss, 11); /* fake read of status bits */
+
+    	/* loop until there are interrupts, but no more than 10 times. */
+    	for (i = 10; i > 0 && io_rd(mss, MSS_STATUS) & 1; i--) {
+		/* get exact reason for full-duplex boards */
+		c = FULL_DUPLEX(mss)? ad_read(mss, 24) : 0x30;
+		c &= ~served;
+		if (mss->pch.buffer->dl && (c & 0x10)) {
+	    		served |= 0x10;
+	    		chn_intr(mss->pch.channel);
+		}
+		if (mss->rch.buffer->dl && (c & 0x20)) {
+	    		served |= 0x20;
+	    		chn_intr(mss->rch.channel);
+		}
+		/* now ack the interrupt */
+		if (FULL_DUPLEX(mss)) ad_write(mss, 24, ~c); /* ack selectively */
+		else io_wr(mss, MSS_STATUS, 0);	/* Clear interrupt status */
+    	}
+    	if (i == 10) {
+		BVDDB(printf("mss_intr: irq, but not from mss\n"));
+	} else if (served == 0) {
+		BVDDB(printf("mss_intr: unexpected irq with reason %x\n", c));
+		/*
+	 	* this should not happen... I have no idea what to do now.
+	 	* maybe should do a sanity check and restart dmas ?
+	 	*/
+		io_wr(mss, MSS_STATUS, 0);	/* Clear interrupt status */
+    	}
+}
+
+/*
+ * AD_WAIT_INIT waits if we are initializing the board and
+ * we cannot modify its settings
+ */
+static int
+ad_wait_init(struct mss_info *mss, int x)
+{
+    	int arg = x, n = 0; /* to shut up the compiler... */
+    	for (; x > 0; x--)
+		if ((n = io_rd(mss, MSS_INDEX)) & MSS_IDXBUSY) DELAY(10);
+		else return n;
+    	printf("AD_WAIT_INIT FAILED %d 0x%02x\n", arg, n);
+    	return n;
+}
+
+static int
+ad_read(struct mss_info *mss, int reg)
+{
+    	u_long   flags;
+    	int             x;
+
+    	flags = spltty();
+    	ad_wait_init(mss, 201);
+    	x = io_rd(mss, MSS_INDEX) & ~MSS_IDXMASK;
+    	io_wr(mss, MSS_INDEX, (u_char)(reg & MSS_IDXMASK) | x);
+    	x = io_rd(mss, MSS_IDATA);
+    	splx(flags);
+	/* printf("ad_read %d, %x\n", reg, x); */
+    	return x;
+}
+
+static void
+ad_write(struct mss_info *mss, int reg, u_char data)
+{
+    	u_long   flags;
+
+    	int x;
+	/* printf("ad_write %d, %x\n", reg, data); */
+    	flags = spltty();
+    	ad_wait_init(mss, 1002);
+    	x = io_rd(mss, MSS_INDEX) & ~MSS_IDXMASK;
+    	io_wr(mss, MSS_INDEX, (u_char)(reg & MSS_IDXMASK) | x);
+    	io_wr(mss, MSS_IDATA, data);
+    	splx(flags);
+}
+
+static void
+ad_write_cnt(struct mss_info *mss, int reg, u_short cnt)
+{
+    	ad_write(mss, reg+1, cnt & 0xff);
+    	ad_write(mss, reg, cnt >> 8); /* upper base must be last */
+}
+
+static void
+wait_for_calibration(struct mss_info *mss)
+{
+    	int t;
+
+    	/*
+     	 * Wait until the auto calibration process has finished.
+     	 *
+     	 * 1) Wait until the chip becomes ready (reads don't return 0x80).
+     	 * 2) Wait until the ACI bit of I11 gets on
+     	 * 3) Wait until the ACI bit of I11 gets off
+     	 */
+
+    	t = ad_wait_init(mss, 1000);
+    	if (t & MSS_IDXBUSY) printf("mss: Auto calibration timed out(1).\n");
+
+	/*
+	 * The calibration mode for chips that support it is set so that
+	 * we never see ACI go on.
+	 */
+	if (mss->bd_id == MD_GUSMAX || mss->bd_id == MD_GUSPNP) {
+		for (t = 100; t > 0 && (ad_read(mss, 11) & 0x20) == 0; t--);
+	} else {
+       		/*
+		 * XXX This should only be enabled for cards that *really*
+		 * need it.  Are there any?
+		 */
+  		for (t = 100; t > 0 && (ad_read(mss, 11) & 0x20) == 0; t--) DELAY(100);
+	}
+    	for (t = 100; t > 0 && ad_read(mss, 11) & 0x20; t--) DELAY(100);
+}
+
+static void
+ad_unmute(struct mss_info *mss)
+{
+    	ad_write(mss, 6, ad_read(mss, 6) & ~I6_MUTE);
+    	ad_write(mss, 7, ad_read(mss, 7) & ~I6_MUTE);
+}
+
+static void
+ad_enter_MCE(struct mss_info *mss)
+{
+    	int prev;
+
+    	mss->bd_flags |= BD_F_MCE_BIT;
+    	ad_wait_init(mss, 203);
+    	prev = io_rd(mss, MSS_INDEX);
+    	prev &= ~MSS_TRD;
+    	io_wr(mss, MSS_INDEX, prev | MSS_MCE);
+}
+
+static void
+ad_leave_MCE(struct mss_info *mss)
+{
+    	u_long   flags;
+    	u_char   prev;
+
+    	if ((mss->bd_flags & BD_F_MCE_BIT) == 0) {
+		DEB(printf("--- hey, leave_MCE: MCE bit was not set!\n"));
+		return;
+    	}
+
+    	ad_wait_init(mss, 1000);
+
+    	flags = spltty();
+    	mss->bd_flags &= ~BD_F_MCE_BIT;
+
+    	prev = io_rd(mss, MSS_INDEX);
+    	prev &= ~MSS_TRD;
+    	io_wr(mss, MSS_INDEX, prev & ~MSS_MCE); /* Clear the MCE bit */
+    	wait_for_calibration(mss);
+    	splx(flags);
+}
+
+static int
+mss_speed(struct mss_chinfo *ch, int speed)
+{
+    	struct mss_info *mss = ch->parent;
+    	/*
+     	* In the CS4231, the low 4 bits of I8 are used to hold the
+     	* sample rate.  Only a fixed number of values is allowed. This
+     	* table lists them. The speed-setting routines scans the table
+     	* looking for the closest match. This is the only supported method.
+     	*
+     	* In the CS4236, there is an alternate metod (which we do not
+     	* support yet) which provides almost arbitrary frequency setting.
+     	* In the AD1845, it looks like the sample rate can be
+     	* almost arbitrary, and written directly to a register.
+     	* In the OPTi931, there is a SB command which provides for
+     	* almost arbitrary frequency setting.
+     	*
+     	*/
+    	ad_enter_MCE(mss);
+    	if (mss->bd_id == MD_AD1845) { /* Use alternate speed select regs */
+		ad_write(mss, 22, (speed >> 8) & 0xff);	/* Speed MSB */
+		ad_write(mss, 23, speed & 0xff);	/* Speed LSB */
+		/* XXX must also do something in I27 for the ad1845 */
+    	} else {
+        	int i, sel = 0; /* assume entry 0 does not contain -1 */
+        	static int speeds[] =
+      	    	{8000, 5512, 16000, 11025, 27429, 18900, 32000, 22050,
+	    	-1, 37800, -1, 44100, 48000, 33075, 9600, 6615};
+
+        	for (i = 1; i < 16; i++)
+   		    	if (speeds[i] > 0 &&
+			    abs(speed-speeds[i]) < abs(speed-speeds[sel])) sel = i;
+        	speed = speeds[sel];
+        	ad_write(mss, 8, (ad_read(mss, 8) & 0xf0) | sel);
+    	}
+    	ad_leave_MCE(mss);
+
+    	return speed;
+}
+
+/*
+ * mss_format checks that the format is supported (or defaults to AFMT_U8)
+ * and returns the bit setting for the 1848 register corresponding to
+ * the desired format.
+ *
+ * fixed lr970724
+ */
+
+static int
+mss_format(struct mss_chinfo *ch, u_int32_t format)
+{
+    	struct mss_info *mss = ch->parent;
+    	int i, arg = format & ~AFMT_STEREO;
+
+    	/*
+     	* The data format uses 3 bits (just 2 on the 1848). For each
+     	* bit setting, the following array returns the corresponding format.
+     	* The code scans the array looking for a suitable format. In
+     	* case it is not found, default to AFMT_U8 (not such a good
+     	* choice, but let's do it for compatibility...).
+     	*/
+
+    	static int fmts[] =
+        	{AFMT_U8, AFMT_MU_LAW, AFMT_S16_LE, AFMT_A_LAW,
+		-1, AFMT_IMA_ADPCM, AFMT_U16_BE, -1};
+
+	ch->fmt = format;
+    	for (i = 0; i < 8; i++) if (arg == fmts[i]) break;
+    	arg = i << 1;
+    	if (format & AFMT_STEREO) arg |= 1;
+    	arg <<= 4;
+    	ad_enter_MCE(mss);
+    	ad_write(mss, 8, (ad_read(mss, 8) & 0x0f) | arg);
+    	if (FULL_DUPLEX(mss)) ad_write(mss, 28, arg); /* capture mode */
+    	ad_leave_MCE(mss);
+    	return format;
+}
+
+static int
+mss_trigger(struct mss_chinfo *ch, int go)
+{
+    	struct mss_info *mss = ch->parent;
+    	u_char m;
+    	int retry, wr, cnt, ss;
+
+	ss = 1;
+	ss <<= (ch->fmt & AFMT_STEREO)? 1 : 0;
+	ss <<= (ch->fmt & AFMT_16BIT)? 1 : 0;
+
+	wr = (ch->dir == PCMDIR_PLAY)? 1 : 0;
+    	m = ad_read(mss, 9);
+    	switch (go) {
+    	case PCMTRIG_START:
+		cnt = (ch->buffer->dl / ss) - 1;
+
+		DEB(if (m & 4) printf("OUCH! reg 9 0x%02x\n", m););
+		m |= wr? I9_PEN : I9_CEN; /* enable DMA */
+		ad_write_cnt(mss, (wr || !FULL_DUPLEX(mss))? 14 : 30, cnt);
+		break;
+
+    	case PCMTRIG_STOP:
+    	case PCMTRIG_ABORT: /* XXX check this... */
+		m &= ~(wr? I9_PEN : I9_CEN); /* Stop DMA */
+#if 0
+		/*
+	 	* try to disable DMA by clearing count registers. Not sure it
+	 	* is needed, and it might cause false interrupts when the
+	 	* DMA is re-enabled later.
+	 	*/
+		ad_write_cnt(mss, (wr || !FULL_DUPLEX(mss))? 14 : 30, 0);
+#endif
+    	}
+    	/* on the OPTi931 the enable bit seems hard to set... */
+    	for (retry = 10; retry > 0; retry--) {
+        	ad_write(mss, 9, m);
+        	if (ad_read(mss, 9) == m) break;
+    	}
+    	if (retry == 0) BVDDB(printf("stop dma, failed to set bit 0x%02x 0x%02x\n", \
+			       m, ad_read(mss, 9)));
+    	return 0;
+}
+
+
+/*
+ * the opti931 seems to miss interrupts when working in full
+ * duplex, so we try some heuristics to catch them.
+ */
+static void
+opti931_intr(void *arg)
+{
+    	struct mss_info *mss = (struct mss_info *)arg;
+    	u_char masked = 0, i11, mc11, c = 0;
+    	u_char reason; /* b0 = playback, b1 = capture, b2 = timer */
+    	int loops = 10;
+
+#if 0
+    	reason = io_rd(mss, MSS_STATUS);
+    	if (!(reason & 1)) {/* no int, maybe a shared line ? */
+		DEB(printf("intr: flag 0, mcir11 0x%02x\n", ad_read(mss, 11)));
+		return;
+    	}
+#endif
+    	i11 = ad_read(mss, 11); /* XXX what's for ? */
+	again:
+
+    	c = mc11 = FULL_DUPLEX(mss)? opti_rd(mss, 11) : 0xc;
+    	mc11 &= 0x0c;
+    	if (c & 0x10) {
+		DEB(printf("Warning: CD interrupt\n");)
+		mc11 |= 0x10;
+    	}
+    	if (c & 0x20) {
+		DEB(printf("Warning: MPU interrupt\n");)
+		mc11 |= 0x20;
+    	}
+    	if (mc11 & masked) BVDDB(printf("irq reset failed, mc11 0x%02x, 0x%02x\n",\
+                              	  mc11, masked));
+    	masked |= mc11;
+    	/*
+     	* the nice OPTi931 sets the IRQ line before setting the bits in
+     	* mc11. So, on some occasions I have to retry (max 10 times).
+     	*/
+    	if (mc11 == 0) { /* perhaps can return ... */
+		reason = io_rd(mss, MSS_STATUS);
+		if (reason & 1) {
+	    		DEB(printf("one more try...\n");)
+	    		if (--loops) goto again;
+	    		else DDB(printf("intr, but mc11 not set\n");)
+		}
+		if (loops == 0) BVDDB(printf("intr, nothing in mcir11 0x%02x\n", mc11));
+		return;
+    	}
+
+    	if (mss->rch.buffer->dl && (mc11 & 8)) chn_intr(mss->rch.channel);
+    	if (mss->pch.buffer->dl && (mc11 & 4)) chn_intr(mss->pch.channel);
+    	opti_wr(mss, 11, ~mc11); /* ack */
+    	if (--loops) goto again;
+    	DEB(printf("xxx too many loops\n");)
+}
+
+/* -------------------------------------------------------------------- */
+/* channel interface */
+static void *
+msschan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+{
+	struct mss_info *mss = devinfo;
+	struct mss_chinfo *ch = (dir == PCMDIR_PLAY)? &mss->pch : &mss->rch;
+
+	ch->parent = mss;
+	ch->channel = c;
+	ch->buffer = b;
+	ch->buffer->bufsize = MSS_BUFFSIZE;
+	ch->buffer->chan = (dir == PCMDIR_PLAY)? mss->pdma : mss->rdma;
+	ch->dir = dir;
+	if (chn_allocbuf(ch->buffer, mss->parent_dmat) == -1) return NULL;
+	return ch;
+}
+
+static int
+msschan_setformat(kobj_t obj, void *data, u_int32_t format)
+{
+	struct mss_chinfo *ch = data;
+
+	mss_format(ch, format);
+	return 0;
+}
+
+static int
+msschan_setspeed(kobj_t obj, void *data, u_int32_t speed)
+{
+	struct mss_chinfo *ch = data;
+
+	return mss_speed(ch, speed);
+}
+
+static int
+msschan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
+{
+	return blocksize;
+}
+
+static int
+msschan_trigger(kobj_t obj, void *data, int go)
+{
+	struct mss_chinfo *ch = data;
+
+	if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
+		return 0;
+
+	buf_isadma(ch->buffer, go);
+	mss_trigger(ch, go);
+	return 0;
+}
+
+static int
+msschan_getptr(kobj_t obj, void *data)
+{
+	struct mss_chinfo *ch = data;
+	return buf_isadmaptr(ch->buffer);
+}
+
+static pcmchan_caps *
+msschan_getcaps(kobj_t obj, void *data)
+{
+	struct mss_chinfo *ch = data;
+
+	switch(ch->parent->bd_id) {
+	case MD_OPTI931:
+		return &opti931_caps;
+		break;
+
+	case MD_GUSPNP:
+	case MD_GUSMAX:
+		return &guspnp_caps;
+		break;
+
+	default:
+		return &mss_caps;
+		break;
+	}
+}
+
+static kobj_method_t msschan_methods[] = {
+    	KOBJMETHOD(channel_init,		msschan_init),
+    	KOBJMETHOD(channel_setformat,		msschan_setformat),
+    	KOBJMETHOD(channel_setspeed,		msschan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	msschan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		msschan_trigger),
+    	KOBJMETHOD(channel_getptr,		msschan_getptr),
+    	KOBJMETHOD(channel_getcaps,		msschan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(msschan);
+
+/* -------------------------------------------------------------------- */
+
 /*
  * mss_probe() is the probe routine. Note, it is not necessary to
  * go through this for PnP devices, since they are already
@@ -919,7 +1534,7 @@ mss_doattach(device_t dev, struct mss_info *mss)
 		io_wr(mss, 0, bits);
 		printf("drq/irq conf %x\n", io_rd(mss, 0));
     	}
-    	mixer_init(dev, (mss->bd_id == MD_YM0020)? &yamaha_mixer : &mss_mixer, mss);
+    	mixer_init(dev, (mss->bd_id == MD_YM0020)? &ymmix_mixer_class : &mssmix_mixer_class, mss);
     	switch (mss->bd_id) {
     	case MD_OPTI931:
 		bus_setup_intr(dev, mss->irq, INTR_TYPE_TTY, opti931_intr, mss, &mss->ih);
@@ -945,8 +1560,8 @@ mss_doattach(device_t dev, struct mss_info *mss)
         	SND_STATUSLEN - strlen(status), ":%d", mss->rdma);
 
     	if (pcm_register(dev, mss, 1, 1)) goto no;
-    	pcm_addchan(dev, PCMDIR_REC, &mss_chantemplate, mss);
-    	pcm_addchan(dev, PCMDIR_PLAY, &mss_chantemplate, mss);
+    	pcm_addchan(dev, PCMDIR_REC, &msschan_class, mss);
+    	pcm_addchan(dev, PCMDIR_PLAY, &msschan_class, mss);
     	pcm_setstatus(dev, status);
 
     	return 0;
@@ -1084,384 +1699,6 @@ DRIVER_MODULE(snd_mss, isa, mss_driver, pcm_devclass, 0, 0);
 MODULE_DEPEND(snd_mss, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
 MODULE_VERSION(snd_mss, 1);
 
-
-/*
- * main irq handler for the CS423x. The OPTi931 code is
- * a separate one.
- * The correct way to operate for a device with multiple internal
- * interrupt sources is to loop on the status register and ack
- * interrupts until all interrupts are served and none are reported. At
- * this point the IRQ line to the ISA IRQ controller should go low
- * and be raised at the next interrupt.
- *
- * Since the ISA IRQ controller is sent EOI _before_ passing control
- * to the isr, it might happen that we serve an interrupt early, in
- * which case the status register at the next interrupt should just
- * say that there are no more interrupts...
- */
-
-static void
-mss_intr(void *arg)
-{
-    	struct mss_info *mss = arg;
-    	u_char c = 0, served = 0;
-    	int i;
-
-    	DEB(printf("mss_intr\n"));
-    	ad_read(mss, 11); /* fake read of status bits */
-
-    	/* loop until there are interrupts, but no more than 10 times. */
-    	for (i = 10; i > 0 && io_rd(mss, MSS_STATUS) & 1; i--) {
-		/* get exact reason for full-duplex boards */
-		c = FULL_DUPLEX(mss)? ad_read(mss, 24) : 0x30;
-		c &= ~served;
-		if (mss->pch.buffer->dl && (c & 0x10)) {
-	    		served |= 0x10;
-	    		chn_intr(mss->pch.channel);
-		}
-		if (mss->rch.buffer->dl && (c & 0x20)) {
-	    		served |= 0x20;
-	    		chn_intr(mss->rch.channel);
-		}
-		/* now ack the interrupt */
-		if (FULL_DUPLEX(mss)) ad_write(mss, 24, ~c); /* ack selectively */
-		else io_wr(mss, MSS_STATUS, 0);	/* Clear interrupt status */
-    	}
-    	if (i == 10) {
-		BVDDB(printf("mss_intr: irq, but not from mss\n"));
-	} else if (served == 0) {
-		BVDDB(printf("mss_intr: unexpected irq with reason %x\n", c));
-		/*
-	 	* this should not happen... I have no idea what to do now.
-	 	* maybe should do a sanity check and restart dmas ?
-	 	*/
-		io_wr(mss, MSS_STATUS, 0);	/* Clear interrupt status */
-    	}
-}
-
-/*
- * AD_WAIT_INIT waits if we are initializing the board and
- * we cannot modify its settings
- */
-static int
-ad_wait_init(struct mss_info *mss, int x)
-{
-    	int arg = x, n = 0; /* to shut up the compiler... */
-    	for (; x > 0; x--)
-		if ((n = io_rd(mss, MSS_INDEX)) & MSS_IDXBUSY) DELAY(10);
-		else return n;
-    	printf("AD_WAIT_INIT FAILED %d 0x%02x\n", arg, n);
-    	return n;
-}
-
-static int
-ad_read(struct mss_info *mss, int reg)
-{
-    	u_long   flags;
-    	int             x;
-
-    	flags = spltty();
-    	ad_wait_init(mss, 201);
-    	x = io_rd(mss, MSS_INDEX) & ~MSS_IDXMASK;
-    	io_wr(mss, MSS_INDEX, (u_char)(reg & MSS_IDXMASK) | x);
-    	x = io_rd(mss, MSS_IDATA);
-    	splx(flags);
-	/* printf("ad_read %d, %x\n", reg, x); */
-    	return x;
-}
-
-static void
-ad_write(struct mss_info *mss, int reg, u_char data)
-{
-    	u_long   flags;
-
-    	int x;
-	/* printf("ad_write %d, %x\n", reg, data); */
-    	flags = spltty();
-    	ad_wait_init(mss, 1002);
-    	x = io_rd(mss, MSS_INDEX) & ~MSS_IDXMASK;
-    	io_wr(mss, MSS_INDEX, (u_char)(reg & MSS_IDXMASK) | x);
-    	io_wr(mss, MSS_IDATA, data);
-    	splx(flags);
-}
-
-static void
-ad_write_cnt(struct mss_info *mss, int reg, u_short cnt)
-{
-    	ad_write(mss, reg+1, cnt & 0xff);
-    	ad_write(mss, reg, cnt >> 8); /* upper base must be last */
-}
-
-static void
-wait_for_calibration(struct mss_info *mss)
-{
-    	int t;
-
-    	/*
-     	 * Wait until the auto calibration process has finished.
-     	 *
-     	 * 1) Wait until the chip becomes ready (reads don't return 0x80).
-     	 * 2) Wait until the ACI bit of I11 gets on
-     	 * 3) Wait until the ACI bit of I11 gets off
-     	 */
-
-    	t = ad_wait_init(mss, 1000);
-    	if (t & MSS_IDXBUSY) printf("mss: Auto calibration timed out(1).\n");
-
-	/*
-	 * The calibration mode for chips that support it is set so that
-	 * we never see ACI go on.
-	 */
-	if (mss->bd_id == MD_GUSMAX || mss->bd_id == MD_GUSPNP) {
-		for (t = 100; t > 0 && (ad_read(mss, 11) & 0x20) == 0; t--);
-	} else {
-       		/*
-		 * XXX This should only be enabled for cards that *really*
-		 * need it.  Are there any?
-		 */
-  		for (t = 100; t > 0 && (ad_read(mss, 11) & 0x20) == 0; t--) DELAY(100);
-	}
-    	for (t = 100; t > 0 && ad_read(mss, 11) & 0x20; t--) DELAY(100);
-}
-
-static void
-ad_unmute(struct mss_info *mss)
-{
-    	ad_write(mss, 6, ad_read(mss, 6) & ~I6_MUTE);
-    	ad_write(mss, 7, ad_read(mss, 7) & ~I6_MUTE);
-}
-
-static void
-ad_enter_MCE(struct mss_info *mss)
-{
-    	int prev;
-
-    	mss->bd_flags |= BD_F_MCE_BIT;
-    	ad_wait_init(mss, 203);
-    	prev = io_rd(mss, MSS_INDEX);
-    	prev &= ~MSS_TRD;
-    	io_wr(mss, MSS_INDEX, prev | MSS_MCE);
-}
-
-static void
-ad_leave_MCE(struct mss_info *mss)
-{
-    	u_long   flags;
-    	u_char   prev;
-
-    	if ((mss->bd_flags & BD_F_MCE_BIT) == 0) {
-		DEB(printf("--- hey, leave_MCE: MCE bit was not set!\n"));
-		return;
-    	}
-
-    	ad_wait_init(mss, 1000);
-
-    	flags = spltty();
-    	mss->bd_flags &= ~BD_F_MCE_BIT;
-
-    	prev = io_rd(mss, MSS_INDEX);
-    	prev &= ~MSS_TRD;
-    	io_wr(mss, MSS_INDEX, prev & ~MSS_MCE); /* Clear the MCE bit */
-    	wait_for_calibration(mss);
-    	splx(flags);
-}
-
-/*
- * only one source can be set...
- */
-static int
-mss_set_recsrc(struct mss_info *mss, int mask)
-{
-    	u_char   recdev;
-
-    	switch (mask) {
-    	case SOUND_MASK_LINE:
-    	case SOUND_MASK_LINE3:
-		recdev = 0;
-		break;
-
-    	case SOUND_MASK_CD:
-    	case SOUND_MASK_LINE1:
-		recdev = 0x40;
-		break;
-
-    	case SOUND_MASK_IMIX:
-		recdev = 0xc0;
-		break;
-
-    	case SOUND_MASK_MIC:
-    	default:
-		mask = SOUND_MASK_MIC;
-		recdev = 0x80;
-    	}
-    	ad_write(mss, 0, (ad_read(mss, 0) & 0x3f) | recdev);
-    	ad_write(mss, 1, (ad_read(mss, 1) & 0x3f) | recdev);
-    	return mask;
-}
-
-/* there are differences in the mixer depending on the actual sound card. */
-static int
-mss_mixer_set(struct mss_info *mss, int dev, int left, int right)
-{
-    	int        regoffs;
-    	mixer_tab *mix_d = (mss->bd_id == MD_OPTI931)? &opti931_devices : &mix_devices;
-    	u_char     old, val;
-
-    	if ((*mix_d)[dev][LEFT_CHN].nbits == 0) {
-		DEB(printf("nbits = 0 for dev %d\n", dev));
-		return -1;
-    	}
-
-    	if ((*mix_d)[dev][RIGHT_CHN].nbits == 0) right = left; /* mono */
-
-    	/* Set the left channel */
-
-    	regoffs = (*mix_d)[dev][LEFT_CHN].regno;
-    	old = val = ad_read(mss, regoffs);
-    	/* if volume is 0, mute chan. Otherwise, unmute. */
-    	if (regoffs != 0) val = (left == 0)? old | 0x80 : old & 0x7f;
-    	change_bits(mix_d, &val, dev, LEFT_CHN, left);
-    	ad_write(mss, regoffs, val);
-
-    	DEB(printf("LEFT: dev %d reg %d old 0x%02x new 0x%02x\n",
-		dev, regoffs, old, val));
-
-    	if ((*mix_d)[dev][RIGHT_CHN].nbits != 0) { /* have stereo */
-		/* Set the right channel */
-		regoffs = (*mix_d)[dev][RIGHT_CHN].regno;
-		old = val = ad_read(mss, regoffs);
-		if (regoffs != 1) val = (right == 0)? old | 0x80 : old & 0x7f;
-		change_bits(mix_d, &val, dev, RIGHT_CHN, right);
-		ad_write(mss, regoffs, val);
-
-		DEB(printf("RIGHT: dev %d reg %d old 0x%02x new 0x%02x\n",
-	    	dev, regoffs, old, val));
-    	}
-    	return 0; /* success */
-}
-
-static int
-mss_speed(struct mss_chinfo *ch, int speed)
-{
-    	struct mss_info *mss = ch->parent;
-    	/*
-     	* In the CS4231, the low 4 bits of I8 are used to hold the
-     	* sample rate.  Only a fixed number of values is allowed. This
-     	* table lists them. The speed-setting routines scans the table
-     	* looking for the closest match. This is the only supported method.
-     	*
-     	* In the CS4236, there is an alternate metod (which we do not
-     	* support yet) which provides almost arbitrary frequency setting.
-     	* In the AD1845, it looks like the sample rate can be
-     	* almost arbitrary, and written directly to a register.
-     	* In the OPTi931, there is a SB command which provides for
-     	* almost arbitrary frequency setting.
-     	*
-     	*/
-    	ad_enter_MCE(mss);
-    	if (mss->bd_id == MD_AD1845) { /* Use alternate speed select regs */
-		ad_write(mss, 22, (speed >> 8) & 0xff);	/* Speed MSB */
-		ad_write(mss, 23, speed & 0xff);	/* Speed LSB */
-		/* XXX must also do something in I27 for the ad1845 */
-    	} else {
-        	int i, sel = 0; /* assume entry 0 does not contain -1 */
-        	static int speeds[] =
-      	    	{8000, 5512, 16000, 11025, 27429, 18900, 32000, 22050,
-	    	-1, 37800, -1, 44100, 48000, 33075, 9600, 6615};
-
-        	for (i = 1; i < 16; i++)
-   		    	if (speeds[i] > 0 &&
-			    abs(speed-speeds[i]) < abs(speed-speeds[sel])) sel = i;
-        	speed = speeds[sel];
-        	ad_write(mss, 8, (ad_read(mss, 8) & 0xf0) | sel);
-    	}
-    	ad_leave_MCE(mss);
-
-    	return speed;
-}
-
-/*
- * mss_format checks that the format is supported (or defaults to AFMT_U8)
- * and returns the bit setting for the 1848 register corresponding to
- * the desired format.
- *
- * fixed lr970724
- */
-
-static int
-mss_format(struct mss_chinfo *ch, u_int32_t format)
-{
-    	struct mss_info *mss = ch->parent;
-    	int i, arg = format & ~AFMT_STEREO;
-
-    	/*
-     	* The data format uses 3 bits (just 2 on the 1848). For each
-     	* bit setting, the following array returns the corresponding format.
-     	* The code scans the array looking for a suitable format. In
-     	* case it is not found, default to AFMT_U8 (not such a good
-     	* choice, but let's do it for compatibility...).
-     	*/
-
-    	static int fmts[] =
-        	{AFMT_U8, AFMT_MU_LAW, AFMT_S16_LE, AFMT_A_LAW,
-		-1, AFMT_IMA_ADPCM, AFMT_U16_BE, -1};
-
-	ch->fmt = format;
-    	for (i = 0; i < 8; i++) if (arg == fmts[i]) break;
-    	arg = i << 1;
-    	if (format & AFMT_STEREO) arg |= 1;
-    	arg <<= 4;
-    	ad_enter_MCE(mss);
-    	ad_write(mss, 8, (ad_read(mss, 8) & 0x0f) | arg);
-    	if (FULL_DUPLEX(mss)) ad_write(mss, 28, arg); /* capture mode */
-    	ad_leave_MCE(mss);
-    	return format;
-}
-
-static int
-mss_trigger(struct mss_chinfo *ch, int go)
-{
-    	struct mss_info *mss = ch->parent;
-    	u_char m;
-    	int retry, wr, cnt, ss;
-
-	ss = 1;
-	ss <<= (ch->fmt & AFMT_STEREO)? 1 : 0;
-	ss <<= (ch->fmt & AFMT_16BIT)? 1 : 0;
-
-	wr = (ch->dir == PCMDIR_PLAY)? 1 : 0;
-    	m = ad_read(mss, 9);
-    	switch (go) {
-    	case PCMTRIG_START:
-		cnt = (ch->buffer->dl / ss) - 1;
-
-		DEB(if (m & 4) printf("OUCH! reg 9 0x%02x\n", m););
-		m |= wr? I9_PEN : I9_CEN; /* enable DMA */
-		ad_write_cnt(mss, (wr || !FULL_DUPLEX(mss))? 14 : 30, cnt);
-		break;
-
-    	case PCMTRIG_STOP:
-    	case PCMTRIG_ABORT: /* XXX check this... */
-		m &= ~(wr? I9_PEN : I9_CEN); /* Stop DMA */
-#if 0
-		/*
-	 	* try to disable DMA by clearing count registers. Not sure it
-	 	* is needed, and it might cause false interrupts when the
-	 	* DMA is re-enabled later.
-	 	*/
-		ad_write_cnt(mss, (wr || !FULL_DUPLEX(mss))? 14 : 30, 0);
-#endif
-    	}
-    	/* on the OPTi931 the enable bit seems hard to set... */
-    	for (retry = 10; retry > 0; retry--) {
-        	ad_write(mss, 9, m);
-        	if (ad_read(mss, 9) == m) break;
-    	}
-    	if (retry == 0) BVDDB(printf("stop dma, failed to set bit 0x%02x 0x%02x\n", \
-			       m, ad_read(mss, 9)));
-    	return 0;
-}
-
 static struct isa_pnp_id pnpmss_ids[] = {
 	{0x0000630e, "CS423x"},				/* CSC0000 */
 	{0x0001630e, "CS423x-PCI"},			/* CSC0100 */
@@ -1582,64 +1819,6 @@ DRIVER_MODULE(snd_pnpmss, isa, pnpmss_driver, pcm_devclass, 0, 0);
 MODULE_DEPEND(snd_pnpmss, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
 MODULE_VERSION(snd_pnpmss, 1);
 
-
-/*
- * the opti931 seems to miss interrupts when working in full
- * duplex, so we try some heuristics to catch them.
- */
-static void
-opti931_intr(void *arg)
-{
-    	struct mss_info *mss = (struct mss_info *)arg;
-    	u_char masked = 0, i11, mc11, c = 0;
-    	u_char reason; /* b0 = playback, b1 = capture, b2 = timer */
-    	int loops = 10;
-
-#if 0
-    	reason = io_rd(mss, MSS_STATUS);
-    	if (!(reason & 1)) {/* no int, maybe a shared line ? */
-		DEB(printf("intr: flag 0, mcir11 0x%02x\n", ad_read(mss, 11)));
-		return;
-    	}
-#endif
-    	i11 = ad_read(mss, 11); /* XXX what's for ? */
-	again:
-
-    	c = mc11 = FULL_DUPLEX(mss)? opti_rd(mss, 11) : 0xc;
-    	mc11 &= 0x0c;
-    	if (c & 0x10) {
-		DEB(printf("Warning: CD interrupt\n");)
-		mc11 |= 0x10;
-    	}
-    	if (c & 0x20) {
-		DEB(printf("Warning: MPU interrupt\n");)
-		mc11 |= 0x20;
-    	}
-    	if (mc11 & masked) BVDDB(printf("irq reset failed, mc11 0x%02x, 0x%02x\n",\
-                              	  mc11, masked));
-    	masked |= mc11;
-    	/*
-     	* the nice OPTi931 sets the IRQ line before setting the bits in
-     	* mc11. So, on some occasions I have to retry (max 10 times).
-     	*/
-    	if (mc11 == 0) { /* perhaps can return ... */
-		reason = io_rd(mss, MSS_STATUS);
-		if (reason & 1) {
-	    		DEB(printf("one more try...\n");)
-	    		if (--loops) goto again;
-	    		else DDB(printf("intr, but mc11 not set\n");)
-		}
-		if (loops == 0) BVDDB(printf("intr, nothing in mcir11 0x%02x\n", mc11));
-		return;
-    	}
-
-    	if (mss->rch.buffer->dl && (mc11 & 8)) chn_intr(mss->rch.channel);
-    	if (mss->pch.buffer->dl && (mc11 & 4)) chn_intr(mss->pch.channel);
-    	opti_wr(mss, 11, ~mc11); /* ack */
-    	if (--loops) goto again;
-    	DEB(printf("xxx too many loops\n");)
-}
-
 static int
 guspcm_probe(device_t dev)
 {
@@ -1726,205 +1905,3 @@ MODULE_DEPEND(snd_guspcm, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
 MODULE_VERSION(snd_guspcm, 1);
 
 
-static int
-mssmix_init(snd_mixer *m)
-{
-	struct mss_info *mss = mix_getdevinfo(m);
-
-	mix_setdevs(m, MODE2_MIXER_DEVICES);
-	mix_setrecdevs(m, MSS_REC_DEVICES);
-	switch(mss->bd_id) {
-	case MD_OPTI931:
-		mix_setdevs(m, OPTI931_MIXER_DEVICES);
-		ad_write(mss, 20, 0x88);
-		ad_write(mss, 21, 0x88);
-		break;
-
-	case MD_AD1848:
-		mix_setdevs(m, MODE1_MIXER_DEVICES);
-		break;
-
-	case MD_GUSPNP:
-	case MD_GUSMAX:
-		/* this is only necessary in mode 3 ... */
-		ad_write(mss, 22, 0x88);
-		ad_write(mss, 23, 0x88);
-		break;
-	}
-	return 0;
-}
-
-static int
-mssmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right)
-{
-	struct mss_info *mss = mix_getdevinfo(m);
-
-	mss_mixer_set(mss, dev, left, right);
-
-	return left | (right << 8);
-}
-
-static int
-mssmix_setrecsrc(snd_mixer *m, u_int32_t src)
-{
-	struct mss_info *mss = mix_getdevinfo(m);
-
-	src = mss_set_recsrc(mss, src);
-	return src;
-}
-
-static int
-ymmix_init(snd_mixer *m)
-{
-	struct mss_info *mss = mix_getdevinfo(m);
-
-	mssmix_init(m);
-	mix_setdevs(m, mix_getdevs(m) | SOUND_MASK_VOLUME | SOUND_MASK_MIC
-				      | SOUND_MASK_BASS | SOUND_MASK_TREBLE);
-	/* Set master volume */
-	conf_wr(mss, OPL3SAx_VOLUMEL, 7);
-	conf_wr(mss, OPL3SAx_VOLUMER, 7);
-
-	return 0;
-}
-
-static int
-ymmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right)
-{
-	struct mss_info *mss = mix_getdevinfo(m);
-	int t, l, r;
-
-	switch (dev) {
-	case SOUND_MIXER_VOLUME:
-		if (left) t = 15 - (left * 15) / 100;
-		else t = 0x80; /* mute */
-		conf_wr(mss, OPL3SAx_VOLUMEL, t);
-		if (right) t = 15 - (right * 15) / 100;
-		else t = 0x80; /* mute */
-		conf_wr(mss, OPL3SAx_VOLUMER, t);
-		break;
-
-	case SOUND_MIXER_MIC:
-		t = left;
-		if (left) t = 31 - (left * 31) / 100;
-		else t = 0x80; /* mute */
-		conf_wr(mss, OPL3SAx_MIC, t);
-		break;
-
-	case SOUND_MIXER_BASS:
-		l = (left * 7) / 100;
-		r = (right * 7) / 100;
-		t = (r << 4) | l;
-		conf_wr(mss, OPL3SAx_BASS, t);
-		break;
-
-	case SOUND_MIXER_TREBLE:
-		l = (left * 7) / 100;
-		r = (right * 7) / 100;
-		t = (r << 4) | l;
-		conf_wr(mss, OPL3SAx_TREBLE, t);
-		break;
-
-	default:
-		mss_mixer_set(mss, dev, left, right);
-	}
-
-	return left | (right << 8);
-}
-
-static int
-ymmix_setrecsrc(snd_mixer *m, u_int32_t src)
-{
-	struct mss_info *mss = mix_getdevinfo(m);
-	src = mss_set_recsrc(mss, src);
-	return src;
-}
-
-/* channel interface */
-static void *
-msschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
-{
-	struct mss_info *mss = devinfo;
-	struct mss_chinfo *ch = (dir == PCMDIR_PLAY)? &mss->pch : &mss->rch;
-
-	ch->parent = mss;
-	ch->channel = c;
-	ch->buffer = b;
-	ch->buffer->bufsize = MSS_BUFFSIZE;
-	if (chn_allocbuf(ch->buffer, mss->parent_dmat) == -1) return NULL;
-	return ch;
-}
-
-static int
-msschan_setdir(void *data, int dir)
-{
-	struct mss_chinfo *ch = data;
-
-	ch->buffer->chan = (dir == PCMDIR_PLAY)? ch->parent->pdma : ch->parent->rdma;
-	ch->dir = dir;
-	return 0;
-}
-
-static int
-msschan_setformat(void *data, u_int32_t format)
-{
-	struct mss_chinfo *ch = data;
-
-	mss_format(ch, format);
-	return 0;
-}
-
-static int
-msschan_setspeed(void *data, u_int32_t speed)
-{
-	struct mss_chinfo *ch = data;
-
-	return mss_speed(ch, speed);
-}
-
-static int
-msschan_setblocksize(void *data, u_int32_t blocksize)
-{
-	return blocksize;
-}
-
-static int
-msschan_trigger(void *data, int go)
-{
-	struct mss_chinfo *ch = data;
-
-	if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
-		return 0;
-
-	buf_isadma(ch->buffer, go);
-	mss_trigger(ch, go);
-	return 0;
-}
-
-static int
-msschan_getptr(void *data)
-{
-	struct mss_chinfo *ch = data;
-	return buf_isadmaptr(ch->buffer);
-}
-
-static pcmchan_caps *
-msschan_getcaps(void *data)
-{
-	struct mss_chinfo *ch = data;
-
-	switch(ch->parent->bd_id) {
-	case MD_OPTI931:
-		return &opti931_caps;
-		break;
-
-	case MD_GUSPNP:
-	case MD_GUSMAX:
-		return &guspnp_caps;
-		break;
-
-	default:
-		return &mss_caps;
-		break;
-	}
-}
diff --git a/sys/dev/sound/isa/sb.h b/sys/dev/sound/isa/sb.h
index 98a0227..8b2a2f6 100644
--- a/sys/dev/sound/isa/sb.h
+++ b/sys/dev/sound/isa/sb.h
@@ -141,13 +141,6 @@
 #define	BD_F_MIDIBUSY	0x0400	/* midi busy */
 #endif
 #define	BD_F_ESS	0x0800	/* this is an ESS chip */
-/*
- * on some SB16 cards, at times I swap DMA channels. Remember this
- * so that they can be restored later.
- */
-#if 0
-#define	BD_F_SWAPPED	0x1000	/* have swapped DMA channels */
-#endif
 #define BD_F_DMARUN	0x2000
 #define BD_F_DMARUN2	0x4000
 
@@ -190,87 +183,5 @@
 #define SB16_IMASK_R	0x3e
 #define SB16_OMASK	0x3c
 
-/*
- * sound/sb_mixer.h
- *
- * Definitions for the SB Pro and SB16 mixers
- *
- * Copyright by Hannu Savolainen 1993
- *
- * 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
- * notice, this list of conditions and the following disclaimer. 2.
- * Redistributions in binary form must reproduce the above copyright notice,
- * this list of conditions and the following disclaimer in the documentation
- * and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 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.
- *
- * Modified: Hunyue Yau	Jan 6 1994 Added defines for the Sound Galaxy NX Pro
- * mixer.
- *
- */
 
-#define SBPRO_RECORDING_DEVICES	\
-    (SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD)
-
-#define SBPRO_MIXER_DEVICES	\
-    (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_LINE | SOUND_MASK_MIC | \
-     SOUND_MASK_CD | SOUND_MASK_VOLUME)
-
-#define SB16_RECORDING_DEVICES	\
-    (SOUND_MASK_SYNTH | SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD)
-
-#define SB16_MIXER_DEVICES	\
-    (SOUND_MASK_SYNTH | SOUND_MASK_PCM | SOUND_MASK_SPEAKER | \
-     SOUND_MASK_LINE | SOUND_MASK_MIC | SOUND_MASK_CD | \
-     SOUND_MASK_IGAIN | SOUND_MASK_OGAIN | \
-     SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE)
-
-#ifdef __SB_MIXER_C__
-mixer_tab       sbpro_mix = {
-    PMIX_ENT(SOUND_MIXER_VOLUME,  0x22, 4, 4, 0x22, 0, 4),
-    PMIX_ENT(SOUND_MIXER_SYNTH,   0x26, 4, 4, 0x26, 0, 4),
-    PMIX_ENT(SOUND_MIXER_PCM,     0x04, 4, 4, 0x04, 0, 4),
-    PMIX_ENT(SOUND_MIXER_LINE,    0x2e, 4, 4, 0x2e, 0, 4),
-    PMIX_ENT(SOUND_MIXER_MIC,     0x0a, 0, 3, 0x00, 0, 0),
-    PMIX_ENT(SOUND_MIXER_CD,      0x28, 4, 4, 0x28, 0, 4),
-};
-
-mixer_tab       ess_mix = {
-    PMIX_ENT(SOUND_MIXER_VOLUME,  0x32, 4, 4, 0x32, 0, 4),
-    PMIX_ENT(SOUND_MIXER_SYNTH,   0x36, 4, 4, 0x26, 0, 4),
-    PMIX_ENT(SOUND_MIXER_PCM,     0x14, 4, 4, 0x04, 0, 4),
-    PMIX_ENT(SOUND_MIXER_SPEAKER, 0x3c, 0, 3, 0x00, 0, 0),
-    PMIX_ENT(SOUND_MIXER_LINE,    0x3e, 4, 4, 0x2e, 0, 4),
-    PMIX_ENT(SOUND_MIXER_MIC,     0x1a, 4, 4, 0x1a, 0, 4),
-    PMIX_ENT(SOUND_MIXER_CD,      0x38, 4, 4, 0x28, 0, 4),
-};
-
-mixer_tab       sb16_mix = {
-    PMIX_ENT(SOUND_MIXER_VOLUME,  0x30, 3, 5, 0x31, 3, 5),
-    PMIX_ENT(SOUND_MIXER_BASS,    0x46, 4, 4, 0x47, 4, 4),
-    PMIX_ENT(SOUND_MIXER_TREBLE,  0x44, 4, 4, 0x45, 4, 4),
-    PMIX_ENT(SOUND_MIXER_SYNTH,   0x34, 3, 5, 0x35, 3, 5),
-    PMIX_ENT(SOUND_MIXER_PCM,     0x32, 3, 5, 0x33, 3, 5),
-    PMIX_ENT(SOUND_MIXER_SPEAKER, 0x3b, 6, 2, 0x00, 0, 0),
-    PMIX_ENT(SOUND_MIXER_LINE,    0x38, 3, 5, 0x39, 3, 5),
-    PMIX_ENT(SOUND_MIXER_MIC,     0x3a, 3, 5, 0x00, 0, 0),
-    PMIX_ENT(SOUND_MIXER_CD,      0x36, 3, 5, 0x37, 3, 5),
-    PMIX_ENT(SOUND_MIXER_IGAIN,   0x3f, 6, 2, 0x40, 6, 2),
-    PMIX_ENT(SOUND_MIXER_OGAIN,   0x41, 6, 2, 0x42, 6, 2)
-};
-
-#endif /* __SB_MIXER_C__ */
 
diff --git a/sys/dev/sound/isa/sb16.c b/sys/dev/sound/isa/sb16.c
index 9869226..e1485fa 100644
--- a/sys/dev/sound/isa/sb16.c
+++ b/sys/dev/sound/isa/sb16.c
@@ -36,20 +36,11 @@
 #include  <dev/sound/isa/sb.h>
 #include  <dev/sound/chip.h>
 
+#include "mixer_if.h"
+
 #define SB16_BUFFSIZE	4096
 #define PLAIN_SB16(x) ((((x)->bd_flags) & (BD_F_SB16|BD_F_SB16X)) == BD_F_SB16)
 
-/* channel interface */
-static void *sb16chan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int sb16chan_setformat(void *data, u_int32_t format);
-static int sb16chan_setspeed(void *data, u_int32_t speed);
-static int sb16chan_setblocksize(void *data, u_int32_t blocksize);
-static int sb16chan_trigger(void *data, int go);
-static int sb16chan_getptr(void *data);
-static pcmchan_caps *sb16chan_getcaps(void *data);
-static int sb16chan_reset(void *data);
-static int sb16chan_resetdone(void *data);
-
 static u_int32_t sb16_fmt8[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -73,25 +64,6 @@ static u_int32_t sb16x_fmt[] = {
 };
 static pcmchan_caps sb16x_caps = {5000, 49000, sb16x_fmt, 0};
 
-static pcm_channel sb_chantemplate = {
-	sb16chan_init,
-	NULL,
-	sb16chan_setformat,
-	sb16chan_setspeed,
-	sb16chan_setblocksize,
-	sb16chan_trigger,
-	sb16chan_getptr,
-	sb16chan_getcaps,
-	NULL, 			/* free */
-	sb16chan_reset,		/* reset */
-	sb16chan_resetdone,	/* resetdone */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 struct sb_info;
 
 struct sb_chinfo {
@@ -118,7 +90,6 @@ struct sb_info {
 
 static int sb_rd(struct sb_info *sb, int reg);
 static void sb_wr(struct sb_info *sb, int reg, u_int8_t val);
-static int sb_dspready(struct sb_info *sb);
 static int sb_cmd(struct sb_info *sb, u_char val);
 /* static int sb_cmd1(struct sb_info *sb, u_char cmd, int val); */
 static int sb_cmd2(struct sb_info *sb, u_char cmd, int val);
@@ -129,19 +100,6 @@ static int sb_reset_dsp(struct sb_info *sb);
 
 static void sb_intr(void *arg);
 
-static int sb16mix_init(snd_mixer *m);
-static int sb16mix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int sb16mix_setrecsrc(snd_mixer *m, u_int32_t src);
-
-static snd_mixer sb16_mixer = {
-    	"SoundBlaster 16 mixer",
-    	sb16mix_init,
-	NULL,
-	NULL,
-    	sb16mix_set,
-    	sb16mix_setrecsrc,
-};
-
 static devclass_t pcm_devclass;
 
 /*
@@ -178,22 +136,17 @@ sb_wr(struct sb_info *sb, int reg, u_int8_t val)
 }
 
 static int
-sb_dspready(struct sb_info *sb)
-{
-	return ((sb_rd(sb, SBDSP_STATUS) & 0x80) == 0);
-}
-
-static int
 sb_dspwr(struct sb_info *sb, u_char val)
 {
     	int  i;
 
     	for (i = 0; i < 1000; i++) {
-		if (sb_dspready(sb)) {
-	    		sb_wr(sb, SBDSP_CMD, val);
-	    		return 1;
+		if ((sb_rd(sb, SBDSP_STATUS) & 0x80))
+	    		DELAY((i > 100)? 1000 : 10);
+	    	else {
+			sb_wr(sb, SBDSP_CMD, val);
+			return 1;
 		}
-		if (i > 10) DELAY((i > 100)? 1000 : 10);
     	}
     	printf("sb_dspwr(0x%02x) timed out.\n", val);
     	return 0;
@@ -398,6 +351,14 @@ sb16mix_setrecsrc(snd_mixer *m, u_int32_t src)
 	return src;
 }
 
+static kobj_method_t sb16mix_mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		sb16mix_init),
+    	KOBJMETHOD(mixer_set,		sb16mix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	sb16mix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(sb16mix_mixer);
+
 /************************************************************/
 
 static void
@@ -626,7 +587,7 @@ sb_setup(struct sb_info *sb)
 
 /* channel interface */
 static void *
-sb16chan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+sb16chan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sb_info *sb = devinfo;
 	struct sb_chinfo *ch = (dir == PCMDIR_PLAY)? &sb->pch : &sb->rch;
@@ -644,7 +605,7 @@ sb16chan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-sb16chan_setformat(void *data, u_int32_t format)
+sb16chan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sb_chinfo *ch = data;
 	struct sb_info *sb = ch->parent;
@@ -657,7 +618,7 @@ sb16chan_setformat(void *data, u_int32_t format)
 }
 
 static int
-sb16chan_setspeed(void *data, u_int32_t speed)
+sb16chan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sb_chinfo *ch = data;
 
@@ -666,7 +627,7 @@ sb16chan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-sb16chan_setblocksize(void *data, u_int32_t blocksize)
+sb16chan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	struct sb_chinfo *ch = data;
 
@@ -675,7 +636,7 @@ sb16chan_setblocksize(void *data, u_int32_t blocksize)
 }
 
 static int
-sb16chan_trigger(void *data, int go)
+sb16chan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sb_chinfo *ch = data;
 	struct sb_info *sb = ch->parent;
@@ -694,7 +655,7 @@ sb16chan_trigger(void *data, int go)
 }
 
 static int
-sb16chan_getptr(void *data)
+sb16chan_getptr(kobj_t obj, void *data)
 {
 	struct sb_chinfo *ch = data;
 
@@ -702,7 +663,7 @@ sb16chan_getptr(void *data)
 }
 
 static pcmchan_caps *
-sb16chan_getcaps(void *data)
+sb16chan_getcaps(kobj_t obj, void *data)
 {
 	struct sb_chinfo *ch = data;
 	struct sb_info *sb = ch->parent;
@@ -714,17 +675,7 @@ sb16chan_getcaps(void *data)
 }
 
 static int
-sb16chan_reset(void *data)
-{
-/*
-	struct sb_chinfo *ch = data;
-	struct sb_info *sb = ch->parent;
-*/
-	return 0;
-}
-
-static int
-sb16chan_resetdone(void *data)
+sb16chan_resetdone(kobj_t obj, void *data)
 {
 	struct sb_chinfo *ch = data;
 	struct sb_info *sb = ch->parent;
@@ -734,6 +685,19 @@ sb16chan_resetdone(void *data)
 	return 0;
 }
 
+static kobj_method_t sb16chan_methods[] = {
+    	KOBJMETHOD(channel_init,		sb16chan_init),
+    	KOBJMETHOD(channel_resetdone,		sb16chan_resetdone),
+    	KOBJMETHOD(channel_setformat,		sb16chan_setformat),
+    	KOBJMETHOD(channel_setspeed,		sb16chan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	sb16chan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		sb16chan_trigger),
+    	KOBJMETHOD(channel_getptr,		sb16chan_getptr),
+    	KOBJMETHOD(channel_getcaps,		sb16chan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(sb16chan);
+
 /************************************************************/
 
 static int
@@ -780,7 +744,7 @@ sb16_attach(device_t dev)
 		goto no;
     	if (sb_reset_dsp(sb))
 		goto no;
-	if (mixer_init(dev, &sb16_mixer, sb))
+	if (mixer_init(dev, &sb16mix_mixer_class, sb))
 		goto no;
 	if (bus_setup_intr(dev, sb->irq, INTR_TYPE_TTY, sb_intr, sb, &sb->ih))
 		goto no;
@@ -812,8 +776,8 @@ sb16_attach(device_t dev)
 
     	if (pcm_register(dev, sb, 1, 1))
 		goto no;
-	pcm_addchan(dev, PCMDIR_REC, &sb_chantemplate, sb);
-	pcm_addchan(dev, PCMDIR_PLAY, &sb_chantemplate, sb);
+	pcm_addchan(dev, PCMDIR_REC, &sb16chan_class, sb);
+	pcm_addchan(dev, PCMDIR_PLAY, &sb16chan_class, sb);
 
     	pcm_setstatus(dev, status);
 
diff --git a/sys/dev/sound/isa/sb8.c b/sys/dev/sound/isa/sb8.c
index 091c6e2..b2e66b3 100644
--- a/sys/dev/sound/isa/sb8.c
+++ b/sys/dev/sound/isa/sb8.c
@@ -36,16 +36,9 @@
 #include  <dev/sound/isa/sb.h>
 #include  <dev/sound/chip.h>
 
-#define SB_BUFFSIZE	4096
+#include "mixer_if.h"
 
-/* channel interface */
-static void *sbchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int sbchan_setformat(void *data, u_int32_t format);
-static int sbchan_setspeed(void *data, u_int32_t speed);
-static int sbchan_setblocksize(void *data, u_int32_t blocksize);
-static int sbchan_trigger(void *data, int go);
-static int sbchan_getptr(void *data);
-static pcmchan_caps *sbchan_getcaps(void *data);
+#define SB_BUFFSIZE	4096
 
 static u_int32_t sb_fmt[] = {
 	AFMT_U8,
@@ -64,25 +57,6 @@ static u_int32_t sbpro_fmt[] = {
 static pcmchan_caps sbpro_playcaps = {4000, 44100, sbpro_fmt, 0};
 static pcmchan_caps sbpro_reccaps = {4000, 44100, sbpro_fmt, 0};
 
-static pcm_channel sb_chantemplate = {
-	sbchan_init,
-	NULL,
-	sbchan_setformat,
-	sbchan_setspeed,
-	sbchan_setblocksize,
-	sbchan_trigger,
-	sbchan_getptr,
-	sbchan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 struct sb_info;
 
 struct sb_chinfo {
@@ -121,32 +95,6 @@ static int sb_speed(struct sb_chinfo *ch);
 static int sb_start(struct sb_chinfo *ch);
 static int sb_stop(struct sb_chinfo *ch);
 
-static int sbmix_init(snd_mixer *m);
-static int sbmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int sbmix_setrecsrc(snd_mixer *m, u_int32_t src);
-
-static int sbpromix_init(snd_mixer *m);
-static int sbpromix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int sbpromix_setrecsrc(snd_mixer *m, u_int32_t src);
-
-static snd_mixer sb_mixer = {
-    	"SoundBlaster 2.0 mixer",
-    	sbmix_init,
-	NULL,
-	NULL,
-    	sbmix_set,
-    	sbmix_setrecsrc,
-};
-
-static snd_mixer sbpro_mixer = {
-    	"SoundBlaster Pro mixer",
-    	sbpromix_init,
-	NULL,
-	NULL,
-    	sbpromix_set,
-    	sbpromix_setrecsrc,
-};
-
 static devclass_t pcm_devclass;
 
 /*
@@ -432,6 +380,14 @@ sbpromix_setrecsrc(snd_mixer *m, u_int32_t src)
 	return src;
 }
 
+static kobj_method_t sbpromix_mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		sbpromix_init),
+    	KOBJMETHOD(mixer_set,		sbpromix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	sbpromix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(sbpromix_mixer);
+
 /************************************************************/
 
 static int
@@ -492,6 +448,14 @@ sbmix_setrecsrc(snd_mixer *m, u_int32_t src)
 	return 0;
 }
 
+static kobj_method_t sbmix_mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		sbmix_init),
+    	KOBJMETHOD(mixer_set,		sbmix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	sbmix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(sbmix_mixer);
+
 /************************************************************/
 
 static void
@@ -593,7 +557,7 @@ sb_stop(struct sb_chinfo *ch)
 
 /* channel interface */
 static void *
-sbchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+sbchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sb_info *sb = devinfo;
 	struct sb_chinfo *ch = (dir == PCMDIR_PLAY)? &sb->pch : &sb->rch;
@@ -610,7 +574,7 @@ sbchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-sbchan_setformat(void *data, u_int32_t format)
+sbchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sb_chinfo *ch = data;
 
@@ -619,7 +583,7 @@ sbchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-sbchan_setspeed(void *data, u_int32_t speed)
+sbchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sb_chinfo *ch = data;
 
@@ -628,13 +592,13 @@ sbchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-sbchan_setblocksize(void *data, u_int32_t blocksize)
+sbchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-sbchan_trigger(void *data, int go)
+sbchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sb_chinfo *ch = data;
 
@@ -650,7 +614,7 @@ sbchan_trigger(void *data, int go)
 }
 
 static int
-sbchan_getptr(void *data)
+sbchan_getptr(kobj_t obj, void *data)
 {
 	struct sb_chinfo *ch = data;
 
@@ -658,7 +622,7 @@ sbchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-sbchan_getcaps(void *data)
+sbchan_getcaps(kobj_t obj, void *data)
 {
 	struct sb_chinfo *ch = data;
 	int p = (ch->dir == PCMDIR_PLAY)? 1 : 0;
@@ -670,6 +634,18 @@ sbchan_getcaps(void *data)
 	return p? &sbpro_playcaps : &sbpro_reccaps;
 }
 
+static kobj_method_t sbchan_methods[] = {
+    	KOBJMETHOD(channel_init,		sbchan_init),
+    	KOBJMETHOD(channel_setformat,		sbchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		sbchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	sbchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		sbchan_trigger),
+    	KOBJMETHOD(channel_getptr,		sbchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		sbchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(sbchan);
+
 /************************************************************/
 
 static int
@@ -717,7 +693,7 @@ sb_attach(device_t dev)
 		goto no;
     	if (sb_reset_dsp(sb))
 		goto no;
-    	if (mixer_init(dev, (sb->bd_id < 0x300)? &sb_mixer : &sbpro_mixer, sb))
+    	if (mixer_init(dev, (sb->bd_id < 0x300)? &sbmix_mixer_class : &sbpromix_mixer_class, sb))
 		goto no;
 	if (bus_setup_intr(dev, sb->irq, INTR_TYPE_TTY, sb_intr, sb, &sb->ih))
 		goto no;
@@ -740,8 +716,8 @@ sb_attach(device_t dev)
 
     	if (pcm_register(dev, sb, 1, 1))
 		goto no;
-	pcm_addchan(dev, PCMDIR_REC, &sb_chantemplate, sb);
-	pcm_addchan(dev, PCMDIR_PLAY, &sb_chantemplate, sb);
+	pcm_addchan(dev, PCMDIR_REC, &sbchan_class, sb);
+	pcm_addchan(dev, PCMDIR_PLAY, &sbchan_class, sb);
 
     	pcm_setstatus(dev, status);
 
diff --git a/sys/dev/sound/pci/aureal.c b/sys/dev/sound/pci/aureal.c
index 9a9dd0a..e957b07 100644
--- a/sys/dev/sound/pci/aureal.c
+++ b/sys/dev/sound/pci/aureal.c
@@ -37,15 +37,6 @@
 #define AU8820_PCI_ID 0x000112eb
 
 /* channel interface */
-static void *auchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int auchan_setdir(void *data, int dir);
-static int auchan_setformat(void *data, u_int32_t format);
-static int auchan_setspeed(void *data, u_int32_t speed);
-static int auchan_setblocksize(void *data, u_int32_t blocksize);
-static int auchan_trigger(void *data, int go);
-static int auchan_getptr(void *data);
-static pcmchan_caps *auchan_getcaps(void *data);
-
 static u_int32_t au_playfmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -64,30 +55,8 @@ static u_int32_t au_recfmt[] = {
 };
 static pcmchan_caps au_reccaps = {4000, 48000, au_recfmt, 0};
 
-static pcm_channel au_chantemplate = {
-	auchan_init,
-	auchan_setdir,
-	auchan_setformat,
-	auchan_setspeed,
-	auchan_setblocksize,
-	auchan_trigger,
-	auchan_getptr,
-	auchan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 /* -------------------------------------------------------------------- */
 
-static u_int32_t au_rdcd(void *arg, int regno);
-static void au_wrcd(void *arg, int regno, u_int32_t data);
-
 struct au_info;
 
 struct au_chinfo {
@@ -147,8 +116,10 @@ au_wr(struct au_info *au, int mapno, int regno, u_int32_t data, int size)
 	}
 }
 
-static u_int32_t
-au_rdcd(void *arg, int regno)
+/* -------------------------------------------------------------------- */
+
+static int
+au_rdcd(kobj_t obj, void *arg, int regno)
 {
 	struct au_info *au = (struct au_info *)arg;
 	int i=0, j=0;
@@ -166,8 +137,8 @@ au_rdcd(void *arg, int regno)
 	return i & AU_CDC_DATAMASK;
 }
 
-static void
-au_wrcd(void *arg, int regno, u_int32_t data)
+static int
+au_wrcd(kobj_t obj, void *arg, int regno, u_int32_t data)
 {
 	struct au_info *au = (struct au_info *)arg;
 	int i, j, tries;
@@ -188,8 +159,19 @@ au_wrcd(void *arg, int regno, u_int32_t data)
 	/*
 	if (tries == 3) printf("giving up writing 0x%4x to codec reg %2x\n", data, regno);
 	*/
+
+	return 0;
 }
 
+static kobj_method_t au_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		au_rdcd),
+    	KOBJMETHOD(ac97_write,		au_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(au_ac97);
+
+/* -------------------------------------------------------------------- */
+
 static void
 au_setbit(u_int32_t *p, char bit, u_int32_t value)
 {
@@ -308,9 +290,10 @@ au_prepareoutput(struct au_chinfo *ch, u_int32_t format)
 	au_addroute(au, 0x11, stereo? 0 : 1, 0x59);
 }
 
+/* -------------------------------------------------------------------- */
 /* channel interface */
 static void *
-auchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+auchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct au_info *au = devinfo;
 	struct au_chinfo *ch = (dir == PCMDIR_PLAY)? &au->pch : NULL;
@@ -319,23 +302,13 @@ auchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 	ch->channel = c;
 	ch->buffer = b;
 	ch->buffer->bufsize = AU_BUFFSIZE;
+	ch->dir = dir;
 	if (chn_allocbuf(ch->buffer, au->parent_dmat) == -1) return NULL;
 	return ch;
 }
 
 static int
-auchan_setdir(void *data, int dir)
-{
-	struct au_chinfo *ch = data;
-	if (dir == PCMDIR_PLAY) {
-	} else {
-	}
-	ch->dir = dir;
-	return 0;
-}
-
-static int
-auchan_setformat(void *data, u_int32_t format)
+auchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct au_chinfo *ch = data;
 
@@ -344,7 +317,7 @@ auchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-auchan_setspeed(void *data, u_int32_t speed)
+auchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct au_chinfo *ch = data;
 	if (ch->dir == PCMDIR_PLAY) {
@@ -354,13 +327,13 @@ auchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-auchan_setblocksize(void *data, u_int32_t blocksize)
+auchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-auchan_trigger(void *data, int go)
+auchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct au_chinfo *ch = data;
 	struct au_info *au = ch->parent;
@@ -382,7 +355,7 @@ auchan_trigger(void *data, int go)
 }
 
 static int
-auchan_getptr(void *data)
+auchan_getptr(kobj_t obj, void *data)
 {
 	struct au_chinfo *ch = data;
 	struct au_info *au = ch->parent;
@@ -394,12 +367,25 @@ auchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-auchan_getcaps(void *data)
+auchan_getcaps(kobj_t obj, void *data)
 {
 	struct au_chinfo *ch = data;
 	return (ch->dir == PCMDIR_PLAY)? &au_playcaps : &au_reccaps;
 }
 
+static kobj_method_t auchan_methods[] = {
+    	KOBJMETHOD(channel_init,		auchan_init),
+    	KOBJMETHOD(channel_setformat,		auchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		auchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	auchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		auchan_trigger),
+    	KOBJMETHOD(channel_getptr,		auchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		auchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(auchan);
+
+/* -------------------------------------------------------------------- */
 /* The interrupt handler */
 static void
 au_intr (void *p)
@@ -571,7 +557,6 @@ au_pci_attach(device_t dev)
 	struct ac97_info *codec;
 	char 		status[SND_STATUSLEN];
 
-	d = device_get_softc(dev);
 	if ((au = malloc(sizeof(*au), M_DEVBUF, M_NOWAIT)) == NULL) {
 		device_printf(dev, "cannot allocate softc\n");
 		return ENXIO;
@@ -649,9 +634,9 @@ au_pci_attach(device_t dev)
 		goto bad;
 	}
 
-	codec = ac97_create(dev, au, NULL, au_rdcd, au_wrcd);
+	codec = AC97_CREATE(dev, au, au_ac97);
 	if (codec == NULL) goto bad;
-	if (mixer_init(dev, &ac97_mixer, codec) == -1) goto bad;
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad;
 
 	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
 		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
@@ -669,7 +654,7 @@ au_pci_attach(device_t dev)
 
 	if (pcm_register(dev, au, 1, 1)) goto bad;
 	/* pcm_addchan(dev, PCMDIR_REC, &au_chantemplate, au); */
-	pcm_addchan(dev, PCMDIR_PLAY, &au_chantemplate, au);
+	pcm_addchan(dev, PCMDIR_PLAY, &auchan_class, au);
 	pcm_setstatus(dev, status);
 
 	return 0;
diff --git a/sys/dev/sound/pci/csapcm.c b/sys/dev/sound/pci/csapcm.c
index 1a5f807..c3ae93e 100644
--- a/sys/dev/sound/pci/csapcm.c
+++ b/sys/dev/sound/pci/csapcm.c
@@ -82,20 +82,6 @@ static int	csa_startdsp(csa_res *resp);
 static int	csa_allocres(struct csa_info *scp, device_t dev);
 static void	csa_releaseres(struct csa_info *scp, device_t dev);
 
-/* talk to the codec - called from ac97.c */
-static u_int32_t csa_rdcd(void *, int);
-static void  	 csa_wrcd(void *, int, u_int32_t);
-
-/* channel interface */
-static void *csachan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int csachan_setdir(void *data, int dir);
-static int csachan_setformat(void *data, u_int32_t format);
-static int csachan_setspeed(void *data, u_int32_t speed);
-static int csachan_setblocksize(void *data, u_int32_t blocksize);
-static int csachan_trigger(void *data, int go);
-static int csachan_getptr(void *data);
-static pcmchan_caps *csachan_getcaps(void *data);
-
 static u_int32_t csa_playfmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -116,116 +102,37 @@ static u_int32_t csa_recfmt[] = {
 };
 static pcmchan_caps csa_reccaps = {11025, 48000, csa_recfmt, 0};
 
-static pcm_channel csa_chantemplate = {
-	csachan_init,
-	csachan_setdir,
-	csachan_setformat,
-	csachan_setspeed,
-	csachan_setblocksize,
-	csachan_trigger,
-	csachan_getptr,
-	csachan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 /* -------------------------------------------------------------------- */
-
-/* channel interface */
-static void *
-csachan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
-{
-	struct csa_info *csa = devinfo;
-	struct csa_chinfo *ch = (dir == PCMDIR_PLAY)? &csa->pch : &csa->rch;
-
-	ch->parent = csa;
-	ch->channel = c;
-	ch->buffer = b;
-	ch->buffer->bufsize = CS461x_BUFFSIZE;
-	if (chn_allocbuf(ch->buffer, csa->parent_dmat) == -1) return NULL;
-	return ch;
-}
+/* ac97 codec */
 
 static int
-csachan_setdir(void *data, int dir)
+csa_rdcd(kobj_t obj, void *devinfo, int regno)
 {
-	struct csa_chinfo *ch = data;
-	struct csa_info *csa = ch->parent;
-	csa_res *resp;
+	u_int32_t data;
+	struct csa_info *csa = (struct csa_info *)devinfo;
 
-	resp = &csa->res;
+	if (csa_readcodec(&csa->res, regno + BA0_AC97_RESET, &data))
+		data = 0;
 
-	if (dir == PCMDIR_PLAY)
-		csa_writemem(resp, BA1_PBA, vtophys(ch->buffer->buf));
-	else
-		csa_writemem(resp, BA1_CBA, vtophys(ch->buffer->buf));
-	ch->dir = dir;
-	return 0;
+	return data;
 }
 
 static int
-csachan_setformat(void *data, u_int32_t format)
+csa_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 {
-	struct csa_chinfo *ch = data;
-	struct csa_info *csa = ch->parent;
-	u_long pdtc;
-	csa_res *resp;
+	struct csa_info *csa = (struct csa_info *)devinfo;
 
-	resp = &csa->res;
+	csa_writecodec(&csa->res, regno + BA0_AC97_RESET, data);
 
-	if (ch->dir == PCMDIR_REC)
-		csa_writemem(resp, BA1_CIE, (csa_readmem(resp, BA1_CIE) & ~0x0000003f) | 0x00000001);
-	else {
-		csa->pfie = csa_readmem(resp, BA1_PFIE) & ~0x0000f03f;
-		if (format & AFMT_U8 || format & AFMT_U16_LE || format & AFMT_U16_BE)
-			csa->pfie |= 0x8000;
-		if (format & AFMT_S16_BE || format & AFMT_U16_BE)
-			csa->pfie |= 0x4000;
-		if (!(format & AFMT_STEREO))
-			csa->pfie |= 0x2000;
-		if (format & AFMT_U8 || format & AFMT_S8)
-			csa->pfie |= 0x1000;
-		csa_writemem(resp, BA1_PFIE, csa->pfie);
-		pdtc = csa_readmem(resp, BA1_PDTC) & ~0x000003ff;
-		if ((format & AFMT_S16_BE || format & AFMT_U16_BE || format & AFMT_S16_LE || format & AFMT_U16_LE) && (format & AFMT_STEREO))
-			pdtc |= 0x00f;
-		else if ((format & AFMT_S16_BE || format & AFMT_U16_BE || format & AFMT_S16_LE || format & AFMT_U16_LE) || (format & AFMT_STEREO))
-			pdtc |= 0x007;
-		else
-			pdtc |= 0x003;
-		csa_writemem(resp, BA1_PDTC, pdtc);
-	}
-	ch->fmt = format;
 	return 0;
 }
 
-static int
-csachan_setspeed(void *data, u_int32_t speed)
-{
-	struct csa_chinfo *ch = data;
-	struct csa_info *csa = ch->parent;
-	csa_res *resp;
-
-	resp = &csa->res;
-
-	if (ch->dir == PCMDIR_PLAY)
-		csa_setplaysamplerate(resp, speed);
-	else if (ch->dir == PCMDIR_REC)
-		csa_setcapturesamplerate(resp, speed);
-
-	/* rec/play speeds locked together - should indicate in flags */
-#if 0
-	if (ch->direction == PCMDIR_PLAY) d->rec[0].speed = speed;
-	else d->play[0].speed = speed;
-#endif
-	return speed; /* XXX calc real speed */
-}
+static kobj_method_t csa_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		csa_rdcd),
+    	KOBJMETHOD(ac97_write,		csa_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(csa_ac97);
 
 static void
 csa_setplaysamplerate(csa_res *resp, u_long ulInRate)
@@ -387,40 +294,6 @@ csa_setcapturesamplerate(csa_res *resp, u_long ulOutRate)
 	csa_writemem(resp, (BA1_CSPB + 4), 0x0000FFFF);
 }
 
-static int
-csachan_setblocksize(void *data, u_int32_t blocksize)
-{
-#if notdef
-	return blocksize;
-#else
-	struct csa_chinfo *ch = data;
-	return ch->buffer->bufsize / 2;
-#endif /* notdef */
-}
-
-static int
-csachan_trigger(void *data, int go)
-{
-	struct csa_chinfo *ch = data;
-	struct csa_info *csa = ch->parent;
-
-	if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
-		return 0;
-
-	if (ch->dir == PCMDIR_PLAY) {
-		if (go == PCMTRIG_START)
-			csa_startplaydma(csa);
-		else
-			csa_stopplaydma(csa);
-	} else {
-		if (go == PCMTRIG_START)
-			csa_startcapturedma(csa);
-		else
-			csa_stopcapturedma(csa);
-	}
-	return 0;
-}
-
 static void
 csa_startplaydma(struct csa_info *csa)
 {
@@ -638,8 +511,134 @@ csa_startdsp(csa_res *resp)
 	return (0);
 }
 
+/* -------------------------------------------------------------------- */
+/* channel interface */
+
+static void *
+csachan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+{
+	struct csa_info *csa = devinfo;
+	struct csa_chinfo *ch = (dir == PCMDIR_PLAY)? &csa->pch : &csa->rch;
+
+	ch->parent = csa;
+	ch->channel = c;
+	ch->buffer = b;
+	ch->buffer->bufsize = CS461x_BUFFSIZE;
+	if (chn_allocbuf(ch->buffer, csa->parent_dmat) == -1) return NULL;
+	return ch;
+}
+
+static int
+csachan_setdir(kobj_t obj, void *data, int dir)
+{
+	struct csa_chinfo *ch = data;
+	struct csa_info *csa = ch->parent;
+	csa_res *resp;
+
+	resp = &csa->res;
+
+	if (dir == PCMDIR_PLAY)
+		csa_writemem(resp, BA1_PBA, vtophys(ch->buffer->buf));
+	else
+		csa_writemem(resp, BA1_CBA, vtophys(ch->buffer->buf));
+	ch->dir = dir;
+	return 0;
+}
+
+static int
+csachan_setformat(kobj_t obj, void *data, u_int32_t format)
+{
+	struct csa_chinfo *ch = data;
+	struct csa_info *csa = ch->parent;
+	u_long pdtc;
+	csa_res *resp;
+
+	resp = &csa->res;
+
+	if (ch->dir == PCMDIR_REC)
+		csa_writemem(resp, BA1_CIE, (csa_readmem(resp, BA1_CIE) & ~0x0000003f) | 0x00000001);
+	else {
+		csa->pfie = csa_readmem(resp, BA1_PFIE) & ~0x0000f03f;
+		if (format & AFMT_U8 || format & AFMT_U16_LE || format & AFMT_U16_BE)
+			csa->pfie |= 0x8000;
+		if (format & AFMT_S16_BE || format & AFMT_U16_BE)
+			csa->pfie |= 0x4000;
+		if (!(format & AFMT_STEREO))
+			csa->pfie |= 0x2000;
+		if (format & AFMT_U8 || format & AFMT_S8)
+			csa->pfie |= 0x1000;
+		csa_writemem(resp, BA1_PFIE, csa->pfie);
+		pdtc = csa_readmem(resp, BA1_PDTC) & ~0x000003ff;
+		if ((format & AFMT_S16_BE || format & AFMT_U16_BE || format & AFMT_S16_LE || format & AFMT_U16_LE) && (format & AFMT_STEREO))
+			pdtc |= 0x00f;
+		else if ((format & AFMT_S16_BE || format & AFMT_U16_BE || format & AFMT_S16_LE || format & AFMT_U16_LE) || (format & AFMT_STEREO))
+			pdtc |= 0x007;
+		else
+			pdtc |= 0x003;
+		csa_writemem(resp, BA1_PDTC, pdtc);
+	}
+	ch->fmt = format;
+	return 0;
+}
+
+static int
+csachan_setspeed(kobj_t obj, void *data, u_int32_t speed)
+{
+	struct csa_chinfo *ch = data;
+	struct csa_info *csa = ch->parent;
+	csa_res *resp;
+
+	resp = &csa->res;
+
+	if (ch->dir == PCMDIR_PLAY)
+		csa_setplaysamplerate(resp, speed);
+	else if (ch->dir == PCMDIR_REC)
+		csa_setcapturesamplerate(resp, speed);
+
+	/* rec/play speeds locked together - should indicate in flags */
+#if 0
+	if (ch->direction == PCMDIR_PLAY) d->rec[0].speed = speed;
+	else d->play[0].speed = speed;
+#endif
+	return speed; /* XXX calc real speed */
+}
+
 static int
-csachan_getptr(void *data)
+csachan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
+{
+#if notdef
+	return blocksize;
+#else
+	struct csa_chinfo *ch = data;
+	return ch->buffer->bufsize / 2;
+#endif /* notdef */
+}
+
+static int
+csachan_trigger(kobj_t obj, void *data, int go)
+{
+	struct csa_chinfo *ch = data;
+	struct csa_info *csa = ch->parent;
+
+	if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
+		return 0;
+
+	if (ch->dir == PCMDIR_PLAY) {
+		if (go == PCMTRIG_START)
+			csa_startplaydma(csa);
+		else
+			csa_stopplaydma(csa);
+	} else {
+		if (go == PCMTRIG_START)
+			csa_startcapturedma(csa);
+		else
+			csa_stopcapturedma(csa);
+	}
+	return 0;
+}
+
+static int
+csachan_getptr(kobj_t obj, void *data)
 {
 	struct csa_chinfo *ch = data;
 	struct csa_info *csa = ch->parent;
@@ -662,12 +661,26 @@ csachan_getptr(void *data)
 }
 
 static pcmchan_caps *
-csachan_getcaps(void *data)
+csachan_getcaps(kobj_t obj, void *data)
 {
 	struct csa_chinfo *ch = data;
 	return (ch->dir == PCMDIR_PLAY)? &csa_playcaps : &csa_reccaps;
 }
 
+static kobj_method_t csachan_methods[] = {
+    	KOBJMETHOD(channel_init,		csachan_init),
+    	KOBJMETHOD(channel_setdir,		csachan_setdir),
+    	KOBJMETHOD(channel_setformat,		csachan_setformat),
+    	KOBJMETHOD(channel_setspeed,		csachan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	csachan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		csachan_trigger),
+    	KOBJMETHOD(channel_getptr,		csachan_getptr),
+    	KOBJMETHOD(channel_getcaps,		csachan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(csachan);
+
+/* -------------------------------------------------------------------- */
 /* The interrupt handler */
 static void
 csa_intr (void *p)
@@ -833,12 +846,12 @@ pcmcsa_attach(device_t dev)
 		csa_releaseres(csa, dev);
 		return (ENXIO);
 	}
-	codec = ac97_create(dev, csa, NULL, csa_rdcd, csa_wrcd);
+	codec = AC97_CREATE(dev, csa, csa_ac97);
 	if (codec == NULL) {
 		csa_releaseres(csa, dev);
 		return (ENXIO);
 	}
-	if (mixer_init(dev, &ac97_mixer, codec) == -1) {
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) {
 		ac97_destroy(codec);
 		csa_releaseres(csa, dev);
 		return (ENXIO);
@@ -860,8 +873,8 @@ pcmcsa_attach(device_t dev)
 		csa_releaseres(csa, dev);
 		return (ENXIO);
 	}
-	pcm_addchan(dev, PCMDIR_REC, &csa_chantemplate, csa);
-	pcm_addchan(dev, PCMDIR_PLAY, &csa_chantemplate, csa);
+	pcm_addchan(dev, PCMDIR_REC, &csachan_class, csa);
+	pcm_addchan(dev, PCMDIR_PLAY, &csachan_class, csa);
 	pcm_setstatus(dev, status);
 
 	return (0);
@@ -883,28 +896,6 @@ pcmcsa_detach(device_t dev)
 	return 0;
 }
 
-/* ac97 codec */
-
-static u_int32_t
-csa_rdcd(void *devinfo, int regno)
-{
-	u_int32_t data;
-	struct csa_info *csa = (struct csa_info *)devinfo;
-
-	if (csa_readcodec(&csa->res, regno + BA0_AC97_RESET, &data))
-		data = 0;
-
-	return data;
-}
-
-static void
-csa_wrcd(void *devinfo, int regno, u_int32_t data)
-{
-	struct csa_info *csa = (struct csa_info *)devinfo;
-
-	csa_writecodec(&csa->res, regno + BA0_AC97_RESET, data);
-}
-
 static device_method_t pcmcsa_methods[] = {
 	/* Device interface */
 	DEVMETHOD(device_probe , pcmcsa_probe ),
diff --git a/sys/dev/sound/pci/ds1.c b/sys/dev/sound/pci/ds1.c
index bf2c79a..c215b5a 100644
--- a/sys/dev/sound/pci/ds1.c
+++ b/sys/dev/sound/pci/ds1.c
@@ -130,7 +130,6 @@ struct {
 	char *name;
 	u_int32_t *mcode;
 } ds_devs[] = {
-/* Beware, things know the indexes here */
 	{0x00041073, 0, 		"Yamaha DS-1 (YMF724)", CntrlInst},
 	{0x000d1073, 0, 		"Yamaha DS-1E (YMF724F)", CntrlInst1E},
 	{0x00051073, 0, 		"Yamaha DS-1? (YMF734)", CntrlInst},
@@ -139,10 +138,10 @@ struct {
 	{0x00061073, 0, 		"Yamaha DS-1? (YMF738_TEG)", CntrlInst},
 	{0x000a1073, 0x00041073, 	"Yamaha DS-1 (YMF740)", CntrlInst},
 	{0x000a1073, 0x000a1073,  	"Yamaha DS-1 (YMF740B)", CntrlInst},
-/*8*/	{0x000a1073, 0x53328086,	"Yamaha DS-1 (YMF740I)", CntrlInst},
+	{0x000a1073, 0x53328086,	"Yamaha DS-1 (YMF740I)", CntrlInst},
 	{0x000a1073, 0, 		"Yamaha DS-1 (YMF740?)", CntrlInst},
 	{0x000c1073, 0, 		"Yamaha DS-1E (YMF740C)", CntrlInst1E},
-/*11*/	{0x00101073, 0, 		"Yamaha DS-1E (YMF744)", CntrlInst1E},
+	{0x00101073, 0, 		"Yamaha DS-1E (YMF744)", CntrlInst1E},
 	{0x00121073, 0, 		"Yamaha DS-1E (YMF754)", CntrlInst1E},
 	{0, 0, NULL, NULL}
 };
@@ -153,27 +152,6 @@ struct {
  * prototypes
  */
 
-/* channel interface */
-static void *ds1pchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int ds1pchan_setformat(void *data, u_int32_t format);
-static int ds1pchan_setspeed(void *data, u_int32_t speed);
-static int ds1pchan_setblocksize(void *data, u_int32_t blocksize);
-static int ds1pchan_trigger(void *data, int go);
-static int ds1pchan_getptr(void *data);
-static pcmchan_caps *ds1pchan_getcaps(void *data);
-
-static void *ds1rchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int ds1rchan_setformat(void *data, u_int32_t format);
-static int ds1rchan_setspeed(void *data, u_int32_t speed);
-static int ds1rchan_setblocksize(void *data, u_int32_t blocksize);
-static int ds1rchan_trigger(void *data, int go);
-static int ds1rchan_getptr(void *data);
-static pcmchan_caps *ds1rchan_getcaps(void *data);
-
-/* talk to the codec - called from ac97.c */
-static u_int32_t ds_rdcd(void *, int);
-static void  	 ds_wrcd(void *, int, u_int32_t);
-
 /* stuff */
 static int       ds_init(struct sc_info *);
 static void      ds_intr(void *);
@@ -206,44 +184,6 @@ static u_int32_t ds_playfmt[] = {
 };
 static pcmchan_caps ds_playcaps = {4000, 96000, ds_playfmt, 0};
 
-static pcm_channel ds_pchantemplate = {
-	ds1pchan_init,
-	NULL, 			/* setdir */
-	ds1pchan_setformat,
-	ds1pchan_setspeed,
-	ds1pchan_setblocksize,
-	ds1pchan_trigger,
-	ds1pchan_getptr,
-	ds1pchan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
-static pcm_channel ds_rchantemplate = {
-	ds1rchan_init,
-	NULL, 			/* setdir */
-	ds1rchan_setformat,
-	ds1rchan_setspeed,
-	ds1rchan_setblocksize,
-	ds1rchan_trigger,
-	ds1rchan_getptr,
-	ds1rchan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 /* -------------------------------------------------------------------- */
 /* Hardware */
 static u_int32_t
@@ -284,6 +224,7 @@ wrl(struct sc_info *sc, u_int32_t *ptr, u_int32_t val)
 	bus_space_barrier(sc->st, sc->sh, 0, 0, BUS_SPACE_BARRIER_WRITE);
 }
 
+/* -------------------------------------------------------------------- */
 /* ac97 codec */
 static int
 ds_cdbusy(struct sc_info *sc, int sec)
@@ -301,7 +242,7 @@ ds_cdbusy(struct sc_info *sc, int sec)
 }
 
 static u_int32_t
-ds_initcd(void *devinfo)
+ds_initcd(kobj_t obj, void *devinfo)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 	u_int32_t x;
@@ -326,8 +267,8 @@ ds_initcd(void *devinfo)
 	return ds_cdbusy(sc, 0)? 0 : 1;
 }
 
-static u_int32_t
-ds_rdcd(void *devinfo, int regno)
+static int
+ds_rdcd(kobj_t obj, void *devinfo, int regno)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 	int sec, cid, i;
@@ -353,8 +294,8 @@ ds_rdcd(void *devinfo, int regno)
 	return ds_rd(sc, reg, 2);
 }
 
-static void
-ds_wrcd(void *devinfo, int regno, u_int32_t data)
+static int
+ds_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 	int sec, cid;
@@ -364,16 +305,26 @@ ds_wrcd(void *devinfo, int regno, u_int32_t data)
 	regno &= 0xff;
 	cid = sec? (sc->cd2id << 8) : 0;
 	if (sec && cid == 0)
-		return;
+		return ENXIO;
 
 	cmd = YDSXG_AC97WRITECMD | cid | regno;
 	cmd <<= 16;
 	cmd |= data;
 	ds_wr(sc, YDSXGR_AC97CMDDATA, cmd, 4);
 
-	ds_cdbusy(sc, sec);
+	return ds_cdbusy(sc, sec);
 }
 
+static kobj_method_t ds_ac97_methods[] = {
+    	KOBJMETHOD(ac97_init,		ds_initcd),
+    	KOBJMETHOD(ac97_read,		ds_rdcd),
+    	KOBJMETHOD(ac97_write,		ds_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(ds_ac97);
+
+/* -------------------------------------------------------------------- */
+
 static void
 ds_enadsp(struct sc_info *sc, int on)
 {
@@ -517,9 +468,10 @@ ds_setuprch(struct sc_rchinfo *ch)
 	ds_wr(sc, pri? YDSXGR_ADCSLOTSR : YDSXGR_RECSLOTSR, y, 4);
 }
 
+/* -------------------------------------------------------------------- */
 /* play channel interface */
 static void *
-ds1pchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+ds1pchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sc_info *sc = devinfo;
 	struct sc_pchinfo *ch;
@@ -548,7 +500,7 @@ ds1pchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-ds1pchan_setformat(void *data, u_int32_t format)
+ds1pchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sc_pchinfo *ch = data;
 
@@ -558,7 +510,7 @@ ds1pchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-ds1pchan_setspeed(void *data, u_int32_t speed)
+ds1pchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sc_pchinfo *ch = data;
 
@@ -568,14 +520,14 @@ ds1pchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-ds1pchan_setblocksize(void *data, u_int32_t blocksize)
+ds1pchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 /* semantic note: must start at beginning of buffer */
 static int
-ds1pchan_trigger(void *data, int go)
+ds1pchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sc_pchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -601,7 +553,7 @@ ds1pchan_trigger(void *data, int go)
 }
 
 static int
-ds1pchan_getptr(void *data)
+ds1pchan_getptr(kobj_t obj, void *data)
 {
 	struct sc_pchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -620,14 +572,27 @@ ds1pchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-ds1pchan_getcaps(void *data)
+ds1pchan_getcaps(kobj_t obj, void *data)
 {
 	return &ds_playcaps;
 }
 
+static kobj_method_t ds1pchan_methods[] = {
+    	KOBJMETHOD(channel_init,		ds1pchan_init),
+    	KOBJMETHOD(channel_setformat,		ds1pchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		ds1pchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	ds1pchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		ds1pchan_trigger),
+    	KOBJMETHOD(channel_getptr,		ds1pchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		ds1pchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(ds1pchan);
+
+/* -------------------------------------------------------------------- */
 /* record channel interface */
 static void *
-ds1rchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+ds1rchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sc_info *sc = devinfo;
 	struct sc_rchinfo *ch;
@@ -653,7 +618,7 @@ ds1rchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-ds1rchan_setformat(void *data, u_int32_t format)
+ds1rchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sc_rchinfo *ch = data;
 
@@ -663,7 +628,7 @@ ds1rchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-ds1rchan_setspeed(void *data, u_int32_t speed)
+ds1rchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sc_rchinfo *ch = data;
 
@@ -673,14 +638,14 @@ ds1rchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-ds1rchan_setblocksize(void *data, u_int32_t blocksize)
+ds1rchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 /* semantic note: must start at beginning of buffer */
 static int
-ds1rchan_trigger(void *data, int go)
+ds1rchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sc_rchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -706,7 +671,7 @@ ds1rchan_trigger(void *data, int go)
 }
 
 static int
-ds1rchan_getptr(void *data)
+ds1rchan_getptr(kobj_t obj, void *data)
 {
 	struct sc_rchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -715,11 +680,24 @@ ds1rchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-ds1rchan_getcaps(void *data)
+ds1rchan_getcaps(kobj_t obj, void *data)
 {
 	return &ds_reccaps;
 }
 
+static kobj_method_t ds1rchan_methods[] = {
+    	KOBJMETHOD(channel_init,		ds1rchan_init),
+    	KOBJMETHOD(channel_setformat,		ds1rchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		ds1rchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	ds1rchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		ds1rchan_trigger),
+    	KOBJMETHOD(channel_getptr,		ds1rchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		ds1rchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(ds1rchan);
+
+/* -------------------------------------------------------------------- */
 /* The interrupt handler */
 static void
 ds_intr(void *p)
@@ -970,10 +948,10 @@ ds_pci_attach(device_t dev)
 		goto bad;
 	}
 
-	codec = ac97_create(dev, sc, ds_initcd, ds_rdcd, ds_wrcd);
+	codec = AC97_CREATE(dev, sc, ds_ac97);
 	if (codec == NULL)
 		goto bad;
-	mixer_init(dev, &ac97_mixer, codec);
+	mixer_init(dev, ac97_getmixerclass(), codec);
 
 	sc->irqid = 0;
 	sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irqid,
@@ -990,9 +968,9 @@ ds_pci_attach(device_t dev)
 	if (pcm_register(dev, sc, DS1_CHANS, 2))
 		goto bad;
 	for (i = 0; i < DS1_CHANS; i++)
-		pcm_addchan(dev, PCMDIR_PLAY, &ds_pchantemplate, sc);
+		pcm_addchan(dev, PCMDIR_PLAY, &ds1pchan_class, sc);
 	for (i = 0; i < 2; i++)
-		pcm_addchan(dev, PCMDIR_REC, &ds_rchantemplate, sc);
+		pcm_addchan(dev, PCMDIR_REC, &ds1rchan_class, sc);
 	pcm_setstatus(dev, status);
 
 	return 0;
diff --git a/sys/dev/sound/pci/emu10k1.c b/sys/dev/sound/pci/emu10k1.c
index 98d55c7..2e46ede 100644
--- a/sys/dev/sound/pci/emu10k1.c
+++ b/sys/dev/sound/pci/emu10k1.c
@@ -111,31 +111,6 @@ struct sc_info {
  * prototypes
  */
 
-/* channel interface */
-static void *emupchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int emupchan_free(void *data);
-static int emupchan_setdir(void *data, int dir);
-static int emupchan_setformat(void *data, u_int32_t format);
-static int emupchan_setspeed(void *data, u_int32_t speed);
-static int emupchan_setblocksize(void *data, u_int32_t blocksize);
-static int emupchan_trigger(void *data, int go);
-static int emupchan_getptr(void *data);
-static pcmchan_caps *emupchan_getcaps(void *data);
-
-/* channel interface */
-static void *emurchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int emurchan_setdir(void *data, int dir);
-static int emurchan_setformat(void *data, u_int32_t format);
-static int emurchan_setspeed(void *data, u_int32_t speed);
-static int emurchan_setblocksize(void *data, u_int32_t blocksize);
-static int emurchan_trigger(void *data, int go);
-static int emurchan_getptr(void *data);
-static pcmchan_caps *emurchan_getcaps(void *data);
-
-/* talk to the codec - called from ac97.c */
-static u_int32_t emu_rdcd(void *, int);
-static void emu_wrcd(void *, int, u_int32_t);
-
 /* stuff */
 static int emu_init(struct sc_info *);
 static void emu_intr(void *);
@@ -183,45 +158,7 @@ static u_int32_t emu_pfmt[] = {
 	0
 };
 
-static pcmchan_caps emu_playcaps = {4000, 48000, emu_pfmt, 0};
-
-static pcm_channel emu_chantemplate = {
-	emupchan_init,
-	emupchan_setdir,
-	emupchan_setformat,
-	emupchan_setspeed,
-	emupchan_setblocksize,
-	emupchan_trigger,
-	emupchan_getptr,
-	emupchan_getcaps,
-	emupchan_free, 		/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
-static pcm_channel emur_chantemplate = {
-	emurchan_init,
-	emurchan_setdir,
-	emurchan_setformat,
-	emurchan_setspeed,
-	emurchan_setblocksize,
-	emurchan_trigger,
-	emurchan_getptr,
-	emurchan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
+static pcmchan_caps emu_playcaps = {48000, 48000, emu_pfmt, 0};
 
 static int adcspeed[8] = {48000, 44100, 32000, 24000, 22050, 16000, 11025, 8000};
 
@@ -300,9 +237,11 @@ emu_wrefx(struct sc_info *sc, unsigned int pc, unsigned int data)
 	emu_wrptr(sc, 0, MICROCODEBASE + pc, data);
 }
 
+/* -------------------------------------------------------------------- */
 /* ac97 codec */
-static u_int32_t
-emu_rdcd(void *devinfo, int regno)
+
+static int
+emu_rdcd(kobj_t obj, void *devinfo, int regno)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 
@@ -310,15 +249,25 @@ emu_rdcd(void *devinfo, int regno)
 	return emu_rd(sc, AC97DATA, 2);
 }
 
-static void
-emu_wrcd(void *devinfo, int regno, u_int32_t data)
+static int
+emu_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 
 	emu_wr(sc, AC97ADDRESS, regno, 1);
 	emu_wr(sc, AC97DATA, data, 2);
+	return 0;
 }
 
+static kobj_method_t emu_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		emu_rdcd),
+    	KOBJMETHOD(ac97_write,		emu_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(emu_ac97);
+
+/* -------------------------------------------------------------------- */
+
 #if 0
 /* playback channel interrupts */
 static u_int32_t
@@ -671,8 +620,8 @@ emu_vdump(struct sc_info *sc, struct emu_voice *v)
 #endif
 
 /* channel interface */
-void *
-emupchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+static void *
+emupchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sc_info *sc = devinfo;
 	struct sc_pchinfo *ch;
@@ -691,7 +640,7 @@ emupchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-emupchan_free(void *data)
+emupchan_free(kobj_t obj, void *data)
 {
 	struct sc_pchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -700,13 +649,7 @@ emupchan_free(void *data)
 }
 
 static int
-emupchan_setdir(void *data, int dir)
-{
-	return 0;
-}
-
-static int
-emupchan_setformat(void *data, u_int32_t format)
+emupchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sc_pchinfo *ch = data;
 
@@ -715,7 +658,7 @@ emupchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-emupchan_setspeed(void *data, u_int32_t speed)
+emupchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sc_pchinfo *ch = data;
 
@@ -724,13 +667,13 @@ emupchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-emupchan_setblocksize(void *data, u_int32_t blocksize)
+emupchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-emupchan_trigger(void *data, int go)
+emupchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sc_pchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -757,7 +700,7 @@ emupchan_trigger(void *data, int go)
 }
 
 static int
-emupchan_getptr(void *data)
+emupchan_getptr(kobj_t obj, void *data)
 {
 	struct sc_pchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -766,14 +709,27 @@ emupchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-emupchan_getcaps(void *data)
+emupchan_getcaps(kobj_t obj, void *data)
 {
 	return &emu_playcaps;
 }
 
+static kobj_method_t emupchan_methods[] = {
+    	KOBJMETHOD(channel_init,		emupchan_init),
+    	KOBJMETHOD(channel_free,		emupchan_free),
+    	KOBJMETHOD(channel_setformat,		emupchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		emupchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	emupchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		emupchan_trigger),
+    	KOBJMETHOD(channel_getptr,		emupchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		emupchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(emupchan);
+
 /* channel interface */
 static void *
-emurchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+emurchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sc_info *sc = devinfo;
 	struct sc_rchinfo *ch;
@@ -823,13 +779,7 @@ emurchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-emurchan_setdir(void *data, int dir)
-{
-	return 0;
-}
-
-static int
-emurchan_setformat(void *data, u_int32_t format)
+emurchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sc_rchinfo *ch = data;
 
@@ -838,7 +788,7 @@ emurchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-emurchan_setspeed(void *data, u_int32_t speed)
+emurchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sc_rchinfo *ch = data;
 
@@ -853,14 +803,14 @@ emurchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-emurchan_setblocksize(void *data, u_int32_t blocksize)
+emurchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 /* semantic note: must start at beginning of buffer */
 static int
-emurchan_trigger(void *data, int go)
+emurchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sc_rchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -903,7 +853,7 @@ emurchan_trigger(void *data, int go)
 }
 
 static int
-emurchan_getptr(void *data)
+emurchan_getptr(kobj_t obj, void *data)
 {
 	struct sc_rchinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -912,7 +862,7 @@ emurchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-emurchan_getcaps(void *data)
+emurchan_getcaps(kobj_t obj, void *data)
 {
 	struct sc_rchinfo *ch = data;
 
@@ -979,6 +929,18 @@ emu_intr(void *p)
 	}
 }
 
+static kobj_method_t emurchan_methods[] = {
+    	KOBJMETHOD(channel_init,		emurchan_init),
+    	KOBJMETHOD(channel_setformat,		emurchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		emurchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	emurchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		emurchan_trigger),
+    	KOBJMETHOD(channel_getptr,		emurchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		emurchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(emurchan);
+
 /* -------------------------------------------------------------------- */
 
 static void
@@ -1468,9 +1430,9 @@ emu_pci_attach(device_t dev)
 		goto bad;
 	}
 
-	codec = ac97_create(dev, sc, NULL, emu_rdcd, emu_wrcd);
+	codec = AC97_CREATE(dev, sc, emu_ac97);
 	if (codec == NULL) goto bad;
-	if (mixer_init(dev, &ac97_mixer, codec) == -1) goto bad;
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad;
 
 	sc->irqid = 0;
 	sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irqid,
@@ -1487,9 +1449,9 @@ emu_pci_attach(device_t dev)
 
 	if (pcm_register(dev, sc, EMU_CHANS, 3)) goto bad;
 	for (i = 0; i < EMU_CHANS; i++)
-		pcm_addchan(dev, PCMDIR_PLAY, &emu_chantemplate, sc);
+		pcm_addchan(dev, PCMDIR_PLAY, &emupchan_class, sc);
 	for (i = 0; i < 3; i++)
-		pcm_addchan(dev, PCMDIR_REC, &emur_chantemplate, sc);
+		pcm_addchan(dev, PCMDIR_REC, &emurchan_class, sc);
 
 	pcm_setstatus(dev, status);
 
diff --git a/sys/dev/sound/pci/es137x.c b/sys/dev/sound/pci/es137x.c
index 2b736c2..15779e8 100644
--- a/sys/dev/sound/pci/es137x.c
+++ b/sys/dev/sound/pci/es137x.c
@@ -59,6 +59,8 @@
 
 #include <sys/sysctl.h>
 
+#include "mixer_if.h"
+
 static int debug = 0;
 SYSCTL_INT(_debug, OID_AUTO, es_debug, CTLFLAG_RW, &debug, 0, "");
 
@@ -105,8 +107,6 @@ struct es_info {
 /* prototypes */
 static void     es_intr(void *);
 
-static void	es1371_wrcodec(void *, int, u_int32_t);
-static u_int32_t es1371_rdcodec(void *, int);
 static u_int	es1371_wait_src_ready(struct es_info *);
 static void	es1371_src_write(struct es_info *, u_short, unsigned short);
 static u_int	es1371_adc_rate(struct es_info *, u_int, int);
@@ -115,17 +115,6 @@ static int	es1371_init(struct es_info *es, int);
 static int      es1370_init(struct es_info *);
 static int      es1370_wrcodec(struct es_info *, u_char, u_char);
 
-/* channel interface */
-static void *eschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int   eschan_setdir(void *data, int dir);
-static int   eschan_setformat(void *data, u_int32_t format);
-static int   eschan1370_setspeed(void *data, u_int32_t speed);
-static int   eschan1371_setspeed(void *data, u_int32_t speed);
-static int   eschan_setblocksize(void *data, u_int32_t blocksize);
-static int   eschan_trigger(void *data, int go);
-static int   eschan_getptr(void *data);
-static pcmchan_caps *eschan_getcaps(void *data);
-
 static u_int32_t es_playfmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -144,61 +133,6 @@ static u_int32_t es_recfmt[] = {
 };
 static pcmchan_caps es_reccaps = {4000, 48000, es_recfmt, 0};
 
-static pcm_channel es1370_chantemplate = {
-	eschan_init,
-	eschan_setdir,
-	eschan_setformat,
-	eschan1370_setspeed,
-	eschan_setblocksize,
-	eschan_trigger,
-	eschan_getptr,
-	eschan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
-static pcm_channel es1371_chantemplate = {
-	eschan_init,
-	eschan_setdir,
-	eschan_setformat,
-	eschan1371_setspeed,
-	eschan_setblocksize,
-	eschan_trigger,
-	eschan_getptr,
-	eschan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
-/* -------------------------------------------------------------------- */
-
-/* The es1370 mixer interface */
-
-static int es1370_mixinit(snd_mixer *m);
-static int es1370_mixset(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int es1370_mixsetrecsrc(snd_mixer *m, u_int32_t src);
-
-static snd_mixer es1370_mixer = {
-	"AudioPCI 1370 mixer",
-	es1370_mixinit,
-	NULL,
-	NULL,
-	es1370_mixset,
-	es1370_mixsetrecsrc,
-};
-
 static const struct {
 	unsigned        volidx:4;
 	unsigned        left:4;
@@ -219,6 +153,9 @@ static const struct {
 	[SOUND_MIXER_OGAIN]	= { 9, 0xf, 0x0, 0, 0x0000, 1 }
 };
 
+/* -------------------------------------------------------------------- */
+/* The es1370 mixer interface */
+
 static int
 es1370_mixinit(snd_mixer *m)
 {
@@ -276,6 +213,16 @@ es1370_mixsetrecsrc(snd_mixer *m, u_int32_t src)
 	return src;
 }
 
+static kobj_method_t es1370_mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		es1370_mixinit),
+    	KOBJMETHOD(mixer_set,		es1370_mixset),
+    	KOBJMETHOD(mixer_setrecsrc,	es1370_mixsetrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(es1370_mixer);
+
+/* -------------------------------------------------------------------- */
+
 static int
 es1370_wrcodec(struct es_info *es, u_char i, u_char data)
 {
@@ -298,7 +245,7 @@ es1370_wrcodec(struct es_info *es, u_char i, u_char data)
 
 /* channel interface */
 static void *
-eschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+eschan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct es_info *es = devinfo;
 	struct es_chinfo *ch = (dir == PCMDIR_PLAY)? &es->pch : &es->rch;
@@ -313,7 +260,7 @@ eschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-eschan_setdir(void *data, int dir)
+eschan_setdir(kobj_t obj, void *data, int dir)
 {
 	struct es_chinfo *ch = data;
 	struct es_info *es = ch->parent;
@@ -338,7 +285,7 @@ eschan_setdir(void *data, int dir)
 }
 
 static int
-eschan_setformat(void *data, u_int32_t format)
+eschan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct es_chinfo *ch = data;
 	struct es_info *es = ch->parent;
@@ -358,7 +305,7 @@ eschan_setformat(void *data, u_int32_t format)
 }
 
 static int
-eschan1370_setspeed(void *data, u_int32_t speed)
+eschan1370_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct es_chinfo *ch = data;
 	struct es_info *es = ch->parent;
@@ -370,8 +317,8 @@ eschan1370_setspeed(void *data, u_int32_t speed)
 	return speed; /* XXX calc real speed */
 }
 
-int
-eschan1371_setspeed(void *data, u_int32_t speed)
+static int
+eschan1371_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
   	struct es_chinfo *ch = data;
   	struct es_info *es = ch->parent;
@@ -384,13 +331,13 @@ eschan1371_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-eschan_setblocksize(void *data, u_int32_t blocksize)
+eschan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-eschan_trigger(void *data, int go)
+eschan_trigger(kobj_t obj, void *data, int go)
 {
 	struct es_chinfo *ch = data;
 	struct es_info *es = ch->parent;
@@ -442,7 +389,7 @@ eschan_trigger(void *data, int go)
 }
 
 static int
-eschan_getptr(void *data)
+eschan_getptr(kobj_t obj, void *data)
 {
 	struct es_chinfo *ch = data;
 	struct es_info *es = ch->parent;
@@ -460,12 +407,39 @@ eschan_getptr(void *data)
 }
 
 static pcmchan_caps *
-eschan_getcaps(void *data)
+eschan_getcaps(kobj_t obj, void *data)
 {
 	struct es_chinfo *ch = data;
 	return (ch->dir == PCMDIR_PLAY)? &es_playcaps : &es_reccaps;
 }
 
+static kobj_method_t eschan1370_methods[] = {
+    	KOBJMETHOD(channel_init,		eschan_init),
+    	KOBJMETHOD(channel_setdir,		eschan_setdir),
+    	KOBJMETHOD(channel_setformat,		eschan_setformat),
+    	KOBJMETHOD(channel_setspeed,		eschan1370_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	eschan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		eschan_trigger),
+    	KOBJMETHOD(channel_getptr,		eschan_getptr),
+    	KOBJMETHOD(channel_getcaps,		eschan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(eschan1370);
+
+static kobj_method_t eschan1371_methods[] = {
+    	KOBJMETHOD(channel_init,		eschan_init),
+    	KOBJMETHOD(channel_setdir,		eschan_setdir),
+    	KOBJMETHOD(channel_setformat,		eschan_setformat),
+    	KOBJMETHOD(channel_setspeed,		eschan1371_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	eschan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		eschan_trigger),
+    	KOBJMETHOD(channel_getptr,		eschan_getptr),
+    	KOBJMETHOD(channel_getcaps,		eschan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(eschan1371);
+
+/* -------------------------------------------------------------------- */
 /* The interrupt handler */
 static void
 es_intr(void *p)
@@ -564,8 +538,10 @@ es1371_init(struct es_info *es, int rev)
 	return (0);
 }
 
-static void
-es1371_wrcodec(void *s, int addr, u_int32_t data)
+/* -------------------------------------------------------------------- */
+
+static int
+es1371_wrcd(kobj_t obj, void *s, int addr, u_int32_t data)
 {
     	int sl;
     	unsigned t, x;
@@ -600,10 +576,12 @@ es1371_wrcodec(void *s, int addr, u_int32_t data)
 	if (debug > 2) printf("two b_s_w: 0x%x 0x%x 0x%x\n", es->sh, ES1371_REG_SMPRATE, x);
 	bus_space_write_4(es->st, es->sh, ES1371_REG_SMPRATE, x);
 	splx(sl);
+
+	return 0;
 }
 
-static u_int32_t
-es1371_rdcodec(void *s, int addr)
+static int
+es1371_rdcd(kobj_t obj, void *s, int addr)
 {
   	int sl;
   	unsigned t, x;
@@ -646,6 +624,15 @@ es1371_rdcodec(void *s, int addr)
   	return ((x & CODEC_PIDAT_MASK) >> CODEC_PIDAT_SHIFT);
 }
 
+static kobj_method_t es1371_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		es1371_rdcd),
+    	KOBJMETHOD(ac97_write,		es1371_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(es1371_ac97);
+
+/* -------------------------------------------------------------------- */
+
 static u_int
 es1371_src_read(struct es_info *es, u_short reg)
 {
@@ -769,7 +756,7 @@ es_pci_attach(device_t dev)
 	int		mapped;
 	char		status[SND_STATUSLEN];
 	struct ac97_info *codec = 0;
-	pcm_channel     *ct = NULL;
+	kobj_class_t    ct = NULL;
 
 	if ((es = malloc(sizeof *es, M_DEVBUF, M_NOWAIT)) == NULL) {
 		device_printf(dev, "cannot allocate softc\n");
@@ -817,20 +804,20 @@ es_pci_attach(device_t dev)
 			device_printf(dev, "unable to initialize the card\n");
 			goto bad;
 		}
-	  	codec = ac97_create(dev, es, NULL, es1371_rdcodec, es1371_wrcodec);
+		codec = AC97_CREATE(dev, es, es1371_ac97);
 	  	if (codec == NULL) goto bad;
 	  	/* our init routine does everything for us */
 	  	/* set to NULL; flag mixer_init not to run the ac97_init */
 	  	/*	  ac97_mixer.init = NULL;  */
-		if (mixer_init(dev, &ac97_mixer, codec) == -1) goto bad;
-		ct = &es1371_chantemplate;
+		if (mixer_init(dev, ac97_getmixerclass(), codec)) goto bad;
+		ct = &eschan1371_class;
 	} else if (pci_get_devid(dev) == ES1370_PCI_ID) {
 	  	if (-1 == es1370_init(es)) {
 			device_printf(dev, "unable to initialize the card\n");
 			goto bad;
 	  	}
-	  	mixer_init(dev, &es1370_mixer, es);
-		ct = &es1370_chantemplate;
+	  	if (mixer_init(dev, &es1370_mixer_class, es)) goto bad;
+		ct = &eschan1370_class;
 	} else goto bad;
 
 	es->irqid = 0;
diff --git a/sys/dev/sound/pci/fm801.c b/sys/dev/sound/pci/fm801.c
index 2173c0a..a01ea8e 100644
--- a/sys/dev/sound/pci/fm801.c
+++ b/sys/dev/sound/pci/fm801.c
@@ -101,15 +101,6 @@
 /* debug purposes */
 #define DPRINT	 if(0) printf
 
-
-/* channel interface */
-static void *fm801ch_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int fm801ch_setformat(void *data, u_int32_t format);
-static int fm801ch_setspeed(void *data, u_int32_t speed);
-static int fm801ch_setblocksize(void *data, u_int32_t blocksize);
-static int fm801ch_trigger(void *data, int go);
-static int fm801ch_getptr(void *data);
-static pcmchan_caps *fm801ch_getcaps(void *data);
 /*
 static int fm801ch_setup(pcm_channel *c);
 */
@@ -127,25 +118,6 @@ static pcmchan_caps fm801ch_caps = {
 	fmts, 0
 };
 
-static pcm_channel fm801_chantemplate = {
-	fm801ch_init,
-	NULL, 			/* setdir */
-	fm801ch_setformat,
-	fm801ch_setspeed,
-	fm801ch_setblocksize,
-	fm801ch_trigger,
-	fm801ch_getptr,
-	fm801ch_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 struct fm801_info;
 
 struct fm801_chinfo {
@@ -220,12 +192,13 @@ fm801_wr(struct fm801_info *fm801, int regno, u_int32_t data, int size)
 	}
 }
 
+/* -------------------------------------------------------------------- */
 /*
  *  ac97 codec routines
  */
 #define TIMO 50
-static u_int32_t
-fm801_rdcd(void *devinfo, int regno)
+static int
+fm801_rdcd(kobj_t obj, void *devinfo, int regno)
 {
 	struct fm801_info *fm801 = (struct fm801_info *)devinfo;
 	int i;
@@ -254,8 +227,8 @@ fm801_rdcd(void *devinfo, int regno)
 	return fm801_rd(fm801,FM_CODEC_DATA,2);
 }
 
-static void
-fm801_wrcd(void *devinfo, int regno, u_int32_t data)
+static int
+fm801_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 {
 	struct fm801_info *fm801 = (struct fm801_info *)devinfo;
 	int i;
@@ -271,7 +244,7 @@ fm801_wrcd(void *devinfo, int regno, u_int32_t data)
 	}
 	if (i >= TIMO) {
 		printf("fm801 wrcd: read codec busy\n");
-		return;
+		return -1;
 	}
 
 	fm801_wr(fm801,FM_CODEC_DATA,data, 2);
@@ -284,12 +257,21 @@ fm801_wrcd(void *devinfo, int regno, u_int32_t data)
 	}
 	if (i >= TIMO) {
 		printf("fm801 wrcd: read codec busy\n");
-		return;
+		return -1;
 	}
 	DPRINT("fm801 wrcd release reg 0x%x val 0x%x\n",regno, data);
-	return;
+	return 0;
 }
 
+static kobj_method_t fm801_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		fm801_rdcd),
+    	KOBJMETHOD(ac97_write,		fm801_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(fm801_ac97);
+
+/* -------------------------------------------------------------------- */
+
 /*
  * The interrupt handler
  */
@@ -337,179 +319,10 @@ fm801_intr(void *p)
 	fm801_wr(fm801, FM_INTSTATUS, intsrc & (FM_INTSTATUS_PLAY | FM_INTSTATUS_REC), 2);
 }
 
-/*
- *  Init routine is taken from an original NetBSD driver
- */
-static int
-fm801_init(struct fm801_info *fm801)
-{
-	u_int32_t k1;
-
-	/* reset codec */
-	fm801_wr(fm801, FM_CODEC_CTL, 0x0020,2);
-	DELAY(100000);
-	fm801_wr(fm801, FM_CODEC_CTL, 0x0000,2);
-	DELAY(100000);
-
-	fm801_wr(fm801, FM_PCM_VOLUME, 0x0808,2);
-	fm801_wr(fm801, FM_FM_VOLUME, 0x0808,2);
-	fm801_wr(fm801, FM_I2S_VOLUME, 0x0808,2);
-	fm801_wr(fm801, 0x40,0x107f,2);	/* enable legacy audio */
-
-	fm801_wr((void *)fm801, FM_RECORD_SOURCE, 0x0000,2);
-
-	/* Unmask playback, record and mpu interrupts, mask the rest */
-	k1 = fm801_rd((void *)fm801, FM_INTMASK,2);
-	fm801_wr(fm801, FM_INTMASK,
-		(k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) |
-		FM_INTMASK_VOL,2);
-	fm801_wr(fm801, FM_INTSTATUS,
-		FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU |
-		FM_INTSTATUS_VOL,2);
-
-	DPRINT("FM801 init Ok\n");
-	return 0;
-}
-
-static int
-fm801_pci_attach(device_t dev)
-{
-	u_int32_t 		data;
-	struct ac97_info 	*codec = 0;
-	struct fm801_info 	*fm801;
-	int 			i;
-	int 			mapped = 0;
-	char 			status[SND_STATUSLEN];
-
-	if ((fm801 = (struct fm801_info *)malloc(sizeof(*fm801),M_DEVBUF, M_NOWAIT)) == NULL) {
-		device_printf(dev, "cannot allocate softc\n");
-		return ENXIO;
-	}
-
-	bzero(fm801, sizeof(*fm801));
-	fm801->type = pci_get_devid(dev);
-
-	data = pci_read_config(dev, PCIR_COMMAND, 2);
-	data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
-	pci_write_config(dev, PCIR_COMMAND, data, 2);
-	data = pci_read_config(dev, PCIR_COMMAND, 2);
-
-	for (i = 0; (mapped == 0) && (i < PCI_MAXMAPS_0); i++) {
-		fm801->regid = PCIR_MAPS + i*4;
-		fm801->regtype = SYS_RES_MEMORY;
-		fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid,
-						0, ~0, 1, RF_ACTIVE);
-		if(!fm801->reg)
-		{
-			fm801->regtype = SYS_RES_IOPORT;
-			fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid,
-						0, ~0, 1, RF_ACTIVE);
-		}
-
-		if(fm801->reg) {
-			fm801->st = rman_get_bustag(fm801->reg);
-			fm801->sh = rman_get_bushandle(fm801->reg);
-			mapped++;
-		}
-	}
-
-	if (mapped == 0) {
-		device_printf(dev, "unable to map register space\n");
-		goto oops;
-	}
-
-	fm801_init(fm801);
-
-	codec = ac97_create(dev, (void *)fm801, NULL, fm801_rdcd, fm801_wrcd);
-	if (codec == NULL) goto oops;
-
-	if (mixer_init(dev, &ac97_mixer, codec) == -1) goto oops;
-
-	fm801->irqid = 0;
-	fm801->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &fm801->irqid,
-				0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
-	if (!fm801->irq ||
-		bus_setup_intr(dev, fm801->irq, INTR_TYPE_TTY,
-					fm801_intr, fm801, &fm801->ih)) {
-		device_printf(dev, "unable to map interrupt\n");
-		goto oops;
-	}
-
-	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
-		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
-		/*highaddr*/BUS_SPACE_MAXADDR,
-		/*filter*/NULL, /*filterarg*/NULL,
-		/*maxsize*/FM801_BUFFSIZE, /*nsegments*/1, /*maxsegz*/0x3ffff,
-		/*flags*/0, &fm801->parent_dmat) != 0) {
-		device_printf(dev, "unable to create dma tag\n");
-		goto oops;
-	}
-
-	snprintf(status, 64, "at %s 0x%lx irq %ld",
-		(fm801->regtype == SYS_RES_IOPORT)? "io" : "memory",
-		rman_get_start(fm801->reg), rman_get_start(fm801->irq));
-
-#define FM801_MAXPLAYCH	1
-	if (pcm_register(dev, fm801, FM801_MAXPLAYCH, 1)) goto oops;
-	pcm_addchan(dev, PCMDIR_PLAY, &fm801_chantemplate, fm801);
-	pcm_addchan(dev, PCMDIR_REC, &fm801_chantemplate, fm801);
-	pcm_setstatus(dev, status);
-
-	return 0;
-
-oops:
-	if (codec) ac97_destroy(codec);
-	if (fm801->reg) bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
-	if (fm801->ih) bus_teardown_intr(dev, fm801->irq, fm801->ih);
-	if (fm801->irq) bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
-	if (fm801->parent_dmat) bus_dma_tag_destroy(fm801->parent_dmat);
-	free(fm801, M_DEVBUF);
-	return ENXIO;
-}
-
-static int
-fm801_pci_detach(device_t dev)
-{
-	int r;
-	struct fm801_info *fm801;
-
-	DPRINT("Forte Media FM801 detach\n");
-
-	r = pcm_unregister(dev);
-	if (r)
-		return r;
-
-	fm801 = pcm_getdevinfo(dev);
-	bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
-	bus_teardown_intr(dev, fm801->irq, fm801->ih);
-	bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
-	bus_dma_tag_destroy(fm801->parent_dmat);
-	free(fm801, M_DEVBUF);
-	return 0;
-}
-
-static int
-fm801_pci_probe( device_t dev )
-{
-	int id;
-	if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA1 ) {
-		device_set_desc(dev, "Forte Media FM801 Audio Controller");
-		return 0;
-	}
-/*
-	if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA2 ) {
-		device_set_desc(dev, "Forte Media FM801 Joystick (Not Supported)");
-		return ENXIO;
-	}
-*/
-	return ENXIO;
-}
-
-
-
+/* -------------------------------------------------------------------- */
 /* channel interface */
 static void *
-fm801ch_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+fm801ch_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct fm801_info *fm801 = (struct fm801_info *)devinfo;
 	struct fm801_chinfo *ch = (dir == PCMDIR_PLAY)? &fm801->pch : &fm801->rch;
@@ -525,7 +338,7 @@ fm801ch_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-fm801ch_setformat(void *data, u_int32_t format)
+fm801ch_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct fm801_chinfo *ch = data;
 	struct fm801_info *fm801 = ch->parent;
@@ -570,7 +383,7 @@ struct {
 };
 
 static int
-fm801ch_setspeed(void *data, u_int32_t speed)
+fm801ch_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct fm801_chinfo *ch = data;
 	struct fm801_info *fm801 = ch->parent;
@@ -597,7 +410,7 @@ fm801ch_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-fm801ch_setblocksize(void *data, u_int32_t blocksize)
+fm801ch_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	struct fm801_chinfo *ch = data;
 	struct fm801_info *fm801 = ch->parent;
@@ -618,7 +431,7 @@ fm801ch_setblocksize(void *data, u_int32_t blocksize)
 }
 
 static int
-fm801ch_trigger(void *data, int go)
+fm801ch_trigger(kobj_t obj, void *data, int go)
 {
 	struct fm801_chinfo *ch = data;
 	struct fm801_info *fm801 = ch->parent;
@@ -678,7 +491,7 @@ fm801ch_trigger(void *data, int go)
 
 /* Almost ALSA copy */
 static int
-fm801ch_getptr(void *data)
+fm801ch_getptr(kobj_t obj, void *data)
 {
 	struct fm801_chinfo *ch = data;
 	struct fm801_info *fm801 = ch->parent;
@@ -704,11 +517,193 @@ fm801ch_getptr(void *data)
 }
 
 static pcmchan_caps *
-fm801ch_getcaps(void *data)
+fm801ch_getcaps(kobj_t obj, void *data)
 {
 	return &fm801ch_caps;
 }
 
+static kobj_method_t fm801ch_methods[] = {
+    	KOBJMETHOD(channel_init,		fm801ch_init),
+    	KOBJMETHOD(channel_setformat,		fm801ch_setformat),
+    	KOBJMETHOD(channel_setspeed,		fm801ch_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	fm801ch_setblocksize),
+    	KOBJMETHOD(channel_trigger,		fm801ch_trigger),
+    	KOBJMETHOD(channel_getptr,		fm801ch_getptr),
+    	KOBJMETHOD(channel_getcaps,		fm801ch_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(fm801ch);
+
+/* -------------------------------------------------------------------- */
+
+/*
+ *  Init routine is taken from an original NetBSD driver
+ */
+static int
+fm801_init(struct fm801_info *fm801)
+{
+	u_int32_t k1;
+
+	/* reset codec */
+	fm801_wr(fm801, FM_CODEC_CTL, 0x0020,2);
+	DELAY(100000);
+	fm801_wr(fm801, FM_CODEC_CTL, 0x0000,2);
+	DELAY(100000);
+
+	fm801_wr(fm801, FM_PCM_VOLUME, 0x0808,2);
+	fm801_wr(fm801, FM_FM_VOLUME, 0x0808,2);
+	fm801_wr(fm801, FM_I2S_VOLUME, 0x0808,2);
+	fm801_wr(fm801, 0x40,0x107f,2);	/* enable legacy audio */
+
+	fm801_wr((void *)fm801, FM_RECORD_SOURCE, 0x0000,2);
+
+	/* Unmask playback, record and mpu interrupts, mask the rest */
+	k1 = fm801_rd((void *)fm801, FM_INTMASK,2);
+	fm801_wr(fm801, FM_INTMASK,
+		(k1 & ~(FM_INTMASK_PLAY | FM_INTMASK_REC | FM_INTMASK_MPU)) |
+		FM_INTMASK_VOL,2);
+	fm801_wr(fm801, FM_INTSTATUS,
+		FM_INTSTATUS_PLAY | FM_INTSTATUS_REC | FM_INTSTATUS_MPU |
+		FM_INTSTATUS_VOL,2);
+
+	DPRINT("FM801 init Ok\n");
+	return 0;
+}
+
+static int
+fm801_pci_attach(device_t dev)
+{
+	u_int32_t 		data;
+	struct ac97_info 	*codec = 0;
+	struct fm801_info 	*fm801;
+	int 			i;
+	int 			mapped = 0;
+	char 			status[SND_STATUSLEN];
+
+	if ((fm801 = (struct fm801_info *)malloc(sizeof(*fm801),M_DEVBUF, M_NOWAIT)) == NULL) {
+		device_printf(dev, "cannot allocate softc\n");
+		return ENXIO;
+	}
+
+	bzero(fm801, sizeof(*fm801));
+	fm801->type = pci_get_devid(dev);
+
+	data = pci_read_config(dev, PCIR_COMMAND, 2);
+	data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
+	pci_write_config(dev, PCIR_COMMAND, data, 2);
+	data = pci_read_config(dev, PCIR_COMMAND, 2);
+
+	for (i = 0; (mapped == 0) && (i < PCI_MAXMAPS_0); i++) {
+		fm801->regid = PCIR_MAPS + i*4;
+		fm801->regtype = SYS_RES_MEMORY;
+		fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid,
+						0, ~0, 1, RF_ACTIVE);
+		if(!fm801->reg)
+		{
+			fm801->regtype = SYS_RES_IOPORT;
+			fm801->reg = bus_alloc_resource(dev, fm801->regtype, &fm801->regid,
+						0, ~0, 1, RF_ACTIVE);
+		}
+
+		if(fm801->reg) {
+			fm801->st = rman_get_bustag(fm801->reg);
+			fm801->sh = rman_get_bushandle(fm801->reg);
+			mapped++;
+		}
+	}
+
+	if (mapped == 0) {
+		device_printf(dev, "unable to map register space\n");
+		goto oops;
+	}
+
+	fm801_init(fm801);
+
+	codec = AC97_CREATE(dev, fm801, fm801_ac97);
+	if (codec == NULL) goto oops;
+
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto oops;
+
+	fm801->irqid = 0;
+	fm801->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &fm801->irqid,
+				0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
+	if (!fm801->irq ||
+		bus_setup_intr(dev, fm801->irq, INTR_TYPE_TTY,
+					fm801_intr, fm801, &fm801->ih)) {
+		device_printf(dev, "unable to map interrupt\n");
+		goto oops;
+	}
+
+	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
+		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
+		/*highaddr*/BUS_SPACE_MAXADDR,
+		/*filter*/NULL, /*filterarg*/NULL,
+		/*maxsize*/FM801_BUFFSIZE, /*nsegments*/1, /*maxsegz*/0x3ffff,
+		/*flags*/0, &fm801->parent_dmat) != 0) {
+		device_printf(dev, "unable to create dma tag\n");
+		goto oops;
+	}
+
+	snprintf(status, 64, "at %s 0x%lx irq %ld",
+		(fm801->regtype == SYS_RES_IOPORT)? "io" : "memory",
+		rman_get_start(fm801->reg), rman_get_start(fm801->irq));
+
+#define FM801_MAXPLAYCH	1
+	if (pcm_register(dev, fm801, FM801_MAXPLAYCH, 1)) goto oops;
+	pcm_addchan(dev, PCMDIR_PLAY, &fm801ch_class, fm801);
+	pcm_addchan(dev, PCMDIR_REC, &fm801ch_class, fm801);
+	pcm_setstatus(dev, status);
+
+	return 0;
+
+oops:
+	if (codec) ac97_destroy(codec);
+	if (fm801->reg) bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
+	if (fm801->ih) bus_teardown_intr(dev, fm801->irq, fm801->ih);
+	if (fm801->irq) bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
+	if (fm801->parent_dmat) bus_dma_tag_destroy(fm801->parent_dmat);
+	free(fm801, M_DEVBUF);
+	return ENXIO;
+}
+
+static int
+fm801_pci_detach(device_t dev)
+{
+	int r;
+	struct fm801_info *fm801;
+
+	DPRINT("Forte Media FM801 detach\n");
+
+	r = pcm_unregister(dev);
+	if (r)
+		return r;
+
+	fm801 = pcm_getdevinfo(dev);
+	bus_release_resource(dev, fm801->regtype, fm801->regid, fm801->reg);
+	bus_teardown_intr(dev, fm801->irq, fm801->ih);
+	bus_release_resource(dev, SYS_RES_IRQ, fm801->irqid, fm801->irq);
+	bus_dma_tag_destroy(fm801->parent_dmat);
+	free(fm801, M_DEVBUF);
+	return 0;
+}
+
+static int
+fm801_pci_probe( device_t dev )
+{
+	int id;
+	if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA1 ) {
+		device_set_desc(dev, "Forte Media FM801 Audio Controller");
+		return 0;
+	}
+/*
+	if ((id = pci_get_devid(dev)) == PCI_DEVICE_FORTEMEDIA2 ) {
+		device_set_desc(dev, "Forte Media FM801 Joystick (Not Supported)");
+		return ENXIO;
+	}
+*/
+	return ENXIO;
+}
+
 static device_method_t fm801_methods[] = {
 	/* Device interface */
 	DEVMETHOD(device_probe,		fm801_pci_probe),
diff --git a/sys/dev/sound/pci/maestro.c b/sys/dev/sound/pci/maestro.c
index 60afaa5..5955f77 100644
--- a/sys/dev/sound/pci/maestro.c
+++ b/sys/dev/sound/pci/maestro.c
@@ -114,10 +114,6 @@ struct agg_info {
 	struct agg_chinfo	rch;
 };
 
-
-static u_int32_t	 agg_rdcodec(void *, int);
-static void		 agg_wrcodec(void *, int, u_int32_t);
-
 static inline void	 ringbus_setdest(struct agg_info*, int, int);
 
 static inline u_int16_t	 wp_rdreg(struct agg_info*, u_int16_t);
@@ -136,7 +132,6 @@ static inline void	 wc_wrchctl(struct agg_info*, int, u_int16_t);
 static inline void	 agg_power(struct agg_info*, int);
 
 static void		 agg_init(struct agg_info*);
-static u_int32_t	 agg_ac97_init(void *);
 
 static void		 aggch_start_dac(struct agg_chinfo*);
 static void		 aggch_stop_dac(struct agg_chinfo*);
@@ -146,15 +141,6 @@ static inline void	 suppress_jitter(struct agg_chinfo*);
 static inline u_int	 calc_timer_freq(struct agg_chinfo*);
 static void		 set_timer(struct agg_info*);
 
-static pcmchan_init_t		aggch_init;
-static pcmchan_free_t		aggch_free;
-static pcmchan_setformat_t	aggch_setplayformat;
-static pcmchan_setspeed_t	aggch_setspeed;
-static pcmchan_setblocksize_t	aggch_setblocksize;
-static pcmchan_trigger_t	aggch_trigger;
-static pcmchan_getptr_t		aggch_getplayptr;
-static pcmchan_getcaps_t	aggch_getcaps;
-
 static void		 agg_intr(void *);
 static int		 agg_probe(device_t);
 static int		 agg_attach(device_t);
@@ -172,8 +158,18 @@ static void	 dma_free(struct agg_info*, void *);
 
 /* Codec/Ringbus */
 
+/* -------------------------------------------------------------------- */
+
 static u_int32_t
-agg_rdcodec(void *sc, int regno)
+agg_ac97_init(kobj_t obj, void *sc)
+{
+	struct agg_info *ess = sc;
+
+	return (bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT) & CODEC_STAT_MASK)? 0 : 1;
+}
+
+static int
+agg_rdcodec(kobj_t obj, void *sc, int regno)
 {
 	struct agg_info *ess = sc;
 	unsigned t;
@@ -206,8 +202,8 @@ agg_rdcodec(void *sc, int regno)
 	return bus_space_read_2(ess->st, ess->sh, PORT_CODEC_REG);
 }
 
-static void
-agg_wrcodec(void *sc, int regno, u_int32_t data)
+static int
+agg_wrcodec(kobj_t obj, void *sc, int regno, u_int32_t data)
 {
 	unsigned t;
 	struct agg_info *ess = sc;
@@ -222,14 +218,26 @@ agg_wrcodec(void *sc, int regno, u_int32_t data)
 	if (t == 20) {
 		/* Timed out. Abort writing. */
 		device_printf(ess->dev, "agg_wrcodec() PROGLESS timed out.\n");
-		return;
+		return -1;
 	}
 
 	bus_space_write_2(ess->st, ess->sh, PORT_CODEC_REG, data);
 	bus_space_write_1(ess->st, ess->sh, PORT_CODEC_CMD,
 	    CODEC_CMD_WRITE | regno);
+
+	return 0;
 }
 
+static kobj_method_t agg_ac97_methods[] = {
+    	KOBJMETHOD(ac97_init,		agg_ac97_init),
+    	KOBJMETHOD(ac97_read,		agg_rdcodec),
+    	KOBJMETHOD(ac97_write,		agg_wrcodec),
+	{ 0, 0 }
+};
+AC97_DECLARE(agg_ac97);
+
+/* -------------------------------------------------------------------- */
+
 static inline void
 ringbus_setdest(struct agg_info *ess, int src, int dest)
 {
@@ -396,7 +404,7 @@ agg_initcodec(struct agg_info* ess)
 	    RINGBUS_CTRL_ACLINK_ENABLED);
 	DELAY(21);
 
-	agg_rdcodec(ess, 0);
+	agg_rdcodec(NULL, ess, 0);
 	if (bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT)
 	    & CODEC_STAT_MASK) {
 		bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 0);
@@ -627,16 +635,8 @@ set_timer(struct agg_info *ess)
  * Newpcm glue.
  */
 
-static u_int32_t
-agg_ac97_init(void *sc)
-{
-	struct agg_info *ess = sc;
-
-	return (bus_space_read_1(ess->st, ess->sh, PORT_CODEC_STAT) & CODEC_STAT_MASK)? 0 : 1;
-}
-
 static void *
-aggch_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+aggch_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct agg_info *ess = devinfo;
 	struct agg_chinfo *ch;
@@ -677,7 +677,7 @@ aggch_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-aggch_free(void *data)
+aggch_free(kobj_t obj, void *data)
 {
 	struct agg_chinfo *ch = data;
 	struct agg_info *ess = ch->parent;
@@ -690,7 +690,7 @@ aggch_free(void *data)
 }
 
 static int
-aggch_setplayformat(void *data, u_int32_t format)
+aggch_setplayformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct agg_chinfo *ch = data;
 	u_int16_t wcreg_tpl;
@@ -717,19 +717,19 @@ aggch_setplayformat(void *data, u_int32_t format)
 }
 
 static int
-aggch_setspeed(void *data, u_int32_t speed)
+aggch_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	return speed;
 }
 
 static int
-aggch_setblocksize(void *data, u_int32_t blocksize)
+aggch_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return ((struct agg_chinfo*)data)->blocksize = blocksize;
 }
 
 static int
-aggch_trigger(void *data, int go)
+aggch_trigger(kobj_t obj, void *data, int go)
 {
 	struct agg_chinfo *ch = data;
 
@@ -767,7 +767,7 @@ aggch_trigger(void *data, int go)
 }
 
 static int
-aggch_getplayptr(void *data)
+aggch_getplayptr(kobj_t obj, void *data)
 {
 	struct agg_chinfo *ch = data;
 	u_int cp;
@@ -782,7 +782,7 @@ aggch_getplayptr(void *data)
 }
 
 static pcmchan_caps *
-aggch_getcaps(void *data)
+aggch_getcaps(kobj_t obj, void *data)
 {
 	static u_int32_t playfmt[] = {
 		AFMT_U8,
@@ -808,6 +808,18 @@ aggch_getcaps(void *data)
 	    &playcaps : &reccaps;
 }
 
+static kobj_method_t aggch_methods[] = {
+    	KOBJMETHOD(channel_init,		aggch_init),
+    	KOBJMETHOD(channel_free,		aggch_free),
+    	KOBJMETHOD(channel_setformat,		aggch_setplayformat),
+    	KOBJMETHOD(channel_setspeed,		aggch_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	aggch_setblocksize),
+    	KOBJMETHOD(channel_trigger,		aggch_trigger),
+    	KOBJMETHOD(channel_getptr,		aggch_getplayptr),
+    	KOBJMETHOD(channel_getcaps,		aggch_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(aggch);
 
 /* -----------------------------
  * Bus space.
@@ -933,24 +945,6 @@ agg_attach(device_t dev)
 	struct resource	*irq = NULL;
 	void	*ih = NULL;
 	char	status[SND_STATUSLEN];
-	static pcm_channel agg_pchtpl = {
-	    	aggch_init,
-		NULL, 			/* setdir */
-	    	aggch_setplayformat,
-	    	aggch_setspeed,
-	    	aggch_setblocksize,
-	    	aggch_trigger,
-	    	aggch_getplayptr,
-	    	aggch_getcaps,
-		aggch_free, 		/* free */
-		NULL, 			/* nop1 */
-		NULL, 			/* nop2 */
-		NULL, 			/* nop3 */
-		NULL, 			/* nop4 */
-		NULL, 			/* nop5 */
-		NULL, 			/* nop6 */
-		NULL, 			/* nop7 */
-	};
 
 	if ((ess = malloc(sizeof *ess, M_DEVBUF, M_NOWAIT)) == NULL) {
 		device_printf(dev, "cannot allocate softc\n");
@@ -1003,14 +997,14 @@ agg_attach(device_t dev)
 	}
 
 	agg_init(ess);
-	if (agg_rdcodec(ess, 0) == 0x80) {
+	if (agg_rdcodec(NULL, ess, 0) == 0x80) {
 		device_printf(dev, "PT101 codec detected!\n");
 		goto bad;
 	}
-	codec = ac97_create(dev, ess, agg_ac97_init, agg_rdcodec, agg_wrcodec);
+	codec = AC97_CREATE(dev, ess, agg_ac97);
 	if (codec == NULL)
 		goto bad;
-	if (mixer_init(dev, &ac97_mixer, codec) == -1)
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1)
 		goto bad;
 	ess->codec = codec;
 
@@ -1032,9 +1026,9 @@ agg_attach(device_t dev)
 		goto bad;
 
 	for (data = 0; data < AGG_MAXPLAYCH; data++)
-		pcm_addchan(dev, PCMDIR_PLAY, &agg_pchtpl, ess);
+		pcm_addchan(dev, PCMDIR_PLAY, &aggch_class, ess);
 #if 0	/* XXX - RECORDING */
-	pcm_addchan(dev, PCMDIR_REC, &agg_rchtpl, ess);
+	pcm_addchan(dev, PCMDIR_REC, &aggrch_class, ess);
 #endif
 	pcm_setstatus(dev, status);
 
@@ -1075,7 +1069,7 @@ agg_detach(device_t dev)
 	dma_free(ess, ess->stat);
 
 	/* Power down everything except clock and vref. */
-	agg_wrcodec(ess, AC97_REG_POWER, 0xd700);
+	agg_wrcodec(NULL, ess, AC97_REG_POWER, 0xd700);
 	DELAY(20);
 	bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 0);
 	agg_power(ess, PPMI_D3);
@@ -1106,7 +1100,7 @@ agg_suspend(device_t dev)
 #endif
 	splx(x);
 	/* Power down everything except clock. */
-	agg_wrcodec(ess, AC97_REG_POWER, 0xdf00);
+	agg_wrcodec(NULL, ess, AC97_REG_POWER, 0xdf00);
 	DELAY(20);
 	bus_space_write_4(ess->st, ess->sh, PORT_RINGBUS_CTRL, 0);
 	DELAY(1);
diff --git a/sys/dev/sound/pci/neomagic.c b/sys/dev/sound/pci/neomagic.c
index 6867253..1e2760c 100644
--- a/sys/dev/sound/pci/neomagic.c
+++ b/sys/dev/sound/pci/neomagic.c
@@ -76,21 +76,6 @@ struct sc_info {
  * prototypes
  */
 
-/* channel interface */
-static void *nmchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int nmchan_free(void *data);
-static int nmchan_setformat(void *data, u_int32_t format);
-static int nmchan_setspeed(void *data, u_int32_t speed);
-static int nmchan_setblocksize(void *data, u_int32_t blocksize);
-static int nmchan_trigger(void *data, int go);
-static int nmchan_getptr(void *data);
-static pcmchan_caps *nmchan_getcaps(void *data);
-
-static int 	 nm_waitcd(struct sc_info *sc);
-/* talk to the codec - called from ac97.c */
-static u_int32_t nm_rdcd(void *, int);
-static void  	 nm_wrcd(void *, int, u_int32_t);
-
 /* stuff */
 static int 	 nm_loadcoeff(struct sc_info *sc, int dir, int num);
 static int	 nm_setch(struct sc_chinfo *ch);
@@ -134,25 +119,6 @@ static u_int32_t nm_fmt[] = {
 };
 static pcmchan_caps nm_caps = {4000, 48000, nm_fmt, 0};
 
-static pcm_channel nm_chantemplate = {
-	nmchan_init,
-	NULL, 			/* setdir */
-	nmchan_setformat,
-	nmchan_setspeed,
-	nmchan_setblocksize,
-	nmchan_trigger,
-	nmchan_getptr,
-	nmchan_getcaps,
-	nmchan_free, 		/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 /* -------------------------------------------------------------------- */
 
 /* Hardware */
@@ -230,6 +196,7 @@ nm_wrbuf(struct sc_info *sc, int regno, u_int32_t data, int size)
 	}
 }
 
+/* -------------------------------------------------------------------- */
 /* ac97 codec */
 static int
 nm_waitcd(struct sc_info *sc)
@@ -246,7 +213,7 @@ nm_waitcd(struct sc_info *sc)
 }
 
 static u_int32_t
-nm_initcd(void *devinfo)
+nm_initcd(kobj_t obj, void *devinfo)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 
@@ -257,8 +224,8 @@ nm_initcd(void *devinfo)
 	return 1;
 }
 
-static u_int32_t
-nm_rdcd(void *devinfo, int regno)
+static int
+nm_rdcd(kobj_t obj, void *devinfo, int regno)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 	u_int32_t x;
@@ -269,12 +236,12 @@ nm_rdcd(void *devinfo, int regno)
 		return x;
 	} else {
 		device_printf(sc->dev, "ac97 codec not ready\n");
-		return 0xffffffff;
+		return -1;
 	}
 }
 
-static void
-nm_wrcd(void *devinfo, int regno, u_int32_t data)
+static int
+nm_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 {
 	struct sc_info *sc = (struct sc_info *)devinfo;
 	int cnt = 3;
@@ -284,13 +251,24 @@ nm_wrcd(void *devinfo, int regno, u_int32_t data)
 			nm_wr(sc, sc->ac97_base + regno, data, 2);
 			if (!nm_waitcd(sc)) {
 				DELAY(1000);
-				return;
+				return 0;
 			}
 		}
 	}
 	device_printf(sc->dev, "ac97 codec not ready\n");
+	return -1;
 }
 
+static kobj_method_t nm_ac97_methods[] = {
+    	KOBJMETHOD(ac97_init,		nm_initcd),
+    	KOBJMETHOD(ac97_read,		nm_rdcd),
+    	KOBJMETHOD(ac97_write,		nm_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(nm_ac97);
+
+/* -------------------------------------------------------------------- */
+
 static void
 nm_ackint(struct sc_info *sc, u_int32_t num)
 {
@@ -351,7 +329,7 @@ nm_setch(struct sc_chinfo *ch)
 
 /* channel interface */
 static void *
-nmchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+nmchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct sc_info *sc = devinfo;
 	struct sc_chinfo *ch;
@@ -372,13 +350,13 @@ nmchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-nmchan_free(void *data)
+nmchan_free(kobj_t obj, void *data)
 {
 	return 0;
 }
 
 static int
-nmchan_setformat(void *data, u_int32_t format)
+nmchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct sc_chinfo *ch = data;
 
@@ -387,7 +365,7 @@ nmchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-nmchan_setspeed(void *data, u_int32_t speed)
+nmchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct sc_chinfo *ch = data;
 
@@ -396,13 +374,13 @@ nmchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-nmchan_setblocksize(void *data, u_int32_t blocksize)
+nmchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-nmchan_trigger(void *data, int go)
+nmchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct sc_chinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -444,7 +422,7 @@ nmchan_trigger(void *data, int go)
 }
 
 static int
-nmchan_getptr(void *data)
+nmchan_getptr(kobj_t obj, void *data)
 {
 	struct sc_chinfo *ch = data;
 	struct sc_info *sc = ch->parent;
@@ -456,11 +434,24 @@ nmchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-nmchan_getcaps(void *data)
+nmchan_getcaps(kobj_t obj, void *data)
 {
 	return &nm_caps;
 }
 
+static kobj_method_t nmchan_methods[] = {
+    	KOBJMETHOD(channel_init,		nmchan_init),
+    	KOBJMETHOD(channel_free,		nmchan_free),
+    	KOBJMETHOD(channel_setformat,		nmchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		nmchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	nmchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		nmchan_trigger),
+    	KOBJMETHOD(channel_getptr,		nmchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		nmchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(nmchan);
+
 /* The interrupt handler */
 static void
 nm_intr(void *p)
@@ -626,9 +617,9 @@ nm_pci_attach(device_t dev)
 		goto bad;
 	}
 
-	codec = ac97_create(dev, sc, nm_initcd, nm_rdcd, nm_wrcd);
+	codec = AC97_CREATE(dev, sc, nm_ac97);
 	if (codec == NULL) goto bad;
-	if (mixer_init(dev, &ac97_mixer, codec) == -1) goto bad;
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad;
 
 	sc->irqid = 0;
 	sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irqid,
@@ -644,8 +635,8 @@ nm_pci_attach(device_t dev)
 		 rman_get_start(sc->irq));
 
 	if (pcm_register(dev, sc, 1, 1)) goto bad;
-	pcm_addchan(dev, PCMDIR_REC, &nm_chantemplate, sc);
-	pcm_addchan(dev, PCMDIR_PLAY, &nm_chantemplate, sc);
+	pcm_addchan(dev, PCMDIR_REC, &nmchan_class, sc);
+	pcm_addchan(dev, PCMDIR_PLAY, &nmchan_class, sc);
 	pcm_setstatus(dev, status);
 
 	return 0;
diff --git a/sys/dev/sound/pci/solo.c b/sys/dev/sound/pci/solo.c
index 672c7a0..7cb10f3 100644
--- a/sys/dev/sound/pci/solo.c
+++ b/sys/dev/sound/pci/solo.c
@@ -33,6 +33,8 @@
 #include  <dev/sound/isa/sb.h>
 #include  <dev/sound/chip.h>
 
+#include "mixer_if.h"
+
 #define ESS_BUFFSIZE (16384)
 #define ABS(x) (((x) < 0)? -(x) : (x))
 
@@ -42,15 +44,6 @@
 /* more accurate clocks and split audio1/audio2 rates */
 #define ESS18XX_NEWSPEED
 
-/* channel interface for ESS */
-static void *esschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int esschan_setformat(void *data, u_int32_t format);
-static int esschan_setspeed(void *data, u_int32_t speed);
-static int esschan_setblocksize(void *data, u_int32_t blocksize);
-static int esschan_trigger(void *data, int go);
-static int esschan_getptr(void *data);
-static pcmchan_caps *esschan_getcaps(void *data);
-
 static u_int32_t ess_playfmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -80,25 +73,6 @@ static u_int32_t ess_recfmt[] = {
 };
 static pcmchan_caps ess_reccaps = {5000, 49000, ess_recfmt, 0};
 
-static pcm_channel ess_chantemplate = {
-	esschan_init,
-	NULL, 			/* setdir */
-	esschan_setformat,
-	esschan_setspeed,
-	esschan_setblocksize,
-	esschan_trigger,
-	esschan_getptr,
-	esschan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 struct ess_info;
 
 struct ess_chinfo {
@@ -141,19 +115,6 @@ static int ess_dmasetup(struct ess_info *sc, int ch, u_int32_t base, u_int16_t c
 static int ess_dmapos(struct ess_info *sc, int ch);
 static int ess_dmatrigger(struct ess_info *sc, int ch, int go);
 
-static int essmix_init(snd_mixer *m);
-static int essmix_set(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-static int essmix_setrecsrc(snd_mixer *m, u_int32_t src);
-
-static snd_mixer ess_mixer = {
-    	"ESS mixer",
-    	essmix_init,
-	NULL,
-	NULL,
-    	essmix_set,
-    	essmix_setrecsrc,
-};
-
 static devclass_t pcm_devclass;
 
 /*
@@ -546,9 +507,10 @@ ess_stop(struct ess_chinfo *ch)
 	return 0;
 }
 
+/* -------------------------------------------------------------------- */
 /* channel interface for ESS18xx */
 static void *
-esschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+esschan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct ess_info *sc = devinfo;
 	struct ess_chinfo *ch = (dir == PCMDIR_PLAY)? &sc->pch : &sc->rch;
@@ -568,7 +530,7 @@ esschan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-esschan_setformat(void *data, u_int32_t format)
+esschan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct ess_chinfo *ch = data;
 
@@ -577,7 +539,7 @@ esschan_setformat(void *data, u_int32_t format)
 }
 
 static int
-esschan_setspeed(void *data, u_int32_t speed)
+esschan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct ess_chinfo *ch = data;
 	struct ess_info *sc = ch->parent;
@@ -591,13 +553,13 @@ esschan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-esschan_setblocksize(void *data, u_int32_t blocksize)
+esschan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-esschan_trigger(void *data, int go)
+esschan_trigger(kobj_t obj, void *data, int go)
 {
 	struct ess_chinfo *ch = data;
 	struct ess_info *sc = ch->parent;
@@ -623,7 +585,7 @@ esschan_trigger(void *data, int go)
 }
 
 static int
-esschan_getptr(void *data)
+esschan_getptr(kobj_t obj, void *data)
 {
 	struct ess_chinfo *ch = data;
 	struct ess_info *sc = ch->parent;
@@ -632,13 +594,25 @@ esschan_getptr(void *data)
 }
 
 static pcmchan_caps *
-esschan_getcaps(void *data)
+esschan_getcaps(kobj_t obj, void *data)
 {
 	struct ess_chinfo *ch = data;
 
 	return (ch->dir == PCMDIR_PLAY)? &ess_playcaps : &ess_reccaps;
 }
 
+static kobj_method_t esschan_methods[] = {
+    	KOBJMETHOD(channel_init,		esschan_init),
+    	KOBJMETHOD(channel_setformat,		esschan_setformat),
+    	KOBJMETHOD(channel_setspeed,		esschan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	esschan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		esschan_trigger),
+    	KOBJMETHOD(channel_getptr,		esschan_getptr),
+    	KOBJMETHOD(channel_getcaps,		esschan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(esschan);
+
 /************************************************************/
 
 static int
@@ -749,6 +723,14 @@ essmix_setrecsrc(snd_mixer *m, u_int32_t src)
 	return src;
 }
 
+static kobj_method_t solomixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		essmix_init),
+    	KOBJMETHOD(mixer_set,		essmix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	essmix_setrecsrc),
+	{ 0, 0 }
+};
+MIXER_DECLARE(solomixer);
+
 /************************************************************/
 
 static int
@@ -942,7 +924,8 @@ ess_attach(device_t dev)
 
     	if (ess_reset_dsp(sc))
 		goto no;
-    	mixer_init(dev, &ess_mixer, sc);
+    	if (mixer_init(dev, &solomixer_class, sc))
+		goto no;
 
 	port_wr(sc->io, 0x7, 0xb0, 1); /* enable irqs */
 #ifdef ESS18XX_DUPLEX
@@ -980,8 +963,8 @@ ess_attach(device_t dev)
 
     	if (pcm_register(dev, sc, 1, 1))
 		goto no;
-      	pcm_addchan(dev, PCMDIR_REC, &ess_chantemplate, sc);
-	pcm_addchan(dev, PCMDIR_PLAY, &ess_chantemplate, sc);
+      	pcm_addchan(dev, PCMDIR_REC, &esschan_class, sc);
+	pcm_addchan(dev, PCMDIR_PLAY, &esschan_class, sc);
 	pcm_setstatus(dev, status);
 
     	return 0;
diff --git a/sys/dev/sound/pci/t4dwave.c b/sys/dev/sound/pci/t4dwave.c
index df11fb9..dee0f9f 100644
--- a/sys/dev/sound/pci/t4dwave.c
+++ b/sys/dev/sound/pci/t4dwave.c
@@ -81,20 +81,6 @@ struct tr_info {
  * prototypes
  */
 
-/* channel interface */
-static void *trchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int trchan_setdir(void *data, int dir);
-static int trchan_setformat(void *data, u_int32_t format);
-static int trchan_setspeed(void *data, u_int32_t speed);
-static int trchan_setblocksize(void *data, u_int32_t blocksize);
-static int trchan_trigger(void *data, int go);
-static int trchan_getptr(void *data);
-static pcmchan_caps *trchan_getcaps(void *data);
-
-/* talk to the codec - called from ac97.c */
-static u_int32_t tr_rdcd(void *, int);
-static void  	 tr_wrcd(void *, int, u_int32_t);
-
 /* stuff */
 static int       tr_init(struct tr_info *);
 static void      tr_intr(void *);
@@ -141,25 +127,6 @@ static u_int32_t tr_playfmt[] = {
 };
 static pcmchan_caps tr_playcaps = {4000, 48000, tr_playfmt, 0};
 
-static pcm_channel tr_chantemplate = {
-	trchan_init,
-	trchan_setdir,
-	trchan_setformat,
-	trchan_setspeed,
-	trchan_setblocksize,
-	trchan_trigger,
-	trchan_getptr,
-	trchan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
 /* -------------------------------------------------------------------- */
 
 static u_int32_t
@@ -205,10 +172,11 @@ tr_wr(struct tr_info *tr, int regno, u_int32_t data, int size)
 	}
 }
 
+/* -------------------------------------------------------------------- */
 /* ac97 codec */
 
-static u_int32_t
-tr_rdcd(void *devinfo, int regno)
+static int
+tr_rdcd(kobj_t obj, void *devinfo, int regno)
 {
 	struct tr_info *tr = (struct tr_info *)devinfo;
 	int i, j, treg, trw;
@@ -224,7 +192,7 @@ tr_rdcd(void *devinfo, int regno)
 		break;
 	default:
 		printf("!!! tr_rdcd defaulted !!!\n");
-		return 0xffffffff;
+		return -1;
 	}
 
 	regno &= 0x7f;
@@ -235,8 +203,8 @@ tr_rdcd(void *devinfo, int regno)
 	return (j >> TR_CDC_DATA) & 0xffff;
 }
 
-static void
-tr_wrcd(void *devinfo, int regno, u_int32_t data)
+static int
+tr_wrcd(kobj_t obj, void *devinfo, int regno, u_int32_t data)
 {
 	struct tr_info *tr = (struct tr_info *)devinfo;
 	int i, j, treg, trw;
@@ -252,7 +220,7 @@ tr_wrcd(void *devinfo, int regno, u_int32_t data)
 		break;
 	default:
 		printf("!!! tr_wrcd defaulted !!!");
-		return;
+		return -1;
 	}
 
 	regno &= 0x7f;
@@ -266,8 +234,17 @@ tr_wrcd(void *devinfo, int regno, u_int32_t data)
 	printf(" - wrote %x, now %x\n", data, tr_rdcd(devinfo, regno));
 #endif
 	if (i==0) printf("codec timeout writing %x, data %x\n", regno, data);
+	return (i > 0)? 0 : -1;
 }
 
+static kobj_method_t tr_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		tr_rdcd),
+    	KOBJMETHOD(ac97_write,		tr_wrcd),
+	{ 0, 0 }
+};
+AC97_DECLARE(tr_ac97);
+
+/* -------------------------------------------------------------------- */
 /* playback channel interrupts */
 
 static u_int32_t
@@ -398,10 +375,11 @@ tr_rdch(struct tr_info *tr, char channel, struct tr_chinfo *ch)
 	}
 }
 
+/* -------------------------------------------------------------------- */
 /* channel interface */
 
-void *
-trchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+static void *
+trchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct tr_info *tr = devinfo;
 	struct tr_chinfo *ch;
@@ -421,7 +399,7 @@ trchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-trchan_setdir(void *data, int dir)
+trchan_setdir(kobj_t obj, void *data, int dir)
 {
 	struct tr_chinfo *ch = data;
 	struct tr_info *tr = ch->parent;
@@ -454,7 +432,7 @@ trchan_setdir(void *data, int dir)
 }
 
 static int
-trchan_setformat(void *data, u_int32_t format)
+trchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct tr_chinfo *ch = data;
 	struct tr_info *tr = ch->parent;
@@ -481,7 +459,7 @@ trchan_setformat(void *data, u_int32_t format)
 }
 
 static int
-trchan_setspeed(void *data, u_int32_t speed)
+trchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct tr_chinfo *ch = data;
 	struct tr_info *tr = ch->parent;
@@ -501,14 +479,14 @@ trchan_setspeed(void *data, u_int32_t speed)
 }
 
 static int
-trchan_setblocksize(void *data, u_int32_t blocksize)
+trchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	struct tr_chinfo *ch = data;
 	return ch->buffer->bufsize / 2;
 }
 
 static int
-trchan_trigger(void *data, int go)
+trchan_trigger(kobj_t obj, void *data, int go)
 {
 	struct tr_chinfo *ch = data;
 	struct tr_info *tr = ch->parent;
@@ -531,7 +509,7 @@ trchan_trigger(void *data, int go)
 }
 
 static int
-trchan_getptr(void *data)
+trchan_getptr(kobj_t obj, void *data)
 {
 	struct tr_chinfo *ch = data;
 	struct tr_info *tr = ch->parent;
@@ -543,12 +521,26 @@ trchan_getptr(void *data)
 }
 
 static pcmchan_caps *
-trchan_getcaps(void *data)
+trchan_getcaps(kobj_t obj, void *data)
 {
 	struct tr_chinfo *ch = data;
 	return (ch->index >= 0)? &tr_playcaps : &tr_reccaps;
 }
 
+static kobj_method_t trchan_methods[] = {
+    	KOBJMETHOD(channel_init,		trchan_init),
+    	KOBJMETHOD(channel_setdir,		trchan_setdir),
+    	KOBJMETHOD(channel_setformat,		trchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		trchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	trchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		trchan_trigger),
+    	KOBJMETHOD(channel_getptr,		trchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		trchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(trchan);
+
+/* -------------------------------------------------------------------- */
 /* The interrupt handler */
 
 static void
@@ -659,9 +651,9 @@ tr_pci_attach(device_t dev)
 		goto bad;
 	}
 
-	codec = ac97_create(dev, tr, NULL, tr_rdcd, tr_wrcd);
+	codec = AC97_CREATE(dev, tr, tr_ac97);
 	if (codec == NULL) goto bad;
-	if (mixer_init(dev, &ac97_mixer, codec) == -1) goto bad;
+	if (mixer_init(dev, ac97_getmixerclass(), codec) == -1) goto bad;
 
 	tr->irqid = 0;
 	tr->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &tr->irqid,
@@ -687,9 +679,9 @@ tr_pci_attach(device_t dev)
 		 rman_get_start(tr->reg), rman_get_start(tr->irq));
 
 	if (pcm_register(dev, tr, TR_MAXPLAYCH, 1)) goto bad;
-	pcm_addchan(dev, PCMDIR_REC, &tr_chantemplate, tr);
+	pcm_addchan(dev, PCMDIR_REC, &trchan_class, tr);
 	for (i = 0; i < TR_MAXPLAYCH; i++)
-		pcm_addchan(dev, PCMDIR_PLAY, &tr_chantemplate, tr);
+		pcm_addchan(dev, PCMDIR_PLAY, &trchan_class, tr);
 	pcm_setstatus(dev, status);
 
 	return 0;
diff --git a/sys/dev/sound/pci/via82c686.c b/sys/dev/sound/pci/via82c686.c
index df72136..27d7aef 100644
--- a/sys/dev/sound/pci/via82c686.c
+++ b/sys/dev/sound/pci/via82c686.c
@@ -70,25 +70,9 @@ struct via_info {
 static u_int32_t via_rd(struct via_info *via, int regno, int size);
 static void via_wr(struct via_info *, int regno, u_int32_t data, int size);
 
-int via_waitready_codec(struct via_info *via);
-int via_waitvalid_codec(struct via_info *via);
-u_int32_t via_read_codec(void *addr, int reg);
-void via_write_codec(void *addr, int reg, u_int32_t val);
-
 static void via_intr(void *);
 bus_dmamap_callback_t dma_cb;
 
-
-/* channel interface */
-static void *viachan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int viachan_setdir(void *data, int dir);
-static int viachan_setformat(void *data, u_int32_t format);
-static int viachan_setspeed(void *data, u_int32_t speed);
-static int viachan_setblocksize(void *data, u_int32_t blocksize);
-static int viachan_trigger(void *data, int go);
-static int viachan_getptr(void *data);
-static pcmchan_caps *viachan_getcaps(void *data);
-
 static u_int32_t via_playfmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -107,217 +91,6 @@ static u_int32_t via_recfmt[] = {
 };
 static pcmchan_caps via_reccaps = {4000, 48000, via_recfmt, 0};
 
-static pcm_channel via_chantemplate = {
-	viachan_init,
-	viachan_setdir,
-	viachan_setformat,
-	viachan_setspeed,
-	viachan_setblocksize,
-	viachan_trigger,
-	viachan_getptr,
-	viachan_getcaps,
-	NULL, 			/* free */
-	NULL, 			/* nop1 */
-	NULL, 			/* nop2 */
-	NULL, 			/* nop3 */
-	NULL, 			/* nop4 */
-	NULL, 			/* nop5 */
-	NULL, 			/* nop6 */
-	NULL, 			/* nop7 */
-};
-
-
-/*
- *  Probe and attach the card
- */
-static int
-via_probe(device_t dev)
-{
-	if (pci_get_devid(dev) == VIA_PCI_ID) {
-	    device_set_desc(dev, "VIA VT82C686A AC'97 Audio");
-	    return 0;
-	}
-	return ENXIO;
-}
-
-
-void dma_cb(void *p, bus_dma_segment_t *bds, int a, int b)
-{
-}
-
-
-static int
-via_attach(device_t dev)
-{
-	struct via_info *via = 0;
-	struct ac97_info *codec = 0;
-	char		status[SND_STATUSLEN];
-
-	u_int32_t	data;
-
-	u_int16_t	v;
-	bus_dmamap_t	sgd_dma_map;
-
-	if ((via = malloc(sizeof *via, M_DEVBUF, M_NOWAIT)) == NULL) {
-		device_printf(dev, "cannot allocate softc\n");
-		return ENXIO;
-	}
-	bzero(via, sizeof *via);
-
-	/* Get resources */
-	data = pci_read_config(dev, PCIR_COMMAND, 2);
-	data |= (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN);
-	pci_write_config(dev, PCIR_COMMAND, data, 2);
-	data = pci_read_config(dev, PCIR_COMMAND, 2);
-
-	pci_write_config(dev, VIA_PCICONF_MISC,
-		VIA_PCICONF_ACLINKENAB | VIA_PCICONF_ACSGD |
-		VIA_PCICONF_ACNOTRST | VIA_PCICONF_ACVSR, 1);
-
-	via->regid = PCIR_MAPS;
-	via->reg = bus_alloc_resource(dev, SYS_RES_IOPORT, &via->regid,
-		0, ~0, 1, RF_ACTIVE);
-	if (!via->reg) {
-		device_printf(dev, "via: Cannot allocate bus resource.");
-		goto bad;
-	}
-	via->st = rman_get_bustag(via->reg);
-	via->sh = rman_get_bushandle(via->reg);
-
-	via->irqid = 0;
-	via->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &via->irqid,
-		0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
-	if (!via->irq
-	    || bus_setup_intr(dev, via->irq, INTR_TYPE_TTY, via_intr, via, &via->ih)){
-		device_printf(dev, "unable to map interrupt\n");
-		goto bad;
-	}
-
-	via_wr(via, VIA_PLAY_MODE,
-		VIA_RPMODE_AUTOSTART |
-		VIA_RPMODE_INTR_FLAG | VIA_RPMODE_INTR_EOL, 1);
-	via_wr(via, VIA_RECORD_MODE,
-		VIA_RPMODE_AUTOSTART |
-		VIA_RPMODE_INTR_FLAG | VIA_RPMODE_INTR_EOL, 1);
-
-	codec = ac97_create(dev, via, NULL,
-		via_read_codec, via_write_codec);
-	if (!codec) goto bad;
-
-	mixer_init(dev, &ac97_mixer, codec);
-
-	/*
-	 *  The mixer init resets the codec.  So enabling VRA must be done
-	 *  afterwards.
-	 */
-	v = via_read_codec(via, AC97_REG_EXT_AUDIO_ID);
-	v &= (AC97_ENAB_VRA | AC97_ENAB_MICVRA);
-	via_write_codec(via, AC97_REG_EXT_AUDIO_STAT, v);
-	via->codec_caps = v;
-	{
-		v = via_read_codec(via, AC97_REG_EXT_AUDIO_STAT);
-		DEB(printf("init: codec stat: %d\n", v));
-	}
-
-	if (!(v & AC97_CODEC_DOES_VRA)) {
-		/* no VRA => can do only 48 kbps */
-		via_playcaps.minspeed = 48000;
-		via_reccaps.minspeed = 48000;
-	}
-
-	/* DMA tag for buffers */
-	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
-		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
-		/*highaddr*/BUS_SPACE_MAXADDR,
-		/*filter*/NULL, /*filterarg*/NULL,
-		/*maxsize*/VIA_BUFFSIZE, /*nsegments*/1, /*maxsegz*/0x3ffff,
-		/*flags*/0, &via->parent_dmat) != 0) {
-		device_printf(dev, "unable to create dma tag\n");
-		goto bad;
-	}
-
-	/*
-	 *  DMA tag for SGD table.  The 686 uses scatter/gather DMA and
-	 *  requires a list in memory of work to do.  We need only 16 bytes
-	 *  for this list, and it is wasteful to allocate 16K.
-	 */
-	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
-		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
-		/*highaddr*/BUS_SPACE_MAXADDR,
-		/*filter*/NULL, /*filterarg*/NULL,
-		/*maxsize*/NSEGS * sizeof(struct via_dma_op),
-		/*nsegments*/1, /*maxsegz*/0x3ffff,
-		/*flags*/0, &via->sgd_dmat) != 0) {
-		device_printf(dev, "unable to create dma tag\n");
-		goto bad;
-	}
-
-	if (bus_dmamem_alloc(via->sgd_dmat, (void **)&via->sgd_table,
-		BUS_DMA_NOWAIT, &sgd_dma_map) == -1) goto bad;
-	if (bus_dmamap_load(via->sgd_dmat, sgd_dma_map, via->sgd_table,
-		NSEGS * sizeof(struct via_dma_op), dma_cb, 0, 0)) goto bad;
-
-	snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld",
-		rman_get_start(via->reg), rman_get_start(via->irq));
-
-	/* Register */
-	if (pcm_register(dev, via, 1, 1)) goto bad;
-	pcm_addchan(dev, PCMDIR_PLAY, &via_chantemplate, via);
-	pcm_addchan(dev, PCMDIR_REC, &via_chantemplate, via);
-	pcm_setstatus(dev, status);
-	return 0;
-bad:
-	if (codec) ac97_destroy(codec);
-	if (via->reg) bus_release_resource(dev, SYS_RES_IOPORT, via->regid, via->reg);
-	if (via->ih) bus_teardown_intr(dev, via->irq, via->ih);
-	if (via->irq) bus_release_resource(dev, SYS_RES_IRQ, via->irqid, via->irq);
-	if (via->parent_dmat) bus_dma_tag_destroy(via->parent_dmat);
-	if (via->sgd_dmat) bus_dma_tag_destroy(via->sgd_dmat);
-	if (via) free(via, M_DEVBUF);
-	return ENXIO;
-}
-
-static int
-via_detach(device_t dev)
-{
-	int r;
-	struct via_info *via = 0;
-
-	r = pcm_unregister(dev);
-	if (r)
-		return r;
-
-	via = pcm_getdevinfo(dev);
-	bus_release_resource(dev, SYS_RES_IOPORT, via->regid, via->reg);
-	bus_teardown_intr(dev, via->irq, via->ih);
-	bus_release_resource(dev, SYS_RES_IRQ, via->irqid, via->irq);
-	bus_dma_tag_destroy(via->parent_dmat);
-	bus_dma_tag_destroy(via->sgd_dmat);
-	free(via, M_DEVBUF);
-	return 0;
-}
-
-
-static device_method_t via_methods[] = {
-	DEVMETHOD(device_probe,		via_probe),
-	DEVMETHOD(device_attach,	via_attach),
-	DEVMETHOD(device_detach,	via_detach),
-	{ 0, 0}
-};
-
-static driver_t via_driver = {
-	"pcm",
-	via_methods,
-	sizeof(snddev_info),
-};
-
-static devclass_t pcm_devclass;
-
-DRIVER_MODULE(via, pci, via_driver, pcm_devclass, 0, 0);
-MODULE_DEPEND(via, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
-MODULE_VERSION(via, 1);
-
-
 static u_int32_t
 via_rd(struct via_info *via, int regno, int size)
 {
@@ -352,9 +125,10 @@ via_wr(struct via_info *via, int regno, u_int32_t data, int size)
 	}
 }
 
-
+/* -------------------------------------------------------------------- */
 /* Codec interface */
-int
+
+static int
 via_waitready_codec(struct via_info *via)
 {
 	int i;
@@ -372,7 +146,7 @@ via_waitready_codec(struct via_info *via)
 }
 
 
-int
+static int
 via_waitvalid_codec(struct via_info *via)
 {
 	int i;
@@ -390,20 +164,22 @@ via_waitvalid_codec(struct via_info *via)
 }
 
 
-void
-via_write_codec(void *addr, int reg, u_int32_t val)
+static int
+via_write_codec(kobj_t obj, void *addr, int reg, u_int32_t val)
 {
 	struct via_info *via = addr;
 
-	if (via_waitready_codec(via)) return;
+	if (via_waitready_codec(via)) return -1;
 
 	via_wr(via, VIA_CODEC_CTL,
 		VIA_CODEC_PRIVALID | VIA_CODEC_INDEX(reg) | val, 4);
+
+	return 0;
 }
 
 
-u_int32_t
-via_read_codec(void *addr, int reg)
+static int
+via_read_codec(kobj_t obj, void *addr, int reg)
 {
 	struct via_info *via = addr;
 
@@ -422,10 +198,18 @@ via_read_codec(void *addr, int reg)
 	return via_rd(via, VIA_CODEC_CTL, 2);
 }
 
+static kobj_method_t via_ac97_methods[] = {
+    	KOBJMETHOD(ac97_read,		via_read_codec),
+    	KOBJMETHOD(ac97_write,		via_write_codec),
+	{ 0, 0 }
+};
+AC97_DECLARE(via_ac97);
+
+/* -------------------------------------------------------------------- */
 
 /* channel interface */
 static void *
-viachan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+viachan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	struct via_info *via = devinfo;
 	struct via_chinfo *ch = (dir == PCMDIR_PLAY) ? &via->pch : &via->rch;
@@ -440,7 +224,7 @@ viachan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-viachan_setdir(void *data, int dir)
+viachan_setdir(kobj_t obj, void *data, int dir)
 {
 	struct via_chinfo *ch = data;
 	struct via_info *via = ch->parent;
@@ -477,7 +261,7 @@ DEB(printf("ado->ptr/flags = %x/%x\n", phys_addr, flag));
 }
 
 static int
-viachan_setformat(void *data, u_int32_t format)
+viachan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	struct via_chinfo *ch = data;
 	struct via_info *via = ch->parent;
@@ -509,7 +293,7 @@ DEB(printf("set record format: %x\n", format));
 }
 
 static int
-viachan_setspeed(void *data, u_int32_t speed)
+viachan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	struct via_chinfo *ch = data;
 	struct via_info *via = ch->parent;
@@ -526,8 +310,8 @@ viachan_setspeed(void *data, u_int32_t speed)
 	if (ch->dir == PCMDIR_PLAY) {
 DEB(printf("requested play speed: %d\n", speed));
 		if (via->codec_caps & AC97_CODEC_DOES_VRA) {
-			via_write_codec(via, AC97_REG_EXT_DAC_RATE, speed);
-			speed = via_read_codec(via, AC97_REG_EXT_DAC_RATE);
+			via_write_codec(NULL, via, AC97_REG_EXT_DAC_RATE, speed);
+			speed = via_read_codec(NULL, via, AC97_REG_EXT_DAC_RATE);
 		}
 		else {
 DEB(printf("VRA not supported!\n"));
@@ -538,8 +322,8 @@ DEB(printf("obtained play speed: %d\n", speed));
 	else {
 DEB(printf("requested record speed: %d\n", speed));
 		if (via->codec_caps & AC97_CODEC_DOES_VRA) {
-			via_write_codec(via, AC97_REG_EXT_ADC_RATE, speed);
-			speed = via_read_codec(via, AC97_REG_EXT_ADC_RATE);
+			via_write_codec(NULL, via, AC97_REG_EXT_ADC_RATE, speed);
+			speed = via_read_codec(NULL, via, AC97_REG_EXT_ADC_RATE);
 		}
 		else {
 DEB(printf("VRA not supported!\n"));
@@ -551,7 +335,7 @@ DEB(printf("obtained record speed: %d\n", speed));
 }
 
 static int
-viachan_setblocksize(void *data, u_int32_t blocksize)
+viachan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	struct via_chinfo *ch = data;
 
@@ -559,7 +343,7 @@ viachan_setblocksize(void *data, u_int32_t blocksize)
 }
 
 static int
-viachan_trigger(void *data, int go)
+viachan_trigger(kobj_t obj, void *data, int go)
 {
 	struct via_chinfo *ch = data;
 	struct via_info *via = ch->parent;
@@ -600,7 +384,7 @@ DEB(printf("viachan_trigger: go=%d\n", go));
 }
 
 static int
-viachan_getptr(void *data)
+viachan_getptr(kobj_t obj, void *data)
 {
 	struct via_chinfo *ch = data;
 	struct via_info *via = ch->parent;
@@ -658,12 +442,27 @@ DEB(printf("return ptr=%d\n", ptr));
 }
 
 static pcmchan_caps *
-viachan_getcaps(void *data)
+viachan_getcaps(kobj_t obj, void *data)
 {
 	struct via_chinfo *ch = data;
 	return (ch->dir == PCMDIR_PLAY) ? &via_playcaps : &via_reccaps;
 }
 
+static kobj_method_t viachan_methods[] = {
+    	KOBJMETHOD(channel_init,		viachan_init),
+    	KOBJMETHOD(channel_setdir,		viachan_setdir),
+    	KOBJMETHOD(channel_setformat,		viachan_setformat),
+    	KOBJMETHOD(channel_setspeed,		viachan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	viachan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		viachan_trigger),
+    	KOBJMETHOD(channel_getptr,		viachan_getptr),
+    	KOBJMETHOD(channel_getcaps,		viachan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(viachan);
+
+/* -------------------------------------------------------------------- */
+
 static void
 via_intr(void *p)
 {
@@ -686,4 +485,193 @@ DEB(printf("viachan_intr\n"));
 	}
 }
 
+/*
+ *  Probe and attach the card
+ */
+static int
+via_probe(device_t dev)
+{
+	if (pci_get_devid(dev) == VIA_PCI_ID) {
+	    device_set_desc(dev, "VIA VT82C686A AC'97 Audio");
+	    return 0;
+	}
+	return ENXIO;
+}
+
+
+void dma_cb(void *p, bus_dma_segment_t *bds, int a, int b)
+{
+}
+
+
+static int
+via_attach(device_t dev)
+{
+	struct via_info *via = 0;
+	struct ac97_info *codec = 0;
+	char		status[SND_STATUSLEN];
+
+	u_int32_t	data;
+
+	u_int16_t	v;
+	bus_dmamap_t	sgd_dma_map;
+
+	if ((via = malloc(sizeof *via, M_DEVBUF, M_NOWAIT)) == NULL) {
+		device_printf(dev, "cannot allocate softc\n");
+		return ENXIO;
+	}
+	bzero(via, sizeof *via);
+
+	/* Get resources */
+	data = pci_read_config(dev, PCIR_COMMAND, 2);
+	data |= (PCIM_CMD_PORTEN | PCIM_CMD_BUSMASTEREN);
+	pci_write_config(dev, PCIR_COMMAND, data, 2);
+	data = pci_read_config(dev, PCIR_COMMAND, 2);
+
+	pci_write_config(dev, VIA_PCICONF_MISC,
+		VIA_PCICONF_ACLINKENAB | VIA_PCICONF_ACSGD |
+		VIA_PCICONF_ACNOTRST | VIA_PCICONF_ACVSR, 1);
+
+	via->regid = PCIR_MAPS;
+	via->reg = bus_alloc_resource(dev, SYS_RES_IOPORT, &via->regid,
+		0, ~0, 1, RF_ACTIVE);
+	if (!via->reg) {
+		device_printf(dev, "via: Cannot allocate bus resource.");
+		goto bad;
+	}
+	via->st = rman_get_bustag(via->reg);
+	via->sh = rman_get_bushandle(via->reg);
+
+	via->irqid = 0;
+	via->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &via->irqid,
+		0, ~0, 1, RF_ACTIVE | RF_SHAREABLE);
+	if (!via->irq
+	    || bus_setup_intr(dev, via->irq, INTR_TYPE_TTY, via_intr, via, &via->ih)){
+		device_printf(dev, "unable to map interrupt\n");
+		goto bad;
+	}
+
+	via_wr(via, VIA_PLAY_MODE,
+		VIA_RPMODE_AUTOSTART |
+		VIA_RPMODE_INTR_FLAG | VIA_RPMODE_INTR_EOL, 1);
+	via_wr(via, VIA_RECORD_MODE,
+		VIA_RPMODE_AUTOSTART |
+		VIA_RPMODE_INTR_FLAG | VIA_RPMODE_INTR_EOL, 1);
+
+	codec = AC97_CREATE(dev, via, via_ac97);
+	if (!codec) goto bad;
+
+	mixer_init(dev, ac97_getmixerclass(), codec);
+
+	/*
+	 *  The mixer init resets the codec.  So enabling VRA must be done
+	 *  afterwards.
+	 */
+	v = via_read_codec(NULL, via, AC97_REG_EXT_AUDIO_ID);
+	v &= (AC97_ENAB_VRA | AC97_ENAB_MICVRA);
+	via_write_codec(NULL, via, AC97_REG_EXT_AUDIO_STAT, v);
+	via->codec_caps = v;
+	{
+		v = via_read_codec(NULL, via, AC97_REG_EXT_AUDIO_STAT);
+		DEB(printf("init: codec stat: %d\n", v));
+	}
+
+	if (!(v & AC97_CODEC_DOES_VRA)) {
+		/* no VRA => can do only 48 kbps */
+		via_playcaps.minspeed = 48000;
+		via_reccaps.minspeed = 48000;
+	}
+
+	/* DMA tag for buffers */
+	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
+		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
+		/*highaddr*/BUS_SPACE_MAXADDR,
+		/*filter*/NULL, /*filterarg*/NULL,
+		/*maxsize*/VIA_BUFFSIZE, /*nsegments*/1, /*maxsegz*/0x3ffff,
+		/*flags*/0, &via->parent_dmat) != 0) {
+		device_printf(dev, "unable to create dma tag\n");
+		goto bad;
+	}
+
+	/*
+	 *  DMA tag for SGD table.  The 686 uses scatter/gather DMA and
+	 *  requires a list in memory of work to do.  We need only 16 bytes
+	 *  for this list, and it is wasteful to allocate 16K.
+	 */
+	if (bus_dma_tag_create(/*parent*/NULL, /*alignment*/2, /*boundary*/0,
+		/*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
+		/*highaddr*/BUS_SPACE_MAXADDR,
+		/*filter*/NULL, /*filterarg*/NULL,
+		/*maxsize*/NSEGS * sizeof(struct via_dma_op),
+		/*nsegments*/1, /*maxsegz*/0x3ffff,
+		/*flags*/0, &via->sgd_dmat) != 0) {
+		device_printf(dev, "unable to create dma tag\n");
+		goto bad;
+	}
+
+	if (bus_dmamem_alloc(via->sgd_dmat, (void **)&via->sgd_table,
+		BUS_DMA_NOWAIT, &sgd_dma_map) == -1) goto bad;
+	if (bus_dmamap_load(via->sgd_dmat, sgd_dma_map, via->sgd_table,
+		NSEGS * sizeof(struct via_dma_op), dma_cb, 0, 0)) goto bad;
+
+	snprintf(status, SND_STATUSLEN, "at io 0x%lx irq %ld",
+		rman_get_start(via->reg), rman_get_start(via->irq));
+
+	/* Register */
+	if (pcm_register(dev, via, 1, 1)) goto bad;
+	pcm_addchan(dev, PCMDIR_PLAY, &viachan_class, via);
+	pcm_addchan(dev, PCMDIR_REC, &viachan_class, via);
+	pcm_setstatus(dev, status);
+	return 0;
+bad:
+	if (codec) ac97_destroy(codec);
+	if (via->reg) bus_release_resource(dev, SYS_RES_IOPORT, via->regid, via->reg);
+	if (via->ih) bus_teardown_intr(dev, via->irq, via->ih);
+	if (via->irq) bus_release_resource(dev, SYS_RES_IRQ, via->irqid, via->irq);
+	if (via->parent_dmat) bus_dma_tag_destroy(via->parent_dmat);
+	if (via->sgd_dmat) bus_dma_tag_destroy(via->sgd_dmat);
+	if (via) free(via, M_DEVBUF);
+	return ENXIO;
+}
+
+static int
+via_detach(device_t dev)
+{
+	int r;
+	struct via_info *via = 0;
+
+	r = pcm_unregister(dev);
+	if (r)
+		return r;
+
+	via = pcm_getdevinfo(dev);
+	bus_release_resource(dev, SYS_RES_IOPORT, via->regid, via->reg);
+	bus_teardown_intr(dev, via->irq, via->ih);
+	bus_release_resource(dev, SYS_RES_IRQ, via->irqid, via->irq);
+	bus_dma_tag_destroy(via->parent_dmat);
+	bus_dma_tag_destroy(via->sgd_dmat);
+	free(via, M_DEVBUF);
+	return 0;
+}
+
+
+static device_method_t via_methods[] = {
+	DEVMETHOD(device_probe,		via_probe),
+	DEVMETHOD(device_attach,	via_attach),
+	DEVMETHOD(device_detach,	via_detach),
+	{ 0, 0}
+};
+
+static driver_t via_driver = {
+	"pcm",
+	via_methods,
+	sizeof(snddev_info),
+};
+
+static devclass_t pcm_devclass;
+
+DRIVER_MODULE(via, pci, via_driver, pcm_devclass, 0, 0);
+MODULE_DEPEND(via, snd_pcm, PCM_MINVER, PCM_PREFVER, PCM_MAXVER);
+MODULE_VERSION(via, 1);
+
 
diff --git a/sys/dev/sound/pcm/ac97.c b/sys/dev/sound/pcm/ac97.c
index 3a8bf36..a4020e8 100644
--- a/sys/dev/sound/pcm/ac97.c
+++ b/sys/dev/sound/pcm/ac97.c
@@ -29,28 +29,9 @@
 #include <dev/sound/pcm/sound.h>
 #include <dev/sound/pcm/ac97.h>
 
-struct ac97mixtable_entry {
-	int		reg:8;
-	unsigned	bits:4;
-	unsigned	ofs:4;
-	unsigned	stereo:1;
-	unsigned	mute:1;
-	unsigned	recidx:4;
-	unsigned        mask:1;
-	unsigned	enable:1;
-};
+#include "mixer_if.h"
 
-struct ac97_info {
-	device_t dev;
-	ac97_init *init;
-	ac97_read *read;
-	ac97_write *write;
-	void *devinfo;
-	char *name;
-	char rev;
-	unsigned count, caps, se, extcaps, extid, extstat, noext:1;
-	struct ac97mixtable_entry mix[32];
-};
+MALLOC_DEFINE(M_AC97, "ac97", "ac97 codec");
 
 struct ac97_codecid {
 	u_int32_t id, noext:1;
@@ -154,13 +135,13 @@ static char *ac97extfeature[] = {
 static u_int16_t
 rdcd(struct ac97_info *codec, int reg)
 {
-	return codec->read(codec->devinfo, reg);
+	return AC97_READ(codec->methods, codec->devinfo, reg);
 }
 
 static void
 wrcd(struct ac97_info *codec, int reg, u_int16_t val)
 {
-	codec->write(codec->devinfo, reg, val);
+	AC97_WRITE(codec->methods, codec->devinfo, reg, val);
 }
 
 int
@@ -309,14 +290,11 @@ ac97_initmixer(struct ac97_info *codec)
 	for (i = 0; i < 32; i++)
 		codec->mix[i] = ac97mixtable_default[i];
 
-	if (codec->init) {
-		codec->count = codec->init(codec->devinfo);
-		if (codec->count == 0) {
-			device_printf(codec->dev, "ac97 codec init failed\n");
-			return ENODEV;
-		}
-	} else
-		codec->count = 1;
+	codec->count = AC97_INIT(codec->methods, codec->devinfo);
+	if (codec->count == 0) {
+		device_printf(codec->dev, "ac97 codec init failed\n");
+		return ENODEV;
+	}
 
 	wrcd(codec, AC97_REG_POWER, 0);
 	wrcd(codec, AC97_REG_RESET, 0);
@@ -401,14 +379,11 @@ ac97_reinitmixer(struct ac97_info *codec)
 {
 	unsigned i;
 
-	if (codec->init) {
-		codec->count = codec->init(codec->devinfo);
-		if (codec->count == 0) {
-			device_printf(codec->dev, "ac97 codec init failed\n");
-			return ENODEV;
-		}
-	} else
-		codec->count = 1;
+	codec->count = AC97_INIT(codec->methods, codec->devinfo);
+	if (codec->count == 0) {
+		device_printf(codec->dev, "ac97 codec init failed\n");
+		return ENODEV;
+	}
 
 	wrcd(codec, AC97_REG_POWER, 0);
 	wrcd(codec, AC97_REG_RESET, 0);
@@ -428,27 +403,35 @@ ac97_reinitmixer(struct ac97_info *codec)
 }
 
 struct ac97_info *
-ac97_create(device_t dev, void *devinfo, ac97_init *init, ac97_read *rd, ac97_write *wr)
+ac97_create(device_t dev, void *devinfo, kobj_class_t cls)
 {
 	struct ac97_info *codec;
 
-	codec = (struct ac97_info *)malloc(sizeof *codec, M_DEVBUF, M_NOWAIT);
-	if (codec != NULL) {
-		codec->dev = dev;
-		codec->init = init;
-		codec->read = rd;
-		codec->write = wr;
-		codec->devinfo = devinfo;
+	codec = (struct ac97_info *)malloc(sizeof *codec, M_AC97, M_NOWAIT);
+	if (codec == NULL)
+		return NULL;
+
+	codec->methods = kobj_create(cls, M_AC97, M_WAITOK);
+	if (codec->methods == NULL) {
+		free(codec, M_AC97);
+		return NULL;
 	}
+
+	codec->dev = dev;
+	codec->devinfo = devinfo;
 	return codec;
 }
 
 void
 ac97_destroy(struct ac97_info *codec)
 {
-	free(codec, M_DEVBUF);
+	if (codec->methods != NULL)
+		kobj_delete(codec->methods, M_AC97);
+	free(codec, M_AC97);
 }
 
+/* -------------------------------------------------------------------- */
+
 static int
 ac97mix_init(snd_mixer *m)
 {
@@ -522,12 +505,22 @@ ac97mix_setrecsrc(snd_mixer *m, u_int32_t src)
 	return (ac97_setrecsrc(codec, i) == 0)? 1 << i : -1;
 }
 
-snd_mixer ac97_mixer = {
-	"AC97 mixer",
-	ac97mix_init,
-	ac97mix_uninit,
-	ac97mix_reinit,
-	ac97mix_set,
-	ac97mix_setrecsrc,
+static kobj_method_t ac97mixer_methods[] = {
+    	KOBJMETHOD(mixer_init,		ac97mix_init),
+    	KOBJMETHOD(mixer_uninit,	ac97mix_uninit),
+    	KOBJMETHOD(mixer_reinit,	ac97mix_reinit),
+    	KOBJMETHOD(mixer_set,		ac97mix_set),
+    	KOBJMETHOD(mixer_setrecsrc,	ac97mix_setrecsrc),
+	{ 0, 0 }
 };
+MIXER_DECLARE(ac97mixer);
+
+/* -------------------------------------------------------------------- */
+
+kobj_class_t
+ac97_getmixerclass(void)
+{
+	return &ac97mixer_class;
+}
+
 
diff --git a/sys/dev/sound/pcm/ac97.h b/sys/dev/sound/pcm/ac97.h
index 1305424..6f36761 100644
--- a/sys/dev/sound/pcm/ac97.h
+++ b/sys/dev/sound/pcm/ac97.h
@@ -63,15 +63,35 @@
 #define AC97_REG_ID1	0x7c
 #define AC97_REG_ID2	0x7e
 
-typedef u_int32_t (ac97_init)(void *devinfo);
-typedef u_int32_t (ac97_read)(void *devinfo, int regno);
-typedef void (ac97_write)(void *devinfo, int regno, u_int32_t data);
+struct ac97mixtable_entry {
+	int		reg:8;
+	unsigned	bits:4;
+	unsigned	ofs:4;
+	unsigned	stereo:1;
+	unsigned	mute:1;
+	unsigned	recidx:4;
+	unsigned        mask:1;
+	unsigned	enable:1;
+};
 
-extern snd_mixer ac97_mixer;
-struct ac97_info;
+#define AC97_DECLARE(name) static DEFINE_CLASS(name, name ## _methods, sizeof(struct kobj))
+#define AC97_CREATE(dev, devinfo, cls) ac97_create(dev, devinfo, &cls ## _class)
 
-struct ac97_info *ac97_create(device_t dev, void *devinfo, ac97_init *init,
-			      ac97_read *rd, ac97_write *wr);
+struct ac97_info {
+	kobj_t methods;
+	device_t dev;
+	void *devinfo;
+	char *name;
+	char rev;
+	unsigned count, caps, se, extcaps, extid, extstat, noext:1;
+	struct ac97mixtable_entry mix[32];
+};
+
+#include "ac97_if.h"
+
+extern kobj_class_t ac97_getmixerclass(void);
+
+struct ac97_info *ac97_create(device_t dev, void *devinfo, kobj_class_t cls);
 void ac97_destroy(struct ac97_info *codec);
 int ac97_setrate(struct ac97_info *codec, int which, int rate);
 int ac97_setextmode(struct ac97_info *codec, u_int16_t mode);
diff --git a/sys/dev/sound/pcm/ac97_if.m b/sys/dev/sound/pcm/ac97_if.m
new file mode 100644
index 0000000..d71f3d1
--- /dev/null
+++ b/sys/dev/sound/pcm/ac97_if.m
@@ -0,0 +1,60 @@
+#

+# Copyright (c) 2000 Cameron Grant <cg@freebsd.org>

+# All rights reserved.

+#

+# 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

+#    notice, this list of conditions and the following disclaimer.

+# 2. Redistributions in binary form must reproduce the above copyright

+#    notice, this list of conditions and the following disclaimer in the

+#    documentation and/or other materials provided with the distribution.

+#

+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

+# 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.

+#

+# $FreeBSD$

+#

+

+#include <dev/sound/pcm/sound.h>

+

+INTERFACE ac97;

+

+CODE {

+

+	static u_int32_t

+	ac97_noinit(kobj_t obj, void *devinfo)

+	{

+		return 1;

+	}

+

+};

+

+METHOD u_int32_t init {

+	kobj_t obj;

+	void *devinfo;

+} DEFAULT ac97_noinit;

+

+METHOD int read {

+	kobj_t obj;

+	void *devinfo;

+	int regno;

+};

+

+METHOD int write {

+	kobj_t obj;

+	void *devinfo;

+	int regno;

+	u_int32_t data;

+};

+

diff --git a/sys/dev/sound/pcm/channel.c b/sys/dev/sound/pcm/channel.c
index 4e37da4..4030028 100644
--- a/sys/dev/sound/pcm/channel.c
+++ b/sys/dev/sound/pcm/channel.c
@@ -29,6 +29,9 @@
 
 #include <dev/sound/pcm/sound.h>
 
+#include "feeder_if.h"
+
+MALLOC_DEFINE(M_CHANNEL, "channel", "pcm channel");
 #define MIN_CHUNK_SIZE 		256	/* for uiomove etc. */
 #define	DMA_ALIGN_THRESHOLD	4
 #define	DMA_ALIGN_MASK		(~(DMA_ALIGN_THRESHOLD - 1))
@@ -326,13 +329,13 @@ chn_wrfeed2nd(pcm_channel *c, struct uio *buf)
 		l = min(bs->fl, bs->bufsize - bs->fp);
 		/* Move the samples, update the markers and pointers. */
 		if (l < 64) {
-			w = c->feeder->feed(c->feeder, c, hackbuf, 64, buf);
+			w = FEEDER_FEED(c->feeder, c, hackbuf, 64, buf);
 			l = min(w, bs->bufsize - bs->fp);
 			bcopy(hackbuf, bs->buf + bs->fp, l);
 			if (w > l)
 				bcopy(hackbuf + l, bs->buf, w - l);
 		} else
-			w = c->feeder->feed(c->feeder, c, bs->buf + bs->fp, l, buf);
+			w = FEEDER_FEED(c->feeder, c, bs->buf + bs->fp, l, buf);
 		if (w == 0)
 			panic("no feed");
 		bs->rl += w;
@@ -639,7 +642,7 @@ chn_rdfeed2nd(pcm_channel *c, struct uio *buf)
 		 */
 		l = min(bs->rl, bs->bufsize - bs->rp);
 		/* Move the samples, update the markers and pointers. */
-		w = c->feeder->feed(c->feeder, c, bs->buf + bs->rp, l, buf);
+		w = FEEDER_FEED(c->feeder, c, bs->buf + bs->rp, l, buf);
 		if (w == 0)
 			panic("no feed");
 		bs->fl += w;
@@ -1128,8 +1131,7 @@ chn_reset(pcm_channel *c, u_int32_t fmt)
 
 	chn_abort(c);
 	c->flags &= CHN_F_RESET;
-	if (c->reset)
-		c->reset(c->devinfo);
+	CHANNEL_RESET(c->methods, c->devinfo);
 	r = chn_setblocksize(c, CHN_2NDBUFBLKNUM, CHN_2NDBUFBLKSIZE);
 	if (r)
 		return r;
@@ -1145,8 +1147,7 @@ chn_reset(pcm_channel *c, u_int32_t fmt)
 			r = chn_setvolume(c, 100, 100);
 	}
 	chn_resetbuf(c);
-	if (c->resetdone)
-		c->resetdone(c->devinfo);
+	CHANNEL_RESETDONE(c->methods, c->devinfo);
 	/* c->flags |= CHN_F_INIT; */
 	return 0;
 }
@@ -1167,26 +1168,25 @@ chn_reinit(pcm_channel *c)
 int
 chn_init(pcm_channel *c, void *devinfo, int dir)
 {
-	snd_dbuf       *bs = &c->buffer2nd;
+	struct feeder_class *fc;
+	snd_dbuf *bs = &c->buffer2nd;
 
 	/* Initialize the hardware and DMA buffer first. */
-	c->feeder = malloc(sizeof(*(c->feeder)), M_DEVBUF, M_NOWAIT);
-	*(c->feeder) = *feeder_getroot();
-	c->feederdesc = malloc(sizeof(*(c->feeder)), M_DEVBUF, M_NOWAIT);
-	c->feederdesc->type = FEEDER_ROOT;
-	c->feederdesc->in = 0;
-	c->feederdesc->out = 0;
-	c->feederdesc->flags = 0;
-	c->feederdesc->idx = 0;
-	c->feeder->desc = c->feederdesc;
-	c->feeder->source = NULL;
+	c->feeder = NULL;
+	fc = feeder_getclass(NULL);
+	if (fc == NULL)
+		return EINVAL;
+	if (chn_addfeeder(c, fc, NULL))
+		return EINVAL;
 
 	c->flags = 0;
 	c->feederflags = 0;
 	c->buffer.chan = -1;
-	c->devinfo = c->init(devinfo, &c->buffer, c, dir);
-	if (c->devinfo == NULL || c->buffer.bufsize == 0)
-		return 1;
+	c->devinfo = CHANNEL_INIT(c->methods, devinfo, &c->buffer, c, dir);
+	if (c->devinfo == NULL)
+		return ENODEV;
+	if (c->buffer.bufsize == 0)
+		return ENOMEM;
 	chn_setdir(c, dir);
 
 	/* And the secondary buffer. */
@@ -1201,11 +1201,7 @@ chn_kill(pcm_channel *c)
 	if (c->flags & CHN_F_TRIGGERED)
 		chn_trigger(c, PCMTRIG_ABORT);
 	while (chn_removefeeder(c) == 0);
-	free(c->feeder->desc, M_DEVBUF);
-	free(c->feeder, M_DEVBUF);
-	if (c->free)
-		c->free(c->devinfo);
-	else
+	if (CHANNEL_FREE(c->methods, c->devinfo))
 		chn_freebuf(&c->buffer);
 	c->flags |= CHN_F_DEAD;
 	return 0;
@@ -1217,7 +1213,7 @@ chn_setdir(pcm_channel *c, int dir)
 	int r;
 
 	c->direction = dir;
-	r = c->setdir? c->setdir(c->devinfo, c->direction) : 0;
+	r = CHANNEL_SETDIR(c->methods, c->devinfo, c->direction);
 	if (!r && ISA_DMA(&c->buffer))
 		c->buffer.dir = (dir == PCMDIR_PLAY)? ISADMA_WRITE : ISADMA_READ;
 	return r;
@@ -1250,7 +1246,7 @@ chn_setspeed(pcm_channel *c, int speed)
 		hwspd = speed;
 		RANGE(hwspd, chn_getcaps(c)->minspeed, chn_getcaps(c)->maxspeed);
 		DEB(printf("try speed %d, ", hwspd));
-		hwspd = c->setspeed(c->devinfo, hwspd);
+		hwspd = CHANNEL_SETSPEED(c->methods, c->devinfo, hwspd);
 		DEB(printf("got speed %d, ", hwspd));
 		delta = hwspd - speed;
 		if (delta < 0)
@@ -1270,11 +1266,11 @@ chn_setspeed(pcm_channel *c, int speed)
 		DEB(printf("feedrate = %p\n", f));
 		if (f == NULL)
 			return EINVAL;
-		r = feeder_set(f, FEEDRATE_SRC, speed);
+		r = FEEDER_SET(f, FEEDRATE_SRC, speed);
 		DEB(printf("feeder_set(FEEDRATE_SRC, %d) = %d\n", speed, r));
 		if (r)
 			return r;
-		r = feeder_set(f, FEEDRATE_DST, hwspd);
+		r = FEEDER_SET(f, FEEDRATE_DST, hwspd);
 		DEB(printf("feeder_set(FEEDRATE_DST, %d) = %d\n", hwspd, r));
 		if (r)
 			return r;
@@ -1296,7 +1292,6 @@ chn_setformat(pcm_channel *c, u_int32_t fmt)
 	if (CANCHANGE(c)) {
 		DEB(printf("want format %d\n", fmt));
 		c->format = fmt;
-		c->feederdesc->out = c->format;
 		hwfmt = c->format;
 		c->feederflags &= ~(1 << FEEDER_FMT);
 		if (!fmtvalid(hwfmt, chn_getcaps(c)->fmtlist))
@@ -1308,7 +1303,7 @@ chn_setformat(pcm_channel *c, u_int32_t fmt)
 		b->fmt = hwfmt;
 		bs->fmt = hwfmt;
 		chn_resetbuf(c);
-		c->setformat(c->devinfo, hwfmt);
+		CHANNEL_SETFORMAT(c->methods, c->devinfo, hwfmt);
 		return chn_setspeed(c, c->speed);
 	}
 	c->format = fmt;
@@ -1368,7 +1363,7 @@ chn_setblocksize(pcm_channel *c, int blkcnt, int blksz)
 	bs->blkcnt = blkcnt;
 	bs->blksz = blksz;
 	RANGE(blksz, 16, b->bufsize / 2);
-	b->blksz = c->setblocksize(c->devinfo, blksz);
+	b->blksz = CHANNEL_SETBLOCKSIZE(c->methods, c->devinfo, blksz);
 	splx(s);
 
 	return 0;
@@ -1377,7 +1372,7 @@ chn_setblocksize(pcm_channel *c, int blkcnt, int blksz)
 int
 chn_trigger(pcm_channel *c, int go)
 {
-	return c->trigger(c->devinfo, go);
+	return CHANNEL_TRIGGER(c->methods, c->devinfo, go);
 }
 
 int
@@ -1387,7 +1382,7 @@ chn_getptr(pcm_channel *c)
 	int a = (1 << c->align) - 1;
 	snd_dbuf *b = &c->buffer;
 
-	hwptr = b->dl? c->getptr(c->devinfo) : 0;
+	hwptr = b->dl? CHANNEL_GETPTR(c->methods, c->devinfo) : 0;
 	/* don't allow unaligned values in the hwa ptr */
 	hwptr &= ~a ; /* Apply channel align mask */
 	hwptr &= DMA_ALIGN_MASK; /* Apply DMA align mask */
@@ -1397,7 +1392,7 @@ chn_getptr(pcm_channel *c)
 pcmchan_caps *
 chn_getcaps(pcm_channel *c)
 {
-	return c->getcaps(c->devinfo);
+	return CHANNEL_GETCAPS(c->methods, c->devinfo);
 }
 
 u_int32_t
@@ -1417,12 +1412,20 @@ chn_getformats(pcm_channel *c)
 static int
 chn_buildfeeder(pcm_channel *c)
 {
-	pcm_feeder *f;
+	struct feeder_class *fc;
 	struct pcm_feederdesc desc;
 	u_int32_t tmp[2], src, dst, type, flags;
 
 	while (chn_removefeeder(c) == 0);
+	KASSERT((c->feeder == NULL), ("feeder chain not empty"));
 	c->align = 0;
+	fc = feeder_getclass(NULL);
+	if (fc == NULL)
+		return EINVAL;
+	if (chn_addfeeder(c, fc, NULL))
+		return EINVAL;
+	c->feeder->desc->out = c->format;
+
 	flags = c->feederflags;
 	src = c->feeder->desc->out;
 	if ((c->flags & CHN_F_MAPPED) && (flags != 0))
@@ -1435,11 +1438,11 @@ chn_buildfeeder(pcm_channel *c)
 			desc.out = 0;
 			desc.flags = 0;
 			DEB(printf("find feeder type %d, ", type));
-			f = feeder_get(&desc);
+			fc = feeder_getclass(&desc);
 			DEB(printf("got %p\n", f));
-			if (f == NULL)
+			if (fc == NULL)
 				return EINVAL;
-			dst = f->desc->in;
+			dst = fc->desc->in;
 			if (src != dst) {
  				DEB(printf("build fmtchain from %x to %x: ", src, dst));
 				tmp[0] = dst;
@@ -1448,9 +1451,9 @@ chn_buildfeeder(pcm_channel *c)
 					return EINVAL;
  				DEB(printf("ok\n"));
 			}
-			if (chn_addfeeder(c, f))
+			if (chn_addfeeder(c, fc, fc->desc))
 				return EINVAL;
-			src = f->desc->out;
+			src = fc->desc->out;
 			DEB(printf("added feeder %p, output %x\n", f, src));
 			dst = 0;
 			flags &= ~(1 << type);
diff --git a/sys/dev/sound/pcm/channel.h b/sys/dev/sound/pcm/channel.h
index fa1173b..243c207 100644
--- a/sys/dev/sound/pcm/channel.h
+++ b/sys/dev/sound/pcm/channel.h
@@ -26,6 +26,8 @@
  * $FreeBSD$
  */
 
+#include "channel_if.h"
+
 int chn_reinit(pcm_channel *c);
 int chn_write(pcm_channel *c, struct uio *buf);
 int chn_read(pcm_channel *c, struct uio *buf);
@@ -85,7 +87,7 @@ int buf_isadmaptr(snd_dbuf *b);
 #define CHN_F_INIT              0x00008000  /* changed parameters. need init */
 #define CHN_F_MAPPED		0x00010000  /* has been mmap()ed */
 #define CHN_F_DEAD		0x00020000
-
+#define CHN_F_BADSETTING	0x00040000
 
 #define CHN_F_RESET		(CHN_F_BUSY | CHN_F_DEAD)
 
@@ -99,3 +101,5 @@ int buf_isadmaptr(snd_dbuf *b);
 #define CHN_2NDBUFBLKNUM	(32)
 /* The size of a whole secondary buffer. */
 #define CHN_2NDBUFMAXSIZE	(131072)
+
+#define CHANNEL_DECLARE(name) static DEFINE_CLASS(name, name ## _methods, sizeof(struct kobj))
diff --git a/sys/dev/sound/pcm/channel_if.m b/sys/dev/sound/pcm/channel_if.m
new file mode 100644
index 0000000..96a60f1
--- /dev/null
+++ b/sys/dev/sound/pcm/channel_if.m
@@ -0,0 +1,123 @@
+#
+# Copyright (c) 2000 Cameron Grant <cg@freebsd.org>
+# All rights reserved.
+#
+# 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
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# 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.
+#
+# $FreeBSD$
+#
+
+#include <dev/sound/pcm/sound.h>
+
+INTERFACE channel;
+
+CODE {
+
+	static int
+	channel_nosetdir(kobj_t obj, void *data, int dir)
+	{
+		return 0;
+	}
+
+	static int
+	channel_noreset(kobj_t obj, void *data)
+	{
+		return 0;
+	}
+
+	static int
+	channel_noresetdone(kobj_t obj, void *data)
+	{
+		return 0;
+	}
+
+	static int
+	channel_nofree(kobj_t obj, void *data)
+	{
+		return 1;
+	}
+
+};
+
+METHOD void* init {
+	kobj_t obj;
+	void *devinfo;
+	snd_dbuf *b;
+	pcm_channel *c;
+	int dir;
+};
+
+METHOD int free {
+	kobj_t obj;
+	void *data;
+} DEFAULT channel_nofree;
+
+METHOD int reset {
+	kobj_t obj;
+	void *data;
+} DEFAULT channel_noreset;
+
+METHOD int resetdone {
+	kobj_t obj;
+	void *data;
+} DEFAULT channel_noresetdone;
+
+METHOD int setdir {
+	kobj_t obj;
+	void *data;
+	int dir;
+} DEFAULT channel_nosetdir;
+
+METHOD u_int32_t setformat {
+	kobj_t obj;
+	void *data;
+	u_int32_t format;
+};
+
+METHOD u_int32_t setspeed {
+	kobj_t obj;
+	void *data;
+	u_int32_t speed;
+};
+
+METHOD u_int32_t setblocksize {
+	kobj_t obj;
+	void *data;
+	u_int32_t blocksize;
+};
+
+METHOD int trigger {
+	kobj_t obj;
+	void *data;
+	int go;
+};
+
+METHOD u_int32_t getptr {
+	kobj_t obj;
+	void *data;
+};
+
+METHOD pcmchan_caps* getcaps {
+	kobj_t obj;
+	void *data;
+};
+
diff --git a/sys/dev/sound/pcm/datatypes.h b/sys/dev/sound/pcm/datatypes.h
index 6b4c01b..aaa17a3 100644
--- a/sys/dev/sound/pcm/datatypes.h
+++ b/sys/dev/sound/pcm/datatypes.h
@@ -33,20 +33,11 @@ typedef struct _pcmchan_caps pcmchan_caps;
 typedef struct _pcm_feeder pcm_feeder;
 typedef struct _pcm_channel pcm_channel;
 
-typedef int (mix_set_t)(snd_mixer *m, unsigned dev, unsigned left, unsigned right);
-typedef int (mix_recsrc_t)(snd_mixer *m, u_int32_t src);
-typedef int (mix_init_t)(snd_mixer *m);
-typedef int (mix_uninit_t)(snd_mixer *m);
-typedef int (mix_reinit_t)(snd_mixer *m);
+/*****************************************************************************/
 
 struct _snd_mixer {
-	char name[64];
-	mix_init_t *init;
-	mix_uninit_t *uninit;
-	mix_uninit_t *reinit;
-	mix_set_t *set;
-	mix_recsrc_t *setrecsrc;
-
+	KOBJ_FIELDS;
+	const char *name;
 	void *devinfo;
 	int busy;
 	u_int32_t devs;
@@ -55,6 +46,8 @@ struct _snd_mixer {
 	u_int16_t level[32];
 };
 
+/*****************************************************************************/
+
 /*
  * descriptor of a dma buffer. See dmabuf.c for documentation.
  * (rp,rl) and (fp,fl) identify the READY and FREE regions of the
@@ -79,11 +72,7 @@ struct _snd_dbuf {
 	struct selinfo sel;
 };
 
-typedef int (pcmfeed_init_t)(pcm_feeder *feeder);
-typedef int (pcmfeed_free_t)(pcm_feeder *feeder);
-typedef int (pcmfeed_feed_t)(pcm_feeder *feeder, pcm_channel *c, u_int8_t *buffer,
-			     u_int32_t count, struct uio *stream);
-typedef int (pcmfeed_set_t)(pcm_feeder *feeder, int what, int value);
+/*****************************************************************************/
 
 struct pcm_feederdesc {
 	u_int32_t type;
@@ -93,55 +82,25 @@ struct pcm_feederdesc {
 };
 
 struct _pcm_feeder {
-	char name[16];
+    	KOBJ_FIELDS;
 	int align;
 	struct pcm_feederdesc *desc;
-	pcmfeed_init_t *init;
-	pcmfeed_free_t *free;
-	pcmfeed_set_t *set;
-	pcmfeed_feed_t *feed;
 	void *data;
 	pcm_feeder *source;
 };
 
+/*****************************************************************************/
+
 struct _pcmchan_caps {
 	u_int32_t minspeed, maxspeed;
 	u_int32_t *fmtlist;
 	u_int32_t caps;
 };
 
-typedef void *(pcmchan_init_t)(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-typedef int (pcmchan_setdir_t)(void *data, int dir);
-typedef int (pcmchan_setformat_t)(void *data, u_int32_t format);
-typedef int (pcmchan_setspeed_t)(void *data, u_int32_t speed);
-typedef int (pcmchan_setblocksize_t)(void *data, u_int32_t blocksize);
-typedef int (pcmchan_trigger_t)(void *data, int go);
-typedef int (pcmchan_getptr_t)(void *data);
-typedef int (pcmchan_free_t)(void *data);
-typedef pcmchan_caps *(pcmchan_getcaps_t)(void *data);
-typedef int (pcmchan_reset_t)(void *data);
-typedef int (pcmchan_resetdone_t)(void *data);
-
 struct _pcm_channel {
-	pcmchan_init_t *init;
-	pcmchan_setdir_t *setdir;
-	pcmchan_setformat_t *setformat;
-	pcmchan_setspeed_t *setspeed;
-	pcmchan_setblocksize_t *setblocksize;
-	pcmchan_trigger_t *trigger;
-	pcmchan_getptr_t *getptr;
-	pcmchan_getcaps_t *getcaps;
-	pcmchan_free_t *free;
-	pcmchan_reset_t *reset;
-	pcmchan_resetdone_t *resetdone;
-	void *nop3;
-	void *nop4;
-	void *nop5;
-	void *nop6;
-	void *nop7;
+	kobj_t methods;
 
 	pcm_feeder *feeder;
-	struct pcm_feederdesc *feederdesc;
 	u_int32_t align;
 
 	int volume;
@@ -157,24 +116,26 @@ struct _pcm_channel {
 	void *devinfo;
 };
 
-typedef void (pcm_swap_t)(void *data, int dir);
+/*****************************************************************************/
+
 #define SND_STATUSLEN	64
 /* descriptor of audio device */
 struct _snddev_info {
 	pcm_channel *play, *rec, **aplay, **arec, fakechan;
 	int *ref;
 	unsigned playcount, reccount, chancount, maxchans;
-	snd_mixer mixer;
+	snd_mixer *mixer;
 	u_long magic;
 	unsigned flags;
 	void *devinfo;
-	pcm_swap_t *swap;
 	device_t dev;
 	char status[SND_STATUSLEN];
 };
 
+/*****************************************************************************/
+
 /* mixer description structure and macros - these should go away,
- * only sb.[ch] and mss.[ch] use them
+ * only mss.[ch] use them
  */
 struct mixer_def {
     	u_int regno:7;
diff --git a/sys/dev/sound/pcm/dsp.c b/sys/dev/sound/pcm/dsp.c
index b3f5c29..59c14e9 100644
--- a/sys/dev/sound/pcm/dsp.c
+++ b/sys/dev/sound/pcm/dsp.c
@@ -72,7 +72,6 @@ setchns(snddev_info *d, int chan)
 	KASSERT((d->flags & SD_F_PRIO_SET) != SD_F_PRIO_SET, \
 		("getchns: read and write both prioritised"));
 	d->flags |= SD_F_DIR_SET;
-	if (d->swap) d->swap(d->devinfo, (d->flags & SD_F_PRIO_WR)? PCMDIR_PLAY : PCMDIR_REC);
 }
 
 int
@@ -288,7 +287,7 @@ dsp_ioctl(snddev_info *d, int chan, u_long cmd, caddr_t arg)
 			if (rdch && wrch)
 				p->formats |= (d->flags & SD_F_SIMPLEX)? 0 : AFMT_FULLDUPLEX;
 	    		p->mixers = 1; /* default: one mixer */
-	    		p->inputs = d->mixer.devs;
+	    		p->inputs = d->mixer->devs;
 	    		p->left = p->right = 100;
 		}
 		break;
@@ -417,7 +416,7 @@ dsp_ioctl(snddev_info *d, int chan, u_long cmd, caddr_t arg)
 			if (rdch && ret == 0)
 				ret = chn_setformat(rdch, (*arg_i) | (rdch->format & AFMT_STEREO));
 		}
-		*arg_i = (wrch? wrch->format: rdch->format) & ~AFMT_STEREO;
+		*arg_i = (wrch? wrch->format : rdch->format) & ~AFMT_STEREO;
 		break;
 
     	case SNDCTL_DSP_SUBDIVIDE:
diff --git a/sys/dev/sound/pcm/fake.c b/sys/dev/sound/pcm/fake.c
index 9cdb1f6..28ae84a 100644
--- a/sys/dev/sound/pcm/fake.c
+++ b/sys/dev/sound/pcm/fake.c
@@ -28,16 +28,6 @@
 
 #include <dev/sound/pcm/sound.h>
 
-/* channel interface */
-static void *fkchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir);
-static int fkchan_setdir(void *data, int dir);
-static int fkchan_setformat(void *data, u_int32_t format);
-static int fkchan_setspeed(void *data, u_int32_t speed);
-static int fkchan_setblocksize(void *data, u_int32_t blocksize);
-static int fkchan_trigger(void *data, int go);
-static int fkchan_getptr(void *data);
-static pcmchan_caps *fkchan_getcaps(void *data);
-
 static u_int32_t fk_fmt[] = {
 	AFMT_U8,
 	AFMT_STEREO | AFMT_U8,
@@ -53,22 +43,11 @@ static u_int32_t fk_fmt[] = {
 	AFMT_STEREO | AFMT_U16_BE,
 	0
 };
-static pcmchan_caps fk_caps = {4000, 48000, fk_fmt, 0};
-
-static pcm_channel fk_chantemplate = {
-	fkchan_init,
-	fkchan_setdir,
-	fkchan_setformat,
-	fkchan_setspeed,
-	fkchan_setblocksize,
-	fkchan_trigger,
-	fkchan_getptr,
-	fkchan_getcaps,
-};
+static pcmchan_caps fk_caps = {0, 1000000, fk_fmt, 0};
 
 /* channel interface */
 static void *
-fkchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
+fkchan_init(kobj_t obj, void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 {
 	b->bufsize = 16384;
 	b->buf = malloc(b->bufsize, M_DEVBUF, M_NOWAIT);
@@ -76,50 +55,66 @@ fkchan_init(void *devinfo, snd_dbuf *b, pcm_channel *c, int dir)
 }
 
 static int
-fkchan_setdir(void *data, int dir)
-{
-	return 0;
-}
-
-static int
-fkchan_setformat(void *data, u_int32_t format)
+fkchan_setformat(kobj_t obj, void *data, u_int32_t format)
 {
 	return 0;
 }
 
 static int
-fkchan_setspeed(void *data, u_int32_t speed)
+fkchan_setspeed(kobj_t obj, void *data, u_int32_t speed)
 {
 	return speed;
 }
 
 static int
-fkchan_setblocksize(void *data, u_int32_t blocksize)
+fkchan_setblocksize(kobj_t obj, void *data, u_int32_t blocksize)
 {
 	return blocksize;
 }
 
 static int
-fkchan_trigger(void *data, int go)
+fkchan_trigger(kobj_t obj, void *data, int go)
 {
 	return 0;
 }
 
 static int
-fkchan_getptr(void *data)
+fkchan_getptr(kobj_t obj, void *data)
 {
 	return 0;
 }
 
 static pcmchan_caps *
-fkchan_getcaps(void *data)
+fkchan_getcaps(kobj_t obj, void *data)
 {
 	return &fk_caps;
 }
 
+static kobj_method_t fkchan_methods[] = {
+    	KOBJMETHOD(channel_init,		fkchan_init),
+    	KOBJMETHOD(channel_setformat,		fkchan_setformat),
+    	KOBJMETHOD(channel_setspeed,		fkchan_setspeed),
+    	KOBJMETHOD(channel_setblocksize,	fkchan_setblocksize),
+    	KOBJMETHOD(channel_trigger,		fkchan_trigger),
+    	KOBJMETHOD(channel_getptr,		fkchan_getptr),
+    	KOBJMETHOD(channel_getcaps,		fkchan_getcaps),
+	{ 0, 0 }
+};
+CHANNEL_DECLARE(fkchan);
+
 int
 fkchan_setup(pcm_channel *c)
 {
-	*c = fk_chantemplate;
+	c->methods = kobj_create(&fkchan_class, M_DEVBUF, M_WAITOK);
 	return 0;
 }
+
+int
+fkchan_kill(pcm_channel *c)
+{
+	kobj_delete(c->methods, M_DEVBUF);
+	c->methods = NULL;
+	return 0;
+}
+
+
diff --git a/sys/dev/sound/pcm/feeder.c b/sys/dev/sound/pcm/feeder.c
index c10d62e..5853770 100644
--- a/sys/dev/sound/pcm/feeder.c
+++ b/sys/dev/sound/pcm/feeder.c
@@ -28,12 +28,16 @@
 
 #include <dev/sound/pcm/sound.h>
 
+#include "feeder_if.h"
+
+MALLOC_DEFINE(M_FEEDER, "feeder", "pcm feeder");
+
 #define MAXFEEDERS 	256
 #undef FEEDER_DEBUG
 
 struct feedertab_entry {
 	SLIST_ENTRY(feedertab_entry) link;
-	pcm_feeder *feeder;
+	struct feeder_class *feederclass;
 	struct pcm_feederdesc *desc;
 
 	int idx;
@@ -45,17 +49,17 @@ static SLIST_HEAD(, feedertab_entry) feedertab;
 void
 feeder_register(void *p)
 {
-	pcm_feeder *f = p;
+	struct feeder_class *fc = p;
 	struct feedertab_entry *fte;
 	static int feedercnt = 0;
 	int i;
 
 	if (feedercnt == 0) {
-		if (f->desc)
-			panic("FIRST FEEDER NOT ROOT: %s\n", f->name);
+		if (fc->desc)
+			panic("FIRST FEEDER NOT ROOT: %s\n", fc->name);
 		SLIST_INIT(&feedertab);
-		fte = malloc(sizeof(*fte), M_DEVBUF, M_NOWAIT);
-		fte->feeder = f;
+		fte = malloc(sizeof(*fte), M_FEEDER, M_WAITOK | M_ZERO);
+		fte->feederclass = fc;
 		fte->desc = NULL;
 		fte->idx = feedercnt;
 		SLIST_INSERT_HEAD(&feedertab, fte, link);
@@ -65,10 +69,10 @@ feeder_register(void *p)
 	/* printf("installing feeder: %s\n", f->name); */
 
 	i = 0;
-	while ((feedercnt < MAXFEEDERS) && (f->desc[i].type > 0)) {
-		fte = malloc(sizeof(*fte), M_DEVBUF, M_NOWAIT);
-		fte->feeder = f;
-		fte->desc = &f->desc[i];
+	while ((feedercnt < MAXFEEDERS) && (fc->desc[i].type > 0)) {
+		fte = malloc(sizeof(*fte), M_FEEDER, M_WAITOK | M_ZERO);
+		fte->feederclass = fc;
+		fte->desc = &fc->desc[i];
 		fte->idx = feedercnt;
 		fte->desc->idx = feedercnt;
 		SLIST_INSERT_HEAD(&feedertab, fte, link);
@@ -88,53 +92,67 @@ cmpdesc(struct pcm_feederdesc *n, struct pcm_feederdesc *m)
 		(n->flags == m->flags));
 }
 
-pcm_feeder *
-feeder_get(struct pcm_feederdesc *desc)
+static void
+feeder_destroy(pcm_feeder *f)
 {
-	struct feedertab_entry *fte;
+	FEEDER_FREE(f);
+	free(f->desc, M_FEEDER);
+	kobj_delete((kobj_t)f, M_FEEDER);
+}
 
-	SLIST_FOREACH(fte, &feedertab, link) {
-		if ((fte->desc != NULL) && cmpdesc(desc, fte->desc))
-			return fte->feeder;
+static pcm_feeder *
+feeder_create(struct feeder_class *fc, struct pcm_feederdesc *desc)
+{
+	pcm_feeder *f;
+	int err;
+
+	f = (pcm_feeder *)kobj_create((kobj_class_t)fc, M_FEEDER, M_WAITOK | M_ZERO);
+	f->align = fc->align;
+	f->desc = malloc(sizeof(*(f->desc)), M_FEEDER, M_WAITOK | M_ZERO);
+	if (desc)
+		*(f->desc) = *desc;
+	else {
+		f->desc->type = FEEDER_ROOT;
+		f->desc->in = 0;
+		f->desc->out = 0;
+		f->desc->flags = 0;
+		f->desc->idx = 0;
 	}
-	return NULL;
+	f->data = fc->data;
+	f->source = NULL;
+	err = FEEDER_INIT(f);
+	if (err) {
+		feeder_destroy(f);
+		return NULL;
+	} else
+		return f;
 }
 
-pcm_feeder *
-feeder_getroot()
+struct feeder_class *
+feeder_getclass(struct pcm_feederdesc *desc)
 {
 	struct feedertab_entry *fte;
 
 	SLIST_FOREACH(fte, &feedertab, link) {
-		if (fte->desc == NULL)
-			return fte->feeder;
+		if ((desc == NULL) && (fte->desc == NULL))
+			return fte->feederclass;
+		if ((fte->desc != NULL) && (desc != NULL) && cmpdesc(desc, fte->desc))
+			return fte->feederclass;
 	}
 	return NULL;
 }
 
 int
-feeder_set(pcm_feeder *feeder, int what, int value)
-{
-	if (feeder->set)
-		return feeder->set(feeder, what, value);
-	else
-		return -1;
-}
-
-int
-chn_addfeeder(pcm_channel *c, pcm_feeder *f)
+chn_addfeeder(pcm_channel *c, struct feeder_class *fc, struct pcm_feederdesc *desc)
 {
 	pcm_feeder *nf;
-	struct pcm_feederdesc *nfdesc;
 
-	nf = malloc(sizeof(*nf), M_DEVBUF, M_NOWAIT);
-	nfdesc = malloc(sizeof(*nfdesc), M_DEVBUF, M_NOWAIT);
-        *nfdesc = *(f->desc);
-	*nf = *f;
-	nf->desc = nfdesc;
+	nf = feeder_create(fc, desc);
+	if (nf == NULL)
+		return -1;
+
 	nf->source = c->feeder;
-	if (nf->init)
-		nf->init(nf);
+
 	if (nf->align > 0)
 		c->align += nf->align;
 	else if (nf->align < 0 && c->align < -nf->align)
@@ -150,14 +168,11 @@ chn_removefeeder(pcm_channel *c)
 {
 	pcm_feeder *f;
 
-	if (c->feeder->source == NULL)
+	if (c->feeder == NULL)
 		return -1;
-	f = c->feeder->source;
-	if (c->feeder->free)
-		c->feeder->free(c->feeder);
-	free(c->feeder->desc, M_DEVBUF);
-	free(c->feeder, M_DEVBUF);
-	c->feeder = f;
+	f = c->feeder;
+	c->feeder = c->feeder->source;
+	feeder_destroy(f);
 	return 0;
 }
 
@@ -203,7 +218,7 @@ feeder_fmtchain(u_int32_t *to, pcm_feeder *source, pcm_feeder *stop, int maxdept
 {
 	struct feedertab_entry *fte;
 	pcm_feeder *try, *ret;
-	struct pcm_feederdesc *trydesc;
+	struct pcm_feederdesc trydesc;
 
 	/* printf("trying %s...\n", source->name); */
 	if (fmtvalid(source->desc->out, to)) {
@@ -214,28 +229,26 @@ feeder_fmtchain(u_int32_t *to, pcm_feeder *source, pcm_feeder *stop, int maxdept
 	if (maxdepth < 0)
 		return NULL;
 
-	try = malloc(sizeof(*try), M_DEVBUF, M_NOWAIT);
-	trydesc = malloc(sizeof(*trydesc), M_DEVBUF, M_NOWAIT);
-	trydesc->type = FEEDER_FMT;
-	trydesc->in = source->desc->out;
-	trydesc->out = 0;
-	trydesc->flags = 0;
-	trydesc->idx = -1;
+	trydesc.type = FEEDER_FMT;
+	trydesc.in = source->desc->out;
+	trydesc.out = 0;
+	trydesc.flags = 0;
+	trydesc.idx = -1;
 
 	SLIST_FOREACH(fte, &feedertab, link) {
 		if ((fte->desc) && (fte->desc->in == source->desc->out)) {
-			*try = *(fte->feeder);
+			trydesc.out = fte->desc->out;
+			trydesc.idx = fte->idx;
+			try = feeder_create(fte->feederclass, &trydesc);
+			if (try == NULL)
+				return NULL;
 			try->source = source;
-			try->desc = trydesc;
-			trydesc->out = fte->desc->out;
-			trydesc->idx = fte->idx;
 			ret = chainok(try, stop)? feeder_fmtchain(to, try, stop, maxdepth - 1) : NULL;
 			if (ret != NULL)
 				return ret;
+			feeder_destroy(try);
 		}
 	}
-	free(try, M_DEVBUF);
-	free(trydesc, M_DEVBUF);
 	/* printf("giving up %s...\n", source->name); */
 	return NULL;
 }
@@ -266,8 +279,6 @@ chn_fmtchain(pcm_channel *c, u_int32_t *to)
 		if (try->source)
 			printf(" -> ");
 #endif
-		if (try->init)
-			try->init(try);
 		if (try->align > 0)
 			c->align += try->align;
 		else if (try->align < 0 && c->align < -try->align)
@@ -295,22 +306,27 @@ feed_root(pcm_feeder *feeder, pcm_channel *ch, u_int8_t *buffer, u_int32_t count
 	count = min(count, stream->uio_resid);
 	if (count) {
 		ret = uiomove(buffer, count, stream);
-		KASSERT(ret == 0, ("feed_root: uiomove failed"));
+		KASSERT(ret == 0, ("feed_root: uiomove failed (%d)", ret));
 	}
 	splx(s);
 
 	return count;
 }
-static pcm_feeder feeder_root = {
-	"root",
-	0,
-	NULL,
-	NULL,
-	NULL,
-	NULL,
-	feed_root,
+
+static kobj_method_t feeder_root_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_root),
+	{ 0, 0 }
+};
+static struct feeder_class feeder_root_class = {
+	name:		"feeder_root",
+	methods:	feeder_root_methods,
+	size:		sizeof(pcm_feeder),
+	align:		0,
+	desc:		NULL,
+	data:		NULL,
 };
-SYSINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_register, &feeder_root);
+SYSINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_register, &feeder_root_class);
+
 
 
 
diff --git a/sys/dev/sound/pcm/feeder.h b/sys/dev/sound/pcm/feeder.h
index 40f866c..bde1218 100644
--- a/sys/dev/sound/pcm/feeder.h
+++ b/sys/dev/sound/pcm/feeder.h
@@ -26,17 +26,31 @@
  * $FreeBSD$
  */
 
+struct feeder_class {
+	KOBJ_CLASS_FIELDS;
+	int align;
+	struct pcm_feederdesc *desc;
+	void *data;
+};
+
 void feeder_register(void *p);
-pcm_feeder *feeder_get(struct pcm_feederdesc *desc);
-pcm_feeder *feeder_getroot(void);
-int feeder_set(pcm_feeder *feeder, int what, int value);
+struct feeder_class *feeder_getclass(struct pcm_feederdesc *desc);
 
 u_int32_t chn_fmtchain(pcm_channel *c, u_int32_t *to);
-int chn_addfeeder(pcm_channel *c, pcm_feeder *f);
+int chn_addfeeder(pcm_channel *c, struct feeder_class *fc, struct pcm_feederdesc *desc);
 int chn_removefeeder(pcm_channel *c);
 pcm_feeder *chn_findfeeder(pcm_channel *c, u_int32_t type);
 
-#define FEEDER_DECLARE(feeder) SYSINIT(feeder, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, feeder_register, &feeder)
+#define FEEDER_DECLARE(feeder, palign, pdata) \
+static struct feeder_class feeder ## _class = { \
+	name:		#feeder, \
+	methods:	feeder ## _methods, \
+	size:		sizeof(pcm_feeder), \
+	align:		palign, \
+	desc:		feeder ## _desc, \
+	data:		pdata, \
+}; \
+SYSINIT(feeder, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, feeder_register, &feeder ## _class);
 
 #define FEEDER_ROOT	1
 #define FEEDER_FMT 	2
diff --git a/sys/dev/sound/pcm/feeder_fmt.c b/sys/dev/sound/pcm/feeder_fmt.c
index e056da6..739c7a5 100644
--- a/sys/dev/sound/pcm/feeder_fmt.c
+++ b/sys/dev/sound/pcm/feeder_fmt.c
@@ -28,6 +28,10 @@
 
 #include <dev/sound/pcm/sound.h>
 
+#include "feeder_if.h"
+
+MALLOC_DEFINE(M_FMTFEEDER, "fmtfeed", "pcm format feeder");
+
 #define FEEDBUFSZ	8192
 
 static unsigned char ulaw_to_u8[] = {
@@ -107,7 +111,7 @@ feed_8to16le(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct
 {
 	int i, j, k;
 
-	k = f->source->feed(f->source, c, b, count / 2, stream);
+	k = FEEDER_FEED(f->source, c, b, count / 2, stream);
 	j = k - 1;
 	i = j * 2 + 1;
 	while (i > 0 && j >= 0) {
@@ -117,37 +121,33 @@ feed_8to16le(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct
 	return k * 2;
 }
 
-static struct pcm_feederdesc desc_8to16le[] = {
+static struct pcm_feederdesc feeder_8to16le_desc[] = {
 	{FEEDER_FMT, AFMT_U8, AFMT_U16_LE, 0},
 	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S8, AFMT_S16_LE, 0},
 	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_8to16le = {
-	"8to16le",
-	0,
-	desc_8to16le,
-	NULL,
-	NULL,
-	NULL,
-	feed_8to16le,
+static kobj_method_t feeder_8to16le_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_8to16le),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_8to16le);
+FEEDER_DECLARE(feeder_8to16le, 0, NULL);
 
 /*****************************************************************************/
 
 static int
 feed_16to8_init(pcm_feeder *f)
 {
-	f->data = malloc(FEEDBUFSZ, M_DEVBUF, M_NOWAIT);
-	return (f->data == NULL);
+	f->data = malloc(FEEDBUFSZ, M_FMTFEEDER, M_WAITOK | M_ZERO);
+	return (f->data == NULL)? 0 : ENOMEM;
 }
 
 static int
 feed_16to8_free(pcm_feeder *f)
 {
-	if (f->data) free(f->data, M_DEVBUF);
+	if (f->data)
+		free(f->data, M_FMTFEEDER);
 	f->data = NULL;
 	return 0;
 }
@@ -158,7 +158,7 @@ feed_16leto8(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct
 	u_int32_t i = 0, toget = count * 2;
 	int j = 1, k;
 
-	k = f->source->feed(f->source, c, f->data, min(toget, FEEDBUFSZ), stream);
+	k = FEEDER_FEED(f->source, c, f->data, min(toget, FEEDBUFSZ), stream);
 	while (j < k) {
 		b[i++] = ((u_int8_t *)f->data)[j];
 		j += 2;
@@ -166,30 +166,27 @@ feed_16leto8(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct
 	return i;
 }
 
-static struct pcm_feederdesc desc_16leto8[] = {
+static struct pcm_feederdesc feeder_16leto8_desc[] = {
 	{FEEDER_FMT, AFMT_U16_LE, AFMT_U8, 0},
 	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S16_LE, AFMT_S8, 0},
 	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_16leto8 = {
-	"16leto8",
-	1,
-	desc_16leto8,
-	feed_16to8_init,
-	feed_16to8_free,
-	NULL,
-	feed_16leto8,
+static kobj_method_t feeder_16leto8_methods[] = {
+    	KOBJMETHOD(feeder_init,		feed_16to8_init),
+    	KOBJMETHOD(feeder_free,		feed_16to8_free),
+    	KOBJMETHOD(feeder_feed,		feed_16leto8),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_16leto8);
+FEEDER_DECLARE(feeder_16leto8, 1, NULL);
 
 /*****************************************************************************/
 
 static int
 feed_monotostereo8(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct uio *stream)
 {
-	int i, j, k = f->source->feed(f->source, c, b, count / 2, stream);
+	int i, j, k = FEEDER_FEED(f->source, c, b, count / 2, stream);
 
 	j = k - 1;
 	i = j * 2 + 1;
@@ -201,28 +198,23 @@ feed_monotostereo8(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count,
 	return k * 2;
 }
 
-static struct pcm_feederdesc desc_monotostereo8[] = {
+static struct pcm_feederdesc feeder_monotostereo8_desc[] = {
 	{FEEDER_FMT, AFMT_U8, AFMT_U8 | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S8, AFMT_S8 | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_monotostereo8 = {
-	"monotostereo8",
-	0,
-	desc_monotostereo8,
-	NULL,
-	NULL,
-	NULL,
-	feed_monotostereo8,
+static kobj_method_t feeder_monotostereo8_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_monotostereo8),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_monotostereo8);
+FEEDER_DECLARE(feeder_monotostereo8, 0, NULL);
 
 /*****************************************************************************/
 
 static int
 feed_monotostereo16(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct uio *stream)
 {
-	int i, j, k = f->source->feed(f->source, c, b, count / 2, stream);
+	int i, j, k = FEEDER_FEED(f->source, c, b, count / 2, stream);
 	u_int8_t x, y;
 
 	j = k - 1;
@@ -238,37 +230,33 @@ feed_monotostereo16(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count,
 	return k * 2;
 }
 
-static struct pcm_feederdesc desc_monotostereo16[] = {
+static struct pcm_feederdesc feeder_monotostereo16_desc[] = {
 	{FEEDER_FMT, AFMT_U16_LE, AFMT_U16_LE | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S16_LE, AFMT_S16_LE | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_U16_BE, AFMT_U16_BE | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S16_BE, AFMT_S16_BE | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_monotostereo16 = {
-	"monotostereo16",
-	0,
-	desc_monotostereo16,
-	NULL,
-	NULL,
-	NULL,
-	feed_monotostereo16,
+static kobj_method_t feeder_monotostereo16_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_monotostereo16),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_monotostereo16);
+FEEDER_DECLARE(feeder_monotostereo16, 0, NULL);
 
 /*****************************************************************************/
 
 static int
 feed_stereotomono8_init(pcm_feeder *f)
 {
-	f->data = malloc(FEEDBUFSZ, M_DEVBUF, M_NOWAIT);
-	return (f->data == NULL);
+	f->data = malloc(FEEDBUFSZ, M_FMTFEEDER, M_WAITOK | M_ZERO);
+	return (f->data == NULL)? 0 : ENOMEM;
 }
 
 static int
 feed_stereotomono8_free(pcm_feeder *f)
 {
-	if (f->data) free(f->data, M_DEVBUF);
+	if (f->data)
+		free(f->data, M_FMTFEEDER);
 	f->data = NULL;
 	return 0;
 }
@@ -279,7 +267,7 @@ feed_stereotomono8(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count,
 	u_int32_t i = 0, toget = count * 2;
 	int j = 0, k;
 
-	k = f->source->feed(f->source, c, f->data, min(toget, FEEDBUFSZ), stream);
+	k = FEEDER_FEED(f->source, c, f->data, min(toget, FEEDBUFSZ), stream);
 	while (j < k) {
 		b[i++] = ((u_int8_t *)f->data)[j];
 		j += 2;
@@ -287,35 +275,33 @@ feed_stereotomono8(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count,
 	return i;
 }
 
-static struct pcm_feederdesc desc_stereotomono8[] = {
+static struct pcm_feederdesc feeder_stereotomono8_desc[] = {
 	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_U8, 0},
 	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_S8, 0},
 	{0},
 };
-static pcm_feeder feeder_stereotomono8 = {
-	"stereotomono8",
-	1,
-	desc_stereotomono8,
-	feed_stereotomono8_init,
-	feed_stereotomono8_free,
-	NULL,
-	feed_stereotomono8,
+static kobj_method_t feeder_stereotomono8_methods[] = {
+    	KOBJMETHOD(feeder_init,		feed_stereotomono8_init),
+    	KOBJMETHOD(feeder_free,		feed_stereotomono8_free),
+    	KOBJMETHOD(feeder_feed,		feed_stereotomono8),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_stereotomono8);
+FEEDER_DECLARE(feeder_stereotomono8, 1, NULL);
 
 /*****************************************************************************/
 
 static int
 feed_stereotomono16_init(pcm_feeder *f)
 {
-	f->data = malloc(FEEDBUFSZ, M_DEVBUF, M_NOWAIT);
-	return (f->data == NULL);
+	f->data = malloc(FEEDBUFSZ, M_FMTFEEDER, M_WAITOK | M_ZERO);
+	return (f->data == NULL)? 0 : ENOMEM;
 }
 
 static int
 feed_stereotomono16_free(pcm_feeder *f)
 {
-	if (f->data) free(f->data, M_DEVBUF);
+	if (f->data)
+		free(f->data, M_FMTFEEDER);
 	f->data = NULL;
 	return 0;
 }
@@ -326,7 +312,7 @@ feed_stereotomono16(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count,
 	u_int32_t i = 0, toget = count * 2;
 	int j = 0, k;
 
-	k = f->source->feed(f->source, c, f->data, min(toget, FEEDBUFSZ), stream);
+	k = FEEDER_FEED(f->source, c, f->data, min(toget, FEEDBUFSZ), stream);
 	while (j < k) {
 		b[i++] = ((u_int8_t *)f->data)[j];
 		b[i++] = ((u_int8_t *)f->data)[j + 1];
@@ -335,23 +321,20 @@ feed_stereotomono16(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count,
 	return i;
 }
 
-static struct pcm_feederdesc desc_stereotomono16[] = {
+static struct pcm_feederdesc feeder_stereotomono16_desc[] = {
 	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_LE, 0},
 	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_S16_LE, 0},
 	{FEEDER_FMT, AFMT_U16_BE | AFMT_STEREO, AFMT_U16_BE, 0},
 	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_BE, 0},
 	{0},
 };
-static pcm_feeder feeder_stereotomono16 = {
-	"stereotomono16",
-	1,
-	desc_stereotomono16,
-	feed_stereotomono16_init,
-	feed_stereotomono16_free,
-	NULL,
-	feed_stereotomono16,
+static kobj_method_t feeder_stereotomono16_methods[] = {
+    	KOBJMETHOD(feeder_init,		feed_stereotomono16_init),
+    	KOBJMETHOD(feeder_free,		feed_stereotomono16_free),
+    	KOBJMETHOD(feeder_feed,		feed_stereotomono16),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_stereotomono16);
+FEEDER_DECLARE(feeder_stereotomono16, 1, NULL);
 
 /*****************************************************************************/
 
@@ -359,7 +342,7 @@ static int
 feed_endian(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct uio *stream)
 {
 	u_int8_t t;
-	int i = 0, j = f->source->feed(f->source, c, b, count, stream);
+	int i = 0, j = FEEDER_FEED(f->source, c, b, count, stream);
 
 	while (i < j) {
 		t = b[i];
@@ -370,7 +353,7 @@ feed_endian(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct
 	return i;
 }
 
-static struct pcm_feederdesc desc_endian[] = {
+static struct pcm_feederdesc feeder_endian_desc[] = {
 	{FEEDER_FMT, AFMT_U16_LE, AFMT_U16_BE, 0},
 	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_U16_BE | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S16_LE, AFMT_S16_BE, 0},
@@ -381,23 +364,18 @@ static struct pcm_feederdesc desc_endian[] = {
 	{FEEDER_FMT, AFMT_S16_BE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_endian = {
-	"endian",
-	-1,
-	desc_endian,
-	NULL,
-	NULL,
-	NULL,
-	feed_endian,
+static kobj_method_t feeder_endian_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_endian),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_endian);
+FEEDER_DECLARE(feeder_endian, 0, NULL);
 
 /*****************************************************************************/
 
 static int
 feed_sign(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct uio *stream)
 {
-	int i = 0, j = f->source->feed(f->source, c, b, count, stream);
+	int i = 0, j = FEEDER_FEED(f->source, c, b, count, stream);
 	int ssz = (int)f->data, ofs = ssz - 1;
 
 	while (i < j) {
@@ -407,50 +385,38 @@ feed_sign(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct ui
 	return i;
 }
 
-static struct pcm_feederdesc desc_sign8[] = {
+static struct pcm_feederdesc feeder_sign8_desc[] = {
 	{FEEDER_FMT, AFMT_U8, AFMT_S8, 0},
 	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_S8 | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S8, AFMT_U8, 0},
 	{FEEDER_FMT, AFMT_S8 | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_sign8 = {
-	"sign8",
-	0,
-	desc_sign8,
-	NULL,
-	NULL,
-	NULL,
-	feed_sign,
-	(void *)1,
+static kobj_method_t feeder_sign8_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_sign),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_sign8);
+FEEDER_DECLARE(feeder_sign8, 0, (void *)1);
 
-static struct pcm_feederdesc desc_sign16le[] = {
+static struct pcm_feederdesc feeder_sign16le_desc[] = {
 	{FEEDER_FMT, AFMT_U16_LE, AFMT_S16_LE, 0},
 	{FEEDER_FMT, AFMT_U16_LE | AFMT_STEREO, AFMT_S16_LE | AFMT_STEREO, 0},
 	{FEEDER_FMT, AFMT_S16_LE, AFMT_U16_LE, 0},
 	{FEEDER_FMT, AFMT_S16_LE | AFMT_STEREO, AFMT_U16_LE | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_sign16le = {
-	"sign16le",
-	-1,
-	desc_sign16le,
-	NULL,
-	NULL,
-	NULL,
-	feed_sign,
-	(void *)2,
+static kobj_method_t feeder_sign16le_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_sign),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_sign16le);
+FEEDER_DECLARE(feeder_sign16le, -1, (void *)2);
 
 /*****************************************************************************/
 
 static int
 feed_table(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct uio *stream)
 {
-	int i = 0, j = f->source->feed(f->source, c, b, count, stream);
+	int i = 0, j = FEEDER_FEED(f->source, c, b, count, stream);
 
 	while (i < j) {
 		b[i] = ((u_int8_t *)f->data)[b[i]];
@@ -459,38 +425,26 @@ feed_table(pcm_feeder *f, pcm_channel *c, u_int8_t *b, u_int32_t count, struct u
 	return i;
 }
 
-static struct pcm_feederdesc desc_ulawtou8[] = {
+static struct pcm_feederdesc feeder_ulawtou8_desc[] = {
 	{FEEDER_FMT, AFMT_MU_LAW, AFMT_U8, 0},
 	{FEEDER_FMT, AFMT_MU_LAW | AFMT_STEREO, AFMT_U8 | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_ulawtou8 = {
-	"ulawtou8",
-	0,
-	desc_ulawtou8,
-	NULL,
-	NULL,
-	NULL,
-	feed_table,
-	ulaw_to_u8,
+static kobj_method_t feeder_ulawtou8_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_table),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_ulawtou8);
+FEEDER_DECLARE(feeder_ulawtou8, 0, ulaw_to_u8);
 
-static struct pcm_feederdesc desc_u8toulaw[] = {
+static struct pcm_feederdesc feeder_u8toulaw_desc[] = {
 	{FEEDER_FMT, AFMT_U8, AFMT_MU_LAW, 0},
 	{FEEDER_FMT, AFMT_U8 | AFMT_STEREO, AFMT_MU_LAW | AFMT_STEREO, 0},
 	{0},
 };
-static pcm_feeder feeder_u8toulaw = {
-	"u8toulaw",
-	0,
-	desc_u8toulaw,
-	NULL,
-	NULL,
-	NULL,
-	feed_table,
-	u8_to_ulaw,
+static kobj_method_t feeder_u8toulaw_methods[] = {
+    	KOBJMETHOD(feeder_feed,		feed_table),
+	{ 0, 0 }
 };
-FEEDER_DECLARE(feeder_u8toulaw);
+FEEDER_DECLARE(feeder_u8toulaw, 0, u8_to_ulaw);
 
 
diff --git a/sys/dev/sound/pcm/feeder_if.m b/sys/dev/sound/pcm/feeder_if.m
new file mode 100644
index 0000000..d9c2c43
--- /dev/null
+++ b/sys/dev/sound/pcm/feeder_if.m
@@ -0,0 +1,71 @@
+#

+# Copyright (c) 2000 Cameron Grant <cg@freebsd.org>

+# All rights reserved.

+#

+# 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

+#    notice, this list of conditions and the following disclaimer.

+# 2. Redistributions in binary form must reproduce the above copyright

+#    notice, this list of conditions and the following disclaimer in the

+#    documentation and/or other materials provided with the distribution.

+#

+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND

+# 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.

+#

+# $FreeBSD$

+#

+

+#include <dev/sound/pcm/sound.h>

+

+INTERFACE feeder;

+

+CODE {

+

+	static int

+	feeder_noinit(pcm_feeder* feeder)

+	{

+		return 0;

+	}

+

+	static int

+	feeder_nofree(pcm_feeder* feeder)

+	{

+		return 0;

+	}

+

+};

+

+METHOD int init {

+	pcm_feeder* feeder;

+} DEFAULT feeder_noinit;

+

+METHOD int free {

+	pcm_feeder* feeder;

+} DEFAULT feeder_nofree;

+

+METHOD int set {

+	pcm_feeder* feeder;

+	int what;

+	int value;

+};

+

+METHOD int feed {

+	pcm_feeder* feeder;

+	pcm_channel* c;

+	u_int8_t* buffer;

+	u_int32_t count;

+	struct uio* stream;

+};

+

+

diff --git a/sys/dev/sound/pcm/mixer.c b/sys/dev/sound/pcm/mixer.c
index 47f141f..ddb161b 100644
--- a/sys/dev/sound/pcm/mixer.c
+++ b/sys/dev/sound/pcm/mixer.c
@@ -28,6 +28,10 @@
 
 #include <dev/sound/pcm/sound.h>
 
+#include "mixer_if.h"
+
+MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
+
 static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
 	[SOUND_MIXER_VOLUME]	= 75,
 	[SOUND_MIXER_BASS]	= 50,
@@ -45,73 +49,144 @@ static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
 };
 
 static int
-mixer_set(snddev_info *d, unsigned dev, unsigned lev)
+mixer_set(snd_mixer *mixer, unsigned dev, unsigned lev)
 {
-	if (d == NULL || d->mixer.set == NULL) return -1;
-	if ((dev < SOUND_MIXER_NRDEVICES) && (d->mixer.devs & (1 << dev))) {
-		unsigned l = min((lev & 0x00ff), 100);
-		unsigned r = min(((lev & 0xff00) >> 8), 100);
-		int v = d->mixer.set(&d->mixer, dev, l, r);
-		if (v >= 0) d->mixer.level[dev] = l | (r << 8);
-		return 0;
-	} else return -1;
+	unsigned l, r;
+	int v;
+
+	if ((dev >= SOUND_MIXER_NRDEVICES) || (0 == (mixer->devs & (1 << dev))))
+		return -1;
+
+	l = min((lev & 0x00ff), 100);
+	r = min(((lev & 0xff00) >> 8), 100);
+
+	v = MIXER_SET(mixer, dev, l, r);
+	if (v < 0)
+		return -1;
+
+	mixer->level[dev] = l | (r << 8);
+	return 0;
 }
 
 static int
-mixer_get(snddev_info *d, int dev)
+mixer_get(snd_mixer *mixer, int dev)
 {
-	if (d == NULL) return -1;
-	if (dev < SOUND_MIXER_NRDEVICES && (d->mixer.devs & (1 << dev)))
-		return d->mixer.level[dev];
+	if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev)))
+		return mixer->level[dev];
 	else return -1;
 }
 
 static int
-mixer_setrecsrc(snddev_info *d, u_int32_t src)
+mixer_setrecsrc(snd_mixer *mixer, u_int32_t src)
 {
-	if (d == NULL || d->mixer.setrecsrc == NULL) return -1;
-	src &= d->mixer.recdevs;
-	if (src == 0) src = SOUND_MASK_MIC;
-	d->mixer.recsrc = d->mixer.setrecsrc(&d->mixer, src);
+	src &= mixer->recdevs;
+	if (src == 0)
+		src = SOUND_MASK_MIC;
+	mixer->recsrc = MIXER_SETRECSRC(mixer, src);
 	return 0;
 }
 
 static int
-mixer_getrecsrc(snddev_info *d)
+mixer_getrecsrc(snd_mixer *mixer)
+{
+	return mixer->recsrc;
+}
+
+void
+mix_setdevs(snd_mixer *m, u_int32_t v)
+{
+	m->devs = v;
+}
+
+void
+mix_setrecdevs(snd_mixer *m, u_int32_t v)
+{
+	m->recdevs = v;
+}
+
+u_int32_t
+mix_getdevs(snd_mixer *m)
+{
+	return m->devs;
+}
+
+u_int32_t
+mix_getrecdevs(snd_mixer *m)
+{
+	return m->recdevs;
+}
+
+void *
+mix_getdevinfo(snd_mixer *m)
 {
-	if (d == NULL) return -1;
-	return d->mixer.recsrc;
+	return m->devinfo;
 }
 
 int
-mixer_init(device_t dev, snd_mixer *m, void *devinfo)
-{
-    	snddev_info *d = device_get_softc(dev);
-	if (d == NULL) return -1;
-	d->mixer = *m;
-	d->mixer.devinfo = devinfo;
-	bzero(&d->mixer.level, sizeof d->mixer.level);
-	if (d->mixer.init != NULL && d->mixer.init(&d->mixer) == 0) {
-		int i;
-		for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
-			u_int16_t v = snd_mixerdefaults[i];
-			mixer_set(d, i, v | (v << 8));
-		}
-		mixer_setrecsrc(d, SOUND_MASK_MIC);
-		return 0;
-	} else return -1;
+mixer_busy(snd_mixer *m, int busy)
+{
+	m->busy = busy;
+	return 0;
+}
+
+int
+mixer_isbusy(snd_mixer *m)
+{
+	return m->busy;
+}
+
+int
+mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
+{
+    	snddev_info *d;
+	snd_mixer *m;
+	u_int16_t v;
+	int i;
+
+	d = device_get_softc(dev);
+	m = (snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
+
+	m->name = cls->name;
+	m->devinfo = devinfo;
+
+	if (MIXER_INIT(m))
+		goto bad;
+
+	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
+		v = snd_mixerdefaults[i];
+		mixer_set(m, i, v | (v << 8));
+	}
+
+	mixer_setrecsrc(m, SOUND_MASK_MIC);
+
+	d->mixer = m;
+
+	return 0;
+
+bad:	kobj_delete((kobj_t)m, M_MIXER);
+	return -1;
 }
 
 int
 mixer_uninit(device_t dev)
 {
 	int i;
-    	snddev_info *d = device_get_softc(dev);
-	if (d == NULL) return -1;
+    	snddev_info *d;
+	snd_mixer *m;
+
+	d = device_get_softc(dev);
+	m = d->mixer;
+
 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
-		mixer_set(d, i, 0);
-	mixer_setrecsrc(d, SOUND_MASK_MIC);
-	if (d->mixer.uninit != NULL) d->mixer.uninit(&d->mixer);
+		mixer_set(m, i, 0);
+
+	mixer_setrecsrc(m, SOUND_MASK_MIC);
+
+	MIXER_UNINIT(m);
+
+	kobj_delete((kobj_t)m, M_MIXER);
+	d->mixer = NULL;
+
 	return 0;
 }
 
@@ -119,20 +194,21 @@ int
 mixer_reinit(device_t dev)
 {
 	int i;
-    	snddev_info *d = device_get_softc(dev);
-	if (d == NULL) return -1;
-
-	if (d->mixer.reinit != NULL)
-		i = d->mixer.reinit(&d->mixer);
-	else if (d->mixer.init != NULL)
-		i = d->mixer.init(&d->mixer);
-	else
-		i = 0;
+    	snddev_info *d;
+	snd_mixer *m;
+
+	d = device_get_softc(dev);
+	m = d->mixer;
+
+	i = MIXER_REINIT(m);
 	if (i)
 		return i;
+
 	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
-		mixer_set(d, i, d->mixer.level[i]);
-	mixer_setrecsrc(d, d->mixer.recsrc);
+		mixer_set(m, i, m->level[i]);
+
+	mixer_setrecsrc(m, m->recsrc);
+
 	return 0;
 }
 
@@ -140,35 +216,37 @@ int
 mixer_ioctl(snddev_info *d, u_long cmd, caddr_t arg)
 {
 	int ret, *arg_i = (int *)arg;
+	int v = -1, j = cmd & 0xff;
+	snd_mixer *m;
 
-	if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) {
-		int j = cmd & 0xff;
+	m = d->mixer;
 
-		if (j == SOUND_MIXER_RECSRC) ret = mixer_setrecsrc(d, *arg_i);
-		else ret = mixer_set(d, j, *arg_i);
+	if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) {
+		if (j == SOUND_MIXER_RECSRC)
+			ret = mixer_setrecsrc(m, *arg_i);
+		else
+			ret = mixer_set(m, j, *arg_i);
 		return (ret == 0)? 0 : ENXIO;
 	}
 
     	if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) {
-		int v = -1, j = cmd & 0xff;
-
 		switch (j) {
     		case SOUND_MIXER_DEVMASK:
     		case SOUND_MIXER_CAPS:
     		case SOUND_MIXER_STEREODEVS:
-			v = d->mixer.devs;
+			v = m->devs;
 			break;
 
     		case SOUND_MIXER_RECMASK:
-			v = d->mixer.recdevs;
+			v = m->recdevs;
 			break;
 
     		case SOUND_MIXER_RECSRC:
-			v = mixer_getrecsrc(d);
+			v = mixer_getrecsrc(m);
 			break;
 
 		default:
-			v = mixer_get(d, j);
+			v = mixer_get(m, j);
 		}
 		*arg_i = v;
 		return (v != -1)? 0 : ENXIO;
@@ -176,51 +254,6 @@ mixer_ioctl(snddev_info *d, u_long cmd, caddr_t arg)
 	return ENXIO;
 }
 
-int
-mixer_busy(snddev_info *d, int busy)
-{
-	if (d == NULL) return -1;
-	d->mixer.busy = busy;
-	return 0;
-}
-
-int
-mixer_isbusy(snddev_info *d)
-{
-	if (d == NULL) return -1;
-	return d->mixer.busy;
-}
-
-void
-mix_setdevs(snd_mixer *m, u_int32_t v)
-{
-	m->devs = v;
-}
-
-void
-mix_setrecdevs(snd_mixer *m, u_int32_t v)
-{
-	m->recdevs = v;
-}
-
-u_int32_t
-mix_getdevs(snd_mixer *m)
-{
-	return m->devs;
-}
-
-u_int32_t
-mix_getrecdevs(snd_mixer *m)
-{
-	return m->recdevs;
-}
-
-void *
-mix_getdevinfo(snd_mixer *m)
-{
-	return m->devinfo;
-}
-
 /*
  * The various mixers use a variety of bitmasks etc. The Voxware
  * driver had a very nice technique to describe a mixer and interface
diff --git a/sys/dev/sound/pcm/mixer.h b/sys/dev/sound/pcm/mixer.h
index eb1946b..08824fc 100644
--- a/sys/dev/sound/pcm/mixer.h
+++ b/sys/dev/sound/pcm/mixer.h
@@ -26,12 +26,12 @@
  * $FreeBSD$
  */
 
-extern int mixer_init(device_t dev, snd_mixer *m, void *devinfo);
+extern int mixer_init(device_t dev, kobj_class_t cls, void *devinfo);
 extern int mixer_uninit(device_t dev);
 extern int mixer_reinit(device_t dev);
 extern int mixer_ioctl(snddev_info *d, u_long cmd, caddr_t arg);
-extern int mixer_busy(snddev_info *d, int busy);
-extern int mixer_isbusy(snddev_info *d);
+extern int mixer_busy(snd_mixer *m, int busy);
+extern int mixer_isbusy(snd_mixer *m);
 
 extern void change_bits(mixer_tab *t, u_char *regval, int dev, int chn, int newval);
 
@@ -40,3 +40,5 @@ void mix_setrecdevs(snd_mixer *m, u_int32_t v);
 u_int32_t mix_getdevs(snd_mixer *m);
 u_int32_t mix_getrecdevs(snd_mixer *m);
 void *mix_getdevinfo(snd_mixer *m);
+
+#define MIXER_DECLARE(name) DEFINE_CLASS(name, name ## _methods, sizeof(snd_mixer))
diff --git a/sys/dev/sound/pcm/mixer_if.m b/sys/dev/sound/pcm/mixer_if.m
new file mode 100644
index 0000000..acc1c20
--- /dev/null
+++ b/sys/dev/sound/pcm/mixer_if.m
@@ -0,0 +1,68 @@
+#
+# Copyright (c) 2000 Cameron Grant <cg@freebsd.org>
+# All rights reserved.
+#
+# 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
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# 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.
+#
+# $FreeBSD$
+#
+
+#include <dev/sound/pcm/sound.h>
+
+INTERFACE mixer;
+
+CODE {
+
+	static int
+	mixer_noreinit(snd_mixer *m)
+	{
+		return 0;
+	}
+
+};
+
+METHOD int init {
+	snd_mixer *m;
+};
+
+METHOD int reinit {
+	snd_mixer *m;
+} DEFAULT mixer_noreinit;
+
+METHOD int uninit {
+	snd_mixer *m;
+};
+
+METHOD int set {
+	snd_mixer *m;
+	unsigned dev;
+	unsigned left;
+	unsigned right;
+};
+
+METHOD u_int32_t setrecsrc {
+	snd_mixer *m;
+	u_int32_t src
+};
+
+
+
diff --git a/sys/dev/sound/pcm/sound.c b/sys/dev/sound/pcm/sound.c
index 0458cd7..0aecfb0 100644
--- a/sys/dev/sound/pcm/sound.c
+++ b/sys/dev/sound/pcm/sound.c
@@ -149,12 +149,13 @@ SYSCTL_PROC(_hw, OID_AUTO, sndunit, CTLTYPE_INT | CTLFLAG_RW,
             0, sizeof(int), sysctl_hw_sndunit, "I", "");
 
 int
-pcm_addchan(device_t dev, int dir, pcm_channel *templ, void *devinfo)
+pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo)
 {
     	int unit = device_get_unit(dev), idx;
     	snddev_info *d = device_get_softc(dev);
 	pcm_channel *chns, *ch;
 	char *dirs;
+	int err;
 
 	dirs = ((dir == PCMDIR_PLAY)? "play" : "record");
 	chns = ((dir == PCMDIR_PLAY)? d->play : d->rec);
@@ -165,10 +166,11 @@ pcm_addchan(device_t dev, int dir, pcm_channel *templ, void *devinfo)
 		return 1;
 	}
 	ch = &chns[idx];
-	*ch = *templ;
+	ch->methods = kobj_create(cls, M_DEVBUF, M_WAITOK);
 	ch->parent = d;
-	if (chn_init(ch, devinfo, dir)) {
-		device_printf(dev, "chn_init() for (%s:%d) failed\n", dirs, idx);
+	err = chn_init(ch, devinfo, dir);
+	if (err) {
+		device_printf(dev, "chn_init() for (%s:%d) failed: err = %d\n", dirs, idx, err);
 		return 1;
 	}
 	make_dev(&snd_cdevsw, PCMMKMINOR(unit, SND_DEV_DSP, d->chancount),
@@ -206,6 +208,8 @@ pcm_killchan(device_t dev, int dir)
 		device_printf(dev, "chn_kill() for (%s:%d) failed\n", dirs, idx);
 		return 1;
 	}
+	kobj_delete(ch->methods, M_DEVBUF);
+	ch->methods = NULL;
 	d->chancount--;
 	pdev = makedev(CDEV_MAJOR, PCMMKMINOR(unit, SND_DEV_DSP, d->chancount));
 	destroy_dev(pdev);
@@ -245,13 +249,6 @@ pcm_getdevinfo(device_t dev)
 	return d->devinfo;
 }
 
-void
-pcm_setswap(device_t dev, pcm_swap_t *swap)
-{
-    	snddev_info *d = device_get_softc(dev);
-	d->swap = swap;
-}
-
 /* This is the generic init routine */
 int
 pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
@@ -309,7 +306,6 @@ pcm_register(device_t dev, void *devinfo, int numplay, int numrec)
 	fkchan_setup(&d->fakechan);
 	chn_init(&d->fakechan, NULL, 0);
 	d->magic = MAGIC(unit); /* debugging... */
-	d->swap = NULL;
 
     	return 0;
 no:
@@ -335,7 +331,7 @@ pcm_unregister(device_t dev)
 		device_printf(dev, "unregister: channel busy");
 		return r;
 	}
-	if (mixer_isbusy(d)) {
+	if (mixer_isbusy(d->mixer)) {
 		device_printf(dev, "unregister: mixer busy");
 		return EBUSY;
 	}
@@ -356,6 +352,7 @@ pcm_unregister(device_t dev)
 	if (d->rec) free(d->rec, M_DEVBUF);
 	if (d->ref) free(d->ref, M_DEVBUF);
 
+	fkchan_kill(&d->fakechan);
 	pcm_makelinks(NULL);
 	return 0;
 }
@@ -417,7 +414,7 @@ sndopen(dev_t i_dev, int flags, int mode, struct proc *p)
 		return 0;
 
     	case SND_DEV_CTL:
-		return d? mixer_busy(d, 1) : ENXIO;
+		return d? mixer_busy(d->mixer, 1) : ENXIO;
 
     	case SND_DEV_AUDIO:
     	case SND_DEV_DSP:
@@ -445,7 +442,7 @@ sndclose(dev_t i_dev, int flags, int mode, struct proc *p)
 		return 0;
 
     	case SND_DEV_CTL:
-		return d? mixer_busy(d, 0) : ENXIO;
+		return d? mixer_busy(d->mixer, 0) : ENXIO;
 
     	case SND_DEV_AUDIO:
     	case SND_DEV_DSP:
diff --git a/sys/dev/sound/pcm/sound.h b/sys/dev/sound/pcm/sound.h
index b5745c6..01cdb93 100644
--- a/sys/dev/sound/pcm/sound.h
+++ b/sys/dev/sound/pcm/sound.h
@@ -119,6 +119,7 @@ struct isa_device { int dummy; };
 #define AFMT_BIGENDIAN (AFMT_S16_BE | AFMT_U16_BE)
 
 int fkchan_setup(pcm_channel *c);
+int fkchan_kill(pcm_channel *c);
 
 /*
  * Minor numbers for the sound driver.
@@ -161,14 +162,13 @@ int fkchan_setup(pcm_channel *c);
 #define DEB(x)
 #endif
 
-int pcm_addchan(device_t dev, int dir, pcm_channel *templ, void *devinfo);
+int pcm_addchan(device_t dev, int dir, kobj_class_t cls, void *devinfo);
 int pcm_register(device_t dev, void *devinfo, int numplay, int numrec);
 int pcm_unregister(device_t dev);
 int pcm_setstatus(device_t dev, char *str);
 u_int32_t pcm_getflags(device_t dev);
 void pcm_setflags(device_t dev, u_int32_t val);
 void *pcm_getdevinfo(device_t dev);
-void pcm_setswap(device_t dev, pcm_swap_t *swap);
 
 #endif /* _KERNEL */
 
diff --git a/sys/modules/sound/driver/Makefile.inc b/sys/modules/sound/driver/Makefile.inc
index 265f86d..124bfc8 100644
--- a/sys/modules/sound/driver/Makefile.inc
+++ b/sys/modules/sound/driver/Makefile.inc
@@ -1,3 +1,5 @@
 # $FreeBSD$
 
+SRCS		+= ac97_if.h channel_if.h feeder_if.h mixer_if.h
+
 .include "../Makefile.inc"
diff --git a/sys/modules/sound/pcm/Makefile b/sys/modules/sound/pcm/Makefile
index 97f83c8..1c30fab 100644
--- a/sys/modules/sound/pcm/Makefile
+++ b/sys/modules/sound/pcm/Makefile
@@ -3,8 +3,9 @@
 .PATH:		${.CURDIR}/../../../dev/sound/pcm
 KMOD		= snd_pcm
 SRCS		= device_if.h bus_if.h isa_if.h pci_if.h
+SRCS		+= ac97_if.h channel_if.h feeder_if.h mixer_if.h
 SRCS		+= ac97.c channel.c dsp.c fake.c
-SRCS		+= feeder.c feeder_fmt.c
+SRCS		+= feeder.c feeder_fmt.c feeder_rate.c
 SRCS		+= mixer.c sound.c
 
 .include <bsd.kmod.mk>
diff --git a/sys/modules/sound/sound/Makefile b/sys/modules/sound/sound/Makefile
index 97f83c8..1c30fab 100644
--- a/sys/modules/sound/sound/Makefile
+++ b/sys/modules/sound/sound/Makefile
@@ -3,8 +3,9 @@
 .PATH:		${.CURDIR}/../../../dev/sound/pcm
 KMOD		= snd_pcm
 SRCS		= device_if.h bus_if.h isa_if.h pci_if.h
+SRCS		+= ac97_if.h channel_if.h feeder_if.h mixer_if.h
 SRCS		+= ac97.c channel.c dsp.c fake.c
-SRCS		+= feeder.c feeder_fmt.c
+SRCS		+= feeder.c feeder_fmt.c feeder_rate.c
 SRCS		+= mixer.c sound.c
 
 .include <bsd.kmod.mk>