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: Gustavo Pimentel Message-Id: Date: Wed, 16 Jan 2019 11:53:00 +0000 To: Jose Abreu , 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 , Luis de Oliveira , Vitor Soares , Nelson Costa , Pedro Sousa List-ID: SGkgSm9zZSwKCk9uIDE2LzAxLzIwMTkgMTA6MjEsIEpvc2UgQWJyZXUgd3JvdGU6Cj4gSGkgR3Vz dGF2bywKPiAKPiBPbiAxLzExLzIwMTkgNjozMyBQTSwgR3VzdGF2byBQaW1lbnRlbCB3cm90ZToK Pj4gQWRkIFN5bm9wc3lzIGVETUEgSVAgY29yZSBkcml2ZXIgdG8ga2VybmVsLgo+Pgo+PiBUaGlz IGNvcmUgZHJpdmVyLCBpbml0aWFsaXplcyBhbmQgY29uZmlndXJlcyB0aGUgZURNQSBJUCB1c2lu ZyB2bWEtaGVscGVycwo+PiBmdW5jdGlvbnMgYW5kIGRtYS1lbmdpbmUgc3Vic3lzdGVtLgo+Pgo+ PiBBbHNvIGNyZWF0ZXMgYW4gYWJzdHJhdGlvbiBsYXllciB0aHJvdWdoIGNhbGxiYWNrcyBhbGxv d2luZyBkaWZmZXJlbnQKPj4gcmVnaXN0ZXJzIG1hcHBpbmdzIGluIHRoZSBmdXR1cmUsIG9yZ2Fu aXplZCBpbiB0byB2ZXJzaW9ucy4KPj4KPj4gVGhpcyBkcml2ZXIgY2FuIGJlIGNvbXBpbGUgYXMg YnVpbHQtaW4gb3IgZXh0ZXJuYWwgbW9kdWxlIGluIGtlcm5lbC4KPj4KPj4gVG8gZW5hYmxlIHRo aXMgZHJpdmVyIGp1c3Qgc2VsZWN0IERXX0VETUEgb3B0aW9uIGluIGtlcm5lbCBjb25maWd1cmF0 aW9uLAo+PiBob3dldmVyIGl0IHJlcXVpcmVzIGFuZCBzZWxlY3RzIGF1dG9tYXRpY2FsbHkgRE1B X0VOR0lORSBhbmQKPj4gRE1BX1ZJUlRVQUxfQ0hBTk5FTFMgb3B0aW9uIHRvby4KPj4KPj4gQ2hh bmdlczoKPj4gUkZDIHYxLT5SRkMgdjI6Cj4+ICAtIFJlcGxhY2UgY29tbWVudHMgLy8gKEM5OSBz dHlsZSkgYnkgLyoqLwo+PiAgLSBGaXggdGhlIGhlYWRlcnMgb2YgdGhlIC5jIGFuZCAuaCBmaWxl cyBhY2NvcmRpbmcgdG8gdGhlIG1vc3QgcmVjZW50Cj4+ICAgIGNvbnZlbnRpb24KPj4gIC0gRml4 IGVycm9ycyBhbmQgY2hlY2tzIHBvaW50ZWQgb3V0IGJ5IGNoZWNrcGF0Y2ggd2l0aCAtLXN0cmlj dCBvcHRpb24KPj4gIC0gUmVwbGFjZSBwYXRjaCBzbWFsbCBkZXNjcmlwdGlvbiB0YWcgZnJvbSBk bWEgYnkgZG1hZW5naW5lCj4+ICAtIENoYW5nZSBzb21lIGRldl9pbmZvKCkgaW50byBkZXZfZGJn KCkKPj4gIC0gUmVtb3ZlIHVubmVjZXNzYXJ5IHplcm8gaW5pdGlhbGl6YXRpb24gYWZ0ZXIga3ph bGxvYwo+PiAgLSBSZW1vdmUgZGlyZWN0aW9uIHZhbGlkYXRpb24gb24gY29uZmlnKCkgQVBJLCBz aW5jZSB0aGUgZGlyZWN0aW9uCj4+ICAgIHBhcmFtZXRlciBpcyBkZXByZWNhdGVkCj4+ICAtIFJl ZmFjdG9yIGNvZGUgdG8gcmVwbGFjZSBhdG9taWNfdCBieSB1MzIgdmFyaWFibGUgdHlwZQo+PiAg LSBSZXBsYWNlIHN0YXJ0X3RyYW5zZmVyKCkgbmFtZSBieSBkd19lZG1hX3N0YXJ0X3RyYW5zZmVy KCkKPj4gIC0gQWRkIHNwaW5sb2NrIHRvIGR3X2VkbWFfZGV2aWNlX3ByZXBfc2xhdmVfc2coKQo+ PiAgLSBBZGQgc3BpbmxvY2sgdG8gZHdfZWRtYV9mcmVlX2NodW5rKCkKPj4gIC0gU2ltcGxpZnkg c3dpdGNoIGNhc2UgaW50byBpZiBvbiBkd19lZG1hX2RldmljZV9wYXVzZSgpLAo+PiAgICBkd19l ZG1hX2RldmljZV9yZXN1bWUoKSBhbmQgZHdfZWRtYV9kZXZpY2VfdGVybWluYXRlX2FsbCgpCj4+ IFJGQyB2Mi0+UkZDIHYzOgo+PiAgLSBBZGQgZHJpdmVyIHBhcmFtZXRlciB0byBkaXNhYmxlIG1z aXggZmVhdHVyZQo+PiAgLSBGaXggcHJpbnRrIHZhcmlhYmxlIG9mIHBoeXNfYWRkcl90IHR5cGUK Pj4gIC0gRml4IHByaW50ayB2YXJpYWJsZSBvZiBfX2lvbWVtIHR5cGUKPj4gIC0gRml4IHByaW50 ayB2YXJpYWJsZSBvZiBzaXplX3QgdHlwZQo+PiAgLSBBZGQgY29tbWVudHMgb3IgaW1wcm92ZSBl eGlzdGluZyBvbmVzCj4+ICAtIEFkZCBwb3NzaWJpbGl0eSB0byB3b3JrIHdpdGggbXVsdGlwbGUg SVJRcyBmZWF0dXJlCj4+ICAtIEZpeCBzb3VyY2UgYW5kIGRlc3RpbmF0aW9uIGFkZHJlc3Nlcwo+ PiAgLSBBZGQgZGVmaW5lIHRvIG1hZ2ljIG51bWJlcnMKPj4gIC0gQWRkIERNQSBjeWNsaWMgdHJh bnNmZXIgZmVhdHVyZQo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBHdXN0YXZvIFBpbWVudGVsIDxndXN0 YXZvLnBpbWVudGVsQHN5bm9wc3lzLmNvbT4KPj4gQ2M6IFZpbm9kIEtvdWwgPHZrb3VsQGtlcm5l bC5vcmc+Cj4+IENjOiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4KPj4g Q2M6IEV1Z2VuaXkgUGFsdHNldiA8cGFsdHNldkBzeW5vcHN5cy5jb20+Cj4+IENjOiBBbmR5IFNo ZXZjaGVua28gPGFuZHJpeS5zaGV2Y2hlbmtvQGxpbnV4LmludGVsLmNvbT4KPj4gQ2M6IFJ1c3Nl bGwgS2luZyA8cm1rK2tlcm5lbEBhcm1saW51eC5vcmcudWs+Cj4+IENjOiBOaWtsYXMgQ2Fzc2Vs IDxuaWtsYXMuY2Fzc2VsQGxpbmFyby5vcmc+Cj4+IENjOiBKb2FvIFBpbnRvIDxqcGludG9Ac3lu b3BzeXMuY29tPgo+PiBDYzogSm9zZSBBYnJldSA8am9zZS5hYnJldUBzeW5vcHN5cy5jb20+Cj4+ IENjOiBMdWlzIE9saXZlaXJhIDxsb2xpdmVpQHN5bm9wc3lzLmNvbT4KPj4gQ2M6IFZpdG9yIFNv YXJlcyA8dml0b3Iuc29hcmVzQHN5bm9wc3lzLmNvbT4KPj4gQ2M6IE5lbHNvbiBDb3N0YSA8bmVs c29uLmNvc3RhQHN5bm9wc3lzLmNvbT4KPj4gQ2M6IFBlZHJvIFNvdXNhIDxwZWRyb20uc291c2FA c3lub3BzeXMuY29tPgo+IAo+IAo+PiArc3RhdGljIHN0cnVjdCBkd19lZG1hX2NodW5rICpkd19l ZG1hX2FsbG9jX2NodW5rKHN0cnVjdCBkd19lZG1hX2Rlc2MgKmRlc2MpCj4+ICt7Cj4+ICsJc3Ry dWN0IGR3X2VkbWFfY2hhbiAqY2hhbiA9IGRlc2MtPmNoYW47Cj4+ICsJc3RydWN0IGR3X2VkbWEg KmR3ID0gY2hhbi0+Y2hpcC0+ZHc7Cj4+ICsJc3RydWN0IGR3X2VkbWFfY2h1bmsgKmNodW5rOwo+ PiArCj4+ICsJY2h1bmsgPSBrdnphbGxvYyhzaXplb2YoKmNodW5rKSwgR0ZQX05PV0FJVCk7Cj4+ ICsJaWYgKHVubGlrZWx5KCFjaHVuaykpCj4+ICsJCXJldHVybiBOVUxMOwo+PiArCj4+ICsJSU5J VF9MSVNUX0hFQUQoJmNodW5rLT5saXN0KTsKPj4gKwljaHVuay0+Y2hhbiA9IGNoYW47Cj4+ICsJ Y2h1bmstPmNiID0gIShkZXNjLT5jaHVua3NfYWxsb2MgJSAyKTsKPj4gKwljaHVuay0+bGxfcmVn aW9uLnBhZGRyID0gZHctPmxsX3JlZ2lvbi5wYWRkciArIGNoYW4tPmxsX29mZjsKPj4gKwljaHVu ay0+bGxfcmVnaW9uLnZhZGRyID0gZHctPmxsX3JlZ2lvbi52YWRkciArIGNoYW4tPmxsX29mZjsK Pj4gKwo+PiArCWlmIChkZXNjLT5jaHVuaykgewo+PiArCQkvKiBDcmVhdGUgYW5kIGFkZCBuZXcg ZWxlbWVudCBpbnRvIHRoZSBsaW5rZWQgbGlzdCAqLwo+PiArCQlkZXNjLT5jaHVua3NfYWxsb2Mr KzsKPj4gKwkJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwgImFsbG9jIG5ldyBjaHVuayBlbGVtZW50 ICglZClcbiIsCj4+ICsJCQlkZXNjLT5jaHVua3NfYWxsb2MpOwo+PiArCQlsaXN0X2FkZF90YWls KCZjaHVuay0+bGlzdCwgJmRlc2MtPmNodW5rLT5saXN0KTsKPj4gKwkJZHdfZWRtYV9hbGxvY19i dXJzdChjaHVuayk7Cj4gCj4gTm8gcmV0dXJuIGNoZWNrID8KCk5pY2UgY2F0Y2ghIEknbGwgZG8g YSByZXR1cm4gY2hlY2suCgo+IAo+PiArCX0gZWxzZSB7Cj4+ICsJCS8qIExpc3QgaGVhZCAqLwo+ PiArCQljaHVuay0+YnVyc3QgPSBOVUxMOwo+PiArCQlkZXNjLT5jaHVua3NfYWxsb2MgPSAwOwo+ PiArCQlkZXNjLT5jaHVuayA9IGNodW5rOwo+PiArCQlkZXZfZGJnKGNoYW4yZGV2KGNoYW4pLCAi YWxsb2MgbmV3IGNodW5rIGhlYWRcbiIpOwo+PiArCX0KPj4gKwo+PiArCXJldHVybiBjaHVuazsK Pj4gK30KPj4gKwo+PiArc3RhdGljIHN0cnVjdCBkd19lZG1hX2Rlc2MgKmR3X2VkbWFfYWxsb2Nf ZGVzYyhzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuKQo+PiArewo+PiArCXN0cnVjdCBkd19lZG1h X2Rlc2MgKmRlc2M7Cj4+ICsKPj4gKwlkZXZfZGJnKGNoYW4yZGV2KGNoYW4pLCAiYWxsb2MgbmV3 IGRlc2NyaXB0b3JcbiIpOwo+PiArCj4+ICsJZGVzYyA9IGt2emFsbG9jKHNpemVvZigqZGVzYyks IEdGUF9OT1dBSVQpOwo+PiArCWlmICh1bmxpa2VseSghZGVzYykpCj4+ICsJCXJldHVybiBOVUxM Owo+PiArCj4+ICsJZGVzYy0+Y2hhbiA9IGNoYW47Cj4+ICsJZHdfZWRtYV9hbGxvY19jaHVuayhk ZXNjKTsKPiAKPiBObyByZXR1cm4gY2hlY2sgPwoKRGl0dG8uCgo+IAo+PiArCj4+ICsJcmV0dXJu IGRlc2M7Cj4+ICt9Cj4+ICsKPiAKPj4gK3N0YXRpYyB2b2lkIGR3X2VkbWFfc3RhcnRfdHJhbnNm ZXIoc3RydWN0IGR3X2VkbWFfY2hhbiAqY2hhbikKPj4gK3sKPj4gKwlzdHJ1Y3QgdmlydF9kbWFf ZGVzYyAqdmQ7Cj4+ICsJc3RydWN0IGR3X2VkbWFfZGVzYyAqZGVzYzsKPj4gKwlzdHJ1Y3QgZHdf ZWRtYV9jaHVuayAqY2hpbGQ7Cj4+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9vcHMgKm9w cyA9IGNoYW4yb3BzKGNoYW4pOwo+IAo+IFJldmVyc2UgdHJlZSBvcmRlciBoZXJlIGFuZCBpbiBy ZW1haW5pbmcgZnVuY3Rpb25zIC4uLgoKT2ssIEknbGwgZG8gdGhhdC4KCj4gCj4+ICsKPj4gKwl2 ZCA9IHZjaGFuX25leHRfZGVzYygmY2hhbi0+dmMpOwo+PiArCWlmICghdmQpCj4+ICsJCXJldHVy bjsKPj4gKwo+PiArCWRlc2MgPSB2ZDJkd19lZG1hX2Rlc2ModmQpOwo+PiArCWlmICghZGVzYykK Pj4gKwkJcmV0dXJuOwo+PiArCj4+ICsJY2hpbGQgPSBsaXN0X2ZpcnN0X2VudHJ5X29yX251bGwo JmRlc2MtPmNodW5rLT5saXN0LAo+PiArCQkJCQkgc3RydWN0IGR3X2VkbWFfY2h1bmssIGxpc3Qp Owo+PiArCWlmICghY2hpbGQpCj4+ICsJCXJldHVybjsKPj4gKwo+PiArCW9wcy0+c3RhcnQoY2hp bGQsICFkZXNjLT54ZmVyX3N6KTsKPj4gKwlkZXNjLT54ZmVyX3N6ICs9IGNoaWxkLT5sbF9yZWdp b24uc3o7Cj4+ICsJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwgInRyYW5zZmVyIG9mICV1IGJ5dGVz IHN0YXJ0ZWRcbiIsCj4+ICsJCWNoaWxkLT5sbF9yZWdpb24uc3opOwo+PiArCj4+ICsJZHdfZWRt YV9mcmVlX2J1cnN0KGNoaWxkKTsKPj4gKwlpZiAoY2hpbGQtPmJ1cnN0c19hbGxvYykKPj4gKwkJ ZGV2X2RiZyhjaGFuMmRldihjaGFuKSwJIiV1IGJ1cnN0cyBzdGlsbCBhbGxvY2F0ZWRcbiIsCj4+ ICsJCQljaGlsZC0+YnVyc3RzX2FsbG9jKTsKPj4gKwlsaXN0X2RlbCgmY2hpbGQtPmxpc3QpOwo+ PiArCWt2ZnJlZShjaGlsZCk7Cj4+ICsJZGVzYy0+Y2h1bmtzX2FsbG9jLS07Cj4+ICt9Cj4+ICsK PiAKPj4gK2ludCBkd19lZG1hX3Byb2JlKHN0cnVjdCBkd19lZG1hX2NoaXAgKmNoaXApCj4+ICt7 Cj4+ICsJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hpcC0+ZHc7Cj4+ICsJc3RydWN0IGRldmljZSAq ZGV2ID0gY2hpcC0+ZGV2Owo+PiArCWNvbnN0IHN0cnVjdCBkd19lZG1hX2NvcmVfb3BzICpvcHM7 Cj4+ICsJc2l6ZV90IGxsX2NodW5rID0gZHctPmxsX3JlZ2lvbi5zejsKPj4gKwlzaXplX3QgZHRf Y2h1bmsgPSBkdy0+ZHRfcmVnaW9uLnN6Owo+PiArCXUzMiBjaF90b3Q7Cj4+ICsJaW50IGksIGos IGVycjsKPj4gKwo+PiArCXJhd19zcGluX2xvY2tfaW5pdCgmZHctPmxvY2spOwo+IAo+IFdoeSBy YXcgPwoKTWFyYyBaeW5naWVyIHRvbGQgbWUgc29tZSB0aW1lIGFnbyByYXcgc3BpbiBsb2NrcyBp dCB3b3VsZCBwcmVmZXJhYmxlLCBzaW5jZSBpdApkb2Vzbid0IGJyaW5nIGFueSBhZGRpdGlvbmFs IGVmZmVjdCBmb3IgdGhlIG1haW5saW5lIGtlcm5lbCwgYnV0IHdpbGwgbWFrZSBpdAp3b3JrIGNv cnJlY3RseSBpZiB5b3UgdXNlIHRoZSBSVCBwYXRjaGVzLgoKPiAKPj4gKwo+PiArCS8qIENhbGxi YWNrIG9wZXJhdGlvbiBzZWxlY3Rpb24gYWNjb3JkaW5nbHkgdG8gZURNQSB2ZXJzaW9uICovCj4+ ICsJc3dpdGNoIChkdy0+dmVyc2lvbikgewo+PiArCWRlZmF1bHQ6Cj4+ICsJCWRldl9lcnIoZGV2 LCAidW5zdXBwb3J0ZWQgdmVyc2lvblxuIik7Cj4+ICsJCXJldHVybiAtRVBFUk07Cj4+ICsJfQo+ PiArCj4+ICsJcG1fcnVudGltZV9nZXRfc3luYyhkZXYpOwo+IAo+IFdoeSBkbyB5b3UgbmVlZCB0 byBpbmNyZWFzZSB1c2FnZSBjb3VudCBhdCBwcm9iZSA/IEFuZCBzaG91bGRuJ3QKPiB0aGlzIGJl IGFmdGVyIHBtX3J1bnRpbWVfZW5hYmxlKCkgPwoKSXQgc2hvdWxkbid0IGJlIHRoZXJlLiBJJ2xs IHJlbW92ZSBpdC4KCj4gCj4+ICsKPj4gKwkvKiBGaW5kIG91dCBob3cgbWFueSB3cml0ZSBjaGFu bmVscyBhcmUgc3VwcG9ydGVkIGJ5IGhhcmR3YXJlICovCj4+ICsJZHctPndyX2NoX2NudCA9IG9w cy0+Y2hfY291bnQoZHcsIEVETUFfRElSX1dSSVRFKTsKPj4gKwlpZiAoIWR3LT53cl9jaF9jbnQp IHsKPj4gKwkJZGV2X2VycihkZXYsICJpbnZhbGlkIG51bWJlciBvZiB3cml0ZSBjaGFubmVscygw KVxuIik7Cj4+ICsJCXJldHVybiAtRUlOVkFMOwo+PiArCX0KPj4gKwo+PiArCS8qIEZpbmQgb3V0 IGhvdyBtYW55IHJlYWQgY2hhbm5lbHMgYXJlIHN1cHBvcnRlZCBieSBoYXJkd2FyZSAqLwo+PiAr CWR3LT5yZF9jaF9jbnQgPSBvcHMtPmNoX2NvdW50KGR3LCBFRE1BX0RJUl9SRUFEKTsKPj4gKwlp ZiAoIWR3LT5yZF9jaF9jbnQpIHsKPj4gKwkJZGV2X2VycihkZXYsICJpbnZhbGlkIG51bWJlciBv ZiByZWFkIGNoYW5uZWxzKDApXG4iKTsKPj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4+ICsJfQo+PiAr Cj4+ICsJZGV2X2RiZyhkZXYsICJDaGFubmVsczpcdHdyaXRlPSVkLCByZWFkPSVkXG4iLAo+PiAr CQlkdy0+d3JfY2hfY250LCBkdy0+cmRfY2hfY250KTsKPj4gKwo+PiArCWNoX3RvdCA9IGR3LT53 cl9jaF9jbnQgKyBkdy0+cmRfY2hfY250Owo+PiArCj4+ICsJLyogQWxsb2NhdGUgY2hhbm5lbHMg Ki8KPj4gKwlkdy0+Y2hhbiA9IGRldm1fa2NhbGxvYyhkZXYsIGNoX3RvdCwgc2l6ZW9mKCpkdy0+ Y2hhbiksIEdGUF9LRVJORUwpOwo+PiArCWlmICghZHctPmNoYW4pCj4+ICsJCXJldHVybiAtRU5P TUVNOwo+PiArCj4+ICsJLyogQ2FsY3VsYXRlIHRoZSBsaW5rZWQgbGlzdCBjaHVuayBmb3IgZWFj aCBjaGFubmVsICovCj4+ICsJbGxfY2h1bmsgLz0gcm91bmR1cF9wb3dfb2ZfdHdvKGNoX3RvdCk7 Cj4+ICsKPj4gKwkvKiBDYWxjdWxhdGUgdGhlIGxpbmtlZCBsaXN0IGNodW5rIGZvciBlYWNoIGNo YW5uZWwgKi8KPj4gKwlkdF9jaHVuayAvPSByb3VuZHVwX3Bvd19vZl90d28oY2hfdG90KTsKPj4g Kwo+PiArCS8qIERpc2FibGUgZURNQSwgb25seSB0byBlc3RhYmxpc2ggdGhlIGlkZWFsIGluaXRp YWwgY29uZGl0aW9ucyAqLwo+PiArCW9wcy0+b2ZmKGR3KTsKPj4gKwo+PiArCXNucHJpbnRmKGR3 LT5uYW1lLCBzaXplb2YoZHctPm5hbWUpLCAiZHctZWRtYS1jb3JlOiVkIiwgY2hpcC0+aWQpOwo+ PiArCj4+ICsJLyogUmVxdWVzdCBJUlFzICovCj4+ICsJaWYgKGR3LT5ucl9pcnFzICE9IDEpIHsK Pj4gKwkJZGV2X2VycihkZXYsICJpbnZhbGlkIG51bWJlciBvZiBpcnFzICgldSlcbiIsIGR3LT5u cl9pcnFzKTsKPj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4+ICsJfQo+PiArCj4+ICsJZm9yIChpID0g MDsgaSA8IGR3LT5ucl9pcnFzOyBpKyspIHsKPj4gKwkJZXJyID0gZGV2bV9yZXF1ZXN0X2lycShk ZXYsIHBjaV9pcnFfdmVjdG9yKHRvX3BjaV9kZXYoZGV2KSwgaSksCj4+ICsJCQkJICAgICAgIGR3 X2VkbWFfaW50ZXJydXB0X2FsbCwKPj4gKwkJCQkgICAgICAgSVJRRl9TSEFSRUQsIGR3LT5uYW1l LCBjaGlwKTsKPj4gKwkJaWYgKGVycikKPj4gKwkJCXJldHVybiBlcnI7Cj4+ICsJfQo+PiArCj4+ ICsJLyogQ3JlYXRlIHdyaXRlIGNoYW5uZWxzICovCj4+ICsJSU5JVF9MSVNUX0hFQUQoJmR3LT53 cl9lZG1hLmNoYW5uZWxzKTsKPj4gKwlmb3IgKGkgPSAwOyBpIDwgZHctPndyX2NoX2NudDsgaSsr KSB7Cj4+ICsJCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4gPSAmZHctPmNoYW5baV07Cj4+ICsJ CXN0cnVjdCBkd19lZG1hX3JlZ2lvbiAqZHRfcmVnaW9uOwo+PiArCj4+ICsJCWR0X3JlZ2lvbiA9 IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqZHRfcmVnaW9uKSwgR0ZQX0tFUk5FTCk7Cj4+ICsJ CWlmICghZHRfcmVnaW9uKQo+PiArCQkJcmV0dXJuIC1FTk9NRU07Cj4+ICsKPj4gKwkJY2hhbi0+ dmMuY2hhbi5wcml2YXRlID0gZHRfcmVnaW9uOwo+PiArCj4+ICsJCWNoYW4tPmNoaXAgPSBjaGlw Owo+PiArCQljaGFuLT5pZCA9IGk7Cj4+ICsJCWNoYW4tPmRpciA9IEVETUFfRElSX1dSSVRFOwo+ PiArCQljaGFuLT5jb25maWd1cmVkID0gZmFsc2U7Cj4+ICsJCWNoYW4tPnJlcXVlc3QgPSBFRE1B X1JFUV9OT05FOwo+PiArCQljaGFuLT5zdGF0dXMgPSBFRE1BX1NUX0lETEU7Cj4+ICsKPj4gKwkJ Y2hhbi0+bGxfb2ZmID0gKGxsX2NodW5rICogaSk7Cj4+ICsJCWNoYW4tPmxsX21heCA9IChsbF9j aHVuayAvIEVETUFfTExfU1opIC0gMTsKPj4gKwo+PiArCQljaGFuLT5kdF9vZmYgPSAoZHRfY2h1 bmsgKiBpKTsKPj4gKwo+PiArCQlkZXZfZGJnKGRldiwgIkwuIExpc3Q6XHRDaGFubmVsIHdyaXRl WyV1XSBvZmY9MHglLjhseCwgbWF4X2NudD0ldVxuIiwKPj4gKwkJCWksIGNoYW4tPmxsX29mZiwg Y2hhbi0+bGxfbWF4KTsKPj4gKwo+PiArCQltZW1jcHkoJmNoYW4tPm1zaSwgJmR3LT5tc2lbMF0s IHNpemVvZihjaGFuLT5tc2kpKTsKPj4gKwo+PiArCQlkZXZfZGJnKGRldiwgIk1TSTpcdFx0Q2hh bm5lbCB3cml0ZVsldV0gYWRkcj0weCUuOHglLjh4LCBkYXRhPTB4JS44eFxuIiwKPj4gKwkJCWks IGNoYW4tPm1zaS5hZGRyZXNzX2hpLCBjaGFuLT5tc2kuYWRkcmVzc19sbywKPj4gKwkJCWNoYW4t Pm1zaS5kYXRhKTsKPj4gKwo+PiArCQljaGFuLT52Yy5kZXNjX2ZyZWUgPSB2Y2hhbl9mcmVlX2Rl c2M7Cj4+ICsJCXZjaGFuX2luaXQoJmNoYW4tPnZjLCAmZHctPndyX2VkbWEpOwo+PiArCj4+ICsJ CWR0X3JlZ2lvbi0+cGFkZHIgPSBkdy0+ZHRfcmVnaW9uLnBhZGRyICsgY2hhbi0+ZHRfb2ZmOwo+ PiArCQlkdF9yZWdpb24tPnZhZGRyID0gZHctPmR0X3JlZ2lvbi52YWRkciArIGNoYW4tPmR0X29m ZjsKPj4gKwkJZHRfcmVnaW9uLT5zeiA9IGR0X2NodW5rOwo+PiArCj4+ICsJCWRldl9kYmcoZGV2 LCAiRGF0YTpcdENoYW5uZWwgd3JpdGVbJXVdIG9mZj0weCUuOGx4XG4iLAo+PiArCQkJaSwgY2hh bi0+ZHRfb2ZmKTsKPj4gKwl9Cj4+ICsJZG1hX2NhcF96ZXJvKGR3LT53cl9lZG1hLmNhcF9tYXNr KTsKPj4gKwlkbWFfY2FwX3NldChETUFfU0xBVkUsIGR3LT53cl9lZG1hLmNhcF9tYXNrKTsKPj4g KwlkbWFfY2FwX3NldChETUFfQ1lDTElDLCBkdy0+d3JfZWRtYS5jYXBfbWFzayk7Cj4+ICsJZHct PndyX2VkbWEuZGlyZWN0aW9ucyA9IEJJVChETUFfREVWX1RPX01FTSk7Cj4+ICsJZHctPndyX2Vk bWEuY2hhbmNudCA9IGR3LT53cl9jaF9jbnQ7Cj4+ICsKPj4gKwkvKiBDcmVhdGUgcmVhZCBjaGFu bmVscyAqLwo+PiArCUlOSVRfTElTVF9IRUFEKCZkdy0+cmRfZWRtYS5jaGFubmVscyk7Cj4+ICsJ Zm9yIChqID0gMDsgaiA8IGR3LT5yZF9jaF9jbnQ7IGorKywgaSsrKSB7Cj4+ICsJCXN0cnVjdCBk d19lZG1hX2NoYW4gKmNoYW4gPSAmZHctPmNoYW5baV07Cj4+ICsJCXN0cnVjdCBkd19lZG1hX3Jl Z2lvbiAqZHRfcmVnaW9uOwo+PiArCj4+ICsJCWR0X3JlZ2lvbiA9IGRldm1fa3phbGxvYyhkZXYs IHNpemVvZigqZHRfcmVnaW9uKSwgR0ZQX0tFUk5FTCk7Cj4+ICsJCWlmICghZHRfcmVnaW9uKQo+ PiArCQkJcmV0dXJuIC1FTk9NRU07Cj4+ICsKPj4gKwkJY2hhbi0+dmMuY2hhbi5wcml2YXRlID0g ZHRfcmVnaW9uOwo+PiArCj4+ICsJCWNoYW4tPmNoaXAgPSBjaGlwOwo+PiArCQljaGFuLT5pZCA9 IGo7Cj4+ICsJCWNoYW4tPmRpciA9IEVETUFfRElSX1JFQUQ7Cj4+ICsJCWNoYW4tPmNvbmZpZ3Vy ZWQgPSBmYWxzZTsKPj4gKwkJY2hhbi0+cmVxdWVzdCA9IEVETUFfUkVRX05PTkU7Cj4+ICsJCWNo YW4tPnN0YXR1cyA9IEVETUFfU1RfSURMRTsKPj4gKwo+PiArCQljaGFuLT5sbF9vZmYgPSAobGxf Y2h1bmsgKiBpKTsKPj4gKwkJY2hhbi0+bGxfbWF4ID0gKGxsX2NodW5rIC8gRURNQV9MTF9TWikg LSAxOwo+PiArCj4+ICsJCWNoYW4tPmR0X29mZiA9IChkdF9jaHVuayAqIGkpOwo+PiArCj4+ICsJ CWRldl9kYmcoZGV2LCAiTC4gTGlzdDpcdENoYW5uZWwgcmVhZFsldV0gb2ZmPTB4JS44bHgsIG1h eF9jbnQ9JXVcbiIsCj4+ICsJCQlqLCBjaGFuLT5sbF9vZmYsIGNoYW4tPmxsX21heCk7Cj4+ICsK Pj4gKwkJbWVtY3B5KCZjaGFuLT5tc2ksICZkdy0+bXNpWzBdLCBzaXplb2YoY2hhbi0+bXNpKSk7 Cj4+ICsKPj4gKwkJZGV2X2RiZyhkZXYsICJNU0k6XHRcdENoYW5uZWwgcmVhZFsldV0gYWRkcj0w eCUuOHglLjh4LCBkYXRhPTB4JS44eFxuIiwKPj4gKwkJCWosIGNoYW4tPm1zaS5hZGRyZXNzX2hp LCBjaGFuLT5tc2kuYWRkcmVzc19sbywKPj4gKwkJCWNoYW4tPm1zaS5kYXRhKTsKPj4gKwo+PiAr CQljaGFuLT52Yy5kZXNjX2ZyZWUgPSB2Y2hhbl9mcmVlX2Rlc2M7Cj4+ICsJCXZjaGFuX2luaXQo JmNoYW4tPnZjLCAmZHctPnJkX2VkbWEpOwo+PiArCj4+ICsJCWR0X3JlZ2lvbi0+cGFkZHIgPSBk dy0+ZHRfcmVnaW9uLnBhZGRyICsgY2hhbi0+ZHRfb2ZmOwo+PiArCQlkdF9yZWdpb24tPnZhZGRy ID0gZHctPmR0X3JlZ2lvbi52YWRkciArIGNoYW4tPmR0X29mZjsKPj4gKwkJZHRfcmVnaW9uLT5z eiA9IGR0X2NodW5rOwo+PiArCj4+ICsJCWRldl9kYmcoZGV2LCAiRGF0YTpcdENoYW5uZWwgcmVh ZFsldV0gb2ZmPTB4JS44bHhcbiIsCj4+ICsJCQlpLCBjaGFuLT5kdF9vZmYpOwo+PiArCX0KPj4g KwlkbWFfY2FwX3plcm8oZHctPnJkX2VkbWEuY2FwX21hc2spOwo+PiArCWRtYV9jYXBfc2V0KERN QV9TTEFWRSwgZHctPnJkX2VkbWEuY2FwX21hc2spOwo+PiArCWRtYV9jYXBfc2V0KERNQV9DWUNM SUMsIGR3LT5yZF9lZG1hLmNhcF9tYXNrKTsKPj4gKwlkdy0+cmRfZWRtYS5kaXJlY3Rpb25zID0g QklUKERNQV9NRU1fVE9fREVWKTsKPj4gKwlkdy0+cmRfZWRtYS5jaGFuY250ID0gZHctPnJkX2No X2NudDsKPj4gKwo+PiArCS8qIFNldCBETUEgY2hhbm5lbHMgIGNhcGFiaWxpdGllcyAqLwo+PiAr CVNFVF9CT1RIX0NIKHNyY19hZGRyX3dpZHRocywgQklUKERNQV9TTEFWRV9CVVNXSURUSF80X0JZ VEVTKSk7Cj4+ICsJU0VUX0JPVEhfQ0goZHN0X2FkZHJfd2lkdGhzLCBCSVQoRE1BX1NMQVZFX0JV U1dJRFRIXzRfQllURVMpKTsKPj4gKwlTRVRfQk9USF9DSChyZXNpZHVlX2dyYW51bGFyaXR5LCBE TUFfUkVTSURVRV9HUkFOVUxBUklUWV9ERVNDUklQVE9SKTsKPj4gKwo+PiArCVNFVF9CT1RIX0NI KGRldiwgZGV2KTsKPj4gKwo+PiArCVNFVF9CT1RIX0NIKGRldmljZV9hbGxvY19jaGFuX3Jlc291 cmNlcywgZHdfZWRtYV9hbGxvY19jaGFuX3Jlc291cmNlcyk7Cj4+ICsJU0VUX0JPVEhfQ0goZGV2 aWNlX2ZyZWVfY2hhbl9yZXNvdXJjZXMsIGR3X2VkbWFfZnJlZV9jaGFuX3Jlc291cmNlcyk7Cj4+ ICsKPj4gKwlTRVRfQk9USF9DSChkZXZpY2VfY29uZmlnLCBkd19lZG1hX2RldmljZV9jb25maWcp Owo+PiArCVNFVF9CT1RIX0NIKGRldmljZV9wYXVzZSwgZHdfZWRtYV9kZXZpY2VfcGF1c2UpOwo+ PiArCVNFVF9CT1RIX0NIKGRldmljZV9yZXN1bWUsIGR3X2VkbWFfZGV2aWNlX3Jlc3VtZSk7Cj4+ ICsJU0VUX0JPVEhfQ0goZGV2aWNlX3Rlcm1pbmF0ZV9hbGwsIGR3X2VkbWFfZGV2aWNlX3Rlcm1p bmF0ZV9hbGwpOwo+PiArCVNFVF9CT1RIX0NIKGRldmljZV9pc3N1ZV9wZW5kaW5nLCBkd19lZG1h X2RldmljZV9pc3N1ZV9wZW5kaW5nKTsKPj4gKwlTRVRfQk9USF9DSChkZXZpY2VfdHhfc3RhdHVz LCBkd19lZG1hX2RldmljZV90eF9zdGF0dXMpOwo+PiArCVNFVF9CT1RIX0NIKGRldmljZV9wcmVw X3NsYXZlX3NnLCBkd19lZG1hX2RldmljZV9wcmVwX3NsYXZlX3NnKTsKPj4gKwlTRVRfQk9USF9D SChkZXZpY2VfcHJlcF9kbWFfY3ljbGljLCBkd19lZG1hX2RldmljZV9wcmVwX2RtYV9jeWNsaWMp Owo+PiArCj4+ICsJLyogUG93ZXIgbWFuYWdlbWVudCAqLwo+PiArCXBtX3J1bnRpbWVfZW5hYmxl KGRldik7Cj4+ICsKPj4gKwkvKiBSZWdpc3RlciBETUEgZGV2aWNlICovCj4+ICsJZXJyID0gZG1h X2FzeW5jX2RldmljZV9yZWdpc3RlcigmZHctPndyX2VkbWEpOwo+PiArCWlmIChlcnIpCj4+ICsJ CWdvdG8gZXJyX3BtX2Rpc2FibGU7Cj4+ICsKPj4gKwllcnIgPSBkbWFfYXN5bmNfZGV2aWNlX3Jl Z2lzdGVyKCZkdy0+cmRfZWRtYSk7Cj4+ICsJaWYgKGVycikKPj4gKwkJZ290byBlcnJfcG1fZGlz YWJsZTsKPj4gKwo+PiArCS8qIFR1cm4gZGVidWdmcyBvbiAqLwo+PiArCWVyciA9IG9wcy0+ZGVi dWdmc19vbihjaGlwKTsKPj4gKwlpZiAoZXJyKSB7Cj4+ICsJCWRldl9lcnIoZGV2LCAidW5hYmxl IHRvIGNyZWF0ZSBkZWJ1Z2ZzIHN0cnVjdHVyZVxuIik7Cj4+ICsJCWdvdG8gZXJyX3BtX2Rpc2Fi bGU7Cj4+ICsJfQo+PiArCj4+ICsJZGV2X2luZm8oZGV2LCAiRGVzaWduV2FyZSBlRE1BIGNvbnRy b2xsZXIgZHJpdmVyIGxvYWRlZCBjb21wbGV0ZWx5XG4iKTsKPj4gKwo+PiArCXJldHVybiAwOwo+ PiArCj4+ICtlcnJfcG1fZGlzYWJsZToKPj4gKwlwbV9ydW50aW1lX2Rpc2FibGUoZGV2KTsKPj4g Kwo+PiArCXJldHVybiBlcnI7Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTChkd19lZG1hX3By b2JlKTsKPj4gKwo+PiAraW50IGR3X2VkbWFfcmVtb3ZlKHN0cnVjdCBkd19lZG1hX2NoaXAgKmNo aXApCj4+ICt7Cj4+ICsJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hpcC0+ZHc7Cj4+ICsJc3RydWN0 IGRldmljZSAqZGV2ID0gY2hpcC0+ZGV2Owo+PiArCWNvbnN0IHN0cnVjdCBkd19lZG1hX2NvcmVf b3BzICpvcHMgPSBkdy0+b3BzOwo+PiArCXN0cnVjdCBkd19lZG1hX2NoYW4gKmNoYW4sICpfY2hh bjsKPj4gKwlpbnQgaTsKPj4gKwo+PiArCS8qIERpc2FibGUgZURNQSAqLwo+PiArCWlmIChvcHMp Cj4+ICsJCW9wcy0+b2ZmKGR3KTsKPj4gKwo+PiArCS8qIEZyZWUgaXJxcyAqLwo+IAo+IEJ1dCBk ZXZtIHdpbGwgYXV0b21hdGljYWxseSBmcmVlIGl0LCBubyA/CgpZZXMsIGl0IHNob3VsZG4ndCBi ZSB0aGVyZS4gSSdsbCByZW1vdmUgaXQuCgo+IAo+PiArCWZvciAoaSA9IDA7IGkgPCBkdy0+bnJf aXJxczsgaSsrKSB7Cj4+ICsJCWlmIChwY2lfaXJxX3ZlY3Rvcih0b19wY2lfZGV2KGRldiksIGkp IDwgMCkKPj4gKwkJCWNvbnRpbnVlOwo+PiArCj4+ICsJCWRldm1fZnJlZV9pcnEoZGV2LCBwY2lf aXJxX3ZlY3Rvcih0b19wY2lfZGV2KGRldiksIGkpLCBjaGlwKTsKPj4gKwl9Cj4+ICsKPj4gKwkv KiBQb3dlciBtYW5hZ2VtZW50ICovCj4+ICsJcG1fcnVudGltZV9kaXNhYmxlKGRldik7Cj4+ICsK Pj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY2hhbiwgX2NoYW4sICZkdy0+d3JfZWRtYS5j aGFubmVscywKPj4gKwkJCQkgdmMuY2hhbi5kZXZpY2Vfbm9kZSkgewo+PiArCQlsaXN0X2RlbCgm Y2hhbi0+dmMuY2hhbi5kZXZpY2Vfbm9kZSk7Cj4+ICsJCXRhc2tsZXRfa2lsbCgmY2hhbi0+dmMu dGFzayk7Cj4+ICsJfQo+PiArCj4+ICsJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGNoYW4sIF9j aGFuLCAmZHctPnJkX2VkbWEuY2hhbm5lbHMsCj4+ICsJCQkJIHZjLmNoYW4uZGV2aWNlX25vZGUp IHsKPj4gKwkJbGlzdF9kZWwoJmNoYW4tPnZjLmNoYW4uZGV2aWNlX25vZGUpOwo+PiArCQl0YXNr bGV0X2tpbGwoJmNoYW4tPnZjLnRhc2spOwo+PiArCX0KPj4gKwo+PiArCS8qIERlcmVnaXN0ZXIg ZURNQSBkZXZpY2UgKi8KPj4gKwlkbWFfYXN5bmNfZGV2aWNlX3VucmVnaXN0ZXIoJmR3LT53cl9l ZG1hKTsKPj4gKwlkbWFfYXN5bmNfZGV2aWNlX3VucmVnaXN0ZXIoJmR3LT5yZF9lZG1hKTsKPj4g Kwo+PiArCS8qIFR1cm4gZGVidWdmcyBvZmYgKi8KPj4gKwlpZiAob3BzKQo+PiArCQlvcHMtPmRl YnVnZnNfb2ZmKCk7Cj4+ICsKPj4gKwlkZXZfaW5mbyhkZXYsICJEZXNpZ25XYXJlIGVETUEgY29u dHJvbGxlciBkcml2ZXIgdW5sb2FkZWQgY29tcGxldGVcbiIpOwo+PiArCj4+ICsJcmV0dXJuIDA7 Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTChkd19lZG1hX3JlbW92ZSk7CgpUaGFua3MhCg== 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 9B546C43387 for ; Wed, 16 Jan 2019 11:57:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4F1A820859 for ; Wed, 16 Jan 2019 11:57:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=synopsys.com header.i=@synopsys.com header.b="SxG+dOt5" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389705AbfAPL5p (ORCPT ); Wed, 16 Jan 2019 06:57:45 -0500 Received: from smtprelay4.synopsys.com ([198.182.47.9]:48042 "EHLO smtprelay.synopsys.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389674AbfAPL5p (ORCPT ); Wed, 16 Jan 2019 06:57:45 -0500 Received: from mailhost.synopsys.com (mailhost1.synopsys.com [10.12.238.239]) by smtprelay.synopsys.com (Postfix) with ESMTP id E822824E0E70; Wed, 16 Jan 2019 03:57:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=synopsys.com; s=mail; t=1547639865; bh=fgJAwhZZORKEAeKxgr+YSPr7zPWKtllQy/tyCy88uQs=; h=Subject:To:CC:References:From:Date:In-Reply-To:From; b=SxG+dOt5016dKU2NOIzgTcfG9jczBef7/1x0Ju++ccAtek/+8gHL8HeFf/KmpjGIX S2qmzaeUiaUoSHyzWEPgd0BgaMlqGnSXhudbBxkdp6mBF34AITTVDcW4s9J3GV5YrL bI6joyN+aI/Vv/yO29tfSYqTsJG89ccEG8x9HHQYzdALZPk7Tj1+I4Hgsn4VcJcsr0 79PPMCP9T3P3CMTrrD8P5TbWkT8iDMZGCu6C73zJlsuRj3xvMyNQvTXZkXaQRUngPz GGs0Z/fCMI8Io/T+cU6eBAqdgfWvZKddmkXjWZLjhkkCuRpVNyAAL0nUcYhjC/KX3y caTt7v5H6YyJw== Received: from US01WEHTC3.internal.synopsys.com (us01wehtc3.internal.synopsys.com [10.15.84.232]) by mailhost.synopsys.com (Postfix) with ESMTP id B752452E4; Wed, 16 Jan 2019 03:57:44 -0800 (PST) Received: from DE02WEHTCB.internal.synopsys.com (10.225.19.94) by US01WEHTC3.internal.synopsys.com (10.15.84.232) with Microsoft SMTP Server (TLS) id 14.3.408.0; Wed, 16 Jan 2019 03:57:44 -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 12:57:42 +0100 Received: from [10.107.25.131] (10.107.25.131) by DE02WEHTCA.internal.synopsys.com (10.225.19.80) with Microsoft SMTP Server (TLS) id 14.3.408.0; Wed, 16 Jan 2019 12:57:42 +0100 Subject: Re: [RFC v3 1/7] dmaengine: Add Synopsys eDMA IP core driver To: Jose Abreu , 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 de Oliveira , Vitor Soares , Nelson Costa , "Pedro Sousa" References: From: Gustavo Pimentel Message-ID: Date: Wed, 16 Jan 2019 11:53:00 +0000 User-Agent: Mozilla/5.0 (Windows NT 10.0; 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.25.131] Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org Hi Jose, On 16/01/2019 10:21, Jose Abreu wrote: > 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 ? Nice catch! I'll do a 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 ? Ditto. > >> + >> + 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 ... Ok, I'll do that. > >> + >> + 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 ? Marc Zyngier told me some time ago raw spin locks it would preferable, since it doesn't bring any additional effect for the mainline kernel, but will make it work correctly if you use the RT patches. > >> + >> + /* 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() ? It shouldn't be there. I'll remove it. > >> + >> + /* 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 ? Yes, it shouldn't be there. I'll remove it. > >> + 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); Thanks!