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

#include <linux/array_size.h>
#include <linux/bits.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/hex.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/types.h>

#include <linux/turris-omnia-mcu-interface.h>
#include "turris-omnia-mcu.h"

#define OMNIA_FW_VERSION_LEN		20
#define OMNIA_FW_VERSION_HEX_LEN	(2 * OMNIA_FW_VERSION_LEN + 1)
#define OMNIA_BOARD_INFO_LEN		16

int omnia_cmd_write_read(const struct i2c_client *client,
			 void *cmd, unsigned int cmd_len,
			 void *reply, unsigned int reply_len)
{
	struct i2c_msg msgs[2];
	int ret, num;

	msgs[0].addr = client->addr;
	msgs[0].flags = 0;
	msgs[0].len = cmd_len;
	msgs[0].buf = cmd;
	num = 1;

	if (reply_len) {
		msgs[1].addr = client->addr;
		msgs[1].flags = I2C_M_RD;
		msgs[1].len = reply_len;
		msgs[1].buf = reply;
		num++;
	}

	ret = i2c_transfer(client->adapter, msgs, num);
	if (ret < 0)
		return ret;
	if (ret != num)
		return -EIO;

	return 0;
}

static int omnia_get_version_hash(struct omnia_mcu *mcu, bool bootloader,
				  char version[static OMNIA_FW_VERSION_HEX_LEN])
{
	u8 reply[OMNIA_FW_VERSION_LEN];
	char *p;
	int err;

	err = omnia_cmd_read(mcu->client,
			     bootloader ? OMNIA_CMD_GET_FW_VERSION_BOOT
					: OMNIA_CMD_GET_FW_VERSION_APP,
			     reply, sizeof(reply));
	if (err)
		return err;

	p = bin2hex(version, reply, OMNIA_FW_VERSION_LEN);
	*p = '\0';

	return 0;
}

static ssize_t fw_version_hash_show(struct device *dev, char *buf,
				    bool bootloader)
{
	struct omnia_mcu *mcu = dev_get_drvdata(dev);
	char version[OMNIA_FW_VERSION_HEX_LEN];
	int err;

	err = omnia_get_version_hash(mcu, bootloader, version);
	if (err)
		return err;

	return sysfs_emit(buf, "%s\n", version);
}

static ssize_t fw_version_hash_application_show(struct device *dev,
						struct device_attribute *a,
						char *buf)
{
	return fw_version_hash_show(dev, buf, false);
}
static DEVICE_ATTR_RO(fw_version_hash_application);

static ssize_t fw_version_hash_bootloader_show(struct device *dev,
					       struct device_attribute *a,
					       char *buf)
{
	return fw_version_hash_show(dev, buf, true);
}
static DEVICE_ATTR_RO(fw_version_hash_bootloader);

static ssize_t fw_features_show(struct device *dev, struct device_attribute *a,
				char *buf)
{
	struct omnia_mcu *mcu = dev_get_drvdata(dev);

	return sysfs_emit(buf, "0x%x\n", mcu->features);
}
static DEVICE_ATTR_RO(fw_features);

static ssize_t mcu_type_show(struct device *dev, struct device_attribute *a,
			     char *buf)
{
	struct omnia_mcu *mcu = dev_get_drvdata(dev);

	return sysfs_emit(buf, "%s\n", mcu->type);
}
static DEVICE_ATTR_RO(mcu_type);

static ssize_t reset_selector_show(struct device *dev,
				   struct device_attribute *a, char *buf)
{
	u8 reply;
	int err;

	err = omnia_cmd_read_u8(to_i2c_client(dev), OMNIA_CMD_GET_RESET,
				&reply);
	if (err)
		return err;

	return sysfs_emit(buf, "%d\n", reply);
}
static DEVICE_ATTR_RO(reset_selector);

static ssize_t serial_number_show(struct device *dev,
				  struct device_attribute *a, char *buf)
{
	struct omnia_mcu *mcu = dev_get_drvdata(dev);

	return sysfs_emit(buf, "%016llX\n", mcu->board_serial_number);
}
static DEVICE_ATTR_RO(serial_number);

static ssize_t first_mac_address_show(struct device *dev,
				      struct device_attribute *a, char *buf)
{
	struct omnia_mcu *mcu = dev_get_drvdata(dev);

