u-boot-megous/drivers/misc/turris_omnia_mcu.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2022 Pali Rohár <pali@kernel.org>
 * Copyright (C) 2024 Marek Behún <kabel@kernel.org>
 */

#include <console.h>
#include <dm.h>
#include <dm/lists.h>
#include <i2c.h>
#include <rng.h>
#include <sysreset.h>
#include <turris-omnia-mcu-interface.h>
#include <asm/byteorder.h>
#include <asm/gpio.h>
#include <linux/delay.h>
#include <linux/log2.h>

#define CMD_TRNG_MAX_ENTROPY_LEN	64

struct turris_omnia_mcu_info {
	u32 features;
};

static int omnia_gpio_get_function(struct udevice *dev, uint offset)
{
	struct turris_omnia_mcu_info *info = dev_get_priv(dev->parent);

	switch (offset) {
	/* bank 0 */
	case 0 ... 15:
		switch (offset) {
		case ilog2(STS_USB30_PWRON):
		case ilog2(STS_USB31_PWRON):
		case ilog2(STS_ENABLE_4V5):
		case ilog2(STS_BUTTON_MODE):
			return GPIOF_OUTPUT;
		default:
			return GPIOF_INPUT;
		}

	/* bank 1 - supported only when FEAT_EXT_CMDS is set */
	case (16 + 0) ... (16 + 31):
		if (!(info->features & FEAT_EXT_CMDS))
			return -EINVAL;
		return GPIOF_INPUT;

	/* bank 2 - supported only when FEAT_EXT_CMDS and FEAT_PERIPH_MCU is set */
	case (16 + 32 + 0) ... (16 + 32 + 15):
		if (!(info->features & FEAT_EXT_CMDS))
			return -EINVAL;
		if (!(info->features & FEAT_PERIPH_MCU))
			return -EINVAL;
		return GPIOF_OUTPUT;

	default:
		return -EINVAL;
	}
}

static int omnia_gpio_get_value(struct udevice *dev, uint offset)
{
	struct turris_omnia_mcu_info *info = dev_get_priv(dev->parent);
	u32 val32;
	u16 val16;
	int ret;

	switch (offset) {
	/* bank 0 */
	case 0 ... 15:
		ret = dm_i2c_read(dev->parent, CMD_GET_STATUS_WORD,
				  (void *)&val16, sizeof(val16));
		if (ret)
			return ret;

		return !!(le16_to_cpu(val16) & BIT(offset));

	/* bank 1 - supported only when FEAT_EXT_CMDS is set */
	case (16 + 0) ... (16 + 31):
		if (!(info->features & FEAT_EXT_CMDS))
			return -EINVAL;

		ret = dm_i2c_read(dev->parent, CMD_GET_EXT_STATUS_DWORD,
				  (void *)&val32, sizeof(val32));
		if (ret)
			return ret;

		return !!(le32_to_cpu(val32) & BIT(offset - 16));

	/* bank 2 - supported only when FEAT_EXT_CMDS and FEAT_PERIPH_MCU is set */
	case (16 + 32 + 0) ... (16 + 32 + 15):
		if (!(info->features & FEAT_EXT_CMDS))
			return -EINVAL;
		if (!(info->features & FEAT_PERIPH_MCU))
			return -EINVAL;

		ret = dm_i2c_read(dev->parent, CMD_GET_EXT_CONTROL_STATUS,
				  (void *)&val16, sizeof(val16));
		if (ret)
			return ret;

		return !!(le16_to_cpu(val16) & BIT(offset - 16 - 32));

	default:
		return -EINVAL;
	}
}

