[RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Scott Wood]

The CoreNet Coherency Fabric is part of the memory subsystem on
some Freescale QorIQ chips.  It can report coherency violations (e.g.
due to misusing memory that is mapped noncoherent) as well as
transactions that do not hit any local access window, or which hit a
local access window with an invalid target ID.

Signed-off-by: Scott Wood <scottwood@freescale.com>
---
Resending to the proper list addresses -- sorry for the duplicate.

 arch/powerpc/configs/corenet32_smp_defconfig |   1 +
 arch/powerpc/configs/corenet64_smp_defconfig |   1 +
 drivers/memory/Kconfig                       |  10 ++
 drivers/memory/Makefile                      |   1 +
 drivers/memory/fsl-corenet-cf.c              | 246 +++++++++++++++++++++++++++
 5 files changed, 259 insertions(+)
 create mode 100644 drivers/memory/fsl-corenet-cf.c

diff --git a/arch/powerpc/configs/corenet32_smp_defconfig b/arch/powerpc/configs/corenet32_smp_defconfig
index c19ff05..0c99d7e 100644
--- a/arch/powerpc/configs/corenet32_smp_defconfig
+++ b/arch/powerpc/configs/corenet32_smp_defconfig
@@ -179,3 +179,4 @@ CONFIG_CRYPTO_SHA512=y
 CONFIG_CRYPTO_AES=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_DEV_FSL_CAAM=y
+CONFIG_FSL_CORENET_CF=y
diff --git a/arch/powerpc/configs/corenet64_smp_defconfig b/arch/powerpc/configs/corenet64_smp_defconfig
index 5c7fa19..8fb616d 100644
--- a/arch/powerpc/configs/corenet64_smp_defconfig
+++ b/arch/powerpc/configs/corenet64_smp_defconfig
@@ -175,3 +175,4 @@ CONFIG_CRYPTO_SHA256=y
 CONFIG_CRYPTO_SHA512=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_DEV_FSL_CAAM=y
+CONFIG_FSL_CORENET_CF=y
diff --git a/drivers/memory/Kconfig b/drivers/memory/Kconfig
index c59e9c9..fab81a1 100644
--- a/drivers/memory/Kconfig
+++ b/drivers/memory/Kconfig
@@ -61,6 +61,16 @@ config TEGRA30_MC
 	  analysis, especially for IOMMU/SMMU(System Memory Management
 	  Unit) module.
 
+config FSL_CORENET_CF
+	tristate "Freescale CoreNet Error Reporting"
+	depends on FSL_SOC_BOOKE
+	help
+	  Say Y for reporting of errors from the Freescale CoreNet
+	  Coherency Fabric.  Errors reported include accesses to
+	  physical addresses that mapped by no local access window
+	  (LAW) or an invalid LAW, as well as bad cache state that
+	  represents a coherency violation.
+
 config FSL_IFC
 	bool
 	depends on FSL_SOC
diff --git a/drivers/memory/Makefile b/drivers/memory/Makefile
index 71160a2..4055c47 100644
--- a/drivers/memory/Makefile
+++ b/drivers/memory/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_OF)		+= of_memory.o
 endif
 obj-$(CONFIG_TI_AEMIF)		+= ti-aemif.o
 obj-$(CONFIG_TI_EMIF)		+= emif.o
+obj-$(CONFIG_FSL_CORENET_CF)	+= fsl-corenet-cf.o
 obj-$(CONFIG_FSL_IFC)		+= fsl_ifc.o
 obj-$(CONFIG_MVEBU_DEVBUS)	+= mvebu-devbus.o
 obj-$(CONFIG_TEGRA20_MC)	+= tegra20-mc.o
