/* ----------------------------------------------------------------------------
 *         SAM Software Package License
 * ----------------------------------------------------------------------------
 * Copyright (c) 2015, Atmel Corporation
 *
 * 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 disclaimer below.
 *
 * Atmel's name may not be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
 * ----------------------------------------------------------------------------
 */


#include "peripherals/aic.h"
#ifdef CONFIG_HAVE_FLEXCOM
#include "peripherals/flexcom.h"
#endif
#include "peripherals/pmc.h"
#include "peripherals/spid.h"
#include "peripherals/spi.h"
#include "peripherals/xdmac.h"
#include "peripherals/xdmad.h"
#include "peripherals/l2cc.h"

#include "cortex-a/cp15.h"

#include "trace.h"

#include <stddef.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>

#define SPID_ATTRIBUTE_MASK     (SPI_MR_PS | SPI_MR_MODFDIS | SPI_MR_MSTR | SPI_MR_WDRBT)
#define SPID_DMA_THRESHOLD      16

static uint32_t _garbage = 0;

static void _spid_xdmad_callback_wrapper(struct _xdmad_channel *channel,
					 void *arg)
{
	trace_debug("SPID DMA Transfert Finished\r\n");
	struct _spi_desc* spid = (struct _spi_desc*) arg;

	xdmad_free_channel(channel);

	if (spid->region_start && spid->region_end) {
		l2cc_invalidate_region(spid->region_start, spid->region_end);
	}

	if (spid && spid->callback)
		spid->callback(spid, spid->cb_args);
}

static void _spid_xdmad_cleanup_callback(struct _xdmad_channel *channel,
					 void *arg)
{
	xdmad_free_channel(channel);
}

#ifdef CONFIG_HAVE_SPI_FIFO
static void spid_fifo_error(void)
{
	trace_error("Fifo pointer error encountered !!\r\n");
}
#endif

void spid_configure(struct _spi_desc* desc)
{
	uint32_t id = get_spi_id_from_addr(desc->addr);

#ifdef CONFIG_HAVE_FLEXCOM
	Flexcom* flexcom = get_flexcom_addr_from_id(id);
	if (flexcom) {
		flexcom_select(flexcom, FLEX_MR_OPMODE_SPI);
	}
#endif
	/* Enable SPI early otherwise FIFO configuration won't be applied */
	pmc_enable_peripheral(id);
	if (desc->transfert_mode == SPID_MODE_FIFO) {
		desc->attributes &= ~SPI_MR_WDRBT;
	}
	spi_configure(desc->addr, (desc->attributes & SPID_ATTRIBUTE_MASK) | SPI_MR_MSTR);
	spi_chip_select(desc->addr, desc->chip_select);
	spi_configure_cs(desc->addr, desc->chip_select, desc->bitrate,
			 desc->dlybs, desc->dlybct, desc->spi_mode, 0);
#ifdef CONFIG_HAVE_SPI_FIFO
	if (desc->transfert_mode == SPID_MODE_FIFO) {
		spi_fifo_configure(desc->addr, SPI_FIFO_DEPTH, SPI_FIFO_DEPTH,
				   SPI_FMR_TXRDYM_ONE_DATA | SPI_FMR_RXRDYM_ONE_DATA);
		spi_enable_it(desc->addr, SPI_IER_TXFPTEF | SPI_IER_RXFPTEF);
		aic_set_source_vector(id, spid_fifo_error);
		aic_enable(id);
	}
#endif
	(void)spi_get_status(desc->addr);

	spi_enable(desc->addr);
}

void spid_begin_transfert(struct _spi_desc* desc)
{
	spi_chip_select(desc->addr, desc->chip_select);
	spi_configure_cs_mode(desc->addr, desc->chip_select, SPI_KEEP_CS_OW);
}

static void _spid_init_dma_write_channel(const struct _spi_desc* desc,
					 struct _xdmad_channel** channel,
					 struct _xdmad_cfg* cfg)
{
	assert(cfg);
	assert(channel);

	uint32_t id = get_spi_id_from_addr(desc->addr);

	memset(cfg, 0x0, sizeof(*cfg));

	*channel =
		xdmad_allocate_channel(XDMAD_PERIPH_MEMORY, id);
	assert(*channel);

