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


/*
 * audio1575 Audio Driver
 *
 * The driver is primarily targeted at providing audio support for
 * those systems which use the Uli M1575 audio core.
 *
 * The M1575 audio core, in AC'97 controller mode, has independent
 * channels for PCM in, PCM out, mic in, modem in, and modem out.
 *
 * The AC'97 controller is a PCI bus master with scatter/gather
 * support. Each channel has a DMA engine. Currently, we use only
 * the PCM in and PCM out channels. Each DMA engine uses one buffer
 * descriptor list. And the buffer descriptor list is an array of up
 * to 32 entries, each of which describes a data buffer. Each entry
 * contains a pointer to a data buffer, control bits, and the length
 * of the buffer being pointed to, where the length is expressed as
 * the number of samples. This, combined with the 16-bit sample size,
 * gives the actual physical length of the buffer.
 *
 *      NOTE:
 *      This driver depends on the drv/audio, misc/ac97
 *      modules being loaded first.
 */

#include <sys/types.h>
#include <sys/modctl.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/pci.h>
#include <sys/note.h>
#include <sys/audio/audio_driver.h>
#include <sys/audio/ac97.h>
#include "audio1575.h"

/*
 * Module linkage routines for the kernel
 */
static int audio1575_ddi_attach(dev_info_t *, ddi_attach_cmd_t);
static int audio1575_ddi_detach(dev_info_t *, ddi_detach_cmd_t);
static int audio1575_ddi_quiesce(dev_info_t *);

/*
 * Entry point routine prototypes
 */
static int audio1575_open(void *, int, unsigned *, caddr_t *);
static void audio1575_close(void *);
static int audio1575_start(void *);
static void audio1575_stop(void *);
static int audio1575_format(void *);
static int audio1575_channels(void *);
static int audio1575_rate(void *);
static uint64_t audio1575_count(void *);
static void audio1575_sync(void *, unsigned);

static audio_engine_ops_t audio1575_engine_ops = {
        AUDIO_ENGINE_VERSION,
        audio1575_open,
        audio1575_close,
        audio1575_start,
        audio1575_stop,
        audio1575_count,
        audio1575_format,
        audio1575_channels,
        audio1575_rate,
        audio1575_sync,
        NULL,
        NULL,
        NULL
};

/*
 * Local Routine Prototypes
 */
static int audio1575_attach(dev_info_t *);
static int audio1575_resume(dev_info_t *);
static int audio1575_detach(dev_info_t *);
static int audio1575_suspend(dev_info_t *);

static int audio1575_alloc_port(audio1575_state_t *, int, uint8_t);
static void audio1575_free_port(audio1575_port_t *);

static int audio1575_codec_sync(audio1575_state_t *);
static void audio1575_write_ac97(void *, uint8_t, uint16_t);
static uint16_t audio1575_read_ac97(void *, uint8_t);
static int audio1575_chip_init(audio1575_state_t *);
static int audio1575_map_regs(audio1575_state_t *);
static void audio1575_unmap_regs(audio1575_state_t *);
static void audio1575_dma_stop(audio1575_state_t *, boolean_t);
static void audio1575_pci_enable(audio1575_state_t *);
static void audio1575_pci_disable(audio1575_state_t *);

static void audio1575_destroy(audio1575_state_t *);

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

/*
 * DDI Structures
 */


/* Device operations structure */
static struct dev_ops audio1575_dev_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* devo_refcnt */
        NULL,                   /* devo_getinfo */
        nulldev,                /* devo_identify - obsolete */
        nulldev,                /* devo_probe */
        audio1575_ddi_attach,   /* devo_attach */
        audio1575_ddi_detach,   /* devo_detach */
        nodev,                  /* devo_reset */
        NULL,                   /* devi_cb_ops */
        NULL,                   /* devo_bus_ops */
        NULL,                   /* devo_power */
        audio1575_ddi_quiesce,  /* devo_quiesce */
};

/* Linkage structure for loadable drivers */
static struct modldrv audio1575_modldrv = {
        &mod_driverops,         /* drv_modops */
        M1575_MOD_NAME,         /* drv_linkinfo */
        &audio1575_dev_ops,     /* drv_dev_ops */
};

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


/*
 * device access attributes for register mapping
 */
static struct ddi_device_acc_attr dev_attr = {
        DDI_DEVICE_ATTR_V0,
        DDI_STRUCTURE_LE_ACC,
        DDI_STRICTORDER_ACC
};

static struct ddi_device_acc_attr buf_attr = {
        DDI_DEVICE_ATTR_V0,
        DDI_NEVERSWAP_ACC,
        DDI_STRICTORDER_ACC
};

/*
 * DMA attributes of buffer descriptor list
 */
static ddi_dma_attr_t bdlist_dma_attr = {
        DMA_ATTR_V0,    /* version */
        0x0000000000000000LL,           /* dlim_addr_lo */
        0x00000000ffffffffLL,           /* dlim_addr_hi */
        0x000000000000ffffLL,           /* DMA counter register - 64 bits */
        0x0000000000000008LL,           /* DMA address align must be 8-bytes */
        0x0000003c,                     /* 1 through 64 byte burst sizes */
        0x00000008,                     /* min xfer DMA size BDList entry */
        0x00000000000ffffLL,            /* max xfer size, 64K */
        0x000000000001fffLL,            /* seg, set to PAGESIZE */
        0x00000001,                     /* s/g list length, no s/g */
        0x00000008,                     /* granularity of device minxfer */
        0                               /* DMA flags use virtual address */
};

/*
 * DMA attributes of buffers to be used to receive/send audio data
 */
