From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v3] drm/xen-front: Add support for Xen PV display frontend Date: Wed, 21 Mar 2018 16:58:13 +0200 Message-ID: <1521644293-14612-2-git-send-email-andr2000@gmail.com> References: <1521644293-14612-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-x229.google.com (mail-lf0-x229.google.com [IPv6:2a00:1450:4010:c07::229]) by gabe.freedesktop.org (Postfix) with ESMTPS id 18A566E340 for ; Wed, 21 Mar 2018 14:58:27 +0000 (UTC) Received: by mail-lf0-x229.google.com with SMTP id z143-v6so8327750lff.3 for ; Wed, 21 Mar 2018 07:58:27 -0700 (PDT) In-Reply-To: <1521644293-14612-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 ZjAyMDZlYzFhMWNjOTtoYj1yZWZzL2hlYWRzL21hc3RlciNsMTI1NwoKU2lnbmVkLW9mZi1ieTog T2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29t PgotLS0KIERvY3VtZW50YXRpb24vZ3B1L2RyaXZlcnMucnN0ICAgICAgICAgICAgICAgfCAgIDEg KwogRG9jdW1lbnRhdGlvbi9ncHUveGVuLWZyb250LnJzdCAgICAgICAgICAgICB8ICA0MyArKwog ZHJpdmVycy9ncHUvZHJtL0tjb25maWcgICAgICAgICAgICAgICAgICAgICB8ICAgMiArCiBkcml2 ZXJzL2dwdS9kcm0vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMv Z3B1L2RybS94ZW4vS2NvbmZpZyAgICAgICAgICAgICAgICAgfCAgMzAgKwogZHJpdmVycy9ncHUv ZHJtL3hlbi9NYWtlZmlsZSAgICAgICAgICAgICAgICB8ICAxNiArCiBkcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnQuYyAgICAgICAgIHwgODMzICsrKysrKysrKysrKysrKysrKysrKysr KysrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oICAgICAgICAgfCAxOTgg KysrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2NmZy5jICAgICB8ICA3 NyArKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcuaCAgICAgfCAgMzcg KysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmMgICAgfCAxNDUgKysr KysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmggICAgfCAgMjcgKwog ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYyB8IDM4MyArKysrKysr KysrKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oIHwgIDgx ICsrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jICAgICB8IDMzMyAr KysrKysrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5oICAgICB8 ICA0MSArKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYyB8ICA3 MyArKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYyAgICAgfCAzMjMg KysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuaCAgICAg fCAgMjggKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmMgICB8IDQz MiArKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1 Zi5oICAgfCAgNzIgKysrCiAyMSBmaWxlcyBjaGFuZ2VkLCAzMTc2IGluc2VydGlvbnMoKykKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2dwdS94ZW4tZnJvbnQucnN0CiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi9LY29uZmlnCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uaAogY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmMKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5o CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dl bS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 X2dlbS5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250X2dlbV9jbWEuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVu X2RybV9mcm9udF9rbXMuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udF9rbXMuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUv ZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmgKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9u L2dwdS9kcml2ZXJzLnJzdCBiL0RvY3VtZW50YXRpb24vZ3B1L2RyaXZlcnMucnN0CmluZGV4IGU4 Yzg0NDE5YTJhMS4uZDNhYjZhYmFlODM4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dwdS9k cml2ZXJzLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcml2ZXJzLnJzdApAQCAtMTIsNiAr MTIsNyBAQCBHUFUgRHJpdmVyIERvY3VtZW50YXRpb24KICAgIHR2ZTIwMAogICAgdmM0CiAgICBi cmlkZ2UvZHctaGRtaQorICAgeGVuLWZyb250CiAKIC4uIG9ubHk6OiAgc3VicHJvamVjdCBhbmQg aHRtbAogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS94ZW4tZnJvbnQucnN0IGIvRG9j dW1lbnRhdGlvbi9ncHUveGVuLWZyb250LnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLjgxODhlMDNjOWQyMwotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRp b24vZ3B1L3hlbi1mcm9udC5yc3QKQEAgLTAsMCArMSw0MyBAQAorPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09CitYZW4gcGFyYS12aXJ0dWFsaXplZCBmcm9udGVuZCBkcml2ZXIK Kz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCitUaGlzIGZyb250ZW5kIGRy aXZlciBpbXBsZW1lbnRzIFhlbiBwYXJhLXZpcnR1YWxpemVkIGRpc3BsYXkKK2FjY29yZGluZyB0 byB0aGUgZGlzcGxheSBwcm90b2NvbCBkZXNjcmliZWQgYXQKK2luY2x1ZGUveGVuL2ludGVyZmFj ZS9pby9kaXNwbGlmLmgKKworRHJpdmVyIG1vZGVzIG9mIG9wZXJhdGlvbiBpbiB0ZXJtcyBvZiBk aXNwbGF5IGJ1ZmZlcnMgdXNlZAorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250LmgKKyAgIDpkb2M6IERyaXZlciBtb2RlcyBvZiBvcGVyYXRpb24g aW4gdGVybXMgb2YgZGlzcGxheSBidWZmZXJzIHVzZWQKKworQnVmZmVycyBhbGxvY2F0ZWQgYnkg dGhlIGZyb250ZW5kIGRyaXZlcgorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 LmgKKyAgIDpkb2M6IEJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBmcm9udGVuZCBkcml2ZXIKKwor V2l0aCBHRU0gQ01BIGhlbHBlcnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1k b2M6OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAgOmRvYzogV2l0aCBH RU0gQ01BIGhlbHBlcnMKKworV2l0aG91dCBHRU0gQ01BIGhlbHBlcnMKK35+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnQuaAorICAgOmRvYzogV2l0aG91dCBHRU0gQ01BIGhlbHBlcnMKKworQnVmZmVycyBhbGxv Y2F0ZWQgYnkgdGhlIGJhY2tlbmQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisK Ky4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAg OmRvYzogQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tlbmQKKworRHJpdmVyIGxpbWl0YXRp b25zCis9PT09PT09PT09PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udC5oCisgICA6ZG9jOiBEcml2ZXIgbGltaXRhdGlvbnMKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcK aW5kZXggZGVlZWZhN2ExNzczLi43NTc4MjVhYzYwZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9LY29uZmlnCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCkBAIC0yODksNiArMjg5 LDggQEAgc291cmNlICJkcml2ZXJzL2dwdS9kcm0vcGwxMTEvS2NvbmZpZyIKIAogc291cmNlICJk cml2ZXJzL2dwdS9kcm0vdHZlMjAwL0tjb25maWciCiAKK3NvdXJjZSAiZHJpdmVycy9ncHUvZHJt L3hlbi9LY29uZmlnIgorCiAjIEtlZXAgbGVnYWN5IGRyaXZlcnMgbGFzdAogCiBtZW51Y29uZmln IERSTV9MRUdBQ1kKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZl cnMvZ3B1L2RybS9NYWtlZmlsZQppbmRleCA1MDA5M2ZmNDQ3OWIuLjlkNjY2NTdlYTExNyAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9N YWtlZmlsZQpAQCAtMTAzLDMgKzEwMyw0IEBAIG9iai0kKENPTkZJR19EUk1fTVhTRkIpCSs9IG14 c2ZiLwogb2JqLSQoQ09ORklHX0RSTV9USU5ZRFJNKSArPSB0aW55ZHJtLwogb2JqLSQoQ09ORklH X0RSTV9QTDExMSkgKz0gcGwxMTEvCiBvYmotJChDT05GSUdfRFJNX1RWRTIwMCkgKz0gdHZlMjAw Lworb2JqLSQoQ09ORklHX0RSTV9YRU4pICs9IHhlbi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS94ZW4vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjRmNGFiYzkxZjNiNgotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwpAQCAtMCwwICsxLDMwIEBACitjb25m aWcgRFJNX1hFTgorCWJvb2wgIkRSTSBTdXBwb3J0IGZvciBYZW4gZ3Vlc3QgT1MiCisJZGVwZW5k cyBvbiBYRU4KKwloZWxwCisJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5h YmxlIERSTSBzdXBwb3J0CisJICBmb3IgWGVuLgorCitjb25maWcgRFJNX1hFTl9GUk9OVEVORAor CXRyaXN0YXRlICJQYXJhLXZpcnR1YWxpemVkIGZyb250ZW5kIGRyaXZlciBmb3IgWGVuIGd1ZXN0 IE9TIgorCWRlcGVuZHMgb24gRFJNX1hFTgorCWRlcGVuZHMgb24gRFJNCisJc2VsZWN0IERSTV9L TVNfSEVMUEVSCisJc2VsZWN0IFZJREVPTU9ERV9IRUxQRVJTCisJc2VsZWN0IFhFTl9YRU5CVVNf RlJPTlRFTkQKKwloZWxwCisJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5h YmxlIGEgcGFyYS12aXJ0dWFsaXplZAorCSAgZnJvbnRlbmQgRFJNL0tNUyBkcml2ZXIgZm9yIFhl biBndWVzdCBPU2VzLgorCitjb25maWcgRFJNX1hFTl9GUk9OVEVORF9DTUEKKwlib29sICJVc2Ug RFJNIENNQSB0byBhbGxvY2F0ZSBkdW1iIGJ1ZmZlcnMiCisJZGVwZW5kcyBvbiBEUk1fWEVOX0ZS T05URU5ECisJc2VsZWN0IERSTV9LTVNfQ01BX0hFTFBFUgorCXNlbGVjdCBEUk1fR0VNX0NNQV9I RUxQRVIKKwloZWxwCisJICBVc2UgRFJNIENNQSBoZWxwZXJzIHRvIGFsbG9jYXRlIGRpc3BsYXkg YnVmZmVycy4KKwkgIFRoaXMgaXMgdXNlZnVsIGZvciB0aGUgdXNlLWNhc2VzIHdoZW4gZ3Vlc3Qg ZHJpdmVyIG5lZWRzIHRvCisJICBzaGFyZSBvciBleHBvcnQgYnVmZmVycyB0byBvdGhlciBkcml2 ZXJzIHdoaWNoIG9ubHkgZXhwZWN0CisJICBjb250aWd1b3VzIGJ1ZmZlcnMuCisJICBOb3RlOiBp biB0aGlzIG1vZGUgZHJpdmVyIGNhbm5vdCB1c2UgYnVmZmVycyBhbGxvY2F0ZWQKKwkgIGJ5IHRo ZSBiYWNrZW5kLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSBiL2Ry aXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi4zNTI3MzBkYzZjMTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9k cm0veGVuL01ha2VmaWxlCkBAIC0wLDAgKzEsMTYgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAgT1IgTUlUCisKK2RybV94ZW5fZnJvbnQtb2JqcyA6PSB4ZW5fZHJtX2Zyb250 Lm8gXAorCQkgICAgICB4ZW5fZHJtX2Zyb250X2ttcy5vIFwKKwkJICAgICAgeGVuX2RybV9mcm9u dF9jb25uLm8gXAorCQkgICAgICB4ZW5fZHJtX2Zyb250X2V2dGNobmwubyBcCisJCSAgICAgIHhl bl9kcm1fZnJvbnRfc2hidWYubyBcCisJCSAgICAgIHhlbl9kcm1fZnJvbnRfY2ZnLm8KKworaWZl cSAoJChDT05GSUdfRFJNX1hFTl9GUk9OVEVORF9DTUEpLHkpCisJZHJtX3hlbl9mcm9udC1vYmpz ICs9IHhlbl9kcm1fZnJvbnRfZ2VtX2NtYS5vCitlbHNlCisJZHJtX3hlbl9mcm9udC1vYmpzICs9 IHhlbl9kcm1fZnJvbnRfZ2VtLm8KK2VuZGlmCisKK29iai0kKENPTkZJR19EUk1fWEVOX0ZST05U RU5EKSArPSBkcm1feGVuX2Zyb250Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udC5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xM2EzYTU4YzczOTcKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwpAQCAtMCww ICsxLDgzMyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisK Ky8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChD KSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBB bmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisj aW5jbHVkZSA8ZHJtL2RybVAuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4K KyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0u aD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+CisKKyNpbmNsdWRlIDxsaW51 eC9vZl9kZXZpY2UuaD4KKworI2luY2x1ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4KKyNpbmNsdWRl IDx4ZW4veGVuLmg+CisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorCisjaW5jbHVkZSA8eGVuL2lu dGVyZmFjZS9pby9kaXNwbGlmLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5j bHVkZSAieGVuX2RybV9mcm9udF9jZmcuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2V2dGNo bmwuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorI2luY2x1ZGUgInhlbl9kcm1f ZnJvbnRfa21zLmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgorCitzdHJ1Y3Qg 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 CW11dGV4X2xvY2soJmV2dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19p cnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9y ZXEoZXZ0Y2hubCwgWEVORElTUExfT1BfU0VUX0NPTkZJRyk7CisJcmVxLT5vcC5zZXRfY29uZmln LnggPSB4OworCXJlcS0+b3Auc2V0X2NvbmZpZy55ID0geTsKKwlyZXEtPm9wLnNldF9jb25maWcu d2lkdGggPSB3aWR0aDsKKwlyZXEtPm9wLnNldF9jb25maWcuaGVpZ2h0ID0gaGVpZ2h0OworCXJl cS0+b3Auc2V0X2NvbmZpZy5icHAgPSBicHA7CisJcmVxLT5vcC5zZXRfY29uZmlnLmZiX2Nvb2tp ZSA9IGZiX2Nvb2tpZTsKKworCXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOwor CXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwor CWlmIChyZXQgPT0gMCkKKwkJcmV0ID0gYmVfc3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7CisKKwlt dXRleF91bmxvY2soJmV2dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gcmV0Owor fQorCitzdGF0aWMgaW50IGJlX2RidWZfY3JlYXRlX2ludChzdHJ1Y3QgeGVuX2RybV9mcm9udF9p bmZvICpmcm9udF9pbmZvLAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgs IHVpbnQzMl90IGhlaWdodCwKKwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBzdHJ1Y3Qg cGFnZSAqKnBhZ2VzLAorCQlzdHJ1Y3Qgc2dfdGFibGUgKnNndCkKK3sKKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpz aGJ1ZjsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWZfY2ZnIGJ1Zl9jZmc7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0OworCisJ ZXZ0Y2hubCA9ICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbR0VORVJJQ19PUF9FVlRfQ0hOTF0ucmVx OworCWlmICh1bmxpa2VseSghZXZ0Y2hubCkpCisJCXJldHVybiAtRUlPOworCisJbWVtc2V0KCZi dWZfY2ZnLCAwLCBzaXplb2YoYnVmX2NmZykpOworCWJ1Zl9jZmcueGJfZGV2ID0gZnJvbnRfaW5m by0+eGJfZGV2OworCWJ1Zl9jZmcucGFnZXMgPSBwYWdlczsKKwlidWZfY2ZnLnNpemUgPSBzaXpl OworCWJ1Zl9jZmcuc2d0ID0gc2d0OworCWJ1Zl9jZmcuYmVfYWxsb2MgPSBmcm9udF9pbmZvLT5j ZmcuYmVfYWxsb2M7CisKKwlzaGJ1ZiA9IHhlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2MoJmJ1Zl9j ZmcpOworCWlmICghc2hidWYpCisJCXJldHVybiAtRU5PTUVNOworCisJcmV0ID0gZGJ1Zl9hZGRf dG9fbGlzdChmcm9udF9pbmZvLCBzaGJ1ZiwgZGJ1Zl9jb29raWUpOworCWlmIChyZXQgPCAwKSB7 CisJCXhlbl9kcm1fZnJvbnRfc2hidWZfZnJlZShzaGJ1Zik7CisJCXJldHVybiByZXQ7CisJfQor CisJbXV0ZXhfbG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2Nr X2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJl X3JlcShldnRjaG5sLCBYRU5ESVNQTF9PUF9EQlVGX0NSRUFURSk7CisJcmVxLT5vcC5kYnVmX2Ny ZWF0ZS5ncmVmX2RpcmVjdG9yeSA9CisJCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2dldF9kaXJfc3Rh cnQoc2hidWYpOworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUuYnVmZmVyX3N6ID0gc2l6ZTsKKwlyZXEt Pm9wLmRidWZfY3JlYXRlLmRidWZfY29va2llID0gZGJ1Zl9jb29raWU7CisJcmVxLT5vcC5kYnVm X2NyZWF0ZS53aWR0aCA9IHdpZHRoOworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUuaGVpZ2h0ID0gaGVp Z2h0OworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUuYnBwID0gYnBwOworCWlmIChidWZfY2ZnLmJlX2Fs bG9jKQorCQlyZXEtPm9wLmRidWZfY3JlYXRlLmZsYWdzIHw9IFhFTkRJU1BMX0RCVUZfRkxHX1JF UV9BTExPQzsKKworCXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChy ZXQgPCAwKQorCQlnb3RvIGZhaWw7CisKKwlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5s KTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0geGVuX2RybV9mcm9udF9z aGJ1Zl9tYXAoc2hidWYpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CisKKwltdXRleF91 bmxvY2soJmV2dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gMDsKKworZmFpbDoK KwltdXRleF91bmxvY2soJmV2dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwlkYnVmX2ZyZWUo JmZyb250X2luZm8tPmRidWZfbGlzdCwgZGJ1Zl9jb29raWUpOworCXJldHVybiByZXQ7Cit9CisK K2ludCB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4ZW5fZHJtX2Zy b250X2luZm8gKmZyb250X2luZm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llLCB1aW50MzJfdCB3 aWR0aCwgdWludDMyX3QgaGVpZ2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90IHNpemUsIHN0 cnVjdCBzZ190YWJsZSAqc2d0KQoreworCXJldHVybiBiZV9kYnVmX2NyZWF0ZV9pbnQoZnJvbnRf aW5mbywgZGJ1Zl9jb29raWUsIHdpZHRoLCBoZWlnaHQsCisJCQlicHAsIHNpemUsIE5VTEwsIHNn dCk7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fcGFnZXMoc3RydWN0 IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJdWludDY0X3QgZGJ1Zl9jb29raWUs IHVpbnQzMl90IHdpZHRoLCB1aW50MzJfdCBoZWlnaHQsCisJCXVpbnQzMl90IGJwcCwgdWludDY0 X3Qgc2l6ZSwgc3RydWN0IHBhZ2UgKipwYWdlcykKK3sKKwlyZXR1cm4gYmVfZGJ1Zl9jcmVhdGVf aW50KGZyb250X2luZm8sIGRidWZfY29va2llLCB3aWR0aCwgaGVpZ2h0LAorCQkJYnBwLCBzaXpl LCBwYWdlcywgTlVMTCk7Cit9CisKK3N0YXRpYyBpbnQgeGVuX2RybV9mcm9udF9kYnVmX2Rlc3Ry b3koc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJdWludDY0X3QgZGJ1 Zl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlz dHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlib29sIGJl X2FsbG9jOworCWludCByZXQ7CisKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tH RU5FUklDX09QX0VWVF9DSE5MXS5yZXE7CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0 dXJuIC1FSU87CisKKwliZV9hbGxvYyA9IGZyb250X2luZm8tPmNmZy5iZV9hbGxvYzsKKworCS8q CisJICogRm9yIHRoZSBiYWNrZW5kIGFsbG9jYXRlZCBidWZmZXIgcmVsZWFzZSByZWZlcmVuY2Vz IG5vdywgc28gYmFja2VuZAorCSAqIGNhbiBmcmVlIHRoZSBidWZmZXIuCisJICovCisJaWYgKGJl X2FsbG9jKQorCQlkYnVmX2ZyZWUoJmZyb250X2luZm8tPmRidWZfbGlzdCwgZGJ1Zl9jb29raWUp OworCisJbXV0ZXhfbG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9s b2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVw YXJlX3JlcShldnRjaG5sLCBYRU5ESVNQTF9PUF9EQlVGX0RFU1RST1kpOworCXJlcS0+b3AuZGJ1 Zl9kZXN0cm95LmRidWZfY29va2llID0gZGJ1Zl9jb29raWU7CisKKwlyZXQgPSBiZV9zdHJlYW1f ZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZv LT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IGJlX3N0cmVhbV93 YWl0X2lvKGV2dGNobmwpOworCisJLyoKKwkgKiBEbyB0aGlzIHJlZ2FyZGxlc3Mgb2YgY29tbXVu aWNhdGlvbiBzdGF0dXMgd2l0aCB0aGUgYmFja2VuZDoKKwkgKiBpZiB3ZSBjYW5ub3QgcmVtb3Zl IHJlbW90ZSByZXNvdXJjZXMgcmVtb3ZlIHdoYXQgd2UgY2FuIGxvY2FsbHkuCisJICovCisJaWYg KCFiZV9hbGxvYykKKwkJZGJ1Zl9mcmVlKCZmcm9udF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29v a2llKTsKKworCW11dGV4X3VubG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCXJl dHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2ZiX2F0dGFjaChzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDY0 X3QgZmJfY29va2llLCB1aW50MzJfdCB3aWR0aCwKKwkJdWludDMyX3QgaGVpZ2h0LCB1aW50MzJf dCBwaXhlbF9mb3JtYXQpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hu bDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kYnVmICpidWY7CisJc3RydWN0IHhlbmRpc3BsX3Jl cSAqcmVxOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IHJldDsKKworCWV2dGNobmwgPSAm ZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW0dFTkVSSUNfT1BfRVZUX0NITkxdLnJlcTsKKwlpZiAodW5s aWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJTzsKKworCWJ1ZiA9IGRidWZfZ2V0KCZmcm9u dF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2llKTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuIC1F SU5WQUw7CisKKwlidWYtPmZiX2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKworCW11dGV4X2xvY2soJmV2 dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9p bmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVO RElTUExfT1BfRkJfQVRUQUNIKTsKKwlyZXEtPm9wLmZiX2F0dGFjaC5kYnVmX2Nvb2tpZSA9IGRi dWZfY29va2llOworCXJlcS0+b3AuZmJfYXR0YWNoLmZiX2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKwly ZXEtPm9wLmZiX2F0dGFjaC53aWR0aCA9IHdpZHRoOworCXJlcS0+b3AuZmJfYXR0YWNoLmhlaWdo dCA9IGhlaWdodDsKKwlyZXEtPm9wLmZiX2F0dGFjaC5waXhlbF9mb3JtYXQgPSBwaXhlbF9mb3Jt YXQ7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3VubG9j a19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0ID09 IDApCisJCXJldCA9IGJlX3N0cmVhbV93YWl0X2lvKGV2dGNobmwpOworCisJbXV0ZXhfdW5sb2Nr KCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisJcmV0dXJuIHJldDsKK30KKworaW50IHhl bl9kcm1fZnJvbnRfZmJfZGV0YWNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8sCisJCXVpbnQ2NF90IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRj aG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25n IGZsYWdzOworCWludCByZXQ7CisKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tH RU5FUklDX09QX0VWVF9DSE5MXS5yZXE7CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0 dXJuIC1FSU87CisKKwltdXRleF9sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisK KwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJlcSA9 IGJlX3ByZXBhcmVfcmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX0ZCX0RFVEFDSCk7CisJcmVxLT5v cC5mYl9kZXRhY2guZmJfY29va2llID0gZmJfY29va2llOworCisJcmV0ID0gYmVfc3RyZWFtX2Rv X2lvKGV2dGNobmwsIHJlcSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+ aW9fbG9jaywgZmxhZ3MpOworCisJaWYgKHJldCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2Fp dF9pbyhldnRjaG5sKTsKKworCW11dGV4X3VubG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xv Y2spOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X3BhZ2VfZmxpcChzdHJ1 Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQlpbnQgY29ubl9pZHgsIHVpbnQ2 NF90IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5s OworCXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWlu dCByZXQ7CisKKwlpZiAodW5saWtlbHkoY29ubl9pZHggPj0gZnJvbnRfaW5mby0+bnVtX2V2dF9w YWlycykpCisJCXJldHVybiAtRUlOVkFMOworCisJZGJ1Zl9mbHVzaF9mYigmZnJvbnRfaW5mby0+ ZGJ1Zl9saXN0LCBmYl9jb29raWUpOworCWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJz W2Nvbm5faWR4XS5yZXE7CisKKwltdXRleF9sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9j ayk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOwor CXJlcSA9IGJlX3ByZXBhcmVfcmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX1BHX0ZMSVApOworCXJl cS0+b3AucGdfZmxpcC5mYl9jb29raWUgPSBmYl9jb29raWU7CisKKwlyZXQgPSBiZV9zdHJlYW1f ZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZv LT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IGJlX3N0cmVhbV93 YWl0X2lvKGV2dGNobmwpOworCisJbXV0ZXhfdW5sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9f bG9jayk7CisJcmV0dXJuIHJldDsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X29uX2ZyYW1lX2Rv bmUoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJaW50IGNvbm5faWR4 LCB1aW50NjRfdCBmYl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8g KmRybV9pbmZvID0gZnJvbnRfaW5mby0+ZHJtX2luZm87CisKKwlpZiAodW5saWtlbHkoY29ubl9p ZHggPj0gZnJvbnRfaW5mby0+Y2ZnLm51bV9jb25uZWN0b3JzKSkKKwkJcmV0dXJuOworCisJeGVu X2RybV9mcm9udF9rbXNfb25fZnJhbWVfZG9uZSgmZHJtX2luZm8tPnBpcGVsaW5lW2Nvbm5faWR4 XSwKKwkJCWZiX2Nvb2tpZSk7Cit9CisKK3N0YXRpYyBpbnQgeGVuX2RybV9kcnZfZHVtYl9jcmVh dGUoc3RydWN0IGRybV9maWxlICpmaWxwLAorCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1 Y3QgZHJtX21vZGVfY3JlYXRlX2R1bWIgKmFyZ3MpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRf ZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgZHJtX2dlbV9v YmplY3QgKm9iajsKKwlpbnQgcmV0OworCisJcmV0ID0geGVuX2RybV9mcm9udF9nZW1fZHVtYl9j cmVhdGUoZmlscCwgZGV2LCBhcmdzKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWw7CisKKwlvYmog PSBkcm1fZ2VtX29iamVjdF9sb29rdXAoZmlscCwgYXJncy0+aGFuZGxlKTsKKwlpZiAoIW9iaikg eworCQlyZXQgPSAtRU5PRU5UOworCQlnb3RvIGZhaWxfZGVzdHJveTsKKwl9CisKKwlkcm1fZ2Vt X29iamVjdF91bnJlZmVyZW5jZV91bmxvY2tlZChvYmopOworCisJLyoKKwkgKiBJbiBjYXNlIG9m IENPTkZJR19EUk1fWEVOX0ZST05URU5EX0NNQSBnZW1fb2JqIGlzIGNvbnN0cnVjdGVkCisJICog dmlhIERSTSBDTUEgaGVscGVycyBhbmQgZG9lc24ndCBoYXZlIC0+cGFnZXMgYWxsb2NhdGVkCisJ ICogKHhlbmRybV9nZW1fZ2V0X3BhZ2VzIHdpbGwgcmV0dXJuIE5VTEwpLCBidXQgaW5zdGVhZCBj YW4gcHJvdmlkZQorCSAqIHNnIHRhYmxlCisJICovCisJaWYgKHhlbl9kcm1fZnJvbnRfZ2VtX2dl dF9wYWdlcyhvYmopKQorCQlyZXQgPSB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fcGFn ZXMoCisJCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9kYnVmX3Rv X2Nvb2tpZShvYmopLAorCQkJCWFyZ3MtPndpZHRoLCBhcmdzLT5oZWlnaHQsIGFyZ3MtPmJwcCwK KwkJCQlhcmdzLT5zaXplLAorCQkJCXhlbl9kcm1fZnJvbnRfZ2VtX2dldF9wYWdlcyhvYmopKTsK KwllbHNlCisJCXJldCA9IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9zZ3QoCisJCQkJ ZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShv YmopLAorCQkJCWFyZ3MtPndpZHRoLCBhcmdzLT5oZWlnaHQsIGFyZ3MtPmJwcCwKKwkJCQlhcmdz LT5zaXplLAorCQkJCXhlbl9kcm1fZnJvbnRfZ2VtX2dldF9zZ190YWJsZShvYmopKTsKKwlpZiAo cmV0KQorCQlnb3RvIGZhaWxfZGVzdHJveTsKKworCXJldHVybiAwOworCitmYWlsX2Rlc3Ryb3k6 CisJZHJtX2dlbV9kdW1iX2Rlc3Ryb3koZmlscCwgZGV2LCBhcmdzLT5oYW5kbGUpOworZmFpbDoK KwlEUk1fRVJST1IoIkZhaWxlZCB0byBjcmVhdGUgZHVtYiBidWZmZXI6ICVkXG4iLCByZXQpOwor CXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIHhlbl9kcm1fZHJ2X2ZyZWVfb2JqZWN0KHN0 cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9p bmZvICpkcm1faW5mbyA9IG9iai0+ZGV2LT5kZXZfcHJpdmF0ZTsKKworCXhlbl9kcm1fZnJvbnRf ZGJ1Zl9kZXN0cm95KGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJeGVuX2RybV9mcm9udF9kYnVm X3RvX2Nvb2tpZShvYmopKTsKKwl4ZW5fZHJtX2Zyb250X2dlbV9mcmVlX29iamVjdChvYmopOwor fQorCitzdGF0aWMgdm9pZCB4ZW5fZHJtX2Rydl9yZWxlYXNlKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5k ZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvID0gZHJt X2luZm8tPmZyb250X2luZm87CisKKwlkcm1fYXRvbWljX2hlbHBlcl9zaHV0ZG93bihkZXYpOwor CWRybV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRldik7CisKKwl4ZW5fZHJtX2Zyb250X2V2dGNobmxf ZnJlZV9hbGwoZnJvbnRfaW5mbyk7CisJZGJ1Zl9mcmVlX2FsbCgmZnJvbnRfaW5mby0+ZGJ1Zl9s aXN0KTsKKworCWRybV9kZXZfZmluaShkZXYpOworCWtmcmVlKGRldik7CisKKwkvKgorCSAqIEZy ZWUgbm93LCBhcyB0aGlzIHJlbGVhc2UgY291bGQgYmUgbm90IGR1ZSB0byBybW1vZCwgYnV0CisJ ICogZHVlIHRvIHRoZSBiYWNrZW5kIGRpc2Nvbm5lY3QsIG1ha2luZyBkcm1faW5mbyBoYW5nIGlu CisJICogbWVtb3J5IHVudGlsIHJtbW9kCisJICovCisJZGV2bV9rZnJlZSgmZnJvbnRfaW5mby0+ eGJfZGV2LT5kZXYsIGZyb250X2luZm8tPmRybV9pbmZvKTsKKwlmcm9udF9pbmZvLT5kcm1faW5m byA9IE5VTEw7CisKKwkvKiBUZWxsIHRoZSBiYWNrZW5kIHdlIGFyZSByZWFkeSB0byAocmUpaW5p dGlhbGl6ZSAqLworCXhlbmJ1c19zd2l0Y2hfc3RhdGUoZnJvbnRfaW5mby0+eGJfZGV2LCBYZW5i dXNTdGF0ZUluaXRpYWxpc2luZyk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVy YXRpb25zIHhlbl9kcm1fZGV2X2ZvcHMgPSB7CisJLm93bmVyICAgICAgICAgID0gVEhJU19NT0RV TEUsCisJLm9wZW4gICAgICAgICAgID0gZHJtX29wZW4sCisJLnJlbGVhc2UgICAgICAgID0gZHJt X3JlbGVhc2UsCisJLnVubG9ja2VkX2lvY3RsID0gZHJtX2lvY3RsLAorI2lmZGVmIENPTkZJR19D T01QQVQKKwkuY29tcGF0X2lvY3RsICAgPSBkcm1fY29tcGF0X2lvY3RsLAorI2VuZGlmCisJLnBv bGwgICAgICAgICAgID0gZHJtX3BvbGwsCisJLnJlYWQgICAgICAgICAgID0gZHJtX3JlYWQsCisJ Lmxsc2VlayAgICAgICAgID0gbm9fbGxzZWVrLAorI2lmZGVmIENPTkZJR19EUk1fWEVOX0ZST05U RU5EX0NNQQorCS5tbWFwICAgICAgICAgICA9IGRybV9nZW1fY21hX21tYXAsCisjZWxzZQorCS5t bWFwICAgICAgICAgICA9IHhlbl9kcm1fZnJvbnRfZ2VtX21tYXAsCisjZW5kaWYKK307CisKK3N0 YXRpYyBjb25zdCBzdHJ1Y3Qgdm1fb3BlcmF0aW9uc19zdHJ1Y3QgeGVuX2RybV9kcnZfdm1fb3Bz ID0geworCS5vcGVuICAgICAgICAgICA9IGRybV9nZW1fdm1fb3BlbiwKKwkuY2xvc2UgICAgICAg ICAgPSBkcm1fZ2VtX3ZtX2Nsb3NlLAorfTsKKworc3RhdGljIHN0cnVjdCBkcm1fZHJpdmVyIHhl bl9kcm1fZHJpdmVyID0geworCS5kcml2ZXJfZmVhdHVyZXMgICAgICAgICAgID0gRFJJVkVSX0dF TSB8IERSSVZFUl9NT0RFU0VUIHwKKwkJCQkgICAgIERSSVZFUl9QUklNRSB8IERSSVZFUl9BVE9N SUMsCisJLnJlbGVhc2UgICAgICAgICAgICAgICAgICAgPSB4ZW5fZHJtX2Rydl9yZWxlYXNlLAor CS5nZW1fdm1fb3BzICAgICAgICAgICAgICAgID0gJnhlbl9kcm1fZHJ2X3ZtX29wcywKKwkuZ2Vt X2ZyZWVfb2JqZWN0X3VubG9ja2VkICA9IHhlbl9kcm1fZHJ2X2ZyZWVfb2JqZWN0LAorCS5wcmlt ZV9oYW5kbGVfdG9fZmQgICAgICAgID0gZHJtX2dlbV9wcmltZV9oYW5kbGVfdG9fZmQsCisJLnBy aW1lX2ZkX3RvX2hhbmRsZSAgICAgICAgPSBkcm1fZ2VtX3ByaW1lX2ZkX3RvX2hhbmRsZSwKKwku Z2VtX3ByaW1lX2ltcG9ydCAgICAgICAgICA9IGRybV9nZW1fcHJpbWVfaW1wb3J0LAorCS5nZW1f cHJpbWVfZXhwb3J0ICAgICAgICAgID0gZHJtX2dlbV9wcmltZV9leHBvcnQsCisJLmdlbV9wcmlt ZV9pbXBvcnRfc2dfdGFibGUgPSB4ZW5fZHJtX2Zyb250X2dlbV9pbXBvcnRfc2dfdGFibGUsCisJ LmdlbV9wcmltZV9nZXRfc2dfdGFibGUgICAgPSB4ZW5fZHJtX2Zyb250X2dlbV9nZXRfc2dfdGFi bGUsCisJLmR1bWJfY3JlYXRlICAgICAgICAgICAgICAgPSB4ZW5fZHJtX2Rydl9kdW1iX2NyZWF0 ZSwKKwkuZm9wcyAgICAgICAgICAgICAgICAgICAgICA9ICZ4ZW5fZHJtX2Rldl9mb3BzLAorCS5u YW1lICAgICAgICAgICAgICAgICAgICAgID0gInhlbmRybS1kdSIsCisJLmRlc2MgICAgICAgICAg ICAgICAgICAgICAgPSAiWGVuIFBWIERSTSBEaXNwbGF5IFVuaXQiLAorCS5kYXRlICAgICAgICAg ICAgICAgICAgICAgID0gIjIwMTgwMjIxIiwKKwkubWFqb3IgICAgICAgICAgICAgICAgICAgICA9 IDEsCisJLm1pbm9yICAgICAgICAgICAgICAgICAgICAgPSAwLAorCisjaWZkZWYgQ09ORklHX0RS TV9YRU5fRlJPTlRFTkRfQ01BCisJLmdlbV9wcmltZV92bWFwICAgICAgICAgICAgPSBkcm1fZ2Vt X2NtYV9wcmltZV92bWFwLAorCS5nZW1fcHJpbWVfdnVubWFwICAgICAgICAgID0gZHJtX2dlbV9j bWFfcHJpbWVfdnVubWFwLAorCS5nZW1fcHJpbWVfbW1hcCAgICAgICAgICAgID0gZHJtX2dlbV9j bWFfcHJpbWVfbW1hcCwKKyNlbHNlCisJLmdlbV9wcmltZV92bWFwICAgICAgICAgICAgPSB4ZW5f ZHJtX2Zyb250X2dlbV9wcmltZV92bWFwLAorCS5nZW1fcHJpbWVfdnVubWFwICAgICAgICAgID0g eGVuX2RybV9mcm9udF9nZW1fcHJpbWVfdnVubWFwLAorCS5nZW1fcHJpbWVfbW1hcCAgICAgICAg ICAgID0geGVuX2RybV9mcm9udF9nZW1fcHJpbWVfbW1hcCwKKyNlbmRpZgorfTsKKworc3RhdGlj IGludCB4ZW5fZHJtX2Rydl9pbml0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8pCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmZyb250X2luZm8tPnhiX2Rldi0+ZGV2Owor CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbzsKKwlzdHJ1Y3QgZHJtX2Rl dmljZSAqZHJtX2RldjsKKwlpbnQgcmV0OworCisJRFJNX0lORk8oIkNyZWF0aW5nICVzXG4iLCB4 ZW5fZHJtX2RyaXZlci5kZXNjKTsKKworCWRybV9pbmZvID0gZGV2bV9remFsbG9jKGRldiwgc2l6 ZW9mKCpkcm1faW5mbyksIEdGUF9LRVJORUwpOworCWlmICghZHJtX2luZm8pCisJCXJldHVybiAt RU5PTUVNOworCisJZHJtX2luZm8tPmZyb250X2luZm8gPSBmcm9udF9pbmZvOworCWZyb250X2lu Zm8tPmRybV9pbmZvID0gZHJtX2luZm87CisKKwlkcm1fZGV2ID0gZHJtX2Rldl9hbGxvYygmeGVu X2RybV9kcml2ZXIsIGRldik7CisJaWYgKCFkcm1fZGV2KQorCQlyZXR1cm4gLUVOT01FTTsKKwor CWRybV9pbmZvLT5kcm1fZGV2ID0gZHJtX2RldjsKKworCWRybV9kZXYtPmRldl9wcml2YXRlID0g ZHJtX2luZm87CisKKwlyZXQgPSB4ZW5fZHJtX2Zyb250X2ttc19pbml0KGRybV9pbmZvKTsKKwlp ZiAocmV0KSB7CisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGluaXRpYWxpemUgRFJNL0tNUywgcmV0 ICVkXG4iLCByZXQpOworCQlnb3RvIGZhaWxfbW9kZXNldDsKKwl9CisKKwlyZXQgPSBkcm1fZGV2 X3JlZ2lzdGVyKGRybV9kZXYsIDApOworCWlmIChyZXQpCisJCWdvdG8gZmFpbF9yZWdpc3RlcjsK KworCURSTV9JTkZPKCJJbml0aWFsaXplZCAlcyAlZC4lZC4lZCAlcyBvbiBtaW5vciAlZFxuIiwK KwkJCXhlbl9kcm1fZHJpdmVyLm5hbWUsIHhlbl9kcm1fZHJpdmVyLm1ham9yLAorCQkJeGVuX2Ry bV9kcml2ZXIubWlub3IsIHhlbl9kcm1fZHJpdmVyLnBhdGNobGV2ZWwsCisJCQl4ZW5fZHJtX2Ry aXZlci5kYXRlLCBkcm1fZGV2LT5wcmltYXJ5LT5pbmRleCk7CisKKwlyZXR1cm4gMDsKKworZmFp bF9yZWdpc3RlcjoKKwlkcm1fZGV2X3VucmVnaXN0ZXIoZHJtX2Rldik7CitmYWlsX21vZGVzZXQ6 CisJZHJtX2ttc19oZWxwZXJfcG9sbF9maW5pKGRybV9kZXYpOworCWRybV9tb2RlX2NvbmZpZ19j bGVhbnVwKGRybV9kZXYpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIHhlbl9kcm1f ZHJ2X2Zpbmkoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBmcm9udF9pbmZvLT5kcm1faW5m bzsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2OworCisJaWYgKCFkcm1faW5mbykKKwkJcmV0dXJu OworCisJZGV2ID0gZHJtX2luZm8tPmRybV9kZXY7CisJaWYgKCFkZXYpCisJCXJldHVybjsKKwor CWlmICghZHJtX2Rldl9pc191bnBsdWdnZWQoZGV2KSkgeworCQlkcm1fa21zX2hlbHBlcl9wb2xs X2ZpbmkoZGV2KTsKKwkJZHJtX2Rldl91bnBsdWcoZGV2KTsKKwl9Cit9CisKK3N0YXRpYyBpbnQg ZGlzcGxiYWNrX2luaXR3YWl0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8p Cit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpjZmcgPSAmZnJvbnRfaW5mby0+Y2ZnOwor CWludCByZXQ7CisKKwljZmctPmZyb250X2luZm8gPSBmcm9udF9pbmZvOworCXJldCA9IHhlbl9k cm1fZnJvbnRfY2ZnX2NhcmQoZnJvbnRfaW5mbywgY2ZnKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0 dXJuIHJldDsKKworCURSTV9JTkZPKCJIYXZlICVkIGNvbmVjdG9yKHMpXG4iLCBjZmctPm51bV9j b25uZWN0b3JzKTsKKwkvKiBDcmVhdGUgZXZlbnQgY2hhbm5lbHMgZm9yIGFsbCBjb25uZWN0b3Jz IGFuZCBwdWJsaXNoICovCisJcmV0ID0geGVuX2RybV9mcm9udF9ldnRjaG5sX2NyZWF0ZV9hbGwo ZnJvbnRfaW5mbyk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4geGVu X2RybV9mcm9udF9ldnRjaG5sX3B1Ymxpc2hfYWxsKGZyb250X2luZm8pOworfQorCitzdGF0aWMg aW50IGRpc3BsYmFja19jb25uZWN0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8pCit7CisJeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShmcm9udF9pbmZvLCBFVlRD SE5MX1NUQVRFX0NPTk5FQ1RFRCk7CisJcmV0dXJuIHhlbl9kcm1fZHJ2X2luaXQoZnJvbnRfaW5m byk7Cit9CisKK3N0YXRpYyB2b2lkIGRpc3BsYmFja19kaXNjb25uZWN0KHN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJaWYgKCFmcm9udF9pbmZvLT5kcm1faW5mbykK KwkJcmV0dXJuOworCisJLyogVGVsbCB0aGUgYmFja2VuZCB0byB3YWl0IHVudGlsIHdlIHJlbGVh c2UgdGhlIERSTSBkcml2ZXIuICovCisJeGVuYnVzX3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54 Yl9kZXYsIFhlbmJ1c1N0YXRlUmVjb25maWd1cmluZyk7CisKKwl4ZW5fZHJtX2Rydl9maW5pKGZy b250X2luZm8pOworfQorCitzdGF0aWMgdm9pZCBkaXNwbGJhY2tfY2hhbmdlZChzdHJ1Y3QgeGVu YnVzX2RldmljZSAqeGJfZGV2LAorCQllbnVtIHhlbmJ1c19zdGF0ZSBiYWNrZW5kX3N0YXRlKQor eworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8gPSBkZXZfZ2V0X2RydmRh dGEoJnhiX2Rldi0+ZGV2KTsKKwlpbnQgcmV0OworCisJRFJNX0RFQlVHKCJCYWNrZW5kIHN0YXRl IGlzICVzLCBmcm9udCBpcyAlc1xuIiwKKwkJCXhlbmJ1c19zdHJzdGF0ZShiYWNrZW5kX3N0YXRl KSwKKwkJCXhlbmJ1c19zdHJzdGF0ZSh4Yl9kZXYtPnN0YXRlKSk7CisKKwlzd2l0Y2ggKGJhY2tl bmRfc3RhdGUpIHsKKwljYXNlIFhlbmJ1c1N0YXRlUmVjb25maWd1cmluZzoKKwkJLyogZmFsbCB0 aHJvdWdoICovCisJY2FzZSBYZW5idXNTdGF0ZVJlY29uZmlndXJlZDoKKwkJLyogZmFsbCB0aHJv dWdoICovCisJY2FzZSBYZW5idXNTdGF0ZUluaXRpYWxpc2VkOgorCQlicmVhazsKKworCWNhc2Ug WGVuYnVzU3RhdGVJbml0aWFsaXNpbmc6CisJCS8qIHJlY292ZXJpbmcgYWZ0ZXIgYmFja2VuZCB1 bmV4cGVjdGVkIGNsb3N1cmUgKi8KKwkJZGlzcGxiYWNrX2Rpc2Nvbm5lY3QoZnJvbnRfaW5mbyk7 CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZUluaXRXYWl0OgorCQkvKiByZWNvdmVyaW5n IGFmdGVyIGJhY2tlbmQgdW5leHBlY3RlZCBjbG9zdXJlICovCisJCWRpc3BsYmFja19kaXNjb25u ZWN0KGZyb250X2luZm8pOworCQlpZiAoeGJfZGV2LT5zdGF0ZSAhPSBYZW5idXNTdGF0ZUluaXRp YWxpc2luZykKKwkJCWJyZWFrOworCisJCXJldCA9IGRpc3BsYmFja19pbml0d2FpdChmcm9udF9p bmZvKTsKKwkJaWYgKHJldCA8IDApCisJCQl4ZW5idXNfZGV2X2ZhdGFsKHhiX2RldiwgcmV0LAor CQkJCQkiaW5pdGlhbGl6aW5nIGZyb250ZW5kIik7CisJCWVsc2UKKwkJCXhlbmJ1c19zd2l0Y2hf c3RhdGUoeGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2VkKTsKKwkJYnJlYWs7CisKKwljYXNl IFhlbmJ1c1N0YXRlQ29ubmVjdGVkOgorCQlpZiAoeGJfZGV2LT5zdGF0ZSAhPSBYZW5idXNTdGF0 ZUluaXRpYWxpc2VkKQorCQkJYnJlYWs7CisKKwkJcmV0ID0gZGlzcGxiYWNrX2Nvbm5lY3QoZnJv bnRfaW5mbyk7CisJCWlmIChyZXQgPCAwKQorCQkJeGVuYnVzX2Rldl9mYXRhbCh4Yl9kZXYsIHJl dCwKKwkJCQkJImluaXRpYWxpemluZyBEUk0gZHJpdmVyIik7CisJCWVsc2UKKwkJCXhlbmJ1c19z d2l0Y2hfc3RhdGUoeGJfZGV2LCBYZW5idXNTdGF0ZUNvbm5lY3RlZCk7CisJCWJyZWFrOworCisJ Y2FzZSBYZW5idXNTdGF0ZUNsb3Npbmc6CisJCS8qCisJCSAqIGluIHRoaXMgc3RhdGUgYmFja2Vu ZCBzdGFydHMgZnJlZWluZyByZXNvdXJjZXMsCisJCSAqIHNvIGxldCBpdCBnbyBpbnRvIGNsb3Nl ZCBzdGF0ZSwgc28gd2UgY2FuIGFsc28KKwkJICogcmVtb3ZlIG91cnMKKwkJICovCisJCWJyZWFr OworCisJY2FzZSBYZW5idXNTdGF0ZVVua25vd246CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNh c2UgWGVuYnVzU3RhdGVDbG9zZWQ6CisJCWlmICh4Yl9kZXYtPnN0YXRlID09IFhlbmJ1c1N0YXRl Q2xvc2VkKQorCQkJYnJlYWs7CisKKwkJZGlzcGxiYWNrX2Rpc2Nvbm5lY3QoZnJvbnRfaW5mbyk7 CisJCWJyZWFrOworCX0KK30KKworc3RhdGljIGludCB4ZW5fZHJ2X3Byb2JlKHN0cnVjdCB4ZW5i dXNfZGV2aWNlICp4Yl9kZXYsCisJCWNvbnN0IHN0cnVjdCB4ZW5idXNfZGV2aWNlX2lkICppZCkK K3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvOworCXN0cnVjdCBkZXZp Y2UgKmRldiA9ICZ4Yl9kZXYtPmRldjsKKwlpbnQgcmV0OworCisJLyoKKwkgKiBUaGUgZGV2aWNl IGlzIG5vdCBzcGF3biBmcm9tIGEgZGV2aWNlIHRyZWUsIHNvIGFyY2hfc2V0dXBfZG1hX29wcwor CSAqIGlzIG5vdCBjYWxsZWQsIHRodXMgbGVhdmluZyB0aGUgZGV2aWNlIHdpdGggZHVtbXkgRE1B IG9wcy4KKwkgKiBUaGlzIG1ha2VzIHRoZSBkZXZpY2UgcmV0dXJuIGVycm9yIG9uIFBSSU1FIGJ1 ZmZlciBpbXBvcnQsIHdoaWNoCisJICogaXMgbm90IGNvcnJlY3Q6IHRvIGZpeCB0aGlzIGNhbGwg b2ZfZG1hX2NvbmZpZ3VyZSgpIHdpdGggYSBOVUxMCisJICogbm9kZSB0byBzZXQgZGVmYXVsdCBE TUEgb3BzLgorCSAqLworCWRldi0+YnVzLT5mb3JjZV9kbWEgPSB0cnVlOworCWRldi0+Y29oZXJl bnRfZG1hX21hc2sgPSBETUFfQklUX01BU0soMzIpOworCXJldCA9IG9mX2RtYV9jb25maWd1cmUo ZGV2LCBOVUxMKTsKKwlpZiAocmV0IDwgMCkgeworCQlEUk1fRVJST1IoIkNhbm5vdCBzZXR1cCBE TUEgb3BzLCByZXQgJWQiLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworCWZyb250X2luZm8g PSBkZXZtX2t6YWxsb2MoJnhiX2Rldi0+ZGV2LAorCQkJc2l6ZW9mKCpmcm9udF9pbmZvKSwgR0ZQ X0tFUk5FTCk7CisJaWYgKCFmcm9udF9pbmZvKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZyb250 X2luZm8tPnhiX2RldiA9IHhiX2RldjsKKwlzcGluX2xvY2tfaW5pdCgmZnJvbnRfaW5mby0+aW9f bG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJmZyb250X2luZm8tPmRidWZfbGlzdCk7CisJZGV2X3Nl dF9kcnZkYXRhKCZ4Yl9kZXYtPmRldiwgZnJvbnRfaW5mbyk7CisKKwlyZXR1cm4geGVuYnVzX3N3 aXRjaF9zdGF0ZSh4Yl9kZXYsIFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5nKTsKK30KKworc3RhdGlj IGludCB4ZW5fZHJ2X3JlbW92ZShzdHJ1Y3QgeGVuYnVzX2RldmljZSAqZGV2KQoreworCXN0cnVj dCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8gPSBkZXZfZ2V0X2RydmRhdGEoJmRldi0+ ZGV2KTsKKwlpbnQgdG8gPSAxMDA7CisKKwl4ZW5idXNfc3dpdGNoX3N0YXRlKGRldiwgWGVuYnVz U3RhdGVDbG9zaW5nKTsKKworCS8qCisJICogT24gZHJpdmVyIHJlbW92YWwgaXQgaXMgZGlzY29u bmVjdGVkIGZyb20gWGVuQnVzLAorCSAqIHNvIG5vIGJhY2tlbmQgc3RhdGUgY2hhbmdlIGV2ZW50 cyBjb21lIHZpYSAub3RoZXJlbmRfY2hhbmdlZAorCSAqIGNhbGxiYWNrLiBUaGlzIHByZXZlbnRz IHVzIGZyb20gZXhpdGluZyBncmFjZWZ1bGx5LCBlLmcuCisJICogc2lnbmFsaW5nIHRoZSBiYWNr ZW5kIHRvIGZyZWUgZXZlbnQgY2hhbm5lbHMsIHdhaXRpbmcgZm9yIGl0cworCSAqIHN0YXRlIHRv IGNoYW5nZSB0byBYZW5idXNTdGF0ZUNsb3NlZCBhbmQgY2xlYW5pbmcgYXQgb3VyIGVuZC4KKwkg KiBOb3JtYWxseSB3aGVuIGZyb250IGRyaXZlciByZW1vdmVkIGJhY2tlbmQgd2lsbCBmaW5hbGx5 IGdvIGludG8KKwkgKiBYZW5idXNTdGF0ZUluaXRXYWl0IHN0YXRlLgorCSAqCisJICogV29ya2Fy b3VuZDogcmVhZCBiYWNrZW5kJ3Mgc3RhdGUgbWFudWFsbHkgYW5kIHdhaXQgd2l0aCB0aW1lLW91 dC4KKwkgKi8KKwl3aGlsZSAoKHhlbmJ1c19yZWFkX3Vuc2lnbmVkKGZyb250X2luZm8tPnhiX2Rl di0+b3RoZXJlbmQsCisJCQkic3RhdGUiLCBYZW5idXNTdGF0ZVVua25vd24pICE9IFhlbmJ1c1N0 YXRlSW5pdFdhaXQpICYmCisJCQl0by0tKQorCQltc2xlZXAoMTApOworCisJaWYgKCF0bykKKwkJ RFJNX0VSUk9SKCJCYWNrZW5kIHN0YXRlIGlzICVzIHdoaWxlIHJlbW92aW5nIGRyaXZlclxuIiwK KwkJCXhlbmJ1c19zdHJzdGF0ZSh4ZW5idXNfcmVhZF91bnNpZ25lZCgKKwkJCQkJZnJvbnRfaW5m by0+eGJfZGV2LT5vdGhlcmVuZCwKKwkJCQkJInN0YXRlIiwgWGVuYnVzU3RhdGVVbmtub3duKSkp OworCisJeGVuX2RybV9kcnZfZmluaShmcm9udF9pbmZvKTsKKwl4ZW5idXNfZnJvbnRlbmRfY2xv c2VkKGRldik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGVuYnVzX2Rl dmljZV9pZCB4ZW5fZHJpdmVyX2lkc1tdID0geworCXsgWEVORElTUExfRFJJVkVSX05BTUUgfSwK Kwl7ICIiIH0KK307CisKK3N0YXRpYyBzdHJ1Y3QgeGVuYnVzX2RyaXZlciB4ZW5fZHJpdmVyID0g eworCS5pZHMgPSB4ZW5fZHJpdmVyX2lkcywKKwkucHJvYmUgPSB4ZW5fZHJ2X3Byb2JlLAorCS5y ZW1vdmUgPSB4ZW5fZHJ2X3JlbW92ZSwKKwkub3RoZXJlbmRfY2hhbmdlZCA9IGRpc3BsYmFja19j aGFuZ2VkLAorfTsKKworc3RhdGljIGludCBfX2luaXQgeGVuX2Rydl9pbml0KHZvaWQpCit7CisJ LyogQXQgdGhlIG1vbWVudCB3ZSBvbmx5IHN1cHBvcnQgY2FzZSB3aXRoIFhFTl9QQUdFX1NJWkUg PT0gUEFHRV9TSVpFICovCisJaWYgKFhFTl9QQUdFX1NJWkUgIT0gUEFHRV9TSVpFKSB7CisJCURS TV9FUlJPUihYRU5ESVNQTF9EUklWRVJfTkFNRSAiOiBkaWZmZXJlbnQga2VybmVsIGFuZCBYZW4g cGFnZSBzaXplcyBhcmUgbm90IHN1cHBvcnRlZDogWEVOX1BBR0VfU0laRSAoJWx1KSAhPSBQQUdF X1NJWkUgKCVsdSlcbiIsCisJCQkJWEVOX1BBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwkJcmV0dXJu IC1FTk9ERVY7CisJfQorCisJaWYgKCF4ZW5fZG9tYWluKCkpCisJCXJldHVybiAtRU5PREVWOwor CisJaWYgKCF4ZW5faGFzX3B2X2RldmljZXMoKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlEUk1f SU5GTygiUmVnaXN0ZXJpbmcgWEVOIFBWICIgWEVORElTUExfRFJJVkVSX05BTUUgIlxuIik7CisJ cmV0dXJuIHhlbmJ1c19yZWdpc3Rlcl9mcm9udGVuZCgmeGVuX2RyaXZlcik7Cit9CisKK3N0YXRp YyB2b2lkIF9fZXhpdCB4ZW5fZHJ2X2Zpbmkodm9pZCkKK3sKKwlEUk1fSU5GTygiVW5yZWdpc3Rl cmluZyBYRU4gUFYgIiBYRU5ESVNQTF9EUklWRVJfTkFNRSAiXG4iKTsKKwl4ZW5idXNfdW5yZWdp c3Rlcl9kcml2ZXIoJnhlbl9kcml2ZXIpOworfQorCittb2R1bGVfaW5pdCh4ZW5fZHJ2X2luaXQp OworbW9kdWxlX2V4aXQoeGVuX2Rydl9maW5pKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJYZW4g cGFyYS12aXJ0dWFsaXplZCBkaXNwbGF5IGRldmljZSBmcm9udGVuZCIpOworTU9EVUxFX0xJQ0VO U0UoIkdQTCIpOworTU9EVUxFX0FMSUFTKCJ4ZW46IlhFTkRJU1BMX0RSSVZFUl9OQU1FKTsKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oIGIvZHJpdmVycy9n cHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi4xOTY3MzNkNWEyNzAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnQuaApAQCAtMCwwICsxLDE5OCBAQAorLyogU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVh bCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1z IEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJf YW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9I XworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfSF8KKworI2luY2x1ZGUgPGRybS9kcm1QLmg+Cisj aW5jbHVkZSA8ZHJtL2RybV9zaW1wbGVfa21zX2hlbHBlci5oPgorCisjaW5jbHVkZSA8bGludXgv c2NhdHRlcmxpc3QuaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfY2ZnLmgiCisKKy8qKgor ICogRE9DOiBEcml2ZXIgbW9kZXMgb2Ygb3BlcmF0aW9uIGluIHRlcm1zIG9mIGRpc3BsYXkgYnVm ZmVycyB1c2VkCisgKgorICogRGVwZW5kaW5nIG9uIHRoZSByZXF1aXJlbWVudHMgZm9yIHRoZSBw YXJhLXZpcnR1YWxpemVkIGVudmlyb25tZW50LCBuYW1lbHkKKyAqIHJlcXVpcmVtZW50cyBkaWN0 YXRlZCBieSB0aGUgYWNjb21wYW55aW5nIERSTS8odilHUFUgZHJpdmVycyBydW5uaW5nIGluIGJv dGgKKyAqIGhvc3QgYW5kIGd1ZXN0IGVudmlyb25tZW50cywgbnVtYmVyIG9mIG9wZXJhdGluZyBt b2RlcyBvZiBwYXJhLXZpcnR1YWxpemVkCisgKiBkaXNwbGF5IGRyaXZlciBhcmUgc3VwcG9ydGVk OgorICoKKyAqIC0gZGlzcGxheSBidWZmZXJzIGNhbiBiZSBhbGxvY2F0ZWQgYnkgZWl0aGVyIGZy b250ZW5kIGRyaXZlciBvciBiYWNrZW5kCisgKiAtIGRpc3BsYXkgYnVmZmVycyBjYW4gYmUgYWxs b2NhdGVkIHRvIGJlIGNvbnRpZ3VvdXMgaW4gbWVtb3J5IG9yIG5vdAorICoKKyAqIE5vdGUhIEZy b250ZW5kIGRyaXZlciBpdHNlbGYgaGFzIG5vIGRlcGVuZGVuY3kgb24gY29udGlndW91cyBtZW1v cnkgZm9yCisgKiBpdHMgb3BlcmF0aW9uLgorICovCisKKy8qKgorICogRE9DOiBCdWZmZXJzIGFs bG9jYXRlZCBieSB0aGUgZnJvbnRlbmQgZHJpdmVyCisgKgorICogVGhlIGJlbG93IG1vZGVzIG9m IG9wZXJhdGlvbiBhcmUgY29uZmlndXJlZCBhdCBjb21waWxlLXRpbWUgdmlhCisgKiBmcm9udGVu ZCBkcml2ZXIncyBrZXJuZWwgY29uZmlndXJhdGlvbjoKKyAqLworCisvKioKKyAqIERPQzogV2l0 aCBHRU0gQ01BIGhlbHBlcnMKKyAqCisgKiBUaGlzIHVzZS1jYXNlIGlzIHVzZWZ1bCB3aGVuIHVz ZWQgd2l0aCBhY2NvbXBhbnlpbmcgRFJNL3ZHUFUgZHJpdmVyIGluCisgKiBndWVzdCBkb21haW4g d2hpY2ggd2FzIGRlc2lnbmVkIHRvIG9ubHkgd29yayB3aXRoIGNvbnRpZ3VvdXMgYnVmZmVycywK KyAqIGUuZy4gRFJNIGRyaXZlciBiYXNlZCBvbiBHRU0gQ01BIGhlbHBlcnM6IHN1Y2ggZHJpdmVy cyBjYW4gb25seSBpbXBvcnQKKyAqIGNvbnRpZ3VvdXMgUFJJTUUgYnVmZmVycywgdGh1cyByZXF1 aXJpbmcgZnJvbnRlbmQgZHJpdmVyIHRvIHByb3ZpZGUKKyAqIHN1Y2guIEluIG9yZGVyIHRvIGlt cGxlbWVudCB0aGlzIG1vZGUgb2Ygb3BlcmF0aW9uIHBhcmEtdmlydHVhbGl6ZWQKKyAqIGZyb250 ZW5kIGRyaXZlciBjYW4gYmUgY29uZmlndXJlZCB0byB1c2UgR0VNIENNQSBoZWxwZXJzLgorICov CisKKy8qKgorICogRE9DOiBXaXRob3V0IEdFTSBDTUEgaGVscGVycworICoKKyAqIElmIGFjY29t cGFueWluZyBkcml2ZXJzIGNhbiBjb3BlIHdpdGggbm9uLWNvbnRpZ3VvdXMgbWVtb3J5IHRoZW4s IHRvCisgKiBsb3dlciBwcmVzc3VyZSBvbiBDTUEgc3Vic3lzdGVtIG9mIHRoZSBrZXJuZWwsIGRy aXZlciBjYW4gYWxsb2NhdGUKKyAqIGJ1ZmZlcnMgZnJvbSBzeXN0ZW0gbWVtb3J5LgorICoKKyAq IE5vdGUhIElmIHVzZWQgd2l0aCBhY2NvbXBhbnlpbmcgRFJNLyh2KUdQVSBkcml2ZXJzIHRoaXMg bW9kZSBvZiBvcGVyYXRpb24KKyAqIG1heSByZXF1aXJlIElPTU1VIHN1cHBvcnQgb24gdGhlIHBs YXRmb3JtLCBzbyBhY2NvbXBhbnlpbmcgRFJNL3ZHUFUKKyAqIGhhcmR3YXJlIGNhbiBzdGlsbCBy ZWFjaCBkaXNwbGF5IGJ1ZmZlciBtZW1vcnkgd2hpbGUgaW1wb3J0aW5nIFBSSU1FCisgKiBidWZm ZXJzIGZyb20gdGhlIGZyb250ZW5kIGRyaXZlci4KKyAqLworCisvKioKKyAqIERPQzogQnVmZmVy cyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tlbmQKKyAqCisgKiBUaGlzIG1vZGUgb2Ygb3BlcmF0aW9u IGlzIHJ1bi10aW1lIGNvbmZpZ3VyZWQgdmlhIGd1ZXN0IGRvbWFpbiBjb25maWd1cmF0aW9uCisg KiB0aHJvdWdoIFhlblN0b3JlIGVudHJpZXMuCisgKgorICogRm9yIHN5c3RlbXMgd2hpY2ggZG8g bm90IHByb3ZpZGUgSU9NTVUgc3VwcG9ydCwgYnV0IGhhdmluZyBzcGVjaWZpYworICogcmVxdWly ZW1lbnRzIGZvciBkaXNwbGF5IGJ1ZmZlcnMgaXQgaXMgcG9zc2libGUgdG8gYWxsb2NhdGUgc3Vj aCBidWZmZXJzCisgKiBhdCBiYWNrZW5kIHNpZGUgYW5kIHNoYXJlIHRob3NlIHdpdGggdGhlIGZy b250ZW5kLgorICogRm9yIGV4YW1wbGUsIGlmIGhvc3QgZG9tYWluIGlzIDE6MSBtYXBwZWQgYW5k IGhhcyBEUk0vR1BVIGhhcmR3YXJlIGV4cGVjdGluZworICogcGh5c2ljYWxseSBjb250aWd1b3Vz IG1lbW9yeSwgdGhpcyBhbGxvd3MgaW1wbGVtZW50aW5nIHplcm8tY29weWluZworICogdXNlLWNh c2VzLgorICoKKyAqIE5vdGUsIHdoaWxlIHVzaW5nIHRoaXMgc2NlbmFyaW8gdGhlIGZvbGxvd2lu ZyBzaG91bGQgYmUgY29uc2lkZXJlZDoKKyAqCisgKiAjLiBJZiBndWVzdCBkb21haW4gZGllcyB0 aGVuIHBhZ2VzL2dyYW50cyByZWNlaXZlZCBmcm9tIHRoZSBiYWNrZW5kCisgKiAgICBjYW5ub3Qg YmUgY2xhaW1lZCBiYWNrCisgKgorICogIy4gTWlzYmVoYXZpbmcgZ3Vlc3QgbWF5IHNlbmQgdG9v IG1hbnkgcmVxdWVzdHMgdG8gdGhlCisgKiAgICBiYWNrZW5kIGV4aGF1c3RpbmcgaXRzIGdyYW50 IHJlZmVyZW5jZXMgYW5kIG1lbW9yeQorICogICAgKGNvbnNpZGVyIHRoaXMgZnJvbSBzZWN1cml0 eSBQT1YpCisgKi8KKworLyoqCisgKiBET0M6IERyaXZlciBsaW1pdGF0aW9ucworICoKKyAqICMu IE9ubHkgcHJpbWFyeSBwbGFuZSB3aXRob3V0IGFkZGl0aW9uYWwgcHJvcGVydGllcyBpcyBzdXBw b3J0ZWQuCisgKgorICogIy4gT25seSBvbmUgdmlkZW8gbW9kZSBwZXIgY29ubmVjdG9yIHN1cHBv cnRlZCB3aGljaCBpcyBjb25maWd1cmVkIHZpYSBYZW5TdG9yZS4KKyAqCisgKiAjLiBBbGwgQ1JU Q3Mgb3BlcmF0ZSBhdCBmaXhlZCBmcmVxdWVuY3kgb2YgNjBIei4KKyAqLworCisvKiB0aW1lb3V0 IGluIG1zIHRvIHdhaXQgZm9yIGJhY2tlbmQgdG8gcmVzcG9uZCAqLworI2RlZmluZSBYRU5fRFJN X0ZST05UX1dBSVRfQkFDS19NUwkzMDAwCisKKyNpZm5kZWYgR1JBTlRfSU5WQUxJRF9SRUYKKy8q CisgKiBOb3RlIG9uIHVzYWdlIG9mIGdyYW50IHJlZmVyZW5jZSAwIGFzIGludmFsaWQgZ3JhbnQg cmVmZXJlbmNlOgorICogZ3JhbnQgcmVmZXJlbmNlIDAgaXMgdmFsaWQsIGJ1dCBuZXZlciBleHBv c2VkIHRvIGEgUFYgZHJpdmVyLAorICogYmVjYXVzZSBvZiB0aGUgZmFjdCBpdCBpcyBhbHJlYWR5 IGluIHVzZS9yZXNlcnZlZCBieSB0aGUgUFYgY29uc29sZS4KKyAqLworI2RlZmluZSBHUkFOVF9J TlZBTElEX1JFRgkwCisjZW5kaWYKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyB7CisJc3Ry dWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldjsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5m byAqZHJtX2luZm87CisKKwkvKiB0byBwcm90ZWN0IGRhdGEgYmV0d2VlbiBiYWNrZW5kIElPIGNv ZGUgYW5kIGludGVycnVwdCBoYW5kbGVyICovCisJc3BpbmxvY2tfdCBpb19sb2NrOworCisJaW50 IG51bV9ldnRfcGFpcnM7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wYWlyICpldnRf cGFpcnM7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnIGNmZzsKKworCS8qIGRpc3BsYXkgYnVm ZmVycyAqLworCXN0cnVjdCBsaXN0X2hlYWQgZGJ1Zl9saXN0OworfTsKKworc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX3BpcGVsaW5lIHsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAq ZHJtX2luZm87CisKKwlpbnQgaW5kZXg7CisKKwlzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3Bp cGUgcGlwZTsKKworCXN0cnVjdCBkcm1fY29ubmVjdG9yIGNvbm47CisJLyogVGhlc2UgYXJlIG9u bHkgZm9yIGNvbm5lY3RvciBtb2RlIGNoZWNraW5nICovCisJaW50IHdpZHRoLCBoZWlnaHQ7CisK KwlzdHJ1Y3QgZHJtX3BlbmRpbmdfdmJsYW5rX2V2ZW50ICpwZW5kaW5nX2V2ZW50OworCisJLyoK KwkgKiBwZmxpcF90aW1lb3V0IGlzIHNldCB0byBjdXJyZW50IGppZmZpZXMgb25jZSB3ZSBzZW5k IGEgcGFnZSBmbGlwIGFuZAorCSAqIHJlc2V0IHRvIDAgd2hlbiB3ZSByZWNlaXZlIGZyYW1lIGRv bmUgZXZlbnQgZnJvbSB0aGUgYmFja2VkLgorCSAqIEl0IGlzIGNoZWNrZWQgZHVyaW5nIGRybV9j b25uZWN0b3JfaGVscGVyX2Z1bmNzLmRldGVjdF9jdHggdG8gZGV0ZWN0CisJICogdGltZS1vdXRz IGZvciBmcmFtZSBkb25lIGV2ZW50LCBlLmcuIGR1ZSB0byBiYWNrZW5kIGVycm9ycy4KKwkgKgor CSAqIFRoaXMgbXVzdCBiZSBwcm90ZWN0ZWQgd2l0aCBmcm9udF9pbmZvLT5pb19sb2NrLCBzbyBy YWNlcyBiZXR3ZWVuCisJICogaW50ZXJydXB0IGhhbmRsZXIgYW5kIHJlc3Qgb2YgdGhlIGNvZGUg YXJlIHByb3Blcmx5IGhhbmRsZWQuCisJICovCisJdW5zaWduZWQgbG9uZyBwZmxpcF90aW1lb3V0 OworCisJYm9vbCBjb25uX2Nvbm5lY3RlZDsKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2Ry bV9pbmZvIHsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvOworCXN0cnVj dCBkcm1fZGV2aWNlICpkcm1fZGV2OworCisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVs aW5lIHBpcGVsaW5lW1hFTl9EUk1fRlJPTlRfTUFYX0NSVENTXTsKK307CisKK3N0YXRpYyBpbmxp bmUgdWludDY0X3QgeGVuX2RybV9mcm9udF9mYl90b19jb29raWUoCisJCXN0cnVjdCBkcm1fZnJh bWVidWZmZXIgKmZiKQoreworCXJldHVybiAodWludDY0X3QpZmI7Cit9CisKK3N0YXRpYyBpbmxp bmUgdWludDY0X3QgeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZSgKKwkJc3RydWN0IGRybV9n ZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXJldHVybiAodWludDY0X3QpZ2VtX29iajsKK30KKwor aW50IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVs aW5lICpwaXBlbGluZSwKKwkJdWludDMyX3QgeCwgdWludDMyX3QgeSwgdWludDMyX3Qgd2lkdGgs IHVpbnQzMl90IGhlaWdodCwKKwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBmYl9jb29raWUpOwor CitpbnQgeGVuX2RybV9mcm9udF9kYnVmX2NyZWF0ZV9mcm9tX3NndChzdHJ1Y3QgeGVuX2RybV9m cm9udF9pbmZvICpmcm9udF9pbmZvLAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qg d2lkdGgsIHVpbnQzMl90IGhlaWdodCwKKwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBz dHJ1Y3Qgc2dfdGFibGUgKnNndCk7CisKK2ludCB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zy b21fcGFnZXMoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJdWludDY0 X3QgZGJ1Zl9jb29raWUsIHVpbnQzMl90IHdpZHRoLCB1aW50MzJfdCBoZWlnaHQsCisJCXVpbnQz Ml90IGJwcCwgdWludDY0X3Qgc2l6ZSwgc3RydWN0IHBhZ2UgKipwYWdlcyk7CisKK2ludCB4ZW5f ZHJtX2Zyb250X2ZiX2F0dGFjaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZv LAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDY0X3QgZmJfY29va2llLCB1aW50MzJfdCB3 aWR0aCwKKwkJdWludDMyX3QgaGVpZ2h0LCB1aW50MzJfdCBwaXhlbF9mb3JtYXQpOworCitpbnQg eGVuX2RybV9mcm9udF9mYl9kZXRhY2goc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRf aW5mbywKKwkJdWludDY0X3QgZmJfY29va2llKTsKKworaW50IHhlbl9kcm1fZnJvbnRfcGFnZV9m bGlwKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCWludCBjb25uX2lk eCwgdWludDY0X3QgZmJfY29va2llKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X29uX2ZyYW1lX2Rv bmUoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJaW50IGNvbm5faWR4 LCB1aW50NjRfdCBmYl9jb29raWUpOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX0hfICov CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMgYi9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45YTBiMmI4ZTYxNjkKLS0tIC9kZXYvbnVsbAorKysgYi9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmMKQEAgLTAsMCArMSw3NyBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVu IHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTgg RVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtv IDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJt L2RybVAuaD4KKworI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgorCisjaW5jbHVkZSA8eGVuL2lu dGVyZmFjZS9pby9kaXNwbGlmLmg+CisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorCisjaW5jbHVk ZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfY2ZnLmgiCisKK3N0 YXRpYyBpbnQgY2ZnX2Nvbm5lY3RvcihzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9p bmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmdfY29ubmVjdG9yICpjb25uZWN0b3IsCisJ CWNvbnN0IGNoYXIgKnBhdGgsIGludCBpbmRleCkKK3sKKwljaGFyICpjb25uZWN0b3JfcGF0aDsK KworCWNvbm5lY3Rvcl9wYXRoID0gZGV2bV9rYXNwcmludGYoJmZyb250X2luZm8tPnhiX2Rldi0+ ZGV2LAorCQkJR0ZQX0tFUk5FTCwgIiVzLyVkIiwgcGF0aCwgaW5kZXgpOworCWlmICghY29ubmVj dG9yX3BhdGgpCisJCXJldHVybiAtRU5PTUVNOworCisJaWYgKHhlbmJ1c19zY2FuZihYQlRfTklM LCBjb25uZWN0b3JfcGF0aCwgWEVORElTUExfRklFTERfUkVTT0xVVElPTiwKKwkJCSIlZCIgWEVO RElTUExfUkVTT0xVVElPTl9TRVBBUkFUT1IgIiVkIiwKKwkJCSZjb25uZWN0b3ItPndpZHRoLCAm Y29ubmVjdG9yLT5oZWlnaHQpIDwgMCkgeworCQkvKiBlaXRoZXIgbm8gZW50cnkgY29uZmlndXJl ZCBvciB3cm9uZyByZXNvbHV0aW9uIHNldCAqLworCQljb25uZWN0b3ItPndpZHRoID0gMDsKKwkJ Y29ubmVjdG9yLT5oZWlnaHQgPSAwOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwljb25uZWN0 b3ItPnhlbnN0b3JlX3BhdGggPSBjb25uZWN0b3JfcGF0aDsKKworCURSTV9JTkZPKCJDb25uZWN0 b3IgJXM6IHJlc29sdXRpb24gJWR4JWRcbiIsCisJCQljb25uZWN0b3JfcGF0aCwgY29ubmVjdG9y LT53aWR0aCwgY29ubmVjdG9yLT5oZWlnaHQpOworCXJldHVybiAwOworfQorCitpbnQgeGVuX2Ry bV9mcm9udF9jZmdfY2FyZChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAor CQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgKmNmZykKK3sKKwlzdHJ1Y3QgeGVuYnVzX2Rldmlj ZSAqeGJfZGV2ID0gZnJvbnRfaW5mby0+eGJfZGV2OworCWludCByZXQsIGk7CisKKwlpZiAoeGVu YnVzX3JlYWRfdW5zaWduZWQoZnJvbnRfaW5mby0+eGJfZGV2LT5ub2RlbmFtZSwKKwkJCVhFTkRJ U1BMX0ZJRUxEX0JFX0FMTE9DLCAwKSkgeworCQlEUk1fSU5GTygiQmFja2VuZCBjYW4gcHJvdmlk ZSBkaXNwbGF5IGJ1ZmZlcnNcbiIpOworCQljZmctPmJlX2FsbG9jID0gdHJ1ZTsKKwl9CisKKwlj ZmctPm51bV9jb25uZWN0b3JzID0gMDsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjZmct PmNvbm5lY3RvcnMpOyBpKyspIHsKKwkJcmV0ID0gY2ZnX2Nvbm5lY3Rvcihmcm9udF9pbmZvLAor CQkJCSZjZmctPmNvbm5lY3RvcnNbaV0sIHhiX2Rldi0+bm9kZW5hbWUsIGkpOworCQlpZiAocmV0 IDwgMCkKKwkJCWJyZWFrOworCQljZmctPm51bV9jb25uZWN0b3JzKys7CisJfQorCisJaWYgKCFj ZmctPm51bV9jb25uZWN0b3JzKSB7CisJCURSTV9FUlJPUigiTm8gY29ubmVjdG9yKHMpIGNvbmZp Z3VyZWQgYXQgJXNcbiIsCisJCQkJeGJfZGV2LT5ub2RlbmFtZSk7CisJCXJldHVybiAtRU5PREVW OworCX0KKworCXJldHVybiAwOworfQorCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfY2ZnLmggYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf Y2ZnLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42ZTdhZjY3MGY4 Y2QKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf Y2ZnLmgKQEAgLTAsMCArMSwzNyBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgor ICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRo b3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFt LmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9DRkdfSF8KKyNkZWZpbmUgX19Y RU5fRFJNX0ZST05UX0NGR19IXworCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2RlZmlu ZSBYRU5fRFJNX0ZST05UX01BWF9DUlRDUwk0CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZ19j b25uZWN0b3IgeworCWludCB3aWR0aDsKKwlpbnQgaGVpZ2h0OworCWNoYXIgKnhlbnN0b3JlX3Bh dGg7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgeworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2luZm8gKmZyb250X2luZm87CisJLyogbnVtYmVyIG9mIGNvbm5lY3RvcnMgaW4gdGhpcyBj b25maWd1cmF0aW9uICovCisJaW50IG51bV9jb25uZWN0b3JzOworCS8qIGNvbm5lY3RvciBjb25m aWd1cmF0aW9ucyAqLworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZ19jb25uZWN0b3IgY29ubmVj dG9yc1tYRU5fRFJNX0ZST05UX01BWF9DUlRDU107CisJLyogc2V0IGlmIGR1bWIgYnVmZmVycyBh cmUgYWxsb2NhdGVkIGV4dGVybmFsbHkgb24gYmFja2VuZCBzaWRlICovCisJYm9vbCBiZV9hbGxv YzsKK307CisKK2ludCB4ZW5fZHJtX2Zyb250X2NmZ19jYXJkKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X2luZm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2ZnKTsKKwor I2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9DRkdfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnRfY29ubi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uYjA0YWMyNjAzMjA0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2Nvbm4uYwpAQCAtMCwwICsxLDE0NSBAQAorLy8gU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0g ZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4K KyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVz aGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVy Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgorCisjaW5jbHVkZSA8dmlkZW8v dmlkZW9tb2RlLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVu X2RybV9mcm9udF9jb25uLmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9rbXMuaCIKKworc3Rh dGljIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqCit0b194ZW5fZHJtX3BpcGVs aW5lKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCit7CisJcmV0dXJuIGNvbnRhaW5l cl9vZihjb25uZWN0b3IsIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSwgY29ubik7 Cit9CisKK3N0YXRpYyBjb25zdCB1aW50MzJfdCBwbGFuZV9mb3JtYXRzW10gPSB7CisJRFJNX0ZP Uk1BVF9SR0I1NjUsCisJRFJNX0ZPUk1BVF9SR0I4ODgsCisJRFJNX0ZPUk1BVF9YUkdCODg4OCwK KwlEUk1fRk9STUFUX0FSR0I4ODg4LAorCURSTV9GT1JNQVRfWFJHQjQ0NDQsCisJRFJNX0ZPUk1B VF9BUkdCNDQ0NCwKKwlEUk1fRk9STUFUX1hSR0IxNTU1LAorCURSTV9GT1JNQVRfQVJHQjE1NTUs Cit9OworCitjb25zdCB1aW50MzJfdCAqeGVuX2RybV9mcm9udF9jb25uX2dldF9mb3JtYXRzKGlu dCAqZm9ybWF0X2NvdW50KQoreworCSpmb3JtYXRfY291bnQgPSBBUlJBWV9TSVpFKHBsYW5lX2Zv cm1hdHMpOworCXJldHVybiBwbGFuZV9mb3JtYXRzOworfQorCitzdGF0aWMgaW50IGNvbm5lY3Rv cl9kZXRlY3Qoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKKwkJc3RydWN0IGRybV9t b2Rlc2V0X2FjcXVpcmVfY3R4ICpjdHgsCisJCWJvb2wgZm9yY2UpCit7CisJc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQl0b194ZW5fZHJtX3BpcGVsaW5l KGNvbm5lY3Rvcik7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyA9IHBp cGVsaW5lLT5kcm1faW5mby0+ZnJvbnRfaW5mbzsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJ LyogY2hlY2sgaWYgdGhlcmUgaXMgYSBmcmFtZSBkb25lIGV2ZW50IHRpbWUtb3V0ICovCisJc3Bp bl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlpZiAocGlwZWxp bmUtPnBmbGlwX3RpbWVvdXQgJiYKKwkJCXRpbWVfYWZ0ZXJfZXEoamlmZmllcywgcGlwZWxpbmUt PnBmbGlwX3RpbWVvdXQpKSB7CisJCURSTV9FUlJPUigiRnJhbWUgZG9uZSBldmVudCB0aW1lZC1v dXRcbiIpOworCisJCXBpcGVsaW5lLT5wZmxpcF90aW1lb3V0ID0gMDsKKwkJcGlwZWxpbmUtPmNv bm5fY29ubmVjdGVkID0gZmFsc2U7CisJCXhlbl9kcm1fZnJvbnRfa21zX3NlbmRfcGVuZGluZ19l dmVudChwaXBlbGluZSk7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8t PmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChkcm1fZGV2X2lzX3VucGx1Z2dlZChjb25uZWN0b3It PmRldikpCisJCXBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA9IGZhbHNlOworCisJcmV0dXJuIHBp cGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA/IGNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkIDoKKwkJ CWNvbm5lY3Rvcl9zdGF0dXNfZGlzY29ubmVjdGVkOworfQorCisjZGVmaW5lIFhFTl9EUk1fQ1JU Q19WUkVGUkVTSF9IWgk2MAorCitzdGF0aWMgaW50IGNvbm5lY3Rvcl9nZXRfbW9kZXMoc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1f cGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUoY29ubmVjdG9yKTsK KwlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZTsKKwlzdHJ1Y3QgdmlkZW9tb2RlIHZpZGVv bW9kZTsKKwlpbnQgd2lkdGgsIGhlaWdodDsKKworCW1vZGUgPSBkcm1fbW9kZV9jcmVhdGUoY29u bmVjdG9yLT5kZXYpOworCWlmICghbW9kZSkKKwkJcmV0dXJuIDA7CisKKwltZW1zZXQoJnZpZGVv bW9kZSwgMCwgc2l6ZW9mKHZpZGVvbW9kZSkpOworCXZpZGVvbW9kZS5oYWN0aXZlID0gcGlwZWxp bmUtPndpZHRoOworCXZpZGVvbW9kZS52YWN0aXZlID0gcGlwZWxpbmUtPmhlaWdodDsKKwl3aWR0 aCA9IHZpZGVvbW9kZS5oYWN0aXZlICsgdmlkZW9tb2RlLmhmcm9udF9wb3JjaCArCisJCQl2aWRl b21vZGUuaGJhY2tfcG9yY2ggKyB2aWRlb21vZGUuaHN5bmNfbGVuOworCWhlaWdodCA9IHZpZGVv bW9kZS52YWN0aXZlICsgdmlkZW9tb2RlLnZmcm9udF9wb3JjaCArCisJCQl2aWRlb21vZGUudmJh Y2tfcG9yY2ggKyB2aWRlb21vZGUudnN5bmNfbGVuOworCXZpZGVvbW9kZS5waXhlbGNsb2NrID0g d2lkdGggKiBoZWlnaHQgKiBYRU5fRFJNX0NSVENfVlJFRlJFU0hfSFo7CisJbW9kZS0+dHlwZSA9 IERSTV9NT0RFX1RZUEVfUFJFRkVSUkVEIHwgRFJNX01PREVfVFlQRV9EUklWRVI7CisKKwlkcm1f ZGlzcGxheV9tb2RlX2Zyb21fdmlkZW9tb2RlKCZ2aWRlb21vZGUsIG1vZGUpOworCWRybV9tb2Rl X3Byb2JlZF9hZGQoY29ubmVjdG9yLCBtb2RlKTsKKwlyZXR1cm4gMTsKK30KKworc3RhdGljIGlu dCBjb25uZWN0b3JfbW9kZV92YWxpZChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAor CQlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9u dF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUoY29ubmVj dG9yKTsKKworCWlmIChtb2RlLT5oZGlzcGxheSAhPSBwaXBlbGluZS0+d2lkdGgpCisJCXJldHVy biBNT0RFX0VSUk9SOworCisJaWYgKG1vZGUtPnZkaXNwbGF5ICE9IHBpcGVsaW5lLT5oZWlnaHQp CisJCXJldHVybiBNT0RFX0VSUk9SOworCisJcmV0dXJuIE1PREVfT0s7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MgY29ubmVjdG9yX2hlbHBlcl9m dW5jcyA9IHsKKwkuZ2V0X21vZGVzID0gY29ubmVjdG9yX2dldF9tb2RlcywKKwkubW9kZV92YWxp ZCA9IGNvbm5lY3Rvcl9tb2RlX3ZhbGlkLAorCS5kZXRlY3RfY3R4ID0gY29ubmVjdG9yX2RldGVj dCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9mdW5jcyBjb25uZWN0 b3JfZnVuY3MgPSB7CisJLmRwbXMgPSBkcm1faGVscGVyX2Nvbm5lY3Rvcl9kcG1zLAorCS5maWxs X21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLAorCS5kZXN0 cm95ID0gZHJtX2Nvbm5lY3Rvcl9jbGVhbnVwLAorCS5yZXNldCA9IGRybV9hdG9taWNfaGVscGVy X2Nvbm5lY3Rvcl9yZXNldCwKKwkuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSA9IGRybV9hdG9taWNf aGVscGVyX2Nvbm5lY3Rvcl9kdXBsaWNhdGVfc3RhdGUsCisJLmF0b21pY19kZXN0cm95X3N0YXRl ID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2Rlc3Ryb3lfc3RhdGUsCit9OworCitpbnQg eGVuX2RybV9mcm9udF9jb25uX2luaXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRy bV9pbmZvLAorCQlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQoreworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUgPQorCQkJdG9feGVuX2RybV9waXBl bGluZShjb25uZWN0b3IpOworCisJZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKGNvbm5lY3Rvciwg JmNvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOworCisJcGlwZWxpbmUtPmNvbm5fY29ubmVjdGVkID0g dHJ1ZTsKKworCWNvbm5lY3Rvci0+cG9sbGVkID0gRFJNX0NPTk5FQ1RPUl9QT0xMX0NPTk5FQ1Qg fAorCQkJRFJNX0NPTk5FQ1RPUl9QT0xMX0RJU0NPTk5FQ1Q7CisKKwlyZXR1cm4gZHJtX2Nvbm5l Y3Rvcl9pbml0KGRybV9pbmZvLT5kcm1fZGV2LCBjb25uZWN0b3IsCisJCSZjb25uZWN0b3JfZnVu Y3MsIERSTV9NT0RFX0NPTk5FQ1RPUl9WSVJUVUFMKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmggYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnRfY29ubi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uZjM4YzRiNmRiNWRmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2Nvbm4uaApAQCAtMCwwICsxLDI3IEBACisvKiBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERS TSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5j LgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRy dXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYgX19YRU5fRFJNX0ZST05UX0NPTk5f SF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0NPTk5fSF8KKworI2luY2x1ZGUgPGRybS9kcm1Q Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9lbmNvZGVy Lmg+CisKKyNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2Ry bV9pbmZvOworCitpbnQgeGVuX2RybV9mcm9udF9jb25uX2luaXQoc3RydWN0IHhlbl9kcm1fZnJv bnRfZHJtX2luZm8gKmRybV9pbmZvLAorCQlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y KTsKKworY29uc3QgdWludDMyX3QgKnhlbl9kcm1fZnJvbnRfY29ubl9nZXRfZm9ybWF0cyhpbnQg KmZvcm1hdF9jb3VudCk7CisKKyNlbmRpZiAvKiBfX1hFTl9EUk1fRlJPTlRfQ09OTl9IXyAqLwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYyBi L2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmMKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNWU1NTc5MjU0OTUKLS0tIC9kZXYvbnVsbAor KysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5jCkBAIC0wLDAg KzEsMzgzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKwor LyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMp IDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFu ZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNp bmNsdWRlIDxkcm0vZHJtUC5oPgorCisjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KKyNpbmNsdWRl IDxsaW51eC9pcnEuaD4KKworI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KKyNpbmNsdWRlIDx4ZW4v ZXZlbnRzLmg+CisjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CisKKyNpbmNsdWRlICJ4ZW5f ZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9ldnRjaG5sLmgiCisKK3N0YXRp YyBpcnFyZXR1cm5fdCBldnRjaG5sX2ludGVycnVwdF9jdHJsKGludCBpcnEsIHZvaWQgKmRldl9p ZCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sID0gZGV2X2lkOwor CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8gPSBldnRjaG5sLT5mcm9udF9p bmZvOworCXN0cnVjdCB4ZW5kaXNwbF9yZXNwICpyZXNwOworCVJJTkdfSURYIGksIHJwOworCXVu c2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAodW5saWtlbHkoZXZ0Y2hubC0+c3RhdGUgIT0gRVZU Q0hOTF9TVEFURV9DT05ORUNURUQpKQorCQlyZXR1cm4gSVJRX0hBTkRMRUQ7CisKKwlzcGluX2xv Y2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCithZ2FpbjoKKwlycCA9 IGV2dGNobmwtPnUucmVxLnJpbmcuc3JpbmctPnJzcF9wcm9kOworCS8qIGVuc3VyZSB3ZSBzZWUg cXVldWVkIHJlc3BvbnNlcyB1cCB0byBycCAqLworCXZpcnRfcm1iKCk7CisKKwlmb3IgKGkgPSBl dnRjaG5sLT51LnJlcS5yaW5nLnJzcF9jb25zOyBpICE9IHJwOyBpKyspIHsKKwkJcmVzcCA9IFJJ TkdfR0VUX1JFU1BPTlNFKCZldnRjaG5sLT51LnJlcS5yaW5nLCBpKTsKKwkJaWYgKHVubGlrZWx5 KHJlc3AtPmlkICE9IGV2dGNobmwtPmV2dF9pZCkpCisJCQljb250aW51ZTsKKworCQlzd2l0Y2gg KHJlc3AtPm9wZXJhdGlvbikgeworCQljYXNlIFhFTkRJU1BMX09QX1BHX0ZMSVA6CisJCWNhc2Ug WEVORElTUExfT1BfRkJfQVRUQUNIOgorCQljYXNlIFhFTkRJU1BMX09QX0ZCX0RFVEFDSDoKKwkJ Y2FzZSBYRU5ESVNQTF9PUF9EQlVGX0NSRUFURToKKwkJY2FzZSBYRU5ESVNQTF9PUF9EQlVGX0RF U1RST1k6CisJCWNhc2UgWEVORElTUExfT1BfU0VUX0NPTkZJRzoKKwkJCWV2dGNobmwtPnUucmVx LnJlc3Bfc3RhdHVzID0gcmVzcC0+c3RhdHVzOworCQkJY29tcGxldGUoJmV2dGNobmwtPnUucmVx LmNvbXBsZXRpb24pOworCQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJCURSTV9FUlJPUigiT3Bl cmF0aW9uICVkIGlzIG5vdCBzdXBwb3J0ZWRcbiIsCisJCQkJcmVzcC0+b3BlcmF0aW9uKTsKKwkJ CWJyZWFrOworCQl9CisJfQorCisJZXZ0Y2hubC0+dS5yZXEucmluZy5yc3BfY29ucyA9IGk7CisK KwlpZiAoaSAhPSBldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2dCkgeworCQlpbnQgbW9y ZV90b19kbzsKKworCQlSSU5HX0ZJTkFMX0NIRUNLX0ZPUl9SRVNQT05TRVMoJmV2dGNobmwtPnUu cmVxLnJpbmcsCisJCQkJbW9yZV90b19kbyk7CisJCWlmIChtb3JlX3RvX2RvKQorCQkJZ290byBh Z2FpbjsKKwl9IGVsc2UKKwkJZXZ0Y2hubC0+dS5yZXEucmluZy5zcmluZy0+cnNwX2V2ZW50ID0g aSArIDE7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBm bGFncyk7CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitzdGF0aWMgaXJxcmV0dXJuX3QgZXZ0 Y2hubF9pbnRlcnJ1cHRfZXZ0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwlzdHJ1Y3QgeGVu X2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sID0gZGV2X2lkOworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2luZm8gKmZyb250X2luZm8gPSBldnRjaG5sLT5mcm9udF9pbmZvOworCXN0cnVjdCB4ZW5k aXNwbF9ldmVudF9wYWdlICpwYWdlID0gZXZ0Y2hubC0+dS5ldnQucGFnZTsKKwl1aW50MzJfdCBj b25zLCBwcm9kOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAodW5saWtlbHkoZXZ0Y2hu bC0+c3RhdGUgIT0gRVZUQ0hOTF9TVEFURV9DT05ORUNURUQpKQorCQlyZXR1cm4gSVJRX0hBTkRM RUQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOwor CisJcHJvZCA9IHBhZ2UtPmluX3Byb2Q7CisJLyogZW5zdXJlIHdlIHNlZSByaW5nIGNvbnRlbnRz IHVwIHRvIHByb2QgKi8KKwl2aXJ0X3JtYigpOworCWlmIChwcm9kID09IHBhZ2UtPmluX2NvbnMp CisJCWdvdG8gb3V0OworCisJZm9yIChjb25zID0gcGFnZS0+aW5fY29uczsgY29ucyAhPSBwcm9k OyBjb25zKyspIHsKKwkJc3RydWN0IHhlbmRpc3BsX2V2dCAqZXZlbnQ7CisKKwkJZXZlbnQgPSAm WEVORElTUExfSU5fUklOR19SRUYocGFnZSwgY29ucyk7CisJCWlmICh1bmxpa2VseShldmVudC0+ aWQgIT0gZXZ0Y2hubC0+ZXZ0X2lkKyspKQorCQkJY29udGludWU7CisKKwkJc3dpdGNoIChldmVu dC0+dHlwZSkgeworCQljYXNlIFhFTkRJU1BMX0VWVF9QR19GTElQOgorCQkJeGVuX2RybV9mcm9u dF9vbl9mcmFtZV9kb25lKGZyb250X2luZm8sIGV2dGNobmwtPmluZGV4LAorCQkJCQlldmVudC0+ b3AucGdfZmxpcC5mYl9jb29raWUpOworCQkJYnJlYWs7CisJCX0KKwl9CisJcGFnZS0+aW5fY29u cyA9IGNvbnM7CisJLyogZW5zdXJlIHJpbmcgY29udGVudHMgKi8KKwl2aXJ0X3dtYigpOworCitv dXQ6CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3Mp OworCXJldHVybiBJUlFfSEFORExFRDsKK30KKworc3RhdGljIHZvaWQgZXZ0Y2hubF9mcmVlKHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2V2dGNobmwgKmV2dGNobmwpCit7CisJdW5zaWduZWQgbG9uZyBwYWdlID0gMDsKKworCWlm IChldnRjaG5sLT50eXBlID09IEVWVENITkxfVFlQRV9SRVEpCisJCXBhZ2UgPSAodW5zaWduZWQg bG9uZylldnRjaG5sLT51LnJlcS5yaW5nLnNyaW5nOworCWVsc2UgaWYgKGV2dGNobmwtPnR5cGUg PT0gRVZUQ0hOTF9UWVBFX0VWVCkKKwkJcGFnZSA9ICh1bnNpZ25lZCBsb25nKWV2dGNobmwtPnUu ZXZ0LnBhZ2U7CisJaWYgKCFwYWdlKQorCQlyZXR1cm47CisKKwlldnRjaG5sLT5zdGF0ZSA9IEVW VENITkxfU1RBVEVfRElTQ09OTkVDVEVEOworCisJaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZUQ0hO TF9UWVBFX1JFUSkgeworCQkvKiByZWxlYXNlIGFsbCB3aG8gc3RpbGwgd2FpdHMgZm9yIHJlc3Bv bnNlIGlmIGFueSAqLworCQlldnRjaG5sLT51LnJlcS5yZXNwX3N0YXR1cyA9IC1FSU87CisJCWNv bXBsZXRlX2FsbCgmZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlvbik7CisJfQorCisJaWYgKGV2dGNo bmwtPmlycSkKKwkJdW5iaW5kX2Zyb21faXJxaGFuZGxlcihldnRjaG5sLT5pcnEsIGV2dGNobmwp OworCisJaWYgKGV2dGNobmwtPnBvcnQpCisJCXhlbmJ1c19mcmVlX2V2dGNobihmcm9udF9pbmZv LT54Yl9kZXYsIGV2dGNobmwtPnBvcnQpOworCisJLyogZW5kIGFjY2VzcyBhbmQgZnJlZSB0aGUg cGFnZSAqLworCWlmIChldnRjaG5sLT5ncmVmICE9IEdSQU5UX0lOVkFMSURfUkVGKQorCQlnbnR0 YWJfZW5kX2ZvcmVpZ25fYWNjZXNzKGV2dGNobmwtPmdyZWYsIDAsIHBhZ2UpOworCisJbWVtc2V0 KGV2dGNobmwsIDAsIHNpemVvZigqZXZ0Y2hubCkpOworfQorCitzdGF0aWMgaW50IGV2dGNobmxf YWxsb2Moc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywgaW50IGluZGV4LAor CQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sLAorCQllbnVtIHhlbl9kcm1f ZnJvbnRfZXZ0Y2hubF90eXBlIHR5cGUpCit7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2Rl diA9IGZyb250X2luZm8tPnhiX2RldjsKKwl1bnNpZ25lZCBsb25nIHBhZ2U7CisJZ3JhbnRfcmVm X3QgZ3JlZjsKKwlpcnFfaGFuZGxlcl90IGhhbmRsZXI7CisJaW50IHJldDsKKworCW1lbXNldChl dnRjaG5sLCAwLCBzaXplb2YoKmV2dGNobmwpKTsKKwlldnRjaG5sLT50eXBlID0gdHlwZTsKKwll dnRjaG5sLT5pbmRleCA9IGluZGV4OworCWV2dGNobmwtPmZyb250X2luZm8gPSBmcm9udF9pbmZv OworCWV2dGNobmwtPnN0YXRlID0gRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQ7CisJZXZ0Y2hu bC0+Z3JlZiA9IEdSQU5UX0lOVkFMSURfUkVGOworCisJcGFnZSA9IGdldF96ZXJvZWRfcGFnZShH RlBfTk9JTyB8IF9fR0ZQX0hJR0gpOworCWlmICghcGFnZSkgeworCQlyZXQgPSAtRU5PTUVNOwor CQlnb3RvIGZhaWw7CisJfQorCisJaWYgKHR5cGUgPT0gRVZUQ0hOTF9UWVBFX1JFUSkgeworCQlz dHJ1Y3QgeGVuX2Rpc3BsaWZfc3JpbmcgKnNyaW5nOworCisJCWluaXRfY29tcGxldGlvbigmZXZ0 Y2hubC0+dS5yZXEuY29tcGxldGlvbik7CisJCW11dGV4X2luaXQoJmV2dGNobmwtPnUucmVxLnJl cV9pb19sb2NrKTsKKwkJc3JpbmcgPSAoc3RydWN0IHhlbl9kaXNwbGlmX3NyaW5nICopcGFnZTsK KwkJU0hBUkVEX1JJTkdfSU5JVChzcmluZyk7CisJCUZST05UX1JJTkdfSU5JVCgmZXZ0Y2hubC0+ dS5yZXEucmluZywKKwkJCQlzcmluZywgWEVOX1BBR0VfU0laRSk7CisKKwkJcmV0ID0geGVuYnVz X2dyYW50X3JpbmcoeGJfZGV2LCBzcmluZywgMSwgJmdyZWYpOworCQlpZiAocmV0IDwgMCkKKwkJ CWdvdG8gZmFpbDsKKworCQloYW5kbGVyID0gZXZ0Y2hubF9pbnRlcnJ1cHRfY3RybDsKKwl9IGVs c2UgeworCQlldnRjaG5sLT51LmV2dC5wYWdlID0gKHN0cnVjdCB4ZW5kaXNwbF9ldmVudF9wYWdl ICopcGFnZTsKKworCQlyZXQgPSBnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3MoeGJfZGV2LT5v dGhlcmVuZF9pZCwKKwkJCQl2aXJ0X3RvX2dmbigodm9pZCAqKXBhZ2UpLCAwKTsKKwkJaWYgKHJl dCA8IDApCisJCQlnb3RvIGZhaWw7CisKKwkJZ3JlZiA9IHJldDsKKwkJaGFuZGxlciA9IGV2dGNo bmxfaW50ZXJydXB0X2V2dDsKKwl9CisJZXZ0Y2hubC0+Z3JlZiA9IGdyZWY7CisKKwlyZXQgPSB4 ZW5idXNfYWxsb2NfZXZ0Y2huKHhiX2RldiwgJmV2dGNobmwtPnBvcnQpOworCWlmIChyZXQgPCAw KQorCQlnb3RvIGZhaWw7CisKKwlyZXQgPSBiaW5kX2V2dGNobl90b19pcnFoYW5kbGVyKGV2dGNo bmwtPnBvcnQsCisJCQloYW5kbGVyLCAwLCB4Yl9kZXYtPmRldmljZXR5cGUsIGV2dGNobmwpOwor CWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CisKKwlldnRjaG5sLT5pcnEgPSByZXQ7CisJcmV0 dXJuIDA7CisKK2ZhaWw6CisJRFJNX0VSUk9SKCJGYWlsZWQgdG8gYWxsb2NhdGUgcmluZzogJWRc biIsIHJldCk7CisJcmV0dXJuIHJldDsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9j cmVhdGVfYWxsKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJc3Ry dWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpjZmc7CisJaW50IHJldCwgY29ubjsKKworCWNmZyA9ICZm cm9udF9pbmZvLT5jZmc7CisKKwlmcm9udF9pbmZvLT5ldnRfcGFpcnMgPSBkZXZtX2tjYWxsb2Mo JmZyb250X2luZm8tPnhiX2Rldi0+ZGV2LAorCQkJY2ZnLT5udW1fY29ubmVjdG9ycywKKwkJCXNp emVvZihzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sX3BhaXIpLCBHRlBfS0VSTkVMKTsKKwlp ZiAoIWZyb250X2luZm8tPmV2dF9wYWlycykgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZh aWw7CisJfQorCisJZm9yIChjb25uID0gMDsgY29ubiA8IGNmZy0+bnVtX2Nvbm5lY3RvcnM7IGNv bm4rKykgeworCQlyZXQgPSBldnRjaG5sX2FsbG9jKGZyb250X2luZm8sIGNvbm4sCisJCQkJJmZy b250X2luZm8tPmV2dF9wYWlyc1tjb25uXS5yZXEsCisJCQkJRVZUQ0hOTF9UWVBFX1JFUSk7CisJ CWlmIChyZXQgPCAwKSB7CisJCQlEUk1fRVJST1IoIkVycm9yIGFsbG9jYXRpbmcgY29udHJvbCBj aGFubmVsXG4iKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCisJCXJldCA9IGV2dGNobmxfYWxsb2Mo ZnJvbnRfaW5mbywgY29ubiwKKwkJCQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLmV2dCwK KwkJCQlFVlRDSE5MX1RZUEVfRVZUKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURSTV9FUlJPUigi RXJyb3IgYWxsb2NhdGluZyBpbi1ldmVudCBjaGFubmVsXG4iKTsKKwkJCWdvdG8gZmFpbDsKKwkJ fQorCX0KKwlmcm9udF9pbmZvLT5udW1fZXZ0X3BhaXJzID0gY2ZnLT5udW1fY29ubmVjdG9yczsK KwlyZXR1cm4gMDsKKworZmFpbDoKKwl4ZW5fZHJtX2Zyb250X2V2dGNobmxfZnJlZV9hbGwoZnJv bnRfaW5mbyk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBldnRjaG5sX3B1Ymxpc2go c3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQsCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2 dGNobmwgKmV2dGNobmwsIGNvbnN0IGNoYXIgKnBhdGgsCisJCWNvbnN0IGNoYXIgKm5vZGVfcmlu ZywgY29uc3QgY2hhciAqbm9kZV9jaG5sKQoreworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9k ZXYgPSBldnRjaG5sLT5mcm9udF9pbmZvLT54Yl9kZXY7CisJaW50IHJldDsKKworCS8qIHdyaXRl IGNvbnRyb2wgY2hhbm5lbCByaW5nIHJlZmVyZW5jZSAqLworCXJldCA9IHhlbmJ1c19wcmludGYo eGJ0LCBwYXRoLCBub2RlX3JpbmcsICIldSIsIGV2dGNobmwtPmdyZWYpOworCWlmIChyZXQgPCAw KSB7CisJCXhlbmJ1c19kZXZfZXJyb3IoeGJfZGV2LCByZXQsICJ3cml0aW5nIHJpbmctcmVmIik7 CisJCXJldHVybiByZXQ7CisJfQorCisJLyogd3JpdGUgZXZlbnQgY2hhbm5lbCByaW5nIHJlZmVy ZW5jZSAqLworCXJldCA9IHhlbmJ1c19wcmludGYoeGJ0LCBwYXRoLCBub2RlX2NobmwsICIldSIs IGV2dGNobmwtPnBvcnQpOworCWlmIChyZXQgPCAwKSB7CisJCXhlbmJ1c19kZXZfZXJyb3IoeGJf ZGV2LCByZXQsICJ3cml0aW5nIGV2ZW50IGNoYW5uZWwiKTsKKwkJcmV0dXJuIHJldDsKKwl9CisK KwlyZXR1cm4gMDsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wdWJsaXNoX2FsbChz dHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCXN0cnVjdCB4ZW5idXNf dHJhbnNhY3Rpb24geGJ0OworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqcGxhdF9kYXRhOwor CWludCByZXQsIGNvbm47CisKKwlwbGF0X2RhdGEgPSAmZnJvbnRfaW5mby0+Y2ZnOworCithZ2Fp bjoKKwlyZXQgPSB4ZW5idXNfdHJhbnNhY3Rpb25fc3RhcnQoJnhidCk7CisJaWYgKHJldCA8IDAp IHsKKwkJeGVuYnVzX2Rldl9mYXRhbChmcm9udF9pbmZvLT54Yl9kZXYsIHJldCwKKwkJCQkic3Rh cnRpbmcgdHJhbnNhY3Rpb24iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlmb3IgKGNvbm4gPSAw OyBjb25uIDwgcGxhdF9kYXRhLT5udW1fY29ubmVjdG9yczsgY29ubisrKSB7CisJCXJldCA9IGV2 dGNobmxfcHVibGlzaCh4YnQsCisJCQkJJmZyb250X2luZm8tPmV2dF9wYWlyc1tjb25uXS5yZXEs CisJCQkJcGxhdF9kYXRhLT5jb25uZWN0b3JzW2Nvbm5dLnhlbnN0b3JlX3BhdGgsCisJCQkJWEVO RElTUExfRklFTERfUkVRX1JJTkdfUkVGLAorCQkJCVhFTkRJU1BMX0ZJRUxEX1JFUV9DSEFOTkVM KTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWw7CisKKwkJcmV0ID0gZXZ0Y2hubF9wdWJs aXNoKHhidCwKKwkJCQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLmV2dCwKKwkJCQlwbGF0 X2RhdGEtPmNvbm5lY3RvcnNbY29ubl0ueGVuc3RvcmVfcGF0aCwKKwkJCQlYRU5ESVNQTF9GSUVM RF9FVlRfUklOR19SRUYsCisJCQkJWEVORElTUExfRklFTERfRVZUX0NIQU5ORUwpOworCQlpZiAo cmV0IDwgMCkKKwkJCWdvdG8gZmFpbDsKKwl9CisKKwlyZXQgPSB4ZW5idXNfdHJhbnNhY3Rpb25f ZW5kKHhidCwgMCk7CisJaWYgKHJldCA8IDApIHsKKwkJaWYgKHJldCA9PSAtRUFHQUlOKQorCQkJ Z290byBhZ2FpbjsKKworCQl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0 LAorCQkJCSJjb21wbGV0aW5nIHRyYW5zYWN0aW9uIik7CisJCWdvdG8gZmFpbF90b19lbmQ7CisJ fQorCisJcmV0dXJuIDA7CisKK2ZhaWw6CisJeGVuYnVzX3RyYW5zYWN0aW9uX2VuZCh4YnQsIDEp OworCitmYWlsX3RvX2VuZDoKKwl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2Rldiwg cmV0LCAid3JpdGluZyBYZW4gc3RvcmUiKTsKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIHhlbl9k cm1fZnJvbnRfZXZ0Y2hubF9mbHVzaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRj aG5sKQoreworCWludCBub3RpZnk7CisKKwlldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2 dCsrOworCVJJTkdfUFVTSF9SRVFVRVNUU19BTkRfQ0hFQ0tfTk9USUZZKCZldnRjaG5sLT51LnJl cS5yaW5nLCBub3RpZnkpOworCWlmIChub3RpZnkpCisJCW5vdGlmeV9yZW1vdGVfdmlhX2lycShl dnRjaG5sLT5pcnEpOworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zZXRfc3RhdGUo c3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJZW51bSB4ZW5fZHJtX2Zy b250X2V2dGNobmxfc3RhdGUgc3RhdGUpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQg aTsKKworCWlmICghZnJvbnRfaW5mby0+ZXZ0X3BhaXJzKQorCQlyZXR1cm47CisKKwlzcGluX2xv Y2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCWZvciAoaSA9IDA7IGkg PCBmcm9udF9pbmZvLT5udW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZnJvbnRfaW5mby0+ZXZ0X3Bh aXJzW2ldLnJlcS5zdGF0ZSA9IHN0YXRlOworCQlmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0 LnN0YXRlID0gc3RhdGU7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8t PmlvX2xvY2ssIGZsYWdzKTsKKworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVl X2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCWludCBpOwor CisJaWYgKCFmcm9udF9pbmZvLT5ldnRfcGFpcnMpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7 IGkgPCBmcm9udF9pbmZvLT5udW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZXZ0Y2hubF9mcmVlKGZy b250X2luZm8sICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0ucmVxKTsKKwkJZXZ0Y2hubF9mcmVl KGZyb250X2luZm8sICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0KTsKKwl9CisKKwlkZXZt X2tmcmVlKCZmcm9udF9pbmZvLT54Yl9kZXYtPmRldiwgZnJvbnRfaW5mby0+ZXZ0X3BhaXJzKTsK Kwlmcm9udF9pbmZvLT5ldnRfcGFpcnMgPSBOVUxMOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udF9ldnRjaG5sLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwLi4zOGNlYWNiOGU5YzEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oCkBAIC0wLDAgKzEsODEgQEAKKy8qIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJhLXZp cnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lz dGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3Nh bmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1fRlJP TlRfRVZUQ0hOTF9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfRVZUQ0hOTF9IXworCisjaW5j bHVkZSA8bGludXgvY29tcGxldGlvbi5oPgorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKyNp bmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2lvL3JpbmcuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNl L2lvL2Rpc3BsaWYuaD4KKworLyoKKyAqIEFsbCBvcGVyYXRpb25zIHdoaWNoIGFyZSBub3QgY29u bmVjdG9yIG9yaWVudGVkIHVzZSB0aGlzIGN0cmwgZXZlbnQgY2hhbm5lbCwKKyAqIGUuZy4gZmJf YXR0YWNoL2Rlc3Ryb3kgd2hpY2ggYmVsb25nIHRvIGEgRFJNIGRldmljZSwgbm90IHRvIGEgQ1JU Qy4KKyAqLworI2RlZmluZSBHRU5FUklDX09QX0VWVF9DSE5MCTAKKworZW51bSB4ZW5fZHJtX2Zy b250X2V2dGNobmxfc3RhdGUgeworCUVWVENITkxfU1RBVEVfRElTQ09OTkVDVEVELAorCUVWVENI TkxfU1RBVEVfQ09OTkVDVEVELAorfTsKKworZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfdHlw ZSB7CisJRVZUQ0hOTF9UWVBFX1JFUSwKKwlFVlRDSE5MX1RZUEVfRVZULAorfTsKKworc3RydWN0 IHhlbl9kcm1fZnJvbnRfZHJtX2luZm87CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwg eworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm87CisJaW50IGdyZWY7CisJ aW50IHBvcnQ7CisJaW50IGlycTsKKwlpbnQgaW5kZXg7CisJZW51bSB4ZW5fZHJtX2Zyb250X2V2 dGNobmxfc3RhdGUgc3RhdGU7CisJZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfdHlwZSB0eXBl OworCS8qIGVpdGhlciByZXNwb25zZSBpZCBvciBpbmNvbWluZyBldmVudCBpZCAqLworCXVpbnQx Nl90IGV2dF9pZDsKKwkvKiBuZXh0IHJlcXVlc3QgaWQgb3IgbmV4dCBleHBlY3RlZCBldmVudCBp ZCAqLworCXVpbnQxNl90IGV2dF9uZXh0X2lkOworCXVuaW9uIHsKKwkJc3RydWN0IHsKKwkJCXN0 cnVjdCB4ZW5fZGlzcGxpZl9mcm9udF9yaW5nIHJpbmc7CisJCQlzdHJ1Y3QgY29tcGxldGlvbiBj b21wbGV0aW9uOworCQkJLyogbGF0ZXN0IHJlc3BvbnNlIHN0YXR1cyAqLworCQkJaW50IHJlc3Bf c3RhdHVzOworCQkJLyogc2VyaWFsaXplciBmb3IgYmFja2VuZCBJTzogcmVxdWVzdC9yZXNwb25z ZSAqLworCQkJc3RydWN0IG11dGV4IHJlcV9pb19sb2NrOworCQl9IHJlcTsKKwkJc3RydWN0IHsK KwkJCXN0cnVjdCB4ZW5kaXNwbF9ldmVudF9wYWdlICpwYWdlOworCQl9IGV2dDsKKwl9IHU7Cit9 OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sX3BhaXIgeworCXN0cnVjdCB4ZW5fZHJt X2Zyb250X2V2dGNobmwgcmVxOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgZXZ0Owor fTsKKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9jcmVhdGVfYWxsKHN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm8pOworCitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3B1 Ymxpc2hfYWxsKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pOworCit2b2lk IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mbHVzaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5s ICpldnRjaG5sKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfc2V0X3N0YXRlKHN0cnVj dCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCWVudW0geGVuX2RybV9mcm9udF9l dnRjaG5sX3N0YXRlIHN0YXRlKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfZnJlZV9h bGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyk7CisKKyNlbmRpZiAvKiBf X1hFTl9EUk1fRlJPTlRfRVZUQ0hOTF9IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250X2dlbS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNGI1NmQy OTc3MDJjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250X2dlbS5jCkBAIC0wLDAgKzEsMzMzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAq CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1 dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgorICovCisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorCisjaW5jbHVk ZSA8ZHJtL2RybVAuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CisjaW5jbHVk ZSA8ZHJtL2RybV9mYl9oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbS5oPgorCisjaW5j bHVkZSA8bGludXgvZG1hLWJ1Zi5oPgorI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+Cisj aW5jbHVkZSA8bGludXgvc2htZW1fZnMuaD4KKworI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CisK KyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1 Zi5oIgorCitzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgeworCXN0cnVjdCBkcm1fZ2VtX29iamVjdCBi YXNlOworCisJc2l6ZV90IG51bV9wYWdlczsKKwlzdHJ1Y3QgcGFnZSAqKnBhZ2VzOworCisJLyog c2V0IGZvciBidWZmZXJzIGFsbG9jYXRlZCBieSB0aGUgYmFja2VuZCAqLworCWJvb2wgYmVfYWxs b2M7CisKKwkvKiB0aGlzIGlzIGZvciBpbXBvcnRlZCBQUklNRSBidWZmZXIgKi8KKwlzdHJ1Y3Qg c2dfdGFibGUgKnNndF9pbXBvcnRlZDsKK307CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IHhlbl9n ZW1fb2JqZWN0ICp0b194ZW5fZ2VtX29iaigKKwkJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1f b2JqKQoreworCXJldHVybiBjb250YWluZXJfb2YoZ2VtX29iaiwgc3RydWN0IHhlbl9nZW1fb2Jq ZWN0LCBiYXNlKTsKK30KKworc3RhdGljIGludCBnZW1fYWxsb2NfcGFnZXNfYXJyYXkoc3RydWN0 IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqLAorCQlzaXplX3QgYnVmX3NpemUpCit7CisJeGVuX29i ai0+bnVtX3BhZ2VzID0gRElWX1JPVU5EX1VQKGJ1Zl9zaXplLCBQQUdFX1NJWkUpOworCXhlbl9v YmotPnBhZ2VzID0ga3ZtYWxsb2NfYXJyYXkoeGVuX29iai0+bnVtX3BhZ2VzLAorCQkJc2l6ZW9m KHN0cnVjdCBwYWdlICopLCBHRlBfS0VSTkVMKTsKKwlyZXR1cm4geGVuX29iai0+cGFnZXMgPT0g TlVMTCA/IC1FTk9NRU0gOiAwOworfQorCitzdGF0aWMgdm9pZCBnZW1fZnJlZV9wYWdlc19hcnJh eShzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmopCit7CisJa3ZmcmVlKHhlbl9vYmotPnBh Z2VzKTsKKwl4ZW5fb2JqLT5wYWdlcyA9IE5VTEw7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2dl bV9vYmplY3QgKmdlbV9jcmVhdGVfb2JqKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJc2l6ZV90 IHNpemUpCit7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOworCWludCByZXQ7CisK Kwl4ZW5fb2JqID0ga3phbGxvYyhzaXplb2YoKnhlbl9vYmopLCBHRlBfS0VSTkVMKTsKKwlpZiAo IXhlbl9vYmopCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJcmV0ID0gZHJtX2dlbV9v YmplY3RfaW5pdChkZXYsICZ4ZW5fb2JqLT5iYXNlLCBzaXplKTsKKwlpZiAocmV0IDwgMCkgewor CQlrZnJlZSh4ZW5fb2JqKTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwlyZXR1cm4g eGVuX29iajsKK30KKworc3RhdGljIHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqZ2VtX2NyZWF0ZShz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9m cm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCB4ZW5f Z2VtX29iamVjdCAqeGVuX29iajsKKwlpbnQgcmV0OworCisJc2l6ZSA9IHJvdW5kX3VwKHNpemUs IFBBR0VfU0laRSk7CisJeGVuX29iaiA9IGdlbV9jcmVhdGVfb2JqKGRldiwgc2l6ZSk7CisJaWYg KElTX0VSUl9PUl9OVUxMKHhlbl9vYmopKQorCQlyZXR1cm4geGVuX29iajsKKworCWlmIChkcm1f aW5mby0+ZnJvbnRfaW5mby0+Y2ZnLmJlX2FsbG9jKSB7CisJCS8qCisJCSAqIGJhY2tlbmQgd2ls bCBhbGxvY2F0ZSBzcGFjZSBmb3IgdGhpcyBidWZmZXIsIHNvCisJCSAqIG9ubHkgYWxsb2NhdGUg YXJyYXkgb2YgcG9pbnRlcnMgdG8gcGFnZXMKKwkJICovCisJCXJldCA9IGdlbV9hbGxvY19wYWdl c19hcnJheSh4ZW5fb2JqLCBzaXplKTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWw7CisK KwkJLyoKKwkJICogYWxsb2NhdGUgYmFsbG9vbmVkIHBhZ2VzIHdoaWNoIHdpbGwgYmUgdXNlZCB0 byBtYXAKKwkJICogZ3JhbnQgcmVmZXJlbmNlcyBwcm92aWRlZCBieSB0aGUgYmFja2VuZAorCQkg Ki8KKwkJcmV0ID0gYWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2VzKHhlbl9vYmotPm51bV9wYWdlcywK KwkJCQl4ZW5fb2JqLT5wYWdlcyk7CisJCWlmIChyZXQgPCAwKSB7CisJCQlEUk1fRVJST1IoIkNh bm5vdCBhbGxvY2F0ZSAlenUgYmFsbG9vbmVkIHBhZ2VzOiAlZFxuIiwKKwkJCQkJeGVuX29iai0+ bnVtX3BhZ2VzLCByZXQpOworCQkJZ2VtX2ZyZWVfcGFnZXNfYXJyYXkoeGVuX29iaik7CisJCQln b3RvIGZhaWw7CisJCX0KKworCQl4ZW5fb2JqLT5iZV9hbGxvYyA9IHRydWU7CisJCXJldHVybiB4 ZW5fb2JqOworCX0KKwkvKgorCSAqIG5lZWQgdG8gYWxsb2NhdGUgYmFja2luZyBwYWdlcyBub3cs IHNvIHdlIGNhbiBzaGFyZSB0aG9zZQorCSAqIHdpdGggdGhlIGJhY2tlbmQKKwkgKi8KKwl4ZW5f b2JqLT5udW1fcGFnZXMgPSBESVZfUk9VTkRfVVAoc2l6ZSwgUEFHRV9TSVpFKTsKKwl4ZW5fb2Jq LT5wYWdlcyA9IGRybV9nZW1fZ2V0X3BhZ2VzKCZ4ZW5fb2JqLT5iYXNlKTsKKwlpZiAoSVNfRVJS X09SX05VTEwoeGVuX29iai0+cGFnZXMpKSB7CisJCXJldCA9IFBUUl9FUlIoeGVuX29iai0+cGFn ZXMpOworCQl4ZW5fb2JqLT5wYWdlcyA9IE5VTEw7CisJCWdvdG8gZmFpbDsKKwl9CisKKwlyZXR1 cm4geGVuX29iajsKKworZmFpbDoKKwlEUk1fRVJST1IoIkZhaWxlZCB0byBhbGxvY2F0ZSBidWZm ZXIgd2l0aCBzaXplICV6dVxuIiwgc2l6ZSk7CisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKwor c3RhdGljIHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqZ2VtX2NyZWF0ZV93aXRoX2hhbmRsZShzdHJ1 Y3QgZHJtX2ZpbGUgKmZpbHAsCisJCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHNpemVfdCBzaXpl LCB1aW50MzJfdCAqaGFuZGxlKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsK KwlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmo7CisJaW50IHJldDsKKworCXhlbl9vYmog PSBnZW1fY3JlYXRlKGRldiwgc2l6ZSk7CisJaWYgKElTX0VSUl9PUl9OVUxMKHhlbl9vYmopKQor CQlyZXR1cm4geGVuX29iajsKKworCWdlbV9vYmogPSAmeGVuX29iai0+YmFzZTsKKwlyZXQgPSBk cm1fZ2VtX2hhbmRsZV9jcmVhdGUoZmlscCwgZ2VtX29iaiwgaGFuZGxlKTsKKwkvKiBoYW5kbGUg aG9sZHMgdGhlIHJlZmVyZW5jZSAqLworCWRybV9nZW1fb2JqZWN0X3VucmVmZXJlbmNlX3VubG9j a2VkKGdlbV9vYmopOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCisJ cmV0dXJuIHhlbl9vYmo7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2dlbV9kdW1iX2NyZWF0ZShz dHJ1Y3QgZHJtX2ZpbGUgKmZpbHAsIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCXN0cnVjdCBk cm1fbW9kZV9jcmVhdGVfZHVtYiAqYXJncykKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhl bl9vYmo7CisKKwlhcmdzLT5waXRjaCA9IERJVl9ST1VORF9VUChhcmdzLT53aWR0aCAqIGFyZ3Mt PmJwcCwgOCk7CisJYXJncy0+c2l6ZSA9IGFyZ3MtPnBpdGNoICogYXJncy0+aGVpZ2h0OworCisJ eGVuX29iaiA9IGdlbV9jcmVhdGVfd2l0aF9oYW5kbGUoZmlscCwgZGV2LCBhcmdzLT5zaXplLCAm YXJncy0+aGFuZGxlKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoeGVuX29iaikpCisJCXJldHVybiB4 ZW5fb2JqID09IE5VTEwgPyAtRU5PTUVNIDogUFRSX0VSUih4ZW5fb2JqKTsKKworCXJldHVybiAw OworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZ2VtX2ZyZWVfb2JqZWN0KHN0cnVjdCBkcm1fZ2Vt X29iamVjdCAqZ2VtX29iaikKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmogPSB0 b194ZW5fZ2VtX29iaihnZW1fb2JqKTsKKworCWlmICh4ZW5fb2JqLT5iYXNlLmltcG9ydF9hdHRh Y2gpIHsKKwkJZHJtX3ByaW1lX2dlbV9kZXN0cm95KCZ4ZW5fb2JqLT5iYXNlLCB4ZW5fb2JqLT5z Z3RfaW1wb3J0ZWQpOworCQlnZW1fZnJlZV9wYWdlc19hcnJheSh4ZW5fb2JqKTsKKwl9IGVsc2Ug eworCQlpZiAoeGVuX29iai0+cGFnZXMpIHsKKwkJCWlmICh4ZW5fb2JqLT5iZV9hbGxvYykgewor CQkJCWZyZWVfeGVuYmFsbG9vbmVkX3BhZ2VzKHhlbl9vYmotPm51bV9wYWdlcywKKwkJCQkJCXhl bl9vYmotPnBhZ2VzKTsKKwkJCQlnZW1fZnJlZV9wYWdlc19hcnJheSh4ZW5fb2JqKTsKKwkJCX0g ZWxzZQorCQkJCWRybV9nZW1fcHV0X3BhZ2VzKCZ4ZW5fb2JqLT5iYXNlLAorCQkJCQkJeGVuX29i ai0+cGFnZXMsIHRydWUsIGZhbHNlKTsKKwkJfQorCX0KKwlkcm1fZ2VtX29iamVjdF9yZWxlYXNl KGdlbV9vYmopOworCWtmcmVlKHhlbl9vYmopOworfQorCitzdHJ1Y3QgcGFnZSAqKnhlbl9kcm1f ZnJvbnRfZ2VtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJ c3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7 CisKKwlyZXR1cm4geGVuX29iai0+cGFnZXM7Cit9CisKK3N0cnVjdCBzZ190YWJsZSAqeGVuX2Ry bV9mcm9udF9nZW1fZ2V0X3NnX3RhYmxlKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikK K3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1f b2JqKTsKKworCWlmICgheGVuX29iai0+cGFnZXMpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJu IGRybV9wcmltZV9wYWdlc190b19zZyh4ZW5fb2JqLT5wYWdlcywgeGVuX29iai0+bnVtX3BhZ2Vz KTsKK30KKworc3RydWN0IGRybV9nZW1fb2JqZWN0ICp4ZW5fZHJtX2Zyb250X2dlbV9pbXBvcnRf c2dfdGFibGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IGRtYV9idWZfYXR0YWNo bWVudCAqYXR0YWNoLCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9m cm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCB4ZW5f Z2VtX29iamVjdCAqeGVuX29iajsKKwlzaXplX3Qgc2l6ZTsKKwlpbnQgcmV0OworCisJc2l6ZSA9 IGF0dGFjaC0+ZG1hYnVmLT5zaXplOworCXhlbl9vYmogPSBnZW1fY3JlYXRlX29iaihkZXYsIHNp emUpOworCWlmIChJU19FUlJfT1JfTlVMTCh4ZW5fb2JqKSkKKwkJcmV0dXJuIEVSUl9DQVNUKHhl bl9vYmopOworCisJcmV0ID0gZ2VtX2FsbG9jX3BhZ2VzX2FycmF5KHhlbl9vYmosIHNpemUpOwor CWlmIChyZXQgPCAwKQorCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCisJeGVuX29iai0+c2d0X2lt cG9ydGVkID0gc2d0OworCisJcmV0ID0gZHJtX3ByaW1lX3NnX3RvX3BhZ2VfYWRkcl9hcnJheXMo c2d0LCB4ZW5fb2JqLT5wYWdlcywKKwkJCU5VTEwsIHhlbl9vYmotPm51bV9wYWdlcyk7CisJaWYg KHJldCA8IDApCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwkvKgorCSAqIE4uQi4gQWx0aG91 Z2ggd2UgaGF2ZSBhbiBBUEkgdG8gY3JlYXRlIGRpc3BsYXkgYnVmZmVyIGZyb20gc2d0CisJICog d2UgdXNlIHBhZ2VzIEFQSSwgYmVjYXVzZSB3ZSBzdGlsbCBuZWVkIHRob3NlIGZvciBHRU0gaGFu ZGxpbmcsCisJICogZS5nLiBmb3IgbWFwcGluZyBldGMuCisJICovCisJcmV0ID0geGVuX2RybV9m cm9udF9kYnVmX2NyZWF0ZV9mcm9tX3BhZ2VzKGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJeGVu X2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZSgmeGVuX29iai0+YmFzZSksCisJCQkwLCAwLCAwLCBz aXplLCB4ZW5fb2JqLT5wYWdlcyk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiBFUlJfUFRSKHJl dCk7CisKKwlEUk1fREVCVUcoIkltcG9ydGVkIGJ1ZmZlciBvZiBzaXplICV6dSB3aXRoIG5lbnRz ICV1XG4iLAorCQlzaXplLCBzZ3QtPm5lbnRzKTsKKworCXJldHVybiAmeGVuX29iai0+YmFzZTsK K30KKworc3RhdGljIGludCBnZW1fbW1hcF9vYmooc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5f b2JqLAorCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwl1bnNpZ25lZCBsb25nIGFk ZHIgPSB2bWEtPnZtX3N0YXJ0OworCWludCBpOworCisJLyoKKwkgKiBjbGVhciB0aGUgVk1fUEZO TUFQIGZsYWcgdGhhdCB3YXMgc2V0IGJ5IGRybV9nZW1fbW1hcCgpLCBhbmQgc2V0IHRoZQorCSAq IHZtX3Bnb2ZmICh1c2VkIGFzIGEgZmFrZSBidWZmZXIgb2Zmc2V0IGJ5IERSTSkgdG8gMCBhcyB3 ZSB3YW50IHRvIG1hcAorCSAqIHRoZSB3aG9sZSBidWZmZXIuCisJICovCisJdm1hLT52bV9mbGFn cyAmPSB+Vk1fUEZOTUFQOworCXZtYS0+dm1fZmxhZ3MgfD0gVk1fTUlYRURNQVA7CisJdm1hLT52 bV9wZ29mZiA9IDA7CisJdm1hLT52bV9wYWdlX3Byb3QgPSBwZ3Byb3Rfd3JpdGVjb21iaW5lKHZt X2dldF9wYWdlX3Byb3Qodm1hLT52bV9mbGFncykpOworCisJLyoKKwkgKiB2bV9vcGVyYXRpb25z X3N0cnVjdC5mYXVsdCBoYW5kbGVyIHdpbGwgYmUgY2FsbGVkIGlmIENQVSBhY2Nlc3MKKwkgKiB0 byBWTSBpcyBoZXJlLiBGb3IgR1BVcyB0aGlzIGlzbid0IHRoZSBjYXNlLCBiZWNhdXNlIENQVQor CSAqIGRvZXNuJ3QgdG91Y2ggdGhlIG1lbW9yeS4gSW5zZXJ0IHBhZ2VzIG5vdywgc28gYm90aCBD UFUgYW5kIEdQVSBhcmUKKwkgKiBoYXBweS4KKwkgKiBGSVhNRTogYXMgd2UgaW5zZXJ0IGFsbCB0 aGUgcGFnZXMgbm93IHRoZW4gbm8gLmZhdWx0IGhhbmRsZXIgbXVzdAorCSAqIGJlIGNhbGxlZCwg c28gZG9uJ3QgcHJvdmlkZSBvbmUKKwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgeGVuX29iai0+bnVt X3BhZ2VzOyBpKyspIHsKKwkJaW50IHJldDsKKworCQlyZXQgPSB2bV9pbnNlcnRfcGFnZSh2bWEs IGFkZHIsIHhlbl9vYmotPnBhZ2VzW2ldKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURSTV9FUlJP UigiRmFpbGVkIHRvIGluc2VydCBwYWdlcyBpbnRvIHZtYTogJWRcbiIsIHJldCk7CisJCQlyZXR1 cm4gcmV0OworCQl9CisKKwkJYWRkciArPSBQQUdFX1NJWkU7CisJfQorCXJldHVybiAwOworfQor CitpbnQgeGVuX2RybV9mcm9udF9nZW1fbW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZt X2FyZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOwor CXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iajsKKwlpbnQgcmV0OworCisJcmV0ID0gZHJt X2dlbV9tbWFwKGZpbHAsIHZtYSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwln ZW1fb2JqID0gdm1hLT52bV9wcml2YXRlX2RhdGE7CisJeGVuX29iaiA9IHRvX3hlbl9nZW1fb2Jq KGdlbV9vYmopOworCXJldHVybiBnZW1fbW1hcF9vYmooeGVuX29iaiwgdm1hKTsKK30KKwordm9p ZCAqeGVuX2RybV9mcm9udF9nZW1fcHJpbWVfdm1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdl bV9vYmopCit7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqID0gdG9feGVuX2dlbV9v YmooZ2VtX29iaik7CisKKwlpZiAoIXhlbl9vYmotPnBhZ2VzKQorCQlyZXR1cm4gTlVMTDsKKwor CXJldHVybiB2bWFwKHhlbl9vYmotPnBhZ2VzLCB4ZW5fb2JqLT5udW1fcGFnZXMsCisJCQlWTV9N QVAsIHBncHJvdF93cml0ZWNvbWJpbmUoUEFHRV9LRVJORUwpKTsKK30KKwordm9pZCB4ZW5fZHJt X2Zyb250X2dlbV9wcmltZV92dW5tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqLAor CQl2b2lkICp2YWRkcikKK3sKKwl2dW5tYXAodmFkZHIpOworfQorCitpbnQgeGVuX2RybV9mcm9u dF9nZW1fcHJpbWVfbW1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosCisJCXN0cnVj dCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29i ajsKKwlpbnQgcmV0OworCisJcmV0ID0gZHJtX2dlbV9tbWFwX29iaihnZW1fb2JqLCBnZW1fb2Jq LT5zaXplLCB2bWEpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJeGVuX29iaiA9 IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCXJldHVybiBnZW1fbW1hcF9vYmooeGVuX29iaiwg dm1hKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9n ZW0uaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjhhMzViYzk4YzFjMQotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaApAQCAtMCwwICsx LDQxIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKwor LyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMp IDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFu ZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNp Zm5kZWYgX19YRU5fRFJNX0ZST05UX0dFTV9ICisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9HRU1f SAorCisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKworaW50IHhlbl9kcm1fZnJvbnRfZ2VtX2R1bWJf Y3JlYXRlKHN0cnVjdCBkcm1fZmlsZSAqZmlscCwgc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJ c3RydWN0IGRybV9tb2RlX2NyZWF0ZV9kdW1iICphcmdzKTsKKworc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICp4ZW5fZHJtX2Zyb250X2dlbV9pbXBvcnRfc2dfdGFibGUoc3RydWN0IGRybV9kZXZpY2Ug KmRldiwKKwkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLCBzdHJ1Y3Qgc2dfdGFi bGUgKnNndCk7CisKK3N0cnVjdCBzZ190YWJsZSAqeGVuX2RybV9mcm9udF9nZW1fZ2V0X3NnX3Rh YmxlKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaik7CisKK3N0cnVjdCBwYWdlICoqeGVu X2RybV9mcm9udF9nZW1fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKTsKKwor dm9pZCB4ZW5fZHJtX2Zyb250X2dlbV9mcmVlX29iamVjdChzdHJ1Y3QgZHJtX2dlbV9vYmplY3Qg KmdlbV9vYmopOworCisjaWZuZGVmIENPTkZJR19EUk1fWEVOX0ZST05URU5EX0NNQQorCitpbnQg eGVuX2RybV9mcm9udF9nZW1fbW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFf c3RydWN0ICp2bWEpOworCit2b2lkICp4ZW5fZHJtX2Zyb250X2dlbV9wcmltZV92bWFwKHN0cnVj dCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaik7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9nZW1fcHJp bWVfdnVubWFwKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaiwKKwkJdm9pZCAqdmFkZHIp OworCitpbnQgeGVuX2RybV9mcm9udF9nZW1fcHJpbWVfbW1hcChzdHJ1Y3QgZHJtX2dlbV9vYmpl Y3QgKmdlbV9vYmosCisJCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKTsKKyNlbmRpZgorCisj ZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX0dFTV9IICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtX2NtYS5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2dlbV9jbWEuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLmM3YzI2NjZlYWIzZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udF9nZW1fY21hLmMKQEAgLTAsMCArMSw3MyBAQAorLy8gU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVh bCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1z IEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJf YW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKyNp bmNsdWRlIDxkcm0vZHJtX2dlbS5oPgorI2luY2x1ZGUgPGRybS9kcm1fZmJfY21hX2hlbHBlci5o PgorI2luY2x1ZGUgPGRybS9kcm1fZ2VtX2NtYV9oZWxwZXIuaD4KKworI2luY2x1ZGUgInhlbl9k cm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorCitzdHJ1Y3QgZHJt X2dlbV9vYmplY3QgKnhlbl9kcm1fZnJvbnRfZ2VtX2ltcG9ydF9zZ190YWJsZShzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LAorCQlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsIHN0cnVj dCBzZ190YWJsZSAqc2d0KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1f aW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2Jq OworCXN0cnVjdCBkcm1fZ2VtX2NtYV9vYmplY3QgKmNtYV9vYmo7CisJaW50IHJldDsKKworCWdl bV9vYmogPSBkcm1fZ2VtX2NtYV9wcmltZV9pbXBvcnRfc2dfdGFibGUoZGV2LCBhdHRhY2gsIHNn dCk7CisJaWYgKElTX0VSUl9PUl9OVUxMKGdlbV9vYmopKQorCQlyZXR1cm4gZ2VtX29iajsKKwor CWNtYV9vYmogPSB0b19kcm1fZ2VtX2NtYV9vYmooZ2VtX29iaik7CisKKwlyZXQgPSB4ZW5fZHJt X2Zyb250X2RidWZfY3JlYXRlX2Zyb21fc2d0KAorCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJ CQl4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2llKGdlbV9vYmopLAorCQkJMCwgMCwgMCwgZ2Vt X29iai0+c2l6ZSwKKwkJCWRybV9nZW1fY21hX3ByaW1lX2dldF9zZ190YWJsZShnZW1fb2JqKSk7 CisJaWYgKHJldCA8IDApCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwlEUk1fREVCVUcoIklt cG9ydGVkIENNQSBidWZmZXIgb2Ygc2l6ZSAlenVcbiIsIGdlbV9vYmotPnNpemUpOworCisJcmV0 dXJuIGdlbV9vYmo7Cit9CisKK3N0cnVjdCBzZ190YWJsZSAqeGVuX2RybV9mcm9udF9nZW1fZ2V0 X3NnX3RhYmxlKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlyZXR1cm4gZHJt X2dlbV9jbWFfcHJpbWVfZ2V0X3NnX3RhYmxlKGdlbV9vYmopOworfQorCitpbnQgeGVuX2RybV9m cm9udF9nZW1fZHVtYl9jcmVhdGUoc3RydWN0IGRybV9maWxlICpmaWxwLCBzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAorCXN0cnVjdCBkcm1fbW9kZV9jcmVhdGVfZHVtYiAqYXJncykKK3sKKwlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOwor CisJaWYgKGRybV9pbmZvLT5mcm9udF9pbmZvLT5jZmcuYmVfYWxsb2MpIHsKKwkJLyogVGhpcyB1 c2UtY2FzZSBpcyBub3QgeWV0IHN1cHBvcnRlZCBhbmQgcHJvYmFibHkgd29uJ3QgYmUgKi8KKwkJ RFJNX0VSUk9SKCJCYWNrZW5kIGFsbG9jYXRlZCBidWZmZXJzIGFuZCBDTUEgaGVscGVycyBhcmUg bm90IHN1cHBvcnRlZCBhdCB0aGUgc2FtZSB0aW1lXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJ fQorCisJcmV0dXJuIGRybV9nZW1fY21hX2R1bWJfY3JlYXRlKGZpbHAsIGRldiwgYXJncyk7Cit9 CisKK3ZvaWQgeGVuX2RybV9mcm9udF9nZW1fZnJlZV9vYmplY3Qoc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICpnZW1fb2JqKQoreworCWRybV9nZW1fY21hX2ZyZWVfb2JqZWN0KGdlbV9vYmopOworfQor CitzdHJ1Y3QgcGFnZSAqKnhlbl9kcm1fZnJvbnRfZ2VtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2dl bV9vYmplY3QgKmdlbV9vYmopCit7CisJcmV0dXJuIE5VTEw7Cit9CmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfa21zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi45MTMwYjYxYzlhNTgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfa21zLmMKQEAgLTAsMCArMSwzMjMgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJN IGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMu CisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1 c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfa21zLmgi CisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljLmg+Cisj aW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRj X2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fZ2VtLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9n ZW1fZnJhbWVidWZmZXJfaGVscGVyLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisj aW5jbHVkZSAieGVuX2RybV9mcm9udF9jb25uLmgiCisKKy8qCisgKiBUaW1lb3V0IGluIG1zIHRv IHdhaXQgZm9yIGZyYW1lIGRvbmUgZXZlbnQgZnJvbSB0aGUgYmFja2VuZDoKKyAqIG11c3QgYmUg YSBiaXQgbW9yZSB0aGFuIElPIHRpbWUtb3V0CisgKi8KKyNkZWZpbmUgRlJBTUVfRE9ORV9UT19N UwkoWEVOX0RSTV9GUk9OVF9XQUlUX0JBQ0tfTVMgKyAxMDApCisKK3N0YXRpYyBzdHJ1Y3QgeGVu X2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKgordG9feGVuX2RybV9waXBlbGluZShzdHJ1Y3QgZHJt X3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUpCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihwaXBl LCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUsIHBpcGUpOworfQorCitzdGF0aWMg dm9pZCBmYl9kZXN0cm95KHN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiKQoreworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IGZiLT5kZXYtPmRldl9wcml2YXRlOwor CisJeGVuX2RybV9mcm9udF9mYl9kZXRhY2goZHJtX2luZm8tPmZyb250X2luZm8sCisJCQl4ZW5f ZHJtX2Zyb250X2ZiX3RvX2Nvb2tpZShmYikpOworCWRybV9nZW1fZmJfZGVzdHJveShmYik7Cit9 CisKK3N0YXRpYyBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyX2Z1bmNzIGZiX2Z1bmNzID0geworCS5k ZXN0cm95ID0gZmJfZGVzdHJveSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVy ICpmYl9jcmVhdGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IGRybV9maWxlICpm aWxwLCBjb25zdCBzdHJ1Y3QgZHJtX21vZGVfZmJfY21kMiAqbW9kZV9jbWQpCit7CisJc3RydWN0 IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlz dGF0aWMgc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmI7CisJc3RydWN0IGRybV9nZW1fb2JqZWN0 ICpnZW1fb2JqOworCWludCByZXQ7CisKKwlmYiA9IGRybV9nZW1fZmJfY3JlYXRlX3dpdGhfZnVu Y3MoZGV2LCBmaWxwLCBtb2RlX2NtZCwgJmZiX2Z1bmNzKTsKKwlpZiAoSVNfRVJSX09SX05VTEwo ZmIpKQorCQlyZXR1cm4gZmI7CisKKwlnZW1fb2JqID0gZHJtX2dlbV9vYmplY3RfbG9va3VwKGZp bHAsIG1vZGVfY21kLT5oYW5kbGVzWzBdKTsKKwlpZiAoIWdlbV9vYmopIHsKKwkJRFJNX0VSUk9S KCJGYWlsZWQgdG8gbG9va3VwIEdFTSBvYmplY3RcbiIpOworCQlyZXQgPSAtRU5PRU5UOworCQln b3RvIGZhaWw7CisJfQorCisJZHJtX2dlbV9vYmplY3RfdW5yZWZlcmVuY2VfdW5sb2NrZWQoZ2Vt X29iaik7CisKKwlyZXQgPSB4ZW5fZHJtX2Zyb250X2ZiX2F0dGFjaCgKKwkJCWRybV9pbmZvLT5m cm9udF9pbmZvLAorCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShnZW1fb2JqKSwKKwkJ CXhlbl9kcm1fZnJvbnRfZmJfdG9fY29va2llKGZiKSwKKwkJCWZiLT53aWR0aCwgZmItPmhlaWdo dCwgZmItPmZvcm1hdC0+Zm9ybWF0KTsKKwlpZiAocmV0IDwgMCkgeworCQlEUk1fRVJST1IoIkJh Y2sgZmFpbGVkIHRvIGF0dGFjaCBGQiAlcDogJWRcbiIsIGZiLCByZXQpOworCQlnb3RvIGZhaWw7 CisJfQorCisJcmV0dXJuIGZiOworCitmYWlsOgorCWRybV9nZW1fZmJfZGVzdHJveShmYik7CisJ cmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fbW9kZV9j b25maWdfZnVuY3MgbW9kZV9jb25maWdfZnVuY3MgPSB7CisJLmZiX2NyZWF0ZSA9IGZiX2NyZWF0 ZSwKKwkuYXRvbWljX2NoZWNrID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2ssCisJLmF0b21pY19j b21taXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jb21taXQsCit9OworCit2b2lkIHhlbl9kcm1fZnJv bnRfa21zX3NlbmRfcGVuZGluZ19ldmVudCgKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3Bp cGVsaW5lICpwaXBlbGluZSkKK3sKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmcGlwZWxpbmUt PnBpcGUuY3J0YzsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ZGV2OworCXVuc2ln bmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5ldmVudF9sb2NrLCBm bGFncyk7CisJaWYgKHBpcGVsaW5lLT5wZW5kaW5nX2V2ZW50KQorCQlkcm1fY3J0Y19zZW5kX3Zi bGFua19ldmVudChjcnRjLCBwaXBlbGluZS0+cGVuZGluZ19ldmVudCk7CisJcGlwZWxpbmUtPnBl bmRpbmdfZXZlbnQgPSBOVUxMOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+ZXZlbnRf bG9jaywgZmxhZ3MpOworfQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X2VuYWJsZShzdHJ1Y3QgZHJt X3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0 Y19zdGF0ZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5l ID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUocGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpjcnRj ID0gJnBpcGUtPmNydGM7CisJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwaXBlLT5wbGFu ZS5zdGF0ZS0+ZmI7CisJaW50IHJldDsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQo cGlwZWxpbmUsCisJCQljcnRjLT54LCBjcnRjLT55LCBmYi0+d2lkdGgsIGZiLT5oZWlnaHQsCisJ CQlmYi0+Zm9ybWF0LT5jcHBbMF0gKiA4LAorCQkJeGVuX2RybV9mcm9udF9mYl90b19jb29raWUo ZmIpKTsKKworCWlmIChyZXQpIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gZW5hYmxlIGRpc3Bs YXk6ICVkXG4iLCByZXQpOworCQlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSBmYWxzZTsKKwl9 Cit9CisKK3N0YXRpYyB2b2lkIGRpc3BsYXlfZGlzYWJsZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNw bGF5X3BpcGUgKnBpcGUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpw aXBlbGluZSA9CisJCQl0b194ZW5fZHJtX3BpcGVsaW5lKHBpcGUpOworCXN0cnVjdCB4ZW5fZHJt X2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IHBpcGVsaW5lLT5kcm1faW5mbzsKKwl1bnNpZ25l ZCBsb25nIGZsYWdzOworCWludCByZXQ7CisKKwlyZXQgPSB4ZW5fZHJtX2Zyb250X21vZGVfc2V0 KHBpcGVsaW5lLCAwLCAwLCAwLCAwLCAwLAorCQkJeGVuX2RybV9mcm9udF9mYl90b19jb29raWUo TlVMTCkpOworCWlmIChyZXQpCisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGRpc2FibGUgZGlzcGxh eTogJWRcbiIsIHJldCk7CisKKwlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSB0cnVlOworCisJ c3Bpbl9sb2NrX2lycXNhdmUoJmRybV9pbmZvLT5mcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7 CisJcGlwZWxpbmUtPnBmbGlwX3RpbWVvdXQgPSAwOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUo JmRybV9pbmZvLT5mcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwkvKiByZWxlYXNlIHN0 YWxsZWQgZXZlbnQgaWYgYW55ICovCisJeGVuX2RybV9mcm9udF9rbXNfc2VuZF9wZW5kaW5nX2V2 ZW50KHBpcGVsaW5lKTsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X2ttc19vbl9mcmFtZV9kb25l KAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lLAorCQl1aW50 NjRfdCBmYl9jb29raWUpCit7CisJLyoKKwkgKiBUaGlzIGFscmVhZHkgcnVucyBpbiBpbnRlcnJ1 cHQgY29udGV4dCwgZS5nLiB1bmRlcgorCSAqIGRybV9pbmZvLT5mcm9udF9pbmZvLT5pb19sb2Nr CisJICovCisJcGlwZWxpbmUtPnBmbGlwX3RpbWVvdXQgPSAwOworCisJeGVuX2RybV9mcm9udF9r bXNfc2VuZF9wZW5kaW5nX2V2ZW50KHBpcGVsaW5lKTsKK30KKworc3RhdGljIGJvb2wgZGlzcGxh eV9zZW5kX3BhZ2VfZmxpcChzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJ CXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9wbGFuZV9zdGF0ZSkKK3sKKwlzdHJ1Y3QgZHJt X3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X25ld19wbGFuZV9zdGF0 ZSgKKwkJCW9sZF9wbGFuZV9zdGF0ZS0+c3RhdGUsICZwaXBlLT5wbGFuZSk7CisKKwkvKgorCSAq IElmIG9sZF9wbGFuZV9zdGF0ZS0+ZmIgaXMgTlVMTCBhbmQgcGxhbmVfc3RhdGUtPmZiIGlzIG5v dCwKKwkgKiB0aGVuIHRoaXMgaXMgYW4gYXRvbWljIGNvbW1pdCB3aGljaCB3aWxsIGVuYWJsZSBk aXNwbGF5LgorCSAqIElmIG9sZF9wbGFuZV9zdGF0ZS0+ZmIgaXMgbm90IE5VTEwgYW5kIHBsYW5l X3N0YXRlLT5mYiBpcywKKwkgKiB0aGVuIHRoaXMgaXMgYW4gYXRvbWljIGNvbW1pdCB3aGljaCB3 aWxsIGRpc2FibGUgZGlzcGxheS4KKwkgKiBJZ25vcmUgdGhlc2UgYW5kIGRvIG5vdCBzZW5kIHBh Z2UgZmxpcCBhcyB0aGlzIGZyYW1lYnVmZmVyIHdpbGwgYmUKKwkgKiBzZW50IHRvIHRoZSBiYWNr ZW5kIGFzIGEgcGFydCBvZiBkaXNwbGF5X3NldF9jb25maWcgY2FsbC4KKwkgKi8KKwlpZiAob2xk X3BsYW5lX3N0YXRlLT5mYiAmJiBwbGFuZV9zdGF0ZS0+ZmIpIHsKKwkJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQkJdG9feGVuX2RybV9waXBlbGluZShw aXBlKTsKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gcGlwZWxp bmUtPmRybV9pbmZvOworCQl1bnNpZ25lZCBsb25nIGZsYWdzOworCQlpbnQgcmV0OworCisJCXNw aW5fbG9ja19pcnFzYXZlKCZkcm1faW5mby0+ZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOwor CQlwaXBlbGluZS0+cGZsaXBfdGltZW91dCA9IGppZmZpZXMgKworCQkJCW1zZWNzX3RvX2ppZmZp ZXMoRlJBTUVfRE9ORV9UT19NUyk7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRybV9pbmZv LT5mcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwkJcmV0ID0geGVuX2RybV9mcm9udF9w YWdlX2ZsaXAoZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJcGlwZWxpbmUtPmluZGV4LAorCQkJ CXhlbl9kcm1fZnJvbnRfZmJfdG9fY29va2llKHBsYW5lX3N0YXRlLT5mYikpOworCQlpZiAocmV0 KSB7CisJCQlEUk1fRVJST1IoIkZhaWxlZCB0byBzZW5kIHBhZ2UgZmxpcCByZXF1ZXN0IHRvIGJh Y2tlbmQ6ICVkXG4iLCByZXQpOworCisJCQlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSBmYWxz ZTsKKwkJCS8qCisJCQkgKiBSZXBvcnQgdGhlIGZsaXAgbm90IGhhbmRsZWQsIHNvIHBlbmRpbmcg ZXZlbnQgaXMKKwkJCSAqIHNlbnQsIHVuYmxvY2tpbmcgdXNlci1zcGFjZS4KKwkJCSAqLworCQkJ cmV0dXJuIGZhbHNlOworCQl9CisJCS8qCisJCSAqIFNpZ25hbCB0aGF0IHBhZ2UgZmxpcCB3YXMg aGFuZGxlZCwgcGVuZGluZyBldmVudCB3aWxsIGJlIHNlbnQKKwkJICogb24gZnJhbWUgZG9uZSBl dmVudCBmcm9tIHRoZSBiYWNrZW5kLgorCQkgKi8KKwkJcmV0dXJuIHRydWU7CisJfQorCisJcmV0 dXJuIGZhbHNlOworfQorCitzdGF0aWMgaW50IGRpc3BsYXlfcHJlcGFyZV9mYihzdHJ1Y3QgZHJt X3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBs YW5lX3N0YXRlKQoreworCXJldHVybiBkcm1fZ2VtX2ZiX3ByZXBhcmVfZmIoJnBpcGUtPnBsYW5l LCBwbGFuZV9zdGF0ZSk7Cit9CisKK3N0YXRpYyBpbnQgZGlzcGxheV9jaGVjayhzdHJ1Y3QgZHJt X3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBs YW5lX3N0YXRlLAorCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUpCit7CisJc3Ry dWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQl0b194ZW5fZHJt X3BpcGVsaW5lKHBpcGUpOworCisJcmV0dXJuIHBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA/IDAg OiAtRUlOVkFMOworfQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X3VwZGF0ZShzdHJ1Y3QgZHJtX3Np bXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9w bGFuZV9zdGF0ZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVs aW5lID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUocGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpj cnRjID0gJnBpcGUtPmNydGM7CisJc3RydWN0IGRybV9wZW5kaW5nX3ZibGFua19ldmVudCAqZXZl bnQ7CisKKwlldmVudCA9IGNydGMtPnN0YXRlLT5ldmVudDsKKwlpZiAoZXZlbnQpIHsKKwkJc3Ry dWN0IGRybV9kZXZpY2UgKmRldiA9IGNydGMtPmRldjsKKwkJdW5zaWduZWQgbG9uZyBmbGFnczsK KworCQlXQVJOX09OKHBpcGVsaW5lLT5wZW5kaW5nX2V2ZW50KTsKKworCQlzcGluX2xvY2tfaXJx c2F2ZSgmZGV2LT5ldmVudF9sb2NrLCBmbGFncyk7CisJCWNydGMtPnN0YXRlLT5ldmVudCA9IE5V TEw7CisKKwkJcGlwZWxpbmUtPnBlbmRpbmdfZXZlbnQgPSBldmVudDsKKwkJc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmZGV2LT5ldmVudF9sb2NrLCBmbGFncyk7CisKKwl9CisJLyoKKwkgKiBTZW5k IHBhZ2UgZmxpcCByZXF1ZXN0IHRvIHRoZSBiYWNrZW5kICphZnRlciogd2UgaGF2ZSBldmVudCBj YWNoZWQKKwkgKiBhYm92ZSwgc28gb24gcGFnZSBmbGlwIGRvbmUgZXZlbnQgZnJvbSB0aGUgYmFj a2VuZCB3ZSBjYW4KKwkgKiBkZWxpdmVyIGl0IGFuZCB0aGVyZSBpcyBubyByYWNlIGNvbmRpdGlv biBiZXR3ZWVuIHRoaXMgY29kZSBhbmQKKwkgKiBldmVudCBmcm9tIHRoZSBiYWNrZW5kLgorCSAq IElmIHRoaXMgaXMgbm90IGEgcGFnZSBmbGlwLCBlLmcuIG5vIGZsaXAgZG9uZSBldmVudCBmcm9t IHRoZSBiYWNrZW5kCisJICogaXMgZXhwZWN0ZWQsIHRoZW4gc2VuZCBub3cuCisJICovCisJaWYg KCFkaXNwbGF5X3NlbmRfcGFnZV9mbGlwKHBpcGUsIG9sZF9wbGFuZV9zdGF0ZSkpCisJCXhlbl9k cm1fZnJvbnRfa21zX3NlbmRfcGVuZGluZ19ldmVudChwaXBlbGluZSk7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfZnVuY3MgZGlzcGxheV9mdW5jcyA9 IHsKKwkuZW5hYmxlID0gZGlzcGxheV9lbmFibGUsCisJLmRpc2FibGUgPSBkaXNwbGF5X2Rpc2Fi bGUsCisJLmNoZWNrID0gZGlzcGxheV9jaGVjaywKKwkucHJlcGFyZV9mYiA9IGRpc3BsYXlfcHJl cGFyZV9mYiwKKwkudXBkYXRlID0gZGlzcGxheV91cGRhdGUsCit9OworCitzdGF0aWMgaW50IGRp c3BsYXlfcGlwZV9pbml0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbywK KwkJaW50IGluZGV4LCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmdfY29ubmVjdG9yICpjZmcsCisJ CXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUpCit7CisJc3RydWN0 IGRybV9kZXZpY2UgKmRldiA9IGRybV9pbmZvLT5kcm1fZGV2OworCWNvbnN0IHVpbnQzMl90ICpm b3JtYXRzOworCWludCBmb3JtYXRfY291bnQ7CisJaW50IHJldDsKKworCXBpcGVsaW5lLT5kcm1f aW5mbyA9IGRybV9pbmZvOworCXBpcGVsaW5lLT5pbmRleCA9IGluZGV4OworCXBpcGVsaW5lLT5o ZWlnaHQgPSBjZmctPmhlaWdodDsKKwlwaXBlbGluZS0+d2lkdGggPSBjZmctPndpZHRoOworCisJ cmV0ID0geGVuX2RybV9mcm9udF9jb25uX2luaXQoZHJtX2luZm8sICZwaXBlbGluZS0+Y29ubik7 CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWZvcm1hdHMgPSB4ZW5fZHJtX2Zyb250X2Nv bm5fZ2V0X2Zvcm1hdHMoJmZvcm1hdF9jb3VudCk7CisKKwlyZXR1cm4gZHJtX3NpbXBsZV9kaXNw bGF5X3BpcGVfaW5pdChkZXYsICZwaXBlbGluZS0+cGlwZSwKKwkJCSZkaXNwbGF5X2Z1bmNzLCBm b3JtYXRzLCBmb3JtYXRfY291bnQsCisJCQlOVUxMLCAmcGlwZWxpbmUtPmNvbm4pOworfQorCitp bnQgeGVuX2RybV9mcm9udF9rbXNfaW5pdChzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAq ZHJtX2luZm8pCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGRybV9pbmZvLT5kcm1fZGV2 OworCWludCBpLCByZXQ7CisKKwlkcm1fbW9kZV9jb25maWdfaW5pdChkZXYpOworCisJZGV2LT5t b2RlX2NvbmZpZy5taW5fd2lkdGggPSAwOworCWRldi0+bW9kZV9jb25maWcubWluX2hlaWdodCA9 IDA7CisJZGV2LT5tb2RlX2NvbmZpZy5tYXhfd2lkdGggPSA0MDk1OworCWRldi0+bW9kZV9jb25m aWcubWF4X2hlaWdodCA9IDIwNDc7CisJZGV2LT5tb2RlX2NvbmZpZy5mdW5jcyA9ICZtb2RlX2Nv bmZpZ19mdW5jczsKKworCWZvciAoaSA9IDA7IGkgPCBkcm1faW5mby0+ZnJvbnRfaW5mby0+Y2Zn Lm51bV9jb25uZWN0b3JzOyBpKyspIHsKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnX2Nvbm5l Y3RvciAqY2ZnID0KKwkJCQkmZHJtX2luZm8tPmZyb250X2luZm8tPmNmZy5jb25uZWN0b3JzW2ld OworCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCQkm ZHJtX2luZm8tPnBpcGVsaW5lW2ldOworCisJCXJldCA9IGRpc3BsYXlfcGlwZV9pbml0KGRybV9p bmZvLCBpLCBjZmcsIHBpcGVsaW5lKTsKKwkJaWYgKHJldCkgeworCQkJZHJtX21vZGVfY29uZmln X2NsZWFudXAoZGV2KTsKKwkJCXJldHVybiByZXQ7CisJCX0KKwl9CisKKwlkcm1fbW9kZV9jb25m aWdfcmVzZXQoZGV2KTsKKwlkcm1fa21zX2hlbHBlcl9wb2xsX2luaXQoZGV2KTsKKwlyZXR1cm4g MDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMu aCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjI5ZmQ1ODJiNWIyNwotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuaApAQCAtMCwwICsxLDI4 IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoK KyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5k ZWYgX19YRU5fRFJNX0ZST05UX0tNU19IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfS01TX0hf CisKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1f aW5mbzsKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZTsKKworaW50IHhlbl9kcm1f ZnJvbnRfa21zX2luaXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvKTsK Kwordm9pZCB4ZW5fZHJtX2Zyb250X2ttc19vbl9mcmFtZV9kb25lKAorCQlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lLAorCQl1aW50NjRfdCBmYl9jb29raWUpOwor Cit2b2lkIHhlbl9kcm1fZnJvbnRfa21zX3NlbmRfcGVuZGluZ19ldmVudCgKKwkJc3RydWN0IHhl bl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSk7CisKKyNlbmRpZiAvKiBfX1hFTl9E Uk1fRlJPTlRfS01TX0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9k cm1fZnJvbnRfc2hidWYuYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1 Zi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMGZkZTJkOGY3NzA2 Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3No YnVmLmMKQEAgLTAsMCArMSw0MzIgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwt Mi4wIE9SIE1JVAorCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAq IENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9y OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5j b20+CisgKi8KKworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisKKyNpZiBkZWZpbmVkKENPTkZJR19Y ODYpCisjaW5jbHVkZSA8ZHJtL2RybV9jYWNoZS5oPgorI2VuZGlmCisjaW5jbHVkZSA8bGludXgv ZXJybm8uaD4KKyNpbmNsdWRlIDxsaW51eC9tbS5oPgorCisjaW5jbHVkZSA8YXNtL3hlbi9oeXBl cnZpc29yLmg+CisjaW5jbHVkZSA8eGVuL2JhbGxvb24uaD4KKyNpbmNsdWRlIDx4ZW4veGVuLmg+ CisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvaW8vcmlu Zy5oPgorI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvaW8vZGlzcGxpZi5oPgorCisjaW5jbHVkZSAi eGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfc2hidWYuaCIKKworc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfb3BzIHsKKwkvKgorCSAqIENhbGN1bGF0ZSBudW1iZXIg b2YgZ3JlZnMgcmVxdWlyZWQgdG8gaGFuZGxlIHRoaXMgYnVmZmVyLAorCSAqIGUuZy4gaWYgZ3Jl ZnMgYXJlIHJlcXVpcmVkIGZvciBwYWdlIGRpcmVjdG9yeSBvbmx5IG9yIHRoZSBidWZmZXIKKwkg KiBwYWdlcyBhcyB3ZWxsLgorCSAqLworCXZvaWQgKCpjYWxjX251bV9ncmVmcykoc3RydWN0IHhl bl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisJLyogRmlsbCBwYWdlIGRpcmVjdG9yeSBhY2NvcmRp bmcgdG8gcGFyYS12aXJ0dWFsIGRpc3BsYXkgcHJvdG9jb2wuICovCisJdm9pZCAoKmZpbGxfcGFn ZV9kaXIpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCS8qIENsYWltIGdyYW50 IHJlZmVyZW5jZXMgZm9yIHRoZSBwYWdlcyBvZiB0aGUgYnVmZmVyLiAqLworCWludCAoKmdyYW50 X3JlZnNfZm9yX2J1ZmZlcikoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZiwKKwkJCWdy YW50X3JlZl90ICpwcml2X2dyZWZfaGVhZCwgaW50IGdyZWZfaWR4KTsKKwkvKiBNYXAgZ3JhbnQg cmVmZXJlbmNlcyBvZiB0aGUgYnVmZmVyLiAqLworCWludCAoKm1hcCkoc3RydWN0IHhlbl9kcm1f ZnJvbnRfc2hidWYgKmJ1Zik7CisJLyogVW5tYXAgZ3JhbnQgcmVmZXJlbmNlcyBvZiB0aGUgYnVm ZmVyLiAqLworCWludCAoKnVubWFwKShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsK K307CisKK2dyYW50X3JlZl90IHhlbl9kcm1fZnJvbnRfc2hidWZfZ2V0X2Rpcl9zdGFydChzdHJ1 Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCWlmICghYnVmLT5ncmVmcykKKwkJcmV0 dXJuIEdSQU5UX0lOVkFMSURfUkVGOworCisJcmV0dXJuIGJ1Zi0+Z3JlZnNbMF07Cit9CisKK2lu dCB4ZW5fZHJtX2Zyb250X3NoYnVmX21hcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVm KQoreworCWlmIChidWYtPm9wcy0+bWFwKQorCQlyZXR1cm4gYnVmLT5vcHMtPm1hcChidWYpOwor CisJLyogbm8gbmVlZCB0byBtYXAgb3duIGdyYW50IHJlZmVyZW5jZXMgKi8KKwlyZXR1cm4gMDsK K30KKworaW50IHhlbl9kcm1fZnJvbnRfc2hidWZfdW5tYXAoc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWYgKmJ1ZikKK3sKKwlpZiAoYnVmLT5vcHMtPnVubWFwKQorCQlyZXR1cm4gYnVmLT5vcHMt PnVubWFwKGJ1Zik7CisKKwkvKiBubyBuZWVkIHRvIHVubWFwIG93biBncmFudCByZWZlcmVuY2Vz ICovCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mbHVzaChzdHJ1 Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworI2lmIGRlZmluZWQoQ09ORklHX1g4NikK Kwlkcm1fY2xmbHVzaF9wYWdlcyhidWYtPnBhZ2VzLCBidWYtPm51bV9wYWdlcyk7CisjZW5kaWYK K30KKwordm9pZCB4ZW5fZHJtX2Zyb250X3NoYnVmX2ZyZWUoc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWYgKmJ1ZikKK3sKKwlpZiAoYnVmLT5ncmVmcykgeworCQlpbnQgaTsKKworCQlmb3IgKGkg PSAwOyBpIDwgYnVmLT5udW1fZ3JlZnM7IGkrKykKKwkJCWlmIChidWYtPmdyZWZzW2ldICE9IEdS QU5UX0lOVkFMSURfUkVGKQorCQkJCWdudHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3MoYnVmLT5ncmVm c1tpXSwKKwkJCQkJMCwgMFVMKTsKKwl9CisJa2ZyZWUoYnVmLT5ncmVmcyk7CisJa2ZyZWUoYnVm LT5kaXJlY3RvcnkpOworCWlmIChidWYtPnNndCkgeworCQlzZ19mcmVlX3RhYmxlKGJ1Zi0+c2d0 KTsKKwkJa3ZmcmVlKGJ1Zi0+cGFnZXMpOworCX0KKwlrZnJlZShidWYpOworfQorCisvKgorICog bnVtYmVyIG9mIGdyZWZzIGEgcGFnZSBjYW4gaG9sZCB3aXRoIHJlc3BlY3QgdG8gdGhlCisgKiBz dHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgaGVhZGVyCisgKi8KKyNkZWZpbmUgWEVOX0RS TV9OVU1fR1JFRlNfUEVSX1BBR0UgKChQQUdFX1NJWkUgLSBcCisJb2Zmc2V0b2Yoc3RydWN0IHhl bmRpc3BsX3BhZ2VfZGlyZWN0b3J5LCBncmVmKSkgLyBcCisJc2l6ZW9mKGdyYW50X3JlZl90KSkK Kworc3RhdGljIGludCBnZXRfbnVtX3BhZ2VzX2RpcihzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1 ZiAqYnVmKQoreworCS8qIG51bWJlciBvZiBwYWdlcyB0aGUgcGFnZSBkaXJlY3RvcnkgY29uc3Vt ZXMgaXRzZWxmICovCisJcmV0dXJuIERJVl9ST1VORF9VUChidWYtPm51bV9wYWdlcywgWEVOX0RS TV9OVU1fR1JFRlNfUEVSX1BBR0UpOworfQorCitzdGF0aWMgdm9pZCBiYWNrZW5kX2NhbGNfbnVt X2dyZWZzKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJLyogb25seSBmb3Ig cGFnZXMgdGhlIHBhZ2UgZGlyZWN0b3J5IGNvbnN1bWVzIGl0c2VsZiAqLworCWJ1Zi0+bnVtX2dy ZWZzID0gZ2V0X251bV9wYWdlc19kaXIoYnVmKTsKK30KKworc3RhdGljIHZvaWQgZ3Vlc3RfY2Fs Y19udW1fZ3JlZnMoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwkvKgorCSAq IG51bWJlciBvZiBwYWdlcyB0aGUgcGFnZSBkaXJlY3RvcnkgY29uc3VtZXMgaXRzZWxmCisJICog cGx1cyBncmVmcyBmb3IgdGhlIGJ1ZmZlciBwYWdlcworCSAqLworCWJ1Zi0+bnVtX2dyZWZzID0g Z2V0X251bV9wYWdlc19kaXIoYnVmKSArIGJ1Zi0+bnVtX3BhZ2VzOworfQorCisjZGVmaW5lIHhl bl9wYWdlX3RvX3ZhZGRyKHBhZ2UpIFwKKwkJKChwaHlzX2FkZHJfdClwZm5fdG9fa2FkZHIocGFn ZV90b194ZW5fcGZuKHBhZ2UpKSkKKworc3RhdGljIGludCBiYWNrZW5kX3VubWFwKHN0cnVjdCB4 ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJc3RydWN0IGdudHRhYl91bm1hcF9ncmFudF9y ZWYgKnVubWFwX29wczsKKwlpbnQgaSwgcmV0OworCisJaWYgKCFidWYtPnBhZ2VzIHx8ICFidWYt PmJhY2tlbmRfbWFwX2hhbmRsZXMgfHwgIWJ1Zi0+Z3JlZnMpCisJCXJldHVybiAwOworCisJdW5t YXBfb3BzID0ga2NhbGxvYyhidWYtPm51bV9wYWdlcywgc2l6ZW9mKCp1bm1hcF9vcHMpLAorCQlH RlBfS0VSTkVMKTsKKwlpZiAoIXVubWFwX29wcykgeworCQlEUk1fRVJST1IoIkZhaWxlZCB0byBn ZXQgbWVtb3J5IHdoaWxlIHVubWFwcGluZ1xuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKwor CWZvciAoaSA9IDA7IGkgPCBidWYtPm51bV9wYWdlczsgaSsrKSB7CisJCXBoeXNfYWRkcl90IGFk ZHI7CisKKwkJYWRkciA9IHhlbl9wYWdlX3RvX3ZhZGRyKGJ1Zi0+cGFnZXNbaV0pOworCQlnbnR0 YWJfc2V0X3VubWFwX29wKCZ1bm1hcF9vcHNbaV0sIGFkZHIsIEdOVE1BUF9ob3N0X21hcCwKKwkJ CQlidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXNbaV0pOworCX0KKworCXJldCA9IGdudHRhYl91bm1h cF9yZWZzKHVubWFwX29wcywgTlVMTCwgYnVmLT5wYWdlcywKKwkJCWJ1Zi0+bnVtX3BhZ2VzKTsK KworCWZvciAoaSA9IDA7IGkgPCBidWYtPm51bV9wYWdlczsgaSsrKSB7CisJCWlmICh1bmxpa2Vs eSh1bm1hcF9vcHNbaV0uc3RhdHVzICE9IEdOVFNUX29rYXkpKQorCQkJRFJNX0VSUk9SKCJGYWls ZWQgdG8gdW5tYXAgcGFnZSAlZDogJWRcbiIsCisJCQkJCWksIHVubWFwX29wc1tpXS5zdGF0dXMp OworCX0KKworCWlmIChyZXQpCisJCURSTV9FUlJPUigiRmFpbGVkIHRvIHVubWFwIGdyYW50IHJl ZmVyZW5jZXMsIHJldCAlZCIsIHJldCk7CisKKwlrZnJlZSh1bm1hcF9vcHMpOworCWtmcmVlKGJ1 Zi0+YmFja2VuZF9tYXBfaGFuZGxlcyk7CisJYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzID0gTlVM TDsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGJhY2tlbmRfbWFwKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJc3RydWN0IGdudHRhYl9tYXBfZ3JhbnRfcmVmICpt YXBfb3BzID0gTlVMTDsKKwl1bnNpZ25lZCBjaGFyICpwdHI7CisJaW50IHJldCwgY3VyX2dyZWYs IGN1cl9kaXJfcGFnZSwgY3VyX3BhZ2UsIGdyZWZzX2xlZnQ7CisKKwltYXBfb3BzID0ga2NhbGxv YyhidWYtPm51bV9wYWdlcywgc2l6ZW9mKCptYXBfb3BzKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFt YXBfb3BzKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWJ1Zi0+YmFja2VuZF9tYXBfaGFuZGxlcyA9 IGtjYWxsb2MoYnVmLT5udW1fcGFnZXMsCisJCQlzaXplb2YoKmJ1Zi0+YmFja2VuZF9tYXBfaGFu ZGxlcyksIEdGUF9LRVJORUwpOworCWlmICghYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzKSB7CisJ CWtmcmVlKG1hcF9vcHMpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwkvKgorCSAqIHJlYWQg cGFnZSBkaXJlY3RvcnkgdG8gZ2V0IGdyZWZzIGZyb20gdGhlIGJhY2tlbmQ6IGZvciBleHRlcm5h bAorCSAqIGJ1ZmZlciB3ZSBvbmx5IGFsbG9jYXRlIGJ1Zi0+Z3JlZnMgZm9yIHRoZSBwYWdlIGRp cmVjdG9yeSwKKwkgKiBzbyBidWYtPm51bV9ncmVmcyBoYXMgbnVtYmVyIG9mIHBhZ2VzIGluIHRo ZSBwYWdlIGRpcmVjdG9yeSBpdHNlbGYKKwkgKi8KKwlwdHIgPSBidWYtPmRpcmVjdG9yeTsKKwln cmVmc19sZWZ0ID0gYnVmLT5udW1fcGFnZXM7CisJY3VyX3BhZ2UgPSAwOworCWZvciAoY3VyX2Rp cl9wYWdlID0gMDsgY3VyX2Rpcl9wYWdlIDwgYnVmLT5udW1fZ3JlZnM7IGN1cl9kaXJfcGFnZSsr KSB7CisJCXN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqcGFnZV9kaXIgPQorCQkJCShz dHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKilwdHI7CisJCWludCB0b19jb3B5ID0gWEVO X0RSTV9OVU1fR1JFRlNfUEVSX1BBR0U7CisKKwkJaWYgKHRvX2NvcHkgPiBncmVmc19sZWZ0KQor CQkJdG9fY29weSA9IGdyZWZzX2xlZnQ7CisKKwkJZm9yIChjdXJfZ3JlZiA9IDA7IGN1cl9ncmVm IDwgdG9fY29weTsgY3VyX2dyZWYrKykgeworCQkJcGh5c19hZGRyX3QgYWRkcjsKKworCQkJYWRk ciA9IHhlbl9wYWdlX3RvX3ZhZGRyKGJ1Zi0+cGFnZXNbY3VyX3BhZ2VdKTsKKwkJCWdudHRhYl9z ZXRfbWFwX29wKCZtYXBfb3BzW2N1cl9wYWdlXSwgYWRkciwKKwkJCQkJR05UTUFQX2hvc3RfbWFw LAorCQkJCQlwYWdlX2Rpci0+Z3JlZltjdXJfZ3JlZl0sCisJCQkJCWJ1Zi0+eGJfZGV2LT5vdGhl cmVuZF9pZCk7CisJCQljdXJfcGFnZSsrOworCQl9CisKKwkJZ3JlZnNfbGVmdCAtPSB0b19jb3B5 OworCQlwdHIgKz0gUEFHRV9TSVpFOworCX0KKwlyZXQgPSBnbnR0YWJfbWFwX3JlZnMobWFwX29w cywgTlVMTCwgYnVmLT5wYWdlcywgYnVmLT5udW1fcGFnZXMpOworCisJLyogc2F2ZSBoYW5kbGVz IGV2ZW4gaWYgZXJyb3IsIHNvIHdlIGNhbiB1bm1hcCAqLworCWZvciAoY3VyX3BhZ2UgPSAwOyBj dXJfcGFnZSA8IGJ1Zi0+bnVtX3BhZ2VzOyBjdXJfcGFnZSsrKSB7CisJCWJ1Zi0+YmFja2VuZF9t YXBfaGFuZGxlc1tjdXJfcGFnZV0gPSBtYXBfb3BzW2N1cl9wYWdlXS5oYW5kbGU7CisJCWlmICh1 bmxpa2VseShtYXBfb3BzW2N1cl9wYWdlXS5zdGF0dXMgIT0gR05UU1Rfb2theSkpCisJCQlEUk1f RVJST1IoIkZhaWxlZCB0byBtYXAgcGFnZSAlZDogJWRcbiIsCisJCQkJCWN1cl9wYWdlLCBtYXBf b3BzW2N1cl9wYWdlXS5zdGF0dXMpOworCX0KKworCWlmIChyZXQpIHsKKwkJRFJNX0VSUk9SKCJG YWlsZWQgdG8gbWFwIGdyYW50IHJlZmVyZW5jZXMsIHJldCAlZCIsIHJldCk7CisJCWJhY2tlbmRf dW5tYXAoYnVmKTsKKwl9CisKKwlrZnJlZShtYXBfb3BzKTsKKwlyZXR1cm4gcmV0OworfQorCitz dGF0aWMgdm9pZCBiYWNrZW5kX2ZpbGxfcGFnZV9kaXIoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hi dWYgKmJ1ZikKK3sKKwlzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKnBhZ2VfZGlyOwor CXVuc2lnbmVkIGNoYXIgKnB0cjsKKwlpbnQgaSwgbnVtX3BhZ2VzX2RpcjsKKworCXB0ciA9IGJ1 Zi0+ZGlyZWN0b3J5OworCW51bV9wYWdlc19kaXIgPSBnZXRfbnVtX3BhZ2VzX2RpcihidWYpOwor CisJLyogZmlsbCBvbmx5IGdyZWZzIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgaXRzZWxmICovCisJ Zm9yIChpID0gMDsgaSA8IG51bV9wYWdlc19kaXIgLSAxOyBpKyspIHsKKwkJcGFnZV9kaXIgPSAo c3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICopcHRyOworCisJCXBhZ2VfZGlyLT5ncmVm X2Rpcl9uZXh0X3BhZ2UgPSBidWYtPmdyZWZzW2kgKyAxXTsKKwkJcHRyICs9IFBBR0VfU0laRTsK Kwl9CisJLyogbGFzdCBwYWdlIG11c3Qgc2F5IHRoZXJlIGlzIG5vIG1vcmUgcGFnZXMgKi8KKwlw YWdlX2RpciA9IChzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKilwdHI7CisJcGFnZV9k aXItPmdyZWZfZGlyX25leHRfcGFnZSA9IEdSQU5UX0lOVkFMSURfUkVGOworfQorCitzdGF0aWMg dm9pZCBndWVzdF9maWxsX3BhZ2VfZGlyKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYp Cit7CisJdW5zaWduZWQgY2hhciAqcHRyOworCWludCBjdXJfZ3JlZiwgZ3JlZnNfbGVmdCwgdG9f Y29weSwgaSwgbnVtX3BhZ2VzX2RpcjsKKworCXB0ciA9IGJ1Zi0+ZGlyZWN0b3J5OworCW51bV9w YWdlc19kaXIgPSBnZXRfbnVtX3BhZ2VzX2RpcihidWYpOworCisJLyoKKwkgKiB3aGlsZSBjb3B5 aW5nLCBza2lwIGdyZWZzIGF0IHN0YXJ0LCB0aGV5IGFyZSBmb3IgcGFnZXMKKwkgKiBncmFudGVk IGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgaXRzZWxmCisJICovCisJY3VyX2dyZWYgPSBudW1fcGFn ZXNfZGlyOworCWdyZWZzX2xlZnQgPSBidWYtPm51bV9wYWdlczsKKwlmb3IgKGkgPSAwOyBpIDwg bnVtX3BhZ2VzX2RpcjsgaSsrKSB7CisJCXN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAq cGFnZV9kaXIgPQorCQkJCShzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKilwdHI7CisK KwkJaWYgKGdyZWZzX2xlZnQgPD0gWEVOX0RSTV9OVU1fR1JFRlNfUEVSX1BBR0UpIHsKKwkJCXRv X2NvcHkgPSBncmVmc19sZWZ0OworCQkJcGFnZV9kaXItPmdyZWZfZGlyX25leHRfcGFnZSA9IEdS QU5UX0lOVkFMSURfUkVGOworCQl9IGVsc2UgeworCQkJdG9fY29weSA9IFhFTl9EUk1fTlVNX0dS RUZTX1BFUl9QQUdFOworCQkJcGFnZV9kaXItPmdyZWZfZGlyX25leHRfcGFnZSA9IGJ1Zi0+Z3Jl ZnNbaSArIDFdOworCQl9CisJCW1lbWNweSgmcGFnZV9kaXItPmdyZWYsICZidWYtPmdyZWZzW2N1 cl9ncmVmXSwKKwkJCQl0b19jb3B5ICogc2l6ZW9mKGdyYW50X3JlZl90KSk7CisJCXB0ciArPSBQ QUdFX1NJWkU7CisJCWdyZWZzX2xlZnQgLT0gdG9fY29weTsKKwkJY3VyX2dyZWYgKz0gdG9fY29w eTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgZ3Vlc3RfZ3JhbnRfcmVmc19mb3JfYnVmZmVyKHN0cnVj dCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYsCisJCWdyYW50X3JlZl90ICpwcml2X2dyZWZfaGVh ZCwgaW50IGdyZWZfaWR4KQoreworCWludCBpLCBjdXJfcmVmLCBvdGhlcmVuZF9pZDsKKworCW90 aGVyZW5kX2lkID0gYnVmLT54Yl9kZXYtPm90aGVyZW5kX2lkOworCWZvciAoaSA9IDA7IGkgPCBi dWYtPm51bV9wYWdlczsgaSsrKSB7CisJCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1fZ3JhbnRfcmVm ZXJlbmNlKHByaXZfZ3JlZl9oZWFkKTsKKwkJaWYgKGN1cl9yZWYgPCAwKQorCQkJcmV0dXJuIGN1 cl9yZWY7CisJCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoY3VyX3JlZiwgb3RoZXJl bmRfaWQsCisJCQkJeGVuX3BhZ2VfdG9fZ2ZuKGJ1Zi0+cGFnZXNbaV0pLCAwKTsKKwkJYnVmLT5n cmVmc1tncmVmX2lkeCsrXSA9IGN1cl9yZWY7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IGdyYW50X3JlZmVyZW5jZXMoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sK KwlncmFudF9yZWZfdCBwcml2X2dyZWZfaGVhZDsKKwlpbnQgcmV0LCBpLCBqLCBjdXJfcmVmOwor CWludCBvdGhlcmVuZF9pZCwgbnVtX3BhZ2VzX2RpcjsKKworCXJldCA9IGdudHRhYl9hbGxvY19n cmFudF9yZWZlcmVuY2VzKGJ1Zi0+bnVtX2dyZWZzLCAmcHJpdl9ncmVmX2hlYWQpOworCWlmIChy ZXQgPCAwKSB7CisJCURSTV9FUlJPUigiQ2Fubm90IGFsbG9jYXRlIGdyYW50IHJlZmVyZW5jZXNc biIpOworCQlyZXR1cm4gcmV0OworCX0KKwlvdGhlcmVuZF9pZCA9IGJ1Zi0+eGJfZGV2LT5vdGhl cmVuZF9pZDsKKwlqID0gMDsKKwludW1fcGFnZXNfZGlyID0gZ2V0X251bV9wYWdlc19kaXIoYnVm KTsKKwlmb3IgKGkgPSAwOyBpIDwgbnVtX3BhZ2VzX2RpcjsgaSsrKSB7CisJCXVuc2lnbmVkIGxv bmcgZnJhbWU7CisKKwkJY3VyX3JlZiA9IGdudHRhYl9jbGFpbV9ncmFudF9yZWZlcmVuY2UoJnBy aXZfZ3JlZl9oZWFkKTsKKwkJaWYgKGN1cl9yZWYgPCAwKQorCQkJcmV0dXJuIGN1cl9yZWY7CisK KwkJZnJhbWUgPSB4ZW5fcGFnZV90b19nZm4odmlydF90b19wYWdlKGJ1Zi0+ZGlyZWN0b3J5ICsK KwkJCQlQQUdFX1NJWkUgKiBpKSk7CisJCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYo Y3VyX3JlZiwgb3RoZXJlbmRfaWQsCisJCQkJZnJhbWUsIDApOworCQlidWYtPmdyZWZzW2orK10g PSBjdXJfcmVmOworCX0KKworCWlmIChidWYtPm9wcy0+Z3JhbnRfcmVmc19mb3JfYnVmZmVyKSB7 CisJCXJldCA9IGJ1Zi0+b3BzLT5ncmFudF9yZWZzX2Zvcl9idWZmZXIoYnVmLCAmcHJpdl9ncmVm X2hlYWQsIGopOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwlnbnR0YWJfZnJl ZV9ncmFudF9yZWZlcmVuY2VzKHByaXZfZ3JlZl9oZWFkKTsKKwlyZXR1cm4gMDsKK30KKworc3Rh dGljIGludCBhbGxvY19zdG9yYWdlKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7 CisJaWYgKGJ1Zi0+c2d0KSB7CisJCWJ1Zi0+cGFnZXMgPSBrdm1hbGxvY19hcnJheShidWYtPm51 bV9wYWdlcywKKwkJCQlzaXplb2Yoc3RydWN0IHBhZ2UgKiksIEdGUF9LRVJORUwpOworCQlpZiAo IWJ1Zi0+cGFnZXMpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQlpZiAoZHJtX3ByaW1lX3NnX3Rv X3BhZ2VfYWRkcl9hcnJheXMoYnVmLT5zZ3QsIGJ1Zi0+cGFnZXMsCisJCQkJTlVMTCwgYnVmLT5u dW1fcGFnZXMpIDwgMCkKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCWJ1Zi0+Z3JlZnMgPSBr Y2FsbG9jKGJ1Zi0+bnVtX2dyZWZzLCBzaXplb2YoKmJ1Zi0+Z3JlZnMpLCBHRlBfS0VSTkVMKTsK KwlpZiAoIWJ1Zi0+Z3JlZnMpCisJCXJldHVybiAtRU5PTUVNOworCisJYnVmLT5kaXJlY3Rvcnkg PSBrY2FsbG9jKGdldF9udW1fcGFnZXNfZGlyKGJ1ZiksIFBBR0VfU0laRSwgR0ZQX0tFUk5FTCk7 CisJaWYgKCFidWYtPmRpcmVjdG9yeSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlyZXR1cm4gMDsK K30KKworLyoKKyAqIEZvciBiZSBhbGxvY2F0ZWQgYnVmZmVycyB3ZSBkb24ndCBuZWVkIGdyYW50 X3JlZnNfZm9yX2J1ZmZlciBhcyB0aG9zZQorICogZ3JhbnQgcmVmZXJlbmNlcyBhcmUgYWxsb2Nh dGVkIGF0IGJhY2tlbmQgc2lkZQorICovCitzdGF0aWMgY29uc3Qgc3RydWN0IHhlbl9kcm1fZnJv bnRfc2hidWZfb3BzIGJhY2tlbmRfb3BzID0geworCS5jYWxjX251bV9ncmVmcyA9IGJhY2tlbmRf Y2FsY19udW1fZ3JlZnMsCisJLmZpbGxfcGFnZV9kaXIgPSBiYWNrZW5kX2ZpbGxfcGFnZV9kaXIs CisJLm1hcCA9IGJhY2tlbmRfbWFwLAorCS51bm1hcCA9IGJhY2tlbmRfdW5tYXAKK307CisKKy8q IEZvciBsb2NhbGx5IGdyYW50ZWQgcmVmZXJlbmNlcyB3ZSBkbyBub3QgbmVlZCB0byBtYXAvdW5t YXAgdGhlIHJlZmVyZW5jZXMgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9z aGJ1Zl9vcHMgbG9jYWxfb3BzID0geworCS5jYWxjX251bV9ncmVmcyA9IGd1ZXN0X2NhbGNfbnVt X2dyZWZzLAorCS5maWxsX3BhZ2VfZGlyID0gZ3Vlc3RfZmlsbF9wYWdlX2RpciwKKwkuZ3JhbnRf cmVmc19mb3JfYnVmZmVyID0gZ3Vlc3RfZ3JhbnRfcmVmc19mb3JfYnVmZmVyLAorfTsKKworc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKnhlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2MoCisJCXN0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2NmZyAqY2ZnKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X3NoYnVmICpidWY7CisJaW50IHJldDsKKworCS8qIGVpdGhlciBwYWdlcyBvciBzZ3QsIG5v dCBib3RoICovCisJaWYgKHVubGlrZWx5KGNmZy0+cGFnZXMgJiYgY2ZnLT5zZ3QpKSB7CisJCURS TV9FUlJPUigiQ2Fubm90IGhhbmRsZSBidWZmZXIgYWxsb2NhdGlvbiB3aXRoIGJvdGggcGFnZXMg YW5kIHNnIHRhYmxlIHByb3ZpZGVkXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJYnVmID0g a3phbGxvYyhzaXplb2YoKmJ1ZiksIEdGUF9LRVJORUwpOworCWlmICghYnVmKQorCQlyZXR1cm4g TlVMTDsKKworCWlmIChjZmctPmJlX2FsbG9jKQorCQlidWYtPm9wcyA9ICZiYWNrZW5kX29wczsK KwllbHNlCisJCWJ1Zi0+b3BzID0gJmxvY2FsX29wczsKKworCWJ1Zi0+eGJfZGV2ID0gY2ZnLT54 Yl9kZXY7CisJYnVmLT5udW1fcGFnZXMgPSBESVZfUk9VTkRfVVAoY2ZnLT5zaXplLCBQQUdFX1NJ WkUpOworCWJ1Zi0+c2d0ID0gY2ZnLT5zZ3Q7CisJYnVmLT5wYWdlcyA9IGNmZy0+cGFnZXM7CisK KwlidWYtPm9wcy0+Y2FsY19udW1fZ3JlZnMoYnVmKTsKKworCXJldCA9IGFsbG9jX3N0b3JhZ2Uo YnVmKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWw7CisKKwlyZXQgPSBncmFudF9yZWZlcmVuY2Vz KGJ1Zik7CisJaWYgKHJldCkKKwkJZ290byBmYWlsOworCisJYnVmLT5vcHMtPmZpbGxfcGFnZV9k aXIoYnVmKTsKKworCXJldHVybiBidWY7CisKK2ZhaWw6CisJeGVuX2RybV9mcm9udF9zaGJ1Zl9m cmVlKGJ1Zik7CisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X3NoYnVmLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi42YzRmYmM2OGYzMjgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfc2hidWYuaApAQCAtMCwwICsxLDcyIEBACisvKiBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFs IERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMg SW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9h bmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYgX19YRU5fRFJNX0ZST05UX1NI QlVGX0hfCisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9TSEJVRl9IXworCisjaW5jbHVkZSA8bGlu dXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KKworI2luY2x1ZGUg PHhlbi9ncmFudF90YWJsZS5oPgorCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiB7CisJLyoK KwkgKiBudW1iZXIgb2YgcmVmZXJlbmNlcyBncmFudGVkIGZvciB0aGUgYmFja2VuZCB1c2U6CisJ ICogIC0gZm9yIGFsbG9jYXRlZC9pbXBvcnRlZCBkbWEtYnVmJ3MgdGhpcyBob2xkcyBudW1iZXIg b2YgZ3JhbnQKKwkgKiAgICByZWZlcmVuY2VzIGZvciB0aGUgcGFnZSBkaXJlY3RvcnkgYW5kIHBh Z2VzIG9mIHRoZSBidWZmZXIKKwkgKiAgLSBmb3IgdGhlIGJ1ZmZlciBwcm92aWRlZCBieSB0aGUg YmFja2VuZCB0aGlzIGhvbGRzIG51bWJlciBvZgorCSAqICAgIGdyYW50IHJlZmVyZW5jZXMgZm9y IHRoZSBwYWdlIGRpcmVjdG9yeSBhcyBncmFudCByZWZlcmVuY2VzIGZvcgorCSAqICAgIHRoZSBi dWZmZXIgd2lsbCBiZSBwcm92aWRlZCBieSB0aGUgYmFja2VuZAorCSAqLworCWludCBudW1fZ3Jl ZnM7CisJZ3JhbnRfcmVmX3QgKmdyZWZzOworCXVuc2lnbmVkIGNoYXIgKmRpcmVjdG9yeTsKKwor CS8qCisJICogdGhlcmUgYXJlIDIgd2F5cyB0byBwcm92aWRlIGJhY2tpbmcgc3RvcmFnZSBmb3Ig dGhpcyBzaGFyZWQgYnVmZmVyOgorCSAqIGVpdGhlciBwYWdlcyBvciBzZ3QuIGlmIGJ1ZmZlciBj cmVhdGVkIGZyb20gc2d0IHRoZW4gd2Ugb3duCisJICogdGhlIHBhZ2VzIGFuZCBtdXN0IGZyZWUg dGhvc2Ugb3Vyc2VsdmVzIG9uIGNsb3N1cmUKKwkgKi8KKwlpbnQgbnVtX3BhZ2VzOworCXN0cnVj dCBwYWdlICoqcGFnZXM7CisKKwlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsKKworCXN0cnVjdCB4ZW5i dXNfZGV2aWNlICp4Yl9kZXY7CisKKwkvKiB0aGVzZSBhcmUgdGhlIG9wcyB1c2VkIGludGVybmFs bHkgZGVwZW5kaW5nIG9uIGJlX2FsbG9jIG1vZGUgKi8KKwljb25zdCBzdHJ1Y3QgeGVuX2RybV9m cm9udF9zaGJ1Zl9vcHMgKm9wczsKKworCS8qIFhlbiBtYXAgaGFuZGxlcyBmb3IgdGhlIGJ1ZmZl ciBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tlbmQgKi8KKwlncmFudF9oYW5kbGVfdCAqYmFja2VuZF9t YXBfaGFuZGxlczsKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2NmZyB7CisJc3Ry dWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldjsKKwlzaXplX3Qgc2l6ZTsKKwlzdHJ1Y3QgcGFnZSAq KnBhZ2VzOworCXN0cnVjdCBzZ190YWJsZSAqc2d0OworCWJvb2wgYmVfYWxsb2M7Cit9OworCitz dHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqeGVuX2RybV9mcm9udF9zaGJ1Zl9hbGxvYygKKwkJ c3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfY2ZnICpjZmcpOworCitncmFudF9yZWZfdCB4ZW5f ZHJtX2Zyb250X3NoYnVmX2dldF9kaXJfc3RhcnQoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYg KmJ1Zik7CisKK2ludCB4ZW5fZHJtX2Zyb250X3NoYnVmX21hcChzdHJ1Y3QgeGVuX2RybV9mcm9u dF9zaGJ1ZiAqYnVmKTsKKworaW50IHhlbl9kcm1fZnJvbnRfc2hidWZfdW5tYXAoc3RydWN0IHhl bl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mbHVz aChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250 X3NoYnVmX2ZyZWUoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisKKyNlbmRpZiAv KiBfX1hFTl9EUk1fRlJPTlRfU0hCVUZfSF8gKi8KLS0gCjIuNy40CgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5v cmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752492AbeCUO6h (ORCPT ); Wed, 21 Mar 2018 10:58:37 -0400 Received: from mail-lf0-f45.google.com ([209.85.215.45]:39118 "EHLO mail-lf0-f45.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752458AbeCUO61 (ORCPT ); Wed, 21 Mar 2018 10:58:27 -0400 X-Google-Smtp-Source: AG47ELub6kOEvgpkOQ7Nz8y3t5Zyt2p34R3Hylks9bVoYqWoB5GHihxwKLnQGVEb9tHAHwAfN+97Xg== 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 v3] drm/xen-front: Add support for Xen PV display frontend Date: Wed, 21 Mar 2018 16:58:13 +0200 Message-Id: <1521644293-14612-2-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1521644293-14612-1-git-send-email-andr2000@gmail.com> References: <1521644293-14612-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 Signed-off-by: Oleksandr Andrushchenko --- Documentation/gpu/drivers.rst | 1 + Documentation/gpu/xen-front.rst | 43 ++ drivers/gpu/drm/Kconfig | 2 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/xen/Kconfig | 30 + drivers/gpu/drm/xen/Makefile | 16 + drivers/gpu/drm/xen/xen_drm_front.c | 833 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front.h | 198 +++++++ 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 | 145 +++++ drivers/gpu/drm/xen/xen_drm_front_conn.h | 27 + drivers/gpu/drm/xen/xen_drm_front_evtchnl.c | 383 +++++++++++++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.h | 81 +++ drivers/gpu/drm/xen/xen_drm_front_gem.c | 333 +++++++++++ drivers/gpu/drm/xen/xen_drm_front_gem.h | 41 ++ drivers/gpu/drm/xen/xen_drm_front_gem_cma.c | 73 +++ drivers/gpu/drm/xen/xen_drm_front_kms.c | 323 +++++++++++ drivers/gpu/drm/xen/xen_drm_front_kms.h | 28 + drivers/gpu/drm/xen/xen_drm_front_shbuf.c | 432 +++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_shbuf.h | 72 +++ 21 files changed, 3176 insertions(+) create mode 100644 Documentation/gpu/xen-front.rst 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_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/Documentation/gpu/drivers.rst b/Documentation/gpu/drivers.rst index e8c84419a2a1..d3ab6abae838 100644 --- a/Documentation/gpu/drivers.rst +++ b/Documentation/gpu/drivers.rst @@ -12,6 +12,7 @@ GPU Driver Documentation tve200 vc4 bridge/dw-hdmi + xen-front .. only:: subproject and html diff --git a/Documentation/gpu/xen-front.rst b/Documentation/gpu/xen-front.rst new file mode 100644 index 000000000000..8188e03c9d23 --- /dev/null +++ b/Documentation/gpu/xen-front.rst @@ -0,0 +1,43 @@ +==================================== +Xen para-virtualized frontend driver +==================================== + +This frontend driver implements Xen para-virtualized display +according to the display protocol described at +include/xen/interface/io/displif.h + +Driver modes of operation in terms of display buffers used +========================================================== + +.. kernel-doc:: drivers/gpu/drm/xen/xen_drm_front.h + :doc: Driver modes of operation in terms of display buffers used + +Buffers allocated by the frontend driver +---------------------------------------- + +.. kernel-doc:: drivers/gpu/drm/xen/xen_drm_front.h + :doc: Buffers allocated by the frontend driver + +With GEM CMA helpers +~~~~~~~~~~~~~~~~~~~~ + +.. kernel-doc:: drivers/gpu/drm/xen/xen_drm_front.h + :doc: With GEM CMA helpers + +Without GEM CMA helpers +~~~~~~~~~~~~~~~~~~~~~~~ + +.. kernel-doc:: drivers/gpu/drm/xen/xen_drm_front.h + :doc: Without GEM CMA helpers + +Buffers allocated by the backend +-------------------------------- + +.. kernel-doc:: drivers/gpu/drm/xen/xen_drm_front.h + :doc: Buffers allocated by the backend + +Driver limitations +================== + +.. kernel-doc:: drivers/gpu/drm/xen/xen_drm_front.h + :doc: Driver limitations 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..352730dc6c13 --- /dev/null +++ b/drivers/gpu/drm/xen/Makefile @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: GPL-2.0 OR MIT + +drm_xen_front-objs := xen_drm_front.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..13a3a58c7397 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -0,0 +1,833 @@ +// 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 +#include +#include + +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_cfg.h" +#include "xen_drm_front_evtchnl.h" +#include "xen_drm_front_gem.h" +#include "xen_drm_front_kms.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.req_io_lock); + return 0; + +fail: + mutex_unlock(&evtchnl->u.req.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); +} + +static 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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.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(&evtchnl->u.req.req_io_lock); + return ret; +} + +void xen_drm_front_on_frame_done(struct xen_drm_front_info *front_info, + int conn_idx, uint64_t fb_cookie) +{ + struct xen_drm_front_drm_info *drm_info = front_info->drm_info; + + if (unlikely(conn_idx >= front_info->cfg.num_connectors)) + return; + + xen_drm_front_kms_on_frame_done(&drm_info->pipeline[conn_idx], + fb_cookie); +} + +static int xen_drm_drv_dumb_create(struct drm_file *filp, + struct drm_device *dev, struct drm_mode_create_dumb *args) +{ + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + struct drm_gem_object *obj; + int ret; + + ret = xen_drm_front_gem_dumb_create(filp, dev, args); + if (ret) + goto fail; + + obj = drm_gem_object_lookup(filp, args->handle); + if (!obj) { + ret = -ENOENT; + goto fail_destroy; + } + + drm_gem_object_unreference_unlocked(obj); + + /* + * In case of CONFIG_DRM_XEN_FRONTEND_CMA gem_obj is constructed + * via DRM CMA helpers and doesn't have ->pages allocated + * (xendrm_gem_get_pages will return NULL), but instead can provide + * sg table + */ + if (xen_drm_front_gem_get_pages(obj)) + ret = xen_drm_front_dbuf_create_from_pages( + drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj), + args->width, args->height, args->bpp, + args->size, + xen_drm_front_gem_get_pages(obj)); + else + ret = xen_drm_front_dbuf_create_from_sgt( + drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj), + args->width, args->height, args->bpp, + args->size, + xen_drm_front_gem_get_sg_table(obj)); + if (ret) + goto fail_destroy; + + return 0; + +fail_destroy: + drm_gem_dumb_destroy(filp, dev, args->handle); +fail: + DRM_ERROR("Failed to create dumb buffer: %d\n", ret); + return ret; +} + +static void xen_drm_drv_free_object(struct drm_gem_object *obj) +{ + struct xen_drm_front_drm_info *drm_info = obj->dev->dev_private; + + xen_drm_front_dbuf_destroy(drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj)); + xen_drm_front_gem_free_object(obj); +} + +static void xen_drm_drv_release(struct drm_device *dev) +{ + struct xen_drm_front_drm_info *drm_info = dev->dev_private; + struct xen_drm_front_info *front_info = drm_info->front_info; + + drm_atomic_helper_shutdown(dev); + drm_mode_config_cleanup(dev); + + xen_drm_front_evtchnl_free_all(front_info); + dbuf_free_all(&front_info->dbuf_list); + + drm_dev_fini(dev); + kfree(dev); + + /* + * Free now, as this release could be not due to rmmod, but + * due to the backend disconnect, making drm_info hang in + * memory until rmmod + */ + devm_kfree(&front_info->xb_dev->dev, front_info->drm_info); + front_info->drm_info = NULL; + + /* Tell the backend we are ready to (re)initialize */ + xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); +} + +static const struct file_operations xen_drm_dev_fops = { + .owner = THIS_MODULE, + .open = drm_open, + .release = drm_release, + .unlocked_ioctl = drm_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = drm_compat_ioctl, +#endif + .poll = drm_poll, + .read = drm_read, + .llseek = no_llseek, +#ifdef CONFIG_DRM_XEN_FRONTEND_CMA + .mmap = drm_gem_cma_mmap, +#else + .mmap = xen_drm_front_gem_mmap, +#endif +}; + +static const struct vm_operations_struct xen_drm_drv_vm_ops = { + .open = drm_gem_vm_open, + .close = drm_gem_vm_close, +}; + +static struct drm_driver xen_drm_driver = { + .driver_features = DRIVER_GEM | DRIVER_MODESET | + DRIVER_PRIME | DRIVER_ATOMIC, + .release = xen_drm_drv_release, + .gem_vm_ops = &xen_drm_drv_vm_ops, + .gem_free_object_unlocked = xen_drm_drv_free_object, + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, + .gem_prime_import = drm_gem_prime_import, + .gem_prime_export = drm_gem_prime_export, + .gem_prime_import_sg_table = xen_drm_front_gem_import_sg_table, + .gem_prime_get_sg_table = xen_drm_front_gem_get_sg_table, + .dumb_create = xen_drm_drv_dumb_create, + .fops = &xen_drm_dev_fops, + .name = "xendrm-du", + .desc = "Xen PV DRM Display Unit", + .date = "20180221", + .major = 1, + .minor = 0, + +#ifdef CONFIG_DRM_XEN_FRONTEND_CMA + .gem_prime_vmap = drm_gem_cma_prime_vmap, + .gem_prime_vunmap = drm_gem_cma_prime_vunmap, + .gem_prime_mmap = drm_gem_cma_prime_mmap, +#else + .gem_prime_vmap = xen_drm_front_gem_prime_vmap, + .gem_prime_vunmap = xen_drm_front_gem_prime_vunmap, + .gem_prime_mmap = xen_drm_front_gem_prime_mmap, +#endif +}; + +static int xen_drm_drv_init(struct xen_drm_front_info *front_info) +{ + struct device *dev = &front_info->xb_dev->dev; + struct xen_drm_front_drm_info *drm_info; + struct drm_device *drm_dev; + int ret; + + DRM_INFO("Creating %s\n", xen_drm_driver.desc); + + drm_info = devm_kzalloc(dev, sizeof(*drm_info), GFP_KERNEL); + if (!drm_info) + return -ENOMEM; + + drm_info->front_info = front_info; + front_info->drm_info = drm_info; + + drm_dev = drm_dev_alloc(&xen_drm_driver, dev); + if (!drm_dev) + return -ENOMEM; + + drm_info->drm_dev = drm_dev; + + drm_dev->dev_private = drm_info; + + ret = xen_drm_front_kms_init(drm_info); + if (ret) { + DRM_ERROR("Failed to initialize DRM/KMS, ret %d\n", ret); + goto fail_modeset; + } + + ret = drm_dev_register(drm_dev, 0); + if (ret) + goto fail_register; + + DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", + xen_drm_driver.name, xen_drm_driver.major, + xen_drm_driver.minor, xen_drm_driver.patchlevel, + xen_drm_driver.date, drm_dev->primary->index); + + return 0; + +fail_register: + drm_dev_unregister(drm_dev); +fail_modeset: + drm_kms_helper_poll_fini(drm_dev); + drm_mode_config_cleanup(drm_dev); + return ret; +} + +static void xen_drm_drv_fini(struct xen_drm_front_info *front_info) +{ + struct xen_drm_front_drm_info *drm_info = front_info->drm_info; + struct drm_device *dev; + + if (!drm_info) + return; + + dev = drm_info->drm_dev; + if (!dev) + return; + + if (!drm_dev_is_unplugged(dev)) { + drm_kms_helper_poll_fini(dev); + drm_dev_unplug(dev); + } +} + +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) +{ + if (!front_info->drm_info) + return; + + /* Tell the backend to wait until we release the DRM driver. */ + xenbus_switch_state(front_info->xb_dev, XenbusStateReconfiguring); + + xen_drm_drv_fini(front_info); +} + +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; + struct device *dev = &xb_dev->dev; + int ret; + + /* + * 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. + */ + dev->bus->force_dma = true; + dev->coherent_dma_mask = DMA_BIT_MASK(32); + ret = of_dma_configure(dev, NULL); + if (ret < 0) { + DRM_ERROR("Cannot setup DMA ops, ret %d", ret); + return ret; + } + + 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); + INIT_LIST_HEAD(&front_info->dbuf_list); + 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_drm_drv_fini(front_info); + xenbus_frontend_closed(dev); + return 0; +} + +static const struct xenbus_device_id xen_driver_ids[] = { + { XENDISPL_DRIVER_NAME }, + { "" } +}; + +static struct xenbus_driver xen_driver = { + .ids = xen_driver_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_fini(void) +{ + DRM_INFO("Unregistering XEN PV " XENDISPL_DRIVER_NAME "\n"); + xenbus_unregister_driver(&xen_driver); +} + +module_init(xen_drv_init); +module_exit(xen_drv_fini); + +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..196733d5a270 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -0,0 +1,198 @@ +/* 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 + +#include + +#include "xen_drm_front_cfg.h" + +/** + * DOC: Driver modes of operation in terms of display buffers used + * + * 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. + */ + +/** + * DOC: Buffers allocated by the frontend driver + * + * The below modes of operation are configured at compile-time via + * frontend driver's kernel configuration: + */ + +/** + * DOC: With 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. + */ + +/** + * DOC: Without GEM CMA helpers + * + * 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. + */ + +/** + * DOC: 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: + * + * #. If guest domain dies then pages/grants received from the backend + * cannot be claimed back + * + * #. Misbehaving guest may send too many requests to the + * backend exhausting its grant references and memory + * (consider this from security POV) + */ + +/** + * DOC: Driver limitations + * + * #. Only primary plane without additional properties is supported. + * + * #. Only one video mode per connector supported which is configured via XenStore. + * + * #. All CRTCs operate at fixed frequency of 60Hz. + */ + +/* 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_info { + struct xenbus_device *xb_dev; + struct xen_drm_front_drm_info *drm_info; + + /* to protect data between backend IO code and interrupt handler */ + spinlock_t io_lock; + + 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; +}; + +struct xen_drm_front_drm_pipeline { + struct xen_drm_front_drm_info *drm_info; + + int index; + + struct drm_simple_display_pipe pipe; + + struct drm_connector conn; + /* These are only for connector mode checking */ + int width, height; + + struct drm_pending_vblank_event *pending_event; + + /* + * pflip_timeout is set to current jiffies once we send a page flip and + * reset to 0 when we receive frame done event from the backed. + * It is checked during drm_connector_helper_funcs.detect_ctx to detect + * time-outs for frame done event, e.g. due to backend errors. + * + * This must be protected with front_info->io_lock, so races between + * interrupt handler and rest of the code are properly handled. + */ + unsigned long pflip_timeout; + + bool conn_connected; +}; + +struct xen_drm_front_drm_info { + struct xen_drm_front_info *front_info; + struct drm_device *drm_dev; + + struct xen_drm_front_drm_pipeline pipeline[XEN_DRM_FRONT_MAX_CRTCS]; +}; + +static inline uint64_t xen_drm_front_fb_to_cookie( + struct drm_framebuffer *fb) +{ + return (uint64_t)fb; +} + +static inline uint64_t xen_drm_front_dbuf_to_cookie( + struct drm_gem_object *gem_obj) +{ + return (uint64_t)gem_obj; +} + +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_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_on_frame_done(struct xen_drm_front_info *front_info, + int conn_idx, uint64_t fb_cookie); + +#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..b04ac2603204 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_conn.c @@ -0,0 +1,145 @@ +// 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