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: <20190202100735.GD4296@vkoul-mobl> Date: Sat, 2 Feb 2019 15:37:35 +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: T24gMDEtMDItMTksIDExOjIzLCBHdXN0YXZvIFBpbWVudGVsIHdyb3RlOgo+IE9uIDAxLzAyLzIw MTkgMDQ6MTQsIFZpbm9kIEtvdWwgd3JvdGU6Cj4gPiBPbiAzMS0wMS0xOSwgMTE6MzMsIEd1c3Rh dm8gUGltZW50ZWwgd3JvdGU6Cj4gPj4gT24gMjMvMDEvMjAxOSAxMzowOCwgVmlub2QgS291bCB3 cm90ZToKPiA+Pj4gT24gMjEtMDEtMTksIDE1OjQ4LCBHdXN0YXZvIFBpbWVudGVsIHdyb3RlOgo+ ID4+Pj4gT24gMjAvMDEvMjAxOSAxMTo0NCwgVmlub2QgS291bCB3cm90ZToKPiA+Pj4+PiBPbiAx MS0wMS0xOSwgMTk6MzMsIEd1c3Rhdm8gUGltZW50ZWwgd3JvdGU6Cj4gPiAKPiA+Pj4+Pj4gQEAg LTAsMCArMSwxMDU5IEBACj4gPj4+Pj4+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMAo+ID4+Pj4+PiArLyoKPiA+Pj4+Pj4gKyAqIENvcHlyaWdodCAoYykgMjAxOCBTeW5vcHN5 cywgSW5jLiBhbmQvb3IgaXRzIGFmZmlsaWF0ZXMuCj4gPj4+Pj4KPiA+Pj4+PiAyMDE5IG5vdwo+ ID4+Pj4KPiA+Pj4+IEkndmUgY2hhbmdlZCB0byAiQ29weXJpZ2h0IChjKSAyMDE4LXByZXNlbnQg U3lub3BzeXMsIEluYy4gYW5kL29yIGl0cwo+ID4+Pj4gYWZmaWxpYXRlcy4iIHRoaXMgd2F5IGl0 J3MgYWx3YXlzIHVwIHRvIGRhdGUgYW5kIEkgYWxzbyBrZXB0IDIwMTgsIGJlY2F1c2UgaXQKPiA+ Pj4+IHdhcyB0aGUgZGF0ZSB0aGF0IEkgc3RhcnRlZCB0byBkZXZlbG9wIHRoaXMgZHJpdmVyLCBp ZiB5b3UgZG9uJ3QgbWluZC4KPiA+Pj4KPiA+Pj4geWVhaCAxOCBpcyBmaW5lIDopIGl0IG5lZWQg dG8gZW5kIHdpdGggY3VycmVudCB5ZWFyIGFsd2F5cwo+ID4+Cj4gPj4gSnVzdCB0byBiZSBzdXJl LCBhcmUgeW91IHNheWluZyB0aGF0IG11c3QgYmU6ICJDb3B5cmlnaHQgKGMpIDIwMTgtMjAxOSBT eW5vcHN5cywKPiA+PiBJbmMuIGFuZC9vciBpdHMgYWZmaWxpYXRlcy4iPwo+ID4gCj4gPiBZdXAg OikKPiA+IAo+ID4+Pj4+PiArc3RhdGljIHN0cnVjdCBkd19lZG1hX2NodW5rICpkd19lZG1hX2Fs bG9jX2NodW5rKHN0cnVjdCBkd19lZG1hX2Rlc2MgKmRlc2MpCj4gPj4+Pj4+ICt7Cj4gPj4+Pj4+ ICsJc3RydWN0IGR3X2VkbWFfY2hhbiAqY2hhbiA9IGRlc2MtPmNoYW47Cj4gPj4+Pj4+ICsJc3Ry dWN0IGR3X2VkbWEgKmR3ID0gY2hhbi0+Y2hpcC0+ZHc7Cj4gPj4+Pj4+ICsJc3RydWN0IGR3X2Vk bWFfY2h1bmsgKmNodW5rOwo+ID4+Pj4+PiArCj4gPj4+Pj4+ICsJY2h1bmsgPSBrdnphbGxvYyhz aXplb2YoKmNodW5rKSwgR0ZQX05PV0FJVCk7Cj4gPj4+Pj4+ICsJaWYgKHVubGlrZWx5KCFjaHVu aykpCj4gPj4+Pj4+ICsJCXJldHVybiBOVUxMOwo+ID4+Pj4+PiArCj4gPj4+Pj4+ICsJSU5JVF9M SVNUX0hFQUQoJmNodW5rLT5saXN0KTsKPiA+Pj4+Pj4gKwljaHVuay0+Y2hhbiA9IGNoYW47Cj4g Pj4+Pj4+ICsJY2h1bmstPmNiID0gIShkZXNjLT5jaHVua3NfYWxsb2MgJSAyKTsKPiA+Pj4+Pgo+ ID4+Pj4+IGNiIC4uPwo+ID4+Pj4KPiA+Pj4+IENCID0gY2hhbmdlIGJpdCwgaXMgYSBwcm9wZXJ0 eSBvZiB0aGlzIGVETUEgSVAuIEJhc2ljYWxseSBpdCBpcyBhIGtpbmQgb2YKPiA+Pj4+IGhhbmRz aGFrZSB3aGljaCBzZXJ2ZXMgdG8gdmFsaWRhdGUgd2hldGhlciB0aGUgbGlua2VkIGxpc3QgaGFz IGJlZW4gdXBkYXRlZCBvcgo+ID4+Pj4gbm90LCBlc3BlY2lhbGx5IHVzZWZ1bCBpbiBjYXNlcyBv ZiByZWN5Y2xlZCBsaW5rZWQgbGlzdCBlbGVtZW50cyAoZXZlcnkgbGlua2VkCj4gPj4+PiBsaXN0 IHJlY3ljbGUgaXMgYSBuZXcgY2h1bmssIHRoaXMgd2lsbCBhbGxvdyB0byBkaWZmZXJlbnRpYXRl IGVhY2ggY2h1bmspLgo+ID4+Pgo+ID4+PiBva2F5IHBsZWFzZSBhZGQgdGhhdCBzb21ld2hlcmUu IEFsc28gaXQgd291bGQgaGVscCBtZSBpZiB5b3UgZXhwbGFpbgo+ID4+PiB3aGF0IGlzIGNodW5r IGFuZCBvdGhlciB0ZXJtaW5vbG9naWVzIHVzZWQgaW4gdGhpcyBkcml2ZXIKPiA+Pgo+ID4+IEkn bSB0aGlua2luZyB0byBwdXQgdGhlIGJlbG93IGRlc2NyaXB0aW9uIG9uIHRoZSBwYXRjaCwgcGxl YXNlIGNoZWNrIGlmIHRoaXMgaXMKPiA+PiBzdWZmaWNpZW50IGV4cGxpY2l0IGFuZCBjbGVhciB0 byB1bmRlcnN0YW5kIHdoYXQgdGhpcyBJUCBuZWVkcyBhbmQgZG9lcy4KPiA+Pgo+ID4+IEluIG9y ZGVyIHRvIHRyYW5zZmVyIGRhdGEgZnJvbSBwb2ludCBBIHRvIEIgYXMgZmFzdCBhcyBwb3NzaWJs ZSB0aGlzIElQIHJlcXVpcmVzCj4gPj4gYSBkZWRpY2F0ZWQgbWVtb3J5IHNwYWNlIHdoZXJlIHdp bGwgcmVzaWRlIGEgbGlua2VkIGxpc3Qgb2YgZWxlbWVudHMuCj4gPiAKPiA+IHJlcGhyYXNpbmc6 IGEgZGVkaWNhdGVkIG1lbW9yeSBzcGFjZSBjb250YWluaW5nIGxpbmtlZCBsaXN0IG9mIGVsZW1l bnRzCj4gPiAKPiA+PiBBbGwgZWxlbWVudHMgb2YgdGhpcyBsaW5rZWQgbGlzdCBhcmUgY29udGlu dW91cyBhbmQgZWFjaCBvbmUgZGVzY3JpYmVzIGEgZGF0YQo+ID4+IHRyYW5zZmVyIChzb3VyY2Ug YW5kIGRlc3RpbmF0aW9uIGFkZHJlc3NlcywgbGVuZ3RoIGFuZCBhIGNvbnRyb2wgdmFyaWFibGUp Lgo+ID4+Cj4gPj4gRm9yIHRoZSBzYWtlIG9mIHNpbXBsaWNpdHksIGxldHMgYXNzdW1lIGEgbWVt b3J5IHNwYWNlIGZvciBjaGFubmVsIHdyaXRlIDAgd2hpY2gKPiA+PiBhbGxvd3MgYWJvdXQgNDIg ZWxlbWVudHMuCj4gPj4KPiA+PiArLS0tLS0tLS0tKwo+ID4+IHwgRGVzYyAjMCB8LS0rCj4gPj4g Ky0tLS0tLS0tLSsgIHwKPiA+PiAgICAgICAgICAgICAgVgo+ID4+ICAgICAgICAgKy0tLS0tLS0t LS0rCj4gPj4gICAgICAgICB8IENodW5rICMwIHwtLS0rCj4gPj4gICAgICAgICB8ICBDQiA9IDEg IHwgICB8ICAgKy0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLSsgICArLS0tLS0r Cj4gPj4gICAgICAgICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjMCB8LS0+fCAuLi4gfC0t PnwgQnVyc3QgIzQxIHwtLT58IGxscCB8Cj4gPj4gICAgICAgICAgICAgICB8ICAgICAgICAgICAg Ky0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rCj4gPj4gICAg ICAgICAgICAgICBWCj4gPj4gICAgICAgICArLS0tLS0tLS0tLSsKPiA+PiAgICAgICAgIHwgQ2h1 bmsgIzEgfC0tLSsKPiA+PiAgICAgICAgIHwgIENCID0gMCAgfCAgIHwgICArLS0tLS0tLS0tLS0r ICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rCj4gPj4gICAgICAgICArLS0tLS0t LS0tLSsgICArLS0+fCBCdXJzdCAjNDIgfC0tPnwgLi4uIHwtLT58IEJ1cnN0ICM4MyB8LS0+fCBs bHAgfAo+ID4+ICAgICAgICAgICAgICAgfCAgICAgICAgICAgICstLS0tLS0tLS0tLSsgICArLS0t LS0rICAgKy0tLS0tLS0tLS0tKyAgICstLS0tLSsKPiA+PiAgICAgICAgICAgICAgIFYKPiA+PiAg ICAgICAgICstLS0tLS0tLS0tKwo+ID4+ICAgICAgICAgfCBDaHVuayAjMiB8LS0tKwo+ID4+ICAg ICAgICAgfCAgQ0IgPSAxICB8ICAgfCAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rICAgKy0tLS0t LS0tLS0tLSsgICArLS0tLS0rCj4gPj4gICAgICAgICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJz dCAjODQgfC0tPnwgLi4uIHwtLT58IEJ1cnN0ICMxMjUgfC0tPnwgbGxwIHwKPiA+PiAgICAgICAg ICAgICAgIHwgICAgICAgICAgICArLS0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0t LS0rICAgKy0tLS0tKwo+ID4+ICAgICAgICAgICAgICAgVgo+ID4+ICAgICAgICAgKy0tLS0tLS0t LS0rCj4gPj4gICAgICAgICB8IENodW5rICMzIHwtLS0rCj4gPj4gICAgICAgICB8ICBDQiA9IDAg IHwgICB8ICAgKy0tLS0tLS0tLS0tLSsgICArLS0tLS0rICAgKy0tLS0tLS0tLS0tLSsgICArLS0t LS0rCj4gPj4gICAgICAgICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjMTI2IHwtLT58IC4u LiB8LS0+fCBCdXJzdCAjMTI5IHwtLT58IGxscCB8Cj4gPj4gICAgICAgICAgICAgICAgICAgICAg ICAgICAgKy0tLS0tLS0tLS0tLSsgICArLS0tLS0rICAgKy0tLS0tLS0tLS0tLSsgICArLS0tLS0r Cj4gPiAKPiA+IFRoaXMgaXMgZ3JlYXQgYW5kIHJlcXVpcmVkIHRvIHVuZGVyc3RhbmQgdGhlIGRy aXZlci4KPiA+IAo+ID4gSG93IGRvZXMgY29udHJvbGxlciBtb3ZlIGZyb20gQnVybnN0ICM0MSBv ZiBDaHVuayAwIHRvIENodW5rIDEgPwo+IAo+IEkgZm9yZ290IHRvIGV4cGxhaW4gdGhhdC4uLgo+ IAo+IE9uIGV2ZXJ5IGxhc3QgQnVyc3Qgb2YgdGhlIENodW5rIChCdXJzdCAjNDEsIEJ1cnN0ICM4 MywgQnVyc3QgIzEyNSBvciBldmVuIEJ1cnN0Cj4gIzEyOSkgaXMgc2V0IHNvbWUgZmxhZ3Mgb24g dGhlaXIgY29udHJvbCB2YXJpYWJsZSAoUklFIGFuZCBMSUUgYml0cykgdGhhdCB3aWxsCj4gdHJp Z2dlciB0aGUgc2VuZCBvZiAiZG9uZSIgaW50ZXJydXB0aW9uLgo+IAo+IE9uIHRoZSBpbnRlcnJ1 cHRpb25zIGNhbGxiYWNrLCBpcyBkZWNpZGVkIHdoZXRoZXIgdG8gcmVjeWNsZSB0aGUgbGlua2Vk IGxpc3QKPiBtZW1vcnkgc3BhY2UgYnkgd3JpdGluZyBhIG5ldyBzZXQgb2YgQnVyc3RzIGVsZW1l bnRzIChpZiBzdGlsbCBleGlzdHMgQ2h1bmtzIHRvCj4gdHJhbnNmZXIpIG9yIGlzIGNvbnNpZGVy ZWQgY29tcGxldGVkIChpZiB0aGVyZSBpcyBubyBDaHVua3MgYXZhaWxhYmxlIHRvIHRyYW5zZmVy KQo+IAo+ID4gSXMgQnVyc3QgMCB0byAxMjkgYSBsaW5rIGxpc3Qgd2l0aCBCdXJzdCAwLCA0Miwg ODQgYW5kIDEyNiBoYXZpbmcgYQo+ID4gY2FsbGJhY2sgKGRvbmUgYml0IHNldCkuLgo+IAo+IEkg ZGlkbid0IHF1aXRlIHVuZGVyc3RhbmQgaXQgeW91ciBxdWVzdGlvbi4KPiAKPiBJdCBjb21lcyBm cm9tIHRoZSBwcmVwX3NsYXZlX3NnIG4gZWxlbWVudHMgKDEzMCBhcHBseWluZyB0aGUgZXhhbXBs ZSksIHdoZXJlCj4gd2lsbCBiZSBkaXZpZGUgaW4gc2V2ZXJhbCBDaHVua3MgKCMwLCAjMSwgIzIs ICMzIGFuZCAjNCBhcHBseWluZyB0aGUgZXhhbXBsZSkgKGEKPiBsaW5rZWQgbGlzdCB0aGF0IHdp bGwgY29udGFpbiBhbm90aGVyIGxpbmtlZCBsaXN0IGZvciB0aGUgQnVyc3RzLCBDQiwgQ2h1bmsK PiBzaXplKS4gVGhlIGxpbmtlZCBsaXN0IGluc2lkZSBvZiBlYWNoIENodW5rIHdpbGwgY29udGFp biBhIG51bWJlciBvZiBCdXJzdHMKPiAobGltaXRlZCB0byB0aGUgbWVtb3J5IHNwYWNlIHNpemUp LCBlYWNoIG9uZSB3aWxsIHBvc3Nlc3MgU291cmNlIEFkZHJlc3MsCj4gRGVzdGluYXRpb24gQWRk cmVzcyBhbmQgc2l6ZSBvZiB0aGF0IHN1Yi10cmFuc2Zlci4KClRoYW5rcyB0aGlzIGhlbHBzIDop CgpzbyBpbiB0aGlzIGNhc2Ugd2hhdCBkb2VzIHByZXBfc2xhdmVfc2cgbiBlbGVtZW50cyBjb3Jy b3Nwb25kcyB0byAoMTMwCmJ1cnN0cykgLi4/IElmIHNvIGhvdyBkbyB5b3Ugc3BsaXQgYSB0cmFu c2FjdGlvbiB0byBjaHVua3MgYW5kIGJ1cnN0cz8KCgo+IAo+ID4gCj4gPiBUaGlzIHNvdW5kICoq dmVyeSoqIHNpbWlsYXIgdG8gZHcgZG1hIGNvbmNlcHRzIQo+IAo+IEkgYmVsaWV2ZSBzb21lIHBh cnRzIG9mIGR3IGRtYSBhbmQgZHcgZWRtYSBiZWhhdmlvciBhcmUgc2ltaWxhciBhbmQgdGhhdCBt YWtlcwo+IHBlcmZlY3RseSBzZW5zZSBzaW5jZSBib3RoIGRtYSBhcmUgZG9uZSBieSBTeW5vcHN5 cyBhbmQgbWF5IGJlIGV4aXN0IGEgc2hhcmVkCj4ga25vd2xlZGdlLCBob3dldmVyIHRoZXkgYXJl IGRpZmZlcmVudCBJUHMgYXBwbGllZCB0byBkaWZmZXJlbnQgcHJvZHVjdHMuCj4gCj4gPiAKPiA+ Pgo+ID4+IExlZ2VuZDoKPiA+Pgo+ID4+ICpMaW5rZWQgbGlzdCosIGFsc28ga25vdyBhcyBDaHVu awo+ID4+ICpMaW5rZWQgbGlzdCBlbGVtZW50KiwgYWxzbyBrbm93IGFzIEJ1cnN0Cj4gPj4gKkNC KiwgYWxzbyBrbm93IGFzIENoYW5nZSBCaXQsIGl0J3MgYSBjb250cm9sIGJpdCAoYW5kIHR5cGlj YWxseSBpcyB0b2dnbGVkKQo+ID4+IHRoYXQgYWxsb3dzIHRvIGVhc2lseSBpZGVudGlmeSBhbmQg ZGlmZmVyZW50aWF0ZSBiZXR3ZWVuIHRoZSBjdXJyZW50IGxpbmtlZCBsaXN0Cj4gPj4gYW5kIHRo ZSBwcmV2aW91cyBvciB0aGUgbmV4dCBvbmUuCj4gPj4gKkxMUCosIGlzIGEgc3BlY2lhbCBlbGVt ZW50IHRoYXQgaW5kaWNhdGVzIHRoZSBlbmQgb2YgdGhlIGxpbmtlZCBsaXN0IGVsZW1lbnQKPiA+ PiBzdHJlYW0gYWxzbyBpbmZvcm1zIHRoYXQgdGhlIG5leHQgQ0Igc2hvdWxkIGJlIHRvZ2dsZS4K PiA+Pgo+ID4+IE9uIHNjYXR0ZXItZ2F0aGVyIHRyYW5zZmVyIG1vZGUsIHRoZSBjbGllbnQgd2ls bCBzdWJtaXQgYSBzY2F0dGVyLWdhdGhlciBsaXN0IG9mCj4gPj4gbiAob24gdGhpcyBjYXNlIDEz MCkgZWxlbWVudHMsIHRoYXQgd2lsbCBiZSBkaXZpZGUgaW4gbXVsdGlwbGUgQ2h1bmtzLCBlYWNo Cj4gPj4gQ2h1bmsgd2lsbCBoYXZlIChvbiB0aGlzIGNhc2UgNDIpIGEgbGltaXRlZCBudW1iZXIg b2YgQnVyc3RzIGFuZCBhZnRlcgo+ID4+IHRyYW5zZmVycmluZyBhbGwgQnVyc3RzLCBhbiBpbnRl cnJ1cHQgd2lsbCBiZSB0cmlnZ2VyZWQsIHdoaWNoIHdpbGwgYWxsb3cgdG8KPiA+PiByZWN5Y2xl IHRoZSBhbGwgbGlua2VkIGxpc3QgZGVkaWNhdGVkIG1lbW9yeSBhZ2FpbiB3aXRoIHRoZSBuZXcg aW5mb3JtYXRpb24KPiA+PiByZWxhdGl2ZSB0byB0aGUgbmV4dCBDaHVuayBhbmQgcmVzcGVjdGl2 ZSBCdXJzdCBhc3NvY2lhdGVkIGFuZCByZXBlYXQgdGhlIHdob2xlCj4gPj4gY3ljbGUgYWdhaW4u Cj4gPj4KPiA+PiBPbiBjeWNsaWMgdHJhbnNmZXIgbW9kZSwgdGhlIGNsaWVudCB3aWxsIHN1Ym1p dCBhIGJ1ZmZlciBwb2ludGVyLCBsZW5ndGggb2YgaXQKPiA+PiBhbmQgbnVtYmVyIG9mIHJlcGV0 aXRpb25zLCBpbiB0aGlzIGNhc2UgZWFjaCBidXJzdCB3aWxsIGNvcnJlc3BvbmQgZGlyZWN0bHkg dG8KPiA+PiBlYWNoIHJlcGV0aXRpb24uCj4gPj4KPiA+PiBFYWNoIEJ1cnN0IGNhbiBkZXNjcmli ZXMgYSBkYXRhIHRyYW5zZmVyIGZyb20gcG9pbnQgQShzb3VyY2UpIHRvIHBvaW50Cj4gPj4gQihk ZXN0aW5hdGlvbikgd2l0aCBhIGxlbmd0aCB0aGF0IGNhbiBiZSBmcm9tIDEgYnl0ZSB1cCB0byA0 IEdCLiBTaW5jZSBkZWRpY2F0ZWQKPiA+PiB0aGUgbWVtb3J5IHNwYWNlIHdoZXJlIHRoZSBsaW5r ZWQgbGlzdCB3aWxsIHJlc2lkZSBpcyBsaW1pdGVkLCB0aGUgd2hvbGUgbiBidXJzdAo+ID4+IGVs ZW1lbnRzIHdpbGwgYmUgb3JnYW5pemVkIGluIHNldmVyYWwgQ2h1bmtzLCB0aGF0IHdpbGwgYmUg dXNlZCBsYXRlciB0byByZWN5Y2xlCj4gPj4gdGhlIGRlZGljYXRlZCBtZW1vcnkgc3BhY2UgdG8g aW5pdGlhdGUgYSBuZXcgc2VxdWVuY2Ugb2YgZGF0YSB0cmFuc2ZlcnMuCj4gPj4KPiA+PiBUaGUg d2hvbGUgdHJhbnNmZXIgaXMgY29uc2lkZXJlZCBoYXMgY29tcGxldGVkIHdoZW4gaXQgd2FzIHRy YW5zZmVycmVkIGFsbCBidXJzdHMuCj4gPj4KPiA+PiBDdXJyZW50bHkgdGhpcyBJUCBoYXMgYSBz ZXQgd2VsbC1rbm93biByZWdpc3RlciBtYXAsIHdoaWNoIGluY2x1ZGVzIHN1cHBvcnQgZm9yCj4g Pj4gbGVnYWN5IGFuZCB1bnJvbGwgbW9kZXMuIExlZ2FjeSBtb2RlIGlzIHZlcnNpb24gb2YgdGhp cyByZWdpc3RlciBtYXAgdGhhdCBoYXMKPiA+IAo+ID4gd2hhdHMgIHVucm9sbC4uCj4gPiAKPiA+ PiBtdWx0aXBsZXhlciByZWdpc3RlciB0aGF0IGFsbG93cyB0byBzd2l0Y2ggcmVnaXN0ZXJzIGJl dHdlZW4gYWxsIHdyaXRlIGFuZCByZWFkCj4gCj4gVGhlIHVucm9sbCBpcyBleHBsYWluZWQgaGVy ZSwgc2VlIGJlbG93Cj4gCj4gPj4gY2hhbm5lbHMgYW5kIHRoZSB1bnJvbGwgbW9kZXMgcmVwZWF0 cyBhbGwgd3JpdGUgYW5kIHJlYWQgY2hhbm5lbHMgcmVnaXN0ZXJzIHdpdGgKPiA+PiBhbiBvZmZz ZXQgYmV0d2VlbiB0aGVtLiBUaGlzIHJlZ2lzdGVyIG1hcCBpcyBjYWxsZWQgdjAuCj4gPj4KPiA+ PiBUaGUgSVAgdGVhbSBpcyBjcmVhdGluZyBhIG5ldyByZWdpc3RlciBtYXAgbW9yZSBzdWl0YWJs ZSB0byB0aGUgbGF0ZXN0IFBDSWUKPiA+PiBmZWF0dXJlcywgdGhhdCB2ZXJ5IGxpa2VseSB3aWxs IGNoYW5nZSB0aGUgbWFwIHJlZ2lzdGVyLCB3aGljaCB0aGlzIHZlcnNpb24gd2lsbAo+ID4+IGJl IGNhbGxlZCB2MS4gQXMgc29vbiBhcyB0aGlzIG5ldyB2ZXJzaW9uIGlzIHJlbGVhc2VkIGJ5IHRo ZSBJUCB0ZWFtIHRoZSBzdXBwb3J0Cj4gPj4gZm9yIHRoaXMgdmVyc2lvbiBpbiBiZSBpbmNsdWRl ZCBvbiB0aGlzIGRyaXZlci4KPiA+Pgo+ID4+IFdoYXQgZG8geW91IHRoaW5rPyBUaGVyZSBpcyBh bnkgZ3JheSBhcmVhIHRoYXQgSSBjb3VsZCBjbGFyaWZ5Pwo+ID4gCj4gPiBUaGlzIHNvdW5kcyBn b29kLiBCdXQgd2UgYXJlIGFsc28gY2F0ZXJpbmcgdG8gYSBXSVAgSVAgd2hpY2ggY2FuIGNoYW5n ZQo+ID4gcmlnaHQuIERvZXNudCBzb3VuZCB2ZXJ5IGdvb2QgaWRlYSB0byBtZSA6KQo+IAo+IFRo aXMgSVAgZXhpc3RzIGZvciBzZXZlcmFsIHllYXJzIGxpa2UgdGhpcyBhbmQgaXQgd29ya3MgcXVp dGUgZmluZSwgaG93ZXZlcgo+IGJlY2F1c2Ugb2YgbmV3IGZlYXR1cmVzIGFuZCByZXF1ZXN0cyAo U1ItSU9WLCBtb3JlIGRtYSBjaGFubmVscywgZnVuY3Rpb24KPiBzZWdyZWdhdGlvbiBhbmQgaXNv bGF0aW9uLCBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudCkgdGhhdCBhcmUgY29taW5nIGl0J3MgbmF0 dXJhbAo+IHRvIGhhdmUgZXhpc3QgaW1wcm92ZW1lbnRzLiBUaGUgZHJpdmVycyBzaG91bGQgZm9s bG93IHRoZSBldm9sdXRpb24gYW5kIGJlCj4gc3VmZmljaWVudCByb2J1c3QgZW5vdWdoIHRvIGFk YXB0IHRvIHRoaXMgbmV3IGNpcmN1bXN0YW5jZS4KCktlcm5lbCBkcml2ZXIgc2hvdWxkIGJlIG1v ZHVsYXIgYmUgZGVzaWduLCBpZiB3ZSBrZWVwIHRoaW5ncyBzaW1wbGUgdGhlbgphZGRpbmcvc3Bs aXR0aW5nIHRvIHN1cHBvcnQgZnV0dXJlIHJldmlzaW9ucyBzaG91bGQgYmUgZWFzeSEKCj4gPj4+ Pj4+ICsJZGV2X2RiZyhjaGFuMmRldihjaGFuKSwgImFkZHIocGh5c2ljYWwpIHNyYz0lcGEsIGRz dD0lcGFcbiIsCj4gPj4+Pj4+ICsJCSZjb25maWctPnNyY19hZGRyLCAmY29uZmlnLT5kc3RfYWRk cik7Cj4gPj4+Pj4+ICsKPiA+Pj4+Pj4gKwljaGFuLT5zcmNfYWRkciA9IGNvbmZpZy0+c3JjX2Fk ZHI7Cj4gPj4+Pj4+ICsJY2hhbi0+ZHN0X2FkZHIgPSBjb25maWctPmRzdF9hZGRyOwo+ID4+Pj4+ PiArCj4gPj4+Pj4+ICsJZXJyID0gb3BzLT5kZXZpY2VfY29uZmlnKGRjaGFuKTsKPiA+Pj4+Pgo+ ID4+Pj4+IHdoYXQgZG9lcyB0aGlzIGRvPwo+ID4+Pj4KPiA+Pj4+IFRoaXMgaXMgYW4gaW5pdGlh bGl6YXRpb24gcHJvY2VkdXJlIHRvIHNldHVwIGludGVycnVwdHMgKGRhdGEgYW5kIGFkZHJlc3Nl cykgdG8KPiA+Pj4+IGVhY2ggY2hhbm5lbCBvbiB0aGUgZURNQSBJUCwgIGluIG9yZGVyIHRvIGJl IHRyaWdnZXJlZCBhZnRlciB0cmFuc2ZlciBiZWluZwo+ID4+Pj4gY29tcGxldGVkIG9yIGFib3J0 ZWQuIER1ZSB0aGUgZmFjdCB0aGUgY29uZmlnKCkgY2FuIGJlIGNhbGxlZCBhdCBhbnl0aW1lLAo+ ID4+Pj4gZG9lc24ndCBtYWtlIHNlbnNlIHRvIGhhdmUgdGhpcyBwcm9jZWR1cmUgaGVyZSwgSSds bCBtb3ZlZCBpdCB0byBwcm9iZSgpLgo+ID4+Pgo+ID4+PiBZZWFoIEkgYW0gbm90IHN0aWxsIGNv bnZpbmNlZCBhYm91dCBoYXZpbmcgYW5vdGhlciBsYXllciEgSGF2ZSB5b3UKPiA+Pj4gdGhvdWdo IGFib3V0IHVzaW5nIGNvbW1vbiBsaWIgZm9yIGNvbW1vbiBwYXJ0cyAuLj8KPiA+Pgo+ID4+IE1h eWJlIEknbSBleHBsYWluaW5nIG15c2VsZiB3cm9uZ2x5LiBJIGRvbid0IGhhdmUgYW55IGNsdWUg YWJvdXQgdGhlIG5ldwo+ID4+IHJlZ2lzdGVyIG1hcCBmb3IgdGhlIGZ1dHVyZSB2ZXJzaW9ucy4g SSBob25lc3RseSB0cmllZCB0byBpbXBsZW1lbnQgdGhlIGNvbW1vbgo+ID4+IGxpYiBmb3IgdGhl IHdob2xlIHByb2Nlc3MgdGhhdCBpbnRlcmFjdCB3aXRoIGRtYSBlbmdpbmUgY29udHJvbGxlciB0 byBlYXNlIGluCj4gPj4gdGhlIGZ1dHVyZSBhbnkgbmV3IGFkZGl0aW9uIG9mIHJlZ2lzdGVyIG1h cHBpbmcsIGJ5IGhhdmluZyB0aGlzIGNvbW1vbiBjYWxsYmFja3MKPiA+PiB0aGF0IHdpbGwgb25s eSBiZSByZXNwb25zaWJsZSBmb3IgaW50ZXJmYWNpbmcgdGhlIEhXIGFjY29yZGluZ2x5IHRvIHJl Z2lzdGVyIG1hcAo+ID4+IHZlcnNpb24uIE1heWJlIEkgY2FuIHNpbXBsaWZ5IHNvbWV0aGluZyBp biB0aGUgZnV0dXJlLCBidXQgSSBvbmx5IGJlIGFibGUgdG8KPiA+PiBjb25jbHVkZSB0aGF0IGFm dGVyIGhhdmluZyBzb21lIGlkZWEgYWJvdXQgdGhlIG5ldyByZWdpc3RlciBtYXAuCj4gPj4KPiA+ PiBJTUhPIEkgdGhpbmsgdGhpcyBpcyB0aGUgZWFzaWVyIGFuZCBjbGVhbiB3YXkgdG8gZG8gaXQs IGluIHRlcm1zIG9mIGNvZGUKPiA+PiBtYWludGVuYW5jZSBhbmQgYXJjaGl0ZWN0dXJlLCBidXQg aWYgeW91IGhhdmUgYW5vdGhlciBpZGVhIHRoYXQgeW91IGNhbiBzaG93IG1lCj4gPj4gb3IgcG9p bnRpbmcgb3V0IGZvciBhIGRyaXZlciB0aGF0IGltcGxlbWVudHMgc29tZXRoaW5nIHNpbWlsYXIs IEknbSBubyBwcm9ibGVtCj4gPj4gdG8gY2hlY2sgaXQgb3V0Lgo+ID4gCj4gPiBUaGF0IGlzIHdo YXQgbXkgZmVhciB3YXMgOikKPiA+IAo+ID4gTGV0cyBzdGVwIGJhY2sgYW5kIHNvbHZlIG9uZSBw cm9ibGVtIGF0IGEgdGltZS4gUmlnaHQgbm93IHRoYXQgaXMgdjAgb2YKPiA+IElQLiBQbGVhc2Ug d3JpdGUgYSBzaW1wbGUgZHJpdmVyIHdoaWNoIHNvbHZlIHYwIHdpdGhvdXQgYW55IGxheWVycwo+ ID4gaW52b2x2ZWQuCj4gPiAKPiA+IE9uY2UgdjEgaXMgaW4gZ29vZCBzaGFwZSwgeW91IHdvdWxk IGtub3cgd2hhdCBpdCByZXF1aXJlZCBhbmQgdGhlbiB3ZQo+ID4gY2FuIHNwbGl0IHYwIGRyaXZl ciBpbnRvIGNvbW1vbiBsaWIgYW5kIHYwIGRyaXZlciBhbmQgdGhlbiBhZGQgdjEKPiA+IGRyaXZl ci4KPiAKPiBDYW4gSSBrZWVwIHRoZSBjb2RlIHNlZ3JlZ2F0aW9uIGFzIGl0IGlzIG5vdz8gV2l0 aCB0aGUgZHctZWRtYS12MC1jb3JlLmMvaCwKPiBkdy1lZG1hLXYwLWRlYnVnZnMuYy9oIGFuZCBk dy1lZG1hLXYwLXJlZ3MuaAo+IAo+IFRoYXQgd2F5IEkgd291bGQgb25seSByZXBsYWNlIHRoZSBj YWxsYmFja3MgY2FsbHMgdG8gZGlyZWN0IGZ1bmN0aW9uIGNhbGxzIGFuZAo+IHJlbW92ZSB0aGUg c3dpdGNoIGNhc2UgY2FsbGJhY2sgc2VsZWN0aW9uIGJhc2Ugb24gdGhlIHZlcnNpb24uCgpUaGF0 IHNvdW5kIGJldHRlciwgcGxlYXNlIGtlZXAgcGF0Y2hlcyBzbWFsbGlzaCAoYW55dGhpbmcgZ29p bmcgbW9yZQp0aGFuIDYwMCBsaW5lcyBiZWNvbWVzIGhhcmRlciB0byByZXZpZXcpIGFuZCBsb2dp Y2FsbHkgc3BsaXQuCgo+ID4+Pj4+IHdoYXQgaXMgdGhlIHNlY29uZCBwYXJ0IG9mIHRoZSBjaGVj aywgY2FuIHlvdSBleHBsYWluIHRoYXQsIHdobyBzZXRzCj4gPj4+Pj4gY2hhbi0+ZGlyPwo+ID4+ Pj4KPiA+Pj4+IFRoZSBjaGFuLT5kaXIgaXMgc2V0IG9uIHByb2JlKCkgZHVyaW5nIHRoZSBwcm9j ZXNzIG9mIGNvbmZpZ3VyaW5nIGVhY2ggY2hhbm5lbC4KPiA+Pj4KPiA+Pj4gU28geW91IGhhdmUg Y2hhbm5lbHMgdGhhdCBhcmUgdW5pZGlyZWN0aW9uYWw/Cj4gPj4KPiA+PiBZZXMuIFRoYXQncyBv bmUgYW5vdGhlciByZWFzb24gSU1ITyB0byBrZWVwIHRoZSBkdy1lZG1hLXRlc3Qgc2VwYXJhdGUg ZnJvbQo+ID4+IGRtYS10ZXN0LCBzaW5jZSB0aGlzIElQIGlzIG1vcmUgcGlja3kgYW5kIGhhdmUg dGhpcyBwYXJ0aWN1bGFyaXRpZXMuCj4gPiAKPiA+IFRoYXQgaXMgb2theSwgdGhhdCBzaG91bGQg YmUgaGFuZGxlZCBieSBwcmVwIGNhbGxzLCBpZiB5b3UgZ2V0IGEgcHJlcAo+ID4gY2FsbCBmb3Ig ZGlyZWN0aW9uIHlvdSBkb250IHN1cHBvcnQgcmV0dXJuIGVycm9yIGFuZCBtb3ZlIHRvIG5leHQK PiA+IGF2YWlsYWJsZSBvbmUuCj4gPiAKPiA+IFRoYXQgY2FuIGJlIGRvbmUgZ2VuZXJpY2FsbHkg aW4gZG1hdGVzdCBkcml2ZXIgYW5kIHRvIGFuc3dlciB5b3VyCj4gPiBxdWVzdGlvbiwgeWVzIEkg d291bGQgdGVzdCB0aGF0IDopCj4gCj4gTGlrZSB5b3Ugc2FpZCwgbGV0IGRvIHRoaXMgaW4gc21h bGwgc3RlcHMuIEZvciBub3cgSSB3b3VsZCBsaWtlIHRvIHN1Z2dlc3QgdG8KPiBsZWF2ZSBvdXQg dGhlIGR3LWRtYS10ZXN0IGRyaXZlciBhbmQganVzdCBmb2N1cyBvbiB0aGUgY3VycmVudCBkcml2 ZXIsIGlmIHlvdQo+IGRvbid0IG1pbmQuIEkgbmV2ZXIgdGhvdWdodCB0aGF0IGhpcyB0ZXN0IGRy aXZlciB3b3VsZCByYWlzZSB0aGlzIGtpbmQgb2YgZGlzY3Vzcy4KCldlbGwgZG1hdGVzdCBpcyBq dXN0IGEgdGVzdGluZyBhaWQgYW5kIGRvZXNudCBjYXJlIGFib3V0IGludGVybmFsCmRlc2lnbnMg b2YgeW91ciBkcml2ZXIuIEkgd291bGQgc2F5IGtlZXAgaXQgYXMgaXQgaXMgdXNlZnVsIGFpZCBh bmQgd2lsbApoZWxwIG90aGVyIGZvbGtzIGFzIHdlbGwgOikK 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=-2.6 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,MAILING_LIST_MULTI,SPF_PASS,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 6BCCBC282D7 for ; Sat, 2 Feb 2019 10:09:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1E84C21479 for ; Sat, 2 Feb 2019 10:09:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1549102148; bh=+vywMwY1xwIcSVAYn6HccbRIwl3EtE39MEVw2XnBNeU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:List-ID:From; b=AFBwDEuV7Y74nNSFCRQVkQDZPKJKueAA71oMDzgswV0T3VodTzmOPyW2XicEwJHDO hTdwCjsq5Tuj3lcJSM7iphd1k3R25FI0Pfb0uUCFKCxxwRmwDXnIL4m/D1avAp1fSf ewGSEgaawtlPb/Dohohb4NxAY+iGLC4CnZNz/NBk= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726659AbfBBKJH (ORCPT ); Sat, 2 Feb 2019 05:09:07 -0500 Received: from mail.kernel.org ([198.145.29.99]:58476 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726255AbfBBKJH (ORCPT ); Sat, 2 Feb 2019 05:09:07 -0500 Received: from localhost (unknown [125.16.100.118]) (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 AFF8F2084C; Sat, 2 Feb 2019 10:09:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1549102145; bh=+vywMwY1xwIcSVAYn6HccbRIwl3EtE39MEVw2XnBNeU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=j5kq3eTGwwnGAcszHCXQmqs6qBQnR634m8aSOWFUdEnQnduL7d25604PnmcoYMrxw VvquPa8C+S2ueaqMFvkNBYcDliQ+5Du8yplugjBg03tCsxcSaMkMTy/JBan7Qbvh7Y klaRfJ/BCqm1Md/+H9qlnKuu+NA2Mhl2MTn6lq4s= Date: Sat, 2 Feb 2019 15:37:35 +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: <20190202100735.GD4296@vkoul-mobl> References: <20190120114425.GV4635@vkoul-mobl> <14acfcee-b367-be9c-714b-de0508ff1a7d@synopsys.com> <20190123130829.GQ4635@vkoul-mobl> <20190201041400.GL4635@vkoul-mobl> 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 01-02-19, 11:23, Gustavo Pimentel wrote: > On 01/02/2019 04:14, Vinod Koul wrote: > > On 31-01-19, 11:33, Gustavo Pimentel wrote: > >> On 23/01/2019 13:08, Vinod Koul wrote: > >>> On 21-01-19, 15:48, Gustavo Pimentel wrote: > >>>> On 20/01/2019 11:44, Vinod Koul wrote: > >>>>> On 11-01-19, 19:33, Gustavo Pimentel wrote: > > > >>>>>> @@ -0,0 +1,1059 @@ > >>>>>> +// SPDX-License-Identifier: GPL-2.0 > >>>>>> +/* > >>>>>> + * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates. > >>>>> > >>>>> 2019 now > >>>> > >>>> I've changed to "Copyright (c) 2018-present Synopsys, Inc. and/or its > >>>> affiliates." this way it's always up to date and I also kept 2018, because it > >>>> was the date that I started to develop this driver, if you don't mind. > >>> > >>> yeah 18 is fine :) it need to end with current year always > >> > >> Just to be sure, are you saying that must be: "Copyright (c) 2018-2019 Synopsys, > >> Inc. and/or its affiliates."? > > > > Yup :) > > > >>>>>> +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 ..? > >>>> > >>>> CB = change bit, is a property of this eDMA IP. Basically it is a kind of > >>>> handshake which serves to validate whether the linked list has been updated or > >>>> not, especially useful in cases of recycled linked list elements (every linked > >>>> list recycle is a new chunk, this will allow to differentiate each chunk). > >>> > >>> okay please add that somewhere. Also it would help me if you explain > >>> what is chunk and other terminologies used in this driver > >> > >> I'm thinking to put the below description on the patch, please check if this is > >> sufficient explicit and clear to understand what this IP needs and does. > >> > >> In order to transfer data from point A to B as fast as possible this IP requires > >> a dedicated memory space where will reside a linked list of elements. > > > > rephrasing: a dedicated memory space containing linked list of elements > > > >> All elements of this linked list are continuous and each one describes a data > >> transfer (source and destination addresses, length and a control variable). > >> > >> For the sake of simplicity, lets assume a memory space for channel write 0 which > >> allows about 42 elements. > >> > >> +---------+ > >> | Desc #0 |--+ > >> +---------+ | > >> V > >> +----------+ > >> | Chunk #0 |---+ > >> | CB = 1 | | +----------+ +-----+ +-----------+ +-----+ > >> +----------+ +-->| Burst #0 |-->| ... |-->| Burst #41 |-->| llp | > >> | +----------+ +-----+ +-----------+ +-----+ > >> V > >> +----------+ > >> | Chunk #1 |---+ > >> | CB = 0 | | +-----------+ +-----+ +-----------+ +-----+ > >> +----------+ +-->| Burst #42 |-->| ... |-->| Burst #83 |-->| llp | > >> | +-----------+ +-----+ +-----------+ +-----+ > >> V > >> +----------+ > >> | Chunk #2 |---+ > >> | CB = 1 | | +-----------+ +-----+ +------------+ +-----+ > >> +----------+ +-->| Burst #84 |-->| ... |-->| Burst #125 |-->| llp | > >> | +-----------+ +-----+ +------------+ +-----+ > >> V > >> +----------+ > >> | Chunk #3 |---+ > >> | CB = 0 | | +------------+ +-----+ +------------+ +-----+ > >> +----------+ +-->| Burst #126 |-->| ... |-->| Burst #129 |-->| llp | > >> +------------+ +-----+ +------------+ +-----+ > > > > This is great and required to understand the driver. > > > > How does controller move from Burnst #41 of Chunk 0 to Chunk 1 ? > > I forgot to explain that... > > On every last Burst of the Chunk (Burst #41, Burst #83, Burst #125 or even Burst > #129) is set some flags on their control variable (RIE and LIE bits) that will > trigger the send of "done" interruption. > > On the interruptions callback, is decided whether to recycle the linked list > memory space by writing a new set of Bursts elements (if still exists Chunks to > transfer) or is considered completed (if there is no Chunks available to transfer) > > > Is Burst 0 to 129 a link list with Burst 0, 42, 84 and 126 having a > > callback (done bit set).. > > I didn't quite understand it your question. > > It comes from the prep_slave_sg n elements (130 applying the example), where > will be divide in several Chunks (#0, #1, #2, #3 and #4 applying the example) (a > linked list that will contain another linked list for the Bursts, CB, Chunk > size). The linked list inside of each Chunk will contain a number of Bursts > (limited to the memory space size), each one will possess Source Address, > Destination Address and size of that sub-transfer. Thanks this helps :) so in this case what does prep_slave_sg n elements corrosponds to (130 bursts) ..? If so how do you split a transaction to chunks and bursts? > > > > > This sound **very** similar to dw dma concepts! > > I believe some parts of dw dma and dw edma behavior are similar and that makes > perfectly sense since both dma are done by Synopsys and may be exist a shared > knowledge, however they are different IPs applied to different products. > > > > >> > >> Legend: > >> > >> *Linked list*, also know as Chunk > >> *Linked list element*, also know as Burst > >> *CB*, also know as Change Bit, it's a control bit (and typically is toggled) > >> that allows to easily identify and differentiate between the current linked list > >> and the previous or the next one. > >> *LLP*, is a special element that indicates the end of the linked list element > >> stream also informs that the next CB should be toggle. > >> > >> On scatter-gather transfer mode, the client will submit a scatter-gather list of > >> n (on this case 130) elements, that will be divide in multiple Chunks, each > >> Chunk will have (on this case 42) a limited number of Bursts and after > >> transferring all Bursts, an interrupt will be triggered, which will allow to > >> recycle the all linked list dedicated memory again with the new information > >> relative to the next Chunk and respective Burst associated and repeat the whole > >> cycle again. > >> > >> On cyclic transfer mode, the client will submit a buffer pointer, length of it > >> and number of repetitions, in this case each burst will correspond directly to > >> each repetition. > >> > >> Each Burst can describes a data transfer from point A(source) to point > >> B(destination) with a length that can be from 1 byte up to 4 GB. Since dedicated > >> the memory space where the linked list will reside is limited, the whole n burst > >> elements will be organized in several Chunks, that will be used later to recycle > >> the dedicated memory space to initiate a new sequence of data transfers. > >> > >> The whole transfer is considered has completed when it was transferred all bursts. > >> > >> Currently this IP has a set well-known register map, which includes support for > >> legacy and unroll modes. Legacy mode is version of this register map that has > > > > whats unroll.. > > > >> multiplexer register that allows to switch registers between all write and read > > The unroll is explained here, see below > > >> channels and the unroll modes repeats all write and read channels registers with > >> an offset between them. This register map is called v0. > >> > >> The IP team is creating a new register map more suitable to the latest PCIe > >> features, that very likely will change the map register, which this version will > >> be called v1. As soon as this new version is released by the IP team the support > >> for this version in be included on this driver. > >> > >> What do you think? There is any gray area that I could clarify? > > > > This sounds good. But we are also catering to a WIP IP which can change > > right. Doesnt sound very good idea to me :) > > This IP exists for several years like this and it works quite fine, however > because of new features and requests (SR-IOV, more dma channels, function > segregation and isolation, performance improvement) that are coming it's natural > to have exist improvements. The drivers should follow the evolution and be > sufficient robust enough to adapt to this new circumstance. Kernel driver should be modular be design, if we keep things simple then adding/splitting to support future revisions should be easy! > >>>>>> + 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? > >>>> > >>>> This is an initialization procedure to setup interrupts (data and addresses) to > >>>> each channel on the eDMA IP, in order to be triggered after transfer being > >>>> completed or aborted. Due the fact the config() can be called at anytime, > >>>> doesn't make sense to have this procedure here, I'll moved it to probe(). > >>> > >>> Yeah I am not still convinced about having another layer! Have you > >>> though about using common lib for common parts ..? > >> > >> Maybe I'm explaining myself wrongly. I don't have any clue about the new > >> register map for the future versions. I honestly tried to implement the common > >> lib for the whole process that interact with dma engine controller to ease in > >> the future any new addition of register mapping, by having this common callbacks > >> that will only be responsible for interfacing the HW accordingly to register map > >> version. Maybe I can simplify something in the future, but I only be able to > >> conclude that after having some idea about the new register map. > >> > >> IMHO I think this is the easier and clean way to do it, in terms of code > >> maintenance and architecture, but if you have another idea that you can show me > >> or pointing out for a driver that implements something similar, I'm no problem > >> to check it out. > > > > That is what my fear was :) > > > > Lets step back and solve one problem at a time. Right now that is v0 of > > IP. Please write a simple driver which solve v0 without any layers > > involved. > > > > Once v1 is in good shape, you would know what it required and then we > > can split v0 driver into common lib and v0 driver and then add v1 > > driver. > > Can I keep the code segregation as it is now? With the dw-edma-v0-core.c/h, > dw-edma-v0-debugfs.c/h and dw-edma-v0-regs.h > > That way I would only replace the callbacks calls to direct function calls and > remove the switch case callback selection base on the version. That sound better, please keep patches smallish (anything going more than 600 lines becomes harder to review) and logically split. > >>>>> what is the second part of the check, can you explain that, who sets > >>>>> chan->dir? > >>>> > >>>> The chan->dir is set on probe() during the process of configuring each channel. > >>> > >>> So you have channels that are unidirectional? > >> > >> Yes. That's one another reason IMHO to keep the dw-edma-test separate from > >> dma-test, since this IP is more picky and have this particularities. > > > > That is okay, that should be handled by prep calls, if you get a prep > > call for direction you dont support return error and move to next > > available one. > > > > That can be done generically in dmatest driver and to answer your > > question, yes I would test that :) > > Like you said, let do this in small steps. For now I would like to suggest to > leave out the dw-dma-test driver and just focus on the current driver, if you > don't mind. I never thought that his test driver would raise this kind of discuss. Well dmatest is just a testing aid and doesnt care about internal designs of your driver. I would say keep it as it is useful aid and will help other folks as well :) -- ~Vinod