/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2016 Garrett D'Amore <garrett@damore.org>
 */
/*
 * Purpose: Creative/Ensoniq AudioPCI97  driver (ES1371/ES1373)
 *
 * This driver is used with the original Ensoniq AudioPCI97 card and many
 * PCI based Sound Blaster cards by Creative Technologies. For example
 * Sound Blaster PCI128 and Creative/Ectiva EV1938.
 */

/*
 * This file is part of Open Sound System
 *
 * Copyright (C) 4Front Technologies 1996-2008.
 *
 * This software is released under CDDL 1.0 source license.
 * See the COPYING file included in the main directory of this source
 * distribution for the license terms and conditions.
 */

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

/*
 * For VMWare platforms, we have to utilize the (emulated) hardware interrupts
 * of the device.  This is necessary for audio playback to function, as
 * the toggling of the interrupt bits apparently triggers logic inside the
 * emulated device.  So we need to detect this platform, and conditionally
 * wire up the interrupt handler.
 */
#ifdef __x86
#include <sys/x86_archext.h>
#endif

#include "audioens.h"

/*
 * Set the latency to 32, 64, 96, 128 clocks - some APCI97 devices exhibit
 * garbled audio in some cases and setting the latency to higer values fixes it
 * Values: 32, 64, 96, 128 - Default: 64 (or defined by bios)
 */
int audioens_latency = 0;

/*
 * Enable SPDIF port on SoundBlaster 128D or Sound Blaster Digital-4.1 models
 * Values: 1=Enable 0=Disable Default: 0
 */
int audioens_spdif = 0;

/*
 * Note: Latest devices can support SPDIF with AC3 pass thru.
 * However, in order to do this, one of the two DMA engines must be
 * dedicated to this, which would prevent the card from supporting 4
 * channel audio.  For now we don't bother with the AC3 pass through
 * mode, and instead just focus on 4 channel support.  In the future,
 * this could be selectable via a property.
 */

#define ENSONIQ_VENDOR_ID       0x1274
#define CREATIVE_VENDOR_ID      0x1102
#define ECTIVA_VENDOR_ID        0x1102
#define ENSONIQ_ES1371          0x1371
#define ENSONIQ_ES5880          0x8001
#define ENSONIQ_ES5880A         0x8002
#define ENSONIQ_ES5880B         0x5880
#define ECTIVA_ES1938           0x8938

#define DEFRATE                 48000
#define DRVNAME                 "audioens"

typedef struct audioens_port
{
        /* Audio parameters */
        int                     speed;

        int                     num;
#define PORT_DAC                0
#define PORT_ADC                1
#define PORT_MAX                PORT_ADC

        caddr_t                 kaddr;
        uint32_t                paddr;
        ddi_acc_handle_t        acch;
        ddi_dma_handle_t        dmah;
        int                     nchan;
        unsigned                nframes;
        unsigned                iframes;
        unsigned                frameno;
        uint64_t                count;

        struct audioens_dev     *dev;
        audio_engine_t          *engine;
} audioens_port_t;

typedef struct audioens_dev
{
        audio_dev_t             *osdev;
        kmutex_t                mutex;
        uint16_t                devid;
        uint8_t                 revision;
        dev_info_t              *dip;

        audioens_port_t         port[PORT_MAX + 1];

        ac97_t                  *ac97;

        caddr_t                 regs;
        ddi_acc_handle_t        acch;

        boolean_t               suspended;

#ifdef __x86
        boolean_t               useintr;
        ddi_intr_handle_t       intrh;
        uint_t                  intrpri;
#endif
} audioens_dev_t;

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

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

static ddi_dma_attr_t dma_attr = {
        DMA_ATTR_VERSION,       /* dma_attr_version */
        0x0,                    /* dma_attr_addr_lo */
        0xffffffffU,            /* dma_attr_addr_hi */
        0x3ffff,                /* dma_attr_count_max */
        0x8,                    /* dma_attr_align */
        0x7f,                   /* dma_attr_burstsizes */
        0x1,                    /* dma_attr_minxfer */
        0x3ffff,                /* dma_attr_maxxfer */
        0x3ffff,                /* dma_attr_seg */
        0x1,                    /* dma_attr_sgllen */
        0x1,                    /* dma_attr_granular */
        0                       /* dma_attr_flags */
};

#define GET8(dev, offset)       \
        ddi_get8(dev->acch, (uint8_t *)(dev->regs + (offset)))
#define GET16(dev, offset)      \
        ddi_get16(dev->acch, (uint16_t *)(void *)(dev->regs + (offset)))
#define GET32(dev, offset)      \
        ddi_get32(dev->acch, (uint32_t *)(void *)(dev->regs + (offset)))
#define PUT8(dev, offset, v)    \
        ddi_put8(dev->acch, (uint8_t *)(dev->regs + (offset)), v)
#define PUT16(dev, offset, v)   \
        ddi_put16(dev->acch, (uint16_t *)(void *)(dev->regs + (offset)), v)
#define PUT32(dev, offset, v)   \
        ddi_put32(dev->acch, (uint32_t *)(void *)(dev->regs + (offset)), v)

