13bb16560SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2ea2eb9a8SYork Sun /*
3ea2eb9a8SYork Sun * Freescale Memory Controller kernel module
4ea2eb9a8SYork Sun *
5ea2eb9a8SYork Sun * Support Power-based SoCs including MPC85xx, MPC86xx, MPC83xx and
675dfa870SPatrick Havelange * ARM-based Layerscape SoCs including LS2xxx and LS1021A. Originally
775dfa870SPatrick Havelange * split out from mpc85xx_edac EDAC driver.
8ea2eb9a8SYork Sun *
9ea2eb9a8SYork Sun * Parts Copyrighted (c) 2013 by Freescale Semiconductor, Inc.
10ea2eb9a8SYork Sun *
11ea2eb9a8SYork Sun * Author: Dave Jiang <djiang@mvista.com>
12ea2eb9a8SYork Sun *
133bb16560SThomas Gleixner * 2006-2007 (c) MontaVista Software, Inc.
14ea2eb9a8SYork Sun */
15ea2eb9a8SYork Sun #include <linux/module.h>
16ea2eb9a8SYork Sun #include <linux/init.h>
17ea2eb9a8SYork Sun #include <linux/interrupt.h>
18ea2eb9a8SYork Sun #include <linux/ctype.h>
19ea2eb9a8SYork Sun #include <linux/io.h>
20ea2eb9a8SYork Sun #include <linux/mod_devicetable.h>
21ea2eb9a8SYork Sun #include <linux/edac.h>
22ea2eb9a8SYork Sun #include <linux/smp.h>
23ea2eb9a8SYork Sun #include <linux/gfp.h>
24ea2eb9a8SYork Sun
25*408d8088SRob Herring #include <linux/of.h>
26eeb3d68bSYork Sun #include <linux/of_address.h>
27ea2eb9a8SYork Sun #include "edac_module.h"
28ea2eb9a8SYork Sun #include "fsl_ddr_edac.h"
29ea2eb9a8SYork Sun
30ea2eb9a8SYork Sun #define EDAC_MOD_STR "fsl_ddr_edac"
31ea2eb9a8SYork Sun
32ea2eb9a8SYork Sun static int edac_mc_idx;
33ea2eb9a8SYork Sun
34ea2eb9a8SYork Sun static u32 orig_ddr_err_disable;
35ea2eb9a8SYork Sun static u32 orig_ddr_err_sbe;
36339fdff1SYork Sun static bool little_endian;
37339fdff1SYork Sun
ddr_in32(void __iomem * addr)38339fdff1SYork Sun static inline u32 ddr_in32(void __iomem *addr)
39339fdff1SYork Sun {
40339fdff1SYork Sun return little_endian ? ioread32(addr) : ioread32be(addr);
41339fdff1SYork Sun }
42339fdff1SYork Sun
ddr_out32(void __iomem * addr,u32 value)43339fdff1SYork Sun static inline void ddr_out32(void __iomem *addr, u32 value)
44339fdff1SYork Sun {
45339fdff1SYork Sun if (little_endian)
46339fdff1SYork Sun iowrite32(value, addr);
47339fdff1SYork Sun else
48339fdff1SYork Sun iowrite32be(value, addr);
49339fdff1SYork Sun }
50ea2eb9a8SYork Sun
51a59817faSYork Sun #ifdef CONFIG_EDAC_DEBUG
52ea2eb9a8SYork Sun /************************ MC SYSFS parts ***********************************/
53ea2eb9a8SYork Sun
54ea2eb9a8SYork Sun #define to_mci(k) container_of(k, struct mem_ctl_info, dev)
55ea2eb9a8SYork Sun
fsl_mc_inject_data_hi_show(struct device * dev,struct device_attribute * mattr,char * data)56d43a9fb2SYork Sun static ssize_t fsl_mc_inject_data_hi_show(struct device *dev,
57ea2eb9a8SYork Sun struct device_attribute *mattr,
58ea2eb9a8SYork Sun char *data)
59ea2eb9a8SYork Sun {
60ea2eb9a8SYork Sun struct mem_ctl_info *mci = to_mci(dev);
61d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
62ea2eb9a8SYork Sun return sprintf(data, "0x%08x",
63339fdff1SYork Sun ddr_in32(pdata->mc_vbase + FSL_MC_DATA_ERR_INJECT_HI));
64ea2eb9a8SYork Sun }
65ea2eb9a8SYork Sun
fsl_mc_inject_data_lo_show(struct device * dev,struct device_attribute * mattr,char * data)66d43a9fb2SYork Sun static ssize_t fsl_mc_inject_data_lo_show(struct device *dev,
67ea2eb9a8SYork Sun struct device_attribute *mattr,
68ea2eb9a8SYork Sun char *data)
69ea2eb9a8SYork Sun {
70ea2eb9a8SYork Sun struct mem_ctl_info *mci = to_mci(dev);
71d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
72ea2eb9a8SYork Sun return sprintf(data, "0x%08x",
73339fdff1SYork Sun ddr_in32(pdata->mc_vbase + FSL_MC_DATA_ERR_INJECT_LO));
74ea2eb9a8SYork Sun }
75ea2eb9a8SYork Sun
fsl_mc_inject_ctrl_show(struct device * dev,struct device_attribute * mattr,char * data)76d43a9fb2SYork Sun static ssize_t fsl_mc_inject_ctrl_show(struct device *dev,
77ea2eb9a8SYork Sun struct device_attribute *mattr,
78ea2eb9a8SYork Sun char *data)
79ea2eb9a8SYork Sun {
80ea2eb9a8SYork Sun struct mem_ctl_info *mci = to_mci(dev);
81d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
82ea2eb9a8SYork Sun return sprintf(data, "0x%08x",
83339fdff1SYork Sun ddr_in32(pdata->mc_vbase + FSL_MC_ECC_ERR_INJECT));
84ea2eb9a8SYork Sun }
85ea2eb9a8SYork Sun
fsl_mc_inject_data_hi_store(struct device * dev,struct device_attribute * mattr,const char * data,size_t count)86d43a9fb2SYork Sun static ssize_t fsl_mc_inject_data_hi_store(struct device *dev,
87ea2eb9a8SYork Sun struct device_attribute *mattr,
88ea2eb9a8SYork Sun const char *data, size_t count)
89ea2eb9a8SYork Sun {
90ea2eb9a8SYork Sun struct mem_ctl_info *mci = to_mci(dev);
91d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
92f47ae798SYork Sun unsigned long val;
93f47ae798SYork Sun int rc;
94f47ae798SYork Sun
95ea2eb9a8SYork Sun if (isdigit(*data)) {
96f47ae798SYork Sun rc = kstrtoul(data, 0, &val);
97f47ae798SYork Sun if (rc)
98f47ae798SYork Sun return rc;
99f47ae798SYork Sun
100f47ae798SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_DATA_ERR_INJECT_HI, val);
101ea2eb9a8SYork Sun return count;
102ea2eb9a8SYork Sun }
103ea2eb9a8SYork Sun return 0;
104ea2eb9a8SYork Sun }
105ea2eb9a8SYork Sun
fsl_mc_inject_data_lo_store(struct device * dev,struct device_attribute * mattr,const char * data,size_t count)106d43a9fb2SYork Sun static ssize_t fsl_mc_inject_data_lo_store(struct device *dev,
107ea2eb9a8SYork Sun struct device_attribute *mattr,
108ea2eb9a8SYork Sun const char *data, size_t count)
109ea2eb9a8SYork Sun {
110ea2eb9a8SYork Sun struct mem_ctl_info *mci = to_mci(dev);
111d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
112f47ae798SYork Sun unsigned long val;
113f47ae798SYork Sun int rc;
114f47ae798SYork Sun
115ea2eb9a8SYork Sun if (isdigit(*data)) {
116f47ae798SYork Sun rc = kstrtoul(data, 0, &val);
117f47ae798SYork Sun if (rc)
118f47ae798SYork Sun return rc;
119f47ae798SYork Sun
120f47ae798SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_DATA_ERR_INJECT_LO, val);
121ea2eb9a8SYork Sun return count;
122ea2eb9a8SYork Sun }
123ea2eb9a8SYork Sun return 0;
124ea2eb9a8SYork Sun }
125ea2eb9a8SYork Sun
fsl_mc_inject_ctrl_store(struct device * dev,struct device_attribute * mattr,const char * data,size_t count)126d43a9fb2SYork Sun static ssize_t fsl_mc_inject_ctrl_store(struct device *dev,
127ea2eb9a8SYork Sun struct device_attribute *mattr,
128ea2eb9a8SYork Sun const char *data, size_t count)
129ea2eb9a8SYork Sun {
130ea2eb9a8SYork Sun struct mem_ctl_info *mci = to_mci(dev);
131d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
132f47ae798SYork Sun unsigned long val;
133f47ae798SYork Sun int rc;
134f47ae798SYork Sun
135ea2eb9a8SYork Sun if (isdigit(*data)) {
136f47ae798SYork Sun rc = kstrtoul(data, 0, &val);
137f47ae798SYork Sun if (rc)
138f47ae798SYork Sun return rc;
139f47ae798SYork Sun
140f47ae798SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ECC_ERR_INJECT, val);
141ea2eb9a8SYork Sun return count;
142ea2eb9a8SYork Sun }
143ea2eb9a8SYork Sun return 0;
144ea2eb9a8SYork Sun }
145ea2eb9a8SYork Sun
146279fa580SWei Yongjun static DEVICE_ATTR(inject_data_hi, S_IRUGO | S_IWUSR,
147d43a9fb2SYork Sun fsl_mc_inject_data_hi_show, fsl_mc_inject_data_hi_store);
148279fa580SWei Yongjun static DEVICE_ATTR(inject_data_lo, S_IRUGO | S_IWUSR,
149d43a9fb2SYork Sun fsl_mc_inject_data_lo_show, fsl_mc_inject_data_lo_store);
150279fa580SWei Yongjun static DEVICE_ATTR(inject_ctrl, S_IRUGO | S_IWUSR,
151d43a9fb2SYork Sun fsl_mc_inject_ctrl_show, fsl_mc_inject_ctrl_store);
152a59817faSYork Sun #endif /* CONFIG_EDAC_DEBUG */
153ea2eb9a8SYork Sun
154d43a9fb2SYork Sun static struct attribute *fsl_ddr_dev_attrs[] = {
155a59817faSYork Sun #ifdef CONFIG_EDAC_DEBUG
156ea2eb9a8SYork Sun &dev_attr_inject_data_hi.attr,
157ea2eb9a8SYork Sun &dev_attr_inject_data_lo.attr,
158ea2eb9a8SYork Sun &dev_attr_inject_ctrl.attr,
159a59817faSYork Sun #endif
160ea2eb9a8SYork Sun NULL
161ea2eb9a8SYork Sun };
162ea2eb9a8SYork Sun
163d43a9fb2SYork Sun ATTRIBUTE_GROUPS(fsl_ddr_dev);
164ea2eb9a8SYork Sun
165ea2eb9a8SYork Sun /**************************** MC Err device ***************************/
166ea2eb9a8SYork Sun
167ea2eb9a8SYork Sun /*
168ea2eb9a8SYork Sun * Taken from table 8-55 in the MPC8641 User's Manual and/or 9-61 in the
169ea2eb9a8SYork Sun * MPC8572 User's Manual. Each line represents a syndrome bit column as a
170ea2eb9a8SYork Sun * 64-bit value, but split into an upper and lower 32-bit chunk. The labels
171ea2eb9a8SYork Sun * below correspond to Freescale's manuals.
172ea2eb9a8SYork Sun */
173ea2eb9a8SYork Sun static unsigned int ecc_table[16] = {
174ea2eb9a8SYork Sun /* MSB LSB */
175ea2eb9a8SYork Sun /* [0:31] [32:63] */
176ea2eb9a8SYork Sun 0xf00fe11e, 0xc33c0ff7, /* Syndrome bit 7 */
177ea2eb9a8SYork Sun 0x00ff00ff, 0x00fff0ff,
178ea2eb9a8SYork Sun 0x0f0f0f0f, 0x0f0fff00,
179ea2eb9a8SYork Sun 0x11113333, 0x7777000f,
180ea2eb9a8SYork Sun 0x22224444, 0x8888222f,
181ea2eb9a8SYork Sun 0x44448888, 0xffff4441,
182ea2eb9a8SYork Sun 0x8888ffff, 0x11118882,
183ea2eb9a8SYork Sun 0xffff1111, 0x22221114, /* Syndrome bit 0 */
184ea2eb9a8SYork Sun };
185ea2eb9a8SYork Sun
186ea2eb9a8SYork Sun /*
187ea2eb9a8SYork Sun * Calculate the correct ECC value for a 64-bit value specified by high:low
188ea2eb9a8SYork Sun */
calculate_ecc(u32 high,u32 low)189ea2eb9a8SYork Sun static u8 calculate_ecc(u32 high, u32 low)
190ea2eb9a8SYork Sun {
191ea2eb9a8SYork Sun u32 mask_low;
192ea2eb9a8SYork Sun u32 mask_high;
193ea2eb9a8SYork Sun int bit_cnt;
194ea2eb9a8SYork Sun u8 ecc = 0;
195ea2eb9a8SYork Sun int i;
196ea2eb9a8SYork Sun int j;
197ea2eb9a8SYork Sun
198ea2eb9a8SYork Sun for (i = 0; i < 8; i++) {
199ea2eb9a8SYork Sun mask_high = ecc_table[i * 2];
200ea2eb9a8SYork Sun mask_low = ecc_table[i * 2 + 1];
201ea2eb9a8SYork Sun bit_cnt = 0;
202ea2eb9a8SYork Sun
203ea2eb9a8SYork Sun for (j = 0; j < 32; j++) {
204ea2eb9a8SYork Sun if ((mask_high >> j) & 1)
205ea2eb9a8SYork Sun bit_cnt ^= (high >> j) & 1;
206ea2eb9a8SYork Sun if ((mask_low >> j) & 1)
207ea2eb9a8SYork Sun bit_cnt ^= (low >> j) & 1;
208ea2eb9a8SYork Sun }
209ea2eb9a8SYork Sun
210ea2eb9a8SYork Sun ecc |= bit_cnt << i;
211ea2eb9a8SYork Sun }
212ea2eb9a8SYork Sun
213ea2eb9a8SYork Sun return ecc;
214ea2eb9a8SYork Sun }
215ea2eb9a8SYork Sun
216ea2eb9a8SYork Sun /*
217ea2eb9a8SYork Sun * Create the syndrome code which is generated if the data line specified by
218ea2eb9a8SYork Sun * 'bit' failed. Eg generate an 8-bit codes seen in Table 8-55 in the MPC8641
219ea2eb9a8SYork Sun * User's Manual and 9-61 in the MPC8572 User's Manual.
220ea2eb9a8SYork Sun */
syndrome_from_bit(unsigned int bit)221ea2eb9a8SYork Sun static u8 syndrome_from_bit(unsigned int bit) {
222ea2eb9a8SYork Sun int i;
223ea2eb9a8SYork Sun u8 syndrome = 0;
224ea2eb9a8SYork Sun
225ea2eb9a8SYork Sun /*
226ea2eb9a8SYork Sun * Cycle through the upper or lower 32-bit portion of each value in
227ea2eb9a8SYork Sun * ecc_table depending on if 'bit' is in the upper or lower half of
228ea2eb9a8SYork Sun * 64-bit data.
229ea2eb9a8SYork Sun */
230ea2eb9a8SYork Sun for (i = bit < 32; i < 16; i += 2)
231ea2eb9a8SYork Sun syndrome |= ((ecc_table[i] >> (bit % 32)) & 1) << (i / 2);
232ea2eb9a8SYork Sun
233ea2eb9a8SYork Sun return syndrome;
234ea2eb9a8SYork Sun }
235ea2eb9a8SYork Sun
236ea2eb9a8SYork Sun /*
237ea2eb9a8SYork Sun * Decode data and ecc syndrome to determine what went wrong
238ea2eb9a8SYork Sun * Note: This can only decode single-bit errors
239ea2eb9a8SYork Sun */
sbe_ecc_decode(u32 cap_high,u32 cap_low,u32 cap_ecc,int * bad_data_bit,int * bad_ecc_bit)240ea2eb9a8SYork Sun static void sbe_ecc_decode(u32 cap_high, u32 cap_low, u32 cap_ecc,
241ea2eb9a8SYork Sun int *bad_data_bit, int *bad_ecc_bit)
242ea2eb9a8SYork Sun {
243ea2eb9a8SYork Sun int i;
244ea2eb9a8SYork Sun u8 syndrome;
245ea2eb9a8SYork Sun
246ea2eb9a8SYork Sun *bad_data_bit = -1;
247ea2eb9a8SYork Sun *bad_ecc_bit = -1;
248ea2eb9a8SYork Sun
249ea2eb9a8SYork Sun /*
250ea2eb9a8SYork Sun * Calculate the ECC of the captured data and XOR it with the captured
251ea2eb9a8SYork Sun * ECC to find an ECC syndrome value we can search for
252ea2eb9a8SYork Sun */
253ea2eb9a8SYork Sun syndrome = calculate_ecc(cap_high, cap_low) ^ cap_ecc;
254ea2eb9a8SYork Sun
255ea2eb9a8SYork Sun /* Check if a data line is stuck... */
256ea2eb9a8SYork Sun for (i = 0; i < 64; i++) {
257ea2eb9a8SYork Sun if (syndrome == syndrome_from_bit(i)) {
258ea2eb9a8SYork Sun *bad_data_bit = i;
259ea2eb9a8SYork Sun return;
260ea2eb9a8SYork Sun }
261ea2eb9a8SYork Sun }
262ea2eb9a8SYork Sun
263ea2eb9a8SYork Sun /* If data is correct, check ECC bits for errors... */
264ea2eb9a8SYork Sun for (i = 0; i < 8; i++) {
265ea2eb9a8SYork Sun if ((syndrome >> i) & 0x1) {
266ea2eb9a8SYork Sun *bad_ecc_bit = i;
267ea2eb9a8SYork Sun return;
268ea2eb9a8SYork Sun }
269ea2eb9a8SYork Sun }
270ea2eb9a8SYork Sun }
271ea2eb9a8SYork Sun
272ea2eb9a8SYork Sun #define make64(high, low) (((u64)(high) << 32) | (low))
273ea2eb9a8SYork Sun
fsl_mc_check(struct mem_ctl_info * mci)274d43a9fb2SYork Sun static void fsl_mc_check(struct mem_ctl_info *mci)
275ea2eb9a8SYork Sun {
276d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
277ea2eb9a8SYork Sun struct csrow_info *csrow;
278ea2eb9a8SYork Sun u32 bus_width;
279ea2eb9a8SYork Sun u32 err_detect;
280ea2eb9a8SYork Sun u32 syndrome;
281ea2eb9a8SYork Sun u64 err_addr;
282ea2eb9a8SYork Sun u32 pfn;
283ea2eb9a8SYork Sun int row_index;
284ea2eb9a8SYork Sun u32 cap_high;
285ea2eb9a8SYork Sun u32 cap_low;
286ea2eb9a8SYork Sun int bad_data_bit;
287ea2eb9a8SYork Sun int bad_ecc_bit;
288ea2eb9a8SYork Sun
289339fdff1SYork Sun err_detect = ddr_in32(pdata->mc_vbase + FSL_MC_ERR_DETECT);
290ea2eb9a8SYork Sun if (!err_detect)
291ea2eb9a8SYork Sun return;
292ea2eb9a8SYork Sun
293d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR, "Err Detect Register: %#8.8x\n",
294ea2eb9a8SYork Sun err_detect);
295ea2eb9a8SYork Sun
296ea2eb9a8SYork Sun /* no more processing if not ECC bit errors */
297ea2eb9a8SYork Sun if (!(err_detect & (DDR_EDE_SBE | DDR_EDE_MBE))) {
298339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_DETECT, err_detect);
299ea2eb9a8SYork Sun return;
300ea2eb9a8SYork Sun }
301ea2eb9a8SYork Sun
302339fdff1SYork Sun syndrome = ddr_in32(pdata->mc_vbase + FSL_MC_CAPTURE_ECC);
303ea2eb9a8SYork Sun
304ea2eb9a8SYork Sun /* Mask off appropriate bits of syndrome based on bus width */
305339fdff1SYork Sun bus_width = (ddr_in32(pdata->mc_vbase + FSL_MC_DDR_SDRAM_CFG) &
306ea2eb9a8SYork Sun DSC_DBW_MASK) ? 32 : 64;
307ea2eb9a8SYork Sun if (bus_width == 64)
308ea2eb9a8SYork Sun syndrome &= 0xff;
309ea2eb9a8SYork Sun else
310ea2eb9a8SYork Sun syndrome &= 0xffff;
311ea2eb9a8SYork Sun
312ea2eb9a8SYork Sun err_addr = make64(
313339fdff1SYork Sun ddr_in32(pdata->mc_vbase + FSL_MC_CAPTURE_EXT_ADDRESS),
314339fdff1SYork Sun ddr_in32(pdata->mc_vbase + FSL_MC_CAPTURE_ADDRESS));
315ea2eb9a8SYork Sun pfn = err_addr >> PAGE_SHIFT;
316ea2eb9a8SYork Sun
317ea2eb9a8SYork Sun for (row_index = 0; row_index < mci->nr_csrows; row_index++) {
318ea2eb9a8SYork Sun csrow = mci->csrows[row_index];
319ea2eb9a8SYork Sun if ((pfn >= csrow->first_page) && (pfn <= csrow->last_page))
320ea2eb9a8SYork Sun break;
321ea2eb9a8SYork Sun }
322ea2eb9a8SYork Sun
323339fdff1SYork Sun cap_high = ddr_in32(pdata->mc_vbase + FSL_MC_CAPTURE_DATA_HI);
324339fdff1SYork Sun cap_low = ddr_in32(pdata->mc_vbase + FSL_MC_CAPTURE_DATA_LO);
325ea2eb9a8SYork Sun
326ea2eb9a8SYork Sun /*
327ea2eb9a8SYork Sun * Analyze single-bit errors on 64-bit wide buses
328ea2eb9a8SYork Sun * TODO: Add support for 32-bit wide buses
329ea2eb9a8SYork Sun */
330ea2eb9a8SYork Sun if ((err_detect & DDR_EDE_SBE) && (bus_width == 64)) {
331ea2eb9a8SYork Sun sbe_ecc_decode(cap_high, cap_low, syndrome,
332ea2eb9a8SYork Sun &bad_data_bit, &bad_ecc_bit);
333ea2eb9a8SYork Sun
334ea2eb9a8SYork Sun if (bad_data_bit != -1)
335d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR,
336ea2eb9a8SYork Sun "Faulty Data bit: %d\n", bad_data_bit);
337ea2eb9a8SYork Sun if (bad_ecc_bit != -1)
338d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR,
339ea2eb9a8SYork Sun "Faulty ECC bit: %d\n", bad_ecc_bit);
340ea2eb9a8SYork Sun
341d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR,
342ea2eb9a8SYork Sun "Expected Data / ECC:\t%#8.8x_%08x / %#2.2x\n",
343ea2eb9a8SYork Sun cap_high ^ (1 << (bad_data_bit - 32)),
344ea2eb9a8SYork Sun cap_low ^ (1 << bad_data_bit),
345ea2eb9a8SYork Sun syndrome ^ (1 << bad_ecc_bit));
346ea2eb9a8SYork Sun }
347ea2eb9a8SYork Sun
348d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR,
349ea2eb9a8SYork Sun "Captured Data / ECC:\t%#8.8x_%08x / %#2.2x\n",
350ea2eb9a8SYork Sun cap_high, cap_low, syndrome);
351d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR, "Err addr: %#8.8llx\n", err_addr);
352d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR, "PFN: %#8.8x\n", pfn);
353ea2eb9a8SYork Sun
354ea2eb9a8SYork Sun /* we are out of range */
355ea2eb9a8SYork Sun if (row_index == mci->nr_csrows)
356d43a9fb2SYork Sun fsl_mc_printk(mci, KERN_ERR, "PFN out of range!\n");
357ea2eb9a8SYork Sun
358ea2eb9a8SYork Sun if (err_detect & DDR_EDE_SBE)
359ea2eb9a8SYork Sun edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 1,
360ea2eb9a8SYork Sun pfn, err_addr & ~PAGE_MASK, syndrome,
361ea2eb9a8SYork Sun row_index, 0, -1,
362ea2eb9a8SYork Sun mci->ctl_name, "");
363ea2eb9a8SYork Sun
364ea2eb9a8SYork Sun if (err_detect & DDR_EDE_MBE)
365ea2eb9a8SYork Sun edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, 1,
366ea2eb9a8SYork Sun pfn, err_addr & ~PAGE_MASK, syndrome,
367ea2eb9a8SYork Sun row_index, 0, -1,
368ea2eb9a8SYork Sun mci->ctl_name, "");
369ea2eb9a8SYork Sun
370339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_DETECT, err_detect);
371ea2eb9a8SYork Sun }
372ea2eb9a8SYork Sun
fsl_mc_isr(int irq,void * dev_id)373d43a9fb2SYork Sun static irqreturn_t fsl_mc_isr(int irq, void *dev_id)
374ea2eb9a8SYork Sun {
375ea2eb9a8SYork Sun struct mem_ctl_info *mci = dev_id;
376d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
377ea2eb9a8SYork Sun u32 err_detect;
378ea2eb9a8SYork Sun
379339fdff1SYork Sun err_detect = ddr_in32(pdata->mc_vbase + FSL_MC_ERR_DETECT);
380ea2eb9a8SYork Sun if (!err_detect)
381ea2eb9a8SYork Sun return IRQ_NONE;
382ea2eb9a8SYork Sun
383d43a9fb2SYork Sun fsl_mc_check(mci);
384ea2eb9a8SYork Sun
385ea2eb9a8SYork Sun return IRQ_HANDLED;
386ea2eb9a8SYork Sun }
387ea2eb9a8SYork Sun
fsl_ddr_init_csrows(struct mem_ctl_info * mci)388d43a9fb2SYork Sun static void fsl_ddr_init_csrows(struct mem_ctl_info *mci)
389ea2eb9a8SYork Sun {
390d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
391ea2eb9a8SYork Sun struct csrow_info *csrow;
392ea2eb9a8SYork Sun struct dimm_info *dimm;
393ea2eb9a8SYork Sun u32 sdram_ctl;
394ea2eb9a8SYork Sun u32 sdtype;
395ea2eb9a8SYork Sun enum mem_type mtype;
396ea2eb9a8SYork Sun u32 cs_bnds;
397ea2eb9a8SYork Sun int index;
398ea2eb9a8SYork Sun
399339fdff1SYork Sun sdram_ctl = ddr_in32(pdata->mc_vbase + FSL_MC_DDR_SDRAM_CFG);
400ea2eb9a8SYork Sun
401ea2eb9a8SYork Sun sdtype = sdram_ctl & DSC_SDTYPE_MASK;
402ea2eb9a8SYork Sun if (sdram_ctl & DSC_RD_EN) {
403ea2eb9a8SYork Sun switch (sdtype) {
4044e2c3252SYork Sun case 0x02000000:
405ea2eb9a8SYork Sun mtype = MEM_RDDR;
406ea2eb9a8SYork Sun break;
4074e2c3252SYork Sun case 0x03000000:
408ea2eb9a8SYork Sun mtype = MEM_RDDR2;
409ea2eb9a8SYork Sun break;
4104e2c3252SYork Sun case 0x07000000:
411ea2eb9a8SYork Sun mtype = MEM_RDDR3;
412ea2eb9a8SYork Sun break;
4134e2c3252SYork Sun case 0x05000000:
4144e2c3252SYork Sun mtype = MEM_RDDR4;
4154e2c3252SYork Sun break;
416ea2eb9a8SYork Sun default:
417ea2eb9a8SYork Sun mtype = MEM_UNKNOWN;
418ea2eb9a8SYork Sun break;
419ea2eb9a8SYork Sun }
420ea2eb9a8SYork Sun } else {
421ea2eb9a8SYork Sun switch (sdtype) {
4224e2c3252SYork Sun case 0x02000000:
423ea2eb9a8SYork Sun mtype = MEM_DDR;
424ea2eb9a8SYork Sun break;
4254e2c3252SYork Sun case 0x03000000:
426ea2eb9a8SYork Sun mtype = MEM_DDR2;
427ea2eb9a8SYork Sun break;
4284e2c3252SYork Sun case 0x07000000:
429ea2eb9a8SYork Sun mtype = MEM_DDR3;
430ea2eb9a8SYork Sun break;
4314e2c3252SYork Sun case 0x05000000:
4324e2c3252SYork Sun mtype = MEM_DDR4;
4334e2c3252SYork Sun break;
434ea2eb9a8SYork Sun default:
435ea2eb9a8SYork Sun mtype = MEM_UNKNOWN;
436ea2eb9a8SYork Sun break;
437ea2eb9a8SYork Sun }
438ea2eb9a8SYork Sun }
439ea2eb9a8SYork Sun
440ea2eb9a8SYork Sun for (index = 0; index < mci->nr_csrows; index++) {
441ea2eb9a8SYork Sun u32 start;
442ea2eb9a8SYork Sun u32 end;
443ea2eb9a8SYork Sun
444ea2eb9a8SYork Sun csrow = mci->csrows[index];
445ea2eb9a8SYork Sun dimm = csrow->channels[0]->dimm;
446ea2eb9a8SYork Sun
447339fdff1SYork Sun cs_bnds = ddr_in32(pdata->mc_vbase + FSL_MC_CS_BNDS_0 +
448d43a9fb2SYork Sun (index * FSL_MC_CS_BNDS_OFS));
449ea2eb9a8SYork Sun
450ea2eb9a8SYork Sun start = (cs_bnds & 0xffff0000) >> 16;
451ea2eb9a8SYork Sun end = (cs_bnds & 0x0000ffff);
452ea2eb9a8SYork Sun
453ea2eb9a8SYork Sun if (start == end)
454ea2eb9a8SYork Sun continue; /* not populated */
455ea2eb9a8SYork Sun
456ea2eb9a8SYork Sun start <<= (24 - PAGE_SHIFT);
457ea2eb9a8SYork Sun end <<= (24 - PAGE_SHIFT);
458ea2eb9a8SYork Sun end |= (1 << (24 - PAGE_SHIFT)) - 1;
459ea2eb9a8SYork Sun
460ea2eb9a8SYork Sun csrow->first_page = start;
461ea2eb9a8SYork Sun csrow->last_page = end;
462ea2eb9a8SYork Sun
463ea2eb9a8SYork Sun dimm->nr_pages = end + 1 - start;
464ea2eb9a8SYork Sun dimm->grain = 8;
465ea2eb9a8SYork Sun dimm->mtype = mtype;
466ea2eb9a8SYork Sun dimm->dtype = DEV_UNKNOWN;
467ea2eb9a8SYork Sun if (sdram_ctl & DSC_X32_EN)
468ea2eb9a8SYork Sun dimm->dtype = DEV_X32;
469ea2eb9a8SYork Sun dimm->edac_mode = EDAC_SECDED;
470ea2eb9a8SYork Sun }
471ea2eb9a8SYork Sun }
472ea2eb9a8SYork Sun
fsl_mc_err_probe(struct platform_device * op)473d43a9fb2SYork Sun int fsl_mc_err_probe(struct platform_device *op)
474ea2eb9a8SYork Sun {
475ea2eb9a8SYork Sun struct mem_ctl_info *mci;
476ea2eb9a8SYork Sun struct edac_mc_layer layers[2];
477d43a9fb2SYork Sun struct fsl_mc_pdata *pdata;
478ea2eb9a8SYork Sun struct resource r;
479ea2eb9a8SYork Sun u32 sdram_ctl;
480ea2eb9a8SYork Sun int res;
481ea2eb9a8SYork Sun
482d43a9fb2SYork Sun if (!devres_open_group(&op->dev, fsl_mc_err_probe, GFP_KERNEL))
483ea2eb9a8SYork Sun return -ENOMEM;
484ea2eb9a8SYork Sun
485ea2eb9a8SYork Sun layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
486ea2eb9a8SYork Sun layers[0].size = 4;
487ea2eb9a8SYork Sun layers[0].is_virt_csrow = true;
488ea2eb9a8SYork Sun layers[1].type = EDAC_MC_LAYER_CHANNEL;
489ea2eb9a8SYork Sun layers[1].size = 1;
490ea2eb9a8SYork Sun layers[1].is_virt_csrow = false;
491ea2eb9a8SYork Sun mci = edac_mc_alloc(edac_mc_idx, ARRAY_SIZE(layers), layers,
492ea2eb9a8SYork Sun sizeof(*pdata));
493ea2eb9a8SYork Sun if (!mci) {
494d43a9fb2SYork Sun devres_release_group(&op->dev, fsl_mc_err_probe);
495ea2eb9a8SYork Sun return -ENOMEM;
496ea2eb9a8SYork Sun }
497ea2eb9a8SYork Sun
498ea2eb9a8SYork Sun pdata = mci->pvt_info;
499d43a9fb2SYork Sun pdata->name = "fsl_mc_err";
500ea2eb9a8SYork Sun mci->pdev = &op->dev;
501ea2eb9a8SYork Sun pdata->edac_idx = edac_mc_idx++;
502ea2eb9a8SYork Sun dev_set_drvdata(mci->pdev, mci);
503ea2eb9a8SYork Sun mci->ctl_name = pdata->name;
504ea2eb9a8SYork Sun mci->dev_name = pdata->name;
505ea2eb9a8SYork Sun
506339fdff1SYork Sun /*
507339fdff1SYork Sun * Get the endianness of DDR controller registers.
508339fdff1SYork Sun * Default is big endian.
509339fdff1SYork Sun */
510339fdff1SYork Sun little_endian = of_property_read_bool(op->dev.of_node, "little-endian");
511339fdff1SYork Sun
512ea2eb9a8SYork Sun res = of_address_to_resource(op->dev.of_node, 0, &r);
513ea2eb9a8SYork Sun if (res) {
514ea2eb9a8SYork Sun pr_err("%s: Unable to get resource for MC err regs\n",
515ea2eb9a8SYork Sun __func__);
516ea2eb9a8SYork Sun goto err;
517ea2eb9a8SYork Sun }
518ea2eb9a8SYork Sun
519ea2eb9a8SYork Sun if (!devm_request_mem_region(&op->dev, r.start, resource_size(&r),
520ea2eb9a8SYork Sun pdata->name)) {
521ea2eb9a8SYork Sun pr_err("%s: Error while requesting mem region\n",
522ea2eb9a8SYork Sun __func__);
523ea2eb9a8SYork Sun res = -EBUSY;
524ea2eb9a8SYork Sun goto err;
525ea2eb9a8SYork Sun }
526ea2eb9a8SYork Sun
527ea2eb9a8SYork Sun pdata->mc_vbase = devm_ioremap(&op->dev, r.start, resource_size(&r));
528ea2eb9a8SYork Sun if (!pdata->mc_vbase) {
529ea2eb9a8SYork Sun pr_err("%s: Unable to setup MC err regs\n", __func__);
530ea2eb9a8SYork Sun res = -ENOMEM;
531ea2eb9a8SYork Sun goto err;
532ea2eb9a8SYork Sun }
533ea2eb9a8SYork Sun
534339fdff1SYork Sun sdram_ctl = ddr_in32(pdata->mc_vbase + FSL_MC_DDR_SDRAM_CFG);
535ea2eb9a8SYork Sun if (!(sdram_ctl & DSC_ECC_EN)) {
536ea2eb9a8SYork Sun /* no ECC */
537ea2eb9a8SYork Sun pr_warn("%s: No ECC DIMMs discovered\n", __func__);
538ea2eb9a8SYork Sun res = -ENODEV;
539ea2eb9a8SYork Sun goto err;
540ea2eb9a8SYork Sun }
541ea2eb9a8SYork Sun
542ea2eb9a8SYork Sun edac_dbg(3, "init mci\n");
5434e2c3252SYork Sun mci->mtype_cap = MEM_FLAG_DDR | MEM_FLAG_RDDR |
5444e2c3252SYork Sun MEM_FLAG_DDR2 | MEM_FLAG_RDDR2 |
5454e2c3252SYork Sun MEM_FLAG_DDR3 | MEM_FLAG_RDDR3 |
5464e2c3252SYork Sun MEM_FLAG_DDR4 | MEM_FLAG_RDDR4;
547ea2eb9a8SYork Sun mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED;
548ea2eb9a8SYork Sun mci->edac_cap = EDAC_FLAG_SECDED;
549ea2eb9a8SYork Sun mci->mod_name = EDAC_MOD_STR;
550ea2eb9a8SYork Sun
551ea2eb9a8SYork Sun if (edac_op_state == EDAC_OPSTATE_POLL)
552d43a9fb2SYork Sun mci->edac_check = fsl_mc_check;
553ea2eb9a8SYork Sun
554ea2eb9a8SYork Sun mci->ctl_page_to_phys = NULL;
555ea2eb9a8SYork Sun
556ea2eb9a8SYork Sun mci->scrub_mode = SCRUB_SW_SRC;
557ea2eb9a8SYork Sun
558d43a9fb2SYork Sun fsl_ddr_init_csrows(mci);
559ea2eb9a8SYork Sun
560ea2eb9a8SYork Sun /* store the original error disable bits */
561339fdff1SYork Sun orig_ddr_err_disable = ddr_in32(pdata->mc_vbase + FSL_MC_ERR_DISABLE);
562339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_DISABLE, 0);
563ea2eb9a8SYork Sun
564ea2eb9a8SYork Sun /* clear all error bits */
565339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_DETECT, ~0);
566ea2eb9a8SYork Sun
56743fa9ba6SWei Yongjun res = edac_mc_add_mc_with_groups(mci, fsl_ddr_dev_groups);
56843fa9ba6SWei Yongjun if (res) {
569ea2eb9a8SYork Sun edac_dbg(3, "failed edac_mc_add_mc()\n");
570ea2eb9a8SYork Sun goto err;
571ea2eb9a8SYork Sun }
572ea2eb9a8SYork Sun
573ea2eb9a8SYork Sun if (edac_op_state == EDAC_OPSTATE_INT) {
574339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_INT_EN,
575ea2eb9a8SYork Sun DDR_EIE_MBEE | DDR_EIE_SBEE);
576ea2eb9a8SYork Sun
577ea2eb9a8SYork Sun /* store the original error management threshold */
578339fdff1SYork Sun orig_ddr_err_sbe = ddr_in32(pdata->mc_vbase +
579d43a9fb2SYork Sun FSL_MC_ERR_SBE) & 0xff0000;
580ea2eb9a8SYork Sun
581ea2eb9a8SYork Sun /* set threshold to 1 error per interrupt */
582339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_SBE, 0x10000);
583ea2eb9a8SYork Sun
584ea2eb9a8SYork Sun /* register interrupts */
58555764ed3SYork Sun pdata->irq = platform_get_irq(op, 0);
586ea2eb9a8SYork Sun res = devm_request_irq(&op->dev, pdata->irq,
587d43a9fb2SYork Sun fsl_mc_isr,
588ea2eb9a8SYork Sun IRQF_SHARED,
589ea2eb9a8SYork Sun "[EDAC] MC err", mci);
590ea2eb9a8SYork Sun if (res < 0) {
591d43a9fb2SYork Sun pr_err("%s: Unable to request irq %d for FSL DDR DRAM ERR\n",
592ea2eb9a8SYork Sun __func__, pdata->irq);
593ea2eb9a8SYork Sun res = -ENODEV;
594ea2eb9a8SYork Sun goto err2;
595ea2eb9a8SYork Sun }
596ea2eb9a8SYork Sun
597ea2eb9a8SYork Sun pr_info(EDAC_MOD_STR " acquired irq %d for MC\n",
598ea2eb9a8SYork Sun pdata->irq);
599ea2eb9a8SYork Sun }
600ea2eb9a8SYork Sun
601d43a9fb2SYork Sun devres_remove_group(&op->dev, fsl_mc_err_probe);
602ea2eb9a8SYork Sun edac_dbg(3, "success\n");
603ea2eb9a8SYork Sun pr_info(EDAC_MOD_STR " MC err registered\n");
604ea2eb9a8SYork Sun
605ea2eb9a8SYork Sun return 0;
606ea2eb9a8SYork Sun
607ea2eb9a8SYork Sun err2:
608ea2eb9a8SYork Sun edac_mc_del_mc(&op->dev);
609ea2eb9a8SYork Sun err:
610d43a9fb2SYork Sun devres_release_group(&op->dev, fsl_mc_err_probe);
611ea2eb9a8SYork Sun edac_mc_free(mci);
612ea2eb9a8SYork Sun return res;
613ea2eb9a8SYork Sun }
614ea2eb9a8SYork Sun
fsl_mc_err_remove(struct platform_device * op)615d43a9fb2SYork Sun int fsl_mc_err_remove(struct platform_device *op)
616ea2eb9a8SYork Sun {
617ea2eb9a8SYork Sun struct mem_ctl_info *mci = dev_get_drvdata(&op->dev);
618d43a9fb2SYork Sun struct fsl_mc_pdata *pdata = mci->pvt_info;
619ea2eb9a8SYork Sun
620ea2eb9a8SYork Sun edac_dbg(0, "\n");
621ea2eb9a8SYork Sun
622ea2eb9a8SYork Sun if (edac_op_state == EDAC_OPSTATE_INT) {
623339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_INT_EN, 0);
624ea2eb9a8SYork Sun }
625ea2eb9a8SYork Sun
626339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_DISABLE,
627ea2eb9a8SYork Sun orig_ddr_err_disable);
628339fdff1SYork Sun ddr_out32(pdata->mc_vbase + FSL_MC_ERR_SBE, orig_ddr_err_sbe);
629ea2eb9a8SYork Sun
630ea2eb9a8SYork Sun edac_mc_del_mc(&op->dev);
631ea2eb9a8SYork Sun edac_mc_free(mci);
632ea2eb9a8SYork Sun return 0;
633ea2eb9a8SYork Sun }
634