From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH RESEND v2 1/2] drm/xen-front: Add support for Xen PV display frontend Date: Tue, 13 Mar 2018 18:21:05 +0200 Message-ID: <1520958066-22875-2-git-send-email-andr2000@gmail.com> References: <1520958066-22875-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x22f.google.com (mail-lf0-x22f.google.com [IPv6:2a00:1450:4010:c07::22f]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8005F6E579 for ; Tue, 13 Mar 2018 16:21:24 +0000 (UTC) Received: by mail-lf0-x22f.google.com with SMTP id v9-v6so239452lfa.11 for ; Tue, 13 Mar 2018 09:21:24 -0700 (PDT) In-Reply-To: <1520958066-22875-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKQWRkIHN1cHBvcnQgZm9yIFhlbiBwYXJhLXZpcnR1YWxpemVkIGZyb250ZW5kIGRp c3BsYXkgZHJpdmVyLgpBY2NvbXBhbnlpbmcgYmFja2VuZCBbMV0gaXMgaW1wbGVtZW50ZWQgYXMg YSB1c2VyLXNwYWNlIGFwcGxpY2F0aW9uCmFuZCBpdHMgaGVscGVyIGxpYnJhcnkgWzJdLCBjYXBh YmxlIG9mIHJ1bm5pbmcgYXMgYSBXZXN0b24gY2xpZW50Cm9yIERSTSBtYXN0ZXIuCkNvbmZpZ3Vy YXRpb24gb2YgYm90aCBiYWNrZW5kIGFuZCBmcm9udGVuZCBpcyBkb25lIHZpYQpYZW4gZ3Vlc3Qg ZG9tYWluIGNvbmZpZ3VyYXRpb24gb3B0aW9ucyBbM10uCgpEcml2ZXIgbGltaXRhdGlvbnM6CiAx LiBPbmx5IHByaW1hcnkgcGxhbmUgd2l0aG91dCBhZGRpdGlvbmFsIHByb3BlcnRpZXMgaXMgc3Vw cG9ydGVkLgogMi4gT25seSBvbmUgdmlkZW8gbW9kZSBzdXBwb3J0ZWQgd2hpY2ggcmVzb2x1dGlv biBpcyBjb25maWd1cmVkIHZpYSBYZW5TdG9yZS4KIDMuIEFsbCBDUlRDcyBvcGVyYXRlIGF0IGZp eGVkIGZyZXF1ZW5jeSBvZiA2MEh6LgoKMS4gSW1wbGVtZW50IFhlbiBidXMgc3RhdGUgbWFjaGlu ZSBmb3IgdGhlIGZyb250ZW5kIGRyaXZlciBhY2NvcmRpbmcgdG8KdGhlIHN0YXRlIGRpYWdyYW0g YW5kIHJlY292ZXJ5IGZsb3cgZnJvbSBkaXNwbGF5IHBhcmEtdmlydHVhbGl6ZWQKcHJvdG9jb2w6 IHhlbi9pbnRlcmZhY2UvaW8vZGlzcGxpZi5oLgoKMi4gUmVhZCBjb25maWd1cmF0aW9uIHZhbHVl cyBmcm9tIFhlbiBzdG9yZSBhY2NvcmRpbmcKdG8geGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmgg cHJvdG9jb2w6CiAgLSByZWFkIGNvbm5lY3RvcihzKSBjb25maWd1cmF0aW9uCiAgLSByZWFkIGJ1 ZmZlciBhbGxvY2F0aW9uIG1vZGUgKGJhY2tlbmQvZnJvbnRlbmQpCgozLiBIYW5kbGUgWGVuIGV2 ZW50IGNoYW5uZWxzOgogIC0gY3JlYXRlIGZvciBhbGwgY29uZmlndXJlZCBjb25uZWN0b3JzIGFu ZCBwdWJsaXNoCiAgICBjb3JyZXNwb25kaW5nIHJpbmcgcmVmZXJlbmNlcyBhbmQgZXZlbnQgY2hh bm5lbHMgaW4gWGVuIHN0b3JlLAogICAgc28gYmFja2VuZCBjYW4gY29ubmVjdAogIC0gaW1wbGVt ZW50IGV2ZW50IGNoYW5uZWxzIGludGVycnVwdCBoYW5kbGVycwogIC0gY3JlYXRlIGFuZCBkZXN0 cm95IGV2ZW50IGNoYW5uZWxzIHdpdGggcmVzcGVjdCB0byBYZW4gYnVzIHN0YXRlCgo0LiBJbXBs ZW1lbnQgc2hhcmVkIGJ1ZmZlciBoYW5kbGluZyBhY2NvcmRpbmcgdG8gdGhlCnBhcmEtdmlydHVh bGl6ZWQgZGlzcGxheSBkZXZpY2UgcHJvdG9jb2wgYXQgeGVuL2ludGVyZmFjZS9pby9kaXNwbGlm Lmg6CiAgLSBoYW5kbGUgcGFnZSBkaXJlY3RvcmllcyBhY2NvcmRpbmcgdG8gZGlzcGxpZiBwcm90 b2NvbDoKICAgIC0gYWxsb2NhdGUgYW5kIHNoYXJlIHBhZ2UgZGlyZWN0b3JpZXMKICAgIC0gZ3Jh bnQgcmVmZXJlbmNlcyB0byB0aGUgcmVxdWlyZWQgc2V0IG9mIHBhZ2VzIGZvciB0aGUKICAgICAg cGFnZSBkaXJlY3RvcnkKICAtIGFsbG9jYXRlIHhlbiBiYWxsbG9vbmVkIHBhZ2VzIHZpYSBYZW4g YmFsbG9vbiBkcml2ZXIKICAgIHdpdGggYWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2VzL2ZyZWVfeGVu YmFsbG9vbmVkX3BhZ2VzCiAgLSBncmFudCByZWZlcmVuY2VzIHRvIHRoZSByZXF1aXJlZCBzZXQg b2YgcGFnZXMgZm9yIHRoZQogICAgc2hhcmVkIGJ1ZmZlciBpdHNlbGYKICAtIGltcGxlbWVudCBw YWdlcyBtYXAvdW5tYXAgZm9yIHRoZSBidWZmZXJzIGFsbG9jYXRlZCBieSB0aGUKICAgIGJhY2tl bmQgKGdudHRhYl9tYXBfcmVmcy9nbnR0YWJfdW5tYXBfcmVmcykKCjUuIEltcGxlbWVudCBrZXJu ZWwgbW9kZXNldGlpbmcvY29ubmVjdG9yIGhhbmRsaW5nIHVzaW5nCkRSTSBzaW1wbGUgS01TIGhl bHBlciBwaXBlbGluZToKCi0gaW1wbGVtZW50IEtNUyBwYXJ0IG9mIHRoZSBkcml2ZXIgd2l0aCB0 aGUgaGVscCBvZiBEUk0KICBzaW1wbGUgcGlwZXBsaW5lIGhlbHBlciB3aGljaCBpcyBwb3NzaWJs ZSBkdWUgdG8gdGhlIGZhY3QKICB0aGF0IHRoZSBwYXJhLXZpcnR1YWxpemVkIGRyaXZlciBvbmx5 IHN1cHBvcnRzIGEgc2luZ2xlCiAgKHByaW1hcnkpIHBsYW5lOgogIC0gaW5pdGlhbGl6ZSBjb25u ZWN0b3JzIGFjY29yZGluZyB0byBYZW5TdG9yZSBjb25maWd1cmF0aW9uCiAgLSBoYW5kbGUgZnJh bWUgZG9uZSBldmVudHMgZnJvbSB0aGUgYmFja2VuZAogIC0gY3JlYXRlIGFuZCBkZXN0cm95IGZy YW1lIGJ1ZmZlcnMgYW5kIHByb3BhZ2F0ZSB0aG9zZQogICAgdG8gdGhlIGJhY2tlbmQKICAtIHBy b3BhZ2F0ZSBzZXQvcmVzZXQgbW9kZSBjb25maWd1cmF0aW9uIHRvIHRoZSBiYWNrZW5kIG9uIGRp c3BsYXkKICAgIGVuYWJsZS9kaXNhYmxlIGNhbGxiYWNrcwogIC0gc2VuZCBwYWdlIGZsaXAgcmVx dWVzdCB0byB0aGUgYmFja2VuZCBhbmQgaW1wbGVtZW50IGxvZ2ljIGZvcgogICAgcmVwb3J0aW5n IGJhY2tlbmQgSU8gZXJyb3JzIG9uIHByZXBhcmUgZmIgY2FsbGJhY2sKCi0gaW1wbGVtZW50IHZp cnR1YWwgY29ubmVjdG9yIGhhbmRsaW5nOgogIC0gc3VwcG9ydCBvbmx5IHBpeGVsIGZvcm1hdHMg c3VpdGFibGUgZm9yIHNpbmdsZSBwbGFuZSBtb2RlcwogIC0gbWFrZSBzdXJlIHRoZSBjb25uZWN0 b3IgaXMgYWx3YXlzIGNvbm5lY3RlZAogIC0gc3VwcG9ydCBhIHNpbmdsZSB2aWRlbyBtb2RlIGFz IHBlciBwYXJhLXZpcnR1YWxpemVkIGRyaXZlcgogICAgY29uZmlndXJhdGlvbgoKNi4gSW1wbGVt ZW50IEdFTSBoYW5kbGluZyBkZXBlbmRpbmcgb24gZHJpdmVyIG1vZGUgb2Ygb3BlcmF0aW9uOgpk ZXBlbmRpbmcgb24gdGhlIHJlcXVpcmVtZW50cyBmb3IgdGhlIHBhcmEtdmlydHVhbGl6ZWQgZW52 aXJvbm1lbnQsIG5hbWVseQpyZXF1aXJlbWVudHMgZGljdGF0ZWQgYnkgdGhlIGFjY29tcGFueWlu ZyBEUk0vKHYpR1BVIGRyaXZlcnMgcnVubmluZyBpbiBib3RoCmhvc3QgYW5kIGd1ZXN0IGVudmly b25tZW50cywgbnVtYmVyIG9mIG9wZXJhdGluZyBtb2RlcyBvZiBwYXJhLXZpcnR1YWxpemVkCmRp c3BsYXkgZHJpdmVyIGFyZSBzdXBwb3J0ZWQ6CiAtIGRpc3BsYXkgYnVmZmVycyBjYW4gYmUgYWxs b2NhdGVkIGJ5IGVpdGhlciBmcm9udGVuZCBkcml2ZXIgb3IgYmFja2VuZAogLSBkaXNwbGF5IGJ1 ZmZlcnMgY2FuIGJlIGFsbG9jYXRlZCB0byBiZSBjb250aWd1b3VzIGluIG1lbW9yeSBvciBub3QK Ck5vdGUhIEZyb250ZW5kIGRyaXZlciBpdHNlbGYgaGFzIG5vIGRlcGVuZGVuY3kgb24gY29udGln dW91cyBtZW1vcnkgZm9yCml0cyBvcGVyYXRpb24uCgo2LjEuIEJ1ZmZlcnMgYWxsb2NhdGVkIGJ5 IHRoZSBmcm9udGVuZCBkcml2ZXIuCgpUaGUgYmVsb3cgbW9kZXMgb2Ygb3BlcmF0aW9uIGFyZSBj b25maWd1cmVkIGF0IGNvbXBpbGUtdGltZSB2aWEKZnJvbnRlbmQgZHJpdmVyJ3Mga2VybmVsIGNv bmZpZ3VyYXRpb24uCgo2LjEuMS4gRnJvbnQgZHJpdmVyIGNvbmZpZ3VyZWQgdG8gdXNlIEdFTSBD TUEgaGVscGVycwogICAgIFRoaXMgdXNlLWNhc2UgaXMgdXNlZnVsIHdoZW4gdXNlZCB3aXRoIGFj Y29tcGFueWluZyBEUk0vdkdQVSBkcml2ZXIgaW4KICAgICBndWVzdCBkb21haW4gd2hpY2ggd2Fz IGRlc2lnbmVkIHRvIG9ubHkgd29yayB3aXRoIGNvbnRpZ3VvdXMgYnVmZmVycywKICAgICBlLmcu IERSTSBkcml2ZXIgYmFzZWQgb24gR0VNIENNQSBoZWxwZXJzOiBzdWNoIGRyaXZlcnMgY2FuIG9u bHkgaW1wb3J0CiAgICAgY29udGlndW91cyBQUklNRSBidWZmZXJzLCB0aHVzIHJlcXVpcmluZyBm cm9udGVuZCBkcml2ZXIgdG8gcHJvdmlkZQogICAgIHN1Y2guIEluIG9yZGVyIHRvIGltcGxlbWVu dCB0aGlzIG1vZGUgb2Ygb3BlcmF0aW9uIHBhcmEtdmlydHVhbGl6ZWQKICAgICBmcm9udGVuZCBk cml2ZXIgY2FuIGJlIGNvbmZpZ3VyZWQgdG8gdXNlIEdFTSBDTUEgaGVscGVycy4KCjYuMS4yLiBG cm9udCBkcml2ZXIgZG9lc24ndCB1c2UgR0VNIENNQQogICAgIElmIGFjY29tcGFueWluZyBkcml2 ZXJzIGNhbiBjb3BlIHdpdGggbm9uLWNvbnRpZ3VvdXMgbWVtb3J5IHRoZW4sIHRvCiAgICAgbG93 ZXIgcHJlc3N1cmUgb24gQ01BIHN1YnN5c3RlbSBvZiB0aGUga2VybmVsLCBkcml2ZXIgY2FuIGFs bG9jYXRlCiAgICAgYnVmZmVycyBmcm9tIHN5c3RlbSBtZW1vcnkuCgpOb3RlISBJZiB1c2VkIHdp dGggYWNjb21wYW55aW5nIERSTS8odilHUFUgZHJpdmVycyB0aGlzIG1vZGUgb2Ygb3BlcmF0aW9u Cm1heSByZXF1aXJlIElPTU1VIHN1cHBvcnQgb24gdGhlIHBsYXRmb3JtLCBzbyBhY2NvbXBhbnlp bmcgRFJNL3ZHUFUKaGFyZHdhcmUgY2FuIHN0aWxsIHJlYWNoIGRpc3BsYXkgYnVmZmVyIG1lbW9y eSB3aGlsZSBpbXBvcnRpbmcgUFJJTUUKYnVmZmVycyBmcm9tIHRoZSBmcm9udGVuZCBkcml2ZXIu Cgo2LjIuIEJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBiYWNrZW5kCgpUaGlzIG1vZGUgb2Ygb3Bl cmF0aW9uIGlzIHJ1bi10aW1lIGNvbmZpZ3VyZWQgdmlhIGd1ZXN0IGRvbWFpbiBjb25maWd1cmF0 aW9uCnRocm91Z2ggWGVuU3RvcmUgZW50cmllcy4KCkZvciBzeXN0ZW1zIHdoaWNoIGRvIG5vdCBw cm92aWRlIElPTU1VIHN1cHBvcnQsIGJ1dCBoYXZpbmcgc3BlY2lmaWMKcmVxdWlyZW1lbnRzIGZv ciBkaXNwbGF5IGJ1ZmZlcnMgaXQgaXMgcG9zc2libGUgdG8gYWxsb2NhdGUgc3VjaCBidWZmZXJz CmF0IGJhY2tlbmQgc2lkZSBhbmQgc2hhcmUgdGhvc2Ugd2l0aCB0aGUgZnJvbnRlbmQuCkZvciBl eGFtcGxlLCBpZiBob3N0IGRvbWFpbiBpcyAxOjEgbWFwcGVkIGFuZCBoYXMgRFJNL0dQVSBoYXJk d2FyZSBleHBlY3RpbmcKcGh5c2ljYWxseSBjb250aWd1b3VzIG1lbW9yeSwgdGhpcyBhbGxvd3Mg aW1wbGVtZW50aW5nIHplcm8tY29weWluZwp1c2UtY2FzZXMuCgpOb3RlLCB3aGlsZSB1c2luZyB0 aGlzIHNjZW5hcmlvIHRoZSBmb2xsb3dpbmcgc2hvdWxkIGJlIGNvbnNpZGVyZWQ6CiAgYSkgSWYg Z3Vlc3QgZG9tYWluIGRpZXMgdGhlbiBwYWdlcy9ncmFudHMgcmVjZWl2ZWQgZnJvbSB0aGUgYmFj a2VuZAogICAgIGNhbm5vdCBiZSBjbGFpbWVkIGJhY2sKICBiKSBNaXNiZWhhdmluZyBndWVzdCBt YXkgc2VuZCB0b28gbWFueSByZXF1ZXN0cyB0byB0aGUKICAgICBiYWNrZW5kIGV4aGF1c3Rpbmcg aXRzIGdyYW50IHJlZmVyZW5jZXMgYW5kIG1lbW9yeQogICAgIChjb25zaWRlciB0aGlzIGZyb20g c2VjdXJpdHkgUE9WKS4KCk5vdGUhIENvbmZpZ3VyYXRpb24gb3B0aW9ucyAxLjEgKGNvbnRpZ3Vv dXMgZGlzcGxheSBidWZmZXJzKSBhbmQgMiAoYmFja2VuZAphbGxvY2F0ZWQgYnVmZmVycykgYXJl IG5vdCBzdXBwb3J0ZWQgYXQgdGhlIHNhbWUgdGltZS4KCjcuIEhhbmRsZSBjb21tdW5pY2F0aW9u IHdpdGggdGhlIGJhY2tlbmQ6CiAtIHNlbmQgcmVxdWVzdHMgYW5kIHdhaXQgZm9yIHRoZSByZXNw b25zZXMgYWNjb3JkaW5nCiAgIHRvIHRoZSBkaXNwbGlmIHByb3RvY29sCiAtIHNlcmlhbGl6ZSBh Y2Nlc3MgdG8gdGhlIGNvbW11bmljYXRpb24gY2hhbm5lbAogLSB0aW1lLW91dCB1c2VkIGZvciBi YWNrZW5kIGNvbW11bmljYXRpb24gaXMgc2V0IHRvIDMwMDAgbXMKIC0gbWFuYWdlIGRpc3BsYXkg YnVmZmVycyBzaGFyZWQgd2l0aCB0aGUgYmFja2VuZAoKWzFdIGh0dHBzOi8vZ2l0aHViLmNvbS94 ZW4tdHJvb3BzL2Rpc3BsX2JlClsyXSBodHRwczovL2dpdGh1Yi5jb20veGVuLXRyb29wcy9saWJ4 ZW5iZQpbM10gaHR0cHM6Ly94ZW5iaXRzLnhlbi5vcmcvZ2l0d2ViLz9wPXhlbi5naXQ7YT1ibG9i O2Y9ZG9jcy9tYW4veGwuY2ZnLnBvZC41LmluO2g9YTY5OTM2Nzc3OWUyYWUxMjEyZmY4ZjYzOGVm ZjAyMDZlYzFhMWNjOTtoYj1yZWZzL2hlYWRzL21hc3RlciNsMTI1NwotLS0KIGRyaXZlcnMvZ3B1 L2RybS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKwogZHJpdmVycy9ncHUvZHJt L01ha2VmaWxlICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0veGVu L0tjb25maWcgICAgICAgICAgICAgICAgIHwgIDMwICsrCiBkcml2ZXJzL2dwdS9kcm0veGVuL01h a2VmaWxlICAgICAgICAgICAgICAgIHwgIDE3ICsKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udC5jICAgICAgICAgfCA2OTAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogZHJp dmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmggICAgICAgICB8ICA3NyArKysrCiBkcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMgICAgIHwgIDc3ICsrKysKIGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcuaCAgICAgfCAgMzcgKysKIGRyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmMgICAgfCAxNDYgKysrKysrCiBkcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5oICAgIHwgIDI3ICsrCiBkcml2ZXJzL2dw dS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZHJ2LmMgICAgIHwgMjM5ICsrKysrKysrKysKIGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9kcnYuaCAgICAgfCAgNzggKysrKwogZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYyB8IDM4MyArKysrKysrKysrKysr KysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmggfCAgNzkgKysr KwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jICAgICB8IDMzNSArKysr KysrKysrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5oICAgICB8 ICA0MSArKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYyB8ICA3 NCArKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYyAgICAgfCAzMjQg KysrKysrKysrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5oICAg ICB8ICAyNSArCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuYyAgIHwg NDMyICsrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf c2hidWYuaCAgIHwgIDcyICsrKwogMjEgZmlsZXMgY2hhbmdlZCwgMzE4NiBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi9LY29uZmlnCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZQogY3JlYXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmgKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uaAogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9kcnYuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9kcnYu aAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9l dnRjaG5sLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnRfZXZ0Y2hubC5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2dlbS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hl bi94ZW5fZHJtX2Zyb250X2dlbS5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5jCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmgKCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCmluZGV4 IGRlZWVmYTdhMTc3My4uNzU3ODI1YWM2MGRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v S2NvbmZpZworKysgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwpAQCAtMjg5LDYgKzI4OSw4IEBA IHNvdXJjZSAiZHJpdmVycy9ncHUvZHJtL3BsMTExL0tjb25maWciCiAKIHNvdXJjZSAiZHJpdmVy cy9ncHUvZHJtL3R2ZTIwMC9LY29uZmlnIgogCitzb3VyY2UgImRyaXZlcnMvZ3B1L2RybS94ZW4v S2NvbmZpZyIKKwogIyBLZWVwIGxlZ2FjeSBkcml2ZXJzIGxhc3QKIAogbWVudWNvbmZpZyBEUk1f TEVHQUNZCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUgYi9kcml2ZXJzL2dw dS9kcm0vTWFrZWZpbGUKaW5kZXggNTAwOTNmZjQ0NzliLi45ZDY2NjU3ZWExMTcgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZp bGUKQEAgLTEwMywzICsxMDMsNCBAQCBvYmotJChDT05GSUdfRFJNX01YU0ZCKQkrPSBteHNmYi8K IG9iai0kKENPTkZJR19EUk1fVElOWURSTSkgKz0gdGlueWRybS8KIG9iai0kKENPTkZJR19EUk1f UEwxMTEpICs9IHBsMTExLwogb2JqLSQoQ09ORklHX0RSTV9UVkUyMDApICs9IHR2ZTIwMC8KK29i ai0kKENPTkZJR19EUk1fWEVOKSArPSB4ZW4vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v eGVuL0tjb25maWcgYi9kcml2ZXJzL2dwdS9kcm0veGVuL0tjb25maWcKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40ZjRhYmM5MWYzYjYKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL2dwdS9kcm0veGVuL0tjb25maWcKQEAgLTAsMCArMSwzMCBAQAorY29uZmlnIERS TV9YRU4KKwlib29sICJEUk0gU3VwcG9ydCBmb3IgWGVuIGd1ZXN0IE9TIgorCWRlcGVuZHMgb24g WEVOCisJaGVscAorCSAgQ2hvb3NlIHRoaXMgb3B0aW9uIGlmIHlvdSB3YW50IHRvIGVuYWJsZSBE Uk0gc3VwcG9ydAorCSAgZm9yIFhlbi4KKworY29uZmlnIERSTV9YRU5fRlJPTlRFTkQKKwl0cmlz dGF0ZSAiUGFyYS12aXJ0dWFsaXplZCBmcm9udGVuZCBkcml2ZXIgZm9yIFhlbiBndWVzdCBPUyIK KwlkZXBlbmRzIG9uIERSTV9YRU4KKwlkZXBlbmRzIG9uIERSTQorCXNlbGVjdCBEUk1fS01TX0hF TFBFUgorCXNlbGVjdCBWSURFT01PREVfSEVMUEVSUworCXNlbGVjdCBYRU5fWEVOQlVTX0ZST05U RU5ECisJaGVscAorCSAgQ2hvb3NlIHRoaXMgb3B0aW9uIGlmIHlvdSB3YW50IHRvIGVuYWJsZSBh IHBhcmEtdmlydHVhbGl6ZWQKKwkgIGZyb250ZW5kIERSTS9LTVMgZHJpdmVyIGZvciBYZW4gZ3Vl c3QgT1Nlcy4KKworY29uZmlnIERSTV9YRU5fRlJPTlRFTkRfQ01BCisJYm9vbCAiVXNlIERSTSBD TUEgdG8gYWxsb2NhdGUgZHVtYiBidWZmZXJzIgorCWRlcGVuZHMgb24gRFJNX1hFTl9GUk9OVEVO RAorCXNlbGVjdCBEUk1fS01TX0NNQV9IRUxQRVIKKwlzZWxlY3QgRFJNX0dFTV9DTUFfSEVMUEVS CisJaGVscAorCSAgVXNlIERSTSBDTUEgaGVscGVycyB0byBhbGxvY2F0ZSBkaXNwbGF5IGJ1ZmZl cnMuCisJICBUaGlzIGlzIHVzZWZ1bCBmb3IgdGhlIHVzZS1jYXNlcyB3aGVuIGd1ZXN0IGRyaXZl ciBuZWVkcyB0bworCSAgc2hhcmUgb3IgZXhwb3J0IGJ1ZmZlcnMgdG8gb3RoZXIgZHJpdmVycyB3 aGljaCBvbmx5IGV4cGVjdAorCSAgY29udGlndW91cyBidWZmZXJzLgorCSAgTm90ZTogaW4gdGhp cyBtb2RlIGRyaXZlciBjYW5ub3QgdXNlIGJ1ZmZlcnMgYWxsb2NhdGVkCisJICBieSB0aGUgYmFj a2VuZC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUgYi9kcml2ZXJz L2dwdS9kcm0veGVuL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMC4uYWMxYjgyZjJhODYwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hl bi9NYWtlZmlsZQpAQCAtMCwwICsxLDE3IEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wIE9SIE1JVAorCitkcm1feGVuX2Zyb250LW9ianMgOj0geGVuX2RybV9mcm9udC5vIFwK KwkJICAgICAgeGVuX2RybV9mcm9udF9kcnYubyBcCisJCSAgICAgIHhlbl9kcm1fZnJvbnRfa21z Lm8gXAorCQkgICAgICB4ZW5fZHJtX2Zyb250X2Nvbm4ubyBcCisJCSAgICAgIHhlbl9kcm1fZnJv bnRfZXZ0Y2hubC5vIFwKKwkJICAgICAgeGVuX2RybV9mcm9udF9zaGJ1Zi5vIFwKKwkJICAgICAg eGVuX2RybV9mcm9udF9jZmcubworCitpZmVxICgkKENPTkZJR19EUk1fWEVOX0ZST05URU5EX0NN QSkseSkKKwlkcm1feGVuX2Zyb250LW9ianMgKz0geGVuX2RybV9mcm9udF9nZW1fY21hLm8KK2Vs c2UKKwlkcm1feGVuX2Zyb250LW9ianMgKz0geGVuX2RybV9mcm9udF9nZW0ubworZW5kaWYKKwor b2JqLSQoQ09ORklHX0RSTV9YRU5fRlJPTlRFTkQpICs9IGRybV94ZW5fZnJvbnQubwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMgYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLmRiYWJkZjk4Zjg5NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udC5jCkBAIC0wLDAgKzEsNjkwIEBACisvLyBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBk ZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgor ICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNo Y2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorCisjaW5jbHVk ZSA8bGludXgvb2ZfZGV2aWNlLmg+CisKKyNpbmNsdWRlIDx4ZW4vcGxhdGZvcm1fcGNpLmg+Cisj aW5jbHVkZSA8eGVuL3hlbi5oPgorI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KKworI2luY2x1ZGUg PHhlbi9pbnRlcmZhY2UvaW8vZGlzcGxpZi5oPgorCisjaW5jbHVkZSAieGVuX2RybV9mcm9udC5o IgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfZHJ2LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9u dF9ldnRjaG5sLmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgorCitzdHJ1Y3Qg eGVuX2RybV9mcm9udF9kYnVmIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CisJdWludDY0X3Qg ZGJ1Zl9jb29raWU7CisJdWludDY0X3QgZmJfY29va2llOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpzaGJ1ZjsKK307CisKK3N0YXRpYyBpbnQgZGJ1Zl9hZGRfdG9fbGlzdChzdHJ1Y3Qg eGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9z aGJ1ZiAqc2hidWYsIHVpbnQ2NF90IGRidWZfY29va2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2RidWYgKmRidWY7CisKKwlkYnVmID0ga3phbGxvYyhzaXplb2YoKmRidWYpLCBHRlBfS0VS TkVMKTsKKwlpZiAoIWRidWYpCisJCXJldHVybiAtRU5PTUVNOworCisJZGJ1Zi0+ZGJ1Zl9jb29r aWUgPSBkYnVmX2Nvb2tpZTsKKwlkYnVmLT5zaGJ1ZiA9IHNoYnVmOworCWxpc3RfYWRkKCZkYnVm LT5saXN0LCAmZnJvbnRfaW5mby0+ZGJ1Zl9saXN0KTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGlj IHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmRidWZfZ2V0KHN0cnVjdCBsaXN0X2hlYWQgKmRi dWZfbGlzdCwKKwkJdWludDY0X3QgZGJ1Zl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJv bnRfZGJ1ZiAqYnVmLCAqcTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShidWYsIHEsIGRi dWZfbGlzdCwgbGlzdCkKKwkJaWYgKGJ1Zi0+ZGJ1Zl9jb29raWUgPT0gZGJ1Zl9jb29raWUpCisJ CQlyZXR1cm4gYnVmOworCisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGRidWZfZmx1 c2hfZmIoc3RydWN0IGxpc3RfaGVhZCAqZGJ1Zl9saXN0LCB1aW50NjRfdCBmYl9jb29raWUpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqYnVmLCAqcTsKKworCWxpc3RfZm9yX2VhY2hf ZW50cnlfc2FmZShidWYsIHEsIGRidWZfbGlzdCwgbGlzdCkKKwkJaWYgKGJ1Zi0+ZmJfY29va2ll ID09IGZiX2Nvb2tpZSkKKwkJCXhlbl9kcm1fZnJvbnRfc2hidWZfZmx1c2goYnVmLT5zaGJ1Zik7 Cit9CisKK3N0YXRpYyB2b2lkIGRidWZfZnJlZShzdHJ1Y3QgbGlzdF9oZWFkICpkYnVmX2xpc3Qs IHVpbnQ2NF90IGRidWZfY29va2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmJ1 ZiwgKnE7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoYnVmLCBxLCBkYnVmX2xpc3QsIGxp c3QpCisJCWlmIChidWYtPmRidWZfY29va2llID09IGRidWZfY29va2llKSB7CisJCQlsaXN0X2Rl bCgmYnVmLT5saXN0KTsKKwkJCXhlbl9kcm1fZnJvbnRfc2hidWZfdW5tYXAoYnVmLT5zaGJ1Zik7 CisJCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2ZyZWUoYnVmLT5zaGJ1Zik7CisJCQlrZnJlZShidWYp OworCQkJYnJlYWs7CisJCX0KK30KKworc3RhdGljIHZvaWQgZGJ1Zl9mcmVlX2FsbChzdHJ1Y3Qg bGlzdF9oZWFkICpkYnVmX2xpc3QpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqYnVm LCAqcTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShidWYsIHEsIGRidWZfbGlzdCwgbGlz dCkgeworCQlsaXN0X2RlbCgmYnVmLT5saXN0KTsKKwkJeGVuX2RybV9mcm9udF9zaGJ1Zl91bm1h cChidWYtPnNoYnVmKTsKKwkJeGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKGJ1Zi0+c2hidWYpOwor CQlrZnJlZShidWYpOworCX0KK30KKworc3RhdGljIHN0cnVjdCB4ZW5kaXNwbF9yZXEgKmJlX3By ZXBhcmVfcmVxKAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sLCB1aW50 OF90IG9wZXJhdGlvbikKK3sKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisKKwlyZXEgPSBS SU5HX0dFVF9SRVFVRVNUKCZldnRjaG5sLT51LnJlcS5yaW5nLAorCQkJZXZ0Y2hubC0+dS5yZXEu cmluZy5yZXFfcHJvZF9wdnQpOworCXJlcS0+b3BlcmF0aW9uID0gb3BlcmF0aW9uOworCXJlcS0+ aWQgPSBldnRjaG5sLT5ldnRfbmV4dF9pZCsrOworCWV2dGNobmwtPmV2dF9pZCA9IHJlcS0+aWQ7 CisJcmV0dXJuIHJlcTsKK30KKworc3RhdGljIGludCBiZV9zdHJlYW1fZG9faW8oc3RydWN0IHhl bl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCwKKwkJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVx KQoreworCXJlaW5pdF9jb21wbGV0aW9uKCZldnRjaG5sLT51LnJlcS5jb21wbGV0aW9uKTsKKwlp ZiAodW5saWtlbHkoZXZ0Y2hubC0+c3RhdGUgIT0gRVZUQ0hOTF9TVEFURV9DT05ORUNURUQpKQor CQlyZXR1cm4gLUVJTzsKKworCXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mbHVzaChldnRjaG5sKTsK KwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiZV9zdHJlYW1fd2FpdF9pbyhzdHJ1Y3QgeGVu X2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sKQoreworCWlmICh3YWl0X2Zvcl9jb21wbGV0aW9u X3RpbWVvdXQoJmV2dGNobmwtPnUucmVxLmNvbXBsZXRpb24sCisJCQltc2Vjc190b19qaWZmaWVz KFhFTl9EUk1fRlJPTlRfV0FJVF9CQUNLX01TKSkgPD0gMCkKKwkJcmV0dXJuIC1FVElNRURPVVQ7 CisKKwlyZXR1cm4gZXZ0Y2hubC0+dS5yZXEucmVzcF9zdGF0dXM7Cit9CisKK2ludCB4ZW5fZHJt X2Zyb250X21vZGVfc2V0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxp bmUsCisJCXVpbnQzMl90IHgsIHVpbnQzMl90IHksIHVpbnQzMl90IHdpZHRoLCB1aW50MzJfdCBo ZWlnaHQsCisJCXVpbnQzMl90IGJwcCwgdWludDY0X3QgZmJfY29va2llKQoreworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmw7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5m byAqZnJvbnRfaW5mbzsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisJdW5zaWduZWQgbG9u ZyBmbGFnczsKKwlpbnQgcmV0OworCisJZnJvbnRfaW5mbyA9IHBpcGVsaW5lLT5kcm1faW5mby0+ ZnJvbnRfaW5mbzsKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1twaXBlbGluZS0+ aW5kZXhdLnJlcTsKKwlpZiAodW5saWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJTzsKKwor CW11dGV4X2xvY2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFz YXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEo ZXZ0Y2hubCwgWEVORElTUExfT1BfU0VUX0NPTkZJRyk7CisJcmVxLT5vcC5zZXRfY29uZmlnLngg PSB4OworCXJlcS0+b3Auc2V0X2NvbmZpZy55ID0geTsKKwlyZXEtPm9wLnNldF9jb25maWcud2lk dGggPSB3aWR0aDsKKwlyZXEtPm9wLnNldF9jb25maWcuaGVpZ2h0ID0gaGVpZ2h0OworCXJlcS0+ b3Auc2V0X2NvbmZpZy5icHAgPSBicHA7CisJcmVxLT5vcC5zZXRfY29uZmlnLmZiX2Nvb2tpZSA9 IGZiX2Nvb2tpZTsKKworCXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlm IChyZXQgPT0gMCkKKwkJcmV0ID0gYmVfc3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7CisKKwltdXRl eF91bmxvY2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCitz dGF0aWMgaW50IGJlX2RidWZfY3JlYXRlX2ludChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpm cm9udF9pbmZvLAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgsIHVpbnQz Ml90IGhlaWdodCwKKwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBzdHJ1Y3QgcGFnZSAq KnBhZ2VzLAorCQlzdHJ1Y3Qgc2dfdGFibGUgKnNndCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9u dF9ldnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpzaGJ1ZjsK KwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZf Y2ZnIGJ1Zl9jZmc7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0OworCisJZXZ0Y2hu bCA9ICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbR0VORVJJQ19PUF9FVlRfQ0hOTF0ucmVxOworCWlm ICh1bmxpa2VseSghZXZ0Y2hubCkpCisJCXJldHVybiAtRUlPOworCisJbWVtc2V0KCZidWZfY2Zn LCAwLCBzaXplb2YoYnVmX2NmZykpOworCWJ1Zl9jZmcueGJfZGV2ID0gZnJvbnRfaW5mby0+eGJf ZGV2OworCWJ1Zl9jZmcucGFnZXMgPSBwYWdlczsKKwlidWZfY2ZnLnNpemUgPSBzaXplOworCWJ1 Zl9jZmcuc2d0ID0gc2d0OworCWJ1Zl9jZmcuYmVfYWxsb2MgPSBmcm9udF9pbmZvLT5jZmcuYmVf YWxsb2M7CisKKwlzaGJ1ZiA9IHhlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2MoJmJ1Zl9jZmcpOwor CWlmICghc2hidWYpCisJCXJldHVybiAtRU5PTUVNOworCisJcmV0ID0gZGJ1Zl9hZGRfdG9fbGlz dChmcm9udF9pbmZvLCBzaGJ1ZiwgZGJ1Zl9jb29raWUpOworCWlmIChyZXQgPCAwKSB7CisJCXhl bl9kcm1fZnJvbnRfc2hidWZfZnJlZShzaGJ1Zik7CisJCXJldHVybiByZXQ7CisJfQorCisJbXV0 ZXhfbG9jaygmZnJvbnRfaW5mby0+cmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUo JmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRj aG5sLCBYRU5ESVNQTF9PUF9EQlVGX0NSRUFURSk7CisJcmVxLT5vcC5kYnVmX2NyZWF0ZS5ncmVm X2RpcmVjdG9yeSA9CisJCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2dldF9kaXJfc3RhcnQoc2hidWYp OworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUuYnVmZmVyX3N6ID0gc2l6ZTsKKwlyZXEtPm9wLmRidWZf Y3JlYXRlLmRidWZfY29va2llID0gZGJ1Zl9jb29raWU7CisJcmVxLT5vcC5kYnVmX2NyZWF0ZS53 aWR0aCA9IHdpZHRoOworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUuaGVpZ2h0ID0gaGVpZ2h0OworCXJl cS0+b3AuZGJ1Zl9jcmVhdGUuYnBwID0gYnBwOworCWlmIChidWZfY2ZnLmJlX2FsbG9jKQorCQly ZXEtPm9wLmRidWZfY3JlYXRlLmZsYWdzIHw9IFhFTkRJU1BMX0RCVUZfRkxHX1JFUV9BTExPQzsK KworCXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChyZXQgPCAwKQor CQlnb3RvIGZhaWw7CisKKwlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKwlpZiAo cmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0geGVuX2RybV9mcm9udF9zaGJ1Zl9tYXAo c2hidWYpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CisKKwltdXRleF91bmxvY2soJmZy b250X2luZm8tPnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gMDsKKworZmFpbDoKKwltdXRleF91bmxv Y2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKwlkYnVmX2ZyZWUoJmZyb250X2luZm8tPmRi dWZfbGlzdCwgZGJ1Zl9jb29raWUpOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zy b250X2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llLCB1aW50MzJfdCB3aWR0aCwgdWludDMyX3Qg aGVpZ2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90IHNpemUsIHN0cnVjdCBzZ190YWJsZSAq c2d0KQoreworCXJldHVybiBiZV9kYnVmX2NyZWF0ZV9pbnQoZnJvbnRfaW5mbywgZGJ1Zl9jb29r aWUsIHdpZHRoLCBoZWlnaHQsCisJCQlicHAsIHNpemUsIE5VTEwsIHNndCk7Cit9CisKK2ludCB4 ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fcGFnZXMoc3RydWN0IHhlbl9kcm1fZnJvbnRf aW5mbyAqZnJvbnRfaW5mbywKKwkJdWludDY0X3QgZGJ1Zl9jb29raWUsIHVpbnQzMl90IHdpZHRo LCB1aW50MzJfdCBoZWlnaHQsCisJCXVpbnQzMl90IGJwcCwgdWludDY0X3Qgc2l6ZSwgc3RydWN0 IHBhZ2UgKipwYWdlcykKK3sKKwlyZXR1cm4gYmVfZGJ1Zl9jcmVhdGVfaW50KGZyb250X2luZm8s IGRidWZfY29va2llLCB3aWR0aCwgaGVpZ2h0LAorCQkJYnBwLCBzaXplLCBwYWdlcywgTlVMTCk7 Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2RidWZfZGVzdHJveShzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvLAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSkKK3sKKwlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJl cTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWJvb2wgYmVfYWxsb2M7CisJaW50IHJldDsKKwor CWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW0dFTkVSSUNfT1BfRVZUX0NITkxdLnJl cTsKKwlpZiAodW5saWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJTzsKKworCWJlX2FsbG9j ID0gZnJvbnRfaW5mby0+Y2ZnLmJlX2FsbG9jOworCisJLyoKKwkgKiBmb3IgdGhlIGJhY2tlbmQg YWxsb2NhdGVkIGJ1ZmZlciByZWxlYXNlIHJlZmVyZW5jZXMgbm93LCBzbyBiYWNrZW5kCisJICog Y2FuIGZyZWUgdGhlIGJ1ZmZlcgorCSAqLworCWlmIChiZV9hbGxvYykKKwkJZGJ1Zl9mcmVlKCZm cm9udF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2llKTsKKworCW11dGV4X2xvY2soJmZyb250 X2luZm8tPnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5p b19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVORElTUExf T1BfREJVRl9ERVNUUk9ZKTsKKwlyZXEtPm9wLmRidWZfZGVzdHJveS5kYnVmX2Nvb2tpZSA9IGRi dWZfY29va2llOworCisJcmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmwsIHJlcSk7CisJc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCisJaWYg KHJldCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKworCS8qCisJ ICogZG8gdGhpcyByZWdhcmRsZXNzIG9mIGNvbW11bmljYXRpb24gc3RhdHVzIHdpdGggdGhlIGJh Y2tlbmQ6CisJICogaWYgd2UgY2Fubm90IHJlbW92ZSByZW1vdGUgcmVzb3VyY2VzIHJlbW92ZSB3 aGF0IHdlIGNhbiBsb2NhbGx5CisJICovCisJaWYgKCFiZV9hbGxvYykKKwkJZGJ1Zl9mcmVlKCZm cm9udF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2llKTsKKworCW11dGV4X3VubG9jaygmZnJv bnRfaW5mby0+cmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zy b250X2ZiX2F0dGFjaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQl1 aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDY0X3QgZmJfY29va2llLCB1aW50MzJfdCB3aWR0aCwK KwkJdWludDMyX3QgaGVpZ2h0LCB1aW50MzJfdCBwaXhlbF9mb3JtYXQpCit7CisJc3RydWN0IHhl bl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kYnVm ICpidWY7CisJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVxOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7 CisJaW50IHJldDsKKworCWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW0dFTkVSSUNf T1BfRVZUX0NITkxdLnJlcTsKKwlpZiAodW5saWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJ TzsKKworCWJ1ZiA9IGRidWZfZ2V0KCZmcm9udF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2ll KTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlidWYtPmZiX2Nvb2tpZSA9IGZi X2Nvb2tpZTsKKworCW11dGV4X2xvY2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKworCXNw aW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVf cHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVORElTUExfT1BfRkJfQVRUQUNIKTsKKwlyZXEtPm9wLmZi X2F0dGFjaC5kYnVmX2Nvb2tpZSA9IGRidWZfY29va2llOworCXJlcS0+b3AuZmJfYXR0YWNoLmZi X2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKwlyZXEtPm9wLmZiX2F0dGFjaC53aWR0aCA9IHdpZHRoOwor CXJlcS0+b3AuZmJfYXR0YWNoLmhlaWdodCA9IGhlaWdodDsKKwlyZXEtPm9wLmZiX2F0dGFjaC5w aXhlbF9mb3JtYXQgPSBwaXhlbF9mb3JtYXQ7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0 Y2hubCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2Nr LCBmbGFncyk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IGJlX3N0cmVhbV93YWl0X2lvKGV2 dGNobmwpOworCisJbXV0ZXhfdW5sb2NrKCZmcm9udF9pbmZvLT5yZXFfaW9fbG9jayk7CisJcmV0 dXJuIHJldDsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfZmJfZGV0YWNoKHN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXVpbnQ2NF90IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5kaXNwbF9yZXEg KnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByZXQ7CisKKwlldnRjaG5sID0gJmZy b250X2luZm8tPmV2dF9wYWlyc1tHRU5FUklDX09QX0VWVF9DSE5MXS5yZXE7CisJaWYgKHVubGlr ZWx5KCFldnRjaG5sKSkKKwkJcmV0dXJuIC1FSU87CisKKwltdXRleF9sb2NrKCZmcm9udF9pbmZv LT5yZXFfaW9fbG9jayk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9j aywgZmxhZ3MpOworCXJlcSA9IGJlX3ByZXBhcmVfcmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX0ZC X0RFVEFDSCk7CisJcmVxLT5vcC5mYl9kZXRhY2guZmJfY29va2llID0gZmJfY29va2llOworCisJ cmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmwsIHJlcSk7CisJc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCisJaWYgKHJldCA9PSAwKQorCQly ZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKworCW11dGV4X3VubG9jaygmZnJvbnRf aW5mby0+cmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250 X3BhZ2VfZmxpcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQlpbnQg Y29ubl9pZHgsIHVpbnQ2NF90IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9l dnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBs b25nIGZsYWdzOworCWludCByZXQ7CisKKwlpZiAodW5saWtlbHkoY29ubl9pZHggPj0gZnJvbnRf aW5mby0+bnVtX2V2dF9wYWlycykpCisJCXJldHVybiAtRUlOVkFMOworCisJZGJ1Zl9mbHVzaF9m YigmZnJvbnRfaW5mby0+ZGJ1Zl9saXN0LCBmYl9jb29raWUpOworCWV2dGNobmwgPSAmZnJvbnRf aW5mby0+ZXZ0X3BhaXJzW2Nvbm5faWR4XS5yZXE7CisKKwltdXRleF9sb2NrKCZmcm9udF9pbmZv LT5yZXFfaW9fbG9jayk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9j aywgZmxhZ3MpOworCXJlcSA9IGJlX3ByZXBhcmVfcmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX1BH X0ZMSVApOworCXJlcS0+b3AucGdfZmxpcC5mYl9jb29raWUgPSBmYl9jb29raWU7CisKKwlyZXQg PSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9 IGJlX3N0cmVhbV93YWl0X2lvKGV2dGNobmwpOworCisJbXV0ZXhfdW5sb2NrKCZmcm9udF9pbmZv LT5yZXFfaW9fbG9jayk7CisJcmV0dXJuIHJldDsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X3Vu bG9hZChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCWlmIChmcm9u dF9pbmZvLT54Yl9kZXYtPnN0YXRlICE9IFhlbmJ1c1N0YXRlUmVjb25maWd1cmluZykKKwkJcmV0 dXJuOworCisJRFJNX0RFQlVHKCJDYW4gdHJ5IHJlbW92aW5nIGRyaXZlciBub3dcbiIpOworCXhl bmJ1c19zd2l0Y2hfc3RhdGUoZnJvbnRfaW5mby0+eGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxp c2luZyk7Cit9CisKK3N0YXRpYyBpbnQgeGVuX2RybV9kcnZfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldikKK3sKKwkvKgorCSAqIFRoZSBkZXZpY2UgaXMgbm90IHNwYXduIGZyb20g YSBkZXZpY2UgdHJlZSwgc28gYXJjaF9zZXR1cF9kbWFfb3BzCisJICogaXMgbm90IGNhbGxlZCwg dGh1cyBsZWF2aW5nIHRoZSBkZXZpY2Ugd2l0aCBkdW1teSBETUEgb3BzLgorCSAqIFRoaXMgbWFr ZXMgdGhlIGRldmljZSByZXR1cm4gZXJyb3Igb24gUFJJTUUgYnVmZmVyIGltcG9ydCwgd2hpY2gK KwkgKiBpcyBub3QgY29ycmVjdDogdG8gZml4IHRoaXMgY2FsbCBvZl9kbWFfY29uZmlndXJlKCkg d2l0aCBhIE5VTEwKKwkgKiBub2RlIHRvIHNldCBkZWZhdWx0IERNQSBvcHMuCisJICovCisJb2Zf ZG1hX2NvbmZpZ3VyZSgmcGRldi0+ZGV2LCBOVUxMKTsKKwlyZXR1cm4geGVuX2RybV9mcm9udF9k cnZfcHJvYmUocGRldik7Cit9CisKK3N0YXRpYyBpbnQgeGVuX2RybV9kcnZfcmVtb3ZlKHN0cnVj dCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJcmV0dXJuIHhlbl9kcm1fZnJvbnRfZHJ2X3Jl bW92ZShwZGV2KTsKK30KKworc3RydWN0IHBsYXRmb3JtX2RldmljZV9pbmZvIHhlbl9kcm1fZnJv bnRfcGxhdGZvcm1faW5mbyA9IHsKKwkubmFtZSA9IFhFTkRJU1BMX0RSSVZFUl9OQU1FLAorCS5p ZCA9IDAsCisJLm51bV9yZXMgPSAwLAorCS5kbWFfbWFzayA9IERNQV9CSVRfTUFTSygzMiksCit9 OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciB4ZW5fZHJtX2Zyb250X2Zyb250X2lu Zm8gPSB7CisJLnByb2JlCQk9IHhlbl9kcm1fZHJ2X3Byb2JlLAorCS5yZW1vdmUJCT0geGVuX2Ry bV9kcnZfcmVtb3ZlLAorCS5kcml2ZXIJCT0geworCQkubmFtZQk9IFhFTkRJU1BMX0RSSVZFUl9O QU1FLAorCX0sCit9OworCitzdGF0aWMgdm9pZCB4ZW5fZHJtX2Rydl9kZWluaXQoc3RydWN0IHhl bl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwlpZiAoIWZyb250X2luZm8tPmRybV9w ZHJ2X3JlZ2lzdGVyZWQpCisJCXJldHVybjsKKworCWlmIChmcm9udF9pbmZvLT5kcm1fcGRldikK KwkJcGxhdGZvcm1fZGV2aWNlX3VucmVnaXN0ZXIoZnJvbnRfaW5mby0+ZHJtX3BkZXYpOworCisJ cGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJnhlbl9kcm1fZnJvbnRfZnJvbnRfaW5mbyk7CisJ ZnJvbnRfaW5mby0+ZHJtX3BkcnZfcmVnaXN0ZXJlZCA9IGZhbHNlOworCWZyb250X2luZm8tPmRy bV9wZGV2ID0gTlVMTDsKK30KKworc3RhdGljIGludCB4ZW5fZHJtX2Rydl9pbml0KHN0cnVjdCB4 ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJaW50IHJldDsKKworCXJldCA9IHBs YXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmeGVuX2RybV9mcm9udF9mcm9udF9pbmZvKTsKKwlpZiAo cmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCWZyb250X2luZm8tPmRybV9wZHJ2X3JlZ2lzdGVy ZWQgPSB0cnVlOworCS8qIHBhc3MgY2FyZCBjb25maWd1cmF0aW9uIHZpYSBwbGF0Zm9ybSBkYXRh ICovCisJeGVuX2RybV9mcm9udF9wbGF0Zm9ybV9pbmZvLmRhdGEgPSAmZnJvbnRfaW5mby0+Y2Zn OworCXhlbl9kcm1fZnJvbnRfcGxhdGZvcm1faW5mby5zaXplX2RhdGEgPSBzaXplb2YoZnJvbnRf aW5mby0+Y2ZnKTsKKworCWZyb250X2luZm8tPmRybV9wZGV2ID0gcGxhdGZvcm1fZGV2aWNlX3Jl Z2lzdGVyX2Z1bGwoCisJCQkmeGVuX2RybV9mcm9udF9wbGF0Zm9ybV9pbmZvKTsKKwlpZiAoSVNf RVJSX09SX05VTEwoZnJvbnRfaW5mby0+ZHJtX3BkZXYpKSB7CisJCURSTV9FUlJPUigiRmFpbGVk IHRvIHJlZ2lzdGVyICIgWEVORElTUExfRFJJVkVSX05BTUUgIiBQViBEUk0gZHJpdmVyXG4iKTsK KwkJZnJvbnRfaW5mby0+ZHJtX3BkZXYgPSBOVUxMOworCQl4ZW5fZHJtX2Rydl9kZWluaXQoZnJv bnRfaW5mbyk7CisJCXJldHVybiAtRU5PREVWOworCX0KKworCXJldHVybiAwOworfQorCitzdGF0 aWMgdm9pZCB4ZW5fZHJ2X3JlbW92ZV9pbnRlcm5hbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZv ICpmcm9udF9pbmZvKQoreworCXhlbl9kcm1fZHJ2X2RlaW5pdChmcm9udF9pbmZvKTsKKwl4ZW5f ZHJtX2Zyb250X2V2dGNobmxfZnJlZV9hbGwoZnJvbnRfaW5mbyk7CisJZGJ1Zl9mcmVlX2FsbCgm ZnJvbnRfaW5mby0+ZGJ1Zl9saXN0KTsKK30KKworc3RhdGljIGludCBkaXNwbGJhY2tfaW5pdHdh aXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwlzdHJ1Y3QgeGVu X2RybV9mcm9udF9jZmcgKmNmZyA9ICZmcm9udF9pbmZvLT5jZmc7CisJaW50IHJldDsKKworCWNm Zy0+ZnJvbnRfaW5mbyA9IGZyb250X2luZm87CisJcmV0ID0geGVuX2RybV9mcm9udF9jZmdfY2Fy ZChmcm9udF9pbmZvLCBjZmcpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJRFJN X0lORk8oIkhhdmUgJWQgY29uZWN0b3IocylcbiIsIGNmZy0+bnVtX2Nvbm5lY3RvcnMpOworCS8q IENyZWF0ZSBldmVudCBjaGFubmVscyBmb3IgYWxsIGNvbm5lY3RvcnMgYW5kIHB1Ymxpc2ggKi8K KwlyZXQgPSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfY3JlYXRlX2FsbChmcm9udF9pbmZvKTsKKwlp ZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXJldHVybiB4ZW5fZHJtX2Zyb250X2V2dGNo bmxfcHVibGlzaF9hbGwoZnJvbnRfaW5mbyk7Cit9CisKK3N0YXRpYyBpbnQgZGlzcGxiYWNrX2Nv bm5lY3Qoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwl4ZW5fZHJt X2Zyb250X2V2dGNobmxfc2V0X3N0YXRlKGZyb250X2luZm8sIEVWVENITkxfU1RBVEVfQ09OTkVD VEVEKTsKKwlyZXR1cm4geGVuX2RybV9kcnZfaW5pdChmcm9udF9pbmZvKTsKK30KKworc3RhdGlj IHZvaWQgZGlzcGxiYWNrX2Rpc2Nvbm5lY3Qoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJv bnRfaW5mbykKK3sKKwlib29sIHJlbW92ZWQgPSB0cnVlOworCisJaWYgKGZyb250X2luZm8tPmRy bV9wZGV2KSB7CisJCWlmICh4ZW5fZHJtX2Zyb250X2Rydl9pc191c2VkKGZyb250X2luZm8tPmRy bV9wZGV2KSkgeworCQkJRFJNX1dBUk4oIkRSTSBkcml2ZXIgc3RpbGwgaW4gdXNlLCBkZWZlcnJp bmcgcmVtb3ZhbFxuIik7CisJCQlyZW1vdmVkID0gZmFsc2U7CisJCX0gZWxzZQorCQkJeGVuX2Ry dl9yZW1vdmVfaW50ZXJuYWwoZnJvbnRfaW5mbyk7CisJfQorCisJeGVuX2RybV9mcm9udF9ldnRj aG5sX3NldF9zdGF0ZShmcm9udF9pbmZvLCBFVlRDSE5MX1NUQVRFX0RJU0NPTk5FQ1RFRCk7CisK KwlpZiAocmVtb3ZlZCkKKwkJeGVuYnVzX3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54Yl9kZXYs CisJCQkJWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpOworCWVsc2UKKwkJeGVuYnVzX3N3aXRjaF9z dGF0ZShmcm9udF9pbmZvLT54Yl9kZXYsCisJCQkJWGVuYnVzU3RhdGVSZWNvbmZpZ3VyaW5nKTsK K30KKworc3RhdGljIHZvaWQgZGlzcGxiYWNrX2NoYW5nZWQoc3RydWN0IHhlbmJ1c19kZXZpY2Ug KnhiX2RldiwKKwkJZW51bSB4ZW5idXNfc3RhdGUgYmFja2VuZF9zdGF0ZSkKK3sKKwlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvID0gZGV2X2dldF9kcnZkYXRhKCZ4Yl9kZXYt PmRldik7CisJaW50IHJldDsKKworCURSTV9ERUJVRygiQmFja2VuZCBzdGF0ZSBpcyAlcywgZnJv bnQgaXMgJXNcbiIsCisJCQl4ZW5idXNfc3Ryc3RhdGUoYmFja2VuZF9zdGF0ZSksCisJCQl4ZW5i dXNfc3Ryc3RhdGUoeGJfZGV2LT5zdGF0ZSkpOworCisJc3dpdGNoIChiYWNrZW5kX3N0YXRlKSB7 CisJY2FzZSBYZW5idXNTdGF0ZVJlY29uZmlndXJpbmc6CisJCS8qIGZhbGwgdGhyb3VnaCAqLwor CWNhc2UgWGVuYnVzU3RhdGVSZWNvbmZpZ3VyZWQ6CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNh c2UgWGVuYnVzU3RhdGVJbml0aWFsaXNlZDoKKwkJYnJlYWs7CisKKwljYXNlIFhlbmJ1c1N0YXRl SW5pdGlhbGlzaW5nOgorCQkvKiByZWNvdmVyaW5nIGFmdGVyIGJhY2tlbmQgdW5leHBlY3RlZCBj bG9zdXJlICovCisJCWRpc3BsYmFja19kaXNjb25uZWN0KGZyb250X2luZm8pOworCQlicmVhazsK KworCWNhc2UgWGVuYnVzU3RhdGVJbml0V2FpdDoKKwkJLyogcmVjb3ZlcmluZyBhZnRlciBiYWNr ZW5kIHVuZXhwZWN0ZWQgY2xvc3VyZSAqLworCQlkaXNwbGJhY2tfZGlzY29ubmVjdChmcm9udF9p bmZvKTsKKwkJaWYgKHhiX2Rldi0+c3RhdGUgIT0gWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpCisJ CQlicmVhazsKKworCQlyZXQgPSBkaXNwbGJhY2tfaW5pdHdhaXQoZnJvbnRfaW5mbyk7CisJCWlm IChyZXQgPCAwKQorCQkJeGVuYnVzX2Rldl9mYXRhbCh4Yl9kZXYsIHJldCwKKwkJCQkJImluaXRp YWxpemluZyBmcm9udGVuZCIpOworCQllbHNlCisJCQl4ZW5idXNfc3dpdGNoX3N0YXRlKHhiX2Rl diwgWGVuYnVzU3RhdGVJbml0aWFsaXNlZCk7CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0 ZUNvbm5lY3RlZDoKKwkJaWYgKHhiX2Rldi0+c3RhdGUgIT0gWGVuYnVzU3RhdGVJbml0aWFsaXNl ZCkKKwkJCWJyZWFrOworCisJCXJldCA9IGRpc3BsYmFja19jb25uZWN0KGZyb250X2luZm8pOwor CQlpZiAocmV0IDwgMCkKKwkJCXhlbmJ1c19kZXZfZmF0YWwoeGJfZGV2LCByZXQsCisJCQkJCSJp bml0aWFsaXppbmcgRFJNIGRyaXZlciIpOworCQllbHNlCisJCQl4ZW5idXNfc3dpdGNoX3N0YXRl KHhiX2RldiwgWGVuYnVzU3RhdGVDb25uZWN0ZWQpOworCQlicmVhazsKKworCWNhc2UgWGVuYnVz U3RhdGVDbG9zaW5nOgorCQkvKgorCQkgKiBpbiB0aGlzIHN0YXRlIGJhY2tlbmQgc3RhcnRzIGZy ZWVpbmcgcmVzb3VyY2VzLAorCQkgKiBzbyBsZXQgaXQgZ28gaW50byBjbG9zZWQgc3RhdGUsIHNv IHdlIGNhbiBhbHNvCisJCSAqIHJlbW92ZSBvdXJzCisJCSAqLworCQlicmVhazsKKworCWNhc2Ug WGVuYnVzU3RhdGVVbmtub3duOgorCQkvKiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIFhlbmJ1c1N0 YXRlQ2xvc2VkOgorCQlpZiAoeGJfZGV2LT5zdGF0ZSA9PSBYZW5idXNTdGF0ZUNsb3NlZCkKKwkJ CWJyZWFrOworCisJCWRpc3BsYmFja19kaXNjb25uZWN0KGZyb250X2luZm8pOworCQlicmVhazsK Kwl9Cit9CisKK3N0YXRpYyBpbnQgeGVuX2Rydl9wcm9iZShzdHJ1Y3QgeGVuYnVzX2RldmljZSAq eGJfZGV2LAorCQljb25zdCBzdHJ1Y3QgeGVuYnVzX2RldmljZV9pZCAqaWQpCit7CisJc3RydWN0 IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKworCWZyb250X2luZm8gPSBkZXZtX2t6 YWxsb2MoJnhiX2Rldi0+ZGV2LAorCQkJc2l6ZW9mKCpmcm9udF9pbmZvKSwgR0ZQX0tFUk5FTCk7 CisJaWYgKCFmcm9udF9pbmZvKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZyb250X2luZm8tPnhi X2RldiA9IHhiX2RldjsKKwlzcGluX2xvY2tfaW5pdCgmZnJvbnRfaW5mby0+aW9fbG9jayk7CisJ bXV0ZXhfaW5pdCgmZnJvbnRfaW5mby0+cmVxX2lvX2xvY2spOworCUlOSVRfTElTVF9IRUFEKCZm cm9udF9pbmZvLT5kYnVmX2xpc3QpOworCWZyb250X2luZm8tPmRybV9wZHJ2X3JlZ2lzdGVyZWQg PSBmYWxzZTsKKwlkZXZfc2V0X2RydmRhdGEoJnhiX2Rldi0+ZGV2LCBmcm9udF9pbmZvKTsKKwly ZXR1cm4geGVuYnVzX3N3aXRjaF9zdGF0ZSh4Yl9kZXYsIFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5n KTsKK30KKworc3RhdGljIGludCB4ZW5fZHJ2X3JlbW92ZShzdHJ1Y3QgeGVuYnVzX2RldmljZSAq ZGV2KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8gPSBkZXZfZ2V0 X2RydmRhdGEoJmRldi0+ZGV2KTsKKwlpbnQgdG8gPSAxMDA7CisKKwl4ZW5idXNfc3dpdGNoX3N0 YXRlKGRldiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsKKworCS8qCisJICogT24gZHJpdmVyIHJlbW92 YWwgaXQgaXMgZGlzY29ubmVjdGVkIGZyb20gWGVuQnVzLAorCSAqIHNvIG5vIGJhY2tlbmQgc3Rh dGUgY2hhbmdlIGV2ZW50cyBjb21lIHZpYSAub3RoZXJlbmRfY2hhbmdlZAorCSAqIGNhbGxiYWNr LiBUaGlzIHByZXZlbnRzIHVzIGZyb20gZXhpdGluZyBncmFjZWZ1bGx5LCBlLmcuCisJICogc2ln bmFsaW5nIHRoZSBiYWNrZW5kIHRvIGZyZWUgZXZlbnQgY2hhbm5lbHMsIHdhaXRpbmcgZm9yIGl0 cworCSAqIHN0YXRlIHRvIGNoYW5nZSB0byBYZW5idXNTdGF0ZUNsb3NlZCBhbmQgY2xlYW5pbmcg YXQgb3VyIGVuZC4KKwkgKiBOb3JtYWxseSB3aGVuIGZyb250IGRyaXZlciByZW1vdmVkIGJhY2tl bmQgd2lsbCBmaW5hbGx5IGdvIGludG8KKwkgKiBYZW5idXNTdGF0ZUluaXRXYWl0IHN0YXRlLgor CSAqCisJICogV29ya2Fyb3VuZDogcmVhZCBiYWNrZW5kJ3Mgc3RhdGUgbWFudWFsbHkgYW5kIHdh aXQgd2l0aCB0aW1lLW91dC4KKwkgKi8KKwl3aGlsZSAoKHhlbmJ1c19yZWFkX3Vuc2lnbmVkKGZy b250X2luZm8tPnhiX2Rldi0+b3RoZXJlbmQsCisJCQkic3RhdGUiLCBYZW5idXNTdGF0ZVVua25v d24pICE9IFhlbmJ1c1N0YXRlSW5pdFdhaXQpICYmCisJCQl0by0tKQorCQltc2xlZXAoMTApOwor CisJaWYgKCF0bykKKwkJRFJNX0VSUk9SKCJCYWNrZW5kIHN0YXRlIGlzICVzIHdoaWxlIHJlbW92 aW5nIGRyaXZlclxuIiwKKwkJCXhlbmJ1c19zdHJzdGF0ZSh4ZW5idXNfcmVhZF91bnNpZ25lZCgK KwkJCQkJZnJvbnRfaW5mby0+eGJfZGV2LT5vdGhlcmVuZCwKKwkJCQkJInN0YXRlIiwgWGVuYnVz U3RhdGVVbmtub3duKSkpOworCisJeGVuX2Rydl9yZW1vdmVfaW50ZXJuYWwoZnJvbnRfaW5mbyk7 CisJeGVuYnVzX2Zyb250ZW5kX2Nsb3NlZChkZXYpOworCXJldHVybiAwOworfQorCitzdGF0aWMg Y29uc3Qgc3RydWN0IHhlbmJ1c19kZXZpY2VfaWQgeGVuX2Rydl9pZHNbXSA9IHsKKwl7IFhFTkRJ U1BMX0RSSVZFUl9OQU1FIH0sCisJeyAiIiB9Cit9OworCitzdGF0aWMgc3RydWN0IHhlbmJ1c19k cml2ZXIgeGVuX2RyaXZlciA9IHsKKwkuaWRzID0geGVuX2Rydl9pZHMsCisJLnByb2JlID0geGVu X2Rydl9wcm9iZSwKKwkucmVtb3ZlID0geGVuX2Rydl9yZW1vdmUsCisJLm90aGVyZW5kX2NoYW5n ZWQgPSBkaXNwbGJhY2tfY2hhbmdlZCwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IHhlbl9kcnZf aW5pdCh2b2lkKQoreworCS8qIEF0IHRoZSBtb21lbnQgd2Ugb25seSBzdXBwb3J0IGNhc2Ugd2l0 aCBYRU5fUEFHRV9TSVpFID09IFBBR0VfU0laRSAqLworCWlmIChYRU5fUEFHRV9TSVpFICE9IFBB R0VfU0laRSkgeworCQlEUk1fRVJST1IoWEVORElTUExfRFJJVkVSX05BTUUgIjogZGlmZmVyZW50 IGtlcm5lbCBhbmQgWGVuIHBhZ2Ugc2l6ZXMgYXJlIG5vdCBzdXBwb3J0ZWQ6IFhFTl9QQUdFX1NJ WkUgKCVsdSkgIT0gUEFHRV9TSVpFICglbHUpXG4iLAorCQkJCVhFTl9QQUdFX1NJWkUsIFBBR0Vf U0laRSk7CisJCXJldHVybiAtRU5PREVWOworCX0KKworCWlmICgheGVuX2RvbWFpbigpKQorCQly ZXR1cm4gLUVOT0RFVjsKKworCWlmICgheGVuX2hhc19wdl9kZXZpY2VzKCkpCisJCXJldHVybiAt RU5PREVWOworCisJRFJNX0lORk8oIlJlZ2lzdGVyaW5nIFhFTiBQViAiIFhFTkRJU1BMX0RSSVZF Ul9OQU1FICJcbiIpOworCXJldHVybiB4ZW5idXNfcmVnaXN0ZXJfZnJvbnRlbmQoJnhlbl9kcml2 ZXIpOworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQgeGVuX2Rydl9jbGVhbnVwKHZvaWQpCit7CisJ RFJNX0lORk8oIlVucmVnaXN0ZXJpbmcgWEVOIFBWICIgWEVORElTUExfRFJJVkVSX05BTUUgIlxu Iik7CisJeGVuYnVzX3VucmVnaXN0ZXJfZHJpdmVyKCZ4ZW5fZHJpdmVyKTsKK30KKworbW9kdWxl X2luaXQoeGVuX2Rydl9pbml0KTsKK21vZHVsZV9leGl0KHhlbl9kcnZfY2xlYW51cCk7CisKK01P RFVMRV9ERVNDUklQVElPTigiWGVuIHBhcmEtdmlydHVhbGl6ZWQgZGlzcGxheSBkZXZpY2UgZnJv bnRlbmQiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKK01PRFVMRV9BTElBUygieGVuOiJYRU5E SVNQTF9EUklWRVJfTkFNRSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9k cm1fZnJvbnQuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOTNjNThjNGU4N2QyCi0tLSAvZGV2L251 bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKQEAgLTAsMCArMSw3 NyBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8q CisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAy MDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRy dXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZu ZGVmIF9fWEVOX0RSTV9GUk9OVF9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfSF8KKworI2lu Y2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Nm Zy5oIgorCisvKiB0aW1lb3V0IGluIG1zIHRvIHdhaXQgZm9yIGJhY2tlbmQgdG8gcmVzcG9uZCAq LworI2RlZmluZSBYRU5fRFJNX0ZST05UX1dBSVRfQkFDS19NUwkzMDAwCisKKyNpZm5kZWYgR1JB TlRfSU5WQUxJRF9SRUYKKy8qCisgKiBOb3RlIG9uIHVzYWdlIG9mIGdyYW50IHJlZmVyZW5jZSAw IGFzIGludmFsaWQgZ3JhbnQgcmVmZXJlbmNlOgorICogZ3JhbnQgcmVmZXJlbmNlIDAgaXMgdmFs aWQsIGJ1dCBuZXZlciBleHBvc2VkIHRvIGEgUFYgZHJpdmVyLAorICogYmVjYXVzZSBvZiB0aGUg ZmFjdCBpdCBpcyBhbHJlYWR5IGluIHVzZS9yZXNlcnZlZCBieSB0aGUgUFYgY29uc29sZS4KKyAq LworI2RlZmluZSBHUkFOVF9JTlZBTElEX1JFRgkwCisjZW5kaWYKKworc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX3BpcGVsaW5lOworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvIHsKKwlzdHJ1 Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2OworCS8qIHRvIHByb3RlY3QgZGF0YSBiZXR3ZWVuIGJh Y2tlbmQgSU8gY29kZSBhbmQgaW50ZXJydXB0IGhhbmRsZXIgKi8KKwlzcGlubG9ja190IGlvX2xv Y2s7CisJLyogc2VyaWFsaXplciBmb3IgYmFja2VuZCBJTzogcmVxdWVzdC9yZXNwb25zZSAqLwor CXN0cnVjdCBtdXRleCByZXFfaW9fbG9jazsKKwlib29sIGRybV9wZHJ2X3JlZ2lzdGVyZWQ7CisJ LyogdmlydHVhbCBEUk0gcGxhdGZvcm0gZGV2aWNlICovCisJc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqZHJtX3BkZXY7CisKKwlpbnQgbnVtX2V2dF9wYWlyczsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9u dF9ldnRjaG5sX3BhaXIgKmV2dF9wYWlyczsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgY2Zn OworCisJLyogZGlzcGxheSBidWZmZXJzICovCisJc3RydWN0IGxpc3RfaGVhZCBkYnVmX2xpc3Q7 Cit9OworCitpbnQgeGVuX2RybV9mcm9udF9tb2RlX3NldChzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgKnBpcGVsaW5lLAorCQl1aW50MzJfdCB4LCB1aW50MzJfdCB5LCB1aW50MzJf dCB3aWR0aCwgdWludDMyX3QgaGVpZ2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90IGZiX2Nv b2tpZSk7CisKK2ludCB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4 ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llLCB1 aW50MzJfdCB3aWR0aCwgdWludDMyX3QgaGVpZ2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90 IHNpemUsIHN0cnVjdCBzZ190YWJsZSAqc2d0KTsKKworaW50IHhlbl9kcm1fZnJvbnRfZGJ1Zl9j cmVhdGVfZnJvbV9wYWdlcyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAor CQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgsIHVpbnQzMl90IGhlaWdodCwK KwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKKwor aW50IHhlbl9kcm1fZnJvbnRfZGJ1Zl9kZXN0cm95KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8g KmZyb250X2luZm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llKTsKKworaW50IHhlbl9kcm1fZnJv bnRfZmJfYXR0YWNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXVp bnQ2NF90IGRidWZfY29va2llLCB1aW50NjRfdCBmYl9jb29raWUsIHVpbnQzMl90IHdpZHRoLAor CQl1aW50MzJfdCBoZWlnaHQsIHVpbnQzMl90IHBpeGVsX2Zvcm1hdCk7CisKK2ludCB4ZW5fZHJt X2Zyb250X2ZiX2RldGFjaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAor CQl1aW50NjRfdCBmYl9jb29raWUpOworCitpbnQgeGVuX2RybV9mcm9udF9wYWdlX2ZsaXAoc3Ry dWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJaW50IGNvbm5faWR4LCB1aW50 NjRfdCBmYl9jb29raWUpOworCit2b2lkIHhlbl9kcm1fZnJvbnRfdW5sb2FkKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05U X0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2Zn LmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45YTBiMmI4ZTYxNjkKLS0tIC9kZXYvbnVsbAor KysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMKQEAgLTAsMCArMSw3 NyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisg KiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2 LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNo Y2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVk ZSA8ZHJtL2RybVAuaD4KKworI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorCisjaW5jbHVkZSA8 eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorCisj aW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfY2ZnLmgi CisKK3N0YXRpYyBpbnQgY2ZnX2Nvbm5lY3RvcihzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpm cm9udF9pbmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmdfY29ubmVjdG9yICpjb25uZWN0 b3IsCisJCWNvbnN0IGNoYXIgKnBhdGgsIGludCBpbmRleCkKK3sKKwljaGFyICpjb25uZWN0b3Jf cGF0aDsKKworCWNvbm5lY3Rvcl9wYXRoID0gZGV2bV9rYXNwcmludGYoJmZyb250X2luZm8tPnhi X2Rldi0+ZGV2LAorCQkJR0ZQX0tFUk5FTCwgIiVzLyVkIiwgcGF0aCwgaW5kZXgpOworCWlmICgh Y29ubmVjdG9yX3BhdGgpCisJCXJldHVybiAtRU5PTUVNOworCisJaWYgKHhlbmJ1c19zY2FuZihY QlRfTklMLCBjb25uZWN0b3JfcGF0aCwgWEVORElTUExfRklFTERfUkVTT0xVVElPTiwKKwkJCSIl ZCIgWEVORElTUExfUkVTT0xVVElPTl9TRVBBUkFUT1IgIiVkIiwKKwkJCSZjb25uZWN0b3ItPndp ZHRoLCAmY29ubmVjdG9yLT5oZWlnaHQpIDwgMCkgeworCQkvKiBlaXRoZXIgbm8gZW50cnkgY29u ZmlndXJlZCBvciB3cm9uZyByZXNvbHV0aW9uIHNldCAqLworCQljb25uZWN0b3ItPndpZHRoID0g MDsKKwkJY29ubmVjdG9yLT5oZWlnaHQgPSAwOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlj b25uZWN0b3ItPnhlbnN0b3JlX3BhdGggPSBjb25uZWN0b3JfcGF0aDsKKworCURSTV9JTkZPKCJD b25uZWN0b3IgJXM6IHJlc29sdXRpb24gJWR4JWRcbiIsCisJCQljb25uZWN0b3JfcGF0aCwgY29u bmVjdG9yLT53aWR0aCwgY29ubmVjdG9yLT5oZWlnaHQpOworCXJldHVybiAwOworfQorCitpbnQg eGVuX2RybV9mcm9udF9jZmdfY2FyZChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9p bmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgKmNmZykKK3sKKwlzdHJ1Y3QgeGVuYnVz X2RldmljZSAqeGJfZGV2ID0gZnJvbnRfaW5mby0+eGJfZGV2OworCWludCByZXQsIGk7CisKKwlp ZiAoeGVuYnVzX3JlYWRfdW5zaWduZWQoZnJvbnRfaW5mby0+eGJfZGV2LT5ub2RlbmFtZSwKKwkJ CVhFTkRJU1BMX0ZJRUxEX0JFX0FMTE9DLCAwKSkgeworCQlEUk1fSU5GTygiQmFja2VuZCBjYW4g cHJvdmlkZSBkaXNwbGF5IGJ1ZmZlcnNcbiIpOworCQljZmctPmJlX2FsbG9jID0gdHJ1ZTsKKwl9 CisKKwljZmctPm51bV9jb25uZWN0b3JzID0gMDsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0la RShjZmctPmNvbm5lY3RvcnMpOyBpKyspIHsKKwkJcmV0ID0gY2ZnX2Nvbm5lY3Rvcihmcm9udF9p bmZvLAorCQkJCSZjZmctPmNvbm5lY3RvcnNbaV0sIHhiX2Rldi0+bm9kZW5hbWUsIGkpOworCQlp ZiAocmV0IDwgMCkKKwkJCWJyZWFrOworCQljZmctPm51bV9jb25uZWN0b3JzKys7CisJfQorCisJ aWYgKCFjZmctPm51bV9jb25uZWN0b3JzKSB7CisJCURSTV9FUlJPUigiTm8gY29ubmVjdG9yKHMp IGNvbmZpZ3VyZWQgYXQgJXNcbiIsCisJCQkJeGJfZGV2LT5ub2RlbmFtZSk7CisJCXJldHVybiAt RU5PREVWOworCX0KKworCXJldHVybiAwOworfQorCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmggYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnRfY2ZnLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42ZTdh ZjY3MGY4Y2QKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnRfY2ZnLmgKQEAgLTAsMCArMSwzNyBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNl CisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisg KiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5r b0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9DRkdfSF8KKyNkZWZp bmUgX19YRU5fRFJNX0ZST05UX0NGR19IXworCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKwor I2RlZmluZSBYRU5fRFJNX0ZST05UX01BWF9DUlRDUwk0CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250 X2NmZ19jb25uZWN0b3IgeworCWludCB3aWR0aDsKKwlpbnQgaGVpZ2h0OworCWNoYXIgKnhlbnN0 b3JlX3BhdGg7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgeworCXN0cnVjdCB4ZW5f ZHJtX2Zyb250X2luZm8gKmZyb250X2luZm87CisJLyogbnVtYmVyIG9mIGNvbm5lY3RvcnMgaW4g dGhpcyBjb25maWd1cmF0aW9uICovCisJaW50IG51bV9jb25uZWN0b3JzOworCS8qIGNvbm5lY3Rv ciBjb25maWd1cmF0aW9ucyAqLworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZ19jb25uZWN0b3Ig Y29ubmVjdG9yc1tYRU5fRFJNX0ZST05UX01BWF9DUlRDU107CisJLyogc2V0IGlmIGR1bWIgYnVm ZmVycyBhcmUgYWxsb2NhdGVkIGV4dGVybmFsbHkgb24gYmFja2VuZCBzaWRlICovCisJYm9vbCBi ZV9hbGxvYzsKK307CisKK2ludCB4ZW5fZHJtX2Zyb250X2NmZ19jYXJkKHN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2Zn KTsKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9DRkdfSF8gKi8KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmMgYi9kcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uYWFhMWNmZmY0Nzk3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uYwpAQCAtMCwwICsxLDE0NiBAQAorLy8gU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVh bCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1z IEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJf YW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNf aGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgorCisjaW5jbHVkZSA8 dmlkZW8vdmlkZW9tb2RlLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Nvbm4uaCIKKyNp bmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Rydi5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfa21z LmgiCisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKgordG9feGVu X2RybV9waXBlbGluZShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQoreworCXJldHVy biBjb250YWluZXJfb2YoY29ubmVjdG9yLCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxp bmUsIGNvbm4pOworfQorCitzdGF0aWMgY29uc3QgdWludDMyX3QgcGxhbmVfZm9ybWF0c1tdID0g eworCURSTV9GT1JNQVRfUkdCNTY1LAorCURSTV9GT1JNQVRfUkdCODg4LAorCURSTV9GT1JNQVRf WFJHQjg4ODgsCisJRFJNX0ZPUk1BVF9BUkdCODg4OCwKKwlEUk1fRk9STUFUX1hSR0I0NDQ0LAor CURSTV9GT1JNQVRfQVJHQjQ0NDQsCisJRFJNX0ZPUk1BVF9YUkdCMTU1NSwKKwlEUk1fRk9STUFU X0FSR0IxNTU1LAorfTsKKworY29uc3QgdWludDMyX3QgKnhlbl9kcm1fZnJvbnRfY29ubl9nZXRf Zm9ybWF0cyhpbnQgKmZvcm1hdF9jb3VudCkKK3sKKwkqZm9ybWF0X2NvdW50ID0gQVJSQVlfU0la RShwbGFuZV9mb3JtYXRzKTsKKwlyZXR1cm4gcGxhbmVfZm9ybWF0czsKK30KKworc3RhdGljIGlu dCBjb25uZWN0b3JfZGV0ZWN0KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCisJCXN0 cnVjdCBkcm1fbW9kZXNldF9hY3F1aXJlX2N0eCAqY3R4LAorCQlib29sIGZvcmNlKQoreworCXN0 cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUgPQorCQkJdG9feGVuX2Ry bV9waXBlbGluZShjb25uZWN0b3IpOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8gPSBwaXBlbGluZS0+ZHJtX2luZm8tPmZyb250X2luZm87CisJdW5zaWduZWQgbG9uZyBm bGFnczsKKworCS8qIGNoZWNrIGlmIHRoZXJlIGlzIGEgZnJhbWUgZG9uZSBldmVudCB0aW1lLW91 dCAqLworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJ aWYgKHBpcGVsaW5lLT5wZmxpcF90aW1lb3V0ICYmCisJCQl0aW1lX2FmdGVyX2VxKGppZmZpZXMs IHBpcGVsaW5lLT5wZmxpcF90aW1lb3V0KSkgeworCQlEUk1fRVJST1IoIkZyYW1lIGRvbmUgZXZl bnQgdGltZWQtb3V0XG4iKTsKKworCQlwaXBlbGluZS0+cGZsaXBfdGltZW91dCA9IDA7CisJCXBp cGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA9IGZhbHNlOworCQl4ZW5fZHJtX2Zyb250X2ttc19zZW5k X3BlbmRpbmdfZXZlbnQocGlwZWxpbmUpOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZm cm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAoZHJtX2Rldl9pc191bnBsdWdnZWQo Y29ubmVjdG9yLT5kZXYpKQorCQlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSBmYWxzZTsKKwor CXJldHVybiBwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPyBjb25uZWN0b3Jfc3RhdHVzX2Nvbm5l Y3RlZCA6CisJCQljb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKK30KKworI2RlZmluZSBY RU5fRFJNX05VTV9WSURFT19NT0RFUwkJMQorI2RlZmluZSBYRU5fRFJNX0NSVENfVlJFRlJFU0hf SFoJNjAKKworc3RhdGljIGludCBjb25uZWN0b3JfZ2V0X21vZGVzKHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpw aXBlbGluZSA9CisJCQl0b194ZW5fZHJtX3BpcGVsaW5lKGNvbm5lY3Rvcik7CisJc3RydWN0IGRy bV9kaXNwbGF5X21vZGUgKm1vZGU7CisJc3RydWN0IHZpZGVvbW9kZSB2aWRlb21vZGU7CisJaW50 IHdpZHRoLCBoZWlnaHQ7CisKKwltb2RlID0gZHJtX21vZGVfY3JlYXRlKGNvbm5lY3Rvci0+ZGV2 KTsKKwlpZiAoIW1vZGUpCisJCXJldHVybiAwOworCisJbWVtc2V0KCZ2aWRlb21vZGUsIDAsIHNp emVvZih2aWRlb21vZGUpKTsKKwl2aWRlb21vZGUuaGFjdGl2ZSA9IHBpcGVsaW5lLT53aWR0aDsK Kwl2aWRlb21vZGUudmFjdGl2ZSA9IHBpcGVsaW5lLT5oZWlnaHQ7CisJd2lkdGggPSB2aWRlb21v ZGUuaGFjdGl2ZSArIHZpZGVvbW9kZS5oZnJvbnRfcG9yY2ggKworCQkJdmlkZW9tb2RlLmhiYWNr X3BvcmNoICsgdmlkZW9tb2RlLmhzeW5jX2xlbjsKKwloZWlnaHQgPSB2aWRlb21vZGUudmFjdGl2 ZSArIHZpZGVvbW9kZS52ZnJvbnRfcG9yY2ggKworCQkJdmlkZW9tb2RlLnZiYWNrX3BvcmNoICsg dmlkZW9tb2RlLnZzeW5jX2xlbjsKKwl2aWRlb21vZGUucGl4ZWxjbG9jayA9IHdpZHRoICogaGVp Z2h0ICogWEVOX0RSTV9DUlRDX1ZSRUZSRVNIX0haOworCW1vZGUtPnR5cGUgPSBEUk1fTU9ERV9U WVBFX1BSRUZFUlJFRCB8IERSTV9NT0RFX1RZUEVfRFJJVkVSOworCisJZHJtX2Rpc3BsYXlfbW9k ZV9mcm9tX3ZpZGVvbW9kZSgmdmlkZW9tb2RlLCBtb2RlKTsKKwlkcm1fbW9kZV9wcm9iZWRfYWRk KGNvbm5lY3RvciwgbW9kZSk7CisJcmV0dXJuIFhFTl9EUk1fTlVNX1ZJREVPX01PREVTOworfQor CitzdGF0aWMgaW50IGNvbm5lY3Rvcl9tb2RlX3ZhbGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpj b25uZWN0b3IsCisJCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKQoreworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUgPQorCQkJdG9feGVuX2RybV9waXBl bGluZShjb25uZWN0b3IpOworCisJaWYgKG1vZGUtPmhkaXNwbGF5ICE9IHBpcGVsaW5lLT53aWR0 aCkKKwkJcmV0dXJuIE1PREVfRVJST1I7CisKKwlpZiAobW9kZS0+dmRpc3BsYXkgIT0gcGlwZWxp bmUtPmhlaWdodCkKKwkJcmV0dXJuIE1PREVfRVJST1I7CisKKwlyZXR1cm4gTU9ERV9PSzsKK30K Kworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2hlbHBlcl9mdW5jcyBjb25uZWN0 b3JfaGVscGVyX2Z1bmNzID0geworCS5nZXRfbW9kZXMgPSBjb25uZWN0b3JfZ2V0X21vZGVzLAor CS5tb2RlX3ZhbGlkID0gY29ubmVjdG9yX21vZGVfdmFsaWQsCisJLmRldGVjdF9jdHggPSBjb25u ZWN0b3JfZGV0ZWN0LAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1 bmNzIGNvbm5lY3Rvcl9mdW5jcyA9IHsKKwkuZHBtcyA9IGRybV9oZWxwZXJfY29ubmVjdG9yX2Rw bXMsCisJLmZpbGxfbW9kZXMgPSBkcm1faGVscGVyX3Byb2JlX3NpbmdsZV9jb25uZWN0b3JfbW9k ZXMsCisJLmRlc3Ryb3kgPSBkcm1fY29ubmVjdG9yX2NsZWFudXAsCisJLnJlc2V0ID0gZHJtX2F0 b21pY19oZWxwZXJfY29ubmVjdG9yX3Jlc2V0LAorCS5hdG9taWNfZHVwbGljYXRlX3N0YXRlID0g ZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2R1cGxpY2F0ZV9zdGF0ZSwKKwkuYXRvbWljX2Rl c3Ryb3lfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZGVzdHJveV9zdGF0ZSwK K307CisKK2ludCB4ZW5fZHJtX2Zyb250X2Nvbm5faW5pdChzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1faW5mbyAqZHJtX2luZm8sCisJCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQl0b194 ZW5fZHJtX3BpcGVsaW5lKGNvbm5lY3Rvcik7CisKKwlkcm1fY29ubmVjdG9yX2hlbHBlcl9hZGQo Y29ubmVjdG9yLCAmY29ubmVjdG9yX2hlbHBlcl9mdW5jcyk7CisKKwlwaXBlbGluZS0+Y29ubl9j b25uZWN0ZWQgPSB0cnVlOworCisJY29ubmVjdG9yLT5wb2xsZWQgPSBEUk1fQ09OTkVDVE9SX1BP TExfQ09OTkVDVCB8CisJCQlEUk1fQ09OTkVDVE9SX1BPTExfRElTQ09OTkVDVDsKKworCXJldHVy biBkcm1fY29ubmVjdG9yX2luaXQoZHJtX2luZm8tPmRybV9kZXYsIGNvbm5lY3RvciwKKwkJJmNv bm5lY3Rvcl9mdW5jcywgRFJNX01PREVfQ09OTkVDVE9SX1ZJUlRVQUwpOworfQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uaCBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwLi5mMzhjNGI2ZGI1ZGYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dw dS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5oCkBAIC0wLDAgKzEsMjcgQEAKKy8qIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJh LXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0g U3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xl a3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1f RlJPTlRfQ09OTl9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfQ09OTl9IXworCisjaW5jbHVk ZSA8ZHJtL2RybVAuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2NydGMuaD4KKyNpbmNsdWRlIDxkcm0v ZHJtX2VuY29kZXIuaD4KKworI2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KKworc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX2luZm87CisKK2ludCB4ZW5fZHJtX2Zyb250X2Nvbm5faW5pdChzdHJ1Y3Qg eGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8sCisJCXN0cnVjdCBkcm1fY29ubmVjdG9y ICpjb25uZWN0b3IpOworCitjb25zdCB1aW50MzJfdCAqeGVuX2RybV9mcm9udF9jb25uX2dldF9m b3JtYXRzKGludCAqZm9ybWF0X2NvdW50KTsKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9D T05OX0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf ZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZHJ2LmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zZWRlZmEyMGYxNGYKLS0tIC9kZXYvbnVs bAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZHJ2LmMKQEAgLTAsMCAr MSwyMzkgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisv KgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykg MjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5k cnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lu Y2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+Cisj aW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fZ2VtLmg+ CisjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hlbHBlci5oPgorCisjaW5jbHVkZSAieGVuX2Ry bV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfY2ZnLmgiCisjaW5jbHVkZSAieGVu X2RybV9mcm9udF9kcnYuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorI2luY2x1 ZGUgInhlbl9kcm1fZnJvbnRfa21zLmgiCisKK3N0YXRpYyBpbnQgZHVtYl9jcmVhdGUoc3RydWN0 IGRybV9maWxlICpmaWxwLCBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQlzdHJ1Y3QgZHJtX21v ZGVfY3JlYXRlX2R1bWIgKmFyZ3MpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8g KmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9i ajsKKwlpbnQgcmV0OworCisJcmV0ID0geGVuX2RybV9mcm9udF9nZW1fZHVtYl9jcmVhdGUoZmls cCwgZGV2LCBhcmdzKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWw7CisKKwlvYmogPSBkcm1fZ2Vt X29iamVjdF9sb29rdXAoZmlscCwgYXJncy0+aGFuZGxlKTsKKwlpZiAoIW9iaikgeworCQlyZXQg PSAtRU5PRU5UOworCQlnb3RvIGZhaWxfZGVzdHJveTsKKwl9CisKKwlkcm1fZ2VtX29iamVjdF91 bnJlZmVyZW5jZV91bmxvY2tlZChvYmopOworCisJLyoKKwkgKiBJbiBjYXNlIG9mIENPTkZJR19E Uk1fWEVOX0ZST05URU5EX0NNQSBnZW1fb2JqIGlzIGNvbnN0cnVjdGVkCisJICogdmlhIERSTSBD TUEgaGVscGVycyBhbmQgZG9lc24ndCBoYXZlIC0+cGFnZXMgYWxsb2NhdGVkCisJICogKHhlbmRy bV9nZW1fZ2V0X3BhZ2VzIHdpbGwgcmV0dXJuIE5VTEwpLCBidXQgaW5zdGVhZCBjYW4gcHJvdmlk ZQorCSAqIHNnIHRhYmxlCisJICovCisJaWYgKHhlbl9kcm1fZnJvbnRfZ2VtX2dldF9wYWdlcyhv YmopKQorCQlyZXQgPSB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fcGFnZXMoCisJCQkJ ZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShv YmopLAorCQkJCWFyZ3MtPndpZHRoLCBhcmdzLT5oZWlnaHQsIGFyZ3MtPmJwcCwKKwkJCQlhcmdz LT5zaXplLAorCQkJCXhlbl9kcm1fZnJvbnRfZ2VtX2dldF9wYWdlcyhvYmopKTsKKwllbHNlCisJ CXJldCA9IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9zZ3QoCisJCQkJZHJtX2luZm8t PmZyb250X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShvYmopLAorCQkJ CWFyZ3MtPndpZHRoLCBhcmdzLT5oZWlnaHQsIGFyZ3MtPmJwcCwKKwkJCQlhcmdzLT5zaXplLAor CQkJCXhlbl9kcm1fZnJvbnRfZ2VtX2dldF9zZ190YWJsZShvYmopKTsKKwlpZiAocmV0KQorCQln b3RvIGZhaWxfZGVzdHJveTsKKworCXJldHVybiAwOworCitmYWlsX2Rlc3Ryb3k6CisJZHJtX2dl bV9kdW1iX2Rlc3Ryb3koZmlscCwgZGV2LCBhcmdzLT5oYW5kbGUpOworZmFpbDoKKwlEUk1fRVJS T1IoIkZhaWxlZCB0byBjcmVhdGUgZHVtYiBidWZmZXI6ICVkXG4iLCByZXQpOworCXJldHVybiBy ZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGZyZWVfb2JqZWN0KHN0cnVjdCBkcm1fZ2VtX29iamVjdCAq b2JqKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IG9iai0+ ZGV2LT5kZXZfcHJpdmF0ZTsKKworCXhlbl9kcm1fZnJvbnRfZGJ1Zl9kZXN0cm95KGRybV9pbmZv LT5mcm9udF9pbmZvLAorCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShvYmopKTsKKwl4 ZW5fZHJtX2Zyb250X2dlbV9mcmVlX29iamVjdChvYmopOworfQorCit2b2lkIHhlbl9kcm1fZnJv bnRfb25fZnJhbWVfZG9uZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAorCQlpbnQgY29u bl9pZHgsIHVpbnQ2NF90IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1f aW5mbyAqZHJtX2luZm8gPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCWlmICh1bmxp a2VseShjb25uX2lkeCA+PSBkcm1faW5mby0+Y2ZnLT5udW1fY29ubmVjdG9ycykpCisJCXJldHVy bjsKKworCXhlbl9kcm1fZnJvbnRfa21zX29uX2ZyYW1lX2RvbmUoJmRybV9pbmZvLT5waXBlbGlu ZVtjb25uX2lkeF0sCisJCQlmYl9jb29raWUpOworfQorCitzdGF0aWMgdm9pZCBsYXN0Y2xvc2Uo c3RydWN0IGRybV9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5m byAqZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCisJeGVuX2RybV9mcm9udF91bmxvYWQo ZHJtX2luZm8tPmZyb250X2luZm8pOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3Bl cmF0aW9ucyB4ZW5fZHJtX2ZvcHMgPSB7CisJLm93bmVyICAgICAgICAgID0gVEhJU19NT0RVTEUs CisJLm9wZW4gICAgICAgICAgID0gZHJtX29wZW4sCisJLnJlbGVhc2UgICAgICAgID0gZHJtX3Jl bGVhc2UsCisJLnVubG9ja2VkX2lvY3RsID0gZHJtX2lvY3RsLAorI2lmZGVmIENPTkZJR19DT01Q QVQKKwkuY29tcGF0X2lvY3RsICAgPSBkcm1fY29tcGF0X2lvY3RsLAorI2VuZGlmCisJLnBvbGwg ICAgICAgICAgID0gZHJtX3BvbGwsCisJLnJlYWQgICAgICAgICAgID0gZHJtX3JlYWQsCisJLmxs c2VlayAgICAgICAgID0gbm9fbGxzZWVrLAorI2lmZGVmIENPTkZJR19EUk1fWEVOX0ZST05URU5E X0NNQQorCS5tbWFwICAgICAgICAgICA9IGRybV9nZW1fY21hX21tYXAsCisjZWxzZQorCS5tbWFw ICAgICAgICAgICA9IHhlbl9kcm1fZnJvbnRfZ2VtX21tYXAsCisjZW5kaWYKK307CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3Qgdm1fb3BlcmF0aW9uc19zdHJ1Y3QgeGVuX2RybV92bV9vcHMgPSB7CisJ Lm9wZW4gICAgICAgICAgID0gZHJtX2dlbV92bV9vcGVuLAorCS5jbG9zZSAgICAgICAgICA9IGRy bV9nZW1fdm1fY2xvc2UsCit9OworCitzdHJ1Y3QgZHJtX2RyaXZlciB4ZW5fZHJtX2RyaXZlciA9 IHsKKwkuZHJpdmVyX2ZlYXR1cmVzICAgICAgICAgICA9IERSSVZFUl9HRU0gfCBEUklWRVJfTU9E RVNFVCB8CisJCQkJICAgICBEUklWRVJfUFJJTUUgfCBEUklWRVJfQVRPTUlDLAorCS5sYXN0Y2xv c2UgICAgICAgICAgICAgICAgID0gbGFzdGNsb3NlLAorCS5nZW1fdm1fb3BzICAgICAgICAgICAg ICAgID0gJnhlbl9kcm1fdm1fb3BzLAorCS5nZW1fZnJlZV9vYmplY3RfdW5sb2NrZWQgID0gZnJl ZV9vYmplY3QsCisJLnByaW1lX2hhbmRsZV90b19mZCAgICAgICAgPSBkcm1fZ2VtX3ByaW1lX2hh bmRsZV90b19mZCwKKwkucHJpbWVfZmRfdG9faGFuZGxlICAgICAgICA9IGRybV9nZW1fcHJpbWVf ZmRfdG9faGFuZGxlLAorCS5nZW1fcHJpbWVfaW1wb3J0ICAgICAgICAgID0gZHJtX2dlbV9wcmlt ZV9pbXBvcnQsCisJLmdlbV9wcmltZV9leHBvcnQgICAgICAgICAgPSBkcm1fZ2VtX3ByaW1lX2V4 cG9ydCwKKwkuZ2VtX3ByaW1lX2ltcG9ydF9zZ190YWJsZSA9IHhlbl9kcm1fZnJvbnRfZ2VtX2lt cG9ydF9zZ190YWJsZSwKKwkuZ2VtX3ByaW1lX2dldF9zZ190YWJsZSAgICA9IHhlbl9kcm1fZnJv bnRfZ2VtX2dldF9zZ190YWJsZSwKKwkuZHVtYl9jcmVhdGUgICAgICAgICAgICAgICA9IGR1bWJf Y3JlYXRlLAorCS5mb3BzICAgICAgICAgICAgICAgICAgICAgID0gJnhlbl9kcm1fZm9wcywKKwku bmFtZSAgICAgICAgICAgICAgICAgICAgICA9ICJ4ZW5kcm0tZHUiLAorCS5kZXNjICAgICAgICAg ICAgICAgICAgICAgID0gIlhlbiBQViBEUk0gRGlzcGxheSBVbml0IiwKKwkuZGF0ZSAgICAgICAg ICAgICAgICAgICAgICA9ICIyMDE4MDIyMSIsCisJLm1ham9yICAgICAgICAgICAgICAgICAgICAg PSAxLAorCS5taW5vciAgICAgICAgICAgICAgICAgICAgID0gMCwKKworI2lmZGVmIENPTkZJR19E Uk1fWEVOX0ZST05URU5EX0NNQQorCS5nZW1fcHJpbWVfdm1hcCAgICAgICAgICAgID0gZHJtX2dl bV9jbWFfcHJpbWVfdm1hcCwKKwkuZ2VtX3ByaW1lX3Z1bm1hcCAgICAgICAgICA9IGRybV9nZW1f Y21hX3ByaW1lX3Z1bm1hcCwKKwkuZ2VtX3ByaW1lX21tYXAgICAgICAgICAgICA9IGRybV9nZW1f Y21hX3ByaW1lX21tYXAsCisjZWxzZQorCS5nZW1fcHJpbWVfdm1hcCAgICAgICAgICAgID0geGVu X2RybV9mcm9udF9nZW1fcHJpbWVfdm1hcCwKKwkuZ2VtX3ByaW1lX3Z1bm1hcCAgICAgICAgICA9 IHhlbl9kcm1fZnJvbnRfZ2VtX3ByaW1lX3Z1bm1hcCwKKwkuZ2VtX3ByaW1lX21tYXAgICAgICAg ICAgICA9IHhlbl9kcm1fZnJvbnRfZ2VtX3ByaW1lX21tYXAsCisjZW5kaWYKK307CisKK2ludCB4 ZW5fZHJtX2Zyb250X2Rydl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQorewor CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2ZnID0gZGV2X2dldF9wbGF0ZGF0YSgmcGRldi0+ ZGV2KTsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm87CisJc3RydWN0 IGRybV9kZXZpY2UgKmRldjsKKwlpbnQgcmV0OworCisJRFJNX0lORk8oIkNyZWF0aW5nICVzXG4i LCB4ZW5fZHJtX2RyaXZlci5kZXNjKTsKKworCWRybV9pbmZvID0gZGV2bV9remFsbG9jKCZwZGV2 LT5kZXYsIHNpemVvZigqZHJtX2luZm8pLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRybV9pbmZvKQor CQlyZXR1cm4gLUVOT01FTTsKKworCWRybV9pbmZvLT5mcm9udF9pbmZvID0gY2ZnLT5mcm9udF9p bmZvOworCisJZGV2ID0gZHJtX2Rldl9hbGxvYygmeGVuX2RybV9kcml2ZXIsICZwZGV2LT5kZXYp OworCWlmICghZGV2KQorCQlyZXR1cm4gLUVOT01FTTsKKworCWRybV9pbmZvLT5kcm1fZGV2ID0g ZGV2OworCisJZHJtX2luZm8tPmNmZyA9IGNmZzsKKwlkZXYtPmRldl9wcml2YXRlID0gZHJtX2lu Zm87CisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgZHJtX2luZm8pOworCisJcmV0ID0geGVu X2RybV9mcm9udF9rbXNfaW5pdChkcm1faW5mbyk7CisJaWYgKHJldCkgeworCQlEUk1fRVJST1Io IkZhaWxlZCB0byBpbml0aWFsaXplIERSTS9LTVMsIHJldCAlZFxuIiwgcmV0KTsKKwkJZ290byBm YWlsX21vZGVzZXQ7CisJfQorCisJcmV0ID0gZHJtX2Rldl9yZWdpc3RlcihkZXYsIDApOworCWlm IChyZXQpCisJCWdvdG8gZmFpbF9yZWdpc3RlcjsKKworCURSTV9JTkZPKCJJbml0aWFsaXplZCAl cyAlZC4lZC4lZCAlcyBvbiBtaW5vciAlZFxuIiwKKwkJCXhlbl9kcm1fZHJpdmVyLm5hbWUsIHhl bl9kcm1fZHJpdmVyLm1ham9yLAorCQkJeGVuX2RybV9kcml2ZXIubWlub3IsIHhlbl9kcm1fZHJp dmVyLnBhdGNobGV2ZWwsCisJCQl4ZW5fZHJtX2RyaXZlci5kYXRlLCBkZXYtPnByaW1hcnktPmlu ZGV4KTsKKworCXJldHVybiAwOworCitmYWlsX3JlZ2lzdGVyOgorCWRybV9kZXZfdW5yZWdpc3Rl cihkZXYpOworZmFpbF9tb2Rlc2V0OgorCWRybV9rbXNfaGVscGVyX3BvbGxfZmluaShkZXYpOwor CWRybV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRldik7CisJcmV0dXJuIHJldDsKK30KKworaW50IHhl bl9kcm1fZnJvbnRfZHJ2X3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQorewor CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IHBsYXRmb3JtX2dldF9k cnZkYXRhKHBkZXYpOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBkcm1faW5mby0+ZHJtX2Rl djsKKworCWlmIChkZXYpIHsKKwkJZHJtX2ttc19oZWxwZXJfcG9sbF9maW5pKGRldik7CisJCWRy bV9kZXZfdW5yZWdpc3RlcihkZXYpOworCQlkcm1fYXRvbWljX2hlbHBlcl9zaHV0ZG93bihkZXYp OworCQlkcm1fbW9kZV9jb25maWdfY2xlYW51cChkZXYpOworCQlkcm1fZGV2X3VucmVmKGRldik7 CisJfQorCXJldHVybiAwOworfQorCitib29sIHhlbl9kcm1fZnJvbnRfZHJ2X2lzX3VzZWQoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1f aW5mbyAqZHJtX2luZm8gPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlzdHJ1Y3QgZHJt X2RldmljZSAqZGV2OworCisJaWYgKCFkcm1faW5mbykKKwkJcmV0dXJuIGZhbHNlOworCisJZGV2 ID0gZHJtX2luZm8tPmRybV9kZXY7CisJaWYgKCFkZXYpCisJCXJldHVybiBmYWxzZTsKKworCS8q CisJICogRklYTUU6IHRoZSBjb2RlIGJlbG93IG11c3QgYmUgcHJvdGVjdGVkIGJ5IGRybV9nbG9i YWxfbXV0ZXgsCisJICogYnV0IGl0IGlzIG5vdCBhY2Nlc3NpYmxlIHRvIHVzLiBBbnl3YXlzIHRo ZXJlIGlzIGEgcmFjZSBjb25kaXRpb24sCisJICogYnV0IHdlIHdpbGwgcmUtdHJ5LgorCSAqLwor CXJldHVybiBkZXYtPm9wZW5fY291bnQgIT0gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9kcnYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjUz NjU2Zjg1OGMxMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9kcnYuaApAQCAtMCwwICsxLDc4IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZp Y2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoK KyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hl bmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYgX19YRU5fRFJNX0ZST05UX0RSVl9IXworI2Rl ZmluZSBfX1hFTl9EUk1fRlJPTlRfRFJWX0hfCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorI2lu Y2x1ZGUgPGRybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuaD4KKworI2luY2x1ZGUgInhlbl9kcm1f ZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2NmZy5oIgorI2luY2x1ZGUgInhlbl9k cm1fZnJvbnRfY29ubi5oIgorCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgewor CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbzsKKworCWludCBpbmRleDsK KworCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSBwaXBlOworCisJc3RydWN0IGRybV9j b25uZWN0b3IgY29ubjsKKwkvKiBUaGVzZSBhcmUgb25seSBmb3IgY29ubmVjdG9yIG1vZGUgY2hl Y2tpbmcgKi8KKwlpbnQgd2lkdGgsIGhlaWdodDsKKworCXN0cnVjdCBkcm1fcGVuZGluZ192Ymxh bmtfZXZlbnQgKnBlbmRpbmdfZXZlbnQ7CisKKwkvKgorCSAqIHBmbGlwX3RpbWVvdXQgaXMgc2V0 IHRvIGN1cnJlbnQgamlmZmllcyBvbmNlIHdlIHNlbmQgYSBwYWdlIGZsaXAgYW5kCisJICogcmVz ZXQgdG8gMCB3aGVuIHdlIHJlY2VpdmUgZnJhbWUgZG9uZSBldmVudCBmcm9tIHRoZSBiYWNrZWQu CisJICogSXQgaXMgY2hlY2tlZCBkdXJpbmcgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MuZGV0 ZWN0X2N0eCB0byBkZXRlY3QKKwkgKiB0aW1lLW91dHMgZm9yIGZyYW1lIGRvbmUgZXZlbnQsIGUu Zy4gZHVlIHRvIGJhY2tlbmQgZXJyb3JzLgorCSAqCisJICogVGhpcyBtdXN0IGJlIHByb3RlY3Rl ZCB3aXRoIGZyb250X2luZm8tPmlvX2xvY2ssIHNvIHJhY2VzIGJldHdlZW4KKwkgKiBpbnRlcnJ1 cHQgaGFuZGxlciBhbmQgcmVzdCBvZiB0aGUgY29kZSBhcmUgcHJvcGVybHkgaGFuZGxlZC4KKwkg Ki8KKwl1bnNpZ25lZCBsb25nIHBmbGlwX3RpbWVvdXQ7CisKKwlib29sIGNvbm5fY29ubmVjdGVk OworfTsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8geworCXN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm87CisJc3RydWN0IGRybV9kZXZpY2UgKmRybV9kZXY7CisJ c3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpjZmc7CisKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgcGlwZWxpbmVbWEVOX0RSTV9GUk9OVF9NQVhfQ1JUQ1NdOworfTsKKworc3Rh dGljIGlubGluZSB1aW50NjRfdCB4ZW5fZHJtX2Zyb250X2ZiX3RvX2Nvb2tpZSgKKwkJc3RydWN0 IGRybV9mcmFtZWJ1ZmZlciAqZmIpCit7CisJcmV0dXJuICh1aW50NjRfdClmYjsKK30KKworc3Rh dGljIGlubGluZSB1aW50NjRfdCB4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2llKAorCQlzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJcmV0dXJuICh1aW50NjRfdClnZW1fb2Jq OworfQorCitpbnQgeGVuX2RybV9mcm9udF9kcnZfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldik7CisKK2ludCB4ZW5fZHJtX2Zyb250X2Rydl9yZW1vdmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldik7CisKK2Jvb2wgeGVuX2RybV9mcm9udF9kcnZfaXNfdXNlZChzdHJ1Y3Qg cGxhdGZvcm1fZGV2aWNlICpwZGV2KTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X29uX2ZyYW1lX2Rv bmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKKwkJaW50IGNvbm5faWR4LCB1aW50NjRf dCBmYl9jb29raWUpOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX0RSVl9IXyAqLworCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5jIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYwpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjIyOGI5ZmZlOGZkOAotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmMKQEAgLTAsMCAr MSwzODMgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisv KgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykg MjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5k cnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lu Y2x1ZGUgPGRybS9kcm1QLmg+CisKKyNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgorI2luY2x1ZGUg PGxpbnV4L2lycS5oPgorCisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorI2luY2x1ZGUgPHhlbi9l dmVudHMuaD4KKyNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KKworI2luY2x1ZGUgInhlbl9k cm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Rydi5oIgorI2luY2x1ZGUgInhl bl9kcm1fZnJvbnRfZXZ0Y2hubC5oIgorCitzdGF0aWMgaXJxcmV0dXJuX3QgZXZ0Y2hubF9pbnRl cnJ1cHRfY3RybChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCit7CisJc3RydWN0IHhlbl9kcm1fZnJv bnRfZXZ0Y2hubCAqZXZ0Y2hubCA9IGRldl9pZDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZv ICpmcm9udF9pbmZvID0gZXZ0Y2hubC0+ZnJvbnRfaW5mbzsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVz cCAqcmVzcDsKKwlSSU5HX0lEWCBpLCBycDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYg KHVubGlrZWx5KGV2dGNobmwtPnN0YXRlICE9IEVWVENITkxfU1RBVEVfQ09OTkVDVEVEKSkKKwkJ cmV0dXJuIElSUV9IQU5ETEVEOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlv X2xvY2ssIGZsYWdzKTsKKworYWdhaW46CisJcnAgPSBldnRjaG5sLT51LnJlcS5yaW5nLnNyaW5n LT5yc3BfcHJvZDsKKwkvKiBlbnN1cmUgd2Ugc2VlIHF1ZXVlZCByZXNwb25zZXMgdXAgdG8gcnAg Ki8KKwl2aXJ0X3JtYigpOworCisJZm9yIChpID0gZXZ0Y2hubC0+dS5yZXEucmluZy5yc3BfY29u czsgaSAhPSBycDsgaSsrKSB7CisJCXJlc3AgPSBSSU5HX0dFVF9SRVNQT05TRSgmZXZ0Y2hubC0+ dS5yZXEucmluZywgaSk7CisJCWlmICh1bmxpa2VseShyZXNwLT5pZCAhPSBldnRjaG5sLT5ldnRf aWQpKQorCQkJY29udGludWU7CisKKwkJc3dpdGNoIChyZXNwLT5vcGVyYXRpb24pIHsKKwkJY2Fz ZSBYRU5ESVNQTF9PUF9QR19GTElQOgorCQljYXNlIFhFTkRJU1BMX09QX0ZCX0FUVEFDSDoKKwkJ Y2FzZSBYRU5ESVNQTF9PUF9GQl9ERVRBQ0g6CisJCWNhc2UgWEVORElTUExfT1BfREJVRl9DUkVB VEU6CisJCWNhc2UgWEVORElTUExfT1BfREJVRl9ERVNUUk9ZOgorCQljYXNlIFhFTkRJU1BMX09Q X1NFVF9DT05GSUc6CisJCQlldnRjaG5sLT51LnJlcS5yZXNwX3N0YXR1cyA9IHJlc3AtPnN0YXR1 czsKKwkJCWNvbXBsZXRlKCZldnRjaG5sLT51LnJlcS5jb21wbGV0aW9uKTsKKwkJCWJyZWFrOwor CisJCWRlZmF1bHQ6CisJCQlEUk1fRVJST1IoIk9wZXJhdGlvbiAlZCBpcyBub3Qgc3VwcG9ydGVk XG4iLAorCQkJCXJlc3AtPm9wZXJhdGlvbik7CisJCQlicmVhazsKKwkJfQorCX0KKworCWV2dGNo bmwtPnUucmVxLnJpbmcucnNwX2NvbnMgPSBpOworCisJaWYgKGkgIT0gZXZ0Y2hubC0+dS5yZXEu cmluZy5yZXFfcHJvZF9wdnQpIHsKKwkJaW50IG1vcmVfdG9fZG87CisKKwkJUklOR19GSU5BTF9D SEVDS19GT1JfUkVTUE9OU0VTKCZldnRjaG5sLT51LnJlcS5yaW5nLAorCQkJCW1vcmVfdG9fZG8p OworCQlpZiAobW9yZV90b19kbykKKwkJCWdvdG8gYWdhaW47CisJfSBlbHNlCisJCWV2dGNobmwt PnUucmVxLnJpbmcuc3JpbmctPnJzcF9ldmVudCA9IGkgKyAxOworCisJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJldHVybiBJUlFfSEFORExF RDsKK30KKworc3RhdGljIGlycXJldHVybl90IGV2dGNobmxfaW50ZXJydXB0X2V2dChpbnQgaXJx LCB2b2lkICpkZXZfaWQpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hu bCA9IGRldl9pZDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvID0gZXZ0 Y2hubC0+ZnJvbnRfaW5mbzsKKwlzdHJ1Y3QgeGVuZGlzcGxfZXZlbnRfcGFnZSAqcGFnZSA9IGV2 dGNobmwtPnUuZXZ0LnBhZ2U7CisJdWludDMyX3QgY29ucywgcHJvZDsKKwl1bnNpZ25lZCBsb25n IGZsYWdzOworCisJaWYgKHVubGlrZWx5KGV2dGNobmwtPnN0YXRlICE9IEVWVENITkxfU1RBVEVf Q09OTkVDVEVEKSkKKwkJcmV0dXJuIElSUV9IQU5ETEVEOworCisJc3Bpbl9sb2NrX2lycXNhdmUo JmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCXByb2QgPSBwYWdlLT5pbl9wcm9kOwor CS8qIGVuc3VyZSB3ZSBzZWUgcmluZyBjb250ZW50cyB1cCB0byBwcm9kICovCisJdmlydF9ybWIo KTsKKwlpZiAocHJvZCA9PSBwYWdlLT5pbl9jb25zKQorCQlnb3RvIG91dDsKKworCWZvciAoY29u cyA9IHBhZ2UtPmluX2NvbnM7IGNvbnMgIT0gcHJvZDsgY29ucysrKSB7CisJCXN0cnVjdCB4ZW5k aXNwbF9ldnQgKmV2ZW50OworCisJCWV2ZW50ID0gJlhFTkRJU1BMX0lOX1JJTkdfUkVGKHBhZ2Us IGNvbnMpOworCQlpZiAodW5saWtlbHkoZXZlbnQtPmlkICE9IGV2dGNobmwtPmV2dF9pZCsrKSkK KwkJCWNvbnRpbnVlOworCisJCXN3aXRjaCAoZXZlbnQtPnR5cGUpIHsKKwkJY2FzZSBYRU5ESVNQ TF9FVlRfUEdfRkxJUDoKKwkJCXhlbl9kcm1fZnJvbnRfb25fZnJhbWVfZG9uZShmcm9udF9pbmZv LT5kcm1fcGRldiwKKwkJCQlldnRjaG5sLT5pbmRleCwgZXZlbnQtPm9wLnBnX2ZsaXAuZmJfY29v a2llKTsKKwkJCWJyZWFrOworCQl9CisJfQorCXBhZ2UtPmluX2NvbnMgPSBjb25zOworCS8qIGVu c3VyZSByaW5nIGNvbnRlbnRzICovCisJdmlydF93bWIoKTsKKworb3V0OgorCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm4gSVJRX0hB TkRMRUQ7Cit9CisKK3N0YXRpYyB2b2lkIGV2dGNobmxfZnJlZShzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRj aG5sKQoreworCXVuc2lnbmVkIGxvbmcgcGFnZSA9IDA7CisKKwlpZiAoZXZ0Y2hubC0+dHlwZSA9 PSBFVlRDSE5MX1RZUEVfUkVRKQorCQlwYWdlID0gKHVuc2lnbmVkIGxvbmcpZXZ0Y2hubC0+dS5y ZXEucmluZy5zcmluZzsKKwllbHNlIGlmIChldnRjaG5sLT50eXBlID09IEVWVENITkxfVFlQRV9F VlQpCisJCXBhZ2UgPSAodW5zaWduZWQgbG9uZylldnRjaG5sLT51LmV2dC5wYWdlOworCWlmICgh cGFnZSkKKwkJcmV0dXJuOworCisJZXZ0Y2hubC0+c3RhdGUgPSBFVlRDSE5MX1NUQVRFX0RJU0NP Tk5FQ1RFRDsKKworCWlmIChldnRjaG5sLT50eXBlID09IEVWVENITkxfVFlQRV9SRVEpIHsKKwkJ LyogcmVsZWFzZSBhbGwgd2hvIHN0aWxsIHdhaXRzIGZvciByZXNwb25zZSBpZiBhbnkgKi8KKwkJ ZXZ0Y2hubC0+dS5yZXEucmVzcF9zdGF0dXMgPSAtRUlPOworCQljb21wbGV0ZV9hbGwoJmV2dGNo bmwtPnUucmVxLmNvbXBsZXRpb24pOworCX0KKworCWlmIChldnRjaG5sLT5pcnEpCisJCXVuYmlu ZF9mcm9tX2lycWhhbmRsZXIoZXZ0Y2hubC0+aXJxLCBldnRjaG5sKTsKKworCWlmIChldnRjaG5s LT5wb3J0KQorCQl4ZW5idXNfZnJlZV9ldnRjaG4oZnJvbnRfaW5mby0+eGJfZGV2LCBldnRjaG5s LT5wb3J0KTsKKworCS8qIGVuZCBhY2Nlc3MgYW5kIGZyZWUgdGhlIHBhZ2UgKi8KKwlpZiAoZXZ0 Y2hubC0+Z3JlZiAhPSBHUkFOVF9JTlZBTElEX1JFRikKKwkJZ250dGFiX2VuZF9mb3JlaWduX2Fj Y2VzcyhldnRjaG5sLT5ncmVmLCAwLCBwYWdlKTsKKworCW1lbXNldChldnRjaG5sLCAwLCBzaXpl b2YoKmV2dGNobmwpKTsKK30KKworc3RhdGljIGludCBldnRjaG5sX2FsbG9jKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sIGludCBpbmRleCwKKwkJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCwKKwkJZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfdHlw ZSB0eXBlKQoreworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYgPSBmcm9udF9pbmZvLT54 Yl9kZXY7CisJdW5zaWduZWQgbG9uZyBwYWdlOworCWdyYW50X3JlZl90IGdyZWY7CisJaXJxX2hh bmRsZXJfdCBoYW5kbGVyOworCWludCByZXQ7CisKKwltZW1zZXQoZXZ0Y2hubCwgMCwgc2l6ZW9m KCpldnRjaG5sKSk7CisJZXZ0Y2hubC0+dHlwZSA9IHR5cGU7CisJZXZ0Y2hubC0+aW5kZXggPSBp bmRleDsKKwlldnRjaG5sLT5mcm9udF9pbmZvID0gZnJvbnRfaW5mbzsKKwlldnRjaG5sLT5zdGF0 ZSA9IEVWVENITkxfU1RBVEVfRElTQ09OTkVDVEVEOworCWV2dGNobmwtPmdyZWYgPSBHUkFOVF9J TlZBTElEX1JFRjsKKworCXBhZ2UgPSBnZXRfemVyb2VkX3BhZ2UoR0ZQX05PSU8gfCBfX0dGUF9I SUdIKTsKKwlpZiAoIXBhZ2UpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOworCX0K KworCWlmICh0eXBlID09IEVWVENITkxfVFlQRV9SRVEpIHsKKwkJc3RydWN0IHhlbl9kaXNwbGlm X3NyaW5nICpzcmluZzsKKworCQlpbml0X2NvbXBsZXRpb24oJmV2dGNobmwtPnUucmVxLmNvbXBs ZXRpb24pOworCQlzcmluZyA9IChzdHJ1Y3QgeGVuX2Rpc3BsaWZfc3JpbmcgKilwYWdlOworCQlT SEFSRURfUklOR19JTklUKHNyaW5nKTsKKwkJRlJPTlRfUklOR19JTklUKCZldnRjaG5sLT51LnJl cS5yaW5nLAorCQkJCXNyaW5nLCBYRU5fUEFHRV9TSVpFKTsKKworCQlyZXQgPSB4ZW5idXNfZ3Jh bnRfcmluZyh4Yl9kZXYsIHNyaW5nLCAxLCAmZ3JlZik7CisJCWlmIChyZXQgPCAwKQorCQkJZ290 byBmYWlsOworCisJCWhhbmRsZXIgPSBldnRjaG5sX2ludGVycnVwdF9jdHJsOworCX0gZWxzZSB7 CisJCWV2dGNobmwtPnUuZXZ0LnBhZ2UgPSAoc3RydWN0IHhlbmRpc3BsX2V2ZW50X3BhZ2UgKilw YWdlOworCisJCXJldCA9IGdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzcyh4Yl9kZXYtPm90aGVy ZW5kX2lkLAorCQkJCXZpcnRfdG9fZ2ZuKCh2b2lkICopcGFnZSksIDApOworCQlpZiAocmV0IDwg MCkKKwkJCWdvdG8gZmFpbDsKKworCQlncmVmID0gcmV0OworCQloYW5kbGVyID0gZXZ0Y2hubF9p bnRlcnJ1cHRfZXZ0OworCX0KKwlldnRjaG5sLT5ncmVmID0gZ3JlZjsKKworCXJldCA9IHhlbmJ1 c19hbGxvY19ldnRjaG4oeGJfZGV2LCAmZXZ0Y2hubC0+cG9ydCk7CisJaWYgKHJldCA8IDApCisJ CWdvdG8gZmFpbDsKKworCXJldCA9IGJpbmRfZXZ0Y2huX3RvX2lycWhhbmRsZXIoZXZ0Y2hubC0+ cG9ydCwKKwkJCWhhbmRsZXIsIDAsIHhiX2Rldi0+ZGV2aWNldHlwZSwgZXZ0Y2hubCk7CisJaWYg KHJldCA8IDApCisJCWdvdG8gZmFpbDsKKworCWV2dGNobmwtPmlycSA9IHJldDsKKwlyZXR1cm4g MDsKKworZmFpbDoKKwlEUk1fRVJST1IoIkZhaWxlZCB0byBhbGxvY2F0ZSByaW5nOiAlZFxuIiwg cmV0KTsKKwlyZXR1cm4gcmV0OworfQorCitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2NyZWF0 ZV9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9jZmcgKmNmZzsKKwlpbnQgcmV0LCBjb25uOworCisJY2ZnID0gJmZyb250 X2luZm8tPmNmZzsKKworCWZyb250X2luZm8tPmV2dF9wYWlycyA9IGRldm1fa2NhbGxvYygmZnJv bnRfaW5mby0+eGJfZGV2LT5kZXYsCisJCQljZmctPm51bV9jb25uZWN0b3JzLAorCQkJc2l6ZW9m KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfcGFpciksIEdGUF9LRVJORUwpOworCWlmICgh ZnJvbnRfaW5mby0+ZXZ0X3BhaXJzKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZmFpbDsK Kwl9CisKKwlmb3IgKGNvbm4gPSAwOyBjb25uIDwgY2ZnLT5udW1fY29ubmVjdG9yczsgY29ubisr KSB7CisJCXJldCA9IGV2dGNobmxfYWxsb2MoZnJvbnRfaW5mbywgY29ubiwKKwkJCQkmZnJvbnRf aW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLnJlcSwKKwkJCQlFVlRDSE5MX1RZUEVfUkVRKTsKKwkJaWYg KHJldCA8IDApIHsKKwkJCURSTV9FUlJPUigiRXJyb3IgYWxsb2NhdGluZyBjb250cm9sIGNoYW5u ZWxcbiIpOworCQkJZ290byBmYWlsOworCQl9CisKKwkJcmV0ID0gZXZ0Y2hubF9hbGxvYyhmcm9u dF9pbmZvLCBjb25uLAorCQkJCSZmcm9udF9pbmZvLT5ldnRfcGFpcnNbY29ubl0uZXZ0LAorCQkJ CUVWVENITkxfVFlQRV9FVlQpOworCQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0VSUk9SKCJFcnJv ciBhbGxvY2F0aW5nIGluLWV2ZW50IGNoYW5uZWxcbiIpOworCQkJZ290byBmYWlsOworCQl9CisJ fQorCWZyb250X2luZm8tPm51bV9ldnRfcGFpcnMgPSBjZmctPm51bV9jb25uZWN0b3JzOworCXJl dHVybiAwOworCitmYWlsOgorCXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChmcm9udF9p bmZvKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGV2dGNobmxfcHVibGlzaChzdHJ1 Y3QgeGVuYnVzX3RyYW5zYWN0aW9uIHhidCwKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hu bCAqZXZ0Y2hubCwgY29uc3QgY2hhciAqcGF0aCwKKwkJY29uc3QgY2hhciAqbm9kZV9yaW5nLCBj b25zdCBjaGFyICpub2RlX2NobmwpCit7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldiA9 IGV2dGNobmwtPmZyb250X2luZm8tPnhiX2RldjsKKwlpbnQgcmV0OworCisJLyogd3JpdGUgY29u dHJvbCBjaGFubmVsIHJpbmcgcmVmZXJlbmNlICovCisJcmV0ID0geGVuYnVzX3ByaW50Zih4YnQs IHBhdGgsIG5vZGVfcmluZywgIiV1IiwgZXZ0Y2hubC0+Z3JlZik7CisJaWYgKHJldCA8IDApIHsK KwkJeGVuYnVzX2Rldl9lcnJvcih4Yl9kZXYsIHJldCwgIndyaXRpbmcgcmluZy1yZWYiKTsKKwkJ cmV0dXJuIHJldDsKKwl9CisKKwkvKiB3cml0ZSBldmVudCBjaGFubmVsIHJpbmcgcmVmZXJlbmNl ICovCisJcmV0ID0geGVuYnVzX3ByaW50Zih4YnQsIHBhdGgsIG5vZGVfY2hubCwgIiV1IiwgZXZ0 Y2hubC0+cG9ydCk7CisJaWYgKHJldCA8IDApIHsKKwkJeGVuYnVzX2Rldl9lcnJvcih4Yl9kZXYs IHJldCwgIndyaXRpbmcgZXZlbnQgY2hhbm5lbCIpOworCQlyZXR1cm4gcmV0OworCX0KKworCXJl dHVybiAwOworfQorCitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3B1Ymxpc2hfYWxsKHN0cnVj dCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJc3RydWN0IHhlbmJ1c190cmFu c2FjdGlvbiB4YnQ7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpwbGF0X2RhdGE7CisJaW50 IHJldCwgY29ubjsKKworCXBsYXRfZGF0YSA9ICZmcm9udF9pbmZvLT5jZmc7CisKK2FnYWluOgor CXJldCA9IHhlbmJ1c190cmFuc2FjdGlvbl9zdGFydCgmeGJ0KTsKKwlpZiAocmV0IDwgMCkgewor CQl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0LAorCQkJCSJzdGFydGlu ZyB0cmFuc2FjdGlvbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCWZvciAoY29ubiA9IDA7IGNv bm4gPCBwbGF0X2RhdGEtPm51bV9jb25uZWN0b3JzOyBjb25uKyspIHsKKwkJcmV0ID0gZXZ0Y2hu bF9wdWJsaXNoKHhidCwKKwkJCQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLnJlcSwKKwkJ CQlwbGF0X2RhdGEtPmNvbm5lY3RvcnNbY29ubl0ueGVuc3RvcmVfcGF0aCwKKwkJCQlYRU5ESVNQ TF9GSUVMRF9SRVFfUklOR19SRUYsCisJCQkJWEVORElTUExfRklFTERfUkVRX0NIQU5ORUwpOwor CQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbDsKKworCQlyZXQgPSBldnRjaG5sX3B1Ymxpc2go eGJ0LAorCQkJCSZmcm9udF9pbmZvLT5ldnRfcGFpcnNbY29ubl0uZXZ0LAorCQkJCXBsYXRfZGF0 YS0+Y29ubmVjdG9yc1tjb25uXS54ZW5zdG9yZV9wYXRoLAorCQkJCVhFTkRJU1BMX0ZJRUxEX0VW VF9SSU5HX1JFRiwKKwkJCQlYRU5ESVNQTF9GSUVMRF9FVlRfQ0hBTk5FTCk7CisJCWlmIChyZXQg PCAwKQorCQkJZ290byBmYWlsOworCX0KKworCXJldCA9IHhlbmJ1c190cmFuc2FjdGlvbl9lbmQo eGJ0LCAwKTsKKwlpZiAocmV0IDwgMCkgeworCQlpZiAocmV0ID09IC1FQUdBSU4pCisJCQlnb3Rv IGFnYWluOworCisJCXhlbmJ1c19kZXZfZmF0YWwoZnJvbnRfaW5mby0+eGJfZGV2LCByZXQsCisJ CQkJImNvbXBsZXRpbmcgdHJhbnNhY3Rpb24iKTsKKwkJZ290byBmYWlsX3RvX2VuZDsKKwl9CisK KwlyZXR1cm4gMDsKKworZmFpbDoKKwl4ZW5idXNfdHJhbnNhY3Rpb25fZW5kKHhidCwgMSk7CisK K2ZhaWxfdG9fZW5kOgorCXhlbmJ1c19kZXZfZmF0YWwoZnJvbnRfaW5mby0+eGJfZGV2LCByZXQs ICJ3cml0aW5nIFhlbiBzdG9yZSIpOworCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgeGVuX2RybV9m cm9udF9ldnRjaG5sX2ZsdXNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwp Cit7CisJaW50IG5vdGlmeTsKKworCWV2dGNobmwtPnUucmVxLnJpbmcucmVxX3Byb2RfcHZ0Kys7 CisJUklOR19QVVNIX1JFUVVFU1RTX0FORF9DSEVDS19OT1RJRlkoJmV2dGNobmwtPnUucmVxLnJp bmcsIG5vdGlmeSk7CisJaWYgKG5vdGlmeSkKKwkJbm90aWZ5X3JlbW90ZV92aWFfaXJxKGV2dGNo bmwtPmlycSk7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShzdHJ1 Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQllbnVtIHhlbl9kcm1fZnJvbnRf ZXZ0Y2hubF9zdGF0ZSBzdGF0ZSkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBpOwor CisJaWYgKCFmcm9udF9pbmZvLT5ldnRfcGFpcnMpCisJCXJldHVybjsKKworCXNwaW5fbG9ja19p cnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJZm9yIChpID0gMDsgaSA8IGZy b250X2luZm8tPm51bV9ldnRfcGFpcnM7IGkrKykgeworCQlmcm9udF9pbmZvLT5ldnRfcGFpcnNb aV0ucmVxLnN0YXRlID0gc3RhdGU7CisJCWZyb250X2luZm8tPmV2dF9wYWlyc1tpXS5ldnQuc3Rh dGUgPSBzdGF0ZTsKKwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9f bG9jaywgZmxhZ3MpOworCit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2ZyZWVfYWxs KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJaW50IGk7CisKKwlp ZiAoIWZyb250X2luZm8tPmV2dF9wYWlycykKKwkJcmV0dXJuOworCisJZm9yIChpID0gMDsgaSA8 IGZyb250X2luZm8tPm51bV9ldnRfcGFpcnM7IGkrKykgeworCQlldnRjaG5sX2ZyZWUoZnJvbnRf aW5mbywgJmZyb250X2luZm8tPmV2dF9wYWlyc1tpXS5yZXEpOworCQlldnRjaG5sX2ZyZWUoZnJv bnRfaW5mbywgJmZyb250X2luZm8tPmV2dF9wYWlyc1tpXS5ldnQpOworCX0KKworCWRldm1fa2Zy ZWUoJmZyb250X2luZm8tPnhiX2Rldi0+ZGV2LCBmcm9udF9pbmZvLT5ldnRfcGFpcnMpOworCWZy b250X2luZm8tPmV2dF9wYWlycyA9IE5VTEw7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5f ZHJtX2Zyb250X2V2dGNobmwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAuLjhmYWFjZjk0NDRlNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udF9ldnRjaG5sLmgKQEAgLTAsMCArMSw3OSBAQAorLyogU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVh bCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1z IEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJf YW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9F VlRDSE5MX0hfCisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9FVlRDSE5MX0hfCisKKyNpbmNsdWRl IDxsaW51eC9jb21wbGV0aW9uLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2luY2x1 ZGUgPHhlbi9pbnRlcmZhY2UvaW8vcmluZy5oPgorI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvaW8v ZGlzcGxpZi5oPgorCisvKgorICogQWxsIG9wZXJhdGlvbnMgd2hpY2ggYXJlIG5vdCBjb25uZWN0 b3Igb3JpZW50ZWQgdXNlIHRoaXMgY3RybCBldmVudCBjaGFubmVsLAorICogZS5nLiBmYl9hdHRh Y2gvZGVzdHJveSB3aGljaCBiZWxvbmcgdG8gYSBEUk0gZGV2aWNlLCBub3QgdG8gYSBDUlRDLgor ICovCisjZGVmaW5lIEdFTkVSSUNfT1BfRVZUX0NITkwJMAorCitlbnVtIHhlbl9kcm1fZnJvbnRf ZXZ0Y2hubF9zdGF0ZSB7CisJRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQsCisJRVZUQ0hOTF9T VEFURV9DT05ORUNURUQsCit9OworCitlbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF90eXBlIHsK KwlFVlRDSE5MX1RZUEVfUkVRLAorCUVWVENITkxfVFlQRV9FVlQsCit9OworCitzdHJ1Y3QgeGVu X2RybV9mcm9udF9kcm1faW5mbzsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCB7CisJ c3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwlpbnQgZ3JlZjsKKwlpbnQg cG9ydDsKKwlpbnQgaXJxOworCWludCBpbmRleDsKKwllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hu bF9zdGF0ZSBzdGF0ZTsKKwllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF90eXBlIHR5cGU7CisJ LyogZWl0aGVyIHJlc3BvbnNlIGlkIG9yIGluY29taW5nIGV2ZW50IGlkICovCisJdWludDE2X3Qg ZXZ0X2lkOworCS8qIG5leHQgcmVxdWVzdCBpZCBvciBuZXh0IGV4cGVjdGVkIGV2ZW50IGlkICov CisJdWludDE2X3QgZXZ0X25leHRfaWQ7CisJdW5pb24geworCQlzdHJ1Y3QgeworCQkJc3RydWN0 IHhlbl9kaXNwbGlmX2Zyb250X3JpbmcgcmluZzsKKwkJCXN0cnVjdCBjb21wbGV0aW9uIGNvbXBs ZXRpb247CisJCQkvKiBsYXRlc3QgcmVzcG9uc2Ugc3RhdHVzICovCisJCQlpbnQgcmVzcF9zdGF0 dXM7CisJCX0gcmVxOworCQlzdHJ1Y3QgeworCQkJc3RydWN0IHhlbmRpc3BsX2V2ZW50X3BhZ2Ug KnBhZ2U7CisJCX0gZXZ0OworCX0gdTsKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNo bmxfcGFpciB7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCByZXE7CisJc3RydWN0IHhl bl9kcm1fZnJvbnRfZXZ0Y2hubCBldnQ7Cit9OworCitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5s X2NyZWF0ZV9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyk7CisKK2lu dCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfcHVibGlzaF9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRf aW5mbyAqZnJvbnRfaW5mbyk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2ZsdXNoKHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwpOworCit2b2lkIHhlbl9kcm1fZnJv bnRfZXZ0Y2hubF9zZXRfc3RhdGUoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5m bywKKwkJZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfc3RhdGUgc3RhdGUpOworCit2b2lkIHhl bl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpm cm9udF9pbmZvKTsKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9FVlRDSE5MX0hfICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgYi9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5mNmM1NGFiMGZkY2IKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMKQEAgLTAsMCArMSwzMzUgQEAKKy8v IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisvKgorICogIFhlbiBw YXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQ QU0gU3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8 b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgInhlbl9k cm1fZnJvbnRfZ2VtLmgiCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorI2luY2x1ZGUgPGRybS9k cm1fY3J0Y19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgorI2luY2x1 ZGUgPGRybS9kcm1fZ2VtLmg+CisKKyNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLmg+CisjaW5jbHVk ZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgorCisj aW5jbHVkZSA8eGVuL2JhbGxvb24uaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNp bmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Rydi5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfc2hi dWYuaCIKKworc3RydWN0IHhlbl9nZW1fb2JqZWN0IHsKKwlzdHJ1Y3QgZHJtX2dlbV9vYmplY3Qg YmFzZTsKKworCXNpemVfdCBudW1fcGFnZXM7CisJc3RydWN0IHBhZ2UgKipwYWdlczsKKworCS8q IHNldCBmb3IgYnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tlbmQgKi8KKwlib29sIGJlX2Fs bG9jOworCisJLyogdGhpcyBpcyBmb3IgaW1wb3J0ZWQgUFJJTUUgYnVmZmVyICovCisJc3RydWN0 IHNnX3RhYmxlICpzZ3RfaW1wb3J0ZWQ7Cit9OworCitzdGF0aWMgaW5saW5lIHN0cnVjdCB4ZW5f Z2VtX29iamVjdCAqdG9feGVuX2dlbV9vYmooCisJCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2Vt X29iaikKK3sKKwlyZXR1cm4gY29udGFpbmVyX29mKGdlbV9vYmosIHN0cnVjdCB4ZW5fZ2VtX29i amVjdCwgYmFzZSk7Cit9CisKK3N0YXRpYyBpbnQgZ2VtX2FsbG9jX3BhZ2VzX2FycmF5KHN0cnVj dCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiwKKwkJc2l6ZV90IGJ1Zl9zaXplKQoreworCXhlbl9v YmotPm51bV9wYWdlcyA9IERJVl9ST1VORF9VUChidWZfc2l6ZSwgUEFHRV9TSVpFKTsKKwl4ZW5f b2JqLT5wYWdlcyA9IGt2bWFsbG9jX2FycmF5KHhlbl9vYmotPm51bV9wYWdlcywKKwkJCXNpemVv ZihzdHJ1Y3QgcGFnZSAqKSwgR0ZQX0tFUk5FTCk7CisJcmV0dXJuIHhlbl9vYmotPnBhZ2VzID09 IE5VTEwgPyAtRU5PTUVNIDogMDsKK30KKworc3RhdGljIHZvaWQgZ2VtX2ZyZWVfcGFnZXNfYXJy YXkoc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqKQoreworCWt2ZnJlZSh4ZW5fb2JqLT5w YWdlcyk7CisJeGVuX29iai0+cGFnZXMgPSBOVUxMOworfQorCitzdGF0aWMgc3RydWN0IHhlbl9n ZW1fb2JqZWN0ICpnZW1fY3JlYXRlX29iaihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCXNpemVf dCBzaXplKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsKKwlpbnQgcmV0Owor CisJeGVuX29iaiA9IGt6YWxsb2Moc2l6ZW9mKCp4ZW5fb2JqKSwgR0ZQX0tFUk5FTCk7CisJaWYg KCF4ZW5fb2JqKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXJldCA9IGRybV9nZW1f b2JqZWN0X2luaXQoZGV2LCAmeGVuX29iai0+YmFzZSwgc2l6ZSk7CisJaWYgKHJldCA8IDApIHsK KwkJa2ZyZWUoeGVuX29iaik7CisJCXJldHVybiBFUlJfUFRSKHJldCk7CisJfQorCisJcmV0dXJu IHhlbl9vYmo7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKmdlbV9jcmVhdGUo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgc2l6ZV90IHNpemUpCit7CisJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgeGVu X2dlbV9vYmplY3QgKnhlbl9vYmo7CisJaW50IHJldDsKKworCXNpemUgPSByb3VuZF91cChzaXpl LCBQQUdFX1NJWkUpOworCXhlbl9vYmogPSBnZW1fY3JlYXRlX29iaihkZXYsIHNpemUpOworCWlm IChJU19FUlJfT1JfTlVMTCh4ZW5fb2JqKSkKKwkJcmV0dXJuIHhlbl9vYmo7CisKKwlpZiAoZHJt X2luZm8tPmNmZy0+YmVfYWxsb2MpIHsKKwkJLyoKKwkJICogYmFja2VuZCB3aWxsIGFsbG9jYXRl IHNwYWNlIGZvciB0aGlzIGJ1ZmZlciwgc28KKwkJICogb25seSBhbGxvY2F0ZSBhcnJheSBvZiBw b2ludGVycyB0byBwYWdlcworCQkgKi8KKwkJcmV0ID0gZ2VtX2FsbG9jX3BhZ2VzX2FycmF5KHhl bl9vYmosIHNpemUpOworCQlpZiAocmV0IDwgMCkKKwkJCWdvdG8gZmFpbDsKKworCQkvKgorCQkg KiBhbGxvY2F0ZSBiYWxsb29uZWQgcGFnZXMgd2hpY2ggd2lsbCBiZSB1c2VkIHRvIG1hcAorCQkg KiBncmFudCByZWZlcmVuY2VzIHByb3ZpZGVkIGJ5IHRoZSBiYWNrZW5kCisJCSAqLworCQlyZXQg PSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+bnVtX3BhZ2VzLAorCQkJCXhlbl9v YmotPnBhZ2VzKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURSTV9FUlJPUigiQ2Fubm90IGFsbG9j YXRlICV6dSBiYWxsb29uZWQgcGFnZXM6ICVkXG4iLAorCQkJCQl4ZW5fb2JqLT5udW1fcGFnZXMs IHJldCk7CisJCQlnZW1fZnJlZV9wYWdlc19hcnJheSh4ZW5fb2JqKTsKKwkJCWdvdG8gZmFpbDsK KwkJfQorCisJCXhlbl9vYmotPmJlX2FsbG9jID0gdHJ1ZTsKKwkJcmV0dXJuIHhlbl9vYmo7CisJ fQorCS8qCisJICogbmVlZCB0byBhbGxvY2F0ZSBiYWNraW5nIHBhZ2VzIG5vdywgc28gd2UgY2Fu IHNoYXJlIHRob3NlCisJICogd2l0aCB0aGUgYmFja2VuZAorCSAqLworCXhlbl9vYmotPm51bV9w YWdlcyA9IERJVl9ST1VORF9VUChzaXplLCBQQUdFX1NJWkUpOworCXhlbl9vYmotPnBhZ2VzID0g ZHJtX2dlbV9nZXRfcGFnZXMoJnhlbl9vYmotPmJhc2UpOworCWlmIChJU19FUlJfT1JfTlVMTCh4 ZW5fb2JqLT5wYWdlcykpIHsKKwkJcmV0ID0gUFRSX0VSUih4ZW5fb2JqLT5wYWdlcyk7CisJCXhl bl9vYmotPnBhZ2VzID0gTlVMTDsKKwkJZ290byBmYWlsOworCX0KKworCXJldHVybiB4ZW5fb2Jq OworCitmYWlsOgorCURSTV9FUlJPUigiRmFpbGVkIHRvIGFsbG9jYXRlIGJ1ZmZlciB3aXRoIHNp emUgJXp1XG4iLCBzaXplKTsKKwlyZXR1cm4gRVJSX1BUUihyZXQpOworfQorCitzdGF0aWMgc3Ry dWN0IHhlbl9nZW1fb2JqZWN0ICpnZW1fY3JlYXRlX3dpdGhfaGFuZGxlKHN0cnVjdCBkcm1fZmls ZSAqZmlscCwKKwkJc3RydWN0IGRybV9kZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIHVpbnQzMl90 ICpoYW5kbGUpCit7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOworCXN0cnVjdCBk cm1fZ2VtX29iamVjdCAqZ2VtX29iajsKKwlpbnQgcmV0OworCisJeGVuX29iaiA9IGdlbV9jcmVh dGUoZGV2LCBzaXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoeGVuX29iaikpCisJCXJldHVybiB4 ZW5fb2JqOworCisJZ2VtX29iaiA9ICZ4ZW5fb2JqLT5iYXNlOworCXJldCA9IGRybV9nZW1faGFu ZGxlX2NyZWF0ZShmaWxwLCBnZW1fb2JqLCBoYW5kbGUpOworCS8qIGhhbmRsZSBob2xkcyB0aGUg cmVmZXJlbmNlICovCisJZHJtX2dlbV9vYmplY3RfdW5yZWZlcmVuY2VfdW5sb2NrZWQoZ2VtX29i aik7CisJaWYgKHJldCA8IDApCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwlyZXR1cm4geGVu X29iajsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfZ2VtX2R1bWJfY3JlYXRlKHN0cnVjdCBkcm1f ZmlsZSAqZmlscCwgc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IGRybV9tb2RlX2Ny ZWF0ZV9kdW1iICphcmdzKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsKKwor CWFyZ3MtPnBpdGNoID0gRElWX1JPVU5EX1VQKGFyZ3MtPndpZHRoICogYXJncy0+YnBwLCA4KTsK KwlhcmdzLT5zaXplID0gYXJncy0+cGl0Y2ggKiBhcmdzLT5oZWlnaHQ7CisKKwl4ZW5fb2JqID0g Z2VtX2NyZWF0ZV93aXRoX2hhbmRsZShmaWxwLCBkZXYsIGFyZ3MtPnNpemUsICZhcmdzLT5oYW5k bGUpOworCWlmIChJU19FUlJfT1JfTlVMTCh4ZW5fb2JqKSkKKwkJcmV0dXJuIHhlbl9vYmogPT0g TlVMTCA/IC1FTk9NRU0gOiBQVFJfRVJSKHhlbl9vYmopOworCisJcmV0dXJuIDA7Cit9CisKK3Zv aWQgeGVuX2RybV9mcm9udF9nZW1fZnJlZV9vYmplY3Qoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpn ZW1fb2JqKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiA9IHRvX3hlbl9nZW1f b2JqKGdlbV9vYmopOworCisJaWYgKHhlbl9vYmotPmJhc2UuaW1wb3J0X2F0dGFjaCkgeworCQlk cm1fcHJpbWVfZ2VtX2Rlc3Ryb3koJnhlbl9vYmotPmJhc2UsIHhlbl9vYmotPnNndF9pbXBvcnRl ZCk7CisJCWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhlbl9vYmopOworCX0gZWxzZSB7CisJCWlmICh4 ZW5fb2JqLT5wYWdlcykgeworCQkJaWYgKHhlbl9vYmotPmJlX2FsbG9jKSB7CisJCQkJZnJlZV94 ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+bnVtX3BhZ2VzLAorCQkJCQkJeGVuX29iai0+cGFn ZXMpOworCQkJCWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhlbl9vYmopOworCQkJfSBlbHNlCisJCQkJ ZHJtX2dlbV9wdXRfcGFnZXMoJnhlbl9vYmotPmJhc2UsCisJCQkJCQl4ZW5fb2JqLT5wYWdlcywg dHJ1ZSwgZmFsc2UpOworCQl9CisJfQorCWRybV9nZW1fb2JqZWN0X3JlbGVhc2UoZ2VtX29iaik7 CisJa2ZyZWUoeGVuX29iaik7Cit9CisKK3N0cnVjdCBwYWdlICoqeGVuX2RybV9mcm9udF9nZW1f Z2V0X3BhZ2VzKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlzdHJ1Y3QgeGVu X2dlbV9vYmplY3QgKnhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1fb2JqKTsKKworCXJldHVy biB4ZW5fb2JqLT5wYWdlczsKK30KKworc3RydWN0IHNnX3RhYmxlICp4ZW5fZHJtX2Zyb250X2dl bV9nZXRfc2dfdGFibGUoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXN0cnVj dCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCisJ aWYgKCF4ZW5fb2JqLT5wYWdlcykKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXR1cm4gZHJtX3ByaW1l X3BhZ2VzX3RvX3NnKHhlbl9vYmotPnBhZ2VzLCB4ZW5fb2JqLT5udW1fcGFnZXMpOworfQorCitz dHJ1Y3QgZHJtX2dlbV9vYmplY3QgKnhlbl9kcm1fZnJvbnRfZ2VtX2ltcG9ydF9zZ190YWJsZShz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRh Y2gsIHN0cnVjdCBzZ190YWJsZSAqc2d0KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9p bmZvICpkcm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0 ICp4ZW5fb2JqOworCXNpemVfdCBzaXplOworCWludCByZXQ7CisKKwlzaXplID0gYXR0YWNoLT5k bWFidWYtPnNpemU7CisJeGVuX29iaiA9IGdlbV9jcmVhdGVfb2JqKGRldiwgc2l6ZSk7CisJaWYg KElTX0VSUl9PUl9OVUxMKHhlbl9vYmopKQorCQlyZXR1cm4gRVJSX0NBU1QoeGVuX29iaik7CisK KwlyZXQgPSBnZW1fYWxsb2NfcGFnZXNfYXJyYXkoeGVuX29iaiwgc2l6ZSk7CisJaWYgKHJldCA8 IDApCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwl4ZW5fb2JqLT5zZ3RfaW1wb3J0ZWQgPSBz Z3Q7CisKKwlyZXQgPSBkcm1fcHJpbWVfc2dfdG9fcGFnZV9hZGRyX2FycmF5cyhzZ3QsIHhlbl9v YmotPnBhZ2VzLAorCQkJTlVMTCwgeGVuX29iai0+bnVtX3BhZ2VzKTsKKwlpZiAocmV0IDwgMCkK KwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKworCS8qCisJICogTi5CLiBBbHRob3VnaCB3ZSBoYXZl IGFuIEFQSSB0byBjcmVhdGUgZGlzcGxheSBidWZmZXIgZnJvbSBzZ3QKKwkgKiB3ZSB1c2UgcGFn ZXMgQVBJLCBiZWNhdXNlIHdlIHN0aWxsIG5lZWQgdGhvc2UgZm9yIEdFTSBoYW5kbGluZywKKwkg KiBlLmcuIGZvciBtYXBwaW5nIGV0Yy4KKwkgKi8KKwlyZXQgPSB4ZW5fZHJtX2Zyb250X2RidWZf Y3JlYXRlX2Zyb21fcGFnZXMoCisJCQlkcm1faW5mby0+ZnJvbnRfaW5mbywKKwkJCXhlbl9kcm1f ZnJvbnRfZGJ1Zl90b19jb29raWUoJnhlbl9vYmotPmJhc2UpLAorCQkJMCwgMCwgMCwgc2l6ZSwg eGVuX29iai0+cGFnZXMpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gRVJSX1BUUihyZXQpOwor CisJRFJNX0RFQlVHKCJJbXBvcnRlZCBidWZmZXIgb2Ygc2l6ZSAlenUgd2l0aCBuZW50cyAldVxu IiwKKwkJc2l6ZSwgc2d0LT5uZW50cyk7CisKKwlyZXR1cm4gJnhlbl9vYmotPmJhc2U7Cit9CisK K3N0YXRpYyBpbnQgZ2VtX21tYXBfb2JqKHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiwK KwkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJdW5zaWduZWQgbG9uZyBhZGRyID0g dm1hLT52bV9zdGFydDsKKwlpbnQgaTsKKworCS8qCisJICogY2xlYXIgdGhlIFZNX1BGTk1BUCBm bGFnIHRoYXQgd2FzIHNldCBieSBkcm1fZ2VtX21tYXAoKSwgYW5kIHNldCB0aGUKKwkgKiB2bV9w Z29mZiAodXNlZCBhcyBhIGZha2UgYnVmZmVyIG9mZnNldCBieSBEUk0pIHRvIDAgYXMgd2Ugd2Fu dCB0byBtYXAKKwkgKiB0aGUgd2hvbGUgYnVmZmVyLgorCSAqLworCXZtYS0+dm1fZmxhZ3MgJj0g flZNX1BGTk1BUDsKKwl2bWEtPnZtX2ZsYWdzIHw9IFZNX01JWEVETUFQOworCXZtYS0+dm1fcGdv ZmYgPSAwOworCXZtYS0+dm1fcGFnZV9wcm90ID0gcGdwcm90X3dyaXRlY29tYmluZSh2bV9nZXRf cGFnZV9wcm90KHZtYS0+dm1fZmxhZ3MpKTsKKworCS8qCisJICogdm1fb3BlcmF0aW9uc19zdHJ1 Y3QuZmF1bHQgaGFuZGxlciB3aWxsIGJlIGNhbGxlZCBpZiBDUFUgYWNjZXNzCisJICogdG8gVk0g aXMgaGVyZS4gRm9yIEdQVXMgdGhpcyBpc24ndCB0aGUgY2FzZSwgYmVjYXVzZSBDUFUKKwkgKiBk b2Vzbid0IHRvdWNoIHRoZSBtZW1vcnkuIEluc2VydCBwYWdlcyBub3csIHNvIGJvdGggQ1BVIGFu ZCBHUFUgYXJlCisJICogaGFwcHkuCisJICogRklYTUU6IGFzIHdlIGluc2VydCBhbGwgdGhlIHBh Z2VzIG5vdyB0aGVuIG5vIC5mYXVsdCBoYW5kbGVyIG11c3QKKwkgKiBiZSBjYWxsZWQsIHNvIGRv bid0IHByb3ZpZGUgb25lCisJICovCisJZm9yIChpID0gMDsgaSA8IHhlbl9vYmotPm51bV9wYWdl czsgaSsrKSB7CisJCWludCByZXQ7CisKKwkJcmV0ID0gdm1faW5zZXJ0X3BhZ2Uodm1hLCBhZGRy LCB4ZW5fb2JqLT5wYWdlc1tpXSk7CisJCWlmIChyZXQgPCAwKSB7CisJCQlEUk1fRVJST1IoIkZh aWxlZCB0byBpbnNlcnQgcGFnZXMgaW50byB2bWE6ICVkXG4iLCByZXQpOworCQkJcmV0dXJuIHJl dDsKKwkJfQorCisJCWFkZHIgKz0gUEFHRV9TSVpFOworCX0KKwlyZXR1cm4gMDsKK30KKworaW50 IHhlbl9kcm1fZnJvbnRfZ2VtX21tYXAoc3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCB2bV9hcmVh X3N0cnVjdCAqdm1hKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsKKwlzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmo7CisJaW50IHJldDsKKworCXJldCA9IGRybV9nZW1f bW1hcChmaWxwLCB2bWEpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJZ2VtX29i aiA9IHZtYS0+dm1fcHJpdmF0ZV9kYXRhOworCXhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1f b2JqKTsKKwlyZXR1cm4gZ2VtX21tYXBfb2JqKHhlbl9vYmosIHZtYSk7Cit9CisKK3ZvaWQgKnhl bl9kcm1fZnJvbnRfZ2VtX3ByaW1lX3ZtYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2Jq KQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdl bV9vYmopOworCisJaWYgKCF4ZW5fb2JqLT5wYWdlcykKKwkJcmV0dXJuIE5VTEw7CisKKwlyZXR1 cm4gdm1hcCh4ZW5fb2JqLT5wYWdlcywgeGVuX29iai0+bnVtX3BhZ2VzLAorCQkJVk1fTUFQLCBw Z3Byb3Rfd3JpdGVjb21iaW5lKFBBR0VfS0VSTkVMKSk7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9u dF9nZW1fcHJpbWVfdnVubWFwKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaiwKKwkJdm9p ZCAqdmFkZHIpCit7CisJdnVubWFwKHZhZGRyKTsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfZ2Vt X3ByaW1lX21tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqLAorCQlzdHJ1Y3Qgdm1f YXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmo7CisJ aW50IHJldDsKKworCXJldCA9IGRybV9nZW1fbW1hcF9vYmooZ2VtX29iaiwgZ2VtX29iai0+c2l6 ZSwgdm1hKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCXhlbl9vYmogPSB0b194 ZW5fZ2VtX29iaihnZW1fb2JqKTsKKwlyZXR1cm4gZ2VtX21tYXBfb2JqKHhlbl9vYmosIHZtYSk7 Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmgg Yi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi44YTM1YmM5OGMxYzEKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmgKQEAgLTAsMCArMSw0MSBA QAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisg KiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2 LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNo Y2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVm IF9fWEVOX0RSTV9GUk9OVF9HRU1fSAorI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfR0VNX0gKKwor I2luY2x1ZGUgPGRybS9kcm1QLmg+CisKK2ludCB4ZW5fZHJtX2Zyb250X2dlbV9kdW1iX2NyZWF0 ZShzdHJ1Y3QgZHJtX2ZpbGUgKmZpbHAsIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCXN0cnVj dCBkcm1fbW9kZV9jcmVhdGVfZHVtYiAqYXJncyk7CisKK3N0cnVjdCBkcm1fZ2VtX29iamVjdCAq eGVuX2RybV9mcm9udF9nZW1faW1wb3J0X3NnX3RhYmxlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs CisJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwgc3RydWN0IHNnX3RhYmxlICpz Z3QpOworCitzdHJ1Y3Qgc2dfdGFibGUgKnhlbl9kcm1fZnJvbnRfZ2VtX2dldF9zZ190YWJsZShz dHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopOworCitzdHJ1Y3QgcGFnZSAqKnhlbl9kcm1f ZnJvbnRfZ2VtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaik7CisKK3ZvaWQg eGVuX2RybV9mcm9udF9nZW1fZnJlZV9vYmplY3Qoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1f b2JqKTsKKworI2lmbmRlZiBDT05GSUdfRFJNX1hFTl9GUk9OVEVORF9DTUEKKworaW50IHhlbl9k cm1fZnJvbnRfZ2VtX21tYXAoc3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCB2bV9hcmVhX3N0cnVj dCAqdm1hKTsKKwordm9pZCAqeGVuX2RybV9mcm9udF9nZW1fcHJpbWVfdm1hcChzdHJ1Y3QgZHJt X2dlbV9vYmplY3QgKmdlbV9vYmopOworCit2b2lkIHhlbl9kcm1fZnJvbnRfZ2VtX3ByaW1lX3Z1 bm1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosCisJCXZvaWQgKnZhZGRyKTsKKwor aW50IHhlbl9kcm1fZnJvbnRfZ2VtX3ByaW1lX21tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpn ZW1fb2JqLAorCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisjZW5kaWYKKworI2VuZGlm IC8qIF9fWEVOX0RSTV9GUk9OVF9HRU1fSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9nZW1fY21hLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li43OTc4YmM0MmFmZDAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnRfZ2VtX2NtYS5jCkBAIC0wLDAgKzEsNzQgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJN IGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMu CisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1 c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVk ZSA8ZHJtL2RybV9nZW0uaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2NtYV9oZWxwZXIuaD4KKyNp bmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zy b250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9kcnYuaCIKKyNpbmNsdWRlICJ4ZW5fZHJt X2Zyb250X2dlbS5oIgorCitzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKnhlbl9kcm1fZnJvbnRfZ2Vt X2ltcG9ydF9zZ190YWJsZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQlzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2htZW50ICphdHRhY2gsIHN0cnVjdCBzZ190YWJsZSAqc2d0KQoreworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3Ry dWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqOworCXN0cnVjdCBkcm1fZ2VtX2NtYV9vYmplY3Qg KmNtYV9vYmo7CisJaW50IHJldDsKKworCWdlbV9vYmogPSBkcm1fZ2VtX2NtYV9wcmltZV9pbXBv cnRfc2dfdGFibGUoZGV2LCBhdHRhY2gsIHNndCk7CisJaWYgKElTX0VSUl9PUl9OVUxMKGdlbV9v YmopKQorCQlyZXR1cm4gZ2VtX29iajsKKworCWNtYV9vYmogPSB0b19kcm1fZ2VtX2NtYV9vYmoo Z2VtX29iaik7CisKKwlyZXQgPSB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fc2d0KAor CQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQl4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2ll KGdlbV9vYmopLAorCQkJMCwgMCwgMCwgZ2VtX29iai0+c2l6ZSwKKwkJCWRybV9nZW1fY21hX3By aW1lX2dldF9zZ190YWJsZShnZW1fb2JqKSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiBFUlJf UFRSKHJldCk7CisKKwlEUk1fREVCVUcoIkltcG9ydGVkIENNQSBidWZmZXIgb2Ygc2l6ZSAlenVc biIsIGdlbV9vYmotPnNpemUpOworCisJcmV0dXJuIGdlbV9vYmo7Cit9CisKK3N0cnVjdCBzZ190 YWJsZSAqeGVuX2RybV9mcm9udF9nZW1fZ2V0X3NnX3RhYmxlKHN0cnVjdCBkcm1fZ2VtX29iamVj dCAqZ2VtX29iaikKK3sKKwlyZXR1cm4gZHJtX2dlbV9jbWFfcHJpbWVfZ2V0X3NnX3RhYmxlKGdl bV9vYmopOworfQorCitpbnQgeGVuX2RybV9mcm9udF9nZW1fZHVtYl9jcmVhdGUoc3RydWN0IGRy bV9maWxlICpmaWxwLCBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCXN0cnVjdCBkcm1fbW9kZV9j cmVhdGVfZHVtYiAqYXJncykKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJt X2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCisJaWYgKGRybV9pbmZvLT5jZmctPmJlX2FsbG9j KSB7CisJCS8qIFRoaXMgdXNlLWNhc2UgaXMgbm90IHlldCBzdXBwb3J0ZWQgYW5kIHByb2JhYmx5 IHdvbid0IGJlICovCisJCURSTV9FUlJPUigiQmFja2VuZCBhbGxvY2F0ZWQgYnVmZmVycyBhbmQg Q01BIGhlbHBlcnMgYXJlIG5vdCBzdXBwb3J0ZWQgYXQgdGhlIHNhbWUgdGltZVxuIik7CisJCXJl dHVybiAtRUlOVkFMOworCX0KKworCXJldHVybiBkcm1fZ2VtX2NtYV9kdW1iX2NyZWF0ZShmaWxw LCBkZXYsIGFyZ3MpOworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZ2VtX2ZyZWVfb2JqZWN0KHN0 cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlkcm1fZ2VtX2NtYV9mcmVlX29iamVj dChnZW1fb2JqKTsKK30KKworc3RydWN0IHBhZ2UgKip4ZW5fZHJtX2Zyb250X2dlbV9nZXRfcGFn ZXMoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXJldHVybiBOVUxMOworfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5jIGIvZHJp dmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uN2FkNDUyODFiMzE4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJp dmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5jCkBAIC0wLDAgKzEsMzI0IEBACisv LyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4g cGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBF UEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28g PG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpbmNsdWRlICJ4ZW5f ZHJtX2Zyb250X2ttcy5oIgorCisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKyNpbmNsdWRlIDxkcm0v ZHJtX2F0b21pYy5oPgorI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgorI2luY2x1 ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbS5oPgorI2lu Y2x1ZGUgPGRybS9kcm1fZ2VtX2ZyYW1lYnVmZmVyX2hlbHBlci5oPgorCisjaW5jbHVkZSAieGVu X2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfY29ubi5oIgorI2luY2x1ZGUg Inhlbl9kcm1fZnJvbnRfZHJ2LmgiCisKKy8qCisgKiBUaW1lb3V0IGluIG1zIHRvIHdhaXQgZm9y IGZyYW1lIGRvbmUgZXZlbnQgZnJvbSB0aGUgYmFja2VuZDoKKyAqIG11c3QgYmUgYSBiaXQgbW9y ZSB0aGFuIElPIHRpbWUtb3V0CisgKi8KKyNkZWZpbmUgRlJBTUVfRE9ORV9UT19NUwkoWEVOX0RS TV9GUk9OVF9XQUlUX0JBQ0tfTVMgKyAxMDApCisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2RybV9mcm9u dF9kcm1fcGlwZWxpbmUgKgordG9feGVuX2RybV9waXBlbGluZShzdHJ1Y3QgZHJtX3NpbXBsZV9k aXNwbGF5X3BpcGUgKnBpcGUpCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihwaXBlLCBzdHJ1Y3Qg eGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUsIHBpcGUpOworfQorCitzdGF0aWMgdm9pZCBmYl9k ZXN0cm95KHN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2RybV9pbmZvICpkcm1faW5mbyA9IGZiLT5kZXYtPmRldl9wcml2YXRlOworCisJeGVuX2Ry bV9mcm9udF9mYl9kZXRhY2goZHJtX2luZm8tPmZyb250X2luZm8sCisJCQl4ZW5fZHJtX2Zyb250 X2ZiX3RvX2Nvb2tpZShmYikpOworCWRybV9nZW1fZmJfZGVzdHJveShmYik7Cit9CisKK3N0YXRp YyBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyX2Z1bmNzIGZiX2Z1bmNzID0geworCS5kZXN0cm95ID0g ZmJfZGVzdHJveSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYl9jcmVh dGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IGRybV9maWxlICpmaWxwLCBjb25z dCBzdHJ1Y3QgZHJtX21vZGVfZmJfY21kMiAqbW9kZV9jbWQpCit7CisJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdGF0aWMgc3Ry dWN0IGRybV9mcmFtZWJ1ZmZlciAqZmI7CisJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2Jq OworCWludCByZXQ7CisKKwlmYiA9IGRybV9nZW1fZmJfY3JlYXRlX3dpdGhfZnVuY3MoZGV2LCBm aWxwLCBtb2RlX2NtZCwgJmZiX2Z1bmNzKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoZmIpKQorCQly ZXR1cm4gZmI7CisKKwlnZW1fb2JqID0gZHJtX2dlbV9vYmplY3RfbG9va3VwKGZpbHAsIG1vZGVf Y21kLT5oYW5kbGVzWzBdKTsKKwlpZiAoIWdlbV9vYmopIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQg dG8gbG9va3VwIEdFTSBvYmplY3RcbiIpOworCQlyZXQgPSAtRU5PRU5UOworCQlnb3RvIGZhaWw7 CisJfQorCisJZHJtX2dlbV9vYmplY3RfdW5yZWZlcmVuY2VfdW5sb2NrZWQoZ2VtX29iaik7CisK KwlyZXQgPSB4ZW5fZHJtX2Zyb250X2ZiX2F0dGFjaCgKKwkJCWRybV9pbmZvLT5mcm9udF9pbmZv LAorCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShnZW1fb2JqKSwKKwkJCXhlbl9kcm1f ZnJvbnRfZmJfdG9fY29va2llKGZiKSwKKwkJCWZiLT53aWR0aCwgZmItPmhlaWdodCwgZmItPmZv cm1hdC0+Zm9ybWF0KTsKKwlpZiAocmV0IDwgMCkgeworCQlEUk1fRVJST1IoIkJhY2sgZmFpbGVk IHRvIGF0dGFjaCBGQiAlcDogJWRcbiIsIGZiLCByZXQpOworCQlnb3RvIGZhaWw7CisJfQorCisJ cmV0dXJuIGZiOworCitmYWlsOgorCWRybV9nZW1fZmJfZGVzdHJveShmYik7CisJcmV0dXJuIEVS Ul9QVFIocmV0KTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fbW9kZV9jb25maWdfZnVu Y3MgbW9kZV9jb25maWdfZnVuY3MgPSB7CisJLmZiX2NyZWF0ZSA9IGZiX2NyZWF0ZSwKKwkuYXRv bWljX2NoZWNrID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2ssCisJLmF0b21pY19jb21taXQgPSBk cm1fYXRvbWljX2hlbHBlcl9jb21taXQsCit9OworCit2b2lkIHhlbl9kcm1fZnJvbnRfa21zX3Nl bmRfcGVuZGluZ19ldmVudCgKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpw aXBlbGluZSkKK3sKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmcGlwZWxpbmUtPnBpcGUuY3J0 YzsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ZGV2OworCXVuc2lnbmVkIGxvbmcg ZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5ldmVudF9sb2NrLCBmbGFncyk7CisJ aWYgKHBpcGVsaW5lLT5wZW5kaW5nX2V2ZW50KQorCQlkcm1fY3J0Y19zZW5kX3ZibGFua19ldmVu dChjcnRjLCBwaXBlbGluZS0+cGVuZGluZ19ldmVudCk7CisJcGlwZWxpbmUtPnBlbmRpbmdfZXZl bnQgPSBOVUxMOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+ZXZlbnRfbG9jaywgZmxh Z3MpOworfQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X2VuYWJsZShzdHJ1Y3QgZHJtX3NpbXBsZV9k aXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSkK K3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRv X3hlbl9kcm1fcGlwZWxpbmUocGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpjcnRjID0gJnBpcGUt PmNydGM7CisJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwaXBlLT5wbGFuZS5zdGF0ZS0+ ZmI7CisJaW50IHJldDsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQocGlwZWxpbmUs CisJCQljcnRjLT54LCBjcnRjLT55LCBmYi0+d2lkdGgsIGZiLT5oZWlnaHQsCisJCQlmYi0+Zm9y bWF0LT5jcHBbMF0gKiA4LAorCQkJeGVuX2RybV9mcm9udF9mYl90b19jb29raWUoZmIpKTsKKwor CWlmIChyZXQpIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gZW5hYmxlIGRpc3BsYXk6ICVkXG4i LCByZXQpOworCQlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSBmYWxzZTsKKwl9Cit9CisKK3N0 YXRpYyB2b2lkIGRpc3BsYXlfZGlzYWJsZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUg KnBpcGUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9 CisJCQl0b194ZW5fZHJtX3BpcGVsaW5lKHBpcGUpOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2Ry bV9pbmZvICpkcm1faW5mbyA9IHBpcGVsaW5lLT5kcm1faW5mbzsKKwl1bnNpZ25lZCBsb25nIGZs YWdzOworCWludCByZXQ7CisKKwlyZXQgPSB4ZW5fZHJtX2Zyb250X21vZGVfc2V0KHBpcGVsaW5l LCAwLCAwLCAwLCAwLCAwLAorCQkJeGVuX2RybV9mcm9udF9mYl90b19jb29raWUoTlVMTCkpOwor CWlmIChyZXQpCisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGRpc2FibGUgZGlzcGxheTogJWRcbiIs IHJldCk7CisKKwlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSB0cnVlOworCisJc3Bpbl9sb2Nr X2lycXNhdmUoJmRybV9pbmZvLT5mcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcGlwZWxp bmUtPnBmbGlwX3RpbWVvdXQgPSAwOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRybV9pbmZv LT5mcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwkvKiByZWxlYXNlIHN0YWxsZWQgZXZl bnQgaWYgYW55ICovCisJeGVuX2RybV9mcm9udF9rbXNfc2VuZF9wZW5kaW5nX2V2ZW50KHBpcGVs aW5lKTsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X2ttc19vbl9mcmFtZV9kb25lKAorCQlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lLAorCQl1aW50NjRfdCBmYl9j b29raWUpCit7CisJLyoKKwkgKiBUaGlzIGFscmVhZHkgcnVucyBpbiBpbnRlcnJ1cHQgY29udGV4 dCwgZS5nLiB1bmRlcgorCSAqIGRybV9pbmZvLT5mcm9udF9pbmZvLT5pb19sb2NrCisJICovCisJ cGlwZWxpbmUtPnBmbGlwX3RpbWVvdXQgPSAwOworCisJeGVuX2RybV9mcm9udF9rbXNfc2VuZF9w ZW5kaW5nX2V2ZW50KHBpcGVsaW5lKTsKK30KKworc3RhdGljIGJvb2wgZGlzcGxheV9zZW5kX3Bh Z2VfZmxpcChzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBk cm1fcGxhbmVfc3RhdGUgKm9sZF9wbGFuZV9zdGF0ZSkKK3sKKwlzdHJ1Y3QgZHJtX3BsYW5lX3N0 YXRlICpwbGFuZV9zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X25ld19wbGFuZV9zdGF0ZSgKKwkJCW9s ZF9wbGFuZV9zdGF0ZS0+c3RhdGUsICZwaXBlLT5wbGFuZSk7CisKKwkvKgorCSAqIElmIG9sZF9w bGFuZV9zdGF0ZS0+ZmIgaXMgTlVMTCBhbmQgcGxhbmVfc3RhdGUtPmZiIGlzIG5vdCwKKwkgKiB0 aGVuIHRoaXMgaXMgYW4gYXRvbWljIGNvbW1pdCB3aGljaCB3aWxsIGVuYWJsZSBkaXNwbGF5Lgor CSAqIElmIG9sZF9wbGFuZV9zdGF0ZS0+ZmIgaXMgbm90IE5VTEwgYW5kIHBsYW5lX3N0YXRlLT5m YiBpcywKKwkgKiB0aGVuIHRoaXMgaXMgYW4gYXRvbWljIGNvbW1pdCB3aGljaCB3aWxsIGRpc2Fi bGUgZGlzcGxheS4KKwkgKiBJZ25vcmUgdGhlc2UgYW5kIGRvIG5vdCBzZW5kIHBhZ2UgZmxpcCBh cyB0aGlzIGZyYW1lYnVmZmVyIHdpbGwgYmUKKwkgKiBzZW50IHRvIHRoZSBiYWNrZW5kIGFzIGEg cGFydCBvZiBkaXNwbGF5X3NldF9jb25maWcgY2FsbC4KKwkgKi8KKwlpZiAob2xkX3BsYW5lX3N0 YXRlLT5mYiAmJiBwbGFuZV9zdGF0ZS0+ZmIpIHsKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJt X3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQkJdG9feGVuX2RybV9waXBlbGluZShwaXBlKTsKKwkJ c3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gcGlwZWxpbmUtPmRybV9p bmZvOworCQl1bnNpZ25lZCBsb25nIGZsYWdzOworCQlpbnQgcmV0OworCisJCXNwaW5fbG9ja19p cnFzYXZlKCZkcm1faW5mby0+ZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCQlwaXBlbGlu ZS0+cGZsaXBfdGltZW91dCA9IGppZmZpZXMgKworCQkJCW1zZWNzX3RvX2ppZmZpZXMoRlJBTUVf RE9ORV9UT19NUyk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRybV9pbmZvLT5mcm9udF9p bmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwkJcmV0ID0geGVuX2RybV9mcm9udF9wYWdlX2ZsaXAo ZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJcGlwZWxpbmUtPmluZGV4LAorCQkJCXhlbl9kcm1f ZnJvbnRfZmJfdG9fY29va2llKHBsYW5lX3N0YXRlLT5mYikpOworCQlpZiAocmV0KSB7CisJCQlE Uk1fRVJST1IoIkZhaWxlZCB0byBzZW5kIHBhZ2UgZmxpcCByZXF1ZXN0IHRvIGJhY2tlbmQ6ICVk XG4iLCByZXQpOworCisJCQlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSBmYWxzZTsKKwkJCS8q CisJCQkgKiBSZXBvcnQgdGhlIGZsaXAgbm90IGhhbmRsZWQsIHNvIHBlbmRpbmcgZXZlbnQgaXMK KwkJCSAqIHNlbnQsIHVuYmxvY2tpbmcgdXNlci1zcGFjZS4KKwkJCSAqLworCQkJcmV0dXJuIGZh bHNlOworCQl9CisJCS8qCisJCSAqIFNpZ25hbCB0aGF0IHBhZ2UgZmxpcCB3YXMgaGFuZGxlZCwg cGVuZGluZyBldmVudCB3aWxsIGJlIHNlbnQKKwkJICogb24gZnJhbWUgZG9uZSBldmVudCBmcm9t IHRoZSBiYWNrZW5kLgorCQkgKi8KKwkJcmV0dXJuIHRydWU7CisJfQorCisJcmV0dXJuIGZhbHNl OworfQorCitzdGF0aWMgaW50IGRpc3BsYXlfcHJlcGFyZV9mYihzdHJ1Y3QgZHJtX3NpbXBsZV9k aXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRl KQoreworCXJldHVybiBkcm1fZ2VtX2ZiX3ByZXBhcmVfZmIoJnBpcGUtPnBsYW5lLCBwbGFuZV9z dGF0ZSk7Cit9CisKK3N0YXRpYyBpbnQgZGlzcGxheV9jaGVjayhzdHJ1Y3QgZHJtX3NpbXBsZV9k aXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRl LAorCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUpCit7CisJc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQl0b194ZW5fZHJtX3BpcGVsaW5l KHBpcGUpOworCisJcmV0dXJuIHBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA/IDAgOiAtRUlOVkFM OworfQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X3VwZGF0ZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNw bGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9wbGFuZV9zdGF0 ZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJ CXRvX3hlbl9kcm1fcGlwZWxpbmUocGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpjcnRjID0gJnBp cGUtPmNydGM7CisJc3RydWN0IGRybV9wZW5kaW5nX3ZibGFua19ldmVudCAqZXZlbnQ7CisKKwll dmVudCA9IGNydGMtPnN0YXRlLT5ldmVudDsKKwlpZiAoZXZlbnQpIHsKKwkJc3RydWN0IGRybV9k ZXZpY2UgKmRldiA9IGNydGMtPmRldjsKKwkJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCQlXQVJO X09OKHBpcGVsaW5lLT5wZW5kaW5nX2V2ZW50KTsKKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2 LT5ldmVudF9sb2NrLCBmbGFncyk7CisJCWNydGMtPnN0YXRlLT5ldmVudCA9IE5VTEw7CisKKwkJ cGlwZWxpbmUtPnBlbmRpbmdfZXZlbnQgPSBldmVudDsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmZGV2LT5ldmVudF9sb2NrLCBmbGFncyk7CisKKwl9CisJLyoKKwkgKiBTZW5kIHBhZ2UgZmxp cCByZXF1ZXN0IHRvIHRoZSBiYWNrZW5kICphZnRlciogd2UgaGF2ZSBldmVudCBjYWNoZWQKKwkg KiBhYm92ZSwgc28gb24gcGFnZSBmbGlwIGRvbmUgZXZlbnQgZnJvbSB0aGUgYmFja2VuZCB3ZSBj YW4KKwkgKiBkZWxpdmVyIGl0IGFuZCB0aGVyZSBpcyBubyByYWNlIGNvbmRpdGlvbiBiZXR3ZWVu IHRoaXMgY29kZSBhbmQKKwkgKiBldmVudCBmcm9tIHRoZSBiYWNrZW5kLgorCSAqIElmIHRoaXMg aXMgbm90IGEgcGFnZSBmbGlwLCBlLmcuIG5vIGZsaXAgZG9uZSBldmVudCBmcm9tIHRoZSBiYWNr ZW5kCisJICogaXMgZXhwZWN0ZWQsIHRoZW4gc2VuZCBub3cuCisJICovCisJaWYgKCFkaXNwbGF5 X3NlbmRfcGFnZV9mbGlwKHBpcGUsIG9sZF9wbGFuZV9zdGF0ZSkpCisJCXhlbl9kcm1fZnJvbnRf a21zX3NlbmRfcGVuZGluZ19ldmVudChwaXBlbGluZSk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MgZGlzcGxheV9mdW5jcyA9IHsKKwkuZW5h YmxlID0gZGlzcGxheV9lbmFibGUsCisJLmRpc2FibGUgPSBkaXNwbGF5X2Rpc2FibGUsCisJLmNo ZWNrID0gZGlzcGxheV9jaGVjaywKKwkucHJlcGFyZV9mYiA9IGRpc3BsYXlfcHJlcGFyZV9mYiwK KwkudXBkYXRlID0gZGlzcGxheV91cGRhdGUsCit9OworCitzdGF0aWMgaW50IGRpc3BsYXlfcGlw ZV9pbml0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbywKKwkJaW50IGlu ZGV4LCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmdfY29ubmVjdG9yICpjZmcsCisJCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUpCit7CisJc3RydWN0IGRybV9kZXZp Y2UgKmRldiA9IGRybV9pbmZvLT5kcm1fZGV2OworCWNvbnN0IHVpbnQzMl90ICpmb3JtYXRzOwor CWludCBmb3JtYXRfY291bnQ7CisJaW50IHJldDsKKworCXBpcGVsaW5lLT5kcm1faW5mbyA9IGRy bV9pbmZvOworCXBpcGVsaW5lLT5pbmRleCA9IGluZGV4OworCXBpcGVsaW5lLT5oZWlnaHQgPSBj ZmctPmhlaWdodDsKKwlwaXBlbGluZS0+d2lkdGggPSBjZmctPndpZHRoOworCisJcmV0ID0geGVu X2RybV9mcm9udF9jb25uX2luaXQoZHJtX2luZm8sICZwaXBlbGluZS0+Y29ubik7CisJaWYgKHJl dCkKKwkJcmV0dXJuIHJldDsKKworCWZvcm1hdHMgPSB4ZW5fZHJtX2Zyb250X2Nvbm5fZ2V0X2Zv cm1hdHMoJmZvcm1hdF9jb3VudCk7CisKKwlyZXR1cm4gZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVf aW5pdChkZXYsICZwaXBlbGluZS0+cGlwZSwKKwkJCSZkaXNwbGF5X2Z1bmNzLCBmb3JtYXRzLCBm b3JtYXRfY291bnQsCisJCQlOVUxMLCAmcGlwZWxpbmUtPmNvbm4pOworfQorCitpbnQgeGVuX2Ry bV9mcm9udF9rbXNfaW5pdChzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8p Cit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGRybV9pbmZvLT5kcm1fZGV2OworCWludCBp LCByZXQ7CisKKwlkcm1fbW9kZV9jb25maWdfaW5pdChkZXYpOworCisJZGV2LT5tb2RlX2NvbmZp Zy5taW5fd2lkdGggPSAwOworCWRldi0+bW9kZV9jb25maWcubWluX2hlaWdodCA9IDA7CisJZGV2 LT5tb2RlX2NvbmZpZy5tYXhfd2lkdGggPSA0MDk1OworCWRldi0+bW9kZV9jb25maWcubWF4X2hl aWdodCA9IDIwNDc7CisJZGV2LT5tb2RlX2NvbmZpZy5mdW5jcyA9ICZtb2RlX2NvbmZpZ19mdW5j czsKKworCWZvciAoaSA9IDA7IGkgPCBkcm1faW5mby0+Y2ZnLT5udW1fY29ubmVjdG9yczsgaSsr KSB7CisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZ19jb25uZWN0b3IgKmNmZyA9CisJCQkJJmRy bV9pbmZvLT5jZmctPmNvbm5lY3RvcnNbaV07CisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9w aXBlbGluZSAqcGlwZWxpbmUgPQorCQkJCSZkcm1faW5mby0+cGlwZWxpbmVbaV07CisKKwkJcmV0 ID0gZGlzcGxheV9waXBlX2luaXQoZHJtX2luZm8sIGksIGNmZywgcGlwZWxpbmUpOworCQlpZiAo cmV0KSB7CisJCQlkcm1fbW9kZV9jb25maWdfY2xlYW51cChkZXYpOworCQkJcmV0dXJuIHJldDsK KwkJfQorCX0KKworCWRybV9tb2RlX2NvbmZpZ19yZXNldChkZXYpOworCWRybV9rbXNfaGVscGVy X3BvbGxfaW5pdChkZXYpOworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJt X2Zyb250X2ttcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOGRm MjNlNzk0MmFjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJt X2Zyb250X2ttcy5oCkBAIC0wLDAgKzEsMjUgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmlj ZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgor ICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVu a29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1fRlJPTlRfS01TX0hfCisjZGVm aW5lIF9fWEVOX0RSTV9GUk9OVF9LTVNfSF8KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfZHJ2 LmgiCisKK2ludCB4ZW5fZHJtX2Zyb250X2ttc19pbml0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2Ry bV9pbmZvICpkcm1faW5mbyk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9rbXNfb25fZnJhbWVfZG9u ZSgKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSwKKwkJdWlu dDY0X3QgZmJfY29va2llKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X2ttc19zZW5kX3BlbmRpbmdf ZXZlbnQoCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUpOwor CisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX0tNU19IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfc2hidWYuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLjBmZGUyZDhmNzcwNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5jCkBAIC0wLDAgKzEsNDMyIEBACisvLyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFs IERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMg SW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9h bmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorCisj aWYgZGVmaW5lZChDT05GSUdfWDg2KQorI2luY2x1ZGUgPGRybS9kcm1fY2FjaGUuaD4KKyNlbmRp ZgorI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvbW0uaD4KKworI2lu Y2x1ZGUgPGFzbS94ZW4vaHlwZXJ2aXNvci5oPgorI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+Cisj aW5jbHVkZSA8eGVuL3hlbi5oPgorI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KKyNpbmNsdWRlIDx4 ZW4vaW50ZXJmYWNlL2lvL3JpbmcuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2lvL2Rpc3Bs aWYuaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zy b250X3NoYnVmLmgiCisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX29wcyB7CisJLyoKKwkg KiBDYWxjdWxhdGUgbnVtYmVyIG9mIGdyZWZzIHJlcXVpcmVkIHRvIGhhbmRsZSB0aGlzIGJ1ZmZl ciwKKwkgKiBlLmcuIGlmIGdyZWZzIGFyZSByZXF1aXJlZCBmb3IgcGFnZSBkaXJlY3Rvcnkgb25s eSBvciB0aGUgYnVmZmVyCisJICogcGFnZXMgYXMgd2VsbC4KKwkgKi8KKwl2b2lkICgqY2FsY19u dW1fZ3JlZnMpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCS8qIEZpbGwgcGFn ZSBkaXJlY3RvcnkgYWNjb3JkaW5nIHRvIHBhcmEtdmlydHVhbCBkaXNwbGF5IHByb3RvY29sLiAq LworCXZvaWQgKCpmaWxsX3BhZ2VfZGlyKShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVm KTsKKwkvKiBDbGFpbSBncmFudCByZWZlcmVuY2VzIGZvciB0aGUgcGFnZXMgb2YgdGhlIGJ1ZmZl ci4gKi8KKwlpbnQgKCpncmFudF9yZWZzX2Zvcl9idWZmZXIpKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpidWYsCisJCQlncmFudF9yZWZfdCAqcHJpdl9ncmVmX2hlYWQsIGludCBncmVmX2lk eCk7CisJLyogTWFwIGdyYW50IHJlZmVyZW5jZXMgb2YgdGhlIGJ1ZmZlci4gKi8KKwlpbnQgKCpt YXApKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCS8qIFVubWFwIGdyYW50IHJl ZmVyZW5jZXMgb2YgdGhlIGJ1ZmZlci4gKi8KKwlpbnQgKCp1bm1hcCkoc3RydWN0IHhlbl9kcm1f ZnJvbnRfc2hidWYgKmJ1Zik7Cit9OworCitncmFudF9yZWZfdCB4ZW5fZHJtX2Zyb250X3NoYnVm X2dldF9kaXJfc3RhcnQoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwlpZiAo IWJ1Zi0+Z3JlZnMpCisJCXJldHVybiBHUkFOVF9JTlZBTElEX1JFRjsKKworCXJldHVybiBidWYt PmdyZWZzWzBdOworfQorCitpbnQgeGVuX2RybV9mcm9udF9zaGJ1Zl9tYXAoc3RydWN0IHhlbl9k cm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwlpZiAoYnVmLT5vcHMtPm1hcCkKKwkJcmV0dXJuIGJ1 Zi0+b3BzLT5tYXAoYnVmKTsKKworCS8qIG5vIG5lZWQgdG8gbWFwIG93biBncmFudCByZWZlcmVu Y2VzICovCisJcmV0dXJuIDA7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X3NoYnVmX3VubWFwKHN0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+b3BzLT51bm1hcCkK KwkJcmV0dXJuIGJ1Zi0+b3BzLT51bm1hcChidWYpOworCisJLyogbm8gbmVlZCB0byB1bm1hcCBv d24gZ3JhbnQgcmVmZXJlbmNlcyAqLworCXJldHVybiAwOworfQorCit2b2lkIHhlbl9kcm1fZnJv bnRfc2hidWZfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKyNpZiBk ZWZpbmVkKENPTkZJR19YODYpCisJZHJtX2NsZmx1c2hfcGFnZXMoYnVmLT5wYWdlcywgYnVmLT5u dW1fcGFnZXMpOworI2VuZGlmCit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKHN0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+Z3JlZnMpIHsKKwkJ aW50IGk7CisKKwkJZm9yIChpID0gMDsgaSA8IGJ1Zi0+bnVtX2dyZWZzOyBpKyspCisJCQlpZiAo YnVmLT5ncmVmc1tpXSAhPSBHUkFOVF9JTlZBTElEX1JFRikKKwkJCQlnbnR0YWJfZW5kX2ZvcmVp Z25fYWNjZXNzKGJ1Zi0+Z3JlZnNbaV0sCisJCQkJCTAsIDBVTCk7CisJfQorCWtmcmVlKGJ1Zi0+ Z3JlZnMpOworCWtmcmVlKGJ1Zi0+ZGlyZWN0b3J5KTsKKwlpZiAoYnVmLT5zZ3QpIHsKKwkJc2df ZnJlZV90YWJsZShidWYtPnNndCk7CisJCWt2ZnJlZShidWYtPnBhZ2VzKTsKKwl9CisJa2ZyZWUo YnVmKTsKK30KKworLyoKKyAqIG51bWJlciBvZiBncmVmcyBhIHBhZ2UgY2FuIGhvbGQgd2l0aCBy ZXNwZWN0IHRvIHRoZQorICogc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5IGhlYWRlcgor ICovCisjZGVmaW5lIFhFTl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFICgoUEFHRV9TSVpFIC0gXAor CW9mZnNldG9mKHN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSwgZ3JlZikpIC8gXAorCXNp emVvZihncmFudF9yZWZfdCkpCisKK3N0YXRpYyBpbnQgZ2V0X251bV9wYWdlc19kaXIoc3RydWN0 IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwkvKiBudW1iZXIgb2YgcGFnZXMgdGhlIHBh Z2UgZGlyZWN0b3J5IGNvbnN1bWVzIGl0c2VsZiAqLworCXJldHVybiBESVZfUk9VTkRfVVAoYnVm LT5udW1fcGFnZXMsIFhFTl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFKTsKK30KKworc3RhdGljIHZv aWQgYmFja2VuZF9jYWxjX251bV9ncmVmcyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVm KQoreworCS8qIG9ubHkgZm9yIHBhZ2VzIHRoZSBwYWdlIGRpcmVjdG9yeSBjb25zdW1lcyBpdHNl bGYgKi8KKwlidWYtPm51bV9ncmVmcyA9IGdldF9udW1fcGFnZXNfZGlyKGJ1Zik7Cit9CisKK3N0 YXRpYyB2b2lkIGd1ZXN0X2NhbGNfbnVtX2dyZWZzKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVm ICpidWYpCit7CisJLyoKKwkgKiBudW1iZXIgb2YgcGFnZXMgdGhlIHBhZ2UgZGlyZWN0b3J5IGNv bnN1bWVzIGl0c2VsZgorCSAqIHBsdXMgZ3JlZnMgZm9yIHRoZSBidWZmZXIgcGFnZXMKKwkgKi8K KwlidWYtPm51bV9ncmVmcyA9IGdldF9udW1fcGFnZXNfZGlyKGJ1ZikgKyBidWYtPm51bV9wYWdl czsKK30KKworI2RlZmluZSB4ZW5fcGFnZV90b192YWRkcihwYWdlKSBcCisJCSgocGh5c19hZGRy X3QpcGZuX3RvX2thZGRyKHBhZ2VfdG9feGVuX3BmbihwYWdlKSkpCisKK3N0YXRpYyBpbnQgYmFj a2VuZF91bm1hcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCXN0cnVjdCBn bnR0YWJfdW5tYXBfZ3JhbnRfcmVmICp1bm1hcF9vcHM7CisJaW50IGksIHJldDsKKworCWlmICgh YnVmLT5wYWdlcyB8fCAhYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzIHx8ICFidWYtPmdyZWZzKQor CQlyZXR1cm4gMDsKKworCXVubWFwX29wcyA9IGtjYWxsb2MoYnVmLT5udW1fcGFnZXMsIHNpemVv ZigqdW5tYXBfb3BzKSwKKwkJR0ZQX0tFUk5FTCk7CisJaWYgKCF1bm1hcF9vcHMpIHsKKwkJRFJN X0VSUk9SKCJGYWlsZWQgdG8gZ2V0IG1lbW9yeSB3aGlsZSB1bm1hcHBpbmdcbiIpOworCQlyZXR1 cm4gLUVOT01FTTsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fcGFnZXM7IGkrKykg eworCQlwaHlzX2FkZHJfdCBhZGRyOworCisJCWFkZHIgPSB4ZW5fcGFnZV90b192YWRkcihidWYt PnBhZ2VzW2ldKTsKKwkJZ250dGFiX3NldF91bm1hcF9vcCgmdW5tYXBfb3BzW2ldLCBhZGRyLCBH TlRNQVBfaG9zdF9tYXAsCisJCQkJYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzW2ldKTsKKwl9CisK KwlyZXQgPSBnbnR0YWJfdW5tYXBfcmVmcyh1bm1hcF9vcHMsIE5VTEwsIGJ1Zi0+cGFnZXMsCisJ CQlidWYtPm51bV9wYWdlcyk7CisKKwlmb3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fcGFnZXM7IGkr KykgeworCQlpZiAodW5saWtlbHkodW5tYXBfb3BzW2ldLnN0YXR1cyAhPSBHTlRTVF9va2F5KSkK KwkJCURSTV9FUlJPUigiRmFpbGVkIHRvIHVubWFwIHBhZ2UgJWQ6ICVkXG4iLAorCQkJCQlpLCB1 bm1hcF9vcHNbaV0uc3RhdHVzKTsKKwl9CisKKwlpZiAocmV0KQorCQlEUk1fRVJST1IoIkZhaWxl ZCB0byB1bm1hcCBncmFudCByZWZlcmVuY2VzLCByZXQgJWQiLCByZXQpOworCisJa2ZyZWUodW5t YXBfb3BzKTsKKwlrZnJlZShidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMpOworCWJ1Zi0+YmFja2Vu ZF9tYXBfaGFuZGxlcyA9IE5VTEw7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBiYWNr ZW5kX21hcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCXN0cnVjdCBnbnR0 YWJfbWFwX2dyYW50X3JlZiAqbWFwX29wcyA9IE5VTEw7CisJdW5zaWduZWQgY2hhciAqcHRyOwor CWludCByZXQsIGN1cl9ncmVmLCBjdXJfZGlyX3BhZ2UsIGN1cl9wYWdlLCBncmVmc19sZWZ0Owor CisJbWFwX29wcyA9IGtjYWxsb2MoYnVmLT5udW1fcGFnZXMsIHNpemVvZigqbWFwX29wcyksIEdG UF9LRVJORUwpOworCWlmICghbWFwX29wcykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlidWYtPmJh Y2tlbmRfbWFwX2hhbmRsZXMgPSBrY2FsbG9jKGJ1Zi0+bnVtX3BhZ2VzLAorCQkJc2l6ZW9mKCpi dWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJ1Zi0+YmFja2Vu ZF9tYXBfaGFuZGxlcykgeworCQlrZnJlZShtYXBfb3BzKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJ fQorCisJLyoKKwkgKiByZWFkIHBhZ2UgZGlyZWN0b3J5IHRvIGdldCBncmVmcyBmcm9tIHRoZSBi YWNrZW5kOiBmb3IgZXh0ZXJuYWwKKwkgKiBidWZmZXIgd2Ugb25seSBhbGxvY2F0ZSBidWYtPmdy ZWZzIGZvciB0aGUgcGFnZSBkaXJlY3RvcnksCisJICogc28gYnVmLT5udW1fZ3JlZnMgaGFzIG51 bWJlciBvZiBwYWdlcyBpbiB0aGUgcGFnZSBkaXJlY3RvcnkgaXRzZWxmCisJICovCisJcHRyID0g YnVmLT5kaXJlY3Rvcnk7CisJZ3JlZnNfbGVmdCA9IGJ1Zi0+bnVtX3BhZ2VzOworCWN1cl9wYWdl ID0gMDsKKwlmb3IgKGN1cl9kaXJfcGFnZSA9IDA7IGN1cl9kaXJfcGFnZSA8IGJ1Zi0+bnVtX2dy ZWZzOyBjdXJfZGlyX3BhZ2UrKykgeworCQlzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3Rvcnkg KnBhZ2VfZGlyID0KKwkJCQkoc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICopcHRyOwor CQlpbnQgdG9fY29weSA9IFhFTl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFOworCisJCWlmICh0b19j b3B5ID4gZ3JlZnNfbGVmdCkKKwkJCXRvX2NvcHkgPSBncmVmc19sZWZ0OworCisJCWZvciAoY3Vy X2dyZWYgPSAwOyBjdXJfZ3JlZiA8IHRvX2NvcHk7IGN1cl9ncmVmKyspIHsKKwkJCXBoeXNfYWRk cl90IGFkZHI7CisKKwkJCWFkZHIgPSB4ZW5fcGFnZV90b192YWRkcihidWYtPnBhZ2VzW2N1cl9w YWdlXSk7CisJCQlnbnR0YWJfc2V0X21hcF9vcCgmbWFwX29wc1tjdXJfcGFnZV0sIGFkZHIsCisJ CQkJCUdOVE1BUF9ob3N0X21hcCwKKwkJCQkJcGFnZV9kaXItPmdyZWZbY3VyX2dyZWZdLAorCQkJ CQlidWYtPnhiX2Rldi0+b3RoZXJlbmRfaWQpOworCQkJY3VyX3BhZ2UrKzsKKwkJfQorCisJCWdy ZWZzX2xlZnQgLT0gdG9fY29weTsKKwkJcHRyICs9IFBBR0VfU0laRTsKKwl9CisJcmV0ID0gZ250 dGFiX21hcF9yZWZzKG1hcF9vcHMsIE5VTEwsIGJ1Zi0+cGFnZXMsIGJ1Zi0+bnVtX3BhZ2VzKTsK KworCS8qIHNhdmUgaGFuZGxlcyBldmVuIGlmIGVycm9yLCBzbyB3ZSBjYW4gdW5tYXAgKi8KKwlm b3IgKGN1cl9wYWdlID0gMDsgY3VyX3BhZ2UgPCBidWYtPm51bV9wYWdlczsgY3VyX3BhZ2UrKykg eworCQlidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXNbY3VyX3BhZ2VdID0gbWFwX29wc1tjdXJfcGFn ZV0uaGFuZGxlOworCQlpZiAodW5saWtlbHkobWFwX29wc1tjdXJfcGFnZV0uc3RhdHVzICE9IEdO VFNUX29rYXkpKQorCQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gbWFwIHBhZ2UgJWQ6ICVkXG4iLAor CQkJCQljdXJfcGFnZSwgbWFwX29wc1tjdXJfcGFnZV0uc3RhdHVzKTsKKwl9CisKKwlpZiAocmV0 KSB7CisJCURSTV9FUlJPUigiRmFpbGVkIHRvIG1hcCBncmFudCByZWZlcmVuY2VzLCByZXQgJWQi LCByZXQpOworCQliYWNrZW5kX3VubWFwKGJ1Zik7CisJfQorCisJa2ZyZWUobWFwX29wcyk7CisJ cmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgYmFja2VuZF9maWxsX3BhZ2VfZGlyKHN0cnVj dCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGly ZWN0b3J5ICpwYWdlX2RpcjsKKwl1bnNpZ25lZCBjaGFyICpwdHI7CisJaW50IGksIG51bV9wYWdl c19kaXI7CisKKwlwdHIgPSBidWYtPmRpcmVjdG9yeTsKKwludW1fcGFnZXNfZGlyID0gZ2V0X251 bV9wYWdlc19kaXIoYnVmKTsKKworCS8qIGZpbGwgb25seSBncmVmcyBmb3IgdGhlIHBhZ2UgZGly ZWN0b3J5IGl0c2VsZiAqLworCWZvciAoaSA9IDA7IGkgPCBudW1fcGFnZXNfZGlyIC0gMTsgaSsr KSB7CisJCXBhZ2VfZGlyID0gKHN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqKXB0cjsK KworCQlwYWdlX2Rpci0+Z3JlZl9kaXJfbmV4dF9wYWdlID0gYnVmLT5ncmVmc1tpICsgMV07CisJ CXB0ciArPSBQQUdFX1NJWkU7CisJfQorCS8qIGxhc3QgcGFnZSBtdXN0IHNheSB0aGVyZSBpcyBu byBtb3JlIHBhZ2VzICovCisJcGFnZV9kaXIgPSAoc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0 b3J5ICopcHRyOworCXBhZ2VfZGlyLT5ncmVmX2Rpcl9uZXh0X3BhZ2UgPSBHUkFOVF9JTlZBTElE X1JFRjsKK30KKworc3RhdGljIHZvaWQgZ3Vlc3RfZmlsbF9wYWdlX2RpcihzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCXVuc2lnbmVkIGNoYXIgKnB0cjsKKwlpbnQgY3VyX2dy ZWYsIGdyZWZzX2xlZnQsIHRvX2NvcHksIGksIG51bV9wYWdlc19kaXI7CisKKwlwdHIgPSBidWYt PmRpcmVjdG9yeTsKKwludW1fcGFnZXNfZGlyID0gZ2V0X251bV9wYWdlc19kaXIoYnVmKTsKKwor CS8qCisJICogd2hpbGUgY29weWluZywgc2tpcCBncmVmcyBhdCBzdGFydCwgdGhleSBhcmUgZm9y IHBhZ2VzCisJICogZ3JhbnRlZCBmb3IgdGhlIHBhZ2UgZGlyZWN0b3J5IGl0c2VsZgorCSAqLwor CWN1cl9ncmVmID0gbnVtX3BhZ2VzX2RpcjsKKwlncmVmc19sZWZ0ID0gYnVmLT5udW1fcGFnZXM7 CisJZm9yIChpID0gMDsgaSA8IG51bV9wYWdlc19kaXI7IGkrKykgeworCQlzdHJ1Y3QgeGVuZGlz cGxfcGFnZV9kaXJlY3RvcnkgKnBhZ2VfZGlyID0KKwkJCQkoc3RydWN0IHhlbmRpc3BsX3BhZ2Vf ZGlyZWN0b3J5ICopcHRyOworCisJCWlmIChncmVmc19sZWZ0IDw9IFhFTl9EUk1fTlVNX0dSRUZT X1BFUl9QQUdFKSB7CisJCQl0b19jb3B5ID0gZ3JlZnNfbGVmdDsKKwkJCXBhZ2VfZGlyLT5ncmVm X2Rpcl9uZXh0X3BhZ2UgPSBHUkFOVF9JTlZBTElEX1JFRjsKKwkJfSBlbHNlIHsKKwkJCXRvX2Nv cHkgPSBYRU5fRFJNX05VTV9HUkVGU19QRVJfUEFHRTsKKwkJCXBhZ2VfZGlyLT5ncmVmX2Rpcl9u ZXh0X3BhZ2UgPSBidWYtPmdyZWZzW2kgKyAxXTsKKwkJfQorCQltZW1jcHkoJnBhZ2VfZGlyLT5n cmVmLCAmYnVmLT5ncmVmc1tjdXJfZ3JlZl0sCisJCQkJdG9fY29weSAqIHNpemVvZihncmFudF9y ZWZfdCkpOworCQlwdHIgKz0gUEFHRV9TSVpFOworCQlncmVmc19sZWZ0IC09IHRvX2NvcHk7CisJ CWN1cl9ncmVmICs9IHRvX2NvcHk7CisJfQorfQorCitzdGF0aWMgaW50IGd1ZXN0X2dyYW50X3Jl ZnNfZm9yX2J1ZmZlcihzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmLAorCQlncmFudF9y ZWZfdCAqcHJpdl9ncmVmX2hlYWQsIGludCBncmVmX2lkeCkKK3sKKwlpbnQgaSwgY3VyX3JlZiwg b3RoZXJlbmRfaWQ7CisKKwlvdGhlcmVuZF9pZCA9IGJ1Zi0+eGJfZGV2LT5vdGhlcmVuZF9pZDsK Kwlmb3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fcGFnZXM7IGkrKykgeworCQljdXJfcmVmID0gZ250 dGFiX2NsYWltX2dyYW50X3JlZmVyZW5jZShwcml2X2dyZWZfaGVhZCk7CisJCWlmIChjdXJfcmVm IDwgMCkKKwkJCXJldHVybiBjdXJfcmVmOworCQlnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3Nf cmVmKGN1cl9yZWYsIG90aGVyZW5kX2lkLAorCQkJCXhlbl9wYWdlX3RvX2dmbihidWYtPnBhZ2Vz W2ldKSwgMCk7CisJCWJ1Zi0+Z3JlZnNbZ3JlZl9pZHgrK10gPSBjdXJfcmVmOworCX0KKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBncmFudF9yZWZlcmVuY2VzKHN0cnVjdCB4ZW5fZHJtX2Zy b250X3NoYnVmICpidWYpCit7CisJZ3JhbnRfcmVmX3QgcHJpdl9ncmVmX2hlYWQ7CisJaW50IHJl dCwgaSwgaiwgY3VyX3JlZjsKKwlpbnQgb3RoZXJlbmRfaWQsIG51bV9wYWdlc19kaXI7CisKKwly ZXQgPSBnbnR0YWJfYWxsb2NfZ3JhbnRfcmVmZXJlbmNlcyhidWYtPm51bV9ncmVmcywgJnByaXZf Z3JlZl9oZWFkKTsKKwlpZiAocmV0IDwgMCkgeworCQlEUk1fRVJST1IoIkNhbm5vdCBhbGxvY2F0 ZSBncmFudCByZWZlcmVuY2VzXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJb3RoZXJlbmRfaWQg PSBidWYtPnhiX2Rldi0+b3RoZXJlbmRfaWQ7CisJaiA9IDA7CisJbnVtX3BhZ2VzX2RpciA9IGdl dF9udW1fcGFnZXNfZGlyKGJ1Zik7CisJZm9yIChpID0gMDsgaSA8IG51bV9wYWdlc19kaXI7IGkr KykgeworCQl1bnNpZ25lZCBsb25nIGZyYW1lOworCisJCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1f Z3JhbnRfcmVmZXJlbmNlKCZwcml2X2dyZWZfaGVhZCk7CisJCWlmIChjdXJfcmVmIDwgMCkKKwkJ CXJldHVybiBjdXJfcmVmOworCisJCWZyYW1lID0geGVuX3BhZ2VfdG9fZ2ZuKHZpcnRfdG9fcGFn ZShidWYtPmRpcmVjdG9yeSArCisJCQkJUEFHRV9TSVpFICogaSkpOworCQlnbnR0YWJfZ3JhbnRf Zm9yZWlnbl9hY2Nlc3NfcmVmKGN1cl9yZWYsIG90aGVyZW5kX2lkLAorCQkJCWZyYW1lLCAwKTsK KwkJYnVmLT5ncmVmc1tqKytdID0gY3VyX3JlZjsKKwl9CisKKwlpZiAoYnVmLT5vcHMtPmdyYW50 X3JlZnNfZm9yX2J1ZmZlcikgeworCQlyZXQgPSBidWYtPm9wcy0+Z3JhbnRfcmVmc19mb3JfYnVm ZmVyKGJ1ZiwgJnByaXZfZ3JlZl9oZWFkLCBqKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7 CisJfQorCisJZ250dGFiX2ZyZWVfZ3JhbnRfcmVmZXJlbmNlcyhwcml2X2dyZWZfaGVhZCk7CisJ cmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYWxsb2Nfc3RvcmFnZShzdHJ1Y3QgeGVuX2RybV9m cm9udF9zaGJ1ZiAqYnVmKQoreworCWlmIChidWYtPnNndCkgeworCQlidWYtPnBhZ2VzID0ga3Zt YWxsb2NfYXJyYXkoYnVmLT5udW1fcGFnZXMsCisJCQkJc2l6ZW9mKHN0cnVjdCBwYWdlICopLCBH RlBfS0VSTkVMKTsKKwkJaWYgKCFidWYtPnBhZ2VzKQorCQkJcmV0dXJuIC1FTk9NRU07CisKKwkJ aWYgKGRybV9wcmltZV9zZ190b19wYWdlX2FkZHJfYXJyYXlzKGJ1Zi0+c2d0LCBidWYtPnBhZ2Vz LAorCQkJCU5VTEwsIGJ1Zi0+bnVtX3BhZ2VzKSA8IDApCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9 CisKKwlidWYtPmdyZWZzID0ga2NhbGxvYyhidWYtPm51bV9ncmVmcywgc2l6ZW9mKCpidWYtPmdy ZWZzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYtPmdyZWZzKQorCQlyZXR1cm4gLUVOT01FTTsK KworCWJ1Zi0+ZGlyZWN0b3J5ID0ga2NhbGxvYyhnZXRfbnVtX3BhZ2VzX2RpcihidWYpLCBQQUdF X1NJWkUsIEdGUF9LRVJORUwpOworCWlmICghYnVmLT5kaXJlY3RvcnkpCisJCXJldHVybiAtRU5P TUVNOworCisJcmV0dXJuIDA7Cit9CisKKy8qCisgKiBGb3IgYmUgYWxsb2NhdGVkIGJ1ZmZlcnMg d2UgZG9uJ3QgbmVlZCBncmFudF9yZWZzX2Zvcl9idWZmZXIgYXMgdGhvc2UKKyAqIGdyYW50IHJl ZmVyZW5jZXMgYXJlIGFsbG9jYXRlZCBhdCBiYWNrZW5kIHNpZGUKKyAqLworc3RhdGljIGNvbnN0 IHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX29wcyBiYWNrZW5kX29wcyA9IHsKKwkuY2FsY19u dW1fZ3JlZnMgPSBiYWNrZW5kX2NhbGNfbnVtX2dyZWZzLAorCS5maWxsX3BhZ2VfZGlyID0gYmFj a2VuZF9maWxsX3BhZ2VfZGlyLAorCS5tYXAgPSBiYWNrZW5kX21hcCwKKwkudW5tYXAgPSBiYWNr ZW5kX3VubWFwCit9OworCisvKiBGb3IgbG9jYWxseSBncmFudGVkIHJlZmVyZW5jZXMgd2UgZG8g bm90IG5lZWQgdG8gbWFwL3VubWFwIHRoZSByZWZlcmVuY2VzICovCitzdGF0aWMgY29uc3Qgc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfb3BzIGxvY2FsX29wcyA9IHsKKwkuY2FsY19udW1fZ3Jl ZnMgPSBndWVzdF9jYWxjX251bV9ncmVmcywKKwkuZmlsbF9wYWdlX2RpciA9IGd1ZXN0X2ZpbGxf cGFnZV9kaXIsCisJLmdyYW50X3JlZnNfZm9yX2J1ZmZlciA9IGd1ZXN0X2dyYW50X3JlZnNfZm9y X2J1ZmZlciwKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICp4ZW5fZHJtX2Zyb250 X3NoYnVmX2FsbG9jKAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1Zl9jZmcgKmNmZykKK3sK KwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmOworCWludCByZXQ7CisKKwkvKiBlaXRo ZXIgcGFnZXMgb3Igc2d0LCBub3QgYm90aCAqLworCWlmICh1bmxpa2VseShjZmctPnBhZ2VzICYm IGNmZy0+c2d0KSkgeworCQlEUk1fRVJST1IoIkNhbm5vdCBoYW5kbGUgYnVmZmVyIGFsbG9jYXRp b24gd2l0aCBib3RoIHBhZ2VzIGFuZCBzZyB0YWJsZSBwcm92aWRlZFxuIik7CisJCXJldHVybiBO VUxMOworCX0KKworCWJ1ZiA9IGt6YWxsb2Moc2l6ZW9mKCpidWYpLCBHRlBfS0VSTkVMKTsKKwlp ZiAoIWJ1ZikKKwkJcmV0dXJuIE5VTEw7CisKKwlpZiAoY2ZnLT5iZV9hbGxvYykKKwkJYnVmLT5v cHMgPSAmYmFja2VuZF9vcHM7CisJZWxzZQorCQlidWYtPm9wcyA9ICZsb2NhbF9vcHM7CisKKwli dWYtPnhiX2RldiA9IGNmZy0+eGJfZGV2OworCWJ1Zi0+bnVtX3BhZ2VzID0gRElWX1JPVU5EX1VQ KGNmZy0+c2l6ZSwgUEFHRV9TSVpFKTsKKwlidWYtPnNndCA9IGNmZy0+c2d0OworCWJ1Zi0+cGFn ZXMgPSBjZmctPnBhZ2VzOworCisJYnVmLT5vcHMtPmNhbGNfbnVtX2dyZWZzKGJ1Zik7CisKKwly ZXQgPSBhbGxvY19zdG9yYWdlKGJ1Zik7CisJaWYgKHJldCkKKwkJZ290byBmYWlsOworCisJcmV0 ID0gZ3JhbnRfcmVmZXJlbmNlcyhidWYpOworCWlmIChyZXQpCisJCWdvdG8gZmFpbDsKKworCWJ1 Zi0+b3BzLT5maWxsX3BhZ2VfZGlyKGJ1Zik7CisKKwlyZXR1cm4gYnVmOworCitmYWlsOgorCXhl bl9kcm1fZnJvbnRfc2hidWZfZnJlZShidWYpOworCXJldHVybiBFUlJfUFRSKHJldCk7Cit9CmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuaCBiL2Ry aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNmM0ZmJjNjhmMzI4Ci0tLSAvZGV2L251bGwKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmgKQEAgLTAsMCArMSw3MiBA QAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisg KiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2 LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNo Y2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVm IF9fWEVOX0RSTV9GUk9OVF9TSEJVRl9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfU0hCVUZf SF8KKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJs aXN0Lmg+CisKKyNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KKworc3RydWN0IHhlbl9kcm1f ZnJvbnRfc2hidWYgeworCS8qCisJICogbnVtYmVyIG9mIHJlZmVyZW5jZXMgZ3JhbnRlZCBmb3Ig dGhlIGJhY2tlbmQgdXNlOgorCSAqICAtIGZvciBhbGxvY2F0ZWQvaW1wb3J0ZWQgZG1hLWJ1Zidz IHRoaXMgaG9sZHMgbnVtYmVyIG9mIGdyYW50CisJICogICAgcmVmZXJlbmNlcyBmb3IgdGhlIHBh Z2UgZGlyZWN0b3J5IGFuZCBwYWdlcyBvZiB0aGUgYnVmZmVyCisJICogIC0gZm9yIHRoZSBidWZm ZXIgcHJvdmlkZWQgYnkgdGhlIGJhY2tlbmQgdGhpcyBob2xkcyBudW1iZXIgb2YKKwkgKiAgICBn cmFudCByZWZlcmVuY2VzIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgYXMgZ3JhbnQgcmVmZXJlbmNl cyBmb3IKKwkgKiAgICB0aGUgYnVmZmVyIHdpbGwgYmUgcHJvdmlkZWQgYnkgdGhlIGJhY2tlbmQK KwkgKi8KKwlpbnQgbnVtX2dyZWZzOworCWdyYW50X3JlZl90ICpncmVmczsKKwl1bnNpZ25lZCBj aGFyICpkaXJlY3Rvcnk7CisKKwkvKgorCSAqIHRoZXJlIGFyZSAyIHdheXMgdG8gcHJvdmlkZSBi YWNraW5nIHN0b3JhZ2UgZm9yIHRoaXMgc2hhcmVkIGJ1ZmZlcjoKKwkgKiBlaXRoZXIgcGFnZXMg b3Igc2d0LiBpZiBidWZmZXIgY3JlYXRlZCBmcm9tIHNndCB0aGVuIHdlIG93bgorCSAqIHRoZSBw YWdlcyBhbmQgbXVzdCBmcmVlIHRob3NlIG91cnNlbHZlcyBvbiBjbG9zdXJlCisJICovCisJaW50 IG51bV9wYWdlczsKKwlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOworCisJc3RydWN0IHNnX3RhYmxlICpz Z3Q7CisKKwlzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2OworCisJLyogdGhlc2UgYXJlIHRo ZSBvcHMgdXNlZCBpbnRlcm5hbGx5IGRlcGVuZGluZyBvbiBiZV9hbGxvYyBtb2RlICovCisJY29u c3Qgc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfb3BzICpvcHM7CisKKwkvKiBYZW4gbWFwIGhh bmRsZXMgZm9yIHRoZSBidWZmZXIgYWxsb2NhdGVkIGJ5IHRoZSBiYWNrZW5kICovCisJZ3JhbnRf aGFuZGxlX3QgKmJhY2tlbmRfbWFwX2hhbmRsZXM7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9u dF9zaGJ1Zl9jZmcgeworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXY7CisJc2l6ZV90IHNp emU7CisJc3RydWN0IHBhZ2UgKipwYWdlczsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsKKwlib29s IGJlX2FsbG9jOworfTsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKnhlbl9kcm1fZnJv bnRfc2hidWZfYWxsb2MoCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2NmZyAqY2ZnKTsK KworZ3JhbnRfcmVmX3QgeGVuX2RybV9mcm9udF9zaGJ1Zl9nZXRfZGlyX3N0YXJ0KHN0cnVjdCB4 ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCitpbnQgeGVuX2RybV9mcm9udF9zaGJ1Zl9tYXAo c3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisKK2ludCB4ZW5fZHJtX2Zyb250X3No YnVmX3VubWFwKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCit2b2lkIHhlbl9k cm1fZnJvbnRfc2hidWZfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisK K3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVm ICpidWYpOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX1NIQlVGX0hfICovCi0tIAoyLjcu NAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRl dmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S934052AbeCMQWN (ORCPT ); Tue, 13 Mar 2018 12:22:13 -0400 Received: from mail-lf0-f51.google.com ([209.85.215.51]:37617 "EHLO mail-lf0-f51.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752150AbeCMQVY (ORCPT ); Tue, 13 Mar 2018 12:21:24 -0400 X-Google-Smtp-Source: AG47ELvBNC0hylpYHnKBrgN6QgjmX+Xs5g3S9ae5mXkYlNicbq+eB6SNzMeXoi0MF2OMlzf0xDMjpA== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko Subject: [PATCH RESEND v2 1/2] drm/xen-front: Add support for Xen PV display frontend Date: Tue, 13 Mar 2018 18:21:05 +0200 Message-Id: <1520958066-22875-2-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1520958066-22875-1-git-send-email-andr2000@gmail.com> References: <1520958066-22875-1-git-send-email-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Add support for Xen para-virtualized frontend display driver. Accompanying backend [1] is implemented as a user-space application and its helper library [2], capable of running as a Weston client or DRM master. Configuration of both backend and frontend is done via Xen guest domain configuration options [3]. Driver limitations: 1. Only primary plane without additional properties is supported. 2. Only one video mode supported which resolution is configured via XenStore. 3. All CRTCs operate at fixed frequency of 60Hz. 1. Implement Xen bus state machine for the frontend driver according to the state diagram and recovery flow from display para-virtualized protocol: xen/interface/io/displif.h. 2. Read configuration values from Xen store according to xen/interface/io/displif.h protocol: - read connector(s) configuration - read buffer allocation mode (backend/frontend) 3. Handle Xen event channels: - create for all configured connectors and publish corresponding ring references and event channels in Xen store, so backend can connect - implement event channels interrupt handlers - create and destroy event channels with respect to Xen bus state 4. Implement shared buffer handling according to the para-virtualized display device protocol at xen/interface/io/displif.h: - handle page directories according to displif protocol: - allocate and share page directories - grant references to the required set of pages for the page directory - allocate xen balllooned pages via Xen balloon driver with alloc_xenballooned_pages/free_xenballooned_pages - grant references to the required set of pages for the shared buffer itself - implement pages map/unmap for the buffers allocated by the backend (gnttab_map_refs/gnttab_unmap_refs) 5. Implement kernel modesetiing/connector handling using DRM simple KMS helper pipeline: - implement KMS part of the driver with the help of DRM simple pipepline helper which is possible due to the fact that the para-virtualized driver only supports a single (primary) plane: - initialize connectors according to XenStore configuration - handle frame done events from the backend - create and destroy frame buffers and propagate those to the backend - propagate set/reset mode configuration to the backend on display enable/disable callbacks - send page flip request to the backend and implement logic for reporting backend IO errors on prepare fb callback - implement virtual connector handling: - support only pixel formats suitable for single plane modes - make sure the connector is always connected - support a single video mode as per para-virtualized driver configuration 6. Implement GEM handling depending on driver mode of operation: depending on the requirements for the para-virtualized environment, namely requirements dictated by the accompanying DRM/(v)GPU drivers running in both host and guest environments, number of operating modes of para-virtualized display driver are supported: - display buffers can be allocated by either frontend driver or backend - display buffers can be allocated to be contiguous in memory or not Note! Frontend driver itself has no dependency on contiguous memory for its operation. 6.1. Buffers allocated by the frontend driver. The below modes of operation are configured at compile-time via frontend driver's kernel configuration. 6.1.1. Front driver configured to use GEM CMA helpers This use-case is useful when used with accompanying DRM/vGPU driver in guest domain which was designed to only work with contiguous buffers, e.g. DRM driver based on GEM CMA helpers: such drivers can only import contiguous PRIME buffers, thus requiring frontend driver to provide such. In order to implement this mode of operation para-virtualized frontend driver can be configured to use GEM CMA helpers. 6.1.2. Front driver doesn't use GEM CMA If accompanying drivers can cope with non-contiguous memory then, to lower pressure on CMA subsystem of the kernel, driver can allocate buffers from system memory. Note! If used with accompanying DRM/(v)GPU drivers this mode of operation may require IOMMU support on the platform, so accompanying DRM/vGPU hardware can still reach display buffer memory while importing PRIME buffers from the frontend driver. 6.2. Buffers allocated by the backend This mode of operation is run-time configured via guest domain configuration through XenStore entries. For systems which do not provide IOMMU support, but having specific requirements for display buffers it is possible to allocate such buffers at backend side and share those with the frontend. For example, if host domain is 1:1 mapped and has DRM/GPU hardware expecting physically contiguous memory, this allows implementing zero-copying use-cases. Note, while using this scenario the following should be considered: a) If guest domain dies then pages/grants received from the backend cannot be claimed back b) Misbehaving guest may send too many requests to the backend exhausting its grant references and memory (consider this from security POV). Note! Configuration options 1.1 (contiguous display buffers) and 2 (backend allocated buffers) are not supported at the same time. 7. Handle communication with the backend: - send requests and wait for the responses according to the displif protocol - serialize access to the communication channel - time-out used for backend communication is set to 3000 ms - manage display buffers shared with the backend [1] https://github.com/xen-troops/displ_be [2] https://github.com/xen-troops/libxenbe [3] https://xenbits.xen.org/gitweb/?p=xen.git;a=blob;f=docs/man/xl.cfg.pod.5.in;h=a699367779e2ae1212ff8f638eff0206ec1a1cc9;hb=refs/heads/master#l1257 --- drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/xen/Kconfig | 30 ++ drivers/gpu/drm/xen/Makefile | 17 + drivers/gpu/drm/xen/xen_drm_front.c | 690 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front.h | 77 ++++ drivers/gpu/drm/xen/xen_drm_front_cfg.c | 77 ++++ drivers/gpu/drm/xen/xen_drm_front_cfg.h | 37 ++ drivers/gpu/drm/xen/xen_drm_front_conn.c | 146 ++++++ drivers/gpu/drm/xen/xen_drm_front_conn.h | 27 ++ drivers/gpu/drm/xen/xen_drm_front_drv.c | 239 ++++++++++ drivers/gpu/drm/xen/xen_drm_front_drv.h | 78 ++++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.c | 383 +++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.h | 79 ++++ drivers/gpu/drm/xen/xen_drm_front_gem.c | 335 ++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_gem.h | 41 ++ drivers/gpu/drm/xen/xen_drm_front_gem_cma.c | 74 +++ drivers/gpu/drm/xen/xen_drm_front_kms.c | 324 +++++++++++++ drivers/gpu/drm/xen/xen_drm_front_kms.h | 25 + drivers/gpu/drm/xen/xen_drm_front_shbuf.c | 432 +++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_shbuf.h | 72 +++ 21 files changed, 3186 insertions(+) create mode 100644 drivers/gpu/drm/xen/Kconfig create mode 100644 drivers/gpu/drm/xen/Makefile create mode 100644 drivers/gpu/drm/xen/xen_drm_front.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_cfg.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_cfg.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_conn.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_conn.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_drv.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_drv.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_evtchnl.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_evtchnl.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_gem.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_gem.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_gem_cma.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_kms.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_kms.h create mode 100644 drivers/gpu/drm/xen/xen_drm_front_shbuf.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_shbuf.h diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index deeefa7a1773..757825ac60df 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -289,6 +289,8 @@ source "drivers/gpu/drm/pl111/Kconfig" source "drivers/gpu/drm/tve200/Kconfig" +source "drivers/gpu/drm/xen/Kconfig" + # Keep legacy drivers last menuconfig DRM_LEGACY diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 50093ff4479b..9d66657ea117 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -103,3 +103,4 @@ obj-$(CONFIG_DRM_MXSFB) += mxsfb/ obj-$(CONFIG_DRM_TINYDRM) += tinydrm/ obj-$(CONFIG_DRM_PL111) += pl111/ obj-$(CONFIG_DRM_TVE200) += tve200/ +obj-$(CONFIG_DRM_XEN) += xen/ diff --git a/drivers/gpu/drm/xen/Kconfig b/drivers/gpu/drm/xen/Kconfig new file mode 100644 index 000000000000..4f4abc91f3b6 --- /dev/null +++ b/drivers/gpu/drm/xen/Kconfig @@ -0,0 +1,30 @@ +config DRM_XEN + bool "DRM Support for Xen guest OS" + depends on XEN + help + Choose this option if you want to enable DRM support + for Xen. + +config DRM_XEN_FRONTEND + tristate "Para-virtualized frontend driver for Xen guest OS" + depends on DRM_XEN + depends on DRM + select DRM_KMS_HELPER + select VIDEOMODE_HELPERS + select XEN_XENBUS_FRONTEND + help + Choose this option if you want to enable a para-virtualized + frontend DRM/KMS driver for Xen guest OSes. + +config DRM_XEN_FRONTEND_CMA + bool "Use DRM CMA to allocate dumb buffers" + depends on DRM_XEN_FRONTEND + select DRM_KMS_CMA_HELPER + select DRM_GEM_CMA_HELPER + help + Use DRM CMA helpers to allocate display buffers. + This is useful for the use-cases when guest driver needs to + share or export buffers to other drivers which only expect + contiguous buffers. + Note: in this mode driver cannot use buffers allocated + by the backend. diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile new file mode 100644 index 000000000000..ac1b82f2a860 --- /dev/null +++ b/drivers/gpu/drm/xen/Makefile @@ -0,0 +1,17 @@ +# SPDX-License-Identifier: GPL-2.0 OR MIT + +drm_xen_front-objs := xen_drm_front.o \ + xen_drm_front_drv.o \ + xen_drm_front_kms.o \ + xen_drm_front_conn.o \ + xen_drm_front_evtchnl.o \ + xen_drm_front_shbuf.o \ + xen_drm_front_cfg.o + +ifeq ($(CONFIG_DRM_XEN_FRONTEND_CMA),y) + drm_xen_front-objs += xen_drm_front_gem_cma.o +else + drm_xen_front-objs += xen_drm_front_gem.o +endif + +obj-$(CONFIG_DRM_XEN_FRONTEND) += drm_xen_front.o diff --git a/drivers/gpu/drm/xen/xen_drm_front.c b/drivers/gpu/drm/xen/xen_drm_front.c new file mode 100644 index 000000000000..dbabdf98f896 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -0,0 +1,690 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT + +/* + * Xen para-virtual DRM device + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include + +#include + +#include +#include +#include + +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_drv.h" +#include "xen_drm_front_evtchnl.h" +#include "xen_drm_front_shbuf.h" + +struct xen_drm_front_dbuf { + struct list_head list; + uint64_t dbuf_cookie; + uint64_t fb_cookie; + struct xen_drm_front_shbuf *shbuf; +}; + +static int dbuf_add_to_list(struct xen_drm_front_info *front_info, + struct xen_drm_front_shbuf *shbuf, uint64_t dbuf_cookie) +{ + struct xen_drm_front_dbuf *dbuf; + + dbuf = kzalloc(sizeof(*dbuf), GFP_KERNEL); + if (!dbuf) + return -ENOMEM; + + dbuf->dbuf_cookie = dbuf_cookie; + dbuf->shbuf = shbuf; + list_add(&dbuf->list, &front_info->dbuf_list); + return 0; +} + +static struct xen_drm_front_dbuf *dbuf_get(struct list_head *dbuf_list, + uint64_t dbuf_cookie) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) + if (buf->dbuf_cookie == dbuf_cookie) + return buf; + + return NULL; +} + +static void dbuf_flush_fb(struct list_head *dbuf_list, uint64_t fb_cookie) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) + if (buf->fb_cookie == fb_cookie) + xen_drm_front_shbuf_flush(buf->shbuf); +} + +static void dbuf_free(struct list_head *dbuf_list, uint64_t dbuf_cookie) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) + if (buf->dbuf_cookie == dbuf_cookie) { + list_del(&buf->list); + xen_drm_front_shbuf_unmap(buf->shbuf); + xen_drm_front_shbuf_free(buf->shbuf); + kfree(buf); + break; + } +} + +static void dbuf_free_all(struct list_head *dbuf_list) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) { + list_del(&buf->list); + xen_drm_front_shbuf_unmap(buf->shbuf); + xen_drm_front_shbuf_free(buf->shbuf); + kfree(buf); + } +} + +static struct xendispl_req *be_prepare_req( + struct xen_drm_front_evtchnl *evtchnl, uint8_t operation) +{ + struct xendispl_req *req; + + req = RING_GET_REQUEST(&evtchnl->u.req.ring, + evtchnl->u.req.ring.req_prod_pvt); + req->operation = operation; + req->id = evtchnl->evt_next_id++; + evtchnl->evt_id = req->id; + return req; +} + +static int be_stream_do_io(struct xen_drm_front_evtchnl *evtchnl, + struct xendispl_req *req) +{ + reinit_completion(&evtchnl->u.req.completion); + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + return -EIO; + + xen_drm_front_evtchnl_flush(evtchnl); + return 0; +} + +static int be_stream_wait_io(struct xen_drm_front_evtchnl *evtchnl) +{ + if (wait_for_completion_timeout(&evtchnl->u.req.completion, + msecs_to_jiffies(XEN_DRM_FRONT_WAIT_BACK_MS)) <= 0) + return -ETIMEDOUT; + + return evtchnl->u.req.resp_status; +} + +int xen_drm_front_mode_set(struct xen_drm_front_drm_pipeline *pipeline, + uint32_t x, uint32_t y, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t fb_cookie) +{ + struct xen_drm_front_evtchnl *evtchnl; + struct xen_drm_front_info *front_info; + struct xendispl_req *req; + unsigned long flags; + int ret; + + front_info = pipeline->drm_info->front_info; + evtchnl = &front_info->evt_pairs[pipeline->index].req; + if (unlikely(!evtchnl)) + return -EIO; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_SET_CONFIG); + req->op.set_config.x = x; + req->op.set_config.y = y; + req->op.set_config.width = width; + req->op.set_config.height = height; + req->op.set_config.bpp = bpp; + req->op.set_config.fb_cookie = fb_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; +} + +static int be_dbuf_create_int(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t size, struct page **pages, + struct sg_table *sgt) +{ + struct xen_drm_front_evtchnl *evtchnl; + struct xen_drm_front_shbuf *shbuf; + struct xendispl_req *req; + struct xen_drm_front_shbuf_cfg buf_cfg; + unsigned long flags; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + memset(&buf_cfg, 0, sizeof(buf_cfg)); + buf_cfg.xb_dev = front_info->xb_dev; + buf_cfg.pages = pages; + buf_cfg.size = size; + buf_cfg.sgt = sgt; + buf_cfg.be_alloc = front_info->cfg.be_alloc; + + shbuf = xen_drm_front_shbuf_alloc(&buf_cfg); + if (!shbuf) + return -ENOMEM; + + ret = dbuf_add_to_list(front_info, shbuf, dbuf_cookie); + if (ret < 0) { + xen_drm_front_shbuf_free(shbuf); + return ret; + } + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_DBUF_CREATE); + req->op.dbuf_create.gref_directory = + xen_drm_front_shbuf_get_dir_start(shbuf); + req->op.dbuf_create.buffer_sz = size; + req->op.dbuf_create.dbuf_cookie = dbuf_cookie; + req->op.dbuf_create.width = width; + req->op.dbuf_create.height = height; + req->op.dbuf_create.bpp = bpp; + if (buf_cfg.be_alloc) + req->op.dbuf_create.flags |= XENDISPL_DBUF_FLG_REQ_ALLOC; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret < 0) + goto fail; + + ret = be_stream_wait_io(evtchnl); + if (ret < 0) + goto fail; + + ret = xen_drm_front_shbuf_map(shbuf); + if (ret < 0) + goto fail; + + mutex_unlock(&front_info->req_io_lock); + return 0; + +fail: + mutex_unlock(&front_info->req_io_lock); + dbuf_free(&front_info->dbuf_list, dbuf_cookie); + return ret; +} + +int xen_drm_front_dbuf_create_from_sgt(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t size, struct sg_table *sgt) +{ + return be_dbuf_create_int(front_info, dbuf_cookie, width, height, + bpp, size, NULL, sgt); +} + +int xen_drm_front_dbuf_create_from_pages(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t size, struct page **pages) +{ + return be_dbuf_create_int(front_info, dbuf_cookie, width, height, + bpp, size, pages, NULL); +} + +int xen_drm_front_dbuf_destroy(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie) +{ + struct xen_drm_front_evtchnl *evtchnl; + struct xendispl_req *req; + unsigned long flags; + bool be_alloc; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + be_alloc = front_info->cfg.be_alloc; + + /* + * for the backend allocated buffer release references now, so backend + * can free the buffer + */ + if (be_alloc) + dbuf_free(&front_info->dbuf_list, dbuf_cookie); + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_DBUF_DESTROY); + req->op.dbuf_destroy.dbuf_cookie = dbuf_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + /* + * do this regardless of communication status with the backend: + * if we cannot remove remote resources remove what we can locally + */ + if (!be_alloc) + dbuf_free(&front_info->dbuf_list, dbuf_cookie); + + mutex_unlock(&front_info->req_io_lock); + return ret; +} + +int xen_drm_front_fb_attach(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint64_t fb_cookie, uint32_t width, + uint32_t height, uint32_t pixel_format) +{ + struct xen_drm_front_evtchnl *evtchnl; + struct xen_drm_front_dbuf *buf; + struct xendispl_req *req; + unsigned long flags; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + buf = dbuf_get(&front_info->dbuf_list, dbuf_cookie); + if (!buf) + return -EINVAL; + + buf->fb_cookie = fb_cookie; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_FB_ATTACH); + req->op.fb_attach.dbuf_cookie = dbuf_cookie; + req->op.fb_attach.fb_cookie = fb_cookie; + req->op.fb_attach.width = width; + req->op.fb_attach.height = height; + req->op.fb_attach.pixel_format = pixel_format; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; +} + +int xen_drm_front_fb_detach(struct xen_drm_front_info *front_info, + uint64_t fb_cookie) +{ + struct xen_drm_front_evtchnl *evtchnl; + struct xendispl_req *req; + unsigned long flags; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_FB_DETACH); + req->op.fb_detach.fb_cookie = fb_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; +} + +int xen_drm_front_page_flip(struct xen_drm_front_info *front_info, + int conn_idx, uint64_t fb_cookie) +{ + struct xen_drm_front_evtchnl *evtchnl; + struct xendispl_req *req; + unsigned long flags; + int ret; + + if (unlikely(conn_idx >= front_info->num_evt_pairs)) + return -EINVAL; + + dbuf_flush_fb(&front_info->dbuf_list, fb_cookie); + evtchnl = &front_info->evt_pairs[conn_idx].req; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_PG_FLIP); + req->op.pg_flip.fb_cookie = fb_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; +} + +void xen_drm_front_unload(struct xen_drm_front_info *front_info) +{ + if (front_info->xb_dev->state != XenbusStateReconfiguring) + return; + + DRM_DEBUG("Can try removing driver now\n"); + xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); +} + +static int xen_drm_drv_probe(struct platform_device *pdev) +{ + /* + * The device is not spawn from a device tree, so arch_setup_dma_ops + * is not called, thus leaving the device with dummy DMA ops. + * This makes the device return error on PRIME buffer import, which + * is not correct: to fix this call of_dma_configure() with a NULL + * node to set default DMA ops. + */ + of_dma_configure(&pdev->dev, NULL); + return xen_drm_front_drv_probe(pdev); +} + +static int xen_drm_drv_remove(struct platform_device *pdev) +{ + return xen_drm_front_drv_remove(pdev); +} + +struct platform_device_info xen_drm_front_platform_info = { + .name = XENDISPL_DRIVER_NAME, + .id = 0, + .num_res = 0, + .dma_mask = DMA_BIT_MASK(32), +}; + +static struct platform_driver xen_drm_front_front_info = { + .probe = xen_drm_drv_probe, + .remove = xen_drm_drv_remove, + .driver = { + .name = XENDISPL_DRIVER_NAME, + }, +}; + +static void xen_drm_drv_deinit(struct xen_drm_front_info *front_info) +{ + if (!front_info->drm_pdrv_registered) + return; + + if (front_info->drm_pdev) + platform_device_unregister(front_info->drm_pdev); + + platform_driver_unregister(&xen_drm_front_front_info); + front_info->drm_pdrv_registered = false; + front_info->drm_pdev = NULL; +} + +static int xen_drm_drv_init(struct xen_drm_front_info *front_info) +{ + int ret; + + ret = platform_driver_register(&xen_drm_front_front_info); + if (ret < 0) + return ret; + + front_info->drm_pdrv_registered = true; + /* pass card configuration via platform data */ + xen_drm_front_platform_info.data = &front_info->cfg; + xen_drm_front_platform_info.size_data = sizeof(front_info->cfg); + + front_info->drm_pdev = platform_device_register_full( + &xen_drm_front_platform_info); + if (IS_ERR_OR_NULL(front_info->drm_pdev)) { + DRM_ERROR("Failed to register " XENDISPL_DRIVER_NAME " PV DRM driver\n"); + front_info->drm_pdev = NULL; + xen_drm_drv_deinit(front_info); + return -ENODEV; + } + + return 0; +} + +static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) +{ + xen_drm_drv_deinit(front_info); + xen_drm_front_evtchnl_free_all(front_info); + dbuf_free_all(&front_info->dbuf_list); +} + +static int displback_initwait(struct xen_drm_front_info *front_info) +{ + struct xen_drm_front_cfg *cfg = &front_info->cfg; + int ret; + + cfg->front_info = front_info; + ret = xen_drm_front_cfg_card(front_info, cfg); + if (ret < 0) + return ret; + + DRM_INFO("Have %d conector(s)\n", cfg->num_connectors); + /* Create event channels for all connectors and publish */ + ret = xen_drm_front_evtchnl_create_all(front_info); + if (ret < 0) + return ret; + + return xen_drm_front_evtchnl_publish_all(front_info); +} + +static int displback_connect(struct xen_drm_front_info *front_info) +{ + xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_CONNECTED); + return xen_drm_drv_init(front_info); +} + +static void displback_disconnect(struct xen_drm_front_info *front_info) +{ + bool removed = true; + + if (front_info->drm_pdev) { + if (xen_drm_front_drv_is_used(front_info->drm_pdev)) { + DRM_WARN("DRM driver still in use, deferring removal\n"); + removed = false; + } else + xen_drv_remove_internal(front_info); + } + + xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_DISCONNECTED); + + if (removed) + xenbus_switch_state(front_info->xb_dev, + XenbusStateInitialising); + else + xenbus_switch_state(front_info->xb_dev, + XenbusStateReconfiguring); +} + +static void displback_changed(struct xenbus_device *xb_dev, + enum xenbus_state backend_state) +{ + struct xen_drm_front_info *front_info = dev_get_drvdata(&xb_dev->dev); + int ret; + + DRM_DEBUG("Backend state is %s, front is %s\n", + xenbus_strstate(backend_state), + xenbus_strstate(xb_dev->state)); + + switch (backend_state) { + case XenbusStateReconfiguring: + /* fall through */ + case XenbusStateReconfigured: + /* fall through */ + case XenbusStateInitialised: + break; + + case XenbusStateInitialising: + /* recovering after backend unexpected closure */ + displback_disconnect(front_info); + break; + + case XenbusStateInitWait: + /* recovering after backend unexpected closure */ + displback_disconnect(front_info); + if (xb_dev->state != XenbusStateInitialising) + break; + + ret = displback_initwait(front_info); + if (ret < 0) + xenbus_dev_fatal(xb_dev, ret, + "initializing frontend"); + else + xenbus_switch_state(xb_dev, XenbusStateInitialised); + break; + + case XenbusStateConnected: + if (xb_dev->state != XenbusStateInitialised) + break; + + ret = displback_connect(front_info); + if (ret < 0) + xenbus_dev_fatal(xb_dev, ret, + "initializing DRM driver"); + else + xenbus_switch_state(xb_dev, XenbusStateConnected); + break; + + case XenbusStateClosing: + /* + * in this state backend starts freeing resources, + * so let it go into closed state, so we can also + * remove ours + */ + break; + + case XenbusStateUnknown: + /* fall through */ + case XenbusStateClosed: + if (xb_dev->state == XenbusStateClosed) + break; + + displback_disconnect(front_info); + break; + } +} + +static int xen_drv_probe(struct xenbus_device *xb_dev, + const struct xenbus_device_id *id) +{ + struct xen_drm_front_info *front_info; + + front_info = devm_kzalloc(&xb_dev->dev, + sizeof(*front_info), GFP_KERNEL); + if (!front_info) + return -ENOMEM; + + front_info->xb_dev = xb_dev; + spin_lock_init(&front_info->io_lock); + mutex_init(&front_info->req_io_lock); + INIT_LIST_HEAD(&front_info->dbuf_list); + front_info->drm_pdrv_registered = false; + dev_set_drvdata(&xb_dev->dev, front_info); + return xenbus_switch_state(xb_dev, XenbusStateInitialising); +} + +static int xen_drv_remove(struct xenbus_device *dev) +{ + struct xen_drm_front_info *front_info = dev_get_drvdata(&dev->dev); + int to = 100; + + xenbus_switch_state(dev, XenbusStateClosing); + + /* + * On driver removal it is disconnected from XenBus, + * so no backend state change events come via .otherend_changed + * callback. This prevents us from exiting gracefully, e.g. + * signaling the backend to free event channels, waiting for its + * state to change to XenbusStateClosed and cleaning at our end. + * Normally when front driver removed backend will finally go into + * XenbusStateInitWait state. + * + * Workaround: read backend's state manually and wait with time-out. + */ + while ((xenbus_read_unsigned(front_info->xb_dev->otherend, + "state", XenbusStateUnknown) != XenbusStateInitWait) && + to--) + msleep(10); + + if (!to) + DRM_ERROR("Backend state is %s while removing driver\n", + xenbus_strstate(xenbus_read_unsigned( + front_info->xb_dev->otherend, + "state", XenbusStateUnknown))); + + xen_drv_remove_internal(front_info); + xenbus_frontend_closed(dev); + return 0; +} + +static const struct xenbus_device_id xen_drv_ids[] = { + { XENDISPL_DRIVER_NAME }, + { "" } +}; + +static struct xenbus_driver xen_driver = { + .ids = xen_drv_ids, + .probe = xen_drv_probe, + .remove = xen_drv_remove, + .otherend_changed = displback_changed, +}; + +static int __init xen_drv_init(void) +{ + /* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */ + if (XEN_PAGE_SIZE != PAGE_SIZE) { + DRM_ERROR(XENDISPL_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n", + XEN_PAGE_SIZE, PAGE_SIZE); + return -ENODEV; + } + + if (!xen_domain()) + return -ENODEV; + + if (!xen_has_pv_devices()) + return -ENODEV; + + DRM_INFO("Registering XEN PV " XENDISPL_DRIVER_NAME "\n"); + return xenbus_register_frontend(&xen_driver); +} + +static void __exit xen_drv_cleanup(void) +{ + DRM_INFO("Unregistering XEN PV " XENDISPL_DRIVER_NAME "\n"); + xenbus_unregister_driver(&xen_driver); +} + +module_init(xen_drv_init); +module_exit(xen_drv_cleanup); + +MODULE_DESCRIPTION("Xen para-virtualized display device frontend"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("xen:"XENDISPL_DRIVER_NAME); diff --git a/drivers/gpu/drm/xen/xen_drm_front.h b/drivers/gpu/drm/xen/xen_drm_front.h new file mode 100644 index 000000000000..93c58c4e87d2 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -0,0 +1,77 @@ +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ + +/* + * Xen para-virtual DRM device + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#ifndef __XEN_DRM_FRONT_H_ +#define __XEN_DRM_FRONT_H_ + +#include + +#include "xen_drm_front_cfg.h" + +/* timeout in ms to wait for backend to respond */ +#define XEN_DRM_FRONT_WAIT_BACK_MS 3000 + +#ifndef GRANT_INVALID_REF +/* + * Note on usage of grant reference 0 as invalid grant reference: + * grant reference 0 is valid, but never exposed to a PV driver, + * because of the fact it is already in use/reserved by the PV console. + */ +#define GRANT_INVALID_REF 0 +#endif + +struct xen_drm_front_drm_pipeline; + +struct xen_drm_front_info { + struct xenbus_device *xb_dev; + /* to protect data between backend IO code and interrupt handler */ + spinlock_t io_lock; + /* serializer for backend IO: request/response */ + struct mutex req_io_lock; + bool drm_pdrv_registered; + /* virtual DRM platform device */ + struct platform_device *drm_pdev; + + int num_evt_pairs; + struct xen_drm_front_evtchnl_pair *evt_pairs; + struct xen_drm_front_cfg cfg; + + /* display buffers */ + struct list_head dbuf_list; +}; + +int xen_drm_front_mode_set(struct xen_drm_front_drm_pipeline *pipeline, + uint32_t x, uint32_t y, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t fb_cookie); + +int xen_drm_front_dbuf_create_from_sgt(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t size, struct sg_table *sgt); + +int xen_drm_front_dbuf_create_from_pages(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint32_t width, uint32_t height, + uint32_t bpp, uint64_t size, struct page **pages); + +int xen_drm_front_dbuf_destroy(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie); + +int xen_drm_front_fb_attach(struct xen_drm_front_info *front_info, + uint64_t dbuf_cookie, uint64_t fb_cookie, uint32_t width, + uint32_t height, uint32_t pixel_format); + +int xen_drm_front_fb_detach(struct xen_drm_front_info *front_info, + uint64_t fb_cookie); + +int xen_drm_front_page_flip(struct xen_drm_front_info *front_info, + int conn_idx, uint64_t fb_cookie); + +void xen_drm_front_unload(struct xen_drm_front_info *front_info); + +#endif /* __XEN_DRM_FRONT_H_ */ diff --git a/drivers/gpu/drm/xen/xen_drm_front_cfg.c b/drivers/gpu/drm/xen/xen_drm_front_cfg.c new file mode 100644 index 000000000000..9a0b2b8e6169 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_cfg.c @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT + +/* + * Xen para-virtual DRM device + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include + +#include + +#include +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_cfg.h" + +static int cfg_connector(struct xen_drm_front_info *front_info, + struct xen_drm_front_cfg_connector *connector, + const char *path, int index) +{ + char *connector_path; + + connector_path = devm_kasprintf(&front_info->xb_dev->dev, + GFP_KERNEL, "%s/%d", path, index); + if (!connector_path) + return -ENOMEM; + + if (xenbus_scanf(XBT_NIL, connector_path, XENDISPL_FIELD_RESOLUTION, + "%d" XENDISPL_RESOLUTION_SEPARATOR "%d", + &connector->width, &connector->height) < 0) { + /* either no entry configured or wrong resolution set */ + connector->width = 0; + connector->height = 0; + return -EINVAL; + } + + connector->xenstore_path = connector_path; + + DRM_INFO("Connector %s: resolution %dx%d\n", + connector_path, connector->width, connector->height); + return 0; +} + +int xen_drm_front_cfg_card(struct xen_drm_front_info *front_info, + struct xen_drm_front_cfg *cfg) +{ + struct xenbus_device *xb_dev = front_info->xb_dev; + int ret, i; + + if (xenbus_read_unsigned(front_info->xb_dev->nodename, + XENDISPL_FIELD_BE_ALLOC, 0)) { + DRM_INFO("Backend can provide display buffers\n"); + cfg->be_alloc = true; + } + + cfg->num_connectors = 0; + for (i = 0; i < ARRAY_SIZE(cfg->connectors); i++) { + ret = cfg_connector(front_info, + &cfg->connectors[i], xb_dev->nodename, i); + if (ret < 0) + break; + cfg->num_connectors++; + } + + if (!cfg->num_connectors) { + DRM_ERROR("No connector(s) configured at %s\n", + xb_dev->nodename); + return -ENODEV; + } + + return 0; +} + diff --git a/drivers/gpu/drm/xen/xen_drm_front_cfg.h b/drivers/gpu/drm/xen/xen_drm_front_cfg.h new file mode 100644 index 000000000000..6e7af670f8cd --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_cfg.h @@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ + +/* + * Xen para-virtual DRM device + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#ifndef __XEN_DRM_FRONT_CFG_H_ +#define __XEN_DRM_FRONT_CFG_H_ + +#include + +#define XEN_DRM_FRONT_MAX_CRTCS 4 + +struct xen_drm_front_cfg_connector { + int width; + int height; + char *xenstore_path; +}; + +struct xen_drm_front_cfg { + struct xen_drm_front_info *front_info; + /* number of connectors in this configuration */ + int num_connectors; + /* connector configurations */ + struct xen_drm_front_cfg_connector connectors[XEN_DRM_FRONT_MAX_CRTCS]; + /* set if dumb buffers are allocated externally on backend side */ + bool be_alloc; +}; + +int xen_drm_front_cfg_card(struct xen_drm_front_info *front_info, + struct xen_drm_front_cfg *cfg); + +#endif /* __XEN_DRM_FRONT_CFG_H_ */ diff --git a/drivers/gpu/drm/xen/xen_drm_front_conn.c b/drivers/gpu/drm/xen/xen_drm_front_conn.c new file mode 100644 index 000000000000..aaa1cfff4797 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_conn.c @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT + +/* + * Xen para-virtual DRM device + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include +#include + +#include