source: mainline/uspace/lib/usb/src/dma_buffer.c

/*
 * Copyright (c) 2018 Ondrej Hlavaty
 * 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 libusb
 * @{
 */
/** @file
 */

#include <align.h>
#include <as.h>
#include <ddi.h>
#include <stddef.h>

#include "usb/dma_buffer.h"

dma_policy_t dma_policy_create(unsigned flags, size_t chunk_size)
{
        assert((chunk_size & (chunk_size - 1)) == 0); /* Check if power of 2 */
        assert(chunk_size >= PAGE_SIZE || chunk_size == 0);

        return ((chunk_size - 1) & DMA_POLICY_CHUNK_SIZE_MASK) |
            (flags & DMA_POLICY_FLAGS_MASK);
}

/**
 * As the driver is typically using only a few buffers at once, we cache the
 * physical mapping to avoid calling the kernel unnecessarily often. This cache
 * is global for a task.
 *
 * TODO: "few" is currently limited to one.
 */
static struct {
        const void *last;
        uintptr_t phys;
} phys_mapping_cache = { 0 };

static void cache_insert(const void *v, uintptr_t p)
{
        phys_mapping_cache.last = v;
        phys_mapping_cache.phys = p;
}

static void cache_evict(const void *v)
{
        if (phys_mapping_cache.last == v)
                phys_mapping_cache.last = NULL;
}

static bool cache_find(const void *v, uintptr_t *p)
{
        *p = phys_mapping_cache.phys;
        return phys_mapping_cache.last == v;
}

/**
 * Allocate a DMA buffer.
 *
 * @param[in] db dma_buffer_t structure to fill
 * @param[in] size Size of the required memory space
 * @param[in] policy dma_policy_t flags to guide the allocation
 * @return Error code.
 */
errno_t dma_buffer_alloc_policy(dma_buffer_t *db, size_t size, dma_policy_t policy)
{
        assert(db);

        const size_t real_size = ALIGN_UP(size, PAGE_SIZE);
        const bool need_4gib = !!(policy & DMA_POLICY_4GiB);

        const uintptr_t flags = need_4gib ? DMAMEM_4GiB : 0;

        uintptr_t phys;
        void *address = AS_AREA_ANY;

        const int err = dmamem_map_anonymous(real_size,
            flags, AS_AREA_READ | AS_AREA_WRITE, 0,
            &phys, &address);
        if (err)
                return err;

        /* Access the pages to force mapping */
        volatile char *buf = address;
        for (size_t i = 0; i < size; i += PAGE_SIZE)
                buf[i] = 0xff;

        db->virt = address;
        db->policy = dma_policy_create(policy, 0);
        cache_insert(db->virt, phys);

        return EOK;
}

/**
 * Allocate a DMA buffer using the default policy.
 *
 * @param[in] db dma_buffer_t structure to fill
 * @param[in] size Size of the required memory space
 * @return Error code.
 */
errno_t dma_buffer_alloc(dma_buffer_t *db, size_t size)
{
        return dma_buffer_alloc_policy(db, size, DMA_POLICY_DEFAULT);
}

/**
 * Free a DMA buffer.
 *
 * @param[in] db dma_buffer_t structure buffer of which will be freed
 */
void dma_buffer_free(dma_buffer_t *db)
{
        if (db->virt) {
                dmamem_unmap_anonymous(db->virt);
                db->virt = NULL;
                db->policy = 0;
        }
}

/**
 * Convert a pointer inside a buffer to physical address.
 *
 * @param[in] db Buffer at which virt is pointing
 * @param[in] virt Pointer somewhere inside db
 */
uintptr_t dma_buffer_phys(const dma_buffer_t *db, const void *virt)
{
        const size_t chunk_mask = dma_policy_chunk_mask(db->policy);
        const uintptr_t offset = (virt - db->virt) & chunk_mask;
        const void *chunk_base = virt - offset;

        uintptr_t phys;

        if (!cache_find(chunk_base, &phys)) {
                if (as_get_physical_mapping(chunk_base, &phys))
                        return 0;
                cache_insert(chunk_base, phys);
        }

        return phys + offset;
}

static bool dma_buffer_is_4gib(dma_buffer_t *db, size_t size)
{
        if (sizeof(uintptr_t) <= 32)
                return true;

        const size_t chunk_size = dma_policy_chunk_mask(db->policy) + 1;
        const size_t chunks = chunk_size ? 1 : size / chunk_size;

        for (size_t c = 0; c < chunks; c++) {
                const void *addr = db->virt + (c * chunk_size);
                const uintptr_t phys = dma_buffer_phys(db, addr);

                if ((phys & DMAMEM_4GiB) != 0)
                        return false;
        }

        return true;
}

/**
 * Lock an arbitrary buffer for DMA operations, creating a DMA buffer.
 *
 * FIXME: To handle page-unaligned buffers, we need to calculate the base
 *        address and lock the whole first page. But as the operation is not yet
 *        implemented in the kernel, it doesn't matter.
 */
errno_t dma_buffer_lock(dma_buffer_t *db, void *virt, size_t size)
{
        assert(virt);

        uintptr_t phys;

        const errno_t err = dmamem_map(virt, size, 0, 0, &phys);
        if (err)
                return err;

        db->virt = virt;
        db->policy = dma_policy_create(0, PAGE_SIZE);
        cache_insert(virt, phys);

        unsigned flags = -1U;
        if (!dma_buffer_is_4gib(db, size))
                flags &= ~DMA_POLICY_4GiB;
        db->policy = dma_policy_create(flags, PAGE_SIZE);

        return EOK;
}

/**
 * Unlock a buffer for DMA operations.
 */
void dma_buffer_unlock(dma_buffer_t *db, size_t size)
{
        if (db->virt) {
                dmamem_unmap(db->virt, size);
                db->virt = NULL;
                db->policy = 0;
        }
}

/**
 * Must be called when the buffer is received over IPC. Clears potentially
 * leftover value from different buffer mapped to the same virtual address.
 */
void dma_buffer_acquire(dma_buffer_t *db)
{
        cache_evict(db->virt);
}

/**
 * Counterpart of acquire.
 */
void dma_buffer_release(dma_buffer_t *db)
{
        cache_evict(db->virt);
}

/**
 * @}
 */