/* SPDX-License-Identifier: GPL-2.0 */
/*
 * CZ.NIC's Turris Omnia MCU I2C interface commands definitions
 *
 * 2024 by Marek Behún <kabel@kernel.org>
 */

#ifndef __TURRIS_OMNIA_MCU_INTERFACE_H
#define __TURRIS_OMNIA_MCU_INTERFACE_H

#include <linux/bitfield.h>
#include <linux/bitops.h>
#include <linux/types.h>
#include <linux/unaligned.h>
#include <asm/byteorder.h>

enum omnia_commands_e {
	OMNIA_CMD_GET_STATUS_WORD		= 0x01, /* slave sends status word back */
	OMNIA_CMD_GENERAL_CONTROL		= 0x02,
	OMNIA_CMD_LED_MODE			= 0x03, /* default/user */
	OMNIA_CMD_LED_STATE			= 0x04, /* LED on/off */
	OMNIA_CMD_LED_COLOR			= 0x05, /* LED number + RED + GREEN + BLUE */
	OMNIA_CMD_USER_VOLTAGE			= 0x06,
	OMNIA_CMD_SET_BRIGHTNESS		= 0x07,
	OMNIA_CMD_GET_BRIGHTNESS		= 0x08,
	OMNIA_CMD_GET_RESET			= 0x09,
	OMNIA_CMD_GET_FW_VERSION_APP		= 0x0A, /* 20B git hash number */
	OMNIA_CMD_SET_WATCHDOG_STATE		= 0x0B, /* 0 - disable
							 * 1 - enable / ping
							 * after boot watchdog is started
							 * with 2 minutes timeout
							 */

	/* OMNIA_CMD_WATCHDOG_STATUS		= 0x0C, not implemented anymore */

	OMNIA_CMD_GET_WATCHDOG_STATE		= 0x0D,
	OMNIA_CMD_GET_FW_VERSION_BOOT		= 0x0E, /* 20B Git hash number */
	OMNIA_CMD_GET_FW_CHECKSUM		= 0x0F, /* 4B length, 4B checksum */

	/* available if FEATURES_SUPPORTED bit set in status word */
	OMNIA_CMD_GET_FEATURES			= 0x10,

	/* available if EXT_CMD bit set in features */
	OMNIA_CMD_GET_EXT_STATUS_DWORD		= 0x11,
	OMNIA_CMD_EXT_CONTROL			= 0x12,
	OMNIA_CMD_GET_EXT_CONTROL_STATUS	= 0x13,

	/* available if NEW_INT_API bit set in features */
	OMNIA_CMD_GET_INT_AND_CLEAR		= 0x14,
	OMNIA_CMD_GET_INT_MASK			= 0x15,
	OMNIA_CMD_SET_INT_MASK			= 0x16,

	/* available if FLASHING bit set in features */
	OMNIA_CMD_FLASH				= 0x19,

	/* available if WDT_PING bit set in features */
	OMNIA_CMD_SET_WDT_TIMEOUT		= 0x20,
	OMNIA_CMD_GET_WDT_TIMELEFT		= 0x21,

	/* available if POWEROFF_WAKEUP bit set in features */
	OMNIA_CMD_SET_WAKEUP			= 0x22,
	OMNIA_CMD_GET_UPTIME_AND_WAKEUP		= 0x23,
	OMNIA_CMD_POWER_OFF			= 0x24,

	/* available if USB_OVC_PROT_SETTING bit set in features */
	OMNIA_CMD_SET_USB_OVC_PROT		= 0x25,
	OMNIA_CMD_GET_USB_OVC_PROT		= 0x26,

	/* available if TRNG bit set in features */
	OMNIA_CMD_TRNG_COLLECT_ENTROPY		= 0x28,

	/* available if CRYPTO bit set in features */
	OMNIA_CMD_CRYPTO_GET_PUBLIC_KEY		= 0x29,
	OMNIA_CMD_CRYPTO_SIGN_MESSAGE		= 0x2A,
	OMNIA_CMD_CRYPTO_COLLECT_SIGNATURE	= 0x2B,

