path: root/usr/src/uts/sun/io/audio/drv/audiocs/audio_4231.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * audiocs Audio Driver
 *
 * This Audio Driver controls the Crystal CS4231 Codec used on many SPARC
 * platforms. It does not support the CS4231 on Power PCs or x86 PCs. It
 * does support two different DMA engines, the APC and EB2. The code for
 * those DMA engines is split out and a well defined, but private, interface
 * is used to control those DMA engines.
 *
 * For some reason setting the CS4231's registers doesn't always
 * succeed.  Therefore every time we set a register we always read it
 * back to make sure it was set. If not we wait a little while and
 * then try again. This is all taken care of in the routines
 * audiocs_put_index() and audiocs_sel_index() and the macros ORIDX()
 * and ANDIDX(). We don't worry about the status register because it
 * is cleared by writing anything to it.  So it doesn't matter what
 * the value written is.
 *
 * This driver supports suspending and resuming. A suspend just stops playing
 * and recording. The play DMA buffers end up getting thrown away, but when
 * you shut down the machine there is a break in the audio anyway, so they
 * won't be missed and it isn't worth the effort to save them. When we resume
 * we always start playing and recording. If they aren't needed they get
 * shut off by the mixer.
 *
 * Power management is supported by this driver.
 *
 *	NOTE: This module depends on drv/audio being loaded first.
 */

#include <sys/modctl.h>
#include <sys/kmem.h>
#include <sys/stropts.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/note.h>
#include <sys/audio/audio_driver.h>
#include "audio_4231.h"

/*
 * Module linkage routines for the kernel
 */
static int audiocs_ddi_attach(dev_info_t *, ddi_attach_cmd_t);
static int audiocs_ddi_detach(dev_info_t *, ddi_detach_cmd_t);
static int audiocs_ddi_power(dev_info_t *, int, int);

/*
 * Entry point routine prototypes
 */
static int audiocs_open(void *, int, unsigned *, caddr_t *);
static void audiocs_close(void *);
static int audiocs_start(void *);
static void audiocs_stop(void *);
static int audiocs_format(void *);
static int audiocs_channels(void *);
static int audiocs_rate(void *);
static uint64_t audiocs_count(void *);
static void audiocs_sync(void *, unsigned);

/*
 * Control callbacks.
 */
static int audiocs_get_value(void *, uint64_t *);
static int audiocs_set_ogain(void *, uint64_t);
static int audiocs_set_igain(void *, uint64_t);
static int audiocs_set_mgain(void *, uint64_t);
static int audiocs_set_inputs(void *, uint64_t);
static int audiocs_set_outputs(void *, uint64_t);
static int audiocs_set_micboost(void *, uint64_t);

/* Local Routines */
static int audiocs_resume(dev_info_t *);
static int audiocs_attach(dev_info_t *);
static int audiocs_detach(dev_info_t *);
static int audiocs_suspend(dev_info_t *);

static void audiocs_destroy(CS_state_t *);
static int audiocs_init_state(CS_state_t *);
static int audiocs_chip_init(CS_state_t *);
static int audiocs_alloc_engine(CS_state_t *, int);
static void audiocs_free_engine(CS_engine_t *);
static void audiocs_get_ports(CS_state_t *);
static void audiocs_configure_input(CS_state_t *);
static void audiocs_configure_output(CS_state_t *);
static CS_ctrl_t *audiocs_alloc_ctrl(CS_state_t *, uint32_t, uint64_t);
static void audiocs_free_ctrl(CS_ctrl_t *);
static int audiocs_add_controls(CS_state_t *);
static void audiocs_del_controls(CS_state_t *);
static void audiocs_power_up(CS_state_t *);
static void audiocs_power_down(CS_state_t *);
static int audiocs_poll_ready(CS_state_t *);
#ifdef	DEBUG
static void audiocs_put_index(CS_state_t *,  uint8_t, uint8_t, int);
static void audiocs_sel_index(CS_state_t *, uint8_t, int);
#define	SELIDX(s, idx)		audiocs_sel_index(s, idx, __LINE__)
#define	PUTIDX(s, val, mask)	audiocs_put_index(s, val, mask, __LINE__)
#else
static void audiocs_put_index(CS_state_t *,  uint8_t, uint8_t);
static void audiocs_sel_index(CS_state_t *, uint8_t);
#define	SELIDX(s, idx)		audiocs_sel_index(s, idx)
#define	PUTIDX(s, val, mask)	audiocs_put_index(s, val, mask)
#endif
#define	GETIDX(s)		ddi_get8((handle), &CS4231_IDR)

#define	ORIDX(s, val, mask)						\
	PUTIDX(s,							\
	    (ddi_get8((handle), &CS4231_IDR) | (uint8_t)(val)),		\
	    (uint8_t)(mask))

#define	ANDIDX(s, val, mask)						\
	PUTIDX(s, (ddi_get8((handle), &CS4231_IDR) & (uint8_t)(val)),	\
	    (uint8_t)(mask))

static audio_engine_ops_t audiocs_engine_ops = {
	AUDIO_ENGINE_VERSION,
	audiocs_open,
	audiocs_close,
	audiocs_start,
	audiocs_stop,
	audiocs_count,
	audiocs_format,
	audiocs_channels,
	audiocs_rate,
	audiocs_sync,
	NULL,
	NULL,
	NULL,
};

#define	OUTPUT_SPEAKER		0
#define	OUTPUT_HEADPHONES	1
#define	OUTPUT_LINEOUT		2

static const char *audiocs_outputs[] = {
	AUDIO_PORT_SPEAKER,
	AUDIO_PORT_HEADPHONES,
	AUDIO_PORT_LINEOUT,
	NULL
};

#define	INPUT_MIC		0
#define	INPUT_LINEIN		1
#define	INPUT_STEREOMIX		2
#define	INPUT_CD		3

static const char *audiocs_inputs[] = {
	AUDIO_PORT_MIC,
	AUDIO_PORT_LINEIN,
	AUDIO_PORT_STEREOMIX,
	AUDIO_PORT_CD,
	NULL
};

/*
 * Global variables, but viewable only by this file.
 */

