// SPDX-License-Identifier: GPL-2.0/* * The generic EDAC scrub driver controls the memory scrubbers in the * system. The common sysfs scrub interface abstracts the control of * various arbitrary scrubbing functionalities into a unified set of * functions. * * Copyright (c) 2024-2025 HiSilicon Limited. */ #include <linux/edac.h> enum edac_scrub_attributes {	SCRUB_ADDRESS,	SCRUB_SIZE,	SCRUB_ENABLE_BACKGROUND,	SCRUB_MIN_CYCLE_DURATION,	SCRUB_MAX_CYCLE_DURATION,	SCRUB_CUR_CYCLE_DURATION,	SCRUB_MAX_ATTRS}; struct edac_scrub_dev_attr {	struct device_attribute dev_attr;	u8 instance;}; struct edac_scrub_context {	char name[EDAC_FEAT_NAME_LEN];	struct edac_scrub_dev_attr scrub_dev_attr[SCRUB_MAX_ATTRS];	struct attribute *scrub_attrs[SCRUB_MAX_ATTRS + 1];	struct attribute_group group;}; #define TO_SCRUB_DEV_ATTR(_dev_attr)      \		container_of(_dev_attr, struct edac_scrub_dev_attr, dev_attr) #define EDAC_SCRUB_ATTR_SHOW(attrib, cb, type, format)				\static ssize_t attrib##_show(struct device *ras_feat_dev,			\			     struct device_attribute *attr, char *buf)		\{										\	u8 inst = TO_SCRUB_DEV_ATTR(attr)->instance;				\	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);		\	const struct edac_scrub_ops *ops = ctx->scrub[inst].scrub_ops;		\	type data;								\	int ret;								\										\	ret = ops->cb(ras_feat_dev->parent, ctx->scrub[inst].private, &data);	\	if (ret)								\		return ret;							\										\	return sysfs_emit(buf, format, data);					\} EDAC_SCRUB_ATTR_SHOW(addr, read_addr, u64, "0x%llx\n")EDAC_SCRUB_ATTR_SHOW(size, read_size, u64, "0x%llx\n")EDAC_SCRUB_ATTR_SHOW(enable_background, get_enabled_bg, bool, "%u\n")EDAC_SCRUB_ATTR_SHOW(min_cycle_duration, get_min_cycle, u32, "%u\n")EDAC_SCRUB_ATTR_SHOW(max_cycle_duration, get_max_cycle, u32, "%u\n")EDAC_SCRUB_ATTR_SHOW(current_cycle_duration, get_cycle_duration, u32, "%u\n") #define EDAC_SCRUB_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)			\{										\	u8 inst = TO_SCRUB_DEV_ATTR(attr)->instance;				\	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);		\	const struct edac_scrub_ops *ops = ctx->scrub[inst].scrub_ops;		\	type data;								\	int ret;								\										\	ret = conv_func(buf, 0, &data);						\	if (ret < 0)								\		return ret;							\										\	ret = ops->cb(ras_feat_dev->parent, ctx->scrub[inst].private, data);	\	if (ret)								\		return ret;							\										\	return len;								\} EDAC_SCRUB_ATTR_STORE(addr, write_addr, u64, kstrtou64)EDAC_SCRUB_ATTR_STORE(size, write_size, u64, kstrtou64)EDAC_SCRUB_ATTR_STORE(enable_background, set_enabled_bg, unsigned long, kstrtoul)EDAC_SCRUB_ATTR_STORE(current_cycle_duration, set_cycle_duration, unsigned long, kstrtoul) static umode_t scrub_attr_visible(struct kobject *kobj, struct attribute *a, int attr_id){	struct device *ras_feat_dev = kobj_to_dev(kobj);	struct device_attribute *dev_attr = container_of(a, struct device_attribute, attr);	u8 inst = TO_SCRUB_DEV_ATTR(dev_attr)->instance;	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);	const struct edac_scrub_ops *ops = ctx->scrub[inst].scrub_ops; 	switch (attr_id) {	case SCRUB_ADDRESS:		if (ops->read_addr) {			if (ops->write_addr)				return a->mode;			else				return 0444;		}		break;	case SCRUB_SIZE:		if (ops->read_size) {			if (ops->write_size)				return a->mode;			else				return 0444;		}		break;	case SCRUB_ENABLE_BACKGROUND:		if (ops->get_enabled_bg) {			if (ops->set_enabled_bg)				return a->mode;			else				return 0444;		}		break;	case SCRUB_MIN_CYCLE_DURATION:		if (ops->get_min_cycle)			return a->mode;		break;	case SCRUB_MAX_CYCLE_DURATION:		if (ops->get_max_cycle)			return a->mode;		break;	case SCRUB_CUR_CYCLE_DURATION:		if (ops->get_cycle_duration) {			if (ops->set_cycle_duration)				return a->mode;			else				return 0444;		}		break;	default:		break;	} 	return 0;} #define EDAC_SCRUB_ATTR_RO(_name, _instance)       \	((struct edac_scrub_dev_attr) { .dev_attr = __ATTR_RO(_name), \					.instance = _instance }) #define EDAC_SCRUB_ATTR_WO(_name, _instance)       \	((struct edac_scrub_dev_attr) { .dev_attr = __ATTR_WO(_name), \					.instance = _instance }) #define EDAC_SCRUB_ATTR_RW(_name, _instance)       \	((struct edac_scrub_dev_attr) { .dev_attr = __ATTR_RW(_name), \					.instance = _instance }) static int scrub_create_desc(struct device *scrub_dev,			     const struct attribute_group **attr_groups, u8 instance){	struct edac_scrub_context *scrub_ctx;	struct attribute_group *group;	int i;	struct edac_scrub_dev_attr dev_attr[] = {		[SCRUB_ADDRESS] = EDAC_SCRUB_ATTR_RW(addr, instance),		[SCRUB_SIZE] = EDAC_SCRUB_ATTR_RW(size, instance),		[SCRUB_ENABLE_BACKGROUND] = EDAC_SCRUB_ATTR_RW(enable_background, instance),		[SCRUB_MIN_CYCLE_DURATION] = EDAC_SCRUB_ATTR_RO(min_cycle_duration, instance),		[SCRUB_MAX_CYCLE_DURATION] = EDAC_SCRUB_ATTR_RO(max_cycle_duration, instance),		[SCRUB_CUR_CYCLE_DURATION] = EDAC_SCRUB_ATTR_RW(current_cycle_duration, instance)	}; 	scrub_ctx = devm_kzalloc(scrub_dev, sizeof(*scrub_ctx), GFP_KERNEL);	if (!scrub_ctx)		return -ENOMEM; 	group = &scrub_ctx->group;	for (i = 0; i < SCRUB_MAX_ATTRS; i++) {		memcpy(&scrub_ctx->scrub_dev_attr[i], &dev_attr[i], sizeof(dev_attr[i]));		sysfs_attr_init(&scrub_ctx->scrub_dev_attr[i].dev_attr.attr);		scrub_ctx->scrub_attrs[i] = &scrub_ctx->scrub_dev_attr[i].dev_attr.attr;	}	sprintf(scrub_ctx->name, "%s%d", "scrub", instance);	group->name = scrub_ctx->name;	group->attrs = scrub_ctx->scrub_attrs;	group->is_visible  = scrub_attr_visible; 	attr_groups[0] = group; 	return 0;} /** * edac_scrub_get_desc - get EDAC scrub descriptors * @scrub_dev: client device, with scrub support * @attr_groups: pointer to attribute group container * @instance: device's scrub instance number. * * Return: *  * %0	- Success. *  * %-EINVAL	- Invalid parameters passed. *  * %-ENOMEM	- Dynamic memory allocation failed. */int edac_scrub_get_desc(struct device *scrub_dev,			const struct attribute_group **attr_groups, u8 instance){	if (!scrub_dev || !attr_groups)		return -EINVAL; 	return scrub_create_desc(scrub_dev, attr_groups, instance);}