diff --git a/drivers/memory/fsl-corenet-cf.c b/drivers/memory/fsl-corenet-cf.c
new file mode 100644
index 0000000..a57a614
--- /dev/null
+++ b/drivers/memory/fsl-corenet-cf.c
@@ -0,0 +1,246 @@
+/*
+ * CoreNet Coherency Fabric error reporting
+ *
+ * Copyright 2014 Freescale Semiconductor Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/of_irq.h>
+#include <linux/platform_device.h>
+
+enum ccf_version {
+	CCF1,
+	CCF2,
+};
+
+struct ccf_info {
+	enum ccf_version version;
+	int err_reg_offs;
+};
+
+static const struct ccf_info ccf1_info = {
+	.version = CCF1,
+	.err_reg_offs = 0xa00,
+};
+
+static const struct ccf_info ccf2_info = {
+	.version = CCF2,
+	.err_reg_offs = 0xe40,
+};
+
+static const struct of_device_id ccf_matches[] = {
+	{
+		.compatible = "fsl,corenet1-cf",
+		.data = &ccf1_info,
+	},
+	{
+		.compatible = "fsl,corenet2-cf",
+		.data = &ccf2_info,
+	},
+	{}
+};
+
+struct ccf_err_regs {
+	u32 errdet;		/* 0x00 Error Detect Register */
+	/* 0x04 Error Enable (ccf1)/Disable (ccf2) Register */
+	u32 errdis;
+	/* 0x08 Error Interrupt Enable Register (ccf2 only) */
+	u32 errinten;
+	u32 cecar;		/* 0x0c Error Capture Attribute Register */
+	u32 cecadrh;		/* 0x10 Error Capture Address High */
+	u32 cecadrl;		/* 0x14 Error Capture Address Low */
+	u32 cecar2;		/* 0x18 Error Capture Attribute Register 2 */
+};
+
+/* LAE/CV also valid for errdis and errinten */
+#define ERRDET_LAE		(1 << 0)  /* Local Access Error */
+#define ERRDET_CV		(1 << 1)  /* Coherency Violation */
+#define ERRDET_CTYPE_SHIFT	26	  /* Capture Type (ccf2 only) */
+#define ERRDET_CTYPE_MASK	(0x3f << ERRDET_CTYPE_SHIFT)
+#define ERRDET_CAP		(1 << 31) /* Capture Valid (ccf2 only) */
+
+#define CECAR_VAL		(1 << 0)  /* Valid (ccf1 only) */
+#define CECAR_UVT		(1 << 15) /* Unavailable target ID (ccf1) */
+#define CECAR_SRCID_SHIFT_CCF1	24
+#define CECAR_SRCID_MASK_CCF1	(0xff << CECAR_SRCID_SHIFT_CCF1)
+#define CECAR_SRCID_SHIFT_CCF2	18
+#define CECAR_SRCID_MASK_CCF2	(0xff << CECAR_SRCID_SHIFT_CCF2)
+
+#define CECADRH_ADDRH		0xf
+
+struct ccf_private {
+	const struct ccf_info *info;
+	struct device *dev;
+	void __iomem *regs;
+	struct ccf_err_regs __iomem *err_regs;
+};
+
+static irqreturn_t ccf_irq(int irq, void *dev_id)
+{
+	struct ccf_private *ccf = dev_id;
+	static DEFINE_RATELIMIT_STATE(ratelimit, DEFAULT_RATELIMIT_INTERVAL,
+				      DEFAULT_RATELIMIT_BURST);
+	u32 errdet, cecar, cecar2;
+	u64 addr;
+	u32 src_id;
+	bool uvt = false;
+	bool cap_valid = false;
+
+	errdet = ioread32be(&ccf->err_regs->errdet);
+	cecar = ioread32be(&ccf->err_regs->cecar);
+	cecar2 = ioread32be(&ccf->err_regs->cecar2);
+	addr = ioread32be(&ccf->err_regs->cecadrl);
+	addr |= ((u64)(ioread32be(&ccf->err_regs->cecadrh) &
+		       CECADRH_ADDRH)) << 32;
+
+	if (!__ratelimit(&ratelimit))
+		goto out;
+
+	switch (ccf->info->version) {
+	case CCF1:
+		if (cecar & CECAR_VAL) {
+			if (cecar & CECAR_UVT)
+				uvt = true;
+
+			src_id = (cecar & CECAR_SRCID_MASK_CCF1) >>
+				 CECAR_SRCID_SHIFT_CCF1;
+			cap_valid = true;
+		}
+
+		break;
+	case CCF2:
+		if (errdet & ERRDET_CAP) {
+			src_id = (cecar & CECAR_SRCID_MASK_CCF2) >>
+				 CECAR_SRCID_SHIFT_CCF2;
+			cap_valid = true;
+		}
+
+		break;
+	}
+
+	dev_crit(ccf->dev, "errdet 0x%08x cecar 0x%08x cecar2 0x%08x\n",
+		 errdet, cecar, cecar2);
+
+	if (errdet & ERRDET_LAE) {
+		if (uvt)
+			dev_crit(ccf->dev, "LAW Unavailable Target ID\n");
+		else
+			dev_crit(ccf->dev, "Local Access Window Error\n");
+	}
+
+	if (errdet & ERRDET_CV)
+		dev_crit(ccf->dev, "Coherency Violation\n");
+
+	if (cap_valid) {
+		dev_crit(ccf->dev, "address 0x%09llx, src id 0x%x\n",
+			 addr, src_id);
+	}
+
+out:
+	iowrite32be(errdet, &ccf->err_regs->errdet);
+	return errdet ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static int ccf_probe(struct platform_device *pdev)
+{
+	struct ccf_private *ccf;
+	struct resource *r;
+	const struct of_device_id *match;
+	int ret, irq;
+
+	match = of_match_device(ccf_matches, &pdev->dev);
+	if (WARN_ON(!match))
+		return -ENODEV;
+
+	ccf = devm_kzalloc(&pdev->dev, sizeof(*ccf), GFP_KERNEL);
+	if (!ccf)
+		return -ENOMEM;
+
+	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!r) {
+		dev_err(&pdev->dev, "%s: no mem resource\n", __func__);
+		return -ENXIO;
+	}
+
+	ccf->regs = devm_ioremap_resource(&pdev->dev, r);
+	if (IS_ERR(ccf->regs)) {
+		dev_err(&pdev->dev, "%s: can't map mem resource\n", __func__);
+		return PTR_ERR(ccf->regs);
+	}
+
+	ccf->dev = &pdev->dev;
+	ccf->info = match->data;
+	ccf->err_regs = ccf->regs + ccf->info->err_reg_offs;
+
+	dev_set_drvdata(&pdev->dev, ccf);
+
+	irq = platform_get_irq(pdev, 0);
+	if (!irq) {
+		dev_err(&pdev->dev, "%s: no irq\n", __func__);
+		return -ENXIO;
+	}
+
+	ret = devm_request_irq(&pdev->dev, irq, ccf_irq, 0, pdev->name, ccf);
+	if (ret) {
+		dev_err(&pdev->dev, "%s: can't request irq\n", __func__);
+		return ret;
+	}
+
+	switch (ccf->info->version) {
+	case CCF1:
+		/* On CCF1 this register enables rather than disables. */
+		iowrite32be(ERRDET_LAE | ERRDET_CV, &ccf->err_regs->errdis);
+		break;
+
+	case CCF2:
+		iowrite32be(0, &ccf->err_regs->errdis);
+		iowrite32be(ERRDET_LAE | ERRDET_CV, &ccf->err_regs->errinten);
+		break;
+	}
+
+	return 0;
+}
+
+static int ccf_remove(struct platform_device *pdev)
+{
+	struct ccf_private *ccf = dev_get_drvdata(&pdev->dev);
+
+	switch (ccf->info->version) {
+	case CCF1:
+		iowrite32be(0, &ccf->err_regs->errdis);
+		break;
+
+	case CCF2:
+		iowrite32be(0, &ccf->err_regs->errinten);
+		break;
+	}
+
+	return 0;
+}
+
+static struct platform_driver ccf_driver = {
+	.driver = {
+		.name = KBUILD_MODNAME,
+		.owner = THIS_MODULE,
+		.of_match_table = ccf_matches,
+	},
+	.probe = ccf_probe,
+	.remove = ccf_remove,
+};
+
+module_platform_driver(ccf_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Freescale Semiconductor");
+MODULE_DESCRIPTION("Freescale CoreNet Coherency Fabric error reporting");
-- 
1.9.1

RE: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Bharat.Bhushan]

DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogTGludXhwcGMtZGV2IFtt
YWlsdG86bGludXhwcGMtZGV2LQ0KPiBib3VuY2VzK2JoYXJhdC5iaHVzaGFuPWZyZWVzY2FsZS5j
b21AbGlzdHMub3psYWJzLm9yZ10gT24gQmVoYWxmIE9mIFNjb3R0IFdvb2QNCj4gU2VudDogU2F0
dXJkYXksIE1heSAzMSwgMjAxNCAzOjU4IEFNDQo+IFRvOiBHcmVnIEtyb2FoLUhhcnRtYW4NCj4g
Q2M6IGxpbnV4cHBjLWRldkBsaXN0cy5vemxhYnMub3JnOyBsaW51eC1rZXJuZWxAdmdlci5rZXJu
ZWwub3JnDQo+IFN1YmplY3Q6IFtSRVNFTkQgUEFUQ0hdIG1lbW9yeTogRnJlZXNjYWxlIENvcmVO
ZXQgQ29oZXJlbmN5IEZhYnJpYyBlcnJvcg0KPiByZXBvcnRpbmcgZHJpdmVyDQo+IA0KPiBUaGUg
Q29yZU5ldCBDb2hlcmVuY3kgRmFicmljIGlzIHBhcnQgb2YgdGhlIG1lbW9yeSBzdWJzeXN0ZW0g
b24gc29tZSBGcmVlc2NhbGUNCj4gUW9ySVEgY2hpcHMuICBJdCBjYW4gcmVwb3J0IGNvaGVyZW5j
eSB2aW9sYXRpb25zIChlLmcuDQo+IGR1ZSB0byBtaXN1c2luZyBtZW1vcnkgdGhhdCBpcyBtYXBw
ZWQgbm9uY29oZXJlbnQpIGFzIHdlbGwgYXMgdHJhbnNhY3Rpb25zIHRoYXQNCj4gZG8gbm90IGhp
dCBhbnkgbG9jYWwgYWNjZXNzIHdpbmRvdywgb3Igd2hpY2ggaGl0IGEgbG9jYWwgYWNjZXNzIHdp
bmRvdyB3aXRoIGFuDQo+IGludmFsaWQgdGFyZ2V0IElELg0KPiANCj4gU2lnbmVkLW9mZi1ieTog
U2NvdHQgV29vZCA8c2NvdHR3b29kQGZyZWVzY2FsZS5jb20+DQo+IC0tLQ0KPiBSZXNlbmRpbmcg
dG8gdGhlIHByb3BlciBsaXN0IGFkZHJlc3NlcyAtLSBzb3JyeSBmb3IgdGhlIGR1cGxpY2F0ZS4N
Cj4gDQo+ICBhcmNoL3Bvd2VycGMvY29uZmlncy9jb3JlbmV0MzJfc21wX2RlZmNvbmZpZyB8ICAg
MSArDQo+ICBhcmNoL3Bvd2VycGMvY29uZmlncy9jb3JlbmV0NjRfc21wX2RlZmNvbmZpZyB8ICAg
MSArDQo+ICBkcml2ZXJzL21lbW9yeS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICB8ICAx
MCArKw0KPiAgZHJpdmVycy9tZW1vcnkvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgfCAg
IDEgKw0KPiAgZHJpdmVycy9tZW1vcnkvZnNsLWNvcmVuZXQtY2YuYyAgICAgICAgICAgICAgfCAy
NDYgKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ICA1IGZpbGVzIGNoYW5nZWQsIDI1OSBp
bnNlcnRpb25zKCspDQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9tZW1vcnkvZnNsLWNv
cmVuZXQtY2YuYw0KPiANCj4gZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9jb25maWdzL2NvcmVu
ZXQzMl9zbXBfZGVmY29uZmlnDQo+IGIvYXJjaC9wb3dlcnBjL2NvbmZpZ3MvY29yZW5ldDMyX3Nt
cF9kZWZjb25maWcNCj4gaW5kZXggYzE5ZmYwNS4uMGM5OWQ3ZSAxMDA2NDQNCj4gLS0tIGEvYXJj
aC9wb3dlcnBjL2NvbmZpZ3MvY29yZW5ldDMyX3NtcF9kZWZjb25maWcNCj4gKysrIGIvYXJjaC9w
b3dlcnBjL2NvbmZpZ3MvY29yZW5ldDMyX3NtcF9kZWZjb25maWcNCj4gQEAgLTE3OSwzICsxNzks
NCBAQCBDT05GSUdfQ1JZUFRPX1NIQTUxMj15ICBDT05GSUdfQ1JZUFRPX0FFUz15ICAjDQo+IENP
TkZJR19DUllQVE9fQU5TSV9DUFJORyBpcyBub3Qgc2V0ICBDT05GSUdfQ1JZUFRPX0RFVl9GU0xf
Q0FBTT15DQo+ICtDT05GSUdfRlNMX0NPUkVORVRfQ0Y9eQ0KPiBkaWZmIC0tZ2l0IGEvYXJjaC9w
b3dlcnBjL2NvbmZpZ3MvY29yZW5ldDY0X3NtcF9kZWZjb25maWcNCj4gYi9hcmNoL3Bvd2VycGMv
Y29uZmlncy9jb3JlbmV0NjRfc21wX2RlZmNvbmZpZw0KPiBpbmRleCA1YzdmYTE5Li44ZmI2MTZk
IDEwMDY0NA0KPiAtLS0gYS9hcmNoL3Bvd2VycGMvY29uZmlncy9jb3JlbmV0NjRfc21wX2RlZmNv
bmZpZw0KPiArKysgYi9hcmNoL3Bvd2VycGMvY29uZmlncy9jb3JlbmV0NjRfc21wX2RlZmNvbmZp
Zw0KPiBAQCAtMTc1LDMgKzE3NSw0IEBAIENPTkZJR19DUllQVE9fU0hBMjU2PXkgIENPTkZJR19D
UllQVE9fU0hBNTEyPXkgICMNCj4gQ09ORklHX0NSWVBUT19BTlNJX0NQUk5HIGlzIG5vdCBzZXQg
IENPTkZJR19DUllQVE9fREVWX0ZTTF9DQUFNPXkNCj4gK0NPTkZJR19GU0xfQ09SRU5FVF9DRj15
DQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lbW9yeS9LY29uZmlnIGIvZHJpdmVycy9tZW1vcnkv
S2NvbmZpZyBpbmRleA0KPiBjNTllOWM5Li5mYWI4MWExIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJz
L21lbW9yeS9LY29uZmlnDQo+ICsrKyBiL2RyaXZlcnMvbWVtb3J5L0tjb25maWcNCj4gQEAgLTYx
LDYgKzYxLDE2IEBAIGNvbmZpZyBURUdSQTMwX01DDQo+ICAJICBhbmFseXNpcywgZXNwZWNpYWxs
eSBmb3IgSU9NTVUvU01NVShTeXN0ZW0gTWVtb3J5IE1hbmFnZW1lbnQNCj4gIAkgIFVuaXQpIG1v
ZHVsZS4NCj4gDQo+ICtjb25maWcgRlNMX0NPUkVORVRfQ0YNCj4gKwl0cmlzdGF0ZSAiRnJlZXNj
YWxlIENvcmVOZXQgRXJyb3IgUmVwb3J0aW5nIg0KPiArCWRlcGVuZHMgb24gRlNMX1NPQ19CT09L
RQ0KPiArCWhlbHANCj4gKwkgIFNheSBZIGZvciByZXBvcnRpbmcgb2YgZXJyb3JzIGZyb20gdGhl
IEZyZWVzY2FsZSBDb3JlTmV0DQo+ICsJICBDb2hlcmVuY3kgRmFicmljLiAgRXJyb3JzIHJlcG9y
dGVkIGluY2x1ZGUgYWNjZXNzZXMgdG8NCj4gKwkgIHBoeXNpY2FsIGFkZHJlc3NlcyB0aGF0IG1h
cHBlZCBieSBubyBsb2NhbCBhY2Nlc3Mgd2luZG93DQo+ICsJICAoTEFXKSBvciBhbiBpbnZhbGlk
IExBVywgYXMgd2VsbCBhcyBiYWQgY2FjaGUgc3RhdGUgdGhhdA0KPiArCSAgcmVwcmVzZW50cyBh
IGNvaGVyZW5jeSB2aW9sYXRpb24uDQo+ICsNCj4gIGNvbmZpZyBGU0xfSUZDDQo+ICAJYm9vbA0K
PiAgCWRlcGVuZHMgb24gRlNMX1NPQw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZW1vcnkvTWFr
ZWZpbGUgYi9kcml2ZXJzL21lbW9yeS9NYWtlZmlsZSBpbmRleA0KPiA3MTE2MGEyLi40MDU1YzQ3
IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL21lbW9yeS9NYWtlZmlsZQ0KPiArKysgYi9kcml2ZXJz
L21lbW9yeS9NYWtlZmlsZQ0KPiBAQCAtNyw2ICs3LDcgQEAgb2JqLSQoQ09ORklHX09GKQkJKz0g
b2ZfbWVtb3J5Lm8NCj4gIGVuZGlmDQo+ICBvYmotJChDT05GSUdfVElfQUVNSUYpCQkrPSB0aS1h
ZW1pZi5vDQo+ICBvYmotJChDT05GSUdfVElfRU1JRikJCSs9IGVtaWYubw0KPiArb2JqLSQoQ09O
RklHX0ZTTF9DT1JFTkVUX0NGKQkrPSBmc2wtY29yZW5ldC1jZi5vDQo+ICBvYmotJChDT05GSUdf
RlNMX0lGQykJCSs9IGZzbF9pZmMubw0KPiAgb2JqLSQoQ09ORklHX01WRUJVX0RFVkJVUykJKz0g
bXZlYnUtZGV2YnVzLm8NCj4gIG9iai0kKENPTkZJR19URUdSQTIwX01DKQkrPSB0ZWdyYTIwLW1j
Lm8NCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVtb3J5L2ZzbC1jb3JlbmV0LWNmLmMgYi9kcml2
ZXJzL21lbW9yeS9mc2wtY29yZW5ldC1jZi5jDQo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0IGluZGV4
IDAwMDAwMDAuLmE1N2E2MTQNCj4gLS0tIC9kZXYvbnVsbA0KPiArKysgYi9kcml2ZXJzL21lbW9y
eS9mc2wtY29yZW5ldC1jZi5jDQo+IEBAIC0wLDAgKzEsMjQ2IEBADQo+ICsvKg0KPiArICogQ29y
ZU5ldCBDb2hlcmVuY3kgRmFicmljIGVycm9yIHJlcG9ydGluZw0KPiArICoNCj4gKyAqIENvcHly
aWdodCAyMDE0IEZyZWVzY2FsZSBTZW1pY29uZHVjdG9yIEluYy4NCj4gKyAqDQo+ICsgKiBUaGlz
IHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgIGl0IGFuZC9v
cg0KPiArbW9kaWZ5IGl0DQo+ICsgKiB1bmRlciAgdGhlIHRlcm1zIG9mICB0aGUgR05VIEdlbmVy
YWwgIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQ0KPiArdGhlDQo+ICsgKiBGcmVlIFNv
ZnR3YXJlIEZvdW5kYXRpb247ICBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSAgTGljZW5zZSwgb3Ig
KGF0DQo+ICt5b3VyDQo+ICsgKiBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLg0KPiArICovDQo+
ICsNCj4gKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9p
by5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2lycS5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L21vZHVs
ZS5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L29mLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvb2ZfYWRk
cmVzcy5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPg0KPiArI2luY2x1ZGUgPGxp
bnV4L29mX2lycS5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPg0KPiAr
DQo+ICtlbnVtIGNjZl92ZXJzaW9uIHsNCj4gKwlDQ0YxLA0KPiArCUNDRjIsDQo+ICt9Ow0KPiAr
DQo+ICtzdHJ1Y3QgY2NmX2luZm8gew0KPiArCWVudW0gY2NmX3ZlcnNpb24gdmVyc2lvbjsNCj4g
KwlpbnQgZXJyX3JlZ19vZmZzOw0KPiArfTsNCj4gKw0KPiArc3RhdGljIGNvbnN0IHN0cnVjdCBj
Y2ZfaW5mbyBjY2YxX2luZm8gPSB7DQo+ICsJLnZlcnNpb24gPSBDQ0YxLA0KPiArCS5lcnJfcmVn
X29mZnMgPSAweGEwMCwNCj4gK307DQo+ICsNCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgY2NmX2lu
Zm8gY2NmMl9pbmZvID0gew0KPiArCS52ZXJzaW9uID0gQ0NGMiwNCj4gKwkuZXJyX3JlZ19vZmZz
ID0gMHhlNDAsDQo+ICt9Ow0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9p
ZCBjY2ZfbWF0Y2hlc1tdID0gew0KPiArCXsNCj4gKwkJLmNvbXBhdGlibGUgPSAiZnNsLGNvcmVu
ZXQxLWNmIiwNCj4gKwkJLmRhdGEgPSAmY2NmMV9pbmZvLA0KPiArCX0sDQo+ICsJew0KPiArCQku
Y29tcGF0aWJsZSA9ICJmc2wsY29yZW5ldDItY2YiLA0KPiArCQkuZGF0YSA9ICZjY2YyX2luZm8s
DQo+ICsJfSwNCj4gKwl7fQ0KPiArfTsNCj4gKw0KPiArc3RydWN0IGNjZl9lcnJfcmVncyB7DQo+
ICsJdTMyIGVycmRldDsJCS8qIDB4MDAgRXJyb3IgRGV0ZWN0IFJlZ2lzdGVyICovDQo+ICsJLyog
MHgwNCBFcnJvciBFbmFibGUgKGNjZjEpL0Rpc2FibGUgKGNjZjIpIFJlZ2lzdGVyICovDQo+ICsJ
dTMyIGVycmRpczsNCj4gKwkvKiAweDA4IEVycm9yIEludGVycnVwdCBFbmFibGUgUmVnaXN0ZXIg
KGNjZjIgb25seSkgKi8NCj4gKwl1MzIgZXJyaW50ZW47DQo+ICsJdTMyIGNlY2FyOwkJLyogMHgw
YyBFcnJvciBDYXB0dXJlIEF0dHJpYnV0ZSBSZWdpc3RlciAqLw0KPiArCXUzMiBjZWNhZHJoOwkJ
LyogMHgxMCBFcnJvciBDYXB0dXJlIEFkZHJlc3MgSGlnaCAqLw0KDQpzL2NlY2FkcmgvY2VjYWRk
cmgvZw0KVGhpcyB3YXkgd2Ugd2lsbCBiZSBjb25zaXN0ZW50IHdpdGggUmVmZXJlbmNlIG1hbnVh
bC4NCg0KPiArCXUzMiBjZWNhZHJsOwkJLyogMHgxNCBFcnJvciBDYXB0dXJlIEFkZHJlc3MgTG93
ICovDQoNCnMvY2VjYWRybC9jZWNhZGRybC9nDQoNCj4gKwl1MzIgY2VjYXIyOwkJLyogMHgxOCBF
cnJvciBDYXB0dXJlIEF0dHJpYnV0ZSBSZWdpc3RlciAyICovDQo+ICt9Ow0KPiArDQo+ICsvKiBM
QUUvQ1YgYWxzbyB2YWxpZCBmb3IgZXJyZGlzIGFuZCBlcnJpbnRlbiAqLw0KPiArI2RlZmluZSBF
UlJERVRfTEFFCQkoMSA8PCAwKSAgLyogTG9jYWwgQWNjZXNzIEVycm9yICovDQo+ICsjZGVmaW5l
IEVSUkRFVF9DVgkJKDEgPDwgMSkgIC8qIENvaGVyZW5jeSBWaW9sYXRpb24gKi8NCj4gKyNkZWZp
bmUgRVJSREVUX0NUWVBFX1NISUZUCTI2CSAgLyogQ2FwdHVyZSBUeXBlIChjY2YyIG9ubHkpICov
DQo+ICsjZGVmaW5lIEVSUkRFVF9DVFlQRV9NQVNLCSgweDNmIDw8IEVSUkRFVF9DVFlQRV9TSElG
VCkNCg0KU2hvdWxkIG5vdCB0aGlzIGJlICgweDFmIDw8IEVSUkRFVF9DVFlQRV9TSElGVCkNCg0K
PiArI2RlZmluZSBFUlJERVRfQ0FQCQkoMSA8PCAzMSkgLyogQ2FwdHVyZSBWYWxpZCAoY2NmMiBv
bmx5KSAqLw0KPiArDQo+ICsjZGVmaW5lIENFQ0FSX1ZBTAkJKDEgPDwgMCkgIC8qIFZhbGlkIChj
Y2YxIG9ubHkpICovDQo+ICsjZGVmaW5lIENFQ0FSX1VWVAkJKDEgPDwgMTUpIC8qIFVuYXZhaWxh
YmxlIHRhcmdldCBJRCAoY2NmMSkgKi8NCj4gKyNkZWZpbmUgQ0VDQVJfU1JDSURfU0hJRlRfQ0NG
MQkyNA0KPiArI2RlZmluZSBDRUNBUl9TUkNJRF9NQVNLX0NDRjEJKDB4ZmYgPDwgQ0VDQVJfU1JD
SURfU0hJRlRfQ0NGMSkNCj4gKyNkZWZpbmUgQ0VDQVJfU1JDSURfU0hJRlRfQ0NGMgkxOA0KPiAr
I2RlZmluZSBDRUNBUl9TUkNJRF9NQVNLX0NDRjIJKDB4ZmYgPDwgQ0VDQVJfU1JDSURfU0hJRlRf
Q0NGMikNCj4gKw0KPiArI2RlZmluZSBDRUNBRFJIX0FERFJICQkweGYNCg0KT24gY2NmMiB0aGlz
IGlkIDB4ZmYuDQoNCj4gKw0KPiArc3RydWN0IGNjZl9wcml2YXRlIHsNCj4gKwljb25zdCBzdHJ1
Y3QgY2NmX2luZm8gKmluZm87DQo+ICsJc3RydWN0IGRldmljZSAqZGV2Ow0KPiArCXZvaWQgX19p
b21lbSAqcmVnczsNCj4gKwlzdHJ1Y3QgY2NmX2Vycl9yZWdzIF9faW9tZW0gKmVycl9yZWdzOyB9
Ow0KPiArDQo+ICtzdGF0aWMgaXJxcmV0dXJuX3QgY2NmX2lycShpbnQgaXJxLCB2b2lkICpkZXZf
aWQpIHsNCj4gKwlzdHJ1Y3QgY2NmX3ByaXZhdGUgKmNjZiA9IGRldl9pZDsNCj4gKwlzdGF0aWMg
REVGSU5FX1JBVEVMSU1JVF9TVEFURShyYXRlbGltaXQsIERFRkFVTFRfUkFURUxJTUlUX0lOVEVS
VkFMLA0KPiArCQkJCSAgICAgIERFRkFVTFRfUkFURUxJTUlUX0JVUlNUKTsNCj4gKwl1MzIgZXJy
ZGV0LCBjZWNhciwgY2VjYXIyOw0KPiArCXU2NCBhZGRyOw0KPiArCXUzMiBzcmNfaWQ7DQo+ICsJ
Ym9vbCB1dnQgPSBmYWxzZTsNCj4gKwlib29sIGNhcF92YWxpZCA9IGZhbHNlOw0KPiArDQo+ICsJ
ZXJyZGV0ID0gaW9yZWFkMzJiZSgmY2NmLT5lcnJfcmVncy0+ZXJyZGV0KTsNCj4gKwljZWNhciA9
IGlvcmVhZDMyYmUoJmNjZi0+ZXJyX3JlZ3MtPmNlY2FyKTsNCj4gKwljZWNhcjIgPSBpb3JlYWQz
MmJlKCZjY2YtPmVycl9yZWdzLT5jZWNhcjIpOw0KPiArCWFkZHIgPSBpb3JlYWQzMmJlKCZjY2Yt
PmVycl9yZWdzLT5jZWNhZHJsKTsNCj4gKwlhZGRyIHw9ICgodTY0KShpb3JlYWQzMmJlKCZjY2Yt
PmVycl9yZWdzLT5jZWNhZHJoKSAmDQo+ICsJCSAgICAgICBDRUNBRFJIX0FERFJIKSkgPDwgMzI7
DQoNClNvIHRoaXMgZ28gZG93biB0byBjY2YgdmVyc2lvbiB0eXBlIHN3aXRjaC4gDQoNCj4gKw0K
PiArCWlmICghX19yYXRlbGltaXQoJnJhdGVsaW1pdCkpDQo+ICsJCWdvdG8gb3V0Ow0KPiArDQo+
ICsJc3dpdGNoIChjY2YtPmluZm8tPnZlcnNpb24pIHsNCj4gKwljYXNlIENDRjE6DQo+ICsJCWlm
IChjZWNhciAmIENFQ0FSX1ZBTCkgew0KPiArCQkJaWYgKGNlY2FyICYgQ0VDQVJfVVZUKQ0KPiAr
CQkJCXV2dCA9IHRydWU7DQo+ICsNCj4gKwkJCXNyY19pZCA9IChjZWNhciAmIENFQ0FSX1NSQ0lE
X01BU0tfQ0NGMSkgPj4NCj4gKwkJCQkgQ0VDQVJfU1JDSURfU0hJRlRfQ0NGMTsNCj4gKwkJCWNh
cF92YWxpZCA9IHRydWU7DQo+ICsJCX0NCj4gKw0KPiArCQlicmVhazsNCj4gKwljYXNlIENDRjI6
DQo+ICsJCWlmIChlcnJkZXQgJiBFUlJERVRfQ0FQKSB7DQo+ICsJCQlzcmNfaWQgPSAoY2VjYXIg
JiBDRUNBUl9TUkNJRF9NQVNLX0NDRjIpID4+DQo+ICsJCQkJIENFQ0FSX1NSQ0lEX1NISUZUX0ND
RjI7DQo+ICsJCQljYXBfdmFsaWQgPSB0cnVlOw0KPiArCQl9DQo+ICsNCj4gKwkJYnJlYWs7DQo+
ICsJfQ0KPiArDQo+ICsJZGV2X2NyaXQoY2NmLT5kZXYsICJlcnJkZXQgMHglMDh4IGNlY2FyIDB4
JTA4eCBjZWNhcjIgMHglMDh4XG4iLA0KPiArCQkgZXJyZGV0LCBjZWNhciwgY2VjYXIyKTsNCj4g
Kw0KPiArCWlmIChlcnJkZXQgJiBFUlJERVRfTEFFKSB7DQo+ICsJCWlmICh1dnQpDQo+ICsJCQlk
ZXZfY3JpdChjY2YtPmRldiwgIkxBVyBVbmF2YWlsYWJsZSBUYXJnZXQgSURcbiIpOw0KPiArCQll
bHNlDQo+ICsJCQlkZXZfY3JpdChjY2YtPmRldiwgIkxvY2FsIEFjY2VzcyBXaW5kb3cgRXJyb3Jc
biIpOw0KPiArCX0NCj4gKw0KPiArCWlmIChlcnJkZXQgJiBFUlJERVRfQ1YpDQo+ICsJCWRldl9j
cml0KGNjZi0+ZGV2LCAiQ29oZXJlbmN5IFZpb2xhdGlvblxuIik7DQo+ICsNCj4gKwlpZiAoY2Fw
X3ZhbGlkKSB7DQo+ICsJCWRldl9jcml0KGNjZi0+ZGV2LCAiYWRkcmVzcyAweCUwOWxseCwgc3Jj
IGlkIDB4JXhcbiIsDQo+ICsJCQkgYWRkciwgc3JjX2lkKTsNCj4gKwl9DQo+ICsNCj4gK291dDoN
Cj4gKwlpb3dyaXRlMzJiZShlcnJkZXQsICZjY2YtPmVycl9yZWdzLT5lcnJkZXQpOw0KPiArCXJl
dHVybiBlcnJkZXQgPyBJUlFfSEFORExFRCA6IElSUV9OT05FOyB9DQo+ICsNCj4gK3N0YXRpYyBp
bnQgY2NmX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpIHsNCj4gKwlzdHJ1Y3Qg
Y2NmX3ByaXZhdGUgKmNjZjsNCj4gKwlzdHJ1Y3QgcmVzb3VyY2UgKnI7DQo+ICsJY29uc3Qgc3Ry
dWN0IG9mX2RldmljZV9pZCAqbWF0Y2g7DQo+ICsJaW50IHJldCwgaXJxOw0KPiArDQo+ICsJbWF0
Y2ggPSBvZl9tYXRjaF9kZXZpY2UoY2NmX21hdGNoZXMsICZwZGV2LT5kZXYpOw0KPiArCWlmIChX
QVJOX09OKCFtYXRjaCkpDQo+ICsJCXJldHVybiAtRU5PREVWOw0KPiArDQo+ICsJY2NmID0gZGV2
bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqY2NmKSwgR0ZQX0tFUk5FTCk7DQo+ICsJaWYg
KCFjY2YpDQo+ICsJCXJldHVybiAtRU5PTUVNOw0KPiArDQo+ICsJciA9IHBsYXRmb3JtX2dldF9y
ZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7DQo+ICsJaWYgKCFyKSB7DQo+ICsJCWRl
dl9lcnIoJnBkZXYtPmRldiwgIiVzOiBubyBtZW0gcmVzb3VyY2VcbiIsIF9fZnVuY19fKTsNCj4g
KwkJcmV0dXJuIC1FTlhJTzsNCj4gKwl9DQo+ICsNCj4gKwljY2YtPnJlZ3MgPSBkZXZtX2lvcmVt
YXBfcmVzb3VyY2UoJnBkZXYtPmRldiwgcik7DQo+ICsJaWYgKElTX0VSUihjY2YtPnJlZ3MpKSB7
DQo+ICsJCWRldl9lcnIoJnBkZXYtPmRldiwgIiVzOiBjYW4ndCBtYXAgbWVtIHJlc291cmNlXG4i
LCBfX2Z1bmNfXyk7DQo+ICsJCXJldHVybiBQVFJfRVJSKGNjZi0+cmVncyk7DQo+ICsJfQ0KPiAr
DQo+ICsJY2NmLT5kZXYgPSAmcGRldi0+ZGV2Ow0KPiArCWNjZi0+aW5mbyA9IG1hdGNoLT5kYXRh
Ow0KPiArCWNjZi0+ZXJyX3JlZ3MgPSBjY2YtPnJlZ3MgKyBjY2YtPmluZm8tPmVycl9yZWdfb2Zm
czsNCj4gKw0KPiArCWRldl9zZXRfZHJ2ZGF0YSgmcGRldi0+ZGV2LCBjY2YpOw0KPiArDQo+ICsJ
aXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCj4gKwlpZiAoIWlycSkgew0KPiArCQlk
ZXZfZXJyKCZwZGV2LT5kZXYsICIlczogbm8gaXJxXG4iLCBfX2Z1bmNfXyk7DQo+ICsJCXJldHVy
biAtRU5YSU87DQo+ICsJfQ0KPiArDQo+ICsJcmV0ID0gZGV2bV9yZXF1ZXN0X2lycSgmcGRldi0+
ZGV2LCBpcnEsIGNjZl9pcnEsIDAsIHBkZXYtPm5hbWUsIGNjZik7DQo+ICsJaWYgKHJldCkgew0K
PiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICIlczogY2FuJ3QgcmVxdWVzdCBpcnFcbiIsIF9fZnVu
Y19fKTsNCj4gKwkJcmV0dXJuIHJldDsNCj4gKwl9DQo+ICsNCj4gKwlzd2l0Y2ggKGNjZi0+aW5m
by0+dmVyc2lvbikgew0KPiArCWNhc2UgQ0NGMToNCj4gKwkJLyogT24gQ0NGMSB0aGlzIHJlZ2lz
dGVyIGVuYWJsZXMgcmF0aGVyIHRoYW4gZGlzYWJsZXMuICovDQo+ICsJCWlvd3JpdGUzMmJlKEVS
UkRFVF9MQUUgfCBFUlJERVRfQ1YsICZjY2YtPmVycl9yZWdzLT5lcnJkaXMpOw0KPiArCQlicmVh
azsNCj4gKw0KPiArCWNhc2UgQ0NGMjoNCj4gKwkJaW93cml0ZTMyYmUoMCwgJmNjZi0+ZXJyX3Jl
Z3MtPmVycmRpcyk7DQo+ICsJCWlvd3JpdGUzMmJlKEVSUkRFVF9MQUUgfCBFUlJERVRfQ1YsICZj
Y2YtPmVycl9yZWdzLT5lcnJpbnRlbik7DQo+ICsJCWJyZWFrOw0KPiArCX0NCj4gKw0KPiArCXJl
dHVybiAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgaW50IGNjZl9yZW1vdmUoc3RydWN0IHBsYXRm
b3JtX2RldmljZSAqcGRldikgew0KPiArCXN0cnVjdCBjY2ZfcHJpdmF0ZSAqY2NmID0gZGV2X2dl
dF9kcnZkYXRhKCZwZGV2LT5kZXYpOw0KPiArDQo+ICsJc3dpdGNoIChjY2YtPmluZm8tPnZlcnNp
b24pIHsNCj4gKwljYXNlIENDRjE6DQo+ICsJCWlvd3JpdGUzMmJlKDAsICZjY2YtPmVycl9yZWdz
LT5lcnJkaXMpOw0KPiArCQlicmVhazsNCj4gKw0KPiArCWNhc2UgQ0NGMjoNCj4gKwkJaW93cml0
ZTMyYmUoMCwgJmNjZi0+ZXJyX3JlZ3MtPmVycmludGVuKTsNCg0KRG8geW91IHRoaW5rIGl0IGlz
IHNhbWUgdG8gZGlzYWJsZSBkZXRlY3Rpb24gYml0cyBpbiBjY2YtPmVycl9yZWdzLT5lcnJkaXM/
DQoNClRoYW5rcw0KLUJoYXJhdA0KDQo+ICsJCWJyZWFrOw0KPiArCX0NCj4gKw0KPiArCXJldHVy
biAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBjY2ZfZHJp
dmVyID0gew0KPiArCS5kcml2ZXIgPSB7DQo+ICsJCS5uYW1lID0gS0JVSUxEX01PRE5BTUUsDQo+
ICsJCS5vd25lciA9IFRISVNfTU9EVUxFLA0KPiArCQkub2ZfbWF0Y2hfdGFibGUgPSBjY2ZfbWF0
Y2hlcywNCj4gKwl9LA0KPiArCS5wcm9iZSA9IGNjZl9wcm9iZSwNCj4gKwkucmVtb3ZlID0gY2Nm
X3JlbW92ZSwNCj4gK307DQo+ICsNCj4gK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoY2NmX2RyaXZl
cik7DQo+ICsNCj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsNCj4gK01PRFVMRV9BVVRIT1IoIkZy
ZWVzY2FsZSBTZW1pY29uZHVjdG9yIik7IE1PRFVMRV9ERVNDUklQVElPTigiRnJlZXNjYWxlDQo+
ICtDb3JlTmV0IENvaGVyZW5jeSBGYWJyaWMgZXJyb3IgcmVwb3J0aW5nIik7DQo+IC0tDQo+IDEu
OS4xDQo+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQo+
IExpbnV4cHBjLWRldiBtYWlsaW5nIGxpc3QNCj4gTGludXhwcGMtZGV2QGxpc3RzLm96bGFicy5v
cmcNCj4gaHR0cHM6Ly9saXN0cy5vemxhYnMub3JnL2xpc3RpbmZvL2xpbnV4cHBjLWRldg0K