/* play gain array, converts linear gain to 64 steps of log10 gain */
static uint8_t cs4231_atten[] = {
	0x3f,	0x3e,	0x3d,	0x3c,	0x3b,	/* [000] -> [004] */
	0x3a,	0x39,	0x38,	0x37,	0x36,	/* [005] -> [009] */
	0x35,	0x34,	0x33,	0x32,	0x31,	/* [010] -> [014] */
	0x30,	0x2f,	0x2e,	0x2d,	0x2c,	/* [015] -> [019] */
	0x2b,	0x2a,	0x29,	0x29,	0x28,	/* [020] -> [024] */
	0x28,	0x27,	0x27,	0x26,	0x26,	/* [025] -> [029] */
	0x25,	0x25,	0x24,	0x24,	0x23,	/* [030] -> [034] */
	0x23,	0x22,	0x22,	0x21,	0x21,	/* [035] -> [039] */
	0x20,	0x20,	0x1f,	0x1f,	0x1f,	/* [040] -> [044] */
	0x1e,	0x1e,	0x1e,	0x1d,	0x1d,	/* [045] -> [049] */
	0x1d,	0x1c,	0x1c,	0x1c,	0x1b,	/* [050] -> [054] */
	0x1b,	0x1b,	0x1a,	0x1a,	0x1a,	/* [055] -> [059] */
	0x1a,	0x19,	0x19,	0x19,	0x19,	/* [060] -> [064] */
	0x18,	0x18,	0x18,	0x18,	0x17,	/* [065] -> [069] */
	0x17,	0x17,	0x17,	0x16,	0x16,	/* [070] -> [074] */
	0x16,	0x16,	0x16,	0x15,	0x15,	/* [075] -> [079] */
	0x15,	0x15,	0x15,	0x14,	0x14,	/* [080] -> [084] */
	0x14,	0x14,	0x14,	0x13,	0x13,	/* [085] -> [089] */
	0x13,	0x13,	0x13,	0x12,	0x12,	/* [090] -> [094] */
	0x12,	0x12,	0x12,	0x12,	0x11,	/* [095] -> [099] */
	0x11,	0x11,	0x11,	0x11,	0x11,	/* [100] -> [104] */
	0x10,	0x10,	0x10,	0x10,	0x10,	/* [105] -> [109] */
	0x10,	0x0f,	0x0f,	0x0f,	0x0f,	/* [110] -> [114] */
	0x0f,	0x0f,	0x0e,	0x0e,	0x0e,	/* [114] -> [119] */
	0x0e,	0x0e,	0x0e,	0x0e,	0x0d,	/* [120] -> [124] */
	0x0d,	0x0d,	0x0d,	0x0d,	0x0d,	/* [125] -> [129] */
	0x0d,	0x0c,	0x0c,	0x0c,	0x0c,	/* [130] -> [134] */
	0x0c,	0x0c,	0x0c,	0x0b,	0x0b,	/* [135] -> [139] */
	0x0b,	0x0b,	0x0b,	0x0b,	0x0b,	/* [140] -> [144] */
	0x0b,	0x0a,	0x0a,	0x0a,	0x0a,	/* [145] -> [149] */
	0x0a,	0x0a,	0x0a,	0x0a,	0x09,	/* [150] -> [154] */
	0x09,	0x09,	0x09,	0x09,	0x09,	/* [155] -> [159] */
	0x09,	0x09,	0x08,	0x08,	0x08,	/* [160] -> [164] */
	0x08,	0x08,	0x08,	0x08,	0x08,	/* [165] -> [169] */
	0x08,	0x07,	0x07,	0x07,	0x07,	/* [170] -> [174] */
	0x07,	0x07,	0x07,	0x07,	0x07,	/* [175] -> [179] */
	0x06,	0x06,	0x06,	0x06,	0x06,	/* [180] -> [184] */
	0x06,	0x06,	0x06,	0x06,	0x05,	/* [185] -> [189] */
	0x05,	0x05,	0x05,	0x05,	0x05,	/* [190] -> [194] */
	0x05,	0x05,	0x05,	0x05,	0x04,	/* [195] -> [199] */
	0x04,	0x04,	0x04,	0x04,	0x04,	/* [200] -> [204] */
	0x04,	0x04,	0x04,	0x04,	0x03,	/* [205] -> [209] */
	0x03,	0x03,	0x03,	0x03,	0x03,	/* [210] -> [214] */
	0x03,	0x03,	0x03,	0x03,	0x03,	/* [215] -> [219] */
	0x02,	0x02,	0x02,	0x02,	0x02,	/* [220] -> [224] */
	0x02,	0x02,	0x02,	0x02,	0x02,	/* [225] -> [229] */
	0x02,	0x01,	0x01,	0x01,	0x01,	/* [230] -> [234] */
	0x01,	0x01,	0x01,	0x01,	0x01,	/* [235] -> [239] */
	0x01,	0x01,	0x01,	0x00,	0x00,	/* [240] -> [244] */
	0x00,	0x00,	0x00,	0x00,	0x00,	/* [245] -> [249] */
	0x00,	0x00,	0x00,	0x00,	0x00,	/* [250] -> [254] */
	0x00					/* [255] */
};

/*
 * STREAMS Structures
 */

/*
 * DDI Structures
 */

/* Device operations structure */
static struct dev_ops audiocs_dev_ops = {
	DEVO_REV,			/* devo_rev */
	0,				/* devo_refcnt */
	NULL,				/* devo_getinfo */
	nulldev,			/* devo_identify - obsolete */
	nulldev,			/* devo_probe - not needed */
	audiocs_ddi_attach,		/* devo_attach */
	audiocs_ddi_detach,		/* devo_detach */
	nodev,				/* devo_reset */
	NULL,				/* devi_cb_ops */
	NULL,				/* devo_bus_ops */
	audiocs_ddi_power,		/* devo_power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};

/* Linkage structure for loadable drivers */
static struct modldrv audiocs_modldrv = {
	&mod_driverops,		/* drv_modops */
	CS4231_MOD_NAME,	/* drv_linkinfo */
	&audiocs_dev_ops	/* drv_dev_ops */
};

/* Module linkage structure */
static struct modlinkage audiocs_modlinkage = {
	MODREV_1,			/* ml_rev */
	(void *)&audiocs_modldrv,	/* ml_linkage */
	NULL				/* NULL terminates the list */
};


/* *******  Loadable Module Configuration Entry Points  ********************* */

/*
 * _init()
 *
 * Description:
 *	Implements _init(9E).
 *
 * Returns:
 *	mod_install() status, see mod_install(9f)
 */
int
_init(void)
{
	int	rv;

	audio_init_ops(&audiocs_dev_ops, CS4231_NAME);

	if ((rv = mod_install(&audiocs_modlinkage)) != 0) {
		audio_fini_ops(&audiocs_dev_ops);
	}

	return (rv);
}

/*
 * _fini()
 *
 * Description:
 *	Implements _fini(9E).
 *
 * Returns:
 *	mod_remove() status, see mod_remove(9f)
 */
int
_fini(void)
{
	int	rv;

	if ((rv = mod_remove(&audiocs_modlinkage)) == 0) {
		audio_fini_ops(&audiocs_dev_ops);
	}

	return (rv);
}

/*
 * _info()
 *
 * Description:
 *	Implements _info(9E).
 *
 * Arguments:
 *	modinfo *modinfop	Pointer to the opaque modinfo structure
 *
 * Returns:
 *	mod_info() status, see mod_info(9f)
 */
int
_info(struct modinfo *modinfop)
{
	return (mod_info(&audiocs_modlinkage, modinfop));
}


/* *******  Driver Entry Points  ******************************************** */

/*
 * audiocs_ddi_attach()
 *
 * Description:
 *	Implement attach(9e).
 *
 * Arguments:
 *	dev_info_t	*dip	Pointer to the device's dev_info struct
 *	ddi_attach_cmd_t cmd	Attach command
 *
 * Returns:
 *	DDI_SUCCESS		The driver was initialized properly
 *	DDI_FAILURE		The driver couldn't be initialized properly
 */
static int
audiocs_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_ATTACH:
		return (audiocs_attach(dip));

	case DDI_RESUME:
		return (audiocs_resume(dip));

	default:
		return (DDI_FAILURE);
	}
}

/*
 * audiocs_ddi_detach()
 *
 * Description:
 *	Implement detach(9e).
 *
 * Arguments:
 *	dev_info_t	*dip	Pointer to the device's dev_info struct
 *	ddi_detach_cmd_t cmd	Detach command
 *
 * Returns:
 *	DDI_SUCCESS		Success.
 *	DDI_FAILURE		Failure.
 */
static int
audiocs_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		return (audiocs_detach(dip));

	case DDI_SUSPEND:
		return (audiocs_suspend(dip));

	default:
		return (DDI_FAILURE);
	}
}

/*
 * audiocs_ddi_power()
 *
 * Description:
 *	Implements power(9E).
 *
 * Arguments:
 *	def_info_t	*dip		Ptr to the device's dev_info structure
 *	int		component	Which component to power up/down
 *	int		level		The power level for the component
 *
 * Returns:
 *	DDI_SUCCESS		Power level changed, we always succeed
 */
static int
audiocs_ddi_power(dev_info_t *dip, int component, int level)
{
	CS_state_t		*state;

	if (component != CS4231_COMPONENT)
		return (DDI_FAILURE);

	/* get the state structure */
	state = ddi_get_driver_private(dip);

	ASSERT(!mutex_owned(&state->cs_lock));

	/* make sure we have some work to do */
	mutex_enter(&state->cs_lock);

	/*
	 * We don't do anything if we're suspended.  Suspend/resume diddles
	 * with power anyway.
	 */
	if (!state->cs_suspended) {

		/* check the level change to see what we need to do */
		if (level == CS4231_PWR_OFF && state->cs_powered) {

			/* power down and save the state */
			audiocs_power_down(state);
			state->cs_powered = B_FALSE;

		} else if (level == CS4231_PWR_ON && !state->cs_powered) {

			/* power up */
			audiocs_power_up(state);
			state->cs_powered = B_TRUE;
		}
	}

	mutex_exit(&state->cs_lock);

	ASSERT(!mutex_owned(&state->cs_lock));

	return (DDI_SUCCESS);
}

/* ******* Local Routines *************************************************** */

static void
audiocs_destroy(CS_state_t *state)
{
	if (state == NULL)
		return;

	for (int i = CS4231_PLAY; i <= CS4231_REC; i++) {
		audiocs_free_engine(state->cs_engines[i]);
	}
	audiocs_del_controls(state);

	if (state->cs_adev) {
		audio_dev_free(state->cs_adev);
	}

	/* unmap the registers */
	CS4231_DMA_UNMAP_REGS(state);

	/* destroy the state mutex */
	mutex_destroy(&state->cs_lock);
	kmem_free(state, sizeof (*state));
}

/*
 * audiocs_attach()
 *
 * Description:
 *	Attach an instance of the CS4231 driver. This routine does the device
 *	dependent attach tasks.  When it is complete it calls
 *	audio_dev_register() to register with the framework.
 *
 * Arguments:
 *	dev_info_t	*dip	Pointer to the device's dev_info struct
 *
 * Returns:
 *	DDI_SUCCESS		The driver was initialized properly
 *	DDI_FAILURE		The driver couldn't be initialized properly
 */
