upstream/illumos/illumos-gate: comparison usr/src/uts/common/io/audio/drv/audiosolo/audiosolo.c

equal deleted inserted replaced

-:538c866aaac6
+:54dc8a89ba0d
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
 /*
-* Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+* Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
 /*
 * Copyright (C) 4Front Technologies 1996-2008.
 };
 /*
 * For the sake of simplicity, this driver fixes a few parameters with
-* constants.  If you want these values to be tunable, upgrade to a
+* constants.
-* nicer and newer device.  This is all tuned for 100 Hz (10
-* millisecs) latency.
 */
 #define	SOLO_RATE	48000
-#define	SOLO_INTRS	100
+#define	SOLO_FRAGFR	1024
-#define	SOLO_FRAGFR	(SOLO_RATE / SOLO_INTRS)
+#define	SOLO_NFRAGS	2
-#define	SOLO_NFRAGS	8
 #define	SOLO_NCHAN	2
 #define	SOLO_SAMPSZ	2
 #define	SOLO_FRAGSZ	(SOLO_FRAGFR * (SOLO_NCHAN * SOLO_SAMPSZ))
 #define	SOLO_BUFFR	(SOLO_NFRAGS * SOLO_FRAGFR)
 #define	SOLO_BUFSZ	(SOLO_NFRAGS * SOLO_FRAGSZ)
 	ddi_acc_handle_t	acch;
 	caddr_t			kaddr;
 	uint32_t		paddr;
 	bool			started;
+	bool			trigger;
 	uint64_t		count;
 	uint16_t		offset;
 	int			syncdir;
 	int			format;
 	bool			swapped;
 static uint_t
 solo_intr(caddr_t arg1, caddr_t arg2)
 {
 	solo_dev_t	*dev = (void *)arg1;
-	audio_engine_t	*prod = NULL;
-	audio_engine_t	*cons = NULL;
 	uint8_t		status;
 	uint_t		rv = DDI_INTR_UNCLAIMED;
 	_NOTE(ARGUNUSED(arg2));
 	}
 	status = PORT_RD8(dev->io, 0x7);
 	if (status & 0x20) {
 		rv = DDI_INTR_CLAIMED;
-		cons = dev->play.engine;
 		/* ack the interrupt */
 		solo_setmixer(dev, 0x7a, solo_getmixer(dev, 0x7a) & ~0x80);
 	}
 	if (status & 0x10) {
 		rv = DDI_INTR_CLAIMED;
-		prod = dev->rec.engine;
 		/* ack the interrupt */
 		(void) PORT_RD8(dev->sb, 0xe);
 	}
 	mutex_exit(&dev->mutex);
-	if (cons) {
-		audio_engine_consume(cons);
-	}
-	if (prod) {
-		audio_engine_produce(prod);
-	}
 	return (rv);
 }
 static uint8_t
 	if ((val & ~INSRCS) != 0)
 		return (EINVAL);
 	mutex_enter(&dev->mutex);
 	pc->val = val;
-	if (!dev->suspended)
+	solo_configure_mixer(dev);
-		solo_configure_mixer(dev);
 	mutex_exit(&dev->mutex);
 	return (0);
 }
 static int
 	val = (val & 0xff) | ((val & 0xff) << 8);
 	mutex_enter(&dev->mutex);
 	pc->val = val;
-	if (!dev->suspended)
+	solo_configure_mixer(dev);
-		solo_configure_mixer(dev);
 	mutex_exit(&dev->mutex);
 	return (0);
 }
 static int
 	if ((l > 100) || (r > 100))
 		return (EINVAL);
 	mutex_enter(&dev->mutex);
 	pc->val = val;
-	if (!dev->suspended)
+	solo_configure_mixer(dev);
-		solo_configure_mixer(dev);
 	mutex_exit(&dev->mutex);
 	return (0);
 }
 static int
 	solo_ctrl_t	*pc = arg;
 	solo_dev_t	*dev = pc->dev;
 	mutex_enter(&dev->mutex);
 	pc->val = val;
