/*      $NetBSD: emuxki.c,v 1.79 2024/06/08 21:02:29 andvar Exp $       */

/*-
 * Copyright (c) 2001, 2007 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Yannick Montulet, and by Andrew Doran.
 *
 * 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.
 */

/*
 * EMU10K1 single voice driver
 * o. only 1 voice playback, 1 recording
 * o. only s16le 2ch 48k
 * This makes it simple to control buffers and interrupts
 * while satisfying playback and recording quality.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: emuxki.c,v 1.79 2024/06/08 21:02:29 andvar Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/module.h>
#include <sys/errno.h>
#include <sys/systm.h>
#include <sys/audioio.h>
#include <sys/mutex.h>
#include <sys/kmem.h>
#include <sys/fcntl.h>

#include <sys/bus.h>
#include <sys/intr.h>

#include <dev/pci/emuxkireg.h>
#include <dev/pci/emuxkivar.h>
#include <dev/pci/emuxki_boards.h>

/* #define EMUXKI_DEBUG 1 */
#ifdef EMUXKI_DEBUG
#define emudebug EMUXKI_DEBUG
# define DPRINTF(fmt...)        do { if (emudebug) printf(fmt); } while (0)
# define DPRINTFN(n,fmt...)     do { if (emudebug>=(n)) printf(fmt); } while (0)
#else
# define DPRINTF(fmt...)        __nothing
# define DPRINTFN(n,fmt...)     __nothing
#endif

/*
 * PCI
 * Note: emuxki's page table entry uses only 31bit addressing.
 *       (Maybe, later chip has 32bit mode, but it isn't used now.)
 */

#define EMU_PCI_CBIO            (0x10)

/* blackmagic */
#define X1(x)           ((sc->sc_type & EMUXKI_AUDIGY) ? EMU_A_##x : EMU_##x)
#define X2(x, y)        ((sc->sc_type & EMUXKI_AUDIGY) \
    ? EMU_A_##x(EMU_A_##y) : EMU_##x(EMU_##y))
#define EMU_A_DSP_FX            EMU_DSP_FX
#define EMU_A_DSP_IN_AC97       EMU_DSP_IN_AC97

/* prototypes */
static struct dmamem *dmamem_alloc(struct emuxki_softc *, size_t);
static void     dmamem_free(struct dmamem *);
static void     dmamem_sync(struct dmamem *, int);
static uint8_t  emuxki_readio_1(struct emuxki_softc *, int) __unused;
static uint16_t emuxki_readio_2(struct emuxki_softc *, int);
static uint32_t emuxki_readio_4(struct emuxki_softc *, int);
static void     emuxki_writeio_1(struct emuxki_softc *, int, uint8_t);
static void     emuxki_writeio_2(struct emuxki_softc *, int, uint16_t);
static void     emuxki_writeio_4(struct emuxki_softc *, int, uint32_t);
static uint32_t emuxki_readptr(struct emuxki_softc *, int, int, int);
static void     emuxki_writeptr(struct emuxki_softc *, int, int, int, uint32_t);
static uint32_t emuxki_read(struct emuxki_softc *, int, int);
static void     emuxki_write(struct emuxki_softc *, int, int, uint32_t);
static int      emuxki_match(device_t, cfdata_t, void *);
static void     emuxki_attach(device_t, device_t, void *);
static int      emuxki_detach(device_t, int);
static int      emuxki_init(struct emuxki_softc *);
static void     emuxki_dsp_addop(struct emuxki_softc *, uint16_t *, uint8_t,
                    uint16_t, uint16_t, uint16_t, uint16_t);
static void     emuxki_initfx(struct emuxki_softc *);
static void     emuxki_play_start(struct emuxki_softc *, int, uint32_t,
                    uint32_t);
static void     emuxki_play_stop(struct emuxki_softc *, int);

static int      emuxki_query_format(void *, audio_format_query_t *);
static int      emuxki_set_format(void *, int,
                    const audio_params_t *, const audio_params_t *,
                    audio_filter_reg_t *, audio_filter_reg_t *);
static int      emuxki_halt_output(void *);
static int      emuxki_halt_input(void *);
static int      emuxki_intr(void *);
static int      emuxki_getdev(void *, struct audio_device *);
static int      emuxki_set_port(void *, mixer_ctrl_t *);
static int      emuxki_get_port(void *, mixer_ctrl_t *);
static int      emuxki_query_devinfo(void *, mixer_devinfo_t *);
static void     *emuxki_allocm(void *, int, size_t);
static void     emuxki_freem(void *, void *, size_t);
static int      emuxki_round_blocksize(void *, int, int,
                    const audio_params_t *);
static size_t   emuxki_round_buffersize(void *, int, size_t);
static int      emuxki_get_props(void *);
static int      emuxki_trigger_output(void *, void *, void *, int,
                    void (*)(void *), void *, const audio_params_t *);
static int      emuxki_trigger_input(void *, void *, void *, int,
                    void (*)(void *), void *, const audio_params_t *);
static void     emuxki_get_locks(void *, kmutex_t **, kmutex_t **);

static int      emuxki_ac97_init(struct emuxki_softc *);
static int      emuxki_ac97_attach(void *, struct ac97_codec_if *);
static int      emuxki_ac97_read(void *, uint8_t, uint16_t *);
static int      emuxki_ac97_write(void *, uint8_t, uint16_t);
static int      emuxki_ac97_reset(void *);
static enum ac97_host_flags     emuxki_ac97_flags(void *);


CFATTACH_DECL_NEW(emuxki, sizeof(struct emuxki_softc),
    emuxki_match, emuxki_attach, emuxki_detach, NULL);

static const struct audio_hw_if emuxki_hw_if = {
        .query_format           = emuxki_query_format,
        .set_format             = emuxki_set_format,
        .round_blocksize        = emuxki_round_blocksize,
        .halt_output            = emuxki_halt_output,
        .halt_input             = emuxki_halt_input,
        .getdev                 = emuxki_getdev,
        .set_port               = emuxki_set_port,
        .get_port               = emuxki_get_port,
        .query_devinfo          = emuxki_query_devinfo,
        .allocm                 = emuxki_allocm,
        .freem                  = emuxki_freem,
        .round_buffersize       = emuxki_round_buffersize,
        .get_props              = emuxki_get_props,
        .trigger_output         = emuxki_trigger_output,
        .trigger_input          = emuxki_trigger_input,
        .get_locks              = emuxki_get_locks,
};

