upstream/illumos/illumos-gate: comparison usr/src/uts/common/io/audio/impl/audio

equal deleted inserted replaced

-:538c866aaac6
+:54dc8a89ba0d
 * CDDL HEADER END
 */
 /*
 * Copyright (C) 4Front Technologies 1996-2008.
 *
-* Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+* Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
 #include <sys/types.h>
 #include <sys/sysmacros.h>
 auclnt_get_rate(audio_stream_t *sp)
 {
 	return (sp->s_user_parms->p_rate);
 }
-unsigned
+uint_t
 auclnt_get_fragsz(audio_stream_t *sp)
 {
 	return (sp->s_fragbytes);
 }
-unsigned
+uint_t
 auclnt_get_framesz(audio_stream_t *sp)
 {
 	return (sp->s_framesz);
 }
-unsigned
+uint_t
 auclnt_get_nfrags(audio_stream_t *sp)
 {
 	return (sp->s_nfrags);
 }
-unsigned
+uint_t
 auclnt_get_nframes(audio_stream_t *sp)
 {
 	return (sp->s_nframes);
 }
 void
-auclnt_set_latency(audio_stream_t *sp, unsigned frags, unsigned bytes)
+auclnt_set_latency(audio_stream_t *sp, uint_t frags, uint_t bytes)
 {
 	mutex_enter(&sp->s_lock);
 	sp->s_hintfrags = (uint16_t)frags;
 	sp->s_hintsz = bytes;
 	mutex_exit(&sp->s_lock);
 auclnt_get_tail(audio_stream_t *sp)
 {
 	return (sp->s_tail);
 }
-unsigned
+uint_t
 auclnt_get_hidx(audio_stream_t *sp)
 {
 	return (sp->s_hidx);
 }
-unsigned
+uint_t
 auclnt_get_tidx(audio_stream_t *sp)
 {
 	return (sp->s_tidx);
 }
 auclnt_output_stream(audio_client_t *c)
 {
 	return (&c->c_ostream);
 }
-unsigned
+uint_t
 auclnt_get_count(audio_stream_t *sp)
 {
-	unsigned	count;
+	uint_t	count;
 	mutex_enter(&sp->s_lock);
 	ASSERT((sp->s_head - sp->s_tail) <= sp->s_nframes);
-	count = (unsigned)(sp->s_head - sp->s_tail);
+	count = (uint_t)(sp->s_head - sp->s_tail);
 	mutex_exit(&sp->s_lock);
 	return (count);
 }
-unsigned
+uint_t
-auclnt_consume(audio_stream_t *sp, unsigned n)
+auclnt_consume(audio_stream_t *sp, uint_t n)
 {
 	mutex_enter(&sp->s_lock);
 	ASSERT(sp == &sp->s_client->c_istream);
 	n = max(n, sp->s_head - sp->s_tail);
 	mutex_exit(&sp->s_lock);
 	return (n);
 }
-unsigned
+uint_t
-auclnt_consume_data(audio_stream_t *sp, caddr_t dst, unsigned n)
+auclnt_consume_data(audio_stream_t *sp, caddr_t dst, uint_t n)
 {
-	unsigned nframes;
+	uint_t nframes;
-	unsigned framesz;
+	uint_t framesz;
-	unsigned cnt;
+	uint_t cnt;
 	caddr_t	data;
 	mutex_enter(&sp->s_lock);
 	nframes = sp->s_nframes;
 	ASSERT(sp->s_hidx < nframes);
 	cnt = n = min(n, sp->s_head - sp->s_tail);
 	data = sp->s_data + (sp->s_tidx * framesz);
 	do {
-		unsigned nf, nb;
+		uint_t nf, nb;
 		nf = min(nframes - sp->s_tidx, n);
 		nb = nf * framesz;
 		bcopy(data, dst, nb);
 	mutex_exit(&sp->s_lock);
 	return (cnt);
 }
-unsigned
+uint_t
-auclnt_produce(audio_stream_t *sp, unsigned n)
+auclnt_produce(audio_stream_t *sp, uint_t n)
 {
 	mutex_enter(&sp->s_lock);
 	ASSERT(sp == &sp->s_client->c_ostream);
 	n = max(n, sp->s_nframes - (sp->s_head - sp->s_tail));
 	mutex_exit(&sp->s_lock);
 	return (n);
 }
-unsigned
+uint_t
-auclnt_produce_data(audio_stream_t *sp, caddr_t src, unsigned n)
+auclnt_produce_data(audio_stream_t *sp, caddr_t src, uint_t n)
 {
-	unsigned nframes;
+	uint_t nframes;
-	unsigned framesz;
+	uint_t framesz;
-	unsigned cnt;
+	uint_t cnt;
 	caddr_t data;
 	mutex_enter(&sp->s_lock);
 	nframes = sp->s_nframes;
 	ASSERT(sp->s_hidx < nframes);
 	cnt = n = min(n, nframes - (sp->s_head - sp->s_tail));
 	data = sp->s_data + (sp->s_hidx * framesz);
 	do {
-		unsigned nf, nb;
+		uint_t nf, nb;
 		nf = min(nframes - sp->s_hidx, n);
 		nb = nf * framesz;
 		bcopy(src, data, nb);
 int
 auclnt_read(audio_client_t *c, struct uio *uio)
 {
 	audio_stream_t	*sp = &c->c_istream;
-	unsigned	cnt;
+	uint_t		cnt;
 	int		rv = 0;
 	offset_t	loff;
 	int		eagain;
+	uint_t		tidx;
+	uint_t		framesz;
 	loff = uio->uio_loffset;
 	eagain = EAGAIN;
 	mutex_enter(&sp->s_lock);
 		mutex_exit(&sp->s_lock);
 		auclnt_start(sp);
 		mutex_enter(&sp->s_lock);
 	}
+	framesz = sp->s_framesz;
 	ASSERT(sp->s_head >= sp->s_tail);
 	ASSERT(sp->s_tidx < sp->s_nframes);
-	ASSERT(sp->s_hidx < sp->s_nframes);
+	while (uio->uio_resid >= framesz) {
-	while (uio->uio_resid >= sp->s_framesz) {
 		while ((cnt = (sp->s_head - sp->s_tail)) == 0) {
 			if (uio->uio_fmode & (FNONBLOCK|FNDELAY)) {
 				mutex_exit(&sp->s_lock);
 				return (eagain);
 				mutex_exit(&sp->s_lock);
 				return (EINTR);
 			}
 		}
-		cnt = min(cnt, sp->s_nframes - sp->s_tidx);
+		tidx = sp->s_tidx;
-		cnt = min(cnt, (uio->uio_resid / sp->s_framesz));
+		cnt = min(cnt, sp->s_nframes - tidx);
+		cnt = min(cnt, (uio->uio_resid / framesz));
-		rv = uiomove(sp->s_data + (sp->s_tidx * sp->s_framesz),
-		    cnt * sp->s_framesz, UIO_READ, uio);
+		mutex_exit(&sp->s_lock);
+		rv = uiomove(sp->s_data + (tidx * framesz),
+		    cnt * framesz, UIO_READ, uio);
 		uio->uio_loffset = loff;
 		eagain = 0;
 		if (rv != 0) {
-			mutex_exit(&sp->s_lock);
 			return (rv);
 		}
+		mutex_enter(&sp->s_lock);
 		sp->s_tail += cnt;
 		sp->s_tidx += cnt;
 		if (sp->s_tidx == sp->s_nframes) {
 			sp->s_tidx = 0;
 		}
 int
 auclnt_write(audio_client_t *c, struct uio *uio)
 {
 	audio_stream_t *sp = &c->c_ostream;
-	unsigned	cnt;
+	uint_t		cnt;
 	int		rv = 0;
 	offset_t	loff;
 	int		eagain;
+	uint_t		framesz;
+	uint_t		hidx;
 	loff = uio->uio_loffset;
 	eagain = EAGAIN;
 	mutex_enter(&sp->s_lock);
+	framesz = sp->s_framesz;
 	ASSERT(sp->s_head >= sp->s_tail);
-	ASSERT(sp->s_tidx < sp->s_nframes);
 	ASSERT(sp->s_hidx < sp->s_nframes);
-	while (uio->uio_resid >= sp->s_framesz) {
+	while (uio->uio_resid >= framesz) {
 		while ((cnt = sp->s_nframes - (sp->s_head - sp->s_tail)) == 0) {
 			if (uio->uio_fmode & (FNONBLOCK|FNDELAY)) {
 				mutex_exit(&sp->s_lock);
 				return (eagain);
 				mutex_exit(&sp->s_lock);
 				return (EINTR);
 			}
 		}
-		cnt = min(cnt, sp->s_nframes - sp->s_hidx);
+		hidx = sp->s_hidx;
-		cnt = min(cnt, (uio->uio_resid / sp->s_framesz));
+		cnt = min(cnt, sp->s_nframes - hidx);
+		cnt = min(cnt, (uio->uio_resid / framesz));
-		rv = uiomove(sp->s_data + (sp->s_hidx * sp->s_framesz),
-		    cnt * sp->s_framesz, UIO_WRITE, uio);
+		/*
+		 * We have to drop the stream lock, because the
+		 * uiomove might require doing a page in, which could
+		 * get blocked behind the PIL of the audio processing
+		 * thread which also grabs the s_lock.  (Hence, there
+		 * is a risk of deadlock due to priority inversion.)
+		 */
+		mutex_exit(&sp->s_lock);
+		rv = uiomove(sp->s_data + (hidx * framesz),
+		    cnt * framesz, UIO_WRITE, uio);
 		uio->uio_loffset = loff;
 		eagain = 0;
 		if (rv != 0) {
-			mutex_exit(&sp->s_lock);
 			return (rv);
 		}
