path: root/usr/src/uts/common/io/audio/drv/audiosolo/audiosolo.c

/*
 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
 *
 * 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.
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (C) 4Front Technologies 1996-2008.
 */

#include <sys/audio/audio_driver.h>
#include <sys/note.h>
#include <sys/pci.h>
#include <sys/stdbool.h>


/*
 * NB: The Solo-1 is a bit schizophrenic compared to most devices.
 * It has two separate DMA engines for PCM data.  The first can do
 * either capture or playback, and supports various Sound Blaster
 * compatibility features.  The second is dedicated to playback.  The
 * two engines have very little in common when it comes to programming
 * them.
 *
 * We configure engine 1 for record, and engine 2 for playback.  Both
 * are configured for 48 kHz stereo 16-bit signed PCM.
 */

/*
 * ESS Solo-1 only implements the low 24-bits on Audio1, and requires
 * 64KB alignment.  For Audio2, it implements the full 32-bit address
 * space, but requires a 1MB address boundary.  Audio1 is used for
 * recording, and Audio2 is used for playback.
 */
static struct ddi_dma_attr dma_attr_audio1 = {
	DMA_ATTR_VERSION,	/* dma_attr_version */
	0x0,			/* dma_attr_addr_lo */
	0x00ffffffU,		/* dma_attr_addr_hi */
	0xffff,			/* dma_attr_count_max */
	0x10000,		/* dma_attr_align */
	0x7f,			/* dma_attr_burstsizes */
	0x4,			/* dma_attr_minxfer */
	0xffff,			/* dma_attr_maxxfer */
	0xffff,			/* dma_attr_seg */
	0x1,			/* dma_attr_sgllen */
	0x1,			/* dma_attr_granular */
	0			/* dma_attr_flags */
};

static struct ddi_dma_attr dma_attr_audio2 = {
	DMA_ATTR_VERSION,	/* dma_attr_version */
	0x0,			/* dma_attr_addr_lo */
	0xffffffffU,		/* dma_attr_addr_hi */
	0xfff0,			/* dma_attr_count_max */
	0x100000,		/* dma_attr_align */
	0x7f,			/* dma_attr_burstsizes */
	0x4,			/* dma_attr_minxfer */
	0xfff0,			/* dma_attr_maxxfer */
	0xffff,			/* dma_attr_seg */
	0x1,			/* dma_attr_sgllen */
	0x1,			/* dma_attr_granular */
	0			/* dma_attr_flags */
};

static ddi_device_acc_attr_t acc_attr = {
	DDI_DEVICE_ATTR_V0,
	DDI_STRUCTURE_LE_ACC,
	DDI_STRICTORDER_ACC
};

static ddi_device_acc_attr_t buf_attr = {
	DDI_DEVICE_ATTR_V0,
	DDI_NEVERSWAP_ACC,
	DDI_STRICTORDER_ACC
};


/*
 * For the sake of simplicity, this driver fixes a few parameters with
 * constants.
 */
#define	SOLO_RATE	48000
#define	SOLO_FRAGFR	1024
#define	SOLO_NFRAGS	2
#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)

#define	INPUT_MIC	0
#define	INPUT_LINE	1
#define	INPUT_CD	2
#define	INPUT_AUX	3
#define	INPUT_MONO	4
#define	INSRCS		0x1f		/* bits 0-4 */

#define	DRVNAME		"audiosolo"

static const char *solo_insrcs[] = {
	AUDIO_PORT_MIC,
	AUDIO_PORT_LINEIN,
	AUDIO_PORT_CD,
	AUDIO_PORT_AUX1IN,
	AUDIO_PORT_AUX2IN,	/* this is really mono-in */
	NULL
};

typedef struct solo_regs {
	ddi_acc_handle_t	acch;
	caddr_t			base;
} solo_regs_t;

typedef struct solo_engine {
	struct solo_dev		*dev;
	audio_engine_t		*engine;
	ddi_dma_handle_t	dmah;
	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;

	void			(*start)(struct solo_engine *);
	void			(*stop)(struct solo_engine *);
	void			(*update)(struct solo_engine *);
} solo_engine_t;

typedef enum {
	CTL_FRONT = 0,
	CTL_VOLUME,
	CTL_MIC,
	CTL_LINE,
	CTL_CD,
	CTL_AUX,
	CTL_MONO,
	CTL_MICBOOST,
	CTL_RECGAIN,
	CTL_RECSRC,
	CTL_MONSRC,
	CTL_SPEAKER,
	CTL_LOOPBACK,
	CTL_NUM,			/* must be last */
} solo_ctrl_num_t;

typedef struct solo_ctrl {
	struct solo_dev		*dev;
	audio_ctrl_t		*ctrl;
	solo_ctrl_num_t		num;
	uint64_t		val;
} solo_ctrl_t;

typedef struct solo_dev {
	dev_info_t		*dip;
	audio_dev_t		*adev;
	kmutex_t		mutex;
	ddi_intr_handle_t	ihandle;

	bool			suspended;

	/*
	 * Audio engines
	 */
	solo_engine_t		rec;
	solo_engine_t		play;
	uint32_t		last_capture;

	/*
	 * Controls.
	 */
	solo_ctrl_t		ctrls[CTL_NUM];

	/*
	 * Mapped registers
	 */
	ddi_acc_handle_t	pcih;
	solo_regs_t		io;
	solo_regs_t		sb;
	solo_regs_t		vc;

} solo_dev_t;