#define CLR8(dev, offset, v)    PUT8(dev, offset, GET8(dev, offset) & ~(v))
#define SET8(dev, offset, v)    PUT8(dev, offset, GET8(dev, offset) | (v))
#define CLR32(dev, offset, v)   PUT32(dev, offset, GET32(dev, offset) & ~(v))
#define SET32(dev, offset, v)   PUT32(dev, offset, GET32(dev, offset) | (v))

static void audioens_init_hw(audioens_dev_t *);

static uint16_t
audioens_rd97(void *dev_, uint8_t wAddr)
{
        audioens_dev_t *dev = dev_;
        int i, dtemp;

        mutex_enter(&dev->mutex);
        dtemp = GET32(dev, CONC_dCODECCTL_OFF);
        /* wait for WIP to go away saving the current state for later */
        for (i = 0; i < 0x100UL; ++i) {
                dtemp = GET32(dev, CONC_dCODECCTL_OFF);
                if ((dtemp & (1UL << 30)) == 0)
                        break;
        }

        /* write addr w/data=0 and assert read request ... */
        PUT32(dev, CONC_dCODECCTL_OFF, ((int)wAddr << 16) | (1UL << 23));

        /* now wait for the data (RDY) */
        for (i = 0; i < 0x100UL; ++i) {
                dtemp = GET32(dev, CONC_dCODECCTL_OFF);
                if (dtemp & (1UL << 31))
                        break;
        }
        dtemp = GET32(dev, CONC_dCODECCTL_OFF);
        mutex_exit(&dev->mutex);

        return (dtemp & 0xffff);
}

static void
audioens_wr97(void *dev_, uint8_t wAddr, uint16_t wData)
{
        audioens_dev_t *dev = dev_;
        int i, dtemp;

        mutex_enter(&dev->mutex);
        /* wait for WIP to go away */
        for (i = 0; i < 0x100UL; ++i) {
                dtemp = GET32(dev, CONC_dCODECCTL_OFF);
                if ((dtemp & (1UL << 30)) == 0)
                        break;
        }

        PUT32(dev, CONC_dCODECCTL_OFF, ((int)wAddr << 16) | wData);

        mutex_exit(&dev->mutex);
}

static unsigned short
SRCRegRead(audioens_dev_t *dev, unsigned short reg)
{
        int i, dtemp;

        dtemp = GET32(dev, CONC_dSRCIO_OFF);
        /* wait for ready */
        for (i = 0; i < SRC_IOPOLL_COUNT; ++i) {
                dtemp = GET32(dev, CONC_dSRCIO_OFF);
                if ((dtemp & SRC_BUSY) == 0)
                        break;
        }

        /* assert a read request */
        PUT32(dev, CONC_dSRCIO_OFF, (dtemp & SRC_CTLMASK) | ((int)reg << 25));

        /* now wait for the data */
        for (i = 0; i < SRC_IOPOLL_COUNT; ++i) {
                dtemp = GET32(dev, CONC_dSRCIO_OFF);
                if ((dtemp & SRC_BUSY) == 0)
                        break;
        }

        return ((unsigned short) dtemp);
}

static void
SRCRegWrite(audioens_dev_t *dev, unsigned short reg, unsigned short val)
{
        int i, dtemp;
        int writeval;

        dtemp = GET32(dev, CONC_dSRCIO_OFF);
        /* wait for ready */
        for (i = 0; i < SRC_IOPOLL_COUNT; ++i) {
                dtemp = GET32(dev, CONC_dSRCIO_OFF);
                if ((dtemp & SRC_BUSY) == 0)
                        break;
        }

        /* assert the write request */
        writeval = (dtemp & SRC_CTLMASK) | SRC_WENABLE |
            ((int)reg << 25) | val;
        PUT32(dev, CONC_dSRCIO_OFF, writeval);
}

