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: [v5,2/6] dmaengine: fsl-qdma: Add qDMA controller driver for Layerscape SoCs From: Vinod Koul Message-Id: <20180529070724.GE5666@vkoul-mobl> Date: Tue, 29 May 2018 12:37:24 +0530 To: Wen He Cc: dmaengine@vger.kernel.org, robh+dt@kernel.org, devicetree@vger.kernel.org, leoyang.li@nxp.com, jiafei.pan@nxp.com, jiaheng.fan@nxp.com List-ID: T24gMjUtMDUtMTgsIDE5OjE5LCBXZW4gSGUgd3JvdGU6Cgo+ICsvKioKPiArICogc3RydWN0IGZz bF9xZG1hX2Zvcm1hdCAtIFRoaXMgaXMgdGhlIHN0cnVjdCBob2xkaW5nIGRlc2NyaWJpbmcgY29t cG91bmQKPiArICoJCQkgICAgZGVzY3JpcHRvciBmb3JtYXQgd2l0aCBxRE1BLgo+ICsgKiBAc3Rh dHVzOgkJICAgIFRoaXMgZmllbGQgd2hpY2ggZGVzY3JpYmVzIGNvbW1hbmQgc3RhdHVzIGFuZAo+ ICsgKgkJCSAgICBlbnF1ZXVlIHN0YXR1cyBub3RpZmljYXRpb24uCj4gKyAqIEBjZmc6CQkgICAg VGhpcyBmaWVsZCB3aGljaCBkZXNjcmliZXMgZnJhbWUgb2Zmc2V0IGFuZCBmcmFtZQo+ICsgKgkJ CSAgICBmb3JtYXQuCj4gKyAqIEBhZGRyX2xvOgkJICAgIFRoaXMgZmllbGQgd2hpY2ggaW5kaWNh dGluZyB0aGUgc3RhcnQgb2YgdGhlIGJ1ZmZlcgo+ICsgKgkJCSAgICBob2xkaW5nIHRoZSBjb21w b3VuZCBkZXNjcmlwdG9yIG9mIHRoZSBsb3dlciAzMi1iaXRzCj4gKyAqCQkJICAgIGFkZHJlc3Mg aW4gbWVtb3J5IDQwLWJpdCBhZGRyZXNzLgo+ICsgKiBAYWRkcl9oaToJCSAgICBUaGlzIGZpZWxk J3MgdGhlIHNhbWUgYXMgYWJvdmUgZmllbGQsIGJ1dCBwb2ludCBoaWdoCj4gKyAqCQkJICAgIDgt Yml0cyBpbiBtZW1vcnkgNDAtYml0IGFkZHJlc3MuCj4gKyAqIEBfX3Jlc2VydmVkMToJICAgIFJl c2VydmVkIGZpZWxkLgo+ICsgKiBAY2ZnOGJfdzE6CQkgICAgVGhpcyBmaWVsZCB3aGljaCBkZXNj cmliZXMgY29tcG91bmQgZGVzY3JpcHRvcgo+ICsgKgkJCSAgICBjb21tYW5kIHF1ZXVlIG9yaWdp biBwcm9kdWNlZCBieSBxRE1BIGFuZCBkeW5hbWljCgp5b3UgbWF5IHJlbW92ZSAnVGhpcyBmaWVs ZCB3aGljaCBkZXNjcmliZXMnLi4uIGluIGFib3ZlIGxpbmVzLCBnaXZlIHJlYWRlciBubwppbmZv cm1hdGlvbiA6KQoKPiArICoJCQkgICAgZGVidWcgZmllbGQuCj4gKyAqIEBkYXRhCQkgICAgUG9p bnRlciB0byB0aGUgbWVtb3J5IDQwLWJpdCBhZGRyZXNzLCBkZXNjcmliZXMgRE1BCj4gKyAqCQkJ ICAgIHNvdXJjZSBpbmZvcm1haW9uIGFuZCBETUEgZGVzdGluYXRpb24gaW5mb3JtYXRpb24uCgp0 eXBvIGluZm9ybWFpb24KCj4gK3N0YXRpYyBzdHJ1Y3QgZnNsX3FkbWFfcXVldWUgKmZzbF9xZG1h X2FsbG9jX3F1ZXVlX3Jlc291cmNlcygKPiArCQkJCQlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2LAo+ICsJCQkJCXVuc2lnbmVkIGludCBxdWV1ZV9udW0pCj4gK3sKPiArCXN0cnVjdCBmc2xf cWRtYV9xdWV1ZSAqcXVldWVfaGVhZCwgKnF1ZXVlX3RlbXA7Cj4gKwlpbnQgcmV0LCBsZW4sIGk7 Cj4gKwl1bnNpZ25lZCBpbnQgcXVldWVfc2l6ZVtGU0xfUURNQV9RVUVVRV9NQVhdOwo+ICsKPiAr CWlmIChxdWV1ZV9udW0gPiBGU0xfUURNQV9RVUVVRV9NQVgpCj4gKwkJcXVldWVfbnVtID0gRlNM X1FETUFfUVVFVUVfTUFYOwo+ICsJbGVuID0gc2l6ZW9mKCpxdWV1ZV9oZWFkKSAqIHF1ZXVlX251 bTsKPiArCXF1ZXVlX2hlYWQgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgbGVuLCBHRlBfS0VS TkVMKTsKPiArCWlmICghcXVldWVfaGVhZCkKPiArCQlyZXR1cm4gTlVMTDsKPiArCj4gKwlyZXQg PSBkZXZpY2VfcHJvcGVydHlfcmVhZF91MzJfYXJyYXkoJnBkZXYtPmRldiwgInF1ZXVlLXNpemVz IiwKPiArCQkJCQlxdWV1ZV9zaXplLCBxdWV1ZV9udW0pOwo+ICsJaWYgKHJldCkgewo+ICsJCWRl dl9lcnIoJnBkZXYtPmRldiwgIkNhbid0IGdldCBxdWV1ZS1zaXplcy5cbiIpOwo+ICsJCXJldHVy biBOVUxMOwo+ICsJfQo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBxdWV1ZV9udW07IGkrKykgewo+ ICsJCWlmIChxdWV1ZV9zaXplW2ldID4gRlNMX1FETUFfQ0lSQ1VMQVJfREVTQ19TSVpFX01BWAo+ ICsJCQl8fCBxdWV1ZV9zaXplW2ldIDwgRlNMX1FETUFfQ0lSQ1VMQVJfREVTQ19TSVpFX01JTikg ewo+ICsJCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJHZXQgd3JvbmcgcXVldWUtc2l6ZXMuXG4iKTsK PiArCQkJcmV0dXJuIE5VTEw7Cgp0aGUgaW5kZW50cyBoZXJlIGFyZSBiYWQgZm9yIHJlYWRpbmcu LgoKPiArc3RhdGljIGludCBmc2xfcWRtYV9xdWV1ZV90cmFuc2Zlcl9jb21wbGV0ZShzdHJ1Y3Qg ZnNsX3FkbWFfZW5naW5lICpmc2xfcWRtYSkKPiArewo+ICsJc3RydWN0IGZzbF9xZG1hX3F1ZXVl ICpmc2xfcXVldWUgPSBmc2xfcWRtYS0+cXVldWU7Cj4gKwlzdHJ1Y3QgZnNsX3FkbWFfcXVldWUg KmZzbF9zdGF0dXMgPSBmc2xfcWRtYS0+c3RhdHVzOwo+ICsJc3RydWN0IGZzbF9xZG1hX3F1ZXVl ICp0ZW1wX3F1ZXVlOwo+ICsJc3RydWN0IGZzbF9xZG1hX2NvbXAgKmZzbF9jb21wOwo+ICsJc3Ry dWN0IGZzbF9xZG1hX2Zvcm1hdCAqc3RhdHVzX2FkZHI7Cj4gKwlzdHJ1Y3QgZnNsX3FkbWFfZm9y bWF0ICpjc2dmX3NyYzsKPiArCXN0cnVjdCBmc2xfcHJlX3N0YXR1cyBwcmU7Cj4gKwl2b2lkIF9f aW9tZW0gKmJsb2NrID0gZnNsX3FkbWEtPmJsb2NrX2Jhc2U7Cj4gKwl1MzIgcmVnLCBpOwo+ICsJ Ym9vbCBkdXBsaWNhdGUsIGR1cGxpY2F0ZV9oYW5kbGU7Cj4gKwo+ICsJbWVtc2V0KCZwcmUsIDAs IHNpemVvZihzdHJ1Y3QgZnNsX3ByZV9zdGF0dXMpKTsKPiArCj4gKwl3aGlsZSAoMSkgewo+ICsJ CWR1cGxpY2F0ZSA9IDA7Cj4gKwkJZHVwbGljYXRlX2hhbmRsZSA9IDA7Cj4gKwkJcmVnID0gcWRt YV9yZWFkbChmc2xfcWRtYSwgYmxvY2sgKyBGU0xfUURNQV9CU1FTUik7Cj4gKwkJaWYgKHJlZyAm IEZTTF9RRE1BX0JTUVNSX1FFKQo+ICsJCQlyZXR1cm4gMDsKPiArCQlzdGF0dXNfYWRkciA9IGZz bF9zdGF0dXMtPnZpcnRfaGVhZDsKPiArCQlpZiAocWRtYV9jY2RmX2dldF9xdWV1ZShzdGF0dXNf YWRkcikgPT0gcHJlLnF1ZXVlICYmCj4gKwkJCXFkbWFfY2NkZl9hZGRyX2dldDY0KHN0YXR1c19h ZGRyKSA9PSBwcmUuYWRkcikKPiArCQkJZHVwbGljYXRlID0gMTsKPiArCQlpID0gcWRtYV9jY2Rm X2dldF9xdWV1ZShzdGF0dXNfYWRkcik7Cj4gKwkJcHJlLnF1ZXVlID0gcWRtYV9jY2RmX2dldF9x dWV1ZShzdGF0dXNfYWRkcik7Cj4gKwkJcHJlLmFkZHIgPSBxZG1hX2NjZGZfYWRkcl9nZXQ2NChz dGF0dXNfYWRkcik7Cj4gKwkJdGVtcF9xdWV1ZSA9IGZzbF9xdWV1ZSArIGk7Cj4gKwkJc3Bpbl9s b2NrKCZ0ZW1wX3F1ZXVlLT5xdWV1ZV9sb2NrKTsKPiArCQlpZiAobGlzdF9lbXB0eSgmdGVtcF9x dWV1ZS0+Y29tcF91c2VkKSkgewo+ICsJCQlpZiAoZHVwbGljYXRlKQo+ICsJCQkJZHVwbGljYXRl X2hhbmRsZSA9IDE7Cgpjb2RlIHN0eWxlIG1hbmRhdGVzIGJyYWNlcyBmb3IgdGhpcyBhcyBlbHNl IGhhcyBicmFjZXMuLgoKPiArCQkJZWxzZSB7Cj4gKwkJCQlzcGluX3VubG9jaygmdGVtcF9xdWV1 ZS0+cXVldWVfbG9jayk7Cj4gKwkJCQlyZXR1cm4gLUVBR0FJTjsKPiArCQkJfQo+ICsJCX0gZWxz ZSB7Cj4gKwkJCWZzbF9jb21wID0gbGlzdF9maXJzdF9lbnRyeSgmdGVtcF9xdWV1ZS0+Y29tcF91 c2VkLAo+ICsJCQkJCQkJc3RydWN0IGZzbF9xZG1hX2NvbXAsCj4gKwkJCQkJCQlsaXN0KTsKPiAr CQkJY3NnZl9zcmMgPSBmc2xfY29tcC0+dmlydF9hZGRyICsgMjsKPiArCQkJaWYgKGZzbF9jb21w LT5idXNfYWRkciArIDE2ICE9IHByZS5hZGRyKSB7Cj4gKwkJCQlpZiAoZHVwbGljYXRlKQo+ICsJ CQkJCWR1cGxpY2F0ZV9oYW5kbGUgPSAxOwoKaGVyZSBhcyB3ZWxsCgo+ICtzdGF0aWMgaXJxcmV0 dXJuX3QgZnNsX3FkbWFfZXJyb3JfaGFuZGxlcihpbnQgaXJxLCB2b2lkICpkZXZfaWQpCj4gK3sK PiArCXN0cnVjdCBmc2xfcWRtYV9lbmdpbmUgKmZzbF9xZG1hID0gZGV2X2lkOwo+ICsJdW5zaWdu ZWQgaW50IGludHI7Cj4gKwl2b2lkIF9faW9tZW0gKnN0YXR1cyA9IGZzbF9xZG1hLT5zdGF0dXNf YmFzZTsKPiArCj4gKwlpbnRyID0gcWRtYV9yZWFkbChmc2xfcWRtYSwgc3RhdHVzICsgRlNMX1FE TUFfREVEUik7Cj4gKwo+ICsJaWYgKGludHIpCj4gKwkJZGV2X2Vycihmc2xfcWRtYS0+ZG1hX2Rl di5kZXYsICJETUEgdHJhbnNhY3Rpb24gZXJyb3IhXG4iKTsKPiArCj4gKwlxZG1hX3dyaXRlbChm c2xfcWRtYSwgMHhmZmZmZmZmZiwgc3RhdHVzICsgRlNMX1FETUFfREVEUik7Cgp3aHkgdW5jb25k aXRpb25hbCB3cml0ZSwgd2FzIGV4cGVjdGluZyB0aGF0IHlvdSB3b3VsZCB3cml0ZSBpZiBpbnRy IGlzIG5vbiBudWxsCgo+ICtzdGF0aWMgaW50IGZzbF9xZG1hX3JlZ19pbml0KHN0cnVjdCBmc2xf cWRtYV9lbmdpbmUgKmZzbF9xZG1hKQo+ICt7Cj4gKwlzdHJ1Y3QgZnNsX3FkbWFfcXVldWUgKmZz bF9xdWV1ZSA9IGZzbF9xZG1hLT5xdWV1ZTsKPiArCXN0cnVjdCBmc2xfcWRtYV9xdWV1ZSAqdGVt cDsKPiArCXZvaWQgX19pb21lbSAqY3RybCA9IGZzbF9xZG1hLT5jdHJsX2Jhc2U7Cj4gKwl2b2lk IF9faW9tZW0gKnN0YXR1cyA9IGZzbF9xZG1hLT5zdGF0dXNfYmFzZTsKPiArCXZvaWQgX19pb21l bSAqYmxvY2sgPSBmc2xfcWRtYS0+YmxvY2tfYmFzZTsKPiArCWludCBpLCByZXQ7Cj4gKwl1MzIg cmVnOwo+ICsKPiArCS8qIFRyeSB0byBoYWx0IHRoZSBxRE1BIGVuZ2luZSBmaXJzdC4gKi8KPiAr CXJldCA9IGZzbF9xZG1hX2hhbHQoZnNsX3FkbWEpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9l cnIoZnNsX3FkbWEtPmRtYV9kZXYuZGV2LCAiRE1BIGhhbHQgZmFpbGVkISIpOwo+ICsJCXJldHVy biByZXQ7Cj4gKwl9Cj4gKwo+ICsJLyoKPiArCSAqIENsZWFyIHRoZSBjb21tYW5kIHF1ZXVlIGlu dGVycnVwdCBkZXRlY3QgcmVnaXN0ZXIgZm9yIGFsbCBxdWV1ZXMuCj4gKwkgKi8KPiArCXFkbWFf d3JpdGVsKGZzbF9xZG1hLCAweGZmZmZmZmZmLCBibG9jayArIEZTTF9RRE1BX0JDUUlEUigwKSk7 CgpidW5jaCBvZiB3cml0ZXMgd2l0aCAweGZmZmZmZmZmLCBjYW4geW91IGV4cGxhaW4gd2h5PyBB bHNvIGhlbHBzIHRvIG1ha2UgYQptYWNybyBmb3IgdGhpcwoKPiArCj4gKwlmb3IgKGkgPSAwOyBp IDwgZnNsX3FkbWEtPm5fcXVldWVzOyBpKyspIHsKPiArCQl0ZW1wID0gZnNsX3F1ZXVlICsgaTsK PiArCQkvKgo+ICsJCSAqIEluaXRpYWxpemUgQ29tbWFuZCBRdWV1ZSByZWdpc3RlcnMgdG8gcG9p bnQgdG8gdGhlIGZpcnN0Cj4gKwkJICogY29tbWFuZCBkZXNjcmlwdG9yIGluIG1lbW9yeS4KPiAr CQkgKiBEZXF1ZXVlIFBvaW50ZXIgQWRkcmVzcyBSZWdpc3RlcnMKPiArCQkgKiBFbnF1ZXVlIFBv aW50ZXIgQWRkcmVzcyBSZWdpc3RlcnMKPiArCQkgKi8KPiArCQlxZG1hX3dyaXRlbChmc2xfcWRt YSwgdGVtcC0+YnVzX2FkZHIsCj4gKwkJCQlibG9jayArIEZTTF9RRE1BX0JDUURQQV9TQUREUihp KSk7Cj4gKwkJcWRtYV93cml0ZWwoZnNsX3FkbWEsIHRlbXAtPmJ1c19hZGRyLAo+ICsJCQkJYmxv Y2sgKyBGU0xfUURNQV9CQ1FFUEFfU0FERFIoaSkpOwo+ICsKPiArCQkvKiBJbml0aWFsaXplIHRo ZSBxdWV1ZSBtb2RlLiAqLwo+ICsJCXJlZyA9IEZTTF9RRE1BX0JDUU1SX0VOOwo+ICsJCXJlZyB8 PSBGU0xfUURNQV9CQ1FNUl9DRF9USExEKGlsb2cyKHRlbXAtPm5fY3EpLTQpOwo+ICsJCXJlZyB8 PSBGU0xfUURNQV9CQ1FNUl9DUV9TSVpFKGlsb2cyKHRlbXAtPm5fY3EpLTYpOwoKc3BhY2UgYXJv dW5kIC0gaW4gdGhlIGFib3ZlIHR3byBsaW5lcwoKPiArc3RhdGljIGVudW0gZG1hX3N0YXR1cyBm c2xfcWRtYV90eF9zdGF0dXMoc3RydWN0IGRtYV9jaGFuICpjaGFuLAo+ICsJCWRtYV9jb29raWVf dCBjb29raWUsIHN0cnVjdCBkbWFfdHhfc3RhdGUgKnR4c3RhdGUpCj4gK3sKPiArCWVudW0gZG1h X3N0YXR1cyByZXQ7Cj4gKwo+ICsJcmV0ID0gZG1hX2Nvb2tpZV9zdGF0dXMoY2hhbiwgY29va2ll LCB0eHN0YXRlKTsKPiArCWlmIChyZXQgPT0gRE1BX0NPTVBMRVRFIHx8ICF0eHN0YXRlKQo+ICsJ CXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIHJldDsKCmhtbW0sIHRoaXMgc2VlbXMgc2FtZSBh cyByZXR1cm4gZG1hX2Nvb2tpZV9zdGF0dXMoKSBzbyB3aHkgc2hvdWxkIHdlIGhhdmUgcmVzdApv ZiB0aGUgY29kZQoKPiArc3RhdGljIHZvaWQgZnNsX3FkbWFfaXNzdWVfcGVuZGluZyhzdHJ1Y3Qg ZG1hX2NoYW4gKmNoYW4pCj4gK3sKPiArCXN0cnVjdCBmc2xfcWRtYV9jaGFuICpmc2xfY2hhbiA9 IHRvX2ZzbF9xZG1hX2NoYW4oY2hhbik7Cj4gKwlzdHJ1Y3QgZnNsX3FkbWFfcXVldWUgKmZzbF9x dWV1ZSA9IGZzbF9jaGFuLT5xdWV1ZTsKPiArCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4gKwo+ICsJ c3Bpbl9sb2NrX2lycXNhdmUoJmZzbF9xdWV1ZS0+cXVldWVfbG9jaywgZmxhZ3MpOwo+ICsJc3Bp bl9sb2NrKCZmc2xfY2hhbi0+dmNoYW4ubG9jayk7Cj4gKwlpZiAodmNoYW5faXNzdWVfcGVuZGlu ZygmZnNsX2NoYW4tPnZjaGFuKSkKPiArCQlmc2xfcWRtYV9lbnF1ZXVlX2Rlc2MoZnNsX2NoYW4p Owo+ICsJc3Bpbl91bmxvY2soJmZzbF9jaGFuLT52Y2hhbi5sb2NrKTsKPiArCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJmZzbF9xdWV1ZS0+cXVldWVfbG9jaywgZmxhZ3MpOwoKd2h5IGRvIHdlIG5l ZWQgdHdvIGxvY2tzLCBhbmQgc2luY2UgeW91IGFyZSBkb2luZyB2Y2hhbiB3aHkgc2hvdWxkIHlv dSBhZGQgeW91cgpvd24gbG9jayBvbiB0b3AKCi4uLgoKT3ZlcmFsbCB0aGUgcGF0Y2ggaGFzIHNv bWUgY29kZSBzdHlsZSBpc3N1ZXMgd2hpY2gga2VlcCBjYXRjaGluZyBteSBleWUsIGNhbgp5b3Ug cGxlYXNlIGNoZWNrIHRoZW0uIEFsc28gd291bGQgaGVscCB0byBydW4gY2hlY2twYXRjaCB3aXRo IC0tc3RyaWN0IGFuZAotLWNvZGVzcGVsbCBvcHRpb24gdG8gY2F0Y2ggdHlwb3MgYW5kIGFsaWdu bWVudCBpc3N1ZS4gUGxlYXNlIGJld2FyZSBjaGVja3BhdGNoCmlzIGEgZ3VpZGUgYW5kIE5PVCBh IHJ1bGVib29rIHNvIHVzZSB5b3VyIGRpc2NyZXRpb24gOikK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Date: Tue, 29 May 2018 12:37:24 +0530 From: Vinod Subject: Re: [v5 2/6] dmaengine: fsl-qdma: Add qDMA controller driver for Layerscape SoCs Message-ID: <20180529070724.GE5666@vkoul-mobl> References: <20180525111920.24498-1-wen.he_1@nxp.com> <20180525111920.24498-2-wen.he_1@nxp.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20180525111920.24498-2-wen.he_1@nxp.com> To: Wen He Cc: dmaengine@vger.kernel.org, robh+dt@kernel.org, devicetree@vger.kernel.org, leoyang.li@nxp.com, jiafei.pan@nxp.com, jiaheng.fan@nxp.com List-ID: On 25-05-18, 19:19, Wen He wrote: > +/** > + * struct fsl_qdma_format - This is the struct holding describing compound > + * descriptor format with qDMA. > + * @status: This field which describes command status and > + * enqueue status notification. > + * @cfg: This field which describes frame offset and frame > + * format. > + * @addr_lo: This field which indicating the start of the buffer > + * holding the compound descriptor of the lower 32-bits > + * address in memory 40-bit address. > + * @addr_hi: This field's the same as above field, but point high > + * 8-bits in memory 40-bit address. > + * @__reserved1: Reserved field. > + * @cfg8b_w1: This field which describes compound descriptor > + * command queue origin produced by qDMA and dynamic you may remove 'This field which describes'... in above lines, give reader no information :) > + * debug field. > + * @data Pointer to the memory 40-bit address, describes DMA > + * source informaion and DMA destination information. typo informaion > +static struct fsl_qdma_queue *fsl_qdma_alloc_queue_resources( > + struct platform_device *pdev, > + unsigned int queue_num) > +{ > + struct fsl_qdma_queue *queue_head, *queue_temp; > + int ret, len, i; > + unsigned int queue_size[FSL_QDMA_QUEUE_MAX]; > + > + if (queue_num > FSL_QDMA_QUEUE_MAX) > + queue_num = FSL_QDMA_QUEUE_MAX; > + len = sizeof(*queue_head) * queue_num; > + queue_head = devm_kzalloc(&pdev->dev, len, GFP_KERNEL); > + if (!queue_head) > + return NULL; > + > + ret = device_property_read_u32_array(&pdev->dev, "queue-sizes", > + queue_size, queue_num); > + if (ret) { > + dev_err(&pdev->dev, "Can't get queue-sizes.\n"); > + return NULL; > + } > + > + for (i = 0; i < queue_num; i++) { > + if (queue_size[i] > FSL_QDMA_CIRCULAR_DESC_SIZE_MAX > + || queue_size[i] < FSL_QDMA_CIRCULAR_DESC_SIZE_MIN) { > + dev_err(&pdev->dev, "Get wrong queue-sizes.\n"); > + return NULL; the indents here are bad for reading.. > +static int fsl_qdma_queue_transfer_complete(struct fsl_qdma_engine *fsl_qdma) > +{ > + struct fsl_qdma_queue *fsl_queue = fsl_qdma->queue; > + struct fsl_qdma_queue *fsl_status = fsl_qdma->status; > + struct fsl_qdma_queue *temp_queue; > + struct fsl_qdma_comp *fsl_comp; > + struct fsl_qdma_format *status_addr; > + struct fsl_qdma_format *csgf_src; > + struct fsl_pre_status pre; > + void __iomem *block = fsl_qdma->block_base; > + u32 reg, i; > + bool duplicate, duplicate_handle; > + > + memset(&pre, 0, sizeof(struct fsl_pre_status)); > + > + while (1) { > + duplicate = 0; > + duplicate_handle = 0; > + reg = qdma_readl(fsl_qdma, block + FSL_QDMA_BSQSR); > + if (reg & FSL_QDMA_BSQSR_QE) > + return 0; > + status_addr = fsl_status->virt_head; > + if (qdma_ccdf_get_queue(status_addr) == pre.queue && > + qdma_ccdf_addr_get64(status_addr) == pre.addr) > + duplicate = 1; > + i = qdma_ccdf_get_queue(status_addr); > + pre.queue = qdma_ccdf_get_queue(status_addr); > + pre.addr = qdma_ccdf_addr_get64(status_addr); > + temp_queue = fsl_queue + i; > + spin_lock(&temp_queue->queue_lock); > + if (list_empty(&temp_queue->comp_used)) { > + if (duplicate) > + duplicate_handle = 1; code style mandates braces for this as else has braces.. > + else { > + spin_unlock(&temp_queue->queue_lock); > + return -EAGAIN; > + } > + } else { > + fsl_comp = list_first_entry(&temp_queue->comp_used, > + struct fsl_qdma_comp, > + list); > + csgf_src = fsl_comp->virt_addr + 2; > + if (fsl_comp->bus_addr + 16 != pre.addr) { > + if (duplicate) > + duplicate_handle = 1; here as well > +static irqreturn_t fsl_qdma_error_handler(int irq, void *dev_id) > +{ > + struct fsl_qdma_engine *fsl_qdma = dev_id; > + unsigned int intr; > + void __iomem *status = fsl_qdma->status_base; > + > + intr = qdma_readl(fsl_qdma, status + FSL_QDMA_DEDR); > + > + if (intr) > + dev_err(fsl_qdma->dma_dev.dev, "DMA transaction error!\n"); > + > + qdma_writel(fsl_qdma, 0xffffffff, status + FSL_QDMA_DEDR); why unconditional write, was expecting that you would write if intr is non null > +static int fsl_qdma_reg_init(struct fsl_qdma_engine *fsl_qdma) > +{ > + struct fsl_qdma_queue *fsl_queue = fsl_qdma->queue; > + struct fsl_qdma_queue *temp; > + void __iomem *ctrl = fsl_qdma->ctrl_base; > + void __iomem *status = fsl_qdma->status_base; > + void __iomem *block = fsl_qdma->block_base; > + int i, ret; > + u32 reg; > + > + /* Try to halt the qDMA engine first. */ > + ret = fsl_qdma_halt(fsl_qdma); > + if (ret) { > + dev_err(fsl_qdma->dma_dev.dev, "DMA halt failed!"); > + return ret; > + } > + > + /* > + * Clear the command queue interrupt detect register for all queues. > + */ > + qdma_writel(fsl_qdma, 0xffffffff, block + FSL_QDMA_BCQIDR(0)); bunch of writes with 0xffffffff, can you explain why? Also helps to make a macro for this > + > + for (i = 0; i < fsl_qdma->n_queues; i++) { > + temp = fsl_queue + i; > + /* > + * Initialize Command Queue registers to point to the first > + * command descriptor in memory. > + * Dequeue Pointer Address Registers > + * Enqueue Pointer Address Registers > + */ > + qdma_writel(fsl_qdma, temp->bus_addr, > + block + FSL_QDMA_BCQDPA_SADDR(i)); > + qdma_writel(fsl_qdma, temp->bus_addr, > + block + FSL_QDMA_BCQEPA_SADDR(i)); > + > + /* Initialize the queue mode. */ > + reg = FSL_QDMA_BCQMR_EN; > + reg |= FSL_QDMA_BCQMR_CD_THLD(ilog2(temp->n_cq)-4); > + reg |= FSL_QDMA_BCQMR_CQ_SIZE(ilog2(temp->n_cq)-6); space around - in the above two lines > +static enum dma_status fsl_qdma_tx_status(struct dma_chan *chan, > + dma_cookie_t cookie, struct dma_tx_state *txstate) > +{ > + enum dma_status ret; > + > + ret = dma_cookie_status(chan, cookie, txstate); > + if (ret == DMA_COMPLETE || !txstate) > + return ret; > + > + return ret; hmmm, this seems same as return dma_cookie_status() so why should we have rest of the code > +static void fsl_qdma_issue_pending(struct dma_chan *chan) > +{ > + struct fsl_qdma_chan *fsl_chan = to_fsl_qdma_chan(chan); > + struct fsl_qdma_queue *fsl_queue = fsl_chan->queue; > + unsigned long flags; > + > + spin_lock_irqsave(&fsl_queue->queue_lock, flags); > + spin_lock(&fsl_chan->vchan.lock); > + if (vchan_issue_pending(&fsl_chan->vchan)) > + fsl_qdma_enqueue_desc(fsl_chan); > + spin_unlock(&fsl_chan->vchan.lock); > + spin_unlock_irqrestore(&fsl_queue->queue_lock, flags); why do we need two locks, and since you are doing vchan why should you add your own lock on top ... Overall the patch has some code style issues which keep catching my eye, can you please check them. Also would help to run checkpatch with --strict and --codespell option to catch typos and alignment issue. Please beware checkpatch is a guide and NOT a rulebook so use your discretion :) -- ~Vinod