/* $NetBSD: hdaudio.c,v 1.18 2022/04/07 19:33:37 andvar Exp $ */

/*
 * Copyright (c) 2009 Precedence Technologies Ltd <support@precedence.co.uk>
 * Copyright (c) 2009 Jared D. McNeill <jmcneill@invisible.ca>
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Precedence Technologies Ltd
 *
 * 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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hdaudio.c,v 1.18 2022/04/07 19:33:37 andvar Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/bus.h>
#include <sys/kmem.h>
#include <sys/module.h>

#include "hdaudiovar.h"
#include "hdaudioreg.h"
#include "hdaudioio.h"
#include "hdaudio_verbose.h"
#include "hdaudiodevs.h"

/* #define      HDAUDIO_DEBUG */

#define HDAUDIO_RESET_TIMEOUT   5000
#define HDAUDIO_CORB_TIMEOUT    1000
#define HDAUDIO_RIRB_TIMEOUT    5000

#define HDAUDIO_CODEC_DELAY     1000    /* spec calls for 250 */

dev_type_open(hdaudioopen);
dev_type_close(hdaudioclose);
dev_type_ioctl(hdaudioioctl);

const struct cdevsw hdaudio_cdevsw = {
        .d_open = hdaudioopen,
        .d_close = hdaudioclose,
        .d_read = noread,
        .d_write = nowrite,
        .d_ioctl = hdaudioioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = nopoll,
        .d_mmap = nommap,
        .d_kqfilter = nokqfilter,
        .d_discard = nodiscard,
        .d_flag = D_OTHER
};

extern struct cfdriver hdaudio_cd;

#define HDAUDIOUNIT(x)  minor((x))

static void
hdaudio_stream_init(struct hdaudio_softc *sc, int nis, int nos, int nbidir)
{
        int i, cnt = 0;

        for (i = 0; i < nis && cnt < HDAUDIO_MAX_STREAMS; i++) {
                sc->sc_stream[cnt].st_host = sc;
                sc->sc_stream[cnt].st_enable = true;
                sc->sc_stream[cnt].st_shift = cnt;
                sc->sc_stream[cnt++].st_type = HDAUDIO_STREAM_ISS;
        }
        for (i = 0; i < nos && cnt < HDAUDIO_MAX_STREAMS; i++) {
                sc->sc_stream[cnt].st_host = sc;
                sc->sc_stream[cnt].st_enable = true;
                sc->sc_stream[cnt].st_shift = cnt;
                sc->sc_stream[cnt++].st_type = HDAUDIO_STREAM_OSS;
        }
        for (i = 0; i < nbidir && cnt < HDAUDIO_MAX_STREAMS; i++) {
                sc->sc_stream[cnt].st_host = sc;
                sc->sc_stream[cnt].st_enable = true;
                sc->sc_stream[cnt].st_shift = cnt;
                sc->sc_stream[cnt++].st_type = HDAUDIO_STREAM_BSS;
        }

        for (i = 0; i < cnt; i++)
                hdaudio_stream_stop(&sc->sc_stream[i]);

        sc->sc_stream_mask = 0;
}

static void
hdaudio_codec_init(struct hdaudio_softc *sc)
{
        int i;

        for (i = 0; i < HDAUDIO_MAX_CODECS; i++) {
                sc->sc_codec[i].co_addr = i;
                sc->sc_codec[i].co_host = sc;
        }
}

static void
hdaudio_init(struct hdaudio_softc *sc)
{
        const uint8_t vmaj = hda_read1(sc, HDAUDIO_MMIO_VMAJ);
        const uint8_t vmin = hda_read1(sc, HDAUDIO_MMIO_VMIN);
        const uint16_t gcap = hda_read2(sc, HDAUDIO_MMIO_GCAP);
        const int nis = HDAUDIO_GCAP_ISS(gcap);
        const int nos = HDAUDIO_GCAP_OSS(gcap);
        const int nbidir = HDAUDIO_GCAP_BSS(gcap);
        const int nsdo = HDAUDIO_GCAP_NSDO(gcap);
        const int addr64 = HDAUDIO_GCAP_64OK(gcap);

        hda_print(sc, "HDA ver. %d.%d, OSS %d, ISS %d, BSS %d, SDO %d%s\n",
            vmaj, vmin, nos, nis, nbidir, nsdo, addr64 ? ", 64-bit" : "");

        /* Initialize codecs and streams */
        hdaudio_codec_init(sc);
        hdaudio_stream_init(sc, nis, nos, nbidir);
}

static int
hdaudio_codec_probe(struct hdaudio_softc *sc)
{
        uint16_t statests;
        int codecid;

        statests = hda_read2(sc, HDAUDIO_MMIO_STATESTS);
        for (codecid = 0; codecid < HDAUDIO_MAX_CODECS; codecid++)
                if (statests & (1 << codecid))
                        sc->sc_codec[codecid].co_valid = true;
        hda_write2(sc, HDAUDIO_MMIO_STATESTS, statests);

        return statests;
}

int
hdaudio_dma_alloc(struct hdaudio_softc *sc, struct hdaudio_dma *dma,
    int flags)
{
        int err;

        KASSERT(dma->dma_size > 0);

        err = bus_dmamem_alloc(sc->sc_dmat, dma->dma_size, 128, 0,
            dma->dma_segs, sizeof(dma->dma_segs) / sizeof(dma->dma_segs[0]),
            &dma->dma_nsegs, BUS_DMA_WAITOK);
        if (err)
                return err;
        err = bus_dmamem_map(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs,
            dma->dma_size, &dma->dma_addr, BUS_DMA_WAITOK | flags);
        if (err)
                goto free;
        err = bus_dmamap_create(sc->sc_dmat, dma->dma_size, dma->dma_nsegs,
            dma->dma_size, 0, BUS_DMA_WAITOK, &dma->dma_map);
        if (err)
                goto unmap;
        err = bus_dmamap_load(sc->sc_dmat, dma->dma_map, dma->dma_addr,
            dma->dma_size, NULL, BUS_DMA_WAITOK | flags);
        if (err)
                goto destroy;

        memset(dma->dma_addr, 0, dma->dma_size);
        bus_dmamap_sync(sc->sc_dmat, dma->dma_map, 0, dma->dma_size,
            BUS_DMASYNC_PREWRITE);

        dma->dma_valid = true;
        return 0;

destroy:
        bus_dmamap_destroy(sc->sc_dmat, dma->dma_map);  
unmap:
        bus_dmamem_unmap(sc->sc_dmat, dma->dma_addr, dma->dma_size);
free:
        bus_dmamem_free(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs);

        dma->dma_valid = false;
        return err;
}

void
hdaudio_dma_free(struct hdaudio_softc *sc, struct hdaudio_dma *dma)
{
        if (dma->dma_valid == false)
                return;
        bus_dmamap_unload(sc->sc_dmat, dma->dma_map);
        bus_dmamap_destroy(sc->sc_dmat, dma->dma_map);  
        bus_dmamem_unmap(sc->sc_dmat, dma->dma_addr, dma->dma_size);
        bus_dmamem_free(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs);
        dma->dma_valid = false;
}