static const struct audio_format emuxki_formats[] = {
        {
                .mode           = AUMODE_PLAY | AUMODE_RECORD,
                .encoding       = AUDIO_ENCODING_SLINEAR_LE,
                .validbits      = 16,
                .precision      = 16,
                .channels       = 2,
                .channel_mask   = AUFMT_STEREO,
                .frequency_type = 1,
                .frequency      = { 48000 },
        }
};
#define EMUXKI_NFORMATS __arraycount(emuxki_formats)

/*
 * dma memory
 */

static struct dmamem *
dmamem_alloc(struct emuxki_softc *sc, size_t size)
{
        struct dmamem *mem;

        KASSERT(!mutex_owned(&sc->sc_intr_lock));

        /* Allocate memory for structure */
        mem = kmem_alloc(sizeof(*mem), KM_SLEEP);
        mem->dmat = sc->sc_dmat;
        mem->size = size;
        mem->align = EMU_DMA_ALIGN;
        mem->nsegs = EMU_DMA_NSEGS;
        mem->bound = 0;

        mem->segs = kmem_alloc(mem->nsegs * sizeof(*(mem->segs)), KM_SLEEP);

        if (bus_dmamem_alloc(mem->dmat, mem->size, mem->align, mem->bound,
            mem->segs, mem->nsegs, &mem->rsegs, BUS_DMA_WAITOK)) {
                device_printf(sc->sc_dev,
                    "%s bus_dmamem_alloc failed\n", __func__);
                goto memfree;
        }

        if (bus_dmamem_map(mem->dmat, mem->segs, mem->nsegs, mem->size,
            &mem->kaddr, BUS_DMA_WAITOK | BUS_DMA_COHERENT)) {
                device_printf(sc->sc_dev,
                    "%s bus_dmamem_map failed\n", __func__);
                goto free;
        }

        if (bus_dmamap_create(mem->dmat, mem->size, mem->nsegs, mem->size,
            mem->bound, BUS_DMA_WAITOK, &mem->map)) {
                device_printf(sc->sc_dev,
                    "%s bus_dmamap_create failed\n", __func__);
                goto unmap;
        }

        if (bus_dmamap_load(mem->dmat, mem->map, mem->kaddr,
            mem->size, NULL, BUS_DMA_WAITOK)) {
                device_printf(sc->sc_dev,
                    "%s bus_dmamap_load failed\n", __func__);
                goto destroy;
        }

        return mem;

destroy:
        bus_dmamap_destroy(mem->dmat, mem->map);
unmap:
        bus_dmamem_unmap(mem->dmat, mem->kaddr, mem->size);
free:
        bus_dmamem_free(mem->dmat, mem->segs, mem->nsegs);
memfree:
        kmem_free(mem->segs, mem->nsegs * sizeof(*(mem->segs)));
        kmem_free(mem, sizeof(*mem));

        return NULL;
}

static void
dmamem_free(struct dmamem *mem)
{

        bus_dmamap_unload(mem->dmat, mem->map);
        bus_dmamap_destroy(mem->dmat, mem->map);
        bus_dmamem_unmap(mem->dmat, mem->kaddr, mem->size);
        bus_dmamem_free(mem->dmat, mem->segs, mem->nsegs);

        kmem_free(mem->segs, mem->nsegs * sizeof(*(mem->segs)));
        kmem_free(mem, sizeof(*mem));
}

static void
dmamem_sync(struct dmamem *mem, int ops)
{

        bus_dmamap_sync(mem->dmat, mem->map, 0, mem->size, ops);
}


/*
 * I/O register access
 */

static uint8_t
emuxki_readio_1(struct emuxki_softc *sc, int addr)
{

        return bus_space_read_1(sc->sc_iot, sc->sc_ioh, addr);
}

static void
emuxki_writeio_1(struct emuxki_softc *sc, int addr, uint8_t data)
{

        bus_space_write_1(sc->sc_iot, sc->sc_ioh, addr, data);
}

static uint16_t
emuxki_readio_2(struct emuxki_softc *sc, int addr)
{

        return bus_space_read_2(sc->sc_iot, sc->sc_ioh, addr);
}

static void
emuxki_writeio_2(struct emuxki_softc *sc, int addr, uint16_t data)
{

        bus_space_write_2(sc->sc_iot, sc->sc_ioh, addr, data);
}

static uint32_t
emuxki_readio_4(struct emuxki_softc *sc, int addr)
{

        return bus_space_read_4(sc->sc_iot, sc->sc_ioh, addr);
}

static void
emuxki_writeio_4(struct emuxki_softc *sc, int addr, uint32_t data)
{

        bus_space_write_4(sc->sc_iot, sc->sc_ioh, addr, data);
}

static uint32_t
emuxki_readptr(struct emuxki_softc *sc, int aptr, int dptr, int addr)
{
        uint32_t data;

        mutex_spin_enter(&sc->sc_index_lock);
        emuxki_writeio_4(sc, aptr, addr);
        data = emuxki_readio_4(sc, dptr);
        mutex_spin_exit(&sc->sc_index_lock);
        return data;
}

static void
emuxki_writeptr(struct emuxki_softc *sc, int aptr, int dptr, int addr,
    uint32_t data)
{

        mutex_spin_enter(&sc->sc_index_lock);
        emuxki_writeio_4(sc, aptr, addr);
        emuxki_writeio_4(sc, dptr, data);
        mutex_spin_exit(&sc->sc_index_lock);
}

static uint32_t
emuxki_read(struct emuxki_softc *sc, int ch, int addr)
{

        /* Original HENTAI addressing is never supported. */
        KASSERT((addr & 0xff000000) == 0);

        return emuxki_readptr(sc, EMU_PTR, EMU_DATA, (addr << 16) + ch);
}

static void
emuxki_write(struct emuxki_softc *sc, int ch, int addr, uint32_t data)
{

        /* Original HENTAI addressing is never supported. */
        KASSERT((addr & 0xff000000) == 0);

        emuxki_writeptr(sc, EMU_PTR, EMU_DATA, (addr << 16) + ch, data);
}

