bankmem.c

Go to the documentation of this file.

/*
 * Copyright (C) 2004 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``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 EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS 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.
 *
 * For additional information see http://www.ethernut.de/
 *
 */

#include <sys/heap.h>

#include <stdint.h>


#include <sys/bankmem.h>

static char segbuf_empty;
static uint32_t segbuf_total;
static uint32_t segbuf_used;

static char *segbuf_start;
static char *segbuf_end;


static char *segbuf_wp;
static char segbuf_ws;
static char *segbuf_rp;
static char segbuf_rs;

char *NutSegBufReset(void)
{
    segbuf_rp = segbuf_wp = segbuf_start;
    segbuf_rs = segbuf_ws = 0;
    NutSegBufEnable(0);
    segbuf_empty = 1;
    segbuf_used = 0;

    return segbuf_start;
}

char *NutSegBufInit(size_t size)
{

#if NUTBANK_COUNT
    segbuf_start = (char *)(NUTBANK_START);
    segbuf_end = (char *)(NUTBANK_START) + NUTBANK_SIZE;
    segbuf_total = (uint32_t) NUTBANK_COUNT *(uint32_t) NUTBANK_SIZE;
#else
    if (size == 0)
        size = NutHeapAvailable() / 2;
    if (segbuf_start) {
        NutHeapFree(segbuf_start);
    }
    if ((segbuf_start = NutHeapAlloc(size)) != NULL)
        segbuf_end = segbuf_start + size;
    segbuf_total = size;
#endif

    return NutSegBufReset();
}

char *NutSegBufWriteRequest(size_t * bcp)
{
    if (segbuf_empty || segbuf_ws != segbuf_rs || segbuf_wp > segbuf_rp)
        *bcp = segbuf_end - segbuf_wp;
    else
        *bcp = segbuf_rp - segbuf_wp;

    NutSegBufEnable(segbuf_ws);
    return segbuf_wp;
}

char *NutSegBufReadRequest(size_t * bcp)
{
    if (segbuf_empty)
        *bcp = 0;
    else if (segbuf_ws != segbuf_rs || segbuf_rp >= segbuf_wp)
        *bcp = segbuf_end - segbuf_rp;
    else if ((*bcp = segbuf_wp - segbuf_rp) == 0 && segbuf_ws == segbuf_rs)
        segbuf_empty = 1;

    NutSegBufEnable(segbuf_rs);
    return segbuf_rp;
}

char *NutSegBufWriteCommit(size_t bc)
{
    if (bc) {
        segbuf_wp += bc;
        segbuf_empty = 0;
        segbuf_used += bc;
        if (segbuf_wp == segbuf_end) {
            segbuf_wp = segbuf_start;
#if NUTBANK_COUNT > 0
            if (++segbuf_ws >= NUTBANK_COUNT)
                segbuf_ws = 0;
#endif
            NutSegBufEnable(segbuf_ws);
        }
    }
    return segbuf_wp;
}

char *NutSegBufReadCommit(size_t bc)
{
    if (bc) {
        segbuf_rp += bc;
        segbuf_used -= bc;
        if (segbuf_rp == segbuf_end) {
            segbuf_rp = segbuf_start;
#if NUTBANK_COUNT > 0
            if (++segbuf_rs >= NUTBANK_COUNT)
                segbuf_rs = 0;
#endif
            NutSegBufEnable(segbuf_rs);
        }
        if (segbuf_rp == segbuf_wp  && segbuf_rs == segbuf_ws)
            segbuf_empty = 1;
    }
    return segbuf_rp;
}


void NutSegBufWriteLast(size_t bc)
{
    if (bc) {
        segbuf_wp += bc;
        segbuf_used += bc;
        segbuf_empty = 0;
        if (segbuf_wp == segbuf_end) {
            segbuf_wp = segbuf_start;
#if NUTBANK_COUNT > 0
            if (++segbuf_ws >= NUTBANK_COUNT)
                segbuf_ws = 0;
#endif
        }
    }
    NutSegBufEnable(segbuf_rs);
}

void NutSegBufReadLast(size_t bc)
{
    if (bc) {
        segbuf_rp += bc;
        segbuf_used -= bc;
        if (segbuf_rp == segbuf_end) {
            segbuf_rp = segbuf_start;
#if NUTBANK_COUNT > 0
            if (++segbuf_rs >= NUTBANK_COUNT)
                segbuf_rs = 0;
#endif
        }
        if (segbuf_rp == segbuf_wp && segbuf_rs == segbuf_ws)
            segbuf_empty = 1;
    }
    NutSegBufEnable(segbuf_ws);
}


uint32_t NutSegBufAvailable(void)
{
    return segbuf_total - segbuf_used;
}

uint32_t NutSegBufUsed(void)
{
    return segbuf_used;
}