e7xxx_edac.c 16.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * Intel e7xxx Memory Controller kernel module
 * (C) 2003 Linux Networx (http://lnxi.com)
 * This file may be distributed under the terms of the
 * GNU General Public License.
 *
 * See "enum e7xxx_chips" below for supported chipsets
 *
 * Written by Thayne Harbaugh
 * Based on work by Dan Hollis <goemon at anime dot net> and others.
 *	http://www.anime.net/~goemon/linux-ecc/
 *
13 14 15
 * Datasheet:
 *	http://www.intel.com/content/www/us/en/chipsets/e7501-chipset-memory-controller-hub-datasheet.html
 *
16
 * Contributors:
17 18 19
 *	Eric Biederman (Linux Networx)
 *	Tom Zimmerman (Linux Networx)
 *	Jim Garlick (Lawrence Livermore National Labs)
20 21 22 23 24 25 26 27 28 29 30 31
 *	Dave Peterson (Lawrence Livermore National Labs)
 *	That One Guy (Some other place)
 *	Wang Zhenyu (intel.com)
 *
 * $Id: edac_e7xxx.c,v 1.5.2.9 2005/10/05 00:43:44 dsp_llnl Exp $
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/pci_ids.h>
32
#include <linux/edac.h>
33
#include "edac_core.h"
34

Michal Marek's avatar
Michal Marek committed
35
#define	E7XXX_REVISION " Ver: 2.0.2"
36
#define	EDAC_MOD_STR	"e7xxx_edac"
37

Dave Peterson's avatar
Dave Peterson committed
38
#define e7xxx_printk(level, fmt, arg...) \
39
	edac_printk(level, "e7xxx", fmt, ##arg)
Dave Peterson's avatar
Dave Peterson committed
40 41

#define e7xxx_mc_printk(mci, level, fmt, arg...) \
42
	edac_mc_chipset_printk(mci, level, "e7xxx", fmt, ##arg)
Dave Peterson's avatar
Dave Peterson committed
43

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
#ifndef PCI_DEVICE_ID_INTEL_7205_0
#define PCI_DEVICE_ID_INTEL_7205_0	0x255d
#endif				/* PCI_DEVICE_ID_INTEL_7205_0 */

#ifndef PCI_DEVICE_ID_INTEL_7205_1_ERR
#define PCI_DEVICE_ID_INTEL_7205_1_ERR	0x2551
#endif				/* PCI_DEVICE_ID_INTEL_7205_1_ERR */

#ifndef PCI_DEVICE_ID_INTEL_7500_0
#define PCI_DEVICE_ID_INTEL_7500_0	0x2540
#endif				/* PCI_DEVICE_ID_INTEL_7500_0 */

#ifndef PCI_DEVICE_ID_INTEL_7500_1_ERR
#define PCI_DEVICE_ID_INTEL_7500_1_ERR	0x2541
#endif				/* PCI_DEVICE_ID_INTEL_7500_1_ERR */

#ifndef PCI_DEVICE_ID_INTEL_7501_0
#define PCI_DEVICE_ID_INTEL_7501_0	0x254c
#endif				/* PCI_DEVICE_ID_INTEL_7501_0 */

#ifndef PCI_DEVICE_ID_INTEL_7501_1_ERR
#define PCI_DEVICE_ID_INTEL_7501_1_ERR	0x2541
#endif				/* PCI_DEVICE_ID_INTEL_7501_1_ERR */

#ifndef PCI_DEVICE_ID_INTEL_7505_0
#define PCI_DEVICE_ID_INTEL_7505_0	0x2550
#endif				/* PCI_DEVICE_ID_INTEL_7505_0 */

#ifndef PCI_DEVICE_ID_INTEL_7505_1_ERR
#define PCI_DEVICE_ID_INTEL_7505_1_ERR	0x2551
#endif				/* PCI_DEVICE_ID_INTEL_7505_1_ERR */

#define E7XXX_NR_CSROWS		8	/* number of csrows */
77
#define E7XXX_NR_DIMMS		8	/* 2 channels, 4 dimms/channel */
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148

/* E7XXX register addresses - device 0 function 0 */
#define E7XXX_DRB		0x60	/* DRAM row boundary register (8b) */
#define E7XXX_DRA		0x70	/* DRAM row attribute register (8b) */
					/*
					 * 31   Device width row 7 0=x8 1=x4
					 * 27   Device width row 6
					 * 23   Device width row 5
					 * 19   Device width row 4
					 * 15   Device width row 3
					 * 11   Device width row 2
					 *  7   Device width row 1
					 *  3   Device width row 0
					 */
#define E7XXX_DRC		0x7C	/* DRAM controller mode reg (32b) */
					/*
					 * 22    Number channels 0=1,1=2
					 * 19:18 DRB Granularity 32/64MB
					 */
#define E7XXX_TOLM		0xC4	/* DRAM top of low memory reg (16b) */
#define E7XXX_REMAPBASE		0xC6	/* DRAM remap base address reg (16b) */
#define E7XXX_REMAPLIMIT	0xC8	/* DRAM remap limit address reg (16b) */

/* E7XXX register addresses - device 0 function 1 */
#define E7XXX_DRAM_FERR		0x80	/* DRAM first error register (8b) */
#define E7XXX_DRAM_NERR		0x82	/* DRAM next error register (8b) */
#define E7XXX_DRAM_CELOG_ADD	0xA0	/* DRAM first correctable memory */
					/*     error address register (32b) */
					/*
					 * 31:28 Reserved
					 * 27:6  CE address (4k block 33:12)
					 *  5:0  Reserved
					 */
#define E7XXX_DRAM_UELOG_ADD	0xB0	/* DRAM first uncorrectable memory */
					/*     error address register (32b) */
					/*
					 * 31:28 Reserved
					 * 27:6  CE address (4k block 33:12)
					 *  5:0  Reserved
					 */
#define E7XXX_DRAM_CELOG_SYNDROME 0xD0	/* DRAM first correctable memory */
					/*     error syndrome register (16b) */

enum e7xxx_chips {
	E7500 = 0,
	E7501,
	E7505,
	E7205,
};

struct e7xxx_pvt {
	struct pci_dev *bridge_ck;
	u32 tolm;
	u32 remapbase;
	u32 remaplimit;
	const struct e7xxx_dev_info *dev_info;
};

struct e7xxx_dev_info {
	u16 err_dev;
	const char *ctl_name;
};

struct e7xxx_error_info {
	u8 dram_ferr;
	u8 dram_nerr;
	u32 dram_celog_add;
	u16 dram_celog_syndrome;
	u32 dram_uelog_add;
};

149 150
static struct edac_pci_ctl_info *e7xxx_pci;

151 152
static const struct e7xxx_dev_info e7xxx_devs[] = {
	[E7500] = {
153 154
		.err_dev = PCI_DEVICE_ID_INTEL_7500_1_ERR,
		.ctl_name = "E7500"},
155
	[E7501] = {
156 157
		.err_dev = PCI_DEVICE_ID_INTEL_7501_1_ERR,
		.ctl_name = "E7501"},
158
	[E7505] = {
159 160
		.err_dev = PCI_DEVICE_ID_INTEL_7505_1_ERR,
		.ctl_name = "E7505"},
161
	[E7205] = {
162 163
		.err_dev = PCI_DEVICE_ID_INTEL_7205_1_ERR,
		.ctl_name = "E7205"},
164 165 166 167 168
};

/* FIXME - is this valid for both SECDED and S4ECD4ED? */
static inline int e7xxx_find_channel(u16 syndrome)
{
169
	edac_dbg(3, "\n");
170 171 172

	if ((syndrome & 0xff00) == 0)
		return 0;
173

174 175
	if ((syndrome & 0x00ff) == 0)
		return 1;
176

177 178
	if ((syndrome & 0xf000) == 0 || (syndrome & 0x0f00) == 0)
		return 0;
179

180 181 182
	return 1;
}

183
static unsigned long ctl_page_to_phys(struct mem_ctl_info *mci,
184
				unsigned long page)
185 186
{
	u32 remap;
Dave Jiang's avatar
Dave Jiang committed
187
	struct e7xxx_pvt *pvt = (struct e7xxx_pvt *)mci->pvt_info;
188

189
	edac_dbg(3, "\n");
190 191

	if ((page < pvt->tolm) ||
192
		((page >= 0x100000) && (page < pvt->remapbase)))
193
		return page;
194

195
	remap = (page - pvt->tolm) + pvt->remapbase;
196

197 198
	if (remap < pvt->remaplimit)
		return remap;
199

Dave Peterson's avatar
Dave Peterson committed
200
	e7xxx_printk(KERN_ERR, "Invalid page %lx - out of range\n", page);
201 202 203
	return pvt->tolm - 1;
}

Dave Jiang's avatar
Dave Jiang committed
204
static void process_ce(struct mem_ctl_info *mci, struct e7xxx_error_info *info)
205 206 207 208 209 210
{
	u32 error_1b, page;
	u16 syndrome;
	int row;
	int channel;

211
	edac_dbg(3, "\n");
212 213 214
	/* read the error address */
	error_1b = info->dram_celog_add;
	/* FIXME - should use PAGE_SHIFT */
Dave Jiang's avatar
Dave Jiang committed
215
	page = error_1b >> 6;	/* convert the address to 4k page */
216 217 218 219 220 221
	/* read the syndrome */
	syndrome = info->dram_celog_syndrome;
	/* FIXME - check for -1 */
	row = edac_mc_find_csrow_by_page(mci, page);
	/* convert syndrome to channel */
	channel = e7xxx_find_channel(syndrome);
222
	edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, page, 0, syndrome,
223
			     row, channel, -1, "e7xxx CE", "");
224 225 226 227
}

static void process_ce_no_info(struct mem_ctl_info *mci)
{
228
	edac_dbg(3, "\n");
229
	edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1, 0, 0, 0, -1, -1, -1,
230
			     "e7xxx CE log register overflow", "");
231 232
}

Dave Jiang's avatar
Dave Jiang committed
233
static void process_ue(struct mem_ctl_info *mci, struct e7xxx_error_info *info)
234 235 236 237
{
	u32 error_2b, block_page;
	int row;

238
	edac_dbg(3, "\n");
239 240 241
	/* read the error address */
	error_2b = info->dram_uelog_add;
	/* FIXME - should use PAGE_SHIFT */
Dave Jiang's avatar
Dave Jiang committed
242
	block_page = error_2b >> 6;	/* convert to 4k address */
243
	row = edac_mc_find_csrow_by_page(mci, block_page);
244

245
	edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1, block_page, 0, 0,
246
			     row, -1, -1, "e7xxx UE", "");
247 248 249 250
}

