projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge master.kernel.org:/home/rmk/linux-2.6-serial
[deliverable/linux.git] / drivers / edac / e752x_edac.c
1 /*
2 * Intel e752x Memory Controller kernel module
3 * (C) 2004 Linux Networx (http://lnxi.com)
4 * This file may be distributed under the terms of the
5 * GNU General Public License.
6 *
7 * See "enum e752x_chips" below for supported chipsets
8 *
9 * Written by Tom Zimmerman
10 *
11 * Contributors:
12 * Thayne Harbaugh at realmsys.com (?)
13 * Wang Zhenyu at intel.com
14 * Dave Jiang at mvista.com
15 *
16 * $Id: edac_e752x.c,v 1.5.2.11 2005/10/05 00:43:44 dsp_llnl Exp $
17 *
18 */
19
20 #include <linux/config.h>
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/pci.h>
24 #include <linux/pci_ids.h>
25 #include <linux/slab.h>
26 #include "edac_mc.h"
27
28 #define e752x_printk(level, fmt, arg...) \
29 edac_printk(level, "e752x", fmt, ##arg)
30
31 #define e752x_mc_printk(mci, level, fmt, arg...) \
32 edac_mc_chipset_printk(mci, level, "e752x", fmt, ##arg)
33
34 #ifndef PCI_DEVICE_ID_INTEL_7520_0
35 #define PCI_DEVICE_ID_INTEL_7520_0 0x3590
36 #endif /* PCI_DEVICE_ID_INTEL_7520_0 */
37
38 #ifndef PCI_DEVICE_ID_INTEL_7520_1_ERR
39 #define PCI_DEVICE_ID_INTEL_7520_1_ERR 0x3591
40 #endif /* PCI_DEVICE_ID_INTEL_7520_1_ERR */
41
42 #ifndef PCI_DEVICE_ID_INTEL_7525_0
43 #define PCI_DEVICE_ID_INTEL_7525_0 0x359E
44 #endif /* PCI_DEVICE_ID_INTEL_7525_0 */
45
46 #ifndef PCI_DEVICE_ID_INTEL_7525_1_ERR
47 #define PCI_DEVICE_ID_INTEL_7525_1_ERR 0x3593
48 #endif /* PCI_DEVICE_ID_INTEL_7525_1_ERR */
49
50 #ifndef PCI_DEVICE_ID_INTEL_7320_0
51 #define PCI_DEVICE_ID_INTEL_7320_0 0x3592
52 #endif /* PCI_DEVICE_ID_INTEL_7320_0 */
53
54 #ifndef PCI_DEVICE_ID_INTEL_7320_1_ERR
55 #define PCI_DEVICE_ID_INTEL_7320_1_ERR 0x3593
56 #endif /* PCI_DEVICE_ID_INTEL_7320_1_ERR */
57
58 #define E752X_NR_CSROWS 8 /* number of csrows */
59
60 /* E752X register addresses - device 0 function 0 */
61 #define E752X_DRB 0x60 /* DRAM row boundary register (8b) */
62 #define E752X_DRA 0x70 /* DRAM row attribute register (8b) */
63 /*
64 * 31:30 Device width row 7
65 * 01=x8 10=x4 11=x8 DDR2
66 * 27:26 Device width row 6
67 * 23:22 Device width row 5
68 * 19:20 Device width row 4
69 * 15:14 Device width row 3
70 * 11:10 Device width row 2
71 * 7:6 Device width row 1
72 * 3:2 Device width row 0
73 */
74 #define E752X_DRC 0x7C /* DRAM controller mode reg (32b) */
75 /* FIXME:IS THIS RIGHT? */
76 /*
77 * 22 Number channels 0=1,1=2
78 * 19:18 DRB Granularity 32/64MB
79 */
80 #define E752X_DRM 0x80 /* Dimm mapping register */
81 #define E752X_DDRCSR 0x9A /* DDR control and status reg (16b) */
82 /*
83 * 14:12 1 single A, 2 single B, 3 dual
84 */
85 #define E752X_TOLM 0xC4 /* DRAM top of low memory reg (16b) */
86 #define E752X_REMAPBASE 0xC6 /* DRAM remap base address reg (16b) */
87 #define E752X_REMAPLIMIT 0xC8 /* DRAM remap limit address reg (16b) */
88 #define E752X_REMAPOFFSET 0xCA /* DRAM remap limit offset reg (16b) */
89
90 /* E752X register addresses - device 0 function 1 */
91 #define E752X_FERR_GLOBAL 0x40 /* Global first error register (32b) */
92 #define E752X_NERR_GLOBAL 0x44 /* Global next error register (32b) */
93 #define E752X_HI_FERR 0x50 /* Hub interface first error reg (8b) */
94 #define E752X_HI_NERR 0x52 /* Hub interface next error reg (8b) */
95 #define E752X_HI_ERRMASK 0x54 /* Hub interface error mask reg (8b) */
96 #define E752X_HI_SMICMD 0x5A /* Hub interface SMI command reg (8b) */
97 #define E752X_SYSBUS_FERR 0x60 /* System buss first error reg (16b) */
98 #define E752X_SYSBUS_NERR 0x62 /* System buss next error reg (16b) */
99 #define E752X_SYSBUS_ERRMASK 0x64 /* System buss error mask reg (16b) */
100 #define E752X_SYSBUS_SMICMD 0x6A /* System buss SMI command reg (16b) */
101 #define E752X_BUF_FERR 0x70 /* Memory buffer first error reg (8b) */
102 #define E752X_BUF_NERR 0x72 /* Memory buffer next error reg (8b) */
103 #define E752X_BUF_ERRMASK 0x74 /* Memory buffer error mask reg (8b) */
104 #define E752X_BUF_SMICMD 0x7A /* Memory buffer SMI command reg (8b) */
105 #define E752X_DRAM_FERR 0x80 /* DRAM first error register (16b) */
106 #define E752X_DRAM_NERR 0x82 /* DRAM next error register (16b) */
107 #define E752X_DRAM_ERRMASK 0x84 /* DRAM error mask register (8b) */
108 #define E752X_DRAM_SMICMD 0x8A /* DRAM SMI command register (8b) */
109 #define E752X_DRAM_RETR_ADD 0xAC /* DRAM Retry address register (32b) */
110 #define E752X_DRAM_SEC1_ADD 0xA0 /* DRAM first correctable memory */
111 /* error address register (32b) */
112 /*
113 * 31 Reserved
114 * 30:2 CE address (64 byte block 34:6)
115 * 1 Reserved
116 * 0 HiLoCS
117 */
118 #define E752X_DRAM_SEC2_ADD 0xC8 /* DRAM first correctable memory */
119 /* error address register (32b) */
120 /*
121 * 31 Reserved
122 * 30:2 CE address (64 byte block 34:6)
123 * 1 Reserved
124 * 0 HiLoCS
125 */
126 #define E752X_DRAM_DED_ADD 0xA4 /* DRAM first uncorrectable memory */
127 /* error address register (32b) */
128 /*
129 * 31 Reserved
130 * 30:2 CE address (64 byte block 34:6)
131 * 1 Reserved
132 * 0 HiLoCS
133 */
134 #define E752X_DRAM_SCRB_ADD 0xA8 /* DRAM first uncorrectable scrub memory */
135 /* error address register (32b) */
136 /*
137 * 31 Reserved
138 * 30:2 CE address (64 byte block 34:6)
139 * 1 Reserved
140 * 0 HiLoCS
141 */
142 #define E752X_DRAM_SEC1_SYNDROME 0xC4 /* DRAM first correctable memory */
143 /* error syndrome register (16b) */
144 #define E752X_DRAM_SEC2_SYNDROME 0xC6 /* DRAM second correctable memory */
145 /* error syndrome register (16b) */
146 #define E752X_DEVPRES1 0xF4 /* Device Present 1 register (8b) */
147
148 /* ICH5R register addresses - device 30 function 0 */
149 #define ICH5R_PCI_STAT 0x06 /* PCI status register (16b) */
150 #define ICH5R_PCI_2ND_STAT 0x1E /* PCI status secondary reg (16b) */
151 #define ICH5R_PCI_BRIDGE_CTL 0x3E /* PCI bridge control register (16b) */
152
153 enum e752x_chips {
154 E7520 = 0,
155 E7525 = 1,
156 E7320 = 2
157 };
158
159 struct e752x_pvt {
160 struct pci_dev *bridge_ck;
161 struct pci_dev *dev_d0f0;
162 struct pci_dev *dev_d0f1;
163 u32 tolm;
164 u32 remapbase;
165 u32 remaplimit;
166 int mc_symmetric;
167 u8 map[8];
168 int map_type;
169 const struct e752x_dev_info *dev_info;
170 };
171
172 struct e752x_dev_info {
173 u16 err_dev;
174 u16 ctl_dev;
175 const char *ctl_name;
176 };
177
178 struct e752x_error_info {
179 u32 ferr_global;
180 u32 nerr_global;
181 u8 hi_ferr;
182 u8 hi_nerr;
183 u16 sysbus_ferr;
184 u16 sysbus_nerr;
185 u8 buf_ferr;
186 u8 buf_nerr;
187 u16 dram_ferr;
188 u16 dram_nerr;
189 u32 dram_sec1_add;
190 u32 dram_sec2_add;
191 u16 dram_sec1_syndrome;
192 u16 dram_sec2_syndrome;
193 u32 dram_ded_add;
194 u32 dram_scrb_add;
195 u32 dram_retr_add;
196 };
197
198 static const struct e752x_dev_info e752x_devs[] = {
199 [E7520] = {
200 .err_dev = PCI_DEVICE_ID_INTEL_7520_1_ERR,
201 .ctl_dev = PCI_DEVICE_ID_INTEL_7520_0,
202 .ctl_name = "E7520"
203 },
204 [E7525] = {
205 .err_dev = PCI_DEVICE_ID_INTEL_7525_1_ERR,
206 .ctl_dev = PCI_DEVICE_ID_INTEL_7525_0,
207 .ctl_name = "E7525"
208 },
209 [E7320] = {
210 .err_dev = PCI_DEVICE_ID_INTEL_7320_1_ERR,
211 .ctl_dev = PCI_DEVICE_ID_INTEL_7320_0,
212 .ctl_name = "E7320"
213 },
214 };
215
216 static unsigned long ctl_page_to_phys(struct mem_ctl_info *mci,
217 unsigned long page)
218 {
219 u32 remap;
220 struct e752x_pvt *pvt = (struct e752x_pvt *) mci->pvt_info;
221
222 debugf3("%s()\n", __func__);
223
224 if (page < pvt->tolm)
225 return page;
226
227 if ((page >= 0x100000) && (page < pvt->remapbase))
228 return page;
229
230 remap = (page - pvt->tolm) + pvt->remapbase;
231
232 if (remap < pvt->remaplimit)
233 return remap;
234
235 e752x_printk(KERN_ERR, "Invalid page %lx - out of range\n", page);
236 return pvt->tolm - 1;
237 }
238
239 static void do_process_ce(struct mem_ctl_info *mci, u16 error_one,
240 u32 sec1_add, u16 sec1_syndrome)
241 {
242 u32 page;
243 int row;
244 int channel;
245 int i;
246 struct e752x_pvt *pvt = (struct e752x_pvt *) mci->pvt_info;
247
248 debugf3("%s()\n", __func__);
249
250 /* convert the addr to 4k page */
251 page = sec1_add >> (PAGE_SHIFT - 4);
252
253 /* FIXME - check for -1 */
254 if (pvt->mc_symmetric) {
255 /* chip select are bits 14 & 13 */
256 row = ((page >> 1) & 3);
257 e752x_printk(KERN_WARNING,
258 "Test row %d Table %d %d %d %d %d %d %d %d\n", row,
259 pvt->map[0], pvt->map[1], pvt->map[2], pvt->map[3],
260 pvt->map[4], pvt->map[5], pvt->map[6], pvt->map[7]);
261
262 /* test for channel remapping */
263 for (i = 0; i < 8; i++) {
264 if (pvt->map[i] == row)
265 break;
266 }
267
268 e752x_printk(KERN_WARNING, "Test computed row %d\n", i);
269
270 if (i < 8)
271 row = i;
272 else
273 e752x_mc_printk(mci, KERN_WARNING,
274 "row %d not found in remap table\n", row);
275 } else
276 row = edac_mc_find_csrow_by_page(mci, page);
277
278 /* 0 = channel A, 1 = channel B */
279 channel = !(error_one & 1);
280
281 if (!pvt->map_type)
282 row = 7 - row;
283
284 edac_mc_handle_ce(mci, page, 0, sec1_syndrome, row, channel,
285 "e752x CE");
286 }
287
288 static inline void process_ce(struct mem_ctl_info *mci, u16 error_one,
289 u32 sec1_add, u16 sec1_syndrome, int *error_found,
290 int handle_error)
291 {
292 *error_found = 1;
293
294 if (handle_error)
295 do_process_ce(mci, error_one, sec1_add, sec1_syndrome);
296 }
297
298 static void do_process_ue(struct mem_ctl_info *mci, u16 error_one,
299 u32 ded_add, u32 scrb_add)
300 {
301 u32 error_2b, block_page;
302 int row;
303 struct e752x_pvt *pvt = (struct e752x_pvt *) mci->pvt_info;
304
305 debugf3("%s()\n", __func__);
306
307 if (error_one & 0x0202) {
308 error_2b = ded_add;
309
310 /* convert to 4k address */
311 block_page = error_2b >> (PAGE_SHIFT - 4);
312
313 row = pvt->mc_symmetric ?
314 /* chip select are bits 14 & 13 */
315 ((block_page >> 1) & 3) :
316 edac_mc_find_csrow_by_page(mci, block_page);
317
318 edac_mc_handle_ue(mci, block_page, 0, row,
319 "e752x UE from Read");
320 }
321 if (error_one & 0x0404) {
322 error_2b = scrb_add;
323
324 /* convert to 4k address */
325 block_page = error_2b >> (PAGE_SHIFT - 4);
326
327 row = pvt->mc_symmetric ?
328 /* chip select are bits 14 & 13 */
329 ((block_page >> 1) & 3) :
330 edac_mc_find_csrow_by_page(mci, block_page);
331
332 edac_mc_handle_ue(mci, block_page, 0, row,
333 "e752x UE from Scruber");
334 }
335 }
336
337 static inline void process_ue(struct mem_ctl_info *mci, u16 error_one,
338 u32 ded_add, u32 scrb_add, int *error_found, int handle_error)
339 {
340 *error_found = 1;
341
342 if (handle_error)
343 do_process_ue(mci, error_one, ded_add, scrb_add);
344 }
345
346 static inline void process_ue_no_info_wr(struct mem_ctl_info *mci,
347 int *error_found, int handle_error)
348 {
349 *error_found = 1;
350
351 if (!handle_error)
352 return;
353
354 debugf3("%s()\n", __func__);
355 edac_mc_handle_ue_no_info(mci, "e752x UE log memory write");
356 }
357
358 static void do_process_ded_retry(struct mem_ctl_info *mci, u16 error,
359 u32 retry_add)
360 {
361 u32 error_1b, page;
362 int row;
363 struct e752x_pvt *pvt = (struct e752x_pvt *) mci->pvt_info;
364
365 error_1b = retry_add;
366 page = error_1b >> (PAGE_SHIFT - 4); /* convert the addr to 4k page */
367 row = pvt->mc_symmetric ?
368 ((page >> 1) & 3) : /* chip select are bits 14 & 13 */
369 edac_mc_find_csrow_by_page(mci, page);
370 e752x_mc_printk(mci, KERN_WARNING,
371 "CE page 0x%lx, row %d : Memory read retry\n",
372 (long unsigned int) page, row);
373 }
374
375 static inline void process_ded_retry(struct mem_ctl_info *mci, u16 error,
376 u32 retry_add, int *error_found, int handle_error)
377 {
378 *error_found = 1;
379
380 if (handle_error)
381 do_process_ded_retry(mci, error, retry_add);
382 }
383
384 static inline void process_threshold_ce(struct mem_ctl_info *mci, u16 error,
385 int *error_found, int handle_error)
386 {
387 *error_found = 1;
388
389 if (handle_error)
390 e752x_mc_printk(mci, KERN_WARNING, "Memory threshold CE\n");
391 }
392
393 static char *global_message[11] = {
394 "PCI Express C1", "PCI Express C", "PCI Express B1",
395 "PCI Express B", "PCI Express A1", "PCI Express A",
396 "DMA Controler", "HUB Interface", "System Bus",
397 "DRAM Controler", "Internal Buffer"
398 };
399
400 static char *fatal_message[2] = { "Non-Fatal ", "Fatal " };
401
402 static void do_global_error(int fatal, u32 errors)
403 {
404 int i;
405
406 for (i = 0; i < 11; i++) {
407 if (errors & (1 << i))
408 e752x_printk(KERN_WARNING, "%sError %s\n",
409 fatal_message[fatal], global_message[i]);
410 }
411 }
412
413 static inline void global_error(int fatal, u32 errors, int *error_found,
414 int handle_error)
415 {
416 *error_found = 1;
417
418 if (handle_error)
419 do_global_error(fatal, errors);
420 }
421
422 static char *hub_message[7] = {
423 "HI Address or Command Parity", "HI Illegal Access",
424 "HI Internal Parity", "Out of Range Access",
425 "HI Data Parity", "Enhanced Config Access",
426 "Hub Interface Target Abort"
427 };
428
429 static void do_hub_error(int fatal, u8 errors)
430 {
431 int i;
432
433 for (i = 0; i < 7; i++) {
434 if (errors & (1 << i))
435 e752x_printk(KERN_WARNING, "%sError %s\n",
436 fatal_message[fatal], hub_message[i]);
437 }
438 }
439
440 static inline void hub_error(int fatal, u8 errors, int *error_found,
441 int handle_error)
442 {
443 *error_found = 1;
444
445 if (handle_error)
446 do_hub_error(fatal, errors);
447 }
448
449 static char *membuf_message[4] = {
450 "Internal PMWB to DRAM parity",
451 "Internal PMWB to System Bus Parity",
452 "Internal System Bus or IO to PMWB Parity",
453 "Internal DRAM to PMWB Parity"
454 };
455
456 static void do_membuf_error(u8 errors)
457 {
458 int i;
459
460 for (i = 0; i < 4; i++) {
461 if (errors & (1 << i))
462 e752x_printk(KERN_WARNING, "Non-Fatal Error %s\n",
463 membuf_message[i]);
464 }
465 }
466
467 static inline void membuf_error(u8 errors, int *error_found, int handle_error)
468 {
469 *error_found = 1;
470
471 if (handle_error)
472 do_membuf_error(errors);
473 }
474
475 static char *sysbus_message[10] = {
476 "Addr or Request Parity",
477 "Data Strobe Glitch",
478 "Addr Strobe Glitch",
479 "Data Parity",
480 "Addr Above TOM",
481 "Non DRAM Lock Error",
482 "MCERR", "BINIT",
483 "Memory Parity",
484 "IO Subsystem Parity"
485 };
486
487 static void do_sysbus_error(int fatal, u32 errors)
488 {
489 int i;
490
491 for (i = 0; i < 10; i++) {
492 if (errors & (1 << i))
493 e752x_printk(KERN_WARNING, "%sError System Bus %s\n",
494 fatal_message[fatal], sysbus_message[i]);
495 }
496 }
497
498 static inline void sysbus_error(int fatal, u32 errors, int *error_found,
499 int handle_error)
500 {
501 *error_found = 1;
502
503 if (handle_error)
504 do_sysbus_error(fatal, errors);
505 }
506
507 static void e752x_check_hub_interface(struct e752x_error_info *info,
508 int *error_found, int handle_error)
509 {
510 u8 stat8;
511
512 //pci_read_config_byte(dev,E752X_HI_FERR,&stat8);
513
514 stat8 = info->hi_ferr;
515
516 if(stat8 & 0x7f) { /* Error, so process */
517 stat8 &= 0x7f;
518
519 if(stat8 & 0x2b)
520 hub_error(1, stat8 & 0x2b, error_found, handle_error);
521
522 if(stat8 & 0x54)
523 hub_error(0, stat8 & 0x54, error_found, handle_error);
524 }
525
526 //pci_read_config_byte(dev,E752X_HI_NERR,&stat8);
527
528 stat8 = info->hi_nerr;
529
530 if(stat8 & 0x7f) { /* Error, so process */
531 stat8 &= 0x7f;
532
533 if (stat8 & 0x2b)
534 hub_error(1, stat8 & 0x2b, error_found, handle_error);
535
536 if(stat8 & 0x54)
537 hub_error(0, stat8 & 0x54, error_found, handle_error);
538 }
539 }
540
541 static void e752x_check_sysbus(struct e752x_error_info *info,
542 int *error_found, int handle_error)
543 {
544 u32 stat32, error32;
545
546 //pci_read_config_dword(dev,E752X_SYSBUS_FERR,&stat32);
547 stat32 = info->sysbus_ferr + (info->sysbus_nerr << 16);
548
549 if (stat32 == 0)
550 return; /* no errors */
551
552 error32 = (stat32 >> 16) & 0x3ff;
553 stat32 = stat32 & 0x3ff;
554
555 if(stat32 & 0x083)
556 sysbus_error(1, stat32 & 0x083, error_found, handle_error);
557
558 if(stat32 & 0x37c)
559 sysbus_error(0, stat32 & 0x37c, error_found, handle_error);
560
561 if(error32 & 0x083)
562 sysbus_error(1, error32 & 0x083, error_found, handle_error);
563
564 if(error32 & 0x37c)
565 sysbus_error(0, error32 & 0x37c, error_found, handle_error);
566 }
567
568 static void e752x_check_membuf (struct e752x_error_info *info,
569 int *error_found, int handle_error)
570 {
571 u8 stat8;
572
573 stat8 = info->buf_ferr;
574
575 if (stat8 & 0x0f) { /* Error, so process */
576 stat8 &= 0x0f;
577 membuf_error(stat8, error_found, handle_error);
578 }
579
580 stat8 = info->buf_nerr;
581
582 if (stat8 & 0x0f) { /* Error, so process */
583 stat8 &= 0x0f;
584 membuf_error(stat8, error_found, handle_error);
585 }
586 }
587
588 static void e752x_check_dram (struct mem_ctl_info *mci,
589 struct e752x_error_info *info, int *error_found,
590 int handle_error)
591 {
592 u16 error_one, error_next;
593
594 error_one = info->dram_ferr;
595 error_next = info->dram_nerr;
596
597 /* decode and report errors */
598 if(error_one & 0x0101) /* check first error correctable */
599 process_ce(mci, error_one, info->dram_sec1_add,
600 info->dram_sec1_syndrome, error_found,
601 handle_error);
602
603 if(error_next & 0x0101) /* check next error correctable */
604 process_ce(mci, error_next, info->dram_sec2_add,
605 info->dram_sec2_syndrome, error_found,
606 handle_error);
607
608 if(error_one & 0x4040)
609 process_ue_no_info_wr(mci, error_found, handle_error);
610
611 if(error_next & 0x4040)
612 process_ue_no_info_wr(mci, error_found, handle_error);
613
614 if(error_one & 0x2020)
615 process_ded_retry(mci, error_one, info->dram_retr_add,
616 error_found, handle_error);
617
618 if(error_next & 0x2020)
619 process_ded_retry(mci, error_next, info->dram_retr_add,
620 error_found, handle_error);
621
622 if(error_one & 0x0808)
623 process_threshold_ce(mci, error_one, error_found,
624 handle_error);
625
626 if(error_next & 0x0808)
627 process_threshold_ce(mci, error_next, error_found,
628 handle_error);
629
630 if(error_one & 0x0606)
631 process_ue(mci, error_one, info->dram_ded_add,
632 info->dram_scrb_add, error_found, handle_error);
633
634 if(error_next & 0x0606)
635 process_ue(mci, error_next, info->dram_ded_add,
636 info->dram_scrb_add, error_found, handle_error);
637 }
638
639 static void e752x_get_error_info (struct mem_ctl_info *mci,
640 struct e752x_error_info *info)
641 {
642 struct pci_dev *dev;
643 struct e752x_pvt *pvt;
644
645 memset(info, 0, sizeof(*info));
646 pvt = (struct e752x_pvt *) mci->pvt_info;
647 dev = pvt->dev_d0f1;
648 pci_read_config_dword(dev, E752X_FERR_GLOBAL, &info->ferr_global);
649
650 if (info->ferr_global) {
651 pci_read_config_byte(dev, E752X_HI_FERR, &info->hi_ferr);
652 pci_read_config_word(dev, E752X_SYSBUS_FERR,
653 &info->sysbus_ferr);
654 pci_read_config_byte(dev, E752X_BUF_FERR, &info->buf_ferr);
655 pci_read_config_word(dev, E752X_DRAM_FERR,
656 &info->dram_ferr);
657 pci_read_config_dword(dev, E752X_DRAM_SEC1_ADD,
658 &info->dram_sec1_add);
659 pci_read_config_word(dev, E752X_DRAM_SEC1_SYNDROME,
660 &info->dram_sec1_syndrome);
661 pci_read_config_dword(dev, E752X_DRAM_DED_ADD,
662 &info->dram_ded_add);
663 pci_read_config_dword(dev, E752X_DRAM_SCRB_ADD,
664 &info->dram_scrb_add);
665 pci_read_config_dword(dev, E752X_DRAM_RETR_ADD,
666 &info->dram_retr_add);
667
668 if (info->hi_ferr & 0x7f)
669 pci_write_config_byte(dev, E752X_HI_FERR,
670 info->hi_ferr);
671
672 if (info->sysbus_ferr)
673 pci_write_config_word(dev, E752X_SYSBUS_FERR,
674 info->sysbus_ferr);
675
676 if (info->buf_ferr & 0x0f)
677 pci_write_config_byte(dev, E752X_BUF_FERR,
678 info->buf_ferr);
679
680 if (info->dram_ferr)
681 pci_write_bits16(pvt->bridge_ck, E752X_DRAM_FERR,
682 info->dram_ferr, info->dram_ferr);
683
684 pci_write_config_dword(dev, E752X_FERR_GLOBAL,
685 info->ferr_global);
686 }
687
688 pci_read_config_dword(dev, E752X_NERR_GLOBAL, &info->nerr_global);
689
690 if (info->nerr_global) {
691 pci_read_config_byte(dev, E752X_HI_NERR, &info->hi_nerr);
692 pci_read_config_word(dev, E752X_SYSBUS_NERR,
693 &info->sysbus_nerr);
694 pci_read_config_byte(dev, E752X_BUF_NERR, &info->buf_nerr);
695 pci_read_config_word(dev, E752X_DRAM_NERR,
696 &info->dram_nerr);
697 pci_read_config_dword(dev, E752X_DRAM_SEC2_ADD,
698 &info->dram_sec2_add);
699 pci_read_config_word(dev, E752X_DRAM_SEC2_SYNDROME,
700 &info->dram_sec2_syndrome);
701
702 if (info->hi_nerr & 0x7f)
703 pci_write_config_byte(dev, E752X_HI_NERR,
704 info->hi_nerr);
705
706 if (info->sysbus_nerr)
707 pci_write_config_word(dev, E752X_SYSBUS_NERR,
708 info->sysbus_nerr);
709
710 if (info->buf_nerr & 0x0f)
711 pci_write_config_byte(dev, E752X_BUF_NERR,
712 info->buf_nerr);
713
714 if (info->dram_nerr)
715 pci_write_bits16(pvt->bridge_ck, E752X_DRAM_NERR,
716 info->dram_nerr, info->dram_nerr);
717
718 pci_write_config_dword(dev, E752X_NERR_GLOBAL,
719 info->nerr_global);
720 }
721 }
722
723 static int e752x_process_error_info (struct mem_ctl_info *mci,
724 struct e752x_error_info *info, int handle_errors)
725 {
726 u32 error32, stat32;
727 int error_found;
728
729 error_found = 0;
730 error32 = (info->ferr_global >> 18) & 0x3ff;
731 stat32 = (info->ferr_global >> 4) & 0x7ff;
732
733 if (error32)
734 global_error(1, error32, &error_found, handle_errors);
735
736 if (stat32)
737 global_error(0, stat32, &error_found, handle_errors);
738
739 error32 = (info->nerr_global >> 18) & 0x3ff;
740 stat32 = (info->nerr_global >> 4) & 0x7ff;
741
742 if (error32)
743 global_error(1, error32, &error_found, handle_errors);
744
745 if (stat32)
746 global_error(0, stat32, &error_found, handle_errors);
747
748 e752x_check_hub_interface(info, &error_found, handle_errors);
749 e752x_check_sysbus(info, &error_found, handle_errors);
750 e752x_check_membuf(info, &error_found, handle_errors);
751 e752x_check_dram(mci, info, &error_found, handle_errors);
752 return error_found;
753 }
754
755 static void e752x_check(struct mem_ctl_info *mci)
756 {
757 struct e752x_error_info info;
758
759 debugf3("%s()\n", __func__);
760 e752x_get_error_info(mci, &info);
761 e752x_process_error_info(mci, &info, 1);
762 }
763
764 static int e752x_probe1(struct pci_dev *pdev, int dev_idx)
765 {
766 int rc = -ENODEV;
767 int index;
768 u16 pci_data;
769 u8 stat8;
770 struct mem_ctl_info *mci = NULL;
771 struct e752x_pvt *pvt = NULL;
772 u16 ddrcsr;
773 u32 drc;
774 int drc_chan; /* Number of channels 0=1chan,1=2chan */
775 int drc_drbg; /* DRB granularity 0=64mb, 1=128mb */
776 int drc_ddim; /* DRAM Data Integrity Mode 0=none,2=edac */
777 u32 dra;
778 unsigned long last_cumul_size;
779 struct pci_dev *dev = NULL;
780 struct e752x_error_info discard;
781
782 debugf0("%s(): mci\n", __func__);
783 debugf0("Starting Probe1\n");
784
785 /* enable device 0 function 1 */
786 pci_read_config_byte(pdev, E752X_DEVPRES1, &stat8);
787 stat8 |= (1 << 5);
788 pci_write_config_byte(pdev, E752X_DEVPRES1, stat8);
789
790 /* need to find out the number of channels */
791 pci_read_config_dword(pdev, E752X_DRC, &drc);
792 pci_read_config_word(pdev, E752X_DDRCSR, &ddrcsr);
793 /* FIXME: should check >>12 or 0xf, true for all? */
794 /* Dual channel = 1, Single channel = 0 */
795 drc_chan = (((ddrcsr >> 12) & 3) == 3);
796 drc_drbg = drc_chan + 1; /* 128 in dual mode, 64 in single */
797 drc_ddim = (drc >> 20) & 0x3;
798
799 mci = edac_mc_alloc(sizeof(*pvt), E752X_NR_CSROWS, drc_chan + 1);
800
801 if (mci == NULL) {
802 rc = -ENOMEM;
803 goto fail;
804 }
805
806 debugf3("%s(): init mci\n", __func__);
807 mci->mtype_cap = MEM_FLAG_RDDR;
808 mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED |
809 EDAC_FLAG_S4ECD4ED;
810 /* FIXME - what if different memory types are in different csrows? */
811 mci->mod_name = EDAC_MOD_STR;
812 mci->mod_ver = "$Revision: 1.5.2.11 $";
813 mci->pdev = pdev;
814
815 debugf3("%s(): init pvt\n", __func__);
816 pvt = (struct e752x_pvt *) mci->pvt_info;
817 pvt->dev_info = &e752x_devs[dev_idx];
818 pvt->bridge_ck = pci_get_device(PCI_VENDOR_ID_INTEL,
819 pvt->dev_info->err_dev,
820 pvt->bridge_ck);
821
822 if (pvt->bridge_ck == NULL)
823 pvt->bridge_ck = pci_scan_single_device(pdev->bus,
824 PCI_DEVFN(0, 1));
825
826 if (pvt->bridge_ck == NULL) {
827 e752x_printk(KERN_ERR, "error reporting device not found:"
828 "vendor %x device 0x%x (broken BIOS?)\n",
829 PCI_VENDOR_ID_INTEL, e752x_devs[dev_idx].err_dev);
830 goto fail;
831 }
832
833 pvt->mc_symmetric = ((ddrcsr & 0x10) != 0);
834 debugf3("%s(): more mci init\n", __func__);
835 mci->ctl_name = pvt->dev_info->ctl_name;
836 mci->edac_check = e752x_check;
837 mci->ctl_page_to_phys = ctl_page_to_phys;
838
839 /* find out the device types */
840 pci_read_config_dword(pdev, E752X_DRA, &dra);
841
842 /*
843 * The dram row boundary (DRB) reg values are boundary address for
844 * each DRAM row with a granularity of 64 or 128MB (single/dual
845 * channel operation). DRB regs are cumulative; therefore DRB7 will
846 * contain the total memory contained in all eight rows.
847 */
848 for (last_cumul_size = index = 0; index < mci->nr_csrows; index++) {
849 u8 value;
850 u32 cumul_size;
851
852 /* mem_dev 0=x8, 1=x4 */
853 int mem_dev = (dra >> (index * 4 + 2)) & 0x3;
854 struct csrow_info *csrow = &mci->csrows[index];
855
856 mem_dev = (mem_dev == 2);
857 pci_read_config_byte(mci->pdev, E752X_DRB + index, &value);
858 /* convert a 128 or 64 MiB DRB to a page size. */
859 cumul_size = value << (25 + drc_drbg - PAGE_SHIFT);
860 debugf3("%s(): (%d) cumul_size 0x%x\n", __func__, index,
861 cumul_size);
862
863 if (cumul_size == last_cumul_size)
864 continue; /* not populated */
865
866 csrow->first_page = last_cumul_size;
867 csrow->last_page = cumul_size - 1;
868 csrow->nr_pages = cumul_size - last_cumul_size;
869 last_cumul_size = cumul_size;
870 csrow->grain = 1 << 12; /* 4KiB - resolution of CELOG */
871 csrow->mtype = MEM_RDDR; /* only one type supported */
872 csrow->dtype = mem_dev ? DEV_X4 : DEV_X8;
873
874 /*
875 * if single channel or x8 devices then SECDED
876 * if dual channel and x4 then S4ECD4ED
877 */
878 if (drc_ddim) {
879 if (drc_chan && mem_dev) {
880 csrow->edac_mode = EDAC_S4ECD4ED;
881 mci->edac_cap |= EDAC_FLAG_S4ECD4ED;
882 } else {
883 csrow->edac_mode = EDAC_SECDED;
884 mci->edac_cap |= EDAC_FLAG_SECDED;
885 }
886 } else
887 csrow->edac_mode = EDAC_NONE;
888 }
889
890 /* Fill in the memory map table */
891 {
892 u8 value;
893 u8 last = 0;
894 u8 row = 0;
895
896 for (index = 0; index < 8; index += 2) {
897 pci_read_config_byte(mci->pdev, E752X_DRB + index,
898 &value);
899
900 /* test if there is a dimm in this slot */
901 if (value == last) {
902 /* no dimm in the slot, so flag it as empty */
903 pvt->map[index] = 0xff;
904 pvt->map[index + 1] = 0xff;
905 } else { /* there is a dimm in the slot */
906 pvt->map[index] = row;
907 row++;
908 last = value;
909 /* test the next value to see if the dimm is
910 double sided */
911 pci_read_config_byte(mci->pdev,
912 E752X_DRB + index + 1,
913 &value);
914 pvt->map[index + 1] = (value == last) ?
915 0xff : /* the dimm is single sided,
916 * so flag as empty
917 */
918 row; /* this is a double sided dimm
919 * to save the next row #
920 */
921 row++;
922 last = value;
923 }
924 }
925 }
926
927 /* set the map type. 1 = normal, 0 = reversed */
928 pci_read_config_byte(mci->pdev, E752X_DRM, &stat8);
929 pvt->map_type = ((stat8 & 0x0f) > ((stat8 >> 4) & 0x0f));
930
931 mci->edac_cap |= EDAC_FLAG_NONE;
932 debugf3("%s(): tolm, remapbase, remaplimit\n", __func__);
933
934 /* load the top of low memory, remap base, and remap limit vars */
935 pci_read_config_word(mci->pdev, E752X_TOLM, &pci_data);
936 pvt->tolm = ((u32) pci_data) << 4;
937 pci_read_config_word(mci->pdev, E752X_REMAPBASE, &pci_data);
938 pvt->remapbase = ((u32) pci_data) << 14;
939 pci_read_config_word(mci->pdev, E752X_REMAPLIMIT, &pci_data);
940 pvt->remaplimit = ((u32) pci_data) << 14;
941 e752x_printk(KERN_INFO,
942 "tolm = %x, remapbase = %x, remaplimit = %x\n", pvt->tolm,
943 pvt->remapbase, pvt->remaplimit);
944
945 if (edac_mc_add_mc(mci)) {
946 debugf3("%s(): failed edac_mc_add_mc()\n", __func__);
947 goto fail;
948 }
949
950 dev = pci_get_device(PCI_VENDOR_ID_INTEL, e752x_devs[dev_idx].ctl_dev,
951 NULL);
952 pvt->dev_d0f0 = dev;
953 /* find the error reporting device and clear errors */
954 dev = pvt->dev_d0f1 = pci_dev_get(pvt->bridge_ck);
955 /* Turn off error disable & SMI in case the BIOS turned it on */
956 pci_write_config_byte(dev, E752X_HI_ERRMASK, 0x00);
957 pci_write_config_byte(dev, E752X_HI_SMICMD, 0x00);
958 pci_write_config_word(dev, E752X_SYSBUS_ERRMASK, 0x00);
959 pci_write_config_word(dev, E752X_SYSBUS_SMICMD, 0x00);
960 pci_write_config_byte(dev, E752X_BUF_ERRMASK, 0x00);
961 pci_write_config_byte(dev, E752X_BUF_SMICMD, 0x00);
962 pci_write_config_byte(dev, E752X_DRAM_ERRMASK, 0x00);
963 pci_write_config_byte(dev, E752X_DRAM_SMICMD, 0x00);
964
965 e752x_get_error_info(mci, &discard); /* clear other MCH errors */
966
967 /* get this far and it's successful */
968 debugf3("%s(): success\n", __func__);
969 return 0;
970
971 fail:
972 if (mci) {
973 if (pvt->dev_d0f0)
974 pci_dev_put(pvt->dev_d0f0);
975
976 if (pvt->dev_d0f1)
977 pci_dev_put(pvt->dev_d0f1);
978
979 if (pvt->bridge_ck)
980 pci_dev_put(pvt->bridge_ck);
981
982 edac_mc_free(mci);
983 }
984
985 return rc;
986 }
987
988 /* returns count (>= 0), or negative on error */
989 static int __devinit e752x_init_one(struct pci_dev *pdev,
990 const struct pci_device_id *ent)
991 {
992 debugf0("%s()\n", __func__);
993
994 /* wake up and enable device */
995 if(pci_enable_device(pdev) < 0)
996 return -EIO;
997
998 return e752x_probe1(pdev, ent->driver_data);
999 }
1000
1001 static void __devexit e752x_remove_one(struct pci_dev *pdev)
1002 {
1003 struct mem_ctl_info *mci;
1004 struct e752x_pvt *pvt;
1005
1006 debugf0("%s()\n", __func__);
1007
1008 if ((mci = edac_mc_del_mc(pdev)) == NULL)
1009 return;
1010
1011 pvt = (struct e752x_pvt *) mci->pvt_info;
1012 pci_dev_put(pvt->dev_d0f0);
1013 pci_dev_put(pvt->dev_d0f1);
1014 pci_dev_put(pvt->bridge_ck);
1015 edac_mc_free(mci);
1016 }
1017
1018 static const struct pci_device_id e752x_pci_tbl[] __devinitdata = {
1019 {
1020 PCI_VEND_DEV(INTEL, 7520_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
1021 E7520
1022 },
1023 {
1024 PCI_VEND_DEV(INTEL, 7525_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
1025 E7525
1026 },
1027 {
1028 PCI_VEND_DEV(INTEL, 7320_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
1029 E7320
1030 },
1031 {
1032 0,
1033 } /* 0 terminated list. */
1034 };
1035
1036 MODULE_DEVICE_TABLE(pci, e752x_pci_tbl);
1037
1038 static struct pci_driver e752x_driver = {
1039 .name = EDAC_MOD_STR,
1040 .probe = e752x_init_one,
1041 .remove = __devexit_p(e752x_remove_one),
1042 .id_table = e752x_pci_tbl,
1043 };
1044
1045 static int __init e752x_init(void)
1046 {
1047 int pci_rc;
1048
1049 debugf3("%s()\n", __func__);
1050 pci_rc = pci_register_driver(&e752x_driver);
1051 return (pci_rc < 0) ? pci_rc : 0;
1052 }
1053
1054 static void __exit e752x_exit(void)
1055 {
1056 debugf3("%s()\n", __func__);
1057 pci_unregister_driver(&e752x_driver);
1058 }
1059
1060 module_init(e752x_init);
1061 module_exit(e752x_exit);
1062
1063 MODULE_LICENSE("GPL");
1064 MODULE_AUTHOR("Linux Networx (http://lnxi.com) Tom Zimmerman\n");
1065 MODULE_DESCRIPTION("MC support for Intel e752x memory controllers");
Linux kernel - Deliverables
This page took 0.079908 seconds and 6 git commands to generate.