static int omnia_gpio_set_value(struct udevice *dev, uint offset, int value)
{
	struct turris_omnia_mcu_info *info = dev_get_priv(dev->parent);
	u16 valmask16[2];
	u8 valmask8[2];

	switch (offset) {
	/* bank 0 */
	case 0 ... 15:
		switch (offset) {
		case ilog2(STS_USB30_PWRON):
			valmask8[1] = CTL_USB30_PWRON;
			break;
		case ilog2(STS_USB31_PWRON):
			valmask8[1] = CTL_USB31_PWRON;
			break;
		case ilog2(STS_ENABLE_4V5):
			valmask8[1] = CTL_ENABLE_4V5;
			break;
		case ilog2(STS_BUTTON_MODE):
			valmask8[1] = CTL_BUTTON_MODE;
			break;
		default:
			return -EINVAL;
		}

		valmask8[0] = value ? valmask8[1] : 0;

		return dm_i2c_write(dev->parent, CMD_GENERAL_CONTROL, valmask8,
				    sizeof(valmask8));

	/* bank 2 - supported only when FEAT_EXT_CMDS and FEAT_PERIPH_MCU is set */
	case (16 + 32 + 0) ... (16 + 32 + 15):
		if (!(info->features & FEAT_EXT_CMDS))
			return -EINVAL;
		if (!(info->features & FEAT_PERIPH_MCU))
			return -EINVAL;

		valmask16[1] = cpu_to_le16(BIT(offset - 16 - 32));
		valmask16[0] = value ? valmask16[1] : 0;

		return dm_i2c_write(dev->parent, CMD_EXT_CONTROL,
				    (void *)valmask16, sizeof(valmask16));

	default:
		return -EINVAL;
	}
}

static int omnia_gpio_direction_input(struct udevice *dev, uint offset)
{
	int ret;

	ret = omnia_gpio_get_function(dev, offset);
	if (ret < 0)
		return ret;
	else if (ret != GPIOF_INPUT)
		return -EOPNOTSUPP;

	return 0;
}

static int omnia_gpio_direction_output(struct udevice *dev, uint offset, int value)
{
	int ret;

	ret = omnia_gpio_get_function(dev, offset);
	if (ret < 0)
		return ret;
	else if (ret != GPIOF_OUTPUT)
		return -EOPNOTSUPP;

	return omnia_gpio_set_value(dev, offset, value);
}

static int omnia_gpio_xlate(struct udevice *dev, struct gpio_desc *desc,
				  struct ofnode_phandle_args *args)
{
	uint bank, gpio, flags, offset;
	int ret;

	if (args->args_count != 3)
		return -EINVAL;

	bank = args->args[0];
	gpio = args->args[1];
	flags = args->args[2];

	switch (bank) {
	case 0:
		if (gpio >= 16)
			return -EINVAL;
		offset = gpio;
		break;
	case 1:
		if (gpio >= 32)
			return -EINVAL;
		offset = 16 + gpio;
		break;
	case 2:
		if (gpio >= 16)
			return -EINVAL;
		offset = 16 + 32 + gpio;
		break;
	default:
		return -EINVAL;
	}

	ret = omnia_gpio_get_function(dev, offset);
	if (ret < 0)
		return ret;

	desc->offset = offset;
	desc->flags = gpio_flags_xlate(flags);

	return 0;
}

static const struct dm_gpio_ops omnia_gpio_ops = {
	.direction_input	= omnia_gpio_direction_input,
	.direction_output	= omnia_gpio_direction_output,
	.get_value		= omnia_gpio_get_value,
	.set_value		= omnia_gpio_set_value,
	.get_function		= omnia_gpio_get_function,
	.xlate			= omnia_gpio_xlate,
};

static int omnia_gpio_probe(struct udevice *dev)
{
	struct turris_omnia_mcu_info *info = dev_get_priv(dev->parent);
	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);

	uc_priv->bank_name = "mcu_";

	if ((info->features & FEAT_EXT_CMDS) && (info->features & FEAT_PERIPH_MCU))
		uc_priv->gpio_count = 16 + 32 + 16;
	else if (info->features & FEAT_EXT_CMDS)
		uc_priv->gpio_count = 16 + 32;
	else
		uc_priv->gpio_count = 16;

	return 0;
}

U_BOOT_DRIVER(turris_omnia_mcu_gpio) = {
	.name		= "turris-omnia-mcu-gpio",
	.id		= UCLASS_GPIO,
	.ops		= &omnia_gpio_ops,
	.probe		= omnia_gpio_probe,
};

static int omnia_sysreset_request(struct udevice *dev, enum sysreset_t type)
{
	struct {
		u16 magic;
		u16 arg;
		u32 csum;
	} __packed args;

	if (type != SYSRESET_POWER_OFF)
		return -EPROTONOSUPPORT;

	args.magic = CMD_POWER_OFF_MAGIC;
	args.arg = CMD_POWER_OFF_POWERON_BUTTON;
	args.csum = 0xba3b7212;

	return dm_i2c_write(dev->parent, CMD_POWER_OFF, (void *)&args,
			    sizeof(args));
}

