/*	$Id: at91pdcvar.h,v 1.3 2012/11/12 18:00:36 skrll Exp $	*/

#ifndef	_AT91PDCVAR_H_
#define	_AT91PDCVAR_H_

#include <arm/at91/at91pdcreg.h>
#include <sys/param.h>

#if	UNTESTED

typedef struct at91pdc_buf {
	void			*buf_arg;	/* argument (mbuf or other data) */
	int			buf_len;	/* length of data sent / recv */
	bus_dmamap_t		buf_dmamap;	/* dma map */
} at91pdc_buf_t;

typedef struct at91pdc_queue {
	at91pdc_buf_t		q_buf[2];	/* two buffers */
	unsigned		q_ndx;		/* buffer being sent (if q_len > 0) */
	unsigned		q_len;		/* number of buffers being used (<= 2) */
} at91pdc_queue_t;

#define	AT91PDC_UNLOAD_BUF(_pq, _dmat, _sync, _free) do {	\
	unsigned	_i = (_pq)->q_ndx % 2;			\
	at91pdc_buf_t	*_buf = &(_pq)->q_buf[i];		\
	void		*_arg = _buf->buf_arg;			\
								\
	if (_sync) {						\
		bus_dmamap_sync((_dmat), buf->buf_dmamap, 0,	\
				buf->buf_len, (_sync));		\
	}							\
	bus_dmamap_unload((_dmat), buf->buf_dmamap);		\
	buf->buf_arg = 0; buf->buf_len = 0;			\
								\
	(_pq)->q_ndx = i ^ 1;					\
	(_pq)->q_len--;						\
								\
	(_free)(_arg);						\
} while (/*CONSTCOND*/0)

#define	AT91PDC_UNLOAD_QUEUE(_pq, _dmat, _sync, _free, _idle)	\
do {								\
	if ((_pq)->q_len > 1)					\
		AT91PDC_UNLOAD_BUF(_pq, _dmat, _sync, _free);	\
	if ((_idle) && (_pq)->q_len > 0)			\
		AT91PDC_UNLOAD_BUF(_pq, _dmat, _sync, _free);	\
} while (/*CONSTCOND*/0)

#endif	/* UNTESTED */


typedef struct at91pdc_fifo {
	bus_dmamap_t	f_dmamap;	/* DMA map			*/
	void		*f_buf;		/* buffer address		*/
	int		f_buf_size;	/* size of the fifo		*/
	int		f_ndx;		/* current read/write index	*/
	int		f_length;	/* number of bytes in fifo	*/

	bus_addr_t	f_buf_addr;	/* buffer bus addr		*/
	int		f_pdc_rd_ndx;	/* PDC read index		*/
	int		f_pdc_wr_ndx;	/* PDC write index		*/
	int		f_pdc_space;	/* number of bytes allocated for pdc */
} at91pdc_fifo_t;

static __inline int AT91PDC_FIFO_EMPTY(at91pdc_fifo_t *fifo)
{
	return fifo->f_length == 0;
}

static __inline int AT91PDC_FIFO_FULL(at91pdc_fifo_t *fifo)
{
	return fifo->f_length >= fifo->f_buf_size;
}

static __inline int AT91PDC_FIFO_SPACE(at91pdc_fifo_t *fifo)
{
	return fifo->f_buf_size - fifo->f_length;
}


static __inline void AT91PDC_RESET_FIFO(bus_space_tag_t iot,
					 bus_space_handle_t ioh,
					 bus_dma_tag_t dmat,
					 uint offset,
					 at91pdc_fifo_t *fifo,
					 int rw)
{
	fifo->f_ndx = fifo->f_length = 0;

	fifo->f_pdc_rd_ndx = fifo->f_pdc_wr_ndx = 0;
	fifo->f_pdc_space = fifo->f_buf_size;

	if (!rw) {
		bus_space_write_4(iot, ioh, offset + PDC_RNCR, 0);
		bus_space_write_4(iot, ioh, offset + PDC_RCR, 0);
		bus_space_write_4(iot, ioh, offset + PDC_RNPR, fifo->f_buf_addr);
		bus_space_write_4(iot, ioh, offset + PDC_RPR, fifo->f_buf_addr);
	} else {
		bus_space_write_4(iot, ioh, offset + PDC_TNCR, 0);
		bus_space_write_4(iot, ioh, offset + PDC_TCR, 0);
		bus_space_write_4(iot, ioh, offset + PDC_TNPR, fifo->f_buf_addr);
		bus_space_write_4(iot, ioh, offset + PDC_TPR, fifo->f_buf_addr);
	}
}

