1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for Pondicherry2 memory controller. 4 * 5 * Copyright (c) 2016, Intel Corporation. 6 * 7 * [Derived from sb_edac.c] 8 * 9 * Translation of system physical addresses to DIMM addresses 10 * is a two stage process: 11 * 12 * First the Pondicherry 2 memory controller handles slice and channel interleaving 13 * in "sys2pmi()". This is (almost) completley common between platforms. 14 * 15 * Then a platform specific dunit (DIMM unit) completes the process to provide DIMM, 16 * rank, bank, row and column using the appropriate "dunit_ops" functions/parameters. 17 */ 18 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/pci.h> 22 #include <linux/pci_ids.h> 23 #include <linux/slab.h> 24 #include <linux/delay.h> 25 #include <linux/edac.h> 26 #include <linux/mmzone.h> 27 #include <linux/smp.h> 28 #include <linux/bitmap.h> 29 #include <linux/math64.h> 30 #include <linux/mod_devicetable.h> 31 #include <linux/platform_data/x86/p2sb.h> 32 33 #include <asm/cpu_device_id.h> 34 #include <asm/intel-family.h> 35 #include <asm/processor.h> 36 #include <asm/mce.h> 37 38 #include "edac_mc.h" 39 #include "edac_module.h" 40 #include "pnd2_edac.h" 41 42 #define EDAC_MOD_STR "pnd2_edac" 43 44 #define APL_NUM_CHANNELS 4 45 #define DNV_NUM_CHANNELS 2 46 #define DNV_MAX_DIMMS 2 /* Max DIMMs per channel */ 47 48 enum type { 49 APL, 50 DNV, /* All requests go to PMI CH0 on each slice (CH1 disabled) */ 51 }; 52 53 struct dram_addr { 54 int chan; 55 int dimm; 56 int rank; 57 int bank; 58 int row; 59 int col; 60 }; 61 62 struct pnd2_pvt { 63 int dimm_geom[APL_NUM_CHANNELS]; 64 u64 tolm, tohm; 65 }; 66 67 /* 68 * System address space is divided into multiple regions with 69 * different interleave rules in each. The as0/as1 regions 70 * have no interleaving at all. The as2 region is interleaved 71 * between two channels. The mot region is magic and may overlap 72 * other regions, with its interleave rules taking precedence. 73 * Addresses not in any of these regions are interleaved across 74 * all four channels. 75 */ 76 static struct region { 77 u64 base; 78 u64 limit; 79 u8 enabled; 80 } mot, as0, as1, as2; 81 82 static struct dunit_ops { 83 char *name; 84 enum type type; 85 int pmiaddr_shift; 86 int pmiidx_shift; 87 int channels; 88 int dimms_per_channel; 89 int (*rd_reg)(int port, int off, int op, void *data, size_t sz, char *name); 90 int (*get_registers)(void); 91 int (*check_ecc)(void); 92 void (*mk_region)(char *name, struct region *rp, void *asym); 93 void (*get_dimm_config)(struct mem_ctl_info *mci); 94 int (*pmi2mem)(struct mem_ctl_info *mci, u64 pmiaddr, u32 pmiidx, 95 struct dram_addr *daddr, char *msg); 96 } *ops; 97 98 static struct mem_ctl_info *pnd2_mci; 99 100 #define PND2_MSG_SIZE 256 101 102 /* Debug macros */ 103 #define pnd2_printk(level, fmt, arg...) \ 104 edac_printk(level, "pnd2", fmt, ##arg) 105 106 #define pnd2_mc_printk(mci, level, fmt, arg...) \ 107 edac_mc_chipset_printk(mci, level, "pnd2", fmt, ##arg) 108 109 #define MOT_CHAN_INTLV_BIT_1SLC_2CH 12 110 #define MOT_CHAN_INTLV_BIT_2SLC_2CH 13 111 #define SELECTOR_DISABLED (-1) 112 #define _4GB (1ul << 32) 113 114 #define PMI_ADDRESS_WIDTH 31 115 #define PND_MAX_PHYS_BIT 39 116 117 #define APL_ASYMSHIFT 28 118 #define DNV_ASYMSHIFT 31 119 #define CH_HASH_MASK_LSB 6 120 #define SLICE_HASH_MASK_LSB 6 121 #define MOT_SLC_INTLV_BIT 12 122 #define LOG2_PMI_ADDR_GRANULARITY 5 123 #define MOT_SHIFT 24 124 125 #define GET_BITFIELD(v, lo, hi) (((v) & GENMASK_ULL(hi, lo)) >> (lo)) 126 #define U64_LSHIFT(val, s) ((u64)(val) << (s)) 127 128 /* 129 * On Apollo Lake we access memory controller registers via a 130 * side-band mailbox style interface in a hidden PCI device 131 * configuration space. 132 */ 133 static struct pci_bus *p2sb_bus; 134 #define P2SB_DEVFN PCI_DEVFN(0xd, 0) 135 #define P2SB_ADDR_OFF 0xd0 136 #define P2SB_DATA_OFF 0xd4 137 #define P2SB_STAT_OFF 0xd8 138 #define P2SB_ROUT_OFF 0xda 139 #define P2SB_EADD_OFF 0xdc 140 #define P2SB_HIDE_OFF 0xe1 141 142 #define P2SB_BUSY 1 143 144 #define P2SB_READ(size, off, ptr) \ 145 pci_bus_read_config_##size(p2sb_bus, P2SB_DEVFN, off, ptr) 146 #define P2SB_WRITE(size, off, val) \ 147 pci_bus_write_config_##size(p2sb_bus, P2SB_DEVFN, off, val) 148 149 static bool p2sb_is_busy(u16 *status) 150 { 151 P2SB_READ(word, P2SB_STAT_OFF, status); 152 153 return !!(*status & P2SB_BUSY); 154 } 155 156 static int _apl_rd_reg(int port, int off, int op, u32 *data) 157 { 158 int retries = 0xff, ret; 159 u16 status; 160 u8 hidden; 161 162 /* Unhide the P2SB device, if it's hidden */ 163 P2SB_READ(byte, P2SB_HIDE_OFF, &hidden); 164 if (hidden) 165 P2SB_WRITE(byte, P2SB_HIDE_OFF, 0); 166 167 if (p2sb_is_busy(&status)) { 168 ret = -EAGAIN; 169 goto out; 170 } 171 172 P2SB_WRITE(dword, P2SB_ADDR_OFF, (port << 24) | off); 173 P2SB_WRITE(dword, P2SB_DATA_OFF, 0); 174 P2SB_WRITE(dword, P2SB_EADD_OFF, 0); 175 P2SB_WRITE(word, P2SB_ROUT_OFF, 0); 176 P2SB_WRITE(word, P2SB_STAT_OFF, (op << 8) | P2SB_BUSY); 177 178 while (p2sb_is_busy(&status)) { 179 if (retries-- == 0) { 180 ret = -EBUSY; 181 goto out; 182 } 183 } 184 185 P2SB_READ(dword, P2SB_DATA_OFF, data); 186 ret = (status >> 1) & 0x3; 187 out: 188 /* Hide the P2SB device, if it was hidden before */ 189 if (hidden) 190 P2SB_WRITE(byte, P2SB_HIDE_OFF, hidden); 191 192 return ret; 193 } 194 195 static int apl_rd_reg(int port, int off, int op, void *data, size_t sz, char *name) 196 { 197 int ret = 0; 198 199 edac_dbg(2, "Read %s port=%x off=%x op=%x\n", name, port, off, op); 200 switch (sz) { 201 case 8: 202 ret = _apl_rd_reg(port, off + 4, op, (u32 *)(data + 4)); 203 fallthrough; 204 case 4: 205 ret |= _apl_rd_reg(port, off, op, (u32 *)data); 206 pnd2_printk(KERN_DEBUG, "%s=%x%08x ret=%d\n", name, 207 sz == 8 ? *((u32 *)(data + 4)) : 0, *((u32 *)data), ret); 208 break; 209 } 210 211 return ret; 212 } 213 214 static u64 get_mem_ctrl_hub_base_addr(void) 215 { 216 struct b_cr_mchbar_lo_pci lo; 217 struct b_cr_mchbar_hi_pci hi; 218 struct pci_dev *pdev; 219 220 pdev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x1980, NULL); 221 if (pdev) { 222 pci_read_config_dword(pdev, 0x48, (u32 *)&lo); 223 pci_read_config_dword(pdev, 0x4c, (u32 *)&hi); 224 pci_dev_put(pdev); 225 } else { 226 return 0; 227 } 228 229 if (!lo.enable) { 230 edac_dbg(2, "MMIO via memory controller hub base address is disabled!\n"); 231 return 0; 232 } 233 234 return U64_LSHIFT(hi.base, 32) | U64_LSHIFT(lo.base, 15); 235 } 236 237 #define DNV_MCHBAR_SIZE 0x8000 238 #define DNV_SB_PORT_SIZE 0x10000 239 static int dnv_rd_reg(int port, int off, int op, void *data, size_t sz, char *name) 240 { 241 struct pci_dev *pdev; 242 void __iomem *base; 243 struct resource r; 244 int ret; 245 246 if (op == 4) { 247 pdev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x1980, NULL); 248 if (!pdev) 249 return -ENODEV; 250 251 pci_read_config_dword(pdev, off, data); 252 pci_dev_put(pdev); 253 } else { 254 /* MMIO via memory controller hub base address */ 255 if (op == 0 && port == 0x4c) { 256 memset(&r, 0, sizeof(r)); 257 258 r.start = get_mem_ctrl_hub_base_addr(); 259 if (!r.start) 260 return -ENODEV; 261 r.end = r.start + DNV_MCHBAR_SIZE - 1; 262 } else { 263 /* MMIO via sideband register base address */ 264 ret = p2sb_bar(NULL, 0, &r); 265 if (ret) 266 return ret; 267 268 r.start += (port << 16); 269 r.end = r.start + DNV_SB_PORT_SIZE - 1; 270 } 271 272 base = ioremap(r.start, resource_size(&r)); 273 if (!base) 274 return -ENODEV; 275 276 if (sz == 8) 277 *(u64 *)data = readq(base + off); 278 else 279 *(u32 *)data = readl(base + off); 280 281 iounmap(base); 282 } 283 284 edac_dbg(2, "Read %s=%.8x_%.8x\n", name, 285 (sz == 8) ? *(u32 *)(data + 4) : 0, *(u32 *)data); 286 287 return 0; 288 } 289 290 #define RD_REGP(regp, regname, port) \ 291 ops->rd_reg(port, \ 292 regname##_offset, \ 293 regname##_r_opcode, \ 294 regp, sizeof(struct regname), \ 295 #regname) 296 297 #define RD_REG(regp, regname) \ 298 ops->rd_reg(regname ## _port, \ 299 regname##_offset, \ 300 regname##_r_opcode, \ 301 regp, sizeof(struct regname), \ 302 #regname) 303 304 static u64 top_lm, top_hm; 305 static bool two_slices; 306 static bool two_channels; /* Both PMI channels in one slice enabled */ 307 308 static u8 sym_chan_mask; 309 static u8 asym_chan_mask; 310 static u8 chan_mask; 311 312 static int slice_selector = -1; 313 static int chan_selector = -1; 314 static u64 slice_hash_mask; 315 static u64 chan_hash_mask; 316 317 static void mk_region(char *name, struct region *rp, u64 base, u64 limit) 318 { 319 rp->enabled = 1; 320 rp->base = base; 321 rp->limit = limit; 322 edac_dbg(2, "Region:%s [%llx, %llx]\n", name, base, limit); 323 } 324 325 static void mk_region_mask(char *name, struct region *rp, u64 base, u64 mask) 326 { 327 if (mask == 0) { 328 pr_info(FW_BUG "MOT mask cannot be zero\n"); 329 return; 330 } 331 if (mask != GENMASK_ULL(PND_MAX_PHYS_BIT, __ffs(mask))) { 332 pr_info(FW_BUG "MOT mask not power of two\n"); 333 return; 334 } 335 if (base & ~mask) { 336 pr_info(FW_BUG "MOT region base/mask alignment error\n"); 337 return; 338 } 339 rp->base = base; 340 rp->limit = (base | ~mask) & GENMASK_ULL(PND_MAX_PHYS_BIT, 0); 341 rp->enabled = 1; 342 edac_dbg(2, "Region:%s [%llx, %llx]\n", name, base, rp->limit); 343 } 344 345 static bool in_region(struct region *rp, u64 addr) 346 { 347 if (!rp->enabled) 348 return false; 349 350 return rp->base <= addr && addr <= rp->limit; 351 } 352 353 static int gen_sym_mask(struct b_cr_slice_channel_hash *p) 354 { 355 int mask = 0; 356 357 if (!p->slice_0_mem_disabled) 358 mask |= p->sym_slice0_channel_enabled; 359 360 if (!p->slice_1_disabled) 361 mask |= p->sym_slice1_channel_enabled << 2; 362 363 if (p->ch_1_disabled || p->enable_pmi_dual_data_mode) 364 mask &= 0x5; 365 366 return mask; 367 } 368 369 static int gen_asym_mask(struct b_cr_slice_channel_hash *p, 370 struct b_cr_asym_mem_region0_mchbar *as0, 371 struct b_cr_asym_mem_region1_mchbar *as1, 372 struct b_cr_asym_2way_mem_region_mchbar *as2way) 373 { 374 const int intlv[] = { 0x5, 0xA, 0x3, 0xC }; 375 int mask = 0; 376 377 if (as2way->asym_2way_interleave_enable) 378 mask = intlv[as2way->asym_2way_intlv_mode]; 379 if (as0->slice0_asym_enable) 380 mask |= (1 << as0->slice0_asym_channel_select); 381 if (as1->slice1_asym_enable) 382 mask |= (4 << as1->slice1_asym_channel_select); 383 if (p->slice_0_mem_disabled) 384 mask &= 0xc; 385 if (p->slice_1_disabled) 386 mask &= 0x3; 387 if (p->ch_1_disabled || p->enable_pmi_dual_data_mode) 388 mask &= 0x5; 389 390 return mask; 391 } 392 393 static struct b_cr_tolud_pci tolud; 394 static struct b_cr_touud_lo_pci touud_lo; 395 static struct b_cr_touud_hi_pci touud_hi; 396 static struct b_cr_asym_mem_region0_mchbar asym0; 397 static struct b_cr_asym_mem_region1_mchbar asym1; 398 static struct b_cr_asym_2way_mem_region_mchbar asym_2way; 399 static struct b_cr_mot_out_base_mchbar mot_base; 400 static struct b_cr_mot_out_mask_mchbar mot_mask; 401 static struct b_cr_slice_channel_hash chash; 402 403 /* Apollo Lake dunit */ 404 /* 405 * Validated on board with just two DIMMs in the [0] and [2] positions 406 * in this array. Other port number matches documentation, but caution 407 * advised. 408 */ 409 static const int apl_dports[APL_NUM_CHANNELS] = { 0x18, 0x10, 0x11, 0x19 }; 410 static struct d_cr_drp0 drp0[APL_NUM_CHANNELS]; 411 412 /* Denverton dunit */ 413 static const int dnv_dports[DNV_NUM_CHANNELS] = { 0x10, 0x12 }; 414 static struct d_cr_dsch dsch; 415 static struct d_cr_ecc_ctrl ecc_ctrl[DNV_NUM_CHANNELS]; 416 static struct d_cr_drp drp[DNV_NUM_CHANNELS]; 417 static struct d_cr_dmap dmap[DNV_NUM_CHANNELS]; 418 static struct d_cr_dmap1 dmap1[DNV_NUM_CHANNELS]; 419 static struct d_cr_dmap2 dmap2[DNV_NUM_CHANNELS]; 420 static struct d_cr_dmap3 dmap3[DNV_NUM_CHANNELS]; 421 static struct d_cr_dmap4 dmap4[DNV_NUM_CHANNELS]; 422 static struct d_cr_dmap5 dmap5[DNV_NUM_CHANNELS]; 423 424 static void apl_mk_region(char *name, struct region *rp, void *asym) 425 { 426 struct b_cr_asym_mem_region0_mchbar *a = asym; 427 428 mk_region(name, rp, 429 U64_LSHIFT(a->slice0_asym_base, APL_ASYMSHIFT), 430 U64_LSHIFT(a->slice0_asym_limit, APL_ASYMSHIFT) + 431 GENMASK_ULL(APL_ASYMSHIFT - 1, 0)); 432 } 433 434 static void dnv_mk_region(char *name, struct region *rp, void *asym) 435 { 436 struct b_cr_asym_mem_region_denverton *a = asym; 437 438 mk_region(name, rp, 439 U64_LSHIFT(a->slice_asym_base, DNV_ASYMSHIFT), 440 U64_LSHIFT(a->slice_asym_limit, DNV_ASYMSHIFT) + 441 GENMASK_ULL(DNV_ASYMSHIFT - 1, 0)); 442 } 443 444 static int apl_get_registers(void) 445 { 446 int ret = -ENODEV; 447 int i; 448 449 if (RD_REG(&asym_2way, b_cr_asym_2way_mem_region_mchbar)) 450 return -ENODEV; 451 452 /* 453 * RD_REGP() will fail for unpopulated or non-existent 454 * DIMM slots. Return success if we find at least one DIMM. 455 */ 456 for (i = 0; i < APL_NUM_CHANNELS; i++) 457 if (!RD_REGP(&drp0[i], d_cr_drp0, apl_dports[i])) 458 ret = 0; 459 460 return ret; 461 } 462 463 static int dnv_get_registers(void) 464 { 465 int i; 466 467 if (RD_REG(&dsch, d_cr_dsch)) 468 return -ENODEV; 469 470 for (i = 0; i < DNV_NUM_CHANNELS; i++) 471 if (RD_REGP(&ecc_ctrl[i], d_cr_ecc_ctrl, dnv_dports[i]) || 472 RD_REGP(&drp[i], d_cr_drp, dnv_dports[i]) || 473 RD_REGP(&dmap[i], d_cr_dmap, dnv_dports[i]) || 474 RD_REGP(&dmap1[i], d_cr_dmap1, dnv_dports[i]) || 475 RD_REGP(&dmap2[i], d_cr_dmap2, dnv_dports[i]) || 476 RD_REGP(&dmap3[i], d_cr_dmap3, dnv_dports[i]) || 477 RD_REGP(&dmap4[i], d_cr_dmap4, dnv_dports[i]) || 478 RD_REGP(&dmap5[i], d_cr_dmap5, dnv_dports[i])) 479 return -ENODEV; 480 481 return 0; 482 } 483 484 /* 485 * Read all the h/w config registers once here (they don't 486 * change at run time. Figure out which address ranges have 487 * which interleave characteristics. 488 */ 489 static int get_registers(void) 490 { 491 const int intlv[] = { 10, 11, 12, 12 }; 492 493 if (RD_REG(&tolud, b_cr_tolud_pci) || 494 RD_REG(&touud_lo, b_cr_touud_lo_pci) || 495 RD_REG(&touud_hi, b_cr_touud_hi_pci) || 496 RD_REG(&asym0, b_cr_asym_mem_region0_mchbar) || 497 RD_REG(&asym1, b_cr_asym_mem_region1_mchbar) || 498 RD_REG(&mot_base, b_cr_mot_out_base_mchbar) || 499 RD_REG(&mot_mask, b_cr_mot_out_mask_mchbar) || 500 RD_REG(&chash, b_cr_slice_channel_hash)) 501 return -ENODEV; 502 503 if (ops->get_registers()) 504 return -ENODEV; 505 506 if (ops->type == DNV) { 507 /* PMI channel idx (always 0) for asymmetric region */ 508 asym0.slice0_asym_channel_select = 0; 509 asym1.slice1_asym_channel_select = 0; 510 /* PMI channel bitmap (always 1) for symmetric region */ 511 chash.sym_slice0_channel_enabled = 0x1; 512 chash.sym_slice1_channel_enabled = 0x1; 513 } 514 515 if (asym0.slice0_asym_enable) 516 ops->mk_region("as0", &as0, &asym0); 517 518 if (asym1.slice1_asym_enable) 519 ops->mk_region("as1", &as1, &asym1); 520 521 if (asym_2way.asym_2way_interleave_enable) { 522 mk_region("as2way", &as2, 523 U64_LSHIFT(asym_2way.asym_2way_base, APL_ASYMSHIFT), 524 U64_LSHIFT(asym_2way.asym_2way_limit, APL_ASYMSHIFT) + 525 GENMASK_ULL(APL_ASYMSHIFT - 1, 0)); 526 } 527 528 if (mot_base.imr_en) { 529 mk_region_mask("mot", &mot, 530 U64_LSHIFT(mot_base.mot_out_base, MOT_SHIFT), 531 U64_LSHIFT(mot_mask.mot_out_mask, MOT_SHIFT)); 532 } 533 534 top_lm = U64_LSHIFT(tolud.tolud, 20); 535 top_hm = U64_LSHIFT(touud_hi.touud, 32) | U64_LSHIFT(touud_lo.touud, 20); 536 537 two_slices = !chash.slice_1_disabled && 538 !chash.slice_0_mem_disabled && 539 (chash.sym_slice0_channel_enabled != 0) && 540 (chash.sym_slice1_channel_enabled != 0); 541 two_channels = !chash.ch_1_disabled && 542 !chash.enable_pmi_dual_data_mode && 543 ((chash.sym_slice0_channel_enabled == 3) || 544 (chash.sym_slice1_channel_enabled == 3)); 545 546 sym_chan_mask = gen_sym_mask(&chash); 547 asym_chan_mask = gen_asym_mask(&chash, &asym0, &asym1, &asym_2way); 548 chan_mask = sym_chan_mask | asym_chan_mask; 549 550 if (two_slices && !two_channels) { 551 if (chash.hvm_mode) 552 slice_selector = 29; 553 else 554 slice_selector = intlv[chash.interleave_mode]; 555 } else if (!two_slices && two_channels) { 556 if (chash.hvm_mode) 557 chan_selector = 29; 558 else 559 chan_selector = intlv[chash.interleave_mode]; 560 } else if (two_slices && two_channels) { 561 if (chash.hvm_mode) { 562 slice_selector = 29; 563 chan_selector = 30; 564 } else { 565 slice_selector = intlv[chash.interleave_mode]; 566 chan_selector = intlv[chash.interleave_mode] + 1; 567 } 568 } 569 570 if (two_slices) { 571 if (!chash.hvm_mode) 572 slice_hash_mask = chash.slice_hash_mask << SLICE_HASH_MASK_LSB; 573 if (!two_channels) 574 slice_hash_mask |= BIT_ULL(slice_selector); 575 } 576 577 if (two_channels) { 578 if (!chash.hvm_mode) 579 chan_hash_mask = chash.ch_hash_mask << CH_HASH_MASK_LSB; 580 if (!two_slices) 581 chan_hash_mask |= BIT_ULL(chan_selector); 582 } 583 584 return 0; 585 } 586 587 /* Get a contiguous memory address (remove the MMIO gap) */ 588 static u64 remove_mmio_gap(u64 sys) 589 { 590 return (sys < _4GB) ? sys : sys - (_4GB - top_lm); 591 } 592 593 /* Squeeze out one address bit, shift upper part down to fill gap */ 594 static void remove_addr_bit(u64 *addr, int bitidx) 595 { 596 u64 mask; 597 598 if (bitidx == -1) 599 return; 600 601 mask = (1ull << bitidx) - 1; 602 *addr = ((*addr >> 1) & ~mask) | (*addr & mask); 603 } 604 605 /* XOR all the bits from addr specified in mask */ 606 static int hash_by_mask(u64 addr, u64 mask) 607 { 608 u64 result = addr & mask; 609 610 result = (result >> 32) ^ result; 611 result = (result >> 16) ^ result; 612 result = (result >> 8) ^ result; 613 result = (result >> 4) ^ result; 614 result = (result >> 2) ^ result; 615 result = (result >> 1) ^ result; 616 617 return (int)result & 1; 618 } 619 620 /* 621 * First stage decode. Take the system address and figure out which 622 * second stage will deal with it based on interleave modes. 623 */ 624 static int sys2pmi(const u64 addr, u32 *pmiidx, u64 *pmiaddr, char *msg) 625 { 626 u64 contig_addr, contig_base, contig_offset, contig_base_adj; 627 int mot_intlv_bit = two_slices ? MOT_CHAN_INTLV_BIT_2SLC_2CH : 628 MOT_CHAN_INTLV_BIT_1SLC_2CH; 629 int slice_intlv_bit_rm = SELECTOR_DISABLED; 630 int chan_intlv_bit_rm = SELECTOR_DISABLED; 631 /* Determine if address is in the MOT region. */ 632 bool mot_hit = in_region(&mot, addr); 633 /* Calculate the number of symmetric regions enabled. */ 634 int sym_channels = hweight8(sym_chan_mask); 635 636 /* 637 * The amount we need to shift the asym base can be determined by the 638 * number of enabled symmetric channels. 639 * NOTE: This can only work because symmetric memory is not supposed 640 * to do a 3-way interleave. 641 */ 642 int sym_chan_shift = sym_channels >> 1; 643 644 /* Give up if address is out of range, or in MMIO gap */ 645 if (addr >= (1ul << PND_MAX_PHYS_BIT) || 646 (addr >= top_lm && addr < _4GB) || addr >= top_hm) { 647 snprintf(msg, PND2_MSG_SIZE, "Error address 0x%llx is not DRAM", addr); 648 return -EINVAL; 649 } 650 651 /* Get a contiguous memory address (remove the MMIO gap) */ 652 contig_addr = remove_mmio_gap(addr); 653 654 if (in_region(&as0, addr)) { 655 *pmiidx = asym0.slice0_asym_channel_select; 656 657 contig_base = remove_mmio_gap(as0.base); 658 contig_offset = contig_addr - contig_base; 659 contig_base_adj = (contig_base >> sym_chan_shift) * 660 ((chash.sym_slice0_channel_enabled >> (*pmiidx & 1)) & 1); 661 contig_addr = contig_offset + ((sym_channels > 0) ? contig_base_adj : 0ull); 662 } else if (in_region(&as1, addr)) { 663 *pmiidx = 2u + asym1.slice1_asym_channel_select; 664 665 contig_base = remove_mmio_gap(as1.base); 666 contig_offset = contig_addr - contig_base; 667 contig_base_adj = (contig_base >> sym_chan_shift) * 668 ((chash.sym_slice1_channel_enabled >> (*pmiidx & 1)) & 1); 669 contig_addr = contig_offset + ((sym_channels > 0) ? contig_base_adj : 0ull); 670 } else if (in_region(&as2, addr) && (asym_2way.asym_2way_intlv_mode == 0x3ul)) { 671 bool channel1; 672 673 mot_intlv_bit = MOT_CHAN_INTLV_BIT_1SLC_2CH; 674 *pmiidx = (asym_2way.asym_2way_intlv_mode & 1) << 1; 675 channel1 = mot_hit ? ((bool)((addr >> mot_intlv_bit) & 1)) : 676 hash_by_mask(contig_addr, chan_hash_mask); 677 *pmiidx |= (u32)channel1; 678 679 contig_base = remove_mmio_gap(as2.base); 680 chan_intlv_bit_rm = mot_hit ? mot_intlv_bit : chan_selector; 681 contig_offset = contig_addr - contig_base; 682 remove_addr_bit(&contig_offset, chan_intlv_bit_rm); 683 contig_addr = (contig_base >> sym_chan_shift) + contig_offset; 684 } else { 685 /* Otherwise we're in normal, boring symmetric mode. */ 686 *pmiidx = 0u; 687 688 if (two_slices) { 689 bool slice1; 690 691 if (mot_hit) { 692 slice_intlv_bit_rm = MOT_SLC_INTLV_BIT; 693 slice1 = (addr >> MOT_SLC_INTLV_BIT) & 1; 694 } else { 695 slice_intlv_bit_rm = slice_selector; 696 slice1 = hash_by_mask(addr, slice_hash_mask); 697 } 698 699 *pmiidx = (u32)slice1 << 1; 700 } 701 702 if (two_channels) { 703 bool channel1; 704 705 mot_intlv_bit = two_slices ? MOT_CHAN_INTLV_BIT_2SLC_2CH : 706 MOT_CHAN_INTLV_BIT_1SLC_2CH; 707 708 if (mot_hit) { 709 chan_intlv_bit_rm = mot_intlv_bit; 710 channel1 = (addr >> mot_intlv_bit) & 1; 711 } else { 712 chan_intlv_bit_rm = chan_selector; 713 channel1 = hash_by_mask(contig_addr, chan_hash_mask); 714 } 715 716 *pmiidx |= (u32)channel1; 717 } 718 } 719 720 /* Remove the chan_selector bit first */ 721 remove_addr_bit(&contig_addr, chan_intlv_bit_rm); 722 /* Remove the slice bit (we remove it second because it must be lower */ 723 remove_addr_bit(&contig_addr, slice_intlv_bit_rm); 724 *pmiaddr = contig_addr; 725 726 return 0; 727 } 728 729 /* Translate PMI address to memory (rank, row, bank, column) */ 730 #define C(n) (0x10 | (n)) /* column */ 731 #define B(n) (0x20 | (n)) /* bank */ 732 #define R(n) (0x40 | (n)) /* row */ 733 #define RS (0x80) /* rank */ 734 735 /* addrdec values */ 736 #define AMAP_1KB 0 737 #define AMAP_2KB 1 738 #define AMAP_4KB 2 739 #define AMAP_RSVD 3 740 741 /* dden values */ 742 #define DEN_4Gb 0 743 #define DEN_8Gb 2 744 745 /* dwid values */ 746 #define X8 0 747 #define X16 1 748 749 static struct dimm_geometry { 750 u8 addrdec; 751 u8 dden; 752 u8 dwid; 753 u8 rowbits, colbits; 754 u16 bits[PMI_ADDRESS_WIDTH]; 755 } dimms[] = { 756 { 757 .addrdec = AMAP_1KB, .dden = DEN_4Gb, .dwid = X16, 758 .rowbits = 15, .colbits = 10, 759 .bits = { 760 C(2), C(3), C(4), C(5), C(6), B(0), B(1), B(2), R(0), 761 R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), R(9), 762 R(10), C(7), C(8), C(9), R(11), RS, R(12), R(13), R(14), 763 0, 0, 0, 0 764 } 765 }, 766 { 767 .addrdec = AMAP_1KB, .dden = DEN_4Gb, .dwid = X8, 768 .rowbits = 16, .colbits = 10, 769 .bits = { 770 C(2), C(3), C(4), C(5), C(6), B(0), B(1), B(2), R(0), 771 R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), R(9), 772 R(10), C(7), C(8), C(9), R(11), RS, R(12), R(13), R(14), 773 R(15), 0, 0, 0 774 } 775 }, 776 { 777 .addrdec = AMAP_1KB, .dden = DEN_8Gb, .dwid = X16, 778 .rowbits = 16, .colbits = 10, 779 .bits = { 780 C(2), C(3), C(4), C(5), C(6), B(0), B(1), B(2), R(0), 781 R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), R(9), 782 R(10), C(7), C(8), C(9), R(11), RS, R(12), R(13), R(14), 783 R(15), 0, 0, 0 784 } 785 }, 786 { 787 .addrdec = AMAP_1KB, .dden = DEN_8Gb, .dwid = X8, 788 .rowbits = 16, .colbits = 11, 789 .bits = { 790 C(2), C(3), C(4), C(5), C(6), B(0), B(1), B(2), R(0), 791 R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), R(9), 792 R(10), C(7), C(8), C(9), R(11), RS, C(11), R(12), R(13), 793 R(14), R(15), 0, 0 794 } 795 }, 796 { 797 .addrdec = AMAP_2KB, .dden = DEN_4Gb, .dwid = X16, 798 .rowbits = 15, .colbits = 10, 799 .bits = { 800 C(2), C(3), C(4), C(5), C(6), C(7), B(0), B(1), B(2), 801 R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), 802 R(9), R(10), C(8), C(9), R(11), RS, R(12), R(13), R(14), 803 0, 0, 0, 0 804 } 805 }, 806 { 807 .addrdec = AMAP_2KB, .dden = DEN_4Gb, .dwid = X8, 808 .rowbits = 16, .colbits = 10, 809 .bits = { 810 C(2), C(3), C(4), C(5), C(6), C(7), B(0), B(1), B(2), 811 R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), 812 R(9), R(10), C(8), C(9), R(11), RS, R(12), R(13), R(14), 813 R(15), 0, 0, 0 814 } 815 }, 816 { 817 .addrdec = AMAP_2KB, .dden = DEN_8Gb, .dwid = X16, 818 .rowbits = 16, .colbits = 10, 819 .bits = { 820 C(2), C(3), C(4), C(5), C(6), C(7), B(0), B(1), B(2), 821 R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), 822 R(9), R(10), C(8), C(9), R(11), RS, R(12), R(13), R(14), 823 R(15), 0, 0, 0 824 } 825 }, 826 { 827 .addrdec = AMAP_2KB, .dden = DEN_8Gb, .dwid = X8, 828 .rowbits = 16, .colbits = 11, 829 .bits = { 830 C(2), C(3), C(4), C(5), C(6), C(7), B(0), B(1), B(2), 831 R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), R(8), 832 R(9), R(10), C(8), C(9), R(11), RS, C(11), R(12), R(13), 833 R(14), R(15), 0, 0 834 } 835 }, 836 { 837 .addrdec = AMAP_4KB, .dden = DEN_4Gb, .dwid = X16, 838 .rowbits = 15, .colbits = 10, 839 .bits = { 840 C(2), C(3), C(4), C(5), C(6), C(7), C(8), B(0), B(1), 841 B(2), R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), 842 R(8), R(9), R(10), C(9), R(11), RS, R(12), R(13), R(14), 843 0, 0, 0, 0 844 } 845 }, 846 { 847 .addrdec = AMAP_4KB, .dden = DEN_4Gb, .dwid = X8, 848 .rowbits = 16, .colbits = 10, 849 .bits = { 850 C(2), C(3), C(4), C(5), C(6), C(7), C(8), B(0), B(1), 851 B(2), R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), 852 R(8), R(9), R(10), C(9), R(11), RS, R(12), R(13), R(14), 853 R(15), 0, 0, 0 854 } 855 }, 856 { 857 .addrdec = AMAP_4KB, .dden = DEN_8Gb, .dwid = X16, 858 .rowbits = 16, .colbits = 10, 859 .bits = { 860 C(2), C(3), C(4), C(5), C(6), C(7), C(8), B(0), B(1), 861 B(2), R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), 862 R(8), R(9), R(10), C(9), R(11), RS, R(12), R(13), R(14), 863 R(15), 0, 0, 0 864 } 865 }, 866 { 867 .addrdec = AMAP_4KB, .dden = DEN_8Gb, .dwid = X8, 868 .rowbits = 16, .colbits = 11, 869 .bits = { 870 C(2), C(3), C(4), C(5), C(6), C(7), C(8), B(0), B(1), 871 B(2), R(0), R(1), R(2), R(3), R(4), R(5), R(6), R(7), 872 R(8), R(9), R(10), C(9), R(11), RS, C(11), R(12), R(13), 873 R(14), R(15), 0, 0 874 } 875 } 876 }; 877 878 static int bank_hash(u64 pmiaddr, int idx, int shft) 879 { 880 int bhash = 0; 881 882 switch (idx) { 883 case 0: 884 bhash ^= ((pmiaddr >> (12 + shft)) ^ (pmiaddr >> (9 + shft))) & 1; 885 break; 886 case 1: 887 bhash ^= (((pmiaddr >> (10 + shft)) ^ (pmiaddr >> (8 + shft))) & 1) << 1; 888 bhash ^= ((pmiaddr >> 22) & 1) << 1; 889 break; 890 case 2: 891 bhash ^= (((pmiaddr >> (13 + shft)) ^ (pmiaddr >> (11 + shft))) & 1) << 2; 892 break; 893 } 894 895 return bhash; 896 } 897 898 static int rank_hash(u64 pmiaddr) 899 { 900 return ((pmiaddr >> 16) ^ (pmiaddr >> 10)) & 1; 901 } 902 903 /* Second stage decode. Compute rank, bank, row & column. */ 904 static int apl_pmi2mem(struct mem_ctl_info *mci, u64 pmiaddr, u32 pmiidx, 905 struct dram_addr *daddr, char *msg) 906 { 907 struct d_cr_drp0 *cr_drp0 = &drp0[pmiidx]; 908 struct pnd2_pvt *pvt = mci->pvt_info; 909 int g = pvt->dimm_geom[pmiidx]; 910 struct dimm_geometry *d = &dimms[g]; 911 int column = 0, bank = 0, row = 0, rank = 0; 912 int i, idx, type, skiprs = 0; 913 914 for (i = 0; i < PMI_ADDRESS_WIDTH; i++) { 915 int bit = (pmiaddr >> i) & 1; 916 917 if (i + skiprs >= PMI_ADDRESS_WIDTH) { 918 snprintf(msg, PND2_MSG_SIZE, "Bad dimm_geometry[] table\n"); 919 return -EINVAL; 920 } 921 922 type = d->bits[i + skiprs] & ~0xf; 923 idx = d->bits[i + skiprs] & 0xf; 924 925 /* 926 * On single rank DIMMs ignore the rank select bit 927 * and shift remainder of "bits[]" down one place. 928 */ 929 if (type == RS && (cr_drp0->rken0 + cr_drp0->rken1) == 1) { 930 skiprs = 1; 931 type = d->bits[i + skiprs] & ~0xf; 932 idx = d->bits[i + skiprs] & 0xf; 933 } 934 935 switch (type) { 936 case C(0): 937 column |= (bit << idx); 938 break; 939 case B(0): 940 bank |= (bit << idx); 941 if (cr_drp0->bahen) 942 bank ^= bank_hash(pmiaddr, idx, d->addrdec); 943 break; 944 case R(0): 945 row |= (bit << idx); 946 break; 947 case RS: 948 rank = bit; 949 if (cr_drp0->rsien) 950 rank ^= rank_hash(pmiaddr); 951 break; 952 default: 953 if (bit) { 954 snprintf(msg, PND2_MSG_SIZE, "Bad translation\n"); 955 return -EINVAL; 956 } 957 goto done; 958 } 959 } 960 961 done: 962 daddr->col = column; 963 daddr->bank = bank; 964 daddr->row = row; 965 daddr->rank = rank; 966 daddr->dimm = 0; 967 968 return 0; 969 } 970 971 /* Pluck bit "in" from pmiaddr and return value shifted to bit "out" */ 972 #define dnv_get_bit(pmi, in, out) ((int)(((pmi) >> (in)) & 1u) << (out)) 973 974 static int dnv_pmi2mem(struct mem_ctl_info *mci, u64 pmiaddr, u32 pmiidx, 975 struct dram_addr *daddr, char *msg) 976 { 977 /* Rank 0 or 1 */ 978 daddr->rank = dnv_get_bit(pmiaddr, dmap[pmiidx].rs0 + 13, 0); 979 /* Rank 2 or 3 */ 980 daddr->rank |= dnv_get_bit(pmiaddr, dmap[pmiidx].rs1 + 13, 1); 981 982 /* 983 * Normally ranks 0,1 are DIMM0, and 2,3 are DIMM1, but we 984 * flip them if DIMM1 is larger than DIMM0. 985 */ 986 daddr->dimm = (daddr->rank >= 2) ^ drp[pmiidx].dimmflip; 987 988 daddr->bank = dnv_get_bit(pmiaddr, dmap[pmiidx].ba0 + 6, 0); 989 daddr->bank |= dnv_get_bit(pmiaddr, dmap[pmiidx].ba1 + 6, 1); 990 daddr->bank |= dnv_get_bit(pmiaddr, dmap[pmiidx].bg0 + 6, 2); 991 if (dsch.ddr4en) 992 daddr->bank |= dnv_get_bit(pmiaddr, dmap[pmiidx].bg1 + 6, 3); 993 if (dmap1[pmiidx].bxor) { 994 if (dsch.ddr4en) { 995 daddr->bank ^= dnv_get_bit(pmiaddr, dmap3[pmiidx].row6 + 6, 0); 996 daddr->bank ^= dnv_get_bit(pmiaddr, dmap3[pmiidx].row7 + 6, 1); 997 if (dsch.chan_width == 0) 998 /* 64/72 bit dram channel width */ 999 daddr->bank ^= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca3 + 6, 2); 1000 else 1001 /* 32/40 bit dram channel width */ 1002 daddr->bank ^= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca4 + 6, 2); 1003 daddr->bank ^= dnv_get_bit(pmiaddr, dmap2[pmiidx].row2 + 6, 3); 1004 } else { 1005 daddr->bank ^= dnv_get_bit(pmiaddr, dmap2[pmiidx].row2 + 6, 0); 1006 daddr->bank ^= dnv_get_bit(pmiaddr, dmap3[pmiidx].row6 + 6, 1); 1007 if (dsch.chan_width == 0) 1008 daddr->bank ^= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca3 + 6, 2); 1009 else 1010 daddr->bank ^= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca4 + 6, 2); 1011 } 1012 } 1013 1014 daddr->row = dnv_get_bit(pmiaddr, dmap2[pmiidx].row0 + 6, 0); 1015 daddr->row |= dnv_get_bit(pmiaddr, dmap2[pmiidx].row1 + 6, 1); 1016 daddr->row |= dnv_get_bit(pmiaddr, dmap2[pmiidx].row2 + 6, 2); 1017 daddr->row |= dnv_get_bit(pmiaddr, dmap2[pmiidx].row3 + 6, 3); 1018 daddr->row |= dnv_get_bit(pmiaddr, dmap2[pmiidx].row4 + 6, 4); 1019 daddr->row |= dnv_get_bit(pmiaddr, dmap2[pmiidx].row5 + 6, 5); 1020 daddr->row |= dnv_get_bit(pmiaddr, dmap3[pmiidx].row6 + 6, 6); 1021 daddr->row |= dnv_get_bit(pmiaddr, dmap3[pmiidx].row7 + 6, 7); 1022 daddr->row |= dnv_get_bit(pmiaddr, dmap3[pmiidx].row8 + 6, 8); 1023 daddr->row |= dnv_get_bit(pmiaddr, dmap3[pmiidx].row9 + 6, 9); 1024 daddr->row |= dnv_get_bit(pmiaddr, dmap3[pmiidx].row10 + 6, 10); 1025 daddr->row |= dnv_get_bit(pmiaddr, dmap3[pmiidx].row11 + 6, 11); 1026 daddr->row |= dnv_get_bit(pmiaddr, dmap4[pmiidx].row12 + 6, 12); 1027 daddr->row |= dnv_get_bit(pmiaddr, dmap4[pmiidx].row13 + 6, 13); 1028 if (dmap4[pmiidx].row14 != 31) 1029 daddr->row |= dnv_get_bit(pmiaddr, dmap4[pmiidx].row14 + 6, 14); 1030 if (dmap4[pmiidx].row15 != 31) 1031 daddr->row |= dnv_get_bit(pmiaddr, dmap4[pmiidx].row15 + 6, 15); 1032 if (dmap4[pmiidx].row16 != 31) 1033 daddr->row |= dnv_get_bit(pmiaddr, dmap4[pmiidx].row16 + 6, 16); 1034 if (dmap4[pmiidx].row17 != 31) 1035 daddr->row |= dnv_get_bit(pmiaddr, dmap4[pmiidx].row17 + 6, 17); 1036 1037 daddr->col = dnv_get_bit(pmiaddr, dmap5[pmiidx].ca3 + 6, 3); 1038 daddr->col |= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca4 + 6, 4); 1039 daddr->col |= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca5 + 6, 5); 1040 daddr->col |= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca6 + 6, 6); 1041 daddr->col |= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca7 + 6, 7); 1042 daddr->col |= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca8 + 6, 8); 1043 daddr->col |= dnv_get_bit(pmiaddr, dmap5[pmiidx].ca9 + 6, 9); 1044 if (!dsch.ddr4en && dmap1[pmiidx].ca11 != 0x3f) 1045 daddr->col |= dnv_get_bit(pmiaddr, dmap1[pmiidx].ca11 + 13, 11); 1046 1047 return 0; 1048 } 1049 1050 static int check_channel(int ch) 1051 { 1052 if (drp0[ch].dramtype != 0) { 1053 pnd2_printk(KERN_INFO, "Unsupported DIMM in channel %d\n", ch); 1054 return 1; 1055 } else if (drp0[ch].eccen == 0) { 1056 pnd2_printk(KERN_INFO, "ECC disabled on channel %d\n", ch); 1057 return 1; 1058 } 1059 return 0; 1060 } 1061 1062 static int apl_check_ecc_active(void) 1063 { 1064 int i, ret = 0; 1065 1066 /* Check dramtype and ECC mode for each present DIMM */ 1067 for (i = 0; i < APL_NUM_CHANNELS; i++) 1068 if (chan_mask & BIT(i)) 1069 ret += check_channel(i); 1070 return ret ? -EINVAL : 0; 1071 } 1072 1073 #define DIMMS_PRESENT(d) ((d)->rken0 + (d)->rken1 + (d)->rken2 + (d)->rken3) 1074 1075 static int check_unit(int ch) 1076 { 1077 struct d_cr_drp *d = &drp[ch]; 1078 1079 if (DIMMS_PRESENT(d) && !ecc_ctrl[ch].eccen) { 1080 pnd2_printk(KERN_INFO, "ECC disabled on channel %d\n", ch); 1081 return 1; 1082 } 1083 return 0; 1084 } 1085 1086 static int dnv_check_ecc_active(void) 1087 { 1088 int i, ret = 0; 1089 1090 for (i = 0; i < DNV_NUM_CHANNELS; i++) 1091 ret += check_unit(i); 1092 return ret ? -EINVAL : 0; 1093 } 1094 1095 static int get_memory_error_data(struct mem_ctl_info *mci, u64 addr, 1096 struct dram_addr *daddr, char *msg) 1097 { 1098 u64 pmiaddr; 1099 u32 pmiidx; 1100 int ret; 1101 1102 ret = sys2pmi(addr, &pmiidx, &pmiaddr, msg); 1103 if (ret) 1104 return ret; 1105 1106 pmiaddr >>= ops->pmiaddr_shift; 1107 /* pmi channel idx to dimm channel idx */ 1108 pmiidx >>= ops->pmiidx_shift; 1109 daddr->chan = pmiidx; 1110 1111 ret = ops->pmi2mem(mci, pmiaddr, pmiidx, daddr, msg); 1112 if (ret) 1113 return ret; 1114 1115 edac_dbg(0, "SysAddr=%llx PmiAddr=%llx Channel=%d DIMM=%d Rank=%d Bank=%d Row=%d Column=%d\n", 1116 addr, pmiaddr, daddr->chan, daddr->dimm, daddr->rank, daddr->bank, daddr->row, daddr->col); 1117 1118 return 0; 1119 } 1120 1121 static void pnd2_mce_output_error(struct mem_ctl_info *mci, const struct mce *m, 1122 struct dram_addr *daddr) 1123 { 1124 enum hw_event_mc_err_type tp_event; 1125 char *optype, msg[PND2_MSG_SIZE]; 1126 bool ripv = m->mcgstatus & MCG_STATUS_RIPV; 1127 bool overflow = m->status & MCI_STATUS_OVER; 1128 bool uc_err = m->status & MCI_STATUS_UC; 1129 bool recov = m->status & MCI_STATUS_S; 1130 u32 core_err_cnt = GET_BITFIELD(m->status, 38, 52); 1131 u32 mscod = GET_BITFIELD(m->status, 16, 31); 1132 u32 errcode = GET_BITFIELD(m->status, 0, 15); 1133 u32 optypenum = GET_BITFIELD(m->status, 4, 6); 1134 int rc; 1135 1136 tp_event = uc_err ? (ripv ? HW_EVENT_ERR_UNCORRECTED : HW_EVENT_ERR_FATAL) : 1137 HW_EVENT_ERR_CORRECTED; 1138 1139 /* 1140 * According with Table 15-9 of the Intel Architecture spec vol 3A, 1141 * memory errors should fit in this mask: 1142 * 000f 0000 1mmm cccc (binary) 1143 * where: 1144 * f = Correction Report Filtering Bit. If 1, subsequent errors 1145 * won't be shown 1146 * mmm = error type 1147 * cccc = channel 1148 * If the mask doesn't match, report an error to the parsing logic 1149 */ 1150 if (!((errcode & 0xef80) == 0x80)) { 1151 optype = "Can't parse: it is not a mem"; 1152 } else { 1153 switch (optypenum) { 1154 case 0: 1155 optype = "generic undef request error"; 1156 break; 1157 case 1: 1158 optype = "memory read error"; 1159 break; 1160 case 2: 1161 optype = "memory write error"; 1162 break; 1163 case 3: 1164 optype = "addr/cmd error"; 1165 break; 1166 case 4: 1167 optype = "memory scrubbing error"; 1168 break; 1169 default: 1170 optype = "reserved"; 1171 break; 1172 } 1173 } 1174 1175 /* Only decode errors with an valid address (ADDRV) */ 1176 if (!(m->status & MCI_STATUS_ADDRV)) 1177 return; 1178 1179 rc = get_memory_error_data(mci, m->addr, daddr, msg); 1180 if (rc) 1181 goto address_error; 1182 1183 snprintf(msg, sizeof(msg), 1184 "%s%s err_code:%04x:%04x channel:%d DIMM:%d rank:%d row:%d bank:%d col:%d", 1185 overflow ? " OVERFLOW" : "", (uc_err && recov) ? " recoverable" : "", mscod, 1186 errcode, daddr->chan, daddr->dimm, daddr->rank, daddr->row, daddr->bank, daddr->col); 1187 1188 edac_dbg(0, "%s\n", msg); 1189 1190 /* Call the helper to output message */ 1191 edac_mc_handle_error(tp_event, mci, core_err_cnt, m->addr >> PAGE_SHIFT, 1192 m->addr & ~PAGE_MASK, 0, daddr->chan, daddr->dimm, -1, optype, msg); 1193 1194 return; 1195 1196 address_error: 1197 edac_mc_handle_error(tp_event, mci, core_err_cnt, 0, 0, 0, -1, -1, -1, msg, ""); 1198 } 1199 1200 static void apl_get_dimm_config(struct mem_ctl_info *mci) 1201 { 1202 struct pnd2_pvt *pvt = mci->pvt_info; 1203 struct dimm_info *dimm; 1204 struct d_cr_drp0 *d; 1205 u64 capacity; 1206 int i, g; 1207 1208 for (i = 0; i < APL_NUM_CHANNELS; i++) { 1209 if (!(chan_mask & BIT(i))) 1210 continue; 1211 1212 dimm = edac_get_dimm(mci, i, 0, 0); 1213 if (!dimm) { 1214 edac_dbg(0, "No allocated DIMM for channel %d\n", i); 1215 continue; 1216 } 1217 1218 d = &drp0[i]; 1219 for (g = 0; g < ARRAY_SIZE(dimms); g++) 1220 if (dimms[g].addrdec == d->addrdec && 1221 dimms[g].dden == d->dden && 1222 dimms[g].dwid == d->dwid) 1223 break; 1224 1225 if (g == ARRAY_SIZE(dimms)) { 1226 edac_dbg(0, "Channel %d: unrecognized DIMM\n", i); 1227 continue; 1228 } 1229 1230 pvt->dimm_geom[i] = g; 1231 capacity = (d->rken0 + d->rken1) * 8 * (1ul << dimms[g].rowbits) * 1232 (1ul << dimms[g].colbits); 1233 edac_dbg(0, "Channel %d: %lld MByte DIMM\n", i, capacity >> (20 - 3)); 1234 dimm->nr_pages = MiB_TO_PAGES(capacity >> (20 - 3)); 1235 dimm->grain = 32; 1236 dimm->dtype = (d->dwid == 0) ? DEV_X8 : DEV_X16; 1237 dimm->mtype = MEM_DDR3; 1238 dimm->edac_mode = EDAC_SECDED; 1239 snprintf(dimm->label, sizeof(dimm->label), "Slice#%d_Chan#%d", i / 2, i % 2); 1240 } 1241 } 1242 1243 static const int dnv_dtypes[] = { 1244 DEV_X8, DEV_X4, DEV_X16, DEV_UNKNOWN 1245 }; 1246 1247 static void dnv_get_dimm_config(struct mem_ctl_info *mci) 1248 { 1249 int i, j, ranks_of_dimm[DNV_MAX_DIMMS], banks, rowbits, colbits, memtype; 1250 struct dimm_info *dimm; 1251 struct d_cr_drp *d; 1252 u64 capacity; 1253 1254 if (dsch.ddr4en) { 1255 memtype = MEM_DDR4; 1256 banks = 16; 1257 colbits = 10; 1258 } else { 1259 memtype = MEM_DDR3; 1260 banks = 8; 1261 } 1262 1263 for (i = 0; i < DNV_NUM_CHANNELS; i++) { 1264 if (dmap4[i].row14 == 31) 1265 rowbits = 14; 1266 else if (dmap4[i].row15 == 31) 1267 rowbits = 15; 1268 else if (dmap4[i].row16 == 31) 1269 rowbits = 16; 1270 else if (dmap4[i].row17 == 31) 1271 rowbits = 17; 1272 else 1273 rowbits = 18; 1274 1275 if (memtype == MEM_DDR3) { 1276 if (dmap1[i].ca11 != 0x3f) 1277 colbits = 12; 1278 else 1279 colbits = 10; 1280 } 1281 1282 d = &drp[i]; 1283 /* DIMM0 is present if rank0 and/or rank1 is enabled */ 1284 ranks_of_dimm[0] = d->rken0 + d->rken1; 1285 /* DIMM1 is present if rank2 and/or rank3 is enabled */ 1286 ranks_of_dimm[1] = d->rken2 + d->rken3; 1287 1288 for (j = 0; j < DNV_MAX_DIMMS; j++) { 1289 if (!ranks_of_dimm[j]) 1290 continue; 1291 1292 dimm = edac_get_dimm(mci, i, j, 0); 1293 if (!dimm) { 1294 edac_dbg(0, "No allocated DIMM for channel %d DIMM %d\n", i, j); 1295 continue; 1296 } 1297 1298 capacity = ranks_of_dimm[j] * banks * (1ul << rowbits) * (1ul << colbits); 1299 edac_dbg(0, "Channel %d DIMM %d: %lld MByte DIMM\n", i, j, capacity >> (20 - 3)); 1300 dimm->nr_pages = MiB_TO_PAGES(capacity >> (20 - 3)); 1301 dimm->grain = 32; 1302 dimm->dtype = dnv_dtypes[j ? d->dimmdwid0 : d->dimmdwid1]; 1303 dimm->mtype = memtype; 1304 dimm->edac_mode = EDAC_SECDED; 1305 snprintf(dimm->label, sizeof(dimm->label), "Chan#%d_DIMM#%d", i, j); 1306 } 1307 } 1308 } 1309 1310 static int pnd2_register_mci(struct mem_ctl_info **ppmci) 1311 { 1312 struct edac_mc_layer layers[2]; 1313 struct mem_ctl_info *mci; 1314 struct pnd2_pvt *pvt; 1315 int rc; 1316 1317 rc = ops->check_ecc(); 1318 if (rc < 0) 1319 return rc; 1320 1321 /* Allocate a new MC control structure */ 1322 layers[0].type = EDAC_MC_LAYER_CHANNEL; 1323 layers[0].size = ops->channels; 1324 layers[0].is_virt_csrow = false; 1325 layers[1].type = EDAC_MC_LAYER_SLOT; 1326 layers[1].size = ops->dimms_per_channel; 1327 layers[1].is_virt_csrow = true; 1328 mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers, sizeof(*pvt)); 1329 if (!mci) 1330 return -ENOMEM; 1331 1332 pvt = mci->pvt_info; 1333 memset(pvt, 0, sizeof(*pvt)); 1334 1335 mci->mod_name = EDAC_MOD_STR; 1336 mci->dev_name = ops->name; 1337 mci->ctl_name = "Pondicherry2"; 1338 1339 /* Get dimm basic config and the memory layout */ 1340 ops->get_dimm_config(mci); 1341 1342 if (edac_mc_add_mc(mci)) { 1343 edac_dbg(0, "MC: failed edac_mc_add_mc()\n"); 1344 edac_mc_free(mci); 1345 return -EINVAL; 1346 } 1347 1348 *ppmci = mci; 1349 1350 return 0; 1351 } 1352 1353 static void pnd2_unregister_mci(struct mem_ctl_info *mci) 1354 { 1355 if (unlikely(!mci || !mci->pvt_info)) { 1356 pnd2_printk(KERN_ERR, "Couldn't find mci handler\n"); 1357 return; 1358 } 1359 1360 /* Remove MC sysfs nodes */ 1361 edac_mc_del_mc(NULL); 1362 edac_dbg(1, "%s: free mci struct\n", mci->ctl_name); 1363 edac_mc_free(mci); 1364 } 1365 1366 /* 1367 * Callback function registered with core kernel mce code. 1368 * Called once for each logged error. 1369 */ 1370 static int pnd2_mce_check_error(struct notifier_block *nb, unsigned long val, void *data) 1371 { 1372 struct mce *mce = (struct mce *)data; 1373 struct mem_ctl_info *mci; 1374 struct dram_addr daddr; 1375 char *type; 1376 1377 mci = pnd2_mci; 1378 if (!mci || (mce->kflags & MCE_HANDLED_CEC)) 1379 return NOTIFY_DONE; 1380 1381 /* 1382 * Just let mcelog handle it if the error is 1383 * outside the memory controller. A memory error 1384 * is indicated by bit 7 = 1 and bits = 8-11,13-15 = 0. 1385 * bit 12 has an special meaning. 1386 */ 1387 if ((mce->status & 0xefff) >> 7 != 1) 1388 return NOTIFY_DONE; 1389 1390 if (mce->mcgstatus & MCG_STATUS_MCIP) 1391 type = "Exception"; 1392 else 1393 type = "Event"; 1394 1395 pnd2_mc_printk(mci, KERN_INFO, "HANDLING MCE MEMORY ERROR\n"); 1396 pnd2_mc_printk(mci, KERN_INFO, "CPU %u: Machine Check %s: %llx Bank %u: %llx\n", 1397 mce->extcpu, type, mce->mcgstatus, mce->bank, mce->status); 1398 pnd2_mc_printk(mci, KERN_INFO, "TSC %llx ", mce->tsc); 1399 pnd2_mc_printk(mci, KERN_INFO, "ADDR %llx ", mce->addr); 1400 pnd2_mc_printk(mci, KERN_INFO, "MISC %llx ", mce->misc); 1401 pnd2_mc_printk(mci, KERN_INFO, "PROCESSOR %u:%x TIME %llu SOCKET %u APIC %x\n", 1402 mce->cpuvendor, mce->cpuid, mce->time, mce->socketid, mce->apicid); 1403 1404 pnd2_mce_output_error(mci, mce, &daddr); 1405 1406 /* Advice mcelog that the error were handled */ 1407 mce->kflags |= MCE_HANDLED_EDAC; 1408 return NOTIFY_OK; 1409 } 1410 1411 static struct notifier_block pnd2_mce_dec = { 1412 .notifier_call = pnd2_mce_check_error, 1413 .priority = MCE_PRIO_EDAC, 1414 }; 1415 1416 #ifdef CONFIG_EDAC_DEBUG 1417 /* 1418 * Write an address to this file to exercise the address decode 1419 * logic in this driver. 1420 */ 1421 static u64 pnd2_fake_addr; 1422 #define PND2_BLOB_SIZE 1024 1423 static char pnd2_result[PND2_BLOB_SIZE]; 1424 static struct dentry *pnd2_test; 1425 static struct debugfs_blob_wrapper pnd2_blob = { 1426 .data = pnd2_result, 1427 .size = 0 1428 }; 1429 1430 static int debugfs_u64_set(void *data, u64 val) 1431 { 1432 struct dram_addr daddr; 1433 struct mce m; 1434 1435 *(u64 *)data = val; 1436 m.mcgstatus = 0; 1437 /* ADDRV + MemRd + Unknown channel */ 1438 m.status = MCI_STATUS_ADDRV + 0x9f; 1439 m.addr = val; 1440 pnd2_mce_output_error(pnd2_mci, &m, &daddr); 1441 snprintf(pnd2_blob.data, PND2_BLOB_SIZE, 1442 "SysAddr=%llx Channel=%d DIMM=%d Rank=%d Bank=%d Row=%d Column=%d\n", 1443 m.addr, daddr.chan, daddr.dimm, daddr.rank, daddr.bank, daddr.row, daddr.col); 1444 pnd2_blob.size = strlen(pnd2_blob.data); 1445 1446 return 0; 1447 } 1448 DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n"); 1449 1450 static void setup_pnd2_debug(void) 1451 { 1452 pnd2_test = edac_debugfs_create_dir("pnd2_test"); 1453 edac_debugfs_create_file("pnd2_debug_addr", 0200, pnd2_test, 1454 &pnd2_fake_addr, &fops_u64_wo); 1455 debugfs_create_blob("pnd2_debug_results", 0400, pnd2_test, &pnd2_blob); 1456 } 1457 1458 static void teardown_pnd2_debug(void) 1459 { 1460 debugfs_remove_recursive(pnd2_test); 1461 } 1462 #else 1463 static void setup_pnd2_debug(void) {} 1464 static void teardown_pnd2_debug(void) {} 1465 #endif /* CONFIG_EDAC_DEBUG */ 1466 1467 1468 static int pnd2_probe(void) 1469 { 1470 int rc; 1471 1472 edac_dbg(2, "\n"); 1473 rc = get_registers(); 1474 if (rc) 1475 return rc; 1476 1477 return pnd2_register_mci(&pnd2_mci); 1478 } 1479 1480 static void pnd2_remove(void) 1481 { 1482 edac_dbg(0, "\n"); 1483 pnd2_unregister_mci(pnd2_mci); 1484 } 1485 1486 static struct dunit_ops apl_ops = { 1487 .name = "pnd2/apl", 1488 .type = APL, 1489 .pmiaddr_shift = LOG2_PMI_ADDR_GRANULARITY, 1490 .pmiidx_shift = 0, 1491 .channels = APL_NUM_CHANNELS, 1492 .dimms_per_channel = 1, 1493 .rd_reg = apl_rd_reg, 1494 .get_registers = apl_get_registers, 1495 .check_ecc = apl_check_ecc_active, 1496 .mk_region = apl_mk_region, 1497 .get_dimm_config = apl_get_dimm_config, 1498 .pmi2mem = apl_pmi2mem, 1499 }; 1500 1501 static struct dunit_ops dnv_ops = { 1502 .name = "pnd2/dnv", 1503 .type = DNV, 1504 .pmiaddr_shift = 0, 1505 .pmiidx_shift = 1, 1506 .channels = DNV_NUM_CHANNELS, 1507 .dimms_per_channel = 2, 1508 .rd_reg = dnv_rd_reg, 1509 .get_registers = dnv_get_registers, 1510 .check_ecc = dnv_check_ecc_active, 1511 .mk_region = dnv_mk_region, 1512 .get_dimm_config = dnv_get_dimm_config, 1513 .pmi2mem = dnv_pmi2mem, 1514 }; 1515 1516 static const struct x86_cpu_id pnd2_cpuids[] = { 1517 X86_MATCH_INTEL_FAM6_MODEL(ATOM_GOLDMONT, &apl_ops), 1518 X86_MATCH_INTEL_FAM6_MODEL(ATOM_GOLDMONT_D, &dnv_ops), 1519 { } 1520 }; 1521 MODULE_DEVICE_TABLE(x86cpu, pnd2_cpuids); 1522 1523 static int __init pnd2_init(void) 1524 { 1525 const struct x86_cpu_id *id; 1526 const char *owner; 1527 int rc; 1528 1529 edac_dbg(2, "\n"); 1530 1531 if (ghes_get_devices()) 1532 return -EBUSY; 1533 1534 owner = edac_get_owner(); 1535 if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR))) 1536 return -EBUSY; 1537 1538 if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR)) 1539 return -ENODEV; 1540 1541 id = x86_match_cpu(pnd2_cpuids); 1542 if (!id) 1543 return -ENODEV; 1544 1545 ops = (struct dunit_ops *)id->driver_data; 1546 1547 if (ops->type == APL) { 1548 p2sb_bus = pci_find_bus(0, 0); 1549 if (!p2sb_bus) 1550 return -ENODEV; 1551 } 1552 1553 /* Ensure that the OPSTATE is set correctly for POLL or NMI */ 1554 opstate_init(); 1555 1556 rc = pnd2_probe(); 1557 if (rc < 0) { 1558 pnd2_printk(KERN_ERR, "Failed to register device with error %d.\n", rc); 1559 return rc; 1560 } 1561 1562 if (!pnd2_mci) 1563 return -ENODEV; 1564 1565 mce_register_decode_chain(&pnd2_mce_dec); 1566 setup_pnd2_debug(); 1567 1568 return 0; 1569 } 1570 1571 static void __exit pnd2_exit(void) 1572 { 1573 edac_dbg(2, "\n"); 1574 teardown_pnd2_debug(); 1575 mce_unregister_decode_chain(&pnd2_mce_dec); 1576 pnd2_remove(); 1577 } 1578 1579 module_init(pnd2_init); 1580 module_exit(pnd2_exit); 1581 1582 module_param(edac_op_state, int, 0444); 1583 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI"); 1584 1585 MODULE_LICENSE("GPL v2"); 1586 MODULE_AUTHOR("Tony Luck"); 1587 MODULE_DESCRIPTION("MC Driver for Intel SoC using Pondicherry memory controller"); 1588