[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / edac / edac_pci_sysfs.c

/*
 * (C) 2005, 2006 Linux Networx (http://lnxi.com)
 * This file may be distributed under the terms of the
 * GNU General Public License.
 *
 * Written Doug Thompson <norsk5@xmission.com>
 *
 */
#include <linux/module.h>
#include <linux/sysdev.h>
#include <linux/ctype.h>

#include "edac_core.h"
#include "edac_module.h"


#ifdef CONFIG_PCI

#define EDAC_PCI_SYMLINK	"device"

static int check_pci_errors = 0;	/* default YES check PCI parity */
static int edac_pci_panic_on_pe = 0;	/* default no panic on PCI Parity */
static int edac_pci_log_pe = 1;	/* log PCI parity errors */
static int edac_pci_log_npe = 1;	/* log PCI non-parity error errors */
static atomic_t pci_parity_count = ATOMIC_INIT(0);
static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
static int edac_pci_poll_msec = 1000;

static struct kobject edac_pci_kobj; /* /sys/devices/system/edac/pci */
static struct completion edac_pci_kobj_complete;
static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);

int edac_pci_get_check_errors(void)
{
	return check_pci_errors;
}

int edac_pci_get_log_pe(void)
{
	return edac_pci_log_pe;
}

int edac_pci_get_log_npe(void)
{
	return edac_pci_log_npe;
}

int edac_pci_get_panic_on_pe(void)
{
	return edac_pci_panic_on_pe;
}

int edac_pci_get_poll_msec(void)
{
	return edac_pci_poll_msec;
}

/**************************** EDAC PCI sysfs instance *******************/
static ssize_t instance_pe_count_show(struct edac_pci_ctl_info *pci, char *data)
{
        return sprintf(data,"%u\n", atomic_read(&pci->counters.pe_count));
}

static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci,
		char *data)
{
        return sprintf(data,"%u\n", atomic_read(&pci->counters.npe_count));
}

#define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
#define to_instance_attr(a) container_of(a, struct instance_attribute, attr)

/* DEVICE instance kobject release() function */
static void edac_pci_instance_release(struct kobject *kobj)
{
	struct edac_pci_ctl_info *pci;

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

	pci = to_instance(kobj);
	complete(&pci->kobj_complete);
}

/* instance specific attribute structure */
struct instance_attribute {
        struct attribute attr;
        ssize_t (*show)(struct edac_pci_ctl_info *, char *);
        ssize_t (*store)(struct edac_pci_ctl_info *, const char *, size_t);
};

/* Function to 'show' fields from the edac_pci 'instance' structure */
static ssize_t edac_pci_instance_show(struct kobject *kobj,
                        struct attribute *attr,
                        char *buffer)
{
        struct edac_pci_ctl_info *pci = to_instance(kobj);
        struct instance_attribute *instance_attr = to_instance_attr(attr);

        if (instance_attr->show)
                return instance_attr->show(pci, buffer);
        return -EIO;
}


/* Function to 'store' fields into the edac_pci 'instance' structure */
static ssize_t edac_pci_instance_store(struct kobject *kobj,
                        struct attribute *attr,
                	const char *buffer, size_t count)
{
        struct edac_pci_ctl_info *pci = to_instance(kobj);
        struct instance_attribute *instance_attr = to_instance_attr(attr);

        if (instance_attr->store)
                return instance_attr->store(pci, buffer, count);
        return -EIO;
}

static struct sysfs_ops pci_instance_ops = {
	.show = edac_pci_instance_show,
	.store = edac_pci_instance_store
};

#define INSTANCE_ATTR(_name, _mode, _show, _store)	\
static struct instance_attribute attr_instance_##_name = {	\
	.attr	= {.name = __stringify(_name), .mode = _mode },	\
	.show	= _show,					\
	.store	= _store,					\
};

INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL);
INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL);

/* pci instance attributes */
static struct instance_attribute *pci_instance_attr[] = {
	&attr_instance_pe_count,
	&attr_instance_npe_count,
	NULL
};

/* the ktype for pci instance */
static struct kobj_type ktype_pci_instance = {
	.release = edac_pci_instance_release,
	.sysfs_ops = &pci_instance_ops,
	.default_attrs = (struct attribute **)pci_instance_attr,
};

static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
{
	int err;

	pci->kobj.parent = &edac_pci_kobj;
	pci->kobj.ktype = &ktype_pci_instance;

	err = kobject_set_name(&pci->kobj, "pci%d", idx);
	if (err)
		return err;

	err = kobject_register(&pci->kobj);
	if (err != 0) {
		debugf2("%s() failed to register instance pci%d\n",
				__func__, idx);
		return err;
	}

	debugf1("%s() Register instance 'pci%d' kobject\n", __func__, idx);

	return 0;
}

static void
edac_pci_delete_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
{
	init_completion(&pci->kobj_complete);
	kobject_unregister(&pci->kobj);
	wait_for_completion(&pci->kobj_complete);
}

