xref: /src/sys/dev/pci/voyager/vac.c

/* $NetBSD: vac.c,v 1.2 2026/06/22 15:12:59 rkujawa Exp $ */

/*-
 * Copyright (c) 2026 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Driver for the SM502 AC'97 audio interface
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: vac.c,v 1.2 2026/06/22 15:12:59 rkujawa Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/bus.h>
#include <sys/callout.h>
#include <sys/sysctl.h>
#include <sys/audioio.h>

#include <dev/audio/audio_if.h>

#include <dev/ic/ac97var.h>
#include <dev/ic/ac97reg.h>

#include <dev/ic/sm502reg.h>
#include <dev/pci/voyagervar.h>

/* PCM playback format: AC'97 fixed 48 kHz, 16-bit, stereo. */
#define	VAC_RATE	48000
#define	VAC_CHANNELS	2
#define	VAC_PRECISION	16
#define	VAC_FRAMESIZE	(VAC_CHANNELS * (VAC_PRECISION / 8))	/* 4 bytes */

/* poll when waiting on the codec */
#define	VAC_CODEC_TIMEOUT	1000

/*
 * 8051 polled protocol, via 4KB dual-port SRAM
 *
 * Two PCM buffers selected by command parity
 */
#define	VAC_DP_BASE		SM502_uC_SRAM_DUALPORT
#define	VAC_DP_H_CMD		0x00	/* u8  host: command sequence */
#define	VAC_DP_H_DONE		0x01	/* u8  8051: last finished command */
#define	VAC_DP_H_ALIVE		0x03	/* u8  8051: VAC_DP_ALIVE_MAGIC when up */
#define	VAC_DP_H_FC0L		0x04	/* u16 host: buf0 frame count, LE */
#define	VAC_DP_H_FC0H		0x05
#define	VAC_DP_H_FC1L		0x06	/* u16 host: buf1 frame count, LE */
#define	VAC_DP_H_FC1H		0x07
#define	VAC_DP_BUF0		0x10
#define	VAC_DP_MAXFRAMES	504	/* per buffer; 504*4=0x7e0, both fit 4KB */
#define	VAC_DP_BUFBYTES		(VAC_DP_MAXFRAMES * VAC_FRAMESIZE)
#define	VAC_DP_BUF1		(VAC_DP_BUF0 + VAC_DP_BUFBYTES)	/* 0x7f0 */
#define	VAC_DP_ALIVE_MAGIC	0x51

struct vac_softc {
	device_t		sc_dev;
	bus_space_tag_t		sc_memt;
	bus_space_handle_t	sc_regh;	/* BAR 0x14: MMIO registers */
	void			*sc_parent;	/* voyager softc, for gpio/power */

	kmutex_t		sc_lock;	/* thread context */
	kmutex_t		sc_intr_lock;	/* "interrupt" context */

	struct ac97_host_if	sc_ac97_host;
	struct ac97_codec_if	*sc_ac97_codec;
	device_t		sc_audiodev;

	/* MI playback ring (filled by the audio layer, consumed by the feeder) */
	bool			sc_active;	/* playback in progress */
	uint8_t			*sc_pstart;
	uint8_t			*sc_pend;
	uint8_t			*sc_pcur;
	int			sc_pblksize;
	void			(*sc_pint)(void *);
	void			*sc_pintarg;

	/* 8051 interface */
	callout_t		sc_feed_ch;	/* polls H_DONE, refills buffers */
	int			sc_feed_ticks;	/* callout period */
	uint8_t			*sc_dpstage;	/* staging for one dual-port buf */
	uint8_t			sc_cmd_seq;	/* last command we queued */
	uint8_t			sc_done_seen;	/* last H_DONE we acted on */
	bool			sc_8051_ok;	/* feeder firmware responded */
	int			sc_underruns;	/* 8051 ran dry while playing */

	struct sysctllog	*sc_sysctllog;
};

#define	VAC_READ(sc, reg)		\
	bus_space_read_4((sc)->sc_memt, (sc)->sc_regh, (reg))
#define	VAC_WRITE(sc, reg, val)		\
	bus_space_write_4((sc)->sc_memt, (sc)->sc_regh, (reg), (val))
#define	VAC_DP_R8(sc, off) \
	bus_space_read_1((sc)->sc_memt, (sc)->sc_regh, VAC_DP_BASE + (off))