static void
SRCSetRate(audioens_dev_t *dev, unsigned char base, unsigned short rate)
{
        int i, freq, dtemp;
        unsigned short N, truncM, truncStart;

        if (base != SRC_ADC_BASE) {
                /* freeze the channel */
                dtemp = (base == SRC_DAC1_BASE) ?
                    SRC_DAC1FREEZE : SRC_DAC2FREEZE;
                for (i = 0; i < SRC_IOPOLL_COUNT; ++i) {
                        if (!(GET32(dev, CONC_dSRCIO_OFF) & SRC_BUSY))
                                break;
                }
                PUT32(dev, CONC_dSRCIO_OFF,
                    (GET32(dev, CONC_dSRCIO_OFF) & SRC_CTLMASK) | dtemp);

                /* calculate new frequency and write it - preserve accum */
                freq = ((int)rate << 16) / 3000U;
                SRCRegWrite(dev, (unsigned short) base + SRC_INT_REGS_OFF,
                    (SRCRegRead(dev, (unsigned short) base + SRC_INT_REGS_OFF)
                    & 0x00ffU) | ((unsigned short) (freq >> 6) & 0xfc00));
                SRCRegWrite(dev, (unsigned short) base + SRC_VFREQ_FRAC_OFF,
                    (unsigned short) freq >> 1);

                /* un-freeze the channel */
                for (i = 0; i < SRC_IOPOLL_COUNT; ++i)
                        if (!(GET32(dev, CONC_dSRCIO_OFF) & SRC_BUSY))
                                break;
                PUT32(dev, CONC_dSRCIO_OFF,
                    (GET32(dev, CONC_dSRCIO_OFF) & SRC_CTLMASK) & ~dtemp);
        } else {
                /* derive oversample ratio */
                N = rate / 3000U;
                if (N == 15 || N == 13 || N == 11 || N == 9)
                        --N;

                /* truncate the filter and write n/trunc_start */
                truncM = (21 * N - 1) | 1;
                if (rate >= 24000U) {
                        if (truncM > 239)
                                truncM = 239;
                        truncStart = (239 - truncM) >> 1;

                        SRCRegWrite(dev, base + SRC_TRUNC_N_OFF,
                            (truncStart << 9) | (N << 4));
                } else {
                        if (truncM > 119)
                                truncM = 119;
                        truncStart = (119 - truncM) >> 1;

                        SRCRegWrite(dev, base + SRC_TRUNC_N_OFF,
                            0x8000U | (truncStart << 9) | (N << 4));
                }

                /* calculate new frequency and write it - preserve accum */
                freq = ((48000UL << 16) / rate) * N;
                SRCRegWrite(dev, base + SRC_INT_REGS_OFF,
                    (SRCRegRead(dev, (unsigned short) base + SRC_INT_REGS_OFF)
                    & 0x00ff) | ((unsigned short) (freq >> 6) & 0xfc00));
                SRCRegWrite(dev, base + SRC_VFREQ_FRAC_OFF,
                    (unsigned short) freq >> 1);

                SRCRegWrite(dev, SRC_ADC_VOL_L, N << 8);
                SRCRegWrite(dev, SRC_ADC_VOL_R, N << 8);
        }
}

static void
SRCInit(audioens_dev_t *dev)
{
        int i;

        /* Clear all SRC RAM then init - keep SRC disabled until done */
        for (i = 0; i < SRC_IOPOLL_COUNT; ++i) {
                if (!(GET32(dev, CONC_dSRCIO_OFF) & SRC_BUSY))
                        break;
        }
        PUT32(dev, CONC_dSRCIO_OFF, SRC_DISABLE);

        for (i = 0; i < 0x80; ++i)
                SRCRegWrite(dev, (unsigned short) i, 0U);

        SRCRegWrite(dev, SRC_DAC1_BASE + SRC_TRUNC_N_OFF, 16 << 4);
        SRCRegWrite(dev, SRC_DAC1_BASE + SRC_INT_REGS_OFF, 16 << 10);
        SRCRegWrite(dev, SRC_DAC2_BASE + SRC_TRUNC_N_OFF, 16 << 4);
        SRCRegWrite(dev, SRC_DAC2_BASE + SRC_INT_REGS_OFF, 16 << 10);
        SRCRegWrite(dev, SRC_DAC1_VOL_L, 1 << 12);
        SRCRegWrite(dev, SRC_DAC1_VOL_R, 1 << 12);
        SRCRegWrite(dev, SRC_DAC2_VOL_L, 1 << 12);
        SRCRegWrite(dev, SRC_DAC2_VOL_R, 1 << 12);
        SRCRegWrite(dev, SRC_ADC_VOL_L, 1 << 12);
        SRCRegWrite(dev, SRC_ADC_VOL_R, 1 << 12);

        /* default some rates */
        SRCSetRate(dev, SRC_DAC1_BASE, 48000);
        SRCSetRate(dev, SRC_DAC2_BASE, 48000);
        SRCSetRate(dev, SRC_ADC_BASE, 48000);

        /* now enable the whole deal */
        for (i = 0; i < SRC_IOPOLL_COUNT; ++i) {
                if (!(GET32(dev, CONC_dSRCIO_OFF) & SRC_BUSY))
                        break;
        }
        PUT32(dev, CONC_dSRCIO_OFF, 0);
}

static void
audioens_writemem(audioens_dev_t *dev, uint32_t page, uint32_t offs,
    uint32_t data)
{
        /* Select memory page */
        PUT32(dev, CONC_bMEMPAGE_OFF, page);
        PUT32(dev, offs, data);
}

static uint32_t
audioens_readmem(audioens_dev_t *dev, uint32_t page, uint32_t offs)
{
        PUT32(dev, CONC_bMEMPAGE_OFF, page);    /* Select memory page */
        return (GET32(dev, offs));
}