static void
hdaudio_corb_enqueue(struct hdaudio_softc *sc, int addr, int nid,
    uint32_t control, uint32_t param)
{
        uint32_t *corb = DMA_KERNADDR(&sc->sc_corb);
        uint32_t verb;
        uint16_t corbrp;
        int wp;

        /* Build command */
        verb = (addr << 28) | (nid << 20) | (control << 8) | param;

        /* Fetch and update write pointer */
        corbrp = hda_read2(sc, HDAUDIO_MMIO_CORBWP);
        wp = (corbrp & 0xff) + 1;
        if (wp >= (sc->sc_corb.dma_size / sizeof(*corb)))
                wp = 0;

        /* Enqueue command */
        bus_dmamap_sync(sc->sc_dmat, sc->sc_corb.dma_map, 0,
            sc->sc_corb.dma_size, BUS_DMASYNC_POSTWRITE);
        corb[wp] = verb;
        bus_dmamap_sync(sc->sc_dmat, sc->sc_corb.dma_map, 0,
            sc->sc_corb.dma_size, BUS_DMASYNC_PREWRITE);

        /* Commit updated write pointer */
        hda_write2(sc, HDAUDIO_MMIO_CORBWP, wp);
}

static void
hdaudio_rirb_unsol(struct hdaudio_softc *sc, struct rirb_entry *entry)
{
        struct hdaudio_codec *co;
        struct hdaudio_function_group *fg;
        uint8_t codecid = RIRB_CODEC_ID(entry);
        unsigned int i;

        if (codecid >= HDAUDIO_MAX_CODECS) {
                hda_error(sc, "unsol: codec id 0x%02x out of range\n", codecid);
                return;
        }
        co = &sc->sc_codec[codecid];
        if (sc->sc_codec[codecid].co_valid == false) {
                hda_error(sc, "unsol: codec id 0x%02x not valid\n", codecid);
                return;
        }

        for (i = 0; i < co->co_nfg; i++) {
                fg = &co->co_fg[i];
                if (fg->fg_device && fg->fg_unsol)
                        fg->fg_unsol(fg->fg_device, entry->resp);
        }
}

static uint32_t
hdaudio_rirb_dequeue(struct hdaudio_softc *sc, bool unsol)
{
        uint16_t rirbwp;
        uint64_t *rirb = DMA_KERNADDR(&sc->sc_rirb);
        struct rirb_entry entry;
        int retry;

        for (;;) {
                retry = HDAUDIO_RIRB_TIMEOUT;

                rirbwp = hda_read2(sc, HDAUDIO_MMIO_RIRBWP);
                while (--retry > 0 && (rirbwp & 0xff) == sc->sc_rirbrp) {
                        if (unsol) {
                                /* don't wait for more unsol events */
                                hda_trace(sc, "unsol: rirb empty\n");
                                return 0xffffffff;
                        }
                        hda_delay(10);
                        rirbwp = hda_read2(sc, HDAUDIO_MMIO_RIRBWP);
                }
                if (retry == 0) {
                        hda_error(sc, "RIRB timeout\n");
                        return 0xffffffff;
                }

                sc->sc_rirbrp++;
                if (sc->sc_rirbrp >= (sc->sc_rirb.dma_size / sizeof(*rirb)))
                        sc->sc_rirbrp = 0;

                bus_dmamap_sync(sc->sc_dmat, sc->sc_rirb.dma_map, 0,
                    sc->sc_rirb.dma_size, BUS_DMASYNC_POSTREAD);
                entry = *(struct rirb_entry *)&rirb[sc->sc_rirbrp];
                bus_dmamap_sync(sc->sc_dmat, sc->sc_rirb.dma_map, 0,
                    sc->sc_rirb.dma_size, BUS_DMASYNC_PREREAD);

                hda_trace(sc, "%s: response %08X %08X\n",
                    unsol ? "unsol" : "cmd  ",
                    entry.resp, entry.resp_ex);

                if (RIRB_UNSOL(&entry)) {
                        hdaudio_rirb_unsol(sc, &entry);
                        continue;
                }

                return entry.resp;
        }
}

uint32_t
hdaudio_command(struct hdaudio_codec *co, int nid, uint32_t control,
    uint32_t param)
{
        uint32_t result;
        struct hdaudio_softc *sc = co->co_host;
        mutex_enter(&sc->sc_corb_mtx);
        result = hdaudio_command_unlocked(co, nid, control, param);
        mutex_exit(&sc->sc_corb_mtx);
        return result;
}

uint32_t
hdaudio_command_unlocked(struct hdaudio_codec *co, int nid, uint32_t control,
    uint32_t param)
{
        struct hdaudio_softc *sc = co->co_host;
        uint32_t result;

        hda_trace(sc, "cmd  : request %08X %08X (%02X)\n",
            control, param, nid);
        hdaudio_corb_enqueue(sc, co->co_addr, nid, control, param);
        result = hdaudio_rirb_dequeue(sc, false);

        /* Clear response interrupt status */
        hda_write1(sc, HDAUDIO_MMIO_RIRBSTS, hda_read1(sc, HDAUDIO_MMIO_RIRBSTS));

        return result;
}

static int
hdaudio_corb_setsize(struct hdaudio_softc *sc)
{
        uint8_t corbsize;
        bus_size_t bufsize = 0;

        /*
         * The size of the CORB is programmable to 2, 16, or 256 entries
         * by using the CORBSIZE register. Choose a size based on the
         * controller capabilities, preferring a larger size when possible.
         */
        corbsize = hda_read1(sc, HDAUDIO_MMIO_CORBSIZE);
        corbsize &= ~0x3;
        if ((corbsize >> 4) & 0x4) {
                corbsize |= 0x2;
                bufsize = 1024;
        } else if ((corbsize >> 4) & 0x2) {
                corbsize |= 0x1;
                bufsize = 64;
        } else if ((corbsize >> 4) & 0x1) {
                corbsize |= 0x0;
                bufsize = 8;
        } else {
                hda_error(sc, "couldn't configure CORB size\n");
                return ENXIO;
        }

#if defined(HDAUDIO_DEBUG)
        hda_print(sc, "using %d byte CORB (cap %X)\n",
            (int)bufsize, corbsize >> 4);
#endif

        sc->sc_corb.dma_size = bufsize;
        sc->sc_corb.dma_sizereg = corbsize;

        return 0;
}

static int
hdaudio_corb_config(struct hdaudio_softc *sc)
{
        uint32_t corbubase, corblbase;
        uint16_t corbrp;
        int retry = HDAUDIO_CORB_TIMEOUT;

        /* Program command buffer base address and size */
        corblbase = (uint32_t)DMA_DMAADDR(&sc->sc_corb);
        corbubase = (uint32_t)(((uint64_t)DMA_DMAADDR(&sc->sc_corb)) >> 32);
        hda_write4(sc, HDAUDIO_MMIO_CORBLBASE, corblbase);
        hda_write4(sc, HDAUDIO_MMIO_CORBUBASE, corbubase);
        hda_write1(sc, HDAUDIO_MMIO_CORBSIZE, sc->sc_corb.dma_sizereg);

        /* Clear the read and write pointers */
        hda_write2(sc, HDAUDIO_MMIO_CORBRP, HDAUDIO_CORBRP_RP_RESET);
        hda_write2(sc, HDAUDIO_MMIO_CORBRP, 0);
        do {
                hda_delay(10);
                corbrp = hda_read2(sc, HDAUDIO_MMIO_CORBRP);
        } while (--retry > 0 && (corbrp & HDAUDIO_CORBRP_RP_RESET) != 0);
        if (retry == 0) {
                hda_error(sc, "timeout resetting CORB\n");
                return ETIME;
        }
        hda_write2(sc, HDAUDIO_MMIO_CORBWP, 0);

        return 0;
}