/*
 * Common code for the pcm function
 *
 * solo_cmd write a single byte to the CMD port.
 * solo_cmd1 write a CMD + 1 byte arg
 * ess_get_byte returns a single byte from the DSP data port
 *
 * solo_write is actually solo_cmd1
 * solo_read access ext. regs via solo_cmd(0xc0, reg) followed by solo_get_byte
 */

#define	PORT_RD8(port, regno)		\
	ddi_get8(port.acch, (void *)(port.base + (regno)))
#define	PORT_RD16(port, regno)		\
	ddi_get16(port.acch, (void *)(port.base + (regno)))
#define	PORT_RD32(port, regno)		\
	ddi_get32(port.acch, (void *)(port.base + (regno)))
#define	PORT_WR8(port, regno, data)	\
	ddi_put8(port.acch, (void *)(port.base + (regno)), data)
#define	PORT_WR16(port, regno, data)	\
	ddi_put16(port.acch, (void *)(port.base + (regno)), data)
#define	PORT_WR32(port, regno, data)	\
	ddi_put32(port.acch, (void *)(port.base + (regno)), data)

static bool
solo_dspready(solo_dev_t *dev)
{
	return ((PORT_RD8(dev->sb, 0xc) & 0x80) == 0 ? true : false);
}

static bool
solo_dspwr(solo_dev_t *dev, uint8_t val)
{
	int  i;

	for (i = 0; i < 1000; i++) {
		if (solo_dspready(dev)) {
			PORT_WR8(dev->sb, 0xc, val);
			return (true);
		}
		if (i > 10)
			drv_usecwait((i > 100)? 1000 : 10);
	}
	audio_dev_warn(dev->adev, "solo_dspwr(0x%02x) timed out", val);
	return (false);
}

static bool
solo_cmd(solo_dev_t *dev, uint8_t val)
{
	return (solo_dspwr(dev, val));
}

static void
solo_cmd1(solo_dev_t *dev, uint8_t cmd, uint8_t val)
{
	if (solo_dspwr(dev, cmd)) {
		(void) solo_dspwr(dev, val);
	}
}

static void
solo_setmixer(solo_dev_t *dev, uint8_t port, uint8_t value)
{
	PORT_WR8(dev->sb, 0x4, port); /* Select register */
	drv_usecwait(10);
	PORT_WR8(dev->sb, 0x5, value);
	drv_usecwait(10);
}

static uint8_t
solo_getmixer(solo_dev_t *dev, uint8_t port)
{
	uint8_t val;

	PORT_WR8(dev->sb, 0x4, port); /* Select register */
	drv_usecwait(10);
	val = PORT_RD8(dev->sb, 0x5);
	drv_usecwait(10);

	return (val);
}

static uint8_t
solo_get_byte(solo_dev_t *dev)
{
	for (int i = 1000; i > 0; i--) {
		if (PORT_RD8(dev->sb, 0xc) & 0x40)
			return (PORT_RD8(dev->sb, 0xa));
		else
			drv_usecwait(20);
	}
	audio_dev_warn(dev->adev, "timeout waiting to read DSP port");
	return (0xff);
}

static void
solo_write(solo_dev_t *dev, uint8_t reg, uint8_t val)
{
	solo_cmd1(dev, reg, val);
}

static uint8_t
solo_read(solo_dev_t *dev, uint8_t reg)
{
	if (solo_cmd(dev, 0xc0) && solo_cmd(dev, reg)) {
		return (solo_get_byte(dev));
	}
	return (0xff);
}

static bool
solo_reset_dsp(solo_dev_t *dev)
{
	PORT_WR8(dev->sb, 0x6, 3);
	drv_usecwait(100);
	PORT_WR8(dev->sb, 0x6, 0);
	if (solo_get_byte(dev) != 0xAA) {
		audio_dev_warn(dev->adev, "solo_reset_dsp failed");
		return (false);	/* Sorry */
	}
	return (true);
}

static uint_t
solo_intr(caddr_t arg1, caddr_t arg2)
{
	solo_dev_t	*dev = (void *)arg1;
	uint8_t		status;
	uint_t		rv = DDI_INTR_UNCLAIMED;

	_NOTE(ARGUNUSED(arg2));

	mutex_enter(&dev->mutex);

	if (dev->suspended) {
		mutex_exit(&dev->mutex);
		return (rv);
	}

	status = PORT_RD8(dev->io, 0x7);
	if (status & 0x20) {
		rv = DDI_INTR_CLAIMED;
		/* ack the interrupt */
		solo_setmixer(dev, 0x7a, solo_getmixer(dev, 0x7a) & ~0x80);
	}

	if (status & 0x10) {
		rv = DDI_INTR_CLAIMED;
		/* ack the interrupt */
		(void) PORT_RD8(dev->sb, 0xe);
	}
	mutex_exit(&dev->mutex);

	return (rv);
}

static uint8_t
solo_mixer_scale(solo_dev_t *dev, solo_ctrl_num_t num)
{
	uint32_t	l, r;
	uint64_t	value = dev->ctrls[num].val;

	l = (value >> 8) & 0xff;
	r = value & 0xff;

	l = (l * 15) / 100;
	r = (r * 15) / 100;
	return ((uint8_t)((l << 4) | (r)));
}

