 @@ -1,14 +1,14 @@
-/*	$NetBSD: audio.c,v 1.247 2009/09/24 16:03:11 sborrill Exp $	*/
+/*	$NetBSD: audio.c,v 1.248 2009/09/29 15:58:54 sborrill Exp $	*/
 /*
  * Copyright (c) 1991-1993 Regents of the University of California.
  * 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.
 @@ -51,27 +51,27 @@
  * generated.
+ *
  * If you try to set both play and record mode on a half-duplex
  * device, playing takes precedence.
  */
 /*
  * Todo:
  * - Add softaudio() isr processing for wakeup, poll, signals,
  *   and silence fill.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.247 2009/09/24 16:03:11 sborrill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: audio.c,v 1.248 2009/09/29 15:58:54 sborrill Exp $");
 #include "audio.h"
 #if NAUDIO > 0
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <sys/select.h>
 #include <sys/poll.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 @@ -182,26 +182,30 @@ int	audioactivate(device_t, enum devact)
 static void	audio_idle(void *);
 static void	audio_activity(device_t, devactive_t);
 #endif
 static bool	audio_suspend(device_t dv PMF_FN_PROTO);
 static bool	audio_resume(device_t dv PMF_FN_PROTO);
 static void	audio_volume_down(device_t);
 static void	audio_volume_up(device_t);
 static void	audio_volume_toggle(device_t);
 static void	audio_mixer_capture(struct audio_softc *);
 static void	audio_mixer_restore(struct audio_softc *);
 static int	audio_get_props(struct audio_softc *);
 static bool	audio_can_playback(struct audio_softc *);
 static bool	audio_can_capture(struct audio_softc *);
 static void	audio_softintr_rd(void *);
 static void	audio_softintr_wr(void *);
 struct portname {
 	const char *name;
 	int mask;
 };
 static const struct portname itable[] = {
 	{ AudioNmicrophone,	AUDIO_MICROPHONE },
 	{ AudioNline,		AUDIO_LINE_IN },
 	{ AudioNcd,		AUDIO_CD },
 	{ 0, 0 }
 };
 @@ -305,61 +309,71 @@ audioattach(device_t parent, device_t se
 	    hwp->halt_output == 0 ||
 	    hwp->halt_input == 0 ||
 	    hwp->getdev == 0 ||
 	    hwp->set_port == 0 ||
 	    hwp->get_port == 0 ||
 	    hwp->query_devinfo == 0 ||
 	    hwp->get_props == 0) {
 		printf(": missing method\n");
 		sc->hw_if = 0;
 		return;
+	}
 #endif
-	props = hwp->get_props(hdlp);
+	sc->hw_if = hwp;
 	sc->hw_hdl = hdlp;
 	sc->sc_dev = parent;
 	sc->sc_opencnt = 0;
 	sc->sc_writing = sc->sc_waitcomp = 0;
 	sc->sc_lastinfovalid = false;
-	aprint_naive("\n");
+	props = audio_get_props(sc);
 	if (props & AUDIO_PROP_FULLDUPLEX)
 		aprint_normal(": full duplex");
 	else
 		aprint_normal(": half duplex");
 	if (props & AUDIO_PROP_PLAYBACK)
 		aprint_normal(", playback");
 	if (props & AUDIO_PROP_CAPTURE)
 		aprint_normal(", capture");
 	if (props & AUDIO_PROP_MMAP)
 		aprint_normal(", mmap");
 	if (props & AUDIO_PROP_INDEPENDENT)
 		aprint_normal(", independent");
 	aprint_naive("\n");
 	aprint_normal("\n");
-	sc->hw_if = hwp;
+	if (audio_can_playback(sc)) {
-	sc->hw_hdl = hdlp;
+		error = audio_alloc_ring(sc, &sc->sc_pr,
-	sc->sc_dev = parent;
+		    AUMODE_PLAY, AU_RING_SIZE);
-	sc->sc_opencnt = 0;
+		if (error) {
-	sc->sc_writing = sc->sc_waitcomp = 0;
+			sc->hw_if = NULL;
-	sc->sc_lastinfovalid = false;
+			aprint_error("audio: could not allocate play buffer\n");
 			return;
 	error = audio_alloc_ring(sc, &sc->sc_pr, AUMODE_PLAY, AU_RING_SIZE);
 	if (error) {
 		sc->hw_if = NULL;
 		aprint_error("audio: could not allocate play buffer\n");
 		return;
+	}
-	error = audio_alloc_ring(sc, &sc->sc_rr, AUMODE_RECORD, AU_RING_SIZE);
+	if (audio_can_capture(sc)) {
-	if (error) {
+		error = audio_alloc_ring(sc, &sc->sc_rr,
-		audio_free_ring(sc, &sc->sc_pr);
+		    AUMODE_RECORD, AU_RING_SIZE);
-		sc->hw_if = NULL;
+		if (error) {
-		aprint_error("audio: could not allocate record buffer\n");
+			if (sc->sc_pr.s.start != 0)
-		return;
+				audio_free_ring(sc, &sc->sc_pr);
 			sc->hw_if = NULL;
 			aprint_error("audio: could not allocate record buffer\n");
 			return;
+		}
+	}
 	sc->sc_lastgain = 128;
 	if ((error = audio_set_defaults(sc, 0))) {
 		aprint_error("audioattach: audio_set_defaults() failed\n");
 		sc->hw_if = NULL;
 		return;
+	}
 	sc->sc_sih_rd = softint_establish(SOFTINT_SERIAL,
 	    audio_softintr_rd, sc);
 	sc->sc_sih_wr = softint_establish(SOFTINT_SERIAL,
 @@ -732,26 +746,28 @@ audio_alloc_ring(struct audio_softc *sc,
 		r->s.start = hw->allocm(hdl, direction, bufsize,
 					M_DEVBUF, M_WAITOK);
 	else
 		r->s.start = malloc(bufsize, M_DEVBUF, M_WAITOK);
 	if (r->s.start == 0)
 		return ENOMEM;
 	r->s.bufsize = bufsize;
 	return 0;
+}
 void
 audio_free_ring(struct audio_softc *sc, struct audio_ringbuffer *r)
+{
 	if (r->s.start == 0)
 		return;
 	if (sc->hw_if->freem)
 		sc->hw_if->freem(sc->hw_hdl, r->s.start, M_DEVBUF);
 	else
 		free(r->s.start, M_DEVBUF);
 	r->s.start = 0;
+}
 static int
 audio_setup_pfilters(struct audio_softc *sc, const audio_params_t *pp,
 		     stream_filter_list_t *pfilters)
+{
 	stream_filter_t *pf[AUDIO_MAX_FILTERS];
 @@ -1291,84 +1307,98 @@ audio_init_ringbuffer(struct audio_softc
 	rp->copying = false;
 	rp->needfill = false;
 	rp->mmapped = false;
+}
 int
 audio_initbufs(struct audio_softc *sc)
+{
 	const struct audio_hw_if *hw;
 	int error;
 	DPRINTF(("audio_initbufs: mode=0x%x\n", sc->sc_mode));
 	hw = sc->hw_if;
-	audio_init_ringbuffer(sc, &sc->sc_rr, AUMODE_RECORD);
+	if (audio_can_capture(sc)) {
-	if (hw->init_input && (sc->sc_mode & AUMODE_RECORD)) {
+		audio_init_ringbuffer(sc, &sc->sc_rr, AUMODE_RECORD);
-		error = hw->init_input(sc->hw_hdl, sc->sc_rr.s.start,
+		if (hw->init_input && (sc->sc_mode & AUMODE_RECORD)) {
 			error = hw->init_input(sc->hw_hdl, sc->sc_rr.s.start,
 				       sc->sc_rr.s.end - sc->sc_rr.s.start);
-		if (error)
+			if (error)
-			return error;
+				return error;
+		}
+	}
-	audio_init_ringbuffer(sc, &sc->sc_pr, AUMODE_PLAY);
+	if (audio_can_playback(sc)) {
-	sc->sc_sil_count = 0;
+		audio_init_ringbuffer(sc, &sc->sc_pr, AUMODE_PLAY);
-	if (hw->init_output && (sc->sc_mode & AUMODE_PLAY)) {
+		sc->sc_sil_count = 0;
-		error = hw->init_output(sc->hw_hdl, sc->sc_pr.s.start,
+		if (hw->init_output && (sc->sc_mode & AUMODE_PLAY)) {
 			error = hw->init_output(sc->hw_hdl, sc->sc_pr.s.start,
 					sc->sc_pr.s.end - sc->sc_pr.s.start);
-		if (error)
+			if (error)
-			return error;
+				return error;
+		}
+	}
 #ifdef AUDIO_INTR_TIME
 #define double u_long
-	sc->sc_pnintr = 0;
+	if (audio_can_playback(sc)) {
-	sc->sc_pblktime = (u_long)(
+		sc->sc_pnintr = 0;
-	    (double)sc->sc_pr.blksize * 100000 /
+		sc->sc_pblktime = (u_long)(
-	    (double)(sc->sc_pparams.precision / NBBY *
+		    (double)sc->sc_pr.blksize * 100000 /
-		     sc->sc_pparams.channels *
+		    (double)(sc->sc_pparams.precision / NBBY *
-		     sc->sc_pparams.sample_rate)) * 10;
+			     sc->sc_pparams.channels *
-	DPRINTF(("audio: play blktime = %lu for %d\n",
+			     sc->sc_pparams.sample_rate)) * 10;
-		 sc->sc_pblktime, sc->sc_pr.blksize));
+		DPRINTF(("audio: play blktime = %lu for %d\n",
-	sc->sc_rnintr = 0;
+			 sc->sc_pblktime, sc->sc_pr.blksize));
 	sc->sc_rblktime = (u_long)(
-	    (double)sc->sc_rr.blksize * 100000 /
+	if (audio_can_capture(sc)) {
-	    (double)(sc->sc_rparams.precision / NBBY *
+		sc->sc_rnintr = 0;
-		     sc->sc_rparams.channels *
+		sc->sc_rblktime = (u_long)(
-		     sc->sc_rparams.sample_rate)) * 10;
+		    (double)sc->sc_rr.blksize * 100000 /
-	DPRINTF(("audio: record blktime = %lu for %d\n",
+		    (double)(sc->sc_rparams.precision / NBBY *
-		 sc->sc_rblktime, sc->sc_rr.blksize));
+			     sc->sc_rparams.channels *
 			     sc->sc_rparams.sample_rate)) * 10;
 		DPRINTF(("audio: record blktime = %lu for %d\n",
 			 sc->sc_rblktime, sc->sc_rr.blksize));
+	}
 #undef double
 #endif
 	return 0;
+}
 void
 audio_calcwater(struct audio_softc *sc)
+{
 	/* set high at 100% */