#define	VAC_DP_W8(sc, off, v) \
	bus_space_write_1((sc)->sc_memt, (sc)->sc_regh, VAC_DP_BASE + (off), (v))

/*
 * Embedded 8051 firmware
 * assemble from vac8051.asm with naken_asm (-type bin)
 */
static const uint8_t vac8051_fw[] = {
	0x90, 0x30, 0x03, 0x74, 0x51, 0xf0, 0x90, 0x30, 0x01, 0xe4, 0xf0, 0x7f,
	0x00, 0x90, 0x30, 0x00, 0xe0, 0xfe, 0x6f, 0x60, 0xf8, 0xee, 0x54, 0x01,
	0x60, 0x10, 0x90, 0x30, 0x06, 0xe0, 0xfc, 0x90, 0x30, 0x07, 0xe0, 0xfd,
	0x7a, 0xf0, 0x7b, 0x37, 0x80, 0x0e, 0x90, 0x30, 0x04, 0xe0, 0xfc, 0x90,
	0x30, 0x05, 0xe0, 0xfd, 0x7a, 0x10, 0x7b, 0x30, 0x78, 0x00, 0x79, 0x00,
	0x90, 0x91, 0x45, 0xe0, 0x54, 0x08, 0x60, 0x04, 0xd9, 0xf6, 0xd8, 0xf4,
	0x8a, 0x82, 0x8b, 0x83, 0xe0, 0xf5, 0x20, 0xa3, 0xe0, 0xf5, 0x21, 0xa3,
	0xe0, 0xf5, 0x24, 0xa3, 0xe0, 0xf5, 0x25, 0xa3, 0xaa, 0x82, 0xab, 0x83,
	0x90, 0x91, 0x00, 0xe4, 0xf0, 0xa3, 0x74, 0x98, 0xf0, 0xe5, 0x20, 0xc4,
	0xf5, 0x22, 0xe5, 0x21, 0xc4, 0xf5, 0x23, 0x90, 0x91, 0x0c, 0xe5, 0x22,
	0x54, 0xf0, 0xf0, 0xa3, 0xe5, 0x22, 0x54, 0x0f, 0xf5, 0x26, 0xe5, 0x23,
	0x54, 0xf0, 0x45, 0x26, 0xf0, 0xa3, 0xe5, 0x23, 0x54, 0x0f, 0xf0, 0xa3,
	0xe4, 0xf0, 0xe5, 0x24, 0xc4, 0xf5, 0x22, 0xe5, 0x25, 0xc4, 0xf5, 0x23,
	0x90, 0x91, 0x10, 0xe5, 0x22, 0x54, 0xf0, 0xf0, 0xa3, 0xe5, 0x22, 0x54,
	0x0f, 0xf5, 0x26, 0xe5, 0x23, 0x54, 0xf0, 0x45, 0x26, 0xf0, 0xa3, 0xe5,
	0x23, 0x54, 0x0f, 0xf0, 0xa3, 0xe4, 0xf0, 0xec, 0x70, 0x01, 0x1d, 0x1c,
	0xec, 0x4d, 0x60, 0x03, 0x02, 0x00, 0x38, 0x90, 0x30, 0x01, 0xee, 0xf0,
	0xff, 0x02, 0x00, 0x0d
};

static int	vac_match(device_t, cfdata_t, void *);
static void	vac_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(vac, sizeof(struct vac_softc),
    vac_match, vac_attach, NULL, NULL);

static const struct audio_format vac_format = {
	.mode = AUMODE_PLAY,
	.encoding = AUDIO_ENCODING_SLINEAR_LE,
	.validbits = VAC_PRECISION,
	.precision = VAC_PRECISION,
	.channels = VAC_CHANNELS,
	.channel_mask = AUFMT_STEREO,
	.frequency_type = 1,
	.frequency = { VAC_RATE }
};

/*
 * AC'97 codec register access.
 */