static void
solo_configure_mixer(solo_dev_t *dev)
{
	uint32_t v;
	uint32_t mon, rec;

	/*
	 * We disable hardware volume control (i.e. async updates to volume).
	 * We could in theory support this, but making it work right can be
	 * tricky, and we doubt it is widely used.
	 */
	solo_setmixer(dev, 0x64, solo_getmixer(dev, 0x64) | 0xc);
	solo_setmixer(dev, 0x66, 0);

	/* master volume has 6 bits per channel, bit 6 indicates mute  */
	/* left */
	v = (dev->ctrls[CTL_FRONT].val >> 8) & 0xff;
	v = v ? (v * 63) / 100 : 64;
	solo_setmixer(dev, 0x60, v & 0xff);

	/* right */
	v = dev->ctrls[CTL_FRONT].val & 0xff;
	v = v ? (v * 63) / 100 : 64;
	solo_setmixer(dev, 0x62, v & 0xff);

	v = solo_mixer_scale(dev, CTL_VOLUME);
	v = v | (v << 4);
	solo_setmixer(dev, 0x7c, v & 0xff);
	solo_setmixer(dev, 0x14, v & 0xff);

	mon = dev->ctrls[CTL_MONSRC].val;
	rec = dev->ctrls[CTL_RECSRC].val;

	/*
	 * The Solo-1 has dual stereo mixers (one for input and one for output),
	 * with separate volume controls for each.
	 */
	v = solo_mixer_scale(dev, CTL_MIC);
	solo_setmixer(dev, 0x68, rec & (1 << INPUT_MIC) ? v : 0);
	solo_setmixer(dev, 0x1a, mon & (1 << INPUT_MIC) ? v : 0);

	v = solo_mixer_scale(dev, CTL_LINE);
	solo_setmixer(dev, 0x6e, rec & (1 << INPUT_LINE) ? v : 0);
	solo_setmixer(dev, 0x3e, mon & (1 << INPUT_LINE) ? v : 0);

	v = solo_mixer_scale(dev, CTL_CD);
	solo_setmixer(dev, 0x6a, rec & (1 << INPUT_CD) ? v : 0);
	solo_setmixer(dev, 0x38, mon & (1 << INPUT_CD) ? v : 0);

	v = solo_mixer_scale(dev, CTL_AUX);
	solo_setmixer(dev, 0x6c, rec & (1 << INPUT_AUX) ? v : 0);
	solo_setmixer(dev, 0x3a, mon & (1 << INPUT_AUX) ? v : 0);

	v = solo_mixer_scale(dev, CTL_MONO);
	v = v | (v << 4);
	solo_setmixer(dev, 0x6f, rec & (1 << INPUT_MONO) ? v : 0);
	solo_setmixer(dev, 0x6d, mon & (1 << INPUT_MONO) ? v : 0);

	if (dev->ctrls[CTL_MICBOOST].val) {
		solo_setmixer(dev, 0x7d, solo_getmixer(dev, 0x7d) | 0x8);
	} else {
		solo_setmixer(dev, 0x7d, solo_getmixer(dev, 0x7d) & ~(0x8));
	}

	v = solo_mixer_scale(dev, CTL_RECGAIN);
	v = v | (v << 4);
	solo_write(dev, 0xb4, v & 0xff);

	v = dev->ctrls[CTL_SPEAKER].val & 0xff;
	v = (v * 7) / 100;
	solo_setmixer(dev, 0x3c, v & 0xff);

	if (dev->ctrls[CTL_LOOPBACK].val) {
		/* record-what-you-hear mode */
		solo_setmixer(dev, 0x1c, 0x3);
	} else {
		/* use record mixer */
		solo_setmixer(dev, 0x1c, 0x5);
	}

}

static int
solo_set_mixsrc(void *arg, uint64_t val)
{
	solo_ctrl_t	*pc = arg;
	solo_dev_t	*dev = pc->dev;

	if ((val & ~INSRCS) != 0)
		return (EINVAL);

	mutex_enter(&dev->mutex);
	pc->val = val;
	solo_configure_mixer(dev);
	mutex_exit(&dev->mutex);
	return (0);
}

static int
solo_set_mono(void *arg, uint64_t val)
{
	solo_ctrl_t	*pc = arg;
	solo_dev_t	*dev = pc->dev;

	val &= 0xff;
	if (val > 100)
		return (EINVAL);

	val = (val & 0xff) | ((val & 0xff) << 8);

	mutex_enter(&dev->mutex);
	pc->val = val;
	solo_configure_mixer(dev);
	mutex_exit(&dev->mutex);
	return (0);
}

static int
solo_set_stereo(void *arg, uint64_t val)
{
	solo_ctrl_t	*pc = arg;
	solo_dev_t	*dev = pc->dev;
	uint8_t		l;
	uint8_t		r;

	l = (val & 0xff00) >> 8;
	r = val & 0xff;

	if ((l > 100) || (r > 100))
		return (EINVAL);

	mutex_enter(&dev->mutex);
	pc->val = val;
	solo_configure_mixer(dev);
	mutex_exit(&dev->mutex);
	return (0);
}

static int
solo_set_bool(void *arg, uint64_t val)
{
	solo_ctrl_t	*pc = arg;
	solo_dev_t	*dev = pc->dev;

	mutex_enter(&dev->mutex);
	pc->val = val;
	solo_configure_mixer(dev);
	mutex_exit(&dev->mutex);
	return (0);
}

