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