LyoKICogIGxpbnV4L2RyaXZlcnMvbW1jL2hvc3Qvb21hcC5jCiAqCiAqICBDb3B5cmlnaHQgKEMpIDIwMDQgTm9raWEgQ29ycG9yYXRpb24KICogIFdyaXR0ZW4gYnkgVHV1a2thIFRpa2thbmVuIGFuZCBKdWhhIFlyavZs5DxqdWhhLnlyam9sYUBub2tpYS5jb20+CiAqICBNaXNjIGhhY2tzIGhlcmUgYW5kIHRoZXJlIGJ5IFRvbnkgTGluZGdyZW4gPHRvbnlAYXRvbWlkZS5jb20+CiAqICBPdGhlciBoYWNrcyAoRE1BLCBTRCwgZXRjKSBieSBEYXZpZCBCcm93bmVsbAogKgogKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwogKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KICovCgojaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgojaW5jbHVkZSA8bGludXgvdGltZXIuaD4KI2luY2x1ZGUgPGxpbnV4L21tYy9ob3N0Lmg+CiNpbmNsdWRlIDxsaW51eC9tbWMvY2FyZC5oPgojaW5jbHVkZSA8bGludXgvY2xrLmg+CgojaW5jbHVkZSA8YXNtL2lvLmg+CiNpbmNsdWRlIDxhc20vaXJxLmg+CiNpbmNsdWRlIDxhc20vc2NhdHRlcmxpc3QuaD4KI2luY2x1ZGUgPGFzbS9tYWNoLXR5cGVzLmg+CgojaW5jbHVkZSA8YXNtL2FyY2gvYm9hcmQuaD4KI2luY2x1ZGUgPGFzbS9hcmNoL2dwaW8uaD4KI2luY2x1ZGUgPGFzbS9hcmNoL2RtYS5oPgojaW5jbHVkZSA8YXNtL2FyY2gvbXV4Lmg+CiNpbmNsdWRlIDxhc20vYXJjaC9mcGdhLmg+CiNpbmNsdWRlIDxhc20vYXJjaC90cHM2NTAxMC5oPgoKI2RlZmluZQlPTUFQX01NQ19SRUdfQ01ECTB4MDAKI2RlZmluZQlPTUFQX01NQ19SRUdfQVJHTAkweDA0CiNkZWZpbmUJT01BUF9NTUNfUkVHX0FSR0gJMHgwOAojZGVmaW5lCU9NQVBfTU1DX1JFR19DT04JMHgwYwojZGVmaW5lCU9NQVBfTU1DX1JFR19TVEFUCTB4MTAKI2RlZmluZQlPTUFQX01NQ19SRUdfSUUJCTB4MTQKI2RlZmluZQlPTUFQX01NQ19SRUdfQ1RPCTB4MTgKI2RlZmluZQlPTUFQX01NQ19SRUdfRFRPCTB4MWMKI2RlZmluZQlPTUFQX01NQ19SRUdfREFUQQkweDIwCiNkZWZpbmUJT01BUF9NTUNfUkVHX0JMRU4JMHgyNAojZGVmaW5lCU9NQVBfTU1DX1JFR19OQkxLCTB4MjgKI2RlZmluZQlPTUFQX01NQ19SRUdfQlVGCTB4MmMKI2RlZmluZSBPTUFQX01NQ19SRUdfU0RJTwkweDM0CiNkZWZpbmUJT01BUF9NTUNfUkVHX1JFVgkweDNjCiNkZWZpbmUJT01BUF9NTUNfUkVHX1JTUDAJMHg0MAojZGVmaW5lCU9NQVBfTU1DX1JFR19SU1AxCTB4NDQKI2RlZmluZQlPTUFQX01NQ19SRUdfUlNQMgkweDQ4CiNkZWZpbmUJT01BUF9NTUNfUkVHX1JTUDMJMHg0YwojZGVmaW5lCU9NQVBfTU1DX1JFR19SU1A0CTB4NTAKI2RlZmluZQlPTUFQX01NQ19SRUdfUlNQNQkweDU0CiNkZWZpbmUJT01BUF9NTUNfUkVHX1JTUDYJMHg1OAojZGVmaW5lCU9NQVBfTU1DX1JFR19SU1A3CTB4NWMKI2RlZmluZQlPTUFQX01NQ19SRUdfSU9TUgkweDYwCiNkZWZpbmUJT01BUF9NTUNfUkVHX1NZU0MJMHg2NAojZGVmaW5lCU9NQVBfTU1DX1JFR19TWVNTCTB4NjgKCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9DQVJEX0VSUgkJKDEgPDwgMTQpCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9DQVJEX0lSUQkJKDEgPDwgMTMpCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9PQ1JfQlVTWQkJKDEgPDwgMTIpCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9BX0VNUFRZCQkoMSA8PCAxMSkKI2RlZmluZQlPTUFQX01NQ19TVEFUX0FfRlVMTAkJKDEgPDwgMTApCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9DTURfQ1JDCQkoMSA8PCAgOCkKI2RlZmluZQlPTUFQX01NQ19TVEFUX0NNRF9UT1VUCQkoMSA8PCAgNykKI2RlZmluZQlPTUFQX01NQ19TVEFUX0RBVEFfQ1JDCQkoMSA8PCAgNikKI2RlZmluZQlPTUFQX01NQ19TVEFUX0RBVEFfVE9VVAkJKDEgPDwgIDUpCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9FTkRfQlVTWQkJKDEgPDwgIDQpCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9FTkRfT0ZfREFUQQkoMSA8PCAgMykKI2RlZmluZQlPTUFQX01NQ19TVEFUX0NBUkRfQlVTWQkJKDEgPDwgIDIpCiNkZWZpbmUJT01BUF9NTUNfU1RBVF9FTkRfT0ZfQ01ECSgxIDw8ICAwKQoKI2RlZmluZSBPTUFQX01NQ19SRUFEKGhvc3QsIHJlZykJX19yYXdfcmVhZHcoKGhvc3QpLT52aXJ0X2Jhc2UgKyBPTUFQX01NQ19SRUdfIyNyZWcpCiNkZWZpbmUgT01BUF9NTUNfV1JJVEUoaG9zdCwgcmVnLCB2YWwpCV9fcmF3X3dyaXRldygodmFsKSwgKGhvc3QpLT52aXJ0X2Jhc2UgKyBPTUFQX01NQ19SRUdfIyNyZWcpCgovKgogKiBDb21tYW5kIHR5cGVzCiAqLwojZGVmaW5lIE9NQVBfTU1DX0NNRFRZUEVfQkMJMAojZGVmaW5lIE9NQVBfTU1DX0NNRFRZUEVfQkNSCTEKI2RlZmluZSBPTUFQX01NQ19DTURUWVBFX0FDCTIKI2RlZmluZSBPTUFQX01NQ19DTURUWVBFX0FEVEMJMwoKCiNkZWZpbmUgRFJJVkVSX05BTUUgIm1tY2ktb21hcCIKCi8qIFNwZWNpZmllcyBob3cgb2Z0ZW4gaW4gbWlsbGlzZWNzIHRvIHBvbGwgZm9yIGNhcmQgc3RhdHVzIGNoYW5nZXMKICogd2hlbiB0aGUgY292ZXIgc3dpdGNoIGlzIG9wZW4gKi8KI2RlZmluZSBPTUFQX01NQ19TV0lUQ0hfUE9MTF9ERUxBWQk1MDAKCnN0YXRpYyBpbnQgbW1jX29tYXBfZW5hYmxlX3BvbGwgPSAxOwoKc3RydWN0IG1tY19vbWFwX2hvc3QgewoJaW50CQkJaW5pdGlhbGl6ZWQ7CglpbnQJCQlzdXNwZW5kZWQ7CglzdHJ1Y3QgbW1jX3JlcXVlc3QgKgltcnE7CglzdHJ1Y3QgbW1jX2NvbW1hbmQgKgljbWQ7CglzdHJ1Y3QgbW1jX2RhdGEgKglkYXRhOwoJc3RydWN0IG1tY19ob3N0ICoJbW1jOwoJc3RydWN0IGRldmljZSAqCQlkZXY7Cgl1bnNpZ25lZCBjaGFyCQlpZDsgLyogMTZ4eCBjaGlwcyBoYXZlIDIgTU1DIGJsb2NrcyAqLwoJc3RydWN0IGNsayAqCQlpY2xrOwoJc3RydWN0IGNsayAqCQlmY2xrOwoJc3RydWN0IHJlc291cmNlCQkqbWVtX3JlczsKCXZvaWQgX19pb21lbQkJKnZpcnRfYmFzZTsKCXVuc2lnbmVkIGludAkJcGh5c19iYXNlOwoJaW50CQkJaXJxOwoJdW5zaWduZWQgY2hhcgkJYnVzX21vZGU7Cgl1bnNpZ25lZCBjaGFyCQlod19idXNfbW9kZTsKCgl1bnNpZ25lZCBpbnQJCXNnX2xlbjsKCWludAkJCXNnX2lkeDsKCXUxNiAqCQkJYnVmZmVyOwoJdTMyCQkJYnVmZmVyX2J5dGVzX2xlZnQ7Cgl1MzIJCQl0b3RhbF9ieXRlc19sZWZ0OwoKCXVuc2lnbmVkCQl1c2VfZG1hOjE7Cgl1bnNpZ25lZAkJYnJzX3JlY2VpdmVkOjEsIGRtYV9kb25lOjE7Cgl1bnNpZ25lZAkJZG1hX2lzX3JlYWQ6MTsKCXVuc2lnbmVkCQlkbWFfaW5fdXNlOjE7CglpbnQJCQlkbWFfY2g7CglzcGlubG9ja190CQlkbWFfbG9jazsKCXN0cnVjdCB0aW1lcl9saXN0CWRtYV90aW1lcjsKCXVuc2lnbmVkCQlkbWFfbGVuOwoKCXNob3J0CQkJcG93ZXJfcGluOwoJc2hvcnQJCQl3cF9waW47CgoJaW50CQkJc3dpdGNoX3BpbjsKCXN0cnVjdCB3b3JrX3N0cnVjdAlzd2l0Y2hfd29yazsKCXN0cnVjdCB0aW1lcl9saXN0CXN3aXRjaF90aW1lcjsKCWludAkJCXN3aXRjaF9sYXN0X3N0YXRlOwp9OwoKc3RhdGljIGlubGluZSBpbnQKbW1jX29tYXBfY292ZXJfaXNfb3BlbihzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCkKewoJaWYgKGhvc3QtPnN3aXRjaF9waW4gPCAwKQoJCXJldHVybiAwOwoJcmV0dXJuIG9tYXBfZ2V0X2dwaW9fZGF0YWluKGhvc3QtPnN3aXRjaF9waW4pOwp9CgpzdGF0aWMgc3NpemVfdAptbWNfb21hcF9zaG93X2NvdmVyX3N3aXRjaChzdHJ1Y3QgZGV2aWNlICpkZXYsCglzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQp7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwoKCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzXG4iLCBtbWNfb21hcF9jb3Zlcl9pc19vcGVuKGhvc3QpID8gIm9wZW4iIDoKCQkJImNsb3NlZCIpOwp9CgpzdGF0aWMgREVWSUNFX0FUVFIoY292ZXJfc3dpdGNoLCBTX0lSVUdPLCBtbWNfb21hcF9zaG93X2NvdmVyX3N3aXRjaCwgTlVMTCk7CgpzdGF0aWMgc3NpemVfdAptbWNfb21hcF9zaG93X2VuYWJsZV9wb2xsKHN0cnVjdCBkZXZpY2UgKmRldiwKCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVkXG4iLCBtbWNfb21hcF9lbmFibGVfcG9sbCk7Cn0KCnN0YXRpYyBzc2l6ZV90Cm1tY19vbWFwX3N0b3JlX2VuYWJsZV9wb2xsKHN0cnVjdCBkZXZpY2UgKmRldiwKCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYsCglzaXplX3Qgc2l6ZSkKewoJaW50IGVuYWJsZV9wb2xsOwoKCWlmIChzc2NhbmYoYnVmLCAiJTEwZCIsICZlbmFibGVfcG9sbCkgIT0gMSkKCQlyZXR1cm4gLUVJTlZBTDsKCglpZiAoZW5hYmxlX3BvbGwgIT0gbW1jX29tYXBfZW5hYmxlX3BvbGwpIHsKCQlzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwoKCQltbWNfb21hcF9lbmFibGVfcG9sbCA9IGVuYWJsZV9wb2xsOwoJCWlmIChlbmFibGVfcG9sbCAmJiBob3N0LT5zd2l0Y2hfcGluID49IDApCgkJCXNjaGVkdWxlX3dvcmsoJmhvc3QtPnN3aXRjaF93b3JrKTsKCX0KCXJldHVybiBzaXplOwp9CgpzdGF0aWMgREVWSUNFX0FUVFIoZW5hYmxlX3BvbGwsIDA2NjQsCgkJICAgbW1jX29tYXBfc2hvd19lbmFibGVfcG9sbCwgbW1jX29tYXBfc3RvcmVfZW5hYmxlX3BvbGwpOwoKc3RhdGljIHZvaWQKbW1jX29tYXBfc3RhcnRfY29tbWFuZChzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCwgc3RydWN0IG1tY19jb21tYW5kICpjbWQpCnsKCXUzMiBjbWRyZWc7Cgl1MzIgcmVzcHR5cGU7Cgl1MzIgY21kdHlwZTsKCglob3N0LT5jbWQgPSBjbWQ7CgoJcmVzcHR5cGUgPSAwOwoJY21kdHlwZSA9IDA7CgoJLyogT3VyIGhhcmR3YXJlIG5lZWRzIHRvIGtub3cgZXhhY3QgdHlwZSAqLwoJc3dpdGNoIChtbWNfcmVzcF90eXBlKGNtZCkpIHsKCWNhc2UgTU1DX1JTUF9OT05FOgoJCWJyZWFrOwoJY2FzZSBNTUNfUlNQX1IxOgoJY2FzZSBNTUNfUlNQX1IxQjoKCQkvKiByZXNwIDEsIDFiLCA2LCA3ICovCgkJcmVzcHR5cGUgPSAxOwoJCWJyZWFrOwoJY2FzZSBNTUNfUlNQX1IyOgoJCXJlc3B0eXBlID0gMjsKCQlicmVhazsKCWNhc2UgTU1DX1JTUF9SMzoKCQlyZXNwdHlwZSA9IDM7CgkJYnJlYWs7CglkZWZhdWx0OgoJCWRldl9lcnIobW1jX2Rldihob3N0LT5tbWMpLCAiSW52YWxpZCByZXNwb25zZSB0eXBlOiAlMDR4XG4iLCBtbWNfcmVzcF90eXBlKGNtZCkpOwoJCWJyZWFrOwoJfQoKCWlmIChtbWNfY21kX3R5cGUoY21kKSA9PSBNTUNfQ01EX0FEVEMpIHsKCQljbWR0eXBlID0gT01BUF9NTUNfQ01EVFlQRV9BRFRDOwoJfSBlbHNlIGlmIChtbWNfY21kX3R5cGUoY21kKSA9PSBNTUNfQ01EX0JDKSB7CgkJY21kdHlwZSA9IE9NQVBfTU1DX0NNRFRZUEVfQkM7Cgl9IGVsc2UgaWYgKG1tY19jbWRfdHlwZShjbWQpID09IE1NQ19DTURfQkNSKSB7CgkJY21kdHlwZSA9IE9NQVBfTU1DX0NNRFRZUEVfQkNSOwoJfSBlbHNlIHsKCQljbWR0eXBlID0gT01BUF9NTUNfQ01EVFlQRV9BQzsKCX0KCgljbWRyZWcgPSBjbWQtPm9wY29kZSB8IChyZXNwdHlwZSA8PCA4KSB8IChjbWR0eXBlIDw8IDEyKTsKCglpZiAoaG9zdC0+YnVzX21vZGUgPT0gTU1DX0JVU01PREVfT1BFTkRSQUlOKQoJCWNtZHJlZyB8PSAxIDw8IDY7CgoJaWYgKGNtZC0+ZmxhZ3MgJiBNTUNfUlNQX0JVU1kpCgkJY21kcmVnIHw9IDEgPDwgMTE7CgoJaWYgKGhvc3QtPmRhdGEgJiYgIShob3N0LT5kYXRhLT5mbGFncyAmIE1NQ19EQVRBX1dSSVRFKSkKCQljbWRyZWcgfD0gMSA8PCAxNTsKCgljbGtfZW5hYmxlKGhvc3QtPmZjbGspOwoKCU9NQVBfTU1DX1dSSVRFKGhvc3QsIENUTywgMjAwKTsKCU9NQVBfTU1DX1dSSVRFKGhvc3QsIEFSR0wsIGNtZC0+YXJnICYgMHhmZmZmKTsKCU9NQVBfTU1DX1dSSVRFKGhvc3QsIEFSR0gsIGNtZC0+YXJnID4+IDE2KTsKCU9NQVBfTU1DX1dSSVRFKGhvc3QsIElFLAoJCSAgICAgICBPTUFQX01NQ19TVEFUX0FfRU1QVFkgICAgfCBPTUFQX01NQ19TVEFUX0FfRlVMTCAgICB8CgkJICAgICAgIE9NQVBfTU1DX1NUQVRfQ01EX0NSQyAgICB8IE9NQVBfTU1DX1NUQVRfQ01EX1RPVVQgIHwKCQkgICAgICAgT01BUF9NTUNfU1RBVF9EQVRBX0NSQyAgIHwgT01BUF9NTUNfU1RBVF9EQVRBX1RPVVQgfAoJCSAgICAgICBPTUFQX01NQ19TVEFUX0VORF9PRl9DTUQgfCBPTUFQX01NQ19TVEFUX0NBUkRfRVJSICB8CgkJICAgICAgIE9NQVBfTU1DX1NUQVRfRU5EX09GX0RBVEEpOwoJT01BUF9NTUNfV1JJVEUoaG9zdCwgQ01ELCBjbWRyZWcpOwp9CgpzdGF0aWMgdm9pZAptbWNfb21hcF94ZmVyX2RvbmUoc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QsIHN0cnVjdCBtbWNfZGF0YSAqZGF0YSkKewoJaWYgKGhvc3QtPmRtYV9pbl91c2UpIHsKCQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkbWFfZGF0YV9kaXI7CgoJCUJVR19PTihob3N0LT5kbWFfY2ggPCAwKTsKCQlpZiAoZGF0YS0+ZXJyb3IgIT0gTU1DX0VSUl9OT05FKQoJCQlvbWFwX3N0b3BfZG1hKGhvc3QtPmRtYV9jaCk7CgkJLyogUmVsZWFzZSBETUEgY2hhbm5lbCBsYXppbHkgKi8KCQltb2RfdGltZXIoJmhvc3QtPmRtYV90aW1lciwgamlmZmllcyArIEhaKTsKCQlpZiAoZGF0YS0+ZmxhZ3MgJiBNTUNfREFUQV9XUklURSkKCQkJZG1hX2RhdGFfZGlyID0gRE1BX1RPX0RFVklDRTsKCQllbHNlCgkJCWRtYV9kYXRhX2RpciA9IERNQV9GUk9NX0RFVklDRTsKCQlkbWFfdW5tYXBfc2cobW1jX2Rldihob3N0LT5tbWMpLCBkYXRhLT5zZywgaG9zdC0+c2dfbGVuLAoJCQkgICAgIGRtYV9kYXRhX2Rpcik7Cgl9Cglob3N0LT5kYXRhID0gTlVMTDsKCWhvc3QtPnNnX2xlbiA9IDA7CgljbGtfZGlzYWJsZShob3N0LT5mY2xrKTsKCgkvKiBOT1RFOiAgTU1DIGxheWVyIHdpbGwgc29tZXRpbWVzIHBvbGwtd2FpdCBDTUQxMyBuZXh0LCBpc3N1aW5nCgkgKiBkb3plbnMgb2YgcmVxdWVzdHMgdW50aWwgdGhlIGNhcmQgZmluaXNoZXMgd3JpdGluZyBkYXRhLgoJICogSXQnZCBiZSBjaGVhcGVyIHRvIGp1c3Qgd2FpdCB0aWxsIGFuIEVPRkIgaW50ZXJydXB0IGFycml2ZXMuLi4KCSAqLwoKCWlmICghZGF0YS0+c3RvcCkgewoJCWhvc3QtPm1ycSA9IE5VTEw7CgkJbW1jX3JlcXVlc3RfZG9uZShob3N0LT5tbWMsIGRhdGEtPm1ycSk7CgkJcmV0dXJuOwoJfQoKCW1tY19vbWFwX3N0YXJ0X2NvbW1hbmQoaG9zdCwgZGF0YS0+c3RvcCk7Cn0KCnN0YXRpYyB2b2lkCm1tY19vbWFwX2VuZF9vZl9kYXRhKHN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0LCBzdHJ1Y3QgbW1jX2RhdGEgKmRhdGEpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglpbnQgZG9uZTsKCglpZiAoIWhvc3QtPmRtYV9pbl91c2UpIHsKCQltbWNfb21hcF94ZmVyX2RvbmUoaG9zdCwgZGF0YSk7CgkJcmV0dXJuOwoJfQoJZG9uZSA9IDA7CglzcGluX2xvY2tfaXJxc2F2ZSgmaG9zdC0+ZG1hX2xvY2ssIGZsYWdzKTsKCWlmIChob3N0LT5kbWFfZG9uZSkKCQlkb25lID0gMTsKCWVsc2UKCQlob3N0LT5icnNfcmVjZWl2ZWQgPSAxOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaG9zdC0+ZG1hX2xvY2ssIGZsYWdzKTsKCWlmIChkb25lKQoJCW1tY19vbWFwX3hmZXJfZG9uZShob3N0LCBkYXRhKTsKfQoKc3RhdGljIHZvaWQKbW1jX29tYXBfZG1hX3RpbWVyKHVuc2lnbmVkIGxvbmcgZGF0YSkKewoJc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QgPSAoc3RydWN0IG1tY19vbWFwX2hvc3QgKikgZGF0YTsKCglCVUdfT04oaG9zdC0+ZG1hX2NoIDwgMCk7CglvbWFwX2ZyZWVfZG1hKGhvc3QtPmRtYV9jaCk7Cglob3N0LT5kbWFfY2ggPSAtMTsKfQoKc3RhdGljIHZvaWQKbW1jX29tYXBfZG1hX2RvbmUoc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QsIHN0cnVjdCBtbWNfZGF0YSAqZGF0YSkKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWludCBkb25lOwoKCWRvbmUgPSAwOwoJc3Bpbl9sb2NrX2lycXNhdmUoJmhvc3QtPmRtYV9sb2NrLCBmbGFncyk7CglpZiAoaG9zdC0+YnJzX3JlY2VpdmVkKQoJCWRvbmUgPSAxOwoJZWxzZQoJCWhvc3QtPmRtYV9kb25lID0gMTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhvc3QtPmRtYV9sb2NrLCBmbGFncyk7CglpZiAoZG9uZSkKCQltbWNfb21hcF94ZmVyX2RvbmUoaG9zdCwgZGF0YSk7Cn0KCnN0YXRpYyB2b2lkCm1tY19vbWFwX2NtZF9kb25lKHN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0LCBzdHJ1Y3QgbW1jX2NvbW1hbmQgKmNtZCkKewoJaG9zdC0+Y21kID0gTlVMTDsKCglpZiAoY21kLT5mbGFncyAmIE1NQ19SU1BfUFJFU0VOVCkgewoJCWlmIChjbWQtPmZsYWdzICYgTU1DX1JTUF8xMzYpIHsKCQkJLyogcmVzcG9uc2UgdHlwZSAyICovCgkJCWNtZC0+cmVzcFszXSA9CgkJCQlPTUFQX01NQ19SRUFEKGhvc3QsIFJTUDApIHwKCQkJCShPTUFQX01NQ19SRUFEKGhvc3QsIFJTUDEpIDw8IDE2KTsKCQkJY21kLT5yZXNwWzJdID0KCQkJCU9NQVBfTU1DX1JFQUQoaG9zdCwgUlNQMikgfAoJCQkJKE9NQVBfTU1DX1JFQUQoaG9zdCwgUlNQMykgPDwgMTYpOwoJCQljbWQtPnJlc3BbMV0gPQoJCQkJT01BUF9NTUNfUkVBRChob3N0LCBSU1A0KSB8CgkJCQkoT01BUF9NTUNfUkVBRChob3N0LCBSU1A1KSA8PCAxNik7CgkJCWNtZC0+cmVzcFswXSA9CgkJCQlPTUFQX01NQ19SRUFEKGhvc3QsIFJTUDYpIHwKCQkJCShPTUFQX01NQ19SRUFEKGhvc3QsIFJTUDcpIDw8IDE2KTsKCQl9IGVsc2UgewoJCQkvKiByZXNwb25zZSB0eXBlcyAxLCAxYiwgMywgNCwgNSwgNiAqLwoJCQljbWQtPnJlc3BbMF0gPQoJCQkJT01BUF9NTUNfUkVBRChob3N0LCBSU1A2KSB8CgkJCQkoT01BUF9NTUNfUkVBRChob3N0LCBSU1A3KSA8PCAxNik7CgkJfQoJfQoKCWlmIChob3N0LT5kYXRhID09IE5VTEwgfHwgY21kLT5lcnJvciAhPSBNTUNfRVJSX05PTkUpIHsKCQlob3N0LT5tcnEgPSBOVUxMOwoJCWNsa19kaXNhYmxlKGhvc3QtPmZjbGspOwoJCW1tY19yZXF1ZXN0X2RvbmUoaG9zdC0+bW1jLCBjbWQtPm1ycSk7Cgl9Cn0KCi8qIFBJTyBvbmx5ICovCnN0YXRpYyB2b2lkCm1tY19vbWFwX3NnX3RvX2J1ZihzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCkKewoJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKCglzZyA9IGhvc3QtPmRhdGEtPnNnICsgaG9zdC0+c2dfaWR4OwoJaG9zdC0+YnVmZmVyX2J5dGVzX2xlZnQgPSBzZy0+bGVuZ3RoOwoJaG9zdC0+YnVmZmVyID0gcGFnZV9hZGRyZXNzKHNnLT5wYWdlKSArIHNnLT5vZmZzZXQ7CglpZiAoaG9zdC0+YnVmZmVyX2J5dGVzX2xlZnQgPiBob3N0LT50b3RhbF9ieXRlc19sZWZ0KQoJCWhvc3QtPmJ1ZmZlcl9ieXRlc19sZWZ0ID0gaG9zdC0+dG90YWxfYnl0ZXNfbGVmdDsKfQoKLyogUElPIG9ubHkgKi8Kc3RhdGljIHZvaWQKbW1jX29tYXBfeGZlcl9kYXRhKHN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0LCBpbnQgd3JpdGUpCnsKCWludCBuOwoKCWlmIChob3N0LT5idWZmZXJfYnl0ZXNfbGVmdCA9PSAwKSB7CgkJaG9zdC0+c2dfaWR4Kys7CgkJQlVHX09OKGhvc3QtPnNnX2lkeCA9PSBob3N0LT5zZ19sZW4pOwoJCW1tY19vbWFwX3NnX3RvX2J1Zihob3N0KTsKCX0KCW4gPSA2NDsKCWlmIChuID4gaG9zdC0+YnVmZmVyX2J5dGVzX2xlZnQpCgkJbiA9IGhvc3QtPmJ1ZmZlcl9ieXRlc19sZWZ0OwoJaG9zdC0+YnVmZmVyX2J5dGVzX2xlZnQgLT0gbjsKCWhvc3QtPnRvdGFsX2J5dGVzX2xlZnQgLT0gbjsKCWhvc3QtPmRhdGEtPmJ5dGVzX3hmZXJlZCArPSBuOwoKCWlmICh3cml0ZSkgewoJCV9fcmF3X3dyaXRlc3coaG9zdC0+dmlydF9iYXNlICsgT01BUF9NTUNfUkVHX0RBVEEsIGhvc3QtPmJ1ZmZlciwgbik7Cgl9IGVsc2UgewoJCV9fcmF3X3JlYWRzdyhob3N0LT52aXJ0X2Jhc2UgKyBPTUFQX01NQ19SRUdfREFUQSwgaG9zdC0+YnVmZmVyLCBuKTsKCX0KfQoKc3RhdGljIGlubGluZSB2b2lkIG1tY19vbWFwX3JlcG9ydF9pcnEodTE2IHN0YXR1cykKewoJc3RhdGljIGNvbnN0IGNoYXIgKm1tY19vbWFwX3N0YXR1c19iaXRzW10gPSB7CgkJIkVPQyIsICJDRCIsICJDQiIsICJCUlMiLCAiRU9GQiIsICJEVE8iLCAiRENSQyIsICJDVE8iLAoJCSJDQ1JDIiwgIkNSVyIsICJBRiIsICJBRSIsICJPQ1JCIiwgIkNJUlEiLCAiQ0VSUiIKCX07CglpbnQgaSwgYyA9IDA7CgoJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUobW1jX29tYXBfc3RhdHVzX2JpdHMpOyBpKyspCgkJaWYgKHN0YXR1cyAmICgxIDw8IGkpKSB7CgkJCWlmIChjKQoJCQkJcHJpbnRrKCIgIik7CgkJCXByaW50aygiJXMiLCBtbWNfb21hcF9zdGF0dXNfYml0c1tpXSk7CgkJCWMrKzsKCQl9Cn0KCnN0YXRpYyBpcnFyZXR1cm5fdCBtbWNfb21hcF9pcnEoaW50IGlycSwgdm9pZCAqZGV2X2lkKQp7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqIGhvc3QgPSAoc3RydWN0IG1tY19vbWFwX2hvc3QgKilkZXZfaWQ7Cgl1MTYgc3RhdHVzOwoJaW50IGVuZF9jb21tYW5kOwoJaW50IGVuZF90cmFuc2ZlcjsKCWludCB0cmFuc2Zlcl9lcnJvcjsKCglpZiAoaG9zdC0+Y21kID09IE5VTEwgJiYgaG9zdC0+ZGF0YSA9PSBOVUxMKSB7CgkJc3RhdHVzID0gT01BUF9NTUNfUkVBRChob3N0LCBTVEFUKTsKCQlkZXZfaW5mbyhtbWNfZGV2KGhvc3QtPm1tYyksInNwdXJpb3VzIGlycSAweCUwNHhcbiIsIHN0YXR1cyk7CgkJaWYgKHN0YXR1cyAhPSAwKSB7CgkJCU9NQVBfTU1DX1dSSVRFKGhvc3QsIFNUQVQsIHN0YXR1cyk7CgkJCU9NQVBfTU1DX1dSSVRFKGhvc3QsIElFLCAwKTsKCQl9CgkJcmV0dXJuIElSUV9IQU5ETEVEOwoJfQoKCWVuZF9jb21tYW5kID0gMDsKCWVuZF90cmFuc2ZlciA9IDA7Cgl0cmFuc2Zlcl9lcnJvciA9IDA7CgoJd2hpbGUgKChzdGF0dXMgPSBPTUFQX01NQ19SRUFEKGhvc3QsIFNUQVQpKSAhPSAwKSB7CgkJT01BUF9NTUNfV1JJVEUoaG9zdCwgU1RBVCwgc3RhdHVzKTsKI2lmZGVmIENPTkZJR19NTUNfREVCVUcKCQlkZXZfZGJnKG1tY19kZXYoaG9zdC0+bW1jKSwgIk1NQyBJUlEgJTA0eCAoQ01EICVkKTogIiwKCQkJc3RhdHVzLCBob3N0LT5jbWQgIT0gTlVMTCA/IGhvc3QtPmNtZC0+b3Bjb2RlIDogLTEpOwoJCW1tY19vbWFwX3JlcG9ydF9pcnEoc3RhdHVzKTsKCQlwcmludGsoIlxuIik7CiNlbmRpZgoJCWlmIChob3N0LT50b3RhbF9ieXRlc19sZWZ0KSB7CgkJCWlmICgoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9BX0ZVTEwpIHx8CgkJCSAgICAoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9FTkRfT0ZfREFUQSkpCgkJCQltbWNfb21hcF94ZmVyX2RhdGEoaG9zdCwgMCk7CgkJCWlmIChzdGF0dXMgJiBPTUFQX01NQ19TVEFUX0FfRU1QVFkpCgkJCQltbWNfb21hcF94ZmVyX2RhdGEoaG9zdCwgMSk7CgkJfQoKCQlpZiAoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9FTkRfT0ZfREFUQSkgewoJCQllbmRfdHJhbnNmZXIgPSAxOwoJCX0KCgkJaWYgKHN0YXR1cyAmIE9NQVBfTU1DX1NUQVRfREFUQV9UT1VUKSB7CgkJCWRldl9kYmcobW1jX2Rldihob3N0LT5tbWMpLCAiZGF0YSB0aW1lb3V0XG4iKTsKCQkJaWYgKGhvc3QtPmRhdGEpIHsKCQkJCWhvc3QtPmRhdGEtPmVycm9yIHw9IE1NQ19FUlJfVElNRU9VVDsKCQkJCXRyYW5zZmVyX2Vycm9yID0gMTsKCQkJfQoJCX0KCgkJaWYgKHN0YXR1cyAmIE9NQVBfTU1DX1NUQVRfREFUQV9DUkMpIHsKCQkJaWYgKGhvc3QtPmRhdGEpIHsKCQkJCWhvc3QtPmRhdGEtPmVycm9yIHw9IE1NQ19FUlJfQkFEQ1JDOwoJCQkJZGV2X2RiZyhtbWNfZGV2KGhvc3QtPm1tYyksCgkJCQkJICJkYXRhIENSQyBlcnJvciwgYnl0ZXMgbGVmdCAlZFxuIiwKCQkJCQlob3N0LT50b3RhbF9ieXRlc19sZWZ0KTsKCQkJCXRyYW5zZmVyX2Vycm9yID0gMTsKCQkJfSBlbHNlIHsKCQkJCWRldl9kYmcobW1jX2Rldihob3N0LT5tbWMpLCAiZGF0YSBDUkMgZXJyb3JcbiIpOwoJCQl9CgkJfQoKCQlpZiAoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9DTURfVE9VVCkgewoJCQkvKiBUaW1lb3V0cyBhcmUgcm91dGluZSB3aXRoIHNvbWUgY29tbWFuZHMgKi8KCQkJaWYgKGhvc3QtPmNtZCkgewoJCQkJaWYgKGhvc3QtPmNtZC0+b3Bjb2RlICE9IE1NQ19BTExfU0VORF9DSUQgJiYKCQkJCQkJaG9zdC0+Y21kLT5vcGNvZGUgIT0KCQkJCQkJTU1DX1NFTkRfT1BfQ09ORCAmJgoJCQkJCQlob3N0LT5jbWQtPm9wY29kZSAhPQoJCQkJCQlNTUNfQVBQX0NNRCAmJgoJCQkJCQkhbW1jX29tYXBfY292ZXJfaXNfb3Blbihob3N0KSkKCQkJCQlkZXZfZXJyKG1tY19kZXYoaG9zdC0+bW1jKSwKCQkJCQkJImNvbW1hbmQgdGltZW91dCwgQ01EICVkXG4iLAoJCQkJCQlob3N0LT5jbWQtPm9wY29kZSk7CgkJCQlob3N0LT5jbWQtPmVycm9yID0gTU1DX0VSUl9USU1FT1VUOwoJCQkJZW5kX2NvbW1hbmQgPSAxOwoJCQl9CgkJfQoKCQlpZiAoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9DTURfQ1JDKSB7CgkJCWlmIChob3N0LT5jbWQpIHsKCQkJCWRldl9lcnIobW1jX2Rldihob3N0LT5tbWMpLAoJCQkJCSJjb21tYW5kIENSQyBlcnJvciAoQ01EJWQsIGFyZyAweCUwOHgpXG4iLAoJCQkJCWhvc3QtPmNtZC0+b3Bjb2RlLCBob3N0LT5jbWQtPmFyZyk7CgkJCQlob3N0LT5jbWQtPmVycm9yID0gTU1DX0VSUl9CQURDUkM7CgkJCQllbmRfY29tbWFuZCA9IDE7CgkJCX0gZWxzZQoJCQkJZGV2X2VycihtbWNfZGV2KGhvc3QtPm1tYyksCgkJCQkJImNvbW1hbmQgQ1JDIGVycm9yIHdpdGhvdXQgY21kP1xuIik7CgkJfQoKCQlpZiAoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9DQVJEX0VSUikgewoJCQlkZXZfZGJnKG1tY19kZXYoaG9zdC0+bW1jKSwKCQkJCSJpZ25vcmluZyBjYXJkIHN0YXR1cyBlcnJvciAoQ01EJWQpXG4iLAoJCQkJaG9zdC0+Y21kLT5vcGNvZGUpOwoJCQllbmRfY29tbWFuZCA9IDE7CgkJfQoKCQkvKgoJCSAqIE5PVEU6IE9uIDE2MTAgdGhlIEVORF9PRl9DTUQgbWF5IGNvbWUgdG9vIGVhcmx5IHdoZW4KCQkgKiBzdGFydGluZyBhIHdyaXRlIAoJCSAqLwoJCWlmICgoc3RhdHVzICYgT01BUF9NTUNfU1RBVF9FTkRfT0ZfQ01EKSAmJgoJCSAgICAoIShzdGF0dXMgJiBPTUFQX01NQ19TVEFUX0FfRU1QVFkpKSkgewoJCQllbmRfY29tbWFuZCA9IDE7CgkJfQoJfQoKCWlmIChlbmRfY29tbWFuZCkgewoJCW1tY19vbWFwX2NtZF9kb25lKGhvc3QsIGhvc3QtPmNtZCk7Cgl9CglpZiAodHJhbnNmZXJfZXJyb3IpCgkJbW1jX29tYXBfeGZlcl9kb25lKGhvc3QsIGhvc3QtPmRhdGEpOwoJZWxzZSBpZiAoZW5kX3RyYW5zZmVyKQoJCW1tY19vbWFwX2VuZF9vZl9kYXRhKGhvc3QsIGhvc3QtPmRhdGEpOwoKCXJldHVybiBJUlFfSEFORExFRDsKfQoKc3RhdGljIGlycXJldHVybl90IG1tY19vbWFwX3N3aXRjaF9pcnEoaW50IGlycSwgdm9pZCAqZGV2X2lkKQp7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IChzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqKSBkZXZfaWQ7CgoJc2NoZWR1bGVfd29yaygmaG9zdC0+c3dpdGNoX3dvcmspOwoKCXJldHVybiBJUlFfSEFORExFRDsKfQoKc3RhdGljIHZvaWQgbW1jX29tYXBfc3dpdGNoX3RpbWVyKHVuc2lnbmVkIGxvbmcgYXJnKQp7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IChzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqKSBhcmc7CgoJc2NoZWR1bGVfd29yaygmaG9zdC0+c3dpdGNoX3dvcmspOwp9CgpzdGF0aWMgdm9pZCBtbWNfb21hcF9zd2l0Y2hfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCnsKCXN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0ID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBtbWNfb21hcF9ob3N0LCBzd2l0Y2hfd29yayk7CglzdHJ1Y3QgbW1jX2NhcmQgKmNhcmQ7CglzdGF0aWMgaW50IGNvbXBsYWluZWQgPSAwOwoJaW50IGNhcmRzID0gMCwgY292ZXJfb3BlbjsKCglpZiAoaG9zdC0+c3dpdGNoX3BpbiA9PSAtMSkKCQlyZXR1cm47Cgljb3Zlcl9vcGVuID0gbW1jX29tYXBfY292ZXJfaXNfb3Blbihob3N0KTsKCWlmIChjb3Zlcl9vcGVuICE9IGhvc3QtPnN3aXRjaF9sYXN0X3N0YXRlKSB7CgkJa29iamVjdF91ZXZlbnQoJmhvc3QtPmRldi0+a29iaiwgS09CSl9DSEFOR0UpOwoJCWhvc3QtPnN3aXRjaF9sYXN0X3N0YXRlID0gY292ZXJfb3BlbjsKCX0KCW1tY19kZXRlY3RfY2hhbmdlKGhvc3QtPm1tYywgMCk7CglsaXN0X2Zvcl9lYWNoX2VudHJ5KGNhcmQsICZob3N0LT5tbWMtPmNhcmRzLCBub2RlKSB7CgkJaWYgKG1tY19jYXJkX3ByZXNlbnQoY2FyZCkpCgkJCWNhcmRzKys7Cgl9CglpZiAobW1jX29tYXBfY292ZXJfaXNfb3Blbihob3N0KSkgewoJCWlmICghY29tcGxhaW5lZCkgewoJCQlkZXZfaW5mbyhtbWNfZGV2KGhvc3QtPm1tYyksICJjb3ZlciBpcyBvcGVuXG4iKTsKCQkJY29tcGxhaW5lZCA9IDE7CgkJfQoJCWlmIChtbWNfb21hcF9lbmFibGVfcG9sbCkKCQkJbW9kX3RpbWVyKCZob3N0LT5zd2l0Y2hfdGltZXIsIGppZmZpZXMgKwoJCQkJbXNlY3NfdG9famlmZmllcyhPTUFQX01NQ19TV0lUQ0hfUE9MTF9ERUxBWSkpOwoJfSBlbHNlIHsKCQljb21wbGFpbmVkID0gMDsKCX0KfQoKLyogUHJlcGFyZSB0byB0cmFuc2ZlciB0aGUgbmV4dCBzZWdtZW50IG9mIGEgc2NhdHRlcmxpc3QgKi8Kc3RhdGljIHZvaWQKbW1jX29tYXBfcHJlcGFyZV9kbWEoc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QsIHN0cnVjdCBtbWNfZGF0YSAqZGF0YSkKewoJaW50IGRtYV9jaCA9IGhvc3QtPmRtYV9jaDsKCXVuc2lnbmVkIGxvbmcgZGF0YV9hZGRyOwoJdTE2IGJ1ZiwgZnJhbWU7Cgl1MzIgY291bnQ7CglzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnID0gJmRhdGEtPnNnW2hvc3QtPnNnX2lkeF07CglpbnQgc3JjX3BvcnQgPSAwOwoJaW50IGRzdF9wb3J0ID0gMDsKCWludCBzeW5jX2RldiA9IDA7CgoJZGF0YV9hZGRyID0gaG9zdC0+cGh5c19iYXNlICsgT01BUF9NTUNfUkVHX0RBVEE7CglmcmFtZSA9IGRhdGEtPmJsa3N6OwoJY291bnQgPSBzZ19kbWFfbGVuKHNnKTsKCglpZiAoKGRhdGEtPmJsb2NrcyA9PSAxKSAmJiAoY291bnQgPiBkYXRhLT5ibGtzeikpCgkJY291bnQgPSBmcmFtZTsKCglob3N0LT5kbWFfbGVuID0gY291bnQ7CgoJLyogRklGTyBpcyAxNngyIGJ5dGVzIG9uIDE1eHgsIGFuZCAzMngyIGJ5dGVzIG9uIDE2eHggYW5kIDI0eHguCgkgKiBVc2UgMTYgb3IgMzIgd29yZCBmcmFtZXMgd2hlbiB0aGUgYmxvY2tzaXplIGlzIGF0IGxlYXN0IHRoYXQgbGFyZ2UuCgkgKiBCbG9ja3NpemUgaXMgdXN1YWxseSA1MTIgYnl0ZXM7IGJ1dCBub3QgZm9yIHNvbWUgU0QgcmVhZHMuCgkgKi8KCWlmIChjcHVfaXNfb21hcDE1eHgoKSAmJiBmcmFtZSA+IDMyKQoJCWZyYW1lID0gMzI7CgllbHNlIGlmIChmcmFtZSA+IDY0KQoJCWZyYW1lID0gNjQ7Cgljb3VudCAvPSBmcmFtZTsKCWZyYW1lID4+PSAxOwoKCWlmICghKGRhdGEtPmZsYWdzICYgTU1DX0RBVEFfV1JJVEUpKSB7CgkJYnVmID0gMHg4MDBmIHwgKChmcmFtZSAtIDEpIDw8IDgpOwoKCQlpZiAoY3B1X2NsYXNzX2lzX29tYXAxKCkpIHsKCQkJc3JjX3BvcnQgPSBPTUFQX0RNQV9QT1JUX1RJUEI7CgkJCWRzdF9wb3J0ID0gT01BUF9ETUFfUE9SVF9FTUlGRjsKCQl9CgkJaWYgKGNwdV9pc19vbWFwMjR4eCgpKQoJCQlzeW5jX2RldiA9IE9NQVAyNFhYX0RNQV9NTUMxX1JYOwoKCQlvbWFwX3NldF9kbWFfc3JjX3BhcmFtcyhkbWFfY2gsIHNyY19wb3J0LAoJCQkJCU9NQVBfRE1BX0FNT0RFX0NPTlNUQU5ULAoJCQkJCWRhdGFfYWRkciwgMCwgMCk7CgkJb21hcF9zZXRfZG1hX2Rlc3RfcGFyYW1zKGRtYV9jaCwgZHN0X3BvcnQsCgkJCQkJIE9NQVBfRE1BX0FNT0RFX1BPU1RfSU5DLAoJCQkJCSBzZ19kbWFfYWRkcmVzcyhzZyksIDAsIDApOwoJCW9tYXBfc2V0X2RtYV9kZXN0X2RhdGFfcGFjayhkbWFfY2gsIDEpOwoJCW9tYXBfc2V0X2RtYV9kZXN0X2J1cnN0X21vZGUoZG1hX2NoLCBPTUFQX0RNQV9EQVRBX0JVUlNUXzQpOwoJfSBlbHNlIHsKCQlidWYgPSAweDBmODAgfCAoKGZyYW1lIC0gMSkgPDwgMCk7CgoJCWlmIChjcHVfY2xhc3NfaXNfb21hcDEoKSkgewoJCQlzcmNfcG9ydCA9IE9NQVBfRE1BX1BPUlRfRU1JRkY7CgkJCWRzdF9wb3J0ID0gT01BUF9ETUFfUE9SVF9USVBCOwoJCX0KCQlpZiAoY3B1X2lzX29tYXAyNHh4KCkpCgkJCXN5bmNfZGV2ID0gT01BUDI0WFhfRE1BX01NQzFfVFg7CgoJCW9tYXBfc2V0X2RtYV9kZXN0X3BhcmFtcyhkbWFfY2gsIGRzdF9wb3J0LAoJCQkJCSBPTUFQX0RNQV9BTU9ERV9DT05TVEFOVCwKCQkJCQkgZGF0YV9hZGRyLCAwLCAwKTsKCQlvbWFwX3NldF9kbWFfc3JjX3BhcmFtcyhkbWFfY2gsIHNyY19wb3J0LAoJCQkJCU9NQVBfRE1BX0FNT0RFX1BPU1RfSU5DLAoJCQkJCXNnX2RtYV9hZGRyZXNzKHNnKSwgMCwgMCk7CgkJb21hcF9zZXRfZG1hX3NyY19kYXRhX3BhY2soZG1hX2NoLCAxKTsKCQlvbWFwX3NldF9kbWFfc3JjX2J1cnN0X21vZGUoZG1hX2NoLCBPTUFQX0RNQV9EQVRBX0JVUlNUXzQpOwoJfQoKCS8qIE1heCBsaW1pdCBmb3IgRE1BIGZyYW1lIGNvdW50IGlzIDB4ZmZmZiAqLwoJQlVHX09OKGNvdW50ID4gMHhmZmZmKTsKCglPTUFQX01NQ19XUklURShob3N0LCBCVUYsIGJ1Zik7CglvbWFwX3NldF9kbWFfdHJhbnNmZXJfcGFyYW1zKGRtYV9jaCwgT01BUF9ETUFfREFUQV9UWVBFX1MxNiwKCQkJCSAgICAgZnJhbWUsIGNvdW50LCBPTUFQX0RNQV9TWU5DX0ZSQU1FLAoJCQkJICAgICBzeW5jX2RldiwgMCk7Cn0KCi8qIEEgc2NhdHRlcmxpc3Qgc2VnbWVudCBjb21wbGV0ZWQgKi8Kc3RhdGljIHZvaWQgbW1jX29tYXBfZG1hX2NiKGludCBsY2gsIHUxNiBjaF9zdGF0dXMsIHZvaWQgKmRhdGEpCnsKCXN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0ID0gKHN0cnVjdCBtbWNfb21hcF9ob3N0ICopIGRhdGE7CglzdHJ1Y3QgbW1jX2RhdGEgKm1tY2RhdCA9IGhvc3QtPmRhdGE7CgoJaWYgKHVubGlrZWx5KGhvc3QtPmRtYV9jaCA8IDApKSB7CgkJZGV2X2VycihtbWNfZGV2KGhvc3QtPm1tYyksCgkJCSJETUEgY2FsbGJhY2sgd2hpbGUgRE1BIG5vdCBlbmFibGVkXG4iKTsKCQlyZXR1cm47Cgl9CgkvKiBGSVhNRTogV2UgcmVhbGx5IHNob3VsZCBkbyBzb21ldGhpbmcgdG8gX2hhbmRsZV8gdGhlIGVycm9ycyAqLwoJaWYgKGNoX3N0YXR1cyAmIE9NQVAxX0RNQV9UT1VUX0lSUSkgewoJCWRldl9lcnIobW1jX2Rldihob3N0LT5tbWMpLCJETUEgdGltZW91dFxuIik7CgkJcmV0dXJuOwoJfQoJaWYgKGNoX3N0YXR1cyAmIE9NQVBfRE1BX0RST1BfSVJRKSB7CgkJZGV2X2VycihtbWNfZGV2KGhvc3QtPm1tYyksICJETUEgc3luYyBlcnJvclxuIik7CgkJcmV0dXJuOwoJfQoJaWYgKCEoY2hfc3RhdHVzICYgT01BUF9ETUFfQkxPQ0tfSVJRKSkgewoJCXJldHVybjsKCX0KCW1tY2RhdC0+Ynl0ZXNfeGZlcmVkICs9IGhvc3QtPmRtYV9sZW47Cglob3N0LT5zZ19pZHgrKzsKCWlmIChob3N0LT5zZ19pZHggPCBob3N0LT5zZ19sZW4pIHsKCQltbWNfb21hcF9wcmVwYXJlX2RtYShob3N0LCBob3N0LT5kYXRhKTsKCQlvbWFwX3N0YXJ0X2RtYShob3N0LT5kbWFfY2gpOwoJfSBlbHNlCgkJbW1jX29tYXBfZG1hX2RvbmUoaG9zdCwgaG9zdC0+ZGF0YSk7Cn0KCnN0YXRpYyBpbnQgbW1jX29tYXBfZ2V0X2RtYV9jaGFubmVsKHN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0LCBzdHJ1Y3QgbW1jX2RhdGEgKmRhdGEpCnsKCWNvbnN0IGNoYXIgKmRldl9uYW1lOwoJaW50IHN5bmNfZGV2LCBkbWFfY2gsIGlzX3JlYWQsIHI7CgoJaXNfcmVhZCA9ICEoZGF0YS0+ZmxhZ3MgJiBNTUNfREFUQV9XUklURSk7CglkZWxfdGltZXJfc3luYygmaG9zdC0+ZG1hX3RpbWVyKTsKCWlmIChob3N0LT5kbWFfY2ggPj0gMCkgewoJCWlmIChpc19yZWFkID09IGhvc3QtPmRtYV9pc19yZWFkKQoJCQlyZXR1cm4gMDsKCQlvbWFwX2ZyZWVfZG1hKGhvc3QtPmRtYV9jaCk7CgkJaG9zdC0+ZG1hX2NoID0gLTE7Cgl9CgoJaWYgKGlzX3JlYWQpIHsKCQlpZiAoaG9zdC0+aWQgPT0gMSkgewoJCQlzeW5jX2RldiA9IE9NQVBfRE1BX01NQ19SWDsKCQkJZGV2X25hbWUgPSAiTU1DMSByZWFkIjsKCQl9IGVsc2UgewoJCQlzeW5jX2RldiA9IE9NQVBfRE1BX01NQzJfUlg7CgkJCWRldl9uYW1lID0gIk1NQzIgcmVhZCI7CgkJfQoJfSBlbHNlIHsKCQlpZiAoaG9zdC0+aWQgPT0gMSkgewoJCQlzeW5jX2RldiA9IE9NQVBfRE1BX01NQ19UWDsKCQkJZGV2X25hbWUgPSAiTU1DMSB3cml0ZSI7CgkJfSBlbHNlIHsKCQkJc3luY19kZXYgPSBPTUFQX0RNQV9NTUMyX1RYOwoJCQlkZXZfbmFtZSA9ICJNTUMyIHdyaXRlIjsKCQl9Cgl9CglyID0gb21hcF9yZXF1ZXN0X2RtYShzeW5jX2RldiwgZGV2X25hbWUsIG1tY19vbWFwX2RtYV9jYiwKCQkJICAgICBob3N0LCAmZG1hX2NoKTsKCWlmIChyICE9IDApIHsKCQlkZXZfZGJnKG1tY19kZXYoaG9zdC0+bW1jKSwgIm9tYXBfcmVxdWVzdF9kbWEoKSBmYWlsZWQgd2l0aCAlZFxuIiwgcik7CgkJcmV0dXJuIHI7Cgl9Cglob3N0LT5kbWFfY2ggPSBkbWFfY2g7Cglob3N0LT5kbWFfaXNfcmVhZCA9IGlzX3JlYWQ7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfY21kX3RpbWVvdXQoc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QsIHN0cnVjdCBtbWNfcmVxdWVzdCAqcmVxKQp7Cgl1MTYgcmVnOwoKCXJlZyA9IE9NQVBfTU1DX1JFQUQoaG9zdCwgU0RJTyk7CglyZWcgJj0gfigxIDw8IDUpOwoJT01BUF9NTUNfV1JJVEUoaG9zdCwgU0RJTywgcmVnKTsKCS8qIFNldCBtYXhpbXVtIHRpbWVvdXQgKi8KCU9NQVBfTU1DX1dSSVRFKGhvc3QsIENUTywgMHhmZik7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfZGF0YV90aW1lb3V0KHN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0LCBzdHJ1Y3QgbW1jX3JlcXVlc3QgKnJlcSkKewoJaW50IHRpbWVvdXQ7Cgl1MTYgcmVnOwoKCS8qIENvbnZlcnQgbnMgdG8gY2xvY2sgY3ljbGVzIGJ5IGFzc3VtaW5nIDIwTUh6IGZyZXF1ZW5jeQoJICogMSBjeWNsZSBhdCAyME1IeiA9IDUwMCBucwoJICovCgl0aW1lb3V0ID0gcmVxLT5kYXRhLT50aW1lb3V0X2Nsa3MgKyByZXEtPmRhdGEtPnRpbWVvdXRfbnMgLyA1MDA7CgoJLyogQ2hlY2sgaWYgd2UgbmVlZCB0byB1c2UgdGltZW91dCBtdWx0aXBsaWVyIHJlZ2lzdGVyICovCglyZWcgPSBPTUFQX01NQ19SRUFEKGhvc3QsIFNESU8pOwoJaWYgKHRpbWVvdXQgPiAweGZmZmYpIHsKCQlyZWcgfD0gKDEgPDwgNSk7CgkJdGltZW91dCAvPSAxMDI0OwoJfSBlbHNlCgkJcmVnICY9IH4oMSA8PCA1KTsKCU9NQVBfTU1DX1dSSVRFKGhvc3QsIFNESU8sIHJlZyk7CglPTUFQX01NQ19XUklURShob3N0LCBEVE8sIHRpbWVvdXQpOwp9CgpzdGF0aWMgdm9pZAptbWNfb21hcF9wcmVwYXJlX2RhdGEoc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QsIHN0cnVjdCBtbWNfcmVxdWVzdCAqcmVxKQp7CglzdHJ1Y3QgbW1jX2RhdGEgKmRhdGEgPSByZXEtPmRhdGE7CglpbnQgaSwgdXNlX2RtYSwgYmxvY2tfc2l6ZTsKCXVuc2lnbmVkIHNnX2xlbjsKCglob3N0LT5kYXRhID0gZGF0YTsKCWlmIChkYXRhID09IE5VTEwpIHsKCQlPTUFQX01NQ19XUklURShob3N0LCBCTEVOLCAwKTsKCQlPTUFQX01NQ19XUklURShob3N0LCBOQkxLLCAwKTsKCQlPTUFQX01NQ19XUklURShob3N0LCBCVUYsIDApOwoJCWhvc3QtPmRtYV9pbl91c2UgPSAwOwoJCXNldF9jbWRfdGltZW91dChob3N0LCByZXEpOwoJCXJldHVybjsKCX0KCglibG9ja19zaXplID0gZGF0YS0+Ymxrc3o7CgoJT01BUF9NTUNfV1JJVEUoaG9zdCwgTkJMSywgZGF0YS0+YmxvY2tzIC0gMSk7CglPTUFQX01NQ19XUklURShob3N0LCBCTEVOLCBibG9ja19zaXplIC0gMSk7CglzZXRfZGF0YV90aW1lb3V0KGhvc3QsIHJlcSk7CgoJLyogY29wZSB3aXRoIGNhbGxpbmcgbGF5ZXIgY29uZnVzaW9uOyBpdCBpc3N1ZXMgInNpbmdsZQoJICogYmxvY2siIHdyaXRlcyB1c2luZyBtdWx0aS1ibG9jayBzY2F0dGVybGlzdHMuCgkgKi8KCXNnX2xlbiA9IChkYXRhLT5ibG9ja3MgPT0gMSkgPyAxIDogZGF0YS0+c2dfbGVuOwoKCS8qIE9ubHkgZG8gRE1BIGZvciBlbnRpcmUgYmxvY2tzICovCgl1c2VfZG1hID0gaG9zdC0+dXNlX2RtYTsKCWlmICh1c2VfZG1hKSB7CgkJZm9yIChpID0gMDsgaSA8IHNnX2xlbjsgaSsrKSB7CgkJCWlmICgoZGF0YS0+c2dbaV0ubGVuZ3RoICUgYmxvY2tfc2l6ZSkgIT0gMCkgewoJCQkJdXNlX2RtYSA9IDA7CgkJCQlicmVhazsKCQkJfQoJCX0KCX0KCglob3N0LT5zZ19pZHggPSAwOwoJaWYgKHVzZV9kbWEpIHsKCQlpZiAobW1jX29tYXBfZ2V0X2RtYV9jaGFubmVsKGhvc3QsIGRhdGEpID09IDApIHsKCQkJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZG1hX2RhdGFfZGlyOwoKCQkJaWYgKGRhdGEtPmZsYWdzICYgTU1DX0RBVEFfV1JJVEUpCgkJCQlkbWFfZGF0YV9kaXIgPSBETUFfVE9fREVWSUNFOwoJCQllbHNlCgkJCQlkbWFfZGF0YV9kaXIgPSBETUFfRlJPTV9ERVZJQ0U7CgoJCQlob3N0LT5zZ19sZW4gPSBkbWFfbWFwX3NnKG1tY19kZXYoaG9zdC0+bW1jKSwgZGF0YS0+c2csCgkJCQkJCXNnX2xlbiwgZG1hX2RhdGFfZGlyKTsKCQkJaG9zdC0+dG90YWxfYnl0ZXNfbGVmdCA9IDA7CgkJCW1tY19vbWFwX3ByZXBhcmVfZG1hKGhvc3QsIHJlcS0+ZGF0YSk7CgkJCWhvc3QtPmJyc19yZWNlaXZlZCA9IDA7CgkJCWhvc3QtPmRtYV9kb25lID0gMDsKCQkJaG9zdC0+ZG1hX2luX3VzZSA9IDE7CgkJfSBlbHNlCgkJCXVzZV9kbWEgPSAwOwoJfQoKCS8qIFJldmVydCB0byBQSU8/ICovCglpZiAoIXVzZV9kbWEpIHsKCQlPTUFQX01NQ19XUklURShob3N0LCBCVUYsIDB4MWYxZik7CgkJaG9zdC0+dG90YWxfYnl0ZXNfbGVmdCA9IGRhdGEtPmJsb2NrcyAqIGJsb2NrX3NpemU7CgkJaG9zdC0+c2dfbGVuID0gc2dfbGVuOwoJCW1tY19vbWFwX3NnX3RvX2J1Zihob3N0KTsKCQlob3N0LT5kbWFfaW5fdXNlID0gMDsKCX0KfQoKc3RhdGljIHZvaWQgbW1jX29tYXBfcmVxdWVzdChzdHJ1Y3QgbW1jX2hvc3QgKm1tYywgc3RydWN0IG1tY19yZXF1ZXN0ICpyZXEpCnsKCXN0cnVjdCBtbWNfb21hcF9ob3N0ICpob3N0ID0gbW1jX3ByaXYobW1jKTsKCglXQVJOX09OKGhvc3QtPm1ycSAhPSBOVUxMKTsKCglob3N0LT5tcnEgPSByZXE7CgoJLyogb25seSB0b3VjaCBmaWZvIEFGVEVSIHRoZSBjb250cm9sbGVyIHJlYWRpZXMgaXQgKi8KCW1tY19vbWFwX3ByZXBhcmVfZGF0YShob3N0LCByZXEpOwoJbW1jX29tYXBfc3RhcnRfY29tbWFuZChob3N0LCByZXEtPmNtZCk7CglpZiAoaG9zdC0+ZG1hX2luX3VzZSkKCQlvbWFwX3N0YXJ0X2RtYShob3N0LT5kbWFfY2gpOwp9CgpzdGF0aWMgdm9pZCBpbm5vdmF0b3JfZnBnYV9zb2NrZXRfcG93ZXIoaW50IG9uKQp7CiNpZiBkZWZpbmVkKENPTkZJR19NQUNIX09NQVBfSU5OT1ZBVE9SKSAmJiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNVhYKQoJaWYgKG9uKSB7CgkJZnBnYV93cml0ZShmcGdhX3JlYWQoT01BUDE1MTBfRlBHQV9QT1dFUikgfCAoMSA8PCAzKSwKCQkgICAgIE9NQVAxNTEwX0ZQR0FfUE9XRVIpOwoJfSBlbHNlIHsKCQlmcGdhX3dyaXRlKGZwZ2FfcmVhZChPTUFQMTUxMF9GUEdBX1BPV0VSKSAmIH4oMSA8PCAzKSwKCQkgICAgIE9NQVAxNTEwX0ZQR0FfUE9XRVIpOwoJfQojZW5kaWYKfQoKLyoKICogVHVybiB0aGUgc29ja2V0IHBvd2VyIG9uL29mZi4gSW5ub3ZhdG9yIHVzZXMgRlBHQSwgbW9zdCBib2FyZHMKICogcHJvYmFibHkgdXNlIEdQSU8uCiAqLwpzdGF0aWMgdm9pZCBtbWNfb21hcF9wb3dlcihzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCwgaW50IG9uKQp7CglpZiAob24pIHsKCQlpZiAobWFjaGluZV9pc19vbWFwX2lubm92YXRvcigpKQoJCQlpbm5vdmF0b3JfZnBnYV9zb2NrZXRfcG93ZXIoMSk7CgkJZWxzZSBpZiAobWFjaGluZV9pc19vbWFwX2gyKCkpCgkJCXRwczY1MDEwX3NldF9ncGlvX291dF92YWx1ZShHUElPMywgSElHSCk7CgkJZWxzZSBpZiAobWFjaGluZV9pc19vbWFwX2gzKCkpCgkJCS8qIEdQSU8gNCBvZiBUUFM2NTAxMCBzZW5kcyBTRF9FTiBzaWduYWwgKi8KCQkJdHBzNjUwMTBfc2V0X2dwaW9fb3V0X3ZhbHVlKEdQSU80LCBISUdIKTsKCQllbHNlIGlmIChjcHVfaXNfb21hcDI0eHgoKSkgewoJCQl1MTYgcmVnID0gT01BUF9NTUNfUkVBRChob3N0LCBDT04pOwoJCQlPTUFQX01NQ19XUklURShob3N0LCBDT04sIHJlZyB8ICgxIDw8IDExKSk7CgkJfSBlbHNlCgkJCWlmIChob3N0LT5wb3dlcl9waW4gPj0gMCkKCQkJCW9tYXBfc2V0X2dwaW9fZGF0YW91dChob3N0LT5wb3dlcl9waW4sIDEpOwoJfSBlbHNlIHsKCQlpZiAobWFjaGluZV9pc19vbWFwX2lubm92YXRvcigpKQoJCQlpbm5vdmF0b3JfZnBnYV9zb2NrZXRfcG93ZXIoMCk7CgkJZWxzZSBpZiAobWFjaGluZV9pc19vbWFwX2gyKCkpCgkJCXRwczY1MDEwX3NldF9ncGlvX291dF92YWx1ZShHUElPMywgTE9XKTsKCQllbHNlIGlmIChtYWNoaW5lX2lzX29tYXBfaDMoKSkKCQkJdHBzNjUwMTBfc2V0X2dwaW9fb3V0X3ZhbHVlKEdQSU80LCBMT1cpOwoJCWVsc2UgaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJCXUxNiByZWcgPSBPTUFQX01NQ19SRUFEKGhvc3QsIENPTik7CgkJCU9NQVBfTU1DX1dSSVRFKGhvc3QsIENPTiwgcmVnICYgfigxIDw8IDExKSk7CgkJfSBlbHNlCgkJCWlmIChob3N0LT5wb3dlcl9waW4gPj0gMCkKCQkJCW9tYXBfc2V0X2dwaW9fZGF0YW91dChob3N0LT5wb3dlcl9waW4sIDApOwoJfQp9CgpzdGF0aWMgaW50IG1tY19vbWFwX2NhbGNfZGl2aXNvcihzdHJ1Y3QgbW1jX2hvc3QgKm1tYywgc3RydWN0IG1tY19pb3MgKmlvcykKewoJc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QgPSBtbWNfcHJpdihtbWMpOwoJaW50IGZ1bmNfY2xrX3JhdGUgPSBjbGtfZ2V0X3JhdGUoaG9zdC0+ZmNsayk7CglpbnQgZHNvcjsKCglpZiAoaW9zLT5jbG9jayA9PSAwKQoJCXJldHVybiAwOwoKCWRzb3IgPSBmdW5jX2Nsa19yYXRlIC8gaW9zLT5jbG9jazsKCWlmIChkc29yIDwgMSkKCQlkc29yID0gMTsKCglpZiAoZnVuY19jbGtfcmF0ZSAvIGRzb3IgPiBpb3MtPmNsb2NrKQoJCWRzb3IrKzsKCglpZiAoZHNvciA+IDI1MCkKCQlkc29yID0gMjUwOwoJZHNvcisrOwoKCWlmIChpb3MtPmJ1c193aWR0aCA9PSBNTUNfQlVTX1dJRFRIXzQpCgkJZHNvciB8PSAxIDw8IDE1OwoKCXJldHVybiBkc29yOwp9CgpzdGF0aWMgdm9pZCBtbWNfb21hcF9zZXRfaW9zKHN0cnVjdCBtbWNfaG9zdCAqbW1jLCBzdHJ1Y3QgbW1jX2lvcyAqaW9zKQp7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IG1tY19wcml2KG1tYyk7CglpbnQgZHNvcjsKCWludCBpOwoKCWRzb3IgPSBtbWNfb21hcF9jYWxjX2Rpdmlzb3IobW1jLCBpb3MpOwoJaG9zdC0+YnVzX21vZGUgPSBpb3MtPmJ1c19tb2RlOwoJaG9zdC0+aHdfYnVzX21vZGUgPSBob3N0LT5idXNfbW9kZTsKCglzd2l0Y2ggKGlvcy0+cG93ZXJfbW9kZSkgewoJY2FzZSBNTUNfUE9XRVJfT0ZGOgoJCW1tY19vbWFwX3Bvd2VyKGhvc3QsIDApOwoJCWJyZWFrOwoJY2FzZSBNTUNfUE9XRVJfVVA6CgkJLyogQ2Fubm90IHRvdWNoIGRzb3IgeWV0LCBqdXN0IHBvd2VyIHVwIE1NQyAqLwoJCW1tY19vbWFwX3Bvd2VyKGhvc3QsIDEpOwoJCXJldHVybjsKCWNhc2UgTU1DX1BPV0VSX09OOgoJCWRzb3IgfD0gMSA8PCAxMTsKCQlicmVhazsKCX0KCgljbGtfZW5hYmxlKGhvc3QtPmZjbGspOwoKCS8qIE9uIGluc2FuZWx5IGhpZ2ggYXJtX3BlciBmcmVxdWVuY2llcyBzb21ldGhpbmcgc29tZXRpbWVzCgkgKiBnb2VzIHNvbWVob3cgb3V0IG9mIHN5bmMsIGFuZCB0aGUgUE9XIGJpdCBpcyBub3QgYmVpbmcgc2V0LAoJICogd2hpY2ggcmVzdWx0cyBpbiB0aGUgd2hpbGUgbG9vcCBiZWxvdyBnZXR0aW5nIHN0dWNrLgoJICogV3JpdGluZyB0byB0aGUgQ09OIHJlZ2lzdGVyIHR3aWNlIHNlZW1zIHRvIGRvIHRoZSB0cmljay4gKi8KCWZvciAoaSA9IDA7IGkgPCAyOyBpKyspCgkJT01BUF9NTUNfV1JJVEUoaG9zdCwgQ09OLCBkc29yKTsKCWlmIChpb3MtPnBvd2VyX21vZGUgPT0gTU1DX1BPV0VSX09OKSB7CgkJLyogU2VuZCBjbG9jayBjeWNsZXMsIHBvbGwgY29tcGxldGlvbiAqLwoJCU9NQVBfTU1DX1dSSVRFKGhvc3QsIElFLCAwKTsKCQlPTUFQX01NQ19XUklURShob3N0LCBTVEFULCAweGZmZmYpOwoJCU9NQVBfTU1DX1dSSVRFKGhvc3QsIENNRCwgMSA8PCA3KTsKCQl3aGlsZSAoKE9NQVBfTU1DX1JFQUQoaG9zdCwgU1RBVCkgJiAxKSA9PSAwKTsKCQlPTUFQX01NQ19XUklURShob3N0LCBTVEFULCAxKTsKCX0KCWNsa19kaXNhYmxlKGhvc3QtPmZjbGspOwp9CgpzdGF0aWMgaW50IG1tY19vbWFwX2dldF9ybyhzdHJ1Y3QgbW1jX2hvc3QgKm1tYykKewoJc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QgPSBtbWNfcHJpdihtbWMpOwoKCXJldHVybiBob3N0LT53cF9waW4gJiYgb21hcF9nZXRfZ3Bpb19kYXRhaW4oaG9zdC0+d3BfcGluKTsKfQoKc3RhdGljIGNvbnN0IHN0cnVjdCBtbWNfaG9zdF9vcHMgbW1jX29tYXBfb3BzID0gewoJLnJlcXVlc3QJPSBtbWNfb21hcF9yZXF1ZXN0LAoJLnNldF9pb3MJPSBtbWNfb21hcF9zZXRfaW9zLAoJLmdldF9ybwkJPSBtbWNfb21hcF9nZXRfcm8sCn07CgpzdGF0aWMgaW50IF9faW5pdCBtbWNfb21hcF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQp7CglzdHJ1Y3Qgb21hcF9tbWNfY29uZiAqbWluZm8gPSBwZGV2LT5kZXYucGxhdGZvcm1fZGF0YTsKCXN0cnVjdCBtbWNfaG9zdCAqbW1jOwoJc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QgPSBOVUxMOwoJc3RydWN0IHJlc291cmNlICpyZXM7CglpbnQgcmV0ID0gMDsKCWludCBpcnE7CgoJaWYgKG1pbmZvID09IE5VTEwpIHsKCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJwbGF0Zm9ybSBkYXRhIG1pc3NpbmdcbiIpOwoJCXJldHVybiAtRU5YSU87Cgl9CgoJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKCWlycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwgMCk7CglpZiAocmVzID09IE5VTEwgfHwgaXJxIDwgMCkKCQlyZXR1cm4gLUVOWElPOwoKCXJlcyA9IHJlcXVlc3RfbWVtX3JlZ2lvbihyZXMtPnN0YXJ0LCByZXMtPmVuZCAtIHJlcy0+c3RhcnQgKyAxLAoJCQkgICAgICAgICBwZGV2LT5uYW1lKTsKCWlmIChyZXMgPT0gTlVMTCkKCQlyZXR1cm4gLUVCVVNZOwoKCW1tYyA9IG1tY19hbGxvY19ob3N0KHNpemVvZihzdHJ1Y3QgbW1jX29tYXBfaG9zdCksICZwZGV2LT5kZXYpOwoJaWYgKG1tYyA9PSBOVUxMKSB7CgkJcmV0ID0gLUVOT01FTTsKCQlnb3RvIGVycl9mcmVlX21lbV9yZWdpb247Cgl9CgoJaG9zdCA9IG1tY19wcml2KG1tYyk7Cglob3N0LT5tbWMgPSBtbWM7CgoJc3Bpbl9sb2NrX2luaXQoJmhvc3QtPmRtYV9sb2NrKTsKCWluaXRfdGltZXIoJmhvc3QtPmRtYV90aW1lcik7Cglob3N0LT5kbWFfdGltZXIuZnVuY3Rpb24gPSBtbWNfb21hcF9kbWFfdGltZXI7Cglob3N0LT5kbWFfdGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBob3N0OwoKCWhvc3QtPmlkID0gcGRldi0+aWQ7Cglob3N0LT5tZW1fcmVzID0gcmVzOwoJaG9zdC0+aXJxID0gaXJxOwoKCWlmIChjcHVfaXNfb21hcDI0eHgoKSkgewoJCWhvc3QtPmljbGsgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsICJtbWNfaWNrIik7CgkJaWYgKElTX0VSUihob3N0LT5pY2xrKSkKCQkJZ290byBlcnJfZnJlZV9tbWNfaG9zdDsKCQljbGtfZW5hYmxlKGhvc3QtPmljbGspOwoJfQoKCWlmICghY3B1X2lzX29tYXAyNHh4KCkpCgkJaG9zdC0+ZmNsayA9IGNsa19nZXQoJnBkZXYtPmRldiwgIm1tY19jayIpOwoJZWxzZQoJCWhvc3QtPmZjbGsgPSBjbGtfZ2V0KCZwZGV2LT5kZXYsICJtbWNfZmNrIik7CgoJaWYgKElTX0VSUihob3N0LT5mY2xrKSkgewoJCXJldCA9IFBUUl9FUlIoaG9zdC0+ZmNsayk7CgkJZ290byBlcnJfZnJlZV9pY2xrOwoJfQoKCS8qIFJFVklTSVQ6CgkgKiBBbHNvLCB1c2UgbWluZm8tPmNvdmVyIHRvIGRlY2lkZSBob3cgdG8gbWFuYWdlCgkgKiB0aGUgY2FyZCBkZXRlY3Qgc2Vuc2luZy4KCSAqLwoJaG9zdC0+cG93ZXJfcGluID0gbWluZm8tPnBvd2VyX3BpbjsKCWhvc3QtPnN3aXRjaF9waW4gPSBtaW5mby0+c3dpdGNoX3BpbjsKCWhvc3QtPndwX3BpbiA9IG1pbmZvLT53cF9waW47Cglob3N0LT51c2VfZG1hID0gMTsKCWhvc3QtPmRtYV9jaCA9IC0xOwoKCWhvc3QtPmlycSA9IGlycTsKCWhvc3QtPnBoeXNfYmFzZSA9IGhvc3QtPm1lbV9yZXMtPnN0YXJ0OwoJaG9zdC0+dmlydF9iYXNlID0gKHZvaWQgX19pb21lbSAqKSBJT19BRERSRVNTKGhvc3QtPnBoeXNfYmFzZSk7CgoJbW1jLT5vcHMgPSAmbW1jX29tYXBfb3BzOwoJbW1jLT5mX21pbiA9IDQwMDAwMDsKCW1tYy0+Zl9tYXggPSAyNDAwMDAwMDsKCW1tYy0+b2NyX2F2YWlsID0gTU1DX1ZERF8zMl8zMyB8IE1NQ19WRERfMzNfMzQ7CgltbWMtPmNhcHMgPSBNTUNfQ0FQX01VTFRJV1JJVEUgfCBNTUNfQ0FQX0JZVEVCTE9DSzsKCglpZiAobWluZm8tPndpcmU0KQoJCSBtbWMtPmNhcHMgfD0gTU1DX0NBUF80X0JJVF9EQVRBOwoKCS8qIFVzZSBzY2F0dGVybGlzdCBETUEgdG8gcmVkdWNlIHBlci10cmFuc2ZlciBjb3N0cy4KCSAqIE5PVEUgbWF4X3NlZ19zaXplIGFzc3VtcHRpb24gdGhhdCBzbWFsbCBibG9ja3MgYXJlbid0CgkgKiBub3JtYWxseSB1c2VkIChleGNlcHQgZS5nLiBmb3IgcmVhZGluZyBTRCByZWdpc3RlcnMpLgoJICovCgltbWMtPm1heF9waHlzX3NlZ3MgPSAzMjsKCW1tYy0+bWF4X2h3X3NlZ3MgPSAzMjsKCW1tYy0+bWF4X2Jsa19zaXplID0gMjA0ODsJLyogQkxFTiBpcyAxMSBiaXRzICgrMSkgKi8KCW1tYy0+bWF4X2Jsa19jb3VudCA9IDIwNDg7CS8qIE5CTEsgaXMgMTEgYml0cyAoKzEpICovCgltbWMtPm1heF9yZXFfc2l6ZSA9IG1tYy0+bWF4X2Jsa19zaXplICogbW1jLT5tYXhfYmxrX2NvdW50OwoJbW1jLT5tYXhfc2VnX3NpemUgPSBtbWMtPm1heF9yZXFfc2l6ZTsKCglpZiAoaG9zdC0+cG93ZXJfcGluID49IDApIHsKCQlpZiAoKHJldCA9IG9tYXBfcmVxdWVzdF9ncGlvKGhvc3QtPnBvd2VyX3BpbikpICE9IDApIHsKCQkJZGV2X2VycihtbWNfZGV2KGhvc3QtPm1tYyksCgkJCQkiVW5hYmxlIHRvIGdldCBHUElPIHBpbiBmb3IgTU1DIHBvd2VyXG4iKTsKCQkJZ290byBlcnJfZnJlZV9mY2xrOwoJCX0KCQlvbWFwX3NldF9ncGlvX2RpcmVjdGlvbihob3N0LT5wb3dlcl9waW4sIDApOwoJfQoKCXJldCA9IHJlcXVlc3RfaXJxKGhvc3QtPmlycSwgbW1jX29tYXBfaXJxLCAwLCBEUklWRVJfTkFNRSwgaG9zdCk7CglpZiAocmV0KQoJCWdvdG8gZXJyX2ZyZWVfcG93ZXJfZ3BpbzsKCglob3N0LT5kZXYgPSAmcGRldi0+ZGV2OwoJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgaG9zdCk7CgoJaWYgKGhvc3QtPnN3aXRjaF9waW4gPj0gMCkgewoJCUlOSVRfV09SSygmaG9zdC0+c3dpdGNoX3dvcmssIG1tY19vbWFwX3N3aXRjaF9oYW5kbGVyKTsKCQlpbml0X3RpbWVyKCZob3N0LT5zd2l0Y2hfdGltZXIpOwoJCWhvc3QtPnN3aXRjaF90aW1lci5mdW5jdGlvbiA9IG1tY19vbWFwX3N3aXRjaF90aW1lcjsKCQlob3N0LT5zd2l0Y2hfdGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBob3N0OwoJCWlmIChvbWFwX3JlcXVlc3RfZ3Bpbyhob3N0LT5zd2l0Y2hfcGluKSAhPSAwKSB7CgkJCWRldl93YXJuKG1tY19kZXYoaG9zdC0+bW1jKSwgIlVuYWJsZSB0byBnZXQgR1BJTyBwaW4gZm9yIE1NQyBjb3ZlciBzd2l0Y2hcbiIpOwoJCQlob3N0LT5zd2l0Y2hfcGluID0gLTE7CgkJCWdvdG8gbm9fc3dpdGNoOwoJCX0KCgkJb21hcF9zZXRfZ3Bpb19kaXJlY3Rpb24oaG9zdC0+c3dpdGNoX3BpbiwgMSk7CgkJcmV0ID0gcmVxdWVzdF9pcnEoT01BUF9HUElPX0lSUShob3N0LT5zd2l0Y2hfcGluKSwKCQkJCSAgbW1jX29tYXBfc3dpdGNoX2lycSwgSVJRRl9UUklHR0VSX1JJU0lORywgRFJJVkVSX05BTUUsIGhvc3QpOwoJCWlmIChyZXQpIHsKCQkJZGV2X3dhcm4obW1jX2Rldihob3N0LT5tbWMpLCAiVW5hYmxlIHRvIGdldCBJUlEgZm9yIE1NQyBjb3ZlciBzd2l0Y2hcbiIpOwoJCQlvbWFwX2ZyZWVfZ3Bpbyhob3N0LT5zd2l0Y2hfcGluKTsKCQkJaG9zdC0+c3dpdGNoX3BpbiA9IC0xOwoJCQlnb3RvIG5vX3N3aXRjaDsKCQl9CgkJcmV0ID0gZGV2aWNlX2NyZWF0ZV9maWxlKCZwZGV2LT5kZXYsICZkZXZfYXR0cl9jb3Zlcl9zd2l0Y2gpOwoJCWlmIChyZXQgPT0gMCkgewoJCQlyZXQgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnBkZXYtPmRldiwgJmRldl9hdHRyX2VuYWJsZV9wb2xsKTsKCQkJaWYgKHJldCAhPSAwKQoJCQkJZGV2aWNlX3JlbW92ZV9maWxlKCZwZGV2LT5kZXYsICZkZXZfYXR0cl9jb3Zlcl9zd2l0Y2gpOwoJCX0KCQlpZiAocmV0KSB7CgkJCWRldl93YXJuKG1tY19kZXYoaG9zdC0+bW1jKSwgIlVuYWJsZSB0byBjcmVhdGUgc3lzZnMgYXR0cmlidXRlc1xuIik7CgkJCWZyZWVfaXJxKE9NQVBfR1BJT19JUlEoaG9zdC0+c3dpdGNoX3BpbiksIGhvc3QpOwoJCQlvbWFwX2ZyZWVfZ3Bpbyhob3N0LT5zd2l0Y2hfcGluKTsKCQkJaG9zdC0+c3dpdGNoX3BpbiA9IC0xOwoJCQlnb3RvIG5vX3N3aXRjaDsKCQl9CgkJaWYgKG1tY19vbWFwX2VuYWJsZV9wb2xsICYmIG1tY19vbWFwX2NvdmVyX2lzX29wZW4oaG9zdCkpCgkJCXNjaGVkdWxlX3dvcmsoJmhvc3QtPnN3aXRjaF93b3JrKTsKCX0KCgltbWNfYWRkX2hvc3QobW1jKTsKCglyZXR1cm4gMDsKCm5vX3N3aXRjaDoKCS8qIEZJWE1FOiBGcmVlIG90aGVyIHJlc291cmNlcyB0b28uICovCglpZiAoaG9zdCkgewoJCWlmIChob3N0LT5pY2xrICYmICFJU19FUlIoaG9zdC0+aWNsaykpCgkJCWNsa19wdXQoaG9zdC0+aWNsayk7CgkJaWYgKGhvc3QtPmZjbGsgJiYgIUlTX0VSUihob3N0LT5mY2xrKSkKCQkJY2xrX3B1dChob3N0LT5mY2xrKTsKCQltbWNfZnJlZV9ob3N0KGhvc3QtPm1tYyk7Cgl9CmVycl9mcmVlX3Bvd2VyX2dwaW86CglpZiAoaG9zdC0+cG93ZXJfcGluID49IDApCgkJb21hcF9mcmVlX2dwaW8oaG9zdC0+cG93ZXJfcGluKTsKZXJyX2ZyZWVfZmNsazoKCWNsa19wdXQoaG9zdC0+ZmNsayk7CmVycl9mcmVlX2ljbGs6CglpZiAoaG9zdC0+aWNsayAhPSBOVUxMKSB7CgkJY2xrX2Rpc2FibGUoaG9zdC0+aWNsayk7CgkJY2xrX3B1dChob3N0LT5pY2xrKTsKCX0KZXJyX2ZyZWVfbW1jX2hvc3Q6CgltbWNfZnJlZV9ob3N0KGhvc3QtPm1tYyk7CmVycl9mcmVlX21lbV9yZWdpb246CglyZWxlYXNlX21lbV9yZWdpb24ocmVzLT5zdGFydCwgcmVzLT5lbmQgLSByZXMtPnN0YXJ0ICsgMSk7CglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgaW50IG1tY19vbWFwX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQp7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwoKCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIE5VTEwpOwoKCUJVR19PTihob3N0ID09IE5VTEwpOwoKCW1tY19yZW1vdmVfaG9zdChob3N0LT5tbWMpOwoJZnJlZV9pcnEoaG9zdC0+aXJxLCBob3N0KTsKCglpZiAoaG9zdC0+cG93ZXJfcGluID49IDApCgkJb21hcF9mcmVlX2dwaW8oaG9zdC0+cG93ZXJfcGluKTsKCWlmIChob3N0LT5zd2l0Y2hfcGluID49IDApIHsKCQlkZXZpY2VfcmVtb3ZlX2ZpbGUoJnBkZXYtPmRldiwgJmRldl9hdHRyX2VuYWJsZV9wb2xsKTsKCQlkZXZpY2VfcmVtb3ZlX2ZpbGUoJnBkZXYtPmRldiwgJmRldl9hdHRyX2NvdmVyX3N3aXRjaCk7CgkJZnJlZV9pcnEoT01BUF9HUElPX0lSUShob3N0LT5zd2l0Y2hfcGluKSwgaG9zdCk7CgkJb21hcF9mcmVlX2dwaW8oaG9zdC0+c3dpdGNoX3Bpbik7CgkJaG9zdC0+c3dpdGNoX3BpbiA9IC0xOwoJCWRlbF90aW1lcl9zeW5jKCZob3N0LT5zd2l0Y2hfdGltZXIpOwoJCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7Cgl9CglpZiAoaG9zdC0+aWNsayAmJiAhSVNfRVJSKGhvc3QtPmljbGspKQoJCWNsa19wdXQoaG9zdC0+aWNsayk7CglpZiAoaG9zdC0+ZmNsayAmJiAhSVNfRVJSKGhvc3QtPmZjbGspKQoJCWNsa19wdXQoaG9zdC0+ZmNsayk7CgoJcmVsZWFzZV9tZW1fcmVnaW9uKHBkZXYtPnJlc291cmNlWzBdLnN0YXJ0LAoJCQkgICBwZGV2LT5yZXNvdXJjZVswXS5lbmQgLSBwZGV2LT5yZXNvdXJjZVswXS5zdGFydCArIDEpOwoKCW1tY19mcmVlX2hvc3QoaG9zdC0+bW1jKTsKCglyZXR1cm4gMDsKfQoKI2lmZGVmIENPTkZJR19QTQpzdGF0aWMgaW50IG1tY19vbWFwX3N1c3BlbmQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwgcG1fbWVzc2FnZV90IG1lc2cpCnsKCWludCByZXQgPSAwOwoJc3RydWN0IG1tY19vbWFwX2hvc3QgKmhvc3QgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKCglpZiAoaG9zdCAmJiBob3N0LT5zdXNwZW5kZWQpCgkJcmV0dXJuIDA7CgoJaWYgKGhvc3QpIHsKCQlyZXQgPSBtbWNfc3VzcGVuZF9ob3N0KGhvc3QtPm1tYywgbWVzZyk7CgkJaWYgKHJldCA9PSAwKQoJCQlob3N0LT5zdXNwZW5kZWQgPSAxOwoJfQoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGludCBtbWNfb21hcF9yZXN1bWUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKewoJaW50IHJldCA9IDA7CglzdHJ1Y3QgbW1jX29tYXBfaG9zdCAqaG9zdCA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwoKCWlmIChob3N0ICYmICFob3N0LT5zdXNwZW5kZWQpCgkJcmV0dXJuIDA7CgoJaWYgKGhvc3QpIHsKCQlyZXQgPSBtbWNfcmVzdW1lX2hvc3QoaG9zdC0+bW1jKTsKCQlpZiAocmV0ID09IDApCgkJCWhvc3QtPnN1c3BlbmRlZCA9IDA7Cgl9CgoJcmV0dXJuIHJldDsKfQojZWxzZQojZGVmaW5lIG1tY19vbWFwX3N1c3BlbmQJTlVMTAojZGVmaW5lIG1tY19vbWFwX3Jlc3VtZQkJTlVMTAojZW5kaWYKCnN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIG1tY19vbWFwX2RyaXZlciA9IHsKCS5wcm9iZQkJPSBtbWNfb21hcF9wcm9iZSwKCS5yZW1vdmUJCT0gbW1jX29tYXBfcmVtb3ZlLAoJLnN1c3BlbmQJPSBtbWNfb21hcF9zdXNwZW5kLAoJLnJlc3VtZQkJPSBtbWNfb21hcF9yZXN1bWUsCgkuZHJpdmVyCQk9IHsKCQkubmFtZQk9IERSSVZFUl9OQU1FLAoJfSwKfTsKCnN0YXRpYyBpbnQgX19pbml0IG1tY19vbWFwX2luaXQodm9pZCkKewoJcmV0dXJuIHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmbW1jX29tYXBfZHJpdmVyKTsKfQoKc3RhdGljIHZvaWQgX19leGl0IG1tY19vbWFwX2V4aXQodm9pZCkKewoJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJm1tY19vbWFwX2RyaXZlcik7Cn0KCm1vZHVsZV9pbml0KG1tY19vbWFwX2luaXQpOwptb2R1bGVfZXhpdChtbWNfb21hcF9leGl0KTsKCk1PRFVMRV9ERVNDUklQVElPTigiT01BUCBNdWx0aW1lZGlhIENhcmQgZHJpdmVyIik7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKTU9EVUxFX0FMSUFTKERSSVZFUl9OQU1FKTsKTU9EVUxFX0FVVEhPUigiSnVoYSBZcmr2bOQiKTsK