hwmon: (coretemp) Don't use threshold registers for tempX_max

[mirror_ubuntu-artful-kernel.git] / drivers / edac / edac_mc.c

/*
 * edac_mc kernel module
 * (C) 2005, 2006 Linux Networx (http://lnxi.com)
 * This file may be distributed under the terms of the
 * GNU General Public License.
 *
 * Written by Thayne Harbaugh
 * Based on work by Dan Hollis <goemon at anime dot net> and others.
 *      http://www.anime.net/~goemon/linux-ecc/
 *
 * Modified by Dave Peterson and Doug Thompson
 *
 */

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/smp.h>
#include <linux/init.h>
#include <linux/sysctl.h>
#include <linux/highmem.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/sysdev.h>
#include <linux/ctype.h>
#include <linux/edac.h>
#include <asm/uaccess.h>
#include <asm/page.h>
#include <asm/edac.h>
#include "edac_core.h"
#include "edac_module.h"

/* lock to memory controller's control array */
static DEFINE_MUTEX(mem_ctls_mutex);
static LIST_HEAD(mc_devices);

#ifdef CONFIG_EDAC_DEBUG

static void edac_mc_dump_channel(struct channel_info *chan)
{
        debugf4("\tchannel = %p\n", chan);
        debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx);
        debugf4("\tchannel->ce_count = %d\n", chan->ce_count);
        debugf4("\tchannel->label = '%s'\n", chan->label);
        debugf4("\tchannel->csrow = %p\n\n", chan->csrow);
}

static void edac_mc_dump_csrow(struct csrow_info *csrow)
{
        debugf4("\tcsrow = %p\n", csrow);
        debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx);
        debugf4("\tcsrow->first_page = 0x%lx\n", csrow->first_page);
        debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page);
        debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask);
        debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages);
        debugf4("\tcsrow->nr_channels = %d\n", csrow->nr_channels);
        debugf4("\tcsrow->channels = %p\n", csrow->channels);
        debugf4("\tcsrow->mci = %p\n\n", csrow->mci);
}

static void edac_mc_dump_mci(struct mem_ctl_info *mci)
{
        debugf3("\tmci = %p\n", mci);
        debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap);
        debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
        debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap);
        debugf4("\tmci->edac_check = %p\n", mci->edac_check);
        debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
                mci->nr_csrows, mci->csrows);
        debugf3("\tdev = %p\n", mci->dev);
        debugf3("\tmod_name:ctl_name = %s:%s\n", mci->mod_name, mci->ctl_name);
        debugf3("\tpvt_info = %p\n\n", mci->pvt_info);
}

#endif                          /* CONFIG_EDAC_DEBUG */

/*
 * keep those in sync with the enum mem_type
 */
const char *edac_mem_types[] = {
        "Empty csrow",
        "Reserved csrow type",
        "Unknown csrow type",
        "Fast page mode RAM",
        "Extended data out RAM",
        "Burst Extended data out RAM",
        "Single data rate SDRAM",
        "Registered single data rate SDRAM",
        "Double data rate SDRAM",
        "Registered Double data rate SDRAM",
        "Rambus DRAM",
        "Unbuffered DDR2 RAM",
        "Fully buffered DDR2",
        "Registered DDR2 RAM",
        "Rambus XDR",
        "Unbuffered DDR3 RAM",
        "Registered DDR3 RAM",
};
EXPORT_SYMBOL_GPL(edac_mem_types);

/* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
 * Adjust 'ptr' so that its alignment is at least as stringent as what the
 * compiler would provide for X and return the aligned result.
 *
 * If 'size' is a constant, the compiler will optimize this whole function
 * down to either a no-op or the addition of a constant to the value of 'ptr'.
 */
void *edac_align_ptr(void *ptr, unsigned size)
{
        unsigned align, r;

        /* Here we assume that the alignment of a "long long" is the most
         * stringent alignment that the compiler will ever provide by default.
         * As far as I know, this is a reasonable assumption.
         */
        if (size > sizeof(long))
                align = sizeof(long long);
        else if (size > sizeof(int))
                align = sizeof(long);
        else if (size > sizeof(short))
                align = sizeof(int);
        else if (size > sizeof(char))
                align = sizeof(short);
        else
                return (char *)ptr;

        r = size % align;

        if (r == 0)
                return (char *)ptr;

        return (void *)(((unsigned long)ptr) + align - r);
}

