drv/audiocmihd/audiocmihd.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Purpose: Driver for the CMedia 8788 sound card
 */
/*
 *
 * Copyright (C) 4Front Technologies 1996-2011.
 *
 * 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/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/sysmacros.h>
#include <sys/note.h>
#include <sys/audio/audio_driver.h>
#include <sys/audio/ac97.h>

#include "audiocmihd.h"

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
};

static ddi_dma_attr_t dma_attr_buf = {
    DMA_ATTR_V0,        /* version number */
    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 */
};


static int cmediahd_attach(dev_info_t *);
static int cmediahd_resume(dev_info_t *);
static int cmediahd_detach(cmediahd_devc_t *);
static int cmediahd_suspend(cmediahd_devc_t *);

static int cmediahd_open(void *, int, unsigned *, caddr_t *);
static void cmediahd_close(void *);
static int cmediahd_start(void *);
static void cmediahd_stop(void *);
static int cmediahd_format(void *);
static int cmediahd_channels(void *);
static int cmediahd_rate(void *);
static uint64_t cmediahd_count(void *);
static void cmediahd_sync(void *, unsigned);
static void cmediahd_chinfo(void *, int, unsigned *, unsigned *);


static uint16_t cmediahd_read_ac97(void *, uint8_t);
static void cmediahd_write_ac97(void *, uint8_t, uint16_t);
static int cmediahd_alloc_port(cmediahd_devc_t *, int);
static void cmediahd_reset_port(cmediahd_portc_t *);
static void cmediahd_destroy(cmediahd_devc_t *);
static void cmediahd_hwinit(cmediahd_devc_t *);
static void cmediahd_refresh_mixer(cmediahd_devc_t *devc);
static uint32_t mix_scale(uint32_t, int8_t);
static void cmediahd_ac97_hwinit(cmediahd_devc_t *);
static void cmediahd_del_controls(cmediahd_devc_t *);


static audio_engine_ops_t cmediahd_engine_ops = {
    AUDIO_ENGINE_VERSION,
    cmediahd_open,
    cmediahd_close,
    cmediahd_start,
    cmediahd_stop,
    cmediahd_count,
    cmediahd_format,
    cmediahd_channels,
    cmediahd_rate,
    cmediahd_sync,
    NULL,   /* qlen */
    cmediahd_chinfo,
    NULL    /* playahead */
};

#define PLAYCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_PLAY)
#define RECCTL  (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_REC)
#define MONCTL  (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_MONITOR)
#define PCMVOL  (PLAYCTL | AUDIO_CTRL_FLAG_PCMVOL)
#define MAINVOL (PLAYCTL | AUDIO_CTRL_FLAG_MAINVOL)
#define RECVOL  (RECCTL | AUDIO_CTRL_FLAG_RECVOL)

static const char mix_cvt[101] = {
    0, 0, 3, 7, 10, 13, 16, 19,
    21, 23, 26, 28, 30, 32, 34, 35,
    37, 39, 40, 42, 43, 45, 46, 47,
    49, 50, 51, 52, 53, 55, 56, 57,
    58, 59, 60, 61, 62, 63, 64, 65,
    65, 66, 67, 68, 69, 70, 70, 71,
    72, 73, 73, 74, 75, 75, 76, 77,
    77, 78, 79, 79, 80, 81, 81, 82,
    82, 83, 84, 84, 85, 85, 86, 86,
    87, 87, 88, 88, 89, 89, 90, 90,
    91, 91, 92, 92, 93, 93, 94, 94,
    95, 95, 96, 96, 96, 97, 97, 98,
    98, 98, 99, 99, 100
};

static uint32_t
mix_scale(uint32_t vol, int8_t bits)
{
    vol = mix_cvt[vol];
    vol = (vol * ((1 << bits) - 1)) / 100;
    return (vol);
}

static uint16_t
cmediahd_read_ac97(void *arg, uint8_t reg)
{
    cmediahd_devc_t *devc = arg;
    uint32_t val;
    uint16_t data;

    mutex_enter(&devc->low_mutex);
    val = 0L;
    val |= reg << 16;
    val |= 0 << 24;         /* codec 0 or codec 1 */
    val |= 1 << 23;         /* ac97 read the reg address */
    OUTL(devc, val, AC97_CMD_DATA);
    drv_usecwait(100);
    data = INL(devc, AC97_CMD_DATA) & 0xFFFF;
    mutex_exit(&devc->low_mutex);
    return (data);
}

static void
cmediahd_write_ac97(void *arg, uint8_t reg, uint16_t data)
{
    cmediahd_devc_t *devc = arg;
    uint32_t val;

    mutex_enter(&devc->low_mutex);
    val = 0L;
    val |= reg << 16;
    val |= data & 0xFFFF;
    val |= 0 << 24;         /* on board codec or frontpanel */
    val |= 0 << 23;         /* ac97 write operation */
    OUTL(devc, val, AC97_CMD_DATA);
    drv_usecwait(100);
    mutex_exit(&devc->low_mutex);
}

#if 0   /* Front Panel AC'97 not supported yet */
static uint16_t
cmediahd_read_fp_ac97(void *arg, uint8_t reg)
{
    cmediahd_devc_t *devc = arg;
    uint32_t val;
    uint16_t data;

    mutex_enter(&devc->low_mutex);
    val = 0L;
    val |= 1 << 24;         /* front panel */
    val |= 1 << 23;         /* ac97 read the reg address */
    val |= reg << 16;
    OUTL(devc, val, AC97_CMD_DATA);
    drv_usecwait(100);
    data = INL(devc, AC97_CMD_DATA) & 0xFFFF;
    mutex_exit(&devc->low_mutex);

    return (data);
}

static void
cmediahd_write_fp_ac97(void *arg, uint8_t reg, uint16_t data)
{
    cmediahd_devc_t *devc = arg;
    uint32_t val;

    mutex_enter(&devc->low_mutex);
    val = 0L;
    val |= 1 << 24;         /* frontpanel */
    val |= 0 << 23;         /* ac97 write operation */
    val |= reg << 16;
    val |= data & 0xFFFF;
    OUTL(devc, val, AC97_CMD_DATA);
    drv_usecwait(100);
    mutex_exit(&devc->low_mutex);
}
#endif

static void
spi_write(void *arg, int codec_num, unsigned char reg, int val)
{
    cmediahd_devc_t *devc = arg;
    unsigned int tmp;
    int latch, shift, count;

    mutex_enter(&devc->low_mutex);

    /* check if SPI is busy */
    count = 10;
    while ((INB(devc, SPI_CONTROL) & 0x1) && count-- > 0) {
        drv_usecwait(10);
    }

    if (devc->model == SUBID_XONAR_DS) {
        shift = 9;
        latch = 0;
    } else {
        shift = 8;
        latch = 0x80;
    }

    /* 2 byte data/reg info to be written */
    tmp = val;
    tmp |= (reg << shift);

    /* write 2-byte data values */
    OUTB(devc, tmp & 0xff, SPI_DATA + 0);
    OUTB(devc, (tmp >> 8) & 0xff, SPI_DATA + 1);

    /* Latch high, clock=160, Len=2byte, mode=write */
    tmp = (INB(devc, SPI_CONTROL) & ~0x7E) | latch | 0x1;

    /* now address which codec you want to send the data to */
    tmp |= (codec_num << 4);

    /* send the command to write the data */
    OUTB(devc, tmp, SPI_CONTROL);

    mutex_exit(&devc->low_mutex);
}