static int
audiocs_attach(dev_info_t *dip)
{
	CS_state_t		*state;
	audio_dev_t		*adev;

	/* allocate the state structure */
	state = kmem_zalloc(sizeof (*state), KM_SLEEP);
	state->cs_dip = dip;
	ddi_set_driver_private(dip, state);

	/* now fill it in, initialize the state mutexs first */
	mutex_init(&state->cs_lock, NULL, MUTEX_DRIVER, NULL);

	/*
	 * audio state initialization... should always succeed,
	 * framework will message failure.
	 */
	if ((state->cs_adev = audio_dev_alloc(dip, 0)) == NULL) {
		goto error;
	}
	adev = state->cs_adev;
	audio_dev_set_description(adev, CS_DEV_CONFIG_ONBRD1);
	audio_dev_add_info(adev, "Legacy codec: Crystal Semiconductor CS4231");

	/* initialize the audio state structures */
	if ((audiocs_init_state(state)) == DDI_FAILURE) {
		audio_dev_warn(adev, "init_state() failed");
		goto error;
	}

	mutex_enter(&state->cs_lock);

	/* initialize the audio chip */
	if ((audiocs_chip_init(state)) == DDI_FAILURE) {
		mutex_exit(&state->cs_lock);
		audio_dev_warn(adev, "chip_init() failed");
		goto error;
	}
	/* chip init will have powered us up */
	state->cs_powered = B_TRUE;

	mutex_exit(&state->cs_lock);

	/* finally register with framework to kick everything off */
	if (audio_dev_register(state->cs_adev) != DDI_SUCCESS) {
		audio_dev_warn(state->cs_adev, "unable to register audio dev");
	}

	/* everything worked out, so report the device */
	ddi_report_dev(dip);

	return (DDI_SUCCESS);

error:
	audiocs_destroy(state);
	return (DDI_FAILURE);
}

/*
 * audiocs_resume()
 *
 * Description:
 *	Resume a suspended device instance.
 *
 * Arguments:
 *	dev_info_t	*dip	Pointer to the device's dev_info struct
 *
 * Returns:
 *	DDI_SUCCESS		The driver was initialized properly
 *	DDI_FAILURE		The driver couldn't be initialized properly
 */
static int
audiocs_resume(dev_info_t *dip)
{
	CS_state_t		*state;
	audio_dev_t		*adev;

	/* we've already allocated the state structure so get ptr */
	state = ddi_get_driver_private(dip);
	adev = state->cs_adev;

	ASSERT(dip == state->cs_dip);
	ASSERT(!mutex_owned(&state->cs_lock));

	/* mark the Codec busy -- this should keep power(9e) away */
	(void) pm_busy_component(state->cs_dip, CS4231_COMPONENT);

	/* power it up */
	audiocs_power_up(state);
	state->cs_powered = B_TRUE;

	mutex_enter(&state->cs_lock);

	/* initialize the audio chip */
	if ((audiocs_chip_init(state)) == DDI_FAILURE) {
		mutex_exit(&state->cs_lock);
		audio_dev_warn(adev, "chip_init() failed");
		(void) pm_idle_component(state->cs_dip, CS4231_COMPONENT);
		return (DDI_FAILURE);
	}

	state->cs_suspended = B_FALSE;

	mutex_exit(&state->cs_lock);

	/*
	 * We have already powered up the chip, but this alerts the
	 * framework to the fact.
	 */
	(void) pm_raise_power(dip, CS4231_COMPONENT, CS4231_PWR_ON);
	(void) pm_idle_component(state->cs_dip, CS4231_COMPONENT);

	audio_dev_resume(state->cs_adev);

	return (DDI_SUCCESS);
}

/*
 * audiocs_detach()
 *
 * Description:
 *	Detach an instance of the CS4231 driver.
 *
 * Arguments:
 *	dev_info_t	*dip	Pointer to the device's dev_info struct
 *
 * Returns:
 *	DDI_SUCCESS		The driver was detached
 *	DDI_FAILURE		The driver couldn't be detached (busy)
 */
static int
audiocs_detach(dev_info_t *dip)
{
	CS_state_t		*state;
	audio_dev_t		*adev;
	ddi_acc_handle_t	handle;

	/* get the state structure */
	state = ddi_get_driver_private(dip);
	handle = CODEC_HANDLE;
	adev = state->cs_adev;

	/* don't detach if still in use */
	if (audio_dev_unregister(adev) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	if (state->cs_powered) {
		/*
		 * Make sure the Codec and DMA engine are off.
		 */
		SELIDX(state, INTC_REG);
		ANDIDX(state, ~(INTC_PEN|INTC_CEN), INTC_VALID_MASK);

		/* make sure the DMA engine isn't going to do anything */
		CS4231_DMA_RESET(state);

		/*
		 * power down the device, no reason to waste power without
		 * a driver
		 */
		(void) pm_lower_power(dip, CS4231_COMPONENT, CS4231_PWR_OFF);
	}

	audiocs_destroy(state);

	return (DDI_SUCCESS);
}

/*
 * audiocs_suspend()
 *
 * Description:
 *	Suspend an instance of the CS4231 driver.
 *
 * Arguments:
 *	dev_info_t	*dip	Pointer to the device's dev_info struct
 *
 * Returns:
 *	DDI_SUCCESS		The driver was detached
 *	DDI_FAILURE		The driver couldn't be detached
 */
static int
audiocs_suspend(dev_info_t *dip)
{
	CS_state_t		*state;

	/* get the state structure */
	state = ddi_get_driver_private(dip);

	mutex_enter(&state->cs_lock);

	ASSERT(!state->cs_suspended);

	audio_dev_suspend(state->cs_adev);

	if (state->cs_powered) {
		/* now we can power down the Codec */
		audiocs_power_down(state);
		state->cs_powered = B_FALSE;
	}
	state->cs_suspended = B_TRUE;	/* stop new ops */
	mutex_exit(&state->cs_lock);

	return (DDI_SUCCESS);
}

#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)
#define	MONVOL	(MONCTL | AUDIO_CTRL_FLAG_MONVOL)

/*
 * audiocs_alloc_ctrl
 *
 * Description:
 *	Allocates a control structure for the audio mixer.
 *
 * Arguments:
 *	CS_state_t	*state		Device soft state.
 *	uint32_t	num		Control number to allocate.
 *	uint64_t	val		Initial value.
 *
 * Returns:
 *	Pointer to newly allocated CS_ctrl_t structure.
 */
static CS_ctrl_t *
audiocs_alloc_ctrl(CS_state_t *state, uint32_t num, uint64_t val)
{
	audio_ctrl_desc_t	desc;
	audio_ctrl_wr_t		fn;
	CS_ctrl_t		*cc;

	cc = kmem_zalloc(sizeof (*cc), KM_SLEEP);
	cc->cc_state = state;
	cc->cc_num = num;

	bzero(&desc, sizeof (desc));

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

	case CTL_IGAIN:
		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 = RECVOL;
		fn = audiocs_set_igain;
		break;

	case CTL_MGAIN:
		desc.acd_name = AUDIO_CTRL_ID_MONGAIN;
		desc.acd_type = AUDIO_CTRL_TYPE_MONO;
		desc.acd_minvalue = 0;
		desc.acd_maxvalue = 100;
		desc.acd_flags = MONVOL;
		fn = audiocs_set_mgain;
		break;

	case CTL_INPUTS:
		desc.acd_name = AUDIO_CTRL_ID_RECSRC;
		desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
		desc.acd_minvalue = state->cs_imask;
		desc.acd_maxvalue = state->cs_imask;
		desc.acd_flags = RECCTL;
		for (int i = 0; audiocs_inputs[i]; i++) {
			desc.acd_enum[i] = audiocs_inputs[i];
		}
		fn = audiocs_set_inputs;

		break;

	case CTL_OUTPUTS:
		desc.acd_name = AUDIO_CTRL_ID_OUTPUTS;
		desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
		desc.acd_minvalue = state->cs_omod;
		desc.acd_maxvalue = state->cs_omask;
		desc.acd_flags = PLAYCTL | AUDIO_CTRL_FLAG_MULTI;
		for (int i = 0; audiocs_outputs[i]; i++) {
			desc.acd_enum[i] = audiocs_outputs[i];
		}
		fn = audiocs_set_outputs;
		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 = audiocs_set_micboost;
		break;
	}

	cc->cc_val = val;
	cc->cc_ctrl = audio_dev_add_control(state->cs_adev, &desc,
	    audiocs_get_value, fn, cc);

	return (cc);
}

