source: mainline/uspace/drv/audio/hdaudio/stream.c@ fff4f21

/*
 * Copyright (c) 2014 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup hdaudio
 * @{
 */
/** @file High Definition Audio stream
 */

#include <as.h>
#include <bitops.h>
#include <byteorder.h>
#include <ddf/log.h>
#include <ddi.h>
#include <errno.h>
#include <macros.h>
#include <stdlib.h>

#include "hdactl.h"
#include "hdaudio.h"
#include "regif.h"
#include "spec/bdl.h"
#include "stream.h"

static int hda_stream_buffers_alloc(hda_stream_t *stream)
{
        void *bdl;
        void *buffer;
        uintptr_t buffer_phys;
        size_t i;
//      size_t j, k;
        int rc;

        stream->nbuffers = 4;
        stream->bufsize = 16384;

        /*
         * BDL must be aligned to 128 bytes. If 64OK is not set,
         * it must be within the 32-bit address space.
         */
        bdl = AS_AREA_ANY;
        rc = dmamem_map_anonymous(stream->nbuffers * sizeof(hda_buffer_desc_t),
            stream->hda->ctl->ok64bit ? 0 : DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE,
            0, &stream->bdl_phys, &bdl);
        if (rc != EOK)
                goto error;

        stream->bdl = bdl;

        /* Allocate arrays of buffer pointers */

        stream->buf = calloc(stream->nbuffers, sizeof(void *));
        if (stream->buf == NULL)
                goto error;

        stream->buf_phys = calloc(stream->nbuffers, sizeof(uintptr_t));
        if (stream->buf_phys == NULL)
                goto error;

        /* Allocate buffers */
/*
        for (i = 0; i < stream->nbuffers; i++) {
                buffer = AS_AREA_ANY;
                rc = dmamem_map_anonymous(stream->bufsize,
                    stream->hda->ctl->ok64bit ? 0 : DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE,
                    0, &buffer_phys, &buffer);
                if (rc != EOK)
                        goto error;

                ddf_msg(LVL_NOTE, "Stream buf phys=0x%llx virt=%p",
                    (unsigned long long)buffer_phys, buffer);

                stream->buf[i] = buffer;
                stream->buf_phys[i] = buffer_phys;

                k = 0;
                for (j = 0; j < stream->bufsize / 2; j++) {
                        int16_t *bp = stream->buf[i];
                        bp[j] = (k > 128) ? -100 : 100;
                        ++k;
                        if (k >= 256)
                                k = 0;
                }
        }
*/
//      async_usleep(1000*1000);
        /* audio_pcm_iface requires a single contiguous buffer */
        buffer = AS_AREA_ANY;
        rc = dmamem_map_anonymous(stream->bufsize * stream->nbuffers,
            stream->hda->ctl->ok64bit ? 0 : DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE,
            0, &buffer_phys, &buffer);
        if (rc != EOK) {
                ddf_msg(LVL_NOTE, "dmamem_map_anon -> %d", rc);
                goto error;
        }

        for (i = 0; i < stream->nbuffers; i++) {
                stream->buf[i] = buffer + i * stream->bufsize;
                stream->buf_phys[i] = buffer_phys + i * stream->bufsize;

                ddf_msg(LVL_NOTE, "Stream buf phys=0x%llx virt=%p",
                    (long long unsigned)(uintptr_t)stream->buf[i],
                    (void *)stream->buf_phys[i]);
/*              k = 0;
                for (j = 0; j < stream->bufsize / 2; j++) {
                        int16_t *bp = stream->buf[i];
                        bp[j] = (k > 128) ? -10000 : 10000;
                        ++k;
                        if (k >= 256)
                                k = 0;
                }
*/
        }

        /* Fill in BDL */
        for (i = 0; i < stream->nbuffers; i++) {
                stream->bdl[i].address = host2uint64_t_le(stream->buf_phys[i]);
                stream->bdl[i].length = host2uint32_t_le(stream->bufsize);
                stream->bdl[i].flags = BIT_V(uint32_t, bdf_ioc);
        }

        return EOK;
error:
        return ENOMEM;
}

