// SPDX-License-Identifier: GPL-2.0/* * The generic ECS driver is designed to support control of on-die error * check scrub (e.g., DDR5 ECS). The common sysfs ECS interface abstracts * the control of various ECS functionalities into a unified set of functions. * * Copyright (c) 2024-2025 HiSilicon Limited. */ #include <linux/edac.h> #define EDAC_ECS_FRU_NAME "ecs_fru" enum edac_ecs_attributes {	ECS_LOG_ENTRY_TYPE,	ECS_MODE,	ECS_RESET,	ECS_THRESHOLD,	ECS_MAX_ATTRS}; struct edac_ecs_dev_attr {	struct device_attribute dev_attr;	int fru_id;}; struct edac_ecs_fru_context {	char name[EDAC_FEAT_NAME_LEN];	struct edac_ecs_dev_attr dev_attr[ECS_MAX_ATTRS];	struct attribute *ecs_attrs[ECS_MAX_ATTRS + 1];	struct attribute_group group;}; struct edac_ecs_context {	u16 num_media_frus;	struct edac_ecs_fru_context *fru_ctxs;}; #define TO_ECS_DEV_ATTR(_dev_attr)	\	container_of(_dev_attr, struct edac_ecs_dev_attr, dev_attr) #define EDAC_ECS_ATTR_SHOW(attrib, cb, type, format)				\static ssize_t attrib##_show(struct device *ras_feat_dev,			\			     struct device_attribute *attr, char *buf)		\{										\	struct edac_ecs_dev_attr *dev_attr = TO_ECS_DEV_ATTR(attr);		\	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);		\	const struct edac_ecs_ops *ops = ctx->ecs.ecs_ops;			\	type data;								\	int ret;								\										\	ret = ops->cb(ras_feat_dev->parent, ctx->ecs.private,			\		      dev_attr->fru_id, &data);					\	if (ret)								\		return ret;							\										\	return sysfs_emit(buf, format, data);					\} EDAC_ECS_ATTR_SHOW(log_entry_type, get_log_entry_type, u32, "%u\n")EDAC_ECS_ATTR_SHOW(mode, get_mode, u32, "%u\n")EDAC_ECS_ATTR_SHOW(threshold, get_threshold, u32, "%u\n") #define EDAC_ECS_ATTR_STORE(attrib, cb, type, conv_func)			\static ssize_t attrib##_store(struct device *ras_feat_dev,			\			      struct device_attribute *attr,			\			      const char *buf, size_t len)			\{										\	struct edac_ecs_dev_attr *dev_attr = TO_ECS_DEV_ATTR(attr);		\	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);		\	const struct edac_ecs_ops *ops = ctx->ecs.ecs_ops;			\	type data;								\	int ret;								\										\	ret = conv_func(buf, 0, &data);						\	if (ret < 0)								\		return ret;							\										\	ret = ops->cb(ras_feat_dev->parent, ctx->ecs.private,			\		      dev_attr->fru_id, data);					\	if (ret)								\		return ret;							\										\	return len;								\} EDAC_ECS_ATTR_STORE(log_entry_type, set_log_entry_type, unsigned long, kstrtoul)EDAC_ECS_ATTR_STORE(mode, set_mode, unsigned long, kstrtoul)EDAC_ECS_ATTR_STORE(reset, reset, unsigned long, kstrtoul)EDAC_ECS_ATTR_STORE(threshold, set_threshold, unsigned long, kstrtoul) static umode_t ecs_attr_visible(struct kobject *kobj, struct attribute *a, int attr_id){	struct device *ras_feat_dev = kobj_to_dev(kobj);	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);	const struct edac_ecs_ops *ops = ctx->ecs.ecs_ops; 	switch (attr_id) {	case ECS_LOG_ENTRY_TYPE:		if (ops->get_log_entry_type)  {			if (ops->set_log_entry_type)				return a->mode;			else				return 0444;		}		break;	case ECS_MODE:		if (ops->get_mode) {			if (ops->set_mode)				return a->mode;			else				return 0444;		}		break;	case ECS_RESET:		if (ops->reset)			return a->mode;		break;	case ECS_THRESHOLD:		if (ops->get_threshold) {			if (ops->set_threshold)				return a->mode;			else				return 0444;		}		break;	default:		break;	} 	return 0;} #define EDAC_ECS_ATTR_RO(_name, _fru_id)       \	((struct edac_ecs_dev_attr) { .dev_attr = __ATTR_RO(_name), \				     .fru_id = _fru_id }) #define EDAC_ECS_ATTR_WO(_name, _fru_id)       \	((struct edac_ecs_dev_attr) { .dev_attr = __ATTR_WO(_name), \				     .fru_id = _fru_id }) #define EDAC_ECS_ATTR_RW(_name, _fru_id)       \	((struct edac_ecs_dev_attr) { .dev_attr = __ATTR_RW(_name), \				     .fru_id = _fru_id }) static int ecs_create_desc(struct device *ecs_dev, const struct attribute_group **attr_groups,			   u16 num_media_frus){	struct edac_ecs_context *ecs_ctx;	u32 fru; 	ecs_ctx = devm_kzalloc(ecs_dev, sizeof(*ecs_ctx), GFP_KERNEL);	if (!ecs_ctx)		return -ENOMEM; 	ecs_ctx->num_media_frus = num_media_frus;	ecs_ctx->fru_ctxs = devm_kcalloc(ecs_dev, num_media_frus,					 sizeof(*ecs_ctx->fru_ctxs),					 GFP_KERNEL);	if (!ecs_ctx->fru_ctxs)		return -ENOMEM; 	for (fru = 0; fru < num_media_frus; fru++) {		struct edac_ecs_fru_context *fru_ctx = &ecs_ctx->fru_ctxs[fru];		struct attribute_group *group = &fru_ctx->group;		int i; 		fru_ctx->dev_attr[ECS_LOG_ENTRY_TYPE]	= EDAC_ECS_ATTR_RW(log_entry_type, fru);		fru_ctx->dev_attr[ECS_MODE]		= EDAC_ECS_ATTR_RW(mode, fru);		fru_ctx->dev_attr[ECS_RESET]		= EDAC_ECS_ATTR_WO(reset, fru);		fru_ctx->dev_attr[ECS_THRESHOLD]	= EDAC_ECS_ATTR_RW(threshold, fru); 		for (i = 0; i < ECS_MAX_ATTRS; i++) {			sysfs_attr_init(&fru_ctx->dev_attr[i].dev_attr.attr);			fru_ctx->ecs_attrs[i] = &fru_ctx->dev_attr[i].dev_attr.attr;		} 		sprintf(fru_ctx->name, "%s%d", EDAC_ECS_FRU_NAME, fru);		group->name = fru_ctx->name;		group->attrs = fru_ctx->ecs_attrs;		group->is_visible  = ecs_attr_visible; 		attr_groups[fru] = group;	} 	return 0;} /** * edac_ecs_get_desc - get EDAC ECS descriptors * @ecs_dev: client device, supports ECS feature * @attr_groups: pointer to attribute group container * @num_media_frus: number of media FRUs in the device * * Return: *  * %0	- Success. *  * %-EINVAL	- Invalid parameters passed. *  * %-ENOMEM	- Dynamic memory allocation failed. */int edac_ecs_get_desc(struct device *ecs_dev,		      const struct attribute_group **attr_groups, u16 num_media_frus){	if (!ecs_dev || !attr_groups || !num_media_frus)		return -EINVAL; 	return ecs_create_desc(ecs_dev, attr_groups, num_media_frus);}