1// SPDX-License-Identifier: GPL-2.0
2/*
3 * The generic EDAC scrub driver controls the memory scrubbers in the
4 * system. The common sysfs scrub interface abstracts the control of
5 * various arbitrary scrubbing functionalities into a unified set of
6 * functions.
7 *
8 * Copyright (c) 2024-2025 HiSilicon Limited.
9 */
10
11#include <linux/edac.h>
12
13enum edac_scrub_attributes {
14 SCRUB_ADDRESS,
15 SCRUB_SIZE,
16 SCRUB_ENABLE_BACKGROUND,
17 SCRUB_MIN_CYCLE_DURATION,
18 SCRUB_MAX_CYCLE_DURATION,
19 SCRUB_CUR_CYCLE_DURATION,
20 SCRUB_MAX_ATTRS
21};
22
23struct edac_scrub_dev_attr {
24 struct device_attribute dev_attr;
25 u8 instance;
26};
27
28struct edac_scrub_context {
29 char name[EDAC_FEAT_NAME_LEN];
30 struct edac_scrub_dev_attr scrub_dev_attr[SCRUB_MAX_ATTRS];
31 struct attribute *scrub_attrs[SCRUB_MAX_ATTRS + 1];
32 struct attribute_group group;
33};
34
35#define TO_SCRUB_DEV_ATTR(_dev_attr) \
36 container_of(_dev_attr, struct edac_scrub_dev_attr, dev_attr)
37
38#define EDAC_SCRUB_ATTR_SHOW(attrib, cb, type, format) \
39static ssize_t attrib##_show(struct device *ras_feat_dev, \
40 struct device_attribute *attr, char *buf) \
41{ \
42 u8 inst = TO_SCRUB_DEV_ATTR(attr)->instance; \
43 struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev); \
44 const struct edac_scrub_ops *ops = ctx->scrub[inst].scrub_ops; \
45 type data; \
46 int ret; \
47 \
48 ret = ops->cb(ras_feat_dev->parent, ctx->scrub[inst].private, &data); \
49 if (ret) \
50 return ret; \
51 \
52 return sysfs_emit(buf, format, data); \
53}
54
55EDAC_SCRUB_ATTR_SHOW(addr, read_addr, u64, "0x%llx\n")
56EDAC_SCRUB_ATTR_SHOW(size, read_size, u64, "0x%llx\n")
57EDAC_SCRUB_ATTR_SHOW(enable_background, get_enabled_bg, bool, "%u\n")
58EDAC_SCRUB_ATTR_SHOW(min_cycle_duration, get_min_cycle, u32, "%u\n")
59EDAC_SCRUB_ATTR_SHOW(max_cycle_duration, get_max_cycle, u32, "%u\n")
60EDAC_SCRUB_ATTR_SHOW(current_cycle_duration, get_cycle_duration, u32, "%u\n")
61
62#define EDAC_SCRUB_ATTR_STORE(attrib, cb, type, conv_func) \
63static ssize_t attrib##_store(struct device *ras_feat_dev, \
64 struct device_attribute *attr, \
65 const char *buf, size_t len) \
66{ \
67 u8 inst = TO_SCRUB_DEV_ATTR(attr)->instance; \
68 struct edac_dev_feat_ctx *ctx = dev_get_drvdata(ras_feat_dev); \
69 const struct edac_scrub_ops *ops = ctx->scrub[inst].scrub_ops; \
70 type data; \
71 int ret; \
72 \
73 ret = conv_func(buf, 0, &data); \
74 if (ret < 0) \
75 return ret; \
76 \
77 ret = ops->cb(ras_feat_dev->parent, ctx->scrub[inst].private, data); \
78 if (ret) \
79 return ret; \
80 \
81 return len; \
82}
83
84EDAC_SCRUB_ATTR_STORE(addr, write_addr, u64, kstrtou64)
85EDAC_SCRUB_ATTR_STORE(size, write_size, u64, kstrtou64)
86EDAC_SCRUB_ATTR_STORE(enable_background, set_enabled_bg, unsigned long, kstrtoul)
87EDAC_SCRUB_ATTR_STORE(current_cycle_duration, set_cycle_duration, unsigned long, kstrtoul)
88
89static umode_t scrub_attr_visible(struct kobject *kobj, struct attribute *a, int attr_id)
90{
91 struct device *ras_feat_dev = kobj_to_dev(kobj);
92 struct device_attribute *dev_attr = container_of(a, struct device_attribute, attr);
93 u8 inst = TO_SCRUB_DEV_ATTR(dev_attr)->instance;
94 struct edac_dev_feat_ctx *ctx = dev_get_drvdata(dev: ras_feat_dev);
95 const struct edac_scrub_ops *ops = ctx->scrub[inst].scrub_ops;
96
97 switch (attr_id) {
98 case SCRUB_ADDRESS:
99 if (ops->read_addr) {
100 if (ops->write_addr)
101 return a->mode;
102 else
103 return 0444;
104 }
105 break;
106 case SCRUB_SIZE:
107 if (ops->read_size) {
108 if (ops->write_size)
109 return a->mode;
110 else
111 return 0444;
112 }
113 break;
114 case SCRUB_ENABLE_BACKGROUND:
115 if (ops->get_enabled_bg) {
116 if (ops->set_enabled_bg)
117 return a->mode;
118 else
119 return 0444;
120 }
121 break;
122 case SCRUB_MIN_CYCLE_DURATION:
123 if (ops->get_min_cycle)
124 return a->mode;
125 break;
126 case SCRUB_MAX_CYCLE_DURATION:
127 if (ops->get_max_cycle)
128 return a->mode;
129 break;
130 case SCRUB_CUR_CYCLE_DURATION:
131 if (ops->get_cycle_duration) {
132 if (ops->set_cycle_duration)
133 return a->mode;
134 else
135 return 0444;
136 }
137 break;
138 default:
139 break;
140 }
141
142 return 0;
143}
144
145#define EDAC_SCRUB_ATTR_RO(_name, _instance) \
146 ((struct edac_scrub_dev_attr) { .dev_attr = __ATTR_RO(_name), \
147 .instance = _instance })
148
149#define EDAC_SCRUB_ATTR_WO(_name, _instance) \
150 ((struct edac_scrub_dev_attr) { .dev_attr = __ATTR_WO(_name), \
151 .instance = _instance })
152
153#define EDAC_SCRUB_ATTR_RW(_name, _instance) \
154 ((struct edac_scrub_dev_attr) { .dev_attr = __ATTR_RW(_name), \
155 .instance = _instance })
156
157static int scrub_create_desc(struct device *scrub_dev,
158 const struct attribute_group **attr_groups, u8 instance)
159{
160 struct edac_scrub_context *scrub_ctx;
161 struct attribute_group *group;
162 int i;
163 struct edac_scrub_dev_attr dev_attr[] = {
164 [SCRUB_ADDRESS] = EDAC_SCRUB_ATTR_RW(addr, instance),
165 [SCRUB_SIZE] = EDAC_SCRUB_ATTR_RW(size, instance),
166 [SCRUB_ENABLE_BACKGROUND] = EDAC_SCRUB_ATTR_RW(enable_background, instance),
167 [SCRUB_MIN_CYCLE_DURATION] = EDAC_SCRUB_ATTR_RO(min_cycle_duration, instance),
168 [SCRUB_MAX_CYCLE_DURATION] = EDAC_SCRUB_ATTR_RO(max_cycle_duration, instance),
169 [SCRUB_CUR_CYCLE_DURATION] = EDAC_SCRUB_ATTR_RW(current_cycle_duration, instance)
170 };
171
172 scrub_ctx = devm_kzalloc(dev: scrub_dev, size: sizeof(*scrub_ctx), GFP_KERNEL);
173 if (!scrub_ctx)
174 return -ENOMEM;
175
176 group = &scrub_ctx->group;
177 for (i = 0; i < SCRUB_MAX_ATTRS; i++) {
178 memcpy(&scrub_ctx->scrub_dev_attr[i], &dev_attr[i], sizeof(dev_attr[i]));
179 sysfs_attr_init(&scrub_ctx->scrub_dev_attr[i].dev_attr.attr);
180 scrub_ctx->scrub_attrs[i] = &scrub_ctx->scrub_dev_attr[i].dev_attr.attr;
181 }
182 sprintf(buf: scrub_ctx->name, fmt: "%s%d", "scrub", instance);
183 group->name = scrub_ctx->name;
184 group->attrs = scrub_ctx->scrub_attrs;
185 group->is_visible = scrub_attr_visible;
186
187 attr_groups[0] = group;
188
189 return 0;
190}
191
192/**
193 * edac_scrub_get_desc - get EDAC scrub descriptors
194 * @scrub_dev: client device, with scrub support
195 * @attr_groups: pointer to attribute group container
196 * @instance: device's scrub instance number.
197 *
198 * Return:
199 * * %0 - Success.
200 * * %-EINVAL - Invalid parameters passed.
201 * * %-ENOMEM - Dynamic memory allocation failed.
202 */
203int edac_scrub_get_desc(struct device *scrub_dev,
204 const struct attribute_group **attr_groups, u8 instance)
205{
206 if (!scrub_dev || !attr_groups)
207 return -EINVAL;
208
209 return scrub_create_desc(scrub_dev, attr_groups, instance);
210}
211

source code of linux/drivers/edac/scrub.c