Add Aspeed AST2700 SDRAM EDAC support
Subsystems (4)
Ryan Chen
reviewerv6 cover Add Aspeed AST2700 SDRAM EDAC support
Add ECC error reporting for the Aspeed AST2700 SoC to the existing aspeed_edac driver.
The AST2700 memory controller keeps the same overall EDAC programming model as the earlier Aspeed BMC SoCs, but uses a different register layout, a split interrupt status/clear/mask scheme and DDR4/DDR5 memory. Rather than fork the driver, the existing code is first generalised, then the AST2700 is added as one more per-SoC variant.
The bug fixes, cleanups and AST2700 binding from v5 (v5 patches 1-5) have been applied to the edac-drivers-aspeed branch ofgit://git.kernel.org/pub/scm/linux/kernel/git/bp/bp.git, and this series is based on that branch.
Patches 1 and 2 rework the implementation to accommodate the AST2700:
patch 1 replaces the driver's private regmap with direct register access, and patch 2 moves the SoC-specific details behind per-SoC chip data. Patch 3 adds the AST2700 support itself. Patch 4 is Stefan's step-down patch, amended to leave the entry in place with me as its reviewer.
Claude, an AI coding assistant, was used in developing patches 1-3. It drafted parts of the code and of the changelogs, and proposed the locking changes in this revision. I reviewed every change, and the AST2600 and AST2700 test results are in patches 2 and 3.
---
Changes in v6:
- Rebase onto the edac-drivers-aspeed branch of bp.git and drop the five v5 patches applied there (v5 patches 1-5). v5 patches 6-9 are now patches 1-4.
- Patch 1: use a spinlock_t rather than a raw_spinlock_t for the register lock, as regmap did; the interrupt handler is not IRQF_NO_THREAD. Patches 2 and 3 follow.
- Patch 1: drop the __guarded_by() annotations and the context analysis opt-in, and assign the register base in probe without taking the
lock, so aspeed_probe() no longer mixes scoped_guard() with goto unwinding.
- Link to v5: https://lore.kernel.org/r/[email protected]
Changes in v5:
- v5 patch 2: register the ECC interrupt with request_irq() instead of devm_request_irq() followed by an explicit free, and keep the interrupt number alongside the driver's other state so
aspeed_remove() does not have to call platform_get_irq() again.
- Link to v4: https://lore.kernel.org/r/[email protected]
Changes in v4:
- Put the bug fixes first: the two fixes became v4 patches 1 and 2, the cleanups v4 patches 3 and 4, and the bindings patch moved to v4
patch 5 ahead of the AST2700 work.
- Explain in v4 patch 1 where the grain value comes from, rather than the warning it silences.
- Drop the Cc: stable tags from the two fixes. Neither meets the bar in Documentation/process/stable-kernel-rules.rst; the Fixes: tags stay.
- Merge Stefan's step-down patch into v4 patch 9 (now patch 4),
keeping the MAINTAINERS entry alive with a reviewer instead of removing it.
- Link to v3: https://lore.kernel.org/r/[email protected]
Changes in v3:
- Establish the AST2700 interrupt mask in the driver rather than deriving it from the register's contents: ast2700_set_irq() now
writes the mask outright, masking every source and unmasking only
the ECC ones, and the mask is established before the interrupt is requested.
- New patch: add myself as a reviewer for the driver in MAINTAINERS.
- Tested on an AST2600 with CONFIG_PROVE_LOCKING=y; injected correctable errors are reported from the interrupt handler with no lockdep reports.
- Link to v2: https://lore.kernel.org/r/[email protected]
Changes in v2:
- New patch (v5 patch 2, now applied): free the ECC interrupt before
the mem_ctl_info in aspeed_remove(). The interrupt is requested with devm_request_irq() and is only released after .remove() has returned, so edac_mc_free() could free the handler's context while the handler was still running on another CPU.
- Acquire the register lock with the irqsave variant in init_csrows() and in aspeed_probe(). The interrupt handler takes the same lock in hardirq context.
- Move the dev_dbg() of the interrupt status register out of the raw_spinlock critical section in the interrupt handler.
- Opt aspeed_edac.o into context analysis in drivers/edac/Makefile. The check is opt-in per object, so without it the __guarded_by() annotation added by the same patch was never actually verified.
- Return IRQ_NONE from ast2700_dramc_isr() when no ECC interrupt status bit is set; the handler clears only the ECC bits, so unconditionally claiming the interrupt could livelock the level-triggered line.
- Tested v2 on both AST2600 and AST2700 by injecting a correctable
error with the memory controller's ECC error injection; each is reported as a CE with the expected failure address.
- Link to v1: https://lore.kernel.org/r/[email protected]
---
Ryan Chen (3):
EDAC/aspeed: Replace regmap with direct register access EDAC/aspeed: Abstract SoC differences behind chip data EDAC/aspeed: Add AST2700 support
Stefan M Schaeckeler (1):
MAINTAINERS: Step down as Aspeed AST2500 EDAC driver maintainer
CREDITS | 8 + .../bindings/edac/aspeed,ast2400-sdram-edac.yaml | 2 +- MAINTAINERS | 2 +- drivers/edac/aspeed_edac.c | 385 ++++++++++++++------- 4 files changed, 273 insertions(+), 124 deletions(-)
---
base-commit: 65d0a904696bae7e99a2c6eef61d4df03bac025f
change-id: 20260625-edac-8e960e02e7f7
Best regards,
Signature · 1 line
Ryan Chen <[email protected]>
Ryan Chen
reviewerPATCH v6 1/4 EDAC/aspeed: Replace regmap with direct register access
The driver instantiates its own regmap purely as an MMIO wrapper: it has no register cache, uses custom .reg_read()/.reg_write() callbacks, and is not shared as a syscon with other drivers. So it brings nothing here beyond the spinlock that regmap takes around each access when fast_io is set.
Drop the regmap and access the registers directly with readl()/writel() under an explicit spinlock, held across the whole read-modify-write so the controller is unlocked once around the grouped writes rather than on every register write.
---
Changes in v6:
- Use a spinlock_t rather than a raw_spinlock_t, as regmap did; the interrupt handler is not IRQF_NO_THREAD, so a raw lock is not needed.
- Drop the __guarded_by() annotation and the context analysis opt-in, and assign the register base in probe without taking the lock, so aspeed_probe() no longer mixes a cleanup helper with goto unwinding.
Changes in v2:
- Take the register lock with the irqsave variant in init_csrows() and in aspeed_probe(); the interrupt handler takes the same lock in hardirq context.
- Move the dev_dbg() of the interrupt status register out of the raw_spinlock critical section in the interrupt handler.
- Opt aspeed_edac.o into context analysis in drivers/edac/Makefile, so that the __guarded_by() annotation is actually checked.
- Note in the interrupt handler that the counter and interrupt flag fields are read-only, so writing back the read value is harmless.
--- drivers/edac/aspeed_edac.c | 130 +++++++++++++++++---------------------------- 1 file changed, 49 insertions(+), 81 deletions(-)
drivers/edac/aspeed_edac.c +49 -81
@@ -3,6 +3,7 @@* Copyright 2018, 2019 Cisco Systems */ +#include <linux/cleanup.h> #include <linux/edac.h> #include <linux/init.h> #include <linux/interrupt.h>
@@ -10,7 +11,7 @@#include <linux/module.h> #include <linux/of_address.h> #include <linux/platform_device.h> -#include <linux/regmap.h> +#include <linux/spinlock.h> #include "edac_module.h" #define DRV_NAME "aspeed-edac"
@@ -20,7 +21,6 @@#define ASPEED_MCR_INTR_CTRL 0x50/* interrupt control/status register */ #define ASPEED_MCR_ADDR_UNREC 0x58/* address of first un-recoverable error */ #define ASPEED_MCR_ADDR_REC 0x5c/* address of last recoverable error */ -#define ASPEED_MCR_LAST ASPEED_MCR_ADDR_REC#define ASPEED_MCR_PROT_PASSWD 0xfc600309#define ASPEED_MCR_CONF_DRAM_TYPE BIT(4)
@@ -30,57 +30,10 @@#define ASPEED_MCR_INTR_CTRL_CNT_UNREC GENMASK(15, 12)#define ASPEED_MCR_INTR_CTRL_ENABLE (BIT(0) | BIT(1)) -static struct regmap *aspeed_regmap; +static DEFINE_SPINLOCK (aspeed_lock); +static void __iomem *aspeed_regs;static int aspeed_irq; -static int regmap_reg_write (void *context,unsigned int reg,unsigned int val) -{ -void __iomem *regs = (void __iomem *)context; - -/* enable write to MCR register set */ -writel (ASPEED_MCR_PROT_PASSWD , regs +ASPEED_MCR_PROT ); - -writel (val, regs + reg); - -/* disable write to MCR register set */ -writel (~ASPEED_MCR_PROT_PASSWD , regs +ASPEED_MCR_PROT ); - -return 0 ; -} - -static int regmap_reg_read (void *context,unsigned int reg,unsigned int *val) -{ -void __iomem *regs = (void __iomem *)context; - - *val =readl (regs + reg); - -return 0 ; -} - -static bool regmap_is_volatile (struct device *dev,unsigned int reg) -{ -switch (reg) { -case ASPEED_MCR_PROT : -case ASPEED_MCR_INTR_CTRL : -case ASPEED_MCR_ADDR_UNREC : -case ASPEED_MCR_ADDR_REC : -return true; -default : -return false; - } -} - -static const struct regmap_config aspeed_regmap_config = { - .reg_bits =32 , - .val_bits =32 , - .reg_stride =4 , - .max_register =ASPEED_MCR_LAST , - .reg_write = regmap_reg_write, - .reg_read = regmap_reg_read, - .volatile_reg = regmap_is_volatile, - .fast_io = true, -}; -static void count_rec (struct mem_ctl_info *mci,u8 rec_cnt,u32 rec_addr) {struct csrow_info *csrow = mci->csrows[0 ];
@@ -148,10 +101,27 @@ static irqreturn_t mcr_isr(int irq, void *arg) {struct mem_ctl_info *mci = arg;u32 rec_addr, un_rec_addr; -u32 reg50, reg5c, reg58; -u8 rec_cnt, un_rec_cnt; +u8 rec_cnt, un_rec_cnt; +u32 reg50; + + scoped_guard(spinlock, &aspeed_lock) { + reg50 =readl (aspeed_regs +ASPEED_MCR_INTR_CTRL ); + un_rec_addr =readl (aspeed_regs +ASPEED_MCR_ADDR_UNREC ); + rec_addr =readl (aspeed_regs +ASPEED_MCR_ADDR_REC ); + +/* +* Clearing the counters needs a set-then-clear of CLEAR. The +* counter and interrupt flag fields are read-only, so writing +* back the values read above leaves them unaffected. +*/ +writel (ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); +writel (reg50 |ASPEED_MCR_INTR_CTRL_CLEAR , + aspeed_regs +ASPEED_MCR_INTR_CTRL ); +writel (reg50 & ~ASPEED_MCR_INTR_CTRL_CLEAR , + aspeed_regs +ASPEED_MCR_INTR_CTRL ); +writel (~ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); + } -regmap_read (aspeed_regmap,ASPEED_MCR_INTR_CTRL , ®50);dev_dbg (mci->pdev,"received edac interrupt w/ mcr register 50: 0x%x\n" , reg50);
@@ -162,20 +132,6 @@ static irqreturn_t mcr_isr(int irq, void *arg)dev_dbg (mci->pdev,"%d recoverable interrupts and %d unrecoverable interrupts\n" , rec_cnt, un_rec_cnt); -regmap_read (aspeed_regmap,ASPEED_MCR_ADDR_UNREC , ®58); - un_rec_addr = reg58; - -regmap_read (aspeed_regmap,ASPEED_MCR_ADDR_REC , ®5c); - rec_addr = reg5c; - -/* clear interrupt flags and error counters: */ -regmap_update_bits (aspeed_regmap,ASPEED_MCR_INTR_CTRL , -ASPEED_MCR_INTR_CTRL_CLEAR , -ASPEED_MCR_INTR_CTRL_CLEAR ); - -regmap_update_bits (aspeed_regmap,ASPEED_MCR_INTR_CTRL , -ASPEED_MCR_INTR_CTRL_CLEAR ,0 ); -/* process recoverable and unrecoverable errors */ count_rec (mci, rec_cnt, rec_addr);count_un_rec (mci, un_rec_cnt, un_rec_addr);
@@ -183,13 +139,31 @@ static irqreturn_t mcr_isr(int irq, void *arg)if (!rec_cnt && !un_rec_cnt)dev_dbg (mci->pdev,"received edac interrupt, but did not find any ECC counters\n" ); -regmap_read (aspeed_regmap,ASPEED_MCR_INTR_CTRL , ®50); +scoped_guard (spinlock, &aspeed_lock) + reg50 = readl(aspeed_regs + ASPEED_MCR_INTR_CTRL);dev_dbg (mci->pdev,"edac interrupt handled. mcr reg 50 is now: 0x%x\n" , reg50);return IRQ_HANDLED ; } +static void aspeed_set_irq (bool enable) +{ +u32 val; + +guard (spinlock_irqsave)(&aspeed_lock); + + val =readl (aspeed_regs +ASPEED_MCR_INTR_CTRL ); +if (enable) + val |=ASPEED_MCR_INTR_CTRL_ENABLE ; +else + val &= ~ASPEED_MCR_INTR_CTRL_ENABLE ; + +writel (ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); +writel (val, aspeed_regs +ASPEED_MCR_INTR_CTRL ); +writel (~ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); +} +static int config_irq (void *ctx,struct platform_device *pdev) {int irq;
@@ -208,9 +182,7 @@ static int config_irq(void *ctx, struct platform_device *pdev) aspeed_irq = irq;/* enable interrupts */ -regmap_update_bits (aspeed_regmap,ASPEED_MCR_INTR_CTRL , -ASPEED_MCR_INTR_CTRL_ENABLE , -ASPEED_MCR_INTR_CTRL_ENABLE ); +aspeed_set_irq (true);return 0 ; }
@@ -248,7 +220,8 @@ static int init_csrows(struct mem_ctl_info *mci) nr_pages =resource_size (&r) >>PAGE_SHIFT ; csrow->last_page = csrow->first_page + nr_pages -1 ; -regmap_read (aspeed_regmap,ASPEED_MCR_CONF , ®04); +scoped_guard (spinlock_irqsave, &aspeed_lock) + reg04 = readl(aspeed_regs + ASPEED_MCR_CONF); dram_type = (reg04 &ASPEED_MCR_CONF_DRAM_TYPE ) ?MEM_DDR4 :MEM_DDR3 ; dimm = csrow->channels[0 ]->dimm;
@@ -265,7 +238,6 @@ static int init_csrows(struct mem_ctl_info *mci)static int aspeed_probe (struct platform_device *pdev) { -struct device *dev = &pdev->dev;struct edac_mc_layer layers[2 ];struct mem_ctl_info *mci;void __iomem *regs;
@@ -276,13 +248,10 @@ static int aspeed_probe(struct platform_device *pdev)if (IS_ERR (regs))return PTR_ERR (regs); - aspeed_regmap =devm_regmap_init (dev,NULL , (__force void *)regs, - &aspeed_regmap_config); -if (IS_ERR (aspeed_regmap)) -return PTR_ERR (aspeed_regmap); + aspeed_regs = regs;/* bail out if ECC mode is not configured */ -regmap_read (aspeed_regmap,ASPEED_MCR_CONF , ®04); + reg04 =readl (regs +ASPEED_MCR_CONF );if (!(reg04 &ASPEED_MCR_CONF_ECC )) {dev_err (&pdev->dev,"ECC mode is not configured in u-boot\n" );return -EPERM ;
@@ -348,8 +317,7 @@ static void aspeed_remove(struct platform_device *pdev)struct mem_ctl_info *mci =platform_get_drvdata (pdev);/* disable interrupts */ -regmap_update_bits (aspeed_regmap,ASPEED_MCR_INTR_CTRL , -ASPEED_MCR_INTR_CTRL_ENABLE ,0 ); +aspeed_set_irq (false);free_irq (aspeed_irq, mci);
Signature · 1 line
2.34.1
Ryan Chen
reviewerPATCH v6 2/4 EDAC/aspeed: Abstract SoC differences behind chip data
In reply to Ryan ChenThe driver hard-codes the AST2400/2500/2600 register layout, ECC and DRAM-type bits, memory types and write-protection key. Abstract these SoC-specific details behind a per-SoC struct aspeed_edac_chip selected by the compatible, and move the per-instance state (register base, lock) into mci->pvt_info instead of globals, so controller variants that differ in these details can be added as table data.
Only the AST2400 and AST2500 key-protect the interrupt control register (MCR50); the AST2600 does not. Gate the unlock/relock on the chip carrying a protection key and split the shared entry into keyed (AST2400/2500) and unkeyed (AST2600) variants, so the AST2600 no longer performs the unnecessary unlock.
Tested on an AST2600: A correctable error was injected from the console by unlocking the controller and writing its ECC error inject test register:
# mw 1e6e0000 fc600309 # mw 1e6e00b0 81 EDAC MC0: 1 CE address(es) not available on mc#0csrow#0channel#0 (csrow:0 channel:0 page:0x0 offset:0x0 grain:16 syndrome:0x0) EDAC MC0: 1 CE on mc#0csrow#0channel#0 (csrow:0 channel:0 page:0x8a543 offset:0xec0 grain:16 syndrome:0x0)
---
Changes in v6:
- Follow patch 1 ("EDAC/aspeed: Replace regmap with direct register access"): spinlock_t, no __guarded_by()/__must_hold().
Changes in v5:
- Follow v5 patch 2 ("EDAC/aspeed: Free the interrupt before the mem_ctl_info on remove", now applied) in using request_irq()/free_irq().
Changes in v2:
- Carry over the irqsave lock acquisition in init_csrows() and the dev_dbg() moved out of the raw_spinlock critical section.
- Store the interrupt number in struct aspeed_edac so that aspeed_remove() can free the interrupt without looking it up again.
--- drivers/edac/aspeed_edac.c | 156 ++++++++++++++++++++++++++++++++------------- 1 file changed, 110 insertions(+), 46 deletions(-)
drivers/edac/aspeed_edac.c +110 -46
@@ -3,12 +3,14 @@* Copyright 2018, 2019 Cisco Systems */ +#include <linux/bitfield.h> #include <linux/cleanup.h> #include <linux/edac.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/io.h> #include <linux/module.h> +#include <linux/of.h> #include <linux/of_address.h> #include <linux/platform_device.h> #include <linux/spinlock.h>
@@ -30,9 +32,23 @@#define ASPEED_MCR_INTR_CTRL_CNT_UNREC GENMASK(15, 12)#define ASPEED_MCR_INTR_CTRL_ENABLE (BIT(0) | BIT(1)) -static DEFINE_SPINLOCK (aspeed_lock); -static void __iomem *aspeed_regs; -static int aspeed_irq; +struct aspeed_edac_chip { +unsigned int conf_reg; +u32 conf_ecc; +u32 conf_dram_type; +enum mem_type dram_type[2 ]; +unsigned long mtype_cap; +unsigned int prot_reg; +u32 prot_key; +}; + +struct aspeed_edac { +spinlock_t lock; + +void __iomem *regs; +const struct aspeed_edac_chip *chip; +int irq; +};static void count_rec (struct mem_ctl_info *mci,u8 rec_cnt,u32 rec_addr) {
@@ -97,37 +113,52 @@ static void count_un_rec(struct mem_ctl_info *mci, u8 un_rec_cnt, } } -static irqreturn_t mcr_isr (int irq,void *arg) +static void aspeed_mcr_irq_update_enter (struct aspeed_edac *priv) +{ +if (priv->chip->prot_key) +writel (priv->chip->prot_key, priv->regs + priv->chip->prot_reg); +} + +static void aspeed_mcr_irq_update_exit (struct aspeed_edac *priv) +{ +if (priv->chip->prot_key) +writel (~priv->chip->prot_key, priv->regs + priv->chip->prot_reg); +} + +static irqreturn_t aspeed_mcr_isr (int irq,void *arg) {struct mem_ctl_info *mci = arg;u32 rec_addr, un_rec_addr; +struct aspeed_edac *priv;u8 rec_cnt, un_rec_cnt;u32 reg50; - scoped_guard(spinlock, &aspeed_lock) { - reg50 =readl (aspeed_regs +ASPEED_MCR_INTR_CTRL ); - un_rec_addr =readl (aspeed_regs +ASPEED_MCR_ADDR_UNREC ); - rec_addr =readl (aspeed_regs +ASPEED_MCR_ADDR_REC ); + priv = mci->pvt_info; + + scoped_guard(spinlock, &priv->lock) { + reg50 =readl (priv->regs +ASPEED_MCR_INTR_CTRL ); + un_rec_addr =readl (priv->regs +ASPEED_MCR_ADDR_UNREC ); + rec_addr =readl (priv->regs +ASPEED_MCR_ADDR_REC );/* * Clearing the counters needs a set-then-clear of CLEAR. The * counter and interrupt flag fields are read-only, so writing * back the values read above leaves them unaffected. */ -writel (ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); +aspeed_mcr_irq_update_enter (priv);writel (reg50 |ASPEED_MCR_INTR_CTRL_CLEAR , - aspeed_regs +ASPEED_MCR_INTR_CTRL ); + priv->regs +ASPEED_MCR_INTR_CTRL );writel (reg50 & ~ASPEED_MCR_INTR_CTRL_CLEAR , - aspeed_regs +ASPEED_MCR_INTR_CTRL ); -writel (~ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); + priv->regs +ASPEED_MCR_INTR_CTRL ); +aspeed_mcr_irq_update_exit (priv); }dev_dbg (mci->pdev,"received edac interrupt w/ mcr register 50: 0x%x\n" , reg50);/* collect data about recoverable and unrecoverable errors */ - rec_cnt = (reg50 &ASPEED_MCR_INTR_CTRL_CNT_REC ) >>16 ; - un_rec_cnt = (reg50 &ASPEED_MCR_INTR_CTRL_CNT_UNREC ) >>12 ; + rec_cnt =FIELD_GET (ASPEED_MCR_INTR_CTRL_CNT_REC , reg50); + un_rec_cnt =FIELD_GET (ASPEED_MCR_INTR_CTRL_CNT_UNREC , reg50);dev_dbg (mci->pdev,"%d recoverable interrupts and %d unrecoverable interrupts\n" , rec_cnt, un_rec_cnt);
@@ -137,35 +168,36 @@ static irqreturn_t mcr_isr(int irq, void *arg)count_un_rec (mci, un_rec_cnt, un_rec_addr);if (!rec_cnt && !un_rec_cnt) -dev_dbg (mci->pdev,"received edac interrupt, but did not find any ECC counters\n" ); +dev_dbg_ratelimited (mci->pdev,"received edac interrupt, but did not find any ECC counters\n" ); -scoped_guard (spinlock, &aspeed_lock) - reg50 = readl(aspeed_regs + ASPEED_MCR_INTR_CTRL); +scoped_guard (spinlock, &priv->lock) + reg50 = readl(priv->regs + ASPEED_MCR_INTR_CTRL);dev_dbg (mci->pdev,"edac interrupt handled. mcr reg 50 is now: 0x%x\n" , reg50);return IRQ_HANDLED ; } -static void aspeed_set_irq (bool enable) +static void aspeed_set_irq (struct aspeed_edac *priv,bool enable) {u32 val; -guard (spinlock_irqsave)(&aspeed_lock); +guard (spinlock_irqsave)(&priv->lock); - val =readl (aspeed_regs +ASPEED_MCR_INTR_CTRL ); + val =readl (priv->regs +ASPEED_MCR_INTR_CTRL );if (enable) val |=ASPEED_MCR_INTR_CTRL_ENABLE ;else val &= ~ASPEED_MCR_INTR_CTRL_ENABLE ; -writel (ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); -writel (val, aspeed_regs +ASPEED_MCR_INTR_CTRL ); -writel (~ASPEED_MCR_PROT_PASSWD , aspeed_regs +ASPEED_MCR_PROT ); +aspeed_mcr_irq_update_enter (priv); +writel (val, priv->regs +ASPEED_MCR_INTR_CTRL ); +aspeed_mcr_irq_update_exit (priv); } -static int config_irq (void *ctx,struct platform_device *pdev) +static int config_irq (struct mem_ctl_info *mci,struct platform_device *pdev) { +struct aspeed_edac *priv = mci->pvt_info;int irq;int rc;
@@ -175,14 +207,14 @@ static int config_irq(void *ctx, struct platform_device *pdev)if (irq <0 )return irq; - rc =request_irq (irq, mcr_isr,IRQF_TRIGGER_HIGH ,DRV_NAME , ctx); + rc =request_irq (irq, aspeed_mcr_isr,IRQF_TRIGGER_HIGH ,DRV_NAME , mci);if (rc)return rc; - aspeed_irq = irq; + priv->irq = irq;/* enable interrupts */ -aspeed_set_irq (true); +aspeed_set_irq (priv, true);return 0 ; }
@@ -190,11 +222,13 @@ static int config_irq(void *ctx, struct platform_device *pdev)static int init_csrows (struct mem_ctl_info *mci) {struct csrow_info *csrow = mci->csrows[0 ]; -u32 nr_pages, dram_type; -struct dimm_info *dimm; +struct aspeed_edac *priv = mci->pvt_info;struct device_node *np; +struct dimm_info *dimm;struct resource r; -u32 reg04; +unsigned int type; +u32 nr_pages; +u32 conf;int rc;/* retrieve info about physical memory from device tree */
@@ -220,12 +254,12 @@ static int init_csrows(struct mem_ctl_info *mci) nr_pages =resource_size (&r) >>PAGE_SHIFT ; csrow->last_page = csrow->first_page + nr_pages -1 ; -scoped_guard (spinlock_irqsave, &aspeed_lock) - reg04 = readl(aspeed_regs + ASPEED_MCR_CONF); - dram_type = (reg04 &ASPEED_MCR_CONF_DRAM_TYPE ) ?MEM_DDR4 :MEM_DDR3 ; +scoped_guard (spinlock_irqsave, &priv->lock) + conf = readl(priv->regs + priv->chip->conf_reg); + type =field_get (priv->chip->conf_dram_type, conf); dimm = csrow->channels[0 ]->dimm; - dimm->mtype = dram_type; + dimm->mtype = priv->chip->dram_type[type]; dimm->edac_mode =EDAC_SECDED ; dimm->nr_pages = nr_pages / csrow->nr_channels; dimm->grain =16 ;
@@ -238,21 +272,26 @@ static int init_csrows(struct mem_ctl_info *mci)static int aspeed_probe (struct platform_device *pdev) { +const struct aspeed_edac_chip *chip; +struct device *dev = &pdev->dev;struct edac_mc_layer layers[2 ]; +struct aspeed_edac *priv;struct mem_ctl_info *mci;void __iomem *regs; -u32 reg04; +u32 conf;int rc; + chip =of_device_get_match_data (dev); +if (!chip) +return -EINVAL ; + regs =devm_platform_ioremap_resource (pdev,0 );if (IS_ERR (regs))return PTR_ERR (regs); - aspeed_regs = regs; -/* bail out if ECC mode is not configured */ - reg04 =readl (regs +ASPEED_MCR_CONF ); -if (!(reg04 &ASPEED_MCR_CONF_ECC )) { + conf =readl (regs + chip->conf_reg); +if (!field_get (chip->conf_ecc, conf)) {dev_err (&pdev->dev,"ECC mode is not configured in u-boot\n" );return -EPERM ; }
@@ -267,12 +306,17 @@ static int aspeed_probe(struct platform_device *pdev) layers[1 ].size =1 ; layers[1 ].is_virt_csrow = false; - mci =edac_mc_alloc (0 ,ARRAY_SIZE (layers), layers,0 ); + mci =edac_mc_alloc (0 ,ARRAY_SIZE (layers), layers,sizeof (*priv));if (!mci)return -ENOMEM ; + priv = mci->pvt_info; + priv->chip = chip; +spin_lock_init (&priv->lock); + priv->regs = regs; + mci->pdev = &pdev->dev; - mci->mtype_cap =MEM_FLAG_DDR3 |MEM_FLAG_DDR4 ; + mci->mtype_cap = chip->mtype_cap; mci->edac_ctl_cap =EDAC_FLAG_SECDED ; mci->edac_cap =EDAC_FLAG_SECDED ; mci->scrub_cap =SCRUB_FLAG_HW_SRC ;
@@ -315,21 +359,41 @@ static int aspeed_probe(struct platform_device *pdev)static void aspeed_remove (struct platform_device *pdev) {struct mem_ctl_info *mci =platform_get_drvdata (pdev); +struct aspeed_edac *priv = mci->pvt_info;/* disable interrupts */ -aspeed_set_irq (false); +aspeed_set_irq (priv, false); -free_irq (aspeed_irq, mci); +free_irq (priv->irq, mci);/* free resources */ edac_mc_del_mc (&pdev->dev);edac_mc_free (mci); } +static const struct aspeed_edac_chip ast2400_edac = { + .conf_reg =ASPEED_MCR_CONF , + .conf_ecc =ASPEED_MCR_CONF_ECC , + .conf_dram_type =ASPEED_MCR_CONF_DRAM_TYPE , + .dram_type = {MEM_DDR3 ,MEM_DDR4 }, + .mtype_cap =MEM_FLAG_DDR3 |MEM_FLAG_DDR4 , + .prot_reg =ASPEED_MCR_PROT , + .prot_key =ASPEED_MCR_PROT_PASSWD , +}; + +/* The AST2600 does not key-protect the interrupt control register (MCR50). */ +static const struct aspeed_edac_chip ast2600_edac = { + .conf_reg =ASPEED_MCR_CONF , + .conf_ecc =ASPEED_MCR_CONF_ECC , + .conf_dram_type =ASPEED_MCR_CONF_DRAM_TYPE , + .dram_type = {MEM_DDR3 ,MEM_DDR4 }, + .mtype_cap =MEM_FLAG_DDR3 |MEM_FLAG_DDR4 , +}; +static const struct of_device_id aspeed_of_match[] = { - { .compatible ="aspeed,ast2400-sdram-edac" }, - { .compatible ="aspeed,ast2500-sdram-edac" }, - { .compatible ="aspeed,ast2600-sdram-edac" }, + { .compatible ="aspeed,ast2400-sdram-edac" , .data = &ast2400_edac }, + { .compatible ="aspeed,ast2500-sdram-edac" , .data = &ast2400_edac }, + { .compatible ="aspeed,ast2600-sdram-edac" , .data = &ast2600_edac }, {}, };
Signature · 1 line
2.34.1
Ryan Chen
reviewerPATCH v6 3/4 EDAC/aspeed: Add AST2700 support
In reply to Ryan ChenAdd SDRAM ECC reporting for the Aspeed AST2700. Its DRAMC has a different register layout, a split interrupt status/clear/mask scheme, DDR4/DDR5 memory and interrupt registers that are not key-protected.
Its interrupt status/clear and enable sequences differ from the earlier SoCs, so add per-chip isr() and set_irq() hooks and route the request_irq() and enable/disable paths through them, keeping the existing AST2400/2500/2600 behaviour under the shared aspeed_mcr_isr()/aspeed_set_irq().
Unlike the earlier SoCs it records a single failure address shared by both error types, so extend the shared count_rec()/count_un_rec() helpers with a have_addr flag to report an error without an address (existing SoCs pass have_addr = true, unchanged) and widen their address argument to phys_addr_t as the AST2700 address can exceed 32 bits.
Tested on an AST2700: A correctable error was injected from the console by unlocking the controller and writing its ECC error inject test register:
# mw 12c00000 1688a8a8 # mw 12c00080 31 EDAC MC0: 1 CE on mc#0csrow#0channel#0 (csrow:0 channel:0 page:0x40f6da offset:0xdb0 grain:16 syndrome:0x0)
---
Changes in v6:
- Follow patch 1 ("EDAC/aspeed: Replace regmap with direct register access"): spinlock_t.
Changes in v5:
- Follow v5 patch 2 ("EDAC/aspeed: Free the interrupt before the mem_ctl_info on remove", now applied) in using request_irq().
Changes in v3:
- Write the AST2700 interrupt mask register outright rather than
read-modify-write: mask every source and unmask only the ECC ones. The driver owns the line exclusively, so it should establish the mask itself instead of deriving it from the register's contents.
- Mask the interrupts before requesting them rather than after, so the mask is established before the handler can run.
Changes in v2:
- Return IRQ_NONE from ast2700_dramc_isr() when no ECC interrupt status bit is set. The handler clears only the ECC bits, so unconditionally claiming the interrupt could livelock the level-triggered line if another DRAMC source was left unmasked.
- Add AST2700_INT_ECC for the pair of ECC interrupt bits, now used by both the handler and the enable path.
- Expand the enable/disable ternary in ast2700_set_irq() into if/else, matching the shape of aspeed_set_irq().
- Pass struct aspeed_edac to the set_irq() hooks instead of struct mem_ctl_info, which the callees only used to reach pvt_info.
--- drivers/edac/aspeed_edac.c | 161 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 135 insertions(+), 26 deletions(-)
drivers/edac/aspeed_edac.c +135 -26
@@ -32,6 +32,24 @@#define ASPEED_MCR_INTR_CTRL_CNT_UNREC GENMASK(15, 12)#define ASPEED_MCR_INTR_CTRL_ENABLE (BIT(0) | BIT(1)) +#define AST2700_INT_STS 0x04 +#define AST2700_INT_CLR 0x08 +#define AST2700_INT_MASK 0x0c +#define AST2700_INT_ECC_RECOVERABLE BIT(5) +#define AST2700_INT_ECC_UNRECOVERABLE BIT(4) +#define AST2700_INT_ECC (AST2700_INT_ECC_RECOVERABLE | \ + AST2700_INT_ECC_UNRECOVERABLE) +#define AST2700_INT_ALL GENMASK(16, 0) +#define AST2700_MCFG 0x10 +#define AST2700_MCFG_ECC BIT(6) +#define AST2700_MCFG_DRAM_TYPE BIT(0)/* 0=DDR4, 1=DDR5 */ +#define AST2700_ECC_STS 0x78 +#define AST2700_ECC_REC_CNT GENMASK(15, 8) +#define AST2700_ECC_UNREC_CNT GENMASK(7, 0) +#define AST2700_ECC_FAIL_ADDR 0x7c + +struct aspeed_edac ; +struct aspeed_edac_chip {unsigned int conf_reg;u32 conf_ecc;
@@ -40,6 +58,8 @@ struct aspeed_edac_chip {unsigned long mtype_cap;unsigned int prot_reg;u32 prot_key; +irqreturn_t (*isr)(int irq,void *arg); +void (*set_irq)(struct aspeed_edac *priv,bool enable); };struct aspeed_edac {
@@ -50,26 +70,34 @@ struct aspeed_edac {int irq; }; -static void count_rec (struct mem_ctl_info *mci,u8 rec_cnt,u32 rec_addr) +static void count_rec (struct mem_ctl_info *mci,u8 rec_cnt,phys_addr_t rec_addr, +bool have_addr) {struct csrow_info *csrow = mci->csrows[0 ]; -u32 page, offset, syndrome; +unsigned long page, offset, syndrome;if (!rec_cnt)return ; -/* report first few errors (if there are) */ -/* note: no addresses are recorded */ -if (rec_cnt >1 ) { +/* +* Report the errors whose address is not recorded: all of them when +* no address is available, otherwise all but the last one (reported +* with its address below). +*/ +if (rec_cnt >1 || !have_addr) {/* page, offset and syndrome are not available */ page =0 ; offset =0 ; syndrome =0 ; -edac_mc_handle_error (HW_EVENT_ERR_CORRECTED , mci, rec_cnt-1 , +edac_mc_handle_error (HW_EVENT_ERR_CORRECTED , mci, + have_addr ? rec_cnt -1 : rec_cnt, page, offset, syndrome,0 ,0 ,-1 ,"address(es) not available" ,"" ); } +if (!have_addr) +return ; +/* report last error */ /* note: rec_addr is the last recoverable error addr */ page = rec_addr >>PAGE_SHIFT ;
@@ -82,32 +110,34 @@ static void count_rec(struct mem_ctl_info *mci, u8 rec_cnt, u32 rec_addr) }static void count_un_rec (struct mem_ctl_info *mci,u8 un_rec_cnt, -u32 un_rec_addr) +phys_addr_t un_rec_addr,bool have_addr) {struct csrow_info *csrow = mci->csrows[0 ]; -u32 page, offset, syndrome; +unsigned long page, offset, syndrome;if (!un_rec_cnt)return ; -/* report 1. error */ -/* note: un_rec_addr is the first unrecoverable error addr */ - page = un_rec_addr >>PAGE_SHIFT ; - offset = un_rec_addr & ~PAGE_MASK ; -/* syndrome is not available */ - syndrome =0 ; -edac_mc_handle_error (HW_EVENT_ERR_UNCORRECTED , mci,1 , - csrow->first_page + page, offset, syndrome, -0 ,0 ,-1 ,"" ,"" ); +/* report the first error with its address when one is available */ +if (have_addr) { +/* note: un_rec_addr is the first unrecoverable error addr */ + page = un_rec_addr >>PAGE_SHIFT ; + offset = un_rec_addr & ~PAGE_MASK ; +/* syndrome is not available */ + syndrome =0 ; +edac_mc_handle_error (HW_EVENT_ERR_UNCORRECTED , mci,1 , + csrow->first_page + page, offset, syndrome, +0 ,0 ,-1 ,"" ,"" ); + } -/* report further errors (if there are) */ -/* note: no addresses are recorded */ -if (un_rec_cnt >1 ) { +/* report the remaining errors without a recorded address */ +if (un_rec_cnt >1 || !have_addr) {/* page, offset and syndrome are not available */ page =0 ; offset =0 ; syndrome =0 ; -edac_mc_handle_error (HW_EVENT_ERR_UNCORRECTED , mci, un_rec_cnt-1 , +edac_mc_handle_error (HW_EVENT_ERR_UNCORRECTED , mci, + have_addr ? un_rec_cnt -1 : un_rec_cnt, page, offset, syndrome,0 ,0 ,-1 ,"address(es) not available" ,"" ); }
@@ -164,8 +194,8 @@ static irqreturn_t aspeed_mcr_isr(int irq, void *arg) rec_cnt, un_rec_cnt);/* process recoverable and unrecoverable errors */ -count_rec (mci, rec_cnt, rec_addr); -count_un_rec (mci, un_rec_cnt, un_rec_addr); +count_rec (mci, rec_cnt, rec_addr, true); +count_un_rec (mci, un_rec_cnt, un_rec_addr, true);if (!rec_cnt && !un_rec_cnt)dev_dbg_ratelimited (mci->pdev,"received edac interrupt, but did not find any ECC counters\n" );
@@ -178,6 +208,54 @@ static irqreturn_t aspeed_mcr_isr(int irq, void *arg)return IRQ_HANDLED ; } +static irqreturn_t ast2700_dramc_isr (int irq,void *arg) +{ +u32 int_sts, ecc_sts, fail_addr; +struct mem_ctl_info *mci = arg; +struct aspeed_edac *priv; +u8 rec_cnt, un_rec_cnt; +phys_addr_t addr; + + priv = mci->pvt_info; + + scoped_guard(spinlock, &priv->lock) { + int_sts =readl (priv->regs +AST2700_INT_STS ); +if (!(int_sts &AST2700_INT_ECC )) +return IRQ_NONE ; + + ecc_sts =readl (priv->regs +AST2700_ECC_STS ); + fail_addr =readl (priv->regs +AST2700_ECC_FAIL_ADDR ); + +/* the interrupt registers are not key-protected; clear only ECC */ +writel (int_sts &AST2700_INT_ECC , priv->regs +AST2700_INT_CLR ); + } + + rec_cnt =FIELD_GET (AST2700_ECC_REC_CNT , ecc_sts); + un_rec_cnt =FIELD_GET (AST2700_ECC_UNREC_CNT , ecc_sts); + +/* the register holds address bits [35:4], in units of 16 bytes */ + addr = (phys_addr_t )fail_addr <<4 ; + +/* +* The controller records only the address of the latest failure, +* shared by both error types. When only one type occurred it owns +* that address; when both occurred attribute it to the uncorrectable +* error and report the corrected ones without an address. +*/ +if (un_rec_cnt && !rec_cnt) { +count_un_rec (mci, un_rec_cnt, addr, true); + }else if (!un_rec_cnt && rec_cnt) { +count_rec (mci, rec_cnt, addr, true); + }else if (un_rec_cnt && rec_cnt) { +count_un_rec (mci, un_rec_cnt, addr, true); +count_rec (mci, rec_cnt,0 , false); + }else { +dev_dbg_ratelimited (mci->pdev,"received interrupt with no ECC counters set\n" ); + } + +return IRQ_HANDLED ; +} +static void aspeed_set_irq (struct aspeed_edac *priv,bool enable) {u32 val;
@@ -195,6 +273,19 @@ static void aspeed_set_irq(struct aspeed_edac *priv, bool enable)aspeed_mcr_irq_update_exit (priv); } +static void ast2700_set_irq (struct aspeed_edac *priv,bool enable) +{ +u32 val =AST2700_INT_ALL ; + +guard (spinlock_irqsave)(&priv->lock); + +/* interrupts are enabled by clearing their mask bits */ +if (enable) + val &= ~AST2700_INT_ECC ; + +writel (val, priv->regs +AST2700_INT_MASK ); +} +static int config_irq (struct mem_ctl_info *mci,struct platform_device *pdev) {struct aspeed_edac *priv = mci->pvt_info;
@@ -207,14 +298,16 @@ static int config_irq(struct mem_ctl_info *mci, struct platform_device *pdev)if (irq <0 )return irq; - rc =request_irq (irq, aspeed_mcr_isr,IRQF_TRIGGER_HIGH ,DRV_NAME , mci); + priv->chip->set_irq (priv, false); + + rc =request_irq (irq, priv->chip->isr,IRQF_TRIGGER_HIGH ,DRV_NAME , mci);if (rc)return rc; priv->irq = irq;/* enable interrupts */ -aspeed_set_irq (priv, true); + priv->chip->set_irq (priv, true);return 0 ; }
@@ -362,7 +455,7 @@ static void aspeed_remove(struct platform_device *pdev)struct aspeed_edac *priv = mci->pvt_info;/* disable interrupts */ -aspeed_set_irq (priv, false); + priv->chip->set_irq (priv, false);free_irq (priv->irq, mci);
@@ -379,6 +472,8 @@ static const struct aspeed_edac_chip ast2400_edac = { .mtype_cap = MEM_FLAG_DDR3 | MEM_FLAG_DDR4, .prot_reg = ASPEED_MCR_PROT, .prot_key = ASPEED_MCR_PROT_PASSWD, + .isr = aspeed_mcr_isr, + .set_irq = aspeed_set_irq, };/* The AST2600 does not key-protect the interrupt control register (MCR50). */
@@ -388,12 +483,26 @@ static const struct aspeed_edac_chip ast2600_edac = { .conf_dram_type = ASPEED_MCR_CONF_DRAM_TYPE, .dram_type = { MEM_DDR3, MEM_DDR4 }, .mtype_cap = MEM_FLAG_DDR3 | MEM_FLAG_DDR4, + .isr = aspeed_mcr_isr, + .set_irq = aspeed_set_irq, +}; + +/* The AST2700 interrupt registers are not key-protected either. */ +static const struct aspeed_edac_chip ast2700_edac = { + .conf_reg =AST2700_MCFG , + .conf_ecc =AST2700_MCFG_ECC , + .conf_dram_type =AST2700_MCFG_DRAM_TYPE , + .dram_type = {MEM_DDR4 ,MEM_DDR5 }, + .mtype_cap =MEM_FLAG_DDR4 |MEM_FLAG_DDR5 , + .isr = ast2700_dramc_isr, + .set_irq = ast2700_set_irq, };static const struct of_device_id aspeed_of_match[] = { { .compatible ="aspeed,ast2400-sdram-edac" , .data = &ast2400_edac }, { .compatible ="aspeed,ast2500-sdram-edac" , .data = &ast2400_edac }, { .compatible ="aspeed,ast2600-sdram-edac" , .data = &ast2600_edac }, + { .compatible ="aspeed,ast2700-sdram-edac" , .data = &ast2700_edac }, {}, };
Signature · 1 line
2.34.1
Ryan Chen
reviewerPATCH v6 4/4 MAINTAINERS: Step down as Aspeed AST2500 EDAC driver maintainer
In reply to Ryan ChenFrom: Stefan M Schaeckeler <[email protected]>
I am stepping down as a maintainer for drivers/edac/aspeed_edac.c and Documentation/devicetree/bindings/edac/aspeed,ast2400-sdram-edac.yaml
Move my entry from the MAINTAINERS file to CREDITS to reflect my past contributions.
[ ryan: keep the EDAC-AST2500 entry and list myself as its reviewer
rather than removing it, and take over the binding's maintainers field ]
---
Changes in v5:
- Also hand over the maintainers field inside the binding, which get_maintainer.pl reads directly for .yaml files.
Changes in v4:
- Merge Stefan's step-down patch into this one, keeping the MAINTAINERS entry alive with a reviewer instead of removing it.
Changes in v3:
- New patch.
--- CREDITS | 8 ++++++++ .../devicetree/bindings/edac/aspeed,ast2400-sdram-edac.yaml | 2 +- MAINTAINERS | 2 +- 3 files changed, 10 insertions(+), 2 deletions(-)
CREDITS +8 -0
@@ -3696,6 +3696,14 @@ D: I2O kernel layer (config, block, core, pci, net). I2O disk support for LILO D: XScale (IOP, IXP) porting and other random ARM bits S: Portland, OR +N: Stefan Schaeckeler +E: [email protected] +E: [email protected] +D: Author and initial maintainer of the Aspeed AST2500 EDAC driver +S: 2253 Anna Dr. +S: Santa Clara, CA 95050 +S: USA + N: Eric Schenk E: [email protected] D: Random kernel debugging.
Documentation/devicetree/bindings/edac/aspeed,ast2400-sdram-edac.yaml +1 -1
@@ -7,7 +7,7 @@ $schema: http://devicetree.org/meta-schemas/core.yaml# title: Aspeed BMC SoC SDRAM EDAC controller maintainers: - - Stefan Schaeckeler <[email protected]> + - Ryan Chen <[email protected]> description: > The Aspeed BMC SoCs support DDR memory with and without ECC (error
MAINTAINERS +1 -1
@@ -9607,7 +9607,7 @@ F: Documentation/devicetree/bindings/memory-controllers/marvell,mvebu-sdram-cont F: drivers/edac/armada_xp_* EDAC-AST2500 -M: Stefan Schaeckeler <[email protected]> +R: Ryan Chen <[email protected]> S: Supported F: Documentation/devicetree/bindings/edac/aspeed,ast2400-sdram-edac.yaml F: drivers/edac/aspeed_edac.c
Signature · 1 line
2.34.1