static int
solo_get_value(void *arg, uint64_t *val)
{
	solo_ctrl_t	*pc = arg;
	solo_dev_t	*dev = pc->dev;

	mutex_enter(&dev->mutex);
	*val = pc->val;
	mutex_exit(&dev->mutex);
	return (0);
}

#define	PLAYCTL	(AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_PLAY)
#define	RECCTL	(AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_REC)
#define	MONCTL	(AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_MONITOR)
#define	PCMVOL	(PLAYCTL | AUDIO_CTRL_FLAG_PCMVOL)
#define	MAINVOL	(PLAYCTL | AUDIO_CTRL_FLAG_MAINVOL)
#define	RECVOL	(RECCTL | AUDIO_CTRL_FLAG_RECVOL)

static void
solo_alloc_ctrl(solo_dev_t *dev, uint32_t num, uint64_t val)
{
	audio_ctrl_desc_t	desc;
	audio_ctrl_wr_t		fn;
	solo_ctrl_t		*pc;

	bzero(&desc, sizeof (desc));

	pc = &dev->ctrls[num];
	pc->num = num;
	pc->dev = dev;

	switch (num) {
	case CTL_VOLUME:
		desc.acd_name = AUDIO_CTRL_ID_VOLUME;
		desc.acd_type = AUDIO_CTRL_TYPE_MONO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = PCMVOL;
		fn = solo_set_mono;
		break;

	case CTL_FRONT:
		desc.acd_name = AUDIO_CTRL_ID_LINEOUT;
		desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = MAINVOL;
		fn = solo_set_stereo;
		break;

	case CTL_SPEAKER:
		desc.acd_name = AUDIO_CTRL_ID_SPEAKER;
		desc.acd_type = AUDIO_CTRL_TYPE_MONO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = MAINVOL;
		fn = solo_set_mono;
		break;

	case CTL_MIC:
		desc.acd_name = AUDIO_CTRL_ID_MIC;
		desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = RECVOL;
		fn = solo_set_stereo;
		break;

	case CTL_LINE:
		desc.acd_name = AUDIO_CTRL_ID_LINEIN;
		desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = RECVOL;
		fn = solo_set_stereo;
		break;

	case CTL_CD:
		desc.acd_name = AUDIO_CTRL_ID_CD;
		desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = RECVOL;
		fn = solo_set_stereo;
		break;

	case CTL_AUX:
		desc.acd_name = AUDIO_CTRL_ID_AUX1IN;
		desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = RECVOL;
		fn = solo_set_stereo;
		break;

	case CTL_MONO:
		desc.acd_name = AUDIO_CTRL_ID_AUX2IN;
		desc.acd_type = AUDIO_CTRL_TYPE_MONO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = RECVOL;
		fn = solo_set_mono;
		break;

	case CTL_RECSRC:
		desc.acd_name = AUDIO_CTRL_ID_RECSRC;
		desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
		desc.acd_minvalue = INSRCS;
		desc.acd_maxvalue = INSRCS;
		desc.acd_flags = RECCTL | AUDIO_CTRL_FLAG_MULTI;
		for (int i = 0; solo_insrcs[i]; i++) {
			desc.acd_enum[i] = solo_insrcs[i];
		}
		fn = solo_set_mixsrc;
		break;

	case CTL_MONSRC:
		desc.acd_name = AUDIO_CTRL_ID_MONSRC;
		desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
		desc.acd_minvalue = INSRCS;
		desc.acd_maxvalue = INSRCS;
		desc.acd_flags = MONCTL | AUDIO_CTRL_FLAG_MULTI;
		for (int i = 0; solo_insrcs[i]; i++) {
			desc.acd_enum[i] = solo_insrcs[i];
		}
		fn = solo_set_mixsrc;
		break;

	case CTL_MICBOOST:
		desc.acd_name = AUDIO_CTRL_ID_MICBOOST;
		desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 1;
		desc.acd_flags = RECCTL;
		fn = solo_set_bool;
		break;

	case CTL_LOOPBACK:
		desc.acd_name = AUDIO_CTRL_ID_LOOPBACK;
		desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 1;
		desc.acd_flags = RECCTL;
		fn = solo_set_bool;
		break;

	case CTL_RECGAIN:
		desc.acd_name = AUDIO_CTRL_ID_RECGAIN;
		desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = RECCTL;
		fn = solo_set_stereo;
		break;
	}

	pc->val = val;
	pc->ctrl = audio_dev_add_control(dev->adev, &desc,
	    solo_get_value, fn, pc);
}

static bool
solo_add_controls(solo_dev_t *dev)
{
	solo_alloc_ctrl(dev, CTL_VOLUME, 0x4b);
	solo_alloc_ctrl(dev, CTL_FRONT, 0x5a5a);
	solo_alloc_ctrl(dev, CTL_SPEAKER, 0x4b);
	solo_alloc_ctrl(dev, CTL_MIC, 0x3232);
	solo_alloc_ctrl(dev, CTL_LINE, 0x4b4b);
	solo_alloc_ctrl(dev, CTL_CD, 0x4b4b);
	solo_alloc_ctrl(dev, CTL_AUX, 0);
	solo_alloc_ctrl(dev, CTL_MONO, 0);
	solo_alloc_ctrl(dev, CTL_RECSRC, (1U << INPUT_MIC));
	solo_alloc_ctrl(dev, CTL_MONSRC, 0);
	solo_alloc_ctrl(dev, CTL_RECGAIN, 0x4b4b);
	solo_alloc_ctrl(dev, CTL_MICBOOST, 1);
	solo_alloc_ctrl(dev, CTL_LOOPBACK, 0);

	return (true);
}


