[mirror_ubuntu-eoan-kernel.git] / drivers / edac / edac_pci.c

/*
 * EDAC PCI component
 *
 * Author: Dave Jiang <djiang@mvista.com>
 *
 * 2007 (c) MontaVista Software, Inc. This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 *
 */
#include <asm/page.h>
#include <linux/uaccess.h>
#include <linux/ctype.h>
#include <linux/highmem.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/smp.h>
#include <linux/spinlock.h>
#include <linux/sysctl.h>
#include <linux/timer.h>

#include "edac_pci.h"
#include "edac_module.h"

static DEFINE_MUTEX(edac_pci_ctls_mutex);
static LIST_HEAD(edac_pci_list);
static atomic_t pci_indexes = ATOMIC_INIT(0);

struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt,
						const char *edac_pci_name)
{
	struct edac_pci_ctl_info *pci;
	void *p = NULL, *pvt;
	unsigned int size;

	edac_dbg(1, "\n");

	pci = edac_align_ptr(&p, sizeof(*pci), 1);
	pvt = edac_align_ptr(&p, 1, sz_pvt);
	size = ((unsigned long)pvt) + sz_pvt;

	/* Alloc the needed control struct memory */
	pci = kzalloc(size, GFP_KERNEL);
	if (pci  == NULL)
		return NULL;

	/* Now much private space */
	pvt = sz_pvt ? ((char *)pci) + ((unsigned long)pvt) : NULL;

	pci->pvt_info = pvt;
	pci->op_state = OP_ALLOC;

	snprintf(pci->name, strlen(edac_pci_name) + 1, "%s", edac_pci_name);

	return pci;
}
EXPORT_SYMBOL_GPL(edac_pci_alloc_ctl_info);

void edac_pci_free_ctl_info(struct edac_pci_ctl_info *pci)
{
	edac_dbg(1, "\n");

	edac_pci_remove_sysfs(pci);
}
EXPORT_SYMBOL_GPL(edac_pci_free_ctl_info);

/*
 * find_edac_pci_by_dev()
 * 	scans the edac_pci list for a specific 'struct device *'
 *
 *	return NULL if not found, or return control struct pointer
 */
static struct edac_pci_ctl_info *find_edac_pci_by_dev(struct device *dev)
{
	struct edac_pci_ctl_info *pci;
	struct list_head *item;

	edac_dbg(1, "\n");

	list_for_each(item, &edac_pci_list) {
		pci = list_entry(item, struct edac_pci_ctl_info, link);

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

	return NULL;
}

/*
 * add_edac_pci_to_global_list
 * 	Before calling this function, caller must assign a unique value to
 * 	edac_dev->pci_idx.
 * 	Return:
 * 		0 on success
 * 		1 on failure
 */
static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci)
{
	struct list_head *item, *insert_before;
	struct edac_pci_ctl_info *rover;

	edac_dbg(1, "\n");

	insert_before = &edac_pci_list;

	/* Determine if already on the list */
	rover = find_edac_pci_by_dev(pci->dev);
	if (unlikely(rover != NULL))
		goto fail0;

	/* Insert in ascending order by 'pci_idx', so find position */
	list_for_each(item, &edac_pci_list) {
		rover = list_entry(item, struct edac_pci_ctl_info, link);

		if (rover->pci_idx >= pci->pci_idx) {
			if (unlikely(rover->pci_idx == pci->pci_idx))
				goto fail1;

			insert_before = item;
			break;
		}
	}

	list_add_tail_rcu(&pci->link, insert_before);
	return 0;

fail0:
	edac_printk(KERN_WARNING, EDAC_PCI,
		"%s (%s) %s %s already assigned %d\n",
		dev_name(rover->dev), edac_dev_name(rover),
		rover->mod_name, rover->ctl_name, rover->pci_idx);
	return 1;

fail1:
	edac_printk(KERN_WARNING, EDAC_PCI,
		"but in low-level driver: attempt to assign\n"
		"\tduplicate pci_idx %d in %s()\n", rover->pci_idx,
		__func__);
	return 1;
}

/*
 * del_edac_pci_from_global_list
 *
 *	remove the PCI control struct from the global list
 */