static ddi_dma_attr_t   sample_buf_dma_attr = {
        DMA_ATTR_V0,
        0x0000000000000000LL,           /* dlim_addr_lo */
        0x00000000ffffffffLL,           /* dlim_addr_hi */
        0x000000000001fffeLL,           /* DMA counter register - 16 bits */
        0x0000000000000004LL,           /* DMA address align 2-byte boundary */
        0x0000003c,                     /* 1 through 60 byte burst sizes */
        0x00000004,                     /* min xfer DMA size BDList entry */
        0x000000000001ffffLL,           /* max xfer size, 64K */
        0x000000000001ffffLL,           /* seg, set to 64K */
        0x00000001,                     /* s/g list length, no s/g */
        0x00000004,                     /* granularity of device minxfer */
        0                               /* DMA flags use virtual address */
};

/*
 * _init()
 *
 * Description:
 *      Driver initialization, called when driver is first loaded.
 *      This is how access is initially given to all the static structures.
 *
 * Arguments:
 *      None
 *
 * Returns:
 *      mod_install() status, see mod_install(9f)
 */
int
_init(void)
{
        int     error;

        audio_init_ops(&audio1575_dev_ops, M1575_NAME);

        if ((error = mod_install(&audio1575_modlinkage)) != 0) {
                audio_fini_ops(&audio1575_dev_ops);
        }

        return (error);
}

/*
 * _fini()
 *
 * Description:
 *      Module de-initialization, called when the driver is to be unloaded.
 *
 * Arguments:
 *      None
 *
 * Returns:
 *      mod_remove() status, see mod_remove(9f)
 */
int
_fini(void)
{
        int             error;

        if ((error = mod_remove(&audio1575_modlinkage)) != 0) {
                return (error);
        }

        /* clean up ops */
        audio_fini_ops(&audio1575_dev_ops);

        return (0);
}

/*
 * _info()
 *
 * Description:
 *      Module information, returns information about the driver.
 *
 * Arguments:
 *      modinfo         *modinfop       Pointer to the opaque modinfo structure
 *
 * Returns:
 *      mod_info() status, see mod_info(9f)
 */
int
_info(struct modinfo *modinfop)
{
        return (mod_info(&audio1575_modlinkage, modinfop));
}


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

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

        case DDI_RESUME:
                return (audio1575_resume(dip));
        }
        return (DDI_FAILURE);
}

/*
 * audio1575_ddi_detach()
 *
 * Description:
 *      Implements the detach(9e) entry point.
 *
 * Arguments:
 *      dev_info_t              *dip    Pointer to the device's dev_info struct
 *      ddi_detach_cmd_t        cmd     Detach command
 *
 * Returns:
 *      DDI_SUCCESS     The driver was detached
 *      DDI_FAILURE     The driver couldn't be detached
 */
static int
audio1575_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        switch (cmd) {
        case DDI_DETACH:
                return (audio1575_detach(dip));

        case DDI_SUSPEND:
                return (audio1575_suspend(dip));
        }
        return (DDI_FAILURE);
}

/*
 * audio1575_ddi_quiesce()
 *
 * Description:
 *      Implements the quiesce(9e) entry point.
 *
 * Arguments:
 *      dev_info_t              *dip    Pointer to the device's dev_info struct
 *
 * Returns:
 *      DDI_SUCCESS     The driver was quiesced
 *      DDI_FAILURE     The driver couldn't be quiesced
 */
static int
audio1575_ddi_quiesce(dev_info_t *dip)
{
        audio1575_state_t       *statep;

        if ((statep = ddi_get_driver_private(dip)) == NULL)
                return (DDI_FAILURE);

        audio1575_dma_stop(statep, B_TRUE);
        return (DDI_SUCCESS);
}

/*
 * audio1575_open()
 *
 * Description:
 *      Opens a DMA engine for use.
 *
 * Arguments:
 *      void            *arg            The DMA engine to set up
 *      int             flag            Open flags
 *      unsigned        *nframesp       Receives number of frames
 *      caddr_t         *bufp           Receives kernel data buffer
 *
 * Returns:
 *      0       on success
 *      errno   on failure
 */
static int
audio1575_open(void *arg, int flag, unsigned *nframesp, caddr_t *bufp)
{
        audio1575_port_t        *port = arg;

        _NOTE(ARGUNUSED(flag));

        port->count = 0;
        *nframesp = port->nframes;
        *bufp = port->samp_kaddr;

        return (0);
}


/*
 * audio1575_close()
 *
 * Description:
 *      Closes an audio DMA engine that was previously opened.  Since
 *      nobody is using it, we take this opportunity to possibly power
 *      down the entire device.
 *
 * Arguments:
 *      void    *arg            The DMA engine to shut down
 */
static void
audio1575_close(void *arg)
{
        _NOTE(ARGUNUSED(arg));
}

/*
 * audio1575_stop()
 *
 * Description:
 *      This is called by the framework to stop a port that is
 *      transferring data.
 *
 * Arguments:
 *      void    *arg            The DMA engine to stop
 */
static void
audio1575_stop(void *arg)
{
        audio1575_port_t        *port = arg;
        audio1575_state_t       *statep = port->statep;

        mutex_enter(&statep->lock);
        if (port->num == M1575_REC) {
                SET32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE);
        } else {
                SET32(M1575_DMACR_REG, M1575_DMACR_PCMOPAUSE);
        }
        mutex_exit(&statep->lock);
}

/*
 * audio1575_start()
 *
 * Description:
 *      This is called by the framework to start a port transferring data.
 *
 * Arguments:
 *      void    *arg            The DMA engine to start
 *
 * Returns:
 *      0       on success (never fails, errno if it did)
 */
