---

// SPDX-License-Identifier: GPL-2.0
/*
 * Lattice FPGA sysCONFIG interface functions independent of port type.
 */

#include <linux/delay.h>
#include <linux/fpga/fpga-mgr.h>
#include <linux/gpio/consumer.h>
#include <linux/iopoll.h>

#include "lattice-sysconfig.h"

static int sysconfig_cmd_write(struct sysconfig_priv *priv, const void *buf,
			       size_t buf_len)
{
	return priv->command_transfer(priv, buf, buf_len, NULL, 0);
}

static int sysconfig_cmd_read(struct sysconfig_priv *priv, const void *tx_buf,
			      size_t tx_len, void *rx_buf, size_t rx_len)
{
	return priv->command_transfer(priv, tx_buf, tx_len, rx_buf, rx_len);
}

static int sysconfig_read_busy(struct sysconfig_priv *priv)
{
	const u8 lsc_check_busy[] = SYSCONFIG_LSC_CHECK_BUSY;
	u8 busy;
	int ret;

	ret = sysconfig_cmd_read(priv, lsc_check_busy, sizeof(lsc_check_busy),
				 &busy, sizeof(busy));

	return ret ? : busy;
}

static int sysconfig_poll_busy(struct sysconfig_priv *priv)
{
	int ret, busy;

	ret = read_poll_timeout(sysconfig_read_busy, busy, busy <= 0,
				SYSCONFIG_POLL_INTERVAL_US,
				SYSCONFIG_POLL_BUSY_TIMEOUT_US, false, priv);

	return ret ? : busy;
}

static int sysconfig_read_status(struct sysconfig_priv *priv, u64 *status)
{
	const u8 lsc_read_status[] = SYSCONFIG_LSC_READ_STATUS;
	u8 buf[8] = {0};
	int ret;

	ret = sysconfig_cmd_read(priv, lsc_read_status, sizeof(lsc_read_status),
				 buf, sizeof(buf));
	if (ret)
		return ret;

	*status = ((u64)buf[0] << 56 |(u64)buf[1] << 48 | (u64)buf[2] << 40 | (u64)buf[3] << 32 | (u64)buf[4] << 24 |(u64)buf[5] << 16 | (u64)buf[6] << 8 | buf[7]);

	return 0;
}

static int sysconfig_read_idcode(struct sysconfig_priv *priv)
{
	const u8 lsc_idcode[] = SYSCONFIG_LSC_IDCODE;
	u8 buf[4] = {0};
	int ret;

        printk("%s(%d)\n",__FUNCTION__,__LINE__);
	ret = sysconfig_cmd_read(priv, lsc_idcode, sizeof(lsc_idcode),buf, sizeof(buf));
	if (ret)
		return ret;
        printk("%s(%d) 0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,buf[0],buf[1],buf[2],buf[3],ret);
        return 0;
}

static int sysconfig_poll_status(struct sysconfig_priv *priv, u64 *status)
{
	int ret = sysconfig_poll_busy(priv);

	if (ret)
		return ret;

	return sysconfig_read_status(priv, status);
}

static int sysconfig_poll_gpio(struct gpio_desc *gpio, bool is_active)
{
	int ret, val;

	ret = read_poll_timeout(gpiod_get_value, val,
				val < 0 || !!val == is_active,
				SYSCONFIG_POLL_INTERVAL_US,
				SYSCONFIG_POLL_GPIO_TIMEOUT_US, false, gpio);

	if (val < 0)
		return val;

	return ret;
}

static int sysconfig_gpio_refresh(struct sysconfig_priv *priv)
{
	struct gpio_desc *program = priv->program;
	struct gpio_desc *init = priv->init;
	struct gpio_desc *done = priv->done;
	int ret;

	/* Enter init mode */
	gpiod_set_value(program, 1);

	ret = sysconfig_poll_gpio(init, true);
	if (!ret)
		ret = sysconfig_poll_gpio(done, false);

	if (ret)
		return ret;

	/* Enter program mode */
	gpiod_set_value(program, 0);

	return sysconfig_poll_gpio(init, false);
}

static int sysconfig_lsc_refresh(struct sysconfig_priv *priv)
{
	static const u8 lsc_refresh[] = SYSCONFIG_LSC_REFRESH;
	int ret;

	ret = sysconfig_cmd_write(priv, lsc_refresh, sizeof(lsc_refresh));
    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,lsc_refresh[0],lsc_refresh[1],lsc_refresh[2],lsc_refresh[3],ret);
	if (ret)
		return ret;

	usleep_range(4000, 8000);

	return 0;
}