static int
hdaudio_corb_stop(struct hdaudio_softc *sc)
{
        uint8_t corbctl;
        int retry = HDAUDIO_CORB_TIMEOUT;

        /* Stop the CORB if necessary */
        corbctl = hda_read1(sc, HDAUDIO_MMIO_CORBCTL);
        if (corbctl & HDAUDIO_CORBCTL_RUN) {
                corbctl &= ~HDAUDIO_CORBCTL_RUN;
                hda_write1(sc, HDAUDIO_MMIO_CORBCTL, corbctl);
                do {
                        hda_delay(10);
                        corbctl = hda_read1(sc, HDAUDIO_MMIO_CORBCTL);
                } while (--retry > 0 && (corbctl & HDAUDIO_CORBCTL_RUN) != 0);
                if (retry == 0) {
                        hda_error(sc, "timeout stopping CORB\n");
                        return ETIME;
                }
        }

        return 0;
}

static int
hdaudio_corb_start(struct hdaudio_softc *sc)
{
        uint8_t corbctl;
        int retry = HDAUDIO_CORB_TIMEOUT;

        /* Start the CORB if necessary */
        corbctl = hda_read1(sc, HDAUDIO_MMIO_CORBCTL);
        if ((corbctl & HDAUDIO_CORBCTL_RUN) == 0) {
                corbctl |= HDAUDIO_CORBCTL_RUN;
                hda_write1(sc, HDAUDIO_MMIO_CORBCTL, corbctl);
                do {
                        hda_delay(10);
                        corbctl = hda_read1(sc, HDAUDIO_MMIO_CORBCTL);
                } while (--retry > 0 && (corbctl & HDAUDIO_CORBCTL_RUN) == 0);
                if (retry == 0) {
                        hda_error(sc, "timeout starting CORB\n");
                        return ETIME;
                }
        }

        return 0;
}

static int
hdaudio_rirb_stop(struct hdaudio_softc *sc)
{
        uint8_t rirbctl;
        int retry = HDAUDIO_RIRB_TIMEOUT;

        /* Stop the RIRB if necessary */
        rirbctl = hda_read1(sc, HDAUDIO_MMIO_RIRBCTL);
        if (rirbctl & (HDAUDIO_RIRBCTL_RUN|HDAUDIO_RIRBCTL_ROI_EN)) {
                rirbctl &= ~HDAUDIO_RIRBCTL_RUN;
                rirbctl &= ~HDAUDIO_RIRBCTL_ROI_EN;
                hda_write1(sc, HDAUDIO_MMIO_RIRBCTL, rirbctl);
                do {
                        hda_delay(10);
                        rirbctl = hda_read1(sc, HDAUDIO_MMIO_RIRBCTL);
                } while (--retry > 0 && (rirbctl & HDAUDIO_RIRBCTL_RUN) != 0);
                if (retry == 0) {
                        hda_error(sc, "timeout stopping RIRB\n");
                        return ETIME;
                }
        }

        return 0;
}

static int
hdaudio_rirb_start(struct hdaudio_softc *sc)
{
        uint8_t rirbctl;
        int retry = HDAUDIO_RIRB_TIMEOUT;

        /* Set the RIRB interrupt count */
        hda_write2(sc, HDAUDIO_MMIO_RINTCNT, 1);

        /* Start the RIRB */
        rirbctl = hda_read1(sc, HDAUDIO_MMIO_RIRBCTL);
        rirbctl |= HDAUDIO_RIRBCTL_RUN;
        rirbctl |= HDAUDIO_RIRBCTL_INT_EN;
        hda_write1(sc, HDAUDIO_MMIO_RIRBCTL, rirbctl);
        do {
                hda_delay(10);
                rirbctl = hda_read1(sc, HDAUDIO_MMIO_RIRBCTL);
        } while (--retry > 0 && (rirbctl & HDAUDIO_RIRBCTL_RUN) == 0);
        if (retry == 0) {
                hda_error(sc, "timeout starting RIRB\n");
                return ETIME;
        }

        return 0;
}

static int
hdaudio_rirb_setsize(struct hdaudio_softc *sc)
{
        uint8_t rirbsize;
        bus_size_t bufsize = 0;

        /*
         * The size of the RIRB is programmable to 2, 16, or 256 entries
         * by using the RIRBSIZE register. Choose a size based on the
         * controller capabilities, preferring a larger size when possible.
         */
        rirbsize = hda_read1(sc, HDAUDIO_MMIO_RIRBSIZE);
        rirbsize &= ~0x3;
        if ((rirbsize >> 4) & 0x4) {
                rirbsize |= 0x2;
                bufsize = 2048;
        } else if ((rirbsize >> 4) & 0x2) {
                rirbsize |= 0x1;
                bufsize = 128;
        } else if ((rirbsize >> 4) & 0x1) {
                rirbsize |= 0x0;
                bufsize = 16;
        } else {
                hda_error(sc, "couldn't configure RIRB size\n");
                return ENXIO;
        }

#if defined(HDAUDIO_DEBUG)
        hda_print(sc, "using %d byte RIRB (cap %X)\n",
            (int)bufsize, rirbsize >> 4);
#endif

        sc->sc_rirb.dma_size = bufsize;
        sc->sc_rirb.dma_sizereg = rirbsize;

        return 0;
}

static int
hdaudio_rirb_config(struct hdaudio_softc *sc)
{
        uint32_t rirbubase, rirblbase;

        /* Program command buffer base address and size */
        rirblbase = (uint32_t)DMA_DMAADDR(&sc->sc_rirb);
        rirbubase = (uint32_t)(((uint64_t)DMA_DMAADDR(&sc->sc_rirb)) >> 32);
        hda_write4(sc, HDAUDIO_MMIO_RIRBLBASE, rirblbase);
        hda_write4(sc, HDAUDIO_MMIO_RIRBUBASE, rirbubase);
        hda_write1(sc, HDAUDIO_MMIO_RIRBSIZE, sc->sc_rirb.dma_sizereg);

        /* Clear the write pointer */
        hda_write2(sc, HDAUDIO_MMIO_RIRBWP, HDAUDIO_RIRBWP_WP_RESET);
        sc->sc_rirbrp = 0;

        return 0;
}