	/* available if BOARD_INFO it set in features */
	OMNIA_CMD_BOARD_INFO_GET		= 0x2C,
	OMNIA_CMD_BOARD_INFO_BURN		= 0x2D,

	/* available only at address 0x2b (LED-controller) */
	/* available only if LED_GAMMA_CORRECTION bit set in features */
	OMNIA_CMD_SET_GAMMA_CORRECTION		= 0x30,
	OMNIA_CMD_GET_GAMMA_CORRECTION		= 0x31,

	/* available only at address 0x2b (LED-controller) */
	/* available only if PER_LED_CORRECTION bit set in features */
	/* available only if FROM_BIT_16_INVALID bit NOT set in features */
	OMNIA_CMD_SET_LED_CORRECTIONS		= 0x32,
	OMNIA_CMD_GET_LED_CORRECTIONS		= 0x33,
};

enum omnia_flashing_commands_e {
	OMNIA_FLASH_CMD_UNLOCK		= 0x01,
	OMNIA_FLASH_CMD_SIZE_AND_CSUM	= 0x02,
	OMNIA_FLASH_CMD_PROGRAM		= 0x03,
	OMNIA_FLASH_CMD_RESET		= 0x04,
};

enum omnia_sts_word_e {
	OMNIA_STS_MCU_TYPE_MASK			= GENMASK(1, 0),
	OMNIA_STS_MCU_TYPE_STM32		= FIELD_PREP_CONST(OMNIA_STS_MCU_TYPE_MASK, 0),
	OMNIA_STS_MCU_TYPE_GD32			= FIELD_PREP_CONST(OMNIA_STS_MCU_TYPE_MASK, 1),
	OMNIA_STS_MCU_TYPE_MKL			= FIELD_PREP_CONST(OMNIA_STS_MCU_TYPE_MASK, 2),
	OMNIA_STS_FEATURES_SUPPORTED		= BIT(2),
	OMNIA_STS_USER_REGULATOR_NOT_SUPPORTED	= BIT(3),
	OMNIA_STS_CARD_DET			= BIT(4),
	OMNIA_STS_MSATA_IND			= BIT(5),
	OMNIA_STS_USB30_OVC			= BIT(6),
	OMNIA_STS_USB31_OVC			= BIT(7),
	OMNIA_STS_USB30_PWRON			= BIT(8),
	OMNIA_STS_USB31_PWRON			= BIT(9),
	OMNIA_STS_ENABLE_4V5			= BIT(10),
	OMNIA_STS_BUTTON_MODE			= BIT(11),
	OMNIA_STS_BUTTON_PRESSED		= BIT(12),
	OMNIA_STS_BUTTON_COUNTER_MASK		= GENMASK(15, 13),
};

enum omnia_ctl_byte_e {
	OMNIA_CTL_LIGHT_RST	= BIT(0),
	OMNIA_CTL_HARD_RST	= BIT(1),
	/* BIT(2) is currently reserved */
	OMNIA_CTL_USB30_PWRON	= BIT(3),
	OMNIA_CTL_USB31_PWRON	= BIT(4),
	OMNIA_CTL_ENABLE_4V5	= BIT(5),
	OMNIA_CTL_BUTTON_MODE	= BIT(6),
	OMNIA_CTL_BOOTLOADER	= BIT(7),
};