static void del_edac_pci_from_global_list(struct edac_pci_ctl_info *pci)
{
	list_del_rcu(&pci->link);

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

/*
 * edac_pci_workq_function()
 *
 * 	periodic function that performs the operation
 *	scheduled by a workq request, for a given PCI control struct
 */
static void edac_pci_workq_function(struct work_struct *work_req)
{
	struct delayed_work *d_work = to_delayed_work(work_req);
	struct edac_pci_ctl_info *pci = to_edac_pci_ctl_work(d_work);
	int msec;
	unsigned long delay;

	edac_dbg(3, "checking\n");

	mutex_lock(&edac_pci_ctls_mutex);

	if (pci->op_state != OP_RUNNING_POLL) {
		mutex_unlock(&edac_pci_ctls_mutex);
		return;
	}

	if (edac_pci_get_check_errors())
		pci->edac_check(pci);

	/* if we are on a one second period, then use round */
	msec = edac_pci_get_poll_msec();
	if (msec == 1000)
		delay = round_jiffies_relative(msecs_to_jiffies(msec));
	else
		delay = msecs_to_jiffies(msec);

	edac_queue_work(&pci->work, delay);

	mutex_unlock(&edac_pci_ctls_mutex);
}

int edac_pci_alloc_index(void)
{
	return atomic_inc_return(&pci_indexes) - 1;
}
EXPORT_SYMBOL_GPL(edac_pci_alloc_index);

int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx)
{
	edac_dbg(0, "\n");

	pci->pci_idx = edac_idx;
	pci->start_time = jiffies;

	mutex_lock(&edac_pci_ctls_mutex);

	if (add_edac_pci_to_global_list(pci))
		goto fail0;

	if (edac_pci_create_sysfs(pci)) {
		edac_pci_printk(pci, KERN_WARNING,
				"failed to create sysfs pci\n");
		goto fail1;
	}

	if (pci->edac_check) {
		pci->op_state = OP_RUNNING_POLL;

		INIT_DELAYED_WORK(&pci->work, edac_pci_workq_function);
		edac_queue_work(&pci->work, msecs_to_jiffies(edac_pci_get_poll_msec()));

	} else {
		pci->op_state = OP_RUNNING_INTERRUPT;
	}

	edac_pci_printk(pci, KERN_INFO,
		"Giving out device to module %s controller %s: DEV %s (%s)\n",
		pci->mod_name, pci->ctl_name, pci->dev_name,
		edac_op_state_to_string(pci->op_state));

	mutex_unlock(&edac_pci_ctls_mutex);
	return 0;

	/* error unwind stack */
fail1:
	del_edac_pci_from_global_list(pci);
fail0:
	mutex_unlock(&edac_pci_ctls_mutex);
	return 1;
}
EXPORT_SYMBOL_GPL(edac_pci_add_device);

struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev)
{
	struct edac_pci_ctl_info *pci;

	edac_dbg(0, "\n");

	mutex_lock(&edac_pci_ctls_mutex);

	/* ensure the control struct is on the global list
	 * if not, then leave
	 */
	pci = find_edac_pci_by_dev(dev);
	if (pci  == NULL) {
		mutex_unlock(&edac_pci_ctls_mutex);
		return NULL;
	}

	pci->op_state = OP_OFFLINE;

	del_edac_pci_from_global_list(pci);

	mutex_unlock(&edac_pci_ctls_mutex);

	if (pci->edac_check)
		edac_stop_work(&pci->work);

	edac_printk(KERN_INFO, EDAC_PCI,
		"Removed device %d for %s %s: DEV %s\n",
		pci->pci_idx, pci->mod_name, pci->ctl_name, edac_dev_name(pci));

	return pci;
}
EXPORT_SYMBOL_GPL(edac_pci_del_device);

/*
 * edac_pci_generic_check
 *
 *	a Generic parity check API
 */
static void edac_pci_generic_check(struct edac_pci_ctl_info *pci)
{
	edac_dbg(4, "\n");
	edac_pci_do_parity_check();
}

/* free running instance index counter */
static int edac_pci_idx;
#define EDAC_PCI_GENCTL_NAME	"EDAC PCI controller"