/**
 * edac_mc_alloc: Allocate a struct mem_ctl_info structure
 * @size_pvt:   size of private storage needed
 * @nr_csrows:  Number of CWROWS needed for this MC
 * @nr_chans:   Number of channels for the MC
 *
 * Everything is kmalloc'ed as one big chunk - more efficient.
 * Only can be used if all structures have the same lifetime - otherwise
 * you have to allocate and initialize your own structures.
 *
 * Use edac_mc_free() to free mc structures allocated by this function.
 *
 * Returns:
 *      NULL allocation failed
 *      struct mem_ctl_info pointer
 */
struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
                                unsigned nr_chans, int edac_index)
{
        struct mem_ctl_info *mci;
        struct csrow_info *csi, *csrow;
        struct channel_info *chi, *chp, *chan;
        void *pvt;
        unsigned size;
        int row, chn;
        int err;

        /* Figure out the offsets of the various items from the start of an mc
         * structure.  We want the alignment of each item to be at least as
         * stringent as what the compiler would provide if we could simply
         * hardcode everything into a single struct.
         */
        mci = (struct mem_ctl_info *)0;
        csi = edac_align_ptr(&mci[1], sizeof(*csi));
        chi = edac_align_ptr(&csi[nr_csrows], sizeof(*chi));
        pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
        size = ((unsigned long)pvt) + sz_pvt;

        mci = kzalloc(size, GFP_KERNEL);
        if (mci == NULL)
                return NULL;

        /* Adjust pointers so they point within the memory we just allocated
         * rather than an imaginary chunk of memory located at address 0.
         */
        csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi));
        chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi));
        pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;

        /* setup index and various internal pointers */
        mci->mc_idx = edac_index;
        mci->csrows = csi;
        mci->pvt_info = pvt;
        mci->nr_csrows = nr_csrows;

        for (row = 0; row < nr_csrows; row++) {
                csrow = &csi[row];
                csrow->csrow_idx = row;
                csrow->mci = mci;
                csrow->nr_channels = nr_chans;
                chp = &chi[row * nr_chans];
                csrow->channels = chp;

                for (chn = 0; chn < nr_chans; chn++) {
                        chan = &chp[chn];
                        chan->chan_idx = chn;
                        chan->csrow = csrow;
                }
        }

        mci->op_state = OP_ALLOC;
        INIT_LIST_HEAD(&mci->grp_kobj_list);

        /*
         * Initialize the 'root' kobj for the edac_mc controller
         */
        err = edac_mc_register_sysfs_main_kobj(mci);
        if (err) {
                kfree(mci);
                return NULL;
        }

        /* at this point, the root kobj is valid, and in order to
         * 'free' the object, then the function:
         *      edac_mc_unregister_sysfs_main_kobj() must be called
         * which will perform kobj unregistration and the actual free
         * will occur during the kobject callback operation
         */
        return mci;
}
EXPORT_SYMBOL_GPL(edac_mc_alloc);

/**
 * edac_mc_free
 *      'Free' a previously allocated 'mci' structure
 * @mci: pointer to a struct mem_ctl_info structure
 */
void edac_mc_free(struct mem_ctl_info *mci)
{
        debugf1("%s()\n", __func__);

        edac_mc_unregister_sysfs_main_kobj(mci);

        /* free the mci instance memory here */
        kfree(mci);
}
EXPORT_SYMBOL_GPL(edac_mc_free);


/**
 * find_mci_by_dev
 *
 *      scan list of controllers looking for the one that manages
 *      the 'dev' device
 * @dev: pointer to a struct device related with the MCI
 */
struct mem_ctl_info *find_mci_by_dev(struct device *dev)
{
        struct mem_ctl_info *mci;
        struct list_head *item;

        debugf3("%s()\n", __func__);

        list_for_each(item, &mc_devices) {
                mci = list_entry(item, struct mem_ctl_info, link);

                if (mci->dev == dev)
                        return mci;
        }

        return NULL;
}
EXPORT_SYMBOL_GPL(find_mci_by_dev);

/*
 * handler for EDAC to check if NMI type handler has asserted interrupt
 */