	return sysfs_emit(buf, "%pM\n", mcu->board_first_mac);
}
static DEVICE_ATTR_RO(first_mac_address);

static ssize_t board_revision_show(struct device *dev,
				   struct device_attribute *a, char *buf)
{
	struct omnia_mcu *mcu = dev_get_drvdata(dev);

	return sysfs_emit(buf, "%u\n", mcu->board_revision);
}
static DEVICE_ATTR_RO(board_revision);

static struct attribute *omnia_mcu_base_attrs[] = {
	&dev_attr_fw_version_hash_application.attr,
	&dev_attr_fw_version_hash_bootloader.attr,
	&dev_attr_fw_features.attr,
	&dev_attr_mcu_type.attr,
	&dev_attr_reset_selector.attr,
	&dev_attr_serial_number.attr,
	&dev_attr_first_mac_address.attr,
	&dev_attr_board_revision.attr,
	NULL
};

static umode_t omnia_mcu_base_attrs_visible(struct kobject *kobj,
					    struct attribute *a, int n)
{
	struct device *dev = kobj_to_dev(kobj);
	struct omnia_mcu *mcu = dev_get_drvdata(dev);

	if ((a == &dev_attr_serial_number.attr ||
	     a == &dev_attr_first_mac_address.attr ||
	     a == &dev_attr_board_revision.attr) &&
	    !(mcu->features & OMNIA_FEAT_BOARD_INFO))
		return 0;

	return a->mode;
}

static const struct attribute_group omnia_mcu_base_group = {
	.attrs = omnia_mcu_base_attrs,
	.is_visible = omnia_mcu_base_attrs_visible,
};

static const struct attribute_group *omnia_mcu_groups[] = {
	&omnia_mcu_base_group,
	&omnia_mcu_gpio_group,
	&omnia_mcu_poweroff_group,
	NULL
};

static void omnia_mcu_print_version_hash(struct omnia_mcu *mcu, bool bootloader)
{
	const char *type = bootloader ? "bootloader" : "application";
	struct device *dev = &mcu->client->dev;
	char version[OMNIA_FW_VERSION_HEX_LEN];
	int err;

	err = omnia_get_version_hash(mcu, bootloader, version);
	if (err) {
		dev_err(dev, "Cannot read MCU %s firmware version: %d\n",
			type, err);
		return;
	}

	dev_info(dev, "MCU %s firmware version hash: %s\n", type, version);
}

static const char *omnia_status_to_mcu_type(u16 status)
{
	switch (status & OMNIA_STS_MCU_TYPE_MASK) {
	case OMNIA_STS_MCU_TYPE_STM32:
		return "STM32";
	case OMNIA_STS_MCU_TYPE_GD32:
		return "GD32";
	case OMNIA_STS_MCU_TYPE_MKL:
		return "MKL";
	default:
		return "unknown";
	}
}

static void omnia_info_missing_feature(struct device *dev, const char *feature)
{
	dev_info(dev,
		 "Your board's MCU firmware does not support the %s feature.\n",
		 feature);
}

