From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v4 4/9] xen/grant-table: Allow allocating buffers suitable for DMA Date: Fri, 15 Jun 2018 09:27:48 +0300 Message-ID: <20180615062753.9229-5-andr2000@gmail.com> References: <20180615062753.9229-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-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id 97DE66E984 for ; Fri, 15 Jun 2018 06:28:10 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id i83-v6so12994619lfh.5 for ; Thu, 14 Jun 2018 23:28:10 -0700 (PDT) In-Reply-To: <20180615062753.9229-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 YW0uY29tPgoKRXh0ZW5kIGdyYW50IHRhYmxlIG1vZHVsZSBBUEkgdG8gYWxsb3cgYWxsb2NhdGlu ZyBidWZmZXJzIHRoYXQgY2FuCmJlIHVzZWQgZm9yIERNQSBvcGVyYXRpb25zIGFuZCBtYXBwaW5n IGZvcmVpZ24gZ3JhbnQgcmVmZXJlbmNlcwpvbiB0b3Agb2YgdGhvc2UuClRoZSByZXN1bHRpbmcg YnVmZmVyIGlzIHNpbWlsYXIgdG8gdGhlIG9uZSBhbGxvY2F0ZWQgYnkgdGhlIGJhbGxvb24KZHJp dmVyIGluIHRoYXQgcHJvcGVyIG1lbW9yeSByZXNlcnZhdGlvbiBpcyBtYWRlIGJ5Cih7aW5jcmVh c2V8ZGVjcmVhc2V9X3Jlc2VydmF0aW9uIGFuZCBWQSBtYXBwaW5ncyBhcmUgdXBkYXRlZCBpZgpu ZWVkZWQpLgpUaGlzIGlzIHVzZWZ1bCBmb3Igc2hhcmluZyBmb3JlaWduIGJ1ZmZlcnMgd2l0aCBI VyBkcml2ZXJzIHdoaWNoCmNhbm5vdCB3b3JrIHdpdGggc2NhdHRlcmVkIGJ1ZmZlcnMgcHJvdmlk ZWQgYnkgdGhlIGJhbGxvb24gZHJpdmVyLApidXQgcmVxdWlyZSBETUFhYmxlIG1lbW9yeSBpbnN0 ZWFkLgoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9h bmRydXNoY2hlbmtvQGVwYW0uY29tPgpSZXZpZXdlZC1ieTogQm9yaXMgT3N0cm92c2t5IDxib3Jp cy5vc3Ryb3Zza3lAb3JhY2xlLmNvbT4KLS0tCiBkcml2ZXJzL3hlbi9LY29uZmlnICAgICAgIHwg MTQgKysrKysrCiBkcml2ZXJzL3hlbi9ncmFudC10YWJsZS5jIHwgOTcgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL3hlbi9ncmFudF90YWJsZS5oIHwgMTgg KysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgMTI5IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQg YS9kcml2ZXJzL3hlbi9LY29uZmlnIGIvZHJpdmVycy94ZW4vS2NvbmZpZwppbmRleCBlNWQwYzI4 MzcyZWEuLjc1ZTVjNDBmODBhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vS2NvbmZpZworKysg Yi9kcml2ZXJzL3hlbi9LY29uZmlnCkBAIC0xNjEsNiArMTYxLDIwIEBAIGNvbmZpZyBYRU5fR1JB TlRfREVWX0FMTE9DCiAJICB0byBvdGhlciBkb21haW5zLiBUaGlzIGNhbiBiZSB1c2VkIHRvIGlt cGxlbWVudCBmcm9udGVuZCBkcml2ZXJzCiAJICBvciBhcyBwYXJ0IG9mIGFuIGludGVyLWRvbWFp biBzaGFyZWQgbWVtb3J5IGNoYW5uZWwuCiAKK2NvbmZpZyBYRU5fR1JBTlRfRE1BX0FMTE9DCisJ Ym9vbCAiQWxsb3cgYWxsb2NhdGluZyBETUEgY2FwYWJsZSBidWZmZXJzIHdpdGggZ3JhbnQgcmVm ZXJlbmNlIG1vZHVsZSIKKwlkZXBlbmRzIG9uIFhFTiAmJiBIQVNfRE1BCisJaGVscAorCSAgRXh0 ZW5kcyBncmFudCB0YWJsZSBtb2R1bGUgQVBJIHRvIGFsbG93IGFsbG9jYXRpbmcgRE1BIGNhcGFi bGUKKwkgIGJ1ZmZlcnMgYW5kIG1hcHBpbmcgZm9yZWlnbiBncmFudCByZWZlcmVuY2VzIG9uIHRv cCBvZiBpdC4KKwkgIFRoZSByZXN1bHRpbmcgYnVmZmVyIGlzIHNpbWlsYXIgdG8gb25lIGFsbG9j YXRlZCBieSB0aGUgYmFsbG9vbgorCSAgZHJpdmVyIGluIHRoYXQgcHJvcGVyIG1lbW9yeSByZXNl cnZhdGlvbiBpcyBtYWRlIGJ5CisJICAoe2luY3JlYXNlfGRlY3JlYXNlfV9yZXNlcnZhdGlvbiBh bmQgVkEgbWFwcGluZ3MgYXJlIHVwZGF0ZWQgaWYKKwkgIG5lZWRlZCkuCisJICBUaGlzIGlzIHVz ZWZ1bCBmb3Igc2hhcmluZyBmb3JlaWduIGJ1ZmZlcnMgd2l0aCBIVyBkcml2ZXJzIHdoaWNoCisJ ICBjYW5ub3Qgd29yayB3aXRoIHNjYXR0ZXJlZCBidWZmZXJzIHByb3ZpZGVkIGJ5IHRoZSBiYWxs b29uIGRyaXZlciwKKwkgIGJ1dCByZXF1aXJlIERNQWFibGUgbWVtb3J5IGluc3RlYWQuCisKIGNv bmZpZyBTV0lPVExCX1hFTgogCWRlZl9ib29sIHkKIAlzZWxlY3QgU1dJT1RMQgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYyBiL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMK aW5kZXggZGJiNDhhODllOTg3Li4yNmVkNDk4YjVlNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVu L2dyYW50LXRhYmxlLmMKKysrIGIvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYwpAQCAtNDUsNiAr NDUsOSBAQAogI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3Jh dGVsaW1pdC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CisjaWZkZWYgQ09ORklH X1hFTl9HUkFOVF9ETUFfQUxMT0MKKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgorI2Vu ZGlmCiAKICNpbmNsdWRlIDx4ZW4veGVuLmg+CiAjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS94ZW4u aD4KQEAgLTU3LDYgKzYwLDcgQEAKICNpZmRlZiBDT05GSUdfWDg2CiAjaW5jbHVkZSA8YXNtL3hl bi9jcHVpZC5oPgogI2VuZGlmCisjaW5jbHVkZSA8eGVuL21lbS1yZXNlcnZhdGlvbi5oPgogI2lu Y2x1ZGUgPGFzbS94ZW4vaHlwZXJjYWxsLmg+CiAjaW5jbHVkZSA8YXNtL3hlbi9pbnRlcmZhY2Uu aD4KIApAQCAtODM4LDYgKzg0Miw5OSBAQCB2b2lkIGdudHRhYl9mcmVlX3BhZ2VzKGludCBucl9w YWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcykKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdudHRhYl9m cmVlX3BhZ2VzKTsKIAorI2lmZGVmIENPTkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisvKioKKyAq IGdudHRhYl9kbWFfYWxsb2NfcGFnZXMgLSBhbGxvYyBETUFhYmxlIHBhZ2VzIHN1aXRhYmxlIGZv ciBncmFudCBtYXBwaW5nIGludG8KKyAqIEBhcmdzOiBhcmd1bWVudHMgdG8gdGhlIGZ1bmN0aW9u CisgKi8KK2ludCBnbnR0YWJfZG1hX2FsbG9jX3BhZ2VzKHN0cnVjdCBnbnR0YWJfZG1hX2FsbG9j X2FyZ3MgKmFyZ3MpCit7CisJdW5zaWduZWQgbG9uZyBwZm4sIHN0YXJ0X3BmbjsKKwlzaXplX3Qg c2l6ZTsKKwlpbnQgaSwgcmV0OworCisJc2l6ZSA9IGFyZ3MtPm5yX3BhZ2VzIDw8IFBBR0VfU0hJ RlQ7CisJaWYgKGFyZ3MtPmNvaGVyZW50KQorCQlhcmdzLT52YWRkciA9IGRtYV9hbGxvY19jb2hl cmVudChhcmdzLT5kZXYsIHNpemUsCisJCQkJCQkgJmFyZ3MtPmRldl9idXNfYWRkciwKKwkJCQkJ CSBHRlBfS0VSTkVMIHwgX19HRlBfTk9XQVJOKTsKKwllbHNlCisJCWFyZ3MtPnZhZGRyID0gZG1h X2FsbG9jX3djKGFyZ3MtPmRldiwgc2l6ZSwKKwkJCQkJICAgJmFyZ3MtPmRldl9idXNfYWRkciwK KwkJCQkJICAgR0ZQX0tFUk5FTCB8IF9fR0ZQX05PV0FSTik7CisJaWYgKCFhcmdzLT52YWRkcikg eworCQlwcl9kZWJ1ZygiRmFpbGVkIHRvIGFsbG9jYXRlIERNQSBidWZmZXIgb2Ygc2l6ZSAlenVc biIsIHNpemUpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlzdGFydF9wZm4gPSBfX3BoeXNf dG9fcGZuKGFyZ3MtPmRldl9idXNfYWRkcik7CisJZm9yIChwZm4gPSBzdGFydF9wZm4sIGkgPSAw OyBwZm4gPCBzdGFydF9wZm4gKyBhcmdzLT5ucl9wYWdlczsKKwkJCXBmbisrLCBpKyspIHsKKwkJ c3RydWN0IHBhZ2UgKnBhZ2UgPSBwZm5fdG9fcGFnZShwZm4pOworCisJCWFyZ3MtPnBhZ2VzW2ld ID0gcGFnZTsKKwkJYXJncy0+ZnJhbWVzW2ldID0geGVuX3BhZ2VfdG9fZ2ZuKHBhZ2UpOworCQl4 ZW5tZW1fcmVzZXJ2YXRpb25fc2NydWJfcGFnZShwYWdlKTsKKwl9CisKKwl4ZW5tZW1fcmVzZXJ2 YXRpb25fdmFfbWFwcGluZ19yZXNldChhcmdzLT5ucl9wYWdlcywgYXJncy0+cGFnZXMpOworCisJ cmV0ID0geGVubWVtX3Jlc2VydmF0aW9uX2RlY3JlYXNlKGFyZ3MtPm5yX3BhZ2VzLCBhcmdzLT5m cmFtZXMpOworCWlmIChyZXQgIT0gYXJncy0+bnJfcGFnZXMpIHsKKwkJcHJfZGVidWcoIkZhaWxl ZCB0byBkZWNyZWFzZSByZXNlcnZhdGlvbiBmb3IgRE1BIGJ1ZmZlclxuIik7CisJCXJldCA9IC1F RkFVTFQ7CisJCWdvdG8gZmFpbDsKKwl9CisKKwlyZXQgPSBnbnR0YWJfcGFnZXNfc2V0X3ByaXZh dGUoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBm YWlsOworCisJcmV0dXJuIDA7CisKK2ZhaWw6CisJZ250dGFiX2RtYV9mcmVlX3BhZ2VzKGFyZ3Mp OworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChnbnR0YWJfZG1hX2FsbG9jX3Bh Z2VzKTsKKworLyoqCisgKiBnbnR0YWJfZG1hX2ZyZWVfcGFnZXMgLSBmcmVlIERNQWFibGUgcGFn ZXMKKyAqIEBhcmdzOiBhcmd1bWVudHMgdG8gdGhlIGZ1bmN0aW9uCisgKi8KK2ludCBnbnR0YWJf ZG1hX2ZyZWVfcGFnZXMoc3RydWN0IGdudHRhYl9kbWFfYWxsb2NfYXJncyAqYXJncykKK3sKKwlz aXplX3Qgc2l6ZTsKKwlpbnQgaSwgcmV0OworCisJZ250dGFiX3BhZ2VzX2NsZWFyX3ByaXZhdGUo YXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzKTsKKworCWZvciAoaSA9IDA7IGkgPCBhcmdzLT5u cl9wYWdlczsgaSsrKQorCQlhcmdzLT5mcmFtZXNbaV0gPSBwYWdlX3RvX3hlbl9wZm4oYXJncy0+ cGFnZXNbaV0pOworCisJcmV0ID0geGVubWVtX3Jlc2VydmF0aW9uX2luY3JlYXNlKGFyZ3MtPm5y X3BhZ2VzLCBhcmdzLT5mcmFtZXMpOworCWlmIChyZXQgIT0gYXJncy0+bnJfcGFnZXMpIHsKKwkJ cHJfZGVidWcoIkZhaWxlZCB0byBkZWNyZWFzZSByZXNlcnZhdGlvbiBmb3IgRE1BIGJ1ZmZlclxu Iik7CisJCXJldCA9IC1FRkFVTFQ7CisJfSBlbHNlIHsKKwkJcmV0ID0gMDsKKwl9CisKKwl4ZW5t ZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGluZ191cGRhdGUoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBh Z2VzLAorCQkJCQkgICAgIGFyZ3MtPmZyYW1lcyk7CisKKwlzaXplID0gYXJncy0+bnJfcGFnZXMg PDwgUEFHRV9TSElGVDsKKwlpZiAoYXJncy0+Y29oZXJlbnQpCisJCWRtYV9mcmVlX2NvaGVyZW50 KGFyZ3MtPmRldiwgc2l6ZSwKKwkJCQkgIGFyZ3MtPnZhZGRyLCBhcmdzLT5kZXZfYnVzX2FkZHIp OworCWVsc2UKKwkJZG1hX2ZyZWVfd2MoYXJncy0+ZGV2LCBzaXplLAorCQkJICAgIGFyZ3MtPnZh ZGRyLCBhcmdzLT5kZXZfYnVzX2FkZHIpOworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9M X0dQTChnbnR0YWJfZG1hX2ZyZWVfcGFnZXMpOworI2VuZGlmCisKIC8qIEhhbmRsaW5nIG9mIHBh Z2VkIG91dCBncmFudCB0YXJnZXRzIChHTlRTVF9lYWdhaW4pICovCiAjZGVmaW5lIE1BWF9ERUxB WSAyNTYKIHN0YXRpYyBpbmxpbmUgdm9pZApkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vZ3JhbnRf dGFibGUuaCBiL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmgKaW5kZXggZGUwM2YyNTQyYmI3Li45 YmM1YmMwN2Q0ZDMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmgKKysrIGIv aW5jbHVkZS94ZW4vZ3JhbnRfdGFibGUuaApAQCAtMTk4LDYgKzE5OCwyNCBAQCB2b2lkIGdudHRh Yl9mcmVlX2F1dG9feGxhdF9mcmFtZXModm9pZCk7CiBpbnQgZ250dGFiX2FsbG9jX3BhZ2VzKGlu dCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcyk7CiB2b2lkIGdudHRhYl9mcmVlX3BhZ2Vz KGludCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcyk7CiAKKyNpZmRlZiBDT05GSUdfWEVO X0dSQU5UX0RNQV9BTExPQworc3RydWN0IGdudHRhYl9kbWFfYWxsb2NfYXJncyB7CisJLyogRGV2 aWNlIGZvciB3aGljaCBETUEgbWVtb3J5IHdpbGwgYmUvd2FzIGFsbG9jYXRlZC4gKi8KKwlzdHJ1 Y3QgZGV2aWNlICpkZXY7CisJLyogSWYgc2V0IHRoZW4gRE1BIGJ1ZmZlciBpcyBjb2hlcmVudCBh bmQgd3JpdGUtY29tYmluZSBvdGhlcndpc2UuICovCisJYm9vbCBjb2hlcmVudDsKKworCWludCBu cl9wYWdlczsKKwlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOworCXhlbl9wZm5fdCAqZnJhbWVzOworCXZv aWQgKnZhZGRyOworCWRtYV9hZGRyX3QgZGV2X2J1c19hZGRyOworfTsKKworaW50IGdudHRhYl9k bWFfYWxsb2NfcGFnZXMoc3RydWN0IGdudHRhYl9kbWFfYWxsb2NfYXJncyAqYXJncyk7CitpbnQg Z250dGFiX2RtYV9mcmVlX3BhZ2VzKHN0cnVjdCBnbnR0YWJfZG1hX2FsbG9jX2FyZ3MgKmFyZ3Mp OworI2VuZGlmCisKIGludCBnbnR0YWJfcGFnZXNfc2V0X3ByaXZhdGUoaW50IG5yX3BhZ2VzLCBz dHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKIHZvaWQgZ250dGFiX3BhZ2VzX2NsZWFyX3ByaXZhdGUoaW50 IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKIAotLSAKMi4xNy4xCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f65.google.com ([209.85.215.65]:42662 "EHLO mail-lf0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755826AbeFOG2K (ORCPT ); Fri, 15 Jun 2018 02:28:10 -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 v4 4/9] xen/grant-table: Allow allocating buffers suitable for DMA Date: Fri, 15 Jun 2018 09:27:48 +0300 Message-Id: <20180615062753.9229-5-andr2000@gmail.com> In-Reply-To: <20180615062753.9229-1-andr2000@gmail.com> References: <20180615062753.9229-1-andr2000@gmail.com> Sender: linux-media-owner@vger.kernel.org List-ID: From: Oleksandr Andrushchenko Extend grant table module API to allow allocating buffers that can be used for DMA operations and mapping foreign grant references on top of those. The resulting buffer is similar to the one allocated by the balloon driver in that proper memory reservation is made by ({increase|decrease}_reservation and VA mappings are updated if needed). This is useful for sharing foreign buffers with HW drivers which cannot work with scattered buffers provided by the balloon driver, but require DMAable memory instead. Signed-off-by: Oleksandr Andrushchenko Reviewed-by: Boris Ostrovsky --- drivers/xen/Kconfig | 14 ++++++ drivers/xen/grant-table.c | 97 +++++++++++++++++++++++++++++++++++++++ include/xen/grant_table.h | 18 ++++++++ 3 files changed, 129 insertions(+) diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index e5d0c28372ea..75e5c40f80a5 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -161,6 +161,20 @@ config XEN_GRANT_DEV_ALLOC to other domains. This can be used to implement frontend drivers or as part of an inter-domain shared memory channel. +config XEN_GRANT_DMA_ALLOC + bool "Allow allocating DMA capable buffers with grant reference module" + depends on XEN && HAS_DMA + help + Extends grant table module API to allow allocating DMA capable + buffers and mapping foreign grant references on top of it. + The resulting buffer is similar to one allocated by the balloon + driver in that proper memory reservation is made by + ({increase|decrease}_reservation and VA mappings are updated if + needed). + This is useful for sharing foreign buffers with HW drivers which + cannot work with scattered buffers provided by the balloon driver, + but require DMAable memory instead. + config SWIOTLB_XEN def_bool y select SWIOTLB diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c index dbb48a89e987..26ed498b5e6d 100644 --- a/drivers/xen/grant-table.c +++ b/drivers/xen/grant-table.c @@ -45,6 +45,9 @@ #include #include #include +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +#include +#endif #include #include @@ -57,6 +60,7 @@ #ifdef CONFIG_X86 #include #endif +#include #include #include @@ -838,6 +842,99 @@ void gnttab_free_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL_GPL(gnttab_free_pages); +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +/** + * gnttab_dma_alloc_pages - alloc DMAable pages suitable for grant mapping into + * @args: arguments to the function + */ +int gnttab_dma_alloc_pages(struct gnttab_dma_alloc_args *args) +{ + unsigned long pfn, start_pfn; + size_t size; + int i, ret; + + size = args->nr_pages << PAGE_SHIFT; + if (args->coherent) + args->vaddr = dma_alloc_coherent(args->dev, size, + &args->dev_bus_addr, + GFP_KERNEL | __GFP_NOWARN); + else + args->vaddr = dma_alloc_wc(args->dev, size, + &args->dev_bus_addr, + GFP_KERNEL | __GFP_NOWARN); + if (!args->vaddr) { + pr_debug("Failed to allocate DMA buffer of size %zu\n", size); + return -ENOMEM; + } + + start_pfn = __phys_to_pfn(args->dev_bus_addr); + for (pfn = start_pfn, i = 0; pfn < start_pfn + args->nr_pages; + pfn++, i++) { + struct page *page = pfn_to_page(pfn); + + args->pages[i] = page; + args->frames[i] = xen_page_to_gfn(page); + xenmem_reservation_scrub_page(page); + } + + xenmem_reservation_va_mapping_reset(args->nr_pages, args->pages); + + ret = xenmem_reservation_decrease(args->nr_pages, args->frames); + if (ret != args->nr_pages) { + pr_debug("Failed to decrease reservation for DMA buffer\n"); + ret = -EFAULT; + goto fail; + } + + ret = gnttab_pages_set_private(args->nr_pages, args->pages); + if (ret < 0) + goto fail; + + return 0; + +fail: + gnttab_dma_free_pages(args); + return ret; +} +EXPORT_SYMBOL_GPL(gnttab_dma_alloc_pages); + +/** + * gnttab_dma_free_pages - free DMAable pages + * @args: arguments to the function + */ +int gnttab_dma_free_pages(struct gnttab_dma_alloc_args *args) +{ + size_t size; + int i, ret; + + gnttab_pages_clear_private(args->nr_pages, args->pages); + + for (i = 0; i < args->nr_pages; i++) + args->frames[i] = page_to_xen_pfn(args->pages[i]); + + ret = xenmem_reservation_increase(args->nr_pages, args->frames); + if (ret != args->nr_pages) { + pr_debug("Failed to decrease reservation for DMA buffer\n"); + ret = -EFAULT; + } else { + ret = 0; + } + + xenmem_reservation_va_mapping_update(args->nr_pages, args->pages, + args->frames); + + size = args->nr_pages << PAGE_SHIFT; + if (args->coherent) + dma_free_coherent(args->dev, size, + args->vaddr, args->dev_bus_addr); + else + dma_free_wc(args->dev, size, + args->vaddr, args->dev_bus_addr); + return ret; +} +EXPORT_SYMBOL_GPL(gnttab_dma_free_pages); +#endif + /* Handling of paged out grant targets (GNTST_eagain) */ #define MAX_DELAY 256 static inline void diff --git a/include/xen/grant_table.h b/include/xen/grant_table.h index de03f2542bb7..9bc5bc07d4d3 100644 --- a/include/xen/grant_table.h +++ b/include/xen/grant_table.h @@ -198,6 +198,24 @@ void gnttab_free_auto_xlat_frames(void); int gnttab_alloc_pages(int nr_pages, struct page **pages); void gnttab_free_pages(int nr_pages, struct page **pages); +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +struct gnttab_dma_alloc_args { + /* Device for which DMA memory will be/was allocated. */ + struct device *dev; + /* If set then DMA buffer is coherent and write-combine otherwise. */ + bool coherent; + + int nr_pages; + struct page **pages; + xen_pfn_t *frames; + void *vaddr; + dma_addr_t dev_bus_addr; +}; + +int gnttab_dma_alloc_pages(struct gnttab_dma_alloc_args *args); +int gnttab_dma_free_pages(struct gnttab_dma_alloc_args *args); +#endif + int gnttab_pages_set_private(int nr_pages, struct page **pages); void gnttab_pages_clear_private(int nr_pages, struct page **pages); -- 2.17.1