static void
i2c_write(void *arg, unsigned char codec_num, unsigned char reg,
    unsigned char data)
{
    cmediahd_devc_t *devc = arg;
    int count = 50;

    /* Wait for it to stop being busy */
    mutex_enter(&devc->low_mutex);
    while ((INW(devc, TWO_WIRE_CTRL) & 0x1) && (count > 0)) {
        drv_usecwait(10);
        count--;
    }

    if (count == 0) {
        audio_dev_warn(devc->adev, "Time out on Two-Wire interface");
        mutex_exit(&devc->low_mutex);
        return;
    }

    /* first write the Register Address into the MAP register */
    OUTB(devc, reg, TWO_WIRE_MAP);

    /* now write the data */
    OUTB(devc, data, TWO_WIRE_DATA);

    /* select the codec number to address */
    OUTB(devc, codec_num, TWO_WIRE_ADDR);

    mutex_exit(&devc->low_mutex);
}

static void
cs4398_init(void *arg, int codec)
{
    cmediahd_devc_t *devc = arg;

    /* Fast Two-Wire. Reduces the wire ready time. */
    OUTW(devc, 0x0100, TWO_WIRE_CTRL);

    /* Power down, enable control mode. */
    i2c_write(devc, codec, CS4398_MISC_CTRL,
        CS4398_CPEN | CS4398_POWER_DOWN);
    /*
     * Left justified PCM (DAC and 8788 support I2S, but doesn't work.
     * Setting it introduces clipping like hell).
     */
    i2c_write(devc, codec, CS4398_MODE_CTRL, 0x00);
    i2c_write(devc, codec, 3, 0x09);
    i2c_write(devc, codec, 4, 0x82);    /* PCM Automute */
    i2c_write(devc, codec, 5, 0x80);    /* Vol A+B to -64dB */
    i2c_write(devc, codec, 6, 0x80);
    i2c_write(devc, codec, 7, 0xf0);    /* soft ramping on */

    /* remove the powerdown flag */
    i2c_write(devc, codec, CS4398_MISC_CTRL, CS4398_CPEN);
}


static void
cs4362a_init(void *arg, int codec)
{

    cmediahd_devc_t *devc = arg;

    OUTW(devc, 0x0100, TWO_WIRE_CTRL);

    /* Power down and enable control port. */
    i2c_write(devc, codec, CS4362A_MODE1_CTRL,
        CS4362A_CPEN | CS4362A_POWER_DOWN);
    /* Left-justified PCM */
    i2c_write(devc, codec, CS4362A_MODE2_CTRL, CS4362A_DIF_LJUST);
    /* Ramp & Automute, re-set DAC defaults. */
    i2c_write(devc, codec, CS4362A_MODE3_CTRL, 0x84);
    /* Filter control, DAC defs. */
    i2c_write(devc, codec, CS4362A_FILTER_CTRL, 0);
    /* Invert control, DAC defs. */
    i2c_write(devc, codec, CS4362A_INVERT_CTRL, 0);
    /* Mixing control, DAC defs. */
    i2c_write(devc, codec, CS4362A_MIX1_CTRL, 0x24);
    i2c_write(devc, codec, CS4362A_MIX2_CTRL, 0x24);
    i2c_write(devc, codec, CS4362A_MIX3_CTRL, 0x24);
    /* Volume to -64dB. */
    i2c_write(devc, codec, CS4362A_VOLA_1, 0x40);
    i2c_write(devc, codec, CS4362A_VOLB_1, 0x40);
    i2c_write(devc, codec, CS4362A_VOLA_2, 0x40);
    i2c_write(devc, codec, CS4362A_VOLB_2, 0x40);
    i2c_write(devc, codec, CS4362A_VOLA_3, 0x40);
    i2c_write(devc, codec, CS4362A_VOLB_3, 0x40);
    /* Power up. */
    i2c_write(devc, codec, CS4362A_MODE1_CTRL, CS4362A_CPEN);
}


static void
cmediahd_generic_set_play_volume(cmediahd_devc_t *devc, int codec_id,
    int left, int right)

{
    spi_write(devc, codec_id, AK4396_LchATTCtl | 0x20, mix_scale(left, 8));
    spi_write(devc, codec_id, AK4396_RchATTCtl | 0x20, mix_scale(right, 8));
}

static void
xonar_d1_set_play_volume(cmediahd_devc_t *devc, int codec_id,
    int left, int right)
{
    switch (codec_id) {
    case 0:
        i2c_write(devc, XONAR_DX_FRONTDAC, CS4398_VOLA,
            CS4398_VOL(left));
        i2c_write(devc, XONAR_DX_FRONTDAC, CS4398_VOLB,
            CS4398_VOL(right));
        break;
    case 1:
        i2c_write(devc, XONAR_DX_SURRDAC, CS4362A_VOLA_1,
            CS4362A_VOL(left));
        i2c_write(devc, XONAR_DX_SURRDAC, CS4362A_VOLB_1,
            CS4362A_VOL(right));
        break;
    case 2:
        i2c_write(devc, XONAR_DX_SURRDAC, CS4362A_VOLA_2,
            CS4362A_VOL(left));
        i2c_write(devc, XONAR_DX_SURRDAC, CS4362A_VOLB_2,
            CS4362A_VOL(right));
        break;
    case 3:
        i2c_write(devc, XONAR_DX_SURRDAC, CS4362A_VOLA_3,
            CS4362A_VOL(left));
        i2c_write(devc, XONAR_DX_SURRDAC, CS4362A_VOLB_3,
            CS4362A_VOL(right));
        break;
    }
}

static void
xonar_d2_set_play_volume(cmediahd_devc_t *devc, int codec_id,
    int left, int right)
{
    spi_write(devc, xd2_codec_map[codec_id], 16, mix_scale(left, 8));
    spi_write(devc, xd2_codec_map[codec_id], 17, mix_scale(right, 8));
}

static void
xonar_stx_set_play_volume(cmediahd_devc_t *devc, int codec_id,
    int left, int right)
{
    if (codec_id == 0) {
        i2c_write(devc, XONAR_STX_FRONTDAC, 16, mix_scale(left, 8));
        i2c_write(devc, XONAR_STX_FRONTDAC, 17, mix_scale(right, 8));
    }
}

static void
xonar_ds_set_play_volume(cmediahd_devc_t *devc, int codec_id,
    int left, int right)
{
    switch (codec_id) {
    case 0:     /* front */
        spi_write(devc, XONAR_DS_FRONTDAC, 0,
            mix_scale(left, 7) | 0x180);
        spi_write(devc, XONAR_DS_FRONTDAC, 1,
            mix_scale(right, 7) | 0x180);
        spi_write(devc, XONAR_DS_FRONTDAC, 3,
            mix_scale(left, 7) |0x180);
        spi_write(devc, XONAR_DS_FRONTDAC, 4,
            mix_scale(right, 7) | 0x180);
        break;

    case 1:     /* side */
        spi_write(devc, XONAR_DS_SURRDAC, 0,
            mix_scale(left, 7) | 0x180);
        spi_write(devc, XONAR_DS_SURRDAC, 1,
            mix_scale(right, 7) | 0x180);
        break;
    case 2:     /* rear */
        spi_write(devc, XONAR_DS_SURRDAC, 4,
            mix_scale(left, 7) | 0x180);
        spi_write(devc, XONAR_DS_SURRDAC, 5,
            mix_scale(right, 7) | 0x180);
        break;
    case 3:     /* center */
        spi_write(devc, XONAR_DS_SURRDAC, 6,
            mix_scale(left, 7) | 0x180);
        spi_write(devc, XONAR_DS_SURRDAC, 7,
            mix_scale(right, 7) | 0x180);
        break;
    }
}

