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=-13.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 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 72410C433B4 for ; Mon, 17 May 2021 10:57:24 +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 3215661059 for ; Mon, 17 May 2021 10:57:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3215661059 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 4CE996E928; Mon, 17 May 2021 10:57:20 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 066AA6E926; Mon, 17 May 2021 10:57:18 +0000 (UTC) IronPort-SDR: fq5YflTTxWr6dyzMM7EY0wsmAmRUPMNZiU8KEe4oOS+qINSxSZokzo9lYv8/uoVNIVEx72cqJo On92HCd8qbxg== X-IronPort-AV: E=McAfee;i="6200,9189,9986"; a="221470226" X-IronPort-AV: E=Sophos;i="5.82,307,1613462400"; d="scan'208";a="221470226" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 03:57:17 -0700 IronPort-SDR: lGBplcriXwGuqoq7xRPG3JRkkzjJheETgd5sjzIFiWO51+9YlYoJNrNP7eV8dWczr6/013tYEG sxwDoNijgqDg== X-IronPort-AV: E=Sophos;i="5.82,307,1613462400"; d="scan'208";a="472359308" Received: from sudhirk1-mobl1.ger.corp.intel.com (HELO localhost) ([10.252.50.192]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 03:57:13 -0700 From: Jani Nikula To: Thomas =?utf-8?Q?Hellstr=C3=B6m?= , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org In-Reply-To: <20210511132525.377190-6-thomas.hellstrom@linux.intel.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> <20210511132525.377190-6-thomas.hellstrom@linux.intel.com> Date: Mon, 17 May 2021 13:57:10 +0300 Message-ID: <87pmxphbll.fsf@intel.com> MIME-Version: 1.0 Subject: Re: [Intel-gfx] [PATCH 5/7] drm/i915/ttm, drm/ttm: Add a generic TTM memcpy move for page-based iomem 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: Thomas =?utf-8?Q?Hellstr=C3=B6m?= , Christian =?utf-8?Q?K=C3=B6nig?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" T24gVHVlLCAxMSBNYXkgMjAyMSwgVGhvbWFzIEhlbGxzdHLDtm0gPHRob21hcy5oZWxsc3Ryb21A bGludXguaW50ZWwuY29tPiB3cm90ZToKPiBUaGUgaW50ZXJuYWwgdHRtX2JvX3V0aWwgbWVtY3B5 IHVzZXMgdm1hcCBmdW5jdGlvbmFsaXR5LCBhbmQgd2hpbGUgaXQKPiBwcm9iYWJseSBtaWdodCBi ZSBwb3NzaWJsZSB0byB1c2UgaXQgZm9yIGNvcHlpbmcgaW4tIGFuZCBvdXQgb2YKPiBzZ2xpc3Qg cmVwcmVzZW50ZWQgaW8gbWVtb3J5LCB1c2luZyBpb19tZW1fcmVzZXJ2ZSgpIC8gaW9fbWVtX2Zy ZWUoKQo+IGNhbGxiYWNrcywgdGhhdCB3b3VsZCBjYXVzZSBwcm9ibGVtcyB3aXRoIGZhdWx0KCku Cj4gSW5zdGVhZCwgaW1wbGVtZW50IGEgbWV0aG9kIG1hcHBpbmcgcGFnZS1ieS1wYWdlIHVzaW5n IGttYXBfbG9jYWwoKQo+IHNlbWFudGljcy4gQXMgYW4gYWRkaXRpb25hbCBiZW5lZml0IHdlIHRo ZW4gYXZvaWQgdGhlIG9jY2FzaW9uYWwgZ2xvYmFsCj4gVExCIGZsdXNoZXMgb2Ygdm1hcCgpIGFu ZCBjb25zdW1pbmcgdm1hcCBzcGFjZSwgZWxpbWluYXRpb24gb2YgYSBjcml0aWNhbAo+IHBvaW50 IG9mIGZhaWx1cmUgYW5kIHdpdGggYSBzbGlnaHQgY2hhbmdlIG9mIHNlbWFudGljcyB3ZSBjb3Vs ZCBhbHNvIHB1c2gKPiB0aGUgbWVtY3B5IG91dCBhc3luYyBmb3IgdGVzdGluZyBhbmQgYXN5bmMg ZHJpdmVyIGRldmVscG1lbnQgcHVycG9zZXMuCj4gUHVzaGluZyBvdXQgYXN5bmMgY2FuIGJlIGRv bmUgc2luY2UgdGhlcmUgaXMgbm8gbWVtb3J5IGFsbG9jYXRpb24gZ29pbmcgb24KPiB0aGF0IGNv dWxkIHZpb2xhdGUgdGhlIGRtYV9mZW5jZSBsb2NrZGVwIHJ1bGVzLgo+Cj4gTm90ZSB0aGF0IGRy aXZlcnMgdGhhdCBkb24ndCB3YW50IHRvIHVzZSBzdHJ1Y3QgaW9fbWFwcGluZyBidXQgcmVsaWVz IG9uCj4gbWVtcmVtYXAgZnVuY3Rpb25hbGl0eSwgYW5kIHRoYXQgZG9uJ3Qgd2FudCB0byB1c2Ug c2NhdHRlcmxpc3RzIGZvcgo+IFZSQU0gbWF5IHdlbGwgZGVmaW5lIHNwZWNpYWxpemVkIChob3Bl ZnVsbHkgcmV1c2FibGUpIGl0ZXJhdG9ycyBmb3IgdGhlaXIKPiBwYXJ0aWN1bGFyIGVudmlyb25t ZW50Lgo+Cj4gQ2M6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4K PiBTaWduZWQtb2ZmLWJ5OiBUaG9tYXMgSGVsbHN0csO2bSA8dGhvbWFzLmhlbGxzdHJvbUBsaW51 eC5pbnRlbC5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlICAgICAg ICAgICAgICAgICB8ICAgMSArCj4gIC4uLi9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9i b191dGlsLmMgICB8IDE1NSArKysrKysrKysrKysrKysrKysKPiAgLi4uL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwuaCAgIHwgMTQxICsrKysrKysrKysrKysrKysKPiAgZHJp dmVycy9ncHUvZHJtL3R0bS90dG1fYm8uYyAgICAgICAgICAgICAgICAgIHwgICAxICsKPiAgNCBm aWxlcyBjaGFuZ2VkLCAyOTggaW5zZXJ0aW9ucygrKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9ib191dGlsLmMKPiAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG1fYm9fdXRpbC5o Cj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9NYWtlZmlsZQo+IGluZGV4IGNiODgyMzU3MDk5Ni4uOTU4Y2NjMWVkZmVk IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKPiBAQCAtMTU1LDYgKzE1NSw3IEBAIGdlbS15ICs9 IFwKPiAgCWdlbS9pOTE1X2dlbV9zdG9sZW4ubyBcCj4gIAlnZW0vaTkxNV9nZW1fdGhyb3R0bGUu byBcCj4gIAlnZW0vaTkxNV9nZW1fdGlsaW5nLm8gXAo+ICsJZ2VtL2k5MTVfZ2VtX3R0bV9ib191 dGlsLm8gXAo+ICAJZ2VtL2k5MTVfZ2VtX3VzZXJwdHIubyBcCj4gIAlnZW0vaTkxNV9nZW1fd2Fp dC5vIFwKPiAgCWdlbS9pOTE1X2dlbWZzLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9ib191dGlsLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n ZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi4xMTE2ZDdkZjE0NjEKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9ib191dGlsLmMKPiBAQCAtMCwwICsxLDE1 NSBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCj4gKy8qCj4gKyAqIENvcHly aWdodCDCqSAyMDIxIEludGVsIENvcnBvcmF0aW9uCj4gKyAqLwo+ICsKPiArLyoqCj4gKyAqIERP QzogVXNhZ2UgYW5kIGludGVudGlvbnMuCj4gKyAqCj4gKyAqIFRoaXMgZmlsZSBjb250YWlucyBm dW5jdGlvbmFsaXR5IHRoYXQgd2UgbWlnaHQgd2FudCB0byBtb3ZlIGludG8KPiArICogdHRtX2Jv X3V0aWwuYyBpZiB0aGVyZSBpcyBhIGNvbW1vbiBpbnRlcmVzdC4KPiArICogQ3VycmVudGx5IGEg a21hcF9sb2NhbCBvbmx5IG1lbWNweSB3aXRoIHN1cHBvcnQgZm9yIHBhZ2UtYmFzZWQgaW9tZW0g cmVnaW9ucywKPiArICogYW5kIGZhc3QgbWVtY3B5IGZyb20gd3JpdGUtY29tYmluZWQgbWVtb3J5 Lgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLW1hcC5oPgo+ICsjaW5jbHVk ZSA8bGludXgvaGlnaG1lbS5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW8tbWFwcGluZy5oPgo+ICsj aW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KPiArCj4gKyNpbmNsdWRlICJpOTE1X21lbWNw eS5oIgo+ICsKPiArI2luY2x1ZGUgImdlbS9pOTE1X2dlbV90dG1fYm9fdXRpbC5oIgo+ICsKPiAr c3RhdGljIHZvaWQgaTkxNV90dG1fa21hcF9pdGVyX3R0X2ttYXBfbG9jYWwoc3RydWN0IGk5MTVf dHRtX2ttYXBfaXRlciAqaXRlciwKPiArCQkJCQkgICAgIHN0cnVjdCBkbWFfYnVmX21hcCAqZG1h cCwKPiArCQkJCQkgICAgIHBnb2ZmX3QgaSkKPiArewo+ICsJc3RydWN0IGk5MTVfdHRtX2ttYXBf aXRlcl90dCAqaXRlcl90dCA9Cj4gKwkJY29udGFpbmVyX29mKGl0ZXIsIHR5cGVvZigqaXRlcl90 dCksIGJhc2UpOwo+ICsKPiArCWRtYV9idWZfbWFwX3NldF92YWRkcihkbWFwLCBrbWFwX2xvY2Fs X3BhZ2UoaXRlcl90dC0+dHQtPnBhZ2VzW2ldKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGk5 MTVfdHRtX2ttYXBfaXRlcl9pb21hcF9rbWFwX2xvY2FsKHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0 ZXIgKml0ZXIsCj4gKwkJCQkJCXN0cnVjdCBkbWFfYnVmX21hcCAqZG1hcCwKPiArCQkJCQkJcGdv ZmZfdCBpKQo+ICt7Cj4gKwlzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyX2lvbWFwICppdGVyX2lv ID0KPiArCQljb250YWluZXJfb2YoaXRlciwgdHlwZW9mKCppdGVyX2lvKSwgYmFzZSk7Cj4gKwl2 b2lkIF9faW9tZW0gKmFkZHI7Cj4gKwo+ICtyZXRyeToKPiArCXdoaWxlIChpID49IGl0ZXJfaW8t PmNhY2hlLmVuZCkgewo+ICsJCWl0ZXJfaW8tPmNhY2hlLnNnID0gaXRlcl9pby0+Y2FjaGUuc2cg Pwo+ICsJCQlzZ19uZXh0KGl0ZXJfaW8tPmNhY2hlLnNnKSA6IGl0ZXJfaW8tPnN0LT5zZ2w7Cj4g KwkJaXRlcl9pby0+Y2FjaGUuaSA9IGl0ZXJfaW8tPmNhY2hlLmVuZDsKPiArCQlpdGVyX2lvLT5j YWNoZS5lbmQgKz0gc2dfZG1hX2xlbihpdGVyX2lvLT5jYWNoZS5zZykgPj4KPiArCQkJUEFHRV9T SElGVDsKPiArCQlpdGVyX2lvLT5jYWNoZS5vZmZzID0gc2dfZG1hX2FkZHJlc3MoaXRlcl9pby0+ Y2FjaGUuc2cpIC0KPiArCQkJaXRlcl9pby0+c3RhcnQ7Cj4gKwl9Cj4gKwo+ICsJaWYgKGkgPCBp dGVyX2lvLT5jYWNoZS5pKSB7Cj4gKwkJaXRlcl9pby0+Y2FjaGUuZW5kID0gMDsKPiArCQlpdGVy X2lvLT5jYWNoZS5zZyA9IE5VTEw7Cj4gKwkJZ290byByZXRyeTsKPiArCX0KPiArCj4gKwlhZGRy ID0gaW9fbWFwcGluZ19tYXBfbG9jYWxfd2MoaXRlcl9pby0+aW9tYXAsIGl0ZXJfaW8tPmNhY2hl Lm9mZnMgKwo+ICsJCQkJICAgICAgICgoKHJlc291cmNlX3NpemVfdClpIC0gaXRlcl9pby0+Y2Fj aGUuaSkKPiArCQkJCQk8PCBQQUdFX1NISUZUKSk7Cj4gKwlkbWFfYnVmX21hcF9zZXRfdmFkZHJf aW9tZW0oZG1hcCwgYWRkcik7Cj4gK30KPiArCj4gK3N0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJf b3BzIGk5MTVfdHRtX2ttYXBfaXRlcl90dF9vcHMgPSB7Cj4gKwkua21hcF9sb2NhbCA9IGk5MTVf dHRtX2ttYXBfaXRlcl90dF9rbWFwX2xvY2FsCj4gK307Cj4gKwo+ICtzdHJ1Y3QgaTkxNV90dG1f a21hcF9pdGVyX29wcyBpOTE1X3R0bV9rbWFwX2l0ZXJfaW9fb3BzID0gewo+ICsJLmttYXBfbG9j YWwgPSAgaTkxNV90dG1fa21hcF9pdGVyX2lvbWFwX2ttYXBfbG9jYWwKPiArfTsKPiArCj4gK3N0 YXRpYyB2b2lkIGt1bm1hcF9sb2NhbF9kbWFfYnVmX21hcChzdHJ1Y3QgZG1hX2J1Zl9tYXAgKm1h cCkKPiArewo+ICsJaWYgKG1hcC0+aXNfaW9tZW0pCj4gKwkJaW9fbWFwcGluZ191bm1hcF9sb2Nh bChtYXAtPnZhZGRyX2lvbWVtKTsKPiArCWVsc2UKPiArCQlrdW5tYXBfbG9jYWwobWFwLT52YWRk cik7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBpOTE1X3R0bV9tb3ZlX21lbWNweSAtIEhlbHBlciB0 byBwZXJmb3JtIGEgbWVtY3B5IHR0bSBtb3ZlIG9wZXJhdGlvbi4KPiArICogQGJvOiBUaGUgc3Ry dWN0IHR0bV9idWZmZXJfb2JqZWN0Lgo+ICsgKiBAbmV3X21lbTogVGhlIHN0cnVjdCB0dG1fcmVz b3VyY2Ugd2UncmUgbW92aW5nIHRvIChjb3B5IGRlc3RpbmF0aW9uKS4KPiArICogQG5ld19rbWFw OiBBIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIgcmVwcmVzZW50aW5nIHRoZSBkZXN0aW5hdGlv biByZXNvdXJjZS4KPiArICogQG9sZF9rbWFwOiBBIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIg cmVwcmVzZW50aW5nIHRoZSBzb3VyY2UgcmVzb3VyY2UuCj4gKyAqLwo+ICt2b2lkIGk5MTVfdHRt X21vdmVfbWVtY3B5KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCj4gKwkJCSAgc3RydWN0 IHR0bV9yZXNvdXJjZSAqbmV3X21lbSwKPiArCQkJICBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVy ICpuZXdfa21hcCwKPiArCQkJICBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyICpvbGRfa21hcCkK PiArewo+ICsJc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYgPSBiby0+YmRldjsKPiArCXN0cnVjdCB0 dG1fcmVzb3VyY2VfbWFuYWdlciAqbWFuID0gdHRtX21hbmFnZXJfdHlwZShiZGV2LCBuZXdfbWVt LT5tZW1fdHlwZSk7Cj4gKwlzdHJ1Y3QgdHRtX3R0ICp0dG0gPSBiby0+dHRtOwo+ICsJc3RydWN0 IHR0bV9yZXNvdXJjZSAqb2xkX21lbSA9ICZiby0+bWVtOwo+ICsJc3RydWN0IHR0bV9yZXNvdXJj ZSBvbGRfY29weSA9ICpvbGRfbWVtOwo+ICsJc3RydWN0IHR0bV9yZXNvdXJjZV9tYW5hZ2VyICpv bGRfbWFuID0gdHRtX21hbmFnZXJfdHlwZShiZGV2LCBvbGRfbWVtLT5tZW1fdHlwZSk7Cj4gKwlz dHJ1Y3QgZG1hX2J1Zl9tYXAgb2xkX21hcCwgbmV3X21hcDsKPiArCXBnb2ZmX3QgaTsKPiArCj4g KwkvKiBGb3IgdGhlIHBhZ2UtYmFzZWQgYWxsb2NhdG9yIHdlIG5lZWQgc2d0YWJsZSBpdGVyYXRv cnMgYXMgd2VsbC4qLwo+ICsKPiArCS8qIFNpbmdsZSBUVE0gbW92ZS4gTk9QICovCj4gKwlpZiAo b2xkX21hbi0+dXNlX3R0ICYmIG1hbi0+dXNlX3R0KQo+ICsJCWdvdG8gZG9uZTsKPiArCj4gKwkv KiBEb24ndCBtb3ZlIG5vbmV4aXN0ZW50IGRhdGEuIENsZWFyIGRlc3RpbmF0aW9uIGluc3RlYWQu ICovCj4gKwlpZiAob2xkX21hbi0+dXNlX3R0ICYmICFtYW4tPnVzZV90dCAmJgo+ICsJICAgICh0 dG0gPT0gTlVMTCB8fCAhdHRtX3R0X2lzX3BvcHVsYXRlZCh0dG0pKSkgewo+ICsJCWlmICh0dG0g JiYgISh0dG0tPnBhZ2VfZmxhZ3MgJiBUVE1fUEFHRV9GTEFHX1pFUk9fQUxMT0MpKQo+ICsJCQln b3RvIGRvbmU7Cj4gKwo+ICsJCWZvciAoaSA9IDA7IGkgPCBuZXdfbWVtLT5udW1fcGFnZXM7ICsr aSkgewo+ICsJCQluZXdfa21hcC0+b3BzLT5rbWFwX2xvY2FsKG5ld19rbWFwLCAmbmV3X21hcCwg aSk7Cj4gKwkJCW1lbXNldF9pbyhuZXdfbWFwLnZhZGRyX2lvbWVtLCAwLCBQQUdFX1NJWkUpOwo+ ICsJCQlrdW5tYXBfbG9jYWxfZG1hX2J1Zl9tYXAoJm5ld19tYXApOwo+ICsJCX0KPiArCQlnb3Rv IGRvbmU7Cj4gKwl9Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IG5ld19tZW0tPm51bV9wYWdlczsg KytpKSB7Cj4gKwkJbmV3X2ttYXAtPm9wcy0+a21hcF9sb2NhbChuZXdfa21hcCwgJm5ld19tYXAs IGkpOwo+ICsJCW9sZF9rbWFwLT5vcHMtPmttYXBfbG9jYWwob2xkX2ttYXAsICZvbGRfbWFwLCBp KTsKPiArCQlpZiAoIW9sZF9tYXAuaXNfaW9tZW0gfHwKPiArCQkgICAgIWk5MTVfbWVtY3B5X2Zy b21fd2MobmV3X21hcC52YWRkciwgb2xkX21hcC52YWRkciwgUEFHRV9TSVpFKSkgewo+ICsJCQlp ZiAoIW9sZF9tYXAuaXNfaW9tZW0pIHsKPiArCQkJCWRtYV9idWZfbWFwX21lbWNweV90bygmbmV3 X21hcCwgb2xkX21hcC52YWRkciwKPiArCQkJCQkJICAgICAgUEFHRV9TSVpFKTsKPiArCQkJfSBl bHNlIGlmICghbmV3X21hcC5pc19pb21lbSkgewo+ICsJCQkJbWVtY3B5X2Zyb21pbyhuZXdfbWFw LnZhZGRyLCBvbGRfbWFwLnZhZGRyX2lvbWVtLAo+ICsJCQkJCSAgICAgIFBBR0VfU0laRSk7Cj4g KwkJCX0gZWxzZSB7Cj4gKwkJCQlwZ29mZl90IGo7Cj4gKwkJCQl1MzIgX19pb21lbSAqc3JjID0g b2xkX21hcC52YWRkcl9pb21lbTsKPiArCQkJCXUzMiBfX2lvbWVtICpkc3QgPSBuZXdfbWFwLnZh ZGRyX2lvbWVtOwo+ICsKPiArCQkJCWZvciAoaiA9IDA7IGogPCAoUEFHRV9TSVpFID4+IDIpOyAr K2opCj4gKwkJCQkJaW93cml0ZTMyKGlvcmVhZDMyKHNyYysrKSwgZHN0KyspOwo+ICsJCQl9Cj4g KwkJfQo+ICsJCWt1bm1hcF9sb2NhbF9kbWFfYnVmX21hcCgmb2xkX21hcCk7Cj4gKwkJa3VubWFw X2xvY2FsX2RtYV9idWZfbWFwKCZuZXdfbWFwKTsKPiArCX0KPiArCj4gK2RvbmU6Cj4gKwlvbGRf Y29weSA9ICpvbGRfbWVtOwo+ICsKPiArCXR0bV9ib19hc3NpZ25fbWVtKGJvLCBuZXdfbWVtKTsK PiArCj4gKwlpZiAoIW1hbi0+dXNlX3R0KQo+ICsJCXR0bV9ib190dF9kZXN0cm95KGJvKTsKPiAr Cj4gKwl0dG1fcmVzb3VyY2VfZnJlZShibywgJm9sZF9jb3B5KTsKPiArfQo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwuaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG1fYm9fdXRpbC5oCj4gbmV3IGZpbGUgbW9k ZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjgyYzkyMTc2NzE4ZAo+IC0tLSAvZGV2L251 bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwu aAo+IEBAIC0wLDAgKzEsMTQxIEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQg Ki8KPiArLyoKPiArICogQ29weXJpZ2h0IMKpIDIwMjEgSW50ZWwgQ29ycG9yYXRpb24KPiArICov Cj4gKwo+ICsvKgo+ICsgKiBUaGlzIGZpbGVzIGNvbnRhaW5zIGZ1bmN0aW9uYWxpdHkgdGhhdCB3 ZSBtaWdodCB3YW50IHRvIG1vdmUgaW50bwo+ICsgKiB0dG1fYm9fdXRpbC5jIGlmIHRoZXJlIGlz IGEgY29tbW9uIGludGVyZXN0Lgo+ICsgKi8KPiArI2lmbmRlZiBfSTkxNV9HRU1fVFRNX0JPX1VU SUxfSF8KPiArI2RlZmluZSBfSTkxNV9HRU1fVFRNX0JPX1VUSUxfSF8KPiArCj4gKyNpbmNsdWRl IDxkcm0vdHRtL3R0bV9ib19kcml2ZXIuaD4KPiArc3RydWN0IGRtYV9idWZfbWFwOwo+ICtzdHJ1 Y3QgaW9fbWFwcGluZzsKPiArc3RydWN0IHNnX3RhYmxlOwo+ICtzdHJ1Y3Qgc2NhdHRlcmxpc3Q7 Cj4gKwo+ICtzdHJ1Y3QgdHRtX3R0Owo+ICtzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyOwo+ICsK PiArLyoqCj4gKyAqIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfb3BzIC0gT3BzIHN0cnVjdHVy ZSBmb3IgYSBzdHJ1Y3QKPiArICogaTkxNV90dG1fa21hcF9pdGVyLgo+ICsgKi8KPiArc3RydWN0 IGk5MTVfdHRtX2ttYXBfaXRlcl9vcHMgewo+ICsJLyoqCj4gKwkgKiBrbWFwX2xvY2FsIC0gTWFw IGEgUEFHRV9TSVpFIHBhcnQgb2YgdGhlIHJlc291cmNlIHVzaW5nCj4gKwkgKiBrbWFwX2xvY2Fs IHNlbWFudGljcy4KPiArCSAqIEByZXNfa21hcDogUG9pbnRlciB0byB0aGUgc3RydWN0IGk5MTVf dHRtX2ttYXBfaXRlciByZXByZXNlbnRpbmcKPiArCSAqIHRoZSByZXNvdXJjZS4KPiArCSAqIEBk bWFwOiBUaGUgc3RydWN0IGRtYV9idWZfbWFwIGhvbGRpbmcgdGhlIHZpcnR1YWwgYWRkcmVzcyBh ZnRlcgo+ICsJICogdGhlIG9wZXJhdGlvbi4KPiArCSAqIEBpOiBUaGUgbG9jYXRpb24gd2l0aGlu IHRoZSByZXNvdXJjZSB0byBtYXAuIFBBR0VfU0laRSBncmFudWxhcml0eS4KPiArCSAqLwo+ICsJ dm9pZCAoKmttYXBfbG9jYWwpKHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIgKnJlc19rbWFwLAo+ ICsJCQkgICBzdHJ1Y3QgZG1hX2J1Zl9tYXAgKmRtYXAsIHBnb2ZmX3QgaSk7Cj4gK307Cj4gKwo+ ICsvKioKPiArICogc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlciAtIEl0ZXJhdG9yIGZvciBrbWFw X2xvY2FsIHR5cGUgb3BlcmF0aW9ucyBvbiBhCj4gKyAqIHJlc291cmNlLgo+ICsgKiBAb3BzOiBQ b2ludGVyIHRvIHRoZSBvcGVyYXRpb25zIHN0cnVjdC4KPiArICoKPiArICogVGhpcyBzdHJ1Y3Qg aXMgaW50ZW5kZWQgdG8gYmUgZW1iZWRkZWQgaW4gYSByZXNvdXJjZS1zcGVjaWZpYyBzcGVjaWFs aXphdGlvbgo+ICsgKiBpbXBsZW1lbnRpbmcgb3BlcmF0aW9ucyBmb3IgdGhlIHJlc291cmNlLgo+ ICsgKgo+ICsgKiBOb3RoaW5nIHN0b3BzIHVzIGZyb20gZXh0ZW5kaW5nIHRoZSBvcGVyYXRpb25z IHRvIHZtYXAsIHZtYXBfcGZuIGV0YywKPiArICogcmVwbGFjaW5nIHNvbWUgb3IgcGFydHMgb2Yg dGhlIHR0bV9ib191dGlsLiBjcHUtbWFwIGZ1bmN0aW9uYWxpdHkuCj4gKyAqLwo+ICtzdHJ1Y3Qg aTkxNV90dG1fa21hcF9pdGVyIHsKPiArCWNvbnN0IHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJf b3BzICpvcHM7Cj4gK307Cj4gKwo+ICsvKioKPiArICogc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRl cl90dCAtIFNwZWNpYWxpemF0aW9uIGZvciBhIHR0IChwYWdlKSBiYWNrZWQgc3RydWN0Cj4gKyAq IHR0bV9yZXNvdXJjZS4KPiArICogQGJhc2U6IEVtYmVkZGVkIHN0cnVjdCBpOTE1X3R0bV9rbWFw X2l0ZXIgcHJvdmlkaW5nIHRoZSB1c2FnZSBpbnRlcmZhY2UKPiArICogQHR0OiBDYWNoZWQgc3Ry dWN0IHR0bV90dC4KPiArICovCj4gK3N0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfdHQgewo+ICsJ c3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlciBiYXNlOwo+ICsJc3RydWN0IHR0bV90dCAqdHQ7Cj4g K307Cj4gKwo+ICsvKioKPiArICogc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9pb21hcCAtIFNw ZWNpYWxpemF0aW9uIGZvciBhIHN0cnVjdCBpb19tYXBwaW5nICsKPiArICogc3RydWN0IHNnX3Rh YmxlIGJhY2tlZCBzdHJ1Y3QgdHRtX3Jlc291cmNlLgo+ICsgKiBAYmFzZTogRW1iZWRkZWQgc3Ry dWN0IGk5MTVfdHRtX2ttYXBfaXRlciBwcm92aWRpbmcgdGhlIHVzYWdlIGludGVyZmFjZS4KPiAr ICogQGlvbWFwOiBzdHJ1Y3QgaW9fbWFwcGluZyByZXByZXNlbnRpbmcgdGhlIHVuZGVybHlpbmcg bGluZWFyIGlvX21lbW9yeS4KPiArICogQHN0OiBzZ190YWJsZSBpbnRvIEBpb21hcCwgcmVwcmVz ZW50aW5nIHRoZSBtZW1vcnkgb2YgdGhlIHN0cnVjdCB0dG1fcmVzb3VyY2UuCj4gKyAqIEBzdGFy dDogT2Zmc2V0IHRoYXQgbmVlZHMgdG8gYmUgc3VidHJhY3RlZCBmcm9tIEBzdCB0byBtYWtlCj4g KyAqIHNnX2RtYV9hZGRyZXNzKHN0LT5zZ2wpIC0gQHN0YXJ0ID09IDAgZm9yIEBpb21hcCBzdGFy dC4KPiArICogQGNhY2hlOiBTY2F0dGVybGlzdCB0cmF2ZXJzYWwgY2FjaGUgZm9yIGZhc3QgbG9v a3Vwcy4KPiArICogQGNhY2hlLnNnOiBQb2ludGVyIHRvIHRoZSBjdXJyZW50bHkgY2FjaGVkIHNj YXR0ZXJsaXN0IHNlZ21lbnQuCj4gKyAqIEBjYWNoZS5pOiBGaXJzdCBpbmRleCBvZiBAc2cuIFBB R0VfU0laRSBncmFudWxhcml0eS4KPiArICogQGNhY2hlLmVuZDogTGFzdCBpbmRleCArIDEgb2Yg QHNnLiBQQUdFX1NJWkUgZ3JhbnVsYXJpdHkuCj4gKyAqIEBjYWNoZS5vZmZzOiBGaXJzdCBvZmZz ZXQgaW50byBAaW9tYXAgb2YgQHNnLiBQQUdFX1NJWkUgZ3JhbnVsYXJpdHkuCj4gKyAqLwo+ICtz dHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyX2lvbWFwIHsKPiArCXN0cnVjdCBpOTE1X3R0bV9rbWFw X2l0ZXIgYmFzZTsKPiArCXN0cnVjdCBpb19tYXBwaW5nICppb21hcDsKPiArCXN0cnVjdCBzZ190 YWJsZSAqc3Q7Cj4gKwlyZXNvdXJjZV9zaXplX3Qgc3RhcnQ7Cj4gKwlzdHJ1Y3Qgewo+ICsJCXN0 cnVjdCBzY2F0dGVybGlzdCAqc2c7Cj4gKwkJcGdvZmZfdCBpOwo+ICsJCXBnb2ZmX3QgZW5kOwo+ ICsJCXBnb2ZmX3Qgb2ZmczsKPiArCX0gY2FjaGU7Cj4gK307Cj4gKwo+ICtleHRlcm4gc3RydWN0 IGk5MTVfdHRtX2ttYXBfaXRlcl9vcHMgaTkxNV90dG1fa21hcF9pdGVyX3R0X29wczsKPiArZXh0 ZXJuIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfb3BzIGk5MTVfdHRtX2ttYXBfaXRlcl9pb19v cHM7Cj4gKwo+ICsvKioKPiArICogaTkxNV90dG1fa21hcF9pdGVyX2lvbWFwX2luaXQgLSBJbml0 aWFsaXplIGEgc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9pb21hcAo+ICsgKiBAaXRlcl9pbzog VGhlIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfaW9tYXAgdG8gaW5pdGlhbGl6ZS4KPiArICog QGlvbWFwOiBUaGUgc3RydWN0IGlvX21hcHBpbmcgcmVwcmVzZW50aW5nIHRoZSB1bmRlcmx5aW5n IGxpbmVhciBpb19tZW1vcnkuCj4gKyAqIEBzdDogc2dfdGFibGUgaW50byBAaW9tYXAsIHJlcHJl c2VudGluZyB0aGUgbWVtb3J5IG9mIHRoZSBzdHJ1Y3QKPiArICogdHRtX3Jlc291cmNlLgo+ICsg KiBAc3RhcnQ6IE9mZnNldCB0aGF0IG5lZWRzIHRvIGJlIHN1YnRyYWN0ZWQgZnJvbSBAc3QgdG8g bWFrZQo+ICsgKiBzZ19kbWFfYWRkcmVzcyhzdC0+c2dsKSAtIEBzdGFydCA9PSAwIGZvciBAaW9t YXAgc3RhcnQuCj4gKyAqCj4gKyAqIFJldHVybjogUG9pbnRlciB0byB0aGUgZW1iZWRkZWQgc3Ry dWN0IGk5MTVfdHRtX2ttYXBfaXRlci4KPiArICovCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IGk5 MTVfdHRtX2ttYXBfaXRlciAqCj4gK2k5MTVfdHRtX2ttYXBfaXRlcl9pb21hcF9pbml0KHN0cnVj dCBpOTE1X3R0bV9rbWFwX2l0ZXJfaW9tYXAgKml0ZXJfaW8sCj4gKwkJCSAgICAgIHN0cnVjdCBp b19tYXBwaW5nICppb21hcCwKPiArCQkJICAgICAgc3RydWN0IHNnX3RhYmxlICpzdCwKPiArCQkJ ICAgICAgcmVzb3VyY2Vfc2l6ZV90IHN0YXJ0KQo+ICt7Cj4gKwlpdGVyX2lvLT5iYXNlLm9wcyA9 ICZpOTE1X3R0bV9rbWFwX2l0ZXJfaW9fb3BzOwo+ICsJaXRlcl9pby0+aW9tYXAgPSBpb21hcDsK PiArCWl0ZXJfaW8tPnN0ID0gc3Q7Cj4gKwlpdGVyX2lvLT5zdGFydCA9IHN0YXJ0Owo+ICsJbWVt c2V0KCZpdGVyX2lvLT5jYWNoZSwgMCwgc2l6ZW9mKGl0ZXJfaW8tPmNhY2hlKSk7Cj4gKwlyZXR1 cm4gJml0ZXJfaW8tPmJhc2U7Cj4gK30KPiArCj4gKy8qKgo+ICsgKiB0dG1fa21hcF9pdGVyX3R0 X2luaXQgLSBJbml0aWFsaXplIGEgc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl90dAo+ICsgKiBA aXRlcl90dDogVGhlIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfdHQgdG8gaW5pdGlhbGl6ZS4K PiArICogQHR0OiBTdHJ1Y3QgdHRtX3R0IGhvbGRpbmcgcGFnZSBwb2ludGVycyBvZiB0aGUgc3Ry dWN0IHR0bV9yZXNvdXJjZS4KPiArICoKPiArICogUmV0dXJuOiBQb2ludGVyIHRvIHRoZSBlbWJl ZGRlZCBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyLgo+ICsgKi8KPiArc3RhdGljIGlubGluZSBz dHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyICoKPiAraTkxNV90dG1fa21hcF9pdGVyX3R0X2luaXQo c3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl90dCAqaXRlcl90dCwKPiArCQkJICAgc3RydWN0IHR0 bV90dCAqdHQpCj4gK3sKPiArCWl0ZXJfdHQtPmJhc2Uub3BzID0gJmk5MTVfdHRtX2ttYXBfaXRl cl90dF9vcHM7Cj4gKwlpdGVyX3R0LT50dCA9IHR0Owo+ICsJcmV0dXJuICZpdGVyX3R0LT5iYXNl Owo+ICt9CgpEbyB0aGVyZSBmdW5jdGlvbnMgaGF2ZSBhIHZhbGlkICpwZXJmb3JtYW5jZSogcmVh c29uIHRvIGJlIGlubGluZT8gSQp0aGluayB0aGF0J3MgcHJldHR5IG11Y2ggdGhlIG9ubHkgdmFs aWQgcmVhc29uLgoKSGF2aW5nIHRoZXNlIGlubGluZSBmb3JjZXMgaTkxNV90dG1fa21hcF9pdGVy Xypfb3BzIGV4dGVybiwgYW5kIHRoZXkKc2hvdWxkIHJlYWxseSBiZSBzdGF0aWMuIElubGluZSBm dW5jdGlvbnMgY29tcGxpY2F0ZSBoZWFkZXIgZGVwZW5kZW5jaWVzCmFuZCBsZWFrIHRoZSBhYnN0 cmFjdGlvbnMuCgpCUiwKSmFuaS4KCgo+ICsKPiArdm9pZCBpOTE1X3R0bV9tb3ZlX21lbWNweShz dHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAo+ICsJCQkgIHN0cnVjdCB0dG1fcmVzb3VyY2Ug Km5ld19tZW0sCj4gKwkJCSAgc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlciAqbmV3X2l0ZXIsCj4g KwkJCSAgc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlciAqb2xkX2l0ZXIpOwo+ICsjZW5kaWYKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R0bS90dG1fYm8uYyBiL2RyaXZlcnMvZ3B1L2Ry bS90dG0vdHRtX2JvLmMKPiBpbmRleCBjYTFiMDk4YjZhNTYuLjQ0NzljNTVhYWExZCAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9iby5jCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL3R0bS90dG1fYm8uYwo+IEBAIC0xMjIxLDMgKzEyMjEsNCBAQCB2b2lkIHR0bV9ib190dF9k ZXN0cm95KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8pCj4gIAl0dG1fdHRfZGVzdHJveShi by0+YmRldiwgYm8tPnR0bSk7Cj4gIAliby0+dHRtID0gTlVMTDsKPiAgfQo+ICtFWFBPUlRfU1lN Qk9MKHR0bV9ib190dF9kZXN0cm95KTsKCi0tIApKYW5pIE5pa3VsYSwgSW50ZWwgT3BlbiBTb3Vy Y2UgR3JhcGhpY3MgQ2VudGVyCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2lu dGVsLWdmeAo= 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=-13.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 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 400A2C433ED for ; Mon, 17 May 2021 10:57:21 +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 04A9761185 for ; Mon, 17 May 2021 10:57:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 04A9761185 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 116276E926; Mon, 17 May 2021 10:57:20 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 066AA6E926; Mon, 17 May 2021 10:57:18 +0000 (UTC) IronPort-SDR: fq5YflTTxWr6dyzMM7EY0wsmAmRUPMNZiU8KEe4oOS+qINSxSZokzo9lYv8/uoVNIVEx72cqJo On92HCd8qbxg== X-IronPort-AV: E=McAfee;i="6200,9189,9986"; a="221470226" X-IronPort-AV: E=Sophos;i="5.82,307,1613462400"; d="scan'208";a="221470226" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 03:57:17 -0700 IronPort-SDR: lGBplcriXwGuqoq7xRPG3JRkkzjJheETgd5sjzIFiWO51+9YlYoJNrNP7eV8dWczr6/013tYEG sxwDoNijgqDg== X-IronPort-AV: E=Sophos;i="5.82,307,1613462400"; d="scan'208";a="472359308" Received: from sudhirk1-mobl1.ger.corp.intel.com (HELO localhost) ([10.252.50.192]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 03:57:13 -0700 From: Jani Nikula To: Thomas =?utf-8?Q?Hellstr=C3=B6m?= , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: Re: [Intel-gfx] [PATCH 5/7] drm/i915/ttm, drm/ttm: Add a generic TTM memcpy move for page-based iomem In-Reply-To: <20210511132525.377190-6-thomas.hellstrom@linux.intel.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> <20210511132525.377190-6-thomas.hellstrom@linux.intel.com> Date: Mon, 17 May 2021 13:57:10 +0300 Message-ID: <87pmxphbll.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable 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: Thomas =?utf-8?Q?Hellstr=C3=B6m?= , Christian =?utf-8?Q?K=C3=B6nig?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" On Tue, 11 May 2021, Thomas Hellstr=C3=B6m wrote: > The internal ttm_bo_util memcpy uses vmap functionality, and while it > probably might be possible to use it for copying in- and out of > sglist represented io memory, using io_mem_reserve() / io_mem_free() > callbacks, that would cause problems with fault(). > Instead, implement a method mapping page-by-page using kmap_local() > semantics. As an additional benefit we then avoid the occasional global > TLB flushes of vmap() and consuming vmap space, elimination of a critical > point of failure and with a slight change of semantics we could also push > the memcpy out async for testing and async driver develpment purposes. > Pushing out async can be done since there is no memory allocation going on > that could violate the dma_fence lockdep rules. > > Note that drivers that don't want to use struct io_mapping but relies on > memremap functionality, and that don't want to use scatterlists for > VRAM may well define specialized (hopefully reusable) iterators for their > particular environment. > > Cc: Christian K=C3=B6nig > Signed-off-by: Thomas Hellstr=C3=B6m > --- > drivers/gpu/drm/i915/Makefile | 1 + > .../gpu/drm/i915/gem/i915_gem_ttm_bo_util.c | 155 ++++++++++++++++++ > .../gpu/drm/i915/gem/i915_gem_ttm_bo_util.h | 141 ++++++++++++++++ > drivers/gpu/drm/ttm/ttm_bo.c | 1 + > 4 files changed, 298 insertions(+) > create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c > create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h > > diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile > index cb8823570996..958ccc1edfed 100644 > --- a/drivers/gpu/drm/i915/Makefile > +++ b/drivers/gpu/drm/i915/Makefile > @@ -155,6 +155,7 @@ gem-y +=3D \ > gem/i915_gem_stolen.o \ > gem/i915_gem_throttle.o \ > gem/i915_gem_tiling.o \ > + gem/i915_gem_ttm_bo_util.o \ > gem/i915_gem_userptr.o \ > gem/i915_gem_wait.o \ > gem/i915_gemfs.o > diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c b/drivers/gp= u/drm/i915/gem/i915_gem_ttm_bo_util.c > new file mode 100644 > index 000000000000..1116d7df1461 > --- /dev/null > +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c > @@ -0,0 +1,155 @@ > +// SPDX-License-Identifier: MIT > +/* > + * Copyright =C2=A9 2021 Intel Corporation > + */ > + > +/** > + * DOC: Usage and intentions. > + * > + * This file contains functionality that we might want to move into > + * ttm_bo_util.c if there is a common interest. > + * Currently a kmap_local only memcpy with support for page-based iomem = regions, > + * and fast memcpy from write-combined memory. > + */ > + > +#include > +#include > +#include > +#include > + > +#include "i915_memcpy.h" > + > +#include "gem/i915_gem_ttm_bo_util.h" > + > +static void i915_ttm_kmap_iter_tt_kmap_local(struct i915_ttm_kmap_iter *= iter, > + struct dma_buf_map *dmap, > + pgoff_t i) > +{ > + struct i915_ttm_kmap_iter_tt *iter_tt =3D > + container_of(iter, typeof(*iter_tt), base); > + > + dma_buf_map_set_vaddr(dmap, kmap_local_page(iter_tt->tt->pages[i])); > +} > + > +static void i915_ttm_kmap_iter_iomap_kmap_local(struct i915_ttm_kmap_ite= r *iter, > + struct dma_buf_map *dmap, > + pgoff_t i) > +{ > + struct i915_ttm_kmap_iter_iomap *iter_io =3D > + container_of(iter, typeof(*iter_io), base); > + void __iomem *addr; > + > +retry: > + while (i >=3D iter_io->cache.end) { > + iter_io->cache.sg =3D iter_io->cache.sg ? > + sg_next(iter_io->cache.sg) : iter_io->st->sgl; > + iter_io->cache.i =3D iter_io->cache.end; > + iter_io->cache.end +=3D sg_dma_len(iter_io->cache.sg) >> > + PAGE_SHIFT; > + iter_io->cache.offs =3D sg_dma_address(iter_io->cache.sg) - > + iter_io->start; > + } > + > + if (i < iter_io->cache.i) { > + iter_io->cache.end =3D 0; > + iter_io->cache.sg =3D NULL; > + goto retry; > + } > + > + addr =3D io_mapping_map_local_wc(iter_io->iomap, iter_io->cache.offs + > + (((resource_size_t)i - iter_io->cache.i) > + << PAGE_SHIFT)); > + dma_buf_map_set_vaddr_iomem(dmap, addr); > +} > + > +struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_tt_ops =3D { > + .kmap_local =3D i915_ttm_kmap_iter_tt_kmap_local > +}; > + > +struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_io_ops =3D { > + .kmap_local =3D i915_ttm_kmap_iter_iomap_kmap_local > +}; > + > +static void kunmap_local_dma_buf_map(struct dma_buf_map *map) > +{ > + if (map->is_iomem) > + io_mapping_unmap_local(map->vaddr_iomem); > + else > + kunmap_local(map->vaddr); > +} > + > +/** > + * i915_ttm_move_memcpy - Helper to perform a memcpy ttm move operation. > + * @bo: The struct ttm_buffer_object. > + * @new_mem: The struct ttm_resource we're moving to (copy destination). > + * @new_kmap: A struct i915_ttm_kmap_iter representing the destination r= esource. > + * @old_kmap: A struct i915_ttm_kmap_iter representing the source resour= ce. > + */ > +void i915_ttm_move_memcpy(struct ttm_buffer_object *bo, > + struct ttm_resource *new_mem, > + struct i915_ttm_kmap_iter *new_kmap, > + struct i915_ttm_kmap_iter *old_kmap) > +{ > + struct ttm_device *bdev =3D bo->bdev; > + struct ttm_resource_manager *man =3D ttm_manager_type(bdev, new_mem->me= m_type); > + struct ttm_tt *ttm =3D bo->ttm; > + struct ttm_resource *old_mem =3D &bo->mem; > + struct ttm_resource old_copy =3D *old_mem; > + struct ttm_resource_manager *old_man =3D ttm_manager_type(bdev, old_mem= ->mem_type); > + struct dma_buf_map old_map, new_map; > + pgoff_t i; > + > + /* For the page-based allocator we need sgtable iterators as well.*/ > + > + /* Single TTM move. NOP */ > + if (old_man->use_tt && man->use_tt) > + goto done; > + > + /* Don't move nonexistent data. Clear destination instead. */ > + if (old_man->use_tt && !man->use_tt && > + (ttm =3D=3D NULL || !ttm_tt_is_populated(ttm))) { > + if (ttm && !(ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)) > + goto done; > + > + for (i =3D 0; i < new_mem->num_pages; ++i) { > + new_kmap->ops->kmap_local(new_kmap, &new_map, i); > + memset_io(new_map.vaddr_iomem, 0, PAGE_SIZE); > + kunmap_local_dma_buf_map(&new_map); > + } > + goto done; > + } > + > + for (i =3D 0; i < new_mem->num_pages; ++i) { > + new_kmap->ops->kmap_local(new_kmap, &new_map, i); > + old_kmap->ops->kmap_local(old_kmap, &old_map, i); > + if (!old_map.is_iomem || > + !i915_memcpy_from_wc(new_map.vaddr, old_map.vaddr, PAGE_SIZE)) { > + if (!old_map.is_iomem) { > + dma_buf_map_memcpy_to(&new_map, old_map.vaddr, > + PAGE_SIZE); > + } else if (!new_map.is_iomem) { > + memcpy_fromio(new_map.vaddr, old_map.vaddr_iomem, > + PAGE_SIZE); > + } else { > + pgoff_t j; > + u32 __iomem *src =3D old_map.vaddr_iomem; > + u32 __iomem *dst =3D new_map.vaddr_iomem; > + > + for (j =3D 0; j < (PAGE_SIZE >> 2); ++j) > + iowrite32(ioread32(src++), dst++); > + } > + } > + kunmap_local_dma_buf_map(&old_map); > + kunmap_local_dma_buf_map(&new_map); > + } > + > +done: > + old_copy =3D *old_mem; > + > + ttm_bo_assign_mem(bo, new_mem); > + > + if (!man->use_tt) > + ttm_bo_tt_destroy(bo); > + > + ttm_resource_free(bo, &old_copy); > +} > diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h b/drivers/gp= u/drm/i915/gem/i915_gem_ttm_bo_util.h > new file mode 100644 > index 000000000000..82c92176718d > --- /dev/null > +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h > @@ -0,0 +1,141 @@ > +/* SPDX-License-Identifier: MIT */ > +/* > + * Copyright =C2=A9 2021 Intel Corporation > + */ > + > +/* > + * This files contains functionality that we might want to move into > + * ttm_bo_util.c if there is a common interest. > + */ > +#ifndef _I915_GEM_TTM_BO_UTIL_H_ > +#define _I915_GEM_TTM_BO_UTIL_H_ > + > +#include > +struct dma_buf_map; > +struct io_mapping; > +struct sg_table; > +struct scatterlist; > + > +struct ttm_tt; > +struct i915_ttm_kmap_iter; > + > +/** > + * struct i915_ttm_kmap_iter_ops - Ops structure for a struct > + * i915_ttm_kmap_iter. > + */ > +struct i915_ttm_kmap_iter_ops { > + /** > + * kmap_local - Map a PAGE_SIZE part of the resource using > + * kmap_local semantics. > + * @res_kmap: Pointer to the struct i915_ttm_kmap_iter representing > + * the resource. > + * @dmap: The struct dma_buf_map holding the virtual address after > + * the operation. > + * @i: The location within the resource to map. PAGE_SIZE granularity. > + */ > + void (*kmap_local)(struct i915_ttm_kmap_iter *res_kmap, > + struct dma_buf_map *dmap, pgoff_t i); > +}; > + > +/** > + * struct i915_ttm_kmap_iter - Iterator for kmap_local type operations o= n a > + * resource. > + * @ops: Pointer to the operations struct. > + * > + * This struct is intended to be embedded in a resource-specific special= ization > + * implementing operations for the resource. > + * > + * Nothing stops us from extending the operations to vmap, vmap_pfn etc, > + * replacing some or parts of the ttm_bo_util. cpu-map functionality. > + */ > +struct i915_ttm_kmap_iter { > + const struct i915_ttm_kmap_iter_ops *ops; > +}; > + > +/** > + * struct i915_ttm_kmap_iter_tt - Specialization for a tt (page) backed = struct > + * ttm_resource. > + * @base: Embedded struct i915_ttm_kmap_iter providing the usage interfa= ce > + * @tt: Cached struct ttm_tt. > + */ > +struct i915_ttm_kmap_iter_tt { > + struct i915_ttm_kmap_iter base; > + struct ttm_tt *tt; > +}; > + > +/** > + * struct i915_ttm_kmap_iter_iomap - Specialization for a struct io_mapp= ing + > + * struct sg_table backed struct ttm_resource. > + * @base: Embedded struct i915_ttm_kmap_iter providing the usage interfa= ce. > + * @iomap: struct io_mapping representing the underlying linear io_memor= y. > + * @st: sg_table into @iomap, representing the memory of the struct ttm_= resource. > + * @start: Offset that needs to be subtracted from @st to make > + * sg_dma_address(st->sgl) - @start =3D=3D 0 for @iomap start. > + * @cache: Scatterlist traversal cache for fast lookups. > + * @cache.sg: Pointer to the currently cached scatterlist segment. > + * @cache.i: First index of @sg. PAGE_SIZE granularity. > + * @cache.end: Last index + 1 of @sg. PAGE_SIZE granularity. > + * @cache.offs: First offset into @iomap of @sg. PAGE_SIZE granularity. > + */ > +struct i915_ttm_kmap_iter_iomap { > + struct i915_ttm_kmap_iter base; > + struct io_mapping *iomap; > + struct sg_table *st; > + resource_size_t start; > + struct { > + struct scatterlist *sg; > + pgoff_t i; > + pgoff_t end; > + pgoff_t offs; > + } cache; > +}; > + > +extern struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_tt_ops; > +extern struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_io_ops; > + > +/** > + * i915_ttm_kmap_iter_iomap_init - Initialize a struct i915_ttm_kmap_ite= r_iomap > + * @iter_io: The struct i915_ttm_kmap_iter_iomap to initialize. > + * @iomap: The struct io_mapping representing the underlying linear io_m= emory. > + * @st: sg_table into @iomap, representing the memory of the struct > + * ttm_resource. > + * @start: Offset that needs to be subtracted from @st to make > + * sg_dma_address(st->sgl) - @start =3D=3D 0 for @iomap start. > + * > + * Return: Pointer to the embedded struct i915_ttm_kmap_iter. > + */ > +static inline struct i915_ttm_kmap_iter * > +i915_ttm_kmap_iter_iomap_init(struct i915_ttm_kmap_iter_iomap *iter_io, > + struct io_mapping *iomap, > + struct sg_table *st, > + resource_size_t start) > +{ > + iter_io->base.ops =3D &i915_ttm_kmap_iter_io_ops; > + iter_io->iomap =3D iomap; > + iter_io->st =3D st; > + iter_io->start =3D start; > + memset(&iter_io->cache, 0, sizeof(iter_io->cache)); > + return &iter_io->base; > +} > + > +/** > + * ttm_kmap_iter_tt_init - Initialize a struct i915_ttm_kmap_iter_tt > + * @iter_tt: The struct i915_ttm_kmap_iter_tt to initialize. > + * @tt: Struct ttm_tt holding page pointers of the struct ttm_resource. > + * > + * Return: Pointer to the embedded struct i915_ttm_kmap_iter. > + */ > +static inline struct i915_ttm_kmap_iter * > +i915_ttm_kmap_iter_tt_init(struct i915_ttm_kmap_iter_tt *iter_tt, > + struct ttm_tt *tt) > +{ > + iter_tt->base.ops =3D &i915_ttm_kmap_iter_tt_ops; > + iter_tt->tt =3D tt; > + return &iter_tt->base; > +} Do there functions have a valid *performance* reason to be inline? I think that's pretty much the only valid reason. Having these inline forces i915_ttm_kmap_iter_*_ops extern, and they should really be static. Inline functions complicate header dependencies and leak the abstractions. BR, Jani. > + > +void i915_ttm_move_memcpy(struct ttm_buffer_object *bo, > + struct ttm_resource *new_mem, > + struct i915_ttm_kmap_iter *new_iter, > + struct i915_ttm_kmap_iter *old_iter); > +#endif > diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c > index ca1b098b6a56..4479c55aaa1d 100644 > --- a/drivers/gpu/drm/ttm/ttm_bo.c > +++ b/drivers/gpu/drm/ttm/ttm_bo.c > @@ -1221,3 +1221,4 @@ void ttm_bo_tt_destroy(struct ttm_buffer_object *bo) > ttm_tt_destroy(bo->bdev, bo->ttm); > bo->ttm =3D NULL; > } > +EXPORT_SYMBOL(ttm_bo_tt_destroy); --=20 Jani Nikula, Intel Open Source Graphics Center