/*
 * audiocs_free_ctrl
 *
 * Description:
 *	Frees a control and all resources associated with it.
 *
 * Arguments:
 *	CS_ctrl_t	*cc	Pointer to control structure.
 */
static void
audiocs_free_ctrl(CS_ctrl_t *cc)
{
	if (cc == NULL)
		return;
	if (cc->cc_ctrl)
		audio_dev_del_control(cc->cc_ctrl);
	kmem_free(cc, sizeof (*cc));
}

/*
 * audiocs_add_controls
 *
 * Description:
 *	Allocates and registers all controls for this device.
 *
 * Arguments:
 *	CS_state_t	*state		Device soft state.
 *
 * Returns:
 *	DDI_SUCCESS	All controls added and registered
 *	DDI_FAILURE	At least one control was not added or registered.
 */
static int
audiocs_add_controls(CS_state_t *state)
{
#define	ADD_CTRL(CTL, ID, VAL)						\
	state->cs_##CTL = audiocs_alloc_ctrl(state, ID, VAL);		\
	if (state->cs_##CTL == NULL) {					\
		audio_dev_warn(state->cs_adev,				\
		    "unable to allocate %s control", #ID);		\
		return (DDI_FAILURE);					\
	}

	ADD_CTRL(ogain, CTL_VOLUME, 0x4b4b);
	ADD_CTRL(igain, CTL_IGAIN, 0x3232);
	ADD_CTRL(mgain, CTL_MGAIN, 0);
	ADD_CTRL(micboost, CTL_MICBOOST, 0);
	ADD_CTRL(outputs, CTL_OUTPUTS, (state->cs_omask & ~state->cs_omod) |
	    (1U << OUTPUT_SPEAKER));
	ADD_CTRL(inputs, CTL_INPUTS, (1U << INPUT_MIC));

	return (DDI_SUCCESS);
}

/*
 * audiocs_del_controls
 *
 * Description:
 *	Unregisters and frees all controls for this device.
 *
 * Arguments:
 *	CS_state_t	*state		Device soft state.
 */
void
audiocs_del_controls(CS_state_t *state)
{
	audiocs_free_ctrl(state->cs_ogain);
	audiocs_free_ctrl(state->cs_igain);
	audiocs_free_ctrl(state->cs_mgain);
	audiocs_free_ctrl(state->cs_micboost);
	audiocs_free_ctrl(state->cs_inputs);
	audiocs_free_ctrl(state->cs_outputs);
}


/*
 * audiocs_chip_init()
 *
 * Description:
 *	Power up the audio core, initialize the audio Codec, prepare the chip
 *	for use.
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 *
 * Returns:
 *	DDI_SUCCESS			Chip initialized and ready to use
 *	DDI_FAILURE			Chip not initialized and not ready
 */
static int
audiocs_chip_init(CS_state_t *state)
{
	ddi_acc_handle_t	handle = CODEC_HANDLE;

	/* make sure we are powered up */
	CS4231_DMA_POWER(state, CS4231_PWR_ON);

	CS4231_DMA_RESET(state);

	/* wait for the Codec before we continue */
	if (audiocs_poll_ready(state) == DDI_FAILURE) {
		return (DDI_FAILURE);
	}

	/* activate registers 16 -> 31 */
	SELIDX(state, MID_REG);
	ddi_put8(handle, &CS4231_IDR, MID_MODE2);

	/* now figure out what version we have */
	SELIDX(state, VID_REG);
	if (ddi_get8(handle, &CS4231_IDR) & VID_A) {
		state->cs_revA = B_TRUE;
	} else {
		state->cs_revA = B_FALSE;
	}

	/* get rid of annoying popping by muting the output channels */
	SELIDX(state, LDACO_REG);
	PUTIDX(state, LDACO_LDM | LDACO_MID_GAIN, LDAC0_VALID_MASK);
	SELIDX(state, RDACO_REG);
	PUTIDX(state, RDACO_RDM | RDACO_MID_GAIN, RDAC0_VALID_MASK);

	/* initialize aux input channels to known gain values & muted */
	SELIDX(state, LAUX1_REG);
	PUTIDX(state, LAUX1_LX1M | LAUX1_UNITY_GAIN, LAUX1_VALID_MASK);
	SELIDX(state, RAUX1_REG);
	PUTIDX(state, RAUX1_RX1M | RAUX1_UNITY_GAIN, RAUX1_VALID_MASK);
	SELIDX(state, LAUX2_REG);
	PUTIDX(state, LAUX2_LX2M | LAUX2_UNITY_GAIN, LAUX2_VALID_MASK);
	SELIDX(state, RAUX2_REG);
	PUTIDX(state, RAUX2_RX2M | RAUX2_UNITY_GAIN, RAUX2_VALID_MASK);

	/* initialize aux input channels to known gain values & muted */
	SELIDX(state, LLIC_REG);
	PUTIDX(state, LLIC_LLM | LLIC_UNITY_GAIN, LLIC_VALID_MASK);
	SELIDX(state, RLIC_REG);
	PUTIDX(state, RLIC_RLM | RLIC_UNITY_GAIN, RLIC_VALID_MASK);

	/* program the sample rate, play and capture must be the same */
	SELIDX(state, FSDF_REG | IAR_MCE);
	PUTIDX(state, FS_48000 | PDF_LINEAR16NE | PDF_STEREO, FSDF_VALID_MASK);
	if (audiocs_poll_ready(state) == DDI_FAILURE) {
		return (DDI_FAILURE);
	}

	SELIDX(state, CDF_REG | IAR_MCE);
	PUTIDX(state, CDF_LINEAR16NE | CDF_STEREO, CDF_VALID_MASK);
	if (audiocs_poll_ready(state) == DDI_FAILURE) {
		return (DDI_FAILURE);
	}

	/*
	 * Set up the Codec for playback and capture disabled, dual DMA, and
	 * playback and capture DMA.
	 */
	SELIDX(state, (INTC_REG | IAR_MCE));
	PUTIDX(state, INTC_DDC | INTC_PDMA | INTC_CDMA, INTC_VALID_MASK);
	if (audiocs_poll_ready(state) == DDI_FAILURE) {
		return (DDI_FAILURE);
	}

	/*
	 * Turn on the output level bit to be 2.8 Vpp. Also, don't go to 0 on
	 * underflow.
	 */
	SELIDX(state, AFE1_REG);
	PUTIDX(state, AFE1_OLB, AFE1_VALID_MASK);

	/* turn on the high pass filter if Rev A */
	SELIDX(state, AFE2_REG);
	if (state->cs_revA) {
		PUTIDX(state, AFE2_HPF, AFE2_VALID_MASK);
	} else {
		PUTIDX(state, 0, AFE2_VALID_MASK);
	}


	/* clear the play and capture interrupt flags */
	SELIDX(state, AFS_REG);
	ddi_put8(handle, &CS4231_STATUS, (AFS_RESET_STATUS));

	/* the play and record gains will be set by the audio mixer */

	/* unmute the output */
	SELIDX(state, LDACO_REG);
	ANDIDX(state, ~LDACO_LDM, LDAC0_VALID_MASK);
	SELIDX(state, RDACO_REG);
	ANDIDX(state, ~RDACO_RDM, RDAC0_VALID_MASK);

	/* unmute the mono speaker and mute mono in */
	SELIDX(state, MIOC_REG);
	PUTIDX(state, MIOC_MIM, MIOC_VALID_MASK);

	audiocs_configure_output(state);
	audiocs_configure_input(state);

	return (DDI_SUCCESS);
}

/*
 * audiocs_init_state()
 *
 * Description:
 *	This routine initializes the audio driver's state structure and
 *	maps in the registers. This also includes reading the properties.
 *
 *	CAUTION: This routine maps the registers and initializes a mutex.
 *		 Failure cleanup is handled by cs4231_attach(). It is not
 *		 handled locally by this routine.
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 *
 * Returns:
 *	DDI_SUCCESS			State structure initialized
 *	DDI_FAILURE			State structure not initialized
 */
static int
audiocs_init_state(CS_state_t *state)
{
	audio_dev_t	*adev = state->cs_adev;
	dev_info_t	*dip = state->cs_dip;
	char		*prop_str;
	char		*pm_comp[] = {
				"NAME=audiocs audio device",
				"0=off",
				"1=on" };

	/* set up the pm-components */
	if (ddi_prop_update_string_array(DDI_DEV_T_NONE, dip,
	    "pm-components", pm_comp, 3) != DDI_PROP_SUCCESS) {
		audio_dev_warn(adev, "couldn't create pm-components property");
		return (DDI_FAILURE);
	}

	/* figure out which DMA engine hardware we have */
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "dma-model", &prop_str) == DDI_PROP_SUCCESS) {
		if (strcmp(prop_str, "eb2dma") == 0) {
			state->cs_dma_engine = EB2_DMA;
			state->cs_dma_ops = &cs4231_eb2dma_ops;
		} else {
			state->cs_dma_engine = APC_DMA;
			state->cs_dma_ops = &cs4231_apcdma_ops;
		}
		ddi_prop_free(prop_str);
	} else {
		state->cs_dma_engine = APC_DMA;
		state->cs_dma_ops = &cs4231_apcdma_ops;
	}

	/* cs_regs, cs_eb2_regs and cs_handles filled in later */

	/* most of what's left is filled in when the registers are mapped */

	audiocs_get_ports(state);

	/* Allocate engines, must be done before register mapping called  */
	if ((audiocs_alloc_engine(state, CS4231_PLAY) != DDI_SUCCESS) ||
	    (audiocs_alloc_engine(state, CS4231_REC) != DDI_SUCCESS)) {
		return (DDI_FAILURE);
	}

	/* Map in the registers */
	if (CS4231_DMA_MAP_REGS(state) == DDI_FAILURE) {
		return (DDI_FAILURE);
	}


	/* Allocate and add controls, must be done *after* registers mapped */
	if (audiocs_add_controls(state) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	state->cs_suspended = B_FALSE;
	state->cs_powered = B_FALSE;

	return (DDI_SUCCESS);
}

