// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2017-2019 NXP
 *
 * Copyright 2019 Siemens AG
 *
 */
#include <common.h>
#include <command.h>
#include <dm.h>
#include <env.h>
#include <errno.h>
#include <init.h>
#include <log.h>
#include <netdev.h>
#include <env_internal.h>
#include <fsl_esdhc_imx.h>
#include <i2c.h>
#include <led.h>
#include <pca953x.h>
#include <power-domain.h>
#include <asm/gpio.h>
#include <asm/arch/imx8-pins.h>
#include <asm/arch/iomux.h>
#include <asm/arch/sci/sci.h>
#include <asm/arch/sys_proto.h>
#ifndef CONFIG_SPL
#include <asm/arch-imx8/clock.h>
#endif
#include <linux/delay.h>
#include "../common/factoryset.h"

#define GPIO_PAD_CTRL \
		((SC_PAD_CONFIG_NORMAL << PADRING_CONFIG_SHIFT) | \
		 (SC_PAD_ISO_OFF << PADRING_LPCONFIG_SHIFT) | \
		 (SC_PAD_28FDSOI_DSE_DV_HIGH << PADRING_DSE_SHIFT) | \
		 (SC_PAD_28FDSOI_PS_PU << PADRING_PULL_SHIFT))

#define ENET_NORMAL_PAD_CTRL \
		((SC_PAD_CONFIG_NORMAL << PADRING_CONFIG_SHIFT) | \
		 (SC_PAD_ISO_OFF << PADRING_LPCONFIG_SHIFT) | \
		 (SC_PAD_28FDSOI_DSE_18V_10MA << PADRING_DSE_SHIFT) | \
		 (SC_PAD_28FDSOI_PS_PU << PADRING_PULL_SHIFT))

#define UART_PAD_CTRL \
		((SC_PAD_CONFIG_OUT_IN << PADRING_CONFIG_SHIFT) | \
		 (SC_PAD_ISO_OFF << PADRING_LPCONFIG_SHIFT) | \
		 (SC_PAD_28FDSOI_DSE_DV_HIGH << PADRING_DSE_SHIFT) | \
		 (SC_PAD_28FDSOI_PS_PU << PADRING_PULL_SHIFT))

static iomux_cfg_t uart2_pads[] = {
	SC_P_UART2_RX | MUX_PAD_CTRL(UART_PAD_CTRL),
	SC_P_UART2_TX | MUX_PAD_CTRL(UART_PAD_CTRL),
};

static void setup_iomux_uart(void)
{
	imx8_iomux_setup_multiple_pads(uart2_pads, ARRAY_SIZE(uart2_pads));
}

int board_early_init_f(void)
{
	/* Set UART clock root to 80 MHz */
	sc_pm_clock_rate_t rate = SC_80MHZ;
	int ret;

	ret = sc_pm_setup_uart(SC_R_UART_0, rate);
	ret |= sc_pm_setup_uart(SC_R_UART_2, rate);
	if (ret)
		return ret;

	setup_iomux_uart();

	return 0;
}

#define ENET_PHY_RESET	IMX_GPIO_NR(0, 3)
#define ENET_TEST_1	IMX_GPIO_NR(0, 8)
#define ENET_TEST_2	IMX_GPIO_NR(0, 9)

/*#define ETH_IO_TEST*/
static iomux_cfg_t enet_reset[] = {
	SC_P_ESAI0_SCKT | MUX_MODE_ALT(4) | MUX_PAD_CTRL(GPIO_PAD_CTRL),
#ifdef ETH_IO_TEST
	/* GPIO0.IO08 MODE3: TXD0 */
	SC_P_ESAI0_TX4_RX1 | MUX_MODE_ALT(4) |
	MUX_PAD_CTRL(ENET_NORMAL_PAD_CTRL),
	/* GPIO0.IO09 MODE3: TXD1 */
	SC_P_ESAI0_TX5_RX0 | MUX_MODE_ALT(4) |
	MUX_PAD_CTRL(ENET_NORMAL_PAD_CTRL),
#endif
};

static void enet_device_phy_reset(void)
{
	int ret = 0;

	imx8_iomux_setup_multiple_pads(enet_reset, ARRAY_SIZE(enet_reset));

	ret = gpio_request(ENET_PHY_RESET, "enet_phy_reset");
	if (!ret) {
		gpio_direction_output(ENET_PHY_RESET, 1);
		gpio_set_value(ENET_PHY_RESET, 0);
		/* SMSC9303 TRM chapter 14.5.2 */
		udelay(200);
		gpio_set_value(ENET_PHY_RESET, 1);
	} else {
		printf("ENET RESET failed!\n");
	}

#ifdef ETH_IO_TEST
	ret =  gpio_request(ENET_TEST_1, "enet_test1");
	if (!ret) {
		int i;

		printf("ENET TEST 1!\n");
		for (i = 0; i < 20; i++) {
			gpio_direction_output(ENET_TEST_1, 1);
			gpio_set_value(ENET_TEST_1, 0);
			udelay(50);
			gpio_set_value(ENET_TEST_1, 1);
			udelay(50);
		}
		gpio_free(ENET_TEST_1);
	} else {
		printf("GPIO for ENET TEST 1 failed!\n");
	}
	ret =  gpio_request(ENET_TEST_2, "enet_test2");
	if (!ret) {
		int i;

		printf("ENET TEST 2!\n");
		for (i = 0; i < 20; i++) {
			gpio_direction_output(ENET_TEST_2, 1);
			gpio_set_value(ENET_TEST_2, 0);
			udelay(50);
			gpio_set_value(ENET_TEST_2, 1);
			udelay(50);
		}
		gpio_free(ENET_TEST_2);
	} else {
		printf("GPIO for ENET TEST 2 failed!\n");
	}
#endif
}