static void
cmediahd_set_rec_volume(cmediahd_devc_t *devc, int value)
{
    unsigned char left, right;

    left = (value >> 8) & 0xff;
    right = value & 0xff;

    if (left > 100)
        left = 100;
    if (right > 100)
        right = 100;

    spi_write(devc, XONAR_DS_FRONTDAC, 0xe, mix_scale(left, 8));
    spi_write(devc, XONAR_DS_FRONTDAC, 0xf, mix_scale(right, 8));
}

static void
cmediahd_set_play_volume(cmediahd_devc_t *devc, int codec_id, int value)
{
    int left, right;

    left = (value >> 8) & 0xFF;
    right = (value & 0xFF);

    if (left > 100)
        left = 100;
    if (right > 100)
        right = 100;

    switch (devc->model) {
    case SUBID_XONAR_D1:
    case SUBID_XONAR_DX:
        xonar_d1_set_play_volume(devc, codec_id, left, right);
        break;
    case SUBID_XONAR_D2:
    case SUBID_XONAR_D2X:
        xonar_d2_set_play_volume(devc, codec_id, left, right);
        break;
    case SUBID_XONAR_STX:
        xonar_stx_set_play_volume(devc, codec_id, left, right);
        break;
    case SUBID_XONAR_DS:
        xonar_ds_set_play_volume(devc, codec_id, left, right);
        break;
    default:
        cmediahd_generic_set_play_volume(devc, codec_id, left, right);
        break;
    }
}

/*
 * Audio routines
 */

int
cmediahd_open(void *arg, int flag, unsigned *nframesp, caddr_t *bufp)
{
    cmediahd_portc_t *portc = arg;

        _NOTE(ARGUNUSED(flag));

    portc->count = 0;

    *nframesp = portc->nframes;
    *bufp = portc->kaddr;

    return (0);
}

void
cmediahd_close(void *arg)
{
        _NOTE(ARGUNUSED(arg));
}

int
cmediahd_start(void *arg)
{
    cmediahd_portc_t    *portc = arg;
    cmediahd_devc_t     *devc = portc->devc;

    mutex_enter(&devc->mutex);
    portc->offset = 0;

    cmediahd_reset_port(portc);

    switch (portc->direction) {
    case CMEDIAHD_PLAY:
        /* enable the dma */
        OUTW(devc, INW(devc, DMA_START) | 0x10, DMA_START);
        break;

    case CMEDIAHD_REC:
        /* enable the channel */
        OUTW(devc, INW(devc, DMA_START) | (1<<devc->rec_eng.chan),
            DMA_START);
        break;
    }

    mutex_exit(&devc->mutex);
    return (0);
}

void
cmediahd_stop(void *arg)
{
    cmediahd_portc_t    *portc = arg;
    cmediahd_devc_t     *devc = portc->devc;

    mutex_enter(&devc->mutex);
    switch (portc->direction) {
    case CMEDIAHD_PLAY:
        /* disable dma */
        OUTW(devc, INW(devc, DMA_START) & ~0x10, DMA_START);
        break;

    case CMEDIAHD_REC:
        /* disable dma */
        OUTW(devc, INW(devc, DMA_START) & ~(1<<devc->rec_eng.chan),
            DMA_START);
        break;
    }
    mutex_exit(&devc->mutex);
}

int
cmediahd_format(void *arg)
{
    _NOTE(ARGUNUSED(arg));

    return (AUDIO_FORMAT_S16_LE);
}

int
cmediahd_channels(void *arg)
{
    cmediahd_portc_t    *portc = arg;

    return (portc->chans);
}

int
cmediahd_rate(void *arg)
{
    _NOTE(ARGUNUSED(arg));

    return (48000);
}

void
cmediahd_sync(void *arg, unsigned nframes)
{
    cmediahd_portc_t *portc = arg;
    _NOTE(ARGUNUSED(nframes));

    (void) ddi_dma_sync(portc->buf_dmah, 0, 0, portc->syncdir);
}

static void
cmediahd_chinfo(void *arg, int chan, unsigned *offset, unsigned *incr)
{
    cmediahd_portc_t *portc = arg;
    static const int map8ch[] = { 0, 1, 4, 5, 2, 3, 6, 7 };
    static const int map4ch[] = { 0, 1, 2, 3 };

    if (portc->chans <= 4) {
        *offset = map4ch[chan];
    } else {
        *offset = map8ch[chan];
    }
    *incr = portc->chans;
}

uint64_t
cmediahd_count(void *arg)
{
    cmediahd_portc_t    *portc = arg;
    cmediahd_devc_t *devc = portc->devc;
    uint64_t    count;
    uint32_t    offset;

    mutex_enter(&devc->mutex);

    if (portc->direction == CMEDIAHD_PLAY)
        offset = portc->bufsz/4 - INL(devc, MULTICH_SIZE) + 1;
    else
        offset = portc->bufsz/4 - INW(devc, devc->rec_eng.size) + 1;

    /* check for wrap */
    if (offset < portc->offset) {
        count = ((portc->bufsz/4) - portc->offset) + offset;
    } else {
        count = offset - portc->offset;
    }
    portc->count += count;
    portc->offset = offset;

    /* convert from 16-bit stereo */
    count = portc->count / (portc->chans/2);
    mutex_exit(&devc->mutex);

    return (count);
}

/* private implementation bits */


void
cmediahd_reset_port(cmediahd_portc_t *portc)
{
    cmediahd_devc_t *devc = portc->devc;
    int channels;

    if (devc->suspended)
        return;

    portc->offset = 0;

    switch (portc->direction) {

    case CMEDIAHD_PLAY:
        /* reset channel */
        OUTB(devc, INB(devc, CHAN_RESET)|0x10, CHAN_RESET);
        drv_usecwait(10);
        OUTB(devc, INB(devc, CHAN_RESET) & ~0x10, CHAN_RESET);
        drv_usecwait(10);

        OUTL(devc, portc->paddr,  MULTICH_ADDR);
        OUTL(devc, (portc->bufsz/4) - 1, MULTICH_SIZE);
        OUTL(devc, (portc->bufsz/4) - 1, MULTICH_FRAG);

        switch (portc->chans) {
        case 2:
            channels = 0;
            break;
        case 4:
            channels = 1;
            break;
        case 6:
            channels = 2;
            break;
        case 8:
            channels = 3;
            break;
        }
        OUTB(devc, (INB(devc, MULTICH_MODE) & ~0x3) | channels,
            MULTICH_MODE);

        /* set the format bits in play format register */
        OUTB(devc, (INB(devc, PLAY_FORMAT) & ~0xC) | 0x0, PLAY_FORMAT);
        break;

    case CMEDIAHD_REC:
        OUTB(devc, INB(devc, CHAN_RESET) | (1 << devc->rec_eng.chan),
            CHAN_RESET);
        drv_usecwait(10);
        OUTB(devc, INB(devc, CHAN_RESET) & ~(1 << devc->rec_eng.chan),
            CHAN_RESET);
        drv_usecwait(10);

        OUTL(devc, portc->paddr,  devc->rec_eng.addr);
        OUTW(devc, (portc->bufsz/4) - 1, devc->rec_eng.size);
        OUTW(devc, (portc->bufsz/4) - 1, devc->rec_eng.frag);


        switch (portc->chans) {
        case 2:
            channels = 0x0;
            break;
        case 4:
            channels = 0x1;
            break;
        case 6:
            channels = 0x2;
            break;
        case 8:
            channels = 0x4;
            break;
        default:
            /* Stereo - boomer only supports stereo */
            channels = 0x0;
            break;
        }

        OUTB(devc, (INB(devc, REC_MODE) & ~0x3) | channels, REC_MODE);
        OUTB(devc, (INB(devc, REC_FORMAT) & ~0x3) | 0x0, REC_FORMAT);

    }
}