/*
 * audiocs_get_ports()
 *
 * Description:
 *	Get which audiocs h/w version we have and use this to
 *	determine the input and output ports as well whether or not
 *	the hardware has internal loopbacks or not. We also have three
 *	different ways for the properties to be specified, which we
 *	also need to worry about.
 *
 * Vers	Platform(s)	DMA eng.	audio-module**	loopback
 * a    SS-4+/SS-5+	apcdma		no		no
 * b	Ultra-1&2	apcdma		no		yes
 * c	positron	apcdma		no		yes
 * d	PPC - retired
 * e	x86 - retired
 * f	tazmo		eb2dma		Perigee		no
 * g	tazmo		eb2dma		Quark		yes
 * h	darwin+		eb2dma		no		N/A
 *
 * Vers	model~		aux1*		aux2*
 * a	N/A		N/A		N/A
 * b	N/A		N/A		N/A
 * c	N/A		N/A		N/A
 * d	retired
 * e	retired
 * f	SUNW,CS4231f	N/A		N/A
 * g	SUNW,CS4231g	N/A		N/A
 * h	SUNW,CS4231h	cdrom		none
 *
 * *   = Replaces internal-loopback for latest property type, can be
 *	 set to "cdrom", "loopback", or "none".
 *
 * **  = For plugin audio modules only. Starting with darwin, this
 *	 property is replaces by the model property.
 *
 * ~   = Replaces audio-module.
 *
 * +   = Has the capability of having a cable run from the internal
 *	 CD-ROM to the audio device.
 *
 * N/A = Not applicable, the property wasn't created for early
 *	 platforms, or the property has been retired.
 *
 * NOTE: Older tazmo and quark machines don't have the model property.
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 */
static void
audiocs_get_ports(CS_state_t *state)
{
	dev_info_t	*dip = state->cs_dip;
	audio_dev_t	*adev = state->cs_adev;
	char		*prop_str;

	/* First we set the common ports, etc. */
	state->cs_omask = state->cs_omod =
	    (1U << OUTPUT_SPEAKER) |
	    (1U << OUTPUT_HEADPHONES) |
	    (1U << OUTPUT_LINEOUT);
	state->cs_imask =
	    (1U << INPUT_MIC) |
	    (1U << INPUT_LINEIN) |
	    (1U << INPUT_STEREOMIX);

	/* now we try the new "model" property */
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "model", &prop_str) == DDI_PROP_SUCCESS) {
		if (strcmp(prop_str, "SUNW,CS4231h") == 0) {
			/* darwin */
			audio_dev_set_version(adev, CS_DEV_VERSION_H);
			state->cs_imask |= (1U << INPUT_CD);
			state->cs_omod = (1U << OUTPUT_SPEAKER);
		} else if (strcmp(prop_str, "SUNW,CS4231g") == 0) {
			/* quark audio module */
			audio_dev_set_version(adev, CS_DEV_VERSION_G);
			/*
			 * NB: This could do SUNVTS LOOPBACK, but we
			 * don't support it for now... owing to no
			 * support in framework.
			 */
		} else if (strcmp(prop_str, "SUNW,CS4231f") == 0) {
			/* tazmo */
			audio_dev_set_version(adev, CS_DEV_VERSION_F);
		} else {
			audio_dev_set_version(adev, prop_str);
			audio_dev_warn(adev,
			    "unknown audio model: %s, some parts of "
			    "audio may not work correctly", prop_str);
		}
		ddi_prop_free(prop_str);	/* done with the property */
	} else {	/* now try the older "audio-module" property */
		if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
		    DDI_PROP_DONTPASS, "audio-module", &prop_str) ==
		    DDI_PROP_SUCCESS) {
			switch (*prop_str) {
			case 'Q':	/* quark audio module */
				audio_dev_set_version(adev, CS_DEV_VERSION_G);
				/* See quark comment above about SunVTS */
				break;
			case 'P':	/* tazmo */
				audio_dev_set_version(adev, CS_DEV_VERSION_F);
				break;
			default:
				audio_dev_set_version(adev, prop_str);
				audio_dev_warn(adev,
				    "unknown audio module: %s, some "
				    "parts of audio may not work correctly",
				    prop_str);
				break;
			}
			ddi_prop_free(prop_str);	/* done with the prop */
		} else {	/* now try heuristics, ;-( */
			if (ddi_prop_get_int(DDI_DEV_T_ANY, dip,
			    DDI_PROP_DONTPASS, "internal-loopback", B_FALSE)) {
				if (state->cs_dma_engine == EB2_DMA) {
					audio_dev_set_version(adev,
					    CS_DEV_VERSION_C);
				} else {
					audio_dev_set_version(adev,
					    CS_DEV_VERSION_B);
				}
				/*
				 * Again, we don't support SunVTS for these
				 * boards, although we potentially could.
				 */
			} else {
				audio_dev_set_version(adev, CS_DEV_VERSION_A);
				state->cs_imask |= (1U << INPUT_CD);
			}
		}
	}
}

/*
 * audiocs_power_up()
 *
 * Description:
 *	Power up the Codec and restore the codec's registers.
 *
 *	NOTE: We don't worry about locking since the only routines
 *		that may call us are attach() and power() Both of
 *		which should be the only threads in the driver.
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 */
static void
audiocs_power_up(CS_state_t *state)
{
	ddi_acc_handle_t	handle = CODEC_HANDLE;
	int			i;

	/* turn on the Codec */
	CS4231_DMA_POWER(state, CS4231_PWR_ON);

	/* reset the DMA engine(s) */
	CS4231_DMA_RESET(state);

	(void) audiocs_poll_ready(state);

	/*
	 * Reload the Codec's registers, the DMA engines will be
	 * taken care of when play and record start up again. But
	 * first enable registers 16 -> 31.
	 */
	SELIDX(state, MID_REG);
	PUTIDX(state, state->cs_save[MID_REG], MID_VALID_MASK);

	for (i = 0; i < CS4231_REGS; i++) {
		/* restore Codec registers */
		SELIDX(state, (i | IAR_MCE));
		ddi_put8(handle, &CS4231_IDR, state->cs_save[i]);
		(void) audiocs_poll_ready(state);
	}
	/* clear MCE bit */
	SELIDX(state, 0);
}

/*
 * audiocs_power_down()
 *
 * Description:
 *	Power down the Codec and save the codec's registers.
 *
 *	NOTE: See the note in cs4231_power_up() about locking.
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 */
static void
audiocs_power_down(CS_state_t *state)
{
	ddi_acc_handle_t	handle;
	int			i;

	handle = state->cs_handles.cs_codec_hndl;

	/*
	 * We are powering down, so we don't need to do a thing with
	 * the DMA engines. However, we do need to save the Codec
	 * registers.
	 */

	for (i = 0; i < CS4231_REGS; i++) {
		/* save Codec regs */
		SELIDX(state, i);
		state->cs_save[i] = ddi_get8(handle, &CS4231_IDR);
	}

	/* turn off the Codec */
	CS4231_DMA_POWER(state, CS4231_PWR_OFF);

}	/* cs4231_power_down() */