/*
 * MD driver
 */

static int
emuxki_match(device_t parent, cfdata_t match, void *aux)
{
        struct pci_attach_args *pa;
        pcireg_t reg;

        pa = aux;

        reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
        if (emuxki_board_lookup(PCI_VENDOR(pa->pa_id),
                                PCI_PRODUCT(pa->pa_id), reg,
                                PCI_REVISION(pa->pa_class)) != NULL)
                return 1;

        return 0;
}

static void
emuxki_attach(device_t parent, device_t self, void *aux)
{
        struct emuxki_softc *sc;
        struct pci_attach_args *pa;
        const struct emuxki_board *sb;
        pci_intr_handle_t ih;
        const char *intrstr;
        char intrbuf[PCI_INTRSTR_LEN];
        pcireg_t reg;

        sc = device_private(self);
        sc->sc_dev = self;
        pa = aux;

        reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_SUBSYS_ID_REG);
        sb = emuxki_board_lookup(PCI_VENDOR(pa->pa_id),
                                      PCI_PRODUCT(pa->pa_id), reg,
                                      PCI_REVISION(pa->pa_class));
        KASSERT(sb != NULL);

        pci_aprint_devinfo(pa, "Audio controller");
        aprint_normal_dev(self, "%s [%s]\n", sb->sb_name, sb->sb_board);
        DPRINTF("dmat=%p\n", (char *)pa->pa_dmat);

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

        sc->sc_pc   = pa->pa_pc;

        /* EMU10K1 can only address 31 bits (2GB) */
        if (bus_dmatag_subregion(pa->pa_dmat, 0, ((uint32_t)1 << 31) - 1,
            &(sc->sc_dmat), BUS_DMA_NOWAIT) != 0) {
                aprint_error_dev(self,
                    "WARNING: failed to restrict dma range,"
                    " falling back to parent bus dma range\n");
                sc->sc_dmat = pa->pa_dmat;
        }

        reg = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
        reg |= PCI_COMMAND_IO_ENABLE | PCI_COMMAND_MASTER_ENABLE |
            PCI_COMMAND_MEM_ENABLE;
        pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, reg);

        if (pci_mapreg_map(pa, EMU_PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
            &sc->sc_iot, &sc->sc_ioh, &sc->sc_iob, &sc->sc_ios)) {
                aprint_error(": can't map iospace\n");
                return;
        }

        if (pci_intr_map(pa, &ih)) {
                aprint_error_dev(self, "couldn't map interrupt\n");
                goto unmap;
        }

        intrstr = pci_intr_string(pa->pa_pc, ih, intrbuf, sizeof(intrbuf));
        sc->sc_ih = pci_intr_establish_xname(pa->pa_pc, ih, IPL_AUDIO,
            emuxki_intr, sc, device_xname(self));
        if (sc->sc_ih == NULL) {
                aprint_error_dev(self, "couldn't establish interrupt");
                if (intrstr != NULL)
                        aprint_error(" at %s", intrstr);
                aprint_error("\n");
                goto unmap;
        }
        aprint_normal_dev(self, "interrupting at %s\n", intrstr);

        /* XXX it's unknown whether APS is made from Audigy as well */
        sc->sc_type = sb->sb_flags;
        if (sc->sc_type & EMUXKI_AUDIGY2_CA0108) {
                strlcpy(sc->sc_audv.name, "Audigy2+CA0108",
                    sizeof(sc->sc_audv.name));
        } else if (sc->sc_type & EMUXKI_AUDIGY2) {
                strlcpy(sc->sc_audv.name, "Audigy2", sizeof(sc->sc_audv.name));
        } else if (sc->sc_type & EMUXKI_AUDIGY) {
                strlcpy(sc->sc_audv.name, "Audigy", sizeof(sc->sc_audv.name));
        } else if (sc->sc_type & EMUXKI_APS) {
                strlcpy(sc->sc_audv.name, "E-mu APS", sizeof(sc->sc_audv.name));
        } else {
                strlcpy(sc->sc_audv.name, "SB Live!", sizeof(sc->sc_audv.name));
        }
        snprintf(sc->sc_audv.version, sizeof(sc->sc_audv.version), "0x%02x",
            PCI_REVISION(pa->pa_class));
        strlcpy(sc->sc_audv.config, "emuxki", sizeof(sc->sc_audv.config));

        if (emuxki_init(sc)) {
                aprint_error("emuxki_init error\n");
                goto intrdis;
        }
        if (emuxki_ac97_init(sc)) {
                aprint_error("emuxki_ac97_init error\n");
                goto intrdis;
        }

        sc->sc_audev = audio_attach_mi(&emuxki_hw_if, sc, self);
        if (sc->sc_audev == NULL) {
                aprint_error("audio_attach_mi error\n");
                goto intrdis;
        }

        return;

intrdis:
        pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
unmap:
        bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
        return;
}

static int
emuxki_detach(device_t self, int flags)
{
        struct emuxki_softc *sc = device_private(self);
        int error;

        error = config_detach_children(self, flags);
        if (error)
                return error;

        /* All voices should be stopped now but add some code here if not */
        emuxki_writeio_4(sc, EMU_HCFG,
            EMU_HCFG_LOCKSOUNDCACHE |
            EMU_HCFG_LOCKTANKCACHE_MASK |
            EMU_HCFG_MUTEBUTTONENABLE);
        emuxki_writeio_4(sc, EMU_INTE, 0);

        /* Disable any Channels interrupts */
        emuxki_write(sc, 0, EMU_CLIEL, 0);
        emuxki_write(sc, 0, EMU_CLIEH, 0);
        emuxki_write(sc, 0, EMU_SOLEL, 0);
        emuxki_write(sc, 0, EMU_SOLEH, 0);

        /* stop DSP */
        emuxki_write(sc, 0, X1(DBG), X1(DBG_SINGLE_STEP));

        dmamem_free(sc->ptb);

        pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
        bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);

        mutex_destroy(&sc->sc_lock);
        mutex_destroy(&sc->sc_intr_lock);
        mutex_destroy(&sc->sc_index_lock);

        return 0;
}

