LyoKICogQ1RDIC8gRVNDT04gbmV0d29yayBkcml2ZXIKICoKICogQ29weXJpZ2h0IChDKSAyMDAxIElCTSBEZXV0c2NobGFuZCBFbnR3aWNrbHVuZyBHbWJILCBJQk0gQ29ycG9yYXRpb24KICogQXV0aG9yKHMpOiBGcml0eiBFbGZlcnQgKGVsZmVydEBkZS5pYm0uY29tLCBmZWxmZXJ0QG1pbGxlbnV4LmNvbSkKICogRml4ZXMgYnkgOiBKb2NoZW4gUvZocmlnIChyb2VocmlnQGRlLmlibS5jb20pCiAqICAgICAgICAgICAgQXJuYWxkbyBDYXJ2YWxobyBkZSBNZWxvIDxhY21lQGNvbmVjdGl2YS5jb20uYnI+CgkgICAgICBQZXRlciBUaWVkZW1hbm4gKHB0aWVkZW1AZGUuaWJtLmNvbSkKICogRHJpdmVyIE1vZGVsIHN0dWZmIGJ5IDogQ29ybmVsaWEgSHVjayA8Y29ybmVsaWEuaHVja0BkZS5pYm0uY29tPgogKgogKiBEb2N1bWVudGF0aW9uIHVzZWQ6CiAqICAtIFByaW5jaXBsZXMgb2YgT3BlcmF0aW9uIChJQk0gZG9jIzogU0EyMi03MjAxLTA2KQogKiAgLSBDb21tb24gSU8vLURldmljZSBDb21tYW5kcyBhbmQgU2VsZiBEZXNjcmlwdGlvbiAoSUJNIGRvYyM6IFNBMjItNzIwNC0wMikKICogIC0gQ29tbW9uIElPLy1EZXZpY2UgQ29tbWFuZHMgYW5kIFNlbGYgRGVzY3JpcHRpb24gKElCTSBkb2MjOiBTTjIyLTU1MzUpCiAqICAtIEVTQ09OIENoYW5uZWwtdG8tQ2hhbm5lbCBBZGFwdGVyIChJQk0gZG9jIzogU0EyMi03MjAzLTAwKQogKiAgLSBFU0NPTiBJL08gSW50ZXJmYWNlIChJQk0gZG9jIzogU0EyMi03MjAyLTAyOQogKgogKiBhbmQgdGhlIHNvdXJjZSBvZiB0aGUgb3JpZ2luYWwgQ1RDIGRyaXZlciBieToKICogIERpZXRlciBXZWxsZXJkaWVrICh3ZWxAZGUuaWJtLmNvbSkKICogIE1hcnRpbiBTY2h3aWRlZnNreSAoc2Nod2lkZWZza3lAZGUuaWJtLmNvbSkKICogIERlbmlzIEpvc2VwaCBCYXJyb3cgKGRqYmFycm93QGRlLmlibS5jb20sYmFycm93X2RqQHlhaG9vLmNvbSkKICogIEpvY2hlbiBS9mhyaWcgKHJvZWhyaWdAZGUuaWJtLmNvbSkKICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQogKiBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNjc1IE1hc3MgQXZlLCBDYW1icmlkZ2UsIE1BIDAyMTM5LCBVU0EuCiAqCiAqLwojdW5kZWYgREVCVUcKI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgojaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvdGltZXIuaD4KI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgoKI2luY2x1ZGUgPGxpbnV4L3NpZ25hbC5oPgojaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CgojaW5jbHVkZSA8bGludXgvaXAuaD4KI2luY2x1ZGUgPGxpbnV4L2lmX2FycC5oPgojaW5jbHVkZSA8bGludXgvdGNwLmg+CiNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CiNpbmNsdWRlIDxuZXQvZHN0Lmg+CgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxhc20vY2N3ZGV2Lmg+CiNpbmNsdWRlIDxhc20vY2N3Z3JvdXAuaD4KI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CgojaW5jbHVkZSA8YXNtL2lkYWxzLmg+CgojaW5jbHVkZSAiZnNtLmgiCiNpbmNsdWRlICJjdTMwODguaCIKCiNpbmNsdWRlICJjdGNkYnVnLmgiCiNpbmNsdWRlICJjdGNtYWluLmgiCgpNT0RVTEVfQVVUSE9SKCIoQykgMjAwMCBJQk0gQ29ycC4gYnkgRnJpdHogRWxmZXJ0IChmZWxmZXJ0QG1pbGxlbnV4LmNvbSkiKTsKTU9EVUxFX0RFU0NSSVBUSU9OKCJMaW51eCBmb3IgUy8zOTAgQ1RDL0VzY29uIERyaXZlciIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7Ci8qKgogKiBTdGF0ZXMgb2YgdGhlIGludGVyZmFjZSBzdGF0ZW1hY2hpbmUuCiAqLwplbnVtIGRldl9zdGF0ZXMgewoJREVWX1NUQVRFX1NUT1BQRUQsCglERVZfU1RBVEVfU1RBUlRXQUlUX1JYVFgsCglERVZfU1RBVEVfU1RBUlRXQUlUX1JYLAoJREVWX1NUQVRFX1NUQVJUV0FJVF9UWCwKCURFVl9TVEFURV9TVE9QV0FJVF9SWFRYLAoJREVWX1NUQVRFX1NUT1BXQUlUX1JYLAoJREVWX1NUQVRFX1NUT1BXQUlUX1RYLAoJREVWX1NUQVRFX1JVTk5JTkcsCgkvKioKCSAqIE1VU1QgYmUgYWx3YXlzIHRoZSBsYXN0IGVsZW1lbnQhIQoJICovCglDVENfTlJfREVWX1NUQVRFUwp9OwoKc3RhdGljIGNvbnN0IGNoYXIgKmRldl9zdGF0ZV9uYW1lc1tdID0gewoJIlN0b3BwZWQiLAoJIlN0YXJ0V2FpdCBSWFRYIiwKCSJTdGFydFdhaXQgUlgiLAoJIlN0YXJ0V2FpdCBUWCIsCgkiU3RvcFdhaXQgUlhUWCIsCgkiU3RvcFdhaXQgUlgiLAoJIlN0b3BXYWl0IFRYIiwKCSJSdW5uaW5nIiwKfTsKCi8qKgogKiBFdmVudHMgb2YgdGhlIGludGVyZmFjZSBzdGF0ZW1hY2hpbmUuCiAqLwplbnVtIGRldl9ldmVudHMgewoJREVWX0VWRU5UX1NUQVJULAoJREVWX0VWRU5UX1NUT1AsCglERVZfRVZFTlRfUlhVUCwKCURFVl9FVkVOVF9UWFVQLAoJREVWX0VWRU5UX1JYRE9XTiwKCURFVl9FVkVOVF9UWERPV04sCglERVZfRVZFTlRfUkVTVEFSVCwKCS8qKgoJICogTVVTVCBiZSBhbHdheXMgdGhlIGxhc3QgZWxlbWVudCEhCgkgKi8KCUNUQ19OUl9ERVZfRVZFTlRTCn07CgpzdGF0aWMgY29uc3QgY2hhciAqZGV2X2V2ZW50X25hbWVzW10gPSB7CgkiU3RhcnQiLAoJIlN0b3AiLAoJIlJYIHVwIiwKCSJUWCB1cCIsCgkiUlggZG93biIsCgkiVFggZG93biIsCgkiUmVzdGFydCIsCn07CgovKioKICogRXZlbnRzIG9mIHRoZSBjaGFubmVsIHN0YXRlbWFjaGluZQogKi8KZW51bSBjaF9ldmVudHMgewoJLyoqCgkgKiBFdmVudHMsIHJlcHJlc2VudGluZyByZXR1cm4gY29kZSBvZgoJICogSS9PIG9wZXJhdGlvbnMgKGNjd19kZXZpY2Vfc3RhcnQsIGNjd19kZXZpY2VfaGFsdCBldCBhbC4pCgkgKi8KCUNIX0VWRU5UX0lPX1NVQ0NFU1MsCglDSF9FVkVOVF9JT19FQlVTWSwKCUNIX0VWRU5UX0lPX0VOT0RFViwKCUNIX0VWRU5UX0lPX0VJTywKCUNIX0VWRU5UX0lPX1VOS05PV04sCgoJQ0hfRVZFTlRfQVRUTkJVU1ksCglDSF9FVkVOVF9BVFROLAoJQ0hfRVZFTlRfQlVTWSwKCgkvKioKCSAqIEV2ZW50cywgcmVwcmVzZW50aW5nIHVuaXQtY2hlY2sKCSAqLwoJQ0hfRVZFTlRfVUNfUkNSRVNFVCwKCUNIX0VWRU5UX1VDX1JTUkVTRVQsCglDSF9FVkVOVF9VQ19UWFRJTUVPVVQsCglDSF9FVkVOVF9VQ19UWFBBUklUWSwKCUNIX0VWRU5UX1VDX0hXRkFJTCwKCUNIX0VWRU5UX1VDX1JYUEFSSVRZLAoJQ0hfRVZFTlRfVUNfWkVSTywKCUNIX0VWRU5UX1VDX1VOS05PV04sCgoJLyoqCgkgKiBFdmVudHMsIHJlcHJlc2VudGluZyBzdWJjaGFubmVsLWNoZWNrCgkgKi8KCUNIX0VWRU5UX1NDX1VOS05PV04sCgoJLyoqCgkgKiBFdmVudHMsIHJlcHJlc2VudGluZyBtYWNoaW5lIGNoZWNrcwoJICovCglDSF9FVkVOVF9NQ19GQUlMLAoJQ0hfRVZFTlRfTUNfR09PRCwKCgkvKioKCSAqIEV2ZW50LCByZXByZXNlbnRpbmcgbm9ybWFsIElSUQoJICovCglDSF9FVkVOVF9JUlEsCglDSF9FVkVOVF9GSU5TVEFULAoKCS8qKgoJICogRXZlbnQsIHJlcHJlc2VudGluZyB0aW1lciBleHBpcnkuCgkgKi8KCUNIX0VWRU5UX1RJTUVSLAoKCS8qKgoJICogRXZlbnRzLCByZXByZXNlbnRpbmcgY29tbWFuZHMgZnJvbSB1cHBlciBsZXZlbHMuCgkgKi8KCUNIX0VWRU5UX1NUQVJULAoJQ0hfRVZFTlRfU1RPUCwKCgkvKioKCSAqIE1VU1QgYmUgYWx3YXlzIHRoZSBsYXN0IGVsZW1lbnQhIQoJICovCglOUl9DSF9FVkVOVFMsCn07CgovKioKICogU3RhdGVzIG9mIHRoZSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICovCmVudW0gY2hfc3RhdGVzIHsKCS8qKgoJICogQ2hhbm5lbCBub3QgYXNzaWduZWQgdG8gYW55IGRldmljZSwKCSAqIGluaXRpYWwgc3RhdGUsIGRpcmVjdGlvbiBpbnZhbGlkCgkgKi8KCUNIX1NUQVRFX0lETEUsCgoJLyoqCgkgKiBDaGFubmVsIGFzc2lnbmVkIGJ1dCBub3Qgb3BlcmF0aW5nCgkgKi8KCUNIX1NUQVRFX1NUT1BQRUQsCglDSF9TVEFURV9TVEFSVFdBSVQsCglDSF9TVEFURV9TVEFSVFJFVFJZLAoJQ0hfU1RBVEVfU0VUVVBXQUlULAoJQ0hfU1RBVEVfUlhJTklULAoJQ0hfU1RBVEVfVFhJTklULAoJQ0hfU1RBVEVfUlgsCglDSF9TVEFURV9UWCwKCUNIX1NUQVRFX1JYSURMRSwKCUNIX1NUQVRFX1RYSURMRSwKCUNIX1NUQVRFX1JYRVJSLAoJQ0hfU1RBVEVfVFhFUlIsCglDSF9TVEFURV9URVJNLAoJQ0hfU1RBVEVfRFRFUk0sCglDSF9TVEFURV9OT1RPUCwKCgkvKioKCSAqIE1VU1QgYmUgYWx3YXlzIHRoZSBsYXN0IGVsZW1lbnQhIQoJICovCglOUl9DSF9TVEFURVMsCn07CgpzdGF0aWMgaW50IGxvZ2xldmVsID0gQ1RDX0xPR0xFVkVMX0RFRkFVTFQ7CgovKioKICogTGlua2VkIGxpc3Qgb2YgYWxsIGRldGVjdGVkIGNoYW5uZWxzLgogKi8Kc3RhdGljIHN0cnVjdCBjaGFubmVsICpjaGFubmVscyA9IE5VTEw7CgovKioKICogUHJpbnQgQmFubmVyLgogKi8Kc3RhdGljIHZvaWQKcHJpbnRfYmFubmVyKHZvaWQpCnsKCXN0YXRpYyBpbnQgcHJpbnRlZCA9IDA7CgoJaWYgKHByaW50ZWQpCgkJcmV0dXJuOwoKCXByaW50ayhLRVJOX0lORk8gIkNUQyBkcml2ZXIgaW5pdGlhbGl6ZWRcbiIpOwoJcHJpbnRlZCA9IDE7Cn0KCi8qKgogKiBSZXR1cm4gdHlwZSBvZiBhIGRldGVjdGVkIGRldmljZS4KICovCnN0YXRpYyBlbnVtIGNoYW5uZWxfdHlwZXMKZ2V0X2NoYW5uZWxfdHlwZShzdHJ1Y3QgY2N3X2RldmljZV9pZCAqaWQpCnsKCWVudW0gY2hhbm5lbF90eXBlcyB0eXBlID0gKGVudW0gY2hhbm5lbF90eXBlcykgaWQtPmRyaXZlcl9pbmZvOwoKCWlmICh0eXBlID09IGNoYW5uZWxfdHlwZV9maWNvbikKCQl0eXBlID0gY2hhbm5lbF90eXBlX2VzY29uOwoKCXJldHVybiB0eXBlOwp9CgpzdGF0aWMgY29uc3QgY2hhciAqY2hfZXZlbnRfbmFtZXNbXSA9IHsKCSJjY3dfZGV2aWNlIHN1Y2Nlc3MiLAoJImNjd19kZXZpY2UgYnVzeSIsCgkiY2N3X2RldmljZSBlbm9kZXYiLAoJImNjd19kZXZpY2UgaW9lcnIiLAoJImNjd19kZXZpY2UgdW5rbm93biIsCgoJIlN0YXR1cyBBVFROICYgQlVTWSIsCgkiU3RhdHVzIEFUVE4iLAoJIlN0YXR1cyBCVVNZIiwKCgkiVW5pdCBjaGVjayByZW1vdGUgcmVzZXQiLAoJIlVuaXQgY2hlY2sgcmVtb3RlIHN5c3RlbSByZXNldCIsCgkiVW5pdCBjaGVjayBUWCB0aW1lb3V0IiwKCSJVbml0IGNoZWNrIFRYIHBhcml0eSIsCgkiVW5pdCBjaGVjayBIYXJkd2FyZSBmYWlsdXJlIiwKCSJVbml0IGNoZWNrIFJYIHBhcml0eSIsCgkiVW5pdCBjaGVjayBaRVJPIiwKCSJVbml0IGNoZWNrIFVua25vd24iLAoKCSJTdWJDaGFubmVsIGNoZWNrIFVua25vd24iLAoKCSJNYWNoaW5lIGNoZWNrIGZhaWx1cmUiLAoJIk1hY2hpbmUgY2hlY2sgb3BlcmF0aW9uYWwiLAoKCSJJUlEgbm9ybWFsIiwKCSJJUlEgZmluYWwiLAoKCSJUaW1lciIsCgoJIlN0YXJ0IiwKCSJTdG9wIiwKfTsKCnN0YXRpYyBjb25zdCBjaGFyICpjaF9zdGF0ZV9uYW1lc1tdID0gewoJIklkbGUiLAoJIlN0b3BwZWQiLAoJIlN0YXJ0V2FpdCIsCgkiU3RhcnRSZXRyeSIsCgkiU2V0dXBXYWl0IiwKCSJSWCBpbml0IiwKCSJUWCBpbml0IiwKCSJSWCIsCgkiVFgiLAoJIlJYIGlkbGUiLAoJIlRYIGlkbGUiLAoJIlJYIGVycm9yIiwKCSJUWCBlcnJvciIsCgkiVGVybWluYXRpbmciLAoJIlJlc3RhcnRpbmciLAoJIk5vdCBvcGVyYXRpb25hbCIsCn07CgojaWZkZWYgREVCVUcKLyoqCiAqIER1bXAgaGVhZGVyIGFuZCBmaXJzdCAxNiBieXRlcyBvZiBhbiBza19idWZmIGZvciBkZWJ1Z2dpbmcgcHVycG9zZXMuCiAqCiAqIEBwYXJhbSBza2IgICAgVGhlIHNrX2J1ZmYgdG8gZHVtcC4KICogQHBhcmFtIG9mZnNldCBPZmZzZXQgcmVsYXRpdmUgdG8gc2tiLWRhdGEsIHdoZXJlIHRvIHN0YXJ0IHRoZSBkdW1wLgogKi8Kc3RhdGljIHZvaWQKY3RjX2R1bXBfc2tiKHN0cnVjdCBza19idWZmICpza2IsIGludCBvZmZzZXQpCnsKCXVuc2lnbmVkIGNoYXIgKnAgPSBza2ItPmRhdGE7CglfX3UxNiBibDsKCXN0cnVjdCBsbF9oZWFkZXIgKmhlYWRlcjsKCWludCBpOwoKCWlmICghKGxvZ2xldmVsICYgQ1RDX0xPR0xFVkVMX0RFQlVHKSkKCQlyZXR1cm47CglwICs9IG9mZnNldDsKCWJsID0gKigoX191MTYgKikgcCk7CglwICs9IDI7CgloZWFkZXIgPSAoc3RydWN0IGxsX2hlYWRlciAqKSBwOwoJcCAtPSAyOwoKCXByaW50ayhLRVJOX0RFQlVHICJkdW1wOlxuIik7CglwcmludGsoS0VSTl9ERUJVRyAiYmxvY2tsZW49JWQgJTA0eFxuIiwgYmwsIGJsKTsKCglwcmludGsoS0VSTl9ERUJVRyAiaC0+bGVuZ3RoPSVkICUwNHhcbiIsIGhlYWRlci0+bGVuZ3RoLAoJICAgICAgIGhlYWRlci0+bGVuZ3RoKTsKCXByaW50ayhLRVJOX0RFQlVHICJoLT50eXBlPSUwNHhcbiIsIGhlYWRlci0+dHlwZSk7CglwcmludGsoS0VSTl9ERUJVRyAiaC0+dW51c2VkPSUwNHhcbiIsIGhlYWRlci0+dW51c2VkKTsKCWlmIChibCA+IDE2KQoJCWJsID0gMTY7CglwcmludGsoS0VSTl9ERUJVRyAiZGF0YTogIik7Cglmb3IgKGkgPSAwOyBpIDwgYmw7IGkrKykKCQlwcmludGsoIiUwMnglcyIsICpwKyssIChpICUgMTYpID8gIiAiIDogIlxuPDc+Iik7CglwcmludGsoIlxuIik7Cn0KI2Vsc2UKc3RhdGljIGlubGluZSB2b2lkCmN0Y19kdW1wX3NrYihzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBpbnQgb2Zmc2V0KQp7Cn0KI2VuZGlmCgovKioKICogVW5wYWNrIGEganVzdCByZWNlaXZlZCBza2IgYW5kIGhhbmQgaXQgb3ZlciB0bwogKiB1cHBlciBsYXllcnMuCiAqCiAqIEBwYXJhbSBjaCBUaGUgY2hhbm5lbCB3aGVyZSB0aGlzIHNrYiBoYXMgYmVlbiByZWNlaXZlZC4KICogQHBhcmFtIHBza2IgVGhlIHJlY2VpdmVkIHNrYi4KICovCnN0YXRpYyB2b2lkCmN0Y191bnBhY2tfc2tiKHN0cnVjdCBjaGFubmVsICpjaCwgc3RydWN0IHNrX2J1ZmYgKnBza2IpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoJc3RydWN0IGN0Y19wcml2ICpwcml2cHRyID0gKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXY7CglfX3UxNiBsZW4gPSAqKChfX3UxNiAqKSBwc2tiLT5kYXRhKTsKCglEQkZfVEVYVCh0cmFjZSwgNCwgX19GVU5DVElPTl9fKTsKCXNrYl9wdXQocHNrYiwgMiArIExMX0hFQURFUl9MRU5HVEgpOwoJc2tiX3B1bGwocHNrYiwgMik7Cglwc2tiLT5kZXYgPSBkZXY7Cglwc2tiLT5pcF9zdW1tZWQgPSBDSEVDS1NVTV9VTk5FQ0VTU0FSWTsKCXdoaWxlIChsZW4gPiAwKSB7CgkJc3RydWN0IHNrX2J1ZmYgKnNrYjsKCQlzdHJ1Y3QgbGxfaGVhZGVyICpoZWFkZXIgPSAoc3RydWN0IGxsX2hlYWRlciAqKSBwc2tiLT5kYXRhOwoKCQlza2JfcHVsbChwc2tiLCBMTF9IRUFERVJfTEVOR1RIKTsKCQlpZiAoKGNoLT5wcm90b2NvbCA9PSBDVENfUFJPVE9fUzM5MCkgJiYKCQkgICAgKGhlYWRlci0+dHlwZSAhPSBFVEhfUF9JUCkpIHsKCiNpZm5kZWYgREVCVUcKCQkgICAgICAgIGlmICghKGNoLT5sb2dmbGFncyAmIExPR19GTEFHX0lMTEVHQUxQS1QpKSB7CiNlbmRpZgoJCQkJLyoqCgkJCQkgKiBDaGVjayBwYWNrZXQgdHlwZSBvbmx5IGlmIHdlIHN0aWNrIHN0cmljdGx5CgkJCQkgKiB0byBTLzM5MCdzIHByb3RvY29sIG9mIE9TMzkwLiBUaGlzIG9ubHkKCQkJCSAqIHN1cHBvcnRzIElQLiBPdGhlcndpc2UgYWxsb3cgYW55IHBhY2tldAoJCQkJICogdHlwZS4KCQkJCSAqLwoJCQkJY3RjX3ByX3dhcm4oCgkJCQkJIiVzIElsbGVnYWwgcGFja2V0IHR5cGUgMHglMDR4IHJlY2VpdmVkLCBkcm9wcGluZ1xuIiwKCQkJCQlkZXYtPm5hbWUsIGhlYWRlci0+dHlwZSk7CgkJCQljaC0+bG9nZmxhZ3MgfD0gTE9HX0ZMQUdfSUxMRUdBTFBLVDsKI2lmbmRlZiBERUJVRwoJCQl9CiNlbmRpZgojaWZkZWYgREVCVUcKCQkJY3RjX2R1bXBfc2tiKHBza2IsIC02KTsKI2VuZGlmCgkJCXByaXZwdHItPnN0YXRzLnJ4X2Ryb3BwZWQrKzsKCQkJcHJpdnB0ci0+c3RhdHMucnhfZnJhbWVfZXJyb3JzKys7CgkJCXJldHVybjsKCQl9CgkJcHNrYi0+cHJvdG9jb2wgPSBudG9ocyhoZWFkZXItPnR5cGUpOwoJCWlmIChoZWFkZXItPmxlbmd0aCA8PSBMTF9IRUFERVJfTEVOR1RIKSB7CiNpZm5kZWYgREVCVUcKCQkgICAgICAgIGlmICghKGNoLT5sb2dmbGFncyAmIExPR19GTEFHX0lMTEVHQUxTSVpFKSkgewojZW5kaWYKCQkJCWN0Y19wcl93YXJuKAoJCQkJICAgICAgICIlcyBJbGxlZ2FsIHBhY2tldCBzaXplICVkICIKCQkJCSAgICAgICAicmVjZWl2ZWQgKE1UVT0lZCBibG9ja2xlbj0lZCksICIKCQkJCSAgICAgICAiZHJvcHBpbmdcbiIsIGRldi0+bmFtZSwgaGVhZGVyLT5sZW5ndGgsCgkJCQkgICAgICAgZGV2LT5tdHUsIGxlbik7CgkJCQljaC0+bG9nZmxhZ3MgfD0gTE9HX0ZMQUdfSUxMRUdBTFNJWkU7CiNpZm5kZWYgREVCVUcKCQkJfQojZW5kaWYKI2lmZGVmIERFQlVHCgkJCWN0Y19kdW1wX3NrYihwc2tiLCAtNik7CiNlbmRpZgoJCQlwcml2cHRyLT5zdGF0cy5yeF9kcm9wcGVkKys7CgkJCXByaXZwdHItPnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKCQkJcmV0dXJuOwoJCX0KCQloZWFkZXItPmxlbmd0aCAtPSBMTF9IRUFERVJfTEVOR1RIOwoJCWxlbiAtPSBMTF9IRUFERVJfTEVOR1RIOwoJCWlmICgoaGVhZGVyLT5sZW5ndGggPiBza2JfdGFpbHJvb20ocHNrYikpIHx8CgkJICAgIChoZWFkZXItPmxlbmd0aCA+IGxlbikpIHsKI2lmbmRlZiBERUJVRwoJCSAgICAgICAgaWYgKCEoY2gtPmxvZ2ZsYWdzICYgTE9HX0ZMQUdfT1ZFUlJVTikpIHsKI2VuZGlmCgkJCQljdGNfcHJfd2FybigKCQkJCQkiJXMgSWxsZWdhbCBwYWNrZXQgc2l6ZSAlZCAiCgkJCQkJIihiZXlvbmQgdGhlIGVuZCBvZiByZWNlaXZlZCBkYXRhKSwgIgoJCQkJCSJkcm9wcGluZ1xuIiwgZGV2LT5uYW1lLCBoZWFkZXItPmxlbmd0aCk7CgkJCQljaC0+bG9nZmxhZ3MgfD0gTE9HX0ZMQUdfT1ZFUlJVTjsKI2lmbmRlZiBERUJVRwoJCQl9CiNlbmRpZgojaWZkZWYgREVCVUcKCQkJY3RjX2R1bXBfc2tiKHBza2IsIC02KTsKI2VuZGlmCgkJCXByaXZwdHItPnN0YXRzLnJ4X2Ryb3BwZWQrKzsKCQkJcHJpdnB0ci0+c3RhdHMucnhfbGVuZ3RoX2Vycm9ycysrOwoJCQlyZXR1cm47CgkJfQoJCXNrYl9wdXQocHNrYiwgaGVhZGVyLT5sZW5ndGgpOwoJCXBza2ItPm1hYy5yYXcgPSBwc2tiLT5kYXRhOwoJCWxlbiAtPSBoZWFkZXItPmxlbmd0aDsKCQlza2IgPSBkZXZfYWxsb2Nfc2tiKHBza2ItPmxlbik7CgkJaWYgKCFza2IpIHsKI2lmbmRlZiBERUJVRwoJCSAgICAgICAgaWYgKCEoY2gtPmxvZ2ZsYWdzICYgTE9HX0ZMQUdfTk9NRU0pKSB7CiNlbmRpZgoJCQkJY3RjX3ByX3dhcm4oCgkJCQkJIiVzIE91dCBvZiBtZW1vcnkgaW4gY3RjX3VucGFja19za2JcbiIsCgkJCQkJZGV2LT5uYW1lKTsKCQkJCWNoLT5sb2dmbGFncyB8PSBMT0dfRkxBR19OT01FTTsKI2lmbmRlZiBERUJVRwoJCQl9CiNlbmRpZgoJCQlwcml2cHRyLT5zdGF0cy5yeF9kcm9wcGVkKys7CgkJCXJldHVybjsKCQl9CgkJbWVtY3B5KHNrYl9wdXQoc2tiLCBwc2tiLT5sZW4pLCBwc2tiLT5kYXRhLCBwc2tiLT5sZW4pOwoJCXNrYi0+bWFjLnJhdyA9IHNrYi0+ZGF0YTsKCQlza2ItPmRldiA9IHBza2ItPmRldjsKCQlza2ItPnByb3RvY29sID0gcHNrYi0+cHJvdG9jb2w7CgkJcHNrYi0+aXBfc3VtbWVkID0gQ0hFQ0tTVU1fVU5ORUNFU1NBUlk7CgkJbmV0aWZfcnhfbmkoc2tiKTsKCQkvKioKCQkgKiBTdWNjZXNzZnVsIHJ4OyByZXNldCBsb2dmbGFncwoJCSAqLwoJCWNoLT5sb2dmbGFncyA9IDA7CgkJZGV2LT5sYXN0X3J4ID0gamlmZmllczsKCQlwcml2cHRyLT5zdGF0cy5yeF9wYWNrZXRzKys7CgkJcHJpdnB0ci0+c3RhdHMucnhfYnl0ZXMgKz0gc2tiLT5sZW47CgkJaWYgKGxlbiA+IDApIHsKCQkJc2tiX3B1bGwocHNrYiwgaGVhZGVyLT5sZW5ndGgpOwoJCQlpZiAoc2tiX3RhaWxyb29tKHBza2IpIDwgTExfSEVBREVSX0xFTkdUSCkgewojaWZuZGVmIERFQlVHCgkJCQlpZiAoIShjaC0+bG9nZmxhZ3MgJiBMT0dfRkxBR19PVkVSUlVOKSkgewojZW5kaWYKCQkJCQljdGNfcHJfd2FybigKCQkJCQkJIiVzIE92ZXJydW4gaW4gY3RjX3VucGFja19za2JcbiIsCgkJCQkJCWRldi0+bmFtZSk7CgkJCQkJY2gtPmxvZ2ZsYWdzIHw9IExPR19GTEFHX09WRVJSVU47CiNpZm5kZWYgREVCVUcKCQkJCX0KI2VuZGlmCgkJCQlyZXR1cm47CgkJCX0KCQkJc2tiX3B1dChwc2tiLCBMTF9IRUFERVJfTEVOR1RIKTsKCQl9Cgl9Cn0KCi8qKgogKiBDaGVjayByZXR1cm4gY29kZSBvZiBhIHByZWNlZWRpbmcgY2N3X2RldmljZSBjYWxsLCBoYWx0X0lPIGV0Yy4uLgogKgogKiBAcGFyYW0gY2ggICAgICAgICAgVGhlIGNoYW5uZWwsIHRoZSBlcnJvciBiZWxvbmdzIHRvLgogKiBAcGFyYW0gcmV0dXJuX2NvZGUgVGhlIGVycm9yIGNvZGUgdG8gaW5zcGVjdC4KICovCnN0YXRpYyB2b2lkCmNjd19jaGVja19yZXR1cm5fY29kZShzdHJ1Y3QgY2hhbm5lbCAqY2gsIGludCByZXR1cm5fY29kZSwgY2hhciAqbXNnKQp7CglEQkZfVEVYVCh0cmFjZSwgNSwgX19GVU5DVElPTl9fKTsKCXN3aXRjaCAocmV0dXJuX2NvZGUpIHsKCQljYXNlIDA6CgkJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9JT19TVUNDRVNTLCBjaCk7CgkJCWJyZWFrOwoJCWNhc2UgLUVCVVNZOgoJCQljdGNfcHJfd2FybigiJXMgKCVzKTogQnVzeSAhXG4iLCBjaC0+aWQsIG1zZyk7CgkJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9JT19FQlVTWSwgY2gpOwoJCQlicmVhazsKCQljYXNlIC1FTk9ERVY6CgkJCWN0Y19wcl9lbWVyZygiJXMgKCVzKTogSW52YWxpZCBkZXZpY2UgY2FsbGVkIGZvciBJT1xuIiwKCQkJCSAgICAgY2gtPmlkLCBtc2cpOwoJCQlmc21fZXZlbnQoY2gtPmZzbSwgQ0hfRVZFTlRfSU9fRU5PREVWLCBjaCk7CgkJCWJyZWFrOwoJCWNhc2UgLUVJTzoKCQkJY3RjX3ByX2VtZXJnKCIlcyAoJXMpOiBTdGF0dXMgcGVuZGluZy4uLiBcbiIsCgkJCQkgICAgIGNoLT5pZCwgbXNnKTsKCQkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX0lPX0VJTywgY2gpOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQljdGNfcHJfZW1lcmcoIiVzICglcyk6IFVua25vd24gZXJyb3IgaW4gZG9fSU8gJTA0eFxuIiwKCQkJCSAgICAgY2gtPmlkLCBtc2csIHJldHVybl9jb2RlKTsKCQkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX0lPX1VOS05PV04sIGNoKTsKCX0KfQoKLyoqCiAqIENoZWNrIHNlbnNlIG9mIGEgdW5pdCBjaGVjay4KICoKICogQHBhcmFtIGNoICAgIFRoZSBjaGFubmVsLCB0aGUgc2Vuc2UgY29kZSBiZWxvbmdzIHRvLgogKiBAcGFyYW0gc2Vuc2UgVGhlIHNlbnNlIGNvZGUgdG8gaW5zcGVjdC4KICovCnN0YXRpYyB2b2lkCmNjd191bml0X2NoZWNrKHN0cnVjdCBjaGFubmVsICpjaCwgdW5zaWduZWQgY2hhciBzZW5zZSkKewoJREJGX1RFWFQodHJhY2UsIDUsIF9fRlVOQ1RJT05fXyk7CglpZiAoc2Vuc2UgJiBTTlMwX0lOVEVSVkVOVElPTl9SRVEpIHsKCQlpZiAoc2Vuc2UgJiAweDAxKSB7CgkJCWN0Y19wcl9kZWJ1ZygiJXM6IEludGVyZmFjZSBkaXNjLiBvciBTZWwuIHJlc2V0ICIKCQkJCQkiKHJlbW90ZSlcbiIsIGNoLT5pZCk7CgkJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9VQ19SQ1JFU0VULCBjaCk7CgkJfSBlbHNlIHsKCQkJY3RjX3ByX2RlYnVnKCIlczogU3lzdGVtIHJlc2V0IChyZW1vdGUpXG4iLCBjaC0+aWQpOwoJCQlmc21fZXZlbnQoY2gtPmZzbSwgQ0hfRVZFTlRfVUNfUlNSRVNFVCwgY2gpOwoJCX0KCX0gZWxzZSBpZiAoc2Vuc2UgJiBTTlMwX0VRVUlQTUVOVF9DSEVDSykgewoJCWlmIChzZW5zZSAmIFNOUzBfQlVTX09VVF9DSEVDSykgewoJCQljdGNfcHJfd2FybigiJXM6IEhhcmR3YXJlIG1hbGZ1bmN0aW9uIChyZW1vdGUpXG4iLAoJCQkJICAgIGNoLT5pZCk7CgkJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9VQ19IV0ZBSUwsIGNoKTsKCQl9IGVsc2UgewoJCQljdGNfcHJfd2FybigiJXM6IFJlYWQtZGF0YSBwYXJpdHkgZXJyb3IgKHJlbW90ZSlcbiIsCgkJCQkgICAgY2gtPmlkKTsKCQkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX1VDX1JYUEFSSVRZLCBjaCk7CgkJfQoJfSBlbHNlIGlmIChzZW5zZSAmIFNOUzBfQlVTX09VVF9DSEVDSykgewoJCWlmIChzZW5zZSAmIDB4MDQpIHsKCQkJY3RjX3ByX3dhcm4oIiVzOiBEYXRhLXN0cmVhbWluZyB0aW1lb3V0KVxuIiwgY2gtPmlkKTsKCQkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX1VDX1RYVElNRU9VVCwgY2gpOwoJCX0gZWxzZSB7CgkJCWN0Y19wcl93YXJuKCIlczogRGF0YS10cmFuc2ZlciBwYXJpdHkgZXJyb3JcbiIsIGNoLT5pZCk7CgkJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9VQ19UWFBBUklUWSwgY2gpOwoJCX0KCX0gZWxzZSBpZiAoc2Vuc2UgJiBTTlMwX0NNRF9SRUpFQ1QpIHsKCQljdGNfcHJfd2FybigiJXM6IENvbW1hbmQgcmVqZWN0XG4iLCBjaC0+aWQpOwoJfSBlbHNlIGlmIChzZW5zZSA9PSAwKSB7CgkJY3RjX3ByX2RlYnVnKCIlczogVW5pdCBjaGVjayBaRVJPXG4iLCBjaC0+aWQpOwoJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9VQ19aRVJPLCBjaCk7Cgl9IGVsc2UgewoJCWN0Y19wcl93YXJuKCIlczogVW5pdCBDaGVjayB3aXRoIHNlbnNlIGNvZGU6ICUwMnhcbiIsCgkJCSAgICBjaC0+aWQsIHNlbnNlKTsKCQlmc21fZXZlbnQoY2gtPmZzbSwgQ0hfRVZFTlRfVUNfVU5LTk9XTiwgY2gpOwoJfQp9CgpzdGF0aWMgdm9pZApjdGNfcHVyZ2Vfc2tiX3F1ZXVlKHN0cnVjdCBza19idWZmX2hlYWQgKnEpCnsKCXN0cnVjdCBza19idWZmICpza2I7CgoJREJGX1RFWFQodHJhY2UsIDUsIF9fRlVOQ1RJT05fXyk7CgoJd2hpbGUgKChza2IgPSBza2JfZGVxdWV1ZShxKSkpIHsKCQlhdG9taWNfZGVjKCZza2ItPnVzZXJzKTsKCQlkZXZfa2ZyZWVfc2tiX2lycShza2IpOwoJfQp9CgpzdGF0aWMgaW50CmN0Y19jaGVja2FsbG9jX2J1ZmZlcihzdHJ1Y3QgY2hhbm5lbCAqY2gsIGludCB3YXJuKQp7CglEQkZfVEVYVCh0cmFjZSwgNSwgX19GVU5DVElPTl9fKTsKCWlmICgoY2gtPnRyYW5zX3NrYiA9PSBOVUxMKSB8fAoJICAgIChjaC0+ZmxhZ3MgJiBDSEFOTkVMX0ZMQUdTX0JVRlNJWkVfQ0hBTkdFRCkpIHsKCQlpZiAoY2gtPnRyYW5zX3NrYiAhPSBOVUxMKQoJCQlkZXZfa2ZyZWVfc2tiKGNoLT50cmFuc19za2IpOwoJCWNsZWFyX25vcm1hbGl6ZWRfY2RhKCZjaC0+Y2N3WzFdKTsKCQljaC0+dHJhbnNfc2tiID0gX19kZXZfYWxsb2Nfc2tiKGNoLT5tYXhfYnVmc2l6ZSwKCQkJCQkJR0ZQX0FUT01JQyB8IEdGUF9ETUEpOwoJCWlmIChjaC0+dHJhbnNfc2tiID09IE5VTEwpIHsKCQkJaWYgKHdhcm4pCgkJCQljdGNfcHJfd2FybigKCQkJCQkiJXM6IENvdWxkbid0IGFsbG9jICVzIHRyYW5zX3NrYlxuIiwKCQkJCQljaC0+aWQsCgkJCQkJKENIQU5ORUxfRElSRUNUSU9OKGNoLT5mbGFncykgPT0gUkVBRCkgPwoJCQkJCSJSWCIgOiAiVFgiKTsKCQkJcmV0dXJuIC1FTk9NRU07CgkJfQoJCWNoLT5jY3dbMV0uY291bnQgPSBjaC0+bWF4X2J1ZnNpemU7CgkJaWYgKHNldF9ub3JtYWxpemVkX2NkYSgmY2gtPmNjd1sxXSwgY2gtPnRyYW5zX3NrYi0+ZGF0YSkpIHsKCQkJZGV2X2tmcmVlX3NrYihjaC0+dHJhbnNfc2tiKTsKCQkJY2gtPnRyYW5zX3NrYiA9IE5VTEw7CgkJCWlmICh3YXJuKQoJCQkJY3RjX3ByX3dhcm4oCgkJCQkJIiVzOiBzZXRfbm9ybWFsaXplZF9jZGEgZm9yICVzICIKCQkJCQkidHJhbnNfc2tiIGZhaWxlZCwgZHJvcHBpbmcgcGFja2V0c1xuIiwKCQkJCQljaC0+aWQsCgkJCQkJKENIQU5ORUxfRElSRUNUSU9OKGNoLT5mbGFncykgPT0gUkVBRCkgPwoJCQkJCSJSWCIgOiAiVFgiKTsKCQkJcmV0dXJuIC1FTk9NRU07CgkJfQoJCWNoLT5jY3dbMV0uY291bnQgPSAwOwoJCWNoLT50cmFuc19za2JfZGF0YSA9IGNoLT50cmFuc19za2ItPmRhdGE7CgkJY2gtPmZsYWdzICY9IH5DSEFOTkVMX0ZMQUdTX0JVRlNJWkVfQ0hBTkdFRDsKCX0KCXJldHVybiAwOwp9CgovKioKICogRHVtbXkgTk9QIGFjdGlvbiBmb3Igc3RhdGVtYWNoaW5lcwogKi8Kc3RhdGljIHZvaWQKZnNtX2FjdGlvbl9ub3AoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7Cn0KCi8qKgogKiBBY3Rpb25zIGZvciBjaGFubmVsIC0gc3RhdGVtYWNoaW5lcy4KICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoqCiAqIE5vcm1hbCBkYXRhIGhhcyBiZWVuIHNlbmQuIEZyZWUgdGhlIGNvcnJlc3BvbmRpbmcKICogc2tiIChpdCdzIGluIGlvX3F1ZXVlKSwgcmVzZXQgZGV2LT50YnVzeSBhbmQKICogcmV2ZXJ0IHRvIGlkbGUgc3RhdGUuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX3R4ZG9uZShmc21faW5zdGFuY2UgKiBmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCXN0cnVjdCBjaGFubmVsICpjaCA9IChzdHJ1Y3QgY2hhbm5lbCAqKSBhcmc7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gY2gtPm5ldGRldjsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdnB0ciA9IGRldi0+cHJpdjsKCXN0cnVjdCBza19idWZmICpza2I7CglpbnQgZmlyc3QgPSAxOwoJaW50IGk7Cgl1bnNpZ25lZCBsb25nIGR1cmF0aW9uOwoJc3RydWN0IHRpbWVzcGVjIGRvbmVfc3RhbXAgPSB4dGltZTsKCglEQkZfVEVYVCh0cmFjZSwgNCwgX19GVU5DVElPTl9fKTsKCglkdXJhdGlvbiA9CgkgICAgKGRvbmVfc3RhbXAudHZfc2VjIC0gY2gtPnByb2Yuc2VuZF9zdGFtcC50dl9zZWMpICogMTAwMDAwMCArCgkgICAgKGRvbmVfc3RhbXAudHZfbnNlYyAtIGNoLT5wcm9mLnNlbmRfc3RhbXAudHZfbnNlYykgLyAxMDAwOwoJaWYgKGR1cmF0aW9uID4gY2gtPnByb2YudHhfdGltZSkKCQljaC0+cHJvZi50eF90aW1lID0gZHVyYXRpb247CgoJaWYgKGNoLT5pcmItPnNjc3cuY291bnQgIT0gMCkKCQljdGNfcHJfZGVidWcoIiVzOiBUWCBub3QgY29tcGxldGUsIHJlbWFpbmluZyAlZCBieXRlc1xuIiwKCQkJICAgICBkZXYtPm5hbWUsIGNoLT5pcmItPnNjc3cuY291bnQpOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJd2hpbGUgKChza2IgPSBza2JfZGVxdWV1ZSgmY2gtPmlvX3F1ZXVlKSkpIHsKCQlwcml2cHRyLT5zdGF0cy50eF9wYWNrZXRzKys7CgkJcHJpdnB0ci0+c3RhdHMudHhfYnl0ZXMgKz0gc2tiLT5sZW4gLSBMTF9IRUFERVJfTEVOR1RIOwoJCWlmIChmaXJzdCkgewoJCQlwcml2cHRyLT5zdGF0cy50eF9ieXRlcyArPSAyOwoJCQlmaXJzdCA9IDA7CgkJfQoJCWF0b21pY19kZWMoJnNrYi0+dXNlcnMpOwoJCWRldl9rZnJlZV9za2JfaXJxKHNrYik7Cgl9CglzcGluX2xvY2soJmNoLT5jb2xsZWN0X2xvY2spOwoJY2xlYXJfbm9ybWFsaXplZF9jZGEoJmNoLT5jY3dbNF0pOwoJaWYgKGNoLT5jb2xsZWN0X2xlbiA+IDApIHsKCQlpbnQgcmM7CgoJCWlmIChjdGNfY2hlY2thbGxvY19idWZmZXIoY2gsIDEpKSB7CgkJCXNwaW5fdW5sb2NrKCZjaC0+Y29sbGVjdF9sb2NrKTsKCQkJcmV0dXJuOwoJCX0KCQljaC0+dHJhbnNfc2tiLT50YWlsID0gY2gtPnRyYW5zX3NrYi0+ZGF0YSA9IGNoLT50cmFuc19za2JfZGF0YTsKCQljaC0+dHJhbnNfc2tiLT5sZW4gPSAwOwoJCWlmIChjaC0+cHJvZi5tYXhtdWx0aSA8IChjaC0+Y29sbGVjdF9sZW4gKyAyKSkKCQkJY2gtPnByb2YubWF4bXVsdGkgPSBjaC0+Y29sbGVjdF9sZW4gKyAyOwoJCWlmIChjaC0+cHJvZi5tYXhjcXVldWUgPCBza2JfcXVldWVfbGVuKCZjaC0+Y29sbGVjdF9xdWV1ZSkpCgkJCWNoLT5wcm9mLm1heGNxdWV1ZSA9IHNrYl9xdWV1ZV9sZW4oJmNoLT5jb2xsZWN0X3F1ZXVlKTsKCQkqKChfX3UxNiAqKSBza2JfcHV0KGNoLT50cmFuc19za2IsIDIpKSA9IGNoLT5jb2xsZWN0X2xlbiArIDI7CgkJaSA9IDA7CgkJd2hpbGUgKChza2IgPSBza2JfZGVxdWV1ZSgmY2gtPmNvbGxlY3RfcXVldWUpKSkgewoJCQltZW1jcHkoc2tiX3B1dChjaC0+dHJhbnNfc2tiLCBza2ItPmxlbiksIHNrYi0+ZGF0YSwKCQkJICAgICAgIHNrYi0+bGVuKTsKCQkJcHJpdnB0ci0+c3RhdHMudHhfcGFja2V0cysrOwoJCQlwcml2cHRyLT5zdGF0cy50eF9ieXRlcyArPSBza2ItPmxlbiAtIExMX0hFQURFUl9MRU5HVEg7CgkJCWF0b21pY19kZWMoJnNrYi0+dXNlcnMpOwoJCQlkZXZfa2ZyZWVfc2tiX2lycShza2IpOwoJCQlpKys7CgkJfQoJCWNoLT5jb2xsZWN0X2xlbiA9IDA7CgkJc3Bpbl91bmxvY2soJmNoLT5jb2xsZWN0X2xvY2spOwoJCWNoLT5jY3dbMV0uY291bnQgPSBjaC0+dHJhbnNfc2tiLT5sZW47CgkJZnNtX2FkZHRpbWVyKCZjaC0+dGltZXIsIENUQ19USU1FT1VUXzVTRUMsIENIX0VWRU5UX1RJTUVSLCBjaCk7CgkJY2gtPnByb2Yuc2VuZF9zdGFtcCA9IHh0aW1lOwoJCXJjID0gY2N3X2RldmljZV9zdGFydChjaC0+Y2RldiwgJmNoLT5jY3dbMF0sCgkJCQkgICAgICAodW5zaWduZWQgbG9uZykgY2gsIDB4ZmYsIDApOwoJCWNoLT5wcm9mLmRvaW9zX211bHRpKys7CgkJaWYgKHJjICE9IDApIHsKCQkJcHJpdnB0ci0+c3RhdHMudHhfZHJvcHBlZCArPSBpOwoJCQlwcml2cHRyLT5zdGF0cy50eF9lcnJvcnMgKz0gaTsKCQkJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJCQljY3dfY2hlY2tfcmV0dXJuX2NvZGUoY2gsIHJjLCAiY2hhaW5lZCBUWCIpOwoJCX0KCX0gZWxzZSB7CgkJc3Bpbl91bmxvY2soJmNoLT5jb2xsZWN0X2xvY2spOwoJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfVFhJRExFKTsKCX0KCWN0Y19jbGVhcl9idXN5KGRldik7Cn0KCi8qKgogKiBJbml0aWFsIGRhdGEgaXMgc2VudC4KICogTm90aWZ5IGRldmljZSBzdGF0ZW1hY2hpbmUgdGhhdCB3ZSBhcmUgdXAgYW5kCiAqIHJ1bm5pbmcuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX3R4aWRsZShmc21faW5zdGFuY2UgKiBmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCXN0cnVjdCBjaGFubmVsICpjaCA9IChzdHJ1Y3QgY2hhbm5lbCAqKSBhcmc7CgoJREJGX1RFWFQodHJhY2UsIDQsIF9fRlVOQ1RJT05fXyk7Cglmc21fZGVsdGltZXIoJmNoLT50aW1lcik7Cglmc21fbmV3c3RhdGUoZmksIENIX1NUQVRFX1RYSURMRSk7Cglmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgY2gtPm5ldGRldi0+cHJpdiktPmZzbSwgREVWX0VWRU5UX1RYVVAsCgkJICBjaC0+bmV0ZGV2KTsKfQoKLyoqCiAqIEdvdCBub3JtYWwgZGF0YSwgY2hlY2sgZm9yIHNhbml0eSwgcXVldWUgaXQgdXAsIGFsbG9jYXRlIG5ldyBidWZmZXIKICogdHJpZ2dlciBib3R0b20gaGFsZiwgYW5kIGluaXRpYXRlIG5leHQgcmVhZC4KICoKICogQHBhcmFtIGZpICAgIEFuIGluc3RhbmNlIG9mIGEgY2hhbm5lbCBzdGF0ZW1hY2hpbmUuCiAqIEBwYXJhbSBldmVudCBUaGUgZXZlbnQsIGp1c3QgaGFwcGVuZWQuCiAqIEBwYXJhbSBhcmcgICBHZW5lcmljIHBvaW50ZXIsIGNhc3RlZCBmcm9tIGNoYW5uZWwgKiB1cG9uIGNhbGwuCiAqLwpzdGF0aWMgdm9pZApjaF9hY3Rpb25fcngoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7CglzdHJ1Y3QgY2hhbm5lbCAqY2ggPSAoc3RydWN0IGNoYW5uZWwgKikgYXJnOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IGNoLT5uZXRkZXY7CglzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSBkZXYtPnByaXY7CglpbnQgbGVuID0gY2gtPm1heF9idWZzaXplIC0gY2gtPmlyYi0+c2Nzdy5jb3VudDsKCXN0cnVjdCBza19idWZmICpza2IgPSBjaC0+dHJhbnNfc2tiOwoJX191MTYgYmxvY2tfbGVuID0gKigoX191MTYgKikgc2tiLT5kYXRhKTsKCWludCBjaGVja19sZW47CglpbnQgcmM7CgoJREJGX1RFWFQodHJhY2UsIDQsIF9fRlVOQ1RJT05fXyk7Cglmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CglpZiAobGVuIDwgOCkgewoJCWN0Y19wcl9kZWJ1ZygiJXM6IGdvdCBwYWNrZXQgd2l0aCBsZW5ndGggJWQgPCA4XG4iLAoJCQkgICAgIGRldi0+bmFtZSwgbGVuKTsKCQlwcml2cHRyLT5zdGF0cy5yeF9kcm9wcGVkKys7CgkJcHJpdnB0ci0+c3RhdHMucnhfbGVuZ3RoX2Vycm9ycysrOwoJCWdvdG8gYWdhaW47Cgl9CglpZiAobGVuID4gY2gtPm1heF9idWZzaXplKSB7CgkJY3RjX3ByX2RlYnVnKCIlczogZ290IHBhY2tldCB3aXRoIGxlbmd0aCAlZCA+ICVkXG4iLAoJCQkgICAgIGRldi0+bmFtZSwgbGVuLCBjaC0+bWF4X2J1ZnNpemUpOwoJCXByaXZwdHItPnN0YXRzLnJ4X2Ryb3BwZWQrKzsKCQlwcml2cHRyLT5zdGF0cy5yeF9sZW5ndGhfZXJyb3JzKys7CgkJZ290byBhZ2FpbjsKCX0KCgkvKioKCSAqIFZNIFRDUCBzZWVtcyB0byBoYXZlIGEgYnVnIHNlbmRpbmcgMiB0cmFpbGluZyBieXRlcyBvZiBnYXJiYWdlLgoJICovCglzd2l0Y2ggKGNoLT5wcm90b2NvbCkgewoJCWNhc2UgQ1RDX1BST1RPX1MzOTA6CgkJY2FzZSBDVENfUFJPVE9fT1MzOTA6CgkJCWNoZWNrX2xlbiA9IGJsb2NrX2xlbiArIDI7CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCWNoZWNrX2xlbiA9IGJsb2NrX2xlbjsKCQkJYnJlYWs7Cgl9CglpZiAoKGxlbiA8IGJsb2NrX2xlbikgfHwgKGxlbiA+IGNoZWNrX2xlbikpIHsKCQljdGNfcHJfZGVidWcoIiVzOiBnb3QgYmxvY2sgbGVuZ3RoICVkICE9IHJ4IGxlbmd0aCAlZFxuIiwKCQkJICAgICBkZXYtPm5hbWUsIGJsb2NrX2xlbiwgbGVuKTsKI2lmZGVmIERFQlVHCgkJY3RjX2R1bXBfc2tiKHNrYiwgMCk7CiNlbmRpZgoJCSooKF9fdTE2ICopIHNrYi0+ZGF0YSkgPSBsZW47CgkJcHJpdnB0ci0+c3RhdHMucnhfZHJvcHBlZCsrOwoJCXByaXZwdHItPnN0YXRzLnJ4X2xlbmd0aF9lcnJvcnMrKzsKCQlnb3RvIGFnYWluOwoJfQoJYmxvY2tfbGVuIC09IDI7CglpZiAoYmxvY2tfbGVuID4gMCkgewoJCSooKF9fdTE2ICopIHNrYi0+ZGF0YSkgPSBibG9ja19sZW47CgkJY3RjX3VucGFja19za2IoY2gsIHNrYik7Cgl9CiBhZ2FpbjoKCXNrYi0+ZGF0YSA9IHNrYi0+dGFpbCA9IGNoLT50cmFuc19za2JfZGF0YTsKCXNrYi0+bGVuID0gMDsKCWlmIChjdGNfY2hlY2thbGxvY19idWZmZXIoY2gsIDEpKQoJCXJldHVybjsKCWNoLT5jY3dbMV0uY291bnQgPSBjaC0+bWF4X2J1ZnNpemU7CglyYyA9IGNjd19kZXZpY2Vfc3RhcnQoY2gtPmNkZXYsICZjaC0+Y2N3WzBdLCAodW5zaWduZWQgbG9uZykgY2gsIDB4ZmYsIDApOwoJaWYgKHJjICE9IDApCgkJY2N3X2NoZWNrX3JldHVybl9jb2RlKGNoLCByYywgIm5vcm1hbCBSWCIpOwp9CgpzdGF0aWMgdm9pZCBjaF9hY3Rpb25fcnhpZGxlKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZyk7CgovKioKICogSW5pdGlhbGl6ZSBjb25uZWN0aW9uIGJ5IHNlbmRpbmcgYSBfX3UxNiBvZiB2YWx1ZSAwLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9maXJzdGlvKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCWludCByYzsKCglEQkZfVEVYVCh0cmFjZSwgNCwgX19GVU5DVElPTl9fKTsKCglpZiAoZnNtX2dldHN0YXRlKGZpKSA9PSBDSF9TVEFURV9UWElETEUpCgkJY3RjX3ByX2RlYnVnKCIlczogcmVtb3RlIHNpZGUgaXNzdWVkIFJFQUQ/LCBpbml0IC4uLlxuIiwgY2gtPmlkKTsKCWZzbV9kZWx0aW1lcigmY2gtPnRpbWVyKTsKCWlmIChjdGNfY2hlY2thbGxvY19idWZmZXIoY2gsIDEpKQoJCXJldHVybjsKCWlmICgoZnNtX2dldHN0YXRlKGZpKSA9PSBDSF9TVEFURV9TRVRVUFdBSVQpICYmCgkgICAgKGNoLT5wcm90b2NvbCA9PSBDVENfUFJPVE9fT1MzOTApKSB7CgkJLyogT1MvMzkwIHJlc3AuIHovT1MgKi8KCQlpZiAoQ0hBTk5FTF9ESVJFQ1RJT04oY2gtPmZsYWdzKSA9PSBSRUFEKSB7CgkJCSooKF9fdTE2ICopIGNoLT50cmFuc19za2ItPmRhdGEpID0gQ1RDX0lOSVRJQUxfQkxPQ0tMRU47CgkJCWZzbV9hZGR0aW1lcigmY2gtPnRpbWVyLCBDVENfVElNRU9VVF81U0VDLAoJCQkJICAgICBDSF9FVkVOVF9USU1FUiwgY2gpOwoJCQljaF9hY3Rpb25fcnhpZGxlKGZpLCBldmVudCwgYXJnKTsKCQl9IGVsc2UgewoJCQlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gY2gtPm5ldGRldjsKCQkJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9UWElETEUpOwoJCQlmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLAoJCQkJICBERVZfRVZFTlRfVFhVUCwgZGV2KTsKCQl9CgkJcmV0dXJuOwoJfQoKCS8qKgoJICogRG9utHQgc2V0dXAgYSB0aW1lciBmb3IgcmVjZWl2aW5nIHRoZSBpbml0aWFsIFJYIGZyYW1lCgkgKiBpZiBpbiBjb21wYXRpYmlsaXR5IG1vZGUsIHNpbmNlIFZNIFRDUCBkZWxheXMgdGhlIGluaXRpYWwKCSAqIGZyYW1lIHVudGlsIGl0IGhhcyBzb21lIGRhdGEgdG8gc2VuZC4KCSAqLwoJaWYgKChDSEFOTkVMX0RJUkVDVElPTihjaC0+ZmxhZ3MpID09IFdSSVRFKSB8fAoJICAgIChjaC0+cHJvdG9jb2wgIT0gQ1RDX1BST1RPX1MzOTApKQoJCWZzbV9hZGR0aW1lcigmY2gtPnRpbWVyLCBDVENfVElNRU9VVF81U0VDLCBDSF9FVkVOVF9USU1FUiwgY2gpOwoKCSooKF9fdTE2ICopIGNoLT50cmFuc19za2ItPmRhdGEpID0gQ1RDX0lOSVRJQUxfQkxPQ0tMRU47CgljaC0+Y2N3WzFdLmNvdW50ID0gMjsJLyogVHJhbnNmZXIgb25seSBsZW5ndGggKi8KCglmc21fbmV3c3RhdGUoZmksIChDSEFOTkVMX0RJUkVDVElPTihjaC0+ZmxhZ3MpID09IFJFQUQpCgkJICAgICA/IENIX1NUQVRFX1JYSU5JVCA6IENIX1NUQVRFX1RYSU5JVCk7CglyYyA9IGNjd19kZXZpY2Vfc3RhcnQoY2gtPmNkZXYsICZjaC0+Y2N3WzBdLCAodW5zaWduZWQgbG9uZykgY2gsIDB4ZmYsIDApOwoJaWYgKHJjICE9IDApIHsKCQlmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CgkJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9TRVRVUFdBSVQpOwoJCWNjd19jaGVja19yZXR1cm5fY29kZShjaCwgcmMsICJpbml0IElPIik7Cgl9CgkvKioKCSAqIElmIGluIGNvbXBhdGliaWxpdHkgbW9kZSBzaW5jZSB3ZSBkb260dCBzZXR1cCBhIHRpbWVyLCB3ZQoJICogYWxzbyBzaWduYWwgUlggY2hhbm5lbCB1cCBpbW1lZGlhdGVseS4gVGhpcyBlbmFibGVzIHVzCgkgKiB0byBzZW5kIHBhY2tldHMgZWFybHkgd2hpY2ggaW4gdHVybiB1c3VhbGx5IHRyaWdnZXJzIHNvbWUKCSAqIHJlcGx5IGZyb20gVk0gVENQIHdoaWNoIGJyaW5ncyB1cCB0aGUgUlggY2hhbm5lbCB0byBpdLRzCgkgKiBmaW5hbCBzdGF0ZS4KCSAqLwoJaWYgKChDSEFOTkVMX0RJUkVDVElPTihjaC0+ZmxhZ3MpID09IFJFQUQpICYmCgkgICAgKGNoLT5wcm90b2NvbCA9PSBDVENfUFJPVE9fUzM5MCkpIHsKCQlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gY2gtPm5ldGRldjsKCQlmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLCBERVZfRVZFTlRfUlhVUCwKCQkJICBkZXYpOwoJfQp9CgovKioKICogR290IGluaXRpYWwgZGF0YSwgY2hlY2sgaXQuIElmIE9LLAogKiBub3RpZnkgZGV2aWNlIHN0YXRlbWFjaGluZSB0aGF0IHdlIGFyZSB1cCBhbmQKICogcnVubmluZy4KICoKICogQHBhcmFtIGZpICAgIEFuIGluc3RhbmNlIG9mIGEgY2hhbm5lbCBzdGF0ZW1hY2hpbmUuCiAqIEBwYXJhbSBldmVudCBUaGUgZXZlbnQsIGp1c3QgaGFwcGVuZWQuCiAqIEBwYXJhbSBhcmcgICBHZW5lcmljIHBvaW50ZXIsIGNhc3RlZCBmcm9tIGNoYW5uZWwgKiB1cG9uIGNhbGwuCiAqLwpzdGF0aWMgdm9pZApjaF9hY3Rpb25fcnhpZGxlKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoJX191MTYgYnVmbGVuOwoJaW50IHJjOwoKCURCRl9URVhUKHRyYWNlLCA0LCBfX0ZVTkNUSU9OX18pOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJYnVmbGVuID0gKigoX191MTYgKikgY2gtPnRyYW5zX3NrYi0+ZGF0YSk7CiNpZmRlZiBERUJVRwoJY3RjX3ByX2RlYnVnKCIlczogSW5pdGlhbCBSWCBjb3VudCAlZFxuIiwgZGV2LT5uYW1lLCBidWZsZW4pOwojZW5kaWYKCWlmIChidWZsZW4gPj0gQ1RDX0lOSVRJQUxfQkxPQ0tMRU4pIHsKCQlpZiAoY3RjX2NoZWNrYWxsb2NfYnVmZmVyKGNoLCAxKSkKCQkJcmV0dXJuOwoJCWNoLT5jY3dbMV0uY291bnQgPSBjaC0+bWF4X2J1ZnNpemU7CgkJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9SWElETEUpOwoJCXJjID0gY2N3X2RldmljZV9zdGFydChjaC0+Y2RldiwgJmNoLT5jY3dbMF0sCgkJCQkgICAgICAodW5zaWduZWQgbG9uZykgY2gsIDB4ZmYsIDApOwoJCWlmIChyYyAhPSAwKSB7CgkJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfUlhJTklUKTsKCQkJY2N3X2NoZWNrX3JldHVybl9jb2RlKGNoLCByYywgImluaXRpYWwgUlgiKTsKCQl9IGVsc2UKCQkJZnNtX2V2ZW50KCgoc3RydWN0IGN0Y19wcml2ICopIGRldi0+cHJpdiktPmZzbSwKCQkJCSAgREVWX0VWRU5UX1JYVVAsIGRldik7Cgl9IGVsc2UgewoJCWN0Y19wcl9kZWJ1ZygiJXM6IEluaXRpYWwgUlggY291bnQgJWQgbm90ICVkXG4iLAoJCQkgICAgIGRldi0+bmFtZSwgYnVmbGVuLCBDVENfSU5JVElBTF9CTE9DS0xFTik7CgkJY2hfYWN0aW9uX2ZpcnN0aW8oZmksIGV2ZW50LCBhcmcpOwoJfQp9CgovKioKICogU2V0IGNoYW5uZWwgaW50byBleHRlbmRlZCBtb2RlLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9zZXRtb2RlKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCWludCByYzsKCXVuc2lnbmVkIGxvbmcgc2F2ZWZsYWdzOwoKCURCRl9URVhUKHRyYWNlLCA0LCBfX0ZVTkNUSU9OX18pOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJZnNtX2FkZHRpbWVyKCZjaC0+dGltZXIsIENUQ19USU1FT1VUXzVTRUMsIENIX0VWRU5UX1RJTUVSLCBjaCk7Cglmc21fbmV3c3RhdGUoZmksIENIX1NUQVRFX1NFVFVQV0FJVCk7CglzYXZlZmxhZ3MgPSAwOwkvKiBhdm9pZHMgY29tcGlsZXIgd2FybmluZyB3aXRoCgkJCSAgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKi8KCWlmIChldmVudCA9PSBDSF9FVkVOVF9USU1FUikJLy8gb25seSBmb3IgdGltZXIgbm90IHlldCBsb2NrZWQKCQlzcGluX2xvY2tfaXJxc2F2ZShnZXRfY2N3ZGV2X2xvY2soY2gtPmNkZXYpLCBzYXZlZmxhZ3MpOwoJcmMgPSBjY3dfZGV2aWNlX3N0YXJ0KGNoLT5jZGV2LCAmY2gtPmNjd1s2XSwgKHVuc2lnbmVkIGxvbmcpIGNoLCAweGZmLCAwKTsKCWlmIChldmVudCA9PSBDSF9FVkVOVF9USU1FUikKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKGdldF9jY3dkZXZfbG9jayhjaC0+Y2RldiksIHNhdmVmbGFncyk7CglpZiAocmMgIT0gMCkgewoJCWZzbV9kZWx0aW1lcigmY2gtPnRpbWVyKTsKCQlmc21fbmV3c3RhdGUoZmksIENIX1NUQVRFX1NUQVJUV0FJVCk7CgkJY2N3X2NoZWNrX3JldHVybl9jb2RlKGNoLCByYywgInNldCBNb2RlIik7Cgl9IGVsc2UKCQljaC0+cmV0cnkgPSAwOwp9CgovKioKICogU2V0dXAgY2hhbm5lbC4KICoKICogQHBhcmFtIGZpICAgIEFuIGluc3RhbmNlIG9mIGEgY2hhbm5lbCBzdGF0ZW1hY2hpbmUuCiAqIEBwYXJhbSBldmVudCBUaGUgZXZlbnQsIGp1c3QgaGFwcGVuZWQuCiAqIEBwYXJhbSBhcmcgICBHZW5lcmljIHBvaW50ZXIsIGNhc3RlZCBmcm9tIGNoYW5uZWwgKiB1cG9uIGNhbGwuCiAqLwpzdGF0aWMgdm9pZApjaF9hY3Rpb25fc3RhcnQoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7CglzdHJ1Y3QgY2hhbm5lbCAqY2ggPSAoc3RydWN0IGNoYW5uZWwgKikgYXJnOwoJdW5zaWduZWQgbG9uZyBzYXZlZmxhZ3M7CglpbnQgcmM7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2OwoKCURCRl9URVhUKHRyYWNlLCA0LCBfX0ZVTkNUSU9OX18pOwoJaWYgKGNoID09IE5VTEwpIHsKCQljdGNfcHJfd2FybigiY2hfYWN0aW9uX3N0YXJ0IGNoPU5VTExcbiIpOwoJCXJldHVybjsKCX0KCWlmIChjaC0+bmV0ZGV2ID09IE5VTEwpIHsKCQljdGNfcHJfd2FybigiY2hfYWN0aW9uX3N0YXJ0IGRldj1OVUxMLCBpZD0lc1xuIiwgY2gtPmlkKTsKCQlyZXR1cm47Cgl9CglkZXYgPSBjaC0+bmV0ZGV2OwoKI2lmZGVmIERFQlVHCgljdGNfcHJfZGVidWcoIiVzOiAlcyBjaGFubmVsIHN0YXJ0XG4iLCBkZXYtPm5hbWUsCgkJICAgICAoQ0hBTk5FTF9ESVJFQ1RJT04oY2gtPmZsYWdzKSA9PSBSRUFEKSA/ICJSWCIgOiAiVFgiKTsKI2VuZGlmCgoJaWYgKGNoLT50cmFuc19za2IgIT0gTlVMTCkgewoJCWNsZWFyX25vcm1hbGl6ZWRfY2RhKCZjaC0+Y2N3WzFdKTsKCQlkZXZfa2ZyZWVfc2tiKGNoLT50cmFuc19za2IpOwoJCWNoLT50cmFuc19za2IgPSBOVUxMOwoJfQoJaWYgKENIQU5ORUxfRElSRUNUSU9OKGNoLT5mbGFncykgPT0gUkVBRCkgewoJCWNoLT5jY3dbMV0uY21kX2NvZGUgPSBDQ1dfQ01EX1JFQUQ7CgkJY2gtPmNjd1sxXS5mbGFncyA9IENDV19GTEFHX1NMSTsKCQljaC0+Y2N3WzFdLmNvdW50ID0gMDsKCX0gZWxzZSB7CgkJY2gtPmNjd1sxXS5jbWRfY29kZSA9IENDV19DTURfV1JJVEU7CgkJY2gtPmNjd1sxXS5mbGFncyA9IENDV19GTEFHX1NMSSB8IENDV19GTEFHX0NDOwoJCWNoLT5jY3dbMV0uY291bnQgPSAwOwoJfQoJaWYgKGN0Y19jaGVja2FsbG9jX2J1ZmZlcihjaCwgMCkpIHsKCQljdGNfcHJfbm90aWNlKAoJCQkiJXM6IENvdWxkIG5vdCBhbGxvY2F0ZSAlcyB0cmFuc19za2IsIGRlbGF5aW5nICIKCQkJImFsbG9jYXRpb24gdW50aWwgZmlyc3QgdHJhbnNmZXJcbiIsCgkJCWRldi0+bmFtZSwKCQkJKENIQU5ORUxfRElSRUNUSU9OKGNoLT5mbGFncykgPT0gUkVBRCkgPyAiUlgiIDogIlRYIik7Cgl9CgoJY2gtPmNjd1swXS5jbWRfY29kZSA9IENDV19DTURfUFJFUEFSRTsKCWNoLT5jY3dbMF0uZmxhZ3MgPSBDQ1dfRkxBR19TTEkgfCBDQ1dfRkxBR19DQzsKCWNoLT5jY3dbMF0uY291bnQgPSAwOwoJY2gtPmNjd1swXS5jZGEgPSAwOwoJY2gtPmNjd1syXS5jbWRfY29kZSA9IENDV19DTURfTk9PUDsJLyogam9pbnRlZCBDRSArIERFICovCgljaC0+Y2N3WzJdLmZsYWdzID0gQ0NXX0ZMQUdfU0xJOwoJY2gtPmNjd1syXS5jb3VudCA9IDA7CgljaC0+Y2N3WzJdLmNkYSA9IDA7CgltZW1jcHkoJmNoLT5jY3dbM10sICZjaC0+Y2N3WzBdLCBzaXplb2YgKHN0cnVjdCBjY3cxKSAqIDMpOwoJY2gtPmNjd1s0XS5jZGEgPSAwOwoJY2gtPmNjd1s0XS5mbGFncyAmPSB+Q0NXX0ZMQUdfSURBOwoKCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfU1RBUlRXQUlUKTsKCWZzbV9hZGR0aW1lcigmY2gtPnRpbWVyLCAxMDAwLCBDSF9FVkVOVF9USU1FUiwgY2gpOwoJc3Bpbl9sb2NrX2lycXNhdmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwgc2F2ZWZsYWdzKTsKCXJjID0gY2N3X2RldmljZV9oYWx0KGNoLT5jZGV2LCAodW5zaWduZWQgbG9uZykgY2gpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShnZXRfY2N3ZGV2X2xvY2soY2gtPmNkZXYpLCBzYXZlZmxhZ3MpOwoJaWYgKHJjICE9IDApIHsKCQlpZiAocmMgIT0gLUVCVVNZKQoJCSAgICBmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CgkJY2N3X2NoZWNrX3JldHVybl9jb2RlKGNoLCByYywgImluaXRpYWwgSGFsdElPIik7Cgl9CiNpZmRlZiBERUJVRwoJY3RjX3ByX2RlYnVnKCJjdGM6ICVzKCk6IGxlYXZpbmdcbiIsIF9fZnVuY19fKTsKI2VuZGlmCn0KCi8qKgogKiBTaHV0ZG93biBhIGNoYW5uZWwuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX2hhbHRpbyhmc21faW5zdGFuY2UgKiBmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCXN0cnVjdCBjaGFubmVsICpjaCA9IChzdHJ1Y3QgY2hhbm5lbCAqKSBhcmc7Cgl1bnNpZ25lZCBsb25nIHNhdmVmbGFnczsKCWludCByYzsKCWludCBvbGRzdGF0ZTsKCglEQkZfVEVYVCh0cmFjZSwgMywgX19GVU5DVElPTl9fKTsKCWZzbV9kZWx0aW1lcigmY2gtPnRpbWVyKTsKCWZzbV9hZGR0aW1lcigmY2gtPnRpbWVyLCBDVENfVElNRU9VVF81U0VDLCBDSF9FVkVOVF9USU1FUiwgY2gpOwoJc2F2ZWZsYWdzID0gMDsJLyogYXZvaWRzIGNvbXAgd2FybmluZyB3aXRoCgkJCSAgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKi8KCWlmIChldmVudCA9PSBDSF9FVkVOVF9TVE9QKQkvLyBvbmx5IGZvciBTVE9QIG5vdCB5ZXQgbG9ja2VkCgkJc3Bpbl9sb2NrX2lycXNhdmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwgc2F2ZWZsYWdzKTsKCW9sZHN0YXRlID0gZnNtX2dldHN0YXRlKGZpKTsKCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfVEVSTSk7CglyYyA9IGNjd19kZXZpY2VfaGFsdChjaC0+Y2RldiwgKHVuc2lnbmVkIGxvbmcpIGNoKTsKCWlmIChldmVudCA9PSBDSF9FVkVOVF9TVE9QKQoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwgc2F2ZWZsYWdzKTsKCWlmIChyYyAhPSAwKSB7CgkJaWYgKHJjICE9IC1FQlVTWSkgewoJCSAgICBmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CgkJICAgIGZzbV9uZXdzdGF0ZShmaSwgb2xkc3RhdGUpOwoJCX0KCQljY3dfY2hlY2tfcmV0dXJuX2NvZGUoY2gsIHJjLCAiSGFsdElPIGluIGNoX2FjdGlvbl9oYWx0aW8iKTsKCX0KfQoKLyoqCiAqIEEgY2hhbm5lbCBoYXMgc3VjY2Vzc2Z1bGx5IGJlZW4gaGFsdGVkLgogKiBDbGVhbnVwIGl0J3MgcXVldWUgYW5kIG5vdGlmeSBpbnRlcmZhY2Ugc3RhdGVtYWNoaW5lLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9zdG9wcGVkKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9TVE9QUEVEKTsKCWlmIChjaC0+dHJhbnNfc2tiICE9IE5VTEwpIHsKCQljbGVhcl9ub3JtYWxpemVkX2NkYSgmY2gtPmNjd1sxXSk7CgkJZGV2X2tmcmVlX3NrYihjaC0+dHJhbnNfc2tiKTsKCQljaC0+dHJhbnNfc2tiID0gTlVMTDsKCX0KCWlmIChDSEFOTkVMX0RJUkVDVElPTihjaC0+ZmxhZ3MpID09IFJFQUQpIHsKCQlza2JfcXVldWVfcHVyZ2UoJmNoLT5pb19xdWV1ZSk7CgkJZnNtX2V2ZW50KCgoc3RydWN0IGN0Y19wcml2ICopIGRldi0+cHJpdiktPmZzbSwKCQkJICBERVZfRVZFTlRfUlhET1dOLCBkZXYpOwoJfSBlbHNlIHsKCQljdGNfcHVyZ2Vfc2tiX3F1ZXVlKCZjaC0+aW9fcXVldWUpOwoJCXNwaW5fbG9jaygmY2gtPmNvbGxlY3RfbG9jayk7CgkJY3RjX3B1cmdlX3NrYl9xdWV1ZSgmY2gtPmNvbGxlY3RfcXVldWUpOwoJCWNoLT5jb2xsZWN0X2xlbiA9IDA7CgkJc3Bpbl91bmxvY2soJmNoLT5jb2xsZWN0X2xvY2spOwoJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCSAgREVWX0VWRU5UX1RYRE9XTiwgZGV2KTsKCX0KfQoKLyoqCiAqIEEgc3RvcCBjb21tYW5kIGZyb20gZGV2aWNlIHN0YXRlbWFjaGluZSBhcnJpdmVkIGFuZCB3ZSBhcmUgaW4KICogbm90IG9wZXJhdGlvbmFsIG1vZGUuIFNldCBzdGF0ZSB0byBzdG9wcGVkLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9zdG9wKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9TVE9QUEVEKTsKfQoKLyoqCiAqIEEgbWFjaGluZSBjaGVjayBmb3Igbm8gcGF0aCwgbm90IG9wZXJhdGlvbmFsIHN0YXR1cyBvciBnb25lIGRldmljZSBoYXMKICogaGFwcGVuZWQuCiAqIENsZWFudXAgcXVldWUgYW5kIG5vdGlmeSBpbnRlcmZhY2Ugc3RhdGVtYWNoaW5lLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9mYWlsKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9OT1RPUCk7CglpZiAoQ0hBTk5FTF9ESVJFQ1RJT04oY2gtPmZsYWdzKSA9PSBSRUFEKSB7CgkJc2tiX3F1ZXVlX3B1cmdlKCZjaC0+aW9fcXVldWUpOwoJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCSAgREVWX0VWRU5UX1JYRE9XTiwgZGV2KTsKCX0gZWxzZSB7CgkJY3RjX3B1cmdlX3NrYl9xdWV1ZSgmY2gtPmlvX3F1ZXVlKTsKCQlzcGluX2xvY2soJmNoLT5jb2xsZWN0X2xvY2spOwoJCWN0Y19wdXJnZV9za2JfcXVldWUoJmNoLT5jb2xsZWN0X3F1ZXVlKTsKCQljaC0+Y29sbGVjdF9sZW4gPSAwOwoJCXNwaW5fdW5sb2NrKCZjaC0+Y29sbGVjdF9sb2NrKTsKCQlmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLAoJCQkgIERFVl9FVkVOVF9UWERPV04sIGRldik7Cgl9Cn0KCi8qKgogKiBIYW5kbGUgZXJyb3IgZHVyaW5nIHNldHVwIG9mIGNoYW5uZWwuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX3NldHVwZXJyKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHNldHVwLCAzLCBfX0ZVTkNUSU9OX18pOwoJLyoqCgkgKiBTcGVjaWFsIGNhc2U6IEdvdCBVQ19SQ1JFU0VUIG9uIHNldG1vZGUuCgkgKiBUaGlzIG1lYW5zIHRoYXQgcmVtb3RlIHNpZGUgaXNuJ3Qgc2V0dXAuIEluIHRoaXMgY2FzZQoJICogc2ltcGx5IHJldHJ5IGFmdGVyIHNvbWUgMTAgc2Vjcy4uLgoJICovCglpZiAoKGZzbV9nZXRzdGF0ZShmaSkgPT0gQ0hfU1RBVEVfU0VUVVBXQUlUKSAmJgoJICAgICgoZXZlbnQgPT0gQ0hfRVZFTlRfVUNfUkNSRVNFVCkgfHwKCSAgICAgKGV2ZW50ID09IENIX0VWRU5UX1VDX1JTUkVTRVQpKSkgewoJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfU1RBUlRSRVRSWSk7CgkJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJCWZzbV9hZGR0aW1lcigmY2gtPnRpbWVyLCBDVENfVElNRU9VVF81U0VDLCBDSF9FVkVOVF9USU1FUiwgY2gpOwoJCWlmIChDSEFOTkVMX0RJUkVDVElPTihjaC0+ZmxhZ3MpID09IFJFQUQpIHsKCQkJaW50IHJjID0gY2N3X2RldmljZV9oYWx0KGNoLT5jZGV2LCAodW5zaWduZWQgbG9uZykgY2gpOwoJCQlpZiAocmMgIT0gMCkKCQkJCWNjd19jaGVja19yZXR1cm5fY29kZSgKCQkJCQljaCwgcmMsICJIYWx0SU8gaW4gY2hfYWN0aW9uX3NldHVwZXJyIik7CgkJfQoJCXJldHVybjsKCX0KCgljdGNfcHJfZGVidWcoIiVzOiBFcnJvciAlcyBkdXJpbmcgJXMgY2hhbm5lbCBzZXR1cCBzdGF0ZT0lc1xuIiwKCQkgICAgIGRldi0+bmFtZSwgY2hfZXZlbnRfbmFtZXNbZXZlbnRdLAoJCSAgICAgKENIQU5ORUxfRElSRUNUSU9OKGNoLT5mbGFncykgPT0gUkVBRCkgPyAiUlgiIDogIlRYIiwKCQkgICAgIGZzbV9nZXRzdGF0ZV9zdHIoZmkpKTsKCWlmIChDSEFOTkVMX0RJUkVDVElPTihjaC0+ZmxhZ3MpID09IFJFQUQpIHsKCQlmc21fbmV3c3RhdGUoZmksIENIX1NUQVRFX1JYRVJSKTsKCQlmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLAoJCQkgIERFVl9FVkVOVF9SWERPV04sIGRldik7Cgl9IGVsc2UgewoJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfVFhFUlIpOwoJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCSAgREVWX0VWRU5UX1RYRE9XTiwgZGV2KTsKCX0KfQoKLyoqCiAqIFJlc3RhcnQgYSBjaGFubmVsIGFmdGVyIGFuIGVycm9yLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9yZXN0YXJ0KGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJdW5zaWduZWQgbG9uZyBzYXZlZmxhZ3M7CglpbnQgb2xkc3RhdGU7CglpbnQgcmM7CgoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJY3RjX3ByX2RlYnVnKCIlczogJXMgY2hhbm5lbCByZXN0YXJ0XG4iLCBkZXYtPm5hbWUsCgkJICAgICAoQ0hBTk5FTF9ESVJFQ1RJT04oY2gtPmZsYWdzKSA9PSBSRUFEKSA/ICJSWCIgOiAiVFgiKTsKCWZzbV9hZGR0aW1lcigmY2gtPnRpbWVyLCBDVENfVElNRU9VVF81U0VDLCBDSF9FVkVOVF9USU1FUiwgY2gpOwoJb2xkc3RhdGUgPSBmc21fZ2V0c3RhdGUoZmkpOwoJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9TVEFSVFdBSVQpOwoJc2F2ZWZsYWdzID0gMDsJLyogYXZvaWRzIGNvbXBpbGVyIHdhcm5pbmcgd2l0aAoJCQkgICBzcGluX3VubG9ja19pcnFyZXN0b3JlICovCglpZiAoZXZlbnQgPT0gQ0hfRVZFTlRfVElNRVIpCS8vIG9ubHkgZm9yIHRpbWVyIG5vdCB5ZXQgbG9ja2VkCgkJc3Bpbl9sb2NrX2lycXNhdmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwgc2F2ZWZsYWdzKTsKCXJjID0gY2N3X2RldmljZV9oYWx0KGNoLT5jZGV2LCAodW5zaWduZWQgbG9uZykgY2gpOwoJaWYgKGV2ZW50ID09IENIX0VWRU5UX1RJTUVSKQoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwgc2F2ZWZsYWdzKTsKCWlmIChyYyAhPSAwKSB7CgkJaWYgKHJjICE9IC1FQlVTWSkgewoJCSAgICBmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CgkJICAgIGZzbV9uZXdzdGF0ZShmaSwgb2xkc3RhdGUpOwoJCX0KCQljY3dfY2hlY2tfcmV0dXJuX2NvZGUoY2gsIHJjLCAiSGFsdElPIGluIGNoX2FjdGlvbl9yZXN0YXJ0Iik7Cgl9Cn0KCi8qKgogKiBIYW5kbGUgZXJyb3IgZHVyaW5nIFJYIGluaXRpYWwgaGFuZHNoYWtlIChleGNoYW5nZSBvZgogKiAwLWxlbmd0aCBibG9jayBoZWFkZXIpCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX3J4aW5pdGVycihmc21faW5zdGFuY2UgKiBmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCXN0cnVjdCBjaGFubmVsICpjaCA9IChzdHJ1Y3QgY2hhbm5lbCAqKSBhcmc7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gY2gtPm5ldGRldjsKCglEQkZfVEVYVChzZXR1cCwgMywgX19GVU5DVElPTl9fKTsKCWlmIChldmVudCA9PSBDSF9FVkVOVF9USU1FUikgewoJCWZzbV9kZWx0aW1lcigmY2gtPnRpbWVyKTsKCQljdGNfcHJfZGVidWcoIiVzOiBUaW1lb3V0IGR1cmluZyBSWCBpbml0IGhhbmRzaGFrZVxuIiwgZGV2LT5uYW1lKTsKCQlpZiAoY2gtPnJldHJ5KysgPCAzKQoJCQljaF9hY3Rpb25fcmVzdGFydChmaSwgZXZlbnQsIGFyZyk7CgkJZWxzZSB7CgkJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfUlhFUlIpOwoJCQlmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLAoJCQkJICBERVZfRVZFTlRfUlhET1dOLCBkZXYpOwoJCX0KCX0gZWxzZQoJCWN0Y19wcl93YXJuKCIlczogRXJyb3IgZHVyaW5nIFJYIGluaXQgaGFuZHNoYWtlXG4iLCBkZXYtPm5hbWUpOwp9CgovKioKICogTm90aWZ5IGRldmljZSBzdGF0ZW1hY2hpbmUgaWYgd2UgZ2F2ZSB1cCBpbml0aWFsaXphdGlvbgogKiBvZiBSWCBjaGFubmVsLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9yeGluaXRmYWlsKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHNldHVwLCAzLCBfX0ZVTkNUSU9OX18pOwoJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9SWEVSUik7CgljdGNfcHJfd2FybigiJXM6IFJYIGluaXRpYWxpemF0aW9uIGZhaWxlZFxuIiwgZGV2LT5uYW1lKTsKCWN0Y19wcl93YXJuKCIlczogUlggPC0+IFJYIGNvbm5lY3Rpb24gZGV0ZWN0ZWRcbiIsIGRldi0+bmFtZSk7Cglmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLCBERVZfRVZFTlRfUlhET1dOLCBkZXYpOwp9CgovKioKICogSGFuZGxlIFJYIFVuaXQgY2hlY2sgcmVtb3RlIHJlc2V0IChyZW1vdGUgZGlzY29ubmVjdGVkKQogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYSBjaGFubmVsIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gY2hhbm5lbCAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmNoX2FjdGlvbl9yeGRpc2MoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7CglzdHJ1Y3QgY2hhbm5lbCAqY2ggPSAoc3RydWN0IGNoYW5uZWwgKikgYXJnOwoJc3RydWN0IGNoYW5uZWwgKmNoMjsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJY3RjX3ByX2RlYnVnKCIlczogR290IHJlbW90ZSBkaXNjb25uZWN0LCByZS1pbml0aWFsaXppbmcgLi4uXG4iLAoJCSAgICAgZGV2LT5uYW1lKTsKCgkvKioKCSAqIE5vdGlmeSBkZXZpY2Ugc3RhdGVtYWNoaW5lCgkgKi8KCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sIERFVl9FVkVOVF9SWERPV04sIGRldik7Cglmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLCBERVZfRVZFTlRfVFhET1dOLCBkZXYpOwoKCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfRFRFUk0pOwoJY2gyID0gKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+Y2hhbm5lbFtXUklURV07Cglmc21fbmV3c3RhdGUoY2gyLT5mc20sIENIX1NUQVRFX0RURVJNKTsKCgljY3dfZGV2aWNlX2hhbHQoY2gtPmNkZXYsICh1bnNpZ25lZCBsb25nKSBjaCk7CgljY3dfZGV2aWNlX2hhbHQoY2gyLT5jZGV2LCAodW5zaWduZWQgbG9uZykgY2gyKTsKfQoKLyoqCiAqIEhhbmRsZSBlcnJvciBkdXJpbmcgVFggY2hhbm5lbCBpbml0aWFsaXphdGlvbi4KICoKICogQHBhcmFtIGZpICAgIEFuIGluc3RhbmNlIG9mIGEgY2hhbm5lbCBzdGF0ZW1hY2hpbmUuCiAqIEBwYXJhbSBldmVudCBUaGUgZXZlbnQsIGp1c3QgaGFwcGVuZWQuCiAqIEBwYXJhbSBhcmcgICBHZW5lcmljIHBvaW50ZXIsIGNhc3RlZCBmcm9tIGNoYW5uZWwgKiB1cG9uIGNhbGwuCiAqLwpzdGF0aWMgdm9pZApjaF9hY3Rpb25fdHhpbml0ZXJyKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gKHN0cnVjdCBjaGFubmVsICopIGFyZzsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSBjaC0+bmV0ZGV2OwoKCURCRl9URVhUKHNldHVwLCAyLCBfX0ZVTkNUSU9OX18pOwoJaWYgKGV2ZW50ID09IENIX0VWRU5UX1RJTUVSKSB7CgkJZnNtX2RlbHRpbWVyKCZjaC0+dGltZXIpOwoJCWN0Y19wcl9kZWJ1ZygiJXM6IFRpbWVvdXQgZHVyaW5nIFRYIGluaXQgaGFuZHNoYWtlXG4iLCBkZXYtPm5hbWUpOwoJCWlmIChjaC0+cmV0cnkrKyA8IDMpCgkJCWNoX2FjdGlvbl9yZXN0YXJ0KGZpLCBldmVudCwgYXJnKTsKCQllbHNlIHsKCQkJZnNtX25ld3N0YXRlKGZpLCBDSF9TVEFURV9UWEVSUik7CgkJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCQkgIERFVl9FVkVOVF9UWERPV04sIGRldik7CgkJfQoJfSBlbHNlCgkJY3RjX3ByX3dhcm4oIiVzOiBFcnJvciBkdXJpbmcgVFggaW5pdCBoYW5kc2hha2VcbiIsIGRldi0+bmFtZSk7Cn0KCi8qKgogKiBIYW5kbGUgVFggdGltZW91dCBieSByZXRyeWluZyBvcGVyYXRpb24uCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX3R4cmV0cnkoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7CglzdHJ1Y3QgY2hhbm5lbCAqY2ggPSAoc3RydWN0IGNoYW5uZWwgKikgYXJnOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IGNoLT5uZXRkZXY7Cgl1bnNpZ25lZCBsb25nIHNhdmVmbGFnczsKCglEQkZfVEVYVCh0cmFjZSwgNCwgX19GVU5DVElPTl9fKTsKCWZzbV9kZWx0aW1lcigmY2gtPnRpbWVyKTsKCWlmIChjaC0+cmV0cnkrKyA+IDMpIHsKCQljdGNfcHJfZGVidWcoIiVzOiBUWCByZXRyeSBmYWlsZWQsIHJlc3RhcnRpbmcgY2hhbm5lbFxuIiwKCQkJICAgICBkZXYtPm5hbWUpOwoJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCSAgREVWX0VWRU5UX1RYRE9XTiwgZGV2KTsKCQljaF9hY3Rpb25fcmVzdGFydChmaSwgZXZlbnQsIGFyZyk7Cgl9IGVsc2UgewoJCXN0cnVjdCBza19idWZmICpza2I7CgoJCWN0Y19wcl9kZWJ1ZygiJXM6IFRYIHJldHJ5ICVkXG4iLCBkZXYtPm5hbWUsIGNoLT5yZXRyeSk7CgkJaWYgKChza2IgPSBza2JfcGVlaygmY2gtPmlvX3F1ZXVlKSkpIHsKCQkJaW50IHJjID0gMDsKCgkJCWNsZWFyX25vcm1hbGl6ZWRfY2RhKCZjaC0+Y2N3WzRdKTsKCQkJY2gtPmNjd1s0XS5jb3VudCA9IHNrYi0+bGVuOwoJCQlpZiAoc2V0X25vcm1hbGl6ZWRfY2RhKCZjaC0+Y2N3WzRdLCBza2ItPmRhdGEpKSB7CgkJCQljdGNfcHJfZGVidWcoCgkJCQkJIiVzOiBJREFMIGFsbG9jIGZhaWxlZCwgY2hhbiByZXN0YXJ0XG4iLAoJCQkJCWRldi0+bmFtZSk7CgkJCQlmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLAoJCQkJCSAgREVWX0VWRU5UX1RYRE9XTiwgZGV2KTsKCQkJCWNoX2FjdGlvbl9yZXN0YXJ0KGZpLCBldmVudCwgYXJnKTsKCQkJCXJldHVybjsKCQkJfQoJCQlmc21fYWRkdGltZXIoJmNoLT50aW1lciwgMTAwMCwgQ0hfRVZFTlRfVElNRVIsIGNoKTsKCQkJc2F2ZWZsYWdzID0gMDsJLyogYXZvaWRzIGNvbXBpbGVyIHdhcm5pbmcgd2l0aAoJCQkJCSAgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUgKi8KCQkJaWYgKGV2ZW50ID09IENIX0VWRU5UX1RJTUVSKSAvLyBvbmx5IGZvciBUSU1FUiBub3QgeWV0IGxvY2tlZAoJCQkJc3Bpbl9sb2NrX2lycXNhdmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwKCQkJCQkJICBzYXZlZmxhZ3MpOwoJCQlyYyA9IGNjd19kZXZpY2Vfc3RhcnQoY2gtPmNkZXYsICZjaC0+Y2N3WzNdLAoJCQkJCSAgICAgICh1bnNpZ25lZCBsb25nKSBjaCwgMHhmZiwgMCk7CgkJCWlmIChldmVudCA9PSBDSF9FVkVOVF9USU1FUikKCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwKCQkJCQkJICAgICAgIHNhdmVmbGFncyk7CgkJCWlmIChyYyAhPSAwKSB7CgkJCQlmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CgkJCQljY3dfY2hlY2tfcmV0dXJuX2NvZGUoY2gsIHJjLCAiVFggaW4gY2hfYWN0aW9uX3R4cmV0cnkiKTsKCQkJCWN0Y19wdXJnZV9za2JfcXVldWUoJmNoLT5pb19xdWV1ZSk7CgkJCX0KCQl9Cgl9Cgp9CgovKioKICogSGFuZGxlIGZhdGFsIGVycm9ycyBkdXJpbmcgYW4gSS9PIGNvbW1hbmQuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhIGNoYW5uZWwgc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBjaGFubmVsICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKY2hfYWN0aW9uX2lvZmF0YWwoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7CglzdHJ1Y3QgY2hhbm5lbCAqY2ggPSAoc3RydWN0IGNoYW5uZWwgKikgYXJnOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IGNoLT5uZXRkZXY7CgoJREJGX1RFWFQodHJhY2UsIDMsIF9fRlVOQ1RJT05fXyk7Cglmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CglpZiAoQ0hBTk5FTF9ESVJFQ1RJT04oY2gtPmZsYWdzKSA9PSBSRUFEKSB7CgkJY3RjX3ByX2RlYnVnKCIlczogUlggSS9PIGVycm9yXG4iLCBkZXYtPm5hbWUpOwoJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfUlhFUlIpOwoJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCSAgREVWX0VWRU5UX1JYRE9XTiwgZGV2KTsKCX0gZWxzZSB7CgkJY3RjX3ByX2RlYnVnKCIlczogVFggSS9PIGVycm9yXG4iLCBkZXYtPm5hbWUpOwoJCWZzbV9uZXdzdGF0ZShmaSwgQ0hfU1RBVEVfVFhFUlIpOwoJCWZzbV9ldmVudCgoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5mc20sCgkJCSAgREVWX0VWRU5UX1RYRE9XTiwgZGV2KTsKCX0KfQoKc3RhdGljIHZvaWQKY2hfYWN0aW9uX3JlaW5pdChmc21faW5zdGFuY2UgKmZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewogCXN0cnVjdCBjaGFubmVsICpjaCA9IChzdHJ1Y3QgY2hhbm5lbCAqKWFyZzsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gY2gtPm5ldGRldjsKIAlzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSBkZXYtPnByaXY7CgoJREJGX1RFWFQodHJhY2UsIDQsIF9fRlVOQ1RJT05fXyk7CiAJY2hfYWN0aW9uX2lvZmF0YWwoZmksIGV2ZW50LCBhcmcpOwogCWZzbV9hZGR0aW1lcigmcHJpdnB0ci0+cmVzdGFydF90aW1lciwgMTAwMCwgREVWX0VWRU5UX1JFU1RBUlQsIGRldik7Cn0KCi8qKgogKiBUaGUgc3RhdGVtYWNoaW5lIGZvciBhIGNoYW5uZWwuCiAqLwpzdGF0aWMgY29uc3QgZnNtX25vZGUgY2hfZnNtW10gPSB7Cgl7Q0hfU1RBVEVfU1RPUFBFRCwgICAgQ0hfRVZFTlRfU1RPUCwgICAgICAgZnNtX2FjdGlvbl9ub3AgICAgICAgfSwKCXtDSF9TVEFURV9TVE9QUEVELCAgICBDSF9FVkVOVF9TVEFSVCwgICAgICBjaF9hY3Rpb25fc3RhcnQgICAgICB9LAoJe0NIX1NUQVRFX1NUT1BQRUQsICAgIENIX0VWRU5UX0ZJTlNUQVQsICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfU1RPUFBFRCwgICAgQ0hfRVZFTlRfTUNfRkFJTCwgICAgZnNtX2FjdGlvbl9ub3AgICAgICAgfSwKCgl7Q0hfU1RBVEVfTk9UT1AsICAgICAgQ0hfRVZFTlRfU1RPUCwgICAgICAgY2hfYWN0aW9uX3N0b3AgICAgICAgfSwKCXtDSF9TVEFURV9OT1RPUCwgICAgICBDSF9FVkVOVF9TVEFSVCwgICAgICBmc21fYWN0aW9uX25vcCAgICAgICB9LAoJe0NIX1NUQVRFX05PVE9QLCAgICAgIENIX0VWRU5UX0ZJTlNUQVQsICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfTk9UT1AsICAgICAgQ0hfRVZFTlRfTUNfRkFJTCwgICAgZnNtX2FjdGlvbl9ub3AgICAgICAgfSwKCXtDSF9TVEFURV9OT1RPUCwgICAgICBDSF9FVkVOVF9NQ19HT09ELCAgICBjaF9hY3Rpb25fc3RhcnQgICAgICB9LAoKCXtDSF9TVEFURV9TVEFSVFdBSVQsICBDSF9FVkVOVF9TVE9QLCAgICAgICBjaF9hY3Rpb25faGFsdGlvICAgICB9LAoJe0NIX1NUQVRFX1NUQVJUV0FJVCwgIENIX0VWRU5UX1NUQVJULCAgICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfU1RBUlRXQUlULCAgQ0hfRVZFTlRfRklOU1RBVCwgICAgY2hfYWN0aW9uX3NldG1vZGUgICAgfSwKCXtDSF9TVEFURV9TVEFSVFdBSVQsICBDSF9FVkVOVF9USU1FUiwgICAgICBjaF9hY3Rpb25fc2V0dXBlcnIgICB9LAoJe0NIX1NUQVRFX1NUQVJUV0FJVCwgIENIX0VWRU5UX0lPX0VOT0RFViwgIGNoX2FjdGlvbl9pb2ZhdGFsICAgIH0sCgl7Q0hfU1RBVEVfU1RBUlRXQUlULCAgQ0hfRVZFTlRfSU9fRUlPLCAgICAgY2hfYWN0aW9uX3JlaW5pdCAgICAgfSwKCXtDSF9TVEFURV9TVEFSVFdBSVQsICBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoKCXtDSF9TVEFURV9TVEFSVFJFVFJZLCBDSF9FVkVOVF9TVE9QLCAgICAgICBjaF9hY3Rpb25faGFsdGlvICAgICB9LAoJe0NIX1NUQVRFX1NUQVJUUkVUUlksIENIX0VWRU5UX1RJTUVSLCAgICAgIGNoX2FjdGlvbl9zZXRtb2RlICAgIH0sCgl7Q0hfU1RBVEVfU1RBUlRSRVRSWSwgQ0hfRVZFTlRfRklOU1RBVCwgICAgZnNtX2FjdGlvbl9ub3AgICAgICAgfSwKCXtDSF9TVEFURV9TVEFSVFJFVFJZLCBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoKCXtDSF9TVEFURV9TRVRVUFdBSVQsICBDSF9FVkVOVF9TVE9QLCAgICAgICBjaF9hY3Rpb25faGFsdGlvICAgICB9LAoJe0NIX1NUQVRFX1NFVFVQV0FJVCwgIENIX0VWRU5UX1NUQVJULCAgICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfU0VUVVBXQUlULCAgQ0hfRVZFTlRfRklOU1RBVCwgICAgY2hfYWN0aW9uX2ZpcnN0aW8gICAgfSwKCXtDSF9TVEFURV9TRVRVUFdBSVQsICBDSF9FVkVOVF9VQ19SQ1JFU0VULCBjaF9hY3Rpb25fc2V0dXBlcnIgICB9LAoJe0NIX1NUQVRFX1NFVFVQV0FJVCwgIENIX0VWRU5UX1VDX1JTUkVTRVQsIGNoX2FjdGlvbl9zZXR1cGVyciAgIH0sCgl7Q0hfU1RBVEVfU0VUVVBXQUlULCAgQ0hfRVZFTlRfVElNRVIsICAgICAgY2hfYWN0aW9uX3NldG1vZGUgICAgfSwKCXtDSF9TVEFURV9TRVRVUFdBSVQsICBDSF9FVkVOVF9JT19FTk9ERVYsICBjaF9hY3Rpb25faW9mYXRhbCAgICB9LAoJe0NIX1NUQVRFX1NFVFVQV0FJVCwgIENIX0VWRU5UX0lPX0VJTywgICAgIGNoX2FjdGlvbl9yZWluaXQgICAgIH0sCgl7Q0hfU1RBVEVfU0VUVVBXQUlULCAgQ0hfRVZFTlRfTUNfRkFJTCwgICAgY2hfYWN0aW9uX2ZhaWwgICAgICAgfSwKCgl7Q0hfU1RBVEVfUlhJTklULCAgICAgQ0hfRVZFTlRfU1RPUCwgICAgICAgY2hfYWN0aW9uX2hhbHRpbyAgICAgfSwKCXtDSF9TVEFURV9SWElOSVQsICAgICBDSF9FVkVOVF9TVEFSVCwgICAgICBmc21fYWN0aW9uX25vcCAgICAgICB9LAoJe0NIX1NUQVRFX1JYSU5JVCwgICAgIENIX0VWRU5UX0ZJTlNUQVQsICAgIGNoX2FjdGlvbl9yeGlkbGUgICAgIH0sCgl7Q0hfU1RBVEVfUlhJTklULCAgICAgQ0hfRVZFTlRfVUNfUkNSRVNFVCwgY2hfYWN0aW9uX3J4aW5pdGVyciAgfSwKCXtDSF9TVEFURV9SWElOSVQsICAgICBDSF9FVkVOVF9VQ19SU1JFU0VULCBjaF9hY3Rpb25fcnhpbml0ZXJyICB9LAoJe0NIX1NUQVRFX1JYSU5JVCwgICAgIENIX0VWRU5UX1RJTUVSLCAgICAgIGNoX2FjdGlvbl9yeGluaXRlcnIgIH0sCgl7Q0hfU1RBVEVfUlhJTklULCAgICAgQ0hfRVZFTlRfQVRUTkJVU1ksICAgY2hfYWN0aW9uX3J4aW5pdGZhaWwgfSwKCXtDSF9TVEFURV9SWElOSVQsICAgICBDSF9FVkVOVF9JT19FTk9ERVYsICBjaF9hY3Rpb25faW9mYXRhbCAgICB9LAoJe0NIX1NUQVRFX1JYSU5JVCwgICAgIENIX0VWRU5UX0lPX0VJTywgICAgIGNoX2FjdGlvbl9yZWluaXQgICAgIH0sCgl7Q0hfU1RBVEVfUlhJTklULCAgICAgQ0hfRVZFTlRfVUNfWkVSTywgICAgY2hfYWN0aW9uX2ZpcnN0aW8gICAgfSwKCXtDSF9TVEFURV9SWElOSVQsICAgICBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoKCXtDSF9TVEFURV9SWElETEUsICAgICBDSF9FVkVOVF9TVE9QLCAgICAgICBjaF9hY3Rpb25faGFsdGlvICAgICB9LAoJe0NIX1NUQVRFX1JYSURMRSwgICAgIENIX0VWRU5UX1NUQVJULCAgICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfUlhJRExFLCAgICAgQ0hfRVZFTlRfRklOU1RBVCwgICAgY2hfYWN0aW9uX3J4ICAgICAgICAgfSwKCXtDSF9TVEFURV9SWElETEUsICAgICBDSF9FVkVOVF9VQ19SQ1JFU0VULCBjaF9hY3Rpb25fcnhkaXNjICAgICB9LAovLyAgICAgIHtDSF9TVEFURV9SWElETEUsICAgICBDSF9FVkVOVF9VQ19SU1JFU0VULCBjaF9hY3Rpb25fcnhyZXRyeSAgICB9LAoJe0NIX1NUQVRFX1JYSURMRSwgICAgIENIX0VWRU5UX0lPX0VOT0RFViwgIGNoX2FjdGlvbl9pb2ZhdGFsICAgIH0sCgl7Q0hfU1RBVEVfUlhJRExFLCAgICAgQ0hfRVZFTlRfSU9fRUlPLCAgICAgY2hfYWN0aW9uX3JlaW5pdCAgICAgfSwKCXtDSF9TVEFURV9SWElETEUsICAgICBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoJe0NIX1NUQVRFX1JYSURMRSwgICAgIENIX0VWRU5UX1VDX1pFUk8sICAgIGNoX2FjdGlvbl9yeCAgICAgICAgIH0sCgoJe0NIX1NUQVRFX1RYSU5JVCwgICAgIENIX0VWRU5UX1NUT1AsICAgICAgIGNoX2FjdGlvbl9oYWx0aW8gICAgIH0sCgl7Q0hfU1RBVEVfVFhJTklULCAgICAgQ0hfRVZFTlRfU1RBUlQsICAgICAgZnNtX2FjdGlvbl9ub3AgICAgICAgfSwKCXtDSF9TVEFURV9UWElOSVQsICAgICBDSF9FVkVOVF9GSU5TVEFULCAgICBjaF9hY3Rpb25fdHhpZGxlICAgICB9LAoJe0NIX1NUQVRFX1RYSU5JVCwgICAgIENIX0VWRU5UX1VDX1JDUkVTRVQsIGNoX2FjdGlvbl90eGluaXRlcnIgIH0sCgl7Q0hfU1RBVEVfVFhJTklULCAgICAgQ0hfRVZFTlRfVUNfUlNSRVNFVCwgY2hfYWN0aW9uX3R4aW5pdGVyciAgfSwKCXtDSF9TVEFURV9UWElOSVQsICAgICBDSF9FVkVOVF9USU1FUiwgICAgICBjaF9hY3Rpb25fdHhpbml0ZXJyICB9LAoJe0NIX1NUQVRFX1RYSU5JVCwgICAgIENIX0VWRU5UX0lPX0VOT0RFViwgIGNoX2FjdGlvbl9pb2ZhdGFsICAgIH0sCgl7Q0hfU1RBVEVfVFhJTklULCAgICAgQ0hfRVZFTlRfSU9fRUlPLCAgICAgY2hfYWN0aW9uX3JlaW5pdCAgICAgfSwKCXtDSF9TVEFURV9UWElOSVQsICAgICBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoKCXtDSF9TVEFURV9UWElETEUsICAgICBDSF9FVkVOVF9TVE9QLCAgICAgICBjaF9hY3Rpb25faGFsdGlvICAgICB9LAoJe0NIX1NUQVRFX1RYSURMRSwgICAgIENIX0VWRU5UX1NUQVJULCAgICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfVFhJRExFLCAgICAgQ0hfRVZFTlRfRklOU1RBVCwgICAgY2hfYWN0aW9uX2ZpcnN0aW8gICAgfSwKCXtDSF9TVEFURV9UWElETEUsICAgICBDSF9FVkVOVF9VQ19SQ1JFU0VULCBmc21fYWN0aW9uX25vcCAgICAgICB9LAoJe0NIX1NUQVRFX1RYSURMRSwgICAgIENIX0VWRU5UX1VDX1JTUkVTRVQsIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfVFhJRExFLCAgICAgQ0hfRVZFTlRfSU9fRU5PREVWLCAgY2hfYWN0aW9uX2lvZmF0YWwgICAgfSwKCXtDSF9TVEFURV9UWElETEUsICAgICBDSF9FVkVOVF9JT19FSU8sICAgICBjaF9hY3Rpb25fcmVpbml0ICAgICB9LAoJe0NIX1NUQVRFX1RYSURMRSwgICAgIENIX0VWRU5UX01DX0ZBSUwsICAgIGNoX2FjdGlvbl9mYWlsICAgICAgIH0sCgoJe0NIX1NUQVRFX1RFUk0sICAgICAgIENIX0VWRU5UX1NUT1AsICAgICAgIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfVEVSTSwgICAgICAgQ0hfRVZFTlRfU1RBUlQsICAgICAgY2hfYWN0aW9uX3Jlc3RhcnQgICAgfSwKCXtDSF9TVEFURV9URVJNLCAgICAgICBDSF9FVkVOVF9GSU5TVEFULCAgICBjaF9hY3Rpb25fc3RvcHBlZCAgICB9LAoJe0NIX1NUQVRFX1RFUk0sICAgICAgIENIX0VWRU5UX1VDX1JDUkVTRVQsIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfVEVSTSwgICAgICAgQ0hfRVZFTlRfVUNfUlNSRVNFVCwgZnNtX2FjdGlvbl9ub3AgICAgICAgfSwKCXtDSF9TVEFURV9URVJNLCAgICAgICBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoKCXtDSF9TVEFURV9EVEVSTSwgICAgICBDSF9FVkVOVF9TVE9QLCAgICAgICBjaF9hY3Rpb25faGFsdGlvICAgICB9LAoJe0NIX1NUQVRFX0RURVJNLCAgICAgIENIX0VWRU5UX1NUQVJULCAgICAgIGNoX2FjdGlvbl9yZXN0YXJ0ICAgIH0sCgl7Q0hfU1RBVEVfRFRFUk0sICAgICAgQ0hfRVZFTlRfRklOU1RBVCwgICAgY2hfYWN0aW9uX3NldG1vZGUgICAgfSwKCXtDSF9TVEFURV9EVEVSTSwgICAgICBDSF9FVkVOVF9VQ19SQ1JFU0VULCBmc21fYWN0aW9uX25vcCAgICAgICB9LAoJe0NIX1NUQVRFX0RURVJNLCAgICAgIENIX0VWRU5UX1VDX1JTUkVTRVQsIGZzbV9hY3Rpb25fbm9wICAgICAgIH0sCgl7Q0hfU1RBVEVfRFRFUk0sICAgICAgQ0hfRVZFTlRfTUNfRkFJTCwgICAgY2hfYWN0aW9uX2ZhaWwgICAgICAgfSwKCgl7Q0hfU1RBVEVfVFgsICAgICAgICAgQ0hfRVZFTlRfU1RPUCwgICAgICAgY2hfYWN0aW9uX2hhbHRpbyAgICAgfSwKCXtDSF9TVEFURV9UWCwgICAgICAgICBDSF9FVkVOVF9TVEFSVCwgICAgICBmc21fYWN0aW9uX25vcCAgICAgICB9LAoJe0NIX1NUQVRFX1RYLCAgICAgICAgIENIX0VWRU5UX0ZJTlNUQVQsICAgIGNoX2FjdGlvbl90eGRvbmUgICAgIH0sCgl7Q0hfU1RBVEVfVFgsICAgICAgICAgQ0hfRVZFTlRfVUNfUkNSRVNFVCwgY2hfYWN0aW9uX3R4cmV0cnkgICAgfSwKCXtDSF9TVEFURV9UWCwgICAgICAgICBDSF9FVkVOVF9VQ19SU1JFU0VULCBjaF9hY3Rpb25fdHhyZXRyeSAgICB9LAoJe0NIX1NUQVRFX1RYLCAgICAgICAgIENIX0VWRU5UX1RJTUVSLCAgICAgIGNoX2FjdGlvbl90eHJldHJ5ICAgIH0sCgl7Q0hfU1RBVEVfVFgsICAgICAgICAgQ0hfRVZFTlRfSU9fRU5PREVWLCAgY2hfYWN0aW9uX2lvZmF0YWwgICAgfSwKCXtDSF9TVEFURV9UWCwgICAgICAgICBDSF9FVkVOVF9JT19FSU8sICAgICBjaF9hY3Rpb25fcmVpbml0ICAgICB9LAoJe0NIX1NUQVRFX1RYLCAgICAgICAgIENIX0VWRU5UX01DX0ZBSUwsICAgIGNoX2FjdGlvbl9mYWlsICAgICAgIH0sCgoJe0NIX1NUQVRFX1JYRVJSLCAgICAgIENIX0VWRU5UX1NUT1AsICAgICAgIGNoX2FjdGlvbl9oYWx0aW8gICAgIH0sCgl7Q0hfU1RBVEVfVFhFUlIsICAgICAgQ0hfRVZFTlRfU1RPUCwgICAgICAgY2hfYWN0aW9uX2hhbHRpbyAgICAgfSwKCXtDSF9TVEFURV9UWEVSUiwgICAgICBDSF9FVkVOVF9NQ19GQUlMLCAgICBjaF9hY3Rpb25fZmFpbCAgICAgICB9LAoJe0NIX1NUQVRFX1JYRVJSLCAgICAgIENIX0VWRU5UX01DX0ZBSUwsICAgIGNoX2FjdGlvbl9mYWlsICAgICAgIH0sCn07CgpzdGF0aWMgY29uc3QgaW50IENIX0ZTTV9MRU4gPSBzaXplb2YgKGNoX2ZzbSkgLyBzaXplb2YgKGZzbV9ub2RlKTsKCi8qKgogKiBGdW5jdGlvbnMgcmVsYXRlZCB0byBzZXR1cCBhbmQgZGV2aWNlIGRldGVjdGlvbi4KICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIGlubGluZSBpbnQKbGVzc190aGFuKGNoYXIgKmlkMSwgY2hhciAqaWQyKQp7CglpbnQgZGV2MSwgZGV2MiwgaTsKCglmb3IgKGkgPSAwOyBpIDwgNTsgaSsrKSB7CgkJaWQxKys7CgkJaWQyKys7Cgl9CglkZXYxID0gc2ltcGxlX3N0cnRvdWwoaWQxLCAmaWQxLCAxNik7CglkZXYyID0gc2ltcGxlX3N0cnRvdWwoaWQyLCAmaWQyLCAxNik7CgoJcmV0dXJuIChkZXYxIDwgZGV2Mik7Cn0KCi8qKgogKiBBZGQgYSBuZXcgY2hhbm5lbCB0byB0aGUgbGlzdCBvZiBjaGFubmVscy4KICogS2VlcHMgdGhlIGNoYW5uZWwgbGlzdCBzb3J0ZWQuCiAqCiAqIEBwYXJhbSBjZGV2ICBUaGUgY2N3X2RldmljZSB0byBiZSBhZGRlZC4KICogQHBhcmFtIHR5cGUgIFRoZSB0eXBlIGNsYXNzIG9mIHRoZSBuZXcgY2hhbm5lbC4KICoKICogQHJldHVybiAwIG9uIHN1Y2Nlc3MsICEwIG9uIGVycm9yLgogKi8Kc3RhdGljIGludAphZGRfY2hhbm5lbChzdHJ1Y3QgY2N3X2RldmljZSAqY2RldiwgZW51bSBjaGFubmVsX3R5cGVzIHR5cGUpCnsKCXN0cnVjdCBjaGFubmVsICoqYyA9ICZjaGFubmVsczsKCXN0cnVjdCBjaGFubmVsICpjaDsKCglEQkZfVEVYVCh0cmFjZSwgMiwgX19GVU5DVElPTl9fKTsKCWlmICgoY2ggPQoJICAgICAoc3RydWN0IGNoYW5uZWwgKikga21hbGxvYyhzaXplb2YgKHN0cnVjdCBjaGFubmVsKSwKCQkJCQlHRlBfS0VSTkVMKSkgPT0gTlVMTCkgewoJCWN0Y19wcl93YXJuKCJjdGM6IE91dCBvZiBtZW1vcnkgaW4gYWRkX2NoYW5uZWxcbiIpOwoJCXJldHVybiAtMTsKCX0KCW1lbXNldChjaCwgMCwgc2l6ZW9mIChzdHJ1Y3QgY2hhbm5lbCkpOwoJaWYgKChjaC0+Y2N3ID0ga21hbGxvYyg4KnNpemVvZihzdHJ1Y3QgY2N3MSksCgkJCQkJICAgICAgIEdGUF9LRVJORUwgfCBHRlBfRE1BKSkgPT0gTlVMTCkgewoJCWtmcmVlKGNoKTsKCQljdGNfcHJfd2FybigiY3RjOiBPdXQgb2YgbWVtb3J5IGluIGFkZF9jaGFubmVsXG4iKTsKCQlyZXR1cm4gLTE7Cgl9CgoJbWVtc2V0KGNoLT5jY3csIDAsIDgqc2l6ZW9mKHN0cnVjdCBjY3cxKSk7CS8vIGFzc3VyZSBhbGwgZmxhZ3MgYW5kIGNvdW50ZXJzIGFyZSByZXNldAoKCS8qKgoJICogInN0YXRpYyIgY2N3cyBhcmUgdXNlZCBpbiB0aGUgZm9sbG93aW5nIHdheToKCSAqCgkgKiBjY3dbMC4uMl0gKENoYW5uZWwgcHJvZ3JhbSBmb3IgZ2VuZXJpYyBJL08pOgoJICogICAgICAgICAgIDA6IHByZXBhcmUKCSAqICAgICAgICAgICAxOiByZWFkIG9yIHdyaXRlIChkZXBlbmRpbmcgb24gZGlyZWN0aW9uKSB3aXRoIGZpeGVkCgkgKiAgICAgICAgICAgICAgYnVmZmVyIChpZGFsIGFsbG9jYXRlZCBvbmNlIHdoZW4gYnVmZmVyIGlzIGFsbG9jYXRlZCkKCSAqICAgICAgICAgICAyOiBub3AKCSAqIGNjd1szLi41XSAoQ2hhbm5lbCBwcm9ncmFtIGZvciBkaXJlY3Qgd3JpdGUgb2YgcGFja2V0cykKCSAqICAgICAgICAgICAzOiBwcmVwYXJlCgkgKiAgICAgICAgICAgNDogd3JpdGUgKGlkYWwgYWxsb2NhdGVkIG9uIGV2ZXJ5IHdyaXRlKS4KCSAqICAgICAgICAgICA1OiBub3AKCSAqIGNjd1s2Li43XSAoQ2hhbm5lbCBwcm9ncmFtIGZvciBpbml0aWFsIGNoYW5uZWwgc2V0dXApOgoJICogICAgICAgICAgIDY6IHNldCBleHRlbmRlZCBtb2RlCgkgKiAgICAgICAgICAgNzogbm9wCgkgKgoJICogY2gtPmNjd1swLi41XSBhcmUgaW5pdGlhbGl6ZWQgaW4gY2hfYWN0aW9uX3N0YXJ0IGJlY2F1c2UKCSAqIHRoZSBjaGFubmVsJ3MgZGlyZWN0aW9uIGlzIHlldCB1bmtub3duIGhlcmUuCgkgKi8KCWNoLT5jY3dbNl0uY21kX2NvZGUgPSBDQ1dfQ01EX1NFVF9FWFRFTkRFRDsKCWNoLT5jY3dbNl0uZmxhZ3MgPSBDQ1dfRkxBR19TTEk7CgoJY2gtPmNjd1s3XS5jbWRfY29kZSA9IENDV19DTURfTk9PUDsKCWNoLT5jY3dbN10uZmxhZ3MgPSBDQ1dfRkxBR19TTEk7CgoJY2gtPmNkZXYgPSBjZGV2OwoJc25wcmludGYoY2gtPmlkLCBDVENfSURfU0laRSwgImNoLSVzIiwgY2Rldi0+ZGV2LmJ1c19pZCk7CgljaC0+dHlwZSA9IHR5cGU7CgljaC0+ZnNtID0gaW5pdF9mc20oY2gtPmlkLCBjaF9zdGF0ZV9uYW1lcywKCQkJICAgY2hfZXZlbnRfbmFtZXMsIE5SX0NIX1NUQVRFUywgTlJfQ0hfRVZFTlRTLAoJCQkgICBjaF9mc20sIENIX0ZTTV9MRU4sIEdGUF9LRVJORUwpOwoJaWYgKGNoLT5mc20gPT0gTlVMTCkgewoJCWN0Y19wcl93YXJuKCJjdGM6IENvdWxkIG5vdCBjcmVhdGUgRlNNIGluIGFkZF9jaGFubmVsXG4iKTsKCQlrZnJlZShjaC0+Y2N3KTsKCQlrZnJlZShjaCk7CgkJcmV0dXJuIC0xOwoJfQoJZnNtX25ld3N0YXRlKGNoLT5mc20sIENIX1NUQVRFX0lETEUpOwoJaWYgKChjaC0+aXJiID0ga21hbGxvYyhzaXplb2YgKHN0cnVjdCBpcmIpLAoJCQkJCSAgICAgIEdGUF9LRVJORUwpKSA9PSBOVUxMKSB7CgkJY3RjX3ByX3dhcm4oImN0YzogT3V0IG9mIG1lbW9yeSBpbiBhZGRfY2hhbm5lbFxuIik7CgkJa2ZyZWVfZnNtKGNoLT5mc20pOwoJCWtmcmVlKGNoLT5jY3cpOwoJCWtmcmVlKGNoKTsKCQlyZXR1cm4gLTE7Cgl9CgltZW1zZXQoY2gtPmlyYiwgMCwgc2l6ZW9mIChzdHJ1Y3QgaXJiKSk7Cgl3aGlsZSAoKmMgJiYgbGVzc190aGFuKCgqYyktPmlkLCBjaC0+aWQpKQoJCWMgPSAmKCpjKS0+bmV4dDsKCWlmICgqYyAmJiAoIXN0cm5jbXAoKCpjKS0+aWQsIGNoLT5pZCwgQ1RDX0lEX1NJWkUpKSkgewoJCWN0Y19wcl9kZWJ1ZygKCQkJImN0YzogYWRkX2NoYW5uZWw6IGRldmljZSAlcyBhbHJlYWR5IGluIGxpc3QsICIKCQkJInVzaW5nIG9sZCBlbnRyeVxuIiwgKCpjKS0+aWQpOwoJCWtmcmVlKGNoLT5pcmIpOwoJCWtmcmVlX2ZzbShjaC0+ZnNtKTsKCQlrZnJlZShjaC0+Y2N3KTsKCQlrZnJlZShjaCk7CgkJcmV0dXJuIDA7Cgl9CgoJc3Bpbl9sb2NrX2luaXQoJmNoLT5jb2xsZWN0X2xvY2spOwoKCWZzbV9zZXR0aW1lcihjaC0+ZnNtLCAmY2gtPnRpbWVyKTsKCXNrYl9xdWV1ZV9oZWFkX2luaXQoJmNoLT5pb19xdWV1ZSk7Cglza2JfcXVldWVfaGVhZF9pbml0KCZjaC0+Y29sbGVjdF9xdWV1ZSk7CgljaC0+bmV4dCA9ICpjOwoJKmMgPSBjaDsKCXJldHVybiAwOwp9CgovKioKICogUmVsZWFzZSBhIHNwZWNpZmljIGNoYW5uZWwgaW4gdGhlIGNoYW5uZWwgbGlzdC4KICoKICogQHBhcmFtIGNoIFBvaW50ZXIgdG8gY2hhbm5lbCBzdHJ1Y3QgdG8gYmUgcmVsZWFzZWQuCiAqLwpzdGF0aWMgdm9pZApjaGFubmVsX2ZyZWUoc3RydWN0IGNoYW5uZWwgKmNoKQp7CgljaC0+ZmxhZ3MgJj0gfkNIQU5ORUxfRkxBR1NfSU5VU0U7Cglmc21fbmV3c3RhdGUoY2gtPmZzbSwgQ0hfU1RBVEVfSURMRSk7Cn0KCi8qKgogKiBSZW1vdmUgYSBzcGVjaWZpYyBjaGFubmVsIGluIHRoZSBjaGFubmVsIGxpc3QuCiAqCiAqIEBwYXJhbSBjaCBQb2ludGVyIHRvIGNoYW5uZWwgc3RydWN0IHRvIGJlIHJlbGVhc2VkLgogKi8Kc3RhdGljIHZvaWQKY2hhbm5lbF9yZW1vdmUoc3RydWN0IGNoYW5uZWwgKmNoKQp7CglzdHJ1Y3QgY2hhbm5lbCAqKmMgPSAmY2hhbm5lbHM7CgoJREJGX1RFWFQodHJhY2UsIDIsIF9fRlVOQ1RJT05fXyk7CglpZiAoY2ggPT0gTlVMTCkKCQlyZXR1cm47CgoJY2hhbm5lbF9mcmVlKGNoKTsKCXdoaWxlICgqYykgewoJCWlmICgqYyA9PSBjaCkgewoJCQkqYyA9IGNoLT5uZXh0OwoJCQlmc21fZGVsdGltZXIoJmNoLT50aW1lcik7CgkJCWtmcmVlX2ZzbShjaC0+ZnNtKTsKCQkJY2xlYXJfbm9ybWFsaXplZF9jZGEoJmNoLT5jY3dbNF0pOwoJCQlpZiAoY2gtPnRyYW5zX3NrYiAhPSBOVUxMKSB7CgkJCQljbGVhcl9ub3JtYWxpemVkX2NkYSgmY2gtPmNjd1sxXSk7CgkJCQlkZXZfa2ZyZWVfc2tiKGNoLT50cmFuc19za2IpOwoJCQl9CgkJCWtmcmVlKGNoLT5jY3cpOwoJCQlrZnJlZShjaC0+aXJiKTsKCQkJa2ZyZWUoY2gpOwoJCQlyZXR1cm47CgkJfQoJCWMgPSAmKCgqYyktPm5leHQpOwoJfQp9CgovKioKICogR2V0IGEgc3BlY2lmaWMgY2hhbm5lbCBmcm9tIHRoZSBjaGFubmVsIGxpc3QuCiAqCiAqIEBwYXJhbSB0eXBlIFR5cGUgb2YgY2hhbm5lbCB3ZSBhcmUgaW50ZXJlc3RlZCBpbi4KICogQHBhcmFtIGlkIElkIG9mIGNoYW5uZWwgd2UgYXJlIGludGVyZXN0ZWQgaW4uCiAqIEBwYXJhbSBkaXJlY3Rpb24gRGlyZWN0aW9uIHdlIHdhbnQgdG8gdXNlIHRoaXMgY2hhbm5lbCBmb3IuCiAqCiAqIEByZXR1cm4gUG9pbnRlciB0byBhIGNoYW5uZWwgb3IgTlVMTCBpZiBubyBtYXRjaGluZyBjaGFubmVsIGF2YWlsYWJsZS4KICovCnN0YXRpYyBzdHJ1Y3QgY2hhbm5lbAoqCmNoYW5uZWxfZ2V0KGVudW0gY2hhbm5lbF90eXBlcyB0eXBlLCBjaGFyICppZCwgaW50IGRpcmVjdGlvbikKewoJc3RydWN0IGNoYW5uZWwgKmNoID0gY2hhbm5lbHM7CgoJREJGX1RFWFQodHJhY2UsIDMsIF9fRlVOQ1RJT05fXyk7CiNpZmRlZiBERUJVRwoJY3RjX3ByX2RlYnVnKCJjdGM6ICVzKCk6IHNlYXJjaGluZyBmb3IgY2ggd2l0aCBpZCAlcyBhbmQgdHlwZSAlZFxuIiwKCQkgICAgIF9fZnVuY19fLCBpZCwgdHlwZSk7CiNlbmRpZgoKCXdoaWxlIChjaCAmJiAoKHN0cm5jbXAoY2gtPmlkLCBpZCwgQ1RDX0lEX1NJWkUpKSB8fCAoY2gtPnR5cGUgIT0gdHlwZSkpKSB7CiNpZmRlZiBERUJVRwoJCWN0Y19wcl9kZWJ1ZygiY3RjOiAlcygpOiBjaD0weCVwIChpZD0lcywgdHlwZT0lZFxuIiwKCQkJICAgICBfX2Z1bmNfXywgY2gsIGNoLT5pZCwgY2gtPnR5cGUpOwojZW5kaWYKCQljaCA9IGNoLT5uZXh0OwoJfQojaWZkZWYgREVCVUcKCWN0Y19wcl9kZWJ1ZygiY3RjOiAlcygpOiBjaD0weCVwcSAoaWQ9JXMsIHR5cGU9JWRcbiIsCgkJICAgICBfX2Z1bmNfXywgY2gsIGNoLT5pZCwgY2gtPnR5cGUpOwojZW5kaWYKCWlmICghY2gpIHsKCQljdGNfcHJfd2FybigiY3RjOiAlcygpOiBjaGFubmVsIHdpdGggaWQgJXMgIgoJCQkgICAgImFuZCB0eXBlICVkIG5vdCBmb3VuZCBpbiBjaGFubmVsIGxpc3RcbiIsCgkJCSAgICBfX2Z1bmNfXywgaWQsIHR5cGUpOwoJfSBlbHNlIHsKCQlpZiAoY2gtPmZsYWdzICYgQ0hBTk5FTF9GTEFHU19JTlVTRSkKCQkJY2ggPSBOVUxMOwoJCWVsc2UgewoJCQljaC0+ZmxhZ3MgfD0gQ0hBTk5FTF9GTEFHU19JTlVTRTsKCQkJY2gtPmZsYWdzICY9IH5DSEFOTkVMX0ZMQUdTX1JXTUFTSzsKCQkJY2gtPmZsYWdzIHw9IChkaXJlY3Rpb24gPT0gV1JJVEUpCgkJCSAgICA/IENIQU5ORUxfRkxBR1NfV1JJVEUgOiBDSEFOTkVMX0ZMQUdTX1JFQUQ7CgkJCWZzbV9uZXdzdGF0ZShjaC0+ZnNtLCBDSF9TVEFURV9TVE9QUEVEKTsKCQl9Cgl9CglyZXR1cm4gY2g7Cn0KCi8qKgogKiBSZXR1cm4gdGhlIGNoYW5uZWwgdHlwZSBieSBuYW1lLgogKgogKiBAcGFyYW0gbmFtZSBOYW1lIG9mIG5ldHdvcmsgaW50ZXJmYWNlLgogKgogKiBAcmV0dXJuIFR5cGUgY2xhc3Mgb2YgY2hhbm5lbCB0byBiZSB1c2VkIGZvciB0aGF0IGludGVyZmFjZS4KICovCnN0YXRpYyBlbnVtIGNoYW5uZWxfdHlwZXMgaW5saW5lCmV4dHJhY3RfY2hhbm5lbF9tZWRpYShjaGFyICpuYW1lKQp7CgllbnVtIGNoYW5uZWxfdHlwZXMgcmV0ID0gY2hhbm5lbF90eXBlX3Vua25vd247CgoJaWYgKG5hbWUgIT0gTlVMTCkgewoJCWlmIChzdHJuY21wKG5hbWUsICJjdGMiLCAzKSA9PSAwKQoJCQlyZXQgPSBjaGFubmVsX3R5cGVfcGFyYWxsZWw7CgkJaWYgKHN0cm5jbXAobmFtZSwgImVzY29uIiwgNSkgPT0gMCkKCQkJcmV0ID0gY2hhbm5lbF90eXBlX2VzY29uOwoJfQoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGxvbmcKX19jdGNfY2hlY2tfaXJiX2Vycm9yKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2LCBzdHJ1Y3QgaXJiICppcmIpCnsKCWlmICghSVNfRVJSKGlyYikpCgkJcmV0dXJuIDA7CgoJc3dpdGNoIChQVFJfRVJSKGlyYikpIHsKCWNhc2UgLUVJTzoKCQljdGNfcHJfd2FybigiaS9vLWVycm9yIG9uIGRldmljZSAlc1xuIiwgY2Rldi0+ZGV2LmJ1c19pZCk7Ci8vCQlDVENfREJGX1RFWFQodHJhY2UsIDIsICJja2lyYmVyciIpOwovLwkJQ1RDX0RCRl9URVhUXyh0cmFjZSwgMiwgIiAgcmMlZCIsIC1FSU8pOwoJCWJyZWFrOwoJY2FzZSAtRVRJTUVET1VUOgoJCWN0Y19wcl93YXJuKCJ0aW1lb3V0IG9uIGRldmljZSAlc1xuIiwgY2Rldi0+ZGV2LmJ1c19pZCk7Ci8vCQlDVENfREJGX1RFWFQodHJhY2UsIDIsICJja2lyYmVyciIpOwovLwkJQ1RDX0RCRl9URVhUXyh0cmFjZSwgMiwgIiAgcmMlZCIsIC1FVElNRURPVVQpOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQljdGNfcHJfd2FybigidW5rbm93biBlcnJvciAlbGQgb24gZGV2aWNlICVzXG4iLCBQVFJfRVJSKGlyYiksCgkJCSAgIGNkZXYtPmRldi5idXNfaWQpOwovLwkJQ1RDX0RCRl9URVhUKHRyYWNlLCAyLCAiY2tpcmJlcnIiKTsKLy8JCUNUQ19EQkZfVEVYVCh0cmFjZSwgMiwgIiAgcmM/Pz8iKTsKCX0KCXJldHVybiBQVFJfRVJSKGlyYik7Cn0KCi8qKgogKiBNYWluIElSUSBoYW5kbGVyLgogKgogKiBAcGFyYW0gY2RldiAgICBUaGUgY2N3X2RldmljZSB0aGUgaW50ZXJydXB0IGlzIGZvci4KICogQHBhcmFtIGludHBhcm0gaW50ZXJydXB0aW9uIHBhcmFtZXRlci4KICogQHBhcmFtIGlyYiAgICAgaW50ZXJydXB0aW9uIHJlc3BvbnNlIGJsb2NrLgogKi8Kc3RhdGljIHZvaWQKY3RjX2lycV9oYW5kbGVyKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2LCB1bnNpZ25lZCBsb25nIGludHBhcm0sIHN0cnVjdCBpcmIgKmlyYikKewoJc3RydWN0IGNoYW5uZWwgKmNoOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldjsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdjsKCglEQkZfVEVYVCh0cmFjZSwgNSwgX19GVU5DVElPTl9fKTsKCWlmIChfX2N0Y19jaGVja19pcmJfZXJyb3IoY2RldiwgaXJiKSkKCQlyZXR1cm47CgoJLyogQ2hlY2sgZm9yIHVuc29saWNpdGVkIGludGVycnVwdHMuICovCglpZiAoIWNkZXYtPmRldi5kcml2ZXJfZGF0YSkgewoJCWN0Y19wcl93YXJuKCJjdGM6IEdvdCB1bnNvbGljaXRlZCBpcnE6ICVzIGMtJTAyeCBkLSUwMnhcbiIsCgkJCSAgICBjZGV2LT5kZXYuYnVzX2lkLCBpcmItPnNjc3cuY3N0YXQsCgkJCSAgICBpcmItPnNjc3cuZHN0YXQpOwoJCXJldHVybjsKCX0KCglwcml2ID0gKChzdHJ1Y3QgY2N3Z3JvdXBfZGV2aWNlICopY2Rldi0+ZGV2LmRyaXZlcl9kYXRhKQoJCS0+ZGV2LmRyaXZlcl9kYXRhOwoKCS8qIFRyeSB0byBleHRyYWN0IGNoYW5uZWwgZnJvbSBkcml2ZXIgZGF0YS4gKi8KCWlmIChwcml2LT5jaGFubmVsW1JFQURdLT5jZGV2ID09IGNkZXYpCgkJY2ggPSBwcml2LT5jaGFubmVsW1JFQURdOwoJZWxzZSBpZiAocHJpdi0+Y2hhbm5lbFtXUklURV0tPmNkZXYgPT0gY2RldikKCQljaCA9IHByaXYtPmNoYW5uZWxbV1JJVEVdOwoJZWxzZSB7CgkJY3RjX3ByX2VycigiY3RjOiBDYW4ndCBkZXRlcm1pbmUgY2hhbm5lbCBmb3IgaW50ZXJydXB0LCAiCgkJCSAgICJkZXZpY2UgJXNcbiIsIGNkZXYtPmRldi5idXNfaWQpOwoJCXJldHVybjsKCX0KCglkZXYgPSAoc3RydWN0IG5ldF9kZXZpY2UgKikgKGNoLT5uZXRkZXYpOwoJaWYgKGRldiA9PSBOVUxMKSB7CgkJY3RjX3ByX2NyaXQoImN0YzogY3RjX2lycV9oYW5kbGVyIGRldj1OVUxMIGJ1c19pZD0lcywgY2g9MHglcFxuIiwKCQkJICAgIGNkZXYtPmRldi5idXNfaWQsIGNoKTsKCQlyZXR1cm47Cgl9CgojaWZkZWYgREVCVUcKCWN0Y19wcl9kZWJ1ZygiJXM6IGludGVycnVwdCBmb3IgZGV2aWNlOiAlcyByZWNlaXZlZCBjLSUwMnggZC0lMDJ4XG4iLAoJCSAgICAgZGV2LT5uYW1lLCBjaC0+aWQsIGlyYi0+c2Nzdy5jc3RhdCwgaXJiLT5zY3N3LmRzdGF0KTsKI2VuZGlmCgoJLyogQ29weSBpbnRlcnJ1cHRpb24gcmVzcG9uc2UgYmxvY2suICovCgltZW1jcHkoY2gtPmlyYiwgaXJiLCBzaXplb2Yoc3RydWN0IGlyYikpOwoKCS8qIENoZWNrIGZvciBnb29kIHN1YmNoYW5uZWwgcmV0dXJuIGNvZGUsIG90aGVyd2lzZSBlcnJvciBtZXNzYWdlICovCglpZiAoY2gtPmlyYi0+c2Nzdy5jc3RhdCkgewoJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9TQ19VTktOT1dOLCBjaCk7CgkJY3RjX3ByX3dhcm4oIiVzOiBzdWJjaGFubmVsIGNoZWNrIGZvciBkZXZpY2U6ICVzIC0gJTAyeCAlMDJ4XG4iLAoJCQkgICAgZGV2LT5uYW1lLCBjaC0+aWQsIGNoLT5pcmItPnNjc3cuY3N0YXQsCgkJCSAgICBjaC0+aXJiLT5zY3N3LmRzdGF0KTsKCQlyZXR1cm47Cgl9CgoJLyogQ2hlY2sgdGhlIHJlYXNvbi1jb2RlIG9mIGEgdW5pdCBjaGVjayAqLwoJaWYgKGNoLT5pcmItPnNjc3cuZHN0YXQgJiBERVZfU1RBVF9VTklUX0NIRUNLKSB7CgkJY2N3X3VuaXRfY2hlY2soY2gsIGNoLT5pcmItPmVjd1swXSk7CgkJcmV0dXJuOwoJfQoJaWYgKGNoLT5pcmItPnNjc3cuZHN0YXQgJiBERVZfU1RBVF9CVVNZKSB7CgkJaWYgKGNoLT5pcmItPnNjc3cuZHN0YXQgJiBERVZfU1RBVF9BVFRFTlRJT04pCgkJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9BVFROQlVTWSwgY2gpOwoJCWVsc2UKCQkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX0JVU1ksIGNoKTsKCQlyZXR1cm47Cgl9CglpZiAoY2gtPmlyYi0+c2Nzdy5kc3RhdCAmIERFVl9TVEFUX0FUVEVOVElPTikgewoJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9BVFROLCBjaCk7CgkJcmV0dXJuOwoJfQoJaWYgKChjaC0+aXJiLT5zY3N3LnN0Y3RsICYgU0NTV19TVENUTF9TRUNfU1RBVFVTKSB8fAoJICAgIChjaC0+aXJiLT5zY3N3LnN0Y3RsID09IFNDU1dfU1RDVExfU1RBVFVTX1BFTkQpIHx8CgkgICAgKGNoLT5pcmItPnNjc3cuc3RjdGwgPT0KCSAgICAgKFNDU1dfU1RDVExfQUxFUlRfU1RBVFVTIHwgU0NTV19TVENUTF9TVEFUVVNfUEVORCkpKQoJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9GSU5TVEFULCBjaCk7CgllbHNlCgkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX0lSUSwgY2gpOwoKfQoKLyoqCiAqIEFjdGlvbnMgZm9yIGludGVyZmFjZSAtIHN0YXRlbWFjaGluZS4KICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKLyoqCiAqIFN0YXJ0dXAgY2hhbm5lbHMgYnkgc2VuZGluZyBDSF9FVkVOVF9TVEFSVCB0byBlYWNoIGNoYW5uZWwuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhbiBpbnRlcmZhY2Ugc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBzdHJ1Y3QgbmV0X2RldmljZSAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmRldl9hY3Rpb25fc3RhcnQoZnNtX2luc3RhbmNlICogZmksIGludCBldmVudCwgdm9pZCAqYXJnKQp7CglzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gKHN0cnVjdCBuZXRfZGV2aWNlICopIGFyZzsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdnB0ciA9IGRldi0+cHJpdjsKCWludCBkaXJlY3Rpb247CgoJREJGX1RFWFQoc2V0dXAsIDMsIF9fRlVOQ1RJT05fXyk7Cglmc21fZGVsdGltZXIoJnByaXZwdHItPnJlc3RhcnRfdGltZXIpOwoJZnNtX25ld3N0YXRlKGZpLCBERVZfU1RBVEVfU1RBUlRXQUlUX1JYVFgpOwoJZm9yIChkaXJlY3Rpb24gPSBSRUFEOyBkaXJlY3Rpb24gPD0gV1JJVEU7IGRpcmVjdGlvbisrKSB7CgkJc3RydWN0IGNoYW5uZWwgKmNoID0gcHJpdnB0ci0+Y2hhbm5lbFtkaXJlY3Rpb25dOwoJCWZzbV9ldmVudChjaC0+ZnNtLCBDSF9FVkVOVF9TVEFSVCwgY2gpOwoJfQp9CgovKioKICogU2h1dGRvd24gY2hhbm5lbHMgYnkgc2VuZGluZyBDSF9FVkVOVF9TVE9QIHRvIGVhY2ggY2hhbm5lbC4KICoKICogQHBhcmFtIGZpICAgIEFuIGluc3RhbmNlIG9mIGFuIGludGVyZmFjZSBzdGF0ZW1hY2hpbmUuCiAqIEBwYXJhbSBldmVudCBUaGUgZXZlbnQsIGp1c3QgaGFwcGVuZWQuCiAqIEBwYXJhbSBhcmcgICBHZW5lcmljIHBvaW50ZXIsIGNhc3RlZCBmcm9tIHN0cnVjdCBuZXRfZGV2aWNlICogdXBvbiBjYWxsLgogKi8Kc3RhdGljIHZvaWQKZGV2X2FjdGlvbl9zdG9wKGZzbV9pbnN0YW5jZSAqIGZpLCBpbnQgZXZlbnQsIHZvaWQgKmFyZykKewoJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IChzdHJ1Y3QgbmV0X2RldmljZSAqKSBhcmc7CglzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSBkZXYtPnByaXY7CglpbnQgZGlyZWN0aW9uOwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJZnNtX25ld3N0YXRlKGZpLCBERVZfU1RBVEVfU1RPUFdBSVRfUlhUWCk7Cglmb3IgKGRpcmVjdGlvbiA9IFJFQUQ7IGRpcmVjdGlvbiA8PSBXUklURTsgZGlyZWN0aW9uKyspIHsKCQlzdHJ1Y3QgY2hhbm5lbCAqY2ggPSBwcml2cHRyLT5jaGFubmVsW2RpcmVjdGlvbl07CgkJZnNtX2V2ZW50KGNoLT5mc20sIENIX0VWRU5UX1NUT1AsIGNoKTsKCX0KfQpzdGF0aWMgdm9pZApkZXZfYWN0aW9uX3Jlc3RhcnQoZnNtX2luc3RhbmNlICpmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSAoc3RydWN0IG5ldF9kZXZpY2UgKilhcmc7CglzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSBkZXYtPnByaXY7CgoJREJGX1RFWFQodHJhY2UsIDMsIF9fRlVOQ1RJT05fXyk7CgljdGNfcHJfZGVidWcoIiVzOiBSZXN0YXJ0aW5nXG4iLCBkZXYtPm5hbWUpOwoJZGV2X2FjdGlvbl9zdG9wKGZpLCBldmVudCwgYXJnKTsKCWZzbV9ldmVudChwcml2cHRyLT5mc20sIERFVl9FVkVOVF9TVE9QLCBkZXYpOwoJZnNtX2FkZHRpbWVyKCZwcml2cHRyLT5yZXN0YXJ0X3RpbWVyLCBDVENfVElNRU9VVF81U0VDLAoJCSAgICAgREVWX0VWRU5UX1NUQVJULCBkZXYpOwp9CgovKioKICogQ2FsbGVkIGZyb20gY2hhbm5lbCBzdGF0ZW1hY2hpbmUKICogd2hlbiBhIGNoYW5uZWwgaXMgdXAgYW5kIHJ1bm5pbmcuCiAqCiAqIEBwYXJhbSBmaSAgICBBbiBpbnN0YW5jZSBvZiBhbiBpbnRlcmZhY2Ugc3RhdGVtYWNoaW5lLgogKiBAcGFyYW0gZXZlbnQgVGhlIGV2ZW50LCBqdXN0IGhhcHBlbmVkLgogKiBAcGFyYW0gYXJnICAgR2VuZXJpYyBwb2ludGVyLCBjYXN0ZWQgZnJvbSBzdHJ1Y3QgbmV0X2RldmljZSAqIHVwb24gY2FsbC4KICovCnN0YXRpYyB2b2lkCmRldl9hY3Rpb25fY2h1cChmc21faW5zdGFuY2UgKiBmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCXN0cnVjdCBuZXRfZGV2aWNlICpkZXYgPSAoc3RydWN0IG5ldF9kZXZpY2UgKikgYXJnOwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJc3dpdGNoIChmc21fZ2V0c3RhdGUoZmkpKSB7CgkJY2FzZSBERVZfU1RBVEVfU1RBUlRXQUlUX1JYVFg6CgkJCWlmIChldmVudCA9PSBERVZfRVZFTlRfUlhVUCkKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUQVJUV0FJVF9UWCk7CgkJCWVsc2UKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUQVJUV0FJVF9SWCk7CgkJCWJyZWFrOwoJCWNhc2UgREVWX1NUQVRFX1NUQVJUV0FJVF9SWDoKCQkJaWYgKGV2ZW50ID09IERFVl9FVkVOVF9SWFVQKSB7CgkJCQlmc21fbmV3c3RhdGUoZmksIERFVl9TVEFURV9SVU5OSU5HKTsKCQkJCWN0Y19wcl9pbmZvKCIlczogY29ubmVjdGVkIHdpdGggcmVtb3RlIHNpZGVcbiIsCgkJCQkJICAgIGRldi0+bmFtZSk7CgkJCQljdGNfY2xlYXJfYnVzeShkZXYpOwoJCQl9CgkJCWJyZWFrOwoJCWNhc2UgREVWX1NUQVRFX1NUQVJUV0FJVF9UWDoKCQkJaWYgKGV2ZW50ID09IERFVl9FVkVOVF9UWFVQKSB7CgkJCQlmc21fbmV3c3RhdGUoZmksIERFVl9TVEFURV9SVU5OSU5HKTsKCQkJCWN0Y19wcl9pbmZvKCIlczogY29ubmVjdGVkIHdpdGggcmVtb3RlIHNpZGVcbiIsCgkJCQkJICAgIGRldi0+bmFtZSk7CgkJCQljdGNfY2xlYXJfYnVzeShkZXYpOwoJCQl9CgkJCWJyZWFrOwoJCWNhc2UgREVWX1NUQVRFX1NUT1BXQUlUX1RYOgoJCQlpZiAoZXZlbnQgPT0gREVWX0VWRU5UX1JYVVApCgkJCQlmc21fbmV3c3RhdGUoZmksIERFVl9TVEFURV9TVE9QV0FJVF9SWFRYKTsKCQkJYnJlYWs7CgkJY2FzZSBERVZfU1RBVEVfU1RPUFdBSVRfUlg6CgkJCWlmIChldmVudCA9PSBERVZfRVZFTlRfVFhVUCkKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUT1BXQUlUX1JYVFgpOwoJCQlicmVhazsKCX0KfQoKLyoqCiAqIENhbGxlZCBmcm9tIGNoYW5uZWwgc3RhdGVtYWNoaW5lCiAqIHdoZW4gYSBjaGFubmVsIGhhcyBiZWVuIHNodXRkb3duLgogKgogKiBAcGFyYW0gZmkgICAgQW4gaW5zdGFuY2Ugb2YgYW4gaW50ZXJmYWNlIHN0YXRlbWFjaGluZS4KICogQHBhcmFtIGV2ZW50IFRoZSBldmVudCwganVzdCBoYXBwZW5lZC4KICogQHBhcmFtIGFyZyAgIEdlbmVyaWMgcG9pbnRlciwgY2FzdGVkIGZyb20gc3RydWN0IG5ldF9kZXZpY2UgKiB1cG9uIGNhbGwuCiAqLwpzdGF0aWMgdm9pZApkZXZfYWN0aW9uX2NoZG93bihmc21faW5zdGFuY2UgKiBmaSwgaW50IGV2ZW50LCB2b2lkICphcmcpCnsKCglEQkZfVEVYVCh0cmFjZSwgMywgX19GVU5DVElPTl9fKTsKCXN3aXRjaCAoZnNtX2dldHN0YXRlKGZpKSkgewoJCWNhc2UgREVWX1NUQVRFX1JVTk5JTkc6CgkJCWlmIChldmVudCA9PSBERVZfRVZFTlRfVFhET1dOKQoJCQkJZnNtX25ld3N0YXRlKGZpLCBERVZfU1RBVEVfU1RBUlRXQUlUX1RYKTsKCQkJZWxzZQoJCQkJZnNtX25ld3N0YXRlKGZpLCBERVZfU1RBVEVfU1RBUlRXQUlUX1JYKTsKCQkJYnJlYWs7CgkJY2FzZSBERVZfU1RBVEVfU1RBUlRXQUlUX1JYOgoJCQlpZiAoZXZlbnQgPT0gREVWX0VWRU5UX1RYRE9XTikKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYKTsKCQkJYnJlYWs7CgkJY2FzZSBERVZfU1RBVEVfU1RBUlRXQUlUX1RYOgoJCQlpZiAoZXZlbnQgPT0gREVWX0VWRU5UX1JYRE9XTikKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYKTsKCQkJYnJlYWs7CgkJY2FzZSBERVZfU1RBVEVfU1RPUFdBSVRfUlhUWDoKCQkJaWYgKGV2ZW50ID09IERFVl9FVkVOVF9UWERPV04pCgkJCQlmc21fbmV3c3RhdGUoZmksIERFVl9TVEFURV9TVE9QV0FJVF9SWCk7CgkJCWVsc2UKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUT1BXQUlUX1RYKTsKCQkJYnJlYWs7CgkJY2FzZSBERVZfU1RBVEVfU1RPUFdBSVRfUlg6CgkJCWlmIChldmVudCA9PSBERVZfRVZFTlRfUlhET1dOKQoJCQkJZnNtX25ld3N0YXRlKGZpLCBERVZfU1RBVEVfU1RPUFBFRCk7CgkJCWJyZWFrOwoJCWNhc2UgREVWX1NUQVRFX1NUT1BXQUlUX1RYOgoJCQlpZiAoZXZlbnQgPT0gREVWX0VWRU5UX1RYRE9XTikKCQkJCWZzbV9uZXdzdGF0ZShmaSwgREVWX1NUQVRFX1NUT1BQRUQpOwoJCQlicmVhazsKCX0KfQoKc3RhdGljIGNvbnN0IGZzbV9ub2RlIGRldl9mc21bXSA9IHsKCXtERVZfU1RBVEVfU1RPUFBFRCwgREVWX0VWRU5UX1NUQVJULCBkZXZfYWN0aW9uX3N0YXJ0fSwKCgl7REVWX1NUQVRFX1NUT1BXQUlUX1JYVFgsICBERVZfRVZFTlRfU1RBUlQsICAgZGV2X2FjdGlvbl9zdGFydCAgIH0sCgl7REVWX1NUQVRFX1NUT1BXQUlUX1JYVFgsICBERVZfRVZFTlRfUlhET1dOLCAgZGV2X2FjdGlvbl9jaGRvd24gIH0sCgl7REVWX1NUQVRFX1NUT1BXQUlUX1JYVFgsICBERVZfRVZFTlRfVFhET1dOLCAgZGV2X2FjdGlvbl9jaGRvd24gIH0sCiAJe0RFVl9TVEFURV9TVE9QV0FJVF9SWFRYLCAgREVWX0VWRU5UX1JFU1RBUlQsIGRldl9hY3Rpb25fcmVzdGFydCB9LAoKCXtERVZfU1RBVEVfU1RPUFdBSVRfUlgsICAgIERFVl9FVkVOVF9TVEFSVCwgICBkZXZfYWN0aW9uX3N0YXJ0ICAgfSwKCXtERVZfU1RBVEVfU1RPUFdBSVRfUlgsICAgIERFVl9FVkVOVF9SWFVQLCAgICBkZXZfYWN0aW9uX2NodXAgICAgfSwKCXtERVZfU1RBVEVfU1RPUFdBSVRfUlgsICAgIERFVl9FVkVOVF9UWFVQLCAgICBkZXZfYWN0aW9uX2NodXAgICAgfSwKCXtERVZfU1RBVEVfU1RPUFdBSVRfUlgsICAgIERFVl9FVkVOVF9SWERPV04sICBkZXZfYWN0aW9uX2NoZG93biAgfSwKIAl7REVWX1NUQVRFX1NUT1BXQUlUX1JYLCAgICBERVZfRVZFTlRfUkVTVEFSVCwgZGV2X2FjdGlvbl9yZXN0YXJ0IH0sCgoJe0RFVl9TVEFURV9TVE9QV0FJVF9UWCwgICAgREVWX0VWRU5UX1NUQVJULCAgIGRldl9hY3Rpb25fc3RhcnQgICB9LAoJe0RFVl9TVEFURV9TVE9QV0FJVF9UWCwgICAgREVWX0VWRU5UX1JYVVAsICAgIGRldl9hY3Rpb25fY2h1cCAgICB9LAoJe0RFVl9TVEFURV9TVE9QV0FJVF9UWCwgICAgREVWX0VWRU5UX1RYVVAsICAgIGRldl9hY3Rpb25fY2h1cCAgICB9LAoJe0RFVl9TVEFURV9TVE9QV0FJVF9UWCwgICAgREVWX0VWRU5UX1RYRE9XTiwgIGRldl9hY3Rpb25fY2hkb3duICB9LAogCXtERVZfU1RBVEVfU1RPUFdBSVRfVFgsICAgIERFVl9FVkVOVF9SRVNUQVJULCBkZXZfYWN0aW9uX3Jlc3RhcnQgfSwKCgl7REVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYLCBERVZfRVZFTlRfU1RPUCwgICAgZGV2X2FjdGlvbl9zdG9wICAgIH0sCgl7REVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYLCBERVZfRVZFTlRfUlhVUCwgICAgZGV2X2FjdGlvbl9jaHVwICAgIH0sCgl7REVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYLCBERVZfRVZFTlRfVFhVUCwgICAgZGV2X2FjdGlvbl9jaHVwICAgIH0sCgl7REVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYLCBERVZfRVZFTlRfUlhET1dOLCAgZGV2X2FjdGlvbl9jaGRvd24gIH0sCgl7REVWX1NUQVRFX1NUQVJUV0FJVF9SWFRYLCBERVZfRVZFTlRfVFhET1dOLCAgZGV2X2FjdGlvbl9jaGRvd24gIH0sCiAJe0RFVl9TVEFURV9TVEFSVFdBSVRfUlhUWCwgREVWX0VWRU5UX1JFU1RBUlQsIGRldl9hY3Rpb25fcmVzdGFydCB9LAoKCXtERVZfU1RBVEVfU1RBUlRXQUlUX1RYLCAgIERFVl9FVkVOVF9TVE9QLCAgICBkZXZfYWN0aW9uX3N0b3AgICAgfSwKCXtERVZfU1RBVEVfU1RBUlRXQUlUX1RYLCAgIERFVl9FVkVOVF9SWFVQLCAgICBkZXZfYWN0aW9uX2NodXAgICAgfSwKCXtERVZfU1RBVEVfU1RBUlRXQUlUX1RYLCAgIERFVl9FVkVOVF9UWFVQLCAgICBkZXZfYWN0aW9uX2NodXAgICAgfSwKCXtERVZfU1RBVEVfU1RBUlRXQUlUX1RYLCAgIERFVl9FVkVOVF9SWERPV04sICBkZXZfYWN0aW9uX2NoZG93biAgfSwKIAl7REVWX1NUQVRFX1NUQVJUV0FJVF9UWCwgICBERVZfRVZFTlRfUkVTVEFSVCwgZGV2X2FjdGlvbl9yZXN0YXJ0IH0sCgoJe0RFVl9TVEFURV9TVEFSVFdBSVRfUlgsICAgREVWX0VWRU5UX1NUT1AsICAgIGRldl9hY3Rpb25fc3RvcCAgICB9LAoJe0RFVl9TVEFURV9TVEFSVFdBSVRfUlgsICAgREVWX0VWRU5UX1JYVVAsICAgIGRldl9hY3Rpb25fY2h1cCAgICB9LAoJe0RFVl9TVEFURV9TVEFSVFdBSVRfUlgsICAgREVWX0VWRU5UX1RYVVAsICAgIGRldl9hY3Rpb25fY2h1cCAgICB9LAoJe0RFVl9TVEFURV9TVEFSVFdBSVRfUlgsICAgREVWX0VWRU5UX1RYRE9XTiwgIGRldl9hY3Rpb25fY2hkb3duICB9LAogCXtERVZfU1RBVEVfU1RBUlRXQUlUX1JYLCAgIERFVl9FVkVOVF9SRVNUQVJULCBkZXZfYWN0aW9uX3Jlc3RhcnQgfSwKCgl7REVWX1NUQVRFX1JVTk5JTkcsICAgICAgICBERVZfRVZFTlRfU1RPUCwgICAgZGV2X2FjdGlvbl9zdG9wICAgIH0sCgl7REVWX1NUQVRFX1JVTk5JTkcsICAgICAgICBERVZfRVZFTlRfUlhET1dOLCAgZGV2X2FjdGlvbl9jaGRvd24gIH0sCgl7REVWX1NUQVRFX1JVTk5JTkcsICAgICAgICBERVZfRVZFTlRfVFhET1dOLCAgZGV2X2FjdGlvbl9jaGRvd24gIH0sCgl7REVWX1NUQVRFX1JVTk5JTkcsICAgICAgICBERVZfRVZFTlRfVFhVUCwgICAgZnNtX2FjdGlvbl9ub3AgICAgIH0sCgl7REVWX1NUQVRFX1JVTk5JTkcsICAgICAgICBERVZfRVZFTlRfUlhVUCwgICAgZnNtX2FjdGlvbl9ub3AgICAgIH0sCiAJe0RFVl9TVEFURV9SVU5OSU5HLCAgICAgICAgREVWX0VWRU5UX1JFU1RBUlQsIGRldl9hY3Rpb25fcmVzdGFydCB9LAp9OwoKc3RhdGljIGNvbnN0IGludCBERVZfRlNNX0xFTiA9IHNpemVvZiAoZGV2X2ZzbSkgLyBzaXplb2YgKGZzbV9ub2RlKTsKCi8qKgogKiBUcmFuc21pdCBhIHBhY2tldC4KICogVGhpcyBpcyBhIGhlbHBlciBmdW5jdGlvbiBmb3IgY3RjX3R4KCkuCiAqCiAqIEBwYXJhbSBjaCBDaGFubmVsIHRvIGJlIHVzZWQgZm9yIHNlbmRpbmcuCiAqIEBwYXJhbSBza2IgUG9pbnRlciB0byBzdHJ1Y3Qgc2tfYnVmZiBvZiBwYWNrZXQgdG8gc2VuZC4KICogICAgICAgICAgICBUaGUgbGlua2xldmVsIGhlYWRlciBoYXMgYWxyZWFkeSBiZWVuIHNldCB1cAogKiAgICAgICAgICAgIGJ5IGN0Y190eCgpLgogKgogKiBAcmV0dXJuIDAgb24gc3VjY2VzcywgLUVSUk5PIG9uIGZhaWx1cmUuIChOZXZlciBmYWlscy4pCiAqLwpzdGF0aWMgaW50CnRyYW5zbWl0X3NrYihzdHJ1Y3QgY2hhbm5lbCAqY2gsIHN0cnVjdCBza19idWZmICpza2IpCnsKCXVuc2lnbmVkIGxvbmcgc2F2ZWZsYWdzOwoJc3RydWN0IGxsX2hlYWRlciBoZWFkZXI7CglpbnQgcmMgPSAwOwoKCURCRl9URVhUKHRyYWNlLCA1LCBfX0ZVTkNUSU9OX18pOwoJLyogd2UgbmVlZCB0byBhY3F1aXJlIHRoZSBsb2NrIGZvciB0ZXN0aW5nIHRoZSBzdGF0ZQoJICogb3RoZXJ3aXNlIHdlIGNhbiBoYXZlIGFuIElSUSBjaGFuZ2luZyB0aGUgc3RhdGUgdG8KCSAqIFRYSURMRSBhZnRlciB0aGUgdGVzdCBidXQgYmVmb3JlIGFjcXVpcmluZyB0aGUgbG9jay4KCSAqLwoJc3Bpbl9sb2NrX2lycXNhdmUoJmNoLT5jb2xsZWN0X2xvY2ssIHNhdmVmbGFncyk7CglpZiAoZnNtX2dldHN0YXRlKGNoLT5mc20pICE9IENIX1NUQVRFX1RYSURMRSkgewoJCWludCBsID0gc2tiLT5sZW4gKyBMTF9IRUFERVJfTEVOR1RIOwoKCQlpZiAoY2gtPmNvbGxlY3RfbGVuICsgbCA+IGNoLT5tYXhfYnVmc2l6ZSAtIDIpIHsKCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2gtPmNvbGxlY3RfbG9jaywgc2F2ZWZsYWdzKTsKCQkJcmV0dXJuIC1FQlVTWTsKCQl9IGVsc2UgewoJCQlhdG9taWNfaW5jKCZza2ItPnVzZXJzKTsKCQkJaGVhZGVyLmxlbmd0aCA9IGw7CgkJCWhlYWRlci50eXBlID0gc2tiLT5wcm90b2NvbDsKCQkJaGVhZGVyLnVudXNlZCA9IDA7CgkJCW1lbWNweShza2JfcHVzaChza2IsIExMX0hFQURFUl9MRU5HVEgpLCAmaGVhZGVyLAoJCQkgICAgICAgTExfSEVBREVSX0xFTkdUSCk7CgkJCXNrYl9xdWV1ZV90YWlsKCZjaC0+Y29sbGVjdF9xdWV1ZSwgc2tiKTsKCQkJY2gtPmNvbGxlY3RfbGVuICs9IGw7CgkJfQoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNoLT5jb2xsZWN0X2xvY2ssIHNhdmVmbGFncyk7Cgl9IGVsc2UgewoJCV9fdTE2IGJsb2NrX2xlbjsKCQlpbnQgY2N3X2lkeDsKCQlzdHJ1Y3Qgc2tfYnVmZiAqbnNrYjsKCQl1bnNpZ25lZCBsb25nIGhpOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNoLT5jb2xsZWN0X2xvY2ssIHNhdmVmbGFncyk7CgkJLyoqCgkJICogUHJvdGVjdCBza2IgYWdhaW5zdCBiZWVpbmcgZnJlZSdkIGJ5IHVwcGVyCgkJICogbGF5ZXJzLgoJCSAqLwoJCWF0b21pY19pbmMoJnNrYi0+dXNlcnMpOwoJCWNoLT5wcm9mLnR4bGVuICs9IHNrYi0+bGVuOwoJCWhlYWRlci5sZW5ndGggPSBza2ItPmxlbiArIExMX0hFQURFUl9MRU5HVEg7CgkJaGVhZGVyLnR5cGUgPSBza2ItPnByb3RvY29sOwoJCWhlYWRlci51bnVzZWQgPSAwOwoJCW1lbWNweShza2JfcHVzaChza2IsIExMX0hFQURFUl9MRU5HVEgpLCAmaGVhZGVyLAoJCSAgICAgICBMTF9IRUFERVJfTEVOR1RIKTsKCQlibG9ja19sZW4gPSBza2ItPmxlbiArIDI7CgkJKigoX191MTYgKikgc2tiX3B1c2goc2tiLCAyKSkgPSBibG9ja19sZW47CgoJCS8qKgoJCSAqIElEQUwgc3VwcG9ydCBpbiBDVEMgaXMgYnJva2VuLCBzbyB3ZSBoYXZlIHRvCgkJICogY2FyZSBhYm91dCBza2IncyBhYm92ZSAyRyBvdXJzZWx2ZXMuCgkJICovCgkJaGkgPSAoKHVuc2lnbmVkIGxvbmcpIHNrYi0+dGFpbCArIExMX0hFQURFUl9MRU5HVEgpID4+IDMxOwoJCWlmIChoaSkgewoJCQluc2tiID0gYWxsb2Nfc2tiKHNrYi0+bGVuLCBHRlBfQVRPTUlDIHwgR0ZQX0RNQSk7CgkJCWlmICghbnNrYikgewoJCQkJYXRvbWljX2RlYygmc2tiLT51c2Vycyk7CgkJCQlza2JfcHVsbChza2IsIExMX0hFQURFUl9MRU5HVEggKyAyKTsKCQkJCWN0Y19jbGVhcl9idXN5KGNoLT5uZXRkZXYpOwoJCQkJcmV0dXJuIC1FTk9NRU07CgkJCX0gZWxzZSB7CgkJCQltZW1jcHkoc2tiX3B1dChuc2tiLCBza2ItPmxlbiksCgkJCQkgICAgICAgc2tiLT5kYXRhLCBza2ItPmxlbik7CgkJCQlhdG9taWNfaW5jKCZuc2tiLT51c2Vycyk7CgkJCQlhdG9taWNfZGVjKCZza2ItPnVzZXJzKTsKCQkJCWRldl9rZnJlZV9za2JfaXJxKHNrYik7CgkJCQlza2IgPSBuc2tiOwoJCQl9CgkJfQoKCQljaC0+Y2N3WzRdLmNvdW50ID0gYmxvY2tfbGVuOwoJCWlmIChzZXRfbm9ybWFsaXplZF9jZGEoJmNoLT5jY3dbNF0sIHNrYi0+ZGF0YSkpIHsKCQkJLyoqCgkJCSAqIGlkYWwgYWxsb2NhdGlvbiBmYWlsZWQsIHRyeSB2aWEgY29weWluZyB0bwoJCQkgKiB0cmFuc19za2IuIHRyYW5zX3NrYiB1c3VhbGx5IGhhcyBhIHByZS1hbGxvY2F0ZWQKCQkJICogaWRhbC4KCQkJICovCgkJCWlmIChjdGNfY2hlY2thbGxvY19idWZmZXIoY2gsIDEpKSB7CgkJCQkvKioKCQkJCSAqIFJlbW92ZSBvdXIgaGVhZGVyLiBJdCBnZXRzIGFkZGVkCgkJCQkgKiBhZ2FpbiBvbiByZXRyYW5zbWl0LgoJCQkJICovCgkJCQlhdG9taWNfZGVjKCZza2ItPnVzZXJzKTsKCQkJCXNrYl9wdWxsKHNrYiwgTExfSEVBREVSX0xFTkdUSCArIDIpOwoJCQkJY3RjX2NsZWFyX2J1c3koY2gtPm5ldGRldik7CgkJCQlyZXR1cm4gLUVCVVNZOwoJCQl9CgoJCQljaC0+dHJhbnNfc2tiLT50YWlsID0gY2gtPnRyYW5zX3NrYi0+ZGF0YTsKCQkJY2gtPnRyYW5zX3NrYi0+bGVuID0gMDsKCQkJY2gtPmNjd1sxXS5jb3VudCA9IHNrYi0+bGVuOwoJCQltZW1jcHkoc2tiX3B1dChjaC0+dHJhbnNfc2tiLCBza2ItPmxlbiksIHNrYi0+ZGF0YSwKCQkJICAgICAgIHNrYi0+bGVuKTsKCQkJYXRvbWljX2RlYygmc2tiLT51c2Vycyk7CgkJCWRldl9rZnJlZV9za2JfaXJxKHNrYik7CgkJCWNjd19pZHggPSAwOwoJCX0gZWxzZSB7CgkJCXNrYl9xdWV1ZV90YWlsKCZjaC0+aW9fcXVldWUsIHNrYik7CgkJCWNjd19pZHggPSAzOwoJCX0KCQljaC0+cmV0cnkgPSAwOwoJCWZzbV9uZXdzdGF0ZShjaC0+ZnNtLCBDSF9TVEFURV9UWCk7CgkJZnNtX2FkZHRpbWVyKCZjaC0+dGltZXIsIENUQ19USU1FT1VUXzVTRUMsIENIX0VWRU5UX1RJTUVSLCBjaCk7CgkJc3Bpbl9sb2NrX2lycXNhdmUoZ2V0X2Njd2Rldl9sb2NrKGNoLT5jZGV2KSwgc2F2ZWZsYWdzKTsKCQljaC0+cHJvZi5zZW5kX3N0YW1wID0geHRpbWU7CgkJcmMgPSBjY3dfZGV2aWNlX3N0YXJ0KGNoLT5jZGV2LCAmY2gtPmNjd1tjY3dfaWR4XSwKCQkJCSAgICAgICh1bnNpZ25lZCBsb25nKSBjaCwgMHhmZiwgMCk7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShnZXRfY2N3ZGV2X2xvY2soY2gtPmNkZXYpLCBzYXZlZmxhZ3MpOwoJCWlmIChjY3dfaWR4ID09IDMpCgkJCWNoLT5wcm9mLmRvaW9zX3NpbmdsZSsrOwoJCWlmIChyYyAhPSAwKSB7CgkJCWZzbV9kZWx0aW1lcigmY2gtPnRpbWVyKTsKCQkJY2N3X2NoZWNrX3JldHVybl9jb2RlKGNoLCByYywgInNpbmdsZSBza2IgVFgiKTsKCQkJaWYgKGNjd19pZHggPT0gMykKCQkJCXNrYl9kZXF1ZXVlX3RhaWwoJmNoLT5pb19xdWV1ZSk7CgkJCS8qKgoJCQkgKiBSZW1vdmUgb3VyIGhlYWRlci4gSXQgZ2V0cyBhZGRlZAoJCQkgKiBhZ2FpbiBvbiByZXRyYW5zbWl0LgoJCQkgKi8KCQkJc2tiX3B1bGwoc2tiLCBMTF9IRUFERVJfTEVOR1RIICsgMik7CgkJfSBlbHNlIHsKCQkJaWYgKGNjd19pZHggPT0gMCkgewoJCQkJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IGNoLT5uZXRkZXY7CgkJCQlzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSBkZXYtPnByaXY7CgkJCQlwcml2cHRyLT5zdGF0cy50eF9wYWNrZXRzKys7CgkJCQlwcml2cHRyLT5zdGF0cy50eF9ieXRlcyArPQoJCQkJICAgIHNrYi0+bGVuIC0gTExfSEVBREVSX0xFTkdUSDsKCQkJfQoJCX0KCX0KCgljdGNfY2xlYXJfYnVzeShjaC0+bmV0ZGV2KTsKCXJldHVybiByYzsKfQoKLyoqCiAqIEludGVyZmFjZSBBUEkgZm9yIHVwcGVyIG5ldHdvcmsgbGF5ZXJzCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCi8qKgogKiBPcGVuIGFuIGludGVyZmFjZS4KICogQ2FsbGVkIGZyb20gZ2VuZXJpYyBuZXR3b3JrIGxheWVyIHdoZW4gaWZjb25maWcgdXAgaXMgcnVuLgogKgogKiBAcGFyYW0gZGV2IFBvaW50ZXIgdG8gaW50ZXJmYWNlIHN0cnVjdC4KICoKICogQHJldHVybiAwIG9uIHN1Y2Nlc3MsIC1FUlJOTyBvbiBmYWlsdXJlLiAoTmV2ZXIgZmFpbHMuKQogKi8Kc3RhdGljIGludApjdGNfb3BlbihzdHJ1Y3QgbmV0X2RldmljZSAqIGRldikKewoJREJGX1RFWFQodHJhY2UsIDUsIF9fRlVOQ1RJT05fXyk7Cglmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLCBERVZfRVZFTlRfU1RBUlQsIGRldik7CglyZXR1cm4gMDsKfQoKLyoqCiAqIENsb3NlIGFuIGludGVyZmFjZS4KICogQ2FsbGVkIGZyb20gZ2VuZXJpYyBuZXR3b3JrIGxheWVyIHdoZW4gaWZjb25maWcgZG93biBpcyBydW4uCiAqCiAqIEBwYXJhbSBkZXYgUG9pbnRlciB0byBpbnRlcmZhY2Ugc3RydWN0LgogKgogKiBAcmV0dXJuIDAgb24gc3VjY2VzcywgLUVSUk5PIG9uIGZhaWx1cmUuIChOZXZlciBmYWlscy4pCiAqLwpzdGF0aWMgaW50CmN0Y19jbG9zZShzdHJ1Y3QgbmV0X2RldmljZSAqIGRldikKewoJREJGX1RFWFQodHJhY2UsIDUsIF9fRlVOQ1RJT05fXyk7Cglmc21fZXZlbnQoKChzdHJ1Y3QgY3RjX3ByaXYgKikgZGV2LT5wcml2KS0+ZnNtLCBERVZfRVZFTlRfU1RPUCwgZGV2KTsKCXJldHVybiAwOwp9CgovKioKICogU3RhcnQgdHJhbnNtaXNzaW9uIG9mIGEgcGFja2V0LgogKiBDYWxsZWQgZnJvbSBnZW5lcmljIG5ldHdvcmsgZGV2aWNlIGxheWVyLgogKgogKiBAcGFyYW0gc2tiIFBvaW50ZXIgdG8gYnVmZmVyIGNvbnRhaW5pbmcgdGhlIHBhY2tldC4KICogQHBhcmFtIGRldiBQb2ludGVyIHRvIGludGVyZmFjZSBzdHJ1Y3QuCiAqCiAqIEByZXR1cm4gMCBpZiBwYWNrZXQgY29uc3VtZWQsICEwIGlmIHBhY2tldCByZWplY3RlZC4KICogICAgICAgICBOb3RlOiBJZiB3ZSByZXR1cm4gITAsIHRoZW4gdGhlIHBhY2tldCBpcyBmcmVlJ2QgYnkKICogICAgICAgICAgICAgICB0aGUgZ2VuZXJpYyBuZXR3b3JrIGxheWVyLgogKi8Kc3RhdGljIGludApjdGNfdHgoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKiBkZXYpCnsKCWludCByYyA9IDA7CglzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSAoc3RydWN0IGN0Y19wcml2ICopIGRldi0+cHJpdjsKCglEQkZfVEVYVCh0cmFjZSwgNSwgX19GVU5DVElPTl9fKTsKCS8qKgoJICogU29tZSBzYW5pdHkgY2hlY2tzIC4uLgoJICovCglpZiAoc2tiID09IE5VTEwpIHsKCQljdGNfcHJfd2FybigiJXM6IE5VTEwgc2tfYnVmZiBwYXNzZWRcbiIsIGRldi0+bmFtZSk7CgkJcHJpdnB0ci0+c3RhdHMudHhfZHJvcHBlZCsrOwoJCXJldHVybiAwOwoJfQoJaWYgKHNrYl9oZWFkcm9vbShza2IpIDwgKExMX0hFQURFUl9MRU5HVEggKyAyKSkgewoJCWN0Y19wcl93YXJuKCIlczogR290IHNrX2J1ZmYgd2l0aCBoZWFkIHJvb20gPCAlbGQgYnl0ZXNcbiIsCgkJCSAgICBkZXYtPm5hbWUsIExMX0hFQURFUl9MRU5HVEggKyAyKTsKCQlkZXZfa2ZyZWVfc2tiKHNrYik7CgkJcHJpdnB0ci0+c3RhdHMudHhfZHJvcHBlZCsrOwoJCXJldHVybiAwOwoJfQoKCS8qKgoJICogSWYgY2hhbm5lbHMgYXJlIG5vdCBydW5uaW5nLCB0cnkgdG8gcmVzdGFydCB0aGVtCgkgKiBhbmQgdGhyb3cgYXdheSBwYWNrZXQuCgkgKi8KCWlmIChmc21fZ2V0c3RhdGUocHJpdnB0ci0+ZnNtKSAhPSBERVZfU1RBVEVfUlVOTklORykgewoJCWZzbV9ldmVudChwcml2cHRyLT5mc20sIERFVl9FVkVOVF9TVEFSVCwgZGV2KTsKCQlkZXZfa2ZyZWVfc2tiKHNrYik7CgkJcHJpdnB0ci0+c3RhdHMudHhfZHJvcHBlZCsrOwoJCXByaXZwdHItPnN0YXRzLnR4X2Vycm9ycysrOwoJCXByaXZwdHItPnN0YXRzLnR4X2NhcnJpZXJfZXJyb3JzKys7CgkJcmV0dXJuIDA7Cgl9CgoJaWYgKGN0Y190ZXN0X2FuZF9zZXRfYnVzeShkZXYpKQoJCXJldHVybiAtRUJVU1k7CgoJZGV2LT50cmFuc19zdGFydCA9IGppZmZpZXM7CglpZiAodHJhbnNtaXRfc2tiKHByaXZwdHItPmNoYW5uZWxbV1JJVEVdLCBza2IpICE9IDApCgkJcmMgPSAxOwoJcmV0dXJuIHJjOwp9CgovKioKICogU2V0cyBNVFUgb2YgYW4gaW50ZXJmYWNlLgogKgogKiBAcGFyYW0gZGV2ICAgICBQb2ludGVyIHRvIGludGVyZmFjZSBzdHJ1Y3QuCiAqIEBwYXJhbSBuZXdfbXR1IFRoZSBuZXcgTVRVIHRvIHVzZSBmb3IgdGhpcyBpbnRlcmZhY2UuCiAqCiAqIEByZXR1cm4gMCBvbiBzdWNjZXNzLCAtRUlOVkFMIGlmIE1UVSBpcyBvdXQgb2YgdmFsaWQgcmFuZ2UuCiAqICAgICAgICAgKHZhbGlkIHJhbmdlIGlzIDU3NiAuLiA2NTUyNykuIElmIFZNIGlzIG9uIHRoZQogKiAgICAgICAgIHJlbW90ZSBzaWRlLCBtYXhpbXVtIE1UVSBpcyAzMjc2MCwgaG93ZXZlciB0aGlzIGlzCiAqICAgICAgICAgPGVtPm5vdDwvZW0+IGNoZWNrZWQgaGVyZS4KICovCnN0YXRpYyBpbnQKY3RjX2NoYW5nZV9tdHUoc3RydWN0IG5ldF9kZXZpY2UgKiBkZXYsIGludCBuZXdfbXR1KQp7CglzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIgPSAoc3RydWN0IGN0Y19wcml2ICopIGRldi0+cHJpdjsKCglEQkZfVEVYVCh0cmFjZSwgMywgX19GVU5DVElPTl9fKTsKCWlmICgobmV3X210dSA8IDU3NikgfHwgKG5ld19tdHUgPiA2NTUyNykgfHwKCSAgICAobmV3X210dSA+IChwcml2cHRyLT5jaGFubmVsW1JFQURdLT5tYXhfYnVmc2l6ZSAtCgkJCUxMX0hFQURFUl9MRU5HVEggLSAyKSkpCgkJcmV0dXJuIC1FSU5WQUw7CglkZXYtPm10dSA9IG5ld19tdHU7CglkZXYtPmhhcmRfaGVhZGVyX2xlbiA9IExMX0hFQURFUl9MRU5HVEggKyAyOwoJcmV0dXJuIDA7Cn0KCi8qKgogKiBSZXR1cm5zIGludGVyZmFjZSBzdGF0aXN0aWNzIG9mIGEgZGV2aWNlLgogKgogKiBAcGFyYW0gZGV2IFBvaW50ZXIgdG8gaW50ZXJmYWNlIHN0cnVjdC4KICoKICogQHJldHVybiBQb2ludGVyIHRvIHN0YXRzIHN0cnVjdCBvZiB0aGlzIGludGVyZmFjZS4KICovCnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqCmN0Y19zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqIGRldikKewoJcmV0dXJuICYoKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXYpLT5zdGF0czsKfQoKLyoKICogc3lzZnMgYXR0cmlidXRlcwogKi8KCnN0YXRpYyBzc2l6ZV90CmJ1ZmZlcl9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKewoJc3RydWN0IGN0Y19wcml2ICpwcml2OwoKCXByaXYgPSBkZXYtPmRyaXZlcl9kYXRhOwoJaWYgKCFwcml2KQoJCXJldHVybiAtRU5PREVWOwoJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsCgkJCXByaXYtPmJ1ZmZlcl9zaXplKTsKfQoKc3RhdGljIHNzaXplX3QKYnVmZmVyX3dyaXRlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQp7CglzdHJ1Y3QgY3RjX3ByaXYgKnByaXY7CglzdHJ1Y3QgbmV0X2RldmljZSAqbmRldjsKCWludCBiczE7CgljaGFyIGJ1ZmZlclsxNl07CgoJREJGX1RFWFQodHJhY2UsIDMsIF9fRlVOQ1RJT05fXyk7CglEQkZfVEVYVCh0cmFjZSwgMywgYnVmKTsKCXByaXYgPSBkZXYtPmRyaXZlcl9kYXRhOwoJaWYgKCFwcml2KSB7CgkJREJGX1RFWFQodHJhY2UsIDMsICJiZm5vcHJpdiIpOwoJCXJldHVybiAtRU5PREVWOwoJfQoKCXNzY2FuZihidWYsICIldSIsICZiczEpOwoJaWYgKGJzMSA+IENUQ19CVUZTSVpFX0xJTUlUKQoJCWdvdG8gZWludmFsOwoJaWYgKGJzMSA8ICg1NzYgKyBMTF9IRUFERVJfTEVOR1RIICsgMikpCgkJZ290byBlaW52YWw7Cglwcml2LT5idWZmZXJfc2l6ZSA9IGJzMTsJLy8ganVzdCB0byBvdmVyd3JpdGUgdGhlIGRlZmF1bHQKCgluZGV2ID0gcHJpdi0+Y2hhbm5lbFtSRUFEXS0+bmV0ZGV2OwoJaWYgKCFuZGV2KSB7CgkJREJGX1RFWFQodHJhY2UsIDMsICJiZm5vbmRldiIpOwoJCXJldHVybiAtRU5PREVWOwoJfQoKCWlmICgobmRldi0+ZmxhZ3MgJiBJRkZfUlVOTklORykgJiYKCSAgICAoYnMxIDwgKG5kZXYtPm10dSArIExMX0hFQURFUl9MRU5HVEggKyAyKSkpCgkJZ290byBlaW52YWw7CgoJcHJpdi0+Y2hhbm5lbFtSRUFEXS0+bWF4X2J1ZnNpemUgPSBiczE7Cglwcml2LT5jaGFubmVsW1dSSVRFXS0+bWF4X2J1ZnNpemUgPSBiczE7CglpZiAoIShuZGV2LT5mbGFncyAmIElGRl9SVU5OSU5HKSkKCQluZGV2LT5tdHUgPSBiczEgLSBMTF9IRUFERVJfTEVOR1RIIC0gMjsKCXByaXYtPmNoYW5uZWxbUkVBRF0tPmZsYWdzIHw9IENIQU5ORUxfRkxBR1NfQlVGU0laRV9DSEFOR0VEOwoJcHJpdi0+Y2hhbm5lbFtXUklURV0tPmZsYWdzIHw9IENIQU5ORUxfRkxBR1NfQlVGU0laRV9DSEFOR0VEOwoKCXNwcmludGYoYnVmZmVyLCAiJWQiLHByaXYtPmJ1ZmZlcl9zaXplKTsKCURCRl9URVhUKHRyYWNlLCAzLCBidWZmZXIpOwoJcmV0dXJuIGNvdW50OwoKZWludmFsOgoJREJGX1RFWFQodHJhY2UsIDMsICJidWZmX2VyciIpOwoJcmV0dXJuIC1FSU5WQUw7Cn0KCnN0YXRpYyBzc2l6ZV90CmxvZ2xldmVsX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglyZXR1cm4gc3ByaW50ZihidWYsICIlZFxuIiwgbG9nbGV2ZWwpOwp9CgpzdGF0aWMgc3NpemVfdApsb2dsZXZlbF93cml0ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKewoJaW50IGxsMTsKCglEQkZfVEVYVCh0cmFjZSwgNSwgX19GVU5DVElPTl9fKTsKCXNzY2FuZihidWYsICIlaSIsICZsbDEpOwoKCWlmICgobGwxID4gQ1RDX0xPR0xFVkVMX01BWCkgfHwgKGxsMSA8IDApKQoJCXJldHVybiAtRUlOVkFMOwoJbG9nbGV2ZWwgPSBsbDE7CglyZXR1cm4gY291bnQ7Cn0KCnN0YXRpYyB2b2lkCmN0Y19wcmludF9zdGF0aXN0aWNzKHN0cnVjdCBjdGNfcHJpdiAqcHJpdikKewoJY2hhciAqc2J1ZjsKCWNoYXIgKnA7CgoJREJGX1RFWFQodHJhY2UsIDQsIF9fRlVOQ1RJT05fXyk7CglpZiAoIXByaXYpCgkJcmV0dXJuOwoJc2J1ZiA9IGttYWxsb2MoMjA0OCwgR0ZQX0tFUk5FTCk7CglpZiAoc2J1ZiA9PSBOVUxMKQoJCXJldHVybjsKCXAgPSBzYnVmOwoKCXAgKz0gc3ByaW50ZihwLCAiICBEZXZpY2UgRlNNIHN0YXRlOiAlc1xuIiwKCQkgICAgIGZzbV9nZXRzdGF0ZV9zdHIocHJpdi0+ZnNtKSk7CglwICs9IHNwcmludGYocCwgIiAgUlggY2hhbm5lbCBGU00gc3RhdGU6ICVzXG4iLAoJCSAgICAgZnNtX2dldHN0YXRlX3N0cihwcml2LT5jaGFubmVsW1JFQURdLT5mc20pKTsKCXAgKz0gc3ByaW50ZihwLCAiICBUWCBjaGFubmVsIEZTTSBzdGF0ZTogJXNcbiIsCgkJICAgICBmc21fZ2V0c3RhdGVfc3RyKHByaXYtPmNoYW5uZWxbV1JJVEVdLT5mc20pKTsKCXAgKz0gc3ByaW50ZihwLCAiICBNYXguIFRYIGJ1ZmZlciB1c2VkOiAlbGRcbiIsCgkJICAgICBwcml2LT5jaGFubmVsW1dSSVRFXS0+cHJvZi5tYXhtdWx0aSk7CglwICs9IHNwcmludGYocCwgIiAgTWF4LiBjaGFpbmVkIFNLQnM6ICVsZFxuIiwKCQkgICAgIHByaXYtPmNoYW5uZWxbV1JJVEVdLT5wcm9mLm1heGNxdWV1ZSk7CglwICs9IHNwcmludGYocCwgIiAgVFggc2luZ2xlIHdyaXRlIG9wczogJWxkXG4iLAoJCSAgICAgcHJpdi0+Y2hhbm5lbFtXUklURV0tPnByb2YuZG9pb3Nfc2luZ2xlKTsKCXAgKz0gc3ByaW50ZihwLCAiICBUWCBtdWx0aSB3cml0ZSBvcHM6ICVsZFxuIiwKCQkgICAgIHByaXYtPmNoYW5uZWxbV1JJVEVdLT5wcm9mLmRvaW9zX211bHRpKTsKCXAgKz0gc3ByaW50ZihwLCAiICBOZXR0byBieXRlcyB3cml0dGVuOiAlbGRcbiIsCgkJICAgICBwcml2LT5jaGFubmVsW1dSSVRFXS0+cHJvZi50eGxlbik7CglwICs9IHNwcmludGYocCwgIiAgTWF4LiBUWCBJTy10aW1lOiAlbGRcbiIsCgkJICAgICBwcml2LT5jaGFubmVsW1dSSVRFXS0+cHJvZi50eF90aW1lKTsKCgljdGNfcHJfZGVidWcoIlN0YXRpc3RpY3MgZm9yICVzOlxuJXMiLAoJCSAgICAgcHJpdi0+Y2hhbm5lbFtXUklURV0tPm5ldGRldi0+bmFtZSwgc2J1Zik7CglrZnJlZShzYnVmKTsKCXJldHVybjsKfQoKc3RhdGljIHNzaXplX3QKc3RhdHNfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdiA9IGRldi0+ZHJpdmVyX2RhdGE7CglpZiAoIXByaXYpCgkJcmV0dXJuIC1FTk9ERVY7CgljdGNfcHJpbnRfc3RhdGlzdGljcyhwcml2KTsKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIjBcbiIpOwp9CgpzdGF0aWMgc3NpemVfdApzdGF0c193cml0ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKewoJc3RydWN0IGN0Y19wcml2ICpwcml2ID0gZGV2LT5kcml2ZXJfZGF0YTsKCWlmICghcHJpdikKCQlyZXR1cm4gLUVOT0RFVjsKCS8qIFJlc2V0IHN0YXRpc3RpY3MgKi8KCW1lbXNldCgmcHJpdi0+Y2hhbm5lbFtXUklURV0tPnByb2YsIDAsCgkJCXNpemVvZihwcml2LT5jaGFubmVsW1dSSVRFXS0+cHJvZikpOwoJcmV0dXJuIGNvdW50Owp9CgpzdGF0aWMgdm9pZApjdGNfbmV0ZGV2X3VucmVnaXN0ZXIoc3RydWN0IG5ldF9kZXZpY2UgKiBkZXYpCnsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdnB0cjsKCglpZiAoIWRldikKCQlyZXR1cm47Cglwcml2cHRyID0gKHN0cnVjdCBjdGNfcHJpdiAqKSBkZXYtPnByaXY7Cgl1bnJlZ2lzdGVyX25ldGRldihkZXYpOwp9CgpzdGF0aWMgaW50CmN0Y19uZXRkZXZfcmVnaXN0ZXIoc3RydWN0IG5ldF9kZXZpY2UgKiBkZXYpCnsKCXJldHVybiByZWdpc3Rlcl9uZXRkZXYoZGV2KTsKfQoKc3RhdGljIHZvaWQKY3RjX2ZyZWVfbmV0ZGV2aWNlKHN0cnVjdCBuZXRfZGV2aWNlICogZGV2LCBpbnQgZnJlZV9kZXYpCnsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdnB0cjsKCWlmICghZGV2KQoJCXJldHVybjsKCXByaXZwdHIgPSBkZXYtPnByaXY7CglpZiAocHJpdnB0cikgewoJCWlmIChwcml2cHRyLT5mc20pCgkJCWtmcmVlX2ZzbShwcml2cHRyLT5mc20pOwoJCWtmcmVlKHByaXZwdHIpOwoJfQojaWZkZWYgTU9EVUxFCglpZiAoZnJlZV9kZXYpCgkJZnJlZV9uZXRkZXYoZGV2KTsKI2VuZGlmCn0KCnN0YXRpYyBzc2l6ZV90CmN0Y19wcm90b19zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKewoJc3RydWN0IGN0Y19wcml2ICpwcml2OwoKCXByaXYgPSBkZXYtPmRyaXZlcl9kYXRhOwoJaWYgKCFwcml2KQoJCXJldHVybiAtRU5PREVWOwoKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBwcml2LT5wcm90b2NvbCk7Cn0KCnN0YXRpYyBzc2l6ZV90CmN0Y19wcm90b19zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKewoJc3RydWN0IGN0Y19wcml2ICpwcml2OwoJaW50IHZhbHVlOwoKCURCRl9URVhUKHRyYWNlLCAzLCBfX0ZVTkNUSU9OX18pOwoJcHJfZGVidWcoIiVzKCkgY2FsbGVkXG4iLCBfX0ZVTkNUSU9OX18pOwoKCXByaXYgPSBkZXYtPmRyaXZlcl9kYXRhOwoJaWYgKCFwcml2KQoJCXJldHVybiAtRU5PREVWOwoJc3NjYW5mKGJ1ZiwgIiV1IiwgJnZhbHVlKTsKCWlmICghKCh2YWx1ZSA9PSBDVENfUFJPVE9fUzM5MCkgIHx8CgkgICAgICAodmFsdWUgPT0gQ1RDX1BST1RPX0xJTlVYKSB8fAoJICAgICAgKHZhbHVlID09IENUQ19QUk9UT19PUzM5MCkpKQoJCXJldHVybiAtRUlOVkFMOwoJcHJpdi0+cHJvdG9jb2wgPSB2YWx1ZTsKCglyZXR1cm4gY291bnQ7Cn0KCnN0YXRpYyBzc2l6ZV90CmN0Y190eXBlX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglzdHJ1Y3QgY2N3Z3JvdXBfZGV2aWNlICpjZ2RldjsKCgljZ2RldiA9IHRvX2Njd2dyb3VwZGV2KGRldik7CglpZiAoIWNnZGV2KQoJCXJldHVybiAtRU5PREVWOwoKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBjdTMwODhfdHlwZVtjZ2Rldi0+Y2RldlswXS0+aWQuZHJpdmVyX2luZm9dKTsKfQoKc3RhdGljIERFVklDRV9BVFRSKGJ1ZmZlciwgMDY0NCwgYnVmZmVyX3Nob3csIGJ1ZmZlcl93cml0ZSk7CnN0YXRpYyBERVZJQ0VfQVRUUihwcm90b2NvbCwgMDY0NCwgY3RjX3Byb3RvX3Nob3csIGN0Y19wcm90b19zdG9yZSk7CnN0YXRpYyBERVZJQ0VfQVRUUih0eXBlLCAwNDQ0LCBjdGNfdHlwZV9zaG93LCBOVUxMKTsKCnN0YXRpYyBERVZJQ0VfQVRUUihsb2dsZXZlbCwgMDY0NCwgbG9nbGV2ZWxfc2hvdywgbG9nbGV2ZWxfd3JpdGUpOwpzdGF0aWMgREVWSUNFX0FUVFIoc3RhdHMsIDA2NDQsIHN0YXRzX3Nob3csIHN0YXRzX3dyaXRlKTsKCnN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpjdGNfYXR0cltdID0gewoJJmRldl9hdHRyX3Byb3RvY29sLmF0dHIsCgkmZGV2X2F0dHJfdHlwZS5hdHRyLAoJJmRldl9hdHRyX2J1ZmZlci5hdHRyLAoJTlVMTCwKfTsKCnN0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGN0Y19hdHRyX2dyb3VwID0gewoJLmF0dHJzID0gY3RjX2F0dHIsCn07CgpzdGF0aWMgaW50CmN0Y19hZGRfYXR0cmlidXRlcyhzdHJ1Y3QgZGV2aWNlICpkZXYpCnsKCWludCByYzsKCglyYyA9IGRldmljZV9jcmVhdGVfZmlsZShkZXYsICZkZXZfYXR0cl9sb2dsZXZlbCk7CglpZiAocmMpCgkJZ290byBvdXQ7CglyYyA9IGRldmljZV9jcmVhdGVfZmlsZShkZXYsICZkZXZfYXR0cl9zdGF0cyk7CglpZiAoIXJjKQoJCWdvdG8gb3V0OwoJZGV2aWNlX3JlbW92ZV9maWxlKGRldiwgJmRldl9hdHRyX2xvZ2xldmVsKTsKb3V0OgoJcmV0dXJuIHJjOwp9CgpzdGF0aWMgdm9pZApjdGNfcmVtb3ZlX2F0dHJpYnV0ZXMoc3RydWN0IGRldmljZSAqZGV2KQp7CglkZXZpY2VfcmVtb3ZlX2ZpbGUoZGV2LCAmZGV2X2F0dHJfc3RhdHMpOwoJZGV2aWNlX3JlbW92ZV9maWxlKGRldiwgJmRldl9hdHRyX2xvZ2xldmVsKTsKfQoKc3RhdGljIGludApjdGNfYWRkX2ZpbGVzKHN0cnVjdCBkZXZpY2UgKmRldikKewoJcHJfZGVidWcoIiVzKCkgY2FsbGVkXG4iLCBfX0ZVTkNUSU9OX18pOwoKCXJldHVybiBzeXNmc19jcmVhdGVfZ3JvdXAoJmRldi0+a29iaiwgJmN0Y19hdHRyX2dyb3VwKTsKfQoKc3RhdGljIHZvaWQKY3RjX3JlbW92ZV9maWxlcyhzdHJ1Y3QgZGV2aWNlICpkZXYpCnsKCXByX2RlYnVnKCIlcygpIGNhbGxlZFxuIiwgX19GVU5DVElPTl9fKTsKCglzeXNmc19yZW1vdmVfZ3JvdXAoJmRldi0+a29iaiwgJmN0Y19hdHRyX2dyb3VwKTsKfQoKLyoqCiAqIEFkZCBjdGMgc3BlY2lmaWMgYXR0cmlidXRlcy4KICogQWRkIGN0YyBwcml2YXRlIGRhdGEuCiAqCiAqIEBwYXJhbSBjZ2RldiBwb2ludGVyIHRvIGNjd2dyb3VwX2RldmljZSBqdXN0IGFkZGVkCiAqCiAqIEByZXR1cm5zIDAgb24gc3VjY2VzcywgITAgb24gZmFpbHVyZS4KICovCnN0YXRpYyBpbnQKY3RjX3Byb2JlX2RldmljZShzdHJ1Y3QgY2N3Z3JvdXBfZGV2aWNlICpjZ2RldikKewoJc3RydWN0IGN0Y19wcml2ICpwcml2OwoJaW50IHJjOwoJY2hhciBidWZmZXJbMTZdOwoKCXByX2RlYnVnKCIlcygpIGNhbGxlZFxuIiwgX19GVU5DVElPTl9fKTsKCURCRl9URVhUKHNldHVwLCAzLCBfX0ZVTkNUSU9OX18pOwoKCWlmICghZ2V0X2RldmljZSgmY2dkZXYtPmRldikpCgkJcmV0dXJuIC1FTk9ERVY7CgoJcHJpdiA9IGttYWxsb2Moc2l6ZW9mIChzdHJ1Y3QgY3RjX3ByaXYpLCBHRlBfS0VSTkVMKTsKCWlmICghcHJpdikgewoJCWN0Y19wcl9lcnIoIiVzOiBPdXQgb2YgbWVtb3J5XG4iLCBfX2Z1bmNfXyk7CgkJcHV0X2RldmljZSgmY2dkZXYtPmRldik7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJbWVtc2V0KHByaXYsIDAsIHNpemVvZiAoc3RydWN0IGN0Y19wcml2KSk7CglyYyA9IGN0Y19hZGRfZmlsZXMoJmNnZGV2LT5kZXYpOwoJaWYgKHJjKSB7CgkJa2ZyZWUocHJpdik7CgkJcHV0X2RldmljZSgmY2dkZXYtPmRldik7CgkJcmV0dXJuIHJjOwoJfQoJcHJpdi0+YnVmZmVyX3NpemUgPSBDVENfQlVGU0laRV9ERUZBVUxUOwoJY2dkZXYtPmNkZXZbMF0tPmhhbmRsZXIgPSBjdGNfaXJxX2hhbmRsZXI7CgljZ2Rldi0+Y2RldlsxXS0+aGFuZGxlciA9IGN0Y19pcnFfaGFuZGxlcjsKCWNnZGV2LT5kZXYuZHJpdmVyX2RhdGEgPSBwcml2OwoKCXNwcmludGYoYnVmZmVyLCAiJXAiLCBwcml2KTsKCURCRl9URVhUKGRhdGEsIDMsIGJ1ZmZlcik7CgoJc3ByaW50ZihidWZmZXIsICIldSIsICh1bnNpZ25lZCBpbnQpc2l6ZW9mKHN0cnVjdCBjdGNfcHJpdikpOwoJREJGX1RFWFQoZGF0YSwgMywgYnVmZmVyKTsKCglzcHJpbnRmKGJ1ZmZlciwgIiVwIiwgJmNoYW5uZWxzKTsKCURCRl9URVhUKGRhdGEsIDMsIGJ1ZmZlcik7CgoJc3ByaW50ZihidWZmZXIsICIldSIsICh1bnNpZ25lZCBpbnQpc2l6ZW9mKHN0cnVjdCBjaGFubmVsKSk7CglEQkZfVEVYVChkYXRhLCAzLCBidWZmZXIpOwoKCXJldHVybiAwOwp9CgovKioKICogSW5pdGlhbGl6ZSBldmVyeXRoaW5nIG9mIHRoZSBuZXQgZGV2aWNlIGV4Y2VwdCB0aGUgbmFtZSBhbmQgdGhlCiAqIGNoYW5uZWwgc3RydWN0cy4KICovCnN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZSAqCmN0Y19pbml0X25ldGRldmljZShzdHJ1Y3QgbmV0X2RldmljZSAqIGRldiwgaW50IGFsbG9jX2RldmljZSwKCQkgICBzdHJ1Y3QgY3RjX3ByaXYgKnByaXZwdHIpCnsKCWlmICghcHJpdnB0cikKCQlyZXR1cm4gTlVMTDsKCglEQkZfVEVYVChzZXR1cCwgMywgX19GVU5DVElPTl9fKTsKCglpZiAoYWxsb2NfZGV2aWNlKSB7CgkJZGV2ID0ga21hbGxvYyhzaXplb2YgKHN0cnVjdCBuZXRfZGV2aWNlKSwgR0ZQX0tFUk5FTCk7CgkJaWYgKCFkZXYpCgkJCXJldHVybiBOVUxMOwoJCW1lbXNldChkZXYsIDAsIHNpemVvZiAoc3RydWN0IG5ldF9kZXZpY2UpKTsKCX0KCglkZXYtPnByaXYgPSBwcml2cHRyOwoJcHJpdnB0ci0+ZnNtID0gaW5pdF9mc20oImN0Y2RldiIsIGRldl9zdGF0ZV9uYW1lcywKCQkJCWRldl9ldmVudF9uYW1lcywgQ1RDX05SX0RFVl9TVEFURVMsIENUQ19OUl9ERVZfRVZFTlRTLAoJCQkJZGV2X2ZzbSwgREVWX0ZTTV9MRU4sIEdGUF9LRVJORUwpOwoJaWYgKHByaXZwdHItPmZzbSA9PSBOVUxMKSB7CgkJaWYgKGFsbG9jX2RldmljZSkKCQkJa2ZyZWUoZGV2KTsKCQlyZXR1cm4gTlVMTDsKCX0KCWZzbV9uZXdzdGF0ZShwcml2cHRyLT5mc20sIERFVl9TVEFURV9TVE9QUEVEKTsKCWZzbV9zZXR0aW1lcihwcml2cHRyLT5mc20sICZwcml2cHRyLT5yZXN0YXJ0X3RpbWVyKTsKCWlmIChkZXYtPm10dSA9PSAwKQoJCWRldi0+bXR1ID0gQ1RDX0JVRlNJWkVfREVGQVVMVCAtIExMX0hFQURFUl9MRU5HVEggLSAyOwoJZGV2LT5oYXJkX3N0YXJ0X3htaXQgPSBjdGNfdHg7CglkZXYtPm9wZW4gPSBjdGNfb3BlbjsKCWRldi0+c3RvcCA9IGN0Y19jbG9zZTsKCWRldi0+Z2V0X3N0YXRzID0gY3RjX3N0YXRzOwoJZGV2LT5jaGFuZ2VfbXR1ID0gY3RjX2NoYW5nZV9tdHU7CglkZXYtPmhhcmRfaGVhZGVyX2xlbiA9IExMX0hFQURFUl9MRU5HVEggKyAyOwoJZGV2LT5hZGRyX2xlbiA9IDA7CglkZXYtPnR5cGUgPSBBUlBIUkRfU0xJUDsKCWRldi0+dHhfcXVldWVfbGVuID0gMTAwOwoJZGV2LT5mbGFncyA9IElGRl9QT0lOVE9QT0lOVCB8IElGRl9OT0FSUDsKCVNFVF9NT0RVTEVfT1dORVIoZGV2KTsKCXJldHVybiBkZXY7Cn0KCgovKioKICoKICogU2V0dXAgYW4gaW50ZXJmYWNlLgogKgogKiBAcGFyYW0gY2dkZXYgIERldmljZSB0byBiZSBzZXR1cC4KICoKICogQHJldHVybnMgMCBvbiBzdWNjZXNzLCAhMCBvbiBmYWlsdXJlLgogKi8Kc3RhdGljIGludApjdGNfbmV3X2RldmljZShzdHJ1Y3QgY2N3Z3JvdXBfZGV2aWNlICpjZ2RldikKewoJY2hhciByZWFkX2lkW0NUQ19JRF9TSVpFXTsKCWNoYXIgd3JpdGVfaWRbQ1RDX0lEX1NJWkVdOwoJaW50IGRpcmVjdGlvbjsKCWVudW0gY2hhbm5lbF90eXBlcyB0eXBlOwoJc3RydWN0IGN0Y19wcml2ICpwcml2cHRyOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldjsKCWludCByZXQ7CgljaGFyIGJ1ZmZlclsxNl07CgoJcHJfZGVidWcoIiVzKCkgY2FsbGVkXG4iLCBfX0ZVTkNUSU9OX18pOwoJREJGX1RFWFQoc2V0dXAsIDMsIF9fRlVOQ1RJT05fXyk7CgoJcHJpdnB0ciA9IGNnZGV2LT5kZXYuZHJpdmVyX2RhdGE7CglpZiAoIXByaXZwdHIpCgkJcmV0dXJuIC1FTk9ERVY7CgoJc3ByaW50ZihidWZmZXIsICIlZCIsIHByaXZwdHItPmJ1ZmZlcl9zaXplKTsKCURCRl9URVhUKHNldHVwLCAzLCBidWZmZXIpOwoKCXR5cGUgPSBnZXRfY2hhbm5lbF90eXBlKCZjZ2Rldi0+Y2RldlswXS0+aWQpOwoKCXNucHJpbnRmKHJlYWRfaWQsIENUQ19JRF9TSVpFLCAiY2gtJXMiLCBjZ2Rldi0+Y2RldlswXS0+ZGV2LmJ1c19pZCk7CglzbnByaW50Zih3cml0ZV9pZCwgQ1RDX0lEX1NJWkUsICJjaC0lcyIsIGNnZGV2LT5jZGV2WzFdLT5kZXYuYnVzX2lkKTsKCglpZiAoYWRkX2NoYW5uZWwoY2dkZXYtPmNkZXZbMF0sIHR5cGUpKQoJCXJldHVybiAtRU5PTUVNOwoJaWYgKGFkZF9jaGFubmVsKGNnZGV2LT5jZGV2WzFdLCB0eXBlKSkKCQlyZXR1cm4gLUVOT01FTTsKCglyZXQgPSBjY3dfZGV2aWNlX3NldF9vbmxpbmUoY2dkZXYtPmNkZXZbMF0pOwoJaWYgKHJldCAhPSAwKSB7CgkJCXByaW50ayhLRVJOX1dBUk5JTkcKCQkgCSJjY3dfZGV2aWNlX3NldF9vbmxpbmUgKGNkZXZbMF0pIGZhaWxlZCB3aXRoIHJldCA9ICVkXG4iLCByZXQpOwoJfQoKCXJldCA9IGNjd19kZXZpY2Vfc2V0X29ubGluZShjZ2Rldi0+Y2RldlsxXSk7CglpZiAocmV0ICE9IDApIHsKCQkJcHJpbnRrKEtFUk5fV0FSTklORwoJCSAJImNjd19kZXZpY2Vfc2V0X29ubGluZSAoY2RldlsxXSkgZmFpbGVkIHdpdGggcmV0ID0gJWRcbiIsIHJldCk7Cgl9CgoJZGV2ID0gY3RjX2luaXRfbmV0ZGV2aWNlKE5VTEwsIDEsIHByaXZwdHIpOwoKCWlmICghZGV2KSB7CgkJY3RjX3ByX3dhcm4oImN0Y19pbml0X25ldGRldmljZSBmYWlsZWRcbiIpOwoJCWdvdG8gb3V0OwoJfQoKCXN0cmxjcHkoZGV2LT5uYW1lLCAiY3RjJWQiLCBJRk5BTVNJWik7CgoJZm9yIChkaXJlY3Rpb24gPSBSRUFEOyBkaXJlY3Rpb24gPD0gV1JJVEU7IGRpcmVjdGlvbisrKSB7CgkJcHJpdnB0ci0+Y2hhbm5lbFtkaXJlY3Rpb25dID0KCQkgICAgY2hhbm5lbF9nZXQodHlwZSwgZGlyZWN0aW9uID09IFJFQUQgPyByZWFkX2lkIDogd3JpdGVfaWQsCgkJCQlkaXJlY3Rpb24pOwoJCWlmIChwcml2cHRyLT5jaGFubmVsW2RpcmVjdGlvbl0gPT0gTlVMTCkgewoJCQlpZiAoZGlyZWN0aW9uID09IFdSSVRFKQoJCQkJY2hhbm5lbF9mcmVlKHByaXZwdHItPmNoYW5uZWxbUkVBRF0pOwoKCQkJY3RjX2ZyZWVfbmV0ZGV2aWNlKGRldiwgMSk7CgkJCWdvdG8gb3V0OwoJCX0KCQlwcml2cHRyLT5jaGFubmVsW2RpcmVjdGlvbl0tPm5ldGRldiA9IGRldjsKCQlwcml2cHRyLT5jaGFubmVsW2RpcmVjdGlvbl0tPnByb3RvY29sID0gcHJpdnB0ci0+cHJvdG9jb2w7CgkJcHJpdnB0ci0+Y2hhbm5lbFtkaXJlY3Rpb25dLT5tYXhfYnVmc2l6ZSA9IHByaXZwdHItPmJ1ZmZlcl9zaXplOwoJfQoJLyogc3lzZnMgbWFnaWMgKi8KCVNFVF9ORVRERVZfREVWKGRldiwgJmNnZGV2LT5kZXYpOwoKCWlmIChjdGNfbmV0ZGV2X3JlZ2lzdGVyKGRldikgIT0gMCkgewoJCWN0Y19mcmVlX25ldGRldmljZShkZXYsIDEpOwoJCWdvdG8gb3V0OwoJfQoKCWlmIChjdGNfYWRkX2F0dHJpYnV0ZXMoJmNnZGV2LT5kZXYpKSB7CgkJY3RjX25ldGRldl91bnJlZ2lzdGVyKGRldik7CgkJZGV2LT5wcml2ID0gTlVMTDsKCQljdGNfZnJlZV9uZXRkZXZpY2UoZGV2LCAxKTsKCQlnb3RvIG91dDsKCX0KCglzdHJsY3B5KHByaXZwdHItPmZzbS0+bmFtZSwgZGV2LT5uYW1lLCBzaXplb2YgKHByaXZwdHItPmZzbS0+bmFtZSkpOwoKCXByaW50X2Jhbm5lcigpOwoKCWN0Y19wcl9pbmZvKCIlczogcmVhZDogJXMsIHdyaXRlOiAlcywgcHJvdG86ICVkXG4iLAoJCSAgICBkZXYtPm5hbWUsIHByaXZwdHItPmNoYW5uZWxbUkVBRF0tPmlkLAoJCSAgICBwcml2cHRyLT5jaGFubmVsW1dSSVRFXS0+aWQsIHByaXZwdHItPnByb3RvY29sKTsKCglyZXR1cm4gMDsKb3V0OgoJY2N3X2RldmljZV9zZXRfb2ZmbGluZShjZ2Rldi0+Y2RldlsxXSk7CgljY3dfZGV2aWNlX3NldF9vZmZsaW5lKGNnZGV2LT5jZGV2WzBdKTsKCglyZXR1cm4gLUVOT0RFVjsKfQoKLyoqCiAqIFNodXRkb3duIGFuIGludGVyZmFjZS4KICoKICogQHBhcmFtIGNnZGV2ICBEZXZpY2UgdG8gYmUgc2h1dCBkb3duLgogKgogKiBAcmV0dXJucyAwIG9uIHN1Y2Nlc3MsICEwIG9uIGZhaWx1cmUuCiAqLwpzdGF0aWMgaW50CmN0Y19zaHV0ZG93bl9kZXZpY2Uoc3RydWN0IGNjd2dyb3VwX2RldmljZSAqY2dkZXYpCnsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdjsKCXN0cnVjdCBuZXRfZGV2aWNlICpuZGV2OwoKCURCRl9URVhUKHNldHVwLCAzLCBfX0ZVTkNUSU9OX18pOwoJcHJfZGVidWcoIiVzKCkgY2FsbGVkXG4iLCBfX0ZVTkNUSU9OX18pOwoKCglwcml2ID0gY2dkZXYtPmRldi5kcml2ZXJfZGF0YTsKCW5kZXYgPSBOVUxMOwoJaWYgKCFwcml2KQoJCXJldHVybiAtRU5PREVWOwoKCWlmIChwcml2LT5jaGFubmVsW1JFQURdKSB7CgkJbmRldiA9IHByaXYtPmNoYW5uZWxbUkVBRF0tPm5ldGRldjsKCgkJLyogQ2xvc2UgdGhlIGRldmljZSAqLwoJCWN0Y19jbG9zZShuZGV2KTsKCQluZGV2LT5mbGFncyAmPX5JRkZfUlVOTklORzsKCgkJY3RjX3JlbW92ZV9hdHRyaWJ1dGVzKCZjZ2Rldi0+ZGV2KTsKCgkJY2hhbm5lbF9mcmVlKHByaXYtPmNoYW5uZWxbUkVBRF0pOwoJfQoJaWYgKHByaXYtPmNoYW5uZWxbV1JJVEVdKQoJCWNoYW5uZWxfZnJlZShwcml2LT5jaGFubmVsW1dSSVRFXSk7CgoJaWYgKG5kZXYpIHsKCQljdGNfbmV0ZGV2X3VucmVnaXN0ZXIobmRldik7CgkJbmRldi0+cHJpdiA9IE5VTEw7CgkJY3RjX2ZyZWVfbmV0ZGV2aWNlKG5kZXYsIDEpOwoJfQoKCWlmIChwcml2LT5mc20pCgkJa2ZyZWVfZnNtKHByaXYtPmZzbSk7CgoJY2N3X2RldmljZV9zZXRfb2ZmbGluZShjZ2Rldi0+Y2RldlsxXSk7CgljY3dfZGV2aWNlX3NldF9vZmZsaW5lKGNnZGV2LT5jZGV2WzBdKTsKCglpZiAocHJpdi0+Y2hhbm5lbFtSRUFEXSkKCQljaGFubmVsX3JlbW92ZShwcml2LT5jaGFubmVsW1JFQURdKTsKCWlmIChwcml2LT5jaGFubmVsW1dSSVRFXSkKCQljaGFubmVsX3JlbW92ZShwcml2LT5jaGFubmVsW1dSSVRFXSk7Cglwcml2LT5jaGFubmVsW1JFQURdID0gcHJpdi0+Y2hhbm5lbFtXUklURV0gPSBOVUxMOwoKCXJldHVybiAwOwoKfQoKc3RhdGljIHZvaWQKY3RjX3JlbW92ZV9kZXZpY2Uoc3RydWN0IGNjd2dyb3VwX2RldmljZSAqY2dkZXYpCnsKCXN0cnVjdCBjdGNfcHJpdiAqcHJpdjsKCglwcl9kZWJ1ZygiJXMoKSBjYWxsZWRcbiIsIF9fRlVOQ1RJT05fXyk7CglEQkZfVEVYVChzZXR1cCwgMywgX19GVU5DVElPTl9fKTsKCglwcml2ID0gY2dkZXYtPmRldi5kcml2ZXJfZGF0YTsKCWlmICghcHJpdikKCQlyZXR1cm47CglpZiAoY2dkZXYtPnN0YXRlID09IENDV0dST1VQX09OTElORSkKCQljdGNfc2h1dGRvd25fZGV2aWNlKGNnZGV2KTsKCWN0Y19yZW1vdmVfZmlsZXMoJmNnZGV2LT5kZXYpOwoJY2dkZXYtPmRldi5kcml2ZXJfZGF0YSA9IE5VTEw7CglrZnJlZShwcml2KTsKCXB1dF9kZXZpY2UoJmNnZGV2LT5kZXYpOwp9CgpzdGF0aWMgc3RydWN0IGNjd2dyb3VwX2RyaXZlciBjdGNfZ3JvdXBfZHJpdmVyID0gewoJLm93bmVyICAgICAgID0gVEhJU19NT0RVTEUsCgkubmFtZSAgICAgICAgPSAiY3RjIiwKCS5tYXhfc2xhdmVzICA9IDIsCgkuZHJpdmVyX2lkICAgPSAweEMzRTNDMywKCS5wcm9iZSAgICAgICA9IGN0Y19wcm9iZV9kZXZpY2UsCgkucmVtb3ZlICAgICAgPSBjdGNfcmVtb3ZlX2RldmljZSwKCS5zZXRfb25saW5lICA9IGN0Y19uZXdfZGV2aWNlLAoJLnNldF9vZmZsaW5lID0gY3RjX3NodXRkb3duX2RldmljZSwKfTsKCi8qKgogKiBNb2R1bGUgcmVsYXRlZCByb3V0aW5lcwogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgovKioKICogUHJlcGFyZSB0byBiZSB1bmxvYWRlZC4gRnJlZSBJUlEncyBhbmQgcmVsZWFzZSBhbGwgcmVzb3VyY2VzLgogKiBUaGlzIGlzIGNhbGxlZCBqdXN0IGJlZm9yZSB0aGlzIG1vZHVsZSBpcyB1bmxvYWRlZC4gSXQgaXMKICogPGVtPm5vdDwvZW0+IGNhbGxlZCwgaWYgdGhlIHVzYWdlIGNvdW50IGlzICEwLCBzbyB3ZSBkb24ndCBuZWVkIHRvIGNoZWNrCiAqIGZvciB0aGF0LgogKi8Kc3RhdGljIHZvaWQgX19leGl0CmN0Y19leGl0KHZvaWQpCnsKCURCRl9URVhUKHNldHVwLCAzLCBfX0ZVTkNUSU9OX18pOwoJdW5yZWdpc3Rlcl9jdTMwODhfZGlzY2lwbGluZSgmY3RjX2dyb3VwX2RyaXZlcik7CgljdGNfdW5yZWdpc3Rlcl9kYmZfdmlld3MoKTsKCWN0Y19wcl9pbmZvKCJDVEMgZHJpdmVyIHVubG9hZGVkXG4iKTsKfQoKLyoqCiAqIEluaXRpYWxpemUgbW9kdWxlLgogKiBUaGlzIGlzIGNhbGxlZCBqdXN0IGFmdGVyIHRoZSBtb2R1bGUgaXMgbG9hZGVkLgogKgogKiBAcmV0dXJuIDAgb24gc3VjY2VzcywgITAgb24gZXJyb3IuCiAqLwpzdGF0aWMgaW50IF9faW5pdApjdGNfaW5pdCh2b2lkKQp7CglpbnQgcmV0ID0gMDsKCglsb2dsZXZlbCA9IENUQ19MT0dMRVZFTF9ERUZBVUxUOwoKCURCRl9URVhUKHNldHVwLCAzLCBfX0ZVTkNUSU9OX18pOwoKCXByaW50X2Jhbm5lcigpOwoKCXJldCA9IGN0Y19yZWdpc3Rlcl9kYmZfdmlld3MoKTsKCWlmIChyZXQpewoJCWN0Y19wcl9jcml0KCJjdGNfaW5pdCBmYWlsZWQgd2l0aCBjdGNfcmVnaXN0ZXJfZGJmX3ZpZXdzIHJjID0gJWRcbiIsIHJldCk7CgkJcmV0dXJuIHJldDsKCX0KCXJldCA9IHJlZ2lzdGVyX2N1MzA4OF9kaXNjaXBsaW5lKCZjdGNfZ3JvdXBfZHJpdmVyKTsKCWlmIChyZXQpIHsKCQljdGNfdW5yZWdpc3Rlcl9kYmZfdmlld3MoKTsKCX0KCXJldHVybiByZXQ7Cn0KCm1vZHVsZV9pbml0KGN0Y19pbml0KTsKbW9kdWxlX2V4aXQoY3RjX2V4aXQpOwoKLyogLS0tIFRoaXMgaXMgdGhlIEVORCBteSBmcmllbmQgLS0tICovCg==