From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alban Browaeys Subject: Re: [PATCH 1/3] dmaengine: pl330: Set residue in tx_status callback. Date: Wed, 04 Dec 2013 00:56:03 +0100 Message-ID: <1386114963.20933.10.camel@penelope> References: <1378879685-5352-1-git-send-email-padma.v@samsung.com> <1378879685-5352-2-git-send-email-padma.v@samsung.com> <00b401ceafac$e3a88170$aaf98450$@samsung.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: Dylan Reid Cc: kgene.kim@samsung.com, arnd@arndb.de, Padmavathi Venna , Sangbeom Kim , vinod.koul@intel.com, Mark Brown , linux-arm-kernel@lists.infradead.org, padma.kvr@gmail.com, Chanho Park , Olof Johansson , linux-samsung-soc@vger.kernel.org List-Id: linux-samsung-soc@vger.kernel.org CkhpIER5bGFuLAoKTGUgbWFyZGkgMDEgb2N0b2JyZSAyMDEzIMOgIDIxOjMzIC0wNzAwLCBEeWxh biBSZWlkIGEgw6ljcml0IDoKPiBPbiBUaHUsIFNlcCAxMiwgMjAxMyBhdCA0OjQwIEFNLCBDaGFu aG8gUGFyayA8Y2hhbmhvNjEucGFya0BzYW1zdW5nLmNvbT4gd3JvdGU6Cj4gPiBIaSBQYWRtYXZh dGhpLAo+ID4KPiA+PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQo+ID4+IEZyb206IGxpbnV4 LWFybS1rZXJuZWwgW21haWx0bzpsaW51eC1hcm0ta2VybmVsLQo+ID4+IGJvdW5jZXNAbGlzdHMu aW5mcmFkZWFkLm9yZ10gT24gQmVoYWxmIE9mIFBhZG1hdmF0aGkgVmVubmEKPiA+PiBTZW50OiBX ZWRuZXNkYXksIFNlcHRlbWJlciAxMSwgMjAxMyAzOjA4IFBNCj4gPj4gVG86IGxpbnV4LXNhbXN1 bmctc29jQHZnZXIua2VybmVsLm9yZzsgbGludXgtYXJtLQo+ID4+IGtlcm5lbEBsaXN0cy5pbmZy YWRlYWQub3JnOyBwYWRtYS52QHNhbXN1bmcuY29tOyBwYWRtYS5rdnJAZ21haWwuY29tCj4gPj4g Q2M6IGtnZW5lLmtpbUBzYW1zdW5nLmNvbTsgYXJuZEBhcm5kYi5kZTsgc2JraW03M0BzYW1zdW5n LmNvbTsKPiA+PiB2aW5vZC5rb3VsQGludGVsLmNvbTsgYnJvb25pZUBrZXJuZWwub3JnOyBkZ3Jl aWRAY2hyb21pdW0ub3JnOwo+ID4+IG9sb2ZqQGNocm9taXVtLm9yZwo+ID4+IFN1YmplY3Q6IFtQ QVRDSCAxLzNdIGRtYWVuZ2luZTogcGwzMzA6IFNldCByZXNpZHVlIGluIHR4X3N0YXR1cyBjYWxs YmFjay4KPiA+Pgo+ID4+IEZyb206IER5bGFuIFJlaWQgPGRncmVpZEBjaHJvbWl1bS5vcmc+Cj4g Pj4KPiA+PiBGaWxsIHR4c3RhdGUucmVzaWR1ZSB3aXRoIHRoZSBhbW91bnQgb2YgYnl0ZXMgcmVt YWluaW5nIGluIHRoZSBjdXJyZW50Cj4gPj4gdHJhbnNmZXIgaWYgdGhlIHRyYW5zZmVyIGlzIG5v dCBjb21wbGV0ZS4gIFRoaXMgd2lsbCBiZSBvZiBwYXJ0aWN1bGFyIHVzZQo+ID4+IHRvIGkycyBE TUEgdHJhbnNmZXJzLCBwcm92aWRpbmcgbW9yZSBhY2N1cmF0ZSBod19wdHIgdmFsdWVzIHRvIEFT b0MuCj4gPj4KPiA+PiBTaWduZWQtb2ZmLWJ5OiBEeWxhbiBSZWlkIDxkZ3JlaWRAY2hyb21pdW0u b3JnPgo+ID4+IFJldmlld2VkLWJ5OiBPbG9mIEpvaGFuc3NvbiA8b2xvZmpAY2hyb21pdW0ub3Jn Pgo+ID4+IFNpZ25lZC1vZmYtYnk6IFBhZG1hdmF0aGkgVmVubmEgPHBhZG1hLnZAc2Ftc3VuZy5j b20+Cj4gPj4gLS0tCj4gPj4gIGRyaXZlcnMvZG1hL3BsMzMwLmMgfCAgIDU1Cj4gPj4gKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCj4gPj4gIDEgZmls ZXMgY2hhbmdlZCwgNTQgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbnMoLSkKPiA+Pgo+ID4+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2RtYS9wbDMzMC5jIGIvZHJpdmVycy9kbWEvcGwzMzAuYyBpbmRl eAo+ID4+IDU5MzgyN2IuLjdhYjkxMzYgMTAwNjQ0Cj4gPj4gLS0tIGEvZHJpdmVycy9kbWEvcGwz MzAuYwo+ID4+ICsrKyBiL2RyaXZlcnMvZG1hL3BsMzMwLmMKPiA+PiBAQCAtMjQ3NiwxMSArMjQ3 Niw2NCBAQCBzdGF0aWMgdm9pZCBwbDMzMF9mcmVlX2NoYW5fcmVzb3VyY2VzKHN0cnVjdAo+ID4+ IGRtYV9jaGFuICpjaGFuKQo+ID4+ICAgICAgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBjaC0+ bG9jaywgZmxhZ3MpOyAgfQo+ID4+Cj4gPj4gK3N0YXRpYyBpbmxpbmUgaW50Cj4gPj4gK3BsMzMw X3NyY19hZGRyX2luX2Rlc2Moc3RydWN0IGRtYV9wbDMzMF9kZXNjICpkZXNjLCB1bnNpZ25lZCBp bnQgc2FyKSB7Cj4gPj4gKyAgICAgcmV0dXJuICgoZGVzYy0+cHguc3JjX2FkZHIgPD0gc2FyKSAm Jgo+ID4+ICsgICAgICAgICAgICAgKHNhciA8PSAoZGVzYy0+cHguc3JjX2FkZHIgKyBkZXNjLT5w eC5ieXRlcykpKTsgfQo+ID4+ICsKPiA+PiArc3RhdGljIGlubGluZSBpbnQKPiA+PiArcGwzMzBf ZHN0X2FkZHJfaW5fZGVzYyhzdHJ1Y3QgZG1hX3BsMzMwX2Rlc2MgKmRlc2MsIHVuc2lnbmVkIGlu dCBkYXIpIHsKPiA+PiArICAgICByZXR1cm4gKChkZXNjLT5weC5kc3RfYWRkciA8PSBkYXIpICYm Cj4gPj4gKyAgICAgICAgICAgICAoZGFyIDw9IChkZXNjLT5weC5kc3RfYWRkciArIGRlc2MtPnB4 LmJ5dGVzKSkpOyB9Cj4gPj4gKwo+ID4+ICtzdGF0aWMgdW5zaWduZWQgaW50IHBsMzMwX3R4X3Jl c2lkdWUoc3RydWN0IGRtYV9jaGFuICpjaGFuKSB7Cj4gPj4gKyAgICAgc3RydWN0IGRtYV9wbDMz MF9jaGFuICpwY2ggPSB0b19wY2hhbihjaGFuKTsKPiA+PiArICAgICB2b2lkIF9faW9tZW0gKnJl Z3MgPSBwY2gtPmRtYWMtPnBpZi5iYXNlOwo+ID4+ICsgICAgIHN0cnVjdCBwbDMzMF90aHJlYWQg KnRocmQgPSBwY2gtPnBsMzMwX2NoaWQ7Cj4gPj4gKyAgICAgc3RydWN0IGRtYV9wbDMzMF9kZXNj ICpkZXNjOwo+ID4+ICsgICAgIHVuc2lnbmVkIGludCBzYXIsIGRhcjsKPiA+PiArICAgICB1bnNp Z25lZCBpbnQgcmVzaWR1ZSA9IDA7Cj4gPj4gKyAgICAgdW5zaWduZWQgbG9uZyBmbGFnczsKPiA+ PiArCj4gPj4gKyAgICAgc2FyID0gcmVhZGwocmVncyArIFNBKHRocmQtPmlkKSk7Cj4gPj4gKyAg ICAgZGFyID0gcmVhZGwocmVncyArIERBKHRocmQtPmlkKSk7Cj4gPj4gKwo+ID4+ICsgICAgIHNw aW5fbG9ja19pcnFzYXZlKCZwY2gtPmxvY2ssIGZsYWdzKTsKPiA+PiArCj4gPj4gKyAgICAgLyog RmluZCB0aGUgZGVzYyByZWxhdGVkIHRvIHRoZSBjdXJyZW50IGJ1ZmZlci4gKi8KPiA+PiArICAg ICBsaXN0X2Zvcl9lYWNoX2VudHJ5KGRlc2MsICZwY2gtPndvcmtfbGlzdCwgbm9kZSkgewo+ID4+ ICsgICAgICAgICAgICAgaWYgKGRlc2MtPnJxY2ZnLnNyY19pbmMgJiYgcGwzMzBfc3JjX2FkZHJf aW5fZGVzYyhkZXNjLAo+ID4+IHNhcikpIHsKPiA+PiArICAgICAgICAgICAgICAgICAgICAgcmVz aWR1ZSA9IGRlc2MtPnB4LmJ5dGVzIC0gKHNhciAtCj4gPiBkZXNjLT5weC5zcmNfYWRkcik7Cj4g Pj4gKyAgICAgICAgICAgICAgICAgICAgIGdvdG8gZm91bmRfdW5sb2NrOwo+ID4+ICsgICAgICAg ICAgICAgfQo+ID4+ICsgICAgICAgICAgICAgaWYgKGRlc2MtPnJxY2ZnLmRzdF9pbmMgJiYgcGwz MzBfZHN0X2FkZHJfaW5fZGVzYyhkZXNjLAo+ID4+IGRhcikpIHsKPiA+PiArICAgICAgICAgICAg ICAgICAgICAgcmVzaWR1ZSA9IGRlc2MtPnB4LmJ5dGVzIC0gKGRhciAtCj4gPiBkZXNjLT5weC5k c3RfYWRkcik7Cj4gPj4gKyAgICAgICAgICAgICAgICAgICAgIGdvdG8gZm91bmRfdW5sb2NrOwo+ ID4+ICsgICAgICAgICAgICAgfQo+ID4+ICsgICAgIH0KPiA+PiArCj4gPj4gK2ZvdW5kX3VubG9j azoKPiA+PiArICAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwY2gtPmxvY2ssIGZsYWdzKTsK PiA+PiArCj4gPj4gKyAgICAgcmV0dXJuIHJlc2lkdWU7Cj4gPj4gK30KPiA+PiArCj4gPj4gIHN0 YXRpYyBlbnVtIGRtYV9zdGF0dXMKPiA+PiAgcGwzMzBfdHhfc3RhdHVzKHN0cnVjdCBkbWFfY2hh biAqY2hhbiwgZG1hX2Nvb2tpZV90IGNvb2tpZSwKPiA+PiAgICAgICAgICAgICAgICBzdHJ1Y3Qg ZG1hX3R4X3N0YXRlICp0eHN0YXRlKQo+ID4+ICB7Cj4gPj4gLSAgICAgcmV0dXJuIGRtYV9jb29r aWVfc3RhdHVzKGNoYW4sIGNvb2tpZSwgdHhzdGF0ZSk7Cj4gPj4gKyAgICAgZW51bSBkbWFfc3Rh dHVzIHJldDsKPiA+PiArCj4gPj4gKyAgICAgcmV0ID0gZG1hX2Nvb2tpZV9zdGF0dXMoY2hhbiwg Y29va2llLCB0eHN0YXRlKTsKPiA+PiArICAgICBpZiAocmV0ICE9IERNQV9TVUNDRVNTKSAvKiBO b3QgY29tcGxldGUsIGNoZWNrIGFtb3VudCBsZWZ0LiAqLwo+ID4+ICsgICAgICAgICAgICAgZG1h X3NldF9yZXNpZHVlKHR4c3RhdGUsIHBsMzMwX3R4X3Jlc2lkdWUoY2hhbikpOwo+ID4+ICsKPiA+ PiArICAgICByZXR1cm4gcmV0Owo+ID4KPiA+IFdoeSBkaWRuJ3QgeW91IHVzZSBhIGNvb2tpZSB2 YWx1ZSB0byB0cmFjayB0aGUgcmVxdWVzdD8KPiA+IFRoZSBjb29raWUgaXMgYXNzaWduZWQgd2hl biBlYWNoIHRyYW5zZmVyIGlzIHN1Ym1pdHRlZC4KPiA+IElmIHlvdSBzYXZlIHRoZSB2YWx1ZSBp biB0aGUgZGVzYywgd2UgY2FuIGZpbmQgdGhlIHJlcXVlc3QgZWFzaWx5Lgo+IAo+IElmIHRoZXJl IGFyZSBzZXZlcmFsIGN5Y2xpYyBkZXNjIGluIHRoZSB3b3JrIGxpc3QsIGlzIHRoZXJlIGEgYmV0 dGVyCj4gd2F5IHRvIGZpbmQgdGhlICJjdXJyZW50IiBvbmU/ICBUaGUgY2hhbiBzdHJ1Y3QgdHJh Y2tzIHRoZSBsYXN0Cj4gY29tcGxldGVkIGFuZCBsYXN0IHN1Ym1pdHRlZCBjb29raWVzLCBidXQg dGhlc2Ugd2lsbCBiZSB0aGUgZmlyc3QgYW5kCj4gbGFzdCByZXNwZWN0aXZlbHkgYXMgbG9uZyBh cyB0aGUgY3ljbGljIHRyYW5zZmVyIGlzIGFjdGl2ZS4gIElzIHRoZXJlCj4gYW4gImFjdGl2ZSIg Y29va2llIHN0b3JlZCBzb21ld2hlcmUgdGhhdCBJIG1pc3NlZD8KPiAKPiBMb29raW5nIGZvciB0 aGUgZmlyc3QgYnVmZmVyIHdpdGggc3RhdHVzID09IEJVU1kgaXMgYW4gaW1wcm92ZW1lbnQKPiBJ J2xsIG1ha2UuICBBbnkgd2F5IHRvIGF2b2lkIGxvb2tpbmcgdGhyb3VnaCB0aGUgbGlzdD8KPiAK PiBUaGFua3MsCj4gCj4gRHlsYW4KPiAKPiA+Cj4gPiBUaGFua3MsCj4gPgo+ID4gQmVzdCAgUmVn YXJkcywKPiA+IENoYW5obyBQYXJrCj4gPgo+IAo+IF9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCj4gbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKPiBs aW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKPiBodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwKPiAKPiAhRFNQQU06NTI0 YmE0NjIxNDM2OTcxNDExMTI1NzQhCj4gCgoKSSBwaGFzZWQgb3V0IGZvbGxvd2luZyBoYWNrIHRv IGdldCBhc29jIHdvcmtpbmcgKHVzaW5nIGEgZHJpdmVyIG5vdCB5ZXQKc3VibWl0dGVkIGJ1dCBk ZXJpdmVkIGZyb20gaGFyZGtlcm5lbCB0cmVlIGRyaXZlciBoa2RrLW1heDk4MDkwKSB3aXRoCmRt YWVuZ2luZSBwY20uIEhpZ2hseSBsaWtlbHkgaXQgd2lsbCBvbmx5IHdvcmsgZm9yIGN5Y2xpYzsg aXQgaXMgYWltZWQgYXQKcmFpc2luZyBhd2FyZW5lc3Mgb2YgdGhlIGN1cnJlbnQgYXNvYyBkbWFl bmdpbmUgKyBwbDMzMCBicmVha2FnZS4gSSBoYWQgdG8KaW5jbHVkZSB0aGUgdHJhbnNmZXIgdXAg dG8gInVzZWQiIHRvIGNvbXB1dGUgdGhlIHJlc2lkdWUgdG8gdGhlIGVuZCBvZgp0aGUgYnVmZmVy IDoKCkZyb20gMTE5OTEyOWU5YTA2N2UzMmY1YWE0ZTliYzYzZjk1Mjc1OTBiNGM5MiBNb24gU2Vw IDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogRHlsYW4gUmVpZCA8ZGdyZWlkQGNocm9taXVtLm9yZz4K RGF0ZTogV2VkLCAxMSBTZXAgMjAxMyAxMTozODowMyArMDUzMApTdWJqZWN0OiBbUEFUQ0hdIGRt YWVuZ2luZTogcGwzMzA6IFNldCByZXNpZHVlIGluIHR4X3N0YXR1cyBjYWxsYmFjay4KCkZpbGwg dHhzdGF0ZS5yZXNpZHVlIHdpdGggdGhlIGFtb3VudCBvZiBieXRlcyByZW1haW5pbmcgaW4gdGhl CnRyYW5zZmVycy4gVGhpcyBpcyByZXF1aXJlZCBieSBhbHNhIGNvcmUgZG1hZW5naW5lIHBjbSBw b2ludGVyLgoKQmFzZWQgb24gcGF0Y2ggZnJvbSBEeWxhbiBSZWlkIDxkZ3JlaWRAY2hyb21pdW0u b3JnPiBidXQgY29tcHV0ZSB0aGUKdGhlIHJlc2lkdWUgaW4gYWxsIHRyYW5zZmVycyBpbnN0ZWFk IG9mIHRoZSBjdXJyZW50IG9uZS4KClNpZ25lZC1vZmYtYnk6IEFsYmFuIEJyb3dhZXlzIDxwcmFo YWxAeWFob28uY29tPgotLS0KIGRyaXZlcnMvZG1hL3BsMzMwLmMgfCA5MQorKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQogMSBmaWxlIGNoYW5nZWQs IDkwIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Rt YS9wbDMzMC5jIGIvZHJpdmVycy9kbWEvcGwzMzAuYwppbmRleCBhZGE3NjUwLi41OGRmOWVjIDEw MDY0NAotLS0gYS9kcml2ZXJzL2RtYS9wbDMzMC5jCisrKyBiL2RyaXZlcnMvZG1hL3BsMzMwLmMK QEAgLTI0NDcsMTEgKzI0NDcsMTAwIEBAIHN0YXRpYyB2b2lkIHBsMzMwX2ZyZWVfY2hhbl9yZXNv dXJjZXMoc3RydWN0CmRtYV9jaGFuICpjaGFuKQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBj aC0+bG9jaywgZmxhZ3MpOwogfQogCitzdGF0aWMgaW5saW5lIGludAorcGwzMzBfc3JjX2FkZHJf aW5fZGVzYyhzdHJ1Y3QgZG1hX3BsMzMwX2Rlc2MgKmRlc2MsIHVuc2lnbmVkIGludCBzYXIpCit7 CisJcmV0dXJuIChkZXNjLT5weC5zcmNfYWRkciA8PSBzYXIpICYmCisJCShzYXIgPD0gKGRlc2Mt PnB4LnNyY19hZGRyICsgZGVzYy0+cHguYnl0ZXMpKTsKK30KKworc3RhdGljIGlubGluZSBpbnQK K3BsMzMwX2RzdF9hZGRyX2luX2Rlc2Moc3RydWN0IGRtYV9wbDMzMF9kZXNjICpkZXNjLCB1bnNp Z25lZCBpbnQgZGFyKQoreworCXJldHVybiAoZGVzYy0+cHguZHN0X2FkZHIgPD0gZGFyKSAmJgor CQkoZGFyIDw9IChkZXNjLT5weC5kc3RfYWRkciArIGRlc2MtPnB4LmJ5dGVzKSk7Cit9CisKKwog c3RhdGljIGVudW0gZG1hX3N0YXR1cwogcGwzMzBfdHhfc3RhdHVzKHN0cnVjdCBkbWFfY2hhbiAq Y2hhbiwgZG1hX2Nvb2tpZV90IGNvb2tpZSwKIAkJIHN0cnVjdCBkbWFfdHhfc3RhdGUgKnR4c3Rh dGUpCiB7Ci0JcmV0dXJuIGRtYV9jb29raWVfc3RhdHVzKGNoYW4sIGNvb2tpZSwgdHhzdGF0ZSk7 CisJc3RydWN0IGRtYV9wbDMzMF9jaGFuICpwY2ggPSB0b19wY2hhbihjaGFuKTsKKwl2b2lkIF9f aW9tZW0gKnJlZ3MgPSBwY2gtPmRtYWMtPnBpZi5iYXNlOworCXN0cnVjdCBwbDMzMF90aHJlYWQg KnRocmQgPSBwY2gtPnBsMzMwX2NoaWQ7CisJc3RydWN0IGRtYV9wbDMzMF9kZXNjICpkZXNjOwor CXVuc2lnbmVkIGludCBzYXIsIGRhcjsKKwl1bnNpZ25lZCBpbnQgcmVzaWR1ZSA9IDA7CisJdW5z aWduZWQgbG9uZyBmbGFnczsKKwlib29sIGZpcnN0ID0gdHJ1ZTsKKwlib29sIHJ1bm5pbmcgPSBm YWxzZTsKKwlkbWFfY29va2llX3QgbGFzdDsKKwlkbWFfY29va2llX3QgdXNlZDsKKwllbnVtIGRt YV9zdGF0dXMgcmV0OworCisJcmV0ID0gZG1hX2Nvb2tpZV9zdGF0dXMoY2hhbiwgY29va2llLCB0 eHN0YXRlKTsKKwlpZiAocmV0ID09IERNQV9DT01QTEVURSkKKwkJcmV0dXJuIHJldDsKKworCS8q CisJICogVGhlcmUncyBubyBwb2ludCBjYWxjdWxhdGluZyB0aGUgcmVzaWR1ZSBpZiB0aGVyZSdz CisJICogbm8gdHhzdGF0ZSB0byBzdG9yZSB0aGUgdmFsdWUuCisJICovCisJaWYgKCF0eHN0YXRl KQorCQlyZXR1cm4gcmV0OworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnBjaC0+bG9jaywgZmxhZ3Mp OworCXJldCA9IGRtYV9jb29raWVfc3RhdHVzKGNoYW4sIGNvb2tpZSwgdHhzdGF0ZSk7CisJbGFz dCA9IHR4c3RhdGUtPmxhc3Q7CisJdXNlZCA9IHR4c3RhdGUtPnVzZWQ7CisJc2FyID0gcmVhZGwo cmVncyArIFNBKHRocmQtPmlkKSk7CisJZGFyID0gcmVhZGwocmVncyArIERBKHRocmQtPmlkKSk7 CisKKwlpZiAocmV0ID09IERNQV9DT01QTEVURSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZwY2gtPmxvY2ssIGZsYWdzKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlsaXN0X2Zvcl9lYWNo X2VudHJ5KGRlc2MsICZwY2gtPndvcmtfbGlzdCwgbm9kZSkgeworCQlpZiAoZGVzYy0+c3RhdHVz ID09IEJVU1kpIHsKKwkJCWlmIChmaXJzdCkgeworCQkJCWZpcnN0ID0gZmFsc2U7CisJCQkJcnVu bmluZyA9IHRydWU7CisJCQl9CisKKwkJCWlmICghcnVubmluZykgeworCQkJCXJlc2lkdWUgKz0g ZGVzYy0+cHguYnl0ZXM7CisJCQkJY29udGludWU7CisJCQl9CisKKwkJCWlmIChkZXNjLT5ycWNm Zy5zcmNfaW5jCisJCQkgICAgJiYgcGwzMzBfc3JjX2FkZHJfaW5fZGVzYyhkZXNjLCBzYXIpKSB7 CisJCQkJcmVzaWR1ZSArPSBkZXNjLT5weC5ieXRlczsKKwkJCQlyZXNpZHVlIC09IHNhciAtIGRl c2MtPnB4LnNyY19hZGRyOworCQkJfSBlbHNlIGlmIChkZXNjLT5ycWNmZy5kc3RfaW5jCisJCQkJ ICAgJiYgcGwzMzBfZHN0X2FkZHJfaW5fZGVzYyhkZXNjLCBkYXIpKSB7CisJCQkJcmVzaWR1ZSAr PSBkZXNjLT5weC5ieXRlczsKKwkJCQlyZXNpZHVlIC09IGRhciAtIGRlc2MtPnB4LmRzdF9hZGRy OworCQkJfSBlbHNlCisJCQkJV0FSTl9PTigxKTsKKworCQkJcnVubmluZyA9IGZhbHNlOworCQl9 IGVsc2UgaWYgKGRlc2MtPnN0YXR1cyA9PSBQUkVQKQorCQkJcmVzaWR1ZSArPSBkZXNjLT5weC5i eXRlczsKKworCQlpZiAoZGVzYy0+dHhkLmNvb2tpZSA9PSB1c2VkKQorCQkJYnJlYWs7CisJfQor CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBjaC0+bG9jaywgZmxhZ3MpOworCisJLyoKKwkgKiBU aGlzIGNvb2tpZSBub3QgY29tcGxldGUgeWV0CisJICogR2V0IG51bWJlciBvZiBieXRlcyBsZWZ0 IGluIHRoZSBhY3RpdmUgdHJhbnNhY3Rpb25zIGFuZCBxdWV1ZQorCSAqLworCWRtYV9zZXRfcmVz aWR1ZSh0eHN0YXRlLCByZXNpZHVlKTsKKworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyB2b2lk IHBsMzMwX2lzc3VlX3BlbmRpbmcoc3RydWN0IGRtYV9jaGFuICpjaGFuKQotLSAKMS44LjUKCgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJt LWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtl cm5lbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: prahal@yahoo.com (Alban Browaeys) Date: Wed, 04 Dec 2013 00:56:03 +0100 Subject: [PATCH 1/3] dmaengine: pl330: Set residue in tx_status callback. In-Reply-To: References: <1378879685-5352-1-git-send-email-padma.v@samsung.com> <1378879685-5352-2-git-send-email-padma.v@samsung.com> <00b401ceafac$e3a88170$aaf98450$@samsung.com> Message-ID: <1386114963.20933.10.camel@penelope> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Hi Dylan, Le mardi 01 octobre 2013 ? 21:33 -0700, Dylan Reid a ?crit : > On Thu, Sep 12, 2013 at 4:40 AM, Chanho Park wrote: > > Hi Padmavathi, > > > >> -----Original Message----- > >> From: linux-arm-kernel [mailto:linux-arm-kernel- > >> bounces at lists.infradead.org] On Behalf Of Padmavathi Venna > >> Sent: Wednesday, September 11, 2013 3:08 PM > >> To: linux-samsung-soc at vger.kernel.org; linux-arm- > >> kernel at lists.infradead.org; padma.v at samsung.com; padma.kvr at gmail.com > >> Cc: kgene.kim at samsung.com; arnd at arndb.de; sbkim73 at samsung.com; > >> vinod.koul at intel.com; broonie at kernel.org; dgreid at chromium.org; > >> olofj at chromium.org > >> Subject: [PATCH 1/3] dmaengine: pl330: Set residue in tx_status callback. > >> > >> From: Dylan Reid > >> > >> Fill txstate.residue with the amount of bytes remaining in the current > >> transfer if the transfer is not complete. This will be of particular use > >> to i2s DMA transfers, providing more accurate hw_ptr values to ASoC. > >> > >> Signed-off-by: Dylan Reid > >> Reviewed-by: Olof Johansson > >> Signed-off-by: Padmavathi Venna > >> --- > >> drivers/dma/pl330.c | 55 > >> ++++++++++++++++++++++++++++++++++++++++++++++++++- > >> 1 files changed, 54 insertions(+), 1 deletions(-) > >> > >> diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c index > >> 593827b..7ab9136 100644 > >> --- a/drivers/dma/pl330.c > >> +++ b/drivers/dma/pl330.c > >> @@ -2476,11 +2476,64 @@ static void pl330_free_chan_resources(struct > >> dma_chan *chan) > >> spin_unlock_irqrestore(&pch->lock, flags); } > >> > >> +static inline int > >> +pl330_src_addr_in_desc(struct dma_pl330_desc *desc, unsigned int sar) { > >> + return ((desc->px.src_addr <= sar) && > >> + (sar <= (desc->px.src_addr + desc->px.bytes))); } > >> + > >> +static inline int > >> +pl330_dst_addr_in_desc(struct dma_pl330_desc *desc, unsigned int dar) { > >> + return ((desc->px.dst_addr <= dar) && > >> + (dar <= (desc->px.dst_addr + desc->px.bytes))); } > >> + > >> +static unsigned int pl330_tx_residue(struct dma_chan *chan) { > >> + struct dma_pl330_chan *pch = to_pchan(chan); > >> + void __iomem *regs = pch->dmac->pif.base; > >> + struct pl330_thread *thrd = pch->pl330_chid; > >> + struct dma_pl330_desc *desc; > >> + unsigned int sar, dar; > >> + unsigned int residue = 0; > >> + unsigned long flags; > >> + > >> + sar = readl(regs + SA(thrd->id)); > >> + dar = readl(regs + DA(thrd->id)); > >> + > >> + spin_lock_irqsave(&pch->lock, flags); > >> + > >> + /* Find the desc related to the current buffer. */ > >> + list_for_each_entry(desc, &pch->work_list, node) { > >> + if (desc->rqcfg.src_inc && pl330_src_addr_in_desc(desc, > >> sar)) { > >> + residue = desc->px.bytes - (sar - > > desc->px.src_addr); > >> + goto found_unlock; > >> + } > >> + if (desc->rqcfg.dst_inc && pl330_dst_addr_in_desc(desc, > >> dar)) { > >> + residue = desc->px.bytes - (dar - > > desc->px.dst_addr); > >> + goto found_unlock; > >> + } > >> + } > >> + > >> +found_unlock: > >> + spin_unlock_irqrestore(&pch->lock, flags); > >> + > >> + return residue; > >> +} > >> + > >> static enum dma_status > >> pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie, > >> struct dma_tx_state *txstate) > >> { > >> - return dma_cookie_status(chan, cookie, txstate); > >> + enum dma_status ret; > >> + > >> + ret = dma_cookie_status(chan, cookie, txstate); > >> + if (ret != DMA_SUCCESS) /* Not complete, check amount left. */ > >> + dma_set_residue(txstate, pl330_tx_residue(chan)); > >> + > >> + return ret; > > > > Why didn't you use a cookie value to track the request? > > The cookie is assigned when each transfer is submitted. > > If you save the value in the desc, we can find the request easily. > > If there are several cyclic desc in the work list, is there a better > way to find the "current" one? The chan struct tracks the last > completed and last submitted cookies, but these will be the first and > last respectively as long as the cyclic transfer is active. Is there > an "active" cookie stored somewhere that I missed? > > Looking for the first buffer with status == BUSY is an improvement > I'll make. Any way to avoid looking through the list? > > Thanks, > > Dylan > > > > > Thanks, > > > > Best Regards, > > Chanho Park > > > > _______________________________________________ > linux-arm-kernel mailing list > linux-arm-kernel at lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > > !DSPAM:524ba462143697141112574! > I phased out following hack to get asoc working (using a driver not yet submitted but derived from hardkernel tree driver hkdk-max98090) with dmaengine pcm. Highly likely it will only work for cyclic; it is aimed at raising awareness of the current asoc dmaengine + pl330 breakage. I had to include the transfer up to "used" to compute the residue to the end of the buffer : >>From 1199129e9a067e32f5aa4e9bc63f9527590b4c92 Mon Sep 17 00:00:00 2001 From: Dylan Reid Date: Wed, 11 Sep 2013 11:38:03 +0530 Subject: [PATCH] dmaengine: pl330: Set residue in tx_status callback. Fill txstate.residue with the amount of bytes remaining in the transfers. This is required by alsa core dmaengine pcm pointer. Based on patch from Dylan Reid but compute the the residue in all transfers instead of the current one. Signed-off-by: Alban Browaeys --- drivers/dma/pl330.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 90 insertions(+), 1 deletion(-) diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c index ada7650..58df9ec 100644 --- a/drivers/dma/pl330.c +++ b/drivers/dma/pl330.c @@ -2447,11 +2447,100 @@ static void pl330_free_chan_resources(struct dma_chan *chan) spin_unlock_irqrestore(&pch->lock, flags); } +static inline int +pl330_src_addr_in_desc(struct dma_pl330_desc *desc, unsigned int sar) +{ + return (desc->px.src_addr <= sar) && + (sar <= (desc->px.src_addr + desc->px.bytes)); +} + +static inline int +pl330_dst_addr_in_desc(struct dma_pl330_desc *desc, unsigned int dar) +{ + return (desc->px.dst_addr <= dar) && + (dar <= (desc->px.dst_addr + desc->px.bytes)); +} + + static enum dma_status pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie, struct dma_tx_state *txstate) { - return dma_cookie_status(chan, cookie, txstate); + struct dma_pl330_chan *pch = to_pchan(chan); + void __iomem *regs = pch->dmac->pif.base; + struct pl330_thread *thrd = pch->pl330_chid; + struct dma_pl330_desc *desc; + unsigned int sar, dar; + unsigned int residue = 0; + unsigned long flags; + bool first = true; + bool running = false; + dma_cookie_t last; + dma_cookie_t used; + enum dma_status ret; + + ret = dma_cookie_status(chan, cookie, txstate); + if (ret == DMA_COMPLETE) + return ret; + + /* + * There's no point calculating the residue if there's + * no txstate to store the value. + */ + if (!txstate) + return ret; + + spin_lock_irqsave(&pch->lock, flags); + ret = dma_cookie_status(chan, cookie, txstate); + last = txstate->last; + used = txstate->used; + sar = readl(regs + SA(thrd->id)); + dar = readl(regs + DA(thrd->id)); + + if (ret == DMA_COMPLETE) { + spin_unlock_irqrestore(&pch->lock, flags); + return ret; + } + + list_for_each_entry(desc, &pch->work_list, node) { + if (desc->status == BUSY) { + if (first) { + first = false; + running = true; + } + + if (!running) { + residue += desc->px.bytes; + continue; + } + + if (desc->rqcfg.src_inc + && pl330_src_addr_in_desc(desc, sar)) { + residue += desc->px.bytes; + residue -= sar - desc->px.src_addr; + } else if (desc->rqcfg.dst_inc + && pl330_dst_addr_in_desc(desc, dar)) { + residue += desc->px.bytes; + residue -= dar - desc->px.dst_addr; + } else + WARN_ON(1); + + running = false; + } else if (desc->status == PREP) + residue += desc->px.bytes; + + if (desc->txd.cookie == used) + break; + } + spin_unlock_irqrestore(&pch->lock, flags); + + /* + * This cookie not complete yet + * Get number of bytes left in the active transactions and queue + */ + dma_set_residue(txstate, residue); + + return ret; } static void pl330_issue_pending(struct dma_chan *chan) -- 1.8.5