drivers/edac/amd64_edac.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include "amd64_edac.h"
   3 #include <asm/amd_nb.h>
   4
   5 static struct edac_pci_ctl_info *pci_ctl;
   6
   7 static int report_gart_errors;
   8 module_param(report_gart_errors, int, 0644);
   9
  10 /*
  11  * Set by command line parameter. If BIOS has enabled the ECC, this override is
  12  * cleared to prevent re-enabling the hardware by this driver.
  13  */
  14 static int ecc_enable_override;
  15 module_param(ecc_enable_override, int, 0644);
  16
  17 static struct msr __percpu *msrs;
  18
  19 /* Per-node stuff */
  20 static struct ecc_settings **ecc_stngs;
  21
  22 /* Number of Unified Memory Controllers */
  23 static u8 num_umcs;
  24
  25 /*
  26  * Valid scrub rates for the K8 hardware memory scrubber. We map the scrubbing
  27  * bandwidth to a valid bit pattern. The 'set' operation finds the 'matching-
  28  * or higher value'.
  29  *
  30  *FIXME: Produce a better mapping/linearisation.
  31  */
  32 static const struct scrubrate {
  33        u32 scrubval;           /* bit pattern for scrub rate */
  34        u32 bandwidth;          /* bandwidth consumed (bytes/sec) */
  35 } scrubrates[] = {
  36         { 0x01, 1600000000UL},
  37         { 0x02, 800000000UL},
  38         { 0x03, 400000000UL},
  39         { 0x04, 200000000UL},
  40         { 0x05, 100000000UL},
  41         { 0x06, 50000000UL},
  42         { 0x07, 25000000UL},
  43         { 0x08, 12284069UL},
  44         { 0x09, 6274509UL},
  45         { 0x0A, 3121951UL},
  46         { 0x0B, 1560975UL},
  47         { 0x0C, 781440UL},
  48         { 0x0D, 390720UL},
  49         { 0x0E, 195300UL},
  50         { 0x0F, 97650UL},
  51         { 0x10, 48854UL},
  52         { 0x11, 24427UL},
  53         { 0x12, 12213UL},
  54         { 0x13, 6101UL},
  55         { 0x14, 3051UL},
  56         { 0x15, 1523UL},
  57         { 0x16, 761UL},
  58         { 0x00, 0UL},        /* scrubbing off */
  59 };
  60
  61 int __amd64_read_pci_cfg_dword(struct pci_dev *pdev, int offset,
  62                                u32 *val, const char *func)
  63 {
  64         int err = 0;
  65
  66         err = pci_read_config_dword(pdev, offset, val);
  67         if (err)
  68                 amd64_warn("%s: error reading F%dx%03x.\n",
  69                            func, PCI_FUNC(pdev->devfn), offset);
  70
  71         return err;
  72 }
  73
  74 int __amd64_write_pci_cfg_dword(struct pci_dev *pdev, int offset,
  75                                 u32 val, const char *func)
  76 {
  77         int err = 0;
  78
  79         err = pci_write_config_dword(pdev, offset, val);
  80         if (err)
  81                 amd64_warn("%s: error writing to F%dx%03x.\n",
  82                            func, PCI_FUNC(pdev->devfn), offset);
  83
  84         return err;
  85 }
  86
  87 /*
  88  * Select DCT to which PCI cfg accesses are routed
  89  */
  90 static void f15h_select_dct(struct amd64_pvt *pvt, u8 dct)
  91 {
  92         u32 reg = 0;
  93
  94         amd64_read_pci_cfg(pvt->F1, DCT_CFG_SEL, &reg);
  95         reg &= (pvt->model == 0x30) ? ~3 : ~1;
  96         reg |= dct;
  97         amd64_write_pci_cfg(pvt->F1, DCT_CFG_SEL, reg);
  98 }
  99
 100 /*
 101  *
 102  * Depending on the family, F2 DCT reads need special handling:
 103  *
 104  * K8: has a single DCT only and no address offsets >= 0x100
 105  *
 106  * F10h: each DCT has its own set of regs
 107  *      DCT0 -> F2x040..
 108  *      DCT1 -> F2x140..
 109  *
 110  * F16h: has only 1 DCT
 111  *
 112  * F15h: we select which DCT we access using F1x10C[DctCfgSel]
 113  */
 114 static inline int amd64_read_dct_pci_cfg(struct amd64_pvt *pvt, u8 dct,
 115                                          int offset, u32 *val)
 116 {
 117         switch (pvt->fam) {
 118         case 0xf:
 119                 if (dct || offset >= 0x100)
 120                         return -EINVAL;
 121                 break;
 122
 123         case 0x10:
 124                 if (dct) {
 125                         /*
 126                          * Note: If ganging is enabled, barring the regs
 127                          * F2x[1,0]98 and F2x[1,0]9C; reads reads to F2x1xx
 128                          * return 0. (cf. Section 2.8.1 F10h BKDG)
 129                          */
 130                         if (dct_ganging_enabled(pvt))
 131                                 return 0;
 132
 133                         offset += 0x100;
 134                 }
 135                 break;
 136
 137         case 0x15:
 138                 /*
 139                  * F15h: F2x1xx addresses do not map explicitly to DCT1.
 140                  * We should select which DCT we access using F1x10C[DctCfgSel]
 141                  */
 142                 dct = (dct && pvt->model == 0x30) ? 3 : dct;
 143                 f15h_select_dct(pvt, dct);
 144                 break;
 145
 146         case 0x16:
 147                 if (dct)
 148                         return -EINVAL;
 149                 break;
 150
 151         default:
 152                 break;
 153         }
 154         return amd64_read_pci_cfg(pvt->F2, offset, val);
 155 }
 156
 157 /*
 158  * Memory scrubber control interface. For K8, memory scrubbing is handled by
 159  * hardware and can involve L2 cache, dcache as well as the main memory. With
 160  * F10, this is extended to L3 cache scrubbing on CPU models sporting that
 161  * functionality.
 162  *
 163  * This causes the "units" for the scrubbing speed to vary from 64 byte blocks
 164  * (dram) over to cache lines. This is nasty, so we will use bandwidth in
 165  * bytes/sec for the setting.
 166  *
 167  * Currently, we only do dram scrubbing. If the scrubbing is done in software on
 168  * other archs, we might not have access to the caches directly.
 169  */
 170
 171 static inline void __f17h_set_scrubval(struct amd64_pvt *pvt, u32 scrubval)
 172 {
 173         /*
 174          * Fam17h supports scrub values between 0x5 and 0x14. Also, the values
 175          * are shifted down by 0x5, so scrubval 0x5 is written to the register
 176          * as 0x0, scrubval 0x6 as 0x1, etc.
 177          */
 178         if (scrubval >= 0x5 && scrubval <= 0x14) {
 179                 scrubval -= 0x5;
 180                 pci_write_bits32(pvt->F6, F17H_SCR_LIMIT_ADDR, scrubval, 0xF);
 181                 pci_write_bits32(pvt->F6, F17H_SCR_BASE_ADDR, 1, 0x1);
 182         } else {
 183                 pci_write_bits32(pvt->F6, F17H_SCR_BASE_ADDR, 0, 0x1);
 184         }
 185 }
 186 /*
 187  * Scan the scrub rate mapping table for a close or matching bandwidth value to
 188  * issue. If requested is too big, then use last maximum value found.
 189  */
 190 static int __set_scrub_rate(struct amd64_pvt *pvt, u32 new_bw, u32 min_rate)
 191 {
 192         u32 scrubval;
 193         int i;
 194
 195         /*
 196          * map the configured rate (new_bw) to a value specific to the AMD64
 197          * memory controller and apply to register. Search for the first
 198          * bandwidth entry that is greater or equal than the setting requested
 199          * and program that. If at last entry, turn off DRAM scrubbing.
 200          *
 201          * If no suitable bandwidth is found, turn off DRAM scrubbing entirely
 202          * by falling back to the last element in scrubrates[].
 203          */
 204         for (i = 0; i < ARRAY_SIZE(scrubrates) - 1; i++) {
 205                 /*
 206                  * skip scrub rates which aren't recommended
 207                  * (see F10 BKDG, F3x58)
 208                  */
 209                 if (scrubrates[i].scrubval < min_rate)
 210                         continue;
 211
 212                 if (scrubrates[i].bandwidth <= new_bw)
 213                         break;
 214         }
 215
 216         scrubval = scrubrates[i].scrubval;
 217
 218         if (pvt->fam == 0x17 || pvt->fam == 0x18) {
 219                 __f17h_set_scrubval(pvt, scrubval);
 220         } else if (pvt->fam == 0x15 && pvt->model == 0x60) {
 221                 f15h_select_dct(pvt, 0);
 222                 pci_write_bits32(pvt->F2, F15H_M60H_SCRCTRL, scrubval, 0x001F);
 223                 f15h_select_dct(pvt, 1);
 224                 pci_write_bits32(pvt->F2, F15H_M60H_SCRCTRL, scrubval, 0x001F);
 225         } else {
 226                 pci_write_bits32(pvt->F3, SCRCTRL, scrubval, 0x001F);
 227         }
 228
 229         if (scrubval)
 230                 return scrubrates[i].bandwidth;
 231
 232         return 0;
 233 }
 234
 235 static int set_scrub_rate(struct mem_ctl_info *mci, u32 bw)
 236 {
 237         struct amd64_pvt *pvt = mci->pvt_info;
 238         u32 min_scrubrate = 0x5;
 239
 240         if (pvt->fam == 0xf)
 241                 min_scrubrate = 0x0;
 242
 243         if (pvt->fam == 0x15) {
 244                 /* Erratum #505 */
 245                 if (pvt->model < 0x10)
 246                         f15h_select_dct(pvt, 0);
 247
 248                 if (pvt->model == 0x60)
 249                         min_scrubrate = 0x6;
 250         }
 251         return __set_scrub_rate(pvt, bw, min_scrubrate);
 252 }
 253
 254 static int get_scrub_rate(struct mem_ctl_info *mci)
 255 {
 256         struct amd64_pvt *pvt = mci->pvt_info;
 257         int i, retval = -EINVAL;
 258         u32 scrubval = 0;
 259
 260         switch (pvt->fam) {
 261         case 0x15:
 262                 /* Erratum #505 */
 263                 if (pvt->model < 0x10)
 264                         f15h_select_dct(pvt, 0);
 265
 266                 if (pvt->model == 0x60)
 267                         amd64_read_pci_cfg(pvt->F2, F15H_M60H_SCRCTRL, &scrubval);
 268                 break;
 269
 270         case 0x17:
 271         case 0x18:
 272                 amd64_read_pci_cfg(pvt->F6, F17H_SCR_BASE_ADDR, &scrubval);
 273                 if (scrubval & BIT(0)) {
 274                         amd64_read_pci_cfg(pvt->F6, F17H_SCR_LIMIT_ADDR, &scrubval);
 275                         scrubval &= 0xF;
 276                         scrubval += 0x5;
 277                 } else {
 278                         scrubval = 0;
 279                 }
 280                 break;
 281
 282         default:
 283                 amd64_read_pci_cfg(pvt->F3, SCRCTRL, &scrubval);
 284                 break;
 285         }
 286
 287         scrubval = scrubval & 0x001F;
 288
 289         for (i = 0; i < ARRAY_SIZE(scrubrates); i++) {
 290                 if (scrubrates[i].scrubval == scrubval) {
 291                         retval = scrubrates[i].bandwidth;
 292                         break;
 293                 }
 294         }
 295         return retval;
 296 }
 297
 298 /*
 299  * returns true if the SysAddr given by sys_addr matches the
 300  * DRAM base/limit associated with node_id
 301  */
 302 static bool base_limit_match(struct amd64_pvt *pvt, u64 sys_addr, u8 nid)
 303 {
 304         u64 addr;
 305
 306         /* The K8 treats this as a 40-bit value.  However, bits 63-40 will be
 307          * all ones if the most significant implemented address bit is 1.
 308          * Here we discard bits 63-40.  See section 3.4.2 of AMD publication
 309          * 24592: AMD x86-64 Architecture Programmer's Manual Volume 1
 310          * Application Programming.
 311          */
 312         addr = sys_addr & 0x000000ffffffffffull;
 313
 314         return ((addr >= get_dram_base(pvt, nid)) &&
 315                 (addr <= get_dram_limit(pvt, nid)));
 316 }
 317
 318 /*
 319  * Attempt to map a SysAddr to a node. On success, return a pointer to the
 320  * mem_ctl_info structure for the node that the SysAddr maps to.
 321  *
 322  * On failure, return NULL.
 323  */
 324 static struct mem_ctl_info *find_mc_by_sys_addr(struct mem_ctl_info *mci,
 325                                                 u64 sys_addr)
 326 {
 327         struct amd64_pvt *pvt;
 328         u8 node_id;
 329         u32 intlv_en, bits;
 330
 331         /*
 332          * Here we use the DRAM Base (section 3.4.4.1) and DRAM Limit (section
 333          * 3.4.4.2) registers to map the SysAddr to a node ID.
 334          */
 335         pvt = mci->pvt_info;
 336
 337         /*
 338          * The value of this field should be the same for all DRAM Base
 339          * registers.  Therefore we arbitrarily choose to read it from the
 340          * register for node 0.
 341          */
 342         intlv_en = dram_intlv_en(pvt, 0);
 343
 344         if (intlv_en == 0) {
 345                 for (node_id = 0; node_id < DRAM_RANGES; node_id++) {
 346                         if (base_limit_match(pvt, sys_addr, node_id))
 347                                 goto found;
 348                 }
 349                 goto err_no_match;
 350         }
 351
 352         if (unlikely((intlv_en != 0x01) &&
 353                      (intlv_en != 0x03) &&
 354                      (intlv_en != 0x07))) {
 355                 amd64_warn("DRAM Base[IntlvEn] junk value: 0x%x, BIOS bug?\n", intlv_en);
 356                 return NULL;
 357         }
 358
 359         bits = (((u32) sys_addr) >> 12) & intlv_en;
 360
 361         for (node_id = 0; ; ) {
 362                 if ((dram_intlv_sel(pvt, node_id) & intlv_en) == bits)
 363                         break;  /* intlv_sel field matches */
 364
 365                 if (++node_id >= DRAM_RANGES)
 366                         goto err_no_match;
 367         }
 368
 369         /* sanity test for sys_addr */
 370         if (unlikely(!base_limit_match(pvt, sys_addr, node_id))) {
 371                 amd64_warn("%s: sys_addr 0x%llx falls outside base/limit address"
 372                            "range for node %d with node interleaving enabled.\n",
 373                            __func__, sys_addr, node_id);
 374                 return NULL;
 375         }
 376
 377 found:
 378         return edac_mc_find((int)node_id);
 379
 380 err_no_match:
 381         edac_dbg(2, "sys_addr 0x%lx doesn't match any node\n",
 382                  (unsigned long)sys_addr);
 383
 384         return NULL;
 385 }
 386
 387 /*
 388  * compute the CS base address of the @csrow on the DRAM controller @dct.
 389  * For details see F2x[5C:40] in the processor's BKDG
 390  */
 391 static void get_cs_base_and_mask(struct amd64_pvt *pvt, int csrow, u8 dct,
 392                                  u64 *base, u64 *mask)
 393 {
 394         u64 csbase, csmask, base_bits, mask_bits;
 395         u8 addr_shift;
 396
 397         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_F) {
 398                 csbase          = pvt->csels[dct].csbases[csrow];
 399                 csmask          = pvt->csels[dct].csmasks[csrow];
 400                 base_bits       = GENMASK_ULL(31, 21) | GENMASK_ULL(15, 9);
 401                 mask_bits       = GENMASK_ULL(29, 21) | GENMASK_ULL(15, 9);
 402                 addr_shift      = 4;
 403
 404         /*
 405          * F16h and F15h, models 30h and later need two addr_shift values:
 406          * 8 for high and 6 for low (cf. F16h BKDG).
 407          */
 408         } else if (pvt->fam == 0x16 ||
 409                   (pvt->fam == 0x15 && pvt->model >= 0x30)) {
 410                 csbase          = pvt->csels[dct].csbases[csrow];
 411                 csmask          = pvt->csels[dct].csmasks[csrow >> 1];
 412
 413                 *base  = (csbase & GENMASK_ULL(15,  5)) << 6;
 414                 *base |= (csbase & GENMASK_ULL(30, 19)) << 8;
 415
 416                 *mask = ~0ULL;
 417                 /* poke holes for the csmask */
 418                 *mask &= ~((GENMASK_ULL(15, 5)  << 6) |
 419                            (GENMASK_ULL(30, 19) << 8));
 420
 421                 *mask |= (csmask & GENMASK_ULL(15, 5))  << 6;
 422                 *mask |= (csmask & GENMASK_ULL(30, 19)) << 8;
 423
 424                 return;
 425         } else {
 426                 csbase          = pvt->csels[dct].csbases[csrow];
 427                 csmask          = pvt->csels[dct].csmasks[csrow >> 1];
 428                 addr_shift      = 8;
 429
 430                 if (pvt->fam == 0x15)
 431                         base_bits = mask_bits =
 432                                 GENMASK_ULL(30,19) | GENMASK_ULL(13,5);
 433                 else
 434                         base_bits = mask_bits =
 435                                 GENMASK_ULL(28,19) | GENMASK_ULL(13,5);
 436         }
 437
 438         *base  = (csbase & base_bits) << addr_shift;
 439
 440         *mask  = ~0ULL;
 441         /* poke holes for the csmask */
 442         *mask &= ~(mask_bits << addr_shift);
 443         /* OR them in */
 444         *mask |= (csmask & mask_bits) << addr_shift;
 445 }
 446
 447 #define for_each_chip_select(i, dct, pvt) \
 448         for (i = 0; i < pvt->csels[dct].b_cnt; i++)
 449
 450 #define chip_select_base(i, dct, pvt) \
 451         pvt->csels[dct].csbases[i]
 452
 453 #define for_each_chip_select_mask(i, dct, pvt) \
 454         for (i = 0; i < pvt->csels[dct].m_cnt; i++)
 455
 456 #define for_each_umc(i) \
 457         for (i = 0; i < num_umcs; i++)
 458
 459 /*
 460  * @input_addr is an InputAddr associated with the node given by mci. Return the
 461  * csrow that input_addr maps to, or -1 on failure (no csrow claims input_addr).
 462  */
 463 static int input_addr_to_csrow(struct mem_ctl_info *mci, u64 input_addr)
 464 {
 465         struct amd64_pvt *pvt;
 466         int csrow;
 467         u64 base, mask;
 468
 469         pvt = mci->pvt_info;
 470
 471         for_each_chip_select(csrow, 0, pvt) {
 472                 if (!csrow_enabled(csrow, 0, pvt))
 473                         continue;
 474
 475                 get_cs_base_and_mask(pvt, csrow, 0, &base, &mask);
 476
 477                 mask = ~mask;
 478
 479                 if ((input_addr & mask) == (base & mask)) {
 480                         edac_dbg(2, "InputAddr 0x%lx matches csrow %d (node %d)\n",
 481                                  (unsigned long)input_addr, csrow,
 482                                  pvt->mc_node_id);
 483
 484                         return csrow;
 485                 }
 486         }
 487         edac_dbg(2, "no matching csrow for InputAddr 0x%lx (MC node %d)\n",
 488                  (unsigned long)input_addr, pvt->mc_node_id);
 489
 490         return -1;
 491 }
 492
 493 /*
 494  * Obtain info from the DRAM Hole Address Register (section 3.4.8, pub #26094)
 495  * for the node represented by mci. Info is passed back in *hole_base,
 496  * *hole_offset, and *hole_size.  Function returns 0 if info is valid or 1 if
 497  * info is invalid. Info may be invalid for either of the following reasons:
 498  *
 499  * - The revision of the node is not E or greater.  In this case, the DRAM Hole
 500  *   Address Register does not exist.
 501  *
 502  * - The DramHoleValid bit is cleared in the DRAM Hole Address Register,
 503  *   indicating that its contents are not valid.
 504  *
 505  * The values passed back in *hole_base, *hole_offset, and *hole_size are
 506  * complete 32-bit values despite the fact that the bitfields in the DHAR
 507  * only represent bits 31-24 of the base and offset values.
 508  */
 509 int amd64_get_dram_hole_info(struct mem_ctl_info *mci, u64 *hole_base,
 510                              u64 *hole_offset, u64 *hole_size)
 511 {
 512         struct amd64_pvt *pvt = mci->pvt_info;
 513
 514         /* only revE and later have the DRAM Hole Address Register */
 515         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_E) {
 516                 edac_dbg(1, "  revision %d for node %d does not support DHAR\n",
 517                          pvt->ext_model, pvt->mc_node_id);
 518                 return 1;
 519         }
 520
 521         /* valid for Fam10h and above */
 522         if (pvt->fam >= 0x10 && !dhar_mem_hoist_valid(pvt)) {
 523                 edac_dbg(1, "  Dram Memory Hoisting is DISABLED on this system\n");
 524                 return 1;
 525         }
 526
 527         if (!dhar_valid(pvt)) {
 528                 edac_dbg(1, "  Dram Memory Hoisting is DISABLED on this node %d\n",
 529                          pvt->mc_node_id);
 530                 return 1;
 531         }
 532
 533         /* This node has Memory Hoisting */
 534
 535         /* +------------------+--------------------+--------------------+-----
 536          * | memory           | DRAM hole          | relocated          |
 537          * | [0, (x - 1)]     | [x, 0xffffffff]    | addresses from     |
 538          * |                  |                    | DRAM hole          |
 539          * |                  |                    | [0x100000000,      |
 540          * |                  |                    |  (0x100000000+     |
 541          * |                  |                    |   (0xffffffff-x))] |
 542          * +------------------+--------------------+--------------------+-----
 543          *
 544          * Above is a diagram of physical memory showing the DRAM hole and the
 545          * relocated addresses from the DRAM hole.  As shown, the DRAM hole
 546          * starts at address x (the base address) and extends through address
 547          * 0xffffffff.  The DRAM Hole Address Register (DHAR) relocates the
 548          * addresses in the hole so that they start at 0x100000000.
 549          */
 550
 551         *hole_base = dhar_base(pvt);
 552         *hole_size = (1ULL << 32) - *hole_base;
 553
 554         *hole_offset = (pvt->fam > 0xf) ? f10_dhar_offset(pvt)
 555                                         : k8_dhar_offset(pvt);
 556
 557         edac_dbg(1, "  DHAR info for node %d base 0x%lx offset 0x%lx size 0x%lx\n",
 558                  pvt->mc_node_id, (unsigned long)*hole_base,
 559                  (unsigned long)*hole_offset, (unsigned long)*hole_size);
 560
 561         return 0;
 562 }
 563 EXPORT_SYMBOL_GPL(amd64_get_dram_hole_info);
 564
 565 /*
 566  * Return the DramAddr that the SysAddr given by @sys_addr maps to.  It is
 567  * assumed that sys_addr maps to the node given by mci.
 568  *
 569  * The first part of section 3.4.4 (p. 70) shows how the DRAM Base (section
 570  * 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers are used to translate a
 571  * SysAddr to a DramAddr. If the DRAM Hole Address Register (DHAR) is enabled,
 572  * then it is also involved in translating a SysAddr to a DramAddr. Sections
 573  * 3.4.8 and 3.5.8.2 describe the DHAR and how it is used for memory hoisting.
 574  * These parts of the documentation are unclear. I interpret them as follows:
 575  *
 576  * When node n receives a SysAddr, it processes the SysAddr as follows:
 577  *
 578  * 1. It extracts the DRAMBase and DRAMLimit values from the DRAM Base and DRAM
 579  *    Limit registers for node n. If the SysAddr is not within the range
 580  *    specified by the base and limit values, then node n ignores the Sysaddr
 581  *    (since it does not map to node n). Otherwise continue to step 2 below.
 582  *
 583  * 2. If the DramHoleValid bit of the DHAR for node n is clear, the DHAR is
 584  *    disabled so skip to step 3 below. Otherwise see if the SysAddr is within
 585  *    the range of relocated addresses (starting at 0x100000000) from the DRAM
 586  *    hole. If not, skip to step 3 below. Else get the value of the
 587  *    DramHoleOffset field from the DHAR. To obtain the DramAddr, subtract the
 588  *    offset defined by this value from the SysAddr.
 589  *
 590  * 3. Obtain the base address for node n from the DRAMBase field of the DRAM
 591  *    Base register for node n. To obtain the DramAddr, subtract the base
 592  *    address from the SysAddr, as shown near the start of section 3.4.4 (p.70).
 593  */
 594 static u64 sys_addr_to_dram_addr(struct mem_ctl_info *mci, u64 sys_addr)
 595 {
 596         struct amd64_pvt *pvt = mci->pvt_info;
 597         u64 dram_base, hole_base, hole_offset, hole_size, dram_addr;
 598         int ret;
 599
 600         dram_base = get_dram_base(pvt, pvt->mc_node_id);
 601
 602         ret = amd64_get_dram_hole_info(mci, &hole_base, &hole_offset,
 603                                       &hole_size);
 604         if (!ret) {
 605                 if ((sys_addr >= (1ULL << 32)) &&
 606                     (sys_addr < ((1ULL << 32) + hole_size))) {
 607                         /* use DHAR to translate SysAddr to DramAddr */
 608                         dram_addr = sys_addr - hole_offset;
 609
 610                         edac_dbg(2, "using DHAR to translate SysAddr 0x%lx to DramAddr 0x%lx\n",
 611                                  (unsigned long)sys_addr,
 612                                  (unsigned long)dram_addr);
 613
 614                         return dram_addr;
 615                 }
 616         }
 617
 618         /*
 619          * Translate the SysAddr to a DramAddr as shown near the start of
 620          * section 3.4.4 (p. 70).  Although sys_addr is a 64-bit value, the k8
 621          * only deals with 40-bit values.  Therefore we discard bits 63-40 of
 622          * sys_addr below.  If bit 39 of sys_addr is 1 then the bits we
 623          * discard are all 1s.  Otherwise the bits we discard are all 0s.  See
 624          * section 3.4.2 of AMD publication 24592: AMD x86-64 Architecture
 625          * Programmer's Manual Volume 1 Application Programming.
 626          */
 627         dram_addr = (sys_addr & GENMASK_ULL(39, 0)) - dram_base;
 628
 629         edac_dbg(2, "using DRAM Base register to translate SysAddr 0x%lx to DramAddr 0x%lx\n",
 630                  (unsigned long)sys_addr, (unsigned long)dram_addr);
 631         return dram_addr;
 632 }
 633
 634 /*
 635  * @intlv_en is the value of the IntlvEn field from a DRAM Base register
 636  * (section 3.4.4.1).  Return the number of bits from a SysAddr that are used
 637  * for node interleaving.
 638  */
 639 static int num_node_interleave_bits(unsigned intlv_en)
 640 {
 641         static const int intlv_shift_table[] = { 0, 1, 0, 2, 0, 0, 0, 3 };
 642         int n;
 643
 644         BUG_ON(intlv_en > 7);
 645         n = intlv_shift_table[intlv_en];
 646         return n;
 647 }
 648
 649 /* Translate the DramAddr given by @dram_addr to an InputAddr. */
 650 static u64 dram_addr_to_input_addr(struct mem_ctl_info *mci, u64 dram_addr)
 651 {
 652         struct amd64_pvt *pvt;
 653         int intlv_shift;
 654         u64 input_addr;
 655
 656         pvt = mci->pvt_info;
 657
 658         /*
 659          * See the start of section 3.4.4 (p. 70, BKDG #26094, K8, revA-E)
 660          * concerning translating a DramAddr to an InputAddr.
 661          */
 662         intlv_shift = num_node_interleave_bits(dram_intlv_en(pvt, 0));
 663         input_addr = ((dram_addr >> intlv_shift) & GENMASK_ULL(35, 12)) +
 664                       (dram_addr & 0xfff);
 665
 666         edac_dbg(2, "  Intlv Shift=%d DramAddr=0x%lx maps to InputAddr=0x%lx\n",
 667                  intlv_shift, (unsigned long)dram_addr,
 668                  (unsigned long)input_addr);
 669
 670         return input_addr;
 671 }
 672
 673 /*
 674  * Translate the SysAddr represented by @sys_addr to an InputAddr.  It is
 675  * assumed that @sys_addr maps to the node given by mci.
 676  */
 677 static u64 sys_addr_to_input_addr(struct mem_ctl_info *mci, u64 sys_addr)
 678 {
 679         u64 input_addr;
 680
 681         input_addr =
 682             dram_addr_to_input_addr(mci, sys_addr_to_dram_addr(mci, sys_addr));
 683
 684         edac_dbg(2, "SysAddr 0x%lx translates to InputAddr 0x%lx\n",
 685                  (unsigned long)sys_addr, (unsigned long)input_addr);
 686
 687         return input_addr;
 688 }
 689
 690 /* Map the Error address to a PAGE and PAGE OFFSET. */
 691 static inline void error_address_to_page_and_offset(u64 error_address,
 692                                                     struct err_info *err)
 693 {
 694         err->page = (u32) (error_address >> PAGE_SHIFT);
 695         err->offset = ((u32) error_address) & ~PAGE_MASK;
 696 }
 697
 698 /*
 699  * @sys_addr is an error address (a SysAddr) extracted from the MCA NB Address
 700  * Low (section 3.6.4.5) and MCA NB Address High (section 3.6.4.6) registers
 701  * of a node that detected an ECC memory error.  mci represents the node that
 702  * the error address maps to (possibly different from the node that detected
 703  * the error).  Return the number of the csrow that sys_addr maps to, or -1 on
 704  * error.
 705  */
 706 static int sys_addr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr)
 707 {
 708         int csrow;
 709
 710         csrow = input_addr_to_csrow(mci, sys_addr_to_input_addr(mci, sys_addr));
 711
 712         if (csrow == -1)
 713                 amd64_mc_err(mci, "Failed to translate InputAddr to csrow for "
 714                                   "address 0x%lx\n", (unsigned long)sys_addr);
 715         return csrow;
 716 }
 717
 718 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *, u16);
 719
 720 /*
 721  * Determine if the DIMMs have ECC enabled. ECC is enabled ONLY if all the DIMMs
 722  * are ECC capable.
 723  */
 724 static unsigned long determine_edac_cap(struct amd64_pvt *pvt)
 725 {
 726         unsigned long edac_cap = EDAC_FLAG_NONE;
 727         u8 bit;
 728
 729         if (pvt->umc) {
 730                 u8 i, umc_en_mask = 0, dimm_ecc_en_mask = 0;
 731
 732                 for_each_umc(i) {
 733                         if (!(pvt->umc[i].sdp_ctrl & UMC_SDP_INIT))
 734                                 continue;
 735
 736                         umc_en_mask |= BIT(i);
 737
 738                         /* UMC Configuration bit 12 (DimmEccEn) */
 739                         if (pvt->umc[i].umc_cfg & BIT(12))
 740                                 dimm_ecc_en_mask |= BIT(i);
 741                 }
 742
 743                 if (umc_en_mask == dimm_ecc_en_mask)
 744                         edac_cap = EDAC_FLAG_SECDED;
 745         } else {
 746                 bit = (pvt->fam > 0xf || pvt->ext_model >= K8_REV_F)
 747                         ? 19
 748                         : 17;
 749
 750                 if (pvt->dclr0 & BIT(bit))
 751                         edac_cap = EDAC_FLAG_SECDED;
 752         }
 753
 754         return edac_cap;
 755 }
 756
 757 static void debug_display_dimm_sizes(struct amd64_pvt *, u8);
 758
 759 static void debug_dump_dramcfg_low(struct amd64_pvt *pvt, u32 dclr, int chan)
 760 {
 761         edac_dbg(1, "F2x%d90 (DRAM Cfg Low): 0x%08x\n", chan, dclr);
 762
 763         if (pvt->dram_type == MEM_LRDDR3) {
 764                 u32 dcsm = pvt->csels[chan].csmasks[0];
 765                 /*
 766                  * It's assumed all LRDIMMs in a DCT are going to be of
 767                  * same 'type' until proven otherwise. So, use a cs
 768                  * value of '0' here to get dcsm value.
 769                  */
 770                 edac_dbg(1, " LRDIMM %dx rank multiply\n", (dcsm & 0x3));
 771         }
 772
 773         edac_dbg(1, "All DIMMs support ECC:%s\n",
 774                     (dclr & BIT(19)) ? "yes" : "no");
 775
 776
 777         edac_dbg(1, "  PAR/ERR parity: %s\n",
 778                  (dclr & BIT(8)) ?  "enabled" : "disabled");
 779
 780         if (pvt->fam == 0x10)
 781                 edac_dbg(1, "  DCT 128bit mode width: %s\n",
 782                          (dclr & BIT(11)) ?  "128b" : "64b");
 783
 784         edac_dbg(1, "  x4 logical DIMMs present: L0: %s L1: %s L2: %s L3: %s\n",
 785                  (dclr & BIT(12)) ?  "yes" : "no",
 786                  (dclr & BIT(13)) ?  "yes" : "no",
 787                  (dclr & BIT(14)) ?  "yes" : "no",
 788                  (dclr & BIT(15)) ?  "yes" : "no");
 789 }
 790
 791 #define CS_EVEN_PRIMARY         BIT(0)
 792 #define CS_ODD_PRIMARY          BIT(1)
 793
 794 #define CS_EVEN                 CS_EVEN_PRIMARY
 795 #define CS_ODD                  CS_ODD_PRIMARY
 796
 797 static int f17_get_cs_mode(int dimm, u8 ctrl, struct amd64_pvt *pvt)
 798 {
 799         int cs_mode = 0;
 800
 801         if (csrow_enabled(2 * dimm, ctrl, pvt))
 802                 cs_mode |= CS_EVEN_PRIMARY;
 803
 804         if (csrow_enabled(2 * dimm + 1, ctrl, pvt))
 805                 cs_mode |= CS_ODD_PRIMARY;
 806
 807         return cs_mode;
 808 }
 809
 810 static void debug_display_dimm_sizes_df(struct amd64_pvt *pvt, u8 ctrl)
 811 {
 812         int dimm, size0, size1, cs0, cs1, cs_mode;
 813
 814         edac_printk(KERN_DEBUG, EDAC_MC, "UMC%d chip selects:\n", ctrl);
 815
 816         for (dimm = 0; dimm < 2; dimm++) {
 817                 cs0 = dimm * 2;
 818                 cs1 = dimm * 2 + 1;
 819
 820                 cs_mode = f17_get_cs_mode(dimm, ctrl, pvt);
 821
 822                 size0 = pvt->ops->dbam_to_cs(pvt, ctrl, cs_mode, cs0);
 823                 size1 = pvt->ops->dbam_to_cs(pvt, ctrl, cs_mode, cs1);
 824
 825                 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
 826                                 cs0,    size0,
 827                                 cs1,    size1);
 828         }
 829 }
 830
 831 static void __dump_misc_regs_df(struct amd64_pvt *pvt)
 832 {
 833         struct amd64_umc *umc;
 834         u32 i, tmp, umc_base;
 835
 836         for_each_umc(i) {
 837                 umc_base = get_umc_base(i);
 838                 umc = &pvt->umc[i];
 839
 840                 edac_dbg(1, "UMC%d DIMM cfg: 0x%x\n", i, umc->dimm_cfg);
 841                 edac_dbg(1, "UMC%d UMC cfg: 0x%x\n", i, umc->umc_cfg);
 842                 edac_dbg(1, "UMC%d SDP ctrl: 0x%x\n", i, umc->sdp_ctrl);
 843                 edac_dbg(1, "UMC%d ECC ctrl: 0x%x\n", i, umc->ecc_ctrl);
 844
 845                 amd_smn_read(pvt->mc_node_id, umc_base + UMCCH_ECC_BAD_SYMBOL, &tmp);
 846                 edac_dbg(1, "UMC%d ECC bad symbol: 0x%x\n", i, tmp);
 847
 848                 amd_smn_read(pvt->mc_node_id, umc_base + UMCCH_UMC_CAP, &tmp);
 849                 edac_dbg(1, "UMC%d UMC cap: 0x%x\n", i, tmp);
 850                 edac_dbg(1, "UMC%d UMC cap high: 0x%x\n", i, umc->umc_cap_hi);
 851
 852                 edac_dbg(1, "UMC%d ECC capable: %s, ChipKill ECC capable: %s\n",
 853                                 i, (umc->umc_cap_hi & BIT(30)) ? "yes" : "no",
 854                                     (umc->umc_cap_hi & BIT(31)) ? "yes" : "no");
 855                 edac_dbg(1, "UMC%d All DIMMs support ECC: %s\n",
 856                                 i, (umc->umc_cfg & BIT(12)) ? "yes" : "no");
 857                 edac_dbg(1, "UMC%d x4 DIMMs present: %s\n",
 858                                 i, (umc->dimm_cfg & BIT(6)) ? "yes" : "no");
 859                 edac_dbg(1, "UMC%d x16 DIMMs present: %s\n",
 860                                 i, (umc->dimm_cfg & BIT(7)) ? "yes" : "no");
 861
 862                 if (pvt->dram_type == MEM_LRDDR4) {
 863                         amd_smn_read(pvt->mc_node_id, umc_base + UMCCH_ADDR_CFG, &tmp);
 864                         edac_dbg(1, "UMC%d LRDIMM %dx rank multiply\n",
 865                                         i, 1 << ((tmp >> 4) & 0x3));
 866                 }
 867
 868                 debug_display_dimm_sizes_df(pvt, i);
 869         }
 870
 871         edac_dbg(1, "F0x104 (DRAM Hole Address): 0x%08x, base: 0x%08x\n",
 872                  pvt->dhar, dhar_base(pvt));
 873 }
 874
 875 /* Display and decode various NB registers for debug purposes. */
 876 static void __dump_misc_regs(struct amd64_pvt *pvt)
 877 {
 878         edac_dbg(1, "F3xE8 (NB Cap): 0x%08x\n", pvt->nbcap);
 879
 880         edac_dbg(1, "  NB two channel DRAM capable: %s\n",
 881                  (pvt->nbcap & NBCAP_DCT_DUAL) ? "yes" : "no");
 882
 883         edac_dbg(1, "  ECC capable: %s, ChipKill ECC capable: %s\n",
 884                  (pvt->nbcap & NBCAP_SECDED) ? "yes" : "no",
 885                  (pvt->nbcap & NBCAP_CHIPKILL) ? "yes" : "no");
 886
 887         debug_dump_dramcfg_low(pvt, pvt->dclr0, 0);
 888
 889         edac_dbg(1, "F3xB0 (Online Spare): 0x%08x\n", pvt->online_spare);
 890
 891         edac_dbg(1, "F1xF0 (DRAM Hole Address): 0x%08x, base: 0x%08x, offset: 0x%08x\n",
 892                  pvt->dhar, dhar_base(pvt),
 893                  (pvt->fam == 0xf) ? k8_dhar_offset(pvt)
 894                                    : f10_dhar_offset(pvt));
 895
 896         debug_display_dimm_sizes(pvt, 0);
 897
 898         /* everything below this point is Fam10h and above */
 899         if (pvt->fam == 0xf)
 900                 return;
 901
 902         debug_display_dimm_sizes(pvt, 1);
 903
 904         /* Only if NOT ganged does dclr1 have valid info */
 905         if (!dct_ganging_enabled(pvt))
 906                 debug_dump_dramcfg_low(pvt, pvt->dclr1, 1);
 907 }
 908
 909 /* Display and decode various NB registers for debug purposes. */
 910 static void dump_misc_regs(struct amd64_pvt *pvt)
 911 {
 912         if (pvt->umc)
 913                 __dump_misc_regs_df(pvt);
 914         else
 915                 __dump_misc_regs(pvt);
 916
 917         edac_dbg(1, "  DramHoleValid: %s\n", dhar_valid(pvt) ? "yes" : "no");
 918
 919         amd64_info("using x%u syndromes.\n", pvt->ecc_sym_sz);
 920 }
 921
 922 /*
 923  * See BKDG, F2x[1,0][5C:40], F2[1,0][6C:60]
 924  */
 925 static void prep_chip_selects(struct amd64_pvt *pvt)
 926 {
 927         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_F) {
 928                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
 929                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 8;
 930         } else if (pvt->fam == 0x15 && pvt->model == 0x30) {
 931                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 4;
 932                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 2;
 933         } else if (pvt->fam >= 0x17) {
 934                 int umc;
 935
 936                 for_each_umc(umc) {
 937                         pvt->csels[umc].b_cnt = 4;
 938                         pvt->csels[umc].m_cnt = 2;
 939                 }
 940
 941         } else {
 942                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
 943                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 4;
 944         }
 945 }
 946
 947 static void read_umc_base_mask(struct amd64_pvt *pvt)
 948 {
 949         u32 umc_base_reg, umc_mask_reg;
 950         u32 base_reg, mask_reg;
 951         u32 *base, *mask;
 952         int cs, umc;
 953
 954         for_each_umc(umc) {
 955                 umc_base_reg = get_umc_base(umc) + UMCCH_BASE_ADDR;
 956
 957                 for_each_chip_select(cs, umc, pvt) {
 958                         base = &pvt->csels[umc].csbases[cs];
 959
 960                         base_reg = umc_base_reg + (cs * 4);
 961
 962                         if (!amd_smn_read(pvt->mc_node_id, base_reg, base))
 963                                 edac_dbg(0, "  DCSB%d[%d]=0x%08x reg: 0x%x\n",
 964                                          umc, cs, *base, base_reg);
 965                 }
 966
 967                 umc_mask_reg = get_umc_base(umc) + UMCCH_ADDR_MASK;
 968
 969                 for_each_chip_select_mask(cs, umc, pvt) {
 970                         mask = &pvt->csels[umc].csmasks[cs];
 971
 972                         mask_reg = umc_mask_reg + (cs * 4);
 973
 974                         if (!amd_smn_read(pvt->mc_node_id, mask_reg, mask))
 975                                 edac_dbg(0, "  DCSM%d[%d]=0x%08x reg: 0x%x\n",
 976                                          umc, cs, *mask, mask_reg);
 977                 }
 978         }
 979 }
 980
 981 /*
 982  * Function 2 Offset F10_DCSB0; read in the DCS Base and DCS Mask registers
 983  */
 984 static void read_dct_base_mask(struct amd64_pvt *pvt)
 985 {
 986         int cs;
 987
 988         prep_chip_selects(pvt);
 989
 990         if (pvt->umc)
 991                 return read_umc_base_mask(pvt);
 992
 993         for_each_chip_select(cs, 0, pvt) {
 994                 int reg0   = DCSB0 + (cs * 4);
 995                 int reg1   = DCSB1 + (cs * 4);
 996                 u32 *base0 = &pvt->csels[0].csbases[cs];
 997                 u32 *base1 = &pvt->csels[1].csbases[cs];
 998
 999                 if (!amd64_read_dct_pci_cfg(pvt, 0, reg0, base0))
1000                         edac_dbg(0, "  DCSB0[%d]=0x%08x reg: F2x%x\n",
1001                                  cs, *base0, reg0);
1002
1003                 if (pvt->fam == 0xf)
1004                         continue;
1005
1006                 if (!amd64_read_dct_pci_cfg(pvt, 1, reg0, base1))
1007                         edac_dbg(0, "  DCSB1[%d]=0x%08x reg: F2x%x\n",
1008                                  cs, *base1, (pvt->fam == 0x10) ? reg1
1009                                                         : reg0);
1010         }
1011
1012         for_each_chip_select_mask(cs, 0, pvt) {
1013                 int reg0   = DCSM0 + (cs * 4);
1014                 int reg1   = DCSM1 + (cs * 4);
1015                 u32 *mask0 = &pvt->csels[0].csmasks[cs];
1016                 u32 *mask1 = &pvt->csels[1].csmasks[cs];
1017
1018                 if (!amd64_read_dct_pci_cfg(pvt, 0, reg0, mask0))
1019                         edac_dbg(0, "    DCSM0[%d]=0x%08x reg: F2x%x\n",
1020                                  cs, *mask0, reg0);
1021
1022                 if (pvt->fam == 0xf)
1023                         continue;
1024
1025                 if (!amd64_read_dct_pci_cfg(pvt, 1, reg0, mask1))
1026                         edac_dbg(0, "    DCSM1[%d]=0x%08x reg: F2x%x\n",
1027                                  cs, *mask1, (pvt->fam == 0x10) ? reg1
1028                                                         : reg0);
1029         }
1030 }
1031
1032 static void determine_memory_type(struct amd64_pvt *pvt)
1033 {
1034         u32 dram_ctrl, dcsm;
1035
1036         switch (pvt->fam) {
1037         case 0xf:
1038                 if (pvt->ext_model >= K8_REV_F)
1039                         goto ddr3;
1040
1041                 pvt->dram_type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
1042                 return;
1043
1044         case 0x10:
1045                 if (pvt->dchr0 & DDR3_MODE)
1046                         goto ddr3;
1047
1048                 pvt->dram_type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
1049                 return;
1050
1051         case 0x15:
1052                 if (pvt->model < 0x60)
1053                         goto ddr3;
1054
1055                 /*
1056                  * Model 0x60h needs special handling:
1057                  *
1058                  * We use a Chip Select value of '0' to obtain dcsm.
1059                  * Theoretically, it is possible to populate LRDIMMs of different
1060                  * 'Rank' value on a DCT. But this is not the common case. So,
1061                  * it's reasonable to assume all DIMMs are going to be of same
1062                  * 'type' until proven otherwise.
1063                  */
1064                 amd64_read_dct_pci_cfg(pvt, 0, DRAM_CONTROL, &dram_ctrl);
1065                 dcsm = pvt->csels[0].csmasks[0];
1066
1067                 if (((dram_ctrl >> 8) & 0x7) == 0x2)
1068                         pvt->dram_type = MEM_DDR4;
1069                 else if (pvt->dclr0 & BIT(16))
1070                         pvt->dram_type = MEM_DDR3;
1071                 else if (dcsm & 0x3)
1072                         pvt->dram_type = MEM_LRDDR3;
1073                 else
1074                         pvt->dram_type = MEM_RDDR3;
1075
1076                 return;
1077
1078         case 0x16:
1079                 goto ddr3;
1080
1081         case 0x17:
1082         case 0x18:
1083                 if ((pvt->umc[0].dimm_cfg | pvt->umc[1].dimm_cfg) & BIT(5))
1084                         pvt->dram_type = MEM_LRDDR4;
1085                 else if ((pvt->umc[0].dimm_cfg | pvt->umc[1].dimm_cfg) & BIT(4))
1086                         pvt->dram_type = MEM_RDDR4;
1087                 else
1088                         pvt->dram_type = MEM_DDR4;
1089                 return;
1090
1091         default:
1092                 WARN(1, KERN_ERR "%s: Family??? 0x%x\n", __func__, pvt->fam);
1093                 pvt->dram_type = MEM_EMPTY;
1094         }
1095         return;
1096
1097 ddr3:
1098         pvt->dram_type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
1099 }
1100
1101 /* Get the number of DCT channels the memory controller is using. */
1102 static int k8_early_channel_count(struct amd64_pvt *pvt)
1103 {
1104         int flag;
1105
1106         if (pvt->ext_model >= K8_REV_F)
1107                 /* RevF (NPT) and later */
1108                 flag = pvt->dclr0 & WIDTH_128;
1109         else
1110                 /* RevE and earlier */
1111                 flag = pvt->dclr0 & REVE_WIDTH_128;
1112
1113         /* not used */
1114         pvt->dclr1 = 0;
1115
1116         return (flag) ? 2 : 1;
1117 }
1118
1119 /* On F10h and later ErrAddr is MC4_ADDR[47:1] */
1120 static u64 get_error_address(struct amd64_pvt *pvt, struct mce *m)
1121 {
1122         u16 mce_nid = amd_get_nb_id(m->extcpu);
1123         struct mem_ctl_info *mci;
1124         u8 start_bit = 1;
1125         u8 end_bit   = 47;
1126         u64 addr;
1127
1128         mci = edac_mc_find(mce_nid);
1129         if (!mci)
1130                 return 0;
1131
1132         pvt = mci->pvt_info;
1133
1134         if (pvt->fam == 0xf) {
1135                 start_bit = 3;
1136                 end_bit   = 39;
1137         }
1138
1139         addr = m->addr & GENMASK_ULL(end_bit, start_bit);
1140
1141         /*
1142          * Erratum 637 workaround
1143          */
1144         if (pvt->fam == 0x15) {
1145                 u64 cc6_base, tmp_addr;
1146                 u32 tmp;
1147                 u8 intlv_en;
1148
1149                 if ((addr & GENMASK_ULL(47, 24)) >> 24 != 0x00fdf7)
1150                         return addr;
1151
1152
1153                 amd64_read_pci_cfg(pvt->F1, DRAM_LOCAL_NODE_LIM, &tmp);
1154                 intlv_en = tmp >> 21 & 0x7;
1155
1156                 /* add [47:27] + 3 trailing bits */
1157                 cc6_base  = (tmp & GENMASK_ULL(20, 0)) << 3;
1158
1159                 /* reverse and add DramIntlvEn */
1160                 cc6_base |= intlv_en ^ 0x7;
1161
1162                 /* pin at [47:24] */
1163                 cc6_base <<= 24;
1164
1165                 if (!intlv_en)
1166                         return cc6_base | (addr & GENMASK_ULL(23, 0));
1167
1168                 amd64_read_pci_cfg(pvt->F1, DRAM_LOCAL_NODE_BASE, &tmp);
1169
1170                                                         /* faster log2 */
1171                 tmp_addr  = (addr & GENMASK_ULL(23, 12)) << __fls(intlv_en + 1);
1172
1173                 /* OR DramIntlvSel into bits [14:12] */
1174                 tmp_addr |= (tmp & GENMASK_ULL(23, 21)) >> 9;
1175
1176                 /* add remaining [11:0] bits from original MC4_ADDR */
1177                 tmp_addr |= addr & GENMASK_ULL(11, 0);
1178
1179                 return cc6_base | tmp_addr;
1180         }
1181
1182         return addr;
1183 }
1184
1185 static struct pci_dev *pci_get_related_function(unsigned int vendor,
1186                                                 unsigned int device,
1187                                                 struct pci_dev *related)
1188 {
1189         struct pci_dev *dev = NULL;
1190
1191         while ((dev = pci_get_device(vendor, device, dev))) {
1192                 if (pci_domain_nr(dev->bus) == pci_domain_nr(related->bus) &&
1193                     (dev->bus->number == related->bus->number) &&
1194                     (PCI_SLOT(dev->devfn) == PCI_SLOT(related->devfn)))
1195                         break;
1196         }
1197
1198         return dev;
1199 }
1200
1201 static void read_dram_base_limit_regs(struct amd64_pvt *pvt, unsigned range)
1202 {
1203         struct amd_northbridge *nb;
1204         struct pci_dev *f1 = NULL;
1205         unsigned int pci_func;
1206         int off = range << 3;
1207         u32 llim;
1208
1209         amd64_read_pci_cfg(pvt->F1, DRAM_BASE_LO + off,  &pvt->ranges[range].base.lo);
1210         amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_LO + off, &pvt->ranges[range].lim.lo);
1211
1212         if (pvt->fam == 0xf)
1213                 return;
1214
1215         if (!dram_rw(pvt, range))
1216                 return;
1217
1218         amd64_read_pci_cfg(pvt->F1, DRAM_BASE_HI + off,  &pvt->ranges[range].base.hi);
1219         amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_HI + off, &pvt->ranges[range].lim.hi);
1220
1221         /* F15h: factor in CC6 save area by reading dst node's limit reg */
1222         if (pvt->fam != 0x15)
1223                 return;
1224
1225         nb = node_to_amd_nb(dram_dst_node(pvt, range));
1226         if (WARN_ON(!nb))
1227                 return;
1228
1229         if (pvt->model == 0x60)
1230                 pci_func = PCI_DEVICE_ID_AMD_15H_M60H_NB_F1;
1231         else if (pvt->model == 0x30)
1232                 pci_func = PCI_DEVICE_ID_AMD_15H_M30H_NB_F1;
1233         else
1234                 pci_func = PCI_DEVICE_ID_AMD_15H_NB_F1;
1235
1236         f1 = pci_get_related_function(nb->misc->vendor, pci_func, nb->misc);
1237         if (WARN_ON(!f1))
1238                 return;
1239
1240         amd64_read_pci_cfg(f1, DRAM_LOCAL_NODE_LIM, &llim);
1241
1242         pvt->ranges[range].lim.lo &= GENMASK_ULL(15, 0);
1243
1244                                     /* {[39:27],111b} */
1245         pvt->ranges[range].lim.lo |= ((llim & 0x1fff) << 3 | 0x7) << 16;
1246
1247         pvt->ranges[range].lim.hi &= GENMASK_ULL(7, 0);
1248
1249                                     /* [47:40] */
1250         pvt->ranges[range].lim.hi |= llim >> 13;
1251
1252         pci_dev_put(f1);
1253 }
1254
1255 static void k8_map_sysaddr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr,
1256                                     struct err_info *err)
1257 {
1258         struct amd64_pvt *pvt = mci->pvt_info;
1259
1260         error_address_to_page_and_offset(sys_addr, err);
1261
1262         /*
1263          * Find out which node the error address belongs to. This may be
1264          * different from the node that detected the error.
1265          */
1266         err->src_mci = find_mc_by_sys_addr(mci, sys_addr);
1267         if (!err->src_mci) {
1268                 amd64_mc_err(mci, "failed to map error addr 0x%lx to a node\n",
1269                              (unsigned long)sys_addr);
1270                 err->err_code = ERR_NODE;
1271                 return;
1272         }
1273
1274         /* Now map the sys_addr to a CSROW */
1275         err->csrow = sys_addr_to_csrow(err->src_mci, sys_addr);
1276         if (err->csrow < 0) {
1277                 err->err_code = ERR_CSROW;
1278                 return;
1279         }
1280
1281         /* CHIPKILL enabled */
1282         if (pvt->nbcfg & NBCFG_CHIPKILL) {
1283                 err->channel = get_channel_from_ecc_syndrome(mci, err->syndrome);
1284                 if (err->channel < 0) {
1285                         /*
1286                          * Syndrome didn't map, so we don't know which of the
1287                          * 2 DIMMs is in error. So we need to ID 'both' of them
1288                          * as suspect.
1289                          */
1290                         amd64_mc_warn(err->src_mci, "unknown syndrome 0x%04x - "
1291                                       "possible error reporting race\n",
1292                                       err->syndrome);
1293                         err->err_code = ERR_CHANNEL;
1294                         return;
1295                 }
1296         } else {
1297                 /*
1298                  * non-chipkill ecc mode
1299                  *
1300                  * The k8 documentation is unclear about how to determine the
1301                  * channel number when using non-chipkill memory.  This method
1302                  * was obtained from email communication with someone at AMD.
1303                  * (Wish the email was placed in this comment - norsk)
1304                  */
1305                 err->channel = ((sys_addr & BIT(3)) != 0);
1306         }
1307 }
1308
1309 static int ddr2_cs_size(unsigned i, bool dct_width)
1310 {
1311         unsigned shift = 0;
1312
1313         if (i <= 2)
1314                 shift = i;
1315         else if (!(i & 0x1))
1316                 shift = i >> 1;
1317         else
1318                 shift = (i + 1) >> 1;
1319
1320         return 128 << (shift + !!dct_width);
1321 }
1322
1323 static int k8_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1324                                   unsigned cs_mode, int cs_mask_nr)
1325 {
1326         u32 dclr = dct ? pvt->dclr1 : pvt->dclr0;
1327
1328         if (pvt->ext_model >= K8_REV_F) {
1329                 WARN_ON(cs_mode > 11);
1330                 return ddr2_cs_size(cs_mode, dclr & WIDTH_128);
1331         }
1332         else if (pvt->ext_model >= K8_REV_D) {
1333                 unsigned diff;
1334                 WARN_ON(cs_mode > 10);
1335
1336                 /*
1337                  * the below calculation, besides trying to win an obfuscated C
1338                  * contest, maps cs_mode values to DIMM chip select sizes. The
1339                  * mappings are:
1340                  *
1341                  * cs_mode      CS size (mb)
1342                  * =======      ============
1343                  * 0            32
1344                  * 1            64
1345                  * 2            128
1346                  * 3            128
1347                  * 4            256
1348                  * 5            512
1349                  * 6            256
1350                  * 7            512
1351                  * 8            1024
1352                  * 9            1024
1353                  * 10           2048
1354                  *
1355                  * Basically, it calculates a value with which to shift the
1356                  * smallest CS size of 32MB.
1357                  *
1358                  * ddr[23]_cs_size have a similar purpose.
1359                  */
1360                 diff = cs_mode/3 + (unsigned)(cs_mode > 5);
1361
1362                 return 32 << (cs_mode - diff);
1363         }
1364         else {
1365                 WARN_ON(cs_mode > 6);
1366                 return 32 << cs_mode;
1367         }
1368 }
1369
1370 /*
1371  * Get the number of DCT channels in use.
1372  *
1373  * Return:
1374  *      number of Memory Channels in operation
1375  * Pass back:
1376  *      contents of the DCL0_LOW register
1377  */
1378 static int f1x_early_channel_count(struct amd64_pvt *pvt)
1379 {
1380         int i, j, channels = 0;
1381
1382         /* On F10h, if we are in 128 bit mode, then we are using 2 channels */
1383         if (pvt->fam == 0x10 && (pvt->dclr0 & WIDTH_128))
1384                 return 2;
1385
1386         /*
1387          * Need to check if in unganged mode: In such, there are 2 channels,
1388          * but they are not in 128 bit mode and thus the above 'dclr0' status
1389          * bit will be OFF.
1390          *
1391          * Need to check DCT0[0] and DCT1[0] to see if only one of them has
1392          * their CSEnable bit on. If so, then SINGLE DIMM case.
1393          */
1394         edac_dbg(0, "Data width is not 128 bits - need more decoding\n");
1395
1396         /*
1397          * Check DRAM Bank Address Mapping values for each DIMM to see if there
1398          * is more than just one DIMM present in unganged mode. Need to check
1399          * both controllers since DIMMs can be placed in either one.
1400          */
1401         for (i = 0; i < 2; i++) {
1402                 u32 dbam = (i ? pvt->dbam1 : pvt->dbam0);
1403
1404                 for (j = 0; j < 4; j++) {
1405                         if (DBAM_DIMM(j, dbam) > 0) {
1406                                 channels++;
1407                                 break;
1408                         }
1409                 }
1410         }
1411
1412         if (channels > 2)
1413                 channels = 2;
1414
1415         amd64_info("MCT channel count: %d\n", channels);
1416
1417         return channels;
1418 }
1419
1420 static int f17_early_channel_count(struct amd64_pvt *pvt)
1421 {
1422         int i, channels = 0;
1423
1424         /* SDP Control bit 31 (SdpInit) is clear for unused UMC channels */
1425         for_each_umc(i)
1426                 channels += !!(pvt->umc[i].sdp_ctrl & UMC_SDP_INIT);
1427
1428         amd64_info("MCT channel count: %d\n", channels);
1429
1430         return channels;
1431 }
1432
1433 static int ddr3_cs_size(unsigned i, bool dct_width)
1434 {
1435         unsigned shift = 0;
1436         int cs_size = 0;
1437
1438         if (i == 0 || i == 3 || i == 4)
1439                 cs_size = -1;
1440         else if (i <= 2)
1441                 shift = i;
1442         else if (i == 12)
1443                 shift = 7;
1444         else if (!(i & 0x1))
1445                 shift = i >> 1;
1446         else
1447                 shift = (i + 1) >> 1;
1448
1449         if (cs_size != -1)
1450                 cs_size = (128 * (1 << !!dct_width)) << shift;
1451
1452         return cs_size;
1453 }
1454
1455 static int ddr3_lrdimm_cs_size(unsigned i, unsigned rank_multiply)
1456 {
1457         unsigned shift = 0;
1458         int cs_size = 0;
1459
1460         if (i < 4 || i == 6)
1461                 cs_size = -1;
1462         else if (i == 12)
1463                 shift = 7;
1464         else if (!(i & 0x1))
1465                 shift = i >> 1;
1466         else
1467                 shift = (i + 1) >> 1;
1468
1469         if (cs_size != -1)
1470                 cs_size = rank_multiply * (128 << shift);
1471
1472         return cs_size;
1473 }
1474
1475 static int ddr4_cs_size(unsigned i)
1476 {
1477         int cs_size = 0;
1478
1479         if (i == 0)
1480                 cs_size = -1;
1481         else if (i == 1)
1482                 cs_size = 1024;
1483         else
1484                 /* Min cs_size = 1G */
1485                 cs_size = 1024 * (1 << (i >> 1));
1486
1487         return cs_size;
1488 }
1489
1490 static int f10_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1491                                    unsigned cs_mode, int cs_mask_nr)
1492 {
1493         u32 dclr = dct ? pvt->dclr1 : pvt->dclr0;
1494
1495         WARN_ON(cs_mode > 11);
1496
1497         if (pvt->dchr0 & DDR3_MODE || pvt->dchr1 & DDR3_MODE)
1498                 return ddr3_cs_size(cs_mode, dclr & WIDTH_128);
1499         else
1500                 return ddr2_cs_size(cs_mode, dclr & WIDTH_128);
1501 }
1502
1503 /*
1504  * F15h supports only 64bit DCT interfaces
1505  */
1506 static int f15_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1507                                    unsigned cs_mode, int cs_mask_nr)
1508 {
1509         WARN_ON(cs_mode > 12);
1510
1511         return ddr3_cs_size(cs_mode, false);
1512 }
1513
1514 /* F15h M60h supports DDR4 mapping as well.. */
1515 static int f15_m60h_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1516                                         unsigned cs_mode, int cs_mask_nr)
1517 {
1518         int cs_size;
1519         u32 dcsm = pvt->csels[dct].csmasks[cs_mask_nr];
1520
1521         WARN_ON(cs_mode > 12);
1522
1523         if (pvt->dram_type == MEM_DDR4) {
1524                 if (cs_mode > 9)
1525                         return -1;
1526
1527                 cs_size = ddr4_cs_size(cs_mode);
1528         } else if (pvt->dram_type == MEM_LRDDR3) {
1529                 unsigned rank_multiply = dcsm & 0xf;
1530
1531                 if (rank_multiply == 3)
1532                         rank_multiply = 4;
1533                 cs_size = ddr3_lrdimm_cs_size(cs_mode, rank_multiply);
1534         } else {
1535                 /* Minimum cs size is 512mb for F15hM60h*/
1536                 if (cs_mode == 0x1)
1537                         return -1;
1538
1539                 cs_size = ddr3_cs_size(cs_mode, false);
1540         }
1541
1542         return cs_size;
1543 }
1544
1545 /*
1546  * F16h and F15h model 30h have only limited cs_modes.
1547  */
1548 static int f16_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1549                                 unsigned cs_mode, int cs_mask_nr)
1550 {
1551         WARN_ON(cs_mode > 12);
1552
1553         if (cs_mode == 6 || cs_mode == 8 ||
1554             cs_mode == 9 || cs_mode == 12)
1555                 return -1;
1556         else
1557                 return ddr3_cs_size(cs_mode, false);
1558 }
1559
1560 static int f17_addr_mask_to_cs_size(struct amd64_pvt *pvt, u8 umc,
1561                                     unsigned int cs_mode, int csrow_nr)
1562 {
1563         u32 addr_mask_orig, addr_mask_deinterleaved;
1564         u32 msb, weight, num_zero_bits;
1565         int dimm, size = 0;
1566
1567         /* No Chip Selects are enabled. */
1568         if (!cs_mode)
1569                 return size;
1570
1571         /* Requested size of an even CS but none are enabled. */
1572         if (!(cs_mode & CS_EVEN) && !(csrow_nr & 1))
1573                 return size;
1574
1575         /* Requested size of an odd CS but none are enabled. */
1576         if (!(cs_mode & CS_ODD) && (csrow_nr & 1))
1577                 return size;
1578
1579         /*
1580          * There is one mask per DIMM, and two Chip Selects per DIMM.
1581          *      CS0 and CS1 -> DIMM0
1582          *      CS2 and CS3 -> DIMM1
1583          */
1584         dimm = csrow_nr >> 1;
1585
1586         addr_mask_orig = pvt->csels[umc].csmasks[dimm];
1587
1588         /*
1589          * The number of zero bits in the mask is equal to the number of bits
1590          * in a full mask minus the number of bits in the current mask.
1591          *
1592          * The MSB is the number of bits in the full mask because BIT[0] is
1593          * always 0.
1594          */
1595         msb = fls(addr_mask_orig) - 1;
1596         weight = hweight_long(addr_mask_orig);
1597         num_zero_bits = msb - weight;
1598
1599         /* Take the number of zero bits off from the top of the mask. */
1600         addr_mask_deinterleaved = GENMASK_ULL(msb - num_zero_bits, 1);
1601
1602         edac_dbg(1, "CS%d DIMM%d AddrMasks:\n", csrow_nr, dimm);
1603         edac_dbg(1, "  Original AddrMask: 0x%x\n", addr_mask_orig);
1604         edac_dbg(1, "  Deinterleaved AddrMask: 0x%x\n", addr_mask_deinterleaved);
1605
1606         /* Register [31:1] = Address [39:9]. Size is in kBs here. */
1607         size = (addr_mask_deinterleaved >> 2) + 1;
1608
1609         /* Return size in MBs. */
1610         return size >> 10;
1611 }
1612
1613 static void read_dram_ctl_register(struct amd64_pvt *pvt)
1614 {
1615
1616         if (pvt->fam == 0xf)
1617                 return;
1618
1619         if (!amd64_read_pci_cfg(pvt->F2, DCT_SEL_LO, &pvt->dct_sel_lo)) {
1620                 edac_dbg(0, "F2x110 (DCTSelLow): 0x%08x, High range addrs at: 0x%x\n",
1621                          pvt->dct_sel_lo, dct_sel_baseaddr(pvt));
1622
1623                 edac_dbg(0, "  DCTs operate in %s mode\n",
1624                          (dct_ganging_enabled(pvt) ? "ganged" : "unganged"));
1625
1626                 if (!dct_ganging_enabled(pvt))
1627                         edac_dbg(0, "  Address range split per DCT: %s\n",
1628                                  (dct_high_range_enabled(pvt) ? "yes" : "no"));
1629
1630                 edac_dbg(0, "  data interleave for ECC: %s, DRAM cleared since last warm reset: %s\n",
1631                          (dct_data_intlv_enabled(pvt) ? "enabled" : "disabled"),
1632                          (dct_memory_cleared(pvt) ? "yes" : "no"));
1633
1634                 edac_dbg(0, "  channel interleave: %s, "
1635                          "interleave bits selector: 0x%x\n",
1636                          (dct_interleave_enabled(pvt) ? "enabled" : "disabled"),
1637                          dct_sel_interleave_addr(pvt));
1638         }
1639
1640         amd64_read_pci_cfg(pvt->F2, DCT_SEL_HI, &pvt->dct_sel_hi);
1641 }
1642
1643 /*
1644  * Determine channel (DCT) based on the interleaving mode (see F15h M30h BKDG,
1645  * 2.10.12 Memory Interleaving Modes).
1646  */
1647 static u8 f15_m30h_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
1648                                      u8 intlv_en, int num_dcts_intlv,
1649                                      u32 dct_sel)
1650 {
1651         u8 channel = 0;
1652         u8 select;
1653
1654         if (!(intlv_en))
1655                 return (u8)(dct_sel);
1656
1657         if (num_dcts_intlv == 2) {
1658                 select = (sys_addr >> 8) & 0x3;
1659                 channel = select ? 0x3 : 0;
1660         } else if (num_dcts_intlv == 4) {
1661                 u8 intlv_addr = dct_sel_interleave_addr(pvt);
1662                 switch (intlv_addr) {
1663                 case 0x4:
1664                         channel = (sys_addr >> 8) & 0x3;
1665                         break;
1666                 case 0x5:
1667                         channel = (sys_addr >> 9) & 0x3;
1668                         break;
1669                 }
1670         }
1671         return channel;
1672 }
1673
1674 /*
1675  * Determine channel (DCT) based on the interleaving mode: F10h BKDG, 2.8.9 Memory
1676  * Interleaving Modes.
1677  */
1678 static u8 f1x_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
1679                                 bool hi_range_sel, u8 intlv_en)
1680 {
1681         u8 dct_sel_high = (pvt->dct_sel_lo >> 1) & 1;
1682
1683         if (dct_ganging_enabled(pvt))
1684                 return 0;
1685
1686         if (hi_range_sel)
1687                 return dct_sel_high;
1688
1689         /*
1690          * see F2x110[DctSelIntLvAddr] - channel interleave mode
1691          */
1692         if (dct_interleave_enabled(pvt)) {
1693                 u8 intlv_addr = dct_sel_interleave_addr(pvt);
1694
1695                 /* return DCT select function: 0=DCT0, 1=DCT1 */
1696                 if (!intlv_addr)
1697                         return sys_addr >> 6 & 1;
1698
1699                 if (intlv_addr & 0x2) {
1700                         u8 shift = intlv_addr & 0x1 ? 9 : 6;
1701                         u32 temp = hweight_long((u32) ((sys_addr >> 16) & 0x1F)) & 1;
1702
1703                         return ((sys_addr >> shift) & 1) ^ temp;
1704                 }
1705
1706                 if (intlv_addr & 0x4) {
1707                         u8 shift = intlv_addr & 0x1 ? 9 : 8;
1708
1709                         return (sys_addr >> shift) & 1;
1710                 }
1711
1712                 return (sys_addr >> (12 + hweight8(intlv_en))) & 1;
1713         }
1714
1715         if (dct_high_range_enabled(pvt))
1716                 return ~dct_sel_high & 1;
1717
1718         return 0;
1719 }
1720
1721 /* Convert the sys_addr to the normalized DCT address */
1722 static u64 f1x_get_norm_dct_addr(struct amd64_pvt *pvt, u8 range,
1723                                  u64 sys_addr, bool hi_rng,
1724                                  u32 dct_sel_base_addr)
1725 {
1726         u64 chan_off;
1727         u64 dram_base           = get_dram_base(pvt, range);
1728         u64 hole_off            = f10_dhar_offset(pvt);
1729         u64 dct_sel_base_off    = (u64)(pvt->dct_sel_hi & 0xFFFFFC00) << 16;
1730
1731         if (hi_rng) {
1732                 /*
1733                  * if
1734                  * base address of high range is below 4Gb
1735                  * (bits [47:27] at [31:11])
1736                  * DRAM address space on this DCT is hoisted above 4Gb  &&
1737                  * sys_addr > 4Gb
1738                  *
1739                  *      remove hole offset from sys_addr
1740                  * else
1741                  *      remove high range offset from sys_addr
1742                  */
1743                 if ((!(dct_sel_base_addr >> 16) ||
1744                      dct_sel_base_addr < dhar_base(pvt)) &&
1745                     dhar_valid(pvt) &&
1746                     (sys_addr >= BIT_64(32)))
1747                         chan_off = hole_off;
1748                 else
1749                         chan_off = dct_sel_base_off;
1750         } else {
1751                 /*
1752                  * if
1753                  * we have a valid hole         &&
1754                  * sys_addr > 4Gb
1755                  *
1756                  *      remove hole
1757                  * else
1758                  *      remove dram base to normalize to DCT address
1759                  */
1760                 if (dhar_valid(pvt) && (sys_addr >= BIT_64(32)))
1761                         chan_off = hole_off;
1762                 else
1763                         chan_off = dram_base;
1764         }
1765
1766         return (sys_addr & GENMASK_ULL(47,6)) - (chan_off & GENMASK_ULL(47,23));
1767 }
1768
1769 /*
1770  * checks if the csrow passed in is marked as SPARED, if so returns the new
1771  * spare row
1772  */
1773 static int f10_process_possible_spare(struct amd64_pvt *pvt, u8 dct, int csrow)
1774 {
1775         int tmp_cs;
1776
1777         if (online_spare_swap_done(pvt, dct) &&
1778             csrow == online_spare_bad_dramcs(pvt, dct)) {
1779
1780                 for_each_chip_select(tmp_cs, dct, pvt) {
1781                         if (chip_select_base(tmp_cs, dct, pvt) & 0x2) {
1782                                 csrow = tmp_cs;
1783                                 break;
1784                         }
1785                 }
1786         }
1787         return csrow;
1788 }
1789
1790 /*
1791  * Iterate over the DRAM DCT "base" and "mask" registers looking for a
1792  * SystemAddr match on the specified 'ChannelSelect' and 'NodeID'
1793  *
1794  * Return:
1795  *      -EINVAL:  NOT FOUND
1796  *      0..csrow = Chip-Select Row
1797  */
1798 static int f1x_lookup_addr_in_dct(u64 in_addr, u8 nid, u8 dct)
1799 {
1800         struct mem_ctl_info *mci;
1801         struct amd64_pvt *pvt;
1802         u64 cs_base, cs_mask;
1803         int cs_found = -EINVAL;
1804         int csrow;
1805
1806         mci = edac_mc_find(nid);
1807         if (!mci)
1808                 return cs_found;
1809
1810         pvt = mci->pvt_info;
1811
1812         edac_dbg(1, "input addr: 0x%llx, DCT: %d\n", in_addr, dct);
1813
1814         for_each_chip_select(csrow, dct, pvt) {
1815                 if (!csrow_enabled(csrow, dct, pvt))
1816                         continue;
1817
1818                 get_cs_base_and_mask(pvt, csrow, dct, &cs_base, &cs_mask);
1819
1820                 edac_dbg(1, "    CSROW=%d CSBase=0x%llx CSMask=0x%llx\n",
1821                          csrow, cs_base, cs_mask);
1822
1823                 cs_mask = ~cs_mask;
1824
1825                 edac_dbg(1, "    (InputAddr & ~CSMask)=0x%llx (CSBase & ~CSMask)=0x%llx\n",
1826                          (in_addr & cs_mask), (cs_base & cs_mask));
1827
1828                 if ((in_addr & cs_mask) == (cs_base & cs_mask)) {
1829                         if (pvt->fam == 0x15 && pvt->model >= 0x30) {
1830                                 cs_found =  csrow;
1831                                 break;
1832                         }
1833                         cs_found = f10_process_possible_spare(pvt, dct, csrow);
1834
1835                         edac_dbg(1, " MATCH csrow=%d\n", cs_found);
1836                         break;
1837                 }
1838         }
1839         return cs_found;
1840 }
1841
1842 /*
1843  * See F2x10C. Non-interleaved graphics framebuffer memory under the 16G is
1844  * swapped with a region located at the bottom of memory so that the GPU can use
1845  * the interleaved region and thus two channels.
1846  */
1847 static u64 f1x_swap_interleaved_region(struct amd64_pvt *pvt, u64 sys_addr)
1848 {
1849         u32 swap_reg, swap_base, swap_limit, rgn_size, tmp_addr;
1850
1851         if (pvt->fam == 0x10) {
1852                 /* only revC3 and revE have that feature */
1853                 if (pvt->model < 4 || (pvt->model < 0xa && pvt->stepping < 3))
1854                         return sys_addr;
1855         }
1856
1857         amd64_read_pci_cfg(pvt->F2, SWAP_INTLV_REG, &swap_reg);
1858
1859         if (!(swap_reg & 0x1))
1860                 return sys_addr;
1861
1862         swap_base       = (swap_reg >> 3) & 0x7f;
1863         swap_limit      = (swap_reg >> 11) & 0x7f;
1864         rgn_size        = (swap_reg >> 20) & 0x7f;
1865         tmp_addr        = sys_addr >> 27;
1866
1867         if (!(sys_addr >> 34) &&
1868             (((tmp_addr >= swap_base) &&
1869              (tmp_addr <= swap_limit)) ||
1870              (tmp_addr < rgn_size)))
1871                 return sys_addr ^ (u64)swap_base << 27;
1872
1873         return sys_addr;
1874 }
1875
1876 /* For a given @dram_range, check if @sys_addr falls within it. */
1877 static int f1x_match_to_this_node(struct amd64_pvt *pvt, unsigned range,
1878                                   u64 sys_addr, int *chan_sel)
1879 {
1880         int cs_found = -EINVAL;
1881         u64 chan_addr;
1882         u32 dct_sel_base;
1883         u8 channel;
1884         bool high_range = false;
1885
1886         u8 node_id    = dram_dst_node(pvt, range);
1887         u8 intlv_en   = dram_intlv_en(pvt, range);
1888         u32 intlv_sel = dram_intlv_sel(pvt, range);
1889
1890         edac_dbg(1, "(range %d) SystemAddr= 0x%llx Limit=0x%llx\n",
1891                  range, sys_addr, get_dram_limit(pvt, range));
1892
1893         if (dhar_valid(pvt) &&
1894             dhar_base(pvt) <= sys_addr &&
1895             sys_addr < BIT_64(32)) {
1896                 amd64_warn("Huh? Address is in the MMIO hole: 0x%016llx\n",
1897                             sys_addr);
1898                 return -EINVAL;
1899         }
1900
1901         if (intlv_en && (intlv_sel != ((sys_addr >> 12) & intlv_en)))
1902                 return -EINVAL;
1903
1904         sys_addr = f1x_swap_interleaved_region(pvt, sys_addr);
1905
1906         dct_sel_base = dct_sel_baseaddr(pvt);
1907
1908         /*
1909          * check whether addresses >= DctSelBaseAddr[47:27] are to be used to
1910          * select between DCT0 and DCT1.
1911          */
1912         if (dct_high_range_enabled(pvt) &&
1913            !dct_ganging_enabled(pvt) &&
1914            ((sys_addr >> 27) >= (dct_sel_base >> 11)))
1915                 high_range = true;
1916
1917         channel = f1x_determine_channel(pvt, sys_addr, high_range, intlv_en);
1918
1919         chan_addr = f1x_get_norm_dct_addr(pvt, range, sys_addr,
1920                                           high_range, dct_sel_base);
1921
1922         /* Remove node interleaving, see F1x120 */
1923         if (intlv_en)
1924                 chan_addr = ((chan_addr >> (12 + hweight8(intlv_en))) << 12) |
1925                             (chan_addr & 0xfff);
1926
1927         /* remove channel interleave */
1928         if (dct_interleave_enabled(pvt) &&
1929            !dct_high_range_enabled(pvt) &&
1930            !dct_ganging_enabled(pvt)) {
1931
1932                 if (dct_sel_interleave_addr(pvt) != 1) {
1933                         if (dct_sel_interleave_addr(pvt) == 0x3)
1934                                 /* hash 9 */
1935                                 chan_addr = ((chan_addr >> 10) << 9) |
1936                                              (chan_addr & 0x1ff);
1937                         else
1938                                 /* A[6] or hash 6 */
1939                                 chan_addr = ((chan_addr >> 7) << 6) |
1940                                              (chan_addr & 0x3f);
1941                 } else
1942                         /* A[12] */
1943                         chan_addr = ((chan_addr >> 13) << 12) |
1944                                      (chan_addr & 0xfff);
1945         }
1946
1947         edac_dbg(1, "   Normalized DCT addr: 0x%llx\n", chan_addr);
1948
1949         cs_found = f1x_lookup_addr_in_dct(chan_addr, node_id, channel);
1950
1951         if (cs_found >= 0)
1952                 *chan_sel = channel;
1953
1954         return cs_found;
1955 }
1956
1957 static int f15_m30h_match_to_this_node(struct amd64_pvt *pvt, unsigned range,
1958                                         u64 sys_addr, int *chan_sel)
1959 {
1960         int cs_found = -EINVAL;
1961         int num_dcts_intlv = 0;
1962         u64 chan_addr, chan_offset;
1963         u64 dct_base, dct_limit;
1964         u32 dct_cont_base_reg, dct_cont_limit_reg, tmp;
1965         u8 channel, alias_channel, leg_mmio_hole, dct_sel, dct_offset_en;
1966
1967         u64 dhar_offset         = f10_dhar_offset(pvt);
1968         u8 intlv_addr           = dct_sel_interleave_addr(pvt);
1969         u8 node_id              = dram_dst_node(pvt, range);
1970         u8 intlv_en             = dram_intlv_en(pvt, range);
1971
1972         amd64_read_pci_cfg(pvt->F1, DRAM_CONT_BASE, &dct_cont_base_reg);
1973         amd64_read_pci_cfg(pvt->F1, DRAM_CONT_LIMIT, &dct_cont_limit_reg);
1974
1975         dct_offset_en           = (u8) ((dct_cont_base_reg >> 3) & BIT(0));
1976         dct_sel                 = (u8) ((dct_cont_base_reg >> 4) & 0x7);
1977
1978         edac_dbg(1, "(range %d) SystemAddr= 0x%llx Limit=0x%llx\n",
1979                  range, sys_addr, get_dram_limit(pvt, range));
1980
1981         if (!(get_dram_base(pvt, range)  <= sys_addr) &&
1982             !(get_dram_limit(pvt, range) >= sys_addr))
1983                 return -EINVAL;
1984
1985         if (dhar_valid(pvt) &&
1986             dhar_base(pvt) <= sys_addr &&
1987             sys_addr < BIT_64(32)) {
1988                 amd64_warn("Huh? Address is in the MMIO hole: 0x%016llx\n",
1989                             sys_addr);
1990                 return -EINVAL;
1991         }
1992
1993         /* Verify sys_addr is within DCT Range. */
1994         dct_base = (u64) dct_sel_baseaddr(pvt);
1995         dct_limit = (dct_cont_limit_reg >> 11) & 0x1FFF;
1996
1997         if (!(dct_cont_base_reg & BIT(0)) &&
1998             !(dct_base <= (sys_addr >> 27) &&
1999               dct_limit >= (sys_addr >> 27)))
2000                 return -EINVAL;
2001
2002         /* Verify number of dct's that participate in channel interleaving. */
2003         num_dcts_intlv = (int) hweight8(intlv_en);
2004
2005         if (!(num_dcts_intlv % 2 == 0) || (num_dcts_intlv > 4))
2006                 return -EINVAL;
2007
2008         if (pvt->model >= 0x60)
2009                 channel = f1x_determine_channel(pvt, sys_addr, false, intlv_en);
2010         else
2011                 channel = f15_m30h_determine_channel(pvt, sys_addr, intlv_en,
2012                                                      num_dcts_intlv, dct_sel);
2013
2014         /* Verify we stay within the MAX number of channels allowed */
2015         if (channel > 3)
2016                 return -EINVAL;
2017
2018         leg_mmio_hole = (u8) (dct_cont_base_reg >> 1 & BIT(0));
2019
2020         /* Get normalized DCT addr */
2021         if (leg_mmio_hole && (sys_addr >= BIT_64(32)))
2022                 chan_offset = dhar_offset;
2023         else
2024                 chan_offset = dct_base << 27;
2025
2026         chan_addr = sys_addr - chan_offset;
2027
2028         /* remove channel interleave */
2029         if (num_dcts_intlv == 2) {
2030                 if (intlv_addr == 0x4)
2031                         chan_addr = ((chan_addr >> 9) << 8) |
2032                                                 (chan_addr & 0xff);
2033                 else if (intlv_addr == 0x5)
2034                         chan_addr = ((chan_addr >> 10) << 9) |
2035                                                 (chan_addr & 0x1ff);
2036                 else
2037                         return -EINVAL;
2038
2039         } else if (num_dcts_intlv == 4) {
2040                 if (intlv_addr == 0x4)
2041                         chan_addr = ((chan_addr >> 10) << 8) |
2042                                                         (chan_addr & 0xff);
2043                 else if (intlv_addr == 0x5)
2044                         chan_addr = ((chan_addr >> 11) << 9) |
2045                                                         (chan_addr & 0x1ff);
2046                 else
2047                         return -EINVAL;
2048         }
2049
2050         if (dct_offset_en) {
2051                 amd64_read_pci_cfg(pvt->F1,
2052                                    DRAM_CONT_HIGH_OFF + (int) channel * 4,
2053                                    &tmp);
2054                 chan_addr +=  (u64) ((tmp >> 11) & 0xfff) << 27;
2055         }
2056
2057         f15h_select_dct(pvt, channel);
2058
2059         edac_dbg(1, "   Normalized DCT addr: 0x%llx\n", chan_addr);
2060
2061         /*
2062          * Find Chip select:
2063          * if channel = 3, then alias it to 1. This is because, in F15 M30h,
2064          * there is support for 4 DCT's, but only 2 are currently functional.
2065          * They are DCT0 and DCT3. But we have read all registers of DCT3 into
2066          * pvt->csels[1]. So we need to use '1' here to get correct info.
2067          * Refer F15 M30h BKDG Section 2.10 and 2.10.3 for clarifications.
2068          */
2069         alias_channel =  (channel == 3) ? 1 : channel;
2070
2071         cs_found = f1x_lookup_addr_in_dct(chan_addr, node_id, alias_channel);
2072
2073         if (cs_found >= 0)
2074                 *chan_sel = alias_channel;
2075
2076         return cs_found;
2077 }
2078
2079 static int f1x_translate_sysaddr_to_cs(struct amd64_pvt *pvt,
2080                                         u64 sys_addr,
2081                                         int *chan_sel)
2082 {
2083         int cs_found = -EINVAL;
2084         unsigned range;
2085
2086         for (range = 0; range < DRAM_RANGES; range++) {
2087                 if (!dram_rw(pvt, range))
2088                         continue;
2089
2090                 if (pvt->fam == 0x15 && pvt->model >= 0x30)
2091                         cs_found = f15_m30h_match_to_this_node(pvt, range,
2092                                                                sys_addr,
2093                                                                chan_sel);
2094
2095                 else if ((get_dram_base(pvt, range)  <= sys_addr) &&
2096                          (get_dram_limit(pvt, range) >= sys_addr)) {
2097                         cs_found = f1x_match_to_this_node(pvt, range,
2098                                                           sys_addr, chan_sel);
2099                         if (cs_found >= 0)
2100                                 break;
2101                 }
2102         }
2103         return cs_found;
2104 }
2105
2106 /*
2107  * For reference see "2.8.5 Routing DRAM Requests" in F10 BKDG. This code maps
2108  * a @sys_addr to NodeID, DCT (channel) and chip select (CSROW).
2109  *
2110  * The @sys_addr is usually an error address received from the hardware
2111  * (MCX_ADDR).
2112  */
2113 static void f1x_map_sysaddr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr,
2114                                      struct err_info *err)
2115 {
2116         struct amd64_pvt *pvt = mci->pvt_info;
2117
2118         error_address_to_page_and_offset(sys_addr, err);
2119
2120         err->csrow = f1x_translate_sysaddr_to_cs(pvt, sys_addr, &err->channel);
2121         if (err->csrow < 0) {
2122                 err->err_code = ERR_CSROW;
2123                 return;
2124         }
2125
2126         /*
2127          * We need the syndromes for channel detection only when we're
2128          * ganged. Otherwise @chan should already contain the channel at
2129          * this point.
2130          */
2131         if (dct_ganging_enabled(pvt))
2132                 err->channel = get_channel_from_ecc_syndrome(mci, err->syndrome);
2133 }
2134
2135 /*
2136  * debug routine to display the memory sizes of all logical DIMMs and its
2137  * CSROWs
2138  */
2139 static void debug_display_dimm_sizes(struct amd64_pvt *pvt, u8 ctrl)
2140 {
2141         int dimm, size0, size1;
2142         u32 *dcsb = ctrl ? pvt->csels[1].csbases : pvt->csels[0].csbases;
2143         u32 dbam  = ctrl ? pvt->dbam1 : pvt->dbam0;
2144
2145         if (pvt->fam == 0xf) {
2146                 /* K8 families < revF not supported yet */
2147                if (pvt->ext_model < K8_REV_F)
2148                         return;
2149                else
2150                        WARN_ON(ctrl != 0);
2151         }
2152
2153         if (pvt->fam == 0x10) {
2154                 dbam = (ctrl && !dct_ganging_enabled(pvt)) ? pvt->dbam1
2155                                                            : pvt->dbam0;
2156                 dcsb = (ctrl && !dct_ganging_enabled(pvt)) ?
2157                                  pvt->csels[1].csbases :
2158                                  pvt->csels[0].csbases;
2159         } else if (ctrl) {
2160                 dbam = pvt->dbam0;
2161                 dcsb = pvt->csels[1].csbases;
2162         }
2163         edac_dbg(1, "F2x%d80 (DRAM Bank Address Mapping): 0x%08x\n",
2164                  ctrl, dbam);
2165
2166         edac_printk(KERN_DEBUG, EDAC_MC, "DCT%d chip selects:\n", ctrl);
2167
2168         /* Dump memory sizes for DIMM and its CSROWs */
2169         for (dimm = 0; dimm < 4; dimm++) {
2170
2171                 size0 = 0;
2172                 if (dcsb[dimm*2] & DCSB_CS_ENABLE)
2173                         /*
2174                          * For F15m60h, we need multiplier for LRDIMM cs_size
2175                          * calculation. We pass dimm value to the dbam_to_cs
2176                          * mapper so we can find the multiplier from the
2177                          * corresponding DCSM.
2178                          */
2179                         size0 = pvt->ops->dbam_to_cs(pvt, ctrl,
2180                                                      DBAM_DIMM(dimm, dbam),
2181                                                      dimm);
2182
2183                 size1 = 0;
2184                 if (dcsb[dimm*2 + 1] & DCSB_CS_ENABLE)
2185                         size1 = pvt->ops->dbam_to_cs(pvt, ctrl,
2186                                                      DBAM_DIMM(dimm, dbam),
2187                                                      dimm);
2188
2189                 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
2190                                 dimm * 2,     size0,
2191                                 dimm * 2 + 1, size1);
2192         }
2193 }
2194
2195 static struct amd64_family_type family_types[] = {
2196         [K8_CPUS] = {
2197                 .ctl_name = "K8",
2198                 .f1_id = PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP,
2199                 .f2_id = PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
2200                 .ops = {
2201                         .early_channel_count    = k8_early_channel_count,
2202                         .map_sysaddr_to_csrow   = k8_map_sysaddr_to_csrow,
2203                         .dbam_to_cs             = k8_dbam_to_chip_select,
2204                 }
2205         },
2206         [F10_CPUS] = {
2207                 .ctl_name = "F10h",
2208                 .f1_id = PCI_DEVICE_ID_AMD_10H_NB_MAP,
2209                 .f2_id = PCI_DEVICE_ID_AMD_10H_NB_DRAM,
2210                 .ops = {
2211                         .early_channel_count    = f1x_early_channel_count,
2212                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2213                         .dbam_to_cs             = f10_dbam_to_chip_select,
2214                 }
2215         },
2216         [F15_CPUS] = {
2217                 .ctl_name = "F15h",
2218                 .f1_id = PCI_DEVICE_ID_AMD_15H_NB_F1,
2219                 .f2_id = PCI_DEVICE_ID_AMD_15H_NB_F2,
2220                 .ops = {
2221                         .early_channel_count    = f1x_early_channel_count,
2222                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2223                         .dbam_to_cs             = f15_dbam_to_chip_select,
2224                 }
2225         },
2226         [F15_M30H_CPUS] = {
2227                 .ctl_name = "F15h_M30h",
2228                 .f1_id = PCI_DEVICE_ID_AMD_15H_M30H_NB_F1,
2229                 .f2_id = PCI_DEVICE_ID_AMD_15H_M30H_NB_F2,
2230                 .ops = {
2231                         .early_channel_count    = f1x_early_channel_count,
2232                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2233                         .dbam_to_cs             = f16_dbam_to_chip_select,
2234                 }
2235         },
2236         [F15_M60H_CPUS] = {
2237                 .ctl_name = "F15h_M60h",
2238                 .f1_id = PCI_DEVICE_ID_AMD_15H_M60H_NB_F1,
2239                 .f2_id = PCI_DEVICE_ID_AMD_15H_M60H_NB_F2,
2240                 .ops = {
2241                         .early_channel_count    = f1x_early_channel_count,
2242                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2243                         .dbam_to_cs             = f15_m60h_dbam_to_chip_select,
2244                 }
2245         },
2246         [F16_CPUS] = {
2247                 .ctl_name = "F16h",
2248                 .f1_id = PCI_DEVICE_ID_AMD_16H_NB_F1,
2249                 .f2_id = PCI_DEVICE_ID_AMD_16H_NB_F2,
2250                 .ops = {
2251                         .early_channel_count    = f1x_early_channel_count,
2252                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2253                         .dbam_to_cs             = f16_dbam_to_chip_select,
2254                 }
2255         },
2256         [F16_M30H_CPUS] = {
2257                 .ctl_name = "F16h_M30h",
2258                 .f1_id = PCI_DEVICE_ID_AMD_16H_M30H_NB_F1,
2259                 .f2_id = PCI_DEVICE_ID_AMD_16H_M30H_NB_F2,
2260                 .ops = {
2261                         .early_channel_count    = f1x_early_channel_count,
2262                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2263                         .dbam_to_cs             = f16_dbam_to_chip_select,
2264                 }
2265         },
2266         [F17_CPUS] = {
2267                 .ctl_name = "F17h",
2268                 .f0_id = PCI_DEVICE_ID_AMD_17H_DF_F0,
2269                 .f6_id = PCI_DEVICE_ID_AMD_17H_DF_F6,
2270                 .ops = {
2271                         .early_channel_count    = f17_early_channel_count,
2272                         .dbam_to_cs             = f17_addr_mask_to_cs_size,
2273                 }
2274         },
2275         [F17_M10H_CPUS] = {
2276                 .ctl_name = "F17h_M10h",
2277                 .f0_id = PCI_DEVICE_ID_AMD_17H_M10H_DF_F0,
2278                 .f6_id = PCI_DEVICE_ID_AMD_17H_M10H_DF_F6,
2279                 .ops = {
2280                         .early_channel_count    = f17_early_channel_count,
2281                         .dbam_to_cs             = f17_addr_mask_to_cs_size,
2282                 }
2283         },
2284         [F17_M30H_CPUS] = {
2285                 .ctl_name = "F17h_M30h",
2286                 .f0_id = PCI_DEVICE_ID_AMD_17H_M30H_DF_F0,
2287                 .f6_id = PCI_DEVICE_ID_AMD_17H_M30H_DF_F6,
2288                 .ops = {
2289                         .early_channel_count    = f17_early_channel_count,
2290                         .dbam_to_cs             = f17_addr_mask_to_cs_size,
2291                 }
2292         },
2293 };
2294
2295 /*
2296  * These are tables of eigenvectors (one per line) which can be used for the
2297  * construction of the syndrome tables. The modified syndrome search algorithm
2298  * uses those to find the symbol in error and thus the DIMM.
2299  *
2300  * Algorithm courtesy of Ross LaFetra from AMD.
2301  */
2302 static const u16 x4_vectors[] = {
2303         0x2f57, 0x1afe, 0x66cc, 0xdd88,
2304         0x11eb, 0x3396, 0x7f4c, 0xeac8,
2305         0x0001, 0x0002, 0x0004, 0x0008,
2306         0x1013, 0x3032, 0x4044, 0x8088,
2307         0x106b, 0x30d6, 0x70fc, 0xe0a8,
2308         0x4857, 0xc4fe, 0x13cc, 0x3288,
2309         0x1ac5, 0x2f4a, 0x5394, 0xa1e8,
2310         0x1f39, 0x251e, 0xbd6c, 0x6bd8,
2311         0x15c1, 0x2a42, 0x89ac, 0x4758,
2312         0x2b03, 0x1602, 0x4f0c, 0xca08,
2313         0x1f07, 0x3a0e, 0x6b04, 0xbd08,
2314         0x8ba7, 0x465e, 0x244c, 0x1cc8,
2315         0x2b87, 0x164e, 0x642c, 0xdc18,
2316         0x40b9, 0x80de, 0x1094, 0x20e8,
2317         0x27db, 0x1eb6, 0x9dac, 0x7b58,
2318         0x11c1, 0x2242, 0x84ac, 0x4c58,
2319         0x1be5, 0x2d7a, 0x5e34, 0xa718,
2320         0x4b39, 0x8d1e, 0x14b4, 0x28d8,
2321         0x4c97, 0xc87e, 0x11fc, 0x33a8,
2322         0x8e97, 0x497e, 0x2ffc, 0x1aa8,
2323         0x16b3, 0x3d62, 0x4f34, 0x8518,
2324         0x1e2f, 0x391a, 0x5cac, 0xf858,
2325         0x1d9f, 0x3b7a, 0x572c, 0xfe18,
2326         0x15f5, 0x2a5a, 0x5264, 0xa3b8,
2327         0x1dbb, 0x3b66, 0x715c, 0xe3f8,
2328         0x4397, 0xc27e, 0x17fc, 0x3ea8,
2329         0x1617, 0x3d3e, 0x6464, 0xb8b8,
2330         0x23ff, 0x12aa, 0xab6c, 0x56d8,
2331         0x2dfb, 0x1ba6, 0x913c, 0x7328,
2332         0x185d, 0x2ca6, 0x7914, 0x9e28,
2333         0x171b, 0x3e36, 0x7d7c, 0xebe8,
2334         0x4199, 0x82ee, 0x19f4, 0x2e58,
2335         0x4807, 0xc40e, 0x130c, 0x3208,
2336         0x1905, 0x2e0a, 0x5804, 0xac08,
2337         0x213f, 0x132a, 0xadfc, 0x5ba8,
2338         0x19a9, 0x2efe, 0xb5cc, 0x6f88,
2339 };
2340
2341 static const u16 x8_vectors[] = {
2342         0x0145, 0x028a, 0x2374, 0x43c8, 0xa1f0, 0x0520, 0x0a40, 0x1480,
2343         0x0211, 0x0422, 0x0844, 0x1088, 0x01b0, 0x44e0, 0x23c0, 0xed80,
2344         0x1011, 0x0116, 0x022c, 0x0458, 0x08b0, 0x8c60, 0x2740, 0x4e80,
2345         0x0411, 0x0822, 0x1044, 0x0158, 0x02b0, 0x2360, 0x46c0, 0xab80,
2346         0x0811, 0x1022, 0x012c, 0x0258, 0x04b0, 0x4660, 0x8cc0, 0x2780,
2347         0x2071, 0x40e2, 0xa0c4, 0x0108, 0x0210, 0x0420, 0x0840, 0x1080,
2348         0x4071, 0x80e2, 0x0104, 0x0208, 0x0410, 0x0820, 0x1040, 0x2080,
2349         0x8071, 0x0102, 0x0204, 0x0408, 0x0810, 0x1020, 0x2040, 0x4080,
2350         0x019d, 0x03d6, 0x136c, 0x2198, 0x50b0, 0xb2e0, 0x0740, 0x0e80,
2351         0x0189, 0x03ea, 0x072c, 0x0e58, 0x1cb0, 0x56e0, 0x37c0, 0xf580,
2352         0x01fd, 0x0376, 0x06ec, 0x0bb8, 0x1110, 0x2220, 0x4440, 0x8880,
2353         0x0163, 0x02c6, 0x1104, 0x0758, 0x0eb0, 0x2be0, 0x6140, 0xc280,
2354         0x02fd, 0x01c6, 0x0b5c, 0x1108, 0x07b0, 0x25a0, 0x8840, 0x6180,
2355         0x0801, 0x012e, 0x025c, 0x04b8, 0x1370, 0x26e0, 0x57c0, 0xb580,
2356         0x0401, 0x0802, 0x015c, 0x02b8, 0x22b0, 0x13e0, 0x7140, 0xe280,
2357         0x0201, 0x0402, 0x0804, 0x01b8, 0x11b0, 0x31a0, 0x8040, 0x7180,
2358         0x0101, 0x0202, 0x0404, 0x0808, 0x1010, 0x2020, 0x4040, 0x8080,
2359         0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
2360         0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000,
2361 };
2362
2363 static int decode_syndrome(u16 syndrome, const u16 *vectors, unsigned num_vecs,
2364                            unsigned v_dim)
2365 {
2366         unsigned int i, err_sym;
2367
2368         for (err_sym = 0; err_sym < num_vecs / v_dim; err_sym++) {
2369                 u16 s = syndrome;
2370                 unsigned v_idx =  err_sym * v_dim;
2371                 unsigned v_end = (err_sym + 1) * v_dim;
2372
2373                 /* walk over all 16 bits of the syndrome */
2374                 for (i = 1; i < (1U << 16); i <<= 1) {
2375
2376                         /* if bit is set in that eigenvector... */
2377                         if (v_idx < v_end && vectors[v_idx] & i) {
2378                                 u16 ev_comp = vectors[v_idx++];
2379
2380                                 /* ... and bit set in the modified syndrome, */
2381                                 if (s & i) {
2382                                         /* remove it. */
2383                                         s ^= ev_comp;
2384
2385                                         if (!s)
2386                                                 return err_sym;
2387                                 }
2388
2389                         } else if (s & i)
2390                                 /* can't get to zero, move to next symbol */
2391                                 break;
2392                 }
2393         }
2394
2395         edac_dbg(0, "syndrome(%x) not found\n", syndrome);
2396         return -1;
2397 }
2398
2399 static int map_err_sym_to_channel(int err_sym, int sym_size)
2400 {
2401         if (sym_size == 4)
2402                 switch (err_sym) {
2403                 case 0x20:
2404                 case 0x21:
2405                         return 0;
2406                         break;
2407                 case 0x22:
2408                 case 0x23:
2409                         return 1;
2410                         break;
2411                 default:
2412                         return err_sym >> 4;
2413                         break;
2414                 }
2415         /* x8 symbols */
2416         else
2417                 switch (err_sym) {
2418                 /* imaginary bits not in a DIMM */
2419                 case 0x10:
2420                         WARN(1, KERN_ERR "Invalid error symbol: 0x%x\n",
2421                                           err_sym);
2422                         return -1;
2423                         break;
2424
2425                 case 0x11:
2426                         return 0;
2427                         break;
2428                 case 0x12:
2429                         return 1;
2430                         break;
2431                 default:
2432                         return err_sym >> 3;
2433                         break;
2434                 }
2435         return -1;
2436 }
2437
2438 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *mci, u16 syndrome)
2439 {
2440         struct amd64_pvt *pvt = mci->pvt_info;
2441         int err_sym = -1;
2442
2443         if (pvt->ecc_sym_sz == 8)
2444                 err_sym = decode_syndrome(syndrome, x8_vectors,
2445                                           ARRAY_SIZE(x8_vectors),
2446                                           pvt->ecc_sym_sz);
2447         else if (pvt->ecc_sym_sz == 4)
2448                 err_sym = decode_syndrome(syndrome, x4_vectors,
2449                                           ARRAY_SIZE(x4_vectors),
2450                                           pvt->ecc_sym_sz);
2451         else {
2452                 amd64_warn("Illegal syndrome type: %u\n", pvt->ecc_sym_sz);
2453                 return err_sym;
2454         }
2455
2456         return map_err_sym_to_channel(err_sym, pvt->ecc_sym_sz);
2457 }
2458
2459 static void __log_ecc_error(struct mem_ctl_info *mci, struct err_info *err,
2460                             u8 ecc_type)
2461 {
2462         enum hw_event_mc_err_type err_type;
2463         const char *string;
2464
2465         if (ecc_type == 2)
2466                 err_type = HW_EVENT_ERR_CORRECTED;
2467         else if (ecc_type == 1)
2468                 err_type = HW_EVENT_ERR_UNCORRECTED;
2469         else if (ecc_type == 3)
2470                 err_type = HW_EVENT_ERR_DEFERRED;
2471         else {
2472                 WARN(1, "Something is rotten in the state of Denmark.\n");
2473                 return;
2474         }
2475
2476         switch (err->err_code) {
2477         case DECODE_OK:
2478                 string = "";
2479                 break;
2480         case ERR_NODE:
2481                 string = "Failed to map error addr to a node";
2482                 break;
2483         case ERR_CSROW:
2484                 string = "Failed to map error addr to a csrow";
2485                 break;
2486         case ERR_CHANNEL:
2487                 string = "Unknown syndrome - possible error reporting race";
2488                 break;
2489         case ERR_SYND:
2490                 string = "MCA_SYND not valid - unknown syndrome and csrow";
2491                 break;
2492         case ERR_NORM_ADDR:
2493                 string = "Cannot decode normalized address";
2494                 break;
2495         default:
2496                 string = "WTF error";
2497                 break;
2498         }
2499
2500         edac_mc_handle_error(err_type, mci, 1,
2501                              err->page, err->offset, err->syndrome,
2502                              err->csrow, err->channel, -1,
2503                              string, "");
2504 }
2505
2506 static inline void decode_bus_error(int node_id, struct mce *m)
2507 {
2508         struct mem_ctl_info *mci;
2509         struct amd64_pvt *pvt;
2510         u8 ecc_type = (m->status >> 45) & 0x3;
2511         u8 xec = XEC(m->status, 0x1f);
2512         u16 ec = EC(m->status);
2513         u64 sys_addr;
2514         struct err_info err;
2515
2516         mci = edac_mc_find(node_id);
2517         if (!mci)
2518                 return;
2519
2520         pvt = mci->pvt_info;
2521
2522         /* Bail out early if this was an 'observed' error */
2523         if (PP(ec) == NBSL_PP_OBS)
2524                 return;
2525
2526         /* Do only ECC errors */
2527         if (xec && xec != F10_NBSL_EXT_ERR_ECC)
2528                 return;
2529
2530         memset(&err, 0, sizeof(err));
2531
2532         sys_addr = get_error_address(pvt, m);
2533
2534         if (ecc_type == 2)
2535                 err.syndrome = extract_syndrome(m->status);
2536
2537         pvt->ops->map_sysaddr_to_csrow(mci, sys_addr, &err);
2538
2539         __log_ecc_error(mci, &err, ecc_type);
2540 }
2541
2542 /*
2543  * To find the UMC channel represented by this bank we need to match on its
2544  * instance_id. The instance_id of a bank is held in the lower 32 bits of its
2545  * IPID.
2546  *
2547  * Currently, we can derive the channel number by looking at the 6th nibble in
2548  * the instance_id. For example, instance_id=0xYXXXXX where Y is the channel
2549  * number.
2550  */
2551 static int find_umc_channel(struct mce *m)
2552 {
2553         return (m->ipid & GENMASK(31, 0)) >> 20;
2554 }
2555
2556 static void decode_umc_error(int node_id, struct mce *m)
2557 {
2558         u8 ecc_type = (m->status >> 45) & 0x3;
2559         struct mem_ctl_info *mci;
2560         struct amd64_pvt *pvt;
2561         struct err_info err;
2562         u64 sys_addr;
2563
2564         mci = edac_mc_find(node_id);
2565         if (!mci)
2566                 return;
2567
2568         pvt = mci->pvt_info;
2569
2570         memset(&err, 0, sizeof(err));
2571
2572         if (m->status & MCI_STATUS_DEFERRED)
2573                 ecc_type = 3;
2574
2575         err.channel = find_umc_channel(m);
2576
2577         if (umc_normaddr_to_sysaddr(m->addr, pvt->mc_node_id, err.channel, &sys_addr)) {
2578                 err.err_code = ERR_NORM_ADDR;
2579                 goto log_error;
2580         }
2581
2582         error_address_to_page_and_offset(sys_addr, &err);
2583
2584         if (!(m->status & MCI_STATUS_SYNDV)) {
2585                 err.err_code = ERR_SYND;
2586                 goto log_error;
2587         }
2588
2589         if (ecc_type == 2) {
2590                 u8 length = (m->synd >> 18) & 0x3f;
2591
2592                 if (length)
2593                         err.syndrome = (m->synd >> 32) & GENMASK(length - 1, 0);
2594                 else
2595                         err.err_code = ERR_CHANNEL;
2596         }
2597
2598         err.csrow = m->synd & 0x7;
2599
2600 log_error:
2601         __log_ecc_error(mci, &err, ecc_type);
2602 }
2603
2604 /*
2605  * Use pvt->F3 which contains the F3 CPU PCI device to get the related
2606  * F1 (AddrMap) and F2 (Dct) devices. Return negative value on error.
2607  * Reserve F0 and F6 on systems with a UMC.
2608  */
2609 static int
2610 reserve_mc_sibling_devs(struct amd64_pvt *pvt, u16 pci_id1, u16 pci_id2)
2611 {
2612         if (pvt->umc) {
2613                 pvt->F0 = pci_get_related_function(pvt->F3->vendor, pci_id1, pvt->F3);
2614                 if (!pvt->F0) {
2615                         amd64_err("F0 not found, device 0x%x (broken BIOS?)\n", pci_id1);
2616                         return -ENODEV;
2617                 }
2618
2619                 pvt->F6 = pci_get_related_function(pvt->F3->vendor, pci_id2, pvt->F3);
2620                 if (!pvt->F6) {
2621                         pci_dev_put(pvt->F0);
2622                         pvt->F0 = NULL;
2623
2624                         amd64_err("F6 not found: device 0x%x (broken BIOS?)\n", pci_id2);
2625                         return -ENODEV;
2626                 }
2627
2628                 edac_dbg(1, "F0: %s\n", pci_name(pvt->F0));
2629                 edac_dbg(1, "F3: %s\n", pci_name(pvt->F3));
2630                 edac_dbg(1, "F6: %s\n", pci_name(pvt->F6));
2631
2632                 return 0;
2633         }
2634
2635         /* Reserve the ADDRESS MAP Device */
2636         pvt->F1 = pci_get_related_function(pvt->F3->vendor, pci_id1, pvt->F3);
2637         if (!pvt->F1) {
2638                 amd64_err("F1 not found: device 0x%x (broken BIOS?)\n", pci_id1);
2639                 return -ENODEV;
2640         }
2641
2642         /* Reserve the DCT Device */
2643         pvt->F2 = pci_get_related_function(pvt->F3->vendor, pci_id2, pvt->F3);
2644         if (!pvt->F2) {
2645                 pci_dev_put(pvt->F1);
2646                 pvt->F1 = NULL;
2647
2648                 amd64_err("F2 not found: device 0x%x (broken BIOS?)\n", pci_id2);
2649                 return -ENODEV;
2650         }
2651
2652         edac_dbg(1, "F1: %s\n", pci_name(pvt->F1));
2653         edac_dbg(1, "F2: %s\n", pci_name(pvt->F2));
2654         edac_dbg(1, "F3: %s\n", pci_name(pvt->F3));
2655
2656         return 0;
2657 }
2658
2659 static void free_mc_sibling_devs(struct amd64_pvt *pvt)
2660 {
2661         if (pvt->umc) {
2662                 pci_dev_put(pvt->F0);
2663                 pci_dev_put(pvt->F6);
2664         } else {
2665                 pci_dev_put(pvt->F1);
2666                 pci_dev_put(pvt->F2);
2667         }
2668 }
2669
2670 static void determine_ecc_sym_sz(struct amd64_pvt *pvt)
2671 {
2672         pvt->ecc_sym_sz = 4;
2673
2674         if (pvt->umc) {
2675                 u8 i;
2676
2677                 for_each_umc(i) {
2678                         /* Check enabled channels only: */
2679                         if (pvt->umc[i].sdp_ctrl & UMC_SDP_INIT) {
2680                                 if (pvt->umc[i].ecc_ctrl & BIT(9)) {
2681                                         pvt->ecc_sym_sz = 16;
2682                                         return;
2683                                 } else if (pvt->umc[i].ecc_ctrl & BIT(7)) {
2684                                         pvt->ecc_sym_sz = 8;
2685                                         return;
2686                                 }
2687                         }
2688                 }
2689         } else if (pvt->fam >= 0x10) {
2690                 u32 tmp;
2691
2692                 amd64_read_pci_cfg(pvt->F3, EXT_NB_MCA_CFG, &tmp);
2693                 /* F16h has only DCT0, so no need to read dbam1. */
2694                 if (pvt->fam != 0x16)
2695                         amd64_read_dct_pci_cfg(pvt, 1, DBAM0, &pvt->dbam1);
2696
2697                 /* F10h, revD and later can do x8 ECC too. */
2698                 if ((pvt->fam > 0x10 || pvt->model > 7) && tmp & BIT(25))
2699                         pvt->ecc_sym_sz = 8;
2700         }
2701 }
2702
2703 /*
2704  * Retrieve the hardware registers of the memory controller.
2705  */
2706 static void __read_mc_regs_df(struct amd64_pvt *pvt)
2707 {
2708         u8 nid = pvt->mc_node_id;
2709         struct amd64_umc *umc;
2710         u32 i, umc_base;
2711
2712         /* Read registers from each UMC */
2713         for_each_umc(i) {
2714
2715                 umc_base = get_umc_base(i);
2716                 umc = &pvt->umc[i];
2717
2718                 amd_smn_read(nid, umc_base + UMCCH_DIMM_CFG, &umc->dimm_cfg);
2719                 amd_smn_read(nid, umc_base + UMCCH_UMC_CFG, &umc->umc_cfg);
2720                 amd_smn_read(nid, umc_base + UMCCH_SDP_CTRL, &umc->sdp_ctrl);
2721                 amd_smn_read(nid, umc_base + UMCCH_ECC_CTRL, &umc->ecc_ctrl);
2722                 amd_smn_read(nid, umc_base + UMCCH_UMC_CAP_HI, &umc->umc_cap_hi);
2723         }
2724 }
2725
2726 /*
2727  * Retrieve the hardware registers of the memory controller (this includes the
2728  * 'Address Map' and 'Misc' device regs)
2729  */
2730 static void read_mc_regs(struct amd64_pvt *pvt)
2731 {
2732         unsigned int range;
2733         u64 msr_val;
2734
2735         /*
2736          * Retrieve TOP_MEM and TOP_MEM2; no masking off of reserved bits since
2737          * those are Read-As-Zero.
2738          */
2739         rdmsrl(MSR_K8_TOP_MEM1, pvt->top_mem);
2740         edac_dbg(0, "  TOP_MEM:  0x%016llx\n", pvt->top_mem);
2741
2742         /* Check first whether TOP_MEM2 is enabled: */
2743         rdmsrl(MSR_K8_SYSCFG, msr_val);
2744         if (msr_val & BIT(21)) {
2745                 rdmsrl(MSR_K8_TOP_MEM2, pvt->top_mem2);
2746                 edac_dbg(0, "  TOP_MEM2: 0x%016llx\n", pvt->top_mem2);
2747         } else {
2748                 edac_dbg(0, "  TOP_MEM2 disabled\n");
2749         }
2750
2751         if (pvt->umc) {
2752                 __read_mc_regs_df(pvt);
2753                 amd64_read_pci_cfg(pvt->F0, DF_DHAR, &pvt->dhar);
2754
2755                 goto skip;
2756         }
2757
2758         amd64_read_pci_cfg(pvt->F3, NBCAP, &pvt->nbcap);
2759
2760         read_dram_ctl_register(pvt);
2761
2762         for (range = 0; range < DRAM_RANGES; range++) {
2763                 u8 rw;
2764
2765                 /* read settings for this DRAM range */
2766                 read_dram_base_limit_regs(pvt, range);
2767
2768                 rw = dram_rw(pvt, range);
2769                 if (!rw)
2770                         continue;
2771
2772                 edac_dbg(1, "  DRAM range[%d], base: 0x%016llx; limit: 0x%016llx\n",
2773                          range,
2774                          get_dram_base(pvt, range),
2775                          get_dram_limit(pvt, range));
2776
2777                 edac_dbg(1, "   IntlvEn=%s; Range access: %s%s IntlvSel=%d DstNode=%d\n",
2778                          dram_intlv_en(pvt, range) ? "Enabled" : "Disabled",
2779                          (rw & 0x1) ? "R" : "-",
2780                          (rw & 0x2) ? "W" : "-",
2781                          dram_intlv_sel(pvt, range),
2782                          dram_dst_node(pvt, range));
2783         }
2784
2785         amd64_read_pci_cfg(pvt->F1, DHAR, &pvt->dhar);
2786         amd64_read_dct_pci_cfg(pvt, 0, DBAM0, &pvt->dbam0);
2787
2788         amd64_read_pci_cfg(pvt->F3, F10_ONLINE_SPARE, &pvt->online_spare);
2789
2790         amd64_read_dct_pci_cfg(pvt, 0, DCLR0, &pvt->dclr0);
2791         amd64_read_dct_pci_cfg(pvt, 0, DCHR0, &pvt->dchr0);
2792
2793         if (!dct_ganging_enabled(pvt)) {
2794                 amd64_read_dct_pci_cfg(pvt, 1, DCLR0, &pvt->dclr1);
2795                 amd64_read_dct_pci_cfg(pvt, 1, DCHR0, &pvt->dchr1);
2796         }
2797
2798 skip:
2799         read_dct_base_mask(pvt);
2800
2801         determine_memory_type(pvt);
2802         edac_dbg(1, "  DIMM type: %s\n", edac_mem_types[pvt->dram_type]);
2803
2804         determine_ecc_sym_sz(pvt);
2805
2806         dump_misc_regs(pvt);
2807 }
2808
2809 /*
2810  * NOTE: CPU Revision Dependent code
2811  *
2812  * Input:
2813  *      @csrow_nr ChipSelect Row Number (0..NUM_CHIPSELECTS-1)
2814  *      k8 private pointer to -->
2815  *                      DRAM Bank Address mapping register
2816  *                      node_id
2817  *                      DCL register where dual_channel_active is
2818  *
2819  * The DBAM register consists of 4 sets of 4 bits each definitions:
2820  *
2821  * Bits:        CSROWs
2822  * 0-3          CSROWs 0 and 1
2823  * 4-7          CSROWs 2 and 3
2824  * 8-11         CSROWs 4 and 5
2825  * 12-15        CSROWs 6 and 7
2826  *
2827  * Values range from: 0 to 15
2828  * The meaning of the values depends on CPU revision and dual-channel state,
2829  * see relevant BKDG more info.
2830  *
2831  * The memory controller provides for total of only 8 CSROWs in its current
2832  * architecture. Each "pair" of CSROWs normally represents just one DIMM in
2833  * single channel or two (2) DIMMs in dual channel mode.
2834  *
2835  * The following code logic collapses the various tables for CSROW based on CPU
2836  * revision.
2837  *
2838  * Returns:
2839  *      The number of PAGE_SIZE pages on the specified CSROW number it
2840  *      encompasses
2841  *
2842  */
2843 static u32 get_csrow_nr_pages(struct amd64_pvt *pvt, u8 dct, int csrow_nr_orig)
2844 {
2845         u32 dbam = dct ? pvt->dbam1 : pvt->dbam0;
2846         int csrow_nr = csrow_nr_orig;
2847         u32 cs_mode, nr_pages;
2848
2849         if (!pvt->umc) {
2850                 csrow_nr >>= 1;
2851                 cs_mode = DBAM_DIMM(csrow_nr, dbam);
2852         } else {
2853                 cs_mode = f17_get_cs_mode(csrow_nr >> 1, dct, pvt);
2854         }
2855
2856         nr_pages   = pvt->ops->dbam_to_cs(pvt, dct, cs_mode, csrow_nr);
2857         nr_pages <<= 20 - PAGE_SHIFT;
2858
2859         edac_dbg(0, "csrow: %d, channel: %d, DBAM idx: %d\n",
2860                     csrow_nr_orig, dct,  cs_mode);
2861         edac_dbg(0, "nr_pages/channel: %u\n", nr_pages);
2862
2863         return nr_pages;
2864 }
2865
2866 static int init_csrows_df(struct mem_ctl_info *mci)
2867 {
2868         struct amd64_pvt *pvt = mci->pvt_info;
2869         enum edac_type edac_mode = EDAC_NONE;
2870         enum dev_type dev_type = DEV_UNKNOWN;
2871         struct dimm_info *dimm;
2872         int empty = 1;
2873         u8 umc, cs;
2874
2875         if (mci->edac_ctl_cap & EDAC_FLAG_S16ECD16ED) {
2876                 edac_mode = EDAC_S16ECD16ED;
2877                 dev_type = DEV_X16;
2878         } else if (mci->edac_ctl_cap & EDAC_FLAG_S8ECD8ED) {
2879                 edac_mode = EDAC_S8ECD8ED;
2880                 dev_type = DEV_X8;
2881         } else if (mci->edac_ctl_cap & EDAC_FLAG_S4ECD4ED) {
2882                 edac_mode = EDAC_S4ECD4ED;
2883                 dev_type = DEV_X4;
2884         } else if (mci->edac_ctl_cap & EDAC_FLAG_SECDED) {
2885                 edac_mode = EDAC_SECDED;
2886         }
2887
2888         for_each_umc(umc) {
2889                 for_each_chip_select(cs, umc, pvt) {
2890                         if (!csrow_enabled(cs, umc, pvt))
2891                                 continue;
2892
2893                         empty = 0;
2894                         dimm = mci->csrows[cs]->channels[umc]->dimm;
2895
2896                         edac_dbg(1, "MC node: %d, csrow: %d\n",
2897                                         pvt->mc_node_id, cs);
2898
2899                         dimm->nr_pages = get_csrow_nr_pages(pvt, umc, cs);
2900                         dimm->mtype = pvt->dram_type;
2901                         dimm->edac_mode = edac_mode;
2902                         dimm->dtype = dev_type;
2903                 }
2904         }
2905
2906         return empty;
2907 }
2908
2909 /*
2910  * Initialize the array of csrow attribute instances, based on the values
2911  * from pci config hardware registers.
2912  */
2913 static int init_csrows(struct mem_ctl_info *mci)
2914 {
2915         struct amd64_pvt *pvt = mci->pvt_info;
2916         enum edac_type edac_mode = EDAC_NONE;
2917         struct csrow_info *csrow;
2918         struct dimm_info *dimm;
2919         int i, j, empty = 1;
2920         int nr_pages = 0;
2921         u32 val;
2922
2923         if (pvt->umc)
2924                 return init_csrows_df(mci);
2925
2926         amd64_read_pci_cfg(pvt->F3, NBCFG, &val);
2927
2928         pvt->nbcfg = val;
2929
2930         edac_dbg(0, "node %d, NBCFG=0x%08x[ChipKillEccCap: %d|DramEccEn: %d]\n",
2931                  pvt->mc_node_id, val,
2932                  !!(val & NBCFG_CHIPKILL), !!(val & NBCFG_ECC_ENABLE));
2933
2934         /*
2935          * We iterate over DCT0 here but we look at DCT1 in parallel, if needed.
2936          */
2937         for_each_chip_select(i, 0, pvt) {
2938                 bool row_dct0 = !!csrow_enabled(i, 0, pvt);
2939                 bool row_dct1 = false;
2940
2941                 if (pvt->fam != 0xf)
2942                         row_dct1 = !!csrow_enabled(i, 1, pvt);
2943
2944                 if (!row_dct0 && !row_dct1)
2945                         continue;
2946
2947                 csrow = mci->csrows[i];
2948                 empty = 0;
2949
2950                 edac_dbg(1, "MC node: %d, csrow: %d\n",
2951                             pvt->mc_node_id, i);
2952
2953                 if (row_dct0) {
2954                         nr_pages = get_csrow_nr_pages(pvt, 0, i);
2955                         csrow->channels[0]->dimm->nr_pages = nr_pages;
2956                 }
2957
2958                 /* K8 has only one DCT */
2959                 if (pvt->fam != 0xf && row_dct1) {
2960                         int row_dct1_pages = get_csrow_nr_pages(pvt, 1, i);
2961
2962                         csrow->channels[1]->dimm->nr_pages = row_dct1_pages;
2963                         nr_pages += row_dct1_pages;
2964                 }
2965
2966                 edac_dbg(1, "Total csrow%d pages: %u\n", i, nr_pages);
2967
2968                 /* Determine DIMM ECC mode: */
2969                 if (pvt->nbcfg & NBCFG_ECC_ENABLE) {
2970                         edac_mode = (pvt->nbcfg & NBCFG_CHIPKILL)
2971                                         ? EDAC_S4ECD4ED
2972                                         : EDAC_SECDED;
2973                 }
2974
2975                 for (j = 0; j < pvt->channel_count; j++) {
2976                         dimm = csrow->channels[j]->dimm;
2977                         dimm->mtype = pvt->dram_type;
2978                         dimm->edac_mode = edac_mode;
2979                 }
2980         }
2981
2982         return empty;
2983 }
2984
2985 /* get all cores on this DCT */
2986 static void get_cpus_on_this_dct_cpumask(struct cpumask *mask, u16 nid)
2987 {
2988         int cpu;
2989
2990         for_each_online_cpu(cpu)
2991                 if (amd_get_nb_id(cpu) == nid)
2992                         cpumask_set_cpu(cpu, mask);
2993 }
2994
2995 /* check MCG_CTL on all the cpus on this node */
2996 static bool nb_mce_bank_enabled_on_node(u16 nid)
2997 {
2998         cpumask_var_t mask;
2999         int cpu, nbe;
3000         bool ret = false;
3001
3002         if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
3003                 amd64_warn("%s: Error allocating mask\n", __func__);
3004                 return false;
3005         }
3006
3007         get_cpus_on_this_dct_cpumask(mask, nid);
3008
3009         rdmsr_on_cpus(mask, MSR_IA32_MCG_CTL, msrs);
3010
3011         for_each_cpu(cpu, mask) {
3012                 struct msr *reg = per_cpu_ptr(msrs, cpu);
3013                 nbe = reg->l & MSR_MCGCTL_NBE;
3014
3015                 edac_dbg(0, "core: %u, MCG_CTL: 0x%llx, NB MSR is %s\n",
3016                          cpu, reg->q,
3017                          (nbe ? "enabled" : "disabled"));
3018
3019                 if (!nbe)
3020                         goto out;
3021         }
3022         ret = true;
3023
3024 out:
3025         free_cpumask_var(mask);
3026         return ret;
3027 }
3028
3029 static int toggle_ecc_err_reporting(struct ecc_settings *s, u16 nid, bool on)
3030 {
3031         cpumask_var_t cmask;
3032         int cpu;
3033
3034         if (!zalloc_cpumask_var(&cmask, GFP_KERNEL)) {
3035                 amd64_warn("%s: error allocating mask\n", __func__);
3036                 return -ENOMEM;
3037         }
3038
3039         get_cpus_on_this_dct_cpumask(cmask, nid);
3040
3041         rdmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
3042
3043         for_each_cpu(cpu, cmask) {
3044
3045                 struct msr *reg = per_cpu_ptr(msrs, cpu);
3046
3047                 if (on) {
3048                         if (reg->l & MSR_MCGCTL_NBE)
3049                                 s->flags.nb_mce_enable = 1;
3050
3051                         reg->l |= MSR_MCGCTL_NBE;
3052                 } else {
3053                         /*
3054                          * Turn off NB MCE reporting only when it was off before
3055                          */
3056                         if (!s->flags.nb_mce_enable)
3057                                 reg->l &= ~MSR_MCGCTL_NBE;
3058                 }
3059         }
3060         wrmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
3061
3062         free_cpumask_var(cmask);
3063
3064         return 0;
3065 }
3066
3067 static bool enable_ecc_error_reporting(struct ecc_settings *s, u16 nid,
3068                                        struct pci_dev *F3)
3069 {
3070         bool ret = true;
3071         u32 value, mask = 0x3;          /* UECC/CECC enable */
3072
3073         if (toggle_ecc_err_reporting(s, nid, ON)) {
3074                 amd64_warn("Error enabling ECC reporting over MCGCTL!\n");
3075                 return false;
3076         }
3077
3078         amd64_read_pci_cfg(F3, NBCTL, &value);
3079
3080         s->old_nbctl   = value & mask;
3081         s->nbctl_valid = true;
3082
3083         value |= mask;
3084         amd64_write_pci_cfg(F3, NBCTL, value);
3085
3086         amd64_read_pci_cfg(F3, NBCFG, &value);
3087
3088         edac_dbg(0, "1: node %d, NBCFG=0x%08x[DramEccEn: %d]\n",
3089                  nid, value, !!(value & NBCFG_ECC_ENABLE));
3090
3091         if (!(value & NBCFG_ECC_ENABLE)) {
3092                 amd64_warn("DRAM ECC disabled on this node, enabling...\n");
3093
3094                 s->flags.nb_ecc_prev = 0;
3095
3096                 /* Attempt to turn on DRAM ECC Enable */
3097                 value |= NBCFG_ECC_ENABLE;
3098                 amd64_write_pci_cfg(F3, NBCFG, value);
3099
3100                 amd64_read_pci_cfg(F3, NBCFG, &value);
3101
3102                 if (!(value & NBCFG_ECC_ENABLE)) {
3103                         amd64_warn("Hardware rejected DRAM ECC enable,"
3104                                    "check memory DIMM configuration.\n");
3105                         ret = false;
3106                 } else {
3107                         amd64_info("Hardware accepted DRAM ECC Enable\n");
3108                 }
3109         } else {
3110                 s->flags.nb_ecc_prev = 1;
3111         }
3112
3113         edac_dbg(0, "2: node %d, NBCFG=0x%08x[DramEccEn: %d]\n",
3114                  nid, value, !!(value & NBCFG_ECC_ENABLE));
3115
3116         return ret;
3117 }
3118
3119 static void restore_ecc_error_reporting(struct ecc_settings *s, u16 nid,
3120                                         struct pci_dev *F3)
3121 {
3122         u32 value, mask = 0x3;          /* UECC/CECC enable */
3123
3124         if (!s->nbctl_valid)
3125                 return;
3126
3127         amd64_read_pci_cfg(F3, NBCTL, &value);
3128         value &= ~mask;
3129         value |= s->old_nbctl;
3130
3131         amd64_write_pci_cfg(F3, NBCTL, value);
3132
3133         /* restore previous BIOS DRAM ECC "off" setting we force-enabled */
3134         if (!s->flags.nb_ecc_prev) {
3135                 amd64_read_pci_cfg(F3, NBCFG, &value);
3136                 value &= ~NBCFG_ECC_ENABLE;
3137                 amd64_write_pci_cfg(F3, NBCFG, value);
3138         }
3139
3140         /* restore the NB Enable MCGCTL bit */
3141         if (toggle_ecc_err_reporting(s, nid, OFF))
3142                 amd64_warn("Error restoring NB MCGCTL settings!\n");
3143 }
3144
3145 /*
3146  * EDAC requires that the BIOS have ECC enabled before
3147  * taking over the processing of ECC errors. A command line
3148  * option allows to force-enable hardware ECC later in
3149  * enable_ecc_error_reporting().
3150  */
3151 static const char *ecc_msg =
3152         "ECC disabled in the BIOS or no ECC capability, module will not load.\n"
3153         " Either enable ECC checking or force module loading by setting "
3154         "'ecc_enable_override'.\n"
3155         " (Note that use of the override may cause unknown side effects.)\n";
3156
3157 static bool ecc_enabled(struct pci_dev *F3, u16 nid)
3158 {
3159         bool nb_mce_en = false;
3160         u8 ecc_en = 0, i;
3161         u32 value;
3162
3163         if (boot_cpu_data.x86 >= 0x17) {
3164                 u8 umc_en_mask = 0, ecc_en_mask = 0;
3165
3166                 for_each_umc(i) {
3167                         u32 base = get_umc_base(i);
3168
3169                         /* Only check enabled UMCs. */
3170                         if (amd_smn_read(nid, base + UMCCH_SDP_CTRL, &value))
3171                                 continue;
3172
3173                         if (!(value & UMC_SDP_INIT))
3174                                 continue;
3175
3176                         umc_en_mask |= BIT(i);
3177
3178                         if (amd_smn_read(nid, base + UMCCH_UMC_CAP_HI, &value))
3179                                 continue;
3180
3181                         if (value & UMC_ECC_ENABLED)
3182                                 ecc_en_mask |= BIT(i);
3183                 }
3184
3185                 /* Check whether at least one UMC is enabled: */
3186                 if (umc_en_mask)
3187                         ecc_en = umc_en_mask == ecc_en_mask;
3188                 else
3189                         edac_dbg(0, "Node %d: No enabled UMCs.\n", nid);
3190
3191                 /* Assume UMC MCA banks are enabled. */
3192                 nb_mce_en = true;
3193         } else {
3194                 amd64_read_pci_cfg(F3, NBCFG, &value);
3195
3196                 ecc_en = !!(value & NBCFG_ECC_ENABLE);
3197
3198                 nb_mce_en = nb_mce_bank_enabled_on_node(nid);
3199                 if (!nb_mce_en)
3200                         edac_dbg(0, "NB MCE bank disabled, set MSR 0x%08x[4] on node %d to enable.\n",
3201                                      MSR_IA32_MCG_CTL, nid);
3202         }
3203
3204         amd64_info("Node %d: DRAM ECC %s.\n",
3205                    nid, (ecc_en ? "enabled" : "disabled"));
3206
3207         if (!ecc_en || !nb_mce_en) {
3208                 amd64_info("%s", ecc_msg);
3209                 return false;
3210         }
3211         return true;
3212 }
3213
3214 static inline void
3215 f17h_determine_edac_ctl_cap(struct mem_ctl_info *mci, struct amd64_pvt *pvt)
3216 {
3217         u8 i, ecc_en = 1, cpk_en = 1, dev_x4 = 1, dev_x16 = 1;
3218
3219         for_each_umc(i) {
3220                 if (pvt->umc[i].sdp_ctrl & UMC_SDP_INIT) {
3221                         ecc_en &= !!(pvt->umc[i].umc_cap_hi & UMC_ECC_ENABLED);
3222                         cpk_en &= !!(pvt->umc[i].umc_cap_hi & UMC_ECC_CHIPKILL_CAP);
3223
3224                         dev_x4  &= !!(pvt->umc[i].dimm_cfg & BIT(6));
3225                         dev_x16 &= !!(pvt->umc[i].dimm_cfg & BIT(7));
3226                 }
3227         }
3228
3229         /* Set chipkill only if ECC is enabled: */
3230         if (ecc_en) {
3231                 mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
3232
3233                 if (!cpk_en)
3234                         return;
3235
3236                 if (dev_x4)
3237                         mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
3238                 else if (dev_x16)
3239                         mci->edac_ctl_cap |= EDAC_FLAG_S16ECD16ED;
3240                 else
3241                         mci->edac_ctl_cap |= EDAC_FLAG_S8ECD8ED;
3242         }
3243 }
3244
3245 static void setup_mci_misc_attrs(struct mem_ctl_info *mci,
3246                                  struct amd64_family_type *fam)
3247 {
3248         struct amd64_pvt *pvt = mci->pvt_info;
3249
3250         mci->mtype_cap          = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
3251         mci->edac_ctl_cap       = EDAC_FLAG_NONE;
3252
3253         if (pvt->umc) {
3254                 f17h_determine_edac_ctl_cap(mci, pvt);
3255         } else {
3256                 if (pvt->nbcap & NBCAP_SECDED)
3257                         mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
3258
3259                 if (pvt->nbcap & NBCAP_CHIPKILL)
3260                         mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
3261         }
3262
3263         mci->edac_cap           = determine_edac_cap(pvt);
3264         mci->mod_name           = EDAC_MOD_STR;
3265         mci->ctl_name           = fam->ctl_name;
3266         mci->dev_name           = pci_name(pvt->F3);
3267         mci->ctl_page_to_phys   = NULL;
3268
3269         /* memory scrubber interface */
3270         mci->set_sdram_scrub_rate = set_scrub_rate;
3271         mci->get_sdram_scrub_rate = get_scrub_rate;
3272 }
3273
3274 /*
3275  * returns a pointer to the family descriptor on success, NULL otherwise.
3276  */
3277 static struct amd64_family_type *per_family_init(struct amd64_pvt *pvt)
3278 {
3279         struct amd64_family_type *fam_type = NULL;
3280
3281         pvt->ext_model  = boot_cpu_data.x86_model >> 4;
3282         pvt->stepping   = boot_cpu_data.x86_stepping;
3283         pvt->model      = boot_cpu_data.x86_model;
3284         pvt->fam        = boot_cpu_data.x86;
3285
3286         switch (pvt->fam) {
3287         case 0xf:
3288                 fam_type        = &family_types[K8_CPUS];
3289                 pvt->ops        = &family_types[K8_CPUS].ops;
3290                 break;
3291
3292         case 0x10:
3293                 fam_type        = &family_types[F10_CPUS];
3294                 pvt->ops        = &family_types[F10_CPUS].ops;
3295                 break;
3296
3297         case 0x15:
3298                 if (pvt->model == 0x30) {
3299                         fam_type = &family_types[F15_M30H_CPUS];
3300                         pvt->ops = &family_types[F15_M30H_CPUS].ops;
3301                         break;
3302                 } else if (pvt->model == 0x60) {
3303                         fam_type = &family_types[F15_M60H_CPUS];
3304                         pvt->ops = &family_types[F15_M60H_CPUS].ops;
3305                         break;
3306                 }
3307
3308                 fam_type        = &family_types[F15_CPUS];
3309                 pvt->ops        = &family_types[F15_CPUS].ops;
3310                 break;
3311
3312         case 0x16:
3313                 if (pvt->model == 0x30) {
3314                         fam_type = &family_types[F16_M30H_CPUS];
3315                         pvt->ops = &family_types[F16_M30H_CPUS].ops;
3316                         break;
3317                 }
3318                 fam_type        = &family_types[F16_CPUS];
3319                 pvt->ops        = &family_types[F16_CPUS].ops;
3320                 break;
3321
3322         case 0x17:
3323                 if (pvt->model >= 0x10 && pvt->model <= 0x2f) {
3324                         fam_type = &family_types[F17_M10H_CPUS];
3325                         pvt->ops = &family_types[F17_M10H_CPUS].ops;
3326                         break;
3327                 } else if (pvt->model >= 0x30 && pvt->model <= 0x3f) {
3328                         fam_type = &family_types[F17_M30H_CPUS];
3329                         pvt->ops = &family_types[F17_M30H_CPUS].ops;
3330                         break;
3331                 }
3332                 /* fall through */
3333         case 0x18:
3334                 fam_type        = &family_types[F17_CPUS];
3335                 pvt->ops        = &family_types[F17_CPUS].ops;
3336
3337                 if (pvt->fam == 0x18)
3338                         family_types[F17_CPUS].ctl_name = "F18h";
3339                 break;
3340
3341         default:
3342                 amd64_err("Unsupported family!\n");
3343                 return NULL;
3344         }
3345
3346         amd64_info("%s %sdetected (node %d).\n", fam_type->ctl_name,
3347                      (pvt->fam == 0xf ?
3348                                 (pvt->ext_model >= K8_REV_F  ? "revF or later "
3349                                                              : "revE or earlier ")
3350                                  : ""), pvt->mc_node_id);
3351         return fam_type;
3352 }
3353
3354 static const struct attribute_group *amd64_edac_attr_groups[] = {
3355 #ifdef CONFIG_EDAC_DEBUG
3356         &amd64_edac_dbg_group,
3357 #endif
3358 #ifdef CONFIG_EDAC_AMD64_ERROR_INJECTION
3359         &amd64_edac_inj_group,
3360 #endif
3361         NULL
3362 };
3363
3364 /* Set the number of Unified Memory Controllers in the system. */
3365 static void compute_num_umcs(void)
3366 {
3367         u8 model = boot_cpu_data.x86_model;
3368
3369         if (boot_cpu_data.x86 < 0x17)
3370                 return;
3371
3372         if (model >= 0x30 && model <= 0x3f)
3373                 num_umcs = 8;
3374         else
3375                 num_umcs = 2;
3376
3377         edac_dbg(1, "Number of UMCs: %x", num_umcs);
3378 }
3379
3380 static int init_one_instance(unsigned int nid)
3381 {
3382         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
3383         struct amd64_family_type *fam_type = NULL;
3384         struct mem_ctl_info *mci = NULL;
3385         struct edac_mc_layer layers[2];
3386         struct amd64_pvt *pvt = NULL;
3387         u16 pci_id1, pci_id2;
3388         int err = 0, ret;
3389
3390         ret = -ENOMEM;
3391         pvt = kzalloc(sizeof(struct amd64_pvt), GFP_KERNEL);
3392         if (!pvt)
3393                 goto err_ret;
3394
3395         pvt->mc_node_id = nid;
3396         pvt->F3 = F3;
3397
3398         ret = -EINVAL;
3399         fam_type = per_family_init(pvt);
3400         if (!fam_type)
3401                 goto err_free;
3402
3403         if (pvt->fam >= 0x17) {
3404                 pvt->umc = kcalloc(num_umcs, sizeof(struct amd64_umc), GFP_KERNEL);
3405                 if (!pvt->umc) {
3406                         ret = -ENOMEM;
3407                         goto err_free;
3408                 }
3409
3410                 pci_id1 = fam_type->f0_id;
3411                 pci_id2 = fam_type->f6_id;
3412         } else {
3413                 pci_id1 = fam_type->f1_id;
3414                 pci_id2 = fam_type->f2_id;
3415         }
3416
3417         err = reserve_mc_sibling_devs(pvt, pci_id1, pci_id2);
3418         if (err)
3419                 goto err_post_init;
3420
3421         read_mc_regs(pvt);
3422
3423         /*
3424          * We need to determine how many memory channels there are. Then use
3425          * that information for calculating the size of the dynamic instance
3426          * tables in the 'mci' structure.
3427          */
3428         ret = -EINVAL;
3429         pvt->channel_count = pvt->ops->early_channel_count(pvt);
3430         if (pvt->channel_count < 0)
3431                 goto err_siblings;
3432
3433         ret = -ENOMEM;
3434         layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
3435         layers[0].size = pvt->csels[0].b_cnt;
3436         layers[0].is_virt_csrow = true;
3437         layers[1].type = EDAC_MC_LAYER_CHANNEL;
3438
3439         /*
3440          * Always allocate two channels since we can have setups with DIMMs on
3441          * only one channel. Also, this simplifies handling later for the price
3442          * of a couple of KBs tops.
3443          *
3444          * On Fam17h+, the number of controllers may be greater than two. So set
3445          * the size equal to the maximum number of UMCs.
3446          */
3447         if (pvt->fam >= 0x17)
3448                 layers[1].size = num_umcs;
3449         else
3450                 layers[1].size = 2;
3451         layers[1].is_virt_csrow = false;
3452
3453         mci = edac_mc_alloc(nid, ARRAY_SIZE(layers), layers, 0);
3454         if (!mci)
3455                 goto err_siblings;
3456
3457         mci->pvt_info = pvt;
3458         mci->pdev = &pvt->F3->dev;
3459
3460         setup_mci_misc_attrs(mci, fam_type);
3461
3462         if (init_csrows(mci))
3463                 mci->edac_cap = EDAC_FLAG_NONE;
3464
3465         ret = -ENODEV;
3466         if (edac_mc_add_mc_with_groups(mci, amd64_edac_attr_groups)) {
3467                 edac_dbg(1, "failed edac_mc_add_mc()\n");
3468                 goto err_add_mc;
3469         }
3470
3471         return 0;
3472
3473 err_add_mc:
3474         edac_mc_free(mci);
3475
3476 err_siblings:
3477         free_mc_sibling_devs(pvt);
3478
3479 err_post_init:
3480         if (pvt->fam >= 0x17)
3481                 kfree(pvt->umc);
3482
3483 err_free:
3484         kfree(pvt);
3485
3486 err_ret:
3487         return ret;
3488 }
3489
3490 static int probe_one_instance(unsigned int nid)
3491 {
3492         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
3493         struct ecc_settings *s;
3494         int ret;
3495
3496         ret = -ENOMEM;
3497         s = kzalloc(sizeof(struct ecc_settings), GFP_KERNEL);
3498         if (!s)
3499                 goto err_out;
3500
3501         ecc_stngs[nid] = s;
3502
3503         if (!ecc_enabled(F3, nid)) {
3504                 ret = 0;
3505
3506                 if (!ecc_enable_override)
3507                         goto err_enable;
3508
3509                 if (boot_cpu_data.x86 >= 0x17) {
3510                         amd64_warn("Forcing ECC on is not recommended on newer systems. Please enable ECC in BIOS.");
3511                         goto err_enable;
3512                 } else
3513                         amd64_warn("Forcing ECC on!\n");
3514
3515                 if (!enable_ecc_error_reporting(s, nid, F3))
3516                         goto err_enable;
3517         }
3518
3519         ret = init_one_instance(nid);
3520         if (ret < 0) {
3521                 amd64_err("Error probing instance: %d\n", nid);
3522
3523                 if (boot_cpu_data.x86 < 0x17)
3524                         restore_ecc_error_reporting(s, nid, F3);
3525
3526                 goto err_enable;
3527         }
3528
3529         return ret;
3530
3531 err_enable:
3532         kfree(s);
3533         ecc_stngs[nid] = NULL;
3534
3535 err_out:
3536         return ret;
3537 }
3538
3539 static void remove_one_instance(unsigned int nid)
3540 {
3541         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
3542         struct ecc_settings *s = ecc_stngs[nid];
3543         struct mem_ctl_info *mci;
3544         struct amd64_pvt *pvt;
3545
3546         mci = find_mci_by_dev(&F3->dev);
3547         WARN_ON(!mci);
3548
3549         /* Remove from EDAC CORE tracking list */
3550         mci = edac_mc_del_mc(&F3->dev);
3551         if (!mci)
3552                 return;
3553
3554         pvt = mci->pvt_info;
3555
3556         restore_ecc_error_reporting(s, nid, F3);
3557
3558         free_mc_sibling_devs(pvt);
3559
3560         kfree(ecc_stngs[nid]);
3561         ecc_stngs[nid] = NULL;
3562
3563         /* Free the EDAC CORE resources */
3564         mci->pvt_info = NULL;
3565
3566         kfree(pvt);
3567         edac_mc_free(mci);
3568 }
3569
3570 static void setup_pci_device(void)
3571 {
3572         struct mem_ctl_info *mci;
3573         struct amd64_pvt *pvt;
3574
3575         if (pci_ctl)
3576                 return;
3577
3578         mci = edac_mc_find(0);
3579         if (!mci)
3580                 return;
3581
3582         pvt = mci->pvt_info;
3583         if (pvt->umc)
3584                 pci_ctl = edac_pci_create_generic_ctl(&pvt->F0->dev, EDAC_MOD_STR);
3585         else
3586                 pci_ctl = edac_pci_create_generic_ctl(&pvt->F2->dev, EDAC_MOD_STR);
3587         if (!pci_ctl) {
3588                 pr_warn("%s(): Unable to create PCI control\n", __func__);
3589                 pr_warn("%s(): PCI error report via EDAC not set\n", __func__);
3590         }
3591 }
3592
3593 static const struct x86_cpu_id amd64_cpuids[] = {
3594         { X86_VENDOR_AMD, 0xF,  X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3595         { X86_VENDOR_AMD, 0x10, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3596         { X86_VENDOR_AMD, 0x15, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3597         { X86_VENDOR_AMD, 0x16, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3598         { X86_VENDOR_AMD, 0x17, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3599         { X86_VENDOR_HYGON, 0x18, X86_MODEL_ANY, X86_FEATURE_ANY, 0 },
3600         { }
3601 };
3602 MODULE_DEVICE_TABLE(x86cpu, amd64_cpuids);
3603
3604 static int __init amd64_edac_init(void)
3605 {
3606         const char *owner;
3607         int err = -ENODEV;
3608         int i;
3609
3610         owner = edac_get_owner();
3611         if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR)))
3612                 return -EBUSY;
3613
3614         if (!x86_match_cpu(amd64_cpuids))
3615                 return -ENODEV;
3616
3617         if (amd_cache_northbridges() < 0)
3618                 return -ENODEV;
3619
3620         opstate_init();
3621
3622         err = -ENOMEM;
3623         ecc_stngs = kcalloc(amd_nb_num(), sizeof(ecc_stngs[0]), GFP_KERNEL);
3624         if (!ecc_stngs)
3625                 goto err_free;
3626
3627         msrs = msrs_alloc();
3628         if (!msrs)
3629                 goto err_free;
3630
3631         compute_num_umcs();
3632
3633         for (i = 0; i < amd_nb_num(); i++) {
3634                 err = probe_one_instance(i);
3635                 if (err) {
3636                         /* unwind properly */
3637                         while (--i >= 0)
3638                                 remove_one_instance(i);
3639
3640                         goto err_pci;
3641                 }
3642         }
3643
3644         if (!edac_has_mcs()) {
3645                 err = -ENODEV;
3646                 goto err_pci;
3647         }
3648
3649         /* register stuff with EDAC MCE */
3650         if (report_gart_errors)
3651                 amd_report_gart_errors(true);
3652
3653         if (boot_cpu_data.x86 >= 0x17)
3654                 amd_register_ecc_decoder(decode_umc_error);
3655         else
3656                 amd_register_ecc_decoder(decode_bus_error);
3657
3658         setup_pci_device();
3659
3660 #ifdef CONFIG_X86_32
3661         amd64_err("%s on 32-bit is unsupported. USE AT YOUR OWN RISK!\n", EDAC_MOD_STR);
3662 #endif
3663
3664         printk(KERN_INFO "AMD64 EDAC driver v%s\n", EDAC_AMD64_VERSION);
3665
3666         return 0;
3667
3668 err_pci:
3669         msrs_free(msrs);
3670         msrs = NULL;
3671
3672 err_free:
3673         kfree(ecc_stngs);
3674         ecc_stngs = NULL;
3675
3676         return err;
3677 }
3678
3679 static void __exit amd64_edac_exit(void)
3680 {
3681         int i;
3682
3683         if (pci_ctl)
3684                 edac_pci_release_generic_ctl(pci_ctl);
3685
3686         /* unregister from EDAC MCE */
3687         amd_report_gart_errors(false);
3688
3689         if (boot_cpu_data.x86 >= 0x17)
3690                 amd_unregister_ecc_decoder(decode_umc_error);
3691         else
3692                 amd_unregister_ecc_decoder(decode_bus_error);
3693
3694         for (i = 0; i < amd_nb_num(); i++)
3695                 remove_one_instance(i);
3696
3697         kfree(ecc_stngs);
3698         ecc_stngs = NULL;
3699
3700         msrs_free(msrs);
3701         msrs = NULL;
3702 }
3703
3704 module_init(amd64_edac_init);
3705 module_exit(amd64_edac_exit);
3706
3707 MODULE_LICENSE("GPL");
3708 MODULE_AUTHOR("SoftwareBitMaker: Doug Thompson, "
3709                 "Dave Peterson, Thayne Harbaugh");
3710 MODULE_DESCRIPTION("MC support for AMD64 memory controllers - "
3711                 EDAC_AMD64_VERSION);
3712
3713 module_param(edac_op_state, int, 0444);
3714 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");