static int
vac_ac97_read(void *priv, uint8_t reg, uint16_t *val)
{
	struct vac_softc * const sc = priv;
	uint32_t addr, rx;
	int i;

	addr = ((uint32_t)reg << SM502_AC97_ADDR_SHIFT) & SM502_AC97_ADDR_MASK;

	/* Mark frame + slot 1 valid and issue a read of the register. */
	VAC_WRITE(sc, SM502_AC97_TX_TAG,
	    SM502_AC97_FRAME_VALID | SM502_AC97_S1_VALID);
	VAC_WRITE(sc, SM502_AC97_TX_ADDR, addr | SM502_AC97_READ);

	/* Wait for the codec to echo the register index back in RX slot 1. */
	for (i = 0; i < VAC_CODEC_TIMEOUT; i++) {
		rx = VAC_READ(sc, SM502_AC97_RX_ADDR);
		if ((rx & SM502_AC97_ADDR_MASK) == addr)
			break;
		DELAY(1);
	}
	if (i == VAC_CODEC_TIMEOUT)
		return 1;

	*val = (VAC_READ(sc, SM502_AC97_RX_DATA) & SM502_AC97_DATA_MASK) >> 4;
	return 0;
}

static int
vac_ac97_write(void *priv, uint8_t reg, uint16_t val)
{
	struct vac_softc * const sc = priv;
	uint32_t addr;

	addr = ((uint32_t)reg << SM502_AC97_ADDR_SHIFT) & SM502_AC97_ADDR_MASK;

	/* Mark frame + slots 1 (address) and 2 (data) valid. */
	VAC_WRITE(sc, SM502_AC97_TX_TAG,
	    SM502_AC97_FRAME_VALID | SM502_AC97_S1_VALID | SM502_AC97_S2_VALID);
	VAC_WRITE(sc, SM502_AC97_TX_DATA,
	    ((uint32_t)val << 4) & SM502_AC97_DATA_MASK);
	VAC_WRITE(sc, SM502_AC97_TX_ADDR, addr);

	DELAY(100);
	return 0;
}

static int
vac_ac97_reset(void *priv)
{
	struct vac_softc * const sc = priv;
	uint32_t reg;
	int i;

	aprint_debug_dev(sc->sc_dev, "ac97 control at reset entry 0x%08x\n",
	    VAC_READ(sc, SM502_AC97_CONTROL));

	/*
	 * Cold reset the codec with the controller enabled: assert RESET#
	 * (COLD_RESET) for well over the 1us minimum, then release it.
	 */
	VAC_WRITE(sc, SM502_AC97_CONTROL,
	    SM502_AC97_ENABLE | SM502_AC97_COLD_RESET);
	DELAY(20);
	VAC_WRITE(sc, SM502_AC97_CONTROL, SM502_AC97_ENABLE);

	/*
	 * Wait (up to ~250ms) for the codec to start the bit clock and the
	 * link to reach the active state.
	 */
	for (i = 0; i < 2500; i++) {
		reg = VAC_READ(sc, SM502_AC97_CONTROL);
		if ((reg & SM502_AC97_BCLK_RUNNING) != 0 &&
		    (reg & SM502_AC97_STATUS_MASK) == SM502_AC97_STATUS_ON) {
			aprint_debug_dev(sc->sc_dev,
			    "AC-link up (control 0x%08x)\n", reg);
			return 0;
		}
		DELAY(100);
	}

	aprint_error_dev(sc->sc_dev,
	    "AC-link did not come ready (control 0x%08x)\n", reg);
	return 1;
}

static int
vac_ac97_attach(void *priv, struct ac97_codec_if *codec)
{
	struct vac_softc * const sc = priv;

	sc->sc_ac97_codec = codec;
	return 0;
}

static void
vac_unmute(struct vac_softc *sc)
{
	struct ac97_codec_if * const codec = sc->sc_ac97_codec;
	static const struct {
		const char *class;
		const char *device;
	} ports[] = {
		{ AudioCoutputs, AudioNmaster },
		{ AudioCinputs,  AudioNdac },
	};
	mixer_ctrl_t mc;
	int i, idx;

	mutex_enter(&sc->sc_lock);
	for (i = 0; i < (int)__arraycount(ports); i++) {
		idx = codec->vtbl->get_portnum_by_name(codec,
		    ports[i].class, ports[i].device, NULL);
		if (idx >= 0) {
			memset(&mc, 0, sizeof(mc));
			mc.dev = idx;
			mc.type = AUDIO_MIXER_VALUE;
			mc.un.value.num_channels = 2;
			mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 200;
			mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 200;
			(void)codec->vtbl->mixer_set_port(codec, &mc);
		}
		idx = codec->vtbl->get_portnum_by_name(codec,
		    ports[i].class, ports[i].device, AudioNmute);
		if (idx >= 0) {
			memset(&mc, 0, sizeof(mc));
			mc.dev = idx;
			mc.type = AUDIO_MIXER_ENUM;
			mc.un.ord = 0;		/* off = not muted */
			(void)codec->vtbl->mixer_set_port(codec, &mc);
		}
	}
	mutex_exit(&sc->sc_lock);
}

