[linux-2.6-block.git] / drivers / edac / edac_module.c

/*
 * edac_module.c
 *
 * (C) 2007 www.softwarebitmaker.com
 *
 * 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.
 *
 * Author: Doug Thompson <dougthompson@xmission.com>
 *
 */
#include <linux/edac.h>

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

#define EDAC_VERSION "Ver: 3.0.0"

#ifdef CONFIG_EDAC_DEBUG
/* Values of 0 to 4 will generate output */
int edac_debug_level = 2;
EXPORT_SYMBOL_GPL(edac_debug_level);
#endif

/* scope is to module level only */
struct workqueue_struct *edac_workqueue;

/*
 * edac_op_state_to_string()
 */
char *edac_op_state_to_string(int opstate)
{
	if (opstate == OP_RUNNING_POLL)
		return "POLLED";
	else if (opstate == OP_RUNNING_INTERRUPT)
		return "INTERRUPT";
	else if (opstate == OP_RUNNING_POLL_INTR)
		return "POLL-INTR";
	else if (opstate == OP_ALLOC)
		return "ALLOC";
	else if (opstate == OP_OFFLINE)
		return "OFFLINE";

	return "UNKNOWN";
}

/*
 * edac_workqueue_setup
 *	initialize the edac work queue for polling operations
 */
static int edac_workqueue_setup(void)
{
	edac_workqueue = create_singlethread_workqueue("edac-poller");
	if (edac_workqueue == NULL)
		return -ENODEV;
	else
		return 0;
}

/*
 * edac_workqueue_teardown
 *	teardown the edac workqueue
 */
static void edac_workqueue_teardown(void)
{
	if (edac_workqueue) {
		flush_workqueue(edac_workqueue);
		destroy_workqueue(edac_workqueue);
		edac_workqueue = NULL;
	}
}

/*
 * edac_init
 *      module initialization entry point
 */
static int __init edac_init(void)
{
	int err = 0;

	edac_printk(KERN_INFO, EDAC_MC, EDAC_VERSION "\n");

	/*
	 * Harvest and clear any boot/initialization PCI parity errors
	 *
	 * FIXME: This only clears errors logged by devices present at time of
	 *      module initialization.  We should also do an initial clear
	 *      of each newly hotplugged device.
	 */
	edac_pci_clear_parity_errors();

	err = edac_mc_sysfs_init();
	if (err)
		goto error;

	edac_debugfs_init();

	/* Setup/Initialize the workq for this core */
	err = edac_workqueue_setup();
	if (err) {
		edac_printk(KERN_ERR, EDAC_MC, "init WorkQueue failure\n");
		goto error;
	}

	return 0;

error:
	return err;
}

/*
 * edac_exit()
 *      module exit/termination function
 */
static void __exit edac_exit(void)
{
	edac_dbg(0, "\n");

	/* tear down the various subsystems */
	edac_workqueue_teardown();
	edac_mc_sysfs_exit();
	edac_debugfs_exit();
}

/*
 * Inform the kernel of our entry and exit points
 */
