2 * edac_mc kernel module
3 * (C) 2005-2007 Linux Networx (http://lnxi.com)
5 * This file may be distributed under the terms of the
6 * GNU General Public License.
8 * Written Doug Thompson <norsk5@xmission.com> www.softwarebitmaker.com
10 * (c) 2012-2013 - Mauro Carvalho Chehab
11 * The entire API were re-written, and ported to use struct device
15 #include <linux/ctype.h>
16 #include <linux/slab.h>
17 #include <linux/edac.h>
18 #include <linux/bug.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/uaccess.h>
23 #include "edac_module.h"
25 /* MC EDAC Controls, setable by module parameter, and sysfs */
26 static int edac_mc_log_ue = 1;
27 static int edac_mc_log_ce = 1;
28 static int edac_mc_panic_on_ue;
29 static unsigned int edac_mc_poll_msec = 1000;
31 /* Getter functions for above */
32 int edac_mc_get_log_ue(void)
34 return edac_mc_log_ue;
37 int edac_mc_get_log_ce(void)
39 return edac_mc_log_ce;
42 int edac_mc_get_panic_on_ue(void)
44 return edac_mc_panic_on_ue;
47 /* this is temporary */
48 unsigned int edac_mc_get_poll_msec(void)
50 return edac_mc_poll_msec;
53 static int edac_set_poll_msec(const char *val, const struct kernel_param *kp)
61 ret = kstrtouint(val, 0, &i);
68 *((unsigned int *)kp->arg) = i;
70 /* notify edac_mc engine to reset the poll period */
71 edac_mc_reset_delay_period(i);
76 /* Parameter declarations for above */
77 module_param(edac_mc_panic_on_ue, int, 0644);
78 MODULE_PARM_DESC(edac_mc_panic_on_ue, "Panic on uncorrected error: 0=off 1=on");
79 module_param(edac_mc_log_ue, int, 0644);
80 MODULE_PARM_DESC(edac_mc_log_ue,
81 "Log uncorrectable error to console: 0=off 1=on");
82 module_param(edac_mc_log_ce, int, 0644);
83 MODULE_PARM_DESC(edac_mc_log_ce,
84 "Log correctable error to console: 0=off 1=on");
85 module_param_call(edac_mc_poll_msec, edac_set_poll_msec, param_get_uint,
86 &edac_mc_poll_msec, 0644);
87 MODULE_PARM_DESC(edac_mc_poll_msec, "Polling period in milliseconds");
89 static struct device *mci_pdev;
92 * various constants for Memory Controllers
94 static const char * const dev_types[] = {
95 [DEV_UNKNOWN] = "Unknown",
105 static const char * const edac_caps[] = {
106 [EDAC_UNKNOWN] = "Unknown",
107 [EDAC_NONE] = "None",
108 [EDAC_RESERVED] = "Reserved",
109 [EDAC_PARITY] = "PARITY",
111 [EDAC_SECDED] = "SECDED",
112 [EDAC_S2ECD2ED] = "S2ECD2ED",
113 [EDAC_S4ECD4ED] = "S4ECD4ED",
114 [EDAC_S8ECD8ED] = "S8ECD8ED",
115 [EDAC_S16ECD16ED] = "S16ECD16ED"
118 #ifdef CONFIG_EDAC_LEGACY_SYSFS
120 * EDAC sysfs CSROW data structures and methods
123 #define to_csrow(k) container_of(k, struct csrow_info, dev)
126 * We need it to avoid namespace conflicts between the legacy API
127 * and the per-dimm/per-rank one
129 #define DEVICE_ATTR_LEGACY(_name, _mode, _show, _store) \
130 static struct device_attribute dev_attr_legacy_##_name = __ATTR(_name, _mode, _show, _store)
132 struct dev_ch_attribute {
133 struct device_attribute attr;
134 unsigned int channel;
137 #define DEVICE_CHANNEL(_name, _mode, _show, _store, _var) \
138 static struct dev_ch_attribute dev_attr_legacy_##_name = \
139 { __ATTR(_name, _mode, _show, _store), (_var) }
141 #define to_channel(k) (container_of(k, struct dev_ch_attribute, attr)->channel)
143 /* Set of more default csrow<id> attribute show/store functions */
144 static ssize_t csrow_ue_count_show(struct device *dev,
145 struct device_attribute *mattr, char *data)
147 struct csrow_info *csrow = to_csrow(dev);
149 return sprintf(data, "%u\n", csrow->ue_count);
152 static ssize_t csrow_ce_count_show(struct device *dev,
153 struct device_attribute *mattr, char *data)
155 struct csrow_info *csrow = to_csrow(dev);
157 return sprintf(data, "%u\n", csrow->ce_count);
160 static ssize_t csrow_size_show(struct device *dev,
161 struct device_attribute *mattr, char *data)
163 struct csrow_info *csrow = to_csrow(dev);
167 for (i = 0; i < csrow->nr_channels; i++)
168 nr_pages += csrow->channels[i]->dimm->nr_pages;
169 return sprintf(data, "%u\n", PAGES_TO_MiB(nr_pages));
172 static ssize_t csrow_mem_type_show(struct device *dev,
173 struct device_attribute *mattr, char *data)
175 struct csrow_info *csrow = to_csrow(dev);
177 return sprintf(data, "%s\n", edac_mem_types[csrow->channels[0]->dimm->mtype]);
180 static ssize_t csrow_dev_type_show(struct device *dev,
181 struct device_attribute *mattr, char *data)
183 struct csrow_info *csrow = to_csrow(dev);
185 return sprintf(data, "%s\n", dev_types[csrow->channels[0]->dimm->dtype]);
188 static ssize_t csrow_edac_mode_show(struct device *dev,
189 struct device_attribute *mattr,
192 struct csrow_info *csrow = to_csrow(dev);
194 return sprintf(data, "%s\n", edac_caps[csrow->channels[0]->dimm->edac_mode]);
197 /* show/store functions for DIMM Label attributes */
198 static ssize_t channel_dimm_label_show(struct device *dev,
199 struct device_attribute *mattr,
202 struct csrow_info *csrow = to_csrow(dev);
203 unsigned int chan = to_channel(mattr);
204 struct rank_info *rank = csrow->channels[chan];
206 /* if field has not been initialized, there is nothing to send */
207 if (!rank->dimm->label[0])
210 return snprintf(data, sizeof(rank->dimm->label) + 1, "%s\n",
214 static ssize_t channel_dimm_label_store(struct device *dev,
215 struct device_attribute *mattr,
216 const char *data, size_t count)
218 struct csrow_info *csrow = to_csrow(dev);
219 unsigned int chan = to_channel(mattr);
220 struct rank_info *rank = csrow->channels[chan];
221 size_t copy_count = count;
226 if (data[count - 1] == '\0' || data[count - 1] == '\n')
229 if (copy_count == 0 || copy_count >= sizeof(rank->dimm->label))
232 strncpy(rank->dimm->label, data, copy_count);
233 rank->dimm->label[copy_count] = '\0';
238 /* show function for dynamic chX_ce_count attribute */
239 static ssize_t channel_ce_count_show(struct device *dev,
240 struct device_attribute *mattr, char *data)
242 struct csrow_info *csrow = to_csrow(dev);
243 unsigned int chan = to_channel(mattr);
244 struct rank_info *rank = csrow->channels[chan];
246 return sprintf(data, "%u\n", rank->ce_count);
249 /* cwrow<id>/attribute files */
250 DEVICE_ATTR_LEGACY(size_mb, S_IRUGO, csrow_size_show, NULL);
251 DEVICE_ATTR_LEGACY(dev_type, S_IRUGO, csrow_dev_type_show, NULL);
252 DEVICE_ATTR_LEGACY(mem_type, S_IRUGO, csrow_mem_type_show, NULL);
253 DEVICE_ATTR_LEGACY(edac_mode, S_IRUGO, csrow_edac_mode_show, NULL);
254 DEVICE_ATTR_LEGACY(ue_count, S_IRUGO, csrow_ue_count_show, NULL);
255 DEVICE_ATTR_LEGACY(ce_count, S_IRUGO, csrow_ce_count_show, NULL);
257 /* default attributes of the CSROW<id> object */
258 static struct attribute *csrow_attrs[] = {
259 &dev_attr_legacy_dev_type.attr,
260 &dev_attr_legacy_mem_type.attr,
261 &dev_attr_legacy_edac_mode.attr,
262 &dev_attr_legacy_size_mb.attr,
263 &dev_attr_legacy_ue_count.attr,
264 &dev_attr_legacy_ce_count.attr,
268 static const struct attribute_group csrow_attr_grp = {
269 .attrs = csrow_attrs,
272 static const struct attribute_group *csrow_attr_groups[] = {
277 static void csrow_attr_release(struct device *dev)
279 /* release device with _edac_mc_free() */
282 static const struct device_type csrow_attr_type = {
283 .groups = csrow_attr_groups,
284 .release = csrow_attr_release,
288 * possible dynamic channel DIMM Label attribute files
291 DEVICE_CHANNEL(ch0_dimm_label, S_IRUGO | S_IWUSR,
292 channel_dimm_label_show, channel_dimm_label_store, 0);
293 DEVICE_CHANNEL(ch1_dimm_label, S_IRUGO | S_IWUSR,
294 channel_dimm_label_show, channel_dimm_label_store, 1);
295 DEVICE_CHANNEL(ch2_dimm_label, S_IRUGO | S_IWUSR,
296 channel_dimm_label_show, channel_dimm_label_store, 2);
297 DEVICE_CHANNEL(ch3_dimm_label, S_IRUGO | S_IWUSR,
298 channel_dimm_label_show, channel_dimm_label_store, 3);
299 DEVICE_CHANNEL(ch4_dimm_label, S_IRUGO | S_IWUSR,
300 channel_dimm_label_show, channel_dimm_label_store, 4);
301 DEVICE_CHANNEL(ch5_dimm_label, S_IRUGO | S_IWUSR,
302 channel_dimm_label_show, channel_dimm_label_store, 5);
303 DEVICE_CHANNEL(ch6_dimm_label, S_IRUGO | S_IWUSR,
304 channel_dimm_label_show, channel_dimm_label_store, 6);
305 DEVICE_CHANNEL(ch7_dimm_label, S_IRUGO | S_IWUSR,
306 channel_dimm_label_show, channel_dimm_label_store, 7);
308 /* Total possible dynamic DIMM Label attribute file table */
309 static struct attribute *dynamic_csrow_dimm_attr[] = {
310 &dev_attr_legacy_ch0_dimm_label.attr.attr,
311 &dev_attr_legacy_ch1_dimm_label.attr.attr,
312 &dev_attr_legacy_ch2_dimm_label.attr.attr,
313 &dev_attr_legacy_ch3_dimm_label.attr.attr,
314 &dev_attr_legacy_ch4_dimm_label.attr.attr,
315 &dev_attr_legacy_ch5_dimm_label.attr.attr,
316 &dev_attr_legacy_ch6_dimm_label.attr.attr,
317 &dev_attr_legacy_ch7_dimm_label.attr.attr,
321 /* possible dynamic channel ce_count attribute files */
322 DEVICE_CHANNEL(ch0_ce_count, S_IRUGO,
323 channel_ce_count_show, NULL, 0);
324 DEVICE_CHANNEL(ch1_ce_count, S_IRUGO,
325 channel_ce_count_show, NULL, 1);
326 DEVICE_CHANNEL(ch2_ce_count, S_IRUGO,
327 channel_ce_count_show, NULL, 2);
328 DEVICE_CHANNEL(ch3_ce_count, S_IRUGO,
329 channel_ce_count_show, NULL, 3);
330 DEVICE_CHANNEL(ch4_ce_count, S_IRUGO,
331 channel_ce_count_show, NULL, 4);
332 DEVICE_CHANNEL(ch5_ce_count, S_IRUGO,
333 channel_ce_count_show, NULL, 5);
334 DEVICE_CHANNEL(ch6_ce_count, S_IRUGO,
335 channel_ce_count_show, NULL, 6);
336 DEVICE_CHANNEL(ch7_ce_count, S_IRUGO,
337 channel_ce_count_show, NULL, 7);
339 /* Total possible dynamic ce_count attribute file table */
340 static struct attribute *dynamic_csrow_ce_count_attr[] = {
341 &dev_attr_legacy_ch0_ce_count.attr.attr,
342 &dev_attr_legacy_ch1_ce_count.attr.attr,
343 &dev_attr_legacy_ch2_ce_count.attr.attr,
344 &dev_attr_legacy_ch3_ce_count.attr.attr,
345 &dev_attr_legacy_ch4_ce_count.attr.attr,
346 &dev_attr_legacy_ch5_ce_count.attr.attr,
347 &dev_attr_legacy_ch6_ce_count.attr.attr,
348 &dev_attr_legacy_ch7_ce_count.attr.attr,
352 static umode_t csrow_dev_is_visible(struct kobject *kobj,
353 struct attribute *attr, int idx)
355 struct device *dev = kobj_to_dev(kobj);
356 struct csrow_info *csrow = container_of(dev, struct csrow_info, dev);
358 if (idx >= csrow->nr_channels)
361 if (idx >= ARRAY_SIZE(dynamic_csrow_ce_count_attr) - 1) {
362 WARN_ONCE(1, "idx: %d\n", idx);
366 /* Only expose populated DIMMs */
367 if (!csrow->channels[idx]->dimm->nr_pages)
374 static const struct attribute_group csrow_dev_dimm_group = {
375 .attrs = dynamic_csrow_dimm_attr,
376 .is_visible = csrow_dev_is_visible,
379 static const struct attribute_group csrow_dev_ce_count_group = {
380 .attrs = dynamic_csrow_ce_count_attr,
381 .is_visible = csrow_dev_is_visible,
384 static const struct attribute_group *csrow_dev_groups[] = {
385 &csrow_dev_dimm_group,
386 &csrow_dev_ce_count_group,
390 static inline int nr_pages_per_csrow(struct csrow_info *csrow)
392 int chan, nr_pages = 0;
394 for (chan = 0; chan < csrow->nr_channels; chan++)
395 nr_pages += csrow->channels[chan]->dimm->nr_pages;
400 /* Create a CSROW object under specifed edac_mc_device */
401 static int edac_create_csrow_object(struct mem_ctl_info *mci,
402 struct csrow_info *csrow, int index)
406 csrow->dev.type = &csrow_attr_type;
407 csrow->dev.groups = csrow_dev_groups;
408 device_initialize(&csrow->dev);
409 csrow->dev.parent = &mci->dev;
411 dev_set_name(&csrow->dev, "csrow%d", index);
412 dev_set_drvdata(&csrow->dev, csrow);
414 err = device_add(&csrow->dev);
416 edac_dbg(1, "failure: create device %s\n", dev_name(&csrow->dev));
417 put_device(&csrow->dev);
421 edac_dbg(0, "device %s created\n", dev_name(&csrow->dev));
426 /* Create a CSROW object under specifed edac_mc_device */
427 static int edac_create_csrow_objects(struct mem_ctl_info *mci)
430 struct csrow_info *csrow;
432 for (i = 0; i < mci->nr_csrows; i++) {
433 csrow = mci->csrows[i];
434 if (!nr_pages_per_csrow(csrow))
436 err = edac_create_csrow_object(mci, mci->csrows[i], i);
443 for (--i; i >= 0; i--) {
444 csrow = mci->csrows[i];
445 if (!nr_pages_per_csrow(csrow))
447 device_unregister(&mci->csrows[i]->dev);
453 static void edac_delete_csrow_objects(struct mem_ctl_info *mci)
456 struct csrow_info *csrow;
458 for (i = mci->nr_csrows - 1; i >= 0; i--) {
459 csrow = mci->csrows[i];
460 if (!nr_pages_per_csrow(csrow))
462 device_unregister(&mci->csrows[i]->dev);
468 * Per-dimm (or per-rank) devices
471 #define to_dimm(k) container_of(k, struct dimm_info, dev)
473 /* show/store functions for DIMM Label attributes */
474 static ssize_t dimmdev_location_show(struct device *dev,
475 struct device_attribute *mattr, char *data)
477 struct dimm_info *dimm = to_dimm(dev);
479 return edac_dimm_info_location(dimm, data, PAGE_SIZE);
482 static ssize_t dimmdev_label_show(struct device *dev,
483 struct device_attribute *mattr, char *data)
485 struct dimm_info *dimm = to_dimm(dev);
487 /* if field has not been initialized, there is nothing to send */
491 return snprintf(data, sizeof(dimm->label) + 1, "%s\n", dimm->label);
494 static ssize_t dimmdev_label_store(struct device *dev,
495 struct device_attribute *mattr,
499 struct dimm_info *dimm = to_dimm(dev);
500 size_t copy_count = count;
505 if (data[count - 1] == '\0' || data[count - 1] == '\n')
508 if (copy_count == 0 || copy_count >= sizeof(dimm->label))
511 strncpy(dimm->label, data, copy_count);
512 dimm->label[copy_count] = '\0';
517 static ssize_t dimmdev_size_show(struct device *dev,
518 struct device_attribute *mattr, char *data)
520 struct dimm_info *dimm = to_dimm(dev);
522 return sprintf(data, "%u\n", PAGES_TO_MiB(dimm->nr_pages));
525 static ssize_t dimmdev_mem_type_show(struct device *dev,
526 struct device_attribute *mattr, char *data)
528 struct dimm_info *dimm = to_dimm(dev);
530 return sprintf(data, "%s\n", edac_mem_types[dimm->mtype]);
533 static ssize_t dimmdev_dev_type_show(struct device *dev,
534 struct device_attribute *mattr, char *data)
536 struct dimm_info *dimm = to_dimm(dev);
538 return sprintf(data, "%s\n", dev_types[dimm->dtype]);
541 static ssize_t dimmdev_edac_mode_show(struct device *dev,
542 struct device_attribute *mattr,
545 struct dimm_info *dimm = to_dimm(dev);
547 return sprintf(data, "%s\n", edac_caps[dimm->edac_mode]);
550 static ssize_t dimmdev_ce_count_show(struct device *dev,
551 struct device_attribute *mattr,
554 struct dimm_info *dimm = to_dimm(dev);
557 count = dimm->mci->ce_per_layer[dimm->mci->n_layers-1][dimm->idx];
558 return sprintf(data, "%u\n", count);
561 static ssize_t dimmdev_ue_count_show(struct device *dev,
562 struct device_attribute *mattr,
565 struct dimm_info *dimm = to_dimm(dev);
568 count = dimm->mci->ue_per_layer[dimm->mci->n_layers-1][dimm->idx];
569 return sprintf(data, "%u\n", count);
572 /* dimm/rank attribute files */
573 static DEVICE_ATTR(dimm_label, S_IRUGO | S_IWUSR,
574 dimmdev_label_show, dimmdev_label_store);
575 static DEVICE_ATTR(dimm_location, S_IRUGO, dimmdev_location_show, NULL);
576 static DEVICE_ATTR(size, S_IRUGO, dimmdev_size_show, NULL);
577 static DEVICE_ATTR(dimm_mem_type, S_IRUGO, dimmdev_mem_type_show, NULL);
578 static DEVICE_ATTR(dimm_dev_type, S_IRUGO, dimmdev_dev_type_show, NULL);
579 static DEVICE_ATTR(dimm_edac_mode, S_IRUGO, dimmdev_edac_mode_show, NULL);
580 static DEVICE_ATTR(dimm_ce_count, S_IRUGO, dimmdev_ce_count_show, NULL);
581 static DEVICE_ATTR(dimm_ue_count, S_IRUGO, dimmdev_ue_count_show, NULL);
583 /* attributes of the dimm<id>/rank<id> object */
584 static struct attribute *dimm_attrs[] = {
585 &dev_attr_dimm_label.attr,
586 &dev_attr_dimm_location.attr,
588 &dev_attr_dimm_mem_type.attr,
589 &dev_attr_dimm_dev_type.attr,
590 &dev_attr_dimm_edac_mode.attr,
591 &dev_attr_dimm_ce_count.attr,
592 &dev_attr_dimm_ue_count.attr,
596 static const struct attribute_group dimm_attr_grp = {
600 static const struct attribute_group *dimm_attr_groups[] = {
605 static void dimm_attr_release(struct device *dev)
607 /* release device with _edac_mc_free() */
610 static const struct device_type dimm_attr_type = {
611 .groups = dimm_attr_groups,
612 .release = dimm_attr_release,
615 /* Create a DIMM object under specifed memory controller device */
616 static int edac_create_dimm_object(struct mem_ctl_info *mci,
617 struct dimm_info *dimm)
622 dimm->dev.type = &dimm_attr_type;
623 device_initialize(&dimm->dev);
625 dimm->dev.parent = &mci->dev;
627 dev_set_name(&dimm->dev, "rank%d", dimm->idx);
629 dev_set_name(&dimm->dev, "dimm%d", dimm->idx);
630 dev_set_drvdata(&dimm->dev, dimm);
631 pm_runtime_forbid(&mci->dev);
633 err = device_add(&dimm->dev);
635 edac_dbg(1, "failure: create device %s\n", dev_name(&dimm->dev));
636 put_device(&dimm->dev);
640 if (IS_ENABLED(CONFIG_EDAC_DEBUG)) {
643 edac_dimm_info_location(dimm, location, sizeof(location));
644 edac_dbg(0, "device %s created at location %s\n",
645 dev_name(&dimm->dev), location);
652 * Memory controller device
655 #define to_mci(k) container_of(k, struct mem_ctl_info, dev)
657 static ssize_t mci_reset_counters_store(struct device *dev,
658 struct device_attribute *mattr,
659 const char *data, size_t count)
661 struct mem_ctl_info *mci = to_mci(dev);
662 int cnt, row, chan, i;
665 mci->ue_noinfo_count = 0;
666 mci->ce_noinfo_count = 0;
668 for (row = 0; row < mci->nr_csrows; row++) {
669 struct csrow_info *ri = mci->csrows[row];
674 for (chan = 0; chan < ri->nr_channels; chan++)
675 ri->channels[chan]->ce_count = 0;
679 for (i = 0; i < mci->n_layers; i++) {
680 cnt *= mci->layers[i].size;
681 memset(mci->ce_per_layer[i], 0, cnt * sizeof(u32));
682 memset(mci->ue_per_layer[i], 0, cnt * sizeof(u32));
685 mci->start_time = jiffies;
689 /* Memory scrubbing interface:
691 * A MC driver can limit the scrubbing bandwidth based on the CPU type.
692 * Therefore, ->set_sdram_scrub_rate should be made to return the actual
693 * bandwidth that is accepted or 0 when scrubbing is to be disabled.
695 * Negative value still means that an error has occurred while setting
698 static ssize_t mci_sdram_scrub_rate_store(struct device *dev,
699 struct device_attribute *mattr,
700 const char *data, size_t count)
702 struct mem_ctl_info *mci = to_mci(dev);
703 unsigned long bandwidth = 0;
706 if (kstrtoul(data, 10, &bandwidth) < 0)
709 new_bw = mci->set_sdram_scrub_rate(mci, bandwidth);
711 edac_printk(KERN_WARNING, EDAC_MC,
712 "Error setting scrub rate to: %lu\n", bandwidth);
720 * ->get_sdram_scrub_rate() return value semantics same as above.
722 static ssize_t mci_sdram_scrub_rate_show(struct device *dev,
723 struct device_attribute *mattr,
726 struct mem_ctl_info *mci = to_mci(dev);
729 bandwidth = mci->get_sdram_scrub_rate(mci);
731 edac_printk(KERN_DEBUG, EDAC_MC, "Error reading scrub rate\n");
735 return sprintf(data, "%d\n", bandwidth);
738 /* default attribute files for the MCI object */
739 static ssize_t mci_ue_count_show(struct device *dev,
740 struct device_attribute *mattr,
743 struct mem_ctl_info *mci = to_mci(dev);
745 return sprintf(data, "%d\n", mci->ue_mc);
748 static ssize_t mci_ce_count_show(struct device *dev,
749 struct device_attribute *mattr,
752 struct mem_ctl_info *mci = to_mci(dev);
754 return sprintf(data, "%d\n", mci->ce_mc);
757 static ssize_t mci_ce_noinfo_show(struct device *dev,
758 struct device_attribute *mattr,
761 struct mem_ctl_info *mci = to_mci(dev);
763 return sprintf(data, "%d\n", mci->ce_noinfo_count);
766 static ssize_t mci_ue_noinfo_show(struct device *dev,
767 struct device_attribute *mattr,
770 struct mem_ctl_info *mci = to_mci(dev);
772 return sprintf(data, "%d\n", mci->ue_noinfo_count);
775 static ssize_t mci_seconds_show(struct device *dev,
776 struct device_attribute *mattr,
779 struct mem_ctl_info *mci = to_mci(dev);
781 return sprintf(data, "%ld\n", (jiffies - mci->start_time) / HZ);
784 static ssize_t mci_ctl_name_show(struct device *dev,
785 struct device_attribute *mattr,
788 struct mem_ctl_info *mci = to_mci(dev);
790 return sprintf(data, "%s\n", mci->ctl_name);
793 static ssize_t mci_size_mb_show(struct device *dev,
794 struct device_attribute *mattr,
797 struct mem_ctl_info *mci = to_mci(dev);
798 int total_pages = 0, csrow_idx, j;
800 for (csrow_idx = 0; csrow_idx < mci->nr_csrows; csrow_idx++) {
801 struct csrow_info *csrow = mci->csrows[csrow_idx];
803 for (j = 0; j < csrow->nr_channels; j++) {
804 struct dimm_info *dimm = csrow->channels[j]->dimm;
806 total_pages += dimm->nr_pages;
810 return sprintf(data, "%u\n", PAGES_TO_MiB(total_pages));
813 static ssize_t mci_max_location_show(struct device *dev,
814 struct device_attribute *mattr,
817 struct mem_ctl_info *mci = to_mci(dev);
821 for (i = 0; i < mci->n_layers; i++) {
822 p += sprintf(p, "%s %d ",
823 edac_layer_name[mci->layers[i].type],
824 mci->layers[i].size - 1);
830 /* default Control file */
831 static DEVICE_ATTR(reset_counters, S_IWUSR, NULL, mci_reset_counters_store);
833 /* default Attribute files */
834 static DEVICE_ATTR(mc_name, S_IRUGO, mci_ctl_name_show, NULL);
835 static DEVICE_ATTR(size_mb, S_IRUGO, mci_size_mb_show, NULL);
836 static DEVICE_ATTR(seconds_since_reset, S_IRUGO, mci_seconds_show, NULL);
837 static DEVICE_ATTR(ue_noinfo_count, S_IRUGO, mci_ue_noinfo_show, NULL);
838 static DEVICE_ATTR(ce_noinfo_count, S_IRUGO, mci_ce_noinfo_show, NULL);
839 static DEVICE_ATTR(ue_count, S_IRUGO, mci_ue_count_show, NULL);
840 static DEVICE_ATTR(ce_count, S_IRUGO, mci_ce_count_show, NULL);
841 static DEVICE_ATTR(max_location, S_IRUGO, mci_max_location_show, NULL);
843 /* memory scrubber attribute file */
844 static DEVICE_ATTR(sdram_scrub_rate, 0, mci_sdram_scrub_rate_show,
845 mci_sdram_scrub_rate_store); /* umode set later in is_visible */
847 static struct attribute *mci_attrs[] = {
848 &dev_attr_reset_counters.attr,
849 &dev_attr_mc_name.attr,
850 &dev_attr_size_mb.attr,
851 &dev_attr_seconds_since_reset.attr,
852 &dev_attr_ue_noinfo_count.attr,
853 &dev_attr_ce_noinfo_count.attr,
854 &dev_attr_ue_count.attr,
855 &dev_attr_ce_count.attr,
856 &dev_attr_max_location.attr,
857 &dev_attr_sdram_scrub_rate.attr,
861 static umode_t mci_attr_is_visible(struct kobject *kobj,
862 struct attribute *attr, int idx)
864 struct device *dev = kobj_to_dev(kobj);
865 struct mem_ctl_info *mci = to_mci(dev);
868 if (attr != &dev_attr_sdram_scrub_rate.attr)
870 if (mci->get_sdram_scrub_rate)
872 if (mci->set_sdram_scrub_rate)
877 static const struct attribute_group mci_attr_grp = {
879 .is_visible = mci_attr_is_visible,
882 static const struct attribute_group *mci_attr_groups[] = {
887 static void mci_attr_release(struct device *dev)
889 /* release device with _edac_mc_free() */
892 static const struct device_type mci_attr_type = {
893 .groups = mci_attr_groups,
894 .release = mci_attr_release,
898 * Create a new Memory Controller kobject instance,
899 * mc<id> under the 'mc' directory
905 int edac_create_sysfs_mci_device(struct mem_ctl_info *mci,
906 const struct attribute_group **groups)
908 struct dimm_info *dimm;
911 /* get the /sys/devices/system/edac subsys reference */
912 mci->dev.type = &mci_attr_type;
913 device_initialize(&mci->dev);
915 mci->dev.parent = mci_pdev;
916 mci->dev.groups = groups;
917 dev_set_name(&mci->dev, "mc%d", mci->mc_idx);
918 dev_set_drvdata(&mci->dev, mci);
919 pm_runtime_forbid(&mci->dev);
921 err = device_add(&mci->dev);
923 edac_dbg(1, "failure: create device %s\n", dev_name(&mci->dev));
924 put_device(&mci->dev);
928 edac_dbg(0, "device %s created\n", dev_name(&mci->dev));
931 * Create the dimm/rank devices
933 mci_for_each_dimm(mci, dimm) {
934 /* Only expose populated DIMMs */
938 err = edac_create_dimm_object(mci, dimm);
940 goto fail_unregister_dimm;
943 #ifdef CONFIG_EDAC_LEGACY_SYSFS
944 err = edac_create_csrow_objects(mci);
946 goto fail_unregister_dimm;
949 edac_create_debugfs_nodes(mci);
952 fail_unregister_dimm:
953 mci_for_each_dimm(mci, dimm) {
954 if (device_is_registered(&dimm->dev))
955 device_unregister(&dimm->dev);
957 device_unregister(&mci->dev);
963 * remove a Memory Controller instance
965 void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci)
967 struct dimm_info *dimm;
971 #ifdef CONFIG_EDAC_DEBUG
972 edac_debugfs_remove_recursive(mci->debugfs);
974 #ifdef CONFIG_EDAC_LEGACY_SYSFS
975 edac_delete_csrow_objects(mci);
978 mci_for_each_dimm(mci, dimm) {
979 if (dimm->nr_pages == 0)
981 edac_dbg(1, "unregistering device %s\n", dev_name(&dimm->dev));
982 device_unregister(&dimm->dev);
986 void edac_unregister_sysfs(struct mem_ctl_info *mci)
988 edac_dbg(1, "unregistering device %s\n", dev_name(&mci->dev));
989 device_unregister(&mci->dev);
992 static void mc_attr_release(struct device *dev)
995 * There's no container structure here, as this is just the mci
996 * parent device, used to create the /sys/devices/mc sysfs node.
997 * So, there are no attributes on it.
999 edac_dbg(1, "device %s released\n", dev_name(dev));
1003 static const struct device_type mc_attr_type = {
1004 .release = mc_attr_release,
1007 * Init/exit code for the module. Basically, creates/removes /sys/class/rc
1009 int __init edac_mc_sysfs_init(void)
1013 mci_pdev = kzalloc(sizeof(*mci_pdev), GFP_KERNEL);
1017 mci_pdev->bus = edac_get_sysfs_subsys();
1018 mci_pdev->type = &mc_attr_type;
1019 device_initialize(mci_pdev);
1020 dev_set_name(mci_pdev, "mc");
1022 err = device_add(mci_pdev);
1024 edac_dbg(1, "failure: create device %s\n", dev_name(mci_pdev));
1025 put_device(mci_pdev);
1029 edac_dbg(0, "device %s created\n", dev_name(mci_pdev));
1034 void edac_mc_sysfs_exit(void)
1036 device_unregister(mci_pdev);