/*
 * MI audio interface.
 */

static int
vac_query_format(void *priv, audio_format_query_t *afp)
{

	return audio_query_format(&vac_format, 1, afp);
}

static int
vac_set_format(void *priv, int setmode,
    const audio_params_t *play, const audio_params_t *rec,
    audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{

	/* Only one format; nothing to do. */
	return 0;
}

static int
vac_getdev(void *priv, struct audio_device *ad)
{

	snprintf(ad->name, sizeof(ad->name), "SM502");
	snprintf(ad->version, sizeof(ad->version), "AC97");
	snprintf(ad->config, sizeof(ad->config), "vac");
	return 0;
}

static int
vac_set_port(void *priv, mixer_ctrl_t *mc)
{
	struct vac_softc * const sc = priv;

	return sc->sc_ac97_codec->vtbl->mixer_set_port(sc->sc_ac97_codec, mc);
}

static int
vac_get_port(void *priv, mixer_ctrl_t *mc)
{
	struct vac_softc * const sc = priv;

	return sc->sc_ac97_codec->vtbl->mixer_get_port(sc->sc_ac97_codec, mc);
}

static int
vac_query_devinfo(void *priv, mixer_devinfo_t *di)
{
	struct vac_softc * const sc = priv;

	return sc->sc_ac97_codec->vtbl->query_devinfo(sc->sc_ac97_codec, di);
}

static int
vac_get_props(void *priv)
{

	return AUDIO_PROP_PLAYBACK;
}

static int
vac_round_blocksize(void *priv, int blk, int mode,
    const audio_params_t *param)
{

	/*
	 * Play one MI block per dual-port buffer
	 */
	if (blk > VAC_DP_BUFBYTES)
		blk = VAC_DP_BUFBYTES;
	blk &= ~(VAC_FRAMESIZE - 1);
	if (blk < VAC_FRAMESIZE)
		blk = VAC_FRAMESIZE;
	return blk;
}

/*
 * Queue one block from the MI ring
 */
static void
vac_dp_queue(struct vac_softc *sc)
{
	const uint8_t cmd = sc->sc_cmd_seq + 1;
	uint8_t *p = sc->sc_pcur;
	bus_size_t base;
	int n, i;

	n = sc->sc_pblksize / VAC_FRAMESIZE;
	if (n > VAC_DP_MAXFRAMES)
		n = VAC_DP_MAXFRAMES;

	/* Copy PCM into the staging buffer (raw 16-bit LE), handling wrap. */
	for (i = 0; i < n; i++) {
		uint8_t * const d = sc->sc_dpstage + i * VAC_FRAMESIZE;

		d[0] = p[0];	/* left low */
		d[1] = p[1];	/* left high */
		d[2] = p[2];	/* right low */
		d[3] = p[3];	/* right high */
		p += VAC_FRAMESIZE;
		if (p >= sc->sc_pend)
			p = sc->sc_pstart;
	}
	sc->sc_pcur = p;

	base = VAC_DP_BASE + ((cmd & 1) ? VAC_DP_BUF1 : VAC_DP_BUF0);
	bus_space_write_region_1(sc->sc_memt, sc->sc_regh, base,
	    sc->sc_dpstage, n * VAC_FRAMESIZE);

	if (cmd & 1) {
		VAC_DP_W8(sc, VAC_DP_H_FC1L, n & 0xff);
		VAC_DP_W8(sc, VAC_DP_H_FC1H, (n >> 8) & 0xff);
	} else {
		VAC_DP_W8(sc, VAC_DP_H_FC0L, n & 0xff);
		VAC_DP_W8(sc, VAC_DP_H_FC0H, (n >> 8) & 0xff);
	}

	/* The data and count must be visible before the command bump. */
	bus_space_barrier(sc->sc_memt, sc->sc_regh, VAC_DP_BASE, 0x1000,
	    BUS_SPACE_BARRIER_WRITE);
	VAC_DP_W8(sc, VAC_DP_H_CMD, cmd);
	sc->sc_cmd_seq = cmd;
}

/*
 * Poll the 8051's done counter
 */
static void
vac_feed_callout(void *arg)
{
	struct vac_softc * const sc = arg;
	uint8_t done;
	int n;

	mutex_enter(&sc->sc_intr_lock);
	if (!sc->sc_active) {
		mutex_exit(&sc->sc_intr_lock);
		return;
	}

	done = VAC_DP_R8(sc, VAC_DP_H_DONE);
	if (sc->sc_cmd_seq == done)
		sc->sc_underruns++;	/* 8051 caught up: nothing queued */

	n = (uint8_t)(done - sc->sc_done_seen);
	sc->sc_done_seen = done;
	while (n-- > 0 && sc->sc_active && sc->sc_pint != NULL)
		sc->sc_pint(sc->sc_pintarg);

	while ((uint8_t)(sc->sc_cmd_seq - done) <= 1 && sc->sc_active)
		vac_dp_queue(sc);

	callout_schedule(&sc->sc_feed_ch, sc->sc_feed_ticks);
	mutex_exit(&sc->sc_intr_lock);
}

static int
vac_trigger_output(void *priv, void *start, void *end, int blksize,
    void (*intr)(void *), void *intrarg, const audio_params_t *params)
{
	struct vac_softc * const sc = priv;
	int i;

	/*
	 * audio calls trigger_output with both sc_lock and sc_intr_lock held
	 */
	KASSERT(mutex_owned(&sc->sc_intr_lock));
	KASSERT(mutex_owned(&sc->sc_lock));

	if (!sc->sc_8051_ok)
		return ENXIO;

	/*
	 * Restart the 8051 cleanly for this playback
	 */
	VAC_WRITE(sc, SM502_uC_RESET, 0);
	for (i = 0; i < 16; i++)
		VAC_DP_W8(sc, i, 0);
	VAC_WRITE(sc, SM502_uC_RESET, SM502_uC_ENABLE);
	for (i = 0; i < 5000 &&
	    VAC_DP_R8(sc, VAC_DP_H_ALIVE) != VAC_DP_ALIVE_MAGIC; i++)
		DELAY(10);

	sc->sc_pstart = start;
	sc->sc_pend = end;
	sc->sc_pcur = start;
	sc->sc_pblksize = blksize;
	sc->sc_pint = intr;
	sc->sc_pintarg = intrarg;

	sc->sc_cmd_seq = 0;
	sc->sc_done_seen = 0;
	sc->sc_underruns = 0;
	sc->sc_active = true;

	/* Prime both buffers, then poll for completion from the callout. */
	vac_dp_queue(sc);
	vac_dp_queue(sc);
	callout_schedule(&sc->sc_feed_ch, sc->sc_feed_ticks);

	return 0;
}

static int
vac_halt_output(void *priv)
{
	struct vac_softc * const sc = priv;

	/*
	 * called with both sc_lock and sc_intr_lock held
	 */
	KASSERT(mutex_owned(&sc->sc_intr_lock));

	sc->sc_active = false;
	sc->sc_pint = NULL;
	callout_stop(&sc->sc_feed_ch);

	/* Park the 8051 so the host codec/mixer path is live while idle. */
	VAC_WRITE(sc, SM502_uC_RESET, 0);
	return 0;
}

static void
vac_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread)
{
	struct vac_softc * const sc = priv;

	*intr = &sc->sc_intr_lock;
	*thread = &sc->sc_lock;
}

