[deliverable/linux.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 panic_on_pci_parity = 0;	/* default no panic on PCI Parity */
static int log_pci_errs = 1;
static atomic_t pci_parity_count = ATOMIC_INIT(0);
static atomic_t pci_nonparity_count = ATOMIC_INIT(0);

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);

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