From mboxrd@z Thu Jan 1 00:00:00 1970 From: Matt Roper Subject: Re: [PATCH v5 6/6] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Tue, 2 Aug 2016 17:11:15 -0700 Message-ID: <20160803001115.GC32025@intel.com> References: <1470163975-30467-1-git-send-email-cpaul@redhat.com> <1470163975-30467-7-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: <1470163975-30467-7-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 T24gVHVlLCBBdWcgMDIsIDIwMTYgYXQgMDI6NTI6NTRQTSAtMDQwMCwgTHl1ZGUgd3JvdGU6Cj4g 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 YXRjaCBmaXhlcyB0aGUgcmVzdCBvZiB0aGUgdW5kZXJydW5zIG9uIFNreWxha2UuCj4gCj4gRml4 ZXM6IDBlOGZiN2JhN2NhNSAoImRybS9pOTE1L3NrbDogRmx1c2ggdGhlIFdNIGNvbmZpZ3VyYXRp b24iKQo+IEZpeGVzOiA4MjExYmQ1YmRmNWUgKCJkcm0vaTkxNS9za2w6IFByb2dyYW0gdGhlIERE QiBhbGxvY2F0aW9uIikKPiBTaWduZWQtb2ZmLWJ5OiBMeXVkZSA8Y3BhdWxAcmVkaGF0LmNvbT4K PiBbb21pdHRpbmcgQ0MgZm9yIHN0YWJsZSwgc2luY2UgdGhpcyBwYXRjaCB3aWxsIG5lZWQgdG8g YmUgY2hhbmdlZCBmb3IKPiBzdWNoIGJhY2twb3J0cyBmaXJzdF0KPiBDYzogVmlsbGUgU3lyasOk bMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KPiBDYzogRGFuaWVsIFZldHRlciA8 ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+Cj4gQ2M6IFJhZGhha3Jpc2huYSBTcmlwYWRhIDxyYWRo YWtyaXNobmEuc3JpcGFkYUBpbnRlbC5jb20+Cj4gQ2M6IEhhbnMgZGUgR29lZGUgPGhkZWdvZWRl QHJlZGhhdC5jb20+Cj4gQ2M6IE1hdHQgUm9wZXIgPG1hdHRoZXcuZC5yb3BlckBpbnRlbC5jb20+ Cj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyB8IDEwMCArKysr KysrKysrLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICAgIHwgIDEwICsr Cj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMgICAgICB8IDI4NyArKysrKysrKysr KysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICAzIGZpbGVzIGNoYW5nZWQsIDIzMSBpbnNlcnRp b25zKCspLCAxNjYgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2Rpc3BsYXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3Bs YXkuYwo+IGluZGV4IGQ5ODViNWIuLmRiMjcxZDYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZGlzcGxheS5jCj4gQEAgLTEyOTA5LDE2ICsxMjkwOSwyMyBAQCBzdGF0aWMgdm9pZCB2ZXJp Znlfd21fc3RhdGUoc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ICAJCQkgIGh3X2VudHJ5LT5zdGFy dCwgaHdfZW50cnktPmVuZCk7Cj4gIAl9Cj4gIAo+IC0JLyogY3Vyc29yICovCj4gLQlod19lbnRy eSA9ICZod19kZGIucGxhbmVbcGlwZV1bUExBTkVfQ1VSU09SXTsKPiAtCXN3X2VudHJ5ID0gJnN3 X2RkYi0+cGxhbmVbcGlwZV1bUExBTkVfQ1VSU09SXTsKPiAtCj4gLQlpZiAoIXNrbF9kZGJfZW50 cnlfZXF1YWwoaHdfZW50cnksIHN3X2VudHJ5KSkgewo+IC0JCURSTV9FUlJPUigibWlzbWF0Y2gg aW4gRERCIHN0YXRlIHBpcGUgJWMgY3Vyc29yICIKPiAtCQkJICAiKGV4cGVjdGVkICgldSwldSks IGZvdW5kICgldSwldSkpXG4iLAo+IC0JCQkgIHBpcGVfbmFtZShwaXBlKSwKPiAtCQkJICBzd19l bnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5lbmQsCj4gLQkJCSAgaHdfZW50cnktPnN0YXJ0LCBod19l bnRyeS0+ZW5kKTsKPiArCS8qCj4gKwkgKiBjdXJzb3IKPiArCSAqIElmIHRoZSBjdXJzb3IgcGxh bmUgaXNuJ3QgYWN0aXZlLCB3ZSBtYXkgbm90IGhhdmUgdXBkYXRlZCBpdCdzIGRkYgo+ICsJICog YWxsb2NhdGlvbi4gSW4gdGhhdCBjYXNlIHNpbmNlIHRoZSBkZGIgYWxsb2NhdGlvbiB3aWxsIGJl IHVwZGF0ZWQKPiArCSAqIG9uY2UgdGhlIHBsYW5lIGJlY29tZXMgdmlzaWJsZSwgd2UgY2FuIHNr aXAgdGhpcyBjaGVjawo+ICsJICovCj4gKwlpZiAoaW50ZWxfY3J0Yy0+Y3Vyc29yX2FkZHIpIHsK PiArCQlod19lbnRyeSA9ICZod19kZGIucGxhbmVbcGlwZV1bUExBTkVfQ1VSU09SXTsKPiArCQlz d19lbnRyeSA9ICZzd19kZGItPnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gKwo+ICsJCWlm ICghc2tsX2RkYl9lbnRyeV9lcXVhbChod19lbnRyeSwgc3dfZW50cnkpKSB7Cj4gKwkJCURSTV9F UlJPUigibWlzbWF0Y2ggaW4gRERCIHN0YXRlIHBpcGUgJWMgY3Vyc29yICIKPiArCQkJCSAgIihl eHBlY3RlZCAoJXUsJXUpLCBmb3VuZCAoJXUsJXUpKVxuIiwKPiArCQkJCSAgcGlwZV9uYW1lKHBp cGUpLAo+ICsJCQkJICBzd19lbnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5lbmQsCj4gKwkJCQkgIGh3 X2VudHJ5LT5zdGFydCwgaHdfZW50cnktPmVuZCk7Cj4gKwkJfQo+ICAJfQo+ICB9Cj4gIAo+IEBA IC0xMzY3MCw2ICsxMzY3Nyw3MiBAQCBzdGF0aWMgdm9pZCBpbnRlbF91cGRhdGVfY3J0Y3Moc3Ry dWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAo+ICAJfQo+ICB9Cj4gIAo+ICtzdGF0aWMgaW5s aW5lIHZvaWQKPiArc2tsX2RvX2RkYl9zdGVwKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0 ZSwKPiArCQllbnVtIHNrbF9kZGJfc3RlcCBzdGVwKQo+ICt7Cj4gKwlzdHJ1Y3QgaW50ZWxfYXRv bWljX3N0YXRlICppbnRlbF9zdGF0ZSA9IHRvX2ludGVsX2F0b21pY19zdGF0ZShzdGF0ZSk7Cj4g KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7Cj4gKwlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKm9sZF9j cnRjX3N0YXRlOwo+ICsJdW5zaWduZWQgaW50IGNydGNfdmJsYW5rX21hc2s7IC8qIHVudXNlZCAq Lwo+ICsJaW50IGk7Cj4gKwo+ICsJZm9yX2VhY2hfY3J0Y19pbl9zdGF0ZShzdGF0ZSwgY3J0Yywg b2xkX2NydGNfc3RhdGUsIGkpIHsKPiArCQlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9 IHRvX2ludGVsX2NydGMoY3J0Yyk7Cj4gKwkJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNzdGF0 ZSA9Cj4gKwkJCXRvX2ludGVsX2NydGNfc3RhdGUoY3J0Yy0+c3RhdGUpOwo+ICsJCWJvb2wgdmJs YW5rX3dhaXQgPSBmYWxzZTsKPiArCj4gKwkJaWYgKGNzdGF0ZS0+d20uc2tsLmRkYl9yZWFsbG9j ICE9IHN0ZXAgfHwgIWNydGMtPnN0YXRlLT5hY3RpdmUpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiAr CQkvKgo+ICsJCSAqIElmIHdlJ3JlIGNoYW5naW5nIHRoZSBkZGIgYWxsb2NhdGlvbiBvZiB0aGlz IHBpcGUgdG8gbWFrZQo+ICsJCSAqIHJvb20gZm9yIGFub3RoZXIgcGlwZSwgd2UgaGF2ZSB0byB3 YWl0IGZvciB0aGUgcGlwZSdzIGRkYgo+ICsJCSAqIGFsbG9jYXRpb25zIHRvIGFjdHVhbGx5IHVw ZGF0ZSBieSB3YWl0aW5nIGZvciBhIHZibGFuay4KPiArCQkgKiBPdGhlcndpc2Ugd2UgcmlzayB0 aGUgbmV4dCBwaXBlIHVwZGF0aW5nIGJlZm9yZSB0aGlzIHBpcGUKPiArCQkgKiBmaW5pc2hlcywg cmVzdWx0aW5nIGluIHRoZSBwaXBlIGZldGNoaW5nIGZyb20gZGRiIHNwYWNlIGZvcgo+ICsJCSAq IHRoZSB3cm9uZyBwaXBlLgo+ICsJCSAqCj4gKwkJICogSG93ZXZlciwgaWYgd2Uga25vdyB3ZSBk b24ndCBoYXZlIGFueSBtb3JlIHBpcGVzIHRvIG1vdmUKPiArCQkgKiBhcm91bmQsIHdlIGNhbiBz a2lwIHRoaXMgd2FpdCBhbmQgdGhlIG5ldyBkZGIgYWxsb2NhdGlvbgo+ICsJCSAqIHdpbGwgdGFr ZSBlZmZlY3QgYXQgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHZibGFuay4KPiArCQkgKi8KPiArCQlz d2l0Y2ggKHN0ZXApIHsKPiArCQljYXNlIFNLTF9EREJfU1RFUF9OT19PVkVSTEFQOgo+ICsJCWNh c2UgU0tMX0REQl9TVEVQX09WRVJMQVA6Cj4gKwkJCWlmIChzdGVwICE9IGludGVsX3N0YXRlLT5s YXN0X2RkYl9zdGVwKQo+ICsJCQkJdmJsYW5rX3dhaXQgPSB0cnVlOwo+ICsKPiArCQkvKiBkcm9w IHRocm91Z2ggKi8KPiArCQljYXNlIFNLTF9EREJfU1RFUF9GSU5BTDoKPiArCQkJRFJNX0RFQlVH X0tNUygKPiArCQkJICAgICJVcGRhdGluZyBbQ1JUQzolZDpwaXBlICVjXSBmb3IgRERCIHN0ZXAg JWRcbiIsCj4gKwkJCSAgICBjcnRjLT5iYXNlLmlkLCBwaXBlX25hbWUoaW50ZWxfY3J0Yy0+cGlw ZSksCj4gKwkJCSAgICBzdGVwKTsKPiArCj4gKwkJY2FzZSBTS0xfRERCX1NURVBfTk9ORToKPiAr CQkJYnJlYWs7Cj4gKwkJfQo+ICsKPiArCQlpbnRlbF91cGRhdGVfY3J0YyhjcnRjLCBzdGF0ZSwg b2xkX2NydGNfc3RhdGUsCj4gKwkJCQkgICZjcnRjX3ZibGFua19tYXNrKTsKPiArCj4gKwkJaWYg KHZibGFua193YWl0KQo+ICsJCQlpbnRlbF93YWl0X2Zvcl92Ymxhbmsoc3RhdGUtPmRldiwgaW50 ZWxfY3J0Yy0+cGlwZSk7CgpXZSBvbmx5IHRlY2huaWNhbGx5IG5lZWQgdG8gd2FpdCBhdCB0aGUg ZW5kIG9mIGEgc3RlcCwgbm90IG9uIGVhY2gKaW5kaXZpZHVhbCBDUlRDIHdpdGhpbiBhIHN0ZXAu ICBTaW5jZSB3ZSBvbmx5IGhhdmUgdGhyZWUgcGlwZXMgdG90YWwsCnRoYXQgdXN1YWxseSB3aW5k cyB1cCBiZWluZyB0aGUgc2FtZSB0aGluZywgYnV0IHRoZSBvbmUgY2FzZSB3ZSBjYW4Kb3B0aW1p emUgc2xpZ2h0bHkgaXMgd2hlbiB3ZSByZS1lbmFibGUgcGlwZSBCIHdoaWxlIEEgYW5kIEMgYXJl IGFscmVhZHkKb24uCgogICAgICAgIEFBQUFBQUNDQ0NDQyAgKGluaXRpYWwgc3RhdGUpCiAgICAg ICAgQUFBQV9fX19DQ0NDICAoc3RlcCAxOiByZWR1Y2UgYm90aCBBIGFuZCBDKQogICAgICAgIEFB QUFCQkJCQ0NDQyAgKGZpbmFsIHN0ZXApCgpXZSBqdXN0IG5lZWQgdG8gd2FpdCB1bnRpbCBib3Ro IEEgYW5kIEMgaGF2ZSBoYWQgYSB2YmxhbmsgKGFzCmludGVsX2F0b21pY193YWl0X2Zvcl92Ymxh bmtzKCkgZG9lcykgcmF0aGVyIHRoYW4gZG9pbmcgZWFjaApzZXF1ZW50aWFsbHkuCgoKPiArCX0K PiArfQo+ICsKPiArc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV9jcnRjcyhzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc3RhdGUsCj4gKwkJCSAgICAgdW5zaWduZWQgaW50ICpjcnRjX3ZibGFua19tYXNr KQo+ICt7Cj4gKwlzdHJ1Y3QgaW50ZWxfYXRvbWljX3N0YXRlICppbnRlbF9zdGF0ZSA9IHRvX2lu dGVsX2F0b21pY19zdGF0ZShzdGF0ZSk7Cj4gKwllbnVtIHNrbF9kZGJfc3RlcCBzdGVwOwo+ICsK PiArCWZvciAoc3RlcCA9IDA7IHN0ZXAgPD0gaW50ZWxfc3RhdGUtPmxhc3RfZGRiX3N0ZXA7IHN0 ZXArKykKPiArCQlza2xfZG9fZGRiX3N0ZXAoc3RhdGUsIHN0ZXApOwo+ICt9Cj4gKwo+ICBzdGF0 aWMgdm9pZCBpbnRlbF9hdG9taWNfY29tbWl0X3RhaWwoc3RydWN0IGRybV9hdG9taWNfc3RhdGUg KnN0YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gc3RhdGUtPmRldjsKPiBA QCAtMTUyMzAsOCArMTUzMDMsNiBAQCB2b2lkIGludGVsX2luaXRfZGlzcGxheV9ob29rcyhzdHJ1 Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCj4gIAkJZGV2X3ByaXYtPmRpc3BsYXkuY3J0 Y19kaXNhYmxlID0gaTl4eF9jcnRjX2Rpc2FibGU7Cj4gIAl9Cj4gIAo+IC0JZGV2X3ByaXYtPmRp c3BsYXkudXBkYXRlX2NydGNzID0gaW50ZWxfdXBkYXRlX2NydGNzOwo+IC0KPiAgCS8qIFJldHVy bnMgdGhlIGNvcmUgZGlzcGxheSBjbG9jayBzcGVlZCAqLwo+ICAJaWYgKElTX1NLWUxBS0UoZGV2 X3ByaXYpIHx8IElTX0tBQllMQUtFKGRldl9wcml2KSkKPiAgCQlkZXZfcHJpdi0+ZGlzcGxheS5n ZXRfZGlzcGxheV9jbG9ja19zcGVlZCA9Cj4gQEAgLTE1MzIxLDYgKzE1MzkyLDExIEBAIHZvaWQg aW50ZWxfaW5pdF9kaXNwbGF5X2hvb2tzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dikKPiAgCQkJc2tsX21vZGVzZXRfY2FsY19jZGNsazsKPiAgCX0KPiAgCj4gKwlpZiAoZGV2X3By aXYtPmluZm8uZ2VuID49IDkpCj4gKwkJZGV2X3ByaXYtPmRpc3BsYXkudXBkYXRlX2NydGNzID0g c2tsX3VwZGF0ZV9jcnRjczsKPiArCWVsc2UKPiArCQlkZXZfcHJpdi0+ZGlzcGxheS51cGRhdGVf Y3J0Y3MgPSBpbnRlbF91cGRhdGVfY3J0Y3M7Cj4gKwo+ICAJc3dpdGNoIChJTlRFTF9JTkZPKGRl dl9wcml2KS0+Z2VuKSB7Cj4gIAljYXNlIDI6Cj4gIAkJZGV2X3ByaXYtPmRpc3BsYXkucXVldWVf ZmxpcCA9IGludGVsX2dlbjJfcXVldWVfZmxpcDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+ IGluZGV4IDFiNDQ0ZDMuLmNmNWRhODMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+ IEBAIC0zMzQsNiArMzM0LDcgQEAgc3RydWN0IGludGVsX2F0b21pY19zdGF0ZSB7Cj4gIAo+ICAJ LyogR2VuOSsgb25seSAqLwo+ICAJc3RydWN0IHNrbF93bV92YWx1ZXMgd21fcmVzdWx0czsKPiAr CWludCBsYXN0X2RkYl9zdGVwOwo+ICB9Owo+ICAKPiAgc3RydWN0IGludGVsX3BsYW5lX3N0YXRl IHsKPiBAQCAtNDM3LDYgKzQzOCwxMyBAQCBzdHJ1Y3Qgc2tsX3BpcGVfd20gewo+ICAJdWludDMy X3QgbGluZXRpbWU7Cj4gIH07Cj4gIAo+ICtlbnVtIHNrbF9kZGJfc3RlcCB7Cj4gKwlTS0xfRERC X1NURVBfTk9ORSA9IDAsCj4gKwlTS0xfRERCX1NURVBfTk9fT1ZFUkxBUCwKPiArCVNLTF9EREJf U1RFUF9PVkVSTEFQLAo+ICsJU0tMX0REQl9TVEVQX0ZJTkFMCj4gK307Cj4gKwo+ICBzdHJ1Y3Qg aW50ZWxfY3J0Y193bV9zdGF0ZSB7Cj4gIAl1bmlvbiB7Cj4gIAkJc3RydWN0IHsKPiBAQCAtNDY3 LDYgKzQ3NSw4IEBAIHN0cnVjdCBpbnRlbF9jcnRjX3dtX3N0YXRlIHsKPiAgCQkJLyogbWluaW11 bSBibG9jayBhbGxvY2F0aW9uICovCj4gIAkJCXVpbnQxNl90IG1pbmltdW1fYmxvY2tzW0k5MTVf TUFYX1BMQU5FU107Cj4gIAkJCXVpbnQxNl90IG1pbmltdW1feV9ibG9ja3NbSTkxNV9NQVhfUExB TkVTXTsKPiArCj4gKwkJCWVudW0gc2tsX2RkYl9zdGVwIGRkYl9yZWFsbG9jOwo+ICAJCX0gc2ts Owo+ICAJfTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Bt LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCj4gaW5kZXggNmIyNDUyYi4uODU5 NmNiOSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCj4gKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwo+IEBAIC0zODE4LDYgKzM4MTgsMTEg QEAgdm9pZCBza2xfd3JpdGVfcGxhbmVfd20oc3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMs Cj4gIAkJCSAgIHdtLT5wbGFuZVtwaXBlXVtwbGFuZV1bbGV2ZWxdKTsKPiAgCX0KPiAgCUk5MTVf V1JJVEUoUExBTkVfV01fVFJBTlMocGlwZSwgcGxhbmUpLCB3bS0+cGxhbmVfdHJhbnNbcGlwZV1b cGxhbmVdKTsKPiArCj4gKwlza2xfZGRiX2VudHJ5X3dyaXRlKGRldl9wcml2LCBQTEFORV9CVUZf Q0ZHKHBpcGUsIHBsYW5lKSwKPiArCQkJICAgICZ3bS0+ZGRiLnBsYW5lW3BpcGVdW3BsYW5lXSk7 Cj4gKwlza2xfZGRiX2VudHJ5X3dyaXRlKGRldl9wcml2LCBQTEFORV9OVjEyX0JVRl9DRkcocGlw ZSwgcGxhbmUpLAo+ICsJCQkgICAgJndtLT5kZGIueV9wbGFuZVtwaXBlXVtwbGFuZV0pOwo+ICB9 Cj4gIAo+ICB2b2lkIHNrbF93cml0ZV9jdXJzb3Jfd20oc3RydWN0IGludGVsX2NydGMgKmludGVs X2NydGMsCj4gQEAgLTM4MzksMTY4ICszODQ0LDQ2IEBAIHZvaWQgc2tsX3dyaXRlX2N1cnNvcl93 bShzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKPiAgCQkJICAgICZ3bS0+ZGRiLnBsYW5l W3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+ICB9Cj4gIAo+IC1zdGF0aWMgdm9pZCBza2xfd3JpdGVf d21fdmFsdWVzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiAtCQkJCWNvbnN0 IHN0cnVjdCBza2xfd21fdmFsdWVzICpuZXcpCj4gLXsKPiAtCXN0cnVjdCBkcm1fZGV2aWNlICpk ZXYgPSAmZGV2X3ByaXYtPmRybTsKPiAtCXN0cnVjdCBpbnRlbF9jcnRjICpjcnRjOwo+IC0KPiAt CWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Cj4gLQkJaW50IGk7Cj4gLQkJZW51bSBw aXBlIHBpcGUgPSBjcnRjLT5waXBlOwo+IC0KPiAtCQlpZiAoKG5ldy0+ZGlydHlfcGlwZXMgJiBk cm1fY3J0Y19tYXNrKCZjcnRjLT5iYXNlKSkgPT0gMCkKPiAtCQkJY29udGludWU7Cj4gLQkJaWYg KCFjcnRjLT5hY3RpdmUpCj4gLQkJCWNvbnRpbnVlOwo+IC0KPiAtCQlmb3IgKGkgPSAwOyBpIDwg aW50ZWxfbnVtX3BsYW5lcyhjcnRjKTsgaSsrKSB7Cj4gLQkJCXNrbF9kZGJfZW50cnlfd3JpdGUo ZGV2X3ByaXYsCj4gLQkJCQkJICAgIFBMQU5FX0JVRl9DRkcocGlwZSwgaSksCj4gLQkJCQkJICAg ICZuZXctPmRkYi5wbGFuZVtwaXBlXVtpXSk7Cj4gLQkJCXNrbF9kZGJfZW50cnlfd3JpdGUoZGV2 X3ByaXYsCj4gLQkJCQkJICAgIFBMQU5FX05WMTJfQlVGX0NGRyhwaXBlLCBpKSwKPiAtCQkJCQkg ICAgJm5ldy0+ZGRiLnlfcGxhbmVbcGlwZV1baV0pOwo+IC0JCX0KPiAtCj4gLQkJc2tsX2RkYl9l bnRyeV93cml0ZShkZXZfcHJpdiwgQ1VSX0JVRl9DRkcocGlwZSksCj4gLQkJCQkgICAgJm5ldy0+ ZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+IC0JfQo+IC19Cj4gLQo+IC0vKgo+IC0g KiBXaGVuIHNldHRpbmcgdXAgYSBuZXcgRERCIGFsbG9jYXRpb24gYXJyYW5nZW1lbnQsIHdlIG5l ZWQgdG8gY29ycmVjdGx5Cj4gLSAqIHNlcXVlbmNlIHRoZSB0aW1lcyBhdCB3aGljaCB0aGUgbmV3 IGFsbG9jYXRpb25zIGZvciB0aGUgcGlwZXMgYXJlIHRha2VuIGludG8KPiAtICogYWNjb3VudCBv ciB3ZSdsbCBoYXZlIHBpcGVzIGZldGNoaW5nIGZyb20gc3BhY2UgcHJldmlvdXNseSBhbGxvY2F0 ZWQgdG8KPiAtICogYW5vdGhlciBwaXBlLgo+IC0gKgo+IC0gKiBSb3VnaGx5IHRoZSBzZXF1ZW5j ZSBsb29rcyBsaWtlOgo+IC0gKiAgMS4gcmUtYWxsb2NhdGUgdGhlIHBpcGUocykgd2l0aCB0aGUg YWxsb2NhdGlvbiBiZWluZyByZWR1Y2VkIGFuZCBub3QKPiAtICogICAgIG92ZXJsYXBwaW5nIHdp dGggYSBwcmV2aW91cyBsaWdodC11cCBwaXBlIChhbm90aGVyIHdheSB0byBwdXQgaXQgaXM6Cj4g LSAqICAgICBwaXBlcyB3aXRoIHRoZWlyIG5ldyBhbGxvY2F0aW9uIHN0cmlja2x5IGluY2x1ZGVk IGludG8gdGhlaXIgb2xkIG9uZXMpLgo+IC0gKiAgMi4gcmUtYWxsb2NhdGUgdGhlIG90aGVyIHBp cGVzIHRoYXQgZ2V0IHRoZWlyIGFsbG9jYXRpb24gcmVkdWNlZAo+IC0gKiAgMy4gYWxsb2NhdGUg dGhlIHBpcGVzIGhhdmluZyB0aGVpciBhbGxvY2F0aW9uIGluY3JlYXNlZAo+IC0gKgo+IC0gKiBT dGVwcyAxLiBhbmQgMi4gYXJlIGhlcmUgdG8gdGFrZSBjYXJlIG9mIHRoZSBmb2xsb3dpbmcgY2Fz ZToKPiAtICogLSBJbml0aWFsbHkgRERCIGxvb2tzIGxpa2UgdGhpczoKPiAtICogICAgIHwgICBC ICAgIHwgICBDICAgIHwKPiAtICogLSBlbmFibGUgcGlwZSBBLgo+IC0gKiAtIHBpcGUgQiBoYXMg YSByZWR1Y2VkIEREQiBhbGxvY2F0aW9uIHRoYXQgb3ZlcmxhcHMgd2l0aCB0aGUgb2xkIHBpcGUg Qwo+IC0gKiAgIGFsbG9jYXRpb24KPiAtICogICAgIHwgIEEgIHwgIEIgIHwgIEMgIHwKPiAtICoK PiAtICogV2UgbmVlZCB0byBzZXF1ZW5jZSB0aGUgcmUtYWxsb2NhdGlvbjogQywgQiwgQSAoYW5k IG5vdCBCLCBDLCBBKS4KPiAtICovCj4gLQo+IC1zdGF0aWMgdm9pZAo+IC1za2xfd21fZmx1c2hf cGlwZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlLCBp bnQgcGFzcykKPiArc3RhdGljIGJvb2wKPiArc2tsX2RkYl9hbGxvY2F0aW9uX2VxdWFscyhjb25z dCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCj4gKwkJCSAgY29uc3Qgc3RydWN0IHNr bF9kZGJfYWxsb2NhdGlvbiAqbmV3LAo+ICsJCQkgIGVudW0gcGlwZSBwaXBlKQo+ICB7Cj4gLQlp bnQgcGxhbmU7Cj4gLQo+IC0JRFJNX0RFQlVHX0tNUygiZmx1c2ggcGlwZSAlYyAocGFzcyAlZClc biIsIHBpcGVfbmFtZShwaXBlKSwgcGFzcyk7Cj4gLQo+IC0JZm9yX2VhY2hfcGxhbmUoZGV2X3By aXYsIHBpcGUsIHBsYW5lKSB7Cj4gLQkJSTkxNV9XUklURShQTEFORV9TVVJGKHBpcGUsIHBsYW5l KSwKPiAtCQkJICAgSTkxNV9SRUFEKFBMQU5FX1NVUkYocGlwZSwgcGxhbmUpKSk7Cj4gLQl9Cj4g LQlJOTE1X1dSSVRFKENVUkJBU0UocGlwZSksIEk5MTVfUkVBRChDVVJCQVNFKHBpcGUpKSk7Cj4g KwlyZXR1cm4gbmV3LT5waXBlW3BpcGVdLnN0YXJ0ID09IG9sZC0+cGlwZVtwaXBlXS5zdGFydCAm Jgo+ICsJICAgICAgIG5ldy0+cGlwZVtwaXBlXS5lbmQgPT0gb2xkLT5waXBlW3BpcGVdLmVuZDsK PiAgfQo+ICAKPiAgc3RhdGljIGJvb2wKPiAtc2tsX2RkYl9hbGxvY2F0aW9uX2luY2x1ZGVkKGNv bnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm9sZCwKPiArc2tsX2RkYl9hbGxvY2F0aW9u X292ZXJsYXBzKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKPiArCQkJICAgIGNvbnN0 IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm9sZCwKPiAgCQkJICAgIGNvbnN0IHN0cnVjdCBz a2xfZGRiX2FsbG9jYXRpb24gKm5ldywKPiAgCQkJICAgIGVudW0gcGlwZSBwaXBlKQo+ICB7Cj4g LQl1aW50MTZfdCBvbGRfc2l6ZSwgbmV3X3NpemU7Cj4gLQo+IC0Jb2xkX3NpemUgPSBza2xfZGRi X2VudHJ5X3NpemUoJm9sZC0+cGlwZVtwaXBlXSk7Cj4gLQluZXdfc2l6ZSA9IHNrbF9kZGJfZW50 cnlfc2l6ZSgmbmV3LT5waXBlW3BpcGVdKTsKPiAtCj4gLQlyZXR1cm4gb2xkX3NpemUgIT0gbmV3 X3NpemUgJiYKPiAtCSAgICAgICBuZXctPnBpcGVbcGlwZV0uc3RhcnQgPj0gb2xkLT5waXBlW3Bp cGVdLnN0YXJ0ICYmCj4gLQkgICAgICAgbmV3LT5waXBlW3BpcGVdLmVuZCA8PSBvbGQtPnBpcGVb cGlwZV0uZW5kOwo+IC19Cj4gLQo+IC1zdGF0aWMgdm9pZCBza2xfZmx1c2hfd21fdmFsdWVzKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiAtCQkJCXN0cnVjdCBza2xfd21fdmFs dWVzICpuZXdfdmFsdWVzKQo+IC17Cj4gLQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gJmRldl9w cml2LT5kcm07Cj4gLQlzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpjdXJfZGRiLCAqbmV3X2Rk YjsKPiAtCWJvb2wgcmVhbGxvY2F0ZWRbSTkxNV9NQVhfUElQRVNdID0ge307Cj4gLQlzdHJ1Y3Qg aW50ZWxfY3J0YyAqY3J0YzsKPiAtCWVudW0gcGlwZSBwaXBlOwo+IC0KPiAtCW5ld19kZGIgPSAm bmV3X3ZhbHVlcy0+ZGRiOwo+IC0JY3VyX2RkYiA9ICZkZXZfcHJpdi0+d20uc2tsX2h3LmRkYjsK PiAtCj4gLQkvKgo+IC0JICogRmlyc3QgcGFzczogZmx1c2ggdGhlIHBpcGVzIHdpdGggdGhlIG5l dyBhbGxvY2F0aW9uIGNvbnRhaW5lZCBpbnRvCj4gLQkgKiB0aGUgb2xkIHNwYWNlLgo+IC0JICoK PiAtCSAqIFdlJ2xsIHdhaXQgZm9yIHRoZSB2Ymxhbmsgb24gdGhvc2UgcGlwZXMgdG8gZW5zdXJl IHdlIGNhbiBzYWZlbHkKPiAtCSAqIHJlLWFsbG9jYXRlIHRoZSBmcmVlZCBzcGFjZSB3aXRob3V0 IHRoaXMgcGlwZSBmZXRjaGluZyBmcm9tIGl0Lgo+IC0JICovCj4gLQlmb3JfZWFjaF9pbnRlbF9j cnRjKGRldiwgY3J0Yykgewo+IC0JCWlmICghY3J0Yy0+YWN0aXZlKQo+IC0JCQljb250aW51ZTsK PiAtCj4gLQkJcGlwZSA9IGNydGMtPnBpcGU7Cj4gLQo+IC0JCWlmICghc2tsX2RkYl9hbGxvY2F0 aW9uX2luY2x1ZGVkKGN1cl9kZGIsIG5ld19kZGIsIHBpcGUpKQo+IC0JCQljb250aW51ZTsKPiAt Cj4gLQkJc2tsX3dtX2ZsdXNoX3BpcGUoZGV2X3ByaXYsIHBpcGUsIDEpOwo+IC0JCWludGVsX3dh aXRfZm9yX3ZibGFuayhkZXYsIHBpcGUpOwo+IC0KPiAtCQlyZWFsbG9jYXRlZFtwaXBlXSA9IHRy dWU7Cj4gLQl9Cj4gLQo+IC0KPiAtCS8qCj4gLQkgKiBTZWNvbmQgcGFzczogZmx1c2ggdGhlIHBp cGVzIHRoYXQgYXJlIGhhdmluZyB0aGVpciBhbGxvY2F0aW9uCj4gLQkgKiByZWR1Y2VkLCBidXQg b3ZlcmxhcHBpbmcgd2l0aCBhIHByZXZpb3VzIGFsbG9jYXRpb24uCj4gLQkgKgo+IC0JICogSGVy ZSBhcyB3ZWxsIHdlIG5lZWQgdG8gd2FpdCBmb3IgdGhlIHZibGFuayB0byBtYWtlIHN1cmUgdGhl IGZyZWVkCj4gLQkgKiBzcGFjZSBpcyBub3QgdXNlZCBhbnltb3JlLgo+IC0JICovCj4gLQlmb3Jf ZWFjaF9pbnRlbF9jcnRjKGRldiwgY3J0Yykgewo+IC0JCWlmICghY3J0Yy0+YWN0aXZlKQo+IC0J CQljb250aW51ZTsKPiAtCj4gLQkJcGlwZSA9IGNydGMtPnBpcGU7Cj4gLQo+IC0JCWlmIChyZWFs bG9jYXRlZFtwaXBlXSkKPiAtCQkJY29udGludWU7Cj4gLQo+IC0JCWlmIChza2xfZGRiX2VudHJ5 X3NpemUoJm5ld19kZGItPnBpcGVbcGlwZV0pIDwKPiAtCQkgICAgc2tsX2RkYl9lbnRyeV9zaXpl KCZjdXJfZGRiLT5waXBlW3BpcGVdKSkgewo+IC0JCQlza2xfd21fZmx1c2hfcGlwZShkZXZfcHJp diwgcGlwZSwgMik7Cj4gLQkJCWludGVsX3dhaXRfZm9yX3ZibGFuayhkZXYsIHBpcGUpOwo+IC0J CQlyZWFsbG9jYXRlZFtwaXBlXSA9IHRydWU7Cj4gLQkJfQo+IC0JfQo+IC0KPiAtCS8qCj4gLQkg KiBUaGlyZCBwYXNzOiBmbHVzaCB0aGUgcGlwZXMgdGhhdCBnb3QgbW9yZSBzcGFjZSBhbGxvY2F0 ZWQuCj4gLQkgKgo+IC0JICogV2UgZG9uJ3QgbmVlZCB0byBhY3RpdmVseSB3YWl0IGZvciB0aGUg dXBkYXRlIGhlcmUsIG5leHQgdmJsYW5rCj4gLQkgKiB3aWxsIGp1c3QgZ2V0IG1vcmUgRERCIHNw YWNlIHdpdGggdGhlIGNvcnJlY3QgV00gdmFsdWVzLgo+IC0JICovCj4gLQlmb3JfZWFjaF9pbnRl bF9jcnRjKGRldiwgY3J0Yykgewo+IC0JCWlmICghY3J0Yy0+YWN0aXZlKQo+IC0JCQljb250aW51 ZTsKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBzdGF0ZS0+ZGV2Owo+ICsJc3RydWN0IGlu dGVsX2NydGMgKmludGVsX2NydGM7Cj4gKwllbnVtIHBpcGUgb3RoZXJwOwo+ICAKPiAtCQlwaXBl ID0gY3J0Yy0+cGlwZTsKPiArCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBpbnRlbF9jcnRjKSB7 Cj4gKwkJb3RoZXJwID0gaW50ZWxfY3J0Yy0+cGlwZTsKPiAgCj4gIAkJLyoKPiAtCQkgKiBBdCB0 aGlzIHBvaW50LCBvbmx5IHRoZSBwaXBlcyBtb3JlIHNwYWNlIHRoYW4gYmVmb3JlIGFyZQo+IC0J CSAqIGxlZnQgdG8gcmUtYWxsb2NhdGUuCj4gKwkJICogV2hlbiBjaGVja2luZyBmb3Igb3Zlcmxh cHMsIHdlIGRvbid0IHdhbnQgdG86Cj4gKwkJICogIC0gQ29tcGFyZSBhZ2FpbnN0IG91cnNlbHZl cwo+ICsJCSAqICAtIENvbXBhcmUgYWdhaW5zdCBwaXBlcyB0aGF0IHdpbGwgYmUgZGlzYWJsZWQg aW4gc3RlcCAwCj4gKwkJICogIC0gQ29tcGFyZSBhZ2FpbnN0IHBpcGVzIHRoYXQgd29uJ3QgYmUg ZW5hYmxlZCB1bnRpbCBzdGVwIDMKPiAgCQkgKi8KPiAtCQlpZiAocmVhbGxvY2F0ZWRbcGlwZV0p Cj4gKwkJaWYgKG90aGVycCA9PSBwaXBlIHx8ICFuZXctPnBpcGVbb3RoZXJwXS5lbmQgfHwKPiAr CQkgICAgIW9sZC0+cGlwZVtvdGhlcnBdLmVuZCkKPiAgCQkJY29udGludWU7Cj4gIAo+IC0JCXNr bF93bV9mbHVzaF9waXBlKGRldl9wcml2LCBwaXBlLCAzKTsKPiArCQlpZiAoKG5ldy0+cGlwZVtw aXBlXS5zdGFydCA+PSBvbGQtPnBpcGVbb3RoZXJwXS5zdGFydCAmJgo+ICsJCSAgICAgbmV3LT5w aXBlW3BpcGVdLnN0YXJ0IDwgb2xkLT5waXBlW290aGVycF0uZW5kKSB8fAo+ICsJCSAgICAob2xk LT5waXBlW290aGVycF0uc3RhcnQgPj0gbmV3LT5waXBlW3BpcGVdLnN0YXJ0ICYmCj4gKwkJICAg ICBvbGQtPnBpcGVbb3RoZXJwXS5zdGFydCA8IG5ldy0+cGlwZVtwaXBlXS5lbmQpKQo+ICsJCQly ZXR1cm4gdHJ1ZTsKPiAgCX0KPiArCj4gKwlyZXR1cm4gZmFsc2U7Cj4gIH0KPiAgCj4gIHN0YXRp YyBpbnQgc2tsX3VwZGF0ZV9waXBlX3dtKHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3N0YXRlLAo+ IEBAIC00MDQzLDggKzM5MjYsMTAgQEAgc2tsX2NvbXB1dGVfZGRiKHN0cnVjdCBkcm1fYXRvbWlj X3N0YXRlICpzdGF0ZSkKPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBzdGF0ZS0+ZGV2Owo+ ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShkZXYpOwo+ICAJ c3RydWN0IGludGVsX2F0b21pY19zdGF0ZSAqaW50ZWxfc3RhdGUgPSB0b19pbnRlbF9hdG9taWNf c3RhdGUoc3RhdGUpOwo+ICsJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZTsKPiAgCXN0 cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjOwo+IC0Jc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlv biAqZGRiID0gJmludGVsX3N0YXRlLT53bV9yZXN1bHRzLmRkYjsKPiArCXN0cnVjdCBza2xfZGRi X2FsbG9jYXRpb24gKm9sZF9kZGIgPSAmZGV2X3ByaXYtPndtLnNrbF9ody5kZGI7Cj4gKwlzdHJ1 Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpuZXdfZGRiID0gJmludGVsX3N0YXRlLT53bV9yZXN1bHRz LmRkYjsKPiAgCXVpbnQzMl90IHJlYWxsb2NfcGlwZXMgPSBwaXBlc19tb2RpZmllZChzdGF0ZSk7 Cj4gIAlpbnQgcmV0Owo+ICAKPiBAQCAtNDA3NiwxMyArMzk2MSwxMSBAQCBza2xfY29tcHV0ZV9k ZGIoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ICAJfQo+ICAKPiAgCWZvcl9lYWNo X2ludGVsX2NydGNfbWFzayhkZXYsIGludGVsX2NydGMsIHJlYWxsb2NfcGlwZXMpIHsKPiAtCQlz dHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3N0YXRlOwo+IC0KPiAgCQljc3RhdGUgPSBpbnRlbF9h dG9taWNfZ2V0X2NydGNfc3RhdGUoc3RhdGUsIGludGVsX2NydGMpOwo+ICAJCWlmIChJU19FUlIo Y3N0YXRlKSkKPiAgCQkJcmV0dXJuIFBUUl9FUlIoY3N0YXRlKTsKPiAgCj4gLQkJcmV0ID0gc2ts X2FsbG9jYXRlX3BpcGVfZGRiKGNzdGF0ZSwgZGRiKTsKPiArCQlyZXQgPSBza2xfYWxsb2NhdGVf cGlwZV9kZGIoY3N0YXRlLCBuZXdfZGRiKTsKPiAgCQlpZiAocmV0KQo+ICAJCQlyZXR1cm4gcmV0 Owo+ICAKPiBAQCAtNDA5MSw2ICszOTc0LDczIEBAIHNrbF9jb21wdXRlX2RkYihzdHJ1Y3QgZHJt X2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gIAkJCXJldHVybiByZXQ7Cj4gIAl9Cj4gIAo+ICsJLyoK PiArCSAqIFdoZW4gc2V0dGluZyB1cCBhIG5ldyBEREIgYWxsb2NhdGlvbiBhcnJhbmdlbWVudCwg d2UgbmVlZCB0bwo+ICsJICogY29ycmVjdGx5IHNlcXVlbmNlIHRoZSB0aW1lcyBhdCB3aGljaCB0 aGUgbmV3IGFsbG9jYXRpb25zIGZvciB0aGUKPiArCSAqIHBpcGVzIGFyZSB0YWtlbiBpbnRvIGFj Y291bnQgb3Igd2UnbGwgaGF2ZSBwaXBlcyBmZXRjaGluZyBmcm9tIHNwYWNlCj4gKwkgKiBwcmV2 aW91c2x5IGFsbG9jYXRlZCB0byBhbm90aGVyIHBpcGUuCj4gKwkgKgo+ICsJICogUm91Z2hseSB0 aGUgZmluYWwgc2VxdWVuY2Ugd2Ugd2FudCBsb29rcyBsaWtlIHRoaXM6Cj4gKwkgKiAgMS4gRGlz YWJsZSBhbnkgcGlwZXMgd2UncmUgbm90IGdvaW5nIHRvIGJlIHVzaW5nIGFueW1vcmUKPiArCSAq ICAyLiBSZWFsbG9jYXRlIGFsbCBvZiB0aGUgYWN0aXZlIHBpcGVzIHdob3NlIG5ldyBkZGIgYWxs b2NhdGlvbnMKPiArCSAqICB3b24ndCBvdmVybGFwIHdpdGggYW5vdGhlciBhY3RpdmUgcGlwZSdz IGRkYiBhbGxvY2F0aW9uLgo+ICsJICogIDMuIFJlYWxsb2NhdGUgcmVtYWluaW5nIGFjdGl2ZSBw aXBlcywgaWYgYW55Lgo+ICsJICogIDQuIEVuYWJsZSBhbnkgbmV3IHBpcGVzLCBpZiBhbnkuCj4g KwkgKgo+ICsJICogRXhhbXBsZToKPiArCSAqIEluaXRpYWxseSBEREIgbG9va3MgbGlrZSB0aGlz Ogo+ICsJICogICB8ICAgQiAgICB8ICAgQyAgICB8Cj4gKwkgKiBBbmQgdGhlIGZpbmFsIEREQiBz aG91bGQgbG9vayBsaWtlIHRoaXM6Cj4gKwkgKiAgIHwgIEIgIHwgIEMgIHwgIEEgIHwKPiArCSAq Cj4gKwkgKiAxLiBXZSdyZSBub3QgZGlzYWJsaW5nIGFueSBwaXBlcywgc28gZG8gbm90aGluZyBv biB0aGlzIHN0ZXAuCj4gKwkgKiAyLiBQaXBlIEIncyBuZXcgYWxsb2NhdGlvbiB3b3VsZG4ndCBv dmVybGFwIHdpdGggcGlwZSBDLCBob3dldmVyCj4gKwkgKiBwaXBlIEMncyBuZXcgYWxsb2NhdGlv biBkb2VzIG92ZXJsYXAgd2l0aCBwaXBlIEIncyBjdXJyZW50Cj4gKwkgKiBhbGxvY2F0aW9uLiBS ZWFsbG9jYXRlIEIgZmlyc3Qgc28gdGhlIEREQiBsb29rcyBsaWtlIHRoaXM6Cj4gKwkgKiAgIHwg IEIgIHx4eHwgICBDICAgIHwKPiArCSAqIDMuIE5vdyB3ZSBjYW4gc2FmZWx5IHJlYWxsb2NhdGUg cGlwZSBDIHRvIGl0J3MgbmV3IGxvY2F0aW9uOgo+ICsJICogICB8ICBCICB8ICBDICB8eHh4eHh8 Cj4gKwkgKiA0LiBFbmFibGUgYW55IHJlbWFpbmluZyBwaXBlcywgaW4gdGhpcyBjYXNlIEEKPiAr CSAqICAgfCAgQiAgfCAgQyAgfCAgQSAgfAoKSXQncyB3b3J0aCBub3RpbmcgdGhhdCB0aGlzIHNl cXVlbmNlIHdpbGwgd29yayBmaW5lIGZvciB0aGUgdGhyZWUgcGlwZQpjYXNlIHdlIGhhdmUgaW4g Z2VuOSBzaW5jZSB3aGVuIGFkZGluZyBvciByZW1vdmluZyBhIHBpcGUgd2UgbmV2ZXIgaGF2ZQph IHNpdHVhdGlvbiB3aGVyZSBtdWx0aXBsZSBwaXBlcyBhcmUgcHJvY2Vzc2VkIGluIHRoZSAnb3Zl cmxhcCcgc3RlcAooc3RlcCAzKS4gIEJ1dCBpZiBzb21lIGZ1dHVyZSBwbGF0Zm9ybSBkZWNpZGVz IHRvIGFkZCBtb3JlIHBpcGVzIHdoaWxlCm1haW50YWluaW5nIHRoZSBzYW1lIGdlbmVyYWwgRERC IHByb2dyYW1taW5nIHN0eWxlLCB0aGlzIHdpbGwgYnJlYWsgZG93bgpzaW5jZSB3ZSdsbCBuZWVk IHRvIGVuc3VyZSBpbnRlbGxpZ2VudCBvcmRlcmluZyBvZiB0aGUgcGlwZXMgYmVpbmcKcHJvY2Vz c2VkIGluIHN0ZXAgMy4gIEUuZy4sIHdpdGggbmFpdmUgb3JkZXJpbmcgb2Ygc3RlcCAzIHdlIGNv dWxkIGhhdmUKCiAgICAgICAgQUFBQkJCQ0NDREREIC0+IEFBQUFCQkJCQ0NDQzoKICAgICAgICAg ICAgQUFBQkJCQ0NDX19fIChzdGVwIDEpCiAgICAgICAgICAgIEFBQUJCQl9fQ0NDQyAoc3RlcCAy KQogICAgICAgICAgICBBQUEhQkJfX0NDQ0MgKHN0ZXAgM2EsIHdvb3BzKQoKPiArCSAqCj4gKwkg KiBBcyB3ZWxsLCBiZXR3ZWVuIGV2ZXJ5IHBpcGUgcmVhbGxvY2F0aW9uIHdlIGhhdmUgdG8gd2Fp dCBmb3IgYQo+ICsJICogdmJsYW5rIG9uIHRoZSBwaXBlIHNvIHRoYXQgd2UgZW5zdXJlIGl0J3Mg bmV3IGFsbG9jYXRpb24gaGFzIHRha2VuCj4gKwkgKiBlZmZlY3QgYnkgdGhlIHRpbWUgd2Ugc3Rh cnQgbW92aW5nIHRoZSBuZXh0IHBpcGUuIFRoaXMgY2FuIGJlCj4gKwkgKiBza2lwcGVkIG9uIHRo ZSBsYXN0IHN0ZXAgd2UgbmVlZCB0byBwZXJmb3JtLCB3aGljaCBpcyB3aHkgd2Uga2VlcAo+ICsJ ICogdHJhY2sgb2YgdGhhdCBpbmZvcm1hdGlvbiBoZXJlLiBGb3IgZXhhbXBsZSwgaWYgd2UndmUg cmVhbGxvY2F0ZWQKPiArCSAqIGFsbCB0aGUgcGlwZXMgdGhhdCBuZWVkIGNoYW5naW5nIGJ5IHRo ZSB0aW1lIHdlIHJlYWNoIHN0ZXAgMywgd2UgY2FuCj4gKwkgKiBmaW5pc2ggd2l0aG91dCB3YWl0 aW5nIGZvciB0aGUgcGlwZXMgd2UgY2hhbmdlZCBpbiBzdGVwIDMgdG8gdXBkYXRlLgo+ICsJICov Cj4gKwlmb3JfZWFjaF9pbnRlbF9jcnRjX21hc2soZGV2LCBpbnRlbF9jcnRjLCByZWFsbG9jX3Bp cGVzKSB7Cj4gKwkJZW51bSBwaXBlIHBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwo+ICsJCWVudW0g c2tsX2RkYl9zdGVwIHN0ZXA7Cj4gKwo+ICsJCWNzdGF0ZSA9IGludGVsX2F0b21pY19nZXRfY3J0 Y19zdGF0ZShzdGF0ZSwgaW50ZWxfY3J0Yyk7Cj4gKwkJaWYgKElTX0VSUihjc3RhdGUpKQo+ICsJ CQlyZXR1cm4gUFRSX0VSUihjc3RhdGUpOwo+ICsKPiArCQkvKiBTdGVwIDE6IFBpcGVzIHdlJ3Jl IGRpc2FibGluZyAvIGhhdmVuJ3QgY2hhbmdlZCAqLwo+ICsJCWlmIChza2xfZGRiX2FsbG9jYXRp b25fZXF1YWxzKG9sZF9kZGIsIG5ld19kZGIsIHBpcGUpIHx8Cj4gKwkJICAgIG5ld19kZGItPnBp cGVbcGlwZV0uZW5kID09IDApIHsKPiArCQkJc3RlcCA9IFNLTF9EREJfU1RFUF9OT05FOwo+ICsJ CS8qIFN0ZXAgMi0zOiBBY3RpdmUgcGlwZXMgd2UncmUgcmVhbGxvY2F0aW5nICovCj4gKwkJfSBl bHNlIGlmIChvbGRfZGRiLT5waXBlW3BpcGVdLmVuZCAhPSAwKSB7Cj4gKwkJCWlmIChza2xfZGRi X2FsbG9jYXRpb25fb3ZlcmxhcHMoc3RhdGUsIG9sZF9kZGIsIG5ld19kZGIsCj4gKwkJCQkJCQlw aXBlKSkKPiArCQkJCXN0ZXAgPSBTS0xfRERCX1NURVBfT1ZFUkxBUDsKPiArCQkJZWxzZQo+ICsJ CQkJc3RlcCA9IFNLTF9EREJfU1RFUF9OT19PVkVSTEFQOwo+ICsJCS8qIFN0ZXAgNDogUGlwZXMg d2UncmUgZW5hYmxpbmcgKi8KPiArCQl9IGVsc2Ugewo+ICsJCQlzdGVwID0gU0tMX0REQl9TVEVQ X0ZJTkFMOwo+ICsJCX0KPiArCj4gKwkJY3N0YXRlLT53bS5za2wuZGRiX3JlYWxsb2MgPSBzdGVw Owo+ICsKPiArCQlpZiAoc3RlcCA+IGludGVsX3N0YXRlLT5sYXN0X2RkYl9zdGVwKQo+ICsJCQlp bnRlbF9zdGF0ZS0+bGFzdF9kZGJfc3RlcCA9IHN0ZXA7Cj4gKwl9Cj4gKwo+ICAJcmV0dXJuIDA7 Cj4gIH0KPiAgCj4gQEAgLTQxMTUsMTAgKzQwNjUsMTMgQEAgc2tsX2NvcHlfd21fZm9yX3BpcGUo c3RydWN0IHNrbF93bV92YWx1ZXMgKmRzdCwKPiAgc3RhdGljIGludAo+ICBza2xfY29tcHV0ZV93 bShzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gIHsKPiArCXN0cnVjdCBkcm1faTkx NV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoc3RhdGUtPmRldik7Cj4gIAlzdHJ1Y3QgZHJt X2NydGMgKmNydGM7Cj4gIAlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNzdGF0ZTsKPiAgCXN0cnVj dCBpbnRlbF9hdG9taWNfc3RhdGUgKmludGVsX3N0YXRlID0gdG9faW50ZWxfYXRvbWljX3N0YXRl KHN0YXRlKTsKPiAgCXN0cnVjdCBza2xfd21fdmFsdWVzICpyZXN1bHRzID0gJmludGVsX3N0YXRl LT53bV9yZXN1bHRzOwo+ICsJc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqb2xkX2RkYiA9ICZk ZXZfcHJpdi0+d20uc2tsX2h3LmRkYjsKPiArCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5l d19kZGIgPSAmcmVzdWx0cy0+ZGRiOwo+ICAJc3RydWN0IHNrbF9waXBlX3dtICpwaXBlX3dtOwo+ ICAJYm9vbCBjaGFuZ2VkID0gZmFsc2U7Cj4gIAlpbnQgcmV0LCBpOwo+IEBAIC00MTU3LDcgKzQx MTAsMTAgQEAgc2tsX2NvbXB1dGVfd20oc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ ICAJCXN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjID0gdG9faW50ZWxfY3J0YyhjcnRjKTsK PiAgCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqaW50ZWxfY3N0YXRlID0KPiAgCQkJdG9faW50 ZWxfY3J0Y19zdGF0ZShjc3RhdGUpOwo+ICsJCWVudW0gc2tsX2RkYl9zdGVwIHN0ZXA7Cj4gKwkJ ZW51bSBwaXBlIHBpcGU7Cj4gIAo+ICsJCXBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwo+ICAJCXBp cGVfd20gPSAmaW50ZWxfY3N0YXRlLT53bS5za2wub3B0aW1hbDsKPiAgCQlyZXQgPSBza2xfdXBk YXRlX3BpcGVfd20oY3N0YXRlLCAmcmVzdWx0cy0+ZGRiLCBwaXBlX3dtLAo+ICAJCQkJCSAmY2hh bmdlZCk7Cj4gQEAgLTQxNzIsNyArNDEyOCwxOCBAQCBza2xfY29tcHV0ZV93bShzdHJ1Y3QgZHJt X2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gIAkJCWNvbnRpbnVlOwo+ICAKPiAgCQlpbnRlbF9jc3Rh dGUtPnVwZGF0ZV93bV9wcmUgPSB0cnVlOwo+ICsJCXN0ZXAgPSBpbnRlbF9jc3RhdGUtPndtLnNr bC5kZGJfcmVhbGxvYzsKPiAgCQlza2xfY29tcHV0ZV93bV9yZXN1bHRzKGNydGMtPmRldiwgcGlw ZV93bSwgcmVzdWx0cywgaW50ZWxfY3J0Yyk7Cj4gKwo+ICsJCWlmICghc2tsX2RkYl9lbnRyeV9l cXVhbCgmb2xkX2RkYi0+cGlwZVtwaXBlXSwKPiArCQkJCQkgJm5ld19kZGItPnBpcGVbcGlwZV0p KSB7Cj4gKwkJCURSTV9ERUJVR19LTVMoCj4gKwkJCSAgICAiRERCIGNoYW5nZXMgZm9yIFtDUlRD OiVkOnBpcGUgJWNdOiAoJTNkIC0gJTNkKSAtPiAoJTNkIC0gJTNkKSBvbiBzdGVwICVkXG4iLAo+ ICsJCQkgICAgaW50ZWxfY3J0Yy0+YmFzZS5iYXNlLmlkLCBwaXBlX25hbWUocGlwZSksCj4gKwkJ CSAgICBvbGRfZGRiLT5waXBlW3BpcGVdLnN0YXJ0LCBvbGRfZGRiLT5waXBlW3BpcGVdLmVuZCwK PiArCQkJICAgIG5ld19kZGItPnBpcGVbcGlwZV0uc3RhcnQsIG5ld19kZGItPnBpcGVbcGlwZV0u ZW5kLAo+ICsJCQkgICAgc3RlcCk7Cj4gKwkJfQo+ICAJfQo+ICAKPiAgCXJldHVybiAwOwo+IEBA IC00MTk2LDggKzQxNjMsMjAgQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV93bShzdHJ1Y3QgZHJt X2NydGMgKmNydGMpCj4gIAo+ICAJbXV0ZXhfbG9jaygmZGV2X3ByaXYtPndtLndtX211dGV4KTsK PiAgCj4gLQlza2xfd3JpdGVfd21fdmFsdWVzKGRldl9wcml2LCByZXN1bHRzKTsKPiAtCXNrbF9m bHVzaF93bV92YWx1ZXMoZGV2X3ByaXYsIHJlc3VsdHMpOwo+ICsJLyoKPiArCSAqIElmIHRoaXMg cGlwZSBpc24ndCBhY3RpdmUgYWxyZWFkeSwgd2UncmUgZ29pbmcgdG8gYmUgZW5hYmxpbmcgaXQK PiArCSAqIHZlcnkgc29vbi4gU2luY2UgaXQncyBzYWZlIHRvIHVwZGF0ZSB0aGVzZSB3aGlsZSB0 aGUgcGlwZSdzIHNodXQgb2ZmLAo+ICsJICoganVzdCBkbyBzbyBoZXJlLiBBbHJlYWR5IGFjdGl2 ZSBwaXBlcyB3aWxsIGhhdmUgdGhlaXIgd2F0ZXJtYXJrcwo+ICsJICogdXBkYXRlZCBvbmNlIHdl IHVwZGF0ZSB0aGVpciBwbGFuZXMuCj4gKwkgKi8KPiArCWlmICghaW50ZWxfY3J0Yy0+YWN0aXZl KSB7Cj4gKwkJaW50IHBsYW5lOwo+ICsKPiArCQlmb3IgKHBsYW5lID0gMDsgcGxhbmUgPCBpbnRl bF9udW1fcGxhbmVzKGludGVsX2NydGMpOyBwbGFuZSsrKQo+ICsJCQlza2xfd3JpdGVfcGxhbmVf d20oaW50ZWxfY3J0YywgcmVzdWx0cywgcGxhbmUpOwo+ICsKPiArCQlza2xfd3JpdGVfY3Vyc29y X3dtKGludGVsX2NydGMsIHJlc3VsdHMpOwo+ICsJfQoKRG8gd2UgYWN0dWFsbHkgbmVlZCB0aGlz PyAgRXZlbiBpZiB0aGUgcGlwZSBpcyBpbiB0aGUgcHJvY2VzcyBvZiBiZWluZwplbmFibGVkLCBh bGwgb2YgdGhlc2UgcmVnaXN0ZXJzIHNob3VsZCBzdGlsbCBiZSBwcm9ncmFtbWVkIGF0IHRoZSBz YW1lCnRpbWUgYXMgdGhlIHBsYW5lIHJlZ2lzdGVycywgcmlnaHQ/ICBUaG9zZSByZWdpc3RlciB3 cml0ZXMgYXJlIGJhc2VkIG9uCmNydGMtPnN0YXRlLT5hY3RpdmUgcmF0aGVyIHRoYW4gY3J0Yy0+ YWN0aXZlIHNvIHRoZXkgc2hvdWxkIGhhcHBlbiB3aGVuCnRoZXkgbmVlZCB0by4KCk9uIHRoZSBv dGhlciBoYW5kLCBpZiB3ZSB3cml0ZSB0aGVzZSB3aGVuIHRoZSBwaXBlIGlzIG9mZiBhbmQgaXNu J3QgaW4KdGhlIHByb2Nlc3Mgb2YgYmVpbmcgZW5hYmxlZCwgdGhlbiB3ZSBtYXkgbm90IGhhdmUg dGhlIHBvd2VyIHdlbGwgdHVybmVkCm9uLCBzbyB3ZSdsbCBnZXQgdW5jbGFpbWVkIHJlZ2lzdGVy IHdhcm5pbmdzLgoKCk1hdHQKCj4gIAo+ICAJLyoKPiAgCSAqIFN0b3JlIHRoZSBuZXcgY29uZmln dXJhdGlvbiAoYnV0IG9ubHkgZm9yIHRoZSBwaXBlcyB0aGF0IGhhdmUKPiAtLSAKPiAyLjcuNAo+ IAoKLS0gCk1hdHQgUm9wZXIKR3JhcGhpY3MgU29mdHdhcmUgRW5naW5lZXIKSW9URyBQbGF0Zm9y bSBFbmFibGluZyAmIERldmVsb3BtZW50CkludGVsIENvcnBvcmF0aW9uCig5MTYpIDM1Ni0yNzk1 Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdm eCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756909AbcHCA1N (ORCPT ); Tue, 2 Aug 2016 20:27:13 -0400 Received: from mga03.intel.com ([134.134.136.65]:11805 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755866AbcHCA1D (ORCPT ); Tue, 2 Aug 2016 20:27:03 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,463,1464678000"; d="scan'208";a="1028660320" Date: Tue, 2 Aug 2016 17:11:15 -0700 From: Matt Roper To: Lyude Cc: intel-gfx@lists.freedesktop.org, Ville =?iso-8859-1?Q?Syrj=E4l=E4?= , Maarten Lankhorst , Daniel Vetter , Radhakrishna Sripada , Hans de Goede , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v5 6/6] drm/i915/skl: Update DDB values atomically with wms/plane attrs Message-ID: <20160803001115.GC32025@intel.com> References: <1470163975-30467-1-git-send-email-cpaul@redhat.com> <1470163975-30467-7-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: <1470163975-30467-7-git-send-email-cpaul@redhat.com> User-Agent: Mutt/1.5.20 (2009-06-14) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Aug 02, 2016 at 02:52:54PM -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. > > Fixes: 0e8fb7ba7ca5 ("drm/i915/skl: Flush the WM configuration") > Fixes: 8211bd5bdf5e ("drm/i915/skl: Program the DDB allocation") > Signed-off-by: Lyude > [omitting CC for stable, since this patch will need to be changed for > such backports first] > 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 | 10 ++ > drivers/gpu/drm/i915/intel_pm.c | 287 ++++++++++++++++------------------- > 3 files changed, 231 insertions(+), 166 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index d985b5b..db271d6 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -12909,16 +12909,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); > + } > } > } > > @@ -13670,6 +13677,72 @@ static void intel_update_crtcs(struct drm_atomic_state *state, > } > } > > +static inline void > +skl_do_ddb_step(struct drm_atomic_state *state, > + enum skl_ddb_step step) > +{ > + struct intel_atomic_state *intel_state = to_intel_atomic_state(state); > + struct drm_crtc *crtc; > + struct drm_crtc_state *old_crtc_state; > + unsigned int crtc_vblank_mask; /* unused */ > + int i; > + > + for_each_crtc_in_state(state, crtc, old_crtc_state, i) { > + struct intel_crtc *intel_crtc = to_intel_crtc(crtc); > + struct intel_crtc_state *cstate = > + to_intel_crtc_state(crtc->state); > + bool vblank_wait = false; > + > + if (cstate->wm.skl.ddb_realloc != step || !crtc->state->active) > + continue; > + > + /* > + * If we're changing the ddb allocation of this pipe to make > + * room for another pipe, we have to wait for the pipe's ddb > + * allocations to actually update by waiting for a vblank. > + * Otherwise we risk the next pipe updating before this pipe > + * finishes, resulting in the pipe fetching from ddb space for > + * the wrong pipe. > + * > + * However, if we know we don't have any more pipes to move > + * around, we can skip this wait and the new ddb allocation > + * will take effect at the start of the next vblank. > + */ > + switch (step) { > + case SKL_DDB_STEP_NO_OVERLAP: > + case SKL_DDB_STEP_OVERLAP: > + if (step != intel_state->last_ddb_step) > + vblank_wait = true; > + > + /* drop through */ > + case SKL_DDB_STEP_FINAL: > + DRM_DEBUG_KMS( > + "Updating [CRTC:%d:pipe %c] for DDB step %d\n", > + crtc->base.id, pipe_name(intel_crtc->pipe), > + step); > + > + case SKL_DDB_STEP_NONE: > + break; > + } > + > + intel_update_crtc(crtc, state, old_crtc_state, > + &crtc_vblank_mask); > + > + if (vblank_wait) > + intel_wait_for_vblank(state->dev, intel_crtc->pipe); We only technically need to wait at the end of a step, not on each individual CRTC within a step. Since we only have three pipes total, that usually winds up being the same thing, but the one case we can optimize slightly is when we re-enable pipe B while A and C are already on. AAAAAACCCCCC (initial state) AAAA____CCCC (step 1: reduce both A and C) AAAABBBBCCCC (final step) We just need to wait until both A and C have had a vblank (as intel_atomic_wait_for_vblanks() does) rather than doing each sequentially. > + } > +} > + > +static void skl_update_crtcs(struct drm_atomic_state *state, > + unsigned int *crtc_vblank_mask) > +{ > + struct intel_atomic_state *intel_state = to_intel_atomic_state(state); > + enum skl_ddb_step step; > + > + for (step = 0; step <= intel_state->last_ddb_step; step++) > + skl_do_ddb_step(state, step); > +} > + > static void intel_atomic_commit_tail(struct drm_atomic_state *state) > { > struct drm_device *dev = state->dev; > @@ -15230,8 +15303,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 = > @@ -15321,6 +15392,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 1b444d3..cf5da83 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -334,6 +334,7 @@ struct intel_atomic_state { > > /* Gen9+ only */ > struct skl_wm_values wm_results; > + int last_ddb_step; > }; > > struct intel_plane_state { > @@ -437,6 +438,13 @@ struct skl_pipe_wm { > uint32_t linetime; > }; > > +enum skl_ddb_step { > + SKL_DDB_STEP_NONE = 0, > + SKL_DDB_STEP_NO_OVERLAP, > + SKL_DDB_STEP_OVERLAP, > + SKL_DDB_STEP_FINAL > +}; > + > struct intel_crtc_wm_state { > union { > struct { > @@ -467,6 +475,8 @@ struct intel_crtc_wm_state { > /* minimum block allocation */ > uint16_t minimum_blocks[I915_MAX_PLANES]; > uint16_t minimum_y_blocks[I915_MAX_PLANES]; > + > + enum skl_ddb_step ddb_realloc; > } skl; > }; > > diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c > index 6b2452b..8596cb9 100644 > --- a/drivers/gpu/drm/i915/intel_pm.c > +++ b/drivers/gpu/drm/i915/intel_pm.c > @@ -3818,6 +3818,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, > @@ -3839,168 +3844,46 @@ void skl_write_cursor_wm(struct intel_crtc *intel_crtc, > &wm->ddb.plane[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]); > - } > -} > - > -/* > - * 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) > +static bool > +skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, > + const struct skl_ddb_allocation *new, > + enum pipe pipe) > { > - 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))); > + return new->pipe[pipe].start == old->pipe[pipe].start && > + new->pipe[pipe].end == old->pipe[pipe].end; > } > > static bool > -skl_ddb_allocation_included(const struct skl_ddb_allocation *old, > +skl_ddb_allocation_overlaps(struct drm_atomic_state *state, > + 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; > -} > - > -static void skl_flush_wm_values(struct drm_i915_private *dev_priv, > - struct skl_wm_values *new_values) > -{ > - 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 disabled in step 0 > + * - Compare against pipes that won't be enabled until step 3 > */ > - if (reallocated[pipe]) > + if (otherp == pipe || !new->pipe[otherp].end || > + !old->pipe[otherp].end) > continue; > > - 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)) > + return true; > } > + > + return false; > } > > static int skl_update_pipe_wm(struct drm_crtc_state *cstate, > @@ -4043,8 +3926,10 @@ skl_compute_ddb(struct drm_atomic_state *state) > 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 intel_crtc_state *cstate; > struct intel_crtc *intel_crtc; > - struct skl_ddb_allocation *ddb = &intel_state->wm_results.ddb; > + struct skl_ddb_allocation *old_ddb = &dev_priv->wm.skl_hw.ddb; > + struct skl_ddb_allocation *new_ddb = &intel_state->wm_results.ddb; > uint32_t realloc_pipes = pipes_modified(state); > int ret; > > @@ -4076,13 +3961,11 @@ skl_compute_ddb(struct drm_atomic_state *state) > } > > for_each_intel_crtc_mask(dev, intel_crtc, realloc_pipes) { > - struct intel_crtc_state *cstate; > - > cstate = intel_atomic_get_crtc_state(state, intel_crtc); > if (IS_ERR(cstate)) > return PTR_ERR(cstate); > > - ret = skl_allocate_pipe_ddb(cstate, ddb); > + ret = skl_allocate_pipe_ddb(cstate, new_ddb); > if (ret) > return ret; > > @@ -4091,6 +3974,73 @@ skl_compute_ddb(struct drm_atomic_state *state) > return ret; > } > > + /* > + * 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 final sequence we want looks like this: > + * 1. Disable any pipes we're not going to be using anymore > + * 2. Reallocate all of the active pipes whose new ddb allocations > + * won't overlap with another active pipe's ddb allocation. > + * 3. Reallocate remaining active pipes, if any. > + * 4. Enable any new pipes, if any. > + * > + * Example: > + * Initially DDB looks like this: > + * | B | C | > + * And the final DDB should look like this: > + * | B | C | A | > + * > + * 1. We're not disabling any pipes, so do nothing on this step. > + * 2. Pipe B's new allocation wouldn't overlap with pipe C, however > + * pipe C's new allocation does overlap with pipe B's current > + * allocation. Reallocate B first so the DDB looks like this: > + * | B |xx| C | > + * 3. Now we can safely reallocate pipe C to it's new location: > + * | B | C |xxxxx| > + * 4. Enable any remaining pipes, in this case A > + * | B | C | A | It's worth noting that this sequence will work fine for the three pipe case we have in gen9 since when adding or removing a pipe we never have a situation where multiple pipes are processed in the 'overlap' step (step 3). But if some future platform decides to add more pipes while maintaining the same general DDB programming style, this will break down since we'll need to ensure intelligent ordering of the pipes being processed in step 3. E.g., with naive ordering of step 3 we could have AAABBBCCCDDD -> AAAABBBBCCCC: AAABBBCCC___ (step 1) AAABBB__CCCC (step 2) AAA!BB__CCCC (step 3a, woops) > + * > + * As well, between every pipe reallocation we have to wait for a > + * vblank on the pipe so that we ensure it's new allocation has taken > + * effect by the time we start moving the next pipe. This can be > + * skipped on the last step we need to perform, which is why we keep > + * track of that information here. For example, if we've reallocated > + * all the pipes that need changing by the time we reach step 3, we can > + * finish without waiting for the pipes we changed in step 3 to update. > + */ > + for_each_intel_crtc_mask(dev, intel_crtc, realloc_pipes) { > + enum pipe pipe = intel_crtc->pipe; > + enum skl_ddb_step step; > + > + cstate = intel_atomic_get_crtc_state(state, intel_crtc); > + if (IS_ERR(cstate)) > + return PTR_ERR(cstate); > + > + /* Step 1: Pipes we're disabling / haven't changed */ > + if (skl_ddb_allocation_equals(old_ddb, new_ddb, pipe) || > + new_ddb->pipe[pipe].end == 0) { > + step = SKL_DDB_STEP_NONE; > + /* Step 2-3: Active pipes we're reallocating */ > + } else if (old_ddb->pipe[pipe].end != 0) { > + if (skl_ddb_allocation_overlaps(state, old_ddb, new_ddb, > + pipe)) > + step = SKL_DDB_STEP_OVERLAP; > + else > + step = SKL_DDB_STEP_NO_OVERLAP; > + /* Step 4: Pipes we're enabling */ > + } else { > + step = SKL_DDB_STEP_FINAL; > + } > + > + cstate->wm.skl.ddb_realloc = step; > + > + if (step > intel_state->last_ddb_step) > + intel_state->last_ddb_step = step; > + } > + > return 0; > } > > @@ -4115,10 +4065,13 @@ skl_copy_wm_for_pipe(struct skl_wm_values *dst, > static int > skl_compute_wm(struct drm_atomic_state *state) > { > + struct drm_i915_private *dev_priv = to_i915(state->dev); > struct drm_crtc *crtc; > struct drm_crtc_state *cstate; > struct intel_atomic_state *intel_state = to_intel_atomic_state(state); > struct skl_wm_values *results = &intel_state->wm_results; > + struct skl_ddb_allocation *old_ddb = &dev_priv->wm.skl_hw.ddb; > + struct skl_ddb_allocation *new_ddb = &results->ddb; > struct skl_pipe_wm *pipe_wm; > bool changed = false; > int ret, i; > @@ -4157,7 +4110,10 @@ skl_compute_wm(struct drm_atomic_state *state) > struct intel_crtc *intel_crtc = to_intel_crtc(crtc); > struct intel_crtc_state *intel_cstate = > to_intel_crtc_state(cstate); > + enum skl_ddb_step step; > + enum pipe pipe; > > + pipe = intel_crtc->pipe; > pipe_wm = &intel_cstate->wm.skl.optimal; > ret = skl_update_pipe_wm(cstate, &results->ddb, pipe_wm, > &changed); > @@ -4172,7 +4128,18 @@ skl_compute_wm(struct drm_atomic_state *state) > continue; > > intel_cstate->update_wm_pre = true; > + step = intel_cstate->wm.skl.ddb_realloc; > skl_compute_wm_results(crtc->dev, pipe_wm, results, intel_crtc); > + > + if (!skl_ddb_entry_equal(&old_ddb->pipe[pipe], > + &new_ddb->pipe[pipe])) { > + DRM_DEBUG_KMS( > + "DDB changes for [CRTC:%d:pipe %c]: (%3d - %3d) -> (%3d - %3d) on step %d\n", > + intel_crtc->base.base.id, pipe_name(pipe), > + old_ddb->pipe[pipe].start, old_ddb->pipe[pipe].end, > + new_ddb->pipe[pipe].start, new_ddb->pipe[pipe].end, > + step); > + } > } > > return 0; > @@ -4196,8 +4163,20 @@ 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); > + /* > + * If this pipe isn't active already, we're going to be enabling it > + * very soon. Since it's safe to update these while the pipe's shut off, > + * just do so here. Already active pipes will have their watermarks > + * updated once we update their planes. > + */ > + if (!intel_crtc->active) { > + 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); > + } Do we actually need this? Even if the pipe is in the process of being enabled, all of these registers should still be programmed at the same time as the plane registers, right? Those register writes are based on crtc->state->active rather than crtc->active so they should happen when they need to. On the other hand, if we write these when the pipe is off and isn't in the process of being enabled, then we may not have the power well turned on, so we'll get unclaimed register warnings. Matt > > /* > * Store the new configuration (but only for the pipes that have > -- > 2.7.4 > -- Matt Roper Graphics Software Engineer IoTG Platform Enabling & Development Intel Corporation (916) 356-2795