/*
 * audiocs_configure_input()
 *
 * Description:
 *	Configure input properties of the mixer (e.g. igain, ports).
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 */
static void
audiocs_configure_input(CS_state_t *state)
{
	uint8_t		l, r;
	uint64_t	inputs;
	uint64_t	micboost;

	ASSERT(mutex_owned(&state->cs_lock));

	inputs = state->cs_inputs->cc_val;
	micboost = state->cs_micboost->cc_val;
	r = (state->cs_igain->cc_val & 0xff);
	l = ((state->cs_igain->cc_val & 0xff00) >> 8);

	/* rescale these for our atten array */
	l = (((uint32_t)l * 255) / 100) & 0xff;
	r = (((uint32_t)r * 255) / 100) & 0xff;

	/* we downshift by 4 bits -- igain only has 16 possible values */
	/* NB: that we do not scale here!  The SADA driver didn't do so. */
	l = l >> 4;
	r = r >> 4;

	if (inputs & (1U << INPUT_MIC)) {
		l |= LADCI_LMIC;
		r |= RADCI_RMIC;
	}
	if (inputs & (1U << INPUT_LINEIN)) {
		l |= LADCI_LLINE;
		r |= RADCI_RLINE;
	}
	if (inputs & (1U << INPUT_CD)) {
		/* note that SunVTS also uses this */
		l |= LADCI_LAUX1;
		r |= RADCI_RAUX1;
	}
	if (inputs & (1U << INPUT_STEREOMIX)) {
		l |= LADCI_LLOOP;
		r |= RADCI_RLOOP;
	}
	if (micboost) {
		l |= LADCI_LMGE;
		r |= RADCI_RMGE;
	}

	SELIDX(state, LADCI_REG);
	PUTIDX(state, l, LADCI_VALID_MASK);

	SELIDX(state, RADCI_REG);
	PUTIDX(state, r, RADCI_VALID_MASK);
}

/*
 * audiocs_configure_output()
 *
 * Description:
 *	Configure output properties of the mixer (e.g. ogain, mgain).
 *
 * Arguments:
 *	CS_state_t	*state		The device's state structure
 */
static void
audiocs_configure_output(CS_state_t *state)
{
	uint64_t		outputs;
	uint8_t			l, r;
	uint8_t			rmute, lmute;
	uint8_t			mgain;
	ddi_acc_handle_t	handle = CODEC_HANDLE;

	rmute = lmute = 0;

	ASSERT(mutex_owned(&state->cs_lock));

	outputs = state->cs_outputs->cc_val;

	/* port selection */
	SELIDX(state, MIOC_REG);
	if (outputs & (1U << OUTPUT_SPEAKER)) {
		ANDIDX(state, ~MIOC_MONO_SPKR_MUTE, MIOC_VALID_MASK);
	} else {
		ORIDX(state, MIOC_MONO_SPKR_MUTE, MIOC_VALID_MASK);
	}
	SELIDX(state, PC_REG);
	if (outputs & (1U << OUTPUT_HEADPHONES)) {
		ANDIDX(state, ~PC_HEADPHONE_MUTE, PC_VALID_MASK);
	} else {
		ORIDX(state, PC_HEADPHONE_MUTE, PC_VALID_MASK);
	}
	SELIDX(state, PC_REG);
	if (outputs & (1U << OUTPUT_LINEOUT)) {
		ANDIDX(state, ~PC_LINE_OUT_MUTE, PC_VALID_MASK);
	} else {
		ORIDX(state, PC_LINE_OUT_MUTE, PC_VALID_MASK);
	}

	/* monitor gain */
	mgain = cs4231_atten[((state->cs_mgain->cc_val * 255) / 100) & 0xff];
	SELIDX(state, LC_REG);
	if (mgain == 0) {
		/* disable loopbacks when gain == 0 */
		PUTIDX(state, LC_OFF, LC_VALID_MASK);
	} else {
		/* we use cs4231_atten[] to linearize attenuation */
		PUTIDX(state, (mgain << 2) | LC_LBE, LC_VALID_MASK);
	}

	/* output gain */
	l = ((state->cs_ogain->cc_val >> 8) & 0xff);
	r = (state->cs_ogain->cc_val & 0xff);
	if (l == 0) {
		lmute = LDACO_LDM;
	}
	if (r == 0) {
		rmute = RDACO_RDM;
	}

	/* rescale these for our atten array */
	l = cs4231_atten[(((uint32_t)l * 255) / 100) & 0xff] | lmute;
	r = cs4231_atten[(((uint32_t)r * 255) / 100) & 0xff] | rmute;

	SELIDX(state, LDACO_REG);
	PUTIDX(state, l, LDAC0_VALID_MASK);
	SELIDX(state, RDACO_REG);
	PUTIDX(state, r, RDAC0_VALID_MASK);
}

/*
 * audiocs_get_value()
 *
 * Description:
 *	Get a control value
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	*valp		Pointer to store value.
 *
 * Returns:
 *	0		The Codec parameter has been retrieved.
 */
static int
audiocs_get_value(void *arg, uint64_t *valp)
{
	CS_ctrl_t		*cc = arg;
	CS_state_t		*state = cc->cc_state;

	mutex_enter(&state->cs_lock);
	*valp = cc->cc_val;
	mutex_exit(&state->cs_lock);
	return (0);
}


/*
 * audiocs_set_ogain()
 *
 * Description:
 *	Set the play gain.
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	val		The gain to set (both left and right)
 *
 * Returns:
 *	0		The Codec parameter has been set
 */
static int
audiocs_set_ogain(void *arg, uint64_t val)
{
	CS_ctrl_t		*cc = arg;
	CS_state_t		*state = cc->cc_state;

	if ((val & ~0xffff) ||
	    ((val & 0xff) > 100) ||
	    (((val & 0xff00) >> 8) > 100))
		return (EINVAL);

	mutex_enter(&state->cs_lock);
	cc->cc_val = val;
	audiocs_configure_output(state);
	mutex_exit(&state->cs_lock);
	return (0);
}

/*
 * audiocs_set_micboost()
 *
 * Description:
 *	Set the 20 dB microphone boost.
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	val		The 1 to enable, 0 to disable.
 *
 * Returns:
 *	0		The Codec parameter has been set
 */
static int
audiocs_set_micboost(void *arg, uint64_t val)
{
	CS_ctrl_t	*cc = arg;
	CS_state_t	*state = cc->cc_state;

	mutex_enter(&state->cs_lock);
	cc->cc_val = val ? B_TRUE : B_FALSE;
	audiocs_configure_input(state);
	mutex_exit(&state->cs_lock);
	return (0);
}

/*
 * audiocs_set_igain()
 *
 * Description:
 *	Set the record gain.
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	val		The gain to set (both left and right)
 *
 * Returns:
 *	0		The Codec parameter has been set
 */
static int
audiocs_set_igain(void *arg, uint64_t val)
{
	CS_ctrl_t	*cc = arg;
	CS_state_t	*state = cc->cc_state;

	if ((val & ~0xffff) ||
	    ((val & 0xff) > 100) ||
	    (((val & 0xff00) >> 8) > 100))
		return (EINVAL);

	mutex_enter(&state->cs_lock);
	cc->cc_val = val;
	audiocs_configure_input(state);
	mutex_exit(&state->cs_lock);

	return (0);
}

/*
 * audiocs_set_inputs()
 *
 * Description:
 *	Set the input ports.
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	val		The mask of output ports.
 *
 * Returns:
 *	0		The Codec parameter has been set
 */
static int
audiocs_set_inputs(void *arg, uint64_t val)
{
	CS_ctrl_t	*cc = arg;
	CS_state_t	*state = cc->cc_state;

	if (val & ~(state->cs_imask))
		return (EINVAL);

	mutex_enter(&state->cs_lock);
	cc->cc_val = val;
	audiocs_configure_input(state);
	mutex_exit(&state->cs_lock);

	return (0);
}

/*
 * audiocs_set_outputs()
 *
 * Description:
 *	Set the output ports.
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	val		The mask of input ports.
 *
 * Returns:
 *	0		The Codec parameter has been set
 */
static int
audiocs_set_outputs(void *arg, uint64_t val)
{
	CS_ctrl_t	*cc = arg;
	CS_state_t	*state = cc->cc_state;

	if ((val & ~(state->cs_omod)) !=
	    (state->cs_omask & ~state->cs_omod))
		return (EINVAL);

	mutex_enter(&state->cs_lock);
	cc->cc_val = val;
	audiocs_configure_output(state);
	mutex_exit(&state->cs_lock);

	return (0);
}

