From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v6 1/1] drm/xen-front: Add support for Xen PV display frontend Date: Tue, 3 Apr 2018 11:28:33 +0300 Message-ID: <20180403082833.26249-2-andr2000@gmail.com> References: <20180403082833.26249-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wr0-x231.google.com (mail-wr0-x231.google.com [IPv6:2a00:1450:400c:c0c::231]) by gabe.freedesktop.org (Postfix) with ESMTPS id BC34F6E2B5 for ; Tue, 3 Apr 2018 08:28:46 +0000 (UTC) Received: by mail-wr0-x231.google.com with SMTP id y55so17578688wry.3 for ; Tue, 03 Apr 2018 01:28:46 -0700 (PDT) In-Reply-To: <20180403082833.26249-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 biBpcyBjb25maWd1cmVkCiAgICB2aWEgWGVuU3RvcmUuCiAzLiBBbGwgQ1JUQ3Mgb3BlcmF0ZSBh dCBmaXhlZCBmcmVxdWVuY3kgb2YgNjBIei4KCjEuIEltcGxlbWVudCBYZW4gYnVzIHN0YXRlIG1h Y2hpbmUgZm9yIHRoZSBmcm9udGVuZCBkcml2ZXIgYWNjb3JkaW5nIHRvCnRoZSBzdGF0ZSBkaWFn cmFtIGFuZCByZWNvdmVyeSBmbG93IGZyb20gZGlzcGxheSBwYXJhLXZpcnR1YWxpemVkCnByb3Rv Y29sOiB4ZW4vaW50ZXJmYWNlL2lvL2Rpc3BsaWYuaC4KCjIuIFJlYWQgY29uZmlndXJhdGlvbiB2 YWx1ZXMgZnJvbSBYZW4gc3RvcmUgYWNjb3JkaW5nCnRvIHhlbi9pbnRlcmZhY2UvaW8vZGlzcGxp Zi5oIHByb3RvY29sOgogIC0gcmVhZCBjb25uZWN0b3IocykgY29uZmlndXJhdGlvbgogIC0gcmVh ZCBidWZmZXIgYWxsb2NhdGlvbiBtb2RlIChiYWNrZW5kL2Zyb250ZW5kKQoKMy4gSGFuZGxlIFhl biBldmVudCBjaGFubmVsczoKICAtIGNyZWF0ZSBmb3IgYWxsIGNvbmZpZ3VyZWQgY29ubmVjdG9y cyBhbmQgcHVibGlzaAogICAgY29ycmVzcG9uZGluZyByaW5nIHJlZmVyZW5jZXMgYW5kIGV2ZW50 IGNoYW5uZWxzIGluIFhlbiBzdG9yZSwKICAgIHNvIGJhY2tlbmQgY2FuIGNvbm5lY3QKICAtIGlt cGxlbWVudCBldmVudCBjaGFubmVscyBpbnRlcnJ1cHQgaGFuZGxlcnMKICAtIGNyZWF0ZSBhbmQg ZGVzdHJveSBldmVudCBjaGFubmVscyB3aXRoIHJlc3BlY3QgdG8gWGVuIGJ1cyBzdGF0ZQoKNC4g SW1wbGVtZW50IHNoYXJlZCBidWZmZXIgaGFuZGxpbmcgYWNjb3JkaW5nIHRvIHRoZQpwYXJhLXZp cnR1YWxpemVkIGRpc3BsYXkgZGV2aWNlIHByb3RvY29sIGF0IHhlbi9pbnRlcmZhY2UvaW8vZGlz cGxpZi5oOgogIC0gaGFuZGxlIHBhZ2UgZGlyZWN0b3JpZXMgYWNjb3JkaW5nIHRvIGRpc3BsaWYg cHJvdG9jb2w6CiAgICAtIGFsbG9jYXRlIGFuZCBzaGFyZSBwYWdlIGRpcmVjdG9yaWVzCiAgICAt IGdyYW50IHJlZmVyZW5jZXMgdG8gdGhlIHJlcXVpcmVkIHNldCBvZiBwYWdlcyBmb3IgdGhlCiAg ICAgIHBhZ2UgZGlyZWN0b3J5CiAgLSBhbGxvY2F0ZSB4ZW4gYmFsbGxvb25lZCBwYWdlcyB2aWEg WGVuIGJhbGxvb24gZHJpdmVyCiAgICB3aXRoIGFsbG9jX3hlbmJhbGxvb25lZF9wYWdlcy9mcmVl X3hlbmJhbGxvb25lZF9wYWdlcwogIC0gZ3JhbnQgcmVmZXJlbmNlcyB0byB0aGUgcmVxdWlyZWQg c2V0IG9mIHBhZ2VzIGZvciB0aGUKICAgIHNoYXJlZCBidWZmZXIgaXRzZWxmCiAgLSBpbXBsZW1l bnQgcGFnZXMgbWFwL3VubWFwIGZvciB0aGUgYnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlCiAgICBi YWNrZW5kIChnbnR0YWJfbWFwX3JlZnMvZ250dGFiX3VubWFwX3JlZnMpCgo1LiBJbXBsZW1lbnQg a2VybmVsIG1vZGVzZXRpaW5nL2Nvbm5lY3RvciBoYW5kbGluZyB1c2luZwpEUk0gc2ltcGxlIEtN UyBoZWxwZXIgcGlwZWxpbmU6CgotIGltcGxlbWVudCBLTVMgcGFydCBvZiB0aGUgZHJpdmVyIHdp dGggdGhlIGhlbHAgb2YgRFJNCiAgc2ltcGxlIHBpcGVwbGluZSBoZWxwZXIgd2hpY2ggaXMgcG9z c2libGUgZHVlIHRvIHRoZSBmYWN0CiAgdGhhdCB0aGUgcGFyYS12aXJ0dWFsaXplZCBkcml2ZXIg b25seSBzdXBwb3J0cyBhIHNpbmdsZQogIChwcmltYXJ5KSBwbGFuZToKICAtIGluaXRpYWxpemUg Y29ubmVjdG9ycyBhY2NvcmRpbmcgdG8gWGVuU3RvcmUgY29uZmlndXJhdGlvbgogIC0gaGFuZGxl IGZyYW1lIGRvbmUgZXZlbnRzIGZyb20gdGhlIGJhY2tlbmQKICAtIGNyZWF0ZSBhbmQgZGVzdHJv eSBmcmFtZSBidWZmZXJzIGFuZCBwcm9wYWdhdGUgdGhvc2UKICAgIHRvIHRoZSBiYWNrZW5kCiAg LSBwcm9wYWdhdGUgc2V0L3Jlc2V0IG1vZGUgY29uZmlndXJhdGlvbiB0byB0aGUgYmFja2VuZCBv biBkaXNwbGF5CiAgICBlbmFibGUvZGlzYWJsZSBjYWxsYmFja3MKICAtIHNlbmQgcGFnZSBmbGlw IHJlcXVlc3QgdG8gdGhlIGJhY2tlbmQgYW5kIGltcGxlbWVudCBsb2dpYyBmb3IKICAgIHJlcG9y dGluZyBiYWNrZW5kIElPIGVycm9ycyBvbiBwcmVwYXJlIGZiIGNhbGxiYWNrCgotIGltcGxlbWVu dCB2aXJ0dWFsIGNvbm5lY3RvciBoYW5kbGluZzoKICAtIHN1cHBvcnQgb25seSBwaXhlbCBmb3Jt YXRzIHN1aXRhYmxlIGZvciBzaW5nbGUgcGxhbmUgbW9kZXMKICAtIG1ha2Ugc3VyZSB0aGUgY29u bmVjdG9yIGlzIGFsd2F5cyBjb25uZWN0ZWQKICAtIHN1cHBvcnQgYSBzaW5nbGUgdmlkZW8gbW9k ZSBhcyBwZXIgcGFyYS12aXJ0dWFsaXplZCBkcml2ZXIKICAgIGNvbmZpZ3VyYXRpb24KCjYuIElt cGxlbWVudCBHRU0gaGFuZGxpbmcgZGVwZW5kaW5nIG9uIGRyaXZlciBtb2RlIG9mIG9wZXJhdGlv bjoKZGVwZW5kaW5nIG9uIHRoZSByZXF1aXJlbWVudHMgZm9yIHRoZSBwYXJhLXZpcnR1YWxpemVk IGVudmlyb25tZW50LApuYW1lbHkgcmVxdWlyZW1lbnRzIGRpY3RhdGVkIGJ5IHRoZSBhY2NvbXBh bnlpbmcgRFJNLyh2KUdQVSBkcml2ZXJzCnJ1bm5pbmcgaW4gYm90aCBob3N0IGFuZCBndWVzdCBl bnZpcm9ubWVudHMsIG51bWJlciBvZiBvcGVyYXRpbmcKbW9kZXMgb2YgcGFyYS12aXJ0dWFsaXpl ZCBkaXNwbGF5IGRyaXZlciBhcmUgc3VwcG9ydGVkOgogLSBkaXNwbGF5IGJ1ZmZlcnMgY2FuIGJl IGFsbG9jYXRlZCBieSBlaXRoZXIKICAgZnJvbnRlbmQgZHJpdmVyIG9yIGJhY2tlbmQKIC0gZGlz cGxheSBidWZmZXJzIGNhbiBiZSBhbGxvY2F0ZWQgdG8gYmUgY29udGlndW91cwogICBpbiBtZW1v cnkgb3Igbm90CgpOb3RlISBGcm9udGVuZCBkcml2ZXIgaXRzZWxmIGhhcyBubyBkZXBlbmRlbmN5 IG9uIGNvbnRpZ3VvdXMgbWVtb3J5IGZvcgppdHMgb3BlcmF0aW9uLgoKNi4xLiBCdWZmZXJzIGFs bG9jYXRlZCBieSB0aGUgZnJvbnRlbmQgZHJpdmVyLgoKVGhlIGJlbG93IG1vZGVzIG9mIG9wZXJh dGlvbiBhcmUgY29uZmlndXJlZCBhdCBjb21waWxlLXRpbWUgdmlhCmZyb250ZW5kIGRyaXZlcidz IGtlcm5lbCBjb25maWd1cmF0aW9uLgoKNi4xLjEuIEZyb250IGRyaXZlciBjb25maWd1cmVkIHRv IHVzZSBHRU0gQ01BIGhlbHBlcnMKICAgICBUaGlzIHVzZS1jYXNlIGlzIHVzZWZ1bCB3aGVuIHVz ZWQgd2l0aCBhY2NvbXBhbnlpbmcgRFJNL3ZHUFUgZHJpdmVyCiAgICAgaW4gZ3Vlc3QgZG9tYWlu IHdoaWNoIHdhcyBkZXNpZ25lZCB0byBvbmx5IHdvcmsgd2l0aCBjb250aWd1b3VzCiAgICAgYnVm ZmVycywgZS5nLiBEUk0gZHJpdmVyIGJhc2VkIG9uIEdFTSBDTUEgaGVscGVyczogc3VjaCBkcml2 ZXJzIGNhbgogICAgIG9ubHkgaW1wb3J0IGNvbnRpZ3VvdXMgUFJJTUUgYnVmZmVycywgdGh1cyBy ZXF1aXJpbmcgZnJvbnRlbmQgZHJpdmVyCiAgICAgdG8gcHJvdmlkZSBzdWNoLiBJbiBvcmRlciB0 byBpbXBsZW1lbnQgdGhpcyBtb2RlIG9mIG9wZXJhdGlvbgogICAgIHBhcmEtdmlydHVhbGl6ZWQg ZnJvbnRlbmQgZHJpdmVyIGNhbiBiZSBjb25maWd1cmVkIHRvIHVzZQogICAgIEdFTSBDTUEgaGVs cGVycy4KCjYuMS4yLiBGcm9udCBkcml2ZXIgZG9lc24ndCB1c2UgR0VNIENNQQogICAgIElmIGFj Y29tcGFueWluZyBkcml2ZXJzIGNhbiBjb3BlIHdpdGggbm9uLWNvbnRpZ3VvdXMgbWVtb3J5IHRo ZW4sIHRvCiAgICAgbG93ZXIgcHJlc3N1cmUgb24gQ01BIHN1YnN5c3RlbSBvZiB0aGUga2VybmVs LCBkcml2ZXIgY2FuIGFsbG9jYXRlCiAgICAgYnVmZmVycyBmcm9tIHN5c3RlbSBtZW1vcnkuCgpO b3RlISBJZiB1c2VkIHdpdGggYWNjb21wYW55aW5nIERSTS8odilHUFUgZHJpdmVycyB0aGlzIG1v ZGUgb2Ygb3BlcmF0aW9uCm1heSByZXF1aXJlIElPTU1VIHN1cHBvcnQgb24gdGhlIHBsYXRmb3Jt LCBzbyBhY2NvbXBhbnlpbmcgRFJNL3ZHUFUKaGFyZHdhcmUgY2FuIHN0aWxsIHJlYWNoIGRpc3Bs YXkgYnVmZmVyIG1lbW9yeSB3aGlsZSBpbXBvcnRpbmcgUFJJTUUKYnVmZmVycyBmcm9tIHRoZSBm cm9udGVuZCBkcml2ZXIuCgo2LjIuIEJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBiYWNrZW5kCgpU aGlzIG1vZGUgb2Ygb3BlcmF0aW9uIGlzIHJ1bi10aW1lIGNvbmZpZ3VyZWQgdmlhIGd1ZXN0IGRv bWFpbgpjb25maWd1cmF0aW9uIHRocm91Z2ggWGVuU3RvcmUgZW50cmllcy4KCkZvciBzeXN0ZW1z IHdoaWNoIGRvIG5vdCBwcm92aWRlIElPTU1VIHN1cHBvcnQsIGJ1dCBoYXZpbmcgc3BlY2lmaWMK cmVxdWlyZW1lbnRzIGZvciBkaXNwbGF5IGJ1ZmZlcnMgaXQgaXMgcG9zc2libGUgdG8gYWxsb2Nh dGUgc3VjaCBidWZmZXJzCmF0IGJhY2tlbmQgc2lkZSBhbmQgc2hhcmUgdGhvc2Ugd2l0aCB0aGUg ZnJvbnRlbmQuCkZvciBleGFtcGxlLCBpZiBob3N0IGRvbWFpbiBpcyAxOjEgbWFwcGVkIGFuZCBo YXMgRFJNL0dQVSBoYXJkd2FyZQpleHBlY3RpbmcgcGh5c2ljYWxseSBjb250aWd1b3VzIG1lbW9y eSwgdGhpcyBhbGxvd3MgaW1wbGVtZW50aW5nCnplcm8tY29weWluZyB1c2UtY2FzZXMuCgpOb3Rl LCB3aGlsZSB1c2luZyB0aGlzIHNjZW5hcmlvIHRoZSBmb2xsb3dpbmcgc2hvdWxkIGJlIGNvbnNp ZGVyZWQ6CiAgYSkgSWYgZ3Vlc3QgZG9tYWluIGRpZXMgdGhlbiBwYWdlcy9ncmFudHMgcmVjZWl2 ZWQgZnJvbSB0aGUgYmFja2VuZAogICAgIGNhbm5vdCBiZSBjbGFpbWVkIGJhY2sKICBiKSBNaXNi ZWhhdmluZyBndWVzdCBtYXkgc2VuZCB0b28gbWFueSByZXF1ZXN0cyB0byB0aGUKICAgICBiYWNr ZW5kIGV4aGF1c3RpbmcgaXRzIGdyYW50IHJlZmVyZW5jZXMgYW5kIG1lbW9yeQogICAgIChjb25z aWRlciB0aGlzIGZyb20gc2VjdXJpdHkgUE9WKS4KCk5vdGUhIENvbmZpZ3VyYXRpb24gb3B0aW9u cyAxLjEgKGNvbnRpZ3VvdXMgZGlzcGxheSBidWZmZXJzKSBhbmQgMgooYmFja2VuZCBhbGxvY2F0 ZWQgYnVmZmVycykgYXJlIG5vdCBzdXBwb3J0ZWQgYXQgdGhlIHNhbWUgdGltZS4KCjcuIEhhbmRs ZSBjb21tdW5pY2F0aW9uIHdpdGggdGhlIGJhY2tlbmQ6CiAtIHNlbmQgcmVxdWVzdHMgYW5kIHdh aXQgZm9yIHRoZSByZXNwb25zZXMgYWNjb3JkaW5nCiAgIHRvIHRoZSBkaXNwbGlmIHByb3RvY29s CiAtIHNlcmlhbGl6ZSBhY2Nlc3MgdG8gdGhlIGNvbW11bmljYXRpb24gY2hhbm5lbAogLSB0aW1l LW91dCB1c2VkIGZvciBiYWNrZW5kIGNvbW11bmljYXRpb24gaXMgc2V0IHRvIDMwMDAgbXMKIC0g bWFuYWdlIGRpc3BsYXkgYnVmZmVycyBzaGFyZWQgd2l0aCB0aGUgYmFja2VuZAoKWzFdIGh0dHBz Oi8vZ2l0aHViLmNvbS94ZW4tdHJvb3BzL2Rpc3BsX2JlClsyXSBodHRwczovL2dpdGh1Yi5jb20v eGVuLXRyb29wcy9saWJ4ZW5iZQpbM10gaHR0cHM6Ly94ZW5iaXRzLnhlbi5vcmcvZ2l0d2ViLz9w PXhlbi5naXQ7YT1ibG9iO2Y9ZG9jcy9tYW4veGwuY2ZnLnBvZC41LmluO2g9YTY5OTM2Nzc3OWUy YWUxMjEyZmY4ZjYzOGVmZjAyMDZlYzFhMWNjOTtoYj1yZWZzL2hlYWRzL21hc3RlciNsMTI1NwoK U2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNo Y2hlbmtvQGVwYW0uY29tPgpSZXZpZXdlZC1ieTogQm9yaXMgT3N0cm92c2t5IDxib3Jpcy5vc3Ry b3Zza3lAb3JhY2xlLmNvbT4KUmV2aWV3ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0 ZXJAZmZ3bGwuY2g+Ci0tLQogRG9jdW1lbnRhdGlvbi9ncHUvZHJpdmVycy5yc3QgICAgICAgICAg ICAgICB8ICAgMSArCiBEb2N1bWVudGF0aW9uL2dwdS94ZW4tZnJvbnQucnN0ICAgICAgICAgICAg IHwgIDQzICsrCiBkcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgIHwg ICAyICsKIGRyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgfCAgIDEg KwogZHJpdmVycy9ncHUvZHJtL3hlbi9LY29uZmlnICAgICAgICAgICAgICAgICB8ICAzMCArCiBk cml2ZXJzL2dwdS9kcm0veGVuL01ha2VmaWxlICAgICAgICAgICAgICAgIHwgIDE2ICsKIGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jICAgICAgICAgfCA4ODIgKysrKysrKysrKysr KysrKysrKysrKysrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmggICAg ICAgICB8IDE4OCArKysrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jZmcu YyAgICAgfCAgNzcgKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmgg ICAgIHwgIDM3ICsrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jICAg IHwgMTE1ICsrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmggICAg fCAgMjcgKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYyB8IDM4 NiArKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5s LmggfCAgODEgKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgICAg IHwgMzExICsrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0u aCAgICAgfCAgNDEgKysKIGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW1fY21h LmMgfCAgNzcgKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfa21zLmMgICAg IHwgMzcwICsrKysrKysrKysrKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2tt cy5oICAgICB8ICAyNiArCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYu YyAgIHwgNDMyICsrKysrKysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnRfc2hidWYuaCAgIHwgIDcyICsrKwogMjEgZmlsZXMgY2hhbmdlZCwgMzIxNSBpbnNlcnRpb25z KCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9ncHUveGVuLWZyb250LnJzdAog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwogY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwogY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2NmZy5jCiBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2NmZy5oCiBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uYwogY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmgKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5j CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2 dGNobmwuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9m cm9udF9nZW0uYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9nZW0uaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVu X2RybV9mcm9udF9nZW1fY21hLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnRfa21zLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfa21zLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dw dS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hidWYuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9zaGJ1Zi5oCgpkaWZmIC0tZ2l0IGEvRG9jdW1l bnRhdGlvbi9ncHUvZHJpdmVycy5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcml2ZXJzLnJzdApp bmRleCBlOGM4NDQxOWEyYTEuLmQzYWI2YWJhZTgzOCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlv bi9ncHUvZHJpdmVycy5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9ncHUvZHJpdmVycy5yc3QKQEAg LTEyLDYgKzEyLDcgQEAgR1BVIERyaXZlciBEb2N1bWVudGF0aW9uCiAgICB0dmUyMDAKICAgIHZj NAogICAgYnJpZGdlL2R3LWhkbWkKKyAgIHhlbi1mcm9udAogCiAuLiBvbmx5OjogIHN1YnByb2pl Y3QgYW5kIGh0bWwKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUveGVuLWZyb250LnJz dCBiL0RvY3VtZW50YXRpb24vZ3B1L3hlbi1mcm9udC5yc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi4wMDlkOTQyMzg2YzUKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1 bWVudGF0aW9uL2dwdS94ZW4tZnJvbnQucnN0CkBAIC0wLDAgKzEsNDMgQEAKKz09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKyBkcm0veGVuLWZyb250 IFhlbiBwYXJhLXZpcnR1YWxpemVkIGZyb250ZW5kIGRyaXZlcgorPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCitUaGlzIGZyb250ZW5kIGRyaXZl ciBpbXBsZW1lbnRzIFhlbiBwYXJhLXZpcnR1YWxpemVkIGRpc3BsYXkKK2FjY29yZGluZyB0byB0 aGUgZGlzcGxheSBwcm90b2NvbCBkZXNjcmliZWQgYXQKK2luY2x1ZGUveGVuL2ludGVyZmFjZS9p by9kaXNwbGlmLmgKKworRHJpdmVyIG1vZGVzIG9mIG9wZXJhdGlvbiBpbiB0ZXJtcyBvZiBkaXNw bGF5IGJ1ZmZlcnMgdXNlZAorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJtL3hl bi94ZW5fZHJtX2Zyb250LmgKKyAgIDpkb2M6IERyaXZlciBtb2RlcyBvZiBvcGVyYXRpb24gaW4g dGVybXMgb2YgZGlzcGxheSBidWZmZXJzIHVzZWQKKworQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhl IGZyb250ZW5kIGRyaXZlcgorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQorCisuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgK KyAgIDpkb2M6IEJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBmcm9udGVuZCBkcml2ZXIKKworV2l0 aCBHRU0gQ01BIGhlbHBlcnMKK35+fn5+fn5+fn5+fn5+fn5+fn5+CisKKy4uIGtlcm5lbC1kb2M6 OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAgOmRvYzogV2l0aCBHRU0g Q01BIGhlbHBlcnMKKworV2l0aG91dCBHRU0gQ01BIGhlbHBlcnMKK35+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+CisKKy4uIGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnQuaAorICAgOmRvYzogV2l0aG91dCBHRU0gQ01BIGhlbHBlcnMKKworQnVmZmVycyBhbGxvY2F0 ZWQgYnkgdGhlIGJhY2tlbmQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKy4u IGtlcm5lbC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAorICAgOmRv YzogQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tlbmQKKworRHJpdmVyIGxpbWl0YXRpb25z Cis9PT09PT09PT09PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udC5oCisgICA6ZG9jOiBEcml2ZXIgbGltaXRhdGlvbnMKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKaW5k ZXggZGVlZWZhN2ExNzczLi43NTc4MjVhYzYwZGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9LY29uZmlnCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCkBAIC0yODksNiArMjg5LDgg QEAgc291cmNlICJkcml2ZXJzL2dwdS9kcm0vcGwxMTEvS2NvbmZpZyIKIAogc291cmNlICJkcml2 ZXJzL2dwdS9kcm0vdHZlMjAwL0tjb25maWciCiAKK3NvdXJjZSAiZHJpdmVycy9ncHUvZHJtL3hl bi9LY29uZmlnIgorCiAjIEtlZXAgbGVnYWN5IGRyaXZlcnMgbGFzdAogCiBtZW51Y29uZmlnIERS TV9MRUdBQ1kKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMv Z3B1L2RybS9NYWtlZmlsZQppbmRleCA1MDA5M2ZmNDQ3OWIuLjlkNjY2NTdlYTExNyAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9NYWtl ZmlsZQpAQCAtMTAzLDMgKzEwMyw0IEBAIG9iai0kKENPTkZJR19EUk1fTVhTRkIpCSs9IG14c2Zi Lwogb2JqLSQoQ09ORklHX0RSTV9USU5ZRFJNKSArPSB0aW55ZHJtLwogb2JqLSQoQ09ORklHX0RS TV9QTDExMSkgKz0gcGwxMTEvCiBvYmotJChDT05GSUdfRFJNX1RWRTIwMCkgKz0gdHZlMjAwLwor b2JqLSQoQ09ORklHX0RSTV9YRU4pICs9IHhlbi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS94ZW4vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjRmNGFiYzkxZjNiNgotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4vS2NvbmZpZwpAQCAtMCwwICsxLDMwIEBACitjb25maWcg RFJNX1hFTgorCWJvb2wgIkRSTSBTdXBwb3J0IGZvciBYZW4gZ3Vlc3QgT1MiCisJZGVwZW5kcyBv biBYRU4KKwloZWxwCisJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxl IERSTSBzdXBwb3J0CisJICBmb3IgWGVuLgorCitjb25maWcgRFJNX1hFTl9GUk9OVEVORAorCXRy aXN0YXRlICJQYXJhLXZpcnR1YWxpemVkIGZyb250ZW5kIGRyaXZlciBmb3IgWGVuIGd1ZXN0IE9T IgorCWRlcGVuZHMgb24gRFJNX1hFTgorCWRlcGVuZHMgb24gRFJNCisJc2VsZWN0IERSTV9LTVNf SEVMUEVSCisJc2VsZWN0IFZJREVPTU9ERV9IRUxQRVJTCisJc2VsZWN0IFhFTl9YRU5CVVNfRlJP TlRFTkQKKwloZWxwCisJICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgdG8gZW5hYmxl IGEgcGFyYS12aXJ0dWFsaXplZAorCSAgZnJvbnRlbmQgRFJNL0tNUyBkcml2ZXIgZm9yIFhlbiBn dWVzdCBPU2VzLgorCitjb25maWcgRFJNX1hFTl9GUk9OVEVORF9DTUEKKwlib29sICJVc2UgRFJN IENNQSB0byBhbGxvY2F0ZSBkdW1iIGJ1ZmZlcnMiCisJZGVwZW5kcyBvbiBEUk1fWEVOX0ZST05U RU5ECisJc2VsZWN0IERSTV9LTVNfQ01BX0hFTFBFUgorCXNlbGVjdCBEUk1fR0VNX0NNQV9IRUxQ RVIKKwloZWxwCisJICBVc2UgRFJNIENNQSBoZWxwZXJzIHRvIGFsbG9jYXRlIGRpc3BsYXkgYnVm ZmVycy4KKwkgIFRoaXMgaXMgdXNlZnVsIGZvciB0aGUgdXNlLWNhc2VzIHdoZW4gZ3Vlc3QgZHJp dmVyIG5lZWRzIHRvCisJICBzaGFyZSBvciBleHBvcnQgYnVmZmVycyB0byBvdGhlciBkcml2ZXJz IHdoaWNoIG9ubHkgZXhwZWN0CisJICBjb250aWd1b3VzIGJ1ZmZlcnMuCisJICBOb3RlOiBpbiB0 aGlzIG1vZGUgZHJpdmVyIGNhbm5vdCB1c2UgYnVmZmVycyBhbGxvY2F0ZWQKKwkgIGJ5IHRoZSBi YWNrZW5kLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSBiL2RyaXZl cnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwLi4zNTI3MzBkYzZjMTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0v eGVuL01ha2VmaWxlCkBAIC0wLDAgKzEsMTYgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAgT1IgTUlUCisKK2RybV94ZW5fZnJvbnQtb2JqcyA6PSB4ZW5fZHJtX2Zyb250Lm8g XAorCQkgICAgICB4ZW5fZHJtX2Zyb250X2ttcy5vIFwKKwkJICAgICAgeGVuX2RybV9mcm9udF9j b25uLm8gXAorCQkgICAgICB4ZW5fZHJtX2Zyb250X2V2dGNobmwubyBcCisJCSAgICAgIHhlbl9k cm1fZnJvbnRfc2hidWYubyBcCisJCSAgICAgIHhlbl9kcm1fZnJvbnRfY2ZnLm8KKworaWZlcSAo JChDT05GSUdfRFJNX1hFTl9GUk9OVEVORF9DTUEpLHkpCisJZHJtX3hlbl9mcm9udC1vYmpzICs9 IHhlbl9kcm1fZnJvbnRfZ2VtX2NtYS5vCitlbHNlCisJZHJtX3hlbl9mcm9udC1vYmpzICs9IHhl bl9kcm1fZnJvbnRfZ2VtLm8KK2VuZGlmCisKK29iai0kKENPTkZJR19EUk1fWEVOX0ZST05URU5E KSArPSBkcm1feGVuX2Zyb250Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVu X2RybV9mcm9udC5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xZTBlY2QzYWJhMzkKLS0tIC9kZXYv bnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwpAQCAtMCwwICsx LDg4MiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8q CisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAy MDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRy dXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5j bHVkZSA8ZHJtL2RybVAuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KKyNp bmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4K KyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+CisKKyNpbmNsdWRlIDxsaW51eC9v Zl9kZXZpY2UuaD4KKworI2luY2x1ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4KKyNpbmNsdWRlIDx4 ZW4veGVuLmg+CisjaW5jbHVkZSA8eGVuL3hlbmJ1cy5oPgorCisjaW5jbHVkZSA8eGVuL2ludGVy ZmFjZS9pby9kaXNwbGlmLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVk ZSAieGVuX2RybV9mcm9udF9jZmcuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2V2dGNobmwu aCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJv bnRfa21zLmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgorCitzdHJ1Y3QgeGVu X2RybV9mcm9udF9kYnVmIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CisJdTY0IGRidWZfY29v a2llOworCXU2NCBmYl9jb29raWU7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKnNoYnVm OworfTsKKworc3RhdGljIGludCBkYnVmX2FkZF90b19saXN0KHN0cnVjdCB4ZW5fZHJtX2Zyb250 X2luZm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpzaGJ1Ziwg dTY0IGRidWZfY29va2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmRidWY7CisK KwlkYnVmID0ga3phbGxvYyhzaXplb2YoKmRidWYpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRidWYp CisJCXJldHVybiAtRU5PTUVNOworCisJZGJ1Zi0+ZGJ1Zl9jb29raWUgPSBkYnVmX2Nvb2tpZTsK KwlkYnVmLT5zaGJ1ZiA9IHNoYnVmOworCWxpc3RfYWRkKCZkYnVmLT5saXN0LCAmZnJvbnRfaW5m by0+ZGJ1Zl9saXN0KTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCB4ZW5fZHJtX2Zy b250X2RidWYgKmRidWZfZ2V0KHN0cnVjdCBsaXN0X2hlYWQgKmRidWZfbGlzdCwKKwkJdTY0IGRi dWZfY29va2llKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmJ1ZiwgKnE7CisKKwls aXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoYnVmLCBxLCBkYnVmX2xpc3QsIGxpc3QpCisJCWlmIChi dWYtPmRidWZfY29va2llID09IGRidWZfY29va2llKQorCQkJcmV0dXJuIGJ1ZjsKKworCXJldHVy biBOVUxMOworfQorCitzdGF0aWMgdm9pZCBkYnVmX2ZsdXNoX2ZiKHN0cnVjdCBsaXN0X2hlYWQg KmRidWZfbGlzdCwgdTY0IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kYnVm ICpidWYsICpxOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGJ1ZiwgcSwgZGJ1Zl9saXN0 LCBsaXN0KQorCQlpZiAoYnVmLT5mYl9jb29raWUgPT0gZmJfY29va2llKQorCQkJeGVuX2RybV9m cm9udF9zaGJ1Zl9mbHVzaChidWYtPnNoYnVmKTsKK30KKworc3RhdGljIHZvaWQgZGJ1Zl9mcmVl KHN0cnVjdCBsaXN0X2hlYWQgKmRidWZfbGlzdCwgdTY0IGRidWZfY29va2llKQoreworCXN0cnVj dCB4ZW5fZHJtX2Zyb250X2RidWYgKmJ1ZiwgKnE7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3Nh ZmUoYnVmLCBxLCBkYnVmX2xpc3QsIGxpc3QpCisJCWlmIChidWYtPmRidWZfY29va2llID09IGRi dWZfY29va2llKSB7CisJCQlsaXN0X2RlbCgmYnVmLT5saXN0KTsKKwkJCXhlbl9kcm1fZnJvbnRf c2hidWZfdW5tYXAoYnVmLT5zaGJ1Zik7CisJCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2ZyZWUoYnVm LT5zaGJ1Zik7CisJCQlrZnJlZShidWYpOworCQkJYnJlYWs7CisJCX0KK30KKworc3RhdGljIHZv aWQgZGJ1Zl9mcmVlX2FsbChzdHJ1Y3QgbGlzdF9oZWFkICpkYnVmX2xpc3QpCit7CisJc3RydWN0 IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqYnVmLCAqcTsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2Fm ZShidWYsIHEsIGRidWZfbGlzdCwgbGlzdCkgeworCQlsaXN0X2RlbCgmYnVmLT5saXN0KTsKKwkJ eGVuX2RybV9mcm9udF9zaGJ1Zl91bm1hcChidWYtPnNoYnVmKTsKKwkJeGVuX2RybV9mcm9udF9z aGJ1Zl9mcmVlKGJ1Zi0+c2hidWYpOworCQlrZnJlZShidWYpOworCX0KK30KKworc3RhdGljIHN0 cnVjdCB4ZW5kaXNwbF9yZXEgKgorYmVfcHJlcGFyZV9yZXEoc3RydWN0IHhlbl9kcm1fZnJvbnRf ZXZ0Y2hubCAqZXZ0Y2hubCwgdTggb3BlcmF0aW9uKQoreworCXN0cnVjdCB4ZW5kaXNwbF9yZXEg KnJlcTsKKworCXJlcSA9IFJJTkdfR0VUX1JFUVVFU1QoJmV2dGNobmwtPnUucmVxLnJpbmcsCisJ CQlldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2dCk7CisJcmVxLT5vcGVyYXRpb24gPSBv cGVyYXRpb247CisJcmVxLT5pZCA9IGV2dGNobmwtPmV2dF9uZXh0X2lkKys7CisJZXZ0Y2hubC0+ ZXZ0X2lkID0gcmVxLT5pZDsKKwlyZXR1cm4gcmVxOworfQorCitzdGF0aWMgaW50IGJlX3N0cmVh bV9kb19pbyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sLAorCQlzdHJ1Y3Qg eGVuZGlzcGxfcmVxICpyZXEpCit7CisJcmVpbml0X2NvbXBsZXRpb24oJmV2dGNobmwtPnUucmVx LmNvbXBsZXRpb24pOworCWlmICh1bmxpa2VseShldnRjaG5sLT5zdGF0ZSAhPSBFVlRDSE5MX1NU QVRFX0NPTk5FQ1RFRCkpCisJCXJldHVybiAtRUlPOworCisJeGVuX2RybV9mcm9udF9ldnRjaG5s X2ZsdXNoKGV2dGNobmwpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJlX3N0cmVhbV93 YWl0X2lvKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwpCit7CisJaWYgKHdh aXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlvbiwKKwkJ CW1zZWNzX3RvX2ppZmZpZXMoWEVOX0RSTV9GUk9OVF9XQUlUX0JBQ0tfTVMpKSA8PSAwKQorCQly ZXR1cm4gLUVUSU1FRE9VVDsKKworCXJldHVybiBldnRjaG5sLT51LnJlcS5yZXNwX3N0YXR1czsK K30KKworaW50IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJt X3BpcGVsaW5lICpwaXBlbGluZSwKKwkJdTMyIHgsIHUzMiB5LCB1MzIgd2lkdGgsIHUzMiBoZWln aHQsIHUzMiBicHAsIHU2NCBmYl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvOwor CXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBy ZXQ7CisKKwlmcm9udF9pbmZvID0gcGlwZWxpbmUtPmRybV9pbmZvLT5mcm9udF9pbmZvOworCWV2 dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW3BpcGVsaW5lLT5pbmRleF0ucmVxOworCWlm ICh1bmxpa2VseSghZXZ0Y2hubCkpCisJCXJldHVybiAtRUlPOworCisJbXV0ZXhfbG9jaygmZXZ0 Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2lu Zm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRjaG5sLCBYRU5E SVNQTF9PUF9TRVRfQ09ORklHKTsKKwlyZXEtPm9wLnNldF9jb25maWcueCA9IHg7CisJcmVxLT5v cC5zZXRfY29uZmlnLnkgPSB5OworCXJlcS0+b3Auc2V0X2NvbmZpZy53aWR0aCA9IHdpZHRoOwor CXJlcS0+b3Auc2V0X2NvbmZpZy5oZWlnaHQgPSBoZWlnaHQ7CisJcmVxLT5vcC5zZXRfY29uZmln LmJwcCA9IGJwcDsKKwlyZXEtPm9wLnNldF9jb25maWcuZmJfY29va2llID0gZmJfY29va2llOwor CisJcmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmwsIHJlcSk7CisJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCisJaWYgKHJldCA9PSAwKQor CQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKworCW11dGV4X3VubG9jaygmZXZ0 Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQg YmVfZGJ1Zl9jcmVhdGVfaW50KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8s CisJCXU2NCBkYnVmX2Nvb2tpZSwgdTMyIHdpZHRoLCB1MzIgaGVpZ2h0LAorCQl1MzIgYnBwLCB1 NjQgc2l6ZSwgc3RydWN0IHBhZ2UgKipwYWdlcywKKwkJc3RydWN0IHNnX3RhYmxlICpzZ3QpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9zaGJ1ZiAqc2hidWY7CisJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVxOworCXN0cnVj dCB4ZW5fZHJtX2Zyb250X3NoYnVmX2NmZyBidWZfY2ZnOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7 CisJaW50IHJldDsKKworCWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW0dFTkVSSUNf T1BfRVZUX0NITkxdLnJlcTsKKwlpZiAodW5saWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJ TzsKKworCW1lbXNldCgmYnVmX2NmZywgMCwgc2l6ZW9mKGJ1Zl9jZmcpKTsKKwlidWZfY2ZnLnhi X2RldiA9IGZyb250X2luZm8tPnhiX2RldjsKKwlidWZfY2ZnLnBhZ2VzID0gcGFnZXM7CisJYnVm X2NmZy5zaXplID0gc2l6ZTsKKwlidWZfY2ZnLnNndCA9IHNndDsKKwlidWZfY2ZnLmJlX2FsbG9j ID0gZnJvbnRfaW5mby0+Y2ZnLmJlX2FsbG9jOworCisJc2hidWYgPSB4ZW5fZHJtX2Zyb250X3No YnVmX2FsbG9jKCZidWZfY2ZnKTsKKwlpZiAoIXNoYnVmKQorCQlyZXR1cm4gLUVOT01FTTsKKwor CXJldCA9IGRidWZfYWRkX3RvX2xpc3QoZnJvbnRfaW5mbywgc2hidWYsIGRidWZfY29va2llKTsK KwlpZiAocmV0IDwgMCkgeworCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2ZyZWUoc2hidWYpOworCQly ZXR1cm4gcmV0OworCX0KKworCW11dGV4X2xvY2soJmV2dGNobmwtPnUucmVxLnJlcV9pb19sb2Nr KTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJ cmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVORElTUExfT1BfREJVRl9DUkVBVEUpOwor CXJlcS0+b3AuZGJ1Zl9jcmVhdGUuZ3JlZl9kaXJlY3RvcnkgPQorCQkJeGVuX2RybV9mcm9udF9z aGJ1Zl9nZXRfZGlyX3N0YXJ0KHNoYnVmKTsKKwlyZXEtPm9wLmRidWZfY3JlYXRlLmJ1ZmZlcl9z eiA9IHNpemU7CisJcmVxLT5vcC5kYnVmX2NyZWF0ZS5kYnVmX2Nvb2tpZSA9IGRidWZfY29va2ll OworCXJlcS0+b3AuZGJ1Zl9jcmVhdGUud2lkdGggPSB3aWR0aDsKKwlyZXEtPm9wLmRidWZfY3Jl YXRlLmhlaWdodCA9IGhlaWdodDsKKwlyZXEtPm9wLmRidWZfY3JlYXRlLmJwcCA9IGJwcDsKKwlp ZiAoYnVmX2NmZy5iZV9hbGxvYykKKwkJcmVxLT5vcC5kYnVmX2NyZWF0ZS5mbGFncyB8PSBYRU5E SVNQTF9EQlVGX0ZMR19SRVFfQUxMT0M7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hu bCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBm bGFncyk7CisKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0gYmVfc3RyZWFt X3dhaXRfaW8oZXZ0Y2hubCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbDsKKworCXJldCA9 IHhlbl9kcm1fZnJvbnRfc2hidWZfbWFwKHNoYnVmKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBm YWlsOworCisJbXV0ZXhfdW5sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisJcmV0 dXJuIDA7CisKK2ZhaWw6CisJbXV0ZXhfdW5sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9j ayk7CisJZGJ1Zl9mcmVlKCZmcm9udF9pbmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2llKTsKKwly ZXR1cm4gcmV0OworfQorCitpbnQgeGVuX2RybV9mcm9udF9kYnVmX2NyZWF0ZV9mcm9tX3NndChz dHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQl1NjQgZGJ1Zl9jb29raWUs IHUzMiB3aWR0aCwgdTMyIGhlaWdodCwKKwkJdTMyIGJwcCwgdTY0IHNpemUsIHN0cnVjdCBzZ190 YWJsZSAqc2d0KQoreworCXJldHVybiBiZV9kYnVmX2NyZWF0ZV9pbnQoZnJvbnRfaW5mbywgZGJ1 Zl9jb29raWUsIHdpZHRoLCBoZWlnaHQsCisJCQlicHAsIHNpemUsIE5VTEwsIHNndCk7Cit9CisK K2ludCB4ZW5fZHJtX2Zyb250X2RidWZfY3JlYXRlX2Zyb21fcGFnZXMoc3RydWN0IHhlbl9kcm1f ZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJdTY0IGRidWZfY29va2llLCB1MzIgd2lkdGgsIHUz MiBoZWlnaHQsCisJCXUzMiBicHAsIHU2NCBzaXplLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQorewor CXJldHVybiBiZV9kYnVmX2NyZWF0ZV9pbnQoZnJvbnRfaW5mbywgZGJ1Zl9jb29raWUsIHdpZHRo LCBoZWlnaHQsCisJCQlicHAsIHNpemUsIHBhZ2VzLCBOVUxMKTsKK30KKworc3RhdGljIGludCB4 ZW5fZHJtX2Zyb250X2RidWZfZGVzdHJveShzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9u dF9pbmZvLAorCQl1NjQgZGJ1Zl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7CisJdW5zaWduZWQgbG9u ZyBmbGFnczsKKwlib29sIGJlX2FsbG9jOworCWludCByZXQ7CisKKwlldnRjaG5sID0gJmZyb250 X2luZm8tPmV2dF9wYWlyc1tHRU5FUklDX09QX0VWVF9DSE5MXS5yZXE7CisJaWYgKHVubGlrZWx5 KCFldnRjaG5sKSkKKwkJcmV0dXJuIC1FSU87CisKKwliZV9hbGxvYyA9IGZyb250X2luZm8tPmNm Zy5iZV9hbGxvYzsKKworCS8qCisJICogRm9yIHRoZSBiYWNrZW5kIGFsbG9jYXRlZCBidWZmZXIg cmVsZWFzZSByZWZlcmVuY2VzIG5vdywgc28gYmFja2VuZAorCSAqIGNhbiBmcmVlIHRoZSBidWZm ZXIuCisJICovCisJaWYgKGJlX2FsbG9jKQorCQlkYnVmX2ZyZWUoJmZyb250X2luZm8tPmRidWZf bGlzdCwgZGJ1Zl9jb29raWUpOworCisJbXV0ZXhfbG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lv X2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdz KTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRjaG5sLCBYRU5ESVNQTF9PUF9EQlVGX0RFU1RS T1kpOworCXJlcS0+b3AuZGJ1Zl9kZXN0cm95LmRidWZfY29va2llID0gZGJ1Zl9jb29raWU7CisK KwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0ID09IDApCisJ CXJldCA9IGJlX3N0cmVhbV93YWl0X2lvKGV2dGNobmwpOworCisJLyoKKwkgKiBEbyB0aGlzIHJl Z2FyZGxlc3Mgb2YgY29tbXVuaWNhdGlvbiBzdGF0dXMgd2l0aCB0aGUgYmFja2VuZDoKKwkgKiBp ZiB3ZSBjYW5ub3QgcmVtb3ZlIHJlbW90ZSByZXNvdXJjZXMgcmVtb3ZlIHdoYXQgd2UgY2FuIGxv Y2FsbHkuCisJICovCisJaWYgKCFiZV9hbGxvYykKKwkJZGJ1Zl9mcmVlKCZmcm9udF9pbmZvLT5k YnVmX2xpc3QsIGRidWZfY29va2llKTsKKworCW11dGV4X3VubG9jaygmZXZ0Y2hubC0+dS5yZXEu cmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2ZiX2F0 dGFjaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQl1NjQgZGJ1Zl9j b29raWUsIHU2NCBmYl9jb29raWUsIHUzMiB3aWR0aCwKKwkJdTMyIGhlaWdodCwgdTMyIHBpeGVs X2Zvcm1hdCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0 cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgKmJ1ZjsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXE7 CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0OworCisJZXZ0Y2hubCA9ICZmcm9udF9p bmZvLT5ldnRfcGFpcnNbR0VORVJJQ19PUF9FVlRfQ0hOTF0ucmVxOworCWlmICh1bmxpa2VseSgh ZXZ0Y2hubCkpCisJCXJldHVybiAtRUlPOworCisJYnVmID0gZGJ1Zl9nZXQoJmZyb250X2luZm8t PmRidWZfbGlzdCwgZGJ1Zl9jb29raWUpOworCWlmICghYnVmKQorCQlyZXR1cm4gLUVJTlZBTDsK KworCWJ1Zi0+ZmJfY29va2llID0gZmJfY29va2llOworCisJbXV0ZXhfbG9jaygmZXZ0Y2hubC0+ dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlv X2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRjaG5sLCBYRU5ESVNQTF9P UF9GQl9BVFRBQ0gpOworCXJlcS0+b3AuZmJfYXR0YWNoLmRidWZfY29va2llID0gZGJ1Zl9jb29r aWU7CisJcmVxLT5vcC5mYl9hdHRhY2guZmJfY29va2llID0gZmJfY29va2llOworCXJlcS0+b3Au ZmJfYXR0YWNoLndpZHRoID0gd2lkdGg7CisJcmVxLT5vcC5mYl9hdHRhY2guaGVpZ2h0ID0gaGVp Z2h0OworCXJlcS0+b3AuZmJfYXR0YWNoLnBpeGVsX2Zvcm1hdCA9IHBpeGVsX2Zvcm1hdDsKKwor CXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChyZXQgPT0gMCkKKwkJ cmV0ID0gYmVfc3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7CisKKwltdXRleF91bmxvY2soJmV2dGNo bmwtPnUucmVxLnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCitpbnQgeGVuX2RybV9m cm9udF9mYl9kZXRhY2goc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJ dTY0IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5s OworCXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWlu dCByZXQ7CisKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tHRU5FUklDX09QX0VW VF9DSE5MXS5yZXE7CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0dXJuIC1FSU87CisK KwltdXRleF9sb2NrKCZldnRjaG5sLT51LnJlcS5yZXFfaW9fbG9jayk7CisKKwlzcGluX2xvY2tf aXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJlcSA9IGJlX3ByZXBhcmVf cmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX0ZCX0RFVEFDSCk7CisJcmVxLT5vcC5mYl9kZXRhY2gu ZmJfY29va2llID0gZmJfY29va2llOworCisJcmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmws IHJlcSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxh Z3MpOworCisJaWYgKHJldCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5s KTsKKworCW11dGV4X3VubG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCXJldHVy biByZXQ7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X3BhZ2VfZmxpcChzdHJ1Y3QgeGVuX2RybV9m cm9udF9pbmZvICpmcm9udF9pbmZvLAorCQlpbnQgY29ubl9pZHgsIHU2NCBmYl9jb29raWUpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuZGlz cGxfcmVxICpyZXE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0OworCisJaWYgKHVu bGlrZWx5KGNvbm5faWR4ID49IGZyb250X2luZm8tPm51bV9ldnRfcGFpcnMpKQorCQlyZXR1cm4g LUVJTlZBTDsKKworCWRidWZfZmx1c2hfZmIoJmZyb250X2luZm8tPmRidWZfbGlzdCwgZmJfY29v a2llKTsKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tjb25uX2lkeF0ucmVxOwor CisJbXV0ZXhfbG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2Nr X2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJl X3JlcShldnRjaG5sLCBYRU5ESVNQTF9PUF9QR19GTElQKTsKKwlyZXEtPm9wLnBnX2ZsaXAuZmJf Y29va2llID0gZmJfY29va2llOworCisJcmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmwsIHJl cSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3Mp OworCisJaWYgKHJldCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsK KworCW11dGV4X3VubG9jaygmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCXJldHVybiBy ZXQ7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9vbl9mcmFtZV9kb25lKHN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCWludCBjb25uX2lkeCwgdTY0IGZiX2Nvb2tpZSkK K3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBmcm9udF9pbmZv LT5kcm1faW5mbzsKKworCWlmICh1bmxpa2VseShjb25uX2lkeCA+PSBmcm9udF9pbmZvLT5jZmcu bnVtX2Nvbm5lY3RvcnMpKQorCQlyZXR1cm47CisKKwl4ZW5fZHJtX2Zyb250X2ttc19vbl9mcmFt ZV9kb25lKCZkcm1faW5mby0+cGlwZWxpbmVbY29ubl9pZHhdLAorCQkJZmJfY29va2llKTsKK30K Kworc3RhdGljIGludCB4ZW5fZHJtX2Rydl9kdW1iX2NyZWF0ZShzdHJ1Y3QgZHJtX2ZpbGUgKmZp bHAsCisJCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fbW9kZV9jcmVhdGVfZHVt YiAqYXJncykKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBk ZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqOworCWludCByZXQ7 CisKKwkvKgorCSAqIER1bWIgY3JlYXRpb24gaXMgYSB0d28gc3RhZ2UgcHJvY2VzczogZmlyc3Qg d2UgY3JlYXRlIGEgZnVsbHkKKwkgKiBjb25zdHJ1Y3RlZCBHRU0gb2JqZWN0IHdoaWNoIGlzIGNv bW11bmljYXRlZCB0byB0aGUgYmFja2VuZCwgYW5kCisJICogb25seSBhZnRlciB0aGF0IHdlIGNh biBjcmVhdGUgR0VNJ3MgaGFuZGxlLiBUaGlzIGlzIGRvbmUgc28sCisJICogYmVjYXVzZSBvZiB0 aGUgcG9zc2libGUgcmFjZXM6IG9uY2UgeW91IGNyZWF0ZSBhIGhhbmRsZSBpdCBiZWNvbWVzCisJ ICogaW1tZWRpYXRlbHkgdmlzaWJsZSB0byB1c2VyLXNwYWNlLCBzbyB0aGUgbGF0dGVyIGNhbiB0 cnkgYWNjZXNzaW5nCisJICogb2JqZWN0IHdpdGhvdXQgcGFnZXMgZXRjLgorCSAqIEZvciBkZXRh aWxzIGFsc28gc2VlIGRybV9nZW1faGFuZGxlX2NyZWF0ZQorCSAqLworCWFyZ3MtPnBpdGNoID0g RElWX1JPVU5EX1VQKGFyZ3MtPndpZHRoICogYXJncy0+YnBwLCA4KTsKKwlhcmdzLT5zaXplID0g YXJncy0+cGl0Y2ggKiBhcmdzLT5oZWlnaHQ7CisKKwlvYmogPSB4ZW5fZHJtX2Zyb250X2dlbV9j cmVhdGUoZGV2LCBhcmdzLT5zaXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwob2JqKSkgeworCQly ZXQgPSBQVFJfRVJSKG9iaik7CisJCWdvdG8gZmFpbDsKKwl9CisKKwkvKgorCSAqIEluIGNhc2Ug b2YgQ09ORklHX0RSTV9YRU5fRlJPTlRFTkRfQ01BIGdlbV9vYmogaXMgY29uc3RydWN0ZWQKKwkg KiB2aWEgRFJNIENNQSBoZWxwZXJzIGFuZCBkb2Vzbid0IGhhdmUgLT5wYWdlcyBhbGxvY2F0ZWQK KwkgKiAoeGVuZHJtX2dlbV9nZXRfcGFnZXMgd2lsbCByZXR1cm4gTlVMTCksIGJ1dCBpbnN0ZWFk IGNhbiBwcm92aWRlCisJICogc2cgdGFibGUKKwkgKi8KKwlpZiAoeGVuX2RybV9mcm9udF9nZW1f Z2V0X3BhZ2VzKG9iaikpCisJCXJldCA9IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9w YWdlcyhkcm1faW5mby0+ZnJvbnRfaW5mbywKKwkJCQl4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29v a2llKG9iaiksCisJCQkJYXJncy0+d2lkdGgsIGFyZ3MtPmhlaWdodCwgYXJncy0+YnBwLAorCQkJ CWFyZ3MtPnNpemUsCisJCQkJeGVuX2RybV9mcm9udF9nZW1fZ2V0X3BhZ2VzKG9iaikpOworCWVs c2UKKwkJcmV0ID0geGVuX2RybV9mcm9udF9kYnVmX2NyZWF0ZV9mcm9tX3NndChkcm1faW5mby0+ ZnJvbnRfaW5mbywKKwkJCQl4ZW5fZHJtX2Zyb250X2RidWZfdG9fY29va2llKG9iaiksCisJCQkJ YXJncy0+d2lkdGgsIGFyZ3MtPmhlaWdodCwgYXJncy0+YnBwLAorCQkJCWFyZ3MtPnNpemUsCisJ CQkJeGVuX2RybV9mcm9udF9nZW1fZ2V0X3NnX3RhYmxlKG9iaikpOworCWlmIChyZXQpCisJCWdv dG8gZmFpbF9iYWNrZW5kOworCisJLyogVGhpcyBpcyB0aGUgdGFpbCBvZiBHRU0gb2JqZWN0IGNy ZWF0aW9uICovCisJcmV0ID0gZHJtX2dlbV9oYW5kbGVfY3JlYXRlKGZpbHAsIG9iaiwgJmFyZ3Mt PmhhbmRsZSk7CisJaWYgKHJldCkKKwkJZ290byBmYWlsX2hhbmRsZTsKKworCS8qIERyb3AgcmVm ZXJlbmNlIGZyb20gYWxsb2NhdGUgLSBoYW5kbGUgaG9sZHMgaXQgbm93ICovCisJZHJtX2dlbV9v YmplY3RfcHV0X3VubG9ja2VkKG9iaik7CisJcmV0dXJuIDA7CisKK2ZhaWxfaGFuZGxlOgorCXhl bl9kcm1fZnJvbnRfZGJ1Zl9kZXN0cm95KGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQl4ZW5fZHJt X2Zyb250X2RidWZfdG9fY29va2llKG9iaikpOworZmFpbF9iYWNrZW5kOgorCS8qIGRyb3AgcmVm ZXJlbmNlIGZyb20gYWxsb2NhdGUgKi8KKwlkcm1fZ2VtX29iamVjdF9wdXRfdW5sb2NrZWQob2Jq KTsKK2ZhaWw6CisJRFJNX0VSUk9SKCJGYWlsZWQgdG8gY3JlYXRlIGR1bWIgYnVmZmVyOiAlZFxu IiwgcmV0KTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCB4ZW5fZHJtX2Rydl9mcmVl X29iamVjdF91bmxvY2tlZChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaikKK3sKKwlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBvYmotPmRldi0+ZGV2X3ByaXZhdGU7 CisJaW50IGlkeDsKKworCWlmIChkcm1fZGV2X2VudGVyKG9iai0+ZGV2LCAmaWR4KSkgeworCQl4 ZW5fZHJtX2Zyb250X2RidWZfZGVzdHJveShkcm1faW5mby0+ZnJvbnRfaW5mbywKKwkJCQl4ZW5f ZHJtX2Zyb250X2RidWZfdG9fY29va2llKG9iaikpOworCQlkcm1fZGV2X2V4aXQoaWR4KTsKKwl9 IGVsc2UgeworCQlkYnVmX2ZyZWUoJmRybV9pbmZvLT5mcm9udF9pbmZvLT5kYnVmX2xpc3QsCisJ CQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShvYmopKTsKKwl9CisKKwl4ZW5fZHJtX2Zy b250X2dlbV9mcmVlX29iamVjdF91bmxvY2tlZChvYmopOworfQorCitzdGF0aWMgdm9pZCB4ZW5f ZHJtX2Rydl9yZWxlYXNlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvID0gZHJtX2luZm8tPmZyb250X2luZm87CisK Kwl4ZW5fZHJtX2Zyb250X2ttc19maW5pKGRybV9pbmZvKTsKKworCWRybV9hdG9taWNfaGVscGVy X3NodXRkb3duKGRldik7CisJZHJtX21vZGVfY29uZmlnX2NsZWFudXAoZGV2KTsKKworCWRybV9k ZXZfZmluaShkZXYpOworCWtmcmVlKGRldik7CisKKwlpZiAoZnJvbnRfaW5mby0+Y2ZnLmJlX2Fs bG9jKQorCQl4ZW5idXNfc3dpdGNoX3N0YXRlKGZyb250X2luZm8tPnhiX2RldiwKKwkJCQlYZW5i dXNTdGF0ZUluaXRpYWxpc2luZyk7CisKKwlrZnJlZShkcm1faW5mbyk7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHhlbl9kcm1fZGV2X2ZvcHMgPSB7CisJLm93bmVy ICAgICAgICAgID0gVEhJU19NT0RVTEUsCisJLm9wZW4gICAgICAgICAgID0gZHJtX29wZW4sCisJ LnJlbGVhc2UgICAgICAgID0gZHJtX3JlbGVhc2UsCisJLnVubG9ja2VkX2lvY3RsID0gZHJtX2lv Y3RsLAorI2lmZGVmIENPTkZJR19DT01QQVQKKwkuY29tcGF0X2lvY3RsICAgPSBkcm1fY29tcGF0 X2lvY3RsLAorI2VuZGlmCisJLnBvbGwgICAgICAgICAgID0gZHJtX3BvbGwsCisJLnJlYWQgICAg ICAgICAgID0gZHJtX3JlYWQsCisJLmxsc2VlayAgICAgICAgID0gbm9fbGxzZWVrLAorI2lmZGVm IENPTkZJR19EUk1fWEVOX0ZST05URU5EX0NNQQorCS5tbWFwICAgICAgICAgICA9IGRybV9nZW1f Y21hX21tYXAsCisjZWxzZQorCS5tbWFwICAgICAgICAgICA9IHhlbl9kcm1fZnJvbnRfZ2VtX21t YXAsCisjZW5kaWYKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgdm1fb3BlcmF0aW9uc19zdHJ1 Y3QgeGVuX2RybV9kcnZfdm1fb3BzID0geworCS5vcGVuICAgICAgICAgICA9IGRybV9nZW1fdm1f b3BlbiwKKwkuY2xvc2UgICAgICAgICAgPSBkcm1fZ2VtX3ZtX2Nsb3NlLAorfTsKKworc3RhdGlj IHN0cnVjdCBkcm1fZHJpdmVyIHhlbl9kcm1fZHJpdmVyID0geworCS5kcml2ZXJfZmVhdHVyZXMg ICAgICAgICAgID0gRFJJVkVSX0dFTSB8IERSSVZFUl9NT0RFU0VUIHwKKwkJCQkgICAgIERSSVZF Ul9QUklNRSB8IERSSVZFUl9BVE9NSUMsCisJLnJlbGVhc2UgICAgICAgICAgICAgICAgICAgPSB4 ZW5fZHJtX2Rydl9yZWxlYXNlLAorCS5nZW1fdm1fb3BzICAgICAgICAgICAgICAgID0gJnhlbl9k cm1fZHJ2X3ZtX29wcywKKwkuZ2VtX2ZyZWVfb2JqZWN0X3VubG9ja2VkICA9IHhlbl9kcm1fZHJ2 X2ZyZWVfb2JqZWN0X3VubG9ja2VkLAorCS5wcmltZV9oYW5kbGVfdG9fZmQgICAgICAgID0gZHJt X2dlbV9wcmltZV9oYW5kbGVfdG9fZmQsCisJLnByaW1lX2ZkX3RvX2hhbmRsZSAgICAgICAgPSBk cm1fZ2VtX3ByaW1lX2ZkX3RvX2hhbmRsZSwKKwkuZ2VtX3ByaW1lX2ltcG9ydCAgICAgICAgICA9 IGRybV9nZW1fcHJpbWVfaW1wb3J0LAorCS5nZW1fcHJpbWVfZXhwb3J0ICAgICAgICAgID0gZHJt X2dlbV9wcmltZV9leHBvcnQsCisJLmdlbV9wcmltZV9pbXBvcnRfc2dfdGFibGUgPSB4ZW5fZHJt X2Zyb250X2dlbV9pbXBvcnRfc2dfdGFibGUsCisJLmdlbV9wcmltZV9nZXRfc2dfdGFibGUgICAg PSB4ZW5fZHJtX2Zyb250X2dlbV9nZXRfc2dfdGFibGUsCisJLmR1bWJfY3JlYXRlICAgICAgICAg ICAgICAgPSB4ZW5fZHJtX2Rydl9kdW1iX2NyZWF0ZSwKKwkuZm9wcyAgICAgICAgICAgICAgICAg ICAgICA9ICZ4ZW5fZHJtX2Rldl9mb3BzLAorCS5uYW1lICAgICAgICAgICAgICAgICAgICAgID0g InhlbmRybS1kdSIsCisJLmRlc2MgICAgICAgICAgICAgICAgICAgICAgPSAiWGVuIFBWIERSTSBE aXNwbGF5IFVuaXQiLAorCS5kYXRlICAgICAgICAgICAgICAgICAgICAgID0gIjIwMTgwMjIxIiwK KwkubWFqb3IgICAgICAgICAgICAgICAgICAgICA9IDEsCisJLm1pbm9yICAgICAgICAgICAgICAg ICAgICAgPSAwLAorCisjaWZkZWYgQ09ORklHX0RSTV9YRU5fRlJPTlRFTkRfQ01BCisJLmdlbV9w cmltZV92bWFwICAgICAgICAgICAgPSBkcm1fZ2VtX2NtYV9wcmltZV92bWFwLAorCS5nZW1fcHJp bWVfdnVubWFwICAgICAgICAgID0gZHJtX2dlbV9jbWFfcHJpbWVfdnVubWFwLAorCS5nZW1fcHJp bWVfbW1hcCAgICAgICAgICAgID0gZHJtX2dlbV9jbWFfcHJpbWVfbW1hcCwKKyNlbHNlCisJLmdl bV9wcmltZV92bWFwICAgICAgICAgICAgPSB4ZW5fZHJtX2Zyb250X2dlbV9wcmltZV92bWFwLAor CS5nZW1fcHJpbWVfdnVubWFwICAgICAgICAgID0geGVuX2RybV9mcm9udF9nZW1fcHJpbWVfdnVu bWFwLAorCS5nZW1fcHJpbWVfbW1hcCAgICAgICAgICAgID0geGVuX2RybV9mcm9udF9nZW1fcHJp bWVfbW1hcCwKKyNlbmRpZgorfTsKKworc3RhdGljIGludCB4ZW5fZHJtX2Rydl9pbml0KHN0cnVj dCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJc3RydWN0IGRldmljZSAqZGV2 ID0gJmZyb250X2luZm8tPnhiX2Rldi0+ZGV2OworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9p bmZvICpkcm1faW5mbzsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtX2RldjsKKwlpbnQgcmV0Owor CisJRFJNX0lORk8oIkNyZWF0aW5nICVzXG4iLCB4ZW5fZHJtX2RyaXZlci5kZXNjKTsKKworCWRy bV9pbmZvID0ga3phbGxvYyhzaXplb2YoKmRybV9pbmZvKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFk cm1faW5mbykgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZhaWw7CisJfQorCisJZHJtX2lu Zm8tPmZyb250X2luZm8gPSBmcm9udF9pbmZvOworCWZyb250X2luZm8tPmRybV9pbmZvID0gZHJt X2luZm87CisKKwlkcm1fZGV2ID0gZHJtX2Rldl9hbGxvYygmeGVuX2RybV9kcml2ZXIsIGRldik7 CisJaWYgKCFkcm1fZGV2KSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZmFpbDsKKwl9CisK Kwlkcm1faW5mby0+ZHJtX2RldiA9IGRybV9kZXY7CisKKwlkcm1fZGV2LT5kZXZfcHJpdmF0ZSA9 IGRybV9pbmZvOworCisJcmV0ID0geGVuX2RybV9mcm9udF9rbXNfaW5pdChkcm1faW5mbyk7CisJ aWYgKHJldCkgeworCQlEUk1fRVJST1IoIkZhaWxlZCB0byBpbml0aWFsaXplIERSTS9LTVMsIHJl dCAlZFxuIiwgcmV0KTsKKwkJZ290byBmYWlsX21vZGVzZXQ7CisJfQorCisJcmV0ID0gZHJtX2Rl dl9yZWdpc3Rlcihkcm1fZGV2LCAwKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWxfcmVnaXN0ZXI7 CisKKwlEUk1fSU5GTygiSW5pdGlhbGl6ZWQgJXMgJWQuJWQuJWQgJXMgb24gbWlub3IgJWRcbiIs CisJCQl4ZW5fZHJtX2RyaXZlci5uYW1lLCB4ZW5fZHJtX2RyaXZlci5tYWpvciwKKwkJCXhlbl9k cm1fZHJpdmVyLm1pbm9yLCB4ZW5fZHJtX2RyaXZlci5wYXRjaGxldmVsLAorCQkJeGVuX2RybV9k cml2ZXIuZGF0ZSwgZHJtX2Rldi0+cHJpbWFyeS0+aW5kZXgpOworCisJcmV0dXJuIDA7CisKK2Zh aWxfcmVnaXN0ZXI6CisJZHJtX2Rldl91bnJlZ2lzdGVyKGRybV9kZXYpOworZmFpbF9tb2Rlc2V0 OgorCWRybV9rbXNfaGVscGVyX3BvbGxfZmluaShkcm1fZGV2KTsKKwlkcm1fbW9kZV9jb25maWdf Y2xlYW51cChkcm1fZGV2KTsKK2ZhaWw6CisJa2ZyZWUoZHJtX2luZm8pOworCXJldHVybiByZXQ7 Cit9CisKK3N0YXRpYyB2b2lkIHhlbl9kcm1fZHJ2X2Zpbmkoc3RydWN0IHhlbl9kcm1fZnJvbnRf aW5mbyAqZnJvbnRfaW5mbykKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJt X2luZm8gPSBmcm9udF9pbmZvLT5kcm1faW5mbzsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2Owor CisJaWYgKCFkcm1faW5mbykKKwkJcmV0dXJuOworCisJZGV2ID0gZHJtX2luZm8tPmRybV9kZXY7 CisJaWYgKCFkZXYpCisJCXJldHVybjsKKworCS8qIE5vdGhpbmcgdG8gZG8gaWYgZGV2aWNlIGlz IGFscmVhZHkgdW5wbHVnZ2VkICovCisJaWYgKGRybV9kZXZfaXNfdW5wbHVnZ2VkKGRldikpCisJ CXJldHVybjsKKworCWRybV9rbXNfaGVscGVyX3BvbGxfZmluaShkZXYpOworCWRybV9kZXZfdW5w bHVnKGRldik7CisKKwlmcm9udF9pbmZvLT5kcm1faW5mbyA9IE5VTEw7CisKKwl4ZW5fZHJtX2Zy b250X2V2dGNobmxfZnJlZV9hbGwoZnJvbnRfaW5mbyk7CisJZGJ1Zl9mcmVlX2FsbCgmZnJvbnRf aW5mby0+ZGJ1Zl9saXN0KTsKKworCS8qCisJICogSWYgd2UgYXJlIG5vdCB1c2luZyBiYWNrZW5k IGFsbG9jYXRlZCBidWZmZXJzLCB0aGVuIHRlbGwgdGhlCisJICogYmFja2VuZCB3ZSBhcmUgcmVh ZHkgdG8gKHJlKWluaXRpYWxpemUuIE90aGVyd2lzZSwgd2FpdCBmb3IKKwkgKiBkcm1fZHJpdmVy LnJlbGVhc2UuCisJICovCisJaWYgKCFmcm9udF9pbmZvLT5jZmcuYmVfYWxsb2MpCisJCXhlbmJ1 c19zd2l0Y2hfc3RhdGUoZnJvbnRfaW5mby0+eGJfZGV2LAorCQkJCVhlbmJ1c1N0YXRlSW5pdGlh bGlzaW5nKTsKK30KKworc3RhdGljIGludCBkaXNwbGJhY2tfaW5pdHdhaXQoc3RydWN0IHhlbl9k cm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcg KmNmZyA9ICZmcm9udF9pbmZvLT5jZmc7CisJaW50IHJldDsKKworCWNmZy0+ZnJvbnRfaW5mbyA9 IGZyb250X2luZm87CisJcmV0ID0geGVuX2RybV9mcm9udF9jZmdfY2FyZChmcm9udF9pbmZvLCBj ZmcpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJRFJNX0lORk8oIkhhdmUgJWQg Y29uZWN0b3IocylcbiIsIGNmZy0+bnVtX2Nvbm5lY3RvcnMpOworCS8qIENyZWF0ZSBldmVudCBj aGFubmVscyBmb3IgYWxsIGNvbm5lY3RvcnMgYW5kIHB1Ymxpc2ggKi8KKwlyZXQgPSB4ZW5fZHJt X2Zyb250X2V2dGNobmxfY3JlYXRlX2FsbChmcm9udF9pbmZvKTsKKwlpZiAocmV0IDwgMCkKKwkJ cmV0dXJuIHJldDsKKworCXJldHVybiB4ZW5fZHJtX2Zyb250X2V2dGNobmxfcHVibGlzaF9hbGwo ZnJvbnRfaW5mbyk7Cit9CisKK3N0YXRpYyBpbnQgZGlzcGxiYWNrX2Nvbm5lY3Qoc3RydWN0IHhl bl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwl4ZW5fZHJtX2Zyb250X2V2dGNobmxf c2V0X3N0YXRlKGZyb250X2luZm8sIEVWVENITkxfU1RBVEVfQ09OTkVDVEVEKTsKKwlyZXR1cm4g eGVuX2RybV9kcnZfaW5pdChmcm9udF9pbmZvKTsKK30KKworc3RhdGljIHZvaWQgZGlzcGxiYWNr X2Rpc2Nvbm5lY3Qoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sKKwlp ZiAoIWZyb250X2luZm8tPmRybV9pbmZvKQorCQlyZXR1cm47CisKKwkvKiBUZWxsIHRoZSBiYWNr ZW5kIHRvIHdhaXQgdW50aWwgd2UgcmVsZWFzZSB0aGUgRFJNIGRyaXZlci4gKi8KKwl4ZW5idXNf c3dpdGNoX3N0YXRlKGZyb250X2luZm8tPnhiX2RldiwgWGVuYnVzU3RhdGVSZWNvbmZpZ3VyaW5n KTsKKworCXhlbl9kcm1fZHJ2X2ZpbmkoZnJvbnRfaW5mbyk7Cit9CisKK3N0YXRpYyB2b2lkIGRp c3BsYmFja19jaGFuZ2VkKHN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYsCisJCWVudW0geGVu YnVzX3N0YXRlIGJhY2tlbmRfc3RhdGUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAq ZnJvbnRfaW5mbyA9IGRldl9nZXRfZHJ2ZGF0YSgmeGJfZGV2LT5kZXYpOworCWludCByZXQ7CisK KwlEUk1fREVCVUcoIkJhY2tlbmQgc3RhdGUgaXMgJXMsIGZyb250IGlzICVzXG4iLAorCQkJeGVu YnVzX3N0cnN0YXRlKGJhY2tlbmRfc3RhdGUpLAorCQkJeGVuYnVzX3N0cnN0YXRlKHhiX2Rldi0+ c3RhdGUpKTsKKworCXN3aXRjaCAoYmFja2VuZF9zdGF0ZSkgeworCWNhc2UgWGVuYnVzU3RhdGVS ZWNvbmZpZ3VyaW5nOgorCQkvKiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIFhlbmJ1c1N0YXRlUmVj b25maWd1cmVkOgorCQkvKiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIFhlbmJ1c1N0YXRlSW5pdGlh bGlzZWQ6CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZUluaXRpYWxpc2luZzoKKwkJaWYg KHhiX2Rldi0+c3RhdGUgPT0gWGVuYnVzU3RhdGVSZWNvbmZpZ3VyaW5nKQorCQkJYnJlYWs7CisK KwkJLyogcmVjb3ZlcmluZyBhZnRlciBiYWNrZW5kIHVuZXhwZWN0ZWQgY2xvc3VyZSAqLworCQlk aXNwbGJhY2tfZGlzY29ubmVjdChmcm9udF9pbmZvKTsKKwkJYnJlYWs7CisKKwljYXNlIFhlbmJ1 c1N0YXRlSW5pdFdhaXQ6CisJCWlmICh4Yl9kZXYtPnN0YXRlID09IFhlbmJ1c1N0YXRlUmVjb25m aWd1cmluZykKKwkJCWJyZWFrOworCisJCS8qIHJlY292ZXJpbmcgYWZ0ZXIgYmFja2VuZCB1bmV4 cGVjdGVkIGNsb3N1cmUgKi8KKwkJZGlzcGxiYWNrX2Rpc2Nvbm5lY3QoZnJvbnRfaW5mbyk7CisJ CWlmICh4Yl9kZXYtPnN0YXRlICE9IFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5nKQorCQkJYnJlYWs7 CisKKwkJcmV0ID0gZGlzcGxiYWNrX2luaXR3YWl0KGZyb250X2luZm8pOworCQlpZiAocmV0IDwg MCkKKwkJCXhlbmJ1c19kZXZfZmF0YWwoeGJfZGV2LCByZXQsCisJCQkJCSJpbml0aWFsaXppbmcg ZnJvbnRlbmQiKTsKKwkJZWxzZQorCQkJeGVuYnVzX3N3aXRjaF9zdGF0ZSh4Yl9kZXYsIFhlbmJ1 c1N0YXRlSW5pdGlhbGlzZWQpOworCQlicmVhazsKKworCWNhc2UgWGVuYnVzU3RhdGVDb25uZWN0 ZWQ6CisJCWlmICh4Yl9kZXYtPnN0YXRlICE9IFhlbmJ1c1N0YXRlSW5pdGlhbGlzZWQpCisJCQli cmVhazsKKworCQlyZXQgPSBkaXNwbGJhY2tfY29ubmVjdChmcm9udF9pbmZvKTsKKwkJaWYgKHJl dCA8IDApIHsKKwkJCWRpc3BsYmFja19kaXNjb25uZWN0KGZyb250X2luZm8pOworCQkJeGVuYnVz X2Rldl9mYXRhbCh4Yl9kZXYsIHJldCwKKwkJCQkJImluaXRpYWxpemluZyBEUk0gZHJpdmVyIik7 CisJCX0gZWxzZSB7CisJCQl4ZW5idXNfc3dpdGNoX3N0YXRlKHhiX2RldiwgWGVuYnVzU3RhdGVD b25uZWN0ZWQpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZUNsb3Npbmc6CisJ CS8qCisJCSAqIGluIHRoaXMgc3RhdGUgYmFja2VuZCBzdGFydHMgZnJlZWluZyByZXNvdXJjZXMs CisJCSAqIHNvIGxldCBpdCBnbyBpbnRvIGNsb3NlZCBzdGF0ZSwgc28gd2UgY2FuIGFsc28KKwkJ ICogcmVtb3ZlIG91cnMKKwkJICovCisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZVVua25v d246CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2UgWGVuYnVzU3RhdGVDbG9zZWQ6CisJCWlm ICh4Yl9kZXYtPnN0YXRlID09IFhlbmJ1c1N0YXRlQ2xvc2VkKQorCQkJYnJlYWs7CisKKwkJZGlz cGxiYWNrX2Rpc2Nvbm5lY3QoZnJvbnRfaW5mbyk7CisJCWJyZWFrOworCX0KK30KKworc3RhdGlj IGludCB4ZW5fZHJ2X3Byb2JlKHN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYsCisJCWNvbnN0 IHN0cnVjdCB4ZW5idXNfZGV2aWNlX2lkICppZCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9p bmZvICpmcm9udF9pbmZvOworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZ4Yl9kZXYtPmRldjsKKwlp bnQgcmV0OworCisJLyoKKwkgKiBUaGUgZGV2aWNlIGlzIG5vdCBzcGF3biBmcm9tIGEgZGV2aWNl IHRyZWUsIHNvIGFyY2hfc2V0dXBfZG1hX29wcworCSAqIGlzIG5vdCBjYWxsZWQsIHRodXMgbGVh dmluZyB0aGUgZGV2aWNlIHdpdGggZHVtbXkgRE1BIG9wcy4KKwkgKiBUaGlzIG1ha2VzIHRoZSBk ZXZpY2UgcmV0dXJuIGVycm9yIG9uIFBSSU1FIGJ1ZmZlciBpbXBvcnQsIHdoaWNoCisJICogaXMg bm90IGNvcnJlY3Q6IHRvIGZpeCB0aGlzIGNhbGwgb2ZfZG1hX2NvbmZpZ3VyZSgpIHdpdGggYSBO VUxMCisJICogbm9kZSB0byBzZXQgZGVmYXVsdCBETUEgb3BzLgorCSAqLworCWRldi0+YnVzLT5m b3JjZV9kbWEgPSB0cnVlOworCWRldi0+Y29oZXJlbnRfZG1hX21hc2sgPSBETUFfQklUX01BU0so MzIpOworCXJldCA9IG9mX2RtYV9jb25maWd1cmUoZGV2LCBOVUxMKTsKKwlpZiAocmV0IDwgMCkg eworCQlEUk1fRVJST1IoIkNhbm5vdCBzZXR1cCBETUEgb3BzLCByZXQgJWQiLCByZXQpOworCQly ZXR1cm4gcmV0OworCX0KKworCWZyb250X2luZm8gPSBkZXZtX2t6YWxsb2MoJnhiX2Rldi0+ZGV2 LAorCQkJc2l6ZW9mKCpmcm9udF9pbmZvKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFmcm9udF9pbmZv KQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZyb250X2luZm8tPnhiX2RldiA9IHhiX2RldjsKKwlz cGluX2xvY2tfaW5pdCgmZnJvbnRfaW5mby0+aW9fbG9jayk7CisJSU5JVF9MSVNUX0hFQUQoJmZy b250X2luZm8tPmRidWZfbGlzdCk7CisJZGV2X3NldF9kcnZkYXRhKCZ4Yl9kZXYtPmRldiwgZnJv bnRfaW5mbyk7CisKKwlyZXR1cm4geGVuYnVzX3N3aXRjaF9zdGF0ZSh4Yl9kZXYsIFhlbmJ1c1N0 YXRlSW5pdGlhbGlzaW5nKTsKK30KKworc3RhdGljIGludCB4ZW5fZHJ2X3JlbW92ZShzdHJ1Y3Qg eGVuYnVzX2RldmljZSAqZGV2KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8gPSBkZXZfZ2V0X2RydmRhdGEoJmRldi0+ZGV2KTsKKwlpbnQgdG8gPSAxMDA7CisKKwl4 ZW5idXNfc3dpdGNoX3N0YXRlKGRldiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsKKworCS8qCisJICog T24gZHJpdmVyIHJlbW92YWwgaXQgaXMgZGlzY29ubmVjdGVkIGZyb20gWGVuQnVzLAorCSAqIHNv IG5vIGJhY2tlbmQgc3RhdGUgY2hhbmdlIGV2ZW50cyBjb21lIHZpYSAub3RoZXJlbmRfY2hhbmdl ZAorCSAqIGNhbGxiYWNrLiBUaGlzIHByZXZlbnRzIHVzIGZyb20gZXhpdGluZyBncmFjZWZ1bGx5 LCBlLmcuCisJICogc2lnbmFsaW5nIHRoZSBiYWNrZW5kIHRvIGZyZWUgZXZlbnQgY2hhbm5lbHMs IHdhaXRpbmcgZm9yIGl0cworCSAqIHN0YXRlIHRvIGNoYW5nZSB0byBYZW5idXNTdGF0ZUNsb3Nl ZCBhbmQgY2xlYW5pbmcgYXQgb3VyIGVuZC4KKwkgKiBOb3JtYWxseSB3aGVuIGZyb250IGRyaXZl ciByZW1vdmVkIGJhY2tlbmQgd2lsbCBmaW5hbGx5IGdvIGludG8KKwkgKiBYZW5idXNTdGF0ZUlu aXRXYWl0IHN0YXRlLgorCSAqCisJICogV29ya2Fyb3VuZDogcmVhZCBiYWNrZW5kJ3Mgc3RhdGUg bWFudWFsbHkgYW5kIHdhaXQgd2l0aCB0aW1lLW91dC4KKwkgKi8KKwl3aGlsZSAoKHhlbmJ1c19y ZWFkX3Vuc2lnbmVkKGZyb250X2luZm8tPnhiX2Rldi0+b3RoZXJlbmQsCisJCQkic3RhdGUiLCBY ZW5idXNTdGF0ZVVua25vd24pICE9IFhlbmJ1c1N0YXRlSW5pdFdhaXQpICYmCisJCQl0by0tKQor CQltc2xlZXAoMTApOworCisJaWYgKCF0bykgeworCQl1bnNpZ25lZCBpbnQgc3RhdGU7CisKKwkJ c3RhdGUgPSB4ZW5idXNfcmVhZF91bnNpZ25lZChmcm9udF9pbmZvLT54Yl9kZXYtPm90aGVyZW5k LAorCQkJCSJzdGF0ZSIsIFhlbmJ1c1N0YXRlVW5rbm93bik7CisJCURSTV9FUlJPUigiQmFja2Vu ZCBzdGF0ZSBpcyAlcyB3aGlsZSByZW1vdmluZyBkcml2ZXJcbiIsCisJCQkJeGVuYnVzX3N0cnN0 YXRlKHN0YXRlKSk7CisJfQorCisJeGVuX2RybV9kcnZfZmluaShmcm9udF9pbmZvKTsKKwl4ZW5i dXNfZnJvbnRlbmRfY2xvc2VkKGRldik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgeGVuYnVzX2RldmljZV9pZCB4ZW5fZHJpdmVyX2lkc1tdID0geworCXsgWEVORElTUExf RFJJVkVSX05BTUUgfSwKKwl7ICIiIH0KK307CisKK3N0YXRpYyBzdHJ1Y3QgeGVuYnVzX2RyaXZl ciB4ZW5fZHJpdmVyID0geworCS5pZHMgPSB4ZW5fZHJpdmVyX2lkcywKKwkucHJvYmUgPSB4ZW5f ZHJ2X3Byb2JlLAorCS5yZW1vdmUgPSB4ZW5fZHJ2X3JlbW92ZSwKKwkub3RoZXJlbmRfY2hhbmdl ZCA9IGRpc3BsYmFja19jaGFuZ2VkLAorfTsKKworc3RhdGljIGludCBfX2luaXQgeGVuX2Rydl9p bml0KHZvaWQpCit7CisJLyogQXQgdGhlIG1vbWVudCB3ZSBvbmx5IHN1cHBvcnQgY2FzZSB3aXRo IFhFTl9QQUdFX1NJWkUgPT0gUEFHRV9TSVpFICovCisJaWYgKFhFTl9QQUdFX1NJWkUgIT0gUEFH RV9TSVpFKSB7CisJCURSTV9FUlJPUihYRU5ESVNQTF9EUklWRVJfTkFNRSAiOiBkaWZmZXJlbnQg a2VybmVsIGFuZCBYZW4gcGFnZSBzaXplcyBhcmUgbm90IHN1cHBvcnRlZDogWEVOX1BBR0VfU0la RSAoJWx1KSAhPSBQQUdFX1NJWkUgKCVsdSlcbiIsCisJCQkJWEVOX1BBR0VfU0laRSwgUEFHRV9T SVpFKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJaWYgKCF4ZW5fZG9tYWluKCkpCisJCXJl dHVybiAtRU5PREVWOworCisJaWYgKCF4ZW5faGFzX3B2X2RldmljZXMoKSkKKwkJcmV0dXJuIC1F Tk9ERVY7CisKKwlEUk1fSU5GTygiUmVnaXN0ZXJpbmcgWEVOIFBWICIgWEVORElTUExfRFJJVkVS X05BTUUgIlxuIik7CisJcmV0dXJuIHhlbmJ1c19yZWdpc3Rlcl9mcm9udGVuZCgmeGVuX2RyaXZl cik7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCB4ZW5fZHJ2X2Zpbmkodm9pZCkKK3sKKwlEUk1f SU5GTygiVW5yZWdpc3RlcmluZyBYRU4gUFYgIiBYRU5ESVNQTF9EUklWRVJfTkFNRSAiXG4iKTsK Kwl4ZW5idXNfdW5yZWdpc3Rlcl9kcml2ZXIoJnhlbl9kcml2ZXIpOworfQorCittb2R1bGVfaW5p dCh4ZW5fZHJ2X2luaXQpOworbW9kdWxlX2V4aXQoeGVuX2Rydl9maW5pKTsKKworTU9EVUxFX0RF U0NSSVBUSU9OKCJYZW4gcGFyYS12aXJ0dWFsaXplZCBkaXNwbGF5IGRldmljZSBmcm9udGVuZCIp OworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0FMSUFTKCJ4ZW46IiBYRU5ESVNQTF9E UklWRVJfTkFNRSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnQuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNzkxMjM5ZDNjMzRmCi0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKQEAgLTAsMCArMSwxODggQEAK Ky8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICog IFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0y MDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNo ZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBf X1hFTl9EUk1fRlJPTlRfSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0hfCisKKyNpbmNsdWRl IDxkcm0vZHJtUC5oPgorI2luY2x1ZGUgPGRybS9kcm1fc2ltcGxlX2ttc19oZWxwZXIuaD4KKwor I2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250 X2NmZy5oIgorCisvKioKKyAqIERPQzogRHJpdmVyIG1vZGVzIG9mIG9wZXJhdGlvbiBpbiB0ZXJt cyBvZiBkaXNwbGF5IGJ1ZmZlcnMgdXNlZAorICoKKyAqIERlcGVuZGluZyBvbiB0aGUgcmVxdWly ZW1lbnRzIGZvciB0aGUgcGFyYS12aXJ0dWFsaXplZCBlbnZpcm9ubWVudCwgbmFtZWx5CisgKiBy ZXF1aXJlbWVudHMgZGljdGF0ZWQgYnkgdGhlIGFjY29tcGFueWluZyBEUk0vKHYpR1BVIGRyaXZl cnMgcnVubmluZyBpbiBib3RoCisgKiBob3N0IGFuZCBndWVzdCBlbnZpcm9ubWVudHMsIG51bWJl ciBvZiBvcGVyYXRpbmcgbW9kZXMgb2YgcGFyYS12aXJ0dWFsaXplZAorICogZGlzcGxheSBkcml2 ZXIgYXJlIHN1cHBvcnRlZDoKKyAqCisgKiAtIGRpc3BsYXkgYnVmZmVycyBjYW4gYmUgYWxsb2Nh dGVkIGJ5IGVpdGhlciBmcm9udGVuZCBkcml2ZXIgb3IgYmFja2VuZAorICogLSBkaXNwbGF5IGJ1 ZmZlcnMgY2FuIGJlIGFsbG9jYXRlZCB0byBiZSBjb250aWd1b3VzIGluIG1lbW9yeSBvciBub3QK KyAqCisgKiBOb3RlISBGcm9udGVuZCBkcml2ZXIgaXRzZWxmIGhhcyBubyBkZXBlbmRlbmN5IG9u IGNvbnRpZ3VvdXMgbWVtb3J5IGZvcgorICogaXRzIG9wZXJhdGlvbi4KKyAqLworCisvKioKKyAq IERPQzogQnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGZyb250ZW5kIGRyaXZlcgorICoKKyAqIFRo ZSBiZWxvdyBtb2RlcyBvZiBvcGVyYXRpb24gYXJlIGNvbmZpZ3VyZWQgYXQgY29tcGlsZS10aW1l IHZpYQorICogZnJvbnRlbmQgZHJpdmVyJ3Mga2VybmVsIGNvbmZpZ3VyYXRpb246CisgKi8KKwor LyoqCisgKiBET0M6IFdpdGggR0VNIENNQSBoZWxwZXJzCisgKgorICogVGhpcyB1c2UtY2FzZSBp cyB1c2VmdWwgd2hlbiB1c2VkIHdpdGggYWNjb21wYW55aW5nIERSTS92R1BVIGRyaXZlciBpbgor ICogZ3Vlc3QgZG9tYWluIHdoaWNoIHdhcyBkZXNpZ25lZCB0byBvbmx5IHdvcmsgd2l0aCBjb250 aWd1b3VzIGJ1ZmZlcnMsCisgKiBlLmcuIERSTSBkcml2ZXIgYmFzZWQgb24gR0VNIENNQSBoZWxw ZXJzOiBzdWNoIGRyaXZlcnMgY2FuIG9ubHkgaW1wb3J0CisgKiBjb250aWd1b3VzIFBSSU1FIGJ1 ZmZlcnMsIHRodXMgcmVxdWlyaW5nIGZyb250ZW5kIGRyaXZlciB0byBwcm92aWRlCisgKiBzdWNo LiBJbiBvcmRlciB0byBpbXBsZW1lbnQgdGhpcyBtb2RlIG9mIG9wZXJhdGlvbiBwYXJhLXZpcnR1 YWxpemVkCisgKiBmcm9udGVuZCBkcml2ZXIgY2FuIGJlIGNvbmZpZ3VyZWQgdG8gdXNlIEdFTSBD TUEgaGVscGVycy4KKyAqLworCisvKioKKyAqIERPQzogV2l0aG91dCBHRU0gQ01BIGhlbHBlcnMK KyAqCisgKiBJZiBhY2NvbXBhbnlpbmcgZHJpdmVycyBjYW4gY29wZSB3aXRoIG5vbi1jb250aWd1 b3VzIG1lbW9yeSB0aGVuLCB0bworICogbG93ZXIgcHJlc3N1cmUgb24gQ01BIHN1YnN5c3RlbSBv ZiB0aGUga2VybmVsLCBkcml2ZXIgY2FuIGFsbG9jYXRlCisgKiBidWZmZXJzIGZyb20gc3lzdGVt IG1lbW9yeS4KKyAqCisgKiBOb3RlISBJZiB1c2VkIHdpdGggYWNjb21wYW55aW5nIERSTS8odilH UFUgZHJpdmVycyB0aGlzIG1vZGUgb2Ygb3BlcmF0aW9uCisgKiBtYXkgcmVxdWlyZSBJT01NVSBz dXBwb3J0IG9uIHRoZSBwbGF0Zm9ybSwgc28gYWNjb21wYW55aW5nIERSTS92R1BVCisgKiBoYXJk d2FyZSBjYW4gc3RpbGwgcmVhY2ggZGlzcGxheSBidWZmZXIgbWVtb3J5IHdoaWxlIGltcG9ydGlu ZyBQUklNRQorICogYnVmZmVycyBmcm9tIHRoZSBmcm9udGVuZCBkcml2ZXIuCisgKi8KKworLyoq CisgKiBET0M6IEJ1ZmZlcnMgYWxsb2NhdGVkIGJ5IHRoZSBiYWNrZW5kCisgKgorICogVGhpcyBt b2RlIG9mIG9wZXJhdGlvbiBpcyBydW4tdGltZSBjb25maWd1cmVkIHZpYSBndWVzdCBkb21haW4g Y29uZmlndXJhdGlvbgorICogdGhyb3VnaCBYZW5TdG9yZSBlbnRyaWVzLgorICoKKyAqIEZvciBz eXN0ZW1zIHdoaWNoIGRvIG5vdCBwcm92aWRlIElPTU1VIHN1cHBvcnQsIGJ1dCBoYXZpbmcgc3Bl Y2lmaWMKKyAqIHJlcXVpcmVtZW50cyBmb3IgZGlzcGxheSBidWZmZXJzIGl0IGlzIHBvc3NpYmxl IHRvIGFsbG9jYXRlIHN1Y2ggYnVmZmVycworICogYXQgYmFja2VuZCBzaWRlIGFuZCBzaGFyZSB0 aG9zZSB3aXRoIHRoZSBmcm9udGVuZC4KKyAqIEZvciBleGFtcGxlLCBpZiBob3N0IGRvbWFpbiBp cyAxOjEgbWFwcGVkIGFuZCBoYXMgRFJNL0dQVSBoYXJkd2FyZSBleHBlY3RpbmcKKyAqIHBoeXNp Y2FsbHkgY29udGlndW91cyBtZW1vcnksIHRoaXMgYWxsb3dzIGltcGxlbWVudGluZyB6ZXJvLWNv cHlpbmcKKyAqIHVzZS1jYXNlcy4KKyAqCisgKiBOb3RlLCB3aGlsZSB1c2luZyB0aGlzIHNjZW5h cmlvIHRoZSBmb2xsb3dpbmcgc2hvdWxkIGJlIGNvbnNpZGVyZWQ6CisgKgorICogIy4gSWYgZ3Vl c3QgZG9tYWluIGRpZXMgdGhlbiBwYWdlcy9ncmFudHMgcmVjZWl2ZWQgZnJvbSB0aGUgYmFja2Vu ZAorICogICAgY2Fubm90IGJlIGNsYWltZWQgYmFjaworICoKKyAqICMuIE1pc2JlaGF2aW5nIGd1 ZXN0IG1heSBzZW5kIHRvbyBtYW55IHJlcXVlc3RzIHRvIHRoZQorICogICAgYmFja2VuZCBleGhh dXN0aW5nIGl0cyBncmFudCByZWZlcmVuY2VzIGFuZCBtZW1vcnkKKyAqICAgIChjb25zaWRlciB0 aGlzIGZyb20gc2VjdXJpdHkgUE9WKQorICovCisKKy8qKgorICogRE9DOiBEcml2ZXIgbGltaXRh dGlvbnMKKyAqCisgKiAjLiBPbmx5IHByaW1hcnkgcGxhbmUgd2l0aG91dCBhZGRpdGlvbmFsIHBy b3BlcnRpZXMgaXMgc3VwcG9ydGVkLgorICoKKyAqICMuIE9ubHkgb25lIHZpZGVvIG1vZGUgcGVy IGNvbm5lY3RvciBzdXBwb3J0ZWQgd2hpY2ggaXMgY29uZmlndXJlZAorICogICAgdmlhIFhlblN0 b3JlLgorICoKKyAqICMuIEFsbCBDUlRDcyBvcGVyYXRlIGF0IGZpeGVkIGZyZXF1ZW5jeSBvZiA2 MEh6LgorICovCisKKy8qIHRpbWVvdXQgaW4gbXMgdG8gd2FpdCBmb3IgYmFja2VuZCB0byByZXNw b25kICovCisjZGVmaW5lIFhFTl9EUk1fRlJPTlRfV0FJVF9CQUNLX01TCTMwMDAKKworI2lmbmRl ZiBHUkFOVF9JTlZBTElEX1JFRgorLyoKKyAqIE5vdGUgb24gdXNhZ2Ugb2YgZ3JhbnQgcmVmZXJl bmNlIDAgYXMgaW52YWxpZCBncmFudCByZWZlcmVuY2U6CisgKiBncmFudCByZWZlcmVuY2UgMCBp cyB2YWxpZCwgYnV0IG5ldmVyIGV4cG9zZWQgdG8gYSBQViBkcml2ZXIsCisgKiBiZWNhdXNlIG9m IHRoZSBmYWN0IGl0IGlzIGFscmVhZHkgaW4gdXNlL3Jlc2VydmVkIGJ5IHRoZSBQViBjb25zb2xl LgorICovCisjZGVmaW5lIEdSQU5UX0lOVkFMSURfUkVGCTAKKyNlbmRpZgorCitzdHJ1Y3QgeGVu X2RybV9mcm9udF9pbmZvIHsKKwlzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2OworCXN0cnVj dCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbzsKKworCS8qIHRvIHByb3RlY3QgZGF0 YSBiZXR3ZWVuIGJhY2tlbmQgSU8gY29kZSBhbmQgaW50ZXJydXB0IGhhbmRsZXIgKi8KKwlzcGlu bG9ja190IGlvX2xvY2s7CisKKwlpbnQgbnVtX2V2dF9wYWlyczsKKwlzdHJ1Y3QgeGVuX2RybV9m cm9udF9ldnRjaG5sX3BhaXIgKmV2dF9wYWlyczsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcg Y2ZnOworCisJLyogZGlzcGxheSBidWZmZXJzICovCisJc3RydWN0IGxpc3RfaGVhZCBkYnVmX2xp c3Q7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgeworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbzsKKworCWludCBpbmRleDsKKworCXN0cnVj dCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSBwaXBlOworCisJc3RydWN0IGRybV9jb25uZWN0b3Ig Y29ubjsKKwkvKiBUaGVzZSBhcmUgb25seSBmb3IgY29ubmVjdG9yIG1vZGUgY2hlY2tpbmcgKi8K KwlpbnQgd2lkdGgsIGhlaWdodDsKKworCXN0cnVjdCBkcm1fcGVuZGluZ192YmxhbmtfZXZlbnQg KnBlbmRpbmdfZXZlbnQ7CisKKwlzdHJ1Y3QgZGVsYXllZF93b3JrIHBmbGlwX3RvX3dvcmtlcjsK KworCWJvb2wgY29ubl9jb25uZWN0ZWQ7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1f aW5mbyB7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwlzdHJ1Y3Qg ZHJtX2RldmljZSAqZHJtX2RldjsKKworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGlu ZSBwaXBlbGluZVtYRU5fRFJNX0ZST05UX01BWF9DUlRDU107Cit9OworCitzdGF0aWMgaW5saW5l IHU2NCB4ZW5fZHJtX2Zyb250X2ZiX3RvX2Nvb2tpZShzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpm YikKK3sKKwlyZXR1cm4gKHU2NClmYjsKK30KKworc3RhdGljIGlubGluZSB1NjQgeGVuX2RybV9m cm9udF9kYnVmX3RvX2Nvb2tpZShzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJ cmV0dXJuICh1NjQpZ2VtX29iajsKK30KKworaW50IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQoc3Ry dWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSwKKwkJdTMyIHgsIHUzMiB5 LCB1MzIgd2lkdGgsIHUzMiBoZWlnaHQsCisJCXUzMiBicHAsIHU2NCBmYl9jb29raWUpOworCitp bnQgeGVuX2RybV9mcm9udF9kYnVmX2NyZWF0ZV9mcm9tX3NndChzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvLAorCQl1NjQgZGJ1Zl9jb29raWUsIHUzMiB3aWR0aCwgdTMyIGhl aWdodCwKKwkJdTMyIGJwcCwgdTY0IHNpemUsIHN0cnVjdCBzZ190YWJsZSAqc2d0KTsKKworaW50 IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9wYWdlcyhzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvLAorCQl1NjQgZGJ1Zl9jb29raWUsIHUzMiB3aWR0aCwgdTMyIGhl aWdodCwKKwkJdTMyIGJwcCwgdTY0IHNpemUsIHN0cnVjdCBwYWdlICoqcGFnZXMpOworCitpbnQg eGVuX2RybV9mcm9udF9mYl9hdHRhY2goc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRf aW5mbywKKwkJdTY0IGRidWZfY29va2llLCB1NjQgZmJfY29va2llLCB1MzIgd2lkdGgsCisJCXUz MiBoZWlnaHQsIHUzMiBwaXhlbF9mb3JtYXQpOworCitpbnQgeGVuX2RybV9mcm9udF9mYl9kZXRh Y2goc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJdTY0IGZiX2Nvb2tp ZSk7CisKK2ludCB4ZW5fZHJtX2Zyb250X3BhZ2VfZmxpcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9p bmZvICpmcm9udF9pbmZvLAorCQlpbnQgY29ubl9pZHgsIHU2NCBmYl9jb29raWUpOworCit2b2lk IHhlbl9kcm1fZnJvbnRfb25fZnJhbWVfZG9uZShzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpm cm9udF9pbmZvLAorCQlpbnQgY29ubl9pZHgsIHU2NCBmYl9jb29raWUpOworCisjZW5kaWYgLyog X19YRU5fRFJNX0ZST05UX0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnRfY2ZnLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2Zn LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45YTBiMmI4ZTYxNjkK LS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2Zn LmMKQEAgLTAsMCArMSw3NyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAg T1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29w eXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9s ZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4K KyAqLworCisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKworI2luY2x1ZGUgPGxpbnV4L2RldmljZS5o PgorCisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CisjaW5jbHVkZSA8eGVu L3hlbmJ1cy5oPgorCisjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9k cm1fZnJvbnRfY2ZnLmgiCisKK3N0YXRpYyBpbnQgY2ZnX2Nvbm5lY3RvcihzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmdfY29u bmVjdG9yICpjb25uZWN0b3IsCisJCWNvbnN0IGNoYXIgKnBhdGgsIGludCBpbmRleCkKK3sKKwlj aGFyICpjb25uZWN0b3JfcGF0aDsKKworCWNvbm5lY3Rvcl9wYXRoID0gZGV2bV9rYXNwcmludGYo JmZyb250X2luZm8tPnhiX2Rldi0+ZGV2LAorCQkJR0ZQX0tFUk5FTCwgIiVzLyVkIiwgcGF0aCwg aW5kZXgpOworCWlmICghY29ubmVjdG9yX3BhdGgpCisJCXJldHVybiAtRU5PTUVNOworCisJaWYg KHhlbmJ1c19zY2FuZihYQlRfTklMLCBjb25uZWN0b3JfcGF0aCwgWEVORElTUExfRklFTERfUkVT T0xVVElPTiwKKwkJCSIlZCIgWEVORElTUExfUkVTT0xVVElPTl9TRVBBUkFUT1IgIiVkIiwKKwkJ CSZjb25uZWN0b3ItPndpZHRoLCAmY29ubmVjdG9yLT5oZWlnaHQpIDwgMCkgeworCQkvKiBlaXRo ZXIgbm8gZW50cnkgY29uZmlndXJlZCBvciB3cm9uZyByZXNvbHV0aW9uIHNldCAqLworCQljb25u ZWN0b3ItPndpZHRoID0gMDsKKwkJY29ubmVjdG9yLT5oZWlnaHQgPSAwOworCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwljb25uZWN0b3ItPnhlbnN0b3JlX3BhdGggPSBjb25uZWN0b3JfcGF0aDsK KworCURSTV9JTkZPKCJDb25uZWN0b3IgJXM6IHJlc29sdXRpb24gJWR4JWRcbiIsCisJCQljb25u ZWN0b3JfcGF0aCwgY29ubmVjdG9yLT53aWR0aCwgY29ubmVjdG9yLT5oZWlnaHQpOworCXJldHVy biAwOworfQorCitpbnQgeGVuX2RybV9mcm9udF9jZmdfY2FyZChzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvLAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgKmNmZykKK3sK KwlzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2ID0gZnJvbnRfaW5mby0+eGJfZGV2OworCWlu dCByZXQsIGk7CisKKwlpZiAoeGVuYnVzX3JlYWRfdW5zaWduZWQoZnJvbnRfaW5mby0+eGJfZGV2 LT5ub2RlbmFtZSwKKwkJCVhFTkRJU1BMX0ZJRUxEX0JFX0FMTE9DLCAwKSkgeworCQlEUk1fSU5G TygiQmFja2VuZCBjYW4gcHJvdmlkZSBkaXNwbGF5IGJ1ZmZlcnNcbiIpOworCQljZmctPmJlX2Fs bG9jID0gdHJ1ZTsKKwl9CisKKwljZmctPm51bV9jb25uZWN0b3JzID0gMDsKKwlmb3IgKGkgPSAw OyBpIDwgQVJSQVlfU0laRShjZmctPmNvbm5lY3RvcnMpOyBpKyspIHsKKwkJcmV0ID0gY2ZnX2Nv bm5lY3Rvcihmcm9udF9pbmZvLAorCQkJCSZjZmctPmNvbm5lY3RvcnNbaV0sIHhiX2Rldi0+bm9k ZW5hbWUsIGkpOworCQlpZiAocmV0IDwgMCkKKwkJCWJyZWFrOworCQljZmctPm51bV9jb25uZWN0 b3JzKys7CisJfQorCisJaWYgKCFjZmctPm51bV9jb25uZWN0b3JzKSB7CisJCURSTV9FUlJPUigi Tm8gY29ubmVjdG9yKHMpIGNvbmZpZ3VyZWQgYXQgJXNcbiIsCisJCQkJeGJfZGV2LT5ub2RlbmFt ZSk7CisJCXJldHVybiAtRU5PREVWOworCX0KKworCXJldHVybiAwOworfQorCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmggYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi42ZTdhZjY3MGY4Y2QKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnRfY2ZnLmgKQEAgLTAsMCArMSwzNyBAQAorLyogU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEtdmly dHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0 ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2Fu ZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9O VF9DRkdfSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0NGR19IXworCisjaW5jbHVkZSA8bGlu dXgvdHlwZXMuaD4KKworI2RlZmluZSBYRU5fRFJNX0ZST05UX01BWF9DUlRDUwk0CisKK3N0cnVj dCB4ZW5fZHJtX2Zyb250X2NmZ19jb25uZWN0b3IgeworCWludCB3aWR0aDsKKwlpbnQgaGVpZ2h0 OworCWNoYXIgKnhlbnN0b3JlX3BhdGg7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcg eworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm87CisJLyogbnVtYmVyIG9m IGNvbm5lY3RvcnMgaW4gdGhpcyBjb25maWd1cmF0aW9uICovCisJaW50IG51bV9jb25uZWN0b3Jz OworCS8qIGNvbm5lY3RvciBjb25maWd1cmF0aW9ucyAqLworCXN0cnVjdCB4ZW5fZHJtX2Zyb250 X2NmZ19jb25uZWN0b3IgY29ubmVjdG9yc1tYRU5fRFJNX0ZST05UX01BWF9DUlRDU107CisJLyog c2V0IGlmIGR1bWIgYnVmZmVycyBhcmUgYWxsb2NhdGVkIGV4dGVybmFsbHkgb24gYmFja2VuZCBz aWRlICovCisJYm9vbCBiZV9hbGxvYzsKK307CisKK2ludCB4ZW5fZHJtX2Zyb250X2NmZ19jYXJk KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJt X2Zyb250X2NmZyAqY2ZnKTsKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9DRkdfSF8gKi8K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmMgYi9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5jCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMjUyMTZkOTlkMWZjCi0tLSAvZGV2L251bGwKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uYwpAQCAtMCwwICsxLDExNSBA QAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAg WGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIw MTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hl bmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8 ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5o PgorCisjaW5jbHVkZSA8dmlkZW8vdmlkZW9tb2RlLmg+CisKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zy b250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9jb25uLmgiCisjaW5jbHVkZSAieGVuX2Ry bV9mcm9udF9rbXMuaCIKKworc3RhdGljIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGlu ZSAqCit0b194ZW5fZHJtX3BpcGVsaW5lKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3Ip Cit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihjb25uZWN0b3IsIHN0cnVjdCB4ZW5fZHJtX2Zyb250 X2RybV9waXBlbGluZSwgY29ubik7Cit9CisKK3N0YXRpYyBjb25zdCB1MzIgcGxhbmVfZm9ybWF0 c1tdID0geworCURSTV9GT1JNQVRfUkdCNTY1LAorCURSTV9GT1JNQVRfUkdCODg4LAorCURSTV9G T1JNQVRfWFJHQjg4ODgsCisJRFJNX0ZPUk1BVF9BUkdCODg4OCwKKwlEUk1fRk9STUFUX1hSR0I0 NDQ0LAorCURSTV9GT1JNQVRfQVJHQjQ0NDQsCisJRFJNX0ZPUk1BVF9YUkdCMTU1NSwKKwlEUk1f Rk9STUFUX0FSR0IxNTU1LAorfTsKKworY29uc3QgdTMyICp4ZW5fZHJtX2Zyb250X2Nvbm5fZ2V0 X2Zvcm1hdHMoaW50ICpmb3JtYXRfY291bnQpCit7CisJKmZvcm1hdF9jb3VudCA9IEFSUkFZX1NJ WkUocGxhbmVfZm9ybWF0cyk7CisJcmV0dXJuIHBsYW5lX2Zvcm1hdHM7Cit9CisKK3N0YXRpYyBp bnQgY29ubmVjdG9yX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAorCQlz dHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHggKmN0eCwKKwkJYm9vbCBmb3JjZSkKK3sKKwlz dHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9k cm1fcGlwZWxpbmUoY29ubmVjdG9yKTsKKworCWlmIChkcm1fZGV2X2lzX3VucGx1Z2dlZChjb25u ZWN0b3ItPmRldikpCisJCXBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA9IGZhbHNlOworCisJcmV0 dXJuIHBpcGVsaW5lLT5jb25uX2Nvbm5lY3RlZCA/IGNvbm5lY3Rvcl9zdGF0dXNfY29ubmVjdGVk IDoKKwkJCWNvbm5lY3Rvcl9zdGF0dXNfZGlzY29ubmVjdGVkOworfQorCisjZGVmaW5lIFhFTl9E Uk1fQ1JUQ19WUkVGUkVTSF9IWgk2MAorCitzdGF0aWMgaW50IGNvbm5lY3Rvcl9nZXRfbW9kZXMo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9u dF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUoY29ubmVj dG9yKTsKKwlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZTsKKwlzdHJ1Y3QgdmlkZW9tb2Rl IHZpZGVvbW9kZTsKKwlpbnQgd2lkdGgsIGhlaWdodDsKKworCW1vZGUgPSBkcm1fbW9kZV9jcmVh dGUoY29ubmVjdG9yLT5kZXYpOworCWlmICghbW9kZSkKKwkJcmV0dXJuIDA7CisKKwltZW1zZXQo JnZpZGVvbW9kZSwgMCwgc2l6ZW9mKHZpZGVvbW9kZSkpOworCXZpZGVvbW9kZS5oYWN0aXZlID0g cGlwZWxpbmUtPndpZHRoOworCXZpZGVvbW9kZS52YWN0aXZlID0gcGlwZWxpbmUtPmhlaWdodDsK Kwl3aWR0aCA9IHZpZGVvbW9kZS5oYWN0aXZlICsgdmlkZW9tb2RlLmhmcm9udF9wb3JjaCArCisJ CQl2aWRlb21vZGUuaGJhY2tfcG9yY2ggKyB2aWRlb21vZGUuaHN5bmNfbGVuOworCWhlaWdodCA9 IHZpZGVvbW9kZS52YWN0aXZlICsgdmlkZW9tb2RlLnZmcm9udF9wb3JjaCArCisJCQl2aWRlb21v ZGUudmJhY2tfcG9yY2ggKyB2aWRlb21vZGUudnN5bmNfbGVuOworCXZpZGVvbW9kZS5waXhlbGNs b2NrID0gd2lkdGggKiBoZWlnaHQgKiBYRU5fRFJNX0NSVENfVlJFRlJFU0hfSFo7CisJbW9kZS0+ dHlwZSA9IERSTV9NT0RFX1RZUEVfUFJFRkVSUkVEIHwgRFJNX01PREVfVFlQRV9EUklWRVI7CisK Kwlkcm1fZGlzcGxheV9tb2RlX2Zyb21fdmlkZW9tb2RlKCZ2aWRlb21vZGUsIG1vZGUpOworCWRy bV9tb2RlX3Byb2JlZF9hZGQoY29ubmVjdG9yLCBtb2RlKTsKKwlyZXR1cm4gMTsKK30KKworc3Rh dGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2hlbHBlcl9mdW5jcyBjb25uZWN0b3JfaGVs cGVyX2Z1bmNzID0geworCS5nZXRfbW9kZXMgPSBjb25uZWN0b3JfZ2V0X21vZGVzLAorCS5kZXRl Y3RfY3R4ID0gY29ubmVjdG9yX2RldGVjdCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJt X2Nvbm5lY3Rvcl9mdW5jcyBjb25uZWN0b3JfZnVuY3MgPSB7CisJLmRwbXMgPSBkcm1faGVscGVy X2Nvbm5lY3Rvcl9kcG1zLAorCS5maWxsX21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVf Y29ubmVjdG9yX21vZGVzLAorCS5kZXN0cm95ID0gZHJtX2Nvbm5lY3Rvcl9jbGVhbnVwLAorCS5y ZXNldCA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9yZXNldCwKKwkuYXRvbWljX2R1cGxp Y2F0ZV9zdGF0ZSA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kdXBsaWNhdGVfc3RhdGUs CisJLmF0b21pY19kZXN0cm95X3N0YXRlID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2Rl c3Ryb3lfc3RhdGUsCit9OworCitpbnQgeGVuX2RybV9mcm9udF9jb25uX2luaXQoc3RydWN0IHhl bl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvLAorCQlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq Y29ubmVjdG9yKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlwZWxp bmUgPQorCQkJdG9feGVuX2RybV9waXBlbGluZShjb25uZWN0b3IpOworCisJZHJtX2Nvbm5lY3Rv cl9oZWxwZXJfYWRkKGNvbm5lY3RvciwgJmNvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOworCisJcGlw ZWxpbmUtPmNvbm5fY29ubmVjdGVkID0gdHJ1ZTsKKworCWNvbm5lY3Rvci0+cG9sbGVkID0gRFJN X0NPTk5FQ1RPUl9QT0xMX0NPTk5FQ1QgfAorCQkJRFJNX0NPTk5FQ1RPUl9QT0xMX0RJU0NPTk5F Q1Q7CisKKwlyZXR1cm4gZHJtX2Nvbm5lY3Rvcl9pbml0KGRybV9pbmZvLT5kcm1fZGV2LCBjb25u ZWN0b3IsCisJCSZjb25uZWN0b3JfZnVuY3MsIERSTV9NT0RFX0NPTk5FQ1RPUl9WSVJUVUFMKTsK K30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9jb25uLmgg Yi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfY29ubi5oCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNmQ4ZDRiNzIwZGFlCi0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Nvbm4uaApAQCAtMCwwICsxLDI3 IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoK KyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5k ZWYgX19YRU5fRFJNX0ZST05UX0NPTk5fSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0NPTk5f SF8KKworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjLmg+Cisj aW5jbHVkZSA8ZHJtL2RybV9lbmNvZGVyLmg+CisKKyNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CisK K3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvOworCitpbnQgeGVuX2RybV9mcm9udF9jb25u X2luaXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvLAorCQlzdHJ1Y3Qg ZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKTsKKworY29uc3QgdTMyICp4ZW5fZHJtX2Zyb250X2Nv bm5fZ2V0X2Zvcm1hdHMoaW50ICpmb3JtYXRfY291bnQpOworCisjZW5kaWYgLyogX19YRU5fRFJN X0ZST05UX0NPTk5fSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9ldnRjaG5sLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0 Y2hubC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uY2Y4MzMxNTlm ZTUwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 X2V2dGNobmwuYwpAQCAtMCwwICsxLDM4NiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisg KgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBB dXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0Bl cGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKworI2luY2x1ZGUgPGxpbnV4 L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvaXJxLmg+CisKKyNpbmNsdWRlIDx4ZW4veGVuYnVz Lmg+CisjaW5jbHVkZSA8eGVuL2V2ZW50cy5oPgorI2luY2x1ZGUgPHhlbi9ncmFudF90YWJsZS5o PgorCisjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRf ZXZ0Y2hubC5oIgorCitzdGF0aWMgaXJxcmV0dXJuX3QgZXZ0Y2hubF9pbnRlcnJ1cHRfY3RybChp bnQgaXJxLCB2b2lkICpkZXZfaWQpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAq ZXZ0Y2hubCA9IGRldl9pZDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZv ID0gZXZ0Y2hubC0+ZnJvbnRfaW5mbzsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVzcCAqcmVzcDsKKwlS SU5HX0lEWCBpLCBycDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJaWYgKHVubGlrZWx5KGV2 dGNobmwtPnN0YXRlICE9IEVWVENITkxfU1RBVEVfQ09OTkVDVEVEKSkKKwkJcmV0dXJuIElSUV9I QU5ETEVEOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdz KTsKKworYWdhaW46CisJcnAgPSBldnRjaG5sLT51LnJlcS5yaW5nLnNyaW5nLT5yc3BfcHJvZDsK KwkvKiBlbnN1cmUgd2Ugc2VlIHF1ZXVlZCByZXNwb25zZXMgdXAgdG8gcnAgKi8KKwl2aXJ0X3Jt YigpOworCisJZm9yIChpID0gZXZ0Y2hubC0+dS5yZXEucmluZy5yc3BfY29uczsgaSAhPSBycDsg aSsrKSB7CisJCXJlc3AgPSBSSU5HX0dFVF9SRVNQT05TRSgmZXZ0Y2hubC0+dS5yZXEucmluZywg aSk7CisJCWlmICh1bmxpa2VseShyZXNwLT5pZCAhPSBldnRjaG5sLT5ldnRfaWQpKQorCQkJY29u dGludWU7CisKKwkJc3dpdGNoIChyZXNwLT5vcGVyYXRpb24pIHsKKwkJY2FzZSBYRU5ESVNQTF9P UF9QR19GTElQOgorCQljYXNlIFhFTkRJU1BMX09QX0ZCX0FUVEFDSDoKKwkJY2FzZSBYRU5ESVNQ TF9PUF9GQl9ERVRBQ0g6CisJCWNhc2UgWEVORElTUExfT1BfREJVRl9DUkVBVEU6CisJCWNhc2Ug WEVORElTUExfT1BfREJVRl9ERVNUUk9ZOgorCQljYXNlIFhFTkRJU1BMX09QX1NFVF9DT05GSUc6 CisJCQlldnRjaG5sLT51LnJlcS5yZXNwX3N0YXR1cyA9IHJlc3AtPnN0YXR1czsKKwkJCWNvbXBs ZXRlKCZldnRjaG5sLT51LnJlcS5jb21wbGV0aW9uKTsKKwkJCWJyZWFrOworCisJCWRlZmF1bHQ6 CisJCQlEUk1fRVJST1IoIk9wZXJhdGlvbiAlZCBpcyBub3Qgc3VwcG9ydGVkXG4iLAorCQkJCXJl c3AtPm9wZXJhdGlvbik7CisJCQlicmVhazsKKwkJfQorCX0KKworCWV2dGNobmwtPnUucmVxLnJp bmcucnNwX2NvbnMgPSBpOworCisJaWYgKGkgIT0gZXZ0Y2hubC0+dS5yZXEucmluZy5yZXFfcHJv ZF9wdnQpIHsKKwkJaW50IG1vcmVfdG9fZG87CisKKwkJUklOR19GSU5BTF9DSEVDS19GT1JfUkVT UE9OU0VTKCZldnRjaG5sLT51LnJlcS5yaW5nLAorCQkJCW1vcmVfdG9fZG8pOworCQlpZiAobW9y ZV90b19kbykKKwkJCWdvdG8gYWdhaW47CisJfSBlbHNlIHsKKwkJZXZ0Y2hubC0+dS5yZXEucmlu Zy5zcmluZy0+cnNwX2V2ZW50ID0gaSArIDE7CisJfQorCisJc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJldHVybiBJUlFfSEFORExFRDsKK30K Kworc3RhdGljIGlycXJldHVybl90IGV2dGNobmxfaW50ZXJydXB0X2V2dChpbnQgaXJxLCB2b2lk ICpkZXZfaWQpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCA9IGRl dl9pZDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvID0gZXZ0Y2hubC0+ ZnJvbnRfaW5mbzsKKwlzdHJ1Y3QgeGVuZGlzcGxfZXZlbnRfcGFnZSAqcGFnZSA9IGV2dGNobmwt PnUuZXZ0LnBhZ2U7CisJdTMyIGNvbnMsIHByb2Q7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwor CWlmICh1bmxpa2VseShldnRjaG5sLT5zdGF0ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkp CisJCXJldHVybiBJUlFfSEFORExFRDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZv LT5pb19sb2NrLCBmbGFncyk7CisKKwlwcm9kID0gcGFnZS0+aW5fcHJvZDsKKwkvKiBlbnN1cmUg d2Ugc2VlIHJpbmcgY29udGVudHMgdXAgdG8gcHJvZCAqLworCXZpcnRfcm1iKCk7CisJaWYgKHBy b2QgPT0gcGFnZS0+aW5fY29ucykKKwkJZ290byBvdXQ7CisKKwlmb3IgKGNvbnMgPSBwYWdlLT5p bl9jb25zOyBjb25zICE9IHByb2Q7IGNvbnMrKykgeworCQlzdHJ1Y3QgeGVuZGlzcGxfZXZ0ICpl dmVudDsKKworCQlldmVudCA9ICZYRU5ESVNQTF9JTl9SSU5HX1JFRihwYWdlLCBjb25zKTsKKwkJ aWYgKHVubGlrZWx5KGV2ZW50LT5pZCAhPSBldnRjaG5sLT5ldnRfaWQrKykpCisJCQljb250aW51 ZTsKKworCQlzd2l0Y2ggKGV2ZW50LT50eXBlKSB7CisJCWNhc2UgWEVORElTUExfRVZUX1BHX0ZM SVA6CisJCQl4ZW5fZHJtX2Zyb250X29uX2ZyYW1lX2RvbmUoZnJvbnRfaW5mbywgZXZ0Y2hubC0+ aW5kZXgsCisJCQkJCWV2ZW50LT5vcC5wZ19mbGlwLmZiX2Nvb2tpZSk7CisJCQlicmVhazsKKwkJ fQorCX0KKwlwYWdlLT5pbl9jb25zID0gY29uczsKKwkvKiBlbnN1cmUgcmluZyBjb250ZW50cyAq LworCXZpcnRfd21iKCk7CisKK291dDoKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZmcm9udF9p bmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitzdGF0aWMg dm9pZCBldnRjaG5sX2ZyZWUoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywK KwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCkKK3sKKwl1bnNpZ25lZCBs b25nIHBhZ2UgPSAwOworCisJaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZUQ0hOTF9UWVBFX1JFUSkK KwkJcGFnZSA9ICh1bnNpZ25lZCBsb25nKWV2dGNobmwtPnUucmVxLnJpbmcuc3Jpbmc7CisJZWxz ZSBpZiAoZXZ0Y2hubC0+dHlwZSA9PSBFVlRDSE5MX1RZUEVfRVZUKQorCQlwYWdlID0gKHVuc2ln bmVkIGxvbmcpZXZ0Y2hubC0+dS5ldnQucGFnZTsKKwlpZiAoIXBhZ2UpCisJCXJldHVybjsKKwor CWV2dGNobmwtPnN0YXRlID0gRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQ7CisKKwlpZiAoZXZ0 Y2hubC0+dHlwZSA9PSBFVlRDSE5MX1RZUEVfUkVRKSB7CisJCS8qIHJlbGVhc2UgYWxsIHdobyBz dGlsbCB3YWl0cyBmb3IgcmVzcG9uc2UgaWYgYW55ICovCisJCWV2dGNobmwtPnUucmVxLnJlc3Bf c3RhdHVzID0gLUVJTzsKKwkJY29tcGxldGVfYWxsKCZldnRjaG5sLT51LnJlcS5jb21wbGV0aW9u KTsKKwl9CisKKwlpZiAoZXZ0Y2hubC0+aXJxKQorCQl1bmJpbmRfZnJvbV9pcnFoYW5kbGVyKGV2 dGNobmwtPmlycSwgZXZ0Y2hubCk7CisKKwlpZiAoZXZ0Y2hubC0+cG9ydCkKKwkJeGVuYnVzX2Zy ZWVfZXZ0Y2huKGZyb250X2luZm8tPnhiX2RldiwgZXZ0Y2hubC0+cG9ydCk7CisKKwkvKiBlbmQg YWNjZXNzIGFuZCBmcmVlIHRoZSBwYWdlICovCisJaWYgKGV2dGNobmwtPmdyZWYgIT0gR1JBTlRf SU5WQUxJRF9SRUYpCisJCWdudHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3MoZXZ0Y2hubC0+Z3JlZiwg MCwgcGFnZSk7CisKKwltZW1zZXQoZXZ0Y2hubCwgMCwgc2l6ZW9mKCpldnRjaG5sKSk7Cit9CisK K3N0YXRpYyBpbnQgZXZ0Y2hubF9hbGxvYyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9u dF9pbmZvLCBpbnQgaW5kZXgsCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNo bmwsCisJCWVudW0geGVuX2RybV9mcm9udF9ldnRjaG5sX3R5cGUgdHlwZSkKK3sKKwlzdHJ1Y3Qg eGVuYnVzX2RldmljZSAqeGJfZGV2ID0gZnJvbnRfaW5mby0+eGJfZGV2OworCXVuc2lnbmVkIGxv bmcgcGFnZTsKKwlncmFudF9yZWZfdCBncmVmOworCWlycV9oYW5kbGVyX3QgaGFuZGxlcjsKKwlp bnQgcmV0OworCisJbWVtc2V0KGV2dGNobmwsIDAsIHNpemVvZigqZXZ0Y2hubCkpOworCWV2dGNo bmwtPnR5cGUgPSB0eXBlOworCWV2dGNobmwtPmluZGV4ID0gaW5kZXg7CisJZXZ0Y2hubC0+ZnJv bnRfaW5mbyA9IGZyb250X2luZm87CisJZXZ0Y2hubC0+c3RhdGUgPSBFVlRDSE5MX1NUQVRFX0RJ U0NPTk5FQ1RFRDsKKwlldnRjaG5sLT5ncmVmID0gR1JBTlRfSU5WQUxJRF9SRUY7CisKKwlwYWdl ID0gZ2V0X3plcm9lZF9wYWdlKEdGUF9OT0lPIHwgX19HRlBfSElHSCk7CisJaWYgKCFwYWdlKSB7 CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZmFpbDsKKwl9CisKKwlpZiAodHlwZSA9PSBFVlRD SE5MX1RZUEVfUkVRKSB7CisJCXN0cnVjdCB4ZW5fZGlzcGxpZl9zcmluZyAqc3Jpbmc7CisKKwkJ aW5pdF9jb21wbGV0aW9uKCZldnRjaG5sLT51LnJlcS5jb21wbGV0aW9uKTsKKwkJbXV0ZXhfaW5p dCgmZXZ0Y2hubC0+dS5yZXEucmVxX2lvX2xvY2spOworCQlzcmluZyA9IChzdHJ1Y3QgeGVuX2Rp c3BsaWZfc3JpbmcgKilwYWdlOworCQlTSEFSRURfUklOR19JTklUKHNyaW5nKTsKKwkJRlJPTlRf UklOR19JTklUKCZldnRjaG5sLT51LnJlcS5yaW5nLAorCQkJCXNyaW5nLCBYRU5fUEFHRV9TSVpF KTsKKworCQlyZXQgPSB4ZW5idXNfZ3JhbnRfcmluZyh4Yl9kZXYsIHNyaW5nLCAxLCAmZ3JlZik7 CisJCWlmIChyZXQgPCAwKSB7CisJCQlmcmVlX3BhZ2UocGFnZSk7CisJCQlnb3RvIGZhaWw7CisJ CX0KKworCQloYW5kbGVyID0gZXZ0Y2hubF9pbnRlcnJ1cHRfY3RybDsKKwl9IGVsc2UgeworCQll dnRjaG5sLT51LmV2dC5wYWdlID0gKHN0cnVjdCB4ZW5kaXNwbF9ldmVudF9wYWdlICopcGFnZTsK KworCQlyZXQgPSBnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3MoeGJfZGV2LT5vdGhlcmVuZF9p ZCwKKwkJCQl2aXJ0X3RvX2dmbigodm9pZCAqKXBhZ2UpLCAwKTsKKwkJaWYgKHJldCA8IDApIHsK KwkJCWZyZWVfcGFnZShwYWdlKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCisJCWdyZWYgPSByZXQ7 CisJCWhhbmRsZXIgPSBldnRjaG5sX2ludGVycnVwdF9ldnQ7CisJfQorCWV2dGNobmwtPmdyZWYg PSBncmVmOworCisJcmV0ID0geGVuYnVzX2FsbG9jX2V2dGNobih4Yl9kZXYsICZldnRjaG5sLT5w b3J0KTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0gYmluZF9ldnRjaG5f dG9faXJxaGFuZGxlcihldnRjaG5sLT5wb3J0LAorCQkJaGFuZGxlciwgMCwgeGJfZGV2LT5kZXZp Y2V0eXBlLCBldnRjaG5sKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJZXZ0Y2hu bC0+aXJxID0gcmV0OworCXJldHVybiAwOworCitmYWlsOgorCURSTV9FUlJPUigiRmFpbGVkIHRv IGFsbG9jYXRlIHJpbmc6ICVkXG4iLCByZXQpOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5f ZHJtX2Zyb250X2V2dGNobmxfY3JlYXRlX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpm cm9udF9pbmZvKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2ZnOworCWludCByZXQs IGNvbm47CisKKwljZmcgPSAmZnJvbnRfaW5mby0+Y2ZnOworCisJZnJvbnRfaW5mby0+ZXZ0X3Bh aXJzID0ga2NhbGxvYyhjZmctPm51bV9jb25uZWN0b3JzLAorCQkJc2l6ZW9mKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X2V2dGNobmxfcGFpciksIEdGUF9LRVJORUwpOworCWlmICghZnJvbnRfaW5mby0+ ZXZ0X3BhaXJzKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZmFpbDsKKwl9CisKKwlmb3Ig KGNvbm4gPSAwOyBjb25uIDwgY2ZnLT5udW1fY29ubmVjdG9yczsgY29ubisrKSB7CisJCXJldCA9 IGV2dGNobmxfYWxsb2MoZnJvbnRfaW5mbywgY29ubiwKKwkJCQkmZnJvbnRfaW5mby0+ZXZ0X3Bh aXJzW2Nvbm5dLnJlcSwKKwkJCQlFVlRDSE5MX1RZUEVfUkVRKTsKKwkJaWYgKHJldCA8IDApIHsK KwkJCURSTV9FUlJPUigiRXJyb3IgYWxsb2NhdGluZyBjb250cm9sIGNoYW5uZWxcbiIpOworCQkJ Z290byBmYWlsOworCQl9CisKKwkJcmV0ID0gZXZ0Y2hubF9hbGxvYyhmcm9udF9pbmZvLCBjb25u LAorCQkJCSZmcm9udF9pbmZvLT5ldnRfcGFpcnNbY29ubl0uZXZ0LAorCQkJCUVWVENITkxfVFlQ RV9FVlQpOworCQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0VSUk9SKCJFcnJvciBhbGxvY2F0aW5n IGluLWV2ZW50IGNoYW5uZWxcbiIpOworCQkJZ290byBmYWlsOworCQl9CisJfQorCWZyb250X2lu Zm8tPm51bV9ldnRfcGFpcnMgPSBjZmctPm51bV9jb25uZWN0b3JzOworCXJldHVybiAwOworCitm YWlsOgorCXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChmcm9udF9pbmZvKTsKKwlyZXR1 cm4gcmV0OworfQorCitzdGF0aWMgaW50IGV2dGNobmxfcHVibGlzaChzdHJ1Y3QgeGVuYnVzX3Ry YW5zYWN0aW9uIHhidCwKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCwg Y29uc3QgY2hhciAqcGF0aCwKKwkJY29uc3QgY2hhciAqbm9kZV9yaW5nLCBjb25zdCBjaGFyICpu b2RlX2NobmwpCit7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldiA9IGV2dGNobmwtPmZy b250X2luZm8tPnhiX2RldjsKKwlpbnQgcmV0OworCisJLyogd3JpdGUgY29udHJvbCBjaGFubmVs IHJpbmcgcmVmZXJlbmNlICovCisJcmV0ID0geGVuYnVzX3ByaW50Zih4YnQsIHBhdGgsIG5vZGVf cmluZywgIiV1IiwgZXZ0Y2hubC0+Z3JlZik7CisJaWYgKHJldCA8IDApIHsKKwkJeGVuYnVzX2Rl dl9lcnJvcih4Yl9kZXYsIHJldCwgIndyaXRpbmcgcmluZy1yZWYiKTsKKwkJcmV0dXJuIHJldDsK Kwl9CisKKwkvKiB3cml0ZSBldmVudCBjaGFubmVsIHJpbmcgcmVmZXJlbmNlICovCisJcmV0ID0g eGVuYnVzX3ByaW50Zih4YnQsIHBhdGgsIG5vZGVfY2hubCwgIiV1IiwgZXZ0Y2hubC0+cG9ydCk7 CisJaWYgKHJldCA8IDApIHsKKwkJeGVuYnVzX2Rldl9lcnJvcih4Yl9kZXYsIHJldCwgIndyaXRp bmcgZXZlbnQgY2hhbm5lbCIpOworCQlyZXR1cm4gcmV0OworCX0KKworCXJldHVybiAwOworfQor CitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3B1Ymxpc2hfYWxsKHN0cnVjdCB4ZW5fZHJtX2Zy b250X2luZm8gKmZyb250X2luZm8pCit7CisJc3RydWN0IHhlbmJ1c190cmFuc2FjdGlvbiB4YnQ7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpwbGF0X2RhdGE7CisJaW50IHJldCwgY29ubjsK KworCXBsYXRfZGF0YSA9ICZmcm9udF9pbmZvLT5jZmc7CisKK2FnYWluOgorCXJldCA9IHhlbmJ1 c190cmFuc2FjdGlvbl9zdGFydCgmeGJ0KTsKKwlpZiAocmV0IDwgMCkgeworCQl4ZW5idXNfZGV2 X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0LAorCQkJCSJzdGFydGluZyB0cmFuc2FjdGlv biIpOworCQlyZXR1cm4gcmV0OworCX0KKworCWZvciAoY29ubiA9IDA7IGNvbm4gPCBwbGF0X2Rh dGEtPm51bV9jb25uZWN0b3JzOyBjb25uKyspIHsKKwkJcmV0ID0gZXZ0Y2hubF9wdWJsaXNoKHhi dCwKKwkJCQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLnJlcSwKKwkJCQlwbGF0X2RhdGEt PmNvbm5lY3RvcnNbY29ubl0ueGVuc3RvcmVfcGF0aCwKKwkJCQlYRU5ESVNQTF9GSUVMRF9SRVFf UklOR19SRUYsCisJCQkJWEVORElTUExfRklFTERfUkVRX0NIQU5ORUwpOworCQlpZiAocmV0IDwg MCkKKwkJCWdvdG8gZmFpbDsKKworCQlyZXQgPSBldnRjaG5sX3B1Ymxpc2goeGJ0LAorCQkJCSZm cm9udF9pbmZvLT5ldnRfcGFpcnNbY29ubl0uZXZ0LAorCQkJCXBsYXRfZGF0YS0+Y29ubmVjdG9y c1tjb25uXS54ZW5zdG9yZV9wYXRoLAorCQkJCVhFTkRJU1BMX0ZJRUxEX0VWVF9SSU5HX1JFRiwK KwkJCQlYRU5ESVNQTF9GSUVMRF9FVlRfQ0hBTk5FTCk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290 byBmYWlsOworCX0KKworCXJldCA9IHhlbmJ1c190cmFuc2FjdGlvbl9lbmQoeGJ0LCAwKTsKKwlp ZiAocmV0IDwgMCkgeworCQlpZiAocmV0ID09IC1FQUdBSU4pCisJCQlnb3RvIGFnYWluOworCisJ CXhlbmJ1c19kZXZfZmF0YWwoZnJvbnRfaW5mby0+eGJfZGV2LCByZXQsCisJCQkJImNvbXBsZXRp bmcgdHJhbnNhY3Rpb24iKTsKKwkJZ290byBmYWlsX3RvX2VuZDsKKwl9CisKKwlyZXR1cm4gMDsK KworZmFpbDoKKwl4ZW5idXNfdHJhbnNhY3Rpb25fZW5kKHhidCwgMSk7CisKK2ZhaWxfdG9fZW5k OgorCXhlbmJ1c19kZXZfZmF0YWwoZnJvbnRfaW5mby0+eGJfZGV2LCByZXQsICJ3cml0aW5nIFhl biBzdG9yZSIpOworCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5s X2ZsdXNoKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwpCit7CisJaW50IG5v dGlmeTsKKworCWV2dGNobmwtPnUucmVxLnJpbmcucmVxX3Byb2RfcHZ0Kys7CisJUklOR19QVVNI X1JFUVVFU1RTX0FORF9DSEVDS19OT1RJRlkoJmV2dGNobmwtPnUucmVxLnJpbmcsIG5vdGlmeSk7 CisJaWYgKG5vdGlmeSkKKwkJbm90aWZ5X3JlbW90ZV92aWFfaXJxKGV2dGNobmwtPmlycSk7Cit9 CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShzdHJ1Y3QgeGVuX2RybV9m cm9udF9pbmZvICpmcm9udF9pbmZvLAorCQllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zdGF0 ZSBzdGF0ZSkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBpOworCisJaWYgKCFmcm9u dF9pbmZvLT5ldnRfcGFpcnMpCisJCXJldHVybjsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9u dF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJZm9yIChpID0gMDsgaSA8IGZyb250X2luZm8tPm51 bV9ldnRfcGFpcnM7IGkrKykgeworCQlmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0ucmVxLnN0YXRl ID0gc3RhdGU7CisJCWZyb250X2luZm8tPmV2dF9wYWlyc1tpXS5ldnQuc3RhdGUgPSBzdGF0ZTsK Kwl9CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3Mp OworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCWludCBpOworCisJaWYgKCFmcm9udF9pbmZv LT5ldnRfcGFpcnMpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCBmcm9udF9pbmZvLT5u dW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZXZ0Y2hubF9mcmVlKGZyb250X2luZm8sICZmcm9udF9p bmZvLT5ldnRfcGFpcnNbaV0ucmVxKTsKKwkJZXZ0Y2hubF9mcmVlKGZyb250X2luZm8sICZmcm9u dF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0KTsKKwl9CisKKwlrZnJlZShmcm9udF9pbmZvLT5ldnRf cGFpcnMpOworCWZyb250X2luZm8tPmV2dF9wYWlycyA9IE5VTEw7Cit9CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oIGIvZHJpdmVycy9ncHUv ZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLmU0ZWE0ZGYyMmZiNwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmgKQEAgLTAsMCArMSw4MSBAQAorLyog U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVu IHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTgg RVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtv IDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVO X0RSTV9GUk9OVF9FVlRDSE5MX0hfCisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9FVlRDSE5MX0hf CisKKyNpbmNsdWRlIDxsaW51eC9jb21wbGV0aW9uLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMu aD4KKworI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvaW8vcmluZy5oPgorI2luY2x1ZGUgPHhlbi9p bnRlcmZhY2UvaW8vZGlzcGxpZi5oPgorCisvKgorICogQWxsIG9wZXJhdGlvbnMgd2hpY2ggYXJl IG5vdCBjb25uZWN0b3Igb3JpZW50ZWQgdXNlIHRoaXMgY3RybCBldmVudCBjaGFubmVsLAorICog ZS5nLiBmYl9hdHRhY2gvZGVzdHJveSB3aGljaCBiZWxvbmcgdG8gYSBEUk0gZGV2aWNlLCBub3Qg dG8gYSBDUlRDLgorICovCisjZGVmaW5lIEdFTkVSSUNfT1BfRVZUX0NITkwJMAorCitlbnVtIHhl bl9kcm1fZnJvbnRfZXZ0Y2hubF9zdGF0ZSB7CisJRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQs CisJRVZUQ0hOTF9TVEFURV9DT05ORUNURUQsCit9OworCitlbnVtIHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubF90eXBlIHsKKwlFVlRDSE5MX1RZUEVfUkVRLAorCUVWVENITkxfVFlQRV9FVlQsCit9Owor CitzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbzsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRf ZXZ0Y2hubCB7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwlpbnQg Z3JlZjsKKwlpbnQgcG9ydDsKKwlpbnQgaXJxOworCWludCBpbmRleDsKKwllbnVtIHhlbl9kcm1f ZnJvbnRfZXZ0Y2hubF9zdGF0ZSBzdGF0ZTsKKwllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF90 eXBlIHR5cGU7CisJLyogZWl0aGVyIHJlc3BvbnNlIGlkIG9yIGluY29taW5nIGV2ZW50IGlkICov CisJdTE2IGV2dF9pZDsKKwkvKiBuZXh0IHJlcXVlc3QgaWQgb3IgbmV4dCBleHBlY3RlZCBldmVu dCBpZCAqLworCXUxNiBldnRfbmV4dF9pZDsKKwl1bmlvbiB7CisJCXN0cnVjdCB7CisJCQlzdHJ1 Y3QgeGVuX2Rpc3BsaWZfZnJvbnRfcmluZyByaW5nOworCQkJc3RydWN0IGNvbXBsZXRpb24gY29t cGxldGlvbjsKKwkJCS8qIGxhdGVzdCByZXNwb25zZSBzdGF0dXMgKi8KKwkJCWludCByZXNwX3N0 YXR1czsKKwkJCS8qIHNlcmlhbGl6ZXIgZm9yIGJhY2tlbmQgSU86IHJlcXVlc3QvcmVzcG9uc2Ug Ki8KKwkJCXN0cnVjdCBtdXRleCByZXFfaW9fbG9jazsKKwkJfSByZXE7CisJCXN0cnVjdCB7CisJ CQlzdHJ1Y3QgeGVuZGlzcGxfZXZlbnRfcGFnZSAqcGFnZTsKKwkJfSBldnQ7CisJfSB1OworfTsK Kworc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wYWlyIHsKKwlzdHJ1Y3QgeGVuX2RybV9m cm9udF9ldnRjaG5sIHJlcTsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sIGV2dDsKK307 CisKK2ludCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfY3JlYXRlX2FsbChzdHJ1Y3QgeGVuX2RybV9m cm9udF9pbmZvICpmcm9udF9pbmZvKTsKKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wdWJs aXNoX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKTsKKwordm9pZCB4 ZW5fZHJtX2Zyb250X2V2dGNobmxfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAq ZXZ0Y2hubCk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShzdHJ1Y3Qg eGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubF9zdGF0ZSBzdGF0ZSk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2ZyZWVfYWxs KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pOworCisjZW5kaWYgLyogX19Y RU5fRFJNX0ZST05UX0VWVENITkxfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udF9nZW0uYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9u dF9nZW0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjUxMDE5YmVj YTI5ZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9u dF9nZW0uYwpAQCAtMCwwICsxLDMxMSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNlCisgKgor ICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisgKiBBdXRo b3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFt LmNvbT4KKyAqLworCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9nZW0uaCIKKworI2luY2x1ZGUg PGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgorI2luY2x1ZGUg PGRybS9kcm1fZmJfaGVscGVyLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KKworI2luY2x1 ZGUgPGxpbnV4L2RtYS1idWYuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2F0dGVybGlzdC5oPgorI2lu Y2x1ZGUgPGxpbnV4L3NobWVtX2ZzLmg+CisKKyNpbmNsdWRlIDx4ZW4vYmFsbG9vbi5oPgorCisj aW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfc2hidWYu aCIKKworc3RydWN0IHhlbl9nZW1fb2JqZWN0IHsKKwlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgYmFz ZTsKKworCXNpemVfdCBudW1fcGFnZXM7CisJc3RydWN0IHBhZ2UgKipwYWdlczsKKworCS8qIHNl dCBmb3IgYnVmZmVycyBhbGxvY2F0ZWQgYnkgdGhlIGJhY2tlbmQgKi8KKwlib29sIGJlX2FsbG9j OworCisJLyogdGhpcyBpcyBmb3IgaW1wb3J0ZWQgUFJJTUUgYnVmZmVyICovCisJc3RydWN0IHNn X3RhYmxlICpzZ3RfaW1wb3J0ZWQ7Cit9OworCitzdGF0aWMgaW5saW5lIHN0cnVjdCB4ZW5fZ2Vt X29iamVjdCAqCit0b194ZW5fZ2VtX29iaihzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmop Cit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihnZW1fb2JqLCBzdHJ1Y3QgeGVuX2dlbV9vYmplY3Qs IGJhc2UpOworfQorCitzdGF0aWMgaW50IGdlbV9hbGxvY19wYWdlc19hcnJheShzdHJ1Y3QgeGVu X2dlbV9vYmplY3QgKnhlbl9vYmosCisJCXNpemVfdCBidWZfc2l6ZSkKK3sKKwl4ZW5fb2JqLT5u dW1fcGFnZXMgPSBESVZfUk9VTkRfVVAoYnVmX3NpemUsIFBBR0VfU0laRSk7CisJeGVuX29iai0+ cGFnZXMgPSBrdm1hbGxvY19hcnJheSh4ZW5fb2JqLT5udW1fcGFnZXMsCisJCQlzaXplb2Yoc3Ry dWN0IHBhZ2UgKiksIEdGUF9LRVJORUwpOworCXJldHVybiAheGVuX29iai0+cGFnZXMgPyAtRU5P TUVNIDogMDsKK30KKworc3RhdGljIHZvaWQgZ2VtX2ZyZWVfcGFnZXNfYXJyYXkoc3RydWN0IHhl bl9nZW1fb2JqZWN0ICp4ZW5fb2JqKQoreworCWt2ZnJlZSh4ZW5fb2JqLT5wYWdlcyk7CisJeGVu X29iai0+cGFnZXMgPSBOVUxMOworfQorCitzdGF0aWMgc3RydWN0IHhlbl9nZW1fb2JqZWN0ICpn ZW1fY3JlYXRlX29iaihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCXNpemVfdCBzaXplKQorewor CXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsKKwlpbnQgcmV0OworCisJeGVuX29iaiA9 IGt6YWxsb2Moc2l6ZW9mKCp4ZW5fb2JqKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCF4ZW5fb2JqKQor CQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXJldCA9IGRybV9nZW1fb2JqZWN0X2luaXQo ZGV2LCAmeGVuX29iai0+YmFzZSwgc2l6ZSk7CisJaWYgKHJldCA8IDApIHsKKwkJa2ZyZWUoeGVu X29iaik7CisJCXJldHVybiBFUlJfUFRSKHJldCk7CisJfQorCisJcmV0dXJuIHhlbl9vYmo7Cit9 CisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKmdlbV9jcmVhdGUoc3RydWN0IGRybV9k ZXZpY2UgKmRldiwgc2l6ZV90IHNpemUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2lu Zm8gKmRybV9pbmZvID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3Qg Knhlbl9vYmo7CisJaW50IHJldDsKKworCXNpemUgPSByb3VuZF91cChzaXplLCBQQUdFX1NJWkUp OworCXhlbl9vYmogPSBnZW1fY3JlYXRlX29iaihkZXYsIHNpemUpOworCWlmIChJU19FUlJfT1Jf TlVMTCh4ZW5fb2JqKSkKKwkJcmV0dXJuIHhlbl9vYmo7CisKKwlpZiAoZHJtX2luZm8tPmZyb250 X2luZm8tPmNmZy5iZV9hbGxvYykgeworCQkvKgorCQkgKiBiYWNrZW5kIHdpbGwgYWxsb2NhdGUg c3BhY2UgZm9yIHRoaXMgYnVmZmVyLCBzbworCQkgKiBvbmx5IGFsbG9jYXRlIGFycmF5IG9mIHBv aW50ZXJzIHRvIHBhZ2VzCisJCSAqLworCQlyZXQgPSBnZW1fYWxsb2NfcGFnZXNfYXJyYXkoeGVu X29iaiwgc2l6ZSk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsOworCisJCS8qCisJCSAq IGFsbG9jYXRlIGJhbGxvb25lZCBwYWdlcyB3aGljaCB3aWxsIGJlIHVzZWQgdG8gbWFwCisJCSAq IGdyYW50IHJlZmVyZW5jZXMgcHJvdmlkZWQgYnkgdGhlIGJhY2tlbmQKKwkJICovCisJCXJldCA9 IGFsbG9jX3hlbmJhbGxvb25lZF9wYWdlcyh4ZW5fb2JqLT5udW1fcGFnZXMsCisJCQkJeGVuX29i ai0+cGFnZXMpOworCQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0VSUk9SKCJDYW5ub3QgYWxsb2Nh dGUgJXp1IGJhbGxvb25lZCBwYWdlczogJWRcbiIsCisJCQkJCXhlbl9vYmotPm51bV9wYWdlcywg cmV0KTsKKwkJCWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhlbl9vYmopOworCQkJZ290byBmYWlsOwor CQl9CisKKwkJeGVuX29iai0+YmVfYWxsb2MgPSB0cnVlOworCQlyZXR1cm4geGVuX29iajsKKwl9 CisJLyoKKwkgKiBuZWVkIHRvIGFsbG9jYXRlIGJhY2tpbmcgcGFnZXMgbm93LCBzbyB3ZSBjYW4g c2hhcmUgdGhvc2UKKwkgKiB3aXRoIHRoZSBiYWNrZW5kCisJICovCisJeGVuX29iai0+bnVtX3Bh Z2VzID0gRElWX1JPVU5EX1VQKHNpemUsIFBBR0VfU0laRSk7CisJeGVuX29iai0+cGFnZXMgPSBk cm1fZ2VtX2dldF9wYWdlcygmeGVuX29iai0+YmFzZSk7CisJaWYgKElTX0VSUl9PUl9OVUxMKHhl bl9vYmotPnBhZ2VzKSkgeworCQlyZXQgPSBQVFJfRVJSKHhlbl9vYmotPnBhZ2VzKTsKKwkJeGVu X29iai0+cGFnZXMgPSBOVUxMOworCQlnb3RvIGZhaWw7CisJfQorCisJcmV0dXJuIHhlbl9vYmo7 CisKK2ZhaWw6CisJRFJNX0VSUk9SKCJGYWlsZWQgdG8gYWxsb2NhdGUgYnVmZmVyIHdpdGggc2l6 ZSAlenVcbiIsIHNpemUpOworCXJldHVybiBFUlJfUFRSKHJldCk7Cit9CisKK3N0cnVjdCBkcm1f Z2VtX29iamVjdCAqeGVuX2RybV9mcm9udF9nZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCisJCXNpemVfdCBzaXplKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iajsK KworCXhlbl9vYmogPSBnZW1fY3JlYXRlKGRldiwgc2l6ZSk7CisJaWYgKElTX0VSUl9PUl9OVUxM KHhlbl9vYmopKQorCQlyZXR1cm4gRVJSX0NBU1QoeGVuX29iaik7CisKKwlyZXR1cm4gJnhlbl9v YmotPmJhc2U7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9nZW1fZnJlZV9vYmplY3RfdW5sb2Nr ZWQoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXN0cnVjdCB4ZW5fZ2VtX29i amVjdCAqeGVuX29iaiA9IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCisJaWYgKHhlbl9vYmot PmJhc2UuaW1wb3J0X2F0dGFjaCkgeworCQlkcm1fcHJpbWVfZ2VtX2Rlc3Ryb3koJnhlbl9vYmot PmJhc2UsIHhlbl9vYmotPnNndF9pbXBvcnRlZCk7CisJCWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhl bl9vYmopOworCX0gZWxzZSB7CisJCWlmICh4ZW5fb2JqLT5wYWdlcykgeworCQkJaWYgKHhlbl9v YmotPmJlX2FsbG9jKSB7CisJCQkJZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+bnVt X3BhZ2VzLAorCQkJCQkJeGVuX29iai0+cGFnZXMpOworCQkJCWdlbV9mcmVlX3BhZ2VzX2FycmF5 KHhlbl9vYmopOworCQkJfSBlbHNlIHsKKwkJCQlkcm1fZ2VtX3B1dF9wYWdlcygmeGVuX29iai0+ YmFzZSwKKwkJCQkJCXhlbl9vYmotPnBhZ2VzLCB0cnVlLCBmYWxzZSk7CisJCQl9CisJCX0KKwl9 CisJZHJtX2dlbV9vYmplY3RfcmVsZWFzZShnZW1fb2JqKTsKKwlrZnJlZSh4ZW5fb2JqKTsKK30K Kworc3RydWN0IHBhZ2UgKip4ZW5fZHJtX2Zyb250X2dlbV9nZXRfcGFnZXMoc3RydWN0IGRybV9n ZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiA9 IHRvX3hlbl9nZW1fb2JqKGdlbV9vYmopOworCisJcmV0dXJuIHhlbl9vYmotPnBhZ2VzOworfQor CitzdHJ1Y3Qgc2dfdGFibGUgKnhlbl9kcm1fZnJvbnRfZ2VtX2dldF9zZ190YWJsZShzdHJ1Y3Qg ZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCit7CisJc3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5f b2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7CisKKwlpZiAoIXhlbl9vYmotPnBhZ2VzKQor CQlyZXR1cm4gTlVMTDsKKworCXJldHVybiBkcm1fcHJpbWVfcGFnZXNfdG9fc2coeGVuX29iai0+ cGFnZXMsIHhlbl9vYmotPm51bV9wYWdlcyk7Cit9CisKK3N0cnVjdCBkcm1fZ2VtX29iamVjdCAq eGVuX2RybV9mcm9udF9nZW1faW1wb3J0X3NnX3RhYmxlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs CisJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwgc3RydWN0IHNnX3RhYmxlICpz Z3QpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZGV2LT5k ZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmo7CisJc2l6ZV90IHNp emU7CisJaW50IHJldDsKKworCXNpemUgPSBhdHRhY2gtPmRtYWJ1Zi0+c2l6ZTsKKwl4ZW5fb2Jq ID0gZ2VtX2NyZWF0ZV9vYmooZGV2LCBzaXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoeGVuX29i aikpCisJCXJldHVybiBFUlJfQ0FTVCh4ZW5fb2JqKTsKKworCXJldCA9IGdlbV9hbGxvY19wYWdl c19hcnJheSh4ZW5fb2JqLCBzaXplKTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIEVSUl9QVFIo cmV0KTsKKworCXhlbl9vYmotPnNndF9pbXBvcnRlZCA9IHNndDsKKworCXJldCA9IGRybV9wcmlt ZV9zZ190b19wYWdlX2FkZHJfYXJyYXlzKHNndCwgeGVuX29iai0+cGFnZXMsCisJCQlOVUxMLCB4 ZW5fb2JqLT5udW1fcGFnZXMpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gRVJSX1BUUihyZXQp OworCisJLyoKKwkgKiBOLkIuIEFsdGhvdWdoIHdlIGhhdmUgYW4gQVBJIHRvIGNyZWF0ZSBkaXNw bGF5IGJ1ZmZlciBmcm9tIHNndAorCSAqIHdlIHVzZSBwYWdlcyBBUEksIGJlY2F1c2Ugd2Ugc3Rp bGwgbmVlZCB0aG9zZSBmb3IgR0VNIGhhbmRsaW5nLAorCSAqIGUuZy4gZm9yIG1hcHBpbmcgZXRj LgorCSAqLworCXJldCA9IHhlbl9kcm1fZnJvbnRfZGJ1Zl9jcmVhdGVfZnJvbV9wYWdlcyhkcm1f aW5mby0+ZnJvbnRfaW5mbywKKwkJCXhlbl9kcm1fZnJvbnRfZGJ1Zl90b19jb29raWUoJnhlbl9v YmotPmJhc2UpLAorCQkJMCwgMCwgMCwgc2l6ZSwgeGVuX29iai0+cGFnZXMpOworCWlmIChyZXQg PCAwKQorCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCisJRFJNX0RFQlVHKCJJbXBvcnRlZCBidWZm ZXIgb2Ygc2l6ZSAlenUgd2l0aCBuZW50cyAldVxuIiwKKwkJc2l6ZSwgc2d0LT5uZW50cyk7CisK KwlyZXR1cm4gJnhlbl9vYmotPmJhc2U7Cit9CisKK3N0YXRpYyBpbnQgZ2VtX21tYXBfb2JqKHN0 cnVjdCB4ZW5fZ2VtX29iamVjdCAqeGVuX29iaiwKKwkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2 bWEpCit7CisJdW5zaWduZWQgbG9uZyBhZGRyID0gdm1hLT52bV9zdGFydDsKKwlpbnQgaTsKKwor CS8qCisJICogY2xlYXIgdGhlIFZNX1BGTk1BUCBmbGFnIHRoYXQgd2FzIHNldCBieSBkcm1fZ2Vt X21tYXAoKSwgYW5kIHNldCB0aGUKKwkgKiB2bV9wZ29mZiAodXNlZCBhcyBhIGZha2UgYnVmZmVy IG9mZnNldCBieSBEUk0pIHRvIDAgYXMgd2Ugd2FudCB0byBtYXAKKwkgKiB0aGUgd2hvbGUgYnVm ZmVyLgorCSAqLworCXZtYS0+dm1fZmxhZ3MgJj0gflZNX1BGTk1BUDsKKwl2bWEtPnZtX2ZsYWdz IHw9IFZNX01JWEVETUFQOworCXZtYS0+dm1fcGdvZmYgPSAwOworCXZtYS0+dm1fcGFnZV9wcm90 ID0KKwkJCXBncHJvdF93cml0ZWNvbWJpbmUodm1fZ2V0X3BhZ2VfcHJvdCh2bWEtPnZtX2ZsYWdz KSk7CisKKwkvKgorCSAqIHZtX29wZXJhdGlvbnNfc3RydWN0LmZhdWx0IGhhbmRsZXIgd2lsbCBi ZSBjYWxsZWQgaWYgQ1BVIGFjY2VzcworCSAqIHRvIFZNIGlzIGhlcmUuIEZvciBHUFVzIHRoaXMg aXNuJ3QgdGhlIGNhc2UsIGJlY2F1c2UgQ1BVCisJICogZG9lc24ndCB0b3VjaCB0aGUgbWVtb3J5 LiBJbnNlcnQgcGFnZXMgbm93LCBzbyBib3RoIENQVSBhbmQgR1BVIGFyZQorCSAqIGhhcHB5Lgor CSAqIEZJWE1FOiBhcyB3ZSBpbnNlcnQgYWxsIHRoZSBwYWdlcyBub3cgdGhlbiBubyAuZmF1bHQg aGFuZGxlciBtdXN0CisJICogYmUgY2FsbGVkLCBzbyBkb24ndCBwcm92aWRlIG9uZQorCSAqLwor CWZvciAoaSA9IDA7IGkgPCB4ZW5fb2JqLT5udW1fcGFnZXM7IGkrKykgeworCQlpbnQgcmV0Owor CisJCXJldCA9IHZtX2luc2VydF9wYWdlKHZtYSwgYWRkciwgeGVuX29iai0+cGFnZXNbaV0pOwor CQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gaW5zZXJ0IHBhZ2VzIGlu dG8gdm1hOiAlZFxuIiwgcmV0KTsKKwkJCXJldHVybiByZXQ7CisJCX0KKworCQlhZGRyICs9IFBB R0VfU0laRTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2dlbV9tbWFw KHN0cnVjdCBmaWxlICpmaWxwLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1 Y3QgeGVuX2dlbV9vYmplY3QgKnhlbl9vYmo7CisJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1f b2JqOworCWludCByZXQ7CisKKwlyZXQgPSBkcm1fZ2VtX21tYXAoZmlscCwgdm1hKTsKKwlpZiAo cmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKworCWdlbV9vYmogPSB2bWEtPnZtX3ByaXZhdGVfZGF0 YTsKKwl4ZW5fb2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7CisJcmV0dXJuIGdlbV9tbWFw X29iaih4ZW5fb2JqLCB2bWEpOworfQorCit2b2lkICp4ZW5fZHJtX2Zyb250X2dlbV9wcmltZV92 bWFwKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqZ2VtX29iaikKK3sKKwlzdHJ1Y3QgeGVuX2dlbV9v YmplY3QgKnhlbl9vYmogPSB0b194ZW5fZ2VtX29iaihnZW1fb2JqKTsKKworCWlmICgheGVuX29i ai0+cGFnZXMpCisJCXJldHVybiBOVUxMOworCisJcmV0dXJuIHZtYXAoeGVuX29iai0+cGFnZXMs IHhlbl9vYmotPm51bV9wYWdlcywKKwkJCVZNX01BUCwgcGdwcm90X3dyaXRlY29tYmluZShQQUdF X0tFUk5FTCkpOworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZ2VtX3ByaW1lX3Z1bm1hcChzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosCisJCXZvaWQgKnZhZGRyKQoreworCXZ1bm1hcCh2 YWRkcik7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2dlbV9wcmltZV9tbWFwKHN0cnVjdCBkcm1f Z2VtX29iamVjdCAqZ2VtX29iaiwKKwkJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJ c3RydWN0IHhlbl9nZW1fb2JqZWN0ICp4ZW5fb2JqOworCWludCByZXQ7CisKKwlyZXQgPSBkcm1f Z2VtX21tYXBfb2JqKGdlbV9vYmosIGdlbV9vYmotPnNpemUsIHZtYSk7CisJaWYgKHJldCA8IDAp CisJCXJldHVybiByZXQ7CisKKwl4ZW5fb2JqID0gdG9feGVuX2dlbV9vYmooZ2VtX29iaik7CisJ cmV0dXJuIGdlbV9tbWFwX29iaih4ZW5fb2JqLCB2bWEpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2dlbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uYTk0MTMwYTFkNzNlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2dlbS5oCkBAIC0wLDAgKzEsNDEgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJN IGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMu CisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1 c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1fRlJPTlRfR0VNX0gK KyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0dFTV9ICisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgor CitzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKnhlbl9kcm1fZnJvbnRfZ2VtX2NyZWF0ZShzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2LAorCQlzaXplX3Qgc2l6ZSk7CisKK3N0cnVjdCBkcm1fZ2VtX29iamVj dCAqeGVuX2RybV9mcm9udF9nZW1faW1wb3J0X3NnX3RhYmxlKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCisJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwgc3RydWN0IHNnX3RhYmxl ICpzZ3QpOworCitzdHJ1Y3Qgc2dfdGFibGUgKnhlbl9kcm1fZnJvbnRfZ2VtX2dldF9zZ190YWJs ZShzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopOworCitzdHJ1Y3QgcGFnZSAqKnhlbl9k cm1fZnJvbnRfZ2VtX2dldF9wYWdlcyhzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm9iaik7CisKK3Zv aWQgeGVuX2RybV9mcm9udF9nZW1fZnJlZV9vYmplY3RfdW5sb2NrZWQoc3RydWN0IGRybV9nZW1f b2JqZWN0ICpnZW1fb2JqKTsKKworI2lmbmRlZiBDT05GSUdfRFJNX1hFTl9GUk9OVEVORF9DTUEK KworaW50IHhlbl9kcm1fZnJvbnRfZ2VtX21tYXAoc3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCB2 bV9hcmVhX3N0cnVjdCAqdm1hKTsKKwordm9pZCAqeGVuX2RybV9mcm9udF9nZW1fcHJpbWVfdm1h cChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopOworCit2b2lkIHhlbl9kcm1fZnJvbnRf Z2VtX3ByaW1lX3Z1bm1hcChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmosCisJCXZvaWQg KnZhZGRyKTsKKworaW50IHhlbl9kcm1fZnJvbnRfZ2VtX3ByaW1lX21tYXAoc3RydWN0IGRybV9n ZW1fb2JqZWN0ICpnZW1fb2JqLAorCQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7CisjZW5k aWYKKworI2VuZGlmIC8qIF9fWEVOX0RSTV9GUk9OVF9HRU1fSCAqLwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbV9jbWEuYyBiL2RyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udF9nZW1fY21hLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwLi5iYjY5NTA2NDNiODIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dw dS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtX2NtYS5jCkBAIC0wLDAgKzEsNzcgQEAKKy8vIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVAorCisvKgorICogIFhlbiBwYXJh LXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0g U3lzdGVtcyBJbmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xl a3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgPGRybS9kcm1Q Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2NtYV9o ZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+CisKKyNpbmNsdWRl ICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9nZW0uaCIKKworc3Ry dWN0IGRybV9nZW1fb2JqZWN0ICp4ZW5fZHJtX2Zyb250X2dlbV9pbXBvcnRfc2dfdGFibGUoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwKKwkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo LCBzdHJ1Y3Qgc2dfdGFibGUgKnNndCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5m byAqZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOworCXN0cnVjdCBkcm1fZ2VtX29iamVjdCAq Z2VtX29iajsKKwlzdHJ1Y3QgZHJtX2dlbV9jbWFfb2JqZWN0ICpjbWFfb2JqOworCWludCByZXQ7 CisKKwlnZW1fb2JqID0gZHJtX2dlbV9jbWFfcHJpbWVfaW1wb3J0X3NnX3RhYmxlKGRldiwgYXR0 YWNoLCBzZ3QpOworCWlmIChJU19FUlJfT1JfTlVMTChnZW1fb2JqKSkKKwkJcmV0dXJuIGdlbV9v Ymo7CisKKwljbWFfb2JqID0gdG9fZHJtX2dlbV9jbWFfb2JqKGdlbV9vYmopOworCisJcmV0ID0g eGVuX2RybV9mcm9udF9kYnVmX2NyZWF0ZV9mcm9tX3NndChkcm1faW5mby0+ZnJvbnRfaW5mbywK KwkJCXhlbl9kcm1fZnJvbnRfZGJ1Zl90b19jb29raWUoZ2VtX29iaiksCisJCQkwLCAwLCAwLCBn ZW1fb2JqLT5zaXplLAorCQkJZHJtX2dlbV9jbWFfcHJpbWVfZ2V0X3NnX3RhYmxlKGdlbV9vYmop KTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKworCURSTV9ERUJVRygi SW1wb3J0ZWQgQ01BIGJ1ZmZlciBvZiBzaXplICV6dVxuIiwgZ2VtX29iai0+c2l6ZSk7CisKKwly ZXR1cm4gZ2VtX29iajsKK30KKworc3RydWN0IHNnX3RhYmxlICp4ZW5fZHJtX2Zyb250X2dlbV9n ZXRfc2dfdGFibGUoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1fb2JqKQoreworCXJldHVybiBk cm1fZ2VtX2NtYV9wcmltZV9nZXRfc2dfdGFibGUoZ2VtX29iaik7Cit9CisKK3N0cnVjdCBkcm1f Z2VtX29iamVjdCAqeGVuX2RybV9mcm9udF9nZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCisJCXNpemVfdCBzaXplKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpk cm1faW5mbyA9IGRldi0+ZGV2X3ByaXZhdGU7CisJc3RydWN0IGRybV9nZW1fY21hX29iamVjdCAq Y21hX29iajsKKworCWlmIChkcm1faW5mby0+ZnJvbnRfaW5mby0+Y2ZnLmJlX2FsbG9jKSB7CisJ CS8qIFRoaXMgdXNlLWNhc2UgaXMgbm90IHlldCBzdXBwb3J0ZWQgYW5kIHByb2JhYmx5IHdvbid0 IGJlICovCisJCURSTV9FUlJPUigiQmFja2VuZCBhbGxvY2F0ZWQgYnVmZmVycyBhbmQgQ01BIGhl bHBlcnMgYXJlIG5vdCBzdXBwb3J0ZWQgYXQgdGhlIHNhbWUgdGltZVxuIik7CisJCXJldHVybiBF UlJfUFRSKC1FSU5WQUwpOworCX0KKworCWNtYV9vYmogPSBkcm1fZ2VtX2NtYV9jcmVhdGUoZGV2 LCBzaXplKTsKKwlpZiAoSVNfRVJSX09SX05VTEwoY21hX29iaikpCisJCXJldHVybiBFUlJfQ0FT VChjbWFfb2JqKTsKKworCXJldHVybiAmY21hX29iai0+YmFzZTsKK30KKwordm9pZCB4ZW5fZHJt X2Zyb250X2dlbV9mcmVlX29iamVjdF91bmxvY2tlZChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdl bV9vYmopCit7CisJZHJtX2dlbV9jbWFfZnJlZV9vYmplY3QoZ2VtX29iaik7Cit9CisKK3N0cnVj dCBwYWdlICoqeGVuX2RybV9mcm9udF9nZW1fZ2V0X3BhZ2VzKHN0cnVjdCBkcm1fZ2VtX29iamVj dCAqZ2VtX29iaikKK3sKKwlyZXR1cm4gTlVMTDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udF9rbXMuYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9rbXMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmM5 NjM4M2FkOTE4NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udF9rbXMuYwpAQCAtMCwwICsxLDM3MCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAgT1IgTUlUCisKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVhbCBEUk0gZGV2aWNl CisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAqCisg KiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5r b0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9rbXMuaCIKKworI2lu Y2x1ZGUgPGRybS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWMuaD4KKyNpbmNsdWRl IDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVy Lmg+CisjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9mcmFt ZWJ1ZmZlcl9oZWxwZXIuaD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNpbmNsdWRl ICJ4ZW5fZHJtX2Zyb250X2Nvbm4uaCIKKworLyoKKyAqIFRpbWVvdXQgaW4gbXMgdG8gd2FpdCBm b3IgZnJhbWUgZG9uZSBldmVudCBmcm9tIHRoZSBiYWNrZW5kOgorICogbXVzdCBiZSBhIGJpdCBt b3JlIHRoYW4gSU8gdGltZS1vdXQKKyAqLworI2RlZmluZSBGUkFNRV9ET05FX1RPX01TCShYRU5f RFJNX0ZST05UX1dBSVRfQkFDS19NUyArIDEwMCkKKworc3RhdGljIHN0cnVjdCB4ZW5fZHJtX2Zy b250X2RybV9waXBlbGluZSAqCit0b194ZW5fZHJtX3BpcGVsaW5lKHN0cnVjdCBkcm1fc2ltcGxl X2Rpc3BsYXlfcGlwZSAqcGlwZSkKK3sKKwlyZXR1cm4gY29udGFpbmVyX29mKHBpcGUsIHN0cnVj dCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSwgcGlwZSk7Cit9CisKK3N0YXRpYyB2b2lkIGZi X2Rlc3Ryb3koc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIpCit7CisJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvID0gZmItPmRldi0+ZGV2X3ByaXZhdGU7CisJaW50IGlk eDsKKworCWlmIChkcm1fZGV2X2VudGVyKGZiLT5kZXYsICZpZHgpKSB7CisJCXhlbl9kcm1fZnJv bnRfZmJfZGV0YWNoKGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJCXhlbl9kcm1fZnJvbnRfZmJf dG9fY29va2llKGZiKSk7CisJCWRybV9kZXZfZXhpdChpZHgpOworCX0KKwlkcm1fZ2VtX2ZiX2Rl c3Ryb3koZmIpOworfQorCitzdGF0aWMgc3RydWN0IGRybV9mcmFtZWJ1ZmZlcl9mdW5jcyBmYl9m dW5jcyA9IHsKKwkuZGVzdHJveSA9IGZiX2Rlc3Ryb3ksCit9OworCitzdGF0aWMgc3RydWN0IGRy bV9mcmFtZWJ1ZmZlciAqZmJfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCXN0cnVj dCBkcm1fZmlsZSAqZmlscCwgY29uc3Qgc3RydWN0IGRybV9tb2RlX2ZiX2NtZDIgKm1vZGVfY21k KQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbyA9IGRldi0+ZGV2 X3ByaXZhdGU7CisJc3RhdGljIHN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiOworCXN0cnVjdCBk cm1fZ2VtX29iamVjdCAqZ2VtX29iajsKKwlpbnQgcmV0OworCisJZmIgPSBkcm1fZ2VtX2ZiX2Ny ZWF0ZV93aXRoX2Z1bmNzKGRldiwgZmlscCwgbW9kZV9jbWQsICZmYl9mdW5jcyk7CisJaWYgKElT X0VSUl9PUl9OVUxMKGZiKSkKKwkJcmV0dXJuIGZiOworCisJZ2VtX29iaiA9IGRybV9nZW1fb2Jq ZWN0X2xvb2t1cChmaWxwLCBtb2RlX2NtZC0+aGFuZGxlc1swXSk7CisJaWYgKCFnZW1fb2JqKSB7 CisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGxvb2t1cCBHRU0gb2JqZWN0XG4iKTsKKwkJcmV0ID0g LUVOT0VOVDsKKwkJZ290byBmYWlsOworCX0KKworCWRybV9nZW1fb2JqZWN0X3B1dF91bmxvY2tl ZChnZW1fb2JqKTsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfZmJfYXR0YWNoKGRybV9pbmZvLT5m cm9udF9pbmZvLAorCQkJeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZShnZW1fb2JqKSwKKwkJ CXhlbl9kcm1fZnJvbnRfZmJfdG9fY29va2llKGZiKSwKKwkJCWZiLT53aWR0aCwgZmItPmhlaWdo dCwgZmItPmZvcm1hdC0+Zm9ybWF0KTsKKwlpZiAocmV0IDwgMCkgeworCQlEUk1fRVJST1IoIkJh Y2sgZmFpbGVkIHRvIGF0dGFjaCBGQiAlcDogJWRcbiIsIGZiLCByZXQpOworCQlnb3RvIGZhaWw7 CisJfQorCisJcmV0dXJuIGZiOworCitmYWlsOgorCWRybV9nZW1fZmJfZGVzdHJveShmYik7CisJ cmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fbW9kZV9j b25maWdfZnVuY3MgbW9kZV9jb25maWdfZnVuY3MgPSB7CisJLmZiX2NyZWF0ZSA9IGZiX2NyZWF0 ZSwKKwkuYXRvbWljX2NoZWNrID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2ssCisJLmF0b21pY19j b21taXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jb21taXQsCit9OworCitzdGF0aWMgdm9pZCBzZW5k X3BlbmRpbmdfZXZlbnQoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGlu ZSkKK3sKKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmcGlwZWxpbmUtPnBpcGUuY3J0YzsKKwlz dHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ZGV2OworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7 CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZGV2LT5ldmVudF9sb2NrLCBmbGFncyk7CisJaWYgKHBp cGVsaW5lLT5wZW5kaW5nX2V2ZW50KQorCQlkcm1fY3J0Y19zZW5kX3ZibGFua19ldmVudChjcnRj LCBwaXBlbGluZS0+cGVuZGluZ19ldmVudCk7CisJcGlwZWxpbmUtPnBlbmRpbmdfZXZlbnQgPSBO VUxMOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmRldi0+ZXZlbnRfbG9jaywgZmxhZ3MpOwor fQorCitzdGF0aWMgdm9pZCBkaXNwbGF5X2VuYWJsZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5 X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSwKKwkJc3Ry dWN0IGRybV9wbGFuZV9zdGF0ZSAqcGxhbmVfc3RhdGUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJv bnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQl0b194ZW5fZHJtX3BpcGVsaW5lKHBpcGUp OworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9ICZwaXBlLT5jcnRjOworCXN0cnVjdCBkcm1fZnJh bWVidWZmZXIgKmZiID0gcGxhbmVfc3RhdGUtPmZiOworCWludCByZXQsIGlkeDsKKworCWlmICgh ZHJtX2Rldl9lbnRlcihwaXBlLT5jcnRjLmRldiwgJmlkeCkpCisJCXJldHVybjsKKworCXJldCA9 IHhlbl9kcm1fZnJvbnRfbW9kZV9zZXQocGlwZWxpbmUsCisJCQljcnRjLT54LCBjcnRjLT55LCBm Yi0+d2lkdGgsIGZiLT5oZWlnaHQsCisJCQlmYi0+Zm9ybWF0LT5jcHBbMF0gKiA4LAorCQkJeGVu X2RybV9mcm9udF9mYl90b19jb29raWUoZmIpKTsKKworCWlmIChyZXQpIHsKKwkJRFJNX0VSUk9S KCJGYWlsZWQgdG8gZW5hYmxlIGRpc3BsYXk6ICVkXG4iLCByZXQpOworCQlwaXBlbGluZS0+Y29u bl9jb25uZWN0ZWQgPSBmYWxzZTsKKwl9CisKKwlkcm1fZGV2X2V4aXQoaWR4KTsKK30KKworc3Rh dGljIHZvaWQgZGlzcGxheV9kaXNhYmxlKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAq cGlwZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0K KwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUocGlwZSk7CisJaW50IHJldCA9IDAsIGlkeDsKKworCWlm IChkcm1fZGV2X2VudGVyKHBpcGUtPmNydGMuZGV2LCAmaWR4KSkgeworCQlyZXQgPSB4ZW5fZHJt X2Zyb250X21vZGVfc2V0KHBpcGVsaW5lLCAwLCAwLCAwLCAwLCAwLAorCQkJCXhlbl9kcm1fZnJv bnRfZmJfdG9fY29va2llKE5VTEwpKTsKKwkJZHJtX2Rldl9leGl0KGlkeCk7CisJfQorCWlmIChy ZXQpCisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGRpc2FibGUgZGlzcGxheTogJWRcbiIsIHJldCk7 CisKKwkvKiBNYWtlIHN1cmUgd2UgY2FuIHJlc3RhcnQgd2l0aCBlbmFibGVkIGNvbm5lY3RvciBu ZXh0IHRpbWUgKi8KKwlwaXBlbGluZS0+Y29ubl9jb25uZWN0ZWQgPSB0cnVlOworCisJLyogcmVs ZWFzZSBzdGFsbGVkIGV2ZW50IGlmIGFueSAqLworCXNlbmRfcGVuZGluZ19ldmVudChwaXBlbGlu ZSk7Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9rbXNfb25fZnJhbWVfZG9uZShzdHJ1Y3QgeGVu X2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lLAorCQl1NjQgZmJfY29va2llKQorewor CS8qCisJICogVGhpcyBydW5zIGluIGludGVycnVwdCBjb250ZXh0LCBlLmcuIHVuZGVyCisJICog ZHJtX2luZm8tPmZyb250X2luZm8tPmlvX2xvY2ssIHNvIHdlIGNhbm5vdCBjYWxsIF9zeW5jIHZl cnNpb24KKwkgKiB0byBjYW5jZWwgdGhlIHdvcmsKKwkgKi8KKwljYW5jZWxfZGVsYXllZF93b3Jr KCZwaXBlbGluZS0+cGZsaXBfdG9fd29ya2VyKTsKKworCXNlbmRfcGVuZGluZ19ldmVudChwaXBl bGluZSk7Cit9CisKK3N0YXRpYyB2b2lkIHBmbGlwX3RvX3dvcmtlcihzdHJ1Y3Qgd29ya19zdHJ1 Y3QgKndvcmspCit7CisJc3RydWN0IGRlbGF5ZWRfd29yayAqZGVsYXllZF93b3JrID0gdG9fZGVs YXllZF93b3JrKHdvcmspOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGluZSAqcGlw ZWxpbmUgPQorCQkJY29udGFpbmVyX29mKGRlbGF5ZWRfd29yaywKKwkJCQkJc3RydWN0IHhlbl9k cm1fZnJvbnRfZHJtX3BpcGVsaW5lLAorCQkJCQlwZmxpcF90b193b3JrZXIpOworCisJRFJNX0VS Uk9SKCJGcmFtZSBkb25lIHRpbWVkLW91dCwgcmVsZWFzaW5nIik7CisJc2VuZF9wZW5kaW5nX2V2 ZW50KHBpcGVsaW5lKTsKK30KKworc3RhdGljIGJvb2wgZGlzcGxheV9zZW5kX3BhZ2VfZmxpcChz dHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0cnVjdCBkcm1fcGxhbmVf c3RhdGUgKm9sZF9wbGFuZV9zdGF0ZSkKK3sKKwlzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFu ZV9zdGF0ZSA9CisJCQlkcm1fYXRvbWljX2dldF9uZXdfcGxhbmVfc3RhdGUob2xkX3BsYW5lX3N0 YXRlLT5zdGF0ZSwKKwkJCQkJJnBpcGUtPnBsYW5lKTsKKworCS8qCisJICogSWYgb2xkX3BsYW5l X3N0YXRlLT5mYiBpcyBOVUxMIGFuZCBwbGFuZV9zdGF0ZS0+ZmIgaXMgbm90LAorCSAqIHRoZW4g dGhpcyBpcyBhbiBhdG9taWMgY29tbWl0IHdoaWNoIHdpbGwgZW5hYmxlIGRpc3BsYXkuCisJICog SWYgb2xkX3BsYW5lX3N0YXRlLT5mYiBpcyBub3QgTlVMTCBhbmQgcGxhbmVfc3RhdGUtPmZiIGlz LAorCSAqIHRoZW4gdGhpcyBpcyBhbiBhdG9taWMgY29tbWl0IHdoaWNoIHdpbGwgZGlzYWJsZSBk aXNwbGF5LgorCSAqIElnbm9yZSB0aGVzZSBhbmQgZG8gbm90IHNlbmQgcGFnZSBmbGlwIGFzIHRo aXMgZnJhbWVidWZmZXIgd2lsbCBiZQorCSAqIHNlbnQgdG8gdGhlIGJhY2tlbmQgYXMgYSBwYXJ0 IG9mIGRpc3BsYXlfc2V0X2NvbmZpZyBjYWxsLgorCSAqLworCWlmIChvbGRfcGxhbmVfc3RhdGUt PmZiICYmIHBsYW5lX3N0YXRlLT5mYikgeworCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlw ZWxpbmUgKnBpcGVsaW5lID0KKwkJCQl0b194ZW5fZHJtX3BpcGVsaW5lKHBpcGUpOworCQlzdHJ1 Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBwaXBlbGluZS0+ZHJtX2luZm87 CisJCWludCByZXQ7CisKKwkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZwaXBlbGluZS0+cGZsaXBf dG9fd29ya2VyLAorCQkJCW1zZWNzX3RvX2ppZmZpZXMoRlJBTUVfRE9ORV9UT19NUykpOworCisJ CXJldCA9IHhlbl9kcm1fZnJvbnRfcGFnZV9mbGlwKGRybV9pbmZvLT5mcm9udF9pbmZvLAorCQkJ CXBpcGVsaW5lLT5pbmRleCwKKwkJCQl4ZW5fZHJtX2Zyb250X2ZiX3RvX2Nvb2tpZShwbGFuZV9z dGF0ZS0+ZmIpKTsKKwkJaWYgKHJldCkgeworCQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gc2VuZCBw YWdlIGZsaXAgcmVxdWVzdCB0byBiYWNrZW5kOiAlZFxuIiwgcmV0KTsKKworCQkJcGlwZWxpbmUt PmNvbm5fY29ubmVjdGVkID0gZmFsc2U7CisJCQkvKgorCQkJICogUmVwb3J0IHRoZSBmbGlwIG5v dCBoYW5kbGVkLCBzbyBwZW5kaW5nIGV2ZW50IGlzCisJCQkgKiBzZW50LCB1bmJsb2NraW5nIHVz ZXItc3BhY2UuCisJCQkgKi8KKwkJCXJldHVybiBmYWxzZTsKKwkJfQorCQkvKgorCQkgKiBTaWdu YWwgdGhhdCBwYWdlIGZsaXAgd2FzIGhhbmRsZWQsIHBlbmRpbmcgZXZlbnQgd2lsbCBiZSBzZW50 CisJCSAqIG9uIGZyYW1lIGRvbmUgZXZlbnQgZnJvbSB0aGUgYmFja2VuZC4KKwkJICovCisJCXJl dHVybiB0cnVlOworCX0KKworCXJldHVybiBmYWxzZTsKK30KKworc3RhdGljIGludCBkaXNwbGF5 X3ByZXBhcmVfZmIoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlLAorCQlzdHJ1 Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZSkKK3sKKwlyZXR1cm4gZHJtX2dlbV9mYl9w cmVwYXJlX2ZiKCZwaXBlLT5wbGFuZSwgcGxhbmVfc3RhdGUpOworfQorCitzdGF0aWMgdm9pZCBk aXNwbGF5X3VwZGF0ZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCisJCXN0 cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9wbGFuZV9zdGF0ZSkKK3sKKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCXRvX3hlbl9kcm1fcGlwZWxpbmUo cGlwZSk7CisJc3RydWN0IGRybV9jcnRjICpjcnRjID0gJnBpcGUtPmNydGM7CisJc3RydWN0IGRy bV9wZW5kaW5nX3ZibGFua19ldmVudCAqZXZlbnQ7CisJaW50IGlkeDsKKworCWV2ZW50ID0gY3J0 Yy0+c3RhdGUtPmV2ZW50OworCWlmIChldmVudCkgeworCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 ID0gY3J0Yy0+ZGV2OworCQl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJCVdBUk5fT04ocGlwZWxp bmUtPnBlbmRpbmdfZXZlbnQpOworCisJCXNwaW5fbG9ja19pcnFzYXZlKCZkZXYtPmV2ZW50X2xv Y2ssIGZsYWdzKTsKKwkJY3J0Yy0+c3RhdGUtPmV2ZW50ID0gTlVMTDsKKworCQlwaXBlbGluZS0+ cGVuZGluZ19ldmVudCA9IGV2ZW50OworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXYtPmV2 ZW50X2xvY2ssIGZsYWdzKTsKKwl9CisKKwlpZiAoIWRybV9kZXZfZW50ZXIocGlwZS0+Y3J0Yy5k ZXYsICZpZHgpKSB7CisJCXNlbmRfcGVuZGluZ19ldmVudChwaXBlbGluZSk7CisJCXJldHVybjsK Kwl9CisKKwkvKgorCSAqIFNlbmQgcGFnZSBmbGlwIHJlcXVlc3QgdG8gdGhlIGJhY2tlbmQgKmFm dGVyKiB3ZSBoYXZlIGV2ZW50IGNhY2hlZAorCSAqIGFib3ZlLCBzbyBvbiBwYWdlIGZsaXAgZG9u ZSBldmVudCBmcm9tIHRoZSBiYWNrZW5kIHdlIGNhbgorCSAqIGRlbGl2ZXIgaXQgYW5kIHRoZXJl IGlzIG5vIHJhY2UgY29uZGl0aW9uIGJldHdlZW4gdGhpcyBjb2RlIGFuZAorCSAqIGV2ZW50IGZy b20gdGhlIGJhY2tlbmQuCisJICogSWYgdGhpcyBpcyBub3QgYSBwYWdlIGZsaXAsIGUuZy4gbm8g ZmxpcCBkb25lIGV2ZW50IGZyb20gdGhlIGJhY2tlbmQKKwkgKiBpcyBleHBlY3RlZCwgdGhlbiBz ZW5kIG5vdy4KKwkgKi8KKwlpZiAoIWRpc3BsYXlfc2VuZF9wYWdlX2ZsaXAocGlwZSwgb2xkX3Bs YW5lX3N0YXRlKSkKKwkJc2VuZF9wZW5kaW5nX2V2ZW50KHBpcGVsaW5lKTsKKworCWRybV9kZXZf ZXhpdChpZHgpOworfQorCitzdGF0aWMgZW51bSBkcm1fbW9kZV9zdGF0dXMgZGlzcGxheV9tb2Rl X3ZhbGlkKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKKwkJY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5 X21vZGUgKm1vZGUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBl bGluZSA9CisJCQljb250YWluZXJfb2YoY3J0YywKKwkJCQkJc3RydWN0IHhlbl9kcm1fZnJvbnRf ZHJtX3BpcGVsaW5lLAorCQkJCQlwaXBlLmNydGMpOworCisJaWYgKG1vZGUtPmhkaXNwbGF5ICE9 IHBpcGVsaW5lLT53aWR0aCkKKwkJcmV0dXJuIE1PREVfRVJST1I7CisKKwlpZiAobW9kZS0+dmRp c3BsYXkgIT0gcGlwZWxpbmUtPmhlaWdodCkKKwkJcmV0dXJuIE1PREVfRVJST1I7CisKKwlyZXR1 cm4gTU9ERV9PSzsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlf cGlwZV9mdW5jcyBkaXNwbGF5X2Z1bmNzID0geworCS5tb2RlX3ZhbGlkID0gZGlzcGxheV9tb2Rl X3ZhbGlkLAorCS5lbmFibGUgPSBkaXNwbGF5X2VuYWJsZSwKKwkuZGlzYWJsZSA9IGRpc3BsYXlf ZGlzYWJsZSwKKwkucHJlcGFyZV9mYiA9IGRpc3BsYXlfcHJlcGFyZV9mYiwKKwkudXBkYXRlID0g ZGlzcGxheV91cGRhdGUsCit9OworCitzdGF0aWMgaW50IGRpc3BsYXlfcGlwZV9pbml0KHN0cnVj dCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5mbywKKwkJaW50IGluZGV4LCBzdHJ1Y3Qg eGVuX2RybV9mcm9udF9jZmdfY29ubmVjdG9yICpjZmcsCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250 X2RybV9waXBlbGluZSAqcGlwZWxpbmUpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGRy bV9pbmZvLT5kcm1fZGV2OworCWNvbnN0IHUzMiAqZm9ybWF0czsKKwlpbnQgZm9ybWF0X2NvdW50 OworCWludCByZXQ7CisKKwlwaXBlbGluZS0+ZHJtX2luZm8gPSBkcm1faW5mbzsKKwlwaXBlbGlu ZS0+aW5kZXggPSBpbmRleDsKKwlwaXBlbGluZS0+aGVpZ2h0ID0gY2ZnLT5oZWlnaHQ7CisJcGlw ZWxpbmUtPndpZHRoID0gY2ZnLT53aWR0aDsKKworCUlOSVRfREVMQVlFRF9XT1JLKCZwaXBlbGlu ZS0+cGZsaXBfdG9fd29ya2VyLCBwZmxpcF90b193b3JrZXIpOworCisJcmV0ID0geGVuX2RybV9m cm9udF9jb25uX2luaXQoZHJtX2luZm8sICZwaXBlbGluZS0+Y29ubik7CisJaWYgKHJldCkKKwkJ cmV0dXJuIHJldDsKKworCWZvcm1hdHMgPSB4ZW5fZHJtX2Zyb250X2Nvbm5fZ2V0X2Zvcm1hdHMo JmZvcm1hdF9jb3VudCk7CisKKwlyZXR1cm4gZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfaW5pdChk ZXYsICZwaXBlbGluZS0+cGlwZSwKKwkJCSZkaXNwbGF5X2Z1bmNzLCBmb3JtYXRzLCBmb3JtYXRf Y291bnQsCisJCQlOVUxMLCAmcGlwZWxpbmUtPmNvbm4pOworfQorCitpbnQgeGVuX2RybV9mcm9u dF9rbXNfaW5pdChzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8pCit7CisJ c3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGRybV9pbmZvLT5kcm1fZGV2OworCWludCBpLCByZXQ7 CisKKwlkcm1fbW9kZV9jb25maWdfaW5pdChkZXYpOworCisJZGV2LT5tb2RlX2NvbmZpZy5taW5f d2lkdGggPSAwOworCWRldi0+bW9kZV9jb25maWcubWluX2hlaWdodCA9IDA7CisJZGV2LT5tb2Rl X2NvbmZpZy5tYXhfd2lkdGggPSA0MDk1OworCWRldi0+bW9kZV9jb25maWcubWF4X2hlaWdodCA9 IDIwNDc7CisJZGV2LT5tb2RlX2NvbmZpZy5mdW5jcyA9ICZtb2RlX2NvbmZpZ19mdW5jczsKKwor CWZvciAoaSA9IDA7IGkgPCBkcm1faW5mby0+ZnJvbnRfaW5mby0+Y2ZnLm51bV9jb25uZWN0b3Jz OyBpKyspIHsKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnX2Nvbm5lY3RvciAqY2ZnID0KKwkJ CQkmZHJtX2luZm8tPmZyb250X2luZm8tPmNmZy5jb25uZWN0b3JzW2ldOworCQlzdHJ1Y3QgeGVu X2RybV9mcm9udF9kcm1fcGlwZWxpbmUgKnBpcGVsaW5lID0KKwkJCQkmZHJtX2luZm8tPnBpcGVs aW5lW2ldOworCisJCXJldCA9IGRpc3BsYXlfcGlwZV9pbml0KGRybV9pbmZvLCBpLCBjZmcsIHBp cGVsaW5lKTsKKwkJaWYgKHJldCkgeworCQkJZHJtX21vZGVfY29uZmlnX2NsZWFudXAoZGV2KTsK KwkJCXJldHVybiByZXQ7CisJCX0KKwl9CisKKwlkcm1fbW9kZV9jb25maWdfcmVzZXQoZGV2KTsK Kwlkcm1fa21zX2hlbHBlcl9wb2xsX2luaXQoZGV2KTsKKwlyZXR1cm4gMDsKK30KKwordm9pZCB4 ZW5fZHJtX2Zyb250X2ttc19maW5pKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1f aW5mbykKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBkcm1faW5mby0+ZnJvbnRfaW5m by0+Y2ZnLm51bV9jb25uZWN0b3JzOyBpKyspIHsKKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJt X3BpcGVsaW5lICpwaXBlbGluZSA9CisJCQkJJmRybV9pbmZvLT5waXBlbGluZVtpXTsKKworCQlj YW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJnBpcGVsaW5lLT5wZmxpcF90b193b3JrZXIpOworCisJ CXNlbmRfcGVuZGluZ19ldmVudChwaXBlbGluZSk7CisJfQorfQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2ttcy5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2ttcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uNzU0NmU2Nzk0NjQwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2ttcy5oCkBAIC0wLDAgKzEsMjYgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJN IGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMu CisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1 c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1fRlJPTlRfS01TX0hf CisjZGVmaW5lIF9fWEVOX0RSTV9GUk9OVF9LTVNfSF8KKworI2luY2x1ZGUgPGxpbnV4L3R5cGVz Lmg+CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvOworc3RydWN0IHhlbl9kcm1fZnJv bnRfZHJtX3BpcGVsaW5lOworCitpbnQgeGVuX2RybV9mcm9udF9rbXNfaW5pdChzdHJ1Y3QgeGVu X2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8pOworCit2b2lkIHhlbl9kcm1fZnJvbnRfa21z X2Zpbmkoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZvKTsKKwordm9pZCB4 ZW5fZHJtX2Zyb250X2ttc19vbl9mcmFtZV9kb25lKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9w aXBlbGluZSAqcGlwZWxpbmUsCisJCXU2NCBmYl9jb29raWUpOworCisjZW5kaWYgLyogX19YRU5f RFJNX0ZST05UX0tNU19IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5f ZHJtX2Zyb250X3NoYnVmLmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfc2hi dWYuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmM1ZTkyOTY5NTU0 MQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9z aGJ1Zi5jCkBAIC0wLDAgKzEsNDMyIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMCBPUiBNSVQKKworLyoKKyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisg KiBDb3B5cmlnaHQgKEMpIDIwMTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhv cjogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0u Y29tPgorICovCisKKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgorCisjaWYgZGVmaW5lZChDT05GSUdf WDg2KQorI2luY2x1ZGUgPGRybS9kcm1fY2FjaGUuaD4KKyNlbmRpZgorI2luY2x1ZGUgPGxpbnV4 L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvbW0uaD4KKworI2luY2x1ZGUgPGFzbS94ZW4vaHlw ZXJ2aXNvci5oPgorI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CisjaW5jbHVkZSA8eGVuL3hlbi5o PgorI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2lvL3Jp bmcuaD4KKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2lvL2Rpc3BsaWYuaD4KKworI2luY2x1ZGUg Inhlbl9kcm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X3NoYnVmLmgiCisKK3N0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmX29wcyB7CisJLyoKKwkgKiBDYWxjdWxhdGUgbnVtYmVy IG9mIGdyZWZzIHJlcXVpcmVkIHRvIGhhbmRsZSB0aGlzIGJ1ZmZlciwKKwkgKiBlLmcuIGlmIGdy ZWZzIGFyZSByZXF1aXJlZCBmb3IgcGFnZSBkaXJlY3Rvcnkgb25seSBvciB0aGUgYnVmZmVyCisJ ICogcGFnZXMgYXMgd2VsbC4KKwkgKi8KKwl2b2lkICgqY2FsY19udW1fZ3JlZnMpKHN0cnVjdCB4 ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpOworCS8qIEZpbGwgcGFnZSBkaXJlY3RvcnkgYWNjb3Jk aW5nIHRvIHBhcmEtdmlydHVhbCBkaXNwbGF5IHByb3RvY29sLiAqLworCXZvaWQgKCpmaWxsX3Bh Z2VfZGlyKShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsKKwkvKiBDbGFpbSBncmFu dCByZWZlcmVuY2VzIGZvciB0aGUgcGFnZXMgb2YgdGhlIGJ1ZmZlci4gKi8KKwlpbnQgKCpncmFu dF9yZWZzX2Zvcl9idWZmZXIpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYsCisJCQln cmFudF9yZWZfdCAqcHJpdl9ncmVmX2hlYWQsIGludCBncmVmX2lkeCk7CisJLyogTWFwIGdyYW50 IHJlZmVyZW5jZXMgb2YgdGhlIGJ1ZmZlci4gKi8KKwlpbnQgKCptYXApKHN0cnVjdCB4ZW5fZHJt X2Zyb250X3NoYnVmICpidWYpOworCS8qIFVubWFwIGdyYW50IHJlZmVyZW5jZXMgb2YgdGhlIGJ1 ZmZlci4gKi8KKwlpbnQgKCp1bm1hcCkoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7 Cit9OworCitncmFudF9yZWZfdCB4ZW5fZHJtX2Zyb250X3NoYnVmX2dldF9kaXJfc3RhcnQoc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKwlpZiAoIWJ1Zi0+Z3JlZnMpCisJCXJl dHVybiBHUkFOVF9JTlZBTElEX1JFRjsKKworCXJldHVybiBidWYtPmdyZWZzWzBdOworfQorCitp bnQgeGVuX2RybV9mcm9udF9zaGJ1Zl9tYXAoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1 ZikKK3sKKwlpZiAoYnVmLT5vcHMtPm1hcCkKKwkJcmV0dXJuIGJ1Zi0+b3BzLT5tYXAoYnVmKTsK KworCS8qIG5vIG5lZWQgdG8gbWFwIG93biBncmFudCByZWZlcmVuY2VzICovCisJcmV0dXJuIDA7 Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X3NoYnVmX3VubWFwKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+b3BzLT51bm1hcCkKKwkJcmV0dXJuIGJ1Zi0+b3Bz LT51bm1hcChidWYpOworCisJLyogbm8gbmVlZCB0byB1bm1hcCBvd24gZ3JhbnQgcmVmZXJlbmNl cyAqLworCXJldHVybiAwOworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfc2hidWZfZmx1c2goc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1ZikKK3sKKyNpZiBkZWZpbmVkKENPTkZJR19YODYp CisJZHJtX2NsZmx1c2hfcGFnZXMoYnVmLT5wYWdlcywgYnVmLT5udW1fcGFnZXMpOworI2VuZGlm Cit9CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mcmVlKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmICpidWYpCit7CisJaWYgKGJ1Zi0+Z3JlZnMpIHsKKwkJaW50IGk7CisKKwkJZm9yIChp ID0gMDsgaSA8IGJ1Zi0+bnVtX2dyZWZzOyBpKyspCisJCQlpZiAoYnVmLT5ncmVmc1tpXSAhPSBH UkFOVF9JTlZBTElEX1JFRikKKwkJCQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzKGJ1Zi0+Z3Jl ZnNbaV0sCisJCQkJCTAsIDBVTCk7CisJfQorCWtmcmVlKGJ1Zi0+Z3JlZnMpOworCWtmcmVlKGJ1 Zi0+ZGlyZWN0b3J5KTsKKwlpZiAoYnVmLT5zZ3QpIHsKKwkJc2dfZnJlZV90YWJsZShidWYtPnNn dCk7CisJCWt2ZnJlZShidWYtPnBhZ2VzKTsKKwl9CisJa2ZyZWUoYnVmKTsKK30KKworLyoKKyAq IG51bWJlciBvZiBncmVmcyBhIHBhZ2UgY2FuIGhvbGQgd2l0aCByZXNwZWN0IHRvIHRoZQorICog c3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5IGhlYWRlcgorICovCisjZGVmaW5lIFhFTl9E Uk1fTlVNX0dSRUZTX1BFUl9QQUdFICgoUEFHRV9TSVpFIC0gXAorCW9mZnNldG9mKHN0cnVjdCB4 ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSwgZ3JlZikpIC8gXAorCXNpemVvZihncmFudF9yZWZfdCkp CisKK3N0YXRpYyBpbnQgZ2V0X251bV9wYWdlc19kaXIoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hi dWYgKmJ1ZikKK3sKKwkvKiBudW1iZXIgb2YgcGFnZXMgdGhlIHBhZ2UgZGlyZWN0b3J5IGNvbnN1 bWVzIGl0c2VsZiAqLworCXJldHVybiBESVZfUk9VTkRfVVAoYnVmLT5udW1fcGFnZXMsIFhFTl9E Uk1fTlVNX0dSRUZTX1BFUl9QQUdFKTsKK30KKworc3RhdGljIHZvaWQgYmFja2VuZF9jYWxjX251 bV9ncmVmcyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCS8qIG9ubHkgZm9y IHBhZ2VzIHRoZSBwYWdlIGRpcmVjdG9yeSBjb25zdW1lcyBpdHNlbGYgKi8KKwlidWYtPm51bV9n cmVmcyA9IGdldF9udW1fcGFnZXNfZGlyKGJ1Zik7Cit9CisKK3N0YXRpYyB2b2lkIGd1ZXN0X2Nh bGNfbnVtX2dyZWZzKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7CisJLyoKKwkg KiBudW1iZXIgb2YgcGFnZXMgdGhlIHBhZ2UgZGlyZWN0b3J5IGNvbnN1bWVzIGl0c2VsZgorCSAq IHBsdXMgZ3JlZnMgZm9yIHRoZSBidWZmZXIgcGFnZXMKKwkgKi8KKwlidWYtPm51bV9ncmVmcyA9 IGdldF9udW1fcGFnZXNfZGlyKGJ1ZikgKyBidWYtPm51bV9wYWdlczsKK30KKworI2RlZmluZSB4 ZW5fcGFnZV90b192YWRkcihwYWdlKSBcCisJCSgocGh5c19hZGRyX3QpcGZuX3RvX2thZGRyKHBh Z2VfdG9feGVuX3BmbihwYWdlKSkpCisKK3N0YXRpYyBpbnQgYmFja2VuZF91bm1hcChzdHJ1Y3Qg eGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCXN0cnVjdCBnbnR0YWJfdW5tYXBfZ3JhbnRf cmVmICp1bm1hcF9vcHM7CisJaW50IGksIHJldDsKKworCWlmICghYnVmLT5wYWdlcyB8fCAhYnVm LT5iYWNrZW5kX21hcF9oYW5kbGVzIHx8ICFidWYtPmdyZWZzKQorCQlyZXR1cm4gMDsKKworCXVu bWFwX29wcyA9IGtjYWxsb2MoYnVmLT5udW1fcGFnZXMsIHNpemVvZigqdW5tYXBfb3BzKSwKKwkJ R0ZQX0tFUk5FTCk7CisJaWYgKCF1bm1hcF9vcHMpIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8g Z2V0IG1lbW9yeSB3aGlsZSB1bm1hcHBpbmdcbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisK Kwlmb3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fcGFnZXM7IGkrKykgeworCQlwaHlzX2FkZHJfdCBh ZGRyOworCisJCWFkZHIgPSB4ZW5fcGFnZV90b192YWRkcihidWYtPnBhZ2VzW2ldKTsKKwkJZ250 dGFiX3NldF91bm1hcF9vcCgmdW5tYXBfb3BzW2ldLCBhZGRyLCBHTlRNQVBfaG9zdF9tYXAsCisJ CQkJYnVmLT5iYWNrZW5kX21hcF9oYW5kbGVzW2ldKTsKKwl9CisKKwlyZXQgPSBnbnR0YWJfdW5t YXBfcmVmcyh1bm1hcF9vcHMsIE5VTEwsIGJ1Zi0+cGFnZXMsCisJCQlidWYtPm51bV9wYWdlcyk7 CisKKwlmb3IgKGkgPSAwOyBpIDwgYnVmLT5udW1fcGFnZXM7IGkrKykgeworCQlpZiAodW5saWtl bHkodW5tYXBfb3BzW2ldLnN0YXR1cyAhPSBHTlRTVF9va2F5KSkKKwkJCURSTV9FUlJPUigiRmFp bGVkIHRvIHVubWFwIHBhZ2UgJWQ6ICVkXG4iLAorCQkJCQlpLCB1bm1hcF9vcHNbaV0uc3RhdHVz KTsKKwl9CisKKwlpZiAocmV0KQorCQlEUk1fRVJST1IoIkZhaWxlZCB0byB1bm1hcCBncmFudCBy ZWZlcmVuY2VzLCByZXQgJWQiLCByZXQpOworCisJa2ZyZWUodW5tYXBfb3BzKTsKKwlrZnJlZShi dWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMpOworCWJ1Zi0+YmFja2VuZF9tYXBfaGFuZGxlcyA9IE5V TEw7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBiYWNrZW5kX21hcChzdHJ1Y3QgeGVu X2RybV9mcm9udF9zaGJ1ZiAqYnVmKQoreworCXN0cnVjdCBnbnR0YWJfbWFwX2dyYW50X3JlZiAq bWFwX29wcyA9IE5VTEw7CisJdW5zaWduZWQgY2hhciAqcHRyOworCWludCByZXQsIGN1cl9ncmVm LCBjdXJfZGlyX3BhZ2UsIGN1cl9wYWdlLCBncmVmc19sZWZ0OworCisJbWFwX29wcyA9IGtjYWxs b2MoYnVmLT5udW1fcGFnZXMsIHNpemVvZigqbWFwX29wcyksIEdGUF9LRVJORUwpOworCWlmICgh bWFwX29wcykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlidWYtPmJhY2tlbmRfbWFwX2hhbmRsZXMg PSBrY2FsbG9jKGJ1Zi0+bnVtX3BhZ2VzLAorCQkJc2l6ZW9mKCpidWYtPmJhY2tlbmRfbWFwX2hh bmRsZXMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJ1Zi0+YmFja2VuZF9tYXBfaGFuZGxlcykgewor CQlrZnJlZShtYXBfb3BzKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJLyoKKwkgKiByZWFk IHBhZ2UgZGlyZWN0b3J5IHRvIGdldCBncmVmcyBmcm9tIHRoZSBiYWNrZW5kOiBmb3IgZXh0ZXJu YWwKKwkgKiBidWZmZXIgd2Ugb25seSBhbGxvY2F0ZSBidWYtPmdyZWZzIGZvciB0aGUgcGFnZSBk aXJlY3RvcnksCisJICogc28gYnVmLT5udW1fZ3JlZnMgaGFzIG51bWJlciBvZiBwYWdlcyBpbiB0 aGUgcGFnZSBkaXJlY3RvcnkgaXRzZWxmCisJICovCisJcHRyID0gYnVmLT5kaXJlY3Rvcnk7CisJ Z3JlZnNfbGVmdCA9IGJ1Zi0+bnVtX3BhZ2VzOworCWN1cl9wYWdlID0gMDsKKwlmb3IgKGN1cl9k aXJfcGFnZSA9IDA7IGN1cl9kaXJfcGFnZSA8IGJ1Zi0+bnVtX2dyZWZzOyBjdXJfZGlyX3BhZ2Ur KykgeworCQlzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3RvcnkgKnBhZ2VfZGlyID0KKwkJCQko c3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICopcHRyOworCQlpbnQgdG9fY29weSA9IFhF Tl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFOworCisJCWlmICh0b19jb3B5ID4gZ3JlZnNfbGVmdCkK KwkJCXRvX2NvcHkgPSBncmVmc19sZWZ0OworCisJCWZvciAoY3VyX2dyZWYgPSAwOyBjdXJfZ3Jl ZiA8IHRvX2NvcHk7IGN1cl9ncmVmKyspIHsKKwkJCXBoeXNfYWRkcl90IGFkZHI7CisKKwkJCWFk ZHIgPSB4ZW5fcGFnZV90b192YWRkcihidWYtPnBhZ2VzW2N1cl9wYWdlXSk7CisJCQlnbnR0YWJf c2V0X21hcF9vcCgmbWFwX29wc1tjdXJfcGFnZV0sIGFkZHIsCisJCQkJCUdOVE1BUF9ob3N0X21h cCwKKwkJCQkJcGFnZV9kaXItPmdyZWZbY3VyX2dyZWZdLAorCQkJCQlidWYtPnhiX2Rldi0+b3Ro ZXJlbmRfaWQpOworCQkJY3VyX3BhZ2UrKzsKKwkJfQorCisJCWdyZWZzX2xlZnQgLT0gdG9fY29w eTsKKwkJcHRyICs9IFBBR0VfU0laRTsKKwl9CisJcmV0ID0gZ250dGFiX21hcF9yZWZzKG1hcF9v cHMsIE5VTEwsIGJ1Zi0+cGFnZXMsIGJ1Zi0+bnVtX3BhZ2VzKTsKKworCS8qIHNhdmUgaGFuZGxl cyBldmVuIGlmIGVycm9yLCBzbyB3ZSBjYW4gdW5tYXAgKi8KKwlmb3IgKGN1cl9wYWdlID0gMDsg Y3VyX3BhZ2UgPCBidWYtPm51bV9wYWdlczsgY3VyX3BhZ2UrKykgeworCQlidWYtPmJhY2tlbmRf bWFwX2hhbmRsZXNbY3VyX3BhZ2VdID0gbWFwX29wc1tjdXJfcGFnZV0uaGFuZGxlOworCQlpZiAo dW5saWtlbHkobWFwX29wc1tjdXJfcGFnZV0uc3RhdHVzICE9IEdOVFNUX29rYXkpKQorCQkJRFJN X0VSUk9SKCJGYWlsZWQgdG8gbWFwIHBhZ2UgJWQ6ICVkXG4iLAorCQkJCQljdXJfcGFnZSwgbWFw X29wc1tjdXJfcGFnZV0uc3RhdHVzKTsKKwl9CisKKwlpZiAocmV0KSB7CisJCURSTV9FUlJPUigi RmFpbGVkIHRvIG1hcCBncmFudCByZWZlcmVuY2VzLCByZXQgJWQiLCByZXQpOworCQliYWNrZW5k X3VubWFwKGJ1Zik7CisJfQorCisJa2ZyZWUobWFwX29wcyk7CisJcmV0dXJuIHJldDsKK30KKwor c3RhdGljIHZvaWQgYmFja2VuZF9maWxsX3BhZ2VfZGlyKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3No YnVmICpidWYpCit7CisJc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICpwYWdlX2RpcjsK Kwl1bnNpZ25lZCBjaGFyICpwdHI7CisJaW50IGksIG51bV9wYWdlc19kaXI7CisKKwlwdHIgPSBi dWYtPmRpcmVjdG9yeTsKKwludW1fcGFnZXNfZGlyID0gZ2V0X251bV9wYWdlc19kaXIoYnVmKTsK KworCS8qIGZpbGwgb25seSBncmVmcyBmb3IgdGhlIHBhZ2UgZGlyZWN0b3J5IGl0c2VsZiAqLwor CWZvciAoaSA9IDA7IGkgPCBudW1fcGFnZXNfZGlyIC0gMTsgaSsrKSB7CisJCXBhZ2VfZGlyID0g KHN0cnVjdCB4ZW5kaXNwbF9wYWdlX2RpcmVjdG9yeSAqKXB0cjsKKworCQlwYWdlX2Rpci0+Z3Jl Zl9kaXJfbmV4dF9wYWdlID0gYnVmLT5ncmVmc1tpICsgMV07CisJCXB0ciArPSBQQUdFX1NJWkU7 CisJfQorCS8qIGxhc3QgcGFnZSBtdXN0IHNheSB0aGVyZSBpcyBubyBtb3JlIHBhZ2VzICovCisJ cGFnZV9kaXIgPSAoc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICopcHRyOworCXBhZ2Vf ZGlyLT5ncmVmX2Rpcl9uZXh0X3BhZ2UgPSBHUkFOVF9JTlZBTElEX1JFRjsKK30KKworc3RhdGlj IHZvaWQgZ3Vlc3RfZmlsbF9wYWdlX2RpcihzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVm KQoreworCXVuc2lnbmVkIGNoYXIgKnB0cjsKKwlpbnQgY3VyX2dyZWYsIGdyZWZzX2xlZnQsIHRv X2NvcHksIGksIG51bV9wYWdlc19kaXI7CisKKwlwdHIgPSBidWYtPmRpcmVjdG9yeTsKKwludW1f cGFnZXNfZGlyID0gZ2V0X251bV9wYWdlc19kaXIoYnVmKTsKKworCS8qCisJICogd2hpbGUgY29w eWluZywgc2tpcCBncmVmcyBhdCBzdGFydCwgdGhleSBhcmUgZm9yIHBhZ2VzCisJICogZ3JhbnRl ZCBmb3IgdGhlIHBhZ2UgZGlyZWN0b3J5IGl0c2VsZgorCSAqLworCWN1cl9ncmVmID0gbnVtX3Bh Z2VzX2RpcjsKKwlncmVmc19sZWZ0ID0gYnVmLT5udW1fcGFnZXM7CisJZm9yIChpID0gMDsgaSA8 IG51bV9wYWdlc19kaXI7IGkrKykgeworCQlzdHJ1Y3QgeGVuZGlzcGxfcGFnZV9kaXJlY3Rvcnkg KnBhZ2VfZGlyID0KKwkJCQkoc3RydWN0IHhlbmRpc3BsX3BhZ2VfZGlyZWN0b3J5ICopcHRyOwor CisJCWlmIChncmVmc19sZWZ0IDw9IFhFTl9EUk1fTlVNX0dSRUZTX1BFUl9QQUdFKSB7CisJCQl0 b19jb3B5ID0gZ3JlZnNfbGVmdDsKKwkJCXBhZ2VfZGlyLT5ncmVmX2Rpcl9uZXh0X3BhZ2UgPSBH UkFOVF9JTlZBTElEX1JFRjsKKwkJfSBlbHNlIHsKKwkJCXRvX2NvcHkgPSBYRU5fRFJNX05VTV9H UkVGU19QRVJfUEFHRTsKKwkJCXBhZ2VfZGlyLT5ncmVmX2Rpcl9uZXh0X3BhZ2UgPSBidWYtPmdy ZWZzW2kgKyAxXTsKKwkJfQorCQltZW1jcHkoJnBhZ2VfZGlyLT5ncmVmLCAmYnVmLT5ncmVmc1tj dXJfZ3JlZl0sCisJCQkJdG9fY29weSAqIHNpemVvZihncmFudF9yZWZfdCkpOworCQlwdHIgKz0g UEFHRV9TSVpFOworCQlncmVmc19sZWZ0IC09IHRvX2NvcHk7CisJCWN1cl9ncmVmICs9IHRvX2Nv cHk7CisJfQorfQorCitzdGF0aWMgaW50IGd1ZXN0X2dyYW50X3JlZnNfZm9yX2J1ZmZlcihzdHJ1 Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmLAorCQlncmFudF9yZWZfdCAqcHJpdl9ncmVmX2hl YWQsIGludCBncmVmX2lkeCkKK3sKKwlpbnQgaSwgY3VyX3JlZiwgb3RoZXJlbmRfaWQ7CisKKwlv dGhlcmVuZF9pZCA9IGJ1Zi0+eGJfZGV2LT5vdGhlcmVuZF9pZDsKKwlmb3IgKGkgPSAwOyBpIDwg YnVmLT5udW1fcGFnZXM7IGkrKykgeworCQljdXJfcmVmID0gZ250dGFiX2NsYWltX2dyYW50X3Jl ZmVyZW5jZShwcml2X2dyZWZfaGVhZCk7CisJCWlmIChjdXJfcmVmIDwgMCkKKwkJCXJldHVybiBj dXJfcmVmOworCQlnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3NfcmVmKGN1cl9yZWYsIG90aGVy ZW5kX2lkLAorCQkJCXhlbl9wYWdlX3RvX2dmbihidWYtPnBhZ2VzW2ldKSwgMCk7CisJCWJ1Zi0+ Z3JlZnNbZ3JlZl9pZHgrK10gPSBjdXJfcmVmOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGlj IGludCBncmFudF9yZWZlcmVuY2VzKHN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpidWYpCit7 CisJZ3JhbnRfcmVmX3QgcHJpdl9ncmVmX2hlYWQ7CisJaW50IHJldCwgaSwgaiwgY3VyX3JlZjsK KwlpbnQgb3RoZXJlbmRfaWQsIG51bV9wYWdlc19kaXI7CisKKwlyZXQgPSBnbnR0YWJfYWxsb2Nf Z3JhbnRfcmVmZXJlbmNlcyhidWYtPm51bV9ncmVmcywgJnByaXZfZ3JlZl9oZWFkKTsKKwlpZiAo cmV0IDwgMCkgeworCQlEUk1fRVJST1IoIkNhbm5vdCBhbGxvY2F0ZSBncmFudCByZWZlcmVuY2Vz XG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJb3RoZXJlbmRfaWQgPSBidWYtPnhiX2Rldi0+b3Ro ZXJlbmRfaWQ7CisJaiA9IDA7CisJbnVtX3BhZ2VzX2RpciA9IGdldF9udW1fcGFnZXNfZGlyKGJ1 Zik7CisJZm9yIChpID0gMDsgaSA8IG51bV9wYWdlc19kaXI7IGkrKykgeworCQl1bnNpZ25lZCBs b25nIGZyYW1lOworCisJCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1fZ3JhbnRfcmVmZXJlbmNlKCZw cml2X2dyZWZfaGVhZCk7CisJCWlmIChjdXJfcmVmIDwgMCkKKwkJCXJldHVybiBjdXJfcmVmOwor CisJCWZyYW1lID0geGVuX3BhZ2VfdG9fZ2ZuKHZpcnRfdG9fcGFnZShidWYtPmRpcmVjdG9yeSAr CisJCQkJUEFHRV9TSVpFICogaSkpOworCQlnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3NfcmVm KGN1cl9yZWYsIG90aGVyZW5kX2lkLAorCQkJCWZyYW1lLCAwKTsKKwkJYnVmLT5ncmVmc1tqKytd ID0gY3VyX3JlZjsKKwl9CisKKwlpZiAoYnVmLT5vcHMtPmdyYW50X3JlZnNfZm9yX2J1ZmZlcikg eworCQlyZXQgPSBidWYtPm9wcy0+Z3JhbnRfcmVmc19mb3JfYnVmZmVyKGJ1ZiwgJnByaXZfZ3Jl Zl9oZWFkLCBqKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisJfQorCisJZ250dGFiX2Zy ZWVfZ3JhbnRfcmVmZXJlbmNlcyhwcml2X2dyZWZfaGVhZCk7CisJcmV0dXJuIDA7Cit9CisKK3N0 YXRpYyBpbnQgYWxsb2Nfc3RvcmFnZShzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKQor eworCWlmIChidWYtPnNndCkgeworCQlidWYtPnBhZ2VzID0ga3ZtYWxsb2NfYXJyYXkoYnVmLT5u dW1fcGFnZXMsCisJCQkJc2l6ZW9mKHN0cnVjdCBwYWdlICopLCBHRlBfS0VSTkVMKTsKKwkJaWYg KCFidWYtPnBhZ2VzKQorCQkJcmV0dXJuIC1FTk9NRU07CisKKwkJaWYgKGRybV9wcmltZV9zZ190 b19wYWdlX2FkZHJfYXJyYXlzKGJ1Zi0+c2d0LCBidWYtPnBhZ2VzLAorCQkJCU5VTEwsIGJ1Zi0+ bnVtX3BhZ2VzKSA8IDApCisJCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlidWYtPmdyZWZzID0g a2NhbGxvYyhidWYtPm51bV9ncmVmcywgc2l6ZW9mKCpidWYtPmdyZWZzKSwgR0ZQX0tFUk5FTCk7 CisJaWYgKCFidWYtPmdyZWZzKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWJ1Zi0+ZGlyZWN0b3J5 ID0ga2NhbGxvYyhnZXRfbnVtX3BhZ2VzX2RpcihidWYpLCBQQUdFX1NJWkUsIEdGUF9LRVJORUwp OworCWlmICghYnVmLT5kaXJlY3RvcnkpCisJCXJldHVybiAtRU5PTUVNOworCisJcmV0dXJuIDA7 Cit9CisKKy8qCisgKiBGb3IgYmUgYWxsb2NhdGVkIGJ1ZmZlcnMgd2UgZG9uJ3QgbmVlZCBncmFu dF9yZWZzX2Zvcl9idWZmZXIgYXMgdGhvc2UKKyAqIGdyYW50IHJlZmVyZW5jZXMgYXJlIGFsbG9j YXRlZCBhdCBiYWNrZW5kIHNpZGUKKyAqLworc3RhdGljIGNvbnN0IHN0cnVjdCB4ZW5fZHJtX2Zy b250X3NoYnVmX29wcyBiYWNrZW5kX29wcyA9IHsKKwkuY2FsY19udW1fZ3JlZnMgPSBiYWNrZW5k X2NhbGNfbnVtX2dyZWZzLAorCS5maWxsX3BhZ2VfZGlyID0gYmFja2VuZF9maWxsX3BhZ2VfZGly LAorCS5tYXAgPSBiYWNrZW5kX21hcCwKKwkudW5tYXAgPSBiYWNrZW5kX3VubWFwCit9OworCisv KiBGb3IgbG9jYWxseSBncmFudGVkIHJlZmVyZW5jZXMgd2UgZG8gbm90IG5lZWQgdG8gbWFwL3Vu bWFwIHRoZSByZWZlcmVuY2VzICovCitzdGF0aWMgY29uc3Qgc3RydWN0IHhlbl9kcm1fZnJvbnRf c2hidWZfb3BzIGxvY2FsX29wcyA9IHsKKwkuY2FsY19udW1fZ3JlZnMgPSBndWVzdF9jYWxjX251 bV9ncmVmcywKKwkuZmlsbF9wYWdlX2RpciA9IGd1ZXN0X2ZpbGxfcGFnZV9kaXIsCisJLmdyYW50 X3JlZnNfZm9yX2J1ZmZlciA9IGd1ZXN0X2dyYW50X3JlZnNfZm9yX2J1ZmZlciwKK307CisKK3N0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICoKK3hlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2Moc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfY2ZnICpjZmcpCit7CisJc3RydWN0IHhlbl9kcm1fZnJv bnRfc2hidWYgKmJ1ZjsKKwlpbnQgcmV0OworCisJLyogZWl0aGVyIHBhZ2VzIG9yIHNndCwgbm90 IGJvdGggKi8KKwlpZiAodW5saWtlbHkoY2ZnLT5wYWdlcyAmJiBjZmctPnNndCkpIHsKKwkJRFJN X0VSUk9SKCJDYW5ub3QgaGFuZGxlIGJ1ZmZlciBhbGxvY2F0aW9uIHdpdGggYm90aCBwYWdlcyBh bmQgc2cgdGFibGUgcHJvdmlkZWRcbiIpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlidWYgPSBr emFsbG9jKHNpemVvZigqYnVmKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYpCisJCXJldHVybiBO VUxMOworCisJaWYgKGNmZy0+YmVfYWxsb2MpCisJCWJ1Zi0+b3BzID0gJmJhY2tlbmRfb3BzOwor CWVsc2UKKwkJYnVmLT5vcHMgPSAmbG9jYWxfb3BzOworCisJYnVmLT54Yl9kZXYgPSBjZmctPnhi X2RldjsKKwlidWYtPm51bV9wYWdlcyA9IERJVl9ST1VORF9VUChjZmctPnNpemUsIFBBR0VfU0la RSk7CisJYnVmLT5zZ3QgPSBjZmctPnNndDsKKwlidWYtPnBhZ2VzID0gY2ZnLT5wYWdlczsKKwor CWJ1Zi0+b3BzLT5jYWxjX251bV9ncmVmcyhidWYpOworCisJcmV0ID0gYWxsb2Nfc3RvcmFnZShi dWYpOworCWlmIChyZXQpCisJCWdvdG8gZmFpbDsKKworCXJldCA9IGdyYW50X3JlZmVyZW5jZXMo YnVmKTsKKwlpZiAocmV0KQorCQlnb3RvIGZhaWw7CisKKwlidWYtPm9wcy0+ZmlsbF9wYWdlX2Rp cihidWYpOworCisJcmV0dXJuIGJ1ZjsKKworZmFpbDoKKwl4ZW5fZHJtX2Zyb250X3NoYnVmX2Zy ZWUoYnVmKTsKKwlyZXR1cm4gRVJSX1BUUihyZXQpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X3NoYnVmLmggYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnRfc2hidWYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAuLjhjMDM3ZmQ3NjA4YgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udF9zaGJ1Zi5oCkBAIC0wLDAgKzEsNzIgQEAKKy8qIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wIE9SIE1JVCAqLworCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwg RFJNIGRldmljZQorICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJ bmMuCisgKgorICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2Fu ZHJ1c2hjaGVua29AZXBhbS5jb20+CisgKi8KKworI2lmbmRlZiBfX1hFTl9EUk1fRlJPTlRfU0hC VUZfSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX1NIQlVGX0hfCisKKyNpbmNsdWRlIDxsaW51 eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2F0dGVybGlzdC5oPgorCisjaW5jbHVkZSA8 eGVuL2dyYW50X3RhYmxlLmg+CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmIHsKKwkvKgor CSAqIG51bWJlciBvZiByZWZlcmVuY2VzIGdyYW50ZWQgZm9yIHRoZSBiYWNrZW5kIHVzZToKKwkg KiAgLSBmb3IgYWxsb2NhdGVkL2ltcG9ydGVkIGRtYS1idWYncyB0aGlzIGhvbGRzIG51bWJlciBv ZiBncmFudAorCSAqICAgIHJlZmVyZW5jZXMgZm9yIHRoZSBwYWdlIGRpcmVjdG9yeSBhbmQgcGFn ZXMgb2YgdGhlIGJ1ZmZlcgorCSAqICAtIGZvciB0aGUgYnVmZmVyIHByb3ZpZGVkIGJ5IHRoZSBi YWNrZW5kIHRoaXMgaG9sZHMgbnVtYmVyIG9mCisJICogICAgZ3JhbnQgcmVmZXJlbmNlcyBmb3Ig dGhlIHBhZ2UgZGlyZWN0b3J5IGFzIGdyYW50IHJlZmVyZW5jZXMgZm9yCisJICogICAgdGhlIGJ1 ZmZlciB3aWxsIGJlIHByb3ZpZGVkIGJ5IHRoZSBiYWNrZW5kCisJICovCisJaW50IG51bV9ncmVm czsKKwlncmFudF9yZWZfdCAqZ3JlZnM7CisJdW5zaWduZWQgY2hhciAqZGlyZWN0b3J5OworCisJ LyoKKwkgKiB0aGVyZSBhcmUgMiB3YXlzIHRvIHByb3ZpZGUgYmFja2luZyBzdG9yYWdlIGZvciB0 aGlzIHNoYXJlZCBidWZmZXI6CisJICogZWl0aGVyIHBhZ2VzIG9yIHNndC4gaWYgYnVmZmVyIGNy ZWF0ZWQgZnJvbSBzZ3QgdGhlbiB3ZSBvd24KKwkgKiB0aGUgcGFnZXMgYW5kIG11c3QgZnJlZSB0 aG9zZSBvdXJzZWx2ZXMgb24gY2xvc3VyZQorCSAqLworCWludCBudW1fcGFnZXM7CisJc3RydWN0 IHBhZ2UgKipwYWdlczsKKworCXN0cnVjdCBzZ190YWJsZSAqc2d0OworCisJc3RydWN0IHhlbmJ1 c19kZXZpY2UgKnhiX2RldjsKKworCS8qIHRoZXNlIGFyZSB0aGUgb3BzIHVzZWQgaW50ZXJuYWxs eSBkZXBlbmRpbmcgb24gYmVfYWxsb2MgbW9kZSAqLworCWNvbnN0IHN0cnVjdCB4ZW5fZHJtX2Zy b250X3NoYnVmX29wcyAqb3BzOworCisJLyogWGVuIG1hcCBoYW5kbGVzIGZvciB0aGUgYnVmZmVy IGFsbG9jYXRlZCBieSB0aGUgYmFja2VuZCAqLworCWdyYW50X2hhbmRsZV90ICpiYWNrZW5kX21h cF9oYW5kbGVzOworfTsKKworc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfY2ZnIHsKKwlzdHJ1 Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2OworCXNpemVfdCBzaXplOworCXN0cnVjdCBwYWdlICoq cGFnZXM7CisJc3RydWN0IHNnX3RhYmxlICpzZ3Q7CisJYm9vbCBiZV9hbGxvYzsKK307CisKK3N0 cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICoKK3hlbl9kcm1fZnJvbnRfc2hidWZfYWxsb2Moc3Ry dWN0IHhlbl9kcm1fZnJvbnRfc2hidWZfY2ZnICpjZmcpOworCitncmFudF9yZWZfdCB4ZW5fZHJt X2Zyb250X3NoYnVmX2dldF9kaXJfc3RhcnQoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1 Zik7CisKK2ludCB4ZW5fZHJtX2Zyb250X3NoYnVmX21hcChzdHJ1Y3QgeGVuX2RybV9mcm9udF9z aGJ1ZiAqYnVmKTsKKworaW50IHhlbl9kcm1fZnJvbnRfc2hidWZfdW5tYXAoc3RydWN0IHhlbl9k cm1fZnJvbnRfc2hidWYgKmJ1Zik7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9zaGJ1Zl9mbHVzaChz dHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAqYnVmKTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X3No YnVmX2ZyZWUoc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKmJ1Zik7CisKKyNlbmRpZiAvKiBf X1hFTl9EUk1fRlJPTlRfU0hCVUZfSF8gKi8KLS0gCjIuMTYuMgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmkt ZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755159AbeDCI2y (ORCPT ); Tue, 3 Apr 2018 04:28:54 -0400 Received: from mail-wr0-f181.google.com ([209.85.128.181]:45630 "EHLO mail-wr0-f181.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755110AbeDCI2r (ORCPT ); Tue, 3 Apr 2018 04:28:47 -0400 X-Google-Smtp-Source: AIpwx4/sHwIMuYujcoXu2XU/YtTcG6q4L7uohsCOIaKyOSr5+dmRfac3wWdFlbf3KTpiarD3JWGX2w== 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 v6 1/1] drm/xen-front: Add support for Xen PV display frontend Date: Tue, 3 Apr 2018 11:28:33 +0300 Message-Id: <20180403082833.26249-2-andr2000@gmail.com> X-Mailer: git-send-email 2.16.2 In-Reply-To: <20180403082833.26249-1-andr2000@gmail.com> References: <20180403082833.26249-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 | 882 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front.h | 188 ++++++ 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 | 311 ++++++++++ drivers/gpu/drm/xen/xen_drm_front_gem.h | 41 ++ drivers/gpu/drm/xen/xen_drm_front_gem_cma.c | 77 +++ drivers/gpu/drm/xen/xen_drm_front_kms.c | 370 ++++++++++++ drivers/gpu/drm/xen/xen_drm_front_kms.h | 26 + drivers/gpu/drm/xen/xen_drm_front_shbuf.c | 432 ++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_shbuf.h | 72 +++ 21 files changed, 3215 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..1e0ecd3aba39 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -0,0 +1,882 @@ +// 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; + u64 dbuf_cookie; + u64 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, u64 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, + u64 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, u64 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, u64 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, u8 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, + u32 x, u32 y, u32 width, u32 height, u32 bpp, u64 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, + u64 dbuf_cookie, u32 width, u32 height, + u32 bpp, u64 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, + u64 dbuf_cookie, u32 width, u32 height, + u32 bpp, u64 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, + u64 dbuf_cookie, u32 width, u32 height, + u32 bpp, u64 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, + u64 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, + u64 dbuf_cookie, u64 fb_cookie, u32 width, + u32 height, u32 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, + u64 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, u64 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, u64 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) { + unsigned int state; + + state = xenbus_read_unsigned(front_info->xb_dev->otherend, + "state", XenbusStateUnknown); + DRM_ERROR("Backend state is %s while removing driver\n", + xenbus_strstate(state)); + } + + 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..791239d3c34f --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -0,0 +1,188 @@ +/* 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 u64 xen_drm_front_fb_to_cookie(struct drm_framebuffer *fb) +{ + return (u64)fb; +} + +static inline u64 xen_drm_front_dbuf_to_cookie(struct drm_gem_object *gem_obj) +{ + return (u64)gem_obj; +} + +int xen_drm_front_mode_set(struct xen_drm_front_drm_pipeline *pipeline, + u32 x, u32 y, u32 width, u32 height, + u32 bpp, u64 fb_cookie); + +int xen_drm_front_dbuf_create_from_sgt(struct xen_drm_front_info *front_info, + u64 dbuf_cookie, u32 width, u32 height, + u32 bpp, u64 size, struct sg_table *sgt); + +int xen_drm_front_dbuf_create_from_pages(struct xen_drm_front_info *front_info, + u64 dbuf_cookie, u32 width, u32 height, + u32 bpp, u64 size, struct page **pages); + +int xen_drm_front_fb_attach(struct xen_drm_front_info *front_info, + u64 dbuf_cookie, u64 fb_cookie, u32 width, + u32 height, u32 pixel_format); + +int xen_drm_front_fb_detach(struct xen_drm_front_info *front_info, + u64 fb_cookie); + +int xen_drm_front_page_flip(struct xen_drm_front_info *front_info, + int conn_idx, u64 fb_cookie); + +void xen_drm_front_on_frame_done(struct xen_drm_front_info *front_info, + int conn_idx, u64 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..25216d99d1fc --- /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