#ifdef __x86
static unsigned
audioens_intr(caddr_t arg1, caddr_t arg2)
{
        audioens_dev_t *dev = (void *)arg1;
        uint32_t status;
        uint32_t frameno;
        uint32_t n;
        audioens_port_t *port;

        _NOTE(ARGUNUSED(arg2));

        mutex_enter(&dev->mutex);
        if (dev->suspended || !dev->useintr) {
                mutex_exit(&dev->mutex);
                return (DDI_INTR_UNCLAIMED);
        }

        status = GET32(dev, CONC_dSTATUS_OFF);
        if ((status & CONC_STATUS_PENDING) == 0) {
                mutex_exit(&dev->mutex);
                return (DDI_INTR_UNCLAIMED);
        }

        /* Three interrupts, DAC1, DAC2, and ADC.  The UART we just toss. */

        if (status & CONC_STATUS_DAC1INT) {
                port = &dev->port[PORT_DAC];

                /* current frame counter is in high nybble */
                frameno = audioens_readmem(dev,
                    CONC_DAC1CTL_PAGE, CONC_wDAC1FC_OFF) >> 16;
                n = frameno >= port->frameno ?
                    frameno - port->frameno :
                    frameno + port->nframes - port->frameno;
                port->frameno = frameno;
                port->count += n;
                CLR8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_DAC1IE);
                SET8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_DAC1IE);
        }
        if (status & CONC_STATUS_ADCINT) {
                port = &dev->port[PORT_ADC];

                /* current frame counter is in high nybble */
                frameno = audioens_readmem(dev,
                    CONC_ADCCTL_PAGE, CONC_wADCFC_OFF) >> 16;
                n = frameno >= port->frameno ?
                    frameno - port->frameno :
                    frameno + port->nframes - port->frameno;
                port->frameno = frameno;
                port->count += n;
                CLR8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_ADCIE);
                SET8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_ADCIE);
        }
        if (status & CONC_STATUS_DAC2INT) {
                CLR8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_DAC2IE);
                SET8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_DAC2IE);
        }
        if (status & CONC_STATUS_UARTINT) {
                /*
                 * Consume data in the UART RX FIFO.  We don't support
                 * the UART for now, so just eat it.
                 */
                while (GET8(dev, CONC_bUARTCSTAT_OFF) & CONC_UART_RXRDY)
                        continue;
        }
        mutex_exit(&dev->mutex);

        return (DDI_INTR_CLAIMED);
}

static int
audioens_setup_intr(audioens_dev_t *dev)
{
        int     act;
        uint_t  ipri;

        if ((ddi_intr_alloc(dev->dip, &dev->intrh, DDI_INTR_TYPE_FIXED, 0, 1,
            &act, DDI_INTR_ALLOC_NORMAL) != DDI_SUCCESS) || (act != 1)) {
                audio_dev_warn(dev->osdev, "can't alloc intr handle");
                goto fail;
        }

        if (ddi_intr_get_pri(dev->intrh, &ipri) != DDI_SUCCESS) {
                audio_dev_warn(dev->osdev, "can't get interrupt priority");
                goto fail;
        }
        if (ddi_intr_add_handler(dev->intrh, audioens_intr, dev, NULL) !=
            DDI_SUCCESS) {
                audio_dev_warn(dev->osdev, "cannot add interrupt handler");
                goto fail;
        }
        dev->intrpri = ipri;
        return (DDI_SUCCESS);

fail:
        if (dev->intrh != NULL) {
                (void) ddi_intr_free(dev->intrh);
                dev->intrh = NULL;
        }
        return (DDI_FAILURE);
}

#endif  /* __x86 */

/*
 * Audio routines
 */
static int
audioens_format(void *arg)
{
        _NOTE(ARGUNUSED(arg));

        /* hardware can also do AUDIO_FORMAT_U8, but no need for it */
        return (AUDIO_FORMAT_S16_LE);
}

static int
audioens_channels(void *arg)
{
        audioens_port_t *port = arg;

        return (port->nchan);
}

static int
audioens_rate(void *arg)
{
        audioens_port_t *port = arg;

        return (port->speed);
}

static int
audioens_open(void *arg, int flag, unsigned *nframes, caddr_t *bufp)
{
        audioens_port_t *port = arg;
        audioens_dev_t  *dev = port->dev;

        _NOTE(ARGUNUSED(flag));

        mutex_enter(&dev->mutex);

        port->count = 0;

        *nframes = port->nframes;
        *bufp = port->kaddr;
        mutex_exit(&dev->mutex);

        return (0);
}