static int edac_mc_assert_error_check_and_clear(void)
{
        int old_state;

        if (edac_op_state == EDAC_OPSTATE_POLL)
                return 1;

        old_state = edac_err_assert;
        edac_err_assert = 0;

        return old_state;
}

/*
 * edac_mc_workq_function
 *      performs the operation scheduled by a workq request
 */
static void edac_mc_workq_function(struct work_struct *work_req)
{
        struct delayed_work *d_work = to_delayed_work(work_req);
        struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);

        mutex_lock(&mem_ctls_mutex);

        /* if this control struct has movd to offline state, we are done */
        if (mci->op_state == OP_OFFLINE) {
                mutex_unlock(&mem_ctls_mutex);
                return;
        }

        /* Only poll controllers that are running polled and have a check */
        if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
                mci->edac_check(mci);

        mutex_unlock(&mem_ctls_mutex);

        /* Reschedule */
        queue_delayed_work(edac_workqueue, &mci->work,
                        msecs_to_jiffies(edac_mc_get_poll_msec()));
}

/*
 * edac_mc_workq_setup
 *      initialize a workq item for this mci
 *      passing in the new delay period in msec
 *
 *      locking model:
 *
 *              called with the mem_ctls_mutex held
 */
static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
{
        debugf0("%s()\n", __func__);

        /* if this instance is not in the POLL state, then simply return */
        if (mci->op_state != OP_RUNNING_POLL)
                return;

        INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
        queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
}

/*
 * edac_mc_workq_teardown
 *      stop the workq processing on this mci
 *
 *      locking model:
 *
 *              called WITHOUT lock held
 */
static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
{
        int status;

        if (mci->op_state != OP_RUNNING_POLL)
                return;

        status = cancel_delayed_work(&mci->work);
        if (status == 0) {
                debugf0("%s() not canceled, flush the queue\n",
                        __func__);

                /* workq instance might be running, wait for it */
                flush_workqueue(edac_workqueue);
        }
}

/*
 * edac_mc_reset_delay_period(unsigned long value)
 *
 *      user space has updated our poll period value, need to
 *      reset our workq delays
 */
void edac_mc_reset_delay_period(int value)
{
        struct mem_ctl_info *mci;
        struct list_head *item;

        mutex_lock(&mem_ctls_mutex);

        /* scan the list and turn off all workq timers, doing so under lock
         */
        list_for_each(item, &mc_devices) {
                mci = list_entry(item, struct mem_ctl_info, link);

                if (mci->op_state == OP_RUNNING_POLL)
                        cancel_delayed_work(&mci->work);
        }

        mutex_unlock(&mem_ctls_mutex);


        /* re-walk the list, and reset the poll delay */
        mutex_lock(&mem_ctls_mutex);

        list_for_each(item, &mc_devices) {
                mci = list_entry(item, struct mem_ctl_info, link);

                edac_mc_workq_setup(mci, (unsigned long) value);
        }

        mutex_unlock(&mem_ctls_mutex);
}



/* Return 0 on success, 1 on failure.
 * Before calling this function, caller must
 * assign a unique value to mci->mc_idx.
 *
 *      locking model:
 *
 *              called with the mem_ctls_mutex lock held
 */