static const struct audio_hw_if vac_hw_if = {
	.query_format = vac_query_format,
	.set_format = vac_set_format,
	.getdev = vac_getdev,
	.set_port = vac_set_port,
	.get_port = vac_get_port,
	.query_devinfo = vac_query_devinfo,
	.get_props = vac_get_props,
	.round_blocksize = vac_round_blocksize,
	.trigger_output = vac_trigger_output,
	.halt_output = vac_halt_output,
	.get_locks = vac_get_locks,
};

/* Load the firmware blob as 32-bit LE words at (h, base). */
static void
vac_load_fw(struct vac_softc *sc, bus_space_handle_t h, bus_size_t base)
{
	size_t i;

	for (i = 0; i < sizeof(vac8051_fw); i += 4) {
		uint8_t b0 = vac8051_fw[i];
		uint8_t b1 = (i + 1 < sizeof(vac8051_fw)) ? vac8051_fw[i + 1] : 0;
		uint8_t b2 = (i + 2 < sizeof(vac8051_fw)) ? vac8051_fw[i + 2] : 0;
		uint8_t b3 = (i + 3 < sizeof(vac8051_fw)) ? vac8051_fw[i + 3] : 0;

		bus_space_write_4(sc->sc_memt, h, base + i,
		    b0 | (b1 << 8) | (b2 << 16) | (b3 << 24));
	}
}

