1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Driver for Intel(R) 10nm server memory controller. 4 * Copyright (c) 2019, Intel Corporation. 5 * 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/io.h> 10 #include <asm/cpu_device_id.h> 11 #include <asm/intel-family.h> 12 #include <asm/mce.h> 13 #include "edac_module.h" 14 #include "skx_common.h" 15 16 #define I10NM_REVISION "v0.0.6" 17 #define EDAC_MOD_STR "i10nm_edac" 18 19 /* Debug macros */ 20 #define i10nm_printk(level, fmt, arg...) \ 21 edac_printk(level, "i10nm", fmt, ##arg) 22 23 #define I10NM_GET_SCK_BAR(d, reg) \ 24 pci_read_config_dword((d)->uracu, 0xd0, &(reg)) 25 #define I10NM_GET_IMC_BAR(d, i, reg) \ 26 pci_read_config_dword((d)->uracu, \ 27 (res_cfg->type == GNR ? 0xd4 : 0xd8) + (i) * 4, &(reg)) 28 #define I10NM_GET_SAD(d, offset, i, reg)\ 29 pci_read_config_dword((d)->sad_all, (offset) + (i) * \ 30 (res_cfg->type == GNR ? 12 : 8), &(reg)) 31 #define I10NM_GET_HBM_IMC_BAR(d, reg) \ 32 pci_read_config_dword((d)->uracu, 0xd4, &(reg)) 33 #define I10NM_GET_CAPID3_CFG(d, reg) \ 34 pci_read_config_dword((d)->pcu_cr3, \ 35 res_cfg->type == GNR ? 0x290 : 0x90, &(reg)) 36 #define I10NM_GET_CAPID5_CFG(d, reg) \ 37 pci_read_config_dword((d)->pcu_cr3, \ 38 res_cfg->type == GNR ? 0x298 : 0x98, &(reg)) 39 #define I10NM_GET_DIMMMTR(m, i, j) \ 40 readl((m)->mbase + ((m)->hbm_mc ? 0x80c : \ 41 (res_cfg->type == GNR ? 0xc0c : 0x2080c)) + \ 42 (i) * (m)->chan_mmio_sz + (j) * 4) 43 #define I10NM_GET_MCDDRTCFG(m, i) \ 44 readl((m)->mbase + ((m)->hbm_mc ? 0x970 : 0x20970) + \ 45 (i) * (m)->chan_mmio_sz) 46 #define I10NM_GET_MCMTR(m, i) \ 47 readl((m)->mbase + ((m)->hbm_mc ? 0xef8 : \ 48 (res_cfg->type == GNR ? 0xaf8 : 0x20ef8)) + \ 49 (i) * (m)->chan_mmio_sz) 50 #define I10NM_GET_REG32(m, i, offset) \ 51 readl((m)->mbase + (i) * (m)->chan_mmio_sz + (offset)) 52 #define I10NM_GET_REG64(m, i, offset) \ 53 readq((m)->mbase + (i) * (m)->chan_mmio_sz + (offset)) 54 #define I10NM_SET_REG32(m, i, offset, v) \ 55 writel(v, (m)->mbase + (i) * (m)->chan_mmio_sz + (offset)) 56 57 #define I10NM_GET_SCK_MMIO_BASE(reg) (GET_BITFIELD(reg, 0, 28) << 23) 58 #define I10NM_GET_IMC_MMIO_OFFSET(reg) (GET_BITFIELD(reg, 0, 10) << 12) 59 #define I10NM_GET_IMC_MMIO_SIZE(reg) ((GET_BITFIELD(reg, 13, 23) - \ 60 GET_BITFIELD(reg, 0, 10) + 1) << 12) 61 #define I10NM_GET_HBM_IMC_MMIO_OFFSET(reg) \ 62 ((GET_BITFIELD(reg, 0, 10) << 12) + 0x140000) 63 64 #define I10NM_GNR_IMC_MMIO_OFFSET 0x24c000 65 #define I10NM_GNR_D_IMC_MMIO_OFFSET 0x206000 66 #define I10NM_GNR_IMC_MMIO_SIZE 0x4000 67 #define I10NM_HBM_IMC_MMIO_SIZE 0x9000 68 #define I10NM_DDR_IMC_CH_CNT(reg) GET_BITFIELD(reg, 21, 24) 69 #define I10NM_IS_HBM_PRESENT(reg) GET_BITFIELD(reg, 27, 30) 70 #define I10NM_IS_HBM_IMC(reg) GET_BITFIELD(reg, 29, 29) 71 72 #define I10NM_MAX_SAD 16 73 #define I10NM_SAD_ENABLE(reg) GET_BITFIELD(reg, 0, 0) 74 #define I10NM_SAD_NM_CACHEABLE(reg) GET_BITFIELD(reg, 5, 5) 75 76 static struct list_head *i10nm_edac_list; 77 78 static struct res_config *res_cfg; 79 static int retry_rd_err_log; 80 static int decoding_via_mca; 81 static bool mem_cfg_2lm; 82 83 static struct reg_rrl icx_reg_rrl_ddr = { 84 .set_num = 2, 85 .reg_num = 6, 86 .modes = {LRE_SCRUB, LRE_DEMAND}, 87 .offsets = { 88 {0x22c60, 0x22c54, 0x22c5c, 0x22c58, 0x22c28, 0x20ed8}, 89 {0x22e54, 0x22e60, 0x22e64, 0x22e58, 0x22e5c, 0x20ee0}, 90 }, 91 .widths = {4, 4, 4, 4, 4, 8}, 92 .v_mask = BIT(0), 93 .uc_mask = BIT(1), 94 .over_mask = BIT(2), 95 .en_patspr_mask = BIT(13), 96 .noover_mask = BIT(14), 97 .en_mask = BIT(15), 98 99 .cecnt_num = 4, 100 .cecnt_offsets = {0x22c18, 0x22c1c, 0x22c20, 0x22c24}, 101 .cecnt_widths = {4, 4, 4, 4}, 102 }; 103 104 static struct reg_rrl spr_reg_rrl_ddr = { 105 .set_num = 3, 106 .reg_num = 6, 107 .modes = {LRE_SCRUB, LRE_DEMAND, FRE_DEMAND}, 108 .offsets = { 109 {0x22c60, 0x22c54, 0x22f08, 0x22c58, 0x22c28, 0x20ed8}, 110 {0x22e54, 0x22e60, 0x22f10, 0x22e58, 0x22e5c, 0x20ee0}, 111 {0x22c70, 0x22d80, 0x22f18, 0x22d58, 0x22c64, 0x20f10}, 112 }, 113 .widths = {4, 4, 8, 4, 4, 8}, 114 .v_mask = BIT(0), 115 .uc_mask = BIT(1), 116 .over_mask = BIT(2), 117 .en_patspr_mask = BIT(13), 118 .noover_mask = BIT(14), 119 .en_mask = BIT(15), 120 121 .cecnt_num = 4, 122 .cecnt_offsets = {0x22c18, 0x22c1c, 0x22c20, 0x22c24}, 123 .cecnt_widths = {4, 4, 4, 4}, 124 }; 125 126 static struct reg_rrl spr_reg_rrl_hbm_pch0 = { 127 .set_num = 2, 128 .reg_num = 6, 129 .modes = {LRE_SCRUB, LRE_DEMAND}, 130 .offsets = { 131 {0x2860, 0x2854, 0x2b08, 0x2858, 0x2828, 0x0ed8}, 132 {0x2a54, 0x2a60, 0x2b10, 0x2a58, 0x2a5c, 0x0ee0}, 133 }, 134 .widths = {4, 4, 8, 4, 4, 8}, 135 .v_mask = BIT(0), 136 .uc_mask = BIT(1), 137 .over_mask = BIT(2), 138 .en_patspr_mask = BIT(13), 139 .noover_mask = BIT(14), 140 .en_mask = BIT(15), 141 142 .cecnt_num = 4, 143 .cecnt_offsets = {0x2818, 0x281c, 0x2820, 0x2824}, 144 .cecnt_widths = {4, 4, 4, 4}, 145 }; 146 147 static struct reg_rrl spr_reg_rrl_hbm_pch1 = { 148 .set_num = 2, 149 .reg_num = 6, 150 .modes = {LRE_SCRUB, LRE_DEMAND}, 151 .offsets = { 152 {0x2c60, 0x2c54, 0x2f08, 0x2c58, 0x2c28, 0x0fa8}, 153 {0x2e54, 0x2e60, 0x2f10, 0x2e58, 0x2e5c, 0x0fb0}, 154 }, 155 .widths = {4, 4, 8, 4, 4, 8}, 156 .v_mask = BIT(0), 157 .uc_mask = BIT(1), 158 .over_mask = BIT(2), 159 .en_patspr_mask = BIT(13), 160 .noover_mask = BIT(14), 161 .en_mask = BIT(15), 162 163 .cecnt_num = 4, 164 .cecnt_offsets = {0x2c18, 0x2c1c, 0x2c20, 0x2c24}, 165 .cecnt_widths = {4, 4, 4, 4}, 166 }; 167 168 static struct reg_rrl gnr_reg_rrl_ddr = { 169 .set_num = 4, 170 .reg_num = 6, 171 .modes = {FRE_SCRUB, FRE_DEMAND, LRE_SCRUB, LRE_DEMAND}, 172 .offsets = { 173 {0x2f10, 0x2f20, 0x2f30, 0x2f50, 0x2f60, 0xba0}, 174 {0x2f14, 0x2f24, 0x2f38, 0x2f54, 0x2f64, 0xba8}, 175 {0x2f18, 0x2f28, 0x2f40, 0x2f58, 0x2f68, 0xbb0}, 176 {0x2f1c, 0x2f2c, 0x2f48, 0x2f5c, 0x2f6c, 0xbb8}, 177 }, 178 .widths = {4, 4, 8, 4, 4, 8}, 179 .v_mask = BIT(0), 180 .uc_mask = BIT(1), 181 .over_mask = BIT(2), 182 .en_patspr_mask = BIT(14), 183 .noover_mask = BIT(15), 184 .en_mask = BIT(12), 185 186 .cecnt_num = 8, 187 .cecnt_offsets = {0x2c10, 0x2c14, 0x2c18, 0x2c1c, 0x2c20, 0x2c24, 0x2c28, 0x2c2c}, 188 .cecnt_widths = {4, 4, 4, 4, 4, 4, 4, 4}, 189 }; 190 191 static u64 read_imc_reg(struct skx_imc *imc, int chan, u32 offset, u8 width) 192 { 193 switch (width) { 194 case 4: 195 return I10NM_GET_REG32(imc, chan, offset); 196 case 8: 197 return I10NM_GET_REG64(imc, chan, offset); 198 default: 199 i10nm_printk(KERN_ERR, "Invalid read RRL 0x%x width %d\n", offset, width); 200 return 0; 201 } 202 } 203 204 static void write_imc_reg(struct skx_imc *imc, int chan, u32 offset, u8 width, u64 val) 205 { 206 switch (width) { 207 case 4: 208 return I10NM_SET_REG32(imc, chan, offset, (u32)val); 209 default: 210 i10nm_printk(KERN_ERR, "Invalid write RRL 0x%x width %d\n", offset, width); 211 } 212 } 213 214 static void enable_rrl(struct skx_imc *imc, int chan, struct reg_rrl *rrl, 215 int rrl_set, bool enable, u32 *rrl_ctl) 216 { 217 enum rrl_mode mode = rrl->modes[rrl_set]; 218 u32 offset = rrl->offsets[rrl_set][0], v; 219 u8 width = rrl->widths[0]; 220 bool first, scrub; 221 222 /* First or last read error. */ 223 first = (mode == FRE_SCRUB || mode == FRE_DEMAND); 224 /* Patrol scrub or on-demand read error. */ 225 scrub = (mode == FRE_SCRUB || mode == LRE_SCRUB); 226 227 v = read_imc_reg(imc, chan, offset, width); 228 229 if (enable) { 230 /* Save default configurations. */ 231 *rrl_ctl = v; 232 v &= ~rrl->uc_mask; 233 234 if (first) 235 v |= rrl->noover_mask; 236 else 237 v &= ~rrl->noover_mask; 238 239 if (scrub) 240 v |= rrl->en_patspr_mask; 241 else 242 v &= ~rrl->en_patspr_mask; 243 244 v |= rrl->en_mask; 245 } else { 246 /* Restore default configurations. */ 247 if (*rrl_ctl & rrl->uc_mask) 248 v |= rrl->uc_mask; 249 250 if (first) { 251 if (!(*rrl_ctl & rrl->noover_mask)) 252 v &= ~rrl->noover_mask; 253 } else { 254 if (*rrl_ctl & rrl->noover_mask) 255 v |= rrl->noover_mask; 256 } 257 258 if (scrub) { 259 if (!(*rrl_ctl & rrl->en_patspr_mask)) 260 v &= ~rrl->en_patspr_mask; 261 } else { 262 if (*rrl_ctl & rrl->en_patspr_mask) 263 v |= rrl->en_patspr_mask; 264 } 265 266 if (!(*rrl_ctl & rrl->en_mask)) 267 v &= ~rrl->en_mask; 268 } 269 270 write_imc_reg(imc, chan, offset, width, v); 271 } 272 273 static void enable_rrls(struct skx_imc *imc, int chan, struct reg_rrl *rrl, 274 bool enable, u32 *rrl_ctl) 275 { 276 for (int i = 0; i < rrl->set_num; i++) 277 enable_rrl(imc, chan, rrl, i, enable, rrl_ctl + i); 278 } 279 280 static void enable_rrls_ddr(struct skx_imc *imc, bool enable) 281 { 282 struct reg_rrl *rrl_ddr = res_cfg->reg_rrl_ddr; 283 int i, chan_num = res_cfg->ddr_chan_num; 284 struct skx_channel *chan = imc->chan; 285 286 if (!imc->mbase) 287 return; 288 289 for (i = 0; i < chan_num; i++) 290 enable_rrls(imc, i, rrl_ddr, enable, chan[i].rrl_ctl[0]); 291 } 292 293 static void enable_rrls_hbm(struct skx_imc *imc, bool enable) 294 { 295 struct reg_rrl **rrl_hbm = res_cfg->reg_rrl_hbm; 296 int i, chan_num = res_cfg->hbm_chan_num; 297 struct skx_channel *chan = imc->chan; 298 299 if (!imc->mbase || !imc->hbm_mc || !rrl_hbm[0] || !rrl_hbm[1]) 300 return; 301 302 for (i = 0; i < chan_num; i++) { 303 enable_rrls(imc, i, rrl_hbm[0], enable, chan[i].rrl_ctl[0]); 304 enable_rrls(imc, i, rrl_hbm[1], enable, chan[i].rrl_ctl[1]); 305 } 306 } 307 308 static void enable_retry_rd_err_log(bool enable) 309 { 310 struct skx_dev *d; 311 int i, imc_num; 312 313 edac_dbg(2, "\n"); 314 315 list_for_each_entry(d, i10nm_edac_list, list) { 316 imc_num = res_cfg->ddr_imc_num; 317 for (i = 0; i < imc_num; i++) 318 enable_rrls_ddr(&d->imc[i], enable); 319 320 imc_num += res_cfg->hbm_imc_num; 321 for (; i < imc_num; i++) 322 enable_rrls_hbm(&d->imc[i], enable); 323 } 324 } 325 326 static void show_retry_rd_err_log(struct decoded_addr *res, char *msg, 327 int len, bool scrub_err) 328 { 329 int i, j, n, ch = res->channel, pch = res->cs & 1; 330 struct skx_imc *imc = &res->dev->imc[res->imc]; 331 u64 log, corr, status_mask; 332 struct reg_rrl *rrl; 333 bool scrub; 334 u32 offset; 335 u8 width; 336 337 if (!imc->mbase) 338 return; 339 340 rrl = imc->hbm_mc ? res_cfg->reg_rrl_hbm[pch] : res_cfg->reg_rrl_ddr; 341 342 if (!rrl) 343 return; 344 345 status_mask = rrl->over_mask | rrl->uc_mask | rrl->v_mask; 346 347 n = scnprintf(msg, len, " retry_rd_err_log["); 348 for (i = 0; i < rrl->set_num; i++) { 349 scrub = (rrl->modes[i] == FRE_SCRUB || rrl->modes[i] == LRE_SCRUB); 350 if (scrub_err != scrub) 351 continue; 352 353 for (j = 0; j < rrl->reg_num && len - n > 0; j++) { 354 offset = rrl->offsets[i][j]; 355 width = rrl->widths[j]; 356 log = read_imc_reg(imc, ch, offset, width); 357 358 if (width == 4) 359 n += scnprintf(msg + n, len - n, "%.8llx ", log); 360 else 361 n += scnprintf(msg + n, len - n, "%.16llx ", log); 362 363 /* Clear RRL status if RRL in Linux control mode. */ 364 if (retry_rd_err_log == 2 && !j && (log & status_mask)) 365 write_imc_reg(imc, ch, offset, width, log & ~status_mask); 366 } 367 } 368 369 /* Move back one space. */ 370 n--; 371 n += scnprintf(msg + n, len - n, "]"); 372 373 if (len - n > 0) { 374 n += scnprintf(msg + n, len - n, " correrrcnt["); 375 for (i = 0; i < rrl->cecnt_num && len - n > 0; i++) { 376 offset = rrl->cecnt_offsets[i]; 377 width = rrl->cecnt_widths[i]; 378 corr = read_imc_reg(imc, ch, offset, width); 379 380 /* CPUs {ICX,SPR} encode two counters per 4-byte CORRERRCNT register. */ 381 if (res_cfg->type <= SPR) { 382 n += scnprintf(msg + n, len - n, "%.4llx %.4llx ", 383 corr & 0xffff, corr >> 16); 384 } else { 385 /* CPUs {GNR} encode one counter per CORRERRCNT register. */ 386 if (width == 4) 387 n += scnprintf(msg + n, len - n, "%.8llx ", corr); 388 else 389 n += scnprintf(msg + n, len - n, "%.16llx ", corr); 390 } 391 } 392 393 /* Move back one space. */ 394 n--; 395 n += scnprintf(msg + n, len - n, "]"); 396 } 397 } 398 399 static struct pci_dev *pci_get_dev_wrapper(int dom, unsigned int bus, 400 unsigned int dev, unsigned int fun) 401 { 402 struct pci_dev *pdev; 403 404 pdev = pci_get_domain_bus_and_slot(dom, bus, PCI_DEVFN(dev, fun)); 405 if (!pdev) { 406 edac_dbg(2, "No device %02x:%02x.%x\n", 407 bus, dev, fun); 408 return NULL; 409 } 410 411 if (unlikely(pci_enable_device(pdev) < 0)) { 412 edac_dbg(2, "Failed to enable device %02x:%02x.%x\n", 413 bus, dev, fun); 414 pci_dev_put(pdev); 415 return NULL; 416 } 417 418 return pdev; 419 } 420 421 /** 422 * i10nm_get_imc_num() - Get the number of present DDR memory controllers. 423 * 424 * @cfg : The pointer to the structure of EDAC resource configurations. 425 * 426 * For Granite Rapids CPUs, the number of present DDR memory controllers read 427 * at runtime overwrites the value statically configured in @cfg->ddr_imc_num. 428 * For other CPUs, the number of present DDR memory controllers is statically 429 * configured in @cfg->ddr_imc_num. 430 * 431 * RETURNS : 0 on success, < 0 on failure. 432 */ 433 static int i10nm_get_imc_num(struct res_config *cfg) 434 { 435 int n, imc_num, chan_num = 0; 436 struct skx_dev *d; 437 u32 reg; 438 439 list_for_each_entry(d, i10nm_edac_list, list) { 440 d->pcu_cr3 = pci_get_dev_wrapper(d->seg, d->bus[res_cfg->pcu_cr3_bdf.bus], 441 res_cfg->pcu_cr3_bdf.dev, 442 res_cfg->pcu_cr3_bdf.fun); 443 if (!d->pcu_cr3) 444 continue; 445 446 if (I10NM_GET_CAPID5_CFG(d, reg)) 447 continue; 448 449 n = I10NM_DDR_IMC_CH_CNT(reg); 450 451 if (!chan_num) { 452 chan_num = n; 453 edac_dbg(2, "Get DDR CH number: %d\n", chan_num); 454 } else if (chan_num != n) { 455 i10nm_printk(KERN_NOTICE, "Get DDR CH numbers: %d, %d\n", chan_num, n); 456 } 457 } 458 459 switch (cfg->type) { 460 case GNR: 461 /* 462 * One channel per DDR memory controller for Granite Rapids CPUs. 463 */ 464 imc_num = chan_num; 465 466 if (!imc_num) { 467 i10nm_printk(KERN_ERR, "Invalid DDR MC number\n"); 468 return -ENODEV; 469 } 470 471 if (cfg->ddr_imc_num != imc_num) { 472 /* 473 * Update the configuration data to reflect the number of 474 * present DDR memory controllers. 475 */ 476 cfg->ddr_imc_num = imc_num; 477 edac_dbg(2, "Set DDR MC number: %d", imc_num); 478 479 /* Release and reallocate skx_dev list with the updated number. */ 480 skx_remove(); 481 if (skx_get_all_bus_mappings(cfg, &i10nm_edac_list) <= 0) 482 return -ENODEV; 483 } 484 485 return 0; 486 default: 487 /* 488 * For other CPUs, the number of present DDR memory controllers 489 * is statically pre-configured in cfg->ddr_imc_num. 490 */ 491 return 0; 492 } 493 } 494 495 static bool i10nm_check_2lm(struct res_config *cfg) 496 { 497 struct skx_dev *d; 498 u32 reg; 499 int i; 500 501 list_for_each_entry(d, i10nm_edac_list, list) { 502 d->sad_all = pci_get_dev_wrapper(d->seg, d->bus[res_cfg->sad_all_bdf.bus], 503 res_cfg->sad_all_bdf.dev, 504 res_cfg->sad_all_bdf.fun); 505 if (!d->sad_all) 506 continue; 507 508 for (i = 0; i < I10NM_MAX_SAD; i++) { 509 I10NM_GET_SAD(d, cfg->sad_all_offset, i, reg); 510 if (I10NM_SAD_ENABLE(reg) && I10NM_SAD_NM_CACHEABLE(reg)) { 511 edac_dbg(2, "2-level memory configuration.\n"); 512 return true; 513 } 514 } 515 } 516 517 return false; 518 } 519 520 /* 521 * Check whether the error comes from DDRT by ICX/Tremont/SPR model specific error code. 522 * Refer to SDM vol3B 17.11.3/17.13.2 Intel IMC MC error codes for IA32_MCi_STATUS. 523 */ 524 static bool i10nm_mscod_is_ddrt(u32 mscod) 525 { 526 switch (res_cfg->type) { 527 case I10NM: 528 switch (mscod) { 529 case 0x0106: case 0x0107: 530 case 0x0800: case 0x0804: 531 case 0x0806 ... 0x0808: 532 case 0x080a ... 0x080e: 533 case 0x0810: case 0x0811: 534 case 0x0816: case 0x081e: 535 case 0x081f: 536 return true; 537 } 538 539 break; 540 case SPR: 541 switch (mscod) { 542 case 0x0800: case 0x0804: 543 case 0x0806 ... 0x0808: 544 case 0x080a ... 0x080e: 545 case 0x0810: case 0x0811: 546 case 0x0816: case 0x081e: 547 case 0x081f: 548 return true; 549 } 550 551 break; 552 default: 553 return false; 554 } 555 556 return false; 557 } 558 559 static bool i10nm_mc_decode_available(struct mce *mce) 560 { 561 #define ICX_IMCx_CHy 0x06666000 562 u8 bank; 563 564 if (!decoding_via_mca || mem_cfg_2lm) 565 return false; 566 567 if ((mce->status & (MCI_STATUS_MISCV | MCI_STATUS_ADDRV)) 568 != (MCI_STATUS_MISCV | MCI_STATUS_ADDRV)) 569 return false; 570 571 bank = mce->bank; 572 573 switch (res_cfg->type) { 574 case I10NM: 575 /* Check whether the bank is one of {13,14,17,18,21,22,25,26} */ 576 if (!(ICX_IMCx_CHy & (1 << bank))) 577 return false; 578 break; 579 case SPR: 580 if (bank < 13 || bank > 20) 581 return false; 582 break; 583 case GNR: 584 if (bank < 13 || bank > 24) 585 return false; 586 break; 587 default: 588 return false; 589 } 590 591 /* DDRT errors can't be decoded from MCA bank registers */ 592 if (MCI_MISC_ECC_MODE(mce->misc) == MCI_MISC_ECC_DDRT) 593 return false; 594 595 if (i10nm_mscod_is_ddrt(MCI_STATUS_MSCOD(mce->status))) 596 return false; 597 598 return true; 599 } 600 601 static bool i10nm_mc_decode(struct decoded_addr *res) 602 { 603 struct mce *m = res->mce; 604 struct skx_dev *d; 605 u8 bank; 606 607 if (!i10nm_mc_decode_available(m)) 608 return false; 609 610 list_for_each_entry(d, i10nm_edac_list, list) { 611 if (d->imc[0].src_id == m->socketid) { 612 res->socket = m->socketid; 613 res->dev = d; 614 break; 615 } 616 } 617 618 switch (res_cfg->type) { 619 case I10NM: 620 bank = m->bank - 13; 621 res->imc = bank / 4; 622 res->channel = bank % 2; 623 res->column = GET_BITFIELD(m->misc, 9, 18) << 2; 624 res->row = GET_BITFIELD(m->misc, 19, 39); 625 res->bank_group = GET_BITFIELD(m->misc, 40, 41); 626 res->bank_address = GET_BITFIELD(m->misc, 42, 43); 627 res->bank_group |= GET_BITFIELD(m->misc, 44, 44) << 2; 628 res->rank = GET_BITFIELD(m->misc, 56, 58); 629 res->dimm = res->rank >> 2; 630 res->rank = res->rank % 4; 631 break; 632 case SPR: 633 bank = m->bank - 13; 634 res->imc = bank / 2; 635 res->channel = bank % 2; 636 res->column = GET_BITFIELD(m->misc, 9, 18) << 2; 637 res->row = GET_BITFIELD(m->misc, 19, 36); 638 res->bank_group = GET_BITFIELD(m->misc, 37, 38); 639 res->bank_address = GET_BITFIELD(m->misc, 39, 40); 640 res->bank_group |= GET_BITFIELD(m->misc, 41, 41) << 2; 641 res->rank = GET_BITFIELD(m->misc, 57, 57); 642 res->dimm = GET_BITFIELD(m->misc, 58, 58); 643 break; 644 case GNR: 645 res->imc = m->bank - 13; 646 res->channel = 0; 647 res->column = GET_BITFIELD(m->misc, 9, 18) << 2; 648 res->row = GET_BITFIELD(m->misc, 19, 36); 649 res->bank_group = GET_BITFIELD(m->misc, 39, 41); 650 res->bank_address = GET_BITFIELD(m->misc, 37, 38); 651 res->rank = GET_BITFIELD(m->misc, 55, 56); 652 res->dimm = GET_BITFIELD(m->misc, 57, 57); 653 break; 654 default: 655 return false; 656 } 657 658 if (!res->dev) { 659 skx_printk(KERN_ERR, "No device for src_id %d imc %d\n", 660 m->socketid, res->imc); 661 return false; 662 } 663 664 return true; 665 } 666 667 /** 668 * get_gnr_mdev() - Get the PCI device of the @logical_idx-th DDR memory controller. 669 * 670 * @d : The pointer to the structure of CPU socket EDAC device. 671 * @logical_idx : The logical index of the present memory controller (0 ~ max present MC# - 1). 672 * @physical_idx : To store the corresponding physical index of @logical_idx. 673 * 674 * RETURNS : The PCI device of the @logical_idx-th DDR memory controller, NULL on failure. 675 */ 676 static struct pci_dev *get_gnr_mdev(struct skx_dev *d, int logical_idx, int *physical_idx) 677 { 678 #define GNR_MAX_IMC_PCI_CNT 28 679 680 struct pci_dev *mdev; 681 int i, logical = 0; 682 683 /* 684 * Detect present memory controllers from { PCI device: 8-5, function 7-1 } 685 */ 686 for (i = 0; i < GNR_MAX_IMC_PCI_CNT; i++) { 687 mdev = pci_get_dev_wrapper(d->seg, 688 d->bus[res_cfg->ddr_mdev_bdf.bus], 689 res_cfg->ddr_mdev_bdf.dev + i / 7, 690 res_cfg->ddr_mdev_bdf.fun + i % 7); 691 692 if (mdev) { 693 if (logical == logical_idx) { 694 *physical_idx = i; 695 return mdev; 696 } 697 698 pci_dev_put(mdev); 699 logical++; 700 } 701 } 702 703 return NULL; 704 } 705 706 static u32 get_gnr_imc_mmio_offset(void) 707 { 708 if (boot_cpu_data.x86_vfm == INTEL_GRANITERAPIDS_D) 709 return I10NM_GNR_D_IMC_MMIO_OFFSET; 710 711 return I10NM_GNR_IMC_MMIO_OFFSET; 712 } 713 714 /** 715 * get_ddr_munit() - Get the resource of the i-th DDR memory controller. 716 * 717 * @d : The pointer to the structure of CPU socket EDAC device. 718 * @i : The index of the CPU socket relative DDR memory controller. 719 * @offset : To store the MMIO offset of the i-th DDR memory controller. 720 * @size : To store the MMIO size of the i-th DDR memory controller. 721 * 722 * RETURNS : The PCI device of the i-th DDR memory controller, NULL on failure. 723 */ 724 static struct pci_dev *get_ddr_munit(struct skx_dev *d, int i, u32 *offset, unsigned long *size) 725 { 726 struct pci_dev *mdev; 727 int physical_idx; 728 u32 reg; 729 730 switch (res_cfg->type) { 731 case GNR: 732 if (I10NM_GET_IMC_BAR(d, 0, reg)) { 733 i10nm_printk(KERN_ERR, "Failed to get mc0 bar\n"); 734 return NULL; 735 } 736 737 mdev = get_gnr_mdev(d, i, &physical_idx); 738 if (!mdev) 739 return NULL; 740 741 *offset = I10NM_GET_IMC_MMIO_OFFSET(reg) + 742 get_gnr_imc_mmio_offset() + 743 physical_idx * I10NM_GNR_IMC_MMIO_SIZE; 744 *size = I10NM_GNR_IMC_MMIO_SIZE; 745 746 break; 747 default: 748 if (I10NM_GET_IMC_BAR(d, i, reg)) { 749 i10nm_printk(KERN_ERR, "Failed to get mc%d bar\n", i); 750 return NULL; 751 } 752 753 mdev = pci_get_dev_wrapper(d->seg, 754 d->bus[res_cfg->ddr_mdev_bdf.bus], 755 res_cfg->ddr_mdev_bdf.dev + i, 756 res_cfg->ddr_mdev_bdf.fun); 757 if (!mdev) 758 return NULL; 759 760 *offset = I10NM_GET_IMC_MMIO_OFFSET(reg); 761 *size = I10NM_GET_IMC_MMIO_SIZE(reg); 762 } 763 764 return mdev; 765 } 766 767 /** 768 * i10nm_imc_absent() - Check whether the memory controller @imc is absent 769 * 770 * @imc : The pointer to the structure of memory controller EDAC device. 771 * 772 * RETURNS : true if the memory controller EDAC device is absent, false otherwise. 773 */ 774 static bool i10nm_imc_absent(struct skx_imc *imc) 775 { 776 u32 mcmtr; 777 int i; 778 779 switch (res_cfg->type) { 780 case SPR: 781 for (i = 0; i < res_cfg->ddr_chan_num; i++) { 782 mcmtr = I10NM_GET_MCMTR(imc, i); 783 edac_dbg(1, "ch%d mcmtr reg %x\n", i, mcmtr); 784 if (mcmtr != ~0) 785 return false; 786 } 787 788 /* 789 * Some workstations' absent memory controllers still 790 * appear as PCIe devices, misleading the EDAC driver. 791 * By observing that the MMIO registers of these absent 792 * memory controllers consistently hold the value of ~0. 793 * 794 * We identify a memory controller as absent by checking 795 * if its MMIO register "mcmtr" == ~0 in all its channels. 796 */ 797 return true; 798 default: 799 return false; 800 } 801 } 802 803 static int i10nm_get_ddr_munits(void) 804 { 805 struct pci_dev *mdev; 806 void __iomem *mbase; 807 unsigned long size; 808 struct skx_dev *d; 809 int i, lmc, j = 0; 810 u32 reg, off; 811 u64 base; 812 813 list_for_each_entry(d, i10nm_edac_list, list) { 814 d->util_all = pci_get_dev_wrapper(d->seg, d->bus[res_cfg->util_all_bdf.bus], 815 res_cfg->util_all_bdf.dev, 816 res_cfg->util_all_bdf.fun); 817 if (!d->util_all) 818 return -ENODEV; 819 820 d->uracu = pci_get_dev_wrapper(d->seg, d->bus[res_cfg->uracu_bdf.bus], 821 res_cfg->uracu_bdf.dev, 822 res_cfg->uracu_bdf.fun); 823 if (!d->uracu) 824 return -ENODEV; 825 826 if (I10NM_GET_SCK_BAR(d, reg)) { 827 i10nm_printk(KERN_ERR, "Failed to socket bar\n"); 828 return -ENODEV; 829 } 830 831 base = I10NM_GET_SCK_MMIO_BASE(reg); 832 edac_dbg(2, "socket%d mmio base 0x%llx (reg 0x%x)\n", 833 j++, base, reg); 834 835 for (lmc = 0, i = 0; i < res_cfg->ddr_imc_num; i++) { 836 mdev = get_ddr_munit(d, i, &off, &size); 837 838 if (i == 0 && !mdev) { 839 i10nm_printk(KERN_ERR, "No IMC found\n"); 840 return -ENODEV; 841 } 842 if (!mdev) 843 continue; 844 845 edac_dbg(2, "mc%d mmio base 0x%llx size 0x%lx (reg 0x%x)\n", 846 i, base + off, size, reg); 847 848 mbase = ioremap(base + off, size); 849 if (!mbase) { 850 i10nm_printk(KERN_ERR, "Failed to ioremap 0x%llx\n", 851 base + off); 852 return -ENODEV; 853 } 854 855 d->imc[lmc].mbase = mbase; 856 if (i10nm_imc_absent(&d->imc[lmc])) { 857 pci_dev_put(mdev); 858 iounmap(mbase); 859 d->imc[lmc].mbase = NULL; 860 edac_dbg(2, "Skip absent mc%d\n", i); 861 continue; 862 } else { 863 d->imc[lmc].mdev = mdev; 864 if (res_cfg->type == SPR) 865 skx_set_mc_mapping(d, i, lmc); 866 lmc++; 867 } 868 } 869 } 870 871 return 0; 872 } 873 874 static bool i10nm_check_hbm_imc(struct skx_dev *d) 875 { 876 u32 reg; 877 878 if (I10NM_GET_CAPID3_CFG(d, reg)) { 879 i10nm_printk(KERN_ERR, "Failed to get capid3_cfg\n"); 880 return false; 881 } 882 883 return I10NM_IS_HBM_PRESENT(reg) != 0; 884 } 885 886 static int i10nm_get_hbm_munits(void) 887 { 888 struct pci_dev *mdev; 889 void __iomem *mbase; 890 u32 reg, off, mcmtr; 891 struct skx_dev *d; 892 int i, lmc; 893 u64 base; 894 895 list_for_each_entry(d, i10nm_edac_list, list) { 896 if (!d->pcu_cr3) 897 return -ENODEV; 898 899 if (!i10nm_check_hbm_imc(d)) { 900 i10nm_printk(KERN_DEBUG, "No hbm memory\n"); 901 return -ENODEV; 902 } 903 904 if (I10NM_GET_SCK_BAR(d, reg)) { 905 i10nm_printk(KERN_ERR, "Failed to get socket bar\n"); 906 return -ENODEV; 907 } 908 base = I10NM_GET_SCK_MMIO_BASE(reg); 909 910 if (I10NM_GET_HBM_IMC_BAR(d, reg)) { 911 i10nm_printk(KERN_ERR, "Failed to get hbm mc bar\n"); 912 return -ENODEV; 913 } 914 base += I10NM_GET_HBM_IMC_MMIO_OFFSET(reg); 915 916 lmc = res_cfg->ddr_imc_num; 917 918 for (i = 0; i < res_cfg->hbm_imc_num; i++) { 919 mdev = pci_get_dev_wrapper(d->seg, d->bus[res_cfg->hbm_mdev_bdf.bus], 920 res_cfg->hbm_mdev_bdf.dev + i / 4, 921 res_cfg->hbm_mdev_bdf.fun + i % 4); 922 923 if (i == 0 && !mdev) { 924 i10nm_printk(KERN_ERR, "No hbm mc found\n"); 925 return -ENODEV; 926 } 927 if (!mdev) 928 continue; 929 930 d->imc[lmc].mdev = mdev; 931 off = i * I10NM_HBM_IMC_MMIO_SIZE; 932 933 edac_dbg(2, "hbm mc%d mmio base 0x%llx size 0x%x\n", 934 lmc, base + off, I10NM_HBM_IMC_MMIO_SIZE); 935 936 mbase = ioremap(base + off, I10NM_HBM_IMC_MMIO_SIZE); 937 if (!mbase) { 938 pci_dev_put(d->imc[lmc].mdev); 939 d->imc[lmc].mdev = NULL; 940 941 i10nm_printk(KERN_ERR, "Failed to ioremap for hbm mc 0x%llx\n", 942 base + off); 943 return -ENOMEM; 944 } 945 946 d->imc[lmc].mbase = mbase; 947 d->imc[lmc].hbm_mc = true; 948 949 mcmtr = I10NM_GET_MCMTR(&d->imc[lmc], 0); 950 if (!I10NM_IS_HBM_IMC(mcmtr)) { 951 iounmap(d->imc[lmc].mbase); 952 d->imc[lmc].mbase = NULL; 953 d->imc[lmc].hbm_mc = false; 954 pci_dev_put(d->imc[lmc].mdev); 955 d->imc[lmc].mdev = NULL; 956 957 i10nm_printk(KERN_ERR, "This isn't an hbm mc!\n"); 958 return -ENODEV; 959 } 960 961 lmc++; 962 } 963 } 964 965 return 0; 966 } 967 968 static struct res_config i10nm_cfg0 = { 969 .type = I10NM, 970 .decs_did = 0x3452, 971 .busno_cfg_offset = 0xcc, 972 .ddr_imc_num = 4, 973 .ddr_chan_num = 2, 974 .ddr_dimm_num = 2, 975 .ddr_chan_mmio_sz = 0x4000, 976 .sad_all_bdf = {1, 29, 0}, 977 .pcu_cr3_bdf = {1, 30, 3}, 978 .util_all_bdf = {1, 29, 1}, 979 .uracu_bdf = {0, 0, 1}, 980 .ddr_mdev_bdf = {0, 12, 0}, 981 .hbm_mdev_bdf = {0, 12, 1}, 982 .sad_all_offset = 0x108, 983 .reg_rrl_ddr = &icx_reg_rrl_ddr, 984 }; 985 986 static struct res_config i10nm_cfg1 = { 987 .type = I10NM, 988 .decs_did = 0x3452, 989 .busno_cfg_offset = 0xd0, 990 .ddr_imc_num = 4, 991 .ddr_chan_num = 2, 992 .ddr_dimm_num = 2, 993 .ddr_chan_mmio_sz = 0x4000, 994 .sad_all_bdf = {1, 29, 0}, 995 .pcu_cr3_bdf = {1, 30, 3}, 996 .util_all_bdf = {1, 29, 1}, 997 .uracu_bdf = {0, 0, 1}, 998 .ddr_mdev_bdf = {0, 12, 0}, 999 .hbm_mdev_bdf = {0, 12, 1}, 1000 .sad_all_offset = 0x108, 1001 .reg_rrl_ddr = &icx_reg_rrl_ddr, 1002 }; 1003 1004 static struct res_config spr_cfg = { 1005 .type = SPR, 1006 .decs_did = 0x3252, 1007 .busno_cfg_offset = 0xd0, 1008 .ddr_imc_num = 4, 1009 .ddr_chan_num = 2, 1010 .ddr_dimm_num = 2, 1011 .hbm_imc_num = 16, 1012 .hbm_chan_num = 2, 1013 .hbm_dimm_num = 1, 1014 .ddr_chan_mmio_sz = 0x8000, 1015 .hbm_chan_mmio_sz = 0x4000, 1016 .support_ddr5 = true, 1017 .sad_all_bdf = {1, 10, 0}, 1018 .pcu_cr3_bdf = {1, 30, 3}, 1019 .util_all_bdf = {1, 29, 1}, 1020 .uracu_bdf = {0, 0, 1}, 1021 .ddr_mdev_bdf = {0, 12, 0}, 1022 .hbm_mdev_bdf = {0, 12, 1}, 1023 .sad_all_offset = 0x300, 1024 .reg_rrl_ddr = &spr_reg_rrl_ddr, 1025 .reg_rrl_hbm[0] = &spr_reg_rrl_hbm_pch0, 1026 .reg_rrl_hbm[1] = &spr_reg_rrl_hbm_pch1, 1027 }; 1028 1029 static struct res_config gnr_cfg = { 1030 .type = GNR, 1031 .decs_did = 0x3252, 1032 .busno_cfg_offset = 0xd0, 1033 .ddr_imc_num = 12, 1034 .ddr_chan_num = 1, 1035 .ddr_dimm_num = 2, 1036 .ddr_chan_mmio_sz = 0x4000, 1037 .support_ddr5 = true, 1038 .sad_all_bdf = {0, 13, 0}, 1039 .pcu_cr3_bdf = {0, 5, 0}, 1040 .util_all_bdf = {0, 13, 1}, 1041 .uracu_bdf = {0, 0, 1}, 1042 .ddr_mdev_bdf = {0, 5, 1}, 1043 .sad_all_offset = 0x300, 1044 .reg_rrl_ddr = &gnr_reg_rrl_ddr, 1045 }; 1046 1047 static const struct x86_cpu_id i10nm_cpuids[] = { 1048 X86_MATCH_VFM_STEPS(INTEL_ATOM_TREMONT_D, X86_STEP_MIN, 0x3, &i10nm_cfg0), 1049 X86_MATCH_VFM_STEPS(INTEL_ATOM_TREMONT_D, 0x4, X86_STEP_MAX, &i10nm_cfg1), 1050 X86_MATCH_VFM_STEPS(INTEL_ICELAKE_X, X86_STEP_MIN, 0x3, &i10nm_cfg0), 1051 X86_MATCH_VFM_STEPS(INTEL_ICELAKE_X, 0x4, X86_STEP_MAX, &i10nm_cfg1), 1052 X86_MATCH_VFM( INTEL_ICELAKE_D, &i10nm_cfg1), 1053 1054 X86_MATCH_VFM(INTEL_SAPPHIRERAPIDS_X, &spr_cfg), 1055 X86_MATCH_VFM(INTEL_EMERALDRAPIDS_X, &spr_cfg), 1056 X86_MATCH_VFM(INTEL_GRANITERAPIDS_X, &gnr_cfg), 1057 X86_MATCH_VFM(INTEL_GRANITERAPIDS_D, &gnr_cfg), 1058 X86_MATCH_VFM(INTEL_ATOM_CRESTMONT_X, &gnr_cfg), 1059 X86_MATCH_VFM(INTEL_ATOM_CRESTMONT, &gnr_cfg), 1060 X86_MATCH_VFM(INTEL_ATOM_DARKMONT_X, &gnr_cfg), 1061 {} 1062 }; 1063 MODULE_DEVICE_TABLE(x86cpu, i10nm_cpuids); 1064 1065 static bool i10nm_check_ecc(struct skx_imc *imc, int chan) 1066 { 1067 u32 mcmtr; 1068 1069 mcmtr = I10NM_GET_MCMTR(imc, chan); 1070 edac_dbg(1, "ch%d mcmtr reg %x\n", chan, mcmtr); 1071 1072 return !!GET_BITFIELD(mcmtr, 2, 2); 1073 } 1074 1075 static bool i10nm_channel_disabled(struct skx_imc *imc, int chan) 1076 { 1077 u32 mcmtr = I10NM_GET_MCMTR(imc, chan); 1078 1079 edac_dbg(1, "mc%d ch%d mcmtr reg %x\n", imc->mc, chan, mcmtr); 1080 1081 return (mcmtr == ~0 || GET_BITFIELD(mcmtr, 18, 18)); 1082 } 1083 1084 static int i10nm_get_dimm_config(struct mem_ctl_info *mci, 1085 struct res_config *cfg) 1086 { 1087 struct skx_pvt *pvt = mci->pvt_info; 1088 struct skx_imc *imc = pvt->imc; 1089 u32 mtr, mcddrtcfg = 0; 1090 struct dimm_info *dimm; 1091 int i, j, ndimms; 1092 1093 for (i = 0; i < imc->num_channels; i++) { 1094 if (!imc->mbase) 1095 continue; 1096 1097 if (i10nm_channel_disabled(imc, i)) { 1098 edac_dbg(1, "mc%d ch%d is disabled.\n", imc->mc, i); 1099 continue; 1100 } 1101 1102 ndimms = 0; 1103 1104 if (res_cfg->type != GNR) 1105 mcddrtcfg = I10NM_GET_MCDDRTCFG(imc, i); 1106 1107 for (j = 0; j < imc->num_dimms; j++) { 1108 dimm = edac_get_dimm(mci, i, j, 0); 1109 mtr = I10NM_GET_DIMMMTR(imc, i, j); 1110 edac_dbg(1, "dimmmtr 0x%x mcddrtcfg 0x%x (mc%d ch%d dimm%d)\n", 1111 mtr, mcddrtcfg, imc->mc, i, j); 1112 1113 if (IS_DIMM_PRESENT(mtr)) 1114 ndimms += skx_get_dimm_info(mtr, 0, 0, dimm, 1115 imc, i, j, cfg); 1116 else if (IS_NVDIMM_PRESENT(mcddrtcfg, j)) 1117 ndimms += skx_get_nvdimm_info(dimm, imc, i, j, 1118 EDAC_MOD_STR); 1119 } 1120 if (ndimms && !i10nm_check_ecc(imc, i)) { 1121 i10nm_printk(KERN_ERR, "ECC is disabled on imc %d channel %d\n", 1122 imc->mc, i); 1123 return -ENODEV; 1124 } 1125 } 1126 1127 return 0; 1128 } 1129 1130 static struct notifier_block i10nm_mce_dec = { 1131 .notifier_call = skx_mce_check_error, 1132 .priority = MCE_PRIO_EDAC, 1133 }; 1134 1135 static int __init i10nm_init(void) 1136 { 1137 u8 mc = 0, src_id = 0; 1138 const struct x86_cpu_id *id; 1139 struct res_config *cfg; 1140 const char *owner; 1141 struct skx_dev *d; 1142 int rc, i, off[3] = {0xd0, 0xc8, 0xcc}; 1143 u64 tolm, tohm; 1144 int imc_num; 1145 1146 edac_dbg(2, "\n"); 1147 1148 if (ghes_get_devices()) 1149 return -EBUSY; 1150 1151 owner = edac_get_owner(); 1152 if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR))) 1153 return -EBUSY; 1154 1155 if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR)) 1156 return -ENODEV; 1157 1158 id = x86_match_cpu(i10nm_cpuids); 1159 if (!id) 1160 return -ENODEV; 1161 1162 cfg = (struct res_config *)id->driver_data; 1163 skx_set_res_cfg(cfg); 1164 res_cfg = cfg; 1165 1166 rc = skx_get_hi_lo(0x09a2, off, &tolm, &tohm); 1167 if (rc) 1168 return rc; 1169 1170 rc = skx_get_all_bus_mappings(cfg, &i10nm_edac_list); 1171 if (rc < 0) 1172 goto fail; 1173 if (rc == 0) { 1174 i10nm_printk(KERN_ERR, "No memory controllers found\n"); 1175 return -ENODEV; 1176 } 1177 1178 rc = i10nm_get_imc_num(cfg); 1179 if (rc < 0) 1180 goto fail; 1181 1182 mem_cfg_2lm = i10nm_check_2lm(cfg); 1183 skx_set_mem_cfg(mem_cfg_2lm); 1184 1185 rc = i10nm_get_ddr_munits(); 1186 1187 if (i10nm_get_hbm_munits() && rc) 1188 goto fail; 1189 1190 imc_num = res_cfg->ddr_imc_num + res_cfg->hbm_imc_num; 1191 1192 list_for_each_entry(d, i10nm_edac_list, list) { 1193 rc = skx_get_src_id(d, 0xf8, &src_id); 1194 if (rc < 0) 1195 goto fail; 1196 1197 edac_dbg(2, "src_id = %d\n", src_id); 1198 for (i = 0; i < imc_num; i++) { 1199 if (!d->imc[i].mdev) 1200 continue; 1201 1202 d->imc[i].mc = mc++; 1203 d->imc[i].lmc = i; 1204 d->imc[i].src_id = src_id; 1205 if (d->imc[i].hbm_mc) { 1206 d->imc[i].chan_mmio_sz = cfg->hbm_chan_mmio_sz; 1207 d->imc[i].num_channels = cfg->hbm_chan_num; 1208 d->imc[i].num_dimms = cfg->hbm_dimm_num; 1209 } else { 1210 d->imc[i].chan_mmio_sz = cfg->ddr_chan_mmio_sz; 1211 d->imc[i].num_channels = cfg->ddr_chan_num; 1212 d->imc[i].num_dimms = cfg->ddr_dimm_num; 1213 } 1214 1215 rc = skx_register_mci(&d->imc[i], &d->imc[i].mdev->dev, 1216 pci_name(d->imc[i].mdev), 1217 "Intel_10nm Socket", EDAC_MOD_STR, 1218 i10nm_get_dimm_config, cfg); 1219 if (rc < 0) 1220 goto fail; 1221 } 1222 } 1223 1224 rc = skx_adxl_get(); 1225 if (rc) 1226 goto fail; 1227 1228 opstate_init(); 1229 mce_register_decode_chain(&i10nm_mce_dec); 1230 skx_setup_debug("i10nm_test"); 1231 1232 if (retry_rd_err_log && res_cfg->reg_rrl_ddr) { 1233 skx_set_decode(i10nm_mc_decode, show_retry_rd_err_log); 1234 if (retry_rd_err_log == 2) 1235 enable_retry_rd_err_log(true); 1236 } else { 1237 skx_set_decode(i10nm_mc_decode, NULL); 1238 } 1239 1240 i10nm_printk(KERN_INFO, "%s\n", I10NM_REVISION); 1241 1242 return 0; 1243 fail: 1244 skx_remove(); 1245 return rc; 1246 } 1247 1248 static void __exit i10nm_exit(void) 1249 { 1250 edac_dbg(2, "\n"); 1251 1252 if (retry_rd_err_log && res_cfg->reg_rrl_ddr) { 1253 skx_set_decode(NULL, NULL); 1254 if (retry_rd_err_log == 2) 1255 enable_retry_rd_err_log(false); 1256 } 1257 1258 skx_teardown_debug(); 1259 mce_unregister_decode_chain(&i10nm_mce_dec); 1260 skx_adxl_put(); 1261 skx_remove(); 1262 } 1263 1264 module_init(i10nm_init); 1265 module_exit(i10nm_exit); 1266 1267 static int set_decoding_via_mca(const char *buf, const struct kernel_param *kp) 1268 { 1269 unsigned long val; 1270 int ret; 1271 1272 ret = kstrtoul(buf, 0, &val); 1273 1274 if (ret || val > 1) 1275 return -EINVAL; 1276 1277 if (val && mem_cfg_2lm) { 1278 i10nm_printk(KERN_NOTICE, "Decoding errors via MCA banks for 2LM isn't supported yet\n"); 1279 return -EIO; 1280 } 1281 1282 ret = param_set_int(buf, kp); 1283 1284 return ret; 1285 } 1286 1287 static const struct kernel_param_ops decoding_via_mca_param_ops = { 1288 .set = set_decoding_via_mca, 1289 .get = param_get_int, 1290 }; 1291 1292 module_param_cb(decoding_via_mca, &decoding_via_mca_param_ops, &decoding_via_mca, 0644); 1293 MODULE_PARM_DESC(decoding_via_mca, "decoding_via_mca: 0=off(default), 1=enable"); 1294 1295 module_param(retry_rd_err_log, int, 0444); 1296 MODULE_PARM_DESC(retry_rd_err_log, "retry_rd_err_log: 0=off(default), 1=bios(Linux doesn't reset any control bits, but just reports values.), 2=linux(Linux tries to take control and resets mode bits, clear valid/UC bits after reading.)"); 1297 1298 MODULE_LICENSE("GPL v2"); 1299 MODULE_DESCRIPTION("MC Driver for Intel 10nm server processors"); 1300