static int
hdaudio_reset(struct hdaudio_softc *sc)
{
        int retry = HDAUDIO_RESET_TIMEOUT;
        uint32_t gctl;
        int err;

        if ((err = hdaudio_rirb_stop(sc)) != 0) {
                hda_error(sc, "couldn't reset because RIRB is busy\n");
                return err;
        }
        if ((err = hdaudio_corb_stop(sc)) != 0) {
                hda_error(sc, "couldn't reset because CORB is busy\n");
                return err;
        }

        /* Disable wake events */
        hda_write2(sc, HDAUDIO_MMIO_WAKEEN, 0);

        /* Disable interrupts */
        hda_write4(sc, HDAUDIO_MMIO_INTCTL, 0);

        /* Clear state change status register */
        hda_write2(sc, HDAUDIO_MMIO_STATESTS,
            hda_read2(sc, HDAUDIO_MMIO_STATESTS));
        hda_write1(sc, HDAUDIO_MMIO_RIRBSTS,
            hda_read1(sc, HDAUDIO_MMIO_RIRBSTS));

        /* Put the controller into reset state */
        gctl = hda_read4(sc, HDAUDIO_MMIO_GCTL);
        gctl &= ~HDAUDIO_GCTL_CRST;
        hda_write4(sc, HDAUDIO_MMIO_GCTL, gctl);
        do {
                hda_delay(10);
                gctl = hda_read4(sc, HDAUDIO_MMIO_GCTL);
        } while (--retry > 0 && (gctl & HDAUDIO_GCTL_CRST) != 0);
        if (retry == 0) {
                hda_error(sc, "timeout entering reset state\n");
                return ETIME;
        }

        hda_delay(1000);

        /* Now the controller is in reset state, so bring it out */
        retry = HDAUDIO_RESET_TIMEOUT;
        hda_write4(sc, HDAUDIO_MMIO_GCTL, gctl | HDAUDIO_GCTL_CRST);
        do {
                hda_delay(10);
                gctl = hda_read4(sc, HDAUDIO_MMIO_GCTL);
        } while (--retry > 0 && (gctl & HDAUDIO_GCTL_CRST) == 0);
        if (retry == 0) {
                hda_error(sc, "timeout leaving reset state\n");
                return ETIME;
        }

        hda_delay(2000);

        /* Accept unsolicited responses */
        hda_write4(sc, HDAUDIO_MMIO_GCTL, gctl | HDAUDIO_GCTL_UNSOL_EN);

        return 0;
}

static void
hdaudio_intr_enable(struct hdaudio_softc *sc)
{
        hda_write4(sc, HDAUDIO_MMIO_INTSTS,
            hda_read4(sc, HDAUDIO_MMIO_INTSTS));
        hda_write4(sc, HDAUDIO_MMIO_INTCTL,
            HDAUDIO_INTCTL_GIE | HDAUDIO_INTCTL_CIE);
}

static void
hdaudio_intr_disable(struct hdaudio_softc *sc)
{
        hda_write4(sc, HDAUDIO_MMIO_INTCTL, 0);
}

static int
hdaudio_config_print(void *opaque, const char *pnp)
{
        prop_dictionary_t dict = opaque;
        uint8_t fgtype, nid;
        uint16_t vendor, product;
        const char *type = "unknown";

        prop_dictionary_get_uint8(dict, "function-group-type", &fgtype);
        prop_dictionary_get_uint8(dict, "node-id", &nid);
        prop_dictionary_get_uint16(dict, "vendor-id", &vendor);
        prop_dictionary_get_uint16(dict, "product-id", &product);
        if (pnp) {
                if (fgtype == HDAUDIO_GROUP_TYPE_AFG)
                        type = "hdafg";
                else if (fgtype == HDAUDIO_GROUP_TYPE_VSM_FG)
                        type = "hdvsmfg";

                aprint_normal("%s at %s", type, pnp);
        }
        aprint_debug(" vendor 0x%04X product 0x%04X nid 0x%02X",
            vendor, product, nid);

        return UNCONF;
}

static void
hdaudio_attach_fg(struct hdaudio_function_group *fg, prop_array_t config)
{
        struct hdaudio_codec *co = fg->fg_codec;
        struct hdaudio_softc *sc = co->co_host;
        prop_dictionary_t args = prop_dictionary_create();
        uint64_t fgptr = (vaddr_t)fg;
        int locs[1];

        prop_dictionary_set_uint8(args, "function-group-type", fg->fg_type);
        prop_dictionary_set_uint64(args, "function-group", fgptr);
        prop_dictionary_set_uint8(args, "node-id", fg->fg_nid);
        prop_dictionary_set_uint16(args, "vendor-id", fg->fg_vendor);
        prop_dictionary_set_uint16(args, "product-id", fg->fg_product);
        if (config)
                prop_dictionary_set(args, "pin-config", config);

        locs[0] = fg->fg_nid;

        fg->fg_device = config_found(sc->sc_dev, args, hdaudio_config_print,
            CFARGS(.submatch = config_stdsubmatch,
                   .locators = locs));

        prop_object_release(args);
}

static void
hdaudio_codec_attach(struct hdaudio_codec *co)
{
        struct hdaudio_softc *sc = co->co_host;
        struct hdaudio_function_group *fg;
        uint32_t vid, snc, fgrp;
        int starting_node, num_nodes, nid;

        if (co->co_valid == false)
                return;

        vid = hdaudio_command(co, 0, CORB_GET_PARAMETER, COP_VENDOR_ID);
        snc = hdaudio_command(co, 0, CORB_GET_PARAMETER,
            COP_SUBORDINATE_NODE_COUNT);

        /* make sure the vendor and product IDs are valid */
        if (vid == 0xffffffff || vid == 0x00000000)
                return;

#ifdef HDAUDIO_DEBUG
        uint32_t rid = hdaudio_command(co, 0, CORB_GET_PARAMETER,
            COP_REVISION_ID);
        hda_print(sc, "Codec%02X: %04X:%04X HDA %d.%d rev %d stepping %d\n",
            co->co_addr, vid >> 16, vid & 0xffff,
            (rid >> 20) & 0xf, (rid >> 16) & 0xf,
            (rid >> 8) & 0xff, rid & 0xff);
#endif
        starting_node = (snc >> 16) & 0xff;
        num_nodes = snc & 0xff;

        /*
         * If the total number of nodes is 0, there's nothing we can do.
         * This shouldn't happen, so complain about it.
         */
        if (num_nodes == 0) {
                hda_error(sc, "Codec%02X: No subordinate nodes found (%08x)\n",
                    co->co_addr, snc);
                return;
        }

        co->co_nfg = num_nodes;
        co->co_fg = kmem_zalloc(co->co_nfg * sizeof(*co->co_fg), KM_SLEEP);

        for (nid = starting_node; nid < starting_node + num_nodes; nid++) {
                fg = &co->co_fg[nid - starting_node];
                fg->fg_codec = co;
                fg->fg_nid = nid;
                fg->fg_vendor = vid >> 16;
                fg->fg_product = vid & 0xffff;

                fgrp = hdaudio_command(co, nid, CORB_GET_PARAMETER,
                    COP_FUNCTION_GROUP_TYPE);
                switch (fgrp & 0xff) {
                case 0x01:      /* Audio Function Group */
                        fg->fg_type = HDAUDIO_GROUP_TYPE_AFG;
                        break;
                case 0x02:      /* Vendor Specific Modem Function Group */
                        fg->fg_type = HDAUDIO_GROUP_TYPE_VSM_FG;
                        break;
                default:
                        /* Function group type not supported */
                        fg->fg_type = HDAUDIO_GROUP_TYPE_UNKNOWN;
                        break;
                }
                hdaudio_attach_fg(fg, NULL);
        }
}

int
hdaudio_stream_tag(struct hdaudio_stream *st)
{
        int ret = 0;

        switch (st->st_type) {
        case HDAUDIO_STREAM_ISS:
                ret = 1;
                break;
        case HDAUDIO_STREAM_OSS:
                ret = 2;
                break;
        case HDAUDIO_STREAM_BSS:
                ret = 3;
                break;
        }

        return ret;
}