/*
 * audiocs_set_mgain()
 *
 * Description:
 *	Set the monitor gain.
 *
 * Arguments:
 *	void		*arg		The device's state structure
 *	uint64_t	val		The gain to set (monoaural).)
 *
 * Returns:
 *	0		The Codec parameter has been set
 */
static int
audiocs_set_mgain(void *arg, uint64_t gain)
{
	CS_ctrl_t	*cc = arg;
	CS_state_t	*state = cc->cc_state;

	if (gain > 100)
		return (EINVAL);

	mutex_enter(&state->cs_lock);
	cc->cc_val = gain;
	audiocs_configure_output(state);
	mutex_exit(&state->cs_lock);

	return (0);
}

/*
 * audiocs_open()
 *
 * Description:
 *	Opens a DMA engine for use.
 *
 * Arguments:
 *	void		*arg		The DMA engine to set up
 *	int		flag		Open flags
 *	unsigned	*nframesp	Receives number of frames
 *	caddr_t		*bufp		Receives kernel data buffer
 *
 * Returns:
 *	0	on success
 *	errno	on failure
 */
static int
audiocs_open(void *arg, int flag, unsigned *nframesp, caddr_t *bufp)
{
	CS_engine_t	*eng = arg;
	CS_state_t	*state = eng->ce_state;
	dev_info_t	*dip = state->cs_dip;

	_NOTE(ARGUNUSED(flag));

	(void) pm_busy_component(dip, CS4231_COMPONENT);
	if (pm_raise_power(dip, CS4231_COMPONENT, CS4231_PWR_ON) ==
	    DDI_FAILURE) {

		/* match the busy call above */
		(void) pm_idle_component(dip, CS4231_COMPONENT);

		audio_dev_warn(state->cs_adev, "power up failed");
	}

	eng->ce_count = 0;
	*nframesp = CS4231_NFRAMES;
	*bufp = eng->ce_kaddr;

	return (0);
}

/*
 * audiocs_close()
 *
 * Description:
 *	Closes an audio DMA engine that was previously opened.  Since
 *	nobody is using it, we take this opportunity to possibly power
 *	down the entire device.
 *
 * Arguments:
 *	void	*arg		The DMA engine to shut down
 */
static void
audiocs_close(void *arg)
{
	CS_engine_t	*eng = arg;
	CS_state_t	*state = eng->ce_state;

	(void) pm_idle_component(state->cs_dip, CS4231_COMPONENT);
}

/*
 * audiocs_stop()
 *
 * Description:
 *	This is called by the framework to stop an engine that is
 *	transferring data.
 *
 * Arguments:
 *	void	*arg		The DMA engine to stop
 */
static void
audiocs_stop(void *arg)
{
	CS_engine_t		*eng = arg;
	CS_state_t		*state = eng->ce_state;
	ddi_acc_handle_t	handle = CODEC_HANDLE;

	mutex_enter(&state->cs_lock);
	/*
	 * Stop the DMA engine.
	 */
	CS4231_DMA_STOP(state, eng);

	/*
	 * Stop the codec.
	 */
	SELIDX(state, INTC_REG);
	ANDIDX(state, ~(eng->ce_codec_en), INTC_VALID_MASK);
	mutex_exit(&state->cs_lock);
}

/*
 * audiocs_start()
 *
 * Description:
 *	This is called by the framework to start an engine transferring data.
 *
 * Arguments:
 *	void	*arg		The DMA engine to start
 *
 * Returns:
 *	0 	on success, an errno otherwise
 */
static int
audiocs_start(void *arg)
{
	CS_engine_t		*eng = arg;
	CS_state_t		*state = eng->ce_state;
	ddi_acc_handle_t	handle = CODEC_HANDLE;
	uint8_t			mask;
	uint8_t			value;
	uint8_t			reg;
	int			rv;

	mutex_enter(&state->cs_lock);

	if (eng->ce_num == CS4231_PLAY) {
		/* sample rate only set on play side */
		value = FS_48000 | PDF_STEREO | PDF_LINEAR16NE;
		reg = FSDF_REG;
		mask = FSDF_VALID_MASK;
	} else {
		value = CDF_STEREO | CDF_LINEAR16NE;
		reg = CDF_REG;
		mask = CDF_VALID_MASK;
	}
	eng->ce_curoff = 0;
	eng->ce_curidx = 0;

	SELIDX(state, reg | IAR_MCE);
	PUTIDX(state, value, mask);

	if (audiocs_poll_ready(state) != DDI_SUCCESS) {
		rv = EIO;
	} else if (CS4231_DMA_START(state, eng) != DDI_SUCCESS) {
		rv = EIO;
	} else {
		/*
		 * Start the codec.
		 */
		SELIDX(state, INTC_REG);
		ORIDX(state, eng->ce_codec_en, INTC_VALID_MASK);
		rv = 0;
	}

	mutex_exit(&state->cs_lock);
	return (rv);
}

/*
 * audiocs_format()
 *
 * Description:
 *	Called by the framework to query the format of the device.
 *
 * Arguments:
 *	void	*arg		The DMA engine to query
 *
 * Returns:
 *	AUDIO_FORMAT_S16_NE
 */
static int
audiocs_format(void *arg)
{
	_NOTE(ARGUNUSED(arg));

	return (AUDIO_FORMAT_S16_NE);
}

/*
 * audiocs_channels()
 *
 * Description:
 *	Called by the framework to query the channels of the device.
 *
 * Arguments:
 *	void	*arg		The DMA engine to query
 *
 * Returns:
 *	2 (stereo)
 */
static int
audiocs_channels(void *arg)
{
	_NOTE(ARGUNUSED(arg));

	return (2);
}

/*
 * audiocs_rates()
 *
 * Description:
 *	Called by the framework to query the sample rate of the device.
 *
 * Arguments:
 *	void	*arg		The DMA engine to query
 *
 * Returns:
 *	48000
 */
static int
audiocs_rate(void *arg)
{
	_NOTE(ARGUNUSED(arg));

	return (48000);
}

/*
 * audiocs_count()
 *
 * Description:
 *	This is called by the framework to get the engine's frame counter
 *
 * Arguments:
 *	void	*arg		The DMA engine to query
 *
 * Returns:
 *	frame count for current engine
 */
static uint64_t
audiocs_count(void *arg)
{
	CS_engine_t		*eng = arg;
	CS_state_t		*state = eng->ce_state;
	uint64_t		val;
	uint32_t		off;

	mutex_enter(&state->cs_lock);

	off = CS4231_DMA_ADDR(state, eng);
	ASSERT(off >= eng->ce_paddr);
	off -= eng->ce_paddr;

	/*
	 * Every now and then, we get a value that is just a wee bit
	 * too large.  This seems to be a small value related to
	 * prefetch.  Rather than believe it, we just assume the last
	 * offset in the buffer.  This should allow us to handle
	 * wraps, but without inserting bogus sample counts.
	 */
	if (off >= CS4231_BUFSZ) {
		off = CS4231_BUFSZ - 4;
	}

	off /= 4;

	val = (off >= eng->ce_curoff) ?
	    off - eng->ce_curoff :
	    off + CS4231_NFRAMES - eng->ce_curoff;

	eng->ce_count += val;
	eng->ce_curoff = off;
	val = eng->ce_count;

	/* while here, possibly reload the next address */
	CS4231_DMA_RELOAD(state, eng);
	mutex_exit(&state->cs_lock);

	return (val);
}

/*
 * audiocs_sync()
 *
 * Description:
 *	This is called by the framework to synchronize DMA caches.
 *
 * Arguments:
 *	void	*arg		The DMA engine to sync
 */
static void
audiocs_sync(void *arg, unsigned nframes)
{
	CS_engine_t *eng = arg;
	_NOTE(ARGUNUSED(nframes));

	(void) ddi_dma_sync(eng->ce_dmah, 0, 0, eng->ce_syncdir);
}

/*
 * audiocs_alloc_engine()
 *
 * Description:
 *	Allocates the DMA handles and the memory for the DMA engine.
 *
 * Arguments:
 *	CS_state_t	*dip	Pointer to the device's soft state
 *	int		num	Engine number, CS4231_PLAY or CS4231_REC.
 *
 * Returns:
 *	DDI_SUCCESS		Engine initialized.
 *	DDI_FAILURE		Engine not initialized.
 */