int
cmediahd_alloc_port(cmediahd_devc_t *devc, int num)
{
    cmediahd_portc_t    *portc;
    size_t          len;
    ddi_dma_cookie_t    cookie;
    uint_t          count;
    int         dir;
    unsigned        caps;
    audio_dev_t     *adev;

    adev = devc->adev;
    portc = kmem_zalloc(sizeof (*portc), KM_SLEEP);
    devc->portc[num] = portc;
    portc->devc = devc;
    portc->direction = num;

    switch (num) {
    case CMEDIAHD_REC:
        portc->syncdir = DDI_DMA_SYNC_FORKERNEL;
        portc->chans = 2;
        caps = ENGINE_INPUT_CAP;
        dir = DDI_DMA_READ;
        break;
    case CMEDIAHD_PLAY:
        portc->syncdir = DDI_DMA_SYNC_FORDEV;
        portc->chans = 8;
        caps = ENGINE_OUTPUT_CAP;
        dir = DDI_DMA_WRITE;
        break;
    default:
        return (DDI_FAILURE);
    }

    /*
     * Calculate buffer size and frames
     */
    portc->nframes = 2048;
    portc->bufsz = portc->nframes * portc->chans * 2;

    /* Alloc buffers */
    if (ddi_dma_alloc_handle(devc->dip, &dma_attr_buf, DDI_DMA_SLEEP, NULL,
        &portc->buf_dmah) != DDI_SUCCESS) {
        audio_dev_warn(adev, "failed to allocate BUF handle");
        return (DDI_FAILURE);
    }

    if (ddi_dma_mem_alloc(portc->buf_dmah, CMEDIAHD_BUF_LEN,
        &buf_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
        &portc->kaddr, &len, &portc->buf_acch) != DDI_SUCCESS) {
        audio_dev_warn(adev, "failed to allocate BUF memory");
        return (DDI_FAILURE);
    }

    bzero(portc->kaddr, len);

    if (ddi_dma_addr_bind_handle(portc->buf_dmah, NULL, portc->kaddr,
        len, DDI_DMA_CONSISTENT | dir, DDI_DMA_SLEEP, NULL, &cookie,
        &count) != DDI_SUCCESS) {
        audio_dev_warn(adev, "failed binding BUF DMA handle");
        return (DDI_FAILURE);
    }
    portc->paddr = cookie.dmac_address;

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

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

    return (DDI_SUCCESS);
}

void
cmediahd_destroy(cmediahd_devc_t *devc)
{
    mutex_destroy(&devc->mutex);
    mutex_destroy(&devc->low_mutex);

    for (int i = 0; i < CMEDIAHD_NUM_PORTC; i++) {
        cmediahd_portc_t *portc = devc->portc[i];
        if (!portc)
            continue;
        if (portc->engine) {
            audio_dev_remove_engine(devc->adev, portc->engine);
            audio_engine_free(portc->engine);
        }
        if (portc->paddr) {
            (void) ddi_dma_unbind_handle(portc->buf_dmah);
        }
        if (portc->buf_acch) {
            ddi_dma_mem_free(&portc->buf_acch);
        }
        if (portc->buf_dmah) {
            ddi_dma_free_handle(&portc->buf_dmah);
        }
        kmem_free(portc, sizeof (*portc));
    }

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

    cmediahd_del_controls(devc);

    if (devc->adev != NULL) {
        audio_dev_free(devc->adev);
    }
    if (devc->regsh != NULL) {
        ddi_regs_map_free(&devc->regsh);
    }
    if (devc->pcih != NULL) {
        pci_config_teardown(&devc->pcih);
    }
    kmem_free(devc, sizeof (*devc));
}

