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.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 98DC5C48BE5 for ; Thu, 17 Jun 2021 06:31:01 +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 6CC28613E7 for ; Thu, 17 Jun 2021 06:31:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6CC28613E7 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id BB6EE6E883; Thu, 17 Jun 2021 06:30:53 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5D1496E87B; Thu, 17 Jun 2021 06:30:48 +0000 (UTC) IronPort-SDR: s5S+1q0I4RFQ/uk2Otkkd7MB0F8XaAXXvaLmgfycNSY8u2W/fPG0/1LbOIx1uJ+IGhwr0H15vr VzNGZrFD1ovQ== X-IronPort-AV: E=McAfee;i="6200,9189,10017"; a="203287837" X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="203287837" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:48 -0700 IronPort-SDR: eAZHIKwgQktvA38+K66Hmfo56vYRzg7Bw57Ma4MPZp9r01WPWv0+Mq31TPJR+jJMwi5vqP9SUG +oJHvGEOoyOQ== X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="554302728" Received: from vanderss-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.193]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:46 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Thu, 17 Jun 2021 08:30:14 +0200 Message-Id: <20210617063018.92802-9-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> References: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v5 08/12] drm/i915/gt: Pipelined clear X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com, Chris Wilson Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogQ2hyaXMgV2lsc29uIDxjaHJpc0BjaHJpcy13aWxzb24uY28udWs+CgpVcGRhdGUgdGhl IFBURSBhbmQgZW1pdCBhIGNsZWFyIHdpdGhpbiBhIHNpbmdsZSB1bnByZWVtcHRpYmxlIHBhY2tl dApzdWNoIHRoYXQgd2UgY2FuIHNjaGVkdWxlIGFuZCBwaXBlbGluZSBjbGVhcnMuCgpTaWduZWQt b2ZmLWJ5OiBDaHJpcyBXaWxzb24gPGNocmlzQGNocmlzLXdpbHNvbi5jby51az4KQ28tZGV2ZWxv cGVkLWJ5OiBUaG9tYXMgSGVsbHN0csO2bSA8dGhvbWFzLmhlbGxzdHJvbUBsaW51eC5pbnRlbC5j b20+ClNpZ25lZC1vZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxp bnV4LmludGVsLmNvbT4KUmV2aWV3ZWQtYnk6IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGlu dGVsLmNvbT4KLS0tCnYzOgotIEhhbmRsZSBlbmdpbmUgaW5zdGFuY2VzIGNvcnJlY3RseSAoUmVw b3J0ZWQgYnkgTWF0dGhldyBBdWxkKQotLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVs X21pZ3JhdGUuYyAgICB8IDE0MyArKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2d0L2ludGVsX21pZ3JhdGUuaCAgICB8ICAyMCArKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3NlbGZ0ZXN0X21pZ3JhdGUuYyB8IDE2MyArKysrKysrKysrKysrKysrKysrKysKIDMgZmls ZXMgY2hhbmdlZCwgMzI2IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9pbnRlbF9taWdyYXRlLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRl bF9taWdyYXRlLmMKaW5kZXggZTJlODYwMDYzZTdiLi5iYTQwMDkxMjBiMzMgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX21pZ3JhdGUuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9taWdyYXRlLmMKQEAgLTQ4OCw2ICs0ODgsMTE0IEBAIGludGVs X2NvbnRleHRfbWlncmF0ZV9jb3B5KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKIAlyZXR1cm4g ZXJyOwogfQogCitzdGF0aWMgaW50IGVtaXRfY2xlYXIoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEs IGludCBzaXplLCB1MzIgdmFsdWUpCit7CisJY29uc3QgaW50IGdlbiA9IElOVEVMX0dFTihycS0+ ZW5naW5lLT5pOTE1KTsKKwl1MzIgaW5zdGFuY2UgPSBycS0+ZW5naW5lLT5pbnN0YW5jZTsKKwl1 MzIgKmNzOworCisJR0VNX0JVR19PTihzaXplID4+IFBBR0VfU0hJRlQgPiBTMTZfTUFYKTsKKwor CWNzID0gaW50ZWxfcmluZ19iZWdpbihycSwgZ2VuID49IDggPyA4IDogNik7CisJaWYgKElTX0VS UihjcykpCisJCXJldHVybiBQVFJfRVJSKGNzKTsKKworCWlmIChnZW4gPj0gOCkgeworCQkqY3Mr KyA9IFhZX0NPTE9SX0JMVF9DTUQgfCBCTFRfV1JJVEVfUkdCQSB8ICg3IC0gMik7CisJCSpjcysr ID0gQkxUX0RFUFRIXzMyIHwgQkxUX1JPUF9DT0xPUl9DT1BZIHwgUEFHRV9TSVpFOworCQkqY3Mr KyA9IDA7CisJCSpjcysrID0gc2l6ZSA+PiBQQUdFX1NISUZUIDw8IDE2IHwgUEFHRV9TSVpFIC8g NDsKKwkJKmNzKysgPSAwOyAvKiBvZmZzZXQgKi8KKwkJKmNzKysgPSBpbnN0YW5jZTsKKwkJKmNz KysgPSB2YWx1ZTsKKwkJKmNzKysgPSBNSV9OT09QOworCX0gZWxzZSB7CisJCUdFTV9CVUdfT04o aW5zdGFuY2UpOworCQkqY3MrKyA9IFhZX0NPTE9SX0JMVF9DTUQgfCBCTFRfV1JJVEVfUkdCQSB8 ICg2IC0gMik7CisJCSpjcysrID0gQkxUX0RFUFRIXzMyIHwgQkxUX1JPUF9DT0xPUl9DT1BZIHwg UEFHRV9TSVpFOworCQkqY3MrKyA9IDA7CisJCSpjcysrID0gc2l6ZSA+PiBQQUdFX1NISUZUIDw8 IDE2IHwgUEFHRV9TSVpFIC8gNDsKKwkJKmNzKysgPSAwOworCQkqY3MrKyA9IHZhbHVlOworCX0K KworCWludGVsX3JpbmdfYWR2YW5jZShycSwgY3MpOworCXJldHVybiAwOworfQorCitpbnQKK2lu dGVsX2NvbnRleHRfbWlncmF0ZV9jbGVhcihzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCisJCQkg ICAgc3RydWN0IGRtYV9mZW5jZSAqYXdhaXQsCisJCQkgICAgc3RydWN0IHNjYXR0ZXJsaXN0ICpz ZywKKwkJCSAgICBlbnVtIGk5MTVfY2FjaGVfbGV2ZWwgY2FjaGVfbGV2ZWwsCisJCQkgICAgYm9v bCBpc19sbWVtLAorCQkJICAgIHUzMiB2YWx1ZSwKKwkJCSAgICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0 ICoqb3V0KQoreworCXN0cnVjdCBzZ3RfZG1hIGl0ID0gc2dfc2d0KHNnKTsKKwlzdHJ1Y3QgaTkx NV9yZXF1ZXN0ICpycTsKKwlpbnQgZXJyOworCisJKm91dCA9IE5VTEw7CisKKwlHRU1fQlVHX09O KGNlLT5yaW5nLT5zaXplIDwgU1pfNjRLKTsKKworCWRvIHsKKwkJaW50IGxlbjsKKworCQlycSA9 IGk5MTVfcmVxdWVzdF9jcmVhdGUoY2UpOworCQlpZiAoSVNfRVJSKHJxKSkgeworCQkJZXJyID0g UFRSX0VSUihycSk7CisJCQlnb3RvIG91dF9jZTsKKwkJfQorCisJCWlmIChhd2FpdCkgeworCQkJ ZXJyID0gaTkxNV9yZXF1ZXN0X2F3YWl0X2RtYV9mZW5jZShycSwgYXdhaXQpOworCQkJaWYgKGVy cikKKwkJCQlnb3RvIG91dF9ycTsKKworCQkJaWYgKHJxLT5lbmdpbmUtPmVtaXRfaW5pdF9icmVh ZGNydW1iKSB7CisJCQkJZXJyID0gcnEtPmVuZ2luZS0+ZW1pdF9pbml0X2JyZWFkY3J1bWIocnEp OworCQkJCWlmIChlcnIpCisJCQkJCWdvdG8gb3V0X3JxOworCQkJfQorCisJCQlhd2FpdCA9IE5V TEw7CisJCX0KKworCQkvKiBUaGUgUFRFIHVwZGF0ZXMgKyBjbGVhciBtdXN0IG5vdCBiZSBpbnRl cnJ1cHRlZC4gKi8KKwkJZXJyID0gZW1pdF9ub19hcmJpdHJhdGlvbihycSk7CisJCWlmIChlcnIp CisJCQlnb3RvIG91dF9ycTsKKworCQlsZW4gPSBlbWl0X3B0ZShycSwgJml0LCBjYWNoZV9sZXZl bCwgaXNfbG1lbSwgMCwgQ0hVTktfU1opOworCQlpZiAobGVuIDw9IDApIHsKKwkJCWVyciA9IGxl bjsKKwkJCWdvdG8gb3V0X3JxOworCQl9CisKKwkJZXJyID0gcnEtPmVuZ2luZS0+ZW1pdF9mbHVz aChycSwgRU1JVF9JTlZBTElEQVRFKTsKKwkJaWYgKGVycikKKwkJCWdvdG8gb3V0X3JxOworCisJ CWVyciA9IGVtaXRfY2xlYXIocnEsIGxlbiwgdmFsdWUpOworCisJCS8qIEFyYml0cmF0aW9uIGlz IHJlLWVuYWJsZWQgYmV0d2VlbiByZXF1ZXN0cy4gKi8KK291dF9ycToKKwkJaWYgKCpvdXQpCisJ CQlpOTE1X3JlcXVlc3RfcHV0KCpvdXQpOworCQkqb3V0ID0gaTkxNV9yZXF1ZXN0X2dldChycSk7 CisJCWk5MTVfcmVxdWVzdF9hZGQocnEpOworCQlpZiAoZXJyIHx8ICFpdC5zZyB8fCAhc2dfZG1h X2xlbihpdC5zZykpCisJCQlicmVhazsKKworCQljb25kX3Jlc2NoZWQoKTsKKwl9IHdoaWxlICgx KTsKKworb3V0X2NlOgorCXJldHVybiBlcnI7Cit9CisKIGludCBpbnRlbF9taWdyYXRlX2NvcHko c3RydWN0IGludGVsX21pZ3JhdGUgKm0sCiAJCSAgICAgICBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4 ICp3dywKIAkJICAgICAgIHN0cnVjdCBkbWFfZmVuY2UgKmF3YWl0LApAQCAtNTI2LDYgKzYzNCw0 MSBAQCBpbnQgaW50ZWxfbWlncmF0ZV9jb3B5KHN0cnVjdCBpbnRlbF9taWdyYXRlICptLAogCXJl dHVybiBlcnI7CiB9CiAKK2ludAoraW50ZWxfbWlncmF0ZV9jbGVhcihzdHJ1Y3QgaW50ZWxfbWln cmF0ZSAqbSwKKwkJICAgIHN0cnVjdCBpOTE1X2dlbV93d19jdHggKnd3LAorCQkgICAgc3RydWN0 IGRtYV9mZW5jZSAqYXdhaXQsCisJCSAgICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAorCQkgICAg ZW51bSBpOTE1X2NhY2hlX2xldmVsIGNhY2hlX2xldmVsLAorCQkgICAgYm9vbCBpc19sbWVtLAor CQkgICAgdTMyIHZhbHVlLAorCQkgICAgc3RydWN0IGk5MTVfcmVxdWVzdCAqKm91dCkKK3sKKwlz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2U7CisJaW50IGVycjsKKworCSpvdXQgPSBOVUxMOworCWlm ICghbS0+Y29udGV4dCkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwljZSA9IGludGVsX21pZ3JhdGVf Y3JlYXRlX2NvbnRleHQobSk7CisJaWYgKElTX0VSUihjZSkpCisJCWNlID0gaW50ZWxfY29udGV4 dF9nZXQobS0+Y29udGV4dCk7CisJR0VNX0JVR19PTihJU19FUlIoY2UpKTsKKworCWVyciA9IGlu dGVsX2NvbnRleHRfcGluX3d3KGNlLCB3dyk7CisJaWYgKGVycikKKwkJZ290byBvdXQ7CisKKwll cnIgPSBpbnRlbF9jb250ZXh0X21pZ3JhdGVfY2xlYXIoY2UsIGF3YWl0LCBzZywgY2FjaGVfbGV2 ZWwsCisJCQkJCSAgaXNfbG1lbSwgdmFsdWUsIG91dCk7CisKKwlpbnRlbF9jb250ZXh0X3VucGlu KGNlKTsKK291dDoKKwlpbnRlbF9jb250ZXh0X3B1dChjZSk7CisJcmV0dXJuIGVycjsKK30KKwog dm9pZCBpbnRlbF9taWdyYXRlX2Zpbmkoc3RydWN0IGludGVsX21pZ3JhdGUgKm0pCiB7CiAJc3Ry dWN0IGludGVsX2NvbnRleHQgKmNlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv Z3QvaW50ZWxfbWlncmF0ZS5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbWlncmF0 ZS5oCmluZGV4IDMyYzYxMTkwZWQ3My4uNGUxOGU3NTVhMDBiIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9taWdyYXRlLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ3QvaW50ZWxfbWlncmF0ZS5oCkBAIC02LDYgKzYsOCBAQAogI2lmbmRlZiBfX0lOVEVMX01J R1JBVEVfXwogI2RlZmluZSBfX0lOVEVMX01JR1JBVEVfXwogCisjaW5jbHVkZSA8bGludXgvdHlw ZXMuaD4KKwogI2luY2x1ZGUgImludGVsX21pZ3JhdGVfdHlwZXMuaCIKIAogc3RydWN0IGRtYV9m ZW5jZTsKQEAgLTQwLDYgKzQyLDI0IEBAIGludCBpbnRlbF9jb250ZXh0X21pZ3JhdGVfY29weShz dHJ1Y3QgaW50ZWxfY29udGV4dCAqY2UsCiAJCQkgICAgICAgYm9vbCBkc3RfaXNfbG1lbSwKIAkJ CSAgICAgICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICoqb3V0KTsKIAoraW50CitpbnRlbF9taWdyYXRl X2NsZWFyKHN0cnVjdCBpbnRlbF9taWdyYXRlICptLAorCQkgICAgc3RydWN0IGk5MTVfZ2VtX3d3 X2N0eCAqd3csCisJCSAgICBzdHJ1Y3QgZG1hX2ZlbmNlICphd2FpdCwKKwkJICAgIHN0cnVjdCBz Y2F0dGVybGlzdCAqc2csCisJCSAgICBlbnVtIGk5MTVfY2FjaGVfbGV2ZWwgY2FjaGVfbGV2ZWws CisJCSAgICBib29sIGlzX2xtZW0sCisJCSAgICB1MzIgdmFsdWUsCisJCSAgICBzdHJ1Y3QgaTkx NV9yZXF1ZXN0ICoqb3V0KTsKK2ludAoraW50ZWxfY29udGV4dF9taWdyYXRlX2NsZWFyKHN0cnVj dCBpbnRlbF9jb250ZXh0ICpjZSwKKwkJCSAgICBzdHJ1Y3QgZG1hX2ZlbmNlICphd2FpdCwKKwkJ CSAgICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAorCQkJICAgIGVudW0gaTkxNV9jYWNoZV9sZXZl bCBjYWNoZV9sZXZlbCwKKwkJCSAgICBib29sIGlzX2xtZW0sCisJCQkgICAgdTMyIHZhbHVlLAor CQkJICAgIHN0cnVjdCBpOTE1X3JlcXVlc3QgKipvdXQpOworCiB2b2lkIGludGVsX21pZ3JhdGVf ZmluaShzdHJ1Y3QgaW50ZWxfbWlncmF0ZSAqbSk7CiAKICNlbmRpZiAvKiBfX0lOVEVMX01JR1JB VEVfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfbWln cmF0ZS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfbWlncmF0ZS5jCmluZGV4 IDk3ODRkMTQ5ZWJmMS4uMTU5Yzg2NTZlMWIwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9zZWxmdGVzdF9taWdyYXRlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv c2VsZnRlc3RfbWlncmF0ZS5jCkBAIC0xMjksNiArMTI5LDgyIEBAIHN0YXRpYyBpbnQgY29weShz dHJ1Y3QgaW50ZWxfbWlncmF0ZSAqbWlncmF0ZSwKIAlyZXR1cm4gZXJyOwogfQogCitzdGF0aWMg aW50IGNsZWFyKHN0cnVjdCBpbnRlbF9taWdyYXRlICptaWdyYXRlLAorCQkgaW50ICgqZm4pKHN0 cnVjdCBpbnRlbF9taWdyYXRlICptaWdyYXRlLAorCQkJICAgc3RydWN0IGk5MTVfZ2VtX3d3X2N0 eCAqd3csCisJCQkgICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAorCQkJICAgdTMy IHZhbHVlLAorCQkJICAgc3RydWN0IGk5MTVfcmVxdWVzdCAqKm91dCksCisJCSB1MzIgc3osIHN0 cnVjdCBybmRfc3RhdGUgKnBybmcpCit7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUg PSBtaWdyYXRlLT5jb250ZXh0LT5lbmdpbmUtPmk5MTU7CisJc3RydWN0IGRybV9pOTE1X2dlbV9v YmplY3QgKm9iajsKKwlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycTsKKwlzdHJ1Y3QgaTkxNV9nZW1f d3dfY3R4IHd3OworCXUzMiAqdmFkZHI7CisJaW50IGVyciA9IDA7CisJaW50IGk7CisKKwlvYmog PSBjcmVhdGVfbG1lbV9vcl9pbnRlcm5hbChpOTE1LCBzeik7CisJaWYgKElTX0VSUihvYmopKQor CQlyZXR1cm4gMDsKKworCWZvcl9pOTE1X2dlbV93dygmd3csIGVyciwgdHJ1ZSkgeworCQllcnIg PSBpOTE1X2dlbV9vYmplY3RfbG9jayhvYmosICZ3dyk7CisJCWlmIChlcnIpCisJCQljb250aW51 ZTsKKworCQl2YWRkciA9IGk5MTVfZ2VtX29iamVjdF9waW5fbWFwKG9iaiwgSTkxNV9NQVBfV0Mp OworCQlpZiAoSVNfRVJSKHZhZGRyKSkgeworCQkJZXJyID0gUFRSX0VSUih2YWRkcik7CisJCQlj b250aW51ZTsKKwkJfQorCisJCWZvciAoaSA9IDA7IGkgPCBzeiAvIHNpemVvZih1MzIpOyBpKysp CisJCQl2YWRkcltpXSA9IH5pOworCQlpOTE1X2dlbV9vYmplY3RfZmx1c2hfbWFwKG9iaik7CisK KwkJZXJyID0gZm4obWlncmF0ZSwgJnd3LCBvYmosIHN6LCAmcnEpOworCQlpZiAoIWVycikKKwkJ CWNvbnRpbnVlOworCisJCWlmIChlcnIgIT0gLUVERUFETEsgJiYgZXJyICE9IC1FSU5UUiAmJiBl cnIgIT0gLUVSRVNUQVJUU1lTKQorCQkJcHJfZXJyKCIlcHMgZmFpbGVkLCBzaXplOiAldVxuIiwg Zm4sIHN6KTsKKwkJaWYgKHJxKSB7CisJCQlpOTE1X3JlcXVlc3Rfd2FpdChycSwgMCwgSFopOwor CQkJaTkxNV9yZXF1ZXN0X3B1dChycSk7CisJCX0KKwkJaTkxNV9nZW1fb2JqZWN0X3VucGluX21h cChvYmopOworCX0KKwlpZiAoZXJyKQorCQlnb3RvIGVycl9vdXQ7CisKKwlpZiAocnEpIHsKKwkJ aWYgKGk5MTVfcmVxdWVzdF93YWl0KHJxLCAwLCBIWikgPCAwKSB7CisJCQlwcl9lcnIoIiVwcyB0 aW1lZCBvdXQsIHNpemU6ICV1XG4iLCBmbiwgc3opOworCQkJZXJyID0gLUVUSU1FOworCQl9CisJ CWk5MTVfcmVxdWVzdF9wdXQocnEpOworCX0KKworCWZvciAoaSA9IDA7ICFlcnIgJiYgaSA8IHN6 IC8gUEFHRV9TSVpFOyBpKyspIHsKKwkJaW50IHggPSBpICogMTAyNCArIGk5MTVfcHJhbmRvbV91 MzJfbWF4X3N0YXRlKDEwMjQsIHBybmcpOworCisJCWlmICh2YWRkclt4XSAhPSBzeikgeworCQkJ cHJfZXJyKCIlcHMgZmFpbGVkLCBzaXplOiAldSwgb2Zmc2V0OiAlenVcbiIsCisJCQkgICAgICAg Zm4sIHN6LCB4ICogc2l6ZW9mKHUzMikpOworCQkJaWd0X2hleGR1bXAodmFkZHIgKyBpICogMTAy NCwgNDA5Nik7CisJCQllcnIgPSAtRUlOVkFMOworCQl9CisJfQorCisJaTkxNV9nZW1fb2JqZWN0 X3VucGluX21hcChvYmopOworZXJyX291dDoKKwlpOTE1X2dlbV9vYmplY3RfcHV0KG9iaik7CisK KwlyZXR1cm4gZXJyOworfQorCiBzdGF0aWMgaW50IF9fbWlncmF0ZV9jb3B5KHN0cnVjdCBpbnRl bF9taWdyYXRlICptaWdyYXRlLAogCQkJICBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4ICp3dywKIAkJ CSAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKnNyYywKQEAgLTE2OSw2ICsyNDUsNDQgQEAg Z2xvYmFsX2NvcHkoc3RydWN0IGludGVsX21pZ3JhdGUgKm1pZ3JhdGUsIHUzMiBzeiwgc3RydWN0 IHJuZF9zdGF0ZSAqcHJuZykKIAlyZXR1cm4gY29weShtaWdyYXRlLCBfX2dsb2JhbF9jb3B5LCBz eiwgcHJuZyk7CiB9CiAKK3N0YXRpYyBpbnQgX19taWdyYXRlX2NsZWFyKHN0cnVjdCBpbnRlbF9t aWdyYXRlICptaWdyYXRlLAorCQkJICAgc3RydWN0IGk5MTVfZ2VtX3d3X2N0eCAqd3csCisJCQkg ICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAorCQkJICAgdTMyIHZhbHVlLAorCQkJ ICAgc3RydWN0IGk5MTVfcmVxdWVzdCAqKm91dCkKK3sKKwlyZXR1cm4gaW50ZWxfbWlncmF0ZV9j bGVhcihtaWdyYXRlLCB3dywgTlVMTCwKKwkJCQkgICBvYmotPm1tLnBhZ2VzLT5zZ2wsCisJCQkJ ICAgb2JqLT5jYWNoZV9sZXZlbCwKKwkJCQkgICBpOTE1X2dlbV9vYmplY3RfaXNfbG1lbShvYmop LAorCQkJCSAgIHZhbHVlLCBvdXQpOworfQorCitzdGF0aWMgaW50IF9fZ2xvYmFsX2NsZWFyKHN0 cnVjdCBpbnRlbF9taWdyYXRlICptaWdyYXRlLAorCQkJICBzdHJ1Y3QgaTkxNV9nZW1fd3dfY3R4 ICp3dywKKwkJCSAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKKwkJCSAgdTMyIHZh bHVlLAorCQkJICBzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICoqb3V0KQoreworCXJldHVybiBpbnRlbF9j b250ZXh0X21pZ3JhdGVfY2xlYXIobWlncmF0ZS0+Y29udGV4dCwgTlVMTCwKKwkJCQkJICAgb2Jq LT5tbS5wYWdlcy0+c2dsLAorCQkJCQkgICBvYmotPmNhY2hlX2xldmVsLAorCQkJCQkgICBpOTE1 X2dlbV9vYmplY3RfaXNfbG1lbShvYmopLAorCQkJCQkgICB2YWx1ZSwgb3V0KTsKK30KKworc3Rh dGljIGludAorbWlncmF0ZV9jbGVhcihzdHJ1Y3QgaW50ZWxfbWlncmF0ZSAqbWlncmF0ZSwgdTMy IHN6LCBzdHJ1Y3Qgcm5kX3N0YXRlICpwcm5nKQoreworCXJldHVybiBjbGVhcihtaWdyYXRlLCBf X21pZ3JhdGVfY2xlYXIsIHN6LCBwcm5nKTsKK30KKworc3RhdGljIGludAorZ2xvYmFsX2NsZWFy KHN0cnVjdCBpbnRlbF9taWdyYXRlICptaWdyYXRlLCB1MzIgc3osIHN0cnVjdCBybmRfc3RhdGUg KnBybmcpCit7CisJcmV0dXJuIGNsZWFyKG1pZ3JhdGUsIF9fZ2xvYmFsX2NsZWFyLCBzeiwgcHJu Zyk7Cit9CisKIHN0YXRpYyBpbnQgbGl2ZV9taWdyYXRlX2NvcHkodm9pZCAqYXJnKQogewogCXN0 cnVjdCBpbnRlbF9taWdyYXRlICptaWdyYXRlID0gYXJnOwpAQCAtMTkwLDYgKzMwNCwyOCBAQCBz dGF0aWMgaW50IGxpdmVfbWlncmF0ZV9jb3B5KHZvaWQgKmFyZykKIAlyZXR1cm4gMDsKIH0KIAor c3RhdGljIGludCBsaXZlX21pZ3JhdGVfY2xlYXIodm9pZCAqYXJnKQoreworCXN0cnVjdCBpbnRl bF9taWdyYXRlICptaWdyYXRlID0gYXJnOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1 ID0gbWlncmF0ZS0+Y29udGV4dC0+ZW5naW5lLT5pOTE1OworCUk5MTVfUk5EX1NUQVRFKHBybmcp OworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc2l6ZXMpOyBpKyspIHsK KwkJaW50IGVycjsKKworCQllcnIgPSBtaWdyYXRlX2NsZWFyKG1pZ3JhdGUsIHNpemVzW2ldLCAm cHJuZyk7CisJCWlmIChlcnIgPT0gMCkKKwkJCWVyciA9IGdsb2JhbF9jbGVhcihtaWdyYXRlLCBz aXplc1tpXSwgJnBybmcpOworCisJCWk5MTVfZ2VtX2RyYWluX2ZyZWVkX29iamVjdHMoaTkxNSk7 CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOworCX0KKworCXJldHVybiAwOworfQorCiBzdHJ1 Y3QgdGhyZWFkZWRfbWlncmF0ZSB7CiAJc3RydWN0IGludGVsX21pZ3JhdGUgKm1pZ3JhdGU7CiAJ c3RydWN0IHRhc2tfc3RydWN0ICp0c2s7CkBAIC0yNzEsMTIgKzQwNywzOSBAQCBzdGF0aWMgaW50 IHRocmVhZF9nbG9iYWxfY29weSh2b2lkICphcmcpCiAJcmV0dXJuIHRocmVhZGVkX21pZ3JhdGUo YXJnLCBfX3RocmVhZF9nbG9iYWxfY29weSwgMCk7CiB9CiAKK3N0YXRpYyBpbnQgX190aHJlYWRf bWlncmF0ZV9jbGVhcih2b2lkICphcmcpCit7CisJc3RydWN0IHRocmVhZGVkX21pZ3JhdGUgKnRt ID0gYXJnOworCisJcmV0dXJuIG1pZ3JhdGVfY2xlYXIodG0tPm1pZ3JhdGUsIDIgKiBDSFVOS19T WiwgJnRtLT5wcm5nKTsKK30KKworc3RhdGljIGludCBfX3RocmVhZF9nbG9iYWxfY2xlYXIodm9p ZCAqYXJnKQoreworCXN0cnVjdCB0aHJlYWRlZF9taWdyYXRlICp0bSA9IGFyZzsKKworCXJldHVy biBnbG9iYWxfY2xlYXIodG0tPm1pZ3JhdGUsIDIgKiBDSFVOS19TWiwgJnRtLT5wcm5nKTsKK30K Kworc3RhdGljIGludCB0aHJlYWRfbWlncmF0ZV9jbGVhcih2b2lkICphcmcpCit7CisJcmV0dXJu IHRocmVhZGVkX21pZ3JhdGUoYXJnLCBfX3RocmVhZF9taWdyYXRlX2NsZWFyLCAwKTsKK30KKwor c3RhdGljIGludCB0aHJlYWRfZ2xvYmFsX2NsZWFyKHZvaWQgKmFyZykKK3sKKwlyZXR1cm4gdGhy ZWFkZWRfbWlncmF0ZShhcmcsIF9fdGhyZWFkX2dsb2JhbF9jbGVhciwgMCk7Cit9CisKIGludCBp bnRlbF9taWdyYXRlX2xpdmVfc2VsZnRlc3RzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1 KQogewogCXN0YXRpYyBjb25zdCBzdHJ1Y3QgaTkxNV9zdWJ0ZXN0IHRlc3RzW10gPSB7CiAJCVNV QlRFU1QobGl2ZV9taWdyYXRlX2NvcHkpLAorCQlTVUJURVNUKGxpdmVfbWlncmF0ZV9jbGVhciks CiAJCVNVQlRFU1QodGhyZWFkX21pZ3JhdGVfY29weSksCisJCVNVQlRFU1QodGhyZWFkX21pZ3Jh dGVfY2xlYXIpLAogCQlTVUJURVNUKHRocmVhZF9nbG9iYWxfY29weSksCisJCVNVQlRFU1QodGhy ZWFkX2dsb2JhbF9jbGVhciksCiAJfTsKIAlzdHJ1Y3QgaW50ZWxfbWlncmF0ZSBtOwogCWludCBl cnI7Ci0tIAoyLjMxLjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVs LWdmeAo= 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.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,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 64B23C49361 for ; Thu, 17 Jun 2021 06:30:55 +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 359D7613E9 for ; Thu, 17 Jun 2021 06:30:55 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 359D7613E9 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com 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 C9D6C6E87D; Thu, 17 Jun 2021 06:30:51 +0000 (UTC) Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5D1496E87B; Thu, 17 Jun 2021 06:30:48 +0000 (UTC) IronPort-SDR: s5S+1q0I4RFQ/uk2Otkkd7MB0F8XaAXXvaLmgfycNSY8u2W/fPG0/1LbOIx1uJ+IGhwr0H15vr VzNGZrFD1ovQ== X-IronPort-AV: E=McAfee;i="6200,9189,10017"; a="203287837" X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="203287837" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga102.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:48 -0700 IronPort-SDR: eAZHIKwgQktvA38+K66Hmfo56vYRzg7Bw57Ma4MPZp9r01WPWv0+Mq31TPJR+jJMwi5vqP9SUG +oJHvGEOoyOQ== X-IronPort-AV: E=Sophos;i="5.83,278,1616482800"; d="scan'208";a="554302728" Received: from vanderss-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.193]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Jun 2021 23:30:46 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v5 08/12] drm/i915/gt: Pipelined clear Date: Thu, 17 Jun 2021 08:30:14 +0200 Message-Id: <20210617063018.92802-9-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> References: <20210617063018.92802-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com, Chris Wilson Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Chris Wilson Update the PTE and emit a clear within a single unpreemptible packet such that we can schedule and pipeline clears. Signed-off-by: Chris Wilson Co-developed-by: Thomas Hellström Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- v3: - Handle engine instances correctly (Reported by Matthew Auld) --- drivers/gpu/drm/i915/gt/intel_migrate.c | 143 ++++++++++++++++++ drivers/gpu/drm/i915/gt/intel_migrate.h | 20 +++ drivers/gpu/drm/i915/gt/selftest_migrate.c | 163 +++++++++++++++++++++ 3 files changed, 326 insertions(+) diff --git a/drivers/gpu/drm/i915/gt/intel_migrate.c b/drivers/gpu/drm/i915/gt/intel_migrate.c index e2e860063e7b..ba4009120b33 100644 --- a/drivers/gpu/drm/i915/gt/intel_migrate.c +++ b/drivers/gpu/drm/i915/gt/intel_migrate.c @@ -488,6 +488,114 @@ intel_context_migrate_copy(struct intel_context *ce, return err; } +static int emit_clear(struct i915_request *rq, int size, u32 value) +{ + const int gen = INTEL_GEN(rq->engine->i915); + u32 instance = rq->engine->instance; + u32 *cs; + + GEM_BUG_ON(size >> PAGE_SHIFT > S16_MAX); + + cs = intel_ring_begin(rq, gen >= 8 ? 8 : 6); + if (IS_ERR(cs)) + return PTR_ERR(cs); + + if (gen >= 8) { + *cs++ = XY_COLOR_BLT_CMD | BLT_WRITE_RGBA | (7 - 2); + *cs++ = BLT_DEPTH_32 | BLT_ROP_COLOR_COPY | PAGE_SIZE; + *cs++ = 0; + *cs++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE / 4; + *cs++ = 0; /* offset */ + *cs++ = instance; + *cs++ = value; + *cs++ = MI_NOOP; + } else { + GEM_BUG_ON(instance); + *cs++ = XY_COLOR_BLT_CMD | BLT_WRITE_RGBA | (6 - 2); + *cs++ = BLT_DEPTH_32 | BLT_ROP_COLOR_COPY | PAGE_SIZE; + *cs++ = 0; + *cs++ = size >> PAGE_SHIFT << 16 | PAGE_SIZE / 4; + *cs++ = 0; + *cs++ = value; + } + + intel_ring_advance(rq, cs); + return 0; +} + +int +intel_context_migrate_clear(struct intel_context *ce, + struct dma_fence *await, + struct scatterlist *sg, + enum i915_cache_level cache_level, + bool is_lmem, + u32 value, + struct i915_request **out) +{ + struct sgt_dma it = sg_sgt(sg); + struct i915_request *rq; + int err; + + *out = NULL; + + GEM_BUG_ON(ce->ring->size < SZ_64K); + + do { + int len; + + rq = i915_request_create(ce); + if (IS_ERR(rq)) { + err = PTR_ERR(rq); + goto out_ce; + } + + if (await) { + err = i915_request_await_dma_fence(rq, await); + if (err) + goto out_rq; + + if (rq->engine->emit_init_breadcrumb) { + err = rq->engine->emit_init_breadcrumb(rq); + if (err) + goto out_rq; + } + + await = NULL; + } + + /* The PTE updates + clear must not be interrupted. */ + err = emit_no_arbitration(rq); + if (err) + goto out_rq; + + len = emit_pte(rq, &it, cache_level, is_lmem, 0, CHUNK_SZ); + if (len <= 0) { + err = len; + goto out_rq; + } + + err = rq->engine->emit_flush(rq, EMIT_INVALIDATE); + if (err) + goto out_rq; + + err = emit_clear(rq, len, value); + + /* Arbitration is re-enabled between requests. */ +out_rq: + if (*out) + i915_request_put(*out); + *out = i915_request_get(rq); + i915_request_add(rq); + if (err || !it.sg || !sg_dma_len(it.sg)) + break; + + cond_resched(); + } while (1); + +out_ce: + return err; +} + int intel_migrate_copy(struct intel_migrate *m, struct i915_gem_ww_ctx *ww, struct dma_fence *await, @@ -526,6 +634,41 @@ int intel_migrate_copy(struct intel_migrate *m, return err; } +int +intel_migrate_clear(struct intel_migrate *m, + struct i915_gem_ww_ctx *ww, + struct dma_fence *await, + struct scatterlist *sg, + enum i915_cache_level cache_level, + bool is_lmem, + u32 value, + struct i915_request **out) +{ + struct intel_context *ce; + int err; + + *out = NULL; + if (!m->context) + return -ENODEV; + + ce = intel_migrate_create_context(m); + if (IS_ERR(ce)) + ce = intel_context_get(m->context); + GEM_BUG_ON(IS_ERR(ce)); + + err = intel_context_pin_ww(ce, ww); + if (err) + goto out; + + err = intel_context_migrate_clear(ce, await, sg, cache_level, + is_lmem, value, out); + + intel_context_unpin(ce); +out: + intel_context_put(ce); + return err; +} + void intel_migrate_fini(struct intel_migrate *m) { struct intel_context *ce; diff --git a/drivers/gpu/drm/i915/gt/intel_migrate.h b/drivers/gpu/drm/i915/gt/intel_migrate.h index 32c61190ed73..4e18e755a00b 100644 --- a/drivers/gpu/drm/i915/gt/intel_migrate.h +++ b/drivers/gpu/drm/i915/gt/intel_migrate.h @@ -6,6 +6,8 @@ #ifndef __INTEL_MIGRATE__ #define __INTEL_MIGRATE__ +#include + #include "intel_migrate_types.h" struct dma_fence; @@ -40,6 +42,24 @@ int intel_context_migrate_copy(struct intel_context *ce, bool dst_is_lmem, struct i915_request **out); +int +intel_migrate_clear(struct intel_migrate *m, + struct i915_gem_ww_ctx *ww, + struct dma_fence *await, + struct scatterlist *sg, + enum i915_cache_level cache_level, + bool is_lmem, + u32 value, + struct i915_request **out); +int +intel_context_migrate_clear(struct intel_context *ce, + struct dma_fence *await, + struct scatterlist *sg, + enum i915_cache_level cache_level, + bool is_lmem, + u32 value, + struct i915_request **out); + void intel_migrate_fini(struct intel_migrate *m); #endif /* __INTEL_MIGRATE__ */ diff --git a/drivers/gpu/drm/i915/gt/selftest_migrate.c b/drivers/gpu/drm/i915/gt/selftest_migrate.c index 9784d149ebf1..159c8656e1b0 100644 --- a/drivers/gpu/drm/i915/gt/selftest_migrate.c +++ b/drivers/gpu/drm/i915/gt/selftest_migrate.c @@ -129,6 +129,82 @@ static int copy(struct intel_migrate *migrate, return err; } +static int clear(struct intel_migrate *migrate, + int (*fn)(struct intel_migrate *migrate, + struct i915_gem_ww_ctx *ww, + struct drm_i915_gem_object *obj, + u32 value, + struct i915_request **out), + u32 sz, struct rnd_state *prng) +{ + struct drm_i915_private *i915 = migrate->context->engine->i915; + struct drm_i915_gem_object *obj; + struct i915_request *rq; + struct i915_gem_ww_ctx ww; + u32 *vaddr; + int err = 0; + int i; + + obj = create_lmem_or_internal(i915, sz); + if (IS_ERR(obj)) + return 0; + + for_i915_gem_ww(&ww, err, true) { + err = i915_gem_object_lock(obj, &ww); + if (err) + continue; + + vaddr = i915_gem_object_pin_map(obj, I915_MAP_WC); + if (IS_ERR(vaddr)) { + err = PTR_ERR(vaddr); + continue; + } + + for (i = 0; i < sz / sizeof(u32); i++) + vaddr[i] = ~i; + i915_gem_object_flush_map(obj); + + err = fn(migrate, &ww, obj, sz, &rq); + if (!err) + continue; + + if (err != -EDEADLK && err != -EINTR && err != -ERESTARTSYS) + pr_err("%ps failed, size: %u\n", fn, sz); + if (rq) { + i915_request_wait(rq, 0, HZ); + i915_request_put(rq); + } + i915_gem_object_unpin_map(obj); + } + if (err) + goto err_out; + + if (rq) { + if (i915_request_wait(rq, 0, HZ) < 0) { + pr_err("%ps timed out, size: %u\n", fn, sz); + err = -ETIME; + } + i915_request_put(rq); + } + + for (i = 0; !err && i < sz / PAGE_SIZE; i++) { + int x = i * 1024 + i915_prandom_u32_max_state(1024, prng); + + if (vaddr[x] != sz) { + pr_err("%ps failed, size: %u, offset: %zu\n", + fn, sz, x * sizeof(u32)); + igt_hexdump(vaddr + i * 1024, 4096); + err = -EINVAL; + } + } + + i915_gem_object_unpin_map(obj); +err_out: + i915_gem_object_put(obj); + + return err; +} + static int __migrate_copy(struct intel_migrate *migrate, struct i915_gem_ww_ctx *ww, struct drm_i915_gem_object *src, @@ -169,6 +245,44 @@ global_copy(struct intel_migrate *migrate, u32 sz, struct rnd_state *prng) return copy(migrate, __global_copy, sz, prng); } +static int __migrate_clear(struct intel_migrate *migrate, + struct i915_gem_ww_ctx *ww, + struct drm_i915_gem_object *obj, + u32 value, + struct i915_request **out) +{ + return intel_migrate_clear(migrate, ww, NULL, + obj->mm.pages->sgl, + obj->cache_level, + i915_gem_object_is_lmem(obj), + value, out); +} + +static int __global_clear(struct intel_migrate *migrate, + struct i915_gem_ww_ctx *ww, + struct drm_i915_gem_object *obj, + u32 value, + struct i915_request **out) +{ + return intel_context_migrate_clear(migrate->context, NULL, + obj->mm.pages->sgl, + obj->cache_level, + i915_gem_object_is_lmem(obj), + value, out); +} + +static int +migrate_clear(struct intel_migrate *migrate, u32 sz, struct rnd_state *prng) +{ + return clear(migrate, __migrate_clear, sz, prng); +} + +static int +global_clear(struct intel_migrate *migrate, u32 sz, struct rnd_state *prng) +{ + return clear(migrate, __global_clear, sz, prng); +} + static int live_migrate_copy(void *arg) { struct intel_migrate *migrate = arg; @@ -190,6 +304,28 @@ static int live_migrate_copy(void *arg) return 0; } +static int live_migrate_clear(void *arg) +{ + struct intel_migrate *migrate = arg; + struct drm_i915_private *i915 = migrate->context->engine->i915; + I915_RND_STATE(prng); + int i; + + for (i = 0; i < ARRAY_SIZE(sizes); i++) { + int err; + + err = migrate_clear(migrate, sizes[i], &prng); + if (err == 0) + err = global_clear(migrate, sizes[i], &prng); + + i915_gem_drain_freed_objects(i915); + if (err) + return err; + } + + return 0; +} + struct threaded_migrate { struct intel_migrate *migrate; struct task_struct *tsk; @@ -271,12 +407,39 @@ static int thread_global_copy(void *arg) return threaded_migrate(arg, __thread_global_copy, 0); } +static int __thread_migrate_clear(void *arg) +{ + struct threaded_migrate *tm = arg; + + return migrate_clear(tm->migrate, 2 * CHUNK_SZ, &tm->prng); +} + +static int __thread_global_clear(void *arg) +{ + struct threaded_migrate *tm = arg; + + return global_clear(tm->migrate, 2 * CHUNK_SZ, &tm->prng); +} + +static int thread_migrate_clear(void *arg) +{ + return threaded_migrate(arg, __thread_migrate_clear, 0); +} + +static int thread_global_clear(void *arg) +{ + return threaded_migrate(arg, __thread_global_clear, 0); +} + int intel_migrate_live_selftests(struct drm_i915_private *i915) { static const struct i915_subtest tests[] = { SUBTEST(live_migrate_copy), + SUBTEST(live_migrate_clear), SUBTEST(thread_migrate_copy), + SUBTEST(thread_migrate_clear), SUBTEST(thread_global_copy), + SUBTEST(thread_global_clear), }; struct intel_migrate m; int err; -- 2.31.1