/*
 * 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.
 */

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

#include <sys/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 "audiovia823x.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_sgd = {
        DMA_ATTR_V0,            /* version number */
        0x00000000,             /* low DMA address range */
        0xffffffff,             /* high DMA address range */
        0x0000ffff,             /* DMA counter register */
        8,                      /* DMA address alignment */
        0x3c,                   /* DMA burstsizes */
        8,                      /* min effective DMA size */
        0xffffffff,             /* max DMA xfer size */
        0x00000fff,             /* segment boundary */
        1,                      /* s/g length */
        8,                      /* granularity of device */
        0                       /* Bus specific DMA flags */
};

static ddi_dma_attr_t dma_attr_buf = {
        DMA_ATTR_V0,            /* version number */
        0x00000000,             /* low DMA address range */
        0xffffffff,             /* high DMA address range */
        0x0001fffe,             /* DMA counter register */
        4,                      /* DMA address alignment */
        0x3c,                   /* DMA burstsizes */
        4,                      /* min effective DMA size */
        0x0001ffff,             /* max DMA xfer size */
        0x0001ffff,             /* segment boundary */
        1,                      /* s/g length */
        4,                      /* granularity of device */
        0                       /* Bus specific DMA flags */
};

static int auvia_attach(dev_info_t *);
static int auvia_resume(dev_info_t *);
static int auvia_detach(auvia_devc_t *);
static int auvia_suspend(auvia_devc_t *);

static int auvia_open(void *, int, unsigned *, caddr_t *);
static void auvia_close(void *);
static int auvia_start(void *);
static void auvia_stop(void *);
static int auvia_format(void *);
static int auvia_channels(void *);
static int auvia_rate(void *);
static uint64_t auvia_count(void *);
static void auvia_sync(void *, unsigned);

static uint16_t auvia_read_ac97(void *, uint8_t);
static void auvia_write_ac97(void *, uint8_t, uint16_t);
static int auvia_alloc_port(auvia_devc_t *, int);
static void auvia_reset_input(auvia_portc_t *);
static void auvia_reset_output(auvia_portc_t *);
static void auvia_destroy(auvia_devc_t *);
static void auvia_hwinit(auvia_devc_t *);

static audio_engine_ops_t auvia_engine_ops = {
        AUDIO_ENGINE_VERSION,
        auvia_open,
        auvia_close,
        auvia_start,
        auvia_stop,
        auvia_count,
        auvia_format,
        auvia_channels,
        auvia_rate,
        auvia_sync,
        NULL,
        NULL,
        NULL,
};

static uint16_t
auvia_read_ac97(void *arg, uint8_t index)
{
        auvia_devc_t *devc = arg;
        uint32_t val = 0;
        int i;

        val = ((uint32_t)index << 16) | CODEC_RD;
        OUTL(devc, devc->base + REG_CODEC, val);
        drv_usecwait(100);

        /* Check AC CODEC access time out */
        for (i = 0; i < CODEC_TIMEOUT_COUNT; i++) {

                /* if send command over, break */
                if (INL(devc, devc->base + REG_CODEC) & CODEC_STA_VALID)
                        break;
                drv_usecwait(50);
        }

        if (i == CODEC_TIMEOUT_COUNT) {
                goto failed;
        }

        /* Check if Index still ours? If yes, return data, else return FAIL */
        val = INL(devc, devc->base + REG_CODEC);
        OUTB(devc, devc->base + REG_CODEC + 3, 0x02);
        if (((val & CODEC_INDEX) >> 16) == index) {
                return (val & CODEC_DATA);
        }

failed:
        return (0xffff);
}

static void
auvia_write_ac97(void *arg, uint8_t index, uint16_t data)
{
        auvia_devc_t *devc = arg;
        uint32_t val = 0;
        int i = 0;

        val = ((uint32_t)index << 16) | data | CODEC_WR;
        OUTL(devc, devc->base + REG_CODEC, val);
        drv_usecwait(100);

        /* Check AC CODEC access time out */
        for (i = 0; i < CODEC_TIMEOUT_COUNT; i++) {
                /* if send command over, break */
                if (!(INL(devc, devc->base + REG_CODEC) & CODEC_IN_CMD))
                        break;
                drv_usecwait(50);
        }

}

/*
 * Audio routines
 */

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

        _NOTE(ARGUNUSED(flag));

        portc->count = 0;
        *nframesp = portc->nframes;
        *bufp = portc->buf_kaddr;

        return (0);
}

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