void
cmediahd_ac97_hwinit(cmediahd_devc_t *devc)
{
    /* GPIO #0 programmed as output, set CMI9780 Reg0x70 */
    cmediahd_write_ac97(devc, 0x70, 0x100);

    /* LI2LI,MIC2MIC; let them always on, FOE on, ROE/BKOE/CBOE off */
    cmediahd_write_ac97(devc, 0x62, 0x180F);

    /* unmute Master Volume */
    cmediahd_write_ac97(devc, 0x02, 0x0);

    /* change PCBeep path, set Mix2FR on, option for quality issue */
    cmediahd_write_ac97(devc, 0x64, 0x8043);

    /* mute PCBeep, option for quality issues */
    cmediahd_write_ac97(devc, 0x0A, 0x8000);

    /* Record Select Control Register (Index 1Ah) */
    cmediahd_write_ac97(devc, 0x1A, 0x0000);

    /* set Mic Volume Register 0x0Eh umute and enable micboost */
    cmediahd_write_ac97(devc, 0x0E, 0x0848);

    /* set Line in Volume Register 0x10h mute */
    cmediahd_write_ac97(devc, 0x10, 0x8808);

    /* set CD Volume Register 0x12h mute */
    cmediahd_write_ac97(devc, 0x12, 0x8808);

    /* set AUX Volume Register 0x16h max */
    cmediahd_write_ac97(devc, 0x16, 0x0808);

    /* set record gain Register 0x1Ch to max */
    cmediahd_write_ac97(devc, 0x1C, 0x0F0F);

    /* GPIO status  register enable GPO0 */
    cmediahd_write_ac97(devc, 0x72, 0x0001);
}
void
cmediahd_hwinit(cmediahd_devc_t *devc)
{

    unsigned short sVal;
    unsigned short i2s_fmt;
    unsigned char bVal;
    int i, count;

    /* setup the default rec DMA engines to REC_A */
    devc->rec_eng.addr = RECA_ADDR;
    devc->rec_eng.size = RECA_SIZE;
    devc->rec_eng.frag = RECA_FRAG;
    devc->rec_eng.i2s = I2S_ADC1;
    devc->rec_eng.chan = REC_A;

    /* setup GPIOs to 0 */
    devc->gpio_mic = 0;
    devc->gpio_out = 0;
    devc->gpio_codec = 0;
    devc->gpio_alt = 0;

    /* Init CMI Controller */
    sVal = INW(devc, CTRL_VERSION);
    if (!(sVal & 0x0008)) {
        bVal = INB(devc, MISC_REG);
        bVal |= 0x20;
        OUTB(devc, bVal, MISC_REG);
    }

    bVal = INB(devc, FUNCTION);
    bVal |= 0x02; /* Reset codec */
    OUTB(devc, bVal, FUNCTION);

    /* Cold reset onboard AC97 */
    OUTW(devc, 0x1, AC97_CTRL);
    count = 100;
    while ((INW(devc, AC97_CTRL) & 0x2) && (count--)) {
        OUTW(devc, (INW(devc, AC97_CTRL) & ~0x2) | 0x2, AC97_CTRL);
        drv_usecwait(100);
    }

    if (!count)
        audio_dev_warn(devc->adev, "CMI8788 AC97 not ready");

    sVal = INW(devc, AC97_CTRL);
    /* check if there's an onboard AC97 codec (CODEC 0) */
    if (sVal & 0x10) {
        /* disable CODEC0 OUTPUT */
        OUTW(devc, INW(devc, AC97_OUT_CHAN_CONFIG) & ~0xFF00,
            AC97_OUT_CHAN_CONFIG);

        /* enable CODEC0 INPUT */
        OUTW(devc, INW(devc, AC97_IN_CHAN_CONFIG) | 0x0300,
            AC97_IN_CHAN_CONFIG);

        devc->has_ac97 = 1;
    }

    /* check if there's an front panel AC97 codec (CODEC1) */
    if (sVal & 0x20) {
        /* enable CODEC1 OUTPUT */
        OUTW(devc, INW(devc, AC97_OUT_CHAN_CONFIG) | 0x0033,
            AC97_OUT_CHAN_CONFIG);
        /* enable CODEC1 INPUT */
        OUTW(devc, INW(devc, AC97_IN_CHAN_CONFIG) | 0x0033,
            AC97_IN_CHAN_CONFIG);

        devc->has_fp_ac97 = 1;
    }

    /* Disable AC97 interrupts and initialize AC97 */
    OUTB(devc, 0x0, AC97_INTR_MASK);
    OUTW(devc, INW(devc, IRQ_MASK) & ~0x4000, IRQ_MASK);

    /* I2S to 16bit/48Khz/Master, see below. */
    i2s_fmt = 0x011A;

    /* Setup I2S to use 16bit instead of 24Bit */
    OUTW(devc, i2s_fmt, I2S_MULTICH_DAC);
    OUTW(devc, i2s_fmt, I2S_ADC1);
    OUTW(devc, i2s_fmt, I2S_ADC2);
    OUTW(devc, i2s_fmt, I2S_ADC3);

    /* setup Routing regs (default vals) */
    OUTW(devc, 0xE400, PLAY_ROUTING);
    OUTB(devc, 0x00, REC_ROUTING); /* default routing set to I2S */
    OUTB(devc, 0x00, REC_MONITOR); /* monitor through MULTICH_PLAY */
    OUTB(devc, 0xE4, MONITOR_ROUTING); /* default monitor routing */


    /* Enable Xonar output */
    switch (devc->model) {
    case SUBID_XONAR_D1:
    case SUBID_XONAR_DX:
        /* GPIO8 = 0x100 controls mic/line-in */
        /* GPIO0 = 0x001controls output */
        /* GPIO2/3 = 0x00C codec output control */

        devc->rec_eng.addr = RECB_ADDR;
        devc->rec_eng.size = RECB_SIZE;
        devc->rec_eng.frag = RECB_FRAG;
        devc->rec_eng.i2s = I2S_ADC2;
        devc->rec_eng.chan = REC_B;

        /* disable AC97 mixer - not used */
        devc->has_ac97 = 0;

        /* setup for 2wire communication mode */
        OUTB(devc, INB(devc, FUNCTION) | 0x40, FUNCTION);

        /* setup GPIO direction */
        OUTW(devc, INW(devc, GPIO_CONTROL) | 0x10D, GPIO_CONTROL);
        /* setup GPIO pins */
        OUTW(devc, INW(devc, GPIO_DATA) | 0x101, GPIO_DATA);

        /* init the front and rear dacs */
        cs4398_init(devc, XONAR_DX_FRONTDAC);
        cs4362a_init(devc, XONAR_DX_SURRDAC);
        break;

    case SUBID_XONAR_D2:
    case SUBID_XONAR_D2X:
        /* GPIO7 = 0x0080 controls mic/line-in */
        /* GPIO8 = 0x0100 controls output */
        /* GPIO2/3 = 0x000C codec output control */

        devc->rec_eng.addr = RECB_ADDR;
        devc->rec_eng.size = RECB_SIZE;
        devc->rec_eng.frag = RECB_FRAG;
        devc->rec_eng.i2s = I2S_ADC2;
        devc->rec_eng.chan = REC_B;

        /* disable the AC97 mixer - it's not useful */
        devc->has_ac97 = 0;

        /* setup for spi communication mode */
        OUTB(devc, (INB(devc, FUNCTION) & ~0x40) | 0x80, FUNCTION);
        /* setup the GPIO direction */
        OUTW(devc, INW(devc, GPIO_CONTROL) | 0x18c, GPIO_CONTROL);

        /* setup GPIO Pins */
        OUTW(devc, INW(devc, GPIO_DATA) | 0x100,  GPIO_DATA);

        /* for all 4 codecs: unmute, set to 24Bit SPI */
        for (i = 0; i < 4; ++i) {
            /* left vol */
            spi_write(devc, i, 16, mix_scale(75, 8));
            /* right vol */
            spi_write(devc, i, 17, mix_scale(75, 8));
            /* unmute/24LSB/ATLD */
            spi_write(devc, i, 18, 0x30 | 0x80);
        }
        break;

    case SUBID_XONAR_STX:
        devc->rec_eng.addr = RECB_ADDR;
        devc->rec_eng.size = RECB_SIZE;
        devc->rec_eng.frag = RECB_FRAG;
        devc->rec_eng.i2s = I2S_ADC2;
        devc->rec_eng.chan = REC_B;

        /* disable the AC97 mixer - it's not useful */
        devc->has_ac97 = 0;

        /* setup for spi communication mode */
        OUTB(devc, (INB(devc, FUNCTION) & ~0x40) | 0x80, FUNCTION);
        /* setup the GPIO direction */
        OUTW(devc, INW(devc, GPIO_CONTROL) | 0x18F, GPIO_CONTROL);
        /* setup GPIO Pins */
        OUTW(devc, INW(devc, GPIO_DATA) | 0x111, GPIO_DATA);

        /* init front DAC */
        /* left vol */
        i2c_write(devc, XONAR_STX_FRONTDAC, 16, mix_scale(75, 8));
        /* right vol */
        i2c_write(devc, XONAR_STX_FRONTDAC, 17, mix_scale(75, 8));
        /* unmute/24LSB/ATLD */
        i2c_write(devc, XONAR_STX_FRONTDAC, 18, 0x30 | 0x80);
        i2c_write(devc, XONAR_STX_FRONTDAC, 19, 0); /* ATS1/FLT_SHARP */
        i2c_write(devc, XONAR_STX_FRONTDAC, 20, 0); /* OS_64 */
        i2c_write(devc, XONAR_STX_FRONTDAC, 21, 0);
        break;

    case SUBID_XONAR_DS:
        /* GPIO 8 = 1 output enabled 0 mute */
        /* GPIO 7 = 1 lineout enabled 0 mute */
        /* GPIO 6 = 1 mic select 0 line-in select */
        /* GPIO 4 = 1 FP Headphone plugged in */
        /* GPIO 3 = 1 FP Mic plugged in */

        devc->rec_eng.addr = RECA_ADDR;
        devc->rec_eng.size = RECA_SIZE;
        devc->rec_eng.frag = RECA_FRAG;
        devc->rec_eng.i2s = I2S_ADC1;
        devc->rec_eng.chan = REC_A;

        /* disable the AC97 mixer - it's not useful */
        devc->has_ac97 = 0;

        /* setup for spi communication mode */
        OUTB(devc, (INB(devc, FUNCTION) & ~0x40) | 0x80, FUNCTION);
        /* setup the GPIO direction */
        OUTW(devc, INW(devc, GPIO_CONTROL) | 0x1D0, GPIO_CONTROL);
        /* setup GPIO Pins */
        OUTW(devc, INW(devc, GPIO_DATA) | 0x1D0, GPIO_DATA);
        spi_write(devc, XONAR_DS_FRONTDAC, 0x17, 0x1); /* reset */
        spi_write(devc, XONAR_DS_FRONTDAC, 0x7, 0x90); /* dac control */
        spi_write(devc, XONAR_DS_FRONTDAC, 0x8, 0); /* unmute */
        /* powerdown hp */
        spi_write(devc, XONAR_DS_FRONTDAC, 0xC, 0x22);
        spi_write(devc, XONAR_DS_FRONTDAC, 0xD, 0x8); /* powerdown hp */
        spi_write(devc, XONAR_DS_FRONTDAC, 0xA, 0x1); /* LJust/16bit */
        spi_write(devc, XONAR_DS_FRONTDAC, 0xB, 0x1); /* LJust/16bit */
        spi_write(devc, XONAR_DS_SURRDAC, 0x1f, 1); /* reset */
        /* LJust/24bit */
        spi_write(devc, XONAR_DS_SURRDAC, 0x3, 0x1|0x20);
        break;


    default:
        /* SPI default for anything else, including the */
        OUTB(devc, (INB(devc, FUNCTION) & ~0x40) | 0x80, FUNCTION);
        OUTB(devc, 0x18, REC_ROUTING); /* default routing set to I2S */
        break;
    }

    /* only initialize AC97 if not defined */
    if (devc->has_ac97)
        cmediahd_ac97_hwinit(devc);
}

