]>
Commit | Line | Data |
---|---|---|
7c9281d7 DT |
1 | /* |
2 | * edac_mc kernel module | |
42a8e397 DT |
3 | * (C) 2005-2007 Linux Networx (http://lnxi.com) |
4 | * | |
7c9281d7 DT |
5 | * This file may be distributed under the terms of the |
6 | * GNU General Public License. | |
7 | * | |
42a8e397 | 8 | * Written Doug Thompson <norsk5@xmission.com> www.softwarebitmaker.com |
7c9281d7 DT |
9 | * |
10 | */ | |
11 | ||
7c9281d7 DT |
12 | #include <linux/ctype.h> |
13 | ||
20bcb7a8 | 14 | #include "edac_core.h" |
7c9281d7 DT |
15 | #include "edac_module.h" |
16 | ||
17 | /* MC EDAC Controls, setable by module parameter, and sysfs */ | |
4de78c68 DJ |
18 | static int edac_mc_log_ue = 1; |
19 | static int edac_mc_log_ce = 1; | |
20 | static int edac_mc_panic_on_ue = 0; | |
21 | static int edac_mc_poll_msec = 1000; | |
7c9281d7 DT |
22 | |
23 | /* Getter functions for above */ | |
4de78c68 | 24 | int edac_mc_get_log_ue(void) |
7c9281d7 | 25 | { |
4de78c68 | 26 | return edac_mc_log_ue; |
7c9281d7 DT |
27 | } |
28 | ||
4de78c68 | 29 | int edac_mc_get_log_ce(void) |
7c9281d7 | 30 | { |
4de78c68 | 31 | return edac_mc_log_ce; |
7c9281d7 DT |
32 | } |
33 | ||
4de78c68 | 34 | int edac_mc_get_panic_on_ue(void) |
7c9281d7 | 35 | { |
4de78c68 | 36 | return edac_mc_panic_on_ue; |
7c9281d7 DT |
37 | } |
38 | ||
81d87cb1 DJ |
39 | /* this is temporary */ |
40 | int edac_mc_get_poll_msec(void) | |
41 | { | |
4de78c68 | 42 | return edac_mc_poll_msec; |
7c9281d7 DT |
43 | } |
44 | ||
45 | /* Parameter declarations for above */ | |
4de78c68 DJ |
46 | module_param(edac_mc_panic_on_ue, int, 0644); |
47 | MODULE_PARM_DESC(edac_mc_panic_on_ue, "Panic on uncorrected error: 0=off 1=on"); | |
48 | module_param(edac_mc_log_ue, int, 0644); | |
49 | MODULE_PARM_DESC(edac_mc_log_ue, | |
079708b9 | 50 | "Log uncorrectable error to console: 0=off 1=on"); |
4de78c68 DJ |
51 | module_param(edac_mc_log_ce, int, 0644); |
52 | MODULE_PARM_DESC(edac_mc_log_ce, | |
079708b9 | 53 | "Log correctable error to console: 0=off 1=on"); |
4de78c68 DJ |
54 | module_param(edac_mc_poll_msec, int, 0644); |
55 | MODULE_PARM_DESC(edac_mc_poll_msec, "Polling period in milliseconds"); | |
7c9281d7 | 56 | |
7c9281d7 DT |
57 | /* |
58 | * various constants for Memory Controllers | |
59 | */ | |
60 | static const char *mem_types[] = { | |
61 | [MEM_EMPTY] = "Empty", | |
62 | [MEM_RESERVED] = "Reserved", | |
63 | [MEM_UNKNOWN] = "Unknown", | |
64 | [MEM_FPM] = "FPM", | |
65 | [MEM_EDO] = "EDO", | |
66 | [MEM_BEDO] = "BEDO", | |
67 | [MEM_SDR] = "Unbuffered-SDR", | |
68 | [MEM_RDR] = "Registered-SDR", | |
69 | [MEM_DDR] = "Unbuffered-DDR", | |
70 | [MEM_RDDR] = "Registered-DDR", | |
1a9b85e6 DJ |
71 | [MEM_RMBS] = "RMBS", |
72 | [MEM_DDR2] = "Unbuffered-DDR2", | |
73 | [MEM_FB_DDR2] = "FullyBuffered-DDR2", | |
74 | [MEM_RDDR2] = "Registered-DDR2" | |
7c9281d7 DT |
75 | }; |
76 | ||
77 | static const char *dev_types[] = { | |
78 | [DEV_UNKNOWN] = "Unknown", | |
79 | [DEV_X1] = "x1", | |
80 | [DEV_X2] = "x2", | |
81 | [DEV_X4] = "x4", | |
82 | [DEV_X8] = "x8", | |
83 | [DEV_X16] = "x16", | |
84 | [DEV_X32] = "x32", | |
85 | [DEV_X64] = "x64" | |
86 | }; | |
87 | ||
88 | static const char *edac_caps[] = { | |
89 | [EDAC_UNKNOWN] = "Unknown", | |
90 | [EDAC_NONE] = "None", | |
91 | [EDAC_RESERVED] = "Reserved", | |
92 | [EDAC_PARITY] = "PARITY", | |
93 | [EDAC_EC] = "EC", | |
94 | [EDAC_SECDED] = "SECDED", | |
95 | [EDAC_S2ECD2ED] = "S2ECD2ED", | |
96 | [EDAC_S4ECD4ED] = "S4ECD4ED", | |
97 | [EDAC_S8ECD8ED] = "S8ECD8ED", | |
98 | [EDAC_S16ECD16ED] = "S16ECD16ED" | |
99 | }; | |
100 | ||
7c9281d7 DT |
101 | /* sysfs object: |
102 | * /sys/devices/system/edac/mc | |
103 | */ | |
104 | static struct kobject edac_memctrl_kobj; | |
105 | ||
106 | /* We use these to wait for the reference counts on edac_memctrl_kobj and | |
107 | * edac_pci_kobj to reach 0. | |
108 | */ | |
109 | static struct completion edac_memctrl_kobj_complete; | |
110 | ||
111 | /* | |
112 | * /sys/devices/system/edac/mc; | |
113 | * data structures and methods | |
114 | */ | |
115 | static ssize_t memctrl_int_show(void *ptr, char *buffer) | |
116 | { | |
079708b9 | 117 | int *value = (int *)ptr; |
7c9281d7 DT |
118 | return sprintf(buffer, "%u\n", *value); |
119 | } | |
120 | ||
121 | static ssize_t memctrl_int_store(void *ptr, const char *buffer, size_t count) | |
122 | { | |
079708b9 | 123 | int *value = (int *)ptr; |
7c9281d7 DT |
124 | |
125 | if (isdigit(*buffer)) | |
126 | *value = simple_strtoul(buffer, NULL, 0); | |
127 | ||
128 | return count; | |
129 | } | |
130 | ||
131 | struct memctrl_dev_attribute { | |
132 | struct attribute attr; | |
133 | void *value; | |
079708b9 DT |
134 | ssize_t(*show) (void *, char *); |
135 | ssize_t(*store) (void *, const char *, size_t); | |
7c9281d7 DT |
136 | }; |
137 | ||
138 | /* Set of show/store abstract level functions for memory control object */ | |
139 | static ssize_t memctrl_dev_show(struct kobject *kobj, | |
079708b9 | 140 | struct attribute *attr, char *buffer) |
7c9281d7 DT |
141 | { |
142 | struct memctrl_dev_attribute *memctrl_dev; | |
079708b9 | 143 | memctrl_dev = (struct memctrl_dev_attribute *)attr; |
7c9281d7 DT |
144 | |
145 | if (memctrl_dev->show) | |
146 | return memctrl_dev->show(memctrl_dev->value, buffer); | |
147 | ||
148 | return -EIO; | |
149 | } | |
150 | ||
151 | static ssize_t memctrl_dev_store(struct kobject *kobj, struct attribute *attr, | |
079708b9 | 152 | const char *buffer, size_t count) |
7c9281d7 DT |
153 | { |
154 | struct memctrl_dev_attribute *memctrl_dev; | |
079708b9 | 155 | memctrl_dev = (struct memctrl_dev_attribute *)attr; |
7c9281d7 DT |
156 | |
157 | if (memctrl_dev->store) | |
158 | return memctrl_dev->store(memctrl_dev->value, buffer, count); | |
159 | ||
160 | return -EIO; | |
161 | } | |
162 | ||
163 | static struct sysfs_ops memctrlfs_ops = { | |
079708b9 DT |
164 | .show = memctrl_dev_show, |
165 | .store = memctrl_dev_store | |
7c9281d7 DT |
166 | }; |
167 | ||
168 | #define MEMCTRL_ATTR(_name,_mode,_show,_store) \ | |
169 | static struct memctrl_dev_attribute attr_##_name = { \ | |
170 | .attr = {.name = __stringify(_name), .mode = _mode }, \ | |
171 | .value = &_name, \ | |
172 | .show = _show, \ | |
173 | .store = _store, \ | |
174 | }; | |
175 | ||
176 | #define MEMCTRL_STRING_ATTR(_name,_data,_mode,_show,_store) \ | |
177 | static struct memctrl_dev_attribute attr_##_name = { \ | |
178 | .attr = {.name = __stringify(_name), .mode = _mode }, \ | |
179 | .value = _data, \ | |
180 | .show = _show, \ | |
181 | .store = _store, \ | |
182 | }; | |
183 | ||
184 | /* csrow<id> control files */ | |
4de78c68 | 185 | MEMCTRL_ATTR(edac_mc_panic_on_ue, |
052dfb45 | 186 | S_IRUGO | S_IWUSR, memctrl_int_show, memctrl_int_store); |
4de78c68 DJ |
187 | |
188 | MEMCTRL_ATTR(edac_mc_log_ue, | |
052dfb45 | 189 | S_IRUGO | S_IWUSR, memctrl_int_show, memctrl_int_store); |
4de78c68 DJ |
190 | |
191 | MEMCTRL_ATTR(edac_mc_log_ce, | |
052dfb45 | 192 | S_IRUGO | S_IWUSR, memctrl_int_show, memctrl_int_store); |
4de78c68 DJ |
193 | |
194 | MEMCTRL_ATTR(edac_mc_poll_msec, | |
052dfb45 | 195 | S_IRUGO | S_IWUSR, memctrl_int_show, memctrl_int_store); |
7c9281d7 DT |
196 | |
197 | /* Base Attributes of the memory ECC object */ | |
198 | static struct memctrl_dev_attribute *memctrl_attr[] = { | |
4de78c68 DJ |
199 | &attr_edac_mc_panic_on_ue, |
200 | &attr_edac_mc_log_ue, | |
201 | &attr_edac_mc_log_ce, | |
202 | &attr_edac_mc_poll_msec, | |
7c9281d7 DT |
203 | NULL, |
204 | }; | |
205 | ||
206 | /* Main MC kobject release() function */ | |
207 | static void edac_memctrl_master_release(struct kobject *kobj) | |
208 | { | |
209 | debugf1("%s()\n", __func__); | |
210 | complete(&edac_memctrl_kobj_complete); | |
211 | } | |
212 | ||
213 | static struct kobj_type ktype_memctrl = { | |
214 | .release = edac_memctrl_master_release, | |
215 | .sysfs_ops = &memctrlfs_ops, | |
079708b9 | 216 | .default_attrs = (struct attribute **)memctrl_attr, |
7c9281d7 DT |
217 | }; |
218 | ||
219 | /* Initialize the main sysfs entries for edac: | |
220 | * /sys/devices/system/edac | |
221 | * | |
222 | * and children | |
223 | * | |
224 | * Return: 0 SUCCESS | |
225 | * !0 FAILURE | |
226 | */ | |
227 | int edac_sysfs_memctrl_setup(void) | |
228 | { | |
229 | int err = 0; | |
e27e3dac | 230 | struct sysdev_class *edac_class; |
7c9281d7 DT |
231 | |
232 | debugf1("%s()\n", __func__); | |
233 | ||
e27e3dac DT |
234 | /* get the /sys/devices/system/edac class reference */ |
235 | edac_class = edac_get_edac_class(); | |
236 | if (edac_class == NULL) { | |
237 | debugf1("%s() no edac_class error=%d\n", __func__, err); | |
7c9281d7 DT |
238 | return err; |
239 | } | |
240 | ||
241 | /* Init the MC's kobject */ | |
079708b9 | 242 | memset(&edac_memctrl_kobj, 0, sizeof(edac_memctrl_kobj)); |
e27e3dac | 243 | edac_memctrl_kobj.parent = &edac_class->kset.kobj; |
7c9281d7 DT |
244 | edac_memctrl_kobj.ktype = &ktype_memctrl; |
245 | ||
246 | /* generate sysfs "..../edac/mc" */ | |
079708b9 | 247 | err = kobject_set_name(&edac_memctrl_kobj, "mc"); |
e27e3dac | 248 | if (err) { |
079708b9 | 249 | debugf1("%s() Failed to set name '.../edac/mc'\n", __func__); |
e27e3dac DT |
250 | return err; |
251 | } | |
7c9281d7 DT |
252 | |
253 | /* FIXME: maybe new sysdev_create_subdir() */ | |
254 | err = kobject_register(&edac_memctrl_kobj); | |
7c9281d7 | 255 | if (err) { |
079708b9 | 256 | debugf1("%s() Failed to register '.../edac/mc'\n", __func__); |
e27e3dac | 257 | return err; |
7c9281d7 DT |
258 | } |
259 | ||
079708b9 | 260 | debugf1("%s() Registered '.../edac/mc' kobject\n", __func__); |
7c9281d7 | 261 | return 0; |
7c9281d7 DT |
262 | } |
263 | ||
264 | /* | |
265 | * MC teardown: | |
266 | * the '..../edac/mc' kobject followed by '..../edac' itself | |
267 | */ | |
268 | void edac_sysfs_memctrl_teardown(void) | |
269 | { | |
270 | debugf0("MC: " __FILE__ ": %s()\n", __func__); | |
271 | ||
272 | /* Unregister the MC's kobject and wait for reference count to reach 0. | |
273 | */ | |
274 | init_completion(&edac_memctrl_kobj_complete); | |
275 | kobject_unregister(&edac_memctrl_kobj); | |
276 | wait_for_completion(&edac_memctrl_kobj_complete); | |
7c9281d7 DT |
277 | } |
278 | ||
7c9281d7 DT |
279 | /* EDAC sysfs CSROW data structures and methods |
280 | */ | |
281 | ||
282 | /* Set of more default csrow<id> attribute show/store functions */ | |
e27e3dac | 283 | static ssize_t csrow_ue_count_show(struct csrow_info *csrow, char *data, |
052dfb45 | 284 | int private) |
7c9281d7 | 285 | { |
079708b9 | 286 | return sprintf(data, "%u\n", csrow->ue_count); |
7c9281d7 DT |
287 | } |
288 | ||
e27e3dac | 289 | static ssize_t csrow_ce_count_show(struct csrow_info *csrow, char *data, |
052dfb45 | 290 | int private) |
7c9281d7 | 291 | { |
079708b9 | 292 | return sprintf(data, "%u\n", csrow->ce_count); |
7c9281d7 DT |
293 | } |
294 | ||
e27e3dac | 295 | static ssize_t csrow_size_show(struct csrow_info *csrow, char *data, |
052dfb45 | 296 | int private) |
7c9281d7 | 297 | { |
079708b9 | 298 | return sprintf(data, "%u\n", PAGES_TO_MiB(csrow->nr_pages)); |
7c9281d7 DT |
299 | } |
300 | ||
e27e3dac | 301 | static ssize_t csrow_mem_type_show(struct csrow_info *csrow, char *data, |
052dfb45 | 302 | int private) |
7c9281d7 | 303 | { |
079708b9 | 304 | return sprintf(data, "%s\n", mem_types[csrow->mtype]); |
7c9281d7 DT |
305 | } |
306 | ||
e27e3dac | 307 | static ssize_t csrow_dev_type_show(struct csrow_info *csrow, char *data, |
052dfb45 | 308 | int private) |
7c9281d7 | 309 | { |
079708b9 | 310 | return sprintf(data, "%s\n", dev_types[csrow->dtype]); |
7c9281d7 DT |
311 | } |
312 | ||
e27e3dac | 313 | static ssize_t csrow_edac_mode_show(struct csrow_info *csrow, char *data, |
052dfb45 | 314 | int private) |
7c9281d7 | 315 | { |
079708b9 | 316 | return sprintf(data, "%s\n", edac_caps[csrow->edac_mode]); |
7c9281d7 DT |
317 | } |
318 | ||
319 | /* show/store functions for DIMM Label attributes */ | |
320 | static ssize_t channel_dimm_label_show(struct csrow_info *csrow, | |
052dfb45 | 321 | char *data, int channel) |
7c9281d7 | 322 | { |
079708b9 | 323 | return snprintf(data, EDAC_MC_LABEL_LEN, "%s", |
7c9281d7 DT |
324 | csrow->channels[channel].label); |
325 | } | |
326 | ||
327 | static ssize_t channel_dimm_label_store(struct csrow_info *csrow, | |
079708b9 DT |
328 | const char *data, |
329 | size_t count, int channel) | |
7c9281d7 DT |
330 | { |
331 | ssize_t max_size = 0; | |
332 | ||
079708b9 | 333 | max_size = min((ssize_t) count, (ssize_t) EDAC_MC_LABEL_LEN - 1); |
7c9281d7 DT |
334 | strncpy(csrow->channels[channel].label, data, max_size); |
335 | csrow->channels[channel].label[max_size] = '\0'; | |
336 | ||
337 | return max_size; | |
338 | } | |
339 | ||
340 | /* show function for dynamic chX_ce_count attribute */ | |
341 | static ssize_t channel_ce_count_show(struct csrow_info *csrow, | |
052dfb45 | 342 | char *data, int channel) |
7c9281d7 DT |
343 | { |
344 | return sprintf(data, "%u\n", csrow->channels[channel].ce_count); | |
345 | } | |
346 | ||
347 | /* csrow specific attribute structure */ | |
348 | struct csrowdev_attribute { | |
349 | struct attribute attr; | |
079708b9 DT |
350 | ssize_t(*show) (struct csrow_info *, char *, int); |
351 | ssize_t(*store) (struct csrow_info *, const char *, size_t, int); | |
352 | int private; | |
7c9281d7 DT |
353 | }; |
354 | ||
355 | #define to_csrow(k) container_of(k, struct csrow_info, kobj) | |
356 | #define to_csrowdev_attr(a) container_of(a, struct csrowdev_attribute, attr) | |
357 | ||
358 | /* Set of show/store higher level functions for default csrow attributes */ | |
359 | static ssize_t csrowdev_show(struct kobject *kobj, | |
052dfb45 | 360 | struct attribute *attr, char *buffer) |
7c9281d7 DT |
361 | { |
362 | struct csrow_info *csrow = to_csrow(kobj); | |
363 | struct csrowdev_attribute *csrowdev_attr = to_csrowdev_attr(attr); | |
364 | ||
365 | if (csrowdev_attr->show) | |
366 | return csrowdev_attr->show(csrow, | |
052dfb45 | 367 | buffer, csrowdev_attr->private); |
7c9281d7 DT |
368 | return -EIO; |
369 | } | |
370 | ||
371 | static ssize_t csrowdev_store(struct kobject *kobj, struct attribute *attr, | |
052dfb45 | 372 | const char *buffer, size_t count) |
7c9281d7 DT |
373 | { |
374 | struct csrow_info *csrow = to_csrow(kobj); | |
079708b9 | 375 | struct csrowdev_attribute *csrowdev_attr = to_csrowdev_attr(attr); |
7c9281d7 DT |
376 | |
377 | if (csrowdev_attr->store) | |
378 | return csrowdev_attr->store(csrow, | |
052dfb45 DT |
379 | buffer, |
380 | count, csrowdev_attr->private); | |
7c9281d7 DT |
381 | return -EIO; |
382 | } | |
383 | ||
384 | static struct sysfs_ops csrowfs_ops = { | |
079708b9 DT |
385 | .show = csrowdev_show, |
386 | .store = csrowdev_store | |
7c9281d7 DT |
387 | }; |
388 | ||
389 | #define CSROWDEV_ATTR(_name,_mode,_show,_store,_private) \ | |
390 | static struct csrowdev_attribute attr_##_name = { \ | |
391 | .attr = {.name = __stringify(_name), .mode = _mode }, \ | |
392 | .show = _show, \ | |
393 | .store = _store, \ | |
394 | .private = _private, \ | |
395 | }; | |
396 | ||
397 | /* default cwrow<id>/attribute files */ | |
079708b9 DT |
398 | CSROWDEV_ATTR(size_mb, S_IRUGO, csrow_size_show, NULL, 0); |
399 | CSROWDEV_ATTR(dev_type, S_IRUGO, csrow_dev_type_show, NULL, 0); | |
400 | CSROWDEV_ATTR(mem_type, S_IRUGO, csrow_mem_type_show, NULL, 0); | |
401 | CSROWDEV_ATTR(edac_mode, S_IRUGO, csrow_edac_mode_show, NULL, 0); | |
402 | CSROWDEV_ATTR(ue_count, S_IRUGO, csrow_ue_count_show, NULL, 0); | |
403 | CSROWDEV_ATTR(ce_count, S_IRUGO, csrow_ce_count_show, NULL, 0); | |
7c9281d7 DT |
404 | |
405 | /* default attributes of the CSROW<id> object */ | |
406 | static struct csrowdev_attribute *default_csrow_attr[] = { | |
407 | &attr_dev_type, | |
408 | &attr_mem_type, | |
409 | &attr_edac_mode, | |
410 | &attr_size_mb, | |
411 | &attr_ue_count, | |
412 | &attr_ce_count, | |
413 | NULL, | |
414 | }; | |
415 | ||
7c9281d7 | 416 | /* possible dynamic channel DIMM Label attribute files */ |
079708b9 | 417 | CSROWDEV_ATTR(ch0_dimm_label, S_IRUGO | S_IWUSR, |
052dfb45 | 418 | channel_dimm_label_show, channel_dimm_label_store, 0); |
079708b9 | 419 | CSROWDEV_ATTR(ch1_dimm_label, S_IRUGO | S_IWUSR, |
052dfb45 | 420 | channel_dimm_label_show, channel_dimm_label_store, 1); |
079708b9 | 421 | CSROWDEV_ATTR(ch2_dimm_label, S_IRUGO | S_IWUSR, |
052dfb45 | 422 | channel_dimm_label_show, channel_dimm_label_store, 2); |
079708b9 | 423 | CSROWDEV_ATTR(ch3_dimm_label, S_IRUGO | S_IWUSR, |
052dfb45 | 424 | channel_dimm_label_show, channel_dimm_label_store, 3); |
079708b9 | 425 | CSROWDEV_ATTR(ch4_dimm_label, S_IRUGO | S_IWUSR, |
052dfb45 | 426 | channel_dimm_label_show, channel_dimm_label_store, 4); |
079708b9 | 427 | CSROWDEV_ATTR(ch5_dimm_label, S_IRUGO | S_IWUSR, |
052dfb45 | 428 | channel_dimm_label_show, channel_dimm_label_store, 5); |
7c9281d7 DT |
429 | |
430 | /* Total possible dynamic DIMM Label attribute file table */ | |
431 | static struct csrowdev_attribute *dynamic_csrow_dimm_attr[] = { | |
079708b9 DT |
432 | &attr_ch0_dimm_label, |
433 | &attr_ch1_dimm_label, | |
434 | &attr_ch2_dimm_label, | |
435 | &attr_ch3_dimm_label, | |
436 | &attr_ch4_dimm_label, | |
437 | &attr_ch5_dimm_label | |
7c9281d7 DT |
438 | }; |
439 | ||
440 | /* possible dynamic channel ce_count attribute files */ | |
079708b9 DT |
441 | CSROWDEV_ATTR(ch0_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 0); |
442 | CSROWDEV_ATTR(ch1_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 1); | |
443 | CSROWDEV_ATTR(ch2_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 2); | |
444 | CSROWDEV_ATTR(ch3_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 3); | |
445 | CSROWDEV_ATTR(ch4_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 4); | |
446 | CSROWDEV_ATTR(ch5_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 5); | |
7c9281d7 DT |
447 | |
448 | /* Total possible dynamic ce_count attribute file table */ | |
449 | static struct csrowdev_attribute *dynamic_csrow_ce_count_attr[] = { | |
079708b9 DT |
450 | &attr_ch0_ce_count, |
451 | &attr_ch1_ce_count, | |
452 | &attr_ch2_ce_count, | |
453 | &attr_ch3_ce_count, | |
454 | &attr_ch4_ce_count, | |
455 | &attr_ch5_ce_count | |
7c9281d7 DT |
456 | }; |
457 | ||
7c9281d7 DT |
458 | #define EDAC_NR_CHANNELS 6 |
459 | ||
460 | /* Create dynamic CHANNEL files, indexed by 'chan', under specifed CSROW */ | |
461 | static int edac_create_channel_files(struct kobject *kobj, int chan) | |
462 | { | |
079708b9 | 463 | int err = -ENODEV; |
7c9281d7 DT |
464 | |
465 | if (chan >= EDAC_NR_CHANNELS) | |
466 | return err; | |
467 | ||
468 | /* create the DIMM label attribute file */ | |
469 | err = sysfs_create_file(kobj, | |
079708b9 DT |
470 | (struct attribute *) |
471 | dynamic_csrow_dimm_attr[chan]); | |
7c9281d7 DT |
472 | |
473 | if (!err) { | |
474 | /* create the CE Count attribute file */ | |
475 | err = sysfs_create_file(kobj, | |
079708b9 DT |
476 | (struct attribute *) |
477 | dynamic_csrow_ce_count_attr[chan]); | |
7c9281d7 | 478 | } else { |
e27e3dac DT |
479 | debugf1("%s() dimm labels and ce_count files created", |
480 | __func__); | |
7c9281d7 DT |
481 | } |
482 | ||
483 | return err; | |
484 | } | |
485 | ||
486 | /* No memory to release for this kobj */ | |
487 | static void edac_csrow_instance_release(struct kobject *kobj) | |
488 | { | |
489 | struct csrow_info *cs; | |
490 | ||
491 | cs = container_of(kobj, struct csrow_info, kobj); | |
492 | complete(&cs->kobj_complete); | |
493 | } | |
494 | ||
495 | /* the kobj_type instance for a CSROW */ | |
496 | static struct kobj_type ktype_csrow = { | |
497 | .release = edac_csrow_instance_release, | |
498 | .sysfs_ops = &csrowfs_ops, | |
079708b9 | 499 | .default_attrs = (struct attribute **)default_csrow_attr, |
7c9281d7 DT |
500 | }; |
501 | ||
502 | /* Create a CSROW object under specifed edac_mc_device */ | |
079708b9 | 503 | static int edac_create_csrow_object(struct kobject *edac_mci_kobj, |
052dfb45 | 504 | struct csrow_info *csrow, int index) |
7c9281d7 DT |
505 | { |
506 | int err = 0; | |
507 | int chan; | |
508 | ||
509 | memset(&csrow->kobj, 0, sizeof(csrow->kobj)); | |
510 | ||
511 | /* generate ..../edac/mc/mc<id>/csrow<index> */ | |
512 | ||
513 | csrow->kobj.parent = edac_mci_kobj; | |
514 | csrow->kobj.ktype = &ktype_csrow; | |
515 | ||
516 | /* name this instance of csrow<id> */ | |
079708b9 | 517 | err = kobject_set_name(&csrow->kobj, "csrow%d", index); |
7c9281d7 DT |
518 | if (err) |
519 | goto error_exit; | |
520 | ||
521 | /* Instanstiate the csrow object */ | |
522 | err = kobject_register(&csrow->kobj); | |
523 | if (!err) { | |
524 | /* Create the dyanmic attribute files on this csrow, | |
525 | * namely, the DIMM labels and the channel ce_count | |
526 | */ | |
527 | for (chan = 0; chan < csrow->nr_channels; chan++) { | |
079708b9 | 528 | err = edac_create_channel_files(&csrow->kobj, chan); |
7c9281d7 DT |
529 | if (err) |
530 | break; | |
531 | } | |
532 | } | |
533 | ||
052dfb45 | 534 | error_exit: |
7c9281d7 DT |
535 | return err; |
536 | } | |
537 | ||
538 | /* default sysfs methods and data structures for the main MCI kobject */ | |
539 | ||
540 | static ssize_t mci_reset_counters_store(struct mem_ctl_info *mci, | |
079708b9 | 541 | const char *data, size_t count) |
7c9281d7 DT |
542 | { |
543 | int row, chan; | |
544 | ||
545 | mci->ue_noinfo_count = 0; | |
546 | mci->ce_noinfo_count = 0; | |
547 | mci->ue_count = 0; | |
548 | mci->ce_count = 0; | |
549 | ||
550 | for (row = 0; row < mci->nr_csrows; row++) { | |
551 | struct csrow_info *ri = &mci->csrows[row]; | |
552 | ||
553 | ri->ue_count = 0; | |
554 | ri->ce_count = 0; | |
555 | ||
556 | for (chan = 0; chan < ri->nr_channels; chan++) | |
557 | ri->channels[chan].ce_count = 0; | |
558 | } | |
559 | ||
560 | mci->start_time = jiffies; | |
561 | return count; | |
562 | } | |
563 | ||
564 | /* memory scrubbing */ | |
565 | static ssize_t mci_sdram_scrub_rate_store(struct mem_ctl_info *mci, | |
052dfb45 | 566 | const char *data, size_t count) |
7c9281d7 DT |
567 | { |
568 | u32 bandwidth = -1; | |
569 | ||
570 | if (mci->set_sdram_scrub_rate) { | |
571 | ||
572 | memctrl_int_store(&bandwidth, data, count); | |
573 | ||
079708b9 | 574 | if (!(*mci->set_sdram_scrub_rate) (mci, &bandwidth)) { |
7c9281d7 | 575 | edac_printk(KERN_DEBUG, EDAC_MC, |
052dfb45 DT |
576 | "Scrub rate set successfully, applied: %d\n", |
577 | bandwidth); | |
7c9281d7 DT |
578 | } else { |
579 | /* FIXME: error codes maybe? */ | |
580 | edac_printk(KERN_DEBUG, EDAC_MC, | |
052dfb45 DT |
581 | "Scrub rate set FAILED, could not apply: %d\n", |
582 | bandwidth); | |
7c9281d7 DT |
583 | } |
584 | } else { | |
585 | /* FIXME: produce "not implemented" ERROR for user-side. */ | |
586 | edac_printk(KERN_WARNING, EDAC_MC, | |
052dfb45 | 587 | "Memory scrubbing 'set'control is not implemented!\n"); |
7c9281d7 DT |
588 | } |
589 | return count; | |
590 | } | |
591 | ||
592 | static ssize_t mci_sdram_scrub_rate_show(struct mem_ctl_info *mci, char *data) | |
593 | { | |
594 | u32 bandwidth = -1; | |
595 | ||
596 | if (mci->get_sdram_scrub_rate) { | |
079708b9 | 597 | if (!(*mci->get_sdram_scrub_rate) (mci, &bandwidth)) { |
7c9281d7 | 598 | edac_printk(KERN_DEBUG, EDAC_MC, |
052dfb45 DT |
599 | "Scrub rate successfully, fetched: %d\n", |
600 | bandwidth); | |
7c9281d7 DT |
601 | } else { |
602 | /* FIXME: error codes maybe? */ | |
603 | edac_printk(KERN_DEBUG, EDAC_MC, | |
052dfb45 DT |
604 | "Scrub rate fetch FAILED, got: %d\n", |
605 | bandwidth); | |
7c9281d7 DT |
606 | } |
607 | } else { | |
608 | /* FIXME: produce "not implemented" ERROR for user-side. */ | |
609 | edac_printk(KERN_WARNING, EDAC_MC, | |
052dfb45 | 610 | "Memory scrubbing 'get' control is not implemented\n"); |
7c9281d7 DT |
611 | } |
612 | return sprintf(data, "%d\n", bandwidth); | |
613 | } | |
614 | ||
615 | /* default attribute files for the MCI object */ | |
616 | static ssize_t mci_ue_count_show(struct mem_ctl_info *mci, char *data) | |
617 | { | |
079708b9 | 618 | return sprintf(data, "%d\n", mci->ue_count); |
7c9281d7 DT |
619 | } |
620 | ||
621 | static ssize_t mci_ce_count_show(struct mem_ctl_info *mci, char *data) | |
622 | { | |
079708b9 | 623 | return sprintf(data, "%d\n", mci->ce_count); |
7c9281d7 DT |
624 | } |
625 | ||
626 | static ssize_t mci_ce_noinfo_show(struct mem_ctl_info *mci, char *data) | |
627 | { | |
079708b9 | 628 | return sprintf(data, "%d\n", mci->ce_noinfo_count); |
7c9281d7 DT |
629 | } |
630 | ||
631 | static ssize_t mci_ue_noinfo_show(struct mem_ctl_info *mci, char *data) | |
632 | { | |
079708b9 | 633 | return sprintf(data, "%d\n", mci->ue_noinfo_count); |
7c9281d7 DT |
634 | } |
635 | ||
636 | static ssize_t mci_seconds_show(struct mem_ctl_info *mci, char *data) | |
637 | { | |
079708b9 | 638 | return sprintf(data, "%ld\n", (jiffies - mci->start_time) / HZ); |
7c9281d7 DT |
639 | } |
640 | ||
641 | static ssize_t mci_ctl_name_show(struct mem_ctl_info *mci, char *data) | |
642 | { | |
079708b9 | 643 | return sprintf(data, "%s\n", mci->ctl_name); |
7c9281d7 DT |
644 | } |
645 | ||
646 | static ssize_t mci_size_mb_show(struct mem_ctl_info *mci, char *data) | |
647 | { | |
648 | int total_pages, csrow_idx; | |
649 | ||
650 | for (total_pages = csrow_idx = 0; csrow_idx < mci->nr_csrows; | |
052dfb45 | 651 | csrow_idx++) { |
7c9281d7 DT |
652 | struct csrow_info *csrow = &mci->csrows[csrow_idx]; |
653 | ||
654 | if (!csrow->nr_pages) | |
655 | continue; | |
656 | ||
657 | total_pages += csrow->nr_pages; | |
658 | } | |
659 | ||
079708b9 | 660 | return sprintf(data, "%u\n", PAGES_TO_MiB(total_pages)); |
7c9281d7 DT |
661 | } |
662 | ||
7c9281d7 | 663 | #define to_mci(k) container_of(k, struct mem_ctl_info, edac_mci_kobj) |
42a8e397 | 664 | #define to_mcidev_attr(a) container_of(a,struct mcidev_sysfs_attribute,attr) |
7c9281d7 DT |
665 | |
666 | /* MCI show/store functions for top most object */ | |
667 | static ssize_t mcidev_show(struct kobject *kobj, struct attribute *attr, | |
052dfb45 | 668 | char *buffer) |
7c9281d7 DT |
669 | { |
670 | struct mem_ctl_info *mem_ctl_info = to_mci(kobj); | |
42a8e397 | 671 | struct mcidev_sysfs_attribute *mcidev_attr = to_mcidev_attr(attr); |
7c9281d7 DT |
672 | |
673 | if (mcidev_attr->show) | |
674 | return mcidev_attr->show(mem_ctl_info, buffer); | |
675 | ||
676 | return -EIO; | |
677 | } | |
678 | ||
679 | static ssize_t mcidev_store(struct kobject *kobj, struct attribute *attr, | |
052dfb45 | 680 | const char *buffer, size_t count) |
7c9281d7 DT |
681 | { |
682 | struct mem_ctl_info *mem_ctl_info = to_mci(kobj); | |
42a8e397 | 683 | struct mcidev_sysfs_attribute *mcidev_attr = to_mcidev_attr(attr); |
7c9281d7 DT |
684 | |
685 | if (mcidev_attr->store) | |
686 | return mcidev_attr->store(mem_ctl_info, buffer, count); | |
687 | ||
688 | return -EIO; | |
689 | } | |
690 | ||
691 | static struct sysfs_ops mci_ops = { | |
692 | .show = mcidev_show, | |
693 | .store = mcidev_store | |
694 | }; | |
695 | ||
696 | #define MCIDEV_ATTR(_name,_mode,_show,_store) \ | |
42a8e397 | 697 | static struct mcidev_sysfs_attribute mci_attr_##_name = { \ |
7c9281d7 DT |
698 | .attr = {.name = __stringify(_name), .mode = _mode }, \ |
699 | .show = _show, \ | |
700 | .store = _store, \ | |
701 | }; | |
702 | ||
703 | /* default Control file */ | |
079708b9 | 704 | MCIDEV_ATTR(reset_counters, S_IWUSR, NULL, mci_reset_counters_store); |
7c9281d7 DT |
705 | |
706 | /* default Attribute files */ | |
079708b9 DT |
707 | MCIDEV_ATTR(mc_name, S_IRUGO, mci_ctl_name_show, NULL); |
708 | MCIDEV_ATTR(size_mb, S_IRUGO, mci_size_mb_show, NULL); | |
709 | MCIDEV_ATTR(seconds_since_reset, S_IRUGO, mci_seconds_show, NULL); | |
710 | MCIDEV_ATTR(ue_noinfo_count, S_IRUGO, mci_ue_noinfo_show, NULL); | |
711 | MCIDEV_ATTR(ce_noinfo_count, S_IRUGO, mci_ce_noinfo_show, NULL); | |
712 | MCIDEV_ATTR(ue_count, S_IRUGO, mci_ue_count_show, NULL); | |
713 | MCIDEV_ATTR(ce_count, S_IRUGO, mci_ce_count_show, NULL); | |
7c9281d7 DT |
714 | |
715 | /* memory scrubber attribute file */ | |
079708b9 | 716 | MCIDEV_ATTR(sdram_scrub_rate, S_IRUGO | S_IWUSR, mci_sdram_scrub_rate_show, |
052dfb45 | 717 | mci_sdram_scrub_rate_store); |
7c9281d7 | 718 | |
42a8e397 | 719 | static struct mcidev_sysfs_attribute *mci_attr[] = { |
7c9281d7 DT |
720 | &mci_attr_reset_counters, |
721 | &mci_attr_mc_name, | |
722 | &mci_attr_size_mb, | |
723 | &mci_attr_seconds_since_reset, | |
724 | &mci_attr_ue_noinfo_count, | |
725 | &mci_attr_ce_noinfo_count, | |
726 | &mci_attr_ue_count, | |
727 | &mci_attr_ce_count, | |
728 | &mci_attr_sdram_scrub_rate, | |
729 | NULL | |
730 | }; | |
731 | ||
732 | /* | |
733 | * Release of a MC controlling instance | |
734 | */ | |
735 | static void edac_mci_instance_release(struct kobject *kobj) | |
736 | { | |
737 | struct mem_ctl_info *mci; | |
738 | ||
739 | mci = to_mci(kobj); | |
740 | debugf0("%s() idx=%d\n", __func__, mci->mc_idx); | |
741 | complete(&mci->kobj_complete); | |
742 | } | |
743 | ||
744 | static struct kobj_type ktype_mci = { | |
745 | .release = edac_mci_instance_release, | |
746 | .sysfs_ops = &mci_ops, | |
079708b9 | 747 | .default_attrs = (struct attribute **)mci_attr, |
7c9281d7 DT |
748 | }; |
749 | ||
7c9281d7 DT |
750 | #define EDAC_DEVICE_SYMLINK "device" |
751 | ||
42a8e397 DT |
752 | /* |
753 | * edac_create_driver_attributes | |
754 | * create MC driver specific attributes at the topmost level | |
755 | * directory of this mci instance. | |
756 | */ | |
757 | static int edac_create_driver_attributes(struct mem_ctl_info *mci) | |
758 | { | |
759 | int err; | |
760 | struct mcidev_sysfs_attribute *sysfs_attrib; | |
761 | ||
762 | /* point to the start of the array and iterate over it | |
763 | * adding each attribute listed to this mci instance's kobject | |
764 | */ | |
765 | sysfs_attrib = mci->mc_driver_sysfs_attributes; | |
766 | ||
767 | while (sysfs_attrib->attr.name != NULL) { | |
768 | err = sysfs_create_file(&mci->edac_mci_kobj, | |
769 | (struct attribute*) sysfs_attrib); | |
770 | if (err) { | |
771 | return err; | |
772 | } | |
773 | ||
774 | sysfs_attrib++; | |
775 | } | |
776 | ||
777 | return 0; | |
778 | } | |
779 | ||
7c9281d7 DT |
780 | /* |
781 | * Create a new Memory Controller kobject instance, | |
782 | * mc<id> under the 'mc' directory | |
783 | * | |
784 | * Return: | |
785 | * 0 Success | |
786 | * !0 Failure | |
787 | */ | |
788 | int edac_create_sysfs_mci_device(struct mem_ctl_info *mci) | |
789 | { | |
790 | int i; | |
791 | int err; | |
792 | struct csrow_info *csrow; | |
079708b9 | 793 | struct kobject *edac_mci_kobj = &mci->edac_mci_kobj; |
7c9281d7 DT |
794 | |
795 | debugf0("%s() idx=%d\n", __func__, mci->mc_idx); | |
796 | memset(edac_mci_kobj, 0, sizeof(*edac_mci_kobj)); | |
797 | ||
798 | /* set the name of the mc<id> object */ | |
079708b9 | 799 | err = kobject_set_name(edac_mci_kobj, "mc%d", mci->mc_idx); |
7c9281d7 DT |
800 | if (err) |
801 | return err; | |
802 | ||
803 | /* link to our parent the '..../edac/mc' object */ | |
804 | edac_mci_kobj->parent = &edac_memctrl_kobj; | |
805 | edac_mci_kobj->ktype = &ktype_mci; | |
806 | ||
807 | /* register the mc<id> kobject */ | |
808 | err = kobject_register(edac_mci_kobj); | |
809 | if (err) | |
810 | return err; | |
811 | ||
812 | /* create a symlink for the device */ | |
813 | err = sysfs_create_link(edac_mci_kobj, &mci->dev->kobj, | |
814 | EDAC_DEVICE_SYMLINK); | |
815 | if (err) | |
816 | goto fail0; | |
817 | ||
42a8e397 DT |
818 | /* If the low level driver desires some attributes, |
819 | * then create them now for the driver. | |
820 | */ | |
821 | if (mci->mc_driver_sysfs_attributes) { | |
822 | err = edac_create_driver_attributes(mci); | |
823 | if (err) | |
824 | goto fail0; | |
825 | } | |
826 | ||
7c9281d7 DT |
827 | /* Make directories for each CSROW object |
828 | * under the mc<id> kobject | |
829 | */ | |
830 | for (i = 0; i < mci->nr_csrows; i++) { | |
831 | csrow = &mci->csrows[i]; | |
832 | ||
833 | /* Only expose populated CSROWs */ | |
834 | if (csrow->nr_pages > 0) { | |
079708b9 | 835 | err = edac_create_csrow_object(edac_mci_kobj, csrow, i); |
7c9281d7 DT |
836 | if (err) |
837 | goto fail1; | |
838 | } | |
839 | } | |
840 | ||
841 | return 0; | |
842 | ||
843 | /* CSROW error: backout what has already been registered, */ | |
052dfb45 | 844 | fail1: |
079708b9 | 845 | for (i--; i >= 0; i--) { |
7c9281d7 DT |
846 | if (csrow->nr_pages > 0) { |
847 | init_completion(&csrow->kobj_complete); | |
848 | kobject_unregister(&mci->csrows[i].kobj); | |
849 | wait_for_completion(&csrow->kobj_complete); | |
850 | } | |
851 | } | |
852 | ||
052dfb45 | 853 | fail0: |
7c9281d7 DT |
854 | init_completion(&mci->kobj_complete); |
855 | kobject_unregister(edac_mci_kobj); | |
856 | wait_for_completion(&mci->kobj_complete); | |
857 | return err; | |
858 | } | |
859 | ||
860 | /* | |
861 | * remove a Memory Controller instance | |
862 | */ | |
863 | void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci) | |
864 | { | |
865 | int i; | |
866 | ||
867 | debugf0("%s()\n", __func__); | |
868 | ||
869 | /* remove all csrow kobjects */ | |
870 | for (i = 0; i < mci->nr_csrows; i++) { | |
871 | if (mci->csrows[i].nr_pages > 0) { | |
872 | init_completion(&mci->csrows[i].kobj_complete); | |
873 | kobject_unregister(&mci->csrows[i].kobj); | |
874 | wait_for_completion(&mci->csrows[i].kobj_complete); | |
875 | } | |
876 | } | |
877 | ||
878 | sysfs_remove_link(&mci->edac_mci_kobj, EDAC_DEVICE_SYMLINK); | |
879 | init_completion(&mci->kobj_complete); | |
880 | kobject_unregister(&mci->edac_mci_kobj); | |
881 | wait_for_completion(&mci->kobj_complete); | |
882 | } |