int setup_gpr_fec(void)
{
	sc_ipc_t ipc_handle = -1;
	sc_err_t err = 0;
	unsigned int test;

	/*
	 * TX_CLK_SEL: it controls a mux between clock coming from the pad 50M
	 * input pin and clock generated internally to connectivity subsystem
	 *	0: internal clock
	 *	1: external clock --->  your choice for RMII
	 *
	 * CLKDIV_SEL: it controls a div by 2 on the internal clock path à
	 *	it should be don’t care when using external clock
	 *	0: non-divided clock
	 *	1: clock divided by 2
	 * 50_DISABLE or 125_DISABLE:
	 *	it’s used to disable the clock tree going outside the chip
	 *	when reference clock is generated internally.
	 *	It should be don’t care when reference clock is provided
	 *	externally.
	 *	0: clock is enabled
	 *	1: clock is disabled
	 *
	 * SC_C_TXCLK		= 24,
	 * SC_C_CLKDIV		= 25,
	 * SC_C_DISABLE_50	= 26,
	 * SC_C_DISABLE_125	= 27,
	 */

	err = sc_misc_set_control(ipc_handle, SC_R_ENET_1, SC_C_TXCLK, 1);
	if (err != SC_ERR_NONE)
		printf("Error in setting up SC_C %d\n\r", SC_C_TXCLK);

	sc_misc_get_control(ipc_handle, SC_R_ENET_1, SC_C_TXCLK, &test);
	debug("TEST SC_C %d-->%d\n\r", SC_C_TXCLK, test);

	err = sc_misc_set_control(ipc_handle, SC_R_ENET_1, SC_C_CLKDIV, 0);
	if (err != SC_ERR_NONE)
		printf("Error in setting up SC_C %d\n\r", SC_C_CLKDIV);

	sc_misc_get_control(ipc_handle, SC_R_ENET_1, SC_C_CLKDIV, &test);
	debug("TEST SC_C %d-->%d\n\r", SC_C_CLKDIV, test);

	err = sc_misc_set_control(ipc_handle, SC_R_ENET_1, SC_C_DISABLE_50, 0);
	if (err != SC_ERR_NONE)
		printf("Error in setting up SC_C %d\n\r", SC_C_DISABLE_50);

	sc_misc_get_control(ipc_handle, SC_R_ENET_1, SC_C_TXCLK, &test);
	debug("TEST SC_C %d-->%d\n\r", SC_C_DISABLE_50, test);

	err = sc_misc_set_control(ipc_handle, SC_R_ENET_1, SC_C_DISABLE_125, 1);
	if (err != SC_ERR_NONE)
		printf("Error in setting up SC_C %d\n\r", SC_C_DISABLE_125);

	sc_misc_get_control(ipc_handle, SC_R_ENET_1, SC_C_TXCLK, &test);
	debug("TEST SC_C %d-->%d\n\r", SC_C_DISABLE_125, test);

	err = sc_misc_set_control(ipc_handle, SC_R_ENET_1, SC_C_SEL_125, 1);
	if (err != SC_ERR_NONE)
		printf("Error in setting up SC_C %d\n\r", SC_C_SEL_125);

	sc_misc_get_control(ipc_handle, SC_R_ENET_1, SC_C_SEL_125, &test);
	debug("TEST SC_C %d-->%d\n\r", SC_C_SEL_125, test);

	return 0;
}

#if IS_ENABLED(CONFIG_FEC_MXC)
#include <miiphy.h>
int board_phy_config(struct phy_device *phydev)
{
	if (phydev->drv->config)
		phydev->drv->config(phydev);

	return 0;
}

#endif

static int setup_fec(void)
{
	setup_gpr_fec();
	/* Reset ENET PHY */
	enet_device_phy_reset();
	return 0;
}

void reset_cpu(void)
{
}