static const struct sysreset_ops omnia_sysreset_ops = {
	.request	= omnia_sysreset_request,
};

U_BOOT_DRIVER(turris_omnia_mcu_sysreset) = {
	.name		= "turris-omnia-mcu-sysreset",
	.id		= UCLASS_SYSRESET,
	.ops		= &omnia_sysreset_ops,
};

static int omnia_rng_read(struct udevice *dev, void *data, size_t count)
{
	u8 buf[1 + CMD_TRNG_MAX_ENTROPY_LEN];
	size_t len;
	int ret;

	while (count) {
		ret = dm_i2c_read(dev->parent, CMD_TRNG_COLLECT_ENTROPY, buf,
				  sizeof(buf));
		if (ret)
			return ret;

		len = min_t(size_t, buf[0],
			    min_t(size_t, CMD_TRNG_MAX_ENTROPY_LEN, count));

		if (!len) {
			/* wait 500ms (fail if interrupted), then try again */
			for (int i = 0; i < 5; ++i) {
				mdelay(100);
				if (ctrlc())
					return -EINTR;
			}
			continue;
		}

		memcpy(data, &buf[1], len);
		data += len;
		count -= len;
	}

	return 0;
}

static const struct dm_rng_ops omnia_rng_ops = {
	.read		= omnia_rng_read,
};

U_BOOT_DRIVER(turris_omnia_mcu_trng) = {
	.name		= "turris-omnia-mcu-trng",
	.id		= UCLASS_RNG,
	.ops		= &omnia_rng_ops,
};

static int turris_omnia_mcu_bind(struct udevice *dev)
{
	/* bind MCU GPIOs as a child device */
	return device_bind_driver_to_node(dev, "turris-omnia-mcu-gpio",
					  "turris-omnia-mcu-gpio",
					  dev_ofnode(dev), NULL);
}

static int turris_omnia_mcu_probe(struct udevice *dev)
{
	struct turris_omnia_mcu_info *info = dev_get_priv(dev);
	u32 dword;
	u16 word;
	int ret;

	ret = dm_i2c_read(dev, CMD_GET_STATUS_WORD, (void *)&word, sizeof(word));
	if (ret < 0) {
		printf("Error: turris_omnia_mcu CMD_GET_STATUS_WORD failed: %d\n",
		       ret);
		return ret;
	}

	if (le16_to_cpu(word) & STS_FEATURES_SUPPORTED) {
		/* try read 32-bit features */
		ret = dm_i2c_read(dev, CMD_GET_FEATURES, (void *)&dword,
				  sizeof(dword));
		if (ret < 0) {
			/* try read 16-bit features */
			ret = dm_i2c_read(dev, CMD_GET_FEATURES, (void *)&word,
					  sizeof(word));
			if (ret < 0) {
				printf("Error: turris_omnia_mcu CMD_GET_FEATURES failed: %d\n",
				       ret);
				return ret;
			}

			info->features = le16_to_cpu(word);
		} else {
			info->features = le32_to_cpu(dword);
			if (info->features & FEAT_FROM_BIT_16_INVALID)
				info->features &= GENMASK(15, 0);
		}
	}

	/* bind sysreset if poweroff is supported */
	if (info->features & FEAT_POWEROFF_WAKEUP) {
		ret = device_bind_driver_to_node(dev,
						 "turris-omnia-mcu-sysreset",
						 "turris-omnia-mcu-sysreset",
						 dev_ofnode(dev), NULL);
		if (ret < 0)
			return ret;
	}

	/* bind rng if trng is supported */
	if (info->features & FEAT_TRNG) {
		ret = device_bind_driver_to_node(dev, "turris-omnia-mcu-trng",
						 "turris-omnia-mcu-trng",
						 dev_ofnode(dev), NULL);
		if (ret < 0)
			return ret;
	}

	return 0;
}

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

U_BOOT_DRIVER(turris_omnia_mcu) = {
	.name		= "turris-omnia-mcu",
	.id		= UCLASS_MISC,
	.bind		= turris_omnia_mcu_bind,
	.probe		= turris_omnia_mcu_probe,
	.priv_auto	= sizeof(struct turris_omnia_mcu_info),
	.of_match	= turris_omnia_mcu_ids,
};