From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <linux-kernel-owner@vger.kernel.org>
Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand
        id S935014AbeCEM7b (ORCPT <rfc822;w@1wt.eu>);
        Mon, 5 Mar 2018 07:59:31 -0500
Received: from mail-lf0-f51.google.com ([209.85.215.51]:35026 "EHLO
        mail-lf0-f51.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org
        with ESMTP id S934109AbeCEM72 (ORCPT
        <rfc822;linux-kernel@vger.kernel.org>);
        Mon, 5 Mar 2018 07:59:28 -0500
X-Google-Smtp-Source: AG47ELtaY4bsuOjnkj0AUmijXfkGtEUiG6U5xGJstfp2AfB7iZ58wuSkzcKfPA02Cbn4131cjcXXPA==
Subject: Re: [PATCH 7/9] drm/xen-front: Implement KMS/connector handling
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,
        Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
References: <1519200222-20623-1-git-send-email-andr2000@gmail.com>
 <1519200222-20623-8-git-send-email-andr2000@gmail.com>
 <20180305092353.GI22212@phenom.ffwll.local>
From: Oleksandr Andrushchenko <andr2000@gmail.com>
Message-ID: <8132411b-ee50-fe42-2e62-8816a1f85433@gmail.com>
Date: Mon, 5 Mar 2018 14:59:23 +0200
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101
 Thunderbird/52.6.0
MIME-Version: 1.0
In-Reply-To: <20180305092353.GI22212@phenom.ffwll.local>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 7bit
Content-Language: en-US
Sender: linux-kernel-owner@vger.kernel.org
List-ID: <linux-kernel.vger.kernel.org>
X-Mailing-List: linux-kernel@vger.kernel.org

On 03/05/2018 11:23 AM, Daniel Vetter wrote:
> On Wed, Feb 21, 2018 at 10:03:40AM +0200, Oleksandr Andrushchenko wrote:
>> From: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
>>
>> 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
>>    - generate vblank events
>>    - 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
>>
>> Signed-off-by: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
> I think once you've removed the midlayer in the previous patch it would
> makes sense to merge the 2 patches into 1.
ok, will squash the two
>
> Bunch more comments below.
> -Daniel
>
>> ---
>>   drivers/gpu/drm/xen/Makefile             |   2 +
>>   drivers/gpu/drm/xen/xen_drm_front_conn.c | 125 +++++++++++++
>>   drivers/gpu/drm/xen/xen_drm_front_conn.h |  35 ++++
>>   drivers/gpu/drm/xen/xen_drm_front_drv.c  |  15 ++
>>   drivers/gpu/drm/xen/xen_drm_front_drv.h  |  12 ++
>>   drivers/gpu/drm/xen/xen_drm_front_kms.c  | 299 +++++++++++++++++++++++++++++++
>>   drivers/gpu/drm/xen/xen_drm_front_kms.h  |  30 ++++
>>   7 files changed, 518 insertions(+)
>>   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_kms.c
>>   create mode 100644 drivers/gpu/drm/xen/xen_drm_front_kms.h
>>
>> diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile
>> index d3068202590f..4fcb0da1a9c5 100644
>> --- a/drivers/gpu/drm/xen/Makefile
>> +++ b/drivers/gpu/drm/xen/Makefile
>> @@ -2,6 +2,8 @@
>>   
>>   drm_xen_front-objs := xen_drm_front.o \
>>   		      xen_drm_front_drv.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
>> 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..d9986a2e1a3b
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xen/xen_drm_front_conn.c
>> @@ -0,0 +1,125 @@
>> +/*
>> + *  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 <oleksandr_andrushchenko@epam.com>
>> + */
>> +
>> +#include <drm/drm_atomic_helper.h>
>> +#include <drm/drm_crtc_helper.h>
>> +
>> +#include <video/videomode.h>
>> +
>> +#include "xen_drm_front_conn.h"
>> +#include "xen_drm_front_drv.h"
>> +
>> +static struct xen_drm_front_drm_pipeline *
>> +to_xen_drm_pipeline(struct drm_connector *connector)
>> +{
>> +	return container_of(connector, struct xen_drm_front_drm_pipeline, conn);
>> +}
>> +
>> +static const uint32_t plane_formats[] = {
>> +	DRM_FORMAT_RGB565,
>> +	DRM_FORMAT_RGB888,
>> +	DRM_FORMAT_XRGB8888,
>> +	DRM_FORMAT_ARGB8888,
>> +	DRM_FORMAT_XRGB4444,
>> +	DRM_FORMAT_ARGB4444,
>> +	DRM_FORMAT_XRGB1555,
>> +	DRM_FORMAT_ARGB1555,
>> +};
>> +
>> +const uint32_t *xen_drm_front_conn_get_formats(int *format_count)
>> +{
>> +	*format_count = ARRAY_SIZE(plane_formats);
>> +	return plane_formats;
>> +}
>> +
>> +static enum drm_connector_status connector_detect(
>> +		struct drm_connector *connector, bool force)
>> +{
>> +	if (drm_dev_is_unplugged(connector->dev))
>> +		return connector_status_disconnected;
>> +
>> +	return connector_status_connected;
>> +}
>> +
>> +#define XEN_DRM_NUM_VIDEO_MODES		1
>> +#define XEN_DRM_CRTC_VREFRESH_HZ	60
>> +
>> +static int connector_get_modes(struct drm_connector *connector)
>> +{
>> +	struct xen_drm_front_drm_pipeline *pipeline =
>> +		to_xen_drm_pipeline(connector);
>> +	struct drm_display_mode *mode;
>> +	struct videomode videomode;
>> +	int width, height;
>> +
>> +	mode = drm_mode_create(connector->dev);
>> +	if (!mode)
>> +		return 0;
>> +
>> +	memset(&videomode, 0, sizeof(videomode));
>> +	videomode.hactive = pipeline->width;
>> +	videomode.vactive = pipeline->height;
>> +	width = videomode.hactive + videomode.hfront_porch +
>> +		videomode.hback_porch + videomode.hsync_len;
>> +	height = videomode.vactive + videomode.vfront_porch +
>> +		videomode.vback_porch + videomode.vsync_len;
>> +	videomode.pixelclock = width * height * XEN_DRM_CRTC_VREFRESH_HZ;
>> +	mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
>> +
>> +	drm_display_mode_from_videomode(&videomode, mode);
>> +	drm_mode_probed_add(connector, mode);
>> +	return XEN_DRM_NUM_VIDEO_MODES;
>> +}
>> +
>> +static int connector_mode_valid(struct drm_connector *connector,
>> +		struct drm_display_mode *mode)
>> +{
>> +	struct xen_drm_front_drm_pipeline *pipeline =
>> +			to_xen_drm_pipeline(connector);
>> +
>> +	if (mode->hdisplay != pipeline->width)
>> +		return MODE_ERROR;
>> +
>> +	if (mode->vdisplay != pipeline->height)
>> +		return MODE_ERROR;
>> +
>> +	return MODE_OK;
>> +}
>> +
>> +static const struct drm_connector_helper_funcs connector_helper_funcs = {
>> +	.get_modes = connector_get_modes,
>> +	.mode_valid = connector_mode_valid,
>> +};
>> +
>> +static const struct drm_connector_funcs connector_funcs = {
>> +	.detect = connector_detect,
>> +	.fill_modes = drm_helper_probe_single_connector_modes,
>> +	.destroy = drm_connector_cleanup,
>> +	.reset = drm_atomic_helper_connector_reset,
>> +	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
>> +	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
>> +};
>> +
>> +int xen_drm_front_conn_init(struct xen_drm_front_drm_info *drm_info,
>> +		struct drm_connector *connector)
>> +{
>> +	drm_connector_helper_add(connector, &connector_helper_funcs);
>> +
>> +	return drm_connector_init(drm_info->drm_dev, connector,
>> +		&connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
>> +}
>> diff --git a/drivers/gpu/drm/xen/xen_drm_front_conn.h b/drivers/gpu/drm/xen/xen_drm_front_conn.h
>> new file mode 100644
>> index 000000000000..708e80d45985
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xen/xen_drm_front_conn.h
>> @@ -0,0 +1,35 @@
>> +/*
>> + *  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 <oleksandr_andrushchenko@epam.com>
>> + */
>> +
>> +#ifndef __XEN_DRM_FRONT_CONN_H_
>> +#define __XEN_DRM_FRONT_CONN_H_
>> +
>> +#include <drm/drmP.h>
>> +#include <drm/drm_crtc.h>
>> +#include <drm/drm_encoder.h>
>> +
>> +#include <linux/wait.h>
>> +
>> +struct xen_drm_front_drm_info;
>> +
>> +const uint32_t *xen_drm_front_conn_get_formats(int *format_count);
>> +
>> +int xen_drm_front_conn_init(struct xen_drm_front_drm_info *drm_info,
>> +		struct drm_connector *connector);
>> +
>> +#endif /* __XEN_DRM_FRONT_CONN_H_ */
>> diff --git a/drivers/gpu/drm/xen/xen_drm_front_drv.c b/drivers/gpu/drm/xen/xen_drm_front_drv.c
>> index b3764d5ed0f6..e8862d26ba27 100644
>> --- a/drivers/gpu/drm/xen/xen_drm_front_drv.c
>> +++ b/drivers/gpu/drm/xen/xen_drm_front_drv.c
>> @@ -23,6 +23,7 @@
>>   #include "xen_drm_front.h"
>>   #include "xen_drm_front_cfg.h"
>>   #include "xen_drm_front_drv.h"
>> +#include "xen_drm_front_kms.h"
>>   
>>   static int dumb_create(struct drm_file *filp,
>>   		struct drm_device *dev, struct drm_mode_create_dumb *args)
>> @@ -41,6 +42,13 @@ static void free_object(struct drm_gem_object *obj)
>>   static void on_frame_done(struct platform_device *pdev,
>>   		int conn_idx, uint64_t fb_cookie)
>>   {
>> +	struct xen_drm_front_drm_info *drm_info = platform_get_drvdata(pdev);
>> +
>> +	if (unlikely(conn_idx >= drm_info->cfg->num_connectors))
>> +		return;
>> +
>> +	xen_drm_front_kms_on_frame_done(&drm_info->pipeline[conn_idx],
>> +			fb_cookie);
>>   }
>>   
>>   static void lastclose(struct drm_device *dev)
>> @@ -157,6 +165,12 @@ int xen_drm_front_drv_probe(struct platform_device *pdev,
>>   		return ret;
>>   	}
>>   
>> +	ret = xen_drm_front_kms_init(drm_info);
>> +	if (ret) {
>> +		DRM_ERROR("Failed to initialize DRM/KMS, ret %d\n", ret);
>> +		goto fail_modeset;
>> +	}
>> +
>>   	dev->irq_enabled = 1;
>>   
>>   	ret = drm_dev_register(dev, 0);
>> @@ -172,6 +186,7 @@ int xen_drm_front_drv_probe(struct platform_device *pdev,
>>   
>>   fail_register:
>>   	drm_dev_unregister(dev);
>> +fail_modeset:
>>   	drm_mode_config_cleanup(dev);
>>   	return ret;
>>   }
>> diff --git a/drivers/gpu/drm/xen/xen_drm_front_drv.h b/drivers/gpu/drm/xen/xen_drm_front_drv.h
>> index aaa476535c13..563318b19f34 100644
>> --- a/drivers/gpu/drm/xen/xen_drm_front_drv.h
>> +++ b/drivers/gpu/drm/xen/xen_drm_front_drv.h
>> @@ -20,14 +20,24 @@
>>   #define __XEN_DRM_FRONT_DRV_H_
>>   
>>   #include <drm/drmP.h>
>> +#include <drm/drm_simple_kms_helper.h>
>>   
>>   #include "xen_drm_front.h"
>>   #include "xen_drm_front_cfg.h"
>> +#include "xen_drm_front_conn.h"
>>   
>>   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;
>> +	/* last backend error seen on page flip */
>> +	int pgflip_last_error;
>>   };
>>   
>>   struct xen_drm_front_drm_info {
>> @@ -35,6 +45,8 @@ struct xen_drm_front_drm_info {
>>   	struct xen_drm_front_ops *front_ops;
>>   	struct drm_device *drm_dev;
>>   	struct xen_drm_front_cfg *cfg;
>> +
>> +	struct xen_drm_front_drm_pipeline pipeline[XEN_DRM_FRONT_MAX_CRTCS];
>>   };
>>   
>>   static inline uint64_t xen_drm_front_fb_to_cookie(
>> diff --git a/drivers/gpu/drm/xen/xen_drm_front_kms.c b/drivers/gpu/drm/xen/xen_drm_front_kms.c
>> new file mode 100644
>> index 000000000000..ad94c28835cd
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xen/xen_drm_front_kms.c
>> @@ -0,0 +1,299 @@
>> +/*
>> + *  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 <oleksandr_andrushchenko@epam.com>
>> + */
>> +
>> +#include "xen_drm_front_kms.h"
>> +
>> +#include <drm/drmP.h>
>> +#include <drm/drm_atomic.h>
>> +#include <drm/drm_atomic_helper.h>
>> +#include <drm/drm_gem.h>
>> +#include <drm/drm_gem_framebuffer_helper.h>
>> +
>> +#include "xen_drm_front.h"
>> +#include "xen_drm_front_conn.h"
>> +#include "xen_drm_front_drv.h"
>> +
>> +static struct xen_drm_front_drm_pipeline *
>> +to_xen_drm_pipeline(struct drm_simple_display_pipe *pipe)
>> +{
>> +	return container_of(pipe, struct xen_drm_front_drm_pipeline, pipe);
>> +}
>> +
>> +static void fb_destroy(struct drm_framebuffer *fb)
>> +{
>> +	struct xen_drm_front_drm_info *drm_info = fb->dev->dev_private;
>> +
>> +	drm_info->front_ops->fb_detach(drm_info->front_info,
>> +			xen_drm_front_fb_to_cookie(fb));
>> +	drm_gem_fb_destroy(fb);
>> +}
>> +
>> +static struct drm_framebuffer_funcs fb_funcs = {
>> +	.destroy = fb_destroy,
>> +};
>> +
>> +static struct drm_framebuffer *fb_create(struct drm_device *dev,
>> +		struct drm_file *filp, const struct drm_mode_fb_cmd2 *mode_cmd)
>> +{
>> +	struct xen_drm_front_drm_info *drm_info = dev->dev_private;
>> +	static struct drm_framebuffer *fb;
>> +	struct drm_gem_object *gem_obj;
>> +	int ret;
>> +
>> +	fb = drm_gem_fb_create_with_funcs(dev, filp, mode_cmd, &fb_funcs);
>> +	if (IS_ERR_OR_NULL(fb))
>> +		return fb;
>> +
>> +	gem_obj = drm_gem_object_lookup(filp, mode_cmd->handles[0]);
>> +	if (!gem_obj) {
>> +		DRM_ERROR("Failed to lookup GEM object\n");
>> +		ret = -ENOENT;
>> +		goto fail;
>> +	}
>> +
>> +	drm_gem_object_unreference_unlocked(gem_obj);
>> +
>> +	ret = drm_info->front_ops->fb_attach(
>> +			drm_info->front_info,
>> +			xen_drm_front_dbuf_to_cookie(gem_obj),
>> +			xen_drm_front_fb_to_cookie(fb),
>> +			fb->width, fb->height, fb->format->format);
>> +	if (ret < 0) {
>> +		DRM_ERROR("Back failed to attach FB %p: %d\n", fb, ret);
>> +		goto fail;
>> +	}
>> +
>> +	return fb;
>> +
>> +fail:
>> +	drm_gem_fb_destroy(fb);
>> +	return ERR_PTR(ret);
>> +}
>> +
>> +static const struct drm_mode_config_funcs mode_config_funcs = {
>> +	.fb_create = fb_create,
>> +	.atomic_check = drm_atomic_helper_check,
>> +	.atomic_commit = drm_atomic_helper_commit,
>> +};
>> +
>> +static int display_set_config(struct drm_simple_display_pipe *pipe,
>> +	struct drm_framebuffer *fb)
>> +{
>> +	struct xen_drm_front_drm_pipeline *pipeline =
>> +			to_xen_drm_pipeline(pipe);
>> +	struct drm_crtc *crtc = &pipe->crtc;
>> +	struct xen_drm_front_drm_info *drm_info = pipeline->drm_info;
>> +	int ret;
>> +
>> +	if (fb)
>> +		ret = drm_info->front_ops->mode_set(pipeline,
>> +				crtc->x, crtc->y,
>> +				fb->width, fb->height, fb->format->cpp[0] * 8,
>> +				xen_drm_front_fb_to_cookie(fb));
>> +	else
>> +		ret = drm_info->front_ops->mode_set(pipeline,
>> +				0, 0, 0, 0, 0,
>> +				xen_drm_front_fb_to_cookie(NULL));
> This is a bit much layering, the if (fb) case corresponds to the
> display_enable/disable hooks, pls fold that in instead of the indirection.
> simple helpers guarantee that when the display is on, then you have an fb.
1. Ok, the only reason for having this function was to keep
front_ops->mode_set calls at one place (will be refactored
to be a direct call, not via front_ops).
2. The if (fb) check was meant not to check if simple helpers
may give us some wrong value when we do not expect: there is
nothing wrong with them. The check was for 2 cases when this
function was called: with fb != NULL on display enable and
with fb == NULL on display disable, e.g. fb was used as a
flag in this check.
3. I will remove this function at all and will make direct calls
to the backend on .display_{enable|disable}
>
> Maybe we need to fix the docs, pls check and if that's not clear, submit a
> kernel-doc patch for the simple pipe helpers.
no, nothing wrong here, just see my reasoning above
>> +
>> +	if (ret)
>> +		DRM_ERROR("Failed to set mode to back: %d\n", ret);
>> +
>> +	return ret;
>> +}
>> +
>> +static void display_enable(struct drm_simple_display_pipe *pipe,
>> +		struct drm_crtc_state *crtc_state)
>> +{
>> +	struct drm_crtc *crtc = &pipe->crtc;
>> +	struct drm_framebuffer *fb = pipe->plane.state->fb;
>> +
>> +	if (display_set_config(pipe, fb) == 0)
>> +		drm_crtc_vblank_on(crtc);
> I get the impression your driver doesn't support vblanks (the page flip
> code at least looks like it's only generating a single event),
yes, this is true
>   you also
> don't have a enable/disable_vblank implementation.
this is because with my previous patches [1] these are now handled
by simple helpers, so no need to provide dummy ones in the driver
>   If there's no vblank
> handling then this shouldn't be needed.
yes, I will rework the code, please see below
>> +	else
>> +		DRM_ERROR("Failed to enable display\n");
>> +}
>> +
>> +static void display_disable(struct drm_simple_display_pipe *pipe)
>> +{
>> +	struct drm_crtc *crtc = &pipe->crtc;
>> +
>> +	display_set_config(pipe, NULL);
>> +	drm_crtc_vblank_off(crtc);
>> +	/* final check for stalled events */
>> +	if (crtc->state->event && !crtc->state->active) {
>> +		unsigned long flags;
>> +
>> +		spin_lock_irqsave(&crtc->dev->event_lock, flags);
>> +		drm_crtc_send_vblank_event(crtc, crtc->state->event);
>> +		spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
>> +		crtc->state->event = NULL;
>> +	}
>> +}
>> +
>> +void xen_drm_front_kms_on_frame_done(
>> +		struct xen_drm_front_drm_pipeline *pipeline,
>> +		uint64_t fb_cookie)
>> +{
>> +	drm_crtc_handle_vblank(&pipeline->pipe.crtc);
> Hm, again this doesn't look like real vblank, but only a page-flip done
> event. If that's correct then please don't use the vblank machinery, but
> just store the event internally (protected with your own private spinlock)
Why can't I use &dev->event_lock? Anyways for handling
page-flip events I will need to lock on it, so I can do
drm_crtc_send_vblank_event?
> and send it out using drm_crtc_send_vblank_event directly. No calls to
> arm_vblank_event or any of the other vblank infrastructure should be
> needed.
will re-work, e.g. will store drm_pending_vblank_event
on .display_update and send out on page flip event from the
backend
> Also please remove the drm_vblank_init() call, since your hw doesn't
> really have vblanks. And exposing vblanks to userspace without
> implementing them is confusing.
will remove all vblank handling at all with the re-work above
>
>> +}
>> +
>> +static void display_send_page_flip(struct drm_simple_display_pipe *pipe,
>> +		struct drm_plane_state *old_plane_state)
>> +{
>> +	struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(
>> +			old_plane_state->state, &pipe->plane);
>> +
>> +	/*
>> +	 * If old_plane_state->fb is NULL and plane_state->fb is not,
>> +	 * then this is an atomic commit which will enable display.
>> +	 * If old_plane_state->fb is not NULL and plane_state->fb is,
>> +	 * then this is an atomic commit which will disable display.
>> +	 * Ignore these and do not send page flip as this framebuffer will be
>> +	 * sent to the backend as a part of display_set_config call.
>> +	 */
>> +	if (old_plane_state->fb && plane_state->fb) {
>> +		struct xen_drm_front_drm_pipeline *pipeline =
>> +				to_xen_drm_pipeline(pipe);
>> +		struct xen_drm_front_drm_info *drm_info = pipeline->drm_info;
>> +		int ret;
>> +
>> +		ret = drm_info->front_ops->page_flip(drm_info->front_info,
>> +				pipeline->index,
>> +				xen_drm_front_fb_to_cookie(plane_state->fb));
>> +		pipeline->pgflip_last_error = ret;
>> +		if (ret) {
>> +			DRM_ERROR("Failed to send page flip request to backend: %d\n", ret);
>> +			/*
>> +			 * As we are at commit stage the DRM core will anyways
>> +			 * wait for the vblank and knows nothing about our
>> +			 * failure. The best we can do is to handle
>> +			 * vblank now, so there is no vblank/flip_done
>> +			 * time outs
>> +			 */
>> +			drm_crtc_handle_vblank(&pipeline->pipe.crtc);
>> +		}
>> +	}
>> +}
>> +
>> +static int display_prepare_fb(struct drm_simple_display_pipe *pipe,
>> +		struct drm_plane_state *plane_state)
>> +{
>> +	struct xen_drm_front_drm_pipeline *pipeline =
>> +			to_xen_drm_pipeline(pipe);
>> +
>> +	if (pipeline->pgflip_last_error) {
>> +		int ret;
>> +
>> +		/* if previous page flip didn't succeed then report the error */
>> +		ret = pipeline->pgflip_last_error;
>> +		/* and let us try to page flip next time */
>> +		pipeline->pgflip_last_error = 0;
>> +		return ret;
>> +	}
> Nope, this isn't how the uapi works. If your flips fail then we might need
> to add some error status thing to the drm events, but you can't make the
> next flip fail.
Well, yes, there is no way for me to tell that the page flip
has failed, so this is why I tried to do this workaround with
the next page-flip. The reason for that is that if, for example,
we are disconnected from the backend for some reason, there is
no way for me to tell the user-space that hey, please, do not
send any other page flips. If backend can recover and that was
a one time error then yes, the code I have will do wrong thing
(fail the current page flip), but if the error state is persistent
then I will be able to tell the user-space to stop by returning errors.
This is kind of trade-off which I am not sure how to solve correctly.

Do you think I can remove this workaround completely?
> -Daniel
>
>> +	return drm_gem_fb_prepare_fb(&pipe->plane, plane_state);
>> +}
>> +
>> +static void display_update(struct drm_simple_display_pipe *pipe,
>> +		struct drm_plane_state *old_plane_state)
>> +{
>> +	struct drm_crtc *crtc = &pipe->crtc;
>> +	struct drm_pending_vblank_event *event;
>> +
>> +	event = crtc->state->event;
>> +	if (event) {
>> +		struct drm_device *dev = crtc->dev;
>> +		unsigned long flags;
>> +
>> +		crtc->state->event = NULL;
>> +
>> +		spin_lock_irqsave(&dev->event_lock, flags);
>> +		if (drm_crtc_vblank_get(crtc) == 0)
>> +			drm_crtc_arm_vblank_event(crtc, event);
>> +		else
>> +			drm_crtc_send_vblank_event(crtc, event);
>> +		spin_unlock_irqrestore(&dev->event_lock, flags);
>> +	}
>> +	/*
>> +	 * Send page flip request to the backend *after* we have event armed/
>> +	 * sent above, so on page flip done event from the backend we can
>> +	 * deliver it while handling vblank.
>> +	 */
>> +	display_send_page_flip(pipe, old_plane_state);
>> +}
>> +
>> +static const struct drm_simple_display_pipe_funcs display_funcs = {
>> +	.enable = display_enable,
>> +	.disable = display_disable,
>> +	.prepare_fb = display_prepare_fb,
>> +	.update = display_update,
>> +};
>> +
>> +static int display_pipe_init(struct xen_drm_front_drm_info *drm_info,
>> +		int index, struct xen_drm_front_cfg_connector *cfg,
>> +		struct xen_drm_front_drm_pipeline *pipeline)
>> +{
>> +	struct drm_device *dev = drm_info->drm_dev;
>> +	const uint32_t *formats;
>> +	int format_count;
>> +	int ret;
>> +
>> +	pipeline->drm_info = drm_info;
>> +	pipeline->index = index;
>> +	pipeline->height = cfg->height;
>> +	pipeline->width = cfg->width;
>> +
>> +	ret = xen_drm_front_conn_init(drm_info, &pipeline->conn);
>> +	if (ret)
>> +		return ret;
>> +
>> +	formats = xen_drm_front_conn_get_formats(&format_count);
>> +
>> +	return drm_simple_display_pipe_init(dev, &pipeline->pipe,
>> +			&display_funcs, formats, format_count,
>> +			NULL, &pipeline->conn);
>> +}
>> +
>> +int xen_drm_front_kms_init(struct xen_drm_front_drm_info *drm_info)
>> +{
>> +	struct drm_device *dev = drm_info->drm_dev;
>> +	int i, ret;
>> +
>> +	drm_mode_config_init(dev);
>> +
>> +	dev->mode_config.min_width = 0;
>> +	dev->mode_config.min_height = 0;
>> +	dev->mode_config.max_width = 4095;
>> +	dev->mode_config.max_height = 2047;
>> +	dev->mode_config.funcs = &mode_config_funcs;
>> +
>> +	for (i = 0; i < drm_info->cfg->num_connectors; i++) {
>> +		struct xen_drm_front_cfg_connector *cfg =
>> +				&drm_info->cfg->connectors[i];
>> +		struct xen_drm_front_drm_pipeline *pipeline =
>> +				&drm_info->pipeline[i];
>> +
>> +		ret = display_pipe_init(drm_info, i, cfg, pipeline);
>> +		if (ret) {
>> +			drm_mode_config_cleanup(dev);
>> +			return ret;
>> +		}
>> +	}
>> +
>> +	drm_mode_config_reset(dev);
>> +	return 0;
>> +}
>> diff --git a/drivers/gpu/drm/xen/xen_drm_front_kms.h b/drivers/gpu/drm/xen/xen_drm_front_kms.h
>> new file mode 100644
>> index 000000000000..65a50033bb9b
>> --- /dev/null
>> +++ b/drivers/gpu/drm/xen/xen_drm_front_kms.h
>> @@ -0,0 +1,30 @@
>> +/*
>> + *  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 <oleksandr_andrushchenko@epam.com>
>> + */
>> +
>> +#ifndef __XEN_DRM_FRONT_KMS_H_
>> +#define __XEN_DRM_FRONT_KMS_H_
>> +
>> +#include "xen_drm_front_drv.h"
>> +
>> +int xen_drm_front_kms_init(struct xen_drm_front_drm_info *drm_info);
>> +
>> +void xen_drm_front_kms_on_frame_done(
>> +		struct xen_drm_front_drm_pipeline *pipeline,
>> +		uint64_t fb_cookie);
>> +
>> +#endif /* __XEN_DRM_FRONT_KMS_H_ */
>> -- 
>> 2.7.4
>>
>> _______________________________________________
>> dri-devel mailing list
>> dri-devel@lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/dri-devel
[1] https://patchwork.kernel.org/patch/10211997/

From mboxrd@z Thu Jan  1 00:00:00 1970
From: Oleksandr Andrushchenko <andr2000@gmail.com>
Subject: Re: [PATCH 7/9] drm/xen-front: Implement KMS/connector handling
Date: Mon, 5 Mar 2018 14:59:23 +0200
Message-ID: <8132411b-ee50-fe42-2e62-8816a1f85433@gmail.com>
References: <1519200222-20623-1-git-send-email-andr2000@gmail.com>
 <1519200222-20623-8-git-send-email-andr2000@gmail.com>
 <20180305092353.GI22212@phenom.ffwll.local>
Mime-Version: 1.0
Content-Type: text/plain; charset="utf-8"; Format="flowed"
Content-Transfer-Encoding: base64
Return-path: <dri-devel-bounces@lists.freedesktop.org>
Received: from mail-lf0-x234.google.com (mail-lf0-x234.google.com
 [IPv6:2a00:1450:4010:c07::234])
 by gabe.freedesktop.org (Postfix) with ESMTPS id 2135D6E35F
 for <dri-devel@lists.freedesktop.org>; Mon,  5 Mar 2018 12:59:28 +0000 (UTC)
Received: by mail-lf0-x234.google.com with SMTP id t204so22902128lff.9
 for <dri-devel@lists.freedesktop.org>; Mon, 05 Mar 2018 04:59:28 -0800 (PST)
In-Reply-To: <20180305092353.GI22212@phenom.ffwll.local>
Content-Language: en-US
List-Unsubscribe: <https://lists.freedesktop.org/mailman/options/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=unsubscribe>
List-Archive: <https://lists.freedesktop.org/archives/dri-devel>
List-Post: <mailto:dri-devel@lists.freedesktop.org>
List-Help: <mailto:dri-devel-request@lists.freedesktop.org?subject=help>
List-Subscribe: <https://lists.freedesktop.org/mailman/listinfo/dri-devel>,
 <mailto:dri-devel-request@lists.freedesktop.org?subject=subscribe>
Errors-To: dri-devel-bounces@lists.freedesktop.org
Sender: "dri-devel" <dri-devel-bounces@lists.freedesktop.org>
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, Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
List-Id: dri-devel@lists.freedesktop.org
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==