static void process_ue_no_info(struct mem_ctl_info *mci)
{
251
	edac_dbg(3, "\n");
252

253
	edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1, 0, 0, 0, -1, -1, -1,
254
			     "e7xxx UE log register overflow", "");
255 256
}

Dave Jiang's avatar
Dave Jiang committed
257 258
static void e7xxx_get_error_info(struct mem_ctl_info *mci,
				 struct e7xxx_error_info *info)
259 260 261
{
	struct e7xxx_pvt *pvt;

Dave Jiang's avatar
Dave Jiang committed
262 263 264
	pvt = (struct e7xxx_pvt *)mci->pvt_info;
	pci_read_config_byte(pvt->bridge_ck, E7XXX_DRAM_FERR, &info->dram_ferr);
	pci_read_config_byte(pvt->bridge_ck, E7XXX_DRAM_NERR, &info->dram_nerr);
265 266 267

	if ((info->dram_ferr & 1) || (info->dram_nerr & 1)) {
		pci_read_config_dword(pvt->bridge_ck, E7XXX_DRAM_CELOG_ADD,
268
				&info->dram_celog_add);
269
		pci_read_config_word(pvt->bridge_ck,
270 271
				E7XXX_DRAM_CELOG_SYNDROME,
				&info->dram_celog_syndrome);
272 273 274 275
	}

	if ((info->dram_ferr & 2) || (info->dram_nerr & 2))
		pci_read_config_dword(pvt->bridge_ck, E7XXX_DRAM_UELOG_ADD,
276
				&info->dram_uelog_add);
277 278

	if (info->dram_ferr & 3)
279
		pci_write_bits8(pvt->bridge_ck, E7XXX_DRAM_FERR, 0x03, 0x03);
280 281

	if (info->dram_nerr & 3)
282
		pci_write_bits8(pvt->bridge_ck, E7XXX_DRAM_NERR, 0x03, 0x03);
283 284
}