/* utility functions for ESS */
static uint8_t
solo_calcfilter(int spd)
{
	int cutoff;

	cutoff = (spd * 9 * 82) / 20;
	return (256 - (7160000 / cutoff));
}

static void
solo_aud1_update(solo_engine_t *e)
{
	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.  We also suspend the DMA
	 * while we do this, to minimize record distortion.
	 */
	if (e->trigger) {
		drv_usecwait(20);
	}
	for (tries = 10; tries; tries--) {
		drv_usecwait(10);
		ptr = PORT_RD32(dev->vc, 0);
		count = PORT_RD16(dev->vc, 4);
		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 :
	    offset + SOLO_BUFSZ - e->offset;

	e->offset = offset;
	e->count += n / (SOLO_NCHAN * SOLO_SAMPSZ);
}

static void
solo_aud1_start(solo_engine_t *e)
{
	solo_dev_t	*dev = e->dev;
	int		len;
	uint32_t	v;

	ASSERT(mutex_owned(&dev->mutex));

	e->offset = 0;
	len = SOLO_FRAGSZ / 2;
	len = -len;

	/* sample rate - 48 kHz */
	solo_write(dev, 0xa1, 0xf0);
	/* filter cutoff */
	solo_write(dev, 0xa2, solo_calcfilter(SOLO_RATE));


	/* mono/stereo - bit 0 set, bit 1 clear */
	solo_write(dev, 0xa8, (solo_read(dev, 0xa8) & ~0x03) | 1);

	(void) solo_cmd(dev, 0xd3);	/* turn off DAC1 output */

	/* setup fifo for signed 16-bit stereo */
	solo_write(dev, 0xb7, 0x71);
	solo_write(dev, 0xb7, 0xbc);

	v = solo_mixer_scale(dev, CTL_RECGAIN);
	v = v | (v << 4);
	solo_write(dev, 0xb4, v & 0xff);

	PORT_WR8(dev->vc, 0x8, 0xc4); /* command */
	PORT_WR8(dev->vc, 0xd, 0xff); /* clear DMA */
	PORT_WR8(dev->vc, 0xf, 0x01); /* stop DMA  */

	PORT_WR8(dev->vc, 0xd, 0xff); /* reset */
	PORT_WR8(dev->vc, 0xf, 0x01); /* mask */
	PORT_WR8(dev->vc, 0xb, 0x14); /* mode */

	PORT_WR32(dev->vc, 0x0, e->paddr);
	PORT_WR16(dev->vc, 0x4, SOLO_BUFSZ - 1);

	/* transfer length low, high */
	solo_write(dev, 0xa4, len & 0x00ff);
	solo_write(dev, 0xa5, (len & 0xff00) >> 8);

	/* 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)
{
	solo_dev_t	*dev = e->dev;
	uint16_t	offset = 0, n;

	ASSERT(mutex_owned(&dev->mutex));

	offset = SOLO_BUFSZ - PORT_RD16(dev->io, 0x4);
	offset /= (SOLO_NCHAN * SOLO_SAMPSZ);

	n = offset >= e->offset ?
	    offset - e->offset :
	    offset + SOLO_BUFFR - e->offset;

	e->offset = offset;
	e->count += n;
}

static void
solo_aud2_start(solo_engine_t *e)
{
	solo_dev_t	*dev = e->dev;
	int		len;
	uint32_t	v;

	ASSERT(mutex_owned(&dev->mutex));

	e->offset = 0;
	len = SOLO_FRAGSZ / 2;
	len = -len;

	/* program transfer type */
	solo_setmixer(dev, 0x78, 0x10);
	/* sample rate - 48 kHz */
	solo_setmixer(dev, 0x70, 0xf0);
	solo_setmixer(dev, 0x72, solo_calcfilter(SOLO_RATE));
	/* transfer length low & high */
	solo_setmixer(dev, 0x74, len & 0x00ff);
	solo_setmixer(dev, 0x76, (len & 0xff00) >> 8);
	/* enable irq, set signed 16-bit stereo format */
	solo_setmixer(dev, 0x7a, 0x47);

	PORT_WR8(dev->io, 0x6, 0);
	PORT_WR32(dev->io, 0x0, e->paddr);
	PORT_WR16(dev->io, 0x4, SOLO_BUFSZ);

	/* this crazy initialization appears to help with fifo weirdness */
	/* start the engine running */
	solo_setmixer(dev, 0x78, 0x92);
	drv_usecwait(10);
	solo_setmixer(dev, 0x78, 0x93);

	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.
 */
static int
solo_format(void *arg)
{
	solo_engine_t	*e = arg;
	return (e->format);
}

static int
solo_channels(void *arg)
{
	_NOTE(ARGUNUSED(arg));
	return (SOLO_NCHAN);
}

static int
solo_rate(void *arg)
{
	_NOTE(ARGUNUSED(arg));
	return (SOLO_RATE);
}

static void
solo_chinfo(void *arg, int chan, unsigned *offset, unsigned *incr)
{
	solo_engine_t *e = arg;

	if (e->swapped) {
		*offset = !chan;
	} else {
		*offset = chan;
	}
	*incr = 2;
}

static void
solo_sync(void *arg, unsigned nframes)
{
	solo_engine_t *e = arg;

	_NOTE(ARGUNUSED(nframes));

	(void) ddi_dma_sync(e->dmah, 0, 0, e->syncdir);
}


static uint64_t
solo_count(void *arg)
{
	solo_engine_t	*e = arg;
	solo_dev_t	*dev = e->dev;
	uint64_t	count;

	mutex_enter(&dev->mutex);
	e->update(e);
	count = e->count;
	mutex_exit(&dev->mutex);

	return (count);
}

static int
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));

	*nframes = SOLO_NFRAGS * SOLO_FRAGFR;
	*buf = e->kaddr;

	mutex_enter(&dev->mutex);
	e->started = false;
	e->count = 0;
	mutex_exit(&dev->mutex);

	return (0);
}

