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: dma: tegra: add accurate reporting of dma state From: Dmitry Osipenko Message-Id: Date: Wed, 24 Apr 2019 21:17:00 +0300 To: Ben Dooks , linux-kernel@lists.codethink.co.uk Cc: Laxman Dewangan , Jon Hunter , Vinod Koul , Dan Williams , Thierry Reding , dmaengine@vger.kernel.org, linux-tegra@vger.kernel.org, linux-kernel@vger.kernel.org List-ID: MjQuMDQuMjAxOSAxOToyMywgQmVuIERvb2tzINC/0LjRiNC10YI6Cj4gVGhlIHR4X3N0YXR1cyBj YWxsYmFjayBkb2VzIG5vdCByZXBvcnQgdGhlIHN0YXRlIG9mIHRoZSB0cmFuc2Zlcgo+IGJleW9u ZCBjb21wbGV0ZSBzZWdtZW50cy4gVGhpcyBjYXVzZXMgcHJvYmxlbXMgd2l0aCB1c2VycyBzdWNo IGFzCj4gQUxTQSB3aGVuIGFwcGxpY2F0aW9ucyB3YW50IHRvIGtub3cgYWNjdXJhdGVseSBob3cg bXVjaCBkYXRhIGhhcwo+IGJlZW4gbW92ZWQuCj4gCj4gVGhpcyBwYXRjaCBhZGRlcyBhIGZ1bmN0 aW9uIHRlZ3JhX2RtYV91cGRhdGVfcmVzaWR1YWwoKSB0byBxdWVyeQo+IHRoZSBoYXJkd2FyZSBh bmQgbW9kaWZ5IHRoZSByZXNpZHVhbCBpbmZvcm1hdGlvbiBhY2NvcmRpbmx5LiBJdAo+IHRha2Vz IGludG8gYWNjb3VudCBhbnkgaGFyZHdhcmUgaXNzdWVzIHdoZW4gdHJ5aW5nIHRvIHJlYWQgdGhl Cj4gc3RhdGUsIHN1Y2ggYXMgZGVsYXlzIGJldHdlZW4gZmluaXNoaW5nIGEgYnVmZmVyIGFuZCBz aWduYWxsaW5nCj4gdGhlIGludGVycnVwdC4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBCZW4gRG9va3Mg PGJlbi5kb29rc0Bjb2RldGhpbmsuY28udWs+CgpIZWxsbyBCZW4sCgpUaGFuayB5b3UgdmVyeSBt dWNoIGZvciBrZWVwaW5nIGl0IHVwLiBJIGhhdmUgY291cGxlIGNvbW1lbnRzLCBwbGVhc2Ugc2Vl IHRoZW0gYmVsb3cuCgo+IENjOiBEbWl0cnkgT3NpcGVua28gPGRpZ2V0eEBnbWFpbC5jb20+Cj4g Q2M6IExheG1hbiBEZXdhbmdhbiA8bGRld2FuZ2FuQG52aWRpYS5jb20+IChzdXBwb3J0ZXI6VEVH UkEgRE1BIERSSVZFUlMpCj4gQ2M6IEpvbiBIdW50ZXIgPGpvbmF0aGFuaEBudmlkaWEuY29tPiAo c3VwcG9ydGVyOlRFR1JBIERNQSBEUklWRVJTKQo+IENjOiBWaW5vZCBLb3VsIDx2a291bEBrZXJu ZWwub3JnPiAobWFpbnRhaW5lcjpETUEgR0VORVJJQyBPRkZMT0FEIEVOR0lORSBTVUJTWVNURU0p Cj4gQ2M6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPiAocmV2aWV3ZXI6 QVNZTkNIUk9OT1VTIFRSQU5TRkVSUy9UUkFOU0ZPUk1TIChJT0FUKSBBUEkpCj4gQ2M6IFRoaWVy cnkgUmVkaW5nIDx0aGllcnJ5LnJlZGluZ0BnbWFpbC5jb20+IChzdXBwb3J0ZXI6VEVHUkEgQVJD SElURUNUVVJFIFNVUFBPUlQpCj4gQ2M6IGRtYWVuZ2luZUB2Z2VyLmtlcm5lbC5vcmcgKG9wZW4g bGlzdDpETUEgR0VORVJJQyBPRkZMT0FEIEVOR0lORSBTVUJTWVNURU0pCj4gQ2M6IGxpbnV4LXRl Z3JhQHZnZXIua2VybmVsLm9yZyAob3BlbiBsaXN0OlRFR1JBIEFSQ0hJVEVDVFVSRSBTVVBQT1JU KQo+IENjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnIChvcGVuIGxpc3QpCj4gLS0tCj4g IGRyaXZlcnMvZG1hL3RlZ3JhMjAtYXBiLWRtYS5jIHwgOTIgKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKystLS0KPiAgMSBmaWxlIGNoYW5nZWQsIDg2IGluc2VydGlvbnMoKyksIDYgZGVs ZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hL3RlZ3JhMjAtYXBiLWRtYS5j IGIvZHJpdmVycy9kbWEvdGVncmEyMC1hcGItZG1hLmMKPiBpbmRleCBjZjQ2MmIxYWJjMGIuLjU0 NGU3MjczZTc0MSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2RtYS90ZWdyYTIwLWFwYi1kbWEuYwo+ ICsrKyBiL2RyaXZlcnMvZG1hL3RlZ3JhMjAtYXBiLWRtYS5jCj4gQEAgLTgwOCw2ICs4MDgsOTAg QEAgc3RhdGljIGludCB0ZWdyYV9kbWFfdGVybWluYXRlX2FsbChzdHJ1Y3QgZG1hX2NoYW4gKmRj KQo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gK3N0YXRpYyB1bnNpZ25lZCBpbnQgdGVncmFfZG1h X3VwZGF0ZV9yZXNpZHVhbChzdHJ1Y3QgdGVncmFfZG1hX2NoYW5uZWwgKnRkYywKPiArCQkJCQkg ICAgICBzdHJ1Y3QgdGVncmFfZG1hX3NnX3JlcSAqc2dfcmVxLAo+ICsJCQkJCSAgICAgIHN0cnVj dCB0ZWdyYV9kbWFfZGVzYyAqZG1hX2Rlc2MsCj4gKwkJCQkJICAgICAgdW5zaWduZWQgaW50IHJl c2lkdWFsKQo+ICt7Cj4gKwl1bnNpZ25lZCBsb25nIHN0YXR1cyA9IDB4MDsKPiArCXVuc2lnbmVk IGxvbmcgd2NvdW50Owo+ICsJdW5zaWduZWQgbG9uZyBhaGJwdHI7Cj4gKwl1bnNpZ25lZCBsb25n IHRtcCA9IDB4MDsKPiArCXVuc2lnbmVkIGludCByZXN1bHQ7CgpZb3UgY291bGQgcHJlLWFzc2ln biBhaGJwdHI9MHhmZmZmZmZmZiBhbmQgcmVzdWx0PXJlc2lkdWFsIGhlcmUsIHRoZW4geW91IGNv dWxkIHJlbW92ZSBhbGwgdGhlIGR1cGxpY2F0ZWQgYXNzaWducyBiZWxvdy4gCgo+ICsJaW50IHJl dHJpZXMgPSBURUdSQV9BUEJETUFfQlVSU1RfQ09NUExFVEVfVElNRSAqIDEwOwo+ICsJaW50IGRv bmU7Cj4gKwo+ICsJLyogaWYgd2UncmUgbm90IHRoZSBjdXJyZW50IHJlcXVlc3QsIHRoZW4gZG9u J3QgYWx0ZXIgdGhlIHJlc2lkdWFsICovCj4gKwlpZiAoc2dfcmVxICE9IGxpc3RfZmlyc3RfZW50 cnkoJnRkYy0+cGVuZGluZ19zZ19yZXEsCj4gKwkJCQkgICAgICAgc3RydWN0IHRlZ3JhX2RtYV9z Z19yZXEsIG5vZGUpKSB7Cj4gKwkJcmVzdWx0ID0gcmVzaWR1YWw7Cj4gKwkJYWhicHRyID0gMHhm ZmZmZmZmZjsKPiArCQlnb3RvIGRvbmU7Cj4gKwl9Cj4gKwo+ICsJLyogbG9vcCB1bnRpbCB3ZSBo YXZlIGEgcmVsaWFibGUgcmVzdWx0IGZvciByZXNpZHVhbCAqLwo+ICsJZG8gewo+ICsJCWFoYnB0 ciA9IHRkY19yZWFkKHRkYywgVEVHUkFfQVBCRE1BX0NIQU5fQUhCUFRSKTsKPiArCQlzdGF0dXMg PSB0ZGNfcmVhZCh0ZGMsIFRFR1JBX0FQQkRNQV9DSEFOX1NUQVRVUyk7Cj4gKwkJdG1wID0gIHRk Y19yZWFkKHRkYywgMHgwOCk7CS8qIHRvdGFsIGNvdW50IGZvciBkZWJ1ZyAqLwoKVGhlICJ0bXAi IHZhcmlhYmxlIGlzbid0IHVzZWQgYW55d2hlcmUgaW4gdGhlIGNvZGUsIHBsZWFzZSByZW1vdmUg aXQuCgo+ICsKPiArCQkvKiBjaGVjayBzdGF0dXMsIGlmIGNoYW5uZWwgaXNuJ3QgYnVzeSB0aGVu IHNraXAgKi8KPiArCQlpZiAoIShzdGF0dXMgJiBURUdSQV9BUEJETUFfU1RBVFVTX0JVU1kpKSB7 Cj4gKwkJCXJlc3VsdCA9IHJlc2lkdWFsOwo+ICsJCQlicmVhazsKPiArCQl9CgpUaGlzIGRvZXNu J3QgbG9vayBjb3JyZWN0IGJlY2F1c2UgVFJNIHNheXMgIkJ1c3kgYml0IGdldHMgc2V0IGFzIHNv b24gYXMgYSBjaGFubmVsIGlzIGVuYWJsZWQgYW5kIGdldHMgY2xlYXJlZCBhZnRlciB0cmFuc2Zl ciBjb21wbGV0ZXMiLCBoZW5jZSBhIGNsZWFyZWQgQlVTWSBiaXQgbWVhbnMgdGhhdCBhbGwgdHJh bnNmZXJzIGFyZSBjb21wbGV0ZWQgYW5kIHJlc3VsdD1yZXNpZHVhbCBpcyBpbmNvcnJlY3QgaGVy ZS4gR2l2ZW4gdGhhdCB0aGVyZSBpcyBhIGNoZWNrIGZvciBFT0MgYml0IGJlaW5nIHNldCBiZWxv dywgdGhpcyBodW5rIHNob3VsZCBiZSByZW1vdmVkLgoKPiArCj4gKwkJLyogaWYgd2UndmUgZ290 IGFuIGludGVycnVwdCBwZW5kaW5nIG9uIHRoZSBjaGFubmVsLCBkb24ndAo+ICsJCSAqIHRyeSBh bmQgZGVhbCB3aXRoIHRoZSByZXNpZHVlIGFzIHRoZSBoYXJkd2FyZSBoYXMgbGlrZWx5Cj4gKwkJ ICogbW92ZWQgb24gdG8gdGhlIG5leHQgYnVmZmVyLiByZXR1cm4gYWxsIGRhdGEgbW92ZWQuCj4g KwkJICovCj4gKwkJaWYgKHN0YXR1cyAmIFRFR1JBX0FQQkRNQV9TVEFUVVNfSVNFX0VPQykgewo+ ICsJCQlyZXN1bHQgPSByZXNpZHVhbCAtIHNnX3JlcS0+cmVxX2xlbjsKPiArCQkJYnJlYWs7Cj4g KwkJfQo+ICsKPiArCQlpZiAodGRjLT50ZG1hLT5jaGlwX2RhdGEtPnN1cHBvcnRfc2VwYXJhdGVf d2NvdW50X3JlZykKPiArCQkJd2NvdW50ID0gdGRjX3JlYWQodGRjLCBURUdSQV9BUEJETUFfQ0hB Tl9XT1JEX1RSQU5TRkVSKTsKPiArCQllbHNlCj4gKwkJCXdjb3VudCA9IHN0YXR1czsKPiArCj4g KwkJLyogSWYgdGhlIHJlcXVlc3QgaXMgYXQgdGhlIGZ1bGwgcG9pbnQsIHRoZW4gdGhlcmUgaXMg YQo+ICsJCSAqIGNoYW5jZSB0aGF0IHdlIGhhdmUgcmVhZCB0aGUgc3RhdHVzIHJlZ2lzdGVyIGlu IHRoZQo+ICsJCSAqIG1pZGRsZSBvZiB0aGUgaGFyZHdhcmUgcmVsb2FkaW5nIHRoZSBuZXh0IGJ1 ZmZlci4KPiArCQkgKgo+ICsJCSAqIFRoZSBzZXF1ZW5jZSBzZWVtcyB0byBiZSBhdCB0aGUgZW5k IG9mIHRoZSBidWZmZXIsIHRvCj4gKwkJICogbG9hZCB0aGUgbmV3IHdvcmQgY291bnQgYmVmb3Jl IHJhaXNpbmcgdGhlIEVPQyBmbGFnIChvcgo+ICsJCSAqIGNoYW5naW5nIHRoZSBwaW5nLXBvbmcg ZmxhZyB3aGljaCBjb3VsZCBoYXZlIGFsc28gYmVlbgo+ICsJCSAqIHVzZWQgdG8gZGV0ZXJtaW5l IGEgbmV3IGJ1ZmZlcikuIFRoaXMgIG1lYW5zIHRoZXJlIGlzIGEKPiArCQkgKiBzbWFsbCB3aW5k b3cgd2hlcmUgd2UgY2Fubm90IGRldGVybWluZSB6ZXJvLWRvbmUgZm9yIHRoZQo+ICsJCSAqIGN1 cnJlbnQgYnVmZmVyLCBvciBtb3ZlZCB0byBuZXh0IGJ1ZmZlci4KPiArCQkgKgo+ICsJCSAqIElm IGRvbmUgc2hvd3MgMCwgdGhlbiByZXRyeSB0aGUgbG9hZCwgYXMgaXQgbWF5IGhpdCB0aGUKPiAr CQkgKiBhYm92ZSBoYXJkd2FyZSByYWNlLiBXZSB3aWxsIGVpdGhlciBnZXQgYSBuZXcgdmFsdWUg d2hpY2gKPiArCQkgKiBpcyBmcm9tIHRoZSBmaXJzdCBidWZmZXIsIG9yIHdlIGdldCBhbiBFT0Mg KG5ldyBidWZmZXIpCj4gKwkJICogb3IgYm90aCBhIG5ldyB2YWx1ZSBhbmQgYW4gRU9DLi4uCj4g KwkJICovCj4gKwkJZG9uZSA9IGdldF9jdXJyZW50X3hmZXJyZWRfY291bnQodGRjLCBzZ19yZXEs IHdjb3VudCk7Cj4gKwkJaWYgKGRvbmUgIT0gMCkgewo+ICsJCQlyZXN1bHQgPSByZXNpZHVhbCAt IGRvbmU7Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCj4gKwkJbmRlbGF5KDEwMCk7CgpQbGVhc2Ug dXNlIHVkZWxheSgxKSBiZWNhdXNlIHRoZXJlIGlzIG5vIG5kZWxheSBvbiBhcm0zMiBhbmQgbmRl bGF5KDEwMCkgaXMgZ2V0dGluZyByb3VuZGVkIHVwIHRvIDF1c2VjLiBBRkFJSywgYXJtNjQgZG9l c24ndCBoYXZlIHJlbGlhYmxlIG5kZWxheSBvbiBUZWdyYSBlaXRoZXIgYmVjYXVzZSB0aW1lciBy YXRlIGNoYW5nZXMgd2l0aCB0aGUgQ1BVIGZyZXF1ZW5jeSBzY2FsaW5nLgoKU2Vjb25kbHkgZG9u ZT0wIGlzbid0IGEgZXJyb3IgY2FzZSwgdGVjaG5pY2FsbHkgdGhpcyBjb3VsZCBiZSB0aGUgY2Fz ZSB3aGVuIHRlZ3JhX2RtYV91cGRhdGVfcmVzaWR1YWwoKSBpcyBpbnZva2VkIGp1c3QgYWZ0ZXIg c3RhcnRpbmcgdGhlIHRyYW5zZmVyLiBIZW5jZSBJIHRoaW5rIHRoaXMgZG8td2hpbGUgbG9vcCBh bmQgdGltZW91dCBjaGVja2luZyBhcmVuJ3QgbmVlZGVkIGF0IGFsbCBzaW5jZSBkb25lPTAgaXMg YSBwZXJmZWN0bHkgdmFsaWQgY2FzZS4KCgpBbHRvZ2V0aGVyIHNlZW1zIHRoZSB0ZWdyYV9kbWFf dXBkYXRlX3Jlc2lkdWFsKCkgY291bGQgYmUgcmVkdWNlZCB0bzoKCnN0YXRpYyB1bnNpZ25lZCBp bnQgdGVncmFfZG1hX3VwZGF0ZV9yZXNpZHVhbChzdHJ1Y3QgdGVncmFfZG1hX2NoYW5uZWwgKnRk YywKCQkJCQkgICAgICBzdHJ1Y3QgdGVncmFfZG1hX3NnX3JlcSAqc2dfcmVxLAoJCQkJCSAgICAg IHN0cnVjdCB0ZWdyYV9kbWFfZGVzYyAqZG1hX2Rlc2MsCgkJCQkJICAgICAgdW5zaWduZWQgaW50 IHJlc2lkdWFsKQp7Cgl1bnNpZ25lZCBsb25nIHN0YXR1cywgd2NvdW50OwoKCWlmIChsaXN0X2lz X2ZpcnN0KCZzZ19yZXEtPm5vZGUsICZ0ZGMtPnBlbmRpbmdfc2dfcmVxKSkKCQlyZXR1cm4gcmVz aWR1YWw7CgoJaWYgKHRkYy0+dGRtYS0+Y2hpcF9kYXRhLT5zdXBwb3J0X3NlcGFyYXRlX3djb3Vu dF9yZWcpCgkJd2NvdW50ID0gdGRjX3JlYWQodGRjLCBURUdSQV9BUEJETUFfQ0hBTl9XT1JEX1RS QU5TRkVSKTsKCglzdGF0dXMgPSB0ZGNfcmVhZCh0ZGMsIFRFR1JBX0FQQkRNQV9DSEFOX1NUQVRV Uyk7CgoJaWYgKCF0ZGMtPnRkbWEtPmNoaXBfZGF0YS0+c3VwcG9ydF9zZXBhcmF0ZV93Y291bnRf cmVnKQoJCXdjb3VudCA9IHN0YXR1czsKCglpZiAoc3RhdHVzICYgVEVHUkFfQVBCRE1BX1NUQVRV U19JU0VfRU9DKQoJCXJldHVybiByZXNpZHVhbCAtIHNnX3JlcS0+cmVxX2xlbjsKCglyZXR1cm4g cmVzaWR1YWwgLSBnZXRfY3VycmVudF94ZmVycmVkX2NvdW50KHRkYywgc2dfcmVxLCB3Y291bnQp Owp9Cg== 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=-7.0 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED autolearn=unavailable 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 00224C282CE for ; Wed, 24 Apr 2019 18:17:08 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id BB39620685 for ; Wed, 24 Apr 2019 18:17:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="BE+yW2Uq" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732944AbfDXSRH (ORCPT ); Wed, 24 Apr 2019 14:17:07 -0400 Received: from mail-lf1-f68.google.com ([209.85.167.68]:35204 "EHLO mail-lf1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1733291AbfDXSRH (ORCPT ); Wed, 24 Apr 2019 14:17:07 -0400 Received: by mail-lf1-f68.google.com with SMTP id j20so15436023lfh.2; Wed, 24 Apr 2019 11:17:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-language:content-transfer-encoding; bh=+46/j9F0qG1EfAvVkzpyw25CvXDI0RPU57Cx8qx0Lcw=; b=BE+yW2Uq+jRwaBv3G5cPbU/l99JG3fEujNT40SBmMMP5uykXJbH9puq9a5rvGbpcw/ IGq+GKqiOsrPjopH1CakU+W/X16F1zNdM9xR0qduv3oW3yfZ+5hxlIg4YkpSFHE5Y3M0 ymw/HfNZ5Hz9cRYaZ1rT0X5xtQScc+ul4enu37bSdz6b2nwMiGdgPRnQgaiAoGskLcOb d48O3ToiQ2jnqWNhvnIFaR6hQsvBd8aPsR/vP5kB1cZ9VU5S3MewEx5Tvk6vNQOPChLm +8tFPzjiFxW4HdGO542e3ERNAq106dmd4xVQJzaVs51/GI7D4bs7oHS6EIjSopSuaC/a gtUg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-language :content-transfer-encoding; bh=+46/j9F0qG1EfAvVkzpyw25CvXDI0RPU57Cx8qx0Lcw=; b=lbqRpdDsNymZ9kF1U+TqlT21caoOFRfjBQdnhayr9DcHyYuJpHUoC4oTh9d9TVULgP zyHEku5nJZzzTsRe+yRTy6o2b543Z58w/rjeUzvITYcP1TkPGBVLToVelEsI1Tx05BVf snmUUdc5SEijH9WPC5BWCVnnxNMFIX2aBhN3IZzP4ggz2Cdomdv/MZ/jhR2J7uTTNwEz CQWHh/Ky0BHb4W3eIvsrAvLQBsWDcnAPQa8BJbDC9QPI6Z6+HNEoQHBwrFfsG46CyB7m UoSwNA7Bu/qPXIyXoFuiuehpdbPaijbxteg5WcdLl3u1ZPNpE2dLwTVBJFYQg6nkYP// RM2Q== X-Gm-Message-State: APjAAAWhcrqLxHxvJ9cjy3WN0YhL+MZX/QDpfOSyWsd/IVO6OXu0rqjK QbvqsL08BKenza3wVIIX23OALQCD X-Google-Smtp-Source: APXvYqyTOUtp1X8dASjMJQ8HTG5pNzcpcSG6D3alBVBmxnJxd1v6LnS4CiAJvHEhtUxIgXaGJIrUFQ== X-Received: by 2002:a19:760f:: with SMTP id c15mr17726030lff.105.1556129822872; Wed, 24 Apr 2019 11:17:02 -0700 (PDT) Received: from [192.168.2.145] (ppp94-29-35-107.pppoe.spdop.ru. [94.29.35.107]) by smtp.googlemail.com with ESMTPSA id k10sm4107830ljh.86.2019.04.24.11.17.01 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 24 Apr 2019 11:17:01 -0700 (PDT) Subject: Re: [PATCH] dma: tegra: add accurate reporting of dma state To: Ben Dooks , linux-kernel@lists.codethink.co.uk Cc: Laxman Dewangan , Jon Hunter , Vinod Koul , Dan Williams , Thierry Reding , dmaengine@vger.kernel.org, linux-tegra@vger.kernel.org, linux-kernel@vger.kernel.org References: <20190424162348.23692-1-ben.dooks@codethink.co.uk> From: Dmitry Osipenko Message-ID: Date: Wed, 24 Apr 2019 21:17:00 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.6.1 MIME-Version: 1.0 In-Reply-To: <20190424162348.23692-1-ben.dooks@codethink.co.uk> Content-Type: text/plain; charset="UTF-8" Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: dmaengine-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: dmaengine@vger.kernel.org Message-ID: <20190424181700.b-xFTJKChPJFn8Ub-nZv5G4v-7mt6AmXVqq9IxvInUI@z> 24.04.2019 19:23, Ben Dooks пишет: > The tx_status callback does not report the state of the transfer > beyond complete segments. This causes problems with users such as > ALSA when applications want to know accurately how much data has > been moved. > > This patch addes a function tegra_dma_update_residual() to query > the hardware and modify the residual information accordinly. It > takes into account any hardware issues when trying to read the > state, such as delays between finishing a buffer and signalling > the interrupt. > > Signed-off-by: Ben Dooks Hello Ben, Thank you very much for keeping it up. I have couple comments, please see them below. > Cc: Dmitry Osipenko > Cc: Laxman Dewangan (supporter:TEGRA DMA DRIVERS) > Cc: Jon Hunter (supporter:TEGRA DMA DRIVERS) > Cc: Vinod Koul (maintainer:DMA GENERIC OFFLOAD ENGINE SUBSYSTEM) > Cc: Dan Williams (reviewer:ASYNCHRONOUS TRANSFERS/TRANSFORMS (IOAT) API) > Cc: Thierry Reding (supporter:TEGRA ARCHITECTURE SUPPORT) > Cc: dmaengine@vger.kernel.org (open list:DMA GENERIC OFFLOAD ENGINE SUBSYSTEM) > Cc: linux-tegra@vger.kernel.org (open list:TEGRA ARCHITECTURE SUPPORT) > Cc: linux-kernel@vger.kernel.org (open list) > --- > drivers/dma/tegra20-apb-dma.c | 92 ++++++++++++++++++++++++++++++++--- > 1 file changed, 86 insertions(+), 6 deletions(-) > > diff --git a/drivers/dma/tegra20-apb-dma.c b/drivers/dma/tegra20-apb-dma.c > index cf462b1abc0b..544e7273e741 100644 > --- a/drivers/dma/tegra20-apb-dma.c > +++ b/drivers/dma/tegra20-apb-dma.c > @@ -808,6 +808,90 @@ static int tegra_dma_terminate_all(struct dma_chan *dc) > return 0; > } > > +static unsigned int tegra_dma_update_residual(struct tegra_dma_channel *tdc, > + struct tegra_dma_sg_req *sg_req, > + struct tegra_dma_desc *dma_desc, > + unsigned int residual) > +{ > + unsigned long status = 0x0; > + unsigned long wcount; > + unsigned long ahbptr; > + unsigned long tmp = 0x0; > + unsigned int result; You could pre-assign ahbptr=0xffffffff and result=residual here, then you could remove all the duplicated assigns below. > + int retries = TEGRA_APBDMA_BURST_COMPLETE_TIME * 10; > + int done; > + > + /* if we're not the current request, then don't alter the residual */ > + if (sg_req != list_first_entry(&tdc->pending_sg_req, > + struct tegra_dma_sg_req, node)) { > + result = residual; > + ahbptr = 0xffffffff; > + goto done; > + } > + > + /* loop until we have a reliable result for residual */ > + do { > + ahbptr = tdc_read(tdc, TEGRA_APBDMA_CHAN_AHBPTR); > + status = tdc_read(tdc, TEGRA_APBDMA_CHAN_STATUS); > + tmp = tdc_read(tdc, 0x08); /* total count for debug */ The "tmp" variable isn't used anywhere in the code, please remove it. > + > + /* check status, if channel isn't busy then skip */ > + if (!(status & TEGRA_APBDMA_STATUS_BUSY)) { > + result = residual; > + break; > + } This doesn't look correct because TRM says "Busy bit gets set as soon as a channel is enabled and gets cleared after transfer completes", hence a cleared BUSY bit means that all transfers are completed and result=residual is incorrect here. Given that there is a check for EOC bit being set below, this hunk should be removed. > + > + /* if we've got an interrupt pending on the channel, don't > + * try and deal with the residue as the hardware has likely > + * moved on to the next buffer. return all data moved. > + */ > + if (status & TEGRA_APBDMA_STATUS_ISE_EOC) { > + result = residual - sg_req->req_len; > + break; > + } > + > + if (tdc->tdma->chip_data->support_separate_wcount_reg) > + wcount = tdc_read(tdc, TEGRA_APBDMA_CHAN_WORD_TRANSFER); > + else > + wcount = status; > + > + /* If the request is at the full point, then there is a > + * chance that we have read the status register in the > + * middle of the hardware reloading the next buffer. > + * > + * The sequence seems to be at the end of the buffer, to > + * load the new word count before raising the EOC flag (or > + * changing the ping-pong flag which could have also been > + * used to determine a new buffer). This means there is a > + * small window where we cannot determine zero-done for the > + * current buffer, or moved to next buffer. > + * > + * If done shows 0, then retry the load, as it may hit the > + * above hardware race. We will either get a new value which > + * is from the first buffer, or we get an EOC (new buffer) > + * or both a new value and an EOC... > + */ > + done = get_current_xferred_count(tdc, sg_req, wcount); > + if (done != 0) { > + result = residual - done; > + break; > + } > + > + ndelay(100); Please use udelay(1) because there is no ndelay on arm32 and ndelay(100) is getting rounded up to 1usec. AFAIK, arm64 doesn't have reliable ndelay on Tegra either because timer rate changes with the CPU frequency scaling. Secondly done=0 isn't a error case, technically this could be the case when tegra_dma_update_residual() is invoked just after starting the transfer. Hence I think this do-while loop and timeout checking aren't needed at all since done=0 is a perfectly valid case. Altogether seems the tegra_dma_update_residual() could be reduced to: static unsigned int tegra_dma_update_residual(struct tegra_dma_channel *tdc, struct tegra_dma_sg_req *sg_req, struct tegra_dma_desc *dma_desc, unsigned int residual) { unsigned long status, wcount; if (list_is_first(&sg_req->node, &tdc->pending_sg_req)) return residual; if (tdc->tdma->chip_data->support_separate_wcount_reg) wcount = tdc_read(tdc, TEGRA_APBDMA_CHAN_WORD_TRANSFER); status = tdc_read(tdc, TEGRA_APBDMA_CHAN_STATUS); if (!tdc->tdma->chip_data->support_separate_wcount_reg) wcount = status; if (status & TEGRA_APBDMA_STATUS_ISE_EOC) return residual - sg_req->req_len; return residual - get_current_xferred_count(tdc, sg_req, wcount); }