Re: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Scott Wood]

On Wed, 2014-06-04 at 03:17 -0500, Bhushan Bharat-R65777 wrote:
> > +struct ccf_err_regs {
> > +	u32 errdet;		/* 0x00 Error Detect Register */
> > +	/* 0x04 Error Enable (ccf1)/Disable (ccf2) Register */
> > +	u32 errdis;
> > +	/* 0x08 Error Interrupt Enable Register (ccf2 only) */
> > +	u32 errinten;
> > +	u32 cecar;		/* 0x0c Error Capture Attribute Register */
> > +	u32 cecadrh;		/* 0x10 Error Capture Address High */
> 
> s/cecadrh/cecaddrh/g
> This way we will be consistent with Reference manual.

It's "cecadrh" in ccf1 and "cecaddrh" in ccf2.  I suppose I should use
the latter since "errdet/errdis/errinten" are the ccf2 names.

> > +	u32 cecadrl;		/* 0x14 Error Capture Address Low */
> 
> s/cecadrl/cecaddrl/g
> 
> > +	u32 cecar2;		/* 0x18 Error Capture Attribute Register 2 */
> > +};
> > +
> > +/* LAE/CV also valid for errdis and errinten */
> > +#define ERRDET_LAE		(1 << 0)  /* Local Access Error */
> > +#define ERRDET_CV		(1 << 1)  /* Coherency Violation */
> > +#define ERRDET_CTYPE_SHIFT	26	  /* Capture Type (ccf2 only) */
> > +#define ERRDET_CTYPE_MASK	(0x3f << ERRDET_CTYPE_SHIFT)
> 
> Should not this be (0x1f << ERRDET_CTYPE_SHIFT)