/***************************** EDAC PCI sysfs root **********************/
#define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
#define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)

static ssize_t edac_pci_int_show(void *ptr, char *buffer)
{
	int *value = ptr;
	return sprintf(buffer,"%d\n",*value);
}

static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
{
	int *value = ptr;

	if (isdigit(*buffer))
		*value = simple_strtoul(buffer,NULL,0);

	return count;
}

struct edac_pci_dev_attribute {
	struct attribute attr;
	void *value;
	ssize_t (*show)(void *,char *);
	ssize_t (*store)(void *, const char *,size_t);
};

/* Set of show/store abstract level functions for PCI Parity object */
static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
		char *buffer)
{
	struct edac_pci_dev_attribute *edac_pci_dev;
	edac_pci_dev= (struct edac_pci_dev_attribute*)attr;

	if (edac_pci_dev->show)
		return edac_pci_dev->show(edac_pci_dev->value, buffer);
	return -EIO;
}

static ssize_t edac_pci_dev_store(struct kobject *kobj,
		struct attribute *attr, const char *buffer, size_t count)
{
	struct edac_pci_dev_attribute *edac_pci_dev;
	edac_pci_dev= (struct edac_pci_dev_attribute*)attr;

	if (edac_pci_dev->show)
		return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
	return -EIO;
}

static struct sysfs_ops edac_pci_sysfs_ops = {
	.show   = edac_pci_dev_show,
	.store  = edac_pci_dev_store
};

#define EDAC_PCI_ATTR(_name,_mode,_show,_store)			\
static struct edac_pci_dev_attribute edac_pci_attr_##_name = {		\
	.attr = {.name = __stringify(_name), .mode = _mode },	\
	.value  = &_name,					\
	.show   = _show,					\
	.store  = _store,					\
};

#define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store)	\
static struct edac_pci_dev_attribute edac_pci_attr_##_name = {		\
	.attr = {.name = __stringify(_name), .mode = _mode },	\
	.value  = _data,					\
	.show   = _show,					\
	.store  = _store,					\
};

/* PCI Parity control files */
EDAC_PCI_ATTR(check_pci_errors, S_IRUGO|S_IWUSR, edac_pci_int_show,
	edac_pci_int_store);
EDAC_PCI_ATTR(edac_pci_log_pe, S_IRUGO|S_IWUSR, edac_pci_int_show,
	edac_pci_int_store);
EDAC_PCI_ATTR(edac_pci_log_npe, S_IRUGO|S_IWUSR, edac_pci_int_show,
	edac_pci_int_store);
EDAC_PCI_ATTR(edac_pci_panic_on_pe, S_IRUGO|S_IWUSR, edac_pci_int_show,
	edac_pci_int_store);
EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL);
EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);

/* Base Attributes of the memory ECC object */
static struct edac_pci_dev_attribute *edac_pci_attr[] = {
	&edac_pci_attr_check_pci_errors,
	&edac_pci_attr_edac_pci_log_pe,
	&edac_pci_attr_edac_pci_log_npe,
	&edac_pci_attr_edac_pci_panic_on_pe,
	&edac_pci_attr_pci_parity_count,
	&edac_pci_attr_pci_nonparity_count,
	NULL,
};

/* No memory to release */
static void edac_pci_release(struct kobject *kobj)
{
	struct edac_pci_ctl_info *pci;

	pci = to_edacpci(kobj);

	debugf1("%s()\n", __func__);
	complete(&pci->kobj_complete);
}

static struct kobj_type ktype_edac_pci = {
	.release = edac_pci_release,
	.sysfs_ops = &edac_pci_sysfs_ops,
	.default_attrs = (struct attribute **) edac_pci_attr,
};

/**
 * edac_sysfs_pci_setup()
 *
 *	setup the sysfs for EDAC PCI attributes
 *	assumes edac_class has already been initialized
 */
int edac_pci_register_main_kobj(void)
{
	int err;
	struct sysdev_class *edac_class;

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

	edac_class = edac_get_edac_class();
	if (edac_class == NULL) {
		debugf1("%s() no edac_class\n", __func__);
		return -ENODEV;
	}

	edac_pci_kobj.ktype = &ktype_edac_pci;

	edac_pci_kobj.parent = &edac_class->kset.kobj;

	err = kobject_set_name(&edac_pci_kobj, "pci");
	if(err)
		return err;

	/* Instanstiate the pci object */
	/* FIXME: maybe new sysdev_create_subdir() */
	err = kobject_register(&edac_pci_kobj);

	if (err) {
		debugf1("Failed to register '.../edac/pci'\n");
		return err;
	}

	debugf1("Registered '.../edac/pci' kobject\n");

	return 0;
}

/*
 * edac_pci_unregister_main_kobj()
 *
 *	perform the sysfs teardown for the PCI attributes
 */
