ecs.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * The generic ECS driver is designed to support control of on-die error
  4 * check scrub (e.g., DDR5 ECS). The common sysfs ECS interface abstracts
  5 * the control of various ECS functionalities into a unified set of functions.
  6 *
  7 * Copyright (c) 2024-2025 HiSilicon Limited.
  8 */
  9
 10#include <linux/edac.h>
 11
 12#define EDAC_ECS_FRU_NAME "ecs_fru"
 13
 14enum edac_ecs_attributes {
 15	ECS_LOG_ENTRY_TYPE,
 16	ECS_MODE,
 17	ECS_RESET,
 18	ECS_THRESHOLD,
 19	ECS_MAX_ATTRS
 20};
 21
 22struct edac_ecs_dev_attr {
 23	struct device_attribute dev_attr;
 24	int fru_id;
 25};
 26
 27struct edac_ecs_fru_context {
 28	char name[EDAC_FEAT_NAME_LEN];
 29	struct edac_ecs_dev_attr dev_attr[ECS_MAX_ATTRS];
 30	struct attribute *ecs_attrs[ECS_MAX_ATTRS + 1];
 31	struct attribute_group group;
 32};
 33
 34struct edac_ecs_context {
 35	u16 num_media_frus;
 36	struct edac_ecs_fru_context *fru_ctxs;
 37};
 38
 39#define TO_ECS_DEV_ATTR(_dev_attr)	\
 40	container_of(_dev_attr, struct edac_ecs_dev_attr, dev_attr)
 41
 42#define EDAC_ECS_ATTR_SHOW(attrib, cb, type, format)				\
 43static ssize_t attrib##_show(struct device *ras_feat_dev,			\
 44			     struct device_attribute *attr, char *buf)		\
 45{										\
 46	struct edac_ecs_dev_attr *dev_attr = TO_ECS_DEV_ATTR(attr);		\
 47	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);		\
 48	const struct edac_ecs_ops *ops = ctx->ecs.ecs_ops;			\
 49	type data;								\
 50	int ret;								\
 51										\
 52	ret = ops->cb(ras_feat_dev->parent, ctx->ecs.private,			\
 53		      dev_attr->fru_id, &data);					\
 54	if (ret)								\
 55		return ret;							\
 56										\
 57	return sysfs_emit(buf, format, data);					\
 58}
 59
 60EDAC_ECS_ATTR_SHOW(log_entry_type, get_log_entry_type, u32, "%u\n")
 61EDAC_ECS_ATTR_SHOW(mode, get_mode, u32, "%u\n")
 62EDAC_ECS_ATTR_SHOW(threshold, get_threshold, u32, "%u\n")
 63
 64#define EDAC_ECS_ATTR_STORE(attrib, cb, type, conv_func)			\
 65static ssize_t attrib##_store(struct device *ras_feat_dev,			\
 66			      struct device_attribute *attr,			\
 67			      const char *buf, size_t len)			\
 68{										\
 69	struct edac_ecs_dev_attr *dev_attr = TO_ECS_DEV_ATTR(attr);		\
 70	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);		\
 71	const struct edac_ecs_ops *ops = ctx->ecs.ecs_ops;			\
 72	type data;								\
 73	int ret;								\
 74										\
 75	ret = conv_func(buf, 0, &data);						\
 76	if (ret < 0)								\
 77		return ret;							\
 78										\
 79	ret = ops->cb(ras_feat_dev->parent, ctx->ecs.private,			\
 80		      dev_attr->fru_id, data);					\
 81	if (ret)								\
 82		return ret;							\
 83										\
 84	return len;								\
 85}
 86
 87EDAC_ECS_ATTR_STORE(log_entry_type, set_log_entry_type, unsigned long, kstrtoul)
 88EDAC_ECS_ATTR_STORE(mode, set_mode, unsigned long, kstrtoul)
 89EDAC_ECS_ATTR_STORE(reset, reset, unsigned long, kstrtoul)
 90EDAC_ECS_ATTR_STORE(threshold, set_threshold, unsigned long, kstrtoul)
 91
 92static umode_t ecs_attr_visible(struct kobject *kobj, struct attribute *a, int attr_id)
 93{
 94	struct device *ras_feat_dev = kobj_to_dev(kobj);
 95	struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev);
 96	const struct edac_ecs_ops *ops = ctx->ecs.ecs_ops;
 97
 98	switch (attr_id) {
 99	case ECS_LOG_ENTRY_TYPE:
100		if (ops->get_log_entry_type)  {
101			if (ops->set_log_entry_type)
102				return a->mode;
103			else
104				return 0444;
105		}
106		break;
107	case ECS_MODE:
108		if (ops->get_mode) {
109			if (ops->set_mode)
110				return a->mode;
111			else
112				return 0444;
113		}
114		break;
115	case ECS_RESET:
116		if (ops->reset)
117			return a->mode;
118		break;
119	case ECS_THRESHOLD:
120		if (ops->get_threshold) {
121			if (ops->set_threshold)
122				return a->mode;
123			else
124				return 0444;
125		}
126		break;
127	default:
128		break;
129	}
130
131	return 0;
132}
133
134#define EDAC_ECS_ATTR_RO(_name, _fru_id)       \
135	((struct edac_ecs_dev_attr) { .dev_attr = __ATTR_RO(_name), \
136				     .fru_id = _fru_id })
137
138#define EDAC_ECS_ATTR_WO(_name, _fru_id)       \
139	((struct edac_ecs_dev_attr) { .dev_attr = __ATTR_WO(_name), \
140				     .fru_id = _fru_id })
141
142#define EDAC_ECS_ATTR_RW(_name, _fru_id)       \
143	((struct edac_ecs_dev_attr) { .dev_attr = __ATTR_RW(_name), \
144				     .fru_id = _fru_id })
145
146static int ecs_create_desc(struct device *ecs_dev, const struct attribute_group **attr_groups,
147			   u16 num_media_frus)
148{
149	struct edac_ecs_context *ecs_ctx;
150	u32 fru;
151
152	ecs_ctx = devm_kzalloc(ecs_dev, sizeof(*ecs_ctx), GFP_KERNEL);
153	if (!ecs_ctx)
154		return -ENOMEM;
155
156	ecs_ctx->num_media_frus = num_media_frus;
157	ecs_ctx->fru_ctxs = devm_kcalloc(ecs_dev, num_media_frus,
158					 sizeof(*ecs_ctx->fru_ctxs),
159					 GFP_KERNEL);
160	if (!ecs_ctx->fru_ctxs)
161		return -ENOMEM;
162
163	for (fru = 0; fru < num_media_frus; fru++) {
164		struct edac_ecs_fru_context *fru_ctx = &ecs_ctx->fru_ctxs[fru];
165		struct attribute_group *group = &fru_ctx->group;
166		int i;
167
168		fru_ctx->dev_attr[ECS_LOG_ENTRY_TYPE]	= EDAC_ECS_ATTR_RW(log_entry_type, fru);
169		fru_ctx->dev_attr[ECS_MODE]		= EDAC_ECS_ATTR_RW(mode, fru);
170		fru_ctx->dev_attr[ECS_RESET]		= EDAC_ECS_ATTR_WO(reset, fru);
171		fru_ctx->dev_attr[ECS_THRESHOLD]	= EDAC_ECS_ATTR_RW(threshold, fru);
172
173		for (i = 0; i < ECS_MAX_ATTRS; i++) {
174			sysfs_attr_init(&fru_ctx->dev_attr[i].dev_attr.attr);
175			fru_ctx->ecs_attrs[i] = &fru_ctx->dev_attr[i].dev_attr.attr;
176		}
177
178		sprintf(fru_ctx->name, "%s%d", EDAC_ECS_FRU_NAME, fru);
179		group->name = fru_ctx->name;
180		group->attrs = fru_ctx->ecs_attrs;
181		group->is_visible  = ecs_attr_visible;
182
183		attr_groups[fru] = group;
184	}
185
186	return 0;
187}
188
189/**
190 * edac_ecs_get_desc - get EDAC ECS descriptors
191 * @ecs_dev: client device, supports ECS feature
192 * @attr_groups: pointer to attribute group container
193 * @num_media_frus: number of media FRUs in the device
194 *
195 * Return:
196 *  * %0	- Success.
197 *  * %-EINVAL	- Invalid parameters passed.
198 *  * %-ENOMEM	- Dynamic memory allocation failed.
199 */
200int edac_ecs_get_desc(struct device *ecs_dev,
201		      const struct attribute_group **attr_groups, u16 num_media_frus)
202{
203	if (!ecs_dev || !attr_groups || !num_media_frus)
204		return -EINVAL;
205
206	return ecs_create_desc(ecs_dev, attr_groups, num_media_frus);
207}