From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 2/8] drm/xen-front: Implement Xen bus state handling Date: Tue, 13 Mar 2018 15:31:01 +0200 Message-ID: <1520947867-32514-3-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-x242.google.com (mail-lf0-x242.google.com [IPv6:2a00:1450:4010:c07::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id B40056E4E7 for ; Tue, 13 Mar 2018 13:31:20 +0000 (UTC) Received: by mail-lf0-x242.google.com with SMTP id i80-v6so28798591lfg.5 for ; Tue, 13 Mar 2018 06:31:20 -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 YW0uY29tPgoKSW5pdGlhbCBoYW5kbGluZyBmb3IgWGVuIGJ1cyBzdGF0ZXM6IGltcGxlbWVudApY ZW4gYnVzIHN0YXRlIG1hY2hpbmUgZm9yIHRoZSBmcm9udGVuZCBkcml2ZXIgYWNjb3JkaW5nIHRv CnRoZSBzdGF0ZSBkaWFncmFtIGFuZCByZWNvdmVyeSBmbG93IGZyb20gZGlzcGxheSBwYXJhLXZp cnR1YWxpemVkCnByb3RvY29sOiB4ZW4vaW50ZXJmYWNlL2lvL2Rpc3BsaWYuaC4KClNpZ25lZC1v ZmYtYnk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNoZW5rb0Bl cGFtLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYyB8IDEyNCAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIGRyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udC5oIHwgIDE4ICsrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAxNDEgaW5zZXJ0 aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2Ry bS94ZW4veGVuX2RybV9mcm9udC5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250LmMgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwppbmRl eCAwM2JjNTBiMTI4ZmQuLjUyMGI1YjM0NTIwYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250LmMKQEAgLTE2LDE5ICsxNiwxNDEgQEAKIAogI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UvaW8v ZGlzcGxpZi5oPgogCisjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorCitzdGF0aWMgdm9pZCB4 ZW5fZHJ2X3JlbW92ZV9pbnRlcm5hbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9p bmZvKQoreworfQorCitzdGF0aWMgaW50IGRpc3BsYmFja19pbml0d2FpdChzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50 IGRpc3BsYmFja19jb25uZWN0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8p Cit7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGRpc3BsYmFja19kaXNjb25uZWN0KHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCit7CisJeGVuYnVzX3N3aXRjaF9z dGF0ZShmcm9udF9pbmZvLT54Yl9kZXYsIFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5nKTsKK30KKwog c3RhdGljIHZvaWQgZGlzcGxiYWNrX2NoYW5nZWQoc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2Rl diwKIAkJZW51bSB4ZW5idXNfc3RhdGUgYmFja2VuZF9zdGF0ZSkKIHsKKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvID0gZGV2X2dldF9kcnZkYXRhKCZ4Yl9kZXYtPmRldik7 CisJaW50IHJldDsKKworCURSTV9ERUJVRygiQmFja2VuZCBzdGF0ZSBpcyAlcywgZnJvbnQgaXMg JXNcbiIsCisJCQl4ZW5idXNfc3Ryc3RhdGUoYmFja2VuZF9zdGF0ZSksCisJCQl4ZW5idXNfc3Ry c3RhdGUoeGJfZGV2LT5zdGF0ZSkpOworCisJc3dpdGNoIChiYWNrZW5kX3N0YXRlKSB7CisJY2Fz ZSBYZW5idXNTdGF0ZVJlY29uZmlndXJpbmc6CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2Ug WGVuYnVzU3RhdGVSZWNvbmZpZ3VyZWQ6CisJCS8qIGZhbGwgdGhyb3VnaCAqLworCWNhc2UgWGVu YnVzU3RhdGVJbml0aWFsaXNlZDoKKwkJYnJlYWs7CisKKwljYXNlIFhlbmJ1c1N0YXRlSW5pdGlh bGlzaW5nOgorCQkvKiByZWNvdmVyaW5nIGFmdGVyIGJhY2tlbmQgdW5leHBlY3RlZCBjbG9zdXJl ICovCisJCWRpc3BsYmFja19kaXNjb25uZWN0KGZyb250X2luZm8pOworCQlicmVhazsKKworCWNh c2UgWGVuYnVzU3RhdGVJbml0V2FpdDoKKwkJLyogcmVjb3ZlcmluZyBhZnRlciBiYWNrZW5kIHVu ZXhwZWN0ZWQgY2xvc3VyZSAqLworCQlkaXNwbGJhY2tfZGlzY29ubmVjdChmcm9udF9pbmZvKTsK KwkJaWYgKHhiX2Rldi0+c3RhdGUgIT0gWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpCisJCQlicmVh azsKKworCQlyZXQgPSBkaXNwbGJhY2tfaW5pdHdhaXQoZnJvbnRfaW5mbyk7CisJCWlmIChyZXQg PCAwKQorCQkJeGVuYnVzX2Rldl9mYXRhbCh4Yl9kZXYsIHJldCwKKwkJCQkJImluaXRpYWxpemlu ZyBmcm9udGVuZCIpOworCQllbHNlCisJCQl4ZW5idXNfc3dpdGNoX3N0YXRlKHhiX2RldiwgWGVu YnVzU3RhdGVJbml0aWFsaXNlZCk7CisJCWJyZWFrOworCisJY2FzZSBYZW5idXNTdGF0ZUNvbm5l Y3RlZDoKKwkJaWYgKHhiX2Rldi0+c3RhdGUgIT0gWGVuYnVzU3RhdGVJbml0aWFsaXNlZCkKKwkJ CWJyZWFrOworCisJCXJldCA9IGRpc3BsYmFja19jb25uZWN0KGZyb250X2luZm8pOworCQlpZiAo cmV0IDwgMCkKKwkJCXhlbmJ1c19kZXZfZmF0YWwoeGJfZGV2LCByZXQsCisJCQkJCSJpbml0aWFs aXppbmcgRFJNIGRyaXZlciIpOworCQllbHNlCisJCQl4ZW5idXNfc3dpdGNoX3N0YXRlKHhiX2Rl diwgWGVuYnVzU3RhdGVDb25uZWN0ZWQpOworCQlicmVhazsKKworCWNhc2UgWGVuYnVzU3RhdGVD bG9zaW5nOgorCQkvKgorCQkgKiBpbiB0aGlzIHN0YXRlIGJhY2tlbmQgc3RhcnRzIGZyZWVpbmcg cmVzb3VyY2VzLAorCQkgKiBzbyBsZXQgaXQgZ28gaW50byBjbG9zZWQgc3RhdGUsIHNvIHdlIGNh biBhbHNvCisJCSAqIHJlbW92ZSBvdXJzCisJCSAqLworCQlicmVhazsKKworCWNhc2UgWGVuYnVz U3RhdGVVbmtub3duOgorCQkvKiBmYWxsIHRocm91Z2ggKi8KKwljYXNlIFhlbmJ1c1N0YXRlQ2xv c2VkOgorCQlpZiAoeGJfZGV2LT5zdGF0ZSA9PSBYZW5idXNTdGF0ZUNsb3NlZCkKKwkJCWJyZWFr OworCisJCWRpc3BsYmFja19kaXNjb25uZWN0KGZyb250X2luZm8pOworCQlicmVhazsKKwl9CiB9 CiAKIHN0YXRpYyBpbnQgeGVuX2Rydl9wcm9iZShzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2 LAogCQljb25zdCBzdHJ1Y3QgeGVuYnVzX2RldmljZV9pZCAqaWQpCiB7Ci0JcmV0dXJuIDA7CisJ c3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKworCWZyb250X2luZm8gPSBk ZXZtX2t6YWxsb2MoJnhiX2Rldi0+ZGV2LAorCQkJc2l6ZW9mKCpmcm9udF9pbmZvKSwgR0ZQX0tF Uk5FTCk7CisJaWYgKCFmcm9udF9pbmZvKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZyb250X2lu Zm8tPnhiX2RldiA9IHhiX2RldjsKKwlkZXZfc2V0X2RydmRhdGEoJnhiX2Rldi0+ZGV2LCBmcm9u dF9pbmZvKTsKKwlyZXR1cm4geGVuYnVzX3N3aXRjaF9zdGF0ZSh4Yl9kZXYsIFhlbmJ1c1N0YXRl SW5pdGlhbGlzaW5nKTsKIH0KIAogc3RhdGljIGludCB4ZW5fZHJ2X3JlbW92ZShzdHJ1Y3QgeGVu YnVzX2RldmljZSAqZGV2KQogeworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8gPSBkZXZfZ2V0X2RydmRhdGEoJmRldi0+ZGV2KTsKKwlpbnQgdG8gPSAxMDA7CisKKwl4ZW5i dXNfc3dpdGNoX3N0YXRlKGRldiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsKKworCS8qCisJICogT24g ZHJpdmVyIHJlbW92YWwgaXQgaXMgZGlzY29ubmVjdGVkIGZyb20gWGVuQnVzLAorCSAqIHNvIG5v IGJhY2tlbmQgc3RhdGUgY2hhbmdlIGV2ZW50cyBjb21lIHZpYSAub3RoZXJlbmRfY2hhbmdlZAor CSAqIGNhbGxiYWNrLiBUaGlzIHByZXZlbnRzIHVzIGZyb20gZXhpdGluZyBncmFjZWZ1bGx5LCBl LmcuCisJICogc2lnbmFsaW5nIHRoZSBiYWNrZW5kIHRvIGZyZWUgZXZlbnQgY2hhbm5lbHMsIHdh aXRpbmcgZm9yIGl0cworCSAqIHN0YXRlIHRvIGNoYW5nZSB0byBYZW5idXNTdGF0ZUNsb3NlZCBh bmQgY2xlYW5pbmcgYXQgb3VyIGVuZC4KKwkgKiBOb3JtYWxseSB3aGVuIGZyb250IGRyaXZlciBy ZW1vdmVkIGJhY2tlbmQgd2lsbCBmaW5hbGx5IGdvIGludG8KKwkgKiBYZW5idXNTdGF0ZUluaXRX YWl0IHN0YXRlLgorCSAqCisJICogV29ya2Fyb3VuZDogcmVhZCBiYWNrZW5kJ3Mgc3RhdGUgbWFu dWFsbHkgYW5kIHdhaXQgd2l0aCB0aW1lLW91dC4KKwkgKi8KKwl3aGlsZSAoKHhlbmJ1c19yZWFk X3Vuc2lnbmVkKGZyb250X2luZm8tPnhiX2Rldi0+b3RoZXJlbmQsCisJCQkic3RhdGUiLCBYZW5i dXNTdGF0ZVVua25vd24pICE9IFhlbmJ1c1N0YXRlSW5pdFdhaXQpICYmCisJCQl0by0tKQorCQlt c2xlZXAoMTApOworCisJaWYgKCF0bykKKwkJRFJNX0VSUk9SKCJCYWNrZW5kIHN0YXRlIGlzICVz IHdoaWxlIHJlbW92aW5nIGRyaXZlclxuIiwKKwkJCXhlbmJ1c19zdHJzdGF0ZSh4ZW5idXNfcmVh ZF91bnNpZ25lZCgKKwkJCQkJZnJvbnRfaW5mby0+eGJfZGV2LT5vdGhlcmVuZCwKKwkJCQkJInN0 YXRlIiwgWGVuYnVzU3RhdGVVbmtub3duKSkpOworCisJeGVuX2Rydl9yZW1vdmVfaW50ZXJuYWwo ZnJvbnRfaW5mbyk7CisJeGVuYnVzX2Zyb250ZW5kX2Nsb3NlZChkZXYpOwogCXJldHVybiAwOwog fQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaCBiL2Ry aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uOGI4ZDRkMWUwODE2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKQEAgLTAsMCArMSwxOCBAQAorLyogU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgT1IgTUlUICovCisKKy8qCisgKiAgWGVuIHBhcmEt dmlydHVhbCBEUk0gZGV2aWNlCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBT eXN0ZW1zIEluYy4KKyAqCisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVr c2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaWZuZGVmIF9fWEVOX0RSTV9G Uk9OVF9IXworI2RlZmluZSBfX1hFTl9EUk1fRlJPTlRfSF8KKworc3RydWN0IHhlbl9kcm1fZnJv bnRfaW5mbyB7CisJc3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldjsKK307CisKKyNlbmRpZiAv KiBfX1hFTl9EUk1fRlJPTlRfSF8gKi8KLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933004AbeCMNbX (ORCPT ); Tue, 13 Mar 2018 09:31:23 -0400 Received: from mail-lf0-f66.google.com ([209.85.215.66]:36388 "EHLO mail-lf0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932756AbeCMNbU (ORCPT ); Tue, 13 Mar 2018 09:31:20 -0400 X-Google-Smtp-Source: AG47ELvSuIvBhXvXXNidmvmzcueQU75BowgSSIsE5L9SZNsz5dQtbroxRKKrhofWENqPBhevyNlc9g== 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 2/8] drm/xen-front: Implement Xen bus state handling Date: Tue, 13 Mar 2018 15:31:01 +0200 Message-Id: <1520947867-32514-3-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 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 | 18 ++++++ 2 files changed, 141 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 03bc50b128fd..520b5b34520b 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.c +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -16,19 +16,141 @@ #include +#include "xen_drm_front.h" + +static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) +{ +} + +static int displback_initwait(struct xen_drm_front_info *front_info) +{ + return 0; +} + +static int displback_connect(struct xen_drm_front_info *front_info) +{ + return 0; +} + +static void displback_disconnect(struct xen_drm_front_info *front_info) +{ + xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); +} + static void displback_changed(struct xenbus_device *xb_dev, enum xenbus_state backend_state) { + struct xen_drm_front_info *front_info = dev_get_drvdata(&xb_dev->dev); + int ret; + + DRM_DEBUG("Backend state is %s, front is %s\n", + xenbus_strstate(backend_state), + xenbus_strstate(xb_dev->state)); + + switch (backend_state) { + case XenbusStateReconfiguring: + /* fall through */ + case XenbusStateReconfigured: + /* fall through */ + case XenbusStateInitialised: + break; + + case XenbusStateInitialising: + /* recovering after backend unexpected closure */ + displback_disconnect(front_info); + break; + + case XenbusStateInitWait: + /* recovering after backend unexpected closure */ + displback_disconnect(front_info); + if (xb_dev->state != XenbusStateInitialising) + break; + + ret = displback_initwait(front_info); + if (ret < 0) + xenbus_dev_fatal(xb_dev, ret, + "initializing frontend"); + else + xenbus_switch_state(xb_dev, XenbusStateInitialised); + break; + + case XenbusStateConnected: + if (xb_dev->state != XenbusStateInitialised) + break; + + ret = displback_connect(front_info); + if (ret < 0) + xenbus_dev_fatal(xb_dev, ret, + "initializing DRM driver"); + else + xenbus_switch_state(xb_dev, XenbusStateConnected); + break; + + case XenbusStateClosing: + /* + * in this state backend starts freeing resources, + * so let it go into closed state, so we can also + * remove ours + */ + break; + + case XenbusStateUnknown: + /* fall through */ + case XenbusStateClosed: + if (xb_dev->state == XenbusStateClosed) + break; + + displback_disconnect(front_info); + break; + } } static int xen_drv_probe(struct xenbus_device *xb_dev, const struct xenbus_device_id *id) { - return 0; + struct xen_drm_front_info *front_info; + + front_info = devm_kzalloc(&xb_dev->dev, + sizeof(*front_info), GFP_KERNEL); + if (!front_info) + 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..8b8d4d1e0816 --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -0,0 +1,18 @@ +/* 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_ + +struct xen_drm_front_info { + struct xenbus_device *xb_dev; +}; + +#endif /* __XEN_DRM_FRONT_H_ */ -- 2.7.4