-	if (!dev->suspended)
+	solo_configure_mixer(dev);
-		solo_configure_mixer(dev);
 	mutex_exit(&dev->mutex);
 	return (0);
 }
 static int
 	solo_dev_t	*dev = e->dev;
 	uint16_t	offset, n;
 	uint32_t	ptr;
 	uint32_t	count;
 	uint32_t	diff;
+	int		tries;
 	ASSERT(mutex_owned(&dev->mutex));
 	/*
 	 * During recording, this register is known to give back
 	 * garbage if it's not quiescent while being read.  This hack
-	 * attempts to work around it.
+	 * attempts to work around it.  We also suspend the DMA
+	 * while we do this, to minimize record distortion.
 	 */
-	ptr = PORT_RD32(dev->vc, 0);
+	if (e->trigger) {
-	count = PORT_RD16(dev->vc, 4);
+		drv_usecwait(20);
-	diff = e->paddr + SOLO_BUFSZ - ptr - count;
+	}
-	if ((diff > 3) || (ptr < e->paddr) ||
+	for (tries = 10; tries; tries--) {
-	    (ptr >= (e->paddr + SOLO_BUFSZ))) {
+		drv_usecwait(10);
-		ptr = dev->last_capture;
+		ptr = PORT_RD32(dev->vc, 0);
-	} else {
+		count = PORT_RD16(dev->vc, 4);
-		dev->last_capture = ptr;
+		diff = e->paddr + SOLO_BUFSZ - ptr - count;
-	}
+		if ((diff > 3) || (ptr < e->paddr) ||
+		    (ptr >= (e->paddr + SOLO_BUFSZ))) {
+			ptr = dev->last_capture;
+		} else {
+			break;
+		}
+	}
+	if (e->trigger) {
+		PORT_WR8(dev->vc, 0xf, 0);	/* restart DMA */
+	}
+	if (!tries) {
+		/*
+		 * Note, this is a pretty bad situation, because we'll
+		 * not have an accurate idea of our position.  But its
+		 * better than making a bad alteration.  If we had FMA
+		 * for audio devices, this would be a good point to
+		 * raise a fault.
+		 */
+		return;
+	}
+	dev->last_capture = ptr;
 	offset = ptr - e->paddr;
 	offset /= (SOLO_NCHAN * SOLO_SAMPSZ);
 	n = offset >= e->offset ?
 	    offset - e->offset :
 	/* autoinit, dma dir, go for it */
 	solo_write(dev, 0xb8, 0x0f);
 	PORT_WR8(dev->vc, 0xf, 0);	/* start DMA */
 	dev->last_capture = e->paddr;
+	e->trigger = true;
 }
 static void
 solo_aud1_stop(solo_engine_t *e)
 {
 	solo_dev_t	*dev = e->dev;
 	/* NB: We might be in quiesce, without a lock held */
 	solo_write(dev, 0xb8, solo_read(dev, 0xb8) & ~0x01);
+	e->trigger = false;
 }
 static void
 solo_aud2_update(solo_engine_t *e)
 {
 	PORT_WR8(dev->io, 0x6, 0x0a); /* autoinit, enable */
 	v = solo_mixer_scale(dev, CTL_VOLUME);
 	v = v | (v << 4);
 	solo_setmixer(dev, 0x7c, v & 0xff);
+	e->trigger = true;
 }
 static void
 solo_aud2_stop(solo_engine_t *e)
 {
 	solo_dev_t	*dev = e->dev;
 	/* NB: We might be in quiesce, without a lock held */
 	PORT_WR8(dev->io, 0x6, 0);
 	solo_setmixer(dev, 0x78, solo_getmixer(dev, 0x78) & ~0x03);
+	e->trigger = false;
 }
 /*
 * Audio entry points.
 */
 	solo_engine_t	*e = arg;
 	solo_dev_t	*dev = e->dev;
 	uint64_t	count;
 	mutex_enter(&dev->mutex);