static int
audio1575_start(void *arg)
{
        audio1575_port_t        *port = arg;
        audio1575_state_t       *statep = port->statep;

        mutex_enter(&statep->lock);

        port->offset = 0;

        if (port->num == M1575_REC) {
                /* Uli FIFO madness ... */
                SET32(M1575_FIFOCR1_REG, M1575_FIFOCR1_PCMIRST);
                SET32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE);

                PUT8(M1575_PCMICR_REG, 0);
                PUT8(M1575_PCMICR_REG, M1575_CR_RR);

                PUT32(M1575_PCMIBDBAR_REG, port->bdl_paddr);
                PUT8(M1575_PCMILVIV_REG, M1575_BD_NUMS - 1);

                CLR32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE);

                /* ULi says do fifo resets here */
                SET32(M1575_FIFOCR1_REG, M1575_FIFOCR1_PCMIRST);
                CLR32(M1575_DMACR_REG, M1575_DMACR_PCMIPAUSE);
                PUT8(M1575_PCMICR_REG, 0);
                SET32(M1575_DMACR_REG, M1575_DMACR_PCMISTART);

        } else {

                uint32_t        scr;

                /* Uli FIFO madness ... */
                SET32(M1575_FIFOCR1_REG, M1575_FIFOCR1_PCMORST);
                SET32(M1575_DMACR_REG, M1575_DMACR_PCMOPAUSE);

                /* configure the number of channels properly */
                scr = GET32(M1575_SCR_REG);
                scr &= ~(M1575_SCR_6CHL_MASK | M1575_SCR_CHAMOD_MASK);
                scr |= M1575_SCR_6CHL_2;        /* select our proper ordering */
                switch (port->nchan) {
                case 2:
                        scr |= M1575_SCR_CHAMOD_2;
                        break;
                case 4:
                        scr |= M1575_SCR_CHAMOD_4;
                        break;
                case 6:
                        scr |= M1575_SCR_CHAMOD_6;
                        break;
                }
                PUT32(M1575_SCR_REG, scr);

                PUT8(M1575_PCMOCR_REG, 0);
                PUT8(M1575_PCMOCR_REG, M1575_CR_RR);

                PUT32(M1575_PCMOBDBAR_REG, port->bdl_paddr);
                PUT8(M1575_PCMOLVIV_REG, M1575_BD_NUMS - 1);

                CLR32(M1575_DMACR_REG, M1575_DMACR_PCMOPAUSE);
                PUT8(M1575_PCMOCR_REG, 0);
                SET32(M1575_DMACR_REG, M1575_DMACR_PCMOSTART);
        }

        mutex_exit(&statep->lock);
        return (0);
}



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

        return (AUDIO_FORMAT_S16_LE);
}

/*
 * audio1575_channels()
 *
 * Description:
 *      Called by the framework to query the channels for the device.
 *
 * Arguments:
 *      void    *arg            The DMA engine to query
 *
 * Returns:
 *      Number of channels for the device
 */
static int
audio1575_channels(void *arg)
{
        audio1575_port_t *port = arg;

        return (port->nchan);
}

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

        return (48000);
}

/*
 * audio1575_count()
 *
 * Description:
 *      This is called by the framework to get the engine's frame counter
 *
 * Arguments:
 *      void    *arg            The DMA engine to query
 *
 * Returns:
 *      frame count for current engine
 */
static uint64_t
audio1575_count(void *arg)
{
        audio1575_port_t        *port = arg;
        audio1575_state_t       *statep = port->statep;
        uint64_t                val;
        uint8_t                 civ;
        unsigned                n;
        int                     civoff;
        int                     lvioff;
        int                     picoff;

        mutex_enter(&statep->lock);

        if (port->num == M1575_REC) {
                civoff = M1575_PCMICIV_REG;
                lvioff = M1575_PCMILVIV_REG;
                picoff = M1575_PCMIPICB_REG;
        } else {
                civoff = M1575_PCMOCIV_REG;
                lvioff = M1575_PCMOLVIV_REG;
                picoff = M1575_PCMOPICB_REG;
        }

        /*
         * Read the position counters.  We also take this opportunity
         * to update the last valid index to the one just previous to
         * the one we're working on (so we'll fully loop.)
         */
        n = GET16(picoff);
        civ = GET8(civoff);
        PUT8(lvioff, (civ - 1) % M1575_BD_NUMS);

        n = port->samp_size - (n * sizeof (int16_t));
        if (n < port->offset) {
                val = (port->samp_size - port->offset) + n;
        } else {
                val = n - port->offset;
        }
        port->offset = n;
        port->count += (val / (port->nchan * sizeof (int16_t)));
        val = port->count;
        mutex_exit(&statep->lock);

        return (val);
}

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

        (void) ddi_dma_sync(port->samp_dmah, 0, 0, port->sync_dir);
}

/*
 * audio1575_attach()
 *
 * Description:
 *      Attach an instance of the audio1575 driver. This routine does the
 *      device dependent attach tasks. When it is completed, it registers
 *      with the audio framework.
 *
 * Arguments:
 *      dev_info_t      *dip    Pointer to the device's dev_info struct
 *
 * Returns:
 *      DDI_SUCCESS             The driver was initialized properly
 *      DDI_FAILURE             The driver couldn't be initialized properly
 */