enum omnia_features_e {
	OMNIA_FEAT_PERIPH_MCU		= BIT(0),
	OMNIA_FEAT_EXT_CMDS		= BIT(1),
	OMNIA_FEAT_WDT_PING		= BIT(2),
	OMNIA_FEAT_LED_STATE_EXT_MASK	= GENMASK(4, 3),
	OMNIA_FEAT_LED_STATE_EXT	= FIELD_PREP_CONST(OMNIA_FEAT_LED_STATE_EXT_MASK, 1),
	OMNIA_FEAT_LED_STATE_EXT_V32	= FIELD_PREP_CONST(OMNIA_FEAT_LED_STATE_EXT_MASK, 2),
	OMNIA_FEAT_LED_GAMMA_CORRECTION	= BIT(5),
	OMNIA_FEAT_NEW_INT_API		= BIT(6),
	OMNIA_FEAT_BOOTLOADER		= BIT(7),
	OMNIA_FEAT_FLASHING		= BIT(8),
	OMNIA_FEAT_NEW_MESSAGE_API	= BIT(9),
	OMNIA_FEAT_BRIGHTNESS_INT	= BIT(10),
	OMNIA_FEAT_POWEROFF_WAKEUP	= BIT(11),
	OMNIA_FEAT_CAN_OLD_MESSAGE_API	= BIT(12),
	OMNIA_FEAT_TRNG			= BIT(13),
	OMNIA_FEAT_CRYPTO		= BIT(14),
	OMNIA_FEAT_BOARD_INFO		= BIT(15),

	/*
	 * Orginally the features command replied only 16 bits. If more were
	 * read, either the I2C transaction failed or 0xff bytes were sent.
	 * Therefore to consider bits 16 - 31 valid, one bit (20) was reserved
	 * to be zero.
	 */

	/* Bits 16 - 19 correspond to bits 0 - 3 of status word */
	OMNIA_FEAT_MCU_TYPE_MASK		= GENMASK(17, 16),
	OMNIA_FEAT_MCU_TYPE_STM32		= FIELD_PREP_CONST(OMNIA_FEAT_MCU_TYPE_MASK, 0),
	OMNIA_FEAT_MCU_TYPE_GD32		= FIELD_PREP_CONST(OMNIA_FEAT_MCU_TYPE_MASK, 1),
	OMNIA_FEAT_MCU_TYPE_MKL			= FIELD_PREP_CONST(OMNIA_FEAT_MCU_TYPE_MASK, 2),
	OMNIA_FEAT_FEATURES_SUPPORTED		= BIT(18),
	OMNIA_FEAT_USER_REGULATOR_NOT_SUPPORTED	= BIT(19),

	/* must not be set */
	OMNIA_FEAT_FROM_BIT_16_INVALID	= BIT(20),

	OMNIA_FEAT_PER_LED_CORRECTION	= BIT(21),
	OMNIA_FEAT_USB_OVC_PROT_SETTING	= BIT(22),
};

enum omnia_ext_sts_dword_e {
	OMNIA_EXT_STS_SFP_nDET		= BIT(0),
	OMNIA_EXT_STS_LED_STATES_MASK	= GENMASK(31, 12),
	OMNIA_EXT_STS_WLAN0_MSATA_LED	= BIT(12),
	OMNIA_EXT_STS_WLAN1_LED		= BIT(13),
	OMNIA_EXT_STS_WLAN2_LED		= BIT(14),
	OMNIA_EXT_STS_WPAN0_LED		= BIT(15),
	OMNIA_EXT_STS_WPAN1_LED		= BIT(16),
	OMNIA_EXT_STS_WPAN2_LED		= BIT(17),
	OMNIA_EXT_STS_WAN_LED0		= BIT(18),
	OMNIA_EXT_STS_WAN_LED1		= BIT(19),
	OMNIA_EXT_STS_LAN0_LED0		= BIT(20),
	OMNIA_EXT_STS_LAN0_LED1		= BIT(21),
	OMNIA_EXT_STS_LAN1_LED0		= BIT(22),
	OMNIA_EXT_STS_LAN1_LED1		= BIT(23),
	OMNIA_EXT_STS_LAN2_LED0		= BIT(24),
	OMNIA_EXT_STS_LAN2_LED1		= BIT(25),
	OMNIA_EXT_STS_LAN3_LED0		= BIT(26),
	OMNIA_EXT_STS_LAN3_LED1		= BIT(27),
	OMNIA_EXT_STS_LAN4_LED0		= BIT(28),
	OMNIA_EXT_STS_LAN4_LED1		= BIT(29),
	OMNIA_EXT_STS_LAN5_LED0		= BIT(30),
	OMNIA_EXT_STS_LAN5_LED1		= BIT(31),
};