static void
vac_8051_bringup(struct vac_softc *sc)
{
	uint32_t v;
	uint8_t alive;
	int i;

	/* Hold the 8051 in reset... mode = SRAM on, AC97, fastest clock (div2). */
	VAC_WRITE(sc, SM502_uC_RESET, 0);
	v = VAC_READ(sc, SM502_uC_MODE_SELECT);
	v &= ~(SM502_uC_SRAM_DISABLE | SM502_uC_CODEC_I2S | SM502_uC_CLOCK_MASK);
	VAC_WRITE(sc, SM502_uC_MODE_SELECT, v);

	/* Load the feeder into the program SRAM (host R/W only while in reset). */
	vac_load_fw(sc, sc->sc_regh, SM502_uC_SRAM_PROG);

	/* Clear the dual-port protocol header before the 8051 starts. */
	for (i = 0; i < 16; i++)
		VAC_DP_W8(sc, i, 0);

	/* Release the 8051 and give it time to post its alive marker. */
	VAC_WRITE(sc, SM502_uC_RESET, SM502_uC_ENABLE);
	DELAY(2000);

	alive = VAC_DP_R8(sc, VAC_DP_H_ALIVE);
	sc->sc_8051_ok = (alive == VAC_DP_ALIVE_MAGIC);
	aprint_verbose_dev(sc->sc_dev, "8051 feeder %s (alive=0x%02x)\n",
	    sc->sc_8051_ok ? "loaded" : "not responding", alive);
	if (!sc->sc_8051_ok)
		aprint_error_dev(sc->sc_dev,
		    "8051 feeder did not start; playback unavailable\n");

	/* Park the 8051 while idle (keeps the host codec/mixer path live). */
	VAC_WRITE(sc, SM502_uC_RESET, 0);
}

#ifdef VAC_DEBUG
/*
 * Diagnostics: dump the AC97 link control + key codec registers (read while the
 * 8051 is idle; codec access is dead while it runs).
 */
static int
vac_sysctl_diag(SYSCTLFN_ARGS)
{
	struct sysctlnode node = *rnode;
	struct vac_softc * const sc = node.sysctl_data;
	uint16_t r02 = 0, r04 = 0, r18 = 0, r26 = 0, r2a = 0, r2c = 0, r7a = 0;
	char buf[200];

	vac_ac97_read(sc, 0x02, &r02);	/* master volume */
	vac_ac97_read(sc, 0x04, &r04);	/* aux/headphone volume */
	vac_ac97_read(sc, 0x18, &r18);	/* PCM out volume */
	vac_ac97_read(sc, 0x26, &r26);	/* powerdown ctrl/status */
	vac_ac97_read(sc, 0x2a, &r2a);	/* extended audio ctrl (VRA) */
	vac_ac97_read(sc, 0x2c, &r2c);	/* PCM front DAC rate */
	vac_ac97_read(sc, 0x7a, &r7a);	/* ALC655 vendor (EAPD etc.) */

	snprintf(buf, sizeof(buf),
	    "acctl=%08x mode=%08x reset=%08x | "
	    "m02=%04x hp04=%04x pcm18=%04x pwr26=%04x ext2a=%04x rate2c=%04x ven7a=%04x",
	    VAC_READ(sc, SM502_AC97_CONTROL),
	    VAC_READ(sc, SM502_uC_MODE_SELECT),
	    VAC_READ(sc, SM502_uC_RESET),
	    r02, r04, r18, r26, r2a, r2c, r7a);
	node.sysctl_data = buf;
	node.sysctl_size = strlen(buf) + 1;
	return sysctl_lookup(SYSCTLFN_CALL(&node));
}
#endif /* VAC_DEBUG */