struct edac_pci_gen_data {
	int edac_idx;
};

struct edac_pci_ctl_info *edac_pci_create_generic_ctl(struct device *dev,
						const char *mod_name)
{
	struct edac_pci_ctl_info *pci;
	struct edac_pci_gen_data *pdata;

	pci = edac_pci_alloc_ctl_info(sizeof(*pdata), EDAC_PCI_GENCTL_NAME);
	if (!pci)
		return NULL;

	pdata = pci->pvt_info;
	pci->dev = dev;
	dev_set_drvdata(pci->dev, pci);
	pci->dev_name = pci_name(to_pci_dev(dev));

	pci->mod_name = mod_name;
	pci->ctl_name = EDAC_PCI_GENCTL_NAME;
	if (edac_op_state == EDAC_OPSTATE_POLL)
		pci->edac_check = edac_pci_generic_check;

	pdata->edac_idx = edac_pci_idx++;

	if (edac_pci_add_device(pci, pdata->edac_idx) > 0) {
		edac_dbg(3, "failed edac_pci_add_device()\n");
		edac_pci_free_ctl_info(pci);
		return NULL;
	}

	return pci;
}
EXPORT_SYMBOL_GPL(edac_pci_create_generic_ctl);

void edac_pci_release_generic_ctl(struct edac_pci_ctl_info *pci)
{
	edac_dbg(0, "pci mod=%s\n", pci->mod_name);

	edac_pci_del_device(pci->dev);
	edac_pci_free_ctl_info(pci);
}
EXPORT_SYMBOL_GPL(edac_pci_release_generic_ctl);
Commit	Line	Data
91b99041 DJ	1	/*
	2	* EDAC PCI component
	3	*
	4	* Author: Dave Jiang <djiang@mvista.com>
	5	*
	6	* 2007 (c) MontaVista Software, Inc. This file is licensed under
	7	* the terms of the GNU General Public License version 2. This program
	8	* is licensed "as is" without any warranty of any kind, whether express
	9	* or implied.
	10	*
	11	*/
0b892c71	12	#include <asm/page.h>
7c0f6ba6	13	#include <linux/uaccess.h>
0b892c71 MCC	14	#include <linux/ctype.h>
	15	#include <linux/highmem.h>
	16	#include <linux/init.h>
91b99041	17	#include <linux/module.h>
0b892c71	18	#include <linux/slab.h>
91b99041	19	#include <linux/smp.h>
0b892c71	20	#include <linux/spinlock.h>
91b99041	21	#include <linux/sysctl.h>
91b99041	22	#include <linux/timer.h>
91b99041	23
0b892c71	24	#include "edac_pci.h"
91b99041 DJ	25	#include "edac_module.h"
	26
	27	static DEFINE_MUTEX(edac_pci_ctls_mutex);
ff6ac2a6	28	static LIST_HEAD(edac_pci_list);
8641a384	29	static atomic_t pci_indexes = ATOMIC_INIT(0);
91b99041	30
079708b9	31	struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt,
052dfb45	32	const char *edac_pci_name)
91b99041 DJ	33	{
91b99041 DJ	34	struct edac_pci_ctl_info *pci;
93e4fe64	35	void p = NULL, pvt;
91b99041 DJ	36	unsigned int size;
91b99041 DJ	37
956b9ba1	38	edac_dbg(1, "\n");
d4c1465b	39
93e4fe64 MCC	40	pci = edac_align_ptr(&p, sizeof(*pci), 1);
93e4fe64 MCC	41	pvt = edac_align_ptr(&p, 1, sz_pvt);
91b99041 DJ	42	size = ((unsigned long)pvt) + sz_pvt;
91b99041 DJ	43
d4c1465b DT	44	/* Alloc the needed control struct memory */
	45	pci = kzalloc(size, GFP_KERNEL);
	46	if (pci == NULL)
91b99041 DJ	47	return NULL;
91b99041 DJ	48
d4c1465b	49	/* Now much private space */
91b99041 DJ	50	pvt = sz_pvt ? ((char *)pci) + ((unsigned long)pvt) : NULL;
	51
	52	pci->pvt_info = pvt;
91b99041 DJ	53	pci->op_state = OP_ALLOC;
91b99041 DJ	54
079708b9	55	snprintf(pci->name, strlen(edac_pci_name) + 1, "%s", edac_pci_name);
91b99041 DJ	56
	57	return pci;
	58	}
	59	EXPORT_SYMBOL_GPL(edac_pci_alloc_ctl_info);
	60