static int
cmediahd_set_control(void *arg, uint64_t val)
{
    cmediahd_ctrl_t *pc = arg;
    cmediahd_devc_t *devc = pc->devc;

    mutex_enter(&devc->mutex);

    pc->val = val;

    switch (pc->num) {

    case CTL_VOLUME:
    case CTL_FRONT:
        cmediahd_set_play_volume(devc, 0, val);
        break;

    case CTL_REAR:
        cmediahd_set_play_volume(devc, 1, val);
        break;

    case CTL_CENTER:
        val &= 0xff;
        val |= ((devc->controls[CTL_LFE].val) << 8);
        cmediahd_set_play_volume(devc, 2, val);
        break;

    case CTL_LFE:
        val &= 0xff;
        val <<= 8;
        val |= (devc->controls[CTL_CENTER].val);
        cmediahd_set_play_volume(devc, 2, val);
        break;

    case CTL_SURROUND:
        cmediahd_set_play_volume(devc, 3, val);
        break;

    case CTL_MONITOR:
        /* enable recording  monitor rec 1 and rec2 */
        if (val)
            OUTB(devc, INB(devc, REC_MONITOR) | 0xF, REC_MONITOR);
        else
            OUTB(devc, INB(devc, REC_MONITOR) & ~0xF, REC_MONITOR);
        break;

    case CTL_RECSRC:
        switch (val) {
        case 1: /* Line */
            if (devc->model == SUBID_XONAR_DS)
                OUTW(devc, INW(devc, GPIO_DATA) & ~0x40,
                    GPIO_DATA);

            if (devc->model == SUBID_XONAR_D1 ||
                devc->model == SUBID_XONAR_DX)
                OUTW(devc, INW(devc, GPIO_DATA) &
                    ~devc->gpio_mic, GPIO_DATA);
            cmediahd_write_ac97(devc, 0x72,
                cmediahd_read_ac97(devc, 0x72) & ~0x1);
            cmediahd_write_ac97(devc, 0x1A, 0x0404);
            break;

        case 2:  /* Mic */
            if (devc->model == SUBID_XONAR_DS)
                OUTW(devc, INW(devc, GPIO_DATA) | 0x40,
                    GPIO_DATA);

            if (devc->model == SUBID_XONAR_D1 ||
                devc->model == SUBID_XONAR_DX)
                OUTW(devc, INW(devc, GPIO_DATA) |
                    devc->gpio_mic, GPIO_DATA);
            cmediahd_write_ac97(devc, 0x72,
                cmediahd_read_ac97(devc, 0x72) | 0x1);
            /* Unmute Mic */
            cmediahd_write_ac97(devc, 0xE,
                cmediahd_read_ac97(devc, 0xE) & ~0x8000);
            /* Mute AUX and Video */
            cmediahd_write_ac97(devc, 0x12,
                cmediahd_read_ac97(devc, 0x12) | 0x8000);
            cmediahd_write_ac97(devc, 0x16,
                cmediahd_read_ac97(devc, 0x16) | 0x8000);
            cmediahd_write_ac97(devc, 0x1A, 0x0000);
            break;

        case 4: /* AUX */
            if (devc->model == SUBID_XONAR_D1 ||
                devc->model == SUBID_XONAR_DX)
                OUTW(devc, INW(devc, GPIO_DATA) |
                    devc->gpio_mic, GPIO_DATA);
            cmediahd_write_ac97(devc, 0x72,
                cmediahd_read_ac97(devc, 0x72) | 0x1);
            /* Unmute AUX */
            cmediahd_write_ac97(devc, 0x16,
                cmediahd_read_ac97(devc, 0x16) & ~0x8000);
            /* Mute CD and Mic */
            cmediahd_write_ac97(devc, 0x14,
                cmediahd_read_ac97(devc, 0x14) | 0x8000);
            cmediahd_write_ac97(devc, 0x0E,
                cmediahd_read_ac97(devc, 0x0E) | 0x8000);
            cmediahd_write_ac97(devc, 0x1A, 0x0303);
            break;

        case 8: /* Video (CD) */
            if (devc->model == SUBID_XONAR_D1 ||
                devc->model == SUBID_XONAR_DX)
                OUTW(devc, INW(devc, GPIO_DATA) |
                    devc->gpio_mic, GPIO_DATA);
            cmediahd_write_ac97(devc, 0x72,
                cmediahd_read_ac97(devc, 0x72) | 0x1);
            /* Unmute Video (CD) */
            cmediahd_write_ac97(devc, 0x14,
                cmediahd_read_ac97(devc, 0x14) & ~0x8000);
            /* Mute AUX and Mic */
            cmediahd_write_ac97(devc, 0x16,
                cmediahd_read_ac97(devc, 0x16) | 0x8000);
            cmediahd_write_ac97(devc, 0x0E,
                cmediahd_read_ac97(devc, 0x0E) | 0x8000);
            /* set input to video */
            cmediahd_write_ac97(devc, 0x1A, 0x0202);
            break;
        }
        break;

    case CTL_LOOP:
        if (val)
            OUTW(devc, INW(devc, GPIO_DATA) | devc->gpio_alt,
                GPIO_DATA);
        else
            OUTW(devc, (INW(devc, GPIO_DATA) & ~devc->gpio_alt),
                GPIO_DATA);
        break;

    case CTL_SPREAD:
        if (val)
            OUTW(devc, INW(devc, PLAY_ROUTING) & 0x00FF,
                PLAY_ROUTING);
        else
            OUTW(devc, (INW(devc, PLAY_ROUTING) & 0x00FF) |
                0xE400, PLAY_ROUTING);
        break;

    case CTL_RECGAIN:
        cmediahd_set_rec_volume(devc, val);
        break;

    case CTL_MICVOL:
        if (val)
            cmediahd_write_ac97(devc, 0x0E,
                (0x40 | mix_scale(val, -5)) & ~0x8000);
        else
            cmediahd_write_ac97(devc, 0x0E, 0x8000);
        break;

    case CTL_AUXVOL:
        if (val)
            cmediahd_write_ac97(devc, 0x16,
                mix_scale(val, -5) & ~0x8000);
        else
            cmediahd_write_ac97(devc, 0x16, 0x8000);
        break;


    case CTL_CDVOL:
        if (val)
            cmediahd_write_ac97(devc, 0x14,
                mix_scale(val, -5) & ~0x8000);
        else
            cmediahd_write_ac97(devc, 0x14, 0x8000);
        break;
    }

    mutex_exit(&devc->mutex);
    return (0);
}