static int
emuxki_init(struct emuxki_softc *sc)
{
        int i;
        uint32_t spcs;
        uint32_t hcfg;

        /* clear AUDIO bit */
        emuxki_writeio_4(sc, EMU_HCFG,
            EMU_HCFG_LOCKSOUNDCACHE |
            EMU_HCFG_LOCKTANKCACHE_MASK |
            EMU_HCFG_MUTEBUTTONENABLE);

        /* mask interrupt without PCIERR */
        emuxki_writeio_4(sc, EMU_INTE,
            EMU_INTE_SAMPLERATER | /* always on this bit */
            EMU_INTE_PCIERRENABLE);

        /* disable all channel interrupt */
        emuxki_write(sc, 0, EMU_CLIEL, 0);
        emuxki_write(sc, 0, EMU_CLIEH, 0);
        emuxki_write(sc, 0, EMU_SOLEL, 0);
        emuxki_write(sc, 0, EMU_SOLEH, 0);

        /* Set recording buffers sizes to zero */
        emuxki_write(sc, 0, EMU_MICBS, EMU_RECBS_BUFSIZE_NONE);
        emuxki_write(sc, 0, EMU_MICBA, 0);
        emuxki_write(sc, 0, EMU_FXBS, EMU_RECBS_BUFSIZE_NONE);
        emuxki_write(sc, 0, EMU_FXBA, 0);
        emuxki_write(sc, 0, EMU_ADCBS, EMU_RECBS_BUFSIZE_NONE);
        emuxki_write(sc, 0, EMU_ADCBA, 0);

        if(sc->sc_type & EMUXKI_AUDIGY) {
                emuxki_write(sc, 0, EMU_SPBYPASS, EMU_SPBYPASS_24_BITS);
                emuxki_write(sc, 0, EMU_AC97SLOT,
                    EMU_AC97SLOT_CENTER | EMU_AC97SLOT_LFE);
        }

        /* Initialize all channels to stopped and no effects */
        for (i = 0; i < EMU_NUMCHAN; i++) {
                emuxki_write(sc, i, EMU_CHAN_DCYSUSV, 0x7f7f);
                emuxki_write(sc, i, EMU_CHAN_IP, EMU_CHAN_IP_UNITY);
                emuxki_write(sc, i, EMU_CHAN_VTFT, 0xffff);
                emuxki_write(sc, i, EMU_CHAN_CVCF, 0xffff);
                emuxki_write(sc, i, EMU_CHAN_PTRX, 0);
                emuxki_write(sc, i, EMU_CHAN_CPF, 0);
                emuxki_write(sc, i, EMU_CHAN_CCR, 0);
                emuxki_write(sc, i, EMU_CHAN_PSST, 0);
                emuxki_write(sc, i, EMU_CHAN_DSL, 0);
                emuxki_write(sc, i, EMU_CHAN_CCCA, EMU_CHAN_CCCA_INTERPROM_1);
                emuxki_write(sc, i, EMU_CHAN_Z1, 0);
                emuxki_write(sc, i, EMU_CHAN_Z2, 0);
                emuxki_write(sc, i, EMU_CHAN_MAPA, 0xffffffff);
                emuxki_write(sc, i, EMU_CHAN_MAPB, 0xffffffff);
                emuxki_write(sc, i, EMU_CHAN_FXRT, 0x32100000);
                emuxki_write(sc, i, EMU_CHAN_ATKHLDM, 0);
                emuxki_write(sc, i, EMU_CHAN_DCYSUSM, 0);
                emuxki_write(sc, i, EMU_CHAN_IFATN, 0xffff);
                emuxki_write(sc, i, EMU_CHAN_PEFE, 0x007f);
                emuxki_write(sc, i, EMU_CHAN_FMMOD, 0);
                emuxki_write(sc, i, EMU_CHAN_TREMFRQ, 0);
                emuxki_write(sc, i, EMU_CHAN_FM2FRQ2, 0);
                emuxki_write(sc, i, EMU_CHAN_TEMPENV, 0);

                /* these are last so OFF prevents writing */
                emuxki_write(sc, i, EMU_CHAN_LFOVAL2, 0x8000);
                emuxki_write(sc, i, EMU_CHAN_LFOVAL1, 0x8000);
                emuxki_write(sc, i, EMU_CHAN_ATKHLDV, 0x7f7f);
                emuxki_write(sc, i, EMU_CHAN_ENVVOL, 0);
                emuxki_write(sc, i, EMU_CHAN_ENVVAL, 0x8000);
        }

        /* set digital outputs format */
        spcs = EMU_SPCS_CLKACCY_1000PPM |
               EMU_SPCS_SAMPLERATE_48 |
               EMU_SPCS_CHANNELNUM_LEFT |
               EMU_SPCS_SOURCENUM_UNSPEC |
               EMU_SPCS_GENERATIONSTATUS |
               0x00001200 /* Cat code. */ |
               0x00000000 /* IEC-958 Mode */ |
               EMU_SPCS_EMPHASIS_NONE |
               EMU_SPCS_COPYRIGHT;
        emuxki_write(sc, 0, EMU_SPCS0, spcs);
        emuxki_write(sc, 0, EMU_SPCS1, spcs);
        emuxki_write(sc, 0, EMU_SPCS2, spcs);

        if (sc->sc_type & EMUXKI_AUDIGY2_CA0108) {
                /* Setup SRCMulti_I2S SamplingRate */
                emuxki_write(sc, 0, EMU_A2_SPDIF_SAMPLERATE,
                    emuxki_read(sc, 0, EMU_A2_SPDIF_SAMPLERATE) & 0xfffff1ff);

                /* Setup SRCSel (Enable SPDIF, I2S SRCMulti) */
                emuxki_writeptr(sc, EMU_A2_PTR, EMU_A2_DATA, EMU_A2_SRCSEL,
                    EMU_A2_SRCSEL_ENABLE_SPDIF | EMU_A2_SRCSEL_ENABLE_SRCMULTI);

                /* Setup SRCMulti Input Audio Enable */
                emuxki_writeptr(sc, EMU_A2_PTR, EMU_A2_DATA,
                    0x7b0000, 0xff000000);

                /* Setup SPDIF Out Audio Enable
                 * The Audigy 2 Value has a separate SPDIF out,
                 * so no need for a mixer switch */
                emuxki_writeptr(sc, EMU_A2_PTR, EMU_A2_DATA,
                    0x7a0000, 0xff000000);
                emuxki_writeio_4(sc, EMU_A_IOCFG,
                    emuxki_readio_4(sc, EMU_A_IOCFG) & ~0x8); /* clear bit 3 */
        } else if (sc->sc_type & EMUXKI_AUDIGY2) {
                emuxki_write(sc, 0, EMU_A2_SPDIF_SAMPLERATE,
                    EMU_A2_SPDIF_UNKNOWN);

                emuxki_writeptr(sc, EMU_A2_PTR, EMU_A2_DATA, EMU_A2_SRCSEL,
                    EMU_A2_SRCSEL_ENABLE_SPDIF | EMU_A2_SRCSEL_ENABLE_SRCMULTI);

                emuxki_writeptr(sc, EMU_A2_PTR, EMU_A2_DATA, EMU_A2_SRCMULTI,
                    EMU_A2_SRCMULTI_ENABLE_INPUT);
        }

        /* page table */
        sc->ptb = dmamem_alloc(sc, EMU_MAXPTE * sizeof(uint32_t));
        if (sc->ptb == NULL) {
                device_printf(sc->sc_dev, "ptb allocation error\n");
                return ENOMEM;
        }
        emuxki_write(sc, 0, EMU_PTB, DMAADDR(sc->ptb));

        emuxki_write(sc, 0, EMU_TCBS, 0);       /* This means 16K TCB */
        emuxki_write(sc, 0, EMU_TCB, 0);        /* No TCB use for now */

        /* Let's play with sound processor */
        emuxki_initfx(sc);

        /* enable interrupt */
        emuxki_writeio_4(sc, EMU_INTE,
            emuxki_readio_4(sc, EMU_INTE) |
            EMU_INTE_VOLINCRENABLE |
            EMU_INTE_VOLDECRENABLE |
            EMU_INTE_MUTEENABLE);

        if (sc->sc_type & EMUXKI_AUDIGY2_CA0108) {
                emuxki_writeio_4(sc, EMU_A_IOCFG,
                    0x0060 | emuxki_readio_4(sc, EMU_A_IOCFG));
        } else if (sc->sc_type & EMUXKI_AUDIGY2) {
                emuxki_writeio_4(sc, EMU_A_IOCFG,
                    EMU_A_IOCFG_GPOUT0 | emuxki_readio_4(sc, EMU_A_IOCFG));
        }

        /* enable AUDIO bit */
        hcfg = EMU_HCFG_AUDIOENABLE | EMU_HCFG_AUTOMUTE;

        if (sc->sc_type & EMUXKI_AUDIGY2) {
                hcfg |= EMU_HCFG_AC3ENABLE_CDSPDIF |
                        EMU_HCFG_AC3ENABLE_GPSPDIF;
        } else if (sc->sc_type & EMUXKI_AUDIGY) {
        } else {
                hcfg |= EMU_HCFG_LOCKTANKCACHE_MASK;
        }
        /* joystick not supported now */
        emuxki_writeio_4(sc, EMU_HCFG, hcfg);

        return 0;
}

