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

/*
 * Purpose: Driver for the Creative P16X AC97 audio controller
 */
/*
 *
 * Copyright (C) 4Front Technologies 1996-2009.
 *
 * 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 "audiop16x.h"

/*
 * These boards use an AC'97 codec, but don't have all of the
 * various outputs that the AC'97 codec can offer.  We just
 * suppress them for now.
 */
static char *p16x_remove_ac97[] = {
    AUDIO_CTRL_ID_BEEP,
    AUDIO_CTRL_ID_VIDEO,
    AUDIO_CTRL_ID_MICSRC,
    AUDIO_CTRL_ID_SPEAKER,
    AUDIO_CTRL_ID_SPKSRC,
    NULL
};

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 */
    0x00000000,     /* low DMA address range */
    0xffffffff,     /* high DMA address range */
    0xfffffffe,     /* DMA counter register */
    4,          /* DMA address alignment */
    0x3c,           /* DMA burstsizes */
    4,          /* min effective DMA size */
    0xffffffff,     /* max DMA xfer size */
    0xffffffff,     /* segment boundary */
    1,          /* s/g length */
    4,          /* granularity of device */
    0           /* Bus specific DMA flags */
};

static int p16x_attach(dev_info_t *);
static int p16x_resume(dev_info_t *);
static int p16x_detach(p16x_dev_t *);
static int p16x_suspend(p16x_dev_t *);

static int p16x_open(void *, int, unsigned *, caddr_t *);
static void p16x_close(void *);
static int p16x_start(void *);
static void p16x_stop(void *);
static int p16x_format(void *);
static int p16x_channels(void *);
static int p16x_rate(void *);
static uint64_t p16x_count(void *);
static void p16x_sync(void *, unsigned);
static void p16x_chinfo(void *, int, unsigned *, unsigned *);

static uint16_t p16x_read_ac97(void *, uint8_t);
static void p16x_write_ac97(void *, uint8_t, uint16_t);
static int p16x_alloc_port(p16x_dev_t *, int);
static void p16x_destroy(p16x_dev_t *);
static void p16x_hwinit(p16x_dev_t *);

static audio_engine_ops_t p16x_engine_ops = {
    AUDIO_ENGINE_VERSION,
    p16x_open,
    p16x_close,
    p16x_start,
    p16x_stop,
    p16x_count,
    p16x_format,
    p16x_channels,
    p16x_rate,
    p16x_sync,
    NULL,
    p16x_chinfo,
    NULL
};

static unsigned int
read_reg(p16x_dev_t *dev, int reg, int chn)
{
    unsigned int val;

    mutex_enter(&dev->mutex);
    OUTL(dev, (reg << 16) | (chn & 0xffff), PTR);   /* Pointer */
    val = INL(dev, DR); /* Data */
    mutex_exit(&dev->mutex);

    return (val);
}

static void
write_reg(p16x_dev_t *dev, int reg, int chn, unsigned int value)
{

    mutex_enter(&dev->mutex);
    OUTL(dev, (reg << 16) | (chn & 0xffff), PTR);   /* Pointer */
    OUTL(dev, value, DR);   /* Data */
    mutex_exit(&dev->mutex);
}

static void
set_reg_bits(p16x_dev_t *dev, int reg, int chn, unsigned int mask)
{
    unsigned int    val;
    mutex_enter(&dev->mutex);
    OUTL(dev, (reg << 16) | (chn & 0xffff), PTR);   /* Pointer */
    val = INL(dev, DR); /* Data */
    val |= mask;
    OUTL(dev, val, DR); /* Data */
    mutex_exit(&dev->mutex);
}

static void
clear_reg_bits(p16x_dev_t *dev, int reg, int chn, unsigned int mask)
{
    unsigned int    val;
    mutex_enter(&dev->mutex);
    OUTL(dev, (reg << 16) | (chn & 0xffff), PTR);   /* Pointer */
    val = INL(dev, DR); /* Data */
    val &= ~(mask);
    OUTL(dev, val, DR); /* Data */
    mutex_exit(&dev->mutex);
}

static uint16_t
p16x_read_ac97(void *arg, uint8_t index)
{
    p16x_dev_t *dev = arg;
    uint16_t value;
    int i;

    OUTB(dev, index, AC97A);
    for (i = 0; i < 10000; i++)
        if (INB(dev, AC97A) & 0x80)
            break;
    value = INW(dev, AC97D);
    return (value);
}