static int
cmediahd_get_control(void *arg, uint64_t *val)
{
    cmediahd_ctrl_t *pc = arg;
    cmediahd_devc_t *devc = pc->devc;

    mutex_enter(&devc->mutex);
    *val = pc->val;
    mutex_exit(&devc->mutex);
    return (0);
}

static void
cmediahd_alloc_ctrl(cmediahd_devc_t *devc, uint32_t num, uint64_t val)
{
    audio_ctrl_desc_t   desc;
    cmediahd_ctrl_t     *pc;

    bzero(&desc, sizeof (desc));

    pc = &devc->controls[num];
    pc->num = num;
    pc->devc = devc;


    switch (num) {

    case CTL_VOLUME:
        desc.acd_name = AUDIO_CTRL_ID_VOLUME;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = PCMVOL;
        break;

    case CTL_FRONT:
        desc.acd_name = AUDIO_CTRL_ID_FRONT;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = PCMVOL;
        break;

    case CTL_REAR:
        desc.acd_name = AUDIO_CTRL_ID_REAR;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = PCMVOL;
        break;

    case CTL_SURROUND:
        desc.acd_name = AUDIO_CTRL_ID_SURROUND;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = PCMVOL;
        break;

    case CTL_CENTER:
        desc.acd_name = AUDIO_CTRL_ID_CENTER;
        desc.acd_type = AUDIO_CTRL_TYPE_MONO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = PCMVOL;
        break;

    case CTL_LFE:
        desc.acd_name = AUDIO_CTRL_ID_LFE;
        desc.acd_type = AUDIO_CTRL_TYPE_MONO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = PCMVOL;
        break;

    case CTL_MONITOR:
        desc.acd_name = AUDIO_CTRL_ID_MONSRC;
        desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 1;
        desc.acd_flags = RECCTL;
        break;

    case CTL_RECSRC:
        desc.acd_name = AUDIO_CTRL_ID_RECSRC;
        desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
        desc.acd_flags = RECCTL;
        desc.acd_enum[0] = AUDIO_PORT_LINEIN;
        desc.acd_enum[1] = AUDIO_PORT_MIC;

        if (devc->model == SUBID_XONAR_D2 ||
            devc->model == SUBID_XONAR_D2X) {
            desc.acd_minvalue = 0xF;
            desc.acd_maxvalue = 0xF;
            desc.acd_enum[2] = AUDIO_PORT_AUX1IN;
            desc.acd_enum[3] = AUDIO_PORT_CD;
        } else {
            desc.acd_minvalue = 0x3;
            desc.acd_maxvalue = 0x3;
        }
        break;

    case CTL_LOOP:
        desc.acd_name = AUDIO_CTRL_ID_LOOPBACK;
        desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 1;
        desc.acd_flags = RECCTL;
        break;

    case CTL_SPREAD:
        desc.acd_name = AUDIO_CTRL_ID_SPREAD;
        desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 1;
        desc.acd_flags = PLAYCTL;
        break;

    case CTL_RECGAIN:
        desc.acd_name = AUDIO_CTRL_ID_RECGAIN;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = RECVOL;
        break;

    case CTL_MICVOL:
        desc.acd_name = AUDIO_CTRL_ID_MIC;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = RECVOL;
        break;

    case CTL_AUXVOL:
        desc.acd_name = AUDIO_CTRL_ID_AUX1IN;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = RECVOL;
        break;
    case CTL_CDVOL:
        desc.acd_name = AUDIO_CTRL_ID_CD;
        desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
        desc.acd_minvalue = 0;
        desc.acd_maxvalue = 100;
        desc.acd_flags = RECVOL;
        break;

    }

    pc->val = val;
    pc->ctrl = audio_dev_add_control(devc->adev, &desc,
        cmediahd_get_control, cmediahd_set_control, pc);
}

static void
cmediahd_refresh_mixer(cmediahd_devc_t *devc)
{
    int ctl;

    for (ctl = 0; ctl < CTL_NUM; ctl++) {
        if (devc->controls[ctl].ctrl == NULL)
            continue;
        (void) cmediahd_set_control(&devc->controls[ctl],
            devc->controls[ctl].val);
    }
}

static void
cmediahd_add_controls(cmediahd_devc_t *devc)
{
    cmediahd_alloc_ctrl(devc, CTL_VOLUME, 80 | (80 << 8));
    cmediahd_alloc_ctrl(devc, CTL_FRONT, 80 | (80<<8));
    cmediahd_alloc_ctrl(devc, CTL_REAR, 80 | (80<<8));
    cmediahd_alloc_ctrl(devc, CTL_CENTER, 80);
    cmediahd_alloc_ctrl(devc, CTL_LFE, 80);
    cmediahd_alloc_ctrl(devc, CTL_SURROUND, 80 | (80<<8));
    cmediahd_alloc_ctrl(devc, CTL_SPREAD, 0);
    cmediahd_alloc_ctrl(devc, CTL_MONITOR, 0);
    cmediahd_alloc_ctrl(devc, CTL_LOOP, 0);
    cmediahd_alloc_ctrl(devc, CTL_RECSRC, 2);

    switch (devc->model) {
    case SUBID_XONAR_DS:
        cmediahd_alloc_ctrl(devc, CTL_RECGAIN, 80|80<<8);
        break;
    case SUBID_XONAR_D2:
    case SUBID_XONAR_D2X:
        cmediahd_alloc_ctrl(devc, CTL_MICVOL, 80|80<<8);
        cmediahd_alloc_ctrl(devc, CTL_AUXVOL, 80|80<<8);
        cmediahd_alloc_ctrl(devc, CTL_CDVOL, 80|80<<8);
        break;
    }

    cmediahd_refresh_mixer(devc);
}

void
cmediahd_del_controls(cmediahd_devc_t *dev)
{
    for (int i = 0; i < CTL_NUM; i++) {
        if (dev->controls[i].ctrl) {
            audio_dev_del_control(dev->controls[i].ctrl);
            dev->controls[i].ctrl = NULL;
        }
    }
}