Dave Jiang's avatar
Dave Jiang committed
285
static int e7xxx_process_error_info(struct mem_ctl_info *mci,
286 287
				struct e7xxx_error_info *info,
				int handle_errors)
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
{
	int error_found;

	error_found = 0;

	/* decode and report errors */
	if (info->dram_ferr & 1) {	/* check first error correctable */
		error_found = 1;

		if (handle_errors)
			process_ce(mci, info);
	}

	if (info->dram_ferr & 2) {	/* check first error uncorrectable */
		error_found = 1;

		if (handle_errors)
			process_ue(mci, info);
	}

	if (info->dram_nerr & 1) {	/* check next error correctable */
		error_found = 1;

		if (handle_errors) {
			if (info->dram_ferr & 1)
				process_ce_no_info(mci);
			else
				process_ce(mci, info);
		}
	}

	if (info->dram_nerr & 2) {	/* check next error uncorrectable */
		error_found = 1;

		if (handle_errors) {
			if (info->dram_ferr & 2)
				process_ue_no_info(mci);
			else
				process_ue(mci, info);
		}
	}

	return error_found;
}

static void e7xxx_check(struct mem_ctl_info *mci)
{
	struct e7xxx_error_info info;

337
	edac_dbg(3, "\n");
338 339 340 341
	e7xxx_get_error_info(mci, &info);
	e7xxx_process_error_info(mci, &info, 1);
}