int
audiocs_alloc_engine(CS_state_t *state, int num)
{
	unsigned		caps;
	int			dir;
	int			rc;
	audio_dev_t		*adev;
	dev_info_t		*dip;
	CS_engine_t		*eng;
	uint_t			ccnt;
	ddi_dma_cookie_t	dmac;
	size_t			bufsz;

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

	adev = state->cs_adev;
	dip = state->cs_dip;

	eng = kmem_zalloc(sizeof (*eng), KM_SLEEP);
	eng->ce_state = state;
	eng->ce_started = B_FALSE;
	eng->ce_num = num;

	switch (num) {
	case CS4231_REC:
		dir = DDI_DMA_READ;
		caps = ENGINE_INPUT_CAP;
		eng->ce_syncdir = DDI_DMA_SYNC_FORKERNEL;
		eng->ce_codec_en = INTC_CEN;
		break;
	case CS4231_PLAY:
		dir = DDI_DMA_WRITE;
		caps = ENGINE_OUTPUT_CAP;
		eng->ce_syncdir = DDI_DMA_SYNC_FORDEV;
		eng->ce_codec_en = INTC_PEN;
		break;
	default:
		kmem_free(eng, sizeof (*eng));
		audio_dev_warn(adev, "bad engine number (%d)!", num);
		return (DDI_FAILURE);
	}
	state->cs_engines[num] = eng;

	/* allocate dma handle */
	rc = ddi_dma_alloc_handle(dip, CS4231_DMA_ATTR(state), DDI_DMA_SLEEP,
	    NULL, &eng->ce_dmah);
	if (rc != DDI_SUCCESS) {
		audio_dev_warn(adev, "ddi_dma_alloc_handle failed: %d", rc);
		return (DDI_FAILURE);
	}
	/* allocate DMA buffer */
	rc = ddi_dma_mem_alloc(eng->ce_dmah, CS4231_BUFSZ, &buf_attr,
	    DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &eng->ce_kaddr,
	    &bufsz, &eng->ce_acch);
	if (rc == DDI_FAILURE) {
		audio_dev_warn(adev, "dma_mem_alloc failed");
		return (DDI_FAILURE);
	}

	/* bind DMA buffer */
	rc = ddi_dma_addr_bind_handle(eng->ce_dmah, NULL,
	    eng->ce_kaddr, CS4231_BUFSZ, dir | DDI_DMA_CONSISTENT,
	    DDI_DMA_SLEEP, NULL, &dmac, &ccnt);
	if ((rc != DDI_DMA_MAPPED) || (ccnt != 1)) {
		audio_dev_warn(adev,
		    "ddi_dma_addr_bind_handle failed: %d", rc);
		return (DDI_FAILURE);
	}

	eng->ce_paddr = dmac.dmac_address;

	eng->ce_engine = audio_engine_alloc(&audiocs_engine_ops, caps);
	if (eng->ce_engine == NULL) {
		audio_dev_warn(adev, "audio_engine_alloc failed");
		return (DDI_FAILURE);
	}

	audio_engine_set_private(eng->ce_engine, eng);
	audio_dev_add_engine(adev, eng->ce_engine);
	return (DDI_SUCCESS);
}

/*
 * audiocs_free_engine()
 *
 * Description:
 *	This routine fress the engine and all associated resources.
 *
 * Arguments:
 *	CS_engine_t	*eng	Engine to free.
 */
void
audiocs_free_engine(CS_engine_t *eng)
{
	CS_state_t	*state = eng->ce_state;
	audio_dev_t	*adev = state->cs_adev;

	if (eng == NULL)
		return;
	if (eng->ce_engine) {
		audio_dev_remove_engine(adev, eng->ce_engine);
		audio_engine_free(eng->ce_engine);
	}
	if (eng->ce_paddr) {
		(void) ddi_dma_unbind_handle(eng->ce_dmah);
	}
	if (eng->ce_acch) {
		ddi_dma_mem_free(&eng->ce_acch);
	}
	if (eng->ce_dmah) {
		ddi_dma_free_handle(&eng->ce_dmah);
	}
	kmem_free(eng, sizeof (*eng));
}

/*
 * audiocs_poll_ready()
 *
 * Description:
 *	This routine waits for the Codec to complete its initialization
 *	sequence and is done with its autocalibration.
 *
 *	Early versions of the Codec have a bug that can take as long as
 *	15 seconds to complete its initialization. For these cases we
 *	use a timeout mechanism so we don't keep the machine locked up.
 *
 * Arguments:
 *	CS_state_t	*state	The device's state structure
 *
 * Returns:
 *	DDI_SUCCESS		The Codec is ready to continue
 *	DDI_FAILURE		The Codec isn't ready to continue
 */
int
audiocs_poll_ready(CS_state_t *state)
{
	ddi_acc_handle_t	handle = CODEC_HANDLE;
	int			x = 0;
	uint8_t			iar;
	uint8_t			idr;

	ASSERT(state->cs_regs != NULL);
	ASSERT(handle != NULL);

	/* wait for the chip to initialize itself */
	iar = ddi_get8(handle, &CS4231_IAR);

	while ((iar & IAR_INIT) && x++ < CS4231_TIMEOUT) {
		drv_usecwait(50);
		iar = ddi_get8(handle, &CS4231_IAR);
	}

	if (x >= CS4231_TIMEOUT) {
		return (DDI_FAILURE);
	}

	x = 0;

	/*
	 * Now wait for the chip to complete its autocalibration.
	 * Set the test register.
	 */
	SELIDX(state, ESI_REG);

	idr = ddi_get8(handle, &CS4231_IDR);

	while ((idr & ESI_ACI) && x++ < CS4231_TIMEOUT) {
		drv_usecwait(50);
		idr = ddi_get8(handle, &CS4231_IDR);
	}

	if (x >= CS4231_TIMEOUT) {
		return (DDI_FAILURE);
	}


	return (DDI_SUCCESS);

}

/*
 * audiocs_sel_index()
 *
 * Description:
 *	Select a cs4231 register. The cs4231 has a hardware bug where a
 *	register is not always selected the first time. We try and try
 *	again until the proper register is selected or we time out and
 *	print an error message.
 *
 * Arguments:
 *	audiohdl_t	ahandle		Handle to this device
 *	ddi_acc_handle_t handle		A handle to the device's registers
 *	uint8_t		addr		The register address to program
 *	int		reg		The register to select
 */
void
#ifdef	DEBUG
audiocs_sel_index(CS_state_t *state, uint8_t reg, int n)
#else
audiocs_sel_index(CS_state_t *state, uint8_t reg)
#endif
{
	int			x;
	uint8_t			T;
	ddi_acc_handle_t	handle = CODEC_HANDLE;
	uint8_t			*addr = &CS4231_IAR;

	for (x = 0; x < CS4231_RETRIES; x++) {
		ddi_put8(handle, addr, reg);
		T = ddi_get8(handle, addr);
		if (T == reg) {
			break;
		}
		drv_usecwait(1000);
	}

	if (x == CS4231_RETRIES) {
		audio_dev_warn(state->cs_adev,
#ifdef	DEBUG
		    "line %d: Couldn't select index (0x%02x 0x%02x)", n,
#else
		    "Couldn't select index (0x%02x 0x%02x)",
#endif
		    T, reg);
		audio_dev_warn(state->cs_adev,
		    "audio may not work correctly until it is stopped and "
		    "restarted");
	}
}

/*
 * audiocs_put_index()
 *
 * Description:
 *	Program a cs4231 register. The cs4231 has a hardware bug where a
 *	register is not programmed properly the first time. We program a value,
 *	then immediately read back the value and reprogram if nescessary.
 *	We do this until the register is properly programmed or we time out and
 *	print an error message.
 *
 * Arguments:
 *	CS_state_t	state		Handle to this device
 *	uint8_t		mask		Mask to not set reserved register bits
 *	int		val		The value to program
 */
void
#ifdef DEBUG
audiocs_put_index(CS_state_t *state, uint8_t val, uint8_t mask, int n)
#else
audiocs_put_index(CS_state_t *state, uint8_t val, uint8_t mask)
#endif
{
	int			x;
	uint8_t			T;
	ddi_acc_handle_t	handle = CODEC_HANDLE;
	uint8_t			*addr = &CS4231_IDR;

	val &= mask;

	for (x = 0; x < CS4231_RETRIES; x++) {
		ddi_put8(handle, addr, val);
		T = ddi_get8(handle, addr);
		if (T == val) {
			break;
		}
		drv_usecwait(1000);
	}

	if (x == CS4231_RETRIES) {
#ifdef DEBUG
		audio_dev_warn(state->cs_adev,
		    "line %d: Couldn't set value (0x%02x 0x%02x)", n, T, val);
#else
		audio_dev_warn(state->cs_adev,
		    "Couldn't set value (0x%02x 0x%02x)", T, val);
#endif
		audio_dev_warn(state->cs_adev,
		    "audio may not work correctly until it is stopped and "
		    "restarted");
	}
}