LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgICAgICAKICogRmlsZW5hbWU6ICAgICAgbmV0d2F2ZV9jcy5jCiAqIFZlcnNpb246ICAgICAgIDAuNC4xCiAqIERlc2NyaXB0aW9uOiAgIE5ldHdhdmUgQWlyU3VyZmVyIFdpcmVsZXNzIExBTiBQQyBDYXJkIGRyaXZlcgogKiBTdGF0dXM6ICAgICAgICBFeHBlcmltZW50YWwuCiAqIEF1dGhvcnM6ICAgICAgIEpvaG4gTWFya3VzIEJq+HJuZGFsZW4gPGpvaG5tQGNzLnVpdC5ubz4KICogICAgICAgICAgICAgICAgRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPgogKiAgICAgICAgICAgICAgICBEYXZpZCBIaW5kcyA8ZGFoaW5kc0B1c2Vycy5zb3VyY2Vmb3JnZS5uZXQ+CiAqIENyZWF0ZWQgYXQ6ICAgIEEgbG9uZyB0aW1lIGFnbyEKICogTW9kaWZpZWQgYXQ6ICAgTW9uIE5vdiAxMCAxMTo1NDozNyAxOTk3CiAqIE1vZGlmaWVkIGJ5OiAgIERhZyBCcmF0dGxpIDxkYWdiQGNzLnVpdC5ubz4KICogCiAqICAgICBDb3B5cmlnaHQgKGMpIDE5OTcgVW5pdmVyc2l0eSBvZiBUcm9tc/gsIE5vcndheQogKgogKiBSZXZpc2lvbiBIaXN0b3J5OgogKgogKiAgIDA4LU5vdi05NyAxNToxNDo0NyAgIEpvaG4gTWFya3VzIEJq+HJuZGFsZW4gPGpvaG5tQGNzLnVpdC5ubz4KICogICAgLSBGaXhlZCBzb21lIGJ1Z3MgaW4gbmV0d2F2ZV9yeCBhbmQgY2xlYW5lZCBpdCB1cCBhIGJpdC4gCiAqICAgICAgKE9uZSBvZiB0aGUgYnVncyB3b3VsZCBoYXZlIGRlc3Ryb3llZCBwYWNrZXRzIHdoZW4gcmVjZWl2aW5nCiAqICAgICAgbXVsdGlwbGUgcGFja2V0cyBwZXIgaW50ZXJydXB0KS4gCiAqICAgIC0gQ2xlYW5lZCB1cCBwYXJ0cyBvZiBuZXdhdmVfaHdfeG1pdC4gCiAqICAgIC0gQSBmZXcgZ2VuZXJhbCBjbGVhbnVwcy4gCiAqICAgMjQtT2N0LTk3IDEzOjE3OjM2ICAgRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPgogKiAgICAtIEZpeGVkIG5ldHdhdmVfcnggcmVjZWl2ZSBmdW5jdGlvbiAoZ290IHVwZGF0ZWQgZG9jcykKICogICBPdGhlcnM6CiAqICAgIC0gQ2hhbmdlZCBuYW1lIGZyb20geGlyY253IHRvIG5ldHdhdmUsIHRha2UgYSBsb29rIGF0IAogKiAgICAgIGh0dHA6Ly93d3cubmV0d2F2ZS13aXJlbGVzcy5jb20KICogICAgLSBTb21lIHJlb3JnYW5pemluZyBvZiB0aGUgY29kZQogKiAgICAtIFJlbW92ZWQgcG9zc2libGUgcmFjZSBjb25kaXRpb24gYmV0d2VlbiBpbnRlcnJ1cHQgaGFuZGxlciBhbmQgdHJhbnNtaXQKICogICAgICBmdW5jdGlvbgogKiAgICAtIFN0YXJ0ZWQgdG8gYWRkIHdpcmVsZXNzIGV4dGVuc2lvbnMsIGJ1dCBzdGlsbCBuZWVkcyBzb21lIGNvZGluZwogKiAgICAtIEFkZGVkIHdhdGNoZG9nIGZvciBiZXR0ZXIgaGFuZGxpbmcgb2YgdHJhbnNtaXNzaW9uIHRpbWVvdXRzIAogKiAgICAgIChob3BlZnVsbHkgdGhpcyB3b3JrcyBiZXR0ZXIpCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCi8qIFRvIGhhdmUgc3RhdGlzdGljcyAoanVzdCBwYWNrZXRzIHNlbnQpIGRlZmluZSB0aGlzICovCiN1bmRlZiBORVRXQVZFX1NUQVRTCgojaW5jbHVkZSA8bGludXgvY29uZmlnLmg+CiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KI2luY2x1ZGUgPGxpbnV4L2ZjbnRsLmg+CiNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgojaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiNpbmNsdWRlIDxsaW51eC9pbi5oPgojaW5jbHVkZSA8bGludXgvc2xhYi5oPgojaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiNpbmNsdWRlIDxsaW51eC90aW1lci5oPgojaW5jbHVkZSA8bGludXgvZXJybm8uaD4KI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgojaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgojaW5jbHVkZSA8bGludXgvYml0b3BzLmg+CiNpbmNsdWRlIDxsaW51eC93aXJlbGVzcy5oPgojaW5jbHVkZSA8bmV0L2l3X2hhbmRsZXIuaD4KCiNpbmNsdWRlIDxwY21jaWEvY3NfdHlwZXMuaD4KI2luY2x1ZGUgPHBjbWNpYS9jcy5oPgojaW5jbHVkZSA8cGNtY2lhL2Npc3RwbC5oPgojaW5jbHVkZSA8cGNtY2lhL2Npc3JlZy5oPgojaW5jbHVkZSA8cGNtY2lhL2RzLmg+CiNpbmNsdWRlIDxwY21jaWEvbWVtX29wLmg+CgojaW5jbHVkZSA8YXNtL3N5c3RlbS5oPgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxhc20vZG1hLmg+CgojZGVmaW5lIE5FVFdBVkVfUkVHT0ZGICAgICAgICAgMHg4MDAwCi8qIFRoZSBOZXR3YXZlIElPIHJlZ2lzdGVycywgb2Zmc2V0cyB0byBpb2Jhc2UgKi8KI2RlZmluZSBORVRXQVZFX1JFR19DT1IgICAgICAgIDB4MAojZGVmaW5lIE5FVFdBVkVfUkVHX0NDU1IgICAgICAgMHgyCiNkZWZpbmUgTkVUV0FWRV9SRUdfQVNSICAgICAgICAweDQKI2RlZmluZSBORVRXQVZFX1JFR19JTVIgICAgICAgIDB4YQojZGVmaW5lIE5FVFdBVkVfUkVHX1BNUiAgICAgICAgMHhjCiNkZWZpbmUgTkVUV0FWRV9SRUdfSU9MT1cgICAgICAweDYKI2RlZmluZSBORVRXQVZFX1JFR19JT0hJICAgICAgIDB4NwojZGVmaW5lIE5FVFdBVkVfUkVHX0lPQ09OVFJPTCAgMHg4CiNkZWZpbmUgTkVUV0FWRV9SRUdfREFUQSAgICAgICAweGYKLyogVGhlIE5ldHdhdmUgRXh0ZW5kZWQgSU8gcmVnaXN0ZXJzLCBvZmZzZXRzIHRvIFJhbUJhc2UgKi8KI2RlZmluZSBORVRXQVZFX0VSRUdfQVNDQyAgICAgIDB4MTE0CiNkZWZpbmUgTkVUV0FWRV9FUkVHX1JTRVIgICAgICAweDEyMAojZGVmaW5lIE5FVFdBVkVfRVJFR19SU0VSVyAgICAgMHgxMjQKI2RlZmluZSBORVRXQVZFX0VSRUdfVFNFUiAgICAgIDB4MTMwCiNkZWZpbmUgTkVUV0FWRV9FUkVHX1RTRVJXICAgICAweDEzNAojZGVmaW5lIE5FVFdBVkVfRVJFR19DQiAgICAgICAgMHgxMDAKI2RlZmluZSBORVRXQVZFX0VSRUdfU1BDUSAgICAgIDB4MTU0CiNkZWZpbmUgTkVUV0FWRV9FUkVHX1NQVSAgICAgICAweDE1NQojZGVmaW5lIE5FVFdBVkVfRVJFR19MSUYgICAgICAgMHgxNGUKI2RlZmluZSBORVRXQVZFX0VSRUdfSVNQTFEgICAgIDB4MTU2CiNkZWZpbmUgTkVUV0FWRV9FUkVHX0hIQyAgICAgICAweDE1OAojZGVmaW5lIE5FVFdBVkVfRVJFR19OSSAgICAgICAgMHgxNmUKI2RlZmluZSBORVRXQVZFX0VSRUdfTUhTICAgICAgIDB4MTZiCiNkZWZpbmUgTkVUV0FWRV9FUkVHX1REUCAgICAgICAweDE0MAojZGVmaW5lIE5FVFdBVkVfRVJFR19SRFAgICAgICAgMHgxNTAKI2RlZmluZSBORVRXQVZFX0VSRUdfUEEgICAgICAgIDB4MTYwCiNkZWZpbmUgTkVUV0FWRV9FUkVHX0VDICAgICAgICAweDE4MAojZGVmaW5lIE5FVFdBVkVfRVJFR19DUkJQICAgICAgMHgxN2EKI2RlZmluZSBORVRXQVZFX0VSRUdfQVJXICAgICAgIDB4MTY2CgovKgogKiBDb21tYW5kcyB1c2VkIGluIHRoZSBleHRlbmRlZCBjb21tYW5kIGJ1ZmZlcgogKiBORVRXQVZFX0VSRUdfQ0IgKDB4MTAwLTB4MTBGKSAKICovCiNkZWZpbmUgTkVUV0FWRV9DTURfTk9QICAgICAgICAweDAwCiNkZWZpbmUgTkVUV0FWRV9DTURfU1JDICAgICAgICAweDAxCiNkZWZpbmUgTkVUV0FWRV9DTURfU1RDICAgICAgICAweDAyCiNkZWZpbmUgTkVUV0FWRV9DTURfQU1BICAgICAgICAweDAzCiNkZWZpbmUgTkVUV0FWRV9DTURfRE1BICAgICAgICAweDA0CiNkZWZpbmUgTkVUV0FWRV9DTURfU0FNQSAgICAgICAweDA1CiNkZWZpbmUgTkVUV0FWRV9DTURfRVIgICAgICAgICAweDA2CiNkZWZpbmUgTkVUV0FWRV9DTURfRFIgICAgICAgICAweDA3CiNkZWZpbmUgTkVUV0FWRV9DTURfVEwgICAgICAgICAweDA4CiNkZWZpbmUgTkVUV0FWRV9DTURfU1JQICAgICAgICAweDA5CiNkZWZpbmUgTkVUV0FWRV9DTURfU1NLICAgICAgICAweDBhCiNkZWZpbmUgTkVUV0FWRV9DTURfU01EICAgICAgICAweDBiCiNkZWZpbmUgTkVUV0FWRV9DTURfU0FQRCAgICAgICAweDBjCiNkZWZpbmUgTkVUV0FWRV9DTURfU1NTICAgICAgICAweDExCi8qIEVuZCBvZiBDb21tYW5kIG1hcmtlciAqLwojZGVmaW5lIE5FVFdBVkVfQ01EX0VPQyAgICAgICAgMHgwMAoKLyogQVNSIHJlZ2lzdGVyIGJpdHMgKi8KI2RlZmluZSBORVRXQVZFX0FTUl9SWFJEWSAgIDB4ODAKI2RlZmluZSBORVRXQVZFX0FTUl9UWEJBICAgIDB4MDEKCiNkZWZpbmUgVFhfVElNRU9VVAkJKCgzMipIWikvMTAwKQoKc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBpbXJDb25mUkZVMSA9IDB4MTA7IC8qIFJGVSBpbnRlcnJ1cHQgbWFzaywga2VlcCBoaWdoICovCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgaW1yQ29uZklFTkEgPSAweDAyOyAvKiBJbnRlcnJ1cHQgZW5hYmxlICovCgpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IGNvckNvbmZJRU5BICAgPSAweDAxOyAvKiBJbnRlcnJ1cHQgZW5hYmxlICovCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgY29yQ29uZkxWTFJFUSA9IDB4NDA7IC8qIEtlZXAgaGlnaCAqLwoKc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCByeENvbmZSeEVuYSAgPSAweDgwOyAvKiBSZWNlaXZlIEVuYWJsZSAqLwpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHJ4Q29uZk1BQyAgICA9IDB4MjA7IC8qIE1BQyBob3N0IHJlY2VpdmUgbW9kZSovIApzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHJ4Q29uZlBybyAgICA9IDB4MTA7IC8qIFByb21pc2N1b3VzICovCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgcnhDb25mQU1QICAgID0gMHgwODsgLyogQWNjZXB0IE11bHRpY2FzdCBQYWNrZXRzICovCnN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgcnhDb25mQmNhc3QgID0gMHgwNDsgLyogQWNjZXB0IEJyb2FkY2FzdCBQYWNrZXRzICovCgpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHR4Q29uZlR4RW5hICA9IDB4ODA7IC8qIFRyYW5zbWl0IEVuYWJsZSAqLwpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHR4Q29uZk1BQyAgICA9IDB4MjA7IC8qIEhvc3Qgc2VuZHMgTUFDIG1vZGUgKi8Kc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCB0eENvbmZFVUQgICAgPSAweDEwOyAvKiBFbmFibGUgVW5pLURhdGEgcGFja2V0cyAqLwpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHR4Q29uZktleSAgICA9IDB4MDI7IC8qIFNjcmFtYmxlIGRhdGEgcGFja2V0cyAqLwpzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHR4Q29uZkxvb3AgICA9IDB4MDE7IC8qIExvb3BiYWNrIG1vZGUgKi8KCi8qCiAgIEFsbCB0aGUgUENNQ0lBIG1vZHVsZXMgdXNlIFBDTUNJQV9ERUJVRyB0byBjb250cm9sIGRlYnVnZ2luZy4gIElmCiAgIHlvdSBkbyBub3QgZGVmaW5lIFBDTUNJQV9ERUJVRyBhdCBhbGwsIGFsbCB0aGUgZGVidWcgY29kZSB3aWxsIGJlCiAgIGxlZnQgb3V0LiAgSWYgeW91IGNvbXBpbGUgd2l0aCBQQ01DSUFfREVCVUc9MCwgdGhlIGRlYnVnIGNvZGUgd2lsbAogICBiZSBwcmVzZW50IGJ1dCBkaXNhYmxlZCAtLSBidXQgaXQgY2FuIHRoZW4gYmUgZW5hYmxlZCBmb3Igc3BlY2lmaWMKICAgbW9kdWxlcyBhdCBsb2FkIHRpbWUgd2l0aCBhICdwY19kZWJ1Zz0jJyBvcHRpb24gdG8gaW5zbW9kLgoqLwoKI2lmZGVmIFBDTUNJQV9ERUJVRwpzdGF0aWMgaW50IHBjX2RlYnVnID0gUENNQ0lBX0RFQlVHOwptb2R1bGVfcGFyYW0ocGNfZGVidWcsIGludCwgMCk7CiNkZWZpbmUgREVCVUcobiwgYXJncy4uLikgaWYgKHBjX2RlYnVnPihuKSkgcHJpbnRrKEtFUk5fREVCVUcgYXJncykKc3RhdGljIGNoYXIgKnZlcnNpb24gPQoibmV0d2F2ZV9jcy5jIDAuMy4wIFRodSBKdWwgMTcgMTQ6MzY6MDIgMTk5NyAoSm9obiBNYXJrdXMgQmr4cm5kYWxlbilcbiI7CiNlbHNlCiNkZWZpbmUgREVCVUcobiwgYXJncy4uLikKI2VuZGlmCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCi8qIFBhcmFtZXRlcnMgdGhhdCBjYW4gYmUgc2V0IHdpdGggJ2luc21vZCcgKi8KCi8qIENob29zZSB0aGUgZG9tYWluLCBkZWZhdWx0IGlzIDB4MTAwICovCnN0YXRpYyB1X2ludCAgZG9tYWluID0gMHgxMDA7CgovKiBTY3JhbWJsZSBrZXksIHJhbmdlIGZyb20gMHgwIHRvIDB4ZmZmZi4gIAogKiAweDAgaXMgbm8gc2NyYW1ibGluZy4gCiAqLwpzdGF0aWMgdV9pbnQgIHNjcmFtYmxlX2tleSA9IDB4MDsKCi8qIFNoYXJlZCBtZW1vcnkgc3BlZWQsIGluIG5zLiBUaGUgZG9jdW1lbnRhdGlvbiBzdGF0ZXMgdGhhdCAKICogdGhlIGNhcmQgc2hvdWxkIG5vdCBiZSByZWFkIGZhc3RlciB0aGFuIGV2ZXJ5IDQwMG5zLiAKICogVGhpcyB0aW1pbmcgc2hvdWxkIGJlIHByb3ZpZGVkIGJ5IHRoZSBIQkEuIElmIGl0IGJlY29tZXMgYSAKICogcHJvYmxlbSwgdHJ5IHNldHRpbmcgbWVtX3NwZWVkIHRvIDQwMC4gCiAqLwpzdGF0aWMgaW50IG1lbV9zcGVlZDsKCm1vZHVsZV9wYXJhbShkb21haW4sIGludCwgMCk7Cm1vZHVsZV9wYXJhbShzY3JhbWJsZV9rZXksIGludCwgMCk7Cm1vZHVsZV9wYXJhbShtZW1fc3BlZWQsIGludCwgMCk7CgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCi8qIFBDTUNJQSAoQ2FyZCBTZXJ2aWNlcykgcmVsYXRlZCBmdW5jdGlvbnMgKi8Kc3RhdGljIHZvaWQgbmV0d2F2ZV9yZWxlYXNlKHN0cnVjdCBwY21jaWFfZGV2aWNlICpsaW5rKTsgICAgIC8qIENhcmQgcmVtb3ZhbCAqLwpzdGF0aWMgaW50IG5ldHdhdmVfcGNtY2lhX2NvbmZpZyhzdHJ1Y3QgcGNtY2lhX2RldmljZSAqYXJnKTsgLyogUnVucyBhZnRlciBjYXJkCgkJCQkJCQkJCQkJCQkgICBpbnNlcnRpb24gKi8Kc3RhdGljIHZvaWQgbmV0d2F2ZV9kZXRhY2goc3RydWN0IHBjbWNpYV9kZXZpY2UgKnBfZGV2KTsgICAgLyogRGVzdHJveSBpbnN0YW5jZSAqLwoKLyogSGFyZHdhcmUgY29uZmlndXJhdGlvbiAqLwpzdGF0aWMgdm9pZCBuZXR3YXZlX2RvcmVzZXQoa2lvX2FkZHJfdCBpb2Jhc2UsIHVfY2hhciBfX2lvbWVtICpyYW1CYXNlKTsKc3RhdGljIHZvaWQgbmV0d2F2ZV9yZXNldChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKCi8qIE1pc2MgZGV2aWNlIHN0dWZmICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOyAgLyogT3BlbiB0aGUgZGV2aWNlICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9jbG9zZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsgLyogQ2xvc2UgdGhlIGRldmljZSAqLwoKLyogUGFja2V0IHRyYW5zbWlzc2lvbiBhbmQgUGFja2V0IHJlY2VwdGlvbiAqLwpzdGF0aWMgaW50IG5ldHdhdmVfc3RhcnRfeG1pdCggc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyBpbnQgbmV0d2F2ZV9yeCggc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CgovKiBJbnRlcnJ1cHQgcm91dGluZXMgKi8Kc3RhdGljIGlycXJldHVybl90IG5ldHdhdmVfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpOwpzdGF0aWMgdm9pZCBuZXR3YXZlX3dhdGNoZG9nKHN0cnVjdCBuZXRfZGV2aWNlICopOwoKLyogU3RhdGlzdGljcyAqLwpzdGF0aWMgdm9pZCB1cGRhdGVfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqbmV0d2F2ZV9nZXRfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CgovKiBXaXJlbGVzcyBleHRlbnNpb25zICovCnN0YXRpYyBzdHJ1Y3QgaXdfc3RhdGlzdGljcyogbmV0d2F2ZV9nZXRfd2lyZWxlc3Nfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CgpzdGF0aWMgdm9pZCBzZXRfbXVsdGljYXN0X2xpc3Qoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CgovKgogICBBIHN0cnVjdCBwY21jaWFfZGV2aWNlIHN0cnVjdHVyZSBoYXMgZmllbGRzIGZvciBtb3N0IHRoaW5ncyB0aGF0IGFyZSBuZWVkZWQKICAgdG8ga2VlcCB0cmFjayBvZiBhIHNvY2tldCwgYnV0IHRoZXJlIHdpbGwgdXN1YWxseSBiZSBzb21lIGRldmljZQogICBzcGVjaWZpYyBpbmZvcm1hdGlvbiB0aGF0IGFsc28gbmVlZHMgdG8gYmUga2VwdCB0cmFjayBvZi4gIFRoZQogICAncHJpdicgcG9pbnRlciBpbiBhIHN0cnVjdCBwY21jaWFfZGV2aWNlIHN0cnVjdHVyZSBjYW4gYmUgdXNlZCB0byBwb2ludCB0bwogICBhIGRldmljZS1zcGVjaWZpYyBwcml2YXRlIGRhdGEgc3RydWN0dXJlLCBsaWtlIHRoaXMuCgogICBBIGRyaXZlciBuZWVkcyB0byBwcm92aWRlIGEgZGV2X25vZGVfdCBzdHJ1Y3R1cmUgZm9yIGVhY2ggZGV2aWNlCiAgIG9uIGEgY2FyZC4gIEluIHNvbWUgY2FzZXMsIHRoZXJlIGlzIG9ubHkgb25lIGRldmljZSBwZXIgY2FyZCAoZm9yCiAgIGV4YW1wbGUsIGV0aGVybmV0IGNhcmRzLCBtb2RlbXMpLiAgSW4gb3RoZXIgY2FzZXMsIHRoZXJlIG1heSBiZQogICBtYW55IGFjdHVhbCBvciBsb2dpY2FsIGRldmljZXMgKFNDU0kgYWRhcHRlcnMsIG1lbW9yeSBjYXJkcyB3aXRoCiAgIG11bHRpcGxlIHBhcnRpdGlvbnMpLiAgVGhlIGRldl9ub2RlX3Qgc3RydWN0dXJlcyBuZWVkIHRvIGJlIGtlcHQKICAgaW4gYSBsaW5rZWQgbGlzdCBzdGFydGluZyBhdCB0aGUgJ2RldicgZmllbGQgb2YgYSBzdHJ1Y3QgcGNtY2lhX2RldmljZQogICBzdHJ1Y3R1cmUuICBXZSBhbGxvY2F0ZSB0aGVtIGluIHRoZSBjYXJkJ3MgcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZSwKICAgYmVjYXVzZSB0aGV5IGdlbmVyYWxseSBjYW4ndCBiZSBhbGxvY2F0ZWQgZHluYW1pY2FsbHkuCiovCgpzdGF0aWMgY29uc3Qgc3RydWN0IGl3X2hhbmRsZXJfZGVmCW5ldHdhdmVfaGFuZGxlcl9kZWY7CgojZGVmaW5lIFNJT0NHSVBTTkFQCVNJT0NJV0ZJUlNUUFJJVgkrIDEJLyogU2l0ZSBTdXJ2ZXkgU25hcHNob3QgKi8KCiNkZWZpbmUgTUFYX0VTQSAxMAoKdHlwZWRlZiBzdHJ1Y3QgbmV0X2FkZHIgewogICAgdV9jaGFyIGFkZHI0OFs2XTsKfSBuZXRfYWRkcjsKCnN0cnVjdCBzaXRlX3N1cnZleSB7CiAgICB1X3Nob3J0IGxlbmd0aDsKICAgIHVfY2hhciAgc3RydWN0X3JldmlzaW9uOwogICAgdV9jaGFyICByb2FtaW5nX3N0YXRlOwoJCiAgICB1X2NoYXIgIHNwX2V4aXN0c0ZsYWc7CiAgICB1X2NoYXIgIHNwX2xpbmtfcXVhbGl0eTsKICAgIHVfY2hhciAgc3BfbWF4X2xpbmtfcXVhbGl0eTsKICAgIHVfY2hhciAgbGlua1F1YWxpdHlHb29kRmFpckJvdW5kYXJ5OwogICAgdV9jaGFyICBsaW5rUXVhbGl0eUZhaXJQb29yQm91bmRhcnk7CiAgICB1X2NoYXIgIHNwX3V0aWxpemF0aW9uOwogICAgdV9jaGFyICBzcF9nb29kbmVzczsKICAgIHVfY2hhciAgc3BfaG90aGVhZGNvdW50OwogICAgdV9jaGFyICByb2FtaW5nX2NvbmRpdGlvbjsKCQogICAgbmV0X2FkZHIgc3A7CiAgICB1X2NoYXIgICBudW1BUHM7CiAgICBuZXRfYWRkciBuZWFyQnlBY2Nlc3NQb2ludHNbTUFYX0VTQV07Cn07CQogICAKdHlwZWRlZiBzdHJ1Y3QgbmV0d2F2ZV9wcml2YXRlIHsKCXN0cnVjdCBwY21jaWFfZGV2aWNlCSpwX2RldjsKICAgIHNwaW5sb2NrX3QJc3BpbmxvY2s7CS8qIFNlcmlhbGl6ZSBhY2Nlc3MgdG8gdGhlIGhhcmR3YXJlIChTTVApICovCiAgICBkZXZfbm9kZV90IG5vZGU7CiAgICB1X2NoYXIgICAgIF9faW9tZW0gKnJhbUJhc2U7CiAgICBpbnQgICAgICAgIHRpbWVvdXRDb3VudGVyOwogICAgaW50ICAgICAgICBsYXN0RXhlYzsKICAgIHN0cnVjdCB0aW1lcl9saXN0ICAgICAgd2F0Y2hkb2c7CS8qIFRvIGF2b2lkIGJsb2NraW5nIHN0YXRlICovCiAgICBzdHJ1Y3Qgc2l0ZV9zdXJ2ZXkgICAgIG5zczsKICAgIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzIHN0YXRzOwogICAgc3RydWN0IGl3X3N0YXRpc3RpY3MgICBpd19zdGF0czsgICAgLyogV2lyZWxlc3Mgc3RhdHMgKi8KfSBuZXR3YXZlX3ByaXZhdGU7CgojaWZkZWYgTkVUV0FWRV9TVEFUUwpzdGF0aWMgc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKm5ldHdhdmVfZ2V0X3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwojZW5kaWYKCi8qCiAqIFRoZSBOZXR3YXZlIGNhcmQgaXMgbGl0dGxlLWVuZGlhbiwgc28gd29uJ3Qgd29yayBmb3IgYmlnIGVuZGlhbgogKiBzeXN0ZW1zLgogKi8Kc3RhdGljIGlubGluZSB1bnNpZ25lZCBzaG9ydCBnZXRfdWludDE2KHVfY2hhciBfX2lvbWVtICpzdGFkZHIpIAp7CiAgICByZXR1cm4gcmVhZHcoc3RhZGRyKTsgLyogUmV0dXJuIG9ubHkgMTYgYml0cyAqLwp9CgpzdGF0aWMgaW5saW5lIHNob3J0IGdldF9pbnQxNih1X2NoYXIgX19pb21lbSAqIHN0YWRkcikKewogICAgcmV0dXJuIHJlYWR3KHN0YWRkcik7Cn0KCi8qIAogKiBXYWl0IHVudGlsIHRoZSBXT0MgKFdyaXRlIE9wZXJhdGlvbiBDb21wbGV0ZSkgYml0IGluIHRoZSAKICogQVNSIChBZGFwdGVyIFN0YXR1cyBSZWdpc3RlcikgaXMgYXNzZXJ0ZWQuIAogKiBUaGlzIHNob3VsZCBoYXZlIGFib3J0ZWQgaWYgaXQgdGFrZXMgdG9vIGxvbmcgdGltZS4gCiAqLwpzdGF0aWMgaW5saW5lIHZvaWQgd2FpdF9XT0ModW5zaWduZWQgaW50IGlvYmFzZSkKewogICAgLyogU3BpbiBsb2NrICovCiAgICB3aGlsZSAoKGluYihpb2Jhc2UgKyBORVRXQVZFX1JFR19BU1IpICYgMHg4KSAhPSAweDgpIDsgCn0KCnN0YXRpYyB2b2lkIG5ldHdhdmVfc25hcHNob3QobmV0d2F2ZV9wcml2YXRlICpwcml2LCB1X2NoYXIgX19pb21lbSAqcmFtQmFzZSwgCgkJCSAgICAga2lvX2FkZHJfdCBpb2Jhc2UpIHsKICAgIHVfc2hvcnQgcmVzdWx0QnVmZmVyOwoKICAgIC8qIGlmIHRpbWUgc2luY2UgbGFzdCBzbmFwc2hvdCBpcyA+IDEgc2VjLiAoMTAwIGppZmZpZXM/KSAgdGhlbiB0YWtlIAogICAgICogbmV3IHNuYXBzaG90LCBlbHNlIHJldHVybiBjYWNoZWQgZGF0YS4gVGhpcyBpcyB0aGUgcmVjb21tZW5kZWQgcmF0ZS4gIAogICAgICovCiAgICBpZiAoIGppZmZpZXMgLSBwcml2LT5sYXN0RXhlYyA+IDEwMCkgeyAKCS8qIFRha2Ugc2l0ZSBzdXJ2ZXkgIHNuYXBzaG90ICovIAoJLypwcmludGsoIEtFUk5fREVCVUcgIlRha2luZyBuZXcgc25hcHNob3QuICVsZFxuIiwgamlmZmllcyAtCgkgIHByaXYtPmxhc3RFeGVjKTsgKi8KCXdhaXRfV09DKGlvYmFzZSk7IAoJd3JpdGViKE5FVFdBVkVfQ01EX1NTUywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDApOyAKCXdyaXRlYihORVRXQVZFX0NNRF9FT0MsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsgCgl3YWl0X1dPQyhpb2Jhc2UpOyAKCgkvKiBHZXQgcmVzdWx0IGFuZCBjb3B5IHRvIGNhY2ggKi8gCglyZXN1bHRCdWZmZXIgPSByZWFkdyhyYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NSQlApOyAKCWNvcHlfZnJvbV9wYyggJnByaXYtPm5zcywgcmFtQmFzZStyZXN1bHRCdWZmZXIsIAoJCSAgICAgIHNpemVvZihzdHJ1Y3Qgc2l0ZV9zdXJ2ZXkpKTsgCiAgICB9IAp9CgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX2dldF93aXJlbGVzc19zdGF0cyAoZGV2KQogKgogKiAgICBXaXJlbGVzcyBleHRlbnNpb25zIHN0YXRpc3RpY3MKICoKICovCnN0YXRpYyBzdHJ1Y3QgaXdfc3RhdGlzdGljcyAqbmV0d2F2ZV9nZXRfd2lyZWxlc3Nfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewkKICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAgICBraW9fYWRkcl90IGlvYmFzZSA9IGRldi0+YmFzZV9hZGRyOwogICAgbmV0d2F2ZV9wcml2YXRlICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKICAgIHVfY2hhciBfX2lvbWVtICpyYW1CYXNlID0gcHJpdi0+cmFtQmFzZTsKICAgIHN0cnVjdCBpd19zdGF0aXN0aWNzKiB3c3RhdHM7CgkKICAgIHdzdGF0cyA9ICZwcml2LT5pd19zdGF0czsKCiAgICBzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+c3BpbmxvY2ssIGZsYWdzKTsKCQogICAgbmV0d2F2ZV9zbmFwc2hvdCggcHJpdiwgcmFtQmFzZSwgaW9iYXNlKTsKCiAgICB3c3RhdHMtPnN0YXR1cyA9IHByaXYtPm5zcy5yb2FtaW5nX3N0YXRlOwogICAgd3N0YXRzLT5xdWFsLnF1YWwgPSByZWFkYiggcmFtQmFzZSArIE5FVFdBVkVfRVJFR19TUENRKTsgCiAgICB3c3RhdHMtPnF1YWwubGV2ZWwgPSByZWFkYiggcmFtQmFzZSArIE5FVFdBVkVfRVJFR19JU1BMUSk7CiAgICB3c3RhdHMtPnF1YWwubm9pc2UgPSByZWFkYiggcmFtQmFzZSArIE5FVFdBVkVfRVJFR19TUFUpICYgMHgzZjsKICAgIHdzdGF0cy0+ZGlzY2FyZC5ud2lkID0gMEw7CiAgICB3c3RhdHMtPmRpc2NhcmQuY29kZSA9IDBMOwogICAgd3N0YXRzLT5kaXNjYXJkLm1pc2MgPSAwTDsKCiAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5zcGlubG9jaywgZmxhZ3MpOwogICAgCiAgICByZXR1cm4gJnByaXYtPml3X3N0YXRzOwp9CgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX2F0dGFjaCAodm9pZCkKICoKICogICAgIENyZWF0ZXMgYW4gImluc3RhbmNlIiBvZiB0aGUgZHJpdmVyLCBhbGxvY2F0aW5nIGxvY2FsIGRhdGEgCiAqICAgICBzdHJ1Y3R1cmVzIGZvciBvbmUgZGV2aWNlLiAgVGhlIGRldmljZSBpcyByZWdpc3RlcmVkIHdpdGggQ2FyZCAKICogICAgIFNlcnZpY2VzLgogKgogKiAgICAgVGhlIGRldl9saW5rIHN0cnVjdHVyZSBpcyBpbml0aWFsaXplZCwgYnV0IHdlIGRvbid0IGFjdHVhbGx5CiAqICAgICBjb25maWd1cmUgdGhlIGNhcmQgYXQgdGhpcyBwb2ludCAtLSB3ZSB3YWl0IHVudGlsIHdlIHJlY2VpdmUgYQogKiAgICAgY2FyZCBpbnNlcnRpb24gZXZlbnQuCiAqLwpzdGF0aWMgaW50IG5ldHdhdmVfcHJvYmUoc3RydWN0IHBjbWNpYV9kZXZpY2UgKmxpbmspCnsKICAgIHN0cnVjdCBuZXRfZGV2aWNlICpkZXY7CiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXY7CgogICAgREVCVUcoMCwgIm5ldHdhdmVfYXR0YWNoKClcbiIpOwoKICAgIC8qIEluaXRpYWxpemUgdGhlIHN0cnVjdCBwY21jaWFfZGV2aWNlIHN0cnVjdHVyZSAqLwogICAgZGV2ID0gYWxsb2NfZXRoZXJkZXYoc2l6ZW9mKG5ldHdhdmVfcHJpdmF0ZSkpOwogICAgaWYgKCFkZXYpCglyZXR1cm4gLUVOT01FTTsKICAgIHByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogICAgcHJpdi0+cF9kZXYgPSBsaW5rOwogICAgbGluay0+cHJpdiA9IGRldjsKCiAgICAvKiBUaGUgaW8gc3RydWN0dXJlIGRlc2NyaWJlcyBJTyBwb3J0IG1hcHBpbmcgKi8KICAgIGxpbmstPmlvLk51bVBvcnRzMSA9IDE2OwogICAgbGluay0+aW8uQXR0cmlidXRlczEgPSBJT19EQVRBX1BBVEhfV0lEVEhfMTY7CiAgICAvKiBsaW5rLT5pby5OdW1Qb3J0czIgPSAxNjsgCiAgICAgICBsaW5rLT5pby5BdHRyaWJ1dGVzMiA9IElPX0RBVEFfUEFUSF9XSURUSF8xNjsgKi8KICAgIGxpbmstPmlvLklPQWRkckxpbmVzID0gNTsKICAgIAogICAgLyogSW50ZXJydXB0IHNldHVwICovCiAgICBsaW5rLT5pcnEuQXR0cmlidXRlcyA9IElSUV9UWVBFX0VYQ0xVU0lWRSB8IElSUV9IQU5ETEVfUFJFU0VOVDsKICAgIGxpbmstPmlycS5JUlFJbmZvMSA9IElSUV9MRVZFTF9JRDsKICAgIGxpbmstPmlycS5IYW5kbGVyID0gJm5ldHdhdmVfaW50ZXJydXB0OwogICAgCiAgICAvKiBHZW5lcmFsIHNvY2tldCBjb25maWd1cmF0aW9uICovCiAgICBsaW5rLT5jb25mLkF0dHJpYnV0ZXMgPSBDT05GX0VOQUJMRV9JUlE7CiAgICBsaW5rLT5jb25mLkludFR5cGUgPSBJTlRfTUVNT1JZX0FORF9JTzsKICAgIGxpbmstPmNvbmYuQ29uZmlnSW5kZXggPSAxOwogICAgbGluay0+Y29uZi5QcmVzZW50ID0gUFJFU0VOVF9PUFRJT047CgogICAgLyogTmV0d2F2ZSBwcml2YXRlIHN0cnVjdCBpbml0LiBsaW5rL2Rldi9ub2RlIGFscmVhZHkgdGFrZW4gY2FyZSBvZiwKICAgICAqIG90aGVyIHN0dWZmIHplcm8nZCAtIEplYW4gSUkgKi8KICAgIHNwaW5fbG9ja19pbml0KCZwcml2LT5zcGlubG9jayk7CgogICAgLyogTmV0d2F2ZSBzcGVjaWZpYyBlbnRyaWVzIGluIHRoZSBkZXZpY2Ugc3RydWN0dXJlICovCiAgICBTRVRfTU9EVUxFX09XTkVSKGRldik7CiAgICBkZXYtPmhhcmRfc3RhcnRfeG1pdCA9ICZuZXR3YXZlX3N0YXJ0X3htaXQ7CiAgICBkZXYtPmdldF9zdGF0cyAgPSAmbmV0d2F2ZV9nZXRfc3RhdHM7CiAgICBkZXYtPnNldF9tdWx0aWNhc3RfbGlzdCA9ICZzZXRfbXVsdGljYXN0X2xpc3Q7CiAgICAvKiB3aXJlbGVzcyBleHRlbnNpb25zICovCiAgICBkZXYtPndpcmVsZXNzX2hhbmRsZXJzID0gKHN0cnVjdCBpd19oYW5kbGVyX2RlZiAqKSZuZXR3YXZlX2hhbmRsZXJfZGVmOwoKICAgIGRldi0+dHhfdGltZW91dCA9ICZuZXR3YXZlX3dhdGNoZG9nOwogICAgZGV2LT53YXRjaGRvZ190aW1lbyA9IFRYX1RJTUVPVVQ7CgogICAgZGV2LT5vcGVuID0gJm5ldHdhdmVfb3BlbjsKICAgIGRldi0+c3RvcCA9ICZuZXR3YXZlX2Nsb3NlOwogICAgbGluay0+aXJxLkluc3RhbmNlID0gZGV2OwoKICAgIHJldHVybiBuZXR3YXZlX3BjbWNpYV9jb25maWcoIGxpbmspOwp9IC8qIG5ldHdhdmVfYXR0YWNoICovCgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX2RldGFjaCAobGluaykKICoKICogICAgVGhpcyBkZWxldGVzIGEgZHJpdmVyICJpbnN0YW5jZSIuICBUaGUgZGV2aWNlIGlzIGRlLXJlZ2lzdGVyZWQKICogICAgd2l0aCBDYXJkIFNlcnZpY2VzLiAgSWYgaXQgaGFzIGJlZW4gcmVsZWFzZWQsIGFsbCBsb2NhbCBkYXRhCiAqICAgIHN0cnVjdHVyZXMgYXJlIGZyZWVkLiAgT3RoZXJ3aXNlLCB0aGUgc3RydWN0dXJlcyB3aWxsIGJlIGZyZWVkCiAqICAgIHdoZW4gdGhlIGRldmljZSBpcyByZWxlYXNlZC4KICovCnN0YXRpYyB2b2lkIG5ldHdhdmVfZGV0YWNoKHN0cnVjdCBwY21jaWFfZGV2aWNlICpsaW5rKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gbGluay0+cHJpdjsKCglERUJVRygwLCAibmV0d2F2ZV9kZXRhY2goMHglcClcbiIsIGxpbmspOwoKCW5ldHdhdmVfcmVsZWFzZShsaW5rKTsKCglpZiAobGluay0+ZGV2X25vZGUpCgkJdW5yZWdpc3Rlcl9uZXRkZXYoZGV2KTsKCglmcmVlX25ldGRldihkZXYpOwp9IC8qIG5ldHdhdmVfZGV0YWNoICovCgovKgogKiBXaXJlbGVzcyBIYW5kbGVyIDogZ2V0IHByb3RvY29sIG5hbWUKICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9nZXRfbmFtZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAoJCQkgICAgc3RydWN0IGl3X3JlcXVlc3RfaW5mbyAqaW5mbywKCQkJICAgIHVuaW9uIGl3cmVxX2RhdGEgKndycXUsCgkJCSAgICBjaGFyICpleHRyYSkKewoJc3RyY3B5KHdycXUtPm5hbWUsICJOZXR3YXZlIik7CglyZXR1cm4gMDsKfQoKLyoKICogV2lyZWxlc3MgSGFuZGxlciA6IHNldCBOZXR3b3JrIElECiAqLwpzdGF0aWMgaW50IG5ldHdhdmVfc2V0X253aWQoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJICAgIHN0cnVjdCBpd19yZXF1ZXN0X2luZm8gKmluZm8sCgkJCSAgICB1bmlvbiBpd3JlcV9kYXRhICp3cnF1LAoJCQkgICAgY2hhciAqZXh0cmEpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglraW9fYWRkcl90IGlvYmFzZSA9IGRldi0+YmFzZV9hZGRyOwoJbmV0d2F2ZV9wcml2YXRlICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXVfY2hhciBfX2lvbWVtICpyYW1CYXNlID0gcHJpdi0+cmFtQmFzZTsKCgkvKiBEaXNhYmxlIGludGVycnVwdHMgJiBzYXZlIGZsYWdzICovCglzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+c3BpbmxvY2ssIGZsYWdzKTsKCglpZighd3JxdS0+bndpZC5kaXNhYmxlZCkgewoJICAgIGRvbWFpbiA9IHdycXUtPm53aWQudmFsdWU7CgkgICAgcHJpbnRrKCBLRVJOX0RFQlVHICJTZXR0aW5nIGRvbWFpbiB0byAweCV4JTAyeFxuIiwgCgkJICAgIChkb21haW4gPj4gOCkgJiAweDAxLCBkb21haW4gJiAweGZmKTsKCSAgICB3YWl0X1dPQyhpb2Jhc2UpOwoJICAgIHdyaXRlYihORVRXQVZFX0NNRF9TTUQsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAwKTsKCSAgICB3cml0ZWIoIGRvbWFpbiAmIDB4ZmYsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsKCSAgICB3cml0ZWIoKGRvbWFpbiA+PjggKSAmIDB4MDEscmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQisyKTsKCSAgICB3cml0ZWIoTkVUV0FWRV9DTURfRU9DLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMyk7Cgl9CgoJLyogUmVFbmFibGUgaW50ZXJydXB0cyAmIHJlc3RvcmUgZmxhZ3MgKi8KCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnNwaW5sb2NrLCBmbGFncyk7CiAgICAKCXJldHVybiAwOwp9CgovKgogKiBXaXJlbGVzcyBIYW5kbGVyIDogZ2V0IE5ldHdvcmsgSUQKICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9nZXRfbndpZChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAoJCQkgICAgc3RydWN0IGl3X3JlcXVlc3RfaW5mbyAqaW5mbywKCQkJICAgIHVuaW9uIGl3cmVxX2RhdGEgKndycXUsCgkJCSAgICBjaGFyICpleHRyYSkKewoJd3JxdS0+bndpZC52YWx1ZSA9IGRvbWFpbjsKCXdycXUtPm53aWQuZGlzYWJsZWQgPSAwOwoJd3JxdS0+bndpZC5maXhlZCA9IDE7CglyZXR1cm4gMDsKfQoKLyoKICogV2lyZWxlc3MgSGFuZGxlciA6IHNldCBzY3JhbWJsZSBrZXkKICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9zZXRfc2NyYW1ibGUoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJCXN0cnVjdCBpd19yZXF1ZXN0X2luZm8gKmluZm8sCgkJCQl1bmlvbiBpd3JlcV9kYXRhICp3cnF1LAoJCQkJY2hhciAqa2V5KQp7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJa2lvX2FkZHJfdCBpb2Jhc2UgPSBkZXYtPmJhc2VfYWRkcjsKCW5ldHdhdmVfcHJpdmF0ZSAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7Cgl1X2NoYXIgX19pb21lbSAqcmFtQmFzZSA9IHByaXYtPnJhbUJhc2U7CgoJLyogRGlzYWJsZSBpbnRlcnJ1cHRzICYgc2F2ZSBmbGFncyAqLwoJc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnNwaW5sb2NrLCBmbGFncyk7CgoJc2NyYW1ibGVfa2V5ID0gKGtleVswXSA8PCA4KSB8IGtleVsxXTsKCXdhaXRfV09DKGlvYmFzZSk7Cgl3cml0ZWIoTkVUV0FWRV9DTURfU1NLLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMCk7Cgl3cml0ZWIoc2NyYW1ibGVfa2V5ICYgMHhmZiwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDEpOwoJd3JpdGViKChzY3JhbWJsZV9rZXk+PjgpICYgMHhmZiwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDIpOwoJd3JpdGViKE5FVFdBVkVfQ01EX0VPQywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDMpOwoKCS8qIFJlRW5hYmxlIGludGVycnVwdHMgJiByZXN0b3JlIGZsYWdzICovCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5zcGlubG9jaywgZmxhZ3MpOwogICAgCglyZXR1cm4gMDsKfQoKLyoKICogV2lyZWxlc3MgSGFuZGxlciA6IGdldCBzY3JhbWJsZSBrZXkKICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9nZXRfc2NyYW1ibGUoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJCXN0cnVjdCBpd19yZXF1ZXN0X2luZm8gKmluZm8sCgkJCQl1bmlvbiBpd3JlcV9kYXRhICp3cnF1LAoJCQkJY2hhciAqa2V5KQp7CglrZXlbMV0gPSBzY3JhbWJsZV9rZXkgJiAweGZmOwoJa2V5WzBdID0gKHNjcmFtYmxlX2tleT4+OCkgJiAweGZmOwoJd3JxdS0+ZW5jb2RpbmcuZmxhZ3MgPSBJV19FTkNPREVfRU5BQkxFRDsKCXdycXUtPmVuY29kaW5nLmxlbmd0aCA9IDI7CglyZXR1cm4gMDsKfQoKLyoKICogV2lyZWxlc3MgSGFuZGxlciA6IGdldCBtb2RlCiAqLwpzdGF0aWMgaW50IG5ldHdhdmVfZ2V0X21vZGUoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJICAgIHN0cnVjdCBpd19yZXF1ZXN0X2luZm8gKmluZm8sCgkJCSAgICB1bmlvbiBpd3JlcV9kYXRhICp3cnF1LAoJCQkgICAgY2hhciAqZXh0cmEpCnsKCWlmKGRvbWFpbiAmIDB4MTAwKQoJCXdycXUtPm1vZGUgPSBJV19NT0RFX0lORlJBOwoJZWxzZQoJCXdycXUtPm1vZGUgPSBJV19NT0RFX0FESE9DOwoKCXJldHVybiAwOwp9CgovKgogKiBXaXJlbGVzcyBIYW5kbGVyIDogZ2V0IHJhbmdlIGluZm8KICovCnN0YXRpYyBpbnQgbmV0d2F2ZV9nZXRfcmFuZ2Uoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJICAgICBzdHJ1Y3QgaXdfcmVxdWVzdF9pbmZvICppbmZvLAoJCQkgICAgIHVuaW9uIGl3cmVxX2RhdGEgKndycXUsCgkJCSAgICAgY2hhciAqZXh0cmEpCnsKCXN0cnVjdCBpd19yYW5nZSAqcmFuZ2UgPSAoc3RydWN0IGl3X3JhbmdlICopIGV4dHJhOwoJaW50IHJldCA9IDA7CgoJLyogU2V0IHRoZSBsZW5ndGggKHZlcnkgaW1wb3J0YW50IGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5KSAqLwoJd3JxdS0+ZGF0YS5sZW5ndGggPSBzaXplb2Yoc3RydWN0IGl3X3JhbmdlKTsKCgkvKiBTZXQgYWxsIHRoZSBpbmZvIHdlIGRvbid0IGNhcmUgb3IgZG9uJ3Qga25vdyBhYm91dCB0byB6ZXJvICovCgltZW1zZXQocmFuZ2UsIDAsIHNpemVvZihzdHJ1Y3QgaXdfcmFuZ2UpKTsKCgkvKiBTZXQgdGhlIFdpcmVsZXNzIEV4dGVuc2lvbiB2ZXJzaW9ucyAqLwoJcmFuZ2UtPndlX3ZlcnNpb25fY29tcGlsZWQgPSBXSVJFTEVTU19FWFQ7CglyYW5nZS0+d2VfdmVyc2lvbl9zb3VyY2UgPSA5OwkvKiBOb3RoaW5nIGZvciB1cyBpbiB2MTAgYW5kIHYxMSAqLwoJCSAgIAoJLyogU2V0IGluZm9ybWF0aW9uIGluIHRoZSByYW5nZSBzdHJ1Y3QgKi8KCXJhbmdlLT50aHJvdWdocHV0ID0gNDUwICogMTAwMDsJLyogZG9uJ3QgYXJndWUgb24gdGhpcyAhICovCglyYW5nZS0+bWluX253aWQgPSAweDAwMDA7CglyYW5nZS0+bWF4X253aWQgPSAweDAxRkY7CgoJcmFuZ2UtPm51bV9jaGFubmVscyA9IHJhbmdlLT5udW1fZnJlcXVlbmN5ID0gMDsKCQkgICAKCXJhbmdlLT5zZW5zaXRpdml0eSA9IDB4M0Y7CglyYW5nZS0+bWF4X3F1YWwucXVhbCA9IDI1NTsKCXJhbmdlLT5tYXhfcXVhbC5sZXZlbCA9IDI1NTsKCXJhbmdlLT5tYXhfcXVhbC5ub2lzZSA9IDA7CgkJICAgCglyYW5nZS0+bnVtX2JpdHJhdGVzID0gMTsKCXJhbmdlLT5iaXRyYXRlWzBdID0gMTAwMDAwMDsJLyogMSBNYi9zICovCgoJcmFuZ2UtPmVuY29kaW5nX3NpemVbMF0gPSAyOwkJLyogMTYgYml0cyBzY3JhbWJsaW5nICovCglyYW5nZS0+bnVtX2VuY29kaW5nX3NpemVzID0gMTsKCXJhbmdlLT5tYXhfZW5jb2RpbmdfdG9rZW5zID0gMTsJLyogT25seSBvbmUga2V5IHBvc3NpYmxlICovCgoJcmV0dXJuIHJldDsKfQoKLyoKICogV2lyZWxlc3MgUHJpdmF0ZSBIYW5kbGVyIDogZ2V0IHNuYXBzaG90CiAqLwpzdGF0aWMgaW50IG5ldHdhdmVfZ2V0X3NuYXAoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKCQkJICAgIHN0cnVjdCBpd19yZXF1ZXN0X2luZm8gKmluZm8sCgkJCSAgICB1bmlvbiBpd3JlcV9kYXRhICp3cnF1LAoJCQkgICAgY2hhciAqZXh0cmEpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglraW9fYWRkcl90IGlvYmFzZSA9IGRldi0+YmFzZV9hZGRyOwoJbmV0d2F2ZV9wcml2YXRlICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKCXVfY2hhciBfX2lvbWVtICpyYW1CYXNlID0gcHJpdi0+cmFtQmFzZTsKCgkvKiBEaXNhYmxlIGludGVycnVwdHMgJiBzYXZlIGZsYWdzICovCglzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+c3BpbmxvY2ssIGZsYWdzKTsKCgkvKiBUYWtlIHNuYXBzaG90IG9mIGVudmlyb25tZW50ICovCgluZXR3YXZlX3NuYXBzaG90KCBwcml2LCByYW1CYXNlLCBpb2Jhc2UpOwoJd3JxdS0+ZGF0YS5sZW5ndGggPSBwcml2LT5uc3MubGVuZ3RoOwoJbWVtY3B5KGV4dHJhLCAodV9jaGFyICopICZwcml2LT5uc3MsIHNpemVvZiggc3RydWN0IHNpdGVfc3VydmV5KSk7CgoJcHJpdi0+bGFzdEV4ZWMgPSBqaWZmaWVzOwoKCS8qIFJlRW5hYmxlIGludGVycnVwdHMgJiByZXN0b3JlIGZsYWdzICovCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5zcGlubG9jaywgZmxhZ3MpOwogICAgCglyZXR1cm4oMCk7Cn0KCi8qCiAqIFN0cnVjdHVyZXMgdG8gZXhwb3J0IHRoZSBXaXJlbGVzcyBIYW5kbGVycwogKiAgICAgVGhpcyBpcyB0aGUgc3R1ZmYgdGhhdCBhcmUgdHJlYXRlZCB0aGUgd2lyZWxlc3MgZXh0ZW5zaW9ucyAoaXdjb25maWcpCiAqLwoKc3RhdGljIGNvbnN0IHN0cnVjdCBpd19wcml2X2FyZ3MgbmV0d2F2ZV9wcml2YXRlX2FyZ3NbXSA9IHsKLyp7IGNtZCwgICAgICAgICBzZXRfYXJncywgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2V0X2FyZ3MsIG5hbWUgfSAqLwogIHsgU0lPQ0dJUFNOQVAsIDAsIAogICAgSVdfUFJJVl9UWVBFX0JZVEUgfCBJV19QUklWX1NJWkVfRklYRUQgfCBzaXplb2Yoc3RydWN0IHNpdGVfc3VydmV5KSwgCiAgICAiZ2V0c2l0ZXN1cnZleSIgfSwKfTsKCnN0YXRpYyBjb25zdCBpd19oYW5kbGVyCQluZXR3YXZlX2hhbmRsZXJbXSA9CnsKCU5VTEwsCQkJCS8qIFNJT0NTSVdOQU1FICovCgluZXR3YXZlX2dldF9uYW1lLAkJLyogU0lPQ0dJV05BTUUgKi8KCW5ldHdhdmVfc2V0X253aWQsCQkvKiBTSU9DU0lXTldJRCAqLwoJbmV0d2F2ZV9nZXRfbndpZCwJCS8qIFNJT0NHSVdOV0lEICovCglOVUxMLAkJCQkvKiBTSU9DU0lXRlJFUSAqLwoJTlVMTCwJCQkJLyogU0lPQ0dJV0ZSRVEgKi8KCU5VTEwsCQkJCS8qIFNJT0NTSVdNT0RFICovCgluZXR3YXZlX2dldF9tb2RlLAkJLyogU0lPQ0dJV01PREUgKi8KCU5VTEwsCQkJCS8qIFNJT0NTSVdTRU5TICovCglOVUxMLAkJCQkvKiBTSU9DR0lXU0VOUyAqLwoJTlVMTCwJCQkJLyogU0lPQ1NJV1JBTkdFICovCgluZXR3YXZlX2dldF9yYW5nZSwJCS8qIFNJT0NHSVdSQU5HRSAqLwoJTlVMTCwJCQkJLyogU0lPQ1NJV1BSSVYgKi8KCU5VTEwsCQkJCS8qIFNJT0NHSVdQUklWICovCglOVUxMLAkJCQkvKiBTSU9DU0lXU1RBVFMgKi8KCU5VTEwsCQkJCS8qIFNJT0NHSVdTVEFUUyAqLwoJTlVMTCwJCQkJLyogU0lPQ1NJV1NQWSAqLwoJTlVMTCwJCQkJLyogU0lPQ0dJV1NQWSAqLwoJTlVMTCwJCQkJLyogLS0gaG9sZSAtLSAqLwoJTlVMTCwJCQkJLyogLS0gaG9sZSAtLSAqLwoJTlVMTCwJCQkJLyogU0lPQ1NJV0FQICovCglOVUxMLAkJCQkvKiBTSU9DR0lXQVAgKi8KCU5VTEwsCQkJCS8qIC0tIGhvbGUgLS0gKi8KCU5VTEwsCQkJCS8qIFNJT0NHSVdBUExJU1QgKi8KCU5VTEwsCQkJCS8qIC0tIGhvbGUgLS0gKi8KCU5VTEwsCQkJCS8qIC0tIGhvbGUgLS0gKi8KCU5VTEwsCQkJCS8qIFNJT0NTSVdFU1NJRCAqLwoJTlVMTCwJCQkJLyogU0lPQ0dJV0VTU0lEICovCglOVUxMLAkJCQkvKiBTSU9DU0lXTklDS04gKi8KCU5VTEwsCQkJCS8qIFNJT0NHSVdOSUNLTiAqLwoJTlVMTCwJCQkJLyogLS0gaG9sZSAtLSAqLwoJTlVMTCwJCQkJLyogLS0gaG9sZSAtLSAqLwoJTlVMTCwJCQkJLyogU0lPQ1NJV1JBVEUgKi8KCU5VTEwsCQkJCS8qIFNJT0NHSVdSQVRFICovCglOVUxMLAkJCQkvKiBTSU9DU0lXUlRTICovCglOVUxMLAkJCQkvKiBTSU9DR0lXUlRTICovCglOVUxMLAkJCQkvKiBTSU9DU0lXRlJBRyAqLwoJTlVMTCwJCQkJLyogU0lPQ0dJV0ZSQUcgKi8KCU5VTEwsCQkJCS8qIFNJT0NTSVdUWFBPVyAqLwoJTlVMTCwJCQkJLyogU0lPQ0dJV1RYUE9XICovCglOVUxMLAkJCQkvKiBTSU9DU0lXUkVUUlkgKi8KCU5VTEwsCQkJCS8qIFNJT0NHSVdSRVRSWSAqLwoJbmV0d2F2ZV9zZXRfc2NyYW1ibGUsCQkvKiBTSU9DU0lXRU5DT0RFICovCgluZXR3YXZlX2dldF9zY3JhbWJsZSwJCS8qIFNJT0NHSVdFTkNPREUgKi8KfTsKCnN0YXRpYyBjb25zdCBpd19oYW5kbGVyCQluZXR3YXZlX3ByaXZhdGVfaGFuZGxlcltdID0KewoJTlVMTCwJCQkJLyogU0lPQ0lXRklSU1RQUklWICovCgluZXR3YXZlX2dldF9zbmFwLAkJLyogU0lPQ0lXRklSU1RQUklWICsgMSAqLwp9OwoKc3RhdGljIGNvbnN0IHN0cnVjdCBpd19oYW5kbGVyX2RlZgluZXR3YXZlX2hhbmRsZXJfZGVmID0KewoJLm51bV9zdGFuZGFyZAk9IHNpemVvZihuZXR3YXZlX2hhbmRsZXIpL3NpemVvZihpd19oYW5kbGVyKSwKCS5udW1fcHJpdmF0ZQk9IHNpemVvZihuZXR3YXZlX3ByaXZhdGVfaGFuZGxlcikvc2l6ZW9mKGl3X2hhbmRsZXIpLAoJLm51bV9wcml2YXRlX2FyZ3MgPSBzaXplb2YobmV0d2F2ZV9wcml2YXRlX2FyZ3MpL3NpemVvZihzdHJ1Y3QgaXdfcHJpdl9hcmdzKSwKCS5zdGFuZGFyZAk9IChpd19oYW5kbGVyICopIG5ldHdhdmVfaGFuZGxlciwKCS5wcml2YXRlCT0gKGl3X2hhbmRsZXIgKikgbmV0d2F2ZV9wcml2YXRlX2hhbmRsZXIsCgkucHJpdmF0ZV9hcmdzCT0gKHN0cnVjdCBpd19wcml2X2FyZ3MgKikgbmV0d2F2ZV9wcml2YXRlX2FyZ3MsCgkuZ2V0X3dpcmVsZXNzX3N0YXRzID0gbmV0d2F2ZV9nZXRfd2lyZWxlc3Nfc3RhdHMsCn07CgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX3BjbWNpYV9jb25maWcgKGxpbmspCiAqCiAqICAgICBuZXR3YXZlX3BjbWNpYV9jb25maWcoKSBpcyBzY2hlZHVsZWQgdG8gcnVuIGFmdGVyIGEgQ0FSRF9JTlNFUlRJT04gCiAqICAgICBldmVudCBpcyByZWNlaXZlZCwgdG8gY29uZmlndXJlIHRoZSBQQ01DSUEgc29ja2V0LCBhbmQgdG8gbWFrZSB0aGUKICogICAgIGRldmljZSBhdmFpbGFibGUgdG8gdGhlIHN5c3RlbS4gCiAqCiAqLwoKI2RlZmluZSBDU19DSEVDSyhmbiwgcmV0KSBcCmRvIHsgbGFzdF9mbiA9IChmbik7IGlmICgobGFzdF9yZXQgPSAocmV0KSkgIT0gMCkgZ290byBjc19mYWlsZWQ7IH0gd2hpbGUgKDApCgpzdGF0aWMgaW50IG5ldHdhdmVfcGNtY2lhX2NvbmZpZyhzdHJ1Y3QgcGNtY2lhX2RldmljZSAqbGluaykgewogICAgc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IGxpbmstPnByaXY7CiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogICAgdHVwbGVfdCB0dXBsZTsKICAgIGNpc3BhcnNlX3QgcGFyc2U7CiAgICBpbnQgaSwgaiwgbGFzdF9yZXQsIGxhc3RfZm47CiAgICB1X2NoYXIgYnVmWzY0XTsKICAgIHdpbl9yZXFfdCByZXE7CiAgICBtZW1yZXFfdCBtZW07CiAgICB1X2NoYXIgX19pb21lbSAqcmFtQmFzZSA9IE5VTEw7CgogICAgREVCVUcoMCwgIm5ldHdhdmVfcGNtY2lhX2NvbmZpZygweCVwKVxuIiwgbGluayk7CgogICAgLyoKICAgICAgVGhpcyByZWFkcyB0aGUgY2FyZCdzIENPTkZJRyB0dXBsZSB0byBmaW5kIGl0cyBjb25maWd1cmF0aW9uCiAgICAgIHJlZ2lzdGVycy4KICAgICovCiAgICB0dXBsZS5BdHRyaWJ1dGVzID0gMDsKICAgIHR1cGxlLlR1cGxlRGF0YSA9IChjaXNkYXRhX3QgKikgYnVmOwogICAgdHVwbGUuVHVwbGVEYXRhTWF4ID0gNjQ7CiAgICB0dXBsZS5UdXBsZU9mZnNldCA9IDA7CiAgICB0dXBsZS5EZXNpcmVkVHVwbGUgPSBDSVNUUExfQ09ORklHOwogICAgQ1NfQ0hFQ0soR2V0Rmlyc3RUdXBsZSwgcGNtY2lhX2dldF9maXJzdF90dXBsZShsaW5rLCAmdHVwbGUpKTsKICAgIENTX0NIRUNLKEdldFR1cGxlRGF0YSwgcGNtY2lhX2dldF90dXBsZV9kYXRhKGxpbmssICZ0dXBsZSkpOwogICAgQ1NfQ0hFQ0soUGFyc2VUdXBsZSwgcGNtY2lhX3BhcnNlX3R1cGxlKGxpbmssICZ0dXBsZSwgJnBhcnNlKSk7CiAgICBsaW5rLT5jb25mLkNvbmZpZ0Jhc2UgPSBwYXJzZS5jb25maWcuYmFzZTsKICAgIGxpbmstPmNvbmYuUHJlc2VudCA9IHBhcnNlLmNvbmZpZy5ybWFza1swXTsKCiAgICAvKgogICAgICogIFRyeSBhbGxvY2F0aW5nIElPIHBvcnRzLiAgVGhpcyB0cmllcyBhIGZldyBmaXhlZCBhZGRyZXNzZXMuCiAgICAgKiAgSWYgeW91IHdhbnQsIHlvdSBjYW4gYWxzbyByZWFkIHRoZSBjYXJkJ3MgY29uZmlnIHRhYmxlIHRvCiAgICAgKiAgcGljayBhZGRyZXNzZXMgLS0gc2VlIHRoZSBzZXJpYWwgZHJpdmVyIGZvciBhbiBleGFtcGxlLgogICAgICovCiAgICBmb3IgKGkgPSBqID0gMHgwOyBqIDwgMHg0MDA7IGogKz0gMHgyMCkgewoJbGluay0+aW8uQmFzZVBvcnQxID0gaiBeIDB4MzAwOwoJaSA9IHBjbWNpYV9yZXF1ZXN0X2lvKGxpbmssICZsaW5rLT5pbyk7CglpZiAoaSA9PSBDU19TVUNDRVNTKSBicmVhazsKICAgIH0KICAgIGlmIChpICE9IENTX1NVQ0NFU1MpIHsKCWNzX2Vycm9yKGxpbmssIFJlcXVlc3RJTywgaSk7Cglnb3RvIGZhaWxlZDsKICAgIH0KCiAgICAvKgogICAgICogIE5vdyBhbGxvY2F0ZSBhbiBpbnRlcnJ1cHQgbGluZS4gIE5vdGUgdGhhdCB0aGlzIGRvZXMgbm90CiAgICAgKiAgYWN0dWFsbHkgYXNzaWduIGEgaGFuZGxlciB0byB0aGUgaW50ZXJydXB0LgogICAgICovCiAgICBDU19DSEVDSyhSZXF1ZXN0SVJRLCBwY21jaWFfcmVxdWVzdF9pcnEobGluaywgJmxpbmstPmlycSkpOwoKICAgIC8qCiAgICAgKiAgVGhpcyBhY3R1YWxseSBjb25maWd1cmVzIHRoZSBQQ01DSUEgc29ja2V0IC0tIHNldHRpbmcgdXAKICAgICAqICB0aGUgSS9PIHdpbmRvd3MgYW5kIHRoZSBpbnRlcnJ1cHQgbWFwcGluZy4KICAgICAqLwogICAgQ1NfQ0hFQ0soUmVxdWVzdENvbmZpZ3VyYXRpb24sIHBjbWNpYV9yZXF1ZXN0X2NvbmZpZ3VyYXRpb24obGluaywgJmxpbmstPmNvbmYpKTsKCiAgICAvKgogICAgICogIEFsbG9jYXRlIGEgMzJLIG1lbW9yeSB3aW5kb3cuICBOb3RlIHRoYXQgdGhlIHN0cnVjdCBwY21jaWFfZGV2aWNlCiAgICAgKiAgc3RydWN0dXJlIHByb3ZpZGVzIHNwYWNlIGZvciBvbmUgd2luZG93IGhhbmRsZSAtLSBpZiB5b3VyCiAgICAgKiAgZGV2aWNlIG5lZWRzIHNldmVyYWwgd2luZG93cywgeW91J2xsIG5lZWQgdG8ga2VlcCB0cmFjayBvZgogICAgICogIHRoZSBoYW5kbGVzIGluIHlvdXIgcHJpdmF0ZSBkYXRhIHN0cnVjdHVyZSwgZGV2LT5wcml2LgogICAgICovCiAgICBERUJVRygxLCAiU2V0dGluZyBtZW0gc3BlZWQgb2YgJWRcbiIsIG1lbV9zcGVlZCk7CgogICAgcmVxLkF0dHJpYnV0ZXMgPSBXSU5fREFUQV9XSURUSF84fFdJTl9NRU1PUllfVFlQRV9DTXxXSU5fRU5BQkxFOwogICAgcmVxLkJhc2UgPSAwOyByZXEuU2l6ZSA9IDB4ODAwMDsKICAgIHJlcS5BY2Nlc3NTcGVlZCA9IG1lbV9zcGVlZDsKICAgIENTX0NIRUNLKFJlcXVlc3RXaW5kb3csIHBjbWNpYV9yZXF1ZXN0X3dpbmRvdygmbGluaywgJnJlcSwgJmxpbmstPndpbikpOwogICAgbWVtLkNhcmRPZmZzZXQgPSAweDIwMDAwOyBtZW0uUGFnZSA9IDA7IAogICAgQ1NfQ0hFQ0soTWFwTWVtUGFnZSwgcGNtY2lhX21hcF9tZW1fcGFnZShsaW5rLT53aW4sICZtZW0pKTsKCiAgICAvKiBTdG9yZSBiYXNlIGFkZHJlc3Mgb2YgdGhlIGNvbW1vbiB3aW5kb3cgZnJhbWUgKi8KICAgIHJhbUJhc2UgPSBpb3JlbWFwKHJlcS5CYXNlLCAweDgwMDApOwogICAgcHJpdi0+cmFtQmFzZSA9IHJhbUJhc2U7CgogICAgZGV2LT5pcnEgPSBsaW5rLT5pcnEuQXNzaWduZWRJUlE7CiAgICBkZXYtPmJhc2VfYWRkciA9IGxpbmstPmlvLkJhc2VQb3J0MTsKICAgIFNFVF9ORVRERVZfREVWKGRldiwgJmhhbmRsZV90b19kZXYobGluaykpOwoKICAgIGlmIChyZWdpc3Rlcl9uZXRkZXYoZGV2KSAhPSAwKSB7CglwcmludGsoS0VSTl9ERUJVRyAibmV0d2F2ZV9jczogcmVnaXN0ZXJfbmV0ZGV2KCkgZmFpbGVkXG4iKTsKCWdvdG8gZmFpbGVkOwogICAgfQoKICAgIHN0cmNweShwcml2LT5ub2RlLmRldl9uYW1lLCBkZXYtPm5hbWUpOwogICAgbGluay0+ZGV2X25vZGUgPSAmcHJpdi0+bm9kZTsKCiAgICAvKiBSZXNldCBjYXJkIGJlZm9yZSByZWFkaW5nIHBoeXNpY2FsIGFkZHJlc3MgKi8KICAgIG5ldHdhdmVfZG9yZXNldChkZXYtPmJhc2VfYWRkciwgcmFtQmFzZSk7CgogICAgLyogUmVhZCB0aGUgZXRoZXJuZXQgYWRkcmVzcyBhbmQgZmlsbCBpbiB0aGUgTmV0d2F2ZSByZWdpc3RlcnMuICovCiAgICBmb3IgKGkgPSAwOyBpIDwgNjsgaSsrKSAKCWRldi0+ZGV2X2FkZHJbaV0gPSByZWFkYihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX1BBICsgaSk7CgogICAgcHJpbnRrKEtFUk5fSU5GTyAiJXM6IE5ldHdhdmU6IHBvcnQgJSMzbHgsIGlycSAlZCwgbWVtICVseCBpZCAiCgkgICAiJWMlYywgaHdfYWRkciAiLCBkZXYtPm5hbWUsIGRldi0+YmFzZV9hZGRyLCBkZXYtPmlycSwKCSAgICh1X2xvbmcpIHJhbUJhc2UsIChpbnQpIHJlYWRiKHJhbUJhc2UrTkVUV0FWRV9FUkVHX05JKSwKCSAgIChpbnQpIHJlYWRiKHJhbUJhc2UrTkVUV0FWRV9FUkVHX05JKzEpKTsKICAgIGZvciAoaSA9IDA7IGkgPCA2OyBpKyspCglwcmludGsoIiUwMlglcyIsIGRldi0+ZGV2X2FkZHJbaV0sICgoaTw1KSA/ICI6IiA6ICJcbiIpKTsKCiAgICAvKiBnZXQgcmV2aXNpb24gd29yZHMgKi8KICAgIHByaW50ayhLRVJOX0RFQlVHICJOZXR3YXZlX3Jlc2V0OiByZXZpc2lvbiAlMDR4ICUwNHhcbiIsIAoJICAgZ2V0X3VpbnQxNihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX0FSVyksCgkgICBnZXRfdWludDE2KHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQVJXKzIpKTsKICAgIHJldHVybiAwOwoKY3NfZmFpbGVkOgogICAgY3NfZXJyb3IobGluaywgbGFzdF9mbiwgbGFzdF9yZXQpOwpmYWlsZWQ6CiAgICBuZXR3YXZlX3JlbGVhc2UobGluayk7CiAgICByZXR1cm4gLUVOT0RFVjsKfSAvKiBuZXR3YXZlX3BjbWNpYV9jb25maWcgKi8KCi8qCiAqIEZ1bmN0aW9uIG5ldHdhdmVfcmVsZWFzZSAoYXJnKQogKgogKiAgICBBZnRlciBhIGNhcmQgaXMgcmVtb3ZlZCwgbmV0d2F2ZV9yZWxlYXNlKCkgd2lsbCB1bnJlZ2lzdGVyIHRoZSBuZXQKICogICAgZGV2aWNlLCBhbmQgcmVsZWFzZSB0aGUgUENNQ0lBIGNvbmZpZ3VyYXRpb24uICBJZiB0aGUgZGV2aWNlIGlzCiAqICAgIHN0aWxsIG9wZW4sIHRoaXMgd2lsbCBiZSBwb3N0cG9uZWQgdW50aWwgaXQgaXMgY2xvc2VkLgogKi8Kc3RhdGljIHZvaWQgbmV0d2F2ZV9yZWxlYXNlKHN0cnVjdCBwY21jaWFfZGV2aWNlICpsaW5rKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gbGluay0+cHJpdjsKCW5ldHdhdmVfcHJpdmF0ZSAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CgoJREVCVUcoMCwgIm5ldHdhdmVfcmVsZWFzZSgweCVwKVxuIiwgbGluayk7CgoJcGNtY2lhX2Rpc2FibGVfZGV2aWNlKGxpbmspOwoJaWYgKGxpbmstPndpbikKCQlpb3VubWFwKHByaXYtPnJhbUJhc2UpOwp9CgpzdGF0aWMgaW50IG5ldHdhdmVfc3VzcGVuZChzdHJ1Y3QgcGNtY2lhX2RldmljZSAqbGluaykKewoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IGxpbmstPnByaXY7CgoJaWYgKGxpbmstPm9wZW4pCgkJbmV0aWZfZGV2aWNlX2RldGFjaChkZXYpOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IG5ldHdhdmVfcmVzdW1lKHN0cnVjdCBwY21jaWFfZGV2aWNlICpsaW5rKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gbGluay0+cHJpdjsKCglpZiAobGluay0+b3BlbikgewoJCW5ldHdhdmVfcmVzZXQoZGV2KTsKCQluZXRpZl9kZXZpY2VfYXR0YWNoKGRldik7Cgl9CgoJcmV0dXJuIDA7Cn0KCgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX2RvcmVzZXQgKGlvQmFzZSwgcmFtQmFzZSkKICoKICogICAgUHJvcGVyIGhhcmR3YXJlIHJlc2V0IG9mIHRoZSBjYXJkLgogKi8Kc3RhdGljIHZvaWQgbmV0d2F2ZV9kb3Jlc2V0KGtpb19hZGRyX3QgaW9CYXNlLCB1X2NoYXIgX19pb21lbSAqcmFtQmFzZSkKewogICAgLyogUmVzZXQgY2FyZCAqLwogICAgd2FpdF9XT0MoaW9CYXNlKTsKICAgIG91dGIoMHg4MCwgaW9CYXNlICsgTkVUV0FWRV9SRUdfUE1SKTsKICAgIHdyaXRlYigweDA4LCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0FTQ0MpOyAvKiBCaXQgMyBpcyBXT0MgKi8KICAgIG91dGIoMHgwLCBpb0Jhc2UgKyBORVRXQVZFX1JFR19QTVIpOyAvKiByZWxlYXNlIHJlc2V0ICovCn0KCi8qCiAqIEZ1bmN0aW9uIG5ldHdhdmVfcmVzZXQgKGRldikKICoKICogICAgUmVzZXQgYW5kIHJlc3RvcmUgYWxsIG9mIHRoZSBuZXR3YXZlIHJlZ2lzdGVycyAKICovCnN0YXRpYyB2b2lkIG5ldHdhdmVfcmVzZXQoc3RydWN0IG5ldF9kZXZpY2UgKmRldikgewogICAgLyogdV9jaGFyIHN0YXRlOyAqLwogICAgbmV0d2F2ZV9wcml2YXRlICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKICAgIHVfY2hhciBfX2lvbWVtICpyYW1CYXNlID0gcHJpdi0+cmFtQmFzZTsKICAgIGtpb19hZGRyX3QgaW9iYXNlID0gZGV2LT5iYXNlX2FkZHI7CgogICAgREVCVUcoMCwgIm5ldHdhdmVfcmVzZXQ6IERvbmUgd2l0aCBoYXJkd2FyZSByZXNldFxuIik7CgogICAgcHJpdi0+dGltZW91dENvdW50ZXIgPSAwOwoKICAgIC8qIFJlc2V0IGNhcmQgKi8KICAgIG5ldHdhdmVfZG9yZXNldChpb2Jhc2UsIHJhbUJhc2UpOwogICAgcHJpbnRrKEtFUk5fREVCVUcgIm5ldHdhdmVfcmVzZXQ6IERvbmUgd2l0aCBoYXJkd2FyZSByZXNldFxuIik7CgkKICAgIC8qIFdyaXRlIGEgTk9QIHRvIGNoZWNrIHRoZSBjYXJkICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX05PUCwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDApOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX0VPQywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDEpOwoJCiAgICAvKiBTZXQgcmVjZWl2ZSBjb25mICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX1NSQywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDApOwogICAgd3JpdGViKHJ4Q29uZlJ4RW5hICsgcnhDb25mQmNhc3QsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsKICAgIHdyaXRlYihORVRXQVZFX0NNRF9FT0MsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAyKTsKICAgIAogICAgLyogU2V0IHRyYW5zbWl0IGNvbmYgKi8KICAgIHdhaXRfV09DKGlvYmFzZSk7CiAgICB3cml0ZWIoTkVUV0FWRV9DTURfU1RDLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMCk7CiAgICB3cml0ZWIodHhDb25mVHhFbmEsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsKICAgIHdyaXRlYihORVRXQVZFX0NNRF9FT0MsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAyKTsKICAgIAogICAgLyogTm93IHNldCB0aGUgTVUgRG9tYWluICovCiAgICBwcmludGsoS0VSTl9ERUJVRyAiU2V0dGluZyBkb21haW4gdG8gMHgleCUwMnhcbiIsIChkb21haW4gPj4gOCkgJiAweDAxLCBkb21haW4gJiAweGZmKTsKICAgIHdhaXRfV09DKGlvYmFzZSk7CiAgICB3cml0ZWIoTkVUV0FWRV9DTURfU01ELCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMCk7CiAgICB3cml0ZWIoZG9tYWluICYgMHhmZiwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDEpOwogICAgd3JpdGViKChkb21haW4+PjgpICYgMHgwMSwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDIpOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX0VPQywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDMpOwoJCiAgICAvKiBTZXQgc2NyYW1ibGUga2V5ICovCiAgICBwcmludGsoS0VSTl9ERUJVRyAiU2V0dGluZyBzY3JhbWJsZSBrZXkgdG8gMHgleFxuIiwgc2NyYW1ibGVfa2V5KTsKICAgIHdhaXRfV09DKGlvYmFzZSk7CiAgICB3cml0ZWIoTkVUV0FWRV9DTURfU1NLLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMCk7CiAgICB3cml0ZWIoc2NyYW1ibGVfa2V5ICYgMHhmZiwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDEpOwogICAgd3JpdGViKChzY3JhbWJsZV9rZXk+PjgpICYgMHhmZiwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDIpOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX0VPQywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDMpOwoKICAgIC8qIEVuYWJsZSBpbnRlcnJ1cHRzLCBiaXQgNCBoaWdoIHRvIGtlZXAgdW51c2VkCiAgICAgKiBzb3VyY2UgZnJvbSBpbnRlcnJ1cHRpbmcgdXMsIGJpdCAyIGhpZ2ggdG8gCiAgICAgKiBzZXQgaW50ZXJydXB0IGVuYWJsZSwgNTY3IHRvIGVuYWJsZSBUeEROLCAKICAgICAqIFJ4RXJyIGFuZCBSeFJkeQogICAgICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgb3V0YihpbXJDb25mSUVOQStpbXJDb25mUkZVMSwgaW9iYXNlICsgTkVUV0FWRV9SRUdfSU1SKTsKCiAgICAvKiBIZW50IDQgYnl0ZXMgZnJhIDB4MTcwLiBTa2FsIHZhZXJlIDBhLDI5LDg4LDM2CiAgICAgKiB3YWl0V09DCiAgICAgKiBza3JpdiA4MCB0aWwgZDAwMDozNjg4CiAgICAgKiBzamVrayBvbSBkZXQgYmxlIDgwCiAgICAgKi8KICAgIAogICAgLyogRW5hYmxlIFJlY2VpdmVyICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX0VSLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMCk7CiAgICB3cml0ZWIoTkVUV0FWRV9DTURfRU9DLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMSk7CgkKICAgIC8qIFNldCB0aGUgSUVOQSBiaXQgaW4gQ09SICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgb3V0Yihjb3JDb25mSUVOQSArIGNvckNvbmZMVkxSRVEsIGlvYmFzZSArIE5FVFdBVkVfUkVHX0NPUik7Cn0KCi8qCiAqIEZ1bmN0aW9uIG5ldHdhdmVfaHdfeG1pdCAoZGF0YSwgbGVuLCBkZXYpICAgIAogKi8Kc3RhdGljIGludCBuZXR3YXZlX2h3X3htaXQodW5zaWduZWQgY2hhciogZGF0YSwgaW50IGxlbiwKCQkJICAgc3RydWN0IG5ldF9kZXZpY2UqIGRldikgewogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKICAgIHVuc2lnbmVkIGludCBUeEZyZWVMaXN0LAoJICAgICAgICAgY3VyQnVmZiwKCSAgICAgICAgIE1heERhdGEsIAogICAgICAgICAgICAgICAgIERhdGFPZmZzZXQ7CiAgICBpbnQgdG1wY291bnQ7IAoJCiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogICAgdV9jaGFyIF9faW9tZW0gKiByYW1CYXNlID0gcHJpdi0+cmFtQmFzZTsKICAgIGtpb19hZGRyX3QgaW9iYXNlID0gZGV2LT5iYXNlX2FkZHI7CgogICAgLyogRGlzYWJsZSBpbnRlcnJ1cHRzICYgc2F2ZSBmbGFncyAqLwogICAgc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnNwaW5sb2NrLCBmbGFncyk7CgogICAgLyogQ2hlY2sgaWYgdGhlcmUgYXJlIHRyYW5zbWl0IGJ1ZmZlcnMgYXZhaWxhYmxlICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgaWYgKChpbmIoaW9iYXNlK05FVFdBVkVfUkVHX0FTUikgJiBORVRXQVZFX0FTUl9UWEJBKSA9PSAwKSB7CgkvKiBObyBidWZmZXJzIGF2YWlsYWJsZSAqLwoJcHJpbnRrKEtFUk5fREVCVUcgIm5ldHdhdmVfaHdfeG1pdDogJXMgLSBubyB4bWl0IGJ1ZmZlcnMgYXZhaWxhYmxlLlxuIiwKCSAgICAgICBkZXYtPm5hbWUpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+c3BpbmxvY2ssIGZsYWdzKTsKCXJldHVybiAxOwogICAgfQoKICAgIHByaXYtPnN0YXRzLnR4X2J5dGVzICs9IGxlbjsKCiAgICBERUJVRygzLCAiVHJhbnNtaXR0aW5nIHdpdGggU1BDUSAleCBTUFUgJXggTElGICV4IElTUExRICV4XG4iLAoJICByZWFkYihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX1NQQ1EpLAoJICByZWFkYihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX1NQVSksCgkgIHJlYWRiKHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfTElGKSwKCSAgcmVhZGIocmFtQmFzZSArIE5FVFdBVkVfRVJFR19JU1BMUSkpOwoKICAgIC8qIE5vdyB0cnkgdG8gaW5zZXJ0IGl0IGludG8gdGhlIGFkYXB0ZXJzIGZyZWUgbWVtb3J5ICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgVHhGcmVlTGlzdCA9IGdldF91aW50MTYocmFtQmFzZSArIE5FVFdBVkVfRVJFR19URFApOwogICAgTWF4RGF0YSAgICA9IGdldF91aW50MTYocmFtQmFzZSArIE5FVFdBVkVfRVJFR19URFArMik7CiAgICBEYXRhT2Zmc2V0ID0gZ2V0X3VpbnQxNihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX1REUCs0KTsKCQogICAgREVCVUcoMywgIlR4RnJlZUxpc3QgJXgsIE1heERhdGEgJXgsIERhdGFPZmZzZXQgJXhcbiIsCgkgIFR4RnJlZUxpc3QsIE1heERhdGEsIERhdGFPZmZzZXQpOwoKICAgIC8qIENvcHkgcGFja2V0IHRvIHRoZSBhZGFwdGVyIGZyYWdtZW50IGJ1ZmZlcnMgKi8KICAgIGN1ckJ1ZmYgPSBUeEZyZWVMaXN0OyAKICAgIHRtcGNvdW50ID0gMDsgCiAgICB3aGlsZSAodG1wY291bnQgPCBsZW4pIHsKCWludCB0bXBsZW4gPSBsZW4gLSB0bXBjb3VudDsgCgljb3B5X3RvX3BjKHJhbUJhc2UgKyBjdXJCdWZmICsgRGF0YU9mZnNldCwgZGF0YSArIHRtcGNvdW50LCAKCQkgICAodG1wbGVuIDwgTWF4RGF0YSkgPyB0bXBsZW4gOiBNYXhEYXRhKTsKCXRtcGNvdW50ICs9IE1heERhdGE7CgkJCQoJLyogQWR2YW5jZSB0byBuZXh0IGJ1ZmZlciAqLwoJY3VyQnVmZiA9IGdldF91aW50MTYocmFtQmFzZSArIGN1ckJ1ZmYpOwogICAgfQogICAgCiAgICAvKiBOb3cgaXNzdWUgdHJhbnNtaXQgbGlzdCAqLwogICAgd2FpdF9XT0MoaW9iYXNlKTsKICAgIHdyaXRlYihORVRXQVZFX0NNRF9UTCwgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDApOwogICAgd3JpdGViKGxlbiAmIDB4ZmYsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsKICAgIHdyaXRlYigobGVuPj44KSAmIDB4ZmYsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAyKTsKICAgIHdyaXRlYihORVRXQVZFX0NNRF9FT0MsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAzKTsKCiAgICBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5zcGlubG9jaywgZmxhZ3MpOwogICAgcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgbmV0d2F2ZV9zdGFydF94bWl0KHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpIHsKCS8qIFRoaXMgZmxhZyBpbmRpY2F0ZSB0aGF0IHRoZSBoYXJkd2FyZSBjYW4ndCBwZXJmb3JtIGEgdHJhbnNtaXNzaW9uLgoJICogVGhlb3JpdGljYWxseSwgTkVUMyBjaGVjayBpdCBiZWZvcmUgc2VuZGluZyBhIHBhY2tldCB0byB0aGUgZHJpdmVyLAoJICogYnV0IGluIGZhY3QgaXQgbmV2ZXIgZG8gdGhhdCBhbmQgcG9vbCBjb250aW51b3VzbHkuCgkgKiBBcyB0aGUgd2F0Y2hkb2cgd2lsbCBhYm9ydCB0b28gbG9uZyB0cmFuc21pc3Npb25zLCB3ZSBhcmUgcXVpdGUgc2FmZS4uLgoJICovCgogICAgbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwoKICAgIHsKCXNob3J0IGxlbmd0aCA9IEVUSF9aTEVOIDwgc2tiLT5sZW4gPyBza2ItPmxlbiA6IEVUSF9aTEVOOwoJdW5zaWduZWQgY2hhciogYnVmID0gc2tiLT5kYXRhOwoJCglpZiAobmV0d2F2ZV9od194bWl0KCBidWYsIGxlbmd0aCwgZGV2KSA9PSAxKSB7CgkgICAgLyogU29tZSBlcnJvciwgbGV0J3MgbWFrZSB0aGVtIGNhbGwgdXMgYW5vdGhlciB0aW1lPyAqLwoJICAgIG5ldGlmX3N0YXJ0X3F1ZXVlKGRldik7Cgl9CglkZXYtPnRyYW5zX3N0YXJ0ID0gamlmZmllczsKICAgIH0KICAgIGRldl9rZnJlZV9za2Ioc2tiKTsKICAgIAogICAgcmV0dXJuIDA7Cn0gLyogbmV0d2F2ZV9zdGFydF94bWl0ICovCgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX2ludGVycnVwdCAoaXJxLCBkZXZfaWQsIHJlZ3MpCiAqCiAqICAgIFRoaXMgZnVuY3Rpb24gaXMgdGhlIGludGVycnVwdCBoYW5kbGVyIGZvciB0aGUgTmV0d2F2ZSBjYXJkLiBUaGlzCiAqICAgIHJvdXRpbmUgd2lsbCBiZSBjYWxsZWQgd2hlbmV2ZXI6IAogKgkgIDEuIEEgcGFja2V0IGlzIHJlY2VpdmVkLgogKgkgIDIuIEEgcGFja2V0IGhhcyBzdWNjZXNzZnVsbHkgYmVlbiB0cmFuc2ZlcnJlZCBhbmQgdGhlIHVuaXQgaXMKICoJICAgICByZWFkeSB0byB0cmFuc21pdCBhbm90aGVyIHBhY2tldC4KICoJICAzLiBBIGNvbW1hbmQgaGFzIGNvbXBsZXRlZCBleGVjdXRpb24uCiAqLwpzdGF0aWMgaXJxcmV0dXJuX3QgbmV0d2F2ZV9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCogZGV2X2lkLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewogICAga2lvX2FkZHJfdCBpb2Jhc2U7CiAgICB1X2NoYXIgX19pb21lbSAqcmFtQmFzZTsKICAgIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSAoc3RydWN0IG5ldF9kZXZpY2UgKilkZXZfaWQ7CiAgICBzdHJ1Y3QgbmV0d2F2ZV9wcml2YXRlICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKICAgIHN0cnVjdCBwY21jaWFfZGV2aWNlICpsaW5rID0gcHJpdi0+cF9kZXY7CiAgICBpbnQgaTsKICAgIAogICAgaWYgKCFuZXRpZl9kZXZpY2VfcHJlc2VudChkZXYpKQoJcmV0dXJuIElSUV9OT05FOwogICAgCiAgICBpb2Jhc2UgPSBkZXYtPmJhc2VfYWRkcjsKICAgIHJhbUJhc2UgPSBwcml2LT5yYW1CYXNlOwoJCiAgICAvKiBOb3cgZmluZCB3aGF0IGNhdXNlZCB0aGUgaW50ZXJydXB0LCBjaGVjayB3aGlsZSBpbnRlcnJ1cHRzIHJlYWR5ICovCiAgICBmb3IgKGkgPSAwOyBpIDwgMTA7IGkrKykgewoJdV9jaGFyIHN0YXR1czsKCQkKCXdhaXRfV09DKGlvYmFzZSk7CQoJaWYgKCEoaW5iKGlvYmFzZStORVRXQVZFX1JFR19DQ1NSKSAmIDB4MDIpKQoJICAgIGJyZWFrOyAvKiBOb25lIG9mIHRoZSBpbnRlcnJ1cHQgc291cmNlcyBhc3NlcnRlZCAobm9ybWFsIGV4aXQpICovCgkKICAgICAgICBzdGF0dXMgPSBpbmIoaW9iYXNlICsgTkVUV0FWRV9SRUdfQVNSKTsKCQkKCWlmICghcGNtY2lhX2Rldl9wcmVzZW50KGxpbmspKSB7CgkgICAgREVCVUcoMSwgIm5ldHdhdmVfaW50ZXJydXB0OiBJbnRlcnJ1cHQgd2l0aCBzdGF0dXMgMHgleCAiCgkJICAiZnJvbSByZW1vdmVkIG9yIHN1c3BlbmRlZCBjYXJkIVxuIiwgc3RhdHVzKTsKCSAgICBicmVhazsKCX0KCQkKCS8qIFJ4UmR5ICovCglpZiAoc3RhdHVzICYgMHg4MCkgewoJICAgIG5ldHdhdmVfcngoZGV2KTsKCSAgICAvKiB3YWl0X1dPQyhpb2Jhc2UpOyAqLwoJICAgIC8qIFJ4UmR5IGNhbm5vdCBiZSByZXNldCBkaXJlY3RseSBieSB0aGUgaG9zdCAqLwoJfQoJLyogUnhFcnIgKi8KCWlmIChzdGF0dXMgJiAweDQwKSB7CgkgICAgdV9jaGFyIHJzZXI7CgkJCQoJICAgIHJzZXIgPSByZWFkYihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX1JTRVIpOwkJCQoJICAgIAoJICAgIGlmIChyc2VyICYgMHgwNCkgewoJCSsrcHJpdi0+c3RhdHMucnhfZHJvcHBlZDsgCgkJKytwcml2LT5zdGF0cy5yeF9jcmNfZXJyb3JzOwoJICAgIH0KCSAgICBpZiAocnNlciAmIDB4MDIpCgkJKytwcml2LT5zdGF0cy5yeF9mcmFtZV9lcnJvcnM7CgkJCQoJICAgIC8qIENsZWFyIHRoZSBSeEVyciBiaXQgaW4gUlNFUi4gUlNFUis0IGlzIHRoZQoJICAgICAqIHdyaXRlIHBhcnQuIEFsc28gY2xlYXIgdGhlIFJ4Q1JDICgweDA0KSBhbmQgCgkgICAgICogUnhCaWcgKDB4MDIpIGJpdHMgaWYgcHJlc2VudCAqLwoJICAgIHdhaXRfV09DKGlvYmFzZSk7CgkgICAgd3JpdGViKDB4NDAgfCAocnNlciAmIDB4MDYpLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX1JTRVIgKyA0KTsKCgkgICAgLyogV3JpdGUgYml0IDYgaGlnaCB0byBBU0NDIHRvIGNsZWFyIFJ4RXJyIGluIEFTUiwKCSAgICAgKiBXT0MgbXVzdCBiZSBzZXQgZmlyc3QhIAoJICAgICAqLwoJICAgIHdhaXRfV09DKGlvYmFzZSk7CgkgICAgd3JpdGViKDB4NDAsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQVNDQyk7CgoJICAgIC8qIFJlbWVtYmVyIHRvIGNvdW50IHVwIHByaXYtPnN0YXRzIG9uIGVycm9yIHBhY2tldHMgKi8KCSAgICArK3ByaXYtPnN0YXRzLnJ4X2Vycm9yczsKCX0KCS8qIFR4RE4gKi8KCWlmIChzdGF0dXMgJiAweDIwKSB7CgkgICAgaW50IHR4U3RhdHVzOwoKCSAgICB0eFN0YXR1cyA9IHJlYWRiKHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfVFNFUik7CgkgICAgREVCVUcoMywgIlRyYW5zbWl0IGRvbmUuIFRTRVIgPSAleCBpZCAleFxuIiwgCgkJICB0eFN0YXR1cywgcmVhZGIocmFtQmFzZSArIE5FVFdBVkVfRVJFR19UU0VSICsgMSkpOwoJICAgIAoJICAgIGlmICh0eFN0YXR1cyAmIDB4MjApIHsKCQkvKiBUcmFuc21pdHRpbmcgd2FzIG9rYXksIGNsZWFyIGJpdHMgKi8KCQl3YWl0X1dPQyhpb2Jhc2UpOwoJCXdyaXRlYigweDJmLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX1RTRVIgKyA0KTsKCQkrK3ByaXYtPnN0YXRzLnR4X3BhY2tldHM7CgkgICAgfQoJCQkKCSAgICBpZiAodHhTdGF0dXMgJiAweGQwKSB7CgkJaWYgKHR4U3RhdHVzICYgMHg4MCkgewoJCSAgICArK3ByaXYtPnN0YXRzLmNvbGxpc2lvbnM7IC8qIEJlY2F1c2Ugb2YgL3Byb2MvbmV0L2RldiovCgkJICAgIC8qICsrcHJpdi0+c3RhdHMudHhfYWJvcnRlZF9lcnJvcnM7ICovCgkJICAgIC8qIHByaW50aygiQ29sbGlzaW9uLiAlbGRcbiIsIGppZmZpZXMgLSBkZXYtPnRyYW5zX3N0YXJ0KTsgKi8KCQl9CgkJaWYgKHR4U3RhdHVzICYgMHg0MCkgCgkJICAgICsrcHJpdi0+c3RhdHMudHhfY2Fycmllcl9lcnJvcnM7CgkJLyogMHg4MCBUeEdVIFRyYW5zbWl0IGdpdmV1cCAtIG5pbmUgdGltZXMgYW5kIG5vIGx1Y2sKCQkgKiAweDQwIFR4Tk9BUCBObyBhY2Nlc3MgcG9pbnQuIERpc2NhcmRlZCBwYWNrZXQuCgkJICogMHgxMCBUeEVyciBUcmFuc21pdCBlcnJvci4gQWx3YXlzIHNldCB3aGVuIAoJCSAqICAgICAgVHhHVSBhbmQgVHhOT0FQIGlzIHNldC4gKFRob3NlIGFyZSB0aGUgb25seSBvbmVzCgkJICogICAgICB0byBzZXQgVHhFcnIpLgoJCSAqLwoJCURFQlVHKDMsICJuZXR3YXZlX2ludGVycnVwdDogVHhETiB3aXRoIGVycm9yIHN0YXR1cyAleFxuIiwgCgkJICAgICAgdHhTdGF0dXMpOwoJCQoJCS8qIENsZWFyIG91dCBUeEdVLCBUeE5PQVAsIFR4RXJyIGFuZCBUeFRyeXMgKi8KCQl3YWl0X1dPQyhpb2Jhc2UpOwoJCXdyaXRlYigweGRmICYgdHhTdGF0dXMsIHJhbUJhc2UrTkVUV0FWRV9FUkVHX1RTRVIrNCk7CgkJKytwcml2LT5zdGF0cy50eF9lcnJvcnM7CgkgICAgfQoJICAgIERFQlVHKDMsICJOZXcgc3RhdHVzIGlzIFRTRVIgJXggQVNSICV4XG4iLAoJCSAgcmVhZGIocmFtQmFzZSArIE5FVFdBVkVfRVJFR19UU0VSKSwKCQkgIGluYihpb2Jhc2UgKyBORVRXQVZFX1JFR19BU1IpKTsKCgkgICAgbmV0aWZfd2FrZV9xdWV1ZShkZXYpOwoJfQoJLyogVHhCQSwgdGhpcyB3b3VsZCB0cmlnZ2VyIG9uIGFsbCBlcnJvciBwYWNrZXRzIHJlY2VpdmVkICovCgkvKiBpZiAoc3RhdHVzICYgMHgwMSkgewoJICAgREVCVUcoNCwgIlRyYW5zbWl0IGJ1ZmZlcnMgYXZhaWxhYmxlLCAleFxuIiwgc3RhdHVzKTsKCSAgIH0KCSAgICovCiAgICB9CiAgICAvKiBIYW5kbGVkIGlmIHdlIGxvb3BlZCBhdCBsZWFzdCBvbmUgdGltZSAtIEplYW4gSUkgKi8KICAgIHJldHVybiBJUlFfUkVUVkFMKGkpOwp9IC8qIG5ldHdhdmVfaW50ZXJydXB0ICovCgovKgogKiBGdW5jdGlvbiBuZXR3YXZlX3dhdGNoZG9nIChhKQogKgogKiAgICBXYXRjaGRvZyA6IHdoZW4gd2Ugc3RhcnQgYSB0cmFuc21pc3Npb24sIHdlIHNldCBhIHRpbWVyIGluIHRoZQogKiAgICBrZXJuZWwuICBJZiB0aGUgdHJhbnNtaXNzaW9uIGNvbXBsZXRlLCB0aGlzIHRpbWVyIGlzIGRpc2FibGVkLiBJZgogKiAgICBpdCBleHBpcmUsIHdlIHJlc2V0IHRoZSBjYXJkLgogKgogKi8Kc3RhdGljIHZvaWQgbmV0d2F2ZV93YXRjaGRvZyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KSB7CgogICAgREVCVUcoMSwgIiVzOiBuZXR3YXZlX3dhdGNoZG9nOiB3YXRjaGRvZyB0aW1lciBleHBpcmVkXG4iLCBkZXYtPm5hbWUpOwogICAgbmV0d2F2ZV9yZXNldChkZXYpOwogICAgZGV2LT50cmFuc19zdGFydCA9IGppZmZpZXM7CiAgICBuZXRpZl93YWtlX3F1ZXVlKGRldik7Cn0gLyogbmV0d2F2ZV93YXRjaGRvZyAqLwoKc3RhdGljIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpuZXR3YXZlX2dldF9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KSB7CiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwoKICAgIHVwZGF0ZV9zdGF0cyhkZXYpOwoKICAgIERFQlVHKDIsICJuZXR3YXZlOiBTUENRICV4IFNQVSAleCBMSUYgJXggSVNQTFEgJXggTUhTICV4IHJ4dHggJXgiCgkgICIgJXggdHggJXggJXggJXggJXhcbiIsIAoJICByZWFkYihwcml2LT5yYW1CYXNlICsgTkVUV0FWRV9FUkVHX1NQQ1EpLAoJICByZWFkYihwcml2LT5yYW1CYXNlICsgTkVUV0FWRV9FUkVHX1NQVSksCgkgIHJlYWRiKHByaXYtPnJhbUJhc2UgKyBORVRXQVZFX0VSRUdfTElGKSwKCSAgcmVhZGIocHJpdi0+cmFtQmFzZSArIE5FVFdBVkVfRVJFR19JU1BMUSksCgkgIHJlYWRiKHByaXYtPnJhbUJhc2UgKyBORVRXQVZFX0VSRUdfTUhTKSwKCSAgcmVhZGIocHJpdi0+cmFtQmFzZSArIE5FVFdBVkVfRVJFR19FQyArIDB4ZSksCgkgIHJlYWRiKHByaXYtPnJhbUJhc2UgKyBORVRXQVZFX0VSRUdfRUMgKyAweGYpLAoJICByZWFkYihwcml2LT5yYW1CYXNlICsgTkVUV0FWRV9FUkVHX0VDICsgMHgxOCksCgkgIHJlYWRiKHByaXYtPnJhbUJhc2UgKyBORVRXQVZFX0VSRUdfRUMgKyAweDE5KSwKCSAgcmVhZGIocHJpdi0+cmFtQmFzZSArIE5FVFdBVkVfRVJFR19FQyArIDB4MWEpLAoJICByZWFkYihwcml2LT5yYW1CYXNlICsgTkVUV0FWRV9FUkVHX0VDICsgMHgxYikpOwoKICAgIHJldHVybiAmcHJpdi0+c3RhdHM7Cn0KCnN0YXRpYyB2b2lkIHVwZGF0ZV9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KSB7CiAgICAvL3Vuc2lnbmVkIGxvbmcgZmxhZ3M7Ci8qICAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOyAqLwoKICAgIC8vc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnNwaW5sb2NrLCBmbGFncyk7CgovKiAgICBwcml2LT5zdGF0cy5yeF9wYWNrZXRzID0gcmVhZGIocHJpdi0+cmFtQmFzZSArIDB4MThlKTsgCiAgICBwcml2LT5zdGF0cy50eF9wYWNrZXRzID0gcmVhZGIocHJpdi0+cmFtQmFzZSArIDB4MThmKTsgKi8KCiAgICAvL3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnNwaW5sb2NrLCBmbGFncyk7Cn0KCnN0YXRpYyBpbnQgbmV0d2F2ZV9yeChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQp7CiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogICAgdV9jaGFyIF9faW9tZW0gKnJhbUJhc2UgPSBwcml2LT5yYW1CYXNlOwogICAga2lvX2FkZHJfdCBpb2Jhc2UgPSBkZXYtPmJhc2VfYWRkcjsKICAgIHVfY2hhciByeFN0YXR1czsKICAgIHN0cnVjdCBza19idWZmICpza2IgPSBOVUxMOwogICAgdW5zaWduZWQgaW50IGN1ckJ1ZmZlciwKCQlyY3ZMaXN0OwogICAgaW50IHJjdkxlbjsKICAgIGludCB0bXBjb3VudCA9IDA7CiAgICBpbnQgZGF0YUNvdW50LCBkYXRhT2Zmc2V0OwogICAgaW50IGk7CiAgICB1X2NoYXIgKnB0cjsKCQogICAgREVCVUcoMywgInhpbndfcng6IFJlY2VpdmluZyAuLi4gXG4iKTsKCiAgICAvKiBSZWNlaXZlIG1heCAxMCBwYWNrZXRzIGZvciBub3cuICovCiAgICBmb3IgKGkgPSAwOyBpIDwgMTA7IGkrKykgewoJLyogQW55IHBhY2tldHM/ICovCgl3YWl0X1dPQyhpb2Jhc2UpOwoJcnhTdGF0dXMgPSByZWFkYihyYW1CYXNlICsgTkVUV0FWRV9FUkVHX1JTRVIpOwkJCglpZiAoICEoIHJ4U3RhdHVzICYgMHg4MCkpIC8qIE5vIG1vcmUgcGFja2V0cyAqLwoJICAgIGJyZWFrOwoJCQoJLyogQ2hlY2sgaWYgbXVsdGljYXN0L2Jyb2FkY2FzdCBvciBvdGhlciAqLwoJLyogbXVsdGljYXN0ID0gKHJ4U3RhdHVzICYgMHgyMCk7ICAqLwoJCQoJLyogVGhlIHJlY2VpdmUgbGlzdCBwb2ludGVyIGFuZCBsZW5ndGggb2YgdGhlIHBhY2tldCAqLwoJd2FpdF9XT0MoaW9iYXNlKTsKCXJjdkxlbiAgPSBnZXRfaW50MTYoIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfUkRQKTsKCXJjdkxpc3QgPSBnZXRfdWludDE2KCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX1JEUCArIDIpOwoJCQoJaWYgKHJjdkxlbiA8IDApIHsKCSAgICBwcmludGsoS0VSTl9ERUJVRyAibmV0d2F2ZV9yeDogUmVjZWl2ZSBwYWNrZXQgd2l0aCBsZW4gJWRcbiIsIAoJCSAgIHJjdkxlbik7CgkgICAgcmV0dXJuIDA7Cgl9CgkJCglza2IgPSBkZXZfYWxsb2Nfc2tiKHJjdkxlbis1KTsKCWlmIChza2IgPT0gTlVMTCkgewoJICAgIERFQlVHKDEsICJuZXR3YXZlX3J4OiBDb3VsZCBub3QgYWxsb2NhdGUgYW4gc2tfYnVmZiBvZiAiCgkJICAibGVuZ3RoICVkXG4iLCByY3ZMZW4pOwoJICAgICsrcHJpdi0+c3RhdHMucnhfZHJvcHBlZDsgCgkgICAgLyogVGVsbCB0aGUgYWRhcHRlciB0byBza2lwIHRoZSBwYWNrZXQgKi8KCSAgICB3YWl0X1dPQyhpb2Jhc2UpOwoJICAgIHdyaXRlYihORVRXQVZFX0NNRF9TUlAsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAwKTsKCSAgICB3cml0ZWIoTkVUV0FWRV9DTURfRU9DLCByYW1CYXNlICsgTkVUV0FWRV9FUkVHX0NCICsgMSk7CgkgICAgcmV0dXJuIDA7Cgl9CgoJc2tiX3Jlc2VydmUoIHNrYiwgMik7ICAvKiBBbGlnbiBJUCBvbiAxNiBieXRlICovCglza2JfcHV0KCBza2IsIHJjdkxlbik7Cglza2ItPmRldiA9IGRldjsKCgkvKiBDb3B5IHBhY2tldCBmcmFnbWVudHMgdG8gdGhlIHNrYiBkYXRhIGFyZWEgKi8KCXB0ciA9ICh1X2NoYXIqKSBza2ItPmRhdGE7CgljdXJCdWZmZXIgPSByY3ZMaXN0OwoJdG1wY291bnQgPSAwOyAKCXdoaWxlICggdG1wY291bnQgPCByY3ZMZW4pIHsKCSAgICAvKiBHZXQgbGVuZ3RoIGFuZCBvZmZzZXQgb2YgY3VycmVudCBidWZmZXIgKi8KCSAgICBkYXRhQ291bnQgID0gZ2V0X3VpbnQxNiggcmFtQmFzZStjdXJCdWZmZXIrMik7CgkgICAgZGF0YU9mZnNldCA9IGdldF91aW50MTYoIHJhbUJhc2UrY3VyQnVmZmVyKzQpOwoJCQoJICAgIGNvcHlfZnJvbV9wYyggcHRyICsgdG1wY291bnQsCgkJCSAgcmFtQmFzZStjdXJCdWZmZXIrZGF0YU9mZnNldCwgZGF0YUNvdW50KTsKCgkgICAgdG1wY291bnQgKz0gZGF0YUNvdW50OwoJCQoJICAgIC8qIFBvaW50IHRvIG5leHQgYnVmZmVyICovCgkgICAgY3VyQnVmZmVyID0gZ2V0X3VpbnQxNihyYW1CYXNlICsgY3VyQnVmZmVyKTsKCX0KCQoJc2tiLT5wcm90b2NvbCA9IGV0aF90eXBlX3RyYW5zKHNrYixkZXYpOwoJLyogUXVldWUgcGFja2V0IGZvciBuZXR3b3JrIGxheWVyICovCgluZXRpZl9yeChza2IpOwoKCWRldi0+bGFzdF9yeCA9IGppZmZpZXM7Cglwcml2LT5zdGF0cy5yeF9wYWNrZXRzKys7Cglwcml2LT5zdGF0cy5yeF9ieXRlcyArPSByY3ZMZW47CgoJLyogR290IHRoZSBwYWNrZXQsIHRlbGwgdGhlIGFkYXB0ZXIgdG8gc2tpcCBpdCAqLwoJd2FpdF9XT0MoaW9iYXNlKTsKCXdyaXRlYihORVRXQVZFX0NNRF9TUlAsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAwKTsKCXdyaXRlYihORVRXQVZFX0NNRF9FT0MsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsKCURFQlVHKDMsICJQYWNrZXQgcmVjZXB0aW9uIG9rXG4iKTsKICAgIH0KICAgIHJldHVybiAwOwp9CgpzdGF0aWMgaW50IG5ldHdhdmVfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KSB7CiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogICAgc3RydWN0IHBjbWNpYV9kZXZpY2UgKmxpbmsgPSBwcml2LT5wX2RldjsKCiAgICBERUJVRygxLCAibmV0d2F2ZV9vcGVuOiBzdGFydGluZy5cbiIpOwogICAgCiAgICBpZiAoIXBjbWNpYV9kZXZfcHJlc2VudChsaW5rKSkKCXJldHVybiAtRU5PREVWOwoKICAgIGxpbmstPm9wZW4rKzsKCiAgICBuZXRpZl9zdGFydF9xdWV1ZShkZXYpOwogICAgbmV0d2F2ZV9yZXNldChkZXYpOwoJCiAgICByZXR1cm4gMDsKfQoKc3RhdGljIGludCBuZXR3YXZlX2Nsb3NlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpIHsKICAgIG5ldHdhdmVfcHJpdmF0ZSAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CiAgICBzdHJ1Y3QgcGNtY2lhX2RldmljZSAqbGluayA9IHByaXYtPnBfZGV2OwoKICAgIERFQlVHKDEsICJuZXR3YXZlX2Nsb3NlOiBmaW5pc2hpbmcuXG4iKTsKCiAgICBsaW5rLT5vcGVuLS07CiAgICBuZXRpZl9zdG9wX3F1ZXVlKGRldik7CgogICAgcmV0dXJuIDA7Cn0KCnN0YXRpYyBzdHJ1Y3QgcGNtY2lhX2RldmljZV9pZCBuZXR3YXZlX2lkc1tdID0gewoJUENNQ0lBX0RFVklDRV9QUk9EX0lEMTIoIlhpcmNvbSIsICJDcmVkaXRDYXJkIE5ldHdhdmUiLCAweDJlM2VlODQ1LCAweDU0ZTI4YTI4KSwKCVBDTUNJQV9ERVZJQ0VfTlVMTCwKfTsKTU9EVUxFX0RFVklDRV9UQUJMRShwY21jaWEsIG5ldHdhdmVfaWRzKTsKCnN0YXRpYyBzdHJ1Y3QgcGNtY2lhX2RyaXZlciBuZXR3YXZlX2RyaXZlciA9IHsKCS5vd25lcgkJPSBUSElTX01PRFVMRSwKCS5kcnYJCT0gewoJCS5uYW1lCT0gIm5ldHdhdmVfY3MiLAoJfSwKCS5wcm9iZQkJPSBuZXR3YXZlX3Byb2JlLAoJLnJlbW92ZQkJPSBuZXR3YXZlX2RldGFjaCwKCS5pZF90YWJsZSAgICAgICA9IG5ldHdhdmVfaWRzLAoJLnN1c3BlbmQJPSBuZXR3YXZlX3N1c3BlbmQsCgkucmVzdW1lCQk9IG5ldHdhdmVfcmVzdW1lLAp9OwoKc3RhdGljIGludCBfX2luaXQgaW5pdF9uZXR3YXZlX2NzKHZvaWQpCnsKCXJldHVybiBwY21jaWFfcmVnaXN0ZXJfZHJpdmVyKCZuZXR3YXZlX2RyaXZlcik7Cn0KCnN0YXRpYyB2b2lkIF9fZXhpdCBleGl0X25ldHdhdmVfY3Modm9pZCkKewoJcGNtY2lhX3VucmVnaXN0ZXJfZHJpdmVyKCZuZXR3YXZlX2RyaXZlcik7Cn0KCm1vZHVsZV9pbml0KGluaXRfbmV0d2F2ZV9jcyk7Cm1vZHVsZV9leGl0KGV4aXRfbmV0d2F2ZV9jcyk7CgovKiBTZXQgb3IgY2xlYXIgdGhlIG11bHRpY2FzdCBmaWx0ZXIgZm9yIHRoaXMgYWRhcHRvci4KICAgbnVtX2FkZHJzID09IC0xCVByb21pc2N1b3VzIG1vZGUsIHJlY2VpdmUgYWxsIHBhY2tldHMKICAgbnVtX2FkZHJzID09IDAJTm9ybWFsIG1vZGUsIGNsZWFyIG11bHRpY2FzdCBsaXN0CiAgIG51bV9hZGRycyA+IDAJTXVsdGljYXN0IG1vZGUsIHJlY2VpdmUgbm9ybWFsIGFuZCBNQyBwYWNrZXRzLCBhbmQgZG8KICAgYmVzdC1lZmZvcnQgZmlsdGVyaW5nLgogKi8Kc3RhdGljIHZvaWQgc2V0X211bHRpY2FzdF9saXN0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKICAgIGtpb19hZGRyX3QgaW9iYXNlID0gZGV2LT5iYXNlX2FkZHI7CiAgICBuZXR3YXZlX3ByaXZhdGUgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOwogICAgdV9jaGFyIF9faW9tZW0gKiByYW1CYXNlID0gcHJpdi0+cmFtQmFzZTsKICAgIHVfY2hhciAgcmN2TW9kZSA9IDA7CiAgIAojaWZkZWYgUENNQ0lBX0RFQlVHCiAgICBpZiAocGNfZGVidWcgPiAyKSB7CglzdGF0aWMgaW50IG9sZDsKCWlmIChvbGQgIT0gZGV2LT5tY19jb3VudCkgewoJICAgIG9sZCA9IGRldi0+bWNfY291bnQ7CgkgICAgREVCVUcoMCwgIiVzOiBzZXR0aW5nIFJ4IG1vZGUgdG8gJWQgYWRkcmVzc2VzLlxuIiwKCQkgIGRldi0+bmFtZSwgZGV2LT5tY19jb3VudCk7Cgl9CiAgICB9CiNlbmRpZgoJCiAgICBpZiAoZGV2LT5tY19jb3VudCB8fCAoZGV2LT5mbGFncyAmIElGRl9BTExNVUxUSSkpIHsKCS8qIE11bHRpY2FzdCBNb2RlICovCglyY3ZNb2RlID0gcnhDb25mUnhFbmEgKyByeENvbmZBTVAgKyByeENvbmZCY2FzdDsKICAgIH0gZWxzZSBpZiAoZGV2LT5mbGFncyAmIElGRl9QUk9NSVNDKSB7CgkvKiBQcm9taXNjb3VzIG1vZGUgKi8KCXJjdk1vZGUgPSByeENvbmZSeEVuYSArIHJ4Q29uZlBybyArIHJ4Q29uZkFNUCArIHJ4Q29uZkJjYXN0OwogICAgfSBlbHNlIHsKCS8qIE5vcm1hbCBtb2RlICovCglyY3ZNb2RlID0gcnhDb25mUnhFbmEgKyByeENvbmZCY2FzdDsKICAgIH0KCQogICAgLyogcHJpbnRrKCJuZXR3YXZlIHNldF9tdWx0aWNhc3RfbGlzdDogcmN2TW9kZSB0byAleFxuIiwgcmN2TW9kZSk7Ki8KICAgIC8qIE5vdyBzZXQgcmVjZWl2ZSBtb2RlICovCiAgICB3YWl0X1dPQyhpb2Jhc2UpOwogICAgd3JpdGViKE5FVFdBVkVfQ01EX1NSQywgcmFtQmFzZSArIE5FVFdBVkVfRVJFR19DQiArIDApOwogICAgd3JpdGViKHJjdk1vZGUsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAxKTsKICAgIHdyaXRlYihORVRXQVZFX0NNRF9FT0MsIHJhbUJhc2UgKyBORVRXQVZFX0VSRUdfQ0IgKyAyKTsKfQpNT0RVTEVfTElDRU5TRSgiR1BMIik7Cg==