enum omnia_ext_ctl_e {
	OMNIA_EXT_CTL_nRES_MMC		= BIT(0),
	OMNIA_EXT_CTL_nRES_LAN		= BIT(1),
	OMNIA_EXT_CTL_nRES_PHY		= BIT(2),
	OMNIA_EXT_CTL_nPERST0		= BIT(3),
	OMNIA_EXT_CTL_nPERST1		= BIT(4),
	OMNIA_EXT_CTL_nPERST2		= BIT(5),
	OMNIA_EXT_CTL_PHY_SFP		= BIT(6),
	OMNIA_EXT_CTL_PHY_SFP_AUTO	= BIT(7),
	OMNIA_EXT_CTL_nVHV_CTRL		= BIT(8),
};

enum omnia_int_e {
	OMNIA_INT_CARD_DET		= BIT(0),
	OMNIA_INT_MSATA_IND		= BIT(1),
	OMNIA_INT_USB30_OVC		= BIT(2),
	OMNIA_INT_USB31_OVC		= BIT(3),
	OMNIA_INT_BUTTON_PRESSED	= BIT(4),
	OMNIA_INT_SFP_nDET		= BIT(5),
	OMNIA_INT_BRIGHTNESS_CHANGED	= BIT(6),
	OMNIA_INT_TRNG			= BIT(7),
	OMNIA_INT_MESSAGE_SIGNED	= BIT(8),

	OMNIA_INT_LED_STATES_MASK	= GENMASK(31, 12),
	OMNIA_INT_WLAN0_MSATA_LED	= BIT(12),
	OMNIA_INT_WLAN1_LED		= BIT(13),
	OMNIA_INT_WLAN2_LED		= BIT(14),
	OMNIA_INT_WPAN0_LED		= BIT(15),
	OMNIA_INT_WPAN1_LED		= BIT(16),
	OMNIA_INT_WPAN2_LED		= BIT(17),
	OMNIA_INT_WAN_LED0		= BIT(18),
	OMNIA_INT_WAN_LED1		= BIT(19),
	OMNIA_INT_LAN0_LED0		= BIT(20),
	OMNIA_INT_LAN0_LED1		= BIT(21),
	OMNIA_INT_LAN1_LED0		= BIT(22),
	OMNIA_INT_LAN1_LED1		= BIT(23),
	OMNIA_INT_LAN2_LED0		= BIT(24),
	OMNIA_INT_LAN2_LED1		= BIT(25),
	OMNIA_INT_LAN3_LED0		= BIT(26),
	OMNIA_INT_LAN3_LED1		= BIT(27),
	OMNIA_INT_LAN4_LED0		= BIT(28),
	OMNIA_INT_LAN4_LED1		= BIT(29),
	OMNIA_INT_LAN5_LED0		= BIT(30),
	OMNIA_INT_LAN5_LED1		= BIT(31),
};

enum omnia_cmd_led_mode_e {
	OMNIA_CMD_LED_MODE_LED_MASK	= GENMASK(3, 0),
	OMNIA_CMD_LED_MODE_USER		= BIT(4),
};

#define OMNIA_CMD_LED_MODE_LED(_l)	FIELD_PREP(OMNIA_CMD_LED_MODE_LED_MASK, _l)

enum omnia_cmd_led_state_e {
	OMNIA_CMD_LED_STATE_LED_MASK	= GENMASK(3, 0),
	OMNIA_CMD_LED_STATE_ON		= BIT(4),
};

#define OMNIA_CMD_LED_STATE_LED(_l)	FIELD_PREP(OMNIA_CMD_LED_STATE_LED_MASK, _l)

