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=-16.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,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 831B0C433E6 for ; Thu, 4 Mar 2021 23:20:22 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 4E6F665016 for ; Thu, 4 Mar 2021 23:20:22 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4E6F665016 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 2AA516EA80; Thu, 4 Mar 2021 23:20:18 +0000 (UTC) Received: from mail-pj1-x102d.google.com (mail-pj1-x102d.google.com [IPv6:2607:f8b0:4864:20::102d]) by gabe.freedesktop.org (Postfix) with ESMTPS id 788F36EA80 for ; Thu, 4 Mar 2021 23:20:16 +0000 (UTC) Received: by mail-pj1-x102d.google.com with SMTP id i14so371463pjz.4 for ; Thu, 04 Mar 2021 15:20:16 -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 :mime-version:content-transfer-encoding; bh=Fqm2n/WLZ4eT9r+Omo3xPTCh/D9fjyEDFpTAnWdfMxc=; b=F2XR2R9XnG6Pl2ygAmc7iKRvSRVWJp1v3xUfsM+HsXSJJnvSvA5KzoLoUBj+OcGM74 lvNhdnut/cgMAmLI6drQIqgMB0mwCmNAQpKRepM+Dg/i13va+NkjlGilhzigUw4SH5Z5 HgCwZxMi3+A7OOHOQvkNxxgIwZnHZBgFXgzqmFIp47vE8gW5tRHP6XObrk/LXZrwtO5t 1jrbCcShLjWUcXdU+6wN+HJt64p7TjmGmO0BeZ8cKvEvtwePgaKCpe8oVR1dU3Ik0cQP WNQuDFFmNyaqsObiDmYCfOrErqmT5mP+svooLmVV4hjROFRY1fEhdkW9Xy/DrMWprhvb +3ZQ== 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:mime-version:content-transfer-encoding; bh=Fqm2n/WLZ4eT9r+Omo3xPTCh/D9fjyEDFpTAnWdfMxc=; b=AoHL9QbMWjOKXFkFowTRRtE7E7cc0J44fni5GHxRUmPixpJ5/ti3a9gVvn9pNJglh4 WGHiPlLNNBDXx2XK0HGDua3vZ6Eh2SfebP/Cl34b1dTHAjWD3gQ+Qqm3103b5tDQyXKb gJRSBQhxkbuy6ulYunjc8BQipFnmHqPoYm+OR4B553bj9fluN2bD5/Kj9Jt/avFnl+m+ 1tOGo9u9GbQTJA2Fg9cXc+qUjFGtLJPSREWLkvBFTXK8p6j8POEMMTQPaOSpWnu1vnEc qNcecI3WX+tAu0XcOs79weEA9+rkI18zj71maxmeNgYZaF7k9mUwdnSpZ+T0Hg7TOVp8 CXPQ== X-Gm-Message-State: AOAM531Xn8E4fhz+J42Pyy89N8gRzn2bnyYI6VvvTVUSFArRUH/F0+qt bmEWJ1l48LHoCxNG9Cmhd2W1FA== X-Google-Smtp-Source: ABdhPJxP9czYFnGyxuCxK65IM0dMb7+TMQaJSX4C16Yezzu0bg5hD2R1LO24UOGgxEkMNX80XnkdVg== X-Received: by 2002:a17:90a:488f:: with SMTP id b15mr7010573pjh.53.1614900016079; Thu, 04 Mar 2021 15:20:16 -0800 (PST) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id u66sm429290pfc.72.2021.03.04.15.20.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Mar 2021 15:20:15 -0800 (PST) From: John Stultz To: lkml Subject: [PATCH v8 1/5] drm: Add a sharable drm page-pool implementation Date: Thu, 4 Mar 2021 23:20:07 +0000 Message-Id: <20210304232011.1479036-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210304232011.1479036-1-john.stultz@linaro.org> References: <20210304232011.1479036-1-john.stultz@linaro.org> MIME-Version: 1.0 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: dri-devel@lists.freedesktop.org, Sandeep Patil , Ezequiel Garcia , Robin Murphy , James Jones , Liam Mark , Laura Abbott , Chris Goldsworthy , Hridya Valsaraju , =?UTF-8?q?=C3=98rjan=20Eide?= , linux-media@vger.kernel.org, Suren Baghdasaryan , Christian Koenig , Daniel Mentz Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VGhpcyBhZGRzIGEgc2hyaW5rZXIgY29udHJvbGxlZCBwYWdlIHBvb2wsIGV4dHJhY3RlZApvdXQg b2YgdGhlIHR0bV9wb29sIGxvZ2ljLCBhbmQgYWJzdHJhY3RlZCBvdXQgYSBiaXQKc28gaXQgY2Fu IGJlIHVzZWQgYnkgb3RoZXIgbm9uLXR0bSBkcml2ZXJzLgoKQ2M6IERhbmllbCBWZXR0ZXIgPGRh bmllbEBmZndsbC5jaD4KQ2M6IENocmlzdGlhbiBLb2VuaWcgPGNocmlzdGlhbi5rb2VuaWdAYW1k LmNvbT4KQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+CkNjOiBMaWFt IE1hcmsgPGxtYXJrQGNvZGVhdXJvcmEub3JnPgpDYzogQ2hyaXMgR29sZHN3b3J0aHkgPGNnb2xk c3dvQGNvZGVhdXJvcmEub3JnPgpDYzogTGF1cmEgQWJib3R0IDxsYWJib3R0QGtlcm5lbC5vcmc+ CkNjOiBCcmlhbiBTdGFya2V5IDxCcmlhbi5TdGFya2V5QGFybS5jb20+CkNjOiBIcmlkeWEgVmFs c2FyYWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KQ2M6IFN1cmVuIEJhZ2hkYXNhcnlhbiA8c3VyZW5i QGdvb2dsZS5jb20+CkNjOiBTYW5kZWVwIFBhdGlsIDxzc3BhdGlsQGdvb2dsZS5jb20+CkNjOiBE YW5pZWwgTWVudHogPGRhbmllbG1lbnR6QGdvb2dsZS5jb20+CkNjOiDDmHJqYW4gRWlkZSA8b3Jq YW4uZWlkZUBhcm0uY29tPgpDYzogUm9iaW4gTXVycGh5IDxyb2Jpbi5tdXJwaHlAYXJtLmNvbT4K Q2M6IEV6ZXF1aWVsIEdhcmNpYSA8ZXplcXVpZWxAY29sbGFib3JhLmNvbT4KQ2M6IFNpbW9uIFNl ciA8Y29udGFjdEBlbWVyc2lvbi5mcj4KQ2M6IEphbWVzIEpvbmVzIDxqYWpvbmVzQG52aWRpYS5j b20+CkNjOiBsaW51eC1tZWRpYUB2Z2VyLmtlcm5lbC5vcmcKQ2M6IGRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKU2lnbmVkLW9mZi1ieTogSm9obiBTdHVsdHogPGpvaG4uc3R1bHR6QGxp bmFyby5vcmc+Ci0tLQp2ODoKKiBDb21wbGV0ZWx5IHJld3JpdHRlbiBmcm9tIHNjcmF0Y2gsIHVz aW5nIG9ubHkgdGhlCiAgdHRtX3Bvb2wgbG9naWMgc28gaXQgY2FuIGJlIGR1YWwgbGljZW5zZWQu Ci0tLQogZHJpdmVycy9ncHUvZHJtL0tjb25maWcgICAgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2Ry bS9NYWtlZmlsZSAgICB8ICAgMiArCiBkcml2ZXJzL2dwdS9kcm0vcGFnZV9wb29sLmMgfCAyMTQg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL2RybS9wYWdlX3Bv b2wuaCAgICAgfCAgNjUgKysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMjg1IGluc2VydGlv bnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcGFnZV9wb29sLmMKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2RybS9wYWdlX3Bvb2wuaAoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKaW5kZXggZTM5 MmE5MGNhNjg3Li43Y2JjZWNiOGY3ZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9LY29u ZmlnCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCkBAIC0xNzcsNiArMTc3LDEwIEBAIGNv bmZpZyBEUk1fRFBfQ0VDCiAJICBOb3RlOiBub3QgYWxsIGFkYXB0ZXJzIHN1cHBvcnQgdGhpcyBm ZWF0dXJlLCBhbmQgZXZlbiBmb3IgdGhvc2UKIAkgIHRoYXQgZG8gc3VwcG9ydCB0aGlzIHRoZXkg b2Z0ZW4gZG8gbm90IGhvb2sgdXAgdGhlIENFQyBwaW4uCiAKK2NvbmZpZyBEUk1fUEFHRV9QT09M CisJYm9vbAorCWRlcGVuZHMgb24gRFJNCisKIGNvbmZpZyBEUk1fVFRNCiAJdHJpc3RhdGUKIAlk ZXBlbmRzIG9uIERSTSAmJiBNTVUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmls ZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQppbmRleCA5MjZhZGVmMjg5ZGIuLjJkYzdiMmZl M2ZlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9NYWtlZmlsZQpAQCAtMzksNiArMzksOCBAQCBvYmotJChDT05GSUdfRFJNX1ZSQU1f SEVMUEVSKSArPSBkcm1fdnJhbV9oZWxwZXIubwogZHJtX3R0bV9oZWxwZXIteSA6PSBkcm1fZ2Vt X3R0bV9oZWxwZXIubwogb2JqLSQoQ09ORklHX0RSTV9UVE1fSEVMUEVSKSArPSBkcm1fdHRtX2hl bHBlci5vCiAKK2RybS0kKENPTkZJR19EUk1fUEFHRV9QT09MKSArPSBwYWdlX3Bvb2wubworCiBk cm1fa21zX2hlbHBlci15IDo9IGRybV9icmlkZ2VfY29ubmVjdG9yLm8gZHJtX2NydGNfaGVscGVy Lm8gZHJtX2RwX2hlbHBlci5vIFwKIAkJZHJtX2RzYy5vIGRybV9wcm9iZV9oZWxwZXIubyBcCiAJ CWRybV9wbGFuZV9oZWxwZXIubyBkcm1fZHBfbXN0X3RvcG9sb2d5Lm8gZHJtX2F0b21pY19oZWxw ZXIubyBcCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcGFnZV9wb29sLmMgYi9kcml2ZXJz L2dwdS9kcm0vcGFnZV9wb29sLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi5hNjBiOTU0Y2ZlMGYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcGFn ZV9wb29sLmMKQEAgLTAsMCArMSwyMTQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wIE9SIE1JVAorLyoKKyAqIFNoYXJhYmxlIHBhZ2UgcG9vbCBpbXBsZW1lbnRhdGlvbgor ICoKKyAqIEV4dHJhY3RlZCBmcm9tIGRyaXZlcnMvZ3B1L2RybS90dG0vdHRtX3Bvb2wuYworICog Q29weXJpZ2h0IDIwMjAgQWR2YW5jZWQgTWljcm8gRGV2aWNlcywgSW5jLgorICogQ29weXJpZ2h0 IDIwMjEgTGluYXJvIEx0ZC4KKyAqCisgKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBm cmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYQorICogY29weSBvZiB0aGlz IHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAiU29mdHdh cmUiKSwKKyAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGlu Y2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KKyAqIHRoZSByaWdodHMgdG8gdXNlLCBjb3B5LCBt b2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLAorICogYW5kL29y IHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdo b20gdGhlCisgKiBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhl IGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNl IGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCisgKiBhbGwg Y29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KKyAqCisgKiBU SEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkg S0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBU TyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisgKiBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiAgSU4gTk8gRVZFTlQgU0hBTEwK KyAqIFRIRSBDT1BZUklHSFQgSE9MREVSKFMpIE9SIEFVVEhPUihTKSBCRSBMSUFCTEUgRk9SIEFO WSBDTEFJTSwgREFNQUdFUyBPUgorICogT1RIRVIgTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFD VElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsCisgKiBBUklTSU5HIEZST00sIE9V VCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IKKyAq IE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KKyAqCisgKiBBdXRob3JzOiBDaHJpc3Rp YW4gS8O2bmlnLCBKb2huIFN0dWx0egorICovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4K KyNpbmNsdWRlIDxsaW51eC9oaWdobWVtLmg+CisjaW5jbHVkZSA8bGludXgvc2hyaW5rZXIuaD4K KyNpbmNsdWRlIDxkcm0vcGFnZV9wb29sLmg+CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nIHBhZ2Vf cG9vbF9zaXplOworCitNT0RVTEVfUEFSTV9ERVNDKHBhZ2VfcG9vbF9zaXplLCAiTnVtYmVyIG9m IHBhZ2VzIGluIHRoZSBXQy9VQy9ETUEgcG9vbCIpOworbW9kdWxlX3BhcmFtKHBhZ2VfcG9vbF9z aXplLCB1bG9uZywgMDY0NCk7CisKK3N0YXRpYyBhdG9taWNfbG9uZ190IGFsbG9jYXRlZF9wYWdl czsKKworc3RhdGljIHN0cnVjdCBtdXRleCBzaHJpbmtlcl9sb2NrOworc3RhdGljIHN0cnVjdCBs aXN0X2hlYWQgc2hyaW5rZXJfbGlzdDsKK3N0YXRpYyBzdHJ1Y3Qgc2hyaW5rZXIgbW1fc2hyaW5r ZXI7CisKK3ZvaWQgZHJtX3BhZ2VfcG9vbF9zZXRfbWF4KHVuc2lnbmVkIGxvbmcgbWF4KQorewor CWlmICghcGFnZV9wb29sX3NpemUpCisJCXBhZ2VfcG9vbF9zaXplID0gbWF4OworfQorCit1bnNp Z25lZCBsb25nIGRybV9wYWdlX3Bvb2xfZ2V0X21heCh2b2lkKQoreworCXJldHVybiBwYWdlX3Bv b2xfc2l6ZTsKK30KKwordW5zaWduZWQgbG9uZyBkcm1fcGFnZV9wb29sX2dldF90b3RhbCh2b2lk KQoreworCXJldHVybiBhdG9taWNfbG9uZ19yZWFkKCZhbGxvY2F0ZWRfcGFnZXMpOworfQorCit1 bnNpZ25lZCBsb25nIGRybV9wYWdlX3Bvb2xfZ2V0X3NpemUoc3RydWN0IGRybV9wYWdlX3Bvb2wg KnBvb2wpCit7CisJdW5zaWduZWQgbG9uZyBzaXplOworCisJc3Bpbl9sb2NrKCZwb29sLT5sb2Nr KTsKKwlzaXplID0gcG9vbC0+cGFnZV9jb3VudDsKKwlzcGluX3VubG9jaygmcG9vbC0+bG9jayk7 CisJcmV0dXJuIHNpemU7Cit9CisKKy8qIEdpdmUgcGFnZXMgaW50byBhIHNwZWNpZmljIHBvb2wg Ki8KK3ZvaWQgZHJtX3BhZ2VfcG9vbF9hZGQoc3RydWN0IGRybV9wYWdlX3Bvb2wgKnBvb2wsIHN0 cnVjdCBwYWdlICpwKQoreworCXVuc2lnbmVkIGludCBpLCBudW1fcGFnZXMgPSAxIDw8IHBvb2wt Pm9yZGVyOworCisJZm9yIChpID0gMDsgaSA8IG51bV9wYWdlczsgKytpKSB7CisJCWlmIChQYWdl SGlnaE1lbShwKSkKKwkJCWNsZWFyX2hpZ2hwYWdlKHAgKyBpKTsKKwkJZWxzZQorCQkJY2xlYXJf cGFnZShwYWdlX2FkZHJlc3MocCArIGkpKTsKKwl9CisKKwlzcGluX2xvY2soJnBvb2wtPmxvY2sp OworCWxpc3RfYWRkKCZwLT5scnUsICZwb29sLT5wYWdlcyk7CisJcG9vbC0+cGFnZV9jb3VudCAr PSAxIDw8IHBvb2wtPm9yZGVyOworCXNwaW5fdW5sb2NrKCZwb29sLT5sb2NrKTsKKwlhdG9taWNf bG9uZ19hZGQoMSA8PCBwb29sLT5vcmRlciwgJmFsbG9jYXRlZF9wYWdlcyk7Cit9CisKKy8qIFRh a2UgcGFnZXMgZnJvbSBhIHNwZWNpZmljIHBvb2wsIHJldHVybiBOVUxMIHdoZW4gbm90aGluZyBh dmFpbGFibGUgKi8KK3N0cnVjdCBwYWdlICpkcm1fcGFnZV9wb29sX3JlbW92ZShzdHJ1Y3QgZHJt X3BhZ2VfcG9vbCAqcG9vbCkKK3sKKwlzdHJ1Y3QgcGFnZSAqcDsKKworCXNwaW5fbG9jaygmcG9v bC0+bG9jayk7CisJcCA9IGxpc3RfZmlyc3RfZW50cnlfb3JfbnVsbCgmcG9vbC0+cGFnZXMsIHR5 cGVvZigqcCksIGxydSk7CisJaWYgKHApIHsKKwkJYXRvbWljX2xvbmdfc3ViKDEgPDwgcG9vbC0+ b3JkZXIsICZhbGxvY2F0ZWRfcGFnZXMpOworCQlwb29sLT5wYWdlX2NvdW50IC09IDEgPDwgcG9v bC0+b3JkZXI7CisJCWxpc3RfZGVsKCZwLT5scnUpOworCX0KKwlzcGluX3VubG9jaygmcG9vbC0+ bG9jayk7CisKKwlyZXR1cm4gcDsKK30KKworLyogSW5pdGlhbGl6ZSBhbmQgYWRkIGEgcG9vbCB0 eXBlIHRvIHRoZSBnbG9iYWwgc2hyaW5rZXIgbGlzdCAqLwordm9pZCBkcm1fcGFnZV9wb29sX2lu aXQoc3RydWN0IGRybV9wYWdlX3Bvb2wgKnBvb2wsIHVuc2lnbmVkIGludCBvcmRlciwKKwkJCXVu c2lnbmVkIGxvbmcgKCpmcmVlX3BhZ2UpKHN0cnVjdCBkcm1fcGFnZV9wb29sICpwb29sLCBzdHJ1 Y3QgcGFnZSAqcCkpCit7CisJcG9vbC0+b3JkZXIgPSBvcmRlcjsKKwlzcGluX2xvY2tfaW5pdCgm cG9vbC0+bG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJnBvb2wtPnBhZ2VzKTsKKwlwb29sLT5mcmVl ID0gZnJlZV9wYWdlOworCXBvb2wtPnBhZ2VfY291bnQgPSAwOworCisJbXV0ZXhfbG9jaygmc2hy aW5rZXJfbG9jayk7CisJbGlzdF9hZGRfdGFpbCgmcG9vbC0+c2hyaW5rZXJfbGlzdCwgJnNocmlu a2VyX2xpc3QpOworCW11dGV4X3VubG9jaygmc2hyaW5rZXJfbG9jayk7Cit9CisKKy8qIFJlbW92 ZSBhIHBvb2xfdHlwZSBmcm9tIHRoZSBnbG9iYWwgc2hyaW5rZXIgbGlzdCBhbmQgZnJlZSBhbGwg cGFnZXMgKi8KK3ZvaWQgZHJtX3BhZ2VfcG9vbF9maW5pKHN0cnVjdCBkcm1fcGFnZV9wb29sICpw b29sKQoreworCXN0cnVjdCBwYWdlICpwLCAqdG1wOworCisJbXV0ZXhfbG9jaygmc2hyaW5rZXJf bG9jayk7CisJbGlzdF9kZWwoJnBvb2wtPnNocmlua2VyX2xpc3QpOworCW11dGV4X3VubG9jaygm c2hyaW5rZXJfbG9jayk7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocCwgdG1wLCAmcG9v bC0+cGFnZXMsIGxydSkKKwkJcG9vbC0+ZnJlZShwb29sLCBwKTsKK30KKworLyogRnJlZSBwYWdl cyB1c2luZyB0aGUgZ2xvYmFsIHNocmlua2VyIGxpc3QgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQg ZHJtX3BhZ2VfcG9vbF9zaHJpbmsodm9pZCkKK3sKKwlzdHJ1Y3QgZHJtX3BhZ2VfcG9vbCAqcG9v bDsKKwl1bnNpZ25lZCBpbnQgbnVtX2ZyZWVkOworCXN0cnVjdCBwYWdlICpwOworCisJbXV0ZXhf bG9jaygmc2hyaW5rZXJfbG9jayk7CisJcG9vbCA9IGxpc3RfZmlyc3RfZW50cnkoJnNocmlua2Vy X2xpc3QsIHR5cGVvZigqcG9vbCksIHNocmlua2VyX2xpc3QpOworCisJcCA9IGRybV9wYWdlX3Bv b2xfcmVtb3ZlKHBvb2wpOworCisJbGlzdF9tb3ZlX3RhaWwoJnBvb2wtPnNocmlua2VyX2xpc3Qs ICZzaHJpbmtlcl9saXN0KTsKKwltdXRleF91bmxvY2soJnNocmlua2VyX2xvY2spOworCisJaWYg KHApIHsKKwkJcG9vbC0+ZnJlZShwb29sLCBwKTsKKwkJbnVtX2ZyZWVkID0gMSA8PCBwb29sLT5v cmRlcjsKKwl9IGVsc2UgeworCQludW1fZnJlZWQgPSAwOworCX0KKworCXJldHVybiBudW1fZnJl ZWQ7Cit9CisKKy8qIEFzIGxvbmcgYXMgcGFnZXMgYXJlIGF2YWlsYWJsZSBtYWtlIHN1cmUgdG8g cmVsZWFzZSBhdCBsZWFzdCBvbmUgKi8KK3N0YXRpYyB1bnNpZ25lZCBsb25nIGRybV9wYWdlX3Bv b2xfc2hyaW5rZXJfc2NhbihzdHJ1Y3Qgc2hyaW5rZXIgKnNocmluaywKKwkJCQkJCSBzdHJ1Y3Qg c2hyaW5rX2NvbnRyb2wgKnNjKQoreworCXVuc2lnbmVkIGxvbmcgbnVtX2ZyZWVkID0gMDsKKwor CWRvCisJCW51bV9mcmVlZCArPSBkcm1fcGFnZV9wb29sX3NocmluaygpOworCXdoaWxlICghbnVt X2ZyZWVkICYmIGF0b21pY19sb25nX3JlYWQoJmFsbG9jYXRlZF9wYWdlcykpOworCisJcmV0dXJu IG51bV9mcmVlZDsKK30KKworLyogUmV0dXJuIHRoZSBudW1iZXIgb2YgcGFnZXMgYXZhaWxhYmxl IG9yIFNIUklOS19FTVBUWSBpZiB3ZSBoYXZlIG5vbmUgKi8KK3N0YXRpYyB1bnNpZ25lZCBsb25n IGRybV9wYWdlX3Bvb2xfc2hyaW5rZXJfY291bnQoc3RydWN0IHNocmlua2VyICpzaHJpbmssCisJ CQkJCQkgIHN0cnVjdCBzaHJpbmtfY29udHJvbCAqc2MpCit7CisJdW5zaWduZWQgbG9uZyBudW1f cGFnZXMgPSBhdG9taWNfbG9uZ19yZWFkKCZhbGxvY2F0ZWRfcGFnZXMpOworCisJcmV0dXJuIG51 bV9wYWdlcyA/IG51bV9wYWdlcyA6IFNIUklOS19FTVBUWTsKK30KKworLyoqCisgKiBkcm1fcGFn ZV9wb29sX3Nocmlua2VyX3NldHVwIC0gSW5pdGlhbGl6ZSBnbG9iYWxzCisgKgorICogQG51bV9w YWdlczogZGVmYXVsdCBudW1iZXIgb2YgcGFnZXMKKyAqCisgKiBJbml0aWFsaXplIHRoZSBnbG9i YWwgbG9ja3MgYW5kIGxpc3RzIGZvciB0aGUgc2hyaW5rZXIuCisgKi8KK2ludCBkcm1fcGFnZV9w b29sX3Nocmlua2VyX3NldHVwKHZvaWQpCit7CisJbXV0ZXhfaW5pdCgmc2hyaW5rZXJfbG9jayk7 CisJSU5JVF9MSVNUX0hFQUQoJnNocmlua2VyX2xpc3QpOworCisJbW1fc2hyaW5rZXIuY291bnRf b2JqZWN0cyA9IGRybV9wYWdlX3Bvb2xfc2hyaW5rZXJfY291bnQ7CisJbW1fc2hyaW5rZXIuc2Nh bl9vYmplY3RzID0gZHJtX3BhZ2VfcG9vbF9zaHJpbmtlcl9zY2FuOworCW1tX3Nocmlua2VyLnNl ZWtzID0gMTsKKwlyZXR1cm4gcmVnaXN0ZXJfc2hyaW5rZXIoJm1tX3Nocmlua2VyKTsKK30KKwor LyoqCisgKiBkcm1fcGFnZV9wb29sX3Nocmlua2VyX3RlYXJkb3duIC0gRmluYWxpemUgZ2xvYmFs cworICoKKyAqIFVucmVnaXN0ZXIgdGhlIHNocmlua2VyLgorICovCit2b2lkIGRybV9wYWdlX3Bv b2xfc2hyaW5rZXJfdGVhcmRvd24odm9pZCkKK3sKKwl1bnJlZ2lzdGVyX3Nocmlua2VyKCZtbV9z aHJpbmtlcik7CisJV0FSTl9PTighbGlzdF9lbXB0eSgmc2hyaW5rZXJfbGlzdCkpOworfQorCitt b2R1bGVfaW5pdChkcm1fcGFnZV9wb29sX3Nocmlua2VyX3NldHVwKTsKK21vZHVsZV9leGl0KGRy bV9wYWdlX3Bvb2xfc2hyaW5rZXJfdGVhcmRvd24pOworTU9EVUxFX0xJQ0VOU0UoIkR1YWwgTUlU L0dQTCIpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vcGFnZV9wb29sLmggYi9pbmNsdWRlL2Ry bS9wYWdlX3Bvb2wuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmQ4 YjhhODQxNTYyOQotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvZHJtL3BhZ2VfcG9vbC5oCkBA IC0wLDAgKzEsNjUgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1J VCAqLworLyoKKyAqIEV4dHJhY3RlZCBmcm9tIGluY2x1ZGUvZHJtL3R0bS90dG1fcG9vbC5oCisg KiBDb3B5cmlnaHQgMjAyMCBBZHZhbmNlZCBNaWNybyBEZXZpY2VzLCBJbmMuCisgKiBDb3B5cmln aHQgMjAyMSBMaW5hcm8gTHRkCisgKgorICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwg ZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEKKyAqIGNvcHkgb2YgdGhp cyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3 YXJlIiksCisgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBp bmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCisgKiB0aGUgcmlnaHRzIHRvIHVzZSwgY29weSwg bW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwKKyAqIGFuZC9v ciBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3 aG9tIHRoZQorICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKKyAqCisgKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGlj ZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbgorICogYWxs IGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCisgKgorICog VEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5Z IEtJTkQsIEVYUFJFU1MgT1IKKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQg VE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxM CisgKiBUSEUgQ09QWVJJR0hUIEhPTERFUihTKSBPUiBBVVRIT1IoUykgQkUgTElBQkxFIEZPUiBB TlkgQ0xBSU0sIERBTUFHRVMgT1IKKyAqIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBB Q1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLAorICogQVJJU0lORyBGUk9NLCBP VVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SCisg KiBPVEhFUiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCisgKgorICogQXV0aG9yczogQ2hyaXN0 aWFuIEvDtm5pZywgSm9obiBTdHVsdHoKKyAqLworCisjaWZuZGVmIF9EUk1fUEFHRV9QT09MX0hf CisjZGVmaW5lIF9EUk1fUEFHRV9QT09MX0hfCisKKyNpbmNsdWRlIDxsaW51eC9tbXpvbmUuaD4K KyNpbmNsdWRlIDxsaW51eC9sbGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisK Ky8qKgorICogZHJtX3BhZ2VfcG9vbCAtIFBhZ2UgUG9vbCBmb3IgYSBjZXJ0YWluIG1lbW9yeSB0 eXBlCisgKgorICogQG9yZGVyOiB0aGUgYWxsb2NhdGlvbiBvcmRlciBvdXIgcGFnZXMgaGF2ZQor ICogQHBhZ2VzOiB0aGUgbGlzdCBvZiBwYWdlcyBpbiB0aGUgcG9vbAorICogQHNocmlua2VyX2xp c3Q6IG91ciBwbGFjZSBvbiB0aGUgZ2xvYmFsIHNocmlua2VyIGxpc3QKKyAqIEBsb2NrOiBwcm90 ZWN0aW9uIG9mIHRoZSBwYWdlIGxpc3QKKyAqIEBwYWdlX2NvdW50OiBudW1iZXIgb2YgcGFnZXMg Y3VycmVudGx5IGluIHRoZSBwb29sCisgKiBAZnJlZTogRnVuY3Rpb24gcG9pbnRlciB0byBmcmVl IHRoZSBwYWdlCisgKi8KK3N0cnVjdCBkcm1fcGFnZV9wb29sIHsKKwl1bnNpZ25lZCBpbnQgb3Jk ZXI7CisJc3RydWN0IGxpc3RfaGVhZCBwYWdlczsKKwlzdHJ1Y3QgbGlzdF9oZWFkIHNocmlua2Vy X2xpc3Q7CisJc3BpbmxvY2tfdCBsb2NrOworCisJdW5zaWduZWQgbG9uZyBwYWdlX2NvdW50Owor CXVuc2lnbmVkIGxvbmcgKCpmcmVlKShzdHJ1Y3QgZHJtX3BhZ2VfcG9vbCAqcG9vbCwgc3RydWN0 IHBhZ2UgKnApOworfTsKKwordm9pZCBkcm1fcGFnZV9wb29sX3NldF9tYXgodW5zaWduZWQgbG9u ZyBtYXgpOwordW5zaWduZWQgbG9uZyBkcm1fcGFnZV9wb29sX2dldF9tYXgodm9pZCk7Cit1bnNp Z25lZCBsb25nIGRybV9wYWdlX3Bvb2xfZ2V0X3RvdGFsKHZvaWQpOwordW5zaWduZWQgbG9uZyBk cm1fcGFnZV9wb29sX2dldF9zaXplKHN0cnVjdCBkcm1fcGFnZV9wb29sICpwb29sKTsKK3ZvaWQg ZHJtX3BhZ2VfcG9vbF9hZGQoc3RydWN0IGRybV9wYWdlX3Bvb2wgKnBvb2wsIHN0cnVjdCBwYWdl ICpwKTsKK3N0cnVjdCBwYWdlICpkcm1fcGFnZV9wb29sX3JlbW92ZShzdHJ1Y3QgZHJtX3BhZ2Vf cG9vbCAqcG9vbCk7Cit2b2lkIGRybV9wYWdlX3Bvb2xfaW5pdChzdHJ1Y3QgZHJtX3BhZ2VfcG9v bCAqcG9vbCwgdW5zaWduZWQgaW50IG9yZGVyLAorCQkJdW5zaWduZWQgbG9uZyAoKmZyZWVfcGFn ZSkoc3RydWN0IGRybV9wYWdlX3Bvb2wgKnBvb2wsIHN0cnVjdCBwYWdlICpwKSk7Cit2b2lkIGRy bV9wYWdlX3Bvb2xfZmluaShzdHJ1Y3QgZHJtX3BhZ2VfcG9vbCAqcG9vbCk7CisKKyNlbmRpZgot LSAKMi4yNS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK 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=-18.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,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 9860FC43381 for ; Thu, 4 Mar 2021 23:20:18 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5623965016 for ; Thu, 4 Mar 2021 23:20:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232979AbhCDXUR (ORCPT ); Thu, 4 Mar 2021 18:20:17 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36960 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233000AbhCDXUQ (ORCPT ); Thu, 4 Mar 2021 18:20:16 -0500 Received: from mail-pj1-x102a.google.com (mail-pj1-x102a.google.com [IPv6:2607:f8b0:4864:20::102a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7D458C061574 for ; Thu, 4 Mar 2021 15:20:16 -0800 (PST) Received: by mail-pj1-x102a.google.com with SMTP id fu20so378642pjb.2 for ; Thu, 04 Mar 2021 15:20:16 -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 :mime-version:content-transfer-encoding; bh=Fqm2n/WLZ4eT9r+Omo3xPTCh/D9fjyEDFpTAnWdfMxc=; b=F2XR2R9XnG6Pl2ygAmc7iKRvSRVWJp1v3xUfsM+HsXSJJnvSvA5KzoLoUBj+OcGM74 lvNhdnut/cgMAmLI6drQIqgMB0mwCmNAQpKRepM+Dg/i13va+NkjlGilhzigUw4SH5Z5 HgCwZxMi3+A7OOHOQvkNxxgIwZnHZBgFXgzqmFIp47vE8gW5tRHP6XObrk/LXZrwtO5t 1jrbCcShLjWUcXdU+6wN+HJt64p7TjmGmO0BeZ8cKvEvtwePgaKCpe8oVR1dU3Ik0cQP WNQuDFFmNyaqsObiDmYCfOrErqmT5mP+svooLmVV4hjROFRY1fEhdkW9Xy/DrMWprhvb +3ZQ== 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:mime-version:content-transfer-encoding; bh=Fqm2n/WLZ4eT9r+Omo3xPTCh/D9fjyEDFpTAnWdfMxc=; b=BqgBVV0bW37NxywYh0hHd2HuT6u+0HHN3ljhkHe4jVda698JkyMl8V6Ybb1Y3Z4fs7 nC3a/YR/5ecKiBfTjw0jJWhnUdaft+UpAdtjCL/rqTg/wosWId6VKs+Wkmv+gxynqfun E3et5jpHMJl2jWIzt3oAbiOiSquBqR8puvDGJaUmWafURoa4a26VngY/xusEAProZsvv SNyd+96+Yxxs/xY17wx2Hwi1aioEgy073SEGnfLa6SdlLsKv49xepHhHjR0vA3XdQysh +4yTgkxk0PFNO86mDBWaCY4haWreVqoflFvpnLrou0VQVMf4jvwBDk0PhiFalOepwz0x YJrA== X-Gm-Message-State: AOAM531MTPolm7W+5qywDbgAHpYsYXScZDN0bam8AKW7SE05AJi0RWMF 3qpZ7f1nPRusdq0LnnkzEa4pfw== X-Google-Smtp-Source: ABdhPJxP9czYFnGyxuCxK65IM0dMb7+TMQaJSX4C16Yezzu0bg5hD2R1LO24UOGgxEkMNX80XnkdVg== X-Received: by 2002:a17:90a:488f:: with SMTP id b15mr7010573pjh.53.1614900016079; Thu, 04 Mar 2021 15:20:16 -0800 (PST) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id u66sm429290pfc.72.2021.03.04.15.20.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 04 Mar 2021 15:20:15 -0800 (PST) From: John Stultz To: lkml Cc: John Stultz , Daniel Vetter , Christian Koenig , Sumit Semwal , Liam Mark , Chris Goldsworthy , Laura Abbott , Brian Starkey , Hridya Valsaraju , Suren Baghdasaryan , Sandeep Patil , Daniel Mentz , =?UTF-8?q?=C3=98rjan=20Eide?= , Robin Murphy , Ezequiel Garcia , Simon Ser , James Jones , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [PATCH v8 1/5] drm: Add a sharable drm page-pool implementation Date: Thu, 4 Mar 2021 23:20:07 +0000 Message-Id: <20210304232011.1479036-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210304232011.1479036-1-john.stultz@linaro.org> References: <20210304232011.1479036-1-john.stultz@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org This adds a shrinker controlled page pool, extracted out of the ttm_pool logic, and abstracted out a bit so it can be used by other non-ttm drivers. Cc: Daniel Vetter Cc: Christian Koenig Cc: Sumit Semwal Cc: Liam Mark Cc: Chris Goldsworthy Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil Cc: Daniel Mentz Cc: Ørjan Eide Cc: Robin Murphy Cc: Ezequiel Garcia Cc: Simon Ser Cc: James Jones Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v8: * Completely rewritten from scratch, using only the ttm_pool logic so it can be dual licensed. --- drivers/gpu/drm/Kconfig | 4 + drivers/gpu/drm/Makefile | 2 + drivers/gpu/drm/page_pool.c | 214 ++++++++++++++++++++++++++++++++++++ include/drm/page_pool.h | 65 +++++++++++ 4 files changed, 285 insertions(+) create mode 100644 drivers/gpu/drm/page_pool.c create mode 100644 include/drm/page_pool.h diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index e392a90ca687..7cbcecb8f7df 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -177,6 +177,10 @@ config DRM_DP_CEC Note: not all adapters support this feature, and even for those that do support this they often do not hook up the CEC pin. +config DRM_PAGE_POOL + bool + depends on DRM + config DRM_TTM tristate depends on DRM && MMU diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 926adef289db..2dc7b2fe3fe5 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -39,6 +39,8 @@ obj-$(CONFIG_DRM_VRAM_HELPER) += drm_vram_helper.o drm_ttm_helper-y := drm_gem_ttm_helper.o obj-$(CONFIG_DRM_TTM_HELPER) += drm_ttm_helper.o +drm-$(CONFIG_DRM_PAGE_POOL) += page_pool.o + drm_kms_helper-y := drm_bridge_connector.o drm_crtc_helper.o drm_dp_helper.o \ drm_dsc.o drm_probe_helper.o \ drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o \ diff --git a/drivers/gpu/drm/page_pool.c b/drivers/gpu/drm/page_pool.c new file mode 100644 index 000000000000..a60b954cfe0f --- /dev/null +++ b/drivers/gpu/drm/page_pool.c @@ -0,0 +1,214 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT +/* + * Sharable page pool implementation + * + * Extracted from drivers/gpu/drm/ttm/ttm_pool.c + * Copyright 2020 Advanced Micro Devices, Inc. + * Copyright 2021 Linaro Ltd. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: Christian König, John Stultz + */ + +#include +#include +#include +#include + +static unsigned long page_pool_size; + +MODULE_PARM_DESC(page_pool_size, "Number of pages in the WC/UC/DMA pool"); +module_param(page_pool_size, ulong, 0644); + +static atomic_long_t allocated_pages; + +static struct mutex shrinker_lock; +static struct list_head shrinker_list; +static struct shrinker mm_shrinker; + +void drm_page_pool_set_max(unsigned long max) +{ + if (!page_pool_size) + page_pool_size = max; +} + +unsigned long drm_page_pool_get_max(void) +{ + return page_pool_size; +} + +unsigned long drm_page_pool_get_total(void) +{ + return atomic_long_read(&allocated_pages); +} + +unsigned long drm_page_pool_get_size(struct drm_page_pool *pool) +{ + unsigned long size; + + spin_lock(&pool->lock); + size = pool->page_count; + spin_unlock(&pool->lock); + return size; +} + +/* Give pages into a specific pool */ +void drm_page_pool_add(struct drm_page_pool *pool, struct page *p) +{ + unsigned int i, num_pages = 1 << pool->order; + + for (i = 0; i < num_pages; ++i) { + if (PageHighMem(p)) + clear_highpage(p + i); + else + clear_page(page_address(p + i)); + } + + spin_lock(&pool->lock); + list_add(&p->lru, &pool->pages); + pool->page_count += 1 << pool->order; + spin_unlock(&pool->lock); + atomic_long_add(1 << pool->order, &allocated_pages); +} + +/* Take pages from a specific pool, return NULL when nothing available */ +struct page *drm_page_pool_remove(struct drm_page_pool *pool) +{ + struct page *p; + + spin_lock(&pool->lock); + p = list_first_entry_or_null(&pool->pages, typeof(*p), lru); + if (p) { + atomic_long_sub(1 << pool->order, &allocated_pages); + pool->page_count -= 1 << pool->order; + list_del(&p->lru); + } + spin_unlock(&pool->lock); + + return p; +} + +/* Initialize and add a pool type to the global shrinker list */ +void drm_page_pool_init(struct drm_page_pool *pool, unsigned int order, + unsigned long (*free_page)(struct drm_page_pool *pool, struct page *p)) +{ + pool->order = order; + spin_lock_init(&pool->lock); + INIT_LIST_HEAD(&pool->pages); + pool->free = free_page; + pool->page_count = 0; + + mutex_lock(&shrinker_lock); + list_add_tail(&pool->shrinker_list, &shrinker_list); + mutex_unlock(&shrinker_lock); +} + +/* Remove a pool_type from the global shrinker list and free all pages */ +void drm_page_pool_fini(struct drm_page_pool *pool) +{ + struct page *p, *tmp; + + mutex_lock(&shrinker_lock); + list_del(&pool->shrinker_list); + mutex_unlock(&shrinker_lock); + + list_for_each_entry_safe(p, tmp, &pool->pages, lru) + pool->free(pool, p); +} + +/* Free pages using the global shrinker list */ +static unsigned int drm_page_pool_shrink(void) +{ + struct drm_page_pool *pool; + unsigned int num_freed; + struct page *p; + + mutex_lock(&shrinker_lock); + pool = list_first_entry(&shrinker_list, typeof(*pool), shrinker_list); + + p = drm_page_pool_remove(pool); + + list_move_tail(&pool->shrinker_list, &shrinker_list); + mutex_unlock(&shrinker_lock); + + if (p) { + pool->free(pool, p); + num_freed = 1 << pool->order; + } else { + num_freed = 0; + } + + return num_freed; +} + +/* As long as pages are available make sure to release at least one */ +static unsigned long drm_page_pool_shrinker_scan(struct shrinker *shrink, + struct shrink_control *sc) +{ + unsigned long num_freed = 0; + + do + num_freed += drm_page_pool_shrink(); + while (!num_freed && atomic_long_read(&allocated_pages)); + + return num_freed; +} + +/* Return the number of pages available or SHRINK_EMPTY if we have none */ +static unsigned long drm_page_pool_shrinker_count(struct shrinker *shrink, + struct shrink_control *sc) +{ + unsigned long num_pages = atomic_long_read(&allocated_pages); + + return num_pages ? num_pages : SHRINK_EMPTY; +} + +/** + * drm_page_pool_shrinker_setup - Initialize globals + * + * @num_pages: default number of pages + * + * Initialize the global locks and lists for the shrinker. + */ +int drm_page_pool_shrinker_setup(void) +{ + mutex_init(&shrinker_lock); + INIT_LIST_HEAD(&shrinker_list); + + mm_shrinker.count_objects = drm_page_pool_shrinker_count; + mm_shrinker.scan_objects = drm_page_pool_shrinker_scan; + mm_shrinker.seeks = 1; + return register_shrinker(&mm_shrinker); +} + +/** + * drm_page_pool_shrinker_teardown - Finalize globals + * + * Unregister the shrinker. + */ +void drm_page_pool_shrinker_teardown(void) +{ + unregister_shrinker(&mm_shrinker); + WARN_ON(!list_empty(&shrinker_list)); +} + +module_init(drm_page_pool_shrinker_setup); +module_exit(drm_page_pool_shrinker_teardown); +MODULE_LICENSE("Dual MIT/GPL"); diff --git a/include/drm/page_pool.h b/include/drm/page_pool.h new file mode 100644 index 000000000000..d8b8a8415629 --- /dev/null +++ b/include/drm/page_pool.h @@ -0,0 +1,65 @@ +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ +/* + * Extracted from include/drm/ttm/ttm_pool.h + * Copyright 2020 Advanced Micro Devices, Inc. + * Copyright 2021 Linaro Ltd + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * Authors: Christian König, John Stultz + */ + +#ifndef _DRM_PAGE_POOL_H_ +#define _DRM_PAGE_POOL_H_ + +#include +#include +#include + +/** + * drm_page_pool - Page Pool for a certain memory type + * + * @order: the allocation order our pages have + * @pages: the list of pages in the pool + * @shrinker_list: our place on the global shrinker list + * @lock: protection of the page list + * @page_count: number of pages currently in the pool + * @free: Function pointer to free the page + */ +struct drm_page_pool { + unsigned int order; + struct list_head pages; + struct list_head shrinker_list; + spinlock_t lock; + + unsigned long page_count; + unsigned long (*free)(struct drm_page_pool *pool, struct page *p); +}; + +void drm_page_pool_set_max(unsigned long max); +unsigned long drm_page_pool_get_max(void); +unsigned long drm_page_pool_get_total(void); +unsigned long drm_page_pool_get_size(struct drm_page_pool *pool); +void drm_page_pool_add(struct drm_page_pool *pool, struct page *p); +struct page *drm_page_pool_remove(struct drm_page_pool *pool); +void drm_page_pool_init(struct drm_page_pool *pool, unsigned int order, + unsigned long (*free_page)(struct drm_page_pool *pool, struct page *p)); +void drm_page_pool_fini(struct drm_page_pool *pool); + +#endif -- 2.25.1