Yes, thanks for catching that.

> > +#define ERRDET_CAP		(1 << 31) /* Capture Valid (ccf2 only) */
> > +
> > +#define CECAR_VAL		(1 << 0)  /* Valid (ccf1 only) */
> > +#define CECAR_UVT		(1 << 15) /* Unavailable target ID (ccf1) */
> > +#define CECAR_SRCID_SHIFT_CCF1	24
> > +#define CECAR_SRCID_MASK_CCF1	(0xff << CECAR_SRCID_SHIFT_CCF1)
> > +#define CECAR_SRCID_SHIFT_CCF2	18
> > +#define CECAR_SRCID_MASK_CCF2	(0xff << CECAR_SRCID_SHIFT_CCF2)
> > +
> > +#define CECADRH_ADDRH		0xf
> 
> On ccf2 this id 0xff.

OK.  I think we can get away with using 0xff on both.

> > +static int ccf_remove(struct platform_device *pdev) {
> > +	struct ccf_private *ccf = dev_get_drvdata(&pdev->dev);
> > +
> > +	switch (ccf->info->version) {
> > +	case CCF1:
> > +		iowrite32be(0, &ccf->err_regs->errdis);
> > +		break;
> > +
> > +	case CCF2:
> > +		iowrite32be(0, &ccf->err_regs->errinten);
> 
> Do you think it is same to disable detection bits in ccf->err_regs->errdis?

Disabling the interrupt is what we're aiming for here, but ccf1 doesn't
provide a way to do that separate from disabling detection.

-Scott

RE: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Bharat.Bhushan]

DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogV29vZCBTY290dC1CMDc0
MjENCj4gU2VudDogV2VkbmVzZGF5LCBKdW5lIDA0LCAyMDE0IDEwOjEyIFBNDQo+IFRvOiBCaHVz
aGFuIEJoYXJhdC1SNjU3NzcNCj4gQ2M6IEdyZWcgS3JvYWgtSGFydG1hbjsgbGludXhwcGMtZGV2
QGxpc3RzLm96bGFicy5vcmc7IGxpbnV4LQ0KPiBrZXJuZWxAdmdlci5rZXJuZWwub3JnDQo+IFN1
YmplY3Q6IFJlOiBbUkVTRU5EIFBBVENIXSBtZW1vcnk6IEZyZWVzY2FsZSBDb3JlTmV0IENvaGVy
ZW5jeSBGYWJyaWMgZXJyb3INCj4gcmVwb3J0aW5nIGRyaXZlcg0KPiANCj4gT24gV2VkLCAyMDE0
LTA2LTA0IGF0IDAzOjE3IC0wNTAwLCBCaHVzaGFuIEJoYXJhdC1SNjU3Nzcgd3JvdGU6DQo+ID4g
PiArc3RydWN0IGNjZl9lcnJfcmVncyB7DQo+ID4gPiArCXUzMiBlcnJkZXQ7CQkvKiAweDAwIEVy
cm9yIERldGVjdCBSZWdpc3RlciAqLw0KPiA+ID4gKwkvKiAweDA0IEVycm9yIEVuYWJsZSAoY2Nm
MSkvRGlzYWJsZSAoY2NmMikgUmVnaXN0ZXIgKi8NCj4gPiA+ICsJdTMyIGVycmRpczsNCj4gPiA+
ICsJLyogMHgwOCBFcnJvciBJbnRlcnJ1cHQgRW5hYmxlIFJlZ2lzdGVyIChjY2YyIG9ubHkpICov
DQo+ID4gPiArCXUzMiBlcnJpbnRlbjsNCj4gPiA+ICsJdTMyIGNlY2FyOwkJLyogMHgwYyBFcnJv
ciBDYXB0dXJlIEF0dHJpYnV0ZSBSZWdpc3RlciAqLw0KPiA+ID4gKwl1MzIgY2VjYWRyaDsJCS8q
IDB4MTAgRXJyb3IgQ2FwdHVyZSBBZGRyZXNzIEhpZ2ggKi8NCj4gPg0KPiA+IHMvY2VjYWRyaC9j
ZWNhZGRyaC9nDQo+ID4gVGhpcyB3YXkgd2Ugd2lsbCBiZSBjb25zaXN0ZW50IHdpdGggUmVmZXJl
bmNlIG1hbnVhbC4NCj4gDQo+IEl0J3MgImNlY2FkcmgiIGluIGNjZjEgYW5kICJjZWNhZGRyaCIg
aW4gY2NmMi4gIEkgc3VwcG9zZSBJIHNob3VsZCB1c2UgdGhlDQo+IGxhdHRlciBzaW5jZSAiZXJy
ZGV0L2VycmRpcy9lcnJpbnRlbiIgYXJlIHRoZSBjY2YyIG5hbWVzLg0KPiANCj4gPiA+ICsJdTMy
IGNlY2Fkcmw7CQkvKiAweDE0IEVycm9yIENhcHR1cmUgQWRkcmVzcyBMb3cgKi8NCj4gPg0KPiA+
IHMvY2VjYWRybC9jZWNhZGRybC9nDQo+ID4NCj4gPiA+ICsJdTMyIGNlY2FyMjsJCS8qIDB4MTgg
RXJyb3IgQ2FwdHVyZSBBdHRyaWJ1dGUgUmVnaXN0ZXIgMiAqLw0KPiA+ID4gK307DQo+ID4gPiAr
DQo+ID4gPiArLyogTEFFL0NWIGFsc28gdmFsaWQgZm9yIGVycmRpcyBhbmQgZXJyaW50ZW4gKi8N
Cj4gPiA+ICsjZGVmaW5lIEVSUkRFVF9MQUUJCSgxIDw8IDApICAvKiBMb2NhbCBBY2Nlc3MgRXJy
b3IgKi8NCj4gPiA+ICsjZGVmaW5lIEVSUkRFVF9DVgkJKDEgPDwgMSkgIC8qIENvaGVyZW5jeSBW
aW9sYXRpb24gKi8NCj4gPiA+ICsjZGVmaW5lIEVSUkRFVF9DVFlQRV9TSElGVAkyNgkgIC8qIENh
cHR1cmUgVHlwZSAoY2NmMiBvbmx5KSAqLw0KPiA+ID4gKyNkZWZpbmUgRVJSREVUX0NUWVBFX01B
U0sJKDB4M2YgPDwgRVJSREVUX0NUWVBFX1NISUZUKQ0KPiA+DQo+ID4gU2hvdWxkIG5vdCB0aGlz
IGJlICgweDFmIDw8IEVSUkRFVF9DVFlQRV9TSElGVCkNCj4gDQo+IFllcywgdGhhbmtzIGZvciBj
YXRjaGluZyB0aGF0Lg0KPiANCj4gPiA+ICsjZGVmaW5lIEVSUkRFVF9DQVAJCSgxIDw8IDMxKSAv
KiBDYXB0dXJlIFZhbGlkIChjY2YyIG9ubHkpICovDQo+ID4gPiArDQo+ID4gPiArI2RlZmluZSBD
RUNBUl9WQUwJCSgxIDw8IDApICAvKiBWYWxpZCAoY2NmMSBvbmx5KSAqLw0KPiA+ID4gKyNkZWZp
bmUgQ0VDQVJfVVZUCQkoMSA8PCAxNSkgLyogVW5hdmFpbGFibGUgdGFyZ2V0IElEIChjY2YxKSAq
Lw0KPiA+ID4gKyNkZWZpbmUgQ0VDQVJfU1JDSURfU0hJRlRfQ0NGMQkyNA0KPiA+ID4gKyNkZWZp
bmUgQ0VDQVJfU1JDSURfTUFTS19DQ0YxCSgweGZmIDw8IENFQ0FSX1NSQ0lEX1NISUZUX0NDRjEp
DQo+ID4gPiArI2RlZmluZSBDRUNBUl9TUkNJRF9TSElGVF9DQ0YyCTE4DQo+ID4gPiArI2RlZmlu
ZSBDRUNBUl9TUkNJRF9NQVNLX0NDRjIJKDB4ZmYgPDwgQ0VDQVJfU1JDSURfU0hJRlRfQ0NGMikN
Cj4gPiA+ICsNCj4gPiA+ICsjZGVmaW5lIENFQ0FEUkhfQUREUkgJCTB4Zg0KPiA+DQo+ID4gT24g
Y2NmMiB0aGlzIGlkIDB4ZmYuDQo+IA0KPiBPSy4gIEkgdGhpbmsgd2UgY2FuIGdldCBhd2F5IHdp
dGggdXNpbmcgMHhmZiBvbiBib3RoLg0KPiANCj4gPiA+ICtzdGF0aWMgaW50IGNjZl9yZW1vdmUo
c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikgew0KPiA+ID4gKwlzdHJ1Y3QgY2NmX3ByaXZh
dGUgKmNjZiA9IGRldl9nZXRfZHJ2ZGF0YSgmcGRldi0+ZGV2KTsNCj4gPiA+ICsNCj4gPiA+ICsJ
c3dpdGNoIChjY2YtPmluZm8tPnZlcnNpb24pIHsNCj4gPiA+ICsJY2FzZSBDQ0YxOg0KPiA+ID4g
KwkJaW93cml0ZTMyYmUoMCwgJmNjZi0+ZXJyX3JlZ3MtPmVycmRpcyk7DQo+ID4gPiArCQlicmVh
azsNCj4gPiA+ICsNCj4gPiA+ICsJY2FzZSBDQ0YyOg0KPiA+ID4gKwkJaW93cml0ZTMyYmUoMCwg
JmNjZi0+ZXJyX3JlZ3MtPmVycmludGVuKTsNCj4gPg0KPiA+IERvIHlvdSB0aGluayBpdCBpcyBz
YW1lIHRvIGRpc2FibGUgZGV0ZWN0aW9uIGJpdHMgaW4gY2NmLT5lcnJfcmVncy0+ZXJyZGlzPw0K
PiANCj4gRGlzYWJsaW5nIHRoZSBpbnRlcnJ1cHQgaXMgd2hhdCB3ZSdyZSBhaW1pbmcgZm9yIGhl
cmUsIGJ1dCBjY2YxIGRvZXNuJ3QgcHJvdmlkZQ0KPiBhIHdheSB0byBkbyB0aGF0IHNlcGFyYXRl
IGZyb20gZGlzYWJsaW5nIGRldGVjdGlvbi4NCg0KV2hhdCBJIHdhbnRlZCB0byBzYXkgdGhhdCBk
byB3ZSBhbHNvIG5lZWQgdG8gZGlzYWJsZSBkZXRlY3Rpb24gKHNldCBFUlJERVRfTEFFIHwgRVJS
REVUX0NWIGJpdHMgaW4gZXJyZGlzKSBhcGFydCBmcm9tIGNsZWFyaW5nIGVycmludGVuIG9uIGNj
ZjIgPw0KDQpUaGFua3MNCi1CaGFyYXQNCg0KPiANCj4gLVNjb3R0DQo+IA0KDQo=

Re: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Scott Wood]