static int sysconfig_activation_key(struct sysconfig_priv *priv)
{
	u8 activation_key[] = SYSCONFIG_I2C_ACTIVATION_KEY;
	int ret;

	ret = sysconfig_cmd_write(priv, activation_key, sizeof(activation_key));
    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,activation_key[0],activation_key[1],activation_key[2],activation_key[3],ret);
	if (ret)
		return ret;
	return 0;
}

static int sysconfig_lsc_device_control(struct sysconfig_priv *priv)
{
	u8 lsc_device_control_reset[] = SYSCONFIG_LSC_DEVICE_CONTROL_RESET;
	u8 lsc_device_control[] = SYSCONFIG_LSC_DEVICE_CONTROL;
	int ret;

	ret = sysconfig_cmd_write(priv, lsc_device_control_reset, sizeof(lsc_device_control_reset));
    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,lsc_device_control_reset[0],lsc_device_control_reset[1],lsc_device_control_reset[2],lsc_device_control_reset[3],ret);
	if (ret)
		return ret;
	ret = sysconfig_cmd_write(priv, lsc_device_control, sizeof(lsc_device_control));
    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,lsc_device_control[0],lsc_device_control[1],lsc_device_control[2],lsc_device_control[3],ret);
	if (ret)
		return ret;
	return 0;
}

static int sysconfig_refresh(struct sysconfig_priv *priv)
{
	struct gpio_desc *program = priv->program;
	struct gpio_desc *init = priv->init;
	struct gpio_desc *done = priv->done;

	if (program && init && done)
		return sysconfig_gpio_refresh(priv);

	return sysconfig_lsc_refresh(priv);
}

static int sysconfig_isc_enable(struct sysconfig_priv *priv)
{
	u8 isc_enable[] = SYSCONFIG_ISC_ENABLE;
	u64 status;
	int ret;

	ret = sysconfig_cmd_write(priv, isc_enable, sizeof(isc_enable));
    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,isc_enable[0],isc_enable[1],isc_enable[2],isc_enable[3],ret);
	if (ret)
		return ret;
#ifdef MY_CODE
	ret = sysconfig_poll_status(priv, &status);
    printk("%s(%d) ret=%d status=0x%llX\n",__FUNCTION__,__LINE__,ret,status);
	if (ret)
		return ret;

	if (status & SYSCONFIG_STATUS_FAIL)
		return -EFAULT;
#endif
	return 0;
}

static int sysconfig_isc_erase(struct sysconfig_priv *priv)
{
	u8 isc_erase[] = SYSCONFIG_ISC_ERASE;
	u64 status;
	int ret;

	ret = sysconfig_cmd_write(priv, isc_erase, sizeof(isc_erase));
    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X ret=%d\n",__FUNCTION__,__LINE__,isc_erase[0],isc_erase[1],isc_erase[2],isc_erase[3],ret);
	if (ret)
		return ret;

	ret = sysconfig_poll_status(priv, &status);
printk("%s(%d) ret=%d status=0x%llX\n",__FUNCTION__,__LINE__,ret,status);
	if (ret)
		return ret;

	if (status & SYSCONFIG_STATUS_FAIL)
		return -EFAULT;

	return 0;
}

static int sysconfig_isc_init(struct sysconfig_priv *priv)
{
	int ret = sysconfig_isc_enable(priv);

printk("%s(%d) ret=%d\n",__FUNCTION__,__LINE__,ret);
	if (ret)
		return ret;

	return sysconfig_isc_erase(priv);
}

static int sysconfig_lsc_init_addr(struct sysconfig_priv *priv)
{
	const u8 lsc_init_addr[] = SYSCONFIG_LSC_INIT_ADDR;

    printk("%s(%d) cmd=0x%X 0x%X 0x%X 0x%X \n",__FUNCTION__,__LINE__,lsc_init_addr[0],lsc_init_addr[1],lsc_init_addr[2],lsc_init_addr[3]);
	return sysconfig_cmd_write(priv, lsc_init_addr, sizeof(lsc_init_addr));
}

static int sysconfig_burst_write_init(struct sysconfig_priv *priv)
{
	return priv->bitstream_burst_write_init(priv);
}

static int sysconfig_burst_write_complete(struct sysconfig_priv *priv)
{
	return priv->bitstream_burst_write_complete(priv);
}