From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 2/9] drm/xen-front: Implement Xen bus state handling Date: Wed, 21 Feb 2018 10:03:35 +0200 Message-ID: <1519200222-20623-3-git-send-email-andr2000@gmail.com> References: <1519200222-20623-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-x242.google.com (mail-lf0-x242.google.com [IPv6:2a00:1450:4010:c07::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id 422A36E522 for ; Wed, 21 Feb 2018 08:03:56 +0000 (UTC) Received: by mail-lf0-x242.google.com with SMTP id v9so1063632lfa.11 for ; Wed, 21 Feb 2018 00:03:56 -0800 (PST) In-Reply-To: <1519200222-20623-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 YW0uY29tPgoKSW5pdGlhbCBoYW5kbGluZyBmb3IgWGVuIGJ1cyBzdGF0ZXM6IGltcGxlbWVudApY ZW4gYnVzIHN0YXRlIG1hY2hpbmUgZm9yIHRoZSBmcm9udGVuZCBkcml2ZXIgYWNjb3JkaW5nIHRv CnRoZSBzdGF0ZSBkaWFncmFtIGFuZCByZWNvdmVyeSBmbG93IGZyb20gZGlzcGxheSBwYXJhLXZp cnR1YWxpemVkCnByb3RvY29sOiB4ZW4vaW50ZXJmYWNlL2lvL2Rpc3BsaWYuaC4KClNpZ25lZC1v ZmYtYnk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0Bl cGFtLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYyB8IDEyNCAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIGRyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udC5oIHwgIDI2ICsrKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDE0OSBpbnNl cnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUv ZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVu L3hlbl9kcm1fZnJvbnQuYyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jCmlu ZGV4IGZkMzcyZmI0NjRhMS4uZDAzMDZmOWQ2NjBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0veGVuL3hlbl9kcm1fZnJvbnQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnQuYwpAQCAtMjQsMTkgKzI0LDE0MSBAQAogCiAjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9p by9kaXNwbGlmLmg+CiAKKyNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250LmgiCisKK3N0YXRpYyB2b2lk IHhlbl9kcnZfcmVtb3ZlX2ludGVybmFsKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8pCit7Cit9CisKK3N0YXRpYyBpbnQgYmFja2VuZF9vbl9pbml0d2FpdChzdHJ1Y3QgeGVu X2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IGJhY2tlbmRfb25fY29ubmVjdGVkKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8pCit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGJhY2tlbmRfb25fZGlzY29u bmVjdGVkKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJeGVuYnVz X3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54Yl9kZXYsIFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5n KTsKK30KKwogc3RhdGljIHZvaWQgYmFja2VuZF9vbl9jaGFuZ2VkKHN0cnVjdCB4ZW5idXNfZGV2 aWNlICp4Yl9kZXYsCiAJCWVudW0geGVuYnVzX3N0YXRlIGJhY2tlbmRfc3RhdGUpCiB7CisJc3Ry dWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyA9IGRldl9nZXRfZHJ2ZGF0YSgmeGJf ZGV2LT5kZXYpOworCWludCByZXQ7CisKKwlEUk1fREVCVUcoIkJhY2tlbmQgc3RhdGUgaXMgJXMs IGZyb250IGlzICVzXG4iLAorCQkJeGVuYnVzX3N0cnN0YXRlKGJhY2tlbmRfc3RhdGUpLAorCQkJ eGVuYnVzX3N0cnN0YXRlKHhiX2Rldi0+c3RhdGUpKTsKKworCXN3aXRjaCAoYmFja2VuZF9zdGF0 ZSkgeworCWNhc2UgWGVuYnVzU3RhdGVSZWNvbmZpZ3VyaW5nOgorCQkvKiBmYWxsIHRocm91Z2gg Ki8KKwljYXNlIFhlbmJ1c1N0YXRlUmVjb25maWd1cmVkOgorCQkvKiBmYWxsIHRocm91Z2ggKi8K KwljYXNlIFhlbmJ1c1N0YXRlSW5pdGlhbGlzZWQ6CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNT dGF0ZUluaXRpYWxpc2luZzoKKwkJLyogcmVjb3ZlcmluZyBhZnRlciBiYWNrZW5kIHVuZXhwZWN0 ZWQgY2xvc3VyZSAqLworCQliYWNrZW5kX29uX2Rpc2Nvbm5lY3RlZChmcm9udF9pbmZvKTsKKwkJ YnJlYWs7CisKKwljYXNlIFhlbmJ1c1N0YXRlSW5pdFdhaXQ6CisJCS8qIHJlY292ZXJpbmcgYWZ0 ZXIgYmFja2VuZCB1bmV4cGVjdGVkIGNsb3N1cmUgKi8KKwkJYmFja2VuZF9vbl9kaXNjb25uZWN0 ZWQoZnJvbnRfaW5mbyk7CisJCWlmICh4Yl9kZXYtPnN0YXRlICE9IFhlbmJ1c1N0YXRlSW5pdGlh bGlzaW5nKQorCQkJYnJlYWs7CisKKwkJcmV0ID0gYmFja2VuZF9vbl9pbml0d2FpdChmcm9udF9p bmZvKTsKKwkJaWYgKHJldCA8IDApCisJCQl4ZW5idXNfZGV2X2ZhdGFsKHhiX2RldiwgcmV0LCAi aW5pdGlhbGl6aW5nIGZyb250ZW5kIik7CisJCWVsc2UKKwkJCXhlbmJ1c19zd2l0Y2hfc3RhdGUo eGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2VkKTsKKwkJYnJlYWs7CisKKwljYXNlIFhlbmJ1 c1N0YXRlQ29ubmVjdGVkOgorCQlpZiAoeGJfZGV2LT5zdGF0ZSAhPSBYZW5idXNTdGF0ZUluaXRp YWxpc2VkKQorCQkJYnJlYWs7CisKKwkJcmV0ID0gYmFja2VuZF9vbl9jb25uZWN0ZWQoZnJvbnRf aW5mbyk7CisJCWlmIChyZXQgPCAwKQorCQkJeGVuYnVzX2Rldl9mYXRhbCh4Yl9kZXYsIHJldCwg ImluaXRpYWxpemluZyBEUk0gZHJpdmVyIik7CisJCWVsc2UKKwkJCXhlbmJ1c19zd2l0Y2hfc3Rh dGUoeGJfZGV2LCBYZW5idXNTdGF0ZUNvbm5lY3RlZCk7CisJCWJyZWFrOworCisJY2FzZSBYZW5i dXNTdGF0ZUNsb3Npbmc6CisJCS8qCisJCSAqIGluIHRoaXMgc3RhdGUgYmFja2VuZCBzdGFydHMg ZnJlZWluZyByZXNvdXJjZXMsCisJCSAqIHNvIGxldCBpdCBnbyBpbnRvIGNsb3NlZCBzdGF0ZSwg c28gd2UgY2FuIGFsc28KKwkJICogcmVtb3ZlIG91cnMKKwkJICovCisJCWJyZWFrOworCisJY2Fz ZSBYZW5idXNTdGF0ZVVua25vd246CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2UgWGVuYnVz U3RhdGVDbG9zZWQ6CisJCWlmICh4Yl9kZXYtPnN0YXRlID09IFhlbmJ1c1N0YXRlQ2xvc2VkKQor CQkJYnJlYWs7CisKKwkJYmFja2VuZF9vbl9kaXNjb25uZWN0ZWQoZnJvbnRfaW5mbyk7CisJCWJy ZWFrOworCX0KIH0KIAogc3RhdGljIGludCB4ZW5fZHJ2X3Byb2JlKHN0cnVjdCB4ZW5idXNfZGV2 aWNlICp4Yl9kZXYsCiAJCWNvbnN0IHN0cnVjdCB4ZW5idXNfZGV2aWNlX2lkICppZCkKIHsKLQly ZXR1cm4gMDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvOworCisJZnJv bnRfaW5mbyA9IGRldm1fa3phbGxvYygmeGJfZGV2LT5kZXYsCisJCQlzaXplb2YoKmZyb250X2lu Zm8pLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWZyb250X2luZm8pIHsKKwkJeGVuYnVzX2Rldl9mYXRh bCh4Yl9kZXYsIC1FTk9NRU0sICJhbGxvY2F0aW5nIGRldmljZSBtZW1vcnkiKTsKKwkJcmV0dXJu IC1FTk9NRU07CisJfQorCisJZnJvbnRfaW5mby0+eGJfZGV2ID0geGJfZGV2OworCWRldl9zZXRf ZHJ2ZGF0YSgmeGJfZGV2LT5kZXYsIGZyb250X2luZm8pOworCXJldHVybiB4ZW5idXNfc3dpdGNo X3N0YXRlKHhiX2RldiwgWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpOwogfQogCiBzdGF0aWMgaW50 IHhlbl9kcnZfcmVtb3ZlKHN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYpCiB7CisJc3RydWN0IHhl bl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbyA9IGRldl9nZXRfZHJ2ZGF0YSgmZGV2LT5kZXYp OworCWludCB0byA9IDEwMDsKKworCXhlbmJ1c19zd2l0Y2hfc3RhdGUoZGV2LCBYZW5idXNTdGF0 ZUNsb3NpbmcpOworCisJLyoKKwkgKiBPbiBkcml2ZXIgcmVtb3ZhbCBpdCBpcyBkaXNjb25uZWN0 ZWQgZnJvbSBYZW5CdXMsCisJICogc28gbm8gYmFja2VuZCBzdGF0ZSBjaGFuZ2UgZXZlbnRzIGNv bWUgdmlhIC5vdGhlcmVuZF9jaGFuZ2VkCisJICogY2FsbGJhY2suIFRoaXMgcHJldmVudHMgdXMg ZnJvbSBleGl0aW5nIGdyYWNlZnVsbHksIGUuZy4KKwkgKiBzaWduYWxpbmcgdGhlIGJhY2tlbmQg dG8gZnJlZSBldmVudCBjaGFubmVscywgd2FpdGluZyBmb3IgaXRzCisJICogc3RhdGUgdG8gY2hh bmdlIHRvIFhlbmJ1c1N0YXRlQ2xvc2VkIGFuZCBjbGVhbmluZyBhdCBvdXIgZW5kLgorCSAqIE5v cm1hbGx5IHdoZW4gZnJvbnQgZHJpdmVyIHJlbW92ZWQgYmFja2VuZCB3aWxsIGZpbmFsbHkgZ28g aW50bworCSAqIFhlbmJ1c1N0YXRlSW5pdFdhaXQgc3RhdGUuCisJICoKKwkgKiBXb3JrYXJvdW5k OiByZWFkIGJhY2tlbmQncyBzdGF0ZSBtYW51YWxseSBhbmQgd2FpdCB3aXRoIHRpbWUtb3V0Lgor CSAqLworCXdoaWxlICgoeGVuYnVzX3JlYWRfdW5zaWduZWQoZnJvbnRfaW5mby0+eGJfZGV2LT5v dGhlcmVuZCwKKwkJCSJzdGF0ZSIsIFhlbmJ1c1N0YXRlVW5rbm93bikgIT0gWGVuYnVzU3RhdGVJ bml0V2FpdCkgJiYKKwkJCXRvLS0pCisJCW1zbGVlcCgxMCk7CisKKwlpZiAoIXRvKQorCQlEUk1f RVJST1IoIkJhY2tlbmQgc3RhdGUgaXMgJXMgd2hpbGUgcmVtb3ZpbmcgZHJpdmVyXG4iLAorCQkJ eGVuYnVzX3N0cnN0YXRlKHhlbmJ1c19yZWFkX3Vuc2lnbmVkKAorCQkJCQlmcm9udF9pbmZvLT54 Yl9kZXYtPm90aGVyZW5kLAorCQkJCQkic3RhdGUiLCBYZW5idXNTdGF0ZVVua25vd24pKSk7CisK Kwl4ZW5fZHJ2X3JlbW92ZV9pbnRlcm5hbChmcm9udF9pbmZvKTsKKwl4ZW5idXNfZnJvbnRlbmRf Y2xvc2VkKGRldik7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udC5oIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250 LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi44YWY0Njg1MGYxMjYK LS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaApA QCAtMCwwICsxLDI2IEBACisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoK KyAqICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vciBtb2RpZnkKKyAqICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqICAgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqICAg KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgIFRoaXMgcHJvZ3Jh bSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog ICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlCisgKiAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1z IEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJf YW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9I XworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfSF8KKworc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5m byB7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldjsKK307CisKKyNlbmRpZiAvKiBfX1hF Tl9EUk1fRlJPTlRfSF8gKi8KLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f 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 S1751887AbeBUIEA (ORCPT ); Wed, 21 Feb 2018 03:04:00 -0500 Received: from mail-lf0-f67.google.com ([209.85.215.67]:37373 "EHLO mail-lf0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751800AbeBUID4 (ORCPT ); Wed, 21 Feb 2018 03:03:56 -0500 X-Google-Smtp-Source: AH8x226LVoCGFVg//M1LNjSaukAPPnpvfI1uwfHDkinWWWZjdLbCQRgoQPAx/4Kg+b9Acjdculo8jA== 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 2/9] drm/xen-front: Implement Xen bus state handling Date: Wed, 21 Feb 2018 10:03:35 +0200 Message-Id: <1519200222-20623-3-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1519200222-20623-1-git-send-email-andr2000@gmail.com> References: <1519200222-20623-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 Initial handling for Xen bus states: 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. Signed-off-by: Oleksandr Andrushchenko --- drivers/gpu/drm/xen/xen_drm_front.c | 124 +++++++++++++++++++++++++++++++++++- drivers/gpu/drm/xen/xen_drm_front.h | 26 ++++++++ 2 files changed, 149 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/xen/xen_drm_front.h diff --git a/drivers/gpu/drm/xen/xen_drm_front.c b/drivers/gpu/drm/xen/xen_drm_front.c index fd372fb464a1..d0306f9d660d 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.c +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -24,19 +24,141 @@ #include +#include "xen_drm_front.h" + +static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) +{ +} + +static int backend_on_initwait(struct xen_drm_front_info *front_info) +{ + return 0; +} + +static int backend_on_connected(struct xen_drm_front_info *front_info) +{ + return 0; +} + +static void backend_on_disconnected(struct xen_drm_front_info *front_info) +{ + xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); +} + static void backend_on_changed(struct xenbus_device *xb_dev, enum xenbus_state backend_state) { + struct xen_drm_front_info *front_info = dev_get_drvdata(&xb_dev->dev); + int ret; + + DRM_DEBUG("Backend state is %s, front is %s\n", + xenbus_strstate(backend_state), + xenbus_strstate(xb_dev->state)); + + switch (backend_state) { + case XenbusStateReconfiguring: + /* fall through */ + case XenbusStateReconfigured: + /* fall through */ + case XenbusStateInitialised: + break; + + case XenbusStateInitialising: + /* recovering after backend unexpected closure */ + backend_on_disconnected(front_info); + break; + + case XenbusStateInitWait: + /* recovering after backend unexpected closure */ + backend_on_disconnected(front_info); + if (xb_dev->state != XenbusStateInitialising) + break; + + ret = backend_on_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 = backend_on_connected(front_info); + if (ret < 0) + xenbus_dev_fatal(xb_dev, ret, "initializing DRM driver"); + else + xenbus_switch_state(xb_dev, XenbusStateConnected); + break; + + case XenbusStateClosing: + /* + * in this state backend starts freeing resources, + * so let it go into closed state, so we can also + * remove ours + */ + break; + + case XenbusStateUnknown: + /* fall through */ + case XenbusStateClosed: + if (xb_dev->state == XenbusStateClosed) + break; + + backend_on_disconnected(front_info); + break; + } } static int xen_drv_probe(struct xenbus_device *xb_dev, const struct xenbus_device_id *id) { - return 0; + struct xen_drm_front_info *front_info; + + front_info = devm_kzalloc(&xb_dev->dev, + sizeof(*front_info), GFP_KERNEL); + if (!front_info) { + xenbus_dev_fatal(xb_dev, -ENOMEM, "allocating device memory"); + return -ENOMEM; + } + + front_info->xb_dev = xb_dev; + dev_set_drvdata(&xb_dev->dev, front_info); + return xenbus_switch_state(xb_dev, XenbusStateInitialising); } static int xen_drv_remove(struct xenbus_device *dev) { + struct xen_drm_front_info *front_info = dev_get_drvdata(&dev->dev); + int to = 100; + + xenbus_switch_state(dev, XenbusStateClosing); + + /* + * On driver removal it is disconnected from XenBus, + * so no backend state change events come via .otherend_changed + * callback. This prevents us from exiting gracefully, e.g. + * signaling the backend to free event channels, waiting for its + * state to change to XenbusStateClosed and cleaning at our end. + * Normally when front driver removed backend will finally go into + * XenbusStateInitWait state. + * + * Workaround: read backend's state manually and wait with time-out. + */ + while ((xenbus_read_unsigned(front_info->xb_dev->otherend, + "state", XenbusStateUnknown) != XenbusStateInitWait) && + to--) + msleep(10); + + if (!to) + DRM_ERROR("Backend state is %s while removing driver\n", + xenbus_strstate(xenbus_read_unsigned( + front_info->xb_dev->otherend, + "state", XenbusStateUnknown))); + + xen_drv_remove_internal(front_info); + xenbus_frontend_closed(dev); return 0; } 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..8af46850f126 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -0,0 +1,26 @@ +/* + * Xen para-virtual DRM device + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#ifndef __XEN_DRM_FRONT_H_ +#define __XEN_DRM_FRONT_H_ + +struct xen_drm_front_info { + struct xenbus_device *xb_dev; +}; + +#endif /* __XEN_DRM_FRONT_H_ */ -- 2.7.4