void edac_pci_unregister_main_kobj(void)
{
	debugf0("%s()\n", __func__);
	init_completion(&edac_pci_kobj_complete);
	kobject_unregister(&edac_pci_kobj);
	wait_for_completion(&edac_pci_kobj_complete);
}

int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
{
	int err;
	struct kobject *edac_kobj = &pci->kobj;

	if (atomic_inc_return(&edac_pci_sysfs_refcount) == 1) {
		err = edac_pci_register_main_kobj();
		if (err) {
			atomic_dec(&edac_pci_sysfs_refcount);
			return err;
		}
	}

	err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
	if (err) {
		if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
			edac_pci_unregister_main_kobj();
	}


	debugf0("%s() idx=%d\n", __func__, pci->pci_idx);

	err = sysfs_create_link(edac_kobj,
			&pci->dev->kobj,
			EDAC_PCI_SYMLINK);
	if (err) {
		debugf0("%s() sysfs_create_link() returned err= %d\n",
				__func__, err);
		return err;
	}

	return 0;
}

void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
{
	debugf0("%s()\n", __func__);

	edac_pci_delete_instance_kobj(pci, pci->pci_idx);

	sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);

	if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
		edac_pci_unregister_main_kobj();
}

/************************ PCI error handling *************************/
static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
{
	int where;
	u16 status;

	where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
	pci_read_config_word(dev, where, &status);

	/* If we get back 0xFFFF then we must suspect that the card has been
	 * pulled but the Linux PCI layer has not yet finished cleaning up.
	 * We don't want to report on such devices
	 */

	if (status == 0xFFFF) {
		u32 sanity;

		pci_read_config_dword(dev, 0, &sanity);

		if (sanity == 0xFFFFFFFF)
			return 0;
	}

	status &= PCI_STATUS_DETECTED_PARITY | PCI_STATUS_SIG_SYSTEM_ERROR |
		PCI_STATUS_PARITY;

	if (status)
		/* reset only the bits we are interested in */
		pci_write_config_word(dev, where, status);

	return status;
}

typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);

/* Clear any PCI parity errors logged by this device. */
static void edac_pci_dev_parity_clear(struct pci_dev *dev)
{
	u8 header_type;

	get_pci_parity_status(dev, 0);

	/* read the device TYPE, looking for bridges */
	pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);

	if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
		get_pci_parity_status(dev, 1);
}

/*
 *  PCI Parity polling
 *
 */
static void edac_pci_dev_parity_test(struct pci_dev *dev)
{
	u16 status;
	u8  header_type;

	/* read the STATUS register on this device
	 */
	status = get_pci_parity_status(dev, 0);

	debugf2("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id );

	/* check the status reg for errors */
	if (status) {
		if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
			edac_printk(KERN_CRIT, EDAC_PCI,
				"Signaled System Error on %s\n",
				pci_name(dev));
			atomic_inc(&pci_nonparity_count);
		}

		if (status & (PCI_STATUS_PARITY)) {
			edac_printk(KERN_CRIT, EDAC_PCI,
				"Master Data Parity Error on %s\n",
				pci_name(dev));

			atomic_inc(&pci_parity_count);
		}

		if (status & (PCI_STATUS_DETECTED_PARITY)) {
			edac_printk(KERN_CRIT, EDAC_PCI,
				"Detected Parity Error on %s\n",
				pci_name(dev));

			atomic_inc(&pci_parity_count);
		}
	}

	/* read the device TYPE, looking for bridges */
	pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);

	debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id );

	if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
		/* On bridges, need to examine secondary status register  */
		status = get_pci_parity_status(dev, 1);

		debugf2("PCI SEC_STATUS= 0x%04x %s\n",
				status, dev->dev.bus_id );

		/* check the secondary status reg for errors */
		if (status) {
			if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
				edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
					"Signaled System Error on %s\n",
					pci_name(dev));
				atomic_inc(&pci_nonparity_count);
			}

			if (status & (PCI_STATUS_PARITY)) {
				edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
					"Master Data Parity Error on "
					"%s\n", pci_name(dev));

				atomic_inc(&pci_parity_count);
			}

			if (status & (PCI_STATUS_DETECTED_PARITY)) {
				edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
					"Detected Parity Error on %s\n",
					pci_name(dev));

				atomic_inc(&pci_parity_count);
			}
		}
	}
}

/*
 * pci_dev parity list iterator
 *	Scan the PCI device list for one iteration, looking for SERRORs
 *	Master Parity ERRORS or Parity ERRORs on primary or secondary devices
 */