static int omnia_mcu_read_features(struct omnia_mcu *mcu)
{
	static const struct {
		u16 mask;
		const char *name;
	} features[] = {
#define _DEF_FEAT(_n, _m) { OMNIA_FEAT_ ## _n, _m }
		_DEF_FEAT(EXT_CMDS,		"extended control and status"),
		_DEF_FEAT(WDT_PING,		"watchdog pinging"),
		_DEF_FEAT(LED_STATE_EXT_MASK,	"peripheral LED pins reading"),
		_DEF_FEAT(NEW_INT_API,		"new interrupt API"),
		_DEF_FEAT(POWEROFF_WAKEUP,	"poweroff and wakeup"),
		_DEF_FEAT(TRNG,			"true random number generator"),
#undef _DEF_FEAT
	};
	struct i2c_client *client = mcu->client;
	struct device *dev = &client->dev;
	bool suggest_fw_upgrade = false;
	u16 status;
	int err;

	/* status word holds MCU type, which we need below */
	err = omnia_cmd_read_u16(client, OMNIA_CMD_GET_STATUS_WORD, &status);
	if (err)
		return err;

	/*
	 * Check whether MCU firmware supports the OMNIA_CMD_GET_FEATURES
	 * command.
	 */
	if (status & OMNIA_STS_FEATURES_SUPPORTED) {
		/* try read 32-bit features */
		err = omnia_cmd_read_u32(client, OMNIA_CMD_GET_FEATURES,
					 &mcu->features);
		if (err) {
			/* try read 16-bit features */
			u16 features16;

			err = omnia_cmd_read_u16(client, OMNIA_CMD_GET_FEATURES,
						 &features16);
			if (err)
				return err;

			mcu->features = features16;
		} else {
			if (mcu->features & OMNIA_FEAT_FROM_BIT_16_INVALID)
				mcu->features &= GENMASK(15, 0);
		}
	} else {
		dev_info(dev,
			 "Your board's MCU firmware does not support feature reading.\n");
		suggest_fw_upgrade = true;
	}

	mcu->type = omnia_status_to_mcu_type(status);
	dev_info(dev, "MCU type %s%s\n", mcu->type,
		 (mcu->features & OMNIA_FEAT_PERIPH_MCU) ?
			", with peripheral resets wired" : "");

	omnia_mcu_print_version_hash(mcu, true);

	if (mcu->features & OMNIA_FEAT_BOOTLOADER)
		dev_warn(dev,
			 "MCU is running bootloader firmware. Was firmware upgrade interrupted?\n");
	else
		omnia_mcu_print_version_hash(mcu, false);

	for (unsigned int i = 0; i < ARRAY_SIZE(features); i++) {
		if (mcu->features & features[i].mask)
			continue;

		omnia_info_missing_feature(dev, features[i].name);
		suggest_fw_upgrade = true;
	}

	if (suggest_fw_upgrade)
		dev_info(dev,
			 "Consider upgrading MCU firmware with the omnia-mcutool utility.\n");

	return 0;
}

static int omnia_mcu_read_board_info(struct omnia_mcu *mcu)
{
	u8 reply[1 + OMNIA_BOARD_INFO_LEN];
	int err;

	err = omnia_cmd_read(mcu->client, OMNIA_CMD_BOARD_INFO_GET, reply,
			     sizeof(reply));
	if (err)
		return err;

	if (reply[0] != OMNIA_BOARD_INFO_LEN)
		return -EIO;

	mcu->board_serial_number = get_unaligned_le64(&reply[1]);

	/* we can't use ether_addr_copy() because reply is not u16-aligned */
	memcpy(mcu->board_first_mac, &reply[9], sizeof(mcu->board_first_mac));

	mcu->board_revision = reply[15];

	return 0;
}

static int omnia_mcu_probe(struct i2c_client *client)
{
	struct device *dev = &client->dev;
	struct omnia_mcu *mcu;
	int err;

	if (!client->irq)
		return dev_err_probe(dev, -EINVAL, "IRQ resource not found\n");

	mcu = devm_kzalloc(dev, sizeof(*mcu), GFP_KERNEL);
	if (!mcu)
		return -ENOMEM;

	mcu->client = client;
	i2c_set_clientdata(client, mcu);

	err = omnia_mcu_read_features(mcu);
	if (err)
		return dev_err_probe(dev, err,
				     "Cannot determine MCU supported features\n");

	if (mcu->features & OMNIA_FEAT_BOARD_INFO) {
		err = omnia_mcu_read_board_info(mcu);
		if (err)
			return dev_err_probe(dev, err,
					     "Cannot read board info\n");
	}

	err = omnia_mcu_register_sys_off_and_wakeup(mcu);
	if (err)
		return err;

	err = omnia_mcu_register_watchdog(mcu);
	if (err)
		return err;

	err = omnia_mcu_register_gpiochip(mcu);
	if (err)
		return err;

	return omnia_mcu_register_trng(mcu);
}

static const struct of_device_id of_omnia_mcu_match[] = {
	{ .compatible = "cznic,turris-omnia-mcu" },
	{}
};

static struct i2c_driver omnia_mcu_driver = {
	.probe		= omnia_mcu_probe,
	.driver		= {
		.name	= "turris-omnia-mcu",
		.of_match_table = of_omnia_mcu_match,
		.dev_groups = omnia_mcu_groups,
	},
};
module_i2c_driver(omnia_mcu_driver);

MODULE_AUTHOR("Marek Behun <kabel@kernel.org>");
MODULE_DESCRIPTION("CZ.NIC's Turris Omnia MCU");
MODULE_LICENSE("GPL");