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 215B2C6377D for ; Thu, 22 Jul 2021 11:35:17 +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 D8E9F60C3D for ; Thu, 22 Jul 2021 11:35:16 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D8E9F60C3D 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 733A16E882; Thu, 22 Jul 2021 11:35:16 +0000 (UTC) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by gabe.freedesktop.org (Postfix) with ESMTPS id 7526B6E5D4; Thu, 22 Jul 2021 11:35:14 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10052"; a="198896664" X-IronPort-AV: E=Sophos;i="5.84,260,1620716400"; d="scan'208";a="198896664" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jul 2021 04:35:13 -0700 X-IronPort-AV: E=Sophos;i="5.84,260,1620716400"; d="scan'208";a="470602848" Received: from kgreenan-mobl.ger.corp.intel.com (HELO mwauld-desk1.intel.com) ([10.252.29.109]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jul 2021 04:35:11 -0700 From: Matthew Auld To: intel-gfx@lists.freedesktop.org Date: Thu, 22 Jul 2021 12:34:55 +0100 Message-Id: <20210722113456.304882-1-matthew.auld@intel.com> X-Mailer: git-send-email 2.26.3 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 1/2] drm/i915: document caching related bits 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: Daniel Vetter , dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" VHJ5IHRvIGRvY3VtZW50IHRoZSBvYmplY3QgY2FjaGluZyByZWxhdGVkIGJpdHMsIGxpa2UgY2Fj aGVfY29oZXJlbnQgYW5kCmNhY2hlX2RpcnR5LgoKdjIoVmlsbGUpOgogLSBBcyBwb2ludGVkIG91 dCBieSBWaWxsZSwgZml4IHRoZSBjb21wbGV0ZWx5IGluY29ycmVjdCBhc3N1bXB0aW9ucwogICBh Ym91dCB0aGUgInBhcnRpYWwiIGNvaGVyZW5jeSBvbiBzaGFyZWQgTExDIHBsYXRmb3Jtcy4KdjMo RGFuaWVsKToKIC0gRml4IG5vbnNlbnNlIGFib3V0ICJkaXJ0eWluZyIgdGhlIGNhY2hlIHdpdGgg cmVhZHMuCgpTdWdnZXN0ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwu Y2g+ClNpZ25lZC1vZmYtYnk6IE1hdHRoZXcgQXVsZCA8bWF0dGhldy5hdWxkQGludGVsLmNvbT4K Q2M6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+CkNjOiBN aWthIEt1b3BwYWxhIDxtaWthLmt1b3BwYWxhQGxpbnV4LmludGVsLmNvbT4KLS0tCiAuLi4vZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3RfdHlwZXMuaCAgfCAxNzYgKysrKysrKysrKysr KysrKystCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgICAgICAgICAgfCAg IDkgLQogMiBmaWxlcyBjaGFuZ2VkLCAxNzIgaW5zZXJ0aW9ucygrKSwgMTMgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90 eXBlcy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5o CmluZGV4IGFmYmFkZmM1NTE2Yi4uNDBjY2U4MTZhN2UzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fb2JqZWN0X3R5cGVzLmgKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdF90eXBlcy5oCkBAIC05Miw2ICs5Miw3NiBAQCBz dHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgewogCWNvbnN0IGNoYXIgKm5hbWU7IC8qIGZy aWVuZGx5IG5hbWUgZm9yIGRlYnVnLCBlLmcuIGxvY2tkZXAgY2xhc3NlcyAqLwogfTsKIAorLyoq CisgKiBlbnVtIGk5MTVfY2FjaGVfbGV2ZWwgLSBUaGUgc3VwcG9ydGVkIEdUVCBjYWNoaW5nIHZh bHVlcyBmb3Igc3lzdGVtIG1lbW9yeQorICogcGFnZXMuCisgKgorICogVGhlc2UgdHJhbnNsYXRl IHRvIHNvbWUgc3BlY2lhbCBHVFQgUFRFIGJpdHMgd2hlbiBiaW5kaW5nIHBhZ2VzIGludG8gc29t ZQorICogYWRkcmVzcyBzcGFjZS4gSXQgYWxzbyBkZXRlcm1pbmVzIHdoZXRoZXIgYW4gb2JqZWN0 LCBvciByYXRoZXIgaXRzIHBhZ2VzIGFyZQorICogY29oZXJlbnQgd2l0aCB0aGUgR1BVLCB3aGVu IGFsc28gcmVhZGluZyBvciB3cml0aW5nIHRocm91Z2ggdGhlIENQVSBjYWNoZQorICogd2l0aCB0 aG9zZSBwYWdlcy4KKyAqCisgKiBVc2Vyc3BhY2UgY2FuIGFsc28gY29udHJvbCB0aGlzIHRocm91 Z2ggc3RydWN0IGRybV9pOTE1X2dlbV9jYWNoaW5nLgorICovCitlbnVtIGk5MTVfY2FjaGVfbGV2 ZWwgeworCS8qKgorCSAqIEBJOTE1X0NBQ0hFX05PTkU6CisJICoKKwkgKiBOb3QgY29oZXJlbnQg d2l0aCB0aGUgQ1BVIGNhY2hlLiBJZiB0aGUgY2FjaGUgaXMgZGlydHkgYW5kIHdlIG5lZWQKKwkg KiB0aGUgdW5kZXJseWluZyBwYWdlcyB0byBiZSBjb2hlcmVudCB3aXRoIHNvbWUgbGF0ZXIgR1BV IGFjY2VzcyB0aGVuCisJICogd2UgbmVlZCB0byBtYW51YWxseSBmbHVzaCB0aGUgcGFnZXMuCisJ ICoKKwkgKiBOb3RlIHRoYXQgb24gc2hhcmVkIExMQyBwbGF0Zm9ybXMgcmVhZHMgYW5kIHdyaXRl cyB0aHJvdWdoIHRoZSBDUFUKKwkgKiBjYWNoZSBhcmUgc3RpbGwgY29oZXJlbnQgZXZlbiB3aXRo IHRoaXMgc2V0dGluZy4gU2VlIGFsc28KKwkgKiAmZHJtX2k5MTVfZ2VtX29iamVjdC5jYWNoZV9j b2hlcmVudCBmb3IgbW9yZSBkZXRhaWxzLgorCSAqCisJICogTm90ZSB0aGF0IG9uIHBsYXRmb3Jt cyB3aXRoIGEgc2hhcmVkIExMQyB0aGlzIHNob3VsZCBpZGVhbGx5IG9ubHkgYmUKKwkgKiB1c2Vk IGZvciBzY2Fub3V0IHN1cmZhY2VzLCBvdGhlcndpc2Ugd2UgZW5kIHVwIG92ZXItZmx1c2hpbmcg aW4gc29tZQorCSAqIHBsYWNlcy4KKwkgKi8KKwlJOTE1X0NBQ0hFX05PTkUgPSAwLAorCS8qKgor CSAqIEBJOTE1X0NBQ0hFX0xMQzoKKwkgKgorCSAqIENvaGVyZW50IHdpdGggdGhlIENQVSBjYWNo ZS4gSWYgdGhlIGNhY2hlIGlzIGRpcnR5LCB0aGVuIHRoZSBHUFUgd2lsbAorCSAqIGVuc3VyZSB0 aGF0IGFjY2VzcyByZW1haW5zIGNvaGVyZW50LCB3aGVuIGJvdGggcmVhZGluZyBhbmQgd3JpdGlu ZworCSAqIHRocm91Z2ggdGhlIENQVSBjYWNoZS4KKwkgKgorCSAqIE5vdCB1c2VkIGZvciBzY2Fu b3V0IHN1cmZhY2VzLgorCSAqCisJICogQXBwbGllcyB0byBib3RoIHBsYXRmb3JtcyB3aXRoIHNo YXJlZCBMTEMoSEFTX0xMQyksIGFuZCBzbm9vcGluZworCSAqIGJhc2VkIHBsYXRmb3JtcyhIQVNf U05PT1ApLgorCSAqCisJICogVGhpcyBzaG91bGQgYmUgdGhlIGRlZmF1bHQgZm9yIHBsYXRmb3Jt cyB3aGljaCBzaGFyZSB0aGUgTExDIHdpdGggdGhlCisJICogQ1BVLiBUaGUgb25seSBleGNlcHRp b24gaXMgc2Nhbm91dCBvYmplY3RzLCB3aGVyZSB0aGUgZGlzcGxheSBlbmdpbmUKKwkgKiBpcyBu b3QgY29oZXJlbnQgd2l0aCB0aGUgTExDLiBGb3Igc3VjaCBvYmplY3RzIEk5MTVfQ0FDSEVfTk9O RSBvcgorCSAqIEk5MTVfQ0FDSEVfV1Qgc2hvdWxkIGJlIHVzZWQuCisJICovCisJSTkxNV9DQUNI RV9MTEMsCisJLyoqCisJICogQEk5MTVfQ0FDSEVfTDNfTExDOgorCSAqCisJICogRXhwbGljaXRs eSBlbmFibGUgdGhlIEdmeCBMMyBjYWNoZSwgd2l0aCBzbm9vcGVkIExMQy4KKwkgKgorCSAqIFRo ZSBHZnggTDMgc2l0cyBiZXR3ZWVuIHRoZSBkb21haW4gc3BlY2lmaWMgY2FjaGVzLCBlLmcKKwkg KiBzYW1wbGVyL3JlbmRlciBjYWNoZXMsIGFuZCB0aGUgbGFyZ2VyIExMQy4gTExDIGlzIGNvaGVy ZW50IHdpdGggdGhlCisJICogR1BVLCBidXQgTDMgaXMgb25seSB2aXNpYmxlIHRvIHRoZSBHUFUs IHNvIGxpa2VseSBuZWVkcyB0byBiZSBmbHVzaGVkCisJICogd2hlbiB0aGUgd29ya2xvYWQgY29t cGxldGVzLgorCSAqCisJICogTm90IHVzZWQgZm9yIHNjYW5vdXQgc3VyZmFjZXMuCisJICoKKwkg KiBPbmx5IGV4cG9zZWQgb24gc29tZSBnZW43ICsgR0dUVC4gTW9yZSByZWNlbnQgaGFyZHdhcmUg aGFzIGRyb3BwZWQKKwkgKiB0aGlzLgorCSAqLworCUk5MTVfQ0FDSEVfTDNfTExDLAorCS8qKgor CSAqIEBJOTE1X0NBQ0hFX1dUOgorCSAqCisJICogaHN3Omd0M2UgV3JpdGUtdGhyb3VnaCBmb3Ig c2Nhbm91dCBidWZmZXJzLgorCSAqLworCUk5MTVfQ0FDSEVfV1QsCit9OworCiBlbnVtIGk5MTVf bWFwX3R5cGUgewogCUk5MTVfTUFQX1dCID0gMCwKIAlJOTE1X01BUF9XQywKQEAgLTIyOSwxNCAr Mjk5LDExMiBAQCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCB7CiAJdW5zaWduZWQgaW50IG1l bV9mbGFnczsKICNkZWZpbmUgSTkxNV9CT19GTEFHX1NUUlVDVF9QQUdFIEJJVCgwKSAvKiBPYmpl Y3QgYmFja2VkIGJ5IHN0cnVjdCBwYWdlcyAqLwogI2RlZmluZSBJOTE1X0JPX0ZMQUdfSU9NRU0g ICAgICAgQklUKDEpIC8qIE9iamVjdCBiYWNrZWQgYnkgSU8gbWVtb3J5ICovCi0JLyoKLQkgKiBJ cyB0aGUgb2JqZWN0IHRvIGJlIG1hcHBlZCBhcyByZWFkLW9ubHkgdG8gdGhlIEdQVQotCSAqIE9u bHkgaG9ub3VyZWQgaWYgaGFyZHdhcmUgaGFzIHJlbGV2YW50IHB0ZSBiaXQKKwkvKioKKwkgKiBA Y2FjaGVfbGV2ZWw6IFRoZSBkZXNpcmVkIEdUVCBjYWNoaW5nIGxldmVsLgorCSAqCisJICogU2Vl IGVudW0gaTkxNV9jYWNoZV9sZXZlbCBmb3IgcG9zc2libGUgdmFsdWVzLCBhbG9uZyB3aXRoIHdo YXQKKwkgKiBlYWNoIGRvZXMuCiAJICovCiAJdW5zaWduZWQgaW50IGNhY2hlX2xldmVsOjM7Ci0J dW5zaWduZWQgaW50IGNhY2hlX2NvaGVyZW50OjI7CisJLyoqCisJICogQGNhY2hlX2NvaGVyZW50 OgorCSAqCisJICogVHJhY2sgd2hldGhlciB0aGUgcGFnZXMgYXJlIGNvaGVyZW50IHdpdGggdGhl IEdQVSBpZiByZWFkaW5nIG9yCisJICogd3JpdGluZyB0aHJvdWdoIHRoZSBDUFUgY2FjaGVzLiBU aGUgbGFyZ2VseSBkZXBlbmRzIG9uIHRoZQorCSAqIEBjYWNoZV9sZXZlbCBzZXR0aW5nLgorCSAq CisJICogT24gcGxhdGZvcm1zIHdoaWNoIGRvbid0IGhhdmUgdGhlIHNoYXJlZCBMTEMoSEFTX1NO T09QKSwgbGlrZSBvbiBBdG9tCisJICogcGxhdGZvcm1zLCBjb2hlcmVuY3kgbXVzdCBiZSBleHBs aWNpdGx5IHJlcXVlc3RlZCB3aXRoIHNvbWUgc3BlY2lhbAorCSAqIEdUVCBjYWNoaW5nIGJpdHMo c2VlIGVudW0gaTkxNV9jYWNoZV9sZXZlbCkuIFdoZW4gZW5hYmxpbmcgY29oZXJlbmN5CisJICog aXQgZG9lcyBjb21lIGF0IGEgcGVyZm9ybWFuY2UgYW5kIHBvd2VyIGNvc3Qgb24gc3VjaCBwbGF0 Zm9ybXMuIE9uCisJICogdGhlIGZsaXAgc2lkZSB0aGUga2VybmVsIGRvZXMgbmVlZCB0byBtYW51 YWxseSBmbHVzaCBhbnkgYnVmZmVycworCSAqIHdoaWNoIG5lZWQgdG8gYmUgY29oZXJlbnQgd2l0 aCB0aGUgR1BVLCBpZiB0aGUgb2JqZWN0IGlzIG5vdAorCSAqIGNvaGVyZW50IGkuZSBAY2FjaGVf Y29oZXJlbnQgaXMgemVyby4KKwkgKgorCSAqIE9uIHBsYXRmb3JtcyB0aGF0IHNoYXJlIHRoZSBM TEMgd2l0aCB0aGUgQ1BVKEhBU19MTEMpLCBhbGwgR1QgbWVtb3J5CisJICogYWNjZXNzIHdpbGwg YXV0b21hdGljYWxseSBzbm9vcCB0aGUgQ1BVIGNhY2hlcyhldmVuIHdpdGggQ0FDSEVfTk9ORSku CisJICogVGhlIG9uZSBleGNlcHRpb24gaXMgd2hlbiBkZWFsaW5nIHdpdGggdGhlIGRpc3BsYXkg ZW5naW5lLCBsaWtlIHdpdGgKKwkgKiBzY2Fub3V0IHN1cmZhY2VzLiBUbyBoYW5kbGUgdGhpcyB0 aGUga2VybmVsIHdpbGwgYWx3YXlzIGZsdXNoIHRoZQorCSAqIHN1cmZhY2Ugb3V0IG9mIHRoZSBD UFUgY2FjaGVzIHdoZW4gcHJlcGFyaW5nIGl0IGZvciBzY2Fub3V0LiAgQWxzbworCSAqIG5vdGUg dGhhdCBzaW5jZSBzY2Fub3V0IHN1cmZhY2VzIGFyZSBvbmx5IGV2ZXIgcmVhZCBieSB0aGUgZGlz cGxheQorCSAqIGVuZ2luZSB3ZSBvbmx5IG5lZWQgdG8gY2FyZSBhYm91dCBmbHVzaGluZyBhbnkg d3JpdGVzIHRocm91Z2ggdGhlIENQVQorCSAqIGNhY2hlLCByZWFkcyBvbiB0aGUgb3RoZXIgaGFu ZCB3aWxsIGFsd2F5cyBiZSBjb2hlcmVudC4KKwkgKgorCSAqIFNvbWV0aGluZyBzdHJhbmdlIGhl cmUgaXMgd2h5IEBjYWNoZV9jb2hlcmVudCBpcyBub3QgYSBzaW1wbGUKKwkgKiBib29sZWFuLCBp LmUgY29oZXJlbnQgdnMgbm9uLWNvaGVyZW50LiBUaGUgcmVhc29uaW5nIGZvciB0aGlzIGlzIGJh Y2sKKwkgKiB0byB0aGUgZGlzcGxheSBlbmdpbmUgbm90IGJlaW5nIGZ1bGx5IGNvaGVyZW50LiBB cyBhIHJlc3VsdCBzY2Fub3V0CisJICogc3VyZmFjZXMgd2lsbCBlaXRoZXIgYmUgbWFya2VkIGFz IEk5MTVfQ0FDSEVfTk9ORSBvciBJOTE1X0NBQ0hFX1dULgorCSAqIEluIHRoZSBjYXNlIG9mIHNl ZWluZyBJOTE1X0NBQ0hFX05PTkUgdGhlIGtlcm5lbCBtYWtlcyB0aGUgYXNzdW1wdGlvbgorCSAq IHRoYXQgdGhpcyBpcyBsaWtlbHkgYSBzY2Fub3V0IHN1cmZhY2UsIGFuZCB3aWxsIHNldCBAY2Fj aGVfY29oZXJlbnQKKwkgKiBhcyBvbmx5IEk5MTVfQk9fQ0FDSEVfQ09IRVJFTlRfRk9SX1JFQUQs IG9uIHBsYXRmb3JtcyB3aXRoIHRoZSBzaGFyZWQKKwkgKiBMTEMuIFRoZSBrZXJuZWwgdXNlcyB0 aGlzIHRvIGFsd2F5cyBmbHVzaCB3cml0ZXMgdGhyb3VnaCB0aGUgQ1BVCisJICogY2FjaGUgYXMg ZWFybHkgYXMgcG9zc2libGUsIHdoZXJlIGl0IGNhbiwgaW4gZWZmZWN0IGtlZXBpbmcKKwkgKiBA Y2FjaGVfZGlydHkgY2xlYW4sIHNvIHdlIGNhbiBwb3RlbnRpYWxseSBhdm9pZCBzdGFsbGluZyB3 aGVuCisJICogZmx1c2hpbmcgdGhlIHN1cmZhY2UganVzdCBiZWZvcmUgZG9pbmcgdGhlIHNjYW5v dXQuICBUaGlzIGRvZXMgbWVhbgorCSAqIHdlIG1pZ2h0IHVubmVjZXNzYXJpbHkgZmx1c2ggbm9u LXNjYW5vdXQgb2JqZWN0cyBpbiBzb21lIHBsYWNlcywgYnV0CisJICogdGhlIGRlZmF1bHQgYXNz dW1wdGlvbiBpcyB0aGF0IGFsbCBub3JtYWwgb2JqZWN0cyBzaG91bGQgYmUgdXNpbmcKKwkgKiBJ OTE1X0NBQ0hFX0xMQywgYXQgbGVhc3Qgb24gcGxhdGZvcm1zIHdpdGggdGhlIHNoYXJlZCBMTEMu CisJICoKKwkgKiBTdXBwb3J0ZWQgdmFsdWVzOgorCSAqCisJICogSTkxNV9CT19DQUNIRV9DT0hF UkVOVF9GT1JfUkVBRDoKKwkgKgorCSAqIE9uIHNoYXJlZCBMTEMgcGxhdGZvcm1zLCB3ZSB1c2Ug dGhpcyBmb3Igc3BlY2lhbCBzY2Fub3V0IHN1cmZhY2VzLAorCSAqIHdoZXJlIHRoZSBkaXNwbGF5 IGVuZ2luZSBpcyBub3QgY29oZXJlbnQgd2l0aCB0aGUgQ1BVIGNhY2hlLiBBcyBzdWNoCisJICog d2UgbmVlZCB0byBlbnN1cmUgd2UgZmx1c2ggYW55IHdyaXRlcyBiZWZvcmUgZG9pbmcgdGhlIHNj YW5vdXQuIEFzIGFuCisJICogb3B0aW1pc2F0aW9uIHdlIHRyeSB0byBmbHVzaCBhbnkgd3JpdGVz IGFzIGVhcmx5IGFzIHBvc3NpYmxlIHRvIGF2b2lkCisJICogc3RhbGxpbmcgbGF0ZXIuCisJICoK KwkgKiBUaHVzIGZvciBzY2Fub3V0IHN1cmZhY2VzIHVzaW5nIEk5MTVfQ0FDSEVfTk9ORSwgb24g c2hhcmVkIExMQworCSAqIHBsYXRmb3Jtcywgd2UgdXNlOgorCSAqCisJICoJY2FjaGVfY29oZXJl bnQgPSBJOTE1X0JPX0NBQ0hFX0NPSEVSRU5UX0ZPUl9SRUFECisJICoKKwkgKiBXaGlsZSBmb3Ig bm9ybWFsIG9iamVjdHMgdGhhdCBhcmUgZnVsbHkgY29oZXJlbnQgd2UgdXNlOgorCSAqCisJICoJ Y2FjaGVfY29oZXJlbnQgPSBJOTE1X0JPX0NBQ0hFX0NPSEVSRU5UX0ZPUl9SRUFEIHwKKwkgKgkJ CSBJOTE1X0JPX0NBQ0hFX0NPSEVSRU5UX0ZPUl9XUklURQorCSAqCisJICogQW5kIHRoZW4gZm9y IG9iamVjdHMgdGhhdCBhcmUgbm90IGNvaGVyZW50IGF0IGFsbCB3ZSB1c2U6CisJICoKKwkgKglj YWNoZV9jb2hlcmVudCA9IDAKKwkgKgorCSAqIEk5MTVfQk9fQ0FDSEVfQ09IRVJFTlRfRk9SX1dS SVRFOgorCSAqCisJICogV2hlbiB3cml0aW5nIHRocm91Z2ggdGhlIENQVSBjYWNoZSwgdGhlIEdQ VSBpcyBzdGlsbCBjb2hlcmVudC4gTm90ZQorCSAqIHRoYXQgdGhpcyBhbHNvIGltcGxpZXMgSTkx NV9CT19DQUNIRV9DT0hFUkVOVF9GT1JfUkVBRC4KKwkgKi8KICNkZWZpbmUgSTkxNV9CT19DQUNI RV9DT0hFUkVOVF9GT1JfUkVBRCBCSVQoMCkKICNkZWZpbmUgSTkxNV9CT19DQUNIRV9DT0hFUkVO VF9GT1JfV1JJVEUgQklUKDEpCisJdW5zaWduZWQgaW50IGNhY2hlX2NvaGVyZW50OjI7CisKKwkv KioKKwkgKiBAY2FjaGVfZGlydHk6CisJICoKKwkgKiBUcmFjayBpZiB3ZSBhcmUgd2UgZGlydHkg d2l0aCB3cml0ZXMgdGhyb3VnaCB0aGUgQ1BVIGNhY2hlIGZvciB0aGlzCisJICogb2JqZWN0LiBB cyBhIHJlc3VsdCByZWFkaW5nIGRpcmVjdGx5IGZyb20gbWFpbiBtZW1vcnkgbWlnaHQgeWllbGQK KwkgKiBzdGFsZSBkYXRhLgorCSAqCisJICogVGhpcyBhbHNvIHRpZXMgaW50byB3aGV0aGVyIHRo ZSBrZXJuZWwgaXMgdHJhY2tpbmcgdGhlIG9iamVjdCBhcworCSAqIGNvaGVyZW50IHdpdGggdGhl IEdQVSwgYXMgcGVyIEBjYWNoZV9jb2hlcmVudCwgYXMgaXQgZGV0ZXJtaW5lcyBpZgorCSAqIGZs dXNoaW5nIG1pZ2h0IGJlIG5lZWRlZCBhdCB2YXJpb3VzIHBvaW50cy4KKwkgKgorCSAqIEFub3Ro ZXIgcGFydCBvZiBAY2FjaGVfZGlydHkgaXMgbWFuYWdpbmcgZmx1c2hpbmcgd2hlbiBmaXJzdAor CSAqIGFjcXVpcmluZyB0aGUgcGFnZXMgZm9yIHN5c3RlbSBtZW1vcnksIGF0IHRoaXMgcG9pbnQg dGhlIHBhZ2VzIGFyZQorCSAqIGNvbnNpZGVyZWQgZm9yZWlnbiwgc28gdGhlIGRlZmF1bHQgYXNz dW1wdGlvbiBpcyB0aGF0IHRoZSBjYWNoZSBpcworCSAqIGRpcnR5LCBmb3IgZXhhbXBsZSB0aGUg cGFnZSB6ZXJvaW5nIGRvbmUgYnkgdGhlIGtlcm5lbCBtaWdodCBsZWF2ZQorCSAqIHdyaXRlcyB0 aG91Z2ggdGhlIENQVSBjYWNoZSwgb3Igc3dhcHBpbmctaW4sIHdoaWxlIHRoZSBhY3R1YWwgZGF0 YSBpbgorCSAqIG1haW4gbWVtb3J5IGlzIHBvdGVudGlhbGx5IHN0YWxlLiAgTm90ZSB0aGF0IHRo aXMgaXMgYSBwb3RlbnRpYWwKKwkgKiBzZWN1cml0eSBpc3N1ZSB3aGVuIGRlYWxpbmcgd2l0aCB1 c2Vyc3BhY2Ugb2JqZWN0cyBhbmQgemVyb2luZy4gTm93LAorCSAqIHdoZXRoZXIgd2UgYWN0dWFs bHkgbmVlZCBhcHBseSB0aGUgYmlnIHNsZWRnZWhhbW1lciBvZiBmbHVzaGluZyBhbGwKKwkgKiB0 aGUgcGFnZXMgb24gYWNxdWlyZSBkZXBlbmRzIG9uIGlmIEBjYWNoZV9jb2hlcmVudCBpcyBtYXJr ZWQgYXMKKwkgKiBJOTE1X0JPX0NBQ0hFX0NPSEVSRU5UX0ZPUl9XUklURSwgaS5lIHRoYXQgdGhl IEdQVSB3aWxsIGJlIGNvaGVyZW50CisJICogZm9yIGJvdGggcmVhZHMgYW5kIHdyaXRlcyB0aG91 Z2ggdGhlIENQVSBjYWNoZS4KKwkgKgorCSAqIE5vdGUgdGhhdCBvbiBzaGFyZWQgTExDIHBsYXRm b3JtcyB3ZSBzdGlsbCBhcHBseSB0aGUgaGVhdnkgZmx1c2ggZm9yCisJICogSTkxNV9DQUNIRV9O T05FIG9iamVjdHMsIHVuZGVyIHRoZSBhc3N1bXB0aW9uIHRoYXQgdGhpcyBpcyBnb2luZyB0bwor CSAqIGJlIHVzZWQgZm9yIHNjYW5vdXQuCisJICovCiAJdW5zaWduZWQgaW50IGNhY2hlX2RpcnR5 OjE7CiAKIAkvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2Lmgg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCmluZGV4IDAzMjFhMWY5NzM4ZC4uZjk3 NzkyY2NjMTk5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKQEAgLTM5NCwxNSArMzk0LDYgQEAg c3RydWN0IGRybV9pOTE1X2Rpc3BsYXlfZnVuY3MgewogCXZvaWQgKCpyZWFkX2x1dHMpKHN0cnVj dCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlKTsKIH07CiAKLWVudW0gaTkxNV9jYWNoZV9s ZXZlbCB7Ci0JSTkxNV9DQUNIRV9OT05FID0gMCwKLQlJOTE1X0NBQ0hFX0xMQywgLyogYWxzbyB1 c2VkIGZvciBzbm9vcGFibGUgbWVtb3J5IG9uIG5vbi1MTEMgKi8KLQlJOTE1X0NBQ0hFX0wzX0xM QywgLyogZ2VuNyssIEwzIHNpdHMgYmV0d2VlbiB0aGUgZG9tYWluIHNwZWNpZmMKLQkJCSAgICAg IGNhY2hlcywgZWcgc2FtcGxlci9yZW5kZXIgY2FjaGVzLCBhbmQgdGhlCi0JCQkgICAgICBsYXJn ZSBMYXN0LUxldmVsLUNhY2hlLiBMTEMgaXMgY29oZXJlbnQgd2l0aAotCQkJICAgICAgdGhlIENQ VSwgYnV0IEwzIGlzIG9ubHkgdmlzaWJsZSB0byB0aGUgR1BVLiAqLwotCUk5MTVfQ0FDSEVfV1Qs IC8qIGhzdzpndDNlIFdyaXRlVGhyb3VnaCBmb3Igc2Nhbm91dHMgKi8KLX07CiAKICNkZWZpbmUg STkxNV9DT0xPUl9VTkVWSUNUQUJMRSAoLTEpIC8qIGEgbm9uLXZtYSBzaGFyaW5nIHRoZSBhZGRy ZXNzIHNwYWNlICovCiAKLS0gCjIuMjYuMwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vaW50ZWwtZ2Z4Cg== 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 55B50C63797 for ; Thu, 22 Jul 2021 11:35:17 +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 1E9FA61260 for ; Thu, 22 Jul 2021 11:35:17 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1E9FA61260 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 7E40F6E88A; Thu, 22 Jul 2021 11:35:16 +0000 (UTC) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by gabe.freedesktop.org (Postfix) with ESMTPS id 7526B6E5D4; Thu, 22 Jul 2021 11:35:14 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10052"; a="198896664" X-IronPort-AV: E=Sophos;i="5.84,260,1620716400"; d="scan'208";a="198896664" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jul 2021 04:35:13 -0700 X-IronPort-AV: E=Sophos;i="5.84,260,1620716400"; d="scan'208";a="470602848" Received: from kgreenan-mobl.ger.corp.intel.com (HELO mwauld-desk1.intel.com) ([10.252.29.109]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 22 Jul 2021 04:35:11 -0700 From: Matthew Auld To: intel-gfx@lists.freedesktop.org Subject: [PATCH v3 1/2] drm/i915: document caching related bits Date: Thu, 22 Jul 2021 12:34:55 +0100 Message-Id: <20210722113456.304882-1-matthew.auld@intel.com> X-Mailer: git-send-email 2.26.3 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: Daniel Vetter , dri-devel@lists.freedesktop.org, Mika Kuoppala Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Try to document the object caching related bits, like cache_coherent and cache_dirty. v2(Ville): - As pointed out by Ville, fix the completely incorrect assumptions about the "partial" coherency on shared LLC platforms. v3(Daniel): - Fix nonsense about "dirtying" the cache with reads. Suggested-by: Daniel Vetter Signed-off-by: Matthew Auld Cc: Ville Syrjälä Cc: Mika Kuoppala --- .../gpu/drm/i915/gem/i915_gem_object_types.h | 176 +++++++++++++++++- drivers/gpu/drm/i915/i915_drv.h | 9 - 2 files changed, 172 insertions(+), 13 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h index afbadfc5516b..40cce816a7e3 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object_types.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_object_types.h @@ -92,6 +92,76 @@ struct drm_i915_gem_object_ops { const char *name; /* friendly name for debug, e.g. lockdep classes */ }; +/** + * enum i915_cache_level - The supported GTT caching values for system memory + * pages. + * + * These translate to some special GTT PTE bits when binding pages into some + * address space. It also determines whether an object, or rather its pages are + * coherent with the GPU, when also reading or writing through the CPU cache + * with those pages. + * + * Userspace can also control this through struct drm_i915_gem_caching. + */ +enum i915_cache_level { + /** + * @I915_CACHE_NONE: + * + * Not coherent with the CPU cache. If the cache is dirty and we need + * the underlying pages to be coherent with some later GPU access then + * we need to manually flush the pages. + * + * Note that on shared LLC platforms reads and writes through the CPU + * cache are still coherent even with this setting. See also + * &drm_i915_gem_object.cache_coherent for more details. + * + * Note that on platforms with a shared LLC this should ideally only be + * used for scanout surfaces, otherwise we end up over-flushing in some + * places. + */ + I915_CACHE_NONE = 0, + /** + * @I915_CACHE_LLC: + * + * Coherent with the CPU cache. If the cache is dirty, then the GPU will + * ensure that access remains coherent, when both reading and writing + * through the CPU cache. + * + * Not used for scanout surfaces. + * + * Applies to both platforms with shared LLC(HAS_LLC), and snooping + * based platforms(HAS_SNOOP). + * + * This should be the default for platforms which share the LLC with the + * CPU. The only exception is scanout objects, where the display engine + * is not coherent with the LLC. For such objects I915_CACHE_NONE or + * I915_CACHE_WT should be used. + */ + I915_CACHE_LLC, + /** + * @I915_CACHE_L3_LLC: + * + * Explicitly enable the Gfx L3 cache, with snooped LLC. + * + * The Gfx L3 sits between the domain specific caches, e.g + * sampler/render caches, and the larger LLC. LLC is coherent with the + * GPU, but L3 is only visible to the GPU, so likely needs to be flushed + * when the workload completes. + * + * Not used for scanout surfaces. + * + * Only exposed on some gen7 + GGTT. More recent hardware has dropped + * this. + */ + I915_CACHE_L3_LLC, + /** + * @I915_CACHE_WT: + * + * hsw:gt3e Write-through for scanout buffers. + */ + I915_CACHE_WT, +}; + enum i915_map_type { I915_MAP_WB = 0, I915_MAP_WC, @@ -229,14 +299,112 @@ struct drm_i915_gem_object { unsigned int mem_flags; #define I915_BO_FLAG_STRUCT_PAGE BIT(0) /* Object backed by struct pages */ #define I915_BO_FLAG_IOMEM BIT(1) /* Object backed by IO memory */ - /* - * Is the object to be mapped as read-only to the GPU - * Only honoured if hardware has relevant pte bit + /** + * @cache_level: The desired GTT caching level. + * + * See enum i915_cache_level for possible values, along with what + * each does. */ unsigned int cache_level:3; - unsigned int cache_coherent:2; + /** + * @cache_coherent: + * + * Track whether the pages are coherent with the GPU if reading or + * writing through the CPU caches. The largely depends on the + * @cache_level setting. + * + * On platforms which don't have the shared LLC(HAS_SNOOP), like on Atom + * platforms, coherency must be explicitly requested with some special + * GTT caching bits(see enum i915_cache_level). When enabling coherency + * it does come at a performance and power cost on such platforms. On + * the flip side the kernel does need to manually flush any buffers + * which need to be coherent with the GPU, if the object is not + * coherent i.e @cache_coherent is zero. + * + * On platforms that share the LLC with the CPU(HAS_LLC), all GT memory + * access will automatically snoop the CPU caches(even with CACHE_NONE). + * The one exception is when dealing with the display engine, like with + * scanout surfaces. To handle this the kernel will always flush the + * surface out of the CPU caches when preparing it for scanout. Also + * note that since scanout surfaces are only ever read by the display + * engine we only need to care about flushing any writes through the CPU + * cache, reads on the other hand will always be coherent. + * + * Something strange here is why @cache_coherent is not a simple + * boolean, i.e coherent vs non-coherent. The reasoning for this is back + * to the display engine not being fully coherent. As a result scanout + * surfaces will either be marked as I915_CACHE_NONE or I915_CACHE_WT. + * In the case of seeing I915_CACHE_NONE the kernel makes the assumption + * that this is likely a scanout surface, and will set @cache_coherent + * as only I915_BO_CACHE_COHERENT_FOR_READ, on platforms with the shared + * LLC. The kernel uses this to always flush writes through the CPU + * cache as early as possible, where it can, in effect keeping + * @cache_dirty clean, so we can potentially avoid stalling when + * flushing the surface just before doing the scanout. This does mean + * we might unnecessarily flush non-scanout objects in some places, but + * the default assumption is that all normal objects should be using + * I915_CACHE_LLC, at least on platforms with the shared LLC. + * + * Supported values: + * + * I915_BO_CACHE_COHERENT_FOR_READ: + * + * On shared LLC platforms, we use this for special scanout surfaces, + * where the display engine is not coherent with the CPU cache. As such + * we need to ensure we flush any writes before doing the scanout. As an + * optimisation we try to flush any writes as early as possible to avoid + * stalling later. + * + * Thus for scanout surfaces using I915_CACHE_NONE, on shared LLC + * platforms, we use: + * + * cache_coherent = I915_BO_CACHE_COHERENT_FOR_READ + * + * While for normal objects that are fully coherent we use: + * + * cache_coherent = I915_BO_CACHE_COHERENT_FOR_READ | + * I915_BO_CACHE_COHERENT_FOR_WRITE + * + * And then for objects that are not coherent at all we use: + * + * cache_coherent = 0 + * + * I915_BO_CACHE_COHERENT_FOR_WRITE: + * + * When writing through the CPU cache, the GPU is still coherent. Note + * that this also implies I915_BO_CACHE_COHERENT_FOR_READ. + */ #define I915_BO_CACHE_COHERENT_FOR_READ BIT(0) #define I915_BO_CACHE_COHERENT_FOR_WRITE BIT(1) + unsigned int cache_coherent:2; + + /** + * @cache_dirty: + * + * Track if we are we dirty with writes through the CPU cache for this + * object. As a result reading directly from main memory might yield + * stale data. + * + * This also ties into whether the kernel is tracking the object as + * coherent with the GPU, as per @cache_coherent, as it determines if + * flushing might be needed at various points. + * + * Another part of @cache_dirty is managing flushing when first + * acquiring the pages for system memory, at this point the pages are + * considered foreign, so the default assumption is that the cache is + * dirty, for example the page zeroing done by the kernel might leave + * writes though the CPU cache, or swapping-in, while the actual data in + * main memory is potentially stale. Note that this is a potential + * security issue when dealing with userspace objects and zeroing. Now, + * whether we actually need apply the big sledgehammer of flushing all + * the pages on acquire depends on if @cache_coherent is marked as + * I915_BO_CACHE_COHERENT_FOR_WRITE, i.e that the GPU will be coherent + * for both reads and writes though the CPU cache. + * + * Note that on shared LLC platforms we still apply the heavy flush for + * I915_CACHE_NONE objects, under the assumption that this is going to + * be used for scanout. + */ unsigned int cache_dirty:1; /** diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 0321a1f9738d..f97792ccc199 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -394,15 +394,6 @@ struct drm_i915_display_funcs { void (*read_luts)(struct intel_crtc_state *crtc_state); }; -enum i915_cache_level { - I915_CACHE_NONE = 0, - I915_CACHE_LLC, /* also used for snoopable memory on non-LLC */ - I915_CACHE_L3_LLC, /* gen7+, L3 sits between the domain specifc - caches, eg sampler/render caches, and the - large Last-Level-Cache. LLC is coherent with - the CPU, but L3 is only visible to the GPU. */ - I915_CACHE_WT, /* hsw:gt3e WriteThrough for scanouts */ -}; #define I915_COLOR_UNEVICTABLE (-1) /* a non-vma sharing the address space */ -- 2.26.3