From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v4 2/2] drm: Add DRM_MODE_ROTATE_ and DRM_MODE_REFLECT_ to UAPI Date: Mon, 22 May 2017 19:09:08 +0300 Message-ID: <20170522160908.GA12629@intel.com> References: <20170519205017.23307-1-robert.foss@collabora.com> <20170519205017.23307-2-robert.foss@collabora.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20170519205017.23307-2-robert.foss@collabora.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Robert Foss Cc: nouveau@lists.freedesktop.org, liviu.dudau@arm.com, dri-devel@lists.freedesktop.org, daniel.vetter@intel.com, thellstrom@vmware.com, linux@armlinux.org.uk, tomi.valkeinen@ti.com, linux-graphics-maintainer@vmware.com, bskeggs@redhat.com, Daniel Vetter , malidp@foss.arm.com, linux-arm-msm@vger.kernel.org, intel-gfx@lists.freedesktop.org, Kristian =?iso-8859-1?Q?H=F8gsberg?= , Tomeu Vizoso , Emil Velikov , linux-kernel@vger.kernel.org, freedreno@lists.freedesktop.org List-Id: linux-arm-msm@vger.kernel.org T24gRnJpLCBNYXkgMTksIDIwMTcgYXQgMDQ6NTA6MTdQTSAtMDQwMCwgUm9iZXJ0IEZvc3Mgd3Jv dGU6Cj4gQWRkIERSTV9NT0RFX1JPVEFURV8gYW5kIERSTV9NT0RFX1JFRkxFQ1RfIGRlZmluZXMg dG8gdGhlIFVBUEkKPiBhcyBhIGNvbnZlbmllbmNlLgo+IAo+IElkZWFsbHkgdGhlIERSTV9ST1RB VEVfIGFuZCBEUk1fUkVGTEVDVF8gcHJvcGVydHkgaWRzIGFyZSBsb29rZWQgdXAKPiB0aHJvdWdo IHRoZSBhdG9taWMgQVBJLCBidXQgcmVhbGl6aW5nIHRoYXQgdXNlcnNwYWNlIGlzIGxpa2VseSB0 byB0YWtlCj4gc2hvcnRjdXRzIGFuZCBhc3N1bWUgdGhhdCB0aGUgZW51bSB2YWx1ZXMgYXJlIHdo YXQgaXMgc2VudCBvdmVyIHRoZQo+IHdpcmUuCj4gCj4gQXMgYSByZXN1bHQgdGhlc2UgZGVmaW5l cyBhcmUgcHJvdmlkZWQgcHVyZWx5IGFzIGEgY29udmVuaWVuY2UgdG8KPiB1c2Vyc3BhY2UgYXBw bGljYXRpb25zLgo+IAo+IFNpZ25lZC1vZmYtYnk6IFJvYmVydCBGb3NzIDxyb2JlcnQuZm9zc0Bj b2xsYWJvcmEuY29tPgo+IFJldmlld2VkLWJ5OiBFbWlsIFZlbGlrb3YgPGVtaWwudmVsaWtvdkBj b2xsYWJvcmEuY29tPgo+IFJldmlld2VkLWJ5OiBTaW5jbGFpciBZZWggPHN5ZWhAdm13YXJlLmNv bT4KPiBBY2tlZC1ieTogTGl2aXUgRHVkYXUgPExpdml1LkR1ZGF1QGFybS5jb20+Cj4gLS0tCj4g Q2hhbmdlcyBzaW5jZSB2MzoKPiAgLSBTd2l0Y2hlZCBhd2F5IGZyb20gcGFzdCB0ZW5zZSBpbiBj b21tZW50cwo+ICAtIEFkZCBkZWZpbmUgbmFtZSBjaGFuZ2UgdG8gcHJldmlvdXNseSBtaXMtc3Bl bGxlZCBEUk1fUkVGTEVDVF9YIGNvbW1lbnQKPiAgLSBJbXByb3ZlZCB0aGUgY29tbWVudCBmb3Ig dGhlIERSTV9NT0RFX1JFRkxFQ1RfPGF4aXM+IGNvbW1lbnQKPiAKPiBDaGFuZ2VzIHNpbmNlIHYy Ogo+ICAtIENoYW5nZWQgZGVmaW5lIHByZWZpeCBmcm9tIERSTV9NT0RFX1BST1BfIHRvIERSTV9N T0RFXwo+ICAtIEZpeCBjb21waWxhdGlvbiBlcnJvcnMKPiAgLSBDaGFuZ2VkIGNvbW1lbnQgZm9y bWF0dGluZwo+ICAtIERlZHVwbGljYXRlZCBjb21tZW50IGxpbmVzCj4gIC0gQ2xhcmlmaWVkIERS TV9NT0RFX1BST1BfUkVGTEVDVF8gY29tbWVudAo+IAo+IENoYW5nZXMgc2luY2UgdjE6Cj4gIC0g TW92ZWQgZGVmaW5lcyBmcm9tIGRybS5oIHRvIGRybV9tb2RlLmgKPiAgLSBDaGFuZ2VkIGRlZmlu ZSBwcmVmaXggZnJvbSBEUk1fIHRvIERSTV9NT0RFX1BST1BfIAo+ICAtIFVwZGF0ZWQgdXNlcyBv ZiB0aGUgZGVmaW5lcyB0byB0aGUgbmV3IHByZWZpeAo+ICAtIFJlbW92ZWQgaW5jbHVkZSBmcm9t IGRybV9yZWN0LmMKPiAgLSBTdG9wcGVkIHVzaW5nIHRoZSBCSVQoKSBtYWNybyAKPiAKPiAgZHJp dmVycy9ncHUvZHJtL2FybS9tYWxpZHBfZHJ2LmggICAgICAgICAgICAgICAgfCAgMiArLQo+ICBk cml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9wbGFuZXMuYyAgICAgICAgICAgICB8IDE4ICsrKyst LS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vYXJtYWRhL2FybWFkYV9vdmVybGF5LmMgICAgICAgICB8 ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9hdG1lbC1obGNkYy9hdG1lbF9obGNkY19wbGFuZS5j IHwgMjAgKysrKystLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jICAgICAgICAg ICAgICAgICAgICB8ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX2hlbHBlci5j ICAgICAgICAgICAgIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV9ibGVuZC5jICAgICAg ICAgICAgICAgICAgICAgfCA0NSArKysrKysrKysrKy0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvZ3B1 L2RybS9kcm1fZmJfaGVscGVyLmMgICAgICAgICAgICAgICAgIHwgIDQgKy0KPiAgZHJpdmVycy9n cHUvZHJtL2RybV9wbGFuZV9oZWxwZXIuYyAgICAgICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJz L2dwdS9kcm0vZHJtX3JlY3QuYyAgICAgICAgICAgICAgICAgICAgICB8IDM2ICsrKysrKysrKy0t LS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYyAgICAgICAgICAg ICB8IDE0ICsrKy0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfYXRvbWljX3BsYW5l LmMgICAgICAgfCAgNiArLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5j ICAgICAgICAgICAgfCA1MCArKysrKysrKysrKystLS0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2ZiYy5jICAgICAgICAgICAgICAgIHwgIDIgKy0KPiAgZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfZmJkZXYuYyAgICAgICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9zcHJpdGUuYyAgICAgICAgICAgICB8IDIwICsrKysrLS0tLS0K PiAgZHJpdmVycy9ncHUvZHJtL2lteC9pcHV2My1wbGFuZS5jICAgICAgICAgICAgICAgfCAgMiAr LQo+ICBkcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVfcGxhbmUuYyAgICAgICB8IDMw ICsrKysrKystLS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX2Rpc3BsYXku YyAgICAgICAgICB8ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZHJ2LmMg ICAgICAgICAgICAgIHwgIDQgKy0KPiAgZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vb21hcF9mYi5j ICAgICAgICAgICAgICAgfCAxOCArKysrLS0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL29tYXBkcm0v b21hcF9wbGFuZS5jICAgICAgICAgICAgfCAxNiArKysrLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0v dm13Z2Z4L3Ztd2dmeF9rbXMuYyAgICAgICAgICAgICB8ICA0ICstCj4gIGluY2x1ZGUvZHJtL2Ry bV9ibGVuZC5oICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjEgKy0tLS0tLS0tLS0KPiAgaW5j bHVkZS91YXBpL2RybS9kcm1fbW9kZS5oICAgICAgICAgICAgICAgICAgICAgfCA0OSArKysrKysr KysrKysrKysrKysrKysrKy0KPiAgMjUgZmlsZXMgY2hhbmdlZCwgMjAyIGluc2VydGlvbnMoKyks IDE3MSBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FybS9t YWxpZHBfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vYXJtL21hbGlkcF9kcnYuaAo+IGluZGV4IDA0 MDMxMWZmY2FlYy4uMmUyMDMzMTQwZWZjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9h cm0vbWFsaWRwX2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FybS9tYWxpZHBfZHJ2LmgK PiBAQCAtNjUsNiArNjUsNiBAQCB2b2lkIG1hbGlkcF9kZV9wbGFuZXNfZGVzdHJveShzdHJ1Y3Qg ZHJtX2RldmljZSAqZHJtKTsKPiAgaW50IG1hbGlkcF9jcnRjX2luaXQoc3RydWN0IGRybV9kZXZp Y2UgKmRybSk7Cj4gIAo+ICAvKiBvZnRlbiB1c2VkIGNvbWJpbmF0aW9uIG9mIHJvdGF0aW9uYWwg Yml0cyAqLwo+IC0jZGVmaW5lIE1BTElEUF9ST1RBVEVEX01BU0sJKERSTV9ST1RBVEVfOTAgfCBE Uk1fUk9UQVRFXzI3MCkKPiArI2RlZmluZSBNQUxJRFBfUk9UQVRFRF9NQVNLCShEUk1fTU9ERV9S T1RBVEVfOTAgfCBEUk1fTU9ERV9ST1RBVEVfMjcwKQo+ICAKPiAgI2VuZGlmICAvKiBfX01BTElE UF9EUlZfSF9fICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX3Bs YW5lcy5jIGIvZHJpdmVycy9ncHUvZHJtL2FybS9tYWxpZHBfcGxhbmVzLmMKPiBpbmRleCA4MTRm ZGEyM2NlYWQuLjA2M2E4ZDJiMGJlMyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYXJt L21hbGlkcF9wbGFuZXMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm0vbWFsaWRwX3BsYW5l cy5jCj4gQEAgLTgwLDcgKzgwLDcgQEAgc3RhdGljIHZvaWQgbWFsaWRwX3BsYW5lX3Jlc2V0KHN0 cnVjdCBkcm1fcGxhbmUgKnBsYW5lKQo+ICAJc3RhdGUgPSBremFsbG9jKHNpemVvZigqc3RhdGUp LCBHRlBfS0VSTkVMKTsKPiAgCWlmIChzdGF0ZSkgewo+ICAJCXN0YXRlLT5iYXNlLnBsYW5lID0g cGxhbmU7Cj4gLQkJc3RhdGUtPmJhc2Uucm90YXRpb24gPSBEUk1fUk9UQVRFXzA7Cj4gKwkJc3Rh dGUtPmJhc2Uucm90YXRpb24gPSBEUk1fTU9ERV9ST1RBVEVfMDsKPiAgCQlwbGFuZS0+c3RhdGUg PSAmc3RhdGUtPmJhc2U7Cj4gIAl9Cj4gIH0KPiBAQCAtMjIxLDcgKzIyMSw3IEBAIHN0YXRpYyBp bnQgbWFsaWRwX2RlX3BsYW5lX2NoZWNrKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICAJCXJl dHVybiByZXQ7Cj4gIAo+ICAJLyogcGFja2VkIFJHQjg4OCAvIEJHUjg4OCBjYW4ndCBiZSByb3Rh dGVkIG9yIGZsaXBwZWQgKi8KPiAtCWlmIChzdGF0ZS0+cm90YXRpb24gIT0gRFJNX1JPVEFURV8w ICYmCj4gKwlpZiAoc3RhdGUtPnJvdGF0aW9uICE9IERSTV9NT0RFX1JPVEFURV8wICYmCj4gIAkg ICAgKGZiLT5mb3JtYXQtPmZvcm1hdCA9PSBEUk1fRk9STUFUX1JHQjg4OCB8fAo+ICAJICAgICBm Yi0+Zm9ybWF0LT5mb3JtYXQgPT0gRFJNX0ZPUk1BVF9CR1I4ODgpKQo+ICAJCXJldHVybiAtRUlO VkFMOwo+IEBAIC0zMTUsMTIgKzMxNSwxMiBAQCBzdGF0aWMgdm9pZCBtYWxpZHBfZGVfcGxhbmVf dXBkYXRlKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICAJdmFsICY9IH5MQVlFUl9ST1RfTUFT SzsKPiAgCj4gIAkvKiBzZXR1cCB0aGUgcm90YXRpb24gYW5kIGF4aXMgZmxpcCBiaXRzICovCj4g LQlpZiAocGxhbmUtPnN0YXRlLT5yb3RhdGlvbiAmIERSTV9ST1RBVEVfTUFTSykKPiAtCQl2YWwg fD0gaWxvZzIocGxhbmUtPnN0YXRlLT5yb3RhdGlvbiAmIERSTV9ST1RBVEVfTUFTSykgPDwKPiAr CWlmIChwbGFuZS0+c3RhdGUtPnJvdGF0aW9uICYgRFJNX01PREVfUk9UQVRFX01BU0spCj4gKwkJ dmFsIHw9IGlsb2cyKHBsYW5lLT5zdGF0ZS0+cm90YXRpb24gJiBEUk1fTU9ERV9ST1RBVEVfTUFT SykgPDwKPiAgCQkgICAgICAgTEFZRVJfUk9UX09GRlNFVDsKPiAtCWlmIChwbGFuZS0+c3RhdGUt PnJvdGF0aW9uICYgRFJNX1JFRkxFQ1RfWCkKPiArCWlmIChwbGFuZS0+c3RhdGUtPnJvdGF0aW9u ICYgRFJNX01PREVfUkVGTEVDVF9YKQo+ICAJCXZhbCB8PSBMQVlFUl9IX0ZMSVA7Cj4gLQlpZiAo cGxhbmUtPnN0YXRlLT5yb3RhdGlvbiAmIERSTV9SRUZMRUNUX1kpCj4gKwlpZiAocGxhbmUtPnN0 YXRlLT5yb3RhdGlvbiAmIERSTV9NT0RFX1JFRkxFQ1RfWSkKPiAgCQl2YWwgfD0gTEFZRVJfVl9G TElQOwo+ICAKPiAgCS8qCj4gQEAgLTM3MCw4ICszNzAsOCBAQCBpbnQgbWFsaWRwX2RlX3BsYW5l c19pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0pCj4gIAlzdHJ1Y3QgbWFsaWRwX3BsYW5lICpw bGFuZSA9IE5VTEw7Cj4gIAllbnVtIGRybV9wbGFuZV90eXBlIHBsYW5lX3R5cGU7Cj4gIAl1bnNp Z25lZCBsb25nIGNydGNzID0gMSA8PCBkcm0tPm1vZGVfY29uZmlnLm51bV9jcnRjOwo+IC0JdW5z aWduZWQgbG9uZyBmbGFncyA9IERSTV9ST1RBVEVfMCB8IERSTV9ST1RBVEVfOTAgfCBEUk1fUk9U QVRFXzE4MCB8Cj4gLQkJCSAgICAgIERSTV9ST1RBVEVfMjcwIHwgRFJNX1JFRkxFQ1RfWCB8IERS TV9SRUZMRUNUX1k7Cj4gKwl1bnNpZ25lZCBsb25nIGZsYWdzID0gRFJNX01PREVfUk9UQVRFXzAg fCBEUk1fTU9ERV9ST1RBVEVfOTAgfCBEUk1fTU9ERV9ST1RBVEVfMTgwIHwKPiArCQkJICAgICAg RFJNX01PREVfUk9UQVRFXzI3MCB8IERSTV9NT0RFX1JFRkxFQ1RfWCB8IERSTV9NT0RFX1JFRkxF Q1RfWTsKPiAgCXUzMiAqZm9ybWF0czsKPiAgCWludCByZXQsIGksIGosIG47Cj4gIAo+IEBAIC00 MjAsNyArNDIwLDcgQEAgaW50IG1hbGlkcF9kZV9wbGFuZXNfaW5pdChzdHJ1Y3QgZHJtX2Rldmlj ZSAqZHJtKQo+ICAJCQljb250aW51ZTsKPiAgCQl9Cj4gIAo+IC0JCWRybV9wbGFuZV9jcmVhdGVf cm90YXRpb25fcHJvcGVydHkoJnBsYW5lLT5iYXNlLCBEUk1fUk9UQVRFXzAsIGZsYWdzKTsKPiAr CQlkcm1fcGxhbmVfY3JlYXRlX3JvdGF0aW9uX3Byb3BlcnR5KCZwbGFuZS0+YmFzZSwgRFJNX01P REVfUk9UQVRFXzAsIGZsYWdzKTsKPiAgCQltYWxpZHBfaHdfd3JpdGUobWFsaWRwLT5kZXYsIE1B TElEUF9BTFBIQV9MVVQsCj4gIAkJCQlwbGFuZS0+bGF5ZXItPmJhc2UgKyBNQUxJRFBfTEFZRVJf Q09NUE9TRSk7Cj4gIAl9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJt YWRhX292ZXJsYXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX292ZXJsYXkuYwo+ IGluZGV4IDQyNGU0NjVmZjQwNy4uZTlhMjlkZjRiNDQzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv Z3B1L2RybS9hcm1hZGEvYXJtYWRhX292ZXJsYXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9h cm1hZGEvYXJtYWRhX292ZXJsYXkuYwo+IEBAIC0xMjUsNyArMTI1LDcgQEAgYXJtYWRhX292bF9w bGFuZV91cGRhdGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsIHN0cnVjdCBkcm1fY3J0YyAqY3J0 YywKPiAgCQkJCSBzcmNfeCwgc3JjX3ksIHNyY193LCBzcmNfaCk7Cj4gIAo+ICAJcmV0ID0gZHJt X3BsYW5lX2hlbHBlcl9jaGVja191cGRhdGUocGxhbmUsIGNydGMsIGZiLCAmc3JjLCAmZGVzdCwg JmNsaXAsCj4gLQkJCQkJICAgIERSTV9ST1RBVEVfMCwKPiArCQkJCQkgICAgRFJNX01PREVfUk9U QVRFXzAsCj4gIAkJCQkJICAgIDAsIElOVF9NQVgsIHRydWUsIGZhbHNlLCAmdmlzaWJsZSk7Cj4g IAlpZiAocmV0KQo+ICAJCXJldHVybiByZXQ7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9hdG1lbC1obGNkYy9hdG1lbF9obGNkY19wbGFuZS5jIGIvZHJpdmVycy9ncHUvZHJtL2F0bWVs LWhsY2RjL2F0bWVsX2hsY2RjX3BsYW5lLmMKPiBpbmRleCAyOWNjMTBkMDUzZWIuLjExMjQyMDBi YjI4MCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYXRtZWwtaGxjZGMvYXRtZWxfaGxj ZGNfcGxhbmUuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hdG1lbC1obGNkYy9hdG1lbF9obGNk Y19wbGFuZS5jCj4gQEAgLTY3OCw4ICs2NzgsOCBAQCBzdGF0aWMgaW50IGF0bWVsX2hsY2RjX3Bs YW5lX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX3BsYW5lICpwLAo+ICAJCWlmICghc3RhdGUtPmJw cFtpXSkKPiAgCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+IC0JCXN3aXRjaCAoc3RhdGUtPmJhc2Uu cm90YXRpb24gJiBEUk1fUk9UQVRFX01BU0spIHsKPiAtCQljYXNlIERSTV9ST1RBVEVfOTA6Cj4g KwkJc3dpdGNoIChzdGF0ZS0+YmFzZS5yb3RhdGlvbiAmIERSTV9NT0RFX1JPVEFURV9NQVNLKSB7 Cj4gKwkJY2FzZSBEUk1fTU9ERV9ST1RBVEVfOTA6Cj4gIAkJCW9mZnNldCA9ICgoeV9vZmZzZXQg KyBzdGF0ZS0+c3JjX3kgKyBwYXRjaGVkX3NyY193IC0gMSkgLwo+ICAJCQkJICB5ZGl2KSAqIGZi LT5waXRjaGVzW2ldOwo+ICAJCQlvZmZzZXQgKz0gKCh4X29mZnNldCArIHN0YXRlLT5zcmNfeCkg LyB4ZGl2KSAqCj4gQEAgLTY4OCw3ICs2ODgsNyBAQCBzdGF0aWMgaW50IGF0bWVsX2hsY2RjX3Bs YW5lX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX3BsYW5lICpwLAo+ICAJCQkJCSAgZmItPnBpdGNo ZXNbaV07Cj4gIAkJCXN0YXRlLT5wc3RyaWRlW2ldID0gLWZiLT5waXRjaGVzW2ldIC0gc3RhdGUt PmJwcFtpXTsKPiAgCQkJYnJlYWs7Cj4gLQkJY2FzZSBEUk1fUk9UQVRFXzE4MDoKPiArCQljYXNl IERSTV9NT0RFX1JPVEFURV8xODA6Cj4gIAkJCW9mZnNldCA9ICgoeV9vZmZzZXQgKyBzdGF0ZS0+ c3JjX3kgKyBwYXRjaGVkX3NyY19oIC0gMSkgLwo+ICAJCQkJICB5ZGl2KSAqIGZiLT5waXRjaGVz W2ldOwo+ICAJCQlvZmZzZXQgKz0gKCh4X29mZnNldCArIHN0YXRlLT5zcmNfeCArIHBhdGNoZWRf c3JjX3cgLSAxKSAvCj4gQEAgLTY5Nyw3ICs2OTcsNyBAQCBzdGF0aWMgaW50IGF0bWVsX2hsY2Rj X3BsYW5lX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX3BsYW5lICpwLAo+ICAJCQkJCSAgIHN0YXRl LT5icHBbaV0pIC0gZmItPnBpdGNoZXNbaV07Cj4gIAkJCXN0YXRlLT5wc3RyaWRlW2ldID0gLTIg KiBzdGF0ZS0+YnBwW2ldOwo+ICAJCQlicmVhazsKPiAtCQljYXNlIERSTV9ST1RBVEVfMjcwOgo+ ICsJCWNhc2UgRFJNX01PREVfUk9UQVRFXzI3MDoKPiAgCQkJb2Zmc2V0ID0gKCh5X29mZnNldCAr IHN0YXRlLT5zcmNfeSkgLyB5ZGl2KSAqCj4gIAkJCQkgZmItPnBpdGNoZXNbaV07Cj4gIAkJCW9m ZnNldCArPSAoKHhfb2Zmc2V0ICsgc3RhdGUtPnNyY194ICsgcGF0Y2hlZF9zcmNfaCAtIDEpIC8K PiBAQCAtNzA3LDcgKzcwNyw3IEBAIHN0YXRpYyBpbnQgYXRtZWxfaGxjZGNfcGxhbmVfYXRvbWlj X2NoZWNrKHN0cnVjdCBkcm1fcGxhbmUgKnAsCj4gIAkJCQkJICAoMiAqIHN0YXRlLT5icHBbaV0p Owo+ICAJCQlzdGF0ZS0+cHN0cmlkZVtpXSA9IGZiLT5waXRjaGVzW2ldIC0gc3RhdGUtPmJwcFtp XTsKPiAgCQkJYnJlYWs7Cj4gLQkJY2FzZSBEUk1fUk9UQVRFXzA6Cj4gKwkJY2FzZSBEUk1fTU9E RV9ST1RBVEVfMDoKPiAgCQlkZWZhdWx0Ogo+ICAJCQlvZmZzZXQgPSAoKHlfb2Zmc2V0ICsgc3Rh dGUtPnNyY195KSAvIHlkaXYpICoKPiAgCQkJCSBmYi0+cGl0Y2hlc1tpXTsKPiBAQCAtODY0LDEx ICs4NjQsMTEgQEAgc3RhdGljIGludCBhdG1lbF9obGNkY19wbGFuZV9pbml0X3Byb3BlcnRpZXMo c3RydWN0IGF0bWVsX2hsY2RjX3BsYW5lICpwbGFuZSwKPiAgCQlpbnQgcmV0Owo+ICAKPiAgCQly ZXQgPSBkcm1fcGxhbmVfY3JlYXRlX3JvdGF0aW9uX3Byb3BlcnR5KCZwbGFuZS0+YmFzZSwKPiAt CQkJCQkJCSBEUk1fUk9UQVRFXzAsCj4gLQkJCQkJCQkgRFJNX1JPVEFURV8wIHwKPiAtCQkJCQkJ CSBEUk1fUk9UQVRFXzkwIHwKPiAtCQkJCQkJCSBEUk1fUk9UQVRFXzE4MCB8Cj4gLQkJCQkJCQkg RFJNX1JPVEFURV8yNzApOwo+ICsJCQkJCQkJIERSTV9NT0RFX1JPVEFURV8wLAo+ICsJCQkJCQkJ IERSTV9NT0RFX1JPVEFURV8wIHwKPiArCQkJCQkJCSBEUk1fTU9ERV9ST1RBVEVfOTAgfAo+ICsJ CQkJCQkJIERSTV9NT0RFX1JPVEFURV8xODAgfAo+ICsJCQkJCQkJIERSTV9NT0RFX1JPVEFURV8y NzApOwo+ICAJCWlmIChyZXQpCj4gIAkJCXJldHVybiByZXQ7Cj4gIAl9Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21p Yy5jCj4gaW5kZXggZjMyNTA2YTdjMWQ2Li5mNDM0ZDc5ZGUzN2UgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRv bWljLmMKPiBAQCAtNzY5LDcgKzc2OSw3IEBAIGludCBkcm1fYXRvbWljX3BsYW5lX3NldF9wcm9w ZXJ0eShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiAgCX0gZWxzZSBpZiAocHJvcGVydHkgPT0g Y29uZmlnLT5wcm9wX3NyY19oKSB7Cj4gIAkJc3RhdGUtPnNyY19oID0gdmFsOwo+ICAJfSBlbHNl IGlmIChwcm9wZXJ0eSA9PSBwbGFuZS0+cm90YXRpb25fcHJvcGVydHkpIHsKPiAtCQlpZiAoIWlz X3Bvd2VyX29mXzIodmFsICYgRFJNX1JPVEFURV9NQVNLKSkKPiArCQlpZiAoIWlzX3Bvd2VyX29m XzIodmFsICYgRFJNX01PREVfUk9UQVRFX01BU0spKQo+ICAJCQlyZXR1cm4gLUVJTlZBTDsKPiAg CQlzdGF0ZS0+cm90YXRpb24gPSB2YWw7Cj4gIAl9IGVsc2UgaWYgKHByb3BlcnR5ID09IHBsYW5l LT56cG9zX3Byb3BlcnR5KSB7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRv bWljX2hlbHBlci5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMKPiBpbmRl eCA4YmU5NzE5Mjg0YjAuLjE2NWJhYTlhMzdlMSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9k cm0vZHJtX2F0b21pY19oZWxwZXIuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWlj X2hlbHBlci5jCj4gQEAgLTMyMjAsNyArMzIyMCw3IEBAIHZvaWQgZHJtX2F0b21pY19oZWxwZXJf cGxhbmVfcmVzZXQoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCj4gIAo+ICAJaWYgKHBsYW5lLT5z dGF0ZSkgewo+ICAJCXBsYW5lLT5zdGF0ZS0+cGxhbmUgPSBwbGFuZTsKPiAtCQlwbGFuZS0+c3Rh dGUtPnJvdGF0aW9uID0gRFJNX1JPVEFURV8wOwo+ICsJCXBsYW5lLT5zdGF0ZS0+cm90YXRpb24g PSBEUk1fTU9ERV9ST1RBVEVfMDsKPiAgCX0KPiAgfQo+ICBFWFBPUlRfU1lNQk9MKGRybV9hdG9t aWNfaGVscGVyX3BsYW5lX3Jlc2V0KTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2Ry bV9ibGVuZC5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9ibGVuZC5jCj4gaW5kZXggZGVlNjdlZjZj NjcwLi5kYjZhZWVjNTBiODIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9ibGVu ZC5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9ibGVuZC5jCj4gQEAgLTExOSwxNyArMTE5 LDE3IEBACj4gICAqIGRybV9wcm9wZXJ0eV9jcmVhdGVfYml0bWFzaygpKSBjYWxsZWQgInJvdGF0 aW9uIiBhbmQgaGFzIHRoZSBmb2xsb3dpbmcKPiAgICogYml0bWFzayBlbnVtYXJhdGlvbiB2YWx1 ZXM6Cj4gICAqCj4gLSAqIERSTV9ST1RBVEVfMDoKPiArICogRFJNX01PREVfUk9UQVRFXzA6Cj4g ICAqIAkicm90YXRlLTAiCj4gLSAqIERSTV9ST1RBVEVfOTA6Cj4gKyAqIERSTV9NT0RFX1JPVEFU RV85MDoKPiAgICogCSJyb3RhdGUtOTAiCj4gLSAqIERSTV9ST1RBVEVfMTgwOgo+ICsgKiBEUk1f TU9ERV9ST1RBVEVfMTgwOgo+ICAgKiAJInJvdGF0ZS0xODAiCj4gLSAqIERSTV9ST1RBVEVfMjcw Ogo+ICsgKiBEUk1fTU9ERV9ST1RBVEVfMjcwOgo+ICAgKiAJInJvdGF0ZS0yNzAiCj4gLSAqIERS TV9SRUZMRUNUX1g6Cj4gKyAqIERSTV9NT0RFX1JFRkxFQ1RfWDoKPiAgICogCSJyZWZsZWN0LXgi Cj4gLSAqIERSTV9SRUZMRUNUX1k6Cj4gKyAqIERSTV9NT0RFX1JFRkxFQ1RfWToKPiAgICogCSJy ZWZsZWN0LXkiCj4gICAqCj4gICAqIFJvdGF0aW9uIGlzIHRoZSBzcGVjaWZpZWQgYW1vdW50IGlu IGRlZ3JlZXMgaW4gY291bnRlciBjbG9ja3dpc2UgZGlyZWN0aW9uLAo+IEBAIC0xNDIsMTcgKzE0 MiwxNyBAQCBpbnQgZHJtX3BsYW5lX2NyZWF0ZV9yb3RhdGlvbl9wcm9wZXJ0eShzdHJ1Y3QgZHJt X3BsYW5lICpwbGFuZSwKPiAgCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgc3VwcG9ydGVkX3JvdGF0 aW9ucykKPiAgewo+ICAJc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fcHJvcF9lbnVtX2xpc3QgcHJv cHNbXSA9IHsKPiAtCQl7IF9fYnVpbHRpbl9mZnMoRFJNX1JPVEFURV8wKSAtIDEsICAgInJvdGF0 ZS0wIiB9LAo+IC0JCXsgX19idWlsdGluX2ZmcyhEUk1fUk9UQVRFXzkwKSAtIDEsICAicm90YXRl LTkwIiB9LAo+IC0JCXsgX19idWlsdGluX2ZmcyhEUk1fUk9UQVRFXzE4MCkgLSAxLCAicm90YXRl LTE4MCIgfSwKPiAtCQl7IF9fYnVpbHRpbl9mZnMoRFJNX1JPVEFURV8yNzApIC0gMSwgInJvdGF0 ZS0yNzAiIH0sCj4gLQkJeyBfX2J1aWx0aW5fZmZzKERSTV9SRUZMRUNUX1gpIC0gMSwgICJyZWZs ZWN0LXgiIH0sCj4gLQkJeyBfX2J1aWx0aW5fZmZzKERSTV9SRUZMRUNUX1kpIC0gMSwgICJyZWZs ZWN0LXkiIH0sCj4gKwkJeyBfX2J1aWx0aW5fZmZzKERSTV9NT0RFX1JPVEFURV8wKSAtIDEsICAg InJvdGF0ZS0wIiB9LAo+ICsJCXsgX19idWlsdGluX2ZmcyhEUk1fTU9ERV9ST1RBVEVfOTApIC0g MSwgICJyb3RhdGUtOTAiIH0sCj4gKwkJeyBfX2J1aWx0aW5fZmZzKERSTV9NT0RFX1JPVEFURV8x ODApIC0gMSwgInJvdGF0ZS0xODAiIH0sCj4gKwkJeyBfX2J1aWx0aW5fZmZzKERSTV9NT0RFX1JP VEFURV8yNzApIC0gMSwgInJvdGF0ZS0yNzAiIH0sCj4gKwkJeyBfX2J1aWx0aW5fZmZzKERSTV9N T0RFX1JFRkxFQ1RfWCkgLSAxLCAgInJlZmxlY3QteCIgfSwKPiArCQl7IF9fYnVpbHRpbl9mZnMo RFJNX01PREVfUkVGTEVDVF9ZKSAtIDEsICAicmVmbGVjdC15IiB9LAo+ICAJfTsKPiAgCXN0cnVj dCBkcm1fcHJvcGVydHkgKnByb3A7Cj4gIAo+IC0JV0FSTl9PTigoc3VwcG9ydGVkX3JvdGF0aW9u cyAmIERSTV9ST1RBVEVfTUFTSykgPT0gMCk7Cj4gLQlXQVJOX09OKCFpc19wb3dlcl9vZl8yKHJv dGF0aW9uICYgRFJNX1JPVEFURV9NQVNLKSk7Cj4gKwlXQVJOX09OKChzdXBwb3J0ZWRfcm90YXRp b25zICYgRFJNX01PREVfUk9UQVRFX01BU0spID09IDApOwo+ICsJV0FSTl9PTighaXNfcG93ZXJf b2ZfMihyb3RhdGlvbiAmIERSTV9NT0RFX1JPVEFURV9NQVNLKSk7Cj4gIAlXQVJOX09OKHJvdGF0 aW9uICYgfnN1cHBvcnRlZF9yb3RhdGlvbnMpOwo+ICAKPiAgCXByb3AgPSBkcm1fcHJvcGVydHlf Y3JlYXRlX2JpdG1hc2socGxhbmUtPmRldiwgMCwgInJvdGF0aW9uIiwKPiBAQCAtMTc4LDE0ICsx NzgsMTQgQEAgRVhQT1JUX1NZTUJPTChkcm1fcGxhbmVfY3JlYXRlX3JvdGF0aW9uX3Byb3BlcnR5 KTsKPiAgICogQHN1cHBvcnRlZF9yb3RhdGlvbnM6IFN1cHBvcnRlZCByb3RhdGlvbnMKPiAgICoK PiAgICogQXR0ZW1wdCB0byBzaW1wbGlmeSB0aGUgcm90YXRpb24gdG8gYSBmb3JtIHRoYXQgaXMg c3VwcG9ydGVkLgo+IC0gKiBFZy4gaWYgdGhlIGhhcmR3YXJlIHN1cHBvcnRzIGV2ZXJ5dGhpbmcg ZXhjZXB0IERSTV9SRUZMRUNUX1gKPiArICogRWcuIGlmIHRoZSBoYXJkd2FyZSBzdXBwb3J0cyBl dmVyeXRoaW5nIGV4Y2VwdCBEUk1fTU9ERV9SRUZMRUNUX1gKPiAgICogb25lIGNvdWxkIGNhbGwg dGhpcyBmdW5jdGlvbiBsaWtlIHRoaXM6Cj4gICAqCj4gLSAqIGRybV9yb3RhdGlvbl9zaW1wbGlm eShyb3RhdGlvbiwgRFJNX1JPVEFURV8wIHwKPiAtICogICAgICAgICAgICAgICAgICAgICAgIERS TV9ST1RBVEVfOTAgfCBEUk1fUk9UQVRFXzE4MCB8Cj4gLSAqICAgICAgICAgICAgICAgICAgICAg ICBEUk1fUk9UQVRFXzI3MCB8IERSTV9SRUZMRUNUX1kpOwo+ICsgKiBkcm1fcm90YXRpb25fc2lt cGxpZnkocm90YXRpb24sIERSTV9NT0RFX1JPVEFURV8wIHwKPiArICogICAgICAgICAgICAgICAg ICAgICAgIERSTV9NT0RFX1JPVEFURV85MCB8IERSTV9NT0RFX1JPVEFURV8xODAgfAo+ICsgKiAg ICAgICAgICAgICAgICAgICAgICAgRFJNX01PREVfUk9UQVRFXzI3MCB8IERSTV9NT0RFX1JFRkxF Q1RfWSk7Cj4gICAqCj4gLSAqIHRvIGVsaW1pbmF0ZSB0aGUgRFJNX1JPVEFURV9YIGZsYWcuIERl cGVuZGluZyBvbiB3aGF0IGtpbmQgb2YKPiArICogdG8gZWxpbWluYXRlIHRoZSBEUk1fTU9ERV9S T1RBVEVfWCBmbGFnLiBEZXBlbmRpbmcgb24gd2hhdCBraW5kIG9mCj4gICAqIHRyYW5zZm9ybXMg dGhlIGhhcmR3YXJlIHN1cHBvcnRzLCB0aGlzIGZ1bmN0aW9uIG1heSBub3QKPiAgICogYmUgYWJs ZSB0byBwcm9kdWNlIGEgc3VwcG9ydGVkIHRyYW5zZm9ybSwgc28gdGhlIGNhbGxlciBzaG91bGQK PiAgICogY2hlY2sgdGhlIHJlc3VsdCBhZnRlcndhcmRzLgo+IEBAIC0xOTQsOSArMTk0LDEwIEBA IHVuc2lnbmVkIGludCBkcm1fcm90YXRpb25fc2ltcGxpZnkodW5zaWduZWQgaW50IHJvdGF0aW9u LAo+ICAJCQkJICAgdW5zaWduZWQgaW50IHN1cHBvcnRlZF9yb3RhdGlvbnMpCj4gIHsKPiAgCWlm IChyb3RhdGlvbiAmIH5zdXBwb3J0ZWRfcm90YXRpb25zKSB7Cj4gLQkJcm90YXRpb24gXj0gRFJN X1JFRkxFQ1RfWCB8IERSTV9SRUZMRUNUX1k7Cj4gLQkJcm90YXRpb24gPSAocm90YXRpb24gJiBE Uk1fUkVGTEVDVF9NQVNLKSB8Cj4gLQkJICAgICAgICAgICBCSVQoKGZmcyhyb3RhdGlvbiAmIERS TV9ST1RBVEVfTUFTSykgKyAxKSAlIDQpOwo+ICsJCXJvdGF0aW9uIF49IERSTV9NT0RFX1JFRkxF Q1RfWCB8IERSTV9NT0RFX1JFRkxFQ1RfWTsKPiArCQlyb3RhdGlvbiA9IChyb3RhdGlvbiAmIERS TV9NT0RFX1JFRkxFQ1RfTUFTSykgfAo+ICsJCSAgICAgICAgICAgQklUKChmZnMocm90YXRpb24g JiBEUk1fTU9ERV9ST1RBVEVfTUFTSykgKyAxKQo+ICsJCSAgICAgICAgICAgJSA0KTsKPiAgCX0K PiAgCj4gIAlyZXR1cm4gcm90YXRpb247Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9k cm1fZmJfaGVscGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2ZiX2hlbHBlci5jCj4gaW5kZXgg MWYxNzhiODc4ZTQyLi41NzRhZjAxZDNjZTkgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L2RybV9mYl9oZWxwZXIuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fZmJfaGVscGVyLmMK PiBAQCAtMzc4LDcgKzM3OCw3IEBAIHN0YXRpYyBpbnQgcmVzdG9yZV9mYmRldl9tb2RlX2F0b21p YyhzdHJ1Y3QgZHJtX2ZiX2hlbHBlciAqZmJfaGVscGVyKQo+ICAJCQlnb3RvIGZhaWw7Cj4gIAkJ fQo+ICAKPiAtCQlwbGFuZV9zdGF0ZS0+cm90YXRpb24gPSBEUk1fUk9UQVRFXzA7Cj4gKwkJcGxh bmVfc3RhdGUtPnJvdGF0aW9uID0gRFJNX01PREVfUk9UQVRFXzA7Cj4gIAo+ICAJCXBsYW5lLT5v bGRfZmIgPSBwbGFuZS0+ZmI7Cj4gIAkJcGxhbmVfbWFzayB8PSAxIDw8IGRybV9wbGFuZV9pbmRl eChwbGFuZSk7Cj4gQEAgLTQzMSw3ICs0MzEsNyBAQCBzdGF0aWMgaW50IHJlc3RvcmVfZmJkZXZf bW9kZV9sZWdhY3koc3RydWN0IGRybV9mYl9oZWxwZXIgKmZiX2hlbHBlcikKPiAgCQlpZiAocGxh bmUtPnJvdGF0aW9uX3Byb3BlcnR5KQo+ICAJCQlkcm1fbW9kZV9wbGFuZV9zZXRfb2JqX3Byb3Ao cGxhbmUsCj4gIAkJCQkJCSAgICBwbGFuZS0+cm90YXRpb25fcHJvcGVydHksCj4gLQkJCQkJCSAg ICBEUk1fUk9UQVRFXzApOwo+ICsJCQkJCQkgICAgRFJNX01PREVfUk9UQVRFXzApOwo+ICAJfQo+ ICAKPiAgCWZvciAoaSA9IDA7IGkgPCBmYl9oZWxwZXItPmNydGNfY291bnQ7IGkrKykgewo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3BsYW5lX2hlbHBlci5jIGIvZHJpdmVycy9n cHUvZHJtL2RybV9wbGFuZV9oZWxwZXIuYwo+IGluZGV4IGI4NGEyOTUyMzBmYy4uYWMxYzUxNGNh ZDJjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcGxhbmVfaGVscGVyLmMKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3BsYW5lX2hlbHBlci5jCj4gQEAgLTMzNiw3ICszMzYs NyBAQCBpbnQgZHJtX3ByaW1hcnlfaGVscGVyX3VwZGF0ZShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFu ZSwgc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ICAKPiAgCXJldCA9IGRybV9wbGFuZV9oZWxwZXJf Y2hlY2tfdXBkYXRlKHBsYW5lLCBjcnRjLCBmYiwKPiAgCQkJCQkgICAgJnNyYywgJmRlc3QsICZj bGlwLAo+IC0JCQkJCSAgICBEUk1fUk9UQVRFXzAsCj4gKwkJCQkJICAgIERSTV9NT0RFX1JPVEFU RV8wLAo+ICAJCQkJCSAgICBEUk1fUExBTkVfSEVMUEVSX05PX1NDQUxJTkcsCj4gIAkJCQkJICAg IERSTV9QTEFORV9IRUxQRVJfTk9fU0NBTElORywKPiAgCQkJCQkgICAgZmFsc2UsIGZhbHNlLCAm dmlzaWJsZSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcmVjdC5jIGIvZHJp dmVycy9ncHUvZHJtL2RybV9yZWN0LmMKPiBpbmRleCBiYzU1NzU5NjBlYmMuLjk4MTdjMTQ0NWJh OSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3JlY3QuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9kcm1fcmVjdC5jCj4gQEAgLTMxMCwzOCArMzEwLDM4IEBAIHZvaWQgZHJtX3Jl Y3Rfcm90YXRlKHN0cnVjdCBkcm1fcmVjdCAqciwKPiAgewo+ICAJc3RydWN0IGRybV9yZWN0IHRt cDsKPiAgCj4gLQlpZiAocm90YXRpb24gJiAoRFJNX1JFRkxFQ1RfWCB8IERSTV9SRUZMRUNUX1kp KSB7Cj4gKwlpZiAocm90YXRpb24gJiAoRFJNX01PREVfUkVGTEVDVF9YIHwgRFJNX01PREVfUkVG TEVDVF9ZKSkgewo+ICAJCXRtcCA9ICpyOwo+ICAKPiAtCQlpZiAocm90YXRpb24gJiBEUk1fUkVG TEVDVF9YKSB7Cj4gKwkJaWYgKHJvdGF0aW9uICYgRFJNX01PREVfUkVGTEVDVF9YKSB7Cj4gIAkJ CXItPngxID0gd2lkdGggLSB0bXAueDI7Cj4gIAkJCXItPngyID0gd2lkdGggLSB0bXAueDE7Cj4g IAkJfQo+ICAKPiAtCQlpZiAocm90YXRpb24gJiBEUk1fUkVGTEVDVF9ZKSB7Cj4gKwkJaWYgKHJv dGF0aW9uICYgRFJNX01PREVfUkVGTEVDVF9ZKSB7Cj4gIAkJCXItPnkxID0gaGVpZ2h0IC0gdG1w LnkyOwo+ICAJCQlyLT55MiA9IGhlaWdodCAtIHRtcC55MTsKPiAgCQl9Cj4gIAl9Cj4gIAo+IC0J c3dpdGNoIChyb3RhdGlvbiAmIERSTV9ST1RBVEVfTUFTSykgewo+IC0JY2FzZSBEUk1fUk9UQVRF XzA6Cj4gKwlzd2l0Y2ggKHJvdGF0aW9uICYgRFJNX01PREVfUk9UQVRFX01BU0spIHsKPiArCWNh c2UgRFJNX01PREVfUk9UQVRFXzA6Cj4gIAkJYnJlYWs7Cj4gLQljYXNlIERSTV9ST1RBVEVfOTA6 Cj4gKwljYXNlIERSTV9NT0RFX1JPVEFURV85MDoKPiAgCQl0bXAgPSAqcjsKPiAgCQlyLT54MSA9 IHRtcC55MTsKPiAgCQlyLT54MiA9IHRtcC55MjsKPiAgCQlyLT55MSA9IHdpZHRoIC0gdG1wLngy Owo+ICAJCXItPnkyID0gd2lkdGggLSB0bXAueDE7Cj4gIAkJYnJlYWs7Cj4gLQljYXNlIERSTV9S T1RBVEVfMTgwOgo+ICsJY2FzZSBEUk1fTU9ERV9ST1RBVEVfMTgwOgo+ICAJCXRtcCA9ICpyOwo+ ICAJCXItPngxID0gd2lkdGggLSB0bXAueDI7Cj4gIAkJci0+eDIgPSB3aWR0aCAtIHRtcC54MTsK PiAgCQlyLT55MSA9IGhlaWdodCAtIHRtcC55MjsKPiAgCQlyLT55MiA9IGhlaWdodCAtIHRtcC55 MTsKPiAgCQlicmVhazsKPiAtCWNhc2UgRFJNX1JPVEFURV8yNzA6Cj4gKwljYXNlIERSTV9NT0RF X1JPVEFURV8yNzA6Cj4gIAkJdG1wID0gKnI7Cj4gIAkJci0+eDEgPSBoZWlnaHQgLSB0bXAueTI7 Cj4gIAkJci0+eDIgPSBoZWlnaHQgLSB0bXAueTE7Cj4gQEAgLTM3Myw4ICszNzMsOCBAQCBFWFBP UlRfU1lNQk9MKGRybV9yZWN0X3JvdGF0ZSk7Cj4gICAqIHRoZW0gd2hlbiBkb2luZyBhIHJvdGF0 YXRpb24gYW5kIGl0cyBpbnZlcnNlLgo+ICAgKiBUaGF0IGlzLCBpZiB5b3UgZG8gOjoKPiAgICoK PiAtICogICAgIGRybV9yb3RhdGUoJnIsIHdpZHRoLCBoZWlnaHQsIHJvdGF0aW9uKTsKPiAtICog ICAgIGRybV9yb3RhdGVfaW52KCZyLCB3aWR0aCwgaGVpZ2h0LCByb3RhdGlvbik7Cj4gKyAqICAg ICBEUk1fTU9ERV9QUk9QX1JPVEFURSgmciwgd2lkdGgsIGhlaWdodCwgcm90YXRpb24pOwo+ICsg KiAgICAgRFJNX01PREVfUk9UQVRFX2ludigmciwgd2lkdGgsIGhlaWdodCwgcm90YXRpb24pOwo+ ICAgKgo+ICAgKiB5b3Ugd2lsbCBhbHdheXMgZ2V0IGJhY2sgdGhlIG9yaWdpbmFsIHJlY3Rhbmds ZS4KPiAgICovCj4gQEAgLTM4NCwyNCArMzg0LDI0IEBAIHZvaWQgZHJtX3JlY3Rfcm90YXRlX2lu dihzdHJ1Y3QgZHJtX3JlY3QgKnIsCj4gIHsKPiAgCXN0cnVjdCBkcm1fcmVjdCB0bXA7Cj4gIAo+ IC0Jc3dpdGNoIChyb3RhdGlvbiAmIERSTV9ST1RBVEVfTUFTSykgewo+IC0JY2FzZSBEUk1fUk9U QVRFXzA6Cj4gKwlzd2l0Y2ggKHJvdGF0aW9uICYgRFJNX01PREVfUk9UQVRFX01BU0spIHsKPiAr CWNhc2UgRFJNX01PREVfUk9UQVRFXzA6Cj4gIAkJYnJlYWs7Cj4gLQljYXNlIERSTV9ST1RBVEVf OTA6Cj4gKwljYXNlIERSTV9NT0RFX1JPVEFURV85MDoKPiAgCQl0bXAgPSAqcjsKPiAgCQlyLT54 MSA9IHdpZHRoIC0gdG1wLnkyOwo+ICAJCXItPngyID0gd2lkdGggLSB0bXAueTE7Cj4gIAkJci0+ eTEgPSB0bXAueDE7Cj4gIAkJci0+eTIgPSB0bXAueDI7Cj4gIAkJYnJlYWs7Cj4gLQljYXNlIERS TV9ST1RBVEVfMTgwOgo+ICsJY2FzZSBEUk1fTU9ERV9ST1RBVEVfMTgwOgo+ICAJCXRtcCA9ICpy Owo+ICAJCXItPngxID0gd2lkdGggLSB0bXAueDI7Cj4gIAkJci0+eDIgPSB3aWR0aCAtIHRtcC54 MTsKPiAgCQlyLT55MSA9IGhlaWdodCAtIHRtcC55MjsKPiAgCQlyLT55MiA9IGhlaWdodCAtIHRt cC55MTsKPiAgCQlicmVhazsKPiAtCWNhc2UgRFJNX1JPVEFURV8yNzA6Cj4gKwljYXNlIERSTV9N T0RFX1JPVEFURV8yNzA6Cj4gIAkJdG1wID0gKnI7Cj4gIAkJci0+eDEgPSB0bXAueTE7Cj4gIAkJ ci0+eDIgPSB0bXAueTI7Cj4gQEAgLTQxMiwxNSArNDEyLDE1IEBAIHZvaWQgZHJtX3JlY3Rfcm90 YXRlX2ludihzdHJ1Y3QgZHJtX3JlY3QgKnIsCj4gIAkJYnJlYWs7Cj4gIAl9Cj4gIAo+IC0JaWYg KHJvdGF0aW9uICYgKERSTV9SRUZMRUNUX1ggfCBEUk1fUkVGTEVDVF9ZKSkgewo+ICsJaWYgKHJv dGF0aW9uICYgKERSTV9NT0RFX1JFRkxFQ1RfWCB8IERSTV9NT0RFX1JFRkxFQ1RfWSkpIHsKPiAg CQl0bXAgPSAqcjsKPiAgCj4gLQkJaWYgKHJvdGF0aW9uICYgRFJNX1JFRkxFQ1RfWCkgewo+ICsJ CWlmIChyb3RhdGlvbiAmIERSTV9NT0RFX1JFRkxFQ1RfWCkgewo+ICAJCQlyLT54MSA9IHdpZHRo IC0gdG1wLngyOwo+ICAJCQlyLT54MiA9IHdpZHRoIC0gdG1wLngxOwo+ICAJCX0KPiAgCj4gLQkJ aWYgKHJvdGF0aW9uICYgRFJNX1JFRkxFQ1RfWSkgewo+ICsJCWlmIChyb3RhdGlvbiAmIERSTV9N T0RFX1JFRkxFQ1RfWSkgewo+ICAJCQlyLT55MSA9IGhlaWdodCAtIHRtcC55MjsKPiAgCQkJci0+ eTIgPSBoZWlnaHQgLSB0bXAueTE7Cj4gIAkJfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2RlYnVnZnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdm cy5jCj4gaW5kZXggZDY4OWU1MTE3NDRlLi5iZjZkNDQ5OGE5NGEgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2RlYnVnZnMuYwo+IEBAIC0zMDk1LDE3ICszMDk1LDE3IEBAIHN0YXRpYyBjb25z dCBjaGFyICpwbGFuZV9yb3RhdGlvbih1bnNpZ25lZCBpbnQgcm90YXRpb24pCj4gIHsKPiAgCXN0 YXRpYyBjaGFyIGJ1Zls0OF07Cj4gIAkvKgo+IC0JICogQWNjb3JkaW5nIHRvIGRvYyBvbmx5IG9u ZSBEUk1fUk9UQVRFXyBpcyBhbGxvd2VkIGJ1dCB0aGlzCj4gKwkgKiBBY2NvcmRpbmcgdG8gZG9j IG9ubHkgb25lIERSTV9NT0RFX1JPVEFURV8gaXMgYWxsb3dlZCBidXQgdGhpcwo+ICAJICogd2ls bCBwcmludCB0aGVtIGFsbCB0byB2aXN1YWxpemUgaWYgdGhlIHZhbHVlcyBhcmUgbWlzdXNlZAo+ ICAJICovCj4gIAlzbnByaW50ZihidWYsIHNpemVvZihidWYpLAo+ICAJCSAiJXMlcyVzJXMlcyVz KDB4JTA4eCkiLAo+IC0JCSAocm90YXRpb24gJiBEUk1fUk9UQVRFXzApID8gIjAgIiA6ICIiLAo+ IC0JCSAocm90YXRpb24gJiBEUk1fUk9UQVRFXzkwKSA/ICI5MCAiIDogIiIsCj4gLQkJIChyb3Rh dGlvbiAmIERSTV9ST1RBVEVfMTgwKSA/ICIxODAgIiA6ICIiLAo+IC0JCSAocm90YXRpb24gJiBE Uk1fUk9UQVRFXzI3MCkgPyAiMjcwICIgOiAiIiwKPiAtCQkgKHJvdGF0aW9uICYgRFJNX1JFRkxF Q1RfWCkgPyAiRkxJUFggIiA6ICIiLAo+IC0JCSAocm90YXRpb24gJiBEUk1fUkVGTEVDVF9ZKSA/ ICJGTElQWSAiIDogIiIsCj4gKwkJIChyb3RhdGlvbiAmIERSTV9NT0RFX1JPVEFURV8wKSA/ICIw ICIgOiAiIiwKPiArCQkgKHJvdGF0aW9uICYgRFJNX01PREVfUk9UQVRFXzkwKSA/ICI5MCAiIDog IiIsCj4gKwkJIChyb3RhdGlvbiAmIERSTV9NT0RFX1JPVEFURV8xODApID8gIjE4MCAiIDogIiIs Cj4gKwkJIChyb3RhdGlvbiAmIERSTV9NT0RFX1JPVEFURV8yNzApID8gIjI3MCAiIDogIiIsCj4g KwkJIChyb3RhdGlvbiAmIERSTV9NT0RFX1JFRkxFQ1RfWCkgPyAiRkxJUFggIiA6ICIiLAo+ICsJ CSAocm90YXRpb24gJiBEUk1fTU9ERV9SRUZMRUNUX1kpID8gIkZMSVBZICIgOiAiIiwKPiAgCQkg cm90YXRpb24pOwo+ICAKPiAgCXJldHVybiBidWY7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2F0b21pY19wbGFuZS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfYXRvbWljX3BsYW5lLmMKPiBpbmRleCBjZmI0NzI5M2ZkNTMuLmE0MGM4MmM2NTQ1MCAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9hdG9taWNfcGxhbmUuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2F0b21pY19wbGFuZS5jCj4gQEAgLTU1LDcg KzU1LDcgQEAgaW50ZWxfY3JlYXRlX3BsYW5lX3N0YXRlKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5l KQo+ICAJCXJldHVybiBOVUxMOwo+ICAKPiAgCXN0YXRlLT5iYXNlLnBsYW5lID0gcGxhbmU7Cj4g LQlzdGF0ZS0+YmFzZS5yb3RhdGlvbiA9IERSTV9ST1RBVEVfMDsKPiArCXN0YXRlLT5iYXNlLnJv dGF0aW9uID0gRFJNX01PREVfUk9UQVRFXzA7Cj4gIAlzdGF0ZS0+Y2tleS5mbGFncyA9IEk5MTVf U0VUX0NPTE9SS0VZX05PTkU7Cj4gIAo+ICAJcmV0dXJuIHN0YXRlOwo+IEBAIC0xNzgsOCArMTc4 LDggQEAgaW50IGludGVsX3BsYW5lX2F0b21pY19jaGVja193aXRoX3N0YXRlKHN0cnVjdCBpbnRl bF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAo+ICAKPiAgCS8qIENIViBpZ25vcmVzIHRoZSBtaXJy b3IgYml0IHdoZW4gdGhlIHJvdGF0ZSBiaXQgaXMgc2V0IDooICovCj4gIAlpZiAoSVNfQ0hFUlJZ VklFVyhkZXZfcHJpdikgJiYKPiAtCSAgICBzdGF0ZS0+cm90YXRpb24gJiBEUk1fUk9UQVRFXzE4 MCAmJgo+IC0JICAgIHN0YXRlLT5yb3RhdGlvbiAmIERSTV9SRUZMRUNUX1gpIHsKPiArCSAgICBz dGF0ZS0+cm90YXRpb24gJiBEUk1fTU9ERV9ST1RBVEVfMTgwICYmCj4gKwkgICAgc3RhdGUtPnJv dGF0aW9uICYgRFJNX01PREVfUkVGTEVDVF9YKSB7Cj4gIAkJRFJNX0RFQlVHX0tNUygiQ2Fubm90 IHJvdGF0ZSBhbmQgcmVmbGVjdCBhdCB0aGUgc2FtZSB0aW1lXG4iKTsKPiAgCQlyZXR1cm4gLUVJ TlZBTDsKPiAgCX0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlz cGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCj4gaW5kZXggMzYx NzkyN2FmMjY5Li4wMTZhYTNmNmU2OWEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZGlzcGxheS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlz cGxheS5jCj4gQEAgLTI0NjgsNyArMjQ2OCw3IEBAIGludGVsX2ZpbGxfZmJfaW5mbyhzdHJ1Y3Qg ZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCj4gIAo+ICAJCW9mZnNldCA9IF9pbnRlbF9jb21w dXRlX3RpbGVfb2Zmc2V0KGRldl9wcml2LCAmeCwgJnksCj4gIAkJCQkJCSAgICBmYiwgaSwgZmIt PnBpdGNoZXNbaV0sCj4gLQkJCQkJCSAgICBEUk1fUk9UQVRFXzAsIHRpbGVfc2l6ZSk7Cj4gKwkJ CQkJCSAgICBEUk1fTU9ERV9ST1RBVEVfMCwgdGlsZV9zaXplKTsKPiAgCQlvZmZzZXQgLz0gdGls ZV9zaXplOwo+ICAKPiAgCQlpZiAoZmItPm1vZGlmaWVyICE9IERSTV9GT1JNQVRfTU9EX0xJTkVB Uikgewo+IEBAIC0yNTAzLDcgKzI1MDMsNyBAQCBpbnRlbF9maWxsX2ZiX2luZm8oc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAo+ICAJCQlkcm1fcmVjdF9yb3RhdGUoJnIsCj4gIAkJ CQkJcm90X2luZm8tPnBsYW5lW2ldLndpZHRoICogdGlsZV93aWR0aCwKPiAgCQkJCQlyb3RfaW5m by0+cGxhbmVbaV0uaGVpZ2h0ICogdGlsZV9oZWlnaHQsCj4gLQkJCQkJRFJNX1JPVEFURV8yNzAp Owo+ICsJCQkJCURSTV9NT0RFX1JPVEFURV8yNzApOwo+ICAJCQl4ID0gci54MTsKPiAgCQkJeSA9 IHIueTE7Cj4gIAo+IEBAIC0yOTM5LDcgKzI5MzksNyBAQCBpbnQgc2tsX2NoZWNrX3BsYW5lX3N1 cmZhY2Uoc3RydWN0IGludGVsX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSkKPiAgCWlmIChkcm1f cm90YXRpb25fOTBfb3JfMjcwKHJvdGF0aW9uKSkKPiAgCQlkcm1fcmVjdF9yb3RhdGUoJnBsYW5l X3N0YXRlLT5iYXNlLnNyYywKPiAgCQkJCWZiLT53aWR0aCA8PCAxNiwgZmItPmhlaWdodCA8PCAx NiwKPiAtCQkJCURSTV9ST1RBVEVfMjcwKTsKPiArCQkJCURSTV9NT0RFX1JPVEFURV8yNzApOwo+ ICAKPiAgCS8qCj4gIAkgKiBIYW5kbGUgdGhlIEFVWCBzdXJmYWNlIGZpcnN0IHNpbmNlCj4gQEAg LTMwMTcsMTAgKzMwMTcsMTAgQEAgc3RhdGljIHUzMiBpOXh4X3BsYW5lX2N0bChjb25zdCBzdHJ1 Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSwKPiAgCSAgICBmYi0+bW9kaWZpZXIgPT0g STkxNV9GT1JNQVRfTU9EX1hfVElMRUQpCj4gIAkJZHNwY250ciB8PSBESVNQUExBTkVfVElMRUQ7 Cj4gIAo+IC0JaWYgKHJvdGF0aW9uICYgRFJNX1JPVEFURV8xODApCj4gKwlpZiAocm90YXRpb24g JiBEUk1fTU9ERV9ST1RBVEVfMTgwKQo+ICAJCWRzcGNudHIgfD0gRElTUFBMQU5FX1JPVEFURV8x ODA7Cj4gIAo+IC0JaWYgKHJvdGF0aW9uICYgRFJNX1JFRkxFQ1RfWCkKPiArCWlmIChyb3RhdGlv biAmIERSTV9NT0RFX1JFRkxFQ1RfWCkKPiAgCQlkc3BjbnRyIHw9IERJU1BQTEFORV9NSVJST1I7 Cj4gIAo+ICAJcmV0dXJuIGRzcGNudHI7Cj4gQEAgLTMwNDgsMTAgKzMwNDgsMTAgQEAgaW50IGk5 eHhfY2hlY2tfcGxhbmVfc3VyZmFjZShzdHJ1Y3QgaW50ZWxfcGxhbmVfc3RhdGUgKnBsYW5lX3N0 YXRlKQo+ICAJCWludCBzcmNfdyA9IGRybV9yZWN0X3dpZHRoKCZwbGFuZV9zdGF0ZS0+YmFzZS5z cmMpID4+IDE2Owo+ICAJCWludCBzcmNfaCA9IGRybV9yZWN0X2hlaWdodCgmcGxhbmVfc3RhdGUt PmJhc2Uuc3JjKSA+PiAxNjsKPiAgCj4gLQkJaWYgKHJvdGF0aW9uICYgRFJNX1JPVEFURV8xODAp IHsKPiArCQlpZiAocm90YXRpb24gJiBEUk1fTU9ERV9ST1RBVEVfMTgwKSB7Cj4gIAkJCXNyY194 ICs9IHNyY193IC0gMTsKPiAgCQkJc3JjX3kgKz0gc3JjX2ggLSAxOwo+IC0JCX0gZWxzZSBpZiAo cm90YXRpb24gJiBEUk1fUkVGTEVDVF9YKSB7Cj4gKwkJfSBlbHNlIGlmIChyb3RhdGlvbiAmIERS TV9NT0RFX1JFRkxFQ1RfWCkgewo+ICAJCQlzcmNfeCArPSBzcmNfdyAtIDE7Cj4gIAkJfQo+ICAJ fQo+IEBAIC0zMjcxLDE3ICszMjcxLDE3IEBAIHN0YXRpYyB1MzIgc2tsX3BsYW5lX2N0bF90aWxp bmcodWludDY0X3QgZmJfbW9kaWZpZXIpCj4gIHN0YXRpYyB1MzIgc2tsX3BsYW5lX2N0bF9yb3Rh dGlvbih1bnNpZ25lZCBpbnQgcm90YXRpb24pCj4gIHsKPiAgCXN3aXRjaCAocm90YXRpb24pIHsK PiAtCWNhc2UgRFJNX1JPVEFURV8wOgo+ICsJY2FzZSBEUk1fTU9ERV9ST1RBVEVfMDoKPiAgCQli cmVhazsKPiAgCS8qCj4gLQkgKiBEUk1fUk9UQVRFXyBpcyBjb3VudGVyIGNsb2Nrd2lzZSB0byBz dGF5IGNvbXBhdGlibGUgd2l0aCBYcmFuZHIKPiArCSAqIERSTV9NT0RFX1JPVEFURV8gaXMgY291 bnRlciBjbG9ja3dpc2UgdG8gc3RheSBjb21wYXRpYmxlIHdpdGggWHJhbmRyCj4gIAkgKiB3aGls ZSBpOTE1IEhXIHJvdGF0aW9uIGlzIGNsb2Nrd2lzZSwgdGhhdHMgd2h5IHRoaXMgc3dhcHBpbmcu Cj4gIAkgKi8KPiAtCWNhc2UgRFJNX1JPVEFURV85MDoKPiArCWNhc2UgRFJNX01PREVfUk9UQVRF XzkwOgo+ICAJCXJldHVybiBQTEFORV9DVExfUk9UQVRFXzI3MDsKPiAtCWNhc2UgRFJNX1JPVEFU RV8xODA6Cj4gKwljYXNlIERSTV9NT0RFX1JPVEFURV8xODA6Cj4gIAkJcmV0dXJuIFBMQU5FX0NU TF9ST1RBVEVfMTgwOwo+IC0JY2FzZSBEUk1fUk9UQVRFXzI3MDoKPiArCWNhc2UgRFJNX01PREVf Uk9UQVRFXzI3MDoKPiAgCQlyZXR1cm4gUExBTkVfQ1RMX1JPVEFURV85MDsKPiAgCWRlZmF1bHQ6 Cj4gIAkJTUlTU0lOR19DQVNFKHJvdGF0aW9uKTsKPiBAQCAtNDY3MSw3ICs0NjcxLDcgQEAgaW50 IHNrbF91cGRhdGVfc2NhbGVyX2NydGMoc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnN0YXRlKQo+ ICAJY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21vZGUgPSAmc3RhdGUt PmJhc2UuYWRqdXN0ZWRfbW9kZTsKPiAgCj4gIAlyZXR1cm4gc2tsX3VwZGF0ZV9zY2FsZXIoc3Rh dGUsICFzdGF0ZS0+YmFzZS5hY3RpdmUsIFNLTF9DUlRDX0lOREVYLAo+IC0JCSZzdGF0ZS0+c2Nh bGVyX3N0YXRlLnNjYWxlcl9pZCwgRFJNX1JPVEFURV8wLAo+ICsJCSZzdGF0ZS0+c2NhbGVyX3N0 YXRlLnNjYWxlcl9pZCwgRFJNX01PREVfUk9UQVRFXzAsCj4gIAkJc3RhdGUtPnBpcGVfc3JjX3cs IHN0YXRlLT5waXBlX3NyY19oLAo+ICAJCWFkanVzdGVkX21vZGUtPmNydGNfaGRpc3BsYXksIGFk anVzdGVkX21vZGUtPmNydGNfdmRpc3BsYXkpOwo+ICB9Cj4gQEAgLTkyMzksNyArOTIzOSw3IEBA IHN0YXRpYyB1MzIgaTl4eF9jdXJzb3JfY3RsKGNvbnN0IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRl ICpjcnRjX3N0YXRlLAo+ICAJCXJldHVybiAwOwo+ICAJfQo+ICAKPiAtCWlmIChwbGFuZV9zdGF0 ZS0+YmFzZS5yb3RhdGlvbiAmIERSTV9ST1RBVEVfMTgwKQo+ICsJaWYgKHBsYW5lX3N0YXRlLT5i YXNlLnJvdGF0aW9uICYgRFJNX01PREVfUk9UQVRFXzE4MCkKPiAgCQljbnRsIHw9IENVUlNPUl9S T1RBVEVfMTgwOwo+ICAKPiAgCXJldHVybiBjbnRsOwo+IEBAIC05MzAwLDcgKzkzMDAsNyBAQCBz dGF0aWMgdm9pZCBpbnRlbF9jcnRjX3VwZGF0ZV9jdXJzb3Ioc3RydWN0IGRybV9jcnRjICpjcnRj LAo+ICAKPiAgCQkvKiBJTEsrIGRvIHRoaXMgYXV0b21hZ2ljYWxseSAqLwo+ICAJCWlmIChIQVNf R01DSF9ESVNQTEFZKGRldl9wcml2KSAmJgo+IC0JCSAgICBwbGFuZV9zdGF0ZS0+YmFzZS5yb3Rh dGlvbiAmIERSTV9ST1RBVEVfMTgwKSB7Cj4gKwkJICAgIHBsYW5lX3N0YXRlLT5iYXNlLnJvdGF0 aW9uICYgRFJNX01PREVfUk9UQVRFXzE4MCkgewo+ICAJCQliYXNlICs9IChwbGFuZV9zdGF0ZS0+ YmFzZS5jcnRjX2ggKgo+ICAJCQkJIHBsYW5lX3N0YXRlLT5iYXNlLmNydGNfdyAtIDEpICogNDsK PiAgCQl9Cj4gQEAgLTEzNjEzLDIyICsxMzYxMywyMiBAQCBpbnRlbF9wcmltYXJ5X3BsYW5lX2Ny ZWF0ZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlKQo+ ICAKPiAgCWlmIChJTlRFTF9HRU4oZGV2X3ByaXYpID49IDkpIHsKPiAgCQlzdXBwb3J0ZWRfcm90 YXRpb25zID0KPiAtCQkJRFJNX1JPVEFURV8wIHwgRFJNX1JPVEFURV85MCB8Cj4gLQkJCURSTV9S T1RBVEVfMTgwIHwgRFJNX1JPVEFURV8yNzA7Cj4gKwkJCURSTV9NT0RFX1JPVEFURV8wIHwgRFJN X01PREVfUk9UQVRFXzkwIHwKPiArCQkJRFJNX01PREVfUk9UQVRFXzE4MCB8IERSTV9NT0RFX1JP VEFURV8yNzA7Cj4gIAl9IGVsc2UgaWYgKElTX0NIRVJSWVZJRVcoZGV2X3ByaXYpICYmIHBpcGUg PT0gUElQRV9CKSB7Cj4gIAkJc3VwcG9ydGVkX3JvdGF0aW9ucyA9Cj4gLQkJCURSTV9ST1RBVEVf MCB8IERSTV9ST1RBVEVfMTgwIHwKPiAtCQkJRFJNX1JFRkxFQ1RfWDsKPiArCQkJRFJNX01PREVf Uk9UQVRFXzAgfCBEUk1fTU9ERV9ST1RBVEVfMTgwIHwKPiArCQkJRFJNX01PREVfUkVGTEVDVF9Y Owo+ICAJfSBlbHNlIGlmIChJTlRFTF9HRU4oZGV2X3ByaXYpID49IDQpIHsKPiAgCQlzdXBwb3J0 ZWRfcm90YXRpb25zID0KPiAtCQkJRFJNX1JPVEFURV8wIHwgRFJNX1JPVEFURV8xODA7Cj4gKwkJ CURSTV9NT0RFX1JPVEFURV8wIHwgRFJNX01PREVfUk9UQVRFXzE4MDsKPiAgCX0gZWxzZSB7Cj4g LQkJc3VwcG9ydGVkX3JvdGF0aW9ucyA9IERSTV9ST1RBVEVfMDsKPiArCQlzdXBwb3J0ZWRfcm90 YXRpb25zID0gRFJNX01PREVfUk9UQVRFXzA7Cj4gIAl9Cj4gIAo+ICAJaWYgKElOVEVMX0dFTihk ZXZfcHJpdikgPj0gNCkKPiAgCQlkcm1fcGxhbmVfY3JlYXRlX3JvdGF0aW9uX3Byb3BlcnR5KCZw cmltYXJ5LT5iYXNlLAo+IC0JCQkJCQkgICBEUk1fUk9UQVRFXzAsCj4gKwkJCQkJCSAgIERSTV9N T0RFX1JPVEFURV8wLAo+ICAJCQkJCQkgICBzdXBwb3J0ZWRfcm90YXRpb25zKTsKPiAgCj4gIAlk cm1fcGxhbmVfaGVscGVyX2FkZCgmcHJpbWFyeS0+YmFzZSwgJmludGVsX3BsYW5lX2hlbHBlcl9m dW5jcyk7Cj4gQEAgLTEzNzgzLDkgKzEzNzgzLDkgQEAgaW50ZWxfY3Vyc29yX3BsYW5lX2NyZWF0 ZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlKQo+ICAK PiAgCWlmIChJTlRFTF9HRU4oZGV2X3ByaXYpID49IDQpCj4gIAkJZHJtX3BsYW5lX2NyZWF0ZV9y b3RhdGlvbl9wcm9wZXJ0eSgmY3Vyc29yLT5iYXNlLAo+IC0JCQkJCQkgICBEUk1fUk9UQVRFXzAs Cj4gLQkJCQkJCSAgIERSTV9ST1RBVEVfMCB8Cj4gLQkJCQkJCSAgIERSTV9ST1RBVEVfMTgwKTsK PiArCQkJCQkJICAgRFJNX01PREVfUk9UQVRFXzAsCj4gKwkJCQkJCSAgIERSTV9NT0RFX1JPVEFU RV8wIHwKPiArCQkJCQkJICAgRFJNX01PREVfUk9UQVRFXzE4MCk7Cj4gIAo+ICAJaWYgKElOVEVM X0dFTihkZXZfcHJpdikgPj0gOSkKPiAgCQlzdGF0ZS0+c2NhbGVyX2lkID0gLTE7Cj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiYy5jIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfZmJjLmMKPiBpbmRleCBkZWQyYWRkMThiMjYuLmRiN2Y4ZjBhMWYzNiAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYmMuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiYy5jCj4gQEAgLTgwMSw3ICs4MDEsNyBAQCBzdGF0aWMg Ym9vbCBpbnRlbF9mYmNfY2FuX2FjdGl2YXRlKHN0cnVjdCBpbnRlbF9jcnRjICpjcnRjKQo+ICAJ CXJldHVybiBmYWxzZTsKPiAgCX0KPiAgCWlmIChJTlRFTF9HRU4oZGV2X3ByaXYpIDw9IDQgJiYg IUlTX0c0WChkZXZfcHJpdikgJiYKPiAtCSAgICBjYWNoZS0+cGxhbmUucm90YXRpb24gIT0gRFJN X1JPVEFURV8wKSB7Cj4gKwkgICAgY2FjaGUtPnBsYW5lLnJvdGF0aW9uICE9IERSTV9NT0RFX1JP VEFURV8wKSB7Cj4gIAkJZmJjLT5ub19mYmNfcmVhc29uID0gInJvdGF0aW9uIHVuc3VwcG9ydGVk IjsKPiAgCQlyZXR1cm4gZmFsc2U7Cj4gIAl9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2ZiZGV2LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYmRldi5j Cj4gaW5kZXggMzMyMjU0YThlZWJlLi4wMzM0N2M2YWU1OTkgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZmJkZXYuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2ZiZGV2LmMKPiBAQCAtMjExLDcgKzIxMSw3IEBAIHN0YXRpYyBpbnQgaW50ZWxmYl9j cmVhdGUoc3RydWN0IGRybV9mYl9oZWxwZXIgKmhlbHBlciwKPiAgCSAqIFRoaXMgYWxzbyB2YWxp ZGF0ZXMgdGhhdCBhbnkgZXhpc3RpbmcgZmIgaW5oZXJpdGVkIGZyb20gdGhlCj4gIAkgKiBCSU9T IGlzIHN1aXRhYmxlIGZvciBvd24gYWNjZXNzLgo+ICAJICovCj4gLQl2bWEgPSBpbnRlbF9waW5f YW5kX2ZlbmNlX2ZiX29iaigmaWZiZGV2LT5mYi0+YmFzZSwgRFJNX1JPVEFURV8wKTsKPiArCXZt YSA9IGludGVsX3Bpbl9hbmRfZmVuY2VfZmJfb2JqKCZpZmJkZXYtPmZiLT5iYXNlLCBEUk1fTU9E RV9ST1RBVEVfMCk7Cj4gIAlpZiAoSVNfRVJSKHZtYSkpIHsKPiAgCQlyZXQgPSBQVFJfRVJSKHZt YSk7Cj4gIAkJZ290byBvdXRfdW5sb2NrOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9zcHJpdGUuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nwcml0ZS5j Cj4gaW5kZXggOGM4N2M3MTdjN2NkLi4xOTFlMTRkZGRlMGMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfc3ByaXRlLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9zcHJpdGUuYwo+IEBAIC0zOTgsMTAgKzM5OCwxMCBAQCBzdGF0aWMgdTMyIHZsdl9z cHJpdGVfY3RsKGNvbnN0IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAo+ICAJ aWYgKGZiLT5tb2RpZmllciA9PSBJOTE1X0ZPUk1BVF9NT0RfWF9USUxFRCkKPiAgCQlzcHJjdGwg fD0gU1BfVElMRUQ7Cj4gIAo+IC0JaWYgKHJvdGF0aW9uICYgRFJNX1JPVEFURV8xODApCj4gKwlp ZiAocm90YXRpb24gJiBEUk1fTU9ERV9ST1RBVEVfMTgwKQo+ICAJCXNwcmN0bCB8PSBTUF9ST1RB VEVfMTgwOwo+ICAKPiAtCWlmIChyb3RhdGlvbiAmIERSTV9SRUZMRUNUX1gpCj4gKwlpZiAocm90 YXRpb24gJiBEUk1fTU9ERV9SRUZMRUNUX1gpCj4gIAkJc3ByY3RsIHw9IFNQX01JUlJPUjsKPiAg Cj4gIAlpZiAoa2V5LT5mbGFncyAmIEk5MTVfU0VUX0NPTE9SS0VZX1NPVVJDRSkKPiBAQCAtNTMz LDcgKzUzMyw3IEBAIHN0YXRpYyB1MzIgaXZiX3Nwcml0ZV9jdGwoY29uc3Qgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCj4gIAlpZiAoZmItPm1vZGlmaWVyID09IEk5MTVfRk9S TUFUX01PRF9YX1RJTEVEKQo+ICAJCXNwcmN0bCB8PSBTUFJJVEVfVElMRUQ7Cj4gIAo+IC0JaWYg KHJvdGF0aW9uICYgRFJNX1JPVEFURV8xODApCj4gKwlpZiAocm90YXRpb24gJiBEUk1fTU9ERV9S T1RBVEVfMTgwKQo+ICAJCXNwcmN0bCB8PSBTUFJJVEVfUk9UQVRFXzE4MDsKPiAgCj4gIAlpZiAo a2V5LT5mbGFncyAmIEk5MTVfU0VUX0NPTE9SS0VZX0RFU1RJTkFUSU9OKQo+IEBAIC02NzQsNyAr Njc0LDcgQEAgc3RhdGljIHUzMiBpbGtfc3ByaXRlX2N0bChjb25zdCBzdHJ1Y3QgaW50ZWxfY3J0 Y19zdGF0ZSAqY3J0Y19zdGF0ZSwKPiAgCWlmIChmYi0+bW9kaWZpZXIgPT0gSTkxNV9GT1JNQVRf TU9EX1hfVElMRUQpCj4gIAkJZHZzY250ciB8PSBEVlNfVElMRUQ7Cj4gIAo+IC0JaWYgKHJvdGF0 aW9uICYgRFJNX1JPVEFURV8xODApCj4gKwlpZiAocm90YXRpb24gJiBEUk1fTU9ERV9ST1RBVEVf MTgwKQo+ICAJCWR2c2NudHIgfD0gRFZTX1JPVEFURV8xODA7Cj4gIAo+ICAJaWYgKGtleS0+Zmxh Z3MgJiBJOTE1X1NFVF9DT0xPUktFWV9ERVNUSU5BVElPTikKPiBAQCAtMTE0NSwxNSArMTE0NSwx NSBAQCBpbnRlbF9zcHJpdGVfcGxhbmVfY3JlYXRlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpk ZXZfcHJpdiwKPiAgCj4gIAlpZiAoSU5URUxfR0VOKGRldl9wcml2KSA+PSA5KSB7Cj4gIAkJc3Vw cG9ydGVkX3JvdGF0aW9ucyA9Cj4gLQkJCURSTV9ST1RBVEVfMCB8IERSTV9ST1RBVEVfOTAgfAo+ IC0JCQlEUk1fUk9UQVRFXzE4MCB8IERSTV9ST1RBVEVfMjcwOwo+ICsJCQlEUk1fTU9ERV9ST1RB VEVfMCB8IERSTV9NT0RFX1JPVEFURV85MCB8Cj4gKwkJCURSTV9NT0RFX1JPVEFURV8xODAgfCBE Uk1fTU9ERV9ST1RBVEVfMjcwOwo+ICAJfSBlbHNlIGlmIChJU19DSEVSUllWSUVXKGRldl9wcml2 KSAmJiBwaXBlID09IFBJUEVfQikgewo+ICAJCXN1cHBvcnRlZF9yb3RhdGlvbnMgPQo+IC0JCQlE Uk1fUk9UQVRFXzAgfCBEUk1fUk9UQVRFXzE4MCB8Cj4gLQkJCURSTV9SRUZMRUNUX1g7Cj4gKwkJ CURSTV9NT0RFX1JPVEFURV8wIHwgRFJNX01PREVfUk9UQVRFXzE4MCB8Cj4gKwkJCURSTV9NT0RF X1JFRkxFQ1RfWDsKPiAgCX0gZWxzZSB7Cj4gIAkJc3VwcG9ydGVkX3JvdGF0aW9ucyA9Cj4gLQkJ CURSTV9ST1RBVEVfMCB8IERSTV9ST1RBVEVfMTgwOwo+ICsJCQlEUk1fTU9ERV9ST1RBVEVfMCB8 IERSTV9NT0RFX1JPVEFURV8xODA7Cj4gIAl9Cj4gIAo+ICAJaW50ZWxfcGxhbmUtPnBpcGUgPSBw aXBlOwo+IEBAIC0xMTgwLDcgKzExODAsNyBAQCBpbnRlbF9zcHJpdGVfcGxhbmVfY3JlYXRlKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKPiAgCQlnb3RvIGZhaWw7Cj4gIAo+ICAJ ZHJtX3BsYW5lX2NyZWF0ZV9yb3RhdGlvbl9wcm9wZXJ0eSgmaW50ZWxfcGxhbmUtPmJhc2UsCj4g LQkJCQkJICAgRFJNX1JPVEFURV8wLAo+ICsJCQkJCSAgIERSTV9NT0RFX1JPVEFURV8wLAo+ICAJ CQkJCSAgIHN1cHBvcnRlZF9yb3RhdGlvbnMpOwo+ICAKPiAgCWRybV9wbGFuZV9oZWxwZXJfYWRk KCZpbnRlbF9wbGFuZS0+YmFzZSwgJmludGVsX3BsYW5lX2hlbHBlcl9mdW5jcyk7Cj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pbXgvaXB1djMtcGxhbmUuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9pbXgvaXB1djMtcGxhbmUuYwo+IGluZGV4IGQ2M2U4NTNhMDMwMC4uNDk1NDYyMjJjNmQzIDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pbXgvaXB1djMtcGxhbmUuYwo+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pbXgvaXB1djMtcGxhbmUuYwo+IEBAIC0yNzMsNyArMjczLDcgQEAgdm9p ZCBpcHVfcGxhbmVfc3RhdGVfcmVzZXQoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCj4gIAo+ICAJ aWYgKGlwdV9zdGF0ZSkgewo+ICAJCWlwdV9zdGF0ZS0+YmFzZS5wbGFuZSA9IHBsYW5lOwo+IC0J CWlwdV9zdGF0ZS0+YmFzZS5yb3RhdGlvbiA9IERSTV9ST1RBVEVfMDsKPiArCQlpcHVfc3RhdGUt PmJhc2Uucm90YXRpb24gPSBEUk1fTU9ERV9ST1RBVEVfMDsKPiAgCX0KPiAgCj4gIAlwbGFuZS0+ c3RhdGUgPSAmaXB1X3N0YXRlLT5iYXNlOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v bXNtL21kcC9tZHA1L21kcDVfcGxhbmUuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUv bWRwNV9wbGFuZS5jCj4gaW5kZXggYTM4YzVmZTZjYzE5Li41ZTdkOWFmNGNiYTggMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X3BsYW5lLmMKPiArKysgYi9k cml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVfcGxhbmUuYwo+IEBAIC02NywxMSArNjcs MTEgQEAgc3RhdGljIHZvaWQgbWRwNV9wbGFuZV9pbnN0YWxsX3JvdGF0aW9uX3Byb3BlcnR5KHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCj4gIHsK PiAgCWRybV9wbGFuZV9jcmVhdGVfcm90YXRpb25fcHJvcGVydHkocGxhbmUsCj4gLQkJCQkJICAg RFJNX1JPVEFURV8wLAo+IC0JCQkJCSAgIERSTV9ST1RBVEVfMCB8Cj4gLQkJCQkJICAgRFJNX1JP VEFURV8xODAgfAo+IC0JCQkJCSAgIERSTV9SRUZMRUNUX1ggfAo+IC0JCQkJCSAgIERSTV9SRUZM RUNUX1kpOwo+ICsJCQkJCSAgIERSTV9NT0RFX1JPVEFURV8wLAo+ICsJCQkJCSAgIERSTV9NT0RF X1JPVEFURV8wIHwKPiArCQkJCQkgICBEUk1fTU9ERV9ST1RBVEVfMTgwIHwKPiArCQkJCQkgICBE Uk1fTU9ERV9SRUZMRUNUX1ggfAo+ICsJCQkJCSAgIERSTV9NT0RFX1JFRkxFQ1RfWSk7Cj4gIH0K PiAgCj4gIC8qIGhlbHBlciB0byBpbnN0YWxsIHByb3BlcnRpZXMgd2hpY2ggYXJlIGNvbW1vbiB0 byBwbGFuZXMgYW5kIGNydGNzICovCj4gQEAgLTM2OSwxNCArMzY5LDE0IEBAIHN0YXRpYyBpbnQg bWRwNV9wbGFuZV9hdG9taWNfY2hlY2tfd2l0aF9zdGF0ZShzdHJ1Y3QgZHJtX2NydGNfc3RhdGUg KmNydGNfc3RhdGUsCj4gIAkJCWNhcHMgfD0gTURQX1BJUEVfQ0FQX1NDQUxFOwo+ICAKPiAgCQly b3RhdGlvbiA9IGRybV9yb3RhdGlvbl9zaW1wbGlmeShzdGF0ZS0+cm90YXRpb24sCj4gLQkJCQkJ CSBEUk1fUk9UQVRFXzAgfAo+IC0JCQkJCQkgRFJNX1JFRkxFQ1RfWCB8Cj4gLQkJCQkJCSBEUk1f UkVGTEVDVF9ZKTsKPiArCQkJCQkJIERSTV9NT0RFX1JPVEFURV8wIHwKPiArCQkJCQkJIERSTV9N T0RFX1JFRkxFQ1RfWCB8Cj4gKwkJCQkJCSBEUk1fTU9ERV9SRUZMRUNUX1kpOwo+ICAKPiAtCQlp ZiAocm90YXRpb24gJiBEUk1fUkVGTEVDVF9YKQo+ICsJCWlmIChyb3RhdGlvbiAmIERSTV9NT0RF X1JFRkxFQ1RfWCkKPiAgCQkJY2FwcyB8PSBNRFBfUElQRV9DQVBfSEZMSVA7Cj4gIAo+IC0JCWlm IChyb3RhdGlvbiAmIERSTV9SRUZMRUNUX1kpCj4gKwkJaWYgKHJvdGF0aW9uICYgRFJNX01PREVf UkVGTEVDVF9ZKQo+ICAJCQljYXBzIHw9IE1EUF9QSVBFX0NBUF9WRkxJUDsKPiAgCj4gIAkJaWYg KHBsYW5lLT50eXBlID09IERSTV9QTEFORV9UWVBFX0NVUlNPUikKPiBAQCAtOTcwLDExICs5NzAs MTEgQEAgc3RhdGljIGludCBtZHA1X3BsYW5lX21vZGVfc2V0KHN0cnVjdCBkcm1fcGxhbmUgKnBs YW5lLAo+ICAJREJHKCJzY2FsZSBjb25maWcgPSAleCIsIGNvbmZpZyk7Cj4gIAo+ICAJcm90YXRp b24gPSBkcm1fcm90YXRpb25fc2ltcGxpZnkocHN0YXRlLT5yb3RhdGlvbiwKPiAtCQkJCQkgRFJN X1JPVEFURV8wIHwKPiAtCQkJCQkgRFJNX1JFRkxFQ1RfWCB8Cj4gLQkJCQkJIERSTV9SRUZMRUNU X1kpOwo+IC0JaGZsaXAgPSAhIShyb3RhdGlvbiAmIERSTV9SRUZMRUNUX1gpOwo+IC0JdmZsaXAg PSAhIShyb3RhdGlvbiAmIERSTV9SRUZMRUNUX1kpOwo+ICsJCQkJCSBEUk1fTU9ERV9ST1RBVEVf MCB8Cj4gKwkJCQkJIERSTV9NT0RFX1JFRkxFQ1RfWCB8Cj4gKwkJCQkJIERSTV9NT0RFX1JFRkxF Q1RfWSk7Cj4gKwloZmxpcCA9ICEhKHJvdGF0aW9uICYgRFJNX01PREVfUkVGTEVDVF9YKTsKPiAr CXZmbGlwID0gISEocm90YXRpb24gJiBEUk1fTU9ERV9SRUZMRUNUX1kpOwo+ICAKPiAgCXNwaW5f bG9ja19pcnFzYXZlKCZtZHA1X3BsYW5lLT5waXBlX2xvY2ssIGZsYWdzKTsKPiAgCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfZGlzcGxheS5jIGIvZHJpdmVycy9n cHUvZHJtL25vdXZlYXUvbnY1MF9kaXNwbGF5LmMKPiBpbmRleCBhNzY2MzI0OWIzYmEuLjkzMDNk YWE3OWFiYSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udjUwX2Rpc3Bs YXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252NTBfZGlzcGxheS5jCj4gQEAg LTEwMzMsNyArMTAzMyw3IEBAIG52NTBfd25kd19yZXNldChzdHJ1Y3QgZHJtX3BsYW5lICpwbGFu ZSkKPiAgCQlwbGFuZS0+ZnVuY3MtPmF0b21pY19kZXN0cm95X3N0YXRlKHBsYW5lLCBwbGFuZS0+ c3RhdGUpOwo+ICAJcGxhbmUtPnN0YXRlID0gJmFzeXctPnN0YXRlOwo+ICAJcGxhbmUtPnN0YXRl LT5wbGFuZSA9IHBsYW5lOwo+IC0JcGxhbmUtPnN0YXRlLT5yb3RhdGlvbiA9IERSTV9ST1RBVEVf MDsKPiArCXBsYW5lLT5zdGF0ZS0+cm90YXRpb24gPSBEUk1fTU9ERV9ST1RBVEVfMDsKPiAgfQo+ ICAKPiAgc3RhdGljIHZvaWQKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL29tYXBkcm0v b21hcF9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZHJ2LmMKPiBpbmRleCBl MWY0N2YwYjNjY2YuLjY2M2U5MzBhN2IwZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v b21hcGRybS9vbWFwX2Rydi5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL29tYXBkcm0vb21hcF9k cnYuYwo+IEBAIC01NzcsNyArNTc3LDcgQEAgc3RhdGljIHZvaWQgZGV2X2xhc3RjbG9zZShzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2KQo+ICAKPiAgCQlkcm1fb2JqZWN0X3Byb3BlcnR5X3NldF92YWx1 ZSgmY3J0Yy0+YmFzZSwKPiAgCQkJCQkgICAgICBjcnRjLT5wcmltYXJ5LT5yb3RhdGlvbl9wcm9w ZXJ0eSwKPiAtCQkJCQkgICAgICBEUk1fUk9UQVRFXzApOwo+ICsJCQkJCSAgICAgIERSTV9NT0RF X1JPVEFURV8wKTsKPiAgCX0KPiAgCj4gIAlmb3IgKGkgPSAwOyBpIDwgcHJpdi0+bnVtX3BsYW5l czsgaSsrKSB7Cj4gQEAgLTU4OCw3ICs1ODgsNyBAQCBzdGF0aWMgdm9pZCBkZXZfbGFzdGNsb3Nl KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gIAo+ICAJCWRybV9vYmplY3RfcHJvcGVydHlfc2V0 X3ZhbHVlKCZwbGFuZS0+YmFzZSwKPiAgCQkJCQkgICAgICBwbGFuZS0+cm90YXRpb25fcHJvcGVy dHksCj4gLQkJCQkJICAgICAgRFJNX1JPVEFURV8wKTsKPiArCQkJCQkgICAgICBEUk1fTU9ERV9S T1RBVEVfMCk7Cj4gIAl9Cj4gIAo+ICAJaWYgKHByaXYtPmZiZGV2KSB7Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZmIuYyBiL2RyaXZlcnMvZ3B1L2RybS9vbWFw ZHJtL29tYXBfZmIuYwo+IGluZGV4IDI5ZGM2NzdkZDRkMy4uNWNhMDUzN2JiNDI3IDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfZmIuYwo+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS9vbWFwZHJtL29tYXBfZmIuYwo+IEBAIC0xNjcsMzAgKzE2NywzMCBAQCB2b2lkIG9t YXBfZnJhbWVidWZmZXJfdXBkYXRlX3NjYW5vdXQoc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIs Cj4gIAkJdWludDMyX3QgdyA9IHdpbi0+c3JjX3c7Cj4gIAkJdWludDMyX3QgaCA9IHdpbi0+c3Jj X2g7Cj4gIAo+IC0JCXN3aXRjaCAod2luLT5yb3RhdGlvbiAmIERSTV9ST1RBVEVfTUFTSykgewo+ ICsJCXN3aXRjaCAod2luLT5yb3RhdGlvbiAmIERSTV9NT0RFX1JPVEFURV9NQVNLKSB7Cj4gIAkJ ZGVmYXVsdDoKPiAgCQkJZGV2X2VycihmYi0+ZGV2LT5kZXYsICJpbnZhbGlkIHJvdGF0aW9uOiAl MDJ4IiwKPiAgCQkJCQkodWludDMyX3Qpd2luLT5yb3RhdGlvbik7Cj4gIAkJCS8qIGZhbGx0aHJ1 IHRvIGRlZmF1bHQgdG8gbm8gcm90YXRpb24gKi8KPiAgCQljYXNlIDA6Cj4gLQkJY2FzZSBEUk1f Uk9UQVRFXzA6Cj4gKwkJY2FzZSBEUk1fTU9ERV9ST1RBVEVfMDoKPiAgCQkJb3JpZW50ID0gMDsK PiAgCQkJYnJlYWs7Cj4gLQkJY2FzZSBEUk1fUk9UQVRFXzkwOgo+ICsJCWNhc2UgRFJNX01PREVf Uk9UQVRFXzkwOgo+ICAJCQlvcmllbnQgPSBNQVNLX1hZX0ZMSVAgfCBNQVNLX1hfSU5WRVJUOwo+ ICAJCQlicmVhazsKPiAtCQljYXNlIERSTV9ST1RBVEVfMTgwOgo+ICsJCWNhc2UgRFJNX01PREVf Uk9UQVRFXzE4MDoKPiAgCQkJb3JpZW50ID0gTUFTS19YX0lOVkVSVCB8IE1BU0tfWV9JTlZFUlQ7 Cj4gIAkJCWJyZWFrOwo+IC0JCWNhc2UgRFJNX1JPVEFURV8yNzA6Cj4gKwkJY2FzZSBEUk1fTU9E RV9ST1RBVEVfMjcwOgo+ICAJCQlvcmllbnQgPSBNQVNLX1hZX0ZMSVAgfCBNQVNLX1lfSU5WRVJU Owo+ICAJCQlicmVhazsKPiAgCQl9Cj4gIAo+IC0JCWlmICh3aW4tPnJvdGF0aW9uICYgRFJNX1JF RkxFQ1RfWCkKPiArCQlpZiAod2luLT5yb3RhdGlvbiAmIERSTV9NT0RFX1JFRkxFQ1RfWCkKPiAg CQkJb3JpZW50IF49IE1BU0tfWF9JTlZFUlQ7Cj4gIAo+IC0JCWlmICh3aW4tPnJvdGF0aW9uICYg RFJNX1JFRkxFQ1RfWSkKPiArCQlpZiAod2luLT5yb3RhdGlvbiAmIERSTV9NT0RFX1JFRkxFQ1Rf WSkKPiAgCQkJb3JpZW50IF49IE1BU0tfWV9JTlZFUlQ7Cj4gIAo+ICAJCS8qIGFkanVzdCB4LHkg b2Zmc2V0IGZvciBmbGlwL2ludmVydDogKi8KPiBAQCAtMjA1LDkgKzIwNSw5IEBAIHZvaWQgb21h cF9mcmFtZWJ1ZmZlcl91cGRhdGVfc2Nhbm91dChzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwK PiAgCQlpbmZvLT5yb3RhdGlvbl90eXBlID0gT01BUF9EU1NfUk9UX1RJTEVSOwo+ICAJCWluZm8t PnNjcmVlbl93aWR0aCAgPSBvbWFwX2dlbV90aWxlZF9zdHJpZGUocGxhbmUtPmJvLCBvcmllbnQp Owo+ICAJfSBlbHNlIHsKPiAtCQlzd2l0Y2ggKHdpbi0+cm90YXRpb24gJiBEUk1fUk9UQVRFX01B U0spIHsKPiArCQlzd2l0Y2ggKHdpbi0+cm90YXRpb24gJiBEUk1fTU9ERV9ST1RBVEVfTUFTSykg ewo+ICAJCWNhc2UgMDoKPiAtCQljYXNlIERSTV9ST1RBVEVfMDoKPiArCQljYXNlIERSTV9NT0RF X1JPVEFURV8wOgo+ICAJCQkvKiBPSyAqLwo+ICAJCQlicmVhazsKPiAgCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfcGxhbmUuYyBiL2RyaXZlcnMvZ3B1L2RybS9v bWFwZHJtL29tYXBfcGxhbmUuYwo+IGluZGV4IDkxNjgxNTRkNzQ5ZS4uZDNkNjgxOGM2OGY4IDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfcGxhbmUuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9vbWFwZHJtL29tYXBfcGxhbmUuYwo+IEBAIC0xNDEsNyArMTQxLDcg QEAgc3RhdGljIHZvaWQgb21hcF9wbGFuZV9hdG9taWNfZGlzYWJsZShzdHJ1Y3QgZHJtX3BsYW5l ICpwbGFuZSwKPiAgCXN0cnVjdCBvbWFwX3BsYW5lX3N0YXRlICpvbWFwX3N0YXRlID0gdG9fb21h cF9wbGFuZV9zdGF0ZShwbGFuZS0+c3RhdGUpOwo+ICAJc3RydWN0IG9tYXBfcGxhbmUgKm9tYXBf cGxhbmUgPSB0b19vbWFwX3BsYW5lKHBsYW5lKTsKPiAgCj4gLQlwbGFuZS0+c3RhdGUtPnJvdGF0 aW9uID0gRFJNX1JPVEFURV8wOwo+ICsJcGxhbmUtPnN0YXRlLT5yb3RhdGlvbiA9IERSTV9NT0RF X1JPVEFURV8wOwo+ICAJb21hcF9zdGF0ZS0+em9yZGVyID0gcGxhbmUtPnR5cGUgPT0gRFJNX1BM QU5FX1RZUEVfUFJJTUFSWQo+ICAJCQkgICA/IDAgOiBvbWFwX3BsYW5lLT5pZDsKPiAgCj4gQEAg LTE3Nyw3ICsxNzcsNyBAQCBzdGF0aWMgaW50IG9tYXBfcGxhbmVfYXRvbWljX2NoZWNrKHN0cnVj dCBkcm1fcGxhbmUgKnBsYW5lLAo+ICAJaWYgKHN0YXRlLT5jcnRjX3kgKyBzdGF0ZS0+Y3J0Y19o ID4gY3J0Y19zdGF0ZS0+YWRqdXN0ZWRfbW9kZS52ZGlzcGxheSkKPiAgCQlyZXR1cm4gLUVJTlZB TDsKPiAgCj4gLQlpZiAoc3RhdGUtPnJvdGF0aW9uICE9IERSTV9ST1RBVEVfMCAmJgo+ICsJaWYg KHN0YXRlLT5yb3RhdGlvbiAhPSBEUk1fTU9ERV9ST1RBVEVfMCAmJgo+ICAJICAgICFvbWFwX2Zy YW1lYnVmZmVyX3N1cHBvcnRzX3JvdGF0aW9uKHN0YXRlLT5mYikpCj4gIAkJcmV0dXJuIC1FSU5W QUw7Cj4gIAo+IEBAIC0yMTMsMTUgKzIxMywxNSBAQCB2b2lkIG9tYXBfcGxhbmVfaW5zdGFsbF9w cm9wZXJ0aWVzKHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lLAo+ICAJaWYgKHByaXYtPmhhc19kbW0p IHsKPiAgCQlpZiAoIXBsYW5lLT5yb3RhdGlvbl9wcm9wZXJ0eSkKPiAgCQkJZHJtX3BsYW5lX2Ny ZWF0ZV9yb3RhdGlvbl9wcm9wZXJ0eShwbGFuZSwKPiAtCQkJCQkJCSAgIERSTV9ST1RBVEVfMCwK PiAtCQkJCQkJCSAgIERSTV9ST1RBVEVfMCB8IERSTV9ST1RBVEVfOTAgfAo+IC0JCQkJCQkJICAg RFJNX1JPVEFURV8xODAgfCBEUk1fUk9UQVRFXzI3MCB8Cj4gLQkJCQkJCQkgICBEUk1fUkVGTEVD VF9YIHwgRFJNX1JFRkxFQ1RfWSk7Cj4gKwkJCQkJCQkgICBEUk1fTU9ERV9ST1RBVEVfMCwKPiAr CQkJCQkJCSAgIERSTV9NT0RFX1JPVEFURV8wIHwgRFJNX01PREVfUk9UQVRFXzkwIHwKPiArCQkJ CQkJCSAgIERSTV9NT0RFX1JPVEFURV8xODAgfCBEUk1fTU9ERV9ST1RBVEVfMjcwIHwKPiArCQkJ CQkJCSAgIERSTV9NT0RFX1JFRkxFQ1RfWCB8IERSTV9NT0RFX1JFRkxFQ1RfWSk7Cj4gIAo+ICAJ CS8qIEF0dGFjaCB0aGUgcm90YXRpb24gcHJvcGVydHkgYWxzbyB0byB0aGUgY3J0YyBvYmplY3Qg Ki8KPiAgCQlpZiAocGxhbmUtPnJvdGF0aW9uX3Byb3BlcnR5ICYmIG9iaiAhPSAmcGxhbmUtPmJh c2UpCj4gIAkJCWRybV9vYmplY3RfYXR0YWNoX3Byb3BlcnR5KG9iaiwgcGxhbmUtPnJvdGF0aW9u X3Byb3BlcnR5LAo+IC0JCQkJCQkgICBEUk1fUk9UQVRFXzApOwo+ICsJCQkJCQkgICBEUk1fTU9E RV9ST1RBVEVfMCk7Cj4gIAl9Cj4gIAo+ICAJZHJtX29iamVjdF9hdHRhY2hfcHJvcGVydHkob2Jq LCBwcml2LT56b3JkZXJfcHJvcCwgMCk7Cj4gQEAgLTI3Myw3ICsyNzMsNyBAQCBzdGF0aWMgdm9p ZCBvbWFwX3BsYW5lX3Jlc2V0KHN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lKQo+ICAJICovCj4gIAlv bWFwX3N0YXRlLT56b3JkZXIgPSBwbGFuZS0+dHlwZSA9PSBEUk1fUExBTkVfVFlQRV9QUklNQVJZ Cj4gIAkJCSAgID8gMCA6IG9tYXBfcGxhbmUtPmlkOwo+IC0Jb21hcF9zdGF0ZS0+YmFzZS5yb3Rh dGlvbiA9IERSTV9ST1RBVEVfMDsKPiArCW9tYXBfc3RhdGUtPmJhc2Uucm90YXRpb24gPSBEUk1f TU9ERV9ST1RBVEVfMDsKPiAgCj4gIAlwbGFuZS0+c3RhdGUgPSAmb21hcF9zdGF0ZS0+YmFzZTsK PiAgCXBsYW5lLT5zdGF0ZS0+cGxhbmUgPSBwbGFuZTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3Ztd2dmeC92bXdnZnhfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dm eF9rbXMuYwo+IGluZGV4IGVmOWYzYTJhNDAzMC4uYTg4NzZiMDcwMTY4IDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvZ3B1L2RybS92bXdnZngvdm13Z2Z4X2ttcy5jCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL3Ztd2dmeC92bXdnZnhfa21zLmMKPiBAQCAtNTY2LDcgKzU2Niw3IEBAIGludCB2bXdfZHVf cHJpbWFyeV9wbGFuZV9hdG9taWNfY2hlY2soc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCj4gIAo+ ICAJcmV0ID0gZHJtX3BsYW5lX2hlbHBlcl9jaGVja191cGRhdGUocGxhbmUsIHN0YXRlLT5jcnRj LCBuZXdfZmIsCj4gIAkJCQkJICAgICZzcmMsICZkZXN0LCAmY2xpcCwKPiAtCQkJCQkgICAgRFJN X1JPVEFURV8wLAo+ICsJCQkJCSAgICBEUk1fTU9ERV9ST1RBVEVfMCwKPiAgCQkJCQkgICAgRFJN X1BMQU5FX0hFTFBFUl9OT19TQ0FMSU5HLAo+ICAJCQkJCSAgICBEUk1fUExBTkVfSEVMUEVSX05P X1NDQUxJTkcsCj4gIAkJCQkJICAgIGZhbHNlLCB0cnVlLCAmdmlzaWJsZSk7Cj4gQEAgLTg0NSw3 ICs4NDUsNyBAQCB2b2lkIHZtd19kdV9wbGFuZV9yZXNldChzdHJ1Y3QgZHJtX3BsYW5lICpwbGFu ZSkKPiAgCj4gIAlwbGFuZS0+c3RhdGUgPSAmdnBzLT5iYXNlOwo+ICAJcGxhbmUtPnN0YXRlLT5w bGFuZSA9IHBsYW5lOwo+IC0JcGxhbmUtPnN0YXRlLT5yb3RhdGlvbiA9IERSTV9ST1RBVEVfMDsK PiArCXBsYW5lLT5zdGF0ZS0+cm90YXRpb24gPSBEUk1fTU9ERV9ST1RBVEVfMDsKPiAgfQo+ICAK PiAgCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9ibGVuZC5oIGIvaW5jbHVkZS9kcm0v ZHJtX2JsZW5kLmgKPiBpbmRleCAxMzIyMWNmOWIzZWIuLjM0MDM4MzgxMGEzNyAxMDA2NDQKPiAt LS0gYS9pbmNsdWRlL2RybS9kcm1fYmxlbmQuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9ibGVu ZC5oCj4gQEAgLTI1LDMxICsyNSwxNCBAQAo+ICAKPiAgI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4K PiAgI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX21vZGUuaD4K PiAgCj4gIHN0cnVjdCBkcm1fZGV2aWNlOwo+ICBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZTsKPiAg Cj4gLS8qCj4gLSAqIFJvdGF0aW9uIHByb3BlcnR5IGJpdHMuIERSTV9ST1RBVEVfPGRlZ3JlZXM+ IHJvdGF0ZXMgdGhlIGltYWdlIGJ5IHRoZQo+IC0gKiBzcGVjaWZpZWQgYW1vdW50IGluIGRlZ3Jl ZXMgaW4gY291bnRlciBjbG9ja3dpc2UgZGlyZWN0aW9uLiBEUk1fUkVGTEVDVF9YIGFuZAo+IC0g KiBEUk1fUkVGTEVDVF9ZIHJlZmxlY3RzIHRoZSBpbWFnZSBhbG9uZyB0aGUgc3BlY2lmaWVkIGF4 aXMgcHJpb3IgdG8gcm90YXRpb24KPiAtICoKPiAtICogV0FSTklORzogVGhlc2UgZGVmaW5lcyBh cmUgVUFCSSBzaW5jZSB0aGV5J3JlIGV4cG9zZWQgaW4gdGhlIHJvdGF0aW9uCj4gLSAqIHByb3Bl cnR5Lgo+IC0gKi8KPiAtI2RlZmluZSBEUk1fUk9UQVRFXzAJQklUKDApCj4gLSNkZWZpbmUgRFJN X1JPVEFURV85MAlCSVQoMSkKPiAtI2RlZmluZSBEUk1fUk9UQVRFXzE4MAlCSVQoMikKPiAtI2Rl ZmluZSBEUk1fUk9UQVRFXzI3MAlCSVQoMykKPiAtI2RlZmluZSBEUk1fUk9UQVRFX01BU0sgKERS TV9ST1RBVEVfMCAgIHwgRFJNX1JPVEFURV85MCB8IFwKPiAtCQkJIERSTV9ST1RBVEVfMTgwIHwg RFJNX1JPVEFURV8yNzApCj4gLSNkZWZpbmUgRFJNX1JFRkxFQ1RfWAlCSVQoNCkKPiAtI2RlZmlu ZSBEUk1fUkVGTEVDVF9ZCUJJVCg1KQo+IC0jZGVmaW5lIERSTV9SRUZMRUNUX01BU0sgKERSTV9S RUZMRUNUX1ggfCBEUk1fUkVGTEVDVF9ZKQo+IC0KPiAgc3RhdGljIGlubGluZSBib29sIGRybV9y b3RhdGlvbl85MF9vcl8yNzAodW5zaWduZWQgaW50IHJvdGF0aW9uKQo+ICB7Cj4gLQlyZXR1cm4g cm90YXRpb24gJiAoRFJNX1JPVEFURV85MCB8IERSTV9ST1RBVEVfMjcwKTsKPiArCXJldHVybiBy b3RhdGlvbiAmIChEUk1fTU9ERV9ST1RBVEVfOTAgfCBEUk1fTU9ERV9ST1RBVEVfMjcwKTsKPiAg fQo+ICAKPiAgaW50IGRybV9wbGFuZV9jcmVhdGVfcm90YXRpb25fcHJvcGVydHkoc3RydWN0IGRy bV9wbGFuZSAqcGxhbmUsCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUu aCBiL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUuaAo+IGluZGV4IDhjNjdmYzAzZDUzZC4uNDAz MzM5Zjk4YTkyIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUuaAo+ICsr KyBiL2luY2x1ZGUvdWFwaS9kcm0vZHJtX21vZGUuaAo+IEBAIC03NSw3ICs3NSw3IEBAIGV4dGVy biAiQyIgewo+ICAgICogKGRlZmluZSBub3QgZXhwb3NlZCB0byB1c2VyIHNwYWNlKS4KPiAgICAq Lwo+ICAjZGVmaW5lIERSTV9NT0RFX0ZMQUdfM0RfTUFTSwkJCSgweDFmPDwxNCkKPiAtI2RlZmlu ZSAgRFJNX01PREVfRkxBR18zRF9OT05FCQkJKDA8PDE0KQo+ICsjZGVmaW5lICBEUk1fTU9ERV9G TEFHXzNEX05PTkUJCSgwPDwxNCkKPiAgI2RlZmluZSAgRFJNX01PREVfRkxBR18zRF9GUkFNRV9Q QUNLSU5HCQkoMTw8MTQpCj4gICNkZWZpbmUgIERSTV9NT0RFX0ZMQUdfM0RfRklFTERfQUxURVJO QVRJVkUJKDI8PDE0KQo+ICAjZGVmaW5lICBEUk1fTU9ERV9GTEFHXzNEX0xJTkVfQUxURVJOQVRJ VkUJKDM8PDE0KQo+IEBAIC0xMjcsNiArMTI3LDUzIEBAIGV4dGVybiAiQyIgewo+ICAjZGVmaW5l IERSTV9NT0RFX0xJTktfU1RBVFVTX0dPT0QJMAo+ICAjZGVmaW5lIERSTV9NT0RFX0xJTktfU1RB VFVTX0JBRAkxCj4gIAo+ICsvKgo+ICsgKiBEUk1fTU9ERV9ST1RBVEVfPGRlZ3JlZXM+Cj4gKyAq Cj4gKyAqIFNpZ25hbHMgdGhhdCBhIGRybSBwbGFuZSBpcyBiZWVuIHJvdGF0ZWQgPGRlZ3JlZXM+ IGRlZ3JlZXMgaW4gY291bnRlcgo+ICsgKiBjbG9ja3dpc2UgZGlyZWN0aW9uLgo+ICsgKgo+ICsg KiBUaGlzIGRlZmluZSBpcyBwcm92aWRlZCBhcyBhIGNvbnZlbmllbmNlLCBsb29raW5nIHVwIHRo ZSBwcm9wZXJ0eSBpZAo+ICsgKiB1c2luZyB0aGUgbmFtZS0+cHJvcCBpZCBsb29rdXAgaXMgdGhl IHByZWZlcnJlZCBtZXRob2QuCj4gKyAqLwo+ICsjZGVmaW5lIERSTV9NT0RFX1JPVEFURV8wICAg ICAgICgxPDwwKQo+ICsjZGVmaW5lIERSTV9NT0RFX1JPVEFURV85MCAgICAgICgxPDwxKQo+ICsj ZGVmaW5lIERSTV9NT0RFX1JPVEFURV8xODAgICAgICgxPDwyKQo+ICsjZGVmaW5lIERSTV9NT0RF X1JPVEFURV8yNzAgICAgICgxPDwzKQo+ICsKPiArLyoKPiArICogRFJNX01PREVfUk9UQVRFX01B U0sKPiArICoKPiArICogQml0bWFzayB1c2VkIHRvIGxvb2sgZm9yIGRybSBwbGFuZSByb3RhdGlv bnMuCj4gKyAqLwo+ICsjZGVmaW5lIERSTV9NT0RFX1JPVEFURV9NQVNLIChcCj4gKwkJRFJNX01P REVfUk9UQVRFXzAgIHwgXAo+ICsJCURSTV9NT0RFX1JPVEFURV85MCAgfCBcCj4gKwkJRFJNX01P REVfUk9UQVRFXzE4MCB8IFwKPiArCQlEUk1fTU9ERV9ST1RBVEVfMjcwKQo+ICsKPiArLyoKPiAr ICogRFJNX01PREVfUkVGTEVDVF88YXhpcz4KPiArICoKPiArICogU2lnbmFscyB0aGF0IHRoZSBj b250ZW50cyBvZiBhIGRybSBwbGFuZSBpcyByZWZsZWN0ZWQgaW4gdGhlIDxheGlzPiBheGlzLAo+ ICsgKiBpbiB0aGUgc2FtZSB3YXkgYXMgbWlycm9yaW5nLgoKVGhhdCdzIG5vdCB3aGF0IEkgd2Fz IGFmdGVyLiBXZSdyZSBzdGlsbCBtaXNzaW5nIHRoZSBpbmZvcm1hdGlvbiBhYm91dAp0aGUgb3Jk ZXIgaW4gd2hpY2ggcmVmbGVjdGlvbiBhbmQgcm90YXRpb24gaGFwcGVucy4gQWxzbyBkb2VzICJp biB0aGUKYXhpcyIgbWVhbiB0aGUgc2FtZSB0aGluZyBhcyAiYWxvbmcgdGhlIGF4aXMiIGFuZCBu b3QgImFjcm9zcyB0aGUgYXhpcyI/Ci9tZSB0aGlua3MgdGhlIG9sZCB0ZXh0IHdhcyBiZXR0ZXIK Cj4gKyAqCj4gKyAqIFRoaXMgZGVmaW5lIGlzIHByb3ZpZGVkIGFzIGEgY29udmVuaWVuY2UsIGxv b2tpbmcgdXAgdGhlIHByb3BlcnR5IGlkCj4gKyAqIHVzaW5nIHRoZSBuYW1lLT5wcm9wIGlkIGxv b2t1cCBpcyB0aGUgcHJlZmVycmVkIG1ldGhvZC4KPiArICovCj4gKyNkZWZpbmUgRFJNX01PREVf UkVGTEVDVF9YICAgICAgKDE8PDQpCj4gKyNkZWZpbmUgRFJNX01PREVfUkVGTEVDVF9ZICAgICAg KDE8PDUpCj4gKwo+ICsvKgo+ICsgKiBEUk1fTU9ERV9SRUZMRUNUX01BU0sKPiArICoKPiArICog Qml0bWFzayB1c2VkIHRvIGxvb2sgZm9yIGRybSBwbGFuZSByZWZsZWN0aW9ucy4KPiArICovCj4g KyNkZWZpbmUgRFJNX01PREVfUkVGTEVDVF9NQVNLIChcCj4gKwkJRFJNX01PREVfUkVGTEVDVF9Y IHwgXAo+ICsJCURSTV9NT0RFX1JFRkxFQ1RfWSkKPiArCj4gKwo+ICBzdHJ1Y3QgZHJtX21vZGVf bW9kZWluZm8gewo+ICAJX191MzIgY2xvY2s7Cj4gIAlfX3UxNiBoZGlzcGxheTsKPiAtLSAKPiAy LjExLjAuNDUzLmc3ODdmNzVmMDUKCi0tIApWaWxsZSBTeXJqw6Rsw6QKSW50ZWwgT1RDCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1760382AbdEVQJZ (ORCPT ); Mon, 22 May 2017 12:09:25 -0400 Received: from mga02.intel.com ([134.134.136.20]:32377 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S935667AbdEVQJS (ORCPT ); Mon, 22 May 2017 12:09:18 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.38,377,1491289200"; d="scan'208";a="860015330" Date: Mon, 22 May 2017 19:09:08 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Robert Foss Cc: liviu.dudau@arm.com, brian.starkey@arm.com, malidp@foss.arm.com, airlied@linux.ie, linux@armlinux.org.uk, boris.brezillon@free-electrons.com, daniel.vetter@intel.com, jani.nikula@linux.intel.com, seanpaul@chromium.org, p.zabel@pengutronix.de, robdclark@gmail.com, bskeggs@redhat.com, tomi.valkeinen@ti.com, linux-graphics-maintainer@vmware.com, syeh@vmware.com, thellstrom@vmware.com, architt@codeaurora.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, intel-gfx@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, freedreno@lists.freedesktop.org, nouveau@lists.freedesktop.org, Tomeu Vizoso , Emil Velikov , Daniel Vetter , Kristian =?iso-8859-1?Q?H=F8gsberg?= Subject: Re: [PATCH v4 2/2] drm: Add DRM_MODE_ROTATE_ and DRM_MODE_REFLECT_ to UAPI Message-ID: <20170522160908.GA12629@intel.com> References: <20170519205017.23307-1-robert.foss@collabora.com> <20170519205017.23307-2-robert.foss@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20170519205017.23307-2-robert.foss@collabora.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 Fri, May 19, 2017 at 04:50:17PM -0400, Robert Foss wrote: > Add DRM_MODE_ROTATE_ and DRM_MODE_REFLECT_ defines to the UAPI > as a convenience. > > Ideally the DRM_ROTATE_ and DRM_REFLECT_ property ids are looked up > through the atomic API, but realizing that userspace is likely to take > shortcuts and assume that the enum values are what is sent over the > wire. > > As a result these defines are provided purely as a convenience to > userspace applications. > > Signed-off-by: Robert Foss > Reviewed-by: Emil Velikov > Reviewed-by: Sinclair Yeh > Acked-by: Liviu Dudau > --- > Changes since v3: > - Switched away from past tense in comments > - Add define name change to previously mis-spelled DRM_REFLECT_X comment > - Improved the comment for the DRM_MODE_REFLECT_ comment > > Changes since v2: > - Changed define prefix from DRM_MODE_PROP_ to DRM_MODE_ > - Fix compilation errors > - Changed comment formatting > - Deduplicated comment lines > - Clarified DRM_MODE_PROP_REFLECT_ comment > > Changes since v1: > - Moved defines from drm.h to drm_mode.h > - Changed define prefix from DRM_ to DRM_MODE_PROP_ > - Updated uses of the defines to the new prefix > - Removed include from drm_rect.c > - Stopped using the BIT() macro > > drivers/gpu/drm/arm/malidp_drv.h | 2 +- > drivers/gpu/drm/arm/malidp_planes.c | 18 ++++----- > drivers/gpu/drm/armada/armada_overlay.c | 2 +- > drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c | 20 +++++----- > drivers/gpu/drm/drm_atomic.c | 2 +- > drivers/gpu/drm/drm_atomic_helper.c | 2 +- > drivers/gpu/drm/drm_blend.c | 45 +++++++++++----------- > drivers/gpu/drm/drm_fb_helper.c | 4 +- > drivers/gpu/drm/drm_plane_helper.c | 2 +- > drivers/gpu/drm/drm_rect.c | 36 +++++++++--------- > drivers/gpu/drm/i915/i915_debugfs.c | 14 +++---- > drivers/gpu/drm/i915/intel_atomic_plane.c | 6 +-- > drivers/gpu/drm/i915/intel_display.c | 50 ++++++++++++------------- > drivers/gpu/drm/i915/intel_fbc.c | 2 +- > drivers/gpu/drm/i915/intel_fbdev.c | 2 +- > drivers/gpu/drm/i915/intel_sprite.c | 20 +++++----- > drivers/gpu/drm/imx/ipuv3-plane.c | 2 +- > drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c | 30 +++++++-------- > drivers/gpu/drm/nouveau/nv50_display.c | 2 +- > drivers/gpu/drm/omapdrm/omap_drv.c | 4 +- > drivers/gpu/drm/omapdrm/omap_fb.c | 18 ++++----- > drivers/gpu/drm/omapdrm/omap_plane.c | 16 ++++---- > drivers/gpu/drm/vmwgfx/vmwgfx_kms.c | 4 +- > include/drm/drm_blend.h | 21 +---------- > include/uapi/drm/drm_mode.h | 49 +++++++++++++++++++++++- > 25 files changed, 202 insertions(+), 171 deletions(-) > > diff --git a/drivers/gpu/drm/arm/malidp_drv.h b/drivers/gpu/drm/arm/malidp_drv.h > index 040311ffcaec..2e2033140efc 100644 > --- a/drivers/gpu/drm/arm/malidp_drv.h > +++ b/drivers/gpu/drm/arm/malidp_drv.h > @@ -65,6 +65,6 @@ void malidp_de_planes_destroy(struct drm_device *drm); > int malidp_crtc_init(struct drm_device *drm); > > /* often used combination of rotational bits */ > -#define MALIDP_ROTATED_MASK (DRM_ROTATE_90 | DRM_ROTATE_270) > +#define MALIDP_ROTATED_MASK (DRM_MODE_ROTATE_90 | DRM_MODE_ROTATE_270) > > #endif /* __MALIDP_DRV_H__ */ > diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/malidp_planes.c > index 814fda23cead..063a8d2b0be3 100644 > --- a/drivers/gpu/drm/arm/malidp_planes.c > +++ b/drivers/gpu/drm/arm/malidp_planes.c > @@ -80,7 +80,7 @@ static void malidp_plane_reset(struct drm_plane *plane) > state = kzalloc(sizeof(*state), GFP_KERNEL); > if (state) { > state->base.plane = plane; > - state->base.rotation = DRM_ROTATE_0; > + state->base.rotation = DRM_MODE_ROTATE_0; > plane->state = &state->base; > } > } > @@ -221,7 +221,7 @@ static int malidp_de_plane_check(struct drm_plane *plane, > return ret; > > /* packed RGB888 / BGR888 can't be rotated or flipped */ > - if (state->rotation != DRM_ROTATE_0 && > + if (state->rotation != DRM_MODE_ROTATE_0 && > (fb->format->format == DRM_FORMAT_RGB888 || > fb->format->format == DRM_FORMAT_BGR888)) > return -EINVAL; > @@ -315,12 +315,12 @@ static void malidp_de_plane_update(struct drm_plane *plane, > val &= ~LAYER_ROT_MASK; > > /* setup the rotation and axis flip bits */ > - if (plane->state->rotation & DRM_ROTATE_MASK) > - val |= ilog2(plane->state->rotation & DRM_ROTATE_MASK) << > + if (plane->state->rotation & DRM_MODE_ROTATE_MASK) > + val |= ilog2(plane->state->rotation & DRM_MODE_ROTATE_MASK) << > LAYER_ROT_OFFSET; > - if (plane->state->rotation & DRM_REFLECT_X) > + if (plane->state->rotation & DRM_MODE_REFLECT_X) > val |= LAYER_H_FLIP; > - if (plane->state->rotation & DRM_REFLECT_Y) > + if (plane->state->rotation & DRM_MODE_REFLECT_Y) > val |= LAYER_V_FLIP; > > /* > @@ -370,8 +370,8 @@ int malidp_de_planes_init(struct drm_device *drm) > struct malidp_plane *plane = NULL; > enum drm_plane_type plane_type; > unsigned long crtcs = 1 << drm->mode_config.num_crtc; > - unsigned long flags = DRM_ROTATE_0 | DRM_ROTATE_90 | DRM_ROTATE_180 | > - DRM_ROTATE_270 | DRM_REFLECT_X | DRM_REFLECT_Y; > + unsigned long flags = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 | DRM_MODE_ROTATE_180 | > + DRM_MODE_ROTATE_270 | DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y; > u32 *formats; > int ret, i, j, n; > > @@ -420,7 +420,7 @@ int malidp_de_planes_init(struct drm_device *drm) > continue; > } > > - drm_plane_create_rotation_property(&plane->base, DRM_ROTATE_0, flags); > + drm_plane_create_rotation_property(&plane->base, DRM_MODE_ROTATE_0, flags); > malidp_hw_write(malidp->dev, MALIDP_ALPHA_LUT, > plane->layer->base + MALIDP_LAYER_COMPOSE); > } > diff --git a/drivers/gpu/drm/armada/armada_overlay.c b/drivers/gpu/drm/armada/armada_overlay.c > index 424e465ff407..e9a29df4b443 100644 > --- a/drivers/gpu/drm/armada/armada_overlay.c > +++ b/drivers/gpu/drm/armada/armada_overlay.c > @@ -125,7 +125,7 @@ armada_ovl_plane_update(struct drm_plane *plane, struct drm_crtc *crtc, > src_x, src_y, src_w, src_h); > > ret = drm_plane_helper_check_update(plane, crtc, fb, &src, &dest, &clip, > - DRM_ROTATE_0, > + DRM_MODE_ROTATE_0, > 0, INT_MAX, true, false, &visible); > if (ret) > return ret; > diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c > index 29cc10d053eb..1124200bb280 100644 > --- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c > +++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c > @@ -678,8 +678,8 @@ static int atmel_hlcdc_plane_atomic_check(struct drm_plane *p, > if (!state->bpp[i]) > return -EINVAL; > > - switch (state->base.rotation & DRM_ROTATE_MASK) { > - case DRM_ROTATE_90: > + switch (state->base.rotation & DRM_MODE_ROTATE_MASK) { > + case DRM_MODE_ROTATE_90: > offset = ((y_offset + state->src_y + patched_src_w - 1) / > ydiv) * fb->pitches[i]; > offset += ((x_offset + state->src_x) / xdiv) * > @@ -688,7 +688,7 @@ static int atmel_hlcdc_plane_atomic_check(struct drm_plane *p, > fb->pitches[i]; > state->pstride[i] = -fb->pitches[i] - state->bpp[i]; > break; > - case DRM_ROTATE_180: > + case DRM_MODE_ROTATE_180: > offset = ((y_offset + state->src_y + patched_src_h - 1) / > ydiv) * fb->pitches[i]; > offset += ((x_offset + state->src_x + patched_src_w - 1) / > @@ -697,7 +697,7 @@ static int atmel_hlcdc_plane_atomic_check(struct drm_plane *p, > state->bpp[i]) - fb->pitches[i]; > state->pstride[i] = -2 * state->bpp[i]; > break; > - case DRM_ROTATE_270: > + case DRM_MODE_ROTATE_270: > offset = ((y_offset + state->src_y) / ydiv) * > fb->pitches[i]; > offset += ((x_offset + state->src_x + patched_src_h - 1) / > @@ -707,7 +707,7 @@ static int atmel_hlcdc_plane_atomic_check(struct drm_plane *p, > (2 * state->bpp[i]); > state->pstride[i] = fb->pitches[i] - state->bpp[i]; > break; > - case DRM_ROTATE_0: > + case DRM_MODE_ROTATE_0: > default: > offset = ((y_offset + state->src_y) / ydiv) * > fb->pitches[i]; > @@ -864,11 +864,11 @@ static int atmel_hlcdc_plane_init_properties(struct atmel_hlcdc_plane *plane, > int ret; > > ret = drm_plane_create_rotation_property(&plane->base, > - DRM_ROTATE_0, > - DRM_ROTATE_0 | > - DRM_ROTATE_90 | > - DRM_ROTATE_180 | > - DRM_ROTATE_270); > + DRM_MODE_ROTATE_0, > + DRM_MODE_ROTATE_0 | > + DRM_MODE_ROTATE_90 | > + DRM_MODE_ROTATE_180 | > + DRM_MODE_ROTATE_270); > if (ret) > return ret; > } > diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c > index f32506a7c1d6..f434d79de37e 100644 > --- a/drivers/gpu/drm/drm_atomic.c > +++ b/drivers/gpu/drm/drm_atomic.c > @@ -769,7 +769,7 @@ int drm_atomic_plane_set_property(struct drm_plane *plane, > } else if (property == config->prop_src_h) { > state->src_h = val; > } else if (property == plane->rotation_property) { > - if (!is_power_of_2(val & DRM_ROTATE_MASK)) > + if (!is_power_of_2(val & DRM_MODE_ROTATE_MASK)) > return -EINVAL; > state->rotation = val; > } else if (property == plane->zpos_property) { > diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c > index 8be9719284b0..165baa9a37e1 100644 > --- a/drivers/gpu/drm/drm_atomic_helper.c > +++ b/drivers/gpu/drm/drm_atomic_helper.c > @@ -3220,7 +3220,7 @@ void drm_atomic_helper_plane_reset(struct drm_plane *plane) > > if (plane->state) { > plane->state->plane = plane; > - plane->state->rotation = DRM_ROTATE_0; > + plane->state->rotation = DRM_MODE_ROTATE_0; > } > } > EXPORT_SYMBOL(drm_atomic_helper_plane_reset); > diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c > index dee67ef6c670..db6aeec50b82 100644 > --- a/drivers/gpu/drm/drm_blend.c > +++ b/drivers/gpu/drm/drm_blend.c > @@ -119,17 +119,17 @@ > * drm_property_create_bitmask()) called "rotation" and has the following > * bitmask enumaration values: > * > - * DRM_ROTATE_0: > + * DRM_MODE_ROTATE_0: > * "rotate-0" > - * DRM_ROTATE_90: > + * DRM_MODE_ROTATE_90: > * "rotate-90" > - * DRM_ROTATE_180: > + * DRM_MODE_ROTATE_180: > * "rotate-180" > - * DRM_ROTATE_270: > + * DRM_MODE_ROTATE_270: > * "rotate-270" > - * DRM_REFLECT_X: > + * DRM_MODE_REFLECT_X: > * "reflect-x" > - * DRM_REFLECT_Y: > + * DRM_MODE_REFLECT_Y: > * "reflect-y" > * > * Rotation is the specified amount in degrees in counter clockwise direction, > @@ -142,17 +142,17 @@ int drm_plane_create_rotation_property(struct drm_plane *plane, > unsigned int supported_rotations) > { > static const struct drm_prop_enum_list props[] = { > - { __builtin_ffs(DRM_ROTATE_0) - 1, "rotate-0" }, > - { __builtin_ffs(DRM_ROTATE_90) - 1, "rotate-90" }, > - { __builtin_ffs(DRM_ROTATE_180) - 1, "rotate-180" }, > - { __builtin_ffs(DRM_ROTATE_270) - 1, "rotate-270" }, > - { __builtin_ffs(DRM_REFLECT_X) - 1, "reflect-x" }, > - { __builtin_ffs(DRM_REFLECT_Y) - 1, "reflect-y" }, > + { __builtin_ffs(DRM_MODE_ROTATE_0) - 1, "rotate-0" }, > + { __builtin_ffs(DRM_MODE_ROTATE_90) - 1, "rotate-90" }, > + { __builtin_ffs(DRM_MODE_ROTATE_180) - 1, "rotate-180" }, > + { __builtin_ffs(DRM_MODE_ROTATE_270) - 1, "rotate-270" }, > + { __builtin_ffs(DRM_MODE_REFLECT_X) - 1, "reflect-x" }, > + { __builtin_ffs(DRM_MODE_REFLECT_Y) - 1, "reflect-y" }, > }; > struct drm_property *prop; > > - WARN_ON((supported_rotations & DRM_ROTATE_MASK) == 0); > - WARN_ON(!is_power_of_2(rotation & DRM_ROTATE_MASK)); > + WARN_ON((supported_rotations & DRM_MODE_ROTATE_MASK) == 0); > + WARN_ON(!is_power_of_2(rotation & DRM_MODE_ROTATE_MASK)); > WARN_ON(rotation & ~supported_rotations); > > prop = drm_property_create_bitmask(plane->dev, 0, "rotation", > @@ -178,14 +178,14 @@ EXPORT_SYMBOL(drm_plane_create_rotation_property); > * @supported_rotations: Supported rotations > * > * Attempt to simplify the rotation to a form that is supported. > - * Eg. if the hardware supports everything except DRM_REFLECT_X > + * Eg. if the hardware supports everything except DRM_MODE_REFLECT_X > * one could call this function like this: > * > - * drm_rotation_simplify(rotation, DRM_ROTATE_0 | > - * DRM_ROTATE_90 | DRM_ROTATE_180 | > - * DRM_ROTATE_270 | DRM_REFLECT_Y); > + * drm_rotation_simplify(rotation, DRM_MODE_ROTATE_0 | > + * DRM_MODE_ROTATE_90 | DRM_MODE_ROTATE_180 | > + * DRM_MODE_ROTATE_270 | DRM_MODE_REFLECT_Y); > * > - * to eliminate the DRM_ROTATE_X flag. Depending on what kind of > + * to eliminate the DRM_MODE_ROTATE_X flag. Depending on what kind of > * transforms the hardware supports, this function may not > * be able to produce a supported transform, so the caller should > * check the result afterwards. > @@ -194,9 +194,10 @@ unsigned int drm_rotation_simplify(unsigned int rotation, > unsigned int supported_rotations) > { > if (rotation & ~supported_rotations) { > - rotation ^= DRM_REFLECT_X | DRM_REFLECT_Y; > - rotation = (rotation & DRM_REFLECT_MASK) | > - BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4); > + rotation ^= DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y; > + rotation = (rotation & DRM_MODE_REFLECT_MASK) | > + BIT((ffs(rotation & DRM_MODE_ROTATE_MASK) + 1) > + % 4); > } > > return rotation; > diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c > index 1f178b878e42..574af01d3ce9 100644 > --- a/drivers/gpu/drm/drm_fb_helper.c > +++ b/drivers/gpu/drm/drm_fb_helper.c > @@ -378,7 +378,7 @@ static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper) > goto fail; > } > > - plane_state->rotation = DRM_ROTATE_0; > + plane_state->rotation = DRM_MODE_ROTATE_0; > > plane->old_fb = plane->fb; > plane_mask |= 1 << drm_plane_index(plane); > @@ -431,7 +431,7 @@ static int restore_fbdev_mode_legacy(struct drm_fb_helper *fb_helper) > if (plane->rotation_property) > drm_mode_plane_set_obj_prop(plane, > plane->rotation_property, > - DRM_ROTATE_0); > + DRM_MODE_ROTATE_0); > } > > for (i = 0; i < fb_helper->crtc_count; i++) { > diff --git a/drivers/gpu/drm/drm_plane_helper.c b/drivers/gpu/drm/drm_plane_helper.c > index b84a295230fc..ac1c514cad2c 100644 > --- a/drivers/gpu/drm/drm_plane_helper.c > +++ b/drivers/gpu/drm/drm_plane_helper.c > @@ -336,7 +336,7 @@ int drm_primary_helper_update(struct drm_plane *plane, struct drm_crtc *crtc, > > ret = drm_plane_helper_check_update(plane, crtc, fb, > &src, &dest, &clip, > - DRM_ROTATE_0, > + DRM_MODE_ROTATE_0, > DRM_PLANE_HELPER_NO_SCALING, > DRM_PLANE_HELPER_NO_SCALING, > false, false, &visible); > diff --git a/drivers/gpu/drm/drm_rect.c b/drivers/gpu/drm/drm_rect.c > index bc5575960ebc..9817c1445ba9 100644 > --- a/drivers/gpu/drm/drm_rect.c > +++ b/drivers/gpu/drm/drm_rect.c > @@ -310,38 +310,38 @@ void drm_rect_rotate(struct drm_rect *r, > { > struct drm_rect tmp; > > - if (rotation & (DRM_REFLECT_X | DRM_REFLECT_Y)) { > + if (rotation & (DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y)) { > tmp = *r; > > - if (rotation & DRM_REFLECT_X) { > + if (rotation & DRM_MODE_REFLECT_X) { > r->x1 = width - tmp.x2; > r->x2 = width - tmp.x1; > } > > - if (rotation & DRM_REFLECT_Y) { > + if (rotation & DRM_MODE_REFLECT_Y) { > r->y1 = height - tmp.y2; > r->y2 = height - tmp.y1; > } > } > > - switch (rotation & DRM_ROTATE_MASK) { > - case DRM_ROTATE_0: > + switch (rotation & DRM_MODE_ROTATE_MASK) { > + case DRM_MODE_ROTATE_0: > break; > - case DRM_ROTATE_90: > + case DRM_MODE_ROTATE_90: > tmp = *r; > r->x1 = tmp.y1; > r->x2 = tmp.y2; > r->y1 = width - tmp.x2; > r->y2 = width - tmp.x1; > break; > - case DRM_ROTATE_180: > + case DRM_MODE_ROTATE_180: > tmp = *r; > r->x1 = width - tmp.x2; > r->x2 = width - tmp.x1; > r->y1 = height - tmp.y2; > r->y2 = height - tmp.y1; > break; > - case DRM_ROTATE_270: > + case DRM_MODE_ROTATE_270: > tmp = *r; > r->x1 = height - tmp.y2; > r->x2 = height - tmp.y1; > @@ -373,8 +373,8 @@ EXPORT_SYMBOL(drm_rect_rotate); > * them when doing a rotatation and its inverse. > * That is, if you do :: > * > - * drm_rotate(&r, width, height, rotation); > - * drm_rotate_inv(&r, width, height, rotation); > + * DRM_MODE_PROP_ROTATE(&r, width, height, rotation); > + * DRM_MODE_ROTATE_inv(&r, width, height, rotation); > * > * you will always get back the original rectangle. > */ > @@ -384,24 +384,24 @@ void drm_rect_rotate_inv(struct drm_rect *r, > { > struct drm_rect tmp; > > - switch (rotation & DRM_ROTATE_MASK) { > - case DRM_ROTATE_0: > + switch (rotation & DRM_MODE_ROTATE_MASK) { > + case DRM_MODE_ROTATE_0: > break; > - case DRM_ROTATE_90: > + case DRM_MODE_ROTATE_90: > tmp = *r; > r->x1 = width - tmp.y2; > r->x2 = width - tmp.y1; > r->y1 = tmp.x1; > r->y2 = tmp.x2; > break; > - case DRM_ROTATE_180: > + case DRM_MODE_ROTATE_180: > tmp = *r; > r->x1 = width - tmp.x2; > r->x2 = width - tmp.x1; > r->y1 = height - tmp.y2; > r->y2 = height - tmp.y1; > break; > - case DRM_ROTATE_270: > + case DRM_MODE_ROTATE_270: > tmp = *r; > r->x1 = tmp.y1; > r->x2 = tmp.y2; > @@ -412,15 +412,15 @@ void drm_rect_rotate_inv(struct drm_rect *r, > break; > } > > - if (rotation & (DRM_REFLECT_X | DRM_REFLECT_Y)) { > + if (rotation & (DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y)) { > tmp = *r; > > - if (rotation & DRM_REFLECT_X) { > + if (rotation & DRM_MODE_REFLECT_X) { > r->x1 = width - tmp.x2; > r->x2 = width - tmp.x1; > } > > - if (rotation & DRM_REFLECT_Y) { > + if (rotation & DRM_MODE_REFLECT_Y) { > r->y1 = height - tmp.y2; > r->y2 = height - tmp.y1; > } > diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c > index d689e511744e..bf6d4498a94a 100644 > --- a/drivers/gpu/drm/i915/i915_debugfs.c > +++ b/drivers/gpu/drm/i915/i915_debugfs.c > @@ -3095,17 +3095,17 @@ static const char *plane_rotation(unsigned int rotation) > { > static char buf[48]; > /* > - * According to doc only one DRM_ROTATE_ is allowed but this > + * According to doc only one DRM_MODE_ROTATE_ is allowed but this > * will print them all to visualize if the values are misused > */ > snprintf(buf, sizeof(buf), > "%s%s%s%s%s%s(0x%08x)", > - (rotation & DRM_ROTATE_0) ? "0 " : "", > - (rotation & DRM_ROTATE_90) ? "90 " : "", > - (rotation & DRM_ROTATE_180) ? "180 " : "", > - (rotation & DRM_ROTATE_270) ? "270 " : "", > - (rotation & DRM_REFLECT_X) ? "FLIPX " : "", > - (rotation & DRM_REFLECT_Y) ? "FLIPY " : "", > + (rotation & DRM_MODE_ROTATE_0) ? "0 " : "", > + (rotation & DRM_MODE_ROTATE_90) ? "90 " : "", > + (rotation & DRM_MODE_ROTATE_180) ? "180 " : "", > + (rotation & DRM_MODE_ROTATE_270) ? "270 " : "", > + (rotation & DRM_MODE_REFLECT_X) ? "FLIPX " : "", > + (rotation & DRM_MODE_REFLECT_Y) ? "FLIPY " : "", > rotation); > > return buf; > diff --git a/drivers/gpu/drm/i915/intel_atomic_plane.c b/drivers/gpu/drm/i915/intel_atomic_plane.c > index cfb47293fd53..a40c82c65450 100644 > --- a/drivers/gpu/drm/i915/intel_atomic_plane.c > +++ b/drivers/gpu/drm/i915/intel_atomic_plane.c > @@ -55,7 +55,7 @@ intel_create_plane_state(struct drm_plane *plane) > return NULL; > > state->base.plane = plane; > - state->base.rotation = DRM_ROTATE_0; > + state->base.rotation = DRM_MODE_ROTATE_0; > state->ckey.flags = I915_SET_COLORKEY_NONE; > > return state; > @@ -178,8 +178,8 @@ int intel_plane_atomic_check_with_state(struct intel_crtc_state *crtc_state, > > /* CHV ignores the mirror bit when the rotate bit is set :( */ > if (IS_CHERRYVIEW(dev_priv) && > - state->rotation & DRM_ROTATE_180 && > - state->rotation & DRM_REFLECT_X) { > + state->rotation & DRM_MODE_ROTATE_180 && > + state->rotation & DRM_MODE_REFLECT_X) { > DRM_DEBUG_KMS("Cannot rotate and reflect at the same time\n"); > return -EINVAL; > } > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index 3617927af269..016aa3f6e69a 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -2468,7 +2468,7 @@ intel_fill_fb_info(struct drm_i915_private *dev_priv, > > offset = _intel_compute_tile_offset(dev_priv, &x, &y, > fb, i, fb->pitches[i], > - DRM_ROTATE_0, tile_size); > + DRM_MODE_ROTATE_0, tile_size); > offset /= tile_size; > > if (fb->modifier != DRM_FORMAT_MOD_LINEAR) { > @@ -2503,7 +2503,7 @@ intel_fill_fb_info(struct drm_i915_private *dev_priv, > drm_rect_rotate(&r, > rot_info->plane[i].width * tile_width, > rot_info->plane[i].height * tile_height, > - DRM_ROTATE_270); > + DRM_MODE_ROTATE_270); > x = r.x1; > y = r.y1; > > @@ -2939,7 +2939,7 @@ int skl_check_plane_surface(struct intel_plane_state *plane_state) > if (drm_rotation_90_or_270(rotation)) > drm_rect_rotate(&plane_state->base.src, > fb->width << 16, fb->height << 16, > - DRM_ROTATE_270); > + DRM_MODE_ROTATE_270); > > /* > * Handle the AUX surface first since > @@ -3017,10 +3017,10 @@ static u32 i9xx_plane_ctl(const struct intel_crtc_state *crtc_state, > fb->modifier == I915_FORMAT_MOD_X_TILED) > dspcntr |= DISPPLANE_TILED; > > - if (rotation & DRM_ROTATE_180) > + if (rotation & DRM_MODE_ROTATE_180) > dspcntr |= DISPPLANE_ROTATE_180; > > - if (rotation & DRM_REFLECT_X) > + if (rotation & DRM_MODE_REFLECT_X) > dspcntr |= DISPPLANE_MIRROR; > > return dspcntr; > @@ -3048,10 +3048,10 @@ int i9xx_check_plane_surface(struct intel_plane_state *plane_state) > int src_w = drm_rect_width(&plane_state->base.src) >> 16; > int src_h = drm_rect_height(&plane_state->base.src) >> 16; > > - if (rotation & DRM_ROTATE_180) { > + if (rotation & DRM_MODE_ROTATE_180) { > src_x += src_w - 1; > src_y += src_h - 1; > - } else if (rotation & DRM_REFLECT_X) { > + } else if (rotation & DRM_MODE_REFLECT_X) { > src_x += src_w - 1; > } > } > @@ -3271,17 +3271,17 @@ static u32 skl_plane_ctl_tiling(uint64_t fb_modifier) > static u32 skl_plane_ctl_rotation(unsigned int rotation) > { > switch (rotation) { > - case DRM_ROTATE_0: > + case DRM_MODE_ROTATE_0: > break; > /* > - * DRM_ROTATE_ is counter clockwise to stay compatible with Xrandr > + * DRM_MODE_ROTATE_ is counter clockwise to stay compatible with Xrandr > * while i915 HW rotation is clockwise, thats why this swapping. > */ > - case DRM_ROTATE_90: > + case DRM_MODE_ROTATE_90: > return PLANE_CTL_ROTATE_270; > - case DRM_ROTATE_180: > + case DRM_MODE_ROTATE_180: > return PLANE_CTL_ROTATE_180; > - case DRM_ROTATE_270: > + case DRM_MODE_ROTATE_270: > return PLANE_CTL_ROTATE_90; > default: > MISSING_CASE(rotation); > @@ -4671,7 +4671,7 @@ int skl_update_scaler_crtc(struct intel_crtc_state *state) > const struct drm_display_mode *adjusted_mode = &state->base.adjusted_mode; > > return skl_update_scaler(state, !state->base.active, SKL_CRTC_INDEX, > - &state->scaler_state.scaler_id, DRM_ROTATE_0, > + &state->scaler_state.scaler_id, DRM_MODE_ROTATE_0, > state->pipe_src_w, state->pipe_src_h, > adjusted_mode->crtc_hdisplay, adjusted_mode->crtc_vdisplay); > } > @@ -9239,7 +9239,7 @@ static u32 i9xx_cursor_ctl(const struct intel_crtc_state *crtc_state, > return 0; > } > > - if (plane_state->base.rotation & DRM_ROTATE_180) > + if (plane_state->base.rotation & DRM_MODE_ROTATE_180) > cntl |= CURSOR_ROTATE_180; > > return cntl; > @@ -9300,7 +9300,7 @@ static void intel_crtc_update_cursor(struct drm_crtc *crtc, > > /* ILK+ do this automagically */ > if (HAS_GMCH_DISPLAY(dev_priv) && > - plane_state->base.rotation & DRM_ROTATE_180) { > + plane_state->base.rotation & DRM_MODE_ROTATE_180) { > base += (plane_state->base.crtc_h * > plane_state->base.crtc_w - 1) * 4; > } > @@ -13613,22 +13613,22 @@ intel_primary_plane_create(struct drm_i915_private *dev_priv, enum pipe pipe) > > if (INTEL_GEN(dev_priv) >= 9) { > supported_rotations = > - DRM_ROTATE_0 | DRM_ROTATE_90 | > - DRM_ROTATE_180 | DRM_ROTATE_270; > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 | > + DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270; > } else if (IS_CHERRYVIEW(dev_priv) && pipe == PIPE_B) { > supported_rotations = > - DRM_ROTATE_0 | DRM_ROTATE_180 | > - DRM_REFLECT_X; > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 | > + DRM_MODE_REFLECT_X; > } else if (INTEL_GEN(dev_priv) >= 4) { > supported_rotations = > - DRM_ROTATE_0 | DRM_ROTATE_180; > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180; > } else { > - supported_rotations = DRM_ROTATE_0; > + supported_rotations = DRM_MODE_ROTATE_0; > } > > if (INTEL_GEN(dev_priv) >= 4) > drm_plane_create_rotation_property(&primary->base, > - DRM_ROTATE_0, > + DRM_MODE_ROTATE_0, > supported_rotations); > > drm_plane_helper_add(&primary->base, &intel_plane_helper_funcs); > @@ -13783,9 +13783,9 @@ intel_cursor_plane_create(struct drm_i915_private *dev_priv, enum pipe pipe) > > if (INTEL_GEN(dev_priv) >= 4) > drm_plane_create_rotation_property(&cursor->base, > - DRM_ROTATE_0, > - DRM_ROTATE_0 | > - DRM_ROTATE_180); > + DRM_MODE_ROTATE_0, > + DRM_MODE_ROTATE_0 | > + DRM_MODE_ROTATE_180); > > if (INTEL_GEN(dev_priv) >= 9) > state->scaler_id = -1; > diff --git a/drivers/gpu/drm/i915/intel_fbc.c b/drivers/gpu/drm/i915/intel_fbc.c > index ded2add18b26..db7f8f0a1f36 100644 > --- a/drivers/gpu/drm/i915/intel_fbc.c > +++ b/drivers/gpu/drm/i915/intel_fbc.c > @@ -801,7 +801,7 @@ static bool intel_fbc_can_activate(struct intel_crtc *crtc) > return false; > } > if (INTEL_GEN(dev_priv) <= 4 && !IS_G4X(dev_priv) && > - cache->plane.rotation != DRM_ROTATE_0) { > + cache->plane.rotation != DRM_MODE_ROTATE_0) { > fbc->no_fbc_reason = "rotation unsupported"; > return false; > } > diff --git a/drivers/gpu/drm/i915/intel_fbdev.c b/drivers/gpu/drm/i915/intel_fbdev.c > index 332254a8eebe..03347c6ae599 100644 > --- a/drivers/gpu/drm/i915/intel_fbdev.c > +++ b/drivers/gpu/drm/i915/intel_fbdev.c > @@ -211,7 +211,7 @@ static int intelfb_create(struct drm_fb_helper *helper, > * This also validates that any existing fb inherited from the > * BIOS is suitable for own access. > */ > - vma = intel_pin_and_fence_fb_obj(&ifbdev->fb->base, DRM_ROTATE_0); > + vma = intel_pin_and_fence_fb_obj(&ifbdev->fb->base, DRM_MODE_ROTATE_0); > if (IS_ERR(vma)) { > ret = PTR_ERR(vma); > goto out_unlock; > diff --git a/drivers/gpu/drm/i915/intel_sprite.c b/drivers/gpu/drm/i915/intel_sprite.c > index 8c87c717c7cd..191e14ddde0c 100644 > --- a/drivers/gpu/drm/i915/intel_sprite.c > +++ b/drivers/gpu/drm/i915/intel_sprite.c > @@ -398,10 +398,10 @@ static u32 vlv_sprite_ctl(const struct intel_crtc_state *crtc_state, > if (fb->modifier == I915_FORMAT_MOD_X_TILED) > sprctl |= SP_TILED; > > - if (rotation & DRM_ROTATE_180) > + if (rotation & DRM_MODE_ROTATE_180) > sprctl |= SP_ROTATE_180; > > - if (rotation & DRM_REFLECT_X) > + if (rotation & DRM_MODE_REFLECT_X) > sprctl |= SP_MIRROR; > > if (key->flags & I915_SET_COLORKEY_SOURCE) > @@ -533,7 +533,7 @@ static u32 ivb_sprite_ctl(const struct intel_crtc_state *crtc_state, > if (fb->modifier == I915_FORMAT_MOD_X_TILED) > sprctl |= SPRITE_TILED; > > - if (rotation & DRM_ROTATE_180) > + if (rotation & DRM_MODE_ROTATE_180) > sprctl |= SPRITE_ROTATE_180; > > if (key->flags & I915_SET_COLORKEY_DESTINATION) > @@ -674,7 +674,7 @@ static u32 ilk_sprite_ctl(const struct intel_crtc_state *crtc_state, > if (fb->modifier == I915_FORMAT_MOD_X_TILED) > dvscntr |= DVS_TILED; > > - if (rotation & DRM_ROTATE_180) > + if (rotation & DRM_MODE_ROTATE_180) > dvscntr |= DVS_ROTATE_180; > > if (key->flags & I915_SET_COLORKEY_DESTINATION) > @@ -1145,15 +1145,15 @@ intel_sprite_plane_create(struct drm_i915_private *dev_priv, > > if (INTEL_GEN(dev_priv) >= 9) { > supported_rotations = > - DRM_ROTATE_0 | DRM_ROTATE_90 | > - DRM_ROTATE_180 | DRM_ROTATE_270; > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 | > + DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270; > } else if (IS_CHERRYVIEW(dev_priv) && pipe == PIPE_B) { > supported_rotations = > - DRM_ROTATE_0 | DRM_ROTATE_180 | > - DRM_REFLECT_X; > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 | > + DRM_MODE_REFLECT_X; > } else { > supported_rotations = > - DRM_ROTATE_0 | DRM_ROTATE_180; > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180; > } > > intel_plane->pipe = pipe; > @@ -1180,7 +1180,7 @@ intel_sprite_plane_create(struct drm_i915_private *dev_priv, > goto fail; > > drm_plane_create_rotation_property(&intel_plane->base, > - DRM_ROTATE_0, > + DRM_MODE_ROTATE_0, > supported_rotations); > > drm_plane_helper_add(&intel_plane->base, &intel_plane_helper_funcs); > diff --git a/drivers/gpu/drm/imx/ipuv3-plane.c b/drivers/gpu/drm/imx/ipuv3-plane.c > index d63e853a0300..49546222c6d3 100644 > --- a/drivers/gpu/drm/imx/ipuv3-plane.c > +++ b/drivers/gpu/drm/imx/ipuv3-plane.c > @@ -273,7 +273,7 @@ void ipu_plane_state_reset(struct drm_plane *plane) > > if (ipu_state) { > ipu_state->base.plane = plane; > - ipu_state->base.rotation = DRM_ROTATE_0; > + ipu_state->base.rotation = DRM_MODE_ROTATE_0; > } > > plane->state = &ipu_state->base; > diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c > index a38c5fe6cc19..5e7d9af4cba8 100644 > --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c > +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c > @@ -67,11 +67,11 @@ static void mdp5_plane_install_rotation_property(struct drm_device *dev, > struct drm_plane *plane) > { > drm_plane_create_rotation_property(plane, > - DRM_ROTATE_0, > - DRM_ROTATE_0 | > - DRM_ROTATE_180 | > - DRM_REFLECT_X | > - DRM_REFLECT_Y); > + DRM_MODE_ROTATE_0, > + DRM_MODE_ROTATE_0 | > + DRM_MODE_ROTATE_180 | > + DRM_MODE_REFLECT_X | > + DRM_MODE_REFLECT_Y); > } > > /* helper to install properties which are common to planes and crtcs */ > @@ -369,14 +369,14 @@ static int mdp5_plane_atomic_check_with_state(struct drm_crtc_state *crtc_state, > caps |= MDP_PIPE_CAP_SCALE; > > rotation = drm_rotation_simplify(state->rotation, > - DRM_ROTATE_0 | > - DRM_REFLECT_X | > - DRM_REFLECT_Y); > + DRM_MODE_ROTATE_0 | > + DRM_MODE_REFLECT_X | > + DRM_MODE_REFLECT_Y); > > - if (rotation & DRM_REFLECT_X) > + if (rotation & DRM_MODE_REFLECT_X) > caps |= MDP_PIPE_CAP_HFLIP; > > - if (rotation & DRM_REFLECT_Y) > + if (rotation & DRM_MODE_REFLECT_Y) > caps |= MDP_PIPE_CAP_VFLIP; > > if (plane->type == DRM_PLANE_TYPE_CURSOR) > @@ -970,11 +970,11 @@ static int mdp5_plane_mode_set(struct drm_plane *plane, > DBG("scale config = %x", config); > > rotation = drm_rotation_simplify(pstate->rotation, > - DRM_ROTATE_0 | > - DRM_REFLECT_X | > - DRM_REFLECT_Y); > - hflip = !!(rotation & DRM_REFLECT_X); > - vflip = !!(rotation & DRM_REFLECT_Y); > + DRM_MODE_ROTATE_0 | > + DRM_MODE_REFLECT_X | > + DRM_MODE_REFLECT_Y); > + hflip = !!(rotation & DRM_MODE_REFLECT_X); > + vflip = !!(rotation & DRM_MODE_REFLECT_Y); > > spin_lock_irqsave(&mdp5_plane->pipe_lock, flags); > > diff --git a/drivers/gpu/drm/nouveau/nv50_display.c b/drivers/gpu/drm/nouveau/nv50_display.c > index a7663249b3ba..9303daa79aba 100644 > --- a/drivers/gpu/drm/nouveau/nv50_display.c > +++ b/drivers/gpu/drm/nouveau/nv50_display.c > @@ -1033,7 +1033,7 @@ nv50_wndw_reset(struct drm_plane *plane) > plane->funcs->atomic_destroy_state(plane, plane->state); > plane->state = &asyw->state; > plane->state->plane = plane; > - plane->state->rotation = DRM_ROTATE_0; > + plane->state->rotation = DRM_MODE_ROTATE_0; > } > > static void > diff --git a/drivers/gpu/drm/omapdrm/omap_drv.c b/drivers/gpu/drm/omapdrm/omap_drv.c > index e1f47f0b3ccf..663e930a7b0f 100644 > --- a/drivers/gpu/drm/omapdrm/omap_drv.c > +++ b/drivers/gpu/drm/omapdrm/omap_drv.c > @@ -577,7 +577,7 @@ static void dev_lastclose(struct drm_device *dev) > > drm_object_property_set_value(&crtc->base, > crtc->primary->rotation_property, > - DRM_ROTATE_0); > + DRM_MODE_ROTATE_0); > } > > for (i = 0; i < priv->num_planes; i++) { > @@ -588,7 +588,7 @@ static void dev_lastclose(struct drm_device *dev) > > drm_object_property_set_value(&plane->base, > plane->rotation_property, > - DRM_ROTATE_0); > + DRM_MODE_ROTATE_0); > } > > if (priv->fbdev) { > diff --git a/drivers/gpu/drm/omapdrm/omap_fb.c b/drivers/gpu/drm/omapdrm/omap_fb.c > index 29dc677dd4d3..5ca0537bb427 100644 > --- a/drivers/gpu/drm/omapdrm/omap_fb.c > +++ b/drivers/gpu/drm/omapdrm/omap_fb.c > @@ -167,30 +167,30 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb, > uint32_t w = win->src_w; > uint32_t h = win->src_h; > > - switch (win->rotation & DRM_ROTATE_MASK) { > + switch (win->rotation & DRM_MODE_ROTATE_MASK) { > default: > dev_err(fb->dev->dev, "invalid rotation: %02x", > (uint32_t)win->rotation); > /* fallthru to default to no rotation */ > case 0: > - case DRM_ROTATE_0: > + case DRM_MODE_ROTATE_0: > orient = 0; > break; > - case DRM_ROTATE_90: > + case DRM_MODE_ROTATE_90: > orient = MASK_XY_FLIP | MASK_X_INVERT; > break; > - case DRM_ROTATE_180: > + case DRM_MODE_ROTATE_180: > orient = MASK_X_INVERT | MASK_Y_INVERT; > break; > - case DRM_ROTATE_270: > + case DRM_MODE_ROTATE_270: > orient = MASK_XY_FLIP | MASK_Y_INVERT; > break; > } > > - if (win->rotation & DRM_REFLECT_X) > + if (win->rotation & DRM_MODE_REFLECT_X) > orient ^= MASK_X_INVERT; > > - if (win->rotation & DRM_REFLECT_Y) > + if (win->rotation & DRM_MODE_REFLECT_Y) > orient ^= MASK_Y_INVERT; > > /* adjust x,y offset for flip/invert: */ > @@ -205,9 +205,9 @@ void omap_framebuffer_update_scanout(struct drm_framebuffer *fb, > info->rotation_type = OMAP_DSS_ROT_TILER; > info->screen_width = omap_gem_tiled_stride(plane->bo, orient); > } else { > - switch (win->rotation & DRM_ROTATE_MASK) { > + switch (win->rotation & DRM_MODE_ROTATE_MASK) { > case 0: > - case DRM_ROTATE_0: > + case DRM_MODE_ROTATE_0: > /* OK */ > break; > > diff --git a/drivers/gpu/drm/omapdrm/omap_plane.c b/drivers/gpu/drm/omapdrm/omap_plane.c > index 9168154d749e..d3d6818c68f8 100644 > --- a/drivers/gpu/drm/omapdrm/omap_plane.c > +++ b/drivers/gpu/drm/omapdrm/omap_plane.c > @@ -141,7 +141,7 @@ static void omap_plane_atomic_disable(struct drm_plane *plane, > struct omap_plane_state *omap_state = to_omap_plane_state(plane->state); > struct omap_plane *omap_plane = to_omap_plane(plane); > > - plane->state->rotation = DRM_ROTATE_0; > + plane->state->rotation = DRM_MODE_ROTATE_0; > omap_state->zorder = plane->type == DRM_PLANE_TYPE_PRIMARY > ? 0 : omap_plane->id; > > @@ -177,7 +177,7 @@ static int omap_plane_atomic_check(struct drm_plane *plane, > if (state->crtc_y + state->crtc_h > crtc_state->adjusted_mode.vdisplay) > return -EINVAL; > > - if (state->rotation != DRM_ROTATE_0 && > + if (state->rotation != DRM_MODE_ROTATE_0 && > !omap_framebuffer_supports_rotation(state->fb)) > return -EINVAL; > > @@ -213,15 +213,15 @@ void omap_plane_install_properties(struct drm_plane *plane, > if (priv->has_dmm) { > if (!plane->rotation_property) > drm_plane_create_rotation_property(plane, > - DRM_ROTATE_0, > - DRM_ROTATE_0 | DRM_ROTATE_90 | > - DRM_ROTATE_180 | DRM_ROTATE_270 | > - DRM_REFLECT_X | DRM_REFLECT_Y); > + DRM_MODE_ROTATE_0, > + DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_90 | > + DRM_MODE_ROTATE_180 | DRM_MODE_ROTATE_270 | > + DRM_MODE_REFLECT_X | DRM_MODE_REFLECT_Y); > > /* Attach the rotation property also to the crtc object */ > if (plane->rotation_property && obj != &plane->base) > drm_object_attach_property(obj, plane->rotation_property, > - DRM_ROTATE_0); > + DRM_MODE_ROTATE_0); > } > > drm_object_attach_property(obj, priv->zorder_prop, 0); > @@ -273,7 +273,7 @@ static void omap_plane_reset(struct drm_plane *plane) > */ > omap_state->zorder = plane->type == DRM_PLANE_TYPE_PRIMARY > ? 0 : omap_plane->id; > - omap_state->base.rotation = DRM_ROTATE_0; > + omap_state->base.rotation = DRM_MODE_ROTATE_0; > > plane->state = &omap_state->base; > plane->state->plane = plane; > diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c > index ef9f3a2a4030..a8876b070168 100644 > --- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c > +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c > @@ -566,7 +566,7 @@ int vmw_du_primary_plane_atomic_check(struct drm_plane *plane, > > ret = drm_plane_helper_check_update(plane, state->crtc, new_fb, > &src, &dest, &clip, > - DRM_ROTATE_0, > + DRM_MODE_ROTATE_0, > DRM_PLANE_HELPER_NO_SCALING, > DRM_PLANE_HELPER_NO_SCALING, > false, true, &visible); > @@ -845,7 +845,7 @@ void vmw_du_plane_reset(struct drm_plane *plane) > > plane->state = &vps->base; > plane->state->plane = plane; > - plane->state->rotation = DRM_ROTATE_0; > + plane->state->rotation = DRM_MODE_ROTATE_0; > } > > > diff --git a/include/drm/drm_blend.h b/include/drm/drm_blend.h > index 13221cf9b3eb..340383810a37 100644 > --- a/include/drm/drm_blend.h > +++ b/include/drm/drm_blend.h > @@ -25,31 +25,14 @@ > > #include > #include > +#include > > struct drm_device; > struct drm_atomic_state; > > -/* > - * Rotation property bits. DRM_ROTATE_ rotates the image by the > - * specified amount in degrees in counter clockwise direction. DRM_REFLECT_X and > - * DRM_REFLECT_Y reflects the image along the specified axis prior to rotation > - * > - * WARNING: These defines are UABI since they're exposed in the rotation > - * property. > - */ > -#define DRM_ROTATE_0 BIT(0) > -#define DRM_ROTATE_90 BIT(1) > -#define DRM_ROTATE_180 BIT(2) > -#define DRM_ROTATE_270 BIT(3) > -#define DRM_ROTATE_MASK (DRM_ROTATE_0 | DRM_ROTATE_90 | \ > - DRM_ROTATE_180 | DRM_ROTATE_270) > -#define DRM_REFLECT_X BIT(4) > -#define DRM_REFLECT_Y BIT(5) > -#define DRM_REFLECT_MASK (DRM_REFLECT_X | DRM_REFLECT_Y) > - > static inline bool drm_rotation_90_or_270(unsigned int rotation) > { > - return rotation & (DRM_ROTATE_90 | DRM_ROTATE_270); > + return rotation & (DRM_MODE_ROTATE_90 | DRM_MODE_ROTATE_270); > } > > int drm_plane_create_rotation_property(struct drm_plane *plane, > diff --git a/include/uapi/drm/drm_mode.h b/include/uapi/drm/drm_mode.h > index 8c67fc03d53d..403339f98a92 100644 > --- a/include/uapi/drm/drm_mode.h > +++ b/include/uapi/drm/drm_mode.h > @@ -75,7 +75,7 @@ extern "C" { > * (define not exposed to user space). > */ > #define DRM_MODE_FLAG_3D_MASK (0x1f<<14) > -#define DRM_MODE_FLAG_3D_NONE (0<<14) > +#define DRM_MODE_FLAG_3D_NONE (0<<14) > #define DRM_MODE_FLAG_3D_FRAME_PACKING (1<<14) > #define DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE (2<<14) > #define DRM_MODE_FLAG_3D_LINE_ALTERNATIVE (3<<14) > @@ -127,6 +127,53 @@ extern "C" { > #define DRM_MODE_LINK_STATUS_GOOD 0 > #define DRM_MODE_LINK_STATUS_BAD 1 > > +/* > + * DRM_MODE_ROTATE_ > + * > + * Signals that a drm plane is been rotated degrees in counter > + * clockwise direction. > + * > + * This define is provided as a convenience, looking up the property id > + * using the name->prop id lookup is the preferred method. > + */ > +#define DRM_MODE_ROTATE_0 (1<<0) > +#define DRM_MODE_ROTATE_90 (1<<1) > +#define DRM_MODE_ROTATE_180 (1<<2) > +#define DRM_MODE_ROTATE_270 (1<<3) > + > +/* > + * DRM_MODE_ROTATE_MASK > + * > + * Bitmask used to look for drm plane rotations. > + */ > +#define DRM_MODE_ROTATE_MASK (\ > + DRM_MODE_ROTATE_0 | \ > + DRM_MODE_ROTATE_90 | \ > + DRM_MODE_ROTATE_180 | \ > + DRM_MODE_ROTATE_270) > + > +/* > + * DRM_MODE_REFLECT_ > + * > + * Signals that the contents of a drm plane is reflected in the axis, > + * in the same way as mirroring. That's not what I was after. We're still missing the information about the order in which reflection and rotation happens. Also does "in the axis" mean the same thing as "along the axis" and not "across the axis"? /me thinks the old text was better > + * > + * This define is provided as a convenience, looking up the property id > + * using the name->prop id lookup is the preferred method. > + */ > +#define DRM_MODE_REFLECT_X (1<<4) > +#define DRM_MODE_REFLECT_Y (1<<5) > + > +/* > + * DRM_MODE_REFLECT_MASK > + * > + * Bitmask used to look for drm plane reflections. > + */ > +#define DRM_MODE_REFLECT_MASK (\ > + DRM_MODE_REFLECT_X | \ > + DRM_MODE_REFLECT_Y) > + > + > struct drm_mode_modeinfo { > __u32 clock; > __u16 hdisplay; > -- > 2.11.0.453.g787f75f05 -- Ville Syrjälä Intel OTC