static __inline int AT91PDC_FIFO_PREREAD(bus_space_tag_t iot,
					  bus_space_handle_t ioh,
					  bus_dma_tag_t dmat,
					  uint offset,
					  at91pdc_fifo_t *fifo,
					  uint chunk_size)
{
	int al;
	int ret = 1;

	/* then check if we can queue new block */
	if (bus_space_read_4(iot, ioh, offset + PDC_RNCR))
		goto get_out;
	if (fifo->f_pdc_space < chunk_size) {
		ret = 0;
		goto get_out;
	}
	/* fifo has enough space left for next chunk! */
	bus_dmamap_sync(dmat,
			fifo->f_dmamap,
			fifo->f_pdc_wr_ndx,
			chunk_size,
			BUS_DMASYNC_PREREAD);
	bus_space_write_4(iot, ioh, offset + PDC_RNPR, fifo->f_buf_addr + fifo->f_pdc_wr_ndx);
	bus_space_write_4(iot, ioh, offset + PDC_RNCR, chunk_size);
	if ((fifo->f_pdc_wr_ndx += chunk_size) >= fifo->f_buf_size)
		fifo->f_pdc_wr_ndx = 0;
	fifo->f_pdc_space -= chunk_size;
get_out:
	/* now check if we need to re-synchronize last read chunk too */
	al = fifo->f_pdc_rd_ndx % chunk_size;
	if (al) {
		bus_dmamap_sync(dmat,
				fifo->f_dmamap,
				fifo->f_pdc_rd_ndx,
				chunk_size - al,
				BUS_DMASYNC_PREREAD);
	}
	return ret;
}

static __inline void AT91PDC_FIFO_POSTREAD(bus_space_tag_t iot,
					    bus_space_handle_t ioh,
					    bus_dma_tag_t dmat,
					    uint offset,
					    at91pdc_fifo_t *fifo)
{
	uint32_t	pdc_ptr = bus_space_read_4(iot, ioh, offset + PDC_RPR);
	int32_t		cc = pdc_ptr - fifo->f_buf_addr - fifo->f_pdc_rd_ndx;

	/* handle fifo wrapping: */
	if (cc < 0) {
		cc = fifo->f_buf_size - fifo->f_pdc_rd_ndx;
		if (cc > 0) {
			bus_dmamap_sync(dmat, fifo->f_dmamap, fifo->f_pdc_rd_ndx, cc,
					BUS_DMASYNC_POSTREAD);
			fifo->f_length += cc;
			fifo->f_pdc_rd_ndx += cc;
		}
		fifo->f_pdc_rd_ndx = 0;
		cc = pdc_ptr - fifo->f_buf_addr;
	}

	if (cc > 0) {
		/* data has been received! */
		bus_dmamap_sync(dmat, fifo->f_dmamap, fifo->f_pdc_rd_ndx, cc,
				BUS_DMASYNC_POSTREAD);
		fifo->f_length += cc;
		fifo->f_pdc_rd_ndx += cc;
	}
}

static __inline void *AT91PDC_FIFO_RDPTR(at91pdc_fifo_t *fifo, int *num_bytes)
{
	if (fifo->f_length <= 0) {
		return NULL;
	}
	int contig_bytes = fifo->f_buf_size - fifo->f_ndx;
	if (contig_bytes > fifo->f_length)
		contig_bytes = fifo->f_length;
	*num_bytes = contig_bytes;
	return (void*)((uintptr_t)fifo->f_buf + fifo->f_ndx);
}

static __inline void AT91PDC_FIFO_READ(at91pdc_fifo_t *fifo, int bytes_read)
{
	if (bytes_read > fifo->f_length)
		bytes_read = fifo->f_length;
	int contig_bytes = fifo->f_buf_size - fifo->f_ndx;
	fifo->f_length -= bytes_read;
	fifo->f_pdc_space += bytes_read;
	if (bytes_read < contig_bytes)
		fifo->f_ndx += bytes_read;
	else
		fifo->f_ndx = bytes_read - contig_bytes;
}