On Wed, 2014-06-04 at 12:04 -0500, Bhushan Bharat-R65777 wrote:
> 
> > -----Original Message-----
> > From: Wood Scott-B07421
> > Sent: Wednesday, June 04, 2014 10:12 PM
> > To: Bhushan Bharat-R65777
> > Cc: Greg Kroah-Hartman; linuxppc-dev@lists.ozlabs.org; linux-
> > kernel@vger.kernel.org
> > Subject: Re: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error
> > reporting driver
> > 
> > On Wed, 2014-06-04 at 03:17 -0500, Bhushan Bharat-R65777 wrote:
> > > > +static int ccf_remove(struct platform_device *pdev) {
> > > > +	struct ccf_private *ccf = dev_get_drvdata(&pdev->dev);
> > > > +
> > > > +	switch (ccf->info->version) {
> > > > +	case CCF1:
> > > > +		iowrite32be(0, &ccf->err_regs->errdis);
> > > > +		break;
> > > > +
> > > > +	case CCF2:
> > > > +		iowrite32be(0, &ccf->err_regs->errinten);
> > >
> > > Do you think it is same to disable detection bits in ccf->err_regs->errdis?
> > 
> > Disabling the interrupt is what we're aiming for here, but ccf1 doesn't provide
> > a way to do that separate from disabling detection.
> 
> What I wanted to say that do we also need to disable detection (set
> ERRDET_LAE | ERRDET_CV bits in errdis) apart from clearing errinten on
> ccf2 ?

I don't think we "need" to.  You could argue that we should for
consistency, though I think there's value in errors continuing to be
detected even without the driver (e.g. can dump the registers in a
debugger).

-Scott

RE: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Bharat.Bhushan]
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=

Re: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Scott Wood]

