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: Jose Abreu Message-Id: Date: Wed, 16 Jan 2019 10:21:35 +0000 To: Gustavo Pimentel , linux-pci@vger.kernel.org, dmaengine@vger.kernel.org Cc: Vinod Koul , Dan Williams , Eugeniy Paltsev , Andy Shevchenko , Russell King , Niklas Cassel , Joao Pinto , Jose Abreu , Luis Oliveira , Vitor Soares , Nelson Costa , Pedro Sousa List-ID: SGkgR3VzdGF2bywKCk9uIDEvMTEvMjAxOSA2OjMzIFBNLCBHdXN0YXZvIFBpbWVudGVsIHdyb3Rl Ogo+IEFkZCBTeW5vcHN5cyBlRE1BIElQIGNvcmUgZHJpdmVyIHRvIGtlcm5lbC4KPiAKPiBUaGlz IGNvcmUgZHJpdmVyLCBpbml0aWFsaXplcyBhbmQgY29uZmlndXJlcyB0aGUgZURNQSBJUCB1c2lu ZyB2bWEtaGVscGVycwo+IGZ1bmN0aW9ucyBhbmQgZG1hLWVuZ2luZSBzdWJzeXN0ZW0uCj4gCj4g QWxzbyBjcmVhdGVzIGFuIGFic3RyYXRpb24gbGF5ZXIgdGhyb3VnaCBjYWxsYmFja3MgYWxsb3dp bmcgZGlmZmVyZW50Cj4gcmVnaXN0ZXJzIG1hcHBpbmdzIGluIHRoZSBmdXR1cmUsIG9yZ2FuaXpl ZCBpbiB0byB2ZXJzaW9ucy4KPiAKPiBUaGlzIGRyaXZlciBjYW4gYmUgY29tcGlsZSBhcyBidWls dC1pbiBvciBleHRlcm5hbCBtb2R1bGUgaW4ga2VybmVsLgo+IAo+IFRvIGVuYWJsZSB0aGlzIGRy aXZlciBqdXN0IHNlbGVjdCBEV19FRE1BIG9wdGlvbiBpbiBrZXJuZWwgY29uZmlndXJhdGlvbiwK PiBob3dldmVyIGl0IHJlcXVpcmVzIGFuZCBzZWxlY3RzIGF1dG9tYXRpY2FsbHkgRE1BX0VOR0lO RSBhbmQKPiBETUFfVklSVFVBTF9DSEFOTkVMUyBvcHRpb24gdG9vLgo+IAo+IENoYW5nZXM6Cj4g UkZDIHYxLT5SRkMgdjI6Cj4gIC0gUmVwbGFjZSBjb21tZW50cyAvLyAoQzk5IHN0eWxlKSBieSAv KiovCj4gIC0gRml4IHRoZSBoZWFkZXJzIG9mIHRoZSAuYyBhbmQgLmggZmlsZXMgYWNjb3JkaW5n IHRvIHRoZSBtb3N0IHJlY2VudAo+ICAgIGNvbnZlbnRpb24KPiAgLSBGaXggZXJyb3JzIGFuZCBj aGVja3MgcG9pbnRlZCBvdXQgYnkgY2hlY2twYXRjaCB3aXRoIC0tc3RyaWN0IG9wdGlvbgo+ICAt IFJlcGxhY2UgcGF0Y2ggc21hbGwgZGVzY3JpcHRpb24gdGFnIGZyb20gZG1hIGJ5IGRtYWVuZ2lu ZQo+ICAtIENoYW5nZSBzb21lIGRldl9pbmZvKCkgaW50byBkZXZfZGJnKCkKPiAgLSBSZW1vdmUg dW5uZWNlc3NhcnkgemVybyBpbml0aWFsaXphdGlvbiBhZnRlciBremFsbG9jCj4gIC0gUmVtb3Zl IGRpcmVjdGlvbiB2YWxpZGF0aW9uIG9uIGNvbmZpZygpIEFQSSwgc2luY2UgdGhlIGRpcmVjdGlv bgo+ICAgIHBhcmFtZXRlciBpcyBkZXByZWNhdGVkCj4gIC0gUmVmYWN0b3IgY29kZSB0byByZXBs YWNlIGF0b21pY190IGJ5IHUzMiB2YXJpYWJsZSB0eXBlCj4gIC0gUmVwbGFjZSBzdGFydF90cmFu c2ZlcigpIG5hbWUgYnkgZHdfZWRtYV9zdGFydF90cmFuc2ZlcigpCj4gIC0gQWRkIHNwaW5sb2Nr IHRvIGR3X2VkbWFfZGV2aWNlX3ByZXBfc2xhdmVfc2coKQo+ICAtIEFkZCBzcGlubG9jayB0byBk d19lZG1hX2ZyZWVfY2h1bmsoKQo+ICAtIFNpbXBsaWZ5IHN3aXRjaCBjYXNlIGludG8gaWYgb24g ZHdfZWRtYV9kZXZpY2VfcGF1c2UoKSwKPiAgICBkd19lZG1hX2RldmljZV9yZXN1bWUoKSBhbmQg ZHdfZWRtYV9kZXZpY2VfdGVybWluYXRlX2FsbCgpCj4gUkZDIHYyLT5SRkMgdjM6Cj4gIC0gQWRk IGRyaXZlciBwYXJhbWV0ZXIgdG8gZGlzYWJsZSBtc2l4IGZlYXR1cmUKPiAgLSBGaXggcHJpbnRr IHZhcmlhYmxlIG9mIHBoeXNfYWRkcl90IHR5cGUKPiAgLSBGaXggcHJpbnRrIHZhcmlhYmxlIG9m IF9faW9tZW0gdHlwZQo+ICAtIEZpeCBwcmludGsgdmFyaWFibGUgb2Ygc2l6ZV90IHR5cGUKPiAg LSBBZGQgY29tbWVudHMgb3IgaW1wcm92ZSBleGlzdGluZyBvbmVzCj4gIC0gQWRkIHBvc3NpYmls aXR5IHRvIHdvcmsgd2l0aCBtdWx0aXBsZSBJUlFzIGZlYXR1cmUKPiAgLSBGaXggc291cmNlIGFu ZCBkZXN0aW5hdGlvbiBhZGRyZXNzZXMKPiAgLSBBZGQgZGVmaW5lIHRvIG1hZ2ljIG51bWJlcnMK PiAgLSBBZGQgRE1BIGN5Y2xpYyB0cmFuc2ZlciBmZWF0dXJlCj4gCj4gU2lnbmVkLW9mZi1ieTog R3VzdGF2byBQaW1lbnRlbCA8Z3VzdGF2by5waW1lbnRlbEBzeW5vcHN5cy5jb20+Cj4gQ2M6IFZp bm9kIEtvdWwgPHZrb3VsQGtlcm5lbC5vcmc+Cj4gQ2M6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2ls bGlhbXNAaW50ZWwuY29tPgo+IENjOiBFdWdlbml5IFBhbHRzZXYgPHBhbHRzZXZAc3lub3BzeXMu Y29tPgo+IENjOiBBbmR5IFNoZXZjaGVua28gPGFuZHJpeS5zaGV2Y2hlbmtvQGxpbnV4LmludGVs LmNvbT4KPiBDYzogUnVzc2VsbCBLaW5nIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KPiBD YzogTmlrbGFzIENhc3NlbCA8bmlrbGFzLmNhc3NlbEBsaW5hcm8ub3JnPgo+IENjOiBKb2FvIFBp bnRvIDxqcGludG9Ac3lub3BzeXMuY29tPgo+IENjOiBKb3NlIEFicmV1IDxqb3NlLmFicmV1QHN5 bm9wc3lzLmNvbT4KPiBDYzogTHVpcyBPbGl2ZWlyYSA8bG9saXZlaUBzeW5vcHN5cy5jb20+Cj4g Q2M6IFZpdG9yIFNvYXJlcyA8dml0b3Iuc29hcmVzQHN5bm9wc3lzLmNvbT4KPiBDYzogTmVsc29u IENvc3RhIDxuZWxzb24uY29zdGFAc3lub3BzeXMuY29tPgo+IENjOiBQZWRybyBTb3VzYSA8cGVk cm9tLnNvdXNhQHN5bm9wc3lzLmNvbT4KCgo+ICtzdGF0aWMgc3RydWN0IGR3X2VkbWFfY2h1bmsg KmR3X2VkbWFfYWxsb2NfY2h1bmsoc3RydWN0IGR3X2VkbWFfZGVzYyAqZGVzYykKPiArewo+ICsJ c3RydWN0IGR3X2VkbWFfY2hhbiAqY2hhbiA9IGRlc2MtPmNoYW47Cj4gKwlzdHJ1Y3QgZHdfZWRt YSAqZHcgPSBjaGFuLT5jaGlwLT5kdzsKPiArCXN0cnVjdCBkd19lZG1hX2NodW5rICpjaHVuazsK PiArCj4gKwljaHVuayA9IGt2emFsbG9jKHNpemVvZigqY2h1bmspLCBHRlBfTk9XQUlUKTsKPiAr CWlmICh1bmxpa2VseSghY2h1bmspKQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCUlOSVRfTElT VF9IRUFEKCZjaHVuay0+bGlzdCk7Cj4gKwljaHVuay0+Y2hhbiA9IGNoYW47Cj4gKwljaHVuay0+ Y2IgPSAhKGRlc2MtPmNodW5rc19hbGxvYyAlIDIpOwo+ICsJY2h1bmstPmxsX3JlZ2lvbi5wYWRk ciA9IGR3LT5sbF9yZWdpb24ucGFkZHIgKyBjaGFuLT5sbF9vZmY7Cj4gKwljaHVuay0+bGxfcmVn aW9uLnZhZGRyID0gZHctPmxsX3JlZ2lvbi52YWRkciArIGNoYW4tPmxsX29mZjsKPiArCj4gKwlp ZiAoZGVzYy0+Y2h1bmspIHsKPiArCQkvKiBDcmVhdGUgYW5kIGFkZCBuZXcgZWxlbWVudCBpbnRv IHRoZSBsaW5rZWQgbGlzdCAqLwo+ICsJCWRlc2MtPmNodW5rc19hbGxvYysrOwo+ICsJCWRldl9k YmcoY2hhbjJkZXYoY2hhbiksICJhbGxvYyBuZXcgY2h1bmsgZWxlbWVudCAoJWQpXG4iLAo+ICsJ CQlkZXNjLT5jaHVua3NfYWxsb2MpOwo+ICsJCWxpc3RfYWRkX3RhaWwoJmNodW5rLT5saXN0LCAm ZGVzYy0+Y2h1bmstPmxpc3QpOwo+ICsJCWR3X2VkbWFfYWxsb2NfYnVyc3QoY2h1bmspOwoKTm8g cmV0dXJuIGNoZWNrID8KCj4gKwl9IGVsc2Ugewo+ICsJCS8qIExpc3QgaGVhZCAqLwo+ICsJCWNo dW5rLT5idXJzdCA9IE5VTEw7Cj4gKwkJZGVzYy0+Y2h1bmtzX2FsbG9jID0gMDsKPiArCQlkZXNj LT5jaHVuayA9IGNodW5rOwo+ICsJCWRldl9kYmcoY2hhbjJkZXYoY2hhbiksICJhbGxvYyBuZXcg Y2h1bmsgaGVhZFxuIik7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIGNodW5rOwo+ICt9Cj4gKwo+ICtz dGF0aWMgc3RydWN0IGR3X2VkbWFfZGVzYyAqZHdfZWRtYV9hbGxvY19kZXNjKHN0cnVjdCBkd19l ZG1hX2NoYW4gKmNoYW4pCj4gK3sKPiArCXN0cnVjdCBkd19lZG1hX2Rlc2MgKmRlc2M7Cj4gKwo+ ICsJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwgImFsbG9jIG5ldyBkZXNjcmlwdG9yXG4iKTsKPiAr Cj4gKwlkZXNjID0ga3Z6YWxsb2Moc2l6ZW9mKCpkZXNjKSwgR0ZQX05PV0FJVCk7Cj4gKwlpZiAo dW5saWtlbHkoIWRlc2MpKQo+ICsJCXJldHVybiBOVUxMOwo+ICsKPiArCWRlc2MtPmNoYW4gPSBj aGFuOwo+ICsJZHdfZWRtYV9hbGxvY19jaHVuayhkZXNjKTsKCk5vIHJldHVybiBjaGVjayA/Cgo+ ICsKPiArCXJldHVybiBkZXNjOwo+ICt9Cj4gKwoKPiArc3RhdGljIHZvaWQgZHdfZWRtYV9zdGFy dF90cmFuc2ZlcihzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuKQo+ICt7Cj4gKwlzdHJ1Y3Qgdmly dF9kbWFfZGVzYyAqdmQ7Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9kZXNjICpkZXNjOwo+ICsJc3RydWN0 IGR3X2VkbWFfY2h1bmsgKmNoaWxkOwo+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9vcHMg Km9wcyA9IGNoYW4yb3BzKGNoYW4pOwoKUmV2ZXJzZSB0cmVlIG9yZGVyIGhlcmUgYW5kIGluIHJl bWFpbmluZyBmdW5jdGlvbnMgLi4uCgo+ICsKPiArCXZkID0gdmNoYW5fbmV4dF9kZXNjKCZjaGFu LT52Yyk7Cj4gKwlpZiAoIXZkKQo+ICsJCXJldHVybjsKPiArCj4gKwlkZXNjID0gdmQyZHdfZWRt YV9kZXNjKHZkKTsKPiArCWlmICghZGVzYykKPiArCQlyZXR1cm47Cj4gKwo+ICsJY2hpbGQgPSBs aXN0X2ZpcnN0X2VudHJ5X29yX251bGwoJmRlc2MtPmNodW5rLT5saXN0LAo+ICsJCQkJCSBzdHJ1 Y3QgZHdfZWRtYV9jaHVuaywgbGlzdCk7Cj4gKwlpZiAoIWNoaWxkKQo+ICsJCXJldHVybjsKPiAr Cj4gKwlvcHMtPnN0YXJ0KGNoaWxkLCAhZGVzYy0+eGZlcl9zeik7Cj4gKwlkZXNjLT54ZmVyX3N6 ICs9IGNoaWxkLT5sbF9yZWdpb24uc3o7Cj4gKwlkZXZfZGJnKGNoYW4yZGV2KGNoYW4pLCAidHJh bnNmZXIgb2YgJXUgYnl0ZXMgc3RhcnRlZFxuIiwKPiArCQljaGlsZC0+bGxfcmVnaW9uLnN6KTsK PiArCj4gKwlkd19lZG1hX2ZyZWVfYnVyc3QoY2hpbGQpOwo+ICsJaWYgKGNoaWxkLT5idXJzdHNf YWxsb2MpCj4gKwkJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwJIiV1IGJ1cnN0cyBzdGlsbCBhbGxv Y2F0ZWRcbiIsCj4gKwkJCWNoaWxkLT5idXJzdHNfYWxsb2MpOwo+ICsJbGlzdF9kZWwoJmNoaWxk LT5saXN0KTsKPiArCWt2ZnJlZShjaGlsZCk7Cj4gKwlkZXNjLT5jaHVua3NfYWxsb2MtLTsKPiAr fQo+ICsKCj4gK2ludCBkd19lZG1hX3Byb2JlKHN0cnVjdCBkd19lZG1hX2NoaXAgKmNoaXApCj4g K3sKPiArCXN0cnVjdCBkd19lZG1hICpkdyA9IGNoaXAtPmR3Owo+ICsJc3RydWN0IGRldmljZSAq ZGV2ID0gY2hpcC0+ZGV2Owo+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9vcHMgKm9wczsK PiArCXNpemVfdCBsbF9jaHVuayA9IGR3LT5sbF9yZWdpb24uc3o7Cj4gKwlzaXplX3QgZHRfY2h1 bmsgPSBkdy0+ZHRfcmVnaW9uLnN6Owo+ICsJdTMyIGNoX3RvdDsKPiArCWludCBpLCBqLCBlcnI7 Cj4gKwo+ICsJcmF3X3NwaW5fbG9ja19pbml0KCZkdy0+bG9jayk7CgpXaHkgcmF3ID8KCj4gKwo+ ICsJLyogQ2FsbGJhY2sgb3BlcmF0aW9uIHNlbGVjdGlvbiBhY2NvcmRpbmdseSB0byBlRE1BIHZl cnNpb24gKi8KPiArCXN3aXRjaCAoZHctPnZlcnNpb24pIHsKPiArCWRlZmF1bHQ6Cj4gKwkJZGV2 X2VycihkZXYsICJ1bnN1cHBvcnRlZCB2ZXJzaW9uXG4iKTsKPiArCQlyZXR1cm4gLUVQRVJNOwo+ ICsJfQo+ICsKPiArCXBtX3J1bnRpbWVfZ2V0X3N5bmMoZGV2KTsKCldoeSBkbyB5b3UgbmVlZCB0 byBpbmNyZWFzZSB1c2FnZSBjb3VudCBhdCBwcm9iZSA/IEFuZCBzaG91bGRuJ3QKdGhpcyBiZSBh ZnRlciBwbV9ydW50aW1lX2VuYWJsZSgpID8KCj4gKwo+ICsJLyogRmluZCBvdXQgaG93IG1hbnkg d3JpdGUgY2hhbm5lbHMgYXJlIHN1cHBvcnRlZCBieSBoYXJkd2FyZSAqLwo+ICsJZHctPndyX2No X2NudCA9IG9wcy0+Y2hfY291bnQoZHcsIEVETUFfRElSX1dSSVRFKTsKPiArCWlmICghZHctPndy X2NoX2NudCkgewo+ICsJCWRldl9lcnIoZGV2LCAiaW52YWxpZCBudW1iZXIgb2Ygd3JpdGUgY2hh bm5lbHMoMClcbiIpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCS8qIEZpbmQg b3V0IGhvdyBtYW55IHJlYWQgY2hhbm5lbHMgYXJlIHN1cHBvcnRlZCBieSBoYXJkd2FyZSAqLwo+ ICsJZHctPnJkX2NoX2NudCA9IG9wcy0+Y2hfY291bnQoZHcsIEVETUFfRElSX1JFQUQpOwo+ICsJ aWYgKCFkdy0+cmRfY2hfY250KSB7Cj4gKwkJZGV2X2VycihkZXYsICJpbnZhbGlkIG51bWJlciBv ZiByZWFkIGNoYW5uZWxzKDApXG4iKTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4g KwlkZXZfZGJnKGRldiwgIkNoYW5uZWxzOlx0d3JpdGU9JWQsIHJlYWQ9JWRcbiIsCj4gKwkJZHct PndyX2NoX2NudCwgZHctPnJkX2NoX2NudCk7Cj4gKwo+ICsJY2hfdG90ID0gZHctPndyX2NoX2Nu dCArIGR3LT5yZF9jaF9jbnQ7Cj4gKwo+ICsJLyogQWxsb2NhdGUgY2hhbm5lbHMgKi8KPiArCWR3 LT5jaGFuID0gZGV2bV9rY2FsbG9jKGRldiwgY2hfdG90LCBzaXplb2YoKmR3LT5jaGFuKSwgR0ZQ X0tFUk5FTCk7Cj4gKwlpZiAoIWR3LT5jaGFuKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiAr CS8qIENhbGN1bGF0ZSB0aGUgbGlua2VkIGxpc3QgY2h1bmsgZm9yIGVhY2ggY2hhbm5lbCAqLwo+ ICsJbGxfY2h1bmsgLz0gcm91bmR1cF9wb3dfb2ZfdHdvKGNoX3RvdCk7Cj4gKwo+ICsJLyogQ2Fs Y3VsYXRlIHRoZSBsaW5rZWQgbGlzdCBjaHVuayBmb3IgZWFjaCBjaGFubmVsICovCj4gKwlkdF9j aHVuayAvPSByb3VuZHVwX3Bvd19vZl90d28oY2hfdG90KTsKPiArCj4gKwkvKiBEaXNhYmxlIGVE TUEsIG9ubHkgdG8gZXN0YWJsaXNoIHRoZSBpZGVhbCBpbml0aWFsIGNvbmRpdGlvbnMgKi8KPiAr CW9wcy0+b2ZmKGR3KTsKPiArCj4gKwlzbnByaW50Zihkdy0+bmFtZSwgc2l6ZW9mKGR3LT5uYW1l KSwgImR3LWVkbWEtY29yZTolZCIsIGNoaXAtPmlkKTsKPiArCj4gKwkvKiBSZXF1ZXN0IElSUXMg Ki8KPiArCWlmIChkdy0+bnJfaXJxcyAhPSAxKSB7Cj4gKwkJZGV2X2VycihkZXYsICJpbnZhbGlk IG51bWJlciBvZiBpcnFzICgldSlcbiIsIGR3LT5ucl9pcnFzKTsKPiArCQlyZXR1cm4gLUVJTlZB TDsKPiArCX0KPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgZHctPm5yX2lycXM7IGkrKykgewo+ICsJ CWVyciA9IGRldm1fcmVxdWVzdF9pcnEoZGV2LCBwY2lfaXJxX3ZlY3Rvcih0b19wY2lfZGV2KGRl diksIGkpLAo+ICsJCQkJICAgICAgIGR3X2VkbWFfaW50ZXJydXB0X2FsbCwKPiArCQkJCSAgICAg ICBJUlFGX1NIQVJFRCwgZHctPm5hbWUsIGNoaXApOwo+ICsJCWlmIChlcnIpCj4gKwkJCXJldHVy biBlcnI7Cj4gKwl9Cj4gKwo+ICsJLyogQ3JlYXRlIHdyaXRlIGNoYW5uZWxzICovCj4gKwlJTklU X0xJU1RfSEVBRCgmZHctPndyX2VkbWEuY2hhbm5lbHMpOwo+ICsJZm9yIChpID0gMDsgaSA8IGR3 LT53cl9jaF9jbnQ7IGkrKykgewo+ICsJCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4gPSAmZHct PmNoYW5baV07Cj4gKwkJc3RydWN0IGR3X2VkbWFfcmVnaW9uICpkdF9yZWdpb247Cj4gKwo+ICsJ CWR0X3JlZ2lvbiA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqZHRfcmVnaW9uKSwgR0ZQX0tF Uk5FTCk7Cj4gKwkJaWYgKCFkdF9yZWdpb24pCj4gKwkJCXJldHVybiAtRU5PTUVNOwo+ICsKPiAr CQljaGFuLT52Yy5jaGFuLnByaXZhdGUgPSBkdF9yZWdpb247Cj4gKwo+ICsJCWNoYW4tPmNoaXAg PSBjaGlwOwo+ICsJCWNoYW4tPmlkID0gaTsKPiArCQljaGFuLT5kaXIgPSBFRE1BX0RJUl9XUklU RTsKPiArCQljaGFuLT5jb25maWd1cmVkID0gZmFsc2U7Cj4gKwkJY2hhbi0+cmVxdWVzdCA9IEVE TUFfUkVRX05PTkU7Cj4gKwkJY2hhbi0+c3RhdHVzID0gRURNQV9TVF9JRExFOwo+ICsKPiArCQlj aGFuLT5sbF9vZmYgPSAobGxfY2h1bmsgKiBpKTsKPiArCQljaGFuLT5sbF9tYXggPSAobGxfY2h1 bmsgLyBFRE1BX0xMX1NaKSAtIDE7Cj4gKwo+ICsJCWNoYW4tPmR0X29mZiA9IChkdF9jaHVuayAq IGkpOwo+ICsKPiArCQlkZXZfZGJnKGRldiwgIkwuIExpc3Q6XHRDaGFubmVsIHdyaXRlWyV1XSBv ZmY9MHglLjhseCwgbWF4X2NudD0ldVxuIiwKPiArCQkJaSwgY2hhbi0+bGxfb2ZmLCBjaGFuLT5s bF9tYXgpOwo+ICsKPiArCQltZW1jcHkoJmNoYW4tPm1zaSwgJmR3LT5tc2lbMF0sIHNpemVvZihj aGFuLT5tc2kpKTsKPiArCj4gKwkJZGV2X2RiZyhkZXYsICJNU0k6XHRcdENoYW5uZWwgd3JpdGVb JXVdIGFkZHI9MHglLjh4JS44eCwgZGF0YT0weCUuOHhcbiIsCj4gKwkJCWksIGNoYW4tPm1zaS5h ZGRyZXNzX2hpLCBjaGFuLT5tc2kuYWRkcmVzc19sbywKPiArCQkJY2hhbi0+bXNpLmRhdGEpOwo+ ICsKPiArCQljaGFuLT52Yy5kZXNjX2ZyZWUgPSB2Y2hhbl9mcmVlX2Rlc2M7Cj4gKwkJdmNoYW5f aW5pdCgmY2hhbi0+dmMsICZkdy0+d3JfZWRtYSk7Cj4gKwo+ICsJCWR0X3JlZ2lvbi0+cGFkZHIg PSBkdy0+ZHRfcmVnaW9uLnBhZGRyICsgY2hhbi0+ZHRfb2ZmOwo+ICsJCWR0X3JlZ2lvbi0+dmFk ZHIgPSBkdy0+ZHRfcmVnaW9uLnZhZGRyICsgY2hhbi0+ZHRfb2ZmOwo+ICsJCWR0X3JlZ2lvbi0+ c3ogPSBkdF9jaHVuazsKPiArCj4gKwkJZGV2X2RiZyhkZXYsICJEYXRhOlx0Q2hhbm5lbCB3cml0 ZVsldV0gb2ZmPTB4JS44bHhcbiIsCj4gKwkJCWksIGNoYW4tPmR0X29mZik7Cj4gKwl9Cj4gKwlk bWFfY2FwX3plcm8oZHctPndyX2VkbWEuY2FwX21hc2spOwo+ICsJZG1hX2NhcF9zZXQoRE1BX1NM QVZFLCBkdy0+d3JfZWRtYS5jYXBfbWFzayk7Cj4gKwlkbWFfY2FwX3NldChETUFfQ1lDTElDLCBk dy0+d3JfZWRtYS5jYXBfbWFzayk7Cj4gKwlkdy0+d3JfZWRtYS5kaXJlY3Rpb25zID0gQklUKERN QV9ERVZfVE9fTUVNKTsKPiArCWR3LT53cl9lZG1hLmNoYW5jbnQgPSBkdy0+d3JfY2hfY250Owo+ ICsKPiArCS8qIENyZWF0ZSByZWFkIGNoYW5uZWxzICovCj4gKwlJTklUX0xJU1RfSEVBRCgmZHct PnJkX2VkbWEuY2hhbm5lbHMpOwo+ICsJZm9yIChqID0gMDsgaiA8IGR3LT5yZF9jaF9jbnQ7IGor KywgaSsrKSB7Cj4gKwkJc3RydWN0IGR3X2VkbWFfY2hhbiAqY2hhbiA9ICZkdy0+Y2hhbltpXTsK PiArCQlzdHJ1Y3QgZHdfZWRtYV9yZWdpb24gKmR0X3JlZ2lvbjsKPiArCj4gKwkJZHRfcmVnaW9u ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpkdF9yZWdpb24pLCBHRlBfS0VSTkVMKTsKPiAr CQlpZiAoIWR0X3JlZ2lvbikKPiArCQkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJCWNoYW4tPnZj LmNoYW4ucHJpdmF0ZSA9IGR0X3JlZ2lvbjsKPiArCj4gKwkJY2hhbi0+Y2hpcCA9IGNoaXA7Cj4g KwkJY2hhbi0+aWQgPSBqOwo+ICsJCWNoYW4tPmRpciA9IEVETUFfRElSX1JFQUQ7Cj4gKwkJY2hh bi0+Y29uZmlndXJlZCA9IGZhbHNlOwo+ICsJCWNoYW4tPnJlcXVlc3QgPSBFRE1BX1JFUV9OT05F Owo+ICsJCWNoYW4tPnN0YXR1cyA9IEVETUFfU1RfSURMRTsKPiArCj4gKwkJY2hhbi0+bGxfb2Zm ID0gKGxsX2NodW5rICogaSk7Cj4gKwkJY2hhbi0+bGxfbWF4ID0gKGxsX2NodW5rIC8gRURNQV9M TF9TWikgLSAxOwo+ICsKPiArCQljaGFuLT5kdF9vZmYgPSAoZHRfY2h1bmsgKiBpKTsKPiArCj4g KwkJZGV2X2RiZyhkZXYsICJMLiBMaXN0Olx0Q2hhbm5lbCByZWFkWyV1XSBvZmY9MHglLjhseCwg bWF4X2NudD0ldVxuIiwKPiArCQkJaiwgY2hhbi0+bGxfb2ZmLCBjaGFuLT5sbF9tYXgpOwo+ICsK PiArCQltZW1jcHkoJmNoYW4tPm1zaSwgJmR3LT5tc2lbMF0sIHNpemVvZihjaGFuLT5tc2kpKTsK PiArCj4gKwkJZGV2X2RiZyhkZXYsICJNU0k6XHRcdENoYW5uZWwgcmVhZFsldV0gYWRkcj0weCUu OHglLjh4LCBkYXRhPTB4JS44eFxuIiwKPiArCQkJaiwgY2hhbi0+bXNpLmFkZHJlc3NfaGksIGNo YW4tPm1zaS5hZGRyZXNzX2xvLAo+ICsJCQljaGFuLT5tc2kuZGF0YSk7Cj4gKwo+ICsJCWNoYW4t PnZjLmRlc2NfZnJlZSA9IHZjaGFuX2ZyZWVfZGVzYzsKPiArCQl2Y2hhbl9pbml0KCZjaGFuLT52 YywgJmR3LT5yZF9lZG1hKTsKPiArCj4gKwkJZHRfcmVnaW9uLT5wYWRkciA9IGR3LT5kdF9yZWdp b24ucGFkZHIgKyBjaGFuLT5kdF9vZmY7Cj4gKwkJZHRfcmVnaW9uLT52YWRkciA9IGR3LT5kdF9y ZWdpb24udmFkZHIgKyBjaGFuLT5kdF9vZmY7Cj4gKwkJZHRfcmVnaW9uLT5zeiA9IGR0X2NodW5r Owo+ICsKPiArCQlkZXZfZGJnKGRldiwgIkRhdGE6XHRDaGFubmVsIHJlYWRbJXVdIG9mZj0weCUu OGx4XG4iLAo+ICsJCQlpLCBjaGFuLT5kdF9vZmYpOwo+ICsJfQo+ICsJZG1hX2NhcF96ZXJvKGR3 LT5yZF9lZG1hLmNhcF9tYXNrKTsKPiArCWRtYV9jYXBfc2V0KERNQV9TTEFWRSwgZHctPnJkX2Vk bWEuY2FwX21hc2spOwo+ICsJZG1hX2NhcF9zZXQoRE1BX0NZQ0xJQywgZHctPnJkX2VkbWEuY2Fw X21hc2spOwo+ICsJZHctPnJkX2VkbWEuZGlyZWN0aW9ucyA9IEJJVChETUFfTUVNX1RPX0RFVik7 Cj4gKwlkdy0+cmRfZWRtYS5jaGFuY250ID0gZHctPnJkX2NoX2NudDsKPiArCj4gKwkvKiBTZXQg RE1BIGNoYW5uZWxzICBjYXBhYmlsaXRpZXMgKi8KPiArCVNFVF9CT1RIX0NIKHNyY19hZGRyX3dp ZHRocywgQklUKERNQV9TTEFWRV9CVVNXSURUSF80X0JZVEVTKSk7Cj4gKwlTRVRfQk9USF9DSChk c3RfYWRkcl93aWR0aHMsIEJJVChETUFfU0xBVkVfQlVTV0lEVEhfNF9CWVRFUykpOwo+ICsJU0VU X0JPVEhfQ0gocmVzaWR1ZV9ncmFudWxhcml0eSwgRE1BX1JFU0lEVUVfR1JBTlVMQVJJVFlfREVT Q1JJUFRPUik7Cj4gKwo+ICsJU0VUX0JPVEhfQ0goZGV2LCBkZXYpOwo+ICsKPiArCVNFVF9CT1RI X0NIKGRldmljZV9hbGxvY19jaGFuX3Jlc291cmNlcywgZHdfZWRtYV9hbGxvY19jaGFuX3Jlc291 cmNlcyk7Cj4gKwlTRVRfQk9USF9DSChkZXZpY2VfZnJlZV9jaGFuX3Jlc291cmNlcywgZHdfZWRt YV9mcmVlX2NoYW5fcmVzb3VyY2VzKTsKPiArCj4gKwlTRVRfQk9USF9DSChkZXZpY2VfY29uZmln LCBkd19lZG1hX2RldmljZV9jb25maWcpOwo+ICsJU0VUX0JPVEhfQ0goZGV2aWNlX3BhdXNlLCBk d19lZG1hX2RldmljZV9wYXVzZSk7Cj4gKwlTRVRfQk9USF9DSChkZXZpY2VfcmVzdW1lLCBkd19l ZG1hX2RldmljZV9yZXN1bWUpOwo+ICsJU0VUX0JPVEhfQ0goZGV2aWNlX3Rlcm1pbmF0ZV9hbGws IGR3X2VkbWFfZGV2aWNlX3Rlcm1pbmF0ZV9hbGwpOwo+ICsJU0VUX0JPVEhfQ0goZGV2aWNlX2lz c3VlX3BlbmRpbmcsIGR3X2VkbWFfZGV2aWNlX2lzc3VlX3BlbmRpbmcpOwo+ICsJU0VUX0JPVEhf Q0goZGV2aWNlX3R4X3N0YXR1cywgZHdfZWRtYV9kZXZpY2VfdHhfc3RhdHVzKTsKPiArCVNFVF9C T1RIX0NIKGRldmljZV9wcmVwX3NsYXZlX3NnLCBkd19lZG1hX2RldmljZV9wcmVwX3NsYXZlX3Nn KTsKPiArCVNFVF9CT1RIX0NIKGRldmljZV9wcmVwX2RtYV9jeWNsaWMsIGR3X2VkbWFfZGV2aWNl X3ByZXBfZG1hX2N5Y2xpYyk7Cj4gKwo+ICsJLyogUG93ZXIgbWFuYWdlbWVudCAqLwo+ICsJcG1f cnVudGltZV9lbmFibGUoZGV2KTsKPiArCj4gKwkvKiBSZWdpc3RlciBETUEgZGV2aWNlICovCj4g KwllcnIgPSBkbWFfYXN5bmNfZGV2aWNlX3JlZ2lzdGVyKCZkdy0+d3JfZWRtYSk7Cj4gKwlpZiAo ZXJyKQo+ICsJCWdvdG8gZXJyX3BtX2Rpc2FibGU7Cj4gKwo+ICsJZXJyID0gZG1hX2FzeW5jX2Rl dmljZV9yZWdpc3RlcigmZHctPnJkX2VkbWEpOwo+ICsJaWYgKGVycikKPiArCQlnb3RvIGVycl9w bV9kaXNhYmxlOwo+ICsKPiArCS8qIFR1cm4gZGVidWdmcyBvbiAqLwo+ICsJZXJyID0gb3BzLT5k ZWJ1Z2ZzX29uKGNoaXApOwo+ICsJaWYgKGVycikgewo+ICsJCWRldl9lcnIoZGV2LCAidW5hYmxl IHRvIGNyZWF0ZSBkZWJ1Z2ZzIHN0cnVjdHVyZVxuIik7Cj4gKwkJZ290byBlcnJfcG1fZGlzYWJs ZTsKPiArCX0KPiArCj4gKwlkZXZfaW5mbyhkZXYsICJEZXNpZ25XYXJlIGVETUEgY29udHJvbGxl ciBkcml2ZXIgbG9hZGVkIGNvbXBsZXRlbHlcbiIpOwo+ICsKPiArCXJldHVybiAwOwo+ICsKPiAr ZXJyX3BtX2Rpc2FibGU6Cj4gKwlwbV9ydW50aW1lX2Rpc2FibGUoZGV2KTsKPiArCj4gKwlyZXR1 cm4gZXJyOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKGR3X2VkbWFfcHJvYmUpOwo+ICsKPiAr aW50IGR3X2VkbWFfcmVtb3ZlKHN0cnVjdCBkd19lZG1hX2NoaXAgKmNoaXApCj4gK3sKPiArCXN0 cnVjdCBkd19lZG1hICpkdyA9IGNoaXAtPmR3Owo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gY2hp cC0+ZGV2Owo+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9vcHMgKm9wcyA9IGR3LT5vcHM7 Cj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuLCAqX2NoYW47Cj4gKwlpbnQgaTsKPiArCj4g KwkvKiBEaXNhYmxlIGVETUEgKi8KPiArCWlmIChvcHMpCj4gKwkJb3BzLT5vZmYoZHcpOwo+ICsK PiArCS8qIEZyZWUgaXJxcyAqLwoKQnV0IGRldm0gd2lsbCBhdXRvbWF0aWNhbGx5IGZyZWUgaXQs IG5vID8KCj4gKwlmb3IgKGkgPSAwOyBpIDwgZHctPm5yX2lycXM7IGkrKykgewo+ICsJCWlmIChw Y2lfaXJxX3ZlY3Rvcih0b19wY2lfZGV2KGRldiksIGkpIDwgMCkKPiArCQkJY29udGludWU7Cj4g Kwo+ICsJCWRldm1fZnJlZV9pcnEoZGV2LCBwY2lfaXJxX3ZlY3Rvcih0b19wY2lfZGV2KGRldiks IGkpLCBjaGlwKTsKPiArCX0KPiArCj4gKwkvKiBQb3dlciBtYW5hZ2VtZW50ICovCj4gKwlwbV9y dW50aW1lX2Rpc2FibGUoZGV2KTsKPiArCj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY2hh biwgX2NoYW4sICZkdy0+d3JfZWRtYS5jaGFubmVscywKPiArCQkJCSB2Yy5jaGFuLmRldmljZV9u b2RlKSB7Cj4gKwkJbGlzdF9kZWwoJmNoYW4tPnZjLmNoYW4uZGV2aWNlX25vZGUpOwo+ICsJCXRh c2tsZXRfa2lsbCgmY2hhbi0+dmMudGFzayk7Cj4gKwl9Cj4gKwo+ICsJbGlzdF9mb3JfZWFjaF9l bnRyeV9zYWZlKGNoYW4sIF9jaGFuLCAmZHctPnJkX2VkbWEuY2hhbm5lbHMsCj4gKwkJCQkgdmMu Y2hhbi5kZXZpY2Vfbm9kZSkgewo+ICsJCWxpc3RfZGVsKCZjaGFuLT52Yy5jaGFuLmRldmljZV9u b2RlKTsKPiArCQl0YXNrbGV0X2tpbGwoJmNoYW4tPnZjLnRhc2spOwo+ICsJfQo+ICsKPiArCS8q IERlcmVnaXN0ZXIgZURNQSBkZXZpY2UgKi8KPiArCWRtYV9hc3luY19kZXZpY2VfdW5yZWdpc3Rl cigmZHctPndyX2VkbWEpOwo+ICsJZG1hX2FzeW5jX2RldmljZV91bnJlZ2lzdGVyKCZkdy0+cmRf ZWRtYSk7Cj4gKwo+ICsJLyogVHVybiBkZWJ1Z2ZzIG9mZiAqLwo+ICsJaWYgKG9wcykKPiArCQlv cHMtPmRlYnVnZnNfb2ZmKCk7Cj4gKwo+ICsJZGV2X2luZm8oZGV2LCAiRGVzaWduV2FyZSBlRE1B IGNvbnRyb2xsZXIgZHJpdmVyIHVubG9hZGVkIGNvbXBsZXRlXG4iKTsKPiArCj4gKwlyZXR1cm4g MDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChkd19lZG1hX3JlbW92ZSk7Cg== 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=-4.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED 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 3930AC43387 for ; Wed, 16 Jan 2019 10:21:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E8FDE20859 for ; Wed, 16 Jan 2019 10:21:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=synopsys.com header.i=@synopsys.com header.b="HaA9RfSP" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2391918AbfAPKVo (ORCPT ); Wed, 16 Jan 2019 05:21:44 -0500 Received: from smtprelay.synopsys.com ([198.182.47.9]:45454 "EHLO smtprelay.synopsys.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1732324AbfAPKVn (ORCPT ); Wed, 16 Jan 2019 05:21:43 -0500 Received: from mailhost.synopsys.com (mailhost1.synopsys.com [10.12.238.239]) by smtprelay.synopsys.com (Postfix) with ESMTP id 887AC24E0F8F; Wed, 16 Jan 2019 02:21:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=synopsys.com; s=mail; t=1547634102; bh=WdrT+bhsgDldBip6DNSzWaNovAKMYEoXNu8pbtfXhsE=; h=Subject:To:CC:References:From:Date:In-Reply-To:From; b=HaA9RfSPslMUGAZwfnWsj+AsVEl4oxVcMZlwr9vACyRSKB0s4KyWvejHvSslwGiJc VG6ZdMXBuE2y9QFIDg8HyOkOwNm5QPAY8egA3R8Hd0K6DywvpFIOOOPFOVPCGknstv nY7UOwpgJYQQhKt+fQ0SAjAlm9kEYIY1WdDfUTHTiGLjZnPQ0OptCkxdQc2PmUV4CQ LKeM6dSlrFZyJGNpiZaj+2vasds3Se/OC3lPRtncIer0bnhpYYIbYTlWRpuRYnaFh9 LFszxWgu42u1/RNZJe+fozlxI7ZgyH+GQdN6uI1ZnYcKldzkvRR6zTAhpWKrBbJPsZ yWvmFiUx1q8xQ== Received: from us01wehtc1.internal.synopsys.com (us01wehtc1-vip.internal.synopsys.com [10.12.239.236]) by mailhost.synopsys.com (Postfix) with ESMTP id 8252B588C; Wed, 16 Jan 2019 02:21:41 -0800 (PST) Received: from DE02WEHTCB.internal.synopsys.com (10.225.19.94) by us01wehtc1.internal.synopsys.com (10.12.239.231) with Microsoft SMTP Server (TLS) id 14.3.408.0; Wed, 16 Jan 2019 02:21:41 -0800 Received: from DE02WEHTCA.internal.synopsys.com (10.225.19.92) by DE02WEHTCB.internal.synopsys.com (10.225.19.94) with Microsoft SMTP Server (TLS) id 14.3.408.0; Wed, 16 Jan 2019 11:21:39 +0100 Received: from [10.107.19.24] (10.107.19.24) by DE02WEHTCA.internal.synopsys.com (10.225.19.80) with Microsoft SMTP Server (TLS) id 14.3.408.0; Wed, 16 Jan 2019 11:21:38 +0100 Subject: Re: [RFC v3 1/7] dmaengine: Add Synopsys eDMA IP core driver To: Gustavo Pimentel , , CC: Vinod Koul , Dan Williams , Eugeniy Paltsev , Andy Shevchenko , Russell King , Niklas Cassel , Joao Pinto , Jose Abreu , Luis Oliveira , Vitor Soares , Nelson Costa , "Pedro Sousa" References: From: Jose Abreu Message-ID: Date: Wed, 16 Jan 2019 10:21:35 +0000 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:60.0) Gecko/20100101 Thunderbird/60.4.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset="utf-8" Content-Language: en-US Content-Transfer-Encoding: 7bit X-Originating-IP: [10.107.19.24] Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org Hi Gustavo, On 1/11/2019 6:33 PM, 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. > > 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: > - Replace comments // (C99 style) by /**/ > - Fix the headers of the .c and .h files according to the most recent > convention > - Fix errors and checks pointed out by checkpatch with --strict option > - Replace patch small description tag from dma by dmaengine > - Change some dev_info() into dev_dbg() > - Remove unnecessary zero initialization after kzalloc > - Remove direction validation on config() API, since the direction > parameter is deprecated > - Refactor code to replace atomic_t by u32 variable type > - Replace start_transfer() name by dw_edma_start_transfer() > - Add spinlock to dw_edma_device_prep_slave_sg() > - Add spinlock to dw_edma_free_chunk() > - Simplify switch case into if on dw_edma_device_pause(), > dw_edma_device_resume() and dw_edma_device_terminate_all() > RFC v2->RFC v3: > - Add driver parameter to disable msix feature > - Fix printk variable of phys_addr_t type > - Fix printk variable of __iomem type > - Fix printk variable of size_t type > - Add comments or improve existing ones > - Add possibility to work with multiple IRQs feature > - Fix source and destination addresses > - Add define to magic numbers > - Add DMA cyclic transfer feature > > Signed-off-by: Gustavo Pimentel > Cc: Vinod Koul > Cc: Dan Williams > Cc: Eugeniy Paltsev > Cc: Andy Shevchenko > Cc: Russell King > Cc: Niklas Cassel > Cc: Joao Pinto > Cc: Jose Abreu > Cc: Luis Oliveira > Cc: Vitor Soares > Cc: Nelson Costa > Cc: Pedro Sousa > +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); > + chunk->ll_region.paddr = dw->ll_region.paddr + chan->ll_off; > + chunk->ll_region.vaddr = dw->ll_region.vaddr + chan->ll_off; > + > + if (desc->chunk) { > + /* Create and add new element into the linked list */ > + desc->chunks_alloc++; > + dev_dbg(chan2dev(chan), "alloc new chunk element (%d)\n", > + desc->chunks_alloc); > + list_add_tail(&chunk->list, &desc->chunk->list); > + dw_edma_alloc_burst(chunk); No return check ? > + } else { > + /* List head */ > + chunk->burst = NULL; > + desc->chunks_alloc = 0; > + desc->chunk = chunk; > + dev_dbg(chan2dev(chan), "alloc new chunk head\n"); > + } > + > + return chunk; > +} > + > +static struct dw_edma_desc *dw_edma_alloc_desc(struct dw_edma_chan *chan) > +{ > + struct dw_edma_desc *desc; > + > + dev_dbg(chan2dev(chan), "alloc new descriptor\n"); > + > + desc = kvzalloc(sizeof(*desc), GFP_NOWAIT); > + if (unlikely(!desc)) > + return NULL; > + > + desc->chan = chan; > + dw_edma_alloc_chunk(desc); No return check ? > + > + return desc; > +} > + > +static void dw_edma_start_transfer(struct dw_edma_chan *chan) > +{ > + struct virt_dma_desc *vd; > + struct dw_edma_desc *desc; > + struct dw_edma_chunk *child; > + const struct dw_edma_core_ops *ops = chan2ops(chan); Reverse tree order here and in remaining functions ... > + > + vd = vchan_next_desc(&chan->vc); > + if (!vd) > + return; > + > + desc = vd2dw_edma_desc(vd); > + if (!desc) > + return; > + > + child = list_first_entry_or_null(&desc->chunk->list, > + struct dw_edma_chunk, list); > + if (!child) > + return; > + > + ops->start(child, !desc->xfer_sz); > + desc->xfer_sz += child->ll_region.sz; > + dev_dbg(chan2dev(chan), "transfer of %u bytes started\n", > + child->ll_region.sz); > + > + dw_edma_free_burst(child); > + if (child->bursts_alloc) > + dev_dbg(chan2dev(chan), "%u bursts still allocated\n", > + child->bursts_alloc); > + list_del(&child->list); > + kvfree(child); > + desc->chunks_alloc--; > +} > + > +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); Why raw ? > + > + /* Callback operation selection accordingly to eDMA version */ > + switch (dw->version) { > + default: > + dev_err(dev, "unsupported version\n"); > + return -EPERM; > + } > + > + pm_runtime_get_sync(dev); Why do you need to increase usage count at probe ? And shouldn't this be after pm_runtime_enable() ? > + > + /* 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); > + 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); > + } > + dma_cap_zero(dw->rd_edma.cap_mask); > + dma_cap_set(DMA_SLAVE, dw->rd_edma.cap_mask); > + dma_cap_set(DMA_CYCLIC, dw->rd_edma.cap_mask); > + dw->rd_edma.directions = BIT(DMA_MEM_TO_DEV); > + dw->rd_edma.chancnt = dw->rd_ch_cnt; > + > + /* Set DMA channels capabilities */ > + SET_BOTH_CH(src_addr_widths, BIT(DMA_SLAVE_BUSWIDTH_4_BYTES)); > + SET_BOTH_CH(dst_addr_widths, BIT(DMA_SLAVE_BUSWIDTH_4_BYTES)); > + SET_BOTH_CH(residue_granularity, DMA_RESIDUE_GRANULARITY_DESCRIPTOR); > + > + SET_BOTH_CH(dev, dev); > + > + SET_BOTH_CH(device_alloc_chan_resources, dw_edma_alloc_chan_resources); > + SET_BOTH_CH(device_free_chan_resources, dw_edma_free_chan_resources); > + > + SET_BOTH_CH(device_config, dw_edma_device_config); > + SET_BOTH_CH(device_pause, dw_edma_device_pause); > + SET_BOTH_CH(device_resume, dw_edma_device_resume); > + SET_BOTH_CH(device_terminate_all, dw_edma_device_terminate_all); > + SET_BOTH_CH(device_issue_pending, dw_edma_device_issue_pending); > + SET_BOTH_CH(device_tx_status, dw_edma_device_tx_status); > + SET_BOTH_CH(device_prep_slave_sg, dw_edma_device_prep_slave_sg); > + SET_BOTH_CH(device_prep_dma_cyclic, dw_edma_device_prep_dma_cyclic); > + > + /* Power management */ > + pm_runtime_enable(dev); > + > + /* Register DMA device */ > + err = dma_async_device_register(&dw->wr_edma); > + if (err) > + goto err_pm_disable; > + > + err = dma_async_device_register(&dw->rd_edma); > + if (err) > + goto err_pm_disable; > + > + /* Turn debugfs on */ > + err = ops->debugfs_on(chip); > + if (err) { > + dev_err(dev, "unable to create debugfs structure\n"); > + goto err_pm_disable; > + } > + > + dev_info(dev, "DesignWare eDMA controller driver loaded completely\n"); > + > + return 0; > + > +err_pm_disable: > + pm_runtime_disable(dev); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(dw_edma_probe); > + > +int dw_edma_remove(struct dw_edma_chip *chip) > +{ > + struct dw_edma *dw = chip->dw; > + struct device *dev = chip->dev; > + const struct dw_edma_core_ops *ops = dw->ops; > + struct dw_edma_chan *chan, *_chan; > + int i; > + > + /* Disable eDMA */ > + if (ops) > + ops->off(dw); > + > + /* Free irqs */ But devm will automatically free it, no ? > + for (i = 0; i < dw->nr_irqs; i++) { > + if (pci_irq_vector(to_pci_dev(dev), i) < 0) > + continue; > + > + devm_free_irq(dev, pci_irq_vector(to_pci_dev(dev), i), chip); > + } > + > + /* Power management */ > + pm_runtime_disable(dev); > + > + list_for_each_entry_safe(chan, _chan, &dw->wr_edma.channels, > + vc.chan.device_node) { > + list_del(&chan->vc.chan.device_node); > + tasklet_kill(&chan->vc.task); > + } > + > + list_for_each_entry_safe(chan, _chan, &dw->rd_edma.channels, > + vc.chan.device_node) { > + list_del(&chan->vc.chan.device_node); > + tasklet_kill(&chan->vc.task); > + } > + > + /* Deregister eDMA device */ > + dma_async_device_unregister(&dw->wr_edma); > + dma_async_device_unregister(&dw->rd_edma); > + > + /* Turn debugfs off */ > + if (ops) > + ops->debugfs_off(); > + > + dev_info(dev, "DesignWare eDMA controller driver unloaded complete\n"); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(dw_edma_remove);