void
solo_close(void *arg)
{
	solo_engine_t	*e = arg;
	solo_dev_t	*dev = e->dev;

	mutex_enter(&dev->mutex);
	e->stop(e);
	e->started = false;
	mutex_exit(&dev->mutex);
}


static int
solo_start(void *arg)
{
	solo_engine_t	*e = arg;
	solo_dev_t	*dev = e->dev;

	mutex_enter(&dev->mutex);
	if (!e->started) {
		e->start(e);
		e->started = true;
	}
	mutex_exit(&dev->mutex);

	return (0);
}

static void
solo_stop(void *arg)
{
	solo_engine_t	*e = arg;
	solo_dev_t	*dev = e->dev;

	mutex_enter(&dev->mutex);
	if (e->started) {
		e->stop(e);
		e->started = false;
	}
	mutex_exit(&dev->mutex);

}

static audio_engine_ops_t solo_engine_ops = {
	AUDIO_ENGINE_VERSION,
	solo_open,
	solo_close,
	solo_start,
	solo_stop,
	solo_count,
	solo_format,
	solo_channels,
	solo_rate,
	solo_sync,
	NULL,
	solo_chinfo,
	NULL,
};

static void
solo_release_resources(solo_dev_t *dev)
{
	if (dev->ihandle != NULL) {
		(void) ddi_intr_disable(dev->ihandle);
		(void) ddi_intr_remove_handler(dev->ihandle);
		(void) ddi_intr_free(dev->ihandle);
		mutex_destroy(&dev->mutex);
	}

	if (dev->io.acch != NULL) {
		ddi_regs_map_free(&dev->io.acch);
	}

	if (dev->sb.acch != NULL) {
		ddi_regs_map_free(&dev->sb.acch);
	}

	if (dev->vc.acch != NULL) {
		ddi_regs_map_free(&dev->vc.acch);
	}

	if (dev->pcih != NULL) {
		pci_config_teardown(&dev->pcih);
	}

	/* release play resources */
	if (dev->play.paddr != 0)
		(void) ddi_dma_unbind_handle(dev->play.dmah);
	if (dev->play.acch != NULL)
		ddi_dma_mem_free(&dev->play.acch);
	if (dev->play.dmah != NULL)
		ddi_dma_free_handle(&dev->play.dmah);

	if (dev->play.engine != NULL) {
		audio_dev_remove_engine(dev->adev, dev->play.engine);
		audio_engine_free(dev->play.engine);
	}

	/* release record resources */
	if (dev->rec.paddr != 0)
		(void) ddi_dma_unbind_handle(dev->rec.dmah);
	if (dev->rec.acch != NULL)
		ddi_dma_mem_free(&dev->rec.acch);
	if (dev->rec.dmah != NULL)
		ddi_dma_free_handle(&dev->rec.dmah);

	if (dev->rec.engine != NULL) {
		audio_dev_remove_engine(dev->adev, dev->rec.engine);
		audio_engine_free(dev->rec.engine);
	}

	for (int i = 0; i < CTL_NUM; i++) {
		if (dev->ctrls[i].ctrl != NULL) {
			audio_dev_del_control(dev->ctrls[i].ctrl);
		}
	}

	if (dev->adev != NULL) {
		audio_dev_free(dev->adev);
	}

	kmem_free(dev, sizeof (*dev));
}

static bool
solo_setup_interrupts(solo_dev_t *dev)
{
	int actual;
	uint_t ipri;

	if ((ddi_intr_alloc(dev->dip, &dev->ihandle, DDI_INTR_TYPE_FIXED,
	    0, 1, &actual, DDI_INTR_ALLOC_NORMAL) != DDI_SUCCESS) ||
	    (actual != 1)) {
		audio_dev_warn(dev->adev, "can't alloc intr handle");
		return (false);
	}

	if (ddi_intr_get_pri(dev->ihandle, &ipri) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev,  "can't determine intr priority");
		(void) ddi_intr_free(dev->ihandle);
		dev->ihandle = NULL;
		return (false);
	}

	if (ddi_intr_add_handler(dev->ihandle, solo_intr, dev,
	    NULL) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev, "can't add intr handler");
		(void) ddi_intr_free(dev->ihandle);
		dev->ihandle = NULL;
		return (false);
	}

	mutex_init(&dev->mutex, NULL, MUTEX_DRIVER, DDI_INTR_PRI(ipri));

	return (true);
}

