From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH 1/3] drm/radeon: Cleanup display interrupt handling for evergreen, si Date: Tue, 16 May 2017 17:11:58 -0400 Message-ID: <20170516211202.20325-2-lyude@redhat.com> References: <20170516211202.20325-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170516211202.20325-1-lyude-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Cc: Lyude , David Airlie , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Alex Deucher , =?UTF-8?q?Christian=20K=C3=B6nig?= VGhlIGN1cnJlbnQgY29kZSBoZXJlIGlzIHJlYWxseSwgcmVhbGx5IGJhZC4gQSBodWdlIGFtb3Vu dCBvZiBpdCBsb29rcwp0byBiZSBjb3B5IHBhc3RlZCwgaXQgaGFzIHNvbWUgd2VpcmQgaGF0cmVk IG9mIGFycmF5cyBhbmQgY29kZSBzaGFyaW5nLApzd2l0Y2ggY2FzZXMgZXZlcnl3aGVyZSBmb3Ig dGhpbmdzIHRoYXQgcmVhbGx5IGRvbid0IG5lZWQgdGhlbSwgYW5kIGl0Cm1ha2VzIHRoZSBmaWxl IHNlZW0gaW1tZW5zZWx5IG1vcmUgY29tcGxleCB0aGVuIGl0IGFjdHVhbGx5IGlzLiBUaGlzIGlz CmEgcGFpbiBmb3IgbWFpbnRhbmVuY2UsIGFuZCBpcyB2dWxuZXJhYmxlIHRvIG1vcmUgd2VpcmQg aXJxIGhhbmRsaW5nCmJ1Z3MuCgpTbywgbGV0J3Mgc3RhcnQgY2xlYW5pbmcgdGhpcyB1cCBhIGJp dC4gTW9kaWZ5IGFsbCBvZiB0aGUgSVJRIGhhbmRsZXJzCmZvciBldmVyZ3JlZW4vc2kgc28gdGhh dCB0aGV5IGp1c3QgdXNlIGZvciBsb29wcy4gQXMgd2VsbCwgd2UgYWRkIGEKaGVscGVyIGZ1bmN0 aW9uIHJhZGVvbl9pcnFfa21zX3NldF9pcnFfbl9lbmFibGVkKCksIHdob3NlIHB1cnBvc2UgaXMK anVzdCB0byB1cGRhdGUgdGhlIHN0YXRlIG9mIHJlZ2lzdGVycyB0aGF0IGVuYWJsZS9kaXNhYmxl IGludGVycnVwdHMKd2hpbGUgcHJpbnRpbmcgYW55IGNoYW5nZXMgdG8gdGhlIHNldCBvZiBlbmFi bGVkIGludGVycnVwdHMgdG8gdGhlCmtlcm5lbCBsb2cuCgpUaGVyZSBpcyBvbmUgY2hhbmdlIGhl cmUgdGhhdCBkb2Vzbid0IGxvb2sgdmVyeSBpbXBvcnRhbnQgKHRlc3RpbmcKaGFzbid0IHNob3du IHRoYXQgaXQgY2hhbmdlcyBhbnl5dGhpbmcgYWZhaWN0KSwgYnV0IHNob3VsZCBiZSBub3RlZCBp bgpjYXNlIHRoaXMgcGF0Y2ggYnJlYWtzIHNvbWV0aGluZy4gVGhlIHdheSB0aGUgY29kZSBvcmln aW5hbGx5IGhhbmRsZWQKZW5hYmxpbmcgb3IgYWNraW5nIElSUXMgd2VudCBsaWtlIHRoaXM6Cgog LSBDaGVjayBlbmFibGUvaW50ZXJydXB0IHN0YXR1cyBvZiBhbGwgSVJRcwogLSBXcml0ZSBiYWNr IGFueSBhY2tub3dsZWRnZW1lbnRzLCBlbmFibGVtZW50cywgb3IgZGlzYWJsZW1lbnRzIHRvCiAg IElSUXMsIGFsbCBhdCB0aGUgc2FtZSB0aW1lCgpCdXQgbm93IHdpdGggdGhlIGhlbHBlcnMgd2Un dmUgaW1wbGVtZW50ZWQsIGl0IGdvZXMgYSBsaXR0bGUgbW9yZSBsaWtlCnRoaXMKIC0gRm9yIGVh Y2ggSVJROgogICAtIENoZWNrIGVuYWJsZS9pbnRlcnJ1cHQgc3RhdHVzCiAgIC0gV3JpdGUgYmFj ayBhY2svbmV3IHN0YXR1cwoKU2lnbmVkLW9mZi1ieTogTHl1ZGUgPGx5dWRlQHJlZGhhdC5jb20+ Ci0tLQogZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW4uYyAgICAgIHwgNjk5ICsrKysr Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJn cmVlbmQuaCAgICAgfCAgNzQgKy0tLQogZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaCAg ICAgICAgIHwgIDEzICstCiBkcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMg fCAgMzUgKysKIGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2kuYyAgICAgICAgICAgICB8IDU2NSAr KysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaWQuaCAg ICAgICAgICAgIHwgIDcyICstLS0KIDYgZmlsZXMgY2hhbmdlZCwgMjkwIGluc2VydGlvbnMoKyks IDExNjggZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9l dmVyZ3JlZW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdyZWVuLmMKaW5kZXggMGJm MTAzNS4uMzViYWYwYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3Jl ZW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbi5jCkBAIC0xNzE0LDM4 ICsxNzE0LDEwIEBAIHZvaWQgZXZlcmdyZWVuX3BtX2ZpbmlzaChzdHJ1Y3QgcmFkZW9uX2Rldmlj ZSAqcmRldikKICAqLwogYm9vbCBldmVyZ3JlZW5faHBkX3NlbnNlKHN0cnVjdCByYWRlb25fZGV2 aWNlICpyZGV2LCBlbnVtIHJhZGVvbl9ocGRfaWQgaHBkKQogewotCWJvb2wgY29ubmVjdGVkID0g ZmFsc2U7Ci0KLQlzd2l0Y2ggKGhwZCkgewotCWNhc2UgUkFERU9OX0hQRF8xOgotCQlpZiAoUlJF RzMyKERDX0hQRDFfSU5UX1NUQVRVUykgJiBEQ19IUER4X1NFTlNFKQotCQkJY29ubmVjdGVkID0g dHJ1ZTsKLQkJYnJlYWs7Ci0JY2FzZSBSQURFT05fSFBEXzI6Ci0JCWlmIChSUkVHMzIoRENfSFBE Ml9JTlRfU1RBVFVTKSAmIERDX0hQRHhfU0VOU0UpCi0JCQljb25uZWN0ZWQgPSB0cnVlOwotCQli cmVhazsKLQljYXNlIFJBREVPTl9IUERfMzoKLQkJaWYgKFJSRUczMihEQ19IUEQzX0lOVF9TVEFU VVMpICYgRENfSFBEeF9TRU5TRSkKLQkJCWNvbm5lY3RlZCA9IHRydWU7Ci0JCWJyZWFrOwotCWNh c2UgUkFERU9OX0hQRF80OgotCQlpZiAoUlJFRzMyKERDX0hQRDRfSU5UX1NUQVRVUykgJiBEQ19I UER4X1NFTlNFKQotCQkJY29ubmVjdGVkID0gdHJ1ZTsKLQkJYnJlYWs7Ci0JY2FzZSBSQURFT05f SFBEXzU6Ci0JCWlmIChSUkVHMzIoRENfSFBENV9JTlRfU1RBVFVTKSAmIERDX0hQRHhfU0VOU0Up Ci0JCQljb25uZWN0ZWQgPSB0cnVlOwotCQlicmVhazsKLQljYXNlIFJBREVPTl9IUERfNjoKLQkJ aWYgKFJSRUczMihEQ19IUEQ2X0lOVF9TVEFUVVMpICYgRENfSFBEeF9TRU5TRSkKLQkJCWNvbm5l Y3RlZCA9IHRydWU7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0JCWJyZWFrOwotCX0KKwlpZiAoaHBk ID09IFJBREVPTl9IUERfTk9ORSkKKwkJcmV0dXJuIGZhbHNlOwogCi0JcmV0dXJuIGNvbm5lY3Rl ZDsKKwlyZXR1cm4gISEoUlJFRzMyKERDX0hQRHhfSU5UX1NUQVRVUyhocGQpKSAmIERDX0hQRHhf U0VOU0UpOwogfQogCiAvKioKQEAgLTE3NTksNjEgKzE3MzEsMTUgQEAgYm9vbCBldmVyZ3JlZW5f aHBkX3NlbnNlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCBlbnVtIHJhZGVvbl9ocGRfaWQg aHBkKQogdm9pZCBldmVyZ3JlZW5faHBkX3NldF9wb2xhcml0eShzdHJ1Y3QgcmFkZW9uX2Rldmlj ZSAqcmRldiwKIAkJCQllbnVtIHJhZGVvbl9ocGRfaWQgaHBkKQogewotCXUzMiB0bXA7CiAJYm9v bCBjb25uZWN0ZWQgPSBldmVyZ3JlZW5faHBkX3NlbnNlKHJkZXYsIGhwZCk7CiAKLQlzd2l0Y2gg KGhwZCkgewotCWNhc2UgUkFERU9OX0hQRF8xOgotCQl0bXAgPSBSUkVHMzIoRENfSFBEMV9JTlRf Q09OVFJPTCk7Ci0JCWlmIChjb25uZWN0ZWQpCi0JCQl0bXAgJj0gfkRDX0hQRHhfSU5UX1BPTEFS SVRZOwotCQllbHNlCi0JCQl0bXAgfD0gRENfSFBEeF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihE Q19IUEQxX0lOVF9DT05UUk9MLCB0bXApOwotCQlicmVhazsKLQljYXNlIFJBREVPTl9IUERfMjoK LQkJdG1wID0gUlJFRzMyKERDX0hQRDJfSU5UX0NPTlRST0wpOwotCQlpZiAoY29ubmVjdGVkKQot CQkJdG1wICY9IH5EQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJZWxzZQotCQkJdG1wIHw9IERDX0hQ RHhfSU5UX1BPTEFSSVRZOwotCQlXUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJPTCwgdG1wKTsKLQkJ YnJlYWs7Ci0JY2FzZSBSQURFT05fSFBEXzM6Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQzX0lOVF9D T05UUk9MKTsKLQkJaWYgKGNvbm5lY3RlZCkKLQkJCXRtcCAmPSB+RENfSFBEeF9JTlRfUE9MQVJJ VFk7Ci0JCWVsc2UKLQkJCXRtcCB8PSBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJV1JFRzMyKERD X0hQRDNfSU5UX0NPTlRST0wsIHRtcCk7Ci0JCWJyZWFrOwotCWNhc2UgUkFERU9OX0hQRF80Ogot CQl0bXAgPSBSUkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCk7Ci0JCWlmIChjb25uZWN0ZWQpCi0J CQl0bXAgJj0gfkRDX0hQRHhfSU5UX1BPTEFSSVRZOwotCQllbHNlCi0JCQl0bXAgfD0gRENfSFBE eF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9MLCB0bXApOwotCQli cmVhazsKLQljYXNlIFJBREVPTl9IUERfNToKLQkJdG1wID0gUlJFRzMyKERDX0hQRDVfSU5UX0NP TlRST0wpOwotCQlpZiAoY29ubmVjdGVkKQotCQkJdG1wICY9IH5EQ19IUER4X0lOVF9QT0xBUklU WTsKLQkJZWxzZQotCQkJdG1wIHw9IERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCQlXUkVHMzIoRENf SFBENV9JTlRfQ09OVFJPTCwgdG1wKTsKLQkJCWJyZWFrOwotCWNhc2UgUkFERU9OX0hQRF82Ogot CQl0bXAgPSBSUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCk7Ci0JCWlmIChjb25uZWN0ZWQpCi0J CQl0bXAgJj0gfkRDX0hQRHhfSU5UX1BPTEFSSVRZOwotCQllbHNlCi0JCQl0bXAgfD0gRENfSFBE eF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MLCB0bXApOwotCQli cmVhazsKLQlkZWZhdWx0OgotCQlicmVhazsKLQl9CisJaWYgKGhwZCA9PSBSQURFT05fSFBEX05P TkUpCisJCXJldHVybjsKKworCWlmIChjb25uZWN0ZWQpCisJCVdSRUczMl9BTkQoRENfSFBEeF9J TlRfQ09OVFJPTChocGQpLCB+RENfSFBEeF9JTlRfUE9MQVJJVFkpOworCWVsc2UKKwkJV1JFRzMy X09SKERDX0hQRHhfSU5UX0NPTlRST0woaHBkKSwgRENfSFBEeF9JTlRfUE9MQVJJVFkpOwogfQog CiAvKioKQEAgLTE4MzMsNyArMTc1OSw4IEBAIHZvaWQgZXZlcmdyZWVuX2hwZF9pbml0KHN0cnVj dCByYWRlb25fZGV2aWNlICpyZGV2KQogCQlEQ19IUER4X1JYX0lOVF9USU1FUigweGZhKSB8IERD X0hQRHhfRU47CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGNvbm5lY3RvciwgJmRldi0+bW9kZV9j b25maWcuY29ubmVjdG9yX2xpc3QsIGhlYWQpIHsKLQkJc3RydWN0IHJhZGVvbl9jb25uZWN0b3Ig KnJhZGVvbl9jb25uZWN0b3IgPSB0b19yYWRlb25fY29ubmVjdG9yKGNvbm5lY3Rvcik7CisJCWVu dW0gcmFkZW9uX2hwZF9pZCBocGQgPQorCQkJdG9fcmFkZW9uX2Nvbm5lY3Rvcihjb25uZWN0b3Ip LT5ocGQuaHBkOwogCiAJCWlmIChjb25uZWN0b3ItPmNvbm5lY3Rvcl90eXBlID09IERSTV9NT0RF X0NPTk5FQ1RPUl9lRFAgfHwKIAkJICAgIGNvbm5lY3Rvci0+Y29ubmVjdG9yX3R5cGUgPT0gRFJN X01PREVfQ09OTkVDVE9SX0xWRFMpIHsKQEAgLTE4NDQsMzEgKzE3NzEsMTQgQEAgdm9pZCBldmVy Z3JlZW5faHBkX2luaXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJCQkgKi8KIAkJCWNv bnRpbnVlOwogCQl9Ci0JCXN3aXRjaCAocmFkZW9uX2Nvbm5lY3Rvci0+aHBkLmhwZCkgewotCQlj YXNlIFJBREVPTl9IUERfMToKLQkJCVdSRUczMihEQ19IUEQxX0NPTlRST0wsIHRtcCk7Ci0JCQli cmVhazsKLQkJY2FzZSBSQURFT05fSFBEXzI6Ci0JCQlXUkVHMzIoRENfSFBEMl9DT05UUk9MLCB0 bXApOwotCQkJYnJlYWs7Ci0JCWNhc2UgUkFERU9OX0hQRF8zOgotCQkJV1JFRzMyKERDX0hQRDNf Q09OVFJPTCwgdG1wKTsKLQkJCWJyZWFrOwotCQljYXNlIFJBREVPTl9IUERfNDoKLQkJCVdSRUcz MihEQ19IUEQ0X0NPTlRST0wsIHRtcCk7Ci0JCQlicmVhazsKLQkJY2FzZSBSQURFT05fSFBEXzU6 Ci0JCQlXUkVHMzIoRENfSFBENV9DT05UUk9MLCB0bXApOwotCQkJYnJlYWs7Ci0JCWNhc2UgUkFE RU9OX0hQRF82OgotCQkJV1JFRzMyKERDX0hQRDZfQ09OVFJPTCwgdG1wKTsKLQkJCWJyZWFrOwot CQlkZWZhdWx0OgotCQkJYnJlYWs7Ci0JCX0KLQkJcmFkZW9uX2hwZF9zZXRfcG9sYXJpdHkocmRl diwgcmFkZW9uX2Nvbm5lY3Rvci0+aHBkLmhwZCk7Ci0JCWlmIChyYWRlb25fY29ubmVjdG9yLT5o cGQuaHBkICE9IFJBREVPTl9IUERfTk9ORSkKLQkJCWVuYWJsZWQgfD0gMSA8PCByYWRlb25fY29u bmVjdG9yLT5ocGQuaHBkOworCisJCWlmIChocGQgPT0gUkFERU9OX0hQRF9OT05FKQorCQkJY29u dGludWU7CisKKwkJV1JFRzMyKERDX0hQRHhfQ09OVFJPTChocGQpLCB0bXApOworCQllbmFibGVk IHw9IDEgPDwgaHBkOworCisJCXJhZGVvbl9ocGRfc2V0X3BvbGFyaXR5KHJkZXYsIGhwZCk7CiAJ fQogCXJhZGVvbl9pcnFfa21zX2VuYWJsZV9ocGQocmRldiwgZW5hYmxlZCk7CiB9CkBAIC0xODg4 LDMxICsxNzk4LDE0IEBAIHZvaWQgZXZlcmdyZWVuX2hwZF9maW5pKHN0cnVjdCByYWRlb25fZGV2 aWNlICpyZGV2KQogCXVuc2lnbmVkIGRpc2FibGVkID0gMDsKIAogCWxpc3RfZm9yX2VhY2hfZW50 cnkoY29ubmVjdG9yLCAmZGV2LT5tb2RlX2NvbmZpZy5jb25uZWN0b3JfbGlzdCwgaGVhZCkgewot CQlzdHJ1Y3QgcmFkZW9uX2Nvbm5lY3RvciAqcmFkZW9uX2Nvbm5lY3RvciA9IHRvX3JhZGVvbl9j b25uZWN0b3IoY29ubmVjdG9yKTsKLQkJc3dpdGNoIChyYWRlb25fY29ubmVjdG9yLT5ocGQuaHBk KSB7Ci0JCWNhc2UgUkFERU9OX0hQRF8xOgotCQkJV1JFRzMyKERDX0hQRDFfQ09OVFJPTCwgMCk7 Ci0JCQlicmVhazsKLQkJY2FzZSBSQURFT05fSFBEXzI6Ci0JCQlXUkVHMzIoRENfSFBEMl9DT05U Uk9MLCAwKTsKLQkJCWJyZWFrOwotCQljYXNlIFJBREVPTl9IUERfMzoKLQkJCVdSRUczMihEQ19I UEQzX0NPTlRST0wsIDApOwotCQkJYnJlYWs7Ci0JCWNhc2UgUkFERU9OX0hQRF80OgotCQkJV1JF RzMyKERDX0hQRDRfQ09OVFJPTCwgMCk7Ci0JCQlicmVhazsKLQkJY2FzZSBSQURFT05fSFBEXzU6 Ci0JCQlXUkVHMzIoRENfSFBENV9DT05UUk9MLCAwKTsKLQkJCWJyZWFrOwotCQljYXNlIFJBREVP Tl9IUERfNjoKLQkJCVdSRUczMihEQ19IUEQ2X0NPTlRST0wsIDApOwotCQkJYnJlYWs7Ci0JCWRl ZmF1bHQ6Ci0JCQlicmVhazsKLQkJfQotCQlpZiAocmFkZW9uX2Nvbm5lY3Rvci0+aHBkLmhwZCAh PSBSQURFT05fSFBEX05PTkUpCi0JCQlkaXNhYmxlZCB8PSAxIDw8IHJhZGVvbl9jb25uZWN0b3It PmhwZC5ocGQ7CisJCWVudW0gcmFkZW9uX2hwZF9pZCBocGQgPQorCQkJdG9fcmFkZW9uX2Nvbm5l Y3Rvcihjb25uZWN0b3IpLT5ocGQuaHBkOworCisJCWlmIChocGQgPT0gUkFERU9OX0hQRF9OT05F KQorCQkJY29udGludWU7CisKKwkJV1JFRzMyKERDX0hQRHhfQ09OVFJPTChocGQpLCAwKTsKKwkJ ZGlzYWJsZWQgfD0gMSA8PCBocGQ7CiAJfQogCXJhZGVvbl9pcnFfa21zX2Rpc2FibGVfaHBkKHJk ZXYsIGRpc2FibGVkKTsKIH0KQEAgLTQ1NDMsNiArNDQzNiw3IEBAIHUzMiBldmVyZ3JlZW5fZ2V0 X3ZibGFua19jb3VudGVyKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LCBpbnQgY3J0YykKIAog dm9pZCBldmVyZ3JlZW5fZGlzYWJsZV9pbnRlcnJ1cHRfc3RhdGUoc3RydWN0IHJhZGVvbl9kZXZp Y2UgKnJkZXYpCiB7CisJaW50IGk7CiAJdTMyIHRtcDsKIAogCWlmIChyZGV2LT5mYW1pbHkgPj0g Q0hJUF9DQVlNQU4pIHsKQEAgLTQ1NTgsMTYgKzQ0NTIsOCBAQCB2b2lkIGV2ZXJncmVlbl9kaXNh YmxlX2ludGVycnVwdF9zdGF0ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAlXUkVHMzIo RE1BX0NOVEwsIHRtcCk7CiAJV1JFRzMyKEdSQk1fSU5UX0NOVEwsIDApOwogCVdSRUczMihTUkJN X0lOVF9DTlRMLCAwKTsKLQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNU RVJfT0ZGU0VULCAwKTsKLQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNU RVJfT0ZGU0VULCAwKTsKLQlpZiAocmRldi0+bnVtX2NydGMgPj0gNCkgewotCQlXUkVHMzIoSU5U X01BU0sgKyBFVkVSR1JFRU5fQ1JUQzJfUkVHSVNURVJfT0ZGU0VULCAwKTsKLQkJV1JFRzMyKElO VF9NQVNLICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0JfQotCWlmIChy ZGV2LT5udW1fY3J0YyA+PSA2KSB7Ci0JCVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVFTl9DUlRD NF9SRUdJU1RFUl9PRkZTRVQsIDApOwotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JU QzVfUkVHSVNURVJfT0ZGU0VULCAwKTsKLQl9CisJZm9yIChpID0gMDsgaSA8IHJkZXYtPm51bV9j cnRjOyBpKyspCisJCVdSRUczMihJTlRfTUFTSyArIGNydGNfb2Zmc2V0c1tpXSwgMCk7CiAKIAlX UkVHMzIoR1JQSF9JTlRfQ09OVFJPTCArIEVWRVJHUkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQs IDApOwogCVdSRUczMihHUlBIX0lOVF9DT05UUk9MICsgRVZFUkdSRUVOX0NSVEMxX1JFR0lTVEVS X09GRlNFVCwgMCk7CkBAIC00NTg1LDI3ICs0NDcxLDE1IEBAIHZvaWQgZXZlcmdyZWVuX2Rpc2Fi bGVfaW50ZXJydXB0X3N0YXRlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCQlXUkVHMzIo REFDQV9BVVRPREVURUNUX0lOVF9DT05UUk9MLCAwKTsKIAlXUkVHMzIoREFDQl9BVVRPREVURUNU X0lOVF9DT05UUk9MLCAwKTsKIAotCXRtcCA9IFJSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MKSAm IERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCVdSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MLCB0bXAp OwotCXRtcCA9IFJSRUczMihEQ19IUEQyX0lOVF9DT05UUk9MKSAmIERDX0hQRHhfSU5UX1BPTEFS SVRZOwotCVdSRUczMihEQ19IUEQyX0lOVF9DT05UUk9MLCB0bXApOwotCXRtcCA9IFJSRUczMihE Q19IUEQzX0lOVF9DT05UUk9MKSAmIERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCVdSRUczMihEQ19I UEQzX0lOVF9DT05UUk9MLCB0bXApOwotCXRtcCA9IFJSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9M KSAmIERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCVdSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9MLCB0 bXApOwotCXRtcCA9IFJSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MKSAmIERDX0hQRHhfSU5UX1BP TEFSSVRZOwotCVdSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MLCB0bXApOwotCXRtcCA9IFJSRUcz MihEQ19IUEQ2X0lOVF9DT05UUk9MKSAmIERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCVdSRUczMihE Q19IUEQ2X0lOVF9DT05UUk9MLCB0bXApOwotCisJZm9yIChpID0gMDsgaSA8IEVWRVJHUkVFTl9N QVhfRElTUF9SRUdJU1RFUlM7IGkrKykKKwkJV1JFRzMyX0FORChEQ19IUER4X0lOVF9DT05UUk9M KGkpLCBEQ19IUER4X0lOVF9QT0xBUklUWSk7CiB9CiAKIGludCBldmVyZ3JlZW5faXJxX3NldChz dHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsKKwlpbnQgaTsKIAl1MzIgY3BfaW50X2NudGwg PSBDTlRYX0JVU1lfSU5UX0VOQUJMRSB8IENOVFhfRU1QVFlfSU5UX0VOQUJMRTsKIAl1MzIgY3Bf aW50X2NudGwxID0gMCwgY3BfaW50X2NudGwyID0gMDsKLQl1MzIgY3J0YzEgPSAwLCBjcnRjMiA9 IDAsIGNydGMzID0gMCwgY3J0YzQgPSAwLCBjcnRjNSA9IDAsIGNydGM2ID0gMDsKLQl1MzIgaHBk MSwgaHBkMiwgaHBkMywgaHBkNCwgaHBkNSwgaHBkNjsKIAl1MzIgZ3JibV9pbnRfY250bCA9IDA7 CiAJdTMyIGFmbXQxID0gMCwgYWZtdDIgPSAwLCBhZm10MyA9IDAsIGFmbXQ0ID0gMCwgYWZtdDUg PSAwLCBhZm10NiA9IDA7CiAJdTMyIGRtYV9jbnRsLCBkbWFfY250bDEgPSAwOwpAQCAtNDYyMywx MiArNDQ5Nyw2IEBAIGludCBldmVyZ3JlZW5faXJxX3NldChzdHJ1Y3QgcmFkZW9uX2RldmljZSAq cmRldikKIAkJcmV0dXJuIDA7CiAJfQogCi0JaHBkMSA9IFJSRUczMihEQ19IUEQxX0lOVF9DT05U Uk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7Ci0JaHBkMiA9IFJS RUczMihEQ19IUEQyX0lOVF9DT05UUk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JY X0lOVF9FTik7Ci0JaHBkMyA9IFJSRUczMihEQ19IUEQzX0lOVF9DT05UUk9MKSAmIH4oRENfSFBE eF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7Ci0JaHBkNCA9IFJSRUczMihEQ19IUEQ0X0lO VF9DT05UUk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7Ci0JaHBk NSA9IFJSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19I UER4X1JYX0lOVF9FTik7Ci0JaHBkNiA9IFJSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MKSAmIH4o RENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7CiAJaWYgKHJkZXYtPmZhbWlseSA9 PSBDSElQX0FSVUJBKQogCQl0aGVybWFsX2ludCA9IFJSRUczMihUTl9DR19USEVSTUFMX0lOVF9D VFJMKSAmCiAJCQl+KFRIRVJNX0lOVF9NQVNLX0hJR0ggfCBUSEVSTV9JTlRfTUFTS19MT1cpOwpA QCAtNDY4NSw2MCArNDU1Myw2IEBAIGludCBldmVyZ3JlZW5faXJxX3NldChzdHJ1Y3QgcmFkZW9u X2RldmljZSAqcmRldikKIAkJdGhlcm1hbF9pbnQgfD0gVEhFUk1fSU5UX01BU0tfSElHSCB8IFRI RVJNX0lOVF9NQVNLX0xPVzsKIAl9CiAKLQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsw XSB8fAotCSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzBdKSkgewotCQlEUk1fREVC VUcoImV2ZXJncmVlbl9pcnFfc2V0OiB2YmxhbmsgMFxuIik7Ci0JCWNydGMxIHw9IFZCTEFOS19J TlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbMV0gfHwKLQkgICAg YXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFsxXSkpIHsKLQkJRFJNX0RFQlVHKCJldmVyZ3Jl ZW5faXJxX3NldDogdmJsYW5rIDFcbiIpOwotCQljcnRjMiB8PSBWQkxBTktfSU5UX01BU0s7Ci0J fQotCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzJdIHx8Ci0JICAgIGF0b21pY19yZWFk KCZyZGV2LT5pcnEucGZsaXBbMl0pKSB7Ci0JCURSTV9ERUJVRygiZXZlcmdyZWVuX2lycV9zZXQ6 IHZibGFuayAyXG4iKTsKLQkJY3J0YzMgfD0gVkJMQU5LX0lOVF9NQVNLOwotCX0KLQlpZiAocmRl di0+aXJxLmNydGNfdmJsYW5rX2ludFszXSB8fAotCSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJx LnBmbGlwWzNdKSkgewotCQlEUk1fREVCVUcoImV2ZXJncmVlbl9pcnFfc2V0OiB2YmxhbmsgM1xu Iik7Ci0JCWNydGM0IHw9IFZCTEFOS19JTlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRj X3ZibGFua19pbnRbNF0gfHwKLQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFs0XSkp IHsKLQkJRFJNX0RFQlVHKCJldmVyZ3JlZW5faXJxX3NldDogdmJsYW5rIDRcbiIpOwotCQljcnRj NSB8PSBWQkxBTktfSU5UX01BU0s7Ci0JfQotCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50 WzVdIHx8Ci0JICAgIGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBbNV0pKSB7Ci0JCURSTV9E RUJVRygiZXZlcmdyZWVuX2lycV9zZXQ6IHZibGFuayA1XG4iKTsKLQkJY3J0YzYgfD0gVkJMQU5L X0lOVF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmhwZFswXSkgewotCQlEUk1fREVCVUcoImV2 ZXJncmVlbl9pcnFfc2V0OiBocGQgMVxuIik7Ci0JCWhwZDEgfD0gRENfSFBEeF9JTlRfRU4gfCBE Q19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYtPmlycS5ocGRbMV0pIHsKLQkJRFJNX0RF QlVHKCJldmVyZ3JlZW5faXJxX3NldDogaHBkIDJcbiIpOwotCQlocGQyIHw9IERDX0hQRHhfSU5U X0VOIHwgRENfSFBEeF9SWF9JTlRfRU47Ci0JfQotCWlmIChyZGV2LT5pcnEuaHBkWzJdKSB7Ci0J CURSTV9ERUJVRygiZXZlcmdyZWVuX2lycV9zZXQ6IGhwZCAzXG4iKTsKLQkJaHBkMyB8PSBEQ19I UER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhwZFsz XSkgewotCQlEUk1fREVCVUcoImV2ZXJncmVlbl9pcnFfc2V0OiBocGQgNFxuIik7Ci0JCWhwZDQg fD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYtPmly cS5ocGRbNF0pIHsKLQkJRFJNX0RFQlVHKCJldmVyZ3JlZW5faXJxX3NldDogaHBkIDVcbiIpOwot CQlocGQ1IHw9IERDX0hQRHhfSU5UX0VOIHwgRENfSFBEeF9SWF9JTlRfRU47Ci0JfQotCWlmIChy ZGV2LT5pcnEuaHBkWzVdKSB7Ci0JCURSTV9ERUJVRygiZXZlcmdyZWVuX2lycV9zZXQ6IGhwZCA2 XG4iKTsKLQkJaHBkNiB8PSBEQ19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0K IAlpZiAocmRldi0+aXJxLmFmbXRbMF0pIHsKIAkJRFJNX0RFQlVHKCJldmVyZ3JlZW5faXJxX3Nl dDogaGRtaSAwXG4iKTsKIAkJYWZtdDEgfD0gQUZNVF9BWl9GT1JNQVRfV1RSSUdfTUFTSzsKQEAg LTQ3NzgsMTcgKzQ1OTIsNiBAQCBpbnQgZXZlcmdyZWVuX2lycV9zZXQoc3RydWN0IHJhZGVvbl9k ZXZpY2UgKnJkZXYpCiAKIAlXUkVHMzIoR1JCTV9JTlRfQ05UTCwgZ3JibV9pbnRfY250bCk7CiAK LQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBjcnRj MSk7Ci0JV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMxX1JFR0lTVEVSX09GRlNFVCwg Y3J0YzIpOwotCWlmIChyZGV2LT5udW1fY3J0YyA+PSA0KSB7Ci0JCVdSRUczMihJTlRfTUFTSyAr IEVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIGNydGMzKTsKLQkJV1JFRzMyKElOVF9N QVNLICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgY3J0YzQpOwotCX0KLQlpZiAo cmRldi0+bnVtX2NydGMgPj0gNikgewotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JU QzRfUkVHSVNURVJfT0ZGU0VULCBjcnRjNSk7Ci0JCVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVF Tl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIGNydGM2KTsKLQl9Ci0KIAlXUkVHMzIoR1JQSF9JTlRf Q09OVFJPTCArIEVWRVJHUkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQsCiAJICAgICAgIEdSUEhf UEZMSVBfSU5UX01BU0spOwogCVdSRUczMihHUlBIX0lOVF9DT05UUk9MICsgRVZFUkdSRUVOX0NS VEMxX1JFR0lTVEVSX09GRlNFVCwKQEAgLTQ4MDYsMTIgKzQ2MDksMjEgQEAgaW50IGV2ZXJncmVl bl9pcnFfc2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCQkgICAgICAgR1JQSF9QRkxJ UF9JTlRfTUFTSyk7CiAJfQogCi0JV1JFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wsIGhwZDEpOwot CVdSRUczMihEQ19IUEQyX0lOVF9DT05UUk9MLCBocGQyKTsKLQlXUkVHMzIoRENfSFBEM19JTlRf Q09OVFJPTCwgaHBkMyk7Ci0JV1JFRzMyKERDX0hQRDRfSU5UX0NPTlRST0wsIGhwZDQpOwotCVdS RUczMihEQ19IUEQ1X0lOVF9DT05UUk9MLCBocGQ1KTsKLQlXUkVHMzIoRENfSFBENl9JTlRfQ09O VFJPTCwgaHBkNik7CisJZm9yIChpID0gMDsgaSA8IEVWRVJHUkVFTl9NQVhfRElTUF9SRUdJU1RF UlM7IGkrKykgeworCQlyYWRlb25faXJxX2ttc19zZXRfaXJxX25fZW5hYmxlZChyZGV2LAorCQkJ CQkJIERDX0hQRHhfSU5UX0NPTlRST0woaSksCisJCQkJCQkgRENfSFBEeF9JTlRfRU4gfAorCQkJ CQkJIERDX0hQRHhfUlhfSU5UX0VOLAorCQkJCQkJIHJkZXYtPmlycS5ocGRbaV0sICJIUEQiLCBp KTsKKworCQlpZiAoaSA8IHJkZXYtPm51bV9jcnRjKSB7CisJCQlyYWRlb25faXJxX2ttc19zZXRf aXJxX25fZW5hYmxlZCgKKwkJCSAgICByZGV2LCBJTlRfTUFTSyArIGNydGNfb2Zmc2V0c1tpXSwg VkJMQU5LX0lOVF9NQVNLLAorCQkJICAgIHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbaV0gfHwK KwkJCSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwW2ldKSwgInZibGFuayIsIGkpOwor CQl9CisJfQorCiAJaWYgKHJkZXYtPmZhbWlseSA9PSBDSElQX0FSVUJBKQogCQlXUkVHMzIoVE5f Q0dfVEhFUk1BTF9JTlRfQ1RSTCwgdGhlcm1hbF9pbnQpOwogCWVsc2UKQEAgLTQ4MzIsMTQgKzQ2 NDQsMjggQEAgaW50IGV2ZXJncmVlbl9pcnFfc2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2 KQogCiBzdGF0aWMgdm9pZCBldmVyZ3JlZW5faXJxX2FjayhzdHJ1Y3QgcmFkZW9uX2RldmljZSAq cmRldikKIHsKKwlpbnQgaTsKKwl1MzIgKmRpc3BfaW50ID0gcmRldi0+aXJxLnN0YXRfcmVncy5l dmVyZ3JlZW4uZGlzcF9pbnQ7CiAJdTMyIHRtcDsKIAotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50ID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVUyk7Ci0JcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCA9IFJSRUczMihESVNQX0lOVEVS UlVQVF9TVEFUVVNfQ09OVElOVUUpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQyID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTIpOwot CXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzID0gUlJFRzMyKERJ U1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTMpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQ0ID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05U SU5VRTQpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ1ID0g UlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTUpOworCWZvciAoaSA9IDA7IGkg PCBFVkVSR1JFRU5fTUFYX0RJU1BfUkVHSVNURVJTOyBpKyspIHsKKwkJZGlzcF9pbnRbaV0gPSBS UkVHMzIoRElTUF9JTlRFUlJVUFRfU1RBVFVTKGkpKTsKKworCQlpZiAoZGlzcF9pbnRbaV0gJiBE Q19IUER4X0lOVEVSUlVQVCkKKwkJCVdSRUczMl9PUihEQ19IUER4X0lOVF9DT05UUk9MKGkpLCBE Q19IUER4X0lOVF9BQ0spOworCQlpZiAoZGlzcF9pbnRbaV0gJiBEQ19IUER4X1JYX0lOVEVSUlVQ VCkKKwkJCVdSRUczMl9PUihEQ19IUER4X0lOVF9DT05UUk9MKGkpLCBEQ19IUER4X1JYX0lOVF9B Q0spOworCisJCWlmIChpIDwgcmRldi0+bnVtX2NydGMpIHsKKwkJCWlmIChkaXNwX2ludFtpXSAm IExCX0R4X1ZCTEFOS19JTlRFUlJVUFQpCisJCQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBjcnRj X29mZnNldHNbaV0sCisJCQkJICAgICAgIFZCTEFOS19BQ0spOworCQkJaWYgKGRpc3BfaW50W2ld ICYgTEJfRHhfVkxJTkVfSU5URVJSVVBUKQorCQkJCVdSRUczMihWTElORV9TVEFUVVMgKyBjcnRj X29mZnNldHNbaV0sCisJCQkJICAgICAgIFZMSU5FX0FDSyk7CisJCX0KKwl9CisKIAlyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kMWdycGhfaW50ID0gUlJFRzMyKEdSUEhfSU5UX1NUQVRV UyArIEVWRVJHUkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQpOwogCXJkZXYtPmlycS5zdGF0X3Jl Z3MuZXZlcmdyZWVuLmQyZ3JwaF9pbnQgPSBSUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdS RUVOX0NSVEMxX1JFR0lTVEVSX09GRlNFVCk7CiAJaWYgKHJkZXYtPm51bV9jcnRjID49IDQpIHsK QEAgLTQ4NjIsMjggKzQ2ODgsMTIgQEAgc3RhdGljIHZvaWQgZXZlcmdyZWVuX2lycV9hY2soc3Ry dWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVS R1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7CiAJaWYg KHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmQyZ3JwaF9pbnQgJiBHUlBIX1BGTElQX0lO VF9PQ0NVUlJFRCkKIAkJV1JFRzMyKEdSUEhfSU5UX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMV9S RUdJU1RFUl9PRkZTRVQsIEdSUEhfUEZMSVBfSU5UX0NMRUFSKTsKLQlpZiAocmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBMQl9EMV9WQkxBTktfSU5URVJSVVBUKQotCQlX UkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQsIFZC TEFOS19BQ0spOwotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAm IExCX0QxX1ZMSU5FX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJHUkVF Tl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7Ci0JaWYgKHJkZXYtPmlycS5zdGF0 X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBMQl9EMl9WQkxBTktfSU5URVJSVVBUKQot CQlXUkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RFUl9PRkZTRVQs IFZCTEFOS19BQ0spOwotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2lu dF9jb250ICYgTEJfRDJfVkxJTkVfSU5URVJSVVBUKQotCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsg RVZFUkdSRUVOX0NSVEMxX1JFR0lTVEVSX09GRlNFVCwgVkxJTkVfQUNLKTsKIAogCWlmIChyZGV2 LT5udW1fY3J0YyA+PSA0KSB7CiAJCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5k M2dycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQpCiAJCQlXUkVHMzIoR1JQSF9JTlRf U1RBVFVTICsgRVZFUkdSRUVOX0NSVEMyX1JFR0lTVEVSX09GRlNFVCwgR1JQSF9QRkxJUF9JTlRf Q0xFQVIpOwogCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZDRncnBoX2ludCAm IEdSUEhfUEZMSVBfSU5UX09DQ1VSUkVEKQogCQkJV1JFRzMyKEdSUEhfSU5UX1NUQVRVUyArIEVW RVJHUkVFTl9DUlRDM19SRUdJU1RFUl9PRkZTRVQsIEdSUEhfUEZMSVBfSU5UX0NMRUFSKTsKLQkJ aWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyICYgTEJfRDNf VkJMQU5LX0lOVEVSUlVQVCkKLQkJCVdSRUczMihWQkxBTktfU1RBVFVTICsgRVZFUkdSRUVOX0NS VEMyX1JFR0lTVEVSX09GRlNFVCwgVkJMQU5LX0FDSyk7Ci0JCWlmIChyZGV2LT5pcnEuc3RhdF9y ZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIExCX0QzX1ZMSU5FX0lOVEVSUlVQVCkKLQkJ CVdSRUczMihWTElORV9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzJfUkVHSVNURVJfT0ZGU0VULCBW TElORV9BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRf Y29udDMgJiBMQl9ENF9WQkxBTktfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZCTEFOS19TVEFUVVMg KyBFVkVSR1JFRU5fQ1JUQzNfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQkJaWYgKHJk ZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICYgTEJfRDRfVkxJTkVf SU5URVJSVVBUKQotCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDM19SRUdJ U1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7CiAJfQogCiAJaWYgKHJkZXYtPm51bV9jcnRjID49IDYp IHsKQEAgLTQ4OTEsNzYgKzQ3MDEsNiBAQCBzdGF0aWMgdm9pZCBldmVyZ3JlZW5faXJxX2Fjayhz dHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAkJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBF VkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7CiAJ CWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kNmdycGhfaW50ICYgR1JQSF9QRkxJ UF9JTlRfT0NDVVJSRUQpCiAJCQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NS VEM1X1JFR0lTVEVSX09GRlNFVCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwotCQlpZiAocmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WQkxBTktfSU5U RVJSVVBUKQotCQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzRfUkVHSVNU RVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdy ZWVuLmRpc3BfaW50X2NvbnQ0ICYgTEJfRDVfVkxJTkVfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZM SU5FX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDNF9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7 Ci0JCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIExC X0Q2X1ZCTEFOS19JTlRFUlJVUFQpCi0JCQlXUkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVF Tl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIFZCTEFOS19BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBMQl9ENl9WTElORV9JTlRFUlJVUFQp Ci0JCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNF VCwgVkxJTkVfQUNLKTsKLQl9Ci0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZGlzcF9pbnQgJiBEQ19IUEQxX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEMV9J TlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQx X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udCAmIERDX0hQRDJfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihE Q19IUEQyX0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMy KERDX0hQRDJfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdz LmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIERDX0hQRDNfSU5URVJSVVBUKSB7Ci0JCXRtcCA9 IFJSRUczMihEQ19IUEQzX0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsK LQkJV1JFRzMyKERDX0hQRDNfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEu c3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIERDX0hQRDRfSU5URVJSVVBUKSB7 Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhf SU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDRfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChy ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmIERDX0hQRDVfSU5U RVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9 IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDVfSU5UX0NPTlRST0wsIHRtcCk7Ci0J fQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIERD X0hQRDZfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MKTsK LQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDZfSU5UX0NPTlRST0ws IHRtcCk7Ci0JfQotCi0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 ICYgRENfSFBEMV9SWF9JTlRFUlJVUFQpIHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDFfSU5UX0NP TlRST0wpOwotCQl0bXAgfD0gRENfSFBEeF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBEMV9J TlRfQ09OVFJPTCwgdG1wKTsKLQl9Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVu LmRpc3BfaW50X2NvbnQgJiBEQ19IUEQyX1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIo RENfSFBEMl9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdS RUczMihEQ19IUEQyX0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDIgJiBEQ19IUEQzX1JYX0lOVEVSUlVQVCkgewot CQl0bXAgPSBSUkVHMzIoRENfSFBEM19JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JY X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQzX0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAo cmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJiBEQ19IUEQ0X1JY X0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCk7Ci0JCXRt cCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9MLCB0 bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29u dDQgJiBEQ19IUEQ1X1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENV9JTlRf Q09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ1 X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udDUgJiBEQ19IUEQ2X1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVH MzIoRENfSFBENl9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0J CVdSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MLCB0bXApOwogCX0KIAogCWlmIChyZGV2LT5pcnEu c3RhdF9yZWdzLmV2ZXJncmVlbi5hZm10X3N0YXR1czEgJiBBRk1UX0FaX0ZPUk1BVF9XVFJJRykg ewpAQCAtNTAzNyw2ICs0Nzc3LDkgQEAgc3RhdGljIHUzMiBldmVyZ3JlZW5fZ2V0X2loX3dwdHIo c3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAKIGludCBldmVyZ3JlZW5faXJxX3Byb2Nlc3Mo c3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7CisJdTMyICpkaXNwX2ludCA9IHJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50OworCXUzMiBjcnRjX2lkeCwgaHBkX2lkeDsK Kwl1MzIgbWFzazsKIAl1MzIgd3B0cjsKIAl1MzIgcnB0cjsKIAl1MzIgc3JjX2lkLCBzcmNfZGF0 YTsKQEAgLTUwNDYsNiArNDc4OSw3IEBAIGludCBldmVyZ3JlZW5faXJxX3Byb2Nlc3Moc3RydWN0 IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJYm9vbCBxdWV1ZV9kcCA9IGZhbHNlOwogCWJvb2wgcXVl dWVfdGhlcm1hbCA9IGZhbHNlOwogCXUzMiBzdGF0dXMsIGFkZHI7CisJY29uc3QgY2hhciAqZXZl bnRfbmFtZTsKIAogCWlmICghcmRldi0+aWguZW5hYmxlZCB8fCByZGV2LT5zaHV0ZG93bikKIAkJ cmV0dXJuIElSUV9OT05FOwpAQCAtNTA3NCwxODQgKzQ4MTgsNDQgQEAgaW50IGV2ZXJncmVlbl9p cnFfcHJvY2VzcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAogCQlzd2l0Y2ggKHNyY19p ZCkgewogCQljYXNlIDE6IC8qIEQxIHZibGFuay92bGluZSAqLwotCQkJc3dpdGNoIChzcmNfZGF0 YSkgewotCQkJY2FzZSAwOiAvKiBEMSB2YmxhbmsgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmIExCX0QxX1ZCTEFOS19JTlRFUlJVUFQpKQotCQkJ CQlEUk1fREVCVUcoIklIOiBEMSB2YmxhbmsgLSBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJp dD9cbiIpOwotCi0JCQkJaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbMF0pIHsKLQkJCQkJ ZHJtX2hhbmRsZV92YmxhbmsocmRldi0+ZGRldiwgMCk7Ci0JCQkJCXJkZXYtPnBtLnZibGFua19z eW5jID0gdHJ1ZTsKLQkJCQkJd2FrZV91cCgmcmRldi0+aXJxLnZibGFua19xdWV1ZSk7Ci0JCQkJ fQotCQkJCWlmIChhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzBdKSkKLQkJCQkJcmFkZW9u X2NydGNfaGFuZGxlX3ZibGFuayhyZGV2LCAwKTsKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kaXNwX2ludCAmPSB+TEJfRDFfVkJMQU5LX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVC VUcoIklIOiBEMSB2YmxhbmtcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6IC8qIEQxIHZs aW5lICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQg JiBMQl9EMV9WTElORV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBEMSB2bGluZSAt IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmPSB+TEJfRDFfVkxJTkVfSU5URVJSVVBUOwotCQkJ CURSTV9ERUJVRygiSUg6IEQxIHZsaW5lXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJZGVmYXVsdDoK LQkJCQlEUk1fREVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBzcmNfaWQsIHNy Y19kYXRhKTsKLQkJCQlicmVhazsKLQkJCX0KLQkJCWJyZWFrOwogCQljYXNlIDI6IC8qIEQyIHZi bGFuay92bGluZSAqLwotCQkJc3dpdGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAwOiAvKiBEMiB2 YmxhbmsgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2lu dF9jb250ICYgTEJfRDJfVkJMQU5LX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQy IHZibGFuayAtIElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlpZiAo cmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsxXSkgewotCQkJCQlkcm1faGFuZGxlX3ZibGFuayhy ZGV2LT5kZGV2LCAxKTsKLQkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwotCQkJCQl3 YWtlX3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsKLQkJCQl9Ci0JCQkJaWYgKGF0b21pY19y ZWFkKCZyZGV2LT5pcnEucGZsaXBbMV0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5r KHJkZXYsIDEpOwotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQgJj0gfkxCX0QyX1ZCTEFOS19JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDIgdmJs YW5rXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAxOiAvKiBEMiB2bGluZSAqLwotCQkJCWlm ICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBMQl9EMl9W TElORV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBEMiB2bGluZSAtIElIIGV2ZW50 IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kaXNwX2ludF9jb250ICY9IH5MQl9EMl9WTElORV9JTlRFUlJVUFQ7Ci0JCQkJRFJN X0RFQlVHKCJJSDogRDIgdmxpbmVcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJ CURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2Rh dGEpOwotCQkJCWJyZWFrOwotCQkJfQotCQkJYnJlYWs7CiAJCWNhc2UgMzogLyogRDMgdmJsYW5r L3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQljYXNlIDA6IC8qIEQzIHZibGFu ayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQyICYgTEJfRDNfVkJMQU5LX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQzIHZi bGFuayAtIElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlpZiAocmRl di0+aXJxLmNydGNfdmJsYW5rX2ludFsyXSkgewotCQkJCQlkcm1faGFuZGxlX3ZibGFuayhyZGV2 LT5kZGV2LCAyKTsKLQkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwotCQkJCQl3YWtl X3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsKLQkJCQl9Ci0JCQkJaWYgKGF0b21pY19yZWFk KCZyZGV2LT5pcnEucGZsaXBbMl0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJk ZXYsIDIpOwotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQy ICY9IH5MQl9EM19WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQzIHZibGFu a1xuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDMgdmxpbmUgKi8KLQkJCQlpZiAo IShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIExCX0QzX1ZM SU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQzIHZsaW5lIC0gSUggZXZlbnQg dy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQyICY9IH5MQl9EM19WTElORV9JTlRFUlJVUFQ7Ci0JCQkJRFJN X0RFQlVHKCJJSDogRDMgdmxpbmVcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJ CURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2Rh dGEpOwotCQkJCWJyZWFrOwotCQkJfQotCQkJYnJlYWs7CiAJCWNhc2UgNDogLyogRDQgdmJsYW5r L3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQljYXNlIDA6IC8qIEQ0IHZibGFu ayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQzICYgTEJfRDRfVkJMQU5LX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQ0IHZi bGFuayAtIElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlpZiAocmRl di0+aXJxLmNydGNfdmJsYW5rX2ludFszXSkgewotCQkJCQlkcm1faGFuZGxlX3ZibGFuayhyZGV2 LT5kZGV2LCAzKTsKLQkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwotCQkJCQl3YWtl X3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsKLQkJCQl9Ci0JCQkJaWYgKGF0b21pY19yZWFk KCZyZGV2LT5pcnEucGZsaXBbM10pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJk ZXYsIDMpOwotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQz ICY9IH5MQl9ENF9WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQ0IHZibGFu a1xuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDQgdmxpbmUgKi8KLQkJCQlpZiAo IShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIExCX0Q0X1ZM SU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQ0IHZsaW5lIC0gSUggZXZlbnQg dy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQzICY9IH5MQl9ENF9WTElORV9JTlRFUlJVUFQ7Ci0JCQkJRFJN X0RFQlVHKCJJSDogRDQgdmxpbmVcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJ CURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2Rh dGEpOwotCQkJCWJyZWFrOwotCQkJfQotCQkJYnJlYWs7CiAJCWNhc2UgNTogLyogRDUgdmJsYW5r L3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQljYXNlIDA6IC8qIEQ1IHZibGFu ayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQ0ICYgTEJfRDVfVkJMQU5LX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQ1IHZi bGFuayAtIElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7CisJCWNhc2UgNjogLyog RDYgdmJsYW5rL3ZsaW5lICovCisJCQljcnRjX2lkeCA9IHNyY19pZCAtIDE7CiAKLQkJCQlpZiAo cmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFs0XSkgewotCQkJCQlkcm1faGFuZGxlX3ZibGFuayhy ZGV2LT5kZGV2LCA0KTsKKwkJCWlmIChzcmNfZGF0YSA9PSAwKSB7IC8qIHZibGFuayAqLworCQkJ CW1hc2sgPSBMQl9EeF9WQkxBTktfSU5URVJSVVBUOworCQkJCWV2ZW50X25hbWUgPSAidmJsYW5r IjsKKworCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50W2NydGNfaWR4XSkgeworCQkJ CQlkcm1faGFuZGxlX3ZibGFuayhyZGV2LT5kZGV2LCBjcnRjX2lkeCk7CiAJCQkJCXJkZXYtPnBt LnZibGFua19zeW5jID0gdHJ1ZTsKIAkJCQkJd2FrZV91cCgmcmRldi0+aXJxLnZibGFua19xdWV1 ZSk7CiAJCQkJfQotCQkJCWlmIChhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzRdKSkKLQkJ CQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhyZGV2LCA0KTsKLQkJCQlyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmPSB+TEJfRDVfVkJMQU5LX0lOVEVSUlVQ VDsKLQkJCQlEUk1fREVCVUcoIklIOiBENSB2YmxhbmtcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlj YXNlIDE6IC8qIEQ1IHZsaW5lICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WTElORV9JTlRFUlJVUFQpKQotCQkJCQlEUk1f REVCVUcoIklIOiBENSB2bGluZSAtIElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7 Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmPSB+ TEJfRDVfVkxJTkVfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQ1IHZsaW5lXG4iKTsK KwkJCQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFtjcnRjX2lkeF0pKSB7CisJCQkJ CXJhZGVvbl9jcnRjX2hhbmRsZV92YmxhbmsocmRldiwKKwkJCQkJCQkJICBjcnRjX2lkeCk7CisJ CQkJfQogCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygiVW5oYW5kbGVk IGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOworCQkJfSBlbHNlIGlmIChz cmNfZGF0YSA9PSAxKSB7IC8qIHZsaW5lICovCisJCQkJbWFzayA9IExCX0R4X1ZMSU5FX0lOVEVS UlVQVDsKKwkJCQlldmVudF9uYW1lID0gInZsaW5lIjsKKwkJCX0gZWxzZSB7CisJCQkJRFJNX0RF QlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwKKwkJCQkJICBzcmNfaWQsIHNyY19k YXRhKTsKIAkJCQlicmVhazsKIAkJCX0KLQkJCWJyZWFrOwotCQljYXNlIDY6IC8qIEQ2IHZibGFu ay92bGluZSAqLwotCQkJc3dpdGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAwOiAvKiBENiB2Ymxh bmsgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9j b250NSAmIExCX0Q2X1ZCTEFOS19JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBENiB2 YmxhbmsgLSBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwogCi0JCQkJaWYgKHJk ZXYtPmlycS5jcnRjX3ZibGFua19pbnRbNV0pIHsKLQkJCQkJZHJtX2hhbmRsZV92YmxhbmsocmRl di0+ZGRldiwgNSk7Ci0JCQkJCXJkZXYtPnBtLnZibGFua19zeW5jID0gdHJ1ZTsKLQkJCQkJd2Fr ZV91cCgmcmRldi0+aXJxLnZibGFua19xdWV1ZSk7Ci0JCQkJfQotCQkJCWlmIChhdG9taWNfcmVh ZCgmcmRldi0+aXJxLnBmbGlwWzVdKSkKLQkJCQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhy ZGV2LCA1KTsKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250 NSAmPSB+TEJfRDZfVkJMQU5LX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENiB2Ymxh bmtcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6IC8qIEQ2IHZsaW5lICovCi0JCQkJaWYg KCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBMQl9ENl9W TElORV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBENiB2bGluZSAtIElIIGV2ZW50 IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7CisJCQlpZiAoIShkaXNwX2ludFtjcnRjX2lkeF0g JiBtYXNrKSkgeworCQkJCURSTV9ERUJVRygiSUg6IEQlZCAlcyAtIElIIGV2ZW50IHcvbyBhc3Nl cnRlZCBpcnEgYml0P1xuIiwKKwkJCQkJICBjcnRjX2lkeCArIDEsIGV2ZW50X25hbWUpOworCQkJ fQogCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJj0g fkxCX0Q2X1ZMSU5FX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENiB2bGluZVxuIik7 CisJCQlkaXNwX2ludFtjcnRjX2lkeF0gJj0gfm1hc2s7CisJCQlEUk1fREVCVUcoIklIOiBEJWQg JXNcbiIsIGNydGNfaWR4ICsgMSwgZXZlbnRfbmFtZSk7CiAKLQkJCQlicmVhazsKLQkJCWRlZmF1 bHQ6Ci0JCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwgc3JjX2lk LCBzcmNfZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9CiAJCQlicmVhazsKIAkJY2FzZSA4OiAvKiBE MSBwYWdlIGZsaXAgKi8KIAkJY2FzZSAxMDogLyogRDIgcGFnZSBmbGlwICovCkBAIC01MjY0LDEw NyArNDg2OCwzMCBAQCBpbnQgZXZlcmdyZWVuX2lycV9wcm9jZXNzKHN0cnVjdCByYWRlb25fZGV2 aWNlICpyZGV2KQogCQkJCXJhZGVvbl9jcnRjX2hhbmRsZV9mbGlwKHJkZXYsIChzcmNfaWQgLSA4 KSA+PiAxKTsKIAkJCWJyZWFrOwogCQljYXNlIDQyOiAvKiBIUEQgaG90cGx1ZyAqLwotCQkJc3dp dGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAwOgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3Jl Z3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgRENfSFBEMV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVC VUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJj0gfkRDX0hQRDFfSU5URVJSVVBUOwot CQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDFcbiIpOwot CQkJCWJyZWFrOwotCQkJY2FzZSAxOgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQgJiBEQ19IUEQyX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJV RygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250ICY9IH5EQ19IUEQyX0lOVEVSUlVQ VDsKLQkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQyXG4i KTsKLQkJCQlicmVhazsKLQkJCWNhc2UgMjoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdz LmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIERDX0hQRDNfSU5URVJSVVBUKSkKLQkJCQkJRFJN X0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJk ZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyICY9IH5EQ19IUEQzX0lO VEVSUlVQVDsKLQkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBI UEQzXG4iKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgMzoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIERDX0hQRDRfSU5URVJSVVBUKSkKLQkJ CQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQot CQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICY9IH5EQ19I UEQ0X0lOVEVSUlVQVDsKKwkJCWlmIChzcmNfZGF0YSA8PSA1KSB7CisJCQkJaHBkX2lkeCA9IHNy Y19kYXRhOworCQkJCW1hc2sgPSBEQ19IUER4X0lOVEVSUlVQVDsKIAkJCQlxdWV1ZV9ob3RwbHVn ID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQ0XG4iKTsKLQkJCQlicmVhazsKLQkJCWNh c2UgNDoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9j b250NCAmIERDX0hQRDVfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQg dy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKKwkJCQlldmVudF9uYW1lID0gIkhQRCI7CiAKLQkJ CQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmPSB+RENfSFBE NV9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfaG90cGx1ZyA9IHRydWU7Ci0JCQkJRFJNX0RFQlVHKCJJ SDogSFBENVxuIik7Ci0JCQkJYnJlYWs7Ci0JCQljYXNlIDU6Ci0JCQkJaWYgKCEocmRldi0+aXJx LnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBEQ19IUEQ2X0lOVEVSUlVQVCkp Ci0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7 Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmPSB+ RENfSFBENl9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfaG90cGx1ZyA9IHRydWU7Ci0JCQkJRFJNX0RF QlVHKCJJSDogSFBENlxuIik7Ci0JCQkJYnJlYWs7Ci0JCQljYXNlIDY6Ci0JCQkJaWYgKCEocmRl di0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBEQ19IUEQxX1JYX0lOVEVSUlVQ VCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xu Iik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmPSB+RENf SFBEMV9SWF9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygi SUg6IEhQRF9SWCAxXG4iKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgNzoKLQkJCQlpZiAoIShyZGV2 LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250ICYgRENfSFBEMl9SWF9JTlRF UlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJp dD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29u dCAmPSB+RENfSFBEMl9SWF9JTlRFUlJVUFQ7CisJCQl9IGVsc2UgaWYgKHNyY19kYXRhIDw9IDEx KSB7CisJCQkJaHBkX2lkeCA9IHNyY19kYXRhIC0gNjsKKwkJCQltYXNrID0gRENfSFBEeF9SWF9J TlRFUlJVUFQ7CiAJCQkJcXVldWVfZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRF9S WCAyXG4iKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgODoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIERDX0hQRDNfUlhfSU5URVJSVVBUKSkK LQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsK KwkJCQlldmVudF9uYW1lID0gIkhQRF9SWCI7CiAKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kaXNwX2ludF9jb250MiAmPSB+RENfSFBEM19SWF9JTlRFUlJVUFQ7Ci0JCQkJcXVl dWVfZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRF9SWCAzXG4iKTsKKwkJCX0gZWxz ZSB7CisJCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwKKwkJCQkJ ICBzcmNfaWQsIHNyY19kYXRhKTsKIAkJCQlicmVhazsKLQkJCWNhc2UgOToKLQkJCQlpZiAoIShy ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIERDX0hQRDRfUlhf SU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGly cSBiaXQ/XG4iKTsKKwkJCX0KIAotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQzICY9IH5EQ19IUEQ0X1JYX0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9kcCA9IHRy dWU7Ci0JCQkJRFJNX0RFQlVHKCJJSDogSFBEX1JYIDRcbiIpOwotCQkJCWJyZWFrOwotCQkJY2Fz ZSAxMDoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9j b250NCAmIERDX0hQRDVfUlhfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZl bnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKKwkJCWlmICghKGRpc3BfaW50W2hwZF9pZHhd ICYgbWFzaykpCisJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBi aXQ/XG4iKTsKIAotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQ0ICY9IH5EQ19IUEQ1X1JYX0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9kcCA9IHRydWU7Ci0JCQkJ RFJNX0RFQlVHKCJJSDogSFBEX1JYIDVcbiIpOwotCQkJCWJyZWFrOwotCQkJY2FzZSAxMToKLQkJ CQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIERD X0hQRDZfUlhfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFz c2VydGVkIGlycSBiaXQ/XG4iKTsKKwkJCWRpc3BfaW50W2hwZF9pZHhdICY9IH5tYXNrOworCQkJ RFJNX0RFQlVHKCJJSDogJXMlZFxuIiwgZXZlbnRfbmFtZSwgaHBkX2lkeCArIDEpOwogCi0JCQkJ cmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJj0gfkRDX0hQRDZf UlhfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2RwID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBI UERfUlggNlxuIik7Ci0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygiVW5o YW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOwotCQkJCWJyZWFr OwotCQkJfQogCQkJYnJlYWs7CiAJCWNhc2UgNDQ6IC8qIGhkbWkgKi8KIAkJCXN3aXRjaCAoc3Jj X2RhdGEpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdyZWVuZC5o IGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW5kLmgKaW5kZXggZjNkODhjYS4uNTZk MWU3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW5kLmgKKysr IGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9ldmVyZ3JlZW5kLmgKQEAgLTM2LDYgKzM2LDcgQEAK ICNkZWZpbmUgRVZFUkdSRUVOX01BWF9QSVBFUyAgICAgICAgICAgICA4CiAjZGVmaW5lIEVWRVJH UkVFTl9NQVhfUElQRVNfTUFTSyAgICAgICAgMHhGRgogI2RlZmluZSBFVkVSR1JFRU5fTUFYX0xE U19OVU0gICAgICAgICAgIDB4RkZGRgorI2RlZmluZSBFVkVSR1JFRU5fTUFYX0RJU1BfUkVHSVNU RVJTICAgIDYKIAogI2RlZmluZSBDWVBSRVNTX0dCX0FERFJfQ09ORklHX0dPTERFTiAgICAgICAg MHgwMjAxMTAwMwogI2RlZmluZSBCQVJUU19HQl9BRERSX0NPTkZJR19HT0xERU4gICAgICAgICAg MHgwMjAxMTAwMwpAQCAtMTI4NSw4NSArMTI4Niw1MiBAQAogIyAgICAgICBkZWZpbmUgVkJMQU5L X0lOVF9NQVNLICAgICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAwKQogIyAgICAgICBkZWZp bmUgVkxJTkVfSU5UX01BU0sgICAgICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCA0KQogCi0j ZGVmaW5lIERJU1BfSU5URVJSVVBUX1NUQVRVUyAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4 NjBmNAotIyAgICAgICBkZWZpbmUgTEJfRDFfVkxJTkVfSU5URVJSVVBUICAgICAgICAgICAgICAg ICAgICAoMSA8PCAyKQotIyAgICAgICBkZWZpbmUgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCAgICAg ICAgICAgICAgICAgICAoMSA8PCAzKQotIyAgICAgICBkZWZpbmUgRENfSFBEMV9JTlRFUlJVUFQg ICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAxNykKLSMgICAgICAgZGVmaW5lIERDX0hQRDFf UlhfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTgpCisvKiAweDYwZjQsIDB4 NjBmOCwgMHg2MGZjLCAweDYxMDAsIDB4NjE0YywgMHg2MTUwICovCisjZGVmaW5lIERJU1BfSU5U RVJSVVBUX1NUQVRVUyhpKSBcCisJKChpIDwgNCkgPyAweDYwZjQgKyAoMHg0ICogaSkgOiAweDYx NGMgKyAoMHg0ICogKGkgLSA0KSkpCisjICAgICAgIGRlZmluZSBMQl9EeF9WTElORV9JTlRFUlJV UFQgICAgICAgICAgICAgICAgICAgICgxIDw8IDIpCisjICAgICAgIGRlZmluZSBMQl9EeF9WQkxB TktfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICgxIDw8IDMpCisjICAgICAgIGRlZmluZSBE Q19IUER4X0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE3KQorIyAgICAg ICBkZWZpbmUgRENfSFBEeF9SWF9JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgICAoMSA8PCAx OCkKKy8qIEZpcnN0IHJlZyBvbmx5ICovCiAjICAgICAgIGRlZmluZSBEQUNBX0FVVE9ERVRFQ1Rf SU5URVJSVVBUICAgICAgICAgICAgICAgICgxIDw8IDIyKQogIyAgICAgICBkZWZpbmUgREFDQl9B VVRPREVURUNUX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAoMSA8PCAyMykKICMgICAgICAgZGVm aW5lIERDX0kyQ19TV19ET05FX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgKDEgPDwgMjQpCiAj ICAgICAgIGRlZmluZSBEQ19JMkNfSFdfRE9ORV9JTlRFUlJVUFQgICAgICAgICAgICAgICAgICgx IDw8IDI1KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUUgICAgICAgICAg ICAgICAgICAweDYwZjgKLSMgICAgICAgZGVmaW5lIExCX0QyX1ZMSU5FX0lOVEVSUlVQVCAgICAg ICAgICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0QyX1ZCTEFOS19JTlRF UlJVUFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5lIERDX0hQRDJf SU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAgICAgIGRlZmlu ZSBEQ19IUEQyX1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE4KQorLyog U2Vjb25kIHJlZyBvbmx5ICovCiAjICAgICAgIGRlZmluZSBESVNQX1RJTUVSX0lOVEVSUlVQVCAg ICAgICAgICAgICAgICAgICAgICgxIDw8IDI0KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFU VVNfQ09OVElOVUUyICAgICAgICAgICAgICAgICAweDYwZmMKLSMgICAgICAgZGVmaW5lIExCX0Qz X1ZMSU5FX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVm aW5lIExCX0QzX1ZCTEFOS19JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMg ICAgICAgZGVmaW5lIERDX0hQRDNfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEg PDwgMTcpCi0jICAgICAgIGRlZmluZSBEQ19IUEQzX1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAg ICAgICAgICgxIDw8IDE4KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUUz ICAgICAgICAgICAgICAgICAweDYxMDAKLSMgICAgICAgZGVmaW5lIExCX0Q0X1ZMSU5FX0lOVEVS UlVQVCAgICAgICAgICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0Q0X1ZC TEFOS19JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5l IERDX0hQRDRfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAg ICAgIGRlZmluZSBEQ19IUEQ0X1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8 IDE4KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUU0ICAgICAgICAgICAg ICAgICAweDYxNGMKLSMgICAgICAgZGVmaW5lIExCX0Q1X1ZMSU5FX0lOVEVSUlVQVCAgICAgICAg ICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0Q1X1ZCTEFOS19JTlRFUlJV UFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5lIERDX0hQRDVfSU5U RVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAgICAgIGRlZmluZSBE Q19IUEQ1X1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE4KQotI2RlZmlu ZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUU1ICAgICAgICAgICAgICAgICAweDYxNTAK LSMgICAgICAgZGVmaW5lIExCX0Q2X1ZMSU5FX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAg KDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0Q2X1ZCTEFOS19JTlRFUlJVUFQgICAgICAgICAg ICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5lIERDX0hQRDZfSU5URVJSVVBUICAgICAg ICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAgICAgIGRlZmluZSBEQ19IUEQ2X1JYX0lO VEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE4KQogCiAvKiAweDY4NTgsIDB4NzQ1 OCwgMHgxMDA1OCwgMHgxMGM1OCwgMHgxMTg1OCwgMHgxMjQ1OCAqLwogI2RlZmluZSBHUlBIX0lO VF9TVEFUVVMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDY4NTgKICMgICAgICAg ZGVmaW5lIEdSUEhfUEZMSVBfSU5UX09DQ1VSUkVEICAgICAgICAgICAgICAgICAgKDEgPDwgMCkK ICMgICAgICAgZGVmaW5lIEdSUEhfUEZMSVBfSU5UX0NMRUFSICAgICAgICAgICAgICAgICAgICAg KDEgPDwgOCkKIC8qIDB4Njg1YywgMHg3NDVjLCAweDEwMDVjLCAweDEwYzVjLCAweDExODVjLCAw eDEyNDVjICovCi0jZGVmaW5lCUdSUEhfSU5UX0NPTlRST0wJCQkgICAgICAgIDB4Njg1YworI2Rl ZmluZQlHUlBIX0lOVF9DT05UUk9MICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDY4 NWMKICMgICAgICAgZGVmaW5lIEdSUEhfUEZMSVBfSU5UX01BU0sgICAgICAgICAgICAgICAgICAg ICAgKDEgPDwgMCkKICMgICAgICAgZGVmaW5lIEdSUEhfUEZMSVBfSU5UX1RZUEUgICAgICAgICAg ICAgICAgICAgICAgKDEgPDwgOCkKIAogI2RlZmluZQlEQUNBX0FVVE9ERVRFQ1RfSU5UX0NPTlRS T0wJCQkweDY2YzgKICNkZWZpbmUJREFDQl9BVVRPREVURUNUX0lOVF9DT05UUk9MCQkJMHg2N2M4 CiAKLSNkZWZpbmUgRENfSFBEMV9JTlRfU1RBVFVTICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgMHg2MDFjCi0jZGVmaW5lIERDX0hQRDJfSU5UX1NUQVRVUyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDB4NjAyOAotI2RlZmluZSBEQ19IUEQzX0lOVF9TVEFUVVMgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAweDYwMzQKLSNkZWZpbmUgRENfSFBENF9JTlRfU1RBVFVTICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDQwCi0jZGVmaW5lIERDX0hQRDVfSU5UX1NUQVRV UyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4NjA0YwotI2RlZmluZSBEQ19IUEQ2X0lO VF9TVEFUVVMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDYwNTgKLSMgICAgICAgZGVm aW5lIERDX0hQRHhfSU5UX1NUQVRVUyAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMCkKKy8q IDB4NjAxYywgMHg2MDI4LCAweDYwMzQsIDB4NjA0MCwgMHg2MDRjLCAweDYwNTggKi8KKyNkZWZp bmUgRENfSFBEeF9JTlRfU1RBVFVTKHgpICAgICAgICAgICAgICAgICAgICAgICAgICAgKDB4NjAx YyArICgweGMgKiB4KSkKKyMgICAgICAgZGVmaW5lIERDX0hQRHhfSU5UX1NUQVRVU19NQVNLICAg ICAgICAgICAgICAgICAgKDEgPDwgMCkKICMgICAgICAgZGVmaW5lIERDX0hQRHhfU0VOU0UgICAg ICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMSkKICMgICAgICAgZGVmaW5lIERDX0hQRHhf UlhfSU5UX1NUQVRVUyAgICAgICAgICAgICAgICAgICAgKDEgPDwgOCkKIAotI2RlZmluZSBEQ19I UEQxX0lOVF9DT05UUk9MICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDYwMjAKLSNkZWZp bmUgRENfSFBEMl9JTlRfQ09OVFJPTCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDJj Ci0jZGVmaW5lIERDX0hQRDNfSU5UX0NPTlRST0wgICAgICAgICAgICAgICAgICAgICAgICAgICAg IDB4NjAzOAotI2RlZmluZSBEQ19IUEQ0X0lOVF9DT05UUk9MICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAweDYwNDQKLSNkZWZpbmUgRENfSFBENV9JTlRfQ09OVFJPTCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgMHg2MDUwCi0jZGVmaW5lIERDX0hQRDZfSU5UX0NPTlRST0wgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDB4NjA1YworLyogMHg2MDIwLCAweDYwMmMsIDB4NjAzOCwg MHg2MDQ0LCAweDYwNTAsIDB4NjA1YyAqLworI2RlZmluZSBEQ19IUER4X0lOVF9DT05UUk9MKHgp ICAgICAgICAgICAgICAgICAgICAgICAgICAoMHg2MDIwICsgKDB4YyAqIHgpKQogIyAgICAgICBk ZWZpbmUgRENfSFBEeF9JTlRfQUNLICAgICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAwKQog IyAgICAgICBkZWZpbmUgRENfSFBEeF9JTlRfUE9MQVJJVFkgICAgICAgICAgICAgICAgICAgICAo MSA8PCA4KQogIyAgICAgICBkZWZpbmUgRENfSFBEeF9JTlRfRU4gICAgICAgICAgICAgICAgICAg ICAgICAgICAoMSA8PCAxNikKICMgICAgICAgZGVmaW5lIERDX0hQRHhfUlhfSU5UX0FDSyAgICAg ICAgICAgICAgICAgICAgICAgKDEgPDwgMjApCiAjICAgICAgIGRlZmluZSBEQ19IUER4X1JYX0lO VF9FTiAgICAgICAgICAgICAgICAgICAgICAgICgxIDw8IDI0KQogCi0jZGVmaW5lIERDX0hQRDFf Q09OVFJPTCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDI0Ci0jZGVmaW5l IERDX0hQRDJfQ09OVFJPTCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDMw Ci0jZGVmaW5lIERDX0hQRDNfQ09OVFJPTCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgMHg2MDNjCi0jZGVmaW5lIERDX0hQRDRfQ09OVFJPTCAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgMHg2MDQ4Ci0jZGVmaW5lIERDX0hQRDVfQ09OVFJPTCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgMHg2MDU0Ci0jZGVmaW5lIERDX0hQRDZfQ09OVFJPTCAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDYwCi0jICAgICAgIGRlZmluZSBEQ19I UER4X0NPTk5FQ1RJT05fVElNRVIoeCkgICAgICAgICAgICAgICAgKCh4KSA8PCAwKQotIyAgICAg ICBkZWZpbmUgRENfSFBEeF9SWF9JTlRfVElNRVIoeCkgICAgICAgICAgICAgICAgICAgICgoeCkg PDwgMTYpCi0jICAgICAgIGRlZmluZSBEQ19IUER4X0VOICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgKDEgPDwgMjgpCisvKiAweDYwMjQsIDB4NjAzMCwgMHg2MDNjLCAweDYwNDgsIDB4 NjA1NCwgMHg2MDYwICovCisjZGVmaW5lIERDX0hQRHhfQ09OVFJPTCh4KSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICgweDYwMjQgKyAoMHhjICogeCkpCisjICAgICAgIGRlZmluZSBEQ19I UER4X0NPTk5FQ1RJT05fVElNRVIoeCkgICAgICAgICAgICAgICgoeCkgPDwgMCkKKyMgICAgICAg ZGVmaW5lIERDX0hQRHhfUlhfSU5UX1RJTUVSKHgpICAgICAgICAgICAgICAgICAgKCh4KSA8PCAx NikKKyMgICAgICAgZGVmaW5lIERDX0hQRHhfRU4gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgKDEgPDwgMjgpCiAKIC8qIERDRTQvNS82IEZNVCBibG9ja3MgKi8KICNkZWZpbmUgRk1UX0RZ TkFNSUNfRVhQX0NOVEwgICAgICAgICAgICAgICAgIDB4NmZiNApkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9u LmgKaW5kZXggYzFjOGUyMi4uYjYwODZlZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Jh ZGVvbi9yYWRlb24uaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCkBAIC03 NjcsMTIgKzc2Nyw3IEBAIHN0cnVjdCByNjAwX2lycV9zdGF0X3JlZ3MgewogfTsKIAogc3RydWN0 IGV2ZXJncmVlbl9pcnFfc3RhdF9yZWdzIHsKLQl1MzIgZGlzcF9pbnQ7Ci0JdTMyIGRpc3BfaW50 X2NvbnQ7Ci0JdTMyIGRpc3BfaW50X2NvbnQyOwotCXUzMiBkaXNwX2ludF9jb250MzsKLQl1MzIg ZGlzcF9pbnRfY29udDQ7Ci0JdTMyIGRpc3BfaW50X2NvbnQ1OworCXUzMiBkaXNwX2ludFs2XTsK IAl1MzIgZDFncnBoX2ludDsKIAl1MzIgZDJncnBoX2ludDsKIAl1MzIgZDNncnBoX2ludDsKQEAg LTI5NzYsNiArMjk3MSwxMiBAQCBpbnQgcjYwMF9jc19jb21tb25fdmxpbmVfcGFyc2Uoc3RydWN0 IHJhZGVvbl9jc19wYXJzZXIgKnAsCiAJCQkgICAgICAgdWludDMyX3QgKnZsaW5lX3N0YXJ0X2Vu ZCwKIAkJCSAgICAgICB1aW50MzJfdCAqdmxpbmVfc3RhdHVzKTsKIAorLyogaW50ZXJydXB0IGNv bnRyb2wgcmVnaXN0ZXIgaGVscGVycyAqLwordm9pZCByYWRlb25faXJxX2ttc19zZXRfaXJxX25f ZW5hYmxlZChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwKKwkJCQkgICAgICB1MzIgcmVnLCB1 MzIgbWFzaywKKwkJCQkgICAgICBib29sIGVuYWJsZSwgY29uc3QgY2hhciAqbmFtZSwKKwkJCQkg ICAgICB1bnNpZ25lZCBuKTsKKwogI2luY2x1ZGUgInJhZGVvbl9vYmplY3QuaCIKIAogI2VuZGlm CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMgYi9k cml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMKaW5kZXggMWI3NTI4ZC4uN2Fh Y2I0NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25faXJxX2ttcy5j CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2lycV9rbXMuYwpAQCAtNTM4LDMg KzUzOCwzOCBAQCB2b2lkIHJhZGVvbl9pcnFfa21zX2Rpc2FibGVfaHBkKHN0cnVjdCByYWRlb25f ZGV2aWNlICpyZGV2LCB1bnNpZ25lZCBocGRfbWFzaykKIAlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZyZGV2LT5pcnEubG9jaywgaXJxZmxhZ3MpOwogfQogCisvKioKKyAqIHJhZGVvbl9pcnFfa21z X3VwZGF0ZV9pbnRfbiAtIGhlbHBlciBmb3IgdXBkYXRpbmcgaW50ZXJydXB0IGVuYWJsZSByZWdp c3RlcnMKKyAqCisgKiBAcmRldjogcmFkZW9uIGRldmljZSBwb2ludGVyCisgKiBAcmVnOiB0aGUg cmVnaXN0ZXIgdG8gd3JpdGUgdG8gZW5hYmxlL2Rpc2FibGUgaW50ZXJydXB0cworICogQG1hc2s6 IHRoZSBtYXNrIHRoYXQgZW5hYmxlcyB0aGUgaW50ZXJydXB0cworICogQGVuYWJsZTogd2hldGhl ciB0byBlbmFibGUgb3IgZGlzYWJsZSB0aGUgaW50ZXJydXB0IHJlZ2lzdGVyCisgKiBAbmFtZTog dGhlIG5hbWUgb2YgdGhlIGludGVycnVwdCByZWdpc3RlciB0byBwcmludCB0byB0aGUga2VybmVs IGxvZworICogQG51bTogdGhlIG51bWJlciBvZiB0aGUgaW50ZXJydXB0IHJlZ2lzdGVyIHRvIHBy aW50IHRvIHRoZSBrZXJuZWwgbG9nCisgKgorICogSGVscGVyIGZvciB1cGRhdGluZyB0aGUgZW5h YmxlIHN0YXRlIG9mIGludGVycnVwdCByZWdpc3RlcnMuIENoZWNrcyB3aGV0aGVyCisgKiBvciBu b3QgdGhlIGludGVycnVwdCBtYXRjaGVzIHRoZSBlbmFibGUgc3RhdGUgd2Ugd2FudC4gSWYgaXQg ZG9lc24ndCwgdGhlbgorICogd2UgdXBkYXRlIGl0IGFuZCBwcmludCBhIGRlYnVnZ2luZyBtZXNz YWdlIHRvIHRoZSBrZXJuZWwgbG9nIGluZGljYXRpbmcgdGhlCisgKiBuZXcgc3RhdGUgb2YgdGhl IGludGVycnVwdCByZWdpc3Rlci4KKyAqCisgKiBVc2VkIGZvciB1cGRhdGluZyBzZXF1ZW5jZXMg b2YgaW50ZXJydXB0cyByZWdpc3RlcnMgbGlrZSBIUEQxLCBIUEQyLCBldGMuCisgKi8KK3ZvaWQg cmFkZW9uX2lycV9rbXNfc2V0X2lycV9uX2VuYWJsZWQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJk ZXYsCisJCQkJICAgICAgdTMyIHJlZywgdTMyIG1hc2ssCisJCQkJICAgICAgYm9vbCBlbmFibGUs IGNvbnN0IGNoYXIgKm5hbWUsIHVuc2lnbmVkIG4pCit7CisJdTMyIHRtcCA9IFJSRUczMihyZWcp OworCisJLyogSW50ZXJydXB0IHN0YXRlIGRpZG4ndCBjaGFuZ2UgKi8KKwlpZiAoISEodG1wICYg bWFzaykgPT0gZW5hYmxlKQorCQlyZXR1cm47CisKKwlpZiAoZW5hYmxlKSB7CisJCURSTV9ERUJV RygiJXMlZCBpbnRlcnJ1cHRzIGVuYWJsZWRcbiIsIG5hbWUsIG4pOworCQlXUkVHMzIocmVnLCB0 bXAgfD0gbWFzayk7CisJfSBlbHNlIHsKKwkJRFJNX0RFQlVHKCIlcyVkIGludGVycnVwdHMgZGlz YWJsZWRcbiIsIG5hbWUsIG4pOworCQlXUkVHMzIocmVnLCB0bXAgJiB+bWFzayk7CisJfQorfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaS5jIGIvZHJpdmVycy9ncHUvZHJt L3JhZGVvbi9zaS5jCmluZGV4IDc2ZDE4ODguLmJiNzQ1ZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9yYWRlb24vc2kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3NpLmMKQEAg LTEzOSw2ICsxMzksMTYgQEAgc3RhdGljIHZvaWQgc2lfZmluaV9wZyhzdHJ1Y3QgcmFkZW9uX2Rl dmljZSAqcmRldik7CiBzdGF0aWMgdm9pZCBzaV9maW5pX2NnKHN0cnVjdCByYWRlb25fZGV2aWNl ICpyZGV2KTsKIHN0YXRpYyB2b2lkIHNpX3JsY19zdG9wKHN0cnVjdCByYWRlb25fZGV2aWNlICpy ZGV2KTsKIAorc3RhdGljIGNvbnN0IHUzMiBjcnRjX29mZnNldHNbXSA9Cit7CisJRVZFUkdSRUVO X0NSVEMwX1JFR0lTVEVSX09GRlNFVCwKKwlFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VU LAorCUVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsCisJRVZFUkdSRUVOX0NSVEMzX1JF R0lTVEVSX09GRlNFVCwKKwlFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULAorCUVWRVJH UkVFTl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQKK307CisKIHN0YXRpYyBjb25zdCB1MzIgdmVyZGVf cmxjX3NhdmVfcmVzdG9yZV9yZWdpc3Rlcl9saXN0W10gPQogewogCSgweDgwMDAgPDwgMTYpIHwg KDB4OThmNCA+PiAyKSwKQEAgLTU5MTYsNiArNTkyNiw3IEBAIHN0YXRpYyB2b2lkIHNpX2Rpc2Fi bGVfaW50ZXJydXB0cyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAogc3RhdGljIHZvaWQg c2lfZGlzYWJsZV9pbnRlcnJ1cHRfc3RhdGUoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7 CisJaW50IGk7CiAJdTMyIHRtcDsKIAogCXRtcCA9IFJSRUczMihDUF9JTlRfQ05UTF9SSU5HMCkg JgpAQCAtNTkyOSwxOCArNTk0MCw4IEBAIHN0YXRpYyB2b2lkIHNpX2Rpc2FibGVfaW50ZXJydXB0 X3N0YXRlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCVdSRUczMihETUFfQ05UTCArIERN QTFfUkVHSVNURVJfT0ZGU0VULCB0bXApOwogCVdSRUczMihHUkJNX0lOVF9DTlRMLCAwKTsKIAlX UkVHMzIoU1JCTV9JTlRfQ05UTCwgMCk7Ci0JaWYgKHJkZXYtPm51bV9jcnRjID49IDIpIHsKLQkJ V1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMwX1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0J CVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RFUl9PRkZTRVQsIDApOwot CX0KLQlpZiAocmRldi0+bnVtX2NydGMgPj0gNCkgewotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVS R1JFRU5fQ1JUQzJfUkVHSVNURVJfT0ZGU0VULCAwKTsKLQkJV1JFRzMyKElOVF9NQVNLICsgRVZF UkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0JfQotCWlmIChyZGV2LT5udW1fY3J0 YyA+PSA2KSB7Ci0JCVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVFTl9DUlRDNF9SRUdJU1RFUl9P RkZTRVQsIDApOwotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzVfUkVHSVNURVJf T0ZGU0VULCAwKTsKLQl9CisJZm9yIChpID0gMDsgaSA8IHJkZXYtPm51bV9jcnRjOyBpKyspCisJ CVdSRUczMihJTlRfTUFTSyArIGNydGNfb2Zmc2V0c1tpXSwgMCk7CiAKIAlpZiAocmRldi0+bnVt X2NydGMgPj0gMikgewogCQlXUkVHMzIoR1JQSF9JTlRfQ09OVFJPTCArIEVWRVJHUkVFTl9DUlRD MF9SRUdJU1RFUl9PRkZTRVQsIDApOwpAQCAtNTk1OCwxOCArNTk1OSw5IEBAIHN0YXRpYyB2b2lk IHNpX2Rpc2FibGVfaW50ZXJydXB0X3N0YXRlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQog CWlmICghQVNJQ19JU19OT0RDRShyZGV2KSkgewogCQlXUkVHMzIoREFDX0FVVE9ERVRFQ1RfSU5U X0NPTlRST0wsIDApOwogCi0JCXRtcCA9IFJSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MKSAmIERD X0hQRHhfSU5UX1BPTEFSSVRZOwotCQlXUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCwgdG1wKTsK LQkJdG1wID0gUlJFRzMyKERDX0hQRDJfSU5UX0NPTlRST0wpICYgRENfSFBEeF9JTlRfUE9MQVJJ VFk7Ci0JCVdSRUczMihEQ19IUEQyX0lOVF9DT05UUk9MLCB0bXApOwotCQl0bXAgPSBSUkVHMzIo RENfSFBEM19JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJV1JFRzMyKERD X0hQRDNfSU5UX0NPTlRST0wsIHRtcCk7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ0X0lOVF9DT05U Uk9MKSAmIERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCQlXUkVHMzIoRENfSFBENF9JTlRfQ09OVFJP TCwgdG1wKTsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDVfSU5UX0NPTlRST0wpICYgRENfSFBEeF9J TlRfUE9MQVJJVFk7Ci0JCVdSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MLCB0bXApOwotCQl0bXAg PSBSUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJ V1JFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wsIHRtcCk7CisJCWZvciAoaSA9IDA7IGkgPCBTSV9N QVhfRElTUF9SRUdJU1RFUlM7IGkrKykKKwkJCVdSRUczMl9BTkQoRENfSFBEeF9JTlRfQ09OVFJP TChpKSwKKwkJCQkgICBEQ19IUER4X0lOVF9QT0xBUklUWSk7CiAJfQogfQogCkBAIC02MDQ2LDEw ICs2MDM4LDkgQEAgc3RhdGljIGludCBzaV9pcnFfaW5pdChzdHJ1Y3QgcmFkZW9uX2RldmljZSAq cmRldikKIAogaW50IHNpX2lycV9zZXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7CisJ aW50IGk7CiAJdTMyIGNwX2ludF9jbnRsOwogCXUzMiBjcF9pbnRfY250bDEgPSAwLCBjcF9pbnRf Y250bDIgPSAwOwotCXUzMiBjcnRjMSA9IDAsIGNydGMyID0gMCwgY3J0YzMgPSAwLCBjcnRjNCA9 IDAsIGNydGM1ID0gMCwgY3J0YzYgPSAwOwotCXUzMiBocGQxID0gMCwgaHBkMiA9IDAsIGhwZDMg PSAwLCBocGQ0ID0gMCwgaHBkNSA9IDAsIGhwZDYgPSAwOwogCXUzMiBncmJtX2ludF9jbnRsID0g MDsKIAl1MzIgZG1hX2NudGwsIGRtYV9jbnRsMTsKIAl1MzIgdGhlcm1hbF9pbnQgPSAwOwpAQCAt NjA2OSwxNSArNjA2MCw2IEBAIGludCBzaV9pcnFfc2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpy ZGV2KQogCWNwX2ludF9jbnRsID0gUlJFRzMyKENQX0lOVF9DTlRMX1JJTkcwKSAmCiAJCShDTlRY X0JVU1lfSU5UX0VOQUJMRSB8IENOVFhfRU1QVFlfSU5UX0VOQUJMRSk7CiAKLQlpZiAoIUFTSUNf SVNfTk9EQ0UocmRldikpIHsKLQkJaHBkMSA9IFJSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MKSAm IH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7Ci0JCWhwZDIgPSBSUkVHMzIo RENfSFBEMl9JTlRfQ09OVFJPTCkgJiB+KERDX0hQRHhfSU5UX0VOIHwgRENfSFBEeF9SWF9JTlRf RU4pOwotCQlocGQzID0gUlJFRzMyKERDX0hQRDNfSU5UX0NPTlRST0wpICYgfihEQ19IUER4X0lO VF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQkJaHBkNCA9IFJSRUczMihEQ19IUEQ0X0lOVF9D T05UUk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7Ci0JCWhwZDUg PSBSUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCkgJiB+KERDX0hQRHhfSU5UX0VOIHwgRENfSFBE eF9SWF9JTlRfRU4pOwotCQlocGQ2ID0gUlJFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wpICYgfihE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQl9Ci0KIAlkbWFfY250bCA9IFJS RUczMihETUFfQ05UTCArIERNQTBfUkVHSVNURVJfT0ZGU0VUKSAmIH5UUkFQX0VOQUJMRTsKIAlk bWFfY250bDEgPSBSUkVHMzIoRE1BX0NOVEwgKyBETUExX1JFR0lTVEVSX09GRlNFVCkgJiB+VFJB UF9FTkFCTEU7CiAKQEAgLTYxMDYsNjAgKzYwODgsNiBAQCBpbnQgc2lfaXJxX3NldChzdHJ1Y3Qg cmFkZW9uX2RldmljZSAqcmRldikKIAkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBzdyBpbnQgZG1h MVxuIik7CiAJCWRtYV9jbnRsMSB8PSBUUkFQX0VOQUJMRTsKIAl9Ci0JaWYgKHJkZXYtPmlycS5j cnRjX3ZibGFua19pbnRbMF0gfHwKLQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFsw XSkpIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiB2YmxhbmsgMFxuIik7Ci0JCWNydGMxIHw9 IFZCTEFOS19JTlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbMV0g fHwKLQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFsxXSkpIHsKLQkJRFJNX0RFQlVH KCJzaV9pcnFfc2V0OiB2YmxhbmsgMVxuIik7Ci0JCWNydGMyIHw9IFZCTEFOS19JTlRfTUFTSzsK LQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbMl0gfHwKLQkgICAgYXRvbWljX3Jl YWQoJnJkZXYtPmlycS5wZmxpcFsyXSkpIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiB2Ymxh bmsgMlxuIik7Ci0JCWNydGMzIHw9IFZCTEFOS19JTlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYtPmly cS5jcnRjX3ZibGFua19pbnRbM10gfHwKLQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxp cFszXSkpIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiB2YmxhbmsgM1xuIik7Ci0JCWNydGM0 IHw9IFZCTEFOS19JTlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRb NF0gfHwKLQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFs0XSkpIHsKLQkJRFJNX0RF QlVHKCJzaV9pcnFfc2V0OiB2YmxhbmsgNFxuIik7Ci0JCWNydGM1IHw9IFZCTEFOS19JTlRfTUFT SzsKLQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbNV0gfHwKLQkgICAgYXRvbWlj X3JlYWQoJnJkZXYtPmlycS5wZmxpcFs1XSkpIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiB2 YmxhbmsgNVxuIik7Ci0JCWNydGM2IHw9IFZCTEFOS19JTlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYt PmlycS5ocGRbMF0pIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBocGQgMVxuIik7Ci0JCWhw ZDEgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYt PmlycS5ocGRbMV0pIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBocGQgMlxuIik7Ci0JCWhw ZDIgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYt PmlycS5ocGRbMl0pIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBocGQgM1xuIik7Ci0JCWhw ZDMgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYt PmlycS5ocGRbM10pIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBocGQgNFxuIik7Ci0JCWhw ZDQgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYt PmlycS5ocGRbNF0pIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBocGQgNVxuIik7Ci0JCWhw ZDUgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYt PmlycS5ocGRbNV0pIHsKLQkJRFJNX0RFQlVHKCJzaV9pcnFfc2V0OiBocGQgNlxuIik7Ci0JCWhw ZDYgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9CiAKIAlXUkVHMzIo Q1BfSU5UX0NOVExfUklORzAsIGNwX2ludF9jbnRsKTsKIAlXUkVHMzIoQ1BfSU5UX0NOVExfUklO RzEsIGNwX2ludF9jbnRsMSk7CkBAIC02MTc2LDE5ICs2MTA0LDYgQEAgaW50IHNpX2lycV9zZXQo c3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJfQogCiAJaWYgKHJkZXYtPm51bV9jcnRjID49 IDIpIHsKLQkJV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMwX1JFR0lTVEVSX09GRlNF VCwgY3J0YzEpOwotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJf T0ZGU0VULCBjcnRjMik7Ci0JfQotCWlmIChyZGV2LT5udW1fY3J0YyA+PSA0KSB7Ci0JCVdSRUcz MihJTlRfTUFTSyArIEVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIGNydGMzKTsKLQkJ V1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgY3J0YzQp OwotCX0KLQlpZiAocmRldi0+bnVtX2NydGMgPj0gNikgewotCQlXUkVHMzIoSU5UX01BU0sgKyBF VkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCBjcnRjNSk7Ci0JCVdSRUczMihJTlRfTUFT SyArIEVWRVJHUkVFTl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIGNydGM2KTsKLQl9Ci0KLQlpZiAo cmRldi0+bnVtX2NydGMgPj0gMikgewogCQlXUkVHMzIoR1JQSF9JTlRfQ09OVFJPTCArIEVWRVJH UkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQsCiAJCSAgICAgICBHUlBIX1BGTElQX0lOVF9NQVNL KTsKIAkJV1JFRzMyKEdSUEhfSU5UX0NPTlRST0wgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJf T0ZGU0VULApAQCAtNjIwOCwxMiArNjEyMywxOSBAQCBpbnQgc2lfaXJxX3NldChzdHJ1Y3QgcmFk ZW9uX2RldmljZSAqcmRldikKIAl9CiAKIAlpZiAoIUFTSUNfSVNfTk9EQ0UocmRldikpIHsKLQkJ V1JFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wsIGhwZDEpOwotCQlXUkVHMzIoRENfSFBEMl9JTlRf Q09OVFJPTCwgaHBkMik7Ci0JCVdSRUczMihEQ19IUEQzX0lOVF9DT05UUk9MLCBocGQzKTsKLQkJ V1JFRzMyKERDX0hQRDRfSU5UX0NPTlRST0wsIGhwZDQpOwotCQlXUkVHMzIoRENfSFBENV9JTlRf Q09OVFJPTCwgaHBkNSk7Ci0JCVdSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MLCBocGQ2KTsKKwkJ Zm9yIChpID0gMDsgaSA8IFNJX01BWF9ESVNQX1JFR0lTVEVSUzsgaSsrKSB7CisJCQlyYWRlb25f aXJxX2ttc19zZXRfaXJxX25fZW5hYmxlZCgKKwkJCSAgICByZGV2LCBEQ19IUER4X0lOVF9DT05U Uk9MKGkpLAorCQkJICAgIERDX0hQRHhfSU5UX0VOIHwgRENfSFBEeF9SWF9JTlRfRU4sCisJCQkg ICAgcmRldi0+aXJxLmhwZFtpXSwgIkhQRCIsIGkpOworCQl9CisJfQorCisJZm9yIChpID0gMDsg aSA8IHJkZXYtPm51bV9jcnRjOyBpKyspIHsKKwkJcmFkZW9uX2lycV9rbXNfc2V0X2lycV9uX2Vu YWJsZWQoCisJCSAgICByZGV2LCBJTlRfTUFTSyArIGNydGNfb2Zmc2V0c1tpXSwgVkJMQU5LX0lO VF9NQVNLLAorCQkgICAgcmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFtpXSB8fAorCQkgICAgYXRv bWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFtpXSksICJ2YmxhbmsiLCBpKTsKIAl9CiAKIAlXUkVH MzIoQ0dfVEhFUk1BTF9JTlQsIHRoZXJtYWxfaW50KTsKQEAgLTYyMjYsMTcgKzYxNDgsMTIgQEAg aW50IHNpX2lycV9zZXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAKIHN0YXRpYyBpbmxp bmUgdm9pZCBzaV9pcnFfYWNrKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogewotCXUzMiB0 bXA7CisJaW50IGk7CisJdTMyICpkaXNwX2ludCA9IHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdy ZWVuLmRpc3BfaW50OwogCiAJaWYgKEFTSUNfSVNfTk9EQ0UocmRldikpCiAJCXJldHVybjsKIAot CXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ID0gUlJFRzMyKERJU1BfSU5U RVJSVVBUX1NUQVRVUyk7Ci0JcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRf Y29udCA9IFJSRUczMihESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUUpOwotCXJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyID0gUlJFRzMyKERJU1BfSU5URVJS VVBUX1NUQVRVU19DT05USU5VRTIpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQzID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTMpOwot CXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ID0gUlJFRzMyKERJ U1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTQpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQ1ID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05U SU5VRTUpOwogCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmQxZ3JwaF9pbnQgPSBSUkVH MzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMwX1JFR0lTVEVSX09GRlNFVCk7CiAJ cmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZDJncnBoX2ludCA9IFJSRUczMihHUlBIX0lO VF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VUKTsKIAlpZiAocmRldi0+ bnVtX2NydGMgPj0gNCkgewpAQCAtNjI0OCwzMiArNjE2NSwzNCBAQCBzdGF0aWMgaW5saW5lIHZv aWQgc2lfaXJxX2FjayhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAkJcmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZDZncnBoX2ludCA9IFJSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBF VkVSR1JFRU5fQ1JUQzVfUkVHSVNURVJfT0ZGU0VUKTsKIAl9CiAKKwlmb3IgKGkgPSAwOyBpIDwg U0lfTUFYX0RJU1BfUkVHSVNURVJTOyBpKyspIHsKKwkJZGlzcF9pbnRbaV0gPSBSUkVHMzIoRElT UF9JTlRFUlJVUFRfU1RBVFVTKGkpKTsKKworCQlpZiAoZGlzcF9pbnRbaV0gJiBEQ19IUER4X0lO VEVSUlVQVCkKKwkJCVdSRUczMl9PUihEQ19IUER4X0lOVF9DT05UUk9MKGkpLCBEQ19IUER4X0lO VF9BQ0spOworCQlpZiAoZGlzcF9pbnRbaV0gJiBEQ19IUER4X1JYX0lOVEVSUlVQVCkKKwkJCVdS RUczMl9PUihEQ19IUER4X0lOVF9DT05UUk9MKGkpLCBEQ19IUER4X1JYX0lOVF9BQ0spOworCisJ CWlmIChpIDwgcmRldi0+bnVtX2NydGMpIHsKKwkJCWlmIChkaXNwX2ludFtpXSAmIExCX0R4X1ZC TEFOS19JTlRFUlJVUFQpCisJCQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBjcnRjX29mZnNldHNb aV0sCisJCQkJICAgICAgIFZCTEFOS19BQ0spOworCQkJaWYgKGRpc3BfaW50W2ldICYgTEJfRHhf VkxJTkVfSU5URVJSVVBUKQorCQkJCVdSRUczMihWTElORV9TVEFUVVMgKyBjcnRjX29mZnNldHNb aV0sCisJCQkJICAgICAgIFZMSU5FX0FDSyk7CisJCX0KKwl9CisKIAlpZiAocmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZDFncnBoX2ludCAmIEdSUEhfUEZMSVBfSU5UX09DQ1VSUkVEKQog CQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMwX1JFR0lTVEVSX09GRlNF VCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwogCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJn cmVlbi5kMmdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQpCiAJCVdSRUczMihHUlBI X0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULCBHUlBIX1BGTElQ X0lOVF9DTEVBUik7Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 ICYgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBFVkVS R1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQlpZiAocmRldi0+aXJx LnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBMQl9EMV9WTElORV9JTlRFUlJVUFQpCi0J CVdSRUczMihWTElORV9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBW TElORV9BQ0spOwotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9j b250ICYgTEJfRDJfVkJMQU5LX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBF VkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQlpZiAocmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmIExCX0QyX1ZMSU5FX0lOVEVS UlVQVCkKLQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RFUl9P RkZTRVQsIFZMSU5FX0FDSyk7CiAKIAlpZiAocmRldi0+bnVtX2NydGMgPj0gNCkgewogCQlpZiAo cmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZDNncnBoX2ludCAmIEdSUEhfUEZMSVBfSU5U X09DQ1VSUkVEKQogCQkJV1JFRzMyKEdSUEhfSU5UX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMl9S RUdJU1RFUl9PRkZTRVQsIEdSUEhfUEZMSVBfSU5UX0NMRUFSKTsKIAkJaWYgKHJkZXYtPmlycS5z dGF0X3JlZ3MuZXZlcmdyZWVuLmQ0Z3JwaF9pbnQgJiBHUlBIX1BGTElQX0lOVF9PQ0NVUlJFRCkK IAkJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzNfUkVHSVNURVJfT0ZG U0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7Ci0JCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIExCX0QzX1ZCTEFOS19JTlRFUlJVUFQpCi0JCQlXUkVH MzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIFZCTEFO S19BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29u dDIgJiBMQl9EM19WTElORV9JTlRFUlJVUFQpCi0JCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsgRVZF UkdSRUVOX0NSVEMyX1JFR0lTVEVSX09GRlNFVCwgVkxJTkVfQUNLKTsKLQkJaWYgKHJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICYgTEJfRDRfVkJMQU5LX0lOVEVS UlVQVCkKLQkJCVdSRUczMihWQkxBTktfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVS X09GRlNFVCwgVkJMQU5LX0FDSyk7Ci0JCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVl bi5kaXNwX2ludF9jb250MyAmIExCX0Q0X1ZMSU5FX0lOVEVSUlVQVCkKLQkJCVdSRUczMihWTElO RV9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzNfUkVHSVNURVJfT0ZGU0VULCBWTElORV9BQ0spOwog CX0KIAogCWlmIChyZGV2LT5udW1fY3J0YyA+PSA2KSB7CkBAIC02MjgxLDc2ICs2MjAwLDYgQEAg c3RhdGljIGlubGluZSB2b2lkIHNpX2lycV9hY2soc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYp CiAJCQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEM0X1JFR0lTVEVSX09G RlNFVCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwogCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5l dmVyZ3JlZW4uZDZncnBoX2ludCAmIEdSUEhfUEZMSVBfSU5UX09DQ1VSUkVEKQogCQkJV1JFRzMy KEdSUEhfSU5UX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIEdSUEhf UEZMSVBfSU5UX0NMRUFSKTsKLQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQ0ICYgTEJfRDVfVkJMQU5LX0lOVEVSUlVQVCkKLQkJCVdSRUczMihWQkxBTktf U1RBVFVTICsgRVZFUkdSRUVOX0NSVEM0X1JFR0lTVEVSX09GRlNFVCwgVkJMQU5LX0FDSyk7Ci0J CWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmIExCX0Q1 X1ZMSU5FX0lOVEVSUlVQVCkKLQkJCVdSRUczMihWTElORV9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JU QzRfUkVHSVNURVJfT0ZGU0VULCBWTElORV9BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVn cy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBMQl9ENl9WQkxBTktfSU5URVJSVVBUKQotCQkJ V1JFRzMyKFZCTEFOS19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzVfUkVHSVNURVJfT0ZGU0VULCBW QkxBTktfQUNLKTsKLQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 X2NvbnQ1ICYgTEJfRDZfVkxJTkVfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyAr IEVWRVJHUkVFTl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7Ci0JfQotCi0JaWYg KHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgRENfSFBEMV9JTlRFUlJV UFQpIHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wpOwotCQl0bXAgfD0gRENf SFBEeF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCwgdG1wKTsKLQl9Ci0J aWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBEQ19IUEQy X0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJPTCk7Ci0JCXRt cCB8PSBEQ19IUER4X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQyX0lOVF9DT05UUk9MLCB0bXAp OwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDIg JiBEQ19IUEQzX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEM19JTlRfQ09OVFJP TCk7Ci0JCXRtcCB8PSBEQ19IUER4X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQzX0lOVF9DT05U Uk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udDMgJiBEQ19IUEQ0X0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENF9J TlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ0 X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udDQgJiBEQ19IUEQ1X0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIo RENfSFBENV9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X0lOVF9BQ0s7Ci0JCVdSRUcz MihEQ19IUEQ1X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVn cy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBEQ19IUEQ2X0lOVEVSUlVQVCkgewotCQl0bXAg PSBSUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X0lOVF9BQ0s7 Ci0JCVdSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQotCWlmIChyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmIERDX0hQRDFfUlhfSU5URVJSVVBUKSB7 Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhf UlhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlm IChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250ICYgRENfSFBEMl9S WF9JTlRFUlJVUFQpIHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDJfSU5UX0NPTlRST0wpOwotCQl0 bXAgfD0gRENfSFBEeF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJPTCwg dG1wKTsKLQl9Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQyICYgRENfSFBEM19SWF9JTlRFUlJVUFQpIHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDNfSU5U X0NPTlRST0wpOwotCQl0bXAgfD0gRENfSFBEeF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBE M19JTlRfQ09OVFJPTCwgdG1wKTsKLQl9Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdy ZWVuLmRpc3BfaW50X2NvbnQzICYgRENfSFBENF9SWF9JTlRFUlJVUFQpIHsKLQkJdG1wID0gUlJF RzMyKERDX0hQRDRfSU5UX0NPTlRST0wpOwotCQl0bXAgfD0gRENfSFBEeF9SWF9JTlRfQUNLOwot CQlXUkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCwgdG1wKTsKLQl9Ci0JaWYgKHJkZXYtPmlycS5z dGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICYgRENfSFBENV9SWF9JTlRFUlJVUFQp IHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDVfSU5UX0NPTlRST0wpOwotCQl0bXAgfD0gRENfSFBE eF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCwgdG1wKTsKLQl9Ci0J aWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ1ICYgRENfSFBE Nl9SWF9JTlRFUlJVUFQpIHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wpOwot CQl0bXAgfD0gRENfSFBEeF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBENl9JTlRfQ09OVFJP TCwgdG1wKTsKIAl9CiB9CiAKQEAgLTY0MTIsNiArNjI2MSw5IEBAIHN0YXRpYyBpbmxpbmUgdTMy IHNpX2dldF9paF93cHRyKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogICovCiBpbnQgc2lf aXJxX3Byb2Nlc3Moc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiB7CisJdTMyICpkaXNwX2lu dCA9IHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50OworCXUzMiBjcnRjX2lk eCwgaHBkX2lkeDsKKwl1MzIgbWFzazsKIAl1MzIgd3B0cjsKIAl1MzIgcnB0cjsKIAl1MzIgc3Jj X2lkLCBzcmNfZGF0YSwgcmluZ19pZDsKQEAgLTY0MjAsNiArNjI3Miw3IEBAIGludCBzaV9pcnFf cHJvY2VzcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAlib29sIHF1ZXVlX2RwID0gZmFs c2U7CiAJYm9vbCBxdWV1ZV90aGVybWFsID0gZmFsc2U7CiAJdTMyIHN0YXR1cywgYWRkcjsKKwlj b25zdCBjaGFyICpldmVudF9uYW1lOwogCiAJaWYgKCFyZGV2LT5paC5lbmFibGVkIHx8IHJkZXYt PnNodXRkb3duKQogCQlyZXR1cm4gSVJRX05PTkU7CkBAIC02NDQ5LDE4NCArNjMwMiw0NCBAQCBp bnQgc2lfaXJxX3Byb2Nlc3Moc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAKIAkJc3dpdGNo IChzcmNfaWQpIHsKIAkJY2FzZSAxOiAvKiBEMSB2YmxhbmsvdmxpbmUgKi8KLQkJCXN3aXRjaCAo c3JjX2RhdGEpIHsKLQkJCWNhc2UgMDogLyogRDEgdmJsYW5rICovCi0JCQkJaWYgKCEocmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBMQl9EMV9WQkxBTktfSU5URVJSVVBU KSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4i KTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzBdKSB7Ci0JCQkJCWRybV9o YW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDApOwotCQkJCQlyZGV2LT5wbS52Ymxhbmtfc3luYyA9 IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYtPmlycS52YmxhbmtfcXVldWUpOwotCQkJCX0KLQkJ CQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFswXSkpCi0JCQkJCXJhZGVvbl9jcnRj X2hhbmRsZV92YmxhbmsocmRldiwgMCk7Ci0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnQgJj0gfkxCX0QxX1ZCTEFOS19JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJ SDogRDEgdmJsYW5rXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAxOiAvKiBEMSB2bGluZSAq LwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgTEJf RDFfVkxJTkVfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFz c2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVu LmRpc3BfaW50ICY9IH5MQl9EMV9WTElORV9JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDog RDEgdmxpbmVcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygi VW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOwotCQkJCWJy ZWFrOwotCQkJfQotCQkJYnJlYWs7CiAJCWNhc2UgMjogLyogRDIgdmJsYW5rL3ZsaW5lICovCi0J CQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQljYXNlIDA6IC8qIEQyIHZibGFuayAqLwotCQkJCWlm ICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBMQl9EMl9W QkxBTktfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2Vy dGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzFd KSB7Ci0JCQkJCWRybV9oYW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDEpOwotCQkJCQlyZGV2LT5w bS52Ymxhbmtfc3luYyA9IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYtPmlycS52YmxhbmtfcXVl dWUpOwotCQkJCX0KLQkJCQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFsxXSkpCi0J CQkJCXJhZGVvbl9jcnRjX2hhbmRsZV92YmxhbmsocmRldiwgMSk7Ci0JCQkJcmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmPSB+TEJfRDJfVkJMQU5LX0lOVEVSUlVQ VDsKLQkJCQlEUk1fREVCVUcoIklIOiBEMiB2YmxhbmtcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlj YXNlIDE6IC8qIEQyIHZsaW5lICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udCAmIExCX0QyX1ZMSU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9E RUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2 LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250ICY9IH5MQl9EMl9WTElORV9J TlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDIgdmxpbmVcbiIpOwotCi0JCQkJYnJlYWs7 Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRc biIsIHNyY19pZCwgc3JjX2RhdGEpOwotCQkJCWJyZWFrOwotCQkJfQotCQkJYnJlYWs7CiAJCWNh c2UgMzogLyogRDMgdmJsYW5rL3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQlj YXNlIDA6IC8qIEQzIHZibGFuayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQyICYgTEJfRDNfVkJMQU5LX0lOVEVSUlVQVCkpCi0JCQkJCURS TV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlp ZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsyXSkgewotCQkJCQlkcm1faGFuZGxlX3ZibGFu ayhyZGV2LT5kZGV2LCAyKTsKLQkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwotCQkJ CQl3YWtlX3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsKLQkJCQl9Ci0JCQkJaWYgKGF0b21p Y19yZWFkKCZyZGV2LT5pcnEucGZsaXBbMl0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJs YW5rKHJkZXYsIDIpOwotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 X2NvbnQyICY9IH5MQl9EM19WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQz IHZibGFua1xuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDMgdmxpbmUgKi8KLQkJ CQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIExC X0QzX1ZMSU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBh c3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVl bi5kaXNwX2ludF9jb250MiAmPSB+TEJfRDNfVkxJTkVfSU5URVJSVVBUOwotCQkJCURSTV9ERUJV RygiSUg6IEQzIHZsaW5lXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJZGVmYXVsdDoKLQkJCQlEUk1f REVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBzcmNfaWQsIHNyY19kYXRhKTsK LQkJCQlicmVhazsKLQkJCX0KLQkJCWJyZWFrOwogCQljYXNlIDQ6IC8qIEQ0IHZibGFuay92bGlu ZSAqLwotCQkJc3dpdGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAwOiAvKiBENCB2YmxhbmsgKi8K LQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAm IExCX0Q0X1ZCTEFOS19JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3 L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFu a19pbnRbM10pIHsKLQkJCQkJZHJtX2hhbmRsZV92YmxhbmsocmRldi0+ZGRldiwgMyk7Ci0JCQkJ CXJkZXYtPnBtLnZibGFua19zeW5jID0gdHJ1ZTsKLQkJCQkJd2FrZV91cCgmcmRldi0+aXJxLnZi bGFua19xdWV1ZSk7Ci0JCQkJfQotCQkJCWlmIChhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlw WzNdKSkKLQkJCQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhyZGV2LCAzKTsKLQkJCQlyZGV2 LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmPSB+TEJfRDRfVkJMQU5L X0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENCB2YmxhbmtcbiIpOwotCi0JCQkJYnJl YWs7Ci0JCQljYXNlIDE6IC8qIEQ0IHZsaW5lICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJiBMQl9ENF9WTElORV9JTlRFUlJVUFQpKQot CQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwot Ci0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJj0gfkxC X0Q0X1ZMSU5FX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENCB2bGluZVxuIik7Ci0K LQkJCQlicmVhazsKLQkJCWRlZmF1bHQ6Ci0JCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJy dXB0OiAlZCAlZFxuIiwgc3JjX2lkLCBzcmNfZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQli cmVhazsKIAkJY2FzZSA1OiAvKiBENSB2YmxhbmsvdmxpbmUgKi8KLQkJCXN3aXRjaCAoc3JjX2Rh dGEpIHsKLQkJCWNhc2UgMDogLyogRDUgdmJsYW5rICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WQkxBTktfSU5URVJSVVBU KSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4i KTsKKwkJY2FzZSA2OiAvKiBENiB2YmxhbmsvdmxpbmUgKi8KKwkJCWNydGNfaWR4ID0gc3JjX2lk IC0gMTsKKworCQkJaWYgKHNyY19kYXRhID09IDApIHsgLyogdmJsYW5rICovCisJCQkJbWFzayA9 IExCX0R4X1ZCTEFOS19JTlRFUlJVUFQ7CisJCQkJZXZlbnRfbmFtZSA9ICJ2YmxhbmsiOwogCi0J CQkJaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbNF0pIHsKLQkJCQkJZHJtX2hhbmRsZV92 YmxhbmsocmRldi0+ZGRldiwgNCk7CisJCQkJaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRb Y3J0Y19pZHhdKSB7CisJCQkJCWRybV9oYW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIGNydGNfaWR4 KTsKIAkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwogCQkJCQl3YWtlX3VwKCZyZGV2 LT5pcnEudmJsYW5rX3F1ZXVlKTsKIAkJCQl9Ci0JCQkJaWYgKGF0b21pY19yZWFkKCZyZGV2LT5p cnEucGZsaXBbNF0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJkZXYsIDQpOwot CQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICY9IH5MQl9E NV9WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQ1IHZibGFua1xuIik7Ci0K LQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDUgdmxpbmUgKi8KLQkJCQlpZiAoIShyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmIExCX0Q1X1ZMSU5FX0lOVEVS UlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0 P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250 NCAmPSB+TEJfRDVfVkxJTkVfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQ1IHZsaW5l XG4iKTsKKwkJCQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFtjcnRjX2lkeF0pKSB7 CisJCQkJCXJhZGVvbl9jcnRjX2hhbmRsZV92YmxhbmsocmRldiwKKwkJCQkJCQkJICBjcnRjX2lk eCk7CisJCQkJfQogCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygiVW5o YW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOworCQkJfSBlbHNl IGlmIChzcmNfZGF0YSA9PSAxKSB7IC8qIHZsaW5lICovCisJCQkJbWFzayA9IExCX0R4X1ZMSU5F X0lOVEVSUlVQVDsKKwkJCQlldmVudF9uYW1lID0gInZsaW5lIjsKKwkJCX0gZWxzZSB7CisJCQkJ RFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwKKwkJCQkJICBzcmNfaWQs IHNyY19kYXRhKTsKIAkJCQlicmVhazsKIAkJCX0KLQkJCWJyZWFrOwotCQljYXNlIDY6IC8qIEQ2 IHZibGFuay92bGluZSAqLwotCQkJc3dpdGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAwOiAvKiBE NiB2YmxhbmsgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNw X2ludF9jb250NSAmIExCX0Q2X1ZCTEFOS19JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklI OiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJaWYgKHJkZXYtPmly cS5jcnRjX3ZibGFua19pbnRbNV0pIHsKLQkJCQkJZHJtX2hhbmRsZV92YmxhbmsocmRldi0+ZGRl diwgNSk7Ci0JCQkJCXJkZXYtPnBtLnZibGFua19zeW5jID0gdHJ1ZTsKLQkJCQkJd2FrZV91cCgm cmRldi0+aXJxLnZibGFua19xdWV1ZSk7Ci0JCQkJfQotCQkJCWlmIChhdG9taWNfcmVhZCgmcmRl di0+aXJxLnBmbGlwWzVdKSkKLQkJCQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhyZGV2LCA1 KTsKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmPSB+ TEJfRDZfVkJMQU5LX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENiB2YmxhbmtcbiIp OwogCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6IC8qIEQ2IHZsaW5lICovCi0JCQkJaWYgKCEocmRl di0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBMQl9ENl9WTElORV9J TlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJx IGJpdD9cbiIpOworCQkJaWYgKCEoZGlzcF9pbnRbY3J0Y19pZHhdICYgbWFzaykpIHsKKwkJCQlE Uk1fREVCVUcoIklIOiBEJWQgJXMgLSBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIs CisJCQkJCSAgY3J0Y19pZHggKyAxLCBldmVudF9uYW1lKTsKKwkJCX0KIAotCQkJCXJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ1ICY9IH5MQl9ENl9WTElORV9JTlRF UlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDYgdmxpbmVcbiIpOworCQkJZGlzcF9pbnRbY3J0 Y19pZHhdICY9IH5tYXNrOworCQkJRFJNX0RFQlVHKCJJSDogRCVkICVzXG4iLCBjcnRjX2lkeCAr IDEsIGV2ZW50X25hbWUpOwogCi0JCQkJYnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJV RygiVW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOwotCQkJ CWJyZWFrOwotCQkJfQogCQkJYnJlYWs7CiAJCWNhc2UgODogLyogRDEgcGFnZSBmbGlwICovCiAJ CWNhc2UgMTA6IC8qIEQyIHBhZ2UgZmxpcCAqLwpAQCAtNjYzOSwxMTkgKzYzNTIsMjkgQEAgaW50 IHNpX2lycV9wcm9jZXNzKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCQkJCXJhZGVvbl9j cnRjX2hhbmRsZV9mbGlwKHJkZXYsIChzcmNfaWQgLSA4KSA+PiAxKTsKIAkJCWJyZWFrOwogCQlj YXNlIDQyOiAvKiBIUEQgaG90cGx1ZyAqLwotCQkJc3dpdGNoIChzcmNfZGF0YSkgewotCQkJY2Fz ZSAwOgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYg RENfSFBEMV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNz ZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZGlzcF9pbnQgJj0gfkRDX0hQRDFfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVl OwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDFcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6 Ci0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAm IERDX0hQRDJfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFz c2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVu LmRpc3BfaW50X2NvbnQgJj0gfkRDX0hQRDJfSU5URVJSVVBUOworCQkJaWYgKHNyY19kYXRhIDw9 IDUpIHsKKwkJCQlocGRfaWR4ID0gc3JjX2RhdGE7CisJCQkJbWFzayA9IERDX0hQRHhfSU5URVJS VVBUOwogCQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDJc biIpOworCQkJCWV2ZW50X25hbWUgPSAiSFBEIjsKIAotCQkJCWJyZWFrOwotCQkJY2FzZSAyOgot CQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyICYg RENfSFBEM19JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNz ZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZGlzcF9pbnRfY29udDIgJj0gfkRDX0hQRDNfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2hvdHBsdWcg PSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDNcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQlj YXNlIDM6Ci0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRf Y29udDMgJiBEQ19IUEQ0X0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50 IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kaXNwX2ludF9jb250MyAmPSB+RENfSFBENF9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVf aG90cGx1ZyA9IHRydWU7Ci0JCQkJRFJNX0RFQlVHKCJJSDogSFBENFxuIik7Ci0KLQkJCQlicmVh azsKLQkJCWNhc2UgNDoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5k aXNwX2ludF9jb250NCAmIERDX0hQRDVfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDog SUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0 X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICY9IH5EQ19IUEQ1X0lOVEVSUlVQVDsKLQkJ CQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQ1XG4iKTsKLQot CQkJCWJyZWFrOwotCQkJY2FzZSA1OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQ1ICYgRENfSFBENl9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVC VUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJj0gfkRDX0hQRDZfSU5URVJS VVBUOwotCQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDZc biIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDY6Ci0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBEQ19IUEQxX1JYX0lOVEVSUlVQVCkpCi0JCQkJCURS TV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQly ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmPSB+RENfSFBEMV9SWF9JTlRF UlJVUFQ7CisJCQl9IGVsc2UgaWYgKHNyY19kYXRhIDw9IDExKSB7CisJCQkJaHBkX2lkeCA9IHNy Y19kYXRhIC0gNjsKKwkJCQltYXNrID0gRENfSFBEeF9SWF9JTlRFUlJVUFQ7CiAJCQkJcXVldWVf ZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRF9SWCAxXG4iKTsKLQotCQkJCWJyZWFr OwotCQkJY2FzZSA3OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQgJiBEQ19IUEQyX1JYX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6 IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250ICY9IH5EQ19IUEQyX1JYX0lOVEVSUlVQVDsK LQkJCQlxdWV1ZV9kcCA9IHRydWU7Ci0JCQkJRFJNX0RFQlVHKCJJSDogSFBEX1JYIDJcbiIpOwot Ci0JCQkJYnJlYWs7Ci0JCQljYXNlIDg6Ci0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5l dmVyZ3JlZW4uZGlzcF9pbnRfY29udDIgJiBEQ19IUEQzX1JYX0lOVEVSUlVQVCkpCi0JCQkJCURS TV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQly ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmPSB+RENfSFBEM19S WF9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQ RF9SWCAzXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSA5OgotCQkJCWlmICghKHJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICYgRENfSFBENF9SWF9JTlRFUlJV UFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9c biIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMg Jj0gfkRDX0hQRDRfUlhfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2RwID0gdHJ1ZTsKLQkJCQlEUk1f REVCVUcoIklIOiBIUERfUlggNFxuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgMTA6Ci0JCQkJ aWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBEQ19I UEQ1X1JYX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3Nl cnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5k aXNwX2ludF9jb250NCAmPSB+RENfSFBENV9SWF9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfZHAgPSB0 cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRF9SWCA1XG4iKTsKKwkJCQlldmVudF9uYW1lID0g IkhQRF9SWCI7CiAKKwkJCX0gZWxzZSB7CisJCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJy dXB0OiAlZCAlZFxuIiwKKwkJCQkJICBzcmNfaWQsIHNyY19kYXRhKTsKIAkJCQlicmVhazsKLQkJ CWNhc2UgMTE6Ci0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udDUgJiBEQ19IUEQ2X1JYX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElI IGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7CisJCQl9CiAKLQkJCQlyZGV2LT5pcnEu c3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmPSB+RENfSFBENl9SWF9JTlRFUlJV UFQ7Ci0JCQkJcXVldWVfZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRF9SWCA2XG4i KTsKKwkJCWlmICghKGRpc3BfaW50W2hwZF9pZHhdICYgbWFzaykpCisJCQkJRFJNX0RFQlVHKCJJ SDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKIAotCQkJCWJyZWFrOwotCQkJ ZGVmYXVsdDoKLQkJCQlEUk1fREVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBz cmNfaWQsIHNyY19kYXRhKTsKLQkJCQlicmVhazsKLQkJCX0KKwkJCWRpc3BfaW50W2hwZF9pZHhd ICY9IH5tYXNrOworCQkJRFJNX0RFQlVHKCJJSDogJXMlZFxuIiwgZXZlbnRfbmFtZSwgaHBkX2lk eCArIDEpOwogCQkJYnJlYWs7CiAJCWNhc2UgOTY6CiAJCQlEUk1fRVJST1IoIlNSQk1fUkVBRF9F UlJPUjogMHgleFxuIiwgUlJFRzMyKFNSQk1fUkVBRF9FUlJPUikpOwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL3JhZGVvbi9zaWQuaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vc2lkLmgK aW5kZXggNjVhOTExZC4uMGVmNjhmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVv bi9zaWQuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3NpZC5oCkBAIC00Nyw2ICs0Nyw3 IEBACiAjZGVmaW5lIFNJX01BWF9MRFNfTlVNICAgICAgICAgICAweEZGRkYKICNkZWZpbmUgU0lf TUFYX1RDQyAgICAgICAgICAgICAgIDE2CiAjZGVmaW5lIFNJX01BWF9UQ0NfTUFTSyAgICAgICAg ICAweEZGRkYKKyNkZWZpbmUgU0lfTUFYX0RJU1BfUkVHSVNURVJTICAgIDYKIAogLyogU01DIElO RCBhY2Nlc3NvciByZWdzICovCiAjZGVmaW5lIFNNQ19JTkRfSU5ERVhfMCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIDB4MjAwCkBAIC04MjAsNDEgKzgyMSwyMCBAQAogIyAgICAgICBkZWZp bmUgVkJMQU5LX0lOVF9NQVNLICAgICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAwKQogIyAg ICAgICBkZWZpbmUgVkxJTkVfSU5UX01BU0sgICAgICAgICAgICAgICAgICAgICAgICAgICAoMSA8 PCA0KQogCi0jZGVmaW5lIERJU1BfSU5URVJSVVBUX1NUQVRVUyAgICAgICAgICAgICAgICAgICAg ICAgICAgIDB4NjBmNAotIyAgICAgICBkZWZpbmUgTEJfRDFfVkxJTkVfSU5URVJSVVBUICAgICAg ICAgICAgICAgICAgICAoMSA8PCAyKQotIyAgICAgICBkZWZpbmUgTEJfRDFfVkJMQU5LX0lOVEVS UlVQVCAgICAgICAgICAgICAgICAgICAoMSA8PCAzKQotIyAgICAgICBkZWZpbmUgRENfSFBEMV9J TlRFUlJVUFQgICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAxNykKLSMgICAgICAgZGVmaW5l IERDX0hQRDFfUlhfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTgpCisvKiAw eDYwZjQsIDB4NjBmOCwgMHg2MGZjLCAweDYxMDAsIDB4NjE0YywgMHg2MTUwICovCisjZGVmaW5l IERJU1BfSU5URVJSVVBUX1NUQVRVUyhpKSBcCisJKChpIDwgNCkgPyAweDYwZjQgKyAoMHg0ICog aSkgOiAweDYxNGMgKyAoMHg0ICogKGkgLSA0KSkpCisjICAgICAgIGRlZmluZSBMQl9EeF9WTElO RV9JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgICgxIDw8IDIpCisjICAgICAgIGRlZmluZSBM Ql9EeF9WQkxBTktfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICgxIDw8IDMpCisjICAgICAg IGRlZmluZSBEQ19IUER4X0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE3 KQorIyAgICAgICBkZWZpbmUgRENfSFBEeF9SWF9JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAg ICAoMSA8PCAxOCkKKy8qIEZpcnN0IHJlZyBvbmx5ICovCiAjICAgICAgIGRlZmluZSBEQUNBX0FV VE9ERVRFQ1RfSU5URVJSVVBUICAgICAgICAgICAgICAgICgxIDw8IDIyKQogIyAgICAgICBkZWZp bmUgREFDQl9BVVRPREVURUNUX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAoMSA8PCAyMykKICMg ICAgICAgZGVmaW5lIERDX0kyQ19TV19ET05FX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgKDEg PDwgMjQpCiAjICAgICAgIGRlZmluZSBEQ19JMkNfSFdfRE9ORV9JTlRFUlJVUFQgICAgICAgICAg ICAgICAgICgxIDw8IDI1KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUUg ICAgICAgICAgICAgICAgICAweDYwZjgKLSMgICAgICAgZGVmaW5lIExCX0QyX1ZMSU5FX0lOVEVS UlVQVCAgICAgICAgICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0QyX1ZC TEFOS19JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5l IERDX0hQRDJfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAg ICAgIGRlZmluZSBEQ19IUEQyX1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8 IDE4KQorLyogU2Vjb25kIHJlZyBvbmx5ICovCiAjICAgICAgIGRlZmluZSBESVNQX1RJTUVSX0lO VEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8IDI0KQotI2RlZmluZSBESVNQX0lOVEVS UlVQVF9TVEFUVVNfQ09OVElOVUUyICAgICAgICAgICAgICAgICAweDYwZmMKLSMgICAgICAgZGVm aW5lIExCX0QzX1ZMSU5FX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgKDEgPDwgMikKLSMg ICAgICAgZGVmaW5lIExCX0QzX1ZCTEFOS19JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgKDEg PDwgMykKLSMgICAgICAgZGVmaW5lIERDX0hQRDNfSU5URVJSVVBUICAgICAgICAgICAgICAgICAg ICAgICAgKDEgPDwgMTcpCi0jICAgICAgIGRlZmluZSBEQ19IUEQzX1JYX0lOVEVSUlVQVCAgICAg ICAgICAgICAgICAgICAgICgxIDw8IDE4KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNf Q09OVElOVUUzICAgICAgICAgICAgICAgICAweDYxMDAKLSMgICAgICAgZGVmaW5lIExCX0Q0X1ZM SU5FX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5l IExCX0Q0X1ZCTEFOS19JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAg ICAgZGVmaW5lIERDX0hQRDRfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwg MTcpCi0jICAgICAgIGRlZmluZSBEQ19IUEQ0X1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAg ICAgICgxIDw8IDE4KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUU0ICAg ICAgICAgICAgICAgICAweDYxNGMKLSMgICAgICAgZGVmaW5lIExCX0Q1X1ZMSU5FX0lOVEVSUlVQ VCAgICAgICAgICAgICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0Q1X1ZCTEFO S19JTlRFUlJVUFQgICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5lIERD X0hQRDVfSU5URVJSVVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAgICAg IGRlZmluZSBEQ19IUEQ1X1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE4 KQotI2RlZmluZSBESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUU1ICAgICAgICAgICAgICAg ICAweDYxNTAKLSMgICAgICAgZGVmaW5lIExCX0Q2X1ZMSU5FX0lOVEVSUlVQVCAgICAgICAgICAg ICAgICAgICAgKDEgPDwgMikKLSMgICAgICAgZGVmaW5lIExCX0Q2X1ZCTEFOS19JTlRFUlJVUFQg ICAgICAgICAgICAgICAgICAgKDEgPDwgMykKLSMgICAgICAgZGVmaW5lIERDX0hQRDZfSU5URVJS VVBUICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMTcpCi0jICAgICAgIGRlZmluZSBEQ19I UEQ2X1JYX0lOVEVSUlVQVCAgICAgICAgICAgICAgICAgICAgICgxIDw8IDE4KQogCiAvKiAweDY4 NTgsIDB4NzQ1OCwgMHgxMDA1OCwgMHgxMGM1OCwgMHgxMTg1OCwgMHgxMjQ1OCAqLwogI2RlZmlu ZSBHUlBIX0lOVF9TVEFUVVMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDY4NTgK QEAgLTg2NywzNyArODQ3LDI1IEBACiAKICNkZWZpbmUJREFDX0FVVE9ERVRFQ1RfSU5UX0NPTlRS T0wJCQkweDY3YzgKIAotI2RlZmluZSBEQ19IUEQxX0lOVF9TVEFUVVMgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAweDYwMWMKLSNkZWZpbmUgRENfSFBEMl9JTlRfU1RBVFVTICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgMHg2MDI4Ci0jZGVmaW5lIERDX0hQRDNfSU5UX1NUQVRVUyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4NjAzNAotI2RlZmluZSBEQ19IUEQ0X0lOVF9T VEFUVVMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDYwNDAKLSNkZWZpbmUgRENfSFBE NV9JTlRfU1RBVFVTICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDRjCi0jZGVmaW5l IERDX0hQRDZfSU5UX1NUQVRVUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4NjA1OAot IyAgICAgICBkZWZpbmUgRENfSFBEeF9JTlRfU1RBVFVTICAgICAgICAgICAgICAgICAgICAgICAo MSA8PCAwKQorLyogMHg2MDFjLCAweDYwMjgsIDB4NjAzNCwgMHg2MDQwLCAweDYwNGMsIDB4NjA1 OCAqLworI2RlZmluZSBEQ19IUER4X0lOVF9TVEFUVVMoeCkgICAgICAgICAgICAgICAgICAgICAg ICAgICAoMHg2MDFjICsgKDB4YyAqIHgpKQorIyAgICAgICBkZWZpbmUgRENfSFBEeF9JTlRfU1RB VFVTX01BU0sgICAgICAgICAgICAgICAgICAoMSA8PCAwKQogIyAgICAgICBkZWZpbmUgRENfSFBE eF9TRU5TRSAgICAgICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAxKQogIyAgICAgICBkZWZp bmUgRENfSFBEeF9SWF9JTlRfU1RBVFVTICAgICAgICAgICAgICAgICAgICAoMSA8PCA4KQogCi0j ZGVmaW5lIERDX0hQRDFfSU5UX0NPTlRST0wgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4 NjAyMAotI2RlZmluZSBEQ19IUEQyX0lOVF9DT05UUk9MICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAweDYwMmMKLSNkZWZpbmUgRENfSFBEM19JTlRfQ09OVFJPTCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgMHg2MDM4Ci0jZGVmaW5lIERDX0hQRDRfSU5UX0NPTlRST0wgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIDB4NjA0NAotI2RlZmluZSBEQ19IUEQ1X0lOVF9DT05UUk9MICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAweDYwNTAKLSNkZWZpbmUgRENfSFBENl9JTlRfQ09O VFJPTCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHg2MDVjCisvKiAweDYwMjAsIDB4NjAy YywgMHg2MDM4LCAweDYwNDQsIDB4NjA1MCwgMHg2MDVjICovCisjZGVmaW5lIERDX0hQRHhfSU5U X0NPTlRST0woeCkgICAgICAgICAgICAgICAgICAgICAgICAgICgweDYwMjAgKyAoMHhjICogeCkp CiAjICAgICAgIGRlZmluZSBEQ19IUER4X0lOVF9BQ0sgICAgICAgICAgICAgICAgICAgICAgICAg ICgxIDw8IDApCiAjICAgICAgIGRlZmluZSBEQ19IUER4X0lOVF9QT0xBUklUWSAgICAgICAgICAg ICAgICAgICAgICgxIDw8IDgpCiAjICAgICAgIGRlZmluZSBEQ19IUER4X0lOVF9FTiAgICAgICAg ICAgICAgICAgICAgICAgICAgICgxIDw8IDE2KQogIyAgICAgICBkZWZpbmUgRENfSFBEeF9SWF9J TlRfQUNLICAgICAgICAgICAgICAgICAgICAgICAoMSA8PCAyMCkKICMgICAgICAgZGVmaW5lIERD X0hQRHhfUlhfSU5UX0VOICAgICAgICAgICAgICAgICAgICAgICAgKDEgPDwgMjQpCiAKLSNkZWZp bmUgRENfSFBEMV9DT05UUk9MICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDYw MjQKLSNkZWZpbmUgRENfSFBEMl9DT05UUk9MICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAweDYwMzAKLSNkZWZpbmUgRENfSFBEM19DT05UUk9MICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAweDYwM2MKLSNkZWZpbmUgRENfSFBENF9DT05UUk9MICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAweDYwNDgKLSNkZWZpbmUgRENfSFBENV9DT05UUk9MICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDYwNTQKLSNkZWZpbmUgRENfSFBENl9D T05UUk9MICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweDYwNjAKLSMgICAgICAg ZGVmaW5lIERDX0hQRHhfQ09OTkVDVElPTl9USU1FUih4KSAgICAgICAgICAgICAgICAoKHgpIDw8 IDApCi0jICAgICAgIGRlZmluZSBEQ19IUER4X1JYX0lOVF9USU1FUih4KSAgICAgICAgICAgICAg ICAgICAgKCh4KSA8PCAxNikKLSMgICAgICAgZGVmaW5lIERDX0hQRHhfRU4gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAoMSA8PCAyOCkKKy8qIDB4NjAyNCwgMHg2MDMwLCAweDYwM2Ms IDB4NjA0OCwgMHg2MDU0LCAweDYwNjAgKi8KKyNkZWZpbmUgRENfSFBEeF9DT05UUk9MKHgpICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKDB4NjAyNCArICgweGMgKiB4KSkKKyMgICAgICAg ZGVmaW5lIERDX0hQRHhfQ09OTkVDVElPTl9USU1FUih4KSAgICAgICAgICAgICAgKCh4KSA8PCAw KQorIyAgICAgICBkZWZpbmUgRENfSFBEeF9SWF9JTlRfVElNRVIoeCkgICAgICAgICAgICAgICAg ICAoKHgpIDw8IDE2KQorIyAgICAgICBkZWZpbmUgRENfSFBEeF9FTiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAoMSA8PCAyOCkKIAogI2RlZmluZSBEUEdfUElQRV9TVFVUVEVSX0NPTlRS T0wgICAgICAgICAgICAgICAgICAgICAgICAgIDB4NmNkNAogIyAgICAgICBkZWZpbmUgU1RVVFRF Ul9FTkFCTEUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICgxIDw8IDApCi0tIAoyLjkuNAoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KYW1kLWdmeCBt YWlsaW5nIGxpc3QKYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbWQtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753158AbdEPVMi (ORCPT ); Tue, 16 May 2017 17:12:38 -0400 Received: from mx1.redhat.com ([209.132.183.28]:4652 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752875AbdEPVMY (ORCPT ); Tue, 16 May 2017 17:12:24 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com 8B40437E65 Authentication-Results: ext-mx05.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx05.extmail.prod.ext.phx2.redhat.com; spf=pass smtp.mailfrom=lyude@redhat.com DKIM-Filter: OpenDKIM Filter v2.11.0 mx1.redhat.com 8B40437E65 From: Lyude To: amd-gfx@lists.freedesktop.org Cc: Lyude , Alex Deucher , =?UTF-8?q?Christian=20K=C3=B6nig?= , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH 1/3] drm/radeon: Cleanup display interrupt handling for evergreen, si Date: Tue, 16 May 2017 17:11:58 -0400 Message-Id: <20170516211202.20325-2-lyude@redhat.com> In-Reply-To: <20170516211202.20325-1-lyude@redhat.com> References: <20170516211202.20325-1-lyude@redhat.com> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.29]); Tue, 16 May 2017 21:12:24 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The current code here is really, really bad. A huge amount of it looks to be copy pasted, it has some weird hatred of arrays and code sharing, switch cases everywhere for things that really don't need them, and it makes the file seem immensely more complex then it actually is. This is a pain for maintanence, and is vulnerable to more weird irq handling bugs. So, let's start cleaning this up a bit. Modify all of the IRQ handlers for evergreen/si so that they just use for loops. As well, we add a helper function radeon_irq_kms_set_irq_n_enabled(), whose purpose is just to update the state of registers that enable/disable interrupts while printing any changes to the set of enabled interrupts to the kernel log. There is one change here that doesn't look very important (testing hasn't shown that it changes anyything afaict), but should be noted in case this patch breaks something. The way the code originally handled enabling or acking IRQs went like this: - Check enable/interrupt status of all IRQs - Write back any acknowledgements, enablements, or disablements to IRQs, all at the same time But now with the helpers we've implemented, it goes a little more like this - For each IRQ: - Check enable/interrupt status - Write back ack/new status Signed-off-by: Lyude --- drivers/gpu/drm/radeon/evergreen.c | 699 ++++++-------------------------- drivers/gpu/drm/radeon/evergreend.h | 74 +--- drivers/gpu/drm/radeon/radeon.h | 13 +- drivers/gpu/drm/radeon/radeon_irq_kms.c | 35 ++ drivers/gpu/drm/radeon/si.c | 565 +++++--------------------- drivers/gpu/drm/radeon/sid.h | 72 +--- 6 files changed, 290 insertions(+), 1168 deletions(-) diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c index 0bf1035..35baf0a 100644 --- a/drivers/gpu/drm/radeon/evergreen.c +++ b/drivers/gpu/drm/radeon/evergreen.c @@ -1714,38 +1714,10 @@ void evergreen_pm_finish(struct radeon_device *rdev) */ bool evergreen_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd) { - bool connected = false; - - switch (hpd) { - case RADEON_HPD_1: - if (RREG32(DC_HPD1_INT_STATUS) & DC_HPDx_SENSE) - connected = true; - break; - case RADEON_HPD_2: - if (RREG32(DC_HPD2_INT_STATUS) & DC_HPDx_SENSE) - connected = true; - break; - case RADEON_HPD_3: - if (RREG32(DC_HPD3_INT_STATUS) & DC_HPDx_SENSE) - connected = true; - break; - case RADEON_HPD_4: - if (RREG32(DC_HPD4_INT_STATUS) & DC_HPDx_SENSE) - connected = true; - break; - case RADEON_HPD_5: - if (RREG32(DC_HPD5_INT_STATUS) & DC_HPDx_SENSE) - connected = true; - break; - case RADEON_HPD_6: - if (RREG32(DC_HPD6_INT_STATUS) & DC_HPDx_SENSE) - connected = true; - break; - default: - break; - } + if (hpd == RADEON_HPD_NONE) + return false; - return connected; + return !!(RREG32(DC_HPDx_INT_STATUS(hpd)) & DC_HPDx_SENSE); } /** @@ -1759,61 +1731,15 @@ bool evergreen_hpd_sense(struct radeon_device *rdev, enum radeon_hpd_id hpd) void evergreen_hpd_set_polarity(struct radeon_device *rdev, enum radeon_hpd_id hpd) { - u32 tmp; bool connected = evergreen_hpd_sense(rdev, hpd); - switch (hpd) { - case RADEON_HPD_1: - tmp = RREG32(DC_HPD1_INT_CONTROL); - if (connected) - tmp &= ~DC_HPDx_INT_POLARITY; - else - tmp |= DC_HPDx_INT_POLARITY; - WREG32(DC_HPD1_INT_CONTROL, tmp); - break; - case RADEON_HPD_2: - tmp = RREG32(DC_HPD2_INT_CONTROL); - if (connected) - tmp &= ~DC_HPDx_INT_POLARITY; - else - tmp |= DC_HPDx_INT_POLARITY; - WREG32(DC_HPD2_INT_CONTROL, tmp); - break; - case RADEON_HPD_3: - tmp = RREG32(DC_HPD3_INT_CONTROL); - if (connected) - tmp &= ~DC_HPDx_INT_POLARITY; - else - tmp |= DC_HPDx_INT_POLARITY; - WREG32(DC_HPD3_INT_CONTROL, tmp); - break; - case RADEON_HPD_4: - tmp = RREG32(DC_HPD4_INT_CONTROL); - if (connected) - tmp &= ~DC_HPDx_INT_POLARITY; - else - tmp |= DC_HPDx_INT_POLARITY; - WREG32(DC_HPD4_INT_CONTROL, tmp); - break; - case RADEON_HPD_5: - tmp = RREG32(DC_HPD5_INT_CONTROL); - if (connected) - tmp &= ~DC_HPDx_INT_POLARITY; - else - tmp |= DC_HPDx_INT_POLARITY; - WREG32(DC_HPD5_INT_CONTROL, tmp); - break; - case RADEON_HPD_6: - tmp = RREG32(DC_HPD6_INT_CONTROL); - if (connected) - tmp &= ~DC_HPDx_INT_POLARITY; - else - tmp |= DC_HPDx_INT_POLARITY; - WREG32(DC_HPD6_INT_CONTROL, tmp); - break; - default: - break; - } + if (hpd == RADEON_HPD_NONE) + return; + + if (connected) + WREG32_AND(DC_HPDx_INT_CONTROL(hpd), ~DC_HPDx_INT_POLARITY); + else + WREG32_OR(DC_HPDx_INT_CONTROL(hpd), DC_HPDx_INT_POLARITY); } /** @@ -1833,7 +1759,8 @@ void evergreen_hpd_init(struct radeon_device *rdev) DC_HPDx_RX_INT_TIMER(0xfa) | DC_HPDx_EN; list_for_each_entry(connector, &dev->mode_config.connector_list, head) { - struct radeon_connector *radeon_connector = to_radeon_connector(connector); + enum radeon_hpd_id hpd = + to_radeon_connector(connector)->hpd.hpd; if (connector->connector_type == DRM_MODE_CONNECTOR_eDP || connector->connector_type == DRM_MODE_CONNECTOR_LVDS) { @@ -1844,31 +1771,14 @@ void evergreen_hpd_init(struct radeon_device *rdev) */ continue; } - switch (radeon_connector->hpd.hpd) { - case RADEON_HPD_1: - WREG32(DC_HPD1_CONTROL, tmp); - break; - case RADEON_HPD_2: - WREG32(DC_HPD2_CONTROL, tmp); - break; - case RADEON_HPD_3: - WREG32(DC_HPD3_CONTROL, tmp); - break; - case RADEON_HPD_4: - WREG32(DC_HPD4_CONTROL, tmp); - break; - case RADEON_HPD_5: - WREG32(DC_HPD5_CONTROL, tmp); - break; - case RADEON_HPD_6: - WREG32(DC_HPD6_CONTROL, tmp); - break; - default: - break; - } - radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd); - if (radeon_connector->hpd.hpd != RADEON_HPD_NONE) - enabled |= 1 << radeon_connector->hpd.hpd; + + if (hpd == RADEON_HPD_NONE) + continue; + + WREG32(DC_HPDx_CONTROL(hpd), tmp); + enabled |= 1 << hpd; + + radeon_hpd_set_polarity(rdev, hpd); } radeon_irq_kms_enable_hpd(rdev, enabled); } @@ -1888,31 +1798,14 @@ void evergreen_hpd_fini(struct radeon_device *rdev) unsigned disabled = 0; list_for_each_entry(connector, &dev->mode_config.connector_list, head) { - struct radeon_connector *radeon_connector = to_radeon_connector(connector); - switch (radeon_connector->hpd.hpd) { - case RADEON_HPD_1: - WREG32(DC_HPD1_CONTROL, 0); - break; - case RADEON_HPD_2: - WREG32(DC_HPD2_CONTROL, 0); - break; - case RADEON_HPD_3: - WREG32(DC_HPD3_CONTROL, 0); - break; - case RADEON_HPD_4: - WREG32(DC_HPD4_CONTROL, 0); - break; - case RADEON_HPD_5: - WREG32(DC_HPD5_CONTROL, 0); - break; - case RADEON_HPD_6: - WREG32(DC_HPD6_CONTROL, 0); - break; - default: - break; - } - if (radeon_connector->hpd.hpd != RADEON_HPD_NONE) - disabled |= 1 << radeon_connector->hpd.hpd; + enum radeon_hpd_id hpd = + to_radeon_connector(connector)->hpd.hpd; + + if (hpd == RADEON_HPD_NONE) + continue; + + WREG32(DC_HPDx_CONTROL(hpd), 0); + disabled |= 1 << hpd; } radeon_irq_kms_disable_hpd(rdev, disabled); } @@ -4543,6 +4436,7 @@ u32 evergreen_get_vblank_counter(struct radeon_device *rdev, int crtc) void evergreen_disable_interrupt_state(struct radeon_device *rdev) { + int i; u32 tmp; if (rdev->family >= CHIP_CAYMAN) { @@ -4558,16 +4452,8 @@ void evergreen_disable_interrupt_state(struct radeon_device *rdev) WREG32(DMA_CNTL, tmp); WREG32(GRBM_INT_CNTL, 0); WREG32(SRBM_INT_CNTL, 0); - WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0); - WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0); - if (rdev->num_crtc >= 4) { - WREG32(INT_MASK + EVERGREEN_CRTC2_REGISTER_OFFSET, 0); - WREG32(INT_MASK + EVERGREEN_CRTC3_REGISTER_OFFSET, 0); - } - if (rdev->num_crtc >= 6) { - WREG32(INT_MASK + EVERGREEN_CRTC4_REGISTER_OFFSET, 0); - WREG32(INT_MASK + EVERGREEN_CRTC5_REGISTER_OFFSET, 0); - } + for (i = 0; i < rdev->num_crtc; i++) + WREG32(INT_MASK + crtc_offsets[i], 0); WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET, 0); WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET, 0); @@ -4585,27 +4471,15 @@ void evergreen_disable_interrupt_state(struct radeon_device *rdev) WREG32(DACA_AUTODETECT_INT_CONTROL, 0); WREG32(DACB_AUTODETECT_INT_CONTROL, 0); - tmp = RREG32(DC_HPD1_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD1_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD2_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD2_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD3_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD3_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD4_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD4_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD5_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD5_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD6_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD6_INT_CONTROL, tmp); - + for (i = 0; i < EVERGREEN_MAX_DISP_REGISTERS; i++) + WREG32_AND(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_POLARITY); } int evergreen_irq_set(struct radeon_device *rdev) { + int i; u32 cp_int_cntl = CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE; u32 cp_int_cntl1 = 0, cp_int_cntl2 = 0; - u32 crtc1 = 0, crtc2 = 0, crtc3 = 0, crtc4 = 0, crtc5 = 0, crtc6 = 0; - u32 hpd1, hpd2, hpd3, hpd4, hpd5, hpd6; u32 grbm_int_cntl = 0; u32 afmt1 = 0, afmt2 = 0, afmt3 = 0, afmt4 = 0, afmt5 = 0, afmt6 = 0; u32 dma_cntl, dma_cntl1 = 0; @@ -4623,12 +4497,6 @@ int evergreen_irq_set(struct radeon_device *rdev) return 0; } - hpd1 = RREG32(DC_HPD1_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd2 = RREG32(DC_HPD2_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd3 = RREG32(DC_HPD3_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd4 = RREG32(DC_HPD4_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd5 = RREG32(DC_HPD5_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd6 = RREG32(DC_HPD6_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); if (rdev->family == CHIP_ARUBA) thermal_int = RREG32(TN_CG_THERMAL_INT_CTRL) & ~(THERM_INT_MASK_HIGH | THERM_INT_MASK_LOW); @@ -4685,60 +4553,6 @@ int evergreen_irq_set(struct radeon_device *rdev) thermal_int |= THERM_INT_MASK_HIGH | THERM_INT_MASK_LOW; } - if (rdev->irq.crtc_vblank_int[0] || - atomic_read(&rdev->irq.pflip[0])) { - DRM_DEBUG("evergreen_irq_set: vblank 0\n"); - crtc1 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[1] || - atomic_read(&rdev->irq.pflip[1])) { - DRM_DEBUG("evergreen_irq_set: vblank 1\n"); - crtc2 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[2] || - atomic_read(&rdev->irq.pflip[2])) { - DRM_DEBUG("evergreen_irq_set: vblank 2\n"); - crtc3 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[3] || - atomic_read(&rdev->irq.pflip[3])) { - DRM_DEBUG("evergreen_irq_set: vblank 3\n"); - crtc4 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[4] || - atomic_read(&rdev->irq.pflip[4])) { - DRM_DEBUG("evergreen_irq_set: vblank 4\n"); - crtc5 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[5] || - atomic_read(&rdev->irq.pflip[5])) { - DRM_DEBUG("evergreen_irq_set: vblank 5\n"); - crtc6 |= VBLANK_INT_MASK; - } - if (rdev->irq.hpd[0]) { - DRM_DEBUG("evergreen_irq_set: hpd 1\n"); - hpd1 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[1]) { - DRM_DEBUG("evergreen_irq_set: hpd 2\n"); - hpd2 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[2]) { - DRM_DEBUG("evergreen_irq_set: hpd 3\n"); - hpd3 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[3]) { - DRM_DEBUG("evergreen_irq_set: hpd 4\n"); - hpd4 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[4]) { - DRM_DEBUG("evergreen_irq_set: hpd 5\n"); - hpd5 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[5]) { - DRM_DEBUG("evergreen_irq_set: hpd 6\n"); - hpd6 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } if (rdev->irq.afmt[0]) { DRM_DEBUG("evergreen_irq_set: hdmi 0\n"); afmt1 |= AFMT_AZ_FORMAT_WTRIG_MASK; @@ -4778,17 +4592,6 @@ int evergreen_irq_set(struct radeon_device *rdev) WREG32(GRBM_INT_CNTL, grbm_int_cntl); - WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, crtc1); - WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, crtc2); - if (rdev->num_crtc >= 4) { - WREG32(INT_MASK + EVERGREEN_CRTC2_REGISTER_OFFSET, crtc3); - WREG32(INT_MASK + EVERGREEN_CRTC3_REGISTER_OFFSET, crtc4); - } - if (rdev->num_crtc >= 6) { - WREG32(INT_MASK + EVERGREEN_CRTC4_REGISTER_OFFSET, crtc5); - WREG32(INT_MASK + EVERGREEN_CRTC5_REGISTER_OFFSET, crtc6); - } - WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET, GRPH_PFLIP_INT_MASK); WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET, @@ -4806,12 +4609,21 @@ int evergreen_irq_set(struct radeon_device *rdev) GRPH_PFLIP_INT_MASK); } - WREG32(DC_HPD1_INT_CONTROL, hpd1); - WREG32(DC_HPD2_INT_CONTROL, hpd2); - WREG32(DC_HPD3_INT_CONTROL, hpd3); - WREG32(DC_HPD4_INT_CONTROL, hpd4); - WREG32(DC_HPD5_INT_CONTROL, hpd5); - WREG32(DC_HPD6_INT_CONTROL, hpd6); + for (i = 0; i < EVERGREEN_MAX_DISP_REGISTERS; i++) { + radeon_irq_kms_set_irq_n_enabled(rdev, + DC_HPDx_INT_CONTROL(i), + DC_HPDx_INT_EN | + DC_HPDx_RX_INT_EN, + rdev->irq.hpd[i], "HPD", i); + + if (i < rdev->num_crtc) { + radeon_irq_kms_set_irq_n_enabled( + rdev, INT_MASK + crtc_offsets[i], VBLANK_INT_MASK, + rdev->irq.crtc_vblank_int[i] || + atomic_read(&rdev->irq.pflip[i]), "vblank", i); + } + } + if (rdev->family == CHIP_ARUBA) WREG32(TN_CG_THERMAL_INT_CTRL, thermal_int); else @@ -4832,14 +4644,28 @@ int evergreen_irq_set(struct radeon_device *rdev) static void evergreen_irq_ack(struct radeon_device *rdev) { + int i; + u32 *disp_int = rdev->irq.stat_regs.evergreen.disp_int; u32 tmp; - rdev->irq.stat_regs.evergreen.disp_int = RREG32(DISP_INTERRUPT_STATUS); - rdev->irq.stat_regs.evergreen.disp_int_cont = RREG32(DISP_INTERRUPT_STATUS_CONTINUE); - rdev->irq.stat_regs.evergreen.disp_int_cont2 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE2); - rdev->irq.stat_regs.evergreen.disp_int_cont3 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE3); - rdev->irq.stat_regs.evergreen.disp_int_cont4 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE4); - rdev->irq.stat_regs.evergreen.disp_int_cont5 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE5); + for (i = 0; i < EVERGREEN_MAX_DISP_REGISTERS; i++) { + disp_int[i] = RREG32(DISP_INTERRUPT_STATUS(i)); + + if (disp_int[i] & DC_HPDx_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_ACK); + if (disp_int[i] & DC_HPDx_RX_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_RX_INT_ACK); + + if (i < rdev->num_crtc) { + if (disp_int[i] & LB_Dx_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[i], + VBLANK_ACK); + if (disp_int[i] & LB_Dx_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[i], + VLINE_ACK); + } + } + rdev->irq.stat_regs.evergreen.d1grph_int = RREG32(GRPH_INT_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET); rdev->irq.stat_regs.evergreen.d2grph_int = RREG32(GRPH_INT_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET); if (rdev->num_crtc >= 4) { @@ -4862,28 +4688,12 @@ static void evergreen_irq_ack(struct radeon_device *rdev) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); if (rdev->irq.stat_regs.evergreen.d2grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); - if (rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET, VLINE_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET, VLINE_ACK); if (rdev->num_crtc >= 4) { if (rdev->irq.stat_regs.evergreen.d3grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC2_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); if (rdev->irq.stat_regs.evergreen.d4grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC3_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC2_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC2_REGISTER_OFFSET, VLINE_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC3_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC3_REGISTER_OFFSET, VLINE_ACK); } if (rdev->num_crtc >= 6) { @@ -4891,76 +4701,6 @@ static void evergreen_irq_ack(struct radeon_device *rdev) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC4_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); if (rdev->irq.stat_regs.evergreen.d6grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC4_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC4_REGISTER_OFFSET, VLINE_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET, VLINE_ACK); - } - - if (rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_INTERRUPT) { - tmp = RREG32(DC_HPD1_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD1_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_INTERRUPT) { - tmp = RREG32(DC_HPD2_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD2_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_INTERRUPT) { - tmp = RREG32(DC_HPD3_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD3_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_INTERRUPT) { - tmp = RREG32(DC_HPD4_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD4_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_INTERRUPT) { - tmp = RREG32(DC_HPD5_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD5_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_INTERRUPT) { - tmp = RREG32(DC_HPD6_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD6_INT_CONTROL, tmp); - } - - if (rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_RX_INTERRUPT) { - tmp = RREG32(DC_HPD1_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD1_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_RX_INTERRUPT) { - tmp = RREG32(DC_HPD2_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD2_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_RX_INTERRUPT) { - tmp = RREG32(DC_HPD3_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD3_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_RX_INTERRUPT) { - tmp = RREG32(DC_HPD4_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD4_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_RX_INTERRUPT) { - tmp = RREG32(DC_HPD5_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD5_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_RX_INTERRUPT) { - tmp = RREG32(DC_HPD6_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD6_INT_CONTROL, tmp); } if (rdev->irq.stat_regs.evergreen.afmt_status1 & AFMT_AZ_FORMAT_WTRIG) { @@ -5037,6 +4777,9 @@ static u32 evergreen_get_ih_wptr(struct radeon_device *rdev) int evergreen_irq_process(struct radeon_device *rdev) { + u32 *disp_int = rdev->irq.stat_regs.evergreen.disp_int; + u32 crtc_idx, hpd_idx; + u32 mask; u32 wptr; u32 rptr; u32 src_id, src_data; @@ -5046,6 +4789,7 @@ int evergreen_irq_process(struct radeon_device *rdev) bool queue_dp = false; bool queue_thermal = false; u32 status, addr; + const char *event_name; if (!rdev->ih.enabled || rdev->shutdown) return IRQ_NONE; @@ -5074,184 +4818,44 @@ int evergreen_irq_process(struct radeon_device *rdev) switch (src_id) { case 1: /* D1 vblank/vline */ - switch (src_data) { - case 0: /* D1 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: D1 vblank - IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[0]) { - drm_handle_vblank(rdev->ddev, 0); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[0])) - radeon_crtc_handle_vblank(rdev, 0); - rdev->irq.stat_regs.evergreen.disp_int &= ~LB_D1_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D1 vblank\n"); - - break; - case 1: /* D1 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VLINE_INTERRUPT)) - DRM_DEBUG("IH: D1 vline - IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int &= ~LB_D1_VLINE_INTERRUPT; - DRM_DEBUG("IH: D1 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 2: /* D2 vblank/vline */ - switch (src_data) { - case 0: /* D2 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: D2 vblank - IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[1]) { - drm_handle_vblank(rdev->ddev, 1); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[1])) - radeon_crtc_handle_vblank(rdev, 1); - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~LB_D2_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D2 vblank\n"); - - break; - case 1: /* D2 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VLINE_INTERRUPT)) - DRM_DEBUG("IH: D2 vline - IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~LB_D2_VLINE_INTERRUPT; - DRM_DEBUG("IH: D2 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 3: /* D3 vblank/vline */ - switch (src_data) { - case 0: /* D3 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: D3 vblank - IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[2]) { - drm_handle_vblank(rdev->ddev, 2); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[2])) - radeon_crtc_handle_vblank(rdev, 2); - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~LB_D3_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D3 vblank\n"); - - break; - case 1: /* D3 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VLINE_INTERRUPT)) - DRM_DEBUG("IH: D3 vline - IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~LB_D3_VLINE_INTERRUPT; - DRM_DEBUG("IH: D3 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 4: /* D4 vblank/vline */ - switch (src_data) { - case 0: /* D4 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: D4 vblank - IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[3]) { - drm_handle_vblank(rdev->ddev, 3); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[3])) - radeon_crtc_handle_vblank(rdev, 3); - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~LB_D4_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D4 vblank\n"); - - break; - case 1: /* D4 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VLINE_INTERRUPT)) - DRM_DEBUG("IH: D4 vline - IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~LB_D4_VLINE_INTERRUPT; - DRM_DEBUG("IH: D4 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 5: /* D5 vblank/vline */ - switch (src_data) { - case 0: /* D5 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: D5 vblank - IH event w/o asserted irq bit?\n"); + case 6: /* D6 vblank/vline */ + crtc_idx = src_id - 1; - if (rdev->irq.crtc_vblank_int[4]) { - drm_handle_vblank(rdev->ddev, 4); + if (src_data == 0) { /* vblank */ + mask = LB_Dx_VBLANK_INTERRUPT; + event_name = "vblank"; + + if (rdev->irq.crtc_vblank_int[crtc_idx]) { + drm_handle_vblank(rdev->ddev, crtc_idx); rdev->pm.vblank_sync = true; wake_up(&rdev->irq.vblank_queue); } - if (atomic_read(&rdev->irq.pflip[4])) - radeon_crtc_handle_vblank(rdev, 4); - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~LB_D5_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D5 vblank\n"); - - break; - case 1: /* D5 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VLINE_INTERRUPT)) - DRM_DEBUG("IH: D5 vline - IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~LB_D5_VLINE_INTERRUPT; - DRM_DEBUG("IH: D5 vline\n"); + if (atomic_read(&rdev->irq.pflip[crtc_idx])) { + radeon_crtc_handle_vblank(rdev, + crtc_idx); + } - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); + } else if (src_data == 1) { /* vline */ + mask = LB_Dx_VLINE_INTERRUPT; + event_name = "vline"; + } else { + DRM_DEBUG("Unhandled interrupt: %d %d\n", + src_id, src_data); break; } - break; - case 6: /* D6 vblank/vline */ - switch (src_data) { - case 0: /* D6 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: D6 vblank - IH event w/o asserted irq bit?\n"); - if (rdev->irq.crtc_vblank_int[5]) { - drm_handle_vblank(rdev->ddev, 5); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[5])) - radeon_crtc_handle_vblank(rdev, 5); - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~LB_D6_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D6 vblank\n"); - - break; - case 1: /* D6 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VLINE_INTERRUPT)) - DRM_DEBUG("IH: D6 vline - IH event w/o asserted irq bit?\n"); + if (!(disp_int[crtc_idx] & mask)) { + DRM_DEBUG("IH: D%d %s - IH event w/o asserted irq bit?\n", + crtc_idx + 1, event_name); + } - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~LB_D6_VLINE_INTERRUPT; - DRM_DEBUG("IH: D6 vline\n"); + disp_int[crtc_idx] &= ~mask; + DRM_DEBUG("IH: D%d %s\n", crtc_idx + 1, event_name); - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } break; case 8: /* D1 page flip */ case 10: /* D2 page flip */ @@ -5264,107 +4868,30 @@ int evergreen_irq_process(struct radeon_device *rdev) radeon_crtc_handle_flip(rdev, (src_id - 8) >> 1); break; case 42: /* HPD hotplug */ - switch (src_data) { - case 0: - if (!(rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int &= ~DC_HPD1_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD1\n"); - break; - case 1: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~DC_HPD2_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD2\n"); - break; - case 2: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~DC_HPD3_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD3\n"); - break; - case 3: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~DC_HPD4_INTERRUPT; + if (src_data <= 5) { + hpd_idx = src_data; + mask = DC_HPDx_INTERRUPT; queue_hotplug = true; - DRM_DEBUG("IH: HPD4\n"); - break; - case 4: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + event_name = "HPD"; - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~DC_HPD5_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD5\n"); - break; - case 5: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~DC_HPD6_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD6\n"); - break; - case 6: - if (!(rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int &= ~DC_HPD1_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 1\n"); - break; - case 7: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~DC_HPD2_RX_INTERRUPT; + } else if (src_data <= 11) { + hpd_idx = src_data - 6; + mask = DC_HPDx_RX_INTERRUPT; queue_dp = true; - DRM_DEBUG("IH: HPD_RX 2\n"); - break; - case 8: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + event_name = "HPD_RX"; - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~DC_HPD3_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 3\n"); + } else { + DRM_DEBUG("Unhandled interrupt: %d %d\n", + src_id, src_data); break; - case 9: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + } - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~DC_HPD4_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 4\n"); - break; - case 10: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + if (!(disp_int[hpd_idx] & mask)) + DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~DC_HPD5_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 5\n"); - break; - case 11: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + disp_int[hpd_idx] &= ~mask; + DRM_DEBUG("IH: %s%d\n", event_name, hpd_idx + 1); - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~DC_HPD6_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 6\n"); - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } break; case 44: /* hdmi */ switch (src_data) { diff --git a/drivers/gpu/drm/radeon/evergreend.h b/drivers/gpu/drm/radeon/evergreend.h index f3d88ca..56d1e7e 100644 --- a/drivers/gpu/drm/radeon/evergreend.h +++ b/drivers/gpu/drm/radeon/evergreend.h @@ -36,6 +36,7 @@ #define EVERGREEN_MAX_PIPES 8 #define EVERGREEN_MAX_PIPES_MASK 0xFF #define EVERGREEN_MAX_LDS_NUM 0xFFFF +#define EVERGREEN_MAX_DISP_REGISTERS 6 #define CYPRESS_GB_ADDR_CONFIG_GOLDEN 0x02011003 #define BARTS_GB_ADDR_CONFIG_GOLDEN 0x02011003 @@ -1285,85 +1286,52 @@ # define VBLANK_INT_MASK (1 << 0) # define VLINE_INT_MASK (1 << 4) -#define DISP_INTERRUPT_STATUS 0x60f4 -# define LB_D1_VLINE_INTERRUPT (1 << 2) -# define LB_D1_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD1_INTERRUPT (1 << 17) -# define DC_HPD1_RX_INTERRUPT (1 << 18) +/* 0x60f4, 0x60f8, 0x60fc, 0x6100, 0x614c, 0x6150 */ +#define DISP_INTERRUPT_STATUS(i) \ + ((i < 4) ? 0x60f4 + (0x4 * i) : 0x614c + (0x4 * (i - 4))) +# define LB_Dx_VLINE_INTERRUPT (1 << 2) +# define LB_Dx_VBLANK_INTERRUPT (1 << 3) +# define DC_HPDx_INTERRUPT (1 << 17) +# define DC_HPDx_RX_INTERRUPT (1 << 18) +/* First reg only */ # define DACA_AUTODETECT_INTERRUPT (1 << 22) # define DACB_AUTODETECT_INTERRUPT (1 << 23) # define DC_I2C_SW_DONE_INTERRUPT (1 << 24) # define DC_I2C_HW_DONE_INTERRUPT (1 << 25) -#define DISP_INTERRUPT_STATUS_CONTINUE 0x60f8 -# define LB_D2_VLINE_INTERRUPT (1 << 2) -# define LB_D2_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD2_INTERRUPT (1 << 17) -# define DC_HPD2_RX_INTERRUPT (1 << 18) +/* Second reg only */ # define DISP_TIMER_INTERRUPT (1 << 24) -#define DISP_INTERRUPT_STATUS_CONTINUE2 0x60fc -# define LB_D3_VLINE_INTERRUPT (1 << 2) -# define LB_D3_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD3_INTERRUPT (1 << 17) -# define DC_HPD3_RX_INTERRUPT (1 << 18) -#define DISP_INTERRUPT_STATUS_CONTINUE3 0x6100 -# define LB_D4_VLINE_INTERRUPT (1 << 2) -# define LB_D4_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD4_INTERRUPT (1 << 17) -# define DC_HPD4_RX_INTERRUPT (1 << 18) -#define DISP_INTERRUPT_STATUS_CONTINUE4 0x614c -# define LB_D5_VLINE_INTERRUPT (1 << 2) -# define LB_D5_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD5_INTERRUPT (1 << 17) -# define DC_HPD5_RX_INTERRUPT (1 << 18) -#define DISP_INTERRUPT_STATUS_CONTINUE5 0x6150 -# define LB_D6_VLINE_INTERRUPT (1 << 2) -# define LB_D6_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD6_INTERRUPT (1 << 17) -# define DC_HPD6_RX_INTERRUPT (1 << 18) /* 0x6858, 0x7458, 0x10058, 0x10c58, 0x11858, 0x12458 */ #define GRPH_INT_STATUS 0x6858 # define GRPH_PFLIP_INT_OCCURRED (1 << 0) # define GRPH_PFLIP_INT_CLEAR (1 << 8) /* 0x685c, 0x745c, 0x1005c, 0x10c5c, 0x1185c, 0x1245c */ -#define GRPH_INT_CONTROL 0x685c +#define GRPH_INT_CONTROL 0x685c # define GRPH_PFLIP_INT_MASK (1 << 0) # define GRPH_PFLIP_INT_TYPE (1 << 8) #define DACA_AUTODETECT_INT_CONTROL 0x66c8 #define DACB_AUTODETECT_INT_CONTROL 0x67c8 -#define DC_HPD1_INT_STATUS 0x601c -#define DC_HPD2_INT_STATUS 0x6028 -#define DC_HPD3_INT_STATUS 0x6034 -#define DC_HPD4_INT_STATUS 0x6040 -#define DC_HPD5_INT_STATUS 0x604c -#define DC_HPD6_INT_STATUS 0x6058 -# define DC_HPDx_INT_STATUS (1 << 0) +/* 0x601c, 0x6028, 0x6034, 0x6040, 0x604c, 0x6058 */ +#define DC_HPDx_INT_STATUS(x) (0x601c + (0xc * x)) +# define DC_HPDx_INT_STATUS_MASK (1 << 0) # define DC_HPDx_SENSE (1 << 1) # define DC_HPDx_RX_INT_STATUS (1 << 8) -#define DC_HPD1_INT_CONTROL 0x6020 -#define DC_HPD2_INT_CONTROL 0x602c -#define DC_HPD3_INT_CONTROL 0x6038 -#define DC_HPD4_INT_CONTROL 0x6044 -#define DC_HPD5_INT_CONTROL 0x6050 -#define DC_HPD6_INT_CONTROL 0x605c +/* 0x6020, 0x602c, 0x6038, 0x6044, 0x6050, 0x605c */ +#define DC_HPDx_INT_CONTROL(x) (0x6020 + (0xc * x)) # define DC_HPDx_INT_ACK (1 << 0) # define DC_HPDx_INT_POLARITY (1 << 8) # define DC_HPDx_INT_EN (1 << 16) # define DC_HPDx_RX_INT_ACK (1 << 20) # define DC_HPDx_RX_INT_EN (1 << 24) -#define DC_HPD1_CONTROL 0x6024 -#define DC_HPD2_CONTROL 0x6030 -#define DC_HPD3_CONTROL 0x603c -#define DC_HPD4_CONTROL 0x6048 -#define DC_HPD5_CONTROL 0x6054 -#define DC_HPD6_CONTROL 0x6060 -# define DC_HPDx_CONNECTION_TIMER(x) ((x) << 0) -# define DC_HPDx_RX_INT_TIMER(x) ((x) << 16) -# define DC_HPDx_EN (1 << 28) +/* 0x6024, 0x6030, 0x603c, 0x6048, 0x6054, 0x6060 */ +#define DC_HPDx_CONTROL(x) (0x6024 + (0xc * x)) +# define DC_HPDx_CONNECTION_TIMER(x) ((x) << 0) +# define DC_HPDx_RX_INT_TIMER(x) ((x) << 16) +# define DC_HPDx_EN (1 << 28) /* DCE4/5/6 FMT blocks */ #define FMT_DYNAMIC_EXP_CNTL 0x6fb4 diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h index c1c8e22..b6086ee 100644 --- a/drivers/gpu/drm/radeon/radeon.h +++ b/drivers/gpu/drm/radeon/radeon.h @@ -767,12 +767,7 @@ struct r600_irq_stat_regs { }; struct evergreen_irq_stat_regs { - u32 disp_int; - u32 disp_int_cont; - u32 disp_int_cont2; - u32 disp_int_cont3; - u32 disp_int_cont4; - u32 disp_int_cont5; + u32 disp_int[6]; u32 d1grph_int; u32 d2grph_int; u32 d3grph_int; @@ -2976,6 +2971,12 @@ int r600_cs_common_vline_parse(struct radeon_cs_parser *p, uint32_t *vline_start_end, uint32_t *vline_status); +/* interrupt control register helpers */ +void radeon_irq_kms_set_irq_n_enabled(struct radeon_device *rdev, + u32 reg, u32 mask, + bool enable, const char *name, + unsigned n); + #include "radeon_object.h" #endif diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c index 1b7528d..7aacb44 100644 --- a/drivers/gpu/drm/radeon/radeon_irq_kms.c +++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c @@ -538,3 +538,38 @@ void radeon_irq_kms_disable_hpd(struct radeon_device *rdev, unsigned hpd_mask) spin_unlock_irqrestore(&rdev->irq.lock, irqflags); } +/** + * radeon_irq_kms_update_int_n - helper for updating interrupt enable registers + * + * @rdev: radeon device pointer + * @reg: the register to write to enable/disable interrupts + * @mask: the mask that enables the interrupts + * @enable: whether to enable or disable the interrupt register + * @name: the name of the interrupt register to print to the kernel log + * @num: the number of the interrupt register to print to the kernel log + * + * Helper for updating the enable state of interrupt registers. Checks whether + * or not the interrupt matches the enable state we want. If it doesn't, then + * we update it and print a debugging message to the kernel log indicating the + * new state of the interrupt register. + * + * Used for updating sequences of interrupts registers like HPD1, HPD2, etc. + */ +void radeon_irq_kms_set_irq_n_enabled(struct radeon_device *rdev, + u32 reg, u32 mask, + bool enable, const char *name, unsigned n) +{ + u32 tmp = RREG32(reg); + + /* Interrupt state didn't change */ + if (!!(tmp & mask) == enable) + return; + + if (enable) { + DRM_DEBUG("%s%d interrupts enabled\n", name, n); + WREG32(reg, tmp |= mask); + } else { + DRM_DEBUG("%s%d interrupts disabled\n", name, n); + WREG32(reg, tmp & ~mask); + } +} diff --git a/drivers/gpu/drm/radeon/si.c b/drivers/gpu/drm/radeon/si.c index 76d1888..bb745e1 100644 --- a/drivers/gpu/drm/radeon/si.c +++ b/drivers/gpu/drm/radeon/si.c @@ -139,6 +139,16 @@ static void si_fini_pg(struct radeon_device *rdev); static void si_fini_cg(struct radeon_device *rdev); static void si_rlc_stop(struct radeon_device *rdev); +static const u32 crtc_offsets[] = +{ + EVERGREEN_CRTC0_REGISTER_OFFSET, + EVERGREEN_CRTC1_REGISTER_OFFSET, + EVERGREEN_CRTC2_REGISTER_OFFSET, + EVERGREEN_CRTC3_REGISTER_OFFSET, + EVERGREEN_CRTC4_REGISTER_OFFSET, + EVERGREEN_CRTC5_REGISTER_OFFSET +}; + static const u32 verde_rlc_save_restore_register_list[] = { (0x8000 << 16) | (0x98f4 >> 2), @@ -5916,6 +5926,7 @@ static void si_disable_interrupts(struct radeon_device *rdev) static void si_disable_interrupt_state(struct radeon_device *rdev) { + int i; u32 tmp; tmp = RREG32(CP_INT_CNTL_RING0) & @@ -5929,18 +5940,8 @@ static void si_disable_interrupt_state(struct radeon_device *rdev) WREG32(DMA_CNTL + DMA1_REGISTER_OFFSET, tmp); WREG32(GRBM_INT_CNTL, 0); WREG32(SRBM_INT_CNTL, 0); - if (rdev->num_crtc >= 2) { - WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0); - WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0); - } - if (rdev->num_crtc >= 4) { - WREG32(INT_MASK + EVERGREEN_CRTC2_REGISTER_OFFSET, 0); - WREG32(INT_MASK + EVERGREEN_CRTC3_REGISTER_OFFSET, 0); - } - if (rdev->num_crtc >= 6) { - WREG32(INT_MASK + EVERGREEN_CRTC4_REGISTER_OFFSET, 0); - WREG32(INT_MASK + EVERGREEN_CRTC5_REGISTER_OFFSET, 0); - } + for (i = 0; i < rdev->num_crtc; i++) + WREG32(INT_MASK + crtc_offsets[i], 0); if (rdev->num_crtc >= 2) { WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET, 0); @@ -5958,18 +5959,9 @@ static void si_disable_interrupt_state(struct radeon_device *rdev) if (!ASIC_IS_NODCE(rdev)) { WREG32(DAC_AUTODETECT_INT_CONTROL, 0); - tmp = RREG32(DC_HPD1_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD1_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD2_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD2_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD3_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD3_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD4_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD4_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD5_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD5_INT_CONTROL, tmp); - tmp = RREG32(DC_HPD6_INT_CONTROL) & DC_HPDx_INT_POLARITY; - WREG32(DC_HPD6_INT_CONTROL, tmp); + for (i = 0; i < SI_MAX_DISP_REGISTERS; i++) + WREG32_AND(DC_HPDx_INT_CONTROL(i), + DC_HPDx_INT_POLARITY); } } @@ -6046,10 +6038,9 @@ static int si_irq_init(struct radeon_device *rdev) int si_irq_set(struct radeon_device *rdev) { + int i; u32 cp_int_cntl; u32 cp_int_cntl1 = 0, cp_int_cntl2 = 0; - u32 crtc1 = 0, crtc2 = 0, crtc3 = 0, crtc4 = 0, crtc5 = 0, crtc6 = 0; - u32 hpd1 = 0, hpd2 = 0, hpd3 = 0, hpd4 = 0, hpd5 = 0, hpd6 = 0; u32 grbm_int_cntl = 0; u32 dma_cntl, dma_cntl1; u32 thermal_int = 0; @@ -6069,15 +6060,6 @@ int si_irq_set(struct radeon_device *rdev) cp_int_cntl = RREG32(CP_INT_CNTL_RING0) & (CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE); - if (!ASIC_IS_NODCE(rdev)) { - hpd1 = RREG32(DC_HPD1_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd2 = RREG32(DC_HPD2_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd3 = RREG32(DC_HPD3_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd4 = RREG32(DC_HPD4_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd5 = RREG32(DC_HPD5_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - hpd6 = RREG32(DC_HPD6_INT_CONTROL) & ~(DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN); - } - dma_cntl = RREG32(DMA_CNTL + DMA0_REGISTER_OFFSET) & ~TRAP_ENABLE; dma_cntl1 = RREG32(DMA_CNTL + DMA1_REGISTER_OFFSET) & ~TRAP_ENABLE; @@ -6106,60 +6088,6 @@ int si_irq_set(struct radeon_device *rdev) DRM_DEBUG("si_irq_set: sw int dma1\n"); dma_cntl1 |= TRAP_ENABLE; } - if (rdev->irq.crtc_vblank_int[0] || - atomic_read(&rdev->irq.pflip[0])) { - DRM_DEBUG("si_irq_set: vblank 0\n"); - crtc1 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[1] || - atomic_read(&rdev->irq.pflip[1])) { - DRM_DEBUG("si_irq_set: vblank 1\n"); - crtc2 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[2] || - atomic_read(&rdev->irq.pflip[2])) { - DRM_DEBUG("si_irq_set: vblank 2\n"); - crtc3 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[3] || - atomic_read(&rdev->irq.pflip[3])) { - DRM_DEBUG("si_irq_set: vblank 3\n"); - crtc4 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[4] || - atomic_read(&rdev->irq.pflip[4])) { - DRM_DEBUG("si_irq_set: vblank 4\n"); - crtc5 |= VBLANK_INT_MASK; - } - if (rdev->irq.crtc_vblank_int[5] || - atomic_read(&rdev->irq.pflip[5])) { - DRM_DEBUG("si_irq_set: vblank 5\n"); - crtc6 |= VBLANK_INT_MASK; - } - if (rdev->irq.hpd[0]) { - DRM_DEBUG("si_irq_set: hpd 1\n"); - hpd1 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[1]) { - DRM_DEBUG("si_irq_set: hpd 2\n"); - hpd2 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[2]) { - DRM_DEBUG("si_irq_set: hpd 3\n"); - hpd3 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[3]) { - DRM_DEBUG("si_irq_set: hpd 4\n"); - hpd4 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[4]) { - DRM_DEBUG("si_irq_set: hpd 5\n"); - hpd5 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } - if (rdev->irq.hpd[5]) { - DRM_DEBUG("si_irq_set: hpd 6\n"); - hpd6 |= DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN; - } WREG32(CP_INT_CNTL_RING0, cp_int_cntl); WREG32(CP_INT_CNTL_RING1, cp_int_cntl1); @@ -6176,19 +6104,6 @@ int si_irq_set(struct radeon_device *rdev) } if (rdev->num_crtc >= 2) { - WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, crtc1); - WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, crtc2); - } - if (rdev->num_crtc >= 4) { - WREG32(INT_MASK + EVERGREEN_CRTC2_REGISTER_OFFSET, crtc3); - WREG32(INT_MASK + EVERGREEN_CRTC3_REGISTER_OFFSET, crtc4); - } - if (rdev->num_crtc >= 6) { - WREG32(INT_MASK + EVERGREEN_CRTC4_REGISTER_OFFSET, crtc5); - WREG32(INT_MASK + EVERGREEN_CRTC5_REGISTER_OFFSET, crtc6); - } - - if (rdev->num_crtc >= 2) { WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET, GRPH_PFLIP_INT_MASK); WREG32(GRPH_INT_CONTROL + EVERGREEN_CRTC1_REGISTER_OFFSET, @@ -6208,12 +6123,19 @@ int si_irq_set(struct radeon_device *rdev) } if (!ASIC_IS_NODCE(rdev)) { - WREG32(DC_HPD1_INT_CONTROL, hpd1); - WREG32(DC_HPD2_INT_CONTROL, hpd2); - WREG32(DC_HPD3_INT_CONTROL, hpd3); - WREG32(DC_HPD4_INT_CONTROL, hpd4); - WREG32(DC_HPD5_INT_CONTROL, hpd5); - WREG32(DC_HPD6_INT_CONTROL, hpd6); + for (i = 0; i < SI_MAX_DISP_REGISTERS; i++) { + radeon_irq_kms_set_irq_n_enabled( + rdev, DC_HPDx_INT_CONTROL(i), + DC_HPDx_INT_EN | DC_HPDx_RX_INT_EN, + rdev->irq.hpd[i], "HPD", i); + } + } + + for (i = 0; i < rdev->num_crtc; i++) { + radeon_irq_kms_set_irq_n_enabled( + rdev, INT_MASK + crtc_offsets[i], VBLANK_INT_MASK, + rdev->irq.crtc_vblank_int[i] || + atomic_read(&rdev->irq.pflip[i]), "vblank", i); } WREG32(CG_THERMAL_INT, thermal_int); @@ -6226,17 +6148,12 @@ int si_irq_set(struct radeon_device *rdev) static inline void si_irq_ack(struct radeon_device *rdev) { - u32 tmp; + int i; + u32 *disp_int = rdev->irq.stat_regs.evergreen.disp_int; if (ASIC_IS_NODCE(rdev)) return; - rdev->irq.stat_regs.evergreen.disp_int = RREG32(DISP_INTERRUPT_STATUS); - rdev->irq.stat_regs.evergreen.disp_int_cont = RREG32(DISP_INTERRUPT_STATUS_CONTINUE); - rdev->irq.stat_regs.evergreen.disp_int_cont2 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE2); - rdev->irq.stat_regs.evergreen.disp_int_cont3 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE3); - rdev->irq.stat_regs.evergreen.disp_int_cont4 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE4); - rdev->irq.stat_regs.evergreen.disp_int_cont5 = RREG32(DISP_INTERRUPT_STATUS_CONTINUE5); rdev->irq.stat_regs.evergreen.d1grph_int = RREG32(GRPH_INT_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET); rdev->irq.stat_regs.evergreen.d2grph_int = RREG32(GRPH_INT_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET); if (rdev->num_crtc >= 4) { @@ -6248,32 +6165,34 @@ static inline void si_irq_ack(struct radeon_device *rdev) rdev->irq.stat_regs.evergreen.d6grph_int = RREG32(GRPH_INT_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET); } + for (i = 0; i < SI_MAX_DISP_REGISTERS; i++) { + disp_int[i] = RREG32(DISP_INTERRUPT_STATUS(i)); + + if (disp_int[i] & DC_HPDx_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_ACK); + if (disp_int[i] & DC_HPDx_RX_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_RX_INT_ACK); + + if (i < rdev->num_crtc) { + if (disp_int[i] & LB_Dx_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[i], + VBLANK_ACK); + if (disp_int[i] & LB_Dx_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[i], + VLINE_ACK); + } + } + if (rdev->irq.stat_regs.evergreen.d1grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); if (rdev->irq.stat_regs.evergreen.d2grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); - if (rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC0_REGISTER_OFFSET, VLINE_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC1_REGISTER_OFFSET, VLINE_ACK); if (rdev->num_crtc >= 4) { if (rdev->irq.stat_regs.evergreen.d3grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC2_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); if (rdev->irq.stat_regs.evergreen.d4grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC3_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC2_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC2_REGISTER_OFFSET, VLINE_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC3_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC3_REGISTER_OFFSET, VLINE_ACK); } if (rdev->num_crtc >= 6) { @@ -6281,76 +6200,6 @@ static inline void si_irq_ack(struct radeon_device *rdev) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC4_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); if (rdev->irq.stat_regs.evergreen.d6grph_int & GRPH_PFLIP_INT_OCCURRED) WREG32(GRPH_INT_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET, GRPH_PFLIP_INT_CLEAR); - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC4_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC4_REGISTER_OFFSET, VLINE_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VBLANK_INTERRUPT) - WREG32(VBLANK_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET, VBLANK_ACK); - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VLINE_INTERRUPT) - WREG32(VLINE_STATUS + EVERGREEN_CRTC5_REGISTER_OFFSET, VLINE_ACK); - } - - if (rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_INTERRUPT) { - tmp = RREG32(DC_HPD1_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD1_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_INTERRUPT) { - tmp = RREG32(DC_HPD2_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD2_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_INTERRUPT) { - tmp = RREG32(DC_HPD3_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD3_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_INTERRUPT) { - tmp = RREG32(DC_HPD4_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD4_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_INTERRUPT) { - tmp = RREG32(DC_HPD5_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD5_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_INTERRUPT) { - tmp = RREG32(DC_HPD6_INT_CONTROL); - tmp |= DC_HPDx_INT_ACK; - WREG32(DC_HPD6_INT_CONTROL, tmp); - } - - if (rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_RX_INTERRUPT) { - tmp = RREG32(DC_HPD1_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD1_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_RX_INTERRUPT) { - tmp = RREG32(DC_HPD2_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD2_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_RX_INTERRUPT) { - tmp = RREG32(DC_HPD3_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD3_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_RX_INTERRUPT) { - tmp = RREG32(DC_HPD4_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD4_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_RX_INTERRUPT) { - tmp = RREG32(DC_HPD5_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD5_INT_CONTROL, tmp); - } - if (rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_RX_INTERRUPT) { - tmp = RREG32(DC_HPD6_INT_CONTROL); - tmp |= DC_HPDx_RX_INT_ACK; - WREG32(DC_HPD6_INT_CONTROL, tmp); } } @@ -6412,6 +6261,9 @@ static inline u32 si_get_ih_wptr(struct radeon_device *rdev) */ int si_irq_process(struct radeon_device *rdev) { + u32 *disp_int = rdev->irq.stat_regs.evergreen.disp_int; + u32 crtc_idx, hpd_idx; + u32 mask; u32 wptr; u32 rptr; u32 src_id, src_data, ring_id; @@ -6420,6 +6272,7 @@ int si_irq_process(struct radeon_device *rdev) bool queue_dp = false; bool queue_thermal = false; u32 status, addr; + const char *event_name; if (!rdev->ih.enabled || rdev->shutdown) return IRQ_NONE; @@ -6449,184 +6302,44 @@ int si_irq_process(struct radeon_device *rdev) switch (src_id) { case 1: /* D1 vblank/vline */ - switch (src_data) { - case 0: /* D1 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[0]) { - drm_handle_vblank(rdev->ddev, 0); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[0])) - radeon_crtc_handle_vblank(rdev, 0); - rdev->irq.stat_regs.evergreen.disp_int &= ~LB_D1_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D1 vblank\n"); - - break; - case 1: /* D1 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int & LB_D1_VLINE_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int &= ~LB_D1_VLINE_INTERRUPT; - DRM_DEBUG("IH: D1 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 2: /* D2 vblank/vline */ - switch (src_data) { - case 0: /* D2 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[1]) { - drm_handle_vblank(rdev->ddev, 1); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[1])) - radeon_crtc_handle_vblank(rdev, 1); - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~LB_D2_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D2 vblank\n"); - - break; - case 1: /* D2 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & LB_D2_VLINE_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~LB_D2_VLINE_INTERRUPT; - DRM_DEBUG("IH: D2 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 3: /* D3 vblank/vline */ - switch (src_data) { - case 0: /* D3 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[2]) { - drm_handle_vblank(rdev->ddev, 2); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[2])) - radeon_crtc_handle_vblank(rdev, 2); - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~LB_D3_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D3 vblank\n"); - - break; - case 1: /* D3 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & LB_D3_VLINE_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~LB_D3_VLINE_INTERRUPT; - DRM_DEBUG("IH: D3 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 4: /* D4 vblank/vline */ - switch (src_data) { - case 0: /* D4 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[3]) { - drm_handle_vblank(rdev->ddev, 3); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[3])) - radeon_crtc_handle_vblank(rdev, 3); - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~LB_D4_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D4 vblank\n"); - - break; - case 1: /* D4 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & LB_D4_VLINE_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~LB_D4_VLINE_INTERRUPT; - DRM_DEBUG("IH: D4 vline\n"); - - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } - break; case 5: /* D5 vblank/vline */ - switch (src_data) { - case 0: /* D5 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + case 6: /* D6 vblank/vline */ + crtc_idx = src_id - 1; + + if (src_data == 0) { /* vblank */ + mask = LB_Dx_VBLANK_INTERRUPT; + event_name = "vblank"; - if (rdev->irq.crtc_vblank_int[4]) { - drm_handle_vblank(rdev->ddev, 4); + if (rdev->irq.crtc_vblank_int[crtc_idx]) { + drm_handle_vblank(rdev->ddev, crtc_idx); rdev->pm.vblank_sync = true; wake_up(&rdev->irq.vblank_queue); } - if (atomic_read(&rdev->irq.pflip[4])) - radeon_crtc_handle_vblank(rdev, 4); - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~LB_D5_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D5 vblank\n"); - - break; - case 1: /* D5 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & LB_D5_VLINE_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~LB_D5_VLINE_INTERRUPT; - DRM_DEBUG("IH: D5 vline\n"); + if (atomic_read(&rdev->irq.pflip[crtc_idx])) { + radeon_crtc_handle_vblank(rdev, + crtc_idx); + } - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); + } else if (src_data == 1) { /* vline */ + mask = LB_Dx_VLINE_INTERRUPT; + event_name = "vline"; + } else { + DRM_DEBUG("Unhandled interrupt: %d %d\n", + src_id, src_data); break; } - break; - case 6: /* D6 vblank/vline */ - switch (src_data) { - case 0: /* D6 vblank */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VBLANK_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - if (rdev->irq.crtc_vblank_int[5]) { - drm_handle_vblank(rdev->ddev, 5); - rdev->pm.vblank_sync = true; - wake_up(&rdev->irq.vblank_queue); - } - if (atomic_read(&rdev->irq.pflip[5])) - radeon_crtc_handle_vblank(rdev, 5); - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~LB_D6_VBLANK_INTERRUPT; - DRM_DEBUG("IH: D6 vblank\n"); - break; - case 1: /* D6 vline */ - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & LB_D6_VLINE_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + if (!(disp_int[crtc_idx] & mask)) { + DRM_DEBUG("IH: D%d %s - IH event w/o asserted irq bit?\n", + crtc_idx + 1, event_name); + } - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~LB_D6_VLINE_INTERRUPT; - DRM_DEBUG("IH: D6 vline\n"); + disp_int[crtc_idx] &= ~mask; + DRM_DEBUG("IH: D%d %s\n", crtc_idx + 1, event_name); - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } break; case 8: /* D1 page flip */ case 10: /* D2 page flip */ @@ -6639,119 +6352,29 @@ int si_irq_process(struct radeon_device *rdev) radeon_crtc_handle_flip(rdev, (src_id - 8) >> 1); break; case 42: /* HPD hotplug */ - switch (src_data) { - case 0: - if (!(rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int &= ~DC_HPD1_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD1\n"); - - break; - case 1: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~DC_HPD2_INTERRUPT; + if (src_data <= 5) { + hpd_idx = src_data; + mask = DC_HPDx_INTERRUPT; queue_hotplug = true; - DRM_DEBUG("IH: HPD2\n"); + event_name = "HPD"; - break; - case 2: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~DC_HPD3_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD3\n"); - - break; - case 3: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~DC_HPD4_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD4\n"); - - break; - case 4: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~DC_HPD5_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD5\n"); - - break; - case 5: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~DC_HPD6_INTERRUPT; - queue_hotplug = true; - DRM_DEBUG("IH: HPD6\n"); - - break; - case 6: - if (!(rdev->irq.stat_regs.evergreen.disp_int & DC_HPD1_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int &= ~DC_HPD1_RX_INTERRUPT; + } else if (src_data <= 11) { + hpd_idx = src_data - 6; + mask = DC_HPDx_RX_INTERRUPT; queue_dp = true; - DRM_DEBUG("IH: HPD_RX 1\n"); - - break; - case 7: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont & DC_HPD2_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont &= ~DC_HPD2_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 2\n"); - - break; - case 8: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont2 & DC_HPD3_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont2 &= ~DC_HPD3_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 3\n"); - - break; - case 9: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont3 & DC_HPD4_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont3 &= ~DC_HPD4_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 4\n"); - - break; - case 10: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont4 & DC_HPD5_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - - rdev->irq.stat_regs.evergreen.disp_int_cont4 &= ~DC_HPD5_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 5\n"); + event_name = "HPD_RX"; + } else { + DRM_DEBUG("Unhandled interrupt: %d %d\n", + src_id, src_data); break; - case 11: - if (!(rdev->irq.stat_regs.evergreen.disp_int_cont5 & DC_HPD6_RX_INTERRUPT)) - DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); + } - rdev->irq.stat_regs.evergreen.disp_int_cont5 &= ~DC_HPD6_RX_INTERRUPT; - queue_dp = true; - DRM_DEBUG("IH: HPD_RX 6\n"); + if (!(disp_int[hpd_idx] & mask)) + DRM_DEBUG("IH: IH event w/o asserted irq bit?\n"); - break; - default: - DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id, src_data); - break; - } + disp_int[hpd_idx] &= ~mask; + DRM_DEBUG("IH: %s%d\n", event_name, hpd_idx + 1); break; case 96: DRM_ERROR("SRBM_READ_ERROR: 0x%x\n", RREG32(SRBM_READ_ERROR)); diff --git a/drivers/gpu/drm/radeon/sid.h b/drivers/gpu/drm/radeon/sid.h index 65a911d..0ef68f0 100644 --- a/drivers/gpu/drm/radeon/sid.h +++ b/drivers/gpu/drm/radeon/sid.h @@ -47,6 +47,7 @@ #define SI_MAX_LDS_NUM 0xFFFF #define SI_MAX_TCC 16 #define SI_MAX_TCC_MASK 0xFFFF +#define SI_MAX_DISP_REGISTERS 6 /* SMC IND accessor regs */ #define SMC_IND_INDEX_0 0x200 @@ -820,41 +821,20 @@ # define VBLANK_INT_MASK (1 << 0) # define VLINE_INT_MASK (1 << 4) -#define DISP_INTERRUPT_STATUS 0x60f4 -# define LB_D1_VLINE_INTERRUPT (1 << 2) -# define LB_D1_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD1_INTERRUPT (1 << 17) -# define DC_HPD1_RX_INTERRUPT (1 << 18) +/* 0x60f4, 0x60f8, 0x60fc, 0x6100, 0x614c, 0x6150 */ +#define DISP_INTERRUPT_STATUS(i) \ + ((i < 4) ? 0x60f4 + (0x4 * i) : 0x614c + (0x4 * (i - 4))) +# define LB_Dx_VLINE_INTERRUPT (1 << 2) +# define LB_Dx_VBLANK_INTERRUPT (1 << 3) +# define DC_HPDx_INTERRUPT (1 << 17) +# define DC_HPDx_RX_INTERRUPT (1 << 18) +/* First reg only */ # define DACA_AUTODETECT_INTERRUPT (1 << 22) # define DACB_AUTODETECT_INTERRUPT (1 << 23) # define DC_I2C_SW_DONE_INTERRUPT (1 << 24) # define DC_I2C_HW_DONE_INTERRUPT (1 << 25) -#define DISP_INTERRUPT_STATUS_CONTINUE 0x60f8 -# define LB_D2_VLINE_INTERRUPT (1 << 2) -# define LB_D2_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD2_INTERRUPT (1 << 17) -# define DC_HPD2_RX_INTERRUPT (1 << 18) +/* Second reg only */ # define DISP_TIMER_INTERRUPT (1 << 24) -#define DISP_INTERRUPT_STATUS_CONTINUE2 0x60fc -# define LB_D3_VLINE_INTERRUPT (1 << 2) -# define LB_D3_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD3_INTERRUPT (1 << 17) -# define DC_HPD3_RX_INTERRUPT (1 << 18) -#define DISP_INTERRUPT_STATUS_CONTINUE3 0x6100 -# define LB_D4_VLINE_INTERRUPT (1 << 2) -# define LB_D4_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD4_INTERRUPT (1 << 17) -# define DC_HPD4_RX_INTERRUPT (1 << 18) -#define DISP_INTERRUPT_STATUS_CONTINUE4 0x614c -# define LB_D5_VLINE_INTERRUPT (1 << 2) -# define LB_D5_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD5_INTERRUPT (1 << 17) -# define DC_HPD5_RX_INTERRUPT (1 << 18) -#define DISP_INTERRUPT_STATUS_CONTINUE5 0x6150 -# define LB_D6_VLINE_INTERRUPT (1 << 2) -# define LB_D6_VBLANK_INTERRUPT (1 << 3) -# define DC_HPD6_INTERRUPT (1 << 17) -# define DC_HPD6_RX_INTERRUPT (1 << 18) /* 0x6858, 0x7458, 0x10058, 0x10c58, 0x11858, 0x12458 */ #define GRPH_INT_STATUS 0x6858 @@ -867,37 +847,25 @@ #define DAC_AUTODETECT_INT_CONTROL 0x67c8 -#define DC_HPD1_INT_STATUS 0x601c -#define DC_HPD2_INT_STATUS 0x6028 -#define DC_HPD3_INT_STATUS 0x6034 -#define DC_HPD4_INT_STATUS 0x6040 -#define DC_HPD5_INT_STATUS 0x604c -#define DC_HPD6_INT_STATUS 0x6058 -# define DC_HPDx_INT_STATUS (1 << 0) +/* 0x601c, 0x6028, 0x6034, 0x6040, 0x604c, 0x6058 */ +#define DC_HPDx_INT_STATUS(x) (0x601c + (0xc * x)) +# define DC_HPDx_INT_STATUS_MASK (1 << 0) # define DC_HPDx_SENSE (1 << 1) # define DC_HPDx_RX_INT_STATUS (1 << 8) -#define DC_HPD1_INT_CONTROL 0x6020 -#define DC_HPD2_INT_CONTROL 0x602c -#define DC_HPD3_INT_CONTROL 0x6038 -#define DC_HPD4_INT_CONTROL 0x6044 -#define DC_HPD5_INT_CONTROL 0x6050 -#define DC_HPD6_INT_CONTROL 0x605c +/* 0x6020, 0x602c, 0x6038, 0x6044, 0x6050, 0x605c */ +#define DC_HPDx_INT_CONTROL(x) (0x6020 + (0xc * x)) # define DC_HPDx_INT_ACK (1 << 0) # define DC_HPDx_INT_POLARITY (1 << 8) # define DC_HPDx_INT_EN (1 << 16) # define DC_HPDx_RX_INT_ACK (1 << 20) # define DC_HPDx_RX_INT_EN (1 << 24) -#define DC_HPD1_CONTROL 0x6024 -#define DC_HPD2_CONTROL 0x6030 -#define DC_HPD3_CONTROL 0x603c -#define DC_HPD4_CONTROL 0x6048 -#define DC_HPD5_CONTROL 0x6054 -#define DC_HPD6_CONTROL 0x6060 -# define DC_HPDx_CONNECTION_TIMER(x) ((x) << 0) -# define DC_HPDx_RX_INT_TIMER(x) ((x) << 16) -# define DC_HPDx_EN (1 << 28) +/* 0x6024, 0x6030, 0x603c, 0x6048, 0x6054, 0x6060 */ +#define DC_HPDx_CONTROL(x) (0x6024 + (0xc * x)) +# define DC_HPDx_CONNECTION_TIMER(x) ((x) << 0) +# define DC_HPDx_RX_INT_TIMER(x) ((x) << 16) +# define DC_HPDx_EN (1 << 28) #define DPG_PIPE_STUTTER_CONTROL 0x6cd4 # define STUTTER_ENABLE (1 << 0) -- 2.9.4