From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 4/8] xen/gntdev: Allow mappings for DMA buffers Date: Fri, 25 May 2018 18:33:27 +0300 Message-ID: <20180525153331.31188-5-andr2000@gmail.com> References: <20180525153331.31188-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x242.google.com (mail-wm0-x242.google.com [IPv6:2a00:1450:400c:c09::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id B9D1F6E957 for ; Fri, 25 May 2018 15:33:50 +0000 (UTC) Received: by mail-wm0-x242.google.com with SMTP id n10-v6so15662123wmc.1 for ; Fri, 25 May 2018 08:33:50 -0700 (PDT) In-Reply-To: <20180525153331.31188-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 LS0tCiBkcml2ZXJzL3hlbi9nbnRkZXYuYyAgICAgIHwgMTAwICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKystCiBpbmNsdWRlL3VhcGkveGVuL2dudGRldi5oIHwgIDE1ICsrKysr KwogMiBmaWxlcyBjaGFuZ2VkLCAxMTMgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9nbnRkZXYuYyBiL2RyaXZlcnMveGVuL2dudGRldi5jCmlu ZGV4IGJkNTY2NTNiOWJiYy4uNjQwYTU3OWY0MmVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9n bnRkZXYuYworKysgYi9kcml2ZXJzL3hlbi9nbnRkZXYuYwpAQCAtMzcsNiArMzcsOSBAQAogI2lu Y2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9oaWdobWVtLmg+CiAjaW5jbHVk ZSA8bGludXgvcmVmY291bnQuaD4KKyNpZmRlZiBDT05GSUdfWEVOX0dSQU5UX0RNQV9BTExPQwor I2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgorI2VuZGlmCiAKICNpbmNsdWRlIDx4ZW4veGVu Lmg+CiAjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CkBAIC03Miw2ICs3NSwxMSBAQCBzdHJ1 Y3QgZ250ZGV2X3ByaXYgewogCXN0cnVjdCBtdXRleCBsb2NrOwogCXN0cnVjdCBtbV9zdHJ1Y3Qg Km1tOwogCXN0cnVjdCBtbXVfbm90aWZpZXIgbW47CisKKyNpZmRlZiBDT05GSUdfWEVOX0dSQU5U X0RNQV9BTExPQworCS8qIERldmljZSBmb3Igd2hpY2ggRE1BIG1lbW9yeSBpcyBhbGxvY2F0ZWQu ICovCisJc3RydWN0IGRldmljZSAqZG1hX2RldjsKKyNlbmRpZgogfTsKIAogc3RydWN0IHVubWFw X25vdGlmeSB7CkBAIC05NiwxMCArMTA0LDI4IEBAIHN0cnVjdCBncmFudF9tYXAgewogCXN0cnVj dCBnbnR0YWJfdW5tYXBfZ3JhbnRfcmVmICprdW5tYXBfb3BzOwogCXN0cnVjdCBwYWdlICoqcGFn ZXM7CiAJdW5zaWduZWQgbG9uZyBwYWdlc192bV9zdGFydDsKKworI2lmZGVmIENPTkZJR19YRU5f R1JBTlRfRE1BX0FMTE9DCisJLyoKKwkgKiBJZiBkbWFidWZfdmFkZHIgaXMgbm90IE5VTEwgdGhl biB0aGlzIG1hcHBpbmcgaXMgYmFja2VkIGJ5IERNQQorCSAqIGNhcGFibGUgbWVtb3J5LgorCSAq LworCisJLyogRGV2aWNlIGZvciB3aGljaCBETUEgbWVtb3J5IGlzIGFsbG9jYXRlZC4gKi8KKwlz dHJ1Y3QgZGV2aWNlICpkbWFfZGV2OworCS8qIEZsYWdzIHVzZWQgdG8gY3JlYXRlIHRoaXMgRE1B IGJ1ZmZlcjogR05UREVWX0RNQUJVRl9GTEFHX1hYWC4gKi8KKwlib29sIGRtYV9mbGFnczsKKwkv KiBWaXJ0dWFsL0NQVSBhZGRyZXNzIG9mIHRoZSBETUEgYnVmZmVyLiAqLworCXZvaWQgKmRtYV92 YWRkcjsKKwkvKiBCdXMgYWRkcmVzcyBvZiB0aGUgRE1BIGJ1ZmZlci4gKi8KKwlkbWFfYWRkcl90 IGRtYV9idXNfYWRkcjsKKyNlbmRpZgogfTsKIAogc3RhdGljIGludCB1bm1hcF9ncmFudF9wYWdl cyhzdHJ1Y3QgZ3JhbnRfbWFwICptYXAsIGludCBvZmZzZXQsIGludCBwYWdlcyk7CiAKK3N0YXRp YyBzdHJ1Y3QgbWlzY2RldmljZSBnbnRkZXZfbWlzY2RldjsKKwogLyogLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAK IHN0YXRpYyB2b2lkIGdudGRldl9wcmludF9tYXBzKHN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdiwK QEAgLTEyMSw4ICsxNDcsMjYgQEAgc3RhdGljIHZvaWQgZ250ZGV2X2ZyZWVfbWFwKHN0cnVjdCBn cmFudF9tYXAgKm1hcCkKIAlpZiAobWFwID09IE5VTEwpCiAJCXJldHVybjsKIAorI2lmZGVmIENP TkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisJaWYgKG1hcC0+ZG1hX3ZhZGRyKSB7CisJCXN0cnVj dCBnbnR0YWJfZG1hX2FsbG9jX2FyZ3MgYXJnczsKKworCQlhcmdzLmRldiA9IG1hcC0+ZG1hX2Rl djsKKwkJYXJncy5jb2hlcmVudCA9IG1hcC0+ZG1hX2ZsYWdzICYgR05UREVWX0RNQV9GTEFHX0NP SEVSRU5UOworCQlhcmdzLm5yX3BhZ2VzID0gbWFwLT5jb3VudDsKKwkJYXJncy5wYWdlcyA9IG1h cC0+cGFnZXM7CisJCWFyZ3MudmFkZHIgPSBtYXAtPmRtYV92YWRkcjsKKwkJYXJncy5kZXZfYnVz X2FkZHIgPSBtYXAtPmRtYV9idXNfYWRkcjsKKworCQlnbnR0YWJfZG1hX2ZyZWVfcGFnZXMoJmFy Z3MpOworCX0gZWxzZSBpZiAobWFwLT5wYWdlcykgeworCQlnbnR0YWJfZnJlZV9wYWdlcyhtYXAt PmNvdW50LCBtYXAtPnBhZ2VzKTsKKwl9CisjZWxzZQogCWlmIChtYXAtPnBhZ2VzKQogCQlnbnR0 YWJfZnJlZV9wYWdlcyhtYXAtPmNvdW50LCBtYXAtPnBhZ2VzKTsKKyNlbmRpZgorCiAJa2ZyZWUo bWFwLT5wYWdlcyk7CiAJa2ZyZWUobWFwLT5ncmFudHMpOwogCWtmcmVlKG1hcC0+bWFwX29wcyk7 CkBAIC0xMzIsNyArMTc2LDggQEAgc3RhdGljIHZvaWQgZ250ZGV2X2ZyZWVfbWFwKHN0cnVjdCBn cmFudF9tYXAgKm1hcCkKIAlrZnJlZShtYXApOwogfQogCi1zdGF0aWMgc3RydWN0IGdyYW50X21h cCAqZ250ZGV2X2FsbG9jX21hcChzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsIGludCBjb3VudCkK K3N0YXRpYyBzdHJ1Y3QgZ3JhbnRfbWFwICpnbnRkZXZfYWxsb2NfbWFwKHN0cnVjdCBnbnRkZXZf cHJpdiAqcHJpdiwgaW50IGNvdW50LAorCQkJCQkgIGludCBkbWFfZmxhZ3MpCiB7CiAJc3RydWN0 IGdyYW50X21hcCAqYWRkOwogCWludCBpOwpAQCAtMTU1LDggKzIwMCwzNyBAQCBzdGF0aWMgc3Ry dWN0IGdyYW50X21hcCAqZ250ZGV2X2FsbG9jX21hcChzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYs IGludCBjb3VudCkKIAkgICAgTlVMTCA9PSBhZGQtPnBhZ2VzKQogCQlnb3RvIGVycjsKIAorI2lm ZGVmIENPTkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisJYWRkLT5kbWFfZmxhZ3MgPSBkbWFfZmxh Z3M7CisKKwkvKgorCSAqIENoZWNrIGlmIHRoaXMgbWFwcGluZyBpcyByZXF1ZXN0ZWQgdG8gYmUg YmFja2VkCisJICogYnkgYSBETUEgYnVmZmVyLgorCSAqLworCWlmIChkbWFfZmxhZ3MgJiAoR05U REVWX0RNQV9GTEFHX1dDIHwgR05UREVWX0RNQV9GTEFHX0NPSEVSRU5UKSkgeworCQlzdHJ1Y3Qg Z250dGFiX2RtYV9hbGxvY19hcmdzIGFyZ3M7CisKKwkJLyogUmVtZW1iZXIgdGhlIGRldmljZSwg c28gd2UgY2FuIGZyZWUgRE1BIG1lbW9yeS4gKi8KKwkJYWRkLT5kbWFfZGV2ID0gcHJpdi0+ZG1h X2RldjsKKworCQlhcmdzLmRldiA9IHByaXYtPmRtYV9kZXY7CisJCWFyZ3MuY29oZXJlbnQgPSBk bWFfZmxhZ3MgJiBHTlRERVZfRE1BX0ZMQUdfQ09IRVJFTlQ7CisJCWFyZ3MubnJfcGFnZXMgPSBj b3VudDsKKwkJYXJncy5wYWdlcyA9IGFkZC0+cGFnZXM7CisKKwkJaWYgKGdudHRhYl9kbWFfYWxs b2NfcGFnZXMoJmFyZ3MpKQorCQkJZ290byBlcnI7CisKKwkJYWRkLT5kbWFfdmFkZHIgPSBhcmdz LnZhZGRyOworCQlhZGQtPmRtYV9idXNfYWRkciA9IGFyZ3MuZGV2X2J1c19hZGRyOworCX0gZWxz ZSB7CisJCWlmIChnbnR0YWJfYWxsb2NfcGFnZXMoY291bnQsIGFkZC0+cGFnZXMpKQorCQkJZ290 byBlcnI7CisJfQorI2Vsc2UKIAlpZiAoZ250dGFiX2FsbG9jX3BhZ2VzKGNvdW50LCBhZGQtPnBh Z2VzKSkKIAkJZ290byBlcnI7CisjZW5kaWYKIAogCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsr KSB7CiAJCWFkZC0+bWFwX29wc1tpXS5oYW5kbGUgPSAtMTsKQEAgLTMyMyw4ICszOTcsMTkgQEAg c3RhdGljIGludCBtYXBfZ3JhbnRfcGFnZXMoc3RydWN0IGdyYW50X21hcCAqbWFwKQogCQl9CiAK IAkJbWFwLT51bm1hcF9vcHNbaV0uaGFuZGxlID0gbWFwLT5tYXBfb3BzW2ldLmhhbmRsZTsKKyNp ZmRlZiBDT05GSUdfWEVOX0dSQU5UX0RNQV9BTExPQworCQlpZiAodXNlX3B0ZW1vZCkgeworCQkJ bWFwLT5rdW5tYXBfb3BzW2ldLmhhbmRsZSA9IG1hcC0+a21hcF9vcHNbaV0uaGFuZGxlOworCQl9 IGVsc2UgaWYgKG1hcC0+ZG1hX3ZhZGRyKSB7CisJCQl1bnNpZ25lZCBsb25nIG1mbjsKKworCQkJ bWZuID0gX19wZm5fdG9fbWZuKHBhZ2VfdG9fcGZuKG1hcC0+cGFnZXNbaV0pKTsKKwkJCW1hcC0+ dW5tYXBfb3BzW2ldLmRldl9idXNfYWRkciA9IF9fcGZuX3RvX3BoeXMobWZuKTsKKwkJfQorI2Vs c2UKIAkJaWYgKHVzZV9wdGVtb2QpCiAJCQltYXAtPmt1bm1hcF9vcHNbaV0uaGFuZGxlID0gbWFw LT5rbWFwX29wc1tpXS5oYW5kbGU7CisjZW5kaWYKIAl9CiAJcmV0dXJuIGVycjsKIH0KQEAgLTU0 OCw2ICs2MzMsMTcgQEAgc3RhdGljIGludCBnbnRkZXZfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2Rl LCBzdHJ1Y3QgZmlsZSAqZmxpcCkKIAl9CiAKIAlmbGlwLT5wcml2YXRlX2RhdGEgPSBwcml2Owor I2lmZGVmIENPTkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisJcHJpdi0+ZG1hX2RldiA9IGdudGRl dl9taXNjZGV2LnRoaXNfZGV2aWNlOworCisJLyoKKwkgKiBUaGUgZGV2aWNlIGlzIG5vdCBzcGF3 biBmcm9tIGEgZGV2aWNlIHRyZWUsIHNvIGFyY2hfc2V0dXBfZG1hX29wcworCSAqIGlzIG5vdCBj YWxsZWQsIHRodXMgbGVhdmluZyB0aGUgZGV2aWNlIHdpdGggZHVtbXkgRE1BIG9wcy4KKwkgKiBG aXggdGhpcyBjYWxsIG9mX2RtYV9jb25maWd1cmUoKSB3aXRoIGEgTlVMTCBub2RlIHRvIHNldAor CSAqIGRlZmF1bHQgRE1BIG9wcy4KKwkgKi8KKwlvZl9kbWFfY29uZmlndXJlKHByaXYtPmRtYV9k ZXYsIE5VTEwpOworI2VuZGlmCiAJcHJfZGVidWcoInByaXYgJXBcbiIsIHByaXYpOwogCiAJcmV0 dXJuIDA7CkBAIC01ODksNyArNjg1LDcgQEAgc3RhdGljIGxvbmcgZ250ZGV2X2lvY3RsX21hcF9n cmFudF9yZWYoc3RydWN0IGdudGRldl9wcml2ICpwcml2LAogCQlyZXR1cm4gLUVJTlZBTDsKIAog CWVyciA9IC1FTk9NRU07Ci0JbWFwID0gZ250ZGV2X2FsbG9jX21hcChwcml2LCBvcC5jb3VudCk7 CisJbWFwID0gZ250ZGV2X2FsbG9jX21hcChwcml2LCBvcC5jb3VudCwgMCAvKiBUaGlzIGlzIG5v dCBhIGRtYS1idWYuICovKTsKIAlpZiAoIW1hcCkKIAkJcmV0dXJuIGVycjsKIApkaWZmIC0tZ2l0 IGEvaW5jbHVkZS91YXBpL3hlbi9nbnRkZXYuaCBiL2luY2x1ZGUvdWFwaS94ZW4vZ250ZGV2LmgK aW5kZXggNmQxMTYzNDU2YzAzLi4yZDVhNDY3MmYwN2MgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFw aS94ZW4vZ250ZGV2LmgKKysrIGIvaW5jbHVkZS91YXBpL3hlbi9nbnRkZXYuaApAQCAtMjAwLDQg KzIwMCwxOSBAQCBzdHJ1Y3QgaW9jdGxfZ250ZGV2X2dyYW50X2NvcHkgewogLyogU2VuZCBhbiBp bnRlcnJ1cHQgb24gdGhlIGluZGljYXRlZCBldmVudCBjaGFubmVsICovCiAjZGVmaW5lIFVOTUFQ X05PVElGWV9TRU5EX0VWRU5UIDB4MgogCisvKgorICogRmxhZ3MgdG8gYmUgdXNlZCB3aGlsZSBy ZXF1ZXN0aW5nIG1lbW9yeSBtYXBwaW5nJ3MgYmFja2luZyBzdG9yYWdlCisgKiB0byBiZSBhbGxv Y2F0ZWQgd2l0aCBETUEgQVBJLgorICovCisKKy8qCisgKiBUaGUgYnVmZmVyIGlzIGJhY2tlZCB3 aXRoIG1lbW9yeSBhbGxvY2F0ZWQgd2l0aCBkbWFfYWxsb2Nfd2MuCisgKi8KKyNkZWZpbmUgR05U REVWX0RNQV9GTEFHX1dDCQkoMSA8PCAxKQorCisvKgorICogVGhlIGJ1ZmZlciBpcyBiYWNrZWQg d2l0aCBtZW1vcnkgYWxsb2NhdGVkIHdpdGggZG1hX2FsbG9jX2NvaGVyZW50LgorICovCisjZGVm aW5lIEdOVERFVl9ETUFfRkxBR19DT0hFUkVOVAkoMSA8PCAyKQorCiAjZW5kaWYgLyogX19MSU5V WF9QVUJMSUNfR05UREVWX0hfXyAqLwotLSAKMi4xNy4wCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wm0-f65.google.com ([74.125.82.65]:39065 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966576AbeEYPdu (ORCPT ); Fri, 25 May 2018 11:33:50 -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 4/8] xen/gntdev: Allow mappings for DMA buffers Date: Fri, 25 May 2018 18:33:27 +0300 Message-Id: <20180525153331.31188-5-andr2000@gmail.com> In-Reply-To: <20180525153331.31188-1-andr2000@gmail.com> References: <20180525153331.31188-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 | 100 +++++++++++++++++++++++++++++++++++++- include/uapi/xen/gntdev.h | 15 ++++++ 2 files changed, 113 insertions(+), 2 deletions(-) diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c index bd56653b9bbc..640a579f42ea 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,28 @@ 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. + */ + + /* Device for which DMA memory is allocated. */ + struct device *dma_dev; + /* Flags used to create this DMA buffer: GNTDEV_DMABUF_FLAG_XXX. */ + bool dma_flags; + /* Virtual/CPU address of the DMA buffer. */ + void *dma_vaddr; + /* Bus address of the DMA buffer. */ + dma_addr_t dma_bus_addr; +#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 +147,26 @@ 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.vaddr = map->dma_vaddr; + args.dev_bus_addr = map->dma_bus_addr; + + gnttab_dma_free_pages(&args); + } else if (map->pages) { + gnttab_free_pages(map->count, map->pages); + } +#else if (map->pages) gnttab_free_pages(map->count, map->pages); +#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,8 +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; + + /* 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; + + if (gnttab_dma_alloc_pages(&args)) + goto err; + + add->dma_vaddr = args.vaddr; + add->dma_bus_addr = args.dev_bus_addr; + } else { + if (gnttab_alloc_pages(count, add->pages)) + goto err; + } +#else if (gnttab_alloc_pages(count, add->pages)) goto err; +#endif for (i = 0; i < count; i++) { add->map_ops[i].handle = -1; @@ -323,8 +397,19 @@ static int map_grant_pages(struct grant_map *map) } map->unmap_ops[i].handle = map->map_ops[i].handle; +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC + if (use_ptemod) { + map->kunmap_ops[i].handle = map->kmap_ops[i].handle; + } 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); + } +#else if (use_ptemod) map->kunmap_ops[i].handle = map->kmap_ops[i].handle; +#endif } return err; } @@ -548,6 +633,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 +685,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..2d5a4672f07c 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 << 1) + +/* + * The buffer is backed with memory allocated with dma_alloc_coherent. + */ +#define GNTDEV_DMA_FLAG_COHERENT (1 << 2) + #endif /* __LINUX_PUBLIC_GNTDEV_H__ */ -- 2.17.0