int
hdaudio_attach(device_t dev, struct hdaudio_softc *sc)
{
        int err, i;

        KASSERT(sc->sc_memvalid == true);

        sc->sc_dev = dev;
        mutex_init(&sc->sc_corb_mtx, MUTEX_DEFAULT, IPL_AUDIO);
        mutex_init(&sc->sc_stream_mtx, MUTEX_DEFAULT, IPL_AUDIO);

        /*
         * Put the controller into a known state by entering and leaving
         * CRST as necessary.
         */
        if ((err = hdaudio_reset(sc)) != 0)
                goto fail;

        /*
         * From the spec:
         *
         * Must wait 250us after reading CRST as a 1 before assuming that
         * codecs have all made status change requests and have been
         * registered by the controller.
         *
         * In reality, we need to wait longer than this.
         */
        hda_delay(HDAUDIO_CODEC_DELAY);

        /*
         * Read device capabilities
         */
        hdaudio_init(sc);

        /*
         * Detect codecs
         */
        if (hdaudio_codec_probe(sc) == 0) {
                hda_error(sc, "no codecs found\n");
                err = ENODEV;
                goto fail;
        }

        /*
         * Ensure that the device is in a known state
         */
        hda_write2(sc, HDAUDIO_MMIO_STATESTS, HDAUDIO_STATESTS_SDIWAKE);
        hda_write1(sc, HDAUDIO_MMIO_RIRBSTS,
            HDAUDIO_RIRBSTS_RIRBOIS | HDAUDIO_RIRBSTS_RINTFL);
        hda_write4(sc, HDAUDIO_MMIO_INTSTS,
            hda_read4(sc, HDAUDIO_MMIO_INTSTS));
        hda_write4(sc, HDAUDIO_MMIO_DPLBASE, 0);
        hda_write4(sc, HDAUDIO_MMIO_DPUBASE, 0);

        /*
         * Initialize the CORB. First negotiate a command buffer size,
         * then allocate and configure it.
         */
        if ((err = hdaudio_corb_setsize(sc)) != 0)
                goto fail;
        if ((err = hdaudio_dma_alloc(sc, &sc->sc_corb, BUS_DMA_WRITE)) != 0)
                goto fail;
        if ((err = hdaudio_corb_config(sc)) != 0)
                goto fail;

        /*
         * Initialize the RIRB.
         */
        if ((err = hdaudio_rirb_setsize(sc)) != 0)
                goto fail;
        if ((err = hdaudio_dma_alloc(sc, &sc->sc_rirb, BUS_DMA_READ)) != 0)
                goto fail;
        if ((err = hdaudio_rirb_config(sc)) != 0)
                goto fail;

        /*
         * Start the CORB and RIRB
         */
        if ((err = hdaudio_corb_start(sc)) != 0)
                goto fail;
        if ((err = hdaudio_rirb_start(sc)) != 0)
                goto fail;

        /*
         * Identify and attach discovered codecs
         */
        for (i = 0; i < HDAUDIO_MAX_CODECS; i++)
                hdaudio_codec_attach(&sc->sc_codec[i]);

        /*
         * Enable interrupts
         */
        hdaudio_intr_enable(sc);

fail:
        if (err)
                hda_error(sc, "device driver failed to attach\n");
        return err;
}

int
hdaudio_detach(struct hdaudio_softc *sc, int flags)
{
        int error;

        /* Disable interrupts */
        hdaudio_intr_disable(sc);

        error = config_detach_children(sc->sc_dev, flags);
        if (error != 0) {
                hdaudio_intr_enable(sc);
                return error;
        }

        mutex_destroy(&sc->sc_corb_mtx);
        mutex_destroy(&sc->sc_stream_mtx);

        hdaudio_dma_free(sc, &sc->sc_corb);
        hdaudio_dma_free(sc, &sc->sc_rirb);

        return 0;
}

bool
hdaudio_resume(struct hdaudio_softc *sc)
{
        if (hdaudio_reset(sc) != 0)
                return false;

        hda_delay(HDAUDIO_CODEC_DELAY);

        /*
         * Ensure that the device is in a known state
         */
        hda_write2(sc, HDAUDIO_MMIO_STATESTS, HDAUDIO_STATESTS_SDIWAKE);
        hda_write1(sc, HDAUDIO_MMIO_RIRBSTS,
            HDAUDIO_RIRBSTS_RIRBOIS | HDAUDIO_RIRBSTS_RINTFL);
        hda_write4(sc, HDAUDIO_MMIO_INTSTS,
            hda_read4(sc, HDAUDIO_MMIO_INTSTS));
        hda_write4(sc, HDAUDIO_MMIO_DPLBASE, 0);
        hda_write4(sc, HDAUDIO_MMIO_DPUBASE, 0);

        if (hdaudio_corb_config(sc) != 0)
                return false;
        if (hdaudio_rirb_config(sc) != 0)
                return false;
        if (hdaudio_corb_start(sc) != 0)
                return false;
        if (hdaudio_rirb_start(sc) != 0)
                return false;

        hdaudio_intr_enable(sc);

        return true;
}

int
hdaudio_rescan(struct hdaudio_softc *sc, const char *ifattr, const int *locs)
{
        struct hdaudio_codec *co;
        struct hdaudio_function_group *fg;
        unsigned int codec;

        for (codec = 0; codec < HDAUDIO_MAX_CODECS; codec++) {
                co = &sc->sc_codec[codec];
                fg = co->co_fg;
                if (!co->co_valid || fg == NULL)
                        continue;
                if (fg->fg_device)
                        continue;
                hdaudio_attach_fg(fg, NULL);
        }

        return 0;
}

void
hdaudio_childdet(struct hdaudio_softc *sc, device_t child)
{
        struct hdaudio_codec *co;
        struct hdaudio_function_group *fg;
        unsigned int codec;

        for (codec = 0; codec < HDAUDIO_MAX_CODECS; codec++) {
                co = &sc->sc_codec[codec];
                fg = co->co_fg;
                if (!co->co_valid || fg == NULL)
                        continue;
                if (fg->fg_device == child)
                        fg->fg_device = NULL;
        }
}

int
hdaudio_intr(struct hdaudio_softc *sc)
{
        struct hdaudio_stream *st;
        uint32_t intsts, stream_mask;
        int streamid = 0;
        uint8_t rirbsts;

        intsts = hda_read4(sc, HDAUDIO_MMIO_INTSTS);
        if (!(intsts & HDAUDIO_INTSTS_GIS))
                return 0;

        if (intsts & HDAUDIO_INTSTS_CIS) {
                rirbsts = hda_read1(sc, HDAUDIO_MMIO_RIRBSTS);
                if (rirbsts & HDAUDIO_RIRBSTS_RINTFL) {
                        mutex_enter(&sc->sc_corb_mtx);
                        hdaudio_rirb_dequeue(sc, true);
                        mutex_exit(&sc->sc_corb_mtx);
                }
                if (rirbsts & (HDAUDIO_RIRBSTS_RIRBOIS|HDAUDIO_RIRBSTS_RINTFL))
                        hda_write1(sc, HDAUDIO_MMIO_RIRBSTS, rirbsts);
                hda_write4(sc, HDAUDIO_MMIO_INTSTS, HDAUDIO_INTSTS_CIS);
        }
        if (intsts & HDAUDIO_INTSTS_SIS_MASK) {
                mutex_enter(&sc->sc_stream_mtx);
                stream_mask = intsts & sc->sc_stream_mask;
                while (streamid < HDAUDIO_MAX_STREAMS && stream_mask != 0) {
                        st = &sc->sc_stream[streamid++];
                        if ((stream_mask & 1) != 0 && st->st_intr) {
                                st->st_intr(st);
                        }
                        stream_mask >>= 1;
                }
                mutex_exit(&sc->sc_stream_mtx);
                hda_write4(sc, HDAUDIO_MMIO_INTSTS, HDAUDIO_INTSTS_SIS_MASK);
        }

        return 1;
}