int
cmediahd_attach(dev_info_t *dip)
{
    uint16_t    pci_command, vendor, device, subvendor, subdevice;
    cmediahd_devc_t *devc;
    ddi_acc_handle_t pcih;

    devc = kmem_zalloc(sizeof (*devc), KM_SLEEP);
    devc->dip = dip;
    ddi_set_driver_private(dip, devc);

    mutex_init(&devc->mutex, NULL, MUTEX_DRIVER, NULL);
    mutex_init(&devc->low_mutex, NULL, MUTEX_DRIVER, NULL);

    if ((devc->adev = audio_dev_alloc(dip, 0)) == NULL) {
        cmn_err(CE_WARN, "audio_dev_alloc failed");
        goto error;
    }

    if (pci_config_setup(dip, &pcih) != DDI_SUCCESS) {
        audio_dev_warn(devc->adev, "pci_config_setup failed");
        goto error;
    }
    devc->pcih = pcih;

    vendor = pci_config_get16(pcih, PCI_CONF_VENID);
    device = pci_config_get16(pcih, PCI_CONF_DEVID);
    subvendor = pci_config_get16(pcih, PCI_CONF_SUBVENID);
    subdevice = pci_config_get16(pcih, PCI_CONF_SUBSYSID);
    if (vendor != PCI_VENDOR_ID_CMEDIA ||
        device != PCI_DEVICE_ID_CMEDIAHD) {
        audio_dev_warn(devc->adev, "Hardware not recognized "
            "(vendor=%x, dev=%x)", vendor, device);
        goto error;
    }


    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);

    if ((ddi_regs_map_setup(dip, 1, &devc->base, 0, 0, &dev_attr,
        &devc->regsh)) != DDI_SUCCESS) {
        audio_dev_warn(devc->adev, "failed to map registers");
        goto error;
    }

    audio_dev_set_description(devc->adev, "CMedia 8788");

    /* Detect Xonar device */
    if (subvendor == ASUS_VENDOR_ID) {
        switch (subdevice) {
        case SUBID_XONAR_D1:
            audio_dev_set_description(devc->adev,
                "Asus Xonar D1 (AV100)");
            break;
        case SUBID_XONAR_DX:
            audio_dev_set_description(devc->adev,
                "Asus Xonar DX (AV100)");
            break;
        case SUBID_XONAR_D2:
            audio_dev_set_description(devc->adev,
                "Asus Xonar D2 (AV200)");
            break;
        case SUBID_XONAR_D2X:
            audio_dev_set_description(devc->adev,
                "Asus Xonar D2X (AV200)");
            break;
        case SUBID_XONAR_STX:
            audio_dev_set_description(devc->adev,
                "Asus Xonar STX (AV100)");
            break;
        case SUBID_XONAR_DS:
            audio_dev_set_description(devc->adev,
                "Asus Xonar DS (AV66)");
            break;
        default:
            audio_dev_set_description(devc->adev,
                "Asus Xonar Unknown Model");
            subdevice = SUBID_GENERIC;
            break;
        }
        devc->model = subdevice;
    }

    cmediahd_hwinit(devc);

    if (cmediahd_alloc_port(devc, CMEDIAHD_PLAY) != DDI_SUCCESS)
        goto error;
    if (cmediahd_alloc_port(devc, CMEDIAHD_REC) != DDI_SUCCESS)
        goto error;

    /* Add the AC97 Mixer if there is an onboard AC97 device */
    if (devc->has_ac97) {
        devc->ac97 = ac97_alloc(dip, cmediahd_read_ac97,
            cmediahd_write_ac97, devc);
        if (ac97_init(devc->ac97, devc->adev) != DDI_SUCCESS) {
            audio_dev_warn(devc->adev, "failed to init ac97");
            goto error;
        }
    }
#if 0
    /* Add the front panel AC97 device if one exists */
    if (devc->has_fp_ac97) {
        devc->fp_ac97 = ac97_alloc(dip, cmediahd_read_fp_ac97,
            cmediahd_write_fp_ac97, devc);
        if (ac97_init(devc->fp_ac97, devc->adev) != DDI_SUCCESS) {
            audio_dev_warn(devc->adev, "failed to init fp_ac97");
            goto error;
        }
    }
#endif
    /* Add the standard CMI8788 Mixer panel */
    cmediahd_add_controls(devc);

    if (audio_dev_register(devc->adev) != DDI_SUCCESS) {
        audio_dev_warn(devc->adev, "unable to register with framework");
        goto error;
    }

    ddi_report_dev(dip);

    return (DDI_SUCCESS);

error:
    cmediahd_destroy(devc);
    return (DDI_FAILURE);
}

int
cmediahd_resume(dev_info_t *dip)
{
    cmediahd_devc_t *devc;

    devc = ddi_get_driver_private(dip);

    cmediahd_hwinit(devc);

    if (devc->ac97)
        ac97_reset(devc->ac97);

    cmediahd_refresh_mixer(devc);

    audio_dev_resume(devc->adev);

    return (DDI_SUCCESS);
}

int
cmediahd_detach(cmediahd_devc_t *devc)
{
    if (audio_dev_unregister(devc->adev) != DDI_SUCCESS)
        return (DDI_FAILURE);

    cmediahd_destroy(devc);
    return (DDI_SUCCESS);
}

int
cmediahd_suspend(cmediahd_devc_t *devc)
{
    audio_dev_suspend(devc->adev);
    return (DDI_SUCCESS);
}

static int cmediahd_ddi_attach(dev_info_t *, ddi_attach_cmd_t);
static int cmediahd_ddi_detach(dev_info_t *, ddi_detach_cmd_t);
static int cmediahd_ddi_quiesce(dev_info_t *);

static struct dev_ops cmediahd_dev_ops = {
    DEVO_REV,       /* rev */
    0,          /* refcnt */
    NULL,           /* getinfo */
    nulldev,        /* identify */
    nulldev,        /* probe */
    cmediahd_ddi_attach,    /* attach */
    cmediahd_ddi_detach,    /* detach */
    nodev,          /* reset */
    NULL,           /* cb_ops */
    NULL,           /* bus_ops */
    NULL,           /* power */
    cmediahd_ddi_quiesce,   /* quiesce */
};

static struct modldrv cmediahd_modldrv = {
    &mod_driverops,         /* drv_modops */
    "CMedia 8788",          /* linkinfo */
    &cmediahd_dev_ops,      /* dev_ops */
};

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

int
_init(void)
{
    int rv;

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

int
_fini(void)
{
    int rv;

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

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

int
cmediahd_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
    switch (cmd) {
    case DDI_ATTACH:
        return (cmediahd_attach(dip));

    case DDI_RESUME:
        return (cmediahd_resume(dip));

    default:
        return (DDI_FAILURE);
    }
}

int
cmediahd_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    cmediahd_devc_t *devc;

    devc = ddi_get_driver_private(dip);

    switch (cmd) {
    case DDI_DETACH:
        return (cmediahd_detach(devc));

    case DDI_SUSPEND:
        return (cmediahd_suspend(devc));

    default:
        return (DDI_FAILURE);
    }
}

int
cmediahd_ddi_quiesce(dev_info_t *dip)
{
    cmediahd_devc_t *devc;

    devc = ddi_get_driver_private(dip);

    OUTW(devc, 0x0, DMA_START);

    /*
     * Turn off the hardware
     */


    return (DDI_SUCCESS);
}