static void
vac_sysctl_setup(struct vac_softc *sc)
{
	const struct sysctlnode *node = NULL;

	if (sysctl_createv(&sc->sc_sysctllog, 0, NULL, &node,
	    0, CTLTYPE_NODE, "vac", SYSCTL_DESCR("SM502 AC97-link audio"),
	    NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL) != 0 || node == NULL)
		return;

	sysctl_createv(&sc->sc_sysctllog, 0, NULL, NULL,
	    CTLFLAG_READONLY, CTLTYPE_INT, "underruns",
	    SYSCTL_DESCR("times the 8051 ran dry during the last playback"),
	    NULL, 0, &sc->sc_underruns, 0, CTL_HW, node->sysctl_num,
	    CTL_CREATE, CTL_EOL);
#ifdef VAC_DEBUG
	sysctl_createv(&sc->sc_sysctllog, 0, NULL, NULL,
	    CTLFLAG_READONLY, CTLTYPE_STRING, "diag",
	    SYSCTL_DESCR("AC97 link + codec register dump (read while idle)"),
	    vac_sysctl_diag, 0, (void *)sc, 0, CTL_HW, node->sysctl_num,
	    CTL_CREATE, CTL_EOL);
#endif
}

static int
vac_match(device_t parent, cfdata_t match, void *aux)
{
	struct voyager_attach_args *vaa = aux;

	if (strcmp(vaa->vaa_name, "vac") == 0)
		return 100;
	return 0;
}

static void
vac_attach(device_t parent, device_t self, void *aux)
{
	struct vac_softc * const sc = device_private(self);
	struct voyager_attach_args *vaa = aux;
	int error;

	sc->sc_dev = self;
	sc->sc_memt = vaa->vaa_tag;
	sc->sc_regh = vaa->vaa_regh;
	sc->sc_parent = device_private(parent);

	aprint_naive("\n");
	aprint_normal(": SM502 AC97-link\n");

	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_AUDIO);

	callout_init(&sc->sc_feed_ch, CALLOUT_MPSAFE);
	callout_setfunc(&sc->sc_feed_ch, vac_feed_callout, sc);
	sc->sc_feed_ticks = mstohz(5);
	if (sc->sc_feed_ticks < 1)
		sc->sc_feed_ticks = 1;
	sc->sc_dpstage = kmem_alloc(VAC_DP_BUFBYTES, KM_SLEEP);

	aprint_debug_dev(self,
	    "power: ctrl 0x%08x cur-gate 0x%08x gate0 0x%08x gate1 0x%08x\n",
	    VAC_READ(sc, SM502_POWER_MODE_CONTROL),
	    VAC_READ(sc, SM502_CURRENT_GATE),
	    VAC_READ(sc, SM502_POWER_MODE0_GATE),
	    VAC_READ(sc, SM502_POWER_MODE1_GATE));

	VAC_WRITE(sc, SM502_POWER_MODE0_GATE,
	    VAC_READ(sc, SM502_POWER_MODE0_GATE) |
	    SM502_GATE_AUDIO_ENABLE | SM502_GATE_8051_ENABLE);
	VAC_WRITE(sc, SM502_POWER_MODE1_GATE,
	    VAC_READ(sc, SM502_POWER_MODE1_GATE) |
	    SM502_GATE_AUDIO_ENABLE | SM502_GATE_8051_ENABLE);
	DELAY(1000);

	/* Route the shared audio pins to the AC97-link (not GPIO). */
	voyager_control_gpio(sc->sc_parent, 0xffffffff, SM502_AUDIO_GPIO_MASK);

	/* Select AC97 mode for the link (CODEC_I2S clear). */
	VAC_WRITE(sc, SM502_uC_MODE_SELECT,
	    VAC_READ(sc, SM502_uC_MODE_SELECT) & ~SM502_uC_CODEC_I2S);

	sc->sc_ac97_host.arg = sc;
	sc->sc_ac97_host.attach = vac_ac97_attach;
	sc->sc_ac97_host.read = vac_ac97_read;
	sc->sc_ac97_host.write = vac_ac97_write;
	sc->sc_ac97_host.reset = vac_ac97_reset;

	error = ac97_attach(&sc->sc_ac97_host, self, &sc->sc_lock);
	if (error) {
		aprint_error_dev(self, "couldn't attach codec (%d)\n", error);
		return;
	}

	vac_sysctl_setup(sc);

	/* Load the 8051 binary. */
	vac_8051_bringup(sc);

	sc->sc_audiodev = audio_attach_mi(&vac_hw_if, sc, self);

	/* Unmute master + DAC now that the codec/mixer stack is up (8051 idle). */
	vac_unmute(sc);
}