struct hdaudio_stream *
hdaudio_stream_establish(struct hdaudio_softc *sc,
    enum hdaudio_stream_type type, int (*intr)(struct hdaudio_stream *),
    void *cookie)
{
        struct hdaudio_stream *st;
        struct hdaudio_dma dma;
        int i, err;

        dma.dma_size = sizeof(struct hdaudio_bdl_entry) * HDAUDIO_BDL_MAX;
        dma.dma_sizereg = 0;
        err = hdaudio_dma_alloc(sc, &dma, BUS_DMA_COHERENT | BUS_DMA_NOCACHE);
        if (err)
                return NULL;

        mutex_enter(&sc->sc_stream_mtx);
        for (i = 0; i < HDAUDIO_MAX_STREAMS; i++) {
                st = &sc->sc_stream[i];
                if (st->st_enable == false)
                        break;
                if (st->st_type != type)
                        continue;
                if (sc->sc_stream_mask & (1 << i))
                        continue;

                /* Allocate stream */
                st->st_bdl = dma;
                st->st_intr = intr;
                st->st_cookie = cookie;
                sc->sc_stream_mask |= (1 << i);
                mutex_exit(&sc->sc_stream_mtx);
                return st;
        }
        mutex_exit(&sc->sc_stream_mtx);

        /* No streams of requested type available */
        hdaudio_dma_free(sc, &dma);
        return NULL;
}

void
hdaudio_stream_disestablish(struct hdaudio_stream *st)
{
        struct hdaudio_softc *sc = st->st_host;
        struct hdaudio_dma dma;

        KASSERT(sc->sc_stream_mask & (1 << st->st_shift));

        mutex_enter(&sc->sc_stream_mtx);
        sc->sc_stream_mask &= ~(1 << st->st_shift);
        st->st_intr = NULL;
        st->st_cookie = NULL;
        dma = st->st_bdl;
        st->st_bdl.dma_valid = false;
        mutex_exit(&sc->sc_stream_mtx);

        /* Can't bus_dmamem_unmap while holding a mutex.  */
        hdaudio_dma_free(sc, &dma);
}

/*
 * Convert most of audio_params_t to stream fmt descriptor; noticeably missing
 * is the # channels bits, as this is encoded differently in codec and
 * stream descriptors.
 *
 * TODO: validate that the stream and selected codecs can handle the fmt
 */
uint16_t
hdaudio_stream_param(struct hdaudio_stream *st, const audio_params_t *param)
{
        uint16_t fmt = 0;

        switch (param->encoding) {
        case AUDIO_ENCODING_AC3:
                fmt |= HDAUDIO_FMT_TYPE_NONPCM;
                break;
        default:
                fmt |= HDAUDIO_FMT_TYPE_PCM;
                break;
        }

        switch (param->sample_rate) {
        case 8000:
                fmt |= HDAUDIO_FMT_BASE_48 | HDAUDIO_FMT_MULT(1) |
                    HDAUDIO_FMT_DIV(6);
                break;
        case 11025:
                fmt |= HDAUDIO_FMT_BASE_44 | HDAUDIO_FMT_MULT(1) |
                    HDAUDIO_FMT_DIV(4);
                break;
        case 16000:
                fmt |= HDAUDIO_FMT_BASE_48 | HDAUDIO_FMT_MULT(1) |
                    HDAUDIO_FMT_DIV(3);
                break;
        case 22050:
                fmt |= HDAUDIO_FMT_BASE_44 | HDAUDIO_FMT_MULT(1) |
                    HDAUDIO_FMT_DIV(2);
                break;
        case 32000:
                fmt |= HDAUDIO_FMT_BASE_48 | HDAUDIO_FMT_MULT(2) |
                    HDAUDIO_FMT_DIV(3);
                break;
        case 44100:
                fmt |= HDAUDIO_FMT_BASE_44 | HDAUDIO_FMT_MULT(1);
                break;
        case 48000:
                fmt |= HDAUDIO_FMT_BASE_48 | HDAUDIO_FMT_MULT(1);
                break;
        case 88200:
                fmt |= HDAUDIO_FMT_BASE_44 | HDAUDIO_FMT_MULT(2);
                break;
        case 96000:
                fmt |= HDAUDIO_FMT_BASE_48 | HDAUDIO_FMT_MULT(2);
                break;
        case 176400:
                fmt |= HDAUDIO_FMT_BASE_44 | HDAUDIO_FMT_MULT(4);
                break;
        case 192000:
                fmt |= HDAUDIO_FMT_BASE_48 | HDAUDIO_FMT_MULT(4);
                break;
        default:
                return 0;
        }

        if (param->precision == 16 && param->validbits == 8)
                fmt |= HDAUDIO_FMT_BITS_8_16;
        else if (param->precision == 16 && param->validbits == 16)
                fmt |= HDAUDIO_FMT_BITS_16_16;
        else if (param->precision == 32 && param->validbits == 20)
                fmt |= HDAUDIO_FMT_BITS_20_32;
        else if (param->precision == 32 && param->validbits == 24)
                fmt |= HDAUDIO_FMT_BITS_24_32;
        else if (param->precision == 32 && param->validbits == 32)
                fmt |= HDAUDIO_FMT_BITS_32_32;
        else
                return 0;

        return fmt;
}

void
hdaudio_stream_reset(struct hdaudio_stream *st)
{
        struct hdaudio_softc *sc = st->st_host;
        int snum = st->st_shift;
        int retry;
        uint8_t ctl0;

        ctl0 = hda_read1(sc, HDAUDIO_SD_CTL0(snum));
        ctl0 |= HDAUDIO_CTL_SRST;
        hda_write1(sc, HDAUDIO_SD_CTL0(snum), ctl0);

        retry = HDAUDIO_RESET_TIMEOUT;
        do {
                ctl0 = hda_read1(sc, HDAUDIO_SD_CTL0(snum));
                if (ctl0 & HDAUDIO_CTL_SRST)
                        break;
                hda_delay(10);
        } while (--retry > 0);

        ctl0 &= ~HDAUDIO_CTL_SRST;
        hda_write1(sc, HDAUDIO_SD_CTL0(snum), ctl0);

        retry = HDAUDIO_RESET_TIMEOUT;
        do {
                ctl0 = hda_read1(sc, HDAUDIO_SD_CTL0(snum));
                if (!(ctl0 & HDAUDIO_CTL_SRST))
                        break;
                hda_delay(10);
        } while (--retry > 0);
        if (retry == 0) {
                hda_error(sc, "timeout leaving stream reset state\n");
                return;
        }
}

