From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH v2 1/3] drm/radeon: Cleanup display interrupt handling for evergreen, si Date: Fri, 19 May 2017 19:48:37 -0400 Message-ID: <20170519234840.5644-2-lyude@redhat.com> References: <20170516211202.20325-1-lyude@redhat.com> <20170519234840.5644-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170519234840.5644-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 bGVkIGludGVycnVwdHMgdG8gdGhlCmtlcm5lbCBsb2cuCgpOb3RlIGluIHRoaXMgY29tbWl0LCBz aW5jZSB2YmxhbmsvdmxpbmUgaXJxIGFja2luZyBpcyBpbnRlcnR3aW5lZCB3aXRoCnBhZ2UgZmxp cCBpcnEgYWNraW5nLCB3ZSBjYW4ndCBjdXQgb3V0IGFsbCBvZiB0aGUgY29weSBwYXN0ZSBpbgpl dmVyZ3JlZW4vc2lfaXJxX2FjaygpIGp1c3QgeWV0LgoKQ2hhbmdlcyBzaW5jZSB2MToKLSBQcmVz ZXJ2ZSBvcmRlciB3ZSB3cml0ZSBiYWNrIGFsbCByZWdpc3RlcnMKClNpZ25lZC1vZmYtYnk6IEx5 dWRlIDxseXVkZUByZWRoYXQuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vZXZlcmdy ZWVuLmMgICAgICB8IDcyOSArKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVy cy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaCAgICAgICAgIHwgIDEzICstCiBkcml2ZXJzL2dwdS9k cm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMgfCAgMzUgKysKIGRyaXZlcnMvZ3B1L2RybS9yYWRl b24vc2kuYyAgICAgICAgICAgICB8IDU5NiArKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLQogNCBm aWxlcyBjaGFuZ2VkLCAzMTQgaW5zZXJ0aW9ucygrKSwgMTA1OSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbi5jIGIvZHJpdmVycy9ncHUv ZHJtL3JhZGVvbi9ldmVyZ3JlZW4uYwppbmRleCAwYmYxMDM1Li40NGFjNmQzIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL2V2ZXJncmVlbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9yYWRlb24vZXZlcmdyZWVuLmMKQEAgLTM1LDYgKzM1LDEwIEBACiAjaW5jbHVkZSAiZXZlcmdy ZWVuX2JsaXRfc2hhZGVycy5oIgogI2luY2x1ZGUgInJhZGVvbl91Y29kZS5oIgogCisjZGVmaW5l IERDX0hQRHhfQ09OVFJPTCh4KSAgICAgICAgKERDX0hQRDFfQ09OVFJPTCAgICAgKyAoeCAqIDB4 YykpCisjZGVmaW5lIERDX0hQRHhfSU5UX0NPTlRST0woeCkgICAgKERDX0hQRDFfSU5UX0NPTlRS T0wgKyAoeCAqIDB4YykpCisjZGVmaW5lIERDX0hQRHhfSU5UX1NUQVRVU19SRUcoeCkgKERDX0hQ RDFfSU5UX1NUQVRVUyAgKyAoeCAqIDB4YykpCisKIC8qCiAgKiBJbmRpcmVjdCByZWdpc3RlcnMg YWNjZXNzb3IKICAqLwpAQCAtMTcxNCwzOCArMTcxOCwxMCBAQCB2b2lkIGV2ZXJncmVlbl9wbV9m aW5pc2goc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAgKi8KIGJvb2wgZXZlcmdyZWVuX2hw ZF9zZW5zZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgZW51bSByYWRlb25faHBkX2lkIGhw ZCkKIHsKLQlib29sIGNvbm5lY3RlZCA9IGZhbHNlOwotCi0Jc3dpdGNoIChocGQpIHsKLQljYXNl IFJBREVPTl9IUERfMToKLQkJaWYgKFJSRUczMihEQ19IUEQxX0lOVF9TVEFUVVMpICYgRENfSFBE eF9TRU5TRSkKLQkJCWNvbm5lY3RlZCA9IHRydWU7Ci0JCWJyZWFrOwotCWNhc2UgUkFERU9OX0hQ RF8yOgotCQlpZiAoUlJFRzMyKERDX0hQRDJfSU5UX1NUQVRVUykgJiBEQ19IUER4X1NFTlNFKQot CQkJY29ubmVjdGVkID0gdHJ1ZTsKLQkJYnJlYWs7Ci0JY2FzZSBSQURFT05fSFBEXzM6Ci0JCWlm IChSUkVHMzIoRENfSFBEM19JTlRfU1RBVFVTKSAmIERDX0hQRHhfU0VOU0UpCi0JCQljb25uZWN0 ZWQgPSB0cnVlOwotCQlicmVhazsKLQljYXNlIFJBREVPTl9IUERfNDoKLQkJaWYgKFJSRUczMihE Q19IUEQ0X0lOVF9TVEFUVVMpICYgRENfSFBEeF9TRU5TRSkKLQkJCWNvbm5lY3RlZCA9IHRydWU7 Ci0JCWJyZWFrOwotCWNhc2UgUkFERU9OX0hQRF81OgotCQlpZiAoUlJFRzMyKERDX0hQRDVfSU5U X1NUQVRVUykgJiBEQ19IUER4X1NFTlNFKQotCQkJY29ubmVjdGVkID0gdHJ1ZTsKLQkJYnJlYWs7 Ci0JY2FzZSBSQURFT05fSFBEXzY6Ci0JCWlmIChSUkVHMzIoRENfSFBENl9JTlRfU1RBVFVTKSAm IERDX0hQRHhfU0VOU0UpCi0JCQljb25uZWN0ZWQgPSB0cnVlOwotCQlicmVhazsKLQlkZWZhdWx0 OgotCQlicmVhazsKLQl9CisJaWYgKGhwZCA9PSBSQURFT05fSFBEX05PTkUpCisJCXJldHVybiBm YWxzZTsKIAotCXJldHVybiBjb25uZWN0ZWQ7CisJcmV0dXJuICEhKFJSRUczMihEQ19IUER4X0lO VF9TVEFUVVNfUkVHKGhwZCkpICYgRENfSFBEeF9TRU5TRSk7CiB9CiAKIC8qKgpAQCAtMTc1OSw2 MSArMTczNSwxNSBAQCBib29sIGV2ZXJncmVlbl9ocGRfc2Vuc2Uoc3RydWN0IHJhZGVvbl9kZXZp Y2UgKnJkZXYsIGVudW0gcmFkZW9uX2hwZF9pZCBocGQpCiB2b2lkIGV2ZXJncmVlbl9ocGRfc2V0 X3BvbGFyaXR5KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2LAogCQkJCWVudW0gcmFkZW9uX2hw ZF9pZCBocGQpCiB7Ci0JdTMyIHRtcDsKIAlib29sIGNvbm5lY3RlZCA9IGV2ZXJncmVlbl9ocGRf c2Vuc2UocmRldiwgaHBkKTsKIAotCXN3aXRjaCAoaHBkKSB7Ci0JY2FzZSBSQURFT05fSFBEXzE6 Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MKTsKLQkJaWYgKGNvbm5lY3RlZCkK LQkJCXRtcCAmPSB+RENfSFBEeF9JTlRfUE9MQVJJVFk7Ci0JCWVsc2UKLQkJCXRtcCB8PSBEQ19I UER4X0lOVF9QT0xBUklUWTsKLQkJV1JFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wsIHRtcCk7Ci0J CWJyZWFrOwotCWNhc2UgUkFERU9OX0hQRF8yOgotCQl0bXAgPSBSUkVHMzIoRENfSFBEMl9JTlRf Q09OVFJPTCk7Ci0JCWlmIChjb25uZWN0ZWQpCi0JCQl0bXAgJj0gfkRDX0hQRHhfSU5UX1BPTEFS SVRZOwotCQllbHNlCi0JCQl0bXAgfD0gRENfSFBEeF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihE Q19IUEQyX0lOVF9DT05UUk9MLCB0bXApOwotCQlicmVhazsKLQljYXNlIFJBREVPTl9IUERfMzoK LQkJdG1wID0gUlJFRzMyKERDX0hQRDNfSU5UX0NPTlRST0wpOwotCQlpZiAoY29ubmVjdGVkKQot CQkJdG1wICY9IH5EQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJZWxzZQotCQkJdG1wIHw9IERDX0hQ RHhfSU5UX1BPTEFSSVRZOwotCQlXUkVHMzIoRENfSFBEM19JTlRfQ09OVFJPTCwgdG1wKTsKLQkJ YnJlYWs7Ci0JY2FzZSBSQURFT05fSFBEXzQ6Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ0X0lOVF9D T05UUk9MKTsKLQkJaWYgKGNvbm5lY3RlZCkKLQkJCXRtcCAmPSB+RENfSFBEeF9JTlRfUE9MQVJJ VFk7Ci0JCWVsc2UKLQkJCXRtcCB8PSBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJV1JFRzMyKERD X0hQRDRfSU5UX0NPTlRST0wsIHRtcCk7Ci0JCWJyZWFrOwotCWNhc2UgUkFERU9OX0hQRF81Ogot CQl0bXAgPSBSUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCk7Ci0JCWlmIChjb25uZWN0ZWQpCi0J CQl0bXAgJj0gfkRDX0hQRHhfSU5UX1BPTEFSSVRZOwotCQllbHNlCi0JCQl0bXAgfD0gRENfSFBE eF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MLCB0bXApOwotCQkJ YnJlYWs7Ci0JY2FzZSBSQURFT05fSFBEXzY6Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ2X0lOVF9D T05UUk9MKTsKLQkJaWYgKGNvbm5lY3RlZCkKLQkJCXRtcCAmPSB+RENfSFBEeF9JTlRfUE9MQVJJ VFk7Ci0JCWVsc2UKLQkJCXRtcCB8PSBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQkJV1JFRzMyKERD X0hQRDZfSU5UX0NPTlRST0wsIHRtcCk7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0JCWJyZWFrOwot CX0KKwlpZiAoaHBkID09IFJBREVPTl9IUERfTk9ORSkKKwkJcmV0dXJuOworCisJaWYgKGNvbm5l Y3RlZCkKKwkJV1JFRzMyX0FORChEQ19IUER4X0lOVF9DT05UUk9MKGhwZCksIH5EQ19IUER4X0lO VF9QT0xBUklUWSk7CisJZWxzZQorCQlXUkVHMzJfT1IoRENfSFBEeF9JTlRfQ09OVFJPTChocGQp LCBEQ19IUER4X0lOVF9QT0xBUklUWSk7CiB9CiAKIC8qKgpAQCAtMTgzMyw3ICsxNzYzLDggQEAg dm9pZCBldmVyZ3JlZW5faHBkX2luaXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJCURD X0hQRHhfUlhfSU5UX1RJTUVSKDB4ZmEpIHwgRENfSFBEeF9FTjsKIAogCWxpc3RfZm9yX2VhY2hf ZW50cnkoY29ubmVjdG9yLCAmZGV2LT5tb2RlX2NvbmZpZy5jb25uZWN0b3JfbGlzdCwgaGVhZCkg ewotCQlzdHJ1Y3QgcmFkZW9uX2Nvbm5lY3RvciAqcmFkZW9uX2Nvbm5lY3RvciA9IHRvX3JhZGVv bl9jb25uZWN0b3IoY29ubmVjdG9yKTsKKwkJZW51bSByYWRlb25faHBkX2lkIGhwZCA9CisJCQl0 b19yYWRlb25fY29ubmVjdG9yKGNvbm5lY3RvciktPmhwZC5ocGQ7CiAKIAkJaWYgKGNvbm5lY3Rv ci0+Y29ubmVjdG9yX3R5cGUgPT0gRFJNX01PREVfQ09OTkVDVE9SX2VEUCB8fAogCQkgICAgY29u bmVjdG9yLT5jb25uZWN0b3JfdHlwZSA9PSBEUk1fTU9ERV9DT05ORUNUT1JfTFZEUykgewpAQCAt MTg0NCwzMSArMTc3NSwxNCBAQCB2b2lkIGV2ZXJncmVlbl9ocGRfaW5pdChzdHJ1Y3QgcmFkZW9u X2RldmljZSAqcmRldikKIAkJCSAqLwogCQkJY29udGludWU7CiAJCX0KLQkJc3dpdGNoIChyYWRl b25fY29ubmVjdG9yLT5ocGQuaHBkKSB7Ci0JCWNhc2UgUkFERU9OX0hQRF8xOgotCQkJV1JFRzMy KERDX0hQRDFfQ09OVFJPTCwgdG1wKTsKLQkJCWJyZWFrOwotCQljYXNlIFJBREVPTl9IUERfMjoK LQkJCVdSRUczMihEQ19IUEQyX0NPTlRST0wsIHRtcCk7Ci0JCQlicmVhazsKLQkJY2FzZSBSQURF T05fSFBEXzM6Ci0JCQlXUkVHMzIoRENfSFBEM19DT05UUk9MLCB0bXApOwotCQkJYnJlYWs7Ci0J CWNhc2UgUkFERU9OX0hQRF80OgotCQkJV1JFRzMyKERDX0hQRDRfQ09OVFJPTCwgdG1wKTsKLQkJ CWJyZWFrOwotCQljYXNlIFJBREVPTl9IUERfNToKLQkJCVdSRUczMihEQ19IUEQ1X0NPTlRST0ws IHRtcCk7Ci0JCQlicmVhazsKLQkJY2FzZSBSQURFT05fSFBEXzY6Ci0JCQlXUkVHMzIoRENfSFBE Nl9DT05UUk9MLCB0bXApOwotCQkJYnJlYWs7Ci0JCWRlZmF1bHQ6Ci0JCQlicmVhazsKLQkJfQot CQlyYWRlb25faHBkX3NldF9wb2xhcml0eShyZGV2LCByYWRlb25fY29ubmVjdG9yLT5ocGQuaHBk KTsKLQkJaWYgKHJhZGVvbl9jb25uZWN0b3ItPmhwZC5ocGQgIT0gUkFERU9OX0hQRF9OT05FKQot CQkJZW5hYmxlZCB8PSAxIDw8IHJhZGVvbl9jb25uZWN0b3ItPmhwZC5ocGQ7CisKKwkJaWYgKGhw ZCA9PSBSQURFT05fSFBEX05PTkUpCisJCQljb250aW51ZTsKKworCQlXUkVHMzIoRENfSFBEeF9D T05UUk9MKGhwZCksIHRtcCk7CisJCWVuYWJsZWQgfD0gMSA8PCBocGQ7CisKKwkJcmFkZW9uX2hw ZF9zZXRfcG9sYXJpdHkocmRldiwgaHBkKTsKIAl9CiAJcmFkZW9uX2lycV9rbXNfZW5hYmxlX2hw ZChyZGV2LCBlbmFibGVkKTsKIH0KQEAgLTE4ODgsMzEgKzE4MDIsMTQgQEAgdm9pZCBldmVyZ3Jl ZW5faHBkX2Zpbmkoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJdW5zaWduZWQgZGlzYWJs ZWQgPSAwOwogCiAJbGlzdF9mb3JfZWFjaF9lbnRyeShjb25uZWN0b3IsICZkZXYtPm1vZGVfY29u ZmlnLmNvbm5lY3Rvcl9saXN0LCBoZWFkKSB7Ci0JCXN0cnVjdCByYWRlb25fY29ubmVjdG9yICpy YWRlb25fY29ubmVjdG9yID0gdG9fcmFkZW9uX2Nvbm5lY3Rvcihjb25uZWN0b3IpOwotCQlzd2l0 Y2ggKHJhZGVvbl9jb25uZWN0b3ItPmhwZC5ocGQpIHsKLQkJY2FzZSBSQURFT05fSFBEXzE6Ci0J CQlXUkVHMzIoRENfSFBEMV9DT05UUk9MLCAwKTsKLQkJCWJyZWFrOwotCQljYXNlIFJBREVPTl9I UERfMjoKLQkJCVdSRUczMihEQ19IUEQyX0NPTlRST0wsIDApOwotCQkJYnJlYWs7Ci0JCWNhc2Ug UkFERU9OX0hQRF8zOgotCQkJV1JFRzMyKERDX0hQRDNfQ09OVFJPTCwgMCk7Ci0JCQlicmVhazsK LQkJY2FzZSBSQURFT05fSFBEXzQ6Ci0JCQlXUkVHMzIoRENfSFBENF9DT05UUk9MLCAwKTsKLQkJ CWJyZWFrOwotCQljYXNlIFJBREVPTl9IUERfNToKLQkJCVdSRUczMihEQ19IUEQ1X0NPTlRST0ws IDApOwotCQkJYnJlYWs7Ci0JCWNhc2UgUkFERU9OX0hQRF82OgotCQkJV1JFRzMyKERDX0hQRDZf Q09OVFJPTCwgMCk7Ci0JCQlicmVhazsKLQkJZGVmYXVsdDoKLQkJCWJyZWFrOwotCQl9Ci0JCWlm IChyYWRlb25fY29ubmVjdG9yLT5ocGQuaHBkICE9IFJBREVPTl9IUERfTk9ORSkKLQkJCWRpc2Fi bGVkIHw9IDEgPDwgcmFkZW9uX2Nvbm5lY3Rvci0+aHBkLmhwZDsKKwkJZW51bSByYWRlb25faHBk X2lkIGhwZCA9CisJCQl0b19yYWRlb25fY29ubmVjdG9yKGNvbm5lY3RvciktPmhwZC5ocGQ7CisK KwkJaWYgKGhwZCA9PSBSQURFT05fSFBEX05PTkUpCisJCQljb250aW51ZTsKKworCQlXUkVHMzIo RENfSFBEeF9DT05UUk9MKGhwZCksIDApOworCQlkaXNhYmxlZCB8PSAxIDw8IGhwZDsKIAl9CiAJ cmFkZW9uX2lycV9rbXNfZGlzYWJsZV9ocGQocmRldiwgZGlzYWJsZWQpOwogfQpAQCAtMjYzNyw2 ICsyNTM0LDE1IEBAIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBldmVyZ3JlZW5fZHBfb2Zmc2V0c1td ID0KIAlFVkVSR1JFRU5fRFA1X1JFR0lTVEVSX09GRlNFVAogfTsKIAorc3RhdGljIGNvbnN0IHVu c2lnbmVkIGV2ZXJncmVlbl9kaXNwX2ludF9zdGF0dXNbXSA9Cit7CisJRElTUF9JTlRFUlJVUFRf U1RBVFVTLAorCURJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRSwKKwlESVNQX0lOVEVSUlVQ VF9TVEFUVVNfQ09OVElOVUUyLAorCURJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTMsCisJ RElTUF9JTlRFUlJVUFRfU1RBVFVTX0NPTlRJTlVFNCwKKwlESVNQX0lOVEVSUlVQVF9TVEFUVVNf Q09OVElOVUU1Cit9OwogCiAvKgogICogQXNzdW1wdGlvbiBpcyB0aGF0IEVWRVJHUkVFTl9DUlRD X01BU1RFUl9FTiBlbmFibGUgZm9yIHJlcXVlc3RlZCBjcnRjCkBAIC00NTQzLDYgKzQ0NDksNyBA QCB1MzIgZXZlcmdyZWVuX2dldF92YmxhbmtfY291bnRlcihzdHJ1Y3QgcmFkZW9uX2RldmljZSAq cmRldiwgaW50IGNydGMpCiAKIHZvaWQgZXZlcmdyZWVuX2Rpc2FibGVfaW50ZXJydXB0X3N0YXRl KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogeworCWludCBpOwogCXUzMiB0bXA7CiAKIAlp ZiAocmRldi0+ZmFtaWx5ID49IENISVBfQ0FZTUFOKSB7CkBAIC00NTU4LDE2ICs0NDY1LDggQEAg dm9pZCBldmVyZ3JlZW5fZGlzYWJsZV9pbnRlcnJ1cHRfc3RhdGUoc3RydWN0IHJhZGVvbl9kZXZp Y2UgKnJkZXYpCiAJV1JFRzMyKERNQV9DTlRMLCB0bXApOwogCVdSRUczMihHUkJNX0lOVF9DTlRM LCAwKTsKIAlXUkVHMzIoU1JCTV9JTlRfQ05UTCwgMCk7Ci0JV1JFRzMyKElOVF9NQVNLICsgRVZF UkdSRUVOX0NSVEMwX1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0JV1JFRzMyKElOVF9NQVNLICsgRVZF UkdSRUVOX0NSVEMxX1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0JaWYgKHJkZXYtPm51bV9jcnRjID49 IDQpIHsKLQkJV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMyX1JFR0lTVEVSX09GRlNF VCwgMCk7Ci0JCVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVFTl9DUlRDM19SRUdJU1RFUl9PRkZT RVQsIDApOwotCX0KLQlpZiAocmRldi0+bnVtX2NydGMgPj0gNikgewotCQlXUkVHMzIoSU5UX01B U0sgKyBFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCAwKTsKLQkJV1JFRzMyKElOVF9N QVNLICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0JfQorCWZvciAoaSA9 IDA7IGkgPCByZGV2LT5udW1fY3J0YzsgaSsrKQorCQlXUkVHMzIoSU5UX01BU0sgKyBjcnRjX29m ZnNldHNbaV0sIDApOwogCiAJV1JFRzMyKEdSUEhfSU5UX0NPTlRST0wgKyBFVkVSR1JFRU5fQ1JU QzBfUkVHSVNURVJfT0ZGU0VULCAwKTsKIAlXUkVHMzIoR1JQSF9JTlRfQ09OVFJPTCArIEVWRVJH UkVFTl9DUlRDMV9SRUdJU1RFUl9PRkZTRVQsIDApOwpAQCAtNDU4NSwyNyArNDQ4NCwxNiBAQCB2 b2lkIGV2ZXJncmVlbl9kaXNhYmxlX2ludGVycnVwdF9zdGF0ZShzdHJ1Y3QgcmFkZW9uX2Rldmlj ZSAqcmRldikKIAkJV1JFRzMyKERBQ0FfQVVUT0RFVEVDVF9JTlRfQ09OVFJPTCwgMCk7CiAJV1JF RzMyKERBQ0JfQVVUT0RFVEVDVF9JTlRfQ09OVFJPTCwgMCk7CiAKLQl0bXAgPSBSUkVHMzIoRENf SFBEMV9JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQlXUkVHMzIoRENfSFBE MV9JTlRfQ09OVFJPTCwgdG1wKTsKLQl0bXAgPSBSUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJPTCkg JiBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQlXUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJPTCwgdG1w KTsKLQl0bXAgPSBSUkVHMzIoRENfSFBEM19JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9QT0xB UklUWTsKLQlXUkVHMzIoRENfSFBEM19JTlRfQ09OVFJPTCwgdG1wKTsKLQl0bXAgPSBSUkVHMzIo RENfSFBENF9JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQlXUkVHMzIoRENf SFBENF9JTlRfQ09OVFJPTCwgdG1wKTsKLQl0bXAgPSBSUkVHMzIoRENfSFBENV9JTlRfQ09OVFJP TCkgJiBEQ19IUER4X0lOVF9QT0xBUklUWTsKLQlXUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCwg dG1wKTsKLQl0bXAgPSBSUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9Q T0xBUklUWTsKLQlXUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCwgdG1wKTsKLQorCWZvciAoaSA9 IDA7IGkgPCA2OyBpKyspCisJCVdSRUczMl9BTkQoRENfSFBEeF9JTlRfQ09OVFJPTChpKSwgRENf SFBEeF9JTlRfUE9MQVJJVFkpOwogfQogCisvKiBOb3RlIHRoYXQgdGhlIG9yZGVyIHdlIHdyaXRl IGJhY2sgcmVncyBoZXJlIGlzIGltcG9ydGFudCAqLwogaW50IGV2ZXJncmVlbl9pcnFfc2V0KHN0 cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogeworCWludCBpOwogCXUzMiBjcF9pbnRfY250bCA9 IENOVFhfQlVTWV9JTlRfRU5BQkxFIHwgQ05UWF9FTVBUWV9JTlRfRU5BQkxFOwogCXUzMiBjcF9p bnRfY250bDEgPSAwLCBjcF9pbnRfY250bDIgPSAwOwotCXUzMiBjcnRjMSA9IDAsIGNydGMyID0g MCwgY3J0YzMgPSAwLCBjcnRjNCA9IDAsIGNydGM1ID0gMCwgY3J0YzYgPSAwOwotCXUzMiBocGQx LCBocGQyLCBocGQzLCBocGQ0LCBocGQ1LCBocGQ2OwogCXUzMiBncmJtX2ludF9jbnRsID0gMDsK IAl1MzIgYWZtdDEgPSAwLCBhZm10MiA9IDAsIGFmbXQzID0gMCwgYWZtdDQgPSAwLCBhZm10NSA9 IDAsIGFmbXQ2ID0gMDsKIAl1MzIgZG1hX2NudGwsIGRtYV9jbnRsMSA9IDA7CkBAIC00NjIzLDEy ICs0NTExLDYgQEAgaW50IGV2ZXJncmVlbl9pcnFfc2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpy ZGV2KQogCQlyZXR1cm4gMDsKIAl9CiAKLQlocGQxID0gUlJFRzMyKERDX0hQRDFfSU5UX0NPTlRS T0wpICYgfihEQ19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQlocGQyID0gUlJF RzMyKERDX0hQRDJfSU5UX0NPTlRST0wpICYgfihEQ19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhf SU5UX0VOKTsKLQlocGQzID0gUlJFRzMyKERDX0hQRDNfSU5UX0NPTlRST0wpICYgfihEQ19IUER4 X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQlocGQ0ID0gUlJFRzMyKERDX0hQRDRfSU5U X0NPTlRST0wpICYgfihEQ19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQlocGQ1 ID0gUlJFRzMyKERDX0hQRDVfSU5UX0NPTlRST0wpICYgfihEQ19IUER4X0lOVF9FTiB8IERDX0hQ RHhfUlhfSU5UX0VOKTsKLQlocGQ2ID0gUlJFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wpICYgfihE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKIAlpZiAocmRldi0+ZmFtaWx5ID09 IENISVBfQVJVQkEpCiAJCXRoZXJtYWxfaW50ID0gUlJFRzMyKFROX0NHX1RIRVJNQUxfSU5UX0NU UkwpICYKIAkJCX4oVEhFUk1fSU5UX01BU0tfSElHSCB8IFRIRVJNX0lOVF9NQVNLX0xPVyk7CkBA IC00Njg1LDYwICs0NTY3LDYgQEAgaW50IGV2ZXJncmVlbl9pcnFfc2V0KHN0cnVjdCByYWRlb25f ZGV2aWNlICpyZGV2KQogCQl0aGVybWFsX2ludCB8PSBUSEVSTV9JTlRfTUFTS19ISUdIIHwgVEhF Uk1fSU5UX01BU0tfTE9XOwogCX0KIAotCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzBd IHx8Ci0JICAgIGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBbMF0pKSB7Ci0JCURSTV9ERUJV RygiZXZlcmdyZWVuX2lycV9zZXQ6IHZibGFuayAwXG4iKTsKLQkJY3J0YzEgfD0gVkJMQU5LX0lO VF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsxXSB8fAotCSAgICBh dG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzFdKSkgewotCQlEUk1fREVCVUcoImV2ZXJncmVl bl9pcnFfc2V0OiB2YmxhbmsgMVxuIik7Ci0JCWNydGMyIHw9IFZCTEFOS19JTlRfTUFTSzsKLQl9 Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbMl0gfHwKLQkgICAgYXRvbWljX3JlYWQo JnJkZXYtPmlycS5wZmxpcFsyXSkpIHsKLQkJRFJNX0RFQlVHKCJldmVyZ3JlZW5faXJxX3NldDog dmJsYW5rIDJcbiIpOwotCQljcnRjMyB8PSBWQkxBTktfSU5UX01BU0s7Ci0JfQotCWlmIChyZGV2 LT5pcnEuY3J0Y192YmxhbmtfaW50WzNdIHx8Ci0JICAgIGF0b21pY19yZWFkKCZyZGV2LT5pcnEu cGZsaXBbM10pKSB7Ci0JCURSTV9ERUJVRygiZXZlcmdyZWVuX2lycV9zZXQ6IHZibGFuayAzXG4i KTsKLQkJY3J0YzQgfD0gVkJMQU5LX0lOVF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmNydGNf dmJsYW5rX2ludFs0XSB8fAotCSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzRdKSkg ewotCQlEUk1fREVCVUcoImV2ZXJncmVlbl9pcnFfc2V0OiB2YmxhbmsgNFxuIik7Ci0JCWNydGM1 IHw9IFZCTEFOS19JTlRfTUFTSzsKLQl9Ci0JaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRb NV0gfHwKLQkgICAgYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFs1XSkpIHsKLQkJRFJNX0RF QlVHKCJldmVyZ3JlZW5faXJxX3NldDogdmJsYW5rIDVcbiIpOwotCQljcnRjNiB8PSBWQkxBTktf SU5UX01BU0s7Ci0JfQotCWlmIChyZGV2LT5pcnEuaHBkWzBdKSB7Ci0JCURSTV9ERUJVRygiZXZl cmdyZWVuX2lycV9zZXQ6IGhwZCAxXG4iKTsKLQkJaHBkMSB8PSBEQ19IUER4X0lOVF9FTiB8IERD X0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhwZFsxXSkgewotCQlEUk1fREVC VUcoImV2ZXJncmVlbl9pcnFfc2V0OiBocGQgMlxuIik7Ci0JCWhwZDIgfD0gRENfSFBEeF9JTlRf RU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJkZXYtPmlycS5ocGRbMl0pIHsKLQkJ RFJNX0RFQlVHKCJldmVyZ3JlZW5faXJxX3NldDogaHBkIDNcbiIpOwotCQlocGQzIHw9IERDX0hQ RHhfSU5UX0VOIHwgRENfSFBEeF9SWF9JTlRfRU47Ci0JfQotCWlmIChyZGV2LT5pcnEuaHBkWzNd KSB7Ci0JCURSTV9ERUJVRygiZXZlcmdyZWVuX2lycV9zZXQ6IGhwZCA0XG4iKTsKLQkJaHBkNCB8 PSBEQ19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJx LmhwZFs0XSkgewotCQlEUk1fREVCVUcoImV2ZXJncmVlbl9pcnFfc2V0OiBocGQgNVxuIik7Ci0J CWhwZDUgfD0gRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTjsKLQl9Ci0JaWYgKHJk ZXYtPmlycS5ocGRbNV0pIHsKLQkJRFJNX0RFQlVHKCJldmVyZ3JlZW5faXJxX3NldDogaHBkIDZc biIpOwotCQlocGQ2IHw9IERDX0hQRHhfSU5UX0VOIHwgRENfSFBEeF9SWF9JTlRfRU47Ci0JfQog CWlmIChyZGV2LT5pcnEuYWZtdFswXSkgewogCQlEUk1fREVCVUcoImV2ZXJncmVlbl9pcnFfc2V0 OiBoZG1pIDBcbiIpOwogCQlhZm10MSB8PSBBRk1UX0FaX0ZPUk1BVF9XVFJJR19NQVNLOwpAQCAt NDc3OCwxNSArNDYwNiwxMiBAQCBpbnQgZXZlcmdyZWVuX2lycV9zZXQoc3RydWN0IHJhZGVvbl9k ZXZpY2UgKnJkZXYpCiAKIAlXUkVHMzIoR1JCTV9JTlRfQ05UTCwgZ3JibV9pbnRfY250bCk7CiAK LQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBjcnRj MSk7Ci0JV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMxX1JFR0lTVEVSX09GRlNFVCwg Y3J0YzIpOwotCWlmIChyZGV2LT5udW1fY3J0YyA+PSA0KSB7Ci0JCVdSRUczMihJTlRfTUFTSyAr IEVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIGNydGMzKTsKLQkJV1JFRzMyKElOVF9N QVNLICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgY3J0YzQpOwotCX0KLQlpZiAo cmRldi0+bnVtX2NydGMgPj0gNikgewotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JU QzRfUkVHSVNURVJfT0ZGU0VULCBjcnRjNSk7Ci0JCVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVF Tl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIGNydGM2KTsKKwlmb3IgKGkgPSAwOyBpIDwgcmRldi0+ bnVtX2NydGM7IGkrKykgeworCQlyYWRlb25faXJxX2ttc19zZXRfaXJxX25fZW5hYmxlZCgKKwkJ ICAgIHJkZXYsIElOVF9NQVNLICsgY3J0Y19vZmZzZXRzW2ldLAorCQkgICAgVkJMQU5LX0lOVF9N QVNLLAorCQkgICAgcmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFtpXSB8fAorCQkgICAgYXRvbWlj X3JlYWQoJnJkZXYtPmlycS5wZmxpcFtpXSksICJ2YmxhbmsiLCBpKTsKIAl9CiAKIAlXUkVHMzIo R1JQSF9JTlRfQ09OVFJPTCArIEVWRVJHUkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQsCkBAIC00 ODA2LDEyICs0NjMxLDEzIEBAIGludCBldmVyZ3JlZW5faXJxX3NldChzdHJ1Y3QgcmFkZW9uX2Rl dmljZSAqcmRldikKIAkJICAgICAgIEdSUEhfUEZMSVBfSU5UX01BU0spOwogCX0KIAotCVdSRUcz MihEQ19IUEQxX0lOVF9DT05UUk9MLCBocGQxKTsKLQlXUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJP TCwgaHBkMik7Ci0JV1JFRzMyKERDX0hQRDNfSU5UX0NPTlRST0wsIGhwZDMpOwotCVdSRUczMihE Q19IUEQ0X0lOVF9DT05UUk9MLCBocGQ0KTsKLQlXUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCwg aHBkNSk7Ci0JV1JFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wsIGhwZDYpOworCWZvciAoaSA9IDA7 IGkgPCA2OyBpKyspIHsKKwkJcmFkZW9uX2lycV9rbXNfc2V0X2lycV9uX2VuYWJsZWQoCisJCSAg ICByZGV2LCBEQ19IUER4X0lOVF9DT05UUk9MKGkpLAorCQkgICAgRENfSFBEeF9JTlRfRU4gfCBE Q19IUER4X1JYX0lOVF9FTiwKKwkJICAgIHJkZXYtPmlycS5ocGRbaV0sICJIUEQiLCBpKTsKKwl9 CisKIAlpZiAocmRldi0+ZmFtaWx5ID09IENISVBfQVJVQkEpCiAJCVdSRUczMihUTl9DR19USEVS TUFMX0lOVF9DVFJMLCB0aGVybWFsX2ludCk7CiAJZWxzZQpAQCAtNDgzMCwxNiArNDY1NiwxNiBA QCBpbnQgZXZlcmdyZWVuX2lycV9zZXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJcmV0 dXJuIDA7CiB9CiAKKy8qIE5vdGUgdGhhdCB0aGUgb3JkZXIgd2Ugd3JpdGUgYmFjayByZWdzIGhl cmUgaXMgaW1wb3J0YW50ICovCiBzdGF0aWMgdm9pZCBldmVyZ3JlZW5faXJxX2FjayhzdHJ1Y3Qg cmFkZW9uX2RldmljZSAqcmRldikKIHsKKwlpbnQgaTsKKwl1MzIgKmRpc3BfaW50ID0gcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQ7CiAJdTMyIHRtcDsKIAotCXJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NU QVRVUyk7Ci0JcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCA9IFJS RUczMihESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUUpOwotCXJkZXYtPmlycS5zdGF0X3Jl Z3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRV U19DT05USU5VRTIpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQzID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTMpOwotCXJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ID0gUlJFRzMyKERJU1BfSU5URVJS VVBUX1NUQVRVU19DT05USU5VRTQpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQ1ID0gUlJFRzMyKERJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTUpOwor CWZvciAoaSA9IDA7IGkgPCA2OyBpKyspCisJCWRpc3BfaW50W2ldID0gUlJFRzMyKGV2ZXJncmVl bl9kaXNwX2ludF9zdGF0dXNbaV0pOworCiAJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZDFncnBoX2ludCA9IFJSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzBfUkVH SVNURVJfT0ZGU0VUKTsKIAlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kMmdycGhfaW50 ID0gUlJFRzMyKEdSUEhfSU5UX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RFUl9PRkZT RVQpOwogCWlmIChyZGV2LT5udW1fY3J0YyA+PSA0KSB7CkBAIC00ODYyLDI4ICs0Njg4LDI4IEBA IHN0YXRpYyB2b2lkIGV2ZXJncmVlbl9pcnFfYWNrKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2 KQogCQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMwX1JFR0lTVEVSX09G RlNFVCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwogCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kMmdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQpCiAJCVdSRUczMihH UlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULCBHUlBIX1BG TElQX0lOVF9DTEVBUik7Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3Bf aW50ICYgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBF VkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQlpZiAocmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBMQl9EMV9WTElORV9JTlRFUlJVUFQp Ci0JCVdSRUczMihWTElORV9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VU LCBWTElORV9BQ0spOwotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2lu dF9jb250ICYgTEJfRDJfVkJMQU5LX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZCTEFOS19TVEFUVVMg KyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQlpZiAocmRl di0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmIExCX0QyX1ZMSU5FX0lO VEVSUlVQVCkKLQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMV9SRUdJU1RF Ul9PRkZTRVQsIFZMSU5FX0FDSyk7CisJaWYgKGRpc3BfaW50WzBdICYgTEJfRDFfVkJMQU5LX0lO VEVSUlVQVCkKKwkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBjcnRjX29mZnNldHNbMF0sIFZCTEFO S19BQ0spOworCWlmIChkaXNwX2ludFswXSAmIExCX0QxX1ZMSU5FX0lOVEVSUlVQVCkKKwkJV1JF RzMyKFZMSU5FX1NUQVRVUyArIGNydGNfb2Zmc2V0c1swXSwgVkxJTkVfQUNLKTsKKwlpZiAoZGlz cF9pbnRbMV0gJiBMQl9EMV9WQkxBTktfSU5URVJSVVBUKQorCQlXUkVHMzIoVkJMQU5LX1NUQVRV UyArIGNydGNfb2Zmc2V0c1sxXSwgVkJMQU5LX0FDSyk7CisJaWYgKGRpc3BfaW50WzFdICYgTEJf RDFfVkxJTkVfSU5URVJSVVBUKQorCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsgY3J0Y19vZmZzZXRz WzFdLCBWTElORV9BQ0spOwogCiAJaWYgKHJkZXYtPm51bV9jcnRjID49IDQpIHsKIAkJaWYgKHJk ZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmQzZ3JwaF9pbnQgJiBHUlBIX1BGTElQX0lOVF9P Q0NVUlJFRCkKIAkJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzJfUkVH SVNURVJfT0ZGU0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7CiAJCWlmIChyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kNGdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQpCiAJ CQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNF VCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDIgJiBMQl9EM19WQkxBTktfSU5URVJSVVBUKQotCQkJV1JFRzMy KFZCTEFOS19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzJfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktf QUNLKTsKLQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQy ICYgTEJfRDNfVkxJTkVfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJH UkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7Ci0JCWlmIChyZGV2LT5pcnEu c3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIExCX0Q0X1ZCTEFOS19JTlRFUlJV UFQpCi0JCQlXUkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDM19SRUdJU1RFUl9P RkZTRVQsIFZCTEFOS19BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZGlzcF9pbnRfY29udDMgJiBMQl9ENF9WTElORV9JTlRFUlJVUFQpCi0JCQlXUkVHMzIoVkxJTkVf U1RBVFVTICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgVkxJTkVfQUNLKTsKKwkJ aWYgKGRpc3BfaW50WzJdICYgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkKKwkJCVdSRUczMihWQkxB TktfU1RBVFVTICsgY3J0Y19vZmZzZXRzWzJdLCBWQkxBTktfQUNLKTsKKwkJaWYgKGRpc3BfaW50 WzJdICYgTEJfRDFfVkxJTkVfSU5URVJSVVBUKQorCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIGNy dGNfb2Zmc2V0c1syXSwgVkxJTkVfQUNLKTsKKwkJaWYgKGRpc3BfaW50WzNdICYgTEJfRDFfVkJM QU5LX0lOVEVSUlVQVCkKKwkJCVdSRUczMihWQkxBTktfU1RBVFVTICsgY3J0Y19vZmZzZXRzWzNd LCBWQkxBTktfQUNLKTsKKwkJaWYgKGRpc3BfaW50WzNdICYgTEJfRDFfVkxJTkVfSU5URVJSVVBU KQorCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIGNydGNfb2Zmc2V0c1szXSwgVkxJTkVfQUNLKTsK IAl9CiAKIAlpZiAocmRldi0+bnVtX2NydGMgPj0gNikgewpAQCAtNDg5MSw3NiArNDcxNywyNCBA QCBzdGF0aWMgdm9pZCBldmVyZ3JlZW5faXJxX2FjayhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRl dikKIAkJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJf T0ZGU0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7CiAJCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdz LmV2ZXJncmVlbi5kNmdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQpCiAJCQlXUkVH MzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNFVCwgR1JQ SF9QRkxJUF9JTlRfQ0xFQVIpOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WQkxBTktfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZCTEFO S19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsK LQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICYgTEJf RDVfVkxJTkVfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJHUkVFTl9D UlRDNF9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7Ci0JCWlmIChyZGV2LT5pcnEuc3RhdF9y ZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIExCX0Q2X1ZCTEFOS19JTlRFUlJVUFQpCi0J CQlXUkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQs IFZCTEFOS19BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udDUgJiBMQl9ENl9WTElORV9JTlRFUlJVUFQpCi0JCQlXUkVHMzIoVkxJTkVfU1RBVFVT ICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNFVCwgVkxJTkVfQUNLKTsKLQl9Ci0KLQlp ZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBEQ19IUEQxX0lOVEVS UlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBE Q19IUER4X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MLCB0bXApOwotCX0K LQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmIERDX0hQ RDJfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQyX0lOVF9DT05UUk9MKTsKLQkJ dG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDJfSU5UX0NPTlRST0wsIHRt cCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250 MiAmIERDX0hQRDNfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQzX0lOVF9DT05U Uk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDNfSU5UX0NP TlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNw X2ludF9jb250MyAmIERDX0hQRDRfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ0 X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQ RDRfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJn cmVlbi5kaXNwX2ludF9jb250NCAmIERDX0hQRDVfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUcz MihEQ19IUEQ1X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JF RzMyKERDX0hQRDVfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9y ZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIERDX0hQRDZfSU5URVJSVVBUKSB7Ci0JCXRt cCA9IFJSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FD SzsKLQkJV1JFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCi0JaWYgKHJkZXYt PmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgRENfSFBEMV9SWF9JTlRFUlJVUFQp IHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wpOwotCQl0bXAgfD0gRENfSFBE eF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCwgdG1wKTsKLQl9Ci0J aWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBEQ19IUEQy X1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEMl9JTlRfQ09OVFJPTCk7Ci0J CXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQyX0lOVF9DT05UUk9M LCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRf Y29udDIgJiBEQ19IUEQzX1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEM19J TlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19I UEQzX0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDMgJiBEQ19IUEQ0X1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBS UkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7 Ci0JCVdSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJx LnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBEQ19IUEQ1X1JYX0lOVEVSUlVQ VCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19I UER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MLCB0bXApOwotCX0K LQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJiBEQ19I UEQ2X1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCk7 Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ2X0lOVF9DT05U Uk9MLCB0bXApOworCQlpZiAoZGlzcF9pbnRbNF0gJiBMQl9EMV9WQkxBTktfSU5URVJSVVBUKQor CQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBjcnRjX29mZnNldHNbNF0sIFZCTEFOS19BQ0spOwor CQlpZiAoZGlzcF9pbnRbNF0gJiBMQl9EMV9WTElORV9JTlRFUlJVUFQpCisJCQlXUkVHMzIoVkxJ TkVfU1RBVFVTICsgY3J0Y19vZmZzZXRzWzRdLCBWTElORV9BQ0spOworCQlpZiAoZGlzcF9pbnRb NV0gJiBMQl9EMV9WQkxBTktfSU5URVJSVVBUKQorCQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBj cnRjX29mZnNldHNbNV0sIFZCTEFOS19BQ0spOworCQlpZiAoZGlzcF9pbnRbNV0gJiBMQl9EMV9W TElORV9JTlRFUlJVUFQpCisJCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsgY3J0Y19vZmZzZXRzWzVd LCBWTElORV9BQ0spOworCX0KKworCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspIHsKKwkJaWYgKGRp c3BfaW50W2ldICYgRENfSFBEMV9JTlRFUlJVUFQpCisJCQlXUkVHMzJfT1IoRENfSFBEeF9JTlRf Q09OVFJPTChpKSwgRENfSFBEeF9JTlRfQUNLKTsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgNjsg aSsrKSB7CisJCWlmIChkaXNwX2ludFtpXSAmIERDX0hQRDFfUlhfSU5URVJSVVBUKQorCQkJV1JF RzMyX09SKERDX0hQRHhfSU5UX0NPTlRST0woaSksIERDX0hQRHhfUlhfSU5UX0FDSyk7CiAJfQog CiAJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmFmbXRfc3RhdHVzMSAmIEFGTVRf QVpfRk9STUFUX1dUUklHKSB7CkBAIC01MDM3LDYgKzQ4MTEsOSBAQCBzdGF0aWMgdTMyIGV2ZXJn cmVlbl9nZXRfaWhfd3B0cihzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAogaW50IGV2ZXJn cmVlbl9pcnFfcHJvY2VzcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsKKwl1MzIgKmRp c3BfaW50ID0gcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQ7CisJdTMyIGNy dGNfaWR4LCBocGRfaWR4OworCXUzMiBtYXNrOwogCXUzMiB3cHRyOwogCXUzMiBycHRyOwogCXUz MiBzcmNfaWQsIHNyY19kYXRhOwpAQCAtNTA0Niw2ICs0ODIzLDcgQEAgaW50IGV2ZXJncmVlbl9p cnFfcHJvY2VzcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAlib29sIHF1ZXVlX2RwID0g ZmFsc2U7CiAJYm9vbCBxdWV1ZV90aGVybWFsID0gZmFsc2U7CiAJdTMyIHN0YXR1cywgYWRkcjsK Kwljb25zdCBjaGFyICpldmVudF9uYW1lOwogCiAJaWYgKCFyZGV2LT5paC5lbmFibGVkIHx8IHJk ZXYtPnNodXRkb3duKQogCQlyZXR1cm4gSVJRX05PTkU7CkBAIC01MDc0LDE4NCArNDg1Miw0NCBA QCBpbnQgZXZlcmdyZWVuX2lycV9wcm9jZXNzKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQog CiAJCXN3aXRjaCAoc3JjX2lkKSB7CiAJCWNhc2UgMTogLyogRDEgdmJsYW5rL3ZsaW5lICovCi0J CQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQljYXNlIDA6IC8qIEQxIHZibGFuayAqLwotCQkJCWlm ICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgTEJfRDFfVkJMQU5L X0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQxIHZibGFuayAtIElIIGV2ZW50IHcv byBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5r X2ludFswXSkgewotCQkJCQlkcm1faGFuZGxlX3ZibGFuayhyZGV2LT5kZGV2LCAwKTsKLQkJCQkJ cmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwotCQkJCQl3YWtlX3VwKCZyZGV2LT5pcnEudmJs YW5rX3F1ZXVlKTsKLQkJCQl9Ci0JCQkJaWYgKGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBb MF0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJkZXYsIDApOwotCQkJCXJkZXYt PmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICY9IH5MQl9EMV9WQkxBTktfSU5URVJS VVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQxIHZibGFua1xuIik7Ci0KLQkJCQlicmVhazsKLQkJ CWNhc2UgMTogLyogRDEgdmxpbmUgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2 ZXJncmVlbi5kaXNwX2ludCAmIExCX0QxX1ZMSU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJV RygiSUg6IEQxIHZsaW5lIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQot CQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICY9IH5MQl9EMV9WTElO RV9JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDEgdmxpbmVcbiIpOwotCi0JCQkJYnJl YWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDogJWQg JWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOwotCQkJCWJyZWFrOwotCQkJfQotCQkJYnJlYWs7CiAJ CWNhc2UgMjogLyogRDIgdmJsYW5rL3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0J CQljYXNlIDA6IC8qIEQyIHZibGFuayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3Mu ZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBMQl9EMl9WQkxBTktfSU5URVJSVVBUKSkKLQkJCQkJ RFJNX0RFQlVHKCJJSDogRDIgdmJsYW5rIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/ XG4iKTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzFdKSB7Ci0JCQkJCWRy bV9oYW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDEpOwotCQkJCQlyZGV2LT5wbS52Ymxhbmtfc3lu YyA9IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYtPmlycS52YmxhbmtfcXVldWUpOwotCQkJCX0K LQkJCQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFsxXSkpCi0JCQkJCXJhZGVvbl9j cnRjX2hhbmRsZV92YmxhbmsocmRldiwgMSk7Ci0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udCAmPSB+TEJfRDJfVkJMQU5LX0lOVEVSUlVQVDsKLQkJCQlEUk1f REVCVUcoIklIOiBEMiB2YmxhbmtcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6IC8qIEQy IHZsaW5lICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udCAmIExCX0QyX1ZMSU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQy IHZsaW5lIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYt PmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJj0gfkxCX0QyX1ZMSU5FX0lO VEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBEMiB2bGluZVxuIik7Ci0KLQkJCQlicmVhazsK LQkJCWRlZmF1bHQ6Ci0JCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxu Iiwgc3JjX2lkLCBzcmNfZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQlicmVhazsKIAkJY2Fz ZSAzOiAvKiBEMyB2YmxhbmsvdmxpbmUgKi8KLQkJCXN3aXRjaCAoc3JjX2RhdGEpIHsKLQkJCWNh c2UgMDogLyogRDMgdmJsYW5rICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDIgJiBMQl9EM19WQkxBTktfSU5URVJSVVBUKSkKLQkJCQkJRFJN X0RFQlVHKCJJSDogRDMgdmJsYW5rIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4i KTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzJdKSB7Ci0JCQkJCWRybV9o YW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDIpOwotCQkJCQlyZGV2LT5wbS52Ymxhbmtfc3luYyA9 IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYtPmlycS52YmxhbmtfcXVldWUpOwotCQkJCX0KLQkJ CQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFsyXSkpCi0JCQkJCXJhZGVvbl9jcnRj X2hhbmRsZV92YmxhbmsocmRldiwgMik7Ci0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udDIgJj0gfkxCX0QzX1ZCTEFOS19JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RF QlVHKCJJSDogRDMgdmJsYW5rXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAxOiAvKiBEMyB2 bGluZSAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 X2NvbnQyICYgTEJfRDNfVkxJTkVfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogRDMg dmxpbmUgLSBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDIgJj0gfkxCX0QzX1ZMSU5FX0lO VEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBEMyB2bGluZVxuIik7Ci0KLQkJCQlicmVhazsK LQkJCWRlZmF1bHQ6Ci0JCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxu Iiwgc3JjX2lkLCBzcmNfZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQlicmVhazsKIAkJY2Fz ZSA0OiAvKiBENCB2YmxhbmsvdmxpbmUgKi8KLQkJCXN3aXRjaCAoc3JjX2RhdGEpIHsKLQkJCWNh c2UgMDogLyogRDQgdmJsYW5rICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDMgJiBMQl9ENF9WQkxBTktfSU5URVJSVVBUKSkKLQkJCQkJRFJN X0RFQlVHKCJJSDogRDQgdmJsYW5rIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4i KTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzNdKSB7Ci0JCQkJCWRybV9o YW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDMpOwotCQkJCQlyZGV2LT5wbS52Ymxhbmtfc3luYyA9 IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYtPmlycS52YmxhbmtfcXVldWUpOwotCQkJCX0KLQkJ CQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFszXSkpCi0JCQkJCXJhZGVvbl9jcnRj X2hhbmRsZV92YmxhbmsocmRldiwgMyk7Ci0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udDMgJj0gfkxCX0Q0X1ZCTEFOS19JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RF QlVHKCJJSDogRDQgdmJsYW5rXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAxOiAvKiBENCB2 bGluZSAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 X2NvbnQzICYgTEJfRDRfVkxJTkVfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogRDQg dmxpbmUgLSBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJj0gfkxCX0Q0X1ZMSU5FX0lO VEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENCB2bGluZVxuIik7Ci0KLQkJCQlicmVhazsK LQkJCWRlZmF1bHQ6Ci0JCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxu Iiwgc3JjX2lkLCBzcmNfZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9Ci0JCQlicmVhazsKIAkJY2Fz ZSA1OiAvKiBENSB2YmxhbmsvdmxpbmUgKi8KLQkJCXN3aXRjaCAoc3JjX2RhdGEpIHsKLQkJCWNh c2UgMDogLyogRDUgdmJsYW5rICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WQkxBTktfSU5URVJSVVBUKSkKLQkJCQkJRFJN X0RFQlVHKCJJSDogRDUgdmJsYW5rIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4i KTsKKwkJY2FzZSA2OiAvKiBENiB2YmxhbmsvdmxpbmUgKi8KKwkJCWNydGNfaWR4ID0gc3JjX2lk IC0gMTsKKworCQkJaWYgKHNyY19kYXRhID09IDApIHsgLyogdmJsYW5rICovCisJCQkJbWFzayA9 IExCX0QxX1ZCTEFOS19JTlRFUlJVUFQ7CisJCQkJZXZlbnRfbmFtZSA9ICJ2YmxhbmsiOwogCi0J CQkJaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRbNF0pIHsKLQkJCQkJZHJtX2hhbmRsZV92 YmxhbmsocmRldi0+ZGRldiwgNCk7CisJCQkJaWYgKHJkZXYtPmlycS5jcnRjX3ZibGFua19pbnRb Y3J0Y19pZHhdKSB7CisJCQkJCWRybV9oYW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIGNydGNfaWR4 KTsKIAkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVlOwogCQkJCQl3YWtlX3VwKCZyZGV2 LT5pcnEudmJsYW5rX3F1ZXVlKTsKIAkJCQl9Ci0JCQkJaWYgKGF0b21pY19yZWFkKCZyZGV2LT5p cnEucGZsaXBbNF0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJkZXYsIDQpOwot CQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICY9IH5MQl9E NV9WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQ1IHZibGFua1xuIik7Ci0K LQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDUgdmxpbmUgKi8KLQkJCQlpZiAoIShyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmIExCX0Q1X1ZMSU5FX0lOVEVS UlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQ1IHZsaW5lIC0gSUggZXZlbnQgdy9vIGFzc2Vy dGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQ0ICY9IH5MQl9ENV9WTElORV9JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJ SDogRDUgdmxpbmVcbiIpOworCQkJCWlmIChhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwW2Ny dGNfaWR4XSkpIHsKKwkJCQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhyZGV2LAorCQkJCQkJ CQkgIGNydGNfaWR4KTsKKwkJCQl9CiAKLQkJCQlicmVhazsKLQkJCWRlZmF1bHQ6Ci0JCQkJRFJN X0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwgc3JjX2lkLCBzcmNfZGF0YSk7 CisJCQl9IGVsc2UgaWYgKHNyY19kYXRhID09IDEpIHsgLyogdmxpbmUgKi8KKwkJCQltYXNrID0g TEJfRDFfVkxJTkVfSU5URVJSVVBUOworCQkJCWV2ZW50X25hbWUgPSAidmxpbmUiOworCQkJfSBl bHNlIHsKKwkJCQlEUk1fREVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLAorCQkJ CQkgIHNyY19pZCwgc3JjX2RhdGEpOwogCQkJCWJyZWFrOwogCQkJfQotCQkJYnJlYWs7Ci0JCWNh c2UgNjogLyogRDYgdmJsYW5rL3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQlj YXNlIDA6IC8qIEQ2IHZibGFuayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQ1ICYgTEJfRDZfVkJMQU5LX0lOVEVSUlVQVCkpCi0JCQkJCURS TV9ERUJVRygiSUg6IEQ2IHZibGFuayAtIElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xu Iik7CiAKLQkJCQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFs1XSkgewotCQkJCQlkcm1f aGFuZGxlX3ZibGFuayhyZGV2LT5kZGV2LCA1KTsKLQkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMg PSB0cnVlOwotCQkJCQl3YWtlX3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsKLQkJCQl9Ci0J CQkJaWYgKGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBbNV0pKQotCQkJCQlyYWRlb25fY3J0 Y19oYW5kbGVfdmJsYW5rKHJkZXYsIDUpOwotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdy ZWVuLmRpc3BfaW50X2NvbnQ1ICY9IH5MQl9ENl9WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9E RUJVRygiSUg6IEQ2IHZibGFua1xuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDYg dmxpbmUgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2lu dF9jb250NSAmIExCX0Q2X1ZMSU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IEQ2 IHZsaW5lIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKKwkJCWlmICghKGRp c3BfaW50W2NydGNfaWR4XSAmIG1hc2spKSB7CisJCQkJRFJNX0RFQlVHKCJJSDogRCVkICVzIC0g SUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iLAorCQkJCQkgIGNydGNfaWR4ICsgMSwg ZXZlbnRfbmFtZSk7CisJCQl9CiAKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5k aXNwX2ludF9jb250NSAmPSB+TEJfRDZfVkxJTkVfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygi SUg6IEQ2IHZsaW5lXG4iKTsKKwkJCWRpc3BfaW50W2NydGNfaWR4XSAmPSB+bWFzazsKKwkJCURS TV9ERUJVRygiSUg6IEQlZCAlc1xuIiwgY3J0Y19pZHggKyAxLCBldmVudF9uYW1lKTsKIAotCQkJ CWJyZWFrOwotCQkJZGVmYXVsdDoKLQkJCQlEUk1fREVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6 ICVkICVkXG4iLCBzcmNfaWQsIHNyY19kYXRhKTsKLQkJCQlicmVhazsKLQkJCX0KIAkJCWJyZWFr OwogCQljYXNlIDg6IC8qIEQxIHBhZ2UgZmxpcCAqLwogCQljYXNlIDEwOiAvKiBEMiBwYWdlIGZs aXAgKi8KQEAgLTUyNjQsMTA3ICs0OTAyLDMwIEBAIGludCBldmVyZ3JlZW5faXJxX3Byb2Nlc3Mo c3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJCQkJcmFkZW9uX2NydGNfaGFuZGxlX2ZsaXAo cmRldiwgKHNyY19pZCAtIDgpID4+IDEpOwogCQkJYnJlYWs7CiAJCWNhc2UgNDI6IC8qIEhQRCBo b3RwbHVnICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7Ci0JCQljYXNlIDA6Ci0JCQkJaWYgKCEo cmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBEQ19IUEQxX0lOVEVSUlVQ VCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xu Iik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmPSB+RENf SFBEMV9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfaG90cGx1ZyA9IHRydWU7Ci0JCQkJRFJNX0RFQlVH KCJJSDogSFBEMVxuIik7Ci0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6Ci0JCQkJaWYgKCEocmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmIERDX0hQRDJfSU5URVJSVVBU KSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4i KTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJj0g fkRDX0hQRDJfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVlOwotCQkJCURSTV9E RUJVRygiSUg6IEhQRDJcbiIpOwotCQkJCWJyZWFrOwotCQkJY2FzZSAyOgotCQkJCWlmICghKHJk ZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyICYgRENfSFBEM19JTlRF UlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJp dD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29u dDIgJj0gfkRDX0hQRDNfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVlOwotCQkJ CURSTV9ERUJVRygiSUg6IEhQRDNcbiIpOwotCQkJCWJyZWFrOwotCQkJY2FzZSAzOgotCQkJCWlm ICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICYgRENfSFBE NF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQg aXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udDMgJj0gfkRDX0hQRDRfSU5URVJSVVBUOworCQkJaWYgKHNyY19kYXRhIDw9IDUpIHsK KwkJCQlocGRfaWR4ID0gc3JjX2RhdGE7CisJCQkJbWFzayA9IERDX0hQRDFfSU5URVJSVVBUOwog CQkJCXF1ZXVlX2hvdHBsdWcgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDRcbiIpOwot CQkJCWJyZWFrOwotCQkJY2FzZSA0OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQ0ICYgRENfSFBENV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVC VUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOworCQkJCWV2ZW50X25h bWUgPSAiSFBEIjsKIAotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50 X2NvbnQ0ICY9IH5EQ19IUEQ1X0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsK LQkJCQlEUk1fREVCVUcoIklIOiBIUEQ1XG4iKTsKLQkJCQlicmVhazsKLQkJCWNhc2UgNToKLQkJ CQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIERD X0hQRDZfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2Vy dGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQ1ICY9IH5EQ19IUEQ2X0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9ob3RwbHVnID0g dHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQ2XG4iKTsKLQkJCQlicmVhazsKLQkJCWNhc2Ug NjoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmIERD X0hQRDFfUlhfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFz c2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVu LmRpc3BfaW50ICY9IH5EQ19IUEQxX1JYX0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9kcCA9IHRydWU7 Ci0JCQkJRFJNX0RFQlVHKCJJSDogSFBEX1JYIDFcbiIpOwotCQkJCWJyZWFrOwotCQkJY2FzZSA3 OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQg JiBEQ19IUEQyX1JYX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcv byBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJn cmVlbi5kaXNwX2ludF9jb250ICY9IH5EQ19IUEQyX1JYX0lOVEVSUlVQVDsKKwkJCX0gZWxzZSBp ZiAoc3JjX2RhdGEgPD0gMTEpIHsKKwkJCQlocGRfaWR4ID0gc3JjX2RhdGEgLSA2OworCQkJCW1h c2sgPSBEQ19IUEQxX1JYX0lOVEVSUlVQVDsKIAkJCQlxdWV1ZV9kcCA9IHRydWU7Ci0JCQkJRFJN X0RFQlVHKCJJSDogSFBEX1JYIDJcbiIpOwotCQkJCWJyZWFrOwotCQkJY2FzZSA4OgotCQkJCWlm ICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyICYgRENfSFBE M19SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0 ZWQgaXJxIGJpdD9cbiIpOworCQkJCWV2ZW50X25hbWUgPSAiSFBEX1JYIjsKIAotCQkJCXJkZXYt PmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQyICY9IH5EQ19IUEQzX1JYX0lO VEVSUlVQVDsKLQkJCQlxdWV1ZV9kcCA9IHRydWU7Ci0JCQkJRFJNX0RFQlVHKCJJSDogSFBEX1JY IDNcbiIpOworCQkJfSBlbHNlIHsKKwkJCQlEUk1fREVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6 ICVkICVkXG4iLAorCQkJCQkgIHNyY19pZCwgc3JjX2RhdGEpOwogCQkJCWJyZWFrOwotCQkJY2Fz ZSA5OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQzICYgRENfSFBENF9SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVu dCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOworCQkJfQogCi0JCQkJcmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJj0gfkRDX0hQRDRfUlhfSU5URVJSVVBUOwot CQkJCXF1ZXVlX2RwID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUERfUlggNFxuIik7Ci0J CQkJYnJlYWs7Ci0JCQljYXNlIDEwOgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZl cmdyZWVuLmRpc3BfaW50X2NvbnQ0ICYgRENfSFBENV9SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1f REVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOworCQkJaWYgKCEo ZGlzcF9pbnRbaHBkX2lkeF0gJiBtYXNrKSkKKwkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3 L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwogCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVy Z3JlZW4uZGlzcF9pbnRfY29udDQgJj0gfkRDX0hQRDVfUlhfSU5URVJSVVBUOwotCQkJCXF1ZXVl X2RwID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUERfUlggNVxuIik7Ci0JCQkJYnJlYWs7 Ci0JCQljYXNlIDExOgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQ1ICYgRENfSFBENl9SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklI OiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOworCQkJZGlzcF9pbnRbaHBkX2lk eF0gJj0gfm1hc2s7CisJCQlEUk1fREVCVUcoIklIOiAlcyVkXG4iLCBldmVudF9uYW1lLCBocGRf aWR4ICsgMSk7CiAKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9j b250NSAmPSB+RENfSFBENl9SWF9JTlRFUlJVUFQ7Ci0JCQkJcXVldWVfZHAgPSB0cnVlOwotCQkJ CURSTV9ERUJVRygiSUg6IEhQRF9SWCA2XG4iKTsKLQkJCQlicmVhazsKLQkJCWRlZmF1bHQ6Ci0J CQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwgc3JjX2lkLCBzcmNf ZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9CiAJCQlicmVhazsKIAkJY2FzZSA0NDogLyogaGRtaSAq LwogCQkJc3dpdGNoIChzcmNfZGF0YSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Jh ZGVvbi9yYWRlb24uaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKaW5kZXggYzFj OGUyMi4uYjYwODZlZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24u aAorKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCkBAIC03NjcsMTIgKzc2Nyw3 IEBAIHN0cnVjdCByNjAwX2lycV9zdGF0X3JlZ3MgewogfTsKIAogc3RydWN0IGV2ZXJncmVlbl9p cnFfc3RhdF9yZWdzIHsKLQl1MzIgZGlzcF9pbnQ7Ci0JdTMyIGRpc3BfaW50X2NvbnQ7Ci0JdTMy IGRpc3BfaW50X2NvbnQyOwotCXUzMiBkaXNwX2ludF9jb250MzsKLQl1MzIgZGlzcF9pbnRfY29u dDQ7Ci0JdTMyIGRpc3BfaW50X2NvbnQ1OworCXUzMiBkaXNwX2ludFs2XTsKIAl1MzIgZDFncnBo X2ludDsKIAl1MzIgZDJncnBoX2ludDsKIAl1MzIgZDNncnBoX2ludDsKQEAgLTI5NzYsNiArMjk3 MSwxMiBAQCBpbnQgcjYwMF9jc19jb21tb25fdmxpbmVfcGFyc2Uoc3RydWN0IHJhZGVvbl9jc19w YXJzZXIgKnAsCiAJCQkgICAgICAgdWludDMyX3QgKnZsaW5lX3N0YXJ0X2VuZCwKIAkJCSAgICAg ICB1aW50MzJfdCAqdmxpbmVfc3RhdHVzKTsKIAorLyogaW50ZXJydXB0IGNvbnRyb2wgcmVnaXN0 ZXIgaGVscGVycyAqLwordm9pZCByYWRlb25faXJxX2ttc19zZXRfaXJxX25fZW5hYmxlZChzdHJ1 Y3QgcmFkZW9uX2RldmljZSAqcmRldiwKKwkJCQkgICAgICB1MzIgcmVnLCB1MzIgbWFzaywKKwkJ CQkgICAgICBib29sIGVuYWJsZSwgY29uc3QgY2hhciAqbmFtZSwKKwkJCQkgICAgICB1bnNpZ25l ZCBuKTsKKwogI2luY2x1ZGUgInJhZGVvbl9vYmplY3QuaCIKIAogI2VuZGlmCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMgYi9kcml2ZXJzL2dwdS9k cm0vcmFkZW9uL3JhZGVvbl9pcnFfa21zLmMKaW5kZXggMWI3NTI4ZC4uN2FhY2I0NCAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25faXJxX2ttcy5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2lycV9rbXMuYwpAQCAtNTM4LDMgKzUzOCwzOCBAQCB2 b2lkIHJhZGVvbl9pcnFfa21zX2Rpc2FibGVfaHBkKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2 LCB1bnNpZ25lZCBocGRfbWFzaykKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZyZGV2LT5pcnEu bG9jaywgaXJxZmxhZ3MpOwogfQogCisvKioKKyAqIHJhZGVvbl9pcnFfa21zX3VwZGF0ZV9pbnRf biAtIGhlbHBlciBmb3IgdXBkYXRpbmcgaW50ZXJydXB0IGVuYWJsZSByZWdpc3RlcnMKKyAqCisg KiBAcmRldjogcmFkZW9uIGRldmljZSBwb2ludGVyCisgKiBAcmVnOiB0aGUgcmVnaXN0ZXIgdG8g d3JpdGUgdG8gZW5hYmxlL2Rpc2FibGUgaW50ZXJydXB0cworICogQG1hc2s6IHRoZSBtYXNrIHRo YXQgZW5hYmxlcyB0aGUgaW50ZXJydXB0cworICogQGVuYWJsZTogd2hldGhlciB0byBlbmFibGUg b3IgZGlzYWJsZSB0aGUgaW50ZXJydXB0IHJlZ2lzdGVyCisgKiBAbmFtZTogdGhlIG5hbWUgb2Yg dGhlIGludGVycnVwdCByZWdpc3RlciB0byBwcmludCB0byB0aGUga2VybmVsIGxvZworICogQG51 bTogdGhlIG51bWJlciBvZiB0aGUgaW50ZXJydXB0IHJlZ2lzdGVyIHRvIHByaW50IHRvIHRoZSBr ZXJuZWwgbG9nCisgKgorICogSGVscGVyIGZvciB1cGRhdGluZyB0aGUgZW5hYmxlIHN0YXRlIG9m IGludGVycnVwdCByZWdpc3RlcnMuIENoZWNrcyB3aGV0aGVyCisgKiBvciBub3QgdGhlIGludGVy cnVwdCBtYXRjaGVzIHRoZSBlbmFibGUgc3RhdGUgd2Ugd2FudC4gSWYgaXQgZG9lc24ndCwgdGhl bgorICogd2UgdXBkYXRlIGl0IGFuZCBwcmludCBhIGRlYnVnZ2luZyBtZXNzYWdlIHRvIHRoZSBr ZXJuZWwgbG9nIGluZGljYXRpbmcgdGhlCisgKiBuZXcgc3RhdGUgb2YgdGhlIGludGVycnVwdCBy ZWdpc3Rlci4KKyAqCisgKiBVc2VkIGZvciB1cGRhdGluZyBzZXF1ZW5jZXMgb2YgaW50ZXJydXB0 cyByZWdpc3RlcnMgbGlrZSBIUEQxLCBIUEQyLCBldGMuCisgKi8KK3ZvaWQgcmFkZW9uX2lycV9r bXNfc2V0X2lycV9uX2VuYWJsZWQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsCisJCQkJICAg ICAgdTMyIHJlZywgdTMyIG1hc2ssCisJCQkJICAgICAgYm9vbCBlbmFibGUsIGNvbnN0IGNoYXIg Km5hbWUsIHVuc2lnbmVkIG4pCit7CisJdTMyIHRtcCA9IFJSRUczMihyZWcpOworCisJLyogSW50 ZXJydXB0IHN0YXRlIGRpZG4ndCBjaGFuZ2UgKi8KKwlpZiAoISEodG1wICYgbWFzaykgPT0gZW5h YmxlKQorCQlyZXR1cm47CisKKwlpZiAoZW5hYmxlKSB7CisJCURSTV9ERUJVRygiJXMlZCBpbnRl cnJ1cHRzIGVuYWJsZWRcbiIsIG5hbWUsIG4pOworCQlXUkVHMzIocmVnLCB0bXAgfD0gbWFzayk7 CisJfSBlbHNlIHsKKwkJRFJNX0RFQlVHKCIlcyVkIGludGVycnVwdHMgZGlzYWJsZWRcbiIsIG5h bWUsIG4pOworCQlXUkVHMzIocmVnLCB0bXAgJiB+bWFzayk7CisJfQorfQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9zaS5j CmluZGV4IDc2ZDE4ODguLjgzNTFmMDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRl b24vc2kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3NpLmMKQEAgLTEzOSw2ICsxMzks MzAgQEAgc3RhdGljIHZvaWQgc2lfZmluaV9wZyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldik7 CiBzdGF0aWMgdm9pZCBzaV9maW5pX2NnKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KTsKIHN0 YXRpYyB2b2lkIHNpX3JsY19zdG9wKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KTsKIAorc3Rh dGljIGNvbnN0IHUzMiBjcnRjX29mZnNldHNbXSA9Cit7CisJRVZFUkdSRUVOX0NSVEMwX1JFR0lT VEVSX09GRlNFVCwKKwlFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULAorCUVWRVJHUkVF Tl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsCisJRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNF VCwKKwlFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULAorCUVWRVJHUkVFTl9DUlRDNV9S RUdJU1RFUl9PRkZTRVQKK307CisKK3N0YXRpYyBjb25zdCB1MzIgc2lfZGlzcF9pbnRfc3RhdHVz W10gPQoreworCURJU1BfSU5URVJSVVBUX1NUQVRVUywKKwlESVNQX0lOVEVSUlVQVF9TVEFUVVNf Q09OVElOVUUsCisJRElTUF9JTlRFUlJVUFRfU1RBVFVTX0NPTlRJTlVFMiwKKwlESVNQX0lOVEVS UlVQVF9TVEFUVVNfQ09OVElOVUUzLAorCURJU1BfSU5URVJSVVBUX1NUQVRVU19DT05USU5VRTQs CisJRElTUF9JTlRFUlJVUFRfU1RBVFVTX0NPTlRJTlVFNQorfTsKKworI2RlZmluZSBEQ19IUER4 X0NPTlRST0woeCkgICAgICAgIChEQ19IUEQxX0NPTlRST0wgICAgICsgKHggKiAweGMpKQorI2Rl ZmluZSBEQ19IUER4X0lOVF9DT05UUk9MKHgpICAgIChEQ19IUEQxX0lOVF9DT05UUk9MICsgKHgg KiAweGMpKQorI2RlZmluZSBEQ19IUER4X0lOVF9TVEFUVVNfUkVHKHgpIChEQ19IUEQxX0lOVF9T VEFUVVMgICsgKHggKiAweGMpKQorCiBzdGF0aWMgY29uc3QgdTMyIHZlcmRlX3JsY19zYXZlX3Jl c3RvcmVfcmVnaXN0ZXJfbGlzdFtdID0KIHsKIAkoMHg4MDAwIDw8IDE2KSB8ICgweDk4ZjQgPj4g MiksCkBAIC01OTE2LDYgKzU5NDAsNyBAQCBzdGF0aWMgdm9pZCBzaV9kaXNhYmxlX2ludGVycnVw dHMoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAKIHN0YXRpYyB2b2lkIHNpX2Rpc2FibGVf aW50ZXJydXB0X3N0YXRlKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogeworCWludCBpOwog CXUzMiB0bXA7CiAKIAl0bXAgPSBSUkVHMzIoQ1BfSU5UX0NOVExfUklORzApICYKQEAgLTU5Mjks MTggKzU5NTQsOCBAQCBzdGF0aWMgdm9pZCBzaV9kaXNhYmxlX2ludGVycnVwdF9zdGF0ZShzdHJ1 Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAlXUkVHMzIoRE1BX0NOVEwgKyBETUExX1JFR0lTVEVS X09GRlNFVCwgdG1wKTsKIAlXUkVHMzIoR1JCTV9JTlRfQ05UTCwgMCk7CiAJV1JFRzMyKFNSQk1f SU5UX0NOVEwsIDApOwotCWlmIChyZGV2LT5udW1fY3J0YyA+PSAyKSB7Ci0JCVdSRUczMihJTlRf TUFTSyArIEVWRVJHUkVFTl9DUlRDMF9SRUdJU1RFUl9PRkZTRVQsIDApOwotCQlXUkVHMzIoSU5U X01BU0sgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULCAwKTsKLQl9Ci0JaWYgKHJk ZXYtPm51bV9jcnRjID49IDQpIHsKLQkJV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMy X1JFR0lTVEVSX09GRlNFVCwgMCk7Ci0JCVdSRUczMihJTlRfTUFTSyArIEVWRVJHUkVFTl9DUlRD M19SRUdJU1RFUl9PRkZTRVQsIDApOwotCX0KLQlpZiAocmRldi0+bnVtX2NydGMgPj0gNikgewot CQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCAwKTsK LQkJV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNFVCwgMCk7 Ci0JfQorCWZvciAoaSA9IDA7IGkgPCByZGV2LT5udW1fY3J0YzsgaSsrKQorCQlXUkVHMzIoSU5U X01BU0sgKyBjcnRjX29mZnNldHNbaV0sIDApOwogCiAJaWYgKHJkZXYtPm51bV9jcnRjID49IDIp IHsKIAkJV1JFRzMyKEdSUEhfSU5UX0NPTlRST0wgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJf T0ZGU0VULCAwKTsKQEAgLTU5NTgsMTggKzU5NzMsOSBAQCBzdGF0aWMgdm9pZCBzaV9kaXNhYmxl X2ludGVycnVwdF9zdGF0ZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAlpZiAoIUFTSUNf SVNfTk9EQ0UocmRldikpIHsKIAkJV1JFRzMyKERBQ19BVVRPREVURUNUX0lOVF9DT05UUk9MLCAw KTsKIAotCQl0bXAgPSBSUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCkgJiBEQ19IUER4X0lOVF9Q T0xBUklUWTsKLQkJV1JFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wsIHRtcCk7Ci0JCXRtcCA9IFJS RUczMihEQ19IUEQyX0lOVF9DT05UUk9MKSAmIERDX0hQRHhfSU5UX1BPTEFSSVRZOwotCQlXUkVH MzIoRENfSFBEMl9JTlRfQ09OVFJPTCwgdG1wKTsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDNfSU5U X0NPTlRST0wpICYgRENfSFBEeF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihEQ19IUEQzX0lOVF9D T05UUk9MLCB0bXApOwotCQl0bXAgPSBSUkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCkgJiBEQ19I UER4X0lOVF9QT0xBUklUWTsKLQkJV1JFRzMyKERDX0hQRDRfSU5UX0NPTlRST0wsIHRtcCk7Ci0J CXRtcCA9IFJSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MKSAmIERDX0hQRHhfSU5UX1BPTEFSSVRZ OwotCQlXUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCwgdG1wKTsKLQkJdG1wID0gUlJFRzMyKERD X0hQRDZfSU5UX0NPTlRST0wpICYgRENfSFBEeF9JTlRfUE9MQVJJVFk7Ci0JCVdSRUczMihEQ19I UEQ2X0lOVF9DT05UUk9MLCB0bXApOworCQlmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKQorCQkJV1JF RzMyX0FORChEQ19IUER4X0lOVF9DT05UUk9MKGkpLAorCQkJCSAgIERDX0hQRHhfSU5UX1BPTEFS SVRZKTsKIAl9CiB9CiAKQEAgLTYwNDQsMTIgKzYwNTAsMTIgQEAgc3RhdGljIGludCBzaV9pcnFf aW5pdChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAlyZXR1cm4gcmV0OwogfQogCisvKiBU aGUgb3JkZXIgd2Ugd3JpdGUgYmFjayBlYWNoIHJlZ2lzdGVyIGhlcmUgaXMgaW1wb3J0YW50ICov CiBpbnQgc2lfaXJxX3NldChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsKKwlpbnQgaTsK IAl1MzIgY3BfaW50X2NudGw7CiAJdTMyIGNwX2ludF9jbnRsMSA9IDAsIGNwX2ludF9jbnRsMiA9 IDA7Ci0JdTMyIGNydGMxID0gMCwgY3J0YzIgPSAwLCBjcnRjMyA9IDAsIGNydGM0ID0gMCwgY3J0 YzUgPSAwLCBjcnRjNiA9IDA7Ci0JdTMyIGhwZDEgPSAwLCBocGQyID0gMCwgaHBkMyA9IDAsIGhw ZDQgPSAwLCBocGQ1ID0gMCwgaHBkNiA9IDA7CiAJdTMyIGdyYm1faW50X2NudGwgPSAwOwogCXUz MiBkbWFfY250bCwgZG1hX2NudGwxOwogCXUzMiB0aGVybWFsX2ludCA9IDA7CkBAIC02MDY5LDE1 ICs2MDc1LDYgQEAgaW50IHNpX2lycV9zZXQoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJ Y3BfaW50X2NudGwgPSBSUkVHMzIoQ1BfSU5UX0NOVExfUklORzApICYKIAkJKENOVFhfQlVTWV9J TlRfRU5BQkxFIHwgQ05UWF9FTVBUWV9JTlRfRU5BQkxFKTsKIAotCWlmICghQVNJQ19JU19OT0RD RShyZGV2KSkgewotCQlocGQxID0gUlJFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wpICYgfihEQ19I UER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQkJaHBkMiA9IFJSRUczMihEQ19IUEQy X0lOVF9DT05UUk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lOVF9FTik7Ci0J CWhwZDMgPSBSUkVHMzIoRENfSFBEM19JTlRfQ09OVFJPTCkgJiB+KERDX0hQRHhfSU5UX0VOIHwg RENfSFBEeF9SWF9JTlRfRU4pOwotCQlocGQ0ID0gUlJFRzMyKERDX0hQRDRfSU5UX0NPTlRST0wp ICYgfihEQ19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOKTsKLQkJaHBkNSA9IFJSRUcz MihEQ19IUEQ1X0lOVF9DT05UUk9MKSAmIH4oRENfSFBEeF9JTlRfRU4gfCBEQ19IUER4X1JYX0lO VF9FTik7Ci0JCWhwZDYgPSBSUkVHMzIoRENfSFBENl9JTlRfQ09OVFJPTCkgJiB+KERDX0hQRHhf SU5UX0VOIHwgRENfSFBEeF9SWF9JTlRfRU4pOwotCX0KLQogCWRtYV9jbnRsID0gUlJFRzMyKERN QV9DTlRMICsgRE1BMF9SRUdJU1RFUl9PRkZTRVQpICYgflRSQVBfRU5BQkxFOwogCWRtYV9jbnRs MSA9IFJSRUczMihETUFfQ05UTCArIERNQTFfUkVHSVNURVJfT0ZGU0VUKSAmIH5UUkFQX0VOQUJM RTsKIApAQCAtNjEwNiw2MCArNjEwMyw2IEBAIGludCBzaV9pcnFfc2V0KHN0cnVjdCByYWRlb25f ZGV2aWNlICpyZGV2KQogCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IHN3IGludCBkbWExXG4iKTsK IAkJZG1hX2NudGwxIHw9IFRSQVBfRU5BQkxFOwogCX0KLQlpZiAocmRldi0+aXJxLmNydGNfdmJs YW5rX2ludFswXSB8fAotCSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzBdKSkgewot CQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IHZibGFuayAwXG4iKTsKLQkJY3J0YzEgfD0gVkJMQU5L X0lOVF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsxXSB8fAotCSAg ICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzFdKSkgewotCQlEUk1fREVCVUcoInNpX2ly cV9zZXQ6IHZibGFuayAxXG4iKTsKLQkJY3J0YzIgfD0gVkJMQU5LX0lOVF9NQVNLOwotCX0KLQlp ZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsyXSB8fAotCSAgICBhdG9taWNfcmVhZCgmcmRl di0+aXJxLnBmbGlwWzJdKSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IHZibGFuayAyXG4i KTsKLQkJY3J0YzMgfD0gVkJMQU5LX0lOVF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmNydGNf dmJsYW5rX2ludFszXSB8fAotCSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzNdKSkg ewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IHZibGFuayAzXG4iKTsKLQkJY3J0YzQgfD0gVkJM QU5LX0lOVF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFs0XSB8fAot CSAgICBhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwWzRdKSkgewotCQlEUk1fREVCVUcoInNp X2lycV9zZXQ6IHZibGFuayA0XG4iKTsKLQkJY3J0YzUgfD0gVkJMQU5LX0lOVF9NQVNLOwotCX0K LQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFs1XSB8fAotCSAgICBhdG9taWNfcmVhZCgm cmRldi0+aXJxLnBmbGlwWzVdKSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IHZibGFuayA1 XG4iKTsKLQkJY3J0YzYgfD0gVkJMQU5LX0lOVF9NQVNLOwotCX0KLQlpZiAocmRldi0+aXJxLmhw ZFswXSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IGhwZCAxXG4iKTsKLQkJaHBkMSB8PSBE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhw ZFsxXSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IGhwZCAyXG4iKTsKLQkJaHBkMiB8PSBE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhw ZFsyXSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IGhwZCAzXG4iKTsKLQkJaHBkMyB8PSBE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhw ZFszXSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IGhwZCA0XG4iKTsKLQkJaHBkNCB8PSBE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhw ZFs0XSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IGhwZCA1XG4iKTsKLQkJaHBkNSB8PSBE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KLQlpZiAocmRldi0+aXJxLmhw ZFs1XSkgewotCQlEUk1fREVCVUcoInNpX2lycV9zZXQ6IGhwZCA2XG4iKTsKLQkJaHBkNiB8PSBE Q19IUER4X0lOVF9FTiB8IERDX0hQRHhfUlhfSU5UX0VOOwotCX0KIAogCVdSRUczMihDUF9JTlRf Q05UTF9SSU5HMCwgY3BfaW50X2NudGwpOwogCVdSRUczMihDUF9JTlRfQ05UTF9SSU5HMSwgY3Bf aW50X2NudGwxKTsKQEAgLTYxNzUsMTcgKzYxMTgsMTEgQEAgaW50IHNpX2lycV9zZXQoc3RydWN0 IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJCXRoZXJtYWxfaW50IHw9IFRIRVJNX0lOVF9NQVNLX0hJ R0ggfCBUSEVSTV9JTlRfTUFTS19MT1c7CiAJfQogCi0JaWYgKHJkZXYtPm51bV9jcnRjID49IDIp IHsKLQkJV1JFRzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMwX1JFR0lTVEVSX09GRlNFVCwg Y3J0YzEpOwotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZG U0VULCBjcnRjMik7Ci0JfQotCWlmIChyZGV2LT5udW1fY3J0YyA+PSA0KSB7Ci0JCVdSRUczMihJ TlRfTUFTSyArIEVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIGNydGMzKTsKLQkJV1JF RzMyKElOVF9NQVNLICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgY3J0YzQpOwot CX0KLQlpZiAocmRldi0+bnVtX2NydGMgPj0gNikgewotCQlXUkVHMzIoSU5UX01BU0sgKyBFVkVS R1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCBjcnRjNSk7Ci0JCVdSRUczMihJTlRfTUFTSyAr IEVWRVJHUkVFTl9DUlRDNV9SRUdJU1RFUl9PRkZTRVQsIGNydGM2KTsKKwlmb3IgKGkgPSAwOyBp IDwgcmRldi0+bnVtX2NydGM7IGkrKykgeworCQlyYWRlb25faXJxX2ttc19zZXRfaXJxX25fZW5h YmxlZCgKKwkJICAgIHJkZXYsIElOVF9NQVNLICsgY3J0Y19vZmZzZXRzW2ldLCBWQkxBTktfSU5U X01BU0ssCisJCSAgICByZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50W2ldIHx8CisJCSAgICBhdG9t aWNfcmVhZCgmcmRldi0+aXJxLnBmbGlwW2ldKSwgInZibGFuayIsIGkpOwogCX0KIAogCWlmIChy ZGV2LT5udW1fY3J0YyA+PSAyKSB7CkBAIC02MjA4LDEyICs2MTQ1LDEyIEBAIGludCBzaV9pcnFf c2V0KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCX0KIAogCWlmICghQVNJQ19JU19OT0RD RShyZGV2KSkgewotCQlXUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCwgaHBkMSk7Ci0JCVdSRUcz MihEQ19IUEQyX0lOVF9DT05UUk9MLCBocGQyKTsKLQkJV1JFRzMyKERDX0hQRDNfSU5UX0NPTlRS T0wsIGhwZDMpOwotCQlXUkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCwgaHBkNCk7Ci0JCVdSRUcz MihEQ19IUEQ1X0lOVF9DT05UUk9MLCBocGQ1KTsKLQkJV1JFRzMyKERDX0hQRDZfSU5UX0NPTlRS T0wsIGhwZDYpOworCQlmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKSB7CisJCQlyYWRlb25faXJxX2tt c19zZXRfaXJxX25fZW5hYmxlZCgKKwkJCSAgICByZGV2LCBEQ19IUER4X0lOVF9DT05UUk9MKGkp LAorCQkJICAgIERDX0hQRHhfSU5UX0VOIHwgRENfSFBEeF9SWF9JTlRfRU4sCisJCQkgICAgcmRl di0+aXJxLmhwZFtpXSwgIkhQRCIsIGkpOworCQl9CiAJfQogCiAJV1JFRzMyKENHX1RIRVJNQUxf SU5ULCB0aGVybWFsX2ludCk7CkBAIC02MjI0LDE5ICs2MTYxLDE4IEBAIGludCBzaV9pcnFfc2V0 KHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCXJldHVybiAwOwogfQogCisvKiBUaGUgb3Jk ZXIgd2Ugd3JpdGUgYmFjayBlYWNoIHJlZ2lzdGVyIGhlcmUgaXMgaW1wb3J0YW50ICovCiBzdGF0 aWMgaW5saW5lIHZvaWQgc2lfaXJxX2FjayhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIHsK LQl1MzIgdG1wOworCWludCBpOworCXUzMiAqZGlzcF9pbnQgPSByZGV2LT5pcnEuc3RhdF9yZWdz LmV2ZXJncmVlbi5kaXNwX2ludDsKIAogCWlmIChBU0lDX0lTX05PRENFKHJkZXYpKQogCQlyZXR1 cm47CiAKLQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCA9IFJSRUczMihE SVNQX0lOVEVSUlVQVF9TVEFUVVMpOwotCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50X2NvbnQgPSBSUkVHMzIoRElTUF9JTlRFUlJVUFRfU1RBVFVTX0NPTlRJTlVFKTsKLQly ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiA9IFJSRUczMihESVNQ X0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUUyKTsKLQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJn cmVlbi5kaXNwX2ludF9jb250MyA9IFJSRUczMihESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElO VUUzKTsKLQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCA9IFJS RUczMihESVNQX0lOVEVSUlVQVF9TVEFUVVNfQ09OVElOVUU0KTsKLQlyZGV2LT5pcnEuc3RhdF9y ZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSA9IFJSRUczMihESVNQX0lOVEVSUlVQVF9TVEFU VVNfQ09OVElOVUU1KTsKKwlmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKQorCQlkaXNwX2ludFtpXSA9 IFJSRUczMihzaV9kaXNwX2ludF9zdGF0dXNbaV0pOworCiAJcmRldi0+aXJxLnN0YXRfcmVncy5l dmVyZ3JlZW4uZDFncnBoX2ludCA9IFJSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5f Q1JUQzBfUkVHSVNURVJfT0ZGU0VUKTsKIAlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5k MmdycGhfaW50ID0gUlJFRzMyKEdSUEhfSU5UX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDMV9SRUdJ U1RFUl9PRkZTRVQpOwogCWlmIChyZGV2LT5udW1fY3J0YyA+PSA0KSB7CkBAIC02MjUyLDI4ICs2 MTg4LDI4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBzaV9pcnFfYWNrKHN0cnVjdCByYWRlb25fZGV2 aWNlICpyZGV2KQogCQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMwX1JF R0lTVEVSX09GRlNFVCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwogCWlmIChyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kMmdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQpCiAJ CVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VU LCBHUlBIX1BGTElQX0lOVF9DTEVBUik7Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdy ZWVuLmRpc3BfaW50ICYgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZCTEFOS19T VEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsKLQlp ZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBMQl9EMV9WTElORV9J TlRFUlJVUFQpCi0JCVdSRUczMihWTElORV9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzBfUkVHSVNU RVJfT0ZGU0VULCBWTElORV9BQ0spOwotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVl bi5kaXNwX2ludF9jb250ICYgTEJfRDJfVkJMQU5LX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZCTEFO S19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzFfUkVHSVNURVJfT0ZGU0VULCBWQkxBTktfQUNLKTsK LQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmIExCX0Qy X1ZMSU5FX0lOVEVSUlVQVCkKLQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRD MV9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7CisJaWYgKGRpc3BfaW50WzBdICYgTEJfRDFf VkJMQU5LX0lOVEVSUlVQVCkKKwkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBjcnRjX29mZnNldHNb MF0sIFZCTEFOS19BQ0spOworCWlmIChkaXNwX2ludFswXSAmIExCX0QxX1ZMSU5FX0lOVEVSUlVQ VCkKKwkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIGNydGNfb2Zmc2V0c1swXSwgVkxJTkVfQUNLKTsK KwlpZiAoZGlzcF9pbnRbMV0gJiBMQl9EMV9WQkxBTktfSU5URVJSVVBUKQorCQlXUkVHMzIoVkJM QU5LX1NUQVRVUyArIGNydGNfb2Zmc2V0c1sxXSwgVkJMQU5LX0FDSyk7CisJaWYgKGRpc3BfaW50 WzFdICYgTEJfRDFfVkxJTkVfSU5URVJSVVBUKQorCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsgY3J0 Y19vZmZzZXRzWzFdLCBWTElORV9BQ0spOwogCiAJaWYgKHJkZXYtPm51bV9jcnRjID49IDQpIHsK IAkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmQzZ3JwaF9pbnQgJiBHUlBIX1BG TElQX0lOVF9PQ0NVUlJFRCkKIAkJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5f Q1JUQzJfUkVHSVNURVJfT0ZGU0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7CiAJCWlmIChyZGV2 LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kNGdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0ND VVJSRUQpCiAJCQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lT VEVSX09GRlNFVCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwotCQlpZiAocmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDIgJiBMQl9EM19WQkxBTktfSU5URVJSVVBUKQot CQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzJfUkVHSVNURVJfT0ZGU0VU LCBWQkxBTktfQUNLKTsKLQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3Bf aW50X2NvbnQyICYgTEJfRDNfVkxJTkVfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZMSU5FX1NUQVRV UyArIEVWRVJHUkVFTl9DUlRDMl9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7Ci0JCWlmIChy ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIExCX0Q0X1ZCTEFO S19JTlRFUlJVUFQpCi0JCQlXUkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDM19S RUdJU1RFUl9PRkZTRVQsIFZCTEFOS19BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5l dmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJiBMQl9ENF9WTElORV9JTlRFUlJVUFQpCi0JCQlXUkVH MzIoVkxJTkVfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEMzX1JFR0lTVEVSX09GRlNFVCwgVkxJTkVf QUNLKTsKKwkJaWYgKGRpc3BfaW50WzJdICYgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkKKwkJCVdS RUczMihWQkxBTktfU1RBVFVTICsgY3J0Y19vZmZzZXRzWzJdLCBWQkxBTktfQUNLKTsKKwkJaWYg KGRpc3BfaW50WzJdICYgTEJfRDFfVkxJTkVfSU5URVJSVVBUKQorCQkJV1JFRzMyKFZMSU5FX1NU QVRVUyArIGNydGNfb2Zmc2V0c1syXSwgVkxJTkVfQUNLKTsKKwkJaWYgKGRpc3BfaW50WzNdICYg TEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkKKwkJCVdSRUczMihWQkxBTktfU1RBVFVTICsgY3J0Y19v ZmZzZXRzWzNdLCBWQkxBTktfQUNLKTsKKwkJaWYgKGRpc3BfaW50WzNdICYgTEJfRDFfVkxJTkVf SU5URVJSVVBUKQorCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIGNydGNfb2Zmc2V0c1szXSwgVkxJ TkVfQUNLKTsKIAl9CiAKIAlpZiAocmRldi0+bnVtX2NydGMgPj0gNikgewpAQCAtNjI4MSw3NiAr NjIxNywyNCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgc2lfaXJxX2FjayhzdHJ1Y3QgcmFkZW9uX2Rl dmljZSAqcmRldikKIAkJCVdSRUczMihHUlBIX0lOVF9TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzRf UkVHSVNURVJfT0ZGU0VULCBHUlBIX1BGTElQX0lOVF9DTEVBUik7CiAJCWlmIChyZGV2LT5pcnEu c3RhdF9yZWdzLmV2ZXJncmVlbi5kNmdycGhfaW50ICYgR1JQSF9QRkxJUF9JTlRfT0NDVVJSRUQp CiAJCQlXUkVHMzIoR1JQSF9JTlRfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09G RlNFVCwgR1JQSF9QRkxJUF9JTlRfQ0xFQVIpOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5l dmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WQkxBTktfSU5URVJSVVBUKQotCQkJV1JF RzMyKFZCTEFOS19TVEFUVVMgKyBFVkVSR1JFRU5fQ1JUQzRfUkVHSVNURVJfT0ZGU0VULCBWQkxB TktfQUNLKTsKLQkJaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQ0ICYgTEJfRDVfVkxJTkVfSU5URVJSVVBUKQotCQkJV1JFRzMyKFZMSU5FX1NUQVRVUyArIEVW RVJHUkVFTl9DUlRDNF9SRUdJU1RFUl9PRkZTRVQsIFZMSU5FX0FDSyk7Ci0JCWlmIChyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIExCX0Q2X1ZCTEFOS19JTlRF UlJVUFQpCi0JCQlXUkVHMzIoVkJMQU5LX1NUQVRVUyArIEVWRVJHUkVFTl9DUlRDNV9SRUdJU1RF Ul9PRkZTRVQsIFZCTEFOS19BQ0spOwotCQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udDUgJiBMQl9ENl9WTElORV9JTlRFUlJVUFQpCi0JCQlXUkVHMzIoVkxJ TkVfU1RBVFVTICsgRVZFUkdSRUVOX0NSVEM1X1JFR0lTVEVSX09GRlNFVCwgVkxJTkVfQUNLKTsK LQl9Ci0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJiBEQ19I UEQxX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCk7Ci0J CXRtcCB8PSBEQ19IUER4X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQxX0lOVF9DT05UUk9MLCB0 bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29u dCAmIERDX0hQRDJfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQyX0lOVF9DT05U Uk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDJfSU5UX0NP TlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNw X2ludF9jb250MiAmIERDX0hQRDNfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQz X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQ RDNfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJn cmVlbi5kaXNwX2ludF9jb250MyAmIERDX0hQRDRfSU5URVJSVVBUKSB7Ci0JCXRtcCA9IFJSRUcz MihEQ19IUEQ0X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FDSzsKLQkJV1JF RzMyKERDX0hQRDRfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5pcnEuc3RhdF9y ZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmIERDX0hQRDVfSU5URVJSVVBUKSB7Ci0JCXRt cCA9IFJSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQRHhfSU5UX0FD SzsKLQkJV1JFRzMyKERDX0hQRDVfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCWlmIChyZGV2LT5p cnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmIERDX0hQRDZfSU5URVJSVVBU KSB7Ci0JCXRtcCA9IFJSRUczMihEQ19IUEQ2X0lOVF9DT05UUk9MKTsKLQkJdG1wIHw9IERDX0hQ RHhfSU5UX0FDSzsKLQkJV1JFRzMyKERDX0hQRDZfSU5UX0NPTlRST0wsIHRtcCk7Ci0JfQotCi0J aWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgRENfSFBEMV9SWF9J TlRFUlJVUFQpIHsKLQkJdG1wID0gUlJFRzMyKERDX0hQRDFfSU5UX0NPTlRST0wpOwotCQl0bXAg fD0gRENfSFBEeF9SWF9JTlRfQUNLOwotCQlXUkVHMzIoRENfSFBEMV9JTlRfQ09OVFJPTCwgdG1w KTsKLQl9Ci0JaWYgKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQg JiBEQ19IUEQyX1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBEMl9JTlRfQ09O VFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQyX0lO VF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4u ZGlzcF9pbnRfY29udDIgJiBEQ19IUEQzX1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIo RENfSFBEM19JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdS RUczMihEQ19IUEQzX0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJiBEQ19IUEQ0X1JYX0lOVEVSUlVQVCkgewot CQl0bXAgPSBSUkVHMzIoRENfSFBENF9JTlRfQ09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JY X0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ0X0lOVF9DT05UUk9MLCB0bXApOwotCX0KLQlpZiAo cmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBEQ19IUEQ1X1JY X0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENV9JTlRfQ09OVFJPTCk7Ci0JCXRt cCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ1X0lOVF9DT05UUk9MLCB0 bXApOwotCX0KLQlpZiAocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29u dDUgJiBEQ19IUEQ2X1JYX0lOVEVSUlVQVCkgewotCQl0bXAgPSBSUkVHMzIoRENfSFBENl9JTlRf Q09OVFJPTCk7Ci0JCXRtcCB8PSBEQ19IUER4X1JYX0lOVF9BQ0s7Ci0JCVdSRUczMihEQ19IUEQ2 X0lOVF9DT05UUk9MLCB0bXApOworCQlpZiAoZGlzcF9pbnRbNF0gJiBMQl9EMV9WQkxBTktfSU5U RVJSVVBUKQorCQkJV1JFRzMyKFZCTEFOS19TVEFUVVMgKyBjcnRjX29mZnNldHNbNF0sIFZCTEFO S19BQ0spOworCQlpZiAoZGlzcF9pbnRbNF0gJiBMQl9EMV9WTElORV9JTlRFUlJVUFQpCisJCQlX UkVHMzIoVkxJTkVfU1RBVFVTICsgY3J0Y19vZmZzZXRzWzRdLCBWTElORV9BQ0spOworCQlpZiAo ZGlzcF9pbnRbNV0gJiBMQl9EMV9WQkxBTktfSU5URVJSVVBUKQorCQkJV1JFRzMyKFZCTEFOS19T VEFUVVMgKyBjcnRjX29mZnNldHNbNV0sIFZCTEFOS19BQ0spOworCQlpZiAoZGlzcF9pbnRbNV0g JiBMQl9EMV9WTElORV9JTlRFUlJVUFQpCisJCQlXUkVHMzIoVkxJTkVfU1RBVFVTICsgY3J0Y19v ZmZzZXRzWzVdLCBWTElORV9BQ0spOworCX0KKworCWZvciAoaSA9IDA7IGkgPCA2OyBpKyspIHsK KwkJaWYgKGRpc3BfaW50W2ldICYgRENfSFBEMV9JTlRFUlJVUFQpCisJCQlXUkVHMzJfT1IoRENf SFBEeF9JTlRfQ09OVFJPTChpKSwgRENfSFBEeF9JTlRfQUNLKTsKKwl9CisKKwlmb3IgKGkgPSAw OyBpIDwgNjsgaSsrKSB7CisJCWlmIChkaXNwX2ludFtpXSAmIERDX0hQRDFfUlhfSU5URVJSVVBU KQorCQkJV1JFRzMyX09SKERDX0hQRHhfSU5UX0NPTlRST0woaSksIERDX0hQRHhfUlhfSU5UX0FD Syk7CiAJfQogfQogCkBAIC02NDEyLDYgKzYyOTYsOSBAQCBzdGF0aWMgaW5saW5lIHUzMiBzaV9n ZXRfaWhfd3B0cihzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKICAqLwogaW50IHNpX2lycV9w cm9jZXNzKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogeworCXUzMiAqZGlzcF9pbnQgPSBy ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludDsKKwl1MzIgY3J0Y19pZHgsIGhw ZF9pZHg7CisJdTMyIG1hc2s7CiAJdTMyIHdwdHI7CiAJdTMyIHJwdHI7CiAJdTMyIHNyY19pZCwg c3JjX2RhdGEsIHJpbmdfaWQ7CkBAIC02NDIwLDYgKzYzMDcsNyBAQCBpbnQgc2lfaXJxX3Byb2Nl c3Moc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYpCiAJYm9vbCBxdWV1ZV9kcCA9IGZhbHNlOwog CWJvb2wgcXVldWVfdGhlcm1hbCA9IGZhbHNlOwogCXUzMiBzdGF0dXMsIGFkZHI7CisJY29uc3Qg Y2hhciAqZXZlbnRfbmFtZTsKIAogCWlmICghcmRldi0+aWguZW5hYmxlZCB8fCByZGV2LT5zaHV0 ZG93bikKIAkJcmV0dXJuIElSUV9OT05FOwpAQCAtNjQ0OSwxODQgKzYzMzcsNDQgQEAgaW50IHNp X2lycV9wcm9jZXNzKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQogCiAJCXN3aXRjaCAoc3Jj X2lkKSB7CiAJCWNhc2UgMTogLyogRDEgdmJsYW5rL3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19k YXRhKSB7Ci0JCQljYXNlIDA6IC8qIEQxIHZibGFuayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5z dGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50ICYgTEJfRDFfVkJMQU5LX0lOVEVSUlVQVCkpCi0J CQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0K LQkJCQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFswXSkgewotCQkJCQlkcm1faGFuZGxl X3ZibGFuayhyZGV2LT5kZGV2LCAwKTsKLQkJCQkJcmRldi0+cG0udmJsYW5rX3N5bmMgPSB0cnVl OwotCQkJCQl3YWtlX3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsKLQkJCQl9Ci0JCQkJaWYg KGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBbMF0pKQotCQkJCQlyYWRlb25fY3J0Y19oYW5k bGVfdmJsYW5rKHJkZXYsIDApOwotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRp c3BfaW50ICY9IH5MQl9EMV9WQkxBTktfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQx IHZibGFua1xuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgMTogLyogRDEgdmxpbmUgKi8KLQkJ CQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmIExCX0QxX1ZM SU5FX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRl ZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNw X2ludCAmPSB+TEJfRDFfVkxJTkVfSU5URVJSVVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQxIHZs aW5lXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJZGVmYXVsdDoKLQkJCQlEUk1fREVCVUcoIlVuaGFu ZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBzcmNfaWQsIHNyY19kYXRhKTsKLQkJCQlicmVhazsK LQkJCX0KLQkJCWJyZWFrOwogCQljYXNlIDI6IC8qIEQyIHZibGFuay92bGluZSAqLwotCQkJc3dp dGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAwOiAvKiBEMiB2YmxhbmsgKi8KLQkJCQlpZiAoIShy ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250ICYgTEJfRDJfVkJMQU5L X0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBp cnEgYml0P1xuIik7Ci0KLQkJCQlpZiAocmRldi0+aXJxLmNydGNfdmJsYW5rX2ludFsxXSkgewot CQkJCQlkcm1faGFuZGxlX3ZibGFuayhyZGV2LT5kZGV2LCAxKTsKLQkJCQkJcmRldi0+cG0udmJs YW5rX3N5bmMgPSB0cnVlOwotCQkJCQl3YWtlX3VwKCZyZGV2LT5pcnEudmJsYW5rX3F1ZXVlKTsK LQkJCQl9Ci0JCQkJaWYgKGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBbMV0pKQotCQkJCQly YWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJkZXYsIDEpOwotCQkJCXJkZXYtPmlycS5zdGF0X3Jl Z3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJj0gfkxCX0QyX1ZCTEFOS19JTlRFUlJVUFQ7Ci0J CQkJRFJNX0RFQlVHKCJJSDogRDIgdmJsYW5rXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAx OiAvKiBEMiB2bGluZSAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVu LmRpc3BfaW50X2NvbnQgJiBMQl9EMl9WTElORV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUco IklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJx LnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmPSB+TEJfRDJfVkxJTkVfSU5URVJS VVBUOwotCQkJCURSTV9ERUJVRygiSUg6IEQyIHZsaW5lXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJ ZGVmYXVsdDoKLQkJCQlEUk1fREVCVUcoIlVuaGFuZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBz cmNfaWQsIHNyY19kYXRhKTsKLQkJCQlicmVhazsKLQkJCX0KLQkJCWJyZWFrOwogCQljYXNlIDM6 IC8qIEQzIHZibGFuay92bGluZSAqLwotCQkJc3dpdGNoIChzcmNfZGF0YSkgewotCQkJY2FzZSAw OiAvKiBEMyB2YmxhbmsgKi8KLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVl bi5kaXNwX2ludF9jb250MiAmIExCX0QzX1ZCTEFOS19JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVC VUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJaWYgKHJk ZXYtPmlycS5jcnRjX3ZibGFua19pbnRbMl0pIHsKLQkJCQkJZHJtX2hhbmRsZV92YmxhbmsocmRl di0+ZGRldiwgMik7Ci0JCQkJCXJkZXYtPnBtLnZibGFua19zeW5jID0gdHJ1ZTsKLQkJCQkJd2Fr ZV91cCgmcmRldi0+aXJxLnZibGFua19xdWV1ZSk7Ci0JCQkJfQotCQkJCWlmIChhdG9taWNfcmVh ZCgmcmRldi0+aXJxLnBmbGlwWzJdKSkKLQkJCQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhy ZGV2LCAyKTsKLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250 MiAmPSB+TEJfRDNfVkJMQU5LX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBEMyB2Ymxh bmtcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDE6IC8qIEQzIHZsaW5lICovCi0JCQkJaWYg KCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDIgJiBMQl9EM19W TElORV9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0 ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlz cF9pbnRfY29udDIgJj0gfkxCX0QzX1ZMSU5FX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklI OiBEMyB2bGluZVxuIik7Ci0KLQkJCQlicmVhazsKLQkJCWRlZmF1bHQ6Ci0JCQkJRFJNX0RFQlVH KCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwgc3JjX2lkLCBzcmNfZGF0YSk7Ci0JCQkJ YnJlYWs7Ci0JCQl9Ci0JCQlicmVhazsKIAkJY2FzZSA0OiAvKiBENCB2YmxhbmsvdmxpbmUgKi8K LQkJCXN3aXRjaCAoc3JjX2RhdGEpIHsKLQkJCWNhc2UgMDogLyogRDQgdmJsYW5rICovCi0JCQkJ aWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJiBMQl9E NF9WQkxBTktfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFz c2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50 WzNdKSB7Ci0JCQkJCWRybV9oYW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDMpOwotCQkJCQlyZGV2 LT5wbS52Ymxhbmtfc3luYyA9IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYtPmlycS52Ymxhbmtf cXVldWUpOwotCQkJCX0KLQkJCQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmlycS5wZmxpcFszXSkp Ci0JCQkJCXJhZGVvbl9jcnRjX2hhbmRsZV92YmxhbmsocmRldiwgMyk7Ci0JCQkJcmRldi0+aXJx LnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDMgJj0gfkxCX0Q0X1ZCTEFOS19JTlRF UlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDQgdmJsYW5rXG4iKTsKLQotCQkJCWJyZWFrOwot CQkJY2FzZSAxOiAvKiBENCB2bGluZSAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3Mu ZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICYgTEJfRDRfVkxJTkVfSU5URVJSVVBUKSkKLQkJCQkJ RFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJ CXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICY9IH5MQl9ENF9W TElORV9JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDQgdmxpbmVcbiIpOwotCi0JCQkJ YnJlYWs7Ci0JCQlkZWZhdWx0OgotCQkJCURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDog JWQgJWRcbiIsIHNyY19pZCwgc3JjX2RhdGEpOwotCQkJCWJyZWFrOwotCQkJfQotCQkJYnJlYWs7 CiAJCWNhc2UgNTogLyogRDUgdmJsYW5rL3ZsaW5lICovCi0JCQlzd2l0Y2ggKHNyY19kYXRhKSB7 Ci0JCQljYXNlIDA6IC8qIEQ1IHZibGFuayAqLwotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3Jl Z3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICYgTEJfRDVfVkJMQU5LX0lOVEVSUlVQVCkpCi0J CQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7CisJ CWNhc2UgNjogLyogRDYgdmJsYW5rL3ZsaW5lICovCisJCQljcnRjX2lkeCA9IHNyY19pZCAtIDE7 CisKKwkJCWlmIChzcmNfZGF0YSA9PSAwKSB7IC8qIHZibGFuayAqLworCQkJCW1hc2sgPSBMQl9E MV9WQkxBTktfSU5URVJSVVBUOworCQkJCWV2ZW50X25hbWUgPSAidmJsYW5rIjsKIAotCQkJCWlm IChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50WzRdKSB7Ci0JCQkJCWRybV9oYW5kbGVfdmJsYW5r KHJkZXYtPmRkZXYsIDQpOworCQkJCWlmIChyZGV2LT5pcnEuY3J0Y192YmxhbmtfaW50W2NydGNf aWR4XSkgeworCQkJCQlkcm1faGFuZGxlX3ZibGFuayhyZGV2LT5kZGV2LCBjcnRjX2lkeCk7CiAJ CQkJCXJkZXYtPnBtLnZibGFua19zeW5jID0gdHJ1ZTsKIAkJCQkJd2FrZV91cCgmcmRldi0+aXJx LnZibGFua19xdWV1ZSk7CiAJCQkJfQotCQkJCWlmIChhdG9taWNfcmVhZCgmcmRldi0+aXJxLnBm bGlwWzRdKSkKLQkJCQkJcmFkZW9uX2NydGNfaGFuZGxlX3ZibGFuayhyZGV2LCA0KTsKLQkJCQly ZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmPSB+TEJfRDVfVkJM QU5LX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENSB2YmxhbmtcbiIpOwotCi0JCQkJ YnJlYWs7Ci0JCQljYXNlIDE6IC8qIEQ1IHZsaW5lICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0 YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJiBMQl9ENV9WTElORV9JTlRFUlJVUFQp KQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIp OwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDQgJj0g fkxCX0Q1X1ZMSU5FX0lOVEVSUlVQVDsKLQkJCQlEUk1fREVCVUcoIklIOiBENSB2bGluZVxuIik7 CisJCQkJaWYgKGF0b21pY19yZWFkKCZyZGV2LT5pcnEucGZsaXBbY3J0Y19pZHhdKSkgeworCQkJ CQlyYWRlb25fY3J0Y19oYW5kbGVfdmJsYW5rKHJkZXYsCisJCQkJCQkJCSAgY3J0Y19pZHgpOwor CQkJCX0KIAotCQkJCWJyZWFrOwotCQkJZGVmYXVsdDoKLQkJCQlEUk1fREVCVUcoIlVuaGFuZGxl ZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBzcmNfaWQsIHNyY19kYXRhKTsKKwkJCX0gZWxzZSBpZiAo c3JjX2RhdGEgPT0gMSkgeyAvKiB2bGluZSAqLworCQkJCW1hc2sgPSBMQl9EMV9WTElORV9JTlRF UlJVUFQ7CisJCQkJZXZlbnRfbmFtZSA9ICJ2bGluZSI7CisJCQl9IGVsc2UgeworCQkJCURSTV9E RUJVRygiVW5oYW5kbGVkIGludGVycnVwdDogJWQgJWRcbiIsCisJCQkJCSAgc3JjX2lkLCBzcmNf ZGF0YSk7CiAJCQkJYnJlYWs7CiAJCQl9Ci0JCQlicmVhazsKLQkJY2FzZSA2OiAvKiBENiB2Ymxh bmsvdmxpbmUgKi8KLQkJCXN3aXRjaCAoc3JjX2RhdGEpIHsKLQkJCWNhc2UgMDogLyogRDYgdmJs YW5rICovCi0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRf Y29udDUgJiBMQl9ENl9WQkxBTktfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUgg ZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCWlmIChyZGV2LT5pcnEuY3J0 Y192YmxhbmtfaW50WzVdKSB7Ci0JCQkJCWRybV9oYW5kbGVfdmJsYW5rKHJkZXYtPmRkZXYsIDUp OwotCQkJCQlyZGV2LT5wbS52Ymxhbmtfc3luYyA9IHRydWU7Ci0JCQkJCXdha2VfdXAoJnJkZXYt PmlycS52YmxhbmtfcXVldWUpOwotCQkJCX0KLQkJCQlpZiAoYXRvbWljX3JlYWQoJnJkZXYtPmly cS5wZmxpcFs1XSkpCi0JCQkJCXJhZGVvbl9jcnRjX2hhbmRsZV92YmxhbmsocmRldiwgNSk7Ci0J CQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJj0gfkxCX0Q2 X1ZCTEFOS19JTlRFUlJVUFQ7Ci0JCQkJRFJNX0RFQlVHKCJJSDogRDYgdmJsYW5rXG4iKTsKIAot CQkJCWJyZWFrOwotCQkJY2FzZSAxOiAvKiBENiB2bGluZSAqLwotCQkJCWlmICghKHJkZXYtPmly cS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ1ICYgTEJfRDZfVkxJTkVfSU5URVJS VVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/ XG4iKTsKKwkJCWlmICghKGRpc3BfaW50W2NydGNfaWR4XSAmIG1hc2spKSB7CisJCQkJRFJNX0RF QlVHKCJJSDogRCVkICVzIC0gSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iLAorCQkJ CQkgIGNydGNfaWR4ICsgMSwgZXZlbnRfbmFtZSk7CisJCQl9CiAKLQkJCQlyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250NSAmPSB+TEJfRDZfVkxJTkVfSU5URVJSVVBU OwotCQkJCURSTV9ERUJVRygiSUg6IEQ2IHZsaW5lXG4iKTsKKwkJCWRpc3BfaW50W2NydGNfaWR4 XSAmPSB+bWFzazsKKwkJCURSTV9ERUJVRygiSUg6IEQlZCAlc1xuIiwgY3J0Y19pZHggKyAxLCBl dmVudF9uYW1lKTsKIAotCQkJCWJyZWFrOwotCQkJZGVmYXVsdDoKLQkJCQlEUk1fREVCVUcoIlVu aGFuZGxlZCBpbnRlcnJ1cHQ6ICVkICVkXG4iLCBzcmNfaWQsIHNyY19kYXRhKTsKLQkJCQlicmVh azsKLQkJCX0KIAkJCWJyZWFrOwogCQljYXNlIDg6IC8qIEQxIHBhZ2UgZmxpcCAqLwogCQljYXNl IDEwOiAvKiBEMiBwYWdlIGZsaXAgKi8KQEAgLTY2MzksMTE5ICs2Mzg3LDI5IEBAIGludCBzaV9p cnFfcHJvY2VzcyhzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKIAkJCQlyYWRlb25fY3J0Y19o YW5kbGVfZmxpcChyZGV2LCAoc3JjX2lkIC0gOCkgPj4gMSk7CiAJCQlicmVhazsKIAkJY2FzZSA0 MjogLyogSFBEIGhvdHBsdWcgKi8KLQkJCXN3aXRjaCAoc3JjX2RhdGEpIHsKLQkJCWNhc2UgMDoK LQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludCAmIERDX0hQ RDFfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVk IGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3Bf aW50ICY9IH5EQ19IUEQxX0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsKLQkJ CQlEUk1fREVCVUcoIklIOiBIUEQxXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAxOgotCQkJ CWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQgJiBEQ19I UEQyX0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2ZW50IHcvbyBhc3NlcnRl ZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNw X2ludF9jb250ICY9IH5EQ19IUEQyX0lOVEVSUlVQVDsKKwkJCWlmIChzcmNfZGF0YSA8PSA1KSB7 CisJCQkJaHBkX2lkeCA9IHNyY19kYXRhOworCQkJCW1hc2sgPSBEQ19IUEQxX0lOVEVSUlVQVDsK IAkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQyXG4iKTsK KwkJCQlldmVudF9uYW1lID0gIkhQRCI7CiAKLQkJCQlicmVhazsKLQkJCWNhc2UgMjoKLQkJCQlp ZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MiAmIERDX0hQ RDNfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVk IGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3Bf aW50X2NvbnQyICY9IH5EQ19IUEQzX0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1 ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQzXG4iKTsKLQotCQkJCWJyZWFrOwotCQkJY2FzZSAz OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQz ICYgRENfSFBENF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28g YXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3Jl ZW4uZGlzcF9pbnRfY29udDMgJj0gfkRDX0hQRDRfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2hvdHBs dWcgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRDRcbiIpOwotCi0JCQkJYnJlYWs7Ci0J CQljYXNlIDQ6Ci0JCQkJaWYgKCEocmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udDQgJiBEQ19IUEQ1X0lOVEVSUlVQVCkpCi0JCQkJCURSTV9ERUJVRygiSUg6IElIIGV2 ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7Ci0KLQkJCQlyZGV2LT5pcnEuc3RhdF9yZWdz LmV2ZXJncmVlbi5kaXNwX2ludF9jb250NCAmPSB+RENfSFBENV9JTlRFUlJVUFQ7Ci0JCQkJcXVl dWVfaG90cGx1ZyA9IHRydWU7Ci0JCQkJRFJNX0RFQlVHKCJJSDogSFBENVxuIik7Ci0KLQkJCQli cmVhazsKLQkJCWNhc2UgNToKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVl bi5kaXNwX2ludF9jb250NSAmIERDX0hQRDZfSU5URVJSVVBUKSkKLQkJCQkJRFJNX0RFQlVHKCJJ SDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsKLQotCQkJCXJkZXYtPmlycS5z dGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ1ICY9IH5EQ19IUEQ2X0lOVEVSUlVQVDsK LQkJCQlxdWV1ZV9ob3RwbHVnID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUEQ2XG4iKTsK LQotCQkJCWJyZWFrOwotCQkJY2FzZSA2OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3Mu ZXZlcmdyZWVuLmRpc3BfaW50ICYgRENfSFBEMV9SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVC VUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnQgJj0gfkRDX0hQRDFfUlhfSU5URVJSVVBU OworCQkJfSBlbHNlIGlmIChzcmNfZGF0YSA8PSAxMSkgeworCQkJCWhwZF9pZHggPSBzcmNfZGF0 YSAtIDY7CisJCQkJbWFzayA9IERDX0hQRDFfUlhfSU5URVJSVVBUOwogCQkJCXF1ZXVlX2RwID0g dHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUERfUlggMVxuIik7Ci0KLQkJCQlicmVhazsKLQkJ CWNhc2UgNzoKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3RhdF9yZWdzLmV2ZXJncmVlbi5kaXNwX2lu dF9jb250ICYgRENfSFBEMl9SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBl dmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVn cy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udCAmPSB+RENfSFBEMl9SWF9JTlRFUlJVUFQ7Ci0JCQkJ cXVldWVfZHAgPSB0cnVlOwotCQkJCURSTV9ERUJVRygiSUg6IEhQRF9SWCAyXG4iKTsKLQotCQkJ CWJyZWFrOwotCQkJY2FzZSA4OgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdy ZWVuLmRpc3BfaW50X2NvbnQyICYgRENfSFBEM19SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVC VUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+ aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDIgJj0gfkRDX0hQRDNfUlhfSU5U RVJSVVBUOwotCQkJCXF1ZXVlX2RwID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUERfUlgg M1xuIik7Ci0KLQkJCQlicmVhazsKLQkJCWNhc2UgOToKLQkJCQlpZiAoIShyZGV2LT5pcnEuc3Rh dF9yZWdzLmV2ZXJncmVlbi5kaXNwX2ludF9jb250MyAmIERDX0hQRDRfUlhfSU5URVJSVVBUKSkK LQkJCQkJRFJNX0RFQlVHKCJJSDogSUggZXZlbnQgdy9vIGFzc2VydGVkIGlycSBiaXQ/XG4iKTsK LQotCQkJCXJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQzICY9IH5E Q19IUEQ0X1JYX0lOVEVSUlVQVDsKLQkJCQlxdWV1ZV9kcCA9IHRydWU7Ci0JCQkJRFJNX0RFQlVH KCJJSDogSFBEX1JYIDRcbiIpOwotCi0JCQkJYnJlYWs7Ci0JCQljYXNlIDEwOgotCQkJCWlmICgh KHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2NvbnQ0ICYgRENfSFBENV9S WF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVudCB3L28gYXNzZXJ0ZWQg aXJxIGJpdD9cbiIpOwotCi0JCQkJcmRldi0+aXJxLnN0YXRfcmVncy5ldmVyZ3JlZW4uZGlzcF9p bnRfY29udDQgJj0gfkRDX0hQRDVfUlhfSU5URVJSVVBUOwotCQkJCXF1ZXVlX2RwID0gdHJ1ZTsK LQkJCQlEUk1fREVCVUcoIklIOiBIUERfUlggNVxuIik7CisJCQkJZXZlbnRfbmFtZSA9ICJIUERf UlgiOwogCisJCQl9IGVsc2UgeworCQkJCURSTV9ERUJVRygiVW5oYW5kbGVkIGludGVycnVwdDog JWQgJWRcbiIsCisJCQkJCSAgc3JjX2lkLCBzcmNfZGF0YSk7CiAJCQkJYnJlYWs7Ci0JCQljYXNl IDExOgotCQkJCWlmICghKHJkZXYtPmlycS5zdGF0X3JlZ3MuZXZlcmdyZWVuLmRpc3BfaW50X2Nv bnQ1ICYgRENfSFBENl9SWF9JTlRFUlJVUFQpKQotCQkJCQlEUk1fREVCVUcoIklIOiBJSCBldmVu dCB3L28gYXNzZXJ0ZWQgaXJxIGJpdD9cbiIpOworCQkJfQogCi0JCQkJcmRldi0+aXJxLnN0YXRf cmVncy5ldmVyZ3JlZW4uZGlzcF9pbnRfY29udDUgJj0gfkRDX0hQRDZfUlhfSU5URVJSVVBUOwot CQkJCXF1ZXVlX2RwID0gdHJ1ZTsKLQkJCQlEUk1fREVCVUcoIklIOiBIUERfUlggNlxuIik7CisJ CQlpZiAoIShkaXNwX2ludFtocGRfaWR4XSAmIG1hc2spKQorCQkJCURSTV9ERUJVRygiSUg6IElI IGV2ZW50IHcvbyBhc3NlcnRlZCBpcnEgYml0P1xuIik7CiAKLQkJCQlicmVhazsKLQkJCWRlZmF1 bHQ6Ci0JCQkJRFJNX0RFQlVHKCJVbmhhbmRsZWQgaW50ZXJydXB0OiAlZCAlZFxuIiwgc3JjX2lk LCBzcmNfZGF0YSk7Ci0JCQkJYnJlYWs7Ci0JCQl9CisJCQlkaXNwX2ludFtocGRfaWR4XSAmPSB+ bWFzazsKKwkJCURSTV9ERUJVRygiSUg6ICVzJWRcbiIsIGV2ZW50X25hbWUsIGhwZF9pZHggKyAx KTsKIAkJCWJyZWFrOwogCQljYXNlIDk2OgogCQkJRFJNX0VSUk9SKCJTUkJNX1JFQURfRVJST1I6 IDB4JXhcbiIsIFJSRUczMihTUkJNX1JFQURfRVJST1IpKTsKLS0gCjIuOS40CgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlz dAphbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2FtZC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932767AbdESXtO (ORCPT ); Fri, 19 May 2017 19:49:14 -0400 Received: from mx1.redhat.com ([209.132.183.28]:41862 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932306AbdESXtG (ORCPT ); Fri, 19 May 2017 19:49:06 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com 34C1EC057FAD Authentication-Results: ext-mx08.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx08.extmail.prod.ext.phx2.redhat.com; spf=pass smtp.mailfrom=lyude@redhat.com DKIM-Filter: OpenDKIM Filter v2.11.0 mx1.redhat.com 34C1EC057FAD 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 v2 1/3] drm/radeon: Cleanup display interrupt handling for evergreen, si Date: Fri, 19 May 2017 19:48:37 -0400 Message-Id: <20170519234840.5644-2-lyude@redhat.com> In-Reply-To: <20170519234840.5644-1-lyude@redhat.com> References: <20170516211202.20325-1-lyude@redhat.com> <20170519234840.5644-1-lyude@redhat.com> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Fri, 19 May 2017 23:49:06 +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. Note in this commit, since vblank/vline irq acking is intertwined with page flip irq acking, we can't cut out all of the copy paste in evergreen/si_irq_ack() just yet. Changes since v1: - Preserve order we write back all registers Signed-off-by: Lyude --- drivers/gpu/drm/radeon/evergreen.c | 729 +++++++------------------------- drivers/gpu/drm/radeon/radeon.h | 13 +- drivers/gpu/drm/radeon/radeon_irq_kms.c | 35 ++ drivers/gpu/drm/radeon/si.c | 596 ++++++-------------------- 4 files changed, 314 insertions(+), 1059 deletions(-) diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c index 0bf1035..44ac6d3 100644 --- a/drivers/gpu/drm/radeon/evergreen.c +++ b/drivers/gpu/drm/radeon/evergreen.c @@ -35,6 +35,10 @@ #include "evergreen_blit_shaders.h" #include "radeon_ucode.h" +#define DC_HPDx_CONTROL(x) (DC_HPD1_CONTROL + (x * 0xc)) +#define DC_HPDx_INT_CONTROL(x) (DC_HPD1_INT_CONTROL + (x * 0xc)) +#define DC_HPDx_INT_STATUS_REG(x) (DC_HPD1_INT_STATUS + (x * 0xc)) + /* * Indirect registers accessor */ @@ -1714,38 +1718,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_REG(hpd)) & DC_HPDx_SENSE); } /** @@ -1759,61 +1735,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 +1763,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 +1775,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 +1802,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); } @@ -2637,6 +2534,15 @@ static const unsigned evergreen_dp_offsets[] = EVERGREEN_DP5_REGISTER_OFFSET }; +static const unsigned evergreen_disp_int_status[] = +{ + DISP_INTERRUPT_STATUS, + DISP_INTERRUPT_STATUS_CONTINUE, + DISP_INTERRUPT_STATUS_CONTINUE2, + DISP_INTERRUPT_STATUS_CONTINUE3, + DISP_INTERRUPT_STATUS_CONTINUE4, + DISP_INTERRUPT_STATUS_CONTINUE5 +}; /* * Assumption is that EVERGREEN_CRTC_MASTER_EN enable for requested crtc @@ -4543,6 +4449,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 +4465,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 +4484,16 @@ 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 < 6; i++) + WREG32_AND(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_POLARITY); } +/* Note that the order we write back regs here is important */ 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 +4511,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 +4567,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,15 +4606,12 @@ 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); + 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(GRPH_INT_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET, @@ -4806,12 +4631,13 @@ 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 < 6; 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 (rdev->family == CHIP_ARUBA) WREG32(TN_CG_THERMAL_INT_CTRL, thermal_int); else @@ -4830,16 +4656,16 @@ int evergreen_irq_set(struct radeon_device *rdev) return 0; } +/* Note that the order we write back regs here is important */ 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 < 6; i++) + disp_int[i] = RREG32(evergreen_disp_int_status[i]); + 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,28 @@ 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 (disp_int[0] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[0], VBLANK_ACK); + if (disp_int[0] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[0], VLINE_ACK); + if (disp_int[1] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[1], VBLANK_ACK); + if (disp_int[1] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[1], 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 (disp_int[2] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[2], VBLANK_ACK); + if (disp_int[2] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[2], VLINE_ACK); + if (disp_int[3] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[3], VBLANK_ACK); + if (disp_int[3] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[3], VLINE_ACK); } if (rdev->num_crtc >= 6) { @@ -4891,76 +4717,24 @@ 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 (disp_int[4] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[4], VBLANK_ACK); + if (disp_int[4] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[4], VLINE_ACK); + if (disp_int[5] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[5], VBLANK_ACK); + if (disp_int[5] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[5], VLINE_ACK); + } + + for (i = 0; i < 6; i++) { + if (disp_int[i] & DC_HPD1_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_ACK); + } + + for (i = 0; i < 6; i++) { + if (disp_int[i] & DC_HPD1_RX_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_RX_INT_ACK); } if (rdev->irq.stat_regs.evergreen.afmt_status1 & AFMT_AZ_FORMAT_WTRIG) { @@ -5037,6 +4811,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 +4823,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 +4852,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 (src_data == 0) { /* vblank */ + mask = LB_D1_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: 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_D1_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 +4902,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_HPD1_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_HPD1_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/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..8351f06 100644 --- a/drivers/gpu/drm/radeon/si.c +++ b/drivers/gpu/drm/radeon/si.c @@ -139,6 +139,30 @@ 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 si_disp_int_status[] = +{ + DISP_INTERRUPT_STATUS, + DISP_INTERRUPT_STATUS_CONTINUE, + DISP_INTERRUPT_STATUS_CONTINUE2, + DISP_INTERRUPT_STATUS_CONTINUE3, + DISP_INTERRUPT_STATUS_CONTINUE4, + DISP_INTERRUPT_STATUS_CONTINUE5 +}; + +#define DC_HPDx_CONTROL(x) (DC_HPD1_CONTROL + (x * 0xc)) +#define DC_HPDx_INT_CONTROL(x) (DC_HPD1_INT_CONTROL + (x * 0xc)) +#define DC_HPDx_INT_STATUS_REG(x) (DC_HPD1_INT_STATUS + (x * 0xc)) + static const u32 verde_rlc_save_restore_register_list[] = { (0x8000 << 16) | (0x98f4 >> 2), @@ -5916,6 +5940,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 +5954,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 +5973,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 < 6; i++) + WREG32_AND(DC_HPDx_INT_CONTROL(i), + DC_HPDx_INT_POLARITY); } } @@ -6044,12 +6050,12 @@ static int si_irq_init(struct radeon_device *rdev) return ret; } +/* The order we write back each register here is important */ 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 +6075,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 +6103,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); @@ -6175,17 +6118,11 @@ int si_irq_set(struct radeon_device *rdev) thermal_int |= THERM_INT_MASK_HIGH | THERM_INT_MASK_LOW; } - 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); + 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); } if (rdev->num_crtc >= 2) { @@ -6208,12 +6145,12 @@ 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 < 6; 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); + } } WREG32(CG_THERMAL_INT, thermal_int); @@ -6224,19 +6161,18 @@ int si_irq_set(struct radeon_device *rdev) return 0; } +/* The order we write back each register here is important */ 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); + for (i = 0; i < 6; i++) + disp_int[i] = RREG32(si_disp_int_status[i]); + 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) { @@ -6252,28 +6188,28 @@ static inline void si_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 (disp_int[0] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[0], VBLANK_ACK); + if (disp_int[0] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[0], VLINE_ACK); + if (disp_int[1] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[1], VBLANK_ACK); + if (disp_int[1] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[1], 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 (disp_int[2] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[2], VBLANK_ACK); + if (disp_int[2] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[2], VLINE_ACK); + if (disp_int[3] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[3], VBLANK_ACK); + if (disp_int[3] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[3], VLINE_ACK); } if (rdev->num_crtc >= 6) { @@ -6281,76 +6217,24 @@ 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); + if (disp_int[4] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[4], VBLANK_ACK); + if (disp_int[4] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[4], VLINE_ACK); + if (disp_int[5] & LB_D1_VBLANK_INTERRUPT) + WREG32(VBLANK_STATUS + crtc_offsets[5], VBLANK_ACK); + if (disp_int[5] & LB_D1_VLINE_INTERRUPT) + WREG32(VLINE_STATUS + crtc_offsets[5], VLINE_ACK); + } + + for (i = 0; i < 6; i++) { + if (disp_int[i] & DC_HPD1_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_INT_ACK); + } + + for (i = 0; i < 6; i++) { + if (disp_int[i] & DC_HPD1_RX_INTERRUPT) + WREG32_OR(DC_HPDx_INT_CONTROL(i), DC_HPDx_RX_INT_ACK); } } @@ -6412,6 +6296,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 +6307,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 +6337,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_D1_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_D1_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 +6387,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_HPD1_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_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; - 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)); -- 2.9.4