static int add_mc_to_global_list(struct mem_ctl_info *mci)
{
        struct list_head *item, *insert_before;
        struct mem_ctl_info *p;

        insert_before = &mc_devices;

        p = find_mci_by_dev(mci->dev);
        if (unlikely(p != NULL))
                goto fail0;

        list_for_each(item, &mc_devices) {
                p = list_entry(item, struct mem_ctl_info, link);

                if (p->mc_idx >= mci->mc_idx) {
                        if (unlikely(p->mc_idx == mci->mc_idx))
                                goto fail1;

                        insert_before = item;
                        break;
                }
        }

        list_add_tail_rcu(&mci->link, insert_before);
        atomic_inc(&edac_handlers);
        return 0;

fail0:
        edac_printk(KERN_WARNING, EDAC_MC,
                "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
                edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
        return 1;

fail1:
        edac_printk(KERN_WARNING, EDAC_MC,
                "bug in low-level driver: attempt to assign\n"
                "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
        return 1;
}

static void del_mc_from_global_list(struct mem_ctl_info *mci)
{
        atomic_dec(&edac_handlers);
        list_del_rcu(&mci->link);

        /* these are for safe removal of devices from global list while
         * NMI handlers may be traversing list
         */
        synchronize_rcu();
        INIT_LIST_HEAD(&mci->link);
}

/**
 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 *
 * If found, return a pointer to the structure.
 * Else return NULL.
 *
 * Caller must hold mem_ctls_mutex.
 */
struct mem_ctl_info *edac_mc_find(int idx)
{
        struct list_head *item;
        struct mem_ctl_info *mci;

        list_for_each(item, &mc_devices) {
                mci = list_entry(item, struct mem_ctl_info, link);

                if (mci->mc_idx >= idx) {
                        if (mci->mc_idx == idx)
                                return mci;

                        break;
                }
        }

        return NULL;
}
EXPORT_SYMBOL(edac_mc_find);

/**
 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 *                 create sysfs entries associated with mci structure
 * @mci: pointer to the mci structure to be added to the list
 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
 *
 * Return:
 *      0       Success
 *      !0      Failure
 */

/* FIXME - should a warning be printed if no error detection? correction? */
int edac_mc_add_mc(struct mem_ctl_info *mci)
{
        debugf0("%s()\n", __func__);

#ifdef CONFIG_EDAC_DEBUG
        if (edac_debug_level >= 3)
                edac_mc_dump_mci(mci);

        if (edac_debug_level >= 4) {
                int i;

                for (i = 0; i < mci->nr_csrows; i++) {
                        int j;

                        edac_mc_dump_csrow(&mci->csrows[i]);
                        for (j = 0; j < mci->csrows[i].nr_channels; j++)
                                edac_mc_dump_channel(&mci->csrows[i].
                                                channels[j]);
                }
        }
#endif
        mutex_lock(&mem_ctls_mutex);

        if (add_mc_to_global_list(mci))
                goto fail0;

        /* set load time so that error rate can be tracked */
        mci->start_time = jiffies;

        if (edac_create_sysfs_mci_device(mci)) {
                edac_mc_printk(mci, KERN_WARNING,
                        "failed to create sysfs device\n");
                goto fail1;
        }

        /* If there IS a check routine, then we are running POLLED */
        if (mci->edac_check != NULL) {
                /* This instance is NOW RUNNING */
                mci->op_state = OP_RUNNING_POLL;

                edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
        } else {
                mci->op_state = OP_RUNNING_INTERRUPT;
        }

        /* Report action taken */
        edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
                " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));

        mutex_unlock(&mem_ctls_mutex);
        return 0;

fail1:
        del_mc_from_global_list(mci);

fail0:
        mutex_unlock(&mem_ctls_mutex);
        return 1;
}
EXPORT_SYMBOL_GPL(edac_mc_add_mc);

/**
 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 *                 remove mci structure from global list
 * @pdev: Pointer to 'struct device' representing mci structure to remove.
 *
 * Return pointer to removed mci structure, or NULL if device not found.
 */
struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
{
        struct mem_ctl_info *mci;

        debugf0("%s()\n", __func__);

        mutex_lock(&mem_ctls_mutex);

        /* find the requested mci struct in the global list */
        mci = find_mci_by_dev(dev);
        if (mci == NULL) {
                mutex_unlock(&mem_ctls_mutex);
                return NULL;
        }

        del_mc_from_global_list(mci);
        mutex_unlock(&mem_ctls_mutex);

        /* flush workq processes */
        edac_mc_workq_teardown(mci);

        /* marking MCI offline */
        mci->op_state = OP_OFFLINE;

        /* remove from sysfs */
        edac_remove_sysfs_mci_device(mci);

        edac_printk(KERN_INFO, EDAC_MC,
                "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
                mci->mod_name, mci->ctl_name, edac_dev_name(mci));

        return mci;
}
EXPORT_SYMBOL_GPL(edac_mc_del_mc);

static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
                                u32 size)
{
        struct page *pg;
        void *virt_addr;
        unsigned long flags = 0;

        debugf3("%s()\n", __func__);

        /* ECC error page was not in our memory. Ignore it. */
        if (!pfn_valid(page))
                return;

        /* Find the actual page structure then map it and fix */
        pg = pfn_to_page(page);

        if (PageHighMem(pg))
                local_irq_save(flags);

        virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);

        /* Perform architecture specific atomic scrub operation */
        atomic_scrub(virt_addr + offset, size);

        /* Unmap and complete */
        kunmap_atomic(virt_addr, KM_BOUNCE_READ);

        if (PageHighMem(pg))
                local_irq_restore(flags);
}

