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,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 3AD77C6377D for ; Tue, 20 Jul 2021 20:40:56 +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 0FF9560FEA for ; Tue, 20 Jul 2021 20:40:56 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0FF9560FEA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 BFA806E563; Tue, 20 Jul 2021 20:40:25 +0000 (UTC) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id 378D56E50C; Tue, 20 Jul 2021 20:40:18 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10051"; a="296885376" X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="296885376" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:17 -0700 X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="414906087" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga006-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:16 -0700 From: Matthew Brost To: , Date: Tue, 20 Jul 2021 13:57:48 -0700 Message-Id: <20210720205802.39610-29-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210720205802.39610-1-matthew.brost@intel.com> References: <20210720205802.39610-1-matthew.brost@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [RFC PATCH 28/42] drm/i915/guc: Add basic GuC multi-lrc selftest 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: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" QWRkIHZlcnkgYmFzaWMgKHNpbmdsZSBzdWJtaXNzaW9uKSBtdWx0aS1scmMgc2VsZnRlc3QuCgpT aWduZWQtb2ZmLWJ5OiBNYXR0aGV3IEJyb3N0IDxtYXR0aGV3LmJyb3N0QGludGVsLmNvbT4KLS0t CiAuLi4vZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19zdWJtaXNzaW9uLmMgfCAgIDEgKwog Li4uL2RybS9pOTE1L2d0L3VjL3NlbGZ0ZXN0X2d1Y19tdWx0aV9scmMuYyAgIHwgMTY4ICsrKysr KysrKysrKysrKysrKwogLi4uL2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X2xpdmVfc2VsZnRlc3Rz LmggIHwgICAxICsKIDMgZmlsZXMgY2hhbmdlZCwgMTcwIGluc2VydGlvbnMoKykKIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9zZWxmdGVzdF9ndWNfbXVsdGlf bHJjLmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNf c3VibWlzc2lvbi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1p c3Npb24uYwppbmRleCAzMjZjYjRmYzhhOWQuLmRkZTZhYWIxZGI4NSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX3N1Ym1pc3Npb24uYworKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfc3VibWlzc2lvbi5jCkBAIC00NzM3LDQg KzQ3MzcsNSBAQCBib29sIGludGVsX2d1Y192aXJ0dWFsX2VuZ2luZV9oYXNfaGVhcnRiZWF0KGNv bnN0IHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKnZlKQogCiAjaWYgSVNfRU5BQkxFRChDT05GSUdf RFJNX0k5MTVfU0VMRlRFU1QpCiAjaW5jbHVkZSAic2VsZnRlc3RfZ3VjX2Zsb3dfY29udHJvbC5j IgorI2luY2x1ZGUgInNlbGZ0ZXN0X2d1Y19tdWx0aV9scmMuYyIKICNlbmRpZgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvc2VsZnRlc3RfZ3VjX211bHRpX2xyYy5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvc2VsZnRlc3RfZ3VjX211bHRpX2xyYy5jCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMjI2ZTY0ZmVlOTE5Ci0tLSAvZGV2 L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvc2VsZnRlc3RfZ3VjX211bHRp X2xyYy5jCkBAIC0wLDAgKzEsMTY4IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlU CisvKgorICogQ29weXJpZ2h0IO+/ve+/vSAyMDE5IEludGVsIENvcnBvcmF0aW9uCisgKi8KKwor I2luY2x1ZGUgInNlbGZ0ZXN0cy9pZ3Rfc3Bpbm5lci5oIgorI2luY2x1ZGUgInNlbGZ0ZXN0cy9p Z3RfcmVzZXQuaCIKKyNpbmNsdWRlICJzZWxmdGVzdHMvaW50ZWxfc2NoZWR1bGVyX2hlbHBlcnMu aCIKKyNpbmNsdWRlICJndC9pbnRlbF9lbmdpbmVfaGVhcnRiZWF0LmgiCisjaW5jbHVkZSAiZ2Vt L3NlbGZ0ZXN0cy9tb2NrX2NvbnRleHQuaCIKKworc3RhdGljIHZvaWQgbG9naWNhbF9zb3J0KHN0 cnVjdCBpbnRlbF9lbmdpbmVfY3MgKiplbmdpbmVzLCBpbnQgbnVtX2VuZ2luZXMpCit7CisJc3Ry dWN0IGludGVsX2VuZ2luZV9jcyAqc29ydGVkW01BWF9FTkdJTkVfSU5TVEFOQ0UgKyAxXTsKKwlp bnQgaSwgajsKKworCWZvciAoaSA9IDA7IGkgPCBudW1fZW5naW5lczsgKytpKQorCQlmb3IgKGog PSAwOyBqIDwgTUFYX0VOR0lORV9JTlNUQU5DRSArIDE7ICsraikgeworCQkJaWYgKGVuZ2luZXNb al0tPmxvZ2ljYWxfbWFzayAmIEJJVChpKSkgeworCQkJCXNvcnRlZFtpXSA9IGVuZ2luZXNbal07 CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKworCW1lbWNweSgqZW5naW5lcywgKnNvcnRlZCwKKwkg ICAgICAgc2l6ZW9mKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKikgKiBudW1fZW5naW5lcyk7Cit9 CisKK3N0YXRpYyBzdHJ1Y3QgaW50ZWxfY29udGV4dCAqCittdWx0aV9scmNfY3JlYXRlX3BhcmVu dChzdHJ1Y3QgaW50ZWxfZ3QgKmd0LCB1OCBjbGFzcywKKwkJCXVuc2lnbmVkIGxvbmcgZmxhZ3Mp Cit7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqc2libGluZ3NbTUFYX0VOR0lORV9JTlNUQU5D RSArIDFdOworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZTsKKwllbnVtIGludGVsX2Vu Z2luZV9pZCBpZDsKKwlpbnQgaSA9IDA7CisKKwlmb3JfZWFjaF9lbmdpbmUoZW5naW5lLCBndCwg aWQpIHsKKwkJaWYgKGVuZ2luZS0+Y2xhc3MgIT0gY2xhc3MpCisJCQljb250aW51ZTsKKworCQlz aWJsaW5nc1tpKytdID0gZW5naW5lOworCX0KKworCWlmIChpIDw9IDEpCisJCXJldHVybiBFUlJf UFRSKDApOworCisJbG9naWNhbF9zb3J0KHNpYmxpbmdzLCBpKTsKKworCXJldHVybiBpbnRlbF9l bmdpbmVfY3JlYXRlX3BhcmFsbGVsKHNpYmxpbmdzLCAxLCBpKTsKK30KKworc3RhdGljIHZvaWQg bXVsdGlfbHJjX2NvbnRleHRfcHV0KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSkKK3sKKwlHRU1f QlVHX09OKCFpbnRlbF9jb250ZXh0X2lzX3BhcmVudChjZSkpOworCisJLyoKKwkgKiBPbmx5IHRo ZSBwYXJlbnQgZ2V0cyB0aGUgY3JlYXRpb24gcmVmIHB1dCBpbiB0aGUgdUFQSSwgdGhlIHBhcmVu dAorCSAqIGl0c2VsZiBpcyByZXNwb25zaWJsZSBmb3IgY3JlYXRpb24gcmVmIHB1dCBvbiB0aGUg Y2hpbGRyZW4uCisJICovCisJaW50ZWxfY29udGV4dF9wdXQoY2UpOworfQorCitzdGF0aWMgc3Ry dWN0IGk5MTVfcmVxdWVzdCAqCittdWx0aV9scmNfbm9wX3JlcXVlc3Qoc3RydWN0IGludGVsX2Nv bnRleHQgKmNlKQoreworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjaGlsZDsKKwlzdHJ1Y3QgaTkx NV9yZXF1ZXN0ICpycSwgKmNoaWxkX3JxOworCWludCBpID0gMDsKKworCUdFTV9CVUdfT04oIWlu dGVsX2NvbnRleHRfaXNfcGFyZW50KGNlKSk7CisKKwlycSA9IGludGVsX2NvbnRleHRfY3JlYXRl X3JlcXVlc3QoY2UpOworCWlmIChJU19FUlIocnEpKQorCQlyZXR1cm4gcnE7CisKKwlpOTE1X3Jl cXVlc3RfZ2V0KHJxKTsKKwlpOTE1X3JlcXVlc3RfYWRkKHJxKTsKKworCWZvcl9lYWNoX2NoaWxk KGNlLCBjaGlsZCkgeworCQljaGlsZF9ycSA9IGludGVsX2NvbnRleHRfY3JlYXRlX3JlcXVlc3Qo Y2hpbGQpOworCQlpZiAoSVNfRVJSKGNoaWxkX3JxKSkKKwkJCWdvdG8gY2hpbGRfZXJyb3I7CisK KwkJaWYgKCsraSA9PSBjZS0+Z3VjX251bWJlcl9jaGlsZHJlbikKKwkJCXNldF9iaXQoSTkxNV9G RU5DRV9GTEFHX1NVQk1JVF9QQVJBTExFTCwKKwkJCQkmY2hpbGRfcnEtPmZlbmNlLmZsYWdzKTsK KwkJaTkxNV9yZXF1ZXN0X2FkZChjaGlsZF9ycSk7CisJfQorCisJcmV0dXJuIHJxOworCitjaGls ZF9lcnJvcjoKKwlpOTE1X3JlcXVlc3RfcHV0KHJxKTsKKworCXJldHVybiBFUlJfUFRSKC1FTk9N RU0pOworfQorCitzdGF0aWMgaW50IF9faW50ZWxfZ3VjX211bHRpX2xyY19iYXNpYyhzdHJ1Y3Qg aW50ZWxfZ3QgKmd0LCB1bnNpZ25lZCBpbnQgY2xhc3MpCit7CisJc3RydWN0IGludGVsX2NvbnRl eHQgKnBhcmVudDsKKwlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycTsKKwlpbnQgcmV0OworCisJcGFy ZW50ID0gbXVsdGlfbHJjX2NyZWF0ZV9wYXJlbnQoZ3QsIGNsYXNzLCAwKTsKKwlpZiAoSVNfRVJS KHBhcmVudCkpIHsKKwkJcHJfZXJyKCJGYWlsZWQgY3JlYXRpbmcgY29udGV4dHM6ICVsZCIsIFBU Ul9FUlIocGFyZW50KSk7CisJCXJldHVybiBQVFJfRVJSKHBhcmVudCk7CisJfSBlbHNlIGlmIChw YXJlbnQgPT0gTlVMTCkgeworCQlwcl9kZWJ1ZygiTm90IGVub3VnaCBlbmdpbmVzIGluIGNsYXNz OiAlZCIsCisJCQkgVklERU9fREVDT0RFX0NMQVNTKTsKKwkJcmV0dXJuIDA7CisJfQorCisJcnEg PSBtdWx0aV9scmNfbm9wX3JlcXVlc3QocGFyZW50KTsKKwlpZiAoSVNfRVJSKHJxKSkgeworCQly ZXQgPSBQVFJfRVJSKHJxKTsKKwkJcHJfZXJyKCJGYWlsZWQgY3JlYXRpbmcgcmVxdWVzdHM6ICVk IiwgcmV0KTsKKwkJZ290byBvdXQ7CisJfQorCisJcmV0ID0gaW50ZWxfc2VsZnRlc3Rfd2FpdF9m b3JfcnEocnEpOworCWlmIChyZXQpCisJCXByX2VycigiRmFpbGVkIHdhaXRpbmcgb24gcmVxdWVz dDogJWQiLCByZXQpOworCisJaTkxNV9yZXF1ZXN0X3B1dChycSk7CisKKwlpZiAocmV0ID49IDAp IHsKKwkJcmV0ID0gaW50ZWxfZ3Rfd2FpdF9mb3JfaWRsZShndCwgSFogKiA1KTsKKwkJaWYgKHJl dCA8IDApCisJCQlwcl9lcnIoIkdUIGZhaWxlZCB0byBpZGxlOiAlZFxuIiwgcmV0KTsKKwl9CisK K291dDoKKwltdWx0aV9scmNfY29udGV4dF9wdXQocGFyZW50KTsKKwlyZXR1cm4gcmV0OworfQor CitzdGF0aWMgaW50IGludGVsX2d1Y19tdWx0aV9scmNfYmFzaWModm9pZCAqYXJnKQoreworCXN0 cnVjdCBpbnRlbF9ndCAqZ3QgPSBhcmc7CisJdW5zaWduZWQgY2xhc3M7CisJaW50IHJldDsKKwor CWZvciAoY2xhc3MgPSAwOyBjbGFzcyA8IE1BWF9FTkdJTkVfQ0xBU1MgKyAxOyArK2NsYXNzKSB7 CisJCXJldCA9IF9faW50ZWxfZ3VjX211bHRpX2xyY19iYXNpYyhndCwgY2xhc3MpOworCQlpZiAo cmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworaW50IGludGVsX2d1 Y19tdWx0aV9scmMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUpCit7CisJc3RhdGljIGNv bnN0IHN0cnVjdCBpOTE1X3N1YnRlc3QgdGVzdHNbXSA9IHsKKwkJU1VCVEVTVChpbnRlbF9ndWNf bXVsdGlfbHJjX2Jhc2ljKSwKKwl9OworCXN0cnVjdCBpbnRlbF9ndCAqZ3QgPSAmaTkxNS0+Z3Q7 CisKKwlpZiAoaW50ZWxfZ3RfaXNfd2VkZ2VkKGd0KSkKKwkJcmV0dXJuIDA7CisKKwlpZiAoIWlu dGVsX3VjX3VzZXNfZ3VjX3N1Ym1pc3Npb24oJmd0LT51YykpCisJCXJldHVybiAwOworCisJcmV0 dXJuIGludGVsX2d0X2xpdmVfc3VidGVzdHModGVzdHMsIGd0KTsKK30KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X2xpdmVfc2VsZnRlc3RzLmggYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9saXZlX3NlbGZ0ZXN0cy5oCmluZGV4IGQ5 YmQ3MzJiNzQxYS4uMmRkYjcyYmJhYjY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9zZWxmdGVzdHMvaTkxNV9saXZlX3NlbGZ0ZXN0cy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L3NlbGZ0ZXN0cy9pOTE1X2xpdmVfc2VsZnRlc3RzLmgKQEAgLTQ4LDUgKzQ4LDYgQEAgc2Vs ZnRlc3QoZXhlY2xpc3RzLCBpbnRlbF9leGVjbGlzdHNfbGl2ZV9zZWxmdGVzdHMpCiBzZWxmdGVz dChyaW5nX3N1Ym1pc3Npb24sIGludGVsX3Jpbmdfc3VibWlzc2lvbl9saXZlX3NlbGZ0ZXN0cykK IHNlbGZ0ZXN0KHBlcmYsIGk5MTVfcGVyZl9saXZlX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KGd1Y19m bG93X2NvbnRyb2wsIGludGVsX2d1Y19mbG93X2NvbnRyb2wpCitzZWxmdGVzdChndWNfbXVsdGlf bHJjLCBpbnRlbF9ndWNfbXVsdGlfbHJjKQogLyogSGVyZSBiZSBkcmFnb25zOiBrZWVwIGxhc3Qg dG8gcnVuIGxhc3QhICovCiBzZWxmdGVzdChsYXRlX2d0X3BtLCBpbnRlbF9ndF9wbV9sYXRlX3Nl bGZ0ZXN0cykKLS0gCjIuMjguMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v aW50ZWwtZ2Z4Cg== 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,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 AECF1C636C8 for ; Tue, 20 Jul 2021 20:41:46 +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 8367E60FF3 for ; Tue, 20 Jul 2021 20:41:46 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8367E60FF3 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 307D26E5CE; Tue, 20 Jul 2021 20:40:57 +0000 (UTC) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by gabe.freedesktop.org (Postfix) with ESMTPS id 378D56E50C; Tue, 20 Jul 2021 20:40:18 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10051"; a="296885376" X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="296885376" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:17 -0700 X-IronPort-AV: E=Sophos;i="5.84,256,1620716400"; d="scan'208";a="414906087" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga006-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Jul 2021 13:40:16 -0700 From: Matthew Brost To: , Subject: [RFC PATCH 28/42] drm/i915/guc: Add basic GuC multi-lrc selftest Date: Tue, 20 Jul 2021 13:57:48 -0700 Message-Id: <20210720205802.39610-29-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210720205802.39610-1-matthew.brost@intel.com> References: <20210720205802.39610-1-matthew.brost@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: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Add very basic (single submission) multi-lrc selftest. Signed-off-by: Matthew Brost --- .../gpu/drm/i915/gt/uc/intel_guc_submission.c | 1 + .../drm/i915/gt/uc/selftest_guc_multi_lrc.c | 168 ++++++++++++++++++ .../drm/i915/selftests/i915_live_selftests.h | 1 + 3 files changed, 170 insertions(+) create mode 100644 drivers/gpu/drm/i915/gt/uc/selftest_guc_multi_lrc.c diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c index 326cb4fc8a9d..dde6aab1db85 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_submission.c @@ -4737,4 +4737,5 @@ bool intel_guc_virtual_engine_has_heartbeat(const struct intel_engine_cs *ve) #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) #include "selftest_guc_flow_control.c" +#include "selftest_guc_multi_lrc.c" #endif diff --git a/drivers/gpu/drm/i915/gt/uc/selftest_guc_multi_lrc.c b/drivers/gpu/drm/i915/gt/uc/selftest_guc_multi_lrc.c new file mode 100644 index 000000000000..226e64fee919 --- /dev/null +++ b/drivers/gpu/drm/i915/gt/uc/selftest_guc_multi_lrc.c @@ -0,0 +1,168 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright �� 2019 Intel Corporation + */ + +#include "selftests/igt_spinner.h" +#include "selftests/igt_reset.h" +#include "selftests/intel_scheduler_helpers.h" +#include "gt/intel_engine_heartbeat.h" +#include "gem/selftests/mock_context.h" + +static void logical_sort(struct intel_engine_cs **engines, int num_engines) +{ + struct intel_engine_cs *sorted[MAX_ENGINE_INSTANCE + 1]; + int i, j; + + for (i = 0; i < num_engines; ++i) + for (j = 0; j < MAX_ENGINE_INSTANCE + 1; ++j) { + if (engines[j]->logical_mask & BIT(i)) { + sorted[i] = engines[j]; + break; + } + } + + memcpy(*engines, *sorted, + sizeof(struct intel_engine_cs *) * num_engines); +} + +static struct intel_context * +multi_lrc_create_parent(struct intel_gt *gt, u8 class, + unsigned long flags) +{ + struct intel_engine_cs *siblings[MAX_ENGINE_INSTANCE + 1]; + struct intel_engine_cs *engine; + enum intel_engine_id id; + int i = 0; + + for_each_engine(engine, gt, id) { + if (engine->class != class) + continue; + + siblings[i++] = engine; + } + + if (i <= 1) + return ERR_PTR(0); + + logical_sort(siblings, i); + + return intel_engine_create_parallel(siblings, 1, i); +} + +static void multi_lrc_context_put(struct intel_context *ce) +{ + GEM_BUG_ON(!intel_context_is_parent(ce)); + + /* + * Only the parent gets the creation ref put in the uAPI, the parent + * itself is responsible for creation ref put on the children. + */ + intel_context_put(ce); +} + +static struct i915_request * +multi_lrc_nop_request(struct intel_context *ce) +{ + struct intel_context *child; + struct i915_request *rq, *child_rq; + int i = 0; + + GEM_BUG_ON(!intel_context_is_parent(ce)); + + rq = intel_context_create_request(ce); + if (IS_ERR(rq)) + return rq; + + i915_request_get(rq); + i915_request_add(rq); + + for_each_child(ce, child) { + child_rq = intel_context_create_request(child); + if (IS_ERR(child_rq)) + goto child_error; + + if (++i == ce->guc_number_children) + set_bit(I915_FENCE_FLAG_SUBMIT_PARALLEL, + &child_rq->fence.flags); + i915_request_add(child_rq); + } + + return rq; + +child_error: + i915_request_put(rq); + + return ERR_PTR(-ENOMEM); +} + +static int __intel_guc_multi_lrc_basic(struct intel_gt *gt, unsigned int class) +{ + struct intel_context *parent; + struct i915_request *rq; + int ret; + + parent = multi_lrc_create_parent(gt, class, 0); + if (IS_ERR(parent)) { + pr_err("Failed creating contexts: %ld", PTR_ERR(parent)); + return PTR_ERR(parent); + } else if (parent == NULL) { + pr_debug("Not enough engines in class: %d", + VIDEO_DECODE_CLASS); + return 0; + } + + rq = multi_lrc_nop_request(parent); + if (IS_ERR(rq)) { + ret = PTR_ERR(rq); + pr_err("Failed creating requests: %d", ret); + goto out; + } + + ret = intel_selftest_wait_for_rq(rq); + if (ret) + pr_err("Failed waiting on request: %d", ret); + + i915_request_put(rq); + + if (ret >= 0) { + ret = intel_gt_wait_for_idle(gt, HZ * 5); + if (ret < 0) + pr_err("GT failed to idle: %d\n", ret); + } + +out: + multi_lrc_context_put(parent); + return ret; +} + +static int intel_guc_multi_lrc_basic(void *arg) +{ + struct intel_gt *gt = arg; + unsigned class; + int ret; + + for (class = 0; class < MAX_ENGINE_CLASS + 1; ++class) { + ret = __intel_guc_multi_lrc_basic(gt, class); + if (ret) + return ret; + } + + return 0; +} + +int intel_guc_multi_lrc(struct drm_i915_private *i915) +{ + static const struct i915_subtest tests[] = { + SUBTEST(intel_guc_multi_lrc_basic), + }; + struct intel_gt *gt = &i915->gt; + + if (intel_gt_is_wedged(gt)) + return 0; + + if (!intel_uc_uses_guc_submission(>->uc)) + return 0; + + return intel_gt_live_subtests(tests, gt); +} diff --git a/drivers/gpu/drm/i915/selftests/i915_live_selftests.h b/drivers/gpu/drm/i915/selftests/i915_live_selftests.h index d9bd732b741a..2ddb72bbab69 100644 --- a/drivers/gpu/drm/i915/selftests/i915_live_selftests.h +++ b/drivers/gpu/drm/i915/selftests/i915_live_selftests.h @@ -48,5 +48,6 @@ selftest(execlists, intel_execlists_live_selftests) selftest(ring_submission, intel_ring_submission_live_selftests) selftest(perf, i915_perf_live_selftests) selftest(guc_flow_control, intel_guc_flow_control) +selftest(guc_multi_lrc, intel_guc_multi_lrc) /* Here be dragons: keep last to run last! */ selftest(late_gt_pm, intel_gt_pm_late_selftests) -- 2.28.0