91b99041 DJ	61	void edac_pci_free_ctl_info(struct edac_pci_ctl_info *pci)
91b99041 DJ	62	{
956b9ba1	63	edac_dbg(1, "\n");
079708b9	64
d4c1465b DT	65	edac_pci_remove_sysfs(pci);
d4c1465b DT	66	}
91b99041 DJ	67	EXPORT_SYMBOL_GPL(edac_pci_free_ctl_info);
	68
	69	/*
	70	* find_edac_pci_by_dev()
	71	* scans the edac_pci list for a specific 'struct device *'
d4c1465b DT	72	*
d4c1465b DT	73	* return NULL if not found, or return control struct pointer
91b99041	74	*/
079708b9	75	static struct edac_pci_ctl_info find_edac_pci_by_dev(struct device dev)
91b99041 DJ	76	{
	77	struct edac_pci_ctl_info *pci;
	78	struct list_head *item;
	79
956b9ba1	80	edac_dbg(1, "\n");
91b99041 DJ	81
	82	list_for_each(item, &edac_pci_list) {
	83	pci = list_entry(item, struct edac_pci_ctl_info, link);
	84
	85	if (pci->dev == dev)
	86	return pci;
	87	}
	88
	89	return NULL;
	90	}
	91
	92	/*
	93	* add_edac_pci_to_global_list
	94	* Before calling this function, caller must assign a unique value to
	95	* edac_dev->pci_idx.
	96	* Return:
	97	* 0 on success
	98	* 1 on failure
	99	*/
	100	static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci)
	101	{
	102	struct list_head item, insert_before;
	103	struct edac_pci_ctl_info *rover;
	104
956b9ba1	105	edac_dbg(1, "\n");
d4c1465b	106
91b99041 DJ	107	insert_before = &edac_pci_list;
	108
	109	/* Determine if already on the list */
d4c1465b DT	110	rover = find_edac_pci_by_dev(pci->dev);
d4c1465b DT	111	if (unlikely(rover != NULL))
91b99041 DJ	112	goto fail0;
	113
	114	/* Insert in ascending order by 'pci_idx', so find position */
	115	list_for_each(item, &edac_pci_list) {
	116	rover = list_entry(item, struct edac_pci_ctl_info, link);
	117
	118	if (rover->pci_idx >= pci->pci_idx) {
	119	if (unlikely(rover->pci_idx == pci->pci_idx))
	120	goto fail1;
	121
	122	insert_before = item;
	123	break;
	124	}
	125	}
	126
	127	list_add_tail_rcu(&pci->link, insert_before);
	128	return 0;
	129
052dfb45	130	fail0:
91b99041	131	edac_printk(KERN_WARNING, EDAC_PCI,
052dfb45	132	"%s (%s) %s %s already assigned %d\n",
281efb17	133	dev_name(rover->dev), edac_dev_name(rover),
052dfb45	134	rover->mod_name, rover->ctl_name, rover->pci_idx);
91b99041 DJ	135	return 1;
91b99041 DJ	136
052dfb45	137	fail1:
91b99041	138	edac_printk(KERN_WARNING, EDAC_PCI,
052dfb45 DT	139	"but in low-level driver: attempt to assign\n"
	140	"\tduplicate pci_idx %d in %s()\n", rover->pci_idx,
	141	__func__);
91b99041 DJ	142	return 1;
	143	}
	144