/*
 * dsp programming
 */

static void
emuxki_dsp_addop(struct emuxki_softc *sc, uint16_t *pc, uint8_t op,
    uint16_t r, uint16_t a, uint16_t x, uint16_t y)
{
        uint32_t loword;
        uint32_t hiword;
        int reg;

        if (sc->sc_type & EMUXKI_AUDIGY) {
                reg = EMU_A_MICROCODEBASE;
                loword = (x << 12) & EMU_A_DSP_LOWORD_OPX_MASK;
                loword |= y & EMU_A_DSP_LOWORD_OPY_MASK;
                hiword = (op << 24) & EMU_A_DSP_HIWORD_OPCODE_MASK;
                hiword |= (r << 12) & EMU_A_DSP_HIWORD_RESULT_MASK;
                hiword |= a & EMU_A_DSP_HIWORD_OPA_MASK;
        } else {
                reg = EMU_MICROCODEBASE;
                loword = (x << 10) & EMU_DSP_LOWORD_OPX_MASK;
                loword |= y & EMU_DSP_LOWORD_OPY_MASK;
                hiword = (op << 20) & EMU_DSP_HIWORD_OPCODE_MASK;
                hiword |= (r << 10) & EMU_DSP_HIWORD_RESULT_MASK;
                hiword |= a & EMU_DSP_HIWORD_OPA_MASK;
        }

        reg += (*pc) * 2;
        /* must ordering; lo, hi */
        emuxki_write(sc, 0, reg, loword);
        emuxki_write(sc, 0, reg + 1, hiword);

        (*pc)++;
}

static void
emuxki_initfx(struct emuxki_softc *sc)
{
        uint16_t pc;

        /* Set all GPRs to 0 */
        for (pc = 0; pc < 256; pc++)
                emuxki_write(sc, 0, EMU_DSP_GPR(pc), 0);
        for (pc = 0; pc < 160; pc++) {
                emuxki_write(sc, 0, EMU_TANKMEMDATAREGBASE + pc, 0);
                emuxki_write(sc, 0, EMU_TANKMEMADDRREGBASE + pc, 0);
        }

        /* stop DSP, single step mode */
        emuxki_write(sc, 0, X1(DBG), X1(DBG_SINGLE_STEP));

        /* XXX: delay (48kHz equiv. 21us) if needed */

        /* start DSP programming */
        pc = 0;

        /* OUT[L/R] = 0 + FX[L/R] * 1 */
        emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
            X2(DSP_OUTL, DSP_OUT_A_FRONT),
            X1(DSP_CST(0)),
            X1(DSP_FX(0)),
            X1(DSP_CST(1)));
        emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
            X2(DSP_OUTR, DSP_OUT_A_FRONT),
            X1(DSP_CST(0)),
            X1(DSP_FX(1)),
            X1(DSP_CST(1)));
#if 0
        /* XXX: rear feature??? */
        /* Rear OUT[L/R] = 0 + FX[L/R] * 1 */
        emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
            X2(DSP_OUTL, DSP_OUT_A_REAR),
            X1(DSP_CST(0)),
            X1(DSP_FX(0)),
            X1(DSP_CST(1)));
        emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_MACINTS,
            X2(DSP_OUTR, DSP_OUT_A_REAR),
            X1(DSP_CST(0)),
            X1(DSP_FX(1)),
            X1(DSP_CST(1)));