static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
{
	struct pci_dev *dev = NULL;

	/* request for kernel access to the next PCI device, if any,
	 * and while we are looking at it have its reference count
	 * bumped until we are done with it
	 */
	while((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
		fn(dev);
	}
}

/*
 * edac_pci_do_parity_check
 *
 *	performs the actual PCI parity check operation
 */
void edac_pci_do_parity_check(void)
{
	unsigned long flags;
	int before_count;

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

	if (!check_pci_errors)
		return;

	before_count = atomic_read(&pci_parity_count);

	/* scan all PCI devices looking for a Parity Error on devices and
	 * bridges
	 */
	local_irq_save(flags);
	edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
	local_irq_restore(flags);

	/* Only if operator has selected panic on PCI Error */
	if (edac_pci_get_panic_on_pe()) {
		/* If the count is different 'after' from 'before' */
		if (before_count != atomic_read(&pci_parity_count))
			panic("EDAC: PCI Parity Error");
	}
}

void edac_pci_clear_parity_errors(void)
{
	/* Clear any PCI bus parity errors that devices initially have logged
	 * in their registers.
	 */
	edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
}
void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
{

	/* global PE counter incremented by edac_pci_do_parity_check() */
	atomic_inc(&pci->counters.pe_count);

	if (edac_pci_get_log_pe())
		edac_pci_printk(pci, KERN_WARNING,
				"Parity Error ctl: %s %d: %s\n",
				pci->ctl_name, pci->pci_idx, msg);

	/*
	 * poke all PCI devices and see which one is the troublemaker
	 * panic() is called if set
	 */
	edac_pci_do_parity_check();
}
EXPORT_SYMBOL_GPL(edac_pci_handle_pe);

void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg)
{

	/* global NPE counter incremented by edac_pci_do_parity_check() */
	atomic_inc(&pci->counters.npe_count);

	if (edac_pci_get_log_npe())
		edac_pci_printk(pci, KERN_WARNING,
				"Non-Parity Error ctl: %s %d: %s\n",
				pci->ctl_name, pci->pci_idx, msg);

	/*
	 * poke all PCI devices and see which one is the troublemaker
	 * panic() is called if set
	 */
	edac_pci_do_parity_check();
}
EXPORT_SYMBOL_GPL(edac_pci_handle_npe);

/*
 * Define the PCI parameter to the module
 */
module_param(check_pci_errors, int, 0644);
MODULE_PARM_DESC(check_pci_errors,
		"Check for PCI bus parity errors: 0=off 1=on");
module_param(edac_pci_panic_on_pe, int, 0644);
MODULE_PARM_DESC(edac_pci_panic_on_pe,
		"Panic on PCI Bus Parity error: 0=off 1=on");

#endif	/* CONFIG_PCI */
Commit	Line	Data
20bcb7a8	1	/*
7c9281d7 DT	2	* (C) 2005, 2006 Linux Networx (http://lnxi.com)
	3	* This file may be distributed under the terms of the
	4	* GNU General Public License.
	5	*
	6	* Written Doug Thompson <norsk5@xmission.com>
	7	*
	8	*/
	9	#include <linux/module.h>
	10	#include <linux/sysdev.h>
	11	#include <linux/ctype.h>
	12
20bcb7a8	13	#include "edac_core.h"
7c9281d7 DT	14	#include "edac_module.h"
	15
	16
	17	#ifdef CONFIG_PCI
91b99041 DJ	18
	19	#define EDAC_PCI_SYMLINK "device"
	20
	21	static int check_pci_errors = 0; /* default YES check PCI parity */
4de78c68 DJ	22	static int edac_pci_panic_on_pe = 0; /* default no panic on PCI Parity */
	23	static int edac_pci_log_pe = 1; /* log PCI parity errors */
	24	static int edac_pci_log_npe = 1; /* log PCI non-parity error errors */
7c9281d7	25	static atomic_t pci_parity_count = ATOMIC_INIT(0);
91b99041	26	static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
4de78c68	27	static int edac_pci_poll_msec = 1000;
7c9281d7 DT	28
	29	static struct kobject edac_pci_kobj; /* /sys/devices/system/edac/pci */
	30	static struct completion edac_pci_kobj_complete;
91b99041 DJ	31	static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);
91b99041 DJ	32
4de78c68 DJ	33	int edac_pci_get_check_errors(void)
	34	{
	35	return check_pci_errors;
	36	}
	37
	38	int edac_pci_get_log_pe(void)
	39	{
	40	return edac_pci_log_pe;
	41	}
	42
	43	int edac_pci_get_log_npe(void)
	44	{
	45	return edac_pci_log_npe;
	46	}
	47
	48	int edac_pci_get_panic_on_pe(void)
	49	{
	50	return edac_pci_panic_on_pe;
	51	}
	52
	53	int edac_pci_get_poll_msec(void)
	54	{
	55	return edac_pci_poll_msec;
	56	}
	57