-	sc->sc_pr.usedhigh = sc->sc_pustream->end - sc->sc_pustream->start;
+	if (audio_can_playback(sc)) {
-	/* set low at 75% of usedhigh */
+		sc->sc_pr.usedhigh =
-	sc->sc_pr.usedlow = sc->sc_pr.usedhigh * 3 / 4;
+		    sc->sc_pustream->end - sc->sc_pustream->start;
-	if (sc->sc_pr.usedlow == sc->sc_pr.usedhigh)
+		/* set low at 75% of usedhigh */
-		sc->sc_pr.usedlow -= sc->sc_pr.blksize;
+		sc->sc_pr.usedlow = sc->sc_pr.usedhigh * 3 / 4;
 		if (sc->sc_pr.usedlow == sc->sc_pr.usedhigh)
-	sc->sc_rr.usedhigh = sc->sc_rustream->end - sc->sc_rustream->start
+			sc->sc_pr.usedlow -= sc->sc_pr.blksize;
 		- sc->sc_rr.blksize;
 	sc->sc_rr.usedlow = 0;
-	DPRINTF(("%s: plow=%d phigh=%d rlow=%d rhigh=%d\n", __func__,
+	if (audio_can_capture(sc)) {
-		 sc->sc_pr.usedlow, sc->sc_pr.usedhigh,
+		sc->sc_rr.usedhigh =
-		 sc->sc_rr.usedlow, sc->sc_rr.usedhigh));
+		    sc->sc_rustream->end - sc->sc_rustream->start -
 		    sc->sc_rr.blksize;
 		sc->sc_rr.usedlow = 0;
 		DPRINTF(("%s: plow=%d phigh=%d rlow=%d rhigh=%d\n", __func__,
 			 sc->sc_pr.usedlow, sc->sc_pr.usedhigh,
 			 sc->sc_rr.usedlow, sc->sc_rr.usedhigh));
+	}
+}
 static inline int
 audio_sleep_timo(int *chan, const char *label, int timo)
