drivers/edac/pnd2_edac.c

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