91b99041 DJ	58	/************************** EDAC PCI sysfs instance *****************/
	59	static ssize_t instance_pe_count_show(struct edac_pci_ctl_info pci, char data)
	60	{
	61	return sprintf(data,"%u\n", atomic_read(&pci->counters.pe_count));
	62	}
	63
	64	static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci,
	65	char *data)
	66	{
	67	return sprintf(data,"%u\n", atomic_read(&pci->counters.npe_count));
	68	}
	69
	70	#define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
	71	#define to_instance_attr(a) container_of(a, struct instance_attribute, attr)
	72
	73	/* DEVICE instance kobject release() function */
	74	static void edac_pci_instance_release(struct kobject *kobj)
	75	{
	76	struct edac_pci_ctl_info *pci;
	77
	78	debugf1("%s()\n", __func__);
	79
	80	pci = to_instance(kobj);
	81	complete(&pci->kobj_complete);
	82	}
	83
	84	/* instance specific attribute structure */
	85	struct instance_attribute {
	86	struct attribute attr;
	87	ssize_t (show)(struct edac_pci_ctl_info , char *);
	88	ssize_t (store)(struct edac_pci_ctl_info , const char *, size_t);
	89	};
	90
	91	/* Function to 'show' fields from the edac_pci 'instance' structure */
	92	static ssize_t edac_pci_instance_show(struct kobject *kobj,
	93	struct attribute *attr,
	94	char *buffer)
	95	{
	96	struct edac_pci_ctl_info *pci = to_instance(kobj);
	97	struct instance_attribute *instance_attr = to_instance_attr(attr);
	98
	99	if (instance_attr->show)
	100	return instance_attr->show(pci, buffer);
	101	return -EIO;
	102	}
	103
	104
	105	/* Function to 'store' fields into the edac_pci 'instance' structure */
	106	static ssize_t edac_pci_instance_store(struct kobject *kobj,
	107	struct attribute *attr,
	108	const char *buffer, size_t count)
	109	{
	110	struct edac_pci_ctl_info *pci = to_instance(kobj);
	111	struct instance_attribute *instance_attr = to_instance_attr(attr);
	112
	113	if (instance_attr->store)
	114	return instance_attr->store(pci, buffer, count);
	115	return -EIO;
	116	}
	117
	118	static struct sysfs_ops pci_instance_ops = {
	119	.show = edac_pci_instance_show,
	120	.store = edac_pci_instance_store
	121	};
122
123	#define INSTANCE_ATTR(_name, _mode, _show, _store) \
124	static struct instance_attribute attr_instance_##_name = { \
125	.attr = {.name = __stringify(_name), .mode = _mode }, \
126	.show = _show, \
127	.store = _store, \
128	};
129
130	INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL);
131	INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL);
132
133	/* pci instance attributes */
134	static struct instance_attribute *pci_instance_attr[] = {
135	&attr_instance_pe_count,
136	&attr_instance_npe_count,
137	NULL
138	};
7c9281d7	139
91b99041 DJ	140	/* the ktype for pci instance */
	141	static struct kobj_type ktype_pci_instance = {
	142	.release = edac_pci_instance_release,
	143	.sysfs_ops = &pci_instance_ops,
	144	.default_attrs = (struct attribute **)pci_instance_attr,
	145	};
	146
	147	static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
	148	{
	149	int err;
	150
	151	pci->kobj.parent = &edac_pci_kobj;
	152	pci->kobj.ktype = &ktype_pci_instance;
	153
	154	err = kobject_set_name(&pci->kobj, "pci%d", idx);
	155	if (err)
	156	return err;
	157
	158	err = kobject_register(&pci->kobj);
	159	if (err != 0) {
	160	debugf2("%s() failed to register instance pci%d\n",
	161	__func__, idx);
	162	return err;
	163	}
	164
	165	debugf1("%s() Register instance 'pci%d' kobject\n", __func__, idx);
	166
	167	return 0;
	168	}
	169
	170	static void
	171	edac_pci_delete_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
	172	{
	173	init_completion(&pci->kobj_complete);
	174	kobject_unregister(&pci->kobj);
	175	wait_for_completion(&pci->kobj_complete);
	176	}
	177
	178	/*************************** EDAC PCI sysfs root ********************/
	179	#define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
	180	#define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
7c9281d7 DT	181
	182	static ssize_t edac_pci_int_show(void ptr, char buffer)
	183	{
	184	int *value = ptr;
	185	return sprintf(buffer,"%d\n",*value);
	186	}
	187
	188	static ssize_t edac_pci_int_store(void ptr, const char buffer, size_t count)
	189	{
	190	int *value = ptr;
	191
	192	if (isdigit(*buffer))
	193	*value = simple_strtoul(buffer,NULL,0);
	194
	195	return count;
	196	}
	197
	198	struct edac_pci_dev_attribute {
	199	struct attribute attr;
	200	void *value;
	201	ssize_t (show)(void ,char *);
	202	ssize_t (store)(void , const char *,size_t);
	203	};
	204
	205	/* Set of show/store abstract level functions for PCI Parity object */
	206	static ssize_t edac_pci_dev_show(struct kobject kobj, struct attribute attr,
	207	char *buffer)
	208	{
	209	struct edac_pci_dev_attribute *edac_pci_dev;
	210	edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
	211
	212	if (edac_pci_dev->show)
	213	return edac_pci_dev->show(edac_pci_dev->value, buffer);
	214	return -EIO;
	215	}
	216
	217	static ssize_t edac_pci_dev_store(struct kobject *kobj,
	218	struct attribute attr, const char buffer, size_t count)
	219	{
	220	struct edac_pci_dev_attribute *edac_pci_dev;
	221	edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
	222
	223	if (edac_pci_dev->show)
	224	return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
	225	return -EIO;
	226	}
	227
	228	static struct sysfs_ops edac_pci_sysfs_ops = {
	229	.show = edac_pci_dev_show,
	230	.store = edac_pci_dev_store
	231	};
	232
	233	#define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
	234	static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
	235	.attr = {.name = __stringify(_name), .mode = _mode }, \
	236	.value = &_name, \
	237	.show = _show, \
	238	.store = _store, \
	239	};
	240
	241	#define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
	242	static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
	243	.attr = {.name = __stringify(_name), .mode = _mode }, \
	244	.value = _data, \
