LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiBGaWxlbmFtZTogICAgICBpcmxhbl9ldGguYwogKiBWZXJzaW9uOgogKiBEZXNjcmlwdGlvbjoKICogU3RhdHVzOiAgICAgICAgRXhwZXJpbWVudGFsLgogKiBBdXRob3I6ICAgICAgICBEYWcgQnJhdHRsaSA8ZGFnYkBjcy51aXQubm8+CiAqIENyZWF0ZWQgYXQ6ICAgIFRodSBPY3QgMTUgMDg6Mzc6NTggMTk5OAogKiBNb2RpZmllZCBhdDogICBUdWUgTWFyIDIxIDA5OjA2OjQxIDIwMDAKICogTW9kaWZpZWQgYnk6ICAgRGFnIEJyYXR0bGkgPGRhZ2JAY3MudWl0Lm5vPgogKiBTb3VyY2VzOiAgICAgICBza2VsZXRvbi5jIGJ5IERvbmFsZCBCZWNrZXIgPGJlY2tlckBDRVNESVMuZ3NmYy5uYXNhLmdvdj4KICogICAgICAgICAgICAgICAgc2xpcC5jIGJ5IExhdXJlbmNlIEN1bGhhbmUsICAgPGxvekBob2xtZXMuZGVtb24uY28udWs+CiAqICAgICAgICAgICAgICAgICAgICAgICAgICBGcmVkIE4uIHZhbiBLZW1wZW4sIDx3YWx0amVAdXdhbHQubmwubXVnbmV0Lm9yZz4KICoKICogICAgIENvcHlyaWdodCAoYykgMTk5OC0yMDAwIERhZyBCcmF0dGxpLCBBbGwgUmlnaHRzIFJlc2VydmVkLgogKgogKiAgICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogKiAgICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMKICogICAgIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mCiAqICAgICB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICogICAgIE5laXRoZXIgRGFnIEJyYXR0bGkgbm9yIFVuaXZlcnNpdHkgb2YgVHJvbXP4IGFkbWl0IGxpYWJpbGl0eSBub3IKICogICAgIHByb3ZpZGUgd2FycmFudHkgZm9yIGFueSBvZiB0aGlzIHNvZnR3YXJlLiBUaGlzIG1hdGVyaWFsIGlzCiAqICAgICBwcm92aWRlZCAiQVMtSVMiIGFuZCBhdCBubyBjaGFyZ2UuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCiNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KI2luY2x1ZGUgPGxpbnV4L2V0aGVyZGV2aWNlLmg+CiNpbmNsdWRlIDxsaW51eC9pbmV0ZGV2aWNlLmg+CiNpbmNsdWRlIDxsaW51eC9pZl9hcnAuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bmV0L2FycC5oPgoKI2luY2x1ZGUgPG5ldC9pcmRhL2lyZGEuaD4KI2luY2x1ZGUgPG5ldC9pcmRhL2lybW9kLmg+CiNpbmNsdWRlIDxuZXQvaXJkYS9pcmxhbl9jb21tb24uaD4KI2luY2x1ZGUgPG5ldC9pcmRhL2lybGFuX2NsaWVudC5oPgojaW5jbHVkZSA8bmV0L2lyZGEvaXJsYW5fZXZlbnQuaD4KI2luY2x1ZGUgPG5ldC9pcmRhL2lybGFuX2V0aC5oPgoKc3RhdGljIGludCAgaXJsYW5fZXRoX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyBpbnQgIGlybGFuX2V0aF9jbG9zZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKc3RhdGljIGludCAgaXJsYW5fZXRoX3htaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CnN0YXRpYyB2b2lkIGlybGFuX2V0aF9zZXRfbXVsdGljYXN0X2xpc3QoIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwpzdGF0aWMgc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKmlybGFuX2V0aF9nZXRfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CgovKgogKiBGdW5jdGlvbiBpcmxhbl9ldGhfc2V0dXAgKGRldikKICoKICogICAgVGhlIG5ldHdvcmsgZGV2aWNlIGluaXRpYWxpemF0aW9uIGZ1bmN0aW9uLgogKgogKi8Kc3RhdGljIHZvaWQgaXJsYW5fZXRoX3NldHVwKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCWRldi0+b3BlbiAgICAgICAgICAgICAgID0gaXJsYW5fZXRoX29wZW47CglkZXYtPnN0b3AgICAgICAgICAgICAgICA9IGlybGFuX2V0aF9jbG9zZTsKCWRldi0+aGFyZF9zdGFydF94bWl0ICAgID0gaXJsYW5fZXRoX3htaXQ7CglkZXYtPmdldF9zdGF0cwkgICAgICAgID0gaXJsYW5fZXRoX2dldF9zdGF0czsKCWRldi0+c2V0X211bHRpY2FzdF9saXN0ID0gaXJsYW5fZXRoX3NldF9tdWx0aWNhc3RfbGlzdDsKCWRldi0+ZGVzdHJ1Y3RvcgkJPSBmcmVlX25ldGRldjsKCglTRVRfTU9EVUxFX09XTkVSKGRldik7CgoJZXRoZXJfc2V0dXAoZGV2KTsKCgkvKgoJICogTGV0cyBkbyBhbGwgcXVldWVpbmcgaW4gSXJUVFAgaW5zdGVhZCBvZiB0aGlzIGRldmljZSBkcml2ZXIuCgkgKiBRdWV1ZWluZyBoZXJlIGFzIHdlbGwgY2FuIGludHJvZHVjZSBzb21lIHN0cmFuZ2UgbGF0ZW5jeQoJICogcHJvYmxlbXMsIHdoaWNoIHdlIHdpbGwgYXZvaWQgYnkgc2V0dGluZyB0aGUgcXVldWUgc2l6ZSB0byAwLgoJICovCgkvKgoJICogVGhlIGJ1Z3MgaW4gSXJUVFAgYW5kIElyTEFOIHRoYXQgY3JlYXRlZCB0aGlzIGxhdGVuY3kgaXNzdWUKCSAqIGhhdmUgbm93IGJlZW4gZml4ZWQsIGFuZCB3ZSBjYW4gcHJvcGFnYXRlIGZsb3cgY29udHJvbCBwcm9wZXJseQoJICogdG8gdGhlIG5ldHdvcmsgbGF5ZXIuIEhvd2V2ZXIsIHRoaXMgcmVxdWlyZXMgYSBtaW5pbWFsIHF1ZXVlIG9mCgkgKiBwYWNrZXRzIGZvciB0aGUgZGV2aWNlLgoJICogV2l0aG91dCBmbG93IGNvbnRyb2wsIHRoZSBUeCBRdWV1ZSBpcyAxNCAodHRwKSArIDAgKGRldikgPSAxNAoJICogV2l0aCBmbG93IGNvbnRyb2wsIHRoZSBUeCBRdWV1ZSBpcyA3ICh0dHApICsgNCAoZGV2KSA9IDExCgkgKiBTZWUgaXJsYW5fZXRoX2Zsb3dfaW5kaWNhdGlvbigpLi4uCgkgKiBOb3RlIDogdGhpcyBudW1iZXIgd2FzIHJhbmRvbWx5IHNlbGVjdGVkIGFuZCB3b3VsZCBuZWVkIHRvCgkgKiBiZSBhZGp1c3RlZC4KCSAqIEplYW4gSUkgKi8KCWRldi0+dHhfcXVldWVfbGVuID0gNDsKfQoKLyoKICogRnVuY3Rpb24gYWxsb2NfaXJsYW5kZXYKICoKICogICAgQWxsb2NhdGUgbmV0d29yayBkZXZpY2UgYW5kIGNvbnRyb2wgYmxvY2sKICoKICovCnN0cnVjdCBuZXRfZGV2aWNlICphbGxvY19pcmxhbmRldihjb25zdCBjaGFyICpuYW1lKQp7CglyZXR1cm4gYWxsb2NfbmV0ZGV2KHNpemVvZihzdHJ1Y3QgaXJsYW5fY2IpLCBuYW1lLAoJCQkgICAgaXJsYW5fZXRoX3NldHVwKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYW5fZXRoX29wZW4gKGRldikKICoKICogICAgTmV0d29yayBkZXZpY2UgaGFzIGJlZW4gb3BlbmVkIGJ5IHVzZXIKICoKICovCnN0YXRpYyBpbnQgaXJsYW5fZXRoX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IGlybGFuX2NiICpzZWxmID0gbmV0ZGV2X3ByaXYoZGV2KTsKCglJUkRBX0RFQlVHKDIsICIlcygpXG4iLCBfX0ZVTkNUSU9OX18gKTsKCgkvKiBSZWFkeSB0byBwbGF5ISAqLwoJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOyAvKiBXYWl0IHVudGlsIGRhdGEgbGluayBpcyByZWFkeSAqLwoKCS8qIFdlIGFyZSBub3cgb3Blbiwgc28gdGltZSB0byBkbyBzb21lIHdvcmsgKi8KCXNlbGYtPmRpc2Nvbm5lY3RfcmVhc29uID0gMDsKCWlybGFuX2NsaWVudF93YWtldXAoc2VsZiwgc2VsZi0+c2FkZHIsIHNlbGYtPmRhZGRyKTsKCgkvKiBNYWtlIHN1cmUgd2UgaGF2ZSBhIGhhcmR3YXJlIGFkZHJlc3MgYmVmb3JlIHdlIHJldHVybiwKCSAgIHNvIERIQ1AgY2xpZW50cyBnZXRzIGhhcHB5ICovCglyZXR1cm4gd2FpdF9ldmVudF9pbnRlcnJ1cHRpYmxlKHNlbGYtPm9wZW5fd2FpdCwKCQkJCQkhc2VsZi0+dHNhcF9kYXRhLT5jb25uZWN0ZWQpOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhbl9ldGhfY2xvc2UgKGRldikKICoKICogICAgU3RvcCB0aGUgZXRoZXIgbmV0d29yayBkZXZpY2UsIGhpcyBmdW5jdGlvbiB3aWxsIHVzdWFsbHkgYmUgY2FsbGVkIGJ5CiAqICAgIGlmY29uZmlnIGRvd24uIFdlIHNob3VsZCBub3cgZGlzY29ubmVjdCB0aGUgbGluaywgV2Ugc3RhcnQgdGhlCiAqICAgIGNsb3NlIHRpbWVyLCBzbyB0aGF0IHRoZSBpbnN0YW5jZSB3aWxsIGJlIHJlbW92ZWQgaWYgd2UgYXJlIHVuYWJsZQogKiAgICB0byBkaXNjb3ZlciB0aGUgcmVtb3RlIGRldmljZSBhZnRlciB0aGUgZGlzY29ubmVjdC4KICovCnN0YXRpYyBpbnQgaXJsYW5fZXRoX2Nsb3NlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBpcmxhbl9jYiAqc2VsZiA9IG5ldGRldl9wcml2KGRldik7CgoJSVJEQV9ERUJVRygyLCAiJXMoKVxuIiwgX19GVU5DVElPTl9fICk7CgoJLyogU3RvcCBkZXZpY2UgKi8KCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKCglpcmxhbl9jbG9zZV9kYXRhX2NoYW5uZWwoc2VsZik7Cglpcmxhbl9jbG9zZV90c2FwcyhzZWxmKTsKCglpcmxhbl9kb19jbGllbnRfZXZlbnQoc2VsZiwgSVJMQU5fTE1QX0RJU0NPTk5FQ1QsIE5VTEwpOwoJaXJsYW5fZG9fcHJvdmlkZXJfZXZlbnQoc2VsZiwgSVJMQU5fTE1QX0RJU0NPTk5FQ1QsIE5VTEwpOwoKCS8qIFJlbW92ZSBmcmFtZXMgcXVldWVkIG9uIHRoZSBjb250cm9sIGNoYW5uZWwgKi8KCXNrYl9xdWV1ZV9wdXJnZSgmc2VsZi0+Y2xpZW50LnR4cSk7CgoJc2VsZi0+Y2xpZW50LnR4X2J1c3kgPSAwOwoKCXJldHVybiAwOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhbl9ldGhfdHggKHNrYikKICoKICogICAgVHJhbnNtaXRzIGV0aGVybmV0IGZyYW1lcyBvdmVyIElyREEgbGluay4KICoKICovCnN0YXRpYyBpbnQgaXJsYW5fZXRoX3htaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKmRldikKewoJc3RydWN0IGlybGFuX2NiICpzZWxmID0gbmV0ZGV2X3ByaXYoZGV2KTsKCWludCByZXQ7CgoJLyogc2tiIGhlYWRyb29tIGxhcmdlIGVub3VnaCB0byBjb250YWluIGFsbCBJckRBLWhlYWRlcnM/ICovCglpZiAoKHNrYl9oZWFkcm9vbShza2IpIDwgc2VsZi0+bWF4X2hlYWRlcl9zaXplKSB8fCAoc2tiX3NoYXJlZChza2IpKSkgewoJCXN0cnVjdCBza19idWZmICpuZXdfc2tiID0KCQkJc2tiX3JlYWxsb2NfaGVhZHJvb20oc2tiLCBzZWxmLT5tYXhfaGVhZGVyX3NpemUpOwoKCQkvKiAgV2UgaGF2ZSB0byBmcmVlIHRoZSBvcmlnaW5hbCBza2IgYW55d2F5ICovCgkJZGV2X2tmcmVlX3NrYihza2IpOwoKCQkvKiBEaWQgdGhlIHJlYWxsb2Mgc3VjY2VlZD8gKi8KCQlpZiAobmV3X3NrYiA9PSBOVUxMKQoJCQlyZXR1cm4gMDsKCgkJLyogVXNlIHRoZSBuZXcgc2tiIGluc3RlYWQgKi8KCQlza2IgPSBuZXdfc2tiOwoJfQoKCWRldi0+dHJhbnNfc3RhcnQgPSBqaWZmaWVzOwoKCS8qIE5vdyBxdWV1ZSB0aGUgcGFja2V0IGluIHRoZSB0cmFuc3BvcnQgbGF5ZXIgKi8KCWlmIChzZWxmLT51c2VfdWRhdGEpCgkJcmV0ID0gaXJ0dHBfdWRhdGFfcmVxdWVzdChzZWxmLT50c2FwX2RhdGEsIHNrYik7CgllbHNlCgkJcmV0ID0gaXJ0dHBfZGF0YV9yZXF1ZXN0KHNlbGYtPnRzYXBfZGF0YSwgc2tiKTsKCglpZiAocmV0IDwgMCkgewoJCS8qCgkJICogSXJUVFBzIHR4IHF1ZXVlIGlzIGZ1bGwsIHNvIHdlIGp1c3QgaGF2ZSB0bwoJCSAqIGRyb3AgdGhlIGZyYW1lISBZb3UgbWlnaHQgdGhpbmsgdGhhdCB3ZSBzaG91bGQKCQkgKiBqdXN0IHJldHVybiAtMSBhbmQgZG9uJ3QgZGVhbGxvY2F0ZSB0aGUgZnJhbWUsCgkJICogYnV0IHRoYXQgaXMgZGFuZ2Vyb3VzIHNpbmNlIGl0J3MgcG9zc2libGUgdGhhdAoJCSAqIHdlIGhhdmUgcmVwbGFjZWQgdGhlIG9yaWdpbmFsIHNrYiB3aXRoIGEgbmV3CgkJICogb25lIHdpdGggbGFyZ2VyIGhlYWRyb29tLCBhbmQgdGhhdCB3b3VsZCByZWFsbHkKCQkgKiBjb25mdXNlIGRvX2Rldl9xdWV1ZV94bWl0KCkgaW4gZGV2LmMhIEkgaGF2ZQoJCSAqIHRyaWVkIDotKSBEQgoJCSAqLwoJCS8qIGlydHRwX2RhdGFfcmVxdWVzdCBhbHJlYWR5IGZyZWUgdGhlIHBhY2tldCAqLwoJCXNlbGYtPnN0YXRzLnR4X2Ryb3BwZWQrKzsKCX0gZWxzZSB7CgkJc2VsZi0+c3RhdHMudHhfcGFja2V0cysrOwoJCXNlbGYtPnN0YXRzLnR4X2J5dGVzICs9IHNrYi0+bGVuOwoJfQoKCXJldHVybiAwOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhbl9ldGhfcmVjZWl2ZSAoaGFuZGxlLCBza2IpCiAqCiAqICAgIFRoaXMgZnVuY3Rpb24gZ2V0cyB0aGUgZGF0YSB0aGF0IGlzIHJlY2VpdmVkIG9uIHRoZSBkYXRhIGNoYW5uZWwKICoKICovCmludCBpcmxhbl9ldGhfcmVjZWl2ZSh2b2lkICppbnN0YW5jZSwgdm9pZCAqc2FwLCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQp7CglzdHJ1Y3QgaXJsYW5fY2IgKnNlbGYgPSBpbnN0YW5jZTsKCglpZiAoc2tiID09IE5VTEwpIHsKCQkrK3NlbGYtPnN0YXRzLnJ4X2Ryb3BwZWQ7CgkJcmV0dXJuIDA7Cgl9CglpZiAoc2tiLT5sZW4gPCBFVEhfSExFTikgewoJCUlSREFfREVCVUcoMCwgIiVzKCkgOiBJckxBTiBmcmFtZSB0b28gc2hvcnQgKCVkKVxuIiwKCQkJICAgX19GVU5DVElPTl9fLCBza2ItPmxlbik7CgkJKytzZWxmLT5zdGF0cy5yeF9kcm9wcGVkOwoJCWRldl9rZnJlZV9za2Ioc2tiKTsKCQlyZXR1cm4gMDsKCX0KCgkvKgoJICogQWRvcHQgdGhpcyBmcmFtZSEgSW1wb3J0YW50IHRvIHNldCBhbGwgdGhlc2UgZmllbGRzIHNpbmNlIHRoZXkKCSAqIG1pZ2h0IGhhdmUgYmVlbiBwcmV2aW91c2x5IHNldCBieSB0aGUgbG93IGxldmVsIElyREEgbmV0d29yawoJICogZGV2aWNlIGRyaXZlcgoJICovCglza2ItPnByb3RvY29sID0gZXRoX3R5cGVfdHJhbnMoc2tiLCBzZWxmLT5kZXYpOyAvKiBSZW1vdmUgZXRoIGhlYWRlciAqLwoKCXNlbGYtPnN0YXRzLnJ4X3BhY2tldHMrKzsKCXNlbGYtPnN0YXRzLnJ4X2J5dGVzICs9IHNrYi0+bGVuOwoKCW5ldGlmX3J4KHNrYik7ICAgLyogRWF0IGl0ISAqLwoKCXJldHVybiAwOwp9CgovKgogKiBGdW5jdGlvbiBpcmxhbl9ldGhfZmxvdyAoc3RhdHVzKQogKgogKiAgICBEbyBmbG93IGNvbnRyb2wgYmV0d2VlbiBJUC9FdGhlcm5ldCBhbmQgSXJMQU4vSXJUVFAuIFRoaXMgaXMgZG9uZSBieQogKiAgICBjb250cm9sbGluZyB0aGUgcXVldWUgc3RvcC9zdGFydC4KICoKICogVGhlIElyREEgbGluayBsYXllciBoYXMgdGhlIGFkdmFudGFnZSB0byBoYXZlIGZsb3cgY29udHJvbCwgYW5kCiAqIElyVFRQIG5vdyBwcm9wZXJseSBoYW5kbGVzIHRoYXQuIEZsb3cgY29udHJvbGxpbmcgdGhlIGhpZ2hlciBsYXllcnMKICogcHJldmVudCB1cyB0byBkcm9wIFR4IHBhY2tldHMgaW4gaGVyZSAodXAgdG8gMTUlIGZvciBhIFRDUCBzb2NrZXQsCiAqIG1vcmUgZm9yIFVEUCBzb2NrZXQpLgogKiBBbHNvLCB0aGlzIGFsbG93IHVzIHRvIHJlZHVjZSB0aGUgb3ZlcmFsbCB0cmFuc21pdCBxdWV1ZSwgd2hpY2ggbWVhbnMKICogbGVzcyBsYXRlbmN5IGluIGNhc2Ugb2YgbWl4ZWQgdHJhZmZpYy4KICogSmVhbiBJSQogKi8Kdm9pZCBpcmxhbl9ldGhfZmxvd19pbmRpY2F0aW9uKHZvaWQgKmluc3RhbmNlLCB2b2lkICpzYXAsIExPQ0FMX0ZMT1cgZmxvdykKewoJc3RydWN0IGlybGFuX2NiICpzZWxmOwoJc3RydWN0IG5ldF9kZXZpY2UgKmRldjsKCglzZWxmID0gKHN0cnVjdCBpcmxhbl9jYiAqKSBpbnN0YW5jZTsKCglJUkRBX0FTU0VSVChzZWxmICE9IE5VTEwsIHJldHVybjspOwoJSVJEQV9BU1NFUlQoc2VsZi0+bWFnaWMgPT0gSVJMQU5fTUFHSUMsIHJldHVybjspOwoKCWRldiA9IHNlbGYtPmRldjsKCglJUkRBX0FTU0VSVChkZXYgIT0gTlVMTCwgcmV0dXJuOyk7CgoJSVJEQV9ERUJVRygwLCAiJXMoKSA6IGZsb3cgJXMgOyBydW5uaW5nICVkXG4iLCBfX0ZVTkNUSU9OX18sCgkJICAgZmxvdyA9PSBGTE9XX1NUT1AgPyAiRkxPV19TVE9QIiA6ICJGTE9XX1NUQVJUIiwKCQkgICBuZXRpZl9ydW5uaW5nKGRldikpOwoKCXN3aXRjaCAoZmxvdykgewoJY2FzZSBGTE9XX1NUT1A6CgkJLyogSXJUVFAgaXMgZnVsbCwgc3RvcCBoaWdoZXIgbGF5ZXJzICovCgkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOwoJCWJyZWFrOwoJY2FzZSBGTE9XX1NUQVJUOgoJZGVmYXVsdDoKCQkvKiBUZWxsIHVwcGVyIGxheWVycyB0aGF0IGl0cyB0aW1lIHRvIHRyYW5zbWl0IGZyYW1lcyBhZ2FpbiAqLwoJCS8qIFNjaGVkdWxlIG5ldHdvcmsgbGF5ZXIgKi8KCQluZXRpZl93YWtlX3F1ZXVlKGRldik7CgkJYnJlYWs7Cgl9Cn0KCi8qCiAqIEZ1bmN0aW9uIGlybGFuX2V0Y19zZW5kX2dyYXR1aXRvdXNfYXJwIChkZXYpCiAqCiAqICAgIFNlbmQgZ3JhdHVpdG91cyBBUlAgdG8gYW5ub3VuY2UgdGhhdCB3ZSBoYXZlIGNoYW5nZWQKICogICAgaGFyZHdhcmUgYWRkcmVzcywgc28gdGhhdCBhbGwgcGVlcnMgdXBkYXRlcyB0aGVpciBBUlAgdGFibGVzCiAqLwp2b2lkIGlybGFuX2V0aF9zZW5kX2dyYXR1aXRvdXNfYXJwKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBpbl9kZXZpY2UgKmluX2RldjsKCgkvKgoJICogV2hlbiB3ZSBnZXQgYSBuZXcgTUFDIGFkZHJlc3MgZG8gYSBncmF0dWl0b3VzIEFSUC4gVGhpcwoJICogaXMgdXNlZnVsIGlmIHdlIGhhdmUgY2hhbmdlZCBhY2Nlc3MgcG9pbnRzIG9uIHRoZSBzYW1lCgkgKiBzdWJuZXQuCgkgKi8KI2lmZGVmIENPTkZJR19JTkVUCglJUkRBX0RFQlVHKDQsICJJckxBTjogU2VuZGluZyBncmF0dWl0b3VzIEFSUFxuIik7CglyY3VfcmVhZF9sb2NrKCk7Cglpbl9kZXYgPSBfX2luX2Rldl9nZXRfcmN1KGRldik7CglpZiAoaW5fZGV2ID09IE5VTEwpCgkJZ290byBvdXQ7CglpZiAoaW5fZGV2LT5pZmFfbGlzdCkKCglhcnBfc2VuZChBUlBPUF9SRVFVRVNULCBFVEhfUF9BUlAsCgkJIGluX2Rldi0+aWZhX2xpc3QtPmlmYV9hZGRyZXNzLAoJCSBkZXYsCgkJIGluX2Rldi0+aWZhX2xpc3QtPmlmYV9hZGRyZXNzLAoJCSBOVUxMLCBkZXYtPmRldl9hZGRyLCBOVUxMKTsKb3V0OgoJcmN1X3JlYWRfdW5sb2NrKCk7CiNlbmRpZiAvKiBDT05GSUdfSU5FVCAqLwp9CgovKgogKiBGdW5jdGlvbiBzZXRfbXVsdGljYXN0X2xpc3QgKGRldikKICoKICogICAgQ29uZmlndXJlIHRoZSBmaWx0ZXJpbmcgb2YgdGhlIGRldmljZQogKgogKi8KI2RlZmluZSBIV19NQVhfQUREUlMgNCAvKiBNdXN0IHF1ZXJ5IHRvIGdldCBpdCEgKi8Kc3RhdGljIHZvaWQgaXJsYW5fZXRoX3NldF9tdWx0aWNhc3RfbGlzdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQp7CglzdHJ1Y3QgaXJsYW5fY2IgKnNlbGYgPSBuZXRkZXZfcHJpdihkZXYpOwoKCUlSREFfREVCVUcoMiwgIiVzKClcbiIsIF9fRlVOQ1RJT05fXyApOwoKCS8qIENoZWNrIGlmIGRhdGEgY2hhbm5lbCBoYXMgYmVlbiBjb25uZWN0ZWQgeWV0ICovCglpZiAoc2VsZi0+Y2xpZW50LnN0YXRlICE9IElSTEFOX0RBVEEpIHsKCQlJUkRBX0RFQlVHKDEsICIlcygpLCBkZWxheWluZyFcbiIsIF9fRlVOQ1RJT05fXyApOwoJCXJldHVybjsKCX0KCglpZiAoZGV2LT5mbGFncyAmIElGRl9QUk9NSVNDKSB7CgkJLyogRW5hYmxlIHByb21pc2N1b3VzIG1vZGUgKi8KCQlJUkRBX1dBUk5JTkcoIlByb21pc2NvdXMgbW9kZSBub3QgaW1wbGVtZW50ZWQgYnkgSXJMQU4hXG4iKTsKCX0KCWVsc2UgaWYgKChkZXYtPmZsYWdzICYgSUZGX0FMTE1VTFRJKSB8fCBkZXYtPm1jX2NvdW50ID4gSFdfTUFYX0FERFJTKSB7CgkJLyogRGlzYWJsZSBwcm9taXNjdW91cyBtb2RlLCB1c2Ugbm9ybWFsIG1vZGUuICovCgkJSVJEQV9ERUJVRyg0LCAiJXMoKSwgU2V0dGluZyBtdWx0aWNhc3QgZmlsdGVyXG4iLCBfX0ZVTkNUSU9OX18gKTsKCQkvKiBoYXJkd2FyZV9zZXRfZmlsdGVyKE5VTEwpOyAqLwoKCQlpcmxhbl9zZXRfbXVsdGljYXN0X2ZpbHRlcihzZWxmLCBUUlVFKTsKCX0KCWVsc2UgaWYgKGRldi0+bWNfY291bnQpIHsKCQlJUkRBX0RFQlVHKDQsICIlcygpLCBTZXR0aW5nIG11bHRpY2FzdCBmaWx0ZXJcbiIsIF9fRlVOQ1RJT05fXyApOwoJCS8qIFdhbGsgdGhlIGFkZHJlc3MgbGlzdCwgYW5kIGxvYWQgdGhlIGZpbHRlciAqLwoJCS8qIGhhcmR3YXJlX3NldF9maWx0ZXIoZGV2LT5tY19saXN0KTsgKi8KCgkJaXJsYW5fc2V0X211bHRpY2FzdF9maWx0ZXIoc2VsZiwgVFJVRSk7Cgl9CgllbHNlIHsKCQlJUkRBX0RFQlVHKDQsICIlcygpLCBDbGVhcmluZyBtdWx0aWNhc3QgZmlsdGVyXG4iLCBfX0ZVTkNUSU9OX18gKTsKCQlpcmxhbl9zZXRfbXVsdGljYXN0X2ZpbHRlcihzZWxmLCBGQUxTRSk7Cgl9CgoJaWYgKGRldi0+ZmxhZ3MgJiBJRkZfQlJPQURDQVNUKQoJCWlybGFuX3NldF9icm9hZGNhc3RfZmlsdGVyKHNlbGYsIFRSVUUpOwoJZWxzZQoJCWlybGFuX3NldF9icm9hZGNhc3RfZmlsdGVyKHNlbGYsIEZBTFNFKTsKfQoKLyoKICogRnVuY3Rpb24gaXJsYW5fZ2V0X3N0YXRzIChkZXYpCiAqCiAqICAgIEdldCB0aGUgY3VycmVudCBzdGF0aXN0aWNzIGZvciB0aGlzIGRldmljZQogKgogKi8Kc3RhdGljIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICppcmxhbl9ldGhfZ2V0X3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCnsKCXN0cnVjdCBpcmxhbl9jYiAqc2VsZiA9IG5ldGRldl9wcml2KGRldik7CgoJcmV0dXJuICZzZWxmLT5zdGF0czsKfQo=