static bool
solo_map_registers(solo_dev_t *dev)
{
	dev_info_t	*dip = dev->dip;

	/* map registers */
	if (ddi_regs_map_setup(dip, 1, &dev->io.base, 0, 0, &acc_attr,
	    &dev->io.acch) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev, "can't map IO registers");
		return (false);
	}
	if (ddi_regs_map_setup(dip, 2, &dev->sb.base, 0, 0, &acc_attr,
	    &dev->sb.acch) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev, "can't map SB registers");
		return (false);
	}
	if (ddi_regs_map_setup(dip, 3, &dev->vc.base, 0, 0, &acc_attr,
	    &dev->vc.acch) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev, "can't map VC registers");
		return (false);
	}

	return (true);
}

#define	ESS_PCI_LEGACYCONTROL		0x40
#define	ESS_PCI_CONFIG			0x50
#define	ESS_PCI_DDMACONTROL		0x60

static bool
solo_init_hw(solo_dev_t *dev)
{
	uint32_t	data;

	/*
	 * Legacy audio register -- disable legacy audio.  We also
	 * arrange for 16-bit I/O address decoding.
	 */
	/* this version disables the MPU, FM synthesis (Adlib), and Game Port */
	pci_config_put16(dev->pcih, ESS_PCI_LEGACYCONTROL, 0x8041);

	/*
	 * Note that Solo-1 uses I/O space for all BARs, and hardwires
	 * the upper 32-bits to zero.
	 */
	data = pci_config_get32(dev->pcih, PCI_CONF_BASE2);
	data |= 1;
	pci_config_put16(dev->pcih, ESS_PCI_DDMACONTROL, data & 0xffff);

	/*
	 * Make sure that legacy IRQ and DRQ are disbled.  We disable most
	 * other legacy features too.
	 */
	pci_config_put16(dev->pcih, ESS_PCI_CONFIG, 0);

	if (!solo_reset_dsp(dev))
		return (false);

	/* enable extended mode */
	(void) solo_cmd(dev, 0xc6);


	PORT_WR8(dev->io, 0x7, 0x30); /* enable audio irqs */

	/* demand mode, 4 bytes/xfer */
	solo_write(dev, 0xb9, 0x01);

	/*
	 * This sets Audio 2 (playback) to use its own independent
	 * rate control, and gives us 48 kHz compatible divisors.  It
	 * also bypasses the switched capacitor filter.
	 */
	solo_setmixer(dev, 0x71, 0x2a);

	/* irq control */
	solo_write(dev, 0xb1, (solo_read(dev, 0xb1) & 0x0f) | 0x50);
	/* drq control */
	solo_write(dev, 0xb2, (solo_read(dev, 0xb2) & 0x0f) | 0x50);

	solo_setmixer(dev, 0, 0); /* reset mixer settings */

	solo_configure_mixer(dev);
	return (true);
}

static bool
solo_alloc_engine(solo_dev_t *dev, int engno)
{
	size_t			rlen;
	ddi_dma_attr_t		*dattr;
	ddi_dma_cookie_t	c;
	unsigned		ccnt;
	unsigned		caps;
	unsigned		dflags;
	const char		*desc;
	solo_engine_t		*e;

	ASSERT((engno == 1) || (engno = 2));

	switch (engno) {
	case 1:	/* record */
		e = &dev->rec;
		desc = "record";
		dattr = &dma_attr_audio1;
		caps = ENGINE_INPUT_CAP;
		dflags = DDI_DMA_READ | DDI_DMA_CONSISTENT;
		e->syncdir = DDI_DMA_SYNC_FORKERNEL;
		e->update = solo_aud1_update;
		e->start = solo_aud1_start;
		e->stop = solo_aud1_stop;
		e->format = AUDIO_FORMAT_S16_BE;
		e->swapped = true;
		break;

	case 2:	/* playback */
		e = &dev->play;
		desc = "playback";
		dattr = &dma_attr_audio2;
		caps = ENGINE_OUTPUT_CAP;
		dflags = DDI_DMA_WRITE | DDI_DMA_CONSISTENT;
		e->syncdir = DDI_DMA_SYNC_FORDEV;
		e->update = solo_aud2_update;
		e->start = solo_aud2_start;
		e->stop = solo_aud2_stop;
		e->format = AUDIO_FORMAT_S16_LE;
		e->swapped = false;
		break;

	default:
		audio_dev_warn(dev->adev, "bad engine number!");
		return (false);
	}

	e->dev = dev;

	if (ddi_dma_alloc_handle(dev->dip, dattr, DDI_DMA_SLEEP, NULL,
	    &e->dmah) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev, "%s dma handle alloc failed", desc);
		return (false);
	}
	if (ddi_dma_mem_alloc(e->dmah, SOLO_BUFSZ, &buf_attr,
	    DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &e->kaddr,
	    &rlen, &e->acch) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev, "%s dma memory alloc failed", desc);
		return (false);
	}
	/* ensure that the buffer is zeroed out properly */
	bzero(e->kaddr, rlen);
	if (ddi_dma_addr_bind_handle(e->dmah, NULL, e->kaddr, SOLO_BUFSZ,
	    dflags, DDI_DMA_SLEEP, NULL, &c, &ccnt) != DDI_DMA_MAPPED) {
		audio_dev_warn(dev->adev, "%s dma binding failed", desc);
		return (false);
	}
	e->paddr = c.dmac_address;

	/*
	 * Allocate and configure audio engine.
	 */
	e->engine = audio_engine_alloc(&solo_engine_ops, caps);
	if (e->engine == NULL) {
		audio_dev_warn(dev->adev, "record audio_engine_alloc failed");
		return (false);
	}

	audio_engine_set_private(e->engine, e);
	audio_dev_add_engine(dev->adev, e->engine);

	return (true);
}