245	.show = _show, \
246	.store = _store, \
247	};
248
249	/* PCI Parity control files */
91b99041 DJ	250	EDAC_PCI_ATTR(check_pci_errors, S_IRUGO\|S_IWUSR, edac_pci_int_show,
91b99041 DJ	251	edac_pci_int_store);
4de78c68 DJ	252	EDAC_PCI_ATTR(edac_pci_log_pe, S_IRUGO\|S_IWUSR, edac_pci_int_show,
	253	edac_pci_int_store);
	254	EDAC_PCI_ATTR(edac_pci_log_npe, S_IRUGO\|S_IWUSR, edac_pci_int_show,
7c9281d7	255	edac_pci_int_store);
4de78c68	256	EDAC_PCI_ATTR(edac_pci_panic_on_pe, S_IRUGO\|S_IWUSR, edac_pci_int_show,
7c9281d7 DT	257	edac_pci_int_store);
7c9281d7 DT	258	EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL);
91b99041	259	EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);
7c9281d7 DT	260
	261	/* Base Attributes of the memory ECC object */
	262	static struct edac_pci_dev_attribute *edac_pci_attr[] = {
91b99041	263	&edac_pci_attr_check_pci_errors,
4de78c68 DJ	264	&edac_pci_attr_edac_pci_log_pe,
	265	&edac_pci_attr_edac_pci_log_npe,
	266	&edac_pci_attr_edac_pci_panic_on_pe,
7c9281d7	267	&edac_pci_attr_pci_parity_count,
91b99041	268	&edac_pci_attr_pci_nonparity_count,
7c9281d7 DT	269	NULL,
	270	};
	271
	272	/* No memory to release */
	273	static void edac_pci_release(struct kobject *kobj)
	274	{
91b99041 DJ	275	struct edac_pci_ctl_info *pci;
	276
	277	pci = to_edacpci(kobj);
	278
7c9281d7	279	debugf1("%s()\n", __func__);
91b99041	280	complete(&pci->kobj_complete);
7c9281d7 DT	281	}
	282
	283	static struct kobj_type ktype_edac_pci = {
	284	.release = edac_pci_release,
	285	.sysfs_ops = &edac_pci_sysfs_ops,
	286	.default_attrs = (struct attribute **) edac_pci_attr,
	287	};
	288
	289	/**
	290	* edac_sysfs_pci_setup()
	291	*
	292	* setup the sysfs for EDAC PCI attributes
	293	* assumes edac_class has already been initialized
	294	*/
91b99041	295	int edac_pci_register_main_kobj(void)
7c9281d7 DT	296	{
	297	int err;
	298	struct sysdev_class *edac_class;
	299
	300	debugf1("%s()\n", __func__);
	301
	302	edac_class = edac_get_edac_class();
91b99041 DJ	303	if (edac_class == NULL) {
	304	debugf1("%s() no edac_class\n", __func__);
	305	return -ENODEV;
	306	}
7c9281d7	307
7c9281d7	308	edac_pci_kobj.ktype = &ktype_edac_pci;
91b99041 DJ	309
	310	edac_pci_kobj.parent = &edac_class->kset.kobj;
	311
7c9281d7	312	err = kobject_set_name(&edac_pci_kobj, "pci");
91b99041 DJ	313	if(err)
91b99041 DJ	314	return err;
7c9281d7	315
91b99041 DJ	316	/* Instanstiate the pci object */
	317	/* FIXME: maybe new sysdev_create_subdir() */
	318	err = kobject_register(&edac_pci_kobj);
7c9281d7	319
91b99041 DJ	320	if (err) {
	321	debugf1("Failed to register '.../edac/pci'\n");
	322	return err;
7c9281d7 DT	323	}
7c9281d7 DT	324
91b99041 DJ	325	debugf1("Registered '.../edac/pci' kobject\n");
	326
	327	return 0;
7c9281d7 DT	328	}
	329
	330	/*
91b99041	331	* edac_pci_unregister_main_kobj()
7c9281d7 DT	332	*
	333	* perform the sysfs teardown for the PCI attributes
	334	*/