91b99041 DJ	145	/*
91b99041 DJ	146	* del_edac_pci_from_global_list
d4c1465b DT	147	*
d4c1465b DT	148	* remove the PCI control struct from the global list
91b99041 DJ	149	*/
	150	static void del_edac_pci_from_global_list(struct edac_pci_ctl_info *pci)
	151	{
	152	list_del_rcu(&pci->link);
e2e77098 LJ	153
	154	/* these are for safe removal of devices from global list while
	155	* NMI handlers may be traversing list
	156	*/
	157	synchronize_rcu();
	158	INIT_LIST_HEAD(&pci->link);
91b99041 DJ	159	}
91b99041 DJ	160
91b99041 DJ	161	/*
91b99041 DJ	162	* edac_pci_workq_function()
d4c1465b DT	163	*
	164	* periodic function that performs the operation
	165	* scheduled by a workq request, for a given PCI control struct
91b99041	166	*/
91b99041 DJ	167	static void edac_pci_workq_function(struct work_struct *work_req)
91b99041 DJ	168	{
fbeb4384	169	struct delayed_work *d_work = to_delayed_work(work_req);
91b99041	170	struct edac_pci_ctl_info *pci = to_edac_pci_ctl_work(d_work);
d4c1465b DT	171	int msec;
d4c1465b DT	172	unsigned long delay;
91b99041	173
956b9ba1	174	edac_dbg(3, "checking\n");
91b99041	175
d4c1465b	176	mutex_lock(&edac_pci_ctls_mutex);
91b99041	177
06e912d4 BP	178	if (pci->op_state != OP_RUNNING_POLL) {
	179	mutex_unlock(&edac_pci_ctls_mutex);
	180	return;
d4c1465b	181	}
91b99041	182
06e912d4 BP	183	if (edac_pci_get_check_errors())
	184	pci->edac_check(pci);
	185
	186	/* if we are on a one second period, then use round */
	187	msec = edac_pci_get_poll_msec();
	188	if (msec == 1000)
	189	delay = round_jiffies_relative(msecs_to_jiffies(msec));
	190	else
	191	delay = msecs_to_jiffies(msec);
	192
	193	edac_queue_work(&pci->work, delay);
	194
d4c1465b	195	mutex_unlock(&edac_pci_ctls_mutex);
91b99041 DJ	196	}
91b99041 DJ	197
8641a384 HC	198	int edac_pci_alloc_index(void)
	199	{
	200	return atomic_inc_return(&pci_indexes) - 1;
	201	}
	202	EXPORT_SYMBOL_GPL(edac_pci_alloc_index);
	203
91b99041 DJ	204	int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx)
91b99041 DJ	205	{
956b9ba1	206	edac_dbg(0, "\n");
91b99041 DJ	207
91b99041 DJ	208	pci->pci_idx = edac_idx;
d4c1465b	209	pci->start_time = jiffies;
91b99041	210
d4c1465b	211	mutex_lock(&edac_pci_ctls_mutex);
91b99041 DJ	212
	213	if (add_edac_pci_to_global_list(pci))
	214	goto fail0;
	215
91b99041 DJ	216	if (edac_pci_create_sysfs(pci)) {
	217	edac_pci_printk(pci, KERN_WARNING,
	218	"failed to create sysfs pci\n");
	219	goto fail1;
	220	}
	221
09667606	222	if (pci->edac_check) {
91b99041 DJ	223	pci->op_state = OP_RUNNING_POLL;
91b99041 DJ	224
626a7a4d BP	225	INIT_DELAYED_WORK(&pci->work, edac_pci_workq_function);
	226	edac_queue_work(&pci->work, msecs_to_jiffies(edac_pci_get_poll_msec()));
	227
91b99041 DJ	228	} else {
	229	pci->op_state = OP_RUNNING_INTERRUPT;
	230	}
	231
	232	edac_pci_printk(pci, KERN_INFO,
7270a608 RR	233	"Giving out device to module %s controller %s: DEV %s (%s)\n",
	234	pci->mod_name, pci->ctl_name, pci->dev_name,
	235	edac_op_state_to_string(pci->op_state));
91b99041	236
d4c1465b	237	mutex_unlock(&edac_pci_ctls_mutex);
91b99041 DJ	238	return 0;
91b99041 DJ	239
d4c1465b	240	/* error unwind stack */
052dfb45	241	fail1:
91b99041	242	del_edac_pci_from_global_list(pci);
052dfb45	243	fail0:
d4c1465b	244	mutex_unlock(&edac_pci_ctls_mutex);
91b99041 DJ	245	return 1;
	246	}
	247	EXPORT_SYMBOL_GPL(edac_pci_add_device);
	248