static int
audioens_start(void *arg)
{
        audioens_port_t *port = arg;
        audioens_dev_t *dev = port->dev;
        uint32_t tmp;

        mutex_enter(&dev->mutex);

        switch (port->num) {
        case PORT_DAC:
                /* Set physical address of the DMA buffer */
                audioens_writemem(dev, CONC_DAC1CTL_PAGE, CONC_dDAC1PADDR_OFF,
                    port->paddr);
                audioens_writemem(dev, CONC_DAC2CTL_PAGE, CONC_dDAC2PADDR_OFF,
                    port->paddr + (port->nframes * sizeof (int16_t) * 2));

                /* Set DAC rate */
                SRCSetRate(dev, SRC_DAC1_BASE, port->speed);
                SRCSetRate(dev, SRC_DAC2_BASE, port->speed);

                /* Configure the channel setup - SPDIF only uses front */
                tmp = GET32(dev, CONC_dSTATUS_OFF);
                tmp &= ~(CONC_STATUS_SPKR_MASK | CONC_STATUS_SPDIF_MASK);
                tmp |= CONC_STATUS_SPKR_4CH | CONC_STATUS_SPDIF_P1;
                PUT32(dev, CONC_dSTATUS_OFF, tmp);

                /* Set format */
                PUT8(dev, CONC_bSKIPC_OFF, 0x10);
                SET8(dev, CONC_bSERFMT_OFF,
                    CONC_PCM_DAC1_16BIT | CONC_PCM_DAC2_16BIT |
                    CONC_PCM_DAC1_STEREO | CONC_PCM_DAC2_STEREO);

                /* Set the frame count */
                audioens_writemem(dev, CONC_DAC1CTL_PAGE, CONC_wDAC1FC_OFF,
                    port->nframes - 1);
                audioens_writemem(dev, CONC_DAC2CTL_PAGE, CONC_wDAC2FC_OFF,
                    port->nframes - 1);

                PUT16(dev, CONC_wDAC1IC_OFF, port->iframes - 1);
                PUT16(dev, CONC_wDAC2IC_OFF, port->iframes - 1);
                SET8(dev, CONC_bDEVCTL_OFF,
                    CONC_DEVCTL_DAC2_EN | CONC_DEVCTL_DAC1_EN);
#ifdef __x86
                if (dev->useintr) {
                        SET8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_DAC1IE);
                }
#endif

                break;

        case PORT_ADC:
                /* Set physical address of the DMA buffer */
                audioens_writemem(dev, CONC_ADCCTL_PAGE, CONC_dADCPADDR_OFF,
                    port->paddr);

                /* Set ADC rate */
                SRCSetRate(dev, SRC_ADC_BASE, port->speed);

                /* Set format - for input we only support 16 bit input */
                tmp = GET8(dev, CONC_bSERFMT_OFF);
                tmp |= CONC_PCM_ADC_16BIT;
                tmp |= CONC_PCM_ADC_STEREO;

                PUT8(dev, CONC_bSKIPC_OFF, 0x10);

                PUT8(dev, CONC_bSERFMT_OFF, tmp);

                /* Set the frame count */
                audioens_writemem(dev, CONC_ADCCTL_PAGE, CONC_wADCFC_OFF,
                    port->nframes - 1);

                /* Set # of frames between interrupts */
                PUT16(dev, CONC_wADCIC_OFF, port->iframes - 1);

                SET8(dev, CONC_bDEVCTL_OFF, CONC_DEVCTL_ADC_EN);
#ifdef __x86
                if (dev->useintr) {
                        SET8(dev, CONC_bSERCTL_OFF, CONC_SERCTL_ADCIE);
                }
#endif
                break;
        }

        port->frameno = 0;
        mutex_exit(&dev->mutex);

        return (0);
}

static void
audioens_stop(void *arg)
{
        audioens_port_t *port = arg;
        audioens_dev_t *dev = port->dev;

        mutex_enter(&dev->mutex);
        switch (port->num) {
        case PORT_DAC:
                CLR8(dev, CONC_bDEVCTL_OFF,
                    CONC_DEVCTL_DAC2_EN | CONC_DEVCTL_DAC1_EN);
                break;
        case PORT_ADC:
                CLR8(dev, CONC_bDEVCTL_OFF, CONC_DEVCTL_ADC_EN);
                break;
        }
        mutex_exit(&dev->mutex);
}

static uint64_t
audioens_count(void *arg)
{
        audioens_port_t *port = arg;
        audioens_dev_t *dev = port->dev;
        uint64_t val;
        uint32_t page, offs;
        int frameno, n;

        switch (port->num) {
        case PORT_DAC:
                page = CONC_DAC1CTL_PAGE;
                offs = CONC_wDAC1FC_OFF;
                break;

        case PORT_ADC:
                page = CONC_ADCCTL_PAGE;
                offs = CONC_wADCFC_OFF;
                break;
        default:
                panic("Unknown port number: %d\n", port->num);
        }

        mutex_enter(&dev->mutex);
#ifdef __x86
        if (!dev->useintr) {
#endif

        /*
         * Note that the current frame counter is in the high nybble.
         */
        frameno = audioens_readmem(port->dev, page, offs) >> 16;
        n = frameno >= port->frameno ?
            frameno - port->frameno :
            frameno + port->nframes - port->frameno;
        port->frameno = frameno;
        port->count += n;

#ifdef __x86
        }
#endif

        val = port->count;
        mutex_exit(&dev->mutex);

        return (val);
}

static void
audioens_close(void *arg)
{
        _NOTE(ARGUNUSED(arg));
}

static void
audioens_sync(void *arg, unsigned nframes)
{
        audioens_port_t *port = arg;

        _NOTE(ARGUNUSED(nframes));

        if (port->num == PORT_ADC) {
                (void) ddi_dma_sync(port->dmah, 0, 0, DDI_DMA_SYNC_FORKERNEL);
        } else {
                (void) ddi_dma_sync(port->dmah, 0, 0, DDI_DMA_SYNC_FORDEV);
        }
}

static void
audioens_chinfo(void *arg, int chan, unsigned *offset, unsigned *incr)
{
        audioens_port_t *port = arg;

        if ((port->num == PORT_DAC) && (chan >= 2)) {
                *offset = (port->nframes * 2) + (chan % 2);
                *incr = 2;
        } else {
                *offset = chan;
                *incr = 2;
        }
}

audio_engine_ops_t audioens_engine_ops = {
        AUDIO_ENGINE_VERSION,           /* version number */
        audioens_open,
        audioens_close,
        audioens_start,
        audioens_stop,
        audioens_count,
        audioens_format,
        audioens_channels,
        audioens_rate,
        audioens_sync,
        NULL,
        audioens_chinfo,
        NULL,
};

