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: [RFC,v3,1/7] dmaengine: Add Synopsys eDMA IP core driver From: Vinod Koul Message-Id: <20190120114425.GV4635@vkoul-mobl> Date: Sun, 20 Jan 2019 17:14:25 +0530 To: Gustavo Pimentel Cc: linux-pci@vger.kernel.org, dmaengine@vger.kernel.org, Dan Williams , Eugeniy Paltsev , Andy Shevchenko , Russell King , Niklas Cassel , Joao Pinto , Jose Abreu , Luis Oliveira , Vitor Soares , Nelson Costa , Pedro Sousa List-ID: T24gMTEtMDEtMTksIDE5OjMzLCBHdXN0YXZvIFBpbWVudGVsIHdyb3RlOgo+IEFkZCBTeW5vcHN5 cyBlRE1BIElQIGNvcmUgZHJpdmVyIHRvIGtlcm5lbC4KPiAKPiBUaGlzIGNvcmUgZHJpdmVyLCBp bml0aWFsaXplcyBhbmQgY29uZmlndXJlcyB0aGUgZURNQSBJUCB1c2luZyB2bWEtaGVscGVycwo+ IGZ1bmN0aW9ucyBhbmQgZG1hLWVuZ2luZSBzdWJzeXN0ZW0uCgpBIGRlc2NyaXB0aW9uIG9mIGVE TUEgSVAgd2lsbCBoZWxwIHJldmlldyB0aGUgZHJpdmVyCgo+IEFsc28gY3JlYXRlcyBhbiBhYnN0 cmF0aW9uIGxheWVyIHRocm91Z2ggY2FsbGJhY2tzIGFsbG93aW5nIGRpZmZlcmVudAo+IHJlZ2lz dGVycyBtYXBwaW5ncyBpbiB0aGUgZnV0dXJlLCBvcmdhbml6ZWQgaW4gdG8gdmVyc2lvbnMuCj4g Cj4gVGhpcyBkcml2ZXIgY2FuIGJlIGNvbXBpbGUgYXMgYnVpbHQtaW4gb3IgZXh0ZXJuYWwgbW9k dWxlIGluIGtlcm5lbC4KPiAKPiBUbyBlbmFibGUgdGhpcyBkcml2ZXIganVzdCBzZWxlY3QgRFdf RURNQSBvcHRpb24gaW4ga2VybmVsIGNvbmZpZ3VyYXRpb24sCj4gaG93ZXZlciBpdCByZXF1aXJl cyBhbmQgc2VsZWN0cyBhdXRvbWF0aWNhbGx5IERNQV9FTkdJTkUgYW5kCj4gRE1BX1ZJUlRVQUxf Q0hBTk5FTFMgb3B0aW9uIHRvby4KPiAKPiBDaGFuZ2VzOgo+IFJGQyB2MS0+UkZDIHYyOgoKVGhl c2UgZG8gbm90IGJlbG9uZyB0byBjaGFuZ2UgbG9nLCBlaXRoZXIgbW92ZSB0aGVtIHRvIGNvdmVy LWxldHRlciBvcgprZWVwIHRoZW0gYWZ0ZXIgcy1vLWIgbGluZXMuLgoKPiBAQCAtMCwwICsxLDEw NTkgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICog Q29weXJpZ2h0IChjKSAyMDE4IFN5bm9wc3lzLCBJbmMuIGFuZC9vciBpdHMgYWZmaWxpYXRlcy4K CjIwMTkgbm93Cgo+ICtzdGF0aWMgc3RydWN0IGR3X2VkbWFfYnVyc3QgKmR3X2VkbWFfYWxsb2Nf YnVyc3Qoc3RydWN0IGR3X2VkbWFfY2h1bmsgKmNodW5rKQo+ICt7Cj4gKwlzdHJ1Y3QgZHdfZWRt YV9jaGFuICpjaGFuID0gY2h1bmstPmNoYW47Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9idXJzdCAqYnVy c3Q7Cj4gKwo+ICsJYnVyc3QgPSBrdnphbGxvYyhzaXplb2YoKmJ1cnN0KSwgR0ZQX05PV0FJVCk7 CgpJcyB0aGVyZSBhIHNwZWNpZmljIHJlYXNvbiBmb3Iga3Z6YWxsb2MoKSwgIGRvIHlvdSBzdWJt aXQgdGhpcyB0byBIVy4uCgo+ICtzdGF0aWMgc3RydWN0IGR3X2VkbWFfY2h1bmsgKmR3X2VkbWFf YWxsb2NfY2h1bmsoc3RydWN0IGR3X2VkbWFfZGVzYyAqZGVzYykKPiArewo+ICsJc3RydWN0IGR3 X2VkbWFfY2hhbiAqY2hhbiA9IGRlc2MtPmNoYW47Cj4gKwlzdHJ1Y3QgZHdfZWRtYSAqZHcgPSBj aGFuLT5jaGlwLT5kdzsKPiArCXN0cnVjdCBkd19lZG1hX2NodW5rICpjaHVuazsKPiArCj4gKwlj aHVuayA9IGt2emFsbG9jKHNpemVvZigqY2h1bmspLCBHRlBfTk9XQUlUKTsKPiArCWlmICh1bmxp a2VseSghY2h1bmspKQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCUlOSVRfTElTVF9IRUFEKCZj aHVuay0+bGlzdCk7Cj4gKwljaHVuay0+Y2hhbiA9IGNoYW47Cj4gKwljaHVuay0+Y2IgPSAhKGRl c2MtPmNodW5rc19hbGxvYyAlIDIpOwoKY2IgLi4/Cgo+ICtzdGF0aWMgaW50IGR3X2VkbWFfZGV2 aWNlX2NvbmZpZyhzdHJ1Y3QgZG1hX2NoYW4gKmRjaGFuLAo+ICsJCQkJIHN0cnVjdCBkbWFfc2xh dmVfY29uZmlnICpjb25maWcpCj4gK3sKPiArCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4gPSBk Y2hhbjJkd19lZG1hX2NoYW4oZGNoYW4pOwo+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9v cHMgKm9wcyA9IGNoYW4yb3BzKGNoYW4pOwo+ICsJdW5zaWduZWQgbG9uZyBmbGFnczsKPiArCWlu dCBlcnIgPSAwOwo+ICsKPiArCXNwaW5fbG9ja19pcnFzYXZlKCZjaGFuLT52Yy5sb2NrLCBmbGFn cyk7Cj4gKwo+ICsJaWYgKCFjb25maWcpIHsKPiArCQllcnIgPSAtRUlOVkFMOwo+ICsJCWdvdG8g ZXJyX2NvbmZpZzsKPiArCX0KPiArCj4gKwlpZiAoY2hhbi0+c3RhdHVzICE9IEVETUFfU1RfSURM RSkgewo+ICsJCWRldl9lcnIoY2hhbjJkZXYoY2hhbiksICJjaGFubmVsIGlzIGJ1c3kgb3IgcGF1 c2VkXG4iKTsKPiArCQllcnIgPSAtRVBFUk07Cgp0aGlzIGlzIG5vdCBjb3JyZWN0IGJlaGF2aW91 ciwgZGV2aWNlX2NvbmZpZyBjYW4gYmUgY2FsbGVkIGFueXRpbWUgYW5kCnZhbHVlcyBjYW4gdGFr ZSBhZmZlY3Qgb24gbmV4dCB0cmFuc2FjdGlvbiBzdWJtaXR0ZWQuLgoKPiArCQlnb3RvIGVycl9j b25maWc7Cj4gKwl9Cj4gKwo+ICsJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwgImFkZHIocGh5c2lj YWwpIHNyYz0lcGEsIGRzdD0lcGFcbiIsCj4gKwkJJmNvbmZpZy0+c3JjX2FkZHIsICZjb25maWct PmRzdF9hZGRyKTsKPiArCj4gKwljaGFuLT5zcmNfYWRkciA9IGNvbmZpZy0+c3JjX2FkZHI7Cj4g KwljaGFuLT5kc3RfYWRkciA9IGNvbmZpZy0+ZHN0X2FkZHI7Cj4gKwo+ICsJZXJyID0gb3BzLT5k ZXZpY2VfY29uZmlnKGRjaGFuKTsKCndoYXQgZG9lcyB0aGlzIGRvPwoKPiArc3RhdGljIGVudW0g ZG1hX3N0YXR1cwo+ICtkd19lZG1hX2RldmljZV90eF9zdGF0dXMoc3RydWN0IGRtYV9jaGFuICpk Y2hhbiwgZG1hX2Nvb2tpZV90IGNvb2tpZSwKPiArCQkJIHN0cnVjdCBkbWFfdHhfc3RhdGUgKnR4 c3RhdGUpCj4gK3sKPiArCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4gPSBkY2hhbjJkd19lZG1h X2NoYW4oZGNoYW4pOwo+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9vcHMgKm9wcyA9IGNo YW4yb3BzKGNoYW4pOwo+ICsJdW5zaWduZWQgbG9uZyBmbGFnczsKPiArCWVudW0gZG1hX3N0YXR1 cyByZXQ7Cj4gKwo+ICsJc3Bpbl9sb2NrX2lycXNhdmUoJmNoYW4tPnZjLmxvY2ssIGZsYWdzKTsK PiArCj4gKwlyZXQgPSBvcHMtPmNoX3N0YXR1cyhjaGFuKTsKPiArCWlmIChyZXQgPT0gRE1BX0VS Uk9SKSB7Cj4gKwkJZ290byByZXRfc3RhdHVzOwo+ICsJfSBlbHNlIGlmIChyZXQgPT0gRE1BX0lO X1BST0dSRVNTKSB7Cj4gKwkJY2hhbi0+c3RhdHVzID0gRURNQV9TVF9CVVNZOwo+ICsJCWdvdG8g cmV0X3N0YXR1czsKCnNvIGluIHRoaXMgY2FzZSB5b3Ugc2V0IHJlc2lkdWUgYXMgemVybywgd2hp Y2ggaXMgbm90IGNvcnJlY3QKCj4gKwl9IGVsc2Ugewo+ICsJCS8qIERNQV9DT01QTEVURSAqLwo+ ICsJCWlmIChjaGFuLT5zdGF0dXMgPT0gRURNQV9TVF9QQVVTRSkKPiArCQkJcmV0ID0gRE1BX1BB VVNFRDsKPiArCQllbHNlIGlmIChjaGFuLT5zdGF0dXMgPT0gRURNQV9TVF9CVVNZKQo+ICsJCQly ZXQgPSBETUFfSU5fUFJPR1JFU1M7Cgo/PyBpZiB0eG4gaXMgY29tcGxldGUgaG93IGFyZSB5b3Ug cmV0dXJuaW5nIERNQV9JTl9QUk9HUkVTUz8KCj4gKwkJZWxzZQo+ICsJCQlyZXQgPSBETUFfQ09N UExFVEU7Cj4gKwl9Cgp0aGlzIGxvb2tzIGluY29ycmVjdCBpbnRlcnByZXRhdGlvbiB0byBtZS4g VGhlIHN0YXR1cyBpcyB0byBiZSByZXRyaWV2ZWQKZm9yIHRoZSBnaXZlbiBjb29raWUgcGFzc2Vk IGFuZCBnaXZlbiB0aGF0IHlvdSBkbyBub3QgZXZlbiB1c2UgdGhpcwphcmd1bWVudCB0ZWxscyBt ZSB0aGF0IHlvdSBoYXZlIHVuZGVyc3Rvb2QgdGhpcyBhcyAnY2hhbm5lbCcgc3RhdHVzCnJlcG9y dGluZywgd2hpY2ggaXMgbm90IGNvcnJlY3QKCj4gK3N0YXRpYyBzdHJ1Y3QgZG1hX2FzeW5jX3R4 X2Rlc2NyaXB0b3IgKgo+ICtkd19lZG1hX2RldmljZV9wcmVwX3NsYXZlX3NnKHN0cnVjdCBkbWFf Y2hhbiAqZGNoYW4sIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dsLAo+ICsJCQkgICAgIHVuc2lnbmVk IGludCBzZ19sZW4sCj4gKwkJCSAgICAgZW51bSBkbWFfdHJhbnNmZXJfZGlyZWN0aW9uIGRpcmVj dGlvbiwKPiArCQkJICAgICB1bnNpZ25lZCBsb25nIGZsYWdzLCB2b2lkICpjb250ZXh0KQo+ICt7 Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuID0gZGNoYW4yZHdfZWRtYV9jaGFuKGRjaGFu KTsKPiArCXN0cnVjdCBkd19lZG1hX2Rlc2MgKmRlc2M7Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaHVu ayAqY2h1bms7Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9idXJzdCAqYnVyc3Q7Cj4gKwlzdHJ1Y3Qgc2Nh dHRlcmxpc3QgKnNnOwo+ICsJdW5zaWduZWQgbG9uZyBzZmxhZ3M7Cj4gKwlwaHlzX2FkZHJfdCBz cmNfYWRkcjsKPiArCXBoeXNfYWRkcl90IGRzdF9hZGRyOwo+ICsJaW50IGk7Cj4gKwo+ICsJaWYg KHNnX2xlbiA8IDEpIHsKPiArCQlkZXZfZXJyKGNoYW4yZGV2KGNoYW4pLCAiaW52YWxpZCBzZyBs ZW5ndGggJXVcbiIsIHNnX2xlbik7Cj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwl9Cj4gKwo+ICsJaWYg KGRpcmVjdGlvbiA9PSBETUFfREVWX1RPX01FTSAmJiBjaGFuLT5kaXIgPT0gRURNQV9ESVJfV1JJ VEUpIHsKCndoYXQgaXMgdGhlIHNlY29uZCBwYXJ0IG9mIHRoZSBjaGVjaywgY2FuIHlvdSBleHBs YWluIHRoYXQsIHdobyBzZXRzCmNoYW4tPmRpcj8KCj4gKwkJZGV2X2RiZyhjaGFuMmRldihjaGFu KSwJInByZXBhcmUgb3BlcmF0aW9uIChXUklURSlcbiIpOwo+ICsJfSBlbHNlIGlmIChkaXJlY3Rp b24gPT0gRE1BX01FTV9UT19ERVYgJiYgY2hhbi0+ZGlyID09IEVETUFfRElSX1JFQUQpIHsKPiAr CQlkZXZfZGJnKGNoYW4yZGV2KGNoYW4pLAkicHJlcGFyZSBvcGVyYXRpb24gKFJFQUQpXG4iKTsK PiArCX0gZWxzZSB7Cj4gKwkJZGV2X2VycihjaGFuMmRldihjaGFuKSwgImludmFsaWQgZGlyZWN0 aW9uXG4iKTsKPiArCQlyZXR1cm4gTlVMTDsKPiArCX0KPiArCj4gKwlpZiAoIWNoYW4tPmNvbmZp Z3VyZWQpIHsKPiArCQlkZXZfZXJyKGNoYW4yZGV2KGNoYW4pLCAiKHByZXBfc2xhdmVfc2cpIGNo YW5uZWwgbm90IGNvbmZpZ3VyZWRcbiIpOwo+ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsKPiAr CWlmIChjaGFuLT5zdGF0dXMgIT0gRURNQV9TVF9JRExFKSB7Cj4gKwkJZGV2X2VycihjaGFuMmRl dihjaGFuKSwgImNoYW5uZWwgaXMgYnVzeSBvciBwYXVzZWRcbiIpOwo+ICsJCXJldHVybiBOVUxM Owo+ICsJfQoKTm8sIHdyb25nIGFnYWluLiBUaGUgdHhuIG11c3QgYmUgcHJlcGFyZWQgYW5kIHRo ZW4gb24gc3VibWl0IGFkZGVkIHRvIGEKcXVldWUuIFlvdSBhcmUgd3JpdGluZyBhIGRyaXZlciBm b3IgZG1hZW5naW5lLCBzdXJlbHkgeW91IGRvbnQgZXhwZWN0CnRoZSBjaGFubmVsIHRvIGJlIGZy ZWUgYW5kIHRoZW4gZG8gYSB0eG4uLiB0aGF0IHdvdWxkIGJlIHZlcnkKaW5lZmZpY2llbnQhCgo+ ICtzdGF0aWMgc3RydWN0IGRtYV9hc3luY190eF9kZXNjcmlwdG9yICoKPiArZHdfZWRtYV9kZXZp Y2VfcHJlcF9kbWFfY3ljbGljKHN0cnVjdCBkbWFfY2hhbiAqZGNoYW4sIGRtYV9hZGRyX3QgYnVm X2FkZHIsCj4gKwkJCSAgICAgICBzaXplX3QgbGVuLCBzaXplX3QgY3ljbGljX2NudCwKPiArCQkJ ICAgICAgIGVudW0gZG1hX3RyYW5zZmVyX2RpcmVjdGlvbiBkaXJlY3Rpb24sCj4gKwkJCSAgICAg ICB1bnNpZ25lZCBsb25nIGZsYWdzKQo+ICt7Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFu ID0gZGNoYW4yZHdfZWRtYV9jaGFuKGRjaGFuKTsKPiArCXN0cnVjdCBkd19lZG1hX2Rlc2MgKmRl c2M7Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaHVuayAqY2h1bms7Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9i dXJzdCAqYnVyc3Q7Cj4gKwl1bnNpZ25lZCBsb25nIHNmbGFnczsKPiArCXBoeXNfYWRkcl90IHNy Y19hZGRyOwo+ICsJcGh5c19hZGRyX3QgZHN0X2FkZHI7Cj4gKwl1MzIgaTsKPiArCj4gKwlpZiAo IWxlbiB8fCAhY3ljbGljX2NudCkgewo+ICsJCWRldl9lcnIoY2hhbjJkZXYoY2hhbiksICJpbnZh bGlkIGxlbiBvciBjeWNsaWMgY291bnRcbiIpOwo+ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsK PiArCWlmIChkaXJlY3Rpb24gPT0gRE1BX0RFVl9UT19NRU0gJiYgY2hhbi0+ZGlyID09IEVETUFf RElSX1dSSVRFKSB7Cj4gKwkJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwJInByZXBhcmUgb3BlcmF0 aW9uIChXUklURSlcbiIpOwo+ICsJfSBlbHNlIGlmIChkaXJlY3Rpb24gPT0gRE1BX01FTV9UT19E RVYgJiYgY2hhbi0+ZGlyID09IEVETUFfRElSX1JFQUQpIHsKPiArCQlkZXZfZGJnKGNoYW4yZGV2 KGNoYW4pLAkicHJlcGFyZSBvcGVyYXRpb24gKFJFQUQpXG4iKTsKPiArCX0gZWxzZSB7Cj4gKwkJ ZGV2X2VycihjaGFuMmRldihjaGFuKSwgImludmFsaWQgZGlyZWN0aW9uXG4iKTsKPiArCQlyZXR1 cm4gTlVMTDsKPiArCX0KPiArCj4gKwlpZiAoIWNoYW4tPmNvbmZpZ3VyZWQpIHsKPiArCQlkZXZf ZXJyKGNoYW4yZGV2KGNoYW4pLCAiKHByZXBfZG1hX2N5Y2xpYykgY2hhbm5lbCBub3QgY29uZmln dXJlZFxuIik7Cj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwl9Cj4gKwo+ICsJaWYgKGNoYW4tPnN0YXR1 cyAhPSBFRE1BX1NUX0lETEUpIHsKPiArCQlkZXZfZXJyKGNoYW4yZGV2KGNoYW4pLCAiY2hhbm5l bCBpcyBidXN5IG9yIHBhdXNlZFxuIik7Cj4gKwkJcmV0dXJuIE5VTEw7Cj4gKwl9Cj4gKwo+ICsJ c3Bpbl9sb2NrX2lycXNhdmUoJmNoYW4tPnZjLmxvY2ssIHNmbGFncyk7Cj4gKwo+ICsJZGVzYyA9 IGR3X2VkbWFfYWxsb2NfZGVzYyhjaGFuKTsKPiArCWlmICh1bmxpa2VseSghZGVzYykpCj4gKwkJ Z290byBlcnJfYWxsb2M7Cj4gKwo+ICsJY2h1bmsgPSBkd19lZG1hX2FsbG9jX2NodW5rKGRlc2Mp Owo+ICsJaWYgKHVubGlrZWx5KCFjaHVuaykpCj4gKwkJZ290byBlcnJfYWxsb2M7Cj4gKwo+ICsJ c3JjX2FkZHIgPSBjaGFuLT5zcmNfYWRkcjsKPiArCWRzdF9hZGRyID0gY2hhbi0+ZHN0X2FkZHI7 Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGN5Y2xpY19jbnQ7IGkrKykgewo+ICsJCWlmIChjaHVu ay0+YnVyc3RzX2FsbG9jID09IGNoYW4tPmxsX21heCkgewo+ICsJCQljaHVuayA9IGR3X2VkbWFf YWxsb2NfY2h1bmsoZGVzYyk7Cj4gKwkJCWlmICh1bmxpa2VseSghY2h1bmspKQo+ICsJCQkJZ290 byBlcnJfYWxsb2M7Cj4gKwkJfQo+ICsKPiArCQlidXJzdCA9IGR3X2VkbWFfYWxsb2NfYnVyc3Qo Y2h1bmspOwo+ICsKPiArCQlpZiAodW5saWtlbHkoIWJ1cnN0KSkKPiArCQkJZ290byBlcnJfYWxs b2M7Cj4gKwo+ICsJCWJ1cnN0LT5zeiA9IGxlbjsKPiArCQljaHVuay0+bGxfcmVnaW9uLnN6ICs9 IGJ1cnN0LT5zejsKPiArCQlkZXNjLT5hbGxvY19zeiArPSBidXJzdC0+c3o7Cj4gKwo+ICsJCWJ1 cnN0LT5zYXIgPSBzcmNfYWRkcjsKPiArCQlidXJzdC0+ZGFyID0gZHN0X2FkZHI7Cj4gKwo+ICsJ CWRldl9kYmcoY2hhbjJkZXYoY2hhbiksICJsbGkgJXUvJXUsIHNhcj0weCUuOGxseCwgZGFyPTB4 JS44bGx4LCBzaXplPSV1IGJ5dGVzXG4iLAo+ICsJCQlpICsgMSwgY3ljbGljX2NudCwgYnVyc3Qt PnNhciwgYnVyc3QtPmRhciwgYnVyc3QtPnN6KTsKPiArCX0KPiArCj4gKwlzcGluX3VubG9ja19p cnFyZXN0b3JlKCZjaGFuLT52Yy5sb2NrLCBzZmxhZ3MpOwo+ICsJcmV0dXJuIHZjaGFuX3R4X3By ZXAoJmNoYW4tPnZjLCAmZGVzYy0+dmQsIGZsYWdzKTsKCmhvdyBpcyBpdCBkaWZmZXJlbnQgZnJv bSBwcmV2aW91cz8gYW0gc3VyZSB3ZSBjYW4gcmV1c2UgYml0cyEKCj4gK3N0YXRpYyB2b2lkIGR3 X2VkbWFfZG9uZV9pbnRlcnJ1cHQoc3RydWN0IGR3X2VkbWFfY2hhbiAqY2hhbikKPiArewo+ICsJ c3RydWN0IGR3X2VkbWEgKmR3ID0gY2hhbi0+Y2hpcC0+ZHc7Cj4gKwljb25zdCBzdHJ1Y3QgZHdf ZWRtYV9jb3JlX29wcyAqb3BzID0gZHctPm9wczsKPiArCXN0cnVjdCB2aXJ0X2RtYV9kZXNjICp2 ZDsKPiArCXN0cnVjdCBkd19lZG1hX2Rlc2MgKmRlc2M7Cj4gKwl1bnNpZ25lZCBsb25nIGZsYWdz Owo+ICsKPiArCW9wcy0+Y2xlYXJfZG9uZV9pbnQoY2hhbik7Cj4gKwlkZXZfZGJnKGNoYW4yZGV2 KGNoYW4pLCAiY2xlYXIgZG9uZSBpbnRlcnJ1cHRcbiIpOwo+ICsKPiArCXNwaW5fbG9ja19pcnFz YXZlKCZjaGFuLT52Yy5sb2NrLCBmbGFncyk7Cj4gKwl2ZCA9IHZjaGFuX25leHRfZGVzYygmY2hh bi0+dmMpOwo+ICsJc3dpdGNoIChjaGFuLT5yZXF1ZXN0KSB7Cj4gKwljYXNlIEVETUFfUkVRX05P TkU6Cj4gKwkJaWYgKCF2ZCkKPiArCQkJYnJlYWs7Cj4gKwo+ICsJCWRlc2MgPSB2ZDJkd19lZG1h X2Rlc2ModmQpOwo+ICsJCWlmIChkZXNjLT5jaHVua3NfYWxsb2MpIHsKPiArCQkJZGV2X2RiZyhj aGFuMmRldihjaGFuKSwgInN1Yi10cmFuc2ZlciBjb21wbGV0ZVxuIik7Cj4gKwkJCWNoYW4tPnN0 YXR1cyA9IEVETUFfU1RfQlVTWTsKPiArCQkJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwgInRyYW5z ZmVycmVkICV1IGJ5dGVzXG4iLAo+ICsJCQkJZGVzYy0+eGZlcl9zeik7Cj4gKwkJCWR3X2VkbWFf c3RhcnRfdHJhbnNmZXIoY2hhbik7Cj4gKwkJfSBlbHNlIHsKPiArCQkJbGlzdF9kZWwoJnZkLT5u b2RlKTsKPiArCQkJdmNoYW5fY29va2llX2NvbXBsZXRlKHZkKTsKPiArCQkJY2hhbi0+c3RhdHVz ID0gRURNQV9TVF9JRExFOwo+ICsJCQlkZXZfZGJnKGNoYW4yZGV2KGNoYW4pLCAidHJhbnNmZXIg Y29tcGxldGVcbiIpOwo+ICsJCX0KPiArCQlicmVhazsKPiArCWNhc2UgRURNQV9SRVFfU1RPUDoK PiArCQlpZiAoIXZkKQo+ICsJCQlicmVhazsKPiArCj4gKwkJbGlzdF9kZWwoJnZkLT5ub2RlKTsK PiArCQl2Y2hhbl9jb29raWVfY29tcGxldGUodmQpOwo+ICsJCWNoYW4tPnJlcXVlc3QgPSBFRE1B X1JFUV9OT05FOwo+ICsJCWNoYW4tPnN0YXR1cyA9IEVETUFfU1RfSURMRTsKPiArCQljaGFuLT5j b25maWd1cmVkID0gZmFsc2U7Cgp3aHkgaXMgY29uZmlndXJhdGlvbiBkZWVtZWQgaW52YWxpZCwg aXQgY2FuIHN0aWxsIGJlIHVzZWQgYWdhaW4hCgo+ICtpbnQgZHdfZWRtYV9wcm9iZShzdHJ1Y3Qg ZHdfZWRtYV9jaGlwICpjaGlwKQo+ICt7Cj4gKwlzdHJ1Y3QgZHdfZWRtYSAqZHcgPSBjaGlwLT5k dzsKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNoaXAtPmRldjsKPiArCWNvbnN0IHN0cnVjdCBk d19lZG1hX2NvcmVfb3BzICpvcHM7Cj4gKwlzaXplX3QgbGxfY2h1bmsgPSBkdy0+bGxfcmVnaW9u LnN6Owo+ICsJc2l6ZV90IGR0X2NodW5rID0gZHctPmR0X3JlZ2lvbi5zejsKPiArCXUzMiBjaF90 b3Q7Cj4gKwlpbnQgaSwgaiwgZXJyOwo+ICsKPiArCXJhd19zcGluX2xvY2tfaW5pdCgmZHctPmxv Y2spOwo+ICsKPiArCS8qIENhbGxiYWNrIG9wZXJhdGlvbiBzZWxlY3Rpb24gYWNjb3JkaW5nbHkg dG8gZURNQSB2ZXJzaW9uICovCj4gKwlzd2l0Y2ggKGR3LT52ZXJzaW9uKSB7Cj4gKwlkZWZhdWx0 Ogo+ICsJCWRldl9lcnIoZGV2LCAidW5zdXBwb3J0ZWQgdmVyc2lvblxuIik7Cj4gKwkJcmV0dXJu IC1FUEVSTTsKPiArCX0KClNvIHdlIGhhdmUgb25seSBvbmUgY2FzZSB3aGljaCByZXR1cm5zIGVy cm9yLCB3YXMgdGhpcyBjb2RlIHRlc3RlZD8KCj4gKwo+ICsJcG1fcnVudGltZV9nZXRfc3luYyhk ZXYpOwo+ICsKPiArCS8qIEZpbmQgb3V0IGhvdyBtYW55IHdyaXRlIGNoYW5uZWxzIGFyZSBzdXBw b3J0ZWQgYnkgaGFyZHdhcmUgKi8KPiArCWR3LT53cl9jaF9jbnQgPSBvcHMtPmNoX2NvdW50KGR3 LCBFRE1BX0RJUl9XUklURSk7Cj4gKwlpZiAoIWR3LT53cl9jaF9jbnQpIHsKPiArCQlkZXZfZXJy KGRldiwgImludmFsaWQgbnVtYmVyIG9mIHdyaXRlIGNoYW5uZWxzKDApXG4iKTsKPiArCQlyZXR1 cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwkvKiBGaW5kIG91dCBob3cgbWFueSByZWFkIGNoYW5u ZWxzIGFyZSBzdXBwb3J0ZWQgYnkgaGFyZHdhcmUgKi8KPiArCWR3LT5yZF9jaF9jbnQgPSBvcHMt PmNoX2NvdW50KGR3LCBFRE1BX0RJUl9SRUFEKTsKPiArCWlmICghZHctPnJkX2NoX2NudCkgewo+ ICsJCWRldl9lcnIoZGV2LCAiaW52YWxpZCBudW1iZXIgb2YgcmVhZCBjaGFubmVscygwKVxuIik7 Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJZGV2X2RiZyhkZXYsICJDaGFubmVs czpcdHdyaXRlPSVkLCByZWFkPSVkXG4iLAo+ICsJCWR3LT53cl9jaF9jbnQsIGR3LT5yZF9jaF9j bnQpOwo+ICsKPiArCWNoX3RvdCA9IGR3LT53cl9jaF9jbnQgKyBkdy0+cmRfY2hfY250Owo+ICsK PiArCS8qIEFsbG9jYXRlIGNoYW5uZWxzICovCj4gKwlkdy0+Y2hhbiA9IGRldm1fa2NhbGxvYyhk ZXYsIGNoX3RvdCwgc2l6ZW9mKCpkdy0+Y2hhbiksIEdGUF9LRVJORUwpOwoKeW91IG1heSB1c2Ug c3RydWN0X3NpemUoKSBoZXJlCgo+ICsJaWYgKCFkdy0+Y2hhbikKPiArCQlyZXR1cm4gLUVOT01F TTsKPiArCj4gKwkvKiBDYWxjdWxhdGUgdGhlIGxpbmtlZCBsaXN0IGNodW5rIGZvciBlYWNoIGNo YW5uZWwgKi8KPiArCWxsX2NodW5rIC89IHJvdW5kdXBfcG93X29mX3R3byhjaF90b3QpOwo+ICsK PiArCS8qIENhbGN1bGF0ZSB0aGUgbGlua2VkIGxpc3QgY2h1bmsgZm9yIGVhY2ggY2hhbm5lbCAq Lwo+ICsJZHRfY2h1bmsgLz0gcm91bmR1cF9wb3dfb2ZfdHdvKGNoX3RvdCk7Cj4gKwo+ICsJLyog RGlzYWJsZSBlRE1BLCBvbmx5IHRvIGVzdGFibGlzaCB0aGUgaWRlYWwgaW5pdGlhbCBjb25kaXRp b25zICovCj4gKwlvcHMtPm9mZihkdyk7Cj4gKwo+ICsJc25wcmludGYoZHctPm5hbWUsIHNpemVv Zihkdy0+bmFtZSksICJkdy1lZG1hLWNvcmU6JWQiLCBjaGlwLT5pZCk7Cj4gKwo+ICsJLyogUmVx dWVzdCBJUlFzICovCj4gKwlpZiAoZHctPm5yX2lycXMgIT0gMSkgewo+ICsJCWRldl9lcnIoZGV2 LCAiaW52YWxpZCBudW1iZXIgb2YgaXJxcyAoJXUpXG4iLCBkdy0+bnJfaXJxcyk7Cj4gKwkJcmV0 dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGR3LT5ucl9pcnFzOyBp KyspIHsKPiArCQllcnIgPSBkZXZtX3JlcXVlc3RfaXJxKGRldiwgcGNpX2lycV92ZWN0b3IodG9f cGNpX2RldihkZXYpLCBpKSwKPiArCQkJCSAgICAgICBkd19lZG1hX2ludGVycnVwdF9hbGwsCj4g KwkJCQkgICAgICAgSVJRRl9TSEFSRUQsIGR3LT5uYW1lLCBjaGlwKTsKPiArCQlpZiAoZXJyKQo+ ICsJCQlyZXR1cm4gZXJyOwo+ICsJfQo+ICsKPiArCS8qIENyZWF0ZSB3cml0ZSBjaGFubmVscyAq Lwo+ICsJSU5JVF9MSVNUX0hFQUQoJmR3LT53cl9lZG1hLmNoYW5uZWxzKTsKPiArCWZvciAoaSA9 IDA7IGkgPCBkdy0+d3JfY2hfY250OyBpKyspIHsKPiArCQlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpj aGFuID0gJmR3LT5jaGFuW2ldOwo+ICsJCXN0cnVjdCBkd19lZG1hX3JlZ2lvbiAqZHRfcmVnaW9u Owo+ICsKPiArCQlkdF9yZWdpb24gPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmR0X3JlZ2lv biksIEdGUF9LRVJORUwpOwo+ICsJCWlmICghZHRfcmVnaW9uKQo+ICsJCQlyZXR1cm4gLUVOT01F TTsKPiArCj4gKwkJY2hhbi0+dmMuY2hhbi5wcml2YXRlID0gZHRfcmVnaW9uOwo+ICsKPiArCQlj aGFuLT5jaGlwID0gY2hpcDsKPiArCQljaGFuLT5pZCA9IGk7Cj4gKwkJY2hhbi0+ZGlyID0gRURN QV9ESVJfV1JJVEU7Cj4gKwkJY2hhbi0+Y29uZmlndXJlZCA9IGZhbHNlOwo+ICsJCWNoYW4tPnJl cXVlc3QgPSBFRE1BX1JFUV9OT05FOwo+ICsJCWNoYW4tPnN0YXR1cyA9IEVETUFfU1RfSURMRTsK PiArCj4gKwkJY2hhbi0+bGxfb2ZmID0gKGxsX2NodW5rICogaSk7Cj4gKwkJY2hhbi0+bGxfbWF4 ID0gKGxsX2NodW5rIC8gRURNQV9MTF9TWikgLSAxOwo+ICsKPiArCQljaGFuLT5kdF9vZmYgPSAo ZHRfY2h1bmsgKiBpKTsKPiArCj4gKwkJZGV2X2RiZyhkZXYsICJMLiBMaXN0Olx0Q2hhbm5lbCB3 cml0ZVsldV0gb2ZmPTB4JS44bHgsIG1heF9jbnQ9JXVcbiIsCj4gKwkJCWksIGNoYW4tPmxsX29m ZiwgY2hhbi0+bGxfbWF4KTsKPiArCj4gKwkJbWVtY3B5KCZjaGFuLT5tc2ksICZkdy0+bXNpWzBd LCBzaXplb2YoY2hhbi0+bXNpKSk7Cj4gKwo+ICsJCWRldl9kYmcoZGV2LCAiTVNJOlx0XHRDaGFu bmVsIHdyaXRlWyV1XSBhZGRyPTB4JS44eCUuOHgsIGRhdGE9MHglLjh4XG4iLAo+ICsJCQlpLCBj aGFuLT5tc2kuYWRkcmVzc19oaSwgY2hhbi0+bXNpLmFkZHJlc3NfbG8sCj4gKwkJCWNoYW4tPm1z aS5kYXRhKTsKPiArCj4gKwkJY2hhbi0+dmMuZGVzY19mcmVlID0gdmNoYW5fZnJlZV9kZXNjOwo+ ICsJCXZjaGFuX2luaXQoJmNoYW4tPnZjLCAmZHctPndyX2VkbWEpOwo+ICsKPiArCQlkdF9yZWdp b24tPnBhZGRyID0gZHctPmR0X3JlZ2lvbi5wYWRkciArIGNoYW4tPmR0X29mZjsKPiArCQlkdF9y ZWdpb24tPnZhZGRyID0gZHctPmR0X3JlZ2lvbi52YWRkciArIGNoYW4tPmR0X29mZjsKPiArCQlk dF9yZWdpb24tPnN6ID0gZHRfY2h1bms7Cj4gKwo+ICsJCWRldl9kYmcoZGV2LCAiRGF0YTpcdENo YW5uZWwgd3JpdGVbJXVdIG9mZj0weCUuOGx4XG4iLAo+ICsJCQlpLCBjaGFuLT5kdF9vZmYpOwo+ ICsJfQo+ICsJZG1hX2NhcF96ZXJvKGR3LT53cl9lZG1hLmNhcF9tYXNrKTsKPiArCWRtYV9jYXBf c2V0KERNQV9TTEFWRSwgZHctPndyX2VkbWEuY2FwX21hc2spOwo+ICsJZG1hX2NhcF9zZXQoRE1B X0NZQ0xJQywgZHctPndyX2VkbWEuY2FwX21hc2spOwo+ICsJZHctPndyX2VkbWEuZGlyZWN0aW9u cyA9IEJJVChETUFfREVWX1RPX01FTSk7Cj4gKwlkdy0+d3JfZWRtYS5jaGFuY250ID0gZHctPndy X2NoX2NudDsKPiArCj4gKwkvKiBDcmVhdGUgcmVhZCBjaGFubmVscyAqLwo+ICsJSU5JVF9MSVNU X0hFQUQoJmR3LT5yZF9lZG1hLmNoYW5uZWxzKTsKPiArCWZvciAoaiA9IDA7IGogPCBkdy0+cmRf Y2hfY250OyBqKyssIGkrKykgewo+ICsJCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4gPSAmZHct PmNoYW5baV07Cj4gKwkJc3RydWN0IGR3X2VkbWFfcmVnaW9uICpkdF9yZWdpb247Cj4gKwo+ICsJ CWR0X3JlZ2lvbiA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqZHRfcmVnaW9uKSwgR0ZQX0tF Uk5FTCk7Cj4gKwkJaWYgKCFkdF9yZWdpb24pCj4gKwkJCXJldHVybiAtRU5PTUVNOwo+ICsKPiAr CQljaGFuLT52Yy5jaGFuLnByaXZhdGUgPSBkdF9yZWdpb247Cj4gKwo+ICsJCWNoYW4tPmNoaXAg PSBjaGlwOwo+ICsJCWNoYW4tPmlkID0gajsKPiArCQljaGFuLT5kaXIgPSBFRE1BX0RJUl9SRUFE Owo+ICsJCWNoYW4tPmNvbmZpZ3VyZWQgPSBmYWxzZTsKPiArCQljaGFuLT5yZXF1ZXN0ID0gRURN QV9SRVFfTk9ORTsKPiArCQljaGFuLT5zdGF0dXMgPSBFRE1BX1NUX0lETEU7Cj4gKwo+ICsJCWNo YW4tPmxsX29mZiA9IChsbF9jaHVuayAqIGkpOwo+ICsJCWNoYW4tPmxsX21heCA9IChsbF9jaHVu ayAvIEVETUFfTExfU1opIC0gMTsKPiArCj4gKwkJY2hhbi0+ZHRfb2ZmID0gKGR0X2NodW5rICog aSk7Cj4gKwo+ICsJCWRldl9kYmcoZGV2LCAiTC4gTGlzdDpcdENoYW5uZWwgcmVhZFsldV0gb2Zm PTB4JS44bHgsIG1heF9jbnQ9JXVcbiIsCj4gKwkJCWosIGNoYW4tPmxsX29mZiwgY2hhbi0+bGxf bWF4KTsKPiArCj4gKwkJbWVtY3B5KCZjaGFuLT5tc2ksICZkdy0+bXNpWzBdLCBzaXplb2YoY2hh bi0+bXNpKSk7Cj4gKwo+ICsJCWRldl9kYmcoZGV2LCAiTVNJOlx0XHRDaGFubmVsIHJlYWRbJXVd IGFkZHI9MHglLjh4JS44eCwgZGF0YT0weCUuOHhcbiIsCj4gKwkJCWosIGNoYW4tPm1zaS5hZGRy ZXNzX2hpLCBjaGFuLT5tc2kuYWRkcmVzc19sbywKPiArCQkJY2hhbi0+bXNpLmRhdGEpOwo+ICsK PiArCQljaGFuLT52Yy5kZXNjX2ZyZWUgPSB2Y2hhbl9mcmVlX2Rlc2M7Cj4gKwkJdmNoYW5faW5p dCgmY2hhbi0+dmMsICZkdy0+cmRfZWRtYSk7Cj4gKwo+ICsJCWR0X3JlZ2lvbi0+cGFkZHIgPSBk dy0+ZHRfcmVnaW9uLnBhZGRyICsgY2hhbi0+ZHRfb2ZmOwo+ICsJCWR0X3JlZ2lvbi0+dmFkZHIg PSBkdy0+ZHRfcmVnaW9uLnZhZGRyICsgY2hhbi0+ZHRfb2ZmOwo+ICsJCWR0X3JlZ2lvbi0+c3og PSBkdF9jaHVuazsKPiArCj4gKwkJZGV2X2RiZyhkZXYsICJEYXRhOlx0Q2hhbm5lbCByZWFkWyV1 XSBvZmY9MHglLjhseFxuIiwKPiArCQkJaSwgY2hhbi0+ZHRfb2ZmKTsKCnRoaXMgaXMgc2ltaWxh ciB0byBwcmV2aW91cyB3aXRoIG9idmlvdXMgY2hhbmdlcywgSSB0aGluayB0aGlzIGNhbiBiZQpt YWRlIGNvbW1vbiByb3V0aW5lIGludm9rZSBmb3IgUiBhbmQgVyAuLi4KClNvIEhXIHByb3ZpZGVz IHJlYWQgY2hhbm5lbHMgYW5kIHdyaXRlIGNoYW5uZWxzIGFuZCBub3QgZ2VuZXJpYyBjaGFubmVs cwp3aGljaCBjYW4gYmUgdXNlZCBmb3IgZWl0aGVyIFIgb3IgVz8K 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=-3.6 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,MAILING_LIST_MULTI,SPF_PASS,URIBL_BLOCKED, USER_AGENT_MUTT 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 29ED8C61CE4 for ; Sun, 20 Jan 2019 11:46:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id CD76820880 for ; Sun, 20 Jan 2019 11:46:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1547984763; bh=3xmya8Huuqixd4lC3eX8croC8Pat0n3d+5ULA7Fv82A=; h=Date:From:To:Cc:Subject:References:In-Reply-To:List-ID:From; b=ja/W5x/b2nLo/DCzEca5nkXTzCuk/5qMoO/ZgDyQ7Z150pKO4prVvUgHrsGwY0b4p BJA49kI1FwXCuCpRDF0H4clUtcyB8vRFK8qdLym6EXrIH8o/cSZFHyyvkMmUW8Bnkn I562ZObSNbvi7jj8jjxRuHGdz9Hsx4sDAvFDr/uY= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730490AbfATLqC (ORCPT ); Sun, 20 Jan 2019 06:46:02 -0500 Received: from mail.kernel.org ([198.145.29.99]:36102 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730473AbfATLqC (ORCPT ); Sun, 20 Jan 2019 06:46:02 -0500 Received: from localhost (unknown [122.178.235.99]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 5E2372084F; Sun, 20 Jan 2019 11:45:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1547984760; bh=3xmya8Huuqixd4lC3eX8croC8Pat0n3d+5ULA7Fv82A=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=GohJRGwZHv849ibrRA2a6NuGBJ9IXcfI8RM2KpJBUTRHk/6S9vl2I5hl4y1PEWxmm iTzU2ccBMfpkRpRWpQyIfKoHJaMMahwVBQw+l6boIxNKJPgOwRK14k6ixbR284iX4C +1YROaSBT75614gIFzG2H95bFE3346SgZaWI6a5M= Date: Sun, 20 Jan 2019 17:14:25 +0530 From: Vinod Koul To: Gustavo Pimentel Cc: linux-pci@vger.kernel.org, dmaengine@vger.kernel.org, Dan Williams , Eugeniy Paltsev , Andy Shevchenko , Russell King , Niklas Cassel , Joao Pinto , Jose Abreu , Luis Oliveira , Vitor Soares , Nelson Costa , Pedro Sousa Subject: Re: [RFC v3 1/7] dmaengine: Add Synopsys eDMA IP core driver Message-ID: <20190120114425.GV4635@vkoul-mobl> References: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org On 11-01-19, 19:33, Gustavo Pimentel wrote: > Add Synopsys eDMA IP core driver to kernel. > > This core driver, initializes and configures the eDMA IP using vma-helpers > functions and dma-engine subsystem. A description of eDMA IP will help review the driver > Also creates an abstration layer through callbacks allowing different > registers mappings in the future, organized in to versions. > > This driver can be compile as built-in or external module in kernel. > > To enable this driver just select DW_EDMA option in kernel configuration, > however it requires and selects automatically DMA_ENGINE and > DMA_VIRTUAL_CHANNELS option too. > > Changes: > RFC v1->RFC v2: These do not belong to change log, either move them to cover-letter or keep them after s-o-b lines.. > @@ -0,0 +1,1059 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. 2019 now > +static struct dw_edma_burst *dw_edma_alloc_burst(struct dw_edma_chunk *chunk) > +{ > + struct dw_edma_chan *chan = chunk->chan; > + struct dw_edma_burst *burst; > + > + burst = kvzalloc(sizeof(*burst), GFP_NOWAIT); Is there a specific reason for kvzalloc(), do you submit this to HW.. > +static struct dw_edma_chunk *dw_edma_alloc_chunk(struct dw_edma_desc *desc) > +{ > + struct dw_edma_chan *chan = desc->chan; > + struct dw_edma *dw = chan->chip->dw; > + struct dw_edma_chunk *chunk; > + > + chunk = kvzalloc(sizeof(*chunk), GFP_NOWAIT); > + if (unlikely(!chunk)) > + return NULL; > + > + INIT_LIST_HEAD(&chunk->list); > + chunk->chan = chan; > + chunk->cb = !(desc->chunks_alloc % 2); cb ..? > +static int dw_edma_device_config(struct dma_chan *dchan, > + struct dma_slave_config *config) > +{ > + struct dw_edma_chan *chan = dchan2dw_edma_chan(dchan); > + const struct dw_edma_core_ops *ops = chan2ops(chan); > + unsigned long flags; > + int err = 0; > + > + spin_lock_irqsave(&chan->vc.lock, flags); > + > + if (!config) { > + err = -EINVAL; > + goto err_config; > + } > + > + if (chan->status != EDMA_ST_IDLE) { > + dev_err(chan2dev(chan), "channel is busy or paused\n"); > + err = -EPERM; this is not correct behaviour, device_config can be called anytime and values can take affect on next transaction submitted.. > + goto err_config; > + } > + > + dev_dbg(chan2dev(chan), "addr(physical) src=%pa, dst=%pa\n", > + &config->src_addr, &config->dst_addr); > + > + chan->src_addr = config->src_addr; > + chan->dst_addr = config->dst_addr; > + > + err = ops->device_config(dchan); what does this do? > +static enum dma_status > +dw_edma_device_tx_status(struct dma_chan *dchan, dma_cookie_t cookie, > + struct dma_tx_state *txstate) > +{ > + struct dw_edma_chan *chan = dchan2dw_edma_chan(dchan); > + const struct dw_edma_core_ops *ops = chan2ops(chan); > + unsigned long flags; > + enum dma_status ret; > + > + spin_lock_irqsave(&chan->vc.lock, flags); > + > + ret = ops->ch_status(chan); > + if (ret == DMA_ERROR) { > + goto ret_status; > + } else if (ret == DMA_IN_PROGRESS) { > + chan->status = EDMA_ST_BUSY; > + goto ret_status; so in this case you set residue as zero, which is not correct > + } else { > + /* DMA_COMPLETE */ > + if (chan->status == EDMA_ST_PAUSE) > + ret = DMA_PAUSED; > + else if (chan->status == EDMA_ST_BUSY) > + ret = DMA_IN_PROGRESS; ?? if txn is complete how are you returning DMA_IN_PROGRESS? > + else > + ret = DMA_COMPLETE; > + } this looks incorrect interpretation to me. The status is to be retrieved for the given cookie passed and given that you do not even use this argument tells me that you have understood this as 'channel' status reporting, which is not correct > +static struct dma_async_tx_descriptor * > +dw_edma_device_prep_slave_sg(struct dma_chan *dchan, struct scatterlist *sgl, > + unsigned int sg_len, > + enum dma_transfer_direction direction, > + unsigned long flags, void *context) > +{ > + struct dw_edma_chan *chan = dchan2dw_edma_chan(dchan); > + struct dw_edma_desc *desc; > + struct dw_edma_chunk *chunk; > + struct dw_edma_burst *burst; > + struct scatterlist *sg; > + unsigned long sflags; > + phys_addr_t src_addr; > + phys_addr_t dst_addr; > + int i; > + > + if (sg_len < 1) { > + dev_err(chan2dev(chan), "invalid sg length %u\n", sg_len); > + return NULL; > + } > + > + if (direction == DMA_DEV_TO_MEM && chan->dir == EDMA_DIR_WRITE) { what is the second part of the check, can you explain that, who sets chan->dir? > + dev_dbg(chan2dev(chan), "prepare operation (WRITE)\n"); > + } else if (direction == DMA_MEM_TO_DEV && chan->dir == EDMA_DIR_READ) { > + dev_dbg(chan2dev(chan), "prepare operation (READ)\n"); > + } else { > + dev_err(chan2dev(chan), "invalid direction\n"); > + return NULL; > + } > + > + if (!chan->configured) { > + dev_err(chan2dev(chan), "(prep_slave_sg) channel not configured\n"); > + return NULL; > + } > + > + if (chan->status != EDMA_ST_IDLE) { > + dev_err(chan2dev(chan), "channel is busy or paused\n"); > + return NULL; > + } No, wrong again. The txn must be prepared and then on submit added to a queue. You are writing a driver for dmaengine, surely you dont expect the channel to be free and then do a txn.. that would be very inefficient! > +static struct dma_async_tx_descriptor * > +dw_edma_device_prep_dma_cyclic(struct dma_chan *dchan, dma_addr_t buf_addr, > + size_t len, size_t cyclic_cnt, > + enum dma_transfer_direction direction, > + unsigned long flags) > +{ > + struct dw_edma_chan *chan = dchan2dw_edma_chan(dchan); > + struct dw_edma_desc *desc; > + struct dw_edma_chunk *chunk; > + struct dw_edma_burst *burst; > + unsigned long sflags; > + phys_addr_t src_addr; > + phys_addr_t dst_addr; > + u32 i; > + > + if (!len || !cyclic_cnt) { > + dev_err(chan2dev(chan), "invalid len or cyclic count\n"); > + return NULL; > + } > + > + if (direction == DMA_DEV_TO_MEM && chan->dir == EDMA_DIR_WRITE) { > + dev_dbg(chan2dev(chan), "prepare operation (WRITE)\n"); > + } else if (direction == DMA_MEM_TO_DEV && chan->dir == EDMA_DIR_READ) { > + dev_dbg(chan2dev(chan), "prepare operation (READ)\n"); > + } else { > + dev_err(chan2dev(chan), "invalid direction\n"); > + return NULL; > + } > + > + if (!chan->configured) { > + dev_err(chan2dev(chan), "(prep_dma_cyclic) channel not configured\n"); > + return NULL; > + } > + > + if (chan->status != EDMA_ST_IDLE) { > + dev_err(chan2dev(chan), "channel is busy or paused\n"); > + return NULL; > + } > + > + spin_lock_irqsave(&chan->vc.lock, sflags); > + > + desc = dw_edma_alloc_desc(chan); > + if (unlikely(!desc)) > + goto err_alloc; > + > + chunk = dw_edma_alloc_chunk(desc); > + if (unlikely(!chunk)) > + goto err_alloc; > + > + src_addr = chan->src_addr; > + dst_addr = chan->dst_addr; > + > + for (i = 0; i < cyclic_cnt; i++) { > + if (chunk->bursts_alloc == chan->ll_max) { > + chunk = dw_edma_alloc_chunk(desc); > + if (unlikely(!chunk)) > + goto err_alloc; > + } > + > + burst = dw_edma_alloc_burst(chunk); > + > + if (unlikely(!burst)) > + goto err_alloc; > + > + burst->sz = len; > + chunk->ll_region.sz += burst->sz; > + desc->alloc_sz += burst->sz; > + > + burst->sar = src_addr; > + burst->dar = dst_addr; > + > + dev_dbg(chan2dev(chan), "lli %u/%u, sar=0x%.8llx, dar=0x%.8llx, size=%u bytes\n", > + i + 1, cyclic_cnt, burst->sar, burst->dar, burst->sz); > + } > + > + spin_unlock_irqrestore(&chan->vc.lock, sflags); > + return vchan_tx_prep(&chan->vc, &desc->vd, flags); how is it different from previous? am sure we can reuse bits! > +static void dw_edma_done_interrupt(struct dw_edma_chan *chan) > +{ > + struct dw_edma *dw = chan->chip->dw; > + const struct dw_edma_core_ops *ops = dw->ops; > + struct virt_dma_desc *vd; > + struct dw_edma_desc *desc; > + unsigned long flags; > + > + ops->clear_done_int(chan); > + dev_dbg(chan2dev(chan), "clear done interrupt\n"); > + > + spin_lock_irqsave(&chan->vc.lock, flags); > + vd = vchan_next_desc(&chan->vc); > + switch (chan->request) { > + case EDMA_REQ_NONE: > + if (!vd) > + break; > + > + desc = vd2dw_edma_desc(vd); > + if (desc->chunks_alloc) { > + dev_dbg(chan2dev(chan), "sub-transfer complete\n"); > + chan->status = EDMA_ST_BUSY; > + dev_dbg(chan2dev(chan), "transferred %u bytes\n", > + desc->xfer_sz); > + dw_edma_start_transfer(chan); > + } else { > + list_del(&vd->node); > + vchan_cookie_complete(vd); > + chan->status = EDMA_ST_IDLE; > + dev_dbg(chan2dev(chan), "transfer complete\n"); > + } > + break; > + case EDMA_REQ_STOP: > + if (!vd) > + break; > + > + list_del(&vd->node); > + vchan_cookie_complete(vd); > + chan->request = EDMA_REQ_NONE; > + chan->status = EDMA_ST_IDLE; > + chan->configured = false; why is configuration deemed invalid, it can still be used again! > +int dw_edma_probe(struct dw_edma_chip *chip) > +{ > + struct dw_edma *dw = chip->dw; > + struct device *dev = chip->dev; > + const struct dw_edma_core_ops *ops; > + size_t ll_chunk = dw->ll_region.sz; > + size_t dt_chunk = dw->dt_region.sz; > + u32 ch_tot; > + int i, j, err; > + > + raw_spin_lock_init(&dw->lock); > + > + /* Callback operation selection accordingly to eDMA version */ > + switch (dw->version) { > + default: > + dev_err(dev, "unsupported version\n"); > + return -EPERM; > + } So we have only one case which returns error, was this code tested? > + > + pm_runtime_get_sync(dev); > + > + /* Find out how many write channels are supported by hardware */ > + dw->wr_ch_cnt = ops->ch_count(dw, EDMA_DIR_WRITE); > + if (!dw->wr_ch_cnt) { > + dev_err(dev, "invalid number of write channels(0)\n"); > + return -EINVAL; > + } > + > + /* Find out how many read channels are supported by hardware */ > + dw->rd_ch_cnt = ops->ch_count(dw, EDMA_DIR_READ); > + if (!dw->rd_ch_cnt) { > + dev_err(dev, "invalid number of read channels(0)\n"); > + return -EINVAL; > + } > + > + dev_dbg(dev, "Channels:\twrite=%d, read=%d\n", > + dw->wr_ch_cnt, dw->rd_ch_cnt); > + > + ch_tot = dw->wr_ch_cnt + dw->rd_ch_cnt; > + > + /* Allocate channels */ > + dw->chan = devm_kcalloc(dev, ch_tot, sizeof(*dw->chan), GFP_KERNEL); you may use struct_size() here > + if (!dw->chan) > + return -ENOMEM; > + > + /* Calculate the linked list chunk for each channel */ > + ll_chunk /= roundup_pow_of_two(ch_tot); > + > + /* Calculate the linked list chunk for each channel */ > + dt_chunk /= roundup_pow_of_two(ch_tot); > + > + /* Disable eDMA, only to establish the ideal initial conditions */ > + ops->off(dw); > + > + snprintf(dw->name, sizeof(dw->name), "dw-edma-core:%d", chip->id); > + > + /* Request IRQs */ > + if (dw->nr_irqs != 1) { > + dev_err(dev, "invalid number of irqs (%u)\n", dw->nr_irqs); > + return -EINVAL; > + } > + > + for (i = 0; i < dw->nr_irqs; i++) { > + err = devm_request_irq(dev, pci_irq_vector(to_pci_dev(dev), i), > + dw_edma_interrupt_all, > + IRQF_SHARED, dw->name, chip); > + if (err) > + return err; > + } > + > + /* Create write channels */ > + INIT_LIST_HEAD(&dw->wr_edma.channels); > + for (i = 0; i < dw->wr_ch_cnt; i++) { > + struct dw_edma_chan *chan = &dw->chan[i]; > + struct dw_edma_region *dt_region; > + > + dt_region = devm_kzalloc(dev, sizeof(*dt_region), GFP_KERNEL); > + if (!dt_region) > + return -ENOMEM; > + > + chan->vc.chan.private = dt_region; > + > + chan->chip = chip; > + chan->id = i; > + chan->dir = EDMA_DIR_WRITE; > + chan->configured = false; > + chan->request = EDMA_REQ_NONE; > + chan->status = EDMA_ST_IDLE; > + > + chan->ll_off = (ll_chunk * i); > + chan->ll_max = (ll_chunk / EDMA_LL_SZ) - 1; > + > + chan->dt_off = (dt_chunk * i); > + > + dev_dbg(dev, "L. List:\tChannel write[%u] off=0x%.8lx, max_cnt=%u\n", > + i, chan->ll_off, chan->ll_max); > + > + memcpy(&chan->msi, &dw->msi[0], sizeof(chan->msi)); > + > + dev_dbg(dev, "MSI:\t\tChannel write[%u] addr=0x%.8x%.8x, data=0x%.8x\n", > + i, chan->msi.address_hi, chan->msi.address_lo, > + chan->msi.data); > + > + chan->vc.desc_free = vchan_free_desc; > + vchan_init(&chan->vc, &dw->wr_edma); > + > + dt_region->paddr = dw->dt_region.paddr + chan->dt_off; > + dt_region->vaddr = dw->dt_region.vaddr + chan->dt_off; > + dt_region->sz = dt_chunk; > + > + dev_dbg(dev, "Data:\tChannel write[%u] off=0x%.8lx\n", > + i, chan->dt_off); > + } > + dma_cap_zero(dw->wr_edma.cap_mask); > + dma_cap_set(DMA_SLAVE, dw->wr_edma.cap_mask); > + dma_cap_set(DMA_CYCLIC, dw->wr_edma.cap_mask); > + dw->wr_edma.directions = BIT(DMA_DEV_TO_MEM); > + dw->wr_edma.chancnt = dw->wr_ch_cnt; > + > + /* Create read channels */ > + INIT_LIST_HEAD(&dw->rd_edma.channels); > + for (j = 0; j < dw->rd_ch_cnt; j++, i++) { > + struct dw_edma_chan *chan = &dw->chan[i]; > + struct dw_edma_region *dt_region; > + > + dt_region = devm_kzalloc(dev, sizeof(*dt_region), GFP_KERNEL); > + if (!dt_region) > + return -ENOMEM; > + > + chan->vc.chan.private = dt_region; > + > + chan->chip = chip; > + chan->id = j; > + chan->dir = EDMA_DIR_READ; > + chan->configured = false; > + chan->request = EDMA_REQ_NONE; > + chan->status = EDMA_ST_IDLE; > + > + chan->ll_off = (ll_chunk * i); > + chan->ll_max = (ll_chunk / EDMA_LL_SZ) - 1; > + > + chan->dt_off = (dt_chunk * i); > + > + dev_dbg(dev, "L. List:\tChannel read[%u] off=0x%.8lx, max_cnt=%u\n", > + j, chan->ll_off, chan->ll_max); > + > + memcpy(&chan->msi, &dw->msi[0], sizeof(chan->msi)); > + > + dev_dbg(dev, "MSI:\t\tChannel read[%u] addr=0x%.8x%.8x, data=0x%.8x\n", > + j, chan->msi.address_hi, chan->msi.address_lo, > + chan->msi.data); > + > + chan->vc.desc_free = vchan_free_desc; > + vchan_init(&chan->vc, &dw->rd_edma); > + > + dt_region->paddr = dw->dt_region.paddr + chan->dt_off; > + dt_region->vaddr = dw->dt_region.vaddr + chan->dt_off; > + dt_region->sz = dt_chunk; > + > + dev_dbg(dev, "Data:\tChannel read[%u] off=0x%.8lx\n", > + i, chan->dt_off); this is similar to previous with obvious changes, I think this can be made common routine invoke for R and W ... So HW provides read channels and write channels and not generic channels which can be used for either R or W? -- ~Vinod