drivers/edac/edac_mc.c

   1 /*
   2  * edac_mc kernel module
   3  * (C) 2005, 2006 Linux Networx (http://lnxi.com)
   4  * This file may be distributed under the terms of the
   5  * GNU General Public License.
   6  *
   7  * Written by Thayne Harbaugh
   8  * Based on work by Dan Hollis <goemon at anime dot net> and others.
   9  *      http://www.anime.net/~goemon/linux-ecc/
  10  *
  11  * Modified by Dave Peterson and Doug Thompson
  12  *
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/kernel.h>
  18 #include <linux/types.h>
  19 #include <linux/smp.h>
  20 #include <linux/init.h>
  21 #include <linux/sysctl.h>
  22 #include <linux/highmem.h>
  23 #include <linux/timer.h>
  24 #include <linux/slab.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/spinlock.h>
  27 #include <linux/list.h>
  28 #include <linux/ctype.h>
  29 #include <linux/edac.h>
  30 #include <linux/bitops.h>
  31 #include <asm/uaccess.h>
  32 #include <asm/page.h>
  33 #include <asm/edac.h>
  34 #include "edac_core.h"
  35 #include "edac_module.h"
  36
  37 #define CREATE_TRACE_POINTS
  38 #define TRACE_INCLUDE_PATH ../../include/ras
  39 #include <ras/ras_event.h>
  40
  41 /* lock to memory controller's control array */
  42 static DEFINE_MUTEX(mem_ctls_mutex);
  43 static LIST_HEAD(mc_devices);
  44
  45 unsigned edac_dimm_info_location(struct dimm_info *dimm, char *buf,
  46                                  unsigned len)
  47 {
  48         struct mem_ctl_info *mci = dimm->mci;
  49         int i, n, count = 0;
  50         char *p = buf;
  51
  52         for (i = 0; i < mci->n_layers; i++) {
  53                 n = snprintf(p, len, "%s %d ",
  54                               edac_layer_name[mci->layers[i].type],
  55                               dimm->location[i]);
  56                 p += n;
  57                 len -= n;
  58                 count += n;
  59                 if (!len)
  60                         break;
  61         }
  62
  63         return count;
  64 }
  65
  66 #ifdef CONFIG_EDAC_DEBUG
  67
  68 static void edac_mc_dump_channel(struct rank_info *chan)
  69 {
  70         edac_dbg(4, "  channel->chan_idx = %d\n", chan->chan_idx);
  71         edac_dbg(4, "    channel = %p\n", chan);
  72         edac_dbg(4, "    channel->csrow = %p\n", chan->csrow);
  73         edac_dbg(4, "    channel->dimm = %p\n", chan->dimm);
  74 }
  75
  76 static void edac_mc_dump_dimm(struct dimm_info *dimm, int number)
  77 {
  78         char location[80];
  79
  80         edac_dimm_info_location(dimm, location, sizeof(location));
  81
  82         edac_dbg(4, "%s%i: %smapped as virtual row %d, chan %d\n",
  83                  dimm->mci->mem_is_per_rank ? "rank" : "dimm",
  84                  number, location, dimm->csrow, dimm->cschannel);
  85         edac_dbg(4, "  dimm = %p\n", dimm);
  86         edac_dbg(4, "  dimm->label = '%s'\n", dimm->label);
  87         edac_dbg(4, "  dimm->nr_pages = 0x%x\n", dimm->nr_pages);
  88         edac_dbg(4, "  dimm->grain = %d\n", dimm->grain);
  89         edac_dbg(4, "  dimm->nr_pages = 0x%x\n", dimm->nr_pages);
  90 }
  91
  92 static void edac_mc_dump_csrow(struct csrow_info *csrow)
  93 {
  94         edac_dbg(4, "csrow->csrow_idx = %d\n", csrow->csrow_idx);
  95         edac_dbg(4, "  csrow = %p\n", csrow);
  96         edac_dbg(4, "  csrow->first_page = 0x%lx\n", csrow->first_page);
  97         edac_dbg(4, "  csrow->last_page = 0x%lx\n", csrow->last_page);
  98         edac_dbg(4, "  csrow->page_mask = 0x%lx\n", csrow->page_mask);
  99         edac_dbg(4, "  csrow->nr_channels = %d\n", csrow->nr_channels);
 100         edac_dbg(4, "  csrow->channels = %p\n", csrow->channels);
 101         edac_dbg(4, "  csrow->mci = %p\n", csrow->mci);
 102 }
 103
 104 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
 105 {
 106         edac_dbg(3, "\tmci = %p\n", mci);
 107         edac_dbg(3, "\tmci->mtype_cap = %lx\n", mci->mtype_cap);
 108         edac_dbg(3, "\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
 109         edac_dbg(3, "\tmci->edac_cap = %lx\n", mci->edac_cap);
 110         edac_dbg(4, "\tmci->edac_check = %p\n", mci->edac_check);
 111         edac_dbg(3, "\tmci->nr_csrows = %d, csrows = %p\n",
 112                  mci->nr_csrows, mci->csrows);
 113         edac_dbg(3, "\tmci->nr_dimms = %d, dimms = %p\n",
 114                  mci->tot_dimms, mci->dimms);
 115         edac_dbg(3, "\tdev = %p\n", mci->pdev);
 116         edac_dbg(3, "\tmod_name:ctl_name = %s:%s\n",
 117                  mci->mod_name, mci->ctl_name);
 118         edac_dbg(3, "\tpvt_info = %p\n\n", mci->pvt_info);
 119 }
 120
 121 #endif                          /* CONFIG_EDAC_DEBUG */
 122
 123 /*
 124  * keep those in sync with the enum mem_type
 125  */
 126 const char *edac_mem_types[] = {
 127         "Empty csrow",
 128         "Reserved csrow type",
 129         "Unknown csrow type",
 130         "Fast page mode RAM",
 131         "Extended data out RAM",
 132         "Burst Extended data out RAM",
 133         "Single data rate SDRAM",
 134         "Registered single data rate SDRAM",
 135         "Double data rate SDRAM",
 136         "Registered Double data rate SDRAM",
 137         "Rambus DRAM",
 138         "Unbuffered DDR2 RAM",
 139         "Fully buffered DDR2",
 140         "Registered DDR2 RAM",
 141         "Rambus XDR",
 142         "Unbuffered DDR3 RAM",
 143         "Registered DDR3 RAM",
 144 };
 145 EXPORT_SYMBOL_GPL(edac_mem_types);
 146
 147 /**
 148  * edac_align_ptr - Prepares the pointer offsets for a single-shot allocation
 149  * @p:          pointer to a pointer with the memory offset to be used. At
 150  *              return, this will be incremented to point to the next offset
 151  * @size:       Size of the data structure to be reserved
 152  * @n_elems:    Number of elements that should be reserved
 153  *
 154  * If 'size' is a constant, the compiler will optimize this whole function
 155  * down to either a no-op or the addition of a constant to the value of '*p'.
 156  *
 157  * The 'p' pointer is absolutely needed to keep the proper advancing
 158  * further in memory to the proper offsets when allocating the struct along
 159  * with its embedded structs, as edac_device_alloc_ctl_info() does it
 160  * above, for example.
 161  *
 162  * At return, the pointer 'p' will be incremented to be used on a next call
 163  * to this function.
 164  */
 165 void *edac_align_ptr(void **p, unsigned size, int n_elems)
 166 {
 167         unsigned align, r;
 168         void *ptr = *p;
 169
 170         *p += size * n_elems;
 171
 172         /*
 173          * 'p' can possibly be an unaligned item X such that sizeof(X) is
 174          * 'size'.  Adjust 'p' so that its alignment is at least as
 175          * stringent as what the compiler would provide for X and return
 176          * the aligned result.
 177          * Here we assume that the alignment of a "long long" is the most
 178          * stringent alignment that the compiler will ever provide by default.
 179          * As far as I know, this is a reasonable assumption.
 180          */
 181         if (size > sizeof(long))
 182                 align = sizeof(long long);
 183         else if (size > sizeof(int))
 184                 align = sizeof(long);
 185         else if (size > sizeof(short))
 186                 align = sizeof(int);
 187         else if (size > sizeof(char))
 188                 align = sizeof(short);
 189         else
 190                 return (char *)ptr;
 191
 192         r = size % align;
 193
 194         if (r == 0)
 195                 return (char *)ptr;
 196
 197         *p += align - r;
 198
 199         return (void *)(((unsigned long)ptr) + align - r);
 200 }
 201
 202 /**
 203  * edac_mc_alloc: Allocate and partially fill a struct mem_ctl_info structure
 204  * @mc_num:             Memory controller number
 205  * @n_layers:           Number of MC hierarchy layers
 206  * layers:              Describes each layer as seen by the Memory Controller
 207  * @size_pvt:           size of private storage needed
 208  *
 209  *
 210  * Everything is kmalloc'ed as one big chunk - more efficient.
 211  * Only can be used if all structures have the same lifetime - otherwise
 212  * you have to allocate and initialize your own structures.
 213  *
 214  * Use edac_mc_free() to free mc structures allocated by this function.
 215  *
 216  * NOTE: drivers handle multi-rank memories in different ways: in some
 217  * drivers, one multi-rank memory stick is mapped as one entry, while, in
 218  * others, a single multi-rank memory stick would be mapped into several
 219  * entries. Currently, this function will allocate multiple struct dimm_info
 220  * on such scenarios, as grouping the multiple ranks require drivers change.
 221  *
 222  * Returns:
 223  *      On failure: NULL
 224  *      On success: struct mem_ctl_info pointer
 225  */
 226 struct mem_ctl_info *edac_mc_alloc(unsigned mc_num,
 227                                    unsigned n_layers,
 228                                    struct edac_mc_layer *layers,
 229                                    unsigned sz_pvt)
 230 {
 231         struct mem_ctl_info *mci;
 232         struct edac_mc_layer *layer;
 233         struct csrow_info *csr;
 234         struct rank_info *chan;
 235         struct dimm_info *dimm;
 236         u32 *ce_per_layer[EDAC_MAX_LAYERS], *ue_per_layer[EDAC_MAX_LAYERS];
 237         unsigned pos[EDAC_MAX_LAYERS];
 238         unsigned size, tot_dimms = 1, count = 1;
 239         unsigned tot_csrows = 1, tot_channels = 1, tot_errcount = 0;
 240         void *pvt, *p, *ptr = NULL;
 241         int i, j, row, chn, n, len, off;
 242         bool per_rank = false;
 243
 244         BUG_ON(n_layers > EDAC_MAX_LAYERS || n_layers == 0);
 245         /*
 246          * Calculate the total amount of dimms and csrows/cschannels while
 247          * in the old API emulation mode
 248          */
 249         for (i = 0; i < n_layers; i++) {
 250                 tot_dimms *= layers[i].size;
 251                 if (layers[i].is_virt_csrow)
 252                         tot_csrows *= layers[i].size;
 253                 else
 254                         tot_channels *= layers[i].size;
 255
 256                 if (layers[i].type == EDAC_MC_LAYER_CHIP_SELECT)
 257                         per_rank = true;
 258         }
 259
 260         /* Figure out the offsets of the various items from the start of an mc
 261          * structure.  We want the alignment of each item to be at least as
 262          * stringent as what the compiler would provide if we could simply
 263          * hardcode everything into a single struct.
 264          */
 265         mci = edac_align_ptr(&ptr, sizeof(*mci), 1);
 266         layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers);
 267         for (i = 0; i < n_layers; i++) {
 268                 count *= layers[i].size;
 269                 edac_dbg(4, "errcount layer %d size %d\n", i, count);
 270                 ce_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
 271                 ue_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
 272                 tot_errcount += 2 * count;
 273         }
 274
 275         edac_dbg(4, "allocating %d error counters\n", tot_errcount);
 276         pvt = edac_align_ptr(&ptr, sz_pvt, 1);
 277         size = ((unsigned long)pvt) + sz_pvt;
 278
 279         edac_dbg(1, "allocating %u bytes for mci data (%d %s, %d csrows/channels)\n",
 280                  size,
 281                  tot_dimms,
 282                  per_rank ? "ranks" : "dimms",
 283                  tot_csrows * tot_channels);
 284
 285         mci = kzalloc(size, GFP_KERNEL);
 286         if (mci == NULL)
 287                 return NULL;
 288
 289         /* Adjust pointers so they point within the memory we just allocated
 290          * rather than an imaginary chunk of memory located at address 0.
 291          */
 292         layer = (struct edac_mc_layer *)(((char *)mci) + ((unsigned long)layer));
 293         for (i = 0; i < n_layers; i++) {
 294                 mci->ce_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ce_per_layer[i]));
 295                 mci->ue_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ue_per_layer[i]));
 296         }
 297         pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
 298
 299         /* setup index and various internal pointers */
 300         mci->mc_idx = mc_num;
 301         mci->tot_dimms = tot_dimms;
 302         mci->pvt_info = pvt;
 303         mci->n_layers = n_layers;
 304         mci->layers = layer;
 305         memcpy(mci->layers, layers, sizeof(*layer) * n_layers);
 306         mci->nr_csrows = tot_csrows;
 307         mci->num_cschannel = tot_channels;
 308         mci->mem_is_per_rank = per_rank;
 309
 310         /*
 311          * Alocate and fill the csrow/channels structs
 312          */
 313         mci->csrows = kcalloc(sizeof(*mci->csrows), tot_csrows, GFP_KERNEL);
 314         if (!mci->csrows)
 315                 goto error;
 316         for (row = 0; row < tot_csrows; row++) {
 317                 csr = kzalloc(sizeof(**mci->csrows), GFP_KERNEL);
 318                 if (!csr)
 319                         goto error;
 320                 mci->csrows[row] = csr;
 321                 csr->csrow_idx = row;
 322                 csr->mci = mci;
 323                 csr->nr_channels = tot_channels;
 324                 csr->channels = kcalloc(sizeof(*csr->channels), tot_channels,
 325                                         GFP_KERNEL);
 326                 if (!csr->channels)
 327                         goto error;
 328
 329                 for (chn = 0; chn < tot_channels; chn++) {
 330                         chan = kzalloc(sizeof(**csr->channels), GFP_KERNEL);
 331                         if (!chan)
 332                                 goto error;
 333                         csr->channels[chn] = chan;
 334                         chan->chan_idx = chn;
 335                         chan->csrow = csr;
 336                 }
 337         }
 338
 339         /*
 340          * Allocate and fill the dimm structs
 341          */
 342         mci->dimms  = kcalloc(sizeof(*mci->dimms), tot_dimms, GFP_KERNEL);
 343         if (!mci->dimms)
 344                 goto error;
 345
 346         memset(&pos, 0, sizeof(pos));
 347         row = 0;
 348         chn = 0;
 349         for (i = 0; i < tot_dimms; i++) {
 350                 chan = mci->csrows[row]->channels[chn];
 351                 off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]);
 352                 if (off < 0 || off >= tot_dimms) {
 353                         edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n");
 354                         goto error;
 355                 }
 356
 357                 dimm = kzalloc(sizeof(**mci->dimms), GFP_KERNEL);
 358                 if (!dimm)
 359                         goto error;
 360                 mci->dimms[off] = dimm;
 361                 dimm->mci = mci;
 362
 363                 /*
 364                  * Copy DIMM location and initialize it.
 365                  */
 366                 len = sizeof(dimm->label);
 367                 p = dimm->label;
 368                 n = snprintf(p, len, "mc#%u", mc_num);
 369                 p += n;
 370                 len -= n;
 371                 for (j = 0; j < n_layers; j++) {
 372                         n = snprintf(p, len, "%s#%u",
 373                                      edac_layer_name[layers[j].type],
 374                                      pos[j]);
 375                         p += n;
 376                         len -= n;
 377                         dimm->location[j] = pos[j];
 378
 379                         if (len <= 0)
 380                                 break;
 381                 }
 382
 383                 /* Link it to the csrows old API data */
 384                 chan->dimm = dimm;
 385                 dimm->csrow = row;
 386                 dimm->cschannel = chn;
 387
 388                 /* Increment csrow location */
 389                 row++;
 390                 if (row == tot_csrows) {
 391                         row = 0;
 392                         chn++;
 393                 }
 394
 395                 /* Increment dimm location */
 396                 for (j = n_layers - 1; j >= 0; j--) {
 397                         pos[j]++;
 398                         if (pos[j] < layers[j].size)
 399                                 break;
 400                         pos[j] = 0;
 401                 }
 402         }
 403
 404         mci->op_state = OP_ALLOC;
 405
 406         /* at this point, the root kobj is valid, and in order to
 407          * 'free' the object, then the function:
 408          *      edac_mc_unregister_sysfs_main_kobj() must be called
 409          * which will perform kobj unregistration and the actual free
 410          * will occur during the kobject callback operation
 411          */
 412
 413         return mci;
 414
 415 error:
 416         if (mci->dimms) {
 417                 for (i = 0; i < tot_dimms; i++)
 418                         kfree(mci->dimms[i]);
 419                 kfree(mci->dimms);
 420         }
 421         if (mci->csrows) {
 422                 for (chn = 0; chn < tot_channels; chn++) {
 423                         csr = mci->csrows[chn];
 424                         if (csr) {
 425                                 for (chn = 0; chn < tot_channels; chn++)
 426                                         kfree(csr->channels[chn]);
 427                                 kfree(csr);
 428                         }
 429                         kfree(mci->csrows[i]);
 430                 }
 431                 kfree(mci->csrows);
 432         }
 433         kfree(mci);
 434
 435         return NULL;
 436 }
 437 EXPORT_SYMBOL_GPL(edac_mc_alloc);
 438
 439 /**
 440  * edac_mc_free
 441  *      'Free' a previously allocated 'mci' structure
 442  * @mci: pointer to a struct mem_ctl_info structure
 443  */
 444 void edac_mc_free(struct mem_ctl_info *mci)
 445 {
 446         edac_dbg(1, "\n");
 447
 448         /* the mci instance is freed here, when the sysfs object is dropped */
 449         edac_unregister_sysfs(mci);
 450 }
 451 EXPORT_SYMBOL_GPL(edac_mc_free);
 452
 453
 454 /**
 455  * find_mci_by_dev
 456  *
 457  *      scan list of controllers looking for the one that manages
 458  *      the 'dev' device
 459  * @dev: pointer to a struct device related with the MCI
 460  */
 461 struct mem_ctl_info *find_mci_by_dev(struct device *dev)
 462 {
 463         struct mem_ctl_info *mci;
 464         struct list_head *item;
 465
 466         edac_dbg(3, "\n");
 467
 468         list_for_each(item, &mc_devices) {
 469                 mci = list_entry(item, struct mem_ctl_info, link);
 470
 471                 if (mci->pdev == dev)
 472                         return mci;
 473         }
 474
 475         return NULL;
 476 }
 477 EXPORT_SYMBOL_GPL(find_mci_by_dev);
 478
 479 /*
 480  * handler for EDAC to check if NMI type handler has asserted interrupt
 481  */
 482 static int edac_mc_assert_error_check_and_clear(void)
 483 {
 484         int old_state;
 485
 486         if (edac_op_state == EDAC_OPSTATE_POLL)
 487                 return 1;
 488
 489         old_state = edac_err_assert;
 490         edac_err_assert = 0;
 491
 492         return old_state;
 493 }
 494
 495 /*
 496  * edac_mc_workq_function
 497  *      performs the operation scheduled by a workq request
 498  */
 499 static void edac_mc_workq_function(struct work_struct *work_req)
 500 {
 501         struct delayed_work *d_work = to_delayed_work(work_req);
 502         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
 503
 504         mutex_lock(&mem_ctls_mutex);
 505
 506         /* if this control struct has movd to offline state, we are done */
 507         if (mci->op_state == OP_OFFLINE) {
 508                 mutex_unlock(&mem_ctls_mutex);
 509                 return;
 510         }
 511
 512         /* Only poll controllers that are running polled and have a check */
 513         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
 514                 mci->edac_check(mci);
 515
 516         mutex_unlock(&mem_ctls_mutex);
 517
 518         /* Reschedule */
 519         queue_delayed_work(edac_workqueue, &mci->work,
 520                         msecs_to_jiffies(edac_mc_get_poll_msec()));
 521 }
 522
 523 /*
 524  * edac_mc_workq_setup
 525  *      initialize a workq item for this mci
 526  *      passing in the new delay period in msec
 527  *
 528  *      locking model:
 529  *
 530  *              called with the mem_ctls_mutex held
 531  */
 532 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
 533 {
 534         edac_dbg(0, "\n");
 535
 536         /* if this instance is not in the POLL state, then simply return */
 537         if (mci->op_state != OP_RUNNING_POLL)
 538                 return;
 539
 540         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
 541         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
 542 }
 543
 544 /*
 545  * edac_mc_workq_teardown
 546  *      stop the workq processing on this mci
 547  *
 548  *      locking model:
 549  *
 550  *              called WITHOUT lock held
 551  */
 552 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
 553 {
 554         int status;
 555
 556         if (mci->op_state != OP_RUNNING_POLL)
 557                 return;
 558
 559         status = cancel_delayed_work(&mci->work);
 560         if (status == 0) {
 561                 edac_dbg(0, "not canceled, flush the queue\n");
 562
 563                 /* workq instance might be running, wait for it */
 564                 flush_workqueue(edac_workqueue);
 565         }
 566 }
 567
 568 /*
 569  * edac_mc_reset_delay_period(unsigned long value)
 570  *
 571  *      user space has updated our poll period value, need to
 572  *      reset our workq delays
 573  */
 574 void edac_mc_reset_delay_period(int value)
 575 {
 576         struct mem_ctl_info *mci;
 577         struct list_head *item;
 578
 579         mutex_lock(&mem_ctls_mutex);
 580
 581         /* scan the list and turn off all workq timers, doing so under lock
 582          */
 583         list_for_each(item, &mc_devices) {
 584                 mci = list_entry(item, struct mem_ctl_info, link);
 585
 586                 if (mci->op_state == OP_RUNNING_POLL)
 587                         cancel_delayed_work(&mci->work);
 588         }
 589
 590         mutex_unlock(&mem_ctls_mutex);
 591
 592
 593         /* re-walk the list, and reset the poll delay */
 594         mutex_lock(&mem_ctls_mutex);
 595
 596         list_for_each(item, &mc_devices) {
 597                 mci = list_entry(item, struct mem_ctl_info, link);
 598
 599                 edac_mc_workq_setup(mci, (unsigned long) value);
 600         }
 601
 602         mutex_unlock(&mem_ctls_mutex);
 603 }
 604
 605
 606
 607 /* Return 0 on success, 1 on failure.
 608  * Before calling this function, caller must
 609  * assign a unique value to mci->mc_idx.
 610  *
 611  *      locking model:
 612  *
 613  *              called with the mem_ctls_mutex lock held
 614  */
 615 static int add_mc_to_global_list(struct mem_ctl_info *mci)
 616 {
 617         struct list_head *item, *insert_before;
 618         struct mem_ctl_info *p;
 619
 620         insert_before = &mc_devices;
 621
 622         p = find_mci_by_dev(mci->pdev);
 623         if (unlikely(p != NULL))
 624                 goto fail0;
 625
 626         list_for_each(item, &mc_devices) {
 627                 p = list_entry(item, struct mem_ctl_info, link);
 628
 629                 if (p->mc_idx >= mci->mc_idx) {
 630                         if (unlikely(p->mc_idx == mci->mc_idx))
 631                                 goto fail1;
 632
 633                         insert_before = item;
 634                         break;
 635                 }
 636         }
 637
 638         list_add_tail_rcu(&mci->link, insert_before);
 639         atomic_inc(&edac_handlers);
 640         return 0;
 641
 642 fail0:
 643         edac_printk(KERN_WARNING, EDAC_MC,
 644                 "%s (%s) %s %s already assigned %d\n", dev_name(p->pdev),
 645                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
 646         return 1;
 647
 648 fail1:
 649         edac_printk(KERN_WARNING, EDAC_MC,
 650                 "bug in low-level driver: attempt to assign\n"
 651                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
 652         return 1;
 653 }
 654
 655 static void del_mc_from_global_list(struct mem_ctl_info *mci)
 656 {
 657         atomic_dec(&edac_handlers);
 658         list_del_rcu(&mci->link);
 659
 660         /* these are for safe removal of devices from global list while
 661          * NMI handlers may be traversing list
 662          */
 663         synchronize_rcu();
 664         INIT_LIST_HEAD(&mci->link);
 665 }
 666
 667 /**
 668  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 669  *
 670  * If found, return a pointer to the structure.
 671  * Else return NULL.
 672  *
 673  * Caller must hold mem_ctls_mutex.
 674  */
 675 struct mem_ctl_info *edac_mc_find(int idx)
 676 {
 677         struct list_head *item;
 678         struct mem_ctl_info *mci;
 679
 680         list_for_each(item, &mc_devices) {
 681                 mci = list_entry(item, struct mem_ctl_info, link);
 682
 683                 if (mci->mc_idx >= idx) {
 684                         if (mci->mc_idx == idx)
 685                                 return mci;
 686
 687                         break;
 688                 }
 689         }
 690
 691         return NULL;
 692 }
 693 EXPORT_SYMBOL(edac_mc_find);
 694
 695 /**
 696  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 697  *                 create sysfs entries associated with mci structure
 698  * @mci: pointer to the mci structure to be added to the list
 699  *
 700  * Return:
 701  *      0       Success
 702  *      !0      Failure
 703  */
 704
 705 /* FIXME - should a warning be printed if no error detection? correction? */
 706 int edac_mc_add_mc(struct mem_ctl_info *mci)
 707 {
 708         edac_dbg(0, "\n");
 709
 710 #ifdef CONFIG_EDAC_DEBUG
 711         if (edac_debug_level >= 3)
 712                 edac_mc_dump_mci(mci);
 713
 714         if (edac_debug_level >= 4) {
 715                 int i;
 716
 717                 for (i = 0; i < mci->nr_csrows; i++) {
 718                         struct csrow_info *csrow = mci->csrows[i];
 719                         u32 nr_pages = 0;
 720                         int j;
 721
 722                         for (j = 0; j < csrow->nr_channels; j++)
 723                                 nr_pages += csrow->channels[j]->dimm->nr_pages;
 724                         if (!nr_pages)
 725                                 continue;
 726                         edac_mc_dump_csrow(csrow);
 727                         for (j = 0; j < csrow->nr_channels; j++)
 728                                 if (csrow->channels[j]->dimm->nr_pages)
 729                                         edac_mc_dump_channel(csrow->channels[j]);
 730                 }
 731                 for (i = 0; i < mci->tot_dimms; i++)
 732                         if (mci->dimms[i]->nr_pages)
 733                                 edac_mc_dump_dimm(mci->dimms[i], i);
 734         }
 735 #endif
 736         mutex_lock(&mem_ctls_mutex);
 737
 738         if (add_mc_to_global_list(mci))
 739                 goto fail0;
 740
 741         /* set load time so that error rate can be tracked */
 742         mci->start_time = jiffies;
 743
 744         if (edac_create_sysfs_mci_device(mci)) {
 745                 edac_mc_printk(mci, KERN_WARNING,
 746                         "failed to create sysfs device\n");
 747                 goto fail1;
 748         }
 749
 750         /* If there IS a check routine, then we are running POLLED */
 751         if (mci->edac_check != NULL) {
 752                 /* This instance is NOW RUNNING */
 753                 mci->op_state = OP_RUNNING_POLL;
 754
 755                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
 756         } else {
 757                 mci->op_state = OP_RUNNING_INTERRUPT;
 758         }
 759
 760         /* Report action taken */
 761         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
 762                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 763
 764         mutex_unlock(&mem_ctls_mutex);
 765         return 0;
 766
 767 fail1:
 768         del_mc_from_global_list(mci);
 769
 770 fail0:
 771         mutex_unlock(&mem_ctls_mutex);
 772         return 1;
 773 }
 774 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
 775
 776 /**
 777  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 778  *                 remove mci structure from global list
 779  * @pdev: Pointer to 'struct device' representing mci structure to remove.
 780  *
 781  * Return pointer to removed mci structure, or NULL if device not found.
 782  */
 783 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 784 {
 785         struct mem_ctl_info *mci;
 786
 787         edac_dbg(0, "\n");
 788
 789         mutex_lock(&mem_ctls_mutex);
 790
 791         /* find the requested mci struct in the global list */
 792         mci = find_mci_by_dev(dev);
 793         if (mci == NULL) {
 794                 mutex_unlock(&mem_ctls_mutex);
 795                 return NULL;
 796         }
 797
 798         del_mc_from_global_list(mci);
 799         mutex_unlock(&mem_ctls_mutex);
 800
 801         /* flush workq processes */
 802         edac_mc_workq_teardown(mci);
 803
 804         /* marking MCI offline */
 805         mci->op_state = OP_OFFLINE;
 806
 807         /* remove from sysfs */
 808         edac_remove_sysfs_mci_device(mci);
 809
 810         edac_printk(KERN_INFO, EDAC_MC,
 811                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
 812                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 813
 814         return mci;
 815 }
 816 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
 817
 818 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
 819                                 u32 size)
 820 {
 821         struct page *pg;
 822         void *virt_addr;
 823         unsigned long flags = 0;
 824
 825         edac_dbg(3, "\n");
 826
 827         /* ECC error page was not in our memory. Ignore it. */
 828         if (!pfn_valid(page))
 829                 return;
 830
 831         /* Find the actual page structure then map it and fix */
 832         pg = pfn_to_page(page);
 833
 834         if (PageHighMem(pg))
 835                 local_irq_save(flags);
 836
 837         virt_addr = kmap_atomic(pg);
 838
 839         /* Perform architecture specific atomic scrub operation */
 840         atomic_scrub(virt_addr + offset, size);
 841
 842         /* Unmap and complete */
 843         kunmap_atomic(virt_addr);
 844
 845         if (PageHighMem(pg))
 846                 local_irq_restore(flags);
 847 }
 848
 849 /* FIXME - should return -1 */
 850 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
 851 {
 852         struct csrow_info **csrows = mci->csrows;
 853         int row, i, j, n;
 854
 855         edac_dbg(1, "MC%d: 0x%lx\n", mci->mc_idx, page);
 856         row = -1;
 857
 858         for (i = 0; i < mci->nr_csrows; i++) {
 859                 struct csrow_info *csrow = csrows[i];
 860                 n = 0;
 861                 for (j = 0; j < csrow->nr_channels; j++) {
 862                         struct dimm_info *dimm = csrow->channels[j]->dimm;
 863                         n += dimm->nr_pages;
 864                 }
 865                 if (n == 0)
 866                         continue;
 867
 868                 edac_dbg(3, "MC%d: first(0x%lx) page(0x%lx) last(0x%lx) mask(0x%lx)\n",
 869                          mci->mc_idx,
 870                          csrow->first_page, page, csrow->last_page,
 871                          csrow->page_mask);
 872
 873                 if ((page >= csrow->first_page) &&
 874                     (page <= csrow->last_page) &&
 875                     ((page & csrow->page_mask) ==
 876                      (csrow->first_page & csrow->page_mask))) {
 877                         row = i;
 878                         break;
 879                 }
 880         }
 881
 882         if (row == -1)
 883                 edac_mc_printk(mci, KERN_ERR,
 884                         "could not look up page error address %lx\n",
 885                         (unsigned long)page);
 886
 887         return row;
 888 }
 889 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
 890
 891 const char *edac_layer_name[] = {
 892         [EDAC_MC_LAYER_BRANCH] = "branch",
 893         [EDAC_MC_LAYER_CHANNEL] = "channel",
 894         [EDAC_MC_LAYER_SLOT] = "slot",
 895         [EDAC_MC_LAYER_CHIP_SELECT] = "csrow",
 896 };
 897 EXPORT_SYMBOL_GPL(edac_layer_name);
 898
 899 static void edac_inc_ce_error(struct mem_ctl_info *mci,
 900                                     bool enable_per_layer_report,
 901                                     const int pos[EDAC_MAX_LAYERS])
 902 {
 903         int i, index = 0;
 904
 905         mci->ce_mc++;
 906
 907         if (!enable_per_layer_report) {
 908                 mci->ce_noinfo_count++;
 909                 return;
 910         }
 911
 912         for (i = 0; i < mci->n_layers; i++) {
 913                 if (pos[i] < 0)
 914                         break;
 915                 index += pos[i];
 916                 mci->ce_per_layer[i][index]++;
 917
 918                 if (i < mci->n_layers - 1)
 919                         index *= mci->layers[i + 1].size;
 920         }
 921 }
 922
 923 static void edac_inc_ue_error(struct mem_ctl_info *mci,
 924                                     bool enable_per_layer_report,
 925                                     const int pos[EDAC_MAX_LAYERS])
 926 {
 927         int i, index = 0;
 928
 929         mci->ue_mc++;
 930
 931         if (!enable_per_layer_report) {
 932                 mci->ce_noinfo_count++;
 933                 return;
 934         }
 935
 936         for (i = 0; i < mci->n_layers; i++) {
 937                 if (pos[i] < 0)
 938                         break;
 939                 index += pos[i];
 940                 mci->ue_per_layer[i][index]++;
 941
 942                 if (i < mci->n_layers - 1)
 943                         index *= mci->layers[i + 1].size;
 944         }
 945 }
 946
 947 static void edac_ce_error(struct mem_ctl_info *mci,
 948                           const int pos[EDAC_MAX_LAYERS],
 949                           const char *msg,
 950                           const char *location,
 951                           const char *label,
 952                           const char *detail,
 953                           const char *other_detail,
 954                           const bool enable_per_layer_report,
 955                           const unsigned long page_frame_number,
 956                           const unsigned long offset_in_page,
 957                           long grain)
 958 {
 959         unsigned long remapped_page;
 960
 961         if (edac_mc_get_log_ce()) {
 962                 if (other_detail && *other_detail)
 963                         edac_mc_printk(mci, KERN_WARNING,
 964                                        "CE %s on %s (%s %s - %s)\n",
 965                                        msg, label, location,
 966                                        detail, other_detail);
 967                 else
 968                         edac_mc_printk(mci, KERN_WARNING,
 969                                        "CE %s on %s (%s %s)\n",
 970                                        msg, label, location,
 971                                        detail);
 972         }
 973         edac_inc_ce_error(mci, enable_per_layer_report, pos);
 974
 975         if (mci->scrub_mode & SCRUB_SW_SRC) {
 976                 /*
 977                         * Some memory controllers (called MCs below) can remap
 978                         * memory so that it is still available at a different
 979                         * address when PCI devices map into memory.
 980                         * MC's that can't do this, lose the memory where PCI
 981                         * devices are mapped. This mapping is MC-dependent
 982                         * and so we call back into the MC driver for it to
 983                         * map the MC page to a physical (CPU) page which can
 984                         * then be mapped to a virtual page - which can then
 985                         * be scrubbed.
 986                         */
 987                 remapped_page = mci->ctl_page_to_phys ?
 988                         mci->ctl_page_to_phys(mci, page_frame_number) :
 989                         page_frame_number;
 990
 991                 edac_mc_scrub_block(remapped_page,
 992                                         offset_in_page, grain);
 993         }
 994 }
 995
 996 static void edac_ue_error(struct mem_ctl_info *mci,
 997                           const int pos[EDAC_MAX_LAYERS],
 998                           const char *msg,
 999                           const char *location,
1000                           const char *label,
1001                           const char *detail,
1002                           const char *other_detail,
1003                           const bool enable_per_layer_report)
1004 {
1005         if (edac_mc_get_log_ue()) {
1006                 if (other_detail && *other_detail)
1007                         edac_mc_printk(mci, KERN_WARNING,
1008                                        "UE %s on %s (%s %s - %s)\n",
1009                                        msg, label, location, detail,
1010                                        other_detail);
1011                 else
1012                         edac_mc_printk(mci, KERN_WARNING,
1013                                        "UE %s on %s (%s %s)\n",
1014                                        msg, label, location, detail);
1015         }
1016
1017         if (edac_mc_get_panic_on_ue()) {
1018                 if (other_detail && *other_detail)
1019                         panic("UE %s on %s (%s%s - %s)\n",
1020                               msg, label, location, detail, other_detail);
1021                 else
1022                         panic("UE %s on %s (%s%s)\n",
1023                               msg, label, location, detail);
1024         }
1025
1026         edac_inc_ue_error(mci, enable_per_layer_report, pos);
1027 }
1028
1029 #define OTHER_LABEL " or "
1030
1031 /**
1032  * edac_mc_handle_error - reports a memory event to userspace
1033  *
1034  * @type:               severity of the error (CE/UE/Fatal)
1035  * @mci:                a struct mem_ctl_info pointer
1036  * @page_frame_number:  mem page where the error occurred
1037  * @offset_in_page:     offset of the error inside the page
1038  * @syndrome:           ECC syndrome
1039  * @top_layer:          Memory layer[0] position
1040  * @mid_layer:          Memory layer[1] position
1041  * @low_layer:          Memory layer[2] position
1042  * @msg:                Message meaningful to the end users that
1043  *                      explains the event
1044  * @other_detail:       Technical details about the event that
1045  *                      may help hardware manufacturers and
1046  *                      EDAC developers to analyse the event
1047  */
1048 void edac_mc_handle_error(const enum hw_event_mc_err_type type,
1049                           struct mem_ctl_info *mci,
1050                           const unsigned long page_frame_number,
1051                           const unsigned long offset_in_page,
1052                           const unsigned long syndrome,
1053                           const int top_layer,
1054                           const int mid_layer,
1055                           const int low_layer,
1056                           const char *msg,
1057                           const char *other_detail)
1058 {
1059         /* FIXME: too much for stack: move it to some pre-alocated area */
1060         char detail[80], location[80];
1061         char label[(EDAC_MC_LABEL_LEN + 1 + sizeof(OTHER_LABEL)) * mci->tot_dimms];
1062         char *p;
1063         int row = -1, chan = -1;
1064         int pos[EDAC_MAX_LAYERS] = { top_layer, mid_layer, low_layer };
1065         int i;
1066         long grain;
1067         bool enable_per_layer_report = false;
1068         u16 error_count;        /* FIXME: make it a parameter */
1069         u8 grain_bits;
1070
1071         edac_dbg(3, "MC%d\n", mci->mc_idx);
1072
1073         /*
1074          * Check if the event report is consistent and if the memory
1075          * location is known. If it is known, enable_per_layer_report will be
1076          * true, the DIMM(s) label info will be filled and the per-layer
1077          * error counters will be incremented.
1078          */
1079         for (i = 0; i < mci->n_layers; i++) {
1080                 if (pos[i] >= (int)mci->layers[i].size) {
1081                         if (type == HW_EVENT_ERR_CORRECTED)
1082                                 p = "CE";
1083                         else
1084                                 p = "UE";
1085
1086                         edac_mc_printk(mci, KERN_ERR,
1087                                        "INTERNAL ERROR: %s value is out of range (%d >= %d)\n",
1088                                        edac_layer_name[mci->layers[i].type],
1089                                        pos[i], mci->layers[i].size);
1090                         /*
1091                          * Instead of just returning it, let's use what's
1092                          * known about the error. The increment routines and
1093                          * the DIMM filter logic will do the right thing by
1094                          * pointing the likely damaged DIMMs.
1095                          */
1096                         pos[i] = -1;
1097                 }
1098                 if (pos[i] >= 0)
1099                         enable_per_layer_report = true;
1100         }
1101
1102         /*
1103          * Get the dimm label/grain that applies to the match criteria.
1104          * As the error algorithm may not be able to point to just one memory
1105          * stick, the logic here will get all possible labels that could
1106          * pottentially be affected by the error.
1107          * On FB-DIMM memory controllers, for uncorrected errors, it is common
1108          * to have only the MC channel and the MC dimm (also called "branch")
1109          * but the channel is not known, as the memory is arranged in pairs,
1110          * where each memory belongs to a separate channel within the same
1111          * branch.
1112          */
1113         grain = 0;
1114         p = label;
1115         *p = '\0';
1116         for (i = 0; i < mci->tot_dimms; i++) {
1117                 struct dimm_info *dimm = mci->dimms[i];
1118
1119                 if (top_layer >= 0 && top_layer != dimm->location[0])
1120                         continue;
1121                 if (mid_layer >= 0 && mid_layer != dimm->location[1])
1122                         continue;
1123                 if (low_layer >= 0 && low_layer != dimm->location[2])
1124                         continue;
1125
1126                 /* get the max grain, over the error match range */
1127                 if (dimm->grain > grain)
1128                         grain = dimm->grain;
1129
1130                 /*
1131                  * If the error is memory-controller wide, there's no need to
1132                  * seek for the affected DIMMs because the whole
1133                  * channel/memory controller/...  may be affected.
1134                  * Also, don't show errors for empty DIMM slots.
1135                  */
1136                 if (enable_per_layer_report && dimm->nr_pages) {
1137                         if (p != label) {
1138                                 strcpy(p, OTHER_LABEL);
1139                                 p += strlen(OTHER_LABEL);
1140                         }
1141                         strcpy(p, dimm->label);
1142                         p += strlen(p);
1143                         *p = '\0';
1144
1145                         /*
1146                          * get csrow/channel of the DIMM, in order to allow
1147                          * incrementing the compat API counters
1148                          */
1149                         edac_dbg(4, "%s csrows map: (%d,%d)\n",
1150                                  mci->mem_is_per_rank ? "rank" : "dimm",
1151                                  dimm->csrow, dimm->cschannel);
1152                         if (row == -1)
1153                                 row = dimm->csrow;
1154                         else if (row >= 0 && row != dimm->csrow)
1155                                 row = -2;
1156
1157                         if (chan == -1)
1158                                 chan = dimm->cschannel;
1159                         else if (chan >= 0 && chan != dimm->cschannel)
1160                                 chan = -2;
1161                 }
1162         }
1163
1164         if (!enable_per_layer_report) {
1165                 strcpy(label, "any memory");
1166         } else {
1167                 edac_dbg(4, "csrow/channel to increment: (%d,%d)\n", row, chan);
1168                 if (p == label)
1169                         strcpy(label, "unknown memory");
1170                 if (type == HW_EVENT_ERR_CORRECTED) {
1171                         if (row >= 0) {
1172                                 mci->csrows[row]->ce_count++;
1173                                 if (chan >= 0)
1174                                         mci->csrows[row]->channels[chan]->ce_count++;
1175                         }
1176                 } else
1177                         if (row >= 0)
1178                                 mci->csrows[row]->ue_count++;
1179         }
1180
1181         /* Fill the RAM location data */
1182         p = location;
1183         for (i = 0; i < mci->n_layers; i++) {
1184                 if (pos[i] < 0)
1185                         continue;
1186
1187                 p += sprintf(p, "%s:%d ",
1188                              edac_layer_name[mci->layers[i].type],
1189                              pos[i]);
1190         }
1191         if (p > location)
1192                 *(p - 1) = '\0';
1193
1194         /* Report the error via the trace interface */
1195
1196         error_count = 1;        /* FIXME: allow change it */
1197         grain_bits = fls_long(grain) + 1;
1198         trace_mc_event(type, msg, label, error_count,
1199                        mci->mc_idx, top_layer, mid_layer, low_layer,
1200                        PAGES_TO_MiB(page_frame_number) | offset_in_page,
1201                        grain_bits, syndrome, other_detail);
1202
1203         /* Memory type dependent details about the error */
1204         if (type == HW_EVENT_ERR_CORRECTED) {
1205                 snprintf(detail, sizeof(detail),
1206                         "page:0x%lx offset:0x%lx grain:%ld syndrome:0x%lx",
1207                         page_frame_number, offset_in_page,
1208                         grain, syndrome);
1209                 edac_ce_error(mci, pos, msg, location, label, detail,
1210                               other_detail, enable_per_layer_report,
1211                               page_frame_number, offset_in_page, grain);
1212         } else {
1213                 snprintf(detail, sizeof(detail),
1214                         "page:0x%lx offset:0x%lx grain:%ld",
1215                         page_frame_number, offset_in_page, grain);
1216
1217                 edac_ue_error(mci, pos, msg, location, label, detail,
1218                               other_detail, enable_per_layer_report);
1219         }
1220 }
1221 EXPORT_SYMBOL_GPL(edac_mc_handle_error);