drivers/platform/mellanox/mlxbf-bootctl.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Mellanox boot control driver
  *
  * This driver provides a sysfs interface for systems management
  * software to manage reset-time actions.
  *
  * Copyright (C) 2019 Mellanox Technologies
  */

 #include <linux/acpi.h>
 #include <linux/arm-smccc.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>

 #include "mlxbf-bootctl.h"

 #define MLXBF_BOOTCTL_SB_SECURE_MASK		0x03
 #define MLXBF_BOOTCTL_SB_TEST_MASK		0x0c

 #define MLXBF_SB_KEY_NUM			4

 /* UUID used to probe ATF service. */
 static const char *mlxbf_bootctl_svc_uuid_str =
 	"89c036b4-e7d7-11e6-8797-001aca00bfc4";

 struct mlxbf_bootctl_name {
 	u32 value;
 	const char *name;
 };

 static struct mlxbf_bootctl_name boot_names[] = {
 	{ MLXBF_BOOTCTL_EXTERNAL, "external" },
 	{ MLXBF_BOOTCTL_EMMC, "emmc" },
 	{ MLNX_BOOTCTL_SWAP_EMMC, "swap_emmc" },
 	{ MLXBF_BOOTCTL_EMMC_LEGACY, "emmc_legacy" },
 	{ MLXBF_BOOTCTL_NONE, "none" },
 };

 static const char * const mlxbf_bootctl_lifecycle_states[] = {
 	[0] = "Production",
 	[1] = "GA Secured",
 	[2] = "GA Non-Secured",
 	[3] = "RMA",
 };

 /* ARM SMC call which is atomic and no need for lock. */
 static int mlxbf_bootctl_smc(unsigned int smc_op, int smc_arg)
 {
 	struct arm_smccc_res res;

 	arm_smccc_smc(smc_op, smc_arg, 0, 0, 0, 0, 0, 0, &res);

 	return res.a0;
 }

 /* Return the action in integer or an error code. */
 static int mlxbf_bootctl_reset_action_to_val(const char *action)
 {
 	int i;

 	for (i = 0; i < ARRAY_SIZE(boot_names); i++)
 		if (sysfs_streq(boot_names[i].name, action))
 			return boot_names[i].value;

 	return -EINVAL;
 }

 /* Return the action in string. */
 static const char *mlxbf_bootctl_action_to_string(int action)
 {
 	int i;

 	for (i = 0; i < ARRAY_SIZE(boot_names); i++)
 		if (boot_names[i].value == action)
 			return boot_names[i].name;

 	return "invalid action";
 }

 static ssize_t post_reset_wdog_show(struct device *dev,
 				    struct device_attribute *attr, char *buf)
 {
 	int ret;

 	ret = mlxbf_bootctl_smc(MLXBF_BOOTCTL_GET_POST_RESET_WDOG, 0);
 	if (ret < 0)
 		return ret;

 	return sprintf(buf, "%d\n", ret);
 }

 static ssize_t post_reset_wdog_store(struct device *dev,
 				     struct device_attribute *attr,
 				     const char *buf, size_t count)
 {
 	unsigned long value;
 	int ret;

 	ret = kstrtoul(buf, 10, &value);
 	if (ret)
 		return ret;

 	ret = mlxbf_bootctl_smc(MLXBF_BOOTCTL_SET_POST_RESET_WDOG, value);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 static ssize_t mlxbf_bootctl_show(int smc_op, char *buf)
 {
 	int action;

 	action = mlxbf_bootctl_smc(smc_op, 0);
 	if (action < 0)
 		return action;

 	return sprintf(buf, "%s\n", mlxbf_bootctl_action_to_string(action));
 }

 static int mlxbf_bootctl_store(int smc_op, const char *buf, size_t count)
 {
 	int ret, action;

 	action = mlxbf_bootctl_reset_action_to_val(buf);
 	if (action < 0)
 		return action;

 	ret = mlxbf_bootctl_smc(smc_op, action);
 	if (ret < 0)
 		return ret;

 	return count;
 }

 static ssize_t reset_action_show(struct device *dev,
 				 struct device_attribute *attr, char *buf)
 {
 	return mlxbf_bootctl_show(MLXBF_BOOTCTL_GET_RESET_ACTION, buf);
 }

 static ssize_t reset_action_store(struct device *dev,
 				  struct device_attribute *attr,
 				  const char *buf, size_t count)
 {
 	return mlxbf_bootctl_store(MLXBF_BOOTCTL_SET_RESET_ACTION, buf, count);
 }

 static ssize_t second_reset_action_show(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
 	return mlxbf_bootctl_show(MLXBF_BOOTCTL_GET_SECOND_RESET_ACTION, buf);
 }

 static ssize_t second_reset_action_store(struct device *dev,
 					 struct device_attribute *attr,
 					 const char *buf, size_t count)
 {
 	return mlxbf_bootctl_store(MLXBF_BOOTCTL_SET_SECOND_RESET_ACTION, buf,
 				   count);
 }

 static ssize_t lifecycle_state_show(struct device *dev,
 				    struct device_attribute *attr, char *buf)
 {
 	int lc_state;

 	lc_state = mlxbf_bootctl_smc(MLXBF_BOOTCTL_GET_TBB_FUSE_STATUS,
 				     MLXBF_BOOTCTL_FUSE_STATUS_LIFECYCLE);
 	if (lc_state < 0)
 		return lc_state;

 	lc_state &=
 		MLXBF_BOOTCTL_SB_TEST_MASK | MLXBF_BOOTCTL_SB_SECURE_MASK;

 	/*
 	 * If the test bits are set, we specify that the current state may be
 	 * due to using the test bits.
 	 */
 	if (lc_state & MLXBF_BOOTCTL_SB_TEST_MASK) {
 		lc_state &= MLXBF_BOOTCTL_SB_SECURE_MASK;

 		return sprintf(buf, "%s(test)\n",
 			       mlxbf_bootctl_lifecycle_states[lc_state]);
 	}

 	return sprintf(buf, "%s\n", mlxbf_bootctl_lifecycle_states[lc_state]);
 }

 static ssize_t secure_boot_fuse_state_show(struct device *dev,
 					   struct device_attribute *attr,
 					   char *buf)
 {
 	int burnt, valid, key, key_state, buf_len = 0, upper_key_used = 0;
 	const char *status;

 	key_state = mlxbf_bootctl_smc(MLXBF_BOOTCTL_GET_TBB_FUSE_STATUS,
 				      MLXBF_BOOTCTL_FUSE_STATUS_KEYS);
 	if (key_state < 0)
 		return key_state;

 	/*
 	 * key_state contains the bits for 4 Key versions, loaded from eFuses
 	 * after a hard reset. Lower 4 bits are a thermometer code indicating
 	 * key programming has started for key n (0000 = none, 0001 = version 0,
 	 * 0011 = version 1, 0111 = version 2, 1111 = version 3). Upper 4 bits
 	 * are a thermometer code indicating key programming has completed for
 	 * key n (same encodings as the start bits). This allows for detection
 	 * of an interruption in the progamming process which has left the key
 	 * partially programmed (and thus invalid). The process is to burn the
 	 * eFuse for the new key start bit, burn the key eFuses, then burn the
 	 * eFuse for the new key complete bit.
 	 *
 	 * For example 0000_0000: no key valid, 0001_0001: key version 0 valid,
 	 * 0011_0011: key 1 version valid, 0011_0111: key version 2 started
 	 * programming but did not complete, etc. The most recent key for which
 	 * both start and complete bit is set is loaded. On soft reset, this
 	 * register is not modified.
 	 */
 	for (key = MLXBF_SB_KEY_NUM - 1; key >= 0; key--) {
 		burnt = key_state & BIT(key);
 		valid = key_state & BIT(key + MLXBF_SB_KEY_NUM);

 		if (burnt && valid)
 			upper_key_used = 1;

 		if (upper_key_used) {
 			if (burnt)
 				status = valid ? "Used" : "Wasted";
 			else
 				status = valid ? "Invalid" : "Skipped";
 		} else {
 			if (burnt)
 				status = valid ? "InUse" : "Incomplete";
 			else
 				status = valid ? "Invalid" : "Free";
 		}
 		buf_len += sprintf(buf + buf_len, "%d:%s ", key, status);
 	}
 	buf_len += sprintf(buf + buf_len, "\n");

 	return buf_len;
 }

 static DEVICE_ATTR_RW(post_reset_wdog);
 static DEVICE_ATTR_RW(reset_action);
 static DEVICE_ATTR_RW(second_reset_action);
 static DEVICE_ATTR_RO(lifecycle_state);
 static DEVICE_ATTR_RO(secure_boot_fuse_state);

 static struct attribute *mlxbf_bootctl_attrs[] = {
 	&dev_attr_post_reset_wdog.attr,
 	&dev_attr_reset_action.attr,
 	&dev_attr_second_reset_action.attr,
 	&dev_attr_lifecycle_state.attr,
 	&dev_attr_secure_boot_fuse_state.attr,
 	NULL
 };

 ATTRIBUTE_GROUPS(mlxbf_bootctl);

 static const struct acpi_device_id mlxbf_bootctl_acpi_ids[] = {
 	{"MLNXBF04", 0},
 	{}
 };

 MODULE_DEVICE_TABLE(acpi, mlxbf_bootctl_acpi_ids);

 static bool mlxbf_bootctl_guid_match(const guid_t *guid,
 				     const struct arm_smccc_res *res)
 {
 	guid_t id = GUID_INIT(res->a0, res->a1, res->a1 >> 16,
 			      res->a2, res->a2 >> 8, res->a2 >> 16,
 			      res->a2 >> 24, res->a3, res->a3 >> 8,
 			      res->a3 >> 16, res->a3 >> 24);

 	return guid_equal(guid, &id);
 }

 static int mlxbf_bootctl_probe(struct platform_device *pdev)
 {
 	struct arm_smccc_res res = { 0 };
 	guid_t guid;
 	int ret;

 	/* Ensure we have the UUID we expect for this service. */
 	arm_smccc_smc(MLXBF_BOOTCTL_SIP_SVC_UID, 0, 0, 0, 0, 0, 0, 0, &res);
 	guid_parse(mlxbf_bootctl_svc_uuid_str, &guid);
 	if (!mlxbf_bootctl_guid_match(&guid, &res))
 		return -ENODEV;

 	/*
 	 * When watchdog is used, it sets boot mode to MLXBF_BOOTCTL_SWAP_EMMC
 	 * in case of boot failures. However it doesn't clear the state if there
 	 * is no failure. Restore the default boot mode here to avoid any
 	 * unnecessary boot partition swapping.
 	 */
 	ret = mlxbf_bootctl_smc(MLXBF_BOOTCTL_SET_RESET_ACTION,
 				MLXBF_BOOTCTL_EMMC);
 	if (ret < 0)
 		dev_warn(&pdev->dev, "Unable to reset the EMMC boot mode\n");

 	return 0;
 }

 static struct platform_driver mlxbf_bootctl_driver = {
 	.probe = mlxbf_bootctl_probe,
 	.driver = {
 		.name = "mlxbf-bootctl",
 		.dev_groups = mlxbf_bootctl_groups,
 		.acpi_match_table = mlxbf_bootctl_acpi_ids,
 	}
 };

 module_platform_driver(mlxbf_bootctl_driver);

 MODULE_DESCRIPTION("Mellanox boot control driver");
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Mellanox Technologies");
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Mellanox boot control driver
	*
	* This driver provides a sysfs interface for systems management
	* software to manage reset-time actions.
	*
	* Copyright (C) 2019 Mellanox Technologies
	*/

	#include <linux/acpi.h>
	#include <linux/arm-smccc.h>
	#include <linux/module.h>
	#include <linux/platform_device.h>

	#include "mlxbf-bootctl.h"

	#define MLXBF_BOOTCTL_SB_SECURE_MASK 0x03
	#define MLXBF_BOOTCTL_SB_TEST_MASK 0x0c

	#define MLXBF_SB_KEY_NUM 4

	/* UUID used to probe ATF service. */
	static const char *mlxbf_bootctl_svc_uuid_str =
	"89c036b4-e7d7-11e6-8797-001aca00bfc4";

	struct mlxbf_bootctl_name {
	u32 value;
	const char *name;
	};

	static struct mlxbf_bootctl_name boot_names[] = {
	{ MLXBF_BOOTCTL_EXTERNAL, "external" },
	{ MLXBF_BOOTCTL_EMMC, "emmc" },
	{ MLNX_BOOTCTL_SWAP_EMMC, "swap_emmc" },
	{ MLXBF_BOOTCTL_EMMC_LEGACY, "emmc_legacy" },
	{ MLXBF_BOOTCTL_NONE, "none" },
	};

	static const char * const mlxbf_bootctl_lifecycle_states[] = {
	[0] = "Production",
	[1] = "GA Secured",
	[2] = "GA Non-Secured",
	[3] = "RMA",
	};

	/* ARM SMC call which is atomic and no need for lock. */
	static int mlxbf_bootctl_smc(unsigned int smc_op, int smc_arg)
	{
	struct arm_smccc_res res;

	arm_smccc_smc(smc_op, smc_arg, 0, 0, 0, 0, 0, 0, &res);

	return res.a0;
	}

	/* Return the action in integer or an error code. */
	static int mlxbf_bootctl_reset_action_to_val(const char *action)
	{
	int i;

	for (i = 0; i < ARRAY_SIZE(boot_names); i++)
	if (sysfs_streq(boot_names[i].name, action))
	return boot_names[i].value;

	return -EINVAL;
	}

	/* Return the action in string. */
	static const char *mlxbf_bootctl_action_to_string(int action)
	{
	int i;

	for (i = 0; i < ARRAY_SIZE(boot_names); i++)
	if (boot_names[i].value == action)
	return boot_names[i].name;

	return "invalid action";
	}

	static ssize_t post_reset_wdog_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	int ret;

	ret = mlxbf_bootctl_smc(MLXBF_BOOTCTL_GET_POST_RESET_WDOG, 0);
	if (ret < 0)
	return ret;

	return sprintf(buf, "%d\n", ret);
	}

	static ssize_t post_reset_wdog_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	unsigned long value;
	int ret;

	ret = kstrtoul(buf, 10, &value);
	if (ret)
	return ret;

	ret = mlxbf_bootctl_smc(MLXBF_BOOTCTL_SET_POST_RESET_WDOG, value);
	if (ret < 0)
	return ret;

	return count;
	}

	static ssize_t mlxbf_bootctl_show(int smc_op, char *buf)
	{
	int action;

	action = mlxbf_bootctl_smc(smc_op, 0);
	if (action < 0)
	return action;

	return sprintf(buf, "%s\n", mlxbf_bootctl_action_to_string(action));
	}

	static int mlxbf_bootctl_store(int smc_op, const char *buf, size_t count)
	{
	int ret, action;

	action = mlxbf_bootctl_reset_action_to_val(buf);
	if (action < 0)
	return action;

	ret = mlxbf_bootctl_smc(smc_op, action);
	if (ret < 0)
	return ret;

	return count;
	}

	static ssize_t reset_action_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	return mlxbf_bootctl_show(MLXBF_BOOTCTL_GET_RESET_ACTION, buf);
	}

	static ssize_t reset_action_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	return mlxbf_bootctl_store(MLXBF_BOOTCTL_SET_RESET_ACTION, buf, count);
	}

	static ssize_t second_reset_action_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	return mlxbf_bootctl_show(MLXBF_BOOTCTL_GET_SECOND_RESET_ACTION, buf);
	}

	static ssize_t second_reset_action_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	return mlxbf_bootctl_store(MLXBF_BOOTCTL_SET_SECOND_RESET_ACTION, buf,
	count);
	}

	static ssize_t lifecycle_state_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	int lc_state;

	lc_state = mlxbf_bootctl_smc(MLXBF_BOOTCTL_GET_TBB_FUSE_STATUS,
	MLXBF_BOOTCTL_FUSE_STATUS_LIFECYCLE);
	if (lc_state < 0)
	return lc_state;

	lc_state &=
	MLXBF_BOOTCTL_SB_TEST_MASK \| MLXBF_BOOTCTL_SB_SECURE_MASK;

	/*
	* If the test bits are set, we specify that the current state may be
	* due to using the test bits.
	*/
	if (lc_state & MLXBF_BOOTCTL_SB_TEST_MASK) {
	lc_state &= MLXBF_BOOTCTL_SB_SECURE_MASK;

	return sprintf(buf, "%s(test)\n",
	mlxbf_bootctl_lifecycle_states[lc_state]);
	}

	return sprintf(buf, "%s\n", mlxbf_bootctl_lifecycle_states[lc_state]);
	}

	static ssize_t secure_boot_fuse_state_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	int burnt, valid, key, key_state, buf_len = 0, upper_key_used = 0;
	const char *status;

	key_state = mlxbf_bootctl_smc(MLXBF_BOOTCTL_GET_TBB_FUSE_STATUS,
	MLXBF_BOOTCTL_FUSE_STATUS_KEYS);
	if (key_state < 0)
	return key_state;

	/*
	* key_state contains the bits for 4 Key versions, loaded from eFuses
	* after a hard reset. Lower 4 bits are a thermometer code indicating
	* key programming has started for key n (0000 = none, 0001 = version 0,
	* 0011 = version 1, 0111 = version 2, 1111 = version 3). Upper 4 bits
	* are a thermometer code indicating key programming has completed for
	* key n (same encodings as the start bits). This allows for detection
	* of an interruption in the progamming process which has left the key
	* partially programmed (and thus invalid). The process is to burn the
	* eFuse for the new key start bit, burn the key eFuses, then burn the
	* eFuse for the new key complete bit.
	*
	* For example 0000_0000: no key valid, 0001_0001: key version 0 valid,
	* 0011_0011: key 1 version valid, 0011_0111: key version 2 started
	* programming but did not complete, etc. The most recent key for which
	* both start and complete bit is set is loaded. On soft reset, this
	* register is not modified.
	*/
	for (key = MLXBF_SB_KEY_NUM - 1; key >= 0; key--) {
	burnt = key_state & BIT(key);
	valid = key_state & BIT(key + MLXBF_SB_KEY_NUM);

	if (burnt && valid)
	upper_key_used = 1;

	if (upper_key_used) {
	if (burnt)
	status = valid ? "Used" : "Wasted";
	else
	status = valid ? "Invalid" : "Skipped";
	} else {
	if (burnt)
	status = valid ? "InUse" : "Incomplete";
	else
	status = valid ? "Invalid" : "Free";
	}
	buf_len += sprintf(buf + buf_len, "%d:%s ", key, status);
	}
	buf_len += sprintf(buf + buf_len, "\n");

	return buf_len;
	}

	static DEVICE_ATTR_RW(post_reset_wdog);
	static DEVICE_ATTR_RW(reset_action);
	static DEVICE_ATTR_RW(second_reset_action);
	static DEVICE_ATTR_RO(lifecycle_state);
	static DEVICE_ATTR_RO(secure_boot_fuse_state);

	static struct attribute *mlxbf_bootctl_attrs[] = {
	&dev_attr_post_reset_wdog.attr,
	&dev_attr_reset_action.attr,
	&dev_attr_second_reset_action.attr,
	&dev_attr_lifecycle_state.attr,
	&dev_attr_secure_boot_fuse_state.attr,
	NULL
	};

	ATTRIBUTE_GROUPS(mlxbf_bootctl);

	static const struct acpi_device_id mlxbf_bootctl_acpi_ids[] = {
	{"MLNXBF04", 0},
	{}
	};

	MODULE_DEVICE_TABLE(acpi, mlxbf_bootctl_acpi_ids);

	static bool mlxbf_bootctl_guid_match(const guid_t *guid,
	const struct arm_smccc_res *res)
	{
	guid_t id = GUID_INIT(res->a0, res->a1, res->a1 >> 16,
	res->a2, res->a2 >> 8, res->a2 >> 16,
	res->a2 >> 24, res->a3, res->a3 >> 8,
	res->a3 >> 16, res->a3 >> 24);

	return guid_equal(guid, &id);
	}

	static int mlxbf_bootctl_probe(struct platform_device *pdev)
	{
	struct arm_smccc_res res = { 0 };
	guid_t guid;
	int ret;

	/* Ensure we have the UUID we expect for this service. */
	arm_smccc_smc(MLXBF_BOOTCTL_SIP_SVC_UID, 0, 0, 0, 0, 0, 0, 0, &res);
	guid_parse(mlxbf_bootctl_svc_uuid_str, &guid);
	if (!mlxbf_bootctl_guid_match(&guid, &res))
	return -ENODEV;

	/*
	* When watchdog is used, it sets boot mode to MLXBF_BOOTCTL_SWAP_EMMC
	* in case of boot failures. However it doesn't clear the state if there
	* is no failure. Restore the default boot mode here to avoid any
	* unnecessary boot partition swapping.
	*/
	ret = mlxbf_bootctl_smc(MLXBF_BOOTCTL_SET_RESET_ACTION,
	MLXBF_BOOTCTL_EMMC);
	if (ret < 0)
	dev_warn(&pdev->dev, "Unable to reset the EMMC boot mode\n");

	return 0;
	}

	static struct platform_driver mlxbf_bootctl_driver = {
	.probe = mlxbf_bootctl_probe,
	.driver = {
	.name = "mlxbf-bootctl",
	.dev_groups = mlxbf_bootctl_groups,
	.acpi_match_table = mlxbf_bootctl_acpi_ids,
	}
	};

	module_platform_driver(mlxbf_bootctl_driver);

	MODULE_DESCRIPTION("Mellanox boot control driver");
	MODULE_LICENSE("GPL v2");
	MODULE_AUTHOR("Mellanox Technologies");