-	if (!dev->suspended)
+	e->update(e);
-		e->update(e);
 	count = e->count;
 	mutex_exit(&dev->mutex);
 	return (count);
 }
 static int
-solo_open(void *arg, int f, unsigned *ffr, unsigned *nfr, caddr_t *buf)
+solo_open(void *arg, int f, unsigned *nframes, caddr_t *buf)
 {
 	solo_engine_t	*e = arg;
 	solo_dev_t	*dev = e->dev;
 	_NOTE(ARGUNUSED(f));
-	/* NB: For simplicity, we just fix the interrupt rate at 100 Hz */
+	*nframes = SOLO_NFRAGS * SOLO_FRAGFR;
-	*ffr = SOLO_FRAGFR;
-	*nfr = SOLO_NFRAGS;
 	*buf = e->kaddr;
 	mutex_enter(&dev->mutex);
 	e->started = false;
 	e->count = 0;
 {
 	solo_engine_t	*e = arg;
 	solo_dev_t	*dev = e->dev;
 	mutex_enter(&dev->mutex);
-	if (!dev->suspended)
+	e->stop(e);
-		e->stop(e);
 	e->started = false;
 	mutex_exit(&dev->mutex);
 }
 	solo_engine_t	*e = arg;
 	solo_dev_t	*dev = e->dev;
 	mutex_enter(&dev->mutex);
 	if (!e->started) {
-		if (!dev->suspended)
+		e->start(e);
-			e->start(e);
 		e->started = true;
 	}
 	mutex_exit(&dev->mutex);
 	return (0);
 	solo_engine_t	*e = arg;
 	solo_dev_t	*dev = e->dev;
 	mutex_enter(&dev->mutex);
 	if (e->started) {
-		if (!dev->suspended)
+		e->stop(e);
-			e->stop(e);
 		e->started = false;
 	}
 	mutex_exit(&dev->mutex);
 }
 static int
 solo_suspend(solo_dev_t *dev)
 {
+	audio_dev_suspend(dev->adev);
 	mutex_enter(&dev->mutex);
-	/* play */
-	solo_aud2_stop(&dev->play);
-	solo_aud2_update(&dev->play);
-	/* record */
-	solo_aud1_stop(&dev->rec);
-	solo_aud1_update(&dev->rec);
 	dev->suspended = true;
 	mutex_exit(&dev->mutex);
 	return (DDI_SUCCESS);
 }
 static int
 solo_resume(solo_dev_t *dev)
 {
-	solo_engine_t	*e;
-	audio_engine_t	*prod = NULL;
-	audio_engine_t	*cons = NULL;
-	audio_engine_reset(dev->rec.engine);
-	audio_engine_reset(dev->play.engine);
 	mutex_enter(&dev->mutex);
 	if (!solo_init_hw(dev)) {
 		/* yikes! */
 		audio_dev_warn(dev->adev, "unable to resume audio!");
 		audio_dev_warn(dev->adev, "reboot or reload driver to reset");
-		mutex_exit(&dev->mutex);
-		return (DDI_SUCCESS);
 	}
 	dev->suspended = false;
-	/* record - audio 1 */
-	e = &dev->rec;
-	if (e->started) {
-		e->start(e);
-		prod = e->engine;
-	}
-	/* play - audio 2 */
-	e = &dev->play;
-	if (e->started) {
-		e->start(e);
-		cons = e->engine;
-	}
 	mutex_exit(&dev->mutex);
-	if (cons)
+	audio_dev_resume(dev->adev);
-		audio_engine_consume(cons);
-	if (prod)
-		audio_engine_produce(prod);
 	return (DDI_SUCCESS);
 }
 static int

changeset 11936	54dc8a89ba0d
parent 11385	ede182582de2