static void hda_stream_desc_configure(hda_stream_t *stream)
{
        hda_sdesc_regs_t *sdregs;
        uint8_t ctl1;
        uint8_t ctl3;

        ctl3 = (stream->sid << 4);
        ctl1 = 0x4;

        sdregs = &stream->hda->regs->sdesc[stream->sdid];
        hda_reg8_write(&sdregs->ctl3, ctl3);
        hda_reg8_write(&sdregs->ctl1, ctl1);
        hda_reg32_write(&sdregs->cbl, stream->nbuffers * stream->bufsize);
        hda_reg16_write(&sdregs->lvi, stream->nbuffers - 1);
        hda_reg16_write(&sdregs->fmt, stream->fmt);
        hda_reg32_write(&sdregs->bdpl, LOWER32(stream->bdl_phys));
        hda_reg32_write(&sdregs->bdpu, UPPER32(stream->bdl_phys));
}

static void hda_stream_set_run(hda_stream_t *stream, bool run)
{
        uint32_t ctl;
        hda_sdesc_regs_t *sdregs;

        sdregs = &stream->hda->regs->sdesc[stream->sdid];

        ctl = hda_reg8_read(&sdregs->ctl1);
        if (run)
                ctl = ctl | BIT_V(uint8_t, sdctl1_run);
        else
                ctl = ctl & ~BIT_V(uint8_t, sdctl1_run);

        hda_reg8_write(&sdregs->ctl1, ctl);
}

static void hda_stream_reset_noinit(hda_stream_t *stream)
{
        uint32_t ctl;
        hda_sdesc_regs_t *sdregs;

        sdregs = &stream->hda->regs->sdesc[stream->sdid];

        ctl = hda_reg8_read(&sdregs->ctl1);
        ctl = ctl | BIT_V(uint8_t, sdctl1_srst);
        hda_reg8_write(&sdregs->ctl1, ctl);

        async_usleep(100 * 1000);

        ctl = hda_reg8_read(&sdregs->ctl1);
        ctl = ctl & ~BIT_V(uint8_t, sdctl1_srst);
        hda_reg8_write(&sdregs->ctl1, ctl);

        async_usleep(100 * 1000);
}

hda_stream_t *hda_stream_create(hda_t *hda, hda_stream_dir_t dir,
    uint32_t fmt)
{
        hda_stream_t *stream;
        int rc;

        stream = calloc(1, sizeof(hda_stream_t));
        if (stream == NULL)
                return NULL;

        stream->hda = hda;
        stream->dir = dir;
        stream->sid = 1; /* XXX Allocate this */
        stream->sdid = hda->ctl->iss; /* XXX Allocate - First output SDESC */
        stream->fmt = fmt;

        ddf_msg(LVL_NOTE, "snum=%d sdidx=%d", stream->sid, stream->sdid);

        ddf_msg(LVL_NOTE, "Allocate buffers");
        rc = hda_stream_buffers_alloc(stream);
        if (rc != EOK)
                goto error;

        ddf_msg(LVL_NOTE, "Configure stream descriptor");
        hda_stream_desc_configure(stream);
        return stream;
error:
        return NULL;
}

void hda_stream_destroy(hda_stream_t *stream)
{
        ddf_msg(LVL_NOTE, "hda_stream_destroy()");
        hda_stream_reset_noinit(stream);
        free(stream);
}

void hda_stream_start(hda_stream_t *stream)
{
        ddf_msg(LVL_NOTE, "hda_stream_start()");
        hda_stream_set_run(stream, true);
}

void hda_stream_stop(hda_stream_t *stream)
{
        ddf_msg(LVL_NOTE, "hda_stream_stop()");
        hda_stream_set_run(stream, false);
}

void hda_stream_reset(hda_stream_t *stream)
{
        ddf_msg(LVL_NOTE, "hda_stream_reset()");
        hda_stream_reset_noinit(stream);
        hda_stream_desc_configure(stream);
}

/** @}
 */