drivers/edac/edac_mc_sysfs.c

   1 /*
   2  * edac_mc kernel module
   3  * (C) 2005-2007 Linux Networx (http://lnxi.com)
   4  *
   5  * This file may be distributed under the terms of the
   6  * GNU General Public License.
   7  *
   8  * Written Doug Thompson <norsk5@xmission.com> www.softwarebitmaker.com
   9  *
  10  */
  11
  12 #include <linux/ctype.h>
  13 #include <linux/slab.h>
  14 #include <linux/bug.h>
  15
  16 #include "edac_core.h"
  17 #include "edac_module.h"
  18
  19
  20 /* MC EDAC Controls, setable by module parameter, and sysfs */
  21 static int edac_mc_log_ue = 1;
  22 static int edac_mc_log_ce = 1;
  23 static int edac_mc_panic_on_ue;
  24 static int edac_mc_poll_msec = 1000;
  25
  26 /* Getter functions for above */
  27 int edac_mc_get_log_ue(void)
  28 {
  29         return edac_mc_log_ue;
  30 }
  31
  32 int edac_mc_get_log_ce(void)
  33 {
  34         return edac_mc_log_ce;
  35 }
  36
  37 int edac_mc_get_panic_on_ue(void)
  38 {
  39         return edac_mc_panic_on_ue;
  40 }
  41
  42 /* this is temporary */
  43 int edac_mc_get_poll_msec(void)
  44 {
  45         return edac_mc_poll_msec;
  46 }
  47
  48 static int edac_set_poll_msec(const char *val, struct kernel_param *kp)
  49 {
  50         long l;
  51         int ret;
  52
  53         if (!val)
  54                 return -EINVAL;
  55
  56         ret = strict_strtol(val, 0, &l);
  57         if (ret == -EINVAL || ((int)l != l))
  58                 return -EINVAL;
  59         *((int *)kp->arg) = l;
  60
  61         /* notify edac_mc engine to reset the poll period */
  62         edac_mc_reset_delay_period(l);
  63
  64         return 0;
  65 }
  66
  67 /* Parameter declarations for above */
  68 module_param(edac_mc_panic_on_ue, int, 0644);
  69 MODULE_PARM_DESC(edac_mc_panic_on_ue, "Panic on uncorrected error: 0=off 1=on");
  70 module_param(edac_mc_log_ue, int, 0644);
  71 MODULE_PARM_DESC(edac_mc_log_ue,
  72                  "Log uncorrectable error to console: 0=off 1=on");
  73 module_param(edac_mc_log_ce, int, 0644);
  74 MODULE_PARM_DESC(edac_mc_log_ce,
  75                  "Log correctable error to console: 0=off 1=on");
  76 module_param_call(edac_mc_poll_msec, edac_set_poll_msec, param_get_int,
  77                   &edac_mc_poll_msec, 0644);
  78 MODULE_PARM_DESC(edac_mc_poll_msec, "Polling period in milliseconds");
  79
  80 /*
  81  * various constants for Memory Controllers
  82  */
  83 static const char *mem_types[] = {
  84         [MEM_EMPTY] = "Empty",
  85         [MEM_RESERVED] = "Reserved",
  86         [MEM_UNKNOWN] = "Unknown",
  87         [MEM_FPM] = "FPM",
  88         [MEM_EDO] = "EDO",
  89         [MEM_BEDO] = "BEDO",
  90         [MEM_SDR] = "Unbuffered-SDR",
  91         [MEM_RDR] = "Registered-SDR",
  92         [MEM_DDR] = "Unbuffered-DDR",
  93         [MEM_RDDR] = "Registered-DDR",
  94         [MEM_RMBS] = "RMBS",
  95         [MEM_DDR2] = "Unbuffered-DDR2",
  96         [MEM_FB_DDR2] = "FullyBuffered-DDR2",
  97         [MEM_RDDR2] = "Registered-DDR2",
  98         [MEM_XDR] = "XDR",
  99         [MEM_DDR3] = "Unbuffered-DDR3",
 100         [MEM_RDDR3] = "Registered-DDR3"
 101 };
 102
 103 static const char *dev_types[] = {
 104         [DEV_UNKNOWN] = "Unknown",
 105         [DEV_X1] = "x1",
 106         [DEV_X2] = "x2",
 107         [DEV_X4] = "x4",
 108         [DEV_X8] = "x8",
 109         [DEV_X16] = "x16",
 110         [DEV_X32] = "x32",
 111         [DEV_X64] = "x64"
 112 };
 113
 114 static const char *edac_caps[] = {
 115         [EDAC_UNKNOWN] = "Unknown",
 116         [EDAC_NONE] = "None",
 117         [EDAC_RESERVED] = "Reserved",
 118         [EDAC_PARITY] = "PARITY",
 119         [EDAC_EC] = "EC",
 120         [EDAC_SECDED] = "SECDED",
 121         [EDAC_S2ECD2ED] = "S2ECD2ED",
 122         [EDAC_S4ECD4ED] = "S4ECD4ED",
 123         [EDAC_S8ECD8ED] = "S8ECD8ED",
 124         [EDAC_S16ECD16ED] = "S16ECD16ED"
 125 };
 126
 127 /* EDAC sysfs CSROW data structures and methods
 128  */
 129
 130 /* Set of more default csrow<id> attribute show/store functions */
 131 static ssize_t csrow_ue_count_show(struct csrow_info *csrow, char *data,
 132                                 int private)
 133 {
 134         return sprintf(data, "%u\n", csrow->ue_count);
 135 }
 136
 137 static ssize_t csrow_ce_count_show(struct csrow_info *csrow, char *data,
 138                                 int private)
 139 {
 140         return sprintf(data, "%u\n", csrow->ce_count);
 141 }
 142
 143 static ssize_t csrow_size_show(struct csrow_info *csrow, char *data,
 144                                 int private)
 145 {
 146         return sprintf(data, "%u\n", PAGES_TO_MiB(csrow->nr_pages));
 147 }
 148
 149 static ssize_t csrow_mem_type_show(struct csrow_info *csrow, char *data,
 150                                 int private)
 151 {
 152         return sprintf(data, "%s\n", mem_types[csrow->mtype]);
 153 }
 154
 155 static ssize_t csrow_dev_type_show(struct csrow_info *csrow, char *data,
 156                                 int private)
 157 {
 158         return sprintf(data, "%s\n", dev_types[csrow->dtype]);
 159 }
 160
 161 static ssize_t csrow_edac_mode_show(struct csrow_info *csrow, char *data,
 162                                 int private)
 163 {
 164         return sprintf(data, "%s\n", edac_caps[csrow->edac_mode]);
 165 }
 166
 167 /* show/store functions for DIMM Label attributes */
 168 static ssize_t channel_dimm_label_show(struct csrow_info *csrow,
 169                                 char *data, int channel)
 170 {
 171         /* if field has not been initialized, there is nothing to send */
 172         if (!csrow->channels[channel].label[0])
 173                 return 0;
 174
 175         return snprintf(data, EDAC_MC_LABEL_LEN, "%s\n",
 176                         csrow->channels[channel].label);
 177 }
 178
 179 static ssize_t channel_dimm_label_store(struct csrow_info *csrow,
 180                                         const char *data,
 181                                         size_t count, int channel)
 182 {
 183         ssize_t max_size = 0;
 184
 185         max_size = min((ssize_t) count, (ssize_t) EDAC_MC_LABEL_LEN - 1);
 186         strncpy(csrow->channels[channel].label, data, max_size);
 187         csrow->channels[channel].label[max_size] = '\0';
 188
 189         return max_size;
 190 }
 191
 192 /* show function for dynamic chX_ce_count attribute */
 193 static ssize_t channel_ce_count_show(struct csrow_info *csrow,
 194                                 char *data, int channel)
 195 {
 196         return sprintf(data, "%u\n", csrow->channels[channel].ce_count);
 197 }
 198
 199 /* csrow specific attribute structure */
 200 struct csrowdev_attribute {
 201         struct attribute attr;
 202          ssize_t(*show) (struct csrow_info *, char *, int);
 203          ssize_t(*store) (struct csrow_info *, const char *, size_t, int);
 204         int private;
 205 };
 206
 207 #define to_csrow(k) container_of(k, struct csrow_info, kobj)
 208 #define to_csrowdev_attr(a) container_of(a, struct csrowdev_attribute, attr)
 209
 210 /* Set of show/store higher level functions for default csrow attributes */
 211 static ssize_t csrowdev_show(struct kobject *kobj,
 212                         struct attribute *attr, char *buffer)
 213 {
 214         struct csrow_info *csrow = to_csrow(kobj);
 215         struct csrowdev_attribute *csrowdev_attr = to_csrowdev_attr(attr);
 216
 217         if (csrowdev_attr->show)
 218                 return csrowdev_attr->show(csrow,
 219                                         buffer, csrowdev_attr->private);
 220         return -EIO;
 221 }
 222
 223 static ssize_t csrowdev_store(struct kobject *kobj, struct attribute *attr,
 224                         const char *buffer, size_t count)
 225 {
 226         struct csrow_info *csrow = to_csrow(kobj);
 227         struct csrowdev_attribute *csrowdev_attr = to_csrowdev_attr(attr);
 228
 229         if (csrowdev_attr->store)
 230                 return csrowdev_attr->store(csrow,
 231                                         buffer,
 232                                         count, csrowdev_attr->private);
 233         return -EIO;
 234 }
 235
 236 static const struct sysfs_ops csrowfs_ops = {
 237         .show = csrowdev_show,
 238         .store = csrowdev_store
 239 };
 240
 241 #define CSROWDEV_ATTR(_name,_mode,_show,_store,_private)        \
 242 static struct csrowdev_attribute attr_##_name = {                       \
 243         .attr = {.name = __stringify(_name), .mode = _mode },   \
 244         .show   = _show,                                        \
 245         .store  = _store,                                       \
 246         .private = _private,                                    \
 247 };
 248
 249 /* default cwrow<id>/attribute files */
 250 CSROWDEV_ATTR(size_mb, S_IRUGO, csrow_size_show, NULL, 0);
 251 CSROWDEV_ATTR(dev_type, S_IRUGO, csrow_dev_type_show, NULL, 0);
 252 CSROWDEV_ATTR(mem_type, S_IRUGO, csrow_mem_type_show, NULL, 0);
 253 CSROWDEV_ATTR(edac_mode, S_IRUGO, csrow_edac_mode_show, NULL, 0);
 254 CSROWDEV_ATTR(ue_count, S_IRUGO, csrow_ue_count_show, NULL, 0);
 255 CSROWDEV_ATTR(ce_count, S_IRUGO, csrow_ce_count_show, NULL, 0);
 256
 257 /* default attributes of the CSROW<id> object */
 258 static struct csrowdev_attribute *default_csrow_attr[] = {
 259         &attr_dev_type,
 260         &attr_mem_type,
 261         &attr_edac_mode,
 262         &attr_size_mb,
 263         &attr_ue_count,
 264         &attr_ce_count,
 265         NULL,
 266 };
 267
 268 /* possible dynamic channel DIMM Label attribute files */
 269 CSROWDEV_ATTR(ch0_dimm_label, S_IRUGO | S_IWUSR,
 270         channel_dimm_label_show, channel_dimm_label_store, 0);
 271 CSROWDEV_ATTR(ch1_dimm_label, S_IRUGO | S_IWUSR,
 272         channel_dimm_label_show, channel_dimm_label_store, 1);
 273 CSROWDEV_ATTR(ch2_dimm_label, S_IRUGO | S_IWUSR,
 274         channel_dimm_label_show, channel_dimm_label_store, 2);
 275 CSROWDEV_ATTR(ch3_dimm_label, S_IRUGO | S_IWUSR,
 276         channel_dimm_label_show, channel_dimm_label_store, 3);
 277 CSROWDEV_ATTR(ch4_dimm_label, S_IRUGO | S_IWUSR,
 278         channel_dimm_label_show, channel_dimm_label_store, 4);
 279 CSROWDEV_ATTR(ch5_dimm_label, S_IRUGO | S_IWUSR,
 280         channel_dimm_label_show, channel_dimm_label_store, 5);
 281
 282 /* Total possible dynamic DIMM Label attribute file table */
 283 static struct csrowdev_attribute *dynamic_csrow_dimm_attr[] = {
 284         &attr_ch0_dimm_label,
 285         &attr_ch1_dimm_label,
 286         &attr_ch2_dimm_label,
 287         &attr_ch3_dimm_label,
 288         &attr_ch4_dimm_label,
 289         &attr_ch5_dimm_label
 290 };
 291
 292 /* possible dynamic channel ce_count attribute files */
 293 CSROWDEV_ATTR(ch0_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 0);
 294 CSROWDEV_ATTR(ch1_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 1);
 295 CSROWDEV_ATTR(ch2_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 2);
 296 CSROWDEV_ATTR(ch3_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 3);
 297 CSROWDEV_ATTR(ch4_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 4);
 298 CSROWDEV_ATTR(ch5_ce_count, S_IRUGO | S_IWUSR, channel_ce_count_show, NULL, 5);
 299
 300 /* Total possible dynamic ce_count attribute file table */
 301 static struct csrowdev_attribute *dynamic_csrow_ce_count_attr[] = {
 302         &attr_ch0_ce_count,
 303         &attr_ch1_ce_count,
 304         &attr_ch2_ce_count,
 305         &attr_ch3_ce_count,
 306         &attr_ch4_ce_count,
 307         &attr_ch5_ce_count
 308 };
 309
 310 #define EDAC_NR_CHANNELS        6
 311
 312 /* Create dynamic CHANNEL files, indexed by 'chan',  under specifed CSROW */
 313 static int edac_create_channel_files(struct kobject *kobj, int chan)
 314 {
 315         int err = -ENODEV;
 316
 317         if (chan >= EDAC_NR_CHANNELS)
 318                 return err;
 319
 320         /* create the DIMM label attribute file */
 321         err = sysfs_create_file(kobj,
 322                                 (struct attribute *)
 323                                 dynamic_csrow_dimm_attr[chan]);
 324
 325         if (!err) {
 326                 /* create the CE Count attribute file */
 327                 err = sysfs_create_file(kobj,
 328                                         (struct attribute *)
 329                                         dynamic_csrow_ce_count_attr[chan]);
 330         } else {
 331                 debugf1("%s()  dimm labels and ce_count files created",
 332                         __func__);
 333         }
 334
 335         return err;
 336 }
 337
 338 /* No memory to release for this kobj */
 339 static void edac_csrow_instance_release(struct kobject *kobj)
 340 {
 341         struct mem_ctl_info *mci;
 342         struct csrow_info *cs;
 343
 344         debugf1("%s()\n", __func__);
 345
 346         cs = container_of(kobj, struct csrow_info, kobj);
 347         mci = cs->mci;
 348
 349         kobject_put(&mci->edac_mci_kobj);
 350 }
 351
 352 /* the kobj_type instance for a CSROW */
 353 static struct kobj_type ktype_csrow = {
 354         .release = edac_csrow_instance_release,
 355         .sysfs_ops = &csrowfs_ops,
 356         .default_attrs = (struct attribute **)default_csrow_attr,
 357 };
 358
 359 /* Create a CSROW object under specifed edac_mc_device */
 360 static int edac_create_csrow_object(struct mem_ctl_info *mci,
 361                                         struct csrow_info *csrow, int index)
 362 {
 363         struct kobject *kobj_mci = &mci->edac_mci_kobj;
 364         struct kobject *kobj;
 365         int chan;
 366         int err;
 367
 368         /* generate ..../edac/mc/mc<id>/csrow<index>   */
 369         memset(&csrow->kobj, 0, sizeof(csrow->kobj));
 370         csrow->mci = mci;       /* include container up link */
 371
 372         /* bump the mci instance's kobject's ref count */
 373         kobj = kobject_get(&mci->edac_mci_kobj);
 374         if (!kobj) {
 375                 err = -ENODEV;
 376                 goto err_out;
 377         }
 378
 379         /* Instanstiate the csrow object */
 380         err = kobject_init_and_add(&csrow->kobj, &ktype_csrow, kobj_mci,
 381                                    "csrow%d", index);
 382         if (err)
 383                 goto err_release_top_kobj;
 384
 385         /* At this point, to release a csrow kobj, one must
 386          * call the kobject_put and allow that tear down
 387          * to work the releasing
 388          */
 389
 390         /* Create the dyanmic attribute files on this csrow,
 391          * namely, the DIMM labels and the channel ce_count
 392          */
 393         for (chan = 0; chan < csrow->nr_channels; chan++) {
 394                 err = edac_create_channel_files(&csrow->kobj, chan);
 395                 if (err) {
 396                         /* special case the unregister here */
 397                         kobject_put(&csrow->kobj);
 398                         goto err_out;
 399                 }
 400         }
 401         kobject_uevent(&csrow->kobj, KOBJ_ADD);
 402         return 0;
 403
 404         /* error unwind stack */
 405 err_release_top_kobj:
 406         kobject_put(&mci->edac_mci_kobj);
 407
 408 err_out:
 409         return err;
 410 }
 411
 412 /* default sysfs methods and data structures for the main MCI kobject */
 413
 414 static ssize_t mci_reset_counters_store(struct mem_ctl_info *mci,
 415                                         const char *data, size_t count)
 416 {
 417         int row, chan;
 418
 419         mci->ue_noinfo_count = 0;
 420         mci->ce_noinfo_count = 0;
 421         mci->ue_count = 0;
 422         mci->ce_count = 0;
 423
 424         for (row = 0; row < mci->nr_csrows; row++) {
 425                 struct csrow_info *ri = &mci->csrows[row];
 426
 427                 ri->ue_count = 0;
 428                 ri->ce_count = 0;
 429
 430                 for (chan = 0; chan < ri->nr_channels; chan++)
 431                         ri->channels[chan].ce_count = 0;
 432         }
 433
 434         mci->start_time = jiffies;
 435         return count;
 436 }
 437
 438 /* memory scrubbing */
 439 static ssize_t mci_sdram_scrub_rate_store(struct mem_ctl_info *mci,
 440                                           const char *data, size_t count)
 441 {
 442         unsigned long bandwidth = 0;
 443         int err;
 444
 445         if (!mci->set_sdram_scrub_rate) {
 446                 edac_printk(KERN_WARNING, EDAC_MC,
 447                             "Memory scrub rate setting not implemented!\n");
 448                 return -EINVAL;
 449         }
 450
 451         if (strict_strtoul(data, 10, &bandwidth) < 0)
 452                 return -EINVAL;
 453
 454         err = mci->set_sdram_scrub_rate(mci, (u32)bandwidth);
 455         if (err) {
 456                 edac_printk(KERN_DEBUG, EDAC_MC,
 457                             "Failed setting scrub rate to %lu\n", bandwidth);
 458                 return -EINVAL;
 459         }
 460         else {
 461                 edac_printk(KERN_DEBUG, EDAC_MC,
 462                             "Scrub rate set to: %lu\n", bandwidth);
 463                 return count;
 464         }
 465 }
 466
 467 static ssize_t mci_sdram_scrub_rate_show(struct mem_ctl_info *mci, char *data)
 468 {
 469         u32 bandwidth = 0;
 470         int err;
 471
 472         if (!mci->get_sdram_scrub_rate) {
 473                 edac_printk(KERN_WARNING, EDAC_MC,
 474                             "Memory scrub rate reading not implemented\n");
 475                 return -EINVAL;
 476         }
 477
 478         err = mci->get_sdram_scrub_rate(mci, &bandwidth);
 479         if (err) {
 480                 edac_printk(KERN_DEBUG, EDAC_MC, "Error reading scrub rate\n");
 481                 return err;
 482         }
 483         else {
 484                 edac_printk(KERN_DEBUG, EDAC_MC,
 485                             "Read scrub rate: %d\n", bandwidth);
 486                 return sprintf(data, "%d\n", bandwidth);
 487         }
 488 }
 489
 490 /* default attribute files for the MCI object */
 491 static ssize_t mci_ue_count_show(struct mem_ctl_info *mci, char *data)
 492 {
 493         return sprintf(data, "%d\n", mci->ue_count);
 494 }
 495
 496 static ssize_t mci_ce_count_show(struct mem_ctl_info *mci, char *data)
 497 {
 498         return sprintf(data, "%d\n", mci->ce_count);
 499 }
 500
 501 static ssize_t mci_ce_noinfo_show(struct mem_ctl_info *mci, char *data)
 502 {
 503         return sprintf(data, "%d\n", mci->ce_noinfo_count);
 504 }
 505
 506 static ssize_t mci_ue_noinfo_show(struct mem_ctl_info *mci, char *data)
 507 {
 508         return sprintf(data, "%d\n", mci->ue_noinfo_count);
 509 }
 510
 511 static ssize_t mci_seconds_show(struct mem_ctl_info *mci, char *data)
 512 {
 513         return sprintf(data, "%ld\n", (jiffies - mci->start_time) / HZ);
 514 }
 515
 516 static ssize_t mci_ctl_name_show(struct mem_ctl_info *mci, char *data)
 517 {
 518         return sprintf(data, "%s\n", mci->ctl_name);
 519 }
 520
 521 static ssize_t mci_size_mb_show(struct mem_ctl_info *mci, char *data)
 522 {
 523         int total_pages, csrow_idx;
 524
 525         for (total_pages = csrow_idx = 0; csrow_idx < mci->nr_csrows;
 526                 csrow_idx++) {
 527                 struct csrow_info *csrow = &mci->csrows[csrow_idx];
 528
 529                 if (!csrow->nr_pages)
 530                         continue;
 531
 532                 total_pages += csrow->nr_pages;
 533         }
 534
 535         return sprintf(data, "%u\n", PAGES_TO_MiB(total_pages));
 536 }
 537
 538 #define to_mci(k) container_of(k, struct mem_ctl_info, edac_mci_kobj)
 539 #define to_mcidev_attr(a) container_of(a,struct mcidev_sysfs_attribute,attr)
 540
 541 /* MCI show/store functions for top most object */
 542 static ssize_t mcidev_show(struct kobject *kobj, struct attribute *attr,
 543                         char *buffer)
 544 {
 545         struct mem_ctl_info *mem_ctl_info = to_mci(kobj);
 546         struct mcidev_sysfs_attribute *mcidev_attr = to_mcidev_attr(attr);
 547
 548         debugf1("%s() mem_ctl_info %p\n", __func__, mem_ctl_info);
 549
 550         if (mcidev_attr->show)
 551                 return mcidev_attr->show(mem_ctl_info, buffer);
 552
 553         return -EIO;
 554 }
 555
 556 static ssize_t mcidev_store(struct kobject *kobj, struct attribute *attr,
 557                         const char *buffer, size_t count)
 558 {
 559         struct mem_ctl_info *mem_ctl_info = to_mci(kobj);
 560         struct mcidev_sysfs_attribute *mcidev_attr = to_mcidev_attr(attr);
 561
 562         debugf1("%s() mem_ctl_info %p\n", __func__, mem_ctl_info);
 563
 564         if (mcidev_attr->store)
 565                 return mcidev_attr->store(mem_ctl_info, buffer, count);
 566
 567         return -EIO;
 568 }
 569
 570 /* Intermediate show/store table */
 571 static const struct sysfs_ops mci_ops = {
 572         .show = mcidev_show,
 573         .store = mcidev_store
 574 };
 575
 576 #define MCIDEV_ATTR(_name,_mode,_show,_store)                   \
 577 static struct mcidev_sysfs_attribute mci_attr_##_name = {                       \
 578         .attr = {.name = __stringify(_name), .mode = _mode },   \
 579         .show   = _show,                                        \
 580         .store  = _store,                                       \
 581 };
 582
 583 /* default Control file */
 584 MCIDEV_ATTR(reset_counters, S_IWUSR, NULL, mci_reset_counters_store);
 585
 586 /* default Attribute files */
 587 MCIDEV_ATTR(mc_name, S_IRUGO, mci_ctl_name_show, NULL);
 588 MCIDEV_ATTR(size_mb, S_IRUGO, mci_size_mb_show, NULL);
 589 MCIDEV_ATTR(seconds_since_reset, S_IRUGO, mci_seconds_show, NULL);
 590 MCIDEV_ATTR(ue_noinfo_count, S_IRUGO, mci_ue_noinfo_show, NULL);
 591 MCIDEV_ATTR(ce_noinfo_count, S_IRUGO, mci_ce_noinfo_show, NULL);
 592 MCIDEV_ATTR(ue_count, S_IRUGO, mci_ue_count_show, NULL);
 593 MCIDEV_ATTR(ce_count, S_IRUGO, mci_ce_count_show, NULL);
 594
 595 /* memory scrubber attribute file */
 596 MCIDEV_ATTR(sdram_scrub_rate, S_IRUGO | S_IWUSR, mci_sdram_scrub_rate_show,
 597         mci_sdram_scrub_rate_store);
 598
 599 static struct mcidev_sysfs_attribute *mci_attr[] = {
 600         &mci_attr_reset_counters,
 601         &mci_attr_mc_name,
 602         &mci_attr_size_mb,
 603         &mci_attr_seconds_since_reset,
 604         &mci_attr_ue_noinfo_count,
 605         &mci_attr_ce_noinfo_count,
 606         &mci_attr_ue_count,
 607         &mci_attr_ce_count,
 608         &mci_attr_sdram_scrub_rate,
 609         NULL
 610 };
 611
 612
 613 /*
 614  * Release of a MC controlling instance
 615  *
 616  *      each MC control instance has the following resources upon entry:
 617  *              a) a ref count on the top memctl kobj
 618  *              b) a ref count on this module
 619  *
 620  *      this function must decrement those ref counts and then
 621  *      issue a free on the instance's memory
 622  */
 623 static void edac_mci_control_release(struct kobject *kobj)
 624 {
 625         struct mem_ctl_info *mci;
 626
 627         mci = to_mci(kobj);
 628
 629         debugf0("%s() mci instance idx=%d releasing\n", __func__, mci->mc_idx);
 630
 631         /* decrement the module ref count */
 632         module_put(mci->owner);
 633
 634         /* free the mci instance memory here */
 635         kfree(mci);
 636 }
 637
 638 static struct kobj_type ktype_mci = {
 639         .release = edac_mci_control_release,
 640         .sysfs_ops = &mci_ops,
 641         .default_attrs = (struct attribute **)mci_attr,
 642 };
 643
 644 /* EDAC memory controller sysfs kset:
 645  *      /sys/devices/system/edac/mc
 646  */
 647 static struct kset *mc_kset;
 648
 649 /*
 650  * edac_mc_register_sysfs_main_kobj
 651  *
 652  *      setups and registers the main kobject for each mci
 653  */
 654 int edac_mc_register_sysfs_main_kobj(struct mem_ctl_info *mci)
 655 {
 656         struct kobject *kobj_mci;
 657         int err;
 658
 659         debugf1("%s()\n", __func__);
 660
 661         kobj_mci = &mci->edac_mci_kobj;
 662
 663         /* Init the mci's kobject */
 664         memset(kobj_mci, 0, sizeof(*kobj_mci));
 665
 666         /* Record which module 'owns' this control structure
 667          * and bump the ref count of the module
 668          */
 669         mci->owner = THIS_MODULE;
 670
 671         /* bump ref count on this module */
 672         if (!try_module_get(mci->owner)) {
 673                 err = -ENODEV;
 674                 goto fail_out;
 675         }
 676
 677         /* this instance become part of the mc_kset */
 678         kobj_mci->kset = mc_kset;
 679
 680         /* register the mc<id> kobject to the mc_kset */
 681         err = kobject_init_and_add(kobj_mci, &ktype_mci, NULL,
 682                                    "mc%d", mci->mc_idx);
 683         if (err) {
 684                 debugf1("%s()Failed to register '.../edac/mc%d'\n",
 685                         __func__, mci->mc_idx);
 686                 goto kobj_reg_fail;
 687         }
 688         kobject_uevent(kobj_mci, KOBJ_ADD);
 689
 690         /* At this point, to 'free' the control struct,
 691          * edac_mc_unregister_sysfs_main_kobj() must be used
 692          */
 693
 694         debugf1("%s() Registered '.../edac/mc%d' kobject\n",
 695                 __func__, mci->mc_idx);
 696
 697         return 0;
 698
 699         /* Error exit stack */
 700
 701 kobj_reg_fail:
 702         module_put(mci->owner);
 703
 704 fail_out:
 705         return err;
 706 }
 707
 708 /*
 709  * edac_mc_register_sysfs_main_kobj
 710  *
 711  *      tears down and the main mci kobject from the mc_kset
 712  */
 713 void edac_mc_unregister_sysfs_main_kobj(struct mem_ctl_info *mci)
 714 {
 715         /* delete the kobj from the mc_kset */
 716         kobject_put(&mci->edac_mci_kobj);
 717 }
 718
 719 #define EDAC_DEVICE_SYMLINK     "device"
 720
 721 #define grp_to_mci(k) (container_of(k, struct mcidev_sysfs_group_kobj, kobj)->mci)
 722
 723 /* MCI show/store functions for top most object */
 724 static ssize_t inst_grp_show(struct kobject *kobj, struct attribute *attr,
 725                         char *buffer)
 726 {
 727         struct mem_ctl_info *mem_ctl_info = grp_to_mci(kobj);
 728         struct mcidev_sysfs_attribute *mcidev_attr = to_mcidev_attr(attr);
 729
 730         debugf1("%s() mem_ctl_info %p\n", __func__, mem_ctl_info);
 731
 732         if (mcidev_attr->show)
 733                 return mcidev_attr->show(mem_ctl_info, buffer);
 734
 735         return -EIO;
 736 }
 737
 738 static ssize_t inst_grp_store(struct kobject *kobj, struct attribute *attr,
 739                         const char *buffer, size_t count)
 740 {
 741         struct mem_ctl_info *mem_ctl_info = grp_to_mci(kobj);
 742         struct mcidev_sysfs_attribute *mcidev_attr = to_mcidev_attr(attr);
 743
 744         debugf1("%s() mem_ctl_info %p\n", __func__, mem_ctl_info);
 745
 746         if (mcidev_attr->store)
 747                 return mcidev_attr->store(mem_ctl_info, buffer, count);
 748
 749         return -EIO;
 750 }
 751
 752 /* No memory to release for this kobj */
 753 static void edac_inst_grp_release(struct kobject *kobj)
 754 {
 755         struct mcidev_sysfs_group_kobj *grp;
 756         struct mem_ctl_info *mci;
 757
 758         debugf1("%s()\n", __func__);
 759
 760         grp = container_of(kobj, struct mcidev_sysfs_group_kobj, kobj);
 761         mci = grp->mci;
 762
 763         kobject_put(&mci->edac_mci_kobj);
 764 }
 765
 766 /* Intermediate show/store table */
 767 static struct sysfs_ops inst_grp_ops = {
 768         .show = inst_grp_show,
 769         .store = inst_grp_store
 770 };
 771
 772 /* the kobj_type instance for a instance group */
 773 static struct kobj_type ktype_inst_grp = {
 774         .release = edac_inst_grp_release,
 775         .sysfs_ops = &inst_grp_ops,
 776 };
 777
 778
 779 /*
 780  * edac_create_mci_instance_attributes
 781  *      create MC driver specific attributes bellow an specified kobj
 782  * This routine calls itself recursively, in order to create an entire
 783  * object tree.
 784  */
 785 static int edac_create_mci_instance_attributes(struct mem_ctl_info *mci,
 786                                 struct mcidev_sysfs_attribute *sysfs_attrib,
 787                                 struct kobject *kobj)
 788 {
 789         int err;
 790
 791         debugf1("%s()\n", __func__);
 792
 793         while (sysfs_attrib) {
 794                 if (sysfs_attrib->grp) {
 795                         struct mcidev_sysfs_group_kobj *grp_kobj;
 796
 797                         grp_kobj = kzalloc(sizeof(*grp_kobj), GFP_KERNEL);
 798                         if (!grp_kobj)
 799                                 return -ENOMEM;
 800
 801                         list_add_tail(&grp_kobj->list, &mci->grp_kobj_list);
 802
 803                         grp_kobj->grp = sysfs_attrib->grp;
 804                         grp_kobj->mci = mci;
 805
 806                         debugf0("%s() grp %s, mci %p\n", __func__,
 807                                 sysfs_attrib->grp->name, mci);
 808
 809                         err = kobject_init_and_add(&grp_kobj->kobj,
 810                                                 &ktype_inst_grp,
 811                                                 &mci->edac_mci_kobj,
 812                                                 sysfs_attrib->grp->name);
 813                         if (err)
 814                                 return err;
 815
 816                         err = edac_create_mci_instance_attributes(mci,
 817                                         grp_kobj->grp->mcidev_attr,
 818                                         &grp_kobj->kobj);
 819
 820                         if (err)
 821                                 return err;
 822                 } else if (sysfs_attrib->attr.name) {
 823                         debugf0("%s() file %s\n", __func__,
 824                                 sysfs_attrib->attr.name);
 825
 826                         err = sysfs_create_file(kobj, &sysfs_attrib->attr);
 827                 } else
 828                         break;
 829
 830                 if (err) {
 831                         return err;
 832                 }
 833                 sysfs_attrib++;
 834         }
 835
 836         return 0;
 837 }
 838
 839 /*
 840  * edac_remove_mci_instance_attributes
 841  *      remove MC driver specific attributes at the topmost level
 842  *      directory of this mci instance.
 843  */
 844 static void edac_remove_mci_instance_attributes(struct mem_ctl_info *mci,
 845                                 struct mcidev_sysfs_attribute *sysfs_attrib,
 846                                 struct kobject *kobj, int count)
 847 {
 848         struct mcidev_sysfs_group_kobj *grp_kobj, *tmp;
 849
 850         debugf1("%s()\n", __func__);
 851
 852         /*
 853          * loop if there are attributes and until we hit a NULL entry
 854          * Remove first all the atributes
 855          */
 856         while (sysfs_attrib) {
 857                 if (sysfs_attrib->grp) {
 858                         list_for_each_entry(grp_kobj, &mci->grp_kobj_list,
 859                                             list)
 860                                 if (grp_kobj->grp == sysfs_attrib->grp)
 861                                         edac_remove_mci_instance_attributes(mci,
 862                                                     grp_kobj->grp->mcidev_attr,
 863                                                     &grp_kobj->kobj, count + 1);
 864                 } else if (sysfs_attrib->attr.name) {
 865                         debugf0("%s() file %s\n", __func__,
 866                                 sysfs_attrib->attr.name);
 867                         sysfs_remove_file(kobj, &sysfs_attrib->attr);
 868                 } else
 869                         break;
 870                 sysfs_attrib++;
 871         }
 872
 873         /*
 874          * Now that all attributes got removed, it is save to remove all groups
 875          */
 876         if (!count)
 877                 list_for_each_entry_safe(grp_kobj, tmp, &mci->grp_kobj_list,
 878                                          list) {
 879                         debugf0("%s() grp %s\n", __func__, grp_kobj->grp->name);
 880                         kobject_put(&grp_kobj->kobj);
 881                 }
 882 }
 883
 884
 885 /*
 886  * Create a new Memory Controller kobject instance,
 887  *      mc<id> under the 'mc' directory
 888  *
 889  * Return:
 890  *      0       Success
 891  *      !0      Failure
 892  */
 893 int edac_create_sysfs_mci_device(struct mem_ctl_info *mci)
 894 {
 895         int i;
 896         int err;
 897         struct csrow_info *csrow;
 898         struct kobject *kobj_mci = &mci->edac_mci_kobj;
 899
 900         debugf0("%s() idx=%d\n", __func__, mci->mc_idx);
 901
 902         INIT_LIST_HEAD(&mci->grp_kobj_list);
 903
 904         /* create a symlink for the device */
 905         err = sysfs_create_link(kobj_mci, &mci->dev->kobj,
 906                                 EDAC_DEVICE_SYMLINK);
 907         if (err) {
 908                 debugf1("%s() failure to create symlink\n", __func__);
 909                 goto fail0;
 910         }
 911
 912         /* If the low level driver desires some attributes,
 913          * then create them now for the driver.
 914          */
 915         if (mci->mc_driver_sysfs_attributes) {
 916                 err = edac_create_mci_instance_attributes(mci,
 917                                         mci->mc_driver_sysfs_attributes,
 918                                         &mci->edac_mci_kobj);
 919                 if (err) {
 920                         debugf1("%s() failure to create mci attributes\n",
 921                                 __func__);
 922                         goto fail0;
 923                 }
 924         }
 925
 926         /* Make directories for each CSROW object under the mc<id> kobject
 927          */
 928         for (i = 0; i < mci->nr_csrows; i++) {
 929                 csrow = &mci->csrows[i];
 930
 931                 /* Only expose populated CSROWs */
 932                 if (csrow->nr_pages > 0) {
 933                         err = edac_create_csrow_object(mci, csrow, i);
 934                         if (err) {
 935                                 debugf1("%s() failure: create csrow %d obj\n",
 936                                         __func__, i);
 937                                 goto fail1;
 938                         }
 939                 }
 940         }
 941
 942         return 0;
 943
 944         /* CSROW error: backout what has already been registered,  */
 945 fail1:
 946         for (i--; i >= 0; i--) {
 947                 if (csrow->nr_pages > 0) {
 948                         kobject_put(&mci->csrows[i].kobj);
 949                 }
 950         }
 951
 952         /* remove the mci instance's attributes, if any */
 953         edac_remove_mci_instance_attributes(mci,
 954                 mci->mc_driver_sysfs_attributes, &mci->edac_mci_kobj, 0);
 955
 956         /* remove the symlink */
 957         sysfs_remove_link(kobj_mci, EDAC_DEVICE_SYMLINK);
 958
 959 fail0:
 960         return err;
 961 }
 962
 963 /*
 964  * remove a Memory Controller instance
 965  */
 966 void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci)
 967 {
 968         int i;
 969
 970         debugf0("%s()\n", __func__);
 971
 972         /* remove all csrow kobjects */
 973         for (i = 0; i < mci->nr_csrows; i++) {
 974                 if (mci->csrows[i].nr_pages > 0) {
 975                         debugf0("%s()  unreg csrow-%d\n", __func__, i);
 976                         kobject_put(&mci->csrows[i].kobj);
 977                 }
 978         }
 979
 980         debugf0("%s()  remove_link\n", __func__);
 981
 982         /* remove the symlink */
 983         sysfs_remove_link(&mci->edac_mci_kobj, EDAC_DEVICE_SYMLINK);
 984
 985         debugf0("%s()  remove_mci_instance\n", __func__);
 986
 987         /* remove this mci instance's attribtes */
 988         edac_remove_mci_instance_attributes(mci,
 989                                             mci->mc_driver_sysfs_attributes,
 990                                             &mci->edac_mci_kobj, 0);
 991         debugf0("%s()  unregister this mci kobj\n", __func__);
 992
 993         /* unregister this instance's kobject */
 994         kobject_put(&mci->edac_mci_kobj);
 995 }
 996
 997
 998
 999
