From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 4/8] drm/xen-front: Implement Xen event channel handling Date: Tue, 13 Mar 2018 15:31:03 +0200 Message-ID: <1520947867-32514-5-git-send-email-andr2000@gmail.com> References: <1520947867-32514-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id C8C896E4E4 for ; Tue, 13 Mar 2018 13:31:24 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id u21-v6so6533923lfc.7 for ; Tue, 13 Mar 2018 06:31:24 -0700 (PDT) In-Reply-To: <1520947867-32514-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKSGFuZGxlIFhlbiBldmVudCBjaGFubmVsczoKICAtIGNyZWF0ZSBmb3IgYWxsIGNv bmZpZ3VyZWQgY29ubmVjdG9ycyBhbmQgcHVibGlzaAogICAgY29ycmVzcG9uZGluZyByaW5nIHJl ZmVyZW5jZXMgYW5kIGV2ZW50IGNoYW5uZWxzIGluIFhlbiBzdG9yZSwKICAgIHNvIGJhY2tlbmQg Y2FuIGNvbm5lY3QKICAtIGltcGxlbWVudCBldmVudCBjaGFubmVscyBpbnRlcnJ1cHQgaGFuZGxl cnMKICAtIGNyZWF0ZSBhbmQgZGVzdHJveSBldmVudCBjaGFubmVscyB3aXRoIHJlc3BlY3QgdG8g WGVuIGJ1cyBzdGF0ZQoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9s ZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS94ZW4v TWFrZWZpbGUgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5f ZHJtX2Zyb250LmMgICAgICAgICB8ICAxMiArLQogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJt X2Zyb250LmggICAgICAgICB8ICAxNiArKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250X2V2dGNobmwuYyB8IDM4MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oIHwgIDc5ICsrKysrKwogNSBmaWxl cyBjaGFuZ2VkLCA0ODggaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmMKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5o CgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1 L2RybS94ZW4vTWFrZWZpbGUKaW5kZXggZDNlYzhjODU4OWUwLi44NDE3MzMyZjNiNTggMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJt L3hlbi9NYWtlZmlsZQpAQCAtMSw2ICsxLDcgQEAKICMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAgT1IgTUlUCiAKIGRybV94ZW5fZnJvbnQtb2JqcyA6PSB4ZW5fZHJtX2Zyb250Lm8g XAorCQkgICAgICB4ZW5fZHJtX2Zyb250X2V2dGNobmwubyBcCiAJCSAgICAgIHhlbl9kcm1fZnJv bnRfY2ZnLm8KIAogb2JqLSQoQ09ORklHX0RSTV9YRU5fRlJPTlRFTkQpICs9IGRybV94ZW5fZnJv bnQubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMgYi9k cml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwppbmRleCBjYTQyY2ViMjRhNDAuLjgz MTJkYWI4NjJlMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMKQEAgLTE3LDkgKzE3 LDExIEBACiAjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CiAKICNpbmNsdWRl ICJ4ZW5fZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9ldnRjaG5sLmgiCiAK IHN0YXRpYyB2b2lkIHhlbl9kcnZfcmVtb3ZlX2ludGVybmFsKHN0cnVjdCB4ZW5fZHJtX2Zyb250 X2luZm8gKmZyb250X2luZm8pCiB7CisJeGVuX2RybV9mcm9udF9ldnRjaG5sX2ZyZWVfYWxsKGZy b250X2luZm8pOwogfQogCiBzdGF0aWMgaW50IGRpc3BsYmFja19pbml0d2FpdChzdHJ1Y3QgeGVu X2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQpAQCAtMzMsMTYgKzM1LDIzIEBAIHN0YXRpYyBp bnQgZGlzcGxiYWNrX2luaXR3YWl0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8pCiAJCXJldHVybiByZXQ7CiAKIAlEUk1fSU5GTygiSGF2ZSAlZCBjb25lY3RvcihzKVxuIiwg Y2ZnLT5udW1fY29ubmVjdG9ycyk7Ci0JcmV0dXJuIDA7CisJLyogQ3JlYXRlIGV2ZW50IGNoYW5u ZWxzIGZvciBhbGwgY29ubmVjdG9ycyBhbmQgcHVibGlzaCAqLworCXJldCA9IHhlbl9kcm1fZnJv bnRfZXZ0Y2hubF9jcmVhdGVfYWxsKGZyb250X2luZm8pOworCWlmIChyZXQgPCAwKQorCQlyZXR1 cm4gcmV0OworCisJcmV0dXJuIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wdWJsaXNoX2FsbChmcm9u dF9pbmZvKTsKIH0KIAogc3RhdGljIGludCBkaXNwbGJhY2tfY29ubmVjdChzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQogeworCXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zZXRf c3RhdGUoZnJvbnRfaW5mbywgRVZUQ0hOTF9TVEFURV9DT05ORUNURUQpOwogCXJldHVybiAwOwog fQogCiBzdGF0aWMgdm9pZCBkaXNwbGJhY2tfZGlzY29ubmVjdChzdHJ1Y3QgeGVuX2RybV9mcm9u dF9pbmZvICpmcm9udF9pbmZvKQogeworCXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zZXRfc3RhdGUo ZnJvbnRfaW5mbywgRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQpOwogCXhlbmJ1c19zd2l0Y2hf c3RhdGUoZnJvbnRfaW5mby0+eGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2luZyk7CiB9CiAK QEAgLTEyNSw2ICsxMzQsNyBAQCBzdGF0aWMgaW50IHhlbl9kcnZfcHJvYmUoc3RydWN0IHhlbmJ1 c19kZXZpY2UgKnhiX2RldiwKIAkJcmV0dXJuIC1FTk9NRU07CiAKIAlmcm9udF9pbmZvLT54Yl9k ZXYgPSB4Yl9kZXY7CisJc3Bpbl9sb2NrX2luaXQoJmZyb250X2luZm8tPmlvX2xvY2spOwogCWRl dl9zZXRfZHJ2ZGF0YSgmeGJfZGV2LT5kZXYsIGZyb250X2luZm8pOwogCXJldHVybiB4ZW5idXNf c3dpdGNoX3N0YXRlKHhiX2RldiwgWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpOwogfQpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmggYi9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnQuaAppbmRleCAwMzRhMzk4NzY1N2UuLjRhZGI2MTAxYzg4OSAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKKysrIGIvZHJp dmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKQEAgLTEzLDggKzEzLDI0IEBACiAKICNp bmNsdWRlICJ4ZW5fZHJtX2Zyb250X2NmZy5oIgogCisjaWZuZGVmIEdSQU5UX0lOVkFMSURfUkVG CisvKgorICogTm90ZSBvbiB1c2FnZSBvZiBncmFudCByZWZlcmVuY2UgMCBhcyBpbnZhbGlkIGdy YW50IHJlZmVyZW5jZToKKyAqIGdyYW50IHJlZmVyZW5jZSAwIGlzIHZhbGlkLCBidXQgbmV2ZXIg ZXhwb3NlZCB0byBhIFBWIGRyaXZlciwKKyAqIGJlY2F1c2Ugb2YgdGhlIGZhY3QgaXQgaXMgYWxy ZWFkeSBpbiB1c2UvcmVzZXJ2ZWQgYnkgdGhlIFBWIGNvbnNvbGUuCisgKi8KKyNkZWZpbmUgR1JB TlRfSU5WQUxJRF9SRUYJMAorI2VuZGlmCisKIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gewog CXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXY7CisJLyogdG8gcHJvdGVjdCBkYXRhIGJldHdl ZW4gYmFja2VuZCBJTyBjb2RlIGFuZCBpbnRlcnJ1cHQgaGFuZGxlciAqLworCXNwaW5sb2NrX3Qg aW9fbG9jazsKKwkvKiB2aXJ0dWFsIERSTSBwbGF0Zm9ybSBkZXZpY2UgKi8KKwlzdHJ1Y3QgcGxh dGZvcm1fZGV2aWNlICpkcm1fcGRldjsKKworCWludCBudW1fZXZ0X3BhaXJzOworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2V2dGNobmxfcGFpciAqZXZ0X3BhaXJzOwogCXN0cnVjdCB4ZW5fZHJtX2Zy b250X2NmZyBjZmc7CiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9k cm1fZnJvbnRfZXZ0Y2hubC5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2 dGNobmwuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmZkOTI4OWE2 YTFjOAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9u dF9ldnRjaG5sLmMKQEAgLTAsMCArMSwzODEgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wIE9SIE1JVAorCisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQor ICoKKyAqIENvcHlyaWdodCAoQykgMjAxNi0yMDE4IEVQQU0gU3lzdGVtcyBJbmMuCisgKgorICog QXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29A ZXBhbS5jb20+CisgKi8KKworI2luY2x1ZGUgPGRybS9kcm1QLmg+CisKKyNpbmNsdWRlIDxsaW51 eC9lcnJuby5oPgorI2luY2x1ZGUgPGxpbnV4L2lycS5oPgorCisjaW5jbHVkZSA8eGVuL3hlbmJ1 cy5oPgorI2luY2x1ZGUgPHhlbi9ldmVudHMuaD4KKyNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUu aD4KKworI2luY2x1ZGUgInhlbl9kcm1fZnJvbnQuaCIKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250 X2V2dGNobmwuaCIKKworc3RhdGljIGlycXJldHVybl90IGV2dGNobmxfaW50ZXJydXB0X2N0cmwo aW50IGlycSwgdm9pZCAqZGV2X2lkKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwg KmV2dGNobmwgPSBkZXZfaWQ7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5m byA9IGV2dGNobmwtPmZyb250X2luZm87CisJc3RydWN0IHhlbmRpc3BsX3Jlc3AgKnJlc3A7CisJ UklOR19JRFggaSwgcnA7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKworCWlmICh1bmxpa2VseShl dnRjaG5sLT5zdGF0ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkpCisJCXJldHVybiBJUlFf SEFORExFRDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFn cyk7CisKK2FnYWluOgorCXJwID0gZXZ0Y2hubC0+dS5yZXEucmluZy5zcmluZy0+cnNwX3Byb2Q7 CisJLyogZW5zdXJlIHdlIHNlZSBxdWV1ZWQgcmVzcG9uc2VzIHVwIHRvIHJwICovCisJdmlydF9y bWIoKTsKKworCWZvciAoaSA9IGV2dGNobmwtPnUucmVxLnJpbmcucnNwX2NvbnM7IGkgIT0gcnA7 IGkrKykgeworCQlyZXNwID0gUklOR19HRVRfUkVTUE9OU0UoJmV2dGNobmwtPnUucmVxLnJpbmcs IGkpOworCQlpZiAodW5saWtlbHkocmVzcC0+aWQgIT0gZXZ0Y2hubC0+ZXZ0X2lkKSkKKwkJCWNv bnRpbnVlOworCisJCXN3aXRjaCAocmVzcC0+b3BlcmF0aW9uKSB7CisJCWNhc2UgWEVORElTUExf T1BfUEdfRkxJUDoKKwkJY2FzZSBYRU5ESVNQTF9PUF9GQl9BVFRBQ0g6CisJCWNhc2UgWEVORElT UExfT1BfRkJfREVUQUNIOgorCQljYXNlIFhFTkRJU1BMX09QX0RCVUZfQ1JFQVRFOgorCQljYXNl IFhFTkRJU1BMX09QX0RCVUZfREVTVFJPWToKKwkJY2FzZSBYRU5ESVNQTF9PUF9TRVRfQ09ORklH OgorCQkJZXZ0Y2hubC0+dS5yZXEucmVzcF9zdGF0dXMgPSByZXNwLT5zdGF0dXM7CisJCQljb21w bGV0ZSgmZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlvbik7CisJCQlicmVhazsKKworCQlkZWZhdWx0 OgorCQkJRFJNX0VSUk9SKCJPcGVyYXRpb24gJWQgaXMgbm90IHN1cHBvcnRlZFxuIiwKKwkJCQly ZXNwLT5vcGVyYXRpb24pOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlldnRjaG5sLT51LnJlcS5y aW5nLnJzcF9jb25zID0gaTsKKworCWlmIChpICE9IGV2dGNobmwtPnUucmVxLnJpbmcucmVxX3By b2RfcHZ0KSB7CisJCWludCBtb3JlX3RvX2RvOworCisJCVJJTkdfRklOQUxfQ0hFQ0tfRk9SX1JF U1BPTlNFUygmZXZ0Y2hubC0+dS5yZXEucmluZywKKwkJCQltb3JlX3RvX2RvKTsKKwkJaWYgKG1v cmVfdG9fZG8pCisJCQlnb3RvIGFnYWluOworCX0gZWxzZQorCQlldnRjaG5sLT51LnJlcS5yaW5n LnNyaW5nLT5yc3BfZXZlbnQgPSBpICsgMTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZy b250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKK3N0 YXRpYyBpcnFyZXR1cm5fdCBldnRjaG5sX2ludGVycnVwdF9ldnQoaW50IGlycSwgdm9pZCAqZGV2 X2lkKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwgPSBkZXZfaWQ7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyA9IGV2dGNobmwtPmZyb250 X2luZm87CisJc3RydWN0IHhlbmRpc3BsX2V2ZW50X3BhZ2UgKnBhZ2UgPSBldnRjaG5sLT51LmV2 dC5wYWdlOworCXVpbnQzMl90IGNvbnMsIHByb2Q7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwor CWlmICh1bmxpa2VseShldnRjaG5sLT5zdGF0ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkp CisJCXJldHVybiBJUlFfSEFORExFRDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZv LT5pb19sb2NrLCBmbGFncyk7CisKKwlwcm9kID0gcGFnZS0+aW5fcHJvZDsKKwkvKiBlbnN1cmUg d2Ugc2VlIHJpbmcgY29udGVudHMgdXAgdG8gcHJvZCAqLworCXZpcnRfcm1iKCk7CisJaWYgKHBy b2QgPT0gcGFnZS0+aW5fY29ucykKKwkJZ290byBvdXQ7CisKKwlmb3IgKGNvbnMgPSBwYWdlLT5p bl9jb25zOyBjb25zICE9IHByb2Q7IGNvbnMrKykgeworCQlzdHJ1Y3QgeGVuZGlzcGxfZXZ0ICpl dmVudDsKKworCQlldmVudCA9ICZYRU5ESVNQTF9JTl9SSU5HX1JFRihwYWdlLCBjb25zKTsKKwkJ aWYgKHVubGlrZWx5KGV2ZW50LT5pZCAhPSBldnRjaG5sLT5ldnRfaWQrKykpCisJCQljb250aW51 ZTsKKworCQlzd2l0Y2ggKGV2ZW50LT50eXBlKSB7CisJCWNhc2UgWEVORElTUExfRVZUX1BHX0ZM SVA6CisJCQkvKiBwbGFjZWhvbGRlciAqLworCQkJYnJlYWs7CisJCX0KKwl9CisJcGFnZS0+aW5f Y29ucyA9IGNvbnM7CisJLyogZW5zdXJlIHJpbmcgY29udGVudHMgKi8KKwl2aXJ0X3dtYigpOwor CitvdXQ6CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxh Z3MpOworCXJldHVybiBJUlFfSEFORExFRDsKK30KKworc3RhdGljIHZvaWQgZXZ0Y2hubF9mcmVl KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJt X2Zyb250X2V2dGNobmwgKmV2dGNobmwpCit7CisJdW5zaWduZWQgbG9uZyBwYWdlID0gMDsKKwor CWlmIChldnRjaG5sLT50eXBlID09IEVWVENITkxfVFlQRV9SRVEpCisJCXBhZ2UgPSAodW5zaWdu ZWQgbG9uZylldnRjaG5sLT51LnJlcS5yaW5nLnNyaW5nOworCWVsc2UgaWYgKGV2dGNobmwtPnR5 cGUgPT0gRVZUQ0hOTF9UWVBFX0VWVCkKKwkJcGFnZSA9ICh1bnNpZ25lZCBsb25nKWV2dGNobmwt PnUuZXZ0LnBhZ2U7CisJaWYgKCFwYWdlKQorCQlyZXR1cm47CisKKwlldnRjaG5sLT5zdGF0ZSA9 IEVWVENITkxfU1RBVEVfRElTQ09OTkVDVEVEOworCisJaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZU Q0hOTF9UWVBFX1JFUSkgeworCQkvKiByZWxlYXNlIGFsbCB3aG8gc3RpbGwgd2FpdHMgZm9yIHJl c3BvbnNlIGlmIGFueSAqLworCQlldnRjaG5sLT51LnJlcS5yZXNwX3N0YXR1cyA9IC1FSU87CisJ CWNvbXBsZXRlX2FsbCgmZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlvbik7CisJfQorCisJaWYgKGV2 dGNobmwtPmlycSkKKwkJdW5iaW5kX2Zyb21faXJxaGFuZGxlcihldnRjaG5sLT5pcnEsIGV2dGNo bmwpOworCisJaWYgKGV2dGNobmwtPnBvcnQpCisJCXhlbmJ1c19mcmVlX2V2dGNobihmcm9udF9p bmZvLT54Yl9kZXYsIGV2dGNobmwtPnBvcnQpOworCisJLyogZW5kIGFjY2VzcyBhbmQgZnJlZSB0 aGUgcGFnZSAqLworCWlmIChldnRjaG5sLT5ncmVmICE9IEdSQU5UX0lOVkFMSURfUkVGKQorCQln bnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzKGV2dGNobmwtPmdyZWYsIDAsIHBhZ2UpOworCisJbWVt c2V0KGV2dGNobmwsIDAsIHNpemVvZigqZXZ0Y2hubCkpOworfQorCitzdGF0aWMgaW50IGV2dGNo bmxfYWxsb2Moc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywgaW50IGluZGV4 LAorCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sLAorCQllbnVtIHhlbl9k cm1fZnJvbnRfZXZ0Y2hubF90eXBlIHR5cGUpCit7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhi X2RldiA9IGZyb250X2luZm8tPnhiX2RldjsKKwl1bnNpZ25lZCBsb25nIHBhZ2U7CisJZ3JhbnRf cmVmX3QgZ3JlZjsKKwlpcnFfaGFuZGxlcl90IGhhbmRsZXI7CisJaW50IHJldDsKKworCW1lbXNl dChldnRjaG5sLCAwLCBzaXplb2YoKmV2dGNobmwpKTsKKwlldnRjaG5sLT50eXBlID0gdHlwZTsK KwlldnRjaG5sLT5pbmRleCA9IGluZGV4OworCWV2dGNobmwtPmZyb250X2luZm8gPSBmcm9udF9p bmZvOworCWV2dGNobmwtPnN0YXRlID0gRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQ7CisJZXZ0 Y2hubC0+Z3JlZiA9IEdSQU5UX0lOVkFMSURfUkVGOworCisJcGFnZSA9IGdldF96ZXJvZWRfcGFn ZShHRlBfTk9JTyB8IF9fR0ZQX0hJR0gpOworCWlmICghcGFnZSkgeworCQlyZXQgPSAtRU5PTUVN OworCQlnb3RvIGZhaWw7CisJfQorCisJaWYgKHR5cGUgPT0gRVZUQ0hOTF9UWVBFX1JFUSkgewor CQlzdHJ1Y3QgeGVuX2Rpc3BsaWZfc3JpbmcgKnNyaW5nOworCisJCWluaXRfY29tcGxldGlvbigm ZXZ0Y2hubC0+dS5yZXEuY29tcGxldGlvbik7CisJCXNyaW5nID0gKHN0cnVjdCB4ZW5fZGlzcGxp Zl9zcmluZyAqKXBhZ2U7CisJCVNIQVJFRF9SSU5HX0lOSVQoc3JpbmcpOworCQlGUk9OVF9SSU5H X0lOSVQoJmV2dGNobmwtPnUucmVxLnJpbmcsCisJCQkJc3JpbmcsIFhFTl9QQUdFX1NJWkUpOwor CisJCXJldCA9IHhlbmJ1c19ncmFudF9yaW5nKHhiX2Rldiwgc3JpbmcsIDEsICZncmVmKTsKKwkJ aWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWw7CisKKwkJaGFuZGxlciA9IGV2dGNobmxfaW50ZXJy dXB0X2N0cmw7CisJfSBlbHNlIHsKKwkJZXZ0Y2hubC0+dS5ldnQucGFnZSA9IChzdHJ1Y3QgeGVu ZGlzcGxfZXZlbnRfcGFnZSAqKXBhZ2U7CisKKwkJcmV0ID0gZ250dGFiX2dyYW50X2ZvcmVpZ25f YWNjZXNzKHhiX2Rldi0+b3RoZXJlbmRfaWQsCisJCQkJdmlydF90b19nZm4oKHZvaWQgKilwYWdl KSwgMCk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsOworCisJCWdyZWYgPSByZXQ7CisJ CWhhbmRsZXIgPSBldnRjaG5sX2ludGVycnVwdF9ldnQ7CisJfQorCWV2dGNobmwtPmdyZWYgPSBn cmVmOworCisJcmV0ID0geGVuYnVzX2FsbG9jX2V2dGNobih4Yl9kZXYsICZldnRjaG5sLT5wb3J0 KTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0gYmluZF9ldnRjaG5fdG9f aXJxaGFuZGxlcihldnRjaG5sLT5wb3J0LAorCQkJaGFuZGxlciwgMCwgeGJfZGV2LT5kZXZpY2V0 eXBlLCBldnRjaG5sKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJZXZ0Y2hubC0+ aXJxID0gcmV0OworCXJldHVybiAwOworCitmYWlsOgorCURSTV9FUlJPUigiRmFpbGVkIHRvIGFs bG9jYXRlIHJpbmc6ICVkXG4iLCByZXQpOworCXJldHVybiByZXQ7Cit9CisKK2ludCB4ZW5fZHJt X2Zyb250X2V2dGNobmxfY3JlYXRlX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9u dF9pbmZvKQoreworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqY2ZnOworCWludCByZXQsIGNv bm47CisKKwljZmcgPSAmZnJvbnRfaW5mby0+Y2ZnOworCisJZnJvbnRfaW5mby0+ZXZ0X3BhaXJz ID0gZGV2bV9rY2FsbG9jKCZmcm9udF9pbmZvLT54Yl9kZXYtPmRldiwKKwkJCWNmZy0+bnVtX2Nv bm5lY3RvcnMsCisJCQlzaXplb2Yoc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wYWlyKSwg R0ZQX0tFUk5FTCk7CisJaWYgKCFmcm9udF9pbmZvLT5ldnRfcGFpcnMpIHsKKwkJcmV0ID0gLUVO T01FTTsKKwkJZ290byBmYWlsOworCX0KKworCWZvciAoY29ubiA9IDA7IGNvbm4gPCBjZmctPm51 bV9jb25uZWN0b3JzOyBjb25uKyspIHsKKwkJcmV0ID0gZXZ0Y2hubF9hbGxvYyhmcm9udF9pbmZv LCBjb25uLAorCQkJCSZmcm9udF9pbmZvLT5ldnRfcGFpcnNbY29ubl0ucmVxLAorCQkJCUVWVENI TkxfVFlQRV9SRVEpOworCQlpZiAocmV0IDwgMCkgeworCQkJRFJNX0VSUk9SKCJFcnJvciBhbGxv Y2F0aW5nIGNvbnRyb2wgY2hhbm5lbFxuIik7CisJCQlnb3RvIGZhaWw7CisJCX0KKworCQlyZXQg PSBldnRjaG5sX2FsbG9jKGZyb250X2luZm8sIGNvbm4sCisJCQkJJmZyb250X2luZm8tPmV2dF9w YWlyc1tjb25uXS5ldnQsCisJCQkJRVZUQ0hOTF9UWVBFX0VWVCk7CisJCWlmIChyZXQgPCAwKSB7 CisJCQlEUk1fRVJST1IoIkVycm9yIGFsbG9jYXRpbmcgaW4tZXZlbnQgY2hhbm5lbFxuIik7CisJ CQlnb3RvIGZhaWw7CisJCX0KKwl9CisJZnJvbnRfaW5mby0+bnVtX2V2dF9wYWlycyA9IGNmZy0+ bnVtX2Nvbm5lY3RvcnM7CisJcmV0dXJuIDA7CisKK2ZhaWw6CisJeGVuX2RybV9mcm9udF9ldnRj aG5sX2ZyZWVfYWxsKGZyb250X2luZm8pOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQg ZXZ0Y2hubF9wdWJsaXNoKHN0cnVjdCB4ZW5idXNfdHJhbnNhY3Rpb24geGJ0LAorCQlzdHJ1Y3Qg eGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sLCBjb25zdCBjaGFyICpwYXRoLAorCQljb25z dCBjaGFyICpub2RlX3JpbmcsIGNvbnN0IGNoYXIgKm5vZGVfY2hubCkKK3sKKwlzdHJ1Y3QgeGVu YnVzX2RldmljZSAqeGJfZGV2ID0gZXZ0Y2hubC0+ZnJvbnRfaW5mby0+eGJfZGV2OworCWludCBy ZXQ7CisKKwkvKiB3cml0ZSBjb250cm9sIGNoYW5uZWwgcmluZyByZWZlcmVuY2UgKi8KKwlyZXQg PSB4ZW5idXNfcHJpbnRmKHhidCwgcGF0aCwgbm9kZV9yaW5nLCAiJXUiLCBldnRjaG5sLT5ncmVm KTsKKwlpZiAocmV0IDwgMCkgeworCQl4ZW5idXNfZGV2X2Vycm9yKHhiX2RldiwgcmV0LCAid3Jp dGluZyByaW5nLXJlZiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCS8qIHdyaXRlIGV2ZW50IGNo YW5uZWwgcmluZyByZWZlcmVuY2UgKi8KKwlyZXQgPSB4ZW5idXNfcHJpbnRmKHhidCwgcGF0aCwg bm9kZV9jaG5sLCAiJXUiLCBldnRjaG5sLT5wb3J0KTsKKwlpZiAocmV0IDwgMCkgeworCQl4ZW5i dXNfZGV2X2Vycm9yKHhiX2RldiwgcmV0LCAid3JpdGluZyBldmVudCBjaGFubmVsIik7CisJCXJl dHVybiByZXQ7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK2ludCB4ZW5fZHJtX2Zyb250X2V2dGNo bmxfcHVibGlzaF9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKK3sK KwlzdHJ1Y3QgeGVuYnVzX3RyYW5zYWN0aW9uIHhidDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9j ZmcgKnBsYXRfZGF0YTsKKwlpbnQgcmV0LCBjb25uOworCisJcGxhdF9kYXRhID0gJmZyb250X2lu Zm8tPmNmZzsKKworYWdhaW46CisJcmV0ID0geGVuYnVzX3RyYW5zYWN0aW9uX3N0YXJ0KCZ4YnQp OworCWlmIChyZXQgPCAwKSB7CisJCXhlbmJ1c19kZXZfZmF0YWwoZnJvbnRfaW5mby0+eGJfZGV2 LCByZXQsCisJCQkJInN0YXJ0aW5nIHRyYW5zYWN0aW9uIik7CisJCXJldHVybiByZXQ7CisJfQor CisJZm9yIChjb25uID0gMDsgY29ubiA8IHBsYXRfZGF0YS0+bnVtX2Nvbm5lY3RvcnM7IGNvbm4r KykgeworCQlyZXQgPSBldnRjaG5sX3B1Ymxpc2goeGJ0LAorCQkJCSZmcm9udF9pbmZvLT5ldnRf cGFpcnNbY29ubl0ucmVxLAorCQkJCXBsYXRfZGF0YS0+Y29ubmVjdG9yc1tjb25uXS54ZW5zdG9y ZV9wYXRoLAorCQkJCVhFTkRJU1BMX0ZJRUxEX1JFUV9SSU5HX1JFRiwKKwkJCQlYRU5ESVNQTF9G SUVMRF9SRVFfQ0hBTk5FTCk7CisJCWlmIChyZXQgPCAwKQorCQkJZ290byBmYWlsOworCisJCXJl dCA9IGV2dGNobmxfcHVibGlzaCh4YnQsCisJCQkJJmZyb250X2luZm8tPmV2dF9wYWlyc1tjb25u XS5ldnQsCisJCQkJcGxhdF9kYXRhLT5jb25uZWN0b3JzW2Nvbm5dLnhlbnN0b3JlX3BhdGgsCisJ CQkJWEVORElTUExfRklFTERfRVZUX1JJTkdfUkVGLAorCQkJCVhFTkRJU1BMX0ZJRUxEX0VWVF9D SEFOTkVMKTsKKwkJaWYgKHJldCA8IDApCisJCQlnb3RvIGZhaWw7CisJfQorCisJcmV0ID0geGVu YnVzX3RyYW5zYWN0aW9uX2VuZCh4YnQsIDApOworCWlmIChyZXQgPCAwKSB7CisJCWlmIChyZXQg PT0gLUVBR0FJTikKKwkJCWdvdG8gYWdhaW47CisKKwkJeGVuYnVzX2Rldl9mYXRhbChmcm9udF9p bmZvLT54Yl9kZXYsIHJldCwKKwkJCQkiY29tcGxldGluZyB0cmFuc2FjdGlvbiIpOworCQlnb3Rv IGZhaWxfdG9fZW5kOworCX0KKworCXJldHVybiAwOworCitmYWlsOgorCXhlbmJ1c190cmFuc2Fj dGlvbl9lbmQoeGJ0LCAxKTsKKworZmFpbF90b19lbmQ6CisJeGVuYnVzX2Rldl9mYXRhbChmcm9u dF9pbmZvLT54Yl9kZXYsIHJldCwgIndyaXRpbmcgWGVuIHN0b3JlIik7CisJcmV0dXJuIHJldDsK K30KKwordm9pZCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJv bnRfZXZ0Y2hubCAqZXZ0Y2hubCkKK3sKKwlpbnQgbm90aWZ5OworCisJZXZ0Y2hubC0+dS5yZXEu cmluZy5yZXFfcHJvZF9wdnQrKzsKKwlSSU5HX1BVU0hfUkVRVUVTVFNfQU5EX0NIRUNLX05PVElG WSgmZXZ0Y2hubC0+dS5yZXEucmluZywgbm90aWZ5KTsKKwlpZiAobm90aWZ5KQorCQlub3RpZnlf cmVtb3RlX3ZpYV9pcnEoZXZ0Y2hubC0+aXJxKTsKK30KKwordm9pZCB4ZW5fZHJtX2Zyb250X2V2 dGNobmxfc2V0X3N0YXRlKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJ CWVudW0geGVuX2RybV9mcm9udF9ldnRjaG5sX3N0YXRlIHN0YXRlKQoreworCXVuc2lnbmVkIGxv bmcgZmxhZ3M7CisJaW50IGk7CisKKwlpZiAoIWZyb250X2luZm8tPmV2dF9wYWlycykKKwkJcmV0 dXJuOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsK Kwlmb3IgKGkgPSAwOyBpIDwgZnJvbnRfaW5mby0+bnVtX2V2dF9wYWlyczsgaSsrKSB7CisJCWZy b250X2luZm8tPmV2dF9wYWlyc1tpXS5yZXEuc3RhdGUgPSBzdGF0ZTsKKwkJZnJvbnRfaW5mby0+ ZXZ0X3BhaXJzW2ldLmV2dC5zdGF0ZSA9IHN0YXRlOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0 b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKK30KKwordm9pZCB4ZW5fZHJtX2Zy b250X2V2dGNobmxfZnJlZV9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5m bykKK3sKKwlpbnQgaTsKKworCWlmICghZnJvbnRfaW5mby0+ZXZ0X3BhaXJzKQorCQlyZXR1cm47 CisKKwlmb3IgKGkgPSAwOyBpIDwgZnJvbnRfaW5mby0+bnVtX2V2dF9wYWlyczsgaSsrKSB7CisJ CWV2dGNobmxfZnJlZShmcm9udF9pbmZvLCAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2ldLnJlcSk7 CisJCWV2dGNobmxfZnJlZShmcm9udF9pbmZvLCAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2ldLmV2 dCk7CisJfQorCisJZGV2bV9rZnJlZSgmZnJvbnRfaW5mby0+eGJfZGV2LT5kZXYsIGZyb250X2lu Zm8tPmV2dF9wYWlycyk7CisJZnJvbnRfaW5mby0+ZXZ0X3BhaXJzID0gTlVMTDsKK30KZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmggYi9kcml2 ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOGZhYWNmOTQ0NGU2Ci0tLSAvZGV2L251bGwKKysrIGIv ZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuaApAQCAtMCwwICsxLDc5 IEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCBPUiBNSVQgKi8KKworLyoK KyAqICBYZW4gcGFyYS12aXJ0dWFsIERSTSBkZXZpY2UKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MTYtMjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5k ZWYgX19YRU5fRFJNX0ZST05UX0VWVENITkxfSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0VW VENITkxfSF8KKworI2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4KKyNpbmNsdWRlIDxsaW51 eC90eXBlcy5oPgorCisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9yaW5nLmg+CisjaW5jbHVk ZSA8eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CisKKy8qCisgKiBBbGwgb3BlcmF0aW9ucyB3 aGljaCBhcmUgbm90IGNvbm5lY3RvciBvcmllbnRlZCB1c2UgdGhpcyBjdHJsIGV2ZW50IGNoYW5u ZWwsCisgKiBlLmcuIGZiX2F0dGFjaC9kZXN0cm95IHdoaWNoIGJlbG9uZyB0byBhIERSTSBkZXZp Y2UsIG5vdCB0byBhIENSVEMuCisgKi8KKyNkZWZpbmUgR0VORVJJQ19PUF9FVlRfQ0hOTAkwCisK K2VudW0geGVuX2RybV9mcm9udF9ldnRjaG5sX3N0YXRlIHsKKwlFVlRDSE5MX1NUQVRFX0RJU0NP Tk5FQ1RFRCwKKwlFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCwKK307CisKK2VudW0geGVuX2RybV9m cm9udF9ldnRjaG5sX3R5cGUgeworCUVWVENITkxfVFlQRV9SRVEsCisJRVZUQ0hOTF9UWVBFX0VW VCwKK307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvOworCitzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9ldnRjaG5sIHsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZv OworCWludCBncmVmOworCWludCBwb3J0OworCWludCBpcnE7CisJaW50IGluZGV4OworCWVudW0g eGVuX2RybV9mcm9udF9ldnRjaG5sX3N0YXRlIHN0YXRlOworCWVudW0geGVuX2RybV9mcm9udF9l dnRjaG5sX3R5cGUgdHlwZTsKKwkvKiBlaXRoZXIgcmVzcG9uc2UgaWQgb3IgaW5jb21pbmcgZXZl bnQgaWQgKi8KKwl1aW50MTZfdCBldnRfaWQ7CisJLyogbmV4dCByZXF1ZXN0IGlkIG9yIG5leHQg ZXhwZWN0ZWQgZXZlbnQgaWQgKi8KKwl1aW50MTZfdCBldnRfbmV4dF9pZDsKKwl1bmlvbiB7CisJ CXN0cnVjdCB7CisJCQlzdHJ1Y3QgeGVuX2Rpc3BsaWZfZnJvbnRfcmluZyByaW5nOworCQkJc3Ry dWN0IGNvbXBsZXRpb24gY29tcGxldGlvbjsKKwkJCS8qIGxhdGVzdCByZXNwb25zZSBzdGF0dXMg Ki8KKwkJCWludCByZXNwX3N0YXR1czsKKwkJfSByZXE7CisJCXN0cnVjdCB7CisJCQlzdHJ1Y3Qg eGVuZGlzcGxfZXZlbnRfcGFnZSAqcGFnZTsKKwkJfSBldnQ7CisJfSB1OworfTsKKworc3RydWN0 IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wYWlyIHsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRj aG5sIHJlcTsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sIGV2dDsKK307CisKK2ludCB4 ZW5fZHJtX2Zyb250X2V2dGNobmxfY3JlYXRlX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZv ICpmcm9udF9pbmZvKTsKKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wdWJsaXNoX2FsbChz dHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKTsKKwordm9pZCB4ZW5fZHJtX2Zy b250X2V2dGNobmxfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCk7 CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShzdHJ1Y3QgeGVuX2RybV9m cm9udF9pbmZvICpmcm9udF9pbmZvLAorCQllbnVtIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zdGF0 ZSBzdGF0ZSk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2ZyZWVfYWxsKHN0cnVjdCB4 ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pOworCisjZW5kaWYgLyogX19YRU5fRFJNX0ZS T05UX0VWVENITkxfSF8gKi8KLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0 cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933026AbeCMNbb (ORCPT ); Tue, 13 Mar 2018 09:31:31 -0400 Received: from mail-lf0-f67.google.com ([209.85.215.67]:34566 "EHLO mail-lf0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932756AbeCMNbY (ORCPT ); Tue, 13 Mar 2018 09:31:24 -0400 X-Google-Smtp-Source: AG47ELurAQopYAI8bmxCU5plSnQZm/jai7+Iv9ZegM9L57DtDdx7QBjJl3N9v7Xm8hvR30CPOHdiSw== 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 v2 4/8] drm/xen-front: Implement Xen event channel handling Date: Tue, 13 Mar 2018 15:31:03 +0200 Message-Id: <1520947867-32514-5-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1520947867-32514-1-git-send-email-andr2000@gmail.com> References: <1520947867-32514-1-git-send-email-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko 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 Signed-off-by: Oleksandr Andrushchenko --- drivers/gpu/drm/xen/Makefile | 1 + drivers/gpu/drm/xen/xen_drm_front.c | 12 +- drivers/gpu/drm/xen/xen_drm_front.h | 16 ++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.c | 381 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.h | 79 ++++++ 5 files changed, 488 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/xen/xen_drm_front_evtchnl.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_evtchnl.h diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile index d3ec8c8589e0..8417332f3b58 100644 --- a/drivers/gpu/drm/xen/Makefile +++ b/drivers/gpu/drm/xen/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 OR MIT drm_xen_front-objs := xen_drm_front.o \ + xen_drm_front_evtchnl.o \ xen_drm_front_cfg.o 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 index ca42ceb24a40..8312dab862e2 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.c +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -17,9 +17,11 @@ #include #include "xen_drm_front.h" +#include "xen_drm_front_evtchnl.h" static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) { + xen_drm_front_evtchnl_free_all(front_info); } static int displback_initwait(struct xen_drm_front_info *front_info) @@ -33,16 +35,23 @@ static int displback_initwait(struct xen_drm_front_info *front_info) return ret; DRM_INFO("Have %d conector(s)\n", cfg->num_connectors); - return 0; + /* 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 0; } static void displback_disconnect(struct xen_drm_front_info *front_info) { + xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_DISCONNECTED); xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); } @@ -125,6 +134,7 @@ static int xen_drv_probe(struct xenbus_device *xb_dev, return -ENOMEM; front_info->xb_dev = xb_dev; + spin_lock_init(&front_info->io_lock); dev_set_drvdata(&xb_dev->dev, front_info); return xenbus_switch_state(xb_dev, XenbusStateInitialising); } diff --git a/drivers/gpu/drm/xen/xen_drm_front.h b/drivers/gpu/drm/xen/xen_drm_front.h index 034a3987657e..4adb6101c889 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.h +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -13,8 +13,24 @@ #include "xen_drm_front_cfg.h" +#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; + /* to protect data between backend IO code and interrupt handler */ + spinlock_t io_lock; + /* virtual DRM platform device */ + struct platform_device *drm_pdev; + + int num_evt_pairs; + struct xen_drm_front_evtchnl_pair *evt_pairs; struct xen_drm_front_cfg cfg; }; diff --git a/drivers/gpu/drm/xen/xen_drm_front_evtchnl.c b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.c new file mode 100644 index 000000000000..fd9289a6a1c8 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.c @@ -0,0 +1,381 @@ +// SPDX-License-Identifier: GPL-2.0 OR MIT + +/* + * Xen para-virtual DRM device + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include + +#include +#include + +#include +#include +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_evtchnl.h" + +static irqreturn_t evtchnl_interrupt_ctrl(int irq, void *dev_id) +{ + struct xen_drm_front_evtchnl *evtchnl = dev_id; + struct xen_drm_front_info *front_info = evtchnl->front_info; + struct xendispl_resp *resp; + RING_IDX i, rp; + unsigned long flags; + + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + return IRQ_HANDLED; + + spin_lock_irqsave(&front_info->io_lock, flags); + +again: + rp = evtchnl->u.req.ring.sring->rsp_prod; + /* ensure we see queued responses up to rp */ + virt_rmb(); + + for (i = evtchnl->u.req.ring.rsp_cons; i != rp; i++) { + resp = RING_GET_RESPONSE(&evtchnl->u.req.ring, i); + if (unlikely(resp->id != evtchnl->evt_id)) + continue; + + switch (resp->operation) { + case XENDISPL_OP_PG_FLIP: + case XENDISPL_OP_FB_ATTACH: + case XENDISPL_OP_FB_DETACH: + case XENDISPL_OP_DBUF_CREATE: + case XENDISPL_OP_DBUF_DESTROY: + case XENDISPL_OP_SET_CONFIG: + evtchnl->u.req.resp_status = resp->status; + complete(&evtchnl->u.req.completion); + break; + + default: + DRM_ERROR("Operation %d is not supported\n", + resp->operation); + break; + } + } + + evtchnl->u.req.ring.rsp_cons = i; + + if (i != evtchnl->u.req.ring.req_prod_pvt) { + int more_to_do; + + RING_FINAL_CHECK_FOR_RESPONSES(&evtchnl->u.req.ring, + more_to_do); + if (more_to_do) + goto again; + } else + evtchnl->u.req.ring.sring->rsp_event = i + 1; + + spin_unlock_irqrestore(&front_info->io_lock, flags); + return IRQ_HANDLED; +} + +static irqreturn_t evtchnl_interrupt_evt(int irq, void *dev_id) +{ + struct xen_drm_front_evtchnl *evtchnl = dev_id; + struct xen_drm_front_info *front_info = evtchnl->front_info; + struct xendispl_event_page *page = evtchnl->u.evt.page; + uint32_t cons, prod; + unsigned long flags; + + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + return IRQ_HANDLED; + + spin_lock_irqsave(&front_info->io_lock, flags); + + prod = page->in_prod; + /* ensure we see ring contents up to prod */ + virt_rmb(); + if (prod == page->in_cons) + goto out; + + for (cons = page->in_cons; cons != prod; cons++) { + struct xendispl_evt *event; + + event = &XENDISPL_IN_RING_REF(page, cons); + if (unlikely(event->id != evtchnl->evt_id++)) + continue; + + switch (event->type) { + case XENDISPL_EVT_PG_FLIP: + /* placeholder */ + break; + } + } + page->in_cons = cons; + /* ensure ring contents */ + virt_wmb(); + +out: + spin_unlock_irqrestore(&front_info->io_lock, flags); + return IRQ_HANDLED; +} + +static void evtchnl_free(struct xen_drm_front_info *front_info, + struct xen_drm_front_evtchnl *evtchnl) +{ + unsigned long page = 0; + + if (evtchnl->type == EVTCHNL_TYPE_REQ) + page = (unsigned long)evtchnl->u.req.ring.sring; + else if (evtchnl->type == EVTCHNL_TYPE_EVT) + page = (unsigned long)evtchnl->u.evt.page; + if (!page) + return; + + evtchnl->state = EVTCHNL_STATE_DISCONNECTED; + + if (evtchnl->type == EVTCHNL_TYPE_REQ) { + /* release all who still waits for response if any */ + evtchnl->u.req.resp_status = -EIO; + complete_all(&evtchnl->u.req.completion); + } + + if (evtchnl->irq) + unbind_from_irqhandler(evtchnl->irq, evtchnl); + + if (evtchnl->port) + xenbus_free_evtchn(front_info->xb_dev, evtchnl->port); + + /* end access and free the page */ + if (evtchnl->gref != GRANT_INVALID_REF) + gnttab_end_foreign_access(evtchnl->gref, 0, page); + + memset(evtchnl, 0, sizeof(*evtchnl)); +} + +static int evtchnl_alloc(struct xen_drm_front_info *front_info, int index, + struct xen_drm_front_evtchnl *evtchnl, + enum xen_drm_front_evtchnl_type type) +{ + struct xenbus_device *xb_dev = front_info->xb_dev; + unsigned long page; + grant_ref_t gref; + irq_handler_t handler; + int ret; + + memset(evtchnl, 0, sizeof(*evtchnl)); + evtchnl->type = type; + evtchnl->index = index; + evtchnl->front_info = front_info; + evtchnl->state = EVTCHNL_STATE_DISCONNECTED; + evtchnl->gref = GRANT_INVALID_REF; + + page = get_zeroed_page(GFP_NOIO | __GFP_HIGH); + if (!page) { + ret = -ENOMEM; + goto fail; + } + + if (type == EVTCHNL_TYPE_REQ) { + struct xen_displif_sring *sring; + + init_completion(&evtchnl->u.req.completion); + sring = (struct xen_displif_sring *)page; + SHARED_RING_INIT(sring); + FRONT_RING_INIT(&evtchnl->u.req.ring, + sring, XEN_PAGE_SIZE); + + ret = xenbus_grant_ring(xb_dev, sring, 1, &gref); + if (ret < 0) + goto fail; + + handler = evtchnl_interrupt_ctrl; + } else { + evtchnl->u.evt.page = (struct xendispl_event_page *)page; + + ret = gnttab_grant_foreign_access(xb_dev->otherend_id, + virt_to_gfn((void *)page), 0); + if (ret < 0) + goto fail; + + gref = ret; + handler = evtchnl_interrupt_evt; + } + evtchnl->gref = gref; + + ret = xenbus_alloc_evtchn(xb_dev, &evtchnl->port); + if (ret < 0) + goto fail; + + ret = bind_evtchn_to_irqhandler(evtchnl->port, + handler, 0, xb_dev->devicetype, evtchnl); + if (ret < 0) + goto fail; + + evtchnl->irq = ret; + return 0; + +fail: + DRM_ERROR("Failed to allocate ring: %d\n", ret); + return ret; +} + +int xen_drm_front_evtchnl_create_all(struct xen_drm_front_info *front_info) +{ + struct xen_drm_front_cfg *cfg; + int ret, conn; + + cfg = &front_info->cfg; + + front_info->evt_pairs = devm_kcalloc(&front_info->xb_dev->dev, + cfg->num_connectors, + sizeof(struct xen_drm_front_evtchnl_pair), GFP_KERNEL); + if (!front_info->evt_pairs) { + ret = -ENOMEM; + goto fail; + } + + for (conn = 0; conn < cfg->num_connectors; conn++) { + ret = evtchnl_alloc(front_info, conn, + &front_info->evt_pairs[conn].req, + EVTCHNL_TYPE_REQ); + if (ret < 0) { + DRM_ERROR("Error allocating control channel\n"); + goto fail; + } + + ret = evtchnl_alloc(front_info, conn, + &front_info->evt_pairs[conn].evt, + EVTCHNL_TYPE_EVT); + if (ret < 0) { + DRM_ERROR("Error allocating in-event channel\n"); + goto fail; + } + } + front_info->num_evt_pairs = cfg->num_connectors; + return 0; + +fail: + xen_drm_front_evtchnl_free_all(front_info); + return ret; +} + +static int evtchnl_publish(struct xenbus_transaction xbt, + struct xen_drm_front_evtchnl *evtchnl, const char *path, + const char *node_ring, const char *node_chnl) +{ + struct xenbus_device *xb_dev = evtchnl->front_info->xb_dev; + int ret; + + /* write control channel ring reference */ + ret = xenbus_printf(xbt, path, node_ring, "%u", evtchnl->gref); + if (ret < 0) { + xenbus_dev_error(xb_dev, ret, "writing ring-ref"); + return ret; + } + + /* write event channel ring reference */ + ret = xenbus_printf(xbt, path, node_chnl, "%u", evtchnl->port); + if (ret < 0) { + xenbus_dev_error(xb_dev, ret, "writing event channel"); + return ret; + } + + return 0; +} + +int xen_drm_front_evtchnl_publish_all(struct xen_drm_front_info *front_info) +{ + struct xenbus_transaction xbt; + struct xen_drm_front_cfg *plat_data; + int ret, conn; + + plat_data = &front_info->cfg; + +again: + ret = xenbus_transaction_start(&xbt); + if (ret < 0) { + xenbus_dev_fatal(front_info->xb_dev, ret, + "starting transaction"); + return ret; + } + + for (conn = 0; conn < plat_data->num_connectors; conn++) { + ret = evtchnl_publish(xbt, + &front_info->evt_pairs[conn].req, + plat_data->connectors[conn].xenstore_path, + XENDISPL_FIELD_REQ_RING_REF, + XENDISPL_FIELD_REQ_CHANNEL); + if (ret < 0) + goto fail; + + ret = evtchnl_publish(xbt, + &front_info->evt_pairs[conn].evt, + plat_data->connectors[conn].xenstore_path, + XENDISPL_FIELD_EVT_RING_REF, + XENDISPL_FIELD_EVT_CHANNEL); + if (ret < 0) + goto fail; + } + + ret = xenbus_transaction_end(xbt, 0); + if (ret < 0) { + if (ret == -EAGAIN) + goto again; + + xenbus_dev_fatal(front_info->xb_dev, ret, + "completing transaction"); + goto fail_to_end; + } + + return 0; + +fail: + xenbus_transaction_end(xbt, 1); + +fail_to_end: + xenbus_dev_fatal(front_info->xb_dev, ret, "writing Xen store"); + return ret; +} + +void xen_drm_front_evtchnl_flush(struct xen_drm_front_evtchnl *evtchnl) +{ + int notify; + + evtchnl->u.req.ring.req_prod_pvt++; + RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&evtchnl->u.req.ring, notify); + if (notify) + notify_remote_via_irq(evtchnl->irq); +} + +void xen_drm_front_evtchnl_set_state(struct xen_drm_front_info *front_info, + enum xen_drm_front_evtchnl_state state) +{ + unsigned long flags; + int i; + + if (!front_info->evt_pairs) + return; + + spin_lock_irqsave(&front_info->io_lock, flags); + for (i = 0; i < front_info->num_evt_pairs; i++) { + front_info->evt_pairs[i].req.state = state; + front_info->evt_pairs[i].evt.state = state; + } + spin_unlock_irqrestore(&front_info->io_lock, flags); + +} + +void xen_drm_front_evtchnl_free_all(struct xen_drm_front_info *front_info) +{ + int i; + + if (!front_info->evt_pairs) + return; + + for (i = 0; i < front_info->num_evt_pairs; i++) { + evtchnl_free(front_info, &front_info->evt_pairs[i].req); + evtchnl_free(front_info, &front_info->evt_pairs[i].evt); + } + + devm_kfree(&front_info->xb_dev->dev, front_info->evt_pairs); + front_info->evt_pairs = NULL; +} diff --git a/drivers/gpu/drm/xen/xen_drm_front_evtchnl.h b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.h new file mode 100644 index 000000000000..8faacf9444e6 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.h @@ -0,0 +1,79 @@ +/* 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_EVTCHNL_H_ +#define __XEN_DRM_FRONT_EVTCHNL_H_ + +#include +#include + +#include +#include + +/* + * All operations which are not connector oriented use this ctrl event channel, + * e.g. fb_attach/destroy which belong to a DRM device, not to a CRTC. + */ +#define GENERIC_OP_EVT_CHNL 0 + +enum xen_drm_front_evtchnl_state { + EVTCHNL_STATE_DISCONNECTED, + EVTCHNL_STATE_CONNECTED, +}; + +enum xen_drm_front_evtchnl_type { + EVTCHNL_TYPE_REQ, + EVTCHNL_TYPE_EVT, +}; + +struct xen_drm_front_drm_info; + +struct xen_drm_front_evtchnl { + struct xen_drm_front_info *front_info; + int gref; + int port; + int irq; + int index; + enum xen_drm_front_evtchnl_state state; + enum xen_drm_front_evtchnl_type type; + /* either response id or incoming event id */ + uint16_t evt_id; + /* next request id or next expected event id */ + uint16_t evt_next_id; + union { + struct { + struct xen_displif_front_ring ring; + struct completion completion; + /* latest response status */ + int resp_status; + } req; + struct { + struct xendispl_event_page *page; + } evt; + } u; +}; + +struct xen_drm_front_evtchnl_pair { + struct xen_drm_front_evtchnl req; + struct xen_drm_front_evtchnl evt; +}; + +int xen_drm_front_evtchnl_create_all(struct xen_drm_front_info *front_info); + +int xen_drm_front_evtchnl_publish_all(struct xen_drm_front_info *front_info); + +void xen_drm_front_evtchnl_flush(struct xen_drm_front_evtchnl *evtchnl); + +void xen_drm_front_evtchnl_set_state(struct xen_drm_front_info *front_info, + enum xen_drm_front_evtchnl_state state); + +void xen_drm_front_evtchnl_free_all(struct xen_drm_front_info *front_info); + +#endif /* __XEN_DRM_FRONT_EVTCHNL_H_ */ -- 2.7.4