static int
audio1575_attach(dev_info_t *dip)
{
        audio1575_state_t       *statep;
        audio_dev_t             *adev;
        uint32_t                devid;
        const char              *name;
        const char              *rev;
        int                     maxch;

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

        /*
         * We want the micboost enabled by default as well.
         */
        (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, AC97_PROP_MICBOOST, 1);

        /* allocate common audio dev structure */
        adev = audio_dev_alloc(dip, 0);
        if (adev == NULL) {
                audio_dev_warn(NULL, "unable to allocate audio dev");
                goto error;
        }
        statep->adev = adev;

        /* map in the audio registers */
        if (audio1575_map_regs(statep) != DDI_SUCCESS) {
                audio_dev_warn(adev, "couldn't map registers");
                goto error;
        }

        /* Enable PCI I/O and Memory Spaces */
        audio1575_pci_enable(statep);

        devid = (pci_config_get16(statep->pcih, PCI_CONF_VENID) << 16) |
            pci_config_get16(statep->pcih, PCI_CONF_DEVID);
        switch (devid) {
        case 0x10b95455:
                name = "Uli M1575 AC'97";
                rev = "M5455";
                break;
        default:
                name = "Uli AC'97";
                rev = "Unknown";
                break;
        }
        /* set device information -- this should check PCI config space */
        audio_dev_set_description(adev, name);
        audio_dev_set_version(adev, rev);

        statep->ac97 = ac97_alloc(dip, audio1575_read_ac97,
            audio1575_write_ac97, statep);
        ASSERT(statep->ac97 != NULL);

        /*
         * Override "max-channels" property to prevent configuration
         * of 4 or 6 (or possibly even 8!) channel audio.  The default
         * is to support as many channels as the hardware can do.
         */
        maxch = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
            "max-channels", ac97_num_channels(statep->ac97));
        if (maxch < 2) {
                maxch = 2;
        }

        statep->maxch = min(maxch, 6) & ~1;

        /* allocate port structures */
        if ((audio1575_alloc_port(statep, M1575_PLAY, statep->maxch) !=
            DDI_SUCCESS) ||
            (audio1575_alloc_port(statep, M1575_REC, 2) != DDI_SUCCESS)) {
                goto error;
        }

        if (audio1575_chip_init(statep) != DDI_SUCCESS) {
                audio_dev_warn(adev, "failed to init chip");
                goto error;
        }

        if (ac97_init(statep->ac97, adev) != DDI_SUCCESS) {
                audio_dev_warn(adev, "ac'97 initialization failed");
                goto error;
        }

        /* register with the framework */
        if (audio_dev_register(adev) != DDI_SUCCESS) {
                audio_dev_warn(adev, "unable to register with framework");
                goto error;
        }

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

        return (DDI_SUCCESS);

error:
        audio1575_destroy(statep);
        return (DDI_FAILURE);
}

/*
 * audio1575_detach()
 *
 * Description:
 *      Detach an instance of the audio1575 driver.
 *
 * Arguments:
 *      dev_info_t      *dip    Pointer to the device's dev_info struct
 *
 * Returns:
 *      DDI_SUCCESS     The driver was detached
 *      DDI_FAILURE     The driver couldn't be detached
 */
static int
audio1575_detach(dev_info_t *dip)
{
        audio1575_state_t       *statep;

        statep = ddi_get_driver_private(dip);

        if (audio_dev_unregister(statep->adev) != DDI_SUCCESS) {
                return (DDI_FAILURE);
        }

        audio1575_destroy(statep);
        return (DDI_SUCCESS);
}

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

/*
 * audio1575_alloc_port()
 *
 * Description:
 *      This routine allocates the DMA handles and the memory for the
 *      DMA engines to use.  It also configures the BDL lists properly
 *      for use.
 *
 * Arguments:
 *      dev_info_t      *dip    Pointer to the device's devinfo
 *      int             num     M1575_PLAY or M1575_REC
 *      uint8_t         nchan   Number of channels (2 = stereo, 6 = 5.1, etc.)
 *
 * Returns:
 *      DDI_SUCCESS             Registers successfully mapped
 *      DDI_FAILURE             Registers not successfully mapped
 */
