#include "xe_survivability_mode.h"
#include "xe_survivability_mode_types.h"
#include <linux/kobject.h>
#include <linux/pci.h>
#include <linux/sysfs.h>
#include "xe_configfs.h"
#include "xe_device.h"
#include "xe_heci_gsc.h"
#include "xe_i2c.h"
#include "xe_log.h"
#include "xe_mmio.h"
#include "xe_nvm.h"
#include "xe_pcode_api.h"
#include "xe_printk.h"
#include "xe_vsec.h"
static const char * const reg_map[] = {
[CAPABILITY_INFO] = "Capability Info",
[POSTCODE_TRACE] = "Postcode trace",
[POSTCODE_TRACE_OVERFLOW] = "Postcode trace overflow",
[AUX_INFO0] = "Auxiliary Info 0",
[AUX_INFO1] = "Auxiliary Info 1",
[AUX_INFO2] = "Auxiliary Info 2",
[AUX_INFO3] = "Auxiliary Info 3",
[AUX_INFO4] = "Auxiliary Info 4",
};
#define FDO_INFO (MAX_SCRATCH_REG + 1)
struct xe_survivability_attribute {
struct device_attribute attr;
u8 index;
};
static struct
xe_survivability_attribute *dev_attr_to_survivability_attr(struct device_attribute *attr)
{
return container_of(attr, struct xe_survivability_attribute, attr);
}
static void set_survivability_info(struct xe_mmio *mmio, u32 *info, int id)
{
info[id] = xe_mmio_read32(mmio, PCODE_SCRATCH(id));
}
static void populate_survivability_info(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
u32 *info = survivability->info;
struct xe_mmio *mmio;
u32 id = 0, reg_value;
mmio = xe_root_tile_mmio(xe);
set_survivability_info(mmio, info, CAPABILITY_INFO);
reg_value = info[CAPABILITY_INFO];
survivability->version = REG_FIELD_GET(BREADCRUMB_VERSION, reg_value);
if (survivability->version >= 2)
survivability->fdo_mode = REG_FIELD_GET(FDO_MODE, reg_value);
if (reg_value & HISTORY_TRACKING) {
set_survivability_info(mmio, info, POSTCODE_TRACE);
if (reg_value & OVERFLOW_SUPPORT)
set_survivability_info(mmio, info, POSTCODE_TRACE_OVERFLOW);
}
if (reg_value & AUXINFO_SUPPORT) {
for (id = REG_FIELD_GET(AUXINFO_REG_OFFSET, reg_value);
id >= AUX_INFO0 && id < MAX_SCRATCH_REG;
id = REG_FIELD_GET(AUXINFO_HISTORY_OFFSET, info[id]))
set_survivability_info(mmio, info, id);
}
}
static const char *boot_status_str(u8 boot_status)
{
switch (boot_status) {
case CRITICAL_FAILURE:
return "Critical Failure";
case NON_CRITICAL_FAILURE:
return "Non Critical Failure";
default:
return "Other";
}
}
static void log_survivability_info(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
u32 *info = survivability->info;
int id;
xe_log_info(xe, SURVIVABILITY, "Boot Status: %#x (%s)\n",
survivability->boot_status,
boot_status_str(survivability->boot_status));
for (id = 0; id < MAX_SCRATCH_REG; id++) {
if (!info[id])
continue;
xe_log_info(xe, SURVIVABILITY, "%s: %#x\n", reg_map[id], info[id]);
}
}
static int check_boot_failure(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
return survivability->boot_status == NON_CRITICAL_FAILURE ||
survivability->boot_status == CRITICAL_FAILURE;
}
static ssize_t survivability_mode_show(struct device *dev,
struct device_attribute *attr, char *buff)
{
struct pci_dev *pdev = to_pci_dev(dev);
struct xe_device *xe = pdev_to_xe_device(pdev);
struct xe_survivability *survivability = &xe->survivability;
return sysfs_emit(buff, "%s\n", survivability->type ? "Runtime" : "Boot");
}
static DEVICE_ATTR_ADMIN_RO(survivability_mode);
static ssize_t survivability_info_show(struct device *dev,
struct device_attribute *attr, char *buff)
{
struct xe_survivability_attribute *sa = dev_attr_to_survivability_attr(attr);
struct pci_dev *pdev = to_pci_dev(dev);
struct xe_device *xe = pdev_to_xe_device(pdev);
struct xe_survivability *survivability = &xe->survivability;
u32 *info = survivability->info;
if (sa->index == FDO_INFO)
return sysfs_emit(buff, "%s\n", str_enabled_disabled(survivability->fdo_mode));
return sysfs_emit(buff, "0x%x\n", info[sa->index]);
}
#define SURVIVABILITY_ATTR_RO(name, _index) \
struct xe_survivability_attribute attr_##name = { \
.attr = __ATTR(name, 0400, survivability_info_show, NULL), \
.index = _index, \
}
static SURVIVABILITY_ATTR_RO(capability_info, CAPABILITY_INFO);
static SURVIVABILITY_ATTR_RO(postcode_trace, POSTCODE_TRACE);
static SURVIVABILITY_ATTR_RO(postcode_trace_overflow, POSTCODE_TRACE_OVERFLOW);
static SURVIVABILITY_ATTR_RO(aux_info0, AUX_INFO0);
static SURVIVABILITY_ATTR_RO(aux_info1, AUX_INFO1);
static SURVIVABILITY_ATTR_RO(aux_info2, AUX_INFO2);
static SURVIVABILITY_ATTR_RO(aux_info3, AUX_INFO3);
static SURVIVABILITY_ATTR_RO(aux_info4, AUX_INFO4);
static SURVIVABILITY_ATTR_RO(fdo_mode, FDO_INFO);
static void xe_survivability_mode_fini(void *arg)
{
struct xe_device *xe = arg;
struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
struct device *dev = &pdev->dev;
device_remove_file(dev, &dev_attr_survivability_mode);
}
static umode_t survivability_info_attrs_visible(struct kobject *kobj, struct attribute *attr,
int idx)
{
struct xe_device *xe = kdev_to_xe_device(kobj_to_dev(kobj));
struct xe_survivability *survivability = &xe->survivability;
u32 *info = survivability->info;
if (idx == MAX_SCRATCH_REG && survivability->version >= 2)
return 0400;
if (idx < MAX_SCRATCH_REG && info[idx])
return 0400;
return 0;
}
static struct attribute *survivability_info_attrs[] = {
&attr_capability_info.attr.attr,
&attr_postcode_trace.attr.attr,
&attr_postcode_trace_overflow.attr.attr,
&attr_aux_info0.attr.attr,
&attr_aux_info1.attr.attr,
&attr_aux_info2.attr.attr,
&attr_aux_info3.attr.attr,
&attr_aux_info4.attr.attr,
&attr_fdo_mode.attr.attr,
NULL,
};
static const struct attribute_group survivability_info_group = {
.name = "survivability_info",
.attrs = survivability_info_attrs,
.is_visible = survivability_info_attrs_visible,
};
static int create_survivability_sysfs(struct pci_dev *pdev)
{
bool needs_info = !xe_configfs_get_survivability_mode(pdev);
struct xe_device *xe = pdev_to_xe_device(pdev);
struct device *dev = &pdev->dev;
int ret;
ret = device_create_file(dev, &dev_attr_survivability_mode);
if (ret)
goto failed;
ret = devm_add_action_or_reset(xe->drm.dev,
xe_survivability_mode_fini, xe);
if (ret)
goto failed;
if (needs_info) {
ret = devm_device_add_group(dev, &survivability_info_group);
if (ret)
goto failed;
}
return 0;
failed:
xe_err(xe, "Failed to create survivability sysfs files: %pe\n", ERR_PTR(ret));
if (needs_info)
log_survivability_info(xe);
return ret;
}
static int enable_boot_survivability_mode(struct pci_dev *pdev)
{
struct xe_device *xe = pdev_to_xe_device(pdev);
struct xe_survivability *survivability = &xe->survivability;
int ret;
ret = create_survivability_sysfs(pdev);
if (ret)
goto failed;
survivability->mode = true;
xe_heci_gsc_init(xe);
xe_vsec_init(xe);
if (survivability->fdo_mode) {
ret = xe_nvm_init(xe);
if (ret)
goto failed;
}
ret = xe_i2c_probe(xe);
if (ret)
goto failed;
if (check_boot_failure(xe))
xe_log_err_fatal(pdev, SURVIVABILITY, 0, "Boot Mode enabled!\n");
else
xe_log_info(pdev, SURVIVABILITY, "Boot Mode enabled!\n");
return 0;
failed:
xe_log_err_fatal(pdev, SURVIVABILITY, ret, "Failed to enable Boot Mode!\n");
survivability->mode = false;
return ret;
}
bool xe_survivability_mode_is_boot_enabled(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
return survivability->mode && survivability->type == XE_SURVIVABILITY_TYPE_BOOT;
}
bool xe_survivability_mode_is_requested(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
struct xe_mmio *mmio = xe_root_tile_mmio(xe);
struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
u32 data;
bool survivability_mode;
if (!IS_DGFX(xe) || IS_SRIOV_VF(xe) || xe->info.platform < XE_BATTLEMAGE)
return false;
survivability_mode = xe_configfs_get_survivability_mode(pdev);
if (survivability_mode)
return true;
data = xe_mmio_read32(mmio, PCODE_SCRATCH(0));
survivability->boot_status = REG_FIELD_GET(BOOT_STATUS, data);
return check_boot_failure(xe);
}
void xe_survivability_mode_runtime_enable(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
if (!IS_DGFX(xe) || IS_SRIOV_VF(xe) || xe->info.platform < XE_BATTLEMAGE) {
xe_log_err(xe, SURVIVABILITY, -EOPNOTSUPP, "Runtime Mode not supported!\n");
return;
}
populate_survivability_info(xe);
create_survivability_sysfs(pdev);
survivability->type = XE_SURVIVABILITY_TYPE_RUNTIME;
xe_log_err(xe, SURVIVABILITY, 0, "Runtime Mode enabled!\n");
xe_device_declare_wedged(xe, DRM_WEDGE_RECOVERY_VENDOR);
xe_log_err(xe, SURVIVABILITY, 0, "Firmware flash required!\n");
xe_info(xe, "Please refer to the userspace documentation for more details how to flash the firmware on %s!\n",
xe->info.platform_name);
}
int xe_survivability_mode_boot_enable(struct xe_device *xe)
{
struct xe_survivability *survivability = &xe->survivability;
struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
if (!xe_survivability_mode_is_requested(xe))
return 0;
populate_survivability_info(xe);
if (survivability->version < 2 && survivability->boot_status == CRITICAL_FAILURE) {
log_survivability_info(xe);
return -ENXIO;
}
survivability->type = XE_SURVIVABILITY_TYPE_BOOT;
return enable_boot_survivability_mode(pdev);
}