/* FIXME - should return -1 */
int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
{
        struct csrow_info *csrows = mci->csrows;
        int row, i;

        debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
        row = -1;

        for (i = 0; i < mci->nr_csrows; i++) {
                struct csrow_info *csrow = &csrows[i];

                if (csrow->nr_pages == 0)
                        continue;

                debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
                        "mask(0x%lx)\n", mci->mc_idx, __func__,
                        csrow->first_page, page, csrow->last_page,
                        csrow->page_mask);

                if ((page >= csrow->first_page) &&
                    (page <= csrow->last_page) &&
                    ((page & csrow->page_mask) ==
                     (csrow->first_page & csrow->page_mask))) {
                        row = i;
                        break;
                }
        }

        if (row == -1)
                edac_mc_printk(mci, KERN_ERR,
                        "could not look up page error address %lx\n",
                        (unsigned long)page);

        return row;
}
EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);

/* FIXME - setable log (warning/emerg) levels */
/* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
void edac_mc_handle_ce(struct mem_ctl_info *mci,
                unsigned long page_frame_number,
                unsigned long offset_in_page, unsigned long syndrome,
                int row, int channel, const char *msg)
{
        unsigned long remapped_page;

        debugf3("MC%d: %s()\n", mci->mc_idx, __func__);

        /* FIXME - maybe make panic on INTERNAL ERROR an option */
        if (row >= mci->nr_csrows || row < 0) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: row out of range "
                        "(%d >= %d)\n", row, mci->nr_csrows);
                edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
                return;
        }

        if (channel >= mci->csrows[row].nr_channels || channel < 0) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: channel out of range "
                        "(%d >= %d)\n", channel,
                        mci->csrows[row].nr_channels);
                edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
                return;
        }

        if (edac_mc_get_log_ce())
                /* FIXME - put in DIMM location */
                edac_mc_printk(mci, KERN_WARNING,
                        "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
                        "0x%lx, row %d, channel %d, label \"%s\": %s\n",
                        page_frame_number, offset_in_page,
                        mci->csrows[row].grain, syndrome, row, channel,
                        mci->csrows[row].channels[channel].label, msg);

        mci->ce_count++;
        mci->csrows[row].ce_count++;
        mci->csrows[row].channels[channel].ce_count++;

        if (mci->scrub_mode & SCRUB_SW_SRC) {
                /*
                 * Some MC's can remap memory so that it is still available
                 * at a different address when PCI devices map into memory.
                 * MC's that can't do this lose the memory where PCI devices
                 * are mapped.  This mapping is MC dependent and so we call
                 * back into the MC driver for it to map the MC page to
                 * a physical (CPU) page which can then be mapped to a virtual
                 * page - which can then be scrubbed.
                 */
                remapped_page = mci->ctl_page_to_phys ?
                        mci->ctl_page_to_phys(mci, page_frame_number) :
                        page_frame_number;

                edac_mc_scrub_block(remapped_page, offset_in_page,
                                mci->csrows[row].grain);
        }
}
EXPORT_SYMBOL_GPL(edac_mc_handle_ce);

void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
{
        if (edac_mc_get_log_ce())
                edac_mc_printk(mci, KERN_WARNING,
                        "CE - no information available: %s\n", msg);

        mci->ce_noinfo_count++;
        mci->ce_count++;
}
EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);