static int
audio1575_alloc_port(audio1575_state_t *statep, int num, uint8_t nchan)
{
        ddi_dma_cookie_t        cookie;
        uint_t                  count;
        int                     dir;
        unsigned                caps;
        audio_dev_t             *adev;
        audio1575_port_t        *port;
        uint32_t                *kaddr;
        int                     rc;
        dev_info_t              *dip;

        adev = statep->adev;
        dip = statep->dip;

        port = kmem_zalloc(sizeof (*port), KM_SLEEP);
        statep->ports[num] = port;
        port->num = num;
        port->statep = statep;
        port->nchan = nchan;

        if (num == M1575_REC) {
                dir = DDI_DMA_READ;
                caps = ENGINE_INPUT_CAP;
                port->sync_dir = DDI_DMA_SYNC_FORKERNEL;
        } else {
                dir = DDI_DMA_WRITE;
                caps = ENGINE_OUTPUT_CAP;
                port->sync_dir = DDI_DMA_SYNC_FORDEV;
        }

        /*
         * We use one big sample area.  The sample area must be larger
         * than about 1.5 framework fragment sizes.  (Currently 480 *
         * 1.5 = 720 frames.)  This is necessary to ensure that we
         * don't have to involve an interrupt service routine on our
         * own, to keep the last valid index updated reasonably.
         */
        port->nframes = 2048;
        port->samp_size = port->nframes * port->nchan * sizeof (int16_t);

        /* allocate dma handle */
        rc = ddi_dma_alloc_handle(dip, &sample_buf_dma_attr, DDI_DMA_SLEEP,
            NULL, &port->samp_dmah);
        if (rc != DDI_SUCCESS) {
                audio_dev_warn(adev, "ddi_dma_alloc_handle failed: %d", rc);
                return (DDI_FAILURE);
        }
        /* allocate DMA buffer */
        rc = ddi_dma_mem_alloc(port->samp_dmah, port->samp_size, &buf_attr,
            DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &port->samp_kaddr,
            &port->samp_size, &port->samp_acch);
        if (rc == DDI_FAILURE) {
                audio_dev_warn(adev, "dma_mem_alloc failed");
                return (DDI_FAILURE);
        }

        /* bind DMA buffer */
        rc = ddi_dma_addr_bind_handle(port->samp_dmah, NULL,
            port->samp_kaddr, port->samp_size, dir|DDI_DMA_CONSISTENT,
            DDI_DMA_SLEEP, NULL, &cookie, &count);
        if ((rc != DDI_DMA_MAPPED) || (count != 1)) {
                audio_dev_warn(adev,
                    "ddi_dma_addr_bind_handle failed: %d", rc);
                return (DDI_FAILURE);
        }
        port->samp_paddr = cookie.dmac_address;

        /*
         * now, from here we allocate DMA memory for buffer descriptor list.
         * we allocate adjacent DMA memory for all DMA engines.
         */
        rc = ddi_dma_alloc_handle(dip, &bdlist_dma_attr, DDI_DMA_SLEEP,
            NULL, &port->bdl_dmah);
        if (rc != DDI_SUCCESS) {
                audio_dev_warn(adev, "ddi_dma_alloc_handle(bdlist) failed");
                return (DDI_FAILURE);
        }

        /*
         * we allocate all buffer descriptors lists in continuous dma memory.
         */
        port->bdl_size = sizeof (m1575_bd_entry_t) * M1575_BD_NUMS;
        rc = ddi_dma_mem_alloc(port->bdl_dmah, port->bdl_size,
            &dev_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
            &port->bdl_kaddr, &port->bdl_size, &port->bdl_acch);
        if (rc != DDI_SUCCESS) {
                audio_dev_warn(adev, "ddi_dma_mem_alloc(bdlist) failed");
                return (DDI_FAILURE);
        }

        /*
         * Wire up the BD list.  We do this *before* binding the BD list
         * so that we don't have to do an extra ddi_dma_sync.
         */
        kaddr = (void *)port->bdl_kaddr;
        for (int i = 0; i < M1575_BD_NUMS; i++) {

                /* set base address of buffer */
                ddi_put32(port->bdl_acch, kaddr, port->samp_paddr);
                kaddr++;

                /* set size in frames, and enable IOC interrupt */
                ddi_put32(port->bdl_acch, kaddr,
                    ((port->samp_size / sizeof (int16_t)) | (1U << 31)));
                kaddr++;
        }

        rc = ddi_dma_addr_bind_handle(port->bdl_dmah, NULL, port->bdl_kaddr,
            port->bdl_size, DDI_DMA_WRITE|DDI_DMA_CONSISTENT, DDI_DMA_SLEEP,
            NULL, &cookie, &count);
        if ((rc != DDI_DMA_MAPPED) || (count != 1)) {
                audio_dev_warn(adev, "addr_bind_handle failed");
                return (DDI_FAILURE);
        }
        port->bdl_paddr = cookie.dmac_address;

        port->engine = audio_engine_alloc(&audio1575_engine_ops, caps);
        if (port->engine == NULL) {
                audio_dev_warn(adev, "audio_engine_alloc failed");
                return (DDI_FAILURE);
        }

        audio_engine_set_private(port->engine, port);
        audio_dev_add_engine(adev, port->engine);

        return (DDI_SUCCESS);
}

/*
 * audio1575_free_port()
 *
 * Description:
 *      This routine unbinds the DMA cookies, frees the DMA buffers,
 *      deallocates the DMA handles.
 *
 * Arguments:
 *      audio1575_port_t        *port   The port structure for a DMA engine.
 */
static void
audio1575_free_port(audio1575_port_t *port)
{
        if (port == NULL)
                return;

        if (port->engine) {
                audio_dev_remove_engine(port->statep->adev, port->engine);
                audio_engine_free(port->engine);
        }
        if (port->bdl_paddr) {
                (void) ddi_dma_unbind_handle(port->bdl_dmah);
        }
        if (port->bdl_acch) {
                ddi_dma_mem_free(&port->bdl_acch);
        }
        if (port->bdl_dmah) {
                ddi_dma_free_handle(&port->bdl_dmah);
        }
        if (port->samp_paddr) {
                (void) ddi_dma_unbind_handle(port->samp_dmah);
        }
        if (port->samp_acch) {
                ddi_dma_mem_free(&port->samp_acch);
        }
        if (port->samp_dmah) {
                ddi_dma_free_handle(&port->samp_dmah);
        }
        kmem_free(port, sizeof (*port));
}

/*
 * audio1575_map_regs()
 *
 * Description:
 *      The registers are mapped in.
 *
 * Arguments:
 *      dev_info_t      *dip    Pointer to the device's devinfo
 *
 * Returns:
 *      DDI_SUCCESS             Registers successfully mapped
 *      DDI_FAILURE             Registers not successfully mapped
 */
static int
audio1575_map_regs(audio1575_state_t *statep)
{
        dev_info_t              *dip = statep->dip;

        /* map the M1575 Audio PCI Cfg Space */
        if (pci_config_setup(dip, &statep->pcih) != DDI_SUCCESS) {
                audio_dev_warn(statep->adev, "PCI config map failure");
                goto error;
        }

        /* map the M1575 Audio registers in PCI IO Space */
        if ((ddi_regs_map_setup(dip, M1575_AUDIO_IO_SPACE, &statep->regsp,
            0, 0, &dev_attr, &statep->regsh)) != DDI_SUCCESS) {
                audio_dev_warn(statep->adev, "Audio IO mapping failure");
                goto error;
        }
        return (DDI_SUCCESS);

error:
        audio1575_unmap_regs(statep);

        return (DDI_FAILURE);
}

/*
 * audio1575_unmap_regs()
 *
 * Description:
 *      This routine unmaps control registers.
 *
 * Arguments:
 *      audio1575_state_t       *state  The device's state structure
 */
