LyoKICogbGludXgvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9vbWFwLWtleXBhZC5jCiAqCiAqIE9NQVAgS2V5cGFkIERyaXZlcgogKgogKiBDb3B5cmlnaHQgKEMpIDIwMDMgTm9raWEgQ29ycG9yYXRpb24KICogV3JpdHRlbiBieSBUaW1vIFRlcuRzIDxleHQtdGltby50ZXJhc0Bub2tpYS5jb20+CiAqCiAqIEFkZGVkIHN1cHBvcnQgZm9yIEgyICYgSDMgS2V5cGFkCiAqIENvcHlyaWdodCAoQykgMjAwNCBUZXhhcyBJbnN0cnVtZW50cwogKgogKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQogKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgogKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCiAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCiAqCiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcgVVNBCiAqLwoKI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgojaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgojaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgojaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiNpbmNsdWRlIDxhc20vYXJjaC9ncGlvLmg+CiNpbmNsdWRlIDxhc20vYXJjaC9rZXlwYWQuaD4KI2luY2x1ZGUgPGFzbS9hcmNoL21lbmVsYXVzLmg+CiNpbmNsdWRlIDxhc20vaXJxLmg+CiNpbmNsdWRlIDxhc20vaGFyZHdhcmUuaD4KI2luY2x1ZGUgPGFzbS9pby5oPgojaW5jbHVkZSA8YXNtL21hY2gtdHlwZXMuaD4KI2luY2x1ZGUgPGFzbS9hcmNoL211eC5oPgoKI3VuZGVmIE5FV19CT0FSRF9MRUFSTklOR19NT0RFCgpzdGF0aWMgdm9pZCBvbWFwX2twX3Rhc2tsZXQodW5zaWduZWQgbG9uZyk7CnN0YXRpYyB2b2lkIG9tYXBfa3BfdGltZXIodW5zaWduZWQgbG9uZyk7CgpzdGF0aWMgdW5zaWduZWQgY2hhciBrZXlwYWRfc3RhdGVbOF07CnN0YXRpYyBERUZJTkVfTVVURVgoa3BfZW5hYmxlX211dGV4KTsKc3RhdGljIGludCBrcF9lbmFibGUgPSAxOwpzdGF0aWMgaW50IGtwX2N1cl9ncm91cCA9IC0xOwoKc3RydWN0IG9tYXBfa3AgewoJc3RydWN0IGlucHV0X2RldiAqaW5wdXQ7CglzdHJ1Y3QgdGltZXJfbGlzdCB0aW1lcjsKCWludCBpcnE7Cgl1bnNpZ25lZCBpbnQgcm93czsKCXVuc2lnbmVkIGludCBjb2xzOwoJdW5zaWduZWQgbG9uZyBkZWxheTsKCXVuc2lnbmVkIGludCBkZWJvdW5jZTsKfTsKCkRFQ0xBUkVfVEFTS0xFVF9ESVNBQkxFRChrcF90YXNrbGV0LCBvbWFwX2twX3Rhc2tsZXQsIDApOwoKc3RhdGljIGludCAqa2V5bWFwOwpzdGF0aWMgdW5zaWduZWQgaW50ICpyb3dfZ3Bpb3M7CnN0YXRpYyB1bnNpZ25lZCBpbnQgKmNvbF9ncGlvczsKCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMgpzdGF0aWMgdm9pZCBzZXRfY29sX2dwaW9fdmFsKHN0cnVjdCBvbWFwX2twICpvbWFwX2twLCB1OCB2YWx1ZSkKewoJaW50IGNvbDsKCWZvciAoY29sID0gMDsgY29sIDwgb21hcF9rcC0+Y29sczsgY29sKyspIHsKCQlpZiAodmFsdWUgJiAoMSA8PCBjb2wpKQoJCQlvbWFwX3NldF9ncGlvX2RhdGFvdXQoY29sX2dwaW9zW2NvbF0sIDEpOwoJCWVsc2UKCQkJb21hcF9zZXRfZ3Bpb19kYXRhb3V0KGNvbF9ncGlvc1tjb2xdLCAwKTsKCX0KfQoKc3RhdGljIHU4IGdldF9yb3dfZ3Bpb192YWwoc3RydWN0IG9tYXBfa3AgKm9tYXBfa3ApCnsKCWludCByb3c7Cgl1OCB2YWx1ZSA9IDA7CgoJZm9yIChyb3cgPSAwOyByb3cgPCBvbWFwX2twLT5yb3dzOyByb3crKykgewoJCWlmIChvbWFwX2dldF9ncGlvX2RhdGFpbihyb3dfZ3Bpb3Nbcm93XSkpCgkJCXZhbHVlIHw9ICgxIDw8IHJvdyk7Cgl9CglyZXR1cm4gdmFsdWU7Cn0KI2Vsc2UKI2RlZmluZQkJc2V0X2NvbF9ncGlvX3ZhbCh4LCB5KQlkbyB7fSB3aGlsZSAoMCkKI2RlZmluZQkJZ2V0X3Jvd19ncGlvX3ZhbCh4KQkwCiNlbmRpZgoKc3RhdGljIGlycXJldHVybl90IG9tYXBfa3BfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKewoJc3RydWN0IG9tYXBfa3AgKm9tYXBfa3AgPSBkZXZfaWQ7CgoJLyogZGlzYWJsZSBrZXlib2FyZCBpbnRlcnJ1cHQgYW5kIHNjaGVkdWxlIGZvciBoYW5kbGluZyAqLwoJaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJaW50IGk7CgkJZm9yIChpID0gMDsgaSA8IG9tYXBfa3AtPnJvd3M7IGkrKykKCQkJZGlzYWJsZV9pcnEoT01BUF9HUElPX0lSUShyb3dfZ3Bpb3NbaV0pKTsKCX0gZWxzZQoJCS8qIGRpc2FibGUga2V5Ym9hcmQgaW50ZXJydXB0IGFuZCBzY2hlZHVsZSBmb3IgaGFuZGxpbmcgKi8KCQlvbWFwX3dyaXRldygxLCBPTUFQX01QVUlPX0JBU0UgKyBPTUFQX01QVUlPX0tCRF9NQVNLSVQpOwoKCXRhc2tsZXRfc2NoZWR1bGUoJmtwX3Rhc2tsZXQpOwoKCXJldHVybiBJUlFfSEFORExFRDsKfQoKc3RhdGljIHZvaWQgb21hcF9rcF90aW1lcih1bnNpZ25lZCBsb25nIGRhdGEpCnsKCXRhc2tsZXRfc2NoZWR1bGUoJmtwX3Rhc2tsZXQpOwp9CgpzdGF0aWMgdm9pZCBvbWFwX2twX3NjYW5fa2V5cGFkKHN0cnVjdCBvbWFwX2twICpvbWFwX2twLCB1bnNpZ25lZCBjaGFyICpzdGF0ZSkKewoJaW50IGNvbCA9IDA7CgoJLyogcmVhZCB0aGUga2V5cGFkIHN0YXR1cyAqLwoJaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJaW50IGk7CgkJZm9yIChpID0gMDsgaSA8IG9tYXBfa3AtPnJvd3M7IGkrKykKCQkJZGlzYWJsZV9pcnEoT01BUF9HUElPX0lSUShyb3dfZ3Bpb3NbaV0pKTsKCgkJLyogcmVhZCB0aGUga2V5cGFkIHN0YXR1cyAqLwoJCWZvciAoY29sID0gMDsgY29sIDwgb21hcF9rcC0+Y29sczsgY29sKyspIHsKCQkJc2V0X2NvbF9ncGlvX3ZhbChvbWFwX2twLCB+KDEgPDwgY29sKSk7CgkJCXN0YXRlW2NvbF0gPSB+KGdldF9yb3dfZ3Bpb192YWwob21hcF9rcCkpICYgMHgzZjsKCQl9CgkJc2V0X2NvbF9ncGlvX3ZhbChvbWFwX2twLCAwKTsKCgl9IGVsc2UgewoJCS8qIGRpc2FibGUga2V5Ym9hcmQgaW50ZXJydXB0IGFuZCBzY2hlZHVsZSBmb3IgaGFuZGxpbmcgKi8KCQlvbWFwX3dyaXRldygxLCBPTUFQX01QVUlPX0JBU0UgKyBPTUFQX01QVUlPX0tCRF9NQVNLSVQpOwoKCQkvKiByZWFkIHRoZSBrZXlwYWQgc3RhdHVzICovCgkJb21hcF93cml0ZXcoMHhmZiwgT01BUF9NUFVJT19CQVNFICsgT01BUF9NUFVJT19LQkMpOwoJCWZvciAoY29sID0gMDsgY29sIDwgb21hcF9rcC0+Y29sczsgY29sKyspIHsKCQkJb21hcF93cml0ZXcofigxIDw8IGNvbCkgJiAweGZmLAoJCQkJICAgIE9NQVBfTVBVSU9fQkFTRSArIE9NQVBfTVBVSU9fS0JDKTsKCgkJCXVkZWxheShvbWFwX2twLT5kZWxheSk7CgoJCQlzdGF0ZVtjb2xdID0gfm9tYXBfcmVhZHcoT01BUF9NUFVJT19CQVNFICsKCQkJCQkJIE9NQVBfTVBVSU9fS0JSX0xBVENIKSAmIDB4ZmY7CgkJfQoJCW9tYXBfd3JpdGV3KDB4MDAsIE9NQVBfTVBVSU9fQkFTRSArIE9NQVBfTVBVSU9fS0JDKTsKCQl1ZGVsYXkoMik7Cgl9Cn0KCnN0YXRpYyBpbmxpbmUgaW50IG9tYXBfa3BfZmluZF9rZXkoaW50IGNvbCwgaW50IHJvdykKewoJaW50IGksIGtleTsKCglrZXkgPSBLRVkoY29sLCByb3csIDApOwoJZm9yIChpID0gMDsga2V5bWFwW2ldICE9IDA7IGkrKykKCQlpZiAoKGtleW1hcFtpXSAmIDB4ZmYwMDAwMDApID09IGtleSkKCQkJcmV0dXJuIGtleW1hcFtpXSAmIDB4MDBmZmZmZmY7CglyZXR1cm4gLTE7Cn0KCnN0YXRpYyB2b2lkIG9tYXBfa3BfdGFza2xldCh1bnNpZ25lZCBsb25nIGRhdGEpCnsKCXN0cnVjdCBvbWFwX2twICpvbWFwX2twX2RhdGEgPSAoc3RydWN0IG9tYXBfa3AgKikgZGF0YTsKCXVuc2lnbmVkIGNoYXIgbmV3X3N0YXRlWzhdLCBjaGFuZ2VkLCBrZXlfZG93biA9IDA7CglpbnQgY29sLCByb3c7CglpbnQgc3B1cmlvdXMgPSAwOwoKCS8qIGNoZWNrIGZvciBhbnkgY2hhbmdlcyAqLwoJb21hcF9rcF9zY2FuX2tleXBhZChvbWFwX2twX2RhdGEsIG5ld19zdGF0ZSk7CgoJLyogY2hlY2sgZm9yIGNoYW5nZXMgYW5kIHByaW50IHRob3NlICovCglmb3IgKGNvbCA9IDA7IGNvbCA8IG9tYXBfa3BfZGF0YS0+Y29sczsgY29sKyspIHsKCQljaGFuZ2VkID0gbmV3X3N0YXRlW2NvbF0gXiBrZXlwYWRfc3RhdGVbY29sXTsKCQlrZXlfZG93biB8PSBuZXdfc3RhdGVbY29sXTsKCQlpZiAoY2hhbmdlZCA9PSAwKQoJCQljb250aW51ZTsKCgkJZm9yIChyb3cgPSAwOyByb3cgPCBvbWFwX2twX2RhdGEtPnJvd3M7IHJvdysrKSB7CgkJCWludCBrZXk7CgkJCWlmICghKGNoYW5nZWQgJiAoMSA8PCByb3cpKSkKCQkJCWNvbnRpbnVlOwojaWZkZWYgTkVXX0JPQVJEX0xFQVJOSU5HX01PREUKCQkJcHJpbnRrKEtFUk5fSU5GTyAib21hcC1rZXlwYWQ6IGtleSAlZC0lZCAlc1xuIiwgY29sLAoJCQkgICAgICAgcm93LCAobmV3X3N0YXRlW2NvbF0gJiAoMSA8PCByb3cpKSA/CgkJCSAgICAgICAicHJlc3NlZCIgOiAicmVsZWFzZWQiKTsKI2Vsc2UKCQkJa2V5ID0gb21hcF9rcF9maW5kX2tleShjb2wsIHJvdyk7CgkJCWlmIChrZXkgPCAwKSB7CgkJCQlwcmludGsoS0VSTl9XQVJOSU5HCgkJCQkgICAgICAib21hcC1rZXlwYWQ6IFNwdXJpb3VzIGtleSBldmVudCAlZC0lZFxuIiwKCQkJCSAgICAgICBjb2wsIHJvdyk7CgkJCQkvKiBXZSBzY2FuIGFnYWluIGFmdGVyIGEgY291cGxlIG9mIHNlY29uZHMgKi8KCQkJCXNwdXJpb3VzID0gMTsKCQkJCWNvbnRpbnVlOwoJCQl9CgoJCQlpZiAoIShrcF9jdXJfZ3JvdXAgPT0gKGtleSAmIEdST1VQX01BU0spIHx8CgkJCSAgICAgIGtwX2N1cl9ncm91cCA9PSAtMSkpCgkJCQljb250aW51ZTsKCgkJCWtwX2N1cl9ncm91cCA9IGtleSAmIEdST1VQX01BU0s7CgkJCWlucHV0X3JlcG9ydF9rZXkob21hcF9rcF9kYXRhLT5pbnB1dCwga2V5ICYgfkdST1VQX01BU0ssCgkJCQkJIG5ld19zdGF0ZVtjb2xdICYgKDEgPDwgcm93KSk7CiNlbmRpZgoJCX0KCX0KCW1lbWNweShrZXlwYWRfc3RhdGUsIG5ld19zdGF0ZSwgc2l6ZW9mKGtleXBhZF9zdGF0ZSkpOwoKCWlmIChrZXlfZG93bikgewogICAgICAgICAgICAgICAgaW50IGRlbGF5ID0gSFogLyAyMDsKCQkvKiBzb21lIGtleSBpcyBwcmVzc2VkIC0ga2VlcCBpcnEgZGlzYWJsZWQgYW5kIHVzZSB0aW1lcgoJCSAqIHRvIHBvbGwgdGhlIGtleXBhZCAqLwoJCWlmIChzcHVyaW91cykKCQkJZGVsYXkgPSAyICogSFo7CgkJbW9kX3RpbWVyKCZvbWFwX2twX2RhdGEtPnRpbWVyLCBqaWZmaWVzICsgZGVsYXkpOwoJfSBlbHNlIHsKCQkvKiBlbmFibGUgaW50ZXJydXB0cyAqLwoJCWlmIChjcHVfaXNfb21hcDI0eHgoKSkgewoJCQlpbnQgaTsKCQkJZm9yIChpID0gMDsgaSA8IG9tYXBfa3BfZGF0YS0+cm93czsgaSsrKQoJCQkJZW5hYmxlX2lycShPTUFQX0dQSU9fSVJRKHJvd19ncGlvc1tpXSkpOwoJCX0gZWxzZSB7CgkJCW9tYXBfd3JpdGV3KDAsIE9NQVBfTVBVSU9fQkFTRSArIE9NQVBfTVBVSU9fS0JEX01BU0tJVCk7CgkJCWtwX2N1cl9ncm91cCA9IC0xOwoJCX0KCX0KfQoKc3RhdGljIHNzaXplX3Qgb21hcF9rcF9lbmFibGVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCgkJCQkgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwga3BfZW5hYmxlKTsKfQoKc3RhdGljIHNzaXplX3Qgb21hcF9rcF9lbmFibGVfc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKCQkJCSAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKewoJaW50IHN0YXRlOwoKCWlmIChzc2NhbmYoYnVmLCAiJXUiLCAmc3RhdGUpICE9IDEpCgkJcmV0dXJuIC1FSU5WQUw7CgoJaWYgKChzdGF0ZSAhPSAxKSAmJiAoc3RhdGUgIT0gMCkpCgkJcmV0dXJuIC1FSU5WQUw7CgoJbXV0ZXhfbG9jaygma3BfZW5hYmxlX211dGV4KTsKCWlmIChzdGF0ZSAhPSBrcF9lbmFibGUpIHsKCQlpZiAoc3RhdGUpCgkJCWVuYWJsZV9pcnEoSU5UX0tFWUJPQVJEKTsKCQllbHNlCgkJCWRpc2FibGVfaXJxKElOVF9LRVlCT0FSRCk7CgkJa3BfZW5hYmxlID0gc3RhdGU7Cgl9CgltdXRleF91bmxvY2soJmtwX2VuYWJsZV9tdXRleCk7CgoJcmV0dXJuIHN0cm5sZW4oYnVmLCBjb3VudCk7Cn0KCnN0YXRpYyBERVZJQ0VfQVRUUihlbmFibGUsIFNfSVJVR08gfCBTX0lXVVNSLCBvbWFwX2twX2VuYWJsZV9zaG93LCBvbWFwX2twX2VuYWJsZV9zdG9yZSk7CgojaWZkZWYgQ09ORklHX1BNCnN0YXRpYyBpbnQgb21hcF9rcF9zdXNwZW5kKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldiwgcG1fbWVzc2FnZV90IHN0YXRlKQp7CgkvKiBOb3RoaW5nIHlldCAqLwoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IG9tYXBfa3BfcmVzdW1lKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldikKewoJLyogTm90aGluZyB5ZXQgKi8KCglyZXR1cm4gMDsKfQojZWxzZQojZGVmaW5lIG9tYXBfa3Bfc3VzcGVuZAlOVUxMCiNkZWZpbmUgb21hcF9rcF9yZXN1bWUJTlVMTAojZW5kaWYKCnN0YXRpYyBpbnQgX19pbml0IG9tYXBfa3BfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKewoJc3RydWN0IG9tYXBfa3AgKm9tYXBfa3A7CglzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dF9kZXY7CglzdHJ1Y3Qgb21hcF9rcF9wbGF0Zm9ybV9kYXRhICpwZGF0YSA9ICBwZGV2LT5kZXYucGxhdGZvcm1fZGF0YTsKCWludCBpLCBjb2xfaWR4LCByb3dfaWR4LCBpcnFfaWR4LCByZXQ7CgoJaWYgKCFwZGF0YS0+cm93cyB8fCAhcGRhdGEtPmNvbHMgfHwgIXBkYXRhLT5rZXltYXApIHsKCQlwcmludGsoS0VSTl9FUlIgIk5vIHJvd3MsIGNvbHMgb3Iga2V5bWFwIGZyb20gcGRhdGFcbiIpOwoJCXJldHVybiAtRUlOVkFMOwoJfQoKCW9tYXBfa3AgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgb21hcF9rcCksIEdGUF9LRVJORUwpOwoJaW5wdXRfZGV2ID0gaW5wdXRfYWxsb2NhdGVfZGV2aWNlKCk7CglpZiAoIW9tYXBfa3AgfHwgIWlucHV0X2RldikgewoJCWtmcmVlKG9tYXBfa3ApOwoJCWlucHV0X2ZyZWVfZGV2aWNlKGlucHV0X2Rldik7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgb21hcF9rcCk7CgoJb21hcF9rcC0+aW5wdXQgPSBpbnB1dF9kZXY7CgoJLyogRGlzYWJsZSB0aGUgaW50ZXJydXB0IGZvciB0aGUgTVBVSU8ga2V5Ym9hcmQgKi8KCWlmICghY3B1X2lzX29tYXAyNHh4KCkpCgkJb21hcF93cml0ZXcoMSwgT01BUF9NUFVJT19CQVNFICsgT01BUF9NUFVJT19LQkRfTUFTS0lUKTsKCglrZXltYXAgPSBwZGF0YS0+a2V5bWFwOwoKCWlmIChwZGF0YS0+cmVwKQoJCV9fc2V0X2JpdChFVl9SRVAsIGlucHV0X2Rldi0+ZXZiaXQpOwoKCWlmIChwZGF0YS0+ZGVsYXkpCgkJb21hcF9rcC0+ZGVsYXkgPSBwZGF0YS0+ZGVsYXk7CgoJaWYgKHBkYXRhLT5yb3dfZ3Bpb3MgJiYgcGRhdGEtPmNvbF9ncGlvcykgewoJCXJvd19ncGlvcyA9IHBkYXRhLT5yb3dfZ3Bpb3M7CgkJY29sX2dwaW9zID0gcGRhdGEtPmNvbF9ncGlvczsKCX0KCglvbWFwX2twLT5yb3dzID0gcGRhdGEtPnJvd3M7CglvbWFwX2twLT5jb2xzID0gcGRhdGEtPmNvbHM7CgoJaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJLyogQ29sczogb3V0cHV0cyAqLwoJCWZvciAoY29sX2lkeCA9IDA7IGNvbF9pZHggPCBvbWFwX2twLT5jb2xzOyBjb2xfaWR4KyspIHsKCQkJaWYgKG9tYXBfcmVxdWVzdF9ncGlvKGNvbF9ncGlvc1tjb2xfaWR4XSkgPCAwKSB7CgkJCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byByZXF1ZXN0IgoJCQkJICAgICAgICJHUElPJWQgZm9yIGtleXBhZFxuIiwKCQkJCSAgICAgICBjb2xfZ3Bpb3NbY29sX2lkeF0pOwoJCQkJZ290byBlcnIxOwoJCQl9CgkJCW9tYXBfc2V0X2dwaW9fZGlyZWN0aW9uKGNvbF9ncGlvc1tjb2xfaWR4XSwgMCk7CgkJfQoJCS8qIFJvd3M6IGlucHV0cyAqLwoJCWZvciAocm93X2lkeCA9IDA7IHJvd19pZHggPCBvbWFwX2twLT5yb3dzOyByb3dfaWR4KyspIHsKCQkJaWYgKG9tYXBfcmVxdWVzdF9ncGlvKHJvd19ncGlvc1tyb3dfaWR4XSkgPCAwKSB7CgkJCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byByZXF1ZXN0IgoJCQkJICAgICAgICJHUElPJWQgZm9yIGtleXBhZFxuIiwKCQkJCSAgICAgICByb3dfZ3Bpb3Nbcm93X2lkeF0pOwoJCQkJZ290byBlcnIyOwoJCQl9CgkJCW9tYXBfc2V0X2dwaW9fZGlyZWN0aW9uKHJvd19ncGlvc1tyb3dfaWR4XSwgMSk7CgkJfQoJfQoKCXNldHVwX3RpbWVyKCZvbWFwX2twLT50aW1lciwgb21hcF9rcF90aW1lciwgKHVuc2lnbmVkIGxvbmcpb21hcF9rcCk7CgoJLyogZ2V0IHRoZSBpcnEgYW5kIGluaXQgdGltZXIqLwoJdGFza2xldF9lbmFibGUoJmtwX3Rhc2tsZXQpOwoJa3BfdGFza2xldC5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIG9tYXBfa3A7CgoJcmV0ID0gZGV2aWNlX2NyZWF0ZV9maWxlKCZwZGV2LT5kZXYsICZkZXZfYXR0cl9lbmFibGUpOwoJaWYgKHJldCA8IDApCgkJZ290byBlcnIyOwoKCS8qIHNldHVwIGlucHV0IGRldmljZSAqLwoJX19zZXRfYml0KEVWX0tFWSwgaW5wdXRfZGV2LT5ldmJpdCk7Cglmb3IgKGkgPSAwOyBrZXltYXBbaV0gIT0gMDsgaSsrKQoJCV9fc2V0X2JpdChrZXltYXBbaV0gJiBLRVlfTUFYLCBpbnB1dF9kZXYtPmtleWJpdCk7CglpbnB1dF9kZXYtPm5hbWUgPSAib21hcC1rZXlwYWQiOwoJaW5wdXRfZGV2LT5waHlzID0gIm9tYXAta2V5cGFkL2lucHV0MCI7CglpbnB1dF9kZXYtPmRldi5wYXJlbnQgPSAmcGRldi0+ZGV2OwoKCWlucHV0X2Rldi0+aWQuYnVzdHlwZSA9IEJVU19IT1NUOwoJaW5wdXRfZGV2LT5pZC52ZW5kb3IgPSAweDAwMDE7CglpbnB1dF9kZXYtPmlkLnByb2R1Y3QgPSAweDAwMDE7CglpbnB1dF9kZXYtPmlkLnZlcnNpb24gPSAweDAxMDA7CgoJcmV0ID0gaW5wdXRfcmVnaXN0ZXJfZGV2aWNlKG9tYXBfa3AtPmlucHV0KTsKCWlmIChyZXQgPCAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJVbmFibGUgdG8gcmVnaXN0ZXIgb21hcC1rZXlwYWQgaW5wdXQgZGV2aWNlXG4iKTsKCQlnb3RvIGVycjM7Cgl9CgoJaWYgKHBkYXRhLT5kYm91bmNlKQoJCW9tYXBfd3JpdGV3KDB4ZmYsIE9NQVBfTVBVSU9fQkFTRSArIE9NQVBfTVBVSU9fR1BJT19ERUJPVU5DSU5HKTsKCgkvKiBzY2FuIGN1cnJlbnQgc3RhdHVzIGFuZCBlbmFibGUgaW50ZXJydXB0ICovCglvbWFwX2twX3NjYW5fa2V5cGFkKG9tYXBfa3AsIGtleXBhZF9zdGF0ZSk7CglpZiAoIWNwdV9pc19vbWFwMjR4eCgpKSB7CgkJb21hcF9rcC0+aXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsKCQlpZiAob21hcF9rcC0+aXJxID49IDApIHsKCQkJaWYgKHJlcXVlc3RfaXJxKG9tYXBfa3AtPmlycSwgb21hcF9rcF9pbnRlcnJ1cHQsIDAsCgkJCQkJIm9tYXAta2V5cGFkIiwgb21hcF9rcCkgPCAwKQoJCQkJZ290byBlcnI0OwoJCX0KCQlvbWFwX3dyaXRldygwLCBPTUFQX01QVUlPX0JBU0UgKyBPTUFQX01QVUlPX0tCRF9NQVNLSVQpOwoJfSBlbHNlIHsKCQlmb3IgKGlycV9pZHggPSAwOyBpcnFfaWR4IDwgb21hcF9rcC0+cm93czsgaXJxX2lkeCsrKSB7CgkJCWlmIChyZXF1ZXN0X2lycShPTUFQX0dQSU9fSVJRKHJvd19ncGlvc1tpcnFfaWR4XSksCgkJCQkJb21hcF9rcF9pbnRlcnJ1cHQsCgkJCQkJSVJRRl9UUklHR0VSX0ZBTExJTkcsCgkJCQkJIm9tYXAta2V5cGFkIiwgb21hcF9rcCkgPCAwKQoJCQkJZ290byBlcnI1OwoJCX0KCX0KCXJldHVybiAwOwplcnI1OgoJZm9yIChpID0gaXJxX2lkeCAtIDE7IGkgPj0wOyBpLS0pCgkJZnJlZV9pcnEocm93X2dwaW9zW2ldLCAwKTsKZXJyNDoKCWlucHV0X3VucmVnaXN0ZXJfZGV2aWNlKG9tYXBfa3AtPmlucHV0KTsKCWlucHV0X2RldiA9IE5VTEw7CmVycjM6CglkZXZpY2VfcmVtb3ZlX2ZpbGUoJnBkZXYtPmRldiwgJmRldl9hdHRyX2VuYWJsZSk7CmVycjI6Cglmb3IgKGkgPSByb3dfaWR4LTE7IGkgPj0wOyBpLS0pCgkJb21hcF9mcmVlX2dwaW8ocm93X2dwaW9zW2ldKTsKZXJyMToKCWZvciAoaSA9IGNvbF9pZHgtMTsgaSA+PTA7IGktLSkKCQlvbWFwX2ZyZWVfZ3Bpbyhjb2xfZ3Bpb3NbaV0pOwoKCWtmcmVlKG9tYXBfa3ApOwoJaW5wdXRfZnJlZV9kZXZpY2UoaW5wdXRfZGV2KTsKCglyZXR1cm4gLUVJTlZBTDsKfQoKc3RhdGljIGludCBvbWFwX2twX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQp7CglzdHJ1Y3Qgb21hcF9rcCAqb21hcF9rcCA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwoKCS8qIGRpc2FibGUga2V5cGFkIGludGVycnVwdCBoYW5kbGluZyAqLwoJdGFza2xldF9kaXNhYmxlKCZrcF90YXNrbGV0KTsKCWlmIChjcHVfaXNfb21hcDI0eHgoKSkgewoJCWludCBpOwoJCWZvciAoaSA9IDA7IGkgPCBvbWFwX2twLT5jb2xzOyBpKyspCgkJCW9tYXBfZnJlZV9ncGlvKGNvbF9ncGlvc1tpXSk7CgkJZm9yIChpID0gMDsgaSA8IG9tYXBfa3AtPnJvd3M7IGkrKykgewoJCQlvbWFwX2ZyZWVfZ3Bpbyhyb3dfZ3Bpb3NbaV0pOwoJCQlmcmVlX2lycShPTUFQX0dQSU9fSVJRKHJvd19ncGlvc1tpXSksIDApOwoJCX0KCX0gZWxzZSB7CgkJb21hcF93cml0ZXcoMSwgT01BUF9NUFVJT19CQVNFICsgT01BUF9NUFVJT19LQkRfTUFTS0lUKTsKCQlmcmVlX2lycShvbWFwX2twLT5pcnEsIDApOwoJfQoKCWRlbF90aW1lcl9zeW5jKCZvbWFwX2twLT50aW1lcik7Cgl0YXNrbGV0X2tpbGwoJmtwX3Rhc2tsZXQpOwoKCS8qIHVucmVnaXN0ZXIgZXZlcnl0aGluZyAqLwoJaW5wdXRfdW5yZWdpc3Rlcl9kZXZpY2Uob21hcF9rcC0+aW5wdXQpOwoKCWtmcmVlKG9tYXBfa3ApOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBvbWFwX2twX2RyaXZlciA9IHsKCS5wcm9iZQkJPSBvbWFwX2twX3Byb2JlLAoJLnJlbW92ZQkJPSBvbWFwX2twX3JlbW92ZSwKCS5zdXNwZW5kCT0gb21hcF9rcF9zdXNwZW5kLAoJLnJlc3VtZQkJPSBvbWFwX2twX3Jlc3VtZSwKCS5kcml2ZXIJCT0gewoJCS5uYW1lCT0gIm9tYXAta2V5cGFkIiwKCX0sCn07CgpzdGF0aWMgaW50IF9fZGV2aW5pdCBvbWFwX2twX2luaXQodm9pZCkKewoJcHJpbnRrKEtFUk5fSU5GTyAiT01BUCBLZXlwYWQgRHJpdmVyXG4iKTsKCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJm9tYXBfa3BfZHJpdmVyKTsKfQoKc3RhdGljIHZvaWQgX19leGl0IG9tYXBfa3BfZXhpdCh2b2lkKQp7CglwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3Rlcigmb21hcF9rcF9kcml2ZXIpOwp9Cgptb2R1bGVfaW5pdChvbWFwX2twX2luaXQpOwptb2R1bGVfZXhpdChvbWFwX2twX2V4aXQpOwoKTU9EVUxFX0FVVEhPUigiVGltbyBUZXLkcyIpOwpNT0RVTEVfREVTQ1JJUFRJT04oIk9NQVAgS2V5cGFkIERyaXZlciIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7Cg==