+		mutex_enter(&sp->s_lock);
 		sp->s_head += cnt;
 		sp->s_hidx += cnt;
 		if (sp->s_hidx == sp->s_nframes) {
 			sp->s_hidx = 0;
 {
 	pollwakeup(&c->c_pollhead, events);
 }
 void
-auclnt_get_output_qlen(audio_client_t *c, unsigned *slen, unsigned *flen)
+auclnt_get_output_qlen(audio_client_t *c, uint_t *slen, uint_t *flen)
 {
 	audio_stream_t	*sp = &c->c_ostream;
 	audio_engine_t	*e = sp->s_engine;
 	uint64_t	el, sl;
-	unsigned	cnt, er, sr;
+	uint_t		cnt, er, sr;
 	if (e == NULL) {
 		/* if no output engine, can't do it! */
 		*slen = 0;
 		*flen = 0;
 		el = (e->e_head - e->e_tail);
 	}
 	er = e->e_rate;
 	sl = sp->s_cnv_cnt;
 	sr = sp->s_user_parms->p_rate;
-	cnt = (unsigned)(sp->s_head - sp->s_tail);
+	cnt = (uint_t)(sp->s_head - sp->s_tail);
 	mutex_exit(&sp->s_lock);
 	mutex_exit(&e->e_lock);
 	/* engine frames converted to stream rate, plus stream frames */
 	*slen = cnt;
-	*flen = ((unsigned)(((el * sr) / er) + sl));
+	*flen = ((uint_t)(((el * sr) / er) + sl));
 }
 int
 auclnt_set_format(audio_stream_t *sp, int fmt)
 {
 	}
 	rw_exit(&auimpl_client_lock);
 	return (c);
 }