On Sun, 2014-06-29 at 23:58 -0500, Bhushan Bharat-R65777 wrote:
> 
> > -----Original Message-----
> > From: Wood Scott-B07421
> > Sent: Wednesday, June 04, 2014 10:38 PM
> > To: Bhushan Bharat-R65777
> > Cc: Greg Kroah-Hartman; linuxppc-dev@lists.ozlabs.org; linux-
> > kernel@vger.kernel.org
> > Subject: Re: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error
> > reporting driver
> > 
> > On Wed, 2014-06-04 at 12:04 -0500, Bhushan Bharat-R65777 wrote:
> > >
> > > > -----Original Message-----
> > > > From: Wood Scott-B07421
> > > > Sent: Wednesday, June 04, 2014 10:12 PM
> > > > To: Bhushan Bharat-R65777
> > > > Cc: Greg Kroah-Hartman; linuxppc-dev@lists.ozlabs.org; linux-
> > > > kernel@vger.kernel.org
> > > > Subject: Re: [RESEND PATCH] memory: Freescale CoreNet Coherency
> > > > Fabric error reporting driver
> > > >
> > > > On Wed, 2014-06-04 at 03:17 -0500, Bhushan Bharat-R65777 wrote:
> > > > > > +static int ccf_remove(struct platform_device *pdev) {
> > > > > > +	struct ccf_private *ccf = dev_get_drvdata(&pdev->dev);
> > > > > > +
> > > > > > +	switch (ccf->info->version) {
> > > > > > +	case CCF1:
> > > > > > +		iowrite32be(0, &ccf->err_regs->errdis);
> > > > > > +		break;
> > > > > > +
> > > > > > +	case CCF2:
> > > > > > +		iowrite32be(0, &ccf->err_regs->errinten);
> > > > >
> > > > > Do you think it is same to disable detection bits in ccf->err_regs-
> > >errdis?
> > > >
> > > > Disabling the interrupt is what we're aiming for here, but ccf1
> > > > doesn't provide a way to do that separate from disabling detection.
> > >
> > > What I wanted to say that do we also need to disable detection (set
> > > ERRDET_LAE | ERRDET_CV bits in errdis) apart from clearing errinten on
> > > ccf2 ?
> > 
> > I don't think we "need" to.  You could argue that we should for consistency,
> > though I think there's value in errors continuing to be detected even without
> > the driver (e.g. can dump the registers in a debugger).
> 
> Yes this comment was for consistency. Also IIUC, the state which is left when the driver is removed is not default reset behavior.

How many drivers leave the hardware in pristine reset state when
exiting?  And you could argue that having detection off by default is
poor hardware design (enabling interrupts is another matter of course).

> If we want errors to be detected then should not we have a sysfs interface?

That may be useful but it's beyond the scope of what I'm doing with this
patch.  We currently don't log machine checks anywhere but via printk
either.

BTW, I thought I had sent v2 of this, but I don't see it anywhere...
I'll respin soon.

-Scott

RE: [RESEND PATCH] memory: Freescale CoreNet Coherency Fabric error reporting driver

[Bharat.Bhushan]
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