static __inline int AT91PDC_FIFO_PREWRITE(bus_space_tag_t iot,
					   bus_space_handle_t ioh,
					   bus_dma_tag_t dmat,
					   uint offset,
					   at91pdc_fifo_t *fifo,
					   uint max_chunk_size)
{
	if (bus_space_read_4(iot, ioh, offset + PDC_TNCR) != 0)
		return 1;
	int len = fifo->f_buf_size - fifo->f_pdc_rd_ndx;
	int max_len = fifo->f_length - (fifo->f_buf_size - fifo->f_pdc_space);
	if (len > max_len)
		len = max_len;
	if (len > max_chunk_size)
		len = max_chunk_size;
	if (len > fifo->f_pdc_space)
		panic("%s: len %d > pdc_space (f_length=%d space=%d size=%d)",
		      __FUNCTION__, len, fifo->f_length, fifo->f_pdc_space, fifo->f_buf_size);
	if (len == 0)
		return 0;
	if (len < 0)
		panic("%s: len < 0 (f_length=%d space=%d size=%d)",
		      __FUNCTION__, fifo->f_length, fifo->f_pdc_space, fifo->f_buf_size);

	/* there's something to write */
	bus_dmamap_sync(dmat,
			fifo->f_dmamap,
			fifo->f_pdc_rd_ndx,
			len,
			BUS_DMASYNC_PREWRITE);
	bus_space_write_4(iot, ioh, offset + PDC_TNPR, fifo->f_buf_addr + fifo->f_pdc_rd_ndx);
	bus_space_write_4(iot, ioh, offset + PDC_TNCR, len);
	if ((fifo->f_pdc_rd_ndx += len) >= fifo->f_buf_size)
		fifo->f_pdc_rd_ndx = 0;
	fifo->f_pdc_space -= len;

	return 1;
}

static __inline void AT91PDC_FIFO_POSTWRITE(bus_space_tag_t iot,
					     bus_space_handle_t ioh,
					     bus_dma_tag_t dmat,
					     uint offset,
					     at91pdc_fifo_t *fifo)
{
	uint32_t	pdc_ptr = bus_space_read_4(iot, ioh, offset + PDC_TPR);
	int32_t		cc = pdc_ptr - fifo->f_buf_addr - fifo->f_pdc_wr_ndx;

	/* handle fifo wrapping: */
	if (cc < 0) {
		cc = fifo->f_buf_size - fifo->f_pdc_wr_ndx;
		if (cc > 0) {
			bus_dmamap_sync(dmat, fifo->f_dmamap, fifo->f_pdc_wr_ndx, cc,
					BUS_DMASYNC_POSTWRITE);
			fifo->f_length -= cc;
			fifo->f_pdc_space += cc;
		}
		fifo->f_pdc_wr_ndx = 0;
		cc = pdc_ptr - fifo->f_buf_addr;
	}

	if (cc > 0) {
		/* data has been sent! */
		bus_dmamap_sync(dmat, fifo->f_dmamap, fifo->f_pdc_wr_ndx, cc,
				BUS_DMASYNC_POSTWRITE);
		fifo->f_length -= cc;
		fifo->f_pdc_space += cc;
		fifo->f_pdc_wr_ndx += cc;
	}
}

static __inline void *AT91PDC_FIFO_WRPTR(at91pdc_fifo_t *fifo, int *max_bytes)
{
	int space = fifo->f_buf_size - fifo->f_length;
	if (space <= 0)
		return NULL;
	int contig_bytes = fifo->f_buf_size - fifo->f_ndx;
	if (contig_bytes > space)
		contig_bytes = space;
	*max_bytes = contig_bytes;
	return (void*)((uintptr_t)fifo->f_buf + fifo->f_ndx);
}

static __inline void AT91PDC_FIFO_WRITTEN(at91pdc_fifo_t *fifo, int bytes_written)
{
	if (bytes_written > (fifo->f_buf_size - fifo->f_length))
		bytes_written = (fifo->f_buf_size - fifo->f_length);
	int contig_bytes = fifo->f_buf_size - fifo->f_ndx;
	fifo->f_length += bytes_written;
	if (bytes_written < contig_bytes)
		fifo->f_ndx += bytes_written;
	else
		fifo->f_ndx = bytes_written - contig_bytes;
}

int at91pdc_alloc_fifo(bus_dma_tag_t dmat, at91pdc_fifo_t *fifo, int size, int flags);

#endif	// !_AT91PDCVAR_H_