drivers/edac/synopsys_edac.c

   1 /*
   2  * Synopsys DDR ECC Driver
   3  * This driver is based on ppc4xx_edac.c drivers
   4  *
   5  * Copyright (C) 2012 - 2014 Xilinx, Inc.
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation, either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * This file is subject to the terms and conditions of the GNU General Public
  18  * License.  See the file "COPYING" in the main directory of this archive
  19  * for more details
  20  */
  21
  22 #include <linux/edac.h>
  23 #include <linux/module.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/of.h>
  27 #include <linux/of_device.h>
  28
  29 #include "edac_module.h"
  30
  31 /* Number of cs_rows needed per memory controller */
  32 #define SYNPS_EDAC_NR_CSROWS            1
  33
  34 /* Number of channels per memory controller */
  35 #define SYNPS_EDAC_NR_CHANS             1
  36
  37 /* Granularity of reported error in bytes */
  38 #define SYNPS_EDAC_ERR_GRAIN            1
  39
  40 #define SYNPS_EDAC_MSG_SIZE             256
  41
  42 #define SYNPS_EDAC_MOD_STRING           "synps_edac"
  43 #define SYNPS_EDAC_MOD_VER              "1"
  44
  45 /* Synopsys DDR memory controller registers that are relevant to ECC */
  46 #define CTRL_OFST                       0x0
  47 #define T_ZQ_OFST                       0xA4
  48
  49 /* ECC control register */
  50 #define ECC_CTRL_OFST                   0xC4
  51 /* ECC log register */
  52 #define CE_LOG_OFST                     0xC8
  53 /* ECC address register */
  54 #define CE_ADDR_OFST                    0xCC
  55 /* ECC data[31:0] register */
  56 #define CE_DATA_31_0_OFST               0xD0
  57
  58 /* Uncorrectable error info registers */
  59 #define UE_LOG_OFST                     0xDC
  60 #define UE_ADDR_OFST                    0xE0
  61 #define UE_DATA_31_0_OFST               0xE4
  62
  63 #define STAT_OFST                       0xF0
  64 #define SCRUB_OFST                      0xF4
  65
  66 /* Control register bit field definitions */
  67 #define CTRL_BW_MASK                    0xC
  68 #define CTRL_BW_SHIFT                   2
  69
  70 #define DDRCTL_WDTH_16                  1
  71 #define DDRCTL_WDTH_32                  0
  72
  73 /* ZQ register bit field definitions */
  74 #define T_ZQ_DDRMODE_MASK               0x2
  75
  76 /* ECC control register bit field definitions */
  77 #define ECC_CTRL_CLR_CE_ERR             0x2
  78 #define ECC_CTRL_CLR_UE_ERR             0x1
  79
  80 /* ECC correctable/uncorrectable error log register definitions */
  81 #define LOG_VALID                       0x1
  82 #define CE_LOG_BITPOS_MASK              0xFE
  83 #define CE_LOG_BITPOS_SHIFT             1
  84
  85 /* ECC correctable/uncorrectable error address register definitions */
  86 #define ADDR_COL_MASK                   0xFFF
  87 #define ADDR_ROW_MASK                   0xFFFF000
  88 #define ADDR_ROW_SHIFT                  12
  89 #define ADDR_BANK_MASK                  0x70000000
  90 #define ADDR_BANK_SHIFT                 28
  91
  92 /* ECC statistic register definitions */
  93 #define STAT_UECNT_MASK                 0xFF
  94 #define STAT_CECNT_MASK                 0xFF00
  95 #define STAT_CECNT_SHIFT                8
  96
  97 /* ECC scrub register definitions */
  98 #define SCRUB_MODE_MASK                 0x7
  99 #define SCRUB_MODE_SECDED               0x4
 100
 101 /* DDR ECC Quirks */
 102 #define DDR_ECC_INTR_SUPPORT            BIT(0)
 103 #define DDR_ECC_DATA_POISON_SUPPORT     BIT(1)
 104
 105 /* ZynqMP Enhanced DDR memory controller registers that are relevant to ECC */
 106 /* ECC Configuration Registers */
 107 #define ECC_CFG0_OFST                   0x70
 108 #define ECC_CFG1_OFST                   0x74
 109
 110 /* ECC Status Register */
 111 #define ECC_STAT_OFST                   0x78
 112
 113 /* ECC Clear Register */
 114 #define ECC_CLR_OFST                    0x7C
 115
 116 /* ECC Error count Register */
 117 #define ECC_ERRCNT_OFST                 0x80
 118
 119 /* ECC Corrected Error Address Register */
 120 #define ECC_CEADDR0_OFST                0x84
 121 #define ECC_CEADDR1_OFST                0x88
 122
 123 /* ECC Syndrome Registers */
 124 #define ECC_CSYND0_OFST                 0x8C
 125 #define ECC_CSYND1_OFST                 0x90
 126 #define ECC_CSYND2_OFST                 0x94
 127
 128 /* ECC Bit Mask0 Address Register */
 129 #define ECC_BITMASK0_OFST               0x98
 130 #define ECC_BITMASK1_OFST               0x9C
 131 #define ECC_BITMASK2_OFST               0xA0
 132
 133 /* ECC UnCorrected Error Address Register */
 134 #define ECC_UEADDR0_OFST                0xA4
 135 #define ECC_UEADDR1_OFST                0xA8
 136
 137 /* ECC Syndrome Registers */
 138 #define ECC_UESYND0_OFST                0xAC
 139 #define ECC_UESYND1_OFST                0xB0
 140 #define ECC_UESYND2_OFST                0xB4
 141
 142 /* ECC Poison Address Reg */
 143 #define ECC_POISON0_OFST                0xB8
 144 #define ECC_POISON1_OFST                0xBC
 145
 146 #define ECC_ADDRMAP0_OFFSET             0x200
 147
 148 /* Control register bitfield definitions */
 149 #define ECC_CTRL_BUSWIDTH_MASK          0x3000
 150 #define ECC_CTRL_BUSWIDTH_SHIFT         12
 151 #define ECC_CTRL_CLR_CE_ERRCNT          BIT(2)
 152 #define ECC_CTRL_CLR_UE_ERRCNT          BIT(3)
 153
 154 /* DDR Control Register width definitions  */
 155 #define DDRCTL_EWDTH_16                 2
 156 #define DDRCTL_EWDTH_32                 1
 157 #define DDRCTL_EWDTH_64                 0
 158
 159 /* ECC status register definitions */
 160 #define ECC_STAT_UECNT_MASK             0xF0000
 161 #define ECC_STAT_UECNT_SHIFT            16
 162 #define ECC_STAT_CECNT_MASK             0xF00
 163 #define ECC_STAT_CECNT_SHIFT            8
 164 #define ECC_STAT_BITNUM_MASK            0x7F
 165
 166 /* DDR QOS Interrupt register definitions */
 167 #define DDR_QOS_IRQ_STAT_OFST           0x20200
 168 #define DDR_QOSUE_MASK                  0x4
 169 #define DDR_QOSCE_MASK                  0x2
 170 #define ECC_CE_UE_INTR_MASK             0x6
 171 #define DDR_QOS_IRQ_EN_OFST             0x20208
 172 #define DDR_QOS_IRQ_DB_OFST             0x2020C
 173
 174 /* ECC Corrected Error Register Mask and Shifts*/
 175 #define ECC_CEADDR0_RW_MASK             0x3FFFF
 176 #define ECC_CEADDR0_RNK_MASK            BIT(24)
 177 #define ECC_CEADDR1_BNKGRP_MASK         0x3000000
 178 #define ECC_CEADDR1_BNKNR_MASK          0x70000
 179 #define ECC_CEADDR1_BLKNR_MASK          0xFFF
 180 #define ECC_CEADDR1_BNKGRP_SHIFT        24
 181 #define ECC_CEADDR1_BNKNR_SHIFT         16
 182
 183 /* ECC Poison register shifts */
 184 #define ECC_POISON0_RANK_SHIFT          24
 185 #define ECC_POISON0_RANK_MASK           BIT(24)
 186 #define ECC_POISON0_COLUMN_SHIFT        0
 187 #define ECC_POISON0_COLUMN_MASK         0xFFF
 188 #define ECC_POISON1_BG_SHIFT            28
 189 #define ECC_POISON1_BG_MASK             0x30000000
 190 #define ECC_POISON1_BANKNR_SHIFT        24
 191 #define ECC_POISON1_BANKNR_MASK         0x7000000
 192 #define ECC_POISON1_ROW_SHIFT           0
 193 #define ECC_POISON1_ROW_MASK            0x3FFFF
 194
 195 /* DDR Memory type defines */
 196 #define MEM_TYPE_DDR3                   0x1
 197 #define MEM_TYPE_LPDDR3                 0x8
 198 #define MEM_TYPE_DDR2                   0x4
 199 #define MEM_TYPE_DDR4                   0x10
 200 #define MEM_TYPE_LPDDR4                 0x20
 201
 202 /* DDRC Software control register */
 203 #define DDRC_SWCTL                      0x320
 204
 205 /* DDRC ECC CE & UE poison mask */
 206 #define ECC_CEPOISON_MASK               0x3
 207 #define ECC_UEPOISON_MASK               0x1
 208
 209 /* DDRC Device config masks */
 210 #define DDRC_MSTR_CFG_MASK              0xC0000000
 211 #define DDRC_MSTR_CFG_SHIFT             30
 212 #define DDRC_MSTR_CFG_X4_MASK           0x0
 213 #define DDRC_MSTR_CFG_X8_MASK           0x1
 214 #define DDRC_MSTR_CFG_X16_MASK          0x2
 215 #define DDRC_MSTR_CFG_X32_MASK          0x3
 216
 217 #define DDR_MAX_ROW_SHIFT               18
 218 #define DDR_MAX_COL_SHIFT               14
 219 #define DDR_MAX_BANK_SHIFT              3
 220 #define DDR_MAX_BANKGRP_SHIFT           2
 221
 222 #define ROW_MAX_VAL_MASK                0xF
 223 #define COL_MAX_VAL_MASK                0xF
 224 #define BANK_MAX_VAL_MASK               0x1F
 225 #define BANKGRP_MAX_VAL_MASK            0x1F
 226 #define RANK_MAX_VAL_MASK               0x1F
 227
 228 #define ROW_B0_BASE                     6
 229 #define ROW_B1_BASE                     7
 230 #define ROW_B2_BASE                     8
 231 #define ROW_B3_BASE                     9
 232 #define ROW_B4_BASE                     10
 233 #define ROW_B5_BASE                     11
 234 #define ROW_B6_BASE                     12
 235 #define ROW_B7_BASE                     13
 236 #define ROW_B8_BASE                     14
 237 #define ROW_B9_BASE                     15
 238 #define ROW_B10_BASE                    16
 239 #define ROW_B11_BASE                    17
 240 #define ROW_B12_BASE                    18
 241 #define ROW_B13_BASE                    19
 242 #define ROW_B14_BASE                    20
 243 #define ROW_B15_BASE                    21
 244 #define ROW_B16_BASE                    22
 245 #define ROW_B17_BASE                    23
 246
 247 #define COL_B2_BASE                     2
 248 #define COL_B3_BASE                     3
 249 #define COL_B4_BASE                     4
 250 #define COL_B5_BASE                     5
 251 #define COL_B6_BASE                     6
 252 #define COL_B7_BASE                     7
 253 #define COL_B8_BASE                     8
 254 #define COL_B9_BASE                     9
 255 #define COL_B10_BASE                    10
 256 #define COL_B11_BASE                    11
 257 #define COL_B12_BASE                    12
 258 #define COL_B13_BASE                    13
 259
 260 #define BANK_B0_BASE                    2
 261 #define BANK_B1_BASE                    3
 262 #define BANK_B2_BASE                    4
 263
 264 #define BANKGRP_B0_BASE                 2
 265 #define BANKGRP_B1_BASE                 3
 266
 267 #define RANK_B0_BASE                    6
 268
 269 /**
 270  * struct ecc_error_info - ECC error log information.
 271  * @row:        Row number.
 272  * @col:        Column number.
 273  * @bank:       Bank number.
 274  * @bitpos:     Bit position.
 275  * @data:       Data causing the error.
 276  * @bankgrpnr:  Bank group number.
 277  * @blknr:      Block number.
 278  */
 279 struct ecc_error_info {
 280         u32 row;
 281         u32 col;
 282         u32 bank;
 283         u32 bitpos;
 284         u32 data;
 285         u32 bankgrpnr;
 286         u32 blknr;
 287 };
 288
 289 /**
 290  * struct synps_ecc_status - ECC status information to report.
 291  * @ce_cnt:     Correctable error count.
 292  * @ue_cnt:     Uncorrectable error count.
 293  * @ceinfo:     Correctable error log information.
 294  * @ueinfo:     Uncorrectable error log information.
 295  */
 296 struct synps_ecc_status {
 297         u32 ce_cnt;
 298         u32 ue_cnt;
 299         struct ecc_error_info ceinfo;
 300         struct ecc_error_info ueinfo;
 301 };
 302
 303 /**
 304  * struct synps_edac_priv - DDR memory controller private instance data.
 305  * @baseaddr:           Base address of the DDR controller.
 306  * @message:            Buffer for framing the event specific info.
 307  * @stat:               ECC status information.
 308  * @p_data:             Platform data.
 309  * @ce_cnt:             Correctable Error count.
 310  * @ue_cnt:             Uncorrectable Error count.
 311  * @poison_addr:        Data poison address.
 312  * @row_shift:          Bit shifts for row bit.
 313  * @col_shift:          Bit shifts for column bit.
 314  * @bank_shift:         Bit shifts for bank bit.
 315  * @bankgrp_shift:      Bit shifts for bank group bit.
 316  * @rank_shift:         Bit shifts for rank bit.
 317  */
 318 struct synps_edac_priv {
 319         void __iomem *baseaddr;
 320         char message[SYNPS_EDAC_MSG_SIZE];
 321         struct synps_ecc_status stat;
 322         const struct synps_platform_data *p_data;
 323         u32 ce_cnt;
 324         u32 ue_cnt;
 325 #ifdef CONFIG_EDAC_DEBUG
 326         ulong poison_addr;
 327         u32 row_shift[18];
 328         u32 col_shift[14];
 329         u32 bank_shift[3];
 330         u32 bankgrp_shift[2];
 331         u32 rank_shift[1];
 332 #endif
 333 };
 334
 335 /**
 336  * struct synps_platform_data -  synps platform data structure.
 337  * @get_error_info:     Get EDAC error info.
 338  * @get_mtype:          Get mtype.
 339  * @get_dtype:          Get dtype.
 340  * @get_ecc_state:      Get ECC state.
 341  * @quirks:             To differentiate IPs.
 342  */
 343 struct synps_platform_data {
 344         int (*get_error_info)(struct synps_edac_priv *priv);
 345         enum mem_type (*get_mtype)(const void __iomem *base);
 346         enum dev_type (*get_dtype)(const void __iomem *base);
 347         bool (*get_ecc_state)(void __iomem *base);
 348         int quirks;
 349 };
 350
 351 /**
 352  * zynq_get_error_info - Get the current ECC error info.
 353  * @priv:       DDR memory controller private instance data.
 354  *
 355  * Return: one if there is no error, otherwise zero.
 356  */
 357 static int zynq_get_error_info(struct synps_edac_priv *priv)
 358 {
 359         struct synps_ecc_status *p;
 360         u32 regval, clearval = 0;
 361         void __iomem *base;
 362
 363         base = priv->baseaddr;
 364         p = &priv->stat;
 365
 366         regval = readl(base + STAT_OFST);
 367         if (!regval)
 368                 return 1;
 369
 370         p->ce_cnt = (regval & STAT_CECNT_MASK) >> STAT_CECNT_SHIFT;
 371         p->ue_cnt = regval & STAT_UECNT_MASK;
 372
 373         regval = readl(base + CE_LOG_OFST);
 374         if (!(p->ce_cnt && (regval & LOG_VALID)))
 375                 goto ue_err;
 376
 377         p->ceinfo.bitpos = (regval & CE_LOG_BITPOS_MASK) >> CE_LOG_BITPOS_SHIFT;
 378         regval = readl(base + CE_ADDR_OFST);
 379         p->ceinfo.row = (regval & ADDR_ROW_MASK) >> ADDR_ROW_SHIFT;
 380         p->ceinfo.col = regval & ADDR_COL_MASK;
 381         p->ceinfo.bank = (regval & ADDR_BANK_MASK) >> ADDR_BANK_SHIFT;
 382         p->ceinfo.data = readl(base + CE_DATA_31_0_OFST);
 383         edac_dbg(3, "CE bit position: %d data: %d\n", p->ceinfo.bitpos,
 384                  p->ceinfo.data);
 385         clearval = ECC_CTRL_CLR_CE_ERR;
 386
 387 ue_err:
 388         regval = readl(base + UE_LOG_OFST);
 389         if (!(p->ue_cnt && (regval & LOG_VALID)))
 390                 goto out;
 391
 392         regval = readl(base + UE_ADDR_OFST);
 393         p->ueinfo.row = (regval & ADDR_ROW_MASK) >> ADDR_ROW_SHIFT;
 394         p->ueinfo.col = regval & ADDR_COL_MASK;
 395         p->ueinfo.bank = (regval & ADDR_BANK_MASK) >> ADDR_BANK_SHIFT;
 396         p->ueinfo.data = readl(base + UE_DATA_31_0_OFST);
 397         clearval |= ECC_CTRL_CLR_UE_ERR;
 398
 399 out:
 400         writel(clearval, base + ECC_CTRL_OFST);
 401         writel(0x0, base + ECC_CTRL_OFST);
 402
 403         return 0;
 404 }
 405
 406 /**
 407  * zynqmp_get_error_info - Get the current ECC error info.
 408  * @priv:       DDR memory controller private instance data.
 409  *
 410  * Return: one if there is no error otherwise returns zero.
 411  */
 412 static int zynqmp_get_error_info(struct synps_edac_priv *priv)
 413 {
 414         struct synps_ecc_status *p;
 415         u32 regval, clearval = 0;
 416         void __iomem *base;
 417
 418         base = priv->baseaddr;
 419         p = &priv->stat;
 420
 421         regval = readl(base + ECC_STAT_OFST);
 422         if (!regval)
 423                 return 1;
 424
 425         p->ce_cnt = (regval & ECC_STAT_CECNT_MASK) >> ECC_STAT_CECNT_SHIFT;
 426         p->ue_cnt = (regval & ECC_STAT_UECNT_MASK) >> ECC_STAT_UECNT_SHIFT;
 427         if (!p->ce_cnt)
 428                 goto ue_err;
 429
 430         p->ceinfo.bitpos = (regval & ECC_STAT_BITNUM_MASK);
 431
 432         regval = readl(base + ECC_CEADDR0_OFST);
 433         p->ceinfo.row = (regval & ECC_CEADDR0_RW_MASK);
 434         regval = readl(base + ECC_CEADDR1_OFST);
 435         p->ceinfo.bank = (regval & ECC_CEADDR1_BNKNR_MASK) >>
 436                                         ECC_CEADDR1_BNKNR_SHIFT;
 437         p->ceinfo.bankgrpnr = (regval & ECC_CEADDR1_BNKGRP_MASK) >>
 438                                         ECC_CEADDR1_BNKGRP_SHIFT;
 439         p->ceinfo.blknr = (regval & ECC_CEADDR1_BLKNR_MASK);
 440         p->ceinfo.data = readl(base + ECC_CSYND0_OFST);
 441         edac_dbg(2, "ECCCSYN0: 0x%08X ECCCSYN1: 0x%08X ECCCSYN2: 0x%08X\n",
 442                  readl(base + ECC_CSYND0_OFST), readl(base + ECC_CSYND1_OFST),
 443                  readl(base + ECC_CSYND2_OFST));
 444 ue_err:
 445         if (!p->ue_cnt)
 446                 goto out;
 447
 448         regval = readl(base + ECC_UEADDR0_OFST);
 449         p->ueinfo.row = (regval & ECC_CEADDR0_RW_MASK);
 450         regval = readl(base + ECC_UEADDR1_OFST);
 451         p->ueinfo.bankgrpnr = (regval & ECC_CEADDR1_BNKGRP_MASK) >>
 452                                         ECC_CEADDR1_BNKGRP_SHIFT;
 453         p->ueinfo.bank = (regval & ECC_CEADDR1_BNKNR_MASK) >>
 454                                         ECC_CEADDR1_BNKNR_SHIFT;
 455         p->ueinfo.blknr = (regval & ECC_CEADDR1_BLKNR_MASK);
 456         p->ueinfo.data = readl(base + ECC_UESYND0_OFST);
 457 out:
 458         clearval = ECC_CTRL_CLR_CE_ERR | ECC_CTRL_CLR_CE_ERRCNT;
 459         clearval |= ECC_CTRL_CLR_UE_ERR | ECC_CTRL_CLR_UE_ERRCNT;
 460         writel(clearval, base + ECC_CLR_OFST);
 461         writel(0x0, base + ECC_CLR_OFST);
 462
 463         return 0;
 464 }
 465
 466 /**
 467  * handle_error - Handle Correctable and Uncorrectable errors.
 468  * @mci:        EDAC memory controller instance.
 469  * @p:          Synopsys ECC status structure.
 470  *
 471  * Handles ECC correctable and uncorrectable errors.
 472  */
 473 static void handle_error(struct mem_ctl_info *mci, struct synps_ecc_status *p)
 474 {
 475         struct synps_edac_priv *priv = mci->pvt_info;
 476         struct ecc_error_info *pinf;
 477
 478         if (p->ce_cnt) {
 479                 pinf = &p->ceinfo;
 480                 if (priv->p_data->quirks & DDR_ECC_INTR_SUPPORT) {
 481                         snprintf(priv->message, SYNPS_EDAC_MSG_SIZE,
 482                                  "DDR ECC error type:%s Row %d Bank %d BankGroup Number %d Block Number %d Bit Position: %d Data: 0x%08x",
 483                                  "CE", pinf->row, pinf->bank,
 484                                  pinf->bankgrpnr, pinf->blknr,
 485                                  pinf->bitpos, pinf->data);
 486                 } else {
 487                         snprintf(priv->message, SYNPS_EDAC_MSG_SIZE,
 488                                  "DDR ECC error type:%s Row %d Bank %d Col %d Bit Position: %d Data: 0x%08x",
 489                                  "CE", pinf->row, pinf->bank, pinf->col,
 490                                  pinf->bitpos, pinf->data);
 491                 }
 492
 493                 edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci,
 494                                      p->ce_cnt, 0, 0, 0, 0, 0, -1,
 495                                      priv->message, "");
 496         }
 497
 498         if (p->ue_cnt) {
 499                 pinf = &p->ueinfo;
 500                 if (priv->p_data->quirks & DDR_ECC_INTR_SUPPORT) {
 501                         snprintf(priv->message, SYNPS_EDAC_MSG_SIZE,
 502                                  "DDR ECC error type :%s Row %d Bank %d BankGroup Number %d Block Number %d",
 503                                  "UE", pinf->row, pinf->bank,
 504                                  pinf->bankgrpnr, pinf->blknr);
 505                 } else {
 506                         snprintf(priv->message, SYNPS_EDAC_MSG_SIZE,
 507                                  "DDR ECC error type :%s Row %d Bank %d Col %d ",
 508                                  "UE", pinf->row, pinf->bank, pinf->col);
 509                 }
 510
 511                 edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci,
 512                                      p->ue_cnt, 0, 0, 0, 0, 0, -1,
 513                                      priv->message, "");
 514         }
 515
 516         memset(p, 0, sizeof(*p));
 517 }
 518
 519 /**
 520  * intr_handler - Interrupt Handler for ECC interrupts.
 521  * @irq:        IRQ number.
 522  * @dev_id:     Device ID.
 523  *
 524  * Return: IRQ_NONE, if interrupt not set or IRQ_HANDLED otherwise.
 525  */
 526 static irqreturn_t intr_handler(int irq, void *dev_id)
 527 {
 528         const struct synps_platform_data *p_data;
 529         struct mem_ctl_info *mci = dev_id;
 530         struct synps_edac_priv *priv;
 531         int status, regval;
 532
 533         priv = mci->pvt_info;
 534         p_data = priv->p_data;
 535
 536         regval = readl(priv->baseaddr + DDR_QOS_IRQ_STAT_OFST);
 537         regval &= (DDR_QOSCE_MASK | DDR_QOSUE_MASK);
 538         if (!(regval & ECC_CE_UE_INTR_MASK))
 539                 return IRQ_NONE;
 540
 541         status = p_data->get_error_info(priv);
 542         if (status)
 543                 return IRQ_NONE;
 544
 545         priv->ce_cnt += priv->stat.ce_cnt;
 546         priv->ue_cnt += priv->stat.ue_cnt;
 547         handle_error(mci, &priv->stat);
 548
 549         edac_dbg(3, "Total error count CE %d UE %d\n",
 550                  priv->ce_cnt, priv->ue_cnt);
 551         writel(regval, priv->baseaddr + DDR_QOS_IRQ_STAT_OFST);
 552         return IRQ_HANDLED;
 553 }
 554
 555 /**
 556  * check_errors - Check controller for ECC errors.
 557  * @mci:        EDAC memory controller instance.
 558  *
 559  * Check and post ECC errors. Called by the polling thread.
 560  */
 561 static void check_errors(struct mem_ctl_info *mci)
 562 {
 563         const struct synps_platform_data *p_data;
 564         struct synps_edac_priv *priv;
 565         int status;
 566
 567         priv = mci->pvt_info;
 568         p_data = priv->p_data;
 569
 570         status = p_data->get_error_info(priv);
 571         if (status)
 572                 return;
 573
 574         priv->ce_cnt += priv->stat.ce_cnt;
 575         priv->ue_cnt += priv->stat.ue_cnt;
 576         handle_error(mci, &priv->stat);
 577
 578         edac_dbg(3, "Total error count CE %d UE %d\n",
 579                  priv->ce_cnt, priv->ue_cnt);
 580 }
 581
 582 /**
 583  * zynq_get_dtype - Return the controller memory width.
 584  * @base:       DDR memory controller base address.
 585  *
 586  * Get the EDAC device type width appropriate for the current controller
 587  * configuration.
 588  *
 589  * Return: a device type width enumeration.
 590  */
 591 static enum dev_type zynq_get_dtype(const void __iomem *base)
 592 {
 593         enum dev_type dt;
 594         u32 width;
 595
 596         width = readl(base + CTRL_OFST);
 597         width = (width & CTRL_BW_MASK) >> CTRL_BW_SHIFT;
 598
 599         switch (width) {
 600         case DDRCTL_WDTH_16:
 601                 dt = DEV_X2;
 602                 break;
 603         case DDRCTL_WDTH_32:
 604                 dt = DEV_X4;
 605                 break;
 606         default:
 607                 dt = DEV_UNKNOWN;
 608         }
 609
 610         return dt;
 611 }
 612
 613 /**
 614  * zynqmp_get_dtype - Return the controller memory width.
 615  * @base:       DDR memory controller base address.
 616  *
 617  * Get the EDAC device type width appropriate for the current controller
 618  * configuration.
 619  *
 620  * Return: a device type width enumeration.
 621  */
 622 static enum dev_type zynqmp_get_dtype(const void __iomem *base)
 623 {
 624         enum dev_type dt;
 625         u32 width;
 626
 627         width = readl(base + CTRL_OFST);
 628         width = (width & ECC_CTRL_BUSWIDTH_MASK) >> ECC_CTRL_BUSWIDTH_SHIFT;
 629         switch (width) {
 630         case DDRCTL_EWDTH_16:
 631                 dt = DEV_X2;
 632                 break;
 633         case DDRCTL_EWDTH_32:
 634                 dt = DEV_X4;
 635                 break;
 636         case DDRCTL_EWDTH_64:
 637                 dt = DEV_X8;
 638                 break;
 639         default:
 640                 dt = DEV_UNKNOWN;
 641         }
 642
 643         return dt;
 644 }
 645
 646 /**
 647  * zynq_get_ecc_state - Return the controller ECC enable/disable status.
 648  * @base:       DDR memory controller base address.
 649  *
 650  * Get the ECC enable/disable status of the controller.
 651  *
 652  * Return: true if enabled, otherwise false.
 653  */
 654 static bool zynq_get_ecc_state(void __iomem *base)
 655 {
 656         enum dev_type dt;
 657         u32 ecctype;
 658
 659         dt = zynq_get_dtype(base);
 660         if (dt == DEV_UNKNOWN)
 661                 return false;
 662
 663         ecctype = readl(base + SCRUB_OFST) & SCRUB_MODE_MASK;
 664         if ((ecctype == SCRUB_MODE_SECDED) && (dt == DEV_X2))
 665                 return true;
 666
 667         return false;
 668 }
 669
 670 /**
 671  * zynqmp_get_ecc_state - Return the controller ECC enable/disable status.
 672  * @base:       DDR memory controller base address.
 673  *
 674  * Get the ECC enable/disable status for the controller.
 675  *
 676  * Return: a ECC status boolean i.e true/false - enabled/disabled.
 677  */
 678 static bool zynqmp_get_ecc_state(void __iomem *base)
 679 {
 680         enum dev_type dt;
 681         u32 ecctype;
 682
 683         dt = zynqmp_get_dtype(base);
 684         if (dt == DEV_UNKNOWN)
 685                 return false;
 686
 687         ecctype = readl(base + ECC_CFG0_OFST) & SCRUB_MODE_MASK;
 688         if ((ecctype == SCRUB_MODE_SECDED) &&
 689             ((dt == DEV_X2) || (dt == DEV_X4) || (dt == DEV_X8)))
 690                 return true;
 691
 692         return false;
 693 }
 694
 695 /**
 696  * get_memsize - Read the size of the attached memory device.
 697  *
 698  * Return: the memory size in bytes.
 699  */
 700 static u32 get_memsize(void)
 701 {
 702         struct sysinfo inf;
 703
 704         si_meminfo(&inf);
 705
 706         return inf.totalram * inf.mem_unit;
 707 }
 708
 709 /**
 710  * zynq_get_mtype - Return the controller memory type.
 711  * @base:       Synopsys ECC status structure.
 712  *
 713  * Get the EDAC memory type appropriate for the current controller
 714  * configuration.
 715  *
 716  * Return: a memory type enumeration.
 717  */
 718 static enum mem_type zynq_get_mtype(const void __iomem *base)
 719 {
 720         enum mem_type mt;
 721         u32 memtype;
 722
 723         memtype = readl(base + T_ZQ_OFST);
 724
 725         if (memtype & T_ZQ_DDRMODE_MASK)
 726                 mt = MEM_DDR3;
 727         else
 728                 mt = MEM_DDR2;
 729
 730         return mt;
 731 }
 732
 733 /**
 734  * zynqmp_get_mtype - Returns controller memory type.
 735  * @base:       Synopsys ECC status structure.
 736  *
 737  * Get the EDAC memory type appropriate for the current controller
 738  * configuration.
 739  *
 740  * Return: a memory type enumeration.
 741  */
 742 static enum mem_type zynqmp_get_mtype(const void __iomem *base)
 743 {
 744         enum mem_type mt;
 745         u32 memtype;
 746
 747         memtype = readl(base + CTRL_OFST);
 748
 749         if ((memtype & MEM_TYPE_DDR3) || (memtype & MEM_TYPE_LPDDR3))
 750                 mt = MEM_DDR3;
 751         else if (memtype & MEM_TYPE_DDR2)
 752                 mt = MEM_RDDR2;
 753         else if ((memtype & MEM_TYPE_LPDDR4) || (memtype & MEM_TYPE_DDR4))
 754                 mt = MEM_DDR4;
 755         else
 756                 mt = MEM_EMPTY;
 757
 758         return mt;
 759 }
 760
 761 /**
 762  * init_csrows - Initialize the csrow data.
 763  * @mci:        EDAC memory controller instance.
 764  *
 765  * Initialize the chip select rows associated with the EDAC memory
 766  * controller instance.
 767  */
 768 static void init_csrows(struct mem_ctl_info *mci)
 769 {
 770         struct synps_edac_priv *priv = mci->pvt_info;
 771         const struct synps_platform_data *p_data;
 772         struct csrow_info *csi;
 773         struct dimm_info *dimm;
 774         u32 size, row;
 775         int j;
 776
 777         p_data = priv->p_data;
 778
 779         for (row = 0; row < mci->nr_csrows; row++) {
 780                 csi = mci->csrows[row];
 781                 size = get_memsize();
 782
 783                 for (j = 0; j < csi->nr_channels; j++) {
 784                         dimm            = csi->channels[j]->dimm;
 785                         dimm->edac_mode = EDAC_FLAG_SECDED;
 786                         dimm->mtype     = p_data->get_mtype(priv->baseaddr);
 787                         dimm->nr_pages  = (size >> PAGE_SHIFT) / csi->nr_channels;
 788                         dimm->grain     = SYNPS_EDAC_ERR_GRAIN;
 789                         dimm->dtype     = p_data->get_dtype(priv->baseaddr);
 790                 }
 791         }
 792 }
 793
 794 /**
 795  * mc_init - Initialize one driver instance.
 796  * @mci:        EDAC memory controller instance.
 797  * @pdev:       platform device.
 798  *
 799  * Perform initialization of the EDAC memory controller instance and
 800  * related driver-private data associated with the memory controller the
 801  * instance is bound to.
 802  */
 803 static void mc_init(struct mem_ctl_info *mci, struct platform_device *pdev)
 804 {
 805         struct synps_edac_priv *priv;
 806
 807         mci->pdev = &pdev->dev;
 808         priv = mci->pvt_info;
 809         platform_set_drvdata(pdev, mci);
 810
 811         /* Initialize controller capabilities and configuration */
 812         mci->mtype_cap = MEM_FLAG_DDR3 | MEM_FLAG_DDR2;
 813         mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED;
 814         mci->scrub_cap = SCRUB_HW_SRC;
 815         mci->scrub_mode = SCRUB_NONE;
 816
 817         mci->edac_cap = EDAC_FLAG_SECDED;
 818         mci->ctl_name = "synps_ddr_controller";
 819         mci->dev_name = SYNPS_EDAC_MOD_STRING;
 820         mci->mod_name = SYNPS_EDAC_MOD_VER;
 821
 822         if (priv->p_data->quirks & DDR_ECC_INTR_SUPPORT) {
 823                 edac_op_state = EDAC_OPSTATE_INT;
 824         } else {
 825                 edac_op_state = EDAC_OPSTATE_POLL;
 826                 mci->edac_check = check_errors;
 827         }
 828
 829         mci->ctl_page_to_phys = NULL;
 830
 831         init_csrows(mci);
 832 }
 833
 834 static void enable_intr(struct synps_edac_priv *priv)
 835 {
 836         /* Enable UE/CE Interrupts */
 837         writel(DDR_QOSUE_MASK | DDR_QOSCE_MASK,
 838                         priv->baseaddr + DDR_QOS_IRQ_EN_OFST);
 839 }
 840
 841 static void disable_intr(struct synps_edac_priv *priv)
 842 {
 843         /* Disable UE/CE Interrupts */
 844         writel(DDR_QOSUE_MASK | DDR_QOSCE_MASK,
 845                         priv->baseaddr + DDR_QOS_IRQ_DB_OFST);
 846 }
 847
 848 static int setup_irq(struct mem_ctl_info *mci,
 849                      struct platform_device *pdev)
 850 {
 851         struct synps_edac_priv *priv = mci->pvt_info;
 852         int ret, irq;
 853
 854         irq = platform_get_irq(pdev, 0);
 855         if (irq < 0) {
 856                 edac_printk(KERN_ERR, EDAC_MC,
 857                             "No IRQ %d in DT\n", irq);
 858                 return irq;
 859         }
 860
 861         ret = devm_request_irq(&pdev->dev, irq, intr_handler,
 862                                0, dev_name(&pdev->dev), mci);
 863         if (ret < 0) {
 864                 edac_printk(KERN_ERR, EDAC_MC, "Failed to request IRQ\n");
 865                 return ret;
 866         }
 867
 868         enable_intr(priv);
 869
 870         return 0;
 871 }
 872
 873 static const struct synps_platform_data zynq_edac_def = {
 874         .get_error_info = zynq_get_error_info,
 875         .get_mtype      = zynq_get_mtype,
 876         .get_dtype      = zynq_get_dtype,
 877         .get_ecc_state  = zynq_get_ecc_state,
 878         .quirks         = 0,
 879 };
 880
 881 static const struct synps_platform_data zynqmp_edac_def = {
 882         .get_error_info = zynqmp_get_error_info,
 883         .get_mtype      = zynqmp_get_mtype,
 884         .get_dtype      = zynqmp_get_dtype,
 885         .get_ecc_state  = zynqmp_get_ecc_state,
 886         .quirks         = (DDR_ECC_INTR_SUPPORT
 887 #ifdef CONFIG_EDAC_DEBUG
 888                           | DDR_ECC_DATA_POISON_SUPPORT
 889 #endif
 890                           ),
 891 };
 892
 893 static const struct of_device_id synps_edac_match[] = {
 894         {
 895                 .compatible = "xlnx,zynq-ddrc-a05",
 896                 .data = (void *)&zynq_edac_def
 897         },
 898         {
 899                 .compatible = "xlnx,zynqmp-ddrc-2.40a",
 900                 .data = (void *)&zynqmp_edac_def
 901         },
 902         {
 903                 /* end of table */
 904         }
 905 };
 906
 907 MODULE_DEVICE_TABLE(of, synps_edac_match);
 908
 909 #ifdef CONFIG_EDAC_DEBUG
 910 #define to_mci(k) container_of(k, struct mem_ctl_info, dev)
 911
 912 /**
 913  * ddr_poison_setup -   Update poison registers.
 914  * @priv:               DDR memory controller private instance data.
 915  *
 916  * Update poison registers as per DDR mapping.
 917  * Return: none.
 918  */
 919 static void ddr_poison_setup(struct synps_edac_priv *priv)
 920 {
 921         int col = 0, row = 0, bank = 0, bankgrp = 0, rank = 0, regval;
 922         int index;
 923         ulong hif_addr = 0;
 924
 925         hif_addr = priv->poison_addr >> 3;
 926
 927         for (index = 0; index < DDR_MAX_ROW_SHIFT; index++) {
 928                 if (priv->row_shift[index])
 929                         row |= (((hif_addr >> priv->row_shift[index]) &
 930                                                 BIT(0)) << index);
 931                 else
 932                         break;
 933         }
 934
 935         for (index = 0; index < DDR_MAX_COL_SHIFT; index++) {
 936                 if (priv->col_shift[index] || index < 3)
 937                         col |= (((hif_addr >> priv->col_shift[index]) &
 938                                                 BIT(0)) << index);
 939                 else
 940                         break;
 941         }
 942
 943         for (index = 0; index < DDR_MAX_BANK_SHIFT; index++) {
 944                 if (priv->bank_shift[index])
 945                         bank |= (((hif_addr >> priv->bank_shift[index]) &
 946                                                 BIT(0)) << index);
 947                 else
 948                         break;
 949         }
 950
 951         for (index = 0; index < DDR_MAX_BANKGRP_SHIFT; index++) {
 952                 if (priv->bankgrp_shift[index])
 953                         bankgrp |= (((hif_addr >> priv->bankgrp_shift[index])
 954                                                 & BIT(0)) << index);
 955                 else
 956                         break;
 957         }
 958
 959         if (priv->rank_shift[0])
 960                 rank = (hif_addr >> priv->rank_shift[0]) & BIT(0);
 961
 962         regval = (rank << ECC_POISON0_RANK_SHIFT) & ECC_POISON0_RANK_MASK;
 963         regval |= (col << ECC_POISON0_COLUMN_SHIFT) & ECC_POISON0_COLUMN_MASK;
 964         writel(regval, priv->baseaddr + ECC_POISON0_OFST);
 965
 966         regval = (bankgrp << ECC_POISON1_BG_SHIFT) & ECC_POISON1_BG_MASK;
 967         regval |= (bank << ECC_POISON1_BANKNR_SHIFT) & ECC_POISON1_BANKNR_MASK;
 968         regval |= (row << ECC_POISON1_ROW_SHIFT) & ECC_POISON1_ROW_MASK;
 969         writel(regval, priv->baseaddr + ECC_POISON1_OFST);
 970 }
 971
 972 static ssize_t inject_data_error_show(struct device *dev,
 973                                       struct device_attribute *mattr,
 974                                       char *data)
 975 {
 976         struct mem_ctl_info *mci = to_mci(dev);
 977         struct synps_edac_priv *priv = mci->pvt_info;
 978
 979         return sprintf(data, "Poison0 Addr: 0x%08x\n\rPoison1 Addr: 0x%08x\n\r"
 980                         "Error injection Address: 0x%lx\n\r",
 981                         readl(priv->baseaddr + ECC_POISON0_OFST),
 982                         readl(priv->baseaddr + ECC_POISON1_OFST),
 983                         priv->poison_addr);
 984 }
 985
 986 static ssize_t inject_data_error_store(struct device *dev,
 987                                        struct device_attribute *mattr,
 988                                        const char *data, size_t count)
 989 {
 990         struct mem_ctl_info *mci = to_mci(dev);
 991         struct synps_edac_priv *priv = mci->pvt_info;
 992
 993         if (kstrtoul(data, 0, &priv->poison_addr))
 994                 return -EINVAL;
 995
 996         ddr_poison_setup(priv);
 997
 998         return count;
 999 }
