drivers/edac/versal_edac.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Xilinx Versal memory controller driver
   4  * Copyright (C) 2023 Advanced Micro Devices, Inc.
   5  */
   6 #include <linux/bitfield.h>
   7 #include <linux/edac.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/module.h>
  10 #include <linux/of.h>
  11 #include <linux/of_address.h>
  12 #include <linux/of_device.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/sizes.h>
  15 #include <linux/firmware/xlnx-zynqmp.h>
  16 #include <linux/firmware/xlnx-event-manager.h>
  17
  18 #include "edac_module.h"
  19
  20 /* Granularity of reported error in bytes */
  21 #define XDDR_EDAC_ERR_GRAIN                     1
  22
  23 #define XDDR_EDAC_MSG_SIZE                      256
  24 #define EVENT                                   2
  25
  26 #define XDDR_PCSR_OFFSET                        0xC
  27 #define XDDR_ISR_OFFSET                         0x14
  28 #define XDDR_IRQ_EN_OFFSET                      0x20
  29 #define XDDR_IRQ1_EN_OFFSET                     0x2C
  30 #define XDDR_IRQ_DIS_OFFSET                     0x24
  31 #define XDDR_IRQ_CE_MASK                        GENMASK(18, 15)
  32 #define XDDR_IRQ_UE_MASK                        GENMASK(14, 11)
  33
  34 #define XDDR_REG_CONFIG0_OFFSET                 0x258
  35 #define XDDR_REG_CONFIG0_BUS_WIDTH_MASK         GENMASK(19, 18)
  36 #define XDDR_REG_CONFIG0_NUM_CHANS_MASK         BIT(17)
  37 #define XDDR_REG_CONFIG0_NUM_RANKS_MASK         GENMASK(15, 14)
  38 #define XDDR_REG_CONFIG0_SIZE_MASK              GENMASK(10, 8)
  39
  40 #define XDDR_REG_PINOUT_OFFSET                  0x25C
  41 #define XDDR_REG_PINOUT_ECC_EN_MASK             GENMASK(7, 5)
  42
  43 #define ECCW0_FLIP_CTRL                         0x109C
  44 #define ECCW0_FLIP0_OFFSET                      0x10A0
  45 #define ECCW0_FLIP0_BITS                        31
  46 #define ECCW0_FLIP1_OFFSET                      0x10A4
  47 #define ECCW1_FLIP_CTRL                         0x10AC
  48 #define ECCW1_FLIP0_OFFSET                      0x10B0
  49 #define ECCW1_FLIP1_OFFSET                      0x10B4
  50 #define ECCR0_CERR_STAT_OFFSET                  0x10BC
  51 #define ECCR0_CE_ADDR_LO_OFFSET                 0x10C0
  52 #define ECCR0_CE_ADDR_HI_OFFSET                 0x10C4
  53 #define ECCR0_CE_DATA_LO_OFFSET                 0x10C8
  54 #define ECCR0_CE_DATA_HI_OFFSET                 0x10CC
  55 #define ECCR0_CE_DATA_PAR_OFFSET                0x10D0
  56
  57 #define ECCR0_UERR_STAT_OFFSET                  0x10D4
  58 #define ECCR0_UE_ADDR_LO_OFFSET                 0x10D8
  59 #define ECCR0_UE_ADDR_HI_OFFSET                 0x10DC
  60 #define ECCR0_UE_DATA_LO_OFFSET                 0x10E0
  61 #define ECCR0_UE_DATA_HI_OFFSET                 0x10E4
  62 #define ECCR0_UE_DATA_PAR_OFFSET                0x10E8
  63
  64 #define ECCR1_CERR_STAT_OFFSET                  0x10F4
  65 #define ECCR1_CE_ADDR_LO_OFFSET                 0x10F8
  66 #define ECCR1_CE_ADDR_HI_OFFSET                 0x10FC
  67 #define ECCR1_CE_DATA_LO_OFFSET                 0x1100
  68 #define ECCR1_CE_DATA_HI_OFFSET                 0x110C
  69 #define ECCR1_CE_DATA_PAR_OFFSET                0x1108
  70
  71 #define ECCR1_UERR_STAT_OFFSET                  0x110C
  72 #define ECCR1_UE_ADDR_LO_OFFSET                 0x1110
  73 #define ECCR1_UE_ADDR_HI_OFFSET                 0x1114
  74 #define ECCR1_UE_DATA_LO_OFFSET                 0x1118
  75 #define ECCR1_UE_DATA_HI_OFFSET                 0x111C
  76 #define ECCR1_UE_DATA_PAR_OFFSET                0x1120
  77
  78 #define XDDR_NOC_REG_ADEC4_OFFSET               0x44
  79 #define RANK_1_MASK                             GENMASK(11, 6)
  80 #define LRANK_0_MASK                            GENMASK(17, 12)
  81 #define LRANK_1_MASK                            GENMASK(23, 18)
  82 #define MASK_24                                 GENMASK(29, 24)
  83
  84 #define XDDR_NOC_REG_ADEC5_OFFSET               0x48
  85 #define XDDR_NOC_REG_ADEC6_OFFSET               0x4C
  86 #define XDDR_NOC_REG_ADEC7_OFFSET               0x50
  87 #define XDDR_NOC_REG_ADEC8_OFFSET               0x54
  88 #define XDDR_NOC_REG_ADEC9_OFFSET               0x58
  89 #define XDDR_NOC_REG_ADEC10_OFFSET              0x5C
  90
  91 #define XDDR_NOC_REG_ADEC11_OFFSET              0x60
  92 #define MASK_0                                  GENMASK(5, 0)
  93 #define GRP_0_MASK                              GENMASK(11, 6)
  94 #define GRP_1_MASK                              GENMASK(17, 12)
  95 #define CH_0_MASK                               GENMASK(23, 18)
  96
  97 #define XDDR_NOC_REG_ADEC12_OFFSET              0x71C
  98 #define XDDR_NOC_REG_ADEC13_OFFSET              0x720
  99
 100 #define XDDR_NOC_REG_ADEC14_OFFSET              0x724
 101 #define XDDR_NOC_ROW_MATCH_MASK                 GENMASK(17, 0)
 102 #define XDDR_NOC_COL_MATCH_MASK                 GENMASK(27, 18)
 103 #define XDDR_NOC_BANK_MATCH_MASK                GENMASK(29, 28)
 104 #define XDDR_NOC_GRP_MATCH_MASK                 GENMASK(31, 30)
 105
 106 #define XDDR_NOC_REG_ADEC15_OFFSET              0x728
 107 #define XDDR_NOC_RANK_MATCH_MASK                GENMASK(1, 0)
 108 #define XDDR_NOC_LRANK_MATCH_MASK               GENMASK(4, 2)
 109 #define XDDR_NOC_CH_MATCH_MASK                  BIT(5)
 110 #define XDDR_NOC_MOD_SEL_MASK                   BIT(6)
 111 #define XDDR_NOC_MATCH_EN_MASK                  BIT(8)
 112
 113 #define ECCR_UE_CE_ADDR_HI_ROW_MASK             GENMASK(7, 0)
 114
 115 #define XDDR_EDAC_NR_CSROWS                     1
 116 #define XDDR_EDAC_NR_CHANS                      1
 117
 118 #define XDDR_BUS_WIDTH_64                       0
 119 #define XDDR_BUS_WIDTH_32                       1
 120 #define XDDR_BUS_WIDTH_16                       2
 121
 122 #define XDDR_MAX_ROW_CNT                        18
 123 #define XDDR_MAX_COL_CNT                        10
 124 #define XDDR_MAX_RANK_CNT                       2
 125 #define XDDR_MAX_LRANK_CNT                      3
 126 #define XDDR_MAX_BANK_CNT                       2
 127 #define XDDR_MAX_GRP_CNT                        2
 128
 129 /*
 130  * Config and system registers are usually locked. This is the
 131  * code which unlocks them in order to accept writes. See
 132  *
 133  * https://docs.xilinx.com/r/en-US/am012-versal-register-reference/PCSR_LOCK-XRAM_SLCR-Register
 134  */
 135 #define PCSR_UNLOCK_VAL                         0xF9E8D7C6
 136 #define PCSR_LOCK_VAL                           1
 137 #define XDDR_ERR_TYPE_CE                        0
 138 #define XDDR_ERR_TYPE_UE                        1
 139
 140 #define XILINX_DRAM_SIZE_4G                     0
 141 #define XILINX_DRAM_SIZE_6G                     1
 142 #define XILINX_DRAM_SIZE_8G                     2
 143 #define XILINX_DRAM_SIZE_12G                    3
 144 #define XILINX_DRAM_SIZE_16G                    4
 145 #define XILINX_DRAM_SIZE_32G                    5
 146 #define NUM_UE_BITPOS                           2
 147
 148 /**
 149  * struct ecc_error_info - ECC error log information.
 150  * @burstpos:           Burst position.
 151  * @lrank:              Logical Rank number.
 152  * @rank:               Rank number.
 153  * @group:              Group number.
 154  * @bank:               Bank number.
 155  * @col:                Column number.
 156  * @row:                Row number.
 157  * @rowhi:              Row number higher bits.
 158  * @i:                  ECC error info.
 159  */
 160 union ecc_error_info {
 161         struct {
 162                 u32 burstpos:3;
 163                 u32 lrank:3;
 164                 u32 rank:2;
 165                 u32 group:2;
 166                 u32 bank:2;
 167                 u32 col:10;
 168                 u32 row:10;
 169                 u32 rowhi;
 170         };
 171         u64 i;
 172 } __packed;
 173
 174 union edac_info {
 175         struct {
 176                 u32 row0:6;
 177                 u32 row1:6;
 178                 u32 row2:6;
 179                 u32 row3:6;
 180                 u32 row4:6;
 181                 u32 reserved:2;
 182         };
 183         struct {
 184                 u32 col1:6;
 185                 u32 col2:6;
 186                 u32 col3:6;
 187                 u32 col4:6;
 188                 u32 col5:6;
 189                 u32 reservedcol:2;
 190         };
 191         u32 i;
 192 } __packed;
 193
 194 /**
 195  * struct ecc_status - ECC status information to report.
 196  * @ceinfo:     Correctable error log information.
 197  * @ueinfo:     Uncorrectable error log information.
 198  * @channel:    Channel number.
 199  * @error_type: Error type information.
 200  */
 201 struct ecc_status {
 202         union ecc_error_info ceinfo[2];
 203         union ecc_error_info ueinfo[2];
 204         u8 channel;
 205         u8 error_type;
 206 };
 207
 208 /**
 209  * struct edac_priv - DDR memory controller private instance data.
 210  * @ddrmc_baseaddr:     Base address of the DDR controller.
 211  * @ddrmc_noc_baseaddr: Base address of the DDRMC NOC.
 212  * @message:            Buffer for framing the event specific info.
 213  * @mc_id:              Memory controller ID.
 214  * @ce_cnt:             Correctable error count.
 215  * @ue_cnt:             UnCorrectable error count.
 216  * @stat:               ECC status information.
 217  * @lrank_bit:          Bit shifts for lrank bit.
 218  * @rank_bit:           Bit shifts for rank bit.
 219  * @row_bit:            Bit shifts for row bit.
 220  * @col_bit:            Bit shifts for column bit.
 221  * @bank_bit:           Bit shifts for bank bit.
 222  * @grp_bit:            Bit shifts for group bit.
 223  * @ch_bit:             Bit shifts for channel bit.
 224  * @err_inject_addr:    Data poison address.
 225  * @debugfs:            Debugfs handle.
 226  */
 227 struct edac_priv {
 228         void __iomem *ddrmc_baseaddr;
 229         void __iomem *ddrmc_noc_baseaddr;
 230         char message[XDDR_EDAC_MSG_SIZE];
 231         u32 mc_id;
 232         u32 ce_cnt;
 233         u32 ue_cnt;
 234         struct ecc_status stat;
 235         u32 lrank_bit[3];
 236         u32 rank_bit[2];
 237         u32 row_bit[18];
 238         u32 col_bit[10];
 239         u32 bank_bit[2];
 240         u32 grp_bit[2];
 241         u32 ch_bit;
 242 #ifdef CONFIG_EDAC_DEBUG
 243         u64 err_inject_addr;
 244         struct dentry *debugfs;
 245 #endif
 246 };
 247
 248 static void get_ce_error_info(struct edac_priv *priv)
 249 {
 250         void __iomem *ddrmc_base;
 251         struct ecc_status *p;
 252         u32  regval;
 253         u64  reghi;
 254
 255         ddrmc_base = priv->ddrmc_baseaddr;
 256         p = &priv->stat;
 257
 258         p->error_type = XDDR_ERR_TYPE_CE;
 259         regval = readl(ddrmc_base + ECCR0_CE_ADDR_LO_OFFSET);
 260         reghi = regval & ECCR_UE_CE_ADDR_HI_ROW_MASK;
 261         p->ceinfo[0].i = regval | reghi << 32;
 262         regval = readl(ddrmc_base + ECCR0_CE_ADDR_HI_OFFSET);
 263
 264         edac_dbg(2, "ERR DATA: 0x%08X%08X ERR DATA PARITY: 0x%08X\n",
 265                  readl(ddrmc_base + ECCR0_CE_DATA_LO_OFFSET),
 266                  readl(ddrmc_base + ECCR0_CE_DATA_HI_OFFSET),
 267                  readl(ddrmc_base + ECCR0_CE_DATA_PAR_OFFSET));
 268
 269         regval = readl(ddrmc_base + ECCR1_CE_ADDR_LO_OFFSET);
 270         reghi = readl(ddrmc_base + ECCR1_CE_ADDR_HI_OFFSET);
 271         p->ceinfo[1].i = regval | reghi << 32;
 272         regval = readl(ddrmc_base + ECCR1_CE_ADDR_HI_OFFSET);
 273
 274         edac_dbg(2, "ERR DATA: 0x%08X%08X ERR DATA PARITY: 0x%08X\n",
 275                  readl(ddrmc_base + ECCR1_CE_DATA_LO_OFFSET),
 276                  readl(ddrmc_base + ECCR1_CE_DATA_HI_OFFSET),
 277                  readl(ddrmc_base + ECCR1_CE_DATA_PAR_OFFSET));
 278 }
 279
 280 static void get_ue_error_info(struct edac_priv *priv)
 281 {
 282         void __iomem *ddrmc_base;
 283         struct ecc_status *p;
 284         u32  regval;
 285         u64 reghi;
 286
 287         ddrmc_base = priv->ddrmc_baseaddr;
 288         p = &priv->stat;
 289
 290         p->error_type = XDDR_ERR_TYPE_UE;
 291         regval = readl(ddrmc_base + ECCR0_UE_ADDR_LO_OFFSET);
 292         reghi = readl(ddrmc_base + ECCR0_UE_ADDR_HI_OFFSET);
 293
 294         p->ueinfo[0].i = regval | reghi << 32;
 295         regval = readl(ddrmc_base + ECCR0_UE_ADDR_HI_OFFSET);
 296
 297         edac_dbg(2, "ERR DATA: 0x%08X%08X ERR DATA PARITY: 0x%08X\n",
 298                  readl(ddrmc_base + ECCR0_UE_DATA_LO_OFFSET),
 299                  readl(ddrmc_base + ECCR0_UE_DATA_HI_OFFSET),
 300                  readl(ddrmc_base + ECCR0_UE_DATA_PAR_OFFSET));
 301
 302         regval = readl(ddrmc_base + ECCR1_UE_ADDR_LO_OFFSET);
 303         reghi = readl(ddrmc_base + ECCR1_UE_ADDR_HI_OFFSET);
 304         p->ueinfo[1].i = regval | reghi << 32;
 305
 306         edac_dbg(2, "ERR DATA: 0x%08X%08X ERR DATA PARITY: 0x%08X\n",
 307                  readl(ddrmc_base + ECCR1_UE_DATA_LO_OFFSET),
 308                  readl(ddrmc_base + ECCR1_UE_DATA_HI_OFFSET),
 309                  readl(ddrmc_base + ECCR1_UE_DATA_PAR_OFFSET));
 310 }
 311
 312 static bool get_error_info(struct edac_priv *priv)
 313 {
 314         u32 eccr0_ceval, eccr1_ceval, eccr0_ueval, eccr1_ueval;
 315         void __iomem *ddrmc_base;
 316         struct ecc_status *p;
 317
 318         ddrmc_base = priv->ddrmc_baseaddr;
 319         p = &priv->stat;
 320
 321         eccr0_ceval = readl(ddrmc_base + ECCR0_CERR_STAT_OFFSET);
 322         eccr1_ceval = readl(ddrmc_base + ECCR1_CERR_STAT_OFFSET);
 323         eccr0_ueval = readl(ddrmc_base + ECCR0_UERR_STAT_OFFSET);
 324         eccr1_ueval = readl(ddrmc_base + ECCR1_UERR_STAT_OFFSET);
 325
 326         if (!eccr0_ceval && !eccr1_ceval && !eccr0_ueval && !eccr1_ueval)
 327                 return 1;
 328         if (!eccr0_ceval)
 329                 p->channel = 1;
 330         else
 331                 p->channel = 0;
 332
 333         if (eccr0_ceval || eccr1_ceval)
 334                 get_ce_error_info(priv);
 335
 336         if (eccr0_ueval || eccr1_ueval) {
 337                 if (!eccr0_ueval)
 338                         p->channel = 1;
 339                 else
 340                         p->channel = 0;
 341                 get_ue_error_info(priv);
 342         }
 343
 344         /* Unlock the PCSR registers */
 345         writel(PCSR_UNLOCK_VAL, ddrmc_base + XDDR_PCSR_OFFSET);
 346
 347         writel(0, ddrmc_base + ECCR0_CERR_STAT_OFFSET);
 348         writel(0, ddrmc_base + ECCR1_CERR_STAT_OFFSET);
 349         writel(0, ddrmc_base + ECCR0_UERR_STAT_OFFSET);
 350         writel(0, ddrmc_base + ECCR1_UERR_STAT_OFFSET);
 351
 352         /* Lock the PCSR registers */
 353         writel(1, ddrmc_base + XDDR_PCSR_OFFSET);
 354
 355         return 0;
 356 }
 357
 358 /**
 359  * convert_to_physical - Convert to physical address.
 360  * @priv:       DDR memory controller private instance data.
 361  * @pinf:       ECC error info structure.
 362  *
 363  * Return: Physical address of the DDR memory.
 364  */
 365 static unsigned long convert_to_physical(struct edac_priv *priv, union ecc_error_info pinf)
 366 {
 367         unsigned long err_addr = 0;
 368         u32 index;
 369         u32 row;
 370
 371         row = pinf.rowhi << 10 | pinf.row;
 372         for (index = 0; index < XDDR_MAX_ROW_CNT; index++) {
 373                 err_addr |= (row & BIT(0)) << priv->row_bit[index];
 374                 row >>= 1;
 375         }
 376
 377         for (index = 0; index < XDDR_MAX_COL_CNT; index++) {
 378                 err_addr |= (pinf.col & BIT(0)) << priv->col_bit[index];
 379                 pinf.col >>= 1;
 380         }
 381
 382         for (index = 0; index < XDDR_MAX_BANK_CNT; index++) {
 383                 err_addr |= (pinf.bank & BIT(0)) << priv->bank_bit[index];
 384                 pinf.bank >>= 1;
 385         }
 386
 387         for (index = 0; index < XDDR_MAX_GRP_CNT; index++) {
 388                 err_addr |= (pinf.group & BIT(0)) << priv->grp_bit[index];
 389                 pinf.group >>= 1;
 390         }
 391
 392         for (index = 0; index < XDDR_MAX_RANK_CNT; index++) {
 393                 err_addr |= (pinf.rank & BIT(0)) << priv->rank_bit[index];
 394                 pinf.rank >>= 1;
 395         }
 396
 397         for (index = 0; index < XDDR_MAX_LRANK_CNT; index++) {
 398                 err_addr |= (pinf.lrank & BIT(0)) << priv->lrank_bit[index];
 399                 pinf.lrank >>= 1;
 400         }
 401
 402         err_addr |= (priv->stat.channel & BIT(0)) << priv->ch_bit;
 403
 404         return err_addr;
 405 }
 406
 407 /**
 408  * handle_error - Handle Correctable and Uncorrectable errors.
 409  * @mci:        EDAC memory controller instance.
 410  * @stat:       ECC status structure.
 411  *
 412  * Handles ECC correctable and uncorrectable errors.
 413  */
 414 static void handle_error(struct mem_ctl_info *mci, struct ecc_status *stat)
 415 {
 416         struct edac_priv *priv = mci->pvt_info;
 417         union ecc_error_info pinf;
 418
 419         if (stat->error_type == XDDR_ERR_TYPE_CE) {
 420                 priv->ce_cnt++;
 421                 pinf = stat->ceinfo[stat->channel];
 422                 snprintf(priv->message, XDDR_EDAC_MSG_SIZE,
 423                          "Error type:%s MC ID: %d Addr at %lx Burst Pos: %d\n",
 424                          "CE", priv->mc_id,
 425                          convert_to_physical(priv, pinf), pinf.burstpos);
 426
 427                 edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci,
 428                                      priv->ce_cnt, 0, 0, 0, 0, 0, -1,
 429                                      priv->message, "");
 430         }
 431
 432         if (stat->error_type == XDDR_ERR_TYPE_UE) {
 433                 priv->ue_cnt++;
 434                 pinf = stat->ueinfo[stat->channel];
 435                 snprintf(priv->message, XDDR_EDAC_MSG_SIZE,
 436                          "Error type:%s MC ID: %d Addr at %lx Burst Pos: %d\n",
 437                          "UE", priv->mc_id,
 438                          convert_to_physical(priv, pinf), pinf.burstpos);
 439
 440                 edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci,
 441                                      priv->ue_cnt, 0, 0, 0, 0, 0, -1,
 442                                      priv->message, "");
 443         }
 444
 445         memset(stat, 0, sizeof(*stat));
 446 }
 447
 448 /**
 449  * err_callback - Handle Correctable and Uncorrectable errors.
 450  * @payload:    payload data.
 451  * @data:       mci controller data.
 452  *
 453  * Handles ECC correctable and uncorrectable errors.
 454  */
 455 static void err_callback(const u32 *payload, void *data)
 456 {
 457         struct mem_ctl_info *mci = (struct mem_ctl_info *)data;
 458         struct edac_priv *priv;
 459         struct ecc_status *p;
 460         int regval;
 461
 462         priv = mci->pvt_info;
 463         p = &priv->stat;
 464
 465         regval = readl(priv->ddrmc_baseaddr + XDDR_ISR_OFFSET);
 466
 467         if (payload[EVENT] == XPM_EVENT_ERROR_MASK_DDRMC_CR)
 468                 p->error_type = XDDR_ERR_TYPE_CE;
 469         if (payload[EVENT] == XPM_EVENT_ERROR_MASK_DDRMC_NCR)
 470                 p->error_type = XDDR_ERR_TYPE_UE;
 471
 472         if (get_error_info(priv))
 473                 return;
 474
 475         handle_error(mci, &priv->stat);
 476
 477         /* Unlock the PCSR registers */
 478         writel(PCSR_UNLOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 479
 480         /* Clear the ISR */
 481         writel(regval, priv->ddrmc_baseaddr + XDDR_ISR_OFFSET);
 482
 483         /* Lock the PCSR registers */
 484         writel(PCSR_LOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 485         edac_dbg(3, "Total error count CE %d UE %d\n",
 486                  priv->ce_cnt, priv->ue_cnt);
 487 }
 488
 489 /**
 490  * get_dwidth - Return the controller memory width.
 491  * @base:       DDR memory controller base address.
 492  *
 493  * Get the EDAC device type width appropriate for the controller
 494  * configuration.
 495  *
 496  * Return: a device type width enumeration.
 497  */
 498 static enum dev_type get_dwidth(const void __iomem *base)
 499 {
 500         enum dev_type dt;
 501         u32 regval;
 502         u32 width;
 503
 504         regval = readl(base + XDDR_REG_CONFIG0_OFFSET);
 505         width  = FIELD_GET(XDDR_REG_CONFIG0_BUS_WIDTH_MASK, regval);
 506
 507         switch (width) {
 508         case XDDR_BUS_WIDTH_16:
 509                 dt = DEV_X2;
 510                 break;
 511         case XDDR_BUS_WIDTH_32:
 512                 dt = DEV_X4;
 513                 break;
 514         case XDDR_BUS_WIDTH_64:
 515                 dt = DEV_X8;
 516                 break;
 517         default:
 518                 dt = DEV_UNKNOWN;
 519         }
 520
 521         return dt;
 522 }
 523
 524 /**
 525  * get_ecc_state - Return the controller ECC enable/disable status.
 526  * @base:       DDR memory controller base address.
 527  *
 528  * Get the ECC enable/disable status for the controller.
 529  *
 530  * Return: a ECC status boolean i.e true/false - enabled/disabled.
 531  */
 532 static bool get_ecc_state(void __iomem *base)
 533 {
 534         enum dev_type dt;
 535         u32 ecctype;
 536
 537         dt = get_dwidth(base);
 538         if (dt == DEV_UNKNOWN)
 539                 return false;
 540
 541         ecctype = readl(base + XDDR_REG_PINOUT_OFFSET);
 542         ecctype &= XDDR_REG_PINOUT_ECC_EN_MASK;
 543
 544         return !!ecctype;
 545 }
 546
 547 /**
 548  * get_memsize - Get the size of the attached memory device.
 549  * @priv:       DDR memory controller private instance data.
 550  *
 551  * Return: the memory size in bytes.
 552  */
 553 static u64 get_memsize(struct edac_priv *priv)
 554 {
 555         u32 regval;
 556         u64 size;
 557
 558         regval = readl(priv->ddrmc_baseaddr + XDDR_REG_CONFIG0_OFFSET);
 559         regval  = FIELD_GET(XDDR_REG_CONFIG0_SIZE_MASK, regval);
 560
 561         switch (regval) {
 562         case XILINX_DRAM_SIZE_4G:
 563                 size = 4U;      break;
 564         case XILINX_DRAM_SIZE_6G:
 565                 size = 6U;      break;
 566         case XILINX_DRAM_SIZE_8G:
 567                 size = 8U;      break;
 568         case XILINX_DRAM_SIZE_12G:
 569                 size = 12U;     break;
 570         case XILINX_DRAM_SIZE_16G:
 571                 size = 16U;     break;
 572         case XILINX_DRAM_SIZE_32G:
 573                 size = 32U;     break;
 574         /* Invalid configuration */
 575         default:
 576                 size = 0;       break;
 577         }
 578
 579         size *= SZ_1G;
 580         return size;
 581 }
 582
 583 /**
 584  * init_csrows - Initialize the csrow data.
 585  * @mci:        EDAC memory controller instance.
 586  *
 587  * Initialize the chip select rows associated with the EDAC memory
 588  * controller instance.
 589  */
 590 static void init_csrows(struct mem_ctl_info *mci)
 591 {
 592         struct edac_priv *priv = mci->pvt_info;
 593         struct csrow_info *csi;
 594         struct dimm_info *dimm;
 595         unsigned long size;
 596         u32 row;
 597         int ch;
 598
 599         size = get_memsize(priv);
 600         for (row = 0; row < mci->nr_csrows; row++) {
 601                 csi = mci->csrows[row];
 602                 for (ch = 0; ch < csi->nr_channels; ch++) {
 603                         dimm = csi->channels[ch]->dimm;
 604                         dimm->edac_mode = EDAC_SECDED;
 605                         dimm->mtype = MEM_DDR4;
 606                         dimm->nr_pages = (size >> PAGE_SHIFT) / csi->nr_channels;
 607                         dimm->grain = XDDR_EDAC_ERR_GRAIN;
 608                         dimm->dtype = get_dwidth(priv->ddrmc_baseaddr);
 609                 }
 610         }
 611 }
 612
 613 /**
 614  * mc_init - Initialize one driver instance.
 615  * @mci:        EDAC memory controller instance.
 616  * @pdev:       platform device.
 617  *
 618  * Perform initialization of the EDAC memory controller instance and
 619  * related driver-private data associated with the memory controller the
 620  * instance is bound to.
 621  */
 622 static void mc_init(struct mem_ctl_info *mci, struct platform_device *pdev)
 623 {
 624         mci->pdev = &pdev->dev;
 625         platform_set_drvdata(pdev, mci);
 626
 627         /* Initialize controller capabilities and configuration */
 628         mci->mtype_cap = MEM_FLAG_DDR4;
 629         mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED;
 630         mci->scrub_cap = SCRUB_HW_SRC;
 631         mci->scrub_mode = SCRUB_NONE;
 632
 633         mci->edac_cap = EDAC_FLAG_SECDED;
 634         mci->ctl_name = "xlnx_ddr_controller";
 635         mci->dev_name = dev_name(&pdev->dev);
 636         mci->mod_name = "xlnx_edac";
 637
 638         edac_op_state = EDAC_OPSTATE_INT;
 639
 640         init_csrows(mci);
 641 }
 642
 643 static void enable_intr(struct edac_priv *priv)
 644 {
 645         /* Unlock the PCSR registers */
 646         writel(PCSR_UNLOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 647
 648         /* Enable UE and CE Interrupts to support the interrupt case */
 649         writel(XDDR_IRQ_CE_MASK | XDDR_IRQ_UE_MASK,
 650                priv->ddrmc_baseaddr + XDDR_IRQ_EN_OFFSET);
 651
 652         writel(XDDR_IRQ_UE_MASK,
 653                priv->ddrmc_baseaddr + XDDR_IRQ1_EN_OFFSET);
 654         /* Lock the PCSR registers */
 655         writel(PCSR_LOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 656 }
 657
 658 static void disable_intr(struct edac_priv *priv)
 659 {
 660         /* Unlock the PCSR registers */
 661         writel(PCSR_UNLOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 662
 663         /* Disable UE/CE Interrupts */
 664         writel(XDDR_IRQ_CE_MASK | XDDR_IRQ_UE_MASK,
 665                priv->ddrmc_baseaddr + XDDR_IRQ_DIS_OFFSET);
 666
 667         /* Lock the PCSR registers */
 668         writel(PCSR_LOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 669 }
 670
 671 #define to_mci(k) container_of(k, struct mem_ctl_info, dev)
 672
 673 #ifdef CONFIG_EDAC_DEBUG
 674 /**
 675  * poison_setup - Update poison registers.
 676  * @priv:       DDR memory controller private instance data.
 677  *
 678  * Update poison registers as per DDR mapping upon write of the address
 679  * location the fault is injected.
 680  * Return: none.
 681  */
 682 static void poison_setup(struct edac_priv *priv)
 683 {
 684         u32 col = 0, row = 0, bank = 0, grp = 0, rank = 0, lrank = 0, ch = 0;
 685         u32 index, regval;
 686
 687         for (index = 0; index < XDDR_MAX_ROW_CNT; index++) {
 688                 row |= (((priv->err_inject_addr >> priv->row_bit[index]) &
 689                                                 BIT(0)) << index);
 690         }
 691
 692         for (index = 0; index < XDDR_MAX_COL_CNT; index++) {
 693                 col |= (((priv->err_inject_addr >> priv->col_bit[index]) &
 694                                                 BIT(0)) << index);
 695         }
 696
 697         for (index = 0; index < XDDR_MAX_BANK_CNT; index++) {
 698                 bank |= (((priv->err_inject_addr >> priv->bank_bit[index]) &
 699                                                 BIT(0)) << index);
 700         }
 701
 702         for (index = 0; index < XDDR_MAX_GRP_CNT; index++) {
 703                 grp |= (((priv->err_inject_addr >> priv->grp_bit[index]) &
 704                                                 BIT(0)) << index);
 705         }
 706
 707         for (index = 0; index < XDDR_MAX_RANK_CNT; index++) {
 708                 rank |= (((priv->err_inject_addr >> priv->rank_bit[index]) &
 709                                                 BIT(0)) << index);
 710         }
 711
 712         for (index = 0; index < XDDR_MAX_LRANK_CNT; index++) {
 713                 lrank |= (((priv->err_inject_addr >> priv->lrank_bit[index]) &
 714                                                 BIT(0)) << index);
 715         }
 716
 717         ch = (priv->err_inject_addr >> priv->ch_bit) & BIT(0);
 718         if (ch)
 719                 writel(0xFF, priv->ddrmc_baseaddr + ECCW1_FLIP_CTRL);
 720         else
 721                 writel(0xFF, priv->ddrmc_baseaddr + ECCW0_FLIP_CTRL);
 722
 723         writel(0, priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC12_OFFSET);
 724         writel(0, priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC13_OFFSET);
 725
 726         regval = row & XDDR_NOC_ROW_MATCH_MASK;
 727         regval |= FIELD_PREP(XDDR_NOC_COL_MATCH_MASK, col);
 728         regval |= FIELD_PREP(XDDR_NOC_BANK_MATCH_MASK, bank);
 729         regval |= FIELD_PREP(XDDR_NOC_GRP_MATCH_MASK, grp);
 730         writel(regval, priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC14_OFFSET);
 731
 732         regval = rank & XDDR_NOC_RANK_MATCH_MASK;
 733         regval |= FIELD_PREP(XDDR_NOC_LRANK_MATCH_MASK, lrank);
 734         regval |= FIELD_PREP(XDDR_NOC_CH_MATCH_MASK, ch);
 735         regval |= (XDDR_NOC_MOD_SEL_MASK | XDDR_NOC_MATCH_EN_MASK);
 736         writel(regval, priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC15_OFFSET);
 737 }
 738
 739 static void xddr_inject_data_ce_store(struct mem_ctl_info *mci, u8 ce_bitpos)
 740 {
 741         u32 ecc0_flip0, ecc1_flip0, ecc0_flip1, ecc1_flip1;
 742         struct edac_priv *priv = mci->pvt_info;
 743
 744         if (ce_bitpos < ECCW0_FLIP0_BITS) {
 745                 ecc0_flip0 = BIT(ce_bitpos);
 746                 ecc1_flip0 = BIT(ce_bitpos);
 747                 ecc0_flip1 = 0;
 748                 ecc1_flip1 = 0;
 749         } else {
 750                 ce_bitpos = ce_bitpos - ECCW0_FLIP0_BITS;
 751                 ecc0_flip1 = BIT(ce_bitpos);
 752                 ecc1_flip1 = BIT(ce_bitpos);
 753                 ecc0_flip0 = 0;
 754                 ecc1_flip0 = 0;
 755         }
 756
 757         writel(ecc0_flip0, priv->ddrmc_baseaddr + ECCW0_FLIP0_OFFSET);
 758         writel(ecc1_flip0, priv->ddrmc_baseaddr + ECCW1_FLIP0_OFFSET);
 759         writel(ecc0_flip1, priv->ddrmc_baseaddr + ECCW0_FLIP1_OFFSET);
 760         writel(ecc1_flip1, priv->ddrmc_baseaddr + ECCW1_FLIP1_OFFSET);
 761 }
 762
 763 /*
 764  * To inject a correctable error, the following steps are needed:
 765  *
 766  * - Write the correctable error bit position value:
 767  *      echo <bit_pos val> > /sys/kernel/debug/edac/<controller instance>/inject_ce
 768  *
 769  * poison_setup() derives the row, column, bank, group and rank and
 770  * writes to the ADEC registers based on the address given by the user.
 771  *
 772  * The ADEC12 and ADEC13 are mask registers; write 0 to make sure default
 773  * configuration is there and no addresses are masked.
 774  *
 775  * The row, column, bank, group and rank registers are written to the
 776  * match ADEC bit to generate errors at the particular address. ADEC14
 777  * and ADEC15 have the match bits.
 778  *
 779  * xddr_inject_data_ce_store() updates the ECC FLIP registers with the
 780  * bits to be corrupted based on the bit position given by the user.
 781  *
 782  * Upon doing a read to the address the errors are injected.
 783  */
 784 static ssize_t inject_data_ce_store(struct file *file, const char __user *data,
 785                                     size_t count, loff_t *ppos)
 786 {
 787         struct device *dev = file->private_data;
 788         struct mem_ctl_info *mci = to_mci(dev);
 789         struct edac_priv *priv = mci->pvt_info;
 790         u8 ce_bitpos;
 791         int ret;
 792
 793         ret = kstrtou8_from_user(data, count, 0, &ce_bitpos);
 794         if (ret)
 795                 return ret;
 796
 797         /* Unlock the PCSR registers */
 798         writel(PCSR_UNLOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 799         writel(PCSR_UNLOCK_VAL, priv->ddrmc_noc_baseaddr + XDDR_PCSR_OFFSET);
 800
 801         poison_setup(priv);
 802
 803         xddr_inject_data_ce_store(mci, ce_bitpos);
 804         ret = count;
 805
 806         /* Lock the PCSR registers */
 807         writel(PCSR_LOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 808         writel(PCSR_LOCK_VAL, priv->ddrmc_noc_baseaddr + XDDR_PCSR_OFFSET);
 809
 810         return ret;
 811 }
 812
 813 static const struct file_operations xddr_inject_ce_fops = {
 814         .open = simple_open,
 815         .write = inject_data_ce_store,
 816         .llseek = generic_file_llseek,
 817 };
 818
 819 static void xddr_inject_data_ue_store(struct mem_ctl_info *mci, u32 val0, u32 val1)
 820 {
 821         struct edac_priv *priv = mci->pvt_info;
 822
 823         writel(val0, priv->ddrmc_baseaddr + ECCW0_FLIP0_OFFSET);
 824         writel(val0, priv->ddrmc_baseaddr + ECCW0_FLIP1_OFFSET);
 825         writel(val1, priv->ddrmc_baseaddr + ECCW1_FLIP1_OFFSET);
 826         writel(val1, priv->ddrmc_baseaddr + ECCW1_FLIP1_OFFSET);
 827 }
 828
 829 /*
 830  * To inject an uncorrectable error, the following steps are needed:
 831  *      echo <bit_pos val> > /sys/kernel/debug/edac/<controller instance>/inject_ue
 832  *
 833  * poison_setup() derives the row, column, bank, group and rank and
 834  * writes to the ADEC registers based on the address given by the user.
 835  *
 836  * The ADEC12 and ADEC13 are mask registers; write 0 so that none of the
 837  * addresses are masked. The row, column, bank, group and rank registers
 838  * are written to the match ADEC bit to generate errors at the
 839  * particular address. ADEC14 and ADEC15 have the match bits.
 840  *
 841  * xddr_inject_data_ue_store() updates the ECC FLIP registers with the
 842  * bits to be corrupted based on the bit position given by the user. For
 843  * uncorrectable errors
 844  * 2 bit errors are injected.
 845  *
 846  * Upon doing a read to the address the errors are injected.
 847  */
 848 static ssize_t inject_data_ue_store(struct file *file, const char __user *data,
 849                                     size_t count, loff_t *ppos)
 850 {
 851         struct device *dev = file->private_data;
 852         struct mem_ctl_info *mci = to_mci(dev);
 853         struct edac_priv *priv = mci->pvt_info;
 854         char buf[6], *pbuf, *token[2];
 855         u32 val0 = 0, val1 = 0;
 856         u8 len, ue0, ue1;
 857         int i, ret;
 858
 859         len = min_t(size_t, count, sizeof(buf));
 860         if (copy_from_user(buf, data, len))
 861                 return -EFAULT;
 862
 863         buf[len] = '\0';
 864         pbuf = &buf[0];
 865         for (i = 0; i < NUM_UE_BITPOS; i++)
 866                 token[i] = strsep(&pbuf, ",");
 867
 868         ret = kstrtou8(token[0], 0, &ue0);
 869         if (ret)
 870                 return ret;
 871
 872         ret = kstrtou8(token[1], 0, &ue1);
 873         if (ret)
 874                 return ret;
 875
 876         if (ue0 < ECCW0_FLIP0_BITS) {
 877                 val0 = BIT(ue0);
 878         } else {
 879                 ue0 = ue0 - ECCW0_FLIP0_BITS;
 880                 val1 = BIT(ue0);
 881         }
 882
 883         if (ue1 < ECCW0_FLIP0_BITS) {
 884                 val0 |= BIT(ue1);
 885         } else {
 886                 ue1 = ue1 - ECCW0_FLIP0_BITS;
 887                 val1 |= BIT(ue1);
 888         }
 889
 890         /* Unlock the PCSR registers */
 891         writel(PCSR_UNLOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 892         writel(PCSR_UNLOCK_VAL, priv->ddrmc_noc_baseaddr + XDDR_PCSR_OFFSET);
 893
 894         poison_setup(priv);
 895
 896         xddr_inject_data_ue_store(mci, val0, val1);
 897
 898         /* Lock the PCSR registers */
 899         writel(PCSR_LOCK_VAL, priv->ddrmc_noc_baseaddr + XDDR_PCSR_OFFSET);
 900         writel(PCSR_LOCK_VAL, priv->ddrmc_baseaddr + XDDR_PCSR_OFFSET);
 901         return count;
 902 }
 903
 904 static const struct file_operations xddr_inject_ue_fops = {
 905         .open = simple_open,
 906         .write = inject_data_ue_store,
 907         .llseek = generic_file_llseek,
 908 };
 909
 910 static void create_debugfs_attributes(struct mem_ctl_info *mci)
 911 {
 912         struct edac_priv *priv = mci->pvt_info;
 913
 914         priv->debugfs = edac_debugfs_create_dir(mci->dev_name);
 915         if (!priv->debugfs)
 916                 return;
 917
 918         if (!edac_debugfs_create_file("inject_ce", 0200, priv->debugfs,
 919                                       &mci->dev, &xddr_inject_ce_fops)) {
 920                 debugfs_remove_recursive(priv->debugfs);
 921                 return;
 922         }
 923
 924         if (!edac_debugfs_create_file("inject_ue", 0200, priv->debugfs,
 925                                       &mci->dev, &xddr_inject_ue_fops)) {
 926                 debugfs_remove_recursive(priv->debugfs);
 927                 return;
 928         }
 929         debugfs_create_x64("address", 0600, priv->debugfs,
 930                            &priv->err_inject_addr);
 931         mci->debugfs = priv->debugfs;
 932 }
 933
 934 static inline void process_bit(struct edac_priv *priv, unsigned int start, u32 regval)
 935 {
 936         union edac_info rows;
 937
 938         rows.i  = regval;
 939         priv->row_bit[start]     = rows.row0;
 940         priv->row_bit[start + 1] = rows.row1;
 941         priv->row_bit[start + 2] = rows.row2;
 942         priv->row_bit[start + 3] = rows.row3;
 943         priv->row_bit[start + 4] = rows.row4;
 944 }
 945
 946 static void setup_row_address_map(struct edac_priv *priv)
 947 {
 948         u32 regval;
 949         union edac_info rows;
 950
 951         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC5_OFFSET);
 952         process_bit(priv, 0, regval);
 953
 954         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC6_OFFSET);
 955         process_bit(priv, 5, regval);
 956
 957         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC7_OFFSET);
 958         process_bit(priv, 10, regval);
 959
 960         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC8_OFFSET);
 961         rows.i  = regval;
 962
 963         priv->row_bit[15] = rows.row0;
 964         priv->row_bit[16] = rows.row1;
 965         priv->row_bit[17] = rows.row2;
 966 }
 967
 968 static void setup_column_address_map(struct edac_priv *priv)
 969 {
 970         u32 regval;
 971         union edac_info cols;
 972
 973         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC8_OFFSET);
 974         priv->col_bit[0] = FIELD_GET(MASK_24, regval);
 975
 976         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC9_OFFSET);
 977         cols.i  = regval;
 978         priv->col_bit[1] = cols.col1;
 979         priv->col_bit[2] = cols.col2;
 980         priv->col_bit[3] = cols.col3;
 981         priv->col_bit[4] = cols.col4;
 982         priv->col_bit[5] = cols.col5;
 983
 984         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC10_OFFSET);
 985         cols.i  = regval;
 986         priv->col_bit[6] = cols.col1;
 987         priv->col_bit[7] = cols.col2;
 988         priv->col_bit[8] = cols.col3;
 989         priv->col_bit[9] = cols.col4;
 990 }
 991
 992 static void setup_bank_grp_ch_address_map(struct edac_priv *priv)
 993 {
 994         u32 regval;
 995
 996         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC10_OFFSET);
 997         priv->bank_bit[0] = FIELD_GET(MASK_24, regval);
 998
 999         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC11_OFFSET);
1000         priv->bank_bit[1] = (regval & MASK_0);
1001         priv->grp_bit[0] = FIELD_GET(GRP_0_MASK, regval);
1002         priv->grp_bit[1] = FIELD_GET(GRP_1_MASK, regval);
1003         priv->ch_bit = FIELD_GET(CH_0_MASK, regval);
1004 }
1005
1006 static void setup_rank_lrank_address_map(struct edac_priv *priv)
1007 {
1008         u32 regval;
1009
1010         regval = readl(priv->ddrmc_noc_baseaddr + XDDR_NOC_REG_ADEC4_OFFSET);
1011         priv->rank_bit[0] = (regval & MASK_0);
1012         priv->rank_bit[1] = FIELD_GET(RANK_1_MASK, regval);
1013         priv->lrank_bit[0] = FIELD_GET(LRANK_0_MASK, regval);
1014         priv->lrank_bit[1] = FIELD_GET(LRANK_1_MASK, regval);
1015         priv->lrank_bit[2] = FIELD_GET(MASK_24, regval);
1016 }
1017
1018 /**
1019  * setup_address_map - Set Address Map by querying ADDRMAP registers.
1020  * @priv:       DDR memory controller private instance data.
1021  *
1022  * Set Address Map by querying ADDRMAP registers.
1023  *
1024  * Return: none.
1025  */
1026 static void setup_address_map(struct edac_priv *priv)
1027 {
1028         setup_row_address_map(priv);
1029
1030         setup_column_address_map(priv);
1031
1032         setup_bank_grp_ch_address_map(priv);
1033
1034         setup_rank_lrank_address_map(priv);
1035 }
1036 #endif /* CONFIG_EDAC_DEBUG */
1037
1038 static const struct of_device_id xlnx_edac_match[] = {
1039         { .compatible = "xlnx,versal-ddrmc", },
1040         {
1041                 /* end of table */
1042         }
1043 };
1044
1045 MODULE_DEVICE_TABLE(of, xlnx_edac_match);
1046 static u32 emif_get_id(struct device_node *node)
1047 {
1048         u32 addr, my_addr, my_id = 0;
1049         struct device_node *np;
1050         const __be32 *addrp;
1051
1052         addrp = of_get_address(node, 0, NULL, NULL);
1053         my_addr = (u32)of_translate_address(node, addrp);
1054
1055         for_each_matching_node(np, xlnx_edac_match) {
1056                 if (np == node)
1057                         continue;
1058
1059                 addrp = of_get_address(np, 0, NULL, NULL);
1060                 addr = (u32)of_translate_address(np, addrp);
1061
1062                 edac_printk(KERN_INFO, EDAC_MC,
1063                             "addr=%x, my_addr=%x\n",
1064                             addr, my_addr);
1065
1066                 if (addr < my_addr)
1067                         my_id++;
1068         }
1069
1070         return my_id;
1071 }
1072
1073 static int mc_probe(struct platform_device *pdev)
1074 {
1075         void __iomem *ddrmc_baseaddr, *ddrmc_noc_baseaddr;
1076         struct edac_mc_layer layers[2];
1077         struct mem_ctl_info *mci;
1078         u8 num_chans, num_csrows;
1079         struct edac_priv *priv;
1080         u32 edac_mc_id, regval;
1081         int rc;
1082
1083         ddrmc_baseaddr = devm_platform_ioremap_resource_byname(pdev, "base");
1084         if (IS_ERR(ddrmc_baseaddr))
1085                 return PTR_ERR(ddrmc_baseaddr);
1086
1087         ddrmc_noc_baseaddr = devm_platform_ioremap_resource_byname(pdev, "noc");
1088         if (IS_ERR(ddrmc_noc_baseaddr))
1089                 return PTR_ERR(ddrmc_noc_baseaddr);
1090
1091         if (!get_ecc_state(ddrmc_baseaddr))
1092                 return -ENXIO;
1093
1094         /* Allocate ID number for the EMIF controller */
1095         edac_mc_id = emif_get_id(pdev->dev.of_node);
1096
1097         regval = readl(ddrmc_baseaddr + XDDR_REG_CONFIG0_OFFSET);
1098         num_chans = FIELD_GET(XDDR_REG_CONFIG0_NUM_CHANS_MASK, regval);
1099         num_chans++;
1100
1101         num_csrows = FIELD_GET(XDDR_REG_CONFIG0_NUM_RANKS_MASK, regval);
1102         num_csrows *= 2;
1103         if (!num_csrows)
1104                 num_csrows = 1;
1105
1106         layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
1107         layers[0].size = num_csrows;
1108         layers[0].is_virt_csrow = true;
1109         layers[1].type = EDAC_MC_LAYER_CHANNEL;
1110         layers[1].size = num_chans;
1111         layers[1].is_virt_csrow = false;
1112
1113         mci = edac_mc_alloc(edac_mc_id, ARRAY_SIZE(layers), layers,
1114                             sizeof(struct edac_priv));
1115         if (!mci) {
1116                 edac_printk(KERN_ERR, EDAC_MC,
1117                             "Failed memory allocation for mc instance\n");
1118                 return -ENOMEM;
1119         }
1120
1121         priv = mci->pvt_info;
1122         priv->ddrmc_baseaddr = ddrmc_baseaddr;
1123         priv->ddrmc_noc_baseaddr = ddrmc_noc_baseaddr;
1124         priv->ce_cnt = 0;
1125         priv->ue_cnt = 0;
1126         priv->mc_id = edac_mc_id;
1127
1128         mc_init(mci, pdev);
1129
1130         rc = edac_mc_add_mc(mci);
1131         if (rc) {
1132                 edac_printk(KERN_ERR, EDAC_MC,
1133                             "Failed to register with EDAC core\n");
1134                 goto free_edac_mc;
1135         }
1136
1137         rc = xlnx_register_event(PM_NOTIFY_CB, VERSAL_EVENT_ERROR_PMC_ERR1,
1138                                  XPM_EVENT_ERROR_MASK_DDRMC_CR | XPM_EVENT_ERROR_MASK_DDRMC_NCR |
1139                                  XPM_EVENT_ERROR_MASK_NOC_CR | XPM_EVENT_ERROR_MASK_NOC_NCR,
1140                                  false, err_callback, mci);
1141         if (rc) {
1142                 if (rc == -EACCES)
1143                         rc = -EPROBE_DEFER;
1144
1145                 goto del_mc;
1146         }
1147
1148 #ifdef CONFIG_EDAC_DEBUG
1149         create_debugfs_attributes(mci);
1150         setup_address_map(priv);
1151 #endif
1152         enable_intr(priv);
1153         return rc;
1154
1155 del_mc:
1156         edac_mc_del_mc(&pdev->dev);
1157 free_edac_mc:
1158         edac_mc_free(mci);
1159
1160         return rc;
1161 }
1162
1163 static void mc_remove(struct platform_device *pdev)
1164 {
1165         struct mem_ctl_info *mci = platform_get_drvdata(pdev);
1166         struct edac_priv *priv = mci->pvt_info;
1167
1168         disable_intr(priv);
1169
1170 #ifdef CONFIG_EDAC_DEBUG
1171         debugfs_remove_recursive(priv->debugfs);
1172 #endif
1173
1174         xlnx_unregister_event(PM_NOTIFY_CB, VERSAL_EVENT_ERROR_PMC_ERR1,
1175                               XPM_EVENT_ERROR_MASK_DDRMC_CR |
1176                               XPM_EVENT_ERROR_MASK_NOC_CR |
1177                               XPM_EVENT_ERROR_MASK_NOC_NCR |
1178                               XPM_EVENT_ERROR_MASK_DDRMC_NCR, err_callback, mci);
1179         edac_mc_del_mc(&pdev->dev);
1180         edac_mc_free(mci);
1181 }
1182
1183 static struct platform_driver xilinx_ddr_edac_mc_driver = {
1184         .driver = {
1185                 .name = "xilinx-ddrmc-edac",
1186                 .of_match_table = xlnx_edac_match,
1187         },
1188         .probe = mc_probe,
1189         .remove_new = mc_remove,
1190 };
1191
1192 module_platform_driver(xilinx_ddr_edac_mc_driver);
1193
1194 MODULE_AUTHOR("AMD Inc");
1195 MODULE_DESCRIPTION("Xilinx DDRMC ECC driver");
1196 MODULE_LICENSE("GPL");