342 343
/* Return 1 if dual channel mode is active.  Else return 0. */
static inline int dual_channel_active(u32 drc, int dev_idx)
344
{
345 346
	return (dev_idx == E7501) ? ((drc >> 22) & 0x1) : 1;
}
347

348 349 350
/* Return DRB granularity (0=32mb, 1=64mb). */
static inline int drb_granularity(u32 drc, int dev_idx)
{
351
	/* only e7501 can be single channel */
352 353
	return (dev_idx == E7501) ? ((drc >> 18) & 0x3) : 1;
}
354

355
static void e7xxx_init_csrows(struct mem_ctl_info *mci, struct pci_dev *pdev,
356
			int dev_idx, u32 drc)
357 358
{
	unsigned long last_cumul_size;
359
	int index, j;
360
	u8 value;
361
	u32 dra, cumul_size, nr_pages;
362 363
	int drc_chan, drc_drbg, drc_ddim, mem_dev;
	struct csrow_info *csrow;
364
	struct dimm_info *dimm;
365
	enum edac_type edac_mode;
366 367

	pci_read_config_dword(pdev, E7XXX_DRA, &dra);
368 369 370 371
	drc_chan = dual_channel_active(drc, dev_idx);
	drc_drbg = drb_granularity(drc, dev_idx);
	drc_ddim = (drc >> 20) & 0x3;
	last_cumul_size = 0;
372

373
	/* The dram row boundary (DRB) reg values are boundary address
374 375 376 377
	 * for each DRAM row with a granularity of 32 or 64MB (single/dual
	 * channel operation).  DRB regs are cumulative; therefore DRB7 will
	 * contain the total memory contained in all eight rows.
	 */
378
	for (index = 0; index < mci->nr_csrows; index++) {
379
		/* mem_dev 0=x8, 1=x4 */
380
		mem_dev = (dra >> (index * 4 + 3)) & 0x1;
381
		csrow = mci->csrows[index];
382

383
		pci_read_config_byte(pdev, E7XXX_DRB + index, &value);
384 385
		/* convert a 64 or 32 MiB DRB to a page size. */
		cumul_size = value << (25 + drc_drbg - PAGE_SHIFT);
386
		edac_dbg(3, "(%d) cumul_size 0x%x\n", index, cumul_size);
387
		if (cumul_size == last_cumul_size)
388
			continue;	/* not populated */
389 390 391

		csrow->first_page = last_cumul_size;
		csrow->last_page = cumul_size - 1;
392
		nr_pages = cumul_size - last_cumul_size;
393
		last_cumul_size = cumul_size;
394

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
		/*
		* if single channel or x8 devices then SECDED
		* if dual channel and x4 then S4ECD4ED
		*/
		if (drc_ddim) {
			if (drc_chan && mem_dev) {
				edac_mode = EDAC_S4ECD4ED;
				mci->edac_cap |= EDAC_FLAG_S4ECD4ED;
			} else {
				edac_mode = EDAC_SECDED;
				mci->edac_cap |= EDAC_FLAG_SECDED;
			}
		} else
			edac_mode = EDAC_NONE;

410
		for (j = 0; j < drc_chan + 1; j++) {
411
			dimm = csrow->channels[j]->dimm;
412

413
			dimm->nr_pages = nr_pages / (drc_chan + 1);
414 415 416
			dimm->grain = 1 << 12;	/* 4KiB - resolution of CELOG */
			dimm->mtype = MEM_RDDR;	/* only one type supported */
			dimm->dtype = mem_dev ? DEV_X4 : DEV_X8;
417
			dimm->edac_mode = edac_mode;
418
		}
419
	}
420
}
421