static void
audio1575_unmap_regs(audio1575_state_t *statep)
{
        if (statep->regsh) {
                ddi_regs_map_free(&statep->regsh);
        }

        if (statep->pcih) {
                pci_config_teardown(&statep->pcih);
        }
}

/*
 * audio1575_chip_init()
 *
 * Description:
 *      This routine initializes the M1575 AC97 audio controller and the AC97
 *      codec.  The AC97 codec registers are programmed from codec_shadow[].
 *      If we are not doing a restore, we initialize codec_shadow[], otherwise
 *      we use the current values of shadow.    This routine expects that the
 *      PCI IO and Memory spaces have been mapped and enabled already.
 * Arguments:
 *      audio1575_state_t       *state          The device's state structure
 *                                              restore from codec_shadow[]
 * Returns:
 *      DDI_SUCCESS     The hardware was initialized properly
 *      DDI_FAILURE     The hardware couldn't be initialized properly
 */
static int
audio1575_chip_init(audio1575_state_t *statep)
{
        uint32_t                ssr;
        uint32_t                rtsr;
        uint32_t                intrsr;
        int                     i;
        int                     j;
#ifdef  __sparc
        uint8_t                 clk_detect;
        ddi_acc_handle_t        pcih;
#endif
        clock_t                 ticks;

        /*
         * clear the interrupt control and status register
         * READ/WRITE/READ workaround required
         * for buggy hardware
         */

        PUT32(M1575_INTRCR_REG, 0);
        (void) GET32(M1575_INTRCR_REG);

        intrsr = GET32(M1575_INTRSR_REG);
        PUT32(M1575_INTRSR_REG, (intrsr & M1575_INTR_MASK));
        (void) GET32(M1575_INTRSR_REG);

        ticks = drv_usectohz(M1575_LOOP_CTR);

        /*
         * SADA only supports stereo, so we set the channel bits
         * to "00" to select 2 channels.
         * will also set the following:
         *
         * Disable double rate enable
         * no SPDIF output selected
         * 16 bit audio record mode
         * 16 bit pcm out mode
         * PCM Out 6 chan mode FL FR CEN BL BR LFE
         * PCM Out 2 channel mode (00)
         */
        for (i = 0; i < M1575_LOOP_CTR; i++) {
                /* Reset the AC97 Codec and default to 2 channel 16 bit mode */
                PUT32(M1575_SCR_REG, M1575_SCR_COLDRST);
                delay(ticks<<1);

                /* Read the System Status Reg */
                ssr = GET32(M1575_SSR_REG);

                /* make sure and release the blocked reset bit */
                if (ssr & M1575_SSR_RSTBLK) {
                        SET32(M1575_INTFCR_REG, M1575_INTFCR_RSTREL);
                        delay(ticks);

                        /* Read the System Status Reg */
                        ssr = GET32(M1575_SSR_REG);

                        /* make sure and release the blocked reset bit */
                        if (ssr & M1575_SSR_RSTBLK) {
                                return (DDI_FAILURE);
                        }

                        /* Reset the controller */
                        PUT32(M1575_SCR_REG, M1575_SCR_COLDRST);
                        delay(ticks);
                }

                /* according AC'97 spec, wait for codec reset */
                for (j = 0; j < M1575_LOOP_CTR; j++) {
                        if ((GET32(M1575_SCR_REG) & M1575_SCR_COLDRST) == 0) {
                                break;
                        }
                        delay(ticks);
                }

                /* codec reset failed */
                if (j >= M1575_LOOP_CTR) {
                        audio_dev_warn(statep->adev,
                            "failure to reset codec");
                        return (DDI_FAILURE);
                }

                /*
                 * Wait for FACRDY First codec ready. The hardware can
                 * provide the state of
                 * codec ready bit on SDATA_IN[0] and as reflected in
                 * the Recv Tag Slot Reg.
                 */
                rtsr = GET32(M1575_RTSR_REG);
                if (rtsr & M1575_RTSR_FACRDY) {
                        break;
                } else { /* reset the status and wait for new status to set */
                        rtsr |= M1575_RTSR_FACRDY;
                        PUT32(M1575_RTSR_REG, rtsr);
                        drv_usecwait(10);
                }
        }

        /* if we could not reset the AC97 codec then report failure */
        if (i >= M1575_LOOP_CTR) {
                audio_dev_warn(statep->adev,
                    "no codec ready signal received");
                return (DDI_FAILURE);
        }

#ifdef  __sparc
        /* Magic code from ULi to Turn on the AC_LINK clock */
        pcih = statep->pcih;
        pci_config_put8(pcih, M1575_PCIACD_REG, 0);
        pci_config_put8(pcih, M1575_PCIACD_REG, 4);
        pci_config_put8(pcih, M1575_PCIACD_REG, 0);
        (void) pci_config_get8(pcih, M1575_PCIACD_REG);
        pci_config_put8(pcih, M1575_PCIACD_REG, 2);
        pci_config_put8(pcih, M1575_PCIACD_REG, 0);
        clk_detect = pci_config_get8(pcih, M1575_PCIACD_REG);

        if (clk_detect != 1) {
                audio_dev_warn(statep->adev, "No AC97 Clock Detected");
                return (DDI_FAILURE);
        }
#endif

        /* Magic code from Uli to Init FIFO1 and FIFO2 */
        PUT32(M1575_FIFOCR1_REG, 0x81818181);
        PUT32(M1575_FIFOCR2_REG, 0x81818181);
        PUT32(M1575_FIFOCR3_REG, 0x81818181);

        /* Make sure that PCM in and PCM out are enabled */
        SET32(M1575_INTFCR_REG, (M1575_INTFCR_PCMIENB | M1575_INTFCR_PCMOENB));

        audio1575_dma_stop(statep, B_FALSE);

        return (DDI_SUCCESS);
}