#endif
        /* ADC recording[L/R] = AC97 In[L/R] */
        emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
            X2(DSP_OUTL, DSP_OUT_ADC),
            X2(DSP_INL, DSP_IN_AC97),
            X1(DSP_CST(0)),
            X1(DSP_CST(0)));
        emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
            X2(DSP_OUTR, DSP_OUT_ADC),
            X2(DSP_INR, DSP_IN_AC97),
            X1(DSP_CST(0)),
            X1(DSP_CST(0)));

        /* fill NOP the rest of the microcode */
        while (pc < 512) {
                emuxki_dsp_addop(sc, &pc, EMU_DSP_OP_ACC3,
                    X1(DSP_CST(0)),
                    X1(DSP_CST(0)),
                    X1(DSP_CST(0)),
                    X1(DSP_CST(0)));
        }

        /* clear single step flag, run DSP */
        emuxki_write(sc, 0, X1(DBG), 0);
}

/*
 * operations
 */

static void
emuxki_play_start(struct emuxki_softc *sc, int ch, uint32_t start, uint32_t end)
{
        uint32_t pitch;
        uint32_t volume;

        /* 48kHz:16384 = 128/375 */
        pitch = sc->play.sample_rate * 128 / 375;
        volume = 32767;

        emuxki_write(sc, ch, EMU_CHAN_DSL,
            (0 << 24) | /* send amount D = 0 */
            end);

        emuxki_write(sc, ch, EMU_CHAN_PSST,
            (0 << 24) | /* send amount C = 0 */
            start);

        emuxki_write(sc, ch, EMU_CHAN_VTFT,
            (volume << 16) |
            (0xffff));  /* cutoff filter = none */

        emuxki_write(sc, ch, EMU_CHAN_CVCF,
            (volume << 16) |
            (0xffff));  /* cutoff filter = none */

        emuxki_write(sc, ch, EMU_CHAN_PTRX,
            (pitch << 16) |
            ((ch == 0 ? 0x7f : 0) << 8) |       /* send amount A = 255,0(L) */
            ((ch == 0 ? 0 : 0x7f)));            /* send amount B = 0,255(R) */

        /* set the pitch to start */
        emuxki_write(sc, ch, EMU_CHAN_CPF,
            (pitch << 16) |
            EMU_CHAN_CPF_STEREO_MASK);  /* stereo only */
}

static void
emuxki_play_stop(struct emuxki_softc *sc, int ch)
{

        /* pitch = 0 to stop playing */
        emuxki_write(sc, ch, EMU_CHAN_CPF, EMU_CHAN_CPF_STOP_MASK);
        /* volume = 0 */
        emuxki_write(sc, ch, EMU_CHAN_CVCF, 0);
}

static void
emuxki_timer_start(struct emuxki_softc *sc)
{
        uint32_t timer;

        /* frame count of half PTE at 16bit, 2ch, 48kHz */
        timer = EMU_PTESIZE / 4 / 2;

        /* EMU_TIMER is 16bit register */
        emuxki_writeio_2(sc, EMU_TIMER, timer);
        emuxki_writeio_4(sc, EMU_INTE,
            emuxki_readio_4(sc, EMU_INTE) |
                EMU_INTE_INTERTIMERENB);
        DPRINTF("timer start\n");
}

static void
emuxki_timer_stop(struct emuxki_softc *sc)
{

        emuxki_writeio_4(sc, EMU_INTE,
            emuxki_readio_4(sc, EMU_INTE) &
                ~EMU_INTE_INTERTIMERENB);
        /* EMU_TIMER is 16bit register */
        emuxki_writeio_2(sc, EMU_TIMER, 0);
        DPRINTF("timer stop\n");
}

/*
 * audio interface
 */

static int
emuxki_query_format(void *hdl, audio_format_query_t *afp)
{

        return audio_query_format(emuxki_formats, EMUXKI_NFORMATS, afp);
}

static int
emuxki_set_format(void *hdl, int setmode,
    const audio_params_t *play, const audio_params_t *rec,
    audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
        struct emuxki_softc *sc = hdl;

        if ((setmode & AUMODE_PLAY))
                sc->play = *play;
        if ((setmode & AUMODE_RECORD))
                sc->rec = *rec;
        return 0;
}

static int
emuxki_halt_output(void *hdl)
{
        struct emuxki_softc *sc = hdl;

        emuxki_timer_stop(sc);
        emuxki_play_stop(sc, 0);
        emuxki_play_stop(sc, 1);
        return 0;
}

static int
emuxki_halt_input(void *hdl)
{
        struct emuxki_softc *sc = hdl;

        /* stop ADC */
        emuxki_write(sc, 0, EMU_ADCCR, 0);

        /* disable interrupt */
        emuxki_writeio_4(sc, EMU_INTE,
            emuxki_readio_4(sc, EMU_INTE) &
                ~EMU_INTE_ADCBUFENABLE);

        return 0;
}

