From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v6 6/6] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Thu, 4 Aug 2016 09:34:47 +0300 Message-ID: <20160804063447.GU4329@intel.com> References: <1470177458-31984-1-git-send-email-cpaul@redhat.com> <1470177458-31984-7-git-send-email-cpaul@redhat.com> <20160803150042.GK4329@intel.com> <20160803221928.GI32025@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20160803221928.GI32025@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Matt Roper Cc: Radhakrishna Sripada , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, Hans de Goede , dri-devel@lists.freedesktop.org, Daniel Vetter , Lyude List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCBBdWcgMDMsIDIwMTYgYXQgMDM6MTk6MjhQTSAtMDcwMCwgTWF0dCBSb3BlciB3cm90 ZToKPiBPbiBXZWQsIEF1ZyAwMywgMjAxNiBhdCAwNjowMDo0MlBNICswMzAwLCBWaWxsZSBTeXJq w6Rsw6Qgd3JvdGU6Cj4gPiBPbiBUdWUsIEF1ZyAwMiwgMjAxNiBhdCAwNjozNzozN1BNIC0wNDAw LCBMeXVkZSB3cm90ZToKPiA+ID4gTm93IHRoYXQgd2UgY2FuIGhvb2sgaW50byB1cGRhdGVfY3J0 Y3MgYW5kIGNvbnRyb2wgdGhlIG9yZGVyIGluIHdoaWNoIHdlCj4gPiA+IHVwZGF0ZSBDUlRDcyBh dCBlYWNoIG1vZGVzZXQsIHdlIGNhbiBmaW5pc2ggdGhlIGZpbmFsIHN0ZXAgb2YgZml4aW5nCj4g PiA+IFNreWxha2UncyB3YXRlcm1hcmsgaGFuZGxpbmcgYnkgcGVyZm9ybWluZyBEREIgdXBkYXRl cyBhdCB0aGUgc2FtZSB0aW1lCj4gPiA+IGFzIHBsYW5lIHVwZGF0ZXMgYW5kIHdhdGVybWFyayB1 cGRhdGVzLgo+ID4gPiAKPiA+ID4gVGhlIGZpcnN0IG1ham9yIGNoYW5nZSBpbiB0aGlzIHBhdGNo IGlzIHNrbF91cGRhdGVfY3J0Y3MoKSwgd2hpY2gKPiA+ID4gaGFuZGxlcyBlbnN1cmluZyB0aGF0 IHdlIG9yZGVyIGVhY2ggQ1JUQyB1cGRhdGUgaW4gb3VyIGF0b21pYyBjb21taXRzCj4gPiA+IHBy b3Blcmx5IHNvIHRoYXQgdGhleSBob25vciB0aGUgRERCIGZsdXNoIG9yZGVyLgo+ID4gPiAKPiA+ ID4gVGhlIHNlY29uZCBtYWpvciBjaGFuZ2UgaW4gdGhpcyBwYXRjaCBpcyB0aGUgb3JkZXIgaW4g d2hpY2ggd2UgZmx1c2ggdGhlCj4gPiA+IHBpcGVzLiBXaGlsZSB0aGUgcHJldmlvdXMgb3JkZXIg bWF5IGhhdmUgd29ya2VkLCBpdCBjYW4ndCBiZSB1c2VkIGluCj4gPiA+IHRoaXMgYXBwcm9hY2gg c2luY2UgaXQgbm8gbG9uZ2VyIHdpbGwgZG8gdGhlIHJpZ2h0IHRoaW5nLiBGb3IgZXhhbXBsZSwK PiA+ID4gdXNpbmcgdGhlIG9sZCBkZGIgZmx1c2ggb3JkZXI6Cj4gPiA+IAo+ID4gPiBXZSBoYXZl IHBpcGVzIEEsIEIsIGFuZCBDIGVuYWJsZWQsIGFuZCB3ZSdyZSBkaXNhYmxpbmcgQy4gSW5pdGlh bCBkZGIKPiA+ID4gYWxsb2NhdGlvbiBsb29rcyBsaWtlIHRoaXM6Cj4gPiA+IAo+ID4gPiB8ICAg QSAgIHwgICBCICAgfHh4eHh4eHh8Cj4gPiA+IAo+ID4gPiBTaW5jZSB3ZSdyZSBwZXJmb3JtaW5n IHRoZSBkZGIgdXBkYXRlcyBhZnRlciBwZXJmb3JtaW5nIGFueSBDUlRDCj4gPiA+IGRpc2FibGVt ZW50cyBpbiBpbnRlbF9hdG9taWNfY29tbWl0X3RhaWwoKSwgdGhlIHNwYWNlIHRvIHRoZSByaWdo dCBvZgo+ID4gPiBwaXBlIEIgaXMgdW5hbGxvY2F0ZWQuCj4gPiA+IAo+ID4gPiAxLiBGbHVzaCBw aXBlcyB3aXRoIG5ldyBhbGxvY2F0aW9uIGNvbnRhaW5lZCBpbnRvIG9sZCBzcGFjZS4gTm9uZQo+ ID4gPiAgICBhcHBseSwgc28gd2Ugc2tpcCB0aGlzCj4gPiA+IDIuIEZsdXNoIHBpcGVzIGhhdmlu ZyB0aGVpciBhbGxvY2F0aW9uIHJlZHVjZWQsIGJ1dCBvdmVybGFwcGluZyB3aXRoIGEKPiA+ID4g ICAgcHJldmlvdXMgYWxsb2NhdGlvbi4gTm9uZSBhcHBseSwgc28gd2UgYWxzbyBza2lwIHRoaXMK PiA+ID4gMy4gRmx1c2ggcGlwZXMgdGhhdCBnb3QgbW9yZSBzcGFjZSBhbGxvY2F0ZWQuIFRoaXMg YXBwbGllcyB0byBBIGFuZCBCLAo+ID4gPiAgICBnaXZpbmcgdXMgdGhlIGZvbGxvd2luZyB1cGRh dGUgb3JkZXI6IEEsIEIKPiA+ID4gCj4gPiA+IFRoaXMgaXMgd3JvbmcsIHNpbmNlIHVwZGF0aW5n IHBpcGUgQSBmaXJzdCB3aWxsIGNhdXNlIGl0IHRvIG92ZXJsYXAgd2l0aAo+ID4gPiBCIGFuZCBw b3RlbnRpYWxseSBidXJzdCBpbnRvIGZsYW1lcy4gT3VyIG5ldyBvcmRlciAoc2VlIHRoZSBjb2Rl Cj4gPiA+IGNvbW1lbnRzIGZvciBkZXRhaWxzKSB3b3VsZCB1cGRhdGUgdGhlIHBpcGVzIGluIHRo ZSBwcm9wZXIgb3JkZXI6IEIsIEEuCj4gPiA+IAo+ID4gPiBBcyB3ZWxsLCB3ZSBjYWxjdWxhdGUg dGhlIG9yZGVyIGZvciBlYWNoIEREQiB1cGRhdGUgZHVyaW5nIHRoZSBjaGVjawo+ID4gPiBwaGFz ZSwgYW5kIHJlZmVyZW5jZSBpdCBsYXRlciBpbiB0aGUgY29tbWl0IHBoYXNlIHdoZW4gd2UgaGl0 Cj4gPiA+IHNrbF91cGRhdGVfY3J0Y3MoKS4KPiA+ID4gCj4gPiA+IFRoaXMgbG9uZyBvdmVyZHVl IHBhdGNoIGZpeGVzIHRoZSByZXN0IG9mIHRoZSB1bmRlcnJ1bnMgb24gU2t5bGFrZS4KPiA+ID4g Cj4gPiA+IENoYW5nZXMgc2luY2UgdjE6Cj4gPiA+ICAtIEFkZCBza2xfZGRiX2VudHJ5X3dyaXRl KCkgZm9yIGN1cnNvciBpbnRvIHNrbF93cml0ZV9jdXJzb3Jfd20oKQo+ID4gPiAKPiA+ID4gRml4 ZXM6IDBlOGZiN2JhN2NhNSAoImRybS9pOTE1L3NrbDogRmx1c2ggdGhlIFdNIGNvbmZpZ3VyYXRp b24iKQo+ID4gPiBGaXhlczogODIxMWJkNWJkZjVlICgiZHJtL2k5MTUvc2tsOiBQcm9ncmFtIHRo ZSBEREIgYWxsb2NhdGlvbiIpCj4gPiA+IFNpZ25lZC1vZmYtYnk6IEx5dWRlIDxjcGF1bEByZWRo YXQuY29tPgo+ID4gPiBbb21pdHRpbmcgQ0MgZm9yIHN0YWJsZSwgc2luY2UgdGhpcyBwYXRjaCB3 aWxsIG5lZWQgdG8gYmUgY2hhbmdlZCBmb3IKPiA+ID4gc3VjaCBiYWNrcG9ydHMgZmlyc3RdCj4g PiA+IENjOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgo+ ID4gPiBDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+Cj4gPiA+IENj OiBSYWRoYWtyaXNobmEgU3JpcGFkYSA8cmFkaGFrcmlzaG5hLnNyaXBhZGFAaW50ZWwuY29tPgo+ ID4gPiBDYzogSGFucyBkZSBHb2VkZSA8aGRlZ29lZGVAcmVkaGF0LmNvbT4KPiA+ID4gQ2M6IE1h dHQgUm9wZXIgPG1hdHRoZXcuZC5yb3BlckBpbnRlbC5jb20+Cj4gPiA+IC0tLQo+ID4gPiAgZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIHwgMTAwICsrKysrKysrKystLQo+ID4g PiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICAgIHwgIDEwICsrCj4gPiA+ICBk cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jICAgICAgfCAyODggKysrKysrKysrKysrKysr Ky0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ID4gIDMgZmlsZXMgY2hhbmdlZCwgMjMzIGluc2VydGlv bnMoKyksIDE2NSBkZWxldGlvbnMoLSkKPiA+ID4gCj4gPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kaXNwbGF5LmMKPiA+ID4gaW5kZXggNTljZjUxMy4uMDYyOTVmNyAxMDA2NDQKPiA+ID4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gPiA+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+ID4gPiBAQCAtMTI4OTcsMTYgKzEyODk3 LDIzIEBAIHN0YXRpYyB2b2lkIHZlcmlmeV93bV9zdGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMs Cj4gPiA+ICAJCQkgIGh3X2VudHJ5LT5zdGFydCwgaHdfZW50cnktPmVuZCk7Cj4gPiA+ICAJfQo+ ID4gPiAgCj4gPiA+IC0JLyogY3Vyc29yICovCj4gPiA+IC0JaHdfZW50cnkgPSAmaHdfZGRiLnBs YW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gPiA+IC0Jc3dfZW50cnkgPSAmc3dfZGRiLT5wbGFu ZVtwaXBlXVtQTEFORV9DVVJTT1JdOwo+ID4gPiAtCj4gPiA+IC0JaWYgKCFza2xfZGRiX2VudHJ5 X2VxdWFsKGh3X2VudHJ5LCBzd19lbnRyeSkpIHsKPiA+ID4gLQkJRFJNX0VSUk9SKCJtaXNtYXRj aCBpbiBEREIgc3RhdGUgcGlwZSAlYyBjdXJzb3IgIgo+ID4gPiAtCQkJICAiKGV4cGVjdGVkICgl dSwldSksIGZvdW5kICgldSwldSkpXG4iLAo+ID4gPiAtCQkJICBwaXBlX25hbWUocGlwZSksCj4g PiA+IC0JCQkgIHN3X2VudHJ5LT5zdGFydCwgc3dfZW50cnktPmVuZCwKPiA+ID4gLQkJCSAgaHdf ZW50cnktPnN0YXJ0LCBod19lbnRyeS0+ZW5kKTsKPiA+ID4gKwkvKgo+ID4gPiArCSAqIGN1cnNv cgo+ID4gPiArCSAqIElmIHRoZSBjdXJzb3IgcGxhbmUgaXNuJ3QgYWN0aXZlLCB3ZSBtYXkgbm90 IGhhdmUgdXBkYXRlZCBpdCdzIGRkYgo+ID4gPiArCSAqIGFsbG9jYXRpb24uIEluIHRoYXQgY2Fz ZSBzaW5jZSB0aGUgZGRiIGFsbG9jYXRpb24gd2lsbCBiZSB1cGRhdGVkCj4gPiA+ICsJICogb25j ZSB0aGUgcGxhbmUgYmVjb21lcyB2aXNpYmxlLCB3ZSBjYW4gc2tpcCB0aGlzIGNoZWNrCj4gPiA+ ICsJICovCj4gPiA+ICsJaWYgKGludGVsX2NydGMtPmN1cnNvcl9hZGRyKSB7Cj4gPiA+ICsJCWh3 X2VudHJ5ID0gJmh3X2RkYi5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdOwo+ID4gPiArCQlzd19l bnRyeSA9ICZzd19kZGItPnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Cj4gPiA+ICsKPiA+ID4g KwkJaWYgKCFza2xfZGRiX2VudHJ5X2VxdWFsKGh3X2VudHJ5LCBzd19lbnRyeSkpIHsKPiA+ID4g KwkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4gRERCIHN0YXRlIHBpcGUgJWMgY3Vyc29yICIKPiA+ ID4gKwkJCQkgICIoZXhwZWN0ZWQgKCV1LCV1KSwgZm91bmQgKCV1LCV1KSlcbiIsCj4gPiA+ICsJ CQkJICBwaXBlX25hbWUocGlwZSksCj4gPiA+ICsJCQkJICBzd19lbnRyeS0+c3RhcnQsIHN3X2Vu dHJ5LT5lbmQsCj4gPiA+ICsJCQkJICBod19lbnRyeS0+c3RhcnQsIGh3X2VudHJ5LT5lbmQpOwo+ ID4gPiArCQl9Cj4gPiA+ICAJfQo+ID4gPiAgfQo+ID4gPiAgCj4gPiA+IEBAIC0xMzY1OCw2ICsx MzY2NSw3MiBAQCBzdGF0aWMgdm9pZCBpbnRlbF91cGRhdGVfY3J0Y3Moc3RydWN0IGRybV9hdG9t aWNfc3RhdGUgKnN0YXRlLAo+ID4gPiAgCX0KPiA+ID4gIH0KPiA+ID4gIAo+ID4gPiArc3RhdGlj IGlubGluZSB2b2lkCj4gPiA+ICtza2xfZG9fZGRiX3N0ZXAoc3RydWN0IGRybV9hdG9taWNfc3Rh dGUgKnN0YXRlLAo+ID4gPiArCQllbnVtIHNrbF9kZGJfc3RlcCBzdGVwKQo+ID4gPiArewo+ID4g PiArCXN0cnVjdCBpbnRlbF9hdG9taWNfc3RhdGUgKmludGVsX3N0YXRlID0gdG9faW50ZWxfYXRv bWljX3N0YXRlKHN0YXRlKTsKPiA+ID4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGM7Cj4gPiA+ICsJ c3RydWN0IGRybV9jcnRjX3N0YXRlICpvbGRfY3J0Y19zdGF0ZTsKPiA+ID4gKwl1bnNpZ25lZCBp bnQgY3J0Y192YmxhbmtfbWFzazsgLyogdW51c2VkICovCj4gPiA+ICsJaW50IGk7Cj4gPiA+ICsK PiA+ID4gKwlmb3JfZWFjaF9jcnRjX2luX3N0YXRlKHN0YXRlLCBjcnRjLCBvbGRfY3J0Y19zdGF0 ZSwgaSkgewo+ID4gPiArCQlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YyA9IHRvX2ludGVs X2NydGMoY3J0Yyk7Cj4gPiA+ICsJCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjc3RhdGUgPQo+ ID4gPiArCQkJdG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLT5zdGF0ZSk7Cj4gPiA+ICsJCWJvb2wg dmJsYW5rX3dhaXQgPSBmYWxzZTsKPiA+ID4gKwo+ID4gPiArCQlpZiAoY3N0YXRlLT53bS5za2wu ZGRiX3JlYWxsb2MgIT0gc3RlcCB8fCAhY3J0Yy0+c3RhdGUtPmFjdGl2ZSkKPiA+ID4gKwkJCWNv bnRpbnVlOwo+ID4gPiArCj4gPiA+ICsJCS8qCj4gPiA+ICsJCSAqIElmIHdlJ3JlIGNoYW5naW5n IHRoZSBkZGIgYWxsb2NhdGlvbiBvZiB0aGlzIHBpcGUgdG8gbWFrZQo+ID4gPiArCQkgKiByb29t IGZvciBhbm90aGVyIHBpcGUsIHdlIGhhdmUgdG8gd2FpdCBmb3IgdGhlIHBpcGUncyBkZGIKPiA+ ID4gKwkJICogYWxsb2NhdGlvbnMgdG8gYWN0dWFsbHkgdXBkYXRlIGJ5IHdhaXRpbmcgZm9yIGEg dmJsYW5rLgo+ID4gPiArCQkgKiBPdGhlcndpc2Ugd2UgcmlzayB0aGUgbmV4dCBwaXBlIHVwZGF0 aW5nIGJlZm9yZSB0aGlzIHBpcGUKPiA+ID4gKwkJICogZmluaXNoZXMsIHJlc3VsdGluZyBpbiB0 aGUgcGlwZSBmZXRjaGluZyBmcm9tIGRkYiBzcGFjZSBmb3IKPiA+ID4gKwkJICogdGhlIHdyb25n IHBpcGUuCj4gPiA+ICsJCSAqCj4gPiA+ICsJCSAqIEhvd2V2ZXIsIGlmIHdlIGtub3cgd2UgZG9u J3QgaGF2ZSBhbnkgbW9yZSBwaXBlcyB0byBtb3ZlCj4gPiA+ICsJCSAqIGFyb3VuZCwgd2UgY2Fu IHNraXAgdGhpcyB3YWl0IGFuZCB0aGUgbmV3IGRkYiBhbGxvY2F0aW9uCj4gPiA+ICsJCSAqIHdp bGwgdGFrZSBlZmZlY3QgYXQgdGhlIHN0YXJ0IG9mIHRoZSBuZXh0IHZibGFuay4KPiA+ID4gKwkJ ICovCj4gPiA+ICsJCXN3aXRjaCAoc3RlcCkgewo+ID4gPiArCQljYXNlIFNLTF9EREJfU1RFUF9O T19PVkVSTEFQOgo+ID4gPiArCQljYXNlIFNLTF9EREJfU1RFUF9PVkVSTEFQOgo+ID4gPiArCQkJ aWYgKHN0ZXAgIT0gaW50ZWxfc3RhdGUtPmxhc3RfZGRiX3N0ZXApCj4gPiA+ICsJCQkJdmJsYW5r X3dhaXQgPSB0cnVlOwo+ID4gPiArCj4gPiA+ICsJCS8qIGRyb3AgdGhyb3VnaCAqLwo+ID4gPiAr CQljYXNlIFNLTF9EREJfU1RFUF9GSU5BTDoKPiA+ID4gKwkJCURSTV9ERUJVR19LTVMoCj4gPiA+ ICsJCQkgICAgIlVwZGF0aW5nIFtDUlRDOiVkOnBpcGUgJWNdIGZvciBEREIgc3RlcCAlZFxuIiwK PiA+ID4gKwkJCSAgICBjcnRjLT5iYXNlLmlkLCBwaXBlX25hbWUoaW50ZWxfY3J0Yy0+cGlwZSks Cj4gPiA+ICsJCQkgICAgc3RlcCk7Cj4gPiA+ICsKPiA+ID4gKwkJY2FzZSBTS0xfRERCX1NURVBf Tk9ORToKPiA+ID4gKwkJCWJyZWFrOwo+ID4gPiArCQl9Cj4gPiAKPiA+IE5vdCBzdXJlIHdlIHJl YWxseSBuZWVkIHRoaXMgc3RlcCBzdHVmZi4gSG93IGFib3V0Pwo+ID4gCj4gPiBmb3JfZWFjaF9j cnRjCj4gPiAJaWYgKGNydGNfbmVlZHNfZGlzYWJsaW5nKQo+ID4gCQlkaXNhYmxlX2NydGMoKTsK PiA+IAo+ID4gZG8gewo+ID4gCXByb2dyZXNzID0gZmFsc2U7Cj4gPiAJd2FpdF92YmxfcGlwZXM9 MDsKPiA+IAlmb3JfZWFjaF9jcnRjKCkgewo+ID4gCQlpZiAoIWFjdGl2ZSB8fCBuZWVkc19tb2Rl c2V0KQo+ID4gCQkJY29udGludWU7Cj4gPiAJCWlmICghZGRiX2NoYW5nZWQpCj4gPiAJCQljb250 aW51ZTsKPiA+IAkJaWYgKG5ld19kZGJfb3ZlcmxhcHNfd2l0aF9hbnlfb3RoZXJfcGlwZXNfY3Vy cmVudF9kZGIpCj4gPiAJCQljb250aW51ZTsKPiA+IAkJY29tbWl0Owo+ID4gCQl3YWl0X3ZibF9w aXBlcyB8PSBwaXBlOwo+ID4gCQlwcm9ncmVzcyA9IHRydWU7Cj4gPiAJfQo+ID4gCXdhaXRfdmJs cyh3YWl0X3ZibF9waXBlcyk7Cj4gPiB9IHdoaWxlIChwcm9ncmVzcyk7Cj4gPiAKPiA+IGZvcl9l YWNoX2NydGMKPiA+IAlpZiAoY3J0Y19uZWVkc19lbmFibGluZykKPiA+IAkJZW5hYmxlX2NydGMo KTsKPiA+IAljb21taXQ7Cj4gPiB9Cj4gCj4gWWVhaCwgdGhpcyBhcHByb2FjaCBsb29rcyBuaWNl ci4gIEl0J3MgYSBiaXQgc2ltcGxlciB0byBmb2xsb3cgY29kZS13aXNlCj4gYW5kIGRvZXNuJ3Qg cmVxdWlyZSB1cyB0byBwcmVjb21wdXRlIGFueSBvcmRlcmluZyBkdXJpbmcgdGhlIGNoZWNrIHBo YXNlCj4gc28gaXQncyBhIGJpdCBtb3JlIHNlbGYtY29udGFpbmVkLiAgSXQgc2hvdWxkIGFsc28g c2NhbGUgcHJvcGVybHkgaWYKPiBmdXR1cmUgcGxhdGZvcm1zIGRlY2lkZSB0byBhZGQgbW9yZSBw aXBlcy4KClllcC4KCj4gCj4gPiAKPiA+IE9yIGlmIHdlJ3JlIHBhcmFub2lkLCB3ZSBjb3VsZCBh bHNvIGhhdmUgYW4gdXBwZXIgYm91bmQgb24gdGhlCj4gPiBsb29wIGFuZCBhc3NlcnQgdGhhdCB3 ZSBuZXZlciByZWFjaCBpdC4KPiA+IAo+ID4gCj4gPiBUaG91Z2ggb25lIHRoaW5nIEkgZG9uJ3Qg cGFydGljdWxhcmx5IGxpa2UgYWJvdXQgdGhpcyBjb21taXQgd2hpbGUKPiA+IGNoYW5naW5nIHRo ZSBkZGIgYXBwcm9hY2ggaXMgdGhhdCBpdCdzIGdvaW5nIHRvIG1ha2UgdGhlIHVwZGF0ZQo+ID4g YXBwZWFyIGV2ZW4gbGVzcyBhdG9taWMuIFdoYXQgSSdkIHJhdGhlciBsaWtlIHRvIGRvIGZvciB0 aGUgbm9ybWFsCj4gPiBjb21taXQgcGF0aCBpcyB0aGlzOgo+ID4gCj4gPiBmb3JfZWFjaF9jcnRj Cj4gPiAJaWYgKGNydGNfbmVlZHNfZGlzYWJsaW5nKQo+ID4gCQlkaXNhYmxlX3BsYW5lcwo+ID4g Zm9yX2VhY2hfY3J0Ywo+ID4gCWlmIChjcnRjX25lZWRzX2Rpc2FibGluZykKPiA+IAkJZGlzYWJs ZV9jcnRjCj4gPiBmb3JfZWFjaF9jcnRjCj4gPiAJaWYgKGNydGNfbmVlZHNfZW5hYmxpbmcpCj4g PiAJCWVuYWJsZV9jcnRjCj4gPiBmb3JfZWFjaF9jcnRjCj4gPiAJaWYgKGFjdGl2ZSkKPiA+IAkJ Y29tbWl0X3BsYW5lczsKPiA+IAo+ID4gVGhhdCB3YXkgZXZlcnl0aGluZyB3b3VsZCBwb3AgaW4g YW5kIG91dCBhcyBjbG9zZSB0b2dldGhlciBhcyBwb3NzaWJsZS4KPiA+IEhtbS4gQWN0dWFsbHks IEkgd29uZGVyLi4uIEknbSB0aGlua2luZyB3ZSBzaG91bGQgYmUgYWJsZSB0byBlbmFibGUgYWxs Cj4gPiBjcnRjcyBwcmlvciB0byBlbnRlcmluZyB0aGUgZGRiIGNvbW1pdCBsb29wLCBvbiBhY2Nv dW50IG9mIG5vIHBsYW5lcwo+ID4gYmVpbmcgZW5hYmxlZCBvbiB0aG9zZSBjcnRjcyB1bnRpbCB3 ZSBjb21taXQgdGhlbS4gQW5kIGlmIG5vIHBsYW5lcyBhcmUKPiA+IGVuYWJsZWQsIHJ1bm5pbmcg dGhlIHBpcGUgdy9vIGFsbG9jYXRlZCBkZGIgc2hvdWxkIGJlIGZpbmUuIFNvIHdpdGggdGhhdAo+ ID4gYXBwcm9hY2gsIEkgdGhpbmsgd2Ugc2hvdWxkIGJlIGFibGUgdG8gY29tbWl0IGFsbCBwbGFu ZXMgd2l0aGluIGEgZmV3Cj4gPiBpdGVyYXRpb25zIG9mIHRoZSBsb29wLCBhbmQgaGVuY2Ugd2l0 aGluIGEgZmV3IHZibGFua3MuCj4gCj4gU28gdGhpcyBpcyBwcmV0dHkgc2ltaWxhciB0byB3aGF0 IHdlIGRvIHRvZGF5LCBleGNlcHQgdGhhdCB3ZSBkbyB0aGUKPiBlbmFibGluZy9kaXNhYmxpbmcg b2YgZWFjaCBDUlRDIGFuZCBpdHMgcGxhbmVzIGFsbCB0b2dldGhlciwgcmlnaHQ/CgpZZWFoLiBT aG91bGQgcHJvdmlkZSBiZXR0ZXIgZXhwZXJpZW5jZSBpbiBjYXNlIG9mICJnZW5sb2NrZWQiIHBp cGVzIGF0CmxlYXN0LCBlZy4gZm9yIHRob3NlIDIgcGFydCA0ayBNU1QgbW9uaXRvcnMuCgo+IFNv dW5kcyByZWFzb25hYmxlIHRvIG1lLCBhbHRob3VnaCBJJ20gbm90IHN1cmUgd2Ugd2FudCB0byBt aXggdGhhdAo+IGNoYW5nZSBpbiB3aXRoIHRoZSBnZW45LXNwZWNpZmljIHNlcmllcyBMeXVkZSBp cyB3b3JraW5nIG9uIGhlcmUuICBNYXliZQo+IGp1c3QgZG8gdGhlIG5ldyBnZW45IGhhbmRsZXIg dGhhdCB3YXkgYXMgcGFydCBvZiB0aGF0IHNlcmllcyBhbmQgdGhlbgo+IGNvbWUgYmFjayBhbmQg dXBkYXRlIHRoZSBub24tZ2VuOSBoYW5kbGVyIHRvIGZvbGxvdyB0aGUgbmV3IGZsb3cgYXMgYQo+ IHNlcGFyYXRlIHBhdGNoPwoKU291bmRzIGdvb2QuIEZpcnN0IGZpeCBnZW45LCB0aGVuIG1ha2Ug dGhpbmdzIHByZXR0eSA6KQoKQXMgZmFyIGFzIG15IGlkZWEgb2YgZW5hYmxpbmcgdGhlIHBpcGVz IG9uIGdlbjkgYmVmb3JlIHRoZSBjb21taXQgbG9vcCwKSSB0aGluayB0aGF0IHdvdWxkIGFsc28g YXZvaWQgaGF2aW5nIHRvIGNvbW1pdCB0aGUgcGxhbmVzIHNlcGFyYXRlbHkgb24KdGhvc2UgbmV3 bHkgZW5hYmxlZCBjcnRjcy4gTXkgJ3Byb2dyZXNzJyBsb29wIHdvdWxkIHRha2UgY2FyZSBvZiB0 aG9zZQpwaXBlcyBhcyB3ZWxsICh3b3VsZCBqdXN0IGhhdmUgdG8gZHJvcCB0aGUgbmVlZHNfbW9k ZXNldCBjaGVjaykuCgo+IAo+IAo+IE1hdHQKPiAKPiA+IAo+ID4gPiArCj4gPiA+ICsJCWludGVs X3VwZGF0ZV9jcnRjKGNydGMsIHN0YXRlLCBvbGRfY3J0Y19zdGF0ZSwKPiA+ID4gKwkJCQkgICZj cnRjX3ZibGFua19tYXNrKTsKPiA+ID4gKwo+ID4gPiArCQlpZiAodmJsYW5rX3dhaXQpCj4gPiA+ ICsJCQlpbnRlbF93YWl0X2Zvcl92Ymxhbmsoc3RhdGUtPmRldiwgaW50ZWxfY3J0Yy0+cGlwZSk7 Cj4gPiA+ICsJfQo+ID4gPiArfQo+ID4gPiArCj4gPiA+ICtzdGF0aWMgdm9pZCBza2xfdXBkYXRl X2NydGNzKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSwKPiA+ID4gKwkJCSAgICAgdW5z aWduZWQgaW50ICpjcnRjX3ZibGFua19tYXNrKQo+ID4gPiArewo+ID4gPiArCXN0cnVjdCBpbnRl bF9hdG9taWNfc3RhdGUgKmludGVsX3N0YXRlID0gdG9faW50ZWxfYXRvbWljX3N0YXRlKHN0YXRl KTsKPiA+ID4gKwllbnVtIHNrbF9kZGJfc3RlcCBzdGVwOwo+ID4gPiArCj4gPiA+ICsJZm9yIChz dGVwID0gMDsgc3RlcCA8PSBpbnRlbF9zdGF0ZS0+bGFzdF9kZGJfc3RlcDsgc3RlcCsrKQo+ID4g PiArCQlza2xfZG9fZGRiX3N0ZXAoc3RhdGUsIHN0ZXApOwo+ID4gPiArfQo+ID4gPiArCj4gPiA+ ICBzdGF0aWMgdm9pZCBpbnRlbF9hdG9taWNfY29tbWl0X3RhaWwoc3RydWN0IGRybV9hdG9taWNf c3RhdGUgKnN0YXRlKQo+ID4gPiAgewo+ID4gPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBz dGF0ZS0+ZGV2Owo+ID4gPiBAQCAtMTUyMzUsOCArMTUzMDgsNiBAQCB2b2lkIGludGVsX2luaXRf ZGlzcGxheV9ob29rcyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCj4gPiA+ICAJ CWRldl9wcml2LT5kaXNwbGF5LmNydGNfZGlzYWJsZSA9IGk5eHhfY3J0Y19kaXNhYmxlOwo+ID4g PiAgCX0KPiA+ID4gIAo+ID4gPiAtCWRldl9wcml2LT5kaXNwbGF5LnVwZGF0ZV9jcnRjcyA9IGlu dGVsX3VwZGF0ZV9jcnRjczsKPiA+ID4gLQo+ID4gPiAgCS8qIFJldHVybnMgdGhlIGNvcmUgZGlz cGxheSBjbG9jayBzcGVlZCAqLwo+ID4gPiAgCWlmIChJU19TS1lMQUtFKGRldl9wcml2KSB8fCBJ U19LQUJZTEFLRShkZXZfcHJpdikpCj4gPiA+ICAJCWRldl9wcml2LT5kaXNwbGF5LmdldF9kaXNw bGF5X2Nsb2NrX3NwZWVkID0KPiA+ID4gQEAgLTE1MzI2LDYgKzE1Mzk3LDExIEBAIHZvaWQgaW50 ZWxfaW5pdF9kaXNwbGF5X2hvb2tzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikK PiA+ID4gIAkJCXNrbF9tb2Rlc2V0X2NhbGNfY2RjbGs7Cj4gPiA+ICAJfQo+ID4gPiAgCj4gPiA+ ICsJaWYgKGRldl9wcml2LT5pbmZvLmdlbiA+PSA5KQo+ID4gPiArCQlkZXZfcHJpdi0+ZGlzcGxh eS51cGRhdGVfY3J0Y3MgPSBza2xfdXBkYXRlX2NydGNzOwo+ID4gPiArCWVsc2UKPiA+ID4gKwkJ ZGV2X3ByaXYtPmRpc3BsYXkudXBkYXRlX2NydGNzID0gaW50ZWxfdXBkYXRlX2NydGNzOwo+ID4g PiArCj4gPiA+ICAJc3dpdGNoIChJTlRFTF9JTkZPKGRldl9wcml2KS0+Z2VuKSB7Cj4gPiA+ICAJ Y2FzZSAyOgo+ID4gPiAgCQlkZXZfcHJpdi0+ZGlzcGxheS5xdWV1ZV9mbGlwID0gaW50ZWxfZ2Vu Ml9xdWV1ZV9mbGlwOwo+ID4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+ID4gPiBpbmRleCAx YjQ0NGQzLi5jZjVkYTgzIDEwMDY0NAo+ID4gPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kcnYuaAo+ID4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+ ID4gPiBAQCAtMzM0LDYgKzMzNCw3IEBAIHN0cnVjdCBpbnRlbF9hdG9taWNfc3RhdGUgewo+ID4g PiAgCj4gPiA+ICAJLyogR2VuOSsgb25seSAqLwo+ID4gPiAgCXN0cnVjdCBza2xfd21fdmFsdWVz IHdtX3Jlc3VsdHM7Cj4gPiA+ICsJaW50IGxhc3RfZGRiX3N0ZXA7Cj4gPiA+ICB9Owo+ID4gPiAg Cj4gPiA+ICBzdHJ1Y3QgaW50ZWxfcGxhbmVfc3RhdGUgewo+ID4gPiBAQCAtNDM3LDYgKzQzOCwx MyBAQCBzdHJ1Y3Qgc2tsX3BpcGVfd20gewo+ID4gPiAgCXVpbnQzMl90IGxpbmV0aW1lOwo+ID4g PiAgfTsKPiA+ID4gIAo+ID4gPiArZW51bSBza2xfZGRiX3N0ZXAgewo+ID4gPiArCVNLTF9EREJf U1RFUF9OT05FID0gMCwKPiA+ID4gKwlTS0xfRERCX1NURVBfTk9fT1ZFUkxBUCwKPiA+ID4gKwlT S0xfRERCX1NURVBfT1ZFUkxBUCwKPiA+ID4gKwlTS0xfRERCX1NURVBfRklOQUwKPiA+ID4gK307 Cj4gPiA+ICsKPiA+ID4gIHN0cnVjdCBpbnRlbF9jcnRjX3dtX3N0YXRlIHsKPiA+ID4gIAl1bmlv biB7Cj4gPiA+ICAJCXN0cnVjdCB7Cj4gPiA+IEBAIC00NjcsNiArNDc1LDggQEAgc3RydWN0IGlu dGVsX2NydGNfd21fc3RhdGUgewo+ID4gPiAgCQkJLyogbWluaW11bSBibG9jayBhbGxvY2F0aW9u ICovCj4gPiA+ICAJCQl1aW50MTZfdCBtaW5pbXVtX2Jsb2Nrc1tJOTE1X01BWF9QTEFORVNdOwo+ ID4gPiAgCQkJdWludDE2X3QgbWluaW11bV95X2Jsb2Nrc1tJOTE1X01BWF9QTEFORVNdOwo+ID4g PiArCj4gPiA+ICsJCQllbnVtIHNrbF9kZGJfc3RlcCBkZGJfcmVhbGxvYzsKPiA+ID4gIAkJfSBz a2w7Cj4gPiA+ICAJfTsKPiA+ID4gIAo+ID4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKPiA+ID4g aW5kZXggNmY1YmViMy4uNjM2YzkwYSAxMDA2NDQKPiA+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfcG0uYwo+ID4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9w bS5jCj4gPiA+IEBAIC0zODE2LDYgKzM4MTYsMTEgQEAgdm9pZCBza2xfd3JpdGVfcGxhbmVfd20o c3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMsCj4gPiA+ICAJCQkgICB3bS0+cGxhbmVbcGlw ZV1bcGxhbmVdW2xldmVsXSk7Cj4gPiA+ICAJfQo+ID4gPiAgCUk5MTVfV1JJVEUoUExBTkVfV01f VFJBTlMocGlwZSwgcGxhbmUpLCB3bS0+cGxhbmVfdHJhbnNbcGlwZV1bcGxhbmVdKTsKPiA+ID4g Kwo+ID4gPiArCXNrbF9kZGJfZW50cnlfd3JpdGUoZGV2X3ByaXYsIFBMQU5FX0JVRl9DRkcocGlw ZSwgcGxhbmUpLAo+ID4gPiArCQkJICAgICZ3bS0+ZGRiLnBsYW5lW3BpcGVdW3BsYW5lXSk7Cj4g PiA+ICsJc2tsX2RkYl9lbnRyeV93cml0ZShkZXZfcHJpdiwgUExBTkVfTlYxMl9CVUZfQ0ZHKHBp cGUsIHBsYW5lKSwKPiA+ID4gKwkJCSAgICAmd20tPmRkYi55X3BsYW5lW3BpcGVdW3BsYW5lXSk7 Cj4gPiA+ICB9Cj4gPiA+ICAKPiA+ID4gIHZvaWQgc2tsX3dyaXRlX2N1cnNvcl93bShzdHJ1Y3Qg aW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKPiA+ID4gQEAgLTM4MzIsMTcwICszODM3LDUxIEBAIHZv aWQgc2tsX3dyaXRlX2N1cnNvcl93bShzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKPiA+ ID4gIAkJCSAgIHdtLT5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdW2xldmVsXSk7Cj4gPiA+ICAJ fQo+ID4gPiAgCUk5MTVfV1JJVEUoQ1VSX1dNX1RSQU5TKHBpcGUpLCB3bS0+cGxhbmVfdHJhbnNb cGlwZV1bUExBTkVfQ1VSU09SXSk7Cj4gPiA+IC19Cj4gPiA+IC0KPiA+ID4gLXN0YXRpYyB2b2lk IHNrbF93cml0ZV93bV92YWx1ZXMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+ ID4gPiAtCQkJCWNvbnN0IHN0cnVjdCBza2xfd21fdmFsdWVzICpuZXcpCj4gPiA+IC17Cj4gPiA+ IC0Jc3RydWN0IGRybV9kZXZpY2UgKmRldiA9ICZkZXZfcHJpdi0+ZHJtOwo+ID4gPiAtCXN0cnVj dCBpbnRlbF9jcnRjICpjcnRjOwo+ID4gPiAtCj4gPiA+IC0JZm9yX2VhY2hfaW50ZWxfY3J0Yyhk ZXYsIGNydGMpIHsKPiA+ID4gLQkJaW50IGk7Cj4gPiA+IC0JCWVudW0gcGlwZSBwaXBlID0gY3J0 Yy0+cGlwZTsKPiA+ID4gLQo+ID4gPiAtCQlpZiAoKG5ldy0+ZGlydHlfcGlwZXMgJiBkcm1fY3J0 Y19tYXNrKCZjcnRjLT5iYXNlKSkgPT0gMCkKPiA+ID4gLQkJCWNvbnRpbnVlOwo+ID4gPiAtCQlp ZiAoIWNydGMtPmFjdGl2ZSkKPiA+ID4gLQkJCWNvbnRpbnVlOwo+ID4gPiAgCj4gPiA+IC0JCWZv ciAoaSA9IDA7IGkgPCBpbnRlbF9udW1fcGxhbmVzKGNydGMpOyBpKyspIHsKPiA+ID4gLQkJCXNr bF9kZGJfZW50cnlfd3JpdGUoZGV2X3ByaXYsCj4gPiA+IC0JCQkJCSAgICBQTEFORV9CVUZfQ0ZH KHBpcGUsIGkpLAo+ID4gPiAtCQkJCQkgICAgJm5ldy0+ZGRiLnBsYW5lW3BpcGVdW2ldKTsKPiA+ ID4gLQkJCXNrbF9kZGJfZW50cnlfd3JpdGUoZGV2X3ByaXYsCj4gPiA+IC0JCQkJCSAgICBQTEFO RV9OVjEyX0JVRl9DRkcocGlwZSwgaSksCj4gPiA+IC0JCQkJCSAgICAmbmV3LT5kZGIueV9wbGFu ZVtwaXBlXVtpXSk7Cj4gPiA+IC0JCX0KPiA+ID4gLQo+ID4gPiAtCQlza2xfZGRiX2VudHJ5X3dy aXRlKGRldl9wcml2LCBDVVJfQlVGX0NGRyhwaXBlKSwKPiA+ID4gLQkJCQkgICAgJm5ldy0+ZGRi LnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl0pOwo+ID4gPiAtCX0KPiA+ID4gKwlza2xfZGRiX2Vu dHJ5X3dyaXRlKGRldl9wcml2LCBDVVJfQlVGX0NGRyhwaXBlKSwKPiA+ID4gKwkJCSAgICAmd20t PmRkYi5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdKTsKPiA+ID4gIH0KPiA+ID4gIAo+ID4gPiAt LyoKPiA+ID4gLSAqIFdoZW4gc2V0dGluZyB1cCBhIG5ldyBEREIgYWxsb2NhdGlvbiBhcnJhbmdl bWVudCwgd2UgbmVlZCB0byBjb3JyZWN0bHkKPiA+ID4gLSAqIHNlcXVlbmNlIHRoZSB0aW1lcyBh dCB3aGljaCB0aGUgbmV3IGFsbG9jYXRpb25zIGZvciB0aGUgcGlwZXMgYXJlIHRha2VuIGludG8K PiA+ID4gLSAqIGFjY291bnQgb3Igd2UnbGwgaGF2ZSBwaXBlcyBmZXRjaGluZyBmcm9tIHNwYWNl IHByZXZpb3VzbHkgYWxsb2NhdGVkIHRvCj4gPiA+IC0gKiBhbm90aGVyIHBpcGUuCj4gPiA+IC0g Kgo+ID4gPiAtICogUm91Z2hseSB0aGUgc2VxdWVuY2UgbG9va3MgbGlrZToKPiA+ID4gLSAqICAx LiByZS1hbGxvY2F0ZSB0aGUgcGlwZShzKSB3aXRoIHRoZSBhbGxvY2F0aW9uIGJlaW5nIHJlZHVj ZWQgYW5kIG5vdAo+ID4gPiAtICogICAgIG92ZXJsYXBwaW5nIHdpdGggYSBwcmV2aW91cyBsaWdo dC11cCBwaXBlIChhbm90aGVyIHdheSB0byBwdXQgaXQgaXM6Cj4gPiA+IC0gKiAgICAgcGlwZXMg d2l0aCB0aGVpciBuZXcgYWxsb2NhdGlvbiBzdHJpY2tseSBpbmNsdWRlZCBpbnRvIHRoZWlyIG9s ZCBvbmVzKS4KPiA+ID4gLSAqICAyLiByZS1hbGxvY2F0ZSB0aGUgb3RoZXIgcGlwZXMgdGhhdCBn ZXQgdGhlaXIgYWxsb2NhdGlvbiByZWR1Y2VkCj4gPiA+IC0gKiAgMy4gYWxsb2NhdGUgdGhlIHBp cGVzIGhhdmluZyB0aGVpciBhbGxvY2F0aW9uIGluY3JlYXNlZAo+ID4gPiAtICoKPiA+ID4gLSAq IFN0ZXBzIDEuIGFuZCAyLiBhcmUgaGVyZSB0byB0YWtlIGNhcmUgb2YgdGhlIGZvbGxvd2luZyBj YXNlOgo+ID4gPiAtICogLSBJbml0aWFsbHkgRERCIGxvb2tzIGxpa2UgdGhpczoKPiA+ID4gLSAq ICAgICB8ICAgQiAgICB8ICAgQyAgICB8Cj4gPiA+IC0gKiAtIGVuYWJsZSBwaXBlIEEuCj4gPiA+ IC0gKiAtIHBpcGUgQiBoYXMgYSByZWR1Y2VkIEREQiBhbGxvY2F0aW9uIHRoYXQgb3ZlcmxhcHMg d2l0aCB0aGUgb2xkIHBpcGUgQwo+ID4gPiAtICogICBhbGxvY2F0aW9uCj4gPiA+IC0gKiAgICAg fCAgQSAgfCAgQiAgfCAgQyAgfAo+ID4gPiAtICoKPiA+ID4gLSAqIFdlIG5lZWQgdG8gc2VxdWVu Y2UgdGhlIHJlLWFsbG9jYXRpb246IEMsIEIsIEEgKGFuZCBub3QgQiwgQywgQSkuCj4gPiA+IC0g Ki8KPiA+ID4gLQo+ID4gPiAtc3RhdGljIHZvaWQKPiA+ID4gLXNrbF93bV9mbHVzaF9waXBlKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBwaXBlIHBpcGUsIGludCBwYXNz KQo+ID4gPiArc3RhdGljIGJvb2wKPiA+ID4gK3NrbF9kZGJfYWxsb2NhdGlvbl9lcXVhbHMoY29u c3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqb2xkLAo+ID4gPiArCQkJICBjb25zdCBzdHJ1 Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpuZXcsCj4gPiA+ICsJCQkgIGVudW0gcGlwZSBwaXBlKQo+ ID4gPiAgewo+ID4gPiAtCWludCBwbGFuZTsKPiA+ID4gLQo+ID4gPiAtCURSTV9ERUJVR19LTVMo ImZsdXNoIHBpcGUgJWMgKHBhc3MgJWQpXG4iLCBwaXBlX25hbWUocGlwZSksIHBhc3MpOwo+ID4g PiAtCj4gPiA+IC0JZm9yX2VhY2hfcGxhbmUoZGV2X3ByaXYsIHBpcGUsIHBsYW5lKSB7Cj4gPiA+ IC0JCUk5MTVfV1JJVEUoUExBTkVfU1VSRihwaXBlLCBwbGFuZSksCj4gPiA+IC0JCQkgICBJOTE1 X1JFQUQoUExBTkVfU1VSRihwaXBlLCBwbGFuZSkpKTsKPiA+ID4gLQl9Cj4gPiA+IC0JSTkxNV9X UklURShDVVJCQVNFKHBpcGUpLCBJOTE1X1JFQUQoQ1VSQkFTRShwaXBlKSkpOwo+ID4gPiArCXJl dHVybiBuZXctPnBpcGVbcGlwZV0uc3RhcnQgPT0gb2xkLT5waXBlW3BpcGVdLnN0YXJ0ICYmCj4g PiA+ICsJICAgICAgIG5ldy0+cGlwZVtwaXBlXS5lbmQgPT0gb2xkLT5waXBlW3BpcGVdLmVuZDsK PiA+ID4gIH0KPiA+ID4gIAo+ID4gPiAgc3RhdGljIGJvb2wKPiA+ID4gLXNrbF9kZGJfYWxsb2Nh dGlvbl9pbmNsdWRlZChjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCj4gPiA+ ICtza2xfZGRiX2FsbG9jYXRpb25fb3ZlcmxhcHMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0 YXRlLAo+ID4gPiArCQkJICAgIGNvbnN0IHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm9sZCwK PiA+ID4gIAkJCSAgICBjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpuZXcsCj4gPiA+ ICAJCQkgICAgZW51bSBwaXBlIHBpcGUpCj4gPiA+ICB7Cj4gPiA+IC0JdWludDE2X3Qgb2xkX3Np emUsIG5ld19zaXplOwo+ID4gPiAtCj4gPiA+IC0Jb2xkX3NpemUgPSBza2xfZGRiX2VudHJ5X3Np emUoJm9sZC0+cGlwZVtwaXBlXSk7Cj4gPiA+IC0JbmV3X3NpemUgPSBza2xfZGRiX2VudHJ5X3Np emUoJm5ldy0+cGlwZVtwaXBlXSk7Cj4gPiA+IC0KPiA+ID4gLQlyZXR1cm4gb2xkX3NpemUgIT0g bmV3X3NpemUgJiYKPiA+ID4gLQkgICAgICAgbmV3LT5waXBlW3BpcGVdLnN0YXJ0ID49IG9sZC0+ cGlwZVtwaXBlXS5zdGFydCAmJgo+ID4gPiAtCSAgICAgICBuZXctPnBpcGVbcGlwZV0uZW5kIDw9 IG9sZC0+cGlwZVtwaXBlXS5lbmQ7Cj4gPiA+IC19Cj4gPiA+IC0KPiA+ID4gLXN0YXRpYyB2b2lk IHNrbF9mbHVzaF93bV92YWx1ZXMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+ ID4gPiAtCQkJCXN0cnVjdCBza2xfd21fdmFsdWVzICpuZXdfdmFsdWVzKQo+ID4gPiAtewo+ID4g PiAtCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmZGV2X3ByaXYtPmRybTsKPiA+ID4gLQlzdHJ1 Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpjdXJfZGRiLCAqbmV3X2RkYjsKPiA+ID4gLQlib29sIHJl YWxsb2NhdGVkW0k5MTVfTUFYX1BJUEVTXSA9IHt9Owo+ID4gPiAtCXN0cnVjdCBpbnRlbF9jcnRj ICpjcnRjOwo+ID4gPiAtCWVudW0gcGlwZSBwaXBlOwo+ID4gPiAtCj4gPiA+IC0JbmV3X2RkYiA9 ICZuZXdfdmFsdWVzLT5kZGI7Cj4gPiA+IC0JY3VyX2RkYiA9ICZkZXZfcHJpdi0+d20uc2tsX2h3 LmRkYjsKPiA+ID4gLQo+ID4gPiAtCS8qCj4gPiA+IC0JICogRmlyc3QgcGFzczogZmx1c2ggdGhl IHBpcGVzIHdpdGggdGhlIG5ldyBhbGxvY2F0aW9uIGNvbnRhaW5lZCBpbnRvCj4gPiA+IC0JICog dGhlIG9sZCBzcGFjZS4KPiA+ID4gLQkgKgo+ID4gPiAtCSAqIFdlJ2xsIHdhaXQgZm9yIHRoZSB2 Ymxhbmsgb24gdGhvc2UgcGlwZXMgdG8gZW5zdXJlIHdlIGNhbiBzYWZlbHkKPiA+ID4gLQkgKiBy ZS1hbGxvY2F0ZSB0aGUgZnJlZWQgc3BhY2Ugd2l0aG91dCB0aGlzIHBpcGUgZmV0Y2hpbmcgZnJv bSBpdC4KPiA+ID4gLQkgKi8KPiA+ID4gLQlmb3JfZWFjaF9pbnRlbF9jcnRjKGRldiwgY3J0Yykg ewo+ID4gPiAtCQlpZiAoIWNydGMtPmFjdGl2ZSkKPiA+ID4gLQkJCWNvbnRpbnVlOwo+ID4gPiAt Cj4gPiA+IC0JCXBpcGUgPSBjcnRjLT5waXBlOwo+ID4gPiAtCj4gPiA+IC0JCWlmICghc2tsX2Rk Yl9hbGxvY2F0aW9uX2luY2x1ZGVkKGN1cl9kZGIsIG5ld19kZGIsIHBpcGUpKQo+ID4gPiAtCQkJ Y29udGludWU7Cj4gPiA+IC0KPiA+ID4gLQkJc2tsX3dtX2ZsdXNoX3BpcGUoZGV2X3ByaXYsIHBp cGUsIDEpOwo+ID4gPiAtCQlpbnRlbF93YWl0X2Zvcl92YmxhbmsoZGV2LCBwaXBlKTsKPiA+ID4g LQo+ID4gPiAtCQlyZWFsbG9jYXRlZFtwaXBlXSA9IHRydWU7Cj4gPiA+IC0JfQo+ID4gPiAtCj4g PiA+IC0KPiA+ID4gLQkvKgo+ID4gPiAtCSAqIFNlY29uZCBwYXNzOiBmbHVzaCB0aGUgcGlwZXMg dGhhdCBhcmUgaGF2aW5nIHRoZWlyIGFsbG9jYXRpb24KPiA+ID4gLQkgKiByZWR1Y2VkLCBidXQg b3ZlcmxhcHBpbmcgd2l0aCBhIHByZXZpb3VzIGFsbG9jYXRpb24uCj4gPiA+IC0JICoKPiA+ID4g LQkgKiBIZXJlIGFzIHdlbGwgd2UgbmVlZCB0byB3YWl0IGZvciB0aGUgdmJsYW5rIHRvIG1ha2Ug c3VyZSB0aGUgZnJlZWQKPiA+ID4gLQkgKiBzcGFjZSBpcyBub3QgdXNlZCBhbnltb3JlLgo+ID4g PiAtCSAqLwo+ID4gPiAtCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRjKSB7Cj4gPiA+IC0J CWlmICghY3J0Yy0+YWN0aXZlKQo+ID4gPiAtCQkJY29udGludWU7Cj4gPiA+IC0KPiA+ID4gLQkJ cGlwZSA9IGNydGMtPnBpcGU7Cj4gPiA+IC0KPiA+ID4gLQkJaWYgKHJlYWxsb2NhdGVkW3BpcGVd KQo+ID4gPiAtCQkJY29udGludWU7Cj4gPiA+IC0KPiA+ID4gLQkJaWYgKHNrbF9kZGJfZW50cnlf c2l6ZSgmbmV3X2RkYi0+cGlwZVtwaXBlXSkgPAo+ID4gPiAtCQkgICAgc2tsX2RkYl9lbnRyeV9z aXplKCZjdXJfZGRiLT5waXBlW3BpcGVdKSkgewo+ID4gPiAtCQkJc2tsX3dtX2ZsdXNoX3BpcGUo ZGV2X3ByaXYsIHBpcGUsIDIpOwo+ID4gPiAtCQkJaW50ZWxfd2FpdF9mb3JfdmJsYW5rKGRldiwg cGlwZSk7Cj4gPiA+IC0JCQlyZWFsbG9jYXRlZFtwaXBlXSA9IHRydWU7Cj4gPiA+IC0JCX0KPiA+ ID4gLQl9Cj4gPiA+IC0KPiA+ID4gLQkvKgo+ID4gPiAtCSAqIFRoaXJkIHBhc3M6IGZsdXNoIHRo ZSBwaXBlcyB0aGF0IGdvdCBtb3JlIHNwYWNlIGFsbG9jYXRlZC4KPiA+ID4gLQkgKgo+ID4gPiAt CSAqIFdlIGRvbid0IG5lZWQgdG8gYWN0aXZlbHkgd2FpdCBmb3IgdGhlIHVwZGF0ZSBoZXJlLCBu ZXh0IHZibGFuawo+ID4gPiAtCSAqIHdpbGwganVzdCBnZXQgbW9yZSBEREIgc3BhY2Ugd2l0aCB0 aGUgY29ycmVjdCBXTSB2YWx1ZXMuCj4gPiA+IC0JICovCj4gPiA+IC0JZm9yX2VhY2hfaW50ZWxf Y3J0YyhkZXYsIGNydGMpIHsKPiA+ID4gLQkJaWYgKCFjcnRjLT5hY3RpdmUpCj4gPiA+IC0JCQlj b250aW51ZTsKPiA+ID4gKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gc3RhdGUtPmRldjsKPiA+ ID4gKwlzdHJ1Y3QgaW50ZWxfY3J0YyAqaW50ZWxfY3J0YzsKPiA+ID4gKwllbnVtIHBpcGUgb3Ro ZXJwOwo+ID4gPiAgCj4gPiA+IC0JCXBpcGUgPSBjcnRjLT5waXBlOwo+ID4gPiArCWZvcl9lYWNo X2ludGVsX2NydGMoZGV2LCBpbnRlbF9jcnRjKSB7Cj4gPiA+ICsJCW90aGVycCA9IGludGVsX2Ny dGMtPnBpcGU7Cj4gPiA+ICAKPiA+ID4gIAkJLyoKPiA+ID4gLQkJICogQXQgdGhpcyBwb2ludCwg b25seSB0aGUgcGlwZXMgbW9yZSBzcGFjZSB0aGFuIGJlZm9yZSBhcmUKPiA+ID4gLQkJICogbGVm dCB0byByZS1hbGxvY2F0ZS4KPiA+ID4gKwkJICogV2hlbiBjaGVja2luZyBmb3Igb3ZlcmxhcHMs IHdlIGRvbid0IHdhbnQgdG86Cj4gPiA+ICsJCSAqICAtIENvbXBhcmUgYWdhaW5zdCBvdXJzZWx2 ZXMKPiA+ID4gKwkJICogIC0gQ29tcGFyZSBhZ2FpbnN0IHBpcGVzIHRoYXQgd2lsbCBiZSBkaXNh YmxlZCBpbiBzdGVwIDAKPiA+ID4gKwkJICogIC0gQ29tcGFyZSBhZ2FpbnN0IHBpcGVzIHRoYXQg d29uJ3QgYmUgZW5hYmxlZCB1bnRpbCBzdGVwIDMKPiA+ID4gIAkJICovCj4gPiA+IC0JCWlmIChy ZWFsbG9jYXRlZFtwaXBlXSkKPiA+ID4gKwkJaWYgKG90aGVycCA9PSBwaXBlIHx8ICFuZXctPnBp cGVbb3RoZXJwXS5lbmQgfHwKPiA+ID4gKwkJICAgICFvbGQtPnBpcGVbb3RoZXJwXS5lbmQpCj4g PiA+ICAJCQljb250aW51ZTsKPiA+ID4gIAo+ID4gPiAtCQlza2xfd21fZmx1c2hfcGlwZShkZXZf cHJpdiwgcGlwZSwgMyk7Cj4gPiA+ICsJCWlmICgobmV3LT5waXBlW3BpcGVdLnN0YXJ0ID49IG9s ZC0+cGlwZVtvdGhlcnBdLnN0YXJ0ICYmCj4gPiA+ICsJCSAgICAgbmV3LT5waXBlW3BpcGVdLnN0 YXJ0IDwgb2xkLT5waXBlW290aGVycF0uZW5kKSB8fAo+ID4gPiArCQkgICAgKG9sZC0+cGlwZVtv dGhlcnBdLnN0YXJ0ID49IG5ldy0+cGlwZVtwaXBlXS5zdGFydCAmJgo+ID4gPiArCQkgICAgIG9s ZC0+cGlwZVtvdGhlcnBdLnN0YXJ0IDwgbmV3LT5waXBlW3BpcGVdLmVuZCkpCj4gPiA+ICsJCQly ZXR1cm4gdHJ1ZTsKPiA+ID4gIAl9Cj4gPiA+ICsKPiA+ID4gKwlyZXR1cm4gZmFsc2U7Cj4gPiA+ ICB9Cj4gPiA+ICAKPiA+ID4gIHN0YXRpYyBpbnQgc2tsX3VwZGF0ZV9waXBlX3dtKHN0cnVjdCBk cm1fY3J0Y19zdGF0ZSAqY3N0YXRlLAo+ID4gPiBAQCAtNDAzOCw4ICszOTI0LDEwIEBAIHNrbF9j b21wdXRlX2RkYihzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gPiA+ICAJc3RydWN0 IGRybV9kZXZpY2UgKmRldiA9IHN0YXRlLT5kZXY7Cj4gPiA+ICAJc3RydWN0IGRybV9pOTE1X3By aXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShkZXYpOwo+ID4gPiAgCXN0cnVjdCBpbnRlbF9hdG9t aWNfc3RhdGUgKmludGVsX3N0YXRlID0gdG9faW50ZWxfYXRvbWljX3N0YXRlKHN0YXRlKTsKPiA+ ID4gKwlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3N0YXRlOwo+ID4gPiAgCXN0cnVjdCBpbnRl bF9jcnRjICppbnRlbF9jcnRjOwo+ID4gPiAtCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKmRk YiA9ICZpbnRlbF9zdGF0ZS0+d21fcmVzdWx0cy5kZGI7Cj4gPiA+ICsJc3RydWN0IHNrbF9kZGJf YWxsb2NhdGlvbiAqb2xkX2RkYiA9ICZkZXZfcHJpdi0+d20uc2tsX2h3LmRkYjsKPiA+ID4gKwlz dHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpuZXdfZGRiID0gJmludGVsX3N0YXRlLT53bV9yZXN1 bHRzLmRkYjsKPiA+ID4gIAl1aW50MzJfdCByZWFsbG9jX3BpcGVzID0gcGlwZXNfbW9kaWZpZWQo c3RhdGUpOwo+ID4gPiAgCWludCByZXQ7Cj4gPiA+ICAKPiA+ID4gQEAgLTQwNzEsMTMgKzM5NTks MTEgQEAgc2tsX2NvbXB1dGVfZGRiKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSkKPiA+ ID4gIAl9Cj4gPiA+ICAKPiA+ID4gIAlmb3JfZWFjaF9pbnRlbF9jcnRjX21hc2soZGV2LCBpbnRl bF9jcnRjLCByZWFsbG9jX3BpcGVzKSB7Cj4gPiA+IC0JCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRl ICpjc3RhdGU7Cj4gPiA+IC0KPiA+ID4gIAkJY3N0YXRlID0gaW50ZWxfYXRvbWljX2dldF9jcnRj X3N0YXRlKHN0YXRlLCBpbnRlbF9jcnRjKTsKPiA+ID4gIAkJaWYgKElTX0VSUihjc3RhdGUpKQo+ ID4gPiAgCQkJcmV0dXJuIFBUUl9FUlIoY3N0YXRlKTsKPiA+ID4gIAo+ID4gPiAtCQlyZXQgPSBz a2xfYWxsb2NhdGVfcGlwZV9kZGIoY3N0YXRlLCBkZGIpOwo+ID4gPiArCQlyZXQgPSBza2xfYWxs b2NhdGVfcGlwZV9kZGIoY3N0YXRlLCBuZXdfZGRiKTsKPiA+ID4gIAkJaWYgKHJldCkKPiA+ID4g IAkJCXJldHVybiByZXQ7Cj4gPiA+ICAKPiA+ID4gQEAgLTQwODYsNiArMzk3Miw3MyBAQCBza2xf Y29tcHV0ZV9kZGIoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ID4gPiAgCQkJcmV0 dXJuIHJldDsKPiA+ID4gIAl9Cj4gPiA+ICAKPiA+ID4gKwkvKgo+ID4gPiArCSAqIFdoZW4gc2V0 dGluZyB1cCBhIG5ldyBEREIgYWxsb2NhdGlvbiBhcnJhbmdlbWVudCwgd2UgbmVlZCB0bwo+ID4g PiArCSAqIGNvcnJlY3RseSBzZXF1ZW5jZSB0aGUgdGltZXMgYXQgd2hpY2ggdGhlIG5ldyBhbGxv Y2F0aW9ucyBmb3IgdGhlCj4gPiA+ICsJICogcGlwZXMgYXJlIHRha2VuIGludG8gYWNjb3VudCBv ciB3ZSdsbCBoYXZlIHBpcGVzIGZldGNoaW5nIGZyb20gc3BhY2UKPiA+ID4gKwkgKiBwcmV2aW91 c2x5IGFsbG9jYXRlZCB0byBhbm90aGVyIHBpcGUuCj4gPiA+ICsJICoKPiA+ID4gKwkgKiBSb3Vn aGx5IHRoZSBmaW5hbCBzZXF1ZW5jZSB3ZSB3YW50IGxvb2tzIGxpa2UgdGhpczoKPiA+ID4gKwkg KiAgMS4gRGlzYWJsZSBhbnkgcGlwZXMgd2UncmUgbm90IGdvaW5nIHRvIGJlIHVzaW5nIGFueW1v cmUKPiA+ID4gKwkgKiAgMi4gUmVhbGxvY2F0ZSBhbGwgb2YgdGhlIGFjdGl2ZSBwaXBlcyB3aG9z ZSBuZXcgZGRiIGFsbG9jYXRpb25zCj4gPiA+ICsJICogIHdvbid0IG92ZXJsYXAgd2l0aCBhbm90 aGVyIGFjdGl2ZSBwaXBlJ3MgZGRiIGFsbG9jYXRpb24uCj4gPiA+ICsJICogIDMuIFJlYWxsb2Nh dGUgcmVtYWluaW5nIGFjdGl2ZSBwaXBlcywgaWYgYW55Lgo+ID4gPiArCSAqICA0LiBFbmFibGUg YW55IG5ldyBwaXBlcywgaWYgYW55Lgo+ID4gPiArCSAqCj4gPiA+ICsJICogRXhhbXBsZToKPiA+ ID4gKwkgKiBJbml0aWFsbHkgRERCIGxvb2tzIGxpa2UgdGhpczoKPiA+ID4gKwkgKiAgIHwgICBC ICAgIHwgICBDICAgIHwKPiA+ID4gKwkgKiBBbmQgdGhlIGZpbmFsIEREQiBzaG91bGQgbG9vayBs aWtlIHRoaXM6Cj4gPiA+ICsJICogICB8ICBCICB8ICBDICB8ICBBICB8Cj4gPiA+ICsJICoKPiA+ ID4gKwkgKiAxLiBXZSdyZSBub3QgZGlzYWJsaW5nIGFueSBwaXBlcywgc28gZG8gbm90aGluZyBv biB0aGlzIHN0ZXAuCj4gPiA+ICsJICogMi4gUGlwZSBCJ3MgbmV3IGFsbG9jYXRpb24gd291bGRu J3Qgb3ZlcmxhcCB3aXRoIHBpcGUgQywgaG93ZXZlcgo+ID4gPiArCSAqIHBpcGUgQydzIG5ldyBh bGxvY2F0aW9uIGRvZXMgb3ZlcmxhcCB3aXRoIHBpcGUgQidzIGN1cnJlbnQKPiA+ID4gKwkgKiBh bGxvY2F0aW9uLiBSZWFsbG9jYXRlIEIgZmlyc3Qgc28gdGhlIEREQiBsb29rcyBsaWtlIHRoaXM6 Cj4gPiA+ICsJICogICB8ICBCICB8eHh8ICAgQyAgICB8Cj4gPiA+ICsJICogMy4gTm93IHdlIGNh biBzYWZlbHkgcmVhbGxvY2F0ZSBwaXBlIEMgdG8gaXQncyBuZXcgbG9jYXRpb246Cj4gPiA+ICsJ ICogICB8ICBCICB8ICBDICB8eHh4eHh8Cj4gPiA+ICsJICogNC4gRW5hYmxlIGFueSByZW1haW5p bmcgcGlwZXMsIGluIHRoaXMgY2FzZSBBCj4gPiA+ICsJICogICB8ICBCICB8ICBDICB8ICBBICB8 Cj4gPiA+ICsJICoKPiA+ID4gKwkgKiBBcyB3ZWxsLCBiZXR3ZWVuIGV2ZXJ5IHBpcGUgcmVhbGxv Y2F0aW9uIHdlIGhhdmUgdG8gd2FpdCBmb3IgYQo+ID4gPiArCSAqIHZibGFuayBvbiB0aGUgcGlw ZSBzbyB0aGF0IHdlIGVuc3VyZSBpdCdzIG5ldyBhbGxvY2F0aW9uIGhhcyB0YWtlbgo+ID4gPiAr CSAqIGVmZmVjdCBieSB0aGUgdGltZSB3ZSBzdGFydCBtb3ZpbmcgdGhlIG5leHQgcGlwZS4gVGhp cyBjYW4gYmUKPiA+ID4gKwkgKiBza2lwcGVkIG9uIHRoZSBsYXN0IHN0ZXAgd2UgbmVlZCB0byBw ZXJmb3JtLCB3aGljaCBpcyB3aHkgd2Uga2VlcAo+ID4gPiArCSAqIHRyYWNrIG9mIHRoYXQgaW5m b3JtYXRpb24gaGVyZS4gRm9yIGV4YW1wbGUsIGlmIHdlJ3ZlIHJlYWxsb2NhdGVkCj4gPiA+ICsJ ICogYWxsIHRoZSBwaXBlcyB0aGF0IG5lZWQgY2hhbmdpbmcgYnkgdGhlIHRpbWUgd2UgcmVhY2gg c3RlcCAzLCB3ZSBjYW4KPiA+ID4gKwkgKiBmaW5pc2ggd2l0aG91dCB3YWl0aW5nIGZvciB0aGUg cGlwZXMgd2UgY2hhbmdlZCBpbiBzdGVwIDMgdG8gdXBkYXRlLgo+ID4gPiArCSAqLwo+ID4gPiAr CWZvcl9lYWNoX2ludGVsX2NydGNfbWFzayhkZXYsIGludGVsX2NydGMsIHJlYWxsb2NfcGlwZXMp IHsKPiA+ID4gKwkJZW51bSBwaXBlIHBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwo+ID4gPiArCQll bnVtIHNrbF9kZGJfc3RlcCBzdGVwOwo+ID4gPiArCj4gPiA+ICsJCWNzdGF0ZSA9IGludGVsX2F0 b21pY19nZXRfY3J0Y19zdGF0ZShzdGF0ZSwgaW50ZWxfY3J0Yyk7Cj4gPiA+ICsJCWlmIChJU19F UlIoY3N0YXRlKSkKPiA+ID4gKwkJCXJldHVybiBQVFJfRVJSKGNzdGF0ZSk7Cj4gPiA+ICsKPiA+ ID4gKwkJLyogU3RlcCAxOiBQaXBlcyB3ZSdyZSBkaXNhYmxpbmcgLyBoYXZlbid0IGNoYW5nZWQg Ki8KPiA+ID4gKwkJaWYgKHNrbF9kZGJfYWxsb2NhdGlvbl9lcXVhbHMob2xkX2RkYiwgbmV3X2Rk YiwgcGlwZSkgfHwKPiA+ID4gKwkJICAgIG5ld19kZGItPnBpcGVbcGlwZV0uZW5kID09IDApIHsK PiA+ID4gKwkJCXN0ZXAgPSBTS0xfRERCX1NURVBfTk9ORTsKPiA+ID4gKwkJLyogU3RlcCAyLTM6 IEFjdGl2ZSBwaXBlcyB3ZSdyZSByZWFsbG9jYXRpbmcgKi8KPiA+ID4gKwkJfSBlbHNlIGlmIChv bGRfZGRiLT5waXBlW3BpcGVdLmVuZCAhPSAwKSB7Cj4gPiA+ICsJCQlpZiAoc2tsX2RkYl9hbGxv Y2F0aW9uX292ZXJsYXBzKHN0YXRlLCBvbGRfZGRiLCBuZXdfZGRiLAo+ID4gPiArCQkJCQkJCXBp cGUpKQo+ID4gPiArCQkJCXN0ZXAgPSBTS0xfRERCX1NURVBfT1ZFUkxBUDsKPiA+ID4gKwkJCWVs c2UKPiA+ID4gKwkJCQlzdGVwID0gU0tMX0REQl9TVEVQX05PX09WRVJMQVA7Cj4gPiA+ICsJCS8q IFN0ZXAgNDogUGlwZXMgd2UncmUgZW5hYmxpbmcgKi8KPiA+ID4gKwkJfSBlbHNlIHsKPiA+ID4g KwkJCXN0ZXAgPSBTS0xfRERCX1NURVBfRklOQUw7Cj4gPiA+ICsJCX0KPiA+ID4gKwo+ID4gPiAr CQljc3RhdGUtPndtLnNrbC5kZGJfcmVhbGxvYyA9IHN0ZXA7Cj4gPiA+ICsKPiA+ID4gKwkJaWYg KHN0ZXAgPiBpbnRlbF9zdGF0ZS0+bGFzdF9kZGJfc3RlcCkKPiA+ID4gKwkJCWludGVsX3N0YXRl LT5sYXN0X2RkYl9zdGVwID0gc3RlcDsKPiA+ID4gKwl9Cj4gPiA+ICsKPiA+ID4gIAlyZXR1cm4g MDsKPiA+ID4gIH0KPiA+ID4gIAo+ID4gPiBAQCAtNDExMCwxMCArNDA2MywxMyBAQCBza2xfY29w eV93bV9mb3JfcGlwZShzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqZHN0LAo+ID4gPiAgc3RhdGljIGlu dAo+ID4gPiAgc2tsX2NvbXB1dGVfd20oc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQo+ ID4gPiAgewo+ID4gPiArCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5 MTUoc3RhdGUtPmRldik7Cj4gPiA+ICAJc3RydWN0IGRybV9jcnRjICpjcnRjOwo+ID4gPiAgCXN0 cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3N0YXRlOwo+ID4gPiAgCXN0cnVjdCBpbnRlbF9hdG9taWNf c3RhdGUgKmludGVsX3N0YXRlID0gdG9faW50ZWxfYXRvbWljX3N0YXRlKHN0YXRlKTsKPiA+ID4g IAlzdHJ1Y3Qgc2tsX3dtX3ZhbHVlcyAqcmVzdWx0cyA9ICZpbnRlbF9zdGF0ZS0+d21fcmVzdWx0 czsKPiA+ID4gKwlzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGRfZGRiID0gJmRldl9wcml2 LT53bS5za2xfaHcuZGRiOwo+ID4gPiArCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKm5ld19k ZGIgPSAmcmVzdWx0cy0+ZGRiOwo+ID4gPiAgCXN0cnVjdCBza2xfcGlwZV93bSAqcGlwZV93bTsK PiA+ID4gIAlib29sIGNoYW5nZWQgPSBmYWxzZTsKPiA+ID4gIAlpbnQgcmV0LCBpOwo+ID4gPiBA QCAtNDE1Miw3ICs0MTA4LDEwIEBAIHNrbF9jb21wdXRlX3dtKHN0cnVjdCBkcm1fYXRvbWljX3N0 YXRlICpzdGF0ZSkKPiA+ID4gIAkJc3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMgPSB0b19p bnRlbF9jcnRjKGNydGMpOwo+ID4gPiAgCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqaW50ZWxf Y3N0YXRlID0KPiA+ID4gIAkJCXRvX2ludGVsX2NydGNfc3RhdGUoY3N0YXRlKTsKPiA+ID4gKwkJ ZW51bSBza2xfZGRiX3N0ZXAgc3RlcDsKPiA+ID4gKwkJZW51bSBwaXBlIHBpcGU7Cj4gPiA+ICAK PiA+ID4gKwkJcGlwZSA9IGludGVsX2NydGMtPnBpcGU7Cj4gPiA+ICAJCXBpcGVfd20gPSAmaW50 ZWxfY3N0YXRlLT53bS5za2wub3B0aW1hbDsKPiA+ID4gIAkJcmV0ID0gc2tsX3VwZGF0ZV9waXBl X3dtKGNzdGF0ZSwgJnJlc3VsdHMtPmRkYiwgcGlwZV93bSwKPiA+ID4gIAkJCQkJICZjaGFuZ2Vk KTsKPiA+ID4gQEAgLTQxNjcsNyArNDEyNiwxOCBAQCBza2xfY29tcHV0ZV93bShzdHJ1Y3QgZHJt X2F0b21pY19zdGF0ZSAqc3RhdGUpCj4gPiA+ICAJCQljb250aW51ZTsKPiA+ID4gIAo+ID4gPiAg CQlpbnRlbF9jc3RhdGUtPnVwZGF0ZV93bV9wcmUgPSB0cnVlOwo+ID4gPiArCQlzdGVwID0gaW50 ZWxfY3N0YXRlLT53bS5za2wuZGRiX3JlYWxsb2M7Cj4gPiA+ICAJCXNrbF9jb21wdXRlX3dtX3Jl c3VsdHMoY3J0Yy0+ZGV2LCBwaXBlX3dtLCByZXN1bHRzLCBpbnRlbF9jcnRjKTsKPiA+ID4gKwo+ ID4gPiArCQlpZiAoIXNrbF9kZGJfZW50cnlfZXF1YWwoJm9sZF9kZGItPnBpcGVbcGlwZV0sCj4g PiA+ICsJCQkJCSAmbmV3X2RkYi0+cGlwZVtwaXBlXSkpIHsKPiA+ID4gKwkJCURSTV9ERUJVR19L TVMoCj4gPiA+ICsJCQkgICAgIkREQiBjaGFuZ2VzIGZvciBbQ1JUQzolZDpwaXBlICVjXTogKCUz ZCAtICUzZCkgLT4gKCUzZCAtICUzZCkgb24gc3RlcCAlZFxuIiwKPiA+ID4gKwkJCSAgICBpbnRl bF9jcnRjLT5iYXNlLmJhc2UuaWQsIHBpcGVfbmFtZShwaXBlKSwKPiA+ID4gKwkJCSAgICBvbGRf ZGRiLT5waXBlW3BpcGVdLnN0YXJ0LCBvbGRfZGRiLT5waXBlW3BpcGVdLmVuZCwKPiA+ID4gKwkJ CSAgICBuZXdfZGRiLT5waXBlW3BpcGVdLnN0YXJ0LCBuZXdfZGRiLT5waXBlW3BpcGVdLmVuZCwK PiA+ID4gKwkJCSAgICBzdGVwKTsKPiA+ID4gKwkJfQo+ID4gPiAgCX0KPiA+ID4gIAo+ID4gPiAg CXJldHVybiAwOwo+ID4gPiBAQCAtNDE5MSw4ICs0MTYxLDIwIEBAIHN0YXRpYyB2b2lkIHNrbF91 cGRhdGVfd20oc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ID4gPiAgCj4gPiA+ICAJbXV0ZXhfbG9j aygmZGV2X3ByaXYtPndtLndtX211dGV4KTsKPiA+ID4gIAo+ID4gPiAtCXNrbF93cml0ZV93bV92 YWx1ZXMoZGV2X3ByaXYsIHJlc3VsdHMpOwo+ID4gPiAtCXNrbF9mbHVzaF93bV92YWx1ZXMoZGV2 X3ByaXYsIHJlc3VsdHMpOwo+ID4gPiArCS8qCj4gPiA+ICsJICogSWYgdGhpcyBwaXBlIGlzbid0 IGFjdGl2ZSBhbHJlYWR5LCB3ZSdyZSBnb2luZyB0byBiZSBlbmFibGluZyBpdAo+ID4gPiArCSAq IHZlcnkgc29vbi4gU2luY2UgaXQncyBzYWZlIHRvIHVwZGF0ZSB0aGVzZSB3aGlsZSB0aGUgcGlw ZSdzIHNodXQgb2ZmLAo+ID4gPiArCSAqIGp1c3QgZG8gc28gaGVyZS4gQWxyZWFkeSBhY3RpdmUg cGlwZXMgd2lsbCBoYXZlIHRoZWlyIHdhdGVybWFya3MKPiA+ID4gKwkgKiB1cGRhdGVkIG9uY2Ug d2UgdXBkYXRlIHRoZWlyIHBsYW5lcy4KPiA+ID4gKwkgKi8KPiA+ID4gKwlpZiAoIWludGVsX2Ny dGMtPmFjdGl2ZSkgewo+ID4gPiArCQlpbnQgcGxhbmU7Cj4gPiA+ICsKPiA+ID4gKwkJZm9yIChw bGFuZSA9IDA7IHBsYW5lIDwgaW50ZWxfbnVtX3BsYW5lcyhpbnRlbF9jcnRjKTsgcGxhbmUrKykK PiA+ID4gKwkJCXNrbF93cml0ZV9wbGFuZV93bShpbnRlbF9jcnRjLCByZXN1bHRzLCBwbGFuZSk7 Cj4gPiA+ICsKPiA+ID4gKwkJc2tsX3dyaXRlX2N1cnNvcl93bShpbnRlbF9jcnRjLCByZXN1bHRz KTsKPiA+ID4gKwl9Cj4gPiA+ICAKPiA+ID4gIAkvKgo+ID4gPiAgCSAqIFN0b3JlIHRoZSBuZXcg Y29uZmlndXJhdGlvbiAoYnV0IG9ubHkgZm9yIHRoZSBwaXBlcyB0aGF0IGhhdmUKPiA+ID4gLS0g Cj4gPiA+IDIuNy40Cj4gPiAKPiA+IC0tIAo+ID4gVmlsbGUgU3lyasOkbMOkCj4gPiBJbnRlbCBP VEMKPiAKPiAtLSAKPiBNYXR0IFJvcGVyCj4gR3JhcGhpY3MgU29mdHdhcmUgRW5naW5lZXIKPiBJ b1RHIFBsYXRmb3JtIEVuYWJsaW5nICYgRGV2ZWxvcG1lbnQKPiBJbnRlbCBDb3Jwb3JhdGlvbgo+ ICg5MTYpIDM1Ni0yNzk1CgotLSAKVmlsbGUgU3lyasOkbMOkCkludGVsIE9UQwpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753810AbcHDGiZ (ORCPT ); Thu, 4 Aug 2016 02:38:25 -0400 Received: from mga04.intel.com ([192.55.52.120]:50071 "EHLO mga04.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751144AbcHDGiX (ORCPT ); Thu, 4 Aug 2016 02:38:23 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.28,469,1464678000"; d="scan'208";a="1019413926" Date: Thu, 4 Aug 2016 09:34:47 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Matt Roper Cc: Lyude , intel-gfx@lists.freedesktop.org, 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 v6 6/6] drm/i915/skl: Update DDB values atomically with wms/plane attrs Message-ID: <20160804063447.GU4329@intel.com> References: <1470177458-31984-1-git-send-email-cpaul@redhat.com> <1470177458-31984-7-git-send-email-cpaul@redhat.com> <20160803150042.GK4329@intel.com> <20160803221928.GI32025@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20160803221928.GI32025@intel.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 Wed, Aug 03, 2016 at 03:19:28PM -0700, Matt Roper wrote: > On Wed, Aug 03, 2016 at 06:00:42PM +0300, Ville Syrjälä wrote: > > On Tue, Aug 02, 2016 at 06:37:37PM -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() > > > > > > 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 | 288 ++++++++++++++++------------------- > > > 3 files changed, 233 insertions(+), 165 deletions(-) > > > > > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > > > index 59cf513..06295f7 100644 > > > --- a/drivers/gpu/drm/i915/intel_display.c > > > +++ b/drivers/gpu/drm/i915/intel_display.c > > > @@ -12897,16 +12897,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); > > > + } > > > } > > > } > > > > > > @@ -13658,6 +13665,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; > > > + } > > > > Not sure we really need this step stuff. How about? > > > > for_each_crtc > > if (crtc_needs_disabling) > > disable_crtc(); > > > > do { > > progress = false; > > wait_vbl_pipes=0; > > for_each_crtc() { > > if (!active || needs_modeset) > > continue; > > if (!ddb_changed) > > continue; > > if (new_ddb_overlaps_with_any_other_pipes_current_ddb) > > continue; > > commit; > > wait_vbl_pipes |= pipe; > > progress = true; > > } > > wait_vbls(wait_vbl_pipes); > > } while (progress); > > > > for_each_crtc > > if (crtc_needs_enabling) > > enable_crtc(); > > commit; > > } > > Yeah, this approach looks nicer. It's a bit simpler to follow code-wise > and doesn't require us to precompute any ordering during the check phase > so it's a bit more self-contained. It should also scale properly if > future platforms decide to add more pipes. Yep. > > > > > Or if we're paranoid, we could also have an upper bound on the > > loop and assert that we never reach it. > > > > > > Though one thing I don't particularly like about this commit while > > changing the ddb approach is that it's going to make the update > > appear even less atomic. What I'd rather like to do for the normal > > commit path is this: > > > > for_each_crtc > > if (crtc_needs_disabling) > > disable_planes > > for_each_crtc > > if (crtc_needs_disabling) > > disable_crtc > > for_each_crtc > > if (crtc_needs_enabling) > > enable_crtc > > for_each_crtc > > if (active) > > commit_planes; > > > > That way everything would pop in and out as close together as possible. > > Hmm. Actually, I wonder... I'm thinking we should be able to enable all > > crtcs prior to entering the ddb commit loop, on account of no planes > > being enabled on those crtcs until we commit them. And if no planes are > > enabled, running the pipe w/o allocated ddb should be fine. So with that > > approach, I think we should be able to commit all planes within a few > > iterations of the loop, and hence within a few vblanks. > > So this is pretty similar to what we do today, except that we do the > enabling/disabling of each CRTC and its planes all together, right? Yeah. Should provide better experience in case of "genlocked" pipes at least, eg. for those 2 part 4k MST monitors. > Sounds reasonable to me, although I'm not sure we want to mix that > change in with the gen9-specific series Lyude is working on here. Maybe > just do the new gen9 handler that way as part of that series and then > come back and update the non-gen9 handler to follow the new flow as a > separate patch? Sounds good. First fix gen9, then make things pretty :) As far as my idea of enabling the pipes on gen9 before the commit loop, I think that would also avoid having to commit the planes separately on those newly enabled crtcs. My 'progress' loop would take care of those pipes as well (would just have to drop the needs_modeset check). > > > Matt > > > > > > + > > > + intel_update_crtc(crtc, state, old_crtc_state, > > > + &crtc_vblank_mask); > > > + > > > + if (vblank_wait) > > > + intel_wait_for_vblank(state->dev, intel_crtc->pipe); > > > + } > > > +} > > > + > > > +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; > > > @@ -15235,8 +15308,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 = > > > @@ -15326,6 +15397,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 6f5beb3..636c90a 100644 > > > --- a/drivers/gpu/drm/i915/intel_pm.c > > > +++ b/drivers/gpu/drm/i915/intel_pm.c > > > @@ -3816,6 +3816,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, > > > @@ -3832,170 +3837,51 @@ 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) > > > +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, > > > @@ -4038,8 +3924,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; > > > > > > @@ -4071,13 +3959,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; > > > > > > @@ -4086,6 +3972,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 | > > > + * > > > + * 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; > > > } > > > > > > @@ -4110,10 +4063,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; > > > @@ -4152,7 +4108,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); > > > @@ -4167,7 +4126,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; > > > @@ -4191,8 +4161,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); > > > + } > > > > > > /* > > > * Store the new configuration (but only for the pipes that have > > > -- > > > 2.7.4 > > > > -- > > Ville Syrjälä > > Intel OTC > > -- > Matt Roper > Graphics Software Engineer > IoTG Platform Enabling & Development > Intel Corporation > (916) 356-2795 -- Ville Syrjälä Intel OTC