void
audioens_init_hw(audioens_dev_t *dev)
{
        int tmp;

        if ((dev->devid == ENSONIQ_ES5880) ||
            (dev->devid == ENSONIQ_ES5880A) ||
            (dev->devid == ENSONIQ_ES5880B) ||
            (dev->devid == 0x1371 && dev->revision == 7) ||
            (dev->devid == 0x1371 && dev->revision >= 9)) {

                /* Have a ES5880 so enable the codec manually */
                tmp = GET8(dev, CONC_bINTSUMM_OFF) & 0xff;
                tmp |= 0x20;
                PUT8(dev, CONC_bINTSUMM_OFF, tmp);
                for (int i = 0; i < 2000; i++)
                        drv_usecwait(10);
        }

        SRCInit(dev);

        /*
         * Turn on CODEC (UART and joystick left disabled)
         */
        tmp = GET32(dev, CONC_bDEVCTL_OFF) & 0xff;
        tmp &= ~(CONC_DEVCTL_PCICLK_DS | CONC_DEVCTL_XTALCLK_DS);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bUARTCSTAT_OFF, 0x00);

        /* Perform AC97 codec warm reset */
        tmp = GET8(dev, CONC_bMISCCTL_OFF) & 0xff;
        PUT8(dev, CONC_bMISCCTL_OFF, tmp | CONC_MISCCTL_SYNC_RES);
        drv_usecwait(200);
        PUT8(dev, CONC_bMISCCTL_OFF, tmp);
        drv_usecwait(200);

        if (dev->revision >= 4) {
                /* XXX: enable SPDIF - PCM only for now */
                if (audioens_spdif) {
                        /* enable SPDIF */
                        PUT32(dev, 0x04, GET32(dev, 0x04) | (1 << 18));
                        /* SPDIF out = data from DAC */
                        PUT32(dev, 0x00, GET32(dev, 0x00) | (1 << 26));
                        CLR32(dev, CONC_dSPDIF_OFF, CONC_SPDIF_AC3);

                } else {
                        /* disable spdif out */
                        PUT32(dev, 0x04, GET32(dev, 0x04) & ~(1 << 18));
                        PUT32(dev, 0x00, GET32(dev, 0x00) & ~(1 << 26));
                }

                /* we want to run each channel independently */
                CLR32(dev, CONC_dSTATUS_OFF, CONC_STATUS_ECHO);
        }
}

static int
audioens_init(audioens_dev_t *dev)
{

        audioens_init_hw(dev);

        /*
         * On this hardware, we want to disable the internal speaker by
         * default, if it exists.  (We don't have a speakerphone on any
         * of these cards, and no SPARC hardware uses it either!)
         */
        (void) ddi_prop_update_int(DDI_DEV_T_NONE, dev->dip, AC97_PROP_SPEAKER,
            0);

        /*
         * Init mixer
         */

        dev->ac97 = ac97_alloc(dev->dip, audioens_rd97, audioens_wr97, dev);
        if (dev->ac97 == NULL)
                return (DDI_FAILURE);

        if (ac97_init(dev->ac97, dev->osdev) != 0) {
                return (DDI_FAILURE);
        }

        for (int i = 0; i <= PORT_MAX; i++) {
                audioens_port_t *port;
                unsigned caps;
                unsigned dmaflags;
                size_t rlen;
                ddi_dma_cookie_t c;
                unsigned ccnt;
                size_t bufsz;

                port = &dev->port[i];
                port->dev = dev;

                /*
                 * We have 48000Hz.  At that rate, 128 frames will give
                 * us an interrupt rate of 375Hz.  2048 frames buys about
                 * 42ms of buffer.  Note that interrupts are only enabled
                 * for platforms which need them (i.e. VMWare).
                 */

                switch (i) {
                case PORT_DAC:
                        port->nchan = 4;
                        port->speed = 48000;
                        port->iframes = 128;
                        port->nframes = 2048;
                        caps = ENGINE_OUTPUT_CAP;
                        dmaflags = DDI_DMA_WRITE | DDI_DMA_CONSISTENT;
                        break;

                case PORT_ADC:
                        port->nchan = 2;
                        port->speed = 48000;
                        port->iframes = 128;
                        port->nframes = 2048;
                        caps = ENGINE_INPUT_CAP;
                        dmaflags = DDI_DMA_READ | DDI_DMA_CONSISTENT;
                        break;
                }

                port->num = i;
                bufsz = port->nframes * port->nchan * sizeof (uint16_t);

                /*
                 * Allocate DMA resources.
                 */

                if (ddi_dma_alloc_handle(dev->dip, &dma_attr, DDI_DMA_SLEEP,
                    NULL, &port->dmah) != DDI_SUCCESS) {
                        audio_dev_warn(dev->osdev,
                            "port %d: dma handle allocation failed", i);
                        return (DDI_FAILURE);
                }
                if (ddi_dma_mem_alloc(port->dmah, bufsz, &buf_attr,
                    DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &port->kaddr,
                    &rlen, &port->acch) != DDI_SUCCESS) {
                        audio_dev_warn(dev->osdev,
                            "port %d: dma memory allocation failed", i);
                        return (DDI_FAILURE);
                }
                /* ensure that the buffer is zeroed out properly */
                bzero(port->kaddr, rlen);
                if (ddi_dma_addr_bind_handle(port->dmah, NULL, port->kaddr,
                    bufsz, dmaflags, DDI_DMA_SLEEP, NULL,
                    &c, &ccnt) != DDI_DMA_MAPPED) {
                        audio_dev_warn(dev->osdev,
                            "port %d: dma binding failed", i);
                        return (DDI_FAILURE);
                }
                port->paddr = c.dmac_address;

                /*
                 * Allocate and configure audio engine.
                 */
                port->engine = audio_engine_alloc(&audioens_engine_ops, caps);
                if (port->engine == NULL) {
                        audio_dev_warn(dev->osdev,
                            "port %d: audio_engine_alloc failed", i);
                        return (DDI_FAILURE);
                }

                audio_engine_set_private(port->engine, port);
                audio_dev_add_engine(dev->osdev, port->engine);
        }

        if (audio_dev_register(dev->osdev) != DDI_SUCCESS) {
                audio_dev_warn(dev->osdev,
                    "unable to register with audio framework");
                return (DDI_FAILURE);
        }

        return (DDI_SUCCESS);
}

