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