module_init(edac_init);
module_exit(edac_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Doug Thompson www.softwarebitmaker.com, et al");
MODULE_DESCRIPTION("Core library routines for EDAC reporting");

/* refer to *_sysfs.c files for parameters that are exported via sysfs */

#ifdef CONFIG_EDAC_DEBUG
module_param(edac_debug_level, int, 0644);
MODULE_PARM_DESC(edac_debug_level, "Debug level");
#endif
Commit	Line	Data
81d87cb1 DJ	1	/*
	2	* edac_module.c
	3	*
fb3fb206 DT	4	* (C) 2007 www.softwarebitmaker.com
fb3fb206 DT	5	*
81d87cb1 DJ	6	* This file is licensed under the terms of the GNU General Public
	7	* License version 2. This program is licensed "as is" without any
	8	* warranty of any kind, whether express or implied.
	9	*
fb3fb206	10	* Author: Doug Thompson <dougthompson@xmission.com>
81d87cb1 DJ	11	*
81d87cb1 DJ	12	*/
c0d12172	13	#include <linux/edac.h>
7c9281d7	14
20bcb7a8	15	#include "edac_core.h"
7c9281d7 DT	16	#include "edac_module.h"
7c9281d7 DT	17
5156a5f4	18	#define EDAC_VERSION "Ver: 3.0.0"
7c9281d7 DT	19
	20	#ifdef CONFIG_EDAC_DEBUG
	21	/* Values of 0 to 4 will generate output */
8096cfaf	22	int edac_debug_level = 2;
7c9281d7 DT	23	EXPORT_SYMBOL_GPL(edac_debug_level);
	24	#endif
	25
e27e3dac DT	26	/* scope is to module level only */
	27	struct workqueue_struct *edac_workqueue;
	28
91b99041	29	/*
494d0d55	30	* edac_op_state_to_string()
91b99041	31	*/
494d0d55	32	char *edac_op_state_to_string(int opstate)
91b99041 DJ	33	{
	34	if (opstate == OP_RUNNING_POLL)
	35	return "POLLED";
	36	else if (opstate == OP_RUNNING_INTERRUPT)
	37	return "INTERRUPT";
	38	else if (opstate == OP_RUNNING_POLL_INTR)
	39	return "POLL-INTR";
	40	else if (opstate == OP_ALLOC)
	41	return "ALLOC";
	42	else if (opstate == OP_OFFLINE)
	43	return "OFFLINE";
	44
	45	return "UNKNOWN";
	46	}
	47
e27e3dac DT	48	/*
	49	* edac_workqueue_setup
	50	* initialize the edac work queue for polling operations
	51	*/
	52	static int edac_workqueue_setup(void)
	53	{
	54	edac_workqueue = create_singlethread_workqueue("edac-poller");
	55	if (edac_workqueue == NULL)
	56	return -ENODEV;
	57	else
	58	return 0;
	59	}
	60
	61	/*
	62	* edac_workqueue_teardown
	63	* teardown the edac workqueue
	64	*/
	65	static void edac_workqueue_teardown(void)
	66	{
	67	if (edac_workqueue) {
	68	flush_workqueue(edac_workqueue);
	69	destroy_workqueue(edac_workqueue);
	70	edac_workqueue = NULL;
	71	}
	72	}
	73
7c9281d7 DT	74	/*
	75	* edac_init
	76	* module initialization entry point
	77	*/
	78	static int __init edac_init(void)
	79	{
e27e3dac DT	80	int err = 0;
e27e3dac DT	81
fb3fb206	82	edac_printk(KERN_INFO, EDAC_MC, EDAC_VERSION "\n");
7c9281d7 DT	83
	84	/*
	85	* Harvest and clear any boot/initialization PCI parity errors
	86	*
	87	* FIXME: This only clears errors logged by devices present at time of
079708b9 DT	88	* module initialization. We should also do an initial clear
079708b9 DT	89	* of each newly hotplugged device.
7c9281d7 DT	90	*/
	91	edac_pci_clear_parity_errors();
	92
7a623c03	93	err = edac_mc_sysfs_init();
8096cfaf	94	if (err)
30e1f7a8	95	goto error;
7c9281d7	96
e7930ba4 RH	97	edac_debugfs_init();
e7930ba4 RH	98
8096cfaf	99	/* Setup/Initialize the workq for this core */
e27e3dac DT	100	err = edac_workqueue_setup();
	101	if (err) {
	102	edac_printk(KERN_ERR, EDAC_MC, "init WorkQueue failure\n");
7a623c03	103	goto error;
7c9281d7 DT	104	}
7c9281d7 DT	105
7c9281d7	106	return 0;
e27e3dac	107
052dfb45	108	error:
e27e3dac	109	return err;
7c9281d7 DT	110	}
	111
	112	/*
	113	* edac_exit()
	114	* module exit/termination function
	115	*/
	116	static void __exit edac_exit(void)
	117	{
956b9ba1	118	edac_dbg(0, "\n");
7c9281d7	119
079708b9	120	/* tear down the various subsystems */
e27e3dac	121	edac_workqueue_teardown();
7a623c03	122	edac_mc_sysfs_exit();
e7930ba4	123	edac_debugfs_exit();
7c9281d7 DT	124	}
	125
	126	/*
	127	* Inform the kernel of our entry and exit points
	128	*/
	129	module_init(edac_init);
	130	module_exit(edac_exit);
	131
	132	MODULE_LICENSE("GPL");
	133	MODULE_AUTHOR("Doug Thompson www.softwarebitmaker.com, et al");
	134	MODULE_DESCRIPTION("Core library routines for EDAC reporting");
	135
	136	/* refer to _sysfs.c files for parameters that are exported via sysfs /
	137
	138	#ifdef CONFIG_EDAC_DEBUG
	139	module_param(edac_debug_level, int, 0644);
	140	MODULE_PARM_DESC(edac_debug_level, "Debug level");
	141	#endif