	xdmad_prepare_channel(*channel);
	cfg->cfg.uint32_value = XDMAC_CC_TYPE_PER_TRAN
		| XDMAC_CC_DSYNC_MEM2PER
		| XDMAC_CC_MEMSET_NORMAL_MODE
		| XDMAC_CC_CSIZE_CHK_1
		| XDMAC_CC_DWIDTH_BYTE
		| XDMAC_CC_DIF_AHB_IF1
		| XDMAC_CC_SIF_AHB_IF0
		| XDMAC_CC_DAM_FIXED_AM;

	cfg->dest_addr = (void*)&desc->addr->SPI_TDR;
}

static void _spid_init_dma_read_channel(const struct _spi_desc* desc,
					 struct _xdmad_channel** channel,
					 struct _xdmad_cfg* cfg)
{
	assert(cfg);
	assert(channel);

	uint32_t id = get_spi_id_from_addr(desc->addr);

	memset(cfg, 0x0, sizeof(*cfg));

	*channel =
		xdmad_allocate_channel(id, XDMAD_PERIPH_MEMORY);
	assert(*channel);

	xdmad_prepare_channel(*channel);
	cfg->cfg.uint32_value = XDMAC_CC_TYPE_PER_TRAN
		| XDMAC_CC_DSYNC_PER2MEM
		| XDMAC_CC_MEMSET_NORMAL_MODE
		| XDMAC_CC_CSIZE_CHK_1
		| XDMAC_CC_DWIDTH_BYTE
		| XDMAC_CC_DIF_AHB_IF0
		| XDMAC_CC_SIF_AHB_IF1
		| XDMAC_CC_SAM_FIXED_AM;

	cfg->src_addr = (void*)&desc->addr->SPI_RDR;
}

static void _spid_dma_write(const struct _spi_desc* desc,
			   const struct _buffer* buffer)
{
	struct _xdmad_channel* w_channel = NULL;
	struct _xdmad_channel* r_channel = NULL;
	struct _xdmad_cfg w_cfg;
	struct _xdmad_cfg r_cfg;

	_spid_init_dma_write_channel(desc, &w_channel, &w_cfg);
	_spid_init_dma_read_channel(desc, &r_channel, &r_cfg);

	w_cfg.cfg.bitfield.sam = XDMAC_CC_SAM_INCREMENTED_AM
		>> XDMAC_CC_SAM_Pos;
	w_cfg.src_addr = buffer->data;
	w_cfg.ublock_size = buffer->size;
	xdmad_configure_transfer(w_channel, &w_cfg, 0, 0);
	xdmad_set_callback(w_channel, _spid_xdmad_cleanup_callback,
			   NULL);

	r_cfg.cfg.bitfield.dam = XDMAC_CC_DAM_FIXED_AM
		>> XDMAC_CC_DAM_Pos;
	r_cfg.dest_addr = &_garbage;
	r_cfg.ublock_size = buffer->size;
	xdmad_configure_transfer(r_channel, &r_cfg, 0, 0);
	xdmad_set_callback(r_channel, _spid_xdmad_callback_wrapper,
			   (void*)desc);

	l2cc_clean_region(desc->region_start, desc->region_end);

	xdmad_start_transfer(w_channel);
	xdmad_start_transfer(r_channel);
}

static void _spid_dma_read(const struct _spi_desc* desc,
			   struct _buffer* buffer)
{
	struct _xdmad_channel* w_channel = NULL;
	struct _xdmad_channel* r_channel = NULL;
	struct _xdmad_cfg w_cfg;
	struct _xdmad_cfg r_cfg;

	_spid_init_dma_write_channel(desc, &w_channel, &w_cfg);
	_spid_init_dma_read_channel(desc, &r_channel, &r_cfg);

	w_cfg.cfg.bitfield.sam = XDMAC_CC_SAM_FIXED_AM
		>> XDMAC_CC_SAM_Pos;
	w_cfg.src_addr = buffer->data;
	w_cfg.ublock_size = buffer->size;
	w_cfg.block_size = 0;
	xdmad_configure_transfer(w_channel, &w_cfg, 0, 0);
	xdmad_set_callback(w_channel, _spid_xdmad_cleanup_callback, NULL);

