From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v5 1/1] drm/xen-front: Add support for Xen PV display frontend Date: Thu, 29 Mar 2018 12:22:47 +0300 Message-ID: <20180329092247.23905-2-andr2000@gmail.com> References: <20180329092247.23905-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x22f.google.com (mail-lf0-x22f.google.com [IPv6:2a00:1450:4010:c07::22f]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5951689F0B for ; Thu, 29 Mar 2018 09:23:01 +0000 (UTC) Received: by mail-lf0-x22f.google.com with SMTP id c78-v6so7467886lfh.1 for ; Thu, 29 Mar 2018 02:23:01 -0700 (PDT) In-Reply-To: <20180329092247.23905-1-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 PgpSZXZpZXdlZC1ieTogQm9yaXMgT3N0cm92c2t5IDxib3Jpcy5vc3Ryb3Zza3lAb3JhY2xlLmNv bT4KUmV2aWV3ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+Ci0t LQogRG9jdW1lbnRhdGlvbi9ncHUvZHJpdmVycy5yc3QgICAgICAgICAgICAgICB8ICAgMSArCiBE b2N1bWVudGF0aW9uL2dwdS94ZW4tZnJvbnQucnN0ICAgICAgICAgICAgIHwgIDQzICsrCiBkcml2 ZXJzL2dwdS9kcm0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgIHwgICAyICsKIGRyaXZlcnMv Z3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUv ZHJtL3hlbi9LY29uZmlnICAgICAgICAgICAgICAgICB8ICAzMCArCiBkcml2ZXJzL2dwdS9kcm0v eGVuL01ha2VmaWxlICAgICAgICAgICAgICAgIHwgIDE2ICsKIGRyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udC5jICAgICAgICAgfCA4ODAgKysrKysrKysrKysrKysrKysrKysrKysrKysr KwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmggICAgICAgICB8IDE4OSArKysr KysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcuYyAgICAgfCAgNzcgKysr CiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmggICAgIHwgIDM3ICsrCiBk cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jICAgIHwgMTE1ICsrKysKIGRy aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmggICAgfCAgMjcgKwogZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYyB8IDM4NiArKysrKysrKysrKysK IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmggfCAgODEgKysrCiBk cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgICAgIHwgMzA5ICsrKysrKysr KysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaCAgICAgfCAgNDEgKysK IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW1fY21hLmMgfCAgNzggKysrCiBk cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfa21zLmMgICAgIHwgMzcyICsrKysrKysr KysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5oICAgICB8ICAyNyAr CiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuYyAgIHwgNDMyICsrKysr KysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuaCAgIHwg IDcyICsrKwogMjEgZmlsZXMgY2hhbmdlZCwgMzIxNiBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9k ZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9ncHUveGVuLWZyb250LnJzdAogY3JlYXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnQuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udC5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2NmZy5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUv ZHJtL3hlbi94ZW5fZHJtX2Zyb250X2NmZy5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9n cHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5jCiBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuaAogY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uYwogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaAog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW1f Y21hLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnRfa21zLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnRfa21zLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9k cm1fZnJvbnRfc2hidWYuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udF9zaGJ1Zi5oCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJp dmVycy5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcml2ZXJzLnJzdAppbmRleCBlOGM4NDQxOWEy YTEuLmQzYWI2YWJhZTgzOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJpdmVycy5y c3QKKysrIGIvRG9jdW1lbnRhdGlvbi9ncHUvZHJpdmVycy5yc3QKQEAgLTEyLDYgKzEyLDcgQEAg R1BVIERyaXZlciBEb2N1bWVudGF0aW9uCiAgICB0dmUyMDAKICAgIHZjNAogICAgYnJpZGdlL2R3 LWhkbWkKKyAgIHhlbi1mcm9udAogCiAuLiBvbmx5OjogIHN1YnByb2plY3QgYW5kIGh0bWwKIApk aWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUveGVuLWZyb250LnJzdCBiL0RvY3VtZW50YXRp b24vZ3B1L3hlbi1mcm9udC5yc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi4wMDlkOTQyMzg2YzUKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL2dwdS94 ZW4tZnJvbnQucnN0CkBAIC0wLDAgKzEsNDMgQEAKKz09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KKyBkcm0veGVuLWZyb250IFhlbiBwYXJhLXZpcnR1 YWxpemVkIGZyb250ZW5kIGRyaXZlcgorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQorCitUaGlzIGZyb250ZW5kIGRyaXZlciBpbXBsZW1lbnRzIFhl biBwYXJhLXZpcnR1YWxpemVkIGRpc3BsYXkKK2FjY29yZGluZyB0byB0aGUgZGlzcGxheSBwcm90 b2NvbCBkZXNjcmliZWQgYXQKK2luY2x1ZGUveGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmgKKwor RHJpdmVyIG1vZGVzIG9mIG9wZXJhdGlvbiBpbiB0ZXJtcyBvZiBkaXNwbGF5IGJ1ZmZlcnMgdXNl ZAorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 LmgKKyAgIDpkb2M6IERyaXZlciBtb2RlcyBvZiBvcGVyYXRpb24gaW4gdGVybXMgb2YgZGlzcGxh eSBidWZmZXJzIHVzZWQKKworQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGZyb250ZW5kIGRyaXZl cgorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisuLiBrZXJuZWwt ZG9jOjogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKKyAgIDpkb2M6IEJ1ZmZl cnMgYWxsb2NhdGVkIGJ5IHRoZSBmcm9udGVuZCBkcml2ZXIKKworV2l0aCBHRU0gQ01BIGhlbHBl cnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAgOmRvYzogV2l0aCBHRU0gQ01BIGhlbHBlcnMKKwor V2l0aG91dCBHRU0gQ01BIGhlbHBlcnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtl cm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAgOmRvYzog V2l0aG91dCBHRU0gQ01BIGhlbHBlcnMKKworQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tl bmQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKy4uIGtlcm5lbC1kb2M6OiBk cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAgOmRvYzogQnVmZmVycyBhbGxv Y2F0ZWQgYnkgdGhlIGJhY2tlbmQKKworRHJpdmVyIGxpbWl0YXRpb25zCis9PT09PT09PT09PT09 PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9u dC5oCisgICA6ZG9jOiBEcml2ZXIgbGltaXRhdGlvbnMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKaW5kZXggZGVlZWZhN2ExNzcz Li43NTc4MjVhYzYwZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCkBAIC0yODksNiArMjg5LDggQEAgc291cmNlICJkcml2 ZXJzL2dwdS9kcm0vcGwxMTEvS2NvbmZpZyIKIAogc291cmNlICJkcml2ZXJzL2dwdS9kcm0vdHZl MjAwL0tjb25maWciCiAKK3NvdXJjZSAiZHJpdmVycy9ncHUvZHJtL3hlbi9LY29uZmlnIgorCiAj IEtlZXAgbGVnYWN5IGRyaXZlcnMgbGFzdAogCiBtZW51Y29uZmlnIERSTV9MRUdBQ1kKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmls ZQppbmRleCA1MDA5M2ZmNDQ3OWIuLjlkNjY2NTdlYTExNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQpAQCAtMTAzLDMg KzEwMyw0IEBAIG9iai0kKENPTkZJR19EUk1fTVhTRkIpCSs9IG14c2ZiLwogb2JqLSQoQ09ORklH X0RSTV9USU5ZRFJNKSArPSB0aW55ZHJtLwogb2JqLSQoQ09ORklHX0RSTV9QTDExMSkgKz0gcGwx MTEvCiBvYmotJChDT05GSUdfRFJNX1RWRTIwMCkgKz0gdHZlMjAwLworb2JqLSQoQ09ORklHX0RS TV9YRU4pICs9IHhlbi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZyBi L2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLjRmNGFiYzkxZjNiNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4vS2NvbmZpZwpAQCAtMCwwICsxLDMwIEBACitjb25maWcgRFJNX1hFTgorCWJvb2wg IkRSTSBTdXBwb3J0IGZvciBYZW4gZ3Vlc3QgT1MiCisJZGVwZW5kcyBvbiBYRU4KKwloZWxwCisJ ICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxlIERSTSBzdXBwb3J0CisJ ICBmb3IgWGVuLgorCitjb25maWcgRFJNX1hFTl9GUk9OVEVORAorCXRyaXN0YXRlICJQYXJhLXZp cnR1YWxpemVkIGZyb250ZW5kIGRyaXZlciBmb3IgWGVuIGd1ZXN0IE9TIgorCWRlcGVuZHMgb24g RFJNX1hFTgorCWRlcGVuZHMgb24gRFJNCisJc2VsZWN0IERSTV9LTVNfSEVMUEVSCisJc2VsZWN0 IFZJREVPTU9ERV9IRUxQRVJTCisJc2VsZWN0IFhFTl9YRU5CVVNfRlJPTlRFTkQKKwloZWxwCisJ ICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxlIGEgcGFyYS12aXJ0dWFs aXplZAorCSAgZnJvbnRlbmQgRFJNL0tNUyBkcml2ZXIgZm9yIFhlbiBndWVzdCBPU2VzLgorCitj b25maWcgRFJNX1hFTl9GUk9OVEVORF9DTUEKKwlib29sICJVc2UgRFJNIENNQSB0byBhbGxvY2F0 ZSBkdW1iIGJ1ZmZlcnMiCisJZGVwZW5kcyBvbiBEUk1fWEVOX0ZST05URU5ECisJc2VsZWN0IERS TV9LTVNfQ01BX0hFTFBFUgorCXNlbGVjdCBEUk1fR0VNX0NNQV9IRUxQRVIKKwloZWxwCisJICBV c2UgRFJNIENNQSBoZWxwZXJzIHRvIGFsbG9jYXRlIGRpc3BsYXkgYnVmZmVycy4KKwkgIFRoaXMg aXMgdXNlZnVsIGZvciB0aGUgdXNlLWNhc2VzIHdoZW4gZ3Vlc3QgZHJpdmVyIG5lZWRzIHRvCisJ ICBzaGFyZSBvciBleHBvcnQgYnVmZmVycyB0byBvdGhlciBkcml2ZXJzIHdoaWNoIG9ubHkgZXhw ZWN0CisJICBjb250aWd1b3VzIGJ1ZmZlcnMuCisJICBOb3RlOiBpbiB0aGlzIG1vZGUgZHJpdmVy IGNhbm5vdCB1c2UgYnVmZmVycyBhbGxvY2F0ZWQKKwkgIGJ5IHRoZSBiYWNrZW5kLgpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v TWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zNTI3MzBk YzZjMTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL01ha2VmaWxlCkBA IC0wLDAgKzEsMTYgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlU CisKK2RybV94ZW5fZnJvbnQtb2JqcyA6PSB4ZW5fZHJtX2Zyb250Lm8gXAorCQkgICAgICB4ZW5f ZHJtX2Zyb250X2ttcy5vIFwKKwkJICAgICAgeGVuX2RybV9mcm9udF9jb25uLm8gXAorCQkgICAg ICB4ZW5fZHJtX2Zyb250X2V2dGNobmwubyBcCisJCSAgICAgIHhlbl9kcm1fZnJvbnRfc2hidWYu byBcCisJCSAgICAgIHhlbl9kcm1fZnJvbnRfY2ZnLm8KKworaWZlcSAoJChDT05GSUdfRFJNX1hF Tl9GUk9OVEVORF9DTUEpLHkpCisJZHJtX3hlbl9mcm9udC1vYmpzICs9IHhlbl9kcm1fZnJvbnRf Z2VtX2NtYS5vCitlbHNlCisJZHJtX3hlbl9mcm9udC1vYmpzICs9IHhlbl9kcm1fZnJvbnRfZ2Vt Lm8KK2VuZGlmCisKK29iai0kKENPTkZJR19EUk1fWEVOX0ZST05URU5EKSArPSBkcm1feGVuX2Zy b250Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5iMDg4MTdlNWUzNWMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwpAQCAtMCwwICsxLDg4MCBAQAorLy8gU1BE WC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEt dmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBT eXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVr c2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybVAu aD4KKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJt X2NydGNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KKyNpbmNsdWRlIDxkcm0v ZHJtX2dlbV9jbWFfaGVscGVyLmg+CisKKyNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4KKwor I2luY2x1ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4KKyNpbmNsdWRlIDx4ZW4veGVuLmg+CisjaW5j bHVkZSA8eGVuL3hlbmJ1cy5oPgorCisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9kaXNwbGlm Lmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9u dF9jZmcuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2V2dGNobmwuaCIKKyNpbmNsdWRlICJ4 ZW5fZHJtX2Zyb250X2dlbS5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfa21zLmgiCisjaW5j bHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgorCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kYnVm IHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CisJdWludDY0X3QgZGJ1Zl9jb29raWU7CisJdWlu dDY0X3QgZmJfY29va2llOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpzaGJ1ZjsKK307 CisKK3N0YXRpYyBpbnQgZGJ1Zl9hZGRfdG9fbGlzdChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZv ICpmcm9udF9pbmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqc2hidWYsIHVpbnQ2 NF90IGRidWZfY29va2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmRidWY7CisK KwlkYnVmID0ga3phbGxvYyhzaXplb2YoKmRidWYpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRidWYp CisJCXJldHVybiAtRU5PTUVNOworCisJZGJ1Zi0+ZGJ1Zl9jb29raWUgPSBkYnVmX2Nvb2tpZTsK KwlkYnVmLT5zaGJ1ZiA9IHNoYnVmOworCWxpc3RfYWRkKCZkYnVmLT5saXN0LCAmZnJvbnRfaW5m by0+ZGJ1Zl9saXN0KTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCB4ZW5fZHJtX2Zy b250X2RidWYgKmRidWZfZ2V0KHN0cnVjdCBsaXN0X2hlYWQgKmRidWZfbGlzdCwKKwkJdWludDY0 X3QgZGJ1Zl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqYnVmLCAqcTsK KworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShidWYsIHEsIGRidWZfbGlzdCwgbGlzdCkKKwkJ aWYgKGJ1Zi0+ZGJ1Zl9jb29raWUgPT0gZGJ1Zl9jb29raWUpCisJCQlyZXR1cm4gYnVmOworCisJ cmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGRidWZfZmx1c2hfZmIoc3RydWN0IGxpc3Rf aGVhZCAqZGJ1Zl9saXN0LCB1aW50NjRfdCBmYl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZGJ1ZiAqYnVmLCAqcTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShidWYsIHEs IGRidWZfbGlzdCwgbGlzdCkKKwkJaWYgKGJ1Zi0+ZmJfY29va2llID09IGZiX2Nvb2tpZSkKKwkJ CXhlbl9kcm1fZnJvbnRfc2hidWZfZmx1c2goYnVmLT5zaGJ1Zik7Cit9CisKK3N0YXRpYyB2b2lk IGRidWZfZnJlZShzdHJ1Y3QgbGlzdF9oZWFkICpkYnVmX2xpc3QsIHVpbnQ2NF90IGRidWZfY29v a2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmJ1ZiwgKnE7CisKKwlsaXN0X2Zv cl9lYWNoX2VudHJ5X3NhZmUoYnVmLCBxLCBkYnVmX2xpc3QsIGxpc3QpCisJCWlmIChidWYtPmRi dWZfY29va2llID09IGRidWZfY29va2llKSB7CisJCQlsaXN0X2RlbCgmYnVmLT5saXN0KTsKKwkJ CXhlbl9kcm1fZnJvbnRfc2hidWZfdW5tYXAoYnVmLT5zaGJ1Zik7CisJCQl4ZW5fZHJtX2Zyb250 X3NoYnVmX2ZyZWUoYnVmLT5zaGJ1Zik7CisJCQlrZnJlZShidWYpOworCQkJYnJlYWs7CisJCX0K K30KKworc3RhdGljIHZvaWQgZGJ1Zl9mcmVlX2FsbChzdHJ1Y3QgbGlzdF9oZWFkICpkYnVmX2xp c3QpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqYnVmLCAqcTsKKworCWxpc3RfZm9y X2VhY2hfZW50cnlfc2FmZShidWYsIHEsIGRidWZfbGlzdCwgbGlzdCkgeworCQlsaXN0X2RlbCgm YnVmLT5saXN0KTsKKwkJeGVuX2RybV9mcm9udF9zaGJ1Zl91bm1hcChidWYtPnNoYnVmKTsKKwkJ eGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKGJ1Zi0+c2hidWYpOworCQlrZnJlZShidWYpOworCX0K K30KKworc3RhdGljIHN0cnVjdCB4ZW5kaXNwbF9yZXEgKmJlX3ByZXBhcmVfcmVxKAorCQlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sLCB1aW50OF90IG9wZXJhdGlvbikKK3sK KwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisKKwlyZXEgPSBSSU5HX0dFVF9SRVFVRVNUKCZl dnRjaG5sLT51LnJlcS5yaW5nLAorCQkJZXZ0Y2hubC0+dS5yZXEucmluZy5yZXFfcHJvZF9wdnQp OworCXJlcS0+b3BlcmF0aW9uID0gb3BlcmF0aW9uOworCXJlcS0+aWQgPSBldnRjaG5sLT5ldnRf bmV4dF9pZCsrOworCWV2dGNobmwtPmV2dF9pZCA9IHJlcS0+aWQ7CisJcmV0dXJuIHJlcTsKK30K Kworc3RhdGljIGludCBiZV9zdHJlYW1fZG9faW8oc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hu bCAqZXZ0Y2hubCwKKwkJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVxKQoreworCXJlaW5pdF9jb21w bGV0aW9uKCZldnRjaG5sLT51LnJlcS5jb21wbGV0aW9uKTsKKwlpZiAodW5saWtlbHkoZXZ0Y2hu bC0+c3RhdGUgIT0gRVZUQ0hOTF9TVEFURV9DT05ORUNURUQpKQorCQlyZXR1cm4gLUVJTzsKKwor CXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mbHVzaChldnRjaG5sKTsKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBiZV9zdHJlYW1fd2FpdF9pbyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5s ICpldnRjaG5sKQoreworCWlmICh3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmV2dGNobmwt PnUucmVxLmNvbXBsZXRpb24sCisJCQltc2Vjc190b19qaWZmaWVzKFhFTl9EUk1fRlJPTlRfV0FJ VF9CQUNLX01TKSkgPD0gMCkKKwkJcmV0dXJuIC1FVElNRURPVVQ7CisKKwlyZXR1cm4gZXZ0Y2hu bC0+dS5yZXEucmVzcF9zdGF0dXM7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X21vZGVfc2V0KHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUsCisJCXVpbnQzMl90IHgs IHVpbnQzMl90IHksIHVpbnQzMl90IHdpZHRoLCB1aW50MzJfdCBoZWlnaHQsCisJCXVpbnQzMl90 IGJwcCwgdWludDY0X3QgZmJfY29va2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNo bmwgKmV2dGNobmw7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwlz dHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0 OworCisJZnJvbnRfaW5mbyA9IHBpcGVsaW5lLT5kcm1faW5mby0+ZnJvbnRfaW5mbzsKKwlldnRj aG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1twaXBlbGluZS0+aW5kZXhdLnJlcTsKKwlpZiAo dW5saWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJTzsKKworCW11dGV4X2xvY2soJmV2dGNo bmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZv LT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVORElT UExfT1BfU0VUX0NPTkZJRyk7CisJcmVxLT5vcC5zZXRfY29uZmlnLnggPSB4OworCXJlcS0+b3Au c2V0X2NvbmZpZy55ID0geTsKKwlyZXEtPm9wLnNldF9jb25maWcud2lkdGggPSB3aWR0aDsKKwly ZXEtPm9wLnNldF9jb25maWcuaGVpZ2h0ID0gaGVpZ2h0OworCXJlcS0+b3Auc2V0X2NvbmZpZy5i cHAgPSBicHA7CisJcmVxLT5vcC5zZXRfY29uZmlnLmZiX2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKwor CXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChyZXQgPT0gMCkKKwkJ cmV0ID0gYmVfc3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7CisKKwltdXRleF91bmxvY2soJmV2dGNo bmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGJl X2RidWZfY3JlYXRlX2ludChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAor CQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgsIHVpbnQzMl90IGhlaWdodCwK KwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzLAorCQlz dHJ1Y3Qgc2dfdGFibGUgKnNndCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpl dnRjaG5sOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpzaGJ1ZjsKKwlzdHJ1Y3QgeGVu ZGlzcGxfcmVxICpyZXE7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfY2ZnIGJ1Zl9jZmc7 CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0OworCisJZXZ0Y2hubCA9ICZmcm9udF9p bmZvLT5ldnRfcGFpcnNbR0VORVJJQ19PUF9FVlRfQ0hOTF0ucmVxOworCWlmICh1bmxpa2VseSgh ZXZ0Y2hubCkpCisJCXJldHVybiAtRUlPOworCisJbWVtc2V0KCZidWZfY2ZnLCAwLCBzaXplb2Yo YnVmX2NmZykpOworCWJ1Zl9jZmcueGJfZGV2ID0gZnJvbnRfaW5mby0+eGJfZGV2OworCWJ1Zl9j ZmcucGFnZXMgPSBwYWdlczsKKwlidWZfY2ZnLnNpemUgPSBzaXplOworCWJ1Zl9jZmcuc2d0ID0g c2d0OworCWJ1Zl9jZmcuYmVfYWxsb2MgPSBmcm9udF9pbmZvLT5jZmcuYmVfYWxsb2M7CisKKwlz aGJ1ZiA9IHhlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2MoJmJ1Zl9jZmcpOworCWlmICghc2hidWYp CisJCXJldHVybiAtRU5PTUVNOworCisJcmV0ID0gZGJ1Zl9hZGRfdG9fbGlzdChmcm9udF9pbmZv LCBzaGJ1ZiwgZGJ1Zl9jb29raWUpOworCWlmIChyZXQgPCAwKSB7CisJCXhlbl9kcm1fZnJvbnRf c2hidWZfZnJlZShzaGJ1Zik7CisJCXJldHVybiByZXQ7CisJfQorCisJbXV0ZXhfbG9jaygmZXZ0 Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2lu Zm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRjaG5sLCBYRU5E SVNQTF9PUF9EQlVGX0NSRUFURSk7CisJcmVxLT5vcC5kYnVmX2NyZWF0ZS5ncmVmX2RpcmVjdG9y eSA9CisJCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2dldF9kaXJfc3RhcnQoc2hidWYpOworCXJlcS0+ b3AuZGJ1Zl9jcmVhdGUuYnVmZmVyX3N6ID0gc2l6ZTsKKwlyZXEtPm9wLmRidWZfY3JlYXRlLmRi dWZfY29va2llID0gZGJ1Zl9jb29raWU7CisJcmVxLT5vcC5kYnVmX2NyZWF0ZS53aWR0aCA9IHdp ZHRoOworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUuaGVpZ2h0ID0gaGVpZ2h0OworCXJlcS0+b3AuZGJ1 Zl9jcmVhdGUuYnBwID0gYnBwOworCWlmIChidWZfY2ZnLmJlX2FsbG9jKQorCQlyZXEtPm9wLmRi dWZfY3JlYXRlLmZsYWdzIHw9IFhFTkRJU1BMX0RCVUZfRkxHX1JFUV9BTExPQzsKKworCXJldCA9 IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUo JmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZh aWw7CisKKwlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKwlpZiAocmV0IDwgMCkK KwkJZ290byBmYWlsOworCisJcmV0ID0geGVuX2RybV9mcm9udF9zaGJ1Zl9tYXAoc2hidWYpOwor CWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWw7CisKKwltdXRleF91bmxvY2soJmV2dGNobmwtPnUu cmVxLnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gMDsKKworZmFpbDoKKwltdXRleF91bmxvY2soJmV2 dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwlkYnVmX2ZyZWUoJmZyb250X2luZm8tPmRidWZf bGlzdCwgZGJ1Zl9jb29raWUpOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250 X2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llLCB1aW50MzJfdCB3aWR0aCwgdWludDMyX3QgaGVp Z2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90IHNpemUsIHN0cnVjdCBzZ190YWJsZSAqc2d0 KQoreworCXJldHVybiBiZV9kYnVmX2NyZWF0ZV9pbnQoZnJvbnRfaW5mbywgZGJ1Zl9jb29raWUs IHdpZHRoLCBoZWlnaHQsCisJCQlicHAsIHNpemUsIE5VTEwsIHNndCk7Cit9CisKK2ludCB4ZW5f ZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fcGFnZXMoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5m byAqZnJvbnRfaW5mbywKKwkJdWludDY0X3QgZGJ1Zl9jb29raWUsIHVpbnQzMl90IHdpZHRoLCB1 aW50MzJfdCBoZWlnaHQsCisJCXVpbnQzMl90IGJwcCwgdWludDY0X3Qgc2l6ZSwgc3RydWN0IHBh Z2UgKipwYWdlcykKK3sKKwlyZXR1cm4gYmVfZGJ1Zl9jcmVhdGVfaW50KGZyb250X2luZm8sIGRi dWZfY29va2llLCB3aWR0aCwgaGVpZ2h0LAorCQkJYnBwLCBzaXplLCBwYWdlcywgTlVMTCk7Cit9 CisKK3N0YXRpYyBpbnQgeGVuX2RybV9mcm9udF9kYnVmX2Rlc3Ryb3koc3RydWN0IHhlbl9kcm1f ZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJdWludDY0X3QgZGJ1Zl9jb29raWUpCit7CisJc3Ry dWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVx ICpyZXE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlib29sIGJlX2FsbG9jOworCWludCByZXQ7 CisKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tHRU5FUklDX09QX0VWVF9DSE5M XS5yZXE7CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0dXJuIC1FSU87CisKKwliZV9h bGxvYyA9IGZyb250X2luZm8tPmNmZy5iZV9hbGxvYzsKKworCS8qCisJICogRm9yIHRoZSBiYWNr ZW5kIGFsbG9jYXRlZCBidWZmZXIgcmVsZWFzZSByZWZlcmVuY2VzIG5vdywgc28gYmFja2VuZAor CSAqIGNhbiBmcmVlIHRoZSBidWZmZXIuCisJICovCisJaWYgKGJlX2FsbG9jKQorCQlkYnVmX2Zy ZWUoJmZyb250X2luZm8tPmRidWZfbGlzdCwgZGJ1Zl9jb29raWUpOworCisJbXV0ZXhfbG9jaygm ZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250 X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRjaG5sLCBY RU5ESVNQTF9PUF9EQlVGX0RFU1RST1kpOworCXJlcS0+b3AuZGJ1Zl9kZXN0cm95LmRidWZfY29v a2llID0gZGJ1Zl9jb29raWU7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVx KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7 CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IGJlX3N0cmVhbV93YWl0X2lvKGV2dGNobmwpOwor CisJLyoKKwkgKiBEbyB0aGlzIHJlZ2FyZGxlc3Mgb2YgY29tbXVuaWNhdGlvbiBzdGF0dXMgd2l0 aCB0aGUgYmFja2VuZDoKKwkgKiBpZiB3ZSBjYW5ub3QgcmVtb3ZlIHJlbW90ZSByZXNvdXJjZXMg cmVtb3ZlIHdoYXQgd2UgY2FuIGxvY2FsbHkuCisJICovCisJaWYgKCFiZV9hbGxvYykKKwkJZGJ1 Zl9mcmVlKCZmcm9udF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2llKTsKKworCW11dGV4X3Vu bG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7Cit9CisKK2lu dCB4ZW5fZHJtX2Zyb250X2ZiX2F0dGFjaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9u dF9pbmZvLAorCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDY0X3QgZmJfY29va2llLCB1aW50 MzJfdCB3aWR0aCwKKwkJdWludDMyX3QgaGVpZ2h0LCB1aW50MzJfdCBwaXhlbF9mb3JtYXQpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9kYnVmICpidWY7CisJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVxOworCXVuc2lnbmVk IGxvbmcgZmxhZ3M7CisJaW50IHJldDsKKworCWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3Bh aXJzW0dFTkVSSUNfT1BfRVZUX0NITkxdLnJlcTsKKwlpZiAodW5saWtlbHkoIWV2dGNobmwpKQor CQlyZXR1cm4gLUVJTzsKKworCWJ1ZiA9IGRidWZfZ2V0KCZmcm9udF9pbmZvLT5kYnVmX2xpc3Qs IGRidWZfY29va2llKTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlidWYtPmZi X2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKworCW11dGV4X2xvY2soJmV2dGNobmwtPnUucmVxLnJlcV9p b19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFn cyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVORElTUExfT1BfRkJfQVRUQUNI KTsKKwlyZXEtPm9wLmZiX2F0dGFjaC5kYnVmX2Nvb2tpZSA9IGRidWZfY29va2llOworCXJlcS0+ b3AuZmJfYXR0YWNoLmZiX2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKwlyZXEtPm9wLmZiX2F0dGFjaC53 aWR0aCA9IHdpZHRoOworCXJlcS0+b3AuZmJfYXR0YWNoLmhlaWdodCA9IGhlaWdodDsKKwlyZXEt Pm9wLmZiX2F0dGFjaC5waXhlbF9mb3JtYXQgPSBwaXhlbF9mb3JtYXQ7CisKKwlyZXQgPSBiZV9z dHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9u dF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IGJlX3N0 cmVhbV93YWl0X2lvKGV2dGNobmwpOworCisJbXV0ZXhfdW5sb2NrKCZldnRjaG5sLT51LnJlcS5y ZXFfaW9fbG9jayk7CisJcmV0dXJuIHJldDsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfZmJfZGV0 YWNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXVpbnQ2NF90IGZi X2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0 cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByZXQ7 CisKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tHRU5FUklDX09QX0VWVF9DSE5M XS5yZXE7CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0dXJuIC1FSU87CisKKwltdXRl eF9sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisKKwlzcGluX2xvY2tfaXJxc2F2 ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJlcSA9IGJlX3ByZXBhcmVfcmVxKGV2 dGNobmwsIFhFTkRJU1BMX09QX0ZCX0RFVEFDSCk7CisJcmVxLT5vcC5mYl9kZXRhY2guZmJfY29v a2llID0gZmJfY29va2llOworCisJcmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmwsIHJlcSk7 CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOwor CisJaWYgKHJldCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKwor CW11dGV4X3VubG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7 Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X3BhZ2VfZmxpcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9p bmZvICpmcm9udF9pbmZvLAorCQlpbnQgY29ubl9pZHgsIHVpbnQ2NF90IGZiX2Nvb2tpZSkKK3sK KwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4ZW5kaXNw bF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByZXQ7CisKKwlpZiAodW5s aWtlbHkoY29ubl9pZHggPj0gZnJvbnRfaW5mby0+bnVtX2V2dF9wYWlycykpCisJCXJldHVybiAt RUlOVkFMOworCisJZGJ1Zl9mbHVzaF9mYigmZnJvbnRfaW5mby0+ZGJ1Zl9saXN0LCBmYl9jb29r aWUpOworCWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5faWR4XS5yZXE7CisK KwltdXRleF9sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisKKwlzcGluX2xvY2tf aXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJlcSA9IGJlX3ByZXBhcmVf cmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX1BHX0ZMSVApOworCXJlcS0+b3AucGdfZmxpcC5mYl9j b29raWUgPSBmYl9jb29raWU7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVx KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7 CisKKwlpZiAocmV0ID09IDApCisJCXJldCA9IGJlX3N0cmVhbV93YWl0X2lvKGV2dGNobmwpOwor CisJbXV0ZXhfdW5sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisJcmV0dXJuIHJl dDsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X29uX2ZyYW1lX2RvbmUoc3RydWN0IHhlbl9kcm1f ZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJaW50IGNvbm5faWR4LCB1aW50NjRfdCBmYl9jb29r aWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZnJvbnRf aW5mby0+ZHJtX2luZm87CisKKwlpZiAodW5saWtlbHkoY29ubl9pZHggPj0gZnJvbnRfaW5mby0+ Y2ZnLm51bV9jb25uZWN0b3JzKSkKKwkJcmV0dXJuOworCisJeGVuX2RybV9mcm9udF9rbXNfb25f ZnJhbWVfZG9uZSgmZHJtX2luZm8tPnBpcGVsaW5lW2Nvbm5faWR4XSwKKwkJCWZiX2Nvb2tpZSk7 Cit9CisKK3N0YXRpYyBpbnQgeGVuX2RybV9kcnZfZHVtYl9jcmVhdGUoc3RydWN0IGRybV9maWxl ICpmaWxwLAorCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX21vZGVfY3JlYXRl X2R1bWIgKmFyZ3MpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZv ID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iajsKKwlpbnQg cmV0OworCisJLyoKKwkgKiBEdW1iIGNyZWF0aW9uIGlzIGEgdHdvIHN0YWdlIHByb2Nlc3M6IGZp cnN0IHdlIGNyZWF0ZSBhIGZ1bGx5CisJICogY29uc3RydWN0ZWQgR0VNIG9iamVjdCB3aGljaCBp cyBjb21tdW5pY2F0ZWQgdG8gdGhlIGJhY2tlbmQsIGFuZAorCSAqIG9ubHkgYWZ0ZXIgdGhhdCB3 ZSBjYW4gY3JlYXRlIEdFTSdzIGhhbmRsZS4gVGhpcyBpcyBkb25lIHNvLAorCSAqIGJlY2F1c2Ug b2YgdGhlIHBvc3NpYmxlIHJhY2VzOiBvbmNlIHlvdSBjcmVhdGUgYSBoYW5kbGUgaXQgYmVjb21l cworCSAqIGltbWVkaWF0ZWx5IHZpc2libGUgdG8gdXNlci1zcGFjZSwgc28gdGhlIGxhdHRlciBj YW4gdHJ5IGFjY2Vzc2luZworCSAqIG9iamVjdCB3aXRob3V0IHBhZ2VzIGV0Yy4KKwkgKiBGb3Ig ZGV0YWlscyBhbHNvIHNlZSBkcm1fZ2VtX2hhbmRsZV9jcmVhdGUKKwkgKi8KKwlhcmdzLT5waXRj aCA9IERJVl9ST1VORF9VUChhcmdzLT53aWR0aCAqIGFyZ3MtPmJwcCwgOCk7CisJYXJncy0+c2l6 ZSA9IGFyZ3MtPnBpdGNoICogYXJncy0+aGVpZ2h0OworCisJb2JqID0geGVuX2RybV9mcm9udF9n ZW1fY3JlYXRlKGRldiwgYXJncy0+c2l6ZSk7CisJaWYgKElTX0VSUl9PUl9OVUxMKG9iaikpIHsK KwkJcmV0ID0gUFRSX0VSUihvYmopOworCQlnb3RvIGZhaWw7CisJfQorCisJLyoKKwkgKiBJbiBj YXNlIG9mIENPTkZJR19EUk1fWEVOX0ZST05URU5EX0NNQSBnZW1fb2JqIGlzIGNvbnN0cnVjdGVk CisJICogdmlhIERSTSBDTUEgaGVscGVycyBhbmQgZG9lc24ndCBoYXZlIC0+cGFnZXMgYWxsb2Nh dGVkCisJICogKHhlbmRybV9nZW1fZ2V0X3BhZ2VzIHdpbGwgcmV0dXJuIE5VTEwpLCBidXQgaW5z dGVhZCBjYW4gcHJvdmlkZQorCSAqIHNnIHRhYmxlCisJICovCisJaWYgKHhlbl9kcm1fZnJvbnRf Z2VtX2dldF9wYWdlcyhvYmopKQorCQlyZXQgPSB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zy b21fcGFnZXMoCisJCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9k YnVmX3RvX2Nvb2tpZShvYmopLAorCQkJCWFyZ3MtPndpZHRoLCBhcmdzLT5oZWlnaHQsIGFyZ3Mt PmJwcCwKKwkJCQlhcmdzLT5zaXplLAorCQkJCXhlbl9kcm1fZnJvbnRfZ2VtX2dldF9wYWdlcyhv YmopKTsKKwllbHNlCisJCXJldCA9IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9zZ3Qo CisJCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nv b2tpZShvYmopLAorCQkJCWFyZ3MtPndpZHRoLCBhcmdzLT5oZWlnaHQsIGFyZ3MtPmJwcCwKKwkJ CQlhcmdzLT5zaXplLAorCQkJCXhlbl9kcm1fZnJvbnRfZ2VtX2dldF9zZ190YWJsZShvYmopKTsK KwlpZiAocmV0KQorCQlnb3RvIGZhaWxfYmFja2VuZDsKKworCS8qIFRoaXMgaXMgdGhlIHRhaWwg b2YgR0VNIG9iamVjdCBjcmVhdGlvbiAqLworCXJldCA9IGRybV9nZW1faGFuZGxlX2NyZWF0ZShm aWxwLCBvYmosICZhcmdzLT5oYW5kbGUpOworCWlmIChyZXQpCisJCWdvdG8gZmFpbF9oYW5kbGU7 CisKKwkvKiBEcm9wIHJlZmVyZW5jZSBmcm9tIGFsbG9jYXRlIC0gaGFuZGxlIGhvbGRzIGl0IG5v dyAqLworCWRybV9nZW1fb2JqZWN0X3B1dF91bmxvY2tlZChvYmopOworCXJldHVybiAwOworCitm YWlsX2hhbmRsZToKKwl4ZW5fZHJtX2Zyb250X2RidWZfZGVzdHJveShkcm1faW5mby0+ZnJvbnRf aW5mbywKKwkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShvYmopKTsKK2ZhaWxfYmFja2Vu ZDoKKwkvKiBkcm9wIHJlZmVyZW5jZSBmcm9tIGFsbG9jYXRlICovCisJZHJtX2dlbV9vYmplY3Rf cHV0X3VubG9ja2VkKG9iaik7CitmYWlsOgorCURSTV9FUlJPUigiRmFpbGVkIHRvIGNyZWF0ZSBk dW1iIGJ1ZmZlcjogJWRcbiIsIHJldCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQg eGVuX2RybV9kcnZfZnJlZV9vYmplY3RfdW5sb2NrZWQoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpv YmopCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gb2JqLT5k ZXYtPmRldl9wcml2YXRlOworCWludCBpZHg7CisKKwlpZiAoZHJtX2Rldl9lbnRlcihvYmotPmRl diwgJmlkeCkpIHsKKwkJeGVuX2RybV9mcm9udF9kYnVmX2Rlc3Ryb3koZHJtX2luZm8tPmZyb250 X2luZm8sCisJCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShvYmopKTsKKwkJZHJtX2Rl dl9leGl0KGlkeCk7CisJfSBlbHNlCisJCWRidWZfZnJlZSgmZHJtX2luZm8tPmZyb250X2luZm8t PmRidWZfbGlzdCwKKwkJCQl4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2llKG9iaikpOworCisJ eGVuX2RybV9mcm9udF9nZW1fZnJlZV9vYmplY3RfdW5sb2NrZWQob2JqKTsKK30KKworc3RhdGlj IHZvaWQgeGVuX2RybV9kcnZfcmVsZWFzZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQoreworCXN0 cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyA9IGRybV9pbmZvLT5mcm9u dF9pbmZvOworCisJeGVuX2RybV9mcm9udF9rbXNfZmluaShkcm1faW5mbyk7CisKKwlkcm1fYXRv bWljX2hlbHBlcl9zaHV0ZG93bihkZXYpOworCWRybV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRldik7 CisKKwlkcm1fZGV2X2ZpbmkoZGV2KTsKKwlrZnJlZShkZXYpOworCisJaWYgKGZyb250X2luZm8t PmNmZy5iZV9hbGxvYykKKwkJeGVuYnVzX3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54Yl9kZXYs CisJCQkJWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpOworCisJa2ZyZWUoZHJtX2luZm8pOworfQor CitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyB4ZW5fZHJtX2Rldl9mb3BzID0g eworCS5vd25lciAgICAgICAgICA9IFRISVNfTU9EVUxFLAorCS5vcGVuICAgICAgICAgICA9IGRy bV9vcGVuLAorCS5yZWxlYXNlICAgICAgICA9IGRybV9yZWxlYXNlLAorCS51bmxvY2tlZF9pb2N0 bCA9IGRybV9pb2N0bCwKKyNpZmRlZiBDT05GSUdfQ09NUEFUCisJLmNvbXBhdF9pb2N0bCAgID0g ZHJtX2NvbXBhdF9pb2N0bCwKKyNlbmRpZgorCS5wb2xsICAgICAgICAgICA9IGRybV9wb2xsLAor CS5yZWFkICAgICAgICAgICA9IGRybV9yZWFkLAorCS5sbHNlZWsgICAgICAgICA9IG5vX2xsc2Vl aywKKyNpZmRlZiBDT05GSUdfRFJNX1hFTl9GUk9OVEVORF9DTUEKKwkubW1hcCAgICAgICAgICAg PSBkcm1fZ2VtX2NtYV9tbWFwLAorI2Vsc2UKKwkubW1hcCAgICAgICAgICAgPSB4ZW5fZHJtX2Zy b250X2dlbV9tbWFwLAorI2VuZGlmCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHZtX29wZXJh dGlvbnNfc3RydWN0IHhlbl9kcm1fZHJ2X3ZtX29wcyA9IHsKKwkub3BlbiAgICAgICAgICAgPSBk cm1fZ2VtX3ZtX29wZW4sCisJLmNsb3NlICAgICAgICAgID0gZHJtX2dlbV92bV9jbG9zZSwKK307 CisKK3N0YXRpYyBzdHJ1Y3QgZHJtX2RyaXZlciB4ZW5fZHJtX2RyaXZlciA9IHsKKwkuZHJpdmVy X2ZlYXR1cmVzICAgICAgICAgICA9IERSSVZFUl9HRU0gfCBEUklWRVJfTU9ERVNFVCB8CisJCQkJ ICAgICBEUklWRVJfUFJJTUUgfCBEUklWRVJfQVRPTUlDLAorCS5yZWxlYXNlICAgICAgICAgICAg ICAgICAgID0geGVuX2RybV9kcnZfcmVsZWFzZSwKKwkuZ2VtX3ZtX29wcyAgICAgICAgICAgICAg ICA9ICZ4ZW5fZHJtX2Rydl92bV9vcHMsCisJLmdlbV9mcmVlX29iamVjdF91bmxvY2tlZCAgPSB4 ZW5fZHJtX2Rydl9mcmVlX29iamVjdF91bmxvY2tlZCwKKwkucHJpbWVfaGFuZGxlX3RvX2ZkICAg ICAgICA9IGRybV9nZW1fcHJpbWVfaGFuZGxlX3RvX2ZkLAorCS5wcmltZV9mZF90b19oYW5kbGUg ICAgICAgID0gZHJtX2dlbV9wcmltZV9mZF90b19oYW5kbGUsCisJLmdlbV9wcmltZV9pbXBvcnQg ICAgICAgICAgPSBkcm1fZ2VtX3ByaW1lX2ltcG9ydCwKKwkuZ2VtX3ByaW1lX2V4cG9ydCAgICAg ICAgICA9IGRybV9nZW1fcHJpbWVfZXhwb3J0LAorCS5nZW1fcHJpbWVfaW1wb3J0X3NnX3RhYmxl ID0geGVuX2RybV9mcm9udF9nZW1faW1wb3J0X3NnX3RhYmxlLAorCS5nZW1fcHJpbWVfZ2V0X3Nn X3RhYmxlICAgID0geGVuX2RybV9mcm9udF9nZW1fZ2V0X3NnX3RhYmxlLAorCS5kdW1iX2NyZWF0 ZSAgICAgICAgICAgICAgID0geGVuX2RybV9kcnZfZHVtYl9jcmVhdGUsCisJLmZvcHMgICAgICAg ICAgICAgICAgICAgICAgPSAmeGVuX2RybV9kZXZfZm9wcywKKwkubmFtZSAgICAgICAgICAgICAg ICAgICAgICA9ICJ4ZW5kcm0tZHUiLAorCS5kZXNjICAgICAgICAgICAgICAgICAgICAgID0gIlhl biBQViBEUk0gRGlzcGxheSBVbml0IiwKKwkuZGF0ZSAgICAgICAgICAgICAgICAgICAgICA9ICIy MDE4MDIyMSIsCisJLm1ham9yICAgICAgICAgICAgICAgICAgICAgPSAxLAorCS5taW5vciAgICAg ICAgICAgICAgICAgICAgID0gMCwKKworI2lmZGVmIENPTkZJR19EUk1fWEVOX0ZST05URU5EX0NN QQorCS5nZW1fcHJpbWVfdm1hcCAgICAgICAgICAgID0gZHJtX2dlbV9jbWFfcHJpbWVfdm1hcCwK KwkuZ2VtX3ByaW1lX3Z1bm1hcCAgICAgICAgICA9IGRybV9nZW1fY21hX3ByaW1lX3Z1bm1hcCwK KwkuZ2VtX3ByaW1lX21tYXAgICAgICAgICAgICA9IGRybV9nZW1fY21hX3ByaW1lX21tYXAsCisj ZWxzZQorCS5nZW1fcHJpbWVfdm1hcCAgICAgICAgICAgID0geGVuX2RybV9mcm9udF9nZW1fcHJp bWVfdm1hcCwKKwkuZ2VtX3ByaW1lX3Z1bm1hcCAgICAgICAgICA9IHhlbl9kcm1fZnJvbnRfZ2Vt X3ByaW1lX3Z1bm1hcCwKKwkuZ2VtX3ByaW1lX21tYXAgICAgICAgICAgICA9IHhlbl9kcm1fZnJv bnRfZ2VtX3ByaW1lX21tYXAsCisjZW5kaWYKK307CisKK3N0YXRpYyBpbnQgeGVuX2RybV9kcnZf aW5pdChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCXN0cnVjdCBk ZXZpY2UgKmRldiA9ICZmcm9udF9pbmZvLT54Yl9kZXYtPmRldjsKKwlzdHJ1Y3QgeGVuX2RybV9m cm9udF9kcm1faW5mbyAqZHJtX2luZm87CisJc3RydWN0IGRybV9kZXZpY2UgKmRybV9kZXY7CisJ aW50IHJldDsKKworCURSTV9JTkZPKCJDcmVhdGluZyAlc1xuIiwgeGVuX2RybV9kcml2ZXIuZGVz Yyk7CisKKwlkcm1faW5mbyA9IGt6YWxsb2Moc2l6ZW9mKCpkcm1faW5mbyksIEdGUF9LRVJORUwp OworCWlmICghZHJtX2luZm8pIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOworCX0K KworCWRybV9pbmZvLT5mcm9udF9pbmZvID0gZnJvbnRfaW5mbzsKKwlmcm9udF9pbmZvLT5kcm1f aW5mbyA9IGRybV9pbmZvOworCisJZHJtX2RldiA9IGRybV9kZXZfYWxsb2MoJnhlbl9kcm1fZHJp dmVyLCBkZXYpOworCWlmICghZHJtX2RldikgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZh aWw7CisJfQorCisJZHJtX2luZm8tPmRybV9kZXYgPSBkcm1fZGV2OworCisJZHJtX2Rldi0+ZGV2 X3ByaXZhdGUgPSBkcm1faW5mbzsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfa21zX2luaXQoZHJt X2luZm8pOworCWlmIChyZXQpIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBE Uk0vS01TLCByZXQgJWRcbiIsIHJldCk7CisJCWdvdG8gZmFpbF9tb2Rlc2V0OworCX0KKworCXJl dCA9IGRybV9kZXZfcmVnaXN0ZXIoZHJtX2RldiwgMCk7CisJaWYgKHJldCkKKwkJZ290byBmYWls X3JlZ2lzdGVyOworCisJRFJNX0lORk8oIkluaXRpYWxpemVkICVzICVkLiVkLiVkICVzIG9uIG1p bm9yICVkXG4iLAorCQkJeGVuX2RybV9kcml2ZXIubmFtZSwgeGVuX2RybV9kcml2ZXIubWFqb3Is CisJCQl4ZW5fZHJtX2RyaXZlci5taW5vciwgeGVuX2RybV9kcml2ZXIucGF0Y2hsZXZlbCwKKwkJ CXhlbl9kcm1fZHJpdmVyLmRhdGUsIGRybV9kZXYtPnByaW1hcnktPmluZGV4KTsKKworCXJldHVy biAwOworCitmYWlsX3JlZ2lzdGVyOgorCWRybV9kZXZfdW5yZWdpc3Rlcihkcm1fZGV2KTsKK2Zh aWxfbW9kZXNldDoKKwlkcm1fa21zX2hlbHBlcl9wb2xsX2ZpbmkoZHJtX2Rldik7CisJZHJtX21v ZGVfY29uZmlnX2NsZWFudXAoZHJtX2Rldik7CitmYWlsOgorCWtmcmVlKGRybV9pbmZvKTsKKwly ZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCB4ZW5fZHJtX2Rydl9maW5pKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJt X2luZm8gKmRybV9pbmZvID0gZnJvbnRfaW5mby0+ZHJtX2luZm87CisJc3RydWN0IGRybV9kZXZp Y2UgKmRldjsKKworCWlmICghZHJtX2luZm8pCisJCXJldHVybjsKKworCWRldiA9IGRybV9pbmZv LT5kcm1fZGV2OworCWlmICghZGV2KQorCQlyZXR1cm47CisKKwkvKiBOb3RoaW5nIHRvIGRvIGlm IGRldmljZSBpcyBhbHJlYWR5IHVucGx1Z2dlZCAqLworCWlmIChkcm1fZGV2X2lzX3VucGx1Z2dl ZChkZXYpKQorCQlyZXR1cm47CisKKwlkcm1fa21zX2hlbHBlcl9wb2xsX2ZpbmkoZGV2KTsKKwlk cm1fZGV2X3VucGx1ZyhkZXYpOworCisJZnJvbnRfaW5mby0+ZHJtX2luZm8gPSBOVUxMOworCisJ eGVuX2RybV9mcm9udF9ldnRjaG5sX2ZyZWVfYWxsKGZyb250X2luZm8pOworCWRidWZfZnJlZV9h bGwoJmZyb250X2luZm8tPmRidWZfbGlzdCk7CisKKwkvKgorCSAqIElmIHdlIGFyZSBub3QgdXNp bmcgYmFja2VuZCBhbGxvY2F0ZWQgYnVmZmVycywgdGhlbiB0ZWxsIHRoZQorCSAqIGJhY2tlbmQg d2UgYXJlIHJlYWR5IHRvIChyZSlpbml0aWFsaXplLiBPdGhlcndpc2UsIHdhaXQgZm9yCisJICog ZHJtX2RyaXZlci5yZWxlYXNlLgorCSAqLworCWlmICghZnJvbnRfaW5mby0+Y2ZnLmJlX2FsbG9j KQorCQl4ZW5idXNfc3dpdGNoX3N0YXRlKGZyb250X2luZm8tPnhiX2RldiwKKwkJCQlYZW5idXNT dGF0ZUluaXRpYWxpc2luZyk7Cit9CisKK3N0YXRpYyBpbnQgZGlzcGxiYWNrX2luaXR3YWl0KHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJc3RydWN0IHhlbl9kcm1f ZnJvbnRfY2ZnICpjZmcgPSAmZnJvbnRfaW5mby0+Y2ZnOworCWludCByZXQ7CisKKwljZmctPmZy b250X2luZm8gPSBmcm9udF9pbmZvOworCXJldCA9IHhlbl9kcm1fZnJvbnRfY2ZnX2NhcmQoZnJv bnRfaW5mbywgY2ZnKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCURSTV9JTkZP KCJIYXZlICVkIGNvbmVjdG9yKHMpXG4iLCBjZmctPm51bV9jb25uZWN0b3JzKTsKKwkvKiBDcmVh dGUgZXZlbnQgY2hhbm5lbHMgZm9yIGFsbCBjb25uZWN0b3JzIGFuZCBwdWJsaXNoICovCisJcmV0 ID0geGVuX2RybV9mcm9udF9ldnRjaG5sX2NyZWF0ZV9hbGwoZnJvbnRfaW5mbyk7CisJaWYgKHJl dCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4geGVuX2RybV9mcm9udF9ldnRjaG5sX3B1 Ymxpc2hfYWxsKGZyb250X2luZm8pOworfQorCitzdGF0aWMgaW50IGRpc3BsYmFja19jb25uZWN0 KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJeGVuX2RybV9mcm9u dF9ldnRjaG5sX3NldF9zdGF0ZShmcm9udF9pbmZvLCBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCk7 CisJcmV0dXJuIHhlbl9kcm1fZHJ2X2luaXQoZnJvbnRfaW5mbyk7Cit9CisKK3N0YXRpYyB2b2lk IGRpc3BsYmFja19kaXNjb25uZWN0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8pCit7CisJaWYgKCFmcm9udF9pbmZvLT5kcm1faW5mbykKKwkJcmV0dXJuOworCisJLyogVGVs bCB0aGUgYmFja2VuZCB0byB3YWl0IHVudGlsIHdlIHJlbGVhc2UgdGhlIERSTSBkcml2ZXIuICov CisJeGVuYnVzX3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54Yl9kZXYsIFhlbmJ1c1N0YXRlUmVj b25maWd1cmluZyk7CisKKwl4ZW5fZHJtX2Rydl9maW5pKGZyb250X2luZm8pOworfQorCitzdGF0 aWMgdm9pZCBkaXNwbGJhY2tfY2hhbmdlZChzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2LAor CQllbnVtIHhlbmJ1c19zdGF0ZSBiYWNrZW5kX3N0YXRlKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2luZm8gKmZyb250X2luZm8gPSBkZXZfZ2V0X2RydmRhdGEoJnhiX2Rldi0+ZGV2KTsKKwlp bnQgcmV0OworCisJRFJNX0RFQlVHKCJCYWNrZW5kIHN0YXRlIGlzICVzLCBmcm9udCBpcyAlc1xu IiwKKwkJCXhlbmJ1c19zdHJzdGF0ZShiYWNrZW5kX3N0YXRlKSwKKwkJCXhlbmJ1c19zdHJzdGF0 ZSh4Yl9kZXYtPnN0YXRlKSk7CisKKwlzd2l0Y2ggKGJhY2tlbmRfc3RhdGUpIHsKKwljYXNlIFhl bmJ1c1N0YXRlUmVjb25maWd1cmluZzoKKwkJLyogZmFsbCB0aHJvdWdoICovCisJY2FzZSBYZW5i dXNTdGF0ZVJlY29uZmlndXJlZDoKKwkJLyogZmFsbCB0aHJvdWdoICovCisJY2FzZSBYZW5idXNT dGF0ZUluaXRpYWxpc2VkOgorCQlicmVhazsKKworCWNhc2UgWGVuYnVzU3RhdGVJbml0aWFsaXNp bmc6CisJCWlmICh4Yl9kZXYtPnN0YXRlID09IFhlbmJ1c1N0YXRlUmVjb25maWd1cmluZykKKwkJ CWJyZWFrOworCisJCS8qIHJlY292ZXJpbmcgYWZ0ZXIgYmFja2VuZCB1bmV4cGVjdGVkIGNsb3N1 cmUgKi8KKwkJZGlzcGxiYWNrX2Rpc2Nvbm5lY3QoZnJvbnRfaW5mbyk7CisJCWJyZWFrOworCisJ Y2FzZSBYZW5idXNTdGF0ZUluaXRXYWl0OgorCQlpZiAoeGJfZGV2LT5zdGF0ZSA9PSBYZW5idXNT dGF0ZVJlY29uZmlndXJpbmcpCisJCQlicmVhazsKKworCQkvKiByZWNvdmVyaW5nIGFmdGVyIGJh Y2tlbmQgdW5leHBlY3RlZCBjbG9zdXJlICovCisJCWRpc3BsYmFja19kaXNjb25uZWN0KGZyb250 X2luZm8pOworCQlpZiAoeGJfZGV2LT5zdGF0ZSAhPSBYZW5idXNTdGF0ZUluaXRpYWxpc2luZykK KwkJCWJyZWFrOworCisJCXJldCA9IGRpc3BsYmFja19pbml0d2FpdChmcm9udF9pbmZvKTsKKwkJ aWYgKHJldCA8IDApCisJCQl4ZW5idXNfZGV2X2ZhdGFsKHhiX2RldiwgcmV0LAorCQkJCQkiaW5p dGlhbGl6aW5nIGZyb250ZW5kIik7CisJCWVsc2UKKwkJCXhlbmJ1c19zd2l0Y2hfc3RhdGUoeGJf ZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2VkKTsKKwkJYnJlYWs7CisKKwljYXNlIFhlbmJ1c1N0 YXRlQ29ubmVjdGVkOgorCQlpZiAoeGJfZGV2LT5zdGF0ZSAhPSBYZW5idXNTdGF0ZUluaXRpYWxp c2VkKQorCQkJYnJlYWs7CisKKwkJcmV0ID0gZGlzcGxiYWNrX2Nvbm5lY3QoZnJvbnRfaW5mbyk7 CisJCWlmIChyZXQgPCAwKSB7CisJCQlkaXNwbGJhY2tfZGlzY29ubmVjdChmcm9udF9pbmZvKTsK KwkJCXhlbmJ1c19kZXZfZmF0YWwoeGJfZGV2LCByZXQsCisJCQkJCSJpbml0aWFsaXppbmcgRFJN IGRyaXZlciIpOworCQl9IGVsc2UKKwkJCXhlbmJ1c19zd2l0Y2hfc3RhdGUoeGJfZGV2LCBYZW5i dXNTdGF0ZUNvbm5lY3RlZCk7CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZUNsb3Npbmc6 CisJCS8qCisJCSAqIGluIHRoaXMgc3RhdGUgYmFja2VuZCBzdGFydHMgZnJlZWluZyByZXNvdXJj ZXMsCisJCSAqIHNvIGxldCBpdCBnbyBpbnRvIGNsb3NlZCBzdGF0ZSwgc28gd2UgY2FuIGFsc28K KwkJICogcmVtb3ZlIG91cnMKKwkJICovCisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZVVu a25vd246CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2UgWGVuYnVzU3RhdGVDbG9zZWQ6CisJ CWlmICh4Yl9kZXYtPnN0YXRlID09IFhlbmJ1c1N0YXRlQ2xvc2VkKQorCQkJYnJlYWs7CisKKwkJ ZGlzcGxiYWNrX2Rpc2Nvbm5lY3QoZnJvbnRfaW5mbyk7CisJCWJyZWFrOworCX0KK30KKworc3Rh dGljIGludCB4ZW5fZHJ2X3Byb2JlKHN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYsCisJCWNv bnN0IHN0cnVjdCB4ZW5idXNfZGV2aWNlX2lkICppZCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvOworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZ4Yl9kZXYtPmRldjsK KwlpbnQgcmV0OworCisJLyoKKwkgKiBUaGUgZGV2aWNlIGlzIG5vdCBzcGF3biBmcm9tIGEgZGV2 aWNlIHRyZWUsIHNvIGFyY2hfc2V0dXBfZG1hX29wcworCSAqIGlzIG5vdCBjYWxsZWQsIHRodXMg bGVhdmluZyB0aGUgZGV2aWNlIHdpdGggZHVtbXkgRE1BIG9wcy4KKwkgKiBUaGlzIG1ha2VzIHRo ZSBkZXZpY2UgcmV0dXJuIGVycm9yIG9uIFBSSU1FIGJ1ZmZlciBpbXBvcnQsIHdoaWNoCisJICog aXMgbm90IGNvcnJlY3Q6IHRvIGZpeCB0aGlzIGNhbGwgb2ZfZG1hX2NvbmZpZ3VyZSgpIHdpdGgg YSBOVUxMCisJICogbm9kZSB0byBzZXQgZGVmYXVsdCBETUEgb3BzLgorCSAqLworCWRldi0+YnVz LT5mb3JjZV9kbWEgPSB0cnVlOworCWRldi0+Y29oZXJlbnRfZG1hX21hc2sgPSBETUFfQklUX01B U0soMzIpOworCXJldCA9IG9mX2RtYV9jb25maWd1cmUoZGV2LCBOVUxMKTsKKwlpZiAocmV0IDwg MCkgeworCQlEUk1fRVJST1IoIkNhbm5vdCBzZXR1cCBETUEgb3BzLCByZXQgJWQiLCByZXQpOwor CQlyZXR1cm4gcmV0OworCX0KKworCWZyb250X2luZm8gPSBkZXZtX2t6YWxsb2MoJnhiX2Rldi0+ ZGV2LAorCQkJc2l6ZW9mKCpmcm9udF9pbmZvKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFmcm9udF9p bmZvKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZyb250X2luZm8tPnhiX2RldiA9IHhiX2RldjsK KwlzcGluX2xvY2tfaW5pdCgmZnJvbnRfaW5mby0+aW9fbG9jayk7CisJSU5JVF9MSVNUX0hFQUQo JmZyb250X2luZm8tPmRidWZfbGlzdCk7CisJZGV2X3NldF9kcnZkYXRhKCZ4Yl9kZXYtPmRldiwg ZnJvbnRfaW5mbyk7CisKKwlyZXR1cm4geGVuYnVzX3N3aXRjaF9zdGF0ZSh4Yl9kZXYsIFhlbmJ1 c1N0YXRlSW5pdGlhbGlzaW5nKTsKK30KKworc3RhdGljIGludCB4ZW5fZHJ2X3JlbW92ZShzdHJ1 Y3QgeGVuYnVzX2RldmljZSAqZGV2KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZy b250X2luZm8gPSBkZXZfZ2V0X2RydmRhdGEoJmRldi0+ZGV2KTsKKwlpbnQgdG8gPSAxMDA7CisK Kwl4ZW5idXNfc3dpdGNoX3N0YXRlKGRldiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsKKworCS8qCisJ ICogT24gZHJpdmVyIHJlbW92YWwgaXQgaXMgZGlzY29ubmVjdGVkIGZyb20gWGVuQnVzLAorCSAq IHNvIG5vIGJhY2tlbmQgc3RhdGUgY2hhbmdlIGV2ZW50cyBjb21lIHZpYSAub3RoZXJlbmRfY2hh bmdlZAorCSAqIGNhbGxiYWNrLiBUaGlzIHByZXZlbnRzIHVzIGZyb20gZXhpdGluZyBncmFjZWZ1 bGx5LCBlLmcuCisJICogc2lnbmFsaW5nIHRoZSBiYWNrZW5kIHRvIGZyZWUgZXZlbnQgY2hhbm5l bHMsIHdhaXRpbmcgZm9yIGl0cworCSAqIHN0YXRlIHRvIGNoYW5nZSB0byBYZW5idXNTdGF0ZUNs b3NlZCBhbmQgY2xlYW5pbmcgYXQgb3VyIGVuZC4KKwkgKiBOb3JtYWxseSB3aGVuIGZyb250IGRy aXZlciByZW1vdmVkIGJhY2tlbmQgd2lsbCBmaW5hbGx5IGdvIGludG8KKwkgKiBYZW5idXNTdGF0 ZUluaXRXYWl0IHN0YXRlLgorCSAqCisJICogV29ya2Fyb3VuZDogcmVhZCBiYWNrZW5kJ3Mgc3Rh dGUgbWFudWFsbHkgYW5kIHdhaXQgd2l0aCB0aW1lLW91dC4KKwkgKi8KKwl3aGlsZSAoKHhlbmJ1 c19yZWFkX3Vuc2lnbmVkKGZyb250X2luZm8tPnhiX2Rldi0+b3RoZXJlbmQsCisJCQkic3RhdGUi LCBYZW5idXNTdGF0ZVVua25vd24pICE9IFhlbmJ1c1N0YXRlSW5pdFdhaXQpICYmCisJCQl0by0t KQorCQltc2xlZXAoMTApOworCisJaWYgKCF0bykKKwkJRFJNX0VSUk9SKCJCYWNrZW5kIHN0YXRl IGlzICVzIHdoaWxlIHJlbW92aW5nIGRyaXZlclxuIiwKKwkJCXhlbmJ1c19zdHJzdGF0ZSh4ZW5i dXNfcmVhZF91bnNpZ25lZCgKKwkJCQkJZnJvbnRfaW5mby0+eGJfZGV2LT5vdGhlcmVuZCwKKwkJ CQkJInN0YXRlIiwgWGVuYnVzU3RhdGVVbmtub3duKSkpOworCisJeGVuX2RybV9kcnZfZmluaShm cm9udF9pbmZvKTsKKwl4ZW5idXNfZnJvbnRlbmRfY2xvc2VkKGRldik7CisJcmV0dXJuIDA7Cit9 CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGVuYnVzX2RldmljZV9pZCB4ZW5fZHJpdmVyX2lkc1td ID0geworCXsgWEVORElTUExfRFJJVkVSX05BTUUgfSwKKwl7ICIiIH0KK307CisKK3N0YXRpYyBz dHJ1Y3QgeGVuYnVzX2RyaXZlciB4ZW5fZHJpdmVyID0geworCS5pZHMgPSB4ZW5fZHJpdmVyX2lk cywKKwkucHJvYmUgPSB4ZW5fZHJ2X3Byb2JlLAorCS5yZW1vdmUgPSB4ZW5fZHJ2X3JlbW92ZSwK Kwkub3RoZXJlbmRfY2hhbmdlZCA9IGRpc3BsYmFja19jaGFuZ2VkLAorfTsKKworc3RhdGljIGlu dCBfX2luaXQgeGVuX2Rydl9pbml0KHZvaWQpCit7CisJLyogQXQgdGhlIG1vbWVudCB3ZSBvbmx5 IHN1cHBvcnQgY2FzZSB3aXRoIFhFTl9QQUdFX1NJWkUgPT0gUEFHRV9TSVpFICovCisJaWYgKFhF Tl9QQUdFX1NJWkUgIT0gUEFHRV9TSVpFKSB7CisJCURSTV9FUlJPUihYRU5ESVNQTF9EUklWRVJf TkFNRSAiOiBkaWZmZXJlbnQga2VybmVsIGFuZCBYZW4gcGFnZSBzaXplcyBhcmUgbm90IHN1cHBv cnRlZDogWEVOX1BBR0VfU0laRSAoJWx1KSAhPSBQQUdFX1NJWkUgKCVsdSlcbiIsCisJCQkJWEVO X1BBR0VfU0laRSwgUEFHRV9TSVpFKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJaWYgKCF4 ZW5fZG9tYWluKCkpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKCF4ZW5faGFzX3B2X2Rldmlj ZXMoKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlEUk1fSU5GTygiUmVnaXN0ZXJpbmcgWEVOIFBW ICIgWEVORElTUExfRFJJVkVSX05BTUUgIlxuIik7CisJcmV0dXJuIHhlbmJ1c19yZWdpc3Rlcl9m cm9udGVuZCgmeGVuX2RyaXZlcik7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCB4ZW5fZHJ2X2Zp bmkodm9pZCkKK3sKKwlEUk1fSU5GTygiVW5yZWdpc3RlcmluZyBYRU4gUFYgIiBYRU5ESVNQTF9E UklWRVJfTkFNRSAiXG4iKTsKKwl4ZW5idXNfdW5yZWdpc3Rlcl9kcml2ZXIoJnhlbl9kcml2ZXIp OworfQorCittb2R1bGVfaW5pdCh4ZW5fZHJ2X2luaXQpOworbW9kdWxlX2V4aXQoeGVuX2Rydl9m aW5pKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJYZW4gcGFyYS12aXJ0dWFsaXplZCBkaXNwbGF5 IGRldmljZSBmcm9udGVuZCIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFT KCJ4ZW46IlhFTkRJU1BMX0RSSVZFUl9OQU1FKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udC5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4yZDAzZGUyODhmOTYK LS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaApA QCAtMCwwICsxLDE4OSBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1Ig TUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29w eXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9s ZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4K KyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJP TlRfSF8KKworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9zaW1wbGVf a21zX2hlbHBlci5oPgorCisjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KKworI2luY2x1 ZGUgInhlbl9kcm1fZnJvbnRfY2ZnLmgiCisKKy8qKgorICogRE9DOiBEcml2ZXIgbW9kZXMgb2Yg b3BlcmF0aW9uIGluIHRlcm1zIG9mIGRpc3BsYXkgYnVmZmVycyB1c2VkCisgKgorICogRGVwZW5k aW5nIG9uIHRoZSByZXF1aXJlbWVudHMgZm9yIHRoZSBwYXJhLXZpcnR1YWxpemVkIGVudmlyb25t ZW50LCBuYW1lbHkKKyAqIHJlcXVpcmVtZW50cyBkaWN0YXRlZCBieSB0aGUgYWNjb21wYW55aW5n IERSTS8odilHUFUgZHJpdmVycyBydW5uaW5nIGluIGJvdGgKKyAqIGhvc3QgYW5kIGd1ZXN0IGVu dmlyb25tZW50cywgbnVtYmVyIG9mIG9wZXJhdGluZyBtb2RlcyBvZiBwYXJhLXZpcnR1YWxpemVk CisgKiBkaXNwbGF5IGRyaXZlciBhcmUgc3VwcG9ydGVkOgorICoKKyAqIC0gZGlzcGxheSBidWZm ZXJzIGNhbiBiZSBhbGxvY2F0ZWQgYnkgZWl0aGVyIGZyb250ZW5kIGRyaXZlciBvciBiYWNrZW5k CisgKiAtIGRpc3BsYXkgYnVmZmVycyBjYW4gYmUgYWxsb2NhdGVkIHRvIGJlIGNvbnRpZ3VvdXMg aW4gbWVtb3J5IG9yIG5vdAorICoKKyAqIE5vdGUhIEZyb250ZW5kIGRyaXZlciBpdHNlbGYgaGFz IG5vIGRlcGVuZGVuY3kgb24gY29udGlndW91cyBtZW1vcnkgZm9yCisgKiBpdHMgb3BlcmF0aW9u LgorICovCisKKy8qKgorICogRE9DOiBCdWZmZXJzIGFsbG9jYXRlZCBieSB0aGUgZnJvbnRlbmQg ZHJpdmVyCisgKgorICogVGhlIGJlbG93IG1vZGVzIG9mIG9wZXJhdGlvbiBhcmUgY29uZmlndXJl ZCBhdCBjb21waWxlLXRpbWUgdmlhCisgKiBmcm9udGVuZCBkcml2ZXIncyBrZXJuZWwgY29uZmln dXJhdGlvbjoKKyAqLworCisvKioKKyAqIERPQzogV2l0aCBHRU0gQ01BIGhlbHBlcnMKKyAqCisg KiBUaGlzIHVzZS1jYXNlIGlzIHVzZWZ1bCB3aGVuIHVzZWQgd2l0aCBhY2NvbXBhbnlpbmcgRFJN L3ZHUFUgZHJpdmVyIGluCisgKiBndWVzdCBkb21haW4gd2hpY2ggd2FzIGRlc2lnbmVkIHRvIG9u bHkgd29yayB3aXRoIGNvbnRpZ3VvdXMgYnVmZmVycywKKyAqIGUuZy4gRFJNIGRyaXZlciBiYXNl ZCBvbiBHRU0gQ01BIGhlbHBlcnM6IHN1Y2ggZHJpdmVycyBjYW4gb25seSBpbXBvcnQKKyAqIGNv bnRpZ3VvdXMgUFJJTUUgYnVmZmVycywgdGh1cyByZXF1aXJpbmcgZnJvbnRlbmQgZHJpdmVyIHRv IHByb3ZpZGUKKyAqIHN1Y2guIEluIG9yZGVyIHRvIGltcGxlbWVudCB0aGlzIG1vZGUgb2Ygb3Bl cmF0aW9uIHBhcmEtdmlydHVhbGl6ZWQKKyAqIGZyb250ZW5kIGRyaXZlciBjYW4gYmUgY29uZmln dXJlZCB0byB1c2UgR0VNIENNQSBoZWxwZXJzLgorICovCisKKy8qKgorICogRE9DOiBXaXRob3V0 IEdFTSBDTUEgaGVscGVycworICoKKyAqIElmIGFjY29tcGFueWluZyBkcml2ZXJzIGNhbiBjb3Bl IHdpdGggbm9uLWNvbnRpZ3VvdXMgbWVtb3J5IHRoZW4sIHRvCisgKiBsb3dlciBwcmVzc3VyZSBv biBDTUEgc3Vic3lzdGVtIG9mIHRoZSBrZXJuZWwsIGRyaXZlciBjYW4gYWxsb2NhdGUKKyAqIGJ1 ZmZlcnMgZnJvbSBzeXN0ZW0gbWVtb3J5LgorICoKKyAqIE5vdGUhIElmIHVzZWQgd2l0aCBhY2Nv bXBhbnlpbmcgRFJNLyh2KUdQVSBkcml2ZXJzIHRoaXMgbW9kZSBvZiBvcGVyYXRpb24KKyAqIG1h eSByZXF1aXJlIElPTU1VIHN1cHBvcnQgb24gdGhlIHBsYXRmb3JtLCBzbyBhY2NvbXBhbnlpbmcg RFJNL3ZHUFUKKyAqIGhhcmR3YXJlIGNhbiBzdGlsbCByZWFjaCBkaXNwbGF5IGJ1ZmZlciBtZW1v cnkgd2hpbGUgaW1wb3J0aW5nIFBSSU1FCisgKiBidWZmZXJzIGZyb20gdGhlIGZyb250ZW5kIGRy aXZlci4KKyAqLworCisvKioKKyAqIERPQzogQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tl bmQKKyAqCisgKiBUaGlzIG1vZGUgb2Ygb3BlcmF0aW9uIGlzIHJ1bi10aW1lIGNvbmZpZ3VyZWQg dmlhIGd1ZXN0IGRvbWFpbiBjb25maWd1cmF0aW9uCisgKiB0aHJvdWdoIFhlblN0b3JlIGVudHJp ZXMuCisgKgorICogRm9yIHN5c3RlbXMgd2hpY2ggZG8gbm90IHByb3ZpZGUgSU9NTVUgc3VwcG9y dCwgYnV0IGhhdmluZyBzcGVjaWZpYworICogcmVxdWlyZW1lbnRzIGZvciBkaXNwbGF5IGJ1ZmZl cnMgaXQgaXMgcG9zc2libGUgdG8gYWxsb2NhdGUgc3VjaCBidWZmZXJzCisgKiBhdCBiYWNrZW5k IHNpZGUgYW5kIHNoYXJlIHRob3NlIHdpdGggdGhlIGZyb250ZW5kLgorICogRm9yIGV4YW1wbGUs IGlmIGhvc3QgZG9tYWluIGlzIDE6MSBtYXBwZWQgYW5kIGhhcyBEUk0vR1BVIGhhcmR3YXJlIGV4 cGVjdGluZworICogcGh5c2ljYWxseSBjb250aWd1b3VzIG1lbW9yeSwgdGhpcyBhbGxvd3MgaW1w bGVtZW50aW5nIHplcm8tY29weWluZworICogdXNlLWNhc2VzLgorICoKKyAqIE5vdGUsIHdoaWxl IHVzaW5nIHRoaXMgc2NlbmFyaW8gdGhlIGZvbGxvd2luZyBzaG91bGQgYmUgY29uc2lkZXJlZDoK KyAqCisgKiAjLiBJZiBndWVzdCBkb21haW4gZGllcyB0aGVuIHBhZ2VzL2dyYW50cyByZWNlaXZl ZCBmcm9tIHRoZSBiYWNrZW5kCisgKiAgICBjYW5ub3QgYmUgY2xhaW1lZCBiYWNrCisgKgorICog Iy4gTWlzYmVoYXZpbmcgZ3Vlc3QgbWF5IHNlbmQgdG9vIG1hbnkgcmVxdWVzdHMgdG8gdGhlCisg KiAgICBiYWNrZW5kIGV4aGF1c3RpbmcgaXRzIGdyYW50IHJlZmVyZW5jZXMgYW5kIG1lbW9yeQor ICogICAgKGNvbnNpZGVyIHRoaXMgZnJvbSBzZWN1cml0eSBQT1YpCisgKi8KKworLyoqCisgKiBE T0M6IERyaXZlciBsaW1pdGF0aW9ucworICoKKyAqICMuIE9ubHkgcHJpbWFyeSBwbGFuZSB3aXRo b3V0IGFkZGl0aW9uYWwgcHJvcGVydGllcyBpcyBzdXBwb3J0ZWQuCisgKgorICogIy4gT25seSBv bmUgdmlkZW8gbW9kZSBwZXIgY29ubmVjdG9yIHN1cHBvcnRlZCB3aGljaCBpcyBjb25maWd1cmVk IHZpYSBYZW5TdG9yZS4KKyAqCisgKiAjLiBBbGwgQ1JUQ3Mgb3BlcmF0ZSBhdCBmaXhlZCBmcmVx dWVuY3kgb2YgNjBIei4KKyAqLworCisvKiB0aW1lb3V0IGluIG1zIHRvIHdhaXQgZm9yIGJhY2tl bmQgdG8gcmVzcG9uZCAqLworI2RlZmluZSBYRU5fRFJNX0ZST05UX1dBSVRfQkFDS19NUwkzMDAw CisKKyNpZm5kZWYgR1JBTlRfSU5WQUxJRF9SRUYKKy8qCisgKiBOb3RlIG9uIHVzYWdlIG9mIGdy YW50IHJlZmVyZW5jZSAwIGFzIGludmFsaWQgZ3JhbnQgcmVmZXJlbmNlOgorICogZ3JhbnQgcmVm ZXJlbmNlIDAgaXMgdmFsaWQsIGJ1dCBuZXZlciBleHBvc2VkIHRvIGEgUFYgZHJpdmVyLAorICog YmVjYXVzZSBvZiB0aGUgZmFjdCBpdCBpcyBhbHJlYWR5IGluIHVzZS9yZXNlcnZlZCBieSB0aGUg UFYgY29uc29sZS4KKyAqLworI2RlZmluZSBHUkFOVF9JTlZBTElEX1JFRgkwCisjZW5kaWYKKwor c3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyB7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2Rl djsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm87CisKKwkvKiB0byBw cm90ZWN0IGRhdGEgYmV0d2VlbiBiYWNrZW5kIElPIGNvZGUgYW5kIGludGVycnVwdCBoYW5kbGVy ICovCisJc3BpbmxvY2tfdCBpb19sb2NrOworCisJaW50IG51bV9ldnRfcGFpcnM7CisJc3RydWN0 IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wYWlyICpldnRfcGFpcnM7CisJc3RydWN0IHhlbl9kcm1f ZnJvbnRfY2ZnIGNmZzsKKworCS8qIGRpc3BsYXkgYnVmZmVycyAqLworCXN0cnVjdCBsaXN0X2hl YWQgZGJ1Zl9saXN0OworfTsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lIHsK KwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm87CisKKwlpbnQgaW5kZXg7 CisKKwlzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgcGlwZTsKKworCXN0cnVjdCBkcm1f Y29ubmVjdG9yIGNvbm47CisJLyogVGhlc2UgYXJlIG9ubHkgZm9yIGNvbm5lY3RvciBtb2RlIGNo ZWNraW5nICovCisJaW50IHdpZHRoLCBoZWlnaHQ7CisKKwlzdHJ1Y3QgZHJtX3BlbmRpbmdfdmJs YW5rX2V2ZW50ICpwZW5kaW5nX2V2ZW50OworCisJc3RydWN0IGRlbGF5ZWRfd29yayBwZmxpcF90 b193b3JrZXI7CisKKwlib29sIGNvbm5fY29ubmVjdGVkOworfTsKKworc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX2luZm8geworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm87 CisJc3RydWN0IGRybV9kZXZpY2UgKmRybV9kZXY7CisKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgcGlwZWxpbmVbWEVOX0RSTV9GUk9OVF9NQVhfQ1JUQ1NdOworfTsKKworc3Rh dGljIGlubGluZSB1aW50NjRfdCB4ZW5fZHJtX2Zyb250X2ZiX3RvX2Nvb2tpZSgKKwkJc3RydWN0 IGRybV9mcmFtZWJ1ZmZlciAqZmIpCit7CisJcmV0dXJuICh1aW50NjRfdClmYjsKK30KKworc3Rh dGljIGlubGluZSB1aW50NjRfdCB4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2llKAorCQlzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJcmV0dXJuICh1aW50NjRfdClnZW1fb2Jq OworfQorCitpbnQgeGVuX2RybV9mcm9udF9tb2RlX3NldChzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgKnBpcGVsaW5lLAorCQl1aW50MzJfdCB4LCB1aW50MzJfdCB5LCB1aW50MzJf dCB3aWR0aCwgdWludDMyX3QgaGVpZ2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90IGZiX2Nv b2tpZSk7CisKK2ludCB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4 ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llLCB1 aW50MzJfdCB3aWR0aCwgdWludDMyX3QgaGVpZ2h0LAorCQl1aW50MzJfdCBicHAsIHVpbnQ2NF90 IHNpemUsIHN0cnVjdCBzZ190YWJsZSAqc2d0KTsKKworaW50IHhlbl9kcm1fZnJvbnRfZGJ1Zl9j cmVhdGVfZnJvbV9wYWdlcyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAor CQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgsIHVpbnQzMl90IGhlaWdodCwK KwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKKwor aW50IHhlbl9kcm1fZnJvbnRfZmJfYXR0YWNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZy b250X2luZm8sCisJCXVpbnQ2NF90IGRidWZfY29va2llLCB1aW50NjRfdCBmYl9jb29raWUsIHVp bnQzMl90IHdpZHRoLAorCQl1aW50MzJfdCBoZWlnaHQsIHVpbnQzMl90IHBpeGVsX2Zvcm1hdCk7 CisKK2ludCB4ZW5fZHJtX2Zyb250X2ZiX2RldGFjaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZv ICpmcm9udF9pbmZvLAorCQl1aW50NjRfdCBmYl9jb29raWUpOworCitpbnQgeGVuX2RybV9mcm9u dF9wYWdlX2ZsaXAoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJaW50 IGNvbm5faWR4LCB1aW50NjRfdCBmYl9jb29raWUpOworCit2b2lkIHhlbl9kcm1fZnJvbnRfb25f ZnJhbWVfZG9uZShzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQlpbnQg Y29ubl9pZHgsIHVpbnQ2NF90IGZiX2Nvb2tpZSk7CisKKyNlbmRpZiAvKiBfX1hFTl9EUk1fRlJP TlRfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9j ZmcuYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcuYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjlhMGIyYjhlNjE2OQotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcuYwpAQCAtMCwwICsx LDc3IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKworLyoK KyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpbmNs dWRlIDxkcm0vZHJtUC5oPgorCisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CisKKyNpbmNsdWRl IDx4ZW4vaW50ZXJmYWNlL2lvL2Rpc3BsaWYuaD4KKyNpbmNsdWRlIDx4ZW4veGVuYnVzLmg+CisK KyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9jZmcu aCIKKworc3RhdGljIGludCBjZmdfY29ubmVjdG9yKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8g KmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZ19jb25uZWN0b3IgKmNvbm5l Y3RvciwKKwkJY29uc3QgY2hhciAqcGF0aCwgaW50IGluZGV4KQoreworCWNoYXIgKmNvbm5lY3Rv cl9wYXRoOworCisJY29ubmVjdG9yX3BhdGggPSBkZXZtX2thc3ByaW50ZigmZnJvbnRfaW5mby0+ eGJfZGV2LT5kZXYsCisJCQlHRlBfS0VSTkVMLCAiJXMvJWQiLCBwYXRoLCBpbmRleCk7CisJaWYg KCFjb25uZWN0b3JfcGF0aCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlpZiAoeGVuYnVzX3NjYW5m KFhCVF9OSUwsIGNvbm5lY3Rvcl9wYXRoLCBYRU5ESVNQTF9GSUVMRF9SRVNPTFVUSU9OLAorCQkJ IiVkIiBYRU5ESVNQTF9SRVNPTFVUSU9OX1NFUEFSQVRPUiAiJWQiLAorCQkJJmNvbm5lY3Rvci0+ d2lkdGgsICZjb25uZWN0b3ItPmhlaWdodCkgPCAwKSB7CisJCS8qIGVpdGhlciBubyBlbnRyeSBj b25maWd1cmVkIG9yIHdyb25nIHJlc29sdXRpb24gc2V0ICovCisJCWNvbm5lY3Rvci0+d2lkdGgg PSAwOworCQljb25uZWN0b3ItPmhlaWdodCA9IDA7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CWNvbm5lY3Rvci0+eGVuc3RvcmVfcGF0aCA9IGNvbm5lY3Rvcl9wYXRoOworCisJRFJNX0lORk8o IkNvbm5lY3RvciAlczogcmVzb2x1dGlvbiAlZHglZFxuIiwKKwkJCWNvbm5lY3Rvcl9wYXRoLCBj b25uZWN0b3ItPndpZHRoLCBjb25uZWN0b3ItPmhlaWdodCk7CisJcmV0dXJuIDA7Cit9CisKK2lu dCB4ZW5fZHJtX2Zyb250X2NmZ19jYXJkKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2ZnKQoreworCXN0cnVjdCB4ZW5i dXNfZGV2aWNlICp4Yl9kZXYgPSBmcm9udF9pbmZvLT54Yl9kZXY7CisJaW50IHJldCwgaTsKKwor CWlmICh4ZW5idXNfcmVhZF91bnNpZ25lZChmcm9udF9pbmZvLT54Yl9kZXYtPm5vZGVuYW1lLAor CQkJWEVORElTUExfRklFTERfQkVfQUxMT0MsIDApKSB7CisJCURSTV9JTkZPKCJCYWNrZW5kIGNh biBwcm92aWRlIGRpc3BsYXkgYnVmZmVyc1xuIik7CisJCWNmZy0+YmVfYWxsb2MgPSB0cnVlOwor CX0KKworCWNmZy0+bnVtX2Nvbm5lY3RvcnMgPSAwOworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9T SVpFKGNmZy0+Y29ubmVjdG9ycyk7IGkrKykgeworCQlyZXQgPSBjZmdfY29ubmVjdG9yKGZyb250 X2luZm8sCisJCQkJJmNmZy0+Y29ubmVjdG9yc1tpXSwgeGJfZGV2LT5ub2RlbmFtZSwgaSk7CisJ CWlmIChyZXQgPCAwKQorCQkJYnJlYWs7CisJCWNmZy0+bnVtX2Nvbm5lY3RvcnMrKzsKKwl9CisK KwlpZiAoIWNmZy0+bnVtX2Nvbm5lY3RvcnMpIHsKKwkJRFJNX0VSUk9SKCJObyBjb25uZWN0b3Io cykgY29uZmlndXJlZCBhdCAlc1xuIiwKKwkJCQl4Yl9kZXYtPm5vZGVuYW1lKTsKKwkJcmV0dXJu IC1FTk9ERVY7CisJfQorCisJcmV0dXJuIDA7Cit9CisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9jZmcuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjZl N2FmNjcwZjhjZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9jZmcuaApAQCAtMCwwICsxLDM3IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZp Y2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoK KyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hl bmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYgX19YRU5fRFJNX0ZST05UX0NGR19IXworI2Rl ZmluZSBfX1hFTl9EUk1fRlJPTlRfQ0ZHX0hfCisKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgor CisjZGVmaW5lIFhFTl9EUk1fRlJPTlRfTUFYX0NSVENTCTQKKworc3RydWN0IHhlbl9kcm1fZnJv bnRfY2ZnX2Nvbm5lY3RvciB7CisJaW50IHdpZHRoOworCWludCBoZWlnaHQ7CisJY2hhciAqeGVu c3RvcmVfcGF0aDsKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyB7CisJc3RydWN0IHhl bl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwkvKiBudW1iZXIgb2YgY29ubmVjdG9ycyBp biB0aGlzIGNvbmZpZ3VyYXRpb24gKi8KKwlpbnQgbnVtX2Nvbm5lY3RvcnM7CisJLyogY29ubmVj dG9yIGNvbmZpZ3VyYXRpb25zICovCisJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnX2Nvbm5lY3Rv ciBjb25uZWN0b3JzW1hFTl9EUk1fRlJPTlRfTUFYX0NSVENTXTsKKwkvKiBzZXQgaWYgZHVtYiBi dWZmZXJzIGFyZSBhbGxvY2F0ZWQgZXh0ZXJuYWxseSBvbiBiYWNrZW5kIHNpZGUgKi8KKwlib29s IGJlX2FsbG9jOworfTsKKworaW50IHhlbl9kcm1fZnJvbnRfY2ZnX2NhcmQoc3RydWN0IHhlbl9k cm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpj ZmcpOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX0NGR19IXyAqLwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uYyBiL2RyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udF9jb25uLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi5iNWQwYjI3OTgzYjgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jCkBAIC0wLDAgKzEsMTE1IEBACisvLyBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4gcGFyYS12aXJ0 dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3Rl bXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5k cl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21p Y19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CisKKyNpbmNsdWRl IDx2aWRlby92aWRlb21vZGUuaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNpbmNs dWRlICJ4ZW5fZHJtX2Zyb250X2Nvbm4uaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2ttcy5o IgorCitzdGF0aWMgc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICoKK3RvX3hlbl9k cm1fcGlwZWxpbmUoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKK3sKKwlyZXR1cm4g Y29udGFpbmVyX29mKGNvbm5lY3Rvciwgc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5l LCBjb25uKTsKK30KKworc3RhdGljIGNvbnN0IHVpbnQzMl90IHBsYW5lX2Zvcm1hdHNbXSA9IHsK KwlEUk1fRk9STUFUX1JHQjU2NSwKKwlEUk1fRk9STUFUX1JHQjg4OCwKKwlEUk1fRk9STUFUX1hS R0I4ODg4LAorCURSTV9GT1JNQVRfQVJHQjg4ODgsCisJRFJNX0ZPUk1BVF9YUkdCNDQ0NCwKKwlE Uk1fRk9STUFUX0FSR0I0NDQ0LAorCURSTV9GT1JNQVRfWFJHQjE1NTUsCisJRFJNX0ZPUk1BVF9B UkdCMTU1NSwKK307CisKK2NvbnN0IHVpbnQzMl90ICp4ZW5fZHJtX2Zyb250X2Nvbm5fZ2V0X2Zv cm1hdHMoaW50ICpmb3JtYXRfY291bnQpCit7CisJKmZvcm1hdF9jb3VudCA9IEFSUkFZX1NJWkUo cGxhbmVfZm9ybWF0cyk7CisJcmV0dXJuIHBsYW5lX2Zvcm1hdHM7Cit9CisKK3N0YXRpYyBpbnQg Y29ubmVjdG9yX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAorCQlzdHJ1 Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHggKmN0eCwKKwkJYm9vbCBmb3JjZSkKK3sKKwlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9kcm1f cGlwZWxpbmUoY29ubmVjdG9yKTsKKworCWlmIChkcm1fZGV2X2lzX3VucGx1Z2dlZChjb25uZWN0 b3ItPmRldikpCisJCXBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA9IGZhbHNlOworCisJcmV0dXJu IHBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA/IGNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVkIDoK KwkJCWNvbm5lY3Rvcl9zdGF0dXNfZGlzY29ubmVjdGVkOworfQorCisjZGVmaW5lIFhFTl9EUk1f Q1JUQ19WUkVGUkVTSF9IWgk2MAorCitzdGF0aWMgaW50IGNvbm5lY3Rvcl9nZXRfbW9kZXMoc3Ry dWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUoY29ubmVjdG9y KTsKKwlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZTsKKwlzdHJ1Y3QgdmlkZW9tb2RlIHZp ZGVvbW9kZTsKKwlpbnQgd2lkdGgsIGhlaWdodDsKKworCW1vZGUgPSBkcm1fbW9kZV9jcmVhdGUo Y29ubmVjdG9yLT5kZXYpOworCWlmICghbW9kZSkKKwkJcmV0dXJuIDA7CisKKwltZW1zZXQoJnZp ZGVvbW9kZSwgMCwgc2l6ZW9mKHZpZGVvbW9kZSkpOworCXZpZGVvbW9kZS5oYWN0aXZlID0gcGlw ZWxpbmUtPndpZHRoOworCXZpZGVvbW9kZS52YWN0aXZlID0gcGlwZWxpbmUtPmhlaWdodDsKKwl3 aWR0aCA9IHZpZGVvbW9kZS5oYWN0aXZlICsgdmlkZW9tb2RlLmhmcm9udF9wb3JjaCArCisJCQl2 aWRlb21vZGUuaGJhY2tfcG9yY2ggKyB2aWRlb21vZGUuaHN5bmNfbGVuOworCWhlaWdodCA9IHZp ZGVvbW9kZS52YWN0aXZlICsgdmlkZW9tb2RlLnZmcm9udF9wb3JjaCArCisJCQl2aWRlb21vZGUu dmJhY2tfcG9yY2ggKyB2aWRlb21vZGUudnN5bmNfbGVuOworCXZpZGVvbW9kZS5waXhlbGNsb2Nr ID0gd2lkdGggKiBoZWlnaHQgKiBYRU5fRFJNX0NSVENfVlJFRlJFU0hfSFo7CisJbW9kZS0+dHlw ZSA9IERSTV9NT0RFX1RZUEVfUFJFRkVSUkVEIHwgRFJNX01PREVfVFlQRV9EUklWRVI7CisKKwlk cm1fZGlzcGxheV9tb2RlX2Zyb21fdmlkZW9tb2RlKCZ2aWRlb21vZGUsIG1vZGUpOworCWRybV9t b2RlX3Byb2JlZF9hZGQoY29ubmVjdG9yLCBtb2RlKTsKKwlyZXR1cm4gMTsKK30KKworc3RhdGlj IGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2hlbHBlcl9mdW5jcyBjb25uZWN0b3JfaGVscGVy X2Z1bmNzID0geworCS5nZXRfbW9kZXMgPSBjb25uZWN0b3JfZ2V0X21vZGVzLAorCS5kZXRlY3Rf Y3R4ID0gY29ubmVjdG9yX2RldGVjdCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nv bm5lY3Rvcl9mdW5jcyBjb25uZWN0b3JfZnVuY3MgPSB7CisJLmRwbXMgPSBkcm1faGVscGVyX2Nv bm5lY3Rvcl9kcG1zLAorCS5maWxsX21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29u bmVjdG9yX21vZGVzLAorCS5kZXN0cm95ID0gZHJtX2Nvbm5lY3Rvcl9jbGVhbnVwLAorCS5yZXNl dCA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9yZXNldCwKKwkuYXRvbWljX2R1cGxpY2F0 ZV9zdGF0ZSA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kdXBsaWNhdGVfc3RhdGUsCisJ LmF0b21pY19kZXN0cm95X3N0YXRlID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2Rlc3Ry b3lfc3RhdGUsCit9OworCitpbnQgeGVuX2RybV9mcm9udF9jb25uX2luaXQoc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvLAorCQlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29u bmVjdG9yKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUg PQorCQkJdG9feGVuX2RybV9waXBlbGluZShjb25uZWN0b3IpOworCisJZHJtX2Nvbm5lY3Rvcl9o ZWxwZXJfYWRkKGNvbm5lY3RvciwgJmNvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOworCisJcGlwZWxp bmUtPmNvbm5fY29ubmVjdGVkID0gdHJ1ZTsKKworCWNvbm5lY3Rvci0+cG9sbGVkID0gRFJNX0NP Tk5FQ1RPUl9QT0xMX0NPTk5FQ1QgfAorCQkJRFJNX0NPTk5FQ1RPUl9QT0xMX0RJU0NPTk5FQ1Q7 CisKKwlyZXR1cm4gZHJtX2Nvbm5lY3Rvcl9pbml0KGRybV9pbmZvLT5kcm1fZGV2LCBjb25uZWN0 b3IsCisJCSZjb25uZWN0b3JfZnVuY3MsIERSTV9NT0RFX0NPTk5FQ1RPUl9WSVJUVUFMKTsKK30K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmggYi9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZjM4YzRiNmRiNWRmCi0tLSAvZGV2L251bGwKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uaApAQCAtMCwwICsxLDI3IEBA CisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoKKyAq ICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYt MjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hj aGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYg X19YRU5fRFJNX0ZST05UX0NPTk5fSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0NPTk5fSF8K KworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjLmg+CisjaW5j bHVkZSA8ZHJtL2RybV9lbmNvZGVyLmg+CisKKyNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CisKK3N0 cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvOworCitpbnQgeGVuX2RybV9mcm9udF9jb25uX2lu aXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvLAorCQlzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yKTsKKworY29uc3QgdWludDMyX3QgKnhlbl9kcm1fZnJvbnRf Y29ubl9nZXRfZm9ybWF0cyhpbnQgKmZvcm1hdF9jb3VudCk7CisKKyNlbmRpZiAvKiBfX1hFTl9E Uk1fRlJPTlRfQ09OTl9IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5f ZHJtX2Zyb250X2V2dGNobmwuYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9l dnRjaG5sLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4wMmI2ZjNk OWZlNGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnRfZXZ0Y2hubC5jCkBAIC0wLDAgKzEsMzg2IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UK KyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAq IEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtv QGVwYW0uY29tPgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorCisjaW5jbHVkZSA8bGlu dXgvZXJybm8uaD4KKyNpbmNsdWRlIDxsaW51eC9pcnEuaD4KKworI2luY2x1ZGUgPHhlbi94ZW5i dXMuaD4KKyNpbmNsdWRlIDx4ZW4vZXZlbnRzLmg+CisjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxl Lmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9u dF9ldnRjaG5sLmgiCisKK3N0YXRpYyBpcnFyZXR1cm5fdCBldnRjaG5sX2ludGVycnVwdF9jdHJs KGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5s ICpldnRjaG5sID0gZGV2X2lkOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8gPSBldnRjaG5sLT5mcm9udF9pbmZvOworCXN0cnVjdCB4ZW5kaXNwbF9yZXNwICpyZXNwOwor CVJJTkdfSURYIGksIHJwOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlpZiAodW5saWtlbHko ZXZ0Y2hubC0+c3RhdGUgIT0gRVZUQ0hOTF9TVEFURV9DT05ORUNURUQpKQorCQlyZXR1cm4gSVJR X0hBTkRMRUQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxh Z3MpOworCithZ2FpbjoKKwlycCA9IGV2dGNobmwtPnUucmVxLnJpbmcuc3JpbmctPnJzcF9wcm9k OworCS8qIGVuc3VyZSB3ZSBzZWUgcXVldWVkIHJlc3BvbnNlcyB1cCB0byBycCAqLworCXZpcnRf cm1iKCk7CisKKwlmb3IgKGkgPSBldnRjaG5sLT51LnJlcS5yaW5nLnJzcF9jb25zOyBpICE9IHJw OyBpKyspIHsKKwkJcmVzcCA9IFJJTkdfR0VUX1JFU1BPTlNFKCZldnRjaG5sLT51LnJlcS5yaW5n LCBpKTsKKwkJaWYgKHVubGlrZWx5KHJlc3AtPmlkICE9IGV2dGNobmwtPmV2dF9pZCkpCisJCQlj b250aW51ZTsKKworCQlzd2l0Y2ggKHJlc3AtPm9wZXJhdGlvbikgeworCQljYXNlIFhFTkRJU1BM X09QX1BHX0ZMSVA6CisJCWNhc2UgWEVORElTUExfT1BfRkJfQVRUQUNIOgorCQljYXNlIFhFTkRJ U1BMX09QX0ZCX0RFVEFDSDoKKwkJY2FzZSBYRU5ESVNQTF9PUF9EQlVGX0NSRUFURToKKwkJY2Fz ZSBYRU5ESVNQTF9PUF9EQlVGX0RFU1RST1k6CisJCWNhc2UgWEVORElTUExfT1BfU0VUX0NPTkZJ RzoKKwkJCWV2dGNobmwtPnUucmVxLnJlc3Bfc3RhdHVzID0gcmVzcC0+c3RhdHVzOworCQkJY29t cGxldGUoJmV2dGNobmwtPnUucmVxLmNvbXBsZXRpb24pOworCQkJYnJlYWs7CisKKwkJZGVmYXVs dDoKKwkJCURSTV9FUlJPUigiT3BlcmF0aW9uICVkIGlzIG5vdCBzdXBwb3J0ZWRcbiIsCisJCQkJ cmVzcC0+b3BlcmF0aW9uKTsKKwkJCWJyZWFrOworCQl9CisJfQorCisJZXZ0Y2hubC0+dS5yZXEu cmluZy5yc3BfY29ucyA9IGk7CisKKwlpZiAoaSAhPSBldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9w cm9kX3B2dCkgeworCQlpbnQgbW9yZV90b19kbzsKKworCQlSSU5HX0ZJTkFMX0NIRUNLX0ZPUl9S RVNQT05TRVMoJmV2dGNobmwtPnUucmVxLnJpbmcsCisJCQkJbW9yZV90b19kbyk7CisJCWlmICht b3JlX3RvX2RvKQorCQkJZ290byBhZ2FpbjsKKwl9IGVsc2UKKwkJZXZ0Y2hubC0+dS5yZXEucmlu Zy5zcmluZy0+cnNwX2V2ZW50ID0gaSArIDE7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZm cm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitz dGF0aWMgaXJxcmV0dXJuX3QgZXZ0Y2hubF9pbnRlcnJ1cHRfZXZ0KGludCBpcnEsIHZvaWQgKmRl dl9pZCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sID0gZGV2X2lk OworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8gPSBldnRjaG5sLT5mcm9u dF9pbmZvOworCXN0cnVjdCB4ZW5kaXNwbF9ldmVudF9wYWdlICpwYWdlID0gZXZ0Y2hubC0+dS5l dnQucGFnZTsKKwl1aW50MzJfdCBjb25zLCBwcm9kOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisK KwlpZiAodW5saWtlbHkoZXZ0Y2hubC0+c3RhdGUgIT0gRVZUQ0hOTF9TVEFURV9DT05ORUNURUQp KQorCQlyZXR1cm4gSVJRX0hBTkRMRUQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5m by0+aW9fbG9jaywgZmxhZ3MpOworCisJcHJvZCA9IHBhZ2UtPmluX3Byb2Q7CisJLyogZW5zdXJl IHdlIHNlZSByaW5nIGNvbnRlbnRzIHVwIHRvIHByb2QgKi8KKwl2aXJ0X3JtYigpOworCWlmIChw cm9kID09IHBhZ2UtPmluX2NvbnMpCisJCWdvdG8gb3V0OworCisJZm9yIChjb25zID0gcGFnZS0+ aW5fY29uczsgY29ucyAhPSBwcm9kOyBjb25zKyspIHsKKwkJc3RydWN0IHhlbmRpc3BsX2V2dCAq ZXZlbnQ7CisKKwkJZXZlbnQgPSAmWEVORElTUExfSU5fUklOR19SRUYocGFnZSwgY29ucyk7CisJ CWlmICh1bmxpa2VseShldmVudC0+aWQgIT0gZXZ0Y2hubC0+ZXZ0X2lkKyspKQorCQkJY29udGlu dWU7CisKKwkJc3dpdGNoIChldmVudC0+dHlwZSkgeworCQljYXNlIFhFTkRJU1BMX0VWVF9QR19G TElQOgorCQkJeGVuX2RybV9mcm9udF9vbl9mcmFtZV9kb25lKGZyb250X2luZm8sIGV2dGNobmwt PmluZGV4LAorCQkJCQlldmVudC0+b3AucGdfZmxpcC5mYl9jb29raWUpOworCQkJYnJlYWs7CisJ CX0KKwl9CisJcGFnZS0+aW5fY29ucyA9IGNvbnM7CisJLyogZW5zdXJlIHJpbmcgY29udGVudHMg Ki8KKwl2aXJ0X3dtYigpOworCitvdXQ6CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRf aW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJldHVybiBJUlFfSEFORExFRDsKK30KKworc3RhdGlj IHZvaWQgZXZ0Y2hubF9mcmVlKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8s CisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwpCit7CisJdW5zaWduZWQg bG9uZyBwYWdlID0gMDsKKworCWlmIChldnRjaG5sLT50eXBlID09IEVWVENITkxfVFlQRV9SRVEp CisJCXBhZ2UgPSAodW5zaWduZWQgbG9uZylldnRjaG5sLT51LnJlcS5yaW5nLnNyaW5nOworCWVs c2UgaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZUQ0hOTF9UWVBFX0VWVCkKKwkJcGFnZSA9ICh1bnNp Z25lZCBsb25nKWV2dGNobmwtPnUuZXZ0LnBhZ2U7CisJaWYgKCFwYWdlKQorCQlyZXR1cm47CisK KwlldnRjaG5sLT5zdGF0ZSA9IEVWVENITkxfU1RBVEVfRElTQ09OTkVDVEVEOworCisJaWYgKGV2 dGNobmwtPnR5cGUgPT0gRVZUQ0hOTF9UWVBFX1JFUSkgeworCQkvKiByZWxlYXNlIGFsbCB3aG8g c3RpbGwgd2FpdHMgZm9yIHJlc3BvbnNlIGlmIGFueSAqLworCQlldnRjaG5sLT51LnJlcS5yZXNw X3N0YXR1cyA9IC1FSU87CisJCWNvbXBsZXRlX2FsbCgmZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlv bik7CisJfQorCisJaWYgKGV2dGNobmwtPmlycSkKKwkJdW5iaW5kX2Zyb21faXJxaGFuZGxlcihl dnRjaG5sLT5pcnEsIGV2dGNobmwpOworCisJaWYgKGV2dGNobmwtPnBvcnQpCisJCXhlbmJ1c19m cmVlX2V2dGNobihmcm9udF9pbmZvLT54Yl9kZXYsIGV2dGNobmwtPnBvcnQpOworCisJLyogZW5k IGFjY2VzcyBhbmQgZnJlZSB0aGUgcGFnZSAqLworCWlmIChldnRjaG5sLT5ncmVmICE9IEdSQU5U X0lOVkFMSURfUkVGKQorCQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzKGV2dGNobmwtPmdyZWYs IDAsIHBhZ2UpOworCisJbWVtc2V0KGV2dGNobmwsIDAsIHNpemVvZigqZXZ0Y2hubCkpOworfQor CitzdGF0aWMgaW50IGV2dGNobmxfYWxsb2Moc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJv bnRfaW5mbywgaW50IGluZGV4LAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRj aG5sLAorCQllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF90eXBlIHR5cGUpCit7CisJc3RydWN0 IHhlbmJ1c19kZXZpY2UgKnhiX2RldiA9IGZyb250X2luZm8tPnhiX2RldjsKKwl1bnNpZ25lZCBs b25nIHBhZ2U7CisJZ3JhbnRfcmVmX3QgZ3JlZjsKKwlpcnFfaGFuZGxlcl90IGhhbmRsZXI7CisJ aW50IHJldDsKKworCW1lbXNldChldnRjaG5sLCAwLCBzaXplb2YoKmV2dGNobmwpKTsKKwlldnRj aG5sLT50eXBlID0gdHlwZTsKKwlldnRjaG5sLT5pbmRleCA9IGluZGV4OworCWV2dGNobmwtPmZy b250X2luZm8gPSBmcm9udF9pbmZvOworCWV2dGNobmwtPnN0YXRlID0gRVZUQ0hOTF9TVEFURV9E SVNDT05ORUNURUQ7CisJZXZ0Y2hubC0+Z3JlZiA9IEdSQU5UX0lOVkFMSURfUkVGOworCisJcGFn ZSA9IGdldF96ZXJvZWRfcGFnZShHRlBfTk9JTyB8IF9fR0ZQX0hJR0gpOworCWlmICghcGFnZSkg eworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZhaWw7CisJfQorCisJaWYgKHR5cGUgPT0gRVZU Q0hOTF9UWVBFX1JFUSkgeworCQlzdHJ1Y3QgeGVuX2Rpc3BsaWZfc3JpbmcgKnNyaW5nOworCisJ CWluaXRfY29tcGxldGlvbigmZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlvbik7CisJCW11dGV4X2lu aXQoJmV2dGNobmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwkJc3JpbmcgPSAoc3RydWN0IHhlbl9k aXNwbGlmX3NyaW5nICopcGFnZTsKKwkJU0hBUkVEX1JJTkdfSU5JVChzcmluZyk7CisJCUZST05U X1JJTkdfSU5JVCgmZXZ0Y2hubC0+dS5yZXEucmluZywKKwkJCQlzcmluZywgWEVOX1BBR0VfU0la RSk7CisKKwkJcmV0ID0geGVuYnVzX2dyYW50X3JpbmcoeGJfZGV2LCBzcmluZywgMSwgJmdyZWYp OworCQlpZiAocmV0IDwgMCkgeworCQkJZnJlZV9wYWdlKHBhZ2UpOworCQkJZ290byBmYWlsOwor CQl9CisKKwkJaGFuZGxlciA9IGV2dGNobmxfaW50ZXJydXB0X2N0cmw7CisJfSBlbHNlIHsKKwkJ ZXZ0Y2hubC0+dS5ldnQucGFnZSA9IChzdHJ1Y3QgeGVuZGlzcGxfZXZlbnRfcGFnZSAqKXBhZ2U7 CisKKwkJcmV0ID0gZ250dGFiX2dyYW50X2ZvcmVpZ25fYWNjZXNzKHhiX2Rldi0+b3RoZXJlbmRf aWQsCisJCQkJdmlydF90b19nZm4oKHZvaWQgKilwYWdlKSwgMCk7CisJCWlmIChyZXQgPCAwKSB7 CisJCQlmcmVlX3BhZ2UocGFnZSk7CisJCQlnb3RvIGZhaWw7CisJCX0KKworCQlncmVmID0gcmV0 OworCQloYW5kbGVyID0gZXZ0Y2hubF9pbnRlcnJ1cHRfZXZ0OworCX0KKwlldnRjaG5sLT5ncmVm ID0gZ3JlZjsKKworCXJldCA9IHhlbmJ1c19hbGxvY19ldnRjaG4oeGJfZGV2LCAmZXZ0Y2hubC0+ cG9ydCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbDsKKworCXJldCA9IGJpbmRfZXZ0Y2hu X3RvX2lycWhhbmRsZXIoZXZ0Y2hubC0+cG9ydCwKKwkJCWhhbmRsZXIsIDAsIHhiX2Rldi0+ZGV2 aWNldHlwZSwgZXZ0Y2hubCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbDsKKworCWV2dGNo bmwtPmlycSA9IHJldDsKKwlyZXR1cm4gMDsKKworZmFpbDoKKwlEUk1fRVJST1IoIkZhaWxlZCB0 byBhbGxvY2F0ZSByaW5nOiAlZFxuIiwgcmV0KTsKKwlyZXR1cm4gcmV0OworfQorCitpbnQgeGVu X2RybV9mcm9udF9ldnRjaG5sX2NyZWF0ZV9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAq ZnJvbnRfaW5mbykKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgKmNmZzsKKwlpbnQgcmV0 LCBjb25uOworCisJY2ZnID0gJmZyb250X2luZm8tPmNmZzsKKworCWZyb250X2luZm8tPmV2dF9w YWlycyA9IGtjYWxsb2MoY2ZnLT5udW1fY29ubmVjdG9ycywKKwkJCXNpemVvZihzdHJ1Y3QgeGVu X2RybV9mcm9udF9ldnRjaG5sX3BhaXIpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWZyb250X2luZm8t PmV2dF9wYWlycykgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZhaWw7CisJfQorCisJZm9y IChjb25uID0gMDsgY29ubiA8IGNmZy0+bnVtX2Nvbm5lY3RvcnM7IGNvbm4rKykgeworCQlyZXQg PSBldnRjaG5sX2FsbG9jKGZyb250X2luZm8sIGNvbm4sCisJCQkJJmZyb250X2luZm8tPmV2dF9w YWlyc1tjb25uXS5yZXEsCisJCQkJRVZUQ0hOTF9UWVBFX1JFUSk7CisJCWlmIChyZXQgPCAwKSB7 CisJCQlEUk1fRVJST1IoIkVycm9yIGFsbG9jYXRpbmcgY29udHJvbCBjaGFubmVsXG4iKTsKKwkJ CWdvdG8gZmFpbDsKKwkJfQorCisJCXJldCA9IGV2dGNobmxfYWxsb2MoZnJvbnRfaW5mbywgY29u biwKKwkJCQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLmV2dCwKKwkJCQlFVlRDSE5MX1RZ UEVfRVZUKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURSTV9FUlJPUigiRXJyb3IgYWxsb2NhdGlu ZyBpbi1ldmVudCBjaGFubmVsXG4iKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCX0KKwlmcm9udF9p bmZvLT5udW1fZXZ0X3BhaXJzID0gY2ZnLT5udW1fY29ubmVjdG9yczsKKwlyZXR1cm4gMDsKKwor ZmFpbDoKKwl4ZW5fZHJtX2Zyb250X2V2dGNobmxfZnJlZV9hbGwoZnJvbnRfaW5mbyk7CisJcmV0 dXJuIHJldDsKK30KKworc3RhdGljIGludCBldnRjaG5sX3B1Ymxpc2goc3RydWN0IHhlbmJ1c190 cmFuc2FjdGlvbiB4YnQsCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmws IGNvbnN0IGNoYXIgKnBhdGgsCisJCWNvbnN0IGNoYXIgKm5vZGVfcmluZywgY29uc3QgY2hhciAq bm9kZV9jaG5sKQoreworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYgPSBldnRjaG5sLT5m cm9udF9pbmZvLT54Yl9kZXY7CisJaW50IHJldDsKKworCS8qIHdyaXRlIGNvbnRyb2wgY2hhbm5l bCByaW5nIHJlZmVyZW5jZSAqLworCXJldCA9IHhlbmJ1c19wcmludGYoeGJ0LCBwYXRoLCBub2Rl X3JpbmcsICIldSIsIGV2dGNobmwtPmdyZWYpOworCWlmIChyZXQgPCAwKSB7CisJCXhlbmJ1c19k ZXZfZXJyb3IoeGJfZGV2LCByZXQsICJ3cml0aW5nIHJpbmctcmVmIik7CisJCXJldHVybiByZXQ7 CisJfQorCisJLyogd3JpdGUgZXZlbnQgY2hhbm5lbCByaW5nIHJlZmVyZW5jZSAqLworCXJldCA9 IHhlbmJ1c19wcmludGYoeGJ0LCBwYXRoLCBub2RlX2NobmwsICIldSIsIGV2dGNobmwtPnBvcnQp OworCWlmIChyZXQgPCAwKSB7CisJCXhlbmJ1c19kZXZfZXJyb3IoeGJfZGV2LCByZXQsICJ3cml0 aW5nIGV2ZW50IGNoYW5uZWwiKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsKK30K KworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wdWJsaXNoX2FsbChzdHJ1Y3QgeGVuX2RybV9m cm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCXN0cnVjdCB4ZW5idXNfdHJhbnNhY3Rpb24geGJ0 OworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqcGxhdF9kYXRhOworCWludCByZXQsIGNvbm47 CisKKwlwbGF0X2RhdGEgPSAmZnJvbnRfaW5mby0+Y2ZnOworCithZ2FpbjoKKwlyZXQgPSB4ZW5i dXNfdHJhbnNhY3Rpb25fc3RhcnQoJnhidCk7CisJaWYgKHJldCA8IDApIHsKKwkJeGVuYnVzX2Rl dl9mYXRhbChmcm9udF9pbmZvLT54Yl9kZXYsIHJldCwKKwkJCQkic3RhcnRpbmcgdHJhbnNhY3Rp b24iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlmb3IgKGNvbm4gPSAwOyBjb25uIDwgcGxhdF9k YXRhLT5udW1fY29ubmVjdG9yczsgY29ubisrKSB7CisJCXJldCA9IGV2dGNobmxfcHVibGlzaCh4 YnQsCisJCQkJJmZyb250X2luZm8tPmV2dF9wYWlyc1tjb25uXS5yZXEsCisJCQkJcGxhdF9kYXRh LT5jb25uZWN0b3JzW2Nvbm5dLnhlbnN0b3JlX3BhdGgsCisJCQkJWEVORElTUExfRklFTERfUkVR X1JJTkdfUkVGLAorCQkJCVhFTkRJU1BMX0ZJRUxEX1JFUV9DSEFOTkVMKTsKKwkJaWYgKHJldCA8 IDApCisJCQlnb3RvIGZhaWw7CisKKwkJcmV0ID0gZXZ0Y2hubF9wdWJsaXNoKHhidCwKKwkJCQkm ZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLmV2dCwKKwkJCQlwbGF0X2RhdGEtPmNvbm5lY3Rv cnNbY29ubl0ueGVuc3RvcmVfcGF0aCwKKwkJCQlYRU5ESVNQTF9GSUVMRF9FVlRfUklOR19SRUYs CisJCQkJWEVORElTUExfRklFTERfRVZUX0NIQU5ORUwpOworCQlpZiAocmV0IDwgMCkKKwkJCWdv dG8gZmFpbDsKKwl9CisKKwlyZXQgPSB4ZW5idXNfdHJhbnNhY3Rpb25fZW5kKHhidCwgMCk7CisJ aWYgKHJldCA8IDApIHsKKwkJaWYgKHJldCA9PSAtRUFHQUlOKQorCQkJZ290byBhZ2FpbjsKKwor CQl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0LAorCQkJCSJjb21wbGV0 aW5nIHRyYW5zYWN0aW9uIik7CisJCWdvdG8gZmFpbF90b19lbmQ7CisJfQorCisJcmV0dXJuIDA7 CisKK2ZhaWw6CisJeGVuYnVzX3RyYW5zYWN0aW9uX2VuZCh4YnQsIDEpOworCitmYWlsX3RvX2Vu ZDoKKwl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0LCAid3JpdGluZyBY ZW4gc3RvcmUiKTsKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hu bF9mbHVzaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sKQoreworCWludCBu b3RpZnk7CisKKwlldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2dCsrOworCVJJTkdfUFVT SF9SRVFVRVNUU19BTkRfQ0hFQ0tfTk9USUZZKCZldnRjaG5sLT51LnJlcS5yaW5nLCBub3RpZnkp OworCWlmIChub3RpZnkpCisJCW5vdGlmeV9yZW1vdGVfdmlhX2lycShldnRjaG5sLT5pcnEpOwor fQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zZXRfc3RhdGUoc3RydWN0IHhlbl9kcm1f ZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfc3Rh dGUgc3RhdGUpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgaTsKKworCWlmICghZnJv bnRfaW5mby0+ZXZ0X3BhaXJzKQorCQlyZXR1cm47CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJv bnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCWZvciAoaSA9IDA7IGkgPCBmcm9udF9pbmZvLT5u dW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2ldLnJlcS5zdGF0 ZSA9IHN0YXRlOworCQlmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0LnN0YXRlID0gc3RhdGU7 CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdz KTsKKworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChzdHJ1Y3QgeGVu X2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCWludCBpOworCisJaWYgKCFmcm9udF9p bmZvLT5ldnRfcGFpcnMpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCBmcm9udF9pbmZv LT5udW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZXZ0Y2hubF9mcmVlKGZyb250X2luZm8sICZmcm9u dF9pbmZvLT5ldnRfcGFpcnNbaV0ucmVxKTsKKwkJZXZ0Y2hubF9mcmVlKGZyb250X2luZm8sICZm cm9udF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0KTsKKwl9CisKKwlrZnJlZShmcm9udF9pbmZvLT5l dnRfcGFpcnMpOworCWZyb250X2luZm8tPmV2dF9wYWlycyA9IE5VTEw7Cit9CmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oIGIvZHJpdmVycy9n cHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAuLjM4Y2VhY2I4ZTljMQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmgKQEAgLTAsMCArMSw4MSBAQAor LyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAg WGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIw MTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hl bmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9f WEVOX0RSTV9GUk9OVF9FVlRDSE5MX0hfCisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9FVlRDSE5M X0hfCisKKyNpbmNsdWRlIDxsaW51eC9jb21wbGV0aW9uLmg+CisjaW5jbHVkZSA8bGludXgvdHlw ZXMuaD4KKworI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvaW8vcmluZy5oPgorI2luY2x1ZGUgPHhl bi9pbnRlcmZhY2UvaW8vZGlzcGxpZi5oPgorCisvKgorICogQWxsIG9wZXJhdGlvbnMgd2hpY2gg YXJlIG5vdCBjb25uZWN0b3Igb3JpZW50ZWQgdXNlIHRoaXMgY3RybCBldmVudCBjaGFubmVsLAor ICogZS5nLiBmYl9hdHRhY2gvZGVzdHJveSB3aGljaCBiZWxvbmcgdG8gYSBEUk0gZGV2aWNlLCBu b3QgdG8gYSBDUlRDLgorICovCisjZGVmaW5lIEdFTkVSSUNfT1BfRVZUX0NITkwJMAorCitlbnVt IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zdGF0ZSB7CisJRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNU RUQsCisJRVZUQ0hOTF9TVEFURV9DT05ORUNURUQsCit9OworCitlbnVtIHhlbl9kcm1fZnJvbnRf ZXZ0Y2hubF90eXBlIHsKKwlFVlRDSE5MX1RZUEVfUkVRLAorCUVWVENITkxfVFlQRV9FVlQsCit9 OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbzsKKworc3RydWN0IHhlbl9kcm1fZnJv bnRfZXZ0Y2hubCB7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwlp bnQgZ3JlZjsKKwlpbnQgcG9ydDsKKwlpbnQgaXJxOworCWludCBpbmRleDsKKwllbnVtIHhlbl9k cm1fZnJvbnRfZXZ0Y2hubF9zdGF0ZSBzdGF0ZTsKKwllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hu bF90eXBlIHR5cGU7CisJLyogZWl0aGVyIHJlc3BvbnNlIGlkIG9yIGluY29taW5nIGV2ZW50IGlk ICovCisJdWludDE2X3QgZXZ0X2lkOworCS8qIG5leHQgcmVxdWVzdCBpZCBvciBuZXh0IGV4cGVj dGVkIGV2ZW50IGlkICovCisJdWludDE2X3QgZXZ0X25leHRfaWQ7CisJdW5pb24geworCQlzdHJ1 Y3QgeworCQkJc3RydWN0IHhlbl9kaXNwbGlmX2Zyb250X3JpbmcgcmluZzsKKwkJCXN0cnVjdCBj b21wbGV0aW9uIGNvbXBsZXRpb247CisJCQkvKiBsYXRlc3QgcmVzcG9uc2Ugc3RhdHVzICovCisJ CQlpbnQgcmVzcF9zdGF0dXM7CisJCQkvKiBzZXJpYWxpemVyIGZvciBiYWNrZW5kIElPOiByZXF1 ZXN0L3Jlc3BvbnNlICovCisJCQlzdHJ1Y3QgbXV0ZXggcmVxX2lvX2xvY2s7CisJCX0gcmVxOwor CQlzdHJ1Y3QgeworCQkJc3RydWN0IHhlbmRpc3BsX2V2ZW50X3BhZ2UgKnBhZ2U7CisJCX0gZXZ0 OworCX0gdTsKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfcGFpciB7CisJc3Ry dWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCByZXE7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubCBldnQ7Cit9OworCitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2NyZWF0ZV9hbGwoc3Ry dWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyk7CisKK2ludCB4ZW5fZHJtX2Zyb250 X2V2dGNobmxfcHVibGlzaF9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5m byk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2ZsdXNoKHN0cnVjdCB4ZW5fZHJtX2Zy b250X2V2dGNobmwgKmV2dGNobmwpOworCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zZXRf c3RhdGUoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJZW51bSB4ZW5f ZHJtX2Zyb250X2V2dGNobmxfc3RhdGUgc3RhdGUpOworCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubF9mcmVlX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKTsKKwor I2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9FVlRDSE5MX0hfICovCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfZ2VtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi5hZDNjNmZlNGFmYTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnRfZ2VtLmMKQEAgLTAsMCArMSwzMDkgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJN IGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMu CisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1 c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfZ2VtLmgi CisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIu aD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fZ2Vt Lmg+CisKKyNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLmg+CisjaW5jbHVkZSA8bGludXgvc2NhdHRl cmxpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgorCisjaW5jbHVkZSA8eGVuL2Jh bGxvb24uaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJt X2Zyb250X3NoYnVmLmgiCisKK3N0cnVjdCB4ZW5fZ2VtX29iamVjdCB7CisJc3RydWN0IGRybV9n ZW1fb2JqZWN0IGJhc2U7CisKKwlzaXplX3QgbnVtX3BhZ2VzOworCXN0cnVjdCBwYWdlICoqcGFn ZXM7CisKKwkvKiBzZXQgZm9yIGJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBiYWNrZW5kICovCisJ Ym9vbCBiZV9hbGxvYzsKKworCS8qIHRoaXMgaXMgZm9yIGltcG9ydGVkIFBSSU1FIGJ1ZmZlciAq LworCXN0cnVjdCBzZ190YWJsZSAqc2d0X2ltcG9ydGVkOworfTsKKworc3RhdGljIGlubGluZSBz dHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnRvX3hlbl9nZW1fb2JqKAorCQlzdHJ1Y3QgZHJtX2dlbV9v YmplY3QgKmdlbV9vYmopCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihnZW1fb2JqLCBzdHJ1Y3Qg eGVuX2dlbV9vYmplY3QsIGJhc2UpOworfQorCitzdGF0aWMgaW50IGdlbV9hbGxvY19wYWdlc19h cnJheShzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmosCisJCXNpemVfdCBidWZfc2l6ZSkK K3sKKwl4ZW5fb2JqLT5udW1fcGFnZXMgPSBESVZfUk9VTkRfVVAoYnVmX3NpemUsIFBBR0VfU0la RSk7CisJeGVuX29iai0+cGFnZXMgPSBrdm1hbGxvY19hcnJheSh4ZW5fb2JqLT5udW1fcGFnZXMs CisJCQlzaXplb2Yoc3RydWN0IHBhZ2UgKiksIEdGUF9LRVJORUwpOworCXJldHVybiB4ZW5fb2Jq LT5wYWdlcyA9PSBOVUxMID8gLUVOT01FTSA6IDA7Cit9CisKK3N0YXRpYyB2b2lkIGdlbV9mcmVl X3BhZ2VzX2FycmF5KHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaikKK3sKKwlrdmZyZWUo eGVuX29iai0+cGFnZXMpOworCXhlbl9vYmotPnBhZ2VzID0gTlVMTDsKK30KKworc3RhdGljIHN0 cnVjdCB4ZW5fZ2VtX29iamVjdCAqZ2VtX2NyZWF0ZV9vYmooc3RydWN0IGRybV9kZXZpY2UgKmRl diwKKwlzaXplX3Qgc2l6ZSkKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmo7CisJ aW50IHJldDsKKworCXhlbl9vYmogPSBremFsbG9jKHNpemVvZigqeGVuX29iaiksIEdGUF9LRVJO RUwpOworCWlmICgheGVuX29iaikKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwlyZXQg PSBkcm1fZ2VtX29iamVjdF9pbml0KGRldiwgJnhlbl9vYmotPmJhc2UsIHNpemUpOworCWlmIChy ZXQgPCAwKSB7CisJCWtmcmVlKHhlbl9vYmopOworCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCX0K KworCXJldHVybiB4ZW5fb2JqOworfQorCitzdGF0aWMgc3RydWN0IHhlbl9nZW1fb2JqZWN0ICpn ZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHNpemVfdCBzaXplKQoreworCXN0cnVj dCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJ c3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOworCWludCByZXQ7CisKKwlzaXplID0gcm91 bmRfdXAoc2l6ZSwgUEFHRV9TSVpFKTsKKwl4ZW5fb2JqID0gZ2VtX2NyZWF0ZV9vYmooZGV2LCBz aXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoeGVuX29iaikpCisJCXJldHVybiB4ZW5fb2JqOwor CisJaWYgKGRybV9pbmZvLT5mcm9udF9pbmZvLT5jZmcuYmVfYWxsb2MpIHsKKwkJLyoKKwkJICog YmFja2VuZCB3aWxsIGFsbG9jYXRlIHNwYWNlIGZvciB0aGlzIGJ1ZmZlciwgc28KKwkJICogb25s eSBhbGxvY2F0ZSBhcnJheSBvZiBwb2ludGVycyB0byBwYWdlcworCQkgKi8KKwkJcmV0ID0gZ2Vt X2FsbG9jX3BhZ2VzX2FycmF5KHhlbl9vYmosIHNpemUpOworCQlpZiAocmV0IDwgMCkKKwkJCWdv dG8gZmFpbDsKKworCQkvKgorCQkgKiBhbGxvY2F0ZSBiYWxsb29uZWQgcGFnZXMgd2hpY2ggd2ls bCBiZSB1c2VkIHRvIG1hcAorCQkgKiBncmFudCByZWZlcmVuY2VzIHByb3ZpZGVkIGJ5IHRoZSBi YWNrZW5kCisJCSAqLworCQlyZXQgPSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+ bnVtX3BhZ2VzLAorCQkJCXhlbl9vYmotPnBhZ2VzKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURS TV9FUlJPUigiQ2Fubm90IGFsbG9jYXRlICV6dSBiYWxsb29uZWQgcGFnZXM6ICVkXG4iLAorCQkJ CQl4ZW5fb2JqLT5udW1fcGFnZXMsIHJldCk7CisJCQlnZW1fZnJlZV9wYWdlc19hcnJheSh4ZW5f b2JqKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCisJCXhlbl9vYmotPmJlX2FsbG9jID0gdHJ1ZTsK KwkJcmV0dXJuIHhlbl9vYmo7CisJfQorCS8qCisJICogbmVlZCB0byBhbGxvY2F0ZSBiYWNraW5n IHBhZ2VzIG5vdywgc28gd2UgY2FuIHNoYXJlIHRob3NlCisJICogd2l0aCB0aGUgYmFja2VuZAor CSAqLworCXhlbl9vYmotPm51bV9wYWdlcyA9IERJVl9ST1VORF9VUChzaXplLCBQQUdFX1NJWkUp OworCXhlbl9vYmotPnBhZ2VzID0gZHJtX2dlbV9nZXRfcGFnZXMoJnhlbl9vYmotPmJhc2UpOwor CWlmIChJU19FUlJfT1JfTlVMTCh4ZW5fb2JqLT5wYWdlcykpIHsKKwkJcmV0ID0gUFRSX0VSUih4 ZW5fb2JqLT5wYWdlcyk7CisJCXhlbl9vYmotPnBhZ2VzID0gTlVMTDsKKwkJZ290byBmYWlsOwor CX0KKworCXJldHVybiB4ZW5fb2JqOworCitmYWlsOgorCURSTV9FUlJPUigiRmFpbGVkIHRvIGFs bG9jYXRlIGJ1ZmZlciB3aXRoIHNpemUgJXp1XG4iLCBzaXplKTsKKwlyZXR1cm4gRVJSX1BUUihy ZXQpOworfQorCitzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKnhlbl9kcm1fZnJvbnRfZ2VtX2NyZWF0 ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQlzaXplX3Qgc2l6ZSkKK3sKKwlzdHJ1Y3QgeGVu X2dlbV9vYmplY3QgKnhlbl9vYmo7CisKKwl4ZW5fb2JqID0gZ2VtX2NyZWF0ZShkZXYsIHNpemUp OworCWlmIChJU19FUlJfT1JfTlVMTCh4ZW5fb2JqKSkKKwkJcmV0dXJuIEVSUl9DQVNUKHhlbl9v YmopOworCisJcmV0dXJuICZ4ZW5fb2JqLT5iYXNlOworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRf Z2VtX2ZyZWVfb2JqZWN0X3VubG9ja2VkKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikK K3sKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1f b2JqKTsKKworCWlmICh4ZW5fb2JqLT5iYXNlLmltcG9ydF9hdHRhY2gpIHsKKwkJZHJtX3ByaW1l X2dlbV9kZXN0cm95KCZ4ZW5fb2JqLT5iYXNlLCB4ZW5fb2JqLT5zZ3RfaW1wb3J0ZWQpOworCQln ZW1fZnJlZV9wYWdlc19hcnJheSh4ZW5fb2JqKTsKKwl9IGVsc2UgeworCQlpZiAoeGVuX29iai0+ cGFnZXMpIHsKKwkJCWlmICh4ZW5fb2JqLT5iZV9hbGxvYykgeworCQkJCWZyZWVfeGVuYmFsbG9v bmVkX3BhZ2VzKHhlbl9vYmotPm51bV9wYWdlcywKKwkJCQkJCXhlbl9vYmotPnBhZ2VzKTsKKwkJ CQlnZW1fZnJlZV9wYWdlc19hcnJheSh4ZW5fb2JqKTsKKwkJCX0gZWxzZQorCQkJCWRybV9nZW1f cHV0X3BhZ2VzKCZ4ZW5fb2JqLT5iYXNlLAorCQkJCQkJeGVuX29iai0+cGFnZXMsIHRydWUsIGZh bHNlKTsKKwkJfQorCX0KKwlkcm1fZ2VtX29iamVjdF9yZWxlYXNlKGdlbV9vYmopOworCWtmcmVl KHhlbl9vYmopOworfQorCitzdHJ1Y3QgcGFnZSAqKnhlbl9kcm1fZnJvbnRfZ2VtX2dldF9wYWdl cyhzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJc3RydWN0IHhlbl9nZW1fb2Jq ZWN0ICp4ZW5fb2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7CisKKwlyZXR1cm4geGVuX29i ai0+cGFnZXM7Cit9CisKK3N0cnVjdCBzZ190YWJsZSAqeGVuX2RybV9mcm9udF9nZW1fZ2V0X3Nn X3RhYmxlKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlzdHJ1Y3QgeGVuX2dl bV9vYmplY3QgKnhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1fb2JqKTsKKworCWlmICgheGVu X29iai0+cGFnZXMpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuIGRybV9wcmltZV9wYWdlc190 b19zZyh4ZW5fb2JqLT5wYWdlcywgeGVuX29iai0+bnVtX3BhZ2VzKTsKK30KKworc3RydWN0IGRy bV9nZW1fb2JqZWN0ICp4ZW5fZHJtX2Zyb250X2dlbV9pbXBvcnRfc2dfdGFibGUoc3RydWN0IGRy bV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLCBzdHJ1 Y3Qgc2dfdGFibGUgKnNndCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJt X2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29i ajsKKwlzaXplX3Qgc2l6ZTsKKwlpbnQgcmV0OworCisJc2l6ZSA9IGF0dGFjaC0+ZG1hYnVmLT5z aXplOworCXhlbl9vYmogPSBnZW1fY3JlYXRlX29iaihkZXYsIHNpemUpOworCWlmIChJU19FUlJf T1JfTlVMTCh4ZW5fb2JqKSkKKwkJcmV0dXJuIEVSUl9DQVNUKHhlbl9vYmopOworCisJcmV0ID0g Z2VtX2FsbG9jX3BhZ2VzX2FycmF5KHhlbl9vYmosIHNpemUpOworCWlmIChyZXQgPCAwKQorCQly ZXR1cm4gRVJSX1BUUihyZXQpOworCisJeGVuX29iai0+c2d0X2ltcG9ydGVkID0gc2d0OworCisJ cmV0ID0gZHJtX3ByaW1lX3NnX3RvX3BhZ2VfYWRkcl9hcnJheXMoc2d0LCB4ZW5fb2JqLT5wYWdl cywKKwkJCU5VTEwsIHhlbl9vYmotPm51bV9wYWdlcyk7CisJaWYgKHJldCA8IDApCisJCXJldHVy biBFUlJfUFRSKHJldCk7CisKKwkvKgorCSAqIE4uQi4gQWx0aG91Z2ggd2UgaGF2ZSBhbiBBUEkg dG8gY3JlYXRlIGRpc3BsYXkgYnVmZmVyIGZyb20gc2d0CisJICogd2UgdXNlIHBhZ2VzIEFQSSwg YmVjYXVzZSB3ZSBzdGlsbCBuZWVkIHRob3NlIGZvciBHRU0gaGFuZGxpbmcsCisJICogZS5nLiBm b3IgbWFwcGluZyBldGMuCisJICovCisJcmV0ID0geGVuX2RybV9mcm9udF9kYnVmX2NyZWF0ZV9m cm9tX3BhZ2VzKGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJeGVuX2RybV9mcm9udF9kYnVmX3Rv X2Nvb2tpZSgmeGVuX29iai0+YmFzZSksCisJCQkwLCAwLCAwLCBzaXplLCB4ZW5fb2JqLT5wYWdl cyk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwlEUk1fREVCVUco IkltcG9ydGVkIGJ1ZmZlciBvZiBzaXplICV6dSB3aXRoIG5lbnRzICV1XG4iLAorCQlzaXplLCBz Z3QtPm5lbnRzKTsKKworCXJldHVybiAmeGVuX29iai0+YmFzZTsKK30KKworc3RhdGljIGludCBn ZW1fbW1hcF9vYmooc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqLAorCQlzdHJ1Y3Qgdm1f YXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwl1bnNpZ25lZCBsb25nIGFkZHIgPSB2bWEtPnZtX3N0YXJ0 OworCWludCBpOworCisJLyoKKwkgKiBjbGVhciB0aGUgVk1fUEZOTUFQIGZsYWcgdGhhdCB3YXMg c2V0IGJ5IGRybV9nZW1fbW1hcCgpLCBhbmQgc2V0IHRoZQorCSAqIHZtX3Bnb2ZmICh1c2VkIGFz IGEgZmFrZSBidWZmZXIgb2Zmc2V0IGJ5IERSTSkgdG8gMCBhcyB3ZSB3YW50IHRvIG1hcAorCSAq IHRoZSB3aG9sZSBidWZmZXIuCisJICovCisJdm1hLT52bV9mbGFncyAmPSB+Vk1fUEZOTUFQOwor CXZtYS0+dm1fZmxhZ3MgfD0gVk1fTUlYRURNQVA7CisJdm1hLT52bV9wZ29mZiA9IDA7CisJdm1h LT52bV9wYWdlX3Byb3QgPSBwZ3Byb3Rfd3JpdGVjb21iaW5lKHZtX2dldF9wYWdlX3Byb3Qodm1h LT52bV9mbGFncykpOworCisJLyoKKwkgKiB2bV9vcGVyYXRpb25zX3N0cnVjdC5mYXVsdCBoYW5k bGVyIHdpbGwgYmUgY2FsbGVkIGlmIENQVSBhY2Nlc3MKKwkgKiB0byBWTSBpcyBoZXJlLiBGb3Ig R1BVcyB0aGlzIGlzbid0IHRoZSBjYXNlLCBiZWNhdXNlIENQVQorCSAqIGRvZXNuJ3QgdG91Y2gg dGhlIG1lbW9yeS4gSW5zZXJ0IHBhZ2VzIG5vdywgc28gYm90aCBDUFUgYW5kIEdQVSBhcmUKKwkg KiBoYXBweS4KKwkgKiBGSVhNRTogYXMgd2UgaW5zZXJ0IGFsbCB0aGUgcGFnZXMgbm93IHRoZW4g bm8gLmZhdWx0IGhhbmRsZXIgbXVzdAorCSAqIGJlIGNhbGxlZCwgc28gZG9uJ3QgcHJvdmlkZSBv bmUKKwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgeGVuX29iai0+bnVtX3BhZ2VzOyBpKyspIHsKKwkJ aW50IHJldDsKKworCQlyZXQgPSB2bV9pbnNlcnRfcGFnZSh2bWEsIGFkZHIsIHhlbl9vYmotPnBh Z2VzW2ldKTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURSTV9FUlJPUigiRmFpbGVkIHRvIGluc2Vy dCBwYWdlcyBpbnRvIHZtYTogJWRcbiIsIHJldCk7CisJCQlyZXR1cm4gcmV0OworCQl9CisKKwkJ YWRkciArPSBQQUdFX1NJWkU7CisJfQorCXJldHVybiAwOworfQorCitpbnQgeGVuX2RybV9mcm9u dF9nZW1fbW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEp Cit7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOworCXN0cnVjdCBkcm1fZ2VtX29i amVjdCAqZ2VtX29iajsKKwlpbnQgcmV0OworCisJcmV0ID0gZHJtX2dlbV9tbWFwKGZpbHAsIHZt YSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlnZW1fb2JqID0gdm1hLT52bV9w cml2YXRlX2RhdGE7CisJeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCXJldHVy biBnZW1fbW1hcF9vYmooeGVuX29iaiwgdm1hKTsKK30KKwordm9pZCAqeGVuX2RybV9mcm9udF9n ZW1fcHJpbWVfdm1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJc3RydWN0 IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7CisKKwlp ZiAoIXhlbl9vYmotPnBhZ2VzKQorCQlyZXR1cm4gTlVMTDsKKworCXJldHVybiB2bWFwKHhlbl9v YmotPnBhZ2VzLCB4ZW5fb2JqLT5udW1fcGFnZXMsCisJCQlWTV9NQVAsIHBncHJvdF93cml0ZWNv bWJpbmUoUEFHRV9LRVJORUwpKTsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X2dlbV9wcmltZV92 dW5tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqLAorCQl2b2lkICp2YWRkcikKK3sK Kwl2dW5tYXAodmFkZHIpOworfQorCitpbnQgeGVuX2RybV9mcm9udF9nZW1fcHJpbWVfbW1hcChz dHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosCisJCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAq dm1hKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsKKwlpbnQgcmV0OworCisJ cmV0ID0gZHJtX2dlbV9tbWFwX29iaihnZW1fb2JqLCBnZW1fb2JqLT5zaXplLCB2bWEpOworCWlm IChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdl bV9vYmopOworCXJldHVybiBnZW1fbW1hcF9vYmooeGVuX29iaiwgdm1hKTsKK30KZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaCBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLmE5NDEzMGExZDczZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uaApAQCAtMCwwICsxLDQxIEBACisvKiBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoKKyAqICBYZW4gcGFyYS12 aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5 c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtz YW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYgX19YRU5fRFJNX0ZS T05UX0dFTV9ICisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9HRU1fSAorCisjaW5jbHVkZSA8ZHJt L2RybVAuaD4KKworc3RydWN0IGRybV9nZW1fb2JqZWN0ICp4ZW5fZHJtX2Zyb250X2dlbV9jcmVh dGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJc2l6ZV90IHNpemUpOworCitzdHJ1Y3QgZHJt X2dlbV9vYmplY3QgKnhlbl9kcm1fZnJvbnRfZ2VtX2ltcG9ydF9zZ190YWJsZShzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LAorCQlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsIHN0cnVj dCBzZ190YWJsZSAqc2d0KTsKKworc3RydWN0IHNnX3RhYmxlICp4ZW5fZHJtX2Zyb250X2dlbV9n ZXRfc2dfdGFibGUoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKTsKKworc3RydWN0IHBh Z2UgKip4ZW5fZHJtX2Zyb250X2dlbV9nZXRfcGFnZXMoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpv YmopOworCit2b2lkIHhlbl9kcm1fZnJvbnRfZ2VtX2ZyZWVfb2JqZWN0X3VubG9ja2VkKHN0cnVj dCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaik7CisKKyNpZm5kZWYgQ09ORklHX0RSTV9YRU5fRlJP TlRFTkRfQ01BCisKK2ludCB4ZW5fZHJtX2Zyb250X2dlbV9tbWFwKHN0cnVjdCBmaWxlICpmaWxw LCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisKK3ZvaWQgKnhlbl9kcm1fZnJvbnRfZ2Vt X3ByaW1lX3ZtYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKTsKKwordm9pZCB4ZW5f ZHJtX2Zyb250X2dlbV9wcmltZV92dW5tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2Jq LAorCQl2b2lkICp2YWRkcik7CisKK2ludCB4ZW5fZHJtX2Zyb250X2dlbV9wcmltZV9tbWFwKHN0 cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaiwKKwkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2 bWEpOworI2VuZGlmCisKKyNlbmRpZiAvKiBfX1hFTl9EUk1fRlJPTlRfR0VNX0ggKi8KZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW1fY21hLmMgYi9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtX2NtYS5jCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZTBjYTFlMTEzZGY5Ci0tLSAvZGV2L251bGwKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYwpAQCAtMCwwICsxLDc4 IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQKKworLyoKKyAq ICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYt MjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hj aGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpbmNsdWRl IDxkcm0vZHJtUC5oPgorI2luY2x1ZGUgPGRybS9kcm1fZ2VtLmg+CisjaW5jbHVkZSA8ZHJtL2Ry bV9mYl9jbWFfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hlbHBlci5oPgor CisjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfZ2Vt LmgiCisKK3N0cnVjdCBkcm1fZ2VtX29iamVjdCAqeGVuX2RybV9mcm9udF9nZW1faW1wb3J0X3Nn X3RhYmxlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1l bnQgKmF0dGFjaCwgc3RydWN0IHNnX3RhYmxlICpzZ3QpCit7CisJc3RydWN0IHhlbl9kcm1fZnJv bnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgZHJtX2dl bV9vYmplY3QgKmdlbV9vYmo7CisJc3RydWN0IGRybV9nZW1fY21hX29iamVjdCAqY21hX29iajsK KwlpbnQgcmV0OworCisJZ2VtX29iaiA9IGRybV9nZW1fY21hX3ByaW1lX2ltcG9ydF9zZ190YWJs ZShkZXYsIGF0dGFjaCwgc2d0KTsKKwlpZiAoSVNfRVJSX09SX05VTEwoZ2VtX29iaikpCisJCXJl dHVybiBnZW1fb2JqOworCisJY21hX29iaiA9IHRvX2RybV9nZW1fY21hX29iaihnZW1fb2JqKTsK KworCXJldCA9IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9zZ3QoCisJCQlkcm1faW5m by0+ZnJvbnRfaW5mbywKKwkJCXhlbl9kcm1fZnJvbnRfZGJ1Zl90b19jb29raWUoZ2VtX29iaiks CisJCQkwLCAwLCAwLCBnZW1fb2JqLT5zaXplLAorCQkJZHJtX2dlbV9jbWFfcHJpbWVfZ2V0X3Nn X3RhYmxlKGdlbV9vYmopKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsK KworCURSTV9ERUJVRygiSW1wb3J0ZWQgQ01BIGJ1ZmZlciBvZiBzaXplICV6dVxuIiwgZ2VtX29i ai0+c2l6ZSk7CisKKwlyZXR1cm4gZ2VtX29iajsKK30KKworc3RydWN0IHNnX3RhYmxlICp4ZW5f ZHJtX2Zyb250X2dlbV9nZXRfc2dfdGFibGUoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2Jq KQoreworCXJldHVybiBkcm1fZ2VtX2NtYV9wcmltZV9nZXRfc2dfdGFibGUoZ2VtX29iaik7Cit9 CisKK3N0cnVjdCBkcm1fZ2VtX29iamVjdCAqeGVuX2RybV9mcm9udF9nZW1fY3JlYXRlKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsCisJCXNpemVfdCBzaXplKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2RybV9pbmZvICpkcm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IGRybV9n ZW1fY21hX29iamVjdCAqY21hX29iajsKKworCWlmIChkcm1faW5mby0+ZnJvbnRfaW5mby0+Y2Zn LmJlX2FsbG9jKSB7CisJCS8qIFRoaXMgdXNlLWNhc2UgaXMgbm90IHlldCBzdXBwb3J0ZWQgYW5k IHByb2JhYmx5IHdvbid0IGJlICovCisJCURSTV9FUlJPUigiQmFja2VuZCBhbGxvY2F0ZWQgYnVm ZmVycyBhbmQgQ01BIGhlbHBlcnMgYXJlIG5vdCBzdXBwb3J0ZWQgYXQgdGhlIHNhbWUgdGltZVxu Iik7CisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKworCWNtYV9vYmogPSBkcm1fZ2Vt X2NtYV9jcmVhdGUoZGV2LCBzaXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoY21hX29iaikpCisJ CXJldHVybiBFUlJfQ0FTVChjbWFfb2JqKTsKKworCXJldHVybiAmY21hX29iai0+YmFzZTsKK30K Kwordm9pZCB4ZW5fZHJtX2Zyb250X2dlbV9mcmVlX29iamVjdF91bmxvY2tlZChzdHJ1Y3QgZHJt X2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJZHJtX2dlbV9jbWFfZnJlZV9vYmplY3QoZ2VtX29i aik7Cit9CisKK3N0cnVjdCBwYWdlICoqeGVuX2RybV9mcm9udF9nZW1fZ2V0X3BhZ2VzKHN0cnVj dCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlyZXR1cm4gTlVMTDsKK30KZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYyBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLmYzZWY5ZGZiNGRmYgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYwpAQCAtMCwwICsxLDM3MiBAQAorLy8gU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmly dHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0 ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2Fu ZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSAieGVuX2RybV9mcm9u dF9rbXMuaCIKKworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9hdG9t aWMuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0v ZHJtX2NydGNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KKyNpbmNsdWRlIDxk cm0vZHJtX2dlbV9mcmFtZWJ1ZmZlcl9oZWxwZXIuaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJv bnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2Nvbm4uaCIKKworLyoKKyAqIFRpbWVvdXQg aW4gbXMgdG8gd2FpdCBmb3IgZnJhbWUgZG9uZSBldmVudCBmcm9tIHRoZSBiYWNrZW5kOgorICog bXVzdCBiZSBhIGJpdCBtb3JlIHRoYW4gSU8gdGltZS1vdXQKKyAqLworI2RlZmluZSBGUkFNRV9E T05FX1RPX01TCShYRU5fRFJNX0ZST05UX1dBSVRfQkFDS19NUyArIDEwMCkKKworc3RhdGljIHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqCit0b194ZW5fZHJtX3BpcGVsaW5lKHN0 cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSkKK3sKKwlyZXR1cm4gY29udGFpbmVy X29mKHBpcGUsIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSwgcGlwZSk7Cit9CisK K3N0YXRpYyB2b2lkIGZiX2Rlc3Ryb3koc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIpCit7CisJ c3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZmItPmRldi0+ZGV2X3By aXZhdGU7CisJaW50IGlkeDsKKworCWlmIChkcm1fZGV2X2VudGVyKGZiLT5kZXYsICZpZHgpKSB7 CisJCXhlbl9kcm1fZnJvbnRfZmJfZGV0YWNoKGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJCXhl bl9kcm1fZnJvbnRfZmJfdG9fY29va2llKGZiKSk7CisJCWRybV9kZXZfZXhpdChpZHgpOworCX0K Kwlkcm1fZ2VtX2ZiX2Rlc3Ryb3koZmIpOworfQorCitzdGF0aWMgc3RydWN0IGRybV9mcmFtZWJ1 ZmZlcl9mdW5jcyBmYl9mdW5jcyA9IHsKKwkuZGVzdHJveSA9IGZiX2Rlc3Ryb3ksCit9OworCitz dGF0aWMgc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmJfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsCisJCXN0cnVjdCBkcm1fZmlsZSAqZmlscCwgY29uc3Qgc3RydWN0IGRybV9tb2RlX2Zi X2NtZDIgKm1vZGVfY21kKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1f aW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RhdGljIHN0cnVjdCBkcm1fZnJhbWVidWZmZXIg KmZiOworCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iajsKKwlpbnQgcmV0OworCisJZmIg PSBkcm1fZ2VtX2ZiX2NyZWF0ZV93aXRoX2Z1bmNzKGRldiwgZmlscCwgbW9kZV9jbWQsICZmYl9m dW5jcyk7CisJaWYgKElTX0VSUl9PUl9OVUxMKGZiKSkKKwkJcmV0dXJuIGZiOworCisJZ2VtX29i aiA9IGRybV9nZW1fb2JqZWN0X2xvb2t1cChmaWxwLCBtb2RlX2NtZC0+aGFuZGxlc1swXSk7CisJ aWYgKCFnZW1fb2JqKSB7CisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGxvb2t1cCBHRU0gb2JqZWN0 XG4iKTsKKwkJcmV0ID0gLUVOT0VOVDsKKwkJZ290byBmYWlsOworCX0KKworCWRybV9nZW1fb2Jq ZWN0X3B1dF91bmxvY2tlZChnZW1fb2JqKTsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfZmJfYXR0 YWNoKAorCQkJZHJtX2luZm8tPmZyb250X2luZm8sCisJCQl4ZW5fZHJtX2Zyb250X2RidWZfdG9f Y29va2llKGdlbV9vYmopLAorCQkJeGVuX2RybV9mcm9udF9mYl90b19jb29raWUoZmIpLAorCQkJ ZmItPndpZHRoLCBmYi0+aGVpZ2h0LCBmYi0+Zm9ybWF0LT5mb3JtYXQpOworCWlmIChyZXQgPCAw KSB7CisJCURSTV9FUlJPUigiQmFjayBmYWlsZWQgdG8gYXR0YWNoIEZCICVwOiAlZFxuIiwgZmIs IHJldCk7CisJCWdvdG8gZmFpbDsKKwl9CisKKwlyZXR1cm4gZmI7CisKK2ZhaWw6CisJZHJtX2dl bV9mYl9kZXN0cm95KGZiKTsKKwlyZXR1cm4gRVJSX1BUUihyZXQpOworfQorCitzdGF0aWMgY29u c3Qgc3RydWN0IGRybV9tb2RlX2NvbmZpZ19mdW5jcyBtb2RlX2NvbmZpZ19mdW5jcyA9IHsKKwku ZmJfY3JlYXRlID0gZmJfY3JlYXRlLAorCS5hdG9taWNfY2hlY2sgPSBkcm1fYXRvbWljX2hlbHBl cl9jaGVjaywKKwkuYXRvbWljX2NvbW1pdCA9IGRybV9hdG9taWNfaGVscGVyX2NvbW1pdCwKK307 CisKK3N0YXRpYyB2b2lkIHNlbmRfcGVuZGluZ19ldmVudChzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgKnBpcGVsaW5lKQoreworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9ICZwaXBl bGluZS0+cGlwZS5jcnRjOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjcnRjLT5kZXY7CisJ dW5zaWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPmV2ZW50X2xv Y2ssIGZsYWdzKTsKKwlpZiAocGlwZWxpbmUtPnBlbmRpbmdfZXZlbnQpCisJCWRybV9jcnRjX3Nl bmRfdmJsYW5rX2V2ZW50KGNydGMsIHBpcGVsaW5lLT5wZW5kaW5nX2V2ZW50KTsKKwlwaXBlbGlu ZS0+cGVuZGluZ19ldmVudCA9IE5VTEw7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGV2LT5l dmVudF9sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyB2b2lkIGRpc3BsYXlfZW5hYmxlKHN0cnVj dCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKKwkJc3RydWN0IGRybV9jcnRjX3N0YXRl ICpjcnRjX3N0YXRlLAorCQlzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSkKK3sK KwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hl bl9kcm1fcGlwZWxpbmUocGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpjcnRjID0gJnBpcGUtPmNy dGM7CisJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwbGFuZV9zdGF0ZS0+ZmI7CisJaW50 IHJldCwgaWR4OworCisJaWYgKCFkcm1fZGV2X2VudGVyKHBpcGUtPmNydGMuZGV2LCAmaWR4KSkK KwkJcmV0dXJuOworCisJcmV0ID0geGVuX2RybV9mcm9udF9tb2RlX3NldChwaXBlbGluZSwKKwkJ CWNydGMtPngsIGNydGMtPnksIGZiLT53aWR0aCwgZmItPmhlaWdodCwKKwkJCWZiLT5mb3JtYXQt PmNwcFswXSAqIDgsCisJCQl4ZW5fZHJtX2Zyb250X2ZiX3RvX2Nvb2tpZShmYikpOworCisJaWYg KHJldCkgeworCQlEUk1fRVJST1IoIkZhaWxlZCB0byBlbmFibGUgZGlzcGxheTogJWRcbiIsIHJl dCk7CisJCXBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA9IGZhbHNlOworCX0KKworCWRybV9kZXZf ZXhpdChpZHgpOworfQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X2Rpc2FibGUoc3RydWN0IGRybV9z aW1wbGVfZGlzcGxheV9waXBlICpwaXBlKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9w aXBlbGluZSAqcGlwZWxpbmUgPQorCQkJdG9feGVuX2RybV9waXBlbGluZShwaXBlKTsKKwlpbnQg cmV0ID0gMCwgaWR4OworCisJaWYgKGRybV9kZXZfZW50ZXIocGlwZS0+Y3J0Yy5kZXYsICZpZHgp KSB7CisJCXJldCA9IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQocGlwZWxpbmUsIDAsIDAsIDAsIDAs IDAsCisJCQkJeGVuX2RybV9mcm9udF9mYl90b19jb29raWUoTlVMTCkpOworCQlkcm1fZGV2X2V4 aXQoaWR4KTsKKwl9CisJaWYgKHJldCkKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gZGlzYWJsZSBk aXNwbGF5OiAlZFxuIiwgcmV0KTsKKworCS8qIE1ha2Ugc3VyZSB3ZSBjYW4gcmVzdGFydCB3aXRo IGVuYWJsZWQgY29ubmVjdG9yIG5leHQgdGltZSAqLworCXBpcGVsaW5lLT5jb25uX2Nvbm5lY3Rl ZCA9IHRydWU7CisKKwkvKiByZWxlYXNlIHN0YWxsZWQgZXZlbnQgaWYgYW55ICovCisJc2VuZF9w ZW5kaW5nX2V2ZW50KHBpcGVsaW5lKTsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X2ttc19vbl9m cmFtZV9kb25lKAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5l LAorCQl1aW50NjRfdCBmYl9jb29raWUpCit7CisJLyoKKwkgKiBUaGlzIHJ1bnMgaW4gaW50ZXJy dXB0IGNvbnRleHQsIGUuZy4gdW5kZXIKKwkgKiBkcm1faW5mby0+ZnJvbnRfaW5mby0+aW9fbG9j aywgc28gd2UgY2Fubm90IGNhbGwgX3N5bmMgdmVyc2lvbgorCSAqIHRvIGNhbmNlbCB0aGUgd29y aworCSAqLworCWNhbmNlbF9kZWxheWVkX3dvcmsoJnBpcGVsaW5lLT5wZmxpcF90b193b3JrZXIp OworCisJc2VuZF9wZW5kaW5nX2V2ZW50KHBpcGVsaW5lKTsKK30KKworc3RhdGljIHZvaWQgcGZs aXBfdG9fd29ya2VyKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3sKKwlzdHJ1Y3QgZGVsYXll ZF93b3JrICpkZWxheWVkX3dvcmsgPSB0b19kZWxheWVkX3dvcmsod29yayk7CisJc3RydWN0IHhl bl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQljb250YWluZXJfb2YoZGVs YXllZF93b3JrLAorCQkJCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUsCisJCQkJ CXBmbGlwX3RvX3dvcmtlcik7CisKKwlEUk1fRVJST1IoIkZyYW1lIGRvbmUgdGltZWQtb3V0LCBy ZWxlYXNpbmciKTsKKwlzZW5kX3BlbmRpbmdfZXZlbnQocGlwZWxpbmUpOworfQorCitzdGF0aWMg Ym9vbCBkaXNwbGF5X3NlbmRfcGFnZV9mbGlwKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlw ZSAqcGlwZSwKKwkJc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqb2xkX3BsYW5lX3N0YXRlKQorewor CXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlID0gZHJtX2F0b21pY19nZXRfbmV3 X3BsYW5lX3N0YXRlKAorCQkJb2xkX3BsYW5lX3N0YXRlLT5zdGF0ZSwgJnBpcGUtPnBsYW5lKTsK KworCS8qCisJICogSWYgb2xkX3BsYW5lX3N0YXRlLT5mYiBpcyBOVUxMIGFuZCBwbGFuZV9zdGF0 ZS0+ZmIgaXMgbm90LAorCSAqIHRoZW4gdGhpcyBpcyBhbiBhdG9taWMgY29tbWl0IHdoaWNoIHdp bGwgZW5hYmxlIGRpc3BsYXkuCisJICogSWYgb2xkX3BsYW5lX3N0YXRlLT5mYiBpcyBub3QgTlVM TCBhbmQgcGxhbmVfc3RhdGUtPmZiIGlzLAorCSAqIHRoZW4gdGhpcyBpcyBhbiBhdG9taWMgY29t bWl0IHdoaWNoIHdpbGwgZGlzYWJsZSBkaXNwbGF5LgorCSAqIElnbm9yZSB0aGVzZSBhbmQgZG8g bm90IHNlbmQgcGFnZSBmbGlwIGFzIHRoaXMgZnJhbWVidWZmZXIgd2lsbCBiZQorCSAqIHNlbnQg dG8gdGhlIGJhY2tlbmQgYXMgYSBwYXJ0IG9mIGRpc3BsYXlfc2V0X2NvbmZpZyBjYWxsLgorCSAq LworCWlmIChvbGRfcGxhbmVfc3RhdGUtPmZiICYmIHBsYW5lX3N0YXRlLT5mYikgeworCQlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCQl0b194ZW5fZHJt X3BpcGVsaW5lKHBpcGUpOworCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2lu Zm8gPSBwaXBlbGluZS0+ZHJtX2luZm87CisJCWludCByZXQ7CisKKwkJc2NoZWR1bGVfZGVsYXll ZF93b3JrKCZwaXBlbGluZS0+cGZsaXBfdG9fd29ya2VyLAorCQkJCW1zZWNzX3RvX2ppZmZpZXMo RlJBTUVfRE9ORV9UT19NUykpOworCisJCXJldCA9IHhlbl9kcm1fZnJvbnRfcGFnZV9mbGlwKGRy bV9pbmZvLT5mcm9udF9pbmZvLAorCQkJCXBpcGVsaW5lLT5pbmRleCwKKwkJCQl4ZW5fZHJtX2Zy b250X2ZiX3RvX2Nvb2tpZShwbGFuZV9zdGF0ZS0+ZmIpKTsKKwkJaWYgKHJldCkgeworCQkJRFJN X0VSUk9SKCJGYWlsZWQgdG8gc2VuZCBwYWdlIGZsaXAgcmVxdWVzdCB0byBiYWNrZW5kOiAlZFxu IiwgcmV0KTsKKworCQkJcGlwZWxpbmUtPmNvbm5fY29ubmVjdGVkID0gZmFsc2U7CisJCQkvKgor CQkJICogUmVwb3J0IHRoZSBmbGlwIG5vdCBoYW5kbGVkLCBzbyBwZW5kaW5nIGV2ZW50IGlzCisJ CQkgKiBzZW50LCB1bmJsb2NraW5nIHVzZXItc3BhY2UuCisJCQkgKi8KKwkJCXJldHVybiBmYWxz ZTsKKwkJfQorCQkvKgorCQkgKiBTaWduYWwgdGhhdCBwYWdlIGZsaXAgd2FzIGhhbmRsZWQsIHBl bmRpbmcgZXZlbnQgd2lsbCBiZSBzZW50CisJCSAqIG9uIGZyYW1lIGRvbmUgZXZlbnQgZnJvbSB0 aGUgYmFja2VuZC4KKwkJICovCisJCXJldHVybiB0cnVlOworCX0KKworCXJldHVybiBmYWxzZTsK K30KKworc3RhdGljIGludCBkaXNwbGF5X3ByZXBhcmVfZmIoc3RydWN0IGRybV9zaW1wbGVfZGlz cGxheV9waXBlICpwaXBlLAorCQlzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSkK K3sKKwlyZXR1cm4gZHJtX2dlbV9mYl9wcmVwYXJlX2ZiKCZwaXBlLT5wbGFuZSwgcGxhbmVfc3Rh dGUpOworfQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X3VwZGF0ZShzdHJ1Y3QgZHJtX3NpbXBsZV9k aXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9wbGFuZV9z dGF0ZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0K KwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUocGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpjcnRjID0g JnBpcGUtPmNydGM7CisJc3RydWN0IGRybV9wZW5kaW5nX3ZibGFua19ldmVudCAqZXZlbnQ7CisJ aW50IGlkeDsKKworCWV2ZW50ID0gY3J0Yy0+c3RhdGUtPmV2ZW50OworCWlmIChldmVudCkgewor CQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ZGV2OworCQl1bnNpZ25lZCBsb25nIGZs YWdzOworCisJCVdBUk5fT04ocGlwZWxpbmUtPnBlbmRpbmdfZXZlbnQpOworCisJCXNwaW5fbG9j a19pcnFzYXZlKCZkZXYtPmV2ZW50X2xvY2ssIGZsYWdzKTsKKwkJY3J0Yy0+c3RhdGUtPmV2ZW50 ID0gTlVMTDsKKworCQlwaXBlbGluZS0+cGVuZGluZ19ldmVudCA9IGV2ZW50OworCQlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZkZXYtPmV2ZW50X2xvY2ssIGZsYWdzKTsKKworCX0KKworCWlmICgh ZHJtX2Rldl9lbnRlcihwaXBlLT5jcnRjLmRldiwgJmlkeCkpIHsKKwkJc2VuZF9wZW5kaW5nX2V2 ZW50KHBpcGVsaW5lKTsKKwkJcmV0dXJuOworCX0KKworCS8qCisJICogU2VuZCBwYWdlIGZsaXAg cmVxdWVzdCB0byB0aGUgYmFja2VuZCAqYWZ0ZXIqIHdlIGhhdmUgZXZlbnQgY2FjaGVkCisJICog YWJvdmUsIHNvIG9uIHBhZ2UgZmxpcCBkb25lIGV2ZW50IGZyb20gdGhlIGJhY2tlbmQgd2UgY2Fu CisJICogZGVsaXZlciBpdCBhbmQgdGhlcmUgaXMgbm8gcmFjZSBjb25kaXRpb24gYmV0d2VlbiB0 aGlzIGNvZGUgYW5kCisJICogZXZlbnQgZnJvbSB0aGUgYmFja2VuZC4KKwkgKiBJZiB0aGlzIGlz IG5vdCBhIHBhZ2UgZmxpcCwgZS5nLiBubyBmbGlwIGRvbmUgZXZlbnQgZnJvbSB0aGUgYmFja2Vu ZAorCSAqIGlzIGV4cGVjdGVkLCB0aGVuIHNlbmQgbm93LgorCSAqLworCWlmICghZGlzcGxheV9z ZW5kX3BhZ2VfZmxpcChwaXBlLCBvbGRfcGxhbmVfc3RhdGUpKQorCQlzZW5kX3BlbmRpbmdfZXZl bnQocGlwZWxpbmUpOworCisJZHJtX2Rldl9leGl0KGlkeCk7Cit9CisKK3N0YXRpYyBlbnVtIGRy bV9tb2RlX3N0YXR1cyBkaXNwbGF5X21vZGVfdmFsaWQoc3RydWN0IGRybV9jcnRjICpjcnRjLAor CQljb25zdCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSkKK3sKKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCWNvbnRhaW5lcl9vZihjcnRjLAor CQkJCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUsCisJCQkJCXBpcGUuY3J0Yyk7 CisKKwlpZiAobW9kZS0+aGRpc3BsYXkgIT0gcGlwZWxpbmUtPndpZHRoKQorCQlyZXR1cm4gTU9E RV9FUlJPUjsKKworCWlmIChtb2RlLT52ZGlzcGxheSAhPSBwaXBlbGluZS0+aGVpZ2h0KQorCQly ZXR1cm4gTU9ERV9FUlJPUjsKKworCXJldHVybiBNT0RFX09LOworfQorCitzdGF0aWMgY29uc3Qg c3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2Z1bmNzIGRpc3BsYXlfZnVuY3MgPSB7CisJ Lm1vZGVfdmFsaWQgPSBkaXNwbGF5X21vZGVfdmFsaWQsCisJLmVuYWJsZSA9IGRpc3BsYXlfZW5h YmxlLAorCS5kaXNhYmxlID0gZGlzcGxheV9kaXNhYmxlLAorCS5wcmVwYXJlX2ZiID0gZGlzcGxh eV9wcmVwYXJlX2ZiLAorCS51cGRhdGUgPSBkaXNwbGF5X3VwZGF0ZSwKK307CisKK3N0YXRpYyBp bnQgZGlzcGxheV9waXBlX2luaXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9p bmZvLAorCQlpbnQgaW5kZXgsIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZ19jb25uZWN0b3IgKmNm ZywKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSkKK3sKKwlz dHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZHJtX2luZm8tPmRybV9kZXY7CisJY29uc3QgdWludDMy X3QgKmZvcm1hdHM7CisJaW50IGZvcm1hdF9jb3VudDsKKwlpbnQgcmV0OworCisJcGlwZWxpbmUt PmRybV9pbmZvID0gZHJtX2luZm87CisJcGlwZWxpbmUtPmluZGV4ID0gaW5kZXg7CisJcGlwZWxp bmUtPmhlaWdodCA9IGNmZy0+aGVpZ2h0OworCXBpcGVsaW5lLT53aWR0aCA9IGNmZy0+d2lkdGg7 CisKKwlJTklUX0RFTEFZRURfV09SSygmcGlwZWxpbmUtPnBmbGlwX3RvX3dvcmtlciwgcGZsaXBf dG9fd29ya2VyKTsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfY29ubl9pbml0KGRybV9pbmZvLCAm cGlwZWxpbmUtPmNvbm4pOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlmb3JtYXRzID0g eGVuX2RybV9mcm9udF9jb25uX2dldF9mb3JtYXRzKCZmb3JtYXRfY291bnQpOworCisJcmV0dXJu IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2luaXQoZGV2LCAmcGlwZWxpbmUtPnBpcGUsCisJCQkm ZGlzcGxheV9mdW5jcywgZm9ybWF0cywgZm9ybWF0X2NvdW50LAorCQkJTlVMTCwgJnBpcGVsaW5l LT5jb25uKTsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfa21zX2luaXQoc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvKQoreworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBk cm1faW5mby0+ZHJtX2RldjsKKwlpbnQgaSwgcmV0OworCisJZHJtX21vZGVfY29uZmlnX2luaXQo ZGV2KTsKKworCWRldi0+bW9kZV9jb25maWcubWluX3dpZHRoID0gMDsKKwlkZXYtPm1vZGVfY29u ZmlnLm1pbl9oZWlnaHQgPSAwOworCWRldi0+bW9kZV9jb25maWcubWF4X3dpZHRoID0gNDA5NTsK KwlkZXYtPm1vZGVfY29uZmlnLm1heF9oZWlnaHQgPSAyMDQ3OworCWRldi0+bW9kZV9jb25maWcu ZnVuY3MgPSAmbW9kZV9jb25maWdfZnVuY3M7CisKKwlmb3IgKGkgPSAwOyBpIDwgZHJtX2luZm8t PmZyb250X2luZm8tPmNmZy5udW1fY29ubmVjdG9yczsgaSsrKSB7CisJCXN0cnVjdCB4ZW5fZHJt X2Zyb250X2NmZ19jb25uZWN0b3IgKmNmZyA9CisJCQkJJmRybV9pbmZvLT5mcm9udF9pbmZvLT5j ZmcuY29ubmVjdG9yc1tpXTsKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpw aXBlbGluZSA9CisJCQkJJmRybV9pbmZvLT5waXBlbGluZVtpXTsKKworCQlyZXQgPSBkaXNwbGF5 X3BpcGVfaW5pdChkcm1faW5mbywgaSwgY2ZnLCBwaXBlbGluZSk7CisJCWlmIChyZXQpIHsKKwkJ CWRybV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRldik7CisJCQlyZXR1cm4gcmV0OworCQl9CisJfQor CisJZHJtX21vZGVfY29uZmlnX3Jlc2V0KGRldik7CisJZHJtX2ttc19oZWxwZXJfcG9sbF9pbml0 KGRldik7CisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9rbXNfZmluaShzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8pCit7CisJaW50IGk7CisKKwlmb3Ig KGkgPSAwOyBpIDwgZHJtX2luZm8tPmZyb250X2luZm8tPmNmZy5udW1fY29ubmVjdG9yczsgaSsr KSB7CisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxpbmUgPQorCQkJ CSZkcm1faW5mby0+cGlwZWxpbmVbaV07CisKKwkJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZw aXBlbGluZS0+cGZsaXBfdG9fd29ya2VyKTsKKworCQlzZW5kX3BlbmRpbmdfZXZlbnQocGlwZWxp bmUpOworCX0KK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9u dF9rbXMuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjFjM2E2NGMzNmRiYgotLS0gL2Rldi9u dWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuaApAQCAtMCww ICsxLDI3IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8K KworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQg KEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRy IEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisK KyNpZm5kZWYgX19YRU5fRFJNX0ZST05UX0tNU19IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRf S01TX0hfCisKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorCitzdHJ1Y3QgeGVuX2RybV9mcm9u dF9kcm1faW5mbzsKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZTsKKworaW50IHhl bl9kcm1fZnJvbnRfa21zX2luaXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9p bmZvKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X2ttc19maW5pKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X2RybV9pbmZvICpkcm1faW5mbyk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9rbXNfb25fZnJhbWVf ZG9uZSgKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSwKKwkJ dWludDY0X3QgZmJfY29va2llKTsKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9LTVNfSF8g Ki8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5j IGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmMKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4wZmRlMmQ4Zjc3MDYKLS0tIC9kZXYvbnVsbAor KysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuYwpAQCAtMCwwICsx LDQzMiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8q CisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAy MDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRy dXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5j bHVkZSA8ZHJtL2RybVAuaD4KKworI2lmIGRlZmluZWQoQ09ORklHX1g4NikKKyNpbmNsdWRlIDxk cm0vZHJtX2NhY2hlLmg+CisjZW5kaWYKKyNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgorI2luY2x1 ZGUgPGxpbnV4L21tLmg+CisKKyNpbmNsdWRlIDxhc20veGVuL2h5cGVydmlzb3IuaD4KKyNpbmNs dWRlIDx4ZW4vYmFsbG9vbi5oPgorI2luY2x1ZGUgPHhlbi94ZW4uaD4KKyNpbmNsdWRlIDx4ZW4v eGVuYnVzLmg+CisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9yaW5nLmg+CisjaW5jbHVkZSA8 eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250Lmgi CisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgorCitzdHJ1Y3QgeGVuX2RybV9mcm9u dF9zaGJ1Zl9vcHMgeworCS8qCisJICogQ2FsY3VsYXRlIG51bWJlciBvZiBncmVmcyByZXF1aXJl ZCB0byBoYW5kbGUgdGhpcyBidWZmZXIsCisJICogZS5nLiBpZiBncmVmcyBhcmUgcmVxdWlyZWQg Zm9yIHBhZ2UgZGlyZWN0b3J5IG9ubHkgb3IgdGhlIGJ1ZmZlcgorCSAqIHBhZ2VzIGFzIHdlbGwu CisJICovCisJdm9pZCAoKmNhbGNfbnVtX2dyZWZzKShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1 ZiAqYnVmKTsKKwkvKiBGaWxsIHBhZ2UgZGlyZWN0b3J5IGFjY29yZGluZyB0byBwYXJhLXZpcnR1 YWwgZGlzcGxheSBwcm90b2NvbC4gKi8KKwl2b2lkICgqZmlsbF9wYWdlX2Rpcikoc3RydWN0IHhl bl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisJLyogQ2xhaW0gZ3JhbnQgcmVmZXJlbmNlcyBmb3Ig dGhlIHBhZ2VzIG9mIHRoZSBidWZmZXIuICovCisJaW50ICgqZ3JhbnRfcmVmc19mb3JfYnVmZmVy KShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmLAorCQkJZ3JhbnRfcmVmX3QgKnByaXZf Z3JlZl9oZWFkLCBpbnQgZ3JlZl9pZHgpOworCS8qIE1hcCBncmFudCByZWZlcmVuY2VzIG9mIHRo ZSBidWZmZXIuICovCisJaW50ICgqbWFwKShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVm KTsKKwkvKiBVbm1hcCBncmFudCByZWZlcmVuY2VzIG9mIHRoZSBidWZmZXIuICovCisJaW50ICgq dW5tYXApKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworfTsKKworZ3JhbnRfcmVm X3QgeGVuX2RybV9mcm9udF9zaGJ1Zl9nZXRfZGlyX3N0YXJ0KHN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpidWYpCit7CisJaWYgKCFidWYtPmdyZWZzKQorCQlyZXR1cm4gR1JBTlRfSU5WQUxJ RF9SRUY7CisKKwlyZXR1cm4gYnVmLT5ncmVmc1swXTsKK30KKworaW50IHhlbl9kcm1fZnJvbnRf c2hidWZfbWFwKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+ b3BzLT5tYXApCisJCXJldHVybiBidWYtPm9wcy0+bWFwKGJ1Zik7CisKKwkvKiBubyBuZWVkIHRv IG1hcCBvd24gZ3JhbnQgcmVmZXJlbmNlcyAqLworCXJldHVybiAwOworfQorCitpbnQgeGVuX2Ry bV9mcm9udF9zaGJ1Zl91bm1hcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQorewor CWlmIChidWYtPm9wcy0+dW5tYXApCisJCXJldHVybiBidWYtPm9wcy0+dW5tYXAoYnVmKTsKKwor CS8qIG5vIG5lZWQgdG8gdW5tYXAgb3duIGdyYW50IHJlZmVyZW5jZXMgKi8KKwlyZXR1cm4gMDsK K30KKwordm9pZCB4ZW5fZHJtX2Zyb250X3NoYnVmX2ZsdXNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpidWYpCit7CisjaWYgZGVmaW5lZChDT05GSUdfWDg2KQorCWRybV9jbGZsdXNoX3Bh Z2VzKGJ1Zi0+cGFnZXMsIGJ1Zi0+bnVtX3BhZ2VzKTsKKyNlbmRpZgorfQorCit2b2lkIHhlbl9k cm1fZnJvbnRfc2hidWZfZnJlZShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQorewor CWlmIChidWYtPmdyZWZzKSB7CisJCWludCBpOworCisJCWZvciAoaSA9IDA7IGkgPCBidWYtPm51 bV9ncmVmczsgaSsrKQorCQkJaWYgKGJ1Zi0+Z3JlZnNbaV0gIT0gR1JBTlRfSU5WQUxJRF9SRUYp CisJCQkJZ250dGFiX2VuZF9mb3JlaWduX2FjY2VzcyhidWYtPmdyZWZzW2ldLAorCQkJCQkwLCAw VUwpOworCX0KKwlrZnJlZShidWYtPmdyZWZzKTsKKwlrZnJlZShidWYtPmRpcmVjdG9yeSk7CisJ aWYgKGJ1Zi0+c2d0KSB7CisJCXNnX2ZyZWVfdGFibGUoYnVmLT5zZ3QpOworCQlrdmZyZWUoYnVm LT5wYWdlcyk7CisJfQorCWtmcmVlKGJ1Zik7Cit9CisKKy8qCisgKiBudW1iZXIgb2YgZ3JlZnMg YSBwYWdlIGNhbiBob2xkIHdpdGggcmVzcGVjdCB0byB0aGUKKyAqIHN0cnVjdCB4ZW5kaXNwbF9w YWdlX2RpcmVjdG9yeSBoZWFkZXIKKyAqLworI2RlZmluZSBYRU5fRFJNX05VTV9HUkVGU19QRVJf UEFHRSAoKFBBR0VfU0laRSAtIFwKKwlvZmZzZXRvZihzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJl Y3RvcnksIGdyZWYpKSAvIFwKKwlzaXplb2YoZ3JhbnRfcmVmX3QpKQorCitzdGF0aWMgaW50IGdl dF9udW1fcGFnZXNfZGlyKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJLyog bnVtYmVyIG9mIHBhZ2VzIHRoZSBwYWdlIGRpcmVjdG9yeSBjb25zdW1lcyBpdHNlbGYgKi8KKwly ZXR1cm4gRElWX1JPVU5EX1VQKGJ1Zi0+bnVtX3BhZ2VzLCBYRU5fRFJNX05VTV9HUkVGU19QRVJf UEFHRSk7Cit9CisKK3N0YXRpYyB2b2lkIGJhY2tlbmRfY2FsY19udW1fZ3JlZnMoc3RydWN0IHhl bl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwkvKiBvbmx5IGZvciBwYWdlcyB0aGUgcGFnZSBk aXJlY3RvcnkgY29uc3VtZXMgaXRzZWxmICovCisJYnVmLT5udW1fZ3JlZnMgPSBnZXRfbnVtX3Bh Z2VzX2RpcihidWYpOworfQorCitzdGF0aWMgdm9pZCBndWVzdF9jYWxjX251bV9ncmVmcyhzdHJ1 Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCS8qCisJICogbnVtYmVyIG9mIHBhZ2Vz IHRoZSBwYWdlIGRpcmVjdG9yeSBjb25zdW1lcyBpdHNlbGYKKwkgKiBwbHVzIGdyZWZzIGZvciB0 aGUgYnVmZmVyIHBhZ2VzCisJICovCisJYnVmLT5udW1fZ3JlZnMgPSBnZXRfbnVtX3BhZ2VzX2Rp cihidWYpICsgYnVmLT5udW1fcGFnZXM7Cit9CisKKyNkZWZpbmUgeGVuX3BhZ2VfdG9fdmFkZHIo cGFnZSkgXAorCQkoKHBoeXNfYWRkcl90KXBmbl90b19rYWRkcihwYWdlX3RvX3hlbl9wZm4ocGFn ZSkpKQorCitzdGF0aWMgaW50IGJhY2tlbmRfdW5tYXAoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hi dWYgKmJ1ZikKK3sKKwlzdHJ1Y3QgZ250dGFiX3VubWFwX2dyYW50X3JlZiAqdW5tYXBfb3BzOwor CWludCBpLCByZXQ7CisKKwlpZiAoIWJ1Zi0+cGFnZXMgfHwgIWJ1Zi0+YmFja2VuZF9tYXBfaGFu ZGxlcyB8fCAhYnVmLT5ncmVmcykKKwkJcmV0dXJuIDA7CisKKwl1bm1hcF9vcHMgPSBrY2FsbG9j KGJ1Zi0+bnVtX3BhZ2VzLCBzaXplb2YoKnVubWFwX29wcyksCisJCUdGUF9LRVJORUwpOworCWlm ICghdW5tYXBfb3BzKSB7CisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGdldCBtZW1vcnkgd2hpbGUg dW5tYXBwaW5nXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJZm9yIChpID0gMDsgaSA8 IGJ1Zi0+bnVtX3BhZ2VzOyBpKyspIHsKKwkJcGh5c19hZGRyX3QgYWRkcjsKKworCQlhZGRyID0g eGVuX3BhZ2VfdG9fdmFkZHIoYnVmLT5wYWdlc1tpXSk7CisJCWdudHRhYl9zZXRfdW5tYXBfb3Ao JnVubWFwX29wc1tpXSwgYWRkciwgR05UTUFQX2hvc3RfbWFwLAorCQkJCWJ1Zi0+YmFja2VuZF9t YXBfaGFuZGxlc1tpXSk7CisJfQorCisJcmV0ID0gZ250dGFiX3VubWFwX3JlZnModW5tYXBfb3Bz LCBOVUxMLCBidWYtPnBhZ2VzLAorCQkJYnVmLT5udW1fcGFnZXMpOworCisJZm9yIChpID0gMDsg aSA8IGJ1Zi0+bnVtX3BhZ2VzOyBpKyspIHsKKwkJaWYgKHVubGlrZWx5KHVubWFwX29wc1tpXS5z dGF0dXMgIT0gR05UU1Rfb2theSkpCisJCQlEUk1fRVJST1IoIkZhaWxlZCB0byB1bm1hcCBwYWdl ICVkOiAlZFxuIiwKKwkJCQkJaSwgdW5tYXBfb3BzW2ldLnN0YXR1cyk7CisJfQorCisJaWYgKHJl dCkKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gdW5tYXAgZ3JhbnQgcmVmZXJlbmNlcywgcmV0ICVk IiwgcmV0KTsKKworCWtmcmVlKHVubWFwX29wcyk7CisJa2ZyZWUoYnVmLT5iYWNrZW5kX21hcF9o YW5kbGVzKTsKKwlidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMgPSBOVUxMOworCXJldHVybiByZXQ7 Cit9CisKK3N0YXRpYyBpbnQgYmFja2VuZF9tYXAoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYg KmJ1ZikKK3sKKwlzdHJ1Y3QgZ250dGFiX21hcF9ncmFudF9yZWYgKm1hcF9vcHMgPSBOVUxMOwor CXVuc2lnbmVkIGNoYXIgKnB0cjsKKwlpbnQgcmV0LCBjdXJfZ3JlZiwgY3VyX2Rpcl9wYWdlLCBj dXJfcGFnZSwgZ3JlZnNfbGVmdDsKKworCW1hcF9vcHMgPSBrY2FsbG9jKGJ1Zi0+bnVtX3BhZ2Vz LCBzaXplb2YoKm1hcF9vcHMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIW1hcF9vcHMpCisJCXJldHVy biAtRU5PTUVNOworCisJYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzID0ga2NhbGxvYyhidWYtPm51 bV9wYWdlcywKKwkJCXNpemVvZigqYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzKSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMpIHsKKwkJa2ZyZWUobWFwX29wcyk7 CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCS8qCisJICogcmVhZCBwYWdlIGRpcmVjdG9yeSB0 byBnZXQgZ3JlZnMgZnJvbSB0aGUgYmFja2VuZDogZm9yIGV4dGVybmFsCisJICogYnVmZmVyIHdl IG9ubHkgYWxsb2NhdGUgYnVmLT5ncmVmcyBmb3IgdGhlIHBhZ2UgZGlyZWN0b3J5LAorCSAqIHNv IGJ1Zi0+bnVtX2dyZWZzIGhhcyBudW1iZXIgb2YgcGFnZXMgaW4gdGhlIHBhZ2UgZGlyZWN0b3J5 IGl0c2VsZgorCSAqLworCXB0ciA9IGJ1Zi0+ZGlyZWN0b3J5OworCWdyZWZzX2xlZnQgPSBidWYt Pm51bV9wYWdlczsKKwljdXJfcGFnZSA9IDA7CisJZm9yIChjdXJfZGlyX3BhZ2UgPSAwOyBjdXJf ZGlyX3BhZ2UgPCBidWYtPm51bV9ncmVmczsgY3VyX2Rpcl9wYWdlKyspIHsKKwkJc3RydWN0IHhl bmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICpwYWdlX2RpciA9CisJCQkJKHN0cnVjdCB4ZW5kaXNwbF9w YWdlX2RpcmVjdG9yeSAqKXB0cjsKKwkJaW50IHRvX2NvcHkgPSBYRU5fRFJNX05VTV9HUkVGU19Q RVJfUEFHRTsKKworCQlpZiAodG9fY29weSA+IGdyZWZzX2xlZnQpCisJCQl0b19jb3B5ID0gZ3Jl ZnNfbGVmdDsKKworCQlmb3IgKGN1cl9ncmVmID0gMDsgY3VyX2dyZWYgPCB0b19jb3B5OyBjdXJf Z3JlZisrKSB7CisJCQlwaHlzX2FkZHJfdCBhZGRyOworCisJCQlhZGRyID0geGVuX3BhZ2VfdG9f dmFkZHIoYnVmLT5wYWdlc1tjdXJfcGFnZV0pOworCQkJZ250dGFiX3NldF9tYXBfb3AoJm1hcF9v cHNbY3VyX3BhZ2VdLCBhZGRyLAorCQkJCQlHTlRNQVBfaG9zdF9tYXAsCisJCQkJCXBhZ2VfZGly LT5ncmVmW2N1cl9ncmVmXSwKKwkJCQkJYnVmLT54Yl9kZXYtPm90aGVyZW5kX2lkKTsKKwkJCWN1 cl9wYWdlKys7CisJCX0KKworCQlncmVmc19sZWZ0IC09IHRvX2NvcHk7CisJCXB0ciArPSBQQUdF X1NJWkU7CisJfQorCXJldCA9IGdudHRhYl9tYXBfcmVmcyhtYXBfb3BzLCBOVUxMLCBidWYtPnBh Z2VzLCBidWYtPm51bV9wYWdlcyk7CisKKwkvKiBzYXZlIGhhbmRsZXMgZXZlbiBpZiBlcnJvciwg c28gd2UgY2FuIHVubWFwICovCisJZm9yIChjdXJfcGFnZSA9IDA7IGN1cl9wYWdlIDwgYnVmLT5u dW1fcGFnZXM7IGN1cl9wYWdlKyspIHsKKwkJYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzW2N1cl9w YWdlXSA9IG1hcF9vcHNbY3VyX3BhZ2VdLmhhbmRsZTsKKwkJaWYgKHVubGlrZWx5KG1hcF9vcHNb Y3VyX3BhZ2VdLnN0YXR1cyAhPSBHTlRTVF9va2F5KSkKKwkJCURSTV9FUlJPUigiRmFpbGVkIHRv IG1hcCBwYWdlICVkOiAlZFxuIiwKKwkJCQkJY3VyX3BhZ2UsIG1hcF9vcHNbY3VyX3BhZ2VdLnN0 YXR1cyk7CisJfQorCisJaWYgKHJldCkgeworCQlEUk1fRVJST1IoIkZhaWxlZCB0byBtYXAgZ3Jh bnQgcmVmZXJlbmNlcywgcmV0ICVkIiwgcmV0KTsKKwkJYmFja2VuZF91bm1hcChidWYpOworCX0K KworCWtmcmVlKG1hcF9vcHMpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGJhY2tl bmRfZmlsbF9wYWdlX2RpcihzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCXN0 cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqcGFnZV9kaXI7CisJdW5zaWduZWQgY2hhciAq cHRyOworCWludCBpLCBudW1fcGFnZXNfZGlyOworCisJcHRyID0gYnVmLT5kaXJlY3Rvcnk7CisJ bnVtX3BhZ2VzX2RpciA9IGdldF9udW1fcGFnZXNfZGlyKGJ1Zik7CisKKwkvKiBmaWxsIG9ubHkg Z3JlZnMgZm9yIHRoZSBwYWdlIGRpcmVjdG9yeSBpdHNlbGYgKi8KKwlmb3IgKGkgPSAwOyBpIDwg bnVtX3BhZ2VzX2RpciAtIDE7IGkrKykgeworCQlwYWdlX2RpciA9IChzdHJ1Y3QgeGVuZGlzcGxf cGFnZV9kaXJlY3RvcnkgKilwdHI7CisKKwkJcGFnZV9kaXItPmdyZWZfZGlyX25leHRfcGFnZSA9 IGJ1Zi0+Z3JlZnNbaSArIDFdOworCQlwdHIgKz0gUEFHRV9TSVpFOworCX0KKwkvKiBsYXN0IHBh Z2UgbXVzdCBzYXkgdGhlcmUgaXMgbm8gbW9yZSBwYWdlcyAqLworCXBhZ2VfZGlyID0gKHN0cnVj dCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqKXB0cjsKKwlwYWdlX2Rpci0+Z3JlZl9kaXJfbmV4 dF9wYWdlID0gR1JBTlRfSU5WQUxJRF9SRUY7Cit9CisKK3N0YXRpYyB2b2lkIGd1ZXN0X2ZpbGxf cGFnZV9kaXIoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwl1bnNpZ25lZCBj aGFyICpwdHI7CisJaW50IGN1cl9ncmVmLCBncmVmc19sZWZ0LCB0b19jb3B5LCBpLCBudW1fcGFn ZXNfZGlyOworCisJcHRyID0gYnVmLT5kaXJlY3Rvcnk7CisJbnVtX3BhZ2VzX2RpciA9IGdldF9u dW1fcGFnZXNfZGlyKGJ1Zik7CisKKwkvKgorCSAqIHdoaWxlIGNvcHlpbmcsIHNraXAgZ3JlZnMg YXQgc3RhcnQsIHRoZXkgYXJlIGZvciBwYWdlcworCSAqIGdyYW50ZWQgZm9yIHRoZSBwYWdlIGRp cmVjdG9yeSBpdHNlbGYKKwkgKi8KKwljdXJfZ3JlZiA9IG51bV9wYWdlc19kaXI7CisJZ3JlZnNf bGVmdCA9IGJ1Zi0+bnVtX3BhZ2VzOworCWZvciAoaSA9IDA7IGkgPCBudW1fcGFnZXNfZGlyOyBp KyspIHsKKwkJc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICpwYWdlX2RpciA9CisJCQkJ KHN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqKXB0cjsKKworCQlpZiAoZ3JlZnNfbGVm dCA8PSBYRU5fRFJNX05VTV9HUkVGU19QRVJfUEFHRSkgeworCQkJdG9fY29weSA9IGdyZWZzX2xl ZnQ7CisJCQlwYWdlX2Rpci0+Z3JlZl9kaXJfbmV4dF9wYWdlID0gR1JBTlRfSU5WQUxJRF9SRUY7 CisJCX0gZWxzZSB7CisJCQl0b19jb3B5ID0gWEVOX0RSTV9OVU1fR1JFRlNfUEVSX1BBR0U7CisJ CQlwYWdlX2Rpci0+Z3JlZl9kaXJfbmV4dF9wYWdlID0gYnVmLT5ncmVmc1tpICsgMV07CisJCX0K KwkJbWVtY3B5KCZwYWdlX2Rpci0+Z3JlZiwgJmJ1Zi0+Z3JlZnNbY3VyX2dyZWZdLAorCQkJCXRv X2NvcHkgKiBzaXplb2YoZ3JhbnRfcmVmX3QpKTsKKwkJcHRyICs9IFBBR0VfU0laRTsKKwkJZ3Jl ZnNfbGVmdCAtPSB0b19jb3B5OworCQljdXJfZ3JlZiArPSB0b19jb3B5OworCX0KK30KKworc3Rh dGljIGludCBndWVzdF9ncmFudF9yZWZzX2Zvcl9idWZmZXIoc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWYgKmJ1ZiwKKwkJZ3JhbnRfcmVmX3QgKnByaXZfZ3JlZl9oZWFkLCBpbnQgZ3JlZl9pZHgp Cit7CisJaW50IGksIGN1cl9yZWYsIG90aGVyZW5kX2lkOworCisJb3RoZXJlbmRfaWQgPSBidWYt PnhiX2Rldi0+b3RoZXJlbmRfaWQ7CisJZm9yIChpID0gMDsgaSA8IGJ1Zi0+bnVtX3BhZ2VzOyBp KyspIHsKKwkJY3VyX3JlZiA9IGdudHRhYl9jbGFpbV9ncmFudF9yZWZlcmVuY2UocHJpdl9ncmVm X2hlYWQpOworCQlpZiAoY3VyX3JlZiA8IDApCisJCQlyZXR1cm4gY3VyX3JlZjsKKwkJZ250dGFi X2dyYW50X2ZvcmVpZ25fYWNjZXNzX3JlZihjdXJfcmVmLCBvdGhlcmVuZF9pZCwKKwkJCQl4ZW5f cGFnZV90b19nZm4oYnVmLT5wYWdlc1tpXSksIDApOworCQlidWYtPmdyZWZzW2dyZWZfaWR4Kytd ID0gY3VyX3JlZjsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZ3JhbnRfcmVmZXJl bmNlcyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCWdyYW50X3JlZl90IHBy aXZfZ3JlZl9oZWFkOworCWludCByZXQsIGksIGosIGN1cl9yZWY7CisJaW50IG90aGVyZW5kX2lk LCBudW1fcGFnZXNfZGlyOworCisJcmV0ID0gZ250dGFiX2FsbG9jX2dyYW50X3JlZmVyZW5jZXMo YnVmLT5udW1fZ3JlZnMsICZwcml2X2dyZWZfaGVhZCk7CisJaWYgKHJldCA8IDApIHsKKwkJRFJN X0VSUk9SKCJDYW5ub3QgYWxsb2NhdGUgZ3JhbnQgcmVmZXJlbmNlc1xuIik7CisJCXJldHVybiBy ZXQ7CisJfQorCW90aGVyZW5kX2lkID0gYnVmLT54Yl9kZXYtPm90aGVyZW5kX2lkOworCWogPSAw OworCW51bV9wYWdlc19kaXIgPSBnZXRfbnVtX3BhZ2VzX2RpcihidWYpOworCWZvciAoaSA9IDA7 IGkgPCBudW1fcGFnZXNfZGlyOyBpKyspIHsKKwkJdW5zaWduZWQgbG9uZyBmcmFtZTsKKworCQlj dXJfcmVmID0gZ250dGFiX2NsYWltX2dyYW50X3JlZmVyZW5jZSgmcHJpdl9ncmVmX2hlYWQpOwor CQlpZiAoY3VyX3JlZiA8IDApCisJCQlyZXR1cm4gY3VyX3JlZjsKKworCQlmcmFtZSA9IHhlbl9w YWdlX3RvX2dmbih2aXJ0X3RvX3BhZ2UoYnVmLT5kaXJlY3RvcnkgKworCQkJCVBBR0VfU0laRSAq IGkpKTsKKwkJZ250dGFiX2dyYW50X2ZvcmVpZ25fYWNjZXNzX3JlZihjdXJfcmVmLCBvdGhlcmVu ZF9pZCwKKwkJCQlmcmFtZSwgMCk7CisJCWJ1Zi0+Z3JlZnNbaisrXSA9IGN1cl9yZWY7CisJfQor CisJaWYgKGJ1Zi0+b3BzLT5ncmFudF9yZWZzX2Zvcl9idWZmZXIpIHsKKwkJcmV0ID0gYnVmLT5v cHMtPmdyYW50X3JlZnNfZm9yX2J1ZmZlcihidWYsICZwcml2X2dyZWZfaGVhZCwgaik7CisJCWlm IChyZXQpCisJCQlyZXR1cm4gcmV0OworCX0KKworCWdudHRhYl9mcmVlX2dyYW50X3JlZmVyZW5j ZXMocHJpdl9ncmVmX2hlYWQpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGFsbG9jX3N0 b3JhZ2Uoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwlpZiAoYnVmLT5zZ3Qp IHsKKwkJYnVmLT5wYWdlcyA9IGt2bWFsbG9jX2FycmF5KGJ1Zi0+bnVtX3BhZ2VzLAorCQkJCXNp emVvZihzdHJ1Y3QgcGFnZSAqKSwgR0ZQX0tFUk5FTCk7CisJCWlmICghYnVmLT5wYWdlcykKKwkJ CXJldHVybiAtRU5PTUVNOworCisJCWlmIChkcm1fcHJpbWVfc2dfdG9fcGFnZV9hZGRyX2FycmF5 cyhidWYtPnNndCwgYnVmLT5wYWdlcywKKwkJCQlOVUxMLCBidWYtPm51bV9wYWdlcykgPCAwKQor CQkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJYnVmLT5ncmVmcyA9IGtjYWxsb2MoYnVmLT5udW1f Z3JlZnMsIHNpemVvZigqYnVmLT5ncmVmcyksIEdGUF9LRVJORUwpOworCWlmICghYnVmLT5ncmVm cykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlidWYtPmRpcmVjdG9yeSA9IGtjYWxsb2MoZ2V0X251 bV9wYWdlc19kaXIoYnVmKSwgUEFHRV9TSVpFLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJ1Zi0+ZGly ZWN0b3J5KQorCQlyZXR1cm4gLUVOT01FTTsKKworCXJldHVybiAwOworfQorCisvKgorICogRm9y IGJlIGFsbG9jYXRlZCBidWZmZXJzIHdlIGRvbid0IG5lZWQgZ3JhbnRfcmVmc19mb3JfYnVmZmVy IGFzIHRob3NlCisgKiBncmFudCByZWZlcmVuY2VzIGFyZSBhbGxvY2F0ZWQgYXQgYmFja2VuZCBz aWRlCisgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1Zl9vcHMgYmFj a2VuZF9vcHMgPSB7CisJLmNhbGNfbnVtX2dyZWZzID0gYmFja2VuZF9jYWxjX251bV9ncmVmcywK KwkuZmlsbF9wYWdlX2RpciA9IGJhY2tlbmRfZmlsbF9wYWdlX2RpciwKKwkubWFwID0gYmFja2Vu ZF9tYXAsCisJLnVubWFwID0gYmFja2VuZF91bm1hcAorfTsKKworLyogRm9yIGxvY2FsbHkgZ3Jh bnRlZCByZWZlcmVuY2VzIHdlIGRvIG5vdCBuZWVkIHRvIG1hcC91bm1hcCB0aGUgcmVmZXJlbmNl cyAqLworc3RhdGljIGNvbnN0IHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX29wcyBsb2NhbF9v cHMgPSB7CisJLmNhbGNfbnVtX2dyZWZzID0gZ3Vlc3RfY2FsY19udW1fZ3JlZnMsCisJLmZpbGxf cGFnZV9kaXIgPSBndWVzdF9maWxsX3BhZ2VfZGlyLAorCS5ncmFudF9yZWZzX2Zvcl9idWZmZXIg PSBndWVzdF9ncmFudF9yZWZzX2Zvcl9idWZmZXIsCit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9u dF9zaGJ1ZiAqeGVuX2RybV9mcm9udF9zaGJ1Zl9hbGxvYygKKwkJc3RydWN0IHhlbl9kcm1fZnJv bnRfc2hidWZfY2ZnICpjZmcpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZjsK KwlpbnQgcmV0OworCisJLyogZWl0aGVyIHBhZ2VzIG9yIHNndCwgbm90IGJvdGggKi8KKwlpZiAo dW5saWtlbHkoY2ZnLT5wYWdlcyAmJiBjZmctPnNndCkpIHsKKwkJRFJNX0VSUk9SKCJDYW5ub3Qg aGFuZGxlIGJ1ZmZlciBhbGxvY2F0aW9uIHdpdGggYm90aCBwYWdlcyBhbmQgc2cgdGFibGUgcHJv dmlkZWRcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlidWYgPSBremFsbG9jKHNpemVvZigq YnVmKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYpCisJCXJldHVybiBOVUxMOworCisJaWYgKGNm Zy0+YmVfYWxsb2MpCisJCWJ1Zi0+b3BzID0gJmJhY2tlbmRfb3BzOworCWVsc2UKKwkJYnVmLT5v cHMgPSAmbG9jYWxfb3BzOworCisJYnVmLT54Yl9kZXYgPSBjZmctPnhiX2RldjsKKwlidWYtPm51 bV9wYWdlcyA9IERJVl9ST1VORF9VUChjZmctPnNpemUsIFBBR0VfU0laRSk7CisJYnVmLT5zZ3Qg PSBjZmctPnNndDsKKwlidWYtPnBhZ2VzID0gY2ZnLT5wYWdlczsKKworCWJ1Zi0+b3BzLT5jYWxj X251bV9ncmVmcyhidWYpOworCisJcmV0ID0gYWxsb2Nfc3RvcmFnZShidWYpOworCWlmIChyZXQp CisJCWdvdG8gZmFpbDsKKworCXJldCA9IGdyYW50X3JlZmVyZW5jZXMoYnVmKTsKKwlpZiAocmV0 KQorCQlnb3RvIGZhaWw7CisKKwlidWYtPm9wcy0+ZmlsbF9wYWdlX2RpcihidWYpOworCisJcmV0 dXJuIGJ1ZjsKKworZmFpbDoKKwl4ZW5fZHJtX2Zyb250X3NoYnVmX2ZyZWUoYnVmKTsKKwlyZXR1 cm4gRVJSX1BUUihyZXQpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5f ZHJtX2Zyb250X3NoYnVmLmggYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hi dWYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjZjNGZiYzY4ZjMy OAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9z aGJ1Zi5oCkBAIC0wLDAgKzEsNzIgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwt Mi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoK KyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgorICogQXV0 aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBh bS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1fRlJPTlRfU0hCVUZfSF8KKyNkZWZpbmUg X19YRU5fRFJNX0ZST05UX1NIQlVGX0hfCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNp bmNsdWRlIDxsaW51eC9zY2F0dGVybGlzdC5oPgorCisjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxl Lmg+CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmIHsKKwkvKgorCSAqIG51bWJlciBvZiBy ZWZlcmVuY2VzIGdyYW50ZWQgZm9yIHRoZSBiYWNrZW5kIHVzZToKKwkgKiAgLSBmb3IgYWxsb2Nh dGVkL2ltcG9ydGVkIGRtYS1idWYncyB0aGlzIGhvbGRzIG51bWJlciBvZiBncmFudAorCSAqICAg IHJlZmVyZW5jZXMgZm9yIHRoZSBwYWdlIGRpcmVjdG9yeSBhbmQgcGFnZXMgb2YgdGhlIGJ1ZmZl cgorCSAqICAtIGZvciB0aGUgYnVmZmVyIHByb3ZpZGVkIGJ5IHRoZSBiYWNrZW5kIHRoaXMgaG9s ZHMgbnVtYmVyIG9mCisJICogICAgZ3JhbnQgcmVmZXJlbmNlcyBmb3IgdGhlIHBhZ2UgZGlyZWN0 b3J5IGFzIGdyYW50IHJlZmVyZW5jZXMgZm9yCisJICogICAgdGhlIGJ1ZmZlciB3aWxsIGJlIHBy b3ZpZGVkIGJ5IHRoZSBiYWNrZW5kCisJICovCisJaW50IG51bV9ncmVmczsKKwlncmFudF9yZWZf dCAqZ3JlZnM7CisJdW5zaWduZWQgY2hhciAqZGlyZWN0b3J5OworCisJLyoKKwkgKiB0aGVyZSBh cmUgMiB3YXlzIHRvIHByb3ZpZGUgYmFja2luZyBzdG9yYWdlIGZvciB0aGlzIHNoYXJlZCBidWZm ZXI6CisJICogZWl0aGVyIHBhZ2VzIG9yIHNndC4gaWYgYnVmZmVyIGNyZWF0ZWQgZnJvbSBzZ3Qg dGhlbiB3ZSBvd24KKwkgKiB0aGUgcGFnZXMgYW5kIG11c3QgZnJlZSB0aG9zZSBvdXJzZWx2ZXMg b24gY2xvc3VyZQorCSAqLworCWludCBudW1fcGFnZXM7CisJc3RydWN0IHBhZ2UgKipwYWdlczsK KworCXN0cnVjdCBzZ190YWJsZSAqc2d0OworCisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2Rl djsKKworCS8qIHRoZXNlIGFyZSB0aGUgb3BzIHVzZWQgaW50ZXJuYWxseSBkZXBlbmRpbmcgb24g YmVfYWxsb2MgbW9kZSAqLworCWNvbnN0IHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX29wcyAq b3BzOworCisJLyogWGVuIG1hcCBoYW5kbGVzIGZvciB0aGUgYnVmZmVyIGFsbG9jYXRlZCBieSB0 aGUgYmFja2VuZCAqLworCWdyYW50X2hhbmRsZV90ICpiYWNrZW5kX21hcF9oYW5kbGVzOworfTsK Kworc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfY2ZnIHsKKwlzdHJ1Y3QgeGVuYnVzX2Rldmlj ZSAqeGJfZGV2OworCXNpemVfdCBzaXplOworCXN0cnVjdCBwYWdlICoqcGFnZXM7CisJc3RydWN0 IHNnX3RhYmxlICpzZ3Q7CisJYm9vbCBiZV9hbGxvYzsKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zy b250X3NoYnVmICp4ZW5fZHJtX2Zyb250X3NoYnVmX2FsbG9jKAorCQlzdHJ1Y3QgeGVuX2RybV9m cm9udF9zaGJ1Zl9jZmcgKmNmZyk7CisKK2dyYW50X3JlZl90IHhlbl9kcm1fZnJvbnRfc2hidWZf Z2V0X2Rpcl9zdGFydChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsKKworaW50IHhl bl9kcm1fZnJvbnRfc2hidWZfbWFwKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOwor CitpbnQgeGVuX2RybV9mcm9udF9zaGJ1Zl91bm1hcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1 ZiAqYnVmKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X3NoYnVmX2ZsdXNoKHN0cnVjdCB4ZW5fZHJt X2Zyb250X3NoYnVmICpidWYpOworCit2b2lkIHhlbl9kcm1fZnJvbnRfc2hidWZfZnJlZShzdHJ1 Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9O VF9TSEJVRl9IXyAqLwotLSAKMi4xNi4yCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752281AbeC2JXU (ORCPT ); Thu, 29 Mar 2018 05:23:20 -0400 Received: from mail-lf0-f53.google.com ([209.85.215.53]:36483 "EHLO mail-lf0-f53.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752077AbeC2JXB (ORCPT ); Thu, 29 Mar 2018 05:23:01 -0400 X-Google-Smtp-Source: AIpwx49BjK/C5yBS+ZpmbQcQFaQ/xLAk4bjZHi19Ixd7Q2IaXRnI+KyPQSq6qiTCZHa4Y2L/xan5Kg== 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 v5 1/1] drm/xen-front: Add support for Xen PV display frontend Date: Thu, 29 Mar 2018 12:22:47 +0300 Message-Id: <20180329092247.23905-2-andr2000@gmail.com> X-Mailer: git-send-email 2.16.2 In-Reply-To: <20180329092247.23905-1-andr2000@gmail.com> References: <20180329092247.23905-1-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 Reviewed-by: Boris Ostrovsky Reviewed-by: Daniel Vetter --- 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 | 880 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front.h | 189 ++++++ 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 | 115 ++++ drivers/gpu/drm/xen/xen_drm_front_conn.h | 27 + drivers/gpu/drm/xen/xen_drm_front_evtchnl.c | 386 ++++++++++++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.h | 81 +++ drivers/gpu/drm/xen/xen_drm_front_gem.c | 309 ++++++++++ drivers/gpu/drm/xen/xen_drm_front_gem.h | 41 ++ drivers/gpu/drm/xen/xen_drm_front_gem_cma.c | 78 +++ drivers/gpu/drm/xen/xen_drm_front_kms.c | 372 ++++++++++++ drivers/gpu/drm/xen/xen_drm_front_kms.h | 27 + drivers/gpu/drm/xen/xen_drm_front_shbuf.c | 432 ++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_shbuf.h | 72 +++ 21 files changed, 3216 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..009d942386c5 --- /dev/null +++ b/Documentation/gpu/xen-front.rst @@ -0,0 +1,43 @@ +==================================================== + drm/xen-front 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..b08817e5e35c --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -0,0 +1,880 @@ +// 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; + + /* + * Dumb creation is a two stage process: first we create a fully + * constructed GEM object which is communicated to the backend, and + * only after that we can create GEM's handle. This is done so, + * because of the possible races: once you create a handle it becomes + * immediately visible to user-space, so the latter can try accessing + * object without pages etc. + * For details also see drm_gem_handle_create + */ + args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8); + args->size = args->pitch * args->height; + + obj = xen_drm_front_gem_create(dev, args->size); + if (IS_ERR_OR_NULL(obj)) { + ret = PTR_ERR(obj); + goto fail; + } + + /* + * 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_backend; + + /* This is the tail of GEM object creation */ + ret = drm_gem_handle_create(filp, obj, &args->handle); + if (ret) + goto fail_handle; + + /* Drop reference from allocate - handle holds it now */ + drm_gem_object_put_unlocked(obj); + return 0; + +fail_handle: + xen_drm_front_dbuf_destroy(drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj)); +fail_backend: + /* drop reference from allocate */ + drm_gem_object_put_unlocked(obj); +fail: + DRM_ERROR("Failed to create dumb buffer: %d\n", ret); + return ret; +} + +static void xen_drm_drv_free_object_unlocked(struct drm_gem_object *obj) +{ + struct xen_drm_front_drm_info *drm_info = obj->dev->dev_private; + int idx; + + if (drm_dev_enter(obj->dev, &idx)) { + xen_drm_front_dbuf_destroy(drm_info->front_info, + xen_drm_front_dbuf_to_cookie(obj)); + drm_dev_exit(idx); + } else + dbuf_free(&drm_info->front_info->dbuf_list, + xen_drm_front_dbuf_to_cookie(obj)); + + xen_drm_front_gem_free_object_unlocked(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; + + xen_drm_front_kms_fini(drm_info); + + drm_atomic_helper_shutdown(dev); + drm_mode_config_cleanup(dev); + + drm_dev_fini(dev); + kfree(dev); + + if (front_info->cfg.be_alloc) + xenbus_switch_state(front_info->xb_dev, + XenbusStateInitialising); + + kfree(drm_info); +} + +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_unlocked, + .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 = kzalloc(sizeof(*drm_info), GFP_KERNEL); + if (!drm_info) { + ret = -ENOMEM; + goto fail; + } + + drm_info->front_info = front_info; + front_info->drm_info = drm_info; + + drm_dev = drm_dev_alloc(&xen_drm_driver, dev); + if (!drm_dev) { + ret = -ENOMEM; + goto fail; + } + + 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); +fail: + kfree(drm_info); + 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; + + /* Nothing to do if device is already unplugged */ + if (drm_dev_is_unplugged(dev)) + return; + + drm_kms_helper_poll_fini(dev); + drm_dev_unplug(dev); + + front_info->drm_info = NULL; + + xen_drm_front_evtchnl_free_all(front_info); + dbuf_free_all(&front_info->dbuf_list); + + /* + * If we are not using backend allocated buffers, then tell the + * backend we are ready to (re)initialize. Otherwise, wait for + * drm_driver.release. + */ + if (!front_info->cfg.be_alloc) + xenbus_switch_state(front_info->xb_dev, + XenbusStateInitialising); +} + +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: + if (xb_dev->state == XenbusStateReconfiguring) + break; + + /* recovering after backend unexpected closure */ + displback_disconnect(front_info); + break; + + case XenbusStateInitWait: + if (xb_dev->state == XenbusStateReconfiguring) + break; + + /* 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) { + displback_disconnect(front_info); + 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..2d03de288f96 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -0,0 +1,189 @@ +/* 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; + + struct delayed_work pflip_to_worker; + + 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..b5d0b27983b8 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_conn.c @@ -0,0 +1,115 @@ +// 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