91b99041	335	void edac_pci_unregister_main_kobj(void)
7c9281d7 DT	336	{
	337	debugf0("%s()\n", __func__);
	338	init_completion(&edac_pci_kobj_complete);
	339	kobject_unregister(&edac_pci_kobj);
	340	wait_for_completion(&edac_pci_kobj_complete);
	341	}
	342
91b99041 DJ	343	int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
	344	{
	345	int err;
	346	struct kobject *edac_kobj = &pci->kobj;
	347
	348	if (atomic_inc_return(&edac_pci_sysfs_refcount) == 1) {
	349	err = edac_pci_register_main_kobj();
	350	if (err) {
	351	atomic_dec(&edac_pci_sysfs_refcount);
	352	return err;
	353	}
	354	}
	355
	356	err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
	357	if (err) {
	358	if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
	359	edac_pci_unregister_main_kobj();
	360	}
7c9281d7	361
91b99041 DJ	362
	363	debugf0("%s() idx=%d\n", __func__, pci->pci_idx);
	364
	365	err = sysfs_create_link(edac_kobj,
	366	&pci->dev->kobj,
	367	EDAC_PCI_SYMLINK);
	368	if (err) {
	369	debugf0("%s() sysfs_create_link() returned err= %d\n",
	370	__func__, err);
	371	return err;
	372	}
	373
	374	return 0;
	375	}
	376
	377	void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
	378	{
	379	debugf0("%s()\n", __func__);
	380
	381	edac_pci_delete_instance_kobj(pci, pci->pci_idx);
	382
	383	sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);
	384
	385	if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
	386	edac_pci_unregister_main_kobj();
	387	}
	388
	389	/********************** PCI error handling ***********************/
7c9281d7 DT	390	static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
	391	{
	392	int where;
	393	u16 status;
	394
	395	where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
	396	pci_read_config_word(dev, where, &status);
	397
	398	/* If we get back 0xFFFF then we must suspect that the card has been
	399	* pulled but the Linux PCI layer has not yet finished cleaning up.
	400	* We don't want to report on such devices
	401	*/
	402
	403	if (status == 0xFFFF) {
	404	u32 sanity;
	405
	406	pci_read_config_dword(dev, 0, &sanity);
	407
	408	if (sanity == 0xFFFFFFFF)
	409	return 0;
	410	}
	411
	412	status &= PCI_STATUS_DETECTED_PARITY \| PCI_STATUS_SIG_SYSTEM_ERROR \|
	413	PCI_STATUS_PARITY;
	414
	415	if (status)
	416	/* reset only the bits we are interested in */
	417	pci_write_config_word(dev, where, status);
	418
	419	return status;
	420	}
	421
	422	typedef void (pci_parity_check_fn_t) (struct pci_dev dev);
	423
	424	/* Clear any PCI parity errors logged by this device. */
	425	static void edac_pci_dev_parity_clear(struct pci_dev *dev)
	426	{
	427	u8 header_type;
	428
	429	get_pci_parity_status(dev, 0);
	430
	431	/* read the device TYPE, looking for bridges */
	432	pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
	433
	434	if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
	435	get_pci_parity_status(dev, 1);
	436	}
	437
	438	/*
	439	* PCI Parity polling
	440	*
	441	*/
	442	static void edac_pci_dev_parity_test(struct pci_dev *dev)
	443	{
	444	u16 status;
	445	u8 header_type;
	446
	447	/* read the STATUS register on this device
	448	*/
	449	status = get_pci_parity_status(dev, 0);
	450
	451	debugf2("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id );
	452
	453	/* check the status reg for errors */
454	if (status) {
91b99041	455	if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
7c9281d7 DT	456	edac_printk(KERN_CRIT, EDAC_PCI,
	457	"Signaled System Error on %s\n",
	458	pci_name(dev));
91b99041 DJ	459	atomic_inc(&pci_nonparity_count);
91b99041 DJ	460	}
7c9281d7 DT	461
	462	if (status & (PCI_STATUS_PARITY)) {
	463	edac_printk(KERN_CRIT, EDAC_PCI,
	464	"Master Data Parity Error on %s\n",
	465	pci_name(dev));
	466
	467	atomic_inc(&pci_parity_count);
	468	}
	469
	470	if (status & (PCI_STATUS_DETECTED_PARITY)) {
	471	edac_printk(KERN_CRIT, EDAC_PCI,
	472	"Detected Parity Error on %s\n",
	473	pci_name(dev));
	474
	475	atomic_inc(&pci_parity_count);
	476	}
	477	}
	478
	479	/* read the device TYPE, looking for bridges */
	480	pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
	481
	482	debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id );
	483
	484	if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
	485	/* On bridges, need to examine secondary status register */
	486	status = get_pci_parity_status(dev, 1);
	487
	488	debugf2("PCI SEC_STATUS= 0x%04x %s\n",
	489	status, dev->dev.bus_id );
	490
	491	/* check the secondary status reg for errors */
	492	if (status) {
91b99041	493	if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
7c9281d7 DT	494	edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
	495	"Signaled System Error on %s\n",
	496	pci_name(dev));
