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/2] dmaengine: milbeaut: Add Milbeaut AXI DMA controller From: Kazuhiro Kasai Message-Id: <1553487314-9185-3-git-send-email-kasai.kazuhiro@socionext.com> Date: Mon, 25 Mar 2019 13:15:14 +0900 To: vkoul@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com Cc: dmaengine@vger.kernel.org, devicetree@vger.kernel.org, orito.takao@socionext.com, sugaya.taichi@socionext.com, kanematsu.shinji@socionext.com, jaswinder.singh@linaro.org, masami.hiramatsu@linaro.org, linux-kernel@vger.kernel.org, Kazuhiro Kasai List-ID: QWRkIE1pbGJlYXV0IEFYSSBETUEgY29udHJvbGxlci4gVGhpcyBETUEgY29udHJvbGxlciBoYXMK b25seSBjYXBhYmxlIG9mIG1lbW9yeSB0byBtZW1vcnkgdHJhbnNmZXIuCgpTaWduZWQtb2ZmLWJ5 OiBLYXp1aGlybyBLYXNhaSA8a2FzYWkua2F6dWhpcm9Ac29jaW9uZXh0LmNvbT4KLS0tCiBkcml2 ZXJzL2RtYS9LY29uZmlnICAgICAgICAgIHwgICA4ICsKIGRyaXZlcnMvZG1hL01ha2VmaWxlICAg ICAgICAgfCAgIDEgKwogZHJpdmVycy9kbWEveGRtYWMtbWlsYmVhdXQuYyB8IDM1MyArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDM2 MiBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEveGRtYWMtbWls YmVhdXQuYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL0tjb25maWcgYi9kcml2ZXJzL2RtYS9L Y29uZmlnCmluZGV4IDBiMWRmYjUuLjczM2ZlNWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hL0tj b25maWcKKysrIGIvZHJpdmVycy9kbWEvS2NvbmZpZwpAQCAtNjEyLDYgKzYxMiwxNCBAQCBjb25m aWcgVU5JUEhJRVJfTURNQUMKIAkgIFVuaVBoaWVyIHBsYXRmb3JtLiAgVGhpcyBETUEgY29udHJv bGxlciBpcyB1c2VkIGFzIHRoZSBleHRlcm5hbAogCSAgRE1BIGVuZ2luZSBvZiB0aGUgU0QvZU1N QyBjb250cm9sbGVycyBvZiB0aGUgTEQ0LCBQcm80LCBzTEQ4IFNvQ3MuCiAKK2NvbmZpZyBYRE1B Q19NSUxCRUFVVAorICAgICAgIHRyaXN0YXRlICJNaWxiZWF1dCBBWEkgRE1BIHN1cHBvcnQiCisg ICAgICAgZGVwZW5kcyBvbiBBUkNIX01JTEJFQVVUIHx8IENPTVBJTEVfVEVTVAorICAgICAgIHNl bGVjdCBETUFfRU5HSU5FCisgICAgICAgaGVscAorICAgICAgICAgU3VwcG9ydCBmb3IgTWlsYmVh dXQgQVhJIERNQSBjb250cm9sbGVyIGRyaXZlci4gVGhlIERNQSBjb250cm9sbGVyCisgICAgICAg ICBoYXMgb25seSBtZW1vcnkgdG8gbWVtb3J5IGNhcGFiaWxpdHkuCisKIGNvbmZpZyBYR0VORV9E TUEKIAl0cmlzdGF0ZSAiQVBNIFgtR2VuZSBETUEgc3VwcG9ydCIKIAlkZXBlbmRzIG9uIEFSQ0hf WEdFTkUgfHwgQ09NUElMRV9URVNUCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9NYWtlZmlsZSBi L2RyaXZlcnMvZG1hL01ha2VmaWxlCmluZGV4IDYxMjZlMWMuLjRhYWI4MTAgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZG1hL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZG1hL01ha2VmaWxlCkBAIC03Miw2 ICs3Miw3IEBAIG9iai0kKENPTkZJR19URUdSQTIwX0FQQl9ETUEpICs9IHRlZ3JhMjAtYXBiLWRt YS5vCiBvYmotJChDT05GSUdfVEVHUkEyMTBfQURNQSkgKz0gdGVncmEyMTAtYWRtYS5vCiBvYmot JChDT05GSUdfVElNQl9ETUEpICs9IHRpbWJfZG1hLm8KIG9iai0kKENPTkZJR19VTklQSElFUl9N RE1BQykgKz0gdW5pcGhpZXItbWRtYWMubworb2JqLSQoQ09ORklHX1hETUFDX01JTEJFQVVUKSAr PSB4ZG1hYy1taWxiZWF1dC5vCiBvYmotJChDT05GSUdfWEdFTkVfRE1BKSArPSB4Z2VuZS1kbWEu bwogb2JqLSQoQ09ORklHX1pYX0RNQSkgKz0genhfZG1hLm8KIG9iai0kKENPTkZJR19TVF9GRE1B KSArPSBzdF9mZG1hLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL3hkbWFjLW1pbGJlYXV0LmMg Yi9kcml2ZXJzL2RtYS94ZG1hYy1taWxiZWF1dC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjcwMzVjNjEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2RtYS94ZG1hYy1t aWxiZWF1dC5jCkBAIC0wLDAgKzEsMzUzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBTb2Npb25leHQgSW5jLgorICovCisK KyNpbmNsdWRlIDxsaW51eC9iaXRmaWVsZC5oPgorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5o PgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2RtYS5oPgor I2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorCisjaW5jbHVkZSAiZG1hZW5naW5l LmgiCisKKy8qIGdsb2JhbCByZWdpc3RlciAqLworI2RlZmluZSBNMTBWX1hEQUNTIDB4MDAKKwor LyogY2hhbm5lbCBsb2NhbCByZWdpc3RlciAqLworI2RlZmluZSBNMTBWX1hEVEJDIDB4MTAKKyNk ZWZpbmUgTTEwVl9YRFNTQSAweDE0CisjZGVmaW5lIE0xMFZfWEREU0EgMHgxOAorI2RlZmluZSBN MTBWX1hEU0FDIDB4MUMKKyNkZWZpbmUgTTEwVl9YRERBQyAweDIwCisjZGVmaW5lIE0xMFZfWERE Q0MgMHgyNAorI2RlZmluZSBNMTBWX1hEREVTIDB4MjgKKyNkZWZpbmUgTTEwVl9YRERQQyAweDJD CisjZGVmaW5lIE0xMFZfWEREU0QgMHgzMAorCisjZGVmaW5lIE0xMFZfWERBQ1NfWEUgQklUKDI4 KQorCisjZGVmaW5lIE0xMFZfWERTQUNfU0JTCUdFTk1BU0soMTcsIDE2KQorI2RlZmluZSBNMTBW X1hEU0FDX1NCTAlHRU5NQVNLKDExLCA4KQorCisjZGVmaW5lIE0xMFZfWEREQUNfREJTCUdFTk1B U0soMTcsIDE2KQorI2RlZmluZSBNMTBWX1hEREFDX0RCTAlHRU5NQVNLKDExLCA4KQorCisjZGVm aW5lIE0xMFZfWERERVNfQ0UJQklUKDI4KQorI2RlZmluZSBNMTBWX1hEREVTX1NFCUJJVCgyNCkK KyNkZWZpbmUgTTEwVl9YRERFU19TQQlCSVQoMTUpCisjZGVmaW5lIE0xMFZfWERERVNfVEYJR0VO TUFTSygyMywgMjApCisjZGVmaW5lIE0xMFZfWERERVNfRUkJQklUKDEpCisjZGVmaW5lIE0xMFZf WERERVNfVEkJQklUKDApCisKKyNkZWZpbmUgTTEwVl9YRERTRF9JU19NQVNLCUdFTk1BU0soMywg MCkKKyNkZWZpbmUgTTEwVl9YRERTRF9JU19OT1JNQUwJMHg4CisKKyNkZWZpbmUgTTEwVl9YRE1B Q19CVVNXSURUSFMJKEJJVChETUFfU0xBVkVfQlVTV0lEVEhfMV9CWVRFKSB8IFwKKwkJCQkgQklU KERNQV9TTEFWRV9CVVNXSURUSF8yX0JZVEVTKSB8IFwKKwkJCQkgQklUKERNQV9TTEFWRV9CVVNX SURUSF80X0JZVEVTKSB8IFwKKwkJCQkgQklUKERNQV9TTEFWRV9CVVNXSURUSF84X0JZVEVTKSkK KworI2RlZmluZSBNMTBWX1hETUFDX0NIQU5fQkFTRShiYXNlLCBpKQkoKGJhc2UpICsgKGkpICog MHgzMCkKKworI2RlZmluZSB0b19tMTB2X2RtYV9jaGFuKGMpCWNvbnRhaW5lcl9vZigoYyksIHN0 cnVjdCBtMTB2X2RtYV9jaGFuLCBjaGFuKQorCitzdHJ1Y3QgbTEwdl9kbWFfZGVzYyB7CisJc3Ry dWN0IGRtYV9hc3luY190eF9kZXNjcmlwdG9yIHR4ZDsKKwlzaXplX3QgbGVuOworCWRtYV9hZGRy X3Qgc3JjOworCWRtYV9hZGRyX3QgZHN0OworfTsKKworc3RydWN0IG0xMHZfZG1hX2NoYW4gewor CXN0cnVjdCBkbWFfY2hhbiBjaGFuOworCXN0cnVjdCBtMTB2X2RtYV9kZXZpY2UgKm1kbWFjOwor CXZvaWQgX19pb21lbSAqcmVnczsKKwlpbnQgaXJxOworCXN0cnVjdCBtMTB2X2RtYV9kZXNjIG1k ZXNjOworCXNwaW5sb2NrX3QgbG9jazsKK307CisKK3N0cnVjdCBtMTB2X2RtYV9kZXZpY2Ugewor CXN0cnVjdCBkbWFfZGV2aWNlIGRtYWM7CisJdm9pZCBfX2lvbWVtICpyZWdzOworCXVuc2lnbmVk IGludCBjaGFubmVsczsKKwlzdHJ1Y3QgbTEwdl9kbWFfY2hhbiBtY2hhblswXTsKK307CisKK3N0 YXRpYyB2b2lkIG0xMHZfeGRtYWNfZW5hYmxlX2RtYShzdHJ1Y3QgbTEwdl9kbWFfZGV2aWNlICpt ZG1hYykKK3sKKwl1bnNpZ25lZCBpbnQgdmFsOworCisJdmFsID0gcmVhZGwobWRtYWMtPnJlZ3Mg KyBNMTBWX1hEQUNTKTsKKwl2YWwgJj0gfk0xMFZfWERBQ1NfWEU7CisJdmFsIHw9IEZJRUxEX1BS RVAoTTEwVl9YREFDU19YRSwgMSk7CisJd3JpdGVsKHZhbCwgbWRtYWMtPnJlZ3MgKyBNMTBWX1hE QUNTKTsKK30KKworc3RhdGljIHZvaWQgbTEwdl94ZG1hY19kaXNhYmxlX2RtYShzdHJ1Y3QgbTEw dl9kbWFfZGV2aWNlICptZG1hYykKK3sKKwl1bnNpZ25lZCBpbnQgdmFsOworCisJdmFsID0gcmVh ZGwobWRtYWMtPnJlZ3MgKyBNMTBWX1hEQUNTKTsKKwl2YWwgJj0gfk0xMFZfWERBQ1NfWEU7CisJ dmFsIHw9IEZJRUxEX1BSRVAoTTEwVl9YREFDU19YRSwgMCk7CisJd3JpdGVsKHZhbCwgbWRtYWMt PnJlZ3MgKyBNMTBWX1hEQUNTKTsKK30KKworc3RhdGljIHZvaWQgbTEwdl94ZG1hY19jb25maWdf Y2hhbihzdHJ1Y3QgbTEwdl9kbWFfY2hhbiAqbWNoYW4pCit7CisJdTMyIHZhbDsKKworCXZhbCA9 IG1jaGFuLT5tZGVzYy5sZW4gLSAxOworCXdyaXRlbCh2YWwsIG1jaGFuLT5yZWdzICsgTTEwVl9Y RFRCQyk7CisKKwl2YWwgPSBtY2hhbi0+bWRlc2Muc3JjOworCXdyaXRlbCh2YWwsIG1jaGFuLT5y ZWdzICsgTTEwVl9YRFNTQSk7CisKKwl2YWwgPSBtY2hhbi0+bWRlc2MuZHN0OworCXdyaXRlbCh2 YWwsIG1jaGFuLT5yZWdzICsgTTEwVl9YRERTQSk7CisKKwl2YWwgPSByZWFkbChtY2hhbi0+cmVn cyArIE0xMFZfWERTQUMpOworCXZhbCAmPSB+KE0xMFZfWERTQUNfU0JTIHwgTTEwVl9YRFNBQ19T QkwpOworCXZhbCB8PSBGSUVMRF9QUkVQKE0xMFZfWERTQUNfU0JTLCAweDMpIHwKKwkgICAgICAg RklFTERfUFJFUChNMTBWX1hEU0FDX1NCTCwgMHhmKTsKKwl3cml0ZWwodmFsLCBtY2hhbi0+cmVn cyArIE0xMFZfWERTQUMpOworCisJdmFsID0gcmVhZGwobWNoYW4tPnJlZ3MgKyBNMTBWX1hEREFD KTsKKwl2YWwgJj0gfihNMTBWX1hEREFDX0RCUyB8IE0xMFZfWEREQUNfREJMKTsKKwl2YWwgfD0g RklFTERfUFJFUChNMTBWX1hEREFDX0RCUywgMHgzKSB8CisJICAgICAgIEZJRUxEX1BSRVAoTTEw Vl9YRERBQ19EQkwsIDB4Zik7CisJd3JpdGVsKHZhbCwgbWNoYW4tPnJlZ3MgKyBNMTBWX1hEREFD KTsKK30KKworc3RhdGljIHZvaWQgbTEwdl94ZG1hY19lbmFibGVfY2hhbihzdHJ1Y3QgbTEwdl9k bWFfY2hhbiAqbWNoYW4pCit7CisJdTMyIHZhbDsKKworCXZhbCA9IHJlYWRsKG1jaGFuLT5yZWdz ICsgTTEwVl9YRERFUyk7CisJdmFsICY9IH4oTTEwVl9YRERFU19DRSB8CisJICAgICAgICAgTTEw Vl9YRERFU19TRSB8CisJICAgICAgICAgTTEwVl9YRERFU19URiB8CisJICAgICAgICAgTTEwVl9Y RERFU19FSSB8CisJICAgICAgICAgTTEwVl9YRERFU19USSk7CisJdmFsIHw9IEZJRUxEX1BSRVAo TTEwVl9YRERFU19DRSwgMSkgfAorCSAgICAgICBGSUVMRF9QUkVQKE0xMFZfWERERVNfU0UsIDEp IHwKKwkgICAgICAgRklFTERfUFJFUChNMTBWX1hEREVTX1RGLCAxKSB8CisJICAgICAgIEZJRUxE X1BSRVAoTTEwVl9YRERFU19FSSwgMSkgfAorCSAgICAgICBGSUVMRF9QUkVQKE0xMFZfWERERVNf VEksIDEpOworCXdyaXRlbCh2YWwsIG1jaGFuLT5yZWdzICsgTTEwVl9YRERFUyk7Cit9CisKK3N0 YXRpYyB2b2lkIG0xMHZfeGRtYWNfZGlzYWJsZV9jaGFuKHN0cnVjdCBtMTB2X2RtYV9jaGFuICpt Y2hhbikKK3sKKwl1MzIgdmFsOworCisJdmFsID0gcmVhZGwobWNoYW4tPnJlZ3MgKyBNMTBWX1hE REVTKTsKKwl2YWwgJj0gfk0xMFZfWERERVNfQ0U7CisJdmFsIHw9IEZJRUxEX1BSRVAoTTEwVl9Y RERFU19DRSwgMCk7CisJd3JpdGVsKHZhbCwgbWNoYW4tPnJlZ3MgKyBNMTBWX1hEREVTKTsKK30K Kworc3RhdGljIGlycXJldHVybl90IG0xMHZfeGRtYWNfaXJxKGludCBpcnEsIHZvaWQgKmRhdGEp Cit7CisJc3RydWN0IG0xMHZfZG1hX2NoYW4gKm1jaGFuID0gZGF0YTsKKwl1bnNpZ25lZCBsb25n IGZsYWdzOworCXUzMiB2YWw7CisKKwl2YWwgPSByZWFkbChtY2hhbi0+cmVncyArIE0xMFZfWERE U0QpOworCXZhbCA9IEZJRUxEX0dFVChNMTBWX1hERFNEX0lTX01BU0ssIHZhbCk7CisKKwlpZiAo dmFsICE9IE0xMFZfWEREU0RfSVNfTk9STUFMKQorCQlkZXZfZXJyKG1jaGFuLT5jaGFuLmRldmlj ZS0+ZGV2LCAiWERNQUMgZXJyb3Igd2l0aCBzdGF0dXM6ICV4IiwgdmFsKTsKKworCXZhbCA9IEZJ RUxEX1BSRVAoTTEwVl9YRERTRF9JU19NQVNLLCAweDApOworCXdyaXRlbCh2YWwsIG1jaGFuLT5y ZWdzICsgTTEwVl9YRERTRCk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmbWNoYW4tPmxvY2ssIGZs YWdzKTsKKwlkbWFfY29va2llX2NvbXBsZXRlKCZtY2hhbi0+bWRlc2MudHhkKTsKKwlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZtY2hhbi0+bG9jaywgZmxhZ3MpOworCisJaWYgKG1jaGFuLT5tZGVz Yy50eGQuZmxhZ3MgJiBETUFfUFJFUF9JTlRFUlJVUFQpCisJCWRtYWVuZ2luZV9kZXNjX2dldF9j YWxsYmFja19pbnZva2UoJm1jaGFuLT5tZGVzYy50eGQsIE5VTEwpOworCisJcmV0dXJuIElSUV9I QU5ETEVEOworfQorCitzdGF0aWMgdm9pZCBtMTB2X3hkbWFjX2lzc3VlX3BlbmRpbmcoc3RydWN0 IGRtYV9jaGFuICpjaGFuKQoreworCXN0cnVjdCBtMTB2X2RtYV9jaGFuICptY2hhbiA9IHRvX20x MHZfZG1hX2NoYW4oY2hhbik7CisKKwltMTB2X3hkbWFjX2NvbmZpZ19jaGFuKG1jaGFuKTsKKwor CW0xMHZfeGRtYWNfZW5hYmxlX2NoYW4obWNoYW4pOworfQorCitzdGF0aWMgZG1hX2Nvb2tpZV90 IG0xMHZfeGRtYWNfdHhfc3VibWl0KHN0cnVjdCBkbWFfYXN5bmNfdHhfZGVzY3JpcHRvciAqdHhk KQoreworCXN0cnVjdCBtMTB2X2RtYV9jaGFuICptY2hhbiA9IHRvX20xMHZfZG1hX2NoYW4odHhk LT5jaGFuKTsKKwlkbWFfY29va2llX3QgY29va2llOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisK KwlzcGluX2xvY2tfaXJxc2F2ZSgmbWNoYW4tPmxvY2ssIGZsYWdzKTsKKwljb29raWUgPSBkbWFf Y29va2llX2Fzc2lnbih0eGQpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm1jaGFuLT5sb2Nr LCBmbGFncyk7CisKKwlyZXR1cm4gY29va2llOworfQorCitzdGF0aWMgc3RydWN0IGRtYV9hc3lu Y190eF9kZXNjcmlwdG9yICoKK20xMHZfeGRtYWNfcHJlcF9kbWFfbWVtY3B5KHN0cnVjdCBkbWFf Y2hhbiAqY2hhbiwgZG1hX2FkZHJfdCBkc3QsCisJCQkgICBkbWFfYWRkcl90IHNyYywgc2l6ZV90 IGxlbiwgdW5zaWduZWQgbG9uZyBmbGFncykKK3sKKwlzdHJ1Y3QgbTEwdl9kbWFfY2hhbiAqbWNo YW4gPSB0b19tMTB2X2RtYV9jaGFuKGNoYW4pOworCisJZG1hX2FzeW5jX3R4X2Rlc2NyaXB0b3Jf aW5pdCgmbWNoYW4tPm1kZXNjLnR4ZCwgY2hhbik7CisJbWNoYW4tPm1kZXNjLnR4ZC50eF9zdWJt aXQgPSBtMTB2X3hkbWFjX3R4X3N1Ym1pdDsKKwltY2hhbi0+bWRlc2MudHhkLmNhbGxiYWNrID0g TlVMTDsKKwltY2hhbi0+bWRlc2MudHhkLmZsYWdzID0gZmxhZ3M7CisJbWNoYW4tPm1kZXNjLnR4 ZC5jb29raWUgPSAtRUJVU1k7CisKKwltY2hhbi0+bWRlc2MubGVuID0gbGVuOworCW1jaGFuLT5t ZGVzYy5zcmMgPSBzcmM7CisJbWNoYW4tPm1kZXNjLmRzdCA9IGRzdDsKKworCXJldHVybiAmbWNo YW4tPm1kZXNjLnR4ZDsKK30KKworc3RhdGljIGludCBtMTB2X3hkbWFjX2RldmljZV90ZXJtaW5h dGVfYWxsKHN0cnVjdCBkbWFfY2hhbiAqY2hhbikKK3sKKwlzdHJ1Y3QgbTEwdl9kbWFfY2hhbiAq bWNoYW4gPSB0b19tMTB2X2RtYV9jaGFuKGNoYW4pOworCisJbTEwdl94ZG1hY19kaXNhYmxlX2No YW4obWNoYW4pOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgbTEwdl94ZG1hY19hbGxv Y19jaGFuX3Jlc291cmNlcyhzdHJ1Y3QgZG1hX2NoYW4gKmNoYW4pCit7CisJc3RydWN0IG0xMHZf ZG1hX2NoYW4gKm1jaGFuID0gdG9fbTEwdl9kbWFfY2hhbihjaGFuKTsKKwl1bnNpZ25lZCBsb25n IGZsYWdzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJm1jaGFuLT5sb2NrLCBmbGFncyk7CisJZG1h X2Nvb2tpZV9pbml0KGNoYW4pOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJm1jaGFuLT5sb2Nr LCBmbGFncyk7CisKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIGludCBtMTB2X3hkbWFjX3Byb2Jl KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGRldmljZV9ub2RlICpu cCA9IHBkZXYtPmRldi5vZl9ub2RlOworCXN0cnVjdCBtMTB2X2RtYV9jaGFuICptY2hhbjsKKwlz dHJ1Y3QgbTEwdl9kbWFfZGV2aWNlICptZG1hYzsKKwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKwl1 bnNpZ25lZCBpbnQgY2hhbm5lbHM7CisJaW50IHJldCwgaTsKKworCXJldCA9IGRldmljZV9wcm9w ZXJ0eV9yZWFkX3UzMigmcGRldi0+ZGV2LCAiZG1hLWNoYW5uZWxzIiwgJmNoYW5uZWxzKTsKKwlp ZiAocmV0KSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImdldCBkbWEtY2hhbm5lbHMgZmFpbGVk XG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwltZG1hYyA9IGRldm1fa3phbGxvYygmcGRldi0+ ZGV2LAorCQkJICAgICBzdHJ1Y3Rfc2l6ZShtZG1hYywgbWNoYW4sIGNoYW5uZWxzKSwKKwkJCSAg ICAgR0ZQX0tFUk5FTCk7CisJaWYgKCFtZG1hYykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwltZG1h Yy0+Y2hhbm5lbHMgPSBjaGFubmVsczsKKworCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShw ZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CisJbWRtYWMtPnJlZ3MgPSBkZXZtX2lvcmVtYXBfcmVz b3VyY2UoJnBkZXYtPmRldiwgcmVzKTsKKwlpZiAoSVNfRVJSKG1kbWFjLT5yZWdzKSkKKwkJcmV0 dXJuIFBUUl9FUlIobWRtYWMtPnJlZ3MpOworCisJSU5JVF9MSVNUX0hFQUQoJm1kbWFjLT5kbWFj LmNoYW5uZWxzKTsKKwlmb3IgKGkgPSAwOyBpIDwgbWRtYWMtPmNoYW5uZWxzOyBpKyspIHsKKwkJ bWNoYW4gPSAmbWRtYWMtPm1jaGFuW2ldOworCQltY2hhbi0+aXJxID0gcGxhdGZvcm1fZ2V0X2ly cShwZGV2LCBpKTsKKwkJcmV0ID0gZGV2bV9yZXF1ZXN0X2lycSgmcGRldi0+ZGV2LCBtY2hhbi0+ aXJxLCBtMTB2X3hkbWFjX2lycSwKKwkJCQkgICAgICAgSVJRRl9TSEFSRUQsIGRldl9uYW1lKCZw ZGV2LT5kZXYpLCBtY2hhbik7CisJCWlmIChyZXQpIHsKKwkJCWRldl9lcnIoJnBkZXYtPmRldiwg ImZhaWxlZCB0byByZXF1ZXN0IElSUVxuIik7CisJCQlyZXR1cm4gcmV0OworCQl9CisJCW1jaGFu LT5tZG1hYyA9IG1kbWFjOworCQltY2hhbi0+Y2hhbi5kZXZpY2UgPSAmbWRtYWMtPmRtYWM7CisJ CWxpc3RfYWRkX3RhaWwoJm1jaGFuLT5jaGFuLmRldmljZV9ub2RlLAorCQkJCSZtZG1hYy0+ZG1h Yy5jaGFubmVscyk7CisKKwkJbWNoYW4tPnJlZ3MgPSBNMTBWX1hETUFDX0NIQU5fQkFTRShtZG1h Yy0+cmVncywgaSk7CisJCXNwaW5fbG9ja19pbml0KCZtY2hhbi0+bG9jayk7CisJfQorCisJZG1h X2NhcF9zZXQoRE1BX01FTUNQWSwgbWRtYWMtPmRtYWMuY2FwX21hc2spOworCisJbWRtYWMtPmRt YWMuZGV2aWNlX2FsbG9jX2NoYW5fcmVzb3VyY2VzID0gbTEwdl94ZG1hY19hbGxvY19jaGFuX3Jl c291cmNlczsKKwltZG1hYy0+ZG1hYy5kZXZpY2VfcHJlcF9kbWFfbWVtY3B5ID0gbTEwdl94ZG1h Y19wcmVwX2RtYV9tZW1jcHk7CisJbWRtYWMtPmRtYWMuZGV2aWNlX2lzc3VlX3BlbmRpbmcgPSBt MTB2X3hkbWFjX2lzc3VlX3BlbmRpbmc7CisJbWRtYWMtPmRtYWMuZGV2aWNlX3R4X3N0YXR1cyA9 IGRtYV9jb29raWVfc3RhdHVzOworCW1kbWFjLT5kbWFjLmRldmljZV90ZXJtaW5hdGVfYWxsID0g bTEwdl94ZG1hY19kZXZpY2VfdGVybWluYXRlX2FsbDsKKwltZG1hYy0+ZG1hYy5zcmNfYWRkcl93 aWR0aHMgPSBNMTBWX1hETUFDX0JVU1dJRFRIUzsKKwltZG1hYy0+ZG1hYy5kc3RfYWRkcl93aWR0 aHMgPSBNMTBWX1hETUFDX0JVU1dJRFRIUzsKKwltZG1hYy0+ZG1hYy5yZXNpZHVlX2dyYW51bGFy aXR5ID0gRE1BX1JFU0lEVUVfR1JBTlVMQVJJVFlfREVTQ1JJUFRPUjsKKwltZG1hYy0+ZG1hYy5k ZXYgPSAmcGRldi0+ZGV2OworCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgbWRtYWMpOwor CisJbTEwdl94ZG1hY19lbmFibGVfZG1hKG1kbWFjKTsKKworCXJldCA9IGRtYWVuZ2luZW1fYXN5 bmNfZGV2aWNlX3JlZ2lzdGVyKCZtZG1hYy0+ZG1hYyk7CisJaWYgKHJldCkgeworCQlkZXZfZXJy KCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgZG1hZW5naW5lIGRldmljZVxuIik7CisJ CXJldHVybiByZXQ7CisJfQorCisJcmV0ID0gb2ZfZG1hX2NvbnRyb2xsZXJfcmVnaXN0ZXIobnAs IG9mX2RtYV9zaW1wbGVfeGxhdGUsIG1kbWFjKTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoJnBk ZXYtPmRldiwgImZhaWxlZCB0byByZWdpc3RlciBPRiBETUEgY29udHJvbGxlclxuIik7CisJCXJl dHVybiByZXQ7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgbTEwdl94ZG1hY19y ZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgbTEwdl9kbWFf Y2hhbiAqbWNoYW47CisJc3RydWN0IG0xMHZfZG1hX2RldmljZSAqbWRtYWMgPSBwbGF0Zm9ybV9n ZXRfZHJ2ZGF0YShwZGV2KTsKKwlpbnQgaTsKKworCW0xMHZfeGRtYWNfZGlzYWJsZV9kbWEobWRt YWMpOworCisJZm9yIChpID0gMDsgaSA8IG1kbWFjLT5jaGFubmVsczsgaSsrKSB7CisJCW1jaGFu ID0gJm1kbWFjLT5tY2hhbltpXTsKKwkJZGV2bV9mcmVlX2lycSgmcGRldi0+ZGV2LCBtY2hhbi0+ aXJxLCBtY2hhbik7CisJfQorCisJb2ZfZG1hX2NvbnRyb2xsZXJfZnJlZShwZGV2LT5kZXYub2Zf bm9kZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2Vf aWQgbTEwdl94ZG1hY19kdF9pZHNbXSA9IHsKKwl7LmNvbXBhdGlibGUgPSAic29jaW9uZXh0LG1p bGJlYXV0LW0xMHYteGRtYWMiLH0sCisJe30sCit9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwg bTEwdl94ZG1hY19kdF9pZHMpOworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBtMTB2 X3hkbWFjX2RyaXZlciA9IHsKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJtMTB2LXhkbWFjIiwK KwkJLm9mX21hdGNoX3RhYmxlID0gb2ZfbWF0Y2hfcHRyKG0xMHZfeGRtYWNfZHRfaWRzKSwKKwl9 LAorCS5wcm9iZSA9IG0xMHZfeGRtYWNfcHJvYmUsCisJLnJlbW92ZSA9IG0xMHZfeGRtYWNfcmVt b3ZlLAorfTsKK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIobTEwdl94ZG1hY19kcml2ZXIpOworCitN T0RVTEVfQVVUSE9SKCJLYXp1aGlybyBLYXNhaSA8a2FzYWkua2F6dWhpcm9Ac29jaW9uZXh0LmNv bT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiU29jaW9uZXh0IE1pbGJlYXV0IFhETUFDIGRyaXZl ciIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS, UNWANTED_LANGUAGE_BODY,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1B6A8C4360F for ; Mon, 25 Mar 2019 04:15:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D167120879 for ; Mon, 25 Mar 2019 04:15:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726318AbfCYEPi (ORCPT ); Mon, 25 Mar 2019 00:15:38 -0400 Received: from mx.socionext.com ([202.248.49.38]:53579 "EHLO mx.socionext.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726182AbfCYEPi (ORCPT ); Mon, 25 Mar 2019 00:15:38 -0400 Received: from unknown (HELO kinkan-ex.css.socionext.com) ([172.31.9.52]) by mx.socionext.com with ESMTP; 25 Mar 2019 13:15:36 +0900 Received: from mail.mfilter.local (m-filter-2 [10.213.24.62]) by kinkan-ex.css.socionext.com (Postfix) with ESMTP id 70CD0180085; Mon, 25 Mar 2019 13:15:36 +0900 (JST) Received: from 172.31.9.51 (172.31.9.51) by m-FILTER with ESMTP; Mon, 25 Mar 2019 13:15:36 +0900 Received: from yuzu.css.socionext.com (yuzu [172.31.8.45]) by kinkan.css.socionext.com (Postfix) with ESMTP id 2BBAC1A15B7; Mon, 25 Mar 2019 13:15:36 +0900 (JST) Received: from M20VSDK.e01.socionext.com (unknown [10.213.118.34]) by yuzu.css.socionext.com (Postfix) with ESMTP id 0A64A120487; Mon, 25 Mar 2019 13:15:36 +0900 (JST) From: Kazuhiro Kasai To: vkoul@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com Cc: dmaengine@vger.kernel.org, devicetree@vger.kernel.org, orito.takao@socionext.com, sugaya.taichi@socionext.com, kanematsu.shinji@socionext.com, jaswinder.singh@linaro.org, masami.hiramatsu@linaro.org, linux-kernel@vger.kernel.org, Kazuhiro Kasai Subject: [PATCH 2/2] dmaengine: milbeaut: Add Milbeaut AXI DMA controller Date: Mon, 25 Mar 2019 13:15:14 +0900 Message-Id: <1553487314-9185-3-git-send-email-kasai.kazuhiro@socionext.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1553487314-9185-1-git-send-email-kasai.kazuhiro@socionext.com> References: <1553487314-9185-1-git-send-email-kasai.kazuhiro@socionext.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add Milbeaut AXI DMA controller. This DMA controller has only capable of memory to memory transfer. Signed-off-by: Kazuhiro Kasai --- drivers/dma/Kconfig | 8 + drivers/dma/Makefile | 1 + drivers/dma/xdmac-milbeaut.c | 353 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 362 insertions(+) create mode 100644 drivers/dma/xdmac-milbeaut.c diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig index 0b1dfb5..733fe5f 100644 --- a/drivers/dma/Kconfig +++ b/drivers/dma/Kconfig @@ -612,6 +612,14 @@ config UNIPHIER_MDMAC UniPhier platform. This DMA controller is used as the external DMA engine of the SD/eMMC controllers of the LD4, Pro4, sLD8 SoCs. +config XDMAC_MILBEAUT + tristate "Milbeaut AXI DMA support" + depends on ARCH_MILBEAUT || COMPILE_TEST + select DMA_ENGINE + help + Support for Milbeaut AXI DMA controller driver. The DMA controller + has only memory to memory capability. + config XGENE_DMA tristate "APM X-Gene DMA support" depends on ARCH_XGENE || COMPILE_TEST diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile index 6126e1c..4aab810 100644 --- a/drivers/dma/Makefile +++ b/drivers/dma/Makefile @@ -72,6 +72,7 @@ obj-$(CONFIG_TEGRA20_APB_DMA) += tegra20-apb-dma.o obj-$(CONFIG_TEGRA210_ADMA) += tegra210-adma.o obj-$(CONFIG_TIMB_DMA) += timb_dma.o obj-$(CONFIG_UNIPHIER_MDMAC) += uniphier-mdmac.o +obj-$(CONFIG_XDMAC_MILBEAUT) += xdmac-milbeaut.o obj-$(CONFIG_XGENE_DMA) += xgene-dma.o obj-$(CONFIG_ZX_DMA) += zx_dma.o obj-$(CONFIG_ST_FDMA) += st_fdma.o diff --git a/drivers/dma/xdmac-milbeaut.c b/drivers/dma/xdmac-milbeaut.c new file mode 100644 index 0000000..7035c61 --- /dev/null +++ b/drivers/dma/xdmac-milbeaut.c @@ -0,0 +1,353 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2019 Socionext Inc. + */ + +#include +#include +#include +#include +#include + +#include "dmaengine.h" + +/* global register */ +#define M10V_XDACS 0x00 + +/* channel local register */ +#define M10V_XDTBC 0x10 +#define M10V_XDSSA 0x14 +#define M10V_XDDSA 0x18 +#define M10V_XDSAC 0x1C +#define M10V_XDDAC 0x20 +#define M10V_XDDCC 0x24 +#define M10V_XDDES 0x28 +#define M10V_XDDPC 0x2C +#define M10V_XDDSD 0x30 + +#define M10V_XDACS_XE BIT(28) + +#define M10V_XDSAC_SBS GENMASK(17, 16) +#define M10V_XDSAC_SBL GENMASK(11, 8) + +#define M10V_XDDAC_DBS GENMASK(17, 16) +#define M10V_XDDAC_DBL GENMASK(11, 8) + +#define M10V_XDDES_CE BIT(28) +#define M10V_XDDES_SE BIT(24) +#define M10V_XDDES_SA BIT(15) +#define M10V_XDDES_TF GENMASK(23, 20) +#define M10V_XDDES_EI BIT(1) +#define M10V_XDDES_TI BIT(0) + +#define M10V_XDDSD_IS_MASK GENMASK(3, 0) +#define M10V_XDDSD_IS_NORMAL 0x8 + +#define M10V_XDMAC_BUSWIDTHS (BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) | \ + BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) | \ + BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | \ + BIT(DMA_SLAVE_BUSWIDTH_8_BYTES)) + +#define M10V_XDMAC_CHAN_BASE(base, i) ((base) + (i) * 0x30) + +#define to_m10v_dma_chan(c) container_of((c), struct m10v_dma_chan, chan) + +struct m10v_dma_desc { + struct dma_async_tx_descriptor txd; + size_t len; + dma_addr_t src; + dma_addr_t dst; +}; + +struct m10v_dma_chan { + struct dma_chan chan; + struct m10v_dma_device *mdmac; + void __iomem *regs; + int irq; + struct m10v_dma_desc mdesc; + spinlock_t lock; +}; + +struct m10v_dma_device { + struct dma_device dmac; + void __iomem *regs; + unsigned int channels; + struct m10v_dma_chan mchan[0]; +}; + +static void m10v_xdmac_enable_dma(struct m10v_dma_device *mdmac) +{ + unsigned int val; + + val = readl(mdmac->regs + M10V_XDACS); + val &= ~M10V_XDACS_XE; + val |= FIELD_PREP(M10V_XDACS_XE, 1); + writel(val, mdmac->regs + M10V_XDACS); +} + +static void m10v_xdmac_disable_dma(struct m10v_dma_device *mdmac) +{ + unsigned int val; + + val = readl(mdmac->regs + M10V_XDACS); + val &= ~M10V_XDACS_XE; + val |= FIELD_PREP(M10V_XDACS_XE, 0); + writel(val, mdmac->regs + M10V_XDACS); +} + +static void m10v_xdmac_config_chan(struct m10v_dma_chan *mchan) +{ + u32 val; + + val = mchan->mdesc.len - 1; + writel(val, mchan->regs + M10V_XDTBC); + + val = mchan->mdesc.src; + writel(val, mchan->regs + M10V_XDSSA); + + val = mchan->mdesc.dst; + writel(val, mchan->regs + M10V_XDDSA); + + val = readl(mchan->regs + M10V_XDSAC); + val &= ~(M10V_XDSAC_SBS | M10V_XDSAC_SBL); + val |= FIELD_PREP(M10V_XDSAC_SBS, 0x3) | + FIELD_PREP(M10V_XDSAC_SBL, 0xf); + writel(val, mchan->regs + M10V_XDSAC); + + val = readl(mchan->regs + M10V_XDDAC); + val &= ~(M10V_XDDAC_DBS | M10V_XDDAC_DBL); + val |= FIELD_PREP(M10V_XDDAC_DBS, 0x3) | + FIELD_PREP(M10V_XDDAC_DBL, 0xf); + writel(val, mchan->regs + M10V_XDDAC); +} + +static void m10v_xdmac_enable_chan(struct m10v_dma_chan *mchan) +{ + u32 val; + + val = readl(mchan->regs + M10V_XDDES); + val &= ~(M10V_XDDES_CE | + M10V_XDDES_SE | + M10V_XDDES_TF | + M10V_XDDES_EI | + M10V_XDDES_TI); + val |= FIELD_PREP(M10V_XDDES_CE, 1) | + FIELD_PREP(M10V_XDDES_SE, 1) | + FIELD_PREP(M10V_XDDES_TF, 1) | + FIELD_PREP(M10V_XDDES_EI, 1) | + FIELD_PREP(M10V_XDDES_TI, 1); + writel(val, mchan->regs + M10V_XDDES); +} + +static void m10v_xdmac_disable_chan(struct m10v_dma_chan *mchan) +{ + u32 val; + + val = readl(mchan->regs + M10V_XDDES); + val &= ~M10V_XDDES_CE; + val |= FIELD_PREP(M10V_XDDES_CE, 0); + writel(val, mchan->regs + M10V_XDDES); +} + +static irqreturn_t m10v_xdmac_irq(int irq, void *data) +{ + struct m10v_dma_chan *mchan = data; + unsigned long flags; + u32 val; + + val = readl(mchan->regs + M10V_XDDSD); + val = FIELD_GET(M10V_XDDSD_IS_MASK, val); + + if (val != M10V_XDDSD_IS_NORMAL) + dev_err(mchan->chan.device->dev, "XDMAC error with status: %x", val); + + val = FIELD_PREP(M10V_XDDSD_IS_MASK, 0x0); + writel(val, mchan->regs + M10V_XDDSD); + + spin_lock_irqsave(&mchan->lock, flags); + dma_cookie_complete(&mchan->mdesc.txd); + spin_unlock_irqrestore(&mchan->lock, flags); + + if (mchan->mdesc.txd.flags & DMA_PREP_INTERRUPT) + dmaengine_desc_get_callback_invoke(&mchan->mdesc.txd, NULL); + + return IRQ_HANDLED; +} + +static void m10v_xdmac_issue_pending(struct dma_chan *chan) +{ + struct m10v_dma_chan *mchan = to_m10v_dma_chan(chan); + + m10v_xdmac_config_chan(mchan); + + m10v_xdmac_enable_chan(mchan); +} + +static dma_cookie_t m10v_xdmac_tx_submit(struct dma_async_tx_descriptor *txd) +{ + struct m10v_dma_chan *mchan = to_m10v_dma_chan(txd->chan); + dma_cookie_t cookie; + unsigned long flags; + + spin_lock_irqsave(&mchan->lock, flags); + cookie = dma_cookie_assign(txd); + spin_unlock_irqrestore(&mchan->lock, flags); + + return cookie; +} + +static struct dma_async_tx_descriptor * +m10v_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst, + dma_addr_t src, size_t len, unsigned long flags) +{ + struct m10v_dma_chan *mchan = to_m10v_dma_chan(chan); + + dma_async_tx_descriptor_init(&mchan->mdesc.txd, chan); + mchan->mdesc.txd.tx_submit = m10v_xdmac_tx_submit; + mchan->mdesc.txd.callback = NULL; + mchan->mdesc.txd.flags = flags; + mchan->mdesc.txd.cookie = -EBUSY; + + mchan->mdesc.len = len; + mchan->mdesc.src = src; + mchan->mdesc.dst = dst; + + return &mchan->mdesc.txd; +} + +static int m10v_xdmac_device_terminate_all(struct dma_chan *chan) +{ + struct m10v_dma_chan *mchan = to_m10v_dma_chan(chan); + + m10v_xdmac_disable_chan(mchan); + + return 0; +} + +static int m10v_xdmac_alloc_chan_resources(struct dma_chan *chan) +{ + struct m10v_dma_chan *mchan = to_m10v_dma_chan(chan); + unsigned long flags; + + spin_lock_irqsave(&mchan->lock, flags); + dma_cookie_init(chan); + spin_unlock_irqrestore(&mchan->lock, flags); + + return 1; +} + +static int m10v_xdmac_probe(struct platform_device *pdev) +{ + struct device_node *np = pdev->dev.of_node; + struct m10v_dma_chan *mchan; + struct m10v_dma_device *mdmac; + struct resource *res; + unsigned int channels; + int ret, i; + + ret = device_property_read_u32(&pdev->dev, "dma-channels", &channels); + if (ret) { + dev_err(&pdev->dev, "get dma-channels failed\n"); + return ret; + } + + mdmac = devm_kzalloc(&pdev->dev, + struct_size(mdmac, mchan, channels), + GFP_KERNEL); + if (!mdmac) + return -ENOMEM; + + mdmac->channels = channels; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + mdmac->regs = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(mdmac->regs)) + return PTR_ERR(mdmac->regs); + + INIT_LIST_HEAD(&mdmac->dmac.channels); + for (i = 0; i < mdmac->channels; i++) { + mchan = &mdmac->mchan[i]; + mchan->irq = platform_get_irq(pdev, i); + ret = devm_request_irq(&pdev->dev, mchan->irq, m10v_xdmac_irq, + IRQF_SHARED, dev_name(&pdev->dev), mchan); + if (ret) { + dev_err(&pdev->dev, "failed to request IRQ\n"); + return ret; + } + mchan->mdmac = mdmac; + mchan->chan.device = &mdmac->dmac; + list_add_tail(&mchan->chan.device_node, + &mdmac->dmac.channels); + + mchan->regs = M10V_XDMAC_CHAN_BASE(mdmac->regs, i); + spin_lock_init(&mchan->lock); + } + + dma_cap_set(DMA_MEMCPY, mdmac->dmac.cap_mask); + + mdmac->dmac.device_alloc_chan_resources = m10v_xdmac_alloc_chan_resources; + mdmac->dmac.device_prep_dma_memcpy = m10v_xdmac_prep_dma_memcpy; + mdmac->dmac.device_issue_pending = m10v_xdmac_issue_pending; + mdmac->dmac.device_tx_status = dma_cookie_status; + mdmac->dmac.device_terminate_all = m10v_xdmac_device_terminate_all; + mdmac->dmac.src_addr_widths = M10V_XDMAC_BUSWIDTHS; + mdmac->dmac.dst_addr_widths = M10V_XDMAC_BUSWIDTHS; + mdmac->dmac.residue_granularity = DMA_RESIDUE_GRANULARITY_DESCRIPTOR; + mdmac->dmac.dev = &pdev->dev; + + platform_set_drvdata(pdev, mdmac); + + m10v_xdmac_enable_dma(mdmac); + + ret = dmaenginem_async_device_register(&mdmac->dmac); + if (ret) { + dev_err(&pdev->dev, "failed to register dmaengine device\n"); + return ret; + } + + ret = of_dma_controller_register(np, of_dma_simple_xlate, mdmac); + if (ret) { + dev_err(&pdev->dev, "failed to register OF DMA controller\n"); + return ret; + } + + return 0; +} + +static int m10v_xdmac_remove(struct platform_device *pdev) +{ + struct m10v_dma_chan *mchan; + struct m10v_dma_device *mdmac = platform_get_drvdata(pdev); + int i; + + m10v_xdmac_disable_dma(mdmac); + + for (i = 0; i < mdmac->channels; i++) { + mchan = &mdmac->mchan[i]; + devm_free_irq(&pdev->dev, mchan->irq, mchan); + } + + of_dma_controller_free(pdev->dev.of_node); + + return 0; +} + +static const struct of_device_id m10v_xdmac_dt_ids[] = { + {.compatible = "socionext,milbeaut-m10v-xdmac",}, + {}, +}; +MODULE_DEVICE_TABLE(of, m10v_xdmac_dt_ids); + +static struct platform_driver m10v_xdmac_driver = { + .driver = { + .name = "m10v-xdmac", + .of_match_table = of_match_ptr(m10v_xdmac_dt_ids), + }, + .probe = m10v_xdmac_probe, + .remove = m10v_xdmac_remove, +}; +module_platform_driver(m10v_xdmac_driver); + +MODULE_AUTHOR("Kazuhiro Kasai "); +MODULE_DESCRIPTION("Socionext Milbeaut XDMAC driver"); +MODULE_LICENSE("GPL v2"); -- 1.9.1