079708b9	249	struct edac_pci_ctl_info edac_pci_del_device(struct device dev)
91b99041 DJ	250	{
	251	struct edac_pci_ctl_info *pci;
	252
956b9ba1	253	edac_dbg(0, "\n");
91b99041	254
d4c1465b	255	mutex_lock(&edac_pci_ctls_mutex);
91b99041	256
d4c1465b DT	257	/* ensure the control struct is on the global list
	258	* if not, then leave
	259	*/
	260	pci = find_edac_pci_by_dev(dev);
	261	if (pci == NULL) {
	262	mutex_unlock(&edac_pci_ctls_mutex);
91b99041 DJ	263	return NULL;
	264	}
	265
	266	pci->op_state = OP_OFFLINE;
	267
91b99041 DJ	268	del_edac_pci_from_global_list(pci);
91b99041 DJ	269
d4c1465b DT	270	mutex_unlock(&edac_pci_ctls_mutex);
d4c1465b DT	271
09667606	272	if (pci->edac_check)
626a7a4d	273	edac_stop_work(&pci->work);
91b99041 DJ	274
91b99041 DJ	275	edac_printk(KERN_INFO, EDAC_PCI,
052dfb45	276	"Removed device %d for %s %s: DEV %s\n",
17aa7e03	277	pci->pci_idx, pci->mod_name, pci->ctl_name, edac_dev_name(pci));
91b99041 DJ	278
	279	return pci;
	280	}
	281	EXPORT_SYMBOL_GPL(edac_pci_del_device);
	282
d4c1465b DT	283	/*
	284	* edac_pci_generic_check
	285	*
	286	* a Generic parity check API
	287	*/
1a45027d	288	static void edac_pci_generic_check(struct edac_pci_ctl_info *pci)
91b99041	289	{
956b9ba1	290	edac_dbg(4, "\n");
91b99041 DJ	291	edac_pci_do_parity_check();
	292	}
	293
d4c1465b	294	/* free running instance index counter */
f044091c	295	static int edac_pci_idx;
91b99041 DJ	296	#define EDAC_PCI_GENCTL_NAME "EDAC PCI controller"
	297
	298	struct edac_pci_gen_data {
	299	int edac_idx;
	300	};
	301
079708b9	302	struct edac_pci_ctl_info edac_pci_create_generic_ctl(struct device dev,
052dfb45	303	const char *mod_name)
91b99041 DJ	304	{
	305	struct edac_pci_ctl_info *pci;
	306	struct edac_pci_gen_data *pdata;
	307
	308	pci = edac_pci_alloc_ctl_info(sizeof(*pdata), EDAC_PCI_GENCTL_NAME);
	309	if (!pci)
	310	return NULL;
	311
	312	pdata = pci->pvt_info;
	313	pci->dev = dev;
	314	dev_set_drvdata(pci->dev, pci);
	315	pci->dev_name = pci_name(to_pci_dev(dev));
	316
	317	pci->mod_name = mod_name;
	318	pci->ctl_name = EDAC_PCI_GENCTL_NAME;
876bb331 BP	319	if (edac_op_state == EDAC_OPSTATE_POLL)
876bb331 BP	320	pci->edac_check = edac_pci_generic_check;
91b99041 DJ	321
	322	pdata->edac_idx = edac_pci_idx++;
	323
	324	if (edac_pci_add_device(pci, pdata->edac_idx) > 0) {
956b9ba1	325	edac_dbg(3, "failed edac_pci_add_device()\n");
91b99041 DJ	326	edac_pci_free_ctl_info(pci);
	327	return NULL;
	328	}
	329
	330	return pci;
	331	}
	332	EXPORT_SYMBOL_GPL(edac_pci_create_generic_ctl);
	333
	334	void edac_pci_release_generic_ctl(struct edac_pci_ctl_info *pci)
	335	{
956b9ba1	336	edac_dbg(0, "pci mod=%s\n", pci->mod_name);
d4c1465b	337
91b99041 DJ	338	edac_pci_del_device(pci->dev);
	339	edac_pci_free_ctl_info(pci);
	340	}
	341	EXPORT_SYMBOL_GPL(edac_pci_release_generic_ctl);