422 423 424 425
static int e7xxx_probe1(struct pci_dev *pdev, int dev_idx)
{
	u16 pci_data;
	struct mem_ctl_info *mci = NULL;
426
	struct edac_mc_layer layers[2];
427 428 429 430 431
	struct e7xxx_pvt *pvt = NULL;
	u32 drc;
	int drc_chan;
	struct e7xxx_error_info discard;

432
	edac_dbg(0, "mci\n");
433

434 435 436
	pci_read_config_dword(pdev, E7XXX_DRC, &drc);

	drc_chan = dual_channel_active(drc, dev_idx);
437 438 439 440 441 442 443 444 445 446 447 448 449 450
	/*
	 * According with the datasheet, this device has a maximum of
	 * 4 DIMMS per channel, either single-rank or dual-rank. So, the
	 * total amount of dimms is 8 (E7XXX_NR_DIMMS).
	 * That means that the DIMM is mapped as CSROWs, and the channel
	 * will map the rank. So, an error to either channel should be
	 * attributed to the same dimm.
	 */
	layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
	layers[0].size = E7XXX_NR_CSROWS;
	layers[0].is_virt_csrow = true;
	layers[1].type = EDAC_MC_LAYER_CHANNEL;
	layers[1].size = drc_chan + 1;
	layers[1].is_virt_csrow = false;
451
	mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers, sizeof(*pvt));
452 453
	if (mci == NULL)
		return -ENOMEM;
454

455
	edac_dbg(3, "init mci\n");
456 457
	mci->mtype_cap = MEM_FLAG_RDDR;
	mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED |
458
		EDAC_FLAG_S4ECD4ED;
459 460 461
	/* FIXME - what if different memory types are in different csrows? */
	mci->mod_name = EDAC_MOD_STR;
	mci->mod_ver = E7XXX_REVISION;
462
	mci->pdev = &pdev->dev;
463
	edac_dbg(3, "init pvt\n");
Dave Jiang's avatar
Dave Jiang committed
464
	pvt = (struct e7xxx_pvt *)mci->pvt_info;
465 466
	pvt->dev_info = &e7xxx_devs[dev_idx];
	pvt->bridge_ck = pci_get_device(PCI_VENDOR_ID_INTEL,
Dave Jiang's avatar
Dave Jiang committed
467
					pvt->dev_info->err_dev, pvt->bridge_ck);
468 469 470

	if (!pvt->bridge_ck) {
		e7xxx_printk(KERN_ERR, "error reporting device not found:"
471 472
			"vendor %x device 0x%x (broken BIOS?)\n",
			PCI_VENDOR_ID_INTEL, e7xxx_devs[dev_idx].err_dev);
473 474 475
		goto fail0;
	}

476
	edac_dbg(3, "more mci init\n");
477
	mci->ctl_name = pvt->dev_info->ctl_name;
478
	mci->dev_name = pci_name(pdev);
479 480 481 482
	mci->edac_check = e7xxx_check;
	mci->ctl_page_to_phys = ctl_page_to_phys;
	e7xxx_init_csrows(mci, pdev, dev_idx, drc);
	mci->edac_cap |= EDAC_FLAG_NONE;
483
	edac_dbg(3, "tolm, remapbase, remaplimit\n");
484
	/* load the top of low memory, remap base, and remap limit vars */
485
	pci_read_config_word(pdev, E7XXX_TOLM, &pci_data);
486
	pvt->tolm = ((u32) pci_data) << 4;
487
	pci_read_config_word(pdev, E7XXX_REMAPBASE, &pci_data);
488
	pvt->remapbase = ((u32) pci_data) << 14;
489
	pci_read_config_word(pdev, E7XXX_REMAPLIMIT, &pci_data);
490
	pvt->remaplimit = ((u32) pci_data) << 14;