static int
emuxki_intr(void *hdl)
{
        struct emuxki_softc *sc = hdl;
        uint32_t ipr;
        uint32_t curaddr;
        int handled = 0;

        mutex_spin_enter(&sc->sc_intr_lock);

        ipr = emuxki_readio_4(sc, EMU_IPR);
        DPRINTFN(3, "emuxki: ipr=%08x\n", ipr);
        if (sc->pintr && (ipr & EMU_IPR_INTERVALTIMER)) {
                /* read ch 0 */
                curaddr = emuxki_read(sc, 0, EMU_CHAN_CCCA) &
                    EMU_CHAN_CCCA_CURRADDR_MASK;
                DPRINTFN(3, "curaddr=%08x\n", curaddr);
                curaddr *= sc->pframesize;

                if (curaddr < sc->poffset)
                        curaddr += sc->plength;
                if (curaddr >= sc->poffset + sc->pblksize) {
                        dmamem_sync(sc->pmem, BUS_DMASYNC_POSTWRITE);
                        sc->pintr(sc->pintrarg);
                        sc->poffset += sc->pblksize;
                        if (sc->poffset >= sc->plength) {
                                sc->poffset -= sc->plength;
                        }
                        dmamem_sync(sc->pmem, BUS_DMASYNC_PREWRITE);
                }
                handled = 1;
        }

        if (sc->rintr &&
            (ipr & (EMU_IPR_ADCBUFHALFFULL | EMU_IPR_ADCBUFFULL))) {
                char *src;
                char *dst;

                /* Record DMA buffer has just 2 blocks */
                src = KERNADDR(sc->rmem);
                if (ipr & EMU_IPR_ADCBUFFULL) {
                        /* 2nd block */
                        src += EMU_REC_DMABLKSIZE;
                }
                dst = (char *)sc->rptr + sc->rcurrent;

                dmamem_sync(sc->rmem, BUS_DMASYNC_POSTREAD);
                memcpy(dst, src, EMU_REC_DMABLKSIZE);
                /* for next trans */
                dmamem_sync(sc->rmem, BUS_DMASYNC_PREREAD);
                sc->rcurrent += EMU_REC_DMABLKSIZE;

                if (sc->rcurrent >= sc->roffset + sc->rblksize) {
                        sc->rintr(sc->rintrarg);
                        sc->roffset += sc->rblksize;
                        if (sc->roffset >= sc->rlength) {
                                sc->roffset = 0;
                                sc->rcurrent = 0;
                        }
                }

                handled = 1;
        }

#if defined(EMUXKI_DEBUG)
        if (!handled) {
                char buf[1024];
                snprintb(buf, sizeof(buf),
                    "\20"
                    "\x19""RATETRCHANGE"
                    "\x18""FXDSP"
                    "\x17""FORCEINT"
                    "\x16""PCIERROR"
                    "\x15""VOLINCR"
                    "\x14""VOLDECR"
                    "\x13""MUTE"
                    "\x12""MICBUFFULL"
                    "\x11""MICBUFHALFFULL"
                    "\x10""ADCBUFFULL"
                    "\x0f""ADCBUFHALFFULL"
                    "\x0e""EFXBUFFULL"
                    "\x0d""EFXBUFHALFFULL"
                    "\x0c""GPSPDIFSTCHANGE"
                    "\x0b""CDROMSTCHANGE"
                    /*     INTERVALTIMER */
                    "\x09""MIDITRANSBUFE"
                    "\x08""MIDIRECVBUFE"
                    "\x07""CHANNELLOOP"
                    , ipr);
                DPRINTF("unexpected intr: %s\n", buf);

                /* for debugging (must not handle if !DEBUG) */
                handled = 1;
        }
#endif

        /* Reset interrupt bit */
        emuxki_writeio_4(sc, EMU_IPR, ipr);

        mutex_spin_exit(&sc->sc_intr_lock);

        /* Interrupt handler must return !=0 if handled */
        return handled;
}

static int
emuxki_getdev(void *hdl, struct audio_device *dev)
{
        struct emuxki_softc *sc = hdl;

        *dev = sc->sc_audv;
        return 0;
}

static int
emuxki_set_port(void *hdl, mixer_ctrl_t *mctl)
{
        struct emuxki_softc *sc = hdl;

        return sc->codecif->vtbl->mixer_set_port(sc->codecif, mctl);
}

static int
emuxki_get_port(void *hdl, mixer_ctrl_t *mctl)
{
        struct emuxki_softc *sc = hdl;

        return sc->codecif->vtbl->mixer_get_port(sc->codecif, mctl);
}

static int
emuxki_query_devinfo(void *hdl, mixer_devinfo_t *minfo)
{
        struct emuxki_softc *sc = hdl;

        return sc->codecif->vtbl->query_devinfo(sc->codecif, minfo);
}

static void *
emuxki_allocm(void *hdl, int direction, size_t size)
{
        struct emuxki_softc *sc = hdl;

        if (direction == AUMODE_PLAY) {
                if (sc->pmem) {
                        panic("pmem already allocated\n");
                        return NULL;
                }
                sc->pmem = dmamem_alloc(sc, size);
                return KERNADDR(sc->pmem);
        } else {
                /* rmem is fixed size internal DMA buffer */
                if (sc->rmem) {
                        panic("rmem already allocated\n");
                        return NULL;
                }
                /* rmem fixed size */
                sc->rmem = dmamem_alloc(sc, EMU_REC_DMASIZE);

                /* recording MI buffer is normal kmem, software trans. */
                sc->rptr = kmem_alloc(size, KM_SLEEP);
                return sc->rptr;
        }
}

static void
emuxki_freem(void *hdl, void *ptr, size_t size)
{
        struct emuxki_softc *sc = hdl;

        if (sc->pmem && ptr == KERNADDR(sc->pmem)) {
                dmamem_free(sc->pmem);
                sc->pmem = NULL;
        }
        if (sc->rmem && ptr == sc->rptr) {
                dmamem_free(sc->rmem);
                sc->rmem = NULL;
                kmem_free(sc->rptr, size);
                sc->rptr = NULL;
        }
}

/*
 * blocksize rounding to EMU_PTESIZE. It is for easy to drive.
 */
static int
emuxki_round_blocksize(void *hdl, int blksize,
    int mode, const audio_params_t* param)
{

        /*
         * This is not necessary for recording, but symmetric for easy.
         * For recording buffer/block size requirements of hardware,
         * see EMU_RECBS_BUFSIZE_*
         */
        if (blksize < EMU_PTESIZE)
                blksize = EMU_PTESIZE;
        return rounddown(blksize, EMU_PTESIZE);
}

static size_t
emuxki_round_buffersize(void *hdl, int direction, size_t bsize)
{

        /* This is not necessary for recording, but symmetric for easy */
        if (bsize < EMU_MINPTE * EMU_PTESIZE) {
                bsize = EMU_MINPTE * EMU_PTESIZE;
        } else if (bsize > EMU_MAXPTE * EMU_PTESIZE) {
                bsize = EMU_MAXPTE * EMU_PTESIZE;
        }
        return roundup(bsize, EMU_PTESIZE);
}

static int
emuxki_get_props(void *hdl)
{

        return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE |
            AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
}

