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: <20190201041400.GL4635@vkoul-mobl> Date: Fri, 1 Feb 2019 09:44:00 +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: T24gMzEtMDEtMTksIDExOjMzLCBHdXN0YXZvIFBpbWVudGVsIHdyb3RlOgo+IE9uIDIzLzAxLzIw MTkgMTM6MDgsIFZpbm9kIEtvdWwgd3JvdGU6Cj4gPiBPbiAyMS0wMS0xOSwgMTU6NDgsIEd1c3Rh dm8gUGltZW50ZWwgd3JvdGU6Cj4gPj4gT24gMjAvMDEvMjAxOSAxMTo0NCwgVmlub2QgS291bCB3 cm90ZToKPiA+Pj4gT24gMTEtMDEtMTksIDE5OjMzLCBHdXN0YXZvIFBpbWVudGVsIHdyb3RlOgoK PiA+Pj4+IEBAIC0wLDAgKzEsMTA1OSBAQAo+ID4+Pj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wCj4gPj4+PiArLyoKPiA+Pj4+ICsgKiBDb3B5cmlnaHQgKGMpIDIwMTggU3lu b3BzeXMsIEluYy4gYW5kL29yIGl0cyBhZmZpbGlhdGVzLgo+ID4+Pgo+ID4+PiAyMDE5IG5vdwo+ ID4+Cj4gPj4gSSd2ZSBjaGFuZ2VkIHRvICJDb3B5cmlnaHQgKGMpIDIwMTgtcHJlc2VudCBTeW5v cHN5cywgSW5jLiBhbmQvb3IgaXRzCj4gPj4gYWZmaWxpYXRlcy4iIHRoaXMgd2F5IGl0J3MgYWx3 YXlzIHVwIHRvIGRhdGUgYW5kIEkgYWxzbyBrZXB0IDIwMTgsIGJlY2F1c2UgaXQKPiA+PiB3YXMg dGhlIGRhdGUgdGhhdCBJIHN0YXJ0ZWQgdG8gZGV2ZWxvcCB0aGlzIGRyaXZlciwgaWYgeW91IGRv bid0IG1pbmQuCj4gPiAKPiA+IHllYWggMTggaXMgZmluZSA6KSBpdCBuZWVkIHRvIGVuZCB3aXRo IGN1cnJlbnQgeWVhciBhbHdheXMKPiAKPiBKdXN0IHRvIGJlIHN1cmUsIGFyZSB5b3Ugc2F5aW5n IHRoYXQgbXVzdCBiZTogIkNvcHlyaWdodCAoYykgMjAxOC0yMDE5IFN5bm9wc3lzLAo+IEluYy4g YW5kL29yIGl0cyBhZmZpbGlhdGVzLiI/CgpZdXAgOikKCj4gPj4+PiArc3RhdGljIHN0cnVjdCBk d19lZG1hX2NodW5rICpkd19lZG1hX2FsbG9jX2NodW5rKHN0cnVjdCBkd19lZG1hX2Rlc2MgKmRl c2MpCj4gPj4+PiArewo+ID4+Pj4gKwlzdHJ1Y3QgZHdfZWRtYV9jaGFuICpjaGFuID0gZGVzYy0+ Y2hhbjsKPiA+Pj4+ICsJc3RydWN0IGR3X2VkbWEgKmR3ID0gY2hhbi0+Y2hpcC0+ZHc7Cj4gPj4+ PiArCXN0cnVjdCBkd19lZG1hX2NodW5rICpjaHVuazsKPiA+Pj4+ICsKPiA+Pj4+ICsJY2h1bmsg PSBrdnphbGxvYyhzaXplb2YoKmNodW5rKSwgR0ZQX05PV0FJVCk7Cj4gPj4+PiArCWlmICh1bmxp a2VseSghY2h1bmspKQo+ID4+Pj4gKwkJcmV0dXJuIE5VTEw7Cj4gPj4+PiArCj4gPj4+PiArCUlO SVRfTElTVF9IRUFEKCZjaHVuay0+bGlzdCk7Cj4gPj4+PiArCWNodW5rLT5jaGFuID0gY2hhbjsK PiA+Pj4+ICsJY2h1bmstPmNiID0gIShkZXNjLT5jaHVua3NfYWxsb2MgJSAyKTsKPiA+Pj4KPiA+ Pj4gY2IgLi4/Cj4gPj4KPiA+PiBDQiA9IGNoYW5nZSBiaXQsIGlzIGEgcHJvcGVydHkgb2YgdGhp cyBlRE1BIElQLiBCYXNpY2FsbHkgaXQgaXMgYSBraW5kIG9mCj4gPj4gaGFuZHNoYWtlIHdoaWNo IHNlcnZlcyB0byB2YWxpZGF0ZSB3aGV0aGVyIHRoZSBsaW5rZWQgbGlzdCBoYXMgYmVlbiB1cGRh dGVkIG9yCj4gPj4gbm90LCBlc3BlY2lhbGx5IHVzZWZ1bCBpbiBjYXNlcyBvZiByZWN5Y2xlZCBs aW5rZWQgbGlzdCBlbGVtZW50cyAoZXZlcnkgbGlua2VkCj4gPj4gbGlzdCByZWN5Y2xlIGlzIGEg bmV3IGNodW5rLCB0aGlzIHdpbGwgYWxsb3cgdG8gZGlmZmVyZW50aWF0ZSBlYWNoIGNodW5rKS4K PiA+IAo+ID4gb2theSBwbGVhc2UgYWRkIHRoYXQgc29tZXdoZXJlLiBBbHNvIGl0IHdvdWxkIGhl bHAgbWUgaWYgeW91IGV4cGxhaW4KPiA+IHdoYXQgaXMgY2h1bmsgYW5kIG90aGVyIHRlcm1pbm9s b2dpZXMgdXNlZCBpbiB0aGlzIGRyaXZlcgo+IAo+IEknbSB0aGlua2luZyB0byBwdXQgdGhlIGJl bG93IGRlc2NyaXB0aW9uIG9uIHRoZSBwYXRjaCwgcGxlYXNlIGNoZWNrIGlmIHRoaXMgaXMKPiBz dWZmaWNpZW50IGV4cGxpY2l0IGFuZCBjbGVhciB0byB1bmRlcnN0YW5kIHdoYXQgdGhpcyBJUCBu ZWVkcyBhbmQgZG9lcy4KPiAKPiBJbiBvcmRlciB0byB0cmFuc2ZlciBkYXRhIGZyb20gcG9pbnQg QSB0byBCIGFzIGZhc3QgYXMgcG9zc2libGUgdGhpcyBJUCByZXF1aXJlcwo+IGEgZGVkaWNhdGVk IG1lbW9yeSBzcGFjZSB3aGVyZSB3aWxsIHJlc2lkZSBhIGxpbmtlZCBsaXN0IG9mIGVsZW1lbnRz LgoKcmVwaHJhc2luZzogYSBkZWRpY2F0ZWQgbWVtb3J5IHNwYWNlIGNvbnRhaW5pbmcgbGlua2Vk IGxpc3Qgb2YgZWxlbWVudHMKCj4gQWxsIGVsZW1lbnRzIG9mIHRoaXMgbGlua2VkIGxpc3QgYXJl IGNvbnRpbnVvdXMgYW5kIGVhY2ggb25lIGRlc2NyaWJlcyBhIGRhdGEKPiB0cmFuc2ZlciAoc291 cmNlIGFuZCBkZXN0aW5hdGlvbiBhZGRyZXNzZXMsIGxlbmd0aCBhbmQgYSBjb250cm9sIHZhcmlh YmxlKS4KPiAKPiBGb3IgdGhlIHNha2Ugb2Ygc2ltcGxpY2l0eSwgbGV0cyBhc3N1bWUgYSBtZW1v cnkgc3BhY2UgZm9yIGNoYW5uZWwgd3JpdGUgMCB3aGljaAo+IGFsbG93cyBhYm91dCA0MiBlbGVt ZW50cy4KPiAKPiArLS0tLS0tLS0tKwo+IHwgRGVzYyAjMCB8LS0rCj4gKy0tLS0tLS0tLSsgIHwK PiAgICAgICAgICAgICAgVgo+ICAgICAgICAgKy0tLS0tLS0tLS0rCj4gICAgICAgICB8IENodW5r ICMwIHwtLS0rCj4gICAgICAgICB8ICBDQiA9IDEgIHwgICB8ICAgKy0tLS0tLS0tLS0rICAgKy0t LS0tKyAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rCj4gICAgICAgICArLS0tLS0tLS0tLSsgICAr LS0+fCBCdXJzdCAjMCB8LS0+fCAuLi4gfC0tPnwgQnVyc3QgIzQxIHwtLT58IGxscCB8Cj4gICAg ICAgICAgICAgICB8ICAgICAgICAgICAgKy0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0t LS0tLSsgICArLS0tLS0rCj4gICAgICAgICAgICAgICBWCj4gICAgICAgICArLS0tLS0tLS0tLSsK PiAgICAgICAgIHwgQ2h1bmsgIzEgfC0tLSsKPiAgICAgICAgIHwgIENCID0gMCAgfCAgIHwgICAr LS0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rCj4gICAgICAg ICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjNDIgfC0tPnwgLi4uIHwtLT58IEJ1cnN0ICM4 MyB8LS0+fCBsbHAgfAo+ICAgICAgICAgICAgICAgfCAgICAgICAgICAgICstLS0tLS0tLS0tLSsg ICArLS0tLS0rICAgKy0tLS0tLS0tLS0tKyAgICstLS0tLSsKPiAgICAgICAgICAgICAgIFYKPiAg ICAgICAgICstLS0tLS0tLS0tKwo+ICAgICAgICAgfCBDaHVuayAjMiB8LS0tKwo+ICAgICAgICAg fCAgQ0IgPSAxICB8ICAgfCAgICstLS0tLS0tLS0tLSsgICArLS0tLS0rICAgKy0tLS0tLS0tLS0t LSsgICArLS0tLS0rCj4gICAgICAgICArLS0tLS0tLS0tLSsgICArLS0+fCBCdXJzdCAjODQgfC0t PnwgLi4uIHwtLT58IEJ1cnN0ICMxMjUgfC0tPnwgbGxwIHwKPiAgICAgICAgICAgICAgIHwgICAg ICAgICAgICArLS0tLS0tLS0tLS0rICAgKy0tLS0tKyAgICstLS0tLS0tLS0tLS0rICAgKy0tLS0t Kwo+ICAgICAgICAgICAgICAgVgo+ICAgICAgICAgKy0tLS0tLS0tLS0rCj4gICAgICAgICB8IENo dW5rICMzIHwtLS0rCj4gICAgICAgICB8ICBDQiA9IDAgIHwgICB8ICAgKy0tLS0tLS0tLS0tLSsg ICArLS0tLS0rICAgKy0tLS0tLS0tLS0tLSsgICArLS0tLS0rCj4gICAgICAgICArLS0tLS0tLS0t LSsgICArLS0+fCBCdXJzdCAjMTI2IHwtLT58IC4uLiB8LS0+fCBCdXJzdCAjMTI5IHwtLT58IGxs cCB8Cj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgKy0tLS0tLS0tLS0tLSsgICArLS0tLS0r ICAgKy0tLS0tLS0tLS0tLSsgICArLS0tLS0rCgpUaGlzIGlzIGdyZWF0IGFuZCByZXF1aXJlZCB0 byB1bmRlcnN0YW5kIHRoZSBkcml2ZXIuCgpIb3cgZG9lcyBjb250cm9sbGVyIG1vdmUgZnJvbSBC dXJuc3QgIzQxIG9mIENodW5rIDAgdG8gQ2h1bmsgMSA/CklzIEJ1cnN0IDAgdG8gMTI5IGEgbGlu ayBsaXN0IHdpdGggQnVyc3QgMCwgNDIsIDg0IGFuZCAxMjYgaGF2aW5nIGEKY2FsbGJhY2sgKGRv bmUgYml0IHNldCkuLgoKVGhpcyBzb3VuZCAqKnZlcnkqKiBzaW1pbGFyIHRvIGR3IGRtYSBjb25j ZXB0cyEKCj4gCj4gTGVnZW5kOgo+IAo+ICpMaW5rZWQgbGlzdCosIGFsc28ga25vdyBhcyBDaHVu awo+ICpMaW5rZWQgbGlzdCBlbGVtZW50KiwgYWxzbyBrbm93IGFzIEJ1cnN0Cj4gKkNCKiwgYWxz byBrbm93IGFzIENoYW5nZSBCaXQsIGl0J3MgYSBjb250cm9sIGJpdCAoYW5kIHR5cGljYWxseSBp cyB0b2dnbGVkKQo+IHRoYXQgYWxsb3dzIHRvIGVhc2lseSBpZGVudGlmeSBhbmQgZGlmZmVyZW50 aWF0ZSBiZXR3ZWVuIHRoZSBjdXJyZW50IGxpbmtlZCBsaXN0Cj4gYW5kIHRoZSBwcmV2aW91cyBv ciB0aGUgbmV4dCBvbmUuCj4gKkxMUCosIGlzIGEgc3BlY2lhbCBlbGVtZW50IHRoYXQgaW5kaWNh dGVzIHRoZSBlbmQgb2YgdGhlIGxpbmtlZCBsaXN0IGVsZW1lbnQKPiBzdHJlYW0gYWxzbyBpbmZv cm1zIHRoYXQgdGhlIG5leHQgQ0Igc2hvdWxkIGJlIHRvZ2dsZS4KPiAKPiBPbiBzY2F0dGVyLWdh dGhlciB0cmFuc2ZlciBtb2RlLCB0aGUgY2xpZW50IHdpbGwgc3VibWl0IGEgc2NhdHRlci1nYXRo ZXIgbGlzdCBvZgo+IG4gKG9uIHRoaXMgY2FzZSAxMzApIGVsZW1lbnRzLCB0aGF0IHdpbGwgYmUg ZGl2aWRlIGluIG11bHRpcGxlIENodW5rcywgZWFjaAo+IENodW5rIHdpbGwgaGF2ZSAob24gdGhp cyBjYXNlIDQyKSBhIGxpbWl0ZWQgbnVtYmVyIG9mIEJ1cnN0cyBhbmQgYWZ0ZXIKPiB0cmFuc2Zl cnJpbmcgYWxsIEJ1cnN0cywgYW4gaW50ZXJydXB0IHdpbGwgYmUgdHJpZ2dlcmVkLCB3aGljaCB3 aWxsIGFsbG93IHRvCj4gcmVjeWNsZSB0aGUgYWxsIGxpbmtlZCBsaXN0IGRlZGljYXRlZCBtZW1v cnkgYWdhaW4gd2l0aCB0aGUgbmV3IGluZm9ybWF0aW9uCj4gcmVsYXRpdmUgdG8gdGhlIG5leHQg Q2h1bmsgYW5kIHJlc3BlY3RpdmUgQnVyc3QgYXNzb2NpYXRlZCBhbmQgcmVwZWF0IHRoZSB3aG9s ZQo+IGN5Y2xlIGFnYWluLgo+IAo+IE9uIGN5Y2xpYyB0cmFuc2ZlciBtb2RlLCB0aGUgY2xpZW50 IHdpbGwgc3VibWl0IGEgYnVmZmVyIHBvaW50ZXIsIGxlbmd0aCBvZiBpdAo+IGFuZCBudW1iZXIg b2YgcmVwZXRpdGlvbnMsIGluIHRoaXMgY2FzZSBlYWNoIGJ1cnN0IHdpbGwgY29ycmVzcG9uZCBk aXJlY3RseSB0bwo+IGVhY2ggcmVwZXRpdGlvbi4KPiAKPiBFYWNoIEJ1cnN0IGNhbiBkZXNjcmli ZXMgYSBkYXRhIHRyYW5zZmVyIGZyb20gcG9pbnQgQShzb3VyY2UpIHRvIHBvaW50Cj4gQihkZXN0 aW5hdGlvbikgd2l0aCBhIGxlbmd0aCB0aGF0IGNhbiBiZSBmcm9tIDEgYnl0ZSB1cCB0byA0IEdC LiBTaW5jZSBkZWRpY2F0ZWQKPiB0aGUgbWVtb3J5IHNwYWNlIHdoZXJlIHRoZSBsaW5rZWQgbGlz dCB3aWxsIHJlc2lkZSBpcyBsaW1pdGVkLCB0aGUgd2hvbGUgbiBidXJzdAo+IGVsZW1lbnRzIHdp bGwgYmUgb3JnYW5pemVkIGluIHNldmVyYWwgQ2h1bmtzLCB0aGF0IHdpbGwgYmUgdXNlZCBsYXRl ciB0byByZWN5Y2xlCj4gdGhlIGRlZGljYXRlZCBtZW1vcnkgc3BhY2UgdG8gaW5pdGlhdGUgYSBu ZXcgc2VxdWVuY2Ugb2YgZGF0YSB0cmFuc2ZlcnMuCj4gCj4gVGhlIHdob2xlIHRyYW5zZmVyIGlz IGNvbnNpZGVyZWQgaGFzIGNvbXBsZXRlZCB3aGVuIGl0IHdhcyB0cmFuc2ZlcnJlZCBhbGwgYnVy c3RzLgo+IAo+IEN1cnJlbnRseSB0aGlzIElQIGhhcyBhIHNldCB3ZWxsLWtub3duIHJlZ2lzdGVy IG1hcCwgd2hpY2ggaW5jbHVkZXMgc3VwcG9ydCBmb3IKPiBsZWdhY3kgYW5kIHVucm9sbCBtb2Rl cy4gTGVnYWN5IG1vZGUgaXMgdmVyc2lvbiBvZiB0aGlzIHJlZ2lzdGVyIG1hcCB0aGF0IGhhcwoK d2hhdHMgIHVucm9sbC4uCgo+IG11bHRpcGxleGVyIHJlZ2lzdGVyIHRoYXQgYWxsb3dzIHRvIHN3 aXRjaCByZWdpc3RlcnMgYmV0d2VlbiBhbGwgd3JpdGUgYW5kIHJlYWQKPiBjaGFubmVscyBhbmQg dGhlIHVucm9sbCBtb2RlcyByZXBlYXRzIGFsbCB3cml0ZSBhbmQgcmVhZCBjaGFubmVscyByZWdp c3RlcnMgd2l0aAo+IGFuIG9mZnNldCBiZXR3ZWVuIHRoZW0uIFRoaXMgcmVnaXN0ZXIgbWFwIGlz IGNhbGxlZCB2MC4KPiAKPiBUaGUgSVAgdGVhbSBpcyBjcmVhdGluZyBhIG5ldyByZWdpc3RlciBt YXAgbW9yZSBzdWl0YWJsZSB0byB0aGUgbGF0ZXN0IFBDSWUKPiBmZWF0dXJlcywgdGhhdCB2ZXJ5 IGxpa2VseSB3aWxsIGNoYW5nZSB0aGUgbWFwIHJlZ2lzdGVyLCB3aGljaCB0aGlzIHZlcnNpb24g d2lsbAo+IGJlIGNhbGxlZCB2MS4gQXMgc29vbiBhcyB0aGlzIG5ldyB2ZXJzaW9uIGlzIHJlbGVh c2VkIGJ5IHRoZSBJUCB0ZWFtIHRoZSBzdXBwb3J0Cj4gZm9yIHRoaXMgdmVyc2lvbiBpbiBiZSBp bmNsdWRlZCBvbiB0aGlzIGRyaXZlci4KPiAKPiBXaGF0IGRvIHlvdSB0aGluaz8gVGhlcmUgaXMg YW55IGdyYXkgYXJlYSB0aGF0IEkgY291bGQgY2xhcmlmeT8KClRoaXMgc291bmRzIGdvb2QuIEJ1 dCB3ZSBhcmUgYWxzbyBjYXRlcmluZyB0byBhIFdJUCBJUCB3aGljaCBjYW4gY2hhbmdlCnJpZ2h0 LiBEb2VzbnQgc291bmQgdmVyeSBnb29kIGlkZWEgdG8gbWUgOikKCj4gPj4+PiArCWRldl9kYmco Y2hhbjJkZXYoY2hhbiksICJhZGRyKHBoeXNpY2FsKSBzcmM9JXBhLCBkc3Q9JXBhXG4iLAo+ID4+ Pj4gKwkJJmNvbmZpZy0+c3JjX2FkZHIsICZjb25maWctPmRzdF9hZGRyKTsKPiA+Pj4+ICsKPiA+ Pj4+ICsJY2hhbi0+c3JjX2FkZHIgPSBjb25maWctPnNyY19hZGRyOwo+ID4+Pj4gKwljaGFuLT5k c3RfYWRkciA9IGNvbmZpZy0+ZHN0X2FkZHI7Cj4gPj4+PiArCj4gPj4+PiArCWVyciA9IG9wcy0+ ZGV2aWNlX2NvbmZpZyhkY2hhbik7Cj4gPj4+Cj4gPj4+IHdoYXQgZG9lcyB0aGlzIGRvPwo+ID4+ Cj4gPj4gVGhpcyBpcyBhbiBpbml0aWFsaXphdGlvbiBwcm9jZWR1cmUgdG8gc2V0dXAgaW50ZXJy dXB0cyAoZGF0YSBhbmQgYWRkcmVzc2VzKSB0bwo+ID4+IGVhY2ggY2hhbm5lbCBvbiB0aGUgZURN QSBJUCwgIGluIG9yZGVyIHRvIGJlIHRyaWdnZXJlZCBhZnRlciB0cmFuc2ZlciBiZWluZwo+ID4+ IGNvbXBsZXRlZCBvciBhYm9ydGVkLiBEdWUgdGhlIGZhY3QgdGhlIGNvbmZpZygpIGNhbiBiZSBj YWxsZWQgYXQgYW55dGltZSwKPiA+PiBkb2Vzbid0IG1ha2Ugc2Vuc2UgdG8gaGF2ZSB0aGlzIHBy b2NlZHVyZSBoZXJlLCBJJ2xsIG1vdmVkIGl0IHRvIHByb2JlKCkuCj4gPiAKPiA+IFllYWggSSBh bSBub3Qgc3RpbGwgY29udmluY2VkIGFib3V0IGhhdmluZyBhbm90aGVyIGxheWVyISBIYXZlIHlv dQo+ID4gdGhvdWdoIGFib3V0IHVzaW5nIGNvbW1vbiBsaWIgZm9yIGNvbW1vbiBwYXJ0cyAuLj8K PiAKPiBNYXliZSBJJ20gZXhwbGFpbmluZyBteXNlbGYgd3JvbmdseS4gSSBkb24ndCBoYXZlIGFu eSBjbHVlIGFib3V0IHRoZSBuZXcKPiByZWdpc3RlciBtYXAgZm9yIHRoZSBmdXR1cmUgdmVyc2lv bnMuIEkgaG9uZXN0bHkgdHJpZWQgdG8gaW1wbGVtZW50IHRoZSBjb21tb24KPiBsaWIgZm9yIHRo ZSB3aG9sZSBwcm9jZXNzIHRoYXQgaW50ZXJhY3Qgd2l0aCBkbWEgZW5naW5lIGNvbnRyb2xsZXIg dG8gZWFzZSBpbgo+IHRoZSBmdXR1cmUgYW55IG5ldyBhZGRpdGlvbiBvZiByZWdpc3RlciBtYXBw aW5nLCBieSBoYXZpbmcgdGhpcyBjb21tb24gY2FsbGJhY2tzCj4gdGhhdCB3aWxsIG9ubHkgYmUg cmVzcG9uc2libGUgZm9yIGludGVyZmFjaW5nIHRoZSBIVyBhY2NvcmRpbmdseSB0byByZWdpc3Rl ciBtYXAKPiB2ZXJzaW9uLiBNYXliZSBJIGNhbiBzaW1wbGlmeSBzb21ldGhpbmcgaW4gdGhlIGZ1 dHVyZSwgYnV0IEkgb25seSBiZSBhYmxlIHRvCj4gY29uY2x1ZGUgdGhhdCBhZnRlciBoYXZpbmcg c29tZSBpZGVhIGFib3V0IHRoZSBuZXcgcmVnaXN0ZXIgbWFwLgo+IAo+IElNSE8gSSB0aGluayB0 aGlzIGlzIHRoZSBlYXNpZXIgYW5kIGNsZWFuIHdheSB0byBkbyBpdCwgaW4gdGVybXMgb2YgY29k ZQo+IG1haW50ZW5hbmNlIGFuZCBhcmNoaXRlY3R1cmUsIGJ1dCBpZiB5b3UgaGF2ZSBhbm90aGVy IGlkZWEgdGhhdCB5b3UgY2FuIHNob3cgbWUKPiBvciBwb2ludGluZyBvdXQgZm9yIGEgZHJpdmVy IHRoYXQgaW1wbGVtZW50cyBzb21ldGhpbmcgc2ltaWxhciwgSSdtIG5vIHByb2JsZW0KPiB0byBj aGVjayBpdCBvdXQuCgpUaGF0IGlzIHdoYXQgbXkgZmVhciB3YXMgOikKCkxldHMgc3RlcCBiYWNr IGFuZCBzb2x2ZSBvbmUgcHJvYmxlbSBhdCBhIHRpbWUuIFJpZ2h0IG5vdyB0aGF0IGlzIHYwIG9m CklQLiBQbGVhc2Ugd3JpdGUgYSBzaW1wbGUgZHJpdmVyIHdoaWNoIHNvbHZlIHYwIHdpdGhvdXQg YW55IGxheWVycwppbnZvbHZlZC4KCk9uY2UgdjEgaXMgaW4gZ29vZCBzaGFwZSwgeW91IHdvdWxk IGtub3cgd2hhdCBpdCByZXF1aXJlZCBhbmQgdGhlbiB3ZQpjYW4gc3BsaXQgdjAgZHJpdmVyIGlu dG8gY29tbW9uIGxpYiBhbmQgdjAgZHJpdmVyIGFuZCB0aGVuIGFkZCB2MQpkcml2ZXIuCgoKPiA+ Pj4gd2hhdCBpcyB0aGUgc2Vjb25kIHBhcnQgb2YgdGhlIGNoZWNrLCBjYW4geW91IGV4cGxhaW4g dGhhdCwgd2hvIHNldHMKPiA+Pj4gY2hhbi0+ZGlyPwo+ID4+Cj4gPj4gVGhlIGNoYW4tPmRpciBp cyBzZXQgb24gcHJvYmUoKSBkdXJpbmcgdGhlIHByb2Nlc3Mgb2YgY29uZmlndXJpbmcgZWFjaCBj aGFubmVsLgo+ID4gCj4gPiBTbyB5b3UgaGF2ZSBjaGFubmVscyB0aGF0IGFyZSB1bmlkaXJlY3Rp b25hbD8KPiAKPiBZZXMuIFRoYXQncyBvbmUgYW5vdGhlciByZWFzb24gSU1ITyB0byBrZWVwIHRo ZSBkdy1lZG1hLXRlc3Qgc2VwYXJhdGUgZnJvbQo+IGRtYS10ZXN0LCBzaW5jZSB0aGlzIElQIGlz IG1vcmUgcGlja3kgYW5kIGhhdmUgdGhpcyBwYXJ0aWN1bGFyaXRpZXMuCgpUaGF0IGlzIG9rYXks IHRoYXQgc2hvdWxkIGJlIGhhbmRsZWQgYnkgcHJlcCBjYWxscywgaWYgeW91IGdldCBhIHByZXAK Y2FsbCBmb3IgZGlyZWN0aW9uIHlvdSBkb250IHN1cHBvcnQgcmV0dXJuIGVycm9yIGFuZCBtb3Zl IHRvIG5leHQKYXZhaWxhYmxlIG9uZS4KClRoYXQgY2FuIGJlIGRvbmUgZ2VuZXJpY2FsbHkgaW4g ZG1hdGVzdCBkcml2ZXIgYW5kIHRvIGFuc3dlciB5b3VyCnF1ZXN0aW9uLCB5ZXMgSSB3b3VsZCB0 ZXN0IHRoYXQgOikKCj4gPj4+PiAraW50IGR3X2VkbWFfcHJvYmUoc3RydWN0IGR3X2VkbWFfY2hp cCAqY2hpcCkKPiA+Pj4+ICt7Cj4gPj4+PiArCXN0cnVjdCBkd19lZG1hICpkdyA9IGNoaXAtPmR3 Owo+ID4+Pj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjaGlwLT5kZXY7Cj4gPj4+PiArCWNvbnN0 IHN0cnVjdCBkd19lZG1hX2NvcmVfb3BzICpvcHM7Cj4gPj4+PiArCXNpemVfdCBsbF9jaHVuayA9 IGR3LT5sbF9yZWdpb24uc3o7Cj4gPj4+PiArCXNpemVfdCBkdF9jaHVuayA9IGR3LT5kdF9yZWdp b24uc3o7Cj4gPj4+PiArCXUzMiBjaF90b3Q7Cj4gPj4+PiArCWludCBpLCBqLCBlcnI7Cj4gPj4+ PiArCj4gPj4+PiArCXJhd19zcGluX2xvY2tfaW5pdCgmZHctPmxvY2spOwo+ID4+Pj4gKwo+ID4+ Pj4gKwkvKiBDYWxsYmFjayBvcGVyYXRpb24gc2VsZWN0aW9uIGFjY29yZGluZ2x5IHRvIGVETUEg dmVyc2lvbiAqLwo+ID4+Pj4gKwlzd2l0Y2ggKGR3LT52ZXJzaW9uKSB7Cj4gPj4+PiArCWRlZmF1 bHQ6Cj4gPj4+PiArCQlkZXZfZXJyKGRldiwgInVuc3VwcG9ydGVkIHZlcnNpb25cbiIpOwo+ID4+ Pj4gKwkJcmV0dXJuIC1FUEVSTTsKPiA+Pj4+ICsJfQo+ID4+Pgo+ID4+PiBTbyB3ZSBoYXZlIG9u bHkgb25lIGNhc2Ugd2hpY2ggcmV0dXJucyBlcnJvciwgd2FzIHRoaXMgY29kZSB0ZXN0ZWQ/Cj4g Pj4KPiA+PiBZZXMgaXQgd2FzLCBidXQgSSB1bmRlcnN0YW5kIHdoYXQgeW91ciBwb2ludCBvZiB2 aWV3Lgo+ID4+IFRoaXMgd2FzIGRvbmUgbGlrZSB0aGlzLCBiZWNhdXNlIEkgd2FubmEgdG8gc2Vn bWVudCB0aGUgcGF0Y2ggc2VyaWVzIGxpa2UgdGhpczoKPiA+PiAgMSkgQWRkaW5nIGVETUEgZHJp dmVyIGNvcmUsIHdoaWNoIGNvbnRhaW5zIHRoZSBkcml2ZXIgc2tlbGV0b24gYW5kIHRoZSB3aG9s ZQo+ID4+IGxvZ2ljIGFzc29jaWF0ZWQuCj4gPj4gIDIpIGFuZCAzKSBBZGRpbmcgdGhlIGNhbGxi YWNrcyBmb3IgdGhlIGVETUEgcmVnaXN0ZXIgbWFwcGluZyB2ZXJzaW9uIDAgKGl0IHdpbGwKPiA+ PiBhcHBlYXIgaW4gdGhlIGZ1dHVyZSBhIG5ldyB2ZXJzaW9uLCBJIHRob3VnaHQgdGhhdCB0aGlz IG5ldyB2ZXJzaW9uIHdvdWxkIGNhbWUKPiA+PiB3aGlsZSBJIHdhcyB0cnlpbmcgdG8gZ2V0IHRo ZSBmZWVkYmFjayBhYm91dCB0aGlzIHBhdGNoIHNlcmllcywgdGhlcmVmb3JlIHdvdWxkCj4gPj4g aGF2ZSBhbm90aGVyIDIgcGF0Y2hlcyBmb3IgdGhlIHZlcnNpb24gMSBpc29sYXRlZCBhbmQgaW5k ZXBlbmRlbnQgZnJvbSB0aGUKPiA+PiB2ZXJzaW9uIDApLgo+ID4+ICA0KSBhbmQgNSkgQWRkaW5n IHRoZSBQQ0llIGdsdWUtbG9naWMgYW5kIGRldmljZSBJRCBhc3NvY2lhdGVkLgo+ID4+ICA2KSBB ZGRpbmcgbWFpbnRhaW5lciBmb3IgdGhpcyBkcml2ZXIuCj4gPj4gIDcpIEFkZGluZyBhIHRlc3Qg ZHJpdmVyLgo+ID4+Cj4gPj4gU2luY2UgdGhpcyBzd2l0Y2ggd2lsbCBvbmx5IGhhdmUgdGhlIGFz c29jaWF0ZWQgY2FzZSBvbiBwYXRjaCAyLCB0aGF0IHdoeSBvbgo+ID4+IHBhdGNoIDEgZG9lc24n dCBhcHBlYXIgYW55IHBvc3NpYmlsaXR5Lgo+ID4+Cj4gPj4gSWYgeW91IGZlZWwgbG9naWMgdG8g c3F1YXNoIHBhdGNoIDIgd2l0aCBwYXRjaCAxLCBqdXN0IHNheSBzb21ldGhpbmcgYW5kIEknbGwg ZG8KPiA+PiBpdCBmb3IgeW91IDopCj4gPiAKPiA+IHdlbGwgZWFjaCBwYXRjaCBzaG91bGQgYnVp bGQgYW5kIHdvcmsgb24gaXRzIG93biwgb3RoZXJ3aXNlIHdlIGdldAo+ID4gcHJvYmxlbXMgOikg QnV0IHNpbmNlIHRoaXMgaXMgYSBuZXcgZHJpdmVyIGl0IGlzIG9rYXkuIEFueXdheSB0aGlzIHBh dGNoCj4gPiBpcyBxdWl0ZSBfaHVnZV8gc28gbGV0cyBub3QgYWRkIG1vcmUgdG8gaXQuLgo+ID4g Cj4gPiBJIHdvdWxkIGhhdmUgbW92ZWQgdGhlIGNhbGxiYWNrIGNoZWNrIHRvIHN1YnNlcXVlbnQg b25lLi4KPiAKPiBTb3JyeS4gSSBkaWRuJ3QgY2F0Y2ggdGhpcy4gQ2FuIHlvdSBleHBsYWluIGl0 PwoKSSB3b3VsZCBoYXZlIG1vdmVkIHRoZXNlIGxpbmVzIHRvIG5leHQgcGF0Y2ggdG8gZ2l2ZSB0 aGVtIHJpZ2h0IG1lYW5pbmcsCmhlcmUgaXQgZmVlbHMgd3Jvbmc6CgogICAgICAgIHN3aXRjaCAo ZHctPnZlcnNpb24pIHsKICAgICAgICBjYXNlIGZvbzoKICAgICAgICAgICAgICAgIC4uLgogICAg ICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICAgICAuLi4KICAgICAgICB9Cg== 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 D16B9C282D8 for ; Fri, 1 Feb 2019 04:15:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 876922184A for ; Fri, 1 Feb 2019 04:15:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1548994533; bh=/uFoG+GGI8zAZ3fYBk52rBU//wyD2K7rQSF0Cu7pJqU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:List-ID:From; b=si8nRaXuTgE1UnXyfJW1IJA3fFnA752gFXnYyvL1ohVJVocndC3ECaqlKaeoG6w3X WK4t0L9pG6bDloQKJxhcO7GbyDIAY2vJLsg269gtfcnxLHi2JAMbjJ3P4RrF3zqabl l4WY57TUXZSfsJ1CXQwtApfvaUfEIouCr4qpNUTU= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726233AbfBAEPc (ORCPT ); Thu, 31 Jan 2019 23:15:32 -0500 Received: from mail.kernel.org ([198.145.29.99]:54834 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725963AbfBAEPc (ORCPT ); Thu, 31 Jan 2019 23:15:32 -0500 Received: from localhost (unknown [171.76.100.40]) (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 ADDF220823; Fri, 1 Feb 2019 04:15:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1548994531; bh=/uFoG+GGI8zAZ3fYBk52rBU//wyD2K7rQSF0Cu7pJqU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=qYUv++NjJLw9lfCgvSQL7bsQKE1iZY4bWLrfgdvSA3w62zRl/5LKK114w9gFVFoLs 7ps8qaK/k6wamNNmrnK3+RS18SnFQAvkSBERZuuQvznrf6u9hHWDs+93+XyIAy4L5Q 2dDrcGWyPavCNsR+/mcroHZw8plwbTVcAJIdAdHw= Date: Fri, 1 Feb 2019 09:44:00 +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: <20190201041400.GL4635@vkoul-mobl> References: <20190120114425.GV4635@vkoul-mobl> <14acfcee-b367-be9c-714b-de0508ff1a7d@synopsys.com> <20190123130829.GQ4635@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 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 ? Is Burst 0 to 129 a link list with Burst 0, 42, 84 and 126 having a callback (done bit set).. This sound **very** similar to dw dma concepts! > > 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 > 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 :) > >>>> + 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. > >>> 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 :) > >>>> +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: ... } -- ~Vinod