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: Ben Dooks Message-Id: <20190424162348.23692-1-ben.dooks@codethink.co.uk> Date: Wed, 24 Apr 2019 17:23:48 +0100 To: linux-kernel@lists.codethink.co.uk Cc: Ben Dooks , Dmitry Osipenko , 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: VGhlIHR4X3N0YXR1cyBjYWxsYmFjayBkb2VzIG5vdCByZXBvcnQgdGhlIHN0YXRlIG9mIHRoZSB0 cmFuc2ZlcgpiZXlvbmQgY29tcGxldGUgc2VnbWVudHMuIFRoaXMgY2F1c2VzIHByb2JsZW1zIHdp dGggdXNlcnMgc3VjaCBhcwpBTFNBIHdoZW4gYXBwbGljYXRpb25zIHdhbnQgdG8ga25vdyBhY2N1 cmF0ZWx5IGhvdyBtdWNoIGRhdGEgaGFzCmJlZW4gbW92ZWQuCgpUaGlzIHBhdGNoIGFkZGVzIGEg ZnVuY3Rpb24gdGVncmFfZG1hX3VwZGF0ZV9yZXNpZHVhbCgpIHRvIHF1ZXJ5CnRoZSBoYXJkd2Fy ZSBhbmQgbW9kaWZ5IHRoZSByZXNpZHVhbCBpbmZvcm1hdGlvbiBhY2NvcmRpbmx5LiBJdAp0YWtl cyBpbnRvIGFjY291bnQgYW55IGhhcmR3YXJlIGlzc3VlcyB3aGVuIHRyeWluZyB0byByZWFkIHRo ZQpzdGF0ZSwgc3VjaCBhcyBkZWxheXMgYmV0d2VlbiBmaW5pc2hpbmcgYSBidWZmZXIgYW5kIHNp Z25hbGxpbmcKdGhlIGludGVycnVwdC4KClNpZ25lZC1vZmYtYnk6IEJlbiBEb29rcyA8YmVuLmRv b2tzQGNvZGV0aGluay5jby51az4KLS0tCkNjOiBEbWl0cnkgT3NpcGVua28gPGRpZ2V0eEBnbWFp bC5jb20+CkNjOiBMYXhtYW4gRGV3YW5nYW4gPGxkZXdhbmdhbkBudmlkaWEuY29tPiAoc3VwcG9y dGVyOlRFR1JBIERNQSBEUklWRVJTKQpDYzogSm9uIEh1bnRlciA8am9uYXRoYW5oQG52aWRpYS5j b20+IChzdXBwb3J0ZXI6VEVHUkEgRE1BIERSSVZFUlMpCkNjOiBWaW5vZCBLb3VsIDx2a291bEBr ZXJuZWwub3JnPiAobWFpbnRhaW5lcjpETUEgR0VORVJJQyBPRkZMT0FEIEVOR0lORSBTVUJTWVNU RU0pCkNjOiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4gKHJldmlld2Vy OkFTWU5DSFJPTk9VUyBUUkFOU0ZFUlMvVFJBTlNGT1JNUyAoSU9BVCkgQVBJKQpDYzogVGhpZXJy eSBSZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNvbT4gKHN1cHBvcnRlcjpURUdSQSBBUkNI SVRFQ1RVUkUgU1VQUE9SVCkKQ2M6IGRtYWVuZ2luZUB2Z2VyLmtlcm5lbC5vcmcgKG9wZW4gbGlz dDpETUEgR0VORVJJQyBPRkZMT0FEIEVOR0lORSBTVUJTWVNURU0pCkNjOiBsaW51eC10ZWdyYUB2 Z2VyLmtlcm5lbC5vcmcgKG9wZW4gbGlzdDpURUdSQSBBUkNISVRFQ1RVUkUgU1VQUE9SVCkKQ2M6 IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcgKG9wZW4gbGlzdCkKLS0tCiBkcml2ZXJzL2Rt YS90ZWdyYTIwLWFwYi1kbWEuYyB8IDkyICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr LS0tCiAxIGZpbGUgY2hhbmdlZCwgODYgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2RtYS90ZWdyYTIwLWFwYi1kbWEuYyBiL2RyaXZlcnMvZG1hL3Rl Z3JhMjAtYXBiLWRtYS5jCmluZGV4IGNmNDYyYjFhYmMwYi4uNTQ0ZTcyNzNlNzQxIDEwMDY0NAot LS0gYS9kcml2ZXJzL2RtYS90ZWdyYTIwLWFwYi1kbWEuYworKysgYi9kcml2ZXJzL2RtYS90ZWdy YTIwLWFwYi1kbWEuYwpAQCAtODA4LDYgKzgwOCw5MCBAQCBzdGF0aWMgaW50IHRlZ3JhX2RtYV90 ZXJtaW5hdGVfYWxsKHN0cnVjdCBkbWFfY2hhbiAqZGMpCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRp YyB1bnNpZ25lZCBpbnQgdGVncmFfZG1hX3VwZGF0ZV9yZXNpZHVhbChzdHJ1Y3QgdGVncmFfZG1h X2NoYW5uZWwgKnRkYywKKwkJCQkJICAgICAgc3RydWN0IHRlZ3JhX2RtYV9zZ19yZXEgKnNnX3Jl cSwKKwkJCQkJICAgICAgc3RydWN0IHRlZ3JhX2RtYV9kZXNjICpkbWFfZGVzYywKKwkJCQkJICAg ICAgdW5zaWduZWQgaW50IHJlc2lkdWFsKQoreworCXVuc2lnbmVkIGxvbmcgc3RhdHVzID0gMHgw OworCXVuc2lnbmVkIGxvbmcgd2NvdW50OworCXVuc2lnbmVkIGxvbmcgYWhicHRyOworCXVuc2ln bmVkIGxvbmcgdG1wID0gMHgwOworCXVuc2lnbmVkIGludCByZXN1bHQ7CisJaW50IHJldHJpZXMg PSBURUdSQV9BUEJETUFfQlVSU1RfQ09NUExFVEVfVElNRSAqIDEwOworCWludCBkb25lOworCisJ LyogaWYgd2UncmUgbm90IHRoZSBjdXJyZW50IHJlcXVlc3QsIHRoZW4gZG9uJ3QgYWx0ZXIgdGhl IHJlc2lkdWFsICovCisJaWYgKHNnX3JlcSAhPSBsaXN0X2ZpcnN0X2VudHJ5KCZ0ZGMtPnBlbmRp bmdfc2dfcmVxLAorCQkJCSAgICAgICBzdHJ1Y3QgdGVncmFfZG1hX3NnX3JlcSwgbm9kZSkpIHsK KwkJcmVzdWx0ID0gcmVzaWR1YWw7CisJCWFoYnB0ciA9IDB4ZmZmZmZmZmY7CisJCWdvdG8gZG9u ZTsKKwl9CisKKwkvKiBsb29wIHVudGlsIHdlIGhhdmUgYSByZWxpYWJsZSByZXN1bHQgZm9yIHJl c2lkdWFsICovCisJZG8geworCQlhaGJwdHIgPSB0ZGNfcmVhZCh0ZGMsIFRFR1JBX0FQQkRNQV9D SEFOX0FIQlBUUik7CisJCXN0YXR1cyA9IHRkY19yZWFkKHRkYywgVEVHUkFfQVBCRE1BX0NIQU5f U1RBVFVTKTsKKwkJdG1wID0gIHRkY19yZWFkKHRkYywgMHgwOCk7CS8qIHRvdGFsIGNvdW50IGZv ciBkZWJ1ZyAqLworCisJCS8qIGNoZWNrIHN0YXR1cywgaWYgY2hhbm5lbCBpc24ndCBidXN5IHRo ZW4gc2tpcCAqLworCQlpZiAoIShzdGF0dXMgJiBURUdSQV9BUEJETUFfU1RBVFVTX0JVU1kpKSB7 CisJCQlyZXN1bHQgPSByZXNpZHVhbDsKKwkJCWJyZWFrOworCQl9CisKKwkJLyogaWYgd2UndmUg Z290IGFuIGludGVycnVwdCBwZW5kaW5nIG9uIHRoZSBjaGFubmVsLCBkb24ndAorCQkgKiB0cnkg YW5kIGRlYWwgd2l0aCB0aGUgcmVzaWR1ZSBhcyB0aGUgaGFyZHdhcmUgaGFzIGxpa2VseQorCQkg KiBtb3ZlZCBvbiB0byB0aGUgbmV4dCBidWZmZXIuIHJldHVybiBhbGwgZGF0YSBtb3ZlZC4KKwkJ ICovCisJCWlmIChzdGF0dXMgJiBURUdSQV9BUEJETUFfU1RBVFVTX0lTRV9FT0MpIHsKKwkJCXJl c3VsdCA9IHJlc2lkdWFsIC0gc2dfcmVxLT5yZXFfbGVuOworCQkJYnJlYWs7CisJCX0KKworCQlp ZiAodGRjLT50ZG1hLT5jaGlwX2RhdGEtPnN1cHBvcnRfc2VwYXJhdGVfd2NvdW50X3JlZykKKwkJ CXdjb3VudCA9IHRkY19yZWFkKHRkYywgVEVHUkFfQVBCRE1BX0NIQU5fV09SRF9UUkFOU0ZFUik7 CisJCWVsc2UKKwkJCXdjb3VudCA9IHN0YXR1czsKKworCQkvKiBJZiB0aGUgcmVxdWVzdCBpcyBh dCB0aGUgZnVsbCBwb2ludCwgdGhlbiB0aGVyZSBpcyBhCisJCSAqIGNoYW5jZSB0aGF0IHdlIGhh dmUgcmVhZCB0aGUgc3RhdHVzIHJlZ2lzdGVyIGluIHRoZQorCQkgKiBtaWRkbGUgb2YgdGhlIGhh cmR3YXJlIHJlbG9hZGluZyB0aGUgbmV4dCBidWZmZXIuCisJCSAqCisJCSAqIFRoZSBzZXF1ZW5j ZSBzZWVtcyB0byBiZSBhdCB0aGUgZW5kIG9mIHRoZSBidWZmZXIsIHRvCisJCSAqIGxvYWQgdGhl IG5ldyB3b3JkIGNvdW50IGJlZm9yZSByYWlzaW5nIHRoZSBFT0MgZmxhZyAob3IKKwkJICogY2hh bmdpbmcgdGhlIHBpbmctcG9uZyBmbGFnIHdoaWNoIGNvdWxkIGhhdmUgYWxzbyBiZWVuCisJCSAq IHVzZWQgdG8gZGV0ZXJtaW5lIGEgbmV3IGJ1ZmZlcikuIFRoaXMgIG1lYW5zIHRoZXJlIGlzIGEK KwkJICogc21hbGwgd2luZG93IHdoZXJlIHdlIGNhbm5vdCBkZXRlcm1pbmUgemVyby1kb25lIGZv ciB0aGUKKwkJICogY3VycmVudCBidWZmZXIsIG9yIG1vdmVkIHRvIG5leHQgYnVmZmVyLgorCQkg KgorCQkgKiBJZiBkb25lIHNob3dzIDAsIHRoZW4gcmV0cnkgdGhlIGxvYWQsIGFzIGl0IG1heSBo aXQgdGhlCisJCSAqIGFib3ZlIGhhcmR3YXJlIHJhY2UuIFdlIHdpbGwgZWl0aGVyIGdldCBhIG5l dyB2YWx1ZSB3aGljaAorCQkgKiBpcyBmcm9tIHRoZSBmaXJzdCBidWZmZXIsIG9yIHdlIGdldCBh biBFT0MgKG5ldyBidWZmZXIpCisJCSAqIG9yIGJvdGggYSBuZXcgdmFsdWUgYW5kIGFuIEVPQy4u LgorCQkgKi8KKwkJZG9uZSA9IGdldF9jdXJyZW50X3hmZXJyZWRfY291bnQodGRjLCBzZ19yZXEs IHdjb3VudCk7CisJCWlmIChkb25lICE9IDApIHsKKwkJCXJlc3VsdCA9IHJlc2lkdWFsIC0gZG9u ZTsKKwkJCWJyZWFrOworCQl9CisKKwkJbmRlbGF5KDEwMCk7CisJfSB3aGlsZSAoLS1yZXRyaWVz ID4gMCk7CisKKwlpZiAocmV0cmllcyA8PSAwKSB7CisJCWRldl9lcnIodGRjMmRldih0ZGMpLCAi dGltZW91dCB3YWl0aW5nIGZvciBkbWEgbG9hZFxuIik7CisJCXJlc3VsdCA9IHJlc2lkdWFsOwor CX0KKworZG9uZToJCisJZGV2X2RiZyh0ZGMyZGV2KHRkYyksICJyZXNpZHVhbDogcmVxICUwOGx4 LCBhaGJAJTA4bHgsIHdjb3VudCAlMDhseCwgZG9uZSAlZFxuIiwKKwkJIHNnX3JlcS0+Y2hfcmVn cy5haGJfcHRyLCBhaGJwdHIsIHdjb3VudCwgZG9uZSk7CisKKwlyZXR1cm4gcmVzdWx0OworfQor CiBzdGF0aWMgZW51bSBkbWFfc3RhdHVzIHRlZ3JhX2RtYV90eF9zdGF0dXMoc3RydWN0IGRtYV9j aGFuICpkYywKIAlkbWFfY29va2llX3QgY29va2llLCBzdHJ1Y3QgZG1hX3R4X3N0YXRlICp0eHN0 YXRlKQogewpAQCAtODQ5LDYgKzkzMyw3IEBAIHN0YXRpYyBlbnVtIGRtYV9zdGF0dXMgdGVncmFf ZG1hX3R4X3N0YXR1cyhzdHJ1Y3QgZG1hX2NoYW4gKmRjLAogCQlyZXNpZHVhbCA9IGRtYV9kZXNj LT5ieXRlc19yZXF1ZXN0ZWQgLQogCQkJICAgKGRtYV9kZXNjLT5ieXRlc190cmFuc2ZlcnJlZCAl CiAJCQkgICAgZG1hX2Rlc2MtPmJ5dGVzX3JlcXVlc3RlZCk7CisJCXJlc2lkdWFsID0gdGVncmFf ZG1hX3VwZGF0ZV9yZXNpZHVhbCh0ZGMsIHNnX3JlcSwgZG1hX2Rlc2MsIHJlc2lkdWFsKTsKIAkJ ZG1hX3NldF9yZXNpZHVlKHR4c3RhdGUsIHJlc2lkdWFsKTsKIAl9CiAKQEAgLTE0NDQsMTIgKzE1 MjksNyBAQCBzdGF0aWMgaW50IHRlZ3JhX2RtYV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQogCQlCSVQoRE1BX1NMQVZFX0JVU1dJRFRIXzRfQllURVMpIHwKIAkJQklUKERNQV9T TEFWRV9CVVNXSURUSF84X0JZVEVTKTsKIAl0ZG1hLT5kbWFfZGV2LmRpcmVjdGlvbnMgPSBCSVQo RE1BX0RFVl9UT19NRU0pIHwgQklUKERNQV9NRU1fVE9fREVWKTsKLQkvKgotCSAqIFhYWCBUaGUg aGFyZHdhcmUgYXBwZWFycyB0byBzdXBwb3J0Ci0JICogRE1BX1JFU0lEVUVfR1JBTlVMQVJJVFlf QlVSU1QtbGV2ZWwgcmVwb3J0aW5nLCBidXQgaXQncwotCSAqIG9ubHkgdXNlZCBieSB0aGlzIGRy aXZlciBkdXJpbmcgdGVncmFfZG1hX3Rlcm1pbmF0ZV9hbGwoKQotCSAqLwotCXRkbWEtPmRtYV9k ZXYucmVzaWR1ZV9ncmFudWxhcml0eSA9IERNQV9SRVNJRFVFX0dSQU5VTEFSSVRZX1NFR01FTlQ7 CisJdGRtYS0+ZG1hX2Rldi5yZXNpZHVlX2dyYW51bGFyaXR5ID0gRE1BX1JFU0lEVUVfR1JBTlVM QVJJVFlfQlVSU1Q7CiAJdGRtYS0+ZG1hX2Rldi5kZXZpY2VfY29uZmlnID0gdGVncmFfZG1hX3Ns YXZlX2NvbmZpZzsKIAl0ZG1hLT5kbWFfZGV2LmRldmljZV90ZXJtaW5hdGVfYWxsID0gdGVncmFf ZG1hX3Rlcm1pbmF0ZV9hbGw7CiAJdGRtYS0+ZG1hX2Rldi5kZXZpY2VfdHhfc3RhdHVzID0gdGVn cmFfZG1hX3R4X3N0YXR1czsK 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=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT 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 76A56C10F11 for ; Wed, 24 Apr 2019 16:24:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 44A54208E4 for ; Wed, 24 Apr 2019 16:24:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731118AbfDXQYD (ORCPT ); Wed, 24 Apr 2019 12:24:03 -0400 Received: from imap1.codethink.co.uk ([176.9.8.82]:44579 "EHLO imap1.codethink.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727393AbfDXQYD (ORCPT ); Wed, 24 Apr 2019 12:24:03 -0400 Received: from [167.98.27.226] (helo=rainbowdash.codethink.co.uk) by imap1.codethink.co.uk with esmtpsa (Exim 4.84_2 #1 (Debian)) id 1hJKgY-0003E7-SJ; Wed, 24 Apr 2019 17:23:51 +0100 Received: from ben by rainbowdash.codethink.co.uk with local (Exim 4.92) (envelope-from ) id 1hJKgY-0006Au-Gi; Wed, 24 Apr 2019 17:23:50 +0100 From: Ben Dooks To: linux-kernel@lists.codethink.co.uk Cc: Ben Dooks , Dmitry Osipenko , Laxman Dewangan , Jon Hunter , Vinod Koul , Dan Williams , Thierry Reding , dmaengine@vger.kernel.org, linux-tegra@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH] dma: tegra: add accurate reporting of dma state Date: Wed, 24 Apr 2019 17:23:48 +0100 Message-Id: <20190424162348.23692-1-ben.dooks@codethink.co.uk> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: dmaengine-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: dmaengine@vger.kernel.org Content-Type: text/plain; charset="UTF-8" Message-ID: <20190424162348.ixNiS3O-IGTk2XMUYq5qRptqIe0oH7udrqYG5vtuu6o@z> 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 --- 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; + 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 */ + + /* check status, if channel isn't busy then skip */ + if (!(status & TEGRA_APBDMA_STATUS_BUSY)) { + result = residual; + break; + } + + /* 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); + } while (--retries > 0); + + if (retries <= 0) { + dev_err(tdc2dev(tdc), "timeout waiting for dma load\n"); + result = residual; + } + +done: + dev_dbg(tdc2dev(tdc), "residual: req %08lx, ahb@%08lx, wcount %08lx, done %d\n", + sg_req->ch_regs.ahb_ptr, ahbptr, wcount, done); + + return result; +} + static enum dma_status tegra_dma_tx_status(struct dma_chan *dc, dma_cookie_t cookie, struct dma_tx_state *txstate) { @@ -849,6 +933,7 @@ static enum dma_status tegra_dma_tx_status(struct dma_chan *dc, residual = dma_desc->bytes_requested - (dma_desc->bytes_transferred % dma_desc->bytes_requested); + residual = tegra_dma_update_residual(tdc, sg_req, dma_desc, residual); dma_set_residue(txstate, residual); } @@ -1444,12 +1529,7 @@ static int tegra_dma_probe(struct platform_device *pdev) BIT(DMA_SLAVE_BUSWIDTH_4_BYTES) | BIT(DMA_SLAVE_BUSWIDTH_8_BYTES); tdma->dma_dev.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV); - /* - * XXX The hardware appears to support - * DMA_RESIDUE_GRANULARITY_BURST-level reporting, but it's - * only used by this driver during tegra_dma_terminate_all() - */ - tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT; + tdma->dma_dev.residue_granularity = DMA_RESIDUE_GRANULARITY_BURST; tdma->dma_dev.device_config = tegra_dma_slave_config; tdma->dma_dev.device_terminate_all = tegra_dma_terminate_all; tdma->dma_dev.device_tx_status = tegra_dma_tx_status; -- 2.20.1