void
audioens_destroy(audioens_dev_t *dev)
{
        int     i;

#ifdef __x86
        if (dev->useintr && dev->intrh != NULL) {
                (void) ddi_intr_disable(dev->intrh);
                (void) ddi_intr_remove_handler(dev->intrh);
                (void) ddi_intr_free(dev->intrh);
                dev->intrh = NULL;
        }
#endif

        mutex_destroy(&dev->mutex);

        /* free up ports, including DMA resources for ports */
        for (i = 0; i <= PORT_MAX; i++) {
                audioens_port_t *port = &dev->port[i];

                if (port->paddr != 0)
                        (void) ddi_dma_unbind_handle(port->dmah);
                if (port->acch != NULL)
                        ddi_dma_mem_free(&port->acch);
                if (port->dmah != NULL)
                        ddi_dma_free_handle(&port->dmah);

                if (port->engine != NULL) {
                        audio_dev_remove_engine(dev->osdev, port->engine);
                        audio_engine_free(port->engine);
                }
        }

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

        if (dev->ac97) {
                ac97_free(dev->ac97);
        }

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

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

int
audioens_attach(dev_info_t *dip)
{
        uint16_t pci_command, vendor, device;
        uint8_t revision;
        audioens_dev_t *dev;
        ddi_acc_handle_t pcih;
        const char *chip_name;
        const char *chip_vers;

        dev = kmem_zalloc(sizeof (*dev), KM_SLEEP);
        dev->dip = dip;
        ddi_set_driver_private(dip, dev);
        mutex_init(&dev->mutex, NULL, MUTEX_DRIVER, NULL);

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

        vendor = pci_config_get16(pcih, PCI_CONF_VENID);
        device = pci_config_get16(pcih, PCI_CONF_DEVID);
        revision = pci_config_get8(pcih, PCI_CONF_REVID);

        if ((vendor != ENSONIQ_VENDOR_ID && vendor != CREATIVE_VENDOR_ID) ||
            (device != ENSONIQ_ES1371 && device != ENSONIQ_ES5880 &&
            device != ENSONIQ_ES5880A && device != ECTIVA_ES1938 &&
            device != ENSONIQ_ES5880B)) {
                audio_dev_warn(dev->osdev, "unrecognized device");
                goto err_exit;
        }

        chip_name = "AudioPCI97";
        chip_vers = "unknown";

        switch (device) {
        case ENSONIQ_ES1371:
                chip_name = "AudioPCI97";
                switch (revision) {
                case 0x02:
                case 0x09:
                default:
                        chip_vers = "ES1371";
                        break;
                case 0x04:
                case 0x06:
                case 0x08:
                        chip_vers = "ES1373";
                        break;
                case 0x07:
                        chip_vers = "ES5880";
                        break;
                }
                break;

        case ENSONIQ_ES5880:
                chip_name = "SB PCI128";
                chip_vers = "ES5880";
                break;
        case ENSONIQ_ES5880A:
                chip_name = "SB PCI128";
                chip_vers = "ES5880A";
                break;
        case ENSONIQ_ES5880B:
                chip_name = "SB PCI128";
                chip_vers = "ES5880B";
                break;

        case ECTIVA_ES1938:
                chip_name = "AudioPCI";
                chip_vers = "ES1938";
                break;
        }

        dev->revision = revision;
        dev->devid = device;

        dev->osdev = audio_dev_alloc(dip, 0);
        if (dev->osdev == NULL) {
                goto err_exit;
        }

        audio_dev_set_description(dev->osdev, chip_name);
        audio_dev_set_version(dev->osdev, chip_vers);

        /* set the PCI latency */
        if ((audioens_latency == 32) || (audioens_latency == 64) ||
            (audioens_latency == 96))
                pci_config_put8(pcih, PCI_CONF_LATENCY_TIMER,
                    audioens_latency);

        /* activate the device */
        pci_command = pci_config_get16(pcih, PCI_CONF_COMM);
        pci_command |= PCI_COMM_ME | PCI_COMM_IO;
        pci_config_put16(pcih, PCI_CONF_COMM, pci_command);

        /* map registers */
        if (ddi_regs_map_setup(dip, 1, &dev->regs, 0, 0, &acc_attr,
            &dev->acch) != DDI_SUCCESS) {
                audio_dev_warn(dev->osdev, "can't map registers");
                goto err_exit;
        }

#ifdef __x86
        /*
         * Virtual platforms (mostly VMWare!) seem to need us to pulse
         * the interrupt enables to make progress.  So enable (emulated)
         * hardware interrupts.
         */
        dev->useintr = B_FALSE;
        if (get_hwenv() & HW_VIRTUAL) {
                dev->useintr = B_TRUE;
                if (audioens_setup_intr(dev) != DDI_SUCCESS) {
                        goto err_exit;
                }
                /* Reinitialize the mutex with interrupt priority. */
                mutex_destroy(&dev->mutex);
                mutex_init(&dev->mutex, NULL, MUTEX_DRIVER,
                    DDI_INTR_PRI(dev->intrpri));
        }
#endif

        /* This allocates and configures the engines */
        if (audioens_init(dev) != DDI_SUCCESS) {
                audio_dev_warn(dev->osdev, "can't init device");
                goto err_exit;
        }

#ifdef __x86
        if (dev->useintr) {
                (void) ddi_intr_enable(dev->intrh);
        }
#endif
        pci_config_teardown(&pcih);

        ddi_report_dev(dip);

        return (DDI_SUCCESS);

err_exit:
        pci_config_teardown(&pcih);

        audioens_destroy(dev);

        return (DDI_FAILURE);
}

int
audioens_detach(audioens_dev_t *dev)
{
        int tmp;

        /* first unregister us from the DDI framework, might be busy */
        if (audio_dev_unregister(dev->osdev) != DDI_SUCCESS)
                return (DDI_FAILURE);

        mutex_enter(&dev->mutex);

        tmp = GET8(dev, CONC_bSERCTL_OFF) &
            ~(CONC_SERCTL_DAC2IE | CONC_SERCTL_DAC1IE | CONC_SERCTL_ADCIE);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);

        tmp = GET8(dev, CONC_bDEVCTL_OFF) &
            ~(CONC_DEVCTL_DAC2_EN | CONC_DEVCTL_ADC_EN | CONC_DEVCTL_DAC1_EN);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);

        mutex_exit(&dev->mutex);

        audioens_destroy(dev);

        return (DDI_SUCCESS);
}

