/* 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 */