bus.c

Go to the documentation of this file.

/**
 * \file    heivs/bus.c
 * \see     heivs/bus.h
 */

#include "heivs/bus.h"

#if !USE_FREERTOS
    static void _mutex_init(const struct heivs_bus_t *bus)
    {
        (void)bus;
    }

    static void _mutex_get(const struct heivs_bus_t *bus)
    {
        (void)bus;
    }

    static void _mutex_put(const struct heivs_bus_t *bus)
    {
        (void)bus;
    }
#else

    #if !INCLUDE_vTaskSuspend
        #error INCLUDE_vTaskSuspend is necessary for bus mutexes
    #endif

    static void _mutex_init(const struct heivs_bus_t *bus)
    {
        if (!bus->var->mutex_ignore && bus->var->mutex == NULL)
        {
            bus->var->mutex = xSemaphoreCreateMutexNamed(bus->name);
        }
    }

    static void _mutex_get(const struct heivs_bus_t *bus)
    {
        if (bus->var->mutex == NULL)
        {
            _mutex_init(bus);
        }

        if (bus->var->mutex && !bus->var->mutex_ignore)
        {
            xSemaphoreTake(bus->var->mutex, portMAX_DELAY);
        }
    }

    static void _mutex_put(const struct heivs_bus_t *bus)
    {
        if (bus->var->mutex && !bus->var->mutex_ignore)
        {
            xSemaphoreGive(bus->var->mutex);
        }
    }
#endif

status_e bus_init(const struct heivs_bus_t *bus)
{
    status_e status;

    _mutex_init(bus);

    _mutex_get(bus);

    /* Bus state check */
    if (bus->var->state == BUS_ACTIVE)
    {
        _mutex_put(bus);
        return ERROR_BUS_BUSY;
    }

    if (bus->var->state == BUS_INACTIVE)
    {
        _mutex_put(bus);
        return NO_ERROR;
    }

    bus->var->state = BUS_INACTIVE;

    /* Now do it for real */
    status = bus->_init(bus);
    if (status != NO_ERROR)
    {
        bus->var->state = BUS_NOINIT;
        _mutex_put(bus);
        return status;
    }

    _mutex_put(bus);
    return status;
}

static status_e _verify_state(const struct heivs_bus_t *bus, enum heivs_bus_state_t required_state)
{
    if (!BUS_PARANOIA)
    {
        return NO_ERROR;
    }

    if (bus->var->state == required_state)
    {
        return NO_ERROR;
    }

    switch (bus->var->state)
    {
        case BUS_INACTIVE:
            bus_release(bus);
            return ERROR_BUS_INACTIVE;
        break;
        case BUS_SUSPENDED:
            bus_release(bus);
            return ERROR_BUS_SUSPENDED;
        break;
        case BUS_NOINIT:
            bus_release(bus);
            return ERROR_BUS_NOINIT;
        break;
        case BUS_ACTIVE:
            bus_release(bus);
            return ERROR_BUS_BAD_STATE;
        break;
        default:
            bus_release(bus);
            return ERROR_BAD_SWITCH;
        break;
    }

    return ERROR_NOT_YET_IMPLEMENTED;
}

status_e bus_get(const struct heivs_bus_t *bus)
{
    _mutex_get(bus);

    /* Bus state check */
    if (bus->var->state != BUS_INACTIVE)
    {
        return ERROR_BUS_BAD_STATE;
    }

    bus->var->state = BUS_ACTIVE;

    return NO_ERROR;
}

status_e bus_release(const struct heivs_bus_t *bus)
{
    /* Bus state check */
    if (bus->var->state != BUS_ACTIVE)
    {
        return ERROR_BUS_BAD_STATE;
    }

    bus->var->state = BUS_INACTIVE;

    _mutex_put(bus);
    return NO_ERROR;
}

status_e bus_suspend(const struct heivs_bus_t *bus)
{
    status_e status;

    /* Bus state check */
    status = bus->_suspend(bus);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    bus->var->state = BUS_SUSPENDED;

    return status;
}

status_e bus_resume(const struct heivs_bus_t *bus)
{
    status_e status;

    /* Bus state check */
    status = bus->_resume(bus);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    bus->var->state = BUS_ACTIVE;

    return status;
}


status_e bus_read(const struct heivs_bus_t *bus, uint32_t address, void *data, size_t len, size_t *rlen)
{
    status_e status;

    // A holder for the return len if the caller don't care
    size_t dont_care;

    if (!rlen)
    {
        rlen = &dont_care;
    }
    *rlen = 0;

    /* NO transfer, fine */
    if (!len)
    {
        return NO_ERROR;
    }

    /* No data buffer, that's bad */
    if (!data)
    {
        bus_release(bus);
        return ERROR_BAD_PARAM;
    }

    /* Bus state check */
    status = _verify_state(bus, BUS_ACTIVE);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    /* Now do it for real */
    status =  bus->_read(bus, address, data, len, rlen);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    return status;
}

status_e bus_write(const struct heivs_bus_t *bus, uint32_t address, const void *data, size_t len)
{
    status_e status;

    /* NO transfer, fine */
    if (!len)
    {
        return NO_ERROR;
    }

    /* No buffers, that's bad */
    if (!data)
    {
        bus_release(bus);
        return ERROR_BAD_PARAM;
    }

    /* Bus state check */
    status = _verify_state(bus, BUS_ACTIVE);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    /* Now do it for real */
    status =  bus->_write(bus, address, data, len);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    return status;
}

status_e bus_writeread(const struct heivs_bus_t *bus, uint32_t address, const void *src, size_t src_len, void *dst, size_t dst_len, size_t *rlen)
{
    status_e status;

    // A holder for the return len if the caller don't care
    size_t dont_care;

    if (!rlen)
    {
        rlen = &dont_care;
    }
    *rlen = 0;

    /* NO transfer, fine */
    if (!src_len && !dst_len)
    {
        return NO_ERROR;
    }

    /* TX only */
    if (!dst_len)
    {
        return bus_write(bus, address, src, src_len);
    }

    /* RX only */
    if (!src_len)
    {
        return bus_read(bus, address, dst, dst_len, rlen);
    }

    /* No data buffer, that's bad */
    if (!src || !dst)
    {
        bus_release(bus);
        return ERROR_BAD_PARAM;
    }

    /* Bus state check */
    status = _verify_state(bus, BUS_ACTIVE);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    /* Now do it for real */
    status = bus->_writeread(bus, address, src, src_len, dst, dst_len, rlen);
    if (status != NO_ERROR)
    {
        bus_release(bus);
        return status;
    }

    return status;
}