mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
321 lines
8.3 KiB
321 lines
8.3 KiB
// 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");
|
|
|