From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [2/6] EDAC, altera: Combine Stratix10 and Arria10 probe functions From: thor.thayer@linux.intel.com Message-Id: <1537385941-11582-3-git-send-email-thor.thayer@linux.intel.com> Date: Wed, 19 Sep 2018 14:38:57 -0500 To: dinguyen@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com, bp@alien8.de, mchehab@kernel.org Cc: thor.thayer@linux.intel.com, devicetree@vger.kernel.org, linux-edac@vger.kernel.org List-ID: RnJvbTogVGhvciBUaGF5ZXIgPHRob3IudGhheWVyQGxpbnV4LmludGVsLmNvbT4KCk9uIFN0cmF0 aXgxMCwgdGhlIEVDQyBvZmZzZXRzIGFyZSBzaW1pbGFyIHRvIHRoZSBleGlzdGluZwpBcnJpYTEw IGZ1bmN0aW9ucyBhbmQgdGhpcyBjYW4gYmUgbGV2ZXJhZ2VkIHRvIHNpbXBsaWZ5CnRoZSBFREFD IGRyaXZlciBhcyBmb2xsb3dzOgoKMS4gRm9sZCBTdHJhdGl4MTAgc3BlY2lmaWNzIGludG8gQXJy aWExMCBzdHJ1Y3R1cmVzIGFuZApmdW5jdGlvbnMuCjIuIEltcGxlbWVudCB0aGUgU3RyYXRpeDEw IFN5c3RlbSBNYW5hZ2VyIHJlZ2lzdGVyIGFjY2Vzc2VzCnVzaW5nIGEgY3VzdG9tIHJlZ21hcCB0 byBhbGxvdyB1c2Ugd2l0aCB0aGUgQXJyaWExMCBTeXN0ZW0KTWFuYWdlciByZWdtYXBzLgozLiBT dHJhdGl4MTAgZG91YmxlIGJpdCBlcnJvcnMgYXJlIGltcGxlbWVudGVkIGFzIFNFcnJvcgppbnN0 ZWFkIG9mIGludGVycnVwdHMgc28gdXNlIGEgcGFuaWMgbm90aWZpZXIuCgpTaWduZWQtb2ZmLWJ5 OiBUaG9yIFRoYXllciA8dGhvci50aGF5ZXJAbGludXguaW50ZWwuY29tPgotLS0KIGRyaXZlcnMv ZWRhYy9hbHRlcmFfZWRhYy5jIHwgMjYzICsrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQogZHJpdmVycy9lZGFjL2FsdGVyYV9lZGFjLmggfCAgMTAgKy0KIDIgZmls ZXMgY2hhbmdlZCwgOTAgaW5zZXJ0aW9ucygrKSwgMTgzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZWRhYy9hbHRlcmFfZWRhYy5jIGIvZHJpdmVycy9lZGFjL2FsdGVyYV9lZGFj LmMKaW5kZXggNTc2MmMzYzM4M2YyLi5lMmI2NmEyMGQwNjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv ZWRhYy9hbHRlcmFfZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9hbHRlcmFfZWRhYy5jCkBAIC0y MTQ2LDYgKzIxNDYsMzUgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBpcnFfZG9tYWluX29wcyBhMTBf ZWNjbWdyX2ljX29wcyA9IHsKIAkueGxhdGUgPSBpcnFfZG9tYWluX3hsYXRlX3R3b2NlbGwsCiB9 OwogCisvKioqKioqKioqKioqKiogU3RyYXRpeCAxMCBFREFDIERvdWJsZSBCaXQgRXJyb3IgSGFu ZGxlciAqKioqKioqKioqKiovCisjZGVmaW5lIHRvX2ExMGVkYWMocCwgbSkgY29udGFpbmVyX29m KHAsIHN0cnVjdCBhbHRyX2FycmlhMTBfZWRhYywgbSkKKworLyoKKyAqIFRoZSBkb3VibGUgYml0 IGVycm9yIGlzIGhhbmRsZWQgdGhyb3VnaCBTRXJyb3Igd2hpY2ggaXMgZmF0YWwuIFRoaXMgaXMK KyAqIGNhbGxlZCBhcyBhIHBhbmljIG5vdGlmaWVyIHRvIHByaW50b3V0IEVDQyBlcnJvciBpbmZv IGFzIHBhcnQgb2YgdGhlIHBhbmljLgorICovCitzdGF0aWMgaW50IHMxMF9lZGFjX2RiZXJyX2hh bmRsZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICp0aGlzLAorCQkJCSAgdW5zaWduZWQgbG9uZyBl dmVudCwgdm9pZCAqcHRyKQoreworCXN0cnVjdCBhbHRyX2FycmlhMTBfZWRhYyAqZWRhYyA9IHRv X2ExMGVkYWModGhpcywgcGFuaWNfbm90aWZpZXIpOworCWludCBlcnJfYWRkciwgZGJlcnJvcjsK KworCXJlZ21hcF9yZWFkKGVkYWMtPmVjY19tZ3JfbWFwLCBTMTBfU1lTTUdSX0VDQ19JTlRTVEFU X0RFUlJfT0ZTVCwKKwkJICAgICZkYmVycm9yKTsKKwlyZWdtYXBfd3JpdGUoZWRhYy0+ZWNjX21n cl9tYXAsIFMxMF9TWVNNR1JfVUVfVkFMX09GU1QsIGRiZXJyb3IpOworCWlmIChkYmVycm9yICYg UzEwX0REUjBfSVJRX01BU0spIHsKKwkJcmVnbWFwX3JlYWQoZWRhYy0+ZWNjX21ncl9tYXAsIFMx MF9ERVJSQUREUl9PRlNULCAmZXJyX2FkZHIpOworCQlyZWdtYXBfd3JpdGUoZWRhYy0+ZWNjX21n cl9tYXAsIFMxMF9TWVNNR1JfVUVfQUREUl9PRlNULAorCQkJICAgICBlcnJfYWRkcik7CisJCWVk YWNfcHJpbnRrKEtFUk5fRVJSLCBFREFDX01DLAorCQkJICAgICJFREFDOiBbVW5jb3JyZWN0YWJs ZSBlcnJvcnMgQCAweCUwOFhdXG5cbiIsCisJCQkgICAgZXJyX2FkZHIpOworCX0KKworCXJldHVy biBOT1RJRllfRE9ORTsKK30KKworLyoqKioqKioqKioqKioqKioqKiBBcnJpYSAxMCBFREFDIFBy b2JlIEZ1bmN0aW9uICoqKioqKioqKioqKioqKioqKioqKi8KIHN0YXRpYyBpbnQgYWx0cl9lZGFj X2ExMF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVjdCBhbHRy X2FycmlhMTBfZWRhYyAqZWRhYzsKQEAgLTIxNTksOCArMjE4OCwzMyBAQCBzdGF0aWMgaW50IGFs dHJfZWRhY19hMTBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlwbGF0Zm9y bV9zZXRfZHJ2ZGF0YShwZGV2LCBlZGFjKTsKIAlJTklUX0xJU1RfSEVBRCgmZWRhYy0+YTEwX2Vj Y19kZXZpY2VzKTsKIAotCWVkYWMtPmVjY19tZ3JfbWFwID0gc3lzY29uX3JlZ21hcF9sb29rdXBf YnlfcGhhbmRsZShwZGV2LT5kZXYub2Zfbm9kZSwKKwlpZiAoc29jZnBnYV9pc19hMTAoKSkgewor CQllZGFjLT5lY2NfbWdyX21hcCA9CisJCQlzeXNjb25fcmVnbWFwX2xvb2t1cF9ieV9waGFuZGxl KHBkZXYtPmRldi5vZl9ub2RlLAogCQkJCQkJCSJhbHRyLHN5c21nci1zeXNjb24iKTsKKwl9IGVs c2UgeworCQlzdHJ1Y3QgZGV2aWNlX25vZGUgKnN5c21ncl9ucDsKKwkJc3RydWN0IHJlc291cmNl IHJlczsKKwkJdm9pZCBfX2lvbWVtICpiYXNlOworCisJCXN5c21ncl9ucCA9IG9mX3BhcnNlX3Bo YW5kbGUocGRldi0+ZGV2Lm9mX25vZGUsCisJCQkJCSAgICAgImFsdHIsc3lzbWdyLXN5c2NvbiIs IDApOworCQlpZiAoIXN5c21ncl9ucCkgeworCQkJZWRhY19wcmludGsoS0VSTl9FUlIsIEVEQUNf REVWSUNFLAorCQkJCSAgICAiVW5hYmxlIHRvIGZpbmQgYWx0cixzeXNtZ3Itc3lzY29uXG4iKTsK KwkJCXJldHVybiAtRU5PREVWOworCQl9CisKKwkJaWYgKG9mX2FkZHJlc3NfdG9fcmVzb3VyY2Uo c3lzbWdyX25wLCAwLCAmcmVzKSkKKwkJCXJldHVybiAtRU5PTUVNOworCisJCS8qIE5lZWQgcGh5 c2ljYWwgYWRkcmVzcyBmb3IgU01DQyBjYWxsICovCisJCWJhc2UgPSAodm9pZCBfX2lvbWVtICop cmVzLnN0YXJ0OworCisJCWVkYWMtPmVjY19tZ3JfbWFwID0gZGV2bV9yZWdtYXBfaW5pdCgmcGRl di0+ZGV2LCBOVUxMLCBiYXNlLAorCQkJCQkJICAgICAmczEwX3NkcmFtX3JlZ21hcF9jZmcpOwor CX0KKwogCWlmIChJU19FUlIoZWRhYy0+ZWNjX21ncl9tYXApKSB7CiAJCWVkYWNfcHJpbnRrKEtF Uk5fRVJSLCBFREFDX0RFVklDRSwKIAkJCSAgICAiVW5hYmxlIHRvIGdldCBzeXNjb24gYWx0cixz eXNtZ3Itc3lzY29uXG4iKTsKQEAgLTIxODcsMTQgKzIyNDEsMzggQEAgc3RhdGljIGludCBhbHRy X2VkYWNfYTEwX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJCQkJCSBhbHRy X2VkYWNfYTEwX2lycV9oYW5kbGVyLAogCQkJCQkgZWRhYyk7CiAKLQllZGFjLT5kYl9pcnEgPSBw bGF0Zm9ybV9nZXRfaXJxKHBkZXYsIDEpOwotCWlmIChlZGFjLT5kYl9pcnEgPCAwKSB7Ci0JCWRl dl9lcnIoJnBkZXYtPmRldiwgIk5vIERCRVJSIElSUSByZXNvdXJjZVxuIik7Ci0JCXJldHVybiBl ZGFjLT5kYl9pcnE7CisJaWYgKHNvY2ZwZ2FfaXNfYTEwKCkpIHsKKwkJZWRhYy0+ZGJfaXJxID0g cGxhdGZvcm1fZ2V0X2lycShwZGV2LCAxKTsKKwkJaWYgKGVkYWMtPmRiX2lycSA8IDApIHsKKwkJ CWRldl9lcnIoJnBkZXYtPmRldiwgIk5vIERCRVJSIElSUSByZXNvdXJjZVxuIik7CisJCQlyZXR1 cm4gZWRhYy0+ZGJfaXJxOworCQl9CisJCWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyX2FuZF9kYXRh KGVkYWMtPmRiX2lycSwKKwkJCQkJCSBhbHRyX2VkYWNfYTEwX2lycV9oYW5kbGVyLAorCQkJCQkJ IGVkYWMpOworCX0gZWxzZSB7CisJCWludCBkYmVycm9yLCBlcnJfYWRkcjsKKworCQllZGFjLT5w YW5pY19ub3RpZmllci5ub3RpZmllcl9jYWxsID0gczEwX2VkYWNfZGJlcnJfaGFuZGxlcjsKKwkJ YXRvbWljX25vdGlmaWVyX2NoYWluX3JlZ2lzdGVyKCZwYW5pY19ub3RpZmllcl9saXN0LAorCQkJ CQkgICAgICAgJmVkYWMtPnBhbmljX25vdGlmaWVyKTsKKworCQkvKiBQcmludG91dCBhIG1lc3Nh Z2UgaWYgdW5jb3JyZWN0YWJsZSBlcnJvciBwcmV2aW91c2x5LiAqLworCQlyZWdtYXBfcmVhZChl ZGFjLT5lY2NfbWdyX21hcCwgUzEwX1NZU01HUl9VRV9WQUxfT0ZTVCwKKwkJCSAgICAmZGJlcnJv cik7CisJCWlmIChkYmVycm9yKSB7CisJCQlyZWdtYXBfcmVhZChlZGFjLT5lY2NfbWdyX21hcCwg UzEwX1NZU01HUl9VRV9BRERSX09GU1QsCisJCQkJICAgICZlcnJfYWRkcik7CisJCQllZGFjX3By aW50ayhLRVJOX0VSUiwgRURBQ19ERVZJQ0UsCisJCQkJICAgICJQcmV2aW91cyBCb290IFVFIGRl dGVjdGVkWzB4JVhdIEAgMHglWFxuIiwKKwkJCQkgICAgZGJlcnJvciwgZXJyX2FkZHIpOworCQkJ LyogUmVzZXQgdGhlIHN0aWNreSByZWdpc3RlcnMgKi8KKwkJCXJlZ21hcF93cml0ZShlZGFjLT5l Y2NfbWdyX21hcCwKKwkJCQkgICAgIFMxMF9TWVNNR1JfVUVfVkFMX09GU1QsIDApOworCQkJcmVn bWFwX3dyaXRlKGVkYWMtPmVjY19tZ3JfbWFwLAorCQkJCSAgICAgUzEwX1NZU01HUl9VRV9BRERS X09GU1QsIDApOworCQl9CiAJfQotCWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyX2FuZF9kYXRhKGVk YWMtPmRiX2lycSwKLQkJCQkJIGFsdHJfZWRhY19hMTBfaXJxX2hhbmRsZXIsCi0JCQkJCSBlZGFj KTsKIAogCWZvcl9lYWNoX2NoaWxkX29mX25vZGUocGRldi0+ZGV2Lm9mX25vZGUsIGNoaWxkKSB7 CiAJCWlmICghb2ZfZGV2aWNlX2lzX2F2YWlsYWJsZShjaGlsZCkpCkBAIC0yMjExLDcgKzIyODks OCBAQCBzdGF0aWMgaW50IGFsdHJfZWRhY19hMTBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKIAogCQkJYWx0cl9lZGFjX2ExMF9kZXZpY2VfYWRkKGVkYWMsIGNoaWxkKTsKIAot CQllbHNlIGlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShjaGlsZCwgImFsdHIsc2RyYW0tZWRh Yy1hMTAiKSkKKwkJZWxzZSBpZiAoKG9mX2RldmljZV9pc19jb21wYXRpYmxlKGNoaWxkLCAiYWx0 cixzZHJhbS1lZGFjLWExMCIpKSB8fAorCQkJIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShjaGls ZCwgImFsdHIsc2RyYW0tZWRhYy1zMTAiKSkpCiAJCQlvZl9wbGF0Zm9ybV9wb3B1bGF0ZShwZGV2 LT5kZXYub2Zfbm9kZSwKIAkJCQkJICAgICBhbHRyX3NkcmFtX2N0cmxfb2ZfbWF0Y2gsCiAJCQkJ CSAgICAgTlVMTCwgJnBkZXYtPmRldik7CkBAIC0yMjIyLDYgKzIzMDEsNyBAQCBzdGF0aWMgaW50 IGFsdHJfZWRhY19hMTBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogc3Rh dGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYWx0cl9lZGFjX2ExMF9vZl9tYXRjaFtdID0g ewogCXsgLmNvbXBhdGlibGUgPSAiYWx0cixzb2NmcGdhLWExMC1lY2MtbWFuYWdlciIgfSwKKwl7 IC5jb21wYXRpYmxlID0gImFsdHIsc29jZnBnYS1zMTAtZWNjLW1hbmFnZXIiIH0sCiAJe30sCiB9 OwogTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgYWx0cl9lZGFjX2ExMF9vZl9tYXRjaCk7CkBAIC0y MjM1LDE3MSArMjMxNSw2IEBAIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGFsdHJfZWRh Y19hMTBfZHJpdmVyID0gewogfTsKIG1vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoYWx0cl9lZGFjX2Ex MF9kcml2ZXIpOwogCi0vKioqKioqKioqKioqKiogU3RyYXRpeCAxMCBFREFDIERldmljZSBDb250 cm9sbGVyIEZ1bmN0aW9ucz4gKioqKioqKioqKioqLwotCi0jZGVmaW5lIHRvX3MxMGVkYWMocCwg bSkgY29udGFpbmVyX29mKHAsIHN0cnVjdCBhbHRyX3N0cmF0aXgxMF9lZGFjLCBtKQotCi0vKgot ICogVGhlIGRvdWJsZSBiaXQgZXJyb3IgaXMgaGFuZGxlZCB0aHJvdWdoIFNFcnJvciB3aGljaCBp cyBmYXRhbC4gVGhpcyBpcwotICogY2FsbGVkIGFzIGEgcGFuaWMgbm90aWZpZXIgdG8gcHJpbnRv dXQgRUNDIGVycm9yIGluZm8gYXMgcGFydCBvZiB0aGUgcGFuaWMuCi0gKi8KLXN0YXRpYyBpbnQg czEwX2VkYWNfZGJlcnJfaGFuZGxlcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnRoaXMsCi0JCQkJ ICB1bnNpZ25lZCBsb25nIGV2ZW50LCB2b2lkICpwdHIpCi17Ci0Jc3RydWN0IGFsdHJfc3RyYXRp eDEwX2VkYWMgKmVkYWMgPSB0b19zMTBlZGFjKHRoaXMsIHBhbmljX25vdGlmaWVyKTsKLQlpbnQg ZXJyX2FkZHIsIGRiZXJyb3I7Ci0KLQlzMTBfcHJvdGVjdGVkX3JlZ19yZWFkKGVkYWMsIFMxMF9T WVNNR1JfRUNDX0lOVFNUQVRfREVSUl9PRlNULAotCQkJICAgICAgICZkYmVycm9yKTsKLQkvKiBS ZW1lbWJlciB0aGUgVUUgRXJyb3JzIGZvciBhIHJlYm9vdCAqLwotCXMxMF9wcm90ZWN0ZWRfcmVn X3dyaXRlKGVkYWMsIFMxMF9TWVNNR1JfVUVfVkFMX09GU1QsIGRiZXJyb3IpOwotCWlmIChkYmVy cm9yICYgUzEwX0REUjBfSVJRX01BU0spIHsKLQkJczEwX3Byb3RlY3RlZF9yZWdfcmVhZChlZGFj LCBTMTBfREVSUkFERFJfT0ZTVCwgJmVycl9hZGRyKTsKLQkJLyogUmVtZW1iZXIgdGhlIFVFIEVy cm9yIGFkZHJlc3MgKi8KLQkJczEwX3Byb3RlY3RlZF9yZWdfd3JpdGUoZWRhYywgUzEwX1NZU01H Ul9VRV9BRERSX09GU1QsCi0JCQkJCWVycl9hZGRyKTsKLQkJZWRhY19wcmludGsoS0VSTl9FUlIs IEVEQUNfTUMsCi0JCQkgICAgIkVEQUM6IFtVbmNvcnJlY3RhYmxlIGVycm9ycyBAIDB4JTA4WF1c blxuIiwKLQkJCSAgICBlcnJfYWRkcik7Ci0JfQotCi0JcmV0dXJuIE5PVElGWV9ET05FOwotfQot Ci1zdGF0aWMgdm9pZCBhbHRyX2VkYWNfczEwX2lycV9oYW5kbGVyKHN0cnVjdCBpcnFfZGVzYyAq ZGVzYykKLXsKLQlzdHJ1Y3QgYWx0cl9zdHJhdGl4MTBfZWRhYyAqZWRhYyA9IGlycV9kZXNjX2dl dF9oYW5kbGVyX2RhdGEoZGVzYyk7Ci0Jc3RydWN0IGlycV9jaGlwICpjaGlwID0gaXJxX2Rlc2Nf Z2V0X2NoaXAoZGVzYyk7Ci0JaW50IGlycSA9IGlycV9kZXNjX2dldF9pcnEoZGVzYyk7Ci0JaW50 IGJpdCwgc21fb2Zmc2V0LCBpcnFfc3RhdHVzOwotCi0Jc21fb2Zmc2V0ID0gUzEwX1NZU01HUl9F Q0NfSU5UU1RBVF9TRVJSX09GU1Q7Ci0KLQljaGFpbmVkX2lycV9lbnRlcihjaGlwLCBkZXNjKTsK LQotCXMxMF9wcm90ZWN0ZWRfcmVnX3JlYWQoTlVMTCwgc21fb2Zmc2V0LCAmaXJxX3N0YXR1cyk7 Ci0KLQlmb3JfZWFjaF9zZXRfYml0KGJpdCwgKHVuc2lnbmVkIGxvbmcgKikmaXJxX3N0YXR1cywg MzIpIHsKLQkJaXJxID0gaXJxX2xpbmVhcl9yZXZtYXAoZWRhYy0+ZG9tYWluLCBiaXQpOwotCQlp ZiAoaXJxKQotCQkJZ2VuZXJpY19oYW5kbGVfaXJxKGlycSk7Ci0JfQotCi0JY2hhaW5lZF9pcnFf ZXhpdChjaGlwLCBkZXNjKTsKLX0KLQotc3RhdGljIHZvaWQgczEwX2VjY21ncl9pcnFfbWFzayhz dHJ1Y3QgaXJxX2RhdGEgKmQpCi17Ci0Jc3RydWN0IGFsdHJfc3RyYXRpeDEwX2VkYWMgKmVkYWMg PSBpcnFfZGF0YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKLQotCXMxMF9wcm90ZWN0ZWRfcmVnX3dy aXRlKGVkYWMsIFMxMF9TWVNNR1JfRUNDX0lOVE1BU0tfU0VUX09GU1QsCi0JCQkJQklUKGQtPmh3 aXJxKSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHMxMF9lY2NtZ3JfaXJxX3VubWFzayhzdHJ1Y3QgaXJx X2RhdGEgKmQpCi17Ci0Jc3RydWN0IGFsdHJfc3RyYXRpeDEwX2VkYWMgKmVkYWMgPSBpcnFfZGF0 YV9nZXRfaXJxX2NoaXBfZGF0YShkKTsKLQotCXMxMF9wcm90ZWN0ZWRfcmVnX3dyaXRlKGVkYWMs IFMxMF9TWVNNR1JfRUNDX0lOVE1BU0tfQ0xSX09GU1QsCi0JCQkJQklUKGQtPmh3aXJxKSk7Ci19 Ci0KLXN0YXRpYyBpbnQgczEwX2VjY21ncl9pcnFkb21haW5fbWFwKHN0cnVjdCBpcnFfZG9tYWlu ICpkLCB1bnNpZ25lZCBpbnQgaXJxLAotCQkJCSAgICBpcnFfaHdfbnVtYmVyX3QgaHdpcnEpCi17 Ci0Jc3RydWN0IGFsdHJfc3RyYXRpeDEwX2VkYWMgKmVkYWMgPSBkLT5ob3N0X2RhdGE7Ci0KLQlp cnFfc2V0X2NoaXBfYW5kX2hhbmRsZXIoaXJxLCAmZWRhYy0+aXJxX2NoaXAsIGhhbmRsZV9zaW1w bGVfaXJxKTsKLQlpcnFfc2V0X2NoaXBfZGF0YShpcnEsIGVkYWMpOwotCWlycV9zZXRfbm9wcm9i ZShpcnEpOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgaXJxX2RvbWFp bl9vcHMgczEwX2VjY21ncl9pY19vcHMgPSB7Ci0JLm1hcCA9IHMxMF9lY2NtZ3JfaXJxZG9tYWlu X21hcCwKLQkueGxhdGUgPSBpcnFfZG9tYWluX3hsYXRlX3R3b2NlbGwsCi19OwotCi1zdGF0aWMg aW50IGFsdHJfZWRhY19zMTBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKLXsK LQlzdHJ1Y3QgYWx0cl9zdHJhdGl4MTBfZWRhYyAqZWRhYzsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUg KmNoaWxkOwotCWludCBkYmVycm9yLCBlcnJfYWRkcjsKLQotCWVkYWMgPSBkZXZtX2t6YWxsb2Mo JnBkZXYtPmRldiwgc2l6ZW9mKCplZGFjKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFlZGFjKQotCQly ZXR1cm4gLUVOT01FTTsKLQotCWVkYWMtPmRldiA9ICZwZGV2LT5kZXY7Ci0JcGxhdGZvcm1fc2V0 X2RydmRhdGEocGRldiwgZWRhYyk7Ci0JSU5JVF9MSVNUX0hFQUQoJmVkYWMtPnMxMF9lY2NfZGV2 aWNlcyk7Ci0KLQllZGFjLT5pcnFfY2hpcC5uYW1lID0gcGRldi0+ZGV2Lm9mX25vZGUtPm5hbWU7 Ci0JZWRhYy0+aXJxX2NoaXAuaXJxX21hc2sgPSBzMTBfZWNjbWdyX2lycV9tYXNrOwotCWVkYWMt PmlycV9jaGlwLmlycV91bm1hc2sgPSBzMTBfZWNjbWdyX2lycV91bm1hc2s7Ci0JZWRhYy0+ZG9t YWluID0gaXJxX2RvbWFpbl9hZGRfbGluZWFyKHBkZXYtPmRldi5vZl9ub2RlLCA2NCwKLQkJCQkJ ICAgICAmczEwX2VjY21ncl9pY19vcHMsIGVkYWMpOwotCWlmICghZWRhYy0+ZG9tYWluKSB7Ci0J CWRldl9lcnIoJnBkZXYtPmRldiwgIkVycm9yIGFkZGluZyBJUlEgZG9tYWluXG4iKTsKLQkJcmV0 dXJuIC1FTk9NRU07Ci0JfQotCi0JZWRhYy0+c2JfaXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2 LCAwKTsKLQlpZiAoZWRhYy0+c2JfaXJxIDwgMCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJO byBTQkVSUiBJUlEgcmVzb3VyY2VcbiIpOwotCQlyZXR1cm4gZWRhYy0+c2JfaXJxOwotCX0KLQot CWlycV9zZXRfY2hhaW5lZF9oYW5kbGVyX2FuZF9kYXRhKGVkYWMtPnNiX2lycSwKLQkJCQkJIGFs dHJfZWRhY19zMTBfaXJxX2hhbmRsZXIsCi0JCQkJCSBlZGFjKTsKLQotCWVkYWMtPnBhbmljX25v dGlmaWVyLm5vdGlmaWVyX2NhbGwgPSBzMTBfZWRhY19kYmVycl9oYW5kbGVyOwotCWF0b21pY19u b3RpZmllcl9jaGFpbl9yZWdpc3RlcigmcGFuaWNfbm90aWZpZXJfbGlzdCwKLQkJCQkgICAgICAg JmVkYWMtPnBhbmljX25vdGlmaWVyKTsKLQotCS8qIFByaW50b3V0IGEgbWVzc2FnZSBpZiB1bmNv cnJlY3RhYmxlIGVycm9yIHByZXZpb3VzbHkuICovCi0JczEwX3Byb3RlY3RlZF9yZWdfcmVhZChl ZGFjLCBTMTBfU1lTTUdSX1VFX1ZBTF9PRlNULCAmZGJlcnJvcik7Ci0JaWYgKGRiZXJyb3IpIHsK LQkJczEwX3Byb3RlY3RlZF9yZWdfcmVhZChlZGFjLCBTMTBfU1lTTUdSX1VFX0FERFJfT0ZTVCwK LQkJCQkgICAgICAgJmVycl9hZGRyKTsKLQkJZWRhY19wcmludGsoS0VSTl9FUlIsIEVEQUNfREVW SUNFLAotCQkJICAgICJQcmV2aW91cyBCb290IFVFIGRldGVjdGVkWzB4JVhdIEAgMHglWFxuIiwK LQkJCSAgICBkYmVycm9yLCBlcnJfYWRkcik7Ci0JCS8qIFJlc2V0IHRoZSBzdGlja3kgcmVnaXN0 ZXJzICovCi0JCXMxMF9wcm90ZWN0ZWRfcmVnX3dyaXRlKGVkYWMsIFMxMF9TWVNNR1JfVUVfVkFM X09GU1QsIDApOwotCQlzMTBfcHJvdGVjdGVkX3JlZ193cml0ZShlZGFjLCBTMTBfU1lTTUdSX1VF X0FERFJfT0ZTVCwgMCk7Ci0JfQotCi0JZm9yX2VhY2hfY2hpbGRfb2Zfbm9kZShwZGV2LT5kZXYu b2Zfbm9kZSwgY2hpbGQpIHsKLQkJaWYgKCFvZl9kZXZpY2VfaXNfYXZhaWxhYmxlKGNoaWxkKSkK LQkJCWNvbnRpbnVlOwotCi0JCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShjaGlsZCwgImFs dHIsc2RyYW0tZWRhYy1zMTAiKSkKLQkJCW9mX3BsYXRmb3JtX3BvcHVsYXRlKHBkZXYtPmRldi5v Zl9ub2RlLAotCQkJCQkgICAgIGFsdHJfc2RyYW1fY3RybF9vZl9tYXRjaCwKLQkJCQkJICAgICBO VUxMLCAmcGRldi0+ZGV2KTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGNvbnN0IHN0 cnVjdCBvZl9kZXZpY2VfaWQgYWx0cl9lZGFjX3MxMF9vZl9tYXRjaFtdID0gewotCXsgLmNvbXBh dGlibGUgPSAiYWx0cixzb2NmcGdhLXMxMC1lY2MtbWFuYWdlciIgfSwKLQl7fSwKLX07Ci1NT0RV TEVfREVWSUNFX1RBQkxFKG9mLCBhbHRyX2VkYWNfczEwX29mX21hdGNoKTsKLQotc3RhdGljIHN0 cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYWx0cl9lZGFjX3MxMF9kcml2ZXIgPSB7Ci0JLnByb2JlID0g IGFsdHJfZWRhY19zMTBfcHJvYmUsCi0JLmRyaXZlciA9IHsKLQkJLm5hbWUgPSAic29jZnBnYV9z MTBfZWNjX21hbmFnZXIiLAotCQkub2ZfbWF0Y2hfdGFibGUgPSBhbHRyX2VkYWNfczEwX29mX21h dGNoLAotCX0sCi19OwotbW9kdWxlX3BsYXRmb3JtX2RyaXZlcihhbHRyX2VkYWNfczEwX2RyaXZl cik7Ci0KIE1PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKIE1PRFVMRV9BVVRIT1IoIlRob3IgVGhh eWVyIik7CiBNT0RVTEVfREVTQ1JJUFRJT04oIkVEQUMgRHJpdmVyIGZvciBBbHRlcmEgTWVtb3Jp ZXMiKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9hbHRlcmFfZWRhYy5oIGIvZHJpdmVycy9l ZGFjL2FsdGVyYV9lZGFjLmgKaW5kZXggODFmMDU1NGUwOWRlLi5kOTI1YzRjZWUwMWIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZWRhYy9hbHRlcmFfZWRhYy5oCisrKyBiL2RyaXZlcnMvZWRhYy9hbHRl cmFfZWRhYy5oCkBAIC0zNzAsNiArMzcwLDcgQEAgc3RydWN0IGFsdHJfYXJyaWExMF9lZGFjIHsK IAlzdHJ1Y3QgaXJxX2RvbWFpbgkqZG9tYWluOwogCXN0cnVjdCBpcnFfY2hpcAkJaXJxX2NoaXA7 CiAJc3RydWN0IGxpc3RfaGVhZAlhMTBfZWNjX2RldmljZXM7CisJc3RydWN0IG5vdGlmaWVyX2Js b2NrCXBhbmljX25vdGlmaWVyOwogfTsKIAogLyoKQEAgLTQzNywxMyArNDM4LDQgQEAgc3RydWN0 IGFsdHJfYXJyaWExMF9lZGFjIHsKICNkZWZpbmUgSU5URUxfU0lQX1NNQ19SRUdfV1JJVEUgXAog CUlOVEVMX1NJUF9TTUNfRkFTVF9DQUxMX1ZBTChJTlRFTF9TSVBfU01DX0ZVTkNJRF9SRUdfV1JJ VEUpCiAKLXN0cnVjdCBhbHRyX3N0cmF0aXgxMF9lZGFjIHsKLQlzdHJ1Y3QgZGV2aWNlCQkqZGV2 OwotCWludCBzYl9pcnE7Ci0Jc3RydWN0IGlycV9kb21haW4JKmRvbWFpbjsKLQlzdHJ1Y3QgaXJx X2NoaXAJCWlycV9jaGlwOwotCXN0cnVjdCBsaXN0X2hlYWQJczEwX2VjY19kZXZpY2VzOwotCXN0 cnVjdCBub3RpZmllcl9ibG9jawlwYW5pY19ub3RpZmllcjsKLX07Ci0KICNlbmRpZgkvKiAjaWZu ZGVmIF9BTFRFUkFfRURBQ19IICovCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: thor.thayer@linux.intel.com Subject: [PATCH 2/6] EDAC, altera: Combine Stratix10 and Arria10 probe functions Date: Wed, 19 Sep 2018 14:38:57 -0500 Message-Id: <1537385941-11582-3-git-send-email-thor.thayer@linux.intel.com> In-Reply-To: <1537385941-11582-1-git-send-email-thor.thayer@linux.intel.com> References: <1537385941-11582-1-git-send-email-thor.thayer@linux.intel.com> To: dinguyen@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com, bp@alien8.de, mchehab@kernel.org Cc: thor.thayer@linux.intel.com, devicetree@vger.kernel.org, linux-edac@vger.kernel.org List-ID: From: Thor Thayer On Stratix10, the ECC offsets are similar to the existing Arria10 functions and this can be leveraged to simplify the EDAC driver as follows: 1. Fold Stratix10 specifics into Arria10 structures and functions. 2. Implement the Stratix10 System Manager register accesses using a custom regmap to allow use with the Arria10 System Manager regmaps. 3. Stratix10 double bit errors are implemented as SError instead of interrupts so use a panic notifier. Signed-off-by: Thor Thayer --- drivers/edac/altera_edac.c | 263 +++++++++++++++------------------------------ drivers/edac/altera_edac.h | 10 +- 2 files changed, 90 insertions(+), 183 deletions(-) diff --git a/drivers/edac/altera_edac.c b/drivers/edac/altera_edac.c index 5762c3c383f2..e2b66a20d064 100644 --- a/drivers/edac/altera_edac.c +++ b/drivers/edac/altera_edac.c @@ -2146,6 +2146,35 @@ static const struct irq_domain_ops a10_eccmgr_ic_ops = { .xlate = irq_domain_xlate_twocell, }; +/************** Stratix 10 EDAC Double Bit Error Handler ************/ +#define to_a10edac(p, m) container_of(p, struct altr_arria10_edac, m) + +/* + * The double bit error is handled through SError which is fatal. This is + * called as a panic notifier to printout ECC error info as part of the panic. + */ +static int s10_edac_dberr_handler(struct notifier_block *this, + unsigned long event, void *ptr) +{ + struct altr_arria10_edac *edac = to_a10edac(this, panic_notifier); + int err_addr, dberror; + + regmap_read(edac->ecc_mgr_map, S10_SYSMGR_ECC_INTSTAT_DERR_OFST, + &dberror); + regmap_write(edac->ecc_mgr_map, S10_SYSMGR_UE_VAL_OFST, dberror); + if (dberror & S10_DDR0_IRQ_MASK) { + regmap_read(edac->ecc_mgr_map, S10_DERRADDR_OFST, &err_addr); + regmap_write(edac->ecc_mgr_map, S10_SYSMGR_UE_ADDR_OFST, + err_addr); + edac_printk(KERN_ERR, EDAC_MC, + "EDAC: [Uncorrectable errors @ 0x%08X]\n\n", + err_addr); + } + + return NOTIFY_DONE; +} + +/****************** Arria 10 EDAC Probe Function *********************/ static int altr_edac_a10_probe(struct platform_device *pdev) { struct altr_arria10_edac *edac; @@ -2159,8 +2188,33 @@ static int altr_edac_a10_probe(struct platform_device *pdev) platform_set_drvdata(pdev, edac); INIT_LIST_HEAD(&edac->a10_ecc_devices); - edac->ecc_mgr_map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, + if (socfpga_is_a10()) { + edac->ecc_mgr_map = + syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "altr,sysmgr-syscon"); + } else { + struct device_node *sysmgr_np; + struct resource res; + void __iomem *base; + + sysmgr_np = of_parse_phandle(pdev->dev.of_node, + "altr,sysmgr-syscon", 0); + if (!sysmgr_np) { + edac_printk(KERN_ERR, EDAC_DEVICE, + "Unable to find altr,sysmgr-syscon\n"); + return -ENODEV; + } + + if (of_address_to_resource(sysmgr_np, 0, &res)) + return -ENOMEM; + + /* Need physical address for SMCC call */ + base = (void __iomem *)res.start; + + edac->ecc_mgr_map = devm_regmap_init(&pdev->dev, NULL, base, + &s10_sdram_regmap_cfg); + } + if (IS_ERR(edac->ecc_mgr_map)) { edac_printk(KERN_ERR, EDAC_DEVICE, "Unable to get syscon altr,sysmgr-syscon\n"); @@ -2187,14 +2241,38 @@ static int altr_edac_a10_probe(struct platform_device *pdev) altr_edac_a10_irq_handler, edac); - edac->db_irq = platform_get_irq(pdev, 1); - if (edac->db_irq < 0) { - dev_err(&pdev->dev, "No DBERR IRQ resource\n"); - return edac->db_irq; + if (socfpga_is_a10()) { + edac->db_irq = platform_get_irq(pdev, 1); + if (edac->db_irq < 0) { + dev_err(&pdev->dev, "No DBERR IRQ resource\n"); + return edac->db_irq; + } + irq_set_chained_handler_and_data(edac->db_irq, + altr_edac_a10_irq_handler, + edac); + } else { + int dberror, err_addr; + + edac->panic_notifier.notifier_call = s10_edac_dberr_handler; + atomic_notifier_chain_register(&panic_notifier_list, + &edac->panic_notifier); + + /* Printout a message if uncorrectable error previously. */ + regmap_read(edac->ecc_mgr_map, S10_SYSMGR_UE_VAL_OFST, + &dberror); + if (dberror) { + regmap_read(edac->ecc_mgr_map, S10_SYSMGR_UE_ADDR_OFST, + &err_addr); + edac_printk(KERN_ERR, EDAC_DEVICE, + "Previous Boot UE detected[0x%X] @ 0x%X\n", + dberror, err_addr); + /* Reset the sticky registers */ + regmap_write(edac->ecc_mgr_map, + S10_SYSMGR_UE_VAL_OFST, 0); + regmap_write(edac->ecc_mgr_map, + S10_SYSMGR_UE_ADDR_OFST, 0); + } } - irq_set_chained_handler_and_data(edac->db_irq, - altr_edac_a10_irq_handler, - edac); for_each_child_of_node(pdev->dev.of_node, child) { if (!of_device_is_available(child)) @@ -2211,7 +2289,8 @@ static int altr_edac_a10_probe(struct platform_device *pdev) altr_edac_a10_device_add(edac, child); - else if (of_device_is_compatible(child, "altr,sdram-edac-a10")) + else if ((of_device_is_compatible(child, "altr,sdram-edac-a10")) || + (of_device_is_compatible(child, "altr,sdram-edac-s10"))) of_platform_populate(pdev->dev.of_node, altr_sdram_ctrl_of_match, NULL, &pdev->dev); @@ -2222,6 +2301,7 @@ static int altr_edac_a10_probe(struct platform_device *pdev) static const struct of_device_id altr_edac_a10_of_match[] = { { .compatible = "altr,socfpga-a10-ecc-manager" }, + { .compatible = "altr,socfpga-s10-ecc-manager" }, {}, }; MODULE_DEVICE_TABLE(of, altr_edac_a10_of_match); @@ -2235,171 +2315,6 @@ static struct platform_driver altr_edac_a10_driver = { }; module_platform_driver(altr_edac_a10_driver); -/************** Stratix 10 EDAC Device Controller Functions> ************/ - -#define to_s10edac(p, m) container_of(p, struct altr_stratix10_edac, m) - -/* - * The double bit error is handled through SError which is fatal. This is - * called as a panic notifier to printout ECC error info as part of the panic. - */ -static int s10_edac_dberr_handler(struct notifier_block *this, - unsigned long event, void *ptr) -{ - struct altr_stratix10_edac *edac = to_s10edac(this, panic_notifier); - int err_addr, dberror; - - s10_protected_reg_read(edac, S10_SYSMGR_ECC_INTSTAT_DERR_OFST, - &dberror); - /* Remember the UE Errors for a reboot */ - s10_protected_reg_write(edac, S10_SYSMGR_UE_VAL_OFST, dberror); - if (dberror & S10_DDR0_IRQ_MASK) { - s10_protected_reg_read(edac, S10_DERRADDR_OFST, &err_addr); - /* Remember the UE Error address */ - s10_protected_reg_write(edac, S10_SYSMGR_UE_ADDR_OFST, - err_addr); - edac_printk(KERN_ERR, EDAC_MC, - "EDAC: [Uncorrectable errors @ 0x%08X]\n\n", - err_addr); - } - - return NOTIFY_DONE; -} - -static void altr_edac_s10_irq_handler(struct irq_desc *desc) -{ - struct altr_stratix10_edac *edac = irq_desc_get_handler_data(desc); - struct irq_chip *chip = irq_desc_get_chip(desc); - int irq = irq_desc_get_irq(desc); - int bit, sm_offset, irq_status; - - sm_offset = S10_SYSMGR_ECC_INTSTAT_SERR_OFST; - - chained_irq_enter(chip, desc); - - s10_protected_reg_read(NULL, sm_offset, &irq_status); - - for_each_set_bit(bit, (unsigned long *)&irq_status, 32) { - irq = irq_linear_revmap(edac->domain, bit); - if (irq) - generic_handle_irq(irq); - } - - chained_irq_exit(chip, desc); -} - -static void s10_eccmgr_irq_mask(struct irq_data *d) -{ - struct altr_stratix10_edac *edac = irq_data_get_irq_chip_data(d); - - s10_protected_reg_write(edac, S10_SYSMGR_ECC_INTMASK_SET_OFST, - BIT(d->hwirq)); -} - -static void s10_eccmgr_irq_unmask(struct irq_data *d) -{ - struct altr_stratix10_edac *edac = irq_data_get_irq_chip_data(d); - - s10_protected_reg_write(edac, S10_SYSMGR_ECC_INTMASK_CLR_OFST, - BIT(d->hwirq)); -} - -static int s10_eccmgr_irqdomain_map(struct irq_domain *d, unsigned int irq, - irq_hw_number_t hwirq) -{ - struct altr_stratix10_edac *edac = d->host_data; - - irq_set_chip_and_handler(irq, &edac->irq_chip, handle_simple_irq); - irq_set_chip_data(irq, edac); - irq_set_noprobe(irq); - - return 0; -} - -static const struct irq_domain_ops s10_eccmgr_ic_ops = { - .map = s10_eccmgr_irqdomain_map, - .xlate = irq_domain_xlate_twocell, -}; - -static int altr_edac_s10_probe(struct platform_device *pdev) -{ - struct altr_stratix10_edac *edac; - struct device_node *child; - int dberror, err_addr; - - edac = devm_kzalloc(&pdev->dev, sizeof(*edac), GFP_KERNEL); - if (!edac) - return -ENOMEM; - - edac->dev = &pdev->dev; - platform_set_drvdata(pdev, edac); - INIT_LIST_HEAD(&edac->s10_ecc_devices); - - edac->irq_chip.name = pdev->dev.of_node->name; - edac->irq_chip.irq_mask = s10_eccmgr_irq_mask; - edac->irq_chip.irq_unmask = s10_eccmgr_irq_unmask; - edac->domain = irq_domain_add_linear(pdev->dev.of_node, 64, - &s10_eccmgr_ic_ops, edac); - if (!edac->domain) { - dev_err(&pdev->dev, "Error adding IRQ domain\n"); - return -ENOMEM; - } - - edac->sb_irq = platform_get_irq(pdev, 0); - if (edac->sb_irq < 0) { - dev_err(&pdev->dev, "No SBERR IRQ resource\n"); - return edac->sb_irq; - } - - irq_set_chained_handler_and_data(edac->sb_irq, - altr_edac_s10_irq_handler, - edac); - - edac->panic_notifier.notifier_call = s10_edac_dberr_handler; - atomic_notifier_chain_register(&panic_notifier_list, - &edac->panic_notifier); - - /* Printout a message if uncorrectable error previously. */ - s10_protected_reg_read(edac, S10_SYSMGR_UE_VAL_OFST, &dberror); - if (dberror) { - s10_protected_reg_read(edac, S10_SYSMGR_UE_ADDR_OFST, - &err_addr); - edac_printk(KERN_ERR, EDAC_DEVICE, - "Previous Boot UE detected[0x%X] @ 0x%X\n", - dberror, err_addr); - /* Reset the sticky registers */ - s10_protected_reg_write(edac, S10_SYSMGR_UE_VAL_OFST, 0); - s10_protected_reg_write(edac, S10_SYSMGR_UE_ADDR_OFST, 0); - } - - for_each_child_of_node(pdev->dev.of_node, child) { - if (!of_device_is_available(child)) - continue; - - if (of_device_is_compatible(child, "altr,sdram-edac-s10")) - of_platform_populate(pdev->dev.of_node, - altr_sdram_ctrl_of_match, - NULL, &pdev->dev); - } - - return 0; -} - -static const struct of_device_id altr_edac_s10_of_match[] = { - { .compatible = "altr,socfpga-s10-ecc-manager" }, - {}, -}; -MODULE_DEVICE_TABLE(of, altr_edac_s10_of_match); - -static struct platform_driver altr_edac_s10_driver = { - .probe = altr_edac_s10_probe, - .driver = { - .name = "socfpga_s10_ecc_manager", - .of_match_table = altr_edac_s10_of_match, - }, -}; -module_platform_driver(altr_edac_s10_driver); - MODULE_LICENSE("GPL v2"); MODULE_AUTHOR("Thor Thayer"); MODULE_DESCRIPTION("EDAC Driver for Altera Memories"); diff --git a/drivers/edac/altera_edac.h b/drivers/edac/altera_edac.h index 81f0554e09de..d925c4cee01b 100644 --- a/drivers/edac/altera_edac.h +++ b/drivers/edac/altera_edac.h @@ -370,6 +370,7 @@ struct altr_arria10_edac { struct irq_domain *domain; struct irq_chip irq_chip; struct list_head a10_ecc_devices; + struct notifier_block panic_notifier; }; /* @@ -437,13 +438,4 @@ struct altr_arria10_edac { #define INTEL_SIP_SMC_REG_WRITE \ INTEL_SIP_SMC_FAST_CALL_VAL(INTEL_SIP_SMC_FUNCID_REG_WRITE) -struct altr_stratix10_edac { - struct device *dev; - int sb_irq; - struct irq_domain *domain; - struct irq_chip irq_chip; - struct list_head s10_ecc_devices; - struct notifier_block panic_notifier; -}; - #endif /* #ifndef _ALTERA_EDAC_H */ -- 2.7.4