static int
solo_suspend(solo_dev_t *dev)
{
	audio_dev_suspend(dev->adev);

	mutex_enter(&dev->mutex);
	dev->suspended = true;
	mutex_exit(&dev->mutex);

	return (DDI_SUCCESS);
}

static int
solo_resume(solo_dev_t *dev)
{
	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");
	}
	dev->suspended = false;
	mutex_exit(&dev->mutex);

	audio_dev_resume(dev->adev);

	return (DDI_SUCCESS);
}

static int
solo_attach(dev_info_t *dip)
{
	solo_dev_t	*dev;
	uint32_t	data;

	dev = kmem_zalloc(sizeof (*dev), KM_SLEEP);
	dev->dip = dip;
	ddi_set_driver_private(dip, dev);

	dev->adev = audio_dev_alloc(dip, 0);
	if (dev->adev == NULL)
		goto no;

	audio_dev_set_description(dev->adev, "ESS Solo-1 PCI AudioDrive");
	audio_dev_set_version(dev->adev, "ES1938");

	if (pci_config_setup(dip, &dev->pcih) != DDI_SUCCESS) {
		audio_dev_warn(NULL, "pci_config_setup failed");
		goto no;
	}

	data = pci_config_get16(dev->pcih, PCI_CONF_COMM);
	data |= PCI_COMM_ME | PCI_COMM_IO;
	pci_config_put16(dev->pcih, PCI_CONF_COMM, data);

	if ((!solo_map_registers(dev)) ||
	    (!solo_setup_interrupts(dev)) ||
	    (!solo_alloc_engine(dev, 1)) ||
	    (!solo_alloc_engine(dev, 2)) ||
	    (!solo_add_controls(dev)) ||
	    (!solo_init_hw(dev))) {
		goto no;
	}

	if (audio_dev_register(dev->adev) != DDI_SUCCESS) {
		audio_dev_warn(dev->adev,
		    "unable to register with audio framework");
		goto no;
	}

	(void) ddi_intr_enable(dev->ihandle);
	ddi_report_dev(dip);

	return (DDI_SUCCESS);

no:
	solo_release_resources(dev);
	return (DDI_FAILURE);
}

static int
solo_detach(solo_dev_t *dev)
{
	if (audio_dev_unregister(dev->adev) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	solo_release_resources(dev);
	return (DDI_SUCCESS);
}

static int
solo_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	solo_dev_t *dev;

	switch (cmd) {
	case DDI_ATTACH:
		return (solo_attach(dip));

	case DDI_RESUME:
		if ((dev = ddi_get_driver_private(dip)) == NULL) {
			return (DDI_FAILURE);
		}
		return (solo_resume(dev));

	default:
		return (DDI_FAILURE);
	}
}

static int
solo_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	solo_dev_t *dev;

	if ((dev = ddi_get_driver_private(dip)) == NULL) {
		return (DDI_FAILURE);
	}

	switch (cmd) {
	case DDI_DETACH:
		return (solo_detach(dev));

	case DDI_SUSPEND:
		return (solo_suspend(dev));
	default:
		return (DDI_FAILURE);
	}
}

static int
solo_quiesce(dev_info_t *dip)
{
	solo_dev_t *dev;

	dev = ddi_get_driver_private(dip);

	solo_aud1_stop(&dev->rec);
	solo_aud2_stop(&dev->play);

	solo_setmixer(dev, 0, 0);
	PORT_WR8(dev->io, 0x7, 0); /* disable all irqs */
	return (0);
}

struct dev_ops solo_dev_ops = {
	DEVO_REV,		/* rev */
	0,			/* refcnt */
	NULL,			/* getinfo */
	nulldev,		/* identify */
	nulldev,		/* probe */
	solo_ddi_attach,	/* attach */
	solo_ddi_detach,	/* detach */
	nodev,			/* reset */
	NULL,			/* cb_ops */
	NULL,			/* bus_ops */
	NULL,			/* power */
	solo_quiesce,		/* quiesce */
};

static struct modldrv solo_modldrv = {
	&mod_driverops,			/* drv_modops */
	"ESS Solo-1 Audio",		/* linkinfo */
	&solo_dev_ops,			/* dev_ops */
};

static struct modlinkage modlinkage = {
	MODREV_1,
	{ &solo_modldrv, NULL }
};

int
_init(void)
{
	int	rv;

	audio_init_ops(&solo_dev_ops, DRVNAME);
	if ((rv = mod_install(&modlinkage)) != 0) {
		audio_fini_ops(&solo_dev_ops);
	}
	return (rv);
}

int
_fini(void)
{
	int	rv;

	if ((rv = mod_remove(&modlinkage)) == 0) {
		audio_fini_ops(&solo_dev_ops);
	}
	return (rv);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}