	r_cfg.cfg.bitfield.dam = XDMAC_CC_DAM_INCREMENTED_AM
		>> XDMAC_CC_DAM_Pos;
	r_cfg.dest_addr = buffer->data;
	r_cfg.ublock_size = buffer->size;
	xdmad_configure_transfer(r_channel, &r_cfg, 0, 0);
	xdmad_set_callback(r_channel, _spid_xdmad_callback_wrapper,
			   (void*)desc);

	l2cc_clean_region(desc->region_start, desc->region_end);

	xdmad_start_transfer(w_channel);
	xdmad_start_transfer(r_channel);
}

uint32_t spid_transfert(struct _spi_desc* desc, struct _buffer* rx,
			struct _buffer* tx, spid_callback_t cb,
			void* user_args)
{
	Spi* spi = desc->addr;
	uint32_t i = 0;

	desc->callback = cb;
	desc->cb_args = user_args;

	if (mutex_try_lock(&desc->mutex)) {
		return SPID_ERROR_LOCK;
	}

	switch (desc->transfert_mode) {
	case SPID_MODE_POLLING:
		if (tx) {
			for (i = 0; i < tx->size; ++i) {
				spi_write(spi, desc->chip_select, tx->data[i]);
			}
		}
		if (rx) {
			for (i = 0; i < rx->size; ++i) {
				rx->data[i] = spi_read(spi, desc->chip_select);
			}
		}
		mutex_free(&desc->mutex);
		if (cb)
			cb(desc, user_args);
		break;
	case SPID_MODE_DMA:
		if (tx) {
			if (tx->size < SPID_DMA_THRESHOLD) {
				for (i = 0; i < tx->size; ++i) {
					spi_write(spi, desc->chip_select, tx->data[i]);
				}
				if (!rx) {
					if (cb)
						cb(desc, user_args);
					mutex_free(&desc->mutex);
				}
			} else {
				desc->region_start = (uint32_t)tx->data;
				desc->region_end = desc->region_start
					+ tx->size;
				_spid_dma_write(desc, tx);
				if (rx) {
					spid_wait_transfert(desc);
					mutex_lock(&desc->mutex);
				}
			}
		}
		if (rx) {
			if (rx->size < SPID_DMA_THRESHOLD) {
				for (i = 0; i < rx->size; ++i) {
					rx->data[i] = spi_read(spi, desc->chip_select);
				}
				if (cb)
					cb(desc, user_args);
				mutex_free(&desc->mutex);
			} else {
				desc->region_start = (uint32_t)rx->data;
				desc->region_end = desc->region_start
					+ rx->size;
				_spid_dma_read(desc, rx);
			}
		}
		break;
#ifdef CONFIG_HAVE_SPI_FIFO
	case SPID_MODE_FIFO:
		if (tx) {
			spi_write_stream(spi, desc->chip_select,
					 tx->data, tx->size);
		}
		if (rx) {
			spi_read_stream(spi, desc->chip_select,
					rx->data, rx->size);
		}
		mutex_free(&desc->mutex);
		if (cb)
			cb(desc, user_args);
		break;
#endif
	default:
		trace_debug("Unkown mode");
	}

	return SPID_SUCCESS;
}

void spid_finish_transfert_callback(struct _spi_desc* desc, void* user_args)
{
	(void)user_args;
	spid_finish_transfert(desc);
}

void spid_finish_transfert(struct _spi_desc* desc)
{
	spi_release_cs(desc->addr);
	mutex_free(&desc->mutex);
}

void spid_close(const struct _spi_desc* desc)
{
	uint32_t id = get_spi_id_from_addr(desc->addr);
#ifdef CONFIG_HAVE_SPI_FIFO
	spi_fifo_disable(desc->addr);
	spi_disable_it(desc->addr, SPI_IER_TXFPTEF | SPI_IER_RXFPTEF);
	aic_disable(id);
#endif
	spi_disable(desc->addr);
	pmc_disable_peripheral(id);
}

uint32_t spid_is_busy(const struct _spi_desc* desc)
{
	return mutex_is_locked(&desc->mutex);
}

void spid_wait_transfert(const struct _spi_desc* desc)
{
	while (mutex_is_locked(&desc->mutex));
}