void
hdaudio_stream_start(struct hdaudio_stream *st, int blksize,
    bus_size_t dmasize, const audio_params_t *params)
{
        struct hdaudio_softc *sc = st->st_host;
        struct hdaudio_bdl_entry *bdl;
        uint64_t dmaaddr;
        uint32_t intctl;
        uint16_t fmt;
        uint8_t ctl0, ctl2;
        int cnt, snum = st->st_shift;

        KASSERT(sc->sc_stream_mask & (1 << st->st_shift));
        KASSERT(st->st_data.dma_valid == true);
        KASSERT(st->st_bdl.dma_valid == true);

        hdaudio_stream_stop(st);
        hdaudio_stream_reset(st);

        /*
         * Configure buffer descriptor list
         */
        dmaaddr = DMA_DMAADDR(&st->st_data);
        bdl = DMA_KERNADDR(&st->st_bdl);
        for (cnt = 0; cnt < HDAUDIO_BDL_MAX; cnt++) {
                bdl[cnt].address_lo = (uint32_t)dmaaddr;
                bdl[cnt].address_hi = dmaaddr >> 32;
                bdl[cnt].length = blksize;
                bdl[cnt].flags = HDAUDIO_BDL_ENTRY_IOC;
                dmaaddr += blksize;
                if (dmaaddr >= DMA_DMAADDR(&st->st_data) + dmasize) {
                        cnt++;
                        break;
                }
        }

        /*
         * Program buffer descriptor list
         */
        dmaaddr = DMA_DMAADDR(&st->st_bdl);
        hda_write4(sc, HDAUDIO_SD_BDPL(snum), (uint32_t)dmaaddr);
        hda_write4(sc, HDAUDIO_SD_BDPU(snum), (uint32_t)(dmaaddr >> 32));
        hda_write2(sc, HDAUDIO_SD_LVI(snum), (cnt - 1) & 0xff);

        /*
         * Program cyclic buffer length
         */
        hda_write4(sc, HDAUDIO_SD_CBL(snum), dmasize);

        /*
         * Program stream number (tag). Although controller hardware is
         * capable of transmitting any stream number (0-15), by convention
         * stream 0 is reserved as unused by software, so that converters
         * whose stream numbers have been reset to 0 do not unintentionally
         * decode data not intended for them.
         */
        ctl2 = hda_read1(sc, HDAUDIO_SD_CTL2(snum));
        ctl2 &= ~0xf0;
        ctl2 |= hdaudio_stream_tag(st) << 4;
        hda_write1(sc, HDAUDIO_SD_CTL2(snum), ctl2);

        /*
         * Program stream format
         */
        fmt = hdaudio_stream_param(st, params) |
            HDAUDIO_FMT_CHAN(params->channels);
        hda_write2(sc, HDAUDIO_SD_FMT(snum), fmt);

        /*
         * Switch on interrupts for this stream
         */
        intctl = hda_read4(sc, HDAUDIO_MMIO_INTCTL);
        intctl |= (1 << st->st_shift);
        hda_write4(sc, HDAUDIO_MMIO_INTCTL, intctl);

        /*
         * Start running the stream
         */
        ctl0 = hda_read1(sc, HDAUDIO_SD_CTL0(snum));
        ctl0 |= HDAUDIO_CTL_DEIE | HDAUDIO_CTL_FEIE | HDAUDIO_CTL_IOCE |
            HDAUDIO_CTL_RUN;
        hda_write1(sc, HDAUDIO_SD_CTL0(snum), ctl0);
}

void
hdaudio_stream_stop(struct hdaudio_stream *st)
{
        struct hdaudio_softc *sc = st->st_host;
        uint32_t intctl;
        uint8_t ctl0;
        int snum = st->st_shift;

        /*
         * Stop running the stream
         */
        ctl0 = hda_read1(sc, HDAUDIO_SD_CTL0(snum));
        ctl0 &= ~(HDAUDIO_CTL_DEIE | HDAUDIO_CTL_FEIE | HDAUDIO_CTL_IOCE |
            HDAUDIO_CTL_RUN);
        hda_write1(sc, HDAUDIO_SD_CTL0(snum), ctl0);

        /*
         * Switch off interrupts for this stream
         */
        intctl = hda_read4(sc, HDAUDIO_MMIO_INTCTL);
        intctl &= ~(1 << st->st_shift);
        hda_write4(sc, HDAUDIO_MMIO_INTCTL, intctl);
}

/*
 * /dev/hdaudioN interface
 */

static const char *
hdaudioioctl_fgrp_to_cstr(enum function_group_type type)
{
        switch (type) {
        case HDAUDIO_GROUP_TYPE_AFG:
                return "afg";
        case HDAUDIO_GROUP_TYPE_VSM_FG:
                return "vsmfg";
        default:
                return "unknown";
        }
}

static struct hdaudio_function_group *
hdaudioioctl_fgrp_lookup(struct hdaudio_softc *sc, int codecid, int nid)
{
        struct hdaudio_codec *co;
        struct hdaudio_function_group *fg = NULL;
        int i;

        if (codecid < 0 || codecid >= HDAUDIO_MAX_CODECS)
                return NULL;
        co = &sc->sc_codec[codecid];
        if (co->co_valid == false)
                return NULL;

        for (i = 0; i < co->co_nfg; i++)
                if (co->co_fg[i].fg_nid == nid) {
                        fg = &co->co_fg[i];
                        break;
                }

        return fg;
}

static int
hdaudioioctl_fgrp_info(struct hdaudio_softc *sc, prop_dictionary_t request,
    prop_dictionary_t response)
{
        struct hdaudio_codec *co;
        struct hdaudio_function_group *fg;
        prop_array_t array;
        prop_dictionary_t dict;
        int codecid, fgid;

        array = prop_array_create();
        if (array == NULL)
                return ENOMEM;

        for (codecid = 0; codecid < HDAUDIO_MAX_CODECS; codecid++) {
                co = &sc->sc_codec[codecid];
                if (co->co_valid == false)
                        continue;
                for (fgid = 0; fgid < co->co_nfg; fgid++) {
                        fg = &co->co_fg[fgid];
                        dict = prop_dictionary_create();
                        if (dict == NULL)
                                return ENOMEM;
                        prop_dictionary_set_string_nocopy(dict,
                            "type", hdaudioioctl_fgrp_to_cstr(fg->fg_type));
                        prop_dictionary_set_int16(dict, "nid", fg->fg_nid);
                        prop_dictionary_set_int16(dict, "codecid", codecid);
                        prop_dictionary_set_uint16(dict, "vendor-id",
                            fg->fg_vendor);
                        prop_dictionary_set_uint16(dict, "product-id",
                            fg->fg_product);
                        prop_dictionary_set_uint32(dict, "subsystem-id",
                            sc->sc_subsystem);
                        if (fg->fg_device)
                                prop_dictionary_set_string(dict, "device",
                                    device_xname(fg->fg_device));
                        else
                                prop_dictionary_set_string_nocopy(dict,
                                    "device", "<none>");
                        prop_array_add(array, dict);
                }
        }

        prop_dictionary_set(response, "function-group-info", array);
        return 0;
}

