From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v11 7/7] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Fri, 12 Aug 2016 16:30:19 +0300 Message-ID: <20160812133019.GB4329@intel.com> References: <1470945277-7973-1-git-send-email-cpaul@redhat.com> <1470945277-7973-8-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1470945277-7973-8-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Lyude Cc: David Airlie , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, Hans de Goede , dri-devel@lists.freedesktop.org, Daniel Vetter List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBBdWcgMTEsIDIwMTYgYXQgMDM6NTQ6MzZQTSAtMDQwMCwgTHl1ZGUgd3JvdGU6Cj4g Tm93IHRoYXQgd2UgY2FuIGhvb2sgaW50byB1cGRhdGVfY3J0Y3MgYW5kIGNvbnRyb2wgdGhlIG9y ZGVyIGluIHdoaWNoIHdlCj4gdXBkYXRlIENSVENzIGF0IGVhY2ggbW9kZXNldCwgd2UgY2FuIGZp bmlzaCB0aGUgZmluYWwgc3RlcCBvZiBmaXhpbmcKPiBTa3lsYWtlJ3Mgd2F0ZXJtYXJrIGhhbmRs aW5nIGJ5IHBlcmZvcm1pbmcgRERCIHVwZGF0ZXMgYXQgdGhlIHNhbWUgdGltZQo+IGFzIHBsYW5l IHVwZGF0ZXMgYW5kIHdhdGVybWFyayB1cGRhdGVzLgo+IAo+IFRoZSBmaXJzdCBtYWpvciBjaGFu Z2UgaW4gdGhpcyBwYXRjaCBpcyBza2xfdXBkYXRlX2NydGNzKCksIHdoaWNoCj4gaGFuZGxlcyBl bnN1cmluZyB0aGF0IHdlIG9yZGVyIGVhY2ggQ1JUQyB1cGRhdGUgaW4gb3VyIGF0b21pYyBjb21t aXRzCj4gcHJvcGVybHkgc28gdGhhdCB0aGV5IGhvbm9yIHRoZSBEREIgZmx1c2ggb3JkZXIuCj4g Cj4gVGhlIHNlY29uZCBtYWpvciBjaGFuZ2UgaW4gdGhpcyBwYXRjaCBpcyB0aGUgb3JkZXIgaW4g d2hpY2ggd2UgZmx1c2ggdGhlCj4gcGlwZXMuIFdoaWxlIHRoZSBwcmV2aW91cyBvcmRlciBtYXkg aGF2ZSB3b3JrZWQsIGl0IGNhbid0IGJlIHVzZWQgaW4KPiB0aGlzIGFwcHJvYWNoIHNpbmNlIGl0 IG5vIGxvbmdlciB3aWxsIGRvIHRoZSByaWdodCB0aGluZy4gRm9yIGV4YW1wbGUsCj4gdXNpbmcg dGhlIG9sZCBkZGIgZmx1c2ggb3JkZXI6Cj4gCj4gV2UgaGF2ZSBwaXBlcyBBLCBCLCBhbmQgQyBl bmFibGVkLCBhbmQgd2UncmUgZGlzYWJsaW5nIEMuIEluaXRpYWwgZGRiCj4gYWxsb2NhdGlvbiBs b29rcyBsaWtlIHRoaXM6Cj4gCj4gfCAgIEEgICB8ICAgQiAgIHx4eHh4eHh4fAo+IAo+IFNpbmNl IHdlJ3JlIHBlcmZvcm1pbmcgdGhlIGRkYiB1cGRhdGVzIGFmdGVyIHBlcmZvcm1pbmcgYW55IENS VEMKPiBkaXNhYmxlbWVudHMgaW4gaW50ZWxfYXRvbWljX2NvbW1pdF90YWlsKCksIHRoZSBzcGFj ZSB0byB0aGUgcmlnaHQgb2YKPiBwaXBlIEIgaXMgdW5hbGxvY2F0ZWQuCj4gCj4gMS4gRmx1c2gg cGlwZXMgd2l0aCBuZXcgYWxsb2NhdGlvbiBjb250YWluZWQgaW50byBvbGQgc3BhY2UuIE5vbmUK PiAgICBhcHBseSwgc28gd2Ugc2tpcCB0aGlzCj4gMi4gRmx1c2ggcGlwZXMgaGF2aW5nIHRoZWly IGFsbG9jYXRpb24gcmVkdWNlZCwgYnV0IG92ZXJsYXBwaW5nIHdpdGggYQo+ICAgIHByZXZpb3Vz IGFsbG9jYXRpb24uIE5vbmUgYXBwbHksIHNvIHdlIGFsc28gc2tpcCB0aGlzCj4gMy4gRmx1c2gg cGlwZXMgdGhhdCBnb3QgbW9yZSBzcGFjZSBhbGxvY2F0ZWQuIFRoaXMgYXBwbGllcyB0byBBIGFu ZCBCLAo+ICAgIGdpdmluZyB1cyB0aGUgZm9sbG93aW5nIHVwZGF0ZSBvcmRlcjogQSwgQgo+IAo+ IFRoaXMgaXMgd3JvbmcsIHNpbmNlIHVwZGF0aW5nIHBpcGUgQSBmaXJzdCB3aWxsIGNhdXNlIGl0 IHRvIG92ZXJsYXAgd2l0aAo+IEIgYW5kIHBvdGVudGlhbGx5IGJ1cnN0IGludG8gZmxhbWVzLiBP dXIgbmV3IG9yZGVyIChzZWUgdGhlIGNvZGUKPiBjb21tZW50cyBmb3IgZGV0YWlscykgd291bGQg dXBkYXRlIHRoZSBwaXBlcyBpbiB0aGUgcHJvcGVyIG9yZGVyOiBCLCBBLgo+IAo+IEFzIHdlbGws IHdlIGNhbGN1bGF0ZSB0aGUgb3JkZXIgZm9yIGVhY2ggRERCIHVwZGF0ZSBkdXJpbmcgdGhlIGNo ZWNrCj4gcGhhc2UsIGFuZCByZWZlcmVuY2UgaXQgbGF0ZXIgaW4gdGhlIGNvbW1pdCBwaGFzZSB3 aGVuIHdlIGhpdAo+IHNrbF91cGRhdGVfY3J0Y3MoKS4KPiAKPiBUaGlzIGxvbmcgb3ZlcmR1ZSBw YXRjaCBmaXhlcyB0aGUgcmVzdCBvZiB0aGUgdW5kZXJydW5zIG9uIFNreWxha2UuCj4gCj4gQ2hh bmdlcyBzaW5jZSB2MToKPiAgLSBBZGQgc2tsX2RkYl9lbnRyeV93cml0ZSgpIGZvciBjdXJzb3Ig aW50byBza2xfd3JpdGVfY3Vyc29yX3dtKCkKPiBDaGFuZ2VzIHNpbmNlIHYyOgo+ICAtIFVzZSB0 aGUgbWV0aG9kIGZvciB1cGRhdGluZyBDUlRDcyB0aGF0IFZpbGxlIHN1Z2dlc3RlZAo+ICAtIElu IHNrbF91cGRhdGVfd20oKSwgb25seSBjb3B5IHRoZSB3YXRlcm1hcmtzIGZvciB0aGUgY3J0YyB0 aGF0IHdhcwo+ICAgIHBhc3NlZCB0byB1cwo+IENoYW5nZXMgc2luY2UgdjM6Cj4gIC0gU21hbGwg Y29tbWVudCBmaXggaW4gc2tsX2RkYl9hbGxvY2F0aW9uX292ZXJsYXBzKCkKPiAKPiBGaXhlczog MGU4ZmI3YmE3Y2E1ICgiZHJtL2k5MTUvc2tsOiBGbHVzaCB0aGUgV00gY29uZmlndXJhdGlvbiIp Cj4gRml4ZXM6IDgyMTFiZDViZGY1ZSAoImRybS9pOTE1L3NrbDogUHJvZ3JhbSB0aGUgRERCIGFs bG9jYXRpb24iKQo+IFtvbWl0dGluZyBDQyBmb3Igc3RhYmxlLCBzaW5jZSB0aGlzIHBhdGNoIHdp bGwgbmVlZCB0byBiZSBjaGFuZ2VkIGZvcgo+IHN1Y2ggYmFja3BvcnRzIGZpcnN0XQo+IAo+IFRl c3RjYXNlOiBrbXNfY3Vyc29yX2xlZ2FjeQo+IFNpZ25lZC1vZmYtYnk6IEx5dWRlIDxjcGF1bEBy ZWRoYXQuY29tPgo+IFJldmlld2VkLWJ5OiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5r aG9yc3RAbGludXguaW50ZWwuY29tPgo+IENjOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmph bGFAbGludXguaW50ZWwuY29tPgo+IENjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGlu dGVsLmNvbT4KPiBDYzogUmFkaGFrcmlzaG5hIFNyaXBhZGEgPHJhZGhha3Jpc2huYS5zcmlwYWRh QGludGVsLmNvbT4KPiBDYzogSGFucyBkZSBHb2VkZSA8aGRlZ29lZGVAcmVkaGF0LmNvbT4KPiBD YzogTWF0dCBSb3BlciA8bWF0dGhldy5kLnJvcGVyQGludGVsLmNvbT4KPiAtLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIHwgMTAwICsrKysrKysrKysrKysrKy0tCj4g IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oICAgICB8ICAgNyArKwo+ICBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jICAgICAgfCAyMDcgKysrKysrKysrLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KPiAgMyBmaWxlcyBjaGFuZ2VkLCAxNDQgaW5zZXJ0aW9ucygrKSwgMTcw IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiBpbmRl eCA2MWE0NWYxLi42OGZkYmYwIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rpc3BsYXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXku Ywo+IEBAIC0xMzM0OCwxNiArMTMzNDgsMjMgQEAgc3RhdGljIHZvaWQgdmVyaWZ5X3dtX3N0YXRl KHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKPiAgCQkJICBod19lbnRyeS0+c3RhcnQsIGh3X2VudHJ5 LT5lbmQpOwo+ICAJfQo+ICAKPiAtCS8qIGN1cnNvciAqLwo+IC0JaHdfZW50cnkgPSAmaHdfZGRi LnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gLQlzd19lbnRyeSA9ICZzd19kZGItPnBsYW5l W3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gLQo+IC0JaWYgKCFza2xfZGRiX2VudHJ5X2VxdWFsKGh3 X2VudHJ5LCBzd19lbnRyeSkpIHsKPiAtCQlEUk1fRVJST1IoIm1pc21hdGNoIGluIEREQiBzdGF0 ZSBwaXBlICVjIGN1cnNvciAiCj4gLQkJCSAgIihleHBlY3RlZCAoJXUsJXUpLCBmb3VuZCAoJXUs JXUpKVxuIiwKPiAtCQkJICBwaXBlX25hbWUocGlwZSksCj4gLQkJCSAgc3dfZW50cnktPnN0YXJ0 LCBzd19lbnRyeS0+ZW5kLAo+IC0JCQkgIGh3X2VudHJ5LT5zdGFydCwgaHdfZW50cnktPmVuZCk7 Cj4gKwkvKgo+ICsJICogY3Vyc29yCj4gKwkgKiBJZiB0aGUgY3Vyc29yIHBsYW5lIGlzbid0IGFj dGl2ZSwgd2UgbWF5IG5vdCBoYXZlIHVwZGF0ZWQgaXQncyBkZGIKPiArCSAqIGFsbG9jYXRpb24u IEluIHRoYXQgY2FzZSBzaW5jZSB0aGUgZGRiIGFsbG9jYXRpb24gd2lsbCBiZSB1cGRhdGVkCj4g KwkgKiBvbmNlIHRoZSBwbGFuZSBiZWNvbWVzIHZpc2libGUsIHdlIGNhbiBza2lwIHRoaXMgY2hl Y2sKPiArCSAqLwo+ICsJaWYgKGludGVsX2NydGMtPmN1cnNvcl9hZGRyKSB7Cj4gKwkJaHdfZW50 cnkgPSAmaHdfZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gKwkJc3dfZW50cnkgPSAm c3dfZGRiLT5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdOwo+ICsKPiArCQlpZiAoIXNrbF9kZGJf ZW50cnlfZXF1YWwoaHdfZW50cnksIHN3X2VudHJ5KSkgewo+ICsJCQlEUk1fRVJST1IoIm1pc21h dGNoIGluIEREQiBzdGF0ZSBwaXBlICVjIGN1cnNvciAiCj4gKwkJCQkgICIoZXhwZWN0ZWQgKCV1 LCV1KSwgZm91bmQgKCV1LCV1KSlcbiIsCj4gKwkJCQkgIHBpcGVfbmFtZShwaXBlKSwKPiArCQkJ CSAgc3dfZW50cnktPnN0YXJ0LCBzd19lbnRyeS0+ZW5kLAo+ICsJCQkJICBod19lbnRyeS0+c3Rh cnQsIGh3X2VudHJ5LT5lbmQpOwo+ICsJCX0KPiAgCX0KPiAgfQo+ICAKPiBAQCAtMTQxMDksNiAr MTQxMTYsNzIgQEAgc3RhdGljIHZvaWQgaW50ZWxfdXBkYXRlX2NydGNzKHN0cnVjdCBkcm1fYXRv bWljX3N0YXRlICpzdGF0ZSwKPiAgCX0KPiAgfQo+ICAKPiArc3RhdGljIHZvaWQgc2tsX3VwZGF0 ZV9jcnRjcyhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCj4gKwkJCSAgICAgdW5zaWdu ZWQgaW50ICpjcnRjX3ZibGFua19tYXNrKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 ID0gc3RhdGUtPmRldjsKPiArCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRv X2k5MTUoZGV2KTsKPiArCXN0cnVjdCBpbnRlbF9hdG9taWNfc3RhdGUgKmludGVsX3N0YXRlID0g dG9faW50ZWxfYXRvbWljX3N0YXRlKHN0YXRlKTsKPiArCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsK PiArCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqb2xkX2NydGNfc3RhdGU7Cj4gKwlzdHJ1Y3Qgc2ts X2RkYl9hbGxvY2F0aW9uICpuZXdfZGRiID0gJmludGVsX3N0YXRlLT53bV9yZXN1bHRzLmRkYjsK PiArCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gY3VyX2RkYjsKPiArCWJvb2wgcHJvZ3Jlc3M7 Cj4gKwlib29sIHJlYWxsb2NhdGVkW0k5MTVfTUFYX1BJUEVTXSA9IHt9Owo+ICsJZW51bSBwaXBl IHBpcGU7Cj4gKwlpbnQgd2FpdF92YmxfcGlwZXMsIGk7Cj4gKwo+ICsJLyoKPiArCSAqIFdoZW5l dmVyIHRoZSBudW1iZXIgb2YgYWN0aXZlIHBpcGVzIGNoYW5nZSwgc28gZG9lcyB0aGUgRERCCj4g KwkgKiBhbGxvY2F0aW9uLiBEREIgYWxsb2NhdGlvbnMgb24gcGlwZXMgY2Fubm90IGV2ZXIgb3Zl cmxhcCB3aXRoCj4gKwkgKiBlYWNob3RoZXIgYXQgYW55IHBvaW50IGluIHRpbWUsIHNvIHdlIG5l ZWQgdG8gY2hhbmdlIHRoZSBvcmRlciB3ZQo+ICsJICogdXBkYXRlIHRoZSBwaXBlcyBzbyB0aGF0 IHdlIGVuc3VyZSB0aGV5IG5ldmVyIG92ZXJsYXAgaW5iZXR3ZWVuIEREQgo+ICsJICogdXBkYXRl cy4KPiArCSAqLwo+ICsJZG8gewo+ICsJCXByb2dyZXNzID0gZmFsc2U7Cj4gKwkJd2FpdF92Ymxf cGlwZXMgPSAwOwo+ICsJCWN1cl9kZGIgPSBkZXZfcHJpdi0+d20uc2tsX2h3LmRkYjsKCkkgZ3Vl c3Mgd291bGQgY291bGQgZG8gdGhlIGxvb3AgdHdpY2UgdG8gYXZvaWQgdGhlIGNvcHkuIEJ1dCBu b3Qgc3VyZQp0aGF0J3MgcmVhbGx5IGFueSBtb3JlIGVmZmljaWVudC4KCj4gKwo+ICsJCWZvcl9l YWNoX2NydGNfaW5fc3RhdGUoc3RhdGUsIGNydGMsIG9sZF9jcnRjX3N0YXRlLCBpKSB7Cj4gKwkJ CXN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjID0gdG9faW50ZWxfY3J0YyhjcnRjKTsKPiAr CQkJcGlwZSA9IGludGVsX2NydGMtPnBpcGU7Cj4gKwo+ICsJCQlpZiAoIWludGVsX2NydGMtPmFj dGl2ZSB8fCBuZWVkc19tb2Rlc2V0KGNydGMtPnN0YXRlKSkKPiArCQkJCWNvbnRpbnVlOwoKY3J0 Yy0+c3RhdGUtPmFjdGl2ZT8KCj4gKwkJCWlmIChza2xfZGRiX2FsbG9jYXRpb25fZXF1YWxzKCZj dXJfZGRiLCBuZXdfZGRiLCBwaXBlKSkKPiArCQkJCWNvbnRpbnVlOwo+ICsJCQlpZiAoc2tsX2Rk Yl9hbGxvY2F0aW9uX292ZXJsYXBzKHN0YXRlLCAmY3VyX2RkYiwKPiArCQkJCQkJCW5ld19kZGIs IHBpcGUpKQo+ICsJCQkJY29udGludWU7Cj4gKwo+ICsJCQlpbnRlbF91cGRhdGVfY3J0YyhjcnRj LCBzdGF0ZSwgb2xkX2NydGNfc3RhdGUsCj4gKwkJCQkJICBjcnRjX3ZibGFua19tYXNrKTsKCldo YXQgZGlkIHRoZSBjYWxsZXIgd2FudCB3aXRoIHRoZSB2YmxhbmtfbWFzaz8gRG8gbW9yZSB2Ymxh bmsgd2FpdHM/ClNob3VsZG4ndCBiZSBuZWVkZWQgSSB0aGluayBzaW5jZSB3ZSB3YWl0IGhlcmUs IG5vPwoKPiArCj4gKwkJCXdhaXRfdmJsX3BpcGVzIHw9IGRybV9jcnRjX21hc2soY3J0Yyk7Cj4g KwkJCXJlYWxsb2NhdGVkW3BpcGVdID0gdHJ1ZTsKPiArCQkJcHJvZ3Jlc3MgPSB0cnVlOwoKSSBn dWVzcyB3ZSBjb3VsZCB0aHJvdyB0aGlzIG91dCBhY3R1bGx5LiB3YWl0X3ZibF9waXBlcyE9MCBz aG91bGQgbWVhbgp0aGUgc2FtZSB0aGluZy4KCj4gKwkJfQo+ICsKPiArCQkvKiBXYWl0IGZvciBl YWNoIHBpcGUncyBuZXcgYWxsb2NhdGlvbiB0byB0YWtlIGVmZmVjdCAqLwo+ICsJCWludGVsX2F0 b21pY193YWl0X2Zvcl92YmxhbmtzKGRldiwgZGV2X3ByaXYsIHdhaXRfdmJsX3BpcGVzKTsKPiAr CX0gd2hpbGUgKHByb2dyZXNzKTsKPiArCj4gKwkvKgo+ICsJICogTm93IHRoYXQgd2UndmUgaGFu ZGxlZCBhbnkgZGRiIHJlYWxsb2NhdGlvbnMsIHdlIGNhbiBnbyBhaGVhZCBhbmQKPiArCSAqIGVu YWJsZSBhbnkgbmV3IHBpcGVzLgo+ICsJICovCj4gKwlmb3JfZWFjaF9jcnRjX2luX3N0YXRlKHN0 YXRlLCBjcnRjLCBvbGRfY3J0Y19zdGF0ZSwgaSkgewo+ICsJCXBpcGUgPSB0b19pbnRlbF9jcnRj KGNydGMpLT5waXBlOwo+ICsKPiArCQlpZiAocmVhbGxvY2F0ZWRbcGlwZV0gfHwgIWNydGMtPnN0 YXRlLT5hY3RpdmUpCj4gKwkJCWNvbnRpbnVlOwoKRG8gd2UgbmVlZCB0aGlzIHJlYWxsb2NhdGVk W10gZmxhZz8gSXNuJ3QgdGhpcyB0aGUgc2FtZSBhcwonYWN0aXZlICYmIG5lZWRzX21vZGVzZXQn ID8KCj4gKwo+ICsJCWludGVsX3VwZGF0ZV9jcnRjKGNydGMsIHN0YXRlLCBvbGRfY3J0Y19zdGF0 ZSwKPiArCQkJCSAgY3J0Y192YmxhbmtfbWFzayk7Cj4gKwl9Cj4gK30KPiArCj4gIHN0YXRpYyB2 b2lkIGludGVsX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3Rh dGUpCj4gIHsKPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBzdGF0ZS0+ZGV2Owo+IEBAIC0x NTczOCw4ICsxNTgxMSw2IEBAIHZvaWQgaW50ZWxfaW5pdF9kaXNwbGF5X2hvb2tzKHN0cnVjdCBk cm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKPiAgCQlkZXZfcHJpdi0+ZGlzcGxheS5jcnRjX2Rp c2FibGUgPSBpOXh4X2NydGNfZGlzYWJsZTsKPiAgCX0KPiAgCj4gLQlkZXZfcHJpdi0+ZGlzcGxh eS51cGRhdGVfY3J0Y3MgPSBpbnRlbF91cGRhdGVfY3J0Y3M7Cj4gLQo+ICAJLyogUmV0dXJucyB0 aGUgY29yZSBkaXNwbGF5IGNsb2NrIHNwZWVkICovCj4gIAlpZiAoSVNfU0tZTEFLRShkZXZfcHJp dikgfHwgSVNfS0FCWUxBS0UoZGV2X3ByaXYpKQo+ICAJCWRldl9wcml2LT5kaXNwbGF5LmdldF9k aXNwbGF5X2Nsb2NrX3NwZWVkID0KPiBAQCAtMTU4MjksNiArMTU5MDAsMTEgQEAgdm9pZCBpbnRl bF9pbml0X2Rpc3BsYXlfaG9va3Moc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQo+ ICAJCQlza2xfbW9kZXNldF9jYWxjX2NkY2xrOwo+ICAJfQo+ICAKPiArCWlmIChkZXZfcHJpdi0+ aW5mby5nZW4gPj0gOSkKPiArCQlkZXZfcHJpdi0+ZGlzcGxheS51cGRhdGVfY3J0Y3MgPSBza2xf dXBkYXRlX2NydGNzOwo+ICsJZWxzZQo+ICsJCWRldl9wcml2LT5kaXNwbGF5LnVwZGF0ZV9jcnRj cyA9IGludGVsX3VwZGF0ZV9jcnRjczsKPiArCj4gIAlzd2l0Y2ggKElOVEVMX0lORk8oZGV2X3By aXYpLT5nZW4pIHsKPiAgCWNhc2UgMjoKPiAgCQlkZXZfcHJpdi0+ZGlzcGxheS5xdWV1ZV9mbGlw ID0gaW50ZWxfZ2VuMl9xdWV1ZV9mbGlwOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gaW5k ZXggODgwODhjMy4uOWY5ZmU2OSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kcnYuaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gQEAg LTE3MjMsNiArMTcyMywxMyBAQCB2b2lkIHNrbF9kZGJfZ2V0X2h3X3N0YXRlKHN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiAgCQkJICBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9u ICpkZGIgLyogb3V0ICovKTsKPiAgaW50IHNrbF9lbmFibGVfc2FndihzdHJ1Y3QgZHJtX2k5MTVf cHJpdmF0ZSAqZGV2X3ByaXYpOwo+ICBpbnQgc2tsX2Rpc2FibGVfc2FndihzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOwo+ICtib29sIHNrbF9kZGJfYWxsb2NhdGlvbl9lcXVhbHMo Y29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqb2xkLAo+ICsJCQkgICAgICAgY29uc3Qg c3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqbmV3LAo+ICsJCQkgICAgICAgZW51bSBwaXBlIHBp cGUpOwo+ICtib29sIHNrbF9kZGJfYWxsb2NhdGlvbl9vdmVybGFwcyhzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUsCj4gKwkJCQkgY29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAq b2xkLAo+ICsJCQkJIGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ldywKPiArCQkJ CSBlbnVtIHBpcGUgcGlwZSk7Cj4gIHZvaWQgc2tsX3dyaXRlX2N1cnNvcl93bShzdHJ1Y3QgaW50 ZWxfY3J0YyAqaW50ZWxfY3J0YywKPiAgCQkJIGNvbnN0IHN0cnVjdCBza2xfd21fdmFsdWVzICp3 bSk7Cj4gIHZvaWQgc2tsX3dyaXRlX3BsYW5lX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9j cnRjLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+IGluZGV4IGYyZTAwNzEuLjZmZTllNTcgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKPiBAQCAtMzc5NCw2ICszNzk0LDExIEBAIHZvaWQg c2tsX3dyaXRlX3BsYW5lX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjLAo+ICAJCQkg ICB3bS0+cGxhbmVbcGlwZV1bcGxhbmVdW2xldmVsXSk7Cj4gIAl9Cj4gIAlJOTE1X1dSSVRFKFBM QU5FX1dNX1RSQU5TKHBpcGUsIHBsYW5lKSwgd20tPnBsYW5lX3RyYW5zW3BpcGVdW3BsYW5lXSk7 Cj4gKwo+ICsJc2tsX2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgUExBTkVfQlVGX0NGRyhwaXBl LCBwbGFuZSksCj4gKwkJCSAgICAmd20tPmRkYi5wbGFuZVtwaXBlXVtwbGFuZV0pOwo+ICsJc2ts X2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgUExBTkVfTlYxMl9CVUZfQ0ZHKHBpcGUsIHBsYW5l KSwKPiArCQkJICAgICZ3bS0+ZGRiLnlfcGxhbmVbcGlwZV1bcGxhbmVdKTsKPiAgfQo+ICAKPiAg dm9pZCBza2xfd3JpdGVfY3Vyc29yX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjLAo+ IEBAIC0zODEwLDE3MCArMzgxNSw0OSBAQCB2b2lkIHNrbF93cml0ZV9jdXJzb3Jfd20oc3RydWN0 IGludGVsX2NydGMgKmludGVsX2NydGMsCj4gIAkJCSAgIHdtLT5wbGFuZVtwaXBlXVtQTEFORV9D VVJTT1JdW2xldmVsXSk7Cj4gIAl9Cj4gIAlJOTE1X1dSSVRFKENVUl9XTV9UUkFOUyhwaXBlKSwg d20tPnBsYW5lX3RyYW5zW3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+IC19Cj4gLQo+IC1zdGF0aWMg dm9pZCBza2xfd3JpdGVfd21fdmFsdWVzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp diwKPiAtCQkJCWNvbnN0IHN0cnVjdCBza2xfd21fdmFsdWVzICpuZXcpCj4gLXsKPiAtCXN0cnVj dCBkcm1fZGV2aWNlICpkZXYgPSAmZGV2X3ByaXYtPmRybTsKPiAtCXN0cnVjdCBpbnRlbF9jcnRj ICpjcnRjOwo+ICAKPiAtCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Cj4gLQkJaW50 IGk7Cj4gLQkJZW51bSBwaXBlIHBpcGUgPSBjcnRjLT5waXBlOwo+IC0KPiAtCQlpZiAoKG5ldy0+ ZGlydHlfcGlwZXMgJiBkcm1fY3J0Y19tYXNrKCZjcnRjLT5iYXNlKSkgPT0gMCkKPiAtCQkJY29u dGludWU7Cj4gLQkJaWYgKCFjcnRjLT5hY3RpdmUpCj4gLQkJCWNvbnRpbnVlOwo+IC0KPiAtCQlm b3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3BsYW5lcyhjcnRjKTsgaSsrKSB7Cj4gLQkJCXNrbF9k ZGJfZW50cnlfd3JpdGUoZGV2X3ByaXYsCj4gLQkJCQkJICAgIFBMQU5FX0JVRl9DRkcocGlwZSwg aSksCj4gLQkJCQkJICAgICZuZXctPmRkYi5wbGFuZVtwaXBlXVtpXSk7Cj4gLQkJCXNrbF9kZGJf ZW50cnlfd3JpdGUoZGV2X3ByaXYsCj4gLQkJCQkJICAgIFBMQU5FX05WMTJfQlVGX0NGRyhwaXBl LCBpKSwKPiAtCQkJCQkgICAgJm5ldy0+ZGRiLnlfcGxhbmVbcGlwZV1baV0pOwo+IC0JCX0KPiAt Cj4gLQkJc2tsX2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgQ1VSX0JVRl9DRkcocGlwZSksCj4g LQkJCQkgICAgJm5ldy0+ZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+IC0JfQo+ICsJ c2tsX2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgQ1VSX0JVRl9DRkcocGlwZSksCj4gKwkJCSAg ICAmd20tPmRkYi5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdKTsKPiAgfQo+ICAKPiAtLyoKPiAt ICogV2hlbiBzZXR0aW5nIHVwIGEgbmV3IEREQiBhbGxvY2F0aW9uIGFycmFuZ2VtZW50LCB3ZSBu ZWVkIHRvIGNvcnJlY3RseQo+IC0gKiBzZXF1ZW5jZSB0aGUgdGltZXMgYXQgd2hpY2ggdGhlIG5l dyBhbGxvY2F0aW9ucyBmb3IgdGhlIHBpcGVzIGFyZSB0YWtlbiBpbnRvCj4gLSAqIGFjY291bnQg b3Igd2UnbGwgaGF2ZSBwaXBlcyBmZXRjaGluZyBmcm9tIHNwYWNlIHByZXZpb3VzbHkgYWxsb2Nh dGVkIHRvCj4gLSAqIGFub3RoZXIgcGlwZS4KPiAtICoKPiAtICogUm91Z2hseSB0aGUgc2VxdWVu Y2UgbG9va3MgbGlrZToKPiAtICogIDEuIHJlLWFsbG9jYXRlIHRoZSBwaXBlKHMpIHdpdGggdGhl IGFsbG9jYXRpb24gYmVpbmcgcmVkdWNlZCBhbmQgbm90Cj4gLSAqICAgICBvdmVybGFwcGluZyB3 aXRoIGEgcHJldmlvdXMgbGlnaHQtdXAgcGlwZSAoYW5vdGhlciB3YXkgdG8gcHV0IGl0IGlzOgo+ IC0gKiAgICAgcGlwZXMgd2l0aCB0aGVpciBuZXcgYWxsb2NhdGlvbiBzdHJpY2tseSBpbmNsdWRl ZCBpbnRvIHRoZWlyIG9sZCBvbmVzKS4KPiAtICogIDIuIHJlLWFsbG9jYXRlIHRoZSBvdGhlciBw aXBlcyB0aGF0IGdldCB0aGVpciBhbGxvY2F0aW9uIHJlZHVjZWQKPiAtICogIDMuIGFsbG9jYXRl IHRoZSBwaXBlcyBoYXZpbmcgdGhlaXIgYWxsb2NhdGlvbiBpbmNyZWFzZWQKPiAtICoKPiAtICog U3RlcHMgMS4gYW5kIDIuIGFyZSBoZXJlIHRvIHRha2UgY2FyZSBvZiB0aGUgZm9sbG93aW5nIGNh c2U6Cj4gLSAqIC0gSW5pdGlhbGx5IEREQiBsb29rcyBsaWtlIHRoaXM6Cj4gLSAqICAgICB8ICAg QiAgICB8ICAgQyAgICB8Cj4gLSAqIC0gZW5hYmxlIHBpcGUgQS4KPiAtICogLSBwaXBlIEIgaGFz IGEgcmVkdWNlZCBEREIgYWxsb2NhdGlvbiB0aGF0IG92ZXJsYXBzIHdpdGggdGhlIG9sZCBwaXBl IEMKPiAtICogICBhbGxvY2F0aW9uCj4gLSAqICAgICB8ICBBICB8ICBCICB8ICBDICB8Cj4gLSAq Cj4gLSAqIFdlIG5lZWQgdG8gc2VxdWVuY2UgdGhlIHJlLWFsbG9jYXRpb246IEMsIEIsIEEgKGFu ZCBub3QgQiwgQywgQSkuCj4gLSAqLwo+IC0KPiAtc3RhdGljIHZvaWQKPiAtc2tsX3dtX2ZsdXNo X3BpcGUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LCBlbnVtIHBpcGUgcGlwZSwg aW50IHBhc3MpCj4gLXsKPiAtCWludCBwbGFuZTsKPiAtCj4gLQlEUk1fREVCVUdfS01TKCJmbHVz aCBwaXBlICVjIChwYXNzICVkKVxuIiwgcGlwZV9uYW1lKHBpcGUpLCBwYXNzKTsKPiAtCj4gLQlm b3JfZWFjaF9wbGFuZShkZXZfcHJpdiwgcGlwZSwgcGxhbmUpIHsKPiAtCQlJOTE1X1dSSVRFKFBM QU5FX1NVUkYocGlwZSwgcGxhbmUpLAo+IC0JCQkgICBJOTE1X1JFQUQoUExBTkVfU1VSRihwaXBl LCBwbGFuZSkpKTsKPiAtCX0KPiAtCUk5MTVfV1JJVEUoQ1VSQkFTRShwaXBlKSwgSTkxNV9SRUFE KENVUkJBU0UocGlwZSkpKTsKPiAtfQo+IC0KPiAtc3RhdGljIGJvb2wKPiAtc2tsX2RkYl9hbGxv Y2F0aW9uX2luY2x1ZGVkKGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm9sZCwKPiAt CQkJICAgIGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ldywKPiAtCQkJICAgIGVu dW0gcGlwZSBwaXBlKQo+ICtib29sIHNrbF9kZGJfYWxsb2NhdGlvbl9lcXVhbHMoY29uc3Qgc3Ry dWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqb2xkLAo+ICsJCQkgICAgICAgY29uc3Qgc3RydWN0IHNr bF9kZGJfYWxsb2NhdGlvbiAqbmV3LAo+ICsJCQkgICAgICAgZW51bSBwaXBlIHBpcGUpCj4gIHsK PiAtCXVpbnQxNl90IG9sZF9zaXplLCBuZXdfc2l6ZTsKPiAtCj4gLQlvbGRfc2l6ZSA9IHNrbF9k ZGJfZW50cnlfc2l6ZSgmb2xkLT5waXBlW3BpcGVdKTsKPiAtCW5ld19zaXplID0gc2tsX2RkYl9l bnRyeV9zaXplKCZuZXctPnBpcGVbcGlwZV0pOwo+IC0KPiAtCXJldHVybiBvbGRfc2l6ZSAhPSBu ZXdfc2l6ZSAmJgo+IC0JICAgICAgIG5ldy0+cGlwZVtwaXBlXS5zdGFydCA+PSBvbGQtPnBpcGVb cGlwZV0uc3RhcnQgJiYKPiAtCSAgICAgICBuZXctPnBpcGVbcGlwZV0uZW5kIDw9IG9sZC0+cGlw ZVtwaXBlXS5lbmQ7Cj4gKwlyZXR1cm4gbmV3LT5waXBlW3BpcGVdLnN0YXJ0ID09IG9sZC0+cGlw ZVtwaXBlXS5zdGFydCAmJgo+ICsJICAgICAgIG5ldy0+cGlwZVtwaXBlXS5lbmQgPT0gb2xkLT5w aXBlW3BpcGVdLmVuZDsKPiAgfQo+ICAKPiAtc3RhdGljIHZvaWQgc2tsX2ZsdXNoX3dtX3ZhbHVl cyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCj4gLQkJCQlzdHJ1Y3Qgc2tsX3dt X3ZhbHVlcyAqbmV3X3ZhbHVlcykKPiArYm9vbCBza2xfZGRiX2FsbG9jYXRpb25fb3ZlcmxhcHMo c3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+ICsJCQkJIGNvbnN0IHN0cnVjdCBza2xf ZGRiX2FsbG9jYXRpb24gKm9sZCwKPiArCQkJCSBjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0 aW9uICpuZXcsCj4gKwkJCQkgZW51bSBwaXBlIHBpcGUpCj4gIHsKPiAtCXN0cnVjdCBkcm1fZGV2 aWNlICpkZXYgPSAmZGV2X3ByaXYtPmRybTsKPiAtCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24g KmN1cl9kZGIsICpuZXdfZGRiOwo+IC0JYm9vbCByZWFsbG9jYXRlZFtJOTE1X01BWF9QSVBFU10g PSB7fTsKPiAtCXN0cnVjdCBpbnRlbF9jcnRjICpjcnRjOwo+IC0JZW51bSBwaXBlIHBpcGU7Cj4g LQo+IC0JbmV3X2RkYiA9ICZuZXdfdmFsdWVzLT5kZGI7Cj4gLQljdXJfZGRiID0gJmRldl9wcml2 LT53bS5za2xfaHcuZGRiOwo+IC0KPiAtCS8qCj4gLQkgKiBGaXJzdCBwYXNzOiBmbHVzaCB0aGUg cGlwZXMgd2l0aCB0aGUgbmV3IGFsbG9jYXRpb24gY29udGFpbmVkIGludG8KPiAtCSAqIHRoZSBv bGQgc3BhY2UuCj4gLQkgKgo+IC0JICogV2UnbGwgd2FpdCBmb3IgdGhlIHZibGFuayBvbiB0aG9z ZSBwaXBlcyB0byBlbnN1cmUgd2UgY2FuIHNhZmVseQo+IC0JICogcmUtYWxsb2NhdGUgdGhlIGZy ZWVkIHNwYWNlIHdpdGhvdXQgdGhpcyBwaXBlIGZldGNoaW5nIGZyb20gaXQuCj4gLQkgKi8KPiAt CWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Cj4gLQkJaWYgKCFjcnRjLT5hY3RpdmUp Cj4gLQkJCWNvbnRpbnVlOwo+IC0KPiAtCQlwaXBlID0gY3J0Yy0+cGlwZTsKPiAtCj4gLQkJaWYg KCFza2xfZGRiX2FsbG9jYXRpb25faW5jbHVkZWQoY3VyX2RkYiwgbmV3X2RkYiwgcGlwZSkpCj4g LQkJCWNvbnRpbnVlOwo+IC0KPiAtCQlza2xfd21fZmx1c2hfcGlwZShkZXZfcHJpdiwgcGlwZSwg MSk7Cj4gLQkJaW50ZWxfd2FpdF9mb3JfdmJsYW5rKGRldiwgcGlwZSk7Cj4gLQo+IC0JCXJlYWxs b2NhdGVkW3BpcGVdID0gdHJ1ZTsKPiAtCX0KPiAtCj4gLQo+IC0JLyoKPiAtCSAqIFNlY29uZCBw YXNzOiBmbHVzaCB0aGUgcGlwZXMgdGhhdCBhcmUgaGF2aW5nIHRoZWlyIGFsbG9jYXRpb24KPiAt CSAqIHJlZHVjZWQsIGJ1dCBvdmVybGFwcGluZyB3aXRoIGEgcHJldmlvdXMgYWxsb2NhdGlvbi4K PiAtCSAqCj4gLQkgKiBIZXJlIGFzIHdlbGwgd2UgbmVlZCB0byB3YWl0IGZvciB0aGUgdmJsYW5r IHRvIG1ha2Ugc3VyZSB0aGUgZnJlZWQKPiAtCSAqIHNwYWNlIGlzIG5vdCB1c2VkIGFueW1vcmUu Cj4gLQkgKi8KPiAtCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Cj4gLQkJaWYgKCFj cnRjLT5hY3RpdmUpCj4gLQkJCWNvbnRpbnVlOwo+IC0KPiAtCQlwaXBlID0gY3J0Yy0+cGlwZTsK PiAtCj4gLQkJaWYgKHJlYWxsb2NhdGVkW3BpcGVdKQo+IC0JCQljb250aW51ZTsKPiAtCj4gLQkJ aWYgKHNrbF9kZGJfZW50cnlfc2l6ZSgmbmV3X2RkYi0+cGlwZVtwaXBlXSkgPAo+IC0JCSAgICBz a2xfZGRiX2VudHJ5X3NpemUoJmN1cl9kZGItPnBpcGVbcGlwZV0pKSB7Cj4gLQkJCXNrbF93bV9m bHVzaF9waXBlKGRldl9wcml2LCBwaXBlLCAyKTsKPiAtCQkJaW50ZWxfd2FpdF9mb3JfdmJsYW5r KGRldiwgcGlwZSk7Cj4gLQkJCXJlYWxsb2NhdGVkW3BpcGVdID0gdHJ1ZTsKPiAtCQl9Cj4gLQl9 Cj4gLQo+IC0JLyoKPiAtCSAqIFRoaXJkIHBhc3M6IGZsdXNoIHRoZSBwaXBlcyB0aGF0IGdvdCBt b3JlIHNwYWNlIGFsbG9jYXRlZC4KPiAtCSAqCj4gLQkgKiBXZSBkb24ndCBuZWVkIHRvIGFjdGl2 ZWx5IHdhaXQgZm9yIHRoZSB1cGRhdGUgaGVyZSwgbmV4dCB2YmxhbmsKPiAtCSAqIHdpbGwganVz dCBnZXQgbW9yZSBEREIgc3BhY2Ugd2l0aCB0aGUgY29ycmVjdCBXTSB2YWx1ZXMuCj4gLQkgKi8K PiAtCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Cj4gLQkJaWYgKCFjcnRjLT5hY3Rp dmUpCj4gLQkJCWNvbnRpbnVlOwo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IHN0YXRlLT5k ZXY7Cj4gKwlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YzsKPiArCWVudW0gcGlwZSBvdGhl cnA7Cj4gIAo+IC0JCXBpcGUgPSBjcnRjLT5waXBlOwo+ICsJZm9yX2VhY2hfaW50ZWxfY3J0Yyhk ZXYsIGludGVsX2NydGMpIHsKPiArCQlvdGhlcnAgPSBpbnRlbF9jcnRjLT5waXBlOwo+ICAKPiAg CQkvKgo+IC0JCSAqIEF0IHRoaXMgcG9pbnQsIG9ubHkgdGhlIHBpcGVzIG1vcmUgc3BhY2UgdGhh biBiZWZvcmUgYXJlCj4gLQkJICogbGVmdCB0byByZS1hbGxvY2F0ZS4KPiArCQkgKiBXaGVuIGNo ZWNraW5nIGZvciBvdmVybGFwcywgd2UgZG9uJ3Qgd2FudCB0bzoKPiArCQkgKiAgLSBDb21wYXJl IGFnYWluc3Qgb3Vyc2VsdmVzCj4gKwkJICogIC0gQ29tcGFyZSBhZ2FpbnN0IHBpcGVzIHRoYXQg d2lsbCBiZS9hcmUgZGlzYWJsZWQKPiArCQkgKiAgLSBDb21wYXJlIGFnYWluc3QgcGlwZXMgdGhh dCBhcmVuJ3QgZW5hYmxlZCB5ZXQKPiAgCQkgKi8KPiAtCQlpZiAocmVhbGxvY2F0ZWRbcGlwZV0p Cj4gKwkJaWYgKG90aGVycCA9PSBwaXBlIHx8ICFuZXctPnBpcGVbb3RoZXJwXS5lbmQgfHwKPiAr CQkgICAgIW9sZC0+cGlwZVtvdGhlcnBdLmVuZCkKPiAgCQkJY29udGludWU7CgpBcmVudCB3ZSBz ZXR0aW5nIHN0YXJ0PWVuZD0wIHdoaWxlIHRoZSBkZGIgZW50cnkgaXMgZGVhbGxvY2F0ZWQgKHdo aWxlCmEgcGlwZSBpcyBkaXNhYmxlZCk/IElmIHNvIHdlIHNob3VsZG4ndCBuZWVkIHRvIGNoZWNr IGZvciBlbXB0eSBlbnRyeQpleHBsaWNpdGx5LiBIbW0uIG1heWJlIHdlJ3JlIG5vdC4gSSB0aGlu ayB3ZSBzaG91bGQgc2luY2UgdGhhdCB3b3VsZAptYWtlIHRoaW5ncyBzaW1wbGVyLgoKPiAgCj4g LQkJc2tsX3dtX2ZsdXNoX3BpcGUoZGV2X3ByaXYsIHBpcGUsIDMpOwo+ICsJCWlmICgobmV3LT5w aXBlW3BpcGVdLnN0YXJ0ID49IG9sZC0+cGlwZVtvdGhlcnBdLnN0YXJ0ICYmCj4gKwkJICAgICBu ZXctPnBpcGVbcGlwZV0uc3RhcnQgPCBvbGQtPnBpcGVbb3RoZXJwXS5lbmQpIHx8Cj4gKwkJICAg IChvbGQtPnBpcGVbb3RoZXJwXS5zdGFydCA+PSBuZXctPnBpcGVbcGlwZV0uc3RhcnQgJiYKPiAr CQkgICAgIG9sZC0+cGlwZVtvdGhlcnBdLnN0YXJ0IDwgbmV3LT5waXBlW3BpcGVdLmVuZCkpCgpJ J2QgZXh0cmFjdCB0aGlzIHRvIGEgc21hbGwgaGVscGVyLCBhbmQgc2ltcGxpZnkgYSBiaXQgd2hp bGUgYXQgaXQuClNvIHBlcmhhcHM6Cgpza2xfZGRiX2VudHJpZXNfb3ZlcmxhcCgpCnsKCXJldHVy biBhLT5zdGFydCA8IGItPmVuZCAmJiBiLT5zdGFydCA8IGEtPmVuZDsKfQoKPiArCQkJcmV0dXJu IHRydWU7Cj4gIAl9Cj4gKwo+ICsJcmV0dXJuIGZhbHNlOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50 IHNrbF91cGRhdGVfcGlwZV93bShzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNzdGF0ZSwKPiBAQCAt NDE2MCw3ICs0MDQ0LDcgQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV93bShzdHJ1Y3QgZHJtX2Ny dGMgKmNydGMpCj4gIAlzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqaHdfdmFscyA9ICZkZXZfcHJpdi0+ d20uc2tsX2h3Owo+ICAJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZSA9IHRvX2ludGVs X2NydGNfc3RhdGUoY3J0Yy0+c3RhdGUpOwo+ICAJc3RydWN0IHNrbF9waXBlX3dtICpwaXBlX3dt ID0gJmNzdGF0ZS0+d20uc2tsLm9wdGltYWw7Cj4gLQlpbnQgcGlwZTsKPiArCWVudW0gcGlwZSBw aXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiAgCj4gIAlpZiAoKHJlc3VsdHMtPmRpcnR5X3BpcGVz ICYgZHJtX2NydGNfbWFzayhjcnRjKSkgPT0gMCkKPiAgCQlyZXR1cm47Cj4gQEAgLTQxNjksMTUg KzQwNTMsMjIgQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV93bShzdHJ1Y3QgZHJtX2NydGMgKmNy dGMpCj4gIAo+ICAJbXV0ZXhfbG9jaygmZGV2X3ByaXYtPndtLndtX211dGV4KTsKPiAgCj4gLQlz a2xfd3JpdGVfd21fdmFsdWVzKGRldl9wcml2LCByZXN1bHRzKTsKPiAtCXNrbF9mbHVzaF93bV92 YWx1ZXMoZGV2X3ByaXYsIHJlc3VsdHMpOwo+IC0KPiAgCS8qCj4gLQkgKiBTdG9yZSB0aGUgbmV3 IGNvbmZpZ3VyYXRpb24gKGJ1dCBvbmx5IGZvciB0aGUgcGlwZXMgdGhhdCBoYXZlCj4gLQkgKiBj aGFuZ2VkOyB0aGUgb3RoZXIgdmFsdWVzIHdlcmVuJ3QgcmVjb21wdXRlZCkuCj4gKwkgKiBJZiB0 aGlzIHBpcGUgaXNuJ3QgYWN0aXZlIGFscmVhZHksIHdlJ3JlIGdvaW5nIHRvIGJlIGVuYWJsaW5n IGl0Cj4gKwkgKiB2ZXJ5IHNvb24uIFNpbmNlIGl0J3Mgc2FmZSB0byB1cGRhdGUgYSBwaXBlJ3Mg ZGRiIGFsbG9jYXRpb24gd2hpbGUKPiArCSAqIHRoZSBwaXBlJ3Mgc2h1dCBvZmYsIGp1c3QgZG8g c28gaGVyZS4gQWxyZWFkeSBhY3RpdmUgcGlwZXMgd2lsbCBoYXZlCj4gKwkgKiB0aGVpciB3YXRl cm1hcmtzIHVwZGF0ZWQgb25jZSB3ZSB1cGRhdGUgdGhlaXIgcGxhbmVzLgo+ICAJICovCj4gLQlm b3JfZWFjaF9waXBlX21hc2tlZChkZXZfcHJpdiwgcGlwZSwgcmVzdWx0cy0+ZGlydHlfcGlwZXMp Cj4gLQkJc2tsX2NvcHlfd21fZm9yX3BpcGUoaHdfdmFscywgcmVzdWx0cywgcGlwZSk7Cj4gKwlp ZiAoY3J0Yy0+c3RhdGUtPmFjdGl2ZV9jaGFuZ2VkKSB7Cj4gKwkJaW50IHBsYW5lOwo+ICsKPiAr CQlmb3IgKHBsYW5lID0gMDsgcGxhbmUgPCBpbnRlbF9udW1fcGxhbmVzKGludGVsX2NydGMpOyBw bGFuZSsrKQo+ICsJCQlza2xfd3JpdGVfcGxhbmVfd20oaW50ZWxfY3J0YywgcmVzdWx0cywgcGxh bmUpOwo+ICsKPiArCQlza2xfd3JpdGVfY3Vyc29yX3dtKGludGVsX2NydGMsIHJlc3VsdHMpOwo+ ICsJfQo+ICsKPiArCXNrbF9jb3B5X3dtX2Zvcl9waXBlKGh3X3ZhbHMsIHJlc3VsdHMsIHBpcGUp OwoKSG1tLiBTbyBJJ20gdGhpbmtpbmcgdGhhdCBpZiB3ZSBtYWtlIHRoZSBkZGIgYWxsb2NhdGlv biBtYXRjaCB0aGUKYWN0dWFsIHBpcGUgc3RhdGUgYXQgYWxsIHRpbWUsIHRoZSBhbGdvcml0aG0g d2lsbCBiZSBzaW1wbGVyLiBTbyBpZiBhbnkKZGlzYWJsZWQgcGlwZSAoZXZlbiBvbmVzIGRpc2Fi bGVkIHRlbXBvcmFyaWx5IGZvciBtb2Rlc2V0KSB3aWxsIGhhdmUKdGhlaXIgY3VycmVudCBkZGIg ZW50cnkgemVyb2VkLCB0aGUgbWFpbiB1cGRhdGUgbG9vcCBjYW4gaGFuZGxlCmV2ZXJ5dGhpbmcg Zm9yIHVzLCBldmVuIGVuYWJsaW5nIG5ldyBwaXBlcy4gV2VsbCwgaXQgd29uJ3QgaGFuZGxlCmRp c2FibGluZyBwaXBlcywgYnV0IHRoYXQncyBmaW5lLgoKPiAgCj4gIAltdXRleF91bmxvY2soJmRl dl9wcml2LT53bS53bV9tdXRleCk7Cj4gIH0KPiAtLSAKPiAyLjcuNAoKLS0gClZpbGxlIFN5cmrD pGzDpApJbnRlbCBPVEMKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwt Z2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752695AbcHLNal (ORCPT ); Fri, 12 Aug 2016 09:30:41 -0400 Received: from mga04.intel.com ([192.55.52.120]:10411 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751982AbcHLNaj (ORCPT ); Fri, 12 Aug 2016 09:30:39 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,510,1464678000"; d="scan'208";a="1034457950" Date: Fri, 12 Aug 2016 16:30:19 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Lyude Cc: intel-gfx@lists.freedesktop.org, Maarten Lankhorst , Matt Roper , Daniel Vetter , Radhakrishna Sripada , Hans de Goede , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v11 7/7] drm/i915/skl: Update DDB values atomically with wms/plane attrs Message-ID: <20160812133019.GB4329@intel.com> References: <1470945277-7973-1-git-send-email-cpaul@redhat.com> <1470945277-7973-8-git-send-email-cpaul@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1470945277-7973-8-git-send-email-cpaul@redhat.com> User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Aug 11, 2016 at 03:54:36PM -0400, Lyude wrote: > Now that we can hook into update_crtcs and control the order in which we > update CRTCs at each modeset, we can finish the final step of fixing > Skylake's watermark handling by performing DDB updates at the same time > as plane updates and watermark updates. > > The first major change in this patch is skl_update_crtcs(), which > handles ensuring that we order each CRTC update in our atomic commits > properly so that they honor the DDB flush order. > > The second major change in this patch is the order in which we flush the > pipes. While the previous order may have worked, it can't be used in > this approach since it no longer will do the right thing. For example, > using the old ddb flush order: > > We have pipes A, B, and C enabled, and we're disabling C. Initial ddb > allocation looks like this: > > | A | B |xxxxxxx| > > Since we're performing the ddb updates after performing any CRTC > disablements in intel_atomic_commit_tail(), the space to the right of > pipe B is unallocated. > > 1. Flush pipes with new allocation contained into old space. None > apply, so we skip this > 2. Flush pipes having their allocation reduced, but overlapping with a > previous allocation. None apply, so we also skip this > 3. Flush pipes that got more space allocated. This applies to A and B, > giving us the following update order: A, B > > This is wrong, since updating pipe A first will cause it to overlap with > B and potentially burst into flames. Our new order (see the code > comments for details) would update the pipes in the proper order: B, A. > > As well, we calculate the order for each DDB update during the check > phase, and reference it later in the commit phase when we hit > skl_update_crtcs(). > > This long overdue patch fixes the rest of the underruns on Skylake. > > Changes since v1: > - Add skl_ddb_entry_write() for cursor into skl_write_cursor_wm() > Changes since v2: > - Use the method for updating CRTCs that Ville suggested > - In skl_update_wm(), only copy the watermarks for the crtc that was > passed to us > Changes since v3: > - Small comment fix in skl_ddb_allocation_overlaps() > > Fixes: 0e8fb7ba7ca5 ("drm/i915/skl: Flush the WM configuration") > Fixes: 8211bd5bdf5e ("drm/i915/skl: Program the DDB allocation") > [omitting CC for stable, since this patch will need to be changed for > such backports first] > > Testcase: kms_cursor_legacy > Signed-off-by: Lyude > Reviewed-by: Maarten Lankhorst > Cc: Ville Syrjälä > Cc: Daniel Vetter > Cc: Radhakrishna Sripada > Cc: Hans de Goede > Cc: Matt Roper > --- > drivers/gpu/drm/i915/intel_display.c | 100 +++++++++++++++-- > drivers/gpu/drm/i915/intel_drv.h | 7 ++ > drivers/gpu/drm/i915/intel_pm.c | 207 +++++++++-------------------------- > 3 files changed, 144 insertions(+), 170 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index 61a45f1..68fdbf0 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -13348,16 +13348,23 @@ static void verify_wm_state(struct drm_crtc *crtc, > hw_entry->start, hw_entry->end); > } > > - /* cursor */ > - hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; > - sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; > - > - if (!skl_ddb_entry_equal(hw_entry, sw_entry)) { > - DRM_ERROR("mismatch in DDB state pipe %c cursor " > - "(expected (%u,%u), found (%u,%u))\n", > - pipe_name(pipe), > - sw_entry->start, sw_entry->end, > - hw_entry->start, hw_entry->end); > + /* > + * cursor > + * If the cursor plane isn't active, we may not have updated it's ddb > + * allocation. In that case since the ddb allocation will be updated > + * once the plane becomes visible, we can skip this check > + */ > + if (intel_crtc->cursor_addr) { > + hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; > + sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; > + > + if (!skl_ddb_entry_equal(hw_entry, sw_entry)) { > + DRM_ERROR("mismatch in DDB state pipe %c cursor " > + "(expected (%u,%u), found (%u,%u))\n", > + pipe_name(pipe), > + sw_entry->start, sw_entry->end, > + hw_entry->start, hw_entry->end); > + } > } > } > > @@ -14109,6 +14116,72 @@ static void intel_update_crtcs(struct drm_atomic_state *state, > } > } > > +static void skl_update_crtcs(struct drm_atomic_state *state, > + unsigned int *crtc_vblank_mask) > +{ > + struct drm_device *dev = state->dev; > + struct drm_i915_private *dev_priv = to_i915(dev); > + struct intel_atomic_state *intel_state = to_intel_atomic_state(state); > + struct drm_crtc *crtc; > + struct drm_crtc_state *old_crtc_state; > + struct skl_ddb_allocation *new_ddb = &intel_state->wm_results.ddb; > + struct skl_ddb_allocation cur_ddb; > + bool progress; > + bool reallocated[I915_MAX_PIPES] = {}; > + enum pipe pipe; > + int wait_vbl_pipes, i; > + > + /* > + * Whenever the number of active pipes change, so does the DDB > + * allocation. DDB allocations on pipes cannot ever overlap with > + * eachother at any point in time, so we need to change the order we > + * update the pipes so that we ensure they never overlap inbetween DDB > + * updates. > + */ > + do { > + progress = false; > + wait_vbl_pipes = 0; > + cur_ddb = dev_priv->wm.skl_hw.ddb; I guess would could do the loop twice to avoid the copy. But not sure that's really any more efficient. > + > + for_each_crtc_in_state(state, crtc, old_crtc_state, i) { > + struct intel_crtc *intel_crtc = to_intel_crtc(crtc); > + pipe = intel_crtc->pipe; > + > + if (!intel_crtc->active || needs_modeset(crtc->state)) > + continue; crtc->state->active? > + if (skl_ddb_allocation_equals(&cur_ddb, new_ddb, pipe)) > + continue; > + if (skl_ddb_allocation_overlaps(state, &cur_ddb, > + new_ddb, pipe)) > + continue; > + > + intel_update_crtc(crtc, state, old_crtc_state, > + crtc_vblank_mask); What did the caller want with the vblank_mask? Do more vblank waits? Shouldn't be needed I think since we wait here, no? > + > + wait_vbl_pipes |= drm_crtc_mask(crtc); > + reallocated[pipe] = true; > + progress = true; I guess we could throw this out actully. wait_vbl_pipes!=0 should mean the same thing. > + } > + > + /* Wait for each pipe's new allocation to take effect */ > + intel_atomic_wait_for_vblanks(dev, dev_priv, wait_vbl_pipes); > + } while (progress); > + > + /* > + * Now that we've handled any ddb reallocations, we can go ahead and > + * enable any new pipes. > + */ > + for_each_crtc_in_state(state, crtc, old_crtc_state, i) { > + pipe = to_intel_crtc(crtc)->pipe; > + > + if (reallocated[pipe] || !crtc->state->active) > + continue; Do we need this reallocated[] flag? Isn't this the same as 'active && needs_modeset' ? > + > + intel_update_crtc(crtc, state, old_crtc_state, > + crtc_vblank_mask); > + } > +} > + > static void intel_atomic_commit_tail(struct drm_atomic_state *state) > { > struct drm_device *dev = state->dev; > @@ -15738,8 +15811,6 @@ void intel_init_display_hooks(struct drm_i915_private *dev_priv) > dev_priv->display.crtc_disable = i9xx_crtc_disable; > } > > - dev_priv->display.update_crtcs = intel_update_crtcs; > - > /* Returns the core display clock speed */ > if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) > dev_priv->display.get_display_clock_speed = > @@ -15829,6 +15900,11 @@ void intel_init_display_hooks(struct drm_i915_private *dev_priv) > skl_modeset_calc_cdclk; > } > > + if (dev_priv->info.gen >= 9) > + dev_priv->display.update_crtcs = skl_update_crtcs; > + else > + dev_priv->display.update_crtcs = intel_update_crtcs; > + > switch (INTEL_INFO(dev_priv)->gen) { > case 2: > dev_priv->display.queue_flip = intel_gen2_queue_flip; > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 88088c3..9f9fe69 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -1723,6 +1723,13 @@ void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv, > struct skl_ddb_allocation *ddb /* out */); > int skl_enable_sagv(struct drm_i915_private *dev_priv); > int skl_disable_sagv(struct drm_i915_private *dev_priv); > +bool skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, > + const struct skl_ddb_allocation *new, > + enum pipe pipe); > +bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, > + const struct skl_ddb_allocation *old, > + const struct skl_ddb_allocation *new, > + enum pipe pipe); > void skl_write_cursor_wm(struct intel_crtc *intel_crtc, > const struct skl_wm_values *wm); > void skl_write_plane_wm(struct intel_crtc *intel_crtc, > diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c > index f2e0071..6fe9e57 100644 > --- a/drivers/gpu/drm/i915/intel_pm.c > +++ b/drivers/gpu/drm/i915/intel_pm.c > @@ -3794,6 +3794,11 @@ void skl_write_plane_wm(struct intel_crtc *intel_crtc, > wm->plane[pipe][plane][level]); > } > I915_WRITE(PLANE_WM_TRANS(pipe, plane), wm->plane_trans[pipe][plane]); > + > + skl_ddb_entry_write(dev_priv, PLANE_BUF_CFG(pipe, plane), > + &wm->ddb.plane[pipe][plane]); > + skl_ddb_entry_write(dev_priv, PLANE_NV12_BUF_CFG(pipe, plane), > + &wm->ddb.y_plane[pipe][plane]); > } > > void skl_write_cursor_wm(struct intel_crtc *intel_crtc, > @@ -3810,170 +3815,49 @@ void skl_write_cursor_wm(struct intel_crtc *intel_crtc, > wm->plane[pipe][PLANE_CURSOR][level]); > } > I915_WRITE(CUR_WM_TRANS(pipe), wm->plane_trans[pipe][PLANE_CURSOR]); > -} > - > -static void skl_write_wm_values(struct drm_i915_private *dev_priv, > - const struct skl_wm_values *new) > -{ > - struct drm_device *dev = &dev_priv->drm; > - struct intel_crtc *crtc; > > - for_each_intel_crtc(dev, crtc) { > - int i; > - enum pipe pipe = crtc->pipe; > - > - if ((new->dirty_pipes & drm_crtc_mask(&crtc->base)) == 0) > - continue; > - if (!crtc->active) > - continue; > - > - for (i = 0; i < intel_num_planes(crtc); i++) { > - skl_ddb_entry_write(dev_priv, > - PLANE_BUF_CFG(pipe, i), > - &new->ddb.plane[pipe][i]); > - skl_ddb_entry_write(dev_priv, > - PLANE_NV12_BUF_CFG(pipe, i), > - &new->ddb.y_plane[pipe][i]); > - } > - > - skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), > - &new->ddb.plane[pipe][PLANE_CURSOR]); > - } > + skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), > + &wm->ddb.plane[pipe][PLANE_CURSOR]); > } > > -/* > - * When setting up a new DDB allocation arrangement, we need to correctly > - * sequence the times at which the new allocations for the pipes are taken into > - * account or we'll have pipes fetching from space previously allocated to > - * another pipe. > - * > - * Roughly the sequence looks like: > - * 1. re-allocate the pipe(s) with the allocation being reduced and not > - * overlapping with a previous light-up pipe (another way to put it is: > - * pipes with their new allocation strickly included into their old ones). > - * 2. re-allocate the other pipes that get their allocation reduced > - * 3. allocate the pipes having their allocation increased > - * > - * Steps 1. and 2. are here to take care of the following case: > - * - Initially DDB looks like this: > - * | B | C | > - * - enable pipe A. > - * - pipe B has a reduced DDB allocation that overlaps with the old pipe C > - * allocation > - * | A | B | C | > - * > - * We need to sequence the re-allocation: C, B, A (and not B, C, A). > - */ > - > -static void > -skl_wm_flush_pipe(struct drm_i915_private *dev_priv, enum pipe pipe, int pass) > -{ > - int plane; > - > - DRM_DEBUG_KMS("flush pipe %c (pass %d)\n", pipe_name(pipe), pass); > - > - for_each_plane(dev_priv, pipe, plane) { > - I915_WRITE(PLANE_SURF(pipe, plane), > - I915_READ(PLANE_SURF(pipe, plane))); > - } > - I915_WRITE(CURBASE(pipe), I915_READ(CURBASE(pipe))); > -} > - > -static bool > -skl_ddb_allocation_included(const struct skl_ddb_allocation *old, > - const struct skl_ddb_allocation *new, > - enum pipe pipe) > +bool skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, > + const struct skl_ddb_allocation *new, > + enum pipe pipe) > { > - uint16_t old_size, new_size; > - > - old_size = skl_ddb_entry_size(&old->pipe[pipe]); > - new_size = skl_ddb_entry_size(&new->pipe[pipe]); > - > - return old_size != new_size && > - new->pipe[pipe].start >= old->pipe[pipe].start && > - new->pipe[pipe].end <= old->pipe[pipe].end; > + return new->pipe[pipe].start == old->pipe[pipe].start && > + new->pipe[pipe].end == old->pipe[pipe].end; > } > > -static void skl_flush_wm_values(struct drm_i915_private *dev_priv, > - struct skl_wm_values *new_values) > +bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, > + const struct skl_ddb_allocation *old, > + const struct skl_ddb_allocation *new, > + enum pipe pipe) > { > - struct drm_device *dev = &dev_priv->drm; > - struct skl_ddb_allocation *cur_ddb, *new_ddb; > - bool reallocated[I915_MAX_PIPES] = {}; > - struct intel_crtc *crtc; > - enum pipe pipe; > - > - new_ddb = &new_values->ddb; > - cur_ddb = &dev_priv->wm.skl_hw.ddb; > - > - /* > - * First pass: flush the pipes with the new allocation contained into > - * the old space. > - * > - * We'll wait for the vblank on those pipes to ensure we can safely > - * re-allocate the freed space without this pipe fetching from it. > - */ > - for_each_intel_crtc(dev, crtc) { > - if (!crtc->active) > - continue; > - > - pipe = crtc->pipe; > - > - if (!skl_ddb_allocation_included(cur_ddb, new_ddb, pipe)) > - continue; > - > - skl_wm_flush_pipe(dev_priv, pipe, 1); > - intel_wait_for_vblank(dev, pipe); > - > - reallocated[pipe] = true; > - } > - > - > - /* > - * Second pass: flush the pipes that are having their allocation > - * reduced, but overlapping with a previous allocation. > - * > - * Here as well we need to wait for the vblank to make sure the freed > - * space is not used anymore. > - */ > - for_each_intel_crtc(dev, crtc) { > - if (!crtc->active) > - continue; > - > - pipe = crtc->pipe; > - > - if (reallocated[pipe]) > - continue; > - > - if (skl_ddb_entry_size(&new_ddb->pipe[pipe]) < > - skl_ddb_entry_size(&cur_ddb->pipe[pipe])) { > - skl_wm_flush_pipe(dev_priv, pipe, 2); > - intel_wait_for_vblank(dev, pipe); > - reallocated[pipe] = true; > - } > - } > - > - /* > - * Third pass: flush the pipes that got more space allocated. > - * > - * We don't need to actively wait for the update here, next vblank > - * will just get more DDB space with the correct WM values. > - */ > - for_each_intel_crtc(dev, crtc) { > - if (!crtc->active) > - continue; > + struct drm_device *dev = state->dev; > + struct intel_crtc *intel_crtc; > + enum pipe otherp; > > - pipe = crtc->pipe; > + for_each_intel_crtc(dev, intel_crtc) { > + otherp = intel_crtc->pipe; > > /* > - * At this point, only the pipes more space than before are > - * left to re-allocate. > + * When checking for overlaps, we don't want to: > + * - Compare against ourselves > + * - Compare against pipes that will be/are disabled > + * - Compare against pipes that aren't enabled yet > */ > - if (reallocated[pipe]) > + if (otherp == pipe || !new->pipe[otherp].end || > + !old->pipe[otherp].end) > continue; Arent we setting start=end=0 while the ddb entry is deallocated (while a pipe is disabled)? If so we shouldn't need to check for empty entry explicitly. Hmm. maybe we're not. I think we should since that would make things simpler. > > - skl_wm_flush_pipe(dev_priv, pipe, 3); > + if ((new->pipe[pipe].start >= old->pipe[otherp].start && > + new->pipe[pipe].start < old->pipe[otherp].end) || > + (old->pipe[otherp].start >= new->pipe[pipe].start && > + old->pipe[otherp].start < new->pipe[pipe].end)) I'd extract this to a small helper, and simplify a bit while at it. So perhaps: skl_ddb_entries_overlap() { return a->start < b->end && b->start < a->end; } > + return true; > } > + > + return false; > } > > static int skl_update_pipe_wm(struct drm_crtc_state *cstate, > @@ -4160,7 +4044,7 @@ static void skl_update_wm(struct drm_crtc *crtc) > struct skl_wm_values *hw_vals = &dev_priv->wm.skl_hw; > struct intel_crtc_state *cstate = to_intel_crtc_state(crtc->state); > struct skl_pipe_wm *pipe_wm = &cstate->wm.skl.optimal; > - int pipe; > + enum pipe pipe = intel_crtc->pipe; > > if ((results->dirty_pipes & drm_crtc_mask(crtc)) == 0) > return; > @@ -4169,15 +4053,22 @@ static void skl_update_wm(struct drm_crtc *crtc) > > mutex_lock(&dev_priv->wm.wm_mutex); > > - skl_write_wm_values(dev_priv, results); > - skl_flush_wm_values(dev_priv, results); > - > /* > - * Store the new configuration (but only for the pipes that have > - * changed; the other values weren't recomputed). > + * If this pipe isn't active already, we're going to be enabling it > + * very soon. Since it's safe to update a pipe's ddb allocation while > + * the pipe's shut off, just do so here. Already active pipes will have > + * their watermarks updated once we update their planes. > */ > - for_each_pipe_masked(dev_priv, pipe, results->dirty_pipes) > - skl_copy_wm_for_pipe(hw_vals, results, pipe); > + if (crtc->state->active_changed) { > + int plane; > + > + for (plane = 0; plane < intel_num_planes(intel_crtc); plane++) > + skl_write_plane_wm(intel_crtc, results, plane); > + > + skl_write_cursor_wm(intel_crtc, results); > + } > + > + skl_copy_wm_for_pipe(hw_vals, results, pipe); Hmm. So I'm thinking that if we make the ddb allocation match the actual pipe state at all time, the algorithm will be simpler. So if any disabled pipe (even ones disabled temporarily for modeset) will have their current ddb entry zeroed, the main update loop can handle everything for us, even enabling new pipes. Well, it won't handle disabling pipes, but that's fine. > > mutex_unlock(&dev_priv->wm.wm_mutex); > } > -- > 2.7.4 -- Ville Syrjälä Intel OTC