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: Fri, 1 Feb 2019 11:23:33 +0000 To: Vinod Koul , 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: T24gMDEvMDIvMjAxOSAwNDoxNCwgVmlub2QgS291bCB3cm90ZToKPiBPbiAzMS0wMS0xOSwgMTE6 MzMsIEd1c3Rhdm8gUGltZW50ZWwgd3JvdGU6Cj4+IE9uIDIzLzAxLzIwMTkgMTM6MDgsIFZpbm9k IEtvdWwgd3JvdGU6Cj4+PiBPbiAyMS0wMS0xOSwgMTU6NDgsIEd1c3Rhdm8gUGltZW50ZWwgd3Jv dGU6Cj4+Pj4gT24gMjAvMDEvMjAxOSAxMTo0NCwgVmlub2QgS291bCB3cm90ZToKPj4+Pj4gT24g MTEtMDEtMTksIDE5OjMzLCBHdXN0YXZvIFBpbWVudGVsIHdyb3RlOgo+IAo+Pj4+Pj4gQEAgLTAs MCArMSwxMDU5IEBACj4+Pj4+PiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAK Pj4+Pj4+ICsvKgo+Pj4+Pj4gKyAqIENvcHlyaWdodCAoYykgMjAxOCBTeW5vcHN5cywgSW5jLiBh bmQvb3IgaXRzIGFmZmlsaWF0ZXMuCj4+Pj4+Cj4+Pj4+IDIwMTkgbm93Cj4+Pj4KPj4+PiBJJ3Zl IGNoYW5nZWQgdG8gIkNvcHlyaWdodCAoYykgMjAxOC1wcmVzZW50IFN5bm9wc3lzLCBJbmMuIGFu ZC9vciBpdHMKPj4+PiBhZmZpbGlhdGVzLiIgdGhpcyB3YXkgaXQncyBhbHdheXMgdXAgdG8gZGF0 ZSBhbmQgSSBhbHNvIGtlcHQgMjAxOCwgYmVjYXVzZSBpdAo+Pj4+IHdhcyB0aGUgZGF0ZSB0aGF0 IEkgc3RhcnRlZCB0byBkZXZlbG9wIHRoaXMgZHJpdmVyLCBpZiB5b3UgZG9uJ3QgbWluZC4KPj4+ Cj4+PiB5ZWFoIDE4IGlzIGZpbmUgOikgaXQgbmVlZCB0byBlbmQgd2l0aCBjdXJyZW50IHllYXIg YWx3YXlzCj4+Cj4+IEp1c3QgdG8gYmUgc3VyZSwgYXJlIHlvdSBzYXlpbmcgdGhhdCBtdXN0IGJl OiAiQ29weXJpZ2h0IChjKSAyMDE4LTIwMTkgU3lub3BzeXMsCj4+IEluYy4gYW5kL29yIGl0cyBh ZmZpbGlhdGVzLiI/Cj4gCj4gWXVwIDopCj4gCj4+Pj4+PiArc3RhdGljIHN0cnVjdCBkd19lZG1h X2NodW5rICpkd19lZG1hX2FsbG9jX2NodW5rKHN0cnVjdCBkd19lZG1hX2Rlc2MgKmRlc2MpCj4+ Pj4+PiArewo+Pj4+Pj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuID0gZGVzYy0+Y2hhbjsK Pj4+Pj4+ICsJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hhbi0+Y2hpcC0+ZHc7Cj4+Pj4+PiArCXN0 cnVjdCBkd19lZG1hX2NodW5rICpjaHVuazsKPj4+Pj4+ICsKPj4+Pj4+ICsJY2h1bmsgPSBrdnph bGxvYyhzaXplb2YoKmNodW5rKSwgR0ZQX05PV0FJVCk7Cj4+Pj4+PiArCWlmICh1bmxpa2VseSgh Y2h1bmspKQo+Pj4+Pj4gKwkJcmV0dXJuIE5VTEw7Cj4+Pj4+PiArCj4+Pj4+PiArCUlOSVRfTElT VF9IRUFEKCZjaHVuay0+bGlzdCk7Cj4+Pj4+PiArCWNodW5rLT5jaGFuID0gY2hhbjsKPj4+Pj4+ ICsJY2h1bmstPmNiID0gIShkZXNjLT5jaHVua3NfYWxsb2MgJSAyKTsKPj4+Pj4KPj4+Pj4gY2Ig Li4/Cj4+Pj4KPj4+PiBDQiA9IGNoYW5nZSBiaXQsIGlzIGEgcHJvcGVydHkgb2YgdGhpcyBlRE1B IElQLiBCYXNpY2FsbHkgaXQgaXMgYSBraW5kIG9mCj4+Pj4gaGFuZHNoYWtlIHdoaWNoIHNlcnZl cyB0byB2YWxpZGF0ZSB3aGV0aGVyIHRoZSBsaW5rZWQgbGlzdCBoYXMgYmVlbiB1cGRhdGVkIG9y Cj4+Pj4gbm90LCBlc3BlY2lhbGx5IHVzZWZ1bCBpbiBjYXNlcyBvZiByZWN5Y2xlZCBsaW5rZWQg bGlzdCBlbGVtZW50cyAoZXZlcnkgbGlua2VkCj4+Pj4gbGlzdCByZWN5Y2xlIGlzIGEgbmV3IGNo dW5rLCB0aGlzIHdpbGwgYWxsb3cgdG8gZGlmZmVyZW50aWF0ZSBlYWNoIGNodW5rKS4KPj4+Cj4+ PiBva2F5IHBsZWFzZSBhZGQgdGhhdCBzb21ld2hlcmUuIEFsc28gaXQgd291bGQgaGVscCBtZSBp ZiB5b3UgZXhwbGFpbgo+Pj4gd2hhdCBpcyBjaHVuayBhbmQgb3RoZXIgdGVybWlub2xvZ2llcyB1 c2VkIGluIHRoaXMgZHJpdmVyCj4+Cj4+IEknbSB0aGlua2luZyB0byBwdXQgdGhlIGJlbG93IGRl c2NyaXB0aW9uIG9uIHRoZSBwYXRjaCwgcGxlYXNlIGNoZWNrIGlmIHRoaXMgaXMKPj4gc3VmZmlj aWVudCBleHBsaWNpdCBhbmQgY2xlYXIgdG8gdW5kZXJzdGFuZCB3aGF0IHRoaXMgSVAgbmVlZHMg YW5kIGRvZXMuCj4+Cj4+IEluIG9yZGVyIHRvIHRyYW5zZmVyIGRhdGEgZnJvbSBwb2ludCBBIHRv IEIgYXMgZmFzdCBhcyBwb3NzaWJsZSB0aGlzIElQIHJlcXVpcmVzCj4+IGEgZGVkaWNhdGVkIG1l bW9yeSBzcGFjZSB3aGVyZSB3aWxsIHJlc2lkZSBhIGxpbmtlZCBsaXN0IG9mIGVsZW1lbnRzLgo+ IAo+IHJlcGhyYXNpbmc6IGEgZGVkaWNhdGVkIG1lbW9yeSBzcGFjZSBjb250YWluaW5nIGxpbmtl ZCBsaXN0IG9mIGVsZW1lbnRzCj4gCj4+IEFsbCBlbGVtZW50cyBvZiB0aGlzIGxpbmtlZCBsaXN0 IGFyZSBjb250aW51b3VzIGFuZCBlYWNoIG9uZSBkZXNjcmliZXMgYSBkYXRhCj4+IHRyYW5zZmVy IChzb3VyY2UgYW5kIGRlc3RpbmF0aW9uIGFkZHJlc3NlcywgbGVuZ3RoIGFuZCBhIGNvbnRyb2wg dmFyaWFibGUpLgo+Pgo+PiBGb3IgdGhlIHNha2Ugb2Ygc2ltcGxpY2l0eSwgbGV0cyBhc3N1bWUg YSBtZW1vcnkgc3BhY2UgZm9yIGNoYW5uZWwgd3JpdGUgMCB3aGljaAo+PiBhbGxvd3MgYWJvdXQg NDIgZWxlbWVudHMuCj4+Cj4+ICstLS0tLS0tLS0rCj4+IHwgRGVzYyAjMCB8LS0rCj4+ICstLS0t LS0tLS0rICB8Cj4+ICAgICAgICAgICAgICBWCj4+ICAgICAgICAgKy0tLS0tLS0tLS0rCj4+ICAg ICAgICAgfCBDaHVuayAjMCB8LS0tKwo+PiAgICAgICAgIHwgIENCID0gMSAgfCAgIHwgICArLS0t LS0tLS0tLSsgICArLS0tLS0rICAgKy0tLS0tLS0tLS0tKyAgICstLS0tLSsKPj4gICAgICAgICAr LS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjMCB8LS0+fCAuLi4gfC0tPnwgQnVyc3QgIzQxIHwt LT58IGxscCB8Cj4+ICAgICAgICAgICAgICAgfCAgICAgICAgICAgICstLS0tLS0tLS0tKyAgICst LS0tLSsgICArLS0tLS0tLS0tLS0rICAgKy0tLS0tKwo+PiAgICAgICAgICAgICAgIFYKPj4gICAg ICAgICArLS0tLS0tLS0tLSsKPj4gICAgICAgICB8IENodW5rICMxIHwtLS0rCj4+ICAgICAgICAg fCAgQ0IgPSAwICB8ICAgfCAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rICAgKy0tLS0tLS0tLS0t KyAgICstLS0tLSsKPj4gICAgICAgICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjNDIgfC0t PnwgLi4uIHwtLT58IEJ1cnN0ICM4MyB8LS0+fCBsbHAgfAo+PiAgICAgICAgICAgICAgIHwgICAg ICAgICAgICArLS0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLSsgICArLS0tLS0r Cj4+ICAgICAgICAgICAgICAgVgo+PiAgICAgICAgICstLS0tLS0tLS0tKwo+PiAgICAgICAgIHwg Q2h1bmsgIzIgfC0tLSsKPj4gICAgICAgICB8ICBDQiA9IDEgIHwgICB8ICAgKy0tLS0tLS0tLS0t KyAgICstLS0tLSsgICArLS0tLS0tLS0tLS0tKyAgICstLS0tLSsKPj4gICAgICAgICArLS0tLS0t LS0tLSsgICArLS0+fCBCdXJzdCAjODQgfC0tPnwgLi4uIHwtLT58IEJ1cnN0ICMxMjUgfC0tPnwg bGxwIHwKPj4gICAgICAgICAgICAgICB8ICAgICAgICAgICAgKy0tLS0tLS0tLS0tKyAgICstLS0t LSsgICArLS0tLS0tLS0tLS0tKyAgICstLS0tLSsKPj4gICAgICAgICAgICAgICBWCj4+ICAgICAg ICAgKy0tLS0tLS0tLS0rCj4+ICAgICAgICAgfCBDaHVuayAjMyB8LS0tKwo+PiAgICAgICAgIHwg IENCID0gMCAgfCAgIHwgICArLS0tLS0tLS0tLS0tKyAgICstLS0tLSsgICArLS0tLS0tLS0tLS0t KyAgICstLS0tLSsKPj4gICAgICAgICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjMTI2IHwt LT58IC4uLiB8LS0+fCBCdXJzdCAjMTI5IHwtLT58IGxscCB8Cj4+ICAgICAgICAgICAgICAgICAg ICAgICAgICAgICstLS0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLS0rICAgKy0t LS0tKwo+IAo+IFRoaXMgaXMgZ3JlYXQgYW5kIHJlcXVpcmVkIHRvIHVuZGVyc3RhbmQgdGhlIGRy aXZlci4KPiAKPiBIb3cgZG9lcyBjb250cm9sbGVyIG1vdmUgZnJvbSBCdXJuc3QgIzQxIG9mIENo dW5rIDAgdG8gQ2h1bmsgMSA/CgpJIGZvcmdvdCB0byBleHBsYWluIHRoYXQuLi4KCk9uIGV2ZXJ5 IGxhc3QgQnVyc3Qgb2YgdGhlIENodW5rIChCdXJzdCAjNDEsIEJ1cnN0ICM4MywgQnVyc3QgIzEy NSBvciBldmVuIEJ1cnN0CiMxMjkpIGlzIHNldCBzb21lIGZsYWdzIG9uIHRoZWlyIGNvbnRyb2wg dmFyaWFibGUgKFJJRSBhbmQgTElFIGJpdHMpIHRoYXQgd2lsbAp0cmlnZ2VyIHRoZSBzZW5kIG9m ICJkb25lIiBpbnRlcnJ1cHRpb24uCgpPbiB0aGUgaW50ZXJydXB0aW9ucyBjYWxsYmFjaywgaXMg ZGVjaWRlZCB3aGV0aGVyIHRvIHJlY3ljbGUgdGhlIGxpbmtlZCBsaXN0Cm1lbW9yeSBzcGFjZSBi eSB3cml0aW5nIGEgbmV3IHNldCBvZiBCdXJzdHMgZWxlbWVudHMgKGlmIHN0aWxsIGV4aXN0cyBD aHVua3MgdG8KdHJhbnNmZXIpIG9yIGlzIGNvbnNpZGVyZWQgY29tcGxldGVkIChpZiB0aGVyZSBp cyBubyBDaHVua3MgYXZhaWxhYmxlIHRvIHRyYW5zZmVyKQoKPiBJcyBCdXJzdCAwIHRvIDEyOSBh IGxpbmsgbGlzdCB3aXRoIEJ1cnN0IDAsIDQyLCA4NCBhbmQgMTI2IGhhdmluZyBhCj4gY2FsbGJh Y2sgKGRvbmUgYml0IHNldCkuLgoKSSBkaWRuJ3QgcXVpdGUgdW5kZXJzdGFuZCBpdCB5b3VyIHF1 ZXN0aW9uLgoKSXQgY29tZXMgZnJvbSB0aGUgcHJlcF9zbGF2ZV9zZyBuIGVsZW1lbnRzICgxMzAg YXBwbHlpbmcgdGhlIGV4YW1wbGUpLCB3aGVyZQp3aWxsIGJlIGRpdmlkZSBpbiBzZXZlcmFsIENo dW5rcyAoIzAsICMxLCAjMiwgIzMgYW5kICM0IGFwcGx5aW5nIHRoZSBleGFtcGxlKSAoYQpsaW5r ZWQgbGlzdCB0aGF0IHdpbGwgY29udGFpbiBhbm90aGVyIGxpbmtlZCBsaXN0IGZvciB0aGUgQnVy c3RzLCBDQiwgQ2h1bmsKc2l6ZSkuIFRoZSBsaW5rZWQgbGlzdCBpbnNpZGUgb2YgZWFjaCBDaHVu ayB3aWxsIGNvbnRhaW4gYSBudW1iZXIgb2YgQnVyc3RzCihsaW1pdGVkIHRvIHRoZSBtZW1vcnkg c3BhY2Ugc2l6ZSksIGVhY2ggb25lIHdpbGwgcG9zc2VzcyBTb3VyY2UgQWRkcmVzcywKRGVzdGlu YXRpb24gQWRkcmVzcyBhbmQgc2l6ZSBvZiB0aGF0IHN1Yi10cmFuc2Zlci4KCj4gCj4gVGhpcyBz b3VuZCAqKnZlcnkqKiBzaW1pbGFyIHRvIGR3IGRtYSBjb25jZXB0cyEKCkkgYmVsaWV2ZSBzb21l IHBhcnRzIG9mIGR3IGRtYSBhbmQgZHcgZWRtYSBiZWhhdmlvciBhcmUgc2ltaWxhciBhbmQgdGhh dCBtYWtlcwpwZXJmZWN0bHkgc2Vuc2Ugc2luY2UgYm90aCBkbWEgYXJlIGRvbmUgYnkgU3lub3Bz eXMgYW5kIG1heSBiZSBleGlzdCBhIHNoYXJlZAprbm93bGVkZ2UsIGhvd2V2ZXIgdGhleSBhcmUg ZGlmZmVyZW50IElQcyBhcHBsaWVkIHRvIGRpZmZlcmVudCBwcm9kdWN0cy4KCj4gCj4+Cj4+IExl Z2VuZDoKPj4KPj4gKkxpbmtlZCBsaXN0KiwgYWxzbyBrbm93IGFzIENodW5rCj4+ICpMaW5rZWQg bGlzdCBlbGVtZW50KiwgYWxzbyBrbm93IGFzIEJ1cnN0Cj4+ICpDQiosIGFsc28ga25vdyBhcyBD aGFuZ2UgQml0LCBpdCdzIGEgY29udHJvbCBiaXQgKGFuZCB0eXBpY2FsbHkgaXMgdG9nZ2xlZCkK Pj4gdGhhdCBhbGxvd3MgdG8gZWFzaWx5IGlkZW50aWZ5IGFuZCBkaWZmZXJlbnRpYXRlIGJldHdl ZW4gdGhlIGN1cnJlbnQgbGlua2VkIGxpc3QKPj4gYW5kIHRoZSBwcmV2aW91cyBvciB0aGUgbmV4 dCBvbmUuCj4+ICpMTFAqLCBpcyBhIHNwZWNpYWwgZWxlbWVudCB0aGF0IGluZGljYXRlcyB0aGUg ZW5kIG9mIHRoZSBsaW5rZWQgbGlzdCBlbGVtZW50Cj4+IHN0cmVhbSBhbHNvIGluZm9ybXMgdGhh dCB0aGUgbmV4dCBDQiBzaG91bGQgYmUgdG9nZ2xlLgo+Pgo+PiBPbiBzY2F0dGVyLWdhdGhlciB0 cmFuc2ZlciBtb2RlLCB0aGUgY2xpZW50IHdpbGwgc3VibWl0IGEgc2NhdHRlci1nYXRoZXIgbGlz dCBvZgo+PiBuIChvbiB0aGlzIGNhc2UgMTMwKSBlbGVtZW50cywgdGhhdCB3aWxsIGJlIGRpdmlk ZSBpbiBtdWx0aXBsZSBDaHVua3MsIGVhY2gKPj4gQ2h1bmsgd2lsbCBoYXZlIChvbiB0aGlzIGNh c2UgNDIpIGEgbGltaXRlZCBudW1iZXIgb2YgQnVyc3RzIGFuZCBhZnRlcgo+PiB0cmFuc2ZlcnJp bmcgYWxsIEJ1cnN0cywgYW4gaW50ZXJydXB0IHdpbGwgYmUgdHJpZ2dlcmVkLCB3aGljaCB3aWxs IGFsbG93IHRvCj4+IHJlY3ljbGUgdGhlIGFsbCBsaW5rZWQgbGlzdCBkZWRpY2F0ZWQgbWVtb3J5 IGFnYWluIHdpdGggdGhlIG5ldyBpbmZvcm1hdGlvbgo+PiByZWxhdGl2ZSB0byB0aGUgbmV4dCBD aHVuayBhbmQgcmVzcGVjdGl2ZSBCdXJzdCBhc3NvY2lhdGVkIGFuZCByZXBlYXQgdGhlIHdob2xl Cj4+IGN5Y2xlIGFnYWluLgo+Pgo+PiBPbiBjeWNsaWMgdHJhbnNmZXIgbW9kZSwgdGhlIGNsaWVu dCB3aWxsIHN1Ym1pdCBhIGJ1ZmZlciBwb2ludGVyLCBsZW5ndGggb2YgaXQKPj4gYW5kIG51bWJl ciBvZiByZXBldGl0aW9ucywgaW4gdGhpcyBjYXNlIGVhY2ggYnVyc3Qgd2lsbCBjb3JyZXNwb25k IGRpcmVjdGx5IHRvCj4+IGVhY2ggcmVwZXRpdGlvbi4KPj4KPj4gRWFjaCBCdXJzdCBjYW4gZGVz Y3JpYmVzIGEgZGF0YSB0cmFuc2ZlciBmcm9tIHBvaW50IEEoc291cmNlKSB0byBwb2ludAo+PiBC KGRlc3RpbmF0aW9uKSB3aXRoIGEgbGVuZ3RoIHRoYXQgY2FuIGJlIGZyb20gMSBieXRlIHVwIHRv IDQgR0IuIFNpbmNlIGRlZGljYXRlZAo+PiB0aGUgbWVtb3J5IHNwYWNlIHdoZXJlIHRoZSBsaW5r ZWQgbGlzdCB3aWxsIHJlc2lkZSBpcyBsaW1pdGVkLCB0aGUgd2hvbGUgbiBidXJzdAo+PiBlbGVt ZW50cyB3aWxsIGJlIG9yZ2FuaXplZCBpbiBzZXZlcmFsIENodW5rcywgdGhhdCB3aWxsIGJlIHVz ZWQgbGF0ZXIgdG8gcmVjeWNsZQo+PiB0aGUgZGVkaWNhdGVkIG1lbW9yeSBzcGFjZSB0byBpbml0 aWF0ZSBhIG5ldyBzZXF1ZW5jZSBvZiBkYXRhIHRyYW5zZmVycy4KPj4KPj4gVGhlIHdob2xlIHRy YW5zZmVyIGlzIGNvbnNpZGVyZWQgaGFzIGNvbXBsZXRlZCB3aGVuIGl0IHdhcyB0cmFuc2ZlcnJl ZCBhbGwgYnVyc3RzLgo+Pgo+PiBDdXJyZW50bHkgdGhpcyBJUCBoYXMgYSBzZXQgd2VsbC1rbm93 biByZWdpc3RlciBtYXAsIHdoaWNoIGluY2x1ZGVzIHN1cHBvcnQgZm9yCj4+IGxlZ2FjeSBhbmQg dW5yb2xsIG1vZGVzLiBMZWdhY3kgbW9kZSBpcyB2ZXJzaW9uIG9mIHRoaXMgcmVnaXN0ZXIgbWFw IHRoYXQgaGFzCj4gCj4gd2hhdHMgIHVucm9sbC4uCj4gCj4+IG11bHRpcGxleGVyIHJlZ2lzdGVy IHRoYXQgYWxsb3dzIHRvIHN3aXRjaCByZWdpc3RlcnMgYmV0d2VlbiBhbGwgd3JpdGUgYW5kIHJl YWQKClRoZSB1bnJvbGwgaXMgZXhwbGFpbmVkIGhlcmUsIHNlZSBiZWxvdwoKPj4gY2hhbm5lbHMg YW5kIHRoZSB1bnJvbGwgbW9kZXMgcmVwZWF0cyBhbGwgd3JpdGUgYW5kIHJlYWQgY2hhbm5lbHMg cmVnaXN0ZXJzIHdpdGgKPj4gYW4gb2Zmc2V0IGJldHdlZW4gdGhlbS4gVGhpcyByZWdpc3RlciBt YXAgaXMgY2FsbGVkIHYwLgo+Pgo+PiBUaGUgSVAgdGVhbSBpcyBjcmVhdGluZyBhIG5ldyByZWdp c3RlciBtYXAgbW9yZSBzdWl0YWJsZSB0byB0aGUgbGF0ZXN0IFBDSWUKPj4gZmVhdHVyZXMsIHRo YXQgdmVyeSBsaWtlbHkgd2lsbCBjaGFuZ2UgdGhlIG1hcCByZWdpc3Rlciwgd2hpY2ggdGhpcyB2 ZXJzaW9uIHdpbGwKPj4gYmUgY2FsbGVkIHYxLiBBcyBzb29uIGFzIHRoaXMgbmV3IHZlcnNpb24g aXMgcmVsZWFzZWQgYnkgdGhlIElQIHRlYW0gdGhlIHN1cHBvcnQKPj4gZm9yIHRoaXMgdmVyc2lv biBpbiBiZSBpbmNsdWRlZCBvbiB0aGlzIGRyaXZlci4KPj4KPj4gV2hhdCBkbyB5b3UgdGhpbms/ IFRoZXJlIGlzIGFueSBncmF5IGFyZWEgdGhhdCBJIGNvdWxkIGNsYXJpZnk/Cj4gCj4gVGhpcyBz b3VuZHMgZ29vZC4gQnV0IHdlIGFyZSBhbHNvIGNhdGVyaW5nIHRvIGEgV0lQIElQIHdoaWNoIGNh biBjaGFuZ2UKPiByaWdodC4gRG9lc250IHNvdW5kIHZlcnkgZ29vZCBpZGVhIHRvIG1lIDopCgpU aGlzIElQIGV4aXN0cyBmb3Igc2V2ZXJhbCB5ZWFycyBsaWtlIHRoaXMgYW5kIGl0IHdvcmtzIHF1 aXRlIGZpbmUsIGhvd2V2ZXIKYmVjYXVzZSBvZiBuZXcgZmVhdHVyZXMgYW5kIHJlcXVlc3RzIChT Ui1JT1YsIG1vcmUgZG1hIGNoYW5uZWxzLCBmdW5jdGlvbgpzZWdyZWdhdGlvbiBhbmQgaXNvbGF0 aW9uLCBwZXJmb3JtYW5jZSBpbXByb3ZlbWVudCkgdGhhdCBhcmUgY29taW5nIGl0J3MgbmF0dXJh bAp0byBoYXZlIGV4aXN0IGltcHJvdmVtZW50cy4gVGhlIGRyaXZlcnMgc2hvdWxkIGZvbGxvdyB0 aGUgZXZvbHV0aW9uIGFuZCBiZQpzdWZmaWNpZW50IHJvYnVzdCBlbm91Z2ggdG8gYWRhcHQgdG8g dGhpcyBuZXcgY2lyY3Vtc3RhbmNlLgoKPiAKPj4+Pj4+ICsJZGV2X2RiZyhjaGFuMmRldihjaGFu KSwgImFkZHIocGh5c2ljYWwpIHNyYz0lcGEsIGRzdD0lcGFcbiIsCj4+Pj4+PiArCQkmY29uZmln LT5zcmNfYWRkciwgJmNvbmZpZy0+ZHN0X2FkZHIpOwo+Pj4+Pj4gKwo+Pj4+Pj4gKwljaGFuLT5z cmNfYWRkciA9IGNvbmZpZy0+c3JjX2FkZHI7Cj4+Pj4+PiArCWNoYW4tPmRzdF9hZGRyID0gY29u ZmlnLT5kc3RfYWRkcjsKPj4+Pj4+ICsKPj4+Pj4+ICsJZXJyID0gb3BzLT5kZXZpY2VfY29uZmln KGRjaGFuKTsKPj4+Pj4KPj4+Pj4gd2hhdCBkb2VzIHRoaXMgZG8/Cj4+Pj4KPj4+PiBUaGlzIGlz IGFuIGluaXRpYWxpemF0aW9uIHByb2NlZHVyZSB0byBzZXR1cCBpbnRlcnJ1cHRzIChkYXRhIGFu ZCBhZGRyZXNzZXMpIHRvCj4+Pj4gZWFjaCBjaGFubmVsIG9uIHRoZSBlRE1BIElQLCAgaW4gb3Jk ZXIgdG8gYmUgdHJpZ2dlcmVkIGFmdGVyIHRyYW5zZmVyIGJlaW5nCj4+Pj4gY29tcGxldGVkIG9y IGFib3J0ZWQuIER1ZSB0aGUgZmFjdCB0aGUgY29uZmlnKCkgY2FuIGJlIGNhbGxlZCBhdCBhbnl0 aW1lLAo+Pj4+IGRvZXNuJ3QgbWFrZSBzZW5zZSB0byBoYXZlIHRoaXMgcHJvY2VkdXJlIGhlcmUs IEknbGwgbW92ZWQgaXQgdG8gcHJvYmUoKS4KPj4+Cj4+PiBZZWFoIEkgYW0gbm90IHN0aWxsIGNv bnZpbmNlZCBhYm91dCBoYXZpbmcgYW5vdGhlciBsYXllciEgSGF2ZSB5b3UKPj4+IHRob3VnaCBh Ym91dCB1c2luZyBjb21tb24gbGliIGZvciBjb21tb24gcGFydHMgLi4/Cj4+Cj4+IE1heWJlIEkn bSBleHBsYWluaW5nIG15c2VsZiB3cm9uZ2x5LiBJIGRvbid0IGhhdmUgYW55IGNsdWUgYWJvdXQg dGhlIG5ldwo+PiByZWdpc3RlciBtYXAgZm9yIHRoZSBmdXR1cmUgdmVyc2lvbnMuIEkgaG9uZXN0 bHkgdHJpZWQgdG8gaW1wbGVtZW50IHRoZSBjb21tb24KPj4gbGliIGZvciB0aGUgd2hvbGUgcHJv Y2VzcyB0aGF0IGludGVyYWN0IHdpdGggZG1hIGVuZ2luZSBjb250cm9sbGVyIHRvIGVhc2UgaW4K Pj4gdGhlIGZ1dHVyZSBhbnkgbmV3IGFkZGl0aW9uIG9mIHJlZ2lzdGVyIG1hcHBpbmcsIGJ5IGhh dmluZyB0aGlzIGNvbW1vbiBjYWxsYmFja3MKPj4gdGhhdCB3aWxsIG9ubHkgYmUgcmVzcG9uc2li bGUgZm9yIGludGVyZmFjaW5nIHRoZSBIVyBhY2NvcmRpbmdseSB0byByZWdpc3RlciBtYXAKPj4g dmVyc2lvbi4gTWF5YmUgSSBjYW4gc2ltcGxpZnkgc29tZXRoaW5nIGluIHRoZSBmdXR1cmUsIGJ1 dCBJIG9ubHkgYmUgYWJsZSB0bwo+PiBjb25jbHVkZSB0aGF0IGFmdGVyIGhhdmluZyBzb21lIGlk ZWEgYWJvdXQgdGhlIG5ldyByZWdpc3RlciBtYXAuCj4+Cj4+IElNSE8gSSB0aGluayB0aGlzIGlz IHRoZSBlYXNpZXIgYW5kIGNsZWFuIHdheSB0byBkbyBpdCwgaW4gdGVybXMgb2YgY29kZQo+PiBt YWludGVuYW5jZSBhbmQgYXJjaGl0ZWN0dXJlLCBidXQgaWYgeW91IGhhdmUgYW5vdGhlciBpZGVh IHRoYXQgeW91IGNhbiBzaG93IG1lCj4+IG9yIHBvaW50aW5nIG91dCBmb3IgYSBkcml2ZXIgdGhh dCBpbXBsZW1lbnRzIHNvbWV0aGluZyBzaW1pbGFyLCBJJ20gbm8gcHJvYmxlbQo+PiB0byBjaGVj ayBpdCBvdXQuCj4gCj4gVGhhdCBpcyB3aGF0IG15IGZlYXIgd2FzIDopCj4gCj4gTGV0cyBzdGVw IGJhY2sgYW5kIHNvbHZlIG9uZSBwcm9ibGVtIGF0IGEgdGltZS4gUmlnaHQgbm93IHRoYXQgaXMg djAgb2YKPiBJUC4gUGxlYXNlIHdyaXRlIGEgc2ltcGxlIGRyaXZlciB3aGljaCBzb2x2ZSB2MCB3 aXRob3V0IGFueSBsYXllcnMKPiBpbnZvbHZlZC4KPiAKPiBPbmNlIHYxIGlzIGluIGdvb2Qgc2hh cGUsIHlvdSB3b3VsZCBrbm93IHdoYXQgaXQgcmVxdWlyZWQgYW5kIHRoZW4gd2UKPiBjYW4gc3Bs aXQgdjAgZHJpdmVyIGludG8gY29tbW9uIGxpYiBhbmQgdjAgZHJpdmVyIGFuZCB0aGVuIGFkZCB2 MQo+IGRyaXZlci4KCkNhbiBJIGtlZXAgdGhlIGNvZGUgc2VncmVnYXRpb24gYXMgaXQgaXMgbm93 PyBXaXRoIHRoZSBkdy1lZG1hLXYwLWNvcmUuYy9oLApkdy1lZG1hLXYwLWRlYnVnZnMuYy9oIGFu ZCBkdy1lZG1hLXYwLXJlZ3MuaAoKVGhhdCB3YXkgSSB3b3VsZCBvbmx5IHJlcGxhY2UgdGhlIGNh bGxiYWNrcyBjYWxscyB0byBkaXJlY3QgZnVuY3Rpb24gY2FsbHMgYW5kCnJlbW92ZSB0aGUgc3dp dGNoIGNhc2UgY2FsbGJhY2sgc2VsZWN0aW9uIGJhc2Ugb24gdGhlIHZlcnNpb24uCgo+IAo+IAo+ Pj4+PiB3aGF0IGlzIHRoZSBzZWNvbmQgcGFydCBvZiB0aGUgY2hlY2ssIGNhbiB5b3UgZXhwbGFp biB0aGF0LCB3aG8gc2V0cwo+Pj4+PiBjaGFuLT5kaXI/Cj4+Pj4KPj4+PiBUaGUgY2hhbi0+ZGly IGlzIHNldCBvbiBwcm9iZSgpIGR1cmluZyB0aGUgcHJvY2VzcyBvZiBjb25maWd1cmluZyBlYWNo IGNoYW5uZWwuCj4+Pgo+Pj4gU28geW91IGhhdmUgY2hhbm5lbHMgdGhhdCBhcmUgdW5pZGlyZWN0 aW9uYWw/Cj4+Cj4+IFllcy4gVGhhdCdzIG9uZSBhbm90aGVyIHJlYXNvbiBJTUhPIHRvIGtlZXAg dGhlIGR3LWVkbWEtdGVzdCBzZXBhcmF0ZSBmcm9tCj4+IGRtYS10ZXN0LCBzaW5jZSB0aGlzIElQ IGlzIG1vcmUgcGlja3kgYW5kIGhhdmUgdGhpcyBwYXJ0aWN1bGFyaXRpZXMuCj4gCj4gVGhhdCBp cyBva2F5LCB0aGF0IHNob3VsZCBiZSBoYW5kbGVkIGJ5IHByZXAgY2FsbHMsIGlmIHlvdSBnZXQg YSBwcmVwCj4gY2FsbCBmb3IgZGlyZWN0aW9uIHlvdSBkb250IHN1cHBvcnQgcmV0dXJuIGVycm9y IGFuZCBtb3ZlIHRvIG5leHQKPiBhdmFpbGFibGUgb25lLgo+IAo+IFRoYXQgY2FuIGJlIGRvbmUg Z2VuZXJpY2FsbHkgaW4gZG1hdGVzdCBkcml2ZXIgYW5kIHRvIGFuc3dlciB5b3VyCj4gcXVlc3Rp b24sIHllcyBJIHdvdWxkIHRlc3QgdGhhdCA6KQoKTGlrZSB5b3Ugc2FpZCwgbGV0IGRvIHRoaXMg aW4gc21hbGwgc3RlcHMuIEZvciBub3cgSSB3b3VsZCBsaWtlIHRvIHN1Z2dlc3QgdG8KbGVhdmUg b3V0IHRoZSBkdy1kbWEtdGVzdCBkcml2ZXIgYW5kIGp1c3QgZm9jdXMgb24gdGhlIGN1cnJlbnQg ZHJpdmVyLCBpZiB5b3UKZG9uJ3QgbWluZC4gSSBuZXZlciB0aG91Z2h0IHRoYXQgaGlzIHRlc3Qg ZHJpdmVyIHdvdWxkIHJhaXNlIHRoaXMga2luZCBvZiBkaXNjdXNzLgoKPiAKPj4+Pj4+ICtpbnQg ZHdfZWRtYV9wcm9iZShzdHJ1Y3QgZHdfZWRtYV9jaGlwICpjaGlwKQo+Pj4+Pj4gK3sKPj4+Pj4+ ICsJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hpcC0+ZHc7Cj4+Pj4+PiArCXN0cnVjdCBkZXZpY2Ug KmRldiA9IGNoaXAtPmRldjsKPj4+Pj4+ICsJY29uc3Qgc3RydWN0IGR3X2VkbWFfY29yZV9vcHMg Km9wczsKPj4+Pj4+ICsJc2l6ZV90IGxsX2NodW5rID0gZHctPmxsX3JlZ2lvbi5zejsKPj4+Pj4+ ICsJc2l6ZV90IGR0X2NodW5rID0gZHctPmR0X3JlZ2lvbi5zejsKPj4+Pj4+ICsJdTMyIGNoX3Rv dDsKPj4+Pj4+ICsJaW50IGksIGosIGVycjsKPj4+Pj4+ICsKPj4+Pj4+ICsJcmF3X3NwaW5fbG9j a19pbml0KCZkdy0+bG9jayk7Cj4+Pj4+PiArCj4+Pj4+PiArCS8qIENhbGxiYWNrIG9wZXJhdGlv biBzZWxlY3Rpb24gYWNjb3JkaW5nbHkgdG8gZURNQSB2ZXJzaW9uICovCj4+Pj4+PiArCXN3aXRj aCAoZHctPnZlcnNpb24pIHsKPj4+Pj4+ICsJZGVmYXVsdDoKPj4+Pj4+ICsJCWRldl9lcnIoZGV2 LCAidW5zdXBwb3J0ZWQgdmVyc2lvblxuIik7Cj4+Pj4+PiArCQlyZXR1cm4gLUVQRVJNOwo+Pj4+ Pj4gKwl9Cj4+Pj4+Cj4+Pj4+IFNvIHdlIGhhdmUgb25seSBvbmUgY2FzZSB3aGljaCByZXR1cm5z IGVycm9yLCB3YXMgdGhpcyBjb2RlIHRlc3RlZD8KPj4+Pgo+Pj4+IFllcyBpdCB3YXMsIGJ1dCBJ IHVuZGVyc3RhbmQgd2hhdCB5b3VyIHBvaW50IG9mIHZpZXcuCj4+Pj4gVGhpcyB3YXMgZG9uZSBs aWtlIHRoaXMsIGJlY2F1c2UgSSB3YW5uYSB0byBzZWdtZW50IHRoZSBwYXRjaCBzZXJpZXMgbGlr ZSB0aGlzOgo+Pj4+ICAxKSBBZGRpbmcgZURNQSBkcml2ZXIgY29yZSwgd2hpY2ggY29udGFpbnMg dGhlIGRyaXZlciBza2VsZXRvbiBhbmQgdGhlIHdob2xlCj4+Pj4gbG9naWMgYXNzb2NpYXRlZC4K Pj4+PiAgMikgYW5kIDMpIEFkZGluZyB0aGUgY2FsbGJhY2tzIGZvciB0aGUgZURNQSByZWdpc3Rl ciBtYXBwaW5nIHZlcnNpb24gMCAoaXQgd2lsbAo+Pj4+IGFwcGVhciBpbiB0aGUgZnV0dXJlIGEg bmV3IHZlcnNpb24sIEkgdGhvdWdodCB0aGF0IHRoaXMgbmV3IHZlcnNpb24gd291bGQgY2FtZQo+ Pj4+IHdoaWxlIEkgd2FzIHRyeWluZyB0byBnZXQgdGhlIGZlZWRiYWNrIGFib3V0IHRoaXMgcGF0 Y2ggc2VyaWVzLCB0aGVyZWZvcmUgd291bGQKPj4+PiBoYXZlIGFub3RoZXIgMiBwYXRjaGVzIGZv ciB0aGUgdmVyc2lvbiAxIGlzb2xhdGVkIGFuZCBpbmRlcGVuZGVudCBmcm9tIHRoZQo+Pj4+IHZl cnNpb24gMCkuCj4+Pj4gIDQpIGFuZCA1KSBBZGRpbmcgdGhlIFBDSWUgZ2x1ZS1sb2dpYyBhbmQg ZGV2aWNlIElEIGFzc29jaWF0ZWQuCj4+Pj4gIDYpIEFkZGluZyBtYWludGFpbmVyIGZvciB0aGlz IGRyaXZlci4KPj4+PiAgNykgQWRkaW5nIGEgdGVzdCBkcml2ZXIuCj4+Pj4KPj4+PiBTaW5jZSB0 aGlzIHN3aXRjaCB3aWxsIG9ubHkgaGF2ZSB0aGUgYXNzb2NpYXRlZCBjYXNlIG9uIHBhdGNoIDIs IHRoYXQgd2h5IG9uCj4+Pj4gcGF0Y2ggMSBkb2Vzbid0IGFwcGVhciBhbnkgcG9zc2liaWxpdHku Cj4+Pj4KPj4+PiBJZiB5b3UgZmVlbCBsb2dpYyB0byBzcXVhc2ggcGF0Y2ggMiB3aXRoIHBhdGNo IDEsIGp1c3Qgc2F5IHNvbWV0aGluZyBhbmQgSSdsbCBkbwo+Pj4+IGl0IGZvciB5b3UgOikKPj4+ Cj4+PiB3ZWxsIGVhY2ggcGF0Y2ggc2hvdWxkIGJ1aWxkIGFuZCB3b3JrIG9uIGl0cyBvd24sIG90 aGVyd2lzZSB3ZSBnZXQKPj4+IHByb2JsZW1zIDopIEJ1dCBzaW5jZSB0aGlzIGlzIGEgbmV3IGRy aXZlciBpdCBpcyBva2F5LiBBbnl3YXkgdGhpcyBwYXRjaAo+Pj4gaXMgcXVpdGUgX2h1Z2VfIHNv IGxldHMgbm90IGFkZCBtb3JlIHRvIGl0Li4KPj4+Cj4+PiBJIHdvdWxkIGhhdmUgbW92ZWQgdGhl IGNhbGxiYWNrIGNoZWNrIHRvIHN1YnNlcXVlbnQgb25lLi4KPj4KPj4gU29ycnkuIEkgZGlkbid0 IGNhdGNoIHRoaXMuIENhbiB5b3UgZXhwbGFpbiBpdD8KPiAKPiBJIHdvdWxkIGhhdmUgbW92ZWQg dGhlc2UgbGluZXMgdG8gbmV4dCBwYXRjaCB0byBnaXZlIHRoZW0gcmlnaHQgbWVhbmluZywKPiBo ZXJlIGl0IGZlZWxzIHdyb25nOgo+IAo+ICAgICAgICAgc3dpdGNoIChkdy0+dmVyc2lvbikgewo+ ICAgICAgICAgY2FzZSBmb286Cj4gICAgICAgICAgICAgICAgIC4uLgo+ICAgICAgICAgZGVmYXVs dDoKPiAgICAgICAgICAgICAgICAgLi4uCj4gICAgICAgICB9Cj4K 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=-1.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_PASS 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 BB511C282D8 for ; Fri, 1 Feb 2019 11:28:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7428E20844 for ; Fri, 1 Feb 2019 11:28:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=synopsys.com header.i=@synopsys.com header.b="fLQfYbqs" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729613AbfBAL2f (ORCPT ); Fri, 1 Feb 2019 06:28:35 -0500 Received: from smtprelay4.synopsys.com ([198.182.47.9]:34164 "EHLO smtprelay.synopsys.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729555AbfBAL2f (ORCPT ); Fri, 1 Feb 2019 06:28:35 -0500 Received: from mailhost.synopsys.com (badc-mailhost1.synopsys.com [10.192.0.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtprelay.synopsys.com (Postfix) with ESMTPS id 998C924E0999; Fri, 1 Feb 2019 03:28:34 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=synopsys.com; s=mail; t=1549020514; bh=KRwcWvEKgIqT9CdoiwaiIEfR10C3TR3gHfR5cJL3yTE=; h=Subject:To:CC:References:From:Date:In-Reply-To:From; b=fLQfYbqsql/+tca3It+cMnYPxmfRS+5kfSeC24EogajMZtWotFxlaiVjEN2FobIdX 8anBfAQsgoRSKHHEbBrCzllbNyNyZ+d0SvgwDnA5UCsNuRRvJF6T5GJ7JJFDKiXGtl vi8SgKZGZpMUjBrxTXM+BhyT6PGa5YN9UJJTzoS+8wWn/WXZHzYTTaXhN67DGjP2L6 lPZRNZYY2itYTH8WJMWP6aTejEClJL1GPa+ZOwIMXhb8JlGVIknR6eGXKCj7LDONHB Du+HV2ktiK/lzkHSzP2PjlpTxan+vXH1JfdzULuNWbQFjJVDU1TUY1D0JuP7eElf5z A1jh5Ymbwx+Ig== Received: from US01WEHTC3.internal.synopsys.com (us01wehtc3.internal.synopsys.com [10.15.84.232]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mailhost.synopsys.com (Postfix) with ESMTPS id 6DE53A0071; Fri, 1 Feb 2019 11:28:33 +0000 (UTC) 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; Fri, 1 Feb 2019 03:28:33 -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; Fri, 1 Feb 2019 12:28:30 +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; Fri, 1 Feb 2019 12:28:30 +0100 Subject: Re: [RFC v3 1/7] dmaengine: Add Synopsys eDMA IP core driver To: Vinod Koul , 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 References: <20190120114425.GV4635@vkoul-mobl> <14acfcee-b367-be9c-714b-de0508ff1a7d@synopsys.com> <20190123130829.GQ4635@vkoul-mobl> <20190201041400.GL4635@vkoul-mobl> From: Gustavo Pimentel Message-ID: Date: Fri, 1 Feb 2019 11:23:33 +0000 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:60.0) Gecko/20100101 Thunderbird/60.5.0 MIME-Version: 1.0 In-Reply-To: <20190201041400.GL4635@vkoul-mobl> 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 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. > > 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. > >>>>>> + 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. > > >>>>> 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. > >>>>>> +int dw_edma_probe(struct dw_edma_chip *chip) >>>>>> +{ >>>>>> + struct dw_edma *dw = chip->dw; >>>>>> + struct device *dev = chip->dev; >>>>>> + const struct dw_edma_core_ops *ops; >>>>>> + size_t ll_chunk = dw->ll_region.sz; >>>>>> + size_t dt_chunk = dw->dt_region.sz; >>>>>> + u32 ch_tot; >>>>>> + int i, j, err; >>>>>> + >>>>>> + raw_spin_lock_init(&dw->lock); >>>>>> + >>>>>> + /* Callback operation selection accordingly to eDMA version */ >>>>>> + switch (dw->version) { >>>>>> + default: >>>>>> + dev_err(dev, "unsupported version\n"); >>>>>> + return -EPERM; >>>>>> + } >>>>> >>>>> So we have only one case which returns error, was this code tested? >>>> >>>> Yes it was, but I understand what your point of view. >>>> This was done like this, because I wanna to segment the patch series like this: >>>> 1) Adding eDMA driver core, which contains the driver skeleton and the whole >>>> logic associated. >>>> 2) and 3) Adding the callbacks for the eDMA register mapping version 0 (it will >>>> appear in the future a new version, I thought that this new version would came >>>> while I was trying to get the feedback about this patch series, therefore would >>>> have another 2 patches for the version 1 isolated and independent from the >>>> version 0). >>>> 4) and 5) Adding the PCIe glue-logic and device ID associated. >>>> 6) Adding maintainer for this driver. >>>> 7) Adding a test driver. >>>> >>>> Since this switch will only have the associated case on patch 2, that why on >>>> patch 1 doesn't appear any possibility. >>>> >>>> If you feel logic to squash patch 2 with patch 1, just say something and I'll do >>>> it for you :) >>> >>> well each patch should build and work on its own, otherwise we get >>> problems :) But since this is a new driver it is okay. Anyway this patch >>> is quite _huge_ so lets not add more to it.. >>> >>> I would have moved the callback check to subsequent one.. >> >> Sorry. I didn't catch this. Can you explain it? > > I would have moved these lines to next patch to give them right meaning, > here it feels wrong: > > switch (dw->version) { > case foo: > ... > default: > ... > } >