/*
 * audio1575_dma_stop()
 *
 * Description:
 *      This routine is used to put each DMA engine into the quiet state.
 *
 * Arguments:
 *      audio1575_state_t *statep       The device's state structure
 */
static void
audio1575_dma_stop(audio1575_state_t *statep, boolean_t quiesce)
{
        uint32_t        intrsr;
        int             i;

        if (statep->regsh == NULL) {
                return;
        }

        /* pause bus master (needed for the following reset register) */
        for (i = 0; i < M1575_LOOP_CTR; i++) {

                SET32(M1575_DMACR_REG, M1575_DMACR_PAUSE_ALL);
                if (GET32(M1575_DMACR_REG) & M1575_DMACR_PAUSE_ALL) {
                        break;
                }
                drv_usecwait(10);
        }

        if (i >= M1575_LOOP_CTR) {
                if (!quiesce)
                        audio_dev_warn(statep->adev, "failed to stop DMA");
                return;
        }

        /* Pause bus master (needed for the following reset register) */
        PUT8(M1575_PCMICR_REG, 0);
        PUT8(M1575_PCMOCR_REG, 0);
        PUT8(M1575_MICICR_REG, 0);
        PUT8(M1575_CSPOCR_REG, 0);
        PUT8(M1575_PCMI2CR_RR, 0);
        PUT8(M1575_MICI2CR_RR, 0);

        /* Reset the bus master registers for all DMA engines */
        PUT8(M1575_PCMICR_REG, M1575_PCMICR_RR);
        PUT8(M1575_PCMOCR_REG, M1575_PCMOCR_RR);
        PUT8(M1575_MICICR_REG, M1575_MICICR_RR);
        PUT8(M1575_CSPOCR_REG, M1575_CSPOCR_RR);
        PUT8(M1575_PCMI2CR_REG, M1575_PCMI2CR_RR);
        PUT8(M1575_MICI2CR_REG, M1575_MICI2CR_RR);

        /* Reset FIFOS */
        PUT32(M1575_FIFOCR1_REG, 0x81818181);
        PUT32(M1575_FIFOCR2_REG, 0x81818181);
        PUT32(M1575_FIFOCR3_REG, 0x81818181);

        /* Clear Interrupts */
        SET16(M1575_PCMISR_REG, M1575_SR_CLR);
        SET16(M1575_PCMOSR_REG, M1575_SR_CLR);
        SET16(M1575_MICISR_REG, M1575_SR_CLR);
        SET16(M1575_CSPOSR_REG, M1575_SR_CLR);
        SET16(M1575_PCMI2SR_REG, M1575_SR_CLR);
        SET16(M1575_MICI2SR_REG, M1575_SR_CLR);

        /*
         * clear the interrupt control and status register
         * READ/WRITE/READ workaround required to flush PCI caches
         */

        PUT32(M1575_INTRCR_REG, 0);
        (void) GET32(M1575_INTRCR_REG);

        intrsr = GET32(M1575_INTRSR_REG);
        PUT32(M1575_INTRSR_REG, (intrsr & M1575_INTR_MASK));
        (void) GET32(M1575_INTRSR_REG);
}

/*
 * audio1575_codec_sync()
 *
 * Description:
 *      Serialize access to the AC97 audio mixer registers.
 *
 * Arguments:
 *      audio1575_state_t       *state          The device's state structure
 *
 * Returns:
 *      DDI_SUCCESS             Ready for an I/O access to the codec
 *      DDI_FAILURE             An I/O access is currently in progress, can't
 *                              perform another I/O access.
 */
static int
audio1575_codec_sync(audio1575_state_t *statep)
{
        /* do the Uli Shuffle ... */
        for (int i = 0; i < M1575_LOOP_CTR; i++) {
                /* Read the semaphore, and loop till we own it */
                if ((GET32(M1575_CASR_REG) & 1) == 0) {
                        for (int j = 0; j < M1575_LOOP_CTR; j++) {
                                /* Wait for CWRSUCC 0x8 */
                                if (GET32(M1575_CSPSR_REG) &
                                    M1575_CSPSR_SUCC) {
                                        return (DDI_SUCCESS);
                                }
                                drv_usecwait(1);
                        }
                }
                drv_usecwait(10);
        }

        return (DDI_FAILURE);
}

/*
 * audio1575_write_ac97()
 *
 * Description:
 *      Set the specific AC97 Codec register.
 *
 * Arguments:
 *      void            *arg            The device's state structure
 *      uint8_t         reg             AC97 register number
 *      uint16_t        data            The data want to be set
 */
static void
audio1575_write_ac97(void *arg, uint8_t reg, uint16_t data)
{
        audio1575_state_t       *statep = arg;
        int                     i;

        if (audio1575_codec_sync(statep) != DDI_SUCCESS) {
                return;
        }

        /* write the data to WRITE to the lo word of the CPR register */
        PUT16(M1575_CPR_REG, data);

        /* write the address to WRITE to the hi word of the CPR register */
        PUT16(M1575_CPR_REG+2, reg);

        /* wait until command is completed sucessfully */
        for (i = 0; i < M1575_LOOP_CTR; i++) {
                /* Wait for Write Ready 0x01 */
                if (GET32(M1575_CSPSR_REG) & M1575_CSPSR_WRRDY) {
                        break;
                }
                drv_usecwait(1);
        }

        if (i < M1575_LOOP_CTR) {
                (void) audio1575_read_ac97(statep, reg);
        }
}

/*
 * audio1575_read_ac97()
 *
 * Description:
 *      Get the specific AC97 Codec register. It also updates codec_shadow[]
 *      with the register value.
 *
 * Arguments:
 *      void            *arg            The device's state structure
 *      uint8_t         reg             AC97 register number
 *
 * Returns:
 *      Value of AC97 register.  (0xffff in failure situations).
 */