+int
+auclnt_serialize(audio_client_t *c)
+{
+	mutex_enter(&c->c_lock);
+	while (c->c_serialize) {
+		if (cv_wait_sig(&c->c_cv, &c->c_lock) == 0) {
+			mutex_exit(&c->c_lock);
+			return (EINTR);
+		}
+	}
+	c->c_serialize = B_TRUE;
+	mutex_exit(&c->c_lock);
+	return (0);
+}
+void
+auclnt_unserialize(audio_client_t *c)
+{
+	mutex_enter(&c->c_lock);
+	ASSERT(c->c_serialize);
+	c->c_serialize = B_FALSE;
+	cv_broadcast(&c->c_cv);
+	mutex_exit(&c->c_lock);
+}
+void
+auclnt_hold(audio_client_t *c)
+{
+	mutex_enter(&c->c_lock);
+	c->c_refcnt++;
+	mutex_exit(&c->c_lock);
+}
 void
 auclnt_release(audio_client_t *c)
 {
 	mutex_enter(&c->c_lock);
 	ASSERT(c->c_refcnt > 0);
 	if (c->c_refcnt == 0)
 		cv_broadcast(&c->c_cv);
 	mutex_exit(&c->c_lock);
 }
-unsigned
+uint_t
 auclnt_dev_get_serial(audio_dev_t *d)
 {
 	return (d->d_serial);
 }
 	rw_exit(&auimpl_client_lock);
 }
 int
-auclnt_open(audio_client_t *c, unsigned fmts, int oflag)
+auclnt_open(audio_client_t *c, uint_t fmts, int oflag)
 {
 	audio_stream_t	*sp;
 	audio_dev_t	*d = c->c_dev;
 	int		rv = 0;
 	int		flags;
 auclnt_get_dev_version(audio_dev_t *dev)
 {
 	return (dev->d_vers);
 }
-unsigned
+uint_t
 auclnt_get_dev_capab(audio_dev_t *dev)
 {
 	uint32_t	flags;
-	unsigned	caps = 0;
+	uint_t		caps = 0;
 	flags = dev->d_flags;
 	if (flags & DEV_OUTPUT_CAP)
 		caps |= AUDIO_CLIENT_CAP_PLAY;
 int (*walker)(audio_ctrl_t *, void *),
 void *arg)
 {
 	audio_ctrl_t *ctrl;
-	rw_enter(&d->d_ctrl_lock, RW_READER);
+	mutex_enter(&d->d_ctrl_lock);
 	for (ctrl = list_head(&d->d_controls); ctrl;
 	    ctrl = list_next(&d->d_controls, ctrl)) {
 		if (walker(ctrl, arg) == AUDIO_WALK_STOP)
 			break;
 	}
-	rw_exit(&d->d_ctrl_lock);
+	mutex_exit(&d->d_ctrl_lock);
 }
 /*
 * This will search all controls attached to an
 * audio device for a control with the desired name.
 	audio_ctrl_t *ctrl;
 	/* Verify argument */
 	ASSERT(d);
-	rw_enter(&d->d_ctrl_lock, RW_READER);
+	mutex_enter(&d->d_ctrl_lock);
 	for (ctrl = list_head(&d->d_controls); ctrl;
 	    ctrl = list_next(&d->d_controls, ctrl)) {
 		if (strcmp(ctrl->ctrl_name, name) == 0) {
-			rw_exit(&d->d_ctrl_lock);
+			mutex_exit(&d->d_ctrl_lock);
 			return (ctrl);
 		}
 	}
-	rw_exit(&d->d_ctrl_lock);
+	mutex_exit(&d->d_ctrl_lock);
 	return (NULL);
 }
 /*
 * Given a known control, get its attributes.

changeset 11936	54dc8a89ba0d
parent 11213	497b84226e09
child 12165	e481916a5729