/*
* Copyright (C) 2008 Niklaus Giger <niklaus.giger@member.fsf.org>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
*/

#include <stdlib.h>
#include <boilerplate/lock.h>
#include <copperplate/heapobj.h>
#include <vxworks/errnoLib.h>
#include "rngLib.h"

#define ring_magic 0x5432affe

static struct wind_ring *find_ring_from_id(RING_ID rid)
{
	struct wind_ring *ring = mainheap_deref(rid, struct wind_ring);

	if (ring == NULL || ((uintptr_t)ring & (sizeof(uintptr_t)-1)) != 0 ||
	    ring->magic != ring_magic)
		return NULL;

	return ring;
}

RING_ID rngCreate(int nbytes)
{
	struct wind_ring *ring;
	struct service svc;
	void *ring_mem;
	RING_ID rid;

	if (nbytes <= 0) {
		errnoSet(S_memLib_NOT_ENOUGH_MEMORY);
		return 0;
	}

	CANCEL_DEFER(svc);

	ring_mem = xnmalloc(sizeof(*ring) + nbytes + 1);
	if (ring_mem == NULL) {
		rid = 0;
		errno = errnoSet(S_memLib_NOT_ENOUGH_MEMORY);
		goto out;
	}

	ring = ring_mem;
	ring->magic = ring_magic;
	ring->bufSize = nbytes;
	ring->readPos = 0;
	ring->writePos = 0;
	rid = mainheap_ref(ring, RING_ID);
out:
	CANCEL_RESTORE(svc);

	return rid;
}

void rngDelete(RING_ID rid)
{
	struct wind_ring *ring = find_ring_from_id(rid);
	struct service svc;

	if (ring) {
		ring->magic = 0;
		CANCEL_DEFER(svc);
		xnfree(ring);
		CANCEL_RESTORE(svc);
	}
}

void rngFlush(RING_ID rid)
{
	struct wind_ring *ring = find_ring_from_id(rid);

	if (ring) {
		ring->readPos = 0;
		ring->writePos = 0;
	}
}

int rngBufGet(RING_ID rid, char *buffer, int maxbytes)
{
	struct wind_ring *ring = find_ring_from_id(rid);
	unsigned int savedWritePos;
	int j, bytesRead = 0;

	if (ring == NULL)
		return ERROR;

	savedWritePos = ring->writePos;

	for (j = 0; j < maxbytes; j++) {
		if ((ring->readPos) % (ring->bufSize + 1) == savedWritePos)
			break;
		buffer[j] = ring->buffer[ring->readPos];
		++bytesRead;
		ring->readPos = (ring->readPos + 1) % (ring->bufSize + 1);
	}

	return bytesRead;
}

int rngBufPut(RING_ID rid, char *buffer, int nbytes)
{
	struct wind_ring *ring = find_ring_from_id(rid);
	unsigned int savedReadPos;
	int j, bytesWritten = 0;

	if (ring == NULL)
		return ERROR;

	savedReadPos = ring->readPos;

	for (j = 0; j < nbytes; j++) {
		if ((ring->writePos + 1) % (ring->bufSize + 1) == savedReadPos)
			break;
		ring->buffer[ring->writePos] = buffer[j];
		++bytesWritten;
		ring->writePos = (ring->writePos + 1) % (ring->bufSize + 1);
	}

	return bytesWritten;
}

BOOL rngIsEmpty(RING_ID rid)
{
	struct wind_ring *ring = find_ring_from_id(rid);

	if (ring == NULL)
		return ERROR;

	return rngFreeBytes(rid) == (int)ring->bufSize;
}

BOOL rngIsFull(RING_ID rid)
{
	struct wind_ring *ring = find_ring_from_id(rid);

	if (ring == NULL)
		return ERROR;

	return rngFreeBytes(rid) == 0;
}

int rngFreeBytes(RING_ID rid)
{
	struct wind_ring *ring = find_ring_from_id(rid);

	if (ring == NULL)
		return ERROR;

	return ((ring->bufSize -
		 (ring->writePos - ring->readPos)) % (ring->bufSize + 1));
}

int rngNBytes(RING_ID rid)
{
	struct wind_ring *ring = find_ring_from_id(rid);

	if (ring == NULL)
		return ERROR;

	return ring->bufSize - rngFreeBytes(rid);
}

void rngPutAhead(RING_ID rid, char byte, int offset)
{
	struct wind_ring *ring = find_ring_from_id(rid);
	int where;

	if (ring) {
		where = (ring->writePos + offset) % (ring->bufSize + 1);
		ring->buffer[where] = byte;
	}
}

void rngMoveAhead(RING_ID rid, int n)
{
	struct wind_ring *ring = find_ring_from_id(rid);

	if (ring) {
		ring->writePos += n;
		ring->writePos %= (ring->bufSize + 1);
	}
}