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 1127