1000
1001 static ssize_t inject_data_poison_show(struct device *dev,
1002                                        struct device_attribute *mattr,
1003                                        char *data)
1004 {
1005         struct mem_ctl_info *mci = to_mci(dev);
1006         struct synps_edac_priv *priv = mci->pvt_info;
1007
1008         return sprintf(data, "Data Poisoning: %s\n\r",
1009                         (((readl(priv->baseaddr + ECC_CFG1_OFST)) & 0x3) == 0x3)
1010                         ? ("Correctable Error") : ("UnCorrectable Error"));
1011 }
1012
1013 static ssize_t inject_data_poison_store(struct device *dev,
1014                                         struct device_attribute *mattr,
1015                                         const char *data, size_t count)
1016 {
1017         struct mem_ctl_info *mci = to_mci(dev);
1018         struct synps_edac_priv *priv = mci->pvt_info;
1019
1020         writel(0, priv->baseaddr + DDRC_SWCTL);
1021         if (strncmp(data, "CE", 2) == 0)
1022                 writel(ECC_CEPOISON_MASK, priv->baseaddr + ECC_CFG1_OFST);
1023         else
1024                 writel(ECC_UEPOISON_MASK, priv->baseaddr + ECC_CFG1_OFST);
1025         writel(1, priv->baseaddr + DDRC_SWCTL);
1026
1027         return count;
1028 }
1029
1030 static DEVICE_ATTR_RW(inject_data_error);
1031 static DEVICE_ATTR_RW(inject_data_poison);
1032
1033 static int edac_create_sysfs_attributes(struct mem_ctl_info *mci)
1034 {
1035         int rc;
1036
1037         rc = device_create_file(&mci->dev, &dev_attr_inject_data_error);
1038         if (rc < 0)
1039                 return rc;
1040         rc = device_create_file(&mci->dev, &dev_attr_inject_data_poison);
1041         if (rc < 0)
1042                 return rc;
1043         return 0;
1044 }
1045
1046 static void edac_remove_sysfs_attributes(struct mem_ctl_info *mci)
1047 {
1048         device_remove_file(&mci->dev, &dev_attr_inject_data_error);
1049         device_remove_file(&mci->dev, &dev_attr_inject_data_poison);
1050 }
1051
1052 static void setup_row_address_map(struct synps_edac_priv *priv, u32 *addrmap)
1053 {
1054         u32 addrmap_row_b2_10;
1055         int index;
1056
1057         priv->row_shift[0] = (addrmap[5] & ROW_MAX_VAL_MASK) + ROW_B0_BASE;
1058         priv->row_shift[1] = ((addrmap[5] >> 8) &
1059                         ROW_MAX_VAL_MASK) + ROW_B1_BASE;
1060
1061         addrmap_row_b2_10 = (addrmap[5] >> 16) & ROW_MAX_VAL_MASK;
1062         if (addrmap_row_b2_10 != ROW_MAX_VAL_MASK) {
1063                 for (index = 2; index < 11; index++)
1064                         priv->row_shift[index] = addrmap_row_b2_10 +
1065                                 index + ROW_B0_BASE;
1066
1067         } else {
1068                 priv->row_shift[2] = (addrmap[9] &
1069                                 ROW_MAX_VAL_MASK) + ROW_B2_BASE;
1070                 priv->row_shift[3] = ((addrmap[9] >> 8) &
1071                                 ROW_MAX_VAL_MASK) + ROW_B3_BASE;
1072                 priv->row_shift[4] = ((addrmap[9] >> 16) &
1073                                 ROW_MAX_VAL_MASK) + ROW_B4_BASE;
1074                 priv->row_shift[5] = ((addrmap[9] >> 24) &
1075                                 ROW_MAX_VAL_MASK) + ROW_B5_BASE;
1076                 priv->row_shift[6] = (addrmap[10] &
1077                                 ROW_MAX_VAL_MASK) + ROW_B6_BASE;
1078                 priv->row_shift[7] = ((addrmap[10] >> 8) &
1079                                 ROW_MAX_VAL_MASK) + ROW_B7_BASE;
1080                 priv->row_shift[8] = ((addrmap[10] >> 16) &
1081                                 ROW_MAX_VAL_MASK) + ROW_B8_BASE;
1082                 priv->row_shift[9] = ((addrmap[10] >> 24) &
1083                                 ROW_MAX_VAL_MASK) + ROW_B9_BASE;
1084                 priv->row_shift[10] = (addrmap[11] &
1085                                 ROW_MAX_VAL_MASK) + ROW_B10_BASE;
1086         }
1087
1088         priv->row_shift[11] = (((addrmap[5] >> 24) & ROW_MAX_VAL_MASK) ==
1089                                 ROW_MAX_VAL_MASK) ? 0 : (((addrmap[5] >> 24) &
1090                                 ROW_MAX_VAL_MASK) + ROW_B11_BASE);
1091         priv->row_shift[12] = ((addrmap[6] & ROW_MAX_VAL_MASK) ==
1092                                 ROW_MAX_VAL_MASK) ? 0 : ((addrmap[6] &
1093                                 ROW_MAX_VAL_MASK) + ROW_B12_BASE);
1094         priv->row_shift[13] = (((addrmap[6] >> 8) & ROW_MAX_VAL_MASK) ==
1095                                 ROW_MAX_VAL_MASK) ? 0 : (((addrmap[6] >> 8) &
1096                                 ROW_MAX_VAL_MASK) + ROW_B13_BASE);
1097         priv->row_shift[14] = (((addrmap[6] >> 16) & ROW_MAX_VAL_MASK) ==
1098                                 ROW_MAX_VAL_MASK) ? 0 : (((addrmap[6] >> 16) &
1099                                 ROW_MAX_VAL_MASK) + ROW_B14_BASE);
1100         priv->row_shift[15] = (((addrmap[6] >> 24) & ROW_MAX_VAL_MASK) ==
1101                                 ROW_MAX_VAL_MASK) ? 0 : (((addrmap[6] >> 24) &
1102                                 ROW_MAX_VAL_MASK) + ROW_B15_BASE);
1103         priv->row_shift[16] = ((addrmap[7] & ROW_MAX_VAL_MASK) ==
1104                                 ROW_MAX_VAL_MASK) ? 0 : ((addrmap[7] &
1105                                 ROW_MAX_VAL_MASK) + ROW_B16_BASE);
1106         priv->row_shift[17] = (((addrmap[7] >> 8) & ROW_MAX_VAL_MASK) ==
1107                                 ROW_MAX_VAL_MASK) ? 0 : (((addrmap[7] >> 8) &
1108                                 ROW_MAX_VAL_MASK) + ROW_B17_BASE);
1109 }
1110
1111 static void setup_column_address_map(struct synps_edac_priv *priv, u32 *addrmap)
1112 {
1113         u32 width, memtype;
1114         int index;
1115
1116         memtype = readl(priv->baseaddr + CTRL_OFST);
1117         width = (memtype & ECC_CTRL_BUSWIDTH_MASK) >> ECC_CTRL_BUSWIDTH_SHIFT;
1118
1119         priv->col_shift[0] = 0;
1120         priv->col_shift[1] = 1;
1121         priv->col_shift[2] = (addrmap[2] & COL_MAX_VAL_MASK) + COL_B2_BASE;
1122         priv->col_shift[3] = ((addrmap[2] >> 8) &
1123                         COL_MAX_VAL_MASK) + COL_B3_BASE;
1124         priv->col_shift[4] = (((addrmap[2] >> 16) & COL_MAX_VAL_MASK) ==
1125                         COL_MAX_VAL_MASK) ? 0 : (((addrmap[2] >> 16) &
1126                                         COL_MAX_VAL_MASK) + COL_B4_BASE);
1127         priv->col_shift[5] = (((addrmap[2] >> 24) & COL_MAX_VAL_MASK) ==
1128                         COL_MAX_VAL_MASK) ? 0 : (((addrmap[2] >> 24) &
1129                                         COL_MAX_VAL_MASK) + COL_B5_BASE);
1130         priv->col_shift[6] = ((addrmap[3] & COL_MAX_VAL_MASK) ==
1131                         COL_MAX_VAL_MASK) ? 0 : ((addrmap[3] &
1132                                         COL_MAX_VAL_MASK) + COL_B6_BASE);
1133         priv->col_shift[7] = (((addrmap[3] >> 8) & COL_MAX_VAL_MASK) ==
1134                         COL_MAX_VAL_MASK) ? 0 : (((addrmap[3] >> 8) &
1135                                         COL_MAX_VAL_MASK) + COL_B7_BASE);
1136         priv->col_shift[8] = (((addrmap[3] >> 16) & COL_MAX_VAL_MASK) ==
1137                         COL_MAX_VAL_MASK) ? 0 : (((addrmap[3] >> 16) &
1138                                         COL_MAX_VAL_MASK) + COL_B8_BASE);
1139         priv->col_shift[9] = (((addrmap[3] >> 24) & COL_MAX_VAL_MASK) ==
1140                         COL_MAX_VAL_MASK) ? 0 : (((addrmap[3] >> 24) &
1141                                         COL_MAX_VAL_MASK) + COL_B9_BASE);
1142         if (width == DDRCTL_EWDTH_64) {
1143                 if (memtype & MEM_TYPE_LPDDR3) {
1144                         priv->col_shift[10] = ((addrmap[4] &
1145                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1146                                 ((addrmap[4] & COL_MAX_VAL_MASK) +
1147                                  COL_B10_BASE);
1148                         priv->col_shift[11] = (((addrmap[4] >> 8) &
1149                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1150                                 (((addrmap[4] >> 8) & COL_MAX_VAL_MASK) +
1151                                  COL_B11_BASE);
1152                 } else {
1153                         priv->col_shift[11] = ((addrmap[4] &
1154                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1155                                 ((addrmap[4] & COL_MAX_VAL_MASK) +
1156                                  COL_B10_BASE);
1157                         priv->col_shift[13] = (((addrmap[4] >> 8) &
1158                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1159                                 (((addrmap[4] >> 8) & COL_MAX_VAL_MASK) +
1160                                  COL_B11_BASE);
1161                 }
1162         } else if (width == DDRCTL_EWDTH_32) {
1163                 if (memtype & MEM_TYPE_LPDDR3) {
1164                         priv->col_shift[10] = (((addrmap[3] >> 24) &
1165                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1166                                 (((addrmap[3] >> 24) & COL_MAX_VAL_MASK) +
1167                                  COL_B9_BASE);
1168                         priv->col_shift[11] = ((addrmap[4] &
1169                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1170                                 ((addrmap[4] & COL_MAX_VAL_MASK) +
1171                                  COL_B10_BASE);
1172                 } else {
1173                         priv->col_shift[11] = (((addrmap[3] >> 24) &
1174                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1175                                 (((addrmap[3] >> 24) & COL_MAX_VAL_MASK) +
1176                                  COL_B9_BASE);
1177                         priv->col_shift[13] = ((addrmap[4] &
1178                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1179                                 ((addrmap[4] & COL_MAX_VAL_MASK) +
1180                                  COL_B10_BASE);
1181                 }
1182         } else {
1183                 if (memtype & MEM_TYPE_LPDDR3) {
1184                         priv->col_shift[10] = (((addrmap[3] >> 16) &
1185                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1186                                 (((addrmap[3] >> 16) & COL_MAX_VAL_MASK) +
1187                                  COL_B8_BASE);
1188                         priv->col_shift[11] = (((addrmap[3] >> 24) &
1189                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1190                                 (((addrmap[3] >> 24) & COL_MAX_VAL_MASK) +
1191                                  COL_B9_BASE);
1192                         priv->col_shift[13] = ((addrmap[4] &
1193                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1194                                 ((addrmap[4] & COL_MAX_VAL_MASK) +
1195                                  COL_B10_BASE);
1196                 } else {
1197                         priv->col_shift[11] = (((addrmap[3] >> 16) &
1198                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1199                                 (((addrmap[3] >> 16) & COL_MAX_VAL_MASK) +
1200                                  COL_B8_BASE);
1201                         priv->col_shift[13] = (((addrmap[3] >> 24) &
1202                                 COL_MAX_VAL_MASK) == COL_MAX_VAL_MASK) ? 0 :
1203                                 (((addrmap[3] >> 24) & COL_MAX_VAL_MASK) +
1204                                  COL_B9_BASE);
1205                 }
1206         }
1207
1208         if (width) {
1209                 for (index = 9; index > width; index--) {
1210                         priv->col_shift[index] = priv->col_shift[index - width];
1211                         priv->col_shift[index - width] = 0;
1212                 }
1213         }
1214
1215 }
1216
1217 static void setup_bank_address_map(struct synps_edac_priv *priv, u32 *addrmap)
1218 {
1219         priv->bank_shift[0] = (addrmap[1] & BANK_MAX_VAL_MASK) + BANK_B0_BASE;
1220         priv->bank_shift[1] = ((addrmap[1] >> 8) &
1221                                 BANK_MAX_VAL_MASK) + BANK_B1_BASE;
1222         priv->bank_shift[2] = (((addrmap[1] >> 16) &
1223                                 BANK_MAX_VAL_MASK) == BANK_MAX_VAL_MASK) ? 0 :
1224                                 (((addrmap[1] >> 16) & BANK_MAX_VAL_MASK) +
1225                                  BANK_B2_BASE);
1226
1227 }
1228
1229 static void setup_bg_address_map(struct synps_edac_priv *priv, u32 *addrmap)
1230 {
1231         priv->bankgrp_shift[0] = (addrmap[8] &
1232                                 BANKGRP_MAX_VAL_MASK) + BANKGRP_B0_BASE;
1233         priv->bankgrp_shift[1] = (((addrmap[8] >> 8) & BANKGRP_MAX_VAL_MASK) ==
1234                                 BANKGRP_MAX_VAL_MASK) ? 0 : (((addrmap[8] >> 8)
1235                                 & BANKGRP_MAX_VAL_MASK) + BANKGRP_B1_BASE);
1236
1237 }
1238
1239 static void setup_rank_address_map(struct synps_edac_priv *priv, u32 *addrmap)
1240 {
1241         priv->rank_shift[0] = ((addrmap[0] & RANK_MAX_VAL_MASK) ==
1242                                 RANK_MAX_VAL_MASK) ? 0 : ((addrmap[0] &
1243                                 RANK_MAX_VAL_MASK) + RANK_B0_BASE);
1244 }
1245
1246 /**
1247  * setup_address_map -  Set Address Map by querying ADDRMAP registers.
1248  * @priv:               DDR memory controller private instance data.
1249  *
1250  * Set Address Map by querying ADDRMAP registers.
1251  *
1252  * Return: none.
1253  */
1254 static void setup_address_map(struct synps_edac_priv *priv)
1255 {
1256         u32 addrmap[12];
1257         int index;
1258
1259         for (index = 0; index < 12; index++) {
1260                 u32 addrmap_offset;
1261
1262                 addrmap_offset = ECC_ADDRMAP0_OFFSET + (index * 4);
1263                 addrmap[index] = readl(priv->baseaddr + addrmap_offset);
1264         }
1265
1266         setup_row_address_map(priv, addrmap);
1267
1268         setup_column_address_map(priv, addrmap);
1269
1270         setup_bank_address_map(priv, addrmap);
1271
1272         setup_bg_address_map(priv, addrmap);
1273
1274         setup_rank_address_map(priv, addrmap);
1275 }
1276 #endif /* CONFIG_EDAC_DEBUG */
1277
1278 /**
1279  * mc_probe - Check controller and bind driver.
1280  * @pdev:       platform device.
1281  *
1282  * Probe a specific controller instance for binding with the driver.
1283  *
1284  * Return: 0 if the controller instance was successfully bound to the
1285  * driver; otherwise, < 0 on error.
1286  */
1287 static int mc_probe(struct platform_device *pdev)
1288 {
1289         const struct synps_platform_data *p_data;
1290         struct edac_mc_layer layers[2];
1291         struct synps_edac_priv *priv;
1292         struct mem_ctl_info *mci;
1293         void __iomem *baseaddr;
1294         struct resource *res;
1295         int rc;
1296
1297         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1298         baseaddr = devm_ioremap_resource(&pdev->dev, res);
1299         if (IS_ERR(baseaddr))
1300                 return PTR_ERR(baseaddr);
1301
1302         p_data = of_device_get_match_data(&pdev->dev);
1303         if (!p_data)
1304                 return -ENODEV;
1305
1306         if (!p_data->get_ecc_state(baseaddr)) {
1307                 edac_printk(KERN_INFO, EDAC_MC, "ECC not enabled\n");
1308                 return -ENXIO;
1309         }
1310
1311         layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
1312         layers[0].size = SYNPS_EDAC_NR_CSROWS;
1313         layers[0].is_virt_csrow = true;
1314         layers[1].type = EDAC_MC_LAYER_CHANNEL;
1315         layers[1].size = SYNPS_EDAC_NR_CHANS;
1316         layers[1].is_virt_csrow = false;
1317
1318         mci = edac_mc_alloc(0, ARRAY_SIZE(layers), layers,
1319                             sizeof(struct synps_edac_priv));
1320         if (!mci) {
1321                 edac_printk(KERN_ERR, EDAC_MC,
1322                             "Failed memory allocation for mc instance\n");
1323                 return -ENOMEM;
1324         }
1325
1326         priv = mci->pvt_info;
1327         priv->baseaddr = baseaddr;
1328         priv->p_data = p_data;
1329
1330         mc_init(mci, pdev);
1331
1332         if (priv->p_data->quirks & DDR_ECC_INTR_SUPPORT) {
1333                 rc = setup_irq(mci, pdev);
1334                 if (rc)
1335                         goto free_edac_mc;
1336         }
1337
1338         rc = edac_mc_add_mc(mci);
1339         if (rc) {
1340                 edac_printk(KERN_ERR, EDAC_MC,
1341                             "Failed to register with EDAC core\n");
1342                 goto free_edac_mc;
1343         }
1344
1345 #ifdef CONFIG_EDAC_DEBUG
1346         if (priv->p_data->quirks & DDR_ECC_DATA_POISON_SUPPORT) {
1347                 rc = edac_create_sysfs_attributes(mci);
1348                 if (rc) {
1349                         edac_printk(KERN_ERR, EDAC_MC,
1350                                         "Failed to create sysfs entries\n");
1351                         goto free_edac_mc;
1352                 }
1353         }
1354
1355         if (of_device_is_compatible(pdev->dev.of_node,
1356                                     "xlnx,zynqmp-ddrc-2.40a"))
1357                 setup_address_map(priv);
1358 #endif
1359
1360         /*
1361          * Start capturing the correctable and uncorrectable errors. A write of
1362          * 0 starts the counters.
1363          */
1364         if (!(priv->p_data->quirks & DDR_ECC_INTR_SUPPORT))
1365                 writel(0x0, baseaddr + ECC_CTRL_OFST);
1366
1367         return rc;
1368
1369 free_edac_mc:
1370         edac_mc_free(mci);
1371
1372         return rc;
1373 }
1374
1375 /**
1376  * mc_remove - Unbind driver from controller.
1377  * @pdev:       Platform device.
1378  *
1379  * Return: Unconditionally 0
1380  */
1381 static int mc_remove(struct platform_device *pdev)
1382 {
1383         struct mem_ctl_info *mci = platform_get_drvdata(pdev);
1384         struct synps_edac_priv *priv = mci->pvt_info;
1385
1386         if (priv->p_data->quirks & DDR_ECC_INTR_SUPPORT)
1387                 disable_intr(priv);
1388
1389 #ifdef CONFIG_EDAC_DEBUG
1390         if (priv->p_data->quirks & DDR_ECC_DATA_POISON_SUPPORT)
1391                 edac_remove_sysfs_attributes(mci);
1392 #endif
1393
1394         edac_mc_del_mc(&pdev->dev);
1395         edac_mc_free(mci);
1396
1397         return 0;
1398 }
1399
1400 static struct platform_driver synps_edac_mc_driver = {
1401         .driver = {
1402                    .name = "synopsys-edac",
1403                    .of_match_table = synps_edac_match,
1404                    },
1405         .probe = mc_probe,
1406         .remove = mc_remove,
1407 };
1408
1409 module_platform_driver(synps_edac_mc_driver);
1410
1411 MODULE_AUTHOR("Xilinx Inc");
1412 MODULE_DESCRIPTION("Synopsys DDR ECC driver");
1413 MODULE_LICENSE("GPL v2");