static int
emuxki_trigger_output(void *hdl, void *start, void *end, int blksize,
    void (*intr)(void *), void *arg, const audio_params_t *params)
{
        struct emuxki_softc *sc = hdl;
        int npage;
        uint32_t *kptb;
        bus_addr_t dpmem;
        int i;
        uint32_t hwstart;
        uint32_t hwend;

        if (sc->pmem == NULL)
                panic("pmem == NULL\n");
        if (start != KERNADDR(sc->pmem))
                panic("start != KERNADDR(sc->pmem)\n");

        sc->pframesize = 4;     /* channels * bit / 8 = 2*16/8=4 */
        sc->pblksize = blksize;
        sc->plength = (char *)end - (char *)start;
        sc->poffset = 0;
        npage = roundup(sc->plength, EMU_PTESIZE);

        kptb = KERNADDR(sc->ptb);
        dpmem = DMAADDR(sc->pmem);
        for (i = 0; i < npage; i++) {
                kptb[i] = htole32(dpmem << 1);
                dpmem += EMU_PTESIZE;
        }
        dmamem_sync(sc->ptb, BUS_DMASYNC_PREWRITE);

        hwstart = 0;
        hwend = hwstart + sc->plength / sc->pframesize;

        sc->pintr = intr;
        sc->pintrarg = arg;

        dmamem_sync(sc->pmem, BUS_DMASYNC_PREWRITE);

        emuxki_play_start(sc, 0, hwstart, hwend);
        emuxki_play_start(sc, 1, hwstart, hwend);

        emuxki_timer_start(sc);

        return 0;
}

/*
 * Recording uses temporary buffer.  Because it can use ADC_HALF/FULL
 * interrupts and this method doesn't conflict with playback.
 */

static int
emuxki_trigger_input(void *hdl, void *start, void *end, int blksize,
    void (*intr)(void *), void *arg, const audio_params_t *params)
{
        struct emuxki_softc *sc = hdl;

        if (sc->rmem == NULL)
                panic("rmem == NULL\n");
        if (start != sc->rptr)
                panic("start != sc->rptr\n");

        sc->rframesize = 4;     /* channels * bit / 8 = 2*16/8=4 */
        sc->rblksize = blksize;
        sc->rlength = (char *)end - (char *)start;
        sc->roffset = 0;
        sc->rcurrent = 0;

        sc->rintr = intr;
        sc->rintrarg = arg;

        /*
         * Memo:
         *  recording source is selected by AC97
         *  AC97 input source routes to ADC by FX(DSP)
         *
         * Must keep following sequence order
         */

        /* first, stop ADC */
        emuxki_write(sc, 0, EMU_ADCCR, 0);
        emuxki_write(sc, 0, EMU_ADCBA, 0);
        emuxki_write(sc, 0, EMU_ADCBS, 0);

        dmamem_sync(sc->rmem, BUS_DMASYNC_PREREAD);

        /* ADC interrupt enable */
        emuxki_writeio_4(sc, EMU_INTE,
            emuxki_readio_4(sc, EMU_INTE) |
                EMU_INTE_ADCBUFENABLE);

        /* ADC Enable */
        /* stereo, 48kHz, enable */
        emuxki_write(sc, 0, EMU_ADCCR,
            X1(ADCCR_LCHANENABLE) | X1(ADCCR_RCHANENABLE));

        /* ADC buffer address */
        emuxki_write(sc, 0, X1(ADCIDX), 0);
        emuxki_write(sc, 0, EMU_ADCBA, DMAADDR(sc->rmem));

        /* ADC buffer size, to start */
        emuxki_write(sc, 0, EMU_ADCBS, EMU_REC_BUFSIZE_RECBS);

        return 0;
}

static void
emuxki_get_locks(void *hdl, kmutex_t **intr, kmutex_t **proc)
{
        struct emuxki_softc *sc = hdl;

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

/*
 * AC97
 */

static int
emuxki_ac97_init(struct emuxki_softc *sc)
{

        sc->hostif.arg = sc;
        sc->hostif.attach = emuxki_ac97_attach;
        sc->hostif.read = emuxki_ac97_read;
        sc->hostif.write = emuxki_ac97_write;
        sc->hostif.reset = emuxki_ac97_reset;
        sc->hostif.flags = emuxki_ac97_flags;
        return ac97_attach(&sc->hostif, sc->sc_dev, &sc->sc_lock);
}

/*
 * AC97 callbacks
 */

static int
emuxki_ac97_attach(void *hdl, struct ac97_codec_if *codecif)
{
        struct emuxki_softc *sc = hdl;

        sc->codecif = codecif;
        return 0;
}

static int
emuxki_ac97_read(void *hdl, uint8_t reg, uint16_t *val)
{
        struct emuxki_softc *sc = hdl;

        mutex_spin_enter(&sc->sc_index_lock);
        emuxki_writeio_1(sc, EMU_AC97ADDR, reg);
        *val = emuxki_readio_2(sc, EMU_AC97DATA);
        mutex_spin_exit(&sc->sc_index_lock);

        return 0;
}

static int
emuxki_ac97_write(void *hdl, uint8_t reg, uint16_t val)
{
        struct emuxki_softc *sc = hdl;

        mutex_spin_enter(&sc->sc_index_lock);
        emuxki_writeio_1(sc, EMU_AC97ADDR, reg);
        emuxki_writeio_2(sc, EMU_AC97DATA, val);
        mutex_spin_exit(&sc->sc_index_lock);

        return 0;
}

static int
emuxki_ac97_reset(void *hdl)
{

        return 0;
}

static enum ac97_host_flags
emuxki_ac97_flags(void *hdl)
{

        return AC97_HOST_SWAPPED_CHANNELS;
}

MODULE(MODULE_CLASS_DRIVER, emuxki, "pci,audio");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
emuxki_modcmd(modcmd_t cmd, void *opaque)
{
        int error = 0;

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                error = config_init_component(cfdriver_ioconf_emuxki,
                    cfattach_ioconf_emuxki, cfdata_ioconf_emuxki);
#endif
                return error;
        case MODULE_CMD_FINI:
#ifdef _MODULE
                error = config_fini_component(cfdriver_ioconf_emuxki,
                    cfattach_ioconf_emuxki, cfdata_ioconf_emuxki);
#endif
                return error;
        default:
                return ENOTTY;
        }
}