void edac_mc_handle_ue(struct mem_ctl_info *mci,
                unsigned long page_frame_number,
                unsigned long offset_in_page, int row, const char *msg)
{
        int len = EDAC_MC_LABEL_LEN * 4;
        char labels[len + 1];
        char *pos = labels;
        int chan;
        int chars;

        debugf3("MC%d: %s()\n", mci->mc_idx, __func__);

        /* FIXME - maybe make panic on INTERNAL ERROR an option */
        if (row >= mci->nr_csrows || row < 0) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: row out of range "
                        "(%d >= %d)\n", row, mci->nr_csrows);
                edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
                return;
        }

        chars = snprintf(pos, len + 1, "%s",
                         mci->csrows[row].channels[0].label);
        len -= chars;
        pos += chars;

        for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
                chan++) {
                chars = snprintf(pos, len + 1, ":%s",
                                 mci->csrows[row].channels[chan].label);
                len -= chars;
                pos += chars;
        }

        if (edac_mc_get_log_ue())
                edac_mc_printk(mci, KERN_EMERG,
                        "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
                        "labels \"%s\": %s\n", page_frame_number,
                        offset_in_page, mci->csrows[row].grain, row,
                        labels, msg);

        if (edac_mc_get_panic_on_ue())
                panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
                        "row %d, labels \"%s\": %s\n", mci->mc_idx,
                        page_frame_number, offset_in_page,
                        mci->csrows[row].grain, row, labels, msg);

        mci->ue_count++;
        mci->csrows[row].ue_count++;
}
EXPORT_SYMBOL_GPL(edac_mc_handle_ue);

void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
{
        if (edac_mc_get_panic_on_ue())
                panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);

        if (edac_mc_get_log_ue())
                edac_mc_printk(mci, KERN_WARNING,
                        "UE - no information available: %s\n", msg);
        mci->ue_noinfo_count++;
        mci->ue_count++;
}
EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);

/*************************************************************
 * On Fully Buffered DIMM modules, this help function is
 * called to process UE events
 */
void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
                        unsigned int csrow,
                        unsigned int channela,
                        unsigned int channelb, char *msg)
{
        int len = EDAC_MC_LABEL_LEN * 4;
        char labels[len + 1];
        char *pos = labels;
        int chars;

        if (csrow >= mci->nr_csrows) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: row out of range (%d >= %d)\n",
                        csrow, mci->nr_csrows);
                edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
                return;
        }

        if (channela >= mci->csrows[csrow].nr_channels) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: channel-a out of range "
                        "(%d >= %d)\n",
                        channela, mci->csrows[csrow].nr_channels);
                edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
                return;
        }

        if (channelb >= mci->csrows[csrow].nr_channels) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: channel-b out of range "
                        "(%d >= %d)\n",
                        channelb, mci->csrows[csrow].nr_channels);
                edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
                return;
        }

        mci->ue_count++;
        mci->csrows[csrow].ue_count++;

        /* Generate the DIMM labels from the specified channels */
        chars = snprintf(pos, len + 1, "%s",
                         mci->csrows[csrow].channels[channela].label);
        len -= chars;
        pos += chars;
        chars = snprintf(pos, len + 1, "-%s",
                         mci->csrows[csrow].channels[channelb].label);

        if (edac_mc_get_log_ue())
                edac_mc_printk(mci, KERN_EMERG,
                        "UE row %d, channel-a= %d channel-b= %d "
                        "labels \"%s\": %s\n", csrow, channela, channelb,
                        labels, msg);

        if (edac_mc_get_panic_on_ue())
                panic("UE row %d, channel-a= %d channel-b= %d "
                        "labels \"%s\": %s\n", csrow, channela,
                        channelb, labels, msg);
}
EXPORT_SYMBOL(edac_mc_handle_fbd_ue);

/*************************************************************
 * On Fully Buffered DIMM modules, this help function is
 * called to process CE events
 */
void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
                        unsigned int csrow, unsigned int channel, char *msg)
{

        /* Ensure boundary values */
        if (csrow >= mci->nr_csrows) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: row out of range (%d >= %d)\n",
                        csrow, mci->nr_csrows);
                edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
                return;
        }
        if (channel >= mci->csrows[csrow].nr_channels) {
                /* something is wrong */
                edac_mc_printk(mci, KERN_ERR,
                        "INTERNAL ERROR: channel out of range (%d >= %d)\n",
                        channel, mci->csrows[csrow].nr_channels);
                edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
                return;
        }

        if (edac_mc_get_log_ce())
                /* FIXME - put in DIMM location */
                edac_mc_printk(mci, KERN_WARNING,
                        "CE row %d, channel %d, label \"%s\": %s\n",
                        csrow, channel,
                        mci->csrows[csrow].channels[channel].label, msg);

        mci->ce_count++;
        mci->csrows[csrow].ce_count++;
        mci->csrows[csrow].channels[channel].ce_count++;
}
EXPORT_SYMBOL(edac_mc_handle_fbd_ce);