1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Driver for Intel client SoC with integrated memory controller using IBECC 4 * 5 * Copyright (C) 2020 Intel Corporation 6 * 7 * The In-Band ECC (IBECC) IP provides ECC protection to all or specific 8 * regions of the physical memory space. It's used for memory controllers 9 * that don't support the out-of-band ECC which often needs an additional 10 * storage device to each channel for storing ECC data. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/pci.h> 16 #include <linux/slab.h> 17 #include <linux/irq_work.h> 18 #include <linux/llist.h> 19 #include <linux/genalloc.h> 20 #include <linux/edac.h> 21 #include <linux/bits.h> 22 #include <linux/io.h> 23 #include <asm/mach_traps.h> 24 #include <asm/nmi.h> 25 #include <asm/mce.h> 26 27 #include "edac_mc.h" 28 #include "edac_module.h" 29 30 #define IGEN6_REVISION "v2.5" 31 32 #define EDAC_MOD_STR "igen6_edac" 33 #define IGEN6_NMI_NAME "igen6_ibecc" 34 35 /* Debug macros */ 36 #define igen6_printk(level, fmt, arg...) \ 37 edac_printk(level, "igen6", fmt, ##arg) 38 39 #define igen6_mc_printk(mci, level, fmt, arg...) \ 40 edac_mc_chipset_printk(mci, level, "igen6", fmt, ##arg) 41 42 #define GET_BITFIELD(v, lo, hi) (((v) & GENMASK_ULL(hi, lo)) >> (lo)) 43 44 #define NUM_IMC 2 /* Max memory controllers */ 45 #define NUM_CHANNELS 2 /* Max channels */ 46 #define NUM_DIMMS 2 /* Max DIMMs per channel */ 47 48 #define _4GB BIT_ULL(32) 49 50 /* Size of physical memory */ 51 #define TOM_OFFSET 0xa0 52 /* Top of low usable DRAM */ 53 #define TOLUD_OFFSET 0xbc 54 /* Capability register C */ 55 #define CAPID_C_OFFSET 0xec 56 #define CAPID_C_IBECC BIT(15) 57 58 /* Capability register E */ 59 #define CAPID_E_OFFSET 0xf0 60 #define CAPID_E_IBECC BIT(12) 61 62 /* Error Status */ 63 #define ERRSTS_OFFSET 0xc8 64 #define ERRSTS_CE BIT_ULL(6) 65 #define ERRSTS_UE BIT_ULL(7) 66 67 /* Error Command */ 68 #define ERRCMD_OFFSET 0xca 69 #define ERRCMD_CE BIT_ULL(6) 70 #define ERRCMD_UE BIT_ULL(7) 71 72 /* IBECC MMIO base address */ 73 #define IBECC_BASE (res_cfg->ibecc_base) 74 #define IBECC_ACTIVATE_OFFSET IBECC_BASE 75 #define IBECC_ACTIVATE_EN BIT(0) 76 77 /* IBECC error log */ 78 #define ECC_ERROR_LOG_OFFSET (IBECC_BASE + res_cfg->ibecc_error_log_offset) 79 #define ECC_ERROR_LOG_CE BIT_ULL(62) 80 #define ECC_ERROR_LOG_UE BIT_ULL(63) 81 #define ECC_ERROR_LOG_ADDR_SHIFT 5 82 #define ECC_ERROR_LOG_ADDR(v) GET_BITFIELD(v, 5, 38) 83 #define ECC_ERROR_LOG_SYND(v) GET_BITFIELD(v, 46, 61) 84 85 /* Host MMIO base address */ 86 #define MCHBAR_OFFSET 0x48 87 #define MCHBAR_EN BIT_ULL(0) 88 #define MCHBAR_BASE(v) (GET_BITFIELD(v, 16, 38) << 16) 89 #define MCHBAR_SIZE 0x10000 90 91 /* Parameters for the channel decode stage */ 92 #define IMC_BASE (res_cfg->imc_base) 93 #define MAD_INTER_CHANNEL_OFFSET IMC_BASE 94 #define MAD_INTER_CHANNEL_DDR_TYPE(v) GET_BITFIELD(v, 0, 2) 95 #define MAD_INTER_CHANNEL_ECHM(v) GET_BITFIELD(v, 3, 3) 96 #define MAD_INTER_CHANNEL_CH_L_MAP(v) GET_BITFIELD(v, 4, 4) 97 #define MAD_INTER_CHANNEL_CH_S_SIZE(v) ((u64)GET_BITFIELD(v, 12, 19) << 29) 98 99 /* Parameters for DRAM decode stage */ 100 #define MAD_INTRA_CH0_OFFSET (IMC_BASE + 4) 101 #define MAD_INTRA_CH_DIMM_L_MAP(v) GET_BITFIELD(v, 0, 0) 102 103 /* DIMM characteristics */ 104 #define MAD_DIMM_CH0_OFFSET (IMC_BASE + 0xc) 105 #define MAD_DIMM_CH_DIMM_L_SIZE(v) ((u64)GET_BITFIELD(v, 0, 6) << 29) 106 #define MAD_DIMM_CH_DLW(v) GET_BITFIELD(v, 7, 8) 107 #define MAD_DIMM_CH_DIMM_S_SIZE(v) ((u64)GET_BITFIELD(v, 16, 22) << 29) 108 #define MAD_DIMM_CH_DSW(v) GET_BITFIELD(v, 24, 25) 109 110 /* Hash for memory controller selection */ 111 #define MAD_MC_HASH_OFFSET (IMC_BASE + 0x1b8) 112 #define MAC_MC_HASH_LSB(v) GET_BITFIELD(v, 1, 3) 113 114 /* Hash for channel selection */ 115 #define CHANNEL_HASH_OFFSET (IMC_BASE + 0x24) 116 /* Hash for enhanced channel selection */ 117 #define CHANNEL_EHASH_OFFSET (IMC_BASE + 0x28) 118 #define CHANNEL_HASH_MASK(v) (GET_BITFIELD(v, 6, 19) << 6) 119 #define CHANNEL_HASH_LSB_MASK_BIT(v) GET_BITFIELD(v, 24, 26) 120 #define CHANNEL_HASH_MODE(v) GET_BITFIELD(v, 28, 28) 121 122 /* Parameters for memory slice decode stage */ 123 #define MEM_SLICE_HASH_MASK(v) (GET_BITFIELD(v, 6, 19) << 6) 124 #define MEM_SLICE_HASH_LSB_MASK_BIT(v) GET_BITFIELD(v, 24, 26) 125 126 static struct res_config { 127 bool machine_check; 128 int num_imc; 129 u32 imc_base; 130 u32 cmf_base; 131 u32 cmf_size; 132 u32 ms_hash_offset; 133 u32 ibecc_base; 134 u32 ibecc_error_log_offset; 135 bool (*ibecc_available)(struct pci_dev *pdev); 136 /* Convert error address logged in IBECC to system physical address */ 137 u64 (*err_addr_to_sys_addr)(u64 eaddr, int mc); 138 /* Convert error address logged in IBECC to integrated memory controller address */ 139 u64 (*err_addr_to_imc_addr)(u64 eaddr, int mc); 140 } *res_cfg; 141 142 struct igen6_imc { 143 int mc; 144 struct mem_ctl_info *mci; 145 struct pci_dev *pdev; 146 struct device dev; 147 void __iomem *window; 148 u64 size; 149 u64 ch_s_size; 150 int ch_l_map; 151 u64 dimm_s_size[NUM_CHANNELS]; 152 u64 dimm_l_size[NUM_CHANNELS]; 153 int dimm_l_map[NUM_CHANNELS]; 154 }; 155 156 static struct igen6_pvt { 157 struct igen6_imc imc[NUM_IMC]; 158 u64 ms_hash; 159 u64 ms_s_size; 160 int ms_l_map; 161 } *igen6_pvt; 162 163 /* The top of low usable DRAM */ 164 static u32 igen6_tolud; 165 /* The size of physical memory */ 166 static u64 igen6_tom; 167 168 struct decoded_addr { 169 int mc; 170 u64 imc_addr; 171 u64 sys_addr; 172 int channel_idx; 173 u64 channel_addr; 174 int sub_channel_idx; 175 u64 sub_channel_addr; 176 }; 177 178 struct ecclog_node { 179 struct llist_node llnode; 180 int mc; 181 u64 ecclog; 182 }; 183 184 /* 185 * In the NMI handler, the driver uses the lock-less memory allocator 186 * to allocate memory to store the IBECC error logs and links the logs 187 * to the lock-less list. Delay printk() and the work of error reporting 188 * to EDAC core in a worker. 189 */ 190 #define ECCLOG_POOL_SIZE PAGE_SIZE 191 static LLIST_HEAD(ecclog_llist); 192 static struct gen_pool *ecclog_pool; 193 static char ecclog_buf[ECCLOG_POOL_SIZE]; 194 static struct irq_work ecclog_irq_work; 195 static struct work_struct ecclog_work; 196 197 /* Compute die IDs for Elkhart Lake with IBECC */ 198 #define DID_EHL_SKU5 0x4514 199 #define DID_EHL_SKU6 0x4528 200 #define DID_EHL_SKU7 0x452a 201 #define DID_EHL_SKU8 0x4516 202 #define DID_EHL_SKU9 0x452c 203 #define DID_EHL_SKU10 0x452e 204 #define DID_EHL_SKU11 0x4532 205 #define DID_EHL_SKU12 0x4518 206 #define DID_EHL_SKU13 0x451a 207 #define DID_EHL_SKU14 0x4534 208 #define DID_EHL_SKU15 0x4536 209 210 /* Compute die IDs for ICL-NNPI with IBECC */ 211 #define DID_ICL_SKU8 0x4581 212 #define DID_ICL_SKU10 0x4585 213 #define DID_ICL_SKU11 0x4589 214 #define DID_ICL_SKU12 0x458d 215 216 /* Compute die IDs for Tiger Lake with IBECC */ 217 #define DID_TGL_SKU 0x9a14 218 219 /* Compute die IDs for Alder Lake with IBECC */ 220 #define DID_ADL_SKU1 0x4601 221 #define DID_ADL_SKU2 0x4602 222 #define DID_ADL_SKU3 0x4621 223 #define DID_ADL_SKU4 0x4641 224 225 static bool ehl_ibecc_available(struct pci_dev *pdev) 226 { 227 u32 v; 228 229 if (pci_read_config_dword(pdev, CAPID_C_OFFSET, &v)) 230 return false; 231 232 return !!(CAPID_C_IBECC & v); 233 } 234 235 static u64 ehl_err_addr_to_sys_addr(u64 eaddr, int mc) 236 { 237 return eaddr; 238 } 239 240 static u64 ehl_err_addr_to_imc_addr(u64 eaddr, int mc) 241 { 242 if (eaddr < igen6_tolud) 243 return eaddr; 244 245 if (igen6_tom <= _4GB) 246 return eaddr + igen6_tolud - _4GB; 247 248 if (eaddr < _4GB) 249 return eaddr + igen6_tolud - igen6_tom; 250 251 return eaddr; 252 } 253 254 static bool icl_ibecc_available(struct pci_dev *pdev) 255 { 256 u32 v; 257 258 if (pci_read_config_dword(pdev, CAPID_C_OFFSET, &v)) 259 return false; 260 261 return !(CAPID_C_IBECC & v) && 262 (boot_cpu_data.x86_stepping >= 1); 263 } 264 265 static bool tgl_ibecc_available(struct pci_dev *pdev) 266 { 267 u32 v; 268 269 if (pci_read_config_dword(pdev, CAPID_E_OFFSET, &v)) 270 return false; 271 272 return !(CAPID_E_IBECC & v); 273 } 274 275 static u64 mem_addr_to_sys_addr(u64 maddr) 276 { 277 if (maddr < igen6_tolud) 278 return maddr; 279 280 if (igen6_tom <= _4GB) 281 return maddr - igen6_tolud + _4GB; 282 283 if (maddr < _4GB) 284 return maddr - igen6_tolud + igen6_tom; 285 286 return maddr; 287 } 288 289 static u64 mem_slice_hash(u64 addr, u64 mask, u64 hash_init, int intlv_bit) 290 { 291 u64 hash_addr = addr & mask, hash = hash_init; 292 u64 intlv = (addr >> intlv_bit) & 1; 293 int i; 294 295 for (i = 6; i < 20; i++) 296 hash ^= (hash_addr >> i) & 1; 297 298 return hash ^ intlv; 299 } 300 301 static u64 tgl_err_addr_to_mem_addr(u64 eaddr, int mc) 302 { 303 u64 maddr, hash, mask, ms_s_size; 304 int intlv_bit; 305 u32 ms_hash; 306 307 ms_s_size = igen6_pvt->ms_s_size; 308 if (eaddr >= ms_s_size) 309 return eaddr + ms_s_size; 310 311 ms_hash = igen6_pvt->ms_hash; 312 313 mask = MEM_SLICE_HASH_MASK(ms_hash); 314 intlv_bit = MEM_SLICE_HASH_LSB_MASK_BIT(ms_hash) + 6; 315 316 maddr = GET_BITFIELD(eaddr, intlv_bit, 63) << (intlv_bit + 1) | 317 GET_BITFIELD(eaddr, 0, intlv_bit - 1); 318 319 hash = mem_slice_hash(maddr, mask, mc, intlv_bit); 320 321 return maddr | (hash << intlv_bit); 322 } 323 324 static u64 tgl_err_addr_to_sys_addr(u64 eaddr, int mc) 325 { 326 u64 maddr = tgl_err_addr_to_mem_addr(eaddr, mc); 327 328 return mem_addr_to_sys_addr(maddr); 329 } 330 331 static u64 tgl_err_addr_to_imc_addr(u64 eaddr, int mc) 332 { 333 return eaddr; 334 } 335 336 static u64 adl_err_addr_to_sys_addr(u64 eaddr, int mc) 337 { 338 return mem_addr_to_sys_addr(eaddr); 339 } 340 341 static u64 adl_err_addr_to_imc_addr(u64 eaddr, int mc) 342 { 343 u64 imc_addr, ms_s_size = igen6_pvt->ms_s_size; 344 struct igen6_imc *imc = &igen6_pvt->imc[mc]; 345 int intlv_bit; 346 u32 mc_hash; 347 348 if (eaddr >= 2 * ms_s_size) 349 return eaddr - ms_s_size; 350 351 mc_hash = readl(imc->window + MAD_MC_HASH_OFFSET); 352 353 intlv_bit = MAC_MC_HASH_LSB(mc_hash) + 6; 354 355 imc_addr = GET_BITFIELD(eaddr, intlv_bit + 1, 63) << intlv_bit | 356 GET_BITFIELD(eaddr, 0, intlv_bit - 1); 357 358 return imc_addr; 359 } 360 361 static struct res_config ehl_cfg = { 362 .num_imc = 1, 363 .imc_base = 0x5000, 364 .ibecc_base = 0xdc00, 365 .ibecc_available = ehl_ibecc_available, 366 .ibecc_error_log_offset = 0x170, 367 .err_addr_to_sys_addr = ehl_err_addr_to_sys_addr, 368 .err_addr_to_imc_addr = ehl_err_addr_to_imc_addr, 369 }; 370 371 static struct res_config icl_cfg = { 372 .num_imc = 1, 373 .imc_base = 0x5000, 374 .ibecc_base = 0xd800, 375 .ibecc_error_log_offset = 0x170, 376 .ibecc_available = icl_ibecc_available, 377 .err_addr_to_sys_addr = ehl_err_addr_to_sys_addr, 378 .err_addr_to_imc_addr = ehl_err_addr_to_imc_addr, 379 }; 380 381 static struct res_config tgl_cfg = { 382 .machine_check = true, 383 .num_imc = 2, 384 .imc_base = 0x5000, 385 .cmf_base = 0x11000, 386 .cmf_size = 0x800, 387 .ms_hash_offset = 0xac, 388 .ibecc_base = 0xd400, 389 .ibecc_error_log_offset = 0x170, 390 .ibecc_available = tgl_ibecc_available, 391 .err_addr_to_sys_addr = tgl_err_addr_to_sys_addr, 392 .err_addr_to_imc_addr = tgl_err_addr_to_imc_addr, 393 }; 394 395 static struct res_config adl_cfg = { 396 .machine_check = true, 397 .num_imc = 2, 398 .imc_base = 0xd800, 399 .ibecc_base = 0xd400, 400 .ibecc_error_log_offset = 0x68, 401 .ibecc_available = tgl_ibecc_available, 402 .err_addr_to_sys_addr = adl_err_addr_to_sys_addr, 403 .err_addr_to_imc_addr = adl_err_addr_to_imc_addr, 404 }; 405 406 static const struct pci_device_id igen6_pci_tbl[] = { 407 { PCI_VDEVICE(INTEL, DID_EHL_SKU5), (kernel_ulong_t)&ehl_cfg }, 408 { PCI_VDEVICE(INTEL, DID_EHL_SKU6), (kernel_ulong_t)&ehl_cfg }, 409 { PCI_VDEVICE(INTEL, DID_EHL_SKU7), (kernel_ulong_t)&ehl_cfg }, 410 { PCI_VDEVICE(INTEL, DID_EHL_SKU8), (kernel_ulong_t)&ehl_cfg }, 411 { PCI_VDEVICE(INTEL, DID_EHL_SKU9), (kernel_ulong_t)&ehl_cfg }, 412 { PCI_VDEVICE(INTEL, DID_EHL_SKU10), (kernel_ulong_t)&ehl_cfg }, 413 { PCI_VDEVICE(INTEL, DID_EHL_SKU11), (kernel_ulong_t)&ehl_cfg }, 414 { PCI_VDEVICE(INTEL, DID_EHL_SKU12), (kernel_ulong_t)&ehl_cfg }, 415 { PCI_VDEVICE(INTEL, DID_EHL_SKU13), (kernel_ulong_t)&ehl_cfg }, 416 { PCI_VDEVICE(INTEL, DID_EHL_SKU14), (kernel_ulong_t)&ehl_cfg }, 417 { PCI_VDEVICE(INTEL, DID_EHL_SKU15), (kernel_ulong_t)&ehl_cfg }, 418 { PCI_VDEVICE(INTEL, DID_ICL_SKU8), (kernel_ulong_t)&icl_cfg }, 419 { PCI_VDEVICE(INTEL, DID_ICL_SKU10), (kernel_ulong_t)&icl_cfg }, 420 { PCI_VDEVICE(INTEL, DID_ICL_SKU11), (kernel_ulong_t)&icl_cfg }, 421 { PCI_VDEVICE(INTEL, DID_ICL_SKU12), (kernel_ulong_t)&icl_cfg }, 422 { PCI_VDEVICE(INTEL, DID_TGL_SKU), (kernel_ulong_t)&tgl_cfg }, 423 { PCI_VDEVICE(INTEL, DID_ADL_SKU1), (kernel_ulong_t)&adl_cfg }, 424 { PCI_VDEVICE(INTEL, DID_ADL_SKU2), (kernel_ulong_t)&adl_cfg }, 425 { PCI_VDEVICE(INTEL, DID_ADL_SKU3), (kernel_ulong_t)&adl_cfg }, 426 { PCI_VDEVICE(INTEL, DID_ADL_SKU4), (kernel_ulong_t)&adl_cfg }, 427 { }, 428 }; 429 MODULE_DEVICE_TABLE(pci, igen6_pci_tbl); 430 431 static enum dev_type get_width(int dimm_l, u32 mad_dimm) 432 { 433 u32 w = dimm_l ? MAD_DIMM_CH_DLW(mad_dimm) : 434 MAD_DIMM_CH_DSW(mad_dimm); 435 436 switch (w) { 437 case 0: 438 return DEV_X8; 439 case 1: 440 return DEV_X16; 441 case 2: 442 return DEV_X32; 443 default: 444 return DEV_UNKNOWN; 445 } 446 } 447 448 static enum mem_type get_memory_type(u32 mad_inter) 449 { 450 u32 t = MAD_INTER_CHANNEL_DDR_TYPE(mad_inter); 451 452 switch (t) { 453 case 0: 454 return MEM_DDR4; 455 case 1: 456 return MEM_DDR3; 457 case 2: 458 return MEM_LPDDR3; 459 case 3: 460 return MEM_LPDDR4; 461 case 4: 462 return MEM_WIO2; 463 default: 464 return MEM_UNKNOWN; 465 } 466 } 467 468 static int decode_chan_idx(u64 addr, u64 mask, int intlv_bit) 469 { 470 u64 hash_addr = addr & mask, hash = 0; 471 u64 intlv = (addr >> intlv_bit) & 1; 472 int i; 473 474 for (i = 6; i < 20; i++) 475 hash ^= (hash_addr >> i) & 1; 476 477 return (int)hash ^ intlv; 478 } 479 480 static u64 decode_channel_addr(u64 addr, int intlv_bit) 481 { 482 u64 channel_addr; 483 484 /* Remove the interleave bit and shift upper part down to fill gap */ 485 channel_addr = GET_BITFIELD(addr, intlv_bit + 1, 63) << intlv_bit; 486 channel_addr |= GET_BITFIELD(addr, 0, intlv_bit - 1); 487 488 return channel_addr; 489 } 490 491 static void decode_addr(u64 addr, u32 hash, u64 s_size, int l_map, 492 int *idx, u64 *sub_addr) 493 { 494 int intlv_bit = CHANNEL_HASH_LSB_MASK_BIT(hash) + 6; 495 496 if (addr > 2 * s_size) { 497 *sub_addr = addr - s_size; 498 *idx = l_map; 499 return; 500 } 501 502 if (CHANNEL_HASH_MODE(hash)) { 503 *sub_addr = decode_channel_addr(addr, intlv_bit); 504 *idx = decode_chan_idx(addr, CHANNEL_HASH_MASK(hash), intlv_bit); 505 } else { 506 *sub_addr = decode_channel_addr(addr, 6); 507 *idx = GET_BITFIELD(addr, 6, 6); 508 } 509 } 510 511 static int igen6_decode(struct decoded_addr *res) 512 { 513 struct igen6_imc *imc = &igen6_pvt->imc[res->mc]; 514 u64 addr = res->imc_addr, sub_addr, s_size; 515 int idx, l_map; 516 u32 hash; 517 518 if (addr >= igen6_tom) { 519 edac_dbg(0, "Address 0x%llx out of range\n", addr); 520 return -EINVAL; 521 } 522 523 /* Decode channel */ 524 hash = readl(imc->window + CHANNEL_HASH_OFFSET); 525 s_size = imc->ch_s_size; 526 l_map = imc->ch_l_map; 527 decode_addr(addr, hash, s_size, l_map, &idx, &sub_addr); 528 res->channel_idx = idx; 529 res->channel_addr = sub_addr; 530 531 /* Decode sub-channel/DIMM */ 532 hash = readl(imc->window + CHANNEL_EHASH_OFFSET); 533 s_size = imc->dimm_s_size[idx]; 534 l_map = imc->dimm_l_map[idx]; 535 decode_addr(res->channel_addr, hash, s_size, l_map, &idx, &sub_addr); 536 res->sub_channel_idx = idx; 537 res->sub_channel_addr = sub_addr; 538 539 return 0; 540 } 541 542 static void igen6_output_error(struct decoded_addr *res, 543 struct mem_ctl_info *mci, u64 ecclog) 544 { 545 enum hw_event_mc_err_type type = ecclog & ECC_ERROR_LOG_UE ? 546 HW_EVENT_ERR_UNCORRECTED : 547 HW_EVENT_ERR_CORRECTED; 548 549 edac_mc_handle_error(type, mci, 1, 550 res->sys_addr >> PAGE_SHIFT, 551 res->sys_addr & ~PAGE_MASK, 552 ECC_ERROR_LOG_SYND(ecclog), 553 res->channel_idx, res->sub_channel_idx, 554 -1, "", ""); 555 } 556 557 static struct gen_pool *ecclog_gen_pool_create(void) 558 { 559 struct gen_pool *pool; 560 561 pool = gen_pool_create(ilog2(sizeof(struct ecclog_node)), -1); 562 if (!pool) 563 return NULL; 564 565 if (gen_pool_add(pool, (unsigned long)ecclog_buf, ECCLOG_POOL_SIZE, -1)) { 566 gen_pool_destroy(pool); 567 return NULL; 568 } 569 570 return pool; 571 } 572 573 static int ecclog_gen_pool_add(int mc, u64 ecclog) 574 { 575 struct ecclog_node *node; 576 577 node = (void *)gen_pool_alloc(ecclog_pool, sizeof(*node)); 578 if (!node) 579 return -ENOMEM; 580 581 node->mc = mc; 582 node->ecclog = ecclog; 583 llist_add(&node->llnode, &ecclog_llist); 584 585 return 0; 586 } 587 588 /* 589 * Either the memory-mapped I/O status register ECC_ERROR_LOG or the PCI 590 * configuration space status register ERRSTS can indicate whether a 591 * correctable error or an uncorrectable error occurred. We only use the 592 * ECC_ERROR_LOG register to check error type, but need to clear both 593 * registers to enable future error events. 594 */ 595 static u64 ecclog_read_and_clear(struct igen6_imc *imc) 596 { 597 u64 ecclog = readq(imc->window + ECC_ERROR_LOG_OFFSET); 598 599 if (ecclog & (ECC_ERROR_LOG_CE | ECC_ERROR_LOG_UE)) { 600 /* Clear CE/UE bits by writing 1s */ 601 writeq(ecclog, imc->window + ECC_ERROR_LOG_OFFSET); 602 return ecclog; 603 } 604 605 return 0; 606 } 607 608 static void errsts_clear(struct igen6_imc *imc) 609 { 610 u16 errsts; 611 612 if (pci_read_config_word(imc->pdev, ERRSTS_OFFSET, &errsts)) { 613 igen6_printk(KERN_ERR, "Failed to read ERRSTS\n"); 614 return; 615 } 616 617 /* Clear CE/UE bits by writing 1s */ 618 if (errsts & (ERRSTS_CE | ERRSTS_UE)) 619 pci_write_config_word(imc->pdev, ERRSTS_OFFSET, errsts); 620 } 621 622 static int errcmd_enable_error_reporting(bool enable) 623 { 624 struct igen6_imc *imc = &igen6_pvt->imc[0]; 625 u16 errcmd; 626 int rc; 627 628 rc = pci_read_config_word(imc->pdev, ERRCMD_OFFSET, &errcmd); 629 if (rc) 630 return rc; 631 632 if (enable) 633 errcmd |= ERRCMD_CE | ERRSTS_UE; 634 else 635 errcmd &= ~(ERRCMD_CE | ERRSTS_UE); 636 637 rc = pci_write_config_word(imc->pdev, ERRCMD_OFFSET, errcmd); 638 if (rc) 639 return rc; 640 641 return 0; 642 } 643 644 static int ecclog_handler(void) 645 { 646 struct igen6_imc *imc; 647 int i, n = 0; 648 u64 ecclog; 649 650 for (i = 0; i < res_cfg->num_imc; i++) { 651 imc = &igen6_pvt->imc[i]; 652 653 /* errsts_clear() isn't NMI-safe. Delay it in the IRQ context */ 654 655 ecclog = ecclog_read_and_clear(imc); 656 if (!ecclog) 657 continue; 658 659 if (!ecclog_gen_pool_add(i, ecclog)) 660 irq_work_queue(&ecclog_irq_work); 661 662 n++; 663 } 664 665 return n; 666 } 667 668 static void ecclog_work_cb(struct work_struct *work) 669 { 670 struct ecclog_node *node, *tmp; 671 struct mem_ctl_info *mci; 672 struct llist_node *head; 673 struct decoded_addr res; 674 u64 eaddr; 675 676 head = llist_del_all(&ecclog_llist); 677 if (!head) 678 return; 679 680 llist_for_each_entry_safe(node, tmp, head, llnode) { 681 memset(&res, 0, sizeof(res)); 682 eaddr = ECC_ERROR_LOG_ADDR(node->ecclog) << 683 ECC_ERROR_LOG_ADDR_SHIFT; 684 res.mc = node->mc; 685 res.sys_addr = res_cfg->err_addr_to_sys_addr(eaddr, res.mc); 686 res.imc_addr = res_cfg->err_addr_to_imc_addr(eaddr, res.mc); 687 688 mci = igen6_pvt->imc[res.mc].mci; 689 690 edac_dbg(2, "MC %d, ecclog = 0x%llx\n", node->mc, node->ecclog); 691 igen6_mc_printk(mci, KERN_DEBUG, "HANDLING IBECC MEMORY ERROR\n"); 692 igen6_mc_printk(mci, KERN_DEBUG, "ADDR 0x%llx ", res.sys_addr); 693 694 if (!igen6_decode(&res)) 695 igen6_output_error(&res, mci, node->ecclog); 696 697 gen_pool_free(ecclog_pool, (unsigned long)node, sizeof(*node)); 698 } 699 } 700 701 static void ecclog_irq_work_cb(struct irq_work *irq_work) 702 { 703 int i; 704 705 for (i = 0; i < res_cfg->num_imc; i++) 706 errsts_clear(&igen6_pvt->imc[i]); 707 708 if (!llist_empty(&ecclog_llist)) 709 schedule_work(&ecclog_work); 710 } 711 712 static int ecclog_nmi_handler(unsigned int cmd, struct pt_regs *regs) 713 { 714 unsigned char reason; 715 716 if (!ecclog_handler()) 717 return NMI_DONE; 718 719 /* 720 * Both In-Band ECC correctable error and uncorrectable error are 721 * reported by SERR# NMI. The NMI generic code (see pci_serr_error()) 722 * doesn't clear the bit NMI_REASON_CLEAR_SERR (in port 0x61) to 723 * re-enable the SERR# NMI after NMI handling. So clear this bit here 724 * to re-enable SERR# NMI for receiving future In-Band ECC errors. 725 */ 726 reason = x86_platform.get_nmi_reason() & NMI_REASON_CLEAR_MASK; 727 reason |= NMI_REASON_CLEAR_SERR; 728 outb(reason, NMI_REASON_PORT); 729 reason &= ~NMI_REASON_CLEAR_SERR; 730 outb(reason, NMI_REASON_PORT); 731 732 return NMI_HANDLED; 733 } 734 735 static int ecclog_mce_handler(struct notifier_block *nb, unsigned long val, 736 void *data) 737 { 738 struct mce *mce = (struct mce *)data; 739 char *type; 740 741 if (mce->kflags & MCE_HANDLED_CEC) 742 return NOTIFY_DONE; 743 744 /* 745 * Ignore unless this is a memory related error. 746 * We don't check the bit MCI_STATUS_ADDRV of MCi_STATUS here, 747 * since this bit isn't set on some CPU (e.g., Tiger Lake UP3). 748 */ 749 if ((mce->status & 0xefff) >> 7 != 1) 750 return NOTIFY_DONE; 751 752 if (mce->mcgstatus & MCG_STATUS_MCIP) 753 type = "Exception"; 754 else 755 type = "Event"; 756 757 edac_dbg(0, "CPU %d: Machine Check %s: 0x%llx Bank %d: 0x%llx\n", 758 mce->extcpu, type, mce->mcgstatus, 759 mce->bank, mce->status); 760 edac_dbg(0, "TSC 0x%llx\n", mce->tsc); 761 edac_dbg(0, "ADDR 0x%llx\n", mce->addr); 762 edac_dbg(0, "MISC 0x%llx\n", mce->misc); 763 edac_dbg(0, "PROCESSOR %u:0x%x TIME %llu SOCKET %u APIC 0x%x\n", 764 mce->cpuvendor, mce->cpuid, mce->time, 765 mce->socketid, mce->apicid); 766 /* 767 * We just use the Machine Check for the memory error notification. 768 * Each memory controller is associated with an IBECC instance. 769 * Directly read and clear the error information(error address and 770 * error type) on all the IBECC instances so that we know on which 771 * memory controller the memory error(s) occurred. 772 */ 773 if (!ecclog_handler()) 774 return NOTIFY_DONE; 775 776 mce->kflags |= MCE_HANDLED_EDAC; 777 778 return NOTIFY_DONE; 779 } 780 781 static struct notifier_block ecclog_mce_dec = { 782 .notifier_call = ecclog_mce_handler, 783 .priority = MCE_PRIO_EDAC, 784 }; 785 786 static bool igen6_check_ecc(struct igen6_imc *imc) 787 { 788 u32 activate = readl(imc->window + IBECC_ACTIVATE_OFFSET); 789 790 return !!(activate & IBECC_ACTIVATE_EN); 791 } 792 793 static int igen6_get_dimm_config(struct mem_ctl_info *mci) 794 { 795 struct igen6_imc *imc = mci->pvt_info; 796 u32 mad_inter, mad_intra, mad_dimm; 797 int i, j, ndimms, mc = imc->mc; 798 struct dimm_info *dimm; 799 enum mem_type mtype; 800 enum dev_type dtype; 801 u64 dsize; 802 bool ecc; 803 804 edac_dbg(2, "\n"); 805 806 mad_inter = readl(imc->window + MAD_INTER_CHANNEL_OFFSET); 807 mtype = get_memory_type(mad_inter); 808 ecc = igen6_check_ecc(imc); 809 imc->ch_s_size = MAD_INTER_CHANNEL_CH_S_SIZE(mad_inter); 810 imc->ch_l_map = MAD_INTER_CHANNEL_CH_L_MAP(mad_inter); 811 812 for (i = 0; i < NUM_CHANNELS; i++) { 813 mad_intra = readl(imc->window + MAD_INTRA_CH0_OFFSET + i * 4); 814 mad_dimm = readl(imc->window + MAD_DIMM_CH0_OFFSET + i * 4); 815 816 imc->dimm_l_size[i] = MAD_DIMM_CH_DIMM_L_SIZE(mad_dimm); 817 imc->dimm_s_size[i] = MAD_DIMM_CH_DIMM_S_SIZE(mad_dimm); 818 imc->dimm_l_map[i] = MAD_INTRA_CH_DIMM_L_MAP(mad_intra); 819 imc->size += imc->dimm_s_size[i]; 820 imc->size += imc->dimm_l_size[i]; 821 ndimms = 0; 822 823 for (j = 0; j < NUM_DIMMS; j++) { 824 dimm = edac_get_dimm(mci, i, j, 0); 825 826 if (j ^ imc->dimm_l_map[i]) { 827 dtype = get_width(0, mad_dimm); 828 dsize = imc->dimm_s_size[i]; 829 } else { 830 dtype = get_width(1, mad_dimm); 831 dsize = imc->dimm_l_size[i]; 832 } 833 834 if (!dsize) 835 continue; 836 837 dimm->grain = 64; 838 dimm->mtype = mtype; 839 dimm->dtype = dtype; 840 dimm->nr_pages = MiB_TO_PAGES(dsize >> 20); 841 dimm->edac_mode = EDAC_SECDED; 842 snprintf(dimm->label, sizeof(dimm->label), 843 "MC#%d_Chan#%d_DIMM#%d", mc, i, j); 844 edac_dbg(0, "MC %d, Channel %d, DIMM %d, Size %llu MiB (%u pages)\n", 845 mc, i, j, dsize >> 20, dimm->nr_pages); 846 847 ndimms++; 848 } 849 850 if (ndimms && !ecc) { 851 igen6_printk(KERN_ERR, "MC%d In-Band ECC is disabled\n", mc); 852 return -ENODEV; 853 } 854 } 855 856 edac_dbg(0, "MC %d, total size %llu MiB\n", mc, imc->size >> 20); 857 858 return 0; 859 } 860 861 #ifdef CONFIG_EDAC_DEBUG 862 /* Top of upper usable DRAM */ 863 static u64 igen6_touud; 864 #define TOUUD_OFFSET 0xa8 865 866 static void igen6_reg_dump(struct igen6_imc *imc) 867 { 868 int i; 869 870 edac_dbg(2, "CHANNEL_HASH : 0x%x\n", 871 readl(imc->window + CHANNEL_HASH_OFFSET)); 872 edac_dbg(2, "CHANNEL_EHASH : 0x%x\n", 873 readl(imc->window + CHANNEL_EHASH_OFFSET)); 874 edac_dbg(2, "MAD_INTER_CHANNEL: 0x%x\n", 875 readl(imc->window + MAD_INTER_CHANNEL_OFFSET)); 876 edac_dbg(2, "ECC_ERROR_LOG : 0x%llx\n", 877 readq(imc->window + ECC_ERROR_LOG_OFFSET)); 878 879 for (i = 0; i < NUM_CHANNELS; i++) { 880 edac_dbg(2, "MAD_INTRA_CH%d : 0x%x\n", i, 881 readl(imc->window + MAD_INTRA_CH0_OFFSET + i * 4)); 882 edac_dbg(2, "MAD_DIMM_CH%d : 0x%x\n", i, 883 readl(imc->window + MAD_DIMM_CH0_OFFSET + i * 4)); 884 } 885 edac_dbg(2, "TOLUD : 0x%x", igen6_tolud); 886 edac_dbg(2, "TOUUD : 0x%llx", igen6_touud); 887 edac_dbg(2, "TOM : 0x%llx", igen6_tom); 888 } 889 890 static struct dentry *igen6_test; 891 892 static int debugfs_u64_set(void *data, u64 val) 893 { 894 u64 ecclog; 895 896 if ((val >= igen6_tolud && val < _4GB) || val >= igen6_touud) { 897 edac_dbg(0, "Address 0x%llx out of range\n", val); 898 return 0; 899 } 900 901 pr_warn_once("Fake error to 0x%llx injected via debugfs\n", val); 902 903 val >>= ECC_ERROR_LOG_ADDR_SHIFT; 904 ecclog = (val << ECC_ERROR_LOG_ADDR_SHIFT) | ECC_ERROR_LOG_CE; 905 906 if (!ecclog_gen_pool_add(0, ecclog)) 907 irq_work_queue(&ecclog_irq_work); 908 909 return 0; 910 } 911 DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n"); 912 913 static void igen6_debug_setup(void) 914 { 915 igen6_test = edac_debugfs_create_dir("igen6_test"); 916 if (!igen6_test) 917 return; 918 919 if (!edac_debugfs_create_file("addr", 0200, igen6_test, 920 NULL, &fops_u64_wo)) { 921 debugfs_remove(igen6_test); 922 igen6_test = NULL; 923 } 924 } 925 926 static void igen6_debug_teardown(void) 927 { 928 debugfs_remove_recursive(igen6_test); 929 } 930 #else 931 static void igen6_reg_dump(struct igen6_imc *imc) {} 932 static void igen6_debug_setup(void) {} 933 static void igen6_debug_teardown(void) {} 934 #endif 935 936 static int igen6_pci_setup(struct pci_dev *pdev, u64 *mchbar) 937 { 938 union { 939 u64 v; 940 struct { 941 u32 v_lo; 942 u32 v_hi; 943 }; 944 } u; 945 946 edac_dbg(2, "\n"); 947 948 if (!res_cfg->ibecc_available(pdev)) { 949 edac_dbg(2, "No In-Band ECC IP\n"); 950 goto fail; 951 } 952 953 if (pci_read_config_dword(pdev, TOLUD_OFFSET, &igen6_tolud)) { 954 igen6_printk(KERN_ERR, "Failed to read TOLUD\n"); 955 goto fail; 956 } 957 958 igen6_tolud &= GENMASK(31, 20); 959 960 if (pci_read_config_dword(pdev, TOM_OFFSET, &u.v_lo)) { 961 igen6_printk(KERN_ERR, "Failed to read lower TOM\n"); 962 goto fail; 963 } 964 965 if (pci_read_config_dword(pdev, TOM_OFFSET + 4, &u.v_hi)) { 966 igen6_printk(KERN_ERR, "Failed to read upper TOM\n"); 967 goto fail; 968 } 969 970 igen6_tom = u.v & GENMASK_ULL(38, 20); 971 972 if (pci_read_config_dword(pdev, MCHBAR_OFFSET, &u.v_lo)) { 973 igen6_printk(KERN_ERR, "Failed to read lower MCHBAR\n"); 974 goto fail; 975 } 976 977 if (pci_read_config_dword(pdev, MCHBAR_OFFSET + 4, &u.v_hi)) { 978 igen6_printk(KERN_ERR, "Failed to read upper MCHBAR\n"); 979 goto fail; 980 } 981 982 if (!(u.v & MCHBAR_EN)) { 983 igen6_printk(KERN_ERR, "MCHBAR is disabled\n"); 984 goto fail; 985 } 986 987 *mchbar = MCHBAR_BASE(u.v); 988 989 #ifdef CONFIG_EDAC_DEBUG 990 if (pci_read_config_dword(pdev, TOUUD_OFFSET, &u.v_lo)) 991 edac_dbg(2, "Failed to read lower TOUUD\n"); 992 else if (pci_read_config_dword(pdev, TOUUD_OFFSET + 4, &u.v_hi)) 993 edac_dbg(2, "Failed to read upper TOUUD\n"); 994 else 995 igen6_touud = u.v & GENMASK_ULL(38, 20); 996 #endif 997 998 return 0; 999 fail: 1000 return -ENODEV; 1001 } 1002 1003 static int igen6_register_mci(int mc, u64 mchbar, struct pci_dev *pdev) 1004 { 1005 struct edac_mc_layer layers[2]; 1006 struct mem_ctl_info *mci; 1007 struct igen6_imc *imc; 1008 void __iomem *window; 1009 int rc; 1010 1011 edac_dbg(2, "\n"); 1012 1013 mchbar += mc * MCHBAR_SIZE; 1014 window = ioremap(mchbar, MCHBAR_SIZE); 1015 if (!window) { 1016 igen6_printk(KERN_ERR, "Failed to ioremap 0x%llx\n", mchbar); 1017 return -ENODEV; 1018 } 1019 1020 layers[0].type = EDAC_MC_LAYER_CHANNEL; 1021 layers[0].size = NUM_CHANNELS; 1022 layers[0].is_virt_csrow = false; 1023 layers[1].type = EDAC_MC_LAYER_SLOT; 1024 layers[1].size = NUM_DIMMS; 1025 layers[1].is_virt_csrow = true; 1026 1027 mci = edac_mc_alloc(mc, ARRAY_SIZE(layers), layers, 0); 1028 if (!mci) { 1029 rc = -ENOMEM; 1030 goto fail; 1031 } 1032 1033 mci->ctl_name = kasprintf(GFP_KERNEL, "Intel_client_SoC MC#%d", mc); 1034 if (!mci->ctl_name) { 1035 rc = -ENOMEM; 1036 goto fail2; 1037 } 1038 1039 mci->mtype_cap = MEM_FLAG_LPDDR4 | MEM_FLAG_DDR4; 1040 mci->edac_ctl_cap = EDAC_FLAG_SECDED; 1041 mci->edac_cap = EDAC_FLAG_SECDED; 1042 mci->mod_name = EDAC_MOD_STR; 1043 mci->dev_name = pci_name(pdev); 1044 mci->pvt_info = &igen6_pvt->imc[mc]; 1045 1046 imc = mci->pvt_info; 1047 device_initialize(&imc->dev); 1048 /* 1049 * EDAC core uses mci->pdev(pointer of structure device) as 1050 * memory controller ID. The client SoCs attach one or more 1051 * memory controllers to single pci_dev (single pci_dev->dev 1052 * can be for multiple memory controllers). 1053 * 1054 * To make mci->pdev unique, assign pci_dev->dev to mci->pdev 1055 * for the first memory controller and assign a unique imc->dev 1056 * to mci->pdev for each non-first memory controller. 1057 */ 1058 mci->pdev = mc ? &imc->dev : &pdev->dev; 1059 imc->mc = mc; 1060 imc->pdev = pdev; 1061 imc->window = window; 1062 1063 igen6_reg_dump(imc); 1064 1065 rc = igen6_get_dimm_config(mci); 1066 if (rc) 1067 goto fail3; 1068 1069 rc = edac_mc_add_mc(mci); 1070 if (rc) { 1071 igen6_printk(KERN_ERR, "Failed to register mci#%d\n", mc); 1072 goto fail3; 1073 } 1074 1075 imc->mci = mci; 1076 return 0; 1077 fail3: 1078 kfree(mci->ctl_name); 1079 fail2: 1080 edac_mc_free(mci); 1081 fail: 1082 iounmap(window); 1083 return rc; 1084 } 1085 1086 static void igen6_unregister_mcis(void) 1087 { 1088 struct mem_ctl_info *mci; 1089 struct igen6_imc *imc; 1090 int i; 1091 1092 edac_dbg(2, "\n"); 1093 1094 for (i = 0; i < res_cfg->num_imc; i++) { 1095 imc = &igen6_pvt->imc[i]; 1096 mci = imc->mci; 1097 if (!mci) 1098 continue; 1099 1100 edac_mc_del_mc(mci->pdev); 1101 kfree(mci->ctl_name); 1102 edac_mc_free(mci); 1103 iounmap(imc->window); 1104 } 1105 } 1106 1107 static int igen6_mem_slice_setup(u64 mchbar) 1108 { 1109 struct igen6_imc *imc = &igen6_pvt->imc[0]; 1110 u64 base = mchbar + res_cfg->cmf_base; 1111 u32 offset = res_cfg->ms_hash_offset; 1112 u32 size = res_cfg->cmf_size; 1113 u64 ms_s_size, ms_hash; 1114 void __iomem *cmf; 1115 int ms_l_map; 1116 1117 edac_dbg(2, "\n"); 1118 1119 if (imc[0].size < imc[1].size) { 1120 ms_s_size = imc[0].size; 1121 ms_l_map = 1; 1122 } else { 1123 ms_s_size = imc[1].size; 1124 ms_l_map = 0; 1125 } 1126 1127 igen6_pvt->ms_s_size = ms_s_size; 1128 igen6_pvt->ms_l_map = ms_l_map; 1129 1130 edac_dbg(0, "ms_s_size: %llu MiB, ms_l_map %d\n", 1131 ms_s_size >> 20, ms_l_map); 1132 1133 if (!size) 1134 return 0; 1135 1136 cmf = ioremap(base, size); 1137 if (!cmf) { 1138 igen6_printk(KERN_ERR, "Failed to ioremap cmf 0x%llx\n", base); 1139 return -ENODEV; 1140 } 1141 1142 ms_hash = readq(cmf + offset); 1143 igen6_pvt->ms_hash = ms_hash; 1144 1145 edac_dbg(0, "MEM_SLICE_HASH: 0x%llx\n", ms_hash); 1146 1147 iounmap(cmf); 1148 1149 return 0; 1150 } 1151 1152 static int register_err_handler(void) 1153 { 1154 int rc; 1155 1156 if (res_cfg->machine_check) { 1157 mce_register_decode_chain(&ecclog_mce_dec); 1158 return 0; 1159 } 1160 1161 rc = register_nmi_handler(NMI_SERR, ecclog_nmi_handler, 1162 0, IGEN6_NMI_NAME); 1163 if (rc) { 1164 igen6_printk(KERN_ERR, "Failed to register NMI handler\n"); 1165 return rc; 1166 } 1167 1168 return 0; 1169 } 1170 1171 static void unregister_err_handler(void) 1172 { 1173 if (res_cfg->machine_check) { 1174 mce_unregister_decode_chain(&ecclog_mce_dec); 1175 return; 1176 } 1177 1178 unregister_nmi_handler(NMI_SERR, IGEN6_NMI_NAME); 1179 } 1180 1181 static int igen6_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 1182 { 1183 u64 mchbar; 1184 int i, rc; 1185 1186 edac_dbg(2, "\n"); 1187 1188 igen6_pvt = kzalloc(sizeof(*igen6_pvt), GFP_KERNEL); 1189 if (!igen6_pvt) 1190 return -ENOMEM; 1191 1192 res_cfg = (struct res_config *)ent->driver_data; 1193 1194 rc = igen6_pci_setup(pdev, &mchbar); 1195 if (rc) 1196 goto fail; 1197 1198 for (i = 0; i < res_cfg->num_imc; i++) { 1199 rc = igen6_register_mci(i, mchbar, pdev); 1200 if (rc) 1201 goto fail2; 1202 } 1203 1204 if (res_cfg->num_imc > 1) { 1205 rc = igen6_mem_slice_setup(mchbar); 1206 if (rc) 1207 goto fail2; 1208 } 1209 1210 ecclog_pool = ecclog_gen_pool_create(); 1211 if (!ecclog_pool) { 1212 rc = -ENOMEM; 1213 goto fail2; 1214 } 1215 1216 INIT_WORK(&ecclog_work, ecclog_work_cb); 1217 init_irq_work(&ecclog_irq_work, ecclog_irq_work_cb); 1218 1219 /* Check if any pending errors before registering the NMI handler */ 1220 ecclog_handler(); 1221 1222 rc = register_err_handler(); 1223 if (rc) 1224 goto fail3; 1225 1226 /* Enable error reporting */ 1227 rc = errcmd_enable_error_reporting(true); 1228 if (rc) { 1229 igen6_printk(KERN_ERR, "Failed to enable error reporting\n"); 1230 goto fail4; 1231 } 1232 1233 igen6_debug_setup(); 1234 return 0; 1235 fail4: 1236 unregister_nmi_handler(NMI_SERR, IGEN6_NMI_NAME); 1237 fail3: 1238 gen_pool_destroy(ecclog_pool); 1239 fail2: 1240 igen6_unregister_mcis(); 1241 fail: 1242 kfree(igen6_pvt); 1243 return rc; 1244 } 1245 1246 static void igen6_remove(struct pci_dev *pdev) 1247 { 1248 edac_dbg(2, "\n"); 1249 1250 igen6_debug_teardown(); 1251 errcmd_enable_error_reporting(false); 1252 unregister_err_handler(); 1253 irq_work_sync(&ecclog_irq_work); 1254 flush_work(&ecclog_work); 1255 gen_pool_destroy(ecclog_pool); 1256 igen6_unregister_mcis(); 1257 kfree(igen6_pvt); 1258 } 1259 1260 static struct pci_driver igen6_driver = { 1261 .name = EDAC_MOD_STR, 1262 .probe = igen6_probe, 1263 .remove = igen6_remove, 1264 .id_table = igen6_pci_tbl, 1265 }; 1266 1267 static int __init igen6_init(void) 1268 { 1269 const char *owner; 1270 int rc; 1271 1272 edac_dbg(2, "\n"); 1273 1274 owner = edac_get_owner(); 1275 if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR))) 1276 return -ENODEV; 1277 1278 edac_op_state = EDAC_OPSTATE_NMI; 1279 1280 rc = pci_register_driver(&igen6_driver); 1281 if (rc) 1282 return rc; 1283 1284 igen6_printk(KERN_INFO, "%s\n", IGEN6_REVISION); 1285 1286 return 0; 1287 } 1288 1289 static void __exit igen6_exit(void) 1290 { 1291 edac_dbg(2, "\n"); 1292 1293 pci_unregister_driver(&igen6_driver); 1294 } 1295 1296 module_init(igen6_init); 1297 module_exit(igen6_exit); 1298 1299 MODULE_LICENSE("GPL v2"); 1300 MODULE_AUTHOR("Qiuxu Zhuo"); 1301 MODULE_DESCRIPTION("MC Driver for Intel client SoC using In-Band ECC"); 1302