static int
audioens_resume(audioens_dev_t *dev)
{
        mutex_enter(&dev->mutex);
        dev->suspended = B_FALSE;
        mutex_exit(&dev->mutex);

        /* reinitialize hardware */
        audioens_init_hw(dev);

        /* restore AC97 state */
        ac97_reset(dev->ac97);

        audio_dev_resume(dev->osdev);

        return (DDI_SUCCESS);
}

static int
audioens_suspend(audioens_dev_t *dev)
{
        audio_dev_suspend(dev->osdev);

        mutex_enter(&dev->mutex);
        CLR8(dev, CONC_bDEVCTL_OFF,
            CONC_DEVCTL_DAC2_EN | CONC_DEVCTL_DAC1_EN | CONC_DEVCTL_ADC_EN);
        dev->suspended = B_TRUE;
        mutex_exit(&dev->mutex);

        return (DDI_SUCCESS);
}

static int
audioens_quiesce(dev_info_t *dip)
{
        audioens_dev_t  *dev;
        uint8_t         tmp;

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

        /* This disables all DMA engines and interrupts */
        tmp = GET8(dev, CONC_bSERCTL_OFF) &
            ~(CONC_SERCTL_DAC2IE | CONC_SERCTL_DAC1IE | CONC_SERCTL_ADCIE);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);
        PUT8(dev, CONC_bSERCTL_OFF, tmp);

        tmp = GET8(dev, CONC_bDEVCTL_OFF) &
            ~(CONC_DEVCTL_DAC2_EN | CONC_DEVCTL_ADC_EN | CONC_DEVCTL_DAC1_EN);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);
        PUT8(dev, CONC_bDEVCTL_OFF, tmp);

        return (DDI_SUCCESS);
}


static int
audioens_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        audioens_dev_t *dev;

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

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

        default:
                return (DDI_FAILURE);
        }
}

static int
audioens_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        audioens_dev_t *dev;

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

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

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

static int audioens_ddi_attach(dev_info_t *, ddi_attach_cmd_t);
static int audioens_ddi_detach(dev_info_t *, ddi_detach_cmd_t);

static struct dev_ops audioens_dev_ops = {
        DEVO_REV,               /* rev */
        0,                      /* refcnt */
        NULL,                   /* getinfo */
        nulldev,                /* identify */
        nulldev,                /* probe */
        audioens_ddi_attach,    /* attach */
        audioens_ddi_detach,    /* detach */
        nodev,                  /* reset */
        NULL,                   /* cb_ops */
        NULL,                   /* bus_ops */
        NULL,                   /* power */
        audioens_quiesce,       /* quiesce */
};

static struct modldrv audioens_modldrv = {
        &mod_driverops,                 /* drv_modops */
        "Ensoniq 1371/1373 Audio",      /* linkinfo */
        &audioens_dev_ops,              /* dev_ops */
};

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

int
_init(void)
{
        int     rv;

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

int
_fini(void)
{
        int     rv;

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

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