enum omnia_cmd_poweroff_e {
	OMNIA_CMD_POWER_OFF_POWERON_BUTTON	= BIT(0),
	OMNIA_CMD_POWER_OFF_MAGIC		= 0xdead,
};

enum omnia_cmd_usb_ovc_prot_e {
	OMNIA_CMD_xET_USB_OVC_PROT_PORT_MASK	= GENMASK(3, 0),
	OMNIA_CMD_xET_USB_OVC_PROT_ENABLE	= BIT(4),
};

/* Command execution functions */

struct i2c_client;

int omnia_cmd_write_read(const struct i2c_client *client,
			 void *cmd, unsigned int cmd_len,
			 void *reply, unsigned int reply_len);

static inline int omnia_cmd_write(const struct i2c_client *client, void *cmd,
				  unsigned int len)
{
	return omnia_cmd_write_read(client, cmd, len, NULL, 0);
}

static inline int omnia_cmd_write_u8(const struct i2c_client *client, u8 cmd,
				     u8 val)
{
	u8 buf[2] = { cmd, val };

	return omnia_cmd_write(client, buf, sizeof(buf));
}

static inline int omnia_cmd_write_u16(const struct i2c_client *client, u8 cmd,
				      u16 val)
{
	u8 buf[3];

	buf[0] = cmd;
	put_unaligned_le16(val, &buf[1]);

	return omnia_cmd_write(client, buf, sizeof(buf));
}

static inline int omnia_cmd_write_u32(const struct i2c_client *client, u8 cmd,
				      u32 val)
{
	u8 buf[5];

	buf[0] = cmd;
	put_unaligned_le32(val, &buf[1]);

	return omnia_cmd_write(client, buf, sizeof(buf));
}

static inline int omnia_cmd_read(const struct i2c_client *client, u8 cmd,
				 void *reply, unsigned int len)
{
	return omnia_cmd_write_read(client, &cmd, 1, reply, len);
}

static inline unsigned int
omnia_compute_reply_length(unsigned long mask, bool interleaved,
			   unsigned int offset)
{
	if (!mask)
		return 0;

	return ((__fls(mask) >> 3) << interleaved) + 1 + offset;
}

/* Returns 0 on success */
static inline int omnia_cmd_read_bits(const struct i2c_client *client, u8 cmd,
				      unsigned long bits, unsigned long *dst)
{
	__le32 reply;
	int err;

	if (!bits) {
		*dst = 0;
		return 0;
	}

	err = omnia_cmd_read(client, cmd, &reply,
			     omnia_compute_reply_length(bits, false, 0));
	if (err)
		return err;

	*dst = le32_to_cpu(reply) & bits;

	return 0;
}

static inline int omnia_cmd_read_bit(const struct i2c_client *client, u8 cmd,
				     unsigned long bit)
{
	unsigned long reply;
	int err;

	err = omnia_cmd_read_bits(client, cmd, bit, &reply);
	if (err)
		return err;

	return !!reply;
}

static inline int omnia_cmd_read_u32(const struct i2c_client *client, u8 cmd,
				     u32 *dst)
{
	__le32 reply;
	int err;

	err = omnia_cmd_read(client, cmd, &reply, sizeof(reply));
	if (err)
		return err;

	*dst = le32_to_cpu(reply);

	return 0;
}

static inline int omnia_cmd_read_u16(const struct i2c_client *client, u8 cmd,
				     u16 *dst)
{
	__le16 reply;
	int err;

	err = omnia_cmd_read(client, cmd, &reply, sizeof(reply));
	if (err)
		return err;

	*dst = le16_to_cpu(reply);

	return 0;
}

static inline int omnia_cmd_read_u8(const struct i2c_client *client, u8 cmd,
				    u8 *reply)
{
	return omnia_cmd_read(client, cmd, reply, sizeof(*reply));
}

#endif /* __TURRIS_OMNIA_MCU_INTERFACE_H */