#ifndef CONFIG_SPL_BUILD
/* LED's */
static int board_led_init(void)
{
	struct udevice *bus, *dev;
	u8 pca_led[2] = { 0x00, 0x00 };
	int ret;

	/* init all GPIO LED's */
	if (IS_ENABLED(CONFIG_LED))
		led_default_state();

	/* enable all leds on PCA9552 */
	ret = uclass_get_device_by_seq(UCLASS_I2C, PCA9552_1_I2C_BUS, &bus);
	if (ret) {
		printf("ERROR: I2C get %d\n", ret);
		return ret;
	}

	ret = dm_i2c_probe(bus, PCA9552_1_I2C_ADDR, 0, &dev);
	if (ret) {
		printf("ERROR: PCA9552 probe failed\n");
		return ret;
	}

	ret = dm_i2c_write(dev, 0x16, pca_led, sizeof(pca_led));
	if (ret) {
		printf("ERROR: PCA9552 write failed\n");
		return ret;
	}

	mdelay(1);
	return ret;
}
#endif /* !CONFIG_SPL_BUILD */

int checkboard(void)
{
	puts("Board: Capricorn\n");

	/*
	 * Running build_info() doesn't work with current SCFW blob.
	 * Uncomment below call when new blob is available.
	 */
	/*build_info();*/

	print_bootinfo();
	return 0;
}

int board_init(void)
{
	setup_fec();
	return 0;
}

#ifdef CONFIG_OF_BOARD_SETUP
int ft_board_setup(void *blob, struct bd_info *bd)
{
	return 0;
}
#endif

int board_mmc_get_env_dev(int devno)
{
	return devno;
}

static int check_mmc_autodetect(void)
{
	char *autodetect_str = env_get("mmcautodetect");

	if (autodetect_str && (strcmp(autodetect_str, "yes") == 0))
		return 1;

	return 0;
}

/* This should be defined for each board */
__weak int mmc_map_to_kernel_blk(int dev_no)
{
	return dev_no;
}

void board_late_mmc_env_init(void)
{
	char cmd[32];
	char mmcblk[32];
	u32 dev_no = mmc_get_env_dev();

	if (!check_mmc_autodetect())
		return;

	env_set_ulong("mmcdev", dev_no);

	/* Set mmcblk env */
	sprintf(mmcblk, "/dev/mmcblk%dp2 rootwait rw",
		mmc_map_to_kernel_blk(dev_no));
	env_set("mmcroot", mmcblk);

	sprintf(cmd, "mmc dev %d", dev_no);
	run_command(cmd, 0);
}

#ifndef CONFIG_SPL_BUILD
int factoryset_read_eeprom(int i2c_addr);

static int load_parameters_from_factoryset(void)
{
	int ret;

	ret = factoryset_read_eeprom(EEPROM_I2C_ADDR);
	if (ret)
		return ret;

	return factoryset_env_set();
}

int board_late_init(void)
{
	env_set("sec_boot", "no");
#ifdef CONFIG_AHAB_BOOT
	env_set("sec_boot", "yes");
#endif

#ifdef CONFIG_ENV_IS_IN_MMC
	board_late_mmc_env_init();
#endif
	/* Init LEDs */
	if (board_led_init())
		printf("I2C LED init failed\n");

	/* Set environment from factoryset */
	if (load_parameters_from_factoryset())
		printf("Loading factoryset parameters failed!\n");

	return 0;
}

/* Service button */
#define MAX_PIN_NUMBER			128
#define BOARD_DEFAULT_BUTTON_GPIO	IMX_GPIO_NR(1, 31)

unsigned char get_button_state(char * const envname, unsigned char def)
{
	int button = 0;
	int gpio;
	char *ptr_env;

	/* If button is not found we take default */
	ptr_env = env_get(envname);
	if (!ptr_env) {
		printf("Using default: %u\n", def);
		gpio = def;
	} else {
		gpio = (unsigned char)simple_strtoul(ptr_env, NULL, 0);
		if (gpio > MAX_PIN_NUMBER)
			gpio = def;
	}

	gpio_request(gpio, "");
	gpio_direction_input(gpio);
	if (gpio_get_value(gpio))
		button = 1;
	else
		button = 0;

	gpio_free(gpio);

	return button;
}

/*
 * This command returns the status of the user button on
 * Input - none
 * Returns -	1 if button is held down
 *		0 if button is not held down
 */
static int
do_userbutton(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	int button = 0;

	button = get_button_state("button_usr1", BOARD_DEFAULT_BUTTON_GPIO);

	if (argc > 1)
		printf("Button state: %u\n", button);

	return button;
}

U_BOOT_CMD(
	usrbutton, CONFIG_SYS_MAXARGS, 2, do_userbutton,
	"Return the status of user button",
	"[print]"
);

#define ERST	IMX_GPIO_NR(0, 3)

static int
do_eth_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	gpio_request(ERST, "ERST");
	gpio_direction_output(ERST, 0);
	udelay(200);
	gpio_set_value(ERST, 1);
	return 0;
}

U_BOOT_CMD(
	switch_rst, CONFIG_SYS_MAXARGS, 2, do_eth_reset,
	"Reset eth phy",
	"[print]"
);
#endif /* ! CONFIG_SPL_BUILD */