static int
hdaudioioctl_fgrp_getconfig(struct hdaudio_softc *sc,
    prop_dictionary_t request, prop_dictionary_t response)
{
        struct hdaudio_function_group *fg;
        prop_dictionary_t dict;
        prop_array_t array;
        uint32_t nodecnt, wcap, config;
        int16_t codecid, nid, i;
        int startnode, endnode;

        if (!prop_dictionary_get_int16(request, "codecid", &codecid) ||
            !prop_dictionary_get_int16(request, "nid", &nid))
                return EINVAL;

        fg = hdaudioioctl_fgrp_lookup(sc, codecid, nid);
        if (fg == NULL)
                return ENODEV;

        array = prop_array_create();
        if (array == NULL)
                return ENOMEM;

        nodecnt = hdaudio_command(fg->fg_codec, fg->fg_nid,
            CORB_GET_PARAMETER, COP_SUBORDINATE_NODE_COUNT);
        startnode = COP_NODECNT_STARTNODE(nodecnt);
        endnode = startnode + COP_NODECNT_NUMNODES(nodecnt);

        for (i = startnode; i < endnode; i++) {
                wcap = hdaudio_command(fg->fg_codec, i,
                    CORB_GET_PARAMETER, COP_AUDIO_WIDGET_CAPABILITIES);
                if (COP_AWCAP_TYPE(wcap) != COP_AWCAP_TYPE_PIN_COMPLEX)
                        continue;
                config = hdaudio_command(fg->fg_codec, i,
                    CORB_GET_CONFIGURATION_DEFAULT, 0);
                dict = prop_dictionary_create();
                if (dict == NULL)
                        return ENOMEM;
                prop_dictionary_set_int16(dict, "nid", i);
                prop_dictionary_set_uint32(dict, "config", config);
                prop_array_add(array, dict);
        }

        prop_dictionary_set(response, "pin-config", array);

        return 0;
}

static int
hdaudioioctl_fgrp_setconfig(struct hdaudio_softc *sc,
    prop_dictionary_t request, prop_dictionary_t response)
{
        struct hdaudio_function_group *fg;
        prop_array_t config;
        int16_t codecid, nid;
        int err;

        if (!prop_dictionary_get_int16(request, "codecid", &codecid) ||
            !prop_dictionary_get_int16(request, "nid", &nid))
                return EINVAL;

        fg = hdaudioioctl_fgrp_lookup(sc, codecid, nid);
        if (fg == NULL)
                return ENODEV;

        if (fg->fg_device) {
                err = config_detach(fg->fg_device, 0);
                if (err)
                        return err;
                fg->fg_device = NULL;
        }

        /* "pin-config" may be NULL, this means "use BIOS configuration" */
        config = prop_dictionary_get(request, "pin-config");
        if (config && prop_object_type(config) != PROP_TYPE_ARRAY) {
                prop_object_release(config);
                return EINVAL;
        }
        hdaudio_attach_fg(fg, config);
        if (config)
                prop_object_release(config);

        return 0;
}

static int
hdaudio_dispatch_fgrp_ioctl(struct hdaudio_softc *sc, u_long cmd,
    prop_dictionary_t request, prop_dictionary_t response)
{
        struct hdaudio_function_group *fg;
        int (*infocb)(void *, prop_dictionary_t, prop_dictionary_t);
        prop_dictionary_t fgrp_dict;
        uint64_t info_fn;
        int16_t codecid, nid;
        void *fgrp_sc; 
        bool rv;
        int err;

        if (!prop_dictionary_get_int16(request, "codecid", &codecid) ||
            !prop_dictionary_get_int16(request, "nid", &nid))
                return EINVAL;

        fg = hdaudioioctl_fgrp_lookup(sc, codecid, nid);
        if (fg == NULL)
                return ENODEV;
        if (fg->fg_device == NULL)
                return ENXIO;
        fgrp_sc = device_private(fg->fg_device);
        fgrp_dict = device_properties(fg->fg_device);

        switch (fg->fg_type) {
        case HDAUDIO_GROUP_TYPE_AFG:
                switch (cmd) {
                case HDAUDIO_FGRP_CODEC_INFO:
                        rv = prop_dictionary_get_uint64(fgrp_dict,
                            "codecinfo-callback", &info_fn);
                        if (!rv)
                                return ENXIO;
                        infocb = (void *)(uintptr_t)info_fn;
                        err = infocb(fgrp_sc, request, response);
                        break;
                case HDAUDIO_FGRP_WIDGET_INFO:
                        rv = prop_dictionary_get_uint64(fgrp_dict,
                            "widgetinfo-callback", &info_fn);
                        if (!rv)
                                return ENXIO;
                        infocb = (void *)(uintptr_t)info_fn;
                        err = infocb(fgrp_sc, request, response);
                        break;
                default:
                        err = EINVAL;
                        break;
                }
                break;

        default:
                err = EINVAL;
                break;
        }
        return err;
}

int
hdaudioopen(dev_t dev, int flag, int mode, struct lwp *l)
{
        device_t self;

        self = device_lookup(&hdaudio_cd, HDAUDIOUNIT(dev));
        if (self == NULL)
                return ENXIO;

        return 0;
}

int
hdaudioclose(dev_t dev, int flag, int mode, struct lwp *l)
{
        return 0;
}

int
hdaudioioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
{
        struct hdaudio_softc *sc;
        struct plistref *pref = addr;
        prop_dictionary_t request, response;
        int err;

        sc = device_lookup_private(&hdaudio_cd, HDAUDIOUNIT(dev));
        if (sc == NULL)
                return ENXIO;

        response = prop_dictionary_create();
        if (response == NULL)
                return ENOMEM;

        err = prop_dictionary_copyin_ioctl(pref, cmd, &request);
        if (err) {
                prop_object_release(response);
                return err;
        }

        switch (cmd) {
        case HDAUDIO_FGRP_INFO:
                err = hdaudioioctl_fgrp_info(sc, request, response);
                break;
        case HDAUDIO_FGRP_GETCONFIG:
                err = hdaudioioctl_fgrp_getconfig(sc, request, response);
                break;
        case HDAUDIO_FGRP_SETCONFIG:
                err = hdaudioioctl_fgrp_setconfig(sc, request, response);
                break;
        case HDAUDIO_FGRP_CODEC_INFO:
        case HDAUDIO_FGRP_WIDGET_INFO:
                err = hdaudio_dispatch_fgrp_ioctl(sc, cmd, request, response);
                break;
        default:
                err = EINVAL;
                break;
        }

        if (!err)
                err = prop_dictionary_copyout_ioctl(pref, cmd, response);

        if (response)
                prop_object_release(response);
        prop_object_release(request);
        return err;
}

MODULE(MODULE_CLASS_DRIVER, hdaudio, "audio");
#ifdef _MODULE
static const struct cfiattrdata hdaudiobuscf_iattrdata = {
        "hdaudiobus", 1, {
                { "nid", "-1", -1 },
        }
};
static const struct cfiattrdata * const hdaudio_attrs[] = {
        &hdaudiobuscf_iattrdata, NULL
};
CFDRIVER_DECL(hdaudio, DV_AUDIODEV, hdaudio_attrs);
#endif

static int
hdaudio_modcmd(modcmd_t cmd, void *opaque)
{
        int error = 0;
#ifdef _MODULE
        int bmaj = -1, cmaj = -1;
#endif

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                error = devsw_attach("hdaudio", NULL, &bmaj,
                    &hdaudio_cdevsw, &cmaj);
                if (error)
                        break;
                error = config_cfdriver_attach(&hdaudio_cd);
                if (error)
                        devsw_detach(NULL, &hdaudio_cdevsw);
#endif
                break;
        case MODULE_CMD_FINI:
#ifdef _MODULE
                error = config_cfdriver_detach(&hdaudio_cd);
                if (error)
                        break;
                devsw_detach(NULL, &hdaudio_cdevsw);
#endif
                break;
        default:
                error = ENOTTY;
                break;
        }
        return error;
}

DEV_VERBOSE_DEFINE(hdaudio);