static uint16_t
audio1575_read_ac97(void *arg, uint8_t reg)
{
        audio1575_state_t       *statep = arg;
        uint16_t                addr = 0;
        uint16_t                data = 0xffff;
        int                     i;

        if ((audio1575_codec_sync(statep)) != DDI_SUCCESS) {
                return (data);
        }

        /*
         * at this point we have the CASR semaphore
         * and the codec is r/w ready
         * OR in the READ opcode into the address field
         */

        addr = (reg | M1575_CPR_READ);

        /* write the address to READ to the hi word of the CPR register */
        PUT16(M1575_CPR_REG+2, addr);

        /* wait until command is completed sucessfully */
        for (i = 0; i < M1575_LOOP_CTR; i++) {
                /* Wait for Read Ready  0x02 */
                if (GET32(M1575_CSPSR_REG) & M1575_CSPSR_RDRDY) {
                        break;
                }
                drv_usecwait(1);
        }

        if (i < M1575_LOOP_CTR) {
                /* read back the data and address */
                data = GET16(M1575_SPR_REG);
                addr = GET16(M1575_SPR_REG+2);
                if (addr != reg) {
                        data = 0xffff;
                }
        }

        return (data);
}

/*
 * audio1575_pci_enable()
 *
 * Description:
 *      This routine Enables all PCI IO and MEMORY accesses
 *
 * Arguments:
 *      audio1575_state_t *statep        The device's state structure
 */
static void
audio1575_pci_enable(audio1575_state_t *statep)
{
        uint16_t pcics_reg;

        pcics_reg = pci_config_get16(statep->pcih, PCI_CONF_COMM);
        pcics_reg |= (PCI_COMM_IO | PCI_COMM_MAE | PCI_COMM_ME);
        pci_config_put16(statep->pcih, PCI_CONF_COMM, pcics_reg);
}

/*
 * audio1575_pci_disable()
 *
 * Description:
 *      This routine Disables all PCI IO and MEMORY accesses
 *
 * Arguments:
 *      audio1575_state_t *statep       The device's state structure
 */
static void
audio1575_pci_disable(audio1575_state_t *statep)
{
        uint16_t pcics_reg;

        if (statep->pcih == NULL)
                return;
        pcics_reg = pci_config_get16(statep->pcih, PCI_CONF_COMM);
        pcics_reg &= ~(PCI_COMM_IO | PCI_COMM_MAE | PCI_COMM_ME);
        pci_config_put16(statep->pcih, PCI_CONF_COMM, pcics_reg);
}

/*
 * audio1575_resume()
 *
 * Description:
 *      Resume operation of the device after sleeping or hibernating.
 *      Note that this should never fail, even if hardware goes wonky,
 *      because the current PM framework will panic if it does.
 *
 * Arguments:
 *      dev_info_t      *dip    Pointer to the device's dev_info struct
 *
 * Returns:
 *      DDI_SUCCESS             The driver was resumed
 */
static int
audio1575_resume(dev_info_t *dip)
{
        audio1575_state_t       *statep;
        audio_dev_t             *adev;

        /* we've already allocated the state structure so get ptr */
        statep = ddi_get_driver_private(dip);
        adev = statep->adev;
        ASSERT(!mutex_owned(&statep->lock));

        if (audio1575_chip_init(statep) != DDI_SUCCESS) {
                /*
                 * Note that PM gurus say we should return
                 * success here.  Failure of audio shouldn't
                 * be considered FATAL to the system.  The
                 * upshot is that audio will not progress.
                 */
                audio_dev_warn(adev, "DDI_RESUME failed to init chip");
                return (DDI_SUCCESS);
        }

        /* allow ac97 operations again */
        ac97_reset(statep->ac97);

        audio_dev_resume(adev);

        return (DDI_SUCCESS);
}

/*
 * audio1575_suspend()
 *
 * Description:
 *      Suspend an instance of the audio1575 driver.
 *
 * Arguments:
 *      dev_info_t      *dip    Pointer to the device's dev_info struct
 *
 * Returns:
 *      DDI_SUCCESS     The driver was suspended
 */
static int
audio1575_suspend(dev_info_t *dip)
{
        audio1575_state_t       *statep;

        statep = ddi_get_driver_private(dip);

        audio_dev_suspend(statep->adev);

        return (DDI_SUCCESS);
}

/*
 * audio1575_destroy()
 *
 * Description:
 *      This routine releases all resources held by the device instance,
 *      as part of either detach or a failure in attach.
 *
 * Arguments:
 *      audio1575_state_t       *state  The device soft state.
 */
void
audio1575_destroy(audio1575_state_t *statep)
{
        ddi_acc_handle_t        pcih;

        /* stop DMA engines */
        audio1575_dma_stop(statep, B_FALSE);

        if (statep->regsh != NULL) {
                /* reset the codec */
                PUT32(M1575_SCR_REG, M1575_SCR_COLDRST);
        }

        if ((pcih = statep->pcih) != NULL) {
                /* turn off the AC_LINK clock */
                pci_config_put8(pcih, M1575_PCIACD_REG, 0);
                pci_config_put8(pcih, M1575_PCIACD_REG, 4);
                pci_config_put8(pcih, M1575_PCIACD_REG, 0);
        }

        /* Disable PCI I/O and Memory Spaces */
        audio1575_pci_disable(statep);

        audio1575_free_port(statep->ports[M1575_PLAY]);
        audio1575_free_port(statep->ports[M1575_REC]);

        audio1575_unmap_regs(statep);

        if (statep->ac97 != NULL) {
                ac97_free(statep->ac97);
        }

        if (statep->adev != NULL) {
                audio_dev_free(statep->adev);
        }

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