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