static void
p16x_write_ac97(void *arg, uint8_t index, uint16_t data)
{
    p16x_dev_t *dev = arg;
    unsigned int i;

    OUTB(dev, index, AC97A);
    for (i = 0; i < 10000; i++)
        if (INB(dev, AC97A) & 0x80)
            break;
    OUTW(dev, data, AC97D);
}

/*
 * Audio routines
 */

int
p16x_open(void *arg, int flag, uint_t *nframes, caddr_t *bufp)
{
    p16x_port_t *port = arg;

    _NOTE(ARGUNUSED(flag));

    port->count = 0;
    *nframes = port->buf_frames;
    *bufp = port->buf_kaddr;

    return (0);
}

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

int
p16x_start(void *arg)
{
    p16x_port_t *port = arg;
    p16x_dev_t  *dev = port->dev;

    port->offset = 0;

    if (port->port_num == P16X_REC) {
        write_reg(dev, CRFA, 0, 0);
        write_reg(dev, CRCAV, 0, 0);

        /* Enable rec channel */
        set_reg_bits(dev, SA, 0, 0x100);
    } else {
        for (int i = 0; i < 3; i++) {
            write_reg(dev, PTBA, i, 0);
            write_reg(dev, PTBS, i, 0);
            write_reg(dev, PTCA, i, 0);
            write_reg(dev, PFEA, i, 0);
            write_reg(dev, CPFA, i, 0);
            write_reg(dev, CPCAV, i, 0);
        }

        /* Enable play channel */
        set_reg_bits(dev, SA, 0, 0x7);
    }

    return (0);
}

void
p16x_stop(void *arg)
{
    p16x_port_t *port = arg;
    p16x_dev_t  *dev = port->dev;

    if (port->port_num == P16X_REC) {
        /* Disable rec channel */
        clear_reg_bits(dev, SA, 0, 0x100);

    } else {
        /* Disable Play channel */
        clear_reg_bits(dev, SA, 0, 0x7);
    }
}

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

    return (AUDIO_FORMAT_S16_LE);
}

int
p16x_channels(void *arg)
{
    p16x_port_t *port = arg;

    return (port->nchan);
}

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

    return (48000);
}