Dave Peterson's avatar
Dave Peterson committed
491
	e7xxx_printk(KERN_INFO,
492 493
		"tolm = %x, remapbase = %x, remaplimit = %x\n", pvt->tolm,
		pvt->remapbase, pvt->remaplimit);
494 495

	/* clear any pending errors, or initial state bits */
496
	e7xxx_get_error_info(mci, &discard);
497

498 499 500
	/* Here we assume that we will never see multiple instances of this
	 * type of memory controller.  The ID is therefore hardcoded to 0.
	 */
501
	if (edac_mc_add_mc(mci)) {
502
		edac_dbg(3, "failed edac_mc_add_mc()\n");
503
		goto fail1;
504 505
	}

506 507 508 509 510 511 512 513 514 515 516
	/* allocating generic PCI control info */
	e7xxx_pci = edac_pci_create_generic_ctl(&pdev->dev, EDAC_MOD_STR);
	if (!e7xxx_pci) {
		printk(KERN_WARNING
			"%s(): Unable to create PCI control\n",
			__func__);
		printk(KERN_WARNING
			"%s(): PCI error report via EDAC not setup\n",
			__func__);
	}

517
	/* get this far and it's successful */
518
	edac_dbg(3, "success\n");
519 520
	return 0;

521
fail1:
522 523
	pci_dev_put(pvt->bridge_ck);

524
fail0:
525
	edac_mc_free(mci);
526

527
	return -ENODEV;
528 529 530
}

/* returns count (>= 0), or negative on error */
531
static int e7xxx_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
532
{
533
	edac_dbg(0, "\n");
534 535 536

	/* wake up and enable device */
	return pci_enable_device(pdev) ?
537
		-EIO : e7xxx_probe1(pdev, ent->driver_data);
538 539
}

540
static void e7xxx_remove_one(struct pci_dev *pdev)
541 542 543 544
{
	struct mem_ctl_info *mci;
	struct e7xxx_pvt *pvt;

545
	edac_dbg(0, "\n");
546

547 548 549
	if (e7xxx_pci)
		edac_pci_release_generic_ctl(e7xxx_pci);

550
	if ((mci = edac_mc_del_mc(&pdev->dev)) == NULL)
551 552
		return;

Dave Jiang's avatar
Dave Jiang committed
553
	pvt = (struct e7xxx_pvt *)mci->pvt_info;
554 555
	pci_dev_put(pvt->bridge_ck);
	edac_mc_free(mci);
556 557
}

558
static const struct pci_device_id e7xxx_pci_tbl[] = {
559
	{
Dave Jiang's avatar
Dave Jiang committed
560 561
	 PCI_VEND_DEV(INTEL, 7205_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	 E7205},
562
	{
Dave Jiang's avatar
Dave Jiang committed
563 564
	 PCI_VEND_DEV(INTEL, 7500_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	 E7500},
565
	{
Dave Jiang's avatar
Dave Jiang committed
566 567
	 PCI_VEND_DEV(INTEL, 7501_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	 E7501},
568
	{
Dave Jiang's avatar
Dave Jiang committed
569 570
	 PCI_VEND_DEV(INTEL, 7505_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
	 E7505},
571
	{
Dave Jiang's avatar
Dave Jiang committed
572 573
	 0,
	 }			/* 0 terminated list. */
574 575 576 577 578
};

MODULE_DEVICE_TABLE(pci, e7xxx_pci_tbl);

static struct pci_driver e7xxx_driver = {
Dave Peterson's avatar
Dave Peterson committed
579
	.name = EDAC_MOD_STR,
580
	.probe = e7xxx_init_one,
581
	.remove = e7xxx_remove_one,
582 583 584
	.id_table = e7xxx_pci_tbl,
};

585
static int __init e7xxx_init(void)
586
{
587 588 589
       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
       opstate_init();

590 591 592 593 594 595 596 597 598 599 600 601 602
	return pci_register_driver(&e7xxx_driver);
}

static void __exit e7xxx_exit(void)
{
	pci_unregister_driver(&e7xxx_driver);
}

module_init(e7xxx_init);
module_exit(e7xxx_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linux Networx (http://lnxi.com) Thayne Harbaugh et al\n"
603
		"Based on.work by Dan Hollis et al");
604
MODULE_DESCRIPTION("MC support for Intel e7xxx memory controllers");
605 606
module_param(edac_op_state, int, 0444);
MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");