From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 5/9] xen/gntdev: Allow mappings for DMA buffers Date: Fri, 1 Jun 2018 14:41:28 +0300 Message-ID: <20180601114132.22596-6-andr2000@gmail.com> References: <20180601114132.22596-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x244.google.com (mail-lf0-x244.google.com [IPv6:2a00:1450:4010:c07::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2AF2F6E67A for ; Fri, 1 Jun 2018 11:41:49 +0000 (UTC) Received: by mail-lf0-x244.google.com with SMTP id r2-v6so14365325lff.4 for ; Fri, 01 Jun 2018 04:41:49 -0700 (PDT) In-Reply-To: <20180601114132.22596-1-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, daniel.vetter@intel.com, dongwon.kim@intel.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKQWxsb3cgbWFwcGluZ3MgZm9yIERNQSBiYWNrZWQgIGJ1ZmZlcnMgaWYgZ3JhbnQg dGFibGUgbW9kdWxlCnN1cHBvcnRzIHN1Y2g6IHRoaXMgZXh0ZW5kcyBncmFudCBkZXZpY2UgdG8g bm90IG9ubHkgbWFwIGJ1ZmZlcnMKbWFkZSBvZiBiYWxsb29uIHBhZ2VzLCBidXQgYWxzbyBmcm9t IGJ1ZmZlcnMgYWxsb2NhdGVkIHdpdGgKZG1hX2FsbG9jX3h4eC4KClNpZ25lZC1vZmYtYnk6IE9s ZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4K LS0tCiBkcml2ZXJzL3hlbi9nbnRkZXYuYyAgICAgIHwgOTkgKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKystCiBpbmNsdWRlL3VhcGkveGVuL2dudGRldi5oIHwgMTUgKysrKysr CiAyIGZpbGVzIGNoYW5nZWQsIDExMiBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMveGVuL2dudGRldi5jIGIvZHJpdmVycy94ZW4vZ250ZGV2LmMKaW5k ZXggYmQ1NjY1M2I5YmJjLi45ODEzZmM0NDBjNzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2du dGRldi5jCisrKyBiL2RyaXZlcnMveGVuL2dudGRldi5jCkBAIC0zNyw2ICszNyw5IEBACiAjaW5j bHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2hpZ2htZW0uaD4KICNpbmNsdWRl IDxsaW51eC9yZWZjb3VudC5oPgorI2lmZGVmIENPTkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisj aW5jbHVkZSA8bGludXgvb2ZfZGV2aWNlLmg+CisjZW5kaWYKIAogI2luY2x1ZGUgPHhlbi94ZW4u aD4KICNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KQEAgLTcyLDYgKzc1LDExIEBAIHN0cnVj dCBnbnRkZXZfcHJpdiB7CiAJc3RydWN0IG11dGV4IGxvY2s7CiAJc3RydWN0IG1tX3N0cnVjdCAq bW07CiAJc3RydWN0IG1tdV9ub3RpZmllciBtbjsKKworI2lmZGVmIENPTkZJR19YRU5fR1JBTlRf RE1BX0FMTE9DCisJLyogRGV2aWNlIGZvciB3aGljaCBETUEgbWVtb3J5IGlzIGFsbG9jYXRlZC4g Ki8KKwlzdHJ1Y3QgZGV2aWNlICpkbWFfZGV2OworI2VuZGlmCiB9OwogCiBzdHJ1Y3QgdW5tYXBf bm90aWZ5IHsKQEAgLTk2LDEwICsxMDQsMjcgQEAgc3RydWN0IGdyYW50X21hcCB7CiAJc3RydWN0 IGdudHRhYl91bm1hcF9ncmFudF9yZWYgKmt1bm1hcF9vcHM7CiAJc3RydWN0IHBhZ2UgKipwYWdl czsKIAl1bnNpZ25lZCBsb25nIHBhZ2VzX3ZtX3N0YXJ0OworCisjaWZkZWYgQ09ORklHX1hFTl9H UkFOVF9ETUFfQUxMT0MKKwkvKgorCSAqIElmIGRtYWJ1Zl92YWRkciBpcyBub3QgTlVMTCB0aGVu IHRoaXMgbWFwcGluZyBpcyBiYWNrZWQgYnkgRE1BCisJICogY2FwYWJsZSBtZW1vcnkuCisJICov CisKKwlzdHJ1Y3QgZGV2aWNlICpkbWFfZGV2OworCS8qIEZsYWdzIHVzZWQgdG8gY3JlYXRlIHRo aXMgRE1BIGJ1ZmZlcjogR05UREVWX0RNQV9GTEFHX1hYWC4gKi8KKwlpbnQgZG1hX2ZsYWdzOwor CXZvaWQgKmRtYV92YWRkcjsKKwlkbWFfYWRkcl90IGRtYV9idXNfYWRkcjsKKwkvKiBUaGlzIGlz IHJlcXVpcmVkIGZvciBnbnR0YWJfZG1hX3thbGxvY3xmcmVlfV9wYWdlcy4gKi8KKwl4ZW5fcGZu X3QgKmZyYW1lczsKKyNlbmRpZgogfTsKIAogc3RhdGljIGludCB1bm1hcF9ncmFudF9wYWdlcyhz dHJ1Y3QgZ3JhbnRfbWFwICptYXAsIGludCBvZmZzZXQsIGludCBwYWdlcyk7CiAKK3N0YXRpYyBz dHJ1Y3QgbWlzY2RldmljZSBnbnRkZXZfbWlzY2RldjsKKwogLyogLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAKIHN0 YXRpYyB2b2lkIGdudGRldl9wcmludF9tYXBzKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwKQEAg LTEyMSw4ICsxNDYsMjcgQEAgc3RhdGljIHZvaWQgZ250ZGV2X2ZyZWVfbWFwKHN0cnVjdCBncmFu dF9tYXAgKm1hcCkKIAlpZiAobWFwID09IE5VTEwpCiAJCXJldHVybjsKIAorI2lmZGVmIENPTkZJ R19YRU5fR1JBTlRfRE1BX0FMTE9DCisJaWYgKG1hcC0+ZG1hX3ZhZGRyKSB7CisJCXN0cnVjdCBn bnR0YWJfZG1hX2FsbG9jX2FyZ3MgYXJnczsKKworCQlhcmdzLmRldiA9IG1hcC0+ZG1hX2RldjsK KwkJYXJncy5jb2hlcmVudCA9IG1hcC0+ZG1hX2ZsYWdzICYgR05UREVWX0RNQV9GTEFHX0NPSEVS RU5UOworCQlhcmdzLm5yX3BhZ2VzID0gbWFwLT5jb3VudDsKKwkJYXJncy5wYWdlcyA9IG1hcC0+ cGFnZXM7CisJCWFyZ3MuZnJhbWVzID0gbWFwLT5mcmFtZXM7CisJCWFyZ3MudmFkZHIgPSBtYXAt PmRtYV92YWRkcjsKKwkJYXJncy5kZXZfYnVzX2FkZHIgPSBtYXAtPmRtYV9idXNfYWRkcjsKKwor CQlnbnR0YWJfZG1hX2ZyZWVfcGFnZXMoJmFyZ3MpOworCX0gZWxzZQorI2VuZGlmCiAJaWYgKG1h cC0+cGFnZXMpCiAJCWdudHRhYl9mcmVlX3BhZ2VzKG1hcC0+Y291bnQsIG1hcC0+cGFnZXMpOwor CisjaWZkZWYgQ09ORklHX1hFTl9HUkFOVF9ETUFfQUxMT0MKKwlrZnJlZShtYXAtPmZyYW1lcyk7 CisjZW5kaWYKIAlrZnJlZShtYXAtPnBhZ2VzKTsKIAlrZnJlZShtYXAtPmdyYW50cyk7CiAJa2Zy ZWUobWFwLT5tYXBfb3BzKTsKQEAgLTEzMiw3ICsxNzYsOCBAQCBzdGF0aWMgdm9pZCBnbnRkZXZf ZnJlZV9tYXAoc3RydWN0IGdyYW50X21hcCAqbWFwKQogCWtmcmVlKG1hcCk7CiB9CiAKLXN0YXRp YyBzdHJ1Y3QgZ3JhbnRfbWFwICpnbnRkZXZfYWxsb2NfbWFwKHN0cnVjdCBnbnRkZXZfcHJpdiAq cHJpdiwgaW50IGNvdW50KQorc3RhdGljIHN0cnVjdCBncmFudF9tYXAgKmdudGRldl9hbGxvY19t YXAoc3RydWN0IGdudGRldl9wcml2ICpwcml2LCBpbnQgY291bnQsCisJCQkJCSAgaW50IGRtYV9m bGFncykKIHsKIAlzdHJ1Y3QgZ3JhbnRfbWFwICphZGQ7CiAJaW50IGk7CkBAIC0xNTUsNiArMjAw LDM3IEBAIHN0YXRpYyBzdHJ1Y3QgZ3JhbnRfbWFwICpnbnRkZXZfYWxsb2NfbWFwKHN0cnVjdCBn bnRkZXZfcHJpdiAqcHJpdiwgaW50IGNvdW50KQogCSAgICBOVUxMID09IGFkZC0+cGFnZXMpCiAJ CWdvdG8gZXJyOwogCisjaWZkZWYgQ09ORklHX1hFTl9HUkFOVF9ETUFfQUxMT0MKKwlhZGQtPmRt YV9mbGFncyA9IGRtYV9mbGFnczsKKworCS8qCisJICogQ2hlY2sgaWYgdGhpcyBtYXBwaW5nIGlz IHJlcXVlc3RlZCB0byBiZSBiYWNrZWQKKwkgKiBieSBhIERNQSBidWZmZXIuCisJICovCisJaWYg KGRtYV9mbGFncyAmIChHTlRERVZfRE1BX0ZMQUdfV0MgfCBHTlRERVZfRE1BX0ZMQUdfQ09IRVJF TlQpKSB7CisJCXN0cnVjdCBnbnR0YWJfZG1hX2FsbG9jX2FyZ3MgYXJnczsKKworCQlhZGQtPmZy YW1lcyA9IGtjYWxsb2MoY291bnQsIHNpemVvZihhZGQtPmZyYW1lc1swXSksCisJCQkJICAgICAg R0ZQX0tFUk5FTCk7CisJCWlmICghYWRkLT5mcmFtZXMpCisJCQlnb3RvIGVycjsKKworCQkvKiBS ZW1lbWJlciB0aGUgZGV2aWNlLCBzbyB3ZSBjYW4gZnJlZSBETUEgbWVtb3J5LiAqLworCQlhZGQt PmRtYV9kZXYgPSBwcml2LT5kbWFfZGV2OworCisJCWFyZ3MuZGV2ID0gcHJpdi0+ZG1hX2RldjsK KwkJYXJncy5jb2hlcmVudCA9IGRtYV9mbGFncyAmIEdOVERFVl9ETUFfRkxBR19DT0hFUkVOVDsK KwkJYXJncy5ucl9wYWdlcyA9IGNvdW50OworCQlhcmdzLnBhZ2VzID0gYWRkLT5wYWdlczsKKwkJ YXJncy5mcmFtZXMgPSBhZGQtPmZyYW1lczsKKworCQlpZiAoZ250dGFiX2RtYV9hbGxvY19wYWdl cygmYXJncykpCisJCQlnb3RvIGVycjsKKworCQlhZGQtPmRtYV92YWRkciA9IGFyZ3MudmFkZHI7 CisJCWFkZC0+ZG1hX2J1c19hZGRyID0gYXJncy5kZXZfYnVzX2FkZHI7CisJfSBlbHNlCisjZW5k aWYKIAlpZiAoZ250dGFiX2FsbG9jX3BhZ2VzKGNvdW50LCBhZGQtPnBhZ2VzKSkKIAkJZ290byBl cnI7CiAKQEAgLTMyNSw2ICs0MDEsMTQgQEAgc3RhdGljIGludCBtYXBfZ3JhbnRfcGFnZXMoc3Ry dWN0IGdyYW50X21hcCAqbWFwKQogCQltYXAtPnVubWFwX29wc1tpXS5oYW5kbGUgPSBtYXAtPm1h cF9vcHNbaV0uaGFuZGxlOwogCQlpZiAodXNlX3B0ZW1vZCkKIAkJCW1hcC0+a3VubWFwX29wc1tp XS5oYW5kbGUgPSBtYXAtPmttYXBfb3BzW2ldLmhhbmRsZTsKKyNpZmRlZiBDT05GSUdfWEVOX0dS QU5UX0RNQV9BTExPQworCQllbHNlIGlmIChtYXAtPmRtYV92YWRkcikgeworCQkJdW5zaWduZWQg bG9uZyBtZm47CisKKwkJCW1mbiA9IF9fcGZuX3RvX21mbihwYWdlX3RvX3BmbihtYXAtPnBhZ2Vz W2ldKSk7CisJCQltYXAtPnVubWFwX29wc1tpXS5kZXZfYnVzX2FkZHIgPSBfX3Bmbl90b19waHlz KG1mbik7CisJCX0KKyNlbmRpZgogCX0KIAlyZXR1cm4gZXJyOwogfQpAQCAtNTQ4LDYgKzYzMiwx NyBAQCBzdGF0aWMgaW50IGdudGRldl9vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBm aWxlICpmbGlwKQogCX0KIAogCWZsaXAtPnByaXZhdGVfZGF0YSA9IHByaXY7CisjaWZkZWYgQ09O RklHX1hFTl9HUkFOVF9ETUFfQUxMT0MKKwlwcml2LT5kbWFfZGV2ID0gZ250ZGV2X21pc2NkZXYu dGhpc19kZXZpY2U7CisKKwkvKgorCSAqIFRoZSBkZXZpY2UgaXMgbm90IHNwYXduIGZyb20gYSBk ZXZpY2UgdHJlZSwgc28gYXJjaF9zZXR1cF9kbWFfb3BzCisJICogaXMgbm90IGNhbGxlZCwgdGh1 cyBsZWF2aW5nIHRoZSBkZXZpY2Ugd2l0aCBkdW1teSBETUEgb3BzLgorCSAqIEZpeCB0aGlzIGNh bGwgb2ZfZG1hX2NvbmZpZ3VyZSgpIHdpdGggYSBOVUxMIG5vZGUgdG8gc2V0CisJICogZGVmYXVs dCBETUEgb3BzLgorCSAqLworCW9mX2RtYV9jb25maWd1cmUocHJpdi0+ZG1hX2RldiwgTlVMTCk7 CisjZW5kaWYKIAlwcl9kZWJ1ZygicHJpdiAlcFxuIiwgcHJpdik7CiAKIAlyZXR1cm4gMDsKQEAg LTU4OSw3ICs2ODQsNyBAQCBzdGF0aWMgbG9uZyBnbnRkZXZfaW9jdGxfbWFwX2dyYW50X3JlZihz dHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsCiAJCXJldHVybiAtRUlOVkFMOwogCiAJZXJyID0gLUVO T01FTTsKLQltYXAgPSBnbnRkZXZfYWxsb2NfbWFwKHByaXYsIG9wLmNvdW50KTsKKwltYXAgPSBn bnRkZXZfYWxsb2NfbWFwKHByaXYsIG9wLmNvdW50LCAwIC8qIFRoaXMgaXMgbm90IGEgZG1hLWJ1 Zi4gKi8pOwogCWlmICghbWFwKQogCQlyZXR1cm4gZXJyOwogCmRpZmYgLS1naXQgYS9pbmNsdWRl L3VhcGkveGVuL2dudGRldi5oIGIvaW5jbHVkZS91YXBpL3hlbi9nbnRkZXYuaAppbmRleCA2ZDEx NjM0NTZjMDMuLjRiOWQ0OThhMzFkNCAxMDA2NDQKLS0tIGEvaW5jbHVkZS91YXBpL3hlbi9nbnRk ZXYuaAorKysgYi9pbmNsdWRlL3VhcGkveGVuL2dudGRldi5oCkBAIC0yMDAsNCArMjAwLDE5IEBA IHN0cnVjdCBpb2N0bF9nbnRkZXZfZ3JhbnRfY29weSB7CiAvKiBTZW5kIGFuIGludGVycnVwdCBv biB0aGUgaW5kaWNhdGVkIGV2ZW50IGNoYW5uZWwgKi8KICNkZWZpbmUgVU5NQVBfTk9USUZZX1NF TkRfRVZFTlQgMHgyCiAKKy8qCisgKiBGbGFncyB0byBiZSB1c2VkIHdoaWxlIHJlcXVlc3Rpbmcg bWVtb3J5IG1hcHBpbmcncyBiYWNraW5nIHN0b3JhZ2UKKyAqIHRvIGJlIGFsbG9jYXRlZCB3aXRo IERNQSBBUEkuCisgKi8KKworLyoKKyAqIFRoZSBidWZmZXIgaXMgYmFja2VkIHdpdGggbWVtb3J5 IGFsbG9jYXRlZCB3aXRoIGRtYV9hbGxvY193Yy4KKyAqLworI2RlZmluZSBHTlRERVZfRE1BX0ZM QUdfV0MJCSgxIDw8IDApCisKKy8qCisgKiBUaGUgYnVmZmVyIGlzIGJhY2tlZCB3aXRoIG1lbW9y eSBhbGxvY2F0ZWQgd2l0aCBkbWFfYWxsb2NfY29oZXJlbnQuCisgKi8KKyNkZWZpbmUgR05UREVW X0RNQV9GTEFHX0NPSEVSRU5UCSgxIDw8IDEpCisKICNlbmRpZiAvKiBfX0xJTlVYX1BVQkxJQ19H TlRERVZfSF9fICovCi0tIAoyLjE3LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f67.google.com ([209.85.215.67]:35162 "EHLO mail-lf0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751900AbeFALlt (ORCPT ); Fri, 1 Jun 2018 07:41:49 -0400 From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: daniel.vetter@intel.com, andr2000@gmail.com, dongwon.kim@intel.com, matthew.d.roper@intel.com, Oleksandr Andrushchenko Subject: [PATCH v2 5/9] xen/gntdev: Allow mappings for DMA buffers Date: Fri, 1 Jun 2018 14:41:28 +0300 Message-Id: <20180601114132.22596-6-andr2000@gmail.com> In-Reply-To: <20180601114132.22596-1-andr2000@gmail.com> References: <20180601114132.22596-1-andr2000@gmail.com> Sender: linux-media-owner@vger.kernel.org List-ID: From: Oleksandr Andrushchenko Allow mappings for DMA backed buffers if grant table module supports such: this extends grant device to not only map buffers made of balloon pages, but also from buffers allocated with dma_alloc_xxx. Signed-off-by: Oleksandr Andrushchenko --- drivers/xen/gntdev.c | 99 ++++++++++++++++++++++++++++++++++++++- include/uapi/xen/gntdev.h | 15 ++++++ 2 files changed, 112 insertions(+), 2 deletions(-) diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c index bd56653b9bbc..9813fc440c70 100644 --- a/drivers/xen/gntdev.c +++ b/drivers/xen/gntdev.c @@ -37,6 +37,9 @@ #include #include #include +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +#include +#endif #include #include @@ -72,6 +75,11 @@ struct gntdev_priv { struct mutex lock; struct mm_struct *mm; struct mmu_notifier mn; + +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + /* Device for which DMA memory is allocated. */ + struct device *dma_dev; +#endif }; struct unmap_notify { @@ -96,10 +104,27 @@ struct grant_map { struct gnttab_unmap_grant_ref *kunmap_ops; struct page **pages; unsigned long pages_vm_start; + +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + /* + * If dmabuf_vaddr is not NULL then this mapping is backed by DMA + * capable memory. + */ + + struct device *dma_dev; + /* Flags used to create this DMA buffer: GNTDEV_DMA_FLAG_XXX. */ + int dma_flags; + void *dma_vaddr; + dma_addr_t dma_bus_addr; + /* This is required for gnttab_dma_{alloc|free}_pages. */ + xen_pfn_t *frames; +#endif }; static int unmap_grant_pages(struct grant_map *map, int offset, int pages); +static struct miscdevice gntdev_miscdev; + /* ------------------------------------------------------------------ */ static void gntdev_print_maps(struct gntdev_priv *priv, @@ -121,8 +146,27 @@ static void gntdev_free_map(struct grant_map *map) if (map == NULL) return; +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + if (map->dma_vaddr) { + struct gnttab_dma_alloc_args args; + + args.dev = map->dma_dev; + args.coherent = map->dma_flags & GNTDEV_DMA_FLAG_COHERENT; + args.nr_pages = map->count; + args.pages = map->pages; + args.frames = map->frames; + args.vaddr = map->dma_vaddr; + args.dev_bus_addr = map->dma_bus_addr; + + gnttab_dma_free_pages(&args); + } else +#endif if (map->pages) gnttab_free_pages(map->count, map->pages); + +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + kfree(map->frames); +#endif kfree(map->pages); kfree(map->grants); kfree(map->map_ops); @@ -132,7 +176,8 @@ static void gntdev_free_map(struct grant_map *map) kfree(map); } -static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count) +static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count, + int dma_flags) { struct grant_map *add; int i; @@ -155,6 +200,37 @@ static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count) NULL == add->pages) goto err; +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + add->dma_flags = dma_flags; + + /* + * Check if this mapping is requested to be backed + * by a DMA buffer. + */ + if (dma_flags & (GNTDEV_DMA_FLAG_WC | GNTDEV_DMA_FLAG_COHERENT)) { + struct gnttab_dma_alloc_args args; + + add->frames = kcalloc(count, sizeof(add->frames[0]), + GFP_KERNEL); + if (!add->frames) + goto err; + + /* Remember the device, so we can free DMA memory. */ + add->dma_dev = priv->dma_dev; + + args.dev = priv->dma_dev; + args.coherent = dma_flags & GNTDEV_DMA_FLAG_COHERENT; + args.nr_pages = count; + args.pages = add->pages; + args.frames = add->frames; + + if (gnttab_dma_alloc_pages(&args)) + goto err; + + add->dma_vaddr = args.vaddr; + add->dma_bus_addr = args.dev_bus_addr; + } else +#endif if (gnttab_alloc_pages(count, add->pages)) goto err; @@ -325,6 +401,14 @@ static int map_grant_pages(struct grant_map *map) map->unmap_ops[i].handle = map->map_ops[i].handle; if (use_ptemod) map->kunmap_ops[i].handle = map->kmap_ops[i].handle; +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + else if (map->dma_vaddr) { + unsigned long mfn; + + mfn = __pfn_to_mfn(page_to_pfn(map->pages[i])); + map->unmap_ops[i].dev_bus_addr = __pfn_to_phys(mfn); + } +#endif } return err; } @@ -548,6 +632,17 @@ static int gntdev_open(struct inode *inode, struct file *flip) } flip->private_data = priv; +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + priv->dma_dev = gntdev_miscdev.this_device; + + /* + * The device is not spawn from a device tree, so arch_setup_dma_ops + * is not called, thus leaving the device with dummy DMA ops. + * Fix this call of_dma_configure() with a NULL node to set + * default DMA ops. + */ + of_dma_configure(priv->dma_dev, NULL); +#endif pr_debug("priv %p\n", priv); return 0; @@ -589,7 +684,7 @@ static long gntdev_ioctl_map_grant_ref(struct gntdev_priv *priv, return -EINVAL; err = -ENOMEM; - map = gntdev_alloc_map(priv, op.count); + map = gntdev_alloc_map(priv, op.count, 0 /* This is not a dma-buf. */); if (!map) return err; diff --git a/include/uapi/xen/gntdev.h b/include/uapi/xen/gntdev.h index 6d1163456c03..4b9d498a31d4 100644 --- a/include/uapi/xen/gntdev.h +++ b/include/uapi/xen/gntdev.h @@ -200,4 +200,19 @@ struct ioctl_gntdev_grant_copy { /* Send an interrupt on the indicated event channel */ #define UNMAP_NOTIFY_SEND_EVENT 0x2 +/* + * Flags to be used while requesting memory mapping's backing storage + * to be allocated with DMA API. + */ + +/* + * The buffer is backed with memory allocated with dma_alloc_wc. + */ +#define GNTDEV_DMA_FLAG_WC (1 << 0) + +/* + * The buffer is backed with memory allocated with dma_alloc_coherent. + */ +#define GNTDEV_DMA_FLAG_COHERENT (1 << 1) + #endif /* __LINUX_PUBLIC_GNTDEV_H__ */ -- 2.17.0