int
auvia_start(void *arg)
{
        auvia_portc_t   *portc = arg;
        auvia_devc_t    *devc = portc->devc;

        portc->reset(portc);
        OUTB(devc, portc->base + OFF_CTRL, CTRL_START | CTRL_AUTOSTART);
        return (0);
}

void
auvia_stop(void *arg)
{
        auvia_portc_t   *portc = arg;
        auvia_devc_t    *devc = portc->devc;

        OUTB(devc, portc->base + OFF_CTRL, CTRL_TERMINATE);
}

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

        return (AUDIO_FORMAT_S16_LE);
}

int
auvia_channels(void *arg)
{
        auvia_portc_t   *portc = arg;

        return (portc->nchan);
}

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

        return (48000);
}

void
auvia_sync(void *arg, unsigned nframes)
{
        auvia_portc_t *portc = arg;
        _NOTE(ARGUNUSED(nframes));

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

uint64_t
auvia_count(void *arg)
{
        auvia_portc_t   *portc = arg;
        auvia_devc_t    *devc = portc->devc;
        uint32_t        pos;
        uint32_t        n;

        pos = INL(devc, portc->base + OFF_COUNT);
        pos &= 0xffffff;
        pos /= (sizeof (int16_t) * portc->nchan);

        if (pos >= portc->pos) {
                n = portc->nframes - (pos - portc->pos);
        } else {
                n = portc->pos - pos;
        }
        portc->pos = pos;
        portc->count += n;

        return (portc->count);
}


/* private implementation bits */

void
auvia_reset_output(auvia_portc_t *portc)
{
        auvia_devc_t    *devc = portc->devc;
        uint32_t        cmap;

        portc->pos = 0;

        OUTB(devc, portc->base + OFF_CTRL, CTRL_TERMINATE);     /* Stop */
        OUTL(devc, portc->base + OFF_DMA, portc->sgd_paddr);

        OUTB(devc, portc->base + OFF_PLAYFMT,
            PLAYFMT_16BIT | (portc->nchan << 4));

        /* Select channel assignment - not valid for 8233A */
        if (devc->chip_type != CHIP_8233A) {
                /*
                 * Undocumented slot mapping table:
                 *
                 * slot 3 = 1 (left)
                 * slot 4 = 2 (right)
                 * slot 6 = 5 (center)
                 * slot 9 = 6 (lfe)
                 * slot 7 = 3 (left rear)
                 * slot 8 = 4 (right rear)
                 */
                switch (portc->nchan) {
                case 1:
                        cmap = (1 << 0) | (1 << 4);
                        break;
                case 2:
                        cmap = (1 << 0) | (2 << 4);
                        break;
                case 4:
                        cmap = (1 << 0) | (2 << 4) | (3 << 8) | (4 << 12);
                        break;
                case 6:
                        cmap = (1 << 0) | (2 << 4) |
                            (5 << 8) | (6 << 12) | (3 << 16) | (4 << 20);
                        break;
                default:
                        cmap = 0;
                        break;
                }
                OUTL(devc, portc->base + OFF_CHANNELS, cmap | 0xFF000000U);
        }
}

static void
auvia_reset_input(auvia_portc_t *portc)
{
        auvia_devc_t    *devc = portc->devc;
        uint32_t        fmt;

        portc->pos = 0;

        OUTB(devc, portc->base + OFF_CTRL, CTRL_TERMINATE);     /* Stop */
        OUTL(devc, portc->base + OFF_DMA, portc->sgd_paddr);

        fmt = RECFMT_STEREO | RECFMT_16BIT;

        if (devc->chip_type != CHIP_8233A) {
                fmt |= RECFMT_48K;
        }
        fmt |= (0xffU << 24);
        OUTB(devc, portc->base + OFF_RECFIFO, RECFIFO_ENABLE);
        OUTL(devc, portc->base + OFF_RECFMT, fmt);
}

int
auvia_alloc_port(auvia_devc_t *devc, int num)
{
        auvia_portc_t           *portc;
        size_t                  len;
        ddi_dma_cookie_t        cookie;
        uint_t                  count;
        int                     dir;
        unsigned                caps;
        audio_dev_t             *adev;
        uint32_t                *desc;

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

        switch (num) {
        case AUVIA_REC_SGD_NUM:
                portc->base = devc->base + REG_RECBASE;
                portc->syncdir = DDI_DMA_SYNC_FORKERNEL;
                portc->nchan = 2;
                portc->reset = auvia_reset_input;
                caps = ENGINE_INPUT_CAP;
                dir = DDI_DMA_READ;
                break;
        case AUVIA_PLAY_SGD_NUM:
                portc->base = devc->base + REG_PLAYBASE;
                portc->syncdir = DDI_DMA_SYNC_FORDEV;
                portc->nchan = 6;
                portc->reset = auvia_reset_output;
                caps = ENGINE_OUTPUT_CAP;
                dir = DDI_DMA_WRITE;
                break;
        default:
                return (DDI_FAILURE);
        }

        /* make sure port is shut down */
        OUTB(portc->devc, portc->base + OFF_CTRL, CTRL_TERMINATE);

        portc->nframes = 4096;
        portc->buf_size = portc->nframes * portc->nchan * sizeof (int16_t);

        /* first allocate up space for SGD list */
        if (ddi_dma_alloc_handle(devc->dip, &dma_attr_sgd,
            DDI_DMA_SLEEP, NULL, &portc->sgd_dmah) != DDI_SUCCESS) {
                audio_dev_warn(adev, "failed to allocate SGD handle");
                return (DDI_FAILURE);
        }

        if (ddi_dma_mem_alloc(portc->sgd_dmah, 2 * sizeof (uint32_t), &dev_attr,
            DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &portc->sgd_kaddr,
            &len, &portc->sgd_acch) != DDI_SUCCESS) {
                audio_dev_warn(adev, "failed to allocate SGD memory");
                return (DDI_FAILURE);
        }

        if (ddi_dma_addr_bind_handle(portc->sgd_dmah, NULL,
            portc->sgd_kaddr, len, DDI_DMA_CONSISTENT | DDI_DMA_WRITE,
            DDI_DMA_SLEEP, NULL, &cookie, &count) != DDI_SUCCESS) {
                audio_dev_warn(adev, "failed binding SGD DMA handle");
                return (DDI_FAILURE);
        }
        portc->sgd_paddr = cookie.dmac_address;

        /* now 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, portc->buf_size,
            &buf_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
            &portc->buf_kaddr, &len, &portc->buf_acch) != DDI_SUCCESS) {
                audio_dev_warn(adev, "failed to allocate BUF memory");
                return (DDI_FAILURE);
        }

        if (ddi_dma_addr_bind_handle(portc->buf_dmah, NULL, portc->buf_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->buf_paddr = cookie.dmac_address;

        /* now wire up descriptor -- just one */
        desc = (void *)portc->sgd_kaddr;

        ddi_put32(portc->sgd_acch, desc++, portc->buf_paddr);
        ddi_put32(portc->sgd_acch, desc++, AUVIA_SGD_EOL | portc->buf_size);

        (void) ddi_dma_sync(portc->sgd_dmah, 0, 0, DDI_DMA_SYNC_FORDEV);

        portc->engine = audio_engine_alloc(&auvia_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
auvia_destroy(auvia_devc_t *devc)
{
        for (int i = 0; i < AUVIA_NUM_PORTC; i++) {
                auvia_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->sgd_paddr) {
                        (void) ddi_dma_unbind_handle(portc->sgd_dmah);
                }
                if (portc->sgd_acch) {
                        ddi_dma_mem_free(&portc->sgd_acch);
                }
                if (portc->sgd_dmah) {
                        ddi_dma_free_handle(&portc->sgd_dmah);
                }
                if (portc->buf_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 != NULL) {
                ac97_free(devc->ac97);
        }
        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
auvia_hwinit(auvia_devc_t *devc)
{
        ddi_acc_handle_t        pcih = devc->pcih;
        uint32_t                val;

        val = pci_config_get32(pcih, AUVIA_PCICFG);
        /* we want to disable all legacy */
        val &= ~AUVIA_PCICFG_LEGACY;
        val &= ~(AUVIA_PCICFG_FMEN | AUVIA_PCICFG_SBEN);

        /* enable AC'97 link and clear the reset bit */
        val |= (AUVIA_PCICFG_ACLINKEN | AUVIA_PCICFG_NRST);
        /* disable SRC (we won't use it) */
        val &= ~AUVIA_PCICFG_SRCEN;
        /* enable the SGD engines */
        val |= AUVIA_PCICFG_SGDEN;

        pci_config_put32(pcih, AUVIA_PCICFG, val);

        drv_usecwait(10);
}

int
auvia_attach(dev_info_t *dip)
{
        uint8_t         pci_revision;
        uint16_t        pci_command, vendor, device;
        auvia_devc_t    *devc;
        ddi_acc_handle_t pcih;
        const char      *version;

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

        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);
        if ((vendor != VIA_VENDOR_ID) || (device != VIA_8233_ID &&
            device != VIA_8233A_ID)) {
                audio_dev_warn(devc->adev, "Hardware not recognized "
                    "(vendor=%x, dev=%x)", vendor, device);
                goto error;
        }

        devc->chip_type = CHIP_8233;
        devc->chip_name = "VIA VT8233";
        version = "8233";

        pci_revision = pci_config_get8(pcih, PCI_CONF_REVID);

        if (pci_revision == 0x50) {
                devc->chip_name = "VIA VT8235";
                version = "8235";
        }

        if (pci_revision == 0x60) {
                devc->chip_name = "VIA VT8237";
                version = "8237";
        }

        if ((device == VIA_8233A_ID) ||
            (device == VIA_8233_ID && pci_revision == 0x40)) {
                devc->chip_type = CHIP_8233A;
                devc->chip_name = "VIA VT8233A";
                version = "8233A";
        }
        audio_dev_set_description(devc->adev, devc->chip_name);
        audio_dev_set_version(devc->adev, version);

        pci_command = pci_config_get16(pcih, PCI_CONF_COMM);
        pci_command |= PCI_COMM_ME | PCI_COMM_IO | PCI_COMM_MAE;
        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;
        }

        auvia_hwinit(devc);

        if ((auvia_alloc_port(devc, AUVIA_PLAY_SGD_NUM) != DDI_SUCCESS) ||
            (auvia_alloc_port(devc, AUVIA_REC_SGD_NUM) != DDI_SUCCESS)) {
                goto error;
        }

        devc->ac97 = ac97_alloc(dip, auvia_read_ac97, auvia_write_ac97, devc);
        if (devc->ac97 == NULL) {
                audio_dev_warn(devc->adev, "failed to allocate ac97 handle");
                goto error;
        }

        if (ac97_init(devc->ac97, devc->adev) != DDI_SUCCESS) {
                audio_dev_warn(devc->adev, "failed to init ac97");
                goto error;
        }

        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:
        auvia_destroy(devc);
        return (DDI_FAILURE);
}

int
auvia_resume(dev_info_t *dip)
{
        auvia_devc_t *devc;

        devc = ddi_get_driver_private(dip);

        auvia_hwinit(devc);

        ac97_reset(devc->ac97);

        audio_dev_resume(devc->adev);

        return (DDI_SUCCESS);
}


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

        auvia_destroy(devc);
        return (DDI_SUCCESS);
}

int
auvia_suspend(auvia_devc_t *devc)
{
        audio_dev_suspend(devc->adev);

        return (DDI_SUCCESS);
}

static int auvia_ddi_attach(dev_info_t *, ddi_attach_cmd_t);
static int auvia_ddi_detach(dev_info_t *, ddi_detach_cmd_t);
static int auvia_ddi_quiesce(dev_info_t *);

static struct dev_ops auvia_dev_ops = {
        DEVO_REV,               /* rev */
        0,                      /* refcnt */
        NULL,                   /* getinfo */
        nulldev,                /* identify */
        nulldev,                /* probe */
        auvia_ddi_attach,       /* attach */
        auvia_ddi_detach,       /* detach */
        nodev,                  /* reset */
        NULL,                   /* cb_ops */
        NULL,                   /* bus_ops */
        NULL,                   /* power */
        auvia_ddi_quiesce,      /* quiesce */
};

static struct modldrv auvia_modldrv = {
        &mod_driverops,                 /* drv_modops */
        "Via 823x Audio",               /* linkinfo */
        &auvia_dev_ops,                 /* dev_ops */
};

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

int
_init(void)
{
        int     rv;

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

int
_fini(void)
{
        int     rv;

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

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

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

        case DDI_RESUME:
                return (auvia_resume(dip));

        default:
                return (DDI_FAILURE);
        }
}

int
auvia_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        auvia_devc_t *devc;

        devc = ddi_get_driver_private(dip);

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

        case DDI_SUSPEND:
                return (auvia_suspend(devc));

        default:
                return (DDI_FAILURE);
        }
}

int
auvia_ddi_quiesce(dev_info_t *dip)
{
        auvia_devc_t    *devc;

        devc = ddi_get_driver_private(dip);

        for (int i = 0; i < AUVIA_NUM_PORTC; i++) {

                auvia_portc_t *portc = devc->portc[i];
                OUTB(devc, portc->base + OFF_CTRL, CTRL_TERMINATE);
        }
        return (DDI_SUCCESS);
}