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.7 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 84388C48BE5 for ; Tue, 22 Jun 2021 09:34:38 +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 22C6060FF1 for ; Tue, 22 Jun 2021 09:34:38 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 22C6060FF1 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 6722F6E466; Tue, 22 Jun 2021 09:34:37 +0000 (UTC) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 7F0296E466; Tue, 22 Jun 2021 09:34:36 +0000 (UTC) IronPort-SDR: 0pVFy0kj5+hvaqiJDAsHSOIDwlUUcpkp2wSgv8/8QSEmebSZuzr7HQxo7FU70x+sIWkUhqLqOb ZbKYaSkPaCCw== X-IronPort-AV: E=McAfee;i="6200,9189,10022"; a="194159556" X-IronPort-AV: E=Sophos;i="5.83,291,1616482800"; d="scan'208";a="194159556" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jun 2021 02:34:34 -0700 IronPort-SDR: /TmHEtq5X6dvjIBBQBtfII6Pvro4fagYtWU5FtRtOVxnsGQZ9PdSRlwl7jUShJY9NpRBm265Lc XXlLfA/9wnhw== X-IronPort-AV: E=Sophos;i="5.83,291,1616482800"; d="scan'208";a="623410036" Received: from clanggaa-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.95]) by orsmga005-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jun 2021 02:34:32 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Tue, 22 Jun 2021 11:34:17 +0200 Message-Id: <20210622093418.153400-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210622093418.153400-1-thomas.hellstrom@linux.intel.com> References: <20210622093418.153400-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v7 2/3] drm/i915/ttm: Adjust gem flags and caching settings after a move 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 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" QWZ0ZXIgYSBUVE0gbW92ZSBvciBvYmplY3QgaW5pdCB3ZSBuZWVkIHRvIHVwZGF0ZSB0aGUgaTkx NSBnZW0gZmxhZ3MgYW5kCmNhY2hpbmcgc2V0dGluZ3MgdG8gcmVmbGVjdCB0aGUgbmV3IHBsYWNl bWVudC4gQ3VycmVudGx5IGNhY2hpbmcgc2V0dGluZ3MKYXJlIG5vdCBjaGFuZ2VkIGR1cmluZyB0 aGUgbGlmZXRpbWUgb2YgYW4gb2JqZWN0LCBhbHRob3VnaCB0aGF0IG1pZ2h0CmNoYW5nZSBtb3Zp bmcgZm9yd2FyZCBpZiB3ZSBydW4gaW50byBwZXJmb3JtYW5jZSBpc3N1ZXMgb3IgaXNzdWVzIHdp dGgKV0Mgc3lzdGVtIHBhZ2UgYWxsb2NhdGlvbnMuCkFsc28gaW50cm9kdWNlIGdwdV9iaW5kc19p b21lbSgpIGFuZCBjcHVfbWFwc19pb21lbSgpIHRvIGNsZWFuIHVwIHRoZQp2YXJpb3VzIHdheXMg d2UgcHJldmlvdXNseSB1c2VkIHRvIGRldGVjdCB0aGlzLgpGaW5hbGx5LCBpbml0aWFsaXplIHRo ZSBUVE0gb2JqZWN0IHJlc2VydmVkIHRvIGJlIGFibGUgdG8gdXBkYXRlCmZsYWdzIGFuZCBjYWNo aW5nIGJlZm9yZSBhbnlvbmUgZWxzZSBnZXRzIGhvbGQgb2YgdGhlIG9iamVjdC4KClNpZ25lZC1v ZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNv bT4KUmV2aWV3ZWQtYnk6IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4KLS0t CnY2OgotIFJlYmFzZSBvbiBhY2NlbGVyYXRlZCB0dG0gbW92ZXMuCi0tLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5jIHwgMTQzICsrKysrKysrKysrKysrKysrKy0tLS0t LQogMSBmaWxlIGNoYW5nZWQsIDEwNyBpbnNlcnRpb25zKCspLCAzNiBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKaW5kZXggYjVkZDNiNzAzN2Y0Li45 NjZiMjkyZDA3ZGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV90dG0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmMKQEAg LTkxLDYgKzkxLDI2IEBAIHN0YXRpYyBpbnQgaTkxNV90dG1fZXJyX3RvX2dlbShpbnQgZXJyKQog CXJldHVybiBlcnI7CiB9CiAKK3N0YXRpYyBib29sIGdwdV9iaW5kc19pb21lbShzdHJ1Y3QgdHRt X3Jlc291cmNlICptZW0pCit7CisJcmV0dXJuIG1lbS0+bWVtX3R5cGUgIT0gVFRNX1BMX1NZU1RF TTsKK30KKworc3RhdGljIGJvb2wgY3B1X21hcHNfaW9tZW0oc3RydWN0IHR0bV9yZXNvdXJjZSAq bWVtKQoreworCS8qIE9uY2UgLyBpZiB3ZSBzdXBwb3J0IEdHVFQsIHRoaXMgaXMgYWxzbyBmYWxz ZSBmb3IgY2FjaGVkIHR0bV90dHMgKi8KKwlyZXR1cm4gbWVtLT5tZW1fdHlwZSAhPSBUVE1fUExf U1lTVEVNOworfQorCitzdGF0aWMgZW51bSBpOTE1X2NhY2hlX2xldmVsCitpOTE1X3R0bV9jYWNo ZV9sZXZlbChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwgc3RydWN0IHR0bV9yZXNvdXJj ZSAqcmVzLAorCQkgICAgIHN0cnVjdCB0dG1fdHQgKnR0bSkKK3sKKwlyZXR1cm4gKChIQVNfTExD KGk5MTUpIHx8IEhBU19TTk9PUChpOTE1KSkgJiYgIWdwdV9iaW5kc19pb21lbShyZXMpICYmCisJ CXR0bS0+Y2FjaGluZyA9PSB0dG1fY2FjaGVkKSA/IEk5MTVfQ0FDSEVfTExDIDoKKwkJSTkxNV9D QUNIRV9OT05FOworfQorCiBzdGF0aWMgdm9pZCBpOTE1X3R0bV9hZGp1c3RfbHJ1KHN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpvYmopOwogCiBzdGF0aWMgZW51bSB0dG1fY2FjaGluZwpAQCAt MjQ4LDYgKzI2OCwzNSBAQCBzdGF0aWMgdm9pZCBpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCW9iai0+dHRtLmNhY2hlZF9pb19zdCA9 IE5VTEw7CiB9CiAKK3N0YXRpYyB2b2lkCitpOTE1X3R0bV9hZGp1c3RfZG9tYWluc19hZnRlcl9t b3ZlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJc3RydWN0IHR0bV9idWZm ZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOworCisJaWYgKGNwdV9tYXBzX2lv bWVtKGJvLT5yZXNvdXJjZSkgfHwgYm8tPnR0bS0+Y2FjaGluZyAhPSB0dG1fY2FjaGVkKSB7CisJ CW9iai0+d3JpdGVfZG9tYWluID0gSTkxNV9HRU1fRE9NQUlOX1dDOworCQlvYmotPnJlYWRfZG9t YWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQzsKKwl9IGVsc2UgeworCQlvYmotPndyaXRlX2RvbWFp biA9IEk5MTVfR0VNX0RPTUFJTl9DUFU7CisJCW9iai0+cmVhZF9kb21haW5zID0gSTkxNV9HRU1f RE9NQUlOX0NQVTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGk5MTVfdHRtX2FkanVzdF9nZW1fYWZ0 ZXJfbW92ZShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQoreworCXN0cnVjdCB0dG1f YnVmZmVyX29iamVjdCAqYm8gPSBpOTE1X2dlbV90b190dG0ob2JqKTsKKwl1bnNpZ25lZCBpbnQg Y2FjaGVfbGV2ZWw7CisKKwlvYmotPm1lbV9mbGFncyAmPSB+KEk5MTVfQk9fRkxBR19TVFJVQ1Rf UEFHRSB8IEk5MTVfQk9fRkxBR19JT01FTSk7CisKKwlvYmotPm1lbV9mbGFncyB8PSBjcHVfbWFw c19pb21lbShiby0+cmVzb3VyY2UpID8gSTkxNV9CT19GTEFHX0lPTUVNIDoKKwkJSTkxNV9CT19G TEFHX1NUUlVDVF9QQUdFOworCisJY2FjaGVfbGV2ZWwgPSBpOTE1X3R0bV9jYWNoZV9sZXZlbCh0 b19pOTE1KGJvLT5iYXNlLmRldiksIGJvLT5yZXNvdXJjZSwKKwkJCQkJICAgYm8tPnR0bSk7CisJ aTkxNV9nZW1fb2JqZWN0X3NldF9jYWNoZV9jb2hlcmVuY3kob2JqLCBjYWNoZV9sZXZlbCk7Cit9 CisKIHN0YXRpYyB2b2lkIGk5MTVfdHRtX3B1cmdlKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0 ICpvYmopCiB7CiAJc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0 bShvYmopOwpAQCAtMjYzLDggKzMxMiwxMCBAQCBzdGF0aWMgdm9pZCBpOTE1X3R0bV9wdXJnZShz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCiAJLyogVFRNJ3MgcHVyZ2UgaW50ZXJm YWNlLiBOb3RlIHRoYXQgd2UgbWlnaHQgYmUgcmVlbnRlcmluZy4gKi8KIAlyZXQgPSB0dG1fYm9f dmFsaWRhdGUoYm8sICZwbGFjZSwgJmN0eCk7Ci0KIAlpZiAoIXJldCkgeworCQlvYmotPndyaXRl X2RvbWFpbiA9IDA7CisJCW9iai0+cmVhZF9kb21haW5zID0gMDsKKwkJaTkxNV90dG1fYWRqdXN0 X2dlbV9hZnRlcl9tb3ZlKG9iaik7CiAJCWk5MTVfdHRtX2ZyZWVfY2FjaGVkX2lvX3N0KG9iaik7 CiAJCW9iai0+bW0ubWFkdiA9IF9fSTkxNV9NQURWX1BVUkdFRDsKIAl9CkBAIC0zNDcsMTIgKzM5 OCwxNSBAQCBpOTE1X3R0bV9yZXNvdXJjZV9nZXRfc3Qoc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iaiwKIAkJCSBzdHJ1Y3QgdHRtX3Jlc291cmNlICpyZXMpCiB7CiAJc3RydWN0IHR0bV9i dWZmZXJfb2JqZWN0ICpibyA9IGk5MTVfZ2VtX3RvX3R0bShvYmopOwotCXN0cnVjdCB0dG1fcmVz b3VyY2VfbWFuYWdlciAqbWFuID0KLQkJdHRtX21hbmFnZXJfdHlwZShiby0+YmRldiwgcmVzLT5t ZW1fdHlwZSk7CiAKLQlpZiAobWFuLT51c2VfdHQpCisJaWYgKCFncHVfYmluZHNfaW9tZW0ocmVz KSkKIAkJcmV0dXJuIGk5MTVfdHRtX3R0X2dldF9zdChiby0+dHRtKTsKIAorCS8qCisJICogSWYg Q1BVIG1hcHBpbmcgZGlmZmVycywgd2UgbmVlZCB0byBhZGQgdGhlIHR0bV90dCBwYWdlcyB0bwor CSAqIHRoZSByZXN1bHRpbmcgc3QuIE1pZ2h0IG1ha2Ugc2Vuc2UgZm9yIEdHVFQuCisJICovCisJ R0VNX1dBUk5fT04oIWNwdV9tYXBzX2lvbWVtKHJlcykpOwogCXJldHVybiBpbnRlbF9yZWdpb25f dHRtX3Jlc291cmNlX3RvX3N0KG9iai0+bW0ucmVnaW9uLCByZXMpOwogfQogCkBAIC0zNjcsMjMg KzQyMSwyNSBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX2FjY2VsX21vdmUoc3RydWN0IHR0bV9idWZm ZXJfb2JqZWN0ICpibywKIAlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqID0gaTkxNV90 dG1fdG9fZ2VtKGJvKTsKIAlzdHJ1Y3Qgc2dfdGFibGUgKnNyY19zdDsKIAlzdHJ1Y3QgaTkxNV9y ZXF1ZXN0ICpycTsKKwlzdHJ1Y3QgdHRtX3R0ICp0dG0gPSBiby0+dHRtOworCWVudW0gaTkxNV9j YWNoZV9sZXZlbCBzcmNfbGV2ZWwsIGRzdF9sZXZlbDsKIAlpbnQgcmV0OwogCiAJaWYgKCFpOTE1 LT5ndC5taWdyYXRlLmNvbnRleHQpCiAJCXJldHVybiAtRUlOVkFMOwogCi0JaWYgKCFiby0+dHRt IHx8ICF0dG1fdHRfaXNfcG9wdWxhdGVkKGJvLT50dG0pKSB7CisJZHN0X2xldmVsID0gaTkxNV90 dG1fY2FjaGVfbGV2ZWwoaTkxNSwgZHN0X21lbSwgdHRtKTsKKwlpZiAoIXR0bSB8fCAhdHRtX3R0 X2lzX3BvcHVsYXRlZCh0dG0pKSB7CiAJCWlmIChiby0+dHlwZSA9PSB0dG1fYm9fdHlwZV9rZXJu ZWwpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAotCQlpZiAoYm8tPnR0bSAmJgotCQkgICAgIShiby0+ dHRtLT5wYWdlX2ZsYWdzICYgVFRNX1BBR0VfRkxBR19aRVJPX0FMTE9DKSkKKwkJaWYgKHR0bSAm JiAhKHR0bS0+cGFnZV9mbGFncyAmIFRUTV9QQUdFX0ZMQUdfWkVST19BTExPQykpCiAJCQlyZXR1 cm4gMDsKIAogCQlpbnRlbF9lbmdpbmVfcG1fZ2V0KGk5MTUtPmd0Lm1pZ3JhdGUuY29udGV4dC0+ ZW5naW5lKTsKIAkJcmV0ID0gaW50ZWxfY29udGV4dF9taWdyYXRlX2NsZWFyKGk5MTUtPmd0Lm1p Z3JhdGUuY29udGV4dCwgTlVMTCwKLQkJCQkJCSAgZHN0X3N0LT5zZ2wsIEk5MTVfQ0FDSEVfTk9O RSwKLQkJCQkJCSAgZHN0X21lbS0+bWVtX3R5cGUgPj0gSTkxNV9QTF9MTUVNMCwKKwkJCQkJCSAg ZHN0X3N0LT5zZ2wsIGRzdF9sZXZlbCwKKwkJCQkJCSAgZ3B1X2JpbmRzX2lvbWVtKGRzdF9tZW0p LAogCQkJCQkJICAwLCAmcnEpOwogCiAJCWlmICghcmV0ICYmIHJxKSB7CkBAIC0zOTIsMTUgKzQ0 OCwxNiBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX2FjY2VsX21vdmUoc3RydWN0IHR0bV9idWZmZXJf b2JqZWN0ICpibywKIAkJfQogCQlpbnRlbF9lbmdpbmVfcG1fcHV0KGk5MTUtPmd0Lm1pZ3JhdGUu Y29udGV4dC0+ZW5naW5lKTsKIAl9IGVsc2UgewotCQlzcmNfc3QgPSBzcmNfbWFuLT51c2VfdHQg PyBpOTE1X3R0bV90dF9nZXRfc3QoYm8tPnR0bSkgOgotCQkJCQkJb2JqLT50dG0uY2FjaGVkX2lv X3N0OworCQlzcmNfc3QgPSBzcmNfbWFuLT51c2VfdHQgPyBpOTE1X3R0bV90dF9nZXRfc3QodHRt KSA6CisJCQlvYmotPnR0bS5jYWNoZWRfaW9fc3Q7CiAKKwkJc3JjX2xldmVsID0gaTkxNV90dG1f Y2FjaGVfbGV2ZWwoaTkxNSwgYm8tPnJlc291cmNlLCB0dG0pOwogCQlpbnRlbF9lbmdpbmVfcG1f Z2V0KGk5MTUtPmd0Lm1pZ3JhdGUuY29udGV4dC0+ZW5naW5lKTsKIAkJcmV0ID0gaW50ZWxfY29u dGV4dF9taWdyYXRlX2NvcHkoaTkxNS0+Z3QubWlncmF0ZS5jb250ZXh0LAotCQkJCQkJIE5VTEws IHNyY19zdC0+c2dsLCBJOTE1X0NBQ0hFX05PTkUsCi0JCQkJCQkgYm8tPnJlc291cmNlLT5tZW1f dHlwZSA+PSBJOTE1X1BMX0xNRU0wLAotCQkJCQkJIGRzdF9zdC0+c2dsLCBJOTE1X0NBQ0hFX05P TkUsCi0JCQkJCQkgZHN0X21lbS0+bWVtX3R5cGUgPj0gSTkxNV9QTF9MTUVNMCwKKwkJCQkJCSBO VUxMLCBzcmNfc3QtPnNnbCwgc3JjX2xldmVsLAorCQkJCQkJIGdwdV9iaW5kc19pb21lbShiby0+ cmVzb3VyY2UpLAorCQkJCQkJIGRzdF9zdC0+c2dsLCBkc3RfbGV2ZWwsCisJCQkJCQkgZ3B1X2Jp bmRzX2lvbWVtKGRzdF9tZW0pLAogCQkJCQkJICZycSk7CiAJCWlmICghcmV0ICYmIHJxKSB7CiAJ CQlpOTE1X3JlcXVlc3Rfd2FpdChycSwgMCwgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwpAQCAtNDIw LDggKzQ3Nyw2IEBAIHN0YXRpYyBpbnQgaTkxNV90dG1fbW92ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9v YmplY3QgKmJvLCBib29sIGV2aWN0LAogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmog PSBpOTE1X3R0bV90b19nZW0oYm8pOwogCXN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlciAqZHN0 X21hbiA9CiAJCXR0bV9tYW5hZ2VyX3R5cGUoYm8tPmJkZXYsIGRzdF9tZW0tPm1lbV90eXBlKTsK LQlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKnNyY19tYW4gPQotCQl0dG1fbWFuYWdlcl90 eXBlKGJvLT5iZGV2LCBiby0+cmVzb3VyY2UtPm1lbV90eXBlKTsKIAlzdHJ1Y3QgaW50ZWxfbWVt b3J5X3JlZ2lvbiAqZHN0X3JlZywgKnNyY19yZWc7CiAJdW5pb24gewogCQlzdHJ1Y3QgdHRtX2tt YXBfaXRlcl90dCB0dDsKQEAgLTQ2NSwxMiArNTIwLDEyIEBAIHN0YXRpYyBpbnQgaTkxNV90dG1f bW92ZShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLCBib29sIGV2aWN0LAogCXJldCA9IGk5 MTVfdHRtX2FjY2VsX21vdmUoYm8sIGRzdF9tZW0sIGRzdF9zdCk7CiAJaWYgKHJldCkgewogCQkv KiBJZiB3ZSBzdGFydCBtYXBwaW5nIEdHVFQsIHdlIGNhbiBubyBsb25nZXIgdXNlIG1hbjo6dXNl X3R0IGhlcmUuICovCi0JCWRzdF9pdGVyID0gZHN0X21hbi0+dXNlX3R0ID8KKwkJZHN0X2l0ZXIg PSAhY3B1X21hcHNfaW9tZW0oZHN0X21lbSkgPwogCQkJdHRtX2ttYXBfaXRlcl90dF9pbml0KCZf ZHN0X2l0ZXIudHQsIGJvLT50dG0pIDoKIAkJCXR0bV9rbWFwX2l0ZXJfaW9tYXBfaW5pdCgmX2Rz dF9pdGVyLmlvLCAmZHN0X3JlZy0+aW9tYXAsCiAJCQkJCQkgZHN0X3N0LCBkc3RfcmVnLT5yZWdp b24uc3RhcnQpOwogCi0JCXNyY19pdGVyID0gc3JjX21hbi0+dXNlX3R0ID8KKwkJc3JjX2l0ZXIg PSAhY3B1X21hcHNfaW9tZW0oYm8tPnJlc291cmNlKSA/CiAJCQl0dG1fa21hcF9pdGVyX3R0X2lu aXQoJl9zcmNfaXRlci50dCwgYm8tPnR0bSkgOgogCQkJdHRtX2ttYXBfaXRlcl9pb21hcF9pbml0 KCZfc3JjX2l0ZXIuaW8sICZzcmNfcmVnLT5pb21hcCwKIAkJCQkJCSBvYmotPnR0bS5jYWNoZWRf aW9fc3QsCkBAIC00NzgsMjEgKzUzMywyNCBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX21vdmUoc3Ry dWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywgYm9vbCBldmljdCwKIAogCQl0dG1fbW92ZV9tZW1j cHkoYm8sIGRzdF9tZW0tPm51bV9wYWdlcywgZHN0X2l0ZXIsIHNyY19pdGVyKTsKIAl9CisJLyog QmVsb3cgZHN0X21lbSBiZWNvbWVzIGJvLT5yZXNvdXJjZS4gKi8KIAl0dG1fYm9fbW92ZV9zeW5j X2NsZWFudXAoYm8sIGRzdF9tZW0pOworCWk5MTVfdHRtX2FkanVzdF9kb21haW5zX2FmdGVyX21v dmUob2JqKTsKIAlpOTE1X3R0bV9mcmVlX2NhY2hlZF9pb19zdChvYmopOwogCi0JaWYgKCFkc3Rf bWFuLT51c2VfdHQpIHsKKwlpZiAoZ3B1X2JpbmRzX2lvbWVtKGRzdF9tZW0pIHx8IGNwdV9tYXBz X2lvbWVtKGRzdF9tZW0pKSB7CiAJCW9iai0+dHRtLmNhY2hlZF9pb19zdCA9IGRzdF9zdDsKIAkJ b2JqLT50dG0uZ2V0X2lvX3BhZ2Uuc2dfcG9zID0gZHN0X3N0LT5zZ2w7CiAJCW9iai0+dHRtLmdl dF9pb19wYWdlLnNnX2lkeCA9IDA7CiAJfQogCisJaTkxNV90dG1fYWRqdXN0X2dlbV9hZnRlcl9t b3ZlKG9iaik7CiAJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyBpbnQgaTkxNV90dG1faW9fbWVtX3Jl c2VydmUoc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYsIHN0cnVjdCB0dG1fcmVzb3VyY2UgKm1lbSkK IHsKLQlpZiAobWVtLT5tZW1fdHlwZSA8IEk5MTVfUExfTE1FTTApCisJaWYgKCFjcHVfbWFwc19p b21lbShtZW0pKQogCQlyZXR1cm4gMDsKIAogCW1lbS0+YnVzLmNhY2hpbmcgPSB0dG1fd3JpdGVf Y29tYmluZWQ7CkBAIC01OTAsNiArNjQ4LDE2IEBAIHN0YXRpYyBpbnQgaTkxNV90dG1fZ2V0X3Bh Z2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCiAJCQlyZXR1cm4gaTkxNV90dG1f ZXJyX3RvX2dlbShyZXQpOwogCX0KIAorCWk5MTVfdHRtX2FkanVzdF9scnUob2JqKTsKKwlpZiAo Ym8tPnR0bSAmJiAhdHRtX3R0X2lzX3BvcHVsYXRlZChiby0+dHRtKSkgeworCQlyZXQgPSB0dG1f dHRfcG9wdWxhdGUoYm8tPmJkZXYsIGJvLT50dG0sICZjdHgpOworCQlpZiAocmV0KQorCQkJcmV0 dXJuIHJldDsKKworCQlpOTE1X3R0bV9hZGp1c3RfZG9tYWluc19hZnRlcl9tb3ZlKG9iaik7CisJ CWk5MTVfdHRtX2FkanVzdF9nZW1fYWZ0ZXJfbW92ZShvYmopOworCX0KKwogCS8qIE9iamVjdCBl aXRoZXIgaGFzIGEgcGFnZSB2ZWN0b3Igb3IgaXMgYW4gaW9tZW0gb2JqZWN0ICovCiAJc3QgPSBi by0+dHRtID8gaTkxNV90dG1fdHRfZ2V0X3N0KGJvLT50dG0pIDogb2JqLT50dG0uY2FjaGVkX2lv X3N0OwogCWlmIChJU19FUlIoc3QpKQpAQCAtNTk3LDggKzY2NSw2IEBAIHN0YXRpYyBpbnQgaTkx NV90dG1fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCiAKIAlfX2k5 MTVfZ2VtX29iamVjdF9zZXRfcGFnZXMob2JqLCBzdCwgaTkxNV9zZ19kbWFfc2l6ZXMoc3QtPnNn bCkpOwogCi0JaTkxNV90dG1fYWRqdXN0X2xydShvYmopOwotCiAJcmV0dXJuIHJldDsKIH0KIApA QCAtNzY4LDYgKzgzNCwxMCBAQCBpbnQgX19pOTE1X2dlbV90dG1fb2JqZWN0X2luaXQoc3RydWN0 IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIHsKIAlzdGF0aWMgc3RydWN0IGxvY2tfY2xhc3Nf a2V5IGxvY2tfY2xhc3M7CiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUgPSBtZW0tPmk5 MTU7CisJc3RydWN0IHR0bV9vcGVyYXRpb25fY3R4IGN0eCA9IHsKKwkJLmludGVycnVwdGlibGUg PSB0cnVlLAorCQkubm9fd2FpdF9ncHUgPSBmYWxzZSwKKwl9OwogCWVudW0gdHRtX2JvX3R5cGUg Ym9fdHlwZTsKIAlpbnQgcmV0OwogCkBAIC03NzUsMTQgKzg0NSwxMyBAQCBpbnQgX19pOTE1X2dl bV90dG1fb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAlpOTE1 X2dlbV9vYmplY3RfaW5pdChvYmosICZpOTE1X2dlbV90dG1fb2JqX29wcywgJmxvY2tfY2xhc3Ms IGZsYWdzKTsKIAlpOTE1X2dlbV9vYmplY3RfaW5pdF9tZW1vcnlfcmVnaW9uKG9iaiwgbWVtKTsK IAlpOTE1X2dlbV9vYmplY3RfbWFrZV91bnNocmlua2FibGUob2JqKTsKLQlvYmotPnJlYWRfZG9t YWlucyA9IEk5MTVfR0VNX0RPTUFJTl9XQyB8IEk5MTVfR0VNX0RPTUFJTl9HVFQ7Ci0Jb2JqLT5t ZW1fZmxhZ3MgfD0gSTkxNV9CT19GTEFHX0lPTUVNOwotCWk5MTVfZ2VtX29iamVjdF9zZXRfY2Fj aGVfY29oZXJlbmN5KG9iaiwgSTkxNV9DQUNIRV9OT05FKTsKIAlJTklUX1JBRElYX1RSRUUoJm9i ai0+dHRtLmdldF9pb19wYWdlLnJhZGl4LCBHRlBfS0VSTkVMIHwgX19HRlBfTk9XQVJOKTsKIAlt dXRleF9pbml0KCZvYmotPnR0bS5nZXRfaW9fcGFnZS5sb2NrKTsKIAlib190eXBlID0gKG9iai0+ ZmxhZ3MgJiBJOTE1X0JPX0FMTE9DX1VTRVIpID8gdHRtX2JvX3R5cGVfZGV2aWNlIDoKIAkJdHRt X2JvX3R5cGVfa2VybmVsOwogCisJb2JqLT5iYXNlLnZtYV9ub2RlLmRyaXZlcl9wcml2YXRlID0g aTkxNV9nZW1fdG9fdHRtKG9iaik7CisKIAkvKgogCSAqIElmIHRoaXMgZnVuY3Rpb24gZmFpbHMs IGl0IHdpbGwgY2FsbCB0aGUgZGVzdHJ1Y3RvciwgYnV0CiAJICogb3VyIGNhbGxlciBzdGlsbCBv d25zIHRoZSBvYmplY3QuIFNvIG5vIGZyZWVpbmcgaW4gdGhlCkBAIC03OTAsMTQgKzg1OSwxNiBA QCBpbnQgX19pOTE1X2dlbV90dG1fb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdp b24gKm1lbSwKIAkgKiBTaW1pbGFybHksIGluIGRlbGF5ZWRfZGVzdHJveSwgd2UgY2FuJ3QgY2Fs bCB0dG1fYm9fcHV0KCkKIAkgKiB1bnRpbCBzdWNjZXNzZnVsIGluaXRpYWxpemF0aW9uLgogCSAq LwotCW9iai0+YmFzZS52bWFfbm9kZS5kcml2ZXJfcHJpdmF0ZSA9IGk5MTVfZ2VtX3RvX3R0bShv YmopOwotCXJldCA9IHR0bV9ib19pbml0KCZpOTE1LT5iZGV2LCBpOTE1X2dlbV90b190dG0ob2Jq KSwgc2l6ZSwKLQkJCSAgYm9fdHlwZSwgJmk5MTVfc3lzX3BsYWNlbWVudCwKLQkJCSAgbWVtLT5t aW5fcGFnZV9zaXplID4+IFBBR0VfU0hJRlQsCi0JCQkgIHRydWUsIE5VTEwsIE5VTEwsIGk5MTVf dHRtX2JvX2Rlc3Ryb3kpOwotCWlmICghcmV0KQotCQlvYmotPnR0bS5jcmVhdGVkID0gdHJ1ZTsK LQotCS8qIGk5MTUgd2FudHMgLUVOWElPIHdoZW4gb3V0IG9mIG1lbW9yeSByZWdpb24gc3BhY2Uu ICovCi0JcmV0dXJuIGk5MTVfdHRtX2Vycl90b19nZW0ocmV0KTsKKwlyZXQgPSB0dG1fYm9faW5p dF9yZXNlcnZlZCgmaTkxNS0+YmRldiwgaTkxNV9nZW1fdG9fdHRtKG9iaiksIHNpemUsCisJCQkJ ICAgYm9fdHlwZSwgJmk5MTVfc3lzX3BsYWNlbWVudCwgMSwKKwkJCQkgICAmY3R4LCBOVUxMLCBO VUxMLCBpOTE1X3R0bV9ib19kZXN0cm95KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gaTkxNV90dG1f ZXJyX3RvX2dlbShyZXQpOworCisJb2JqLT50dG0uY3JlYXRlZCA9IHRydWU7CisJaTkxNV90dG1f YWRqdXN0X2RvbWFpbnNfYWZ0ZXJfbW92ZShvYmopOworCWk5MTVfdHRtX2FkanVzdF9nZW1fYWZ0 ZXJfbW92ZShvYmopOworCWk5MTVfZ2VtX29iamVjdF91bmxvY2sob2JqKTsKKworCXJldHVybiAw OwogfQotLSAKMi4zMS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRl bC1nZngK 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.7 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 B1270C2B9F4 for ; Tue, 22 Jun 2021 09:34:44 +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 643C760FF1 for ; Tue, 22 Jun 2021 09:34:44 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 643C760FF1 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 3EB4D6E47B; Tue, 22 Jun 2021 09:34:38 +0000 (UTC) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 7F0296E466; Tue, 22 Jun 2021 09:34:36 +0000 (UTC) IronPort-SDR: 0pVFy0kj5+hvaqiJDAsHSOIDwlUUcpkp2wSgv8/8QSEmebSZuzr7HQxo7FU70x+sIWkUhqLqOb ZbKYaSkPaCCw== X-IronPort-AV: E=McAfee;i="6200,9189,10022"; a="194159556" X-IronPort-AV: E=Sophos;i="5.83,291,1616482800"; d="scan'208";a="194159556" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jun 2021 02:34:34 -0700 IronPort-SDR: /TmHEtq5X6dvjIBBQBtfII6Pvro4fagYtWU5FtRtOVxnsGQZ9PdSRlwl7jUShJY9NpRBm265Lc XXlLfA/9wnhw== X-IronPort-AV: E=Sophos;i="5.83,291,1616482800"; d="scan'208";a="623410036" Received: from clanggaa-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.95]) by orsmga005-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jun 2021 02:34:32 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v7 2/3] drm/i915/ttm: Adjust gem flags and caching settings after a move Date: Tue, 22 Jun 2021 11:34:17 +0200 Message-Id: <20210622093418.153400-3-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210622093418.153400-1-thomas.hellstrom@linux.intel.com> References: <20210622093418.153400-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 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" After a TTM move or object init we need to update the i915 gem flags and caching settings to reflect the new placement. Currently caching settings are not changed during the lifetime of an object, although that might change moving forward if we run into performance issues or issues with WC system page allocations. Also introduce gpu_binds_iomem() and cpu_maps_iomem() to clean up the various ways we previously used to detect this. Finally, initialize the TTM object reserved to be able to update flags and caching before anyone else gets hold of the object. Signed-off-by: Thomas Hellström Reviewed-by: Matthew Auld --- v6: - Rebase on accelerated ttm moves. --- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 143 ++++++++++++++++++------ 1 file changed, 107 insertions(+), 36 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index b5dd3b7037f4..966b292d07da 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -91,6 +91,26 @@ static int i915_ttm_err_to_gem(int err) return err; } +static bool gpu_binds_iomem(struct ttm_resource *mem) +{ + return mem->mem_type != TTM_PL_SYSTEM; +} + +static bool cpu_maps_iomem(struct ttm_resource *mem) +{ + /* Once / if we support GGTT, this is also false for cached ttm_tts */ + return mem->mem_type != TTM_PL_SYSTEM; +} + +static enum i915_cache_level +i915_ttm_cache_level(struct drm_i915_private *i915, struct ttm_resource *res, + struct ttm_tt *ttm) +{ + return ((HAS_LLC(i915) || HAS_SNOOP(i915)) && !gpu_binds_iomem(res) && + ttm->caching == ttm_cached) ? I915_CACHE_LLC : + I915_CACHE_NONE; +} + static void i915_ttm_adjust_lru(struct drm_i915_gem_object *obj); static enum ttm_caching @@ -248,6 +268,35 @@ static void i915_ttm_free_cached_io_st(struct drm_i915_gem_object *obj) obj->ttm.cached_io_st = NULL; } +static void +i915_ttm_adjust_domains_after_move(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + + if (cpu_maps_iomem(bo->resource) || bo->ttm->caching != ttm_cached) { + obj->write_domain = I915_GEM_DOMAIN_WC; + obj->read_domains = I915_GEM_DOMAIN_WC; + } else { + obj->write_domain = I915_GEM_DOMAIN_CPU; + obj->read_domains = I915_GEM_DOMAIN_CPU; + } +} + +static void i915_ttm_adjust_gem_after_move(struct drm_i915_gem_object *obj) +{ + struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); + unsigned int cache_level; + + obj->mem_flags &= ~(I915_BO_FLAG_STRUCT_PAGE | I915_BO_FLAG_IOMEM); + + obj->mem_flags |= cpu_maps_iomem(bo->resource) ? I915_BO_FLAG_IOMEM : + I915_BO_FLAG_STRUCT_PAGE; + + cache_level = i915_ttm_cache_level(to_i915(bo->base.dev), bo->resource, + bo->ttm); + i915_gem_object_set_cache_coherency(obj, cache_level); +} + static void i915_ttm_purge(struct drm_i915_gem_object *obj) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); @@ -263,8 +312,10 @@ static void i915_ttm_purge(struct drm_i915_gem_object *obj) /* TTM's purge interface. Note that we might be reentering. */ ret = ttm_bo_validate(bo, &place, &ctx); - if (!ret) { + obj->write_domain = 0; + obj->read_domains = 0; + i915_ttm_adjust_gem_after_move(obj); i915_ttm_free_cached_io_st(obj); obj->mm.madv = __I915_MADV_PURGED; } @@ -347,12 +398,15 @@ i915_ttm_resource_get_st(struct drm_i915_gem_object *obj, struct ttm_resource *res) { struct ttm_buffer_object *bo = i915_gem_to_ttm(obj); - struct ttm_resource_manager *man = - ttm_manager_type(bo->bdev, res->mem_type); - if (man->use_tt) + if (!gpu_binds_iomem(res)) return i915_ttm_tt_get_st(bo->ttm); + /* + * If CPU mapping differs, we need to add the ttm_tt pages to + * the resulting st. Might make sense for GGTT. + */ + GEM_WARN_ON(!cpu_maps_iomem(res)); return intel_region_ttm_resource_to_st(obj->mm.region, res); } @@ -367,23 +421,25 @@ static int i915_ttm_accel_move(struct ttm_buffer_object *bo, struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); struct sg_table *src_st; struct i915_request *rq; + struct ttm_tt *ttm = bo->ttm; + enum i915_cache_level src_level, dst_level; int ret; if (!i915->gt.migrate.context) return -EINVAL; - if (!bo->ttm || !ttm_tt_is_populated(bo->ttm)) { + dst_level = i915_ttm_cache_level(i915, dst_mem, ttm); + if (!ttm || !ttm_tt_is_populated(ttm)) { if (bo->type == ttm_bo_type_kernel) return -EINVAL; - if (bo->ttm && - !(bo->ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)) + if (ttm && !(ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)) return 0; intel_engine_pm_get(i915->gt.migrate.context->engine); ret = intel_context_migrate_clear(i915->gt.migrate.context, NULL, - dst_st->sgl, I915_CACHE_NONE, - dst_mem->mem_type >= I915_PL_LMEM0, + dst_st->sgl, dst_level, + gpu_binds_iomem(dst_mem), 0, &rq); if (!ret && rq) { @@ -392,15 +448,16 @@ static int i915_ttm_accel_move(struct ttm_buffer_object *bo, } intel_engine_pm_put(i915->gt.migrate.context->engine); } else { - src_st = src_man->use_tt ? i915_ttm_tt_get_st(bo->ttm) : - obj->ttm.cached_io_st; + src_st = src_man->use_tt ? i915_ttm_tt_get_st(ttm) : + obj->ttm.cached_io_st; + src_level = i915_ttm_cache_level(i915, bo->resource, ttm); intel_engine_pm_get(i915->gt.migrate.context->engine); ret = intel_context_migrate_copy(i915->gt.migrate.context, - NULL, src_st->sgl, I915_CACHE_NONE, - bo->resource->mem_type >= I915_PL_LMEM0, - dst_st->sgl, I915_CACHE_NONE, - dst_mem->mem_type >= I915_PL_LMEM0, + NULL, src_st->sgl, src_level, + gpu_binds_iomem(bo->resource), + dst_st->sgl, dst_level, + gpu_binds_iomem(dst_mem), &rq); if (!ret && rq) { i915_request_wait(rq, 0, MAX_SCHEDULE_TIMEOUT); @@ -420,8 +477,6 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, struct drm_i915_gem_object *obj = i915_ttm_to_gem(bo); struct ttm_resource_manager *dst_man = ttm_manager_type(bo->bdev, dst_mem->mem_type); - struct ttm_resource_manager *src_man = - ttm_manager_type(bo->bdev, bo->resource->mem_type); struct intel_memory_region *dst_reg, *src_reg; union { struct ttm_kmap_iter_tt tt; @@ -465,12 +520,12 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, ret = i915_ttm_accel_move(bo, dst_mem, dst_st); if (ret) { /* If we start mapping GGTT, we can no longer use man::use_tt here. */ - dst_iter = dst_man->use_tt ? + dst_iter = !cpu_maps_iomem(dst_mem) ? ttm_kmap_iter_tt_init(&_dst_iter.tt, bo->ttm) : ttm_kmap_iter_iomap_init(&_dst_iter.io, &dst_reg->iomap, dst_st, dst_reg->region.start); - src_iter = src_man->use_tt ? + src_iter = !cpu_maps_iomem(bo->resource) ? ttm_kmap_iter_tt_init(&_src_iter.tt, bo->ttm) : ttm_kmap_iter_iomap_init(&_src_iter.io, &src_reg->iomap, obj->ttm.cached_io_st, @@ -478,21 +533,24 @@ static int i915_ttm_move(struct ttm_buffer_object *bo, bool evict, ttm_move_memcpy(bo, dst_mem->num_pages, dst_iter, src_iter); } + /* Below dst_mem becomes bo->resource. */ ttm_bo_move_sync_cleanup(bo, dst_mem); + i915_ttm_adjust_domains_after_move(obj); i915_ttm_free_cached_io_st(obj); - if (!dst_man->use_tt) { + if (gpu_binds_iomem(dst_mem) || cpu_maps_iomem(dst_mem)) { obj->ttm.cached_io_st = dst_st; obj->ttm.get_io_page.sg_pos = dst_st->sgl; obj->ttm.get_io_page.sg_idx = 0; } + i915_ttm_adjust_gem_after_move(obj); return 0; } static int i915_ttm_io_mem_reserve(struct ttm_device *bdev, struct ttm_resource *mem) { - if (mem->mem_type < I915_PL_LMEM0) + if (!cpu_maps_iomem(mem)) return 0; mem->bus.caching = ttm_write_combined; @@ -590,6 +648,16 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) return i915_ttm_err_to_gem(ret); } + i915_ttm_adjust_lru(obj); + if (bo->ttm && !ttm_tt_is_populated(bo->ttm)) { + ret = ttm_tt_populate(bo->bdev, bo->ttm, &ctx); + if (ret) + return ret; + + i915_ttm_adjust_domains_after_move(obj); + i915_ttm_adjust_gem_after_move(obj); + } + /* Object either has a page vector or is an iomem object */ st = bo->ttm ? i915_ttm_tt_get_st(bo->ttm) : obj->ttm.cached_io_st; if (IS_ERR(st)) @@ -597,8 +665,6 @@ static int i915_ttm_get_pages(struct drm_i915_gem_object *obj) __i915_gem_object_set_pages(obj, st, i915_sg_dma_sizes(st->sgl)); - i915_ttm_adjust_lru(obj); - return ret; } @@ -768,6 +834,10 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, { static struct lock_class_key lock_class; struct drm_i915_private *i915 = mem->i915; + struct ttm_operation_ctx ctx = { + .interruptible = true, + .no_wait_gpu = false, + }; enum ttm_bo_type bo_type; int ret; @@ -775,14 +845,13 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, i915_gem_object_init(obj, &i915_gem_ttm_obj_ops, &lock_class, flags); i915_gem_object_init_memory_region(obj, mem); i915_gem_object_make_unshrinkable(obj); - obj->read_domains = I915_GEM_DOMAIN_WC | I915_GEM_DOMAIN_GTT; - obj->mem_flags |= I915_BO_FLAG_IOMEM; - i915_gem_object_set_cache_coherency(obj, I915_CACHE_NONE); INIT_RADIX_TREE(&obj->ttm.get_io_page.radix, GFP_KERNEL | __GFP_NOWARN); mutex_init(&obj->ttm.get_io_page.lock); bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : ttm_bo_type_kernel; + obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); + /* * If this function fails, it will call the destructor, but * our caller still owns the object. So no freeing in the @@ -790,14 +859,16 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, * Similarly, in delayed_destroy, we can't call ttm_bo_put() * until successful initialization. */ - obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); - ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, - bo_type, &i915_sys_placement, - mem->min_page_size >> PAGE_SHIFT, - true, NULL, NULL, i915_ttm_bo_destroy); - if (!ret) - obj->ttm.created = true; - - /* i915 wants -ENXIO when out of memory region space. */ - return i915_ttm_err_to_gem(ret); + ret = ttm_bo_init_reserved(&i915->bdev, i915_gem_to_ttm(obj), size, + bo_type, &i915_sys_placement, 1, + &ctx, NULL, NULL, i915_ttm_bo_destroy); + if (ret) + return i915_ttm_err_to_gem(ret); + + obj->ttm.created = true; + i915_ttm_adjust_domains_after_move(obj); + i915_ttm_adjust_gem_after_move(obj); + i915_gem_object_unlock(obj); + + return 0; } -- 2.31.1