91b99041 DJ	497	atomic_inc(&pci_nonparity_count);
91b99041 DJ	498	}
7c9281d7 DT	499
	500	if (status & (PCI_STATUS_PARITY)) {
	501	edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
	502	"Master Data Parity Error on "
	503	"%s\n", pci_name(dev));
	504
	505	atomic_inc(&pci_parity_count);
	506	}
	507
	508	if (status & (PCI_STATUS_DETECTED_PARITY)) {
	509	edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
	510	"Detected Parity Error on %s\n",
	511	pci_name(dev));
	512
	513	atomic_inc(&pci_parity_count);
	514	}
	515	}
	516	}
	517	}
	518
	519	/*
	520	* pci_dev parity list iterator
	521	* Scan the PCI device list for one iteration, looking for SERRORs
	522	* Master Parity ERRORS or Parity ERRORs on primary or secondary devices
	523	*/
	524	static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
	525	{
	526	struct pci_dev *dev = NULL;
	527
	528	/* request for kernel access to the next PCI device, if any,
	529	* and while we are looking at it have its reference count
	530	* bumped until we are done with it
	531	*/
	532	while((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
	533	fn(dev);
	534	}
	535	}
	536
	537	/*
	538	* edac_pci_do_parity_check
	539	*
	540	* performs the actual PCI parity check operation
	541	*/
	542	void edac_pci_do_parity_check(void)
	543	{
	544	unsigned long flags;
	545	int before_count;
	546
	547	debugf3("%s()\n", __func__);
	548
91b99041	549	if (!check_pci_errors)
7c9281d7 DT	550	return;
	551
	552	before_count = atomic_read(&pci_parity_count);
	553
	554	/* scan all PCI devices looking for a Parity Error on devices and
	555	* bridges
	556	*/
	557	local_irq_save(flags);
	558	edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
	559	local_irq_restore(flags);
	560
	561	/* Only if operator has selected panic on PCI Error */
4de78c68	562	if (edac_pci_get_panic_on_pe()) {
7c9281d7 DT	563	/* If the count is different 'after' from 'before' */
	564	if (before_count != atomic_read(&pci_parity_count))
	565	panic("EDAC: PCI Parity Error");
	566	}
	567	}
	568
	569	void edac_pci_clear_parity_errors(void)
	570	{
	571	/* Clear any PCI bus parity errors that devices initially have logged
	572	* in their registers.
	573	*/
	574	edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
	575	}
91b99041 DJ	576	void edac_pci_handle_pe(struct edac_pci_ctl_info pci, const char msg)
	577	{
	578
	579	/* global PE counter incremented by edac_pci_do_parity_check() */
	580	atomic_inc(&pci->counters.pe_count);
	581
4de78c68	582	if (edac_pci_get_log_pe())
91b99041 DJ	583	edac_pci_printk(pci, KERN_WARNING,
	584	"Parity Error ctl: %s %d: %s\n",
	585	pci->ctl_name, pci->pci_idx, msg);
	586
	587	/*
	588	* poke all PCI devices and see which one is the troublemaker
	589	* panic() is called if set
	590	*/
	591	edac_pci_do_parity_check();
	592	}
	593	EXPORT_SYMBOL_GPL(edac_pci_handle_pe);
7c9281d7	594
91b99041 DJ	595	void edac_pci_handle_npe(struct edac_pci_ctl_info pci, const char msg)
	596	{
	597
	598	/* global NPE counter incremented by edac_pci_do_parity_check() */
	599	atomic_inc(&pci->counters.npe_count);
	600
4de78c68	601	if (edac_pci_get_log_npe())
91b99041 DJ	602	edac_pci_printk(pci, KERN_WARNING,
	603	"Non-Parity Error ctl: %s %d: %s\n",
	604	pci->ctl_name, pci->pci_idx, msg);
	605
	606	/*
	607	* poke all PCI devices and see which one is the troublemaker
	608	* panic() is called if set
	609	*/
	610	edac_pci_do_parity_check();
	611	}
	612	EXPORT_SYMBOL_GPL(edac_pci_handle_npe);
7c9281d7 DT	613
	614	/*
	615	* Define the PCI parameter to the module
	616	*/
91b99041	617	module_param(check_pci_errors, int, 0644);
4de78c68 DJ	618	MODULE_PARM_DESC(check_pci_errors,
	619	"Check for PCI bus parity errors: 0=off 1=on");
	620	module_param(edac_pci_panic_on_pe, int, 0644);
	621	MODULE_PARM_DESC(edac_pci_panic_on_pe,
	622	"Panic on PCI Bus Parity error: 0=off 1=on");
7c9281d7 DT	623
7c9281d7 DT	624	#endif /* CONFIG_PCI */