1000 /*
1001  * edac_setup_sysfs_mc_kset(void)
1002  *
1003  * Initialize the mc_kset for the 'mc' entry
1004  *      This requires creating the top 'mc' directory with a kset
1005  *      and its controls/attributes.
1006  *
1007  *      To this 'mc' kset, instance 'mci' will be grouped as children.
1008  *
1009  * Return:  0 SUCCESS
1010  *         !0 FAILURE error code
1011  */
1012 int edac_sysfs_setup_mc_kset(void)
1013 {
1014         int err = 0;
1015         struct sysdev_class *edac_class;
1016
1017         debugf1("%s()\n", __func__);
1018
1019         /* get the /sys/devices/system/edac class reference */
1020         edac_class = edac_get_edac_class();
1021         if (edac_class == NULL) {
1022                 debugf1("%s() no edac_class error=%d\n", __func__, err);
1023                 goto fail_out;
1024         }
1025
1026         /* Init the MC's kobject */
1027         mc_kset = kset_create_and_add("mc", NULL, &edac_class->kset.kobj);
1028         if (!mc_kset) {
1029                 err = -ENOMEM;
1030                 debugf1("%s() Failed to register '.../edac/mc'\n", __func__);
1031                 goto fail_out;
1032         }
1033
1034         debugf1("%s() Registered '.../edac/mc' kobject\n", __func__);
1035
1036         return 0;
1037
1038
1039         /* error unwind stack */
1040 fail_out:
1041         return err;
1042 }
1043
1044 /*
1045  * edac_sysfs_teardown_mc_kset
1046  *
1047  *      deconstruct the mc_ket for memory controllers
1048  */
1049 void edac_sysfs_teardown_mc_kset(void)
1050 {
1051         kset_unregister(mc_kset);
1052 }
1053