+{
 	int st;
 	if (label == NULL)
 		label = "audio";
 	DPRINTFN(3, ("audio_sleep_timo: chan=%p, label=%s, timo=%d\n",
 		     chan, label, timo));
 	*chan = 1;
 @@ -1426,27 +1456,27 @@ audio_open(dev_t dev, struct audio_softc
+	}
 	sc->sc_async_audio = 0;
 	sc->sc_rchan = 0;
 	sc->sc_wchan = 0;
 	sc->sc_sil_count = 0;
 	sc->sc_rbus = false;
 	sc->sc_pbus = false;
 	sc->sc_eof = 0;
 	sc->sc_playdrop = 0;
 	sc->sc_full_duplex =
 		(flags & (FWRITE|FREAD)) == (FWRITE|FREAD) &&
-		(hw->get_props(sc->hw_hdl) & AUDIO_PROP_FULLDUPLEX);
+		(audio_get_props(sc) & AUDIO_PROP_FULLDUPLEX);
 	mode = 0;
 	if (flags & FREAD) {
 		sc->sc_open |= AUOPEN_READ;
 		mode |= AUMODE_RECORD;
+	}
 	if (flags & FWRITE) {
 		sc->sc_open |= AUOPEN_WRITE;
 		mode |= AUMODE_PLAY | AUMODE_PLAY_ALL;
+	}
 	/*
 	 * Multiplex device: /dev/audio (MU-Law) and /dev/sound (linear)
 @@ -2241,44 +2271,44 @@ audio_ioctl(struct audio_softc *sc, u_lo
 		DPRINTF(("AUDIO_GETENC\n"));
 		error = hw->query_encoding(sc->hw_hdl,
 		    (struct audio_encoding *)addr);
 		break;
 	case AUDIO_GETFD:
 		DPRINTF(("AUDIO_GETFD\n"));
 		*(int *)addr = sc->sc_full_duplex;
 		break;
 	case AUDIO_SETFD:
 		DPRINTF(("AUDIO_SETFD\n"));
 		fd = *(int *)addr;
-		if (hw->get_props(sc->hw_hdl) & AUDIO_PROP_FULLDUPLEX) {
+		if (audio_get_props(sc) & AUDIO_PROP_FULLDUPLEX) {
 			if (hw->setfd)
 				error = hw->setfd(sc->hw_hdl, fd);
 			else
 				error = 0;
 			if (!error)
 				sc->sc_full_duplex = fd;
 		} else {
 			if (fd)
 				error = ENOTTY;
 			else
 				error = 0;
+		}
 		break;
 	case AUDIO_GETPROPS:
 		DPRINTF(("AUDIO_GETPROPS\n"));
-		*(int *)addr = hw->get_props(sc->hw_hdl);
+		*(int *)addr = audio_get_props(sc);
 		break;
 	default:
 		if (hw->dev_ioctl) {
 			error = hw->dev_ioctl(sc->hw_hdl, cmd, addr, flag, l);
 		} else {
 			DPRINTF(("audio_ioctl: unknown ioctl\n"));
 			error = EINVAL;
+		}
 		break;
+	}
 	DPRINTF(("audio_ioctl(%lu,'%c',%lu) result %d\n",
 		 IOCPARM_LEN(cmd), (char)IOCGROUP(cmd), cmd&0xff, error));
 @@ -2429,27 +2459,27 @@ audio_kqfilter(struct audio_softc *sc, s
 	return 0;
+}
 paddr_t
 audio_mmap(struct audio_softc *sc, off_t off, int prot)
+{
 	const struct audio_hw_if *hw;
 	struct audio_ringbuffer *cb;
 	int s;
 	DPRINTF(("audio_mmap: off=%lld, prot=%d\n", (long long)off, prot));
 	hw = sc->hw_if;
-	if (!(hw->get_props(sc->hw_hdl) & AUDIO_PROP_MMAP) || !hw->mappage)
+	if (!(audio_get_props(sc) & AUDIO_PROP_MMAP) || !hw->mappage)
 		return -1;
 #if 0
 /* XXX
  * The idea here was to use the protection to determine if
  * we are mapping the read or write buffer, but it fails.
  * The VM system is broken in (at least) two ways.
  * 1) If you map memory VM_PROT_WRITE you SIGSEGV
  *    when writing to it, so VM_PROT_READ|VM_PROT_WRITE
  *    has to be used for mmapping the play buffer.
  * 2) Even if calling mmap() with VM_PROT_READ|VM_PROT_WRITE
  *    audio_mmap will get called at some point with VM_PROT_READ
  *    only.
  * So, alas, we always map the play buffer for now.
 @@ -2488,52 +2518,58 @@ audio_mmap(struct audio_softc *sc, off_t
 	return hw->mappage(sc->hw_hdl, cb->s.start, off, prot);
+}
 int
 audiostartr(struct audio_softc *sc)
+{
 	int error;
 	DPRINTF(("audiostartr: start=%p used=%d(hi=%d) mmapped=%d\n",
 		 sc->sc_rr.s.start, audio_stream_get_used(&sc->sc_rr.s),
 		 sc->sc_rr.usedhigh, sc->sc_rr.mmapped));
 	if (!audio_can_capture(sc))
 		return EINVAL;
 	if (sc->hw_if->trigger_input)
 		error = sc->hw_if->trigger_input(sc->hw_hdl, sc->sc_rr.s.start,
 		    sc->sc_rr.s.end, sc->sc_rr.blksize,
 		    audio_rint, (void *)sc, &sc->sc_rr.s.param);
 	else
 		error = sc->hw_if->start_input(sc->hw_hdl, sc->sc_rr.s.start,
 		    sc->sc_rr.blksize, audio_rint, (void *)sc);
 	if (error) {
 		DPRINTF(("audiostartr failed: %d\n", error));
 		return error;
+	}
 	sc->sc_rbus = true;
 	return 0;
+}
 int
 audiostartp(struct audio_softc *sc)
+{
 	int error;
 	int used;
 	used = audio_stream_get_used(&sc->sc_pr.s);
 	DPRINTF(("audiostartp: start=%p used=%d(hi=%d blk=%d) mmapped=%d\n",
 		 sc->sc_pr.s.start, used, sc->sc_pr.usedhigh,
 		 sc->sc_pr.blksize, sc->sc_pr.mmapped));
 	if (!audio_can_playback(sc))
 		return EINVAL;
 	if (!sc->sc_pr.mmapped && used < sc->sc_pr.blksize) {
 		wakeup(&sc->sc_wchan);
 		DPRINTF(("%s: wakeup and return\n", __func__));
 		return 0;
+	}
 	if (sc->hw_if->trigger_output) {
 		DPRINTF(("%s: call trigger_output\n", __func__));
 		error = sc->hw_if->trigger_output(sc->hw_hdl, sc->sc_pr.s.start,
 		    sc->sc_pr.s.end, sc->sc_pr.blksize,
 		    audio_pint, (void *)sc, &sc->sc_pr.s.param);
 	} else {
 		DPRINTF(("%s: call start_output\n", __func__));
 @@ -3321,26 +3357,32 @@ audiosetinfo(struct audio_softc *sc, str
 		rp.precision = r->precision;
 		/* we don't have API to specify validbits */
 		rp.validbits = r->precision;
 		nr++;
+	}
 	if (SPECIFIED(p->channels)) {
 		pp.channels = p->channels;
 		np++;
+	}
 	if (SPECIFIED(r->channels)) {
 		rp.channels = r->channels;
 		nr++;
+	}
 	if (!audio_can_capture(sc))
 		nr = 0;
 	if (!audio_can_playback(sc))
 		np = 0;
 #ifdef AUDIO_DEBUG
 	if (audiodebug && nr > 0)
 	    audio_print_params("audiosetinfo() Setting record params:", &rp);
 	if (audiodebug && np > 0)
 	    audio_print_params("audiosetinfo() Setting play params:", &pp);
 #endif
 	if (nr > 0 && (error = audio_check_params(&rp)))
 		return error;
 	if (np > 0 && (error = audio_check_params(&pp)))
 		return error;
 	oldpblksize = sc->sc_pr.blksize;
 	oldrblksize = sc->sc_rr.blksize;
 @@ -3372,27 +3414,27 @@ audiosetinfo(struct audio_softc *sc, str
 		sc->sc_mode = ai->mode;
 		if (sc->sc_mode & AUMODE_PLAY_ALL)
 			sc->sc_mode |= AUMODE_PLAY;
 		if ((sc->sc_mode & AUMODE_PLAY) && !sc->sc_full_duplex)
 			/* Play takes precedence */
 			sc->sc_mode &= ~AUMODE_RECORD;
+	}
 	oldpus = sc->sc_pustream;
 	oldrus = sc->sc_rustream;
 	if (modechange) {
 		int indep;
-		indep = hw->get_props(sc->hw_hdl) & AUDIO_PROP_INDEPENDENT;
+		indep = audio_get_props(sc) & AUDIO_PROP_INDEPENDENT;
 		if (!indep) {
 			if (setmode == AUMODE_RECORD)
 				pp = rp;
 			else if (setmode == AUMODE_PLAY)
 				rp = pp;
+		}
 		memset(&pfilters, 0, sizeof(pfilters));
 		memset(&rfilters, 0, sizeof(rfilters));
 		pfilters.append = stream_filter_list_append;
 		pfilters.prepend = stream_filter_list_prepend;
 		pfilters.set = stream_filter_list_set;
 		rfilters.append = stream_filter_list_append;
 		rfilters.prepend = stream_filter_list_prepend;
 @@ -3706,32 +3748,35 @@ audiogetinfo(struct audio_softc *sc, str
 	r->pause = sc->sc_rr.pause;
 	p->error = sc->sc_pr.drops != 0;
 	r->error = sc->sc_rr.drops != 0;
 	p->waiting = r->waiting = 0;		/* open never hangs */
 	p->open = (sc->sc_open & AUOPEN_WRITE) != 0;
 	r->open = (sc->sc_open & AUOPEN_READ) != 0;
 	p->active = sc->sc_pbus;
 	r->active = sc->sc_rbus;
-	p->buffer_size = sc->sc_pustream->bufsize;
+	p->buffer_size = sc->sc_pustream ? sc->sc_pustream->bufsize : 0;
-	r->buffer_size = sc->sc_rustream->bufsize;
+	r->buffer_size = sc->sc_rustream ? sc->sc_rustream->bufsize : 0;
 	ai->blocksize = sc->sc_pr.blksize;
-	ai->hiwat = sc->sc_pr.usedhigh / sc->sc_pr.blksize;
+	if (sc->sc_pr.blksize > 0) {
-	ai->lowat = sc->sc_pr.usedlow / sc->sc_pr.blksize;
+		ai->hiwat = sc->sc_pr.usedhigh / sc->sc_pr.blksize;
 		ai->lowat = sc->sc_pr.usedlow / sc->sc_pr.blksize;
 	} else
 		ai->hiwat = ai->lowat = 0;
 	ai->mode = sc->sc_mode;
 	return 0;
+}
 /*
  * Mixer driver
  */
 int
 mixer_open(dev_t dev, struct audio_softc *sc, int flags,
     int ifmt, struct lwp *l)
+{
 	if (sc->hw_if == NULL)
 @@ -4127,14 +4172,45 @@ audio_volume_toggle(device_t dv)
 	int s;
 	s = splaudio();
 	au_get_gain(sc, &sc->sc_outports, &gain, &balance);
 	if (gain != 0) {
 		sc->sc_lastgain = gain;
 		newgain = 0;
 	} else
 		newgain = sc->sc_lastgain;
 	au_set_gain(sc, &sc->sc_outports, newgain, balance);
 	splx(s);
+}
 static int
 audio_get_props(struct audio_softc *sc)
+{
 	const struct audio_hw_if *hw;
 	int props;
 	hw = sc->hw_if;
 	props = hw->get_props(sc->hw_hdl);
 	/*
 	 * if neither playback nor capture properties are reported,
 	 * assume both are supported by the device driver
 	 */
 	if ((props & (AUDIO_PROP_PLAYBACK|AUDIO_PROP_CAPTURE)) == 0)
 		props |= (AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE);
 	return props;
+}
 static bool
 audio_can_playback(struct audio_softc *sc)
+{
 	return audio_get_props(sc) & AUDIO_PROP_PLAYBACK ? true : false;
+}
 static bool
 audio_can_capture(struct audio_softc *sc)
+{
 	return audio_get_props(sc) & AUDIO_PROP_CAPTURE ? true : false;
+}
 #endif /* NAUDIO > 0 */

 @@ -1,14 +1,14 @@
-/* $NetBSD: hdaudio_afg.c,v 1.15 2009/09/27 02:36:38 jmcneill Exp $ */
+/* $NetBSD: hdaudio_afg.c,v 1.16 2009/09/29 15:58:54 sborrill Exp $ */
 /*
  * Copyright (c) 2009 Precedence Technologies Ltd <support@precedence.co.uk>
  * Copyright (c) 2009 Jared D. McNeill <jmcneill@invisible.ca>
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Precedence Technologies Ltd
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -50,27 +50,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: hdaudio_afg.c,v 1.15 2009/09/27 02:36:38 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: hdaudio_afg.c,v 1.16 2009/09/29 15:58:54 sborrill Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <sys/bus.h>
 #include <sys/kmem.h>
 #include <sys/audioio.h>
 #include <dev/audio_if.h>
 #include <dev/auconv.h>
 @@ -3313,33 +3313,31 @@ hdaudio_afg_set_params(void *opaque, int
+	}
 	return 0;
+}
 static int
 hdaudio_afg_round_blocksize(void *opaque, int blksize, int mode,
     const audio_params_t *param)
+{
 	struct hdaudio_audiodev *ad = opaque;
 	struct hdaudio_stream *st;
 	int bufsize;
 	st = (mode == AUMODE_PLAY) ? ad->ad_playback : ad->ad_capture;
 #ifdef DIAGNOSTIC
 	if (st == NULL) {
-		hda_error(ad->ad_sc,
+		hda_trace(ad->ad_sc,
 		    "round_blocksize called for invalid stream\n");
-		return 256;
+		return 128;
+	}
 #endif
 	/* Multiple of 128 */
 	blksize &= ~128;
 	if (blksize <= 0)
 		blksize = 128;
 	bufsize = st->st_data.dma_size;
 	if (bufsize > HDAUDIO_BDL_MAX * blksize) {
 		blksize = bufsize / HDAUDIO_BDL_MAX;
 		if (blksize & 128)
 			blksize = (blksize + 128) & ~128;
+	}
 @@ -3573,28 +3571,41 @@ hdaudio_afg_mappage(void *opaque, void *
 	else
 		return -1;
 	if (st->st_data.dma_valid == false)
 		return -1;
 	return bus_dmamem_mmap(st->st_host->sc_dmat, st->st_data.dma_segs,
 	    st->st_data.dma_nsegs, off, prot, BUS_DMA_WAITOK);
+}
 static int
 hdaudio_afg_get_props(void *opaque)
+{
 	struct hdaudio_audiodev *ad = opaque;
 	int props = 0;
 	if (ad->ad_playback)
 		props |= AUDIO_PROP_PLAYBACK;
 	if (ad->ad_capture)
 		props |= AUDIO_PROP_CAPTURE;
 	if (ad->ad_playback && ad->ad_capture) {
 		props |= AUDIO_PROP_FULLDUPLEX;
 		props |= AUDIO_PROP_INDEPENDENT;
+	}
 	/* TODO: AUDIO_PROP_MMAP */
 	return AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
 	return props;
+}
 static int
 hdaudio_afg_trigger_output(void *opaque, void *start, void *end, int blksize,
     void (*intr)(void *), void *intrarg, const audio_params_t *param)
+{
 	struct hdaudio_audiodev *ad = opaque;
 	bus_size_t dmasize;
 	if (ad->ad_playback == NULL)
 		return ENXIO;
 	if (ad->ad_playback->st_data.dma_valid == false)
 		return ENOMEM;

 @@ -1,14 +1,14 @@
-.\"	$NetBSD: audio.4,v 1.69 2009/01/03 17:44:20 christos Exp $
+.\"	$NetBSD: audio.4,v 1.70 2009/09/29 15:58:54 sborrill Exp $
 .\"
 .\" Copyright (c) 1996 The NetBSD Foundation, Inc.
 .\" All rights reserved.
 .\"
 .\" This code is derived from software contributed to The NetBSD Foundation
 .\" by John T. Kohl.
 .\"
 .\" 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
 @@ -17,27 +17,27 @@
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 .\"
-.Dd January 3, 2009
+.Dd September 29, 2009
 .Dt AUDIO 4
 .Os
 .Sh NAME
 .Nm audio
 .Nd device-independent audio driver layer
 .Sh SYNOPSIS
 .In sys/audioio.h
 .Sh DESCRIPTION
 The
 .Nm
 driver provides support for various audio peripherals.
 It provides a uniform programming interface layer above different
 underlying audio hardware drivers.
 @@ -233,26 +233,30 @@ This command gets a bit set of hardware
 If the hardware
 has a certain property the corresponding bit is set, otherwise it is not.
 The properties can have the following values:
 .Pp
 .Bl -tag -width AUDIO_PROP_INDEPENDENT -compact
 .It Dv AUDIO_PROP_FULLDUPLEX
 the device admits full duplex operation.
 .It Dv AUDIO_PROP_MMAP
 the device can be used with
 .Xr mmap 2 .
 .It Dv AUDIO_PROP_INDEPENDENT
 the device can set the playing and recording encoding parameters
 independently.
 .It Dv AUDIO_PROP_PLAYBACK
 the device is capable of audio playback.
 .It Dv AUDIO_PROP_CAPTURE
 the device is capable of audio capture.
 .El
 .It Dv AUDIO_GETIOFFS (audio_offset_t)
 .It Dv AUDIO_GETOOFFS (audio_offset_t)
 This command fetches the current offset in the input(output) buffer where
 the audio hardware's DMA engine will be putting(getting) data.
 It mostly useful when the device
 buffer is available in user space via the
 .Xr mmap 2
 call.
 The information is returned in the audio_offset structure.
 .Bd -literal
 typedef struct audio_offset {
 	u_int	samples;   /* Total number of bytes transferred */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: audio_if.h,v 1.65 2008/03/04 18:23:44 cube Exp $	*/
+/*	$NetBSD: audio_if.h,v 1.66 2009/09/29 15:58:54 sborrill Exp $	*/
 /*
  * Copyright (c) 1994 Havard Eidnes.
  * 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.
 @@ -76,33 +76,35 @@ typedef struct audio_stream {
 	size_t bufsize;		/* allocated memory */
 	uint8_t *start;		/* start of buffer area */
 	uint8_t *end;		/* end of valid buffer area */
 	uint8_t *inp;		/* address to be written next */
 	const uint8_t *outp;	/* address to be read next */
 	int used;		/* valid data size in this stream */
 	audio_params_t param;	/* represents this stream */
 	bool loop;
 } audio_stream_t;
 static __inline int
 audio_stream_get_space(const audio_stream_t *s)
+{
-	return (s->end - s->start) - s->used;
+	if (s)
 		return (s->end - s->start) - s->used;
 	return 0;
+}
 static __inline int
 audio_stream_get_used(const audio_stream_t *s)
+{
-	return s->used;
+	return s ? s->used : 0;
+}
 static __inline uint8_t *
 audio_stream_add_inp(audio_stream_t *s, uint8_t *v, int diff)
+{
 	s->used += diff;
 	v += diff;
 	if (v >= s->end)
 		v -= s->end - s->start;
 	return v;
+}
 static __inline const uint8_t *

 @@ -1,14 +1,14 @@
-/*	$NetBSD: audioio.h,v 1.32 2007/06/11 13:05:47 joerg Exp $	*/
+/*	$NetBSD: audioio.h,v 1.33 2009/09/29 15:58:54 sborrill Exp $	*/
 /*
  * Copyright (c) 1991-1993 Regents of the University of California.
  * 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.
 @@ -175,26 +175,28 @@ typedef struct audio_encoding {
 #define AUDIO_WSEEK	_IOR('A', 25, u_long)
 #define AUDIO_RERROR	_IOR('A', 26, int)
 #define AUDIO_GETDEV	_IOR('A', 27, struct audio_device)
 #define AUDIO_GETENC	_IOWR('A', 28, struct audio_encoding)
 #define AUDIO_GETFD	_IOR('A', 29, int)
 #define AUDIO_SETFD	_IOWR('A', 30, int)
 #define AUDIO_PERROR	_IOR('A', 31, int)
 #define AUDIO_GETIOFFS	_IOR('A', 32, struct audio_offset)
 #define AUDIO_GETOOFFS	_IOR('A', 33, struct audio_offset)
 #define AUDIO_GETPROPS	_IOR('A', 34, int)
 #define  AUDIO_PROP_FULLDUPLEX	0x01
 #define  AUDIO_PROP_MMAP	0x02
 #define  AUDIO_PROP_INDEPENDENT	0x04
 #define  AUDIO_PROP_PLAYBACK	0x10
 #define  AUDIO_PROP_CAPTURE	0x20
 #define AUDIO_GETBUFINFO	_IOR('A', 35, struct audio_info)
 /*
  * Mixer device
  */
 #define AUDIO_MIN_GAIN	0
 #define AUDIO_MAX_GAIN	255
 typedef struct mixer_level {
 	int num_channels;
 	u_char level[8];	/* [num_channels] */
 } mixer_level_t;
 #define AUDIO_MIXER_LEVEL_MONO	0