void
p16x_sync(void *arg, unsigned nframes)
{
    p16x_port_t *port = arg;
    _NOTE(ARGUNUSED(nframes));

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

uint64_t
p16x_count(void *arg)
{
    p16x_port_t *port = arg;
    p16x_dev_t  *dev = port->dev;
    uint64_t    val;
    uint32_t    offset, n;

    if (port->port_num == P16X_PLAY) {
        offset = read_reg(dev, CPFA, 0);
    } else {
        offset = read_reg(dev, CRFA, 0);
    }

    /* get the offset, and switch to frames */
    offset /= (2 * sizeof (uint16_t));

    if (offset >= port->offset) {
        n = offset - port->offset;
    } else {
        n = offset + (port->buf_frames - port->offset);
    }
    port->offset = offset;
    port->count += n;
    val = port->count;

    return (val);
}

static void
p16x_chinfo(void *arg, int chan, unsigned *offset, unsigned *incr)
{
    p16x_port_t *port = arg;
    unsigned mult;

    if (port->port_num == P16X_PLAY) {
        switch (chan) {
        case 0: /* left front */
        case 1: /* right front */
            mult = 0;
            break;
        case 2: /* center */
        case 3: /* lfe */
            mult = 2;
            break;
        case 4: /* left surround */
        case 5: /* right surround */
            mult = 1;
            break;
        }
        *offset = (port->buf_frames * 2 * mult) + (chan % 2);
        *incr = 2;
    } else {
        *offset = chan;
        *incr = 2;
    }
}

/* private implementation bits */

int
p16x_alloc_port(p16x_dev_t *dev, int num)
{
    p16x_port_t     *port;
    size_t          len;
    ddi_dma_cookie_t    cookie;
    uint_t          count;
    int         dir;
    unsigned        caps;
    audio_dev_t     *adev;

    adev = dev->adev;
    port = kmem_zalloc(sizeof (*port), KM_SLEEP);
    dev->port[num] = port;
    port->dev = dev;

    switch (num) {
    case P16X_REC:
        port->syncdir = DDI_DMA_SYNC_FORKERNEL;
        caps = ENGINE_INPUT_CAP;
        dir = DDI_DMA_READ;
        port->port_num = P16X_REC;
        port->nchan = 2;
        break;
    case P16X_PLAY:
        port->syncdir = DDI_DMA_SYNC_FORDEV;
        caps = ENGINE_OUTPUT_CAP;
        dir = DDI_DMA_WRITE;
        port->port_num = P16X_PLAY;
        port->nchan = 6;
        break;
    default:
        return (DDI_FAILURE);
    }

    /*
     * NB: The device operates in pairs of dwords at a time, for
     * performance reasons.  So make sure that our buffer is
     * arranged as a whole number of these.  The value below gives
     * a reasonably large buffer so we can support a deep
     * playahead if we need to (and we should avoid input
     * overruns.)
     */
    port->buf_frames = 4096;
    port->buf_size = port->buf_frames * port->nchan * sizeof (uint16_t);

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

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

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

    port->engine = audio_engine_alloc(&p16x_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);
}

void
p16x_destroy(p16x_dev_t *dev)
{
    mutex_destroy(&dev->mutex);

    for (int i = 0; i < P16X_NUM_PORT; i++) {
        p16x_port_t *port = dev->port[i];
        if (!port)
            continue;
        if (port->engine) {
            audio_dev_remove_engine(dev->adev, port->engine);
            audio_engine_free(port->engine);
        }
        if (port->buf_paddr) {
            (void) ddi_dma_unbind_handle(port->buf_dmah);
        }
        if (port->buf_acch) {
            ddi_dma_mem_free(&port->buf_acch);
        }
        if (port->buf_dmah) {
            ddi_dma_free_handle(&port->buf_dmah);
        }
        kmem_free(port, sizeof (*port));
    }

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

void
p16x_hwinit(p16x_dev_t *dev)
{
    p16x_port_t     *port;
    uint32_t        paddr;
    uint32_t        chunksz;
    int i;

    for (i = 0; i < 3; i++) {
        write_reg(dev, PTBA, i, 0);
        write_reg(dev, PTBS, i, 0);
        write_reg(dev, PTCA, i, 0);
        write_reg(dev, PFEA, i, 0);
        write_reg(dev, CPFA, i, 0);
        write_reg(dev, CPCAV, i, 0);
        write_reg(dev, CRFA, i, 0);
        write_reg(dev, CRCAV, i, 0);
    }
    write_reg(dev, SCS0, 0, 0x02108504);
    write_reg(dev, SCS1, 0, 0x02108504);
    write_reg(dev, SCS2, 0, 0x02108504);

    /* set the spdif/analog combo jack to analog out */
    write_reg(dev, SPC, 0, 0x00000700);
    write_reg(dev, EA_aux, 0, 0x0001003f);

    port = dev->port[P16X_REC];
    /* Set physical address of the DMA buffer */
    write_reg(dev, RFBA, 0, port->buf_paddr);
    write_reg(dev, RFBS, 0, (port->buf_size) << 16);

    /* Set physical address of the DMA buffer */
    port = dev->port[P16X_PLAY];
    paddr = port->buf_paddr;
    chunksz = port->buf_frames * 4;
    write_reg(dev, PFBA, 0, paddr);
    write_reg(dev, PFBS, 0, chunksz << 16);
    paddr += chunksz;
    write_reg(dev, PFBA, 1, paddr);
    write_reg(dev, PFBS, 1, chunksz << 16);
    paddr += chunksz;
    write_reg(dev, PFBA, 2, paddr);
    write_reg(dev, PFBS, 2, chunksz << 16);

    OUTL(dev, 0x1080, GPIO);    /* GPIO */
    /* Clear any pending interrupts */
    OUTL(dev, INTR_ALL, IP);
    OUTL(dev, 0, IE);
    OUTL(dev, 0x9, HC); /* Enable audio */
}

int
p16x_attach(dev_info_t *dip)
{
    uint16_t    vendor, device;
    p16x_dev_t  *dev;
    ddi_acc_handle_t pcih;

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

    mutex_init(&dev->mutex, NULL, MUTEX_DRIVER, NULL);

    if ((dev->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(dev->adev, "pci_config_setup failed");
        goto error;
    }
    dev->pcih = pcih;

    vendor = pci_config_get16(pcih, PCI_CONF_VENID);
    device = pci_config_get16(pcih, PCI_CONF_DEVID);
    if (vendor != CREATIVE_VENDOR_ID ||
        device != SB_P16X_ID) {
        audio_dev_warn(dev->adev, "Hardware not recognized "
            "(vendor=%x, dev=%x)", vendor, device);
        goto error;
    }

    /* set PCI command register */
    pci_config_put16(pcih, PCI_CONF_COMM,
        pci_config_get16(pcih, PCI_CONF_COMM) |
        PCI_COMM_MAE | PCI_COMM_IO);


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

    audio_dev_set_description(dev->adev, "Creative Sound Blaster Live!");
    audio_dev_set_version(dev->adev, "SBO200");

    if ((p16x_alloc_port(dev, P16X_PLAY) != DDI_SUCCESS) ||
        (p16x_alloc_port(dev, P16X_REC) != DDI_SUCCESS)) {
        goto error;
    }

    p16x_hwinit(dev);

    dev->ac97 = ac97_allocate(dev->adev, dip,
        p16x_read_ac97, p16x_write_ac97, dev);
    if (dev->ac97 == NULL) {
        audio_dev_warn(dev->adev, "failed to allocate ac97 handle");
        goto error;
    }

    ac97_probe_controls(dev->ac97);

    /* remove the AC'97 controls we don't want to expose */
    for (int i = 0; p16x_remove_ac97[i]; i++) {
        ac97_ctrl_t *ctrl;
        ctrl = ac97_control_find(dev->ac97, p16x_remove_ac97[i]);
        if (ctrl != NULL) {
            ac97_control_unregister(ctrl);
        }
    }

    ac97_register_controls(dev->ac97);

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

    ddi_report_dev(dip);

    return (DDI_SUCCESS);

error:
    p16x_destroy(dev);
    return (DDI_FAILURE);
}

int
p16x_resume(dev_info_t *dip)
{
    p16x_dev_t *dev;

    dev = ddi_get_driver_private(dip);

    p16x_hwinit(dev);

    ac97_reset(dev->ac97);

    audio_dev_resume(dev->adev);

    return (DDI_SUCCESS);
}

int
p16x_detach(p16x_dev_t *dev)
{
    if (audio_dev_unregister(dev->adev) != DDI_SUCCESS)
        return (DDI_FAILURE);

    p16x_destroy(dev);
    return (DDI_SUCCESS);
}

int
p16x_suspend(p16x_dev_t *dev)
{
    audio_dev_suspend(dev->adev);

    return (DDI_SUCCESS);
}

static int p16x_ddi_attach(dev_info_t *, ddi_attach_cmd_t);
static int p16x_ddi_detach(dev_info_t *, ddi_detach_cmd_t);
static int p16x_ddi_quiesce(dev_info_t *);

static struct dev_ops p16x_dev_ops = {
    DEVO_REV,       /* rev */
    0,          /* refcnt */
    NULL,           /* getinfo */
    nulldev,        /* identify */
    nulldev,        /* probe */
    p16x_ddi_attach,    /* attach */
    p16x_ddi_detach,    /* detach */
    nodev,          /* reset */
    NULL,           /* cb_ops */
    NULL,           /* bus_ops */
    NULL,           /* power */
    p16x_ddi_quiesce,   /* quiesce */
};

static struct modldrv p16x_modldrv = {
    &mod_driverops,     /* drv_modops */
    "Creative P16X Audio",  /* linkinfo */
    &p16x_dev_ops,      /* dev_ops */
};

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

int
_init(void)
{
    int rv;

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

int
_fini(void)
{
    int rv;

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

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

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

    case DDI_RESUME:
        return (p16x_resume(dip));

    default:
        return (DDI_FAILURE);
    }
}

int
p16x_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
    p16x_dev_t *dev;

    dev = ddi_get_driver_private(dip);

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

    case DDI_SUSPEND:
        return (p16x_suspend(dev));

    default:
        return (DDI_FAILURE);
    }
}

int
p16x_ddi_quiesce(dev_info_t *dip)
{
    p16x_dev_t  *dev;

    dev = ddi_get_driver_private(dip);

    write_reg(dev, SA, 0, 0);
    OUTL(dev, 0x01, HC);

    return (DDI_SUCCESS);
}