From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Stultz Subject: [RFC][PATCH 1/5 v2] dma-buf: Add dma-buf heaps framework Date: Tue, 5 Mar 2019 12:54:29 -0800 Message-ID: <1551819273-640-2-git-send-email-john.stultz@linaro.org> References: <1551819273-640-1-git-send-email-john.stultz@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-pg1-x544.google.com (mail-pg1-x544.google.com [IPv6:2607:f8b0:4864:20::544]) by gabe.freedesktop.org (Postfix) with ESMTPS id A8F5989C16 for ; Tue, 5 Mar 2019 20:54:43 +0000 (UTC) Received: by mail-pg1-x544.google.com with SMTP id h11so6477199pgl.0 for ; Tue, 05 Mar 2019 12:54:43 -0800 (PST) In-Reply-To: <1551819273-640-1-git-send-email-john.stultz@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: lkml Cc: Greg KH , Chenbo Feng , Alistair Strachan , Liam Mark , "Andrew F. Davis" , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogIkFuZHJldyBGLiBEYXZpcyIgPGFmZEB0aS5jb20+CgpUaGlzIGZyYW1ld29yayBhbGxv d3MgYSB1bmlmaWVkIHVzZXJzcGFjZSBpbnRlcmZhY2UgZm9yIGRtYS1idWYKZXhwb3J0ZXJzLCBh bGxvd2luZyB1c2VybGFuZCB0byBhbGxvY2F0ZSBzcGVjaWZpYyB0eXBlcyBvZgptZW1vcnkgZm9y IHVzZSBpbiBkbWEtYnVmIHNoYXJpbmcuCgpFYWNoIGhlYXAgaXMgZ2l2ZW4gaXRzIG93biBkZXZp Y2Ugbm9kZSwgd2hpY2ggYSB1c2VyIGNhbgphbGxvY2F0ZSBhIGRtYS1idWYgZmQgZnJvbSB1c2lu ZyB0aGUgRE1BX0hFQVBfSU9DX0FMTE9DLgoKVGhpcyBjb2RlIGlzIGFuIGV2b2x1aXRvbiBvZiB0 aGUgQW5kcm9pZCBJT04gaW1wbGVtZW50YXRpb24sCmFuZCBhIGJpZyB0aGFua3MgaXMgZHVlIHRv IGl0cyBhdXRob3JzL21haW50YWluZXJzIG92ZXIgdGltZQpmb3IgdGhlaXIgZWZmb3J0OgogIFJl YmVjY2EgU2NodWx0eiBaYXZpbiwgQ29saW4gQ3Jvc3MsIEJlbmphbWluIEdhaWduYXJkLAogIExh dXJhIEFiYm90dCwgYW5kIG1hbnkgb3RoZXIgY29udHJpYnV0b3JzIQoKQ2M6IExhdXJhIEFiYm90 dCA8bGFiYm90dEByZWRoYXQuY29tPgpDYzogQmVuamFtaW4gR2FpZ25hcmQgPGJlbmphbWluLmdh aWduYXJkQGxpbmFyby5vcmc+CkNjOiBHcmVnIEtIIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9y Zz4KQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+CkNjOiBMaWFtIE1h cmsgPGxtYXJrQGNvZGVhdXJvcmEub3JnPgpDYzogQnJpYW4gU3RhcmtleSA8QnJpYW4uU3Rhcmtl eUBhcm0uY29tPgpDYzogQW5kcmV3IEYuIERhdmlzIDxhZmRAdGkuY29tPgpDYzogQ2hlbmJvIEZl bmcgPGZlbmdjQGdvb2dsZS5jb20+CkNjOiBBbGlzdGFpciBTdHJhY2hhbiA8YXN0cmFjaGFuQGdv b2dsZS5jb20+CkNjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnClNpZ25lZC1vZmYt Ynk6IEFuZHJldyBGLiBEYXZpcyA8YWZkQHRpLmNvbT4KW2pzdHVsdHo6IHJld29yZGVkIGNvbW1p dCBtZXNzYWdlLCBhbmQgbG90cyBvZiBjbGVhbnVwc10KU2lnbmVkLW9mZi1ieTogSm9obiBTdHVs dHogPGpvaG4uc3R1bHR6QGxpbmFyby5vcmc+Ci0tLQp2MjoKKiBGb2xkZWQgZG93biBmaXhlcyBJ IGhhZCBwcmV2aW91c2x5IHNoYXJlZCBpbiBpbXBsZW1lbnRpbmcKICBoZWFwcwoqIE1ha2UgZmxh Z3MgYSB1NjQgKFN1Z2dlc3RlZCBieSBMYXVyYSkKKiBBZGQgUEFHRV9BTElHTigpIGZpeCB0byB0 aGUgY29yZSBhbGxvYyBmdW5jaXRvbgoqIElPQ1RMIGZpeHVwcyBzdWdnZXN0ZWQgYnkgQnJpYW4K KiBBZGRlZCBmaXhlcyBzdWdnZXN0ZWQgYnkgQmVuamFtaW4KKiBSZW1vdmVkIGNvcmUgc3RhdHMg bWdtdCwgYXMgdGhhdCBzaG91bGQgYmUgaW1wbGVtZW50ZWQgYnkKICBwZXItaGVhcCBjb2RlCiog Q2hhbmdlZCBhbGxvYyB0byByZXR1cm4gYSBkbWEtYnVmIGZkLCByYXRoZXIgdGhlbiBhIGJ1ZmZl cgogIChhcyBpdCBzaW1wbGlmaWVzIGVycm9yIGhhbmRsaW5nKQotLS0KIE1BSU5UQUlORVJTICAg ICAgICAgICAgICAgICAgIHwgIDE2ICsrKysKIGRyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnICAgICAg IHwgICA4ICsrCiBkcml2ZXJzL2RtYS1idWYvTWFrZWZpbGUgICAgICB8ICAgMSArCiBkcml2ZXJz L2RtYS1idWYvZG1hLWhlYXAuYyAgICB8IDE5MSArKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysKIGluY2x1ZGUvbGludXgvZG1hLWhlYXAuaCAgICAgIHwgIDY1ICsrKysr KysrKysrKysrCiBpbmNsdWRlL3VhcGkvbGludXgvZG1hLWhlYXAuaCB8ICA1MiArKysrKysrKysr KysKIDYgZmlsZXMgY2hhbmdlZCwgMzMzIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2RtYS1idWYvZG1hLWhlYXAuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUv bGludXgvZG1hLWhlYXAuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvdWFwaS9saW51eC9k bWEtaGVhcC5oCgpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRleCBh YzJlNTE4Li5hNjYxZTE5IDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJTkVS UwpAQCAtNDYyMSw2ICs0NjIxLDIyIEBAIEY6CWluY2x1ZGUvbGludXgvKmZlbmNlLmgKIEY6CURv Y3VtZW50YXRpb24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdAogVDoJZ2l0IGdpdDovL2Fub25naXQu ZnJlZWRlc2t0b3Aub3JnL2RybS9kcm0tbWlzYwogCitETUEtQlVGIEhFQVBTIEZSQU1FV09SSwor TToJTGF1cmEgQWJib3R0IDxsYWJib3R0QHJlZGhhdC5jb20+CitSOglMaWFtIE1hcmsgPGxtYXJr QGNvZGVhdXJvcmEub3JnPgorUjoJQnJpYW4gU3RhcmtleSA8QnJpYW4uU3RhcmtleUBhcm0uY29t PgorUjoJIkFuZHJldyBGLiBEYXZpcyIgPGFmZEB0aS5jb20+CitSOglKb2huIFN0dWx0eiA8am9o bi5zdHVsdHpAbGluYXJvLm9yZz4KK1M6CU1haW50YWluZWQKK0w6CWxpbnV4LW1lZGlhQHZnZXIu a2VybmVsLm9yZworTDoJZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZworTDoJbGluYXJv LW1tLXNpZ0BsaXN0cy5saW5hcm8ub3JnIChtb2RlcmF0ZWQgZm9yIG5vbi1zdWJzY3JpYmVycykK K0Y6CWluY2x1ZGUvdWFwaS9saW51eC9kbWEtaGVhcC5oCitGOglpbmNsdWRlL2xpbnV4L2RtYS1o ZWFwLmgKK0Y6CWRyaXZlcnMvZG1hLWJ1Zi9kbWEtaGVhcC5jCitGOglkcml2ZXJzL2RtYS1idWYv aGVhcHMvKgorVDoJZ2l0IGdpdDovL2Fub25naXQuZnJlZWRlc2t0b3Aub3JnL2RybS9kcm0tbWlz YworCiBETUEgR0VORVJJQyBPRkZMT0FEIEVOR0lORSBTVUJTWVNURU0KIE06CVZpbm9kIEtvdWwg PHZrb3VsQGtlcm5lbC5vcmc+CiBMOglkbWFlbmdpbmVAdmdlci5rZXJuZWwub3JnCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2RtYS1idWYvS2NvbmZpZyBiL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnCmlu ZGV4IDJlNWEwZmEuLjA5YzYxZGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmln CisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9LY29uZmlnCkBAIC0zOSw0ICszOSwxMiBAQCBjb25maWcg VURNQUJVRgogCSAgQSBkcml2ZXIgdG8gbGV0IHVzZXJzcGFjZSB0dXJuIG1lbWZkIHJlZ2lvbnMg aW50byBkbWEtYnVmcy4KIAkgIFFlbXUgY2FuIHVzZSB0aGlzIHRvIGNyZWF0ZSBob3N0IGRtYWJ1 ZnMgZm9yIGd1ZXN0IGZyYW1lYnVmZmVycy4KIAorbWVudWNvbmZpZyBETUFCVUZfSEVBUFMKKwli b29sICJETUEtQlVGIFVzZXJsYW5kIE1lbW9yeSBIZWFwcyIKKwlzZWxlY3QgRE1BX1NIQVJFRF9C VUZGRVIKKwloZWxwCisJICBDaG9vc2UgdGhpcyBvcHRpb24gdG8gZW5hYmxlIHRoZSBETUEtQlVG IHVzZXJsYW5kIG1lbW9yeSBoZWFwcywKKwkgIHRoaXMgYWxsb3dzIHVzZXJzcGFjZSB0byBhbGxv Y2F0ZSBkbWEtYnVmcyB0aGF0IGNhbiBiZSBzaGFyZWQgYmV0d2VlbgorCSAgZHJpdmVycy4KKwog ZW5kbWVudQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlIGIvZHJpdmVycy9k bWEtYnVmL01ha2VmaWxlCmluZGV4IDA5MTNhNmMuLmIwMzMyZjEgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZG1hLWJ1Zi9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2RtYS1idWYvTWFrZWZpbGUKQEAgLTEs NCArMSw1IEBACiBvYmoteSA6PSBkbWEtYnVmLm8gZG1hLWZlbmNlLm8gZG1hLWZlbmNlLWFycmF5 Lm8gcmVzZXJ2YXRpb24ubyBzZXFuby1mZW5jZS5vCitvYmotJChDT05GSUdfRE1BQlVGX0hFQVBT KQkrPSBkbWEtaGVhcC5vCiBvYmotJChDT05GSUdfU1lOQ19GSUxFKQkJKz0gc3luY19maWxlLm8K IG9iai0kKENPTkZJR19TV19TWU5DKQkJKz0gc3dfc3luYy5vIHN5bmNfZGVidWcubwogb2JqLSQo Q09ORklHX1VETUFCVUYpCQkrPSB1ZG1hYnVmLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1 Zi9kbWEtaGVhcC5jIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1oZWFwLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uMTRiMzk3NQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv ZG1hLWJ1Zi9kbWEtaGVhcC5jCkBAIC0wLDAgKzEsMTkxIEBACisvLyBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogR1BMLTIuMAorLyoKKyAqIEZyYW1ld29yayBmb3IgdXNlcnNwYWNlIERNQS1CVUYg YWxsb2NhdGlvbnMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlLCBJbmMuCisgKiBD b3B5cmlnaHQgKEMpIDIwMTkgTGluYXJvIEx0ZC4KKyAqLworCisjaW5jbHVkZSA8bGludXgvY2Rl di5oPgorI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2Uu aD4KKyNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLmg+CisjaW5jbHVkZSA8bGludXgvZXJyLmg+Cisj aW5jbHVkZSA8bGludXgvaWRyLmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisKKyNpbmNsdWRlIDxs aW51eC9kbWEtaGVhcC5oPgorI2luY2x1ZGUgPHVhcGkvbGludXgvZG1hLWhlYXAuaD4KKworI2Rl ZmluZSBERVZOQU1FICJkbWFfaGVhcCIKKworI2RlZmluZSBOVU1fSEVBUF9NSU5PUlMgMTI4Citz dGF0aWMgREVGSU5FX0lEUihkbWFfaGVhcF9pZHIpOworc3RhdGljIERFRklORV9NVVRFWChtaW5v cl9sb2NrKTsgLyogUHJvdGVjdCBpZHIgYWNjZXNzZXMgKi8KKworZGV2X3QgZG1hX2hlYXBfZGV2 dDsKK3N0cnVjdCBjbGFzcyAqZG1hX2hlYXBfY2xhc3M7CitzdHJ1Y3QgbGlzdF9oZWFkIGRtYV9o ZWFwX2xpc3Q7CitzdHJ1Y3QgZGVudHJ5ICpkbWFfaGVhcF9kZWJ1Z19yb290OworCitzdGF0aWMg aW50IGRtYV9oZWFwX2J1ZmZlcl9hbGxvYyhzdHJ1Y3QgZG1hX2hlYXAgKmhlYXAsIHNpemVfdCBs ZW4sCisJCQkJIHVuc2lnbmVkIGludCBmbGFncykKK3sKKwlsZW4gPSBQQUdFX0FMSUdOKGxlbik7 CisJaWYgKCFsZW4pCisJCXJldHVybiAtRUlOVkFMOworCisJcmV0dXJuIGhlYXAtPm9wcy0+YWxs b2NhdGUoaGVhcCwgbGVuLCBmbGFncyk7Cit9CisKK3N0YXRpYyBpbnQgZG1hX2hlYXBfb3Blbihz dHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkKK3sKKwlzdHJ1Y3QgZG1hX2hl YXAgKmhlYXA7CisKKwltdXRleF9sb2NrKCZtaW5vcl9sb2NrKTsKKwloZWFwID0gaWRyX2ZpbmQo JmRtYV9oZWFwX2lkciwgaW1pbm9yKGlub2RlKSk7CisJbXV0ZXhfdW5sb2NrKCZtaW5vcl9sb2Nr KTsKKwlpZiAoIWhlYXApIHsKKwkJcHJfZXJyKCJkbWFfaGVhcDogbWlub3IgJWQgdW5rbm93bi5c biIsIGltaW5vcihpbm9kZSkpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwkvKiBpbnN0YW5j ZSBkYXRhIGFzIGNvbnRleHQgKi8KKwlmaWxwLT5wcml2YXRlX2RhdGEgPSBoZWFwOworCW5vbnNl ZWthYmxlX29wZW4oaW5vZGUsIGZpbHApOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQg ZG1hX2hlYXBfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCkK K3sKKwlmaWxwLT5wcml2YXRlX2RhdGEgPSBOVUxMOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRp YyBsb25nIGRtYV9oZWFwX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBpbnQgY21k LAorCQkJICAgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3dpdGNoIChjbWQpIHsKKwljYXNlIERN QV9IRUFQX0lPQ19BTExPQzoKKwl7CisJCXN0cnVjdCBkbWFfaGVhcF9hbGxvY2F0aW9uX2RhdGEg aGVhcF9hbGxvY2F0aW9uOworCQlzdHJ1Y3QgZG1hX2hlYXAgKmhlYXAgPSBmaWxwLT5wcml2YXRl X2RhdGE7CisJCWludCBmZDsKKworCQlpZiAoY29weV9mcm9tX3VzZXIoJmhlYXBfYWxsb2NhdGlv biwgKHZvaWQgX191c2VyICopYXJnLAorCQkJCSAgIHNpemVvZihoZWFwX2FsbG9jYXRpb24pKSkK KwkJCXJldHVybiAtRUZBVUxUOworCisJCWlmIChoZWFwX2FsbG9jYXRpb24uZmQgfHwKKwkJICAg IGhlYXBfYWxsb2NhdGlvbi5yZXNlcnZlZDAgfHwKKwkJICAgIGhlYXBfYWxsb2NhdGlvbi5yZXNl cnZlZDEgfHwKKwkJICAgIGhlYXBfYWxsb2NhdGlvbi5yZXNlcnZlZDIpIHsKKwkJCXByX3dhcm5f b25jZSgiZG1hX2hlYXA6IGlvY3RsIGRhdGEgbm90IHZhbGlkXG4iKTsKKwkJCXJldHVybiAtRUlO VkFMOworCQl9CisJCWlmIChoZWFwX2FsbG9jYXRpb24uZmxhZ3MgJiB+RE1BX0hFQVBfVkFMSURf RkxBR1MpIHsKKwkJCXByX3dhcm5fb25jZSgiZG1hX2hlYXA6IGZsYWdzIGhhcyBpbnZhbGlkIG9y IHVuc3VwcG9ydGVkIGZsYWdzIHNldFxuIik7CisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJfQorCisJ CWZkID0gZG1hX2hlYXBfYnVmZmVyX2FsbG9jKGhlYXAsIGhlYXBfYWxsb2NhdGlvbi5sZW4sCisJ CQkJCSAgIGhlYXBfYWxsb2NhdGlvbi5mbGFncyk7CisJCWlmIChmZCA8IDApCisJCQlyZXR1cm4g ZmQ7CisKKwkJaGVhcF9hbGxvY2F0aW9uLmZkID0gZmQ7CisKKwkJaWYgKGNvcHlfdG9fdXNlcigo dm9pZCBfX3VzZXIgKilhcmcsICZoZWFwX2FsbG9jYXRpb24sCisJCQkJIHNpemVvZihoZWFwX2Fs bG9jYXRpb24pKSkKKwkJCXJldHVybiAtRUZBVUxUOworCisJCWJyZWFrOworCX0KKwlkZWZhdWx0 OgorCQlyZXR1cm4gLUVOT1RUWTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0 IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgZG1hX2hlYXBfZm9wcyA9IHsKKwkub3duZXIgICAgICAg ICAgPSBUSElTX01PRFVMRSwKKwkub3BlbgkJPSBkbWFfaGVhcF9vcGVuLAorCS5yZWxlYXNlCT0g ZG1hX2hlYXBfcmVsZWFzZSwKKwkudW5sb2NrZWRfaW9jdGwgPSBkbWFfaGVhcF9pb2N0bCwKKyNp ZmRlZiBDT05GSUdfQ09NUEFUCisJLmNvbXBhdF9pb2N0bAk9IGRtYV9oZWFwX2lvY3RsLAorI2Vu ZGlmCit9OworCitpbnQgZG1hX2hlYXBfYWRkKHN0cnVjdCBkbWFfaGVhcCAqaGVhcCkKK3sKKwlz dHJ1Y3QgZGV2aWNlICpkZXZfcmV0OworCWludCByZXQ7CisKKwlpZiAoIWhlYXAtPm5hbWUgfHwg IXN0cmNtcChoZWFwLT5uYW1lLCAiIikpIHsKKwkJcHJfZXJyKCJkbWFfaGVhcDogQ2Fubm90IGFk ZCBoZWFwIHdpdGhvdXQgYSBuYW1lXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYg KCFoZWFwLT5vcHMgfHwgIWhlYXAtPm9wcy0+YWxsb2NhdGUpIHsKKwkJcHJfZXJyKCJkbWFfaGVh cDogQ2Fubm90IGFkZCBoZWFwIHdpdGggaW52YWxpZCBvcHMgc3RydWN0XG4iKTsKKwkJcmV0dXJu IC1FSU5WQUw7CisJfQorCisJLyogRmluZCB1bnVzZWQgbWlub3IgbnVtYmVyICovCisJbXV0ZXhf bG9jaygmbWlub3JfbG9jayk7CisJcmV0ID0gaWRyX2FsbG9jKCZkbWFfaGVhcF9pZHIsIGhlYXAs IDAsIE5VTV9IRUFQX01JTk9SUywgR0ZQX0tFUk5FTCk7CisJbXV0ZXhfdW5sb2NrKCZtaW5vcl9s b2NrKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcl9lcnIoImRtYV9oZWFwOiBVbmFibGUgdG8gZ2V0 IG1pbm9yIG51bWJlciBmb3IgaGVhcFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCWhlYXAtPm1p bm9yID0gcmV0OworCisJLyogQ3JlYXRlIGRldmljZSAqLworCWhlYXAtPmhlYXBfZGV2dCA9IE1L REVWKE1BSk9SKGRtYV9oZWFwX2RldnQpLCBoZWFwLT5taW5vcik7CisJZGV2X3JldCA9IGRldmlj ZV9jcmVhdGUoZG1hX2hlYXBfY2xhc3MsCisJCQkJTlVMTCwKKwkJCQloZWFwLT5oZWFwX2RldnQs CisJCQkJTlVMTCwKKwkJCQloZWFwLT5uYW1lKTsKKwlpZiAoSVNfRVJSKGRldl9yZXQpKSB7CisJ CXByX2VycigiZG1hX2hlYXA6IFVuYWJsZSB0byBjcmVhdGUgY2hhciBkZXZpY2VcbiIpOworCQly ZXR1cm4gUFRSX0VSUihkZXZfcmV0KTsKKwl9CisKKwkvKiBBZGQgZGV2aWNlICovCisJY2Rldl9p bml0KCZoZWFwLT5oZWFwX2NkZXYsICZkbWFfaGVhcF9mb3BzKTsKKwlyZXQgPSBjZGV2X2FkZCgm aGVhcC0+aGVhcF9jZGV2LCBkbWFfaGVhcF9kZXZ0LCBOVU1fSEVBUF9NSU5PUlMpOworCWlmIChy ZXQgPCAwKSB7CisJCWRldmljZV9kZXN0cm95KGRtYV9oZWFwX2NsYXNzLCBoZWFwLT5oZWFwX2Rl dnQpOworCQlwcl9lcnIoImRtYV9oZWFwOiBVbmFibGUgdG8gYWRkIGNoYXIgZGV2aWNlXG4iKTsK KwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKK30KK0VYUE9SVF9TWU1CT0woZG1hX2hl YXBfYWRkKTsKKworc3RhdGljIGludCBkbWFfaGVhcF9pbml0KHZvaWQpCit7CisJaW50IHJldDsK KworCXJldCA9IGFsbG9jX2NocmRldl9yZWdpb24oJmRtYV9oZWFwX2RldnQsIDAsIE5VTV9IRUFQ X01JTk9SUywgREVWTkFNRSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWRtYV9oZWFw X2NsYXNzID0gY2xhc3NfY3JlYXRlKFRISVNfTU9EVUxFLCBERVZOQU1FKTsKKwlpZiAoSVNfRVJS KGRtYV9oZWFwX2NsYXNzKSkgeworCQl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24oZG1hX2hlYXBf ZGV2dCwgTlVNX0hFQVBfTUlOT1JTKTsKKwkJcmV0dXJuIFBUUl9FUlIoZG1hX2hlYXBfY2xhc3Mp OworCX0KKworCXJldHVybiAwOworfQorc3Vic3lzX2luaXRjYWxsKGRtYV9oZWFwX2luaXQpOwpk aWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWEtaGVhcC5oIGIvaW5jbHVkZS9saW51eC9kbWEt aGVhcC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVkODZhOGUKLS0tIC9k ZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L2RtYS1oZWFwLmgKQEAgLTAsMCArMSw2NSBAQAor LyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8KKy8qCisgKiBETUFCVUYgSGVh cHMgQWxsb2NhdGlvbiBJbmZyYXN0cnVjdHVyZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBH b29nbGUsIEluYy4KKyAqIENvcHlyaWdodCAoQykgMjAxOSBMaW5hcm8gTHRkLgorICovCisKKyNp Zm5kZWYgX0RNQV9IRUFQU19ICisjZGVmaW5lIF9ETUFfSEVBUFNfSAorCisjaW5jbHVkZSA8bGlu dXgvY2Rldi5oPgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKy8qKgorICogc3RydWN0IGRt YV9oZWFwX2J1ZmZlciAtIG1ldGFkYXRhIGZvciBhIHBhcnRpY3VsYXIgYnVmZmVyCisgKiBAaGVh cDoJCWJhY2sgcG9pbnRlciB0byB0aGUgaGVhcCB0aGUgYnVmZmVyIGNhbWUgZnJvbQorICogQGRt YWJ1ZjoJCWJhY2tpbmcgZG1hLWJ1ZiBmb3IgdGhpcyBidWZmZXIKKyAqIEBzaXplOgkJc2l6ZSBv ZiB0aGUgYnVmZmVyCisgKiBAZmxhZ3M6CQlidWZmZXIgc3BlY2lmaWMgZmxhZ3MKKyAqLworc3Ry dWN0IGRtYV9oZWFwX2J1ZmZlciB7CisJc3RydWN0IGRtYV9oZWFwICpoZWFwOworCXN0cnVjdCBk bWFfYnVmICpkbWFidWY7CisJc2l6ZV90IHNpemU7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKK307 CisKKy8qKgorICogc3RydWN0IGRtYV9oZWFwIC0gcmVwcmVzZW50cyBhIGRtYWJ1ZiBoZWFwIGlu IHRoZSBzeXN0ZW0KKyAqIEBuYW1lOgkJdXNlZCBmb3IgZGVidWdnaW5nL2RldmljZS1ub2RlIG5h bWUKKyAqIEBvcHM6CQlvcHMgc3RydWN0IGZvciB0aGlzIGhlYXAKKyAqIEBtaW5vcgkJbWlub3Ig bnVtYmVyIG9mIHRoaXMgaGVhcCBkZXZpY2UKKyAqIEBoZWFwX2RldnQJCWhlYXAgZGV2aWNlIG5v ZGUKKyAqIEBoZWFwX2NkZXYJCWhlYXAgY2hhciBkZXZpY2UKKyAqCisgKiBSZXByZXNlbnRzIGEg aGVhcCBvZiBtZW1vcnkgZnJvbSB3aGljaCBidWZmZXJzIGNhbiBiZSBtYWRlLgorICovCitzdHJ1 Y3QgZG1hX2hlYXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJc3RydWN0IGRtYV9oZWFwX29wcyAq b3BzOworCXVuc2lnbmVkIGludCBtaW5vcjsKKwlkZXZfdCBoZWFwX2RldnQ7CisJc3RydWN0IGNk ZXYgaGVhcF9jZGV2OworfTsKKworLyoqCisgKiBzdHJ1Y3QgZG1hX2hlYXBfb3BzIC0gb3BzIHRv IG9wZXJhdGUgb24gYSBnaXZlbiBoZWFwCisgKiBAYWxsb2NhdGU6CQlhbGxvY2F0ZSBkbWFidWYg YW5kIHJldHVybiBmZAorICoKKyAqIGFsbG9jYXRlIHJldHVybnMgZG1hYnVmIGZkICBvbiBzdWNj ZXNzLCAtZXJybm8gb24gZXJyb3IuCisgKi8KK3N0cnVjdCBkbWFfaGVhcF9vcHMgeworCWludCAo KmFsbG9jYXRlKShzdHJ1Y3QgZG1hX2hlYXAgKmhlYXAsCisJCQl1bnNpZ25lZCBsb25nIGxlbiwK KwkJCXVuc2lnbmVkIGxvbmcgZmxhZ3MpOworfTsKKworLyoqCisgKiBkbWFfaGVhcF9hZGQgLSBh ZGRzIGEgaGVhcCB0byBkbWFidWYgaGVhcHMKKyAqIEBoZWFwOgkJdGhlIGhlYXAgdG8gYWRkCisg Ki8KK2ludCBkbWFfaGVhcF9hZGQoc3RydWN0IGRtYV9oZWFwICpoZWFwKTsKKworI2VuZGlmIC8q IF9ETUFfSEVBUFNfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L2RtYS1oZWFw LmggYi9pbmNsdWRlL3VhcGkvbGludXgvZG1hLWhlYXAuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi43NWM1ZDNmCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS91YXBpL2xp bnV4L2RtYS1oZWFwLmgKQEAgLTAsMCArMSw1MiBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAgKi8KKy8qCisgKiBETUFCVUYgSGVhcHMgVXNlcnNwYWNlIEFQSQorICoKKyAq IENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUsIEluYy4KKyAqIENvcHlyaWdodCAoQykgMjAxOSBM aW5hcm8gTHRkLgorICovCisjaWZuZGVmIF9VQVBJX0xJTlVYX0RNQUJVRl9QT09MX0gKKyNkZWZp bmUgX1VBUElfTElOVVhfRE1BQlVGX1BPT0xfSAorCisjaW5jbHVkZSA8bGludXgvaW9jdGwuaD4K KyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorCisvKioKKyAqIERPQzogRE1BQlVGIEhlYXBzIFVz ZXJzcGFjZSBBUEkKKyAqCisgKi8KKworLyogQ3VycmVudGx5IG5vIGZsYWdzICovCisjZGVmaW5l IERNQV9IRUFQX1ZBTElEX0ZMQUdTICgwKQorCisvKioKKyAqIHN0cnVjdCBkbWFfaGVhcF9hbGxv Y2F0aW9uX2RhdGEgLSBtZXRhZGF0YSBwYXNzZWQgZnJvbSB1c2Vyc3BhY2UgZm9yCisgKiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWxsb2NhdGlvbnMKKyAqIEBsZW46CQlz aXplIG9mIHRoZSBhbGxvY2F0aW9uCisgKiBAZmxhZ3M6CQlmbGFncyBwYXNzZWQgdG8gcG9vbAor ICogQGZkOgkJCXdpbGwgYmUgcG9wdWxhdGVkIHdpdGggYSBmZCB3aGljaCBwcm92ZGVzIHRoZQor ICoJCQloYW5kbGUgdG8gdGhlIGFsbG9jYXRlZCBkbWEtYnVmCisgKgorICogUHJvdmlkZWQgYnkg dXNlcnNwYWNlIGFzIGFuIGFyZ3VtZW50IHRvIHRoZSBpb2N0bAorICovCitzdHJ1Y3QgZG1hX2hl YXBfYWxsb2NhdGlvbl9kYXRhIHsKKwlfX3U2NCBsZW47CisJX191NjQgZmxhZ3M7CisJX191MzIg ZmQ7CisJX191MzIgcmVzZXJ2ZWQwOworCV9fdTMyIHJlc2VydmVkMTsKKwlfX3UzMiByZXNlcnZl ZDI7Cit9OworCisjZGVmaW5lIERNQV9IRUFQX0lPQ19NQUdJQwkJJ0gnCisKKy8qKgorICogRE9D OiBETUFfSEVBUF9JT0NfQUxMT0MgLSBhbGxvY2F0ZSBtZW1vcnkgZnJvbSBwb29sCisgKgorICog VGFrZXMgYW4gZG1hX2hlYXBfYWxsb2NhdGlvbl9kYXRhIHN0cnVjdCBhbmQgcmV0dXJucyBpdCB3 aXRoIHRoZSBmZCBmaWVsZAorICogcG9wdWxhdGVkIHdpdGggdGhlIGRtYWJ1ZiBoYW5kbGUgb2Yg dGhlIGFsbG9jYXRpb24uCisgKi8KKyNkZWZpbmUgRE1BX0hFQVBfSU9DX0FMTE9DCV9JT1dSKERN QV9IRUFQX0lPQ19NQUdJQywgMCwgXAorCQkJCSAgICAgIHN0cnVjdCBkbWFfaGVhcF9hbGxvY2F0 aW9uX2RhdGEpCisKKyNlbmRpZiAvKiBfVUFQSV9MSU5VWF9ETUFCVUZfUE9PTF9IICovCi0tIAoy LjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJp LWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBz Oi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs 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=-14.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham 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 9207FC43381 for ; Tue, 5 Mar 2019 20:54:49 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 57D102075B for ; Tue, 5 Mar 2019 20:54:49 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="DvBnCV+V" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728467AbfCEUyr (ORCPT ); Tue, 5 Mar 2019 15:54:47 -0500 Received: from mail-pg1-f196.google.com ([209.85.215.196]:45935 "EHLO mail-pg1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726210AbfCEUyo (ORCPT ); Tue, 5 Mar 2019 15:54:44 -0500 Received: by mail-pg1-f196.google.com with SMTP id 125so6226070pgc.12 for ; Tue, 05 Mar 2019 12:54:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=BG94J8n4JZbnxfrekiwpt69zPxSc7JCbOZr/oAI9WHA=; b=DvBnCV+VDj6+dTQ3JqYAVu46uY16fx5QHPkEp0TQbCH9iJDLmAAAmUPVlNyfhOA3Ot jRcM94UeZmqSG17v3aKd4pggxnbM38DAL8k6azBaWy756ZTGdlovhWnCPUW6iNVvf4rC 1I4YhSK3IvAsVj2RktHrg/beONtZf1eRla9GTJwRPog+8SCK7nzk/Mb7PatfthTChnjC OM7U3DUq45P2tw19RCx8QcjRrtKjF019N5ySCUmbZUqJw8WvyXb18eoHbw5XabTbtbmL dvv8RYA2TgjjXwf9K45/B39jMIavUe9Hq7eyEEPgwa++YdiRLLmVr+ptEx0i4MaQ3Ye0 x68Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=BG94J8n4JZbnxfrekiwpt69zPxSc7JCbOZr/oAI9WHA=; b=O2a0E0EYEX36tRyP17MuUWhpORBcWip0ERDKNfGA+gK4UZ+uReZGPlqaLvruDu2WEF sSU+5nng26bhgS/c55UdKpj5d7MPsVVAkFzv4QwwKElZsJ33XqT9tjyGWFBeGsb3Dyrm 4sexJe0iXwuACxbjenRwASZH8RQg5Yjy44sLwHnqDfOxfiLqKPy3lOFKgRL81pp0wFqs pVoZyv+xffmJP+i7/iZ9RvPj5CpsGpkeZIJfkoqbxyDaElrAqkYeBwIyD4ncQ94F/0kA WHdOX/vCZGQOMFZ7xDLAbDNurTFyCV7BQmCP77MzPKaArvXhCZkuKutlOdoeRarxkVzq zYcw== X-Gm-Message-State: APjAAAWSWT6tcvKxDyRe1cmHyfdq8XR8WXkrj6CLqiTIYX3+tYAYYwns x+X8Gb66g8Ue36Ez5Q1rL3pqRvYknOo= X-Google-Smtp-Source: APXvYqwhBQzKMB98Agxzd4hdnG+gvvWsB/MpP1KzDsieRzFUOBTztn3nv3OM7smscsoV9DNO6/GoYg== X-Received: by 2002:a17:902:380c:: with SMTP id l12mr3150482plc.326.1551819283088; Tue, 05 Mar 2019 12:54:43 -0800 (PST) Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id i4sm13411788pfo.158.2019.03.05.12.54.41 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 05 Mar 2019 12:54:41 -0800 (PST) From: John Stultz To: lkml Cc: "Andrew F. Davis" , Laura Abbott , Benjamin Gaignard , Greg KH , Sumit Semwal , Liam Mark , Brian Starkey , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org, John Stultz Subject: [RFC][PATCH 1/5 v2] dma-buf: Add dma-buf heaps framework Date: Tue, 5 Mar 2019 12:54:29 -0800 Message-Id: <1551819273-640-2-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1551819273-640-1-git-send-email-john.stultz@linaro.org> References: <1551819273-640-1-git-send-email-john.stultz@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: "Andrew F. Davis" This framework allows a unified userspace interface for dma-buf exporters, allowing userland to allocate specific types of memory for use in dma-buf sharing. Each heap is given its own device node, which a user can allocate a dma-buf fd from using the DMA_HEAP_IOC_ALLOC. This code is an evoluiton of the Android ION implementation, and a big thanks is due to its authors/maintainers over time for their effort: Rebecca Schultz Zavin, Colin Cross, Benjamin Gaignard, Laura Abbott, and many other contributors! Cc: Laura Abbott Cc: Benjamin Gaignard Cc: Greg KH Cc: Sumit Semwal Cc: Liam Mark Cc: Brian Starkey Cc: Andrew F. Davis Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Signed-off-by: Andrew F. Davis [jstultz: reworded commit message, and lots of cleanups] Signed-off-by: John Stultz --- v2: * Folded down fixes I had previously shared in implementing heaps * Make flags a u64 (Suggested by Laura) * Add PAGE_ALIGN() fix to the core alloc funciton * IOCTL fixups suggested by Brian * Added fixes suggested by Benjamin * Removed core stats mgmt, as that should be implemented by per-heap code * Changed alloc to return a dma-buf fd, rather then a buffer (as it simplifies error handling) --- MAINTAINERS | 16 ++++ drivers/dma-buf/Kconfig | 8 ++ drivers/dma-buf/Makefile | 1 + drivers/dma-buf/dma-heap.c | 191 ++++++++++++++++++++++++++++++++++++++++++ include/linux/dma-heap.h | 65 ++++++++++++++ include/uapi/linux/dma-heap.h | 52 ++++++++++++ 6 files changed, 333 insertions(+) create mode 100644 drivers/dma-buf/dma-heap.c create mode 100644 include/linux/dma-heap.h create mode 100644 include/uapi/linux/dma-heap.h diff --git a/MAINTAINERS b/MAINTAINERS index ac2e518..a661e19 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4621,6 +4621,22 @@ F: include/linux/*fence.h F: Documentation/driver-api/dma-buf.rst T: git git://anongit.freedesktop.org/drm/drm-misc +DMA-BUF HEAPS FRAMEWORK +M: Laura Abbott +R: Liam Mark +R: Brian Starkey +R: "Andrew F. Davis" +R: John Stultz +S: Maintained +L: linux-media@vger.kernel.org +L: dri-devel@lists.freedesktop.org +L: linaro-mm-sig@lists.linaro.org (moderated for non-subscribers) +F: include/uapi/linux/dma-heap.h +F: include/linux/dma-heap.h +F: drivers/dma-buf/dma-heap.c +F: drivers/dma-buf/heaps/* +T: git git://anongit.freedesktop.org/drm/drm-misc + DMA GENERIC OFFLOAD ENGINE SUBSYSTEM M: Vinod Koul L: dmaengine@vger.kernel.org diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index 2e5a0fa..09c61db 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -39,4 +39,12 @@ config UDMABUF A driver to let userspace turn memfd regions into dma-bufs. Qemu can use this to create host dmabufs for guest framebuffers. +menuconfig DMABUF_HEAPS + bool "DMA-BUF Userland Memory Heaps" + select DMA_SHARED_BUFFER + help + Choose this option to enable the DMA-BUF userland memory heaps, + this allows userspace to allocate dma-bufs that can be shared between + drivers. + endmenu diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index 0913a6c..b0332f1 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -1,4 +1,5 @@ obj-y := dma-buf.o dma-fence.o dma-fence-array.o reservation.o seqno-fence.o +obj-$(CONFIG_DMABUF_HEAPS) += dma-heap.o obj-$(CONFIG_SYNC_FILE) += sync_file.o obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o obj-$(CONFIG_UDMABUF) += udmabuf.o diff --git a/drivers/dma-buf/dma-heap.c b/drivers/dma-buf/dma-heap.c new file mode 100644 index 0000000..14b3975 --- /dev/null +++ b/drivers/dma-buf/dma-heap.c @@ -0,0 +1,191 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Framework for userspace DMA-BUF allocations + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define DEVNAME "dma_heap" + +#define NUM_HEAP_MINORS 128 +static DEFINE_IDR(dma_heap_idr); +static DEFINE_MUTEX(minor_lock); /* Protect idr accesses */ + +dev_t dma_heap_devt; +struct class *dma_heap_class; +struct list_head dma_heap_list; +struct dentry *dma_heap_debug_root; + +static int dma_heap_buffer_alloc(struct dma_heap *heap, size_t len, + unsigned int flags) +{ + len = PAGE_ALIGN(len); + if (!len) + return -EINVAL; + + return heap->ops->allocate(heap, len, flags); +} + +static int dma_heap_open(struct inode *inode, struct file *filp) +{ + struct dma_heap *heap; + + mutex_lock(&minor_lock); + heap = idr_find(&dma_heap_idr, iminor(inode)); + mutex_unlock(&minor_lock); + if (!heap) { + pr_err("dma_heap: minor %d unknown.\n", iminor(inode)); + return -ENODEV; + } + + /* instance data as context */ + filp->private_data = heap; + nonseekable_open(inode, filp); + + return 0; +} + +static int dma_heap_release(struct inode *inode, struct file *filp) +{ + filp->private_data = NULL; + + return 0; +} + +static long dma_heap_ioctl(struct file *filp, unsigned int cmd, + unsigned long arg) +{ + switch (cmd) { + case DMA_HEAP_IOC_ALLOC: + { + struct dma_heap_allocation_data heap_allocation; + struct dma_heap *heap = filp->private_data; + int fd; + + if (copy_from_user(&heap_allocation, (void __user *)arg, + sizeof(heap_allocation))) + return -EFAULT; + + if (heap_allocation.fd || + heap_allocation.reserved0 || + heap_allocation.reserved1 || + heap_allocation.reserved2) { + pr_warn_once("dma_heap: ioctl data not valid\n"); + return -EINVAL; + } + if (heap_allocation.flags & ~DMA_HEAP_VALID_FLAGS) { + pr_warn_once("dma_heap: flags has invalid or unsupported flags set\n"); + return -EINVAL; + } + + fd = dma_heap_buffer_alloc(heap, heap_allocation.len, + heap_allocation.flags); + if (fd < 0) + return fd; + + heap_allocation.fd = fd; + + if (copy_to_user((void __user *)arg, &heap_allocation, + sizeof(heap_allocation))) + return -EFAULT; + + break; + } + default: + return -ENOTTY; + } + + return 0; +} + +static const struct file_operations dma_heap_fops = { + .owner = THIS_MODULE, + .open = dma_heap_open, + .release = dma_heap_release, + .unlocked_ioctl = dma_heap_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = dma_heap_ioctl, +#endif +}; + +int dma_heap_add(struct dma_heap *heap) +{ + struct device *dev_ret; + int ret; + + if (!heap->name || !strcmp(heap->name, "")) { + pr_err("dma_heap: Cannot add heap without a name\n"); + return -EINVAL; + } + + if (!heap->ops || !heap->ops->allocate) { + pr_err("dma_heap: Cannot add heap with invalid ops struct\n"); + return -EINVAL; + } + + /* Find unused minor number */ + mutex_lock(&minor_lock); + ret = idr_alloc(&dma_heap_idr, heap, 0, NUM_HEAP_MINORS, GFP_KERNEL); + mutex_unlock(&minor_lock); + if (ret < 0) { + pr_err("dma_heap: Unable to get minor number for heap\n"); + return ret; + } + heap->minor = ret; + + /* Create device */ + heap->heap_devt = MKDEV(MAJOR(dma_heap_devt), heap->minor); + dev_ret = device_create(dma_heap_class, + NULL, + heap->heap_devt, + NULL, + heap->name); + if (IS_ERR(dev_ret)) { + pr_err("dma_heap: Unable to create char device\n"); + return PTR_ERR(dev_ret); + } + + /* Add device */ + cdev_init(&heap->heap_cdev, &dma_heap_fops); + ret = cdev_add(&heap->heap_cdev, dma_heap_devt, NUM_HEAP_MINORS); + if (ret < 0) { + device_destroy(dma_heap_class, heap->heap_devt); + pr_err("dma_heap: Unable to add char device\n"); + return ret; + } + + return 0; +} +EXPORT_SYMBOL(dma_heap_add); + +static int dma_heap_init(void) +{ + int ret; + + ret = alloc_chrdev_region(&dma_heap_devt, 0, NUM_HEAP_MINORS, DEVNAME); + if (ret) + return ret; + + dma_heap_class = class_create(THIS_MODULE, DEVNAME); + if (IS_ERR(dma_heap_class)) { + unregister_chrdev_region(dma_heap_devt, NUM_HEAP_MINORS); + return PTR_ERR(dma_heap_class); + } + + return 0; +} +subsys_initcall(dma_heap_init); diff --git a/include/linux/dma-heap.h b/include/linux/dma-heap.h new file mode 100644 index 0000000..ed86a8e --- /dev/null +++ b/include/linux/dma-heap.h @@ -0,0 +1,65 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMABUF Heaps Allocation Infrastructure + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#ifndef _DMA_HEAPS_H +#define _DMA_HEAPS_H + +#include +#include + +/** + * struct dma_heap_buffer - metadata for a particular buffer + * @heap: back pointer to the heap the buffer came from + * @dmabuf: backing dma-buf for this buffer + * @size: size of the buffer + * @flags: buffer specific flags + */ +struct dma_heap_buffer { + struct dma_heap *heap; + struct dma_buf *dmabuf; + size_t size; + unsigned long flags; +}; + +/** + * struct dma_heap - represents a dmabuf heap in the system + * @name: used for debugging/device-node name + * @ops: ops struct for this heap + * @minor minor number of this heap device + * @heap_devt heap device node + * @heap_cdev heap char device + * + * Represents a heap of memory from which buffers can be made. + */ +struct dma_heap { + const char *name; + struct dma_heap_ops *ops; + unsigned int minor; + dev_t heap_devt; + struct cdev heap_cdev; +}; + +/** + * struct dma_heap_ops - ops to operate on a given heap + * @allocate: allocate dmabuf and return fd + * + * allocate returns dmabuf fd on success, -errno on error. + */ +struct dma_heap_ops { + int (*allocate)(struct dma_heap *heap, + unsigned long len, + unsigned long flags); +}; + +/** + * dma_heap_add - adds a heap to dmabuf heaps + * @heap: the heap to add + */ +int dma_heap_add(struct dma_heap *heap); + +#endif /* _DMA_HEAPS_H */ diff --git a/include/uapi/linux/dma-heap.h b/include/uapi/linux/dma-heap.h new file mode 100644 index 0000000..75c5d3f --- /dev/null +++ b/include/uapi/linux/dma-heap.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMABUF Heaps Userspace API + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ +#ifndef _UAPI_LINUX_DMABUF_POOL_H +#define _UAPI_LINUX_DMABUF_POOL_H + +#include +#include + +/** + * DOC: DMABUF Heaps Userspace API + * + */ + +/* Currently no flags */ +#define DMA_HEAP_VALID_FLAGS (0) + +/** + * struct dma_heap_allocation_data - metadata passed from userspace for + * allocations + * @len: size of the allocation + * @flags: flags passed to pool + * @fd: will be populated with a fd which provdes the + * handle to the allocated dma-buf + * + * Provided by userspace as an argument to the ioctl + */ +struct dma_heap_allocation_data { + __u64 len; + __u64 flags; + __u32 fd; + __u32 reserved0; + __u32 reserved1; + __u32 reserved2; +}; + +#define DMA_HEAP_IOC_MAGIC 'H' + +/** + * DOC: DMA_HEAP_IOC_ALLOC - allocate memory from pool + * + * Takes an dma_heap_allocation_data struct and returns it with the fd field + * populated with the dmabuf handle of the allocation. + */ +#define DMA_HEAP_IOC_ALLOC _IOWR(DMA_HEAP_IOC_MAGIC, 0, \ + struct dma_heap_allocation_data) + +#endif /* _UAPI_LINUX_DMABUF_POOL_H */ -- 2.7.4