It only makes sense for userspace clients.

Signed-off-by: Noralf Trønnes noralf@tronnes.org Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch --- drivers/gpu/drm/drm_file.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/drivers/gpu/drm/drm_file.c b/drivers/gpu/drm/drm_file.c index d4588d33f91c..55505378df47 100644 --- a/drivers/gpu/drm/drm_file.c +++ b/drivers/gpu/drm/drm_file.c @@ -155,17 +155,8 @@ struct drm_file *drm_file_alloc(struct drm_minor *minor) goto out_prime_destroy; }

- if (drm_is_primary_client(file)) { - ret = drm_master_open(file); - if (ret) - goto out_close; - } - return file;

-out_close: - if (dev->driver->postclose) - dev->driver->postclose(dev, file); out_prime_destroy: if (drm_core_check_feature(dev, DRIVER_PRIME)) drm_prime_destroy_file_private(&file->prime); @@ -365,6 +356,7 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor) { struct drm_device *dev = minor->dev; struct drm_file *priv; + int ret;

if (filp->f_flags & O_EXCL) return -EBUSY; /* No exclusive opens */ @@ -379,6 +371,14 @@ static int drm_open_helper(struct file *filp, struct drm_minor *minor) if (IS_ERR(priv)) return PTR_ERR(priv);

+ if (drm_is_primary_client(priv)) { + ret = drm_master_open(priv); + if (ret) { + drm_file_free(priv); + return ret; + } + } + filp->private_data = priv; priv->filp = filp;

Atomic drivers can't use them so finish what was started in commit 9c79e0b1d096 ("drm/fb-helper: Give up on kgdb for atomic drivers").

This prepares the ground for creating modesets on demand.

TODO: - Actually remove the functions, not just the contents. - Nuke drm_crtc_helper_funcs->mode_set_base_atomic - Documentation/dev-tools/kgdb.rst

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_fb_helper.c | 82 ----------------------------------------- 1 file changed, 82 deletions(-)

diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index e48ace2d55f5..06e94de6452a 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -267,96 +267,14 @@ int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper, } EXPORT_SYMBOL(drm_fb_helper_remove_one_connector);

-static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc) -{ - uint16_t *r_base, *g_base, *b_base; - - if (crtc->funcs->gamma_set == NULL) - return; - - r_base = crtc->gamma_store; - g_base = r_base + crtc->gamma_size; - b_base = g_base + crtc->gamma_size; - - crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, - crtc->gamma_size, NULL); -} - -/** - * drm_fb_helper_debug_enter - implementation for &fb_ops.fb_debug_enter - * @info: fbdev registered by the helper - */ int drm_fb_helper_debug_enter(struct fb_info *info) { - struct drm_fb_helper *helper = info->par; - const struct drm_crtc_helper_funcs *funcs; - int i; - - list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) { - for (i = 0; i < helper->crtc_count; i++) { - struct drm_mode_set *mode_set = - &helper->crtc_info[i].mode_set; - - if (!mode_set->crtc->enabled) - continue; - - funcs = mode_set->crtc->helper_private; - if (funcs->mode_set_base_atomic == NULL) - continue; - - if (drm_drv_uses_atomic_modeset(mode_set->crtc->dev)) - continue; - - funcs->mode_set_base_atomic(mode_set->crtc, - mode_set->fb, - mode_set->x, - mode_set->y, - ENTER_ATOMIC_MODE_SET); - } - } - return 0; } EXPORT_SYMBOL(drm_fb_helper_debug_enter);

-/** - * drm_fb_helper_debug_leave - implementation for &fb_ops.fb_debug_leave - * @info: fbdev registered by the helper - */ int drm_fb_helper_debug_leave(struct fb_info *info) { - struct drm_fb_helper *helper = info->par; - struct drm_crtc *crtc; - const struct drm_crtc_helper_funcs *funcs; - struct drm_framebuffer *fb; - int i; - - for (i = 0; i < helper->crtc_count; i++) { - struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set; - - crtc = mode_set->crtc; - if (drm_drv_uses_atomic_modeset(crtc->dev)) - continue; - - funcs = crtc->helper_private; - fb = crtc->primary->fb; - - if (!crtc->enabled) - continue; - - if (!fb) { - DRM_ERROR("no fb to restore??\n"); - continue; - } - - if (funcs->mode_set_base_atomic == NULL) - continue; - - drm_fb_helper_restore_lut_atomic(mode_set->crtc); - funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x, - crtc->y, LEAVE_ATOMIC_MODE_SET); - } - return 0; } EXPORT_SYMBOL(drm_fb_helper_debug_leave);

Prepare for moving drm_fb_helper modesetting code to drm_client. drm_client will be linked to drm.ko, so move __drm_atomic_helper_disable_plane() and __drm_atomic_helper_set_config() out of drm_kms_helper.ko.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_atomic.c | 168 ++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_atomic_helper.c | 168 +----------------------------------- drivers/gpu/drm/drm_fb_helper.c | 8 +- include/drm/drm_atomic.h | 5 ++ include/drm/drm_atomic_helper.h | 4 - 5 files changed, 179 insertions(+), 174 deletions(-)

diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 7d25c42f22db..1fb602b6c8b1 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -2060,6 +2060,174 @@ void drm_atomic_clean_old_fb(struct drm_device *dev, } EXPORT_SYMBOL(drm_atomic_clean_old_fb);

+/* just used from drm_client and atomic-helper: */ +int drm_atomic_disable_plane(struct drm_plane *plane, + struct drm_plane_state *plane_state) +{ + int ret; + + ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); + if (ret != 0) + return ret; + + drm_atomic_set_fb_for_plane(plane_state, NULL); + plane_state->crtc_x = 0; + plane_state->crtc_y = 0; + plane_state->crtc_w = 0; + plane_state->crtc_h = 0; + plane_state->src_x = 0; + plane_state->src_y = 0; + plane_state->src_w = 0; + plane_state->src_h = 0; + + return 0; +} +EXPORT_SYMBOL(drm_atomic_disable_plane); + +static int update_output_state(struct drm_atomic_state *state, + struct drm_mode_set *set) +{ + struct drm_device *dev = set->crtc->dev; + struct drm_crtc *crtc; + struct drm_crtc_state *new_crtc_state; + struct drm_connector *connector; + struct drm_connector_state *new_conn_state; + int ret, i; + + ret = drm_modeset_lock(&dev->mode_config.connection_mutex, + state->acquire_ctx); + if (ret) + return ret; + + /* First disable all connectors on the target crtc. */ + ret = drm_atomic_add_affected_connectors(state, set->crtc); + if (ret) + return ret; + + for_each_new_connector_in_state(state, connector, new_conn_state, i) { + if (new_conn_state->crtc == set->crtc) { + ret = drm_atomic_set_crtc_for_connector(new_conn_state, + NULL); + if (ret) + return ret; + + /* Make sure legacy setCrtc always re-trains */ + new_conn_state->link_status = DRM_LINK_STATUS_GOOD; + } + } + + /* Then set all connectors from set->connectors on the target crtc */ + for (i = 0; i < set->num_connectors; i++) { + new_conn_state = drm_atomic_get_connector_state(state, + set->connectors[i]); + if (IS_ERR(new_conn_state)) + return PTR_ERR(new_conn_state); + + ret = drm_atomic_set_crtc_for_connector(new_conn_state, + set->crtc); + if (ret) + return ret; + } + + for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { + /* + * Don't update ->enable for the CRTC in the set_config request, + * since a mismatch would indicate a bug in the upper layers. + * The actual modeset code later on will catch any + * inconsistencies here. + */ + if (crtc == set->crtc) + continue; + + if (!new_crtc_state->connector_mask) { + ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state, + NULL); + if (ret < 0) + return ret; + + new_crtc_state->active = false; + } + } + + return 0; +} + +/* just used from drm_client and atomic-helper: */ +int drm_atomic_set_config(struct drm_mode_set *set, + struct drm_atomic_state *state) +{ + struct drm_crtc_state *crtc_state; + struct drm_plane_state *primary_state; + struct drm_crtc *crtc = set->crtc; + int hdisplay, vdisplay; + int ret; + + crtc_state = drm_atomic_get_crtc_state(state, crtc); + if (IS_ERR(crtc_state)) + return PTR_ERR(crtc_state); + + primary_state = drm_atomic_get_plane_state(state, crtc->primary); + if (IS_ERR(primary_state)) + return PTR_ERR(primary_state); + + if (!set->mode) { + WARN_ON(set->fb); + WARN_ON(set->num_connectors); + + ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); + if (ret != 0) + return ret; + + crtc_state->active = false; + + ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); + if (ret != 0) + return ret; + + drm_atomic_set_fb_for_plane(primary_state, NULL); + + goto commit; + } + + WARN_ON(!set->fb); + WARN_ON(!set->num_connectors); + + ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode); + if (ret != 0) + return ret; + + crtc_state->active = true; + + ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); + if (ret != 0) + return ret; + + drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay); + + drm_atomic_set_fb_for_plane(primary_state, set->fb); + primary_state->crtc_x = 0; + primary_state->crtc_y = 0; + primary_state->crtc_w = hdisplay; + primary_state->crtc_h = vdisplay; + primary_state->src_x = set->x << 16; + primary_state->src_y = set->y << 16; + if (drm_rotation_90_or_270(primary_state->rotation)) { + primary_state->src_w = vdisplay << 16; + primary_state->src_h = hdisplay << 16; + } else { + primary_state->src_w = hdisplay << 16; + primary_state->src_h = vdisplay << 16; + } + +commit: + ret = update_output_state(state, set); + if (ret) + return ret; + + return 0; +} +EXPORT_SYMBOL(drm_atomic_set_config); + /** * DOC: explicit fencing properties * diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index ee03c1ed2521..4f20eb58dd4f 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -2673,7 +2673,7 @@ int drm_atomic_helper_disable_plane(struct drm_plane *plane, if (plane_state->crtc && plane_state->crtc->cursor == plane) plane_state->state->legacy_cursor_update = true;

- ret = __drm_atomic_helper_disable_plane(plane, plane_state); + ret = drm_atomic_disable_plane(plane, plane_state); if (ret != 0) goto fail;

@@ -2684,95 +2684,6 @@ int drm_atomic_helper_disable_plane(struct drm_plane *plane, } EXPORT_SYMBOL(drm_atomic_helper_disable_plane);

-/* just used from fb-helper and atomic-helper: */ -int __drm_atomic_helper_disable_plane(struct drm_plane *plane, - struct drm_plane_state *plane_state) -{ - int ret; - - ret = drm_atomic_set_crtc_for_plane(plane_state, NULL); - if (ret != 0) - return ret; - - drm_atomic_set_fb_for_plane(plane_state, NULL); - plane_state->crtc_x = 0; - plane_state->crtc_y = 0; - plane_state->crtc_w = 0; - plane_state->crtc_h = 0; - plane_state->src_x = 0; - plane_state->src_y = 0; - plane_state->src_w = 0; - plane_state->src_h = 0; - - return 0; -} - -static int update_output_state(struct drm_atomic_state *state, - struct drm_mode_set *set) -{ - struct drm_device *dev = set->crtc->dev; - struct drm_crtc *crtc; - struct drm_crtc_state *new_crtc_state; - struct drm_connector *connector; - struct drm_connector_state *new_conn_state; - int ret, i; - - ret = drm_modeset_lock(&dev->mode_config.connection_mutex, - state->acquire_ctx); - if (ret) - return ret; - - /* First disable all connectors on the target crtc. */ - ret = drm_atomic_add_affected_connectors(state, set->crtc); - if (ret) - return ret; - - for_each_new_connector_in_state(state, connector, new_conn_state, i) { - if (new_conn_state->crtc == set->crtc) { - ret = drm_atomic_set_crtc_for_connector(new_conn_state, - NULL); - if (ret) - return ret; - - /* Make sure legacy setCrtc always re-trains */ - new_conn_state->link_status = DRM_LINK_STATUS_GOOD; - } - } - - /* Then set all connectors from set->connectors on the target crtc */ - for (i = 0; i < set->num_connectors; i++) { - new_conn_state = drm_atomic_get_connector_state(state, - set->connectors[i]); - if (IS_ERR(new_conn_state)) - return PTR_ERR(new_conn_state); - - ret = drm_atomic_set_crtc_for_connector(new_conn_state, - set->crtc); - if (ret) - return ret; - } - - for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { - /* Don't update ->enable for the CRTC in the set_config request, - * since a mismatch would indicate a bug in the upper layers. - * The actual modeset code later on will catch any - * inconsistencies here. */ - if (crtc == set->crtc) - continue; - - if (!new_crtc_state->connector_mask) { - ret = drm_atomic_set_mode_prop_for_crtc(new_crtc_state, - NULL); - if (ret < 0) - return ret; - - new_crtc_state->active = false; - } - } - - return 0; -} - /** * drm_atomic_helper_set_config - set a new config from userspace * @set: mode set configuration @@ -2801,7 +2712,7 @@ int drm_atomic_helper_set_config(struct drm_mode_set *set, return -ENOMEM;

state->acquire_ctx = ctx; - ret = __drm_atomic_helper_set_config(set, state); + ret = drm_atomic_set_config(set, state); if (ret != 0) goto fail;

@@ -2817,81 +2728,6 @@ int drm_atomic_helper_set_config(struct drm_mode_set *set, } EXPORT_SYMBOL(drm_atomic_helper_set_config);

-/* just used from fb-helper and atomic-helper: */ -int __drm_atomic_helper_set_config(struct drm_mode_set *set, - struct drm_atomic_state *state) -{ - struct drm_crtc_state *crtc_state; - struct drm_plane_state *primary_state; - struct drm_crtc *crtc = set->crtc; - int hdisplay, vdisplay; - int ret; - - crtc_state = drm_atomic_get_crtc_state(state, crtc); - if (IS_ERR(crtc_state)) - return PTR_ERR(crtc_state); - - primary_state = drm_atomic_get_plane_state(state, crtc->primary); - if (IS_ERR(primary_state)) - return PTR_ERR(primary_state); - - if (!set->mode) { - WARN_ON(set->fb); - WARN_ON(set->num_connectors); - - ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL); - if (ret != 0) - return ret; - - crtc_state->active = false; - - ret = drm_atomic_set_crtc_for_plane(primary_state, NULL); - if (ret != 0) - return ret; - - drm_atomic_set_fb_for_plane(primary_state, NULL); - - goto commit; - } - - WARN_ON(!set->fb); - WARN_ON(!set->num_connectors); - - ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode); - if (ret != 0) - return ret; - - crtc_state->active = true; - - ret = drm_atomic_set_crtc_for_plane(primary_state, crtc); - if (ret != 0) - return ret; - - drm_mode_get_hv_timing(set->mode, &hdisplay, &vdisplay); - - drm_atomic_set_fb_for_plane(primary_state, set->fb); - primary_state->crtc_x = 0; - primary_state->crtc_y = 0; - primary_state->crtc_w = hdisplay; - primary_state->crtc_h = vdisplay; - primary_state->src_x = set->x << 16; - primary_state->src_y = set->y << 16; - if (drm_rotation_90_or_270(primary_state->rotation)) { - primary_state->src_w = vdisplay << 16; - primary_state->src_h = hdisplay << 16; - } else { - primary_state->src_w = hdisplay << 16; - primary_state->src_h = vdisplay << 16; - } - -commit: - ret = update_output_state(state, set); - if (ret) - return ret; - - return 0; -} - static int __drm_atomic_helper_disable_all(struct drm_device *dev, struct drm_modeset_acquire_ctx *ctx, bool clean_old_fbs) diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index d0936671a9a6..2eef24db21f8 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -358,7 +358,7 @@ static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper, bool activ if (plane->type == DRM_PLANE_TYPE_PRIMARY) continue;

- ret = __drm_atomic_helper_disable_plane(plane, plane_state); + ret = drm_atomic_disable_plane(plane, plane_state); if (ret != 0) goto out_state; } @@ -374,13 +374,13 @@ static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper, bool activ plane_state->rotation = rotation; }

- ret = __drm_atomic_helper_set_config(mode_set, state); + ret = drm_atomic_set_config(mode_set, state); if (ret != 0) goto out_state;

/* - * __drm_atomic_helper_set_config() sets active when a - * mode is set, unconditionally clear it if we force DPMS off + * drm_atomic_set_config() sets active when a mode is set, + * unconditionally clear it if we force DPMS off */ if (!active) { struct drm_crtc *crtc = mode_set->crtc; diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index a57a8aa90ffb..0b0827ff2169 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -604,6 +604,11 @@ drm_atomic_add_affected_planes(struct drm_atomic_state *state, void drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret);

+int drm_atomic_disable_plane(struct drm_plane *plane, + struct drm_plane_state *plane_state); +int drm_atomic_set_config(struct drm_mode_set *set, + struct drm_atomic_state *state); + int __must_check drm_atomic_check_only(struct drm_atomic_state *state); int __must_check drm_atomic_commit(struct drm_atomic_state *state); int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state); diff --git a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h index 26aaba58d6ce..8d88a8b2ad52 100644 --- a/include/drm/drm_atomic_helper.h +++ b/include/drm/drm_atomic_helper.h @@ -114,12 +114,8 @@ int drm_atomic_helper_update_plane(struct drm_plane *plane, struct drm_modeset_acquire_ctx *ctx); int drm_atomic_helper_disable_plane(struct drm_plane *plane, struct drm_modeset_acquire_ctx *ctx); -int __drm_atomic_helper_disable_plane(struct drm_plane *plane, - struct drm_plane_state *plane_state); int drm_atomic_helper_set_config(struct drm_mode_set *set, struct drm_modeset_acquire_ctx *ctx); -int __drm_atomic_helper_set_config(struct drm_mode_set *set, - struct drm_atomic_state *state);

int drm_atomic_helper_disable_all(struct drm_device *dev, struct drm_modeset_acquire_ctx *ctx);

This the beginning of an API for in-kernel clients. First out is a display representation that will be used by drm_fb_helper in order to move out its mode setting code.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_client.c | 119 +++++++++++++++++++++++++++++++++++++++++++ include/drm/drm_client.h | 44 ++++++++++++++++ 3 files changed, 164 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/drm_client.c create mode 100644 include/drm/drm_client.h

diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 9d66657ea117..d25afa136d8f 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -18,7 +18,7 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \ drm_encoder.o drm_mode_object.o drm_property.o \ drm_plane.o drm_color_mgmt.o drm_print.o \ drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \ - drm_syncobj.o drm_lease.o + drm_syncobj.o drm_lease.o drm_client.o

drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o drm-$(CONFIG_DRM_VM) += drm_vm.o diff --git a/drivers/gpu/drm/drm_client.c b/drivers/gpu/drm/drm_client.c new file mode 100644 index 000000000000..7c31a6efb2f4 --- /dev/null +++ b/drivers/gpu/drm/drm_client.c @@ -0,0 +1,119 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright 2018 Noralf Trønnes + * + * For parts copied from drm_fb_helper: + * Copyright (c) 2006-2009 Red Hat Inc. + * Copyright (c) 2006-2008 Intel Corporation + * Copyright (c) 2007 Dave Airlie airlied@linux.ie + */ + +#include <linux/slab.h> + +#include <drm/drm_client.h> +#include <drm/drm_connector.h> +#include <drm/drm_crtc.h> +#include <drm/drm_device.h> +#include <drm/drm_modes.h> + +/** + * drm_client_display_create() - Create display structure + * @dev: DRM device + * + * This function creates a display structure for clients backed by an array of + * &drm_mode_set, one per CRTC. + * + * Returns: + * A &drm_client_display or an error pointer on allocation failure. + */ +struct drm_client_display *drm_client_display_create(struct drm_device *dev) +{ + unsigned int num_crtc = dev->mode_config.num_crtc; + struct drm_client_display *display; + struct drm_mode_set *modeset; + struct drm_crtc *crtc; + unsigned int i = 0; + + display = kzalloc(sizeof(*display), GFP_KERNEL); + if (!display) + return ERR_PTR(-ENOMEM); + + /* Add NULL terminating entry to enable index less iteration */ + display->modesets = kcalloc(num_crtc + 1, sizeof(*display->modesets), GFP_KERNEL); + if (!display->modesets) { + kfree(display); + return ERR_PTR(-ENOMEM); + } + + display->dev = dev; + display->modeset_count = num_crtc; + + drm_for_each_crtc(crtc, dev) + display->modesets[i++].crtc = crtc; + + drm_client_display_for_each_modeset(modeset, display) { + /* One connector per crtc except for the cloned case */ + modeset->connectors = kcalloc(2, sizeof(*modeset->connectors), GFP_KERNEL); + if (!modeset->connectors) + goto err_free; + } + + return display; + +err_free: + drm_client_display_free(display); + + return ERR_PTR(-ENOMEM); +} +EXPORT_SYMBOL(drm_client_display_create); + +/** + * drm_client_display_free() - Free display structure + * @display: Client display + * + * This function frees the structure allocated by drm_client_display_create(). + * It also destroys display modes and puts connectors. + */ +void drm_client_display_free(struct drm_client_display *display) +{ + struct drm_mode_set *modeset; + unsigned int i; + + if (!display) + return; + + drm_client_display_for_each_modeset(modeset, display) { + if (modeset->mode) + drm_mode_destroy(display->dev, modeset->mode); + + for (i = 0; i < modeset->num_connectors; i++) + drm_connector_put(modeset->connectors[i]); + kfree(modeset->connectors); + } + kfree(display->modesets); + kfree(display); +} +EXPORT_SYMBOL(drm_client_display_free); + +/** + * drm_client_display_find_modeset() - Find modeset matching a CRTC + * @display: Client display + * @crtc: CRTC + * + * This function looks up the @display modeset connected to @crtc. + * + * Returns: + * A &drm_mode_set or NULL. + */ +struct drm_mode_set * +drm_client_display_find_modeset(struct drm_client_display *display, struct drm_crtc *crtc) +{ + struct drm_mode_set *modeset; + + drm_client_display_for_each_modeset(modeset, display) + if (modeset->crtc == crtc) + return modeset; + + return NULL; +} +EXPORT_SYMBOL(drm_client_display_find_modeset); diff --git a/include/drm/drm_client.h b/include/drm/drm_client.h new file mode 100644 index 000000000000..b6a057802769 --- /dev/null +++ b/include/drm/drm_client.h @@ -0,0 +1,44 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef _DRM_CLIENT_H_ +#define _DRM_CLIENT_H_ + +struct drm_crtc; +struct drm_device; +struct drm_mode_set; + +/** + * struct drm_client_display - DRM client display + */ +struct drm_client_display { + /** + * @dev: + * + * DRM device. + */ + struct drm_device *dev; + + /** + * @modesets: + * + * Per CRTC array of modeset configurations. + */ + struct drm_mode_set *modesets; + + /** + * @modeset_count: + * + * Number of modesets + */ + unsigned int modeset_count; +}; + +struct drm_client_display *drm_client_display_create(struct drm_device *dev); +void drm_client_display_free(struct drm_client_display *display); +struct drm_mode_set * +drm_client_display_find_modeset(struct drm_client_display *display, struct drm_crtc *crtc); + +#define drm_client_display_for_each_modeset(modeset, display) \ + for (modeset = display->modesets; modeset->crtc; modeset++) + +#endif

This moves the committing part of the modesetting code to drm_client.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_client.c | 242 ++++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_fb_helper.c | 216 +---------------------------------- include/drm/drm_client.h | 8 ++ 3 files changed, 252 insertions(+), 214 deletions(-)

diff --git a/drivers/gpu/drm/drm_client.c b/drivers/gpu/drm/drm_client.c index 7c31a6efb2f4..c85c13568cf9 100644 --- a/drivers/gpu/drm/drm_client.c +++ b/drivers/gpu/drm/drm_client.c @@ -10,6 +10,8 @@

#include <linux/slab.h>

+#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h> #include <drm/drm_client.h> #include <drm/drm_connector.h> #include <drm/drm_crtc.h> @@ -117,3 +119,243 @@ drm_client_display_find_modeset(struct drm_client_display *display, struct drm_c return NULL; } EXPORT_SYMBOL(drm_client_display_find_modeset); + +/** + * drm_client_display_panel_rotation() - Check panel orientation + * @connector: DRM connector + * @plane: DRM plane + * @rotation: Returned rotation value + * + * This function checks if @plane can hw rotate to match the panel orientation + * on @connector. + * + * Return: + * True if the plane can do the rotation, false otherwise. + */ +bool drm_client_display_panel_rotation(struct drm_connector *connector, + struct drm_plane *plane, + unsigned int *rotation) +{ + uint64_t valid_mask = 0; + unsigned int i; + + if (!connector) + return false; + + switch (connector->display_info.panel_orientation) { + case DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP: + *rotation = DRM_MODE_ROTATE_180; + break; + case DRM_MODE_PANEL_ORIENTATION_LEFT_UP: + *rotation = DRM_MODE_ROTATE_90; + break; + case DRM_MODE_PANEL_ORIENTATION_RIGHT_UP: + *rotation = DRM_MODE_ROTATE_270; + break; + default: + *rotation = DRM_MODE_ROTATE_0; + } + + /* + * TODO: support 90 / 270 degree hardware rotation, + * depending on the hardware this may require the framebuffer + * to be in a specific tiling format. + */ + if (*rotation != DRM_MODE_ROTATE_180 || !plane->rotation_property) + return false; + + for (i = 0; i < plane->rotation_property->num_values; i++) + valid_mask |= (1ULL << plane->rotation_property->values[i]); + + if (!(*rotation & valid_mask)) + return false; + + return true; +} +EXPORT_SYMBOL(drm_client_display_panel_rotation); + +static int drm_client_display_restore_atomic(struct drm_client_display *display, bool active) +{ + struct drm_device *dev = display->dev; + struct drm_plane_state *plane_state; + struct drm_mode_set *mode_set; + struct drm_plane *plane; + struct drm_atomic_state *state; + int ret; + unsigned int plane_mask; + struct drm_modeset_acquire_ctx ctx; + + drm_modeset_acquire_init(&ctx, 0); + + state = drm_atomic_state_alloc(dev); + if (!state) { + ret = -ENOMEM; + goto out_ctx; + } + + state->acquire_ctx = &ctx; +retry: + plane_mask = 0; + drm_for_each_plane(plane, dev) { + plane_state = drm_atomic_get_plane_state(state, plane); + if (IS_ERR(plane_state)) { + ret = PTR_ERR(plane_state); + goto out_state; + } + + plane_state->rotation = DRM_MODE_ROTATE_0; + + plane->old_fb = plane->fb; + plane_mask |= 1 << drm_plane_index(plane); + + /* disable non-primary: */ + if (plane->type == DRM_PLANE_TYPE_PRIMARY) + continue; + + ret = drm_atomic_disable_plane(plane, plane_state); + if (ret != 0) + goto out_state; + } + + drm_client_display_for_each_modeset(mode_set, display) { + struct drm_plane *primary = mode_set->crtc->primary; + unsigned int rotation; + + if (drm_client_display_panel_rotation(mode_set->connectors[0], primary, &rotation)) { + /* Cannot fail as we've already gotten the plane state above */ + plane_state = drm_atomic_get_new_plane_state(state, primary); + plane_state->rotation = rotation; + } + + ret = drm_atomic_set_config(mode_set, state); + if (ret != 0) + goto out_state; + + /* + * drm_atomic_set_config() sets active when a + * mode is set, unconditionally clear it if we force DPMS off + */ + if (!active) { + struct drm_crtc *crtc = mode_set->crtc; + struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); + + crtc_state->active = false; + } + } + + ret = drm_atomic_commit(state); + +out_state: + drm_atomic_clean_old_fb(dev, plane_mask, ret); + + if (ret == -EDEADLK) + goto backoff; + + drm_atomic_state_put(state); +out_ctx: + drm_modeset_drop_locks(&ctx); + drm_modeset_acquire_fini(&ctx); + + return ret; + +backoff: + drm_atomic_state_clear(state); + drm_modeset_backoff(&ctx); + + goto retry; +} + +static int drm_client_display_restore_legacy(struct drm_client_display *display) +{ + struct drm_device *dev = display->dev; + struct drm_mode_set *mode_set; + struct drm_plane *plane; + int ret = 0; + + drm_modeset_lock_all(dev); + drm_for_each_plane(plane, dev) { + if (plane->type != DRM_PLANE_TYPE_PRIMARY) + drm_plane_force_disable(plane); + + if (plane->rotation_property) + drm_mode_plane_set_obj_prop(plane, + plane->rotation_property, + DRM_MODE_ROTATE_0); + } + + drm_client_display_for_each_modeset(mode_set, display) { + struct drm_crtc *crtc = mode_set->crtc; + + if (crtc->funcs->cursor_set2) { + ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0); + if (ret) + goto out; + } else if (crtc->funcs->cursor_set) { + ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0); + if (ret) + goto out; + } + + ret = drm_mode_set_config_internal(mode_set); + if (ret) + goto out; + } +out: + drm_modeset_unlock_all(dev); + + return ret; +} + +/** + * drm_client_display_restore() - Restore client display + * @display: Client display + * + * Restore client display using the current modeset configuration. + * + * Return: + * Zero on succes or negative error code on failure. + */ +int drm_client_display_restore(struct drm_client_display *display) +{ + if (drm_drv_uses_atomic_modeset(display->dev)) + return drm_client_display_restore_atomic(display, true); + else + return drm_client_display_restore_legacy(display); +} +EXPORT_SYMBOL(drm_client_display_restore); + +static void drm_client_display_dpms_legacy(struct drm_client_display *display, int dpms_mode) +{ + struct drm_device *dev = display->dev; + struct drm_connector *connector; + struct drm_mode_set *modeset; + int i; + + drm_modeset_lock_all(dev); + drm_client_display_for_each_modeset(modeset, display) { + if (!modeset->crtc->enabled) + continue; + + for (i = 0; i < modeset->num_connectors; i++) { + connector = modeset->connectors[i]; + connector->funcs->dpms(connector, dpms_mode); + drm_object_property_set_value(&connector->base, + dev->mode_config.dpms_property, dpms_mode); + } + } + drm_modeset_unlock_all(dev); +} + +/** + * drm_client_display_dpms() - Set display DPMS mode + * @display: Client display + * @mode: DPMS mode + */ +void drm_client_display_dpms(struct drm_client_display *display, int mode) +{ + if (drm_drv_uses_atomic_modeset(display->dev)) + drm_client_display_restore_atomic(display, mode == DRM_MODE_DPMS_ON); + else + drm_client_display_dpms_legacy(display, mode); +} +EXPORT_SYMBOL(drm_client_display_dpms); diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index bdb4b57d2c12..785a2f5d2647 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -280,188 +280,6 @@ int drm_fb_helper_debug_leave(struct fb_info *info) } EXPORT_SYMBOL(drm_fb_helper_debug_leave);

-/* Check if the plane can hw rotate to match panel orientation */ -static bool drm_fb_helper_panel_rotation(struct drm_connector *connector, - struct drm_plane *plane, - unsigned int *rotation) -{ - uint64_t valid_mask = 0; - unsigned int i; - - if (!connector) - return false; - - switch (connector->display_info.panel_orientation) { - case DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP: - *rotation = DRM_MODE_ROTATE_180; - break; - case DRM_MODE_PANEL_ORIENTATION_LEFT_UP: - *rotation = DRM_MODE_ROTATE_90; - break; - case DRM_MODE_PANEL_ORIENTATION_RIGHT_UP: - *rotation = DRM_MODE_ROTATE_270; - break; - default: - *rotation = DRM_MODE_ROTATE_0; - } - - /* - * TODO: support 90 / 270 degree hardware rotation, - * depending on the hardware this may require the framebuffer - * to be in a specific tiling format. - */ - if (*rotation != DRM_MODE_ROTATE_180 || !plane->rotation_property) - return false; - - for (i = 0; i < plane->rotation_property->num_values; i++) - valid_mask |= (1ULL << plane->rotation_property->values[i]); - - if (!(*rotation & valid_mask)) - return false; - - return true; -} - -static int drm_client_display_restore_atomic(struct drm_client_display *display, bool active) -{ - struct drm_device *dev = display->dev; - struct drm_plane_state *plane_state; - struct drm_mode_set *mode_set; - struct drm_plane *plane; - struct drm_atomic_state *state; - int ret; - unsigned int plane_mask; - struct drm_modeset_acquire_ctx ctx; - - drm_modeset_acquire_init(&ctx, 0); - - state = drm_atomic_state_alloc(dev); - if (!state) { - ret = -ENOMEM; - goto out_ctx; - } - - state->acquire_ctx = &ctx; -retry: - plane_mask = 0; - drm_for_each_plane(plane, dev) { - plane_state = drm_atomic_get_plane_state(state, plane); - if (IS_ERR(plane_state)) { - ret = PTR_ERR(plane_state); - goto out_state; - } - - plane_state->rotation = DRM_MODE_ROTATE_0; - - plane->old_fb = plane->fb; - plane_mask |= 1 << drm_plane_index(plane); - - /* disable non-primary: */ - if (plane->type == DRM_PLANE_TYPE_PRIMARY) - continue; - - ret = drm_atomic_disable_plane(plane, plane_state); - if (ret != 0) - goto out_state; - } - - drm_client_display_for_each_modeset(mode_set, display) { - struct drm_plane *primary = mode_set->crtc->primary; - unsigned int rotation; - - if (drm_fb_helper_panel_rotation(mode_set->connectors[0], primary, &rotation)) { - /* Cannot fail as we've already gotten the plane state above */ - plane_state = drm_atomic_get_new_plane_state(state, primary); - plane_state->rotation = rotation; - } - - ret = drm_atomic_set_config(mode_set, state); - if (ret != 0) - goto out_state; - - /* - * drm_atomic_set_config() sets active when a mode is set, - * unconditionally clear it if we force DPMS off - */ - if (!active) { - struct drm_crtc *crtc = mode_set->crtc; - struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc); - - crtc_state->active = false; - } - } - - ret = drm_atomic_commit(state); - -out_state: - drm_atomic_clean_old_fb(dev, plane_mask, ret); - - if (ret == -EDEADLK) - goto backoff; - - drm_atomic_state_put(state); -out_ctx: - drm_modeset_drop_locks(&ctx); - drm_modeset_acquire_fini(&ctx); - - return ret; - -backoff: - drm_atomic_state_clear(state); - drm_modeset_backoff(&ctx); - - goto retry; -} - -static int drm_client_display_restore_legacy(struct drm_client_display *display) -{ - struct drm_device *dev = display->dev; - struct drm_mode_set *mode_set; - struct drm_plane *plane; - int ret = 0; - - drm_modeset_lock_all(dev); - drm_for_each_plane(plane, dev) { - if (plane->type != DRM_PLANE_TYPE_PRIMARY) - drm_plane_force_disable(plane); - - if (plane->rotation_property) - drm_mode_plane_set_obj_prop(plane, - plane->rotation_property, - DRM_MODE_ROTATE_0); - } - - drm_client_display_for_each_modeset(mode_set, display) { - struct drm_crtc *crtc = mode_set->crtc; - - if (crtc->funcs->cursor_set2) { - ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0); - if (ret) - goto out; - } else if (crtc->funcs->cursor_set) { - ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0); - if (ret) - goto out; - } - - ret = drm_mode_set_config_internal(mode_set); - if (ret) - goto out; - } -out: - drm_modeset_unlock_all(dev); - - return ret; -} - -static int drm_client_display_restore(struct drm_client_display *display) -{ - if (drm_drv_uses_atomic_modeset(display->dev)) - return drm_client_display_restore_atomic(display, true); - else - return drm_client_display_restore_legacy(display); -} - /** * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration * @fb_helper: driver-allocated fbdev helper, can be NULL @@ -579,36 +397,6 @@ static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { }; #endif

-static void drm_client_display_dpms_legacy(struct drm_client_display *display, int dpms_mode) -{ - struct drm_device *dev = display->dev; - struct drm_connector *connector; - struct drm_mode_set *modeset; - int i; - - drm_modeset_lock_all(dev); - drm_client_display_for_each_modeset(modeset, display) { - if (!modeset->crtc->enabled) - continue; - - for (i = 0; i < modeset->num_connectors; i++) { - connector = modeset->connectors[i]; - connector->funcs->dpms(connector, dpms_mode); - drm_object_property_set_value(&connector->base, - dev->mode_config.dpms_property, dpms_mode); - } - } - drm_modeset_unlock_all(dev); -} - -static void drm_client_display_dpms(struct drm_client_display *display, int mode) -{ - if (drm_drv_uses_atomic_modeset(display->dev)) - drm_client_display_restore_atomic(display, mode == DRM_MODE_DPMS_ON); - else - drm_client_display_dpms_legacy(display, mode); -} - static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode) { struct drm_fb_helper *fb_helper = info->par; @@ -2487,8 +2275,8 @@ static void drm_setup_crtcs_fb(struct drm_fb_helper *fb_helper)

modeset->fb = fb_helper->fb;

- if (drm_fb_helper_panel_rotation(modeset->connectors[0], - modeset->crtc->primary, &rotation)) + if (drm_client_display_panel_rotation(modeset->connectors[0], + modeset->crtc->primary, &rotation)) /* Rotating in hardware, fbcon should not rotate */ sw_rotations |= DRM_MODE_ROTATE_0; else diff --git a/include/drm/drm_client.h b/include/drm/drm_client.h index b6a057802769..ed028f5877d0 100644 --- a/include/drm/drm_client.h +++ b/include/drm/drm_client.h @@ -3,9 +3,11 @@ #ifndef _DRM_CLIENT_H_ #define _DRM_CLIENT_H_

+struct drm_connector; struct drm_crtc; struct drm_device; struct drm_mode_set; +struct drm_plane;

/** * struct drm_client_display - DRM client display @@ -41,4 +43,10 @@ drm_client_display_find_modeset(struct drm_client_display *display, struct drm_c #define drm_client_display_for_each_modeset(modeset, display) \ for (modeset = display->modesets; modeset->crtc; modeset++)

+bool drm_client_display_panel_rotation(struct drm_connector *connector, + struct drm_plane *plane, + unsigned int *rotation); +int drm_client_display_restore(struct drm_client_display *display); +void drm_client_display_dpms(struct drm_client_display *display, int mode); + #endif

Add functions to deal with the registred connectors as an array: - drm_connector_get_all() - drm_connector_put_all()

And to get the enabled status of those connectors: drm_connector_get_enabled_status()

This is prep work to remove struct drm_fb_helper_connector.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_connector.c | 105 ++++++++++++++++++++++++++++++++++++++++ include/drm/drm_connector.h | 5 ++ 2 files changed, 110 insertions(+)

diff --git a/drivers/gpu/drm/drm_connector.c b/drivers/gpu/drm/drm_connector.c index b9eb143d70fc..25c333c05a4e 100644 --- a/drivers/gpu/drm/drm_connector.c +++ b/drivers/gpu/drm/drm_connector.c @@ -1854,3 +1854,108 @@ drm_connector_pick_cmdline_mode(struct drm_connector *connector) return mode; } EXPORT_SYMBOL(drm_connector_pick_cmdline_mode); + +/** + * drm_connector_get_all - Get all connectors into an array + * @dev: DRM device + * @connectors: Returned connector array + * + * This function iterates through all registered connectors and adds them to an + * array allocated by this function. A ref is taken on the connectors. + * + * Use drm_connector_put_all() to drop refs and free the array. + * + * Returns: + * Number of connectors or -ENOMEM on failure. + */ +int drm_connector_get_all(struct drm_device *dev, struct drm_connector ***connectors) +{ + struct drm_connector *connector, **temp, **conns = NULL; + struct drm_connector_list_iter conn_iter; + int connector_count = 0; + + drm_connector_list_iter_begin(dev, &conn_iter); + drm_for_each_connector_iter(connector, &conn_iter) { + temp = krealloc(conns, (connector_count + 1) * sizeof(*conns), GFP_KERNEL); + if (!temp) + goto err_put_free; + + conns = temp; + conns[connector_count++] = connector; + drm_connector_get(connector); + } + drm_connector_list_iter_end(&conn_iter); + + *connectors = conns; + + return connector_count; + +err_put_free: + drm_connector_list_iter_end(&conn_iter); + drm_connector_put_all(conns, connector_count); + + return -ENOMEM; +} +EXPORT_SYMBOL(drm_connector_get_all); + +/** + * drm_connector_put_all - Put and free connector array + * @connectors: Array of connectors + * @connector_count: Number of connectors in the array (can be negative or zero) + * + * This function drops the ref on the connectors an frees the array. + */ +void drm_connector_put_all(struct drm_connector **connectors, int connector_count) +{ + int i; + + if (connector_count < 1) + return; + + for (i = 0; i < connector_count; i++) + drm_connector_put(connectors[i]); + kfree(connectors); +} +EXPORT_SYMBOL(drm_connector_put_all); + +/** + * drm_connector_get_enabled_status - Get enabled status on connectors + * @connectors: Array of connectors + * @connector_count: Number of connectors in the array + * + * This loops over the connector array and sets enabled if connector status is + * _connected_. If no connectors are connected, a new pass is done and + * connectors that are not _disconnected_ are set enabled. + * + * The caller is responsible for freeing the array using kfree(). + * + * Returns: + * A boolean array of connector enabled statuses or NULL on allocation failure. + */ +bool *drm_connector_get_enabled_status(struct drm_connector **connectors, + unsigned int connector_count) +{ + bool *enabled, any_enabled = false; + unsigned int i; + + enabled = kcalloc(connector_count, sizeof(*enabled), GFP_KERNEL); + if (!enabled) + return NULL; + + for (i = 0; i < connector_count; i++) { + if (connectors[i]->status == connector_status_connected) { + enabled[i] = true; + any_enabled = true; + } + } + + if (any_enabled) + return enabled; + + for (i = 0; i < connector_count; i++) + if (connectors[i]->status != connector_status_disconnected) + enabled[i] = true; + + return enabled; +} +EXPORT_SYMBOL(drm_connector_get_enabled_status); diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index 9cb4ca42373c..c3556a5f40c9 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -1169,4 +1169,9 @@ drm_connector_has_preferred_mode(struct drm_connector *connector, struct drm_display_mode * drm_connector_pick_cmdline_mode(struct drm_connector *connector);

+int drm_connector_get_all(struct drm_device *dev, struct drm_connector ***connectors); +void drm_connector_put_all(struct drm_connector **connectors, int connector_count); +bool *drm_connector_get_enabled_status(struct drm_connector **connectors, + unsigned int connector_count); + #endif

As part of moving the modesetting code out of drm_fb_helper and into drm_client, the drm_fb_helper_funcs->initial_config callback needs to go. Replace it with a drm_driver->initial_client_display callback that can work for all in-kernel clients.

TODO: - Add a patch that moves the function out of intel_fbdev.c since it's not fbdev specific anymore.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_fb_helper.c | 19 +++++-- drivers/gpu/drm/i915/i915_drv.c | 1 + drivers/gpu/drm/i915/intel_drv.h | 11 ++++ drivers/gpu/drm/i915/intel_fbdev.c | 113 ++++++++++++++++++------------------- include/drm/drm_drv.h | 21 +++++++ 5 files changed, 104 insertions(+), 61 deletions(-)

diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index b992f59dad30..5407bf6dc8c0 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -2103,6 +2103,20 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, /* prevent concurrent modification of connector_count by hotplug */ lockdep_assert_held(&fb_helper->lock);

+ mutex_lock(&dev->mode_config.mutex); + if (drm_fb_helper_probe_connector_modes(fb_helper, width, height) == 0) + DRM_DEBUG_KMS("No connectors reported connected with modes\n"); + + if (dev->driver->initial_client_display) { + display = dev->driver->initial_client_display(dev, width, height); + if (display) { + drm_client_display_free(fb_helper->display); + fb_helper->display = display; + mutex_unlock(&dev->mode_config.mutex); + return; + } + } + crtcs = kcalloc(fb_helper->connector_count, sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); modes = kcalloc(fb_helper->connector_count, @@ -2120,9 +2134,6 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, if (IS_ERR(display)) goto out;

- mutex_lock(&fb_helper->dev->mode_config.mutex); - if (drm_fb_helper_probe_connector_modes(fb_helper, width, height) == 0) - DRM_DEBUG_KMS("No connectors reported connected with modes\n"); drm_enable_connectors(fb_helper, enabled);

if (!(fb_helper->funcs->initial_config && @@ -2144,7 +2155,6 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper,

drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height); } - mutex_unlock(&fb_helper->dev->mode_config.mutex);

/* need to set the modesets up here for use later */ /* fill out the connector<->crtc mappings into the modesets */ @@ -2182,6 +2192,7 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, drm_client_display_free(fb_helper->display); fb_helper->display = display; out: + mutex_unlock(&dev->mode_config.mutex); kfree(crtcs); kfree(modes); kfree(offsets); diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 07c07d55398b..b746c0cbaa4b 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -2857,6 +2857,7 @@ static struct drm_driver driver = {

.dumb_create = i915_gem_dumb_create, .dumb_map_offset = i915_gem_mmap_gtt, + .initial_client_display = i915_initial_client_display, .ioctls = i915_ioctls, .num_ioctls = ARRAY_SIZE(i915_ioctls), .fops = &i915_driver_fops, diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index d4368589b355..f77f510617c5 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1720,6 +1720,9 @@ extern void intel_fbdev_fini(struct drm_i915_private *dev_priv); extern void intel_fbdev_set_suspend(struct drm_device *dev, int state, bool synchronous); extern void intel_fbdev_output_poll_changed(struct drm_device *dev); extern void intel_fbdev_restore_mode(struct drm_device *dev); +struct drm_client_display * +i915_initial_client_display(struct drm_device *dev, unsigned int width, + unsigned int height); #else static inline int intel_fbdev_init(struct drm_device *dev) { @@ -1749,6 +1752,14 @@ static inline void intel_fbdev_output_poll_changed(struct drm_device *dev) static inline void intel_fbdev_restore_mode(struct drm_device *dev) { } + +static inline struct drm_client_display * +i915_initial_client_display(struct drm_device *dev, unsigned int width, + unsigned int height) +{ + return NULL; +} + #endif

/* intel_fbc.c */ diff --git a/drivers/gpu/drm/i915/intel_fbdev.c b/drivers/gpu/drm/i915/intel_fbdev.c index a4ab8575a72e..b7f44c9475a8 100644 --- a/drivers/gpu/drm/i915/intel_fbdev.c +++ b/drivers/gpu/drm/i915/intel_fbdev.c @@ -38,6 +38,7 @@ #include <linux/vga_switcheroo.h>

#include <drm/drmP.h> +#include <drm/drm_client.h> #include <drm/drm_crtc.h> #include <drm/drm_fb_helper.h> #include "intel_drv.h" @@ -287,18 +288,6 @@ static int intelfb_create(struct drm_fb_helper *helper, return ret; }

-static struct drm_fb_helper_crtc * -intel_fb_helper_crtc(struct drm_fb_helper *fb_helper, struct drm_crtc *crtc) -{ - int i; - - for (i = 0; i < fb_helper->crtc_count; i++) - if (fb_helper->crtc_info[i].mode_set.crtc == crtc) - return &fb_helper->crtc_info[i]; - - return NULL; -} - /* * Try to read the BIOS display configuration and use it for the initial * fb configuration. @@ -326,44 +315,48 @@ intel_fb_helper_crtc(struct drm_fb_helper *fb_helper, struct drm_crtc *crtc) * is in VGA mode we need to recalculate watermarks and set a new high-res * framebuffer anyway. */ -static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper, - struct drm_fb_helper_crtc **crtcs, - struct drm_display_mode **modes, - struct drm_fb_offset *offsets, - bool *enabled, int width, int height) +struct drm_client_display * +i915_initial_client_display(struct drm_device *dev, unsigned int width, + unsigned int height) { - struct drm_i915_private *dev_priv = to_i915(fb_helper->dev); + struct drm_i915_private *dev_priv = to_i915(dev); unsigned long conn_configured, conn_seq, mask; - unsigned int count = min(fb_helper->connector_count, BITS_PER_LONG); - int i, j; - bool *save_enabled; - bool fallback = true, ret = true; + bool fallback = true, *enabled = NULL; + struct drm_client_display *display; + struct drm_connector **connectors; + int i, connector_count; + unsigned int count; int num_connectors_enabled = 0; int num_connectors_detected = 0; struct drm_modeset_acquire_ctx ctx;

- save_enabled = kcalloc(count, sizeof(bool), GFP_KERNEL); - if (!save_enabled) - return false; + display = drm_client_display_create(dev); + if (IS_ERR(display)) + return NULL;

drm_modeset_acquire_init(&ctx, 0);

- while (drm_modeset_lock_all_ctx(fb_helper->dev, &ctx) != 0) + while (drm_modeset_lock_all_ctx(dev, &ctx) != 0) drm_modeset_backoff(&ctx);

- memcpy(save_enabled, enabled, count); + connector_count = drm_connector_get_all(dev, &connectors); + if (connector_count < 1) + goto bail; + + enabled = drm_connector_get_enabled_status(connectors, connector_count); + if (!enabled) + goto bail; + + count = min(connector_count, BITS_PER_LONG); mask = GENMASK(count - 1, 0); conn_configured = 0; retry: conn_seq = conn_configured; for (i = 0; i < count; i++) { - struct drm_fb_helper_connector *fb_conn; - struct drm_connector *connector; + struct drm_connector *connector = connectors[i]; + struct drm_display_mode *mode; + struct drm_mode_set *modeset; struct drm_encoder *encoder; - struct drm_fb_helper_crtc *new_crtc; - - fb_conn = fb_helper->connector_info[i]; - connector = fb_conn->connector;

if (conn_configured & BIT(i)) continue; @@ -402,16 +395,13 @@ static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper,

num_connectors_enabled++;

- new_crtc = intel_fb_helper_crtc(fb_helper, - connector->state->crtc); - /* * Make sure we're not trying to drive multiple connectors * with a single CRTC, since our cloning support may not * match the BIOS. */ - for (j = 0; j < count; j++) { - if (crtcs[j] == new_crtc) { + drm_client_display_for_each_modeset(modeset, display) { + if (modeset->connectors[0] == connector) { DRM_DEBUG_KMS("fallback: cloned configuration\n"); goto bail; } @@ -421,28 +411,26 @@ static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper, connector->name);

/* go for command line mode first */ - modes[i] = drm_connector_pick_cmdline_mode(connector); + mode = drm_connector_pick_cmdline_mode(connector);

/* try for preferred next */ - if (!modes[i]) { + if (!mode) { DRM_DEBUG_KMS("looking for preferred mode on connector %s %d\n", connector->name, connector->has_tile); - modes[i] = drm_connector_has_preferred_mode(connector, - width, - height); + mode = drm_connector_has_preferred_mode(connector, + width, height); }

/* No preferred mode marked by the EDID? Are there any modes? */ - if (!modes[i] && !list_empty(&connector->modes)) { + if (!mode && !list_empty(&connector->modes)) { DRM_DEBUG_KMS("using first mode listed on connector %s\n", connector->name); - modes[i] = list_first_entry(&connector->modes, - struct drm_display_mode, - head); + mode = list_first_entry(&connector->modes, + struct drm_display_mode, head); }

/* last resort: use current mode */ - if (!modes[i]) { + if (!mode) { /* * IMPORTANT: We want to use the adjusted mode (i.e. * after the panel fitter upscaling) as the initial @@ -458,16 +446,26 @@ static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper, */ DRM_DEBUG_KMS("looking for current mode on connector %s\n", connector->name); - modes[i] = &connector->state->crtc->mode; + mode = &connector->state->crtc->mode; } - crtcs[i] = new_crtc; + + modeset = drm_client_display_find_modeset(display, connector->state->crtc); + if (WARN_ON(!modeset)) + goto bail; + + modeset->mode = drm_mode_duplicate(dev, mode); + drm_connector_get(connector); + modeset->connectors[0] = connector; + modeset->num_connectors = 1; + modeset->x = 0; + modeset->y = 0;

DRM_DEBUG_KMS("connector %s on [CRTC:%d:%s]: %dx%d%s\n", connector->name, connector->state->crtc->base.id, connector->state->crtc->name, - modes[i]->hdisplay, modes[i]->vdisplay, - modes[i]->flags & DRM_MODE_FLAG_INTERLACE ? "i" :""); + mode->hdisplay, mode->vdisplay, + mode->flags & DRM_MODE_FLAG_INTERLACE ? "i" : "");

fallback = false; conn_configured |= BIT(i); @@ -492,19 +490,20 @@ static bool intel_fb_initial_config(struct drm_fb_helper *fb_helper, if (fallback) { bail: DRM_DEBUG_KMS("Not using firmware configuration\n"); - memcpy(enabled, save_enabled, count); - ret = false; + drm_client_display_free(display); + display = NULL; }

drm_modeset_drop_locks(&ctx); drm_modeset_acquire_fini(&ctx);

- kfree(save_enabled); - return ret; + drm_connector_put_all(connectors, connector_count); + kfree(enabled); + + return display; }

static const struct drm_fb_helper_funcs intel_fb_helper_funcs = { - .initial_config = intel_fb_initial_config, .fb_probe = intelfb_create, };

diff --git a/include/drm/drm_drv.h b/include/drm/drm_drv.h index 7e545f5f94d3..13356e6fd40c 100644 --- a/include/drm/drm_drv.h +++ b/include/drm/drm_drv.h @@ -32,6 +32,7 @@

#include <drm/drm_device.h>

+struct drm_client_display; struct drm_file; struct drm_gem_object; struct drm_master; @@ -553,6 +554,26 @@ struct drm_driver { struct drm_device *dev, uint32_t handle);

+ /** + * @initial_client_config: + * + * Driver callback to setup an initial fbdev display configuration. + * Drivers can use this callback to tell the fbdev emulation what the + * preferred initial configuration is. This is useful to implement + * smooth booting where the fbdev (and subsequently all userspace) never + * changes the mode, but always inherits the existing configuration. + * + * This callback is optional. + * + * RETURNS: + * + * The driver should return true if a suitable initial configuration has + * been filled out and false when the fbdev helper should fall back to + * the default probing logic. + */ + struct drm_client_display *(*initial_client_display)(struct drm_device *dev, + unsigned int width, unsigned int height); + /** * @gem_vm_ops: Driver private ops for this object */

The stage is now set for a clean removal of drm_fb_helper_crtc. struct drm_client_display is doing its job now.

Also remove the drm_fb_helper_funcs->initial_config which has been superseded by drm_driver->initial_client_display.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_fb_helper.c | 124 +++++++++------------------------------- include/drm/drm_fb_helper.h | 31 ---------- 2 files changed, 26 insertions(+), 129 deletions(-)

diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index 5407bf6dc8c0..ce38eadcb346 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -443,24 +443,6 @@ int drm_fb_helper_blank(int blank, struct fb_info *info) } EXPORT_SYMBOL(drm_fb_helper_blank);

-static void drm_fb_helper_modeset_release(struct drm_fb_helper *helper, - struct drm_mode_set *modeset) -{ - int i; - - for (i = 0; i < modeset->num_connectors; i++) { - drm_connector_put(modeset->connectors[i]); - modeset->connectors[i] = NULL; - } - modeset->num_connectors = 0; - - drm_mode_destroy(helper->dev, modeset->mode); - modeset->mode = NULL; - - /* FIXME should hold a ref? */ - modeset->fb = NULL; -} - static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper) { int i; @@ -470,14 +452,6 @@ static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper) kfree(helper->connector_info[i]); } kfree(helper->connector_info); - - for (i = 0; i < helper->crtc_count; i++) { - struct drm_mode_set *modeset = &helper->crtc_info[i].mode_set; - - drm_fb_helper_modeset_release(helper, modeset); - kfree(modeset->connectors); - } - kfree(helper->crtc_info); }

static void drm_fb_helper_resume_worker(struct work_struct *work) @@ -552,48 +526,18 @@ int drm_fb_helper_init(struct drm_device *dev, struct drm_fb_helper *fb_helper, int max_conn_count) { - struct drm_crtc *crtc; - struct drm_mode_config *config = &dev->mode_config; - int i; - if (!drm_fbdev_emulation) { dev->fb_helper = fb_helper; return 0; }

- if (!max_conn_count) - return -EINVAL; - - fb_helper->crtc_info = kcalloc(config->num_crtc, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL); - if (!fb_helper->crtc_info) - return -ENOMEM; - - fb_helper->crtc_count = config->num_crtc; fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL); - if (!fb_helper->connector_info) { - kfree(fb_helper->crtc_info); + if (!fb_helper->connector_info) return -ENOMEM; - } + fb_helper->connector_info_alloc_count = dev->mode_config.num_connector; fb_helper->connector_count = 0;

- for (i = 0; i < fb_helper->crtc_count; i++) { - fb_helper->crtc_info[i].mode_set.connectors = - kcalloc(max_conn_count, - sizeof(struct drm_connector *), - GFP_KERNEL); - - if (!fb_helper->crtc_info[i].mode_set.connectors) - goto out_free; - fb_helper->crtc_info[i].mode_set.num_connectors = 0; - } - - i = 0; - drm_for_each_crtc(crtc, dev) { - fb_helper->crtc_info[i].mode_set.crtc = crtc; - i++; - } - fb_helper->display = drm_client_display_create(dev); if (IS_ERR(fb_helper->display)) goto out_free; @@ -1830,7 +1774,7 @@ static bool drm_target_cloned(struct drm_fb_helper *fb_helper, struct drm_display_mode *dmt_mode, *mode;

/* only contemplate cloning in the single crtc case */ - if (fb_helper->crtc_count > 1) + if (fb_helper->dev->mode_config.num_crtc > 1) return false;

count = 0; @@ -1997,16 +1941,18 @@ static bool drm_target_preferred(struct drm_fb_helper *fb_helper, }

static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, - struct drm_fb_helper_crtc **best_crtcs, + struct drm_crtc **best_crtcs, struct drm_display_mode **modes, int n, int width, int height) { - int c, o; + struct drm_client_display *display = fb_helper->display; + struct drm_device *dev = display->dev; + int o, my_score, best_score, score; struct drm_connector *connector; const struct drm_connector_helper_funcs *connector_funcs; + struct drm_mode_set *modeset; struct drm_encoder *encoder; - int my_score, best_score, score; - struct drm_fb_helper_crtc **crtcs, *crtc; + struct drm_crtc **crtcs; struct drm_fb_helper_connector *fb_helper_conn;

if (n == fb_helper->connector_count) @@ -2020,8 +1966,7 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, if (modes[n] == NULL) return best_score;

- crtcs = kcalloc(fb_helper->connector_count, - sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); + crtcs = kcalloc(fb_helper->connector_count, sizeof(*crtcs), GFP_KERNEL); if (!crtcs) return best_score;

@@ -2053,10 +1998,10 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, * select a crtc for this connector and then attempt to configure * remaining connectors */ - for (c = 0; c < fb_helper->crtc_count; c++) { - crtc = &fb_helper->crtc_info[c]; + drm_client_display_for_each_modeset(modeset, display) { + struct drm_crtc *crtc = modeset->crtc;

- if ((encoder->possible_crtcs & (1 << c)) == 0) + if ((encoder->possible_crtcs & drm_crtc_mask(crtc)) == 0) continue;

for (o = 0; o < n; o++) @@ -2065,7 +2010,7 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,

if (o < n) { /* ignore cloning unless only a single crtc */ - if (fb_helper->crtc_count > 1) + if (dev->mode_config.num_crtc > 1) continue;

if (!drm_mode_equal(modes[o], modes[n])) @@ -2073,14 +2018,13 @@ static int drm_pick_crtcs(struct drm_fb_helper *fb_helper, }

crtcs[n] = crtc; - memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *)); + memcpy(crtcs, best_crtcs, n * sizeof(*crtcs)); score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1, width, height); if (score > best_score) { best_score = score; memcpy(best_crtcs, crtcs, - fb_helper->connector_count * - sizeof(struct drm_fb_helper_crtc *)); + fb_helper->connector_count * sizeof(*crtcs)); } } out: @@ -2093,9 +2037,9 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, { struct drm_device *dev = fb_helper->dev; struct drm_client_display *display; - struct drm_fb_helper_crtc **crtcs; struct drm_display_mode **modes; struct drm_fb_offset *offsets; + struct drm_crtc **crtcs; bool *enabled; int i;

@@ -2117,8 +2061,7 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, } }

- crtcs = kcalloc(fb_helper->connector_count, - sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL); + crtcs = kcalloc(fb_helper->connector_count, sizeof(*crtcs), GFP_KERNEL); modes = kcalloc(fb_helper->connector_count, sizeof(struct drm_display_mode *), GFP_KERNEL); offsets = kcalloc(fb_helper->connector_count, @@ -2136,43 +2079,28 @@ static void drm_setup_crtcs(struct drm_fb_helper *fb_helper,

drm_enable_connectors(fb_helper, enabled);

- if (!(fb_helper->funcs->initial_config && - fb_helper->funcs->initial_config(fb_helper, crtcs, modes, - offsets, - enabled, width, height))) { - memset(modes, 0, fb_helper->connector_count*sizeof(modes[0])); - memset(crtcs, 0, fb_helper->connector_count*sizeof(crtcs[0])); - memset(offsets, 0, fb_helper->connector_count*sizeof(offsets[0])); + if (!drm_target_cloned(fb_helper, modes, offsets, enabled, width, height) && + !drm_target_preferred(fb_helper, modes, offsets, enabled, width, height)) + DRM_ERROR("Unable to find initial modes\n");

- if (!drm_target_cloned(fb_helper, modes, offsets, - enabled, width, height) && - !drm_target_preferred(fb_helper, modes, offsets, - enabled, width, height)) - DRM_ERROR("Unable to find initial modes\n"); + DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height);

- DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", - width, height); - - drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height); - } + drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);

/* need to set the modesets up here for use later */ /* fill out the connector<->crtc mappings into the modesets */ - for (i = 0; i < fb_helper->crtc_count; i++) - drm_fb_helper_modeset_release(fb_helper, - &fb_helper->crtc_info[i].mode_set);

drm_fb_helper_for_each_connector(fb_helper, i) { struct drm_display_mode *mode = modes[i]; - struct drm_fb_helper_crtc *fb_crtc = crtcs[i]; + struct drm_crtc *crtc = crtcs[i]; struct drm_fb_offset *offset = &offsets[i];

- if (mode && fb_crtc) { + if (mode && crtc) { struct drm_connector *connector = fb_helper->connector_info[i]->connector; struct drm_mode_set *modeset;

- modeset = drm_client_display_find_modeset(display, fb_crtc->mode_set.crtc); + modeset = drm_client_display_find_modeset(display, crtc); if (WARN_ON(!modeset)) { drm_client_display_free(display); goto out; diff --git a/include/drm/drm_fb_helper.h b/include/drm/drm_fb_helper.h index f379ef6d6085..408931f7613f 100644 --- a/include/drm/drm_fb_helper.h +++ b/include/drm/drm_fb_helper.h @@ -45,12 +45,6 @@ struct drm_fb_offset { int x, y; };

-struct drm_fb_helper_crtc { - struct drm_mode_set mode_set; - struct drm_display_mode *desired_mode; - int x, y; -}; - /** * struct drm_fb_helper_surface_size - describes fbdev size and scanout surface size * @fb_width: fbdev width @@ -101,29 +95,6 @@ struct drm_fb_helper_funcs { */ int (*fb_probe)(struct drm_fb_helper *helper, struct drm_fb_helper_surface_size *sizes); - - /** - * @initial_config: - * - * Driver callback to setup an initial fbdev display configuration. - * Drivers can use this callback to tell the fbdev emulation what the - * preferred initial configuration is. This is useful to implement - * smooth booting where the fbdev (and subsequently all userspace) never - * changes the mode, but always inherits the existing configuration. - * - * This callback is optional. - * - * RETURNS: - * - * The driver should return true if a suitable initial configuration has - * been filled out and false when the fbdev helper should fall back to - * the default probing logic. - */ - bool (*initial_config)(struct drm_fb_helper *fb_helper, - struct drm_fb_helper_crtc **crtcs, - struct drm_display_mode **modes, - struct drm_fb_offset *offsets, - bool *enabled, int width, int height); };

struct drm_fb_helper_connector { @@ -163,8 +134,6 @@ struct drm_fb_helper { */ struct drm_client_display *display;

- int crtc_count; - struct drm_fb_helper_crtc *crtc_info; int connector_count; int connector_info_alloc_count; /**

Call the function drm_client_find_display(). No functional change apart from making width/height arguments optional. Some function name/signature changes and whitespace adjustments.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_client.c | 399 ++++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_fb_helper.c | 371 +------------------------------------ include/drm/drm_client.h | 2 + include/drm/drm_fb_helper.h | 4 - 4 files changed, 403 insertions(+), 373 deletions(-)

diff --git a/drivers/gpu/drm/drm_client.c b/drivers/gpu/drm/drm_client.c index c85c13568cf9..27818a467b09 100644 --- a/drivers/gpu/drm/drm_client.c +++ b/drivers/gpu/drm/drm_client.c @@ -18,6 +18,10 @@ #include <drm/drm_device.h> #include <drm/drm_modes.h>

+struct drm_client_display_offset { + int x, y; +}; + /** * drm_client_display_create() - Create display structure * @dev: DRM device @@ -359,3 +363,398 @@ void drm_client_display_dpms(struct drm_client_display *display, int mode) drm_client_display_dpms_legacy(display, mode); } EXPORT_SYMBOL(drm_client_display_dpms); + +static int drm_client_probe_connector_modes(struct drm_device *dev, + u32 max_width, u32 max_height) +{ + struct drm_connector_list_iter conn_iter; + struct drm_connector *connector; + int count = 0; + + drm_connector_list_iter_begin(dev, &conn_iter); + drm_for_each_connector_iter(connector, &conn_iter) { + count += connector->funcs->fill_modes(connector, max_width, max_height); + } + drm_connector_list_iter_end(&conn_iter); + + return count; +} + +static bool drm_target_cloned(struct drm_device *dev, + struct drm_connector **connectors, + unsigned int connector_count, + struct drm_display_mode **modes, + struct drm_client_display_offset *offsets, + bool *enabled, int width, int height) +{ + int count, i, j; + bool can_clone = false; + struct drm_display_mode *dmt_mode, *mode; + + /* only contemplate cloning in the single crtc case */ + if (dev->mode_config.num_crtc > 1) + return false; + + count = 0; + for (i = 0; i < connector_count; i++) { + if (enabled[i]) + count++; + } + + /* only contemplate cloning if more than one connector is enabled */ + if (count <= 1) + return false; + + /* check the command line or if nothing common pick 1024x768 */ + can_clone = true; + for (i = 0; i < connector_count; i++) { + if (!enabled[i]) + continue; + modes[i] = drm_connector_pick_cmdline_mode(connectors[i]); + if (!modes[i]) { + can_clone = false; + break; + } + for (j = 0; j < i; j++) { + if (!enabled[j]) + continue; + if (!drm_mode_equal(modes[j], modes[i])) + can_clone = false; + } + } + + if (can_clone) { + DRM_DEBUG_KMS("can clone using command line\n"); + return true; + } + + /* try and find a 1024x768 mode on each connector */ + can_clone = true; + dmt_mode = drm_mode_find_dmt(dev, 1024, 768, 60, false); + + for (i = 0; i < connector_count; i++) { + if (!enabled[i]) + continue; + + list_for_each_entry(mode, &connectors[i]->modes, head) { + if (drm_mode_equal(mode, dmt_mode)) + modes[i] = mode; + } + if (!modes[i]) + can_clone = false; + } + + if (can_clone) { + DRM_DEBUG_KMS("can clone using 1024x768\n"); + return true; + } + DRM_INFO("kms: can't enable cloning when we probably wanted to.\n"); + + return false; +} + +static void drm_get_tile_offsets(struct drm_connector **connectors, + unsigned int connector_count, + struct drm_display_mode **modes, + struct drm_client_display_offset *offsets, + int idx, + int h_idx, int v_idx) +{ + int i; + int hoffset = 0, voffset = 0; + + for (i = 0; i < connector_count; i++) { + struct drm_connector *connector = connectors[i]; + + if (!connector->has_tile) + continue; + + if (!modes[i] && (h_idx || v_idx)) { + DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i, + connector->base.id); + continue; + } + if (connector->tile_h_loc < h_idx) + hoffset += modes[i]->hdisplay; + + if (connector->tile_v_loc < v_idx) + voffset += modes[i]->vdisplay; + } + offsets[idx].x = hoffset; + offsets[idx].y = voffset; + DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx); +} + +static bool drm_target_preferred(struct drm_connector **connectors, + unsigned int connector_count, + struct drm_display_mode **modes, + struct drm_client_display_offset *offsets, + bool *enabled, int width, int height) +{ + const u64 mask = BIT_ULL(connector_count) - 1; + u64 conn_configured = 0; + int tile_pass = 0; + int i; + +retry: + for (i = 0; i < connector_count; i++) { + struct drm_connector *connector = connectors[i]; + + if (conn_configured & BIT_ULL(i)) + continue; + + if (!enabled[i]) { + conn_configured |= BIT_ULL(i); + continue; + } + + /* first pass over all the untiled connectors */ + if (tile_pass == 0 && connector->has_tile) + continue; + + if (tile_pass == 1) { + if (connector->tile_h_loc != 0 || + connector->tile_v_loc != 0) + continue; + + } else { + if (connector->tile_h_loc != tile_pass - 1 && + connector->tile_v_loc != tile_pass - 1) + /* if this tile_pass doesn't cover any of the tiles - keep going */ + continue; + + /* + * find the tile offsets for this pass - need to find + * all tiles left and above + */ + drm_get_tile_offsets(connectors, connector_count, modes, offsets, + i, connector->tile_h_loc, connector->tile_v_loc); + } + DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n", connector->base.id); + + /* got for command line mode first */ + modes[i] = drm_connector_pick_cmdline_mode(connector); + if (!modes[i]) { + DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n", + connector->base.id, + connector->tile_group ? connector->tile_group->id : 0); + modes[i] = drm_connector_has_preferred_mode(connector, width, height); + } + /* No preferred modes, pick one off the list */ + if (!modes[i]) + modes[i] = list_first_entry_or_null(&connector->modes, + struct drm_display_mode, head); + + DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name : "none"); + conn_configured |= BIT_ULL(i); + } + + if ((conn_configured & mask) != mask) { + tile_pass++; + goto retry; + } + return true; +} + +static int drm_pick_crtcs(struct drm_client_display *display, + struct drm_connector **connectors, + unsigned int connector_count, + struct drm_crtc **best_crtcs, + struct drm_display_mode **modes, + int n, int width, int height) +{ + struct drm_device *dev = display->dev; + int o, my_score, best_score, score; + struct drm_connector *connector; + struct drm_mode_set *modeset; + struct drm_encoder *encoder; + struct drm_crtc **crtcs; + + if (n == connector_count) + return 0; + + connector = connectors[n]; + + best_crtcs[n] = NULL; + best_score = drm_pick_crtcs(display, connectors, connector_count, + best_crtcs, modes, n + 1, width, height); + if (!modes[n]) + return best_score; + + crtcs = kcalloc(connector_count, sizeof(*crtcs), GFP_KERNEL); + if (!crtcs) + return best_score; + + my_score = 1; + if (connector->status == connector_status_connected) + my_score++; + if (connector->cmdline_mode.specified) + my_score++; + if (drm_connector_has_preferred_mode(connector, width, height)) + my_score++; + + /* + * If the DRM device implements atomic hooks and ->best_encoder() is + * NULL we fallback to the default drm_atomic_helper_best_encoder() + * helper. + */ + if (drm_drv_uses_atomic_modeset(dev) && + !connector->helper_private->best_encoder) + encoder = drm_atomic_helper_best_encoder(connector); + else + encoder = connector->helper_private->best_encoder(connector); + + if (!encoder) + goto out; + + /* + * select a crtc for this connector and then attempt to configure + * remaining connectors + */ + drm_client_display_for_each_modeset(modeset, display) { + struct drm_crtc *crtc = modeset->crtc; + + if ((encoder->possible_crtcs & drm_crtc_mask(crtc)) == 0) + continue; + + for (o = 0; o < n; o++) + if (best_crtcs[o] == crtc) + break; + + if (o < n) { + /* ignore cloning unless only a single crtc */ + if (dev->mode_config.num_crtc > 1) + continue; + + if (!drm_mode_equal(modes[o], modes[n])) + continue; + } + + crtcs[n] = crtc; + memcpy(crtcs, best_crtcs, n * sizeof(*crtcs)); + score = my_score + drm_pick_crtcs(display, connectors, connector_count, + crtcs, modes, n + 1, width, height); + if (score > best_score) { + best_score = score; + memcpy(best_crtcs, crtcs, + connector_count * sizeof(*crtcs)); + } + } +out: + kfree(crtcs); + + return best_score; +} + +/** + * drm_client_find_display() - Find display + * @dev: DRM device + * @width: Maximum display mode width (optional) + * @height: Maximum display mode height (optional) + * + * This function returns a display the client can use if available. + * + * Free resources by calling drm_client_display_free(). + * + * Returns: + * A &drm_client_display on success, NULL if no connectors are found + * or error pointer on failure. + */ +struct drm_client_display * +drm_client_find_display(struct drm_device *dev, unsigned int width, unsigned int height) +{ + struct drm_client_display_offset *offsets; + struct drm_client_display *display; + struct drm_connector **connectors; + struct drm_display_mode **modes; + struct drm_crtc **crtcs; + int i, connector_count; + bool *enabled; + + DRM_DEBUG_KMS("\n"); + + if (!width) + width = dev->mode_config.max_width; + if (!height) + height = dev->mode_config.max_height; + + mutex_lock(&dev->mode_config.mutex); + if (!drm_client_probe_connector_modes(dev, width, height)) + DRM_DEBUG_KMS("No connectors reported connected with modes\n"); + + if (dev->driver->initial_client_display) { + display = dev->driver->initial_client_display(dev, width, height); + if (display) { + mutex_unlock(&dev->mode_config.mutex); + return display; + } + } + + connector_count = drm_connector_get_all(dev, &connectors); + if (connector_count < 1) + return NULL; + + enabled = drm_connector_get_enabled_status(connectors, connector_count); + crtcs = kcalloc(connector_count, sizeof(*crtcs), GFP_KERNEL); + modes = kcalloc(connector_count, sizeof(*modes), GFP_KERNEL); + offsets = kcalloc(connector_count, sizeof(*offsets), GFP_KERNEL); + if (!crtcs || !modes || !enabled || !offsets) { + DRM_ERROR("Memory allocation failed\n"); + display = ERR_PTR(-ENOMEM); + goto out; + } + + display = drm_client_display_create(dev); + if (IS_ERR(display)) + goto out; + + if (!drm_target_cloned(dev, connectors, connector_count, + modes, offsets, enabled, width, height) && + !drm_target_preferred(connectors, connector_count, + modes, offsets, enabled, width, height)) + DRM_ERROR("Unable to find initial modes\n"); + + DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height); + + drm_pick_crtcs(display, connectors, connector_count, crtcs, modes, 0, width, height); + + /* need to set the modesets up here for use later */ + /* fill out the connector<->crtc mappings into the modesets */ + + for (i = 0; i < connector_count; i++) { + struct drm_client_display_offset *offset = &offsets[i]; + struct drm_connector *connector = connectors[i]; + struct drm_display_mode *mode = modes[i]; + struct drm_crtc *crtc = crtcs[i]; + + if (mode && crtc) { + struct drm_mode_set *modeset; + + modeset = drm_client_display_find_modeset(display, crtc); + if (WARN_ON(!modeset)) { + drm_client_display_free(display); + display = ERR_PTR(-EINVAL); + goto out; + } + + DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n", + mode->name, modeset->crtc->base.id, offset->x, offset->y); + + modeset->mode = drm_mode_duplicate(dev, mode); + drm_connector_get(connector); + modeset->connectors[modeset->num_connectors++] = connector; + modeset->x = offset->x; + modeset->y = offset->y; + } + } +out: + mutex_unlock(&dev->mode_config.mutex); + drm_connector_put_all(connectors, connector_count); + kfree(crtcs); + kfree(modes); + kfree(offsets); + kfree(enabled); + + return display; +} +EXPORT_SYMBOL(drm_client_find_display); diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c index 6ee61f195321..01d8840930a3 100644 --- a/drivers/gpu/drm/drm_fb_helper.c +++ b/drivers/gpu/drm/drm_fb_helper.c @@ -1558,386 +1558,19 @@ void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helpe } EXPORT_SYMBOL(drm_fb_helper_fill_var);

-static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper, - uint32_t maxX, - uint32_t maxY) -{ - struct drm_connector_list_iter conn_iter; - struct drm_connector *connector; - int count = 0; - - drm_connector_list_iter_begin(fb_helper->dev, &conn_iter); - drm_for_each_connector_iter(connector, &conn_iter) { - count += connector->funcs->fill_modes(connector, maxX, maxY); - } - drm_connector_list_iter_end(&conn_iter); - - return count; -} - -static bool drm_target_cloned(struct drm_fb_helper *fb_helper, - struct drm_connector **connectors, - unsigned int connector_count, - struct drm_display_mode **modes, - struct drm_fb_offset *offsets, - bool *enabled, int width, int height) -{ - int count, i, j; - bool can_clone = false; - struct drm_display_mode *dmt_mode, *mode; - - /* only contemplate cloning in the single crtc case */ - if (fb_helper->dev->mode_config.num_crtc > 1) - return false; - - count = 0; - for (i = 0; i < connector_count; i++) { - if (enabled[i]) - count++; - } - - /* only contemplate cloning if more than one connector is enabled */ - if (count <= 1) - return false; - - /* check the command line or if nothing common pick 1024x768 */ - can_clone = true; - for (i = 0; i < connector_count; i++) { - if (!enabled[i]) - continue; - modes[i] = drm_connector_pick_cmdline_mode(connectors[i]); - if (!modes[i]) { - can_clone = false; - break; - } - for (j = 0; j < i; j++) { - if (!enabled[j]) - continue; - if (!drm_mode_equal(modes[j], modes[i])) - can_clone = false; - } - } - - if (can_clone) { - DRM_DEBUG_KMS("can clone using command line\n"); - return true; - } - - /* try and find a 1024x768 mode on each connector */ - can_clone = true; - dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60, false); - - for (i = 0; i < connector_count; i++) { - if (!enabled[i]) - continue; - - list_for_each_entry(mode, &connectors[i]->modes, head) { - if (drm_mode_equal(mode, dmt_mode)) - modes[i] = mode; - } - if (!modes[i]) - can_clone = false; - } - - if (can_clone) { - DRM_DEBUG_KMS("can clone using 1024x768\n"); - return true; - } - DRM_INFO("kms: can't enable cloning when we probably wanted to.\n"); - return false; -} - -static int drm_get_tile_offsets(struct drm_connector **connectors, - unsigned int connector_count, - struct drm_display_mode **modes, - struct drm_fb_offset *offsets, - int idx, - int h_idx, int v_idx) -{ - int i; - int hoffset = 0, voffset = 0; - - for (i = 0; i < connector_count; i++) { - struct drm_connector *connector = connectors[i]; - - if (!connector->has_tile) - continue; - - if (!modes[i] && (h_idx || v_idx)) { - DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i, - connector->base.id); - continue; - } - if (connector->tile_h_loc < h_idx) - hoffset += modes[i]->hdisplay; - - if (connector->tile_v_loc < v_idx) - voffset += modes[i]->vdisplay; - } - offsets[idx].x = hoffset; - offsets[idx].y = voffset; - DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx); - return 0; -} - -static bool drm_target_preferred(struct drm_connector **connectors, - unsigned int connector_count, - struct drm_display_mode **modes, - struct drm_fb_offset *offsets, - bool *enabled, int width, int height) -{ - const u64 mask = BIT_ULL(connector_count) - 1; - u64 conn_configured = 0; - int tile_pass = 0; - int i; - -retry: - for (i = 0; i < connector_count; i++) { - struct drm_connector *connector = connectors[i]; - - if (conn_configured & BIT_ULL(i)) - continue; - - if (enabled[i] == false) { - conn_configured |= BIT_ULL(i); - continue; - } - - /* first pass over all the untiled connectors */ - if (tile_pass == 0 && connector->has_tile) - continue; - - if (tile_pass == 1) { - if (connector->tile_h_loc != 0 || - connector->tile_v_loc != 0) - continue; - - } else { - if (connector->tile_h_loc != tile_pass - 1 && - connector->tile_v_loc != tile_pass - 1) - /* if this tile_pass doesn't cover any of the tiles - keep going */ - continue; - - /* - * find the tile offsets for this pass - need to find - * all tiles left and above - */ - drm_get_tile_offsets(connectors, connector_count, modes, offsets, - i, connector->tile_h_loc, connector->tile_v_loc); - } - DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n", - connector->base.id); - - /* got for command line mode first */ - modes[i] = drm_connector_pick_cmdline_mode(connector); - if (!modes[i]) { - DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n", - connector->base.id, connector->tile_group ? connector->tile_group->id : 0); - modes[i] = drm_connector_has_preferred_mode(connector, width, height); - } - /* No preferred modes, pick one off the list */ - if (!modes[i]) - modes[i] = list_first_entry_or_null(&connector->modes, struct drm_display_mode, head); - - DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name : - "none"); - conn_configured |= BIT_ULL(i); - } - - if ((conn_configured & mask) != mask) { - tile_pass++; - goto retry; - } - return true; -} - -static int drm_pick_crtcs(struct drm_client_display *display, - struct drm_connector **connectors, - unsigned int connector_count, - struct drm_crtc **best_crtcs, - struct drm_display_mode **modes, - int n, int width, int height) -{ - struct drm_device *dev = display->dev; - int o, my_score, best_score, score; - struct drm_connector *connector; - const struct drm_connector_helper_funcs *connector_funcs; - struct drm_mode_set *modeset; - struct drm_encoder *encoder; - struct drm_crtc **crtcs; - - if (n == connector_count) - return 0; - - connector = connectors[n]; - - best_crtcs[n] = NULL; - best_score = drm_pick_crtcs(display, connectors, connector_count, - best_crtcs, modes, n + 1, width, height); - if (modes[n] == NULL) - return best_score; - - crtcs = kcalloc(connector_count, sizeof(*crtcs), GFP_KERNEL); - if (!crtcs) - return best_score; - - my_score = 1; - if (connector->status == connector_status_connected) - my_score++; - if (connector->cmdline_mode.specified) - my_score++; - if (drm_connector_has_preferred_mode(connector, width, height)) - my_score++; - - connector_funcs = connector->helper_private; - - /* - * If the DRM device implements atomic hooks and ->best_encoder() is - * NULL we fallback to the default drm_atomic_helper_best_encoder() - * helper. - */ - if (drm_drv_uses_atomic_modeset(dev) && - !connector_funcs->best_encoder) - encoder = drm_atomic_helper_best_encoder(connector); - else - encoder = connector_funcs->best_encoder(connector); - - if (!encoder) - goto out; - - /* - * select a crtc for this connector and then attempt to configure - * remaining connectors - */ - drm_client_display_for_each_modeset(modeset, display) { - struct drm_crtc *crtc = modeset->crtc; - - if ((encoder->possible_crtcs & drm_crtc_mask(crtc)) == 0) - continue; - - for (o = 0; o < n; o++) - if (best_crtcs[o] == crtc) - break; - - if (o < n) { - /* ignore cloning unless only a single crtc */ - if (dev->mode_config.num_crtc > 1) - continue; - - if (!drm_mode_equal(modes[o], modes[n])) - continue; - } - - crtcs[n] = crtc; - memcpy(crtcs, best_crtcs, n * sizeof(*crtcs)); - score = my_score + drm_pick_crtcs(display, connectors, connector_count, - crtcs, modes, n + 1, width, height); - if (score > best_score) { - best_score = score; - memcpy(best_crtcs, crtcs, - connector_count * sizeof(*crtcs)); - } - } -out: - kfree(crtcs); - return best_score; -} - static void drm_setup_crtcs(struct drm_fb_helper *fb_helper, u32 width, u32 height) { - struct drm_device *dev = fb_helper->dev; struct drm_client_display *display; - struct drm_connector **connectors; - struct drm_display_mode **modes; - struct drm_fb_offset *offsets; - struct drm_crtc **crtcs; - int i, connector_count; - bool *enabled;

- DRM_DEBUG_KMS("\n"); - /* prevent concurrent modification of connector_count by hotplug */ lockdep_assert_held(&fb_helper->lock);

- mutex_lock(&dev->mode_config.mutex); - if (drm_fb_helper_probe_connector_modes(fb_helper, width, height) == 0) - DRM_DEBUG_KMS("No connectors reported connected with modes\n"); - - if (dev->driver->initial_client_display) { - display = dev->driver->initial_client_display(dev, width, height); - if (display) { - drm_client_display_free(fb_helper->display); - fb_helper->display = display; - mutex_unlock(&dev->mode_config.mutex); - return; - } - } - - connector_count = drm_connector_get_all(dev, &connectors); - if (connector_count < 1) + display = drm_client_find_display(fb_helper->dev, width, height); + if (IS_ERR_OR_NULL(display)) return;

- enabled = drm_connector_get_enabled_status(connectors, connector_count); - crtcs = kcalloc(connector_count, sizeof(*crtcs), GFP_KERNEL); - modes = kcalloc(connector_count, sizeof(*modes), GFP_KERNEL); - offsets = kcalloc(connector_count, sizeof(*offsets), GFP_KERNEL); - if (!crtcs || !modes || !enabled || !offsets) { - DRM_ERROR("Memory allocation failed\n"); - goto out; - } - - display = drm_client_display_create(dev); - if (IS_ERR(display)) - goto out; - - if (!drm_target_cloned(fb_helper, connectors, connector_count, - modes, offsets, enabled, width, height) && - !drm_target_preferred(connectors, connector_count, - modes, offsets, enabled, width, height)) - DRM_ERROR("Unable to find initial modes\n"); - - DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n", width, height); - - drm_pick_crtcs(display, connectors, connector_count, crtcs, modes, 0, width, height); - - /* need to set the modesets up here for use later */ - /* fill out the connector<->crtc mappings into the modesets */ - - for (i = 0; i < connector_count; i++) { - struct drm_connector *connector = connectors[i]; - struct drm_display_mode *mode = modes[i]; - struct drm_crtc *crtc = crtcs[i]; - struct drm_fb_offset *offset = &offsets[i]; - - if (mode && crtc) { - struct drm_mode_set *modeset; - - modeset = drm_client_display_find_modeset(display, crtc); - if (WARN_ON(!modeset)) { - drm_client_display_free(display); - goto out; - } - - DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n", - mode->name, modeset->crtc->base.id, offset->x, offset->y); - - modeset->mode = drm_mode_duplicate(dev, mode); - drm_connector_get(connector); - modeset->connectors[modeset->num_connectors++] = connector; - modeset->x = offset->x; - modeset->y = offset->y; - } - } - drm_client_display_free(fb_helper->display); fb_helper->display = display; -out: - mutex_unlock(&dev->mode_config.mutex); - drm_connector_put_all(connectors, connector_count); - kfree(crtcs); - kfree(modes); - kfree(offsets); - kfree(enabled); }

/* diff --git a/include/drm/drm_client.h b/include/drm/drm_client.h index ed028f5877d0..27d2a46cd94a 100644 --- a/include/drm/drm_client.h +++ b/include/drm/drm_client.h @@ -48,5 +48,7 @@ bool drm_client_display_panel_rotation(struct drm_connector *connector, unsigned int *rotation); int drm_client_display_restore(struct drm_client_display *display); void drm_client_display_dpms(struct drm_client_display *display, int mode); +struct drm_client_display * +drm_client_find_display(struct drm_device *dev, unsigned int width, unsigned int height);

#endif diff --git a/include/drm/drm_fb_helper.h b/include/drm/drm_fb_helper.h index a1e1ab1247c5..5f66f253a97b 100644 --- a/include/drm/drm_fb_helper.h +++ b/include/drm/drm_fb_helper.h @@ -41,10 +41,6 @@ enum mode_set_atomic { ENTER_ATOMIC_MODE_SET, };

-struct drm_fb_offset { - int x, y; -}; - /** * struct drm_fb_helper_surface_size - describes fbdev size and scanout surface size * @fb_width: fbdev width

The modesetting code is already present, this adds the rest of the API.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_client.c | 573 +++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_debugfs.c | 7 + drivers/gpu/drm/drm_drv.c | 11 + drivers/gpu/drm/drm_file.c | 3 + drivers/gpu/drm/drm_probe_helper.c | 3 + drivers/gpu/drm/drm_sysfs.c | 20 ++ include/drm/drm_client.h | 103 +++++++ include/drm/drm_device.h | 4 + 8 files changed, 724 insertions(+)

diff --git a/drivers/gpu/drm/drm_client.c b/drivers/gpu/drm/drm_client.c index bce1630a0db2..760f1795f812 100644 --- a/drivers/gpu/drm/drm_client.c +++ b/drivers/gpu/drm/drm_client.c @@ -8,7 +8,9 @@ * Copyright (c) 2007 Dave Airlie airlied@linux.ie */

+#include <linux/dma-buf.h> #include <linux/list.h> +#include <linux/mutex.h> #include <linux/slab.h>

#include <drm/drm_atomic.h> @@ -17,14 +19,280 @@ #include <drm/drm_connector.h> #include <drm/drm_crtc.h> #include <drm/drm_device.h> +#include <drm/drm_file.h> #include <drm/drm_modes.h>

+#include "drm_crtc_internal.h" #include "drm_internal.h"

struct drm_client_display_offset { int x, y; };

+static int drm_client_alloc_file(struct drm_client_dev *client) +{ + struct drm_device *dev = client->dev; + struct drm_file *file; + + file = drm_file_alloc(dev->primary); + if (IS_ERR(file)) + return PTR_ERR(file); + + drm_dev_get(dev); + + mutex_lock(&dev->filelist_mutex); + list_add(&file->lhead, &dev->filelist_internal); + mutex_unlock(&dev->filelist_mutex); + + client->file = file; + + return 0; +} + +static void drm_client_free_file(struct drm_client_dev *client) +{ + struct drm_device *dev = client->dev; + + mutex_lock(&dev->filelist_mutex); + list_del(&client->file->lhead); + mutex_unlock(&dev->filelist_mutex); + + drm_file_free(client->file); + drm_dev_put(dev); +} + +struct drm_client_dev * +drm_client_new(struct drm_device *dev, const struct drm_client_funcs *funcs) +{ + struct drm_client_dev *client; + int ret; + + if (WARN_ON(!funcs->name)) + return ERR_PTR(-EINVAL); + + client = kzalloc(sizeof(*client), GFP_KERNEL); + if (!client) + return ERR_PTR(-ENOMEM); + + client->dev = dev; + client->funcs = funcs; + + ret = drm_client_alloc_file(client); + if (ret) { + kfree(client); + return ERR_PTR(ret); + } + + mutex_lock(&dev->clientlist_mutex); + list_add(&client->list, &dev->clientlist); + mutex_unlock(&dev->clientlist_mutex); + + return client; +} +EXPORT_SYMBOL(drm_client_new); + +struct drm_client_dev * +drm_client_new_from_id(unsigned int dev_id, const struct drm_client_funcs *funcs) +{ + struct drm_client_dev *client; + struct drm_minor *minor; + + minor = drm_minor_acquire(dev_id); + if (IS_ERR(minor)) + return ERR_CAST(minor); + + client = drm_client_new(minor->dev, funcs); + + drm_minor_release(minor); + + return client; +} +EXPORT_SYMBOL(drm_client_new_from_id); + +/** + * drm_client_free - Free DRM client resources + * @client: DRM client + * + * This is called automatically on client removal unless the client returns + * non-zero in the &drm_client_funcs->remove callback. The fbdev client does + * this when it can't close &drm_file because userspace has an open fd. + * + * Note: + * If the client can't release it's resources on remove, it needs to hold a + * reference on the driver module to prevent the code from going away. + */ +void drm_client_free(struct drm_client_dev *client) +{ + DRM_DEV_DEBUG_KMS(client->dev->dev, "%s\n", client->funcs->name); + drm_client_free_file(client); + kfree(client); +} +EXPORT_SYMBOL(drm_client_free); + +static void drm_client_remove_locked(struct drm_client_dev *client) +{ + list_del(&client->list); + + if (!client->funcs->remove || !client->funcs->remove(client)) + drm_client_free(client); +} + +static void drm_client_remove_safe(struct drm_device *dev, + struct drm_client_dev *client) +{ + struct drm_client_dev *iter; + + mutex_lock(&dev->clientlist_mutex); + list_for_each_entry(iter, &dev->clientlist, list) { + if (iter == client) { + drm_client_remove_locked(client); + break; + } + } + mutex_unlock(&dev->clientlist_mutex); +} + +/** + * drm_client_remove - Remove client + * @client: Client + * + * Remove a client. + */ +void drm_client_remove(struct drm_client_dev *client) +{ + struct drm_device *dev; + + if (!client) + return; + + dev = client->dev; + drm_dev_get(dev); + drm_client_remove_safe(dev, client); + drm_dev_put(dev); +} +EXPORT_SYMBOL(drm_client_remove); + +struct drm_client_remove_defer { + struct list_head list; + struct drm_device *dev; + struct drm_client_dev *client; +}; + +static LIST_HEAD(drm_client_remove_defer_list); +static DEFINE_MUTEX(drm_client_remove_defer_list_lock); + +static void drm_client_remove_defer_work_fn(struct work_struct *work) +{ + struct drm_client_remove_defer *defer, *tmp; + + mutex_lock(&drm_client_remove_defer_list_lock); + list_for_each_entry_safe(defer, tmp, &drm_client_remove_defer_list, list) { + drm_client_remove_safe(defer->dev, defer->client); + drm_dev_put(defer->dev); + list_del(&defer->list); + kfree(defer); + } + mutex_unlock(&drm_client_remove_defer_list_lock); +} + +static DECLARE_WORK(drm_client_remove_defer_work, drm_client_remove_defer_work_fn); + +/** + * drm_client_remove_defer - Deferred client removal + * @client: Client + * + * Defer client removal to a worker. This makes it possible for a client running + * in a worker to remove itself. + * + * Returns: + * Zero on success, or -ENOMEM on allocation failure. + */ +int drm_client_remove_defer(struct drm_client_dev *client) +{ + struct drm_client_remove_defer *defer; + + if (!client) + return 0; + + defer = kzalloc(sizeof(*defer), GFP_KERNEL); + if (!defer) + return -ENOMEM; + + defer->dev = client->dev; + defer->client = client; + drm_dev_get(client->dev); + + mutex_lock(&drm_client_remove_defer_list_lock); + list_add(&defer->list, &drm_client_remove_defer_list); + mutex_unlock(&drm_client_remove_defer_list_lock); + + schedule_work(&drm_client_remove_defer_work); + + return 0; +} +EXPORT_SYMBOL(drm_client_remove_defer); + +void drm_client_init(void) +{ +} + +void drm_client_exit(void) +{ + flush_work(&drm_client_remove_defer_work); +} + +void drm_client_dev_unregister(struct drm_device *dev) +{ + struct drm_client_dev *client, *tmp; + + if (!drm_core_check_feature(dev, DRIVER_MODESET)) + return; + + mutex_lock(&dev->clientlist_mutex); + list_for_each_entry_safe(client, tmp, &dev->clientlist, list) + drm_client_remove_locked(client); + mutex_unlock(&dev->clientlist_mutex); +} + +void drm_client_dev_hotplug(struct drm_device *dev) +{ + struct drm_client_dev *client; + int ret; + + if (!drm_core_check_feature(dev, DRIVER_MODESET)) + return; + + mutex_lock(&dev->clientlist_mutex); + list_for_each_entry(client, &dev->clientlist, list) { + if (!client->funcs->hotplug) + continue; + + ret = client->funcs->hotplug(client); + DRM_DEV_DEBUG_KMS(dev->dev, "%s: ret=%d\n", client->funcs->name, ret); + } + mutex_unlock(&dev->clientlist_mutex); +} +EXPORT_SYMBOL(drm_client_dev_hotplug); + +void drm_client_dev_lastclose(struct drm_device *dev) +{ + struct drm_client_dev *client; + int ret; + + if (!drm_core_check_feature(dev, DRIVER_MODESET)) + return; + + mutex_lock(&dev->clientlist_mutex); + list_for_each_entry(client, &dev->clientlist, list) { + if (!client->funcs->lastclose) + continue; + + ret = client->funcs->lastclose(client); + DRM_DEV_DEBUG_KMS(dev->dev, "%s: ret=%d\n", client->funcs->name, ret); + } + mutex_unlock(&dev->clientlist_mutex); +} + /** * drm_client_display_create() - Create display structure * @dev: DRM device @@ -348,6 +616,90 @@ int drm_client_display_restore(struct drm_client_display *display, bool force) } EXPORT_SYMBOL(drm_client_display_restore);

+/** + * drm_client_display_commit_mode - Commit a mode/fb to the CRTC(s) + * @display: Client display + * @fb: Framebuffer (if NULL the current fb is used) + * @mode: Display mode (if NULL the current mode is used) + * + * Returns: + * Zero on success, negative error code on failure. + */ +int drm_client_display_commit(struct drm_client_display *display, + struct drm_framebuffer *fb, struct drm_display_mode *mode) +{ + struct drm_display_mode *use_mode = NULL; + struct drm_mode_set *modeset; + unsigned int count = 0; + + if (mode) { + struct drm_display_mode *iter; + + drm_client_display_for_each_mode(iter, display) { + if (!use_mode && drm_mode_equal(iter, mode)) + use_mode = iter; + count++; + } + + if (!use_mode) + return -EINVAL; + + /* + * Don't actually set the mode in the single mode case since it + * might be a tiled display which consists of multiple modes. + * Just keep the current mode. + */ + if (count == 1) + use_mode = NULL; + } + + count = 0; + drm_client_display_for_each_modeset(modeset, display) { + if (!modeset->num_connectors) + continue; + + if (fb) + modeset->fb = fb; + + if (use_mode) { + if (WARN_ON(++count > 1)) + return -EINVAL; + + if (modeset->mode) + drm_mode_destroy(display->dev, modeset->mode); + modeset->mode = drm_mode_duplicate(display->dev, use_mode); + if (!modeset->mode) + return -ENOMEM; + } + } + + return drm_client_display_restore(display, false); +} +EXPORT_SYMBOL(drm_client_display_commit); + +struct drm_framebuffer *drm_client_display_current_fb(struct drm_client_display *display) +{ + struct drm_mode_set *modeset; + + drm_client_display_for_each_modeset(modeset, display) { + struct drm_crtc *crtc = modeset->crtc; + struct drm_framebuffer *fb = NULL; + + drm_modeset_lock(&crtc->primary->mutex, NULL); + if (crtc->primary->state && crtc->primary->state->fb) + fb = crtc->primary->state->fb; + else if (!crtc->primary->state && crtc->primary->fb) + fb = crtc->primary->fb; + drm_modeset_unlock(&crtc->primary->mutex); + + if (fb) + return fb; + } + + return NULL; +} +EXPORT_SYMBOL(drm_client_display_current_fb); + static void drm_client_display_dpms_legacy(struct drm_client_display *display, int dpms_mode) { struct drm_device *dev = display->dev; @@ -869,3 +1221,224 @@ drm_client_find_display(struct drm_device *dev, unsigned int width, unsigned int return display; } EXPORT_SYMBOL(drm_client_find_display); + +static void drm_client_buffer_delete(struct drm_client_buffer *buffer) +{ + if (!buffer) + return; + + if (buffer->vaddr) + dma_buf_vunmap(buffer->dma_buf, buffer->vaddr); + + if (buffer->dma_buf) + dma_buf_put(buffer->dma_buf); + + drm_mode_destroy_dumb(buffer->client->dev, buffer->handle, buffer->client->file); + kfree(buffer); +} + +/* For testing __close_fd() */ +#include <linux/fdtable.h> + +static struct drm_client_buffer * +drm_client_buffer_create(struct drm_client_dev *client, u32 width, u32 height, u32 format) +{ + struct drm_mode_create_dumb dumb_args = { }; + struct drm_prime_handle prime_args = { }; + struct drm_client_buffer *buffer; + struct dma_buf *dma_buf; + void *vaddr; + int ret; + + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); + if (!buffer) + return ERR_PTR(-ENOMEM); + + buffer->client = client; + buffer->width = width; + buffer->height = height; + buffer->format = format; + + dumb_args.width = buffer->width; + dumb_args.height = buffer->height; + dumb_args.bpp = drm_format_plane_cpp(format, 0) * 8; + ret = drm_mode_create_dumb(client->dev, &dumb_args, client->file); + if (ret) + goto err_free; + + buffer->handle = dumb_args.handle; + buffer->pitch = dumb_args.pitch; + buffer->size = dumb_args.size; + + prime_args.handle = dumb_args.handle; + ret = drm_prime_handle_to_fd(client->dev, &prime_args, client->file); + if (ret) + goto err_delete; + + dma_buf = dma_buf_get(prime_args.fd); + if (IS_ERR(dma_buf)) { + ret = PTR_ERR(dma_buf); + goto err_delete; + } + + /* + * If called from a worker the dmabuf fd isn't closed and the ref + * doesn't drop to zero on free. + * If I use __close_fd() it's all fine, but that function is not exported. + * + * How do I get rid of this fd when in a worker/kernel thread? + * The fd isn't used beyond this function. + */ +// WARN_ON(__close_fd(current->files, prime_args.fd)); + + pr_info("%s: PF_KTHREAD=%u\n", __func__, !!(current->flags & PF_KTHREAD)); + + buffer->dma_buf = dma_buf; + + vaddr = dma_buf_vmap(dma_buf); + if (!vaddr) { + ret = -ENOMEM; + goto err_delete; + } + + buffer->vaddr = vaddr; + + return buffer; + +err_delete: + drm_client_buffer_delete(buffer); +err_free: + kfree(buffer); + + return ERR_PTR(ret); +} + +static int drm_client_buffer_rmfb(struct drm_client_buffer *buffer) +{ + int ret; + + if (!buffer || !buffer->fb) + return 0; + + ret = drm_mode_rmfb(buffer->client->dev, buffer->fb->base.id, buffer->client->file); + if (ret) + DRM_DEV_ERROR(buffer->client->dev->dev, + "Error removing FB:%u (%d)\n", buffer->fb->base.id, ret); + + buffer->fb = NULL; + + return 0; +} + +static int drm_client_buffer_addfb(struct drm_client_buffer *buffer, + struct drm_display_mode *mode) +{ + struct drm_client_dev *client = buffer->client; + struct drm_mode_fb_cmd2 fb_req = { }; + int ret; + + if (mode->hdisplay > buffer->width || mode->vdisplay > buffer->height) + return -EINVAL; + + fb_req.width = mode->hdisplay; + fb_req.height = mode->vdisplay; + fb_req.pixel_format = buffer->format; + fb_req.handles[0] = buffer->handle; + fb_req.pitches[0] = buffer->pitch; + + ret = drm_mode_addfb2(client->dev, &fb_req, client->file, client->funcs->name); + if (ret) + return ret; + + buffer->fb = drm_framebuffer_lookup(client->dev, buffer->client->file, fb_req.fb_id); + if (WARN_ON(!buffer->fb)) + return -ENOENT; + + /* drop the reference we picked up in framebuffer lookup */ + drm_framebuffer_put(buffer->fb); + + return 0; +} + +/** + * drm_client_framebuffer_create - Create a client framebuffer + * @client: DRM client + * @mode: Display mode to create a buffer for + * @format: Buffer format + * + * This function creates a &drm_client_buffer which consists of a + * &drm_framebuffer backed by a dumb buffer. The dumb buffer is &dma_buf + * exported to aquire a virtual address which is stored in + * &drm_client_buffer->vaddr. + * Call drm_client_framebuffer_delete() to free the buffer. + * + * Returns: + * Pointer to a client buffer or an error pointer on failure. + */ +struct drm_client_buffer * +drm_client_framebuffer_create(struct drm_client_dev *client, + struct drm_display_mode *mode, u32 format) +{ + struct drm_client_buffer *buffer; + int ret; + + buffer = drm_client_buffer_create(client, mode->hdisplay, + mode->vdisplay, format); + if (IS_ERR(buffer)) + return buffer; + + ret = drm_client_buffer_addfb(buffer, mode); + if (ret) { + drm_client_buffer_delete(buffer); + return ERR_PTR(ret); + } + + return buffer; +} +EXPORT_SYMBOL(drm_client_framebuffer_create); + +void drm_client_framebuffer_delete(struct drm_client_buffer *buffer) +{ + drm_client_buffer_rmfb(buffer); + drm_client_buffer_delete(buffer); +} +EXPORT_SYMBOL(drm_client_framebuffer_delete); + +int drm_client_framebuffer_flush(struct drm_client_buffer *buffer, + struct drm_clip_rect *rect) +{ + if (!buffer->fb || !buffer->fb->funcs->dirty) + return 0; + + return buffer->fb->funcs->dirty(buffer->fb, buffer->client->file, + 0, 0, rect, rect ? 1 : 0); +} +EXPORT_SYMBOL(drm_client_framebuffer_flush); + +#ifdef CONFIG_DEBUG_FS +static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data) +{ + struct drm_info_node *node = m->private; + struct drm_device *dev = node->minor->dev; + struct drm_printer p = drm_seq_file_printer(m); + struct drm_client_dev *client; + + mutex_lock(&dev->clientlist_mutex); + list_for_each_entry(client, &dev->clientlist, list) + drm_printf(&p, "%s\n", client->funcs->name); + mutex_unlock(&dev->clientlist_mutex); + + return 0; +} + +static const struct drm_info_list drm_client_debugfs_list[] = { + { "internal_clients", drm_client_debugfs_internal_clients, 0 }, +}; + +int drm_client_debugfs_init(struct drm_minor *minor) +{ + return drm_debugfs_create_files(drm_client_debugfs_list, + ARRAY_SIZE(drm_client_debugfs_list), + minor->debugfs_root, minor); +} +#endif diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c index b2482818fee8..50a20bfc07ea 100644 --- a/drivers/gpu/drm/drm_debugfs.c +++ b/drivers/gpu/drm/drm_debugfs.c @@ -28,6 +28,7 @@ #include <linux/slab.h> #include <linux/export.h>

+#include <drm/drm_client.h> #include <drm/drm_debugfs.h> #include <drm/drm_edid.h> #include <drm/drm_atomic.h> @@ -164,6 +165,12 @@ int drm_debugfs_init(struct drm_minor *minor, int minor_id, DRM_ERROR("Failed to create framebuffer debugfs file\n"); return ret; } + + ret = drm_client_debugfs_init(minor); + if (ret) { + DRM_ERROR("Failed to create client debugfs file\n"); + return ret; + } }

if (dev->driver->debugfs_init) { diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c index 32a83b41ab61..6f21bafb29be 100644 --- a/drivers/gpu/drm/drm_drv.c +++ b/drivers/gpu/drm/drm_drv.c @@ -34,6 +34,7 @@ #include <linux/slab.h> #include <linux/srcu.h>

+#include <drm/drm_client.h> #include <drm/drm_drv.h> #include <drm/drmP.h>

@@ -507,6 +508,8 @@ int drm_dev_init(struct drm_device *dev, dev->driver = driver;

INIT_LIST_HEAD(&dev->filelist); + INIT_LIST_HEAD(&dev->filelist_internal); + INIT_LIST_HEAD(&dev->clientlist); INIT_LIST_HEAD(&dev->ctxlist); INIT_LIST_HEAD(&dev->vmalist); INIT_LIST_HEAD(&dev->maplist); @@ -516,6 +519,7 @@ int drm_dev_init(struct drm_device *dev, spin_lock_init(&dev->event_lock); mutex_init(&dev->struct_mutex); mutex_init(&dev->filelist_mutex); + mutex_init(&dev->clientlist_mutex); mutex_init(&dev->ctxlist_mutex); mutex_init(&dev->master_mutex);

@@ -572,6 +576,7 @@ int drm_dev_init(struct drm_device *dev, err_free: mutex_destroy(&dev->master_mutex); mutex_destroy(&dev->ctxlist_mutex); + mutex_destroy(&dev->clientlist_mutex); mutex_destroy(&dev->filelist_mutex); mutex_destroy(&dev->struct_mutex); return ret; @@ -607,6 +612,7 @@ void drm_dev_fini(struct drm_device *dev)

mutex_destroy(&dev->master_mutex); mutex_destroy(&dev->ctxlist_mutex); + mutex_destroy(&dev->clientlist_mutex); mutex_destroy(&dev->filelist_mutex); mutex_destroy(&dev->struct_mutex); kfree(dev->unique); @@ -862,6 +868,8 @@ void drm_dev_unregister(struct drm_device *dev) { struct drm_map_list *r_list, *list_temp;

+ drm_client_dev_unregister(dev); + if (drm_core_check_feature(dev, DRIVER_LEGACY)) drm_lastclose(dev);

@@ -968,6 +976,7 @@ static const struct file_operations drm_stub_fops = {

static void drm_core_exit(void) { + drm_client_exit(); unregister_chrdev(DRM_MAJOR, "drm"); debugfs_remove(drm_debugfs_root); drm_sysfs_destroy(); @@ -1001,6 +1010,8 @@ static int __init drm_core_init(void) if (ret < 0) goto error;

+ drm_client_init(); + drm_core_init_complete = true;

DRM_DEBUG("Initialized\n"); diff --git a/drivers/gpu/drm/drm_file.c b/drivers/gpu/drm/drm_file.c index 55505378df47..bcc688e58776 100644 --- a/drivers/gpu/drm/drm_file.c +++ b/drivers/gpu/drm/drm_file.c @@ -35,6 +35,7 @@ #include <linux/slab.h> #include <linux/module.h>

+#include <drm/drm_client.h> #include <drm/drm_file.h> #include <drm/drmP.h>

@@ -443,6 +444,8 @@ void drm_lastclose(struct drm_device * dev)

if (drm_core_check_feature(dev, DRIVER_LEGACY)) drm_legacy_dev_reinit(dev); + + drm_client_dev_lastclose(dev); }

/** diff --git a/drivers/gpu/drm/drm_probe_helper.c b/drivers/gpu/drm/drm_probe_helper.c index 527743394150..26be57e28a9d 100644 --- a/drivers/gpu/drm/drm_probe_helper.c +++ b/drivers/gpu/drm/drm_probe_helper.c @@ -33,6 +33,7 @@ #include <linux/moduleparam.h>

#include <drm/drmP.h> +#include <drm/drm_client.h> #include <drm/drm_crtc.h> #include <drm/drm_fourcc.h> #include <drm/drm_crtc_helper.h> @@ -563,6 +564,8 @@ void drm_kms_helper_hotplug_event(struct drm_device *dev) drm_sysfs_hotplug_event(dev); if (dev->mode_config.funcs->output_poll_changed) dev->mode_config.funcs->output_poll_changed(dev); + + drm_client_dev_hotplug(dev); } EXPORT_SYMBOL(drm_kms_helper_hotplug_event);

diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c index 1c5b5ce1fd7f..1fc066c41861 100644 --- a/drivers/gpu/drm/drm_sysfs.c +++ b/drivers/gpu/drm/drm_sysfs.c @@ -18,6 +18,7 @@ #include <linux/err.h> #include <linux/export.h>

+#include <drm/drm_client.h> #include <drm/drm_sysfs.h> #include <drm/drmP.h> #include "drm_internal.h" @@ -320,6 +321,24 @@ void drm_sysfs_hotplug_event(struct drm_device *dev) } EXPORT_SYMBOL(drm_sysfs_hotplug_event);

+static ssize_t remove_internal_clients_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + struct drm_minor *minor = dev_get_drvdata(dev); + + drm_client_dev_unregister(minor->dev); + + return len; +} +static DEVICE_ATTR_WO(remove_internal_clients); + +static struct attribute *minor_attrs[] = { + &dev_attr_remove_internal_clients.attr, + NULL, +}; +ATTRIBUTE_GROUPS(minor); + static void drm_sysfs_release(struct device *dev) { kfree(dev); @@ -347,6 +366,7 @@ struct device *drm_sysfs_minor_alloc(struct drm_minor *minor) kdev->class = drm_class; kdev->type = &drm_sysfs_device_minor; kdev->parent = minor->dev->dev; + kdev->groups = minor_groups; kdev->release = drm_sysfs_release; dev_set_drvdata(kdev, minor);

diff --git a/include/drm/drm_client.h b/include/drm/drm_client.h index 524f793d6e7b..6fd2fcaae826 100644 --- a/include/drm/drm_client.h +++ b/include/drm/drm_client.h @@ -5,13 +5,91 @@

#include <linux/types.h>

+struct drm_clip_rect; struct drm_connector; struct drm_crtc; struct drm_device; struct drm_display_mode; +struct drm_framebuffer; +struct drm_minor; struct drm_mode_set; struct drm_plane;

+struct drm_client_dev; + +/** + * struct drm_client_funcs - DRM client callbacks + */ +struct drm_client_funcs { + /** + * @name: + * + * Name of the client. Mandatory. + */ + const char *name; + + /** + * @remove: + * + * Called when a &drm_device is unregistered or the client is + * unregistered. If zero is returned drm_client_free() is called + * automatically. If the client can't drop it's resources it should + * return non-zero and call drm_client_free() later. + * + * This callback is optional. + */ + int (*remove)(struct drm_client_dev *client); + + /** + * @lastclose: + * + * Called on drm_lastclose(). The first client instance in the list + * that returns zero gets the privilege to restore and no more clients + * are called. + * + * This callback is optional. + */ + int (*lastclose)(struct drm_client_dev *client); + + /** + * @hotplug: + * + * Called on drm_kms_helper_hotplug_event(). + * + * This callback is optional. + */ + int (*hotplug)(struct drm_client_dev *client); +}; + +/** + * struct drm_client_dev - DRM client instance + */ +struct drm_client_dev { + struct list_head list; + struct drm_device *dev; + const struct drm_client_funcs *funcs; + struct drm_file *file; + unsigned int file_ref_count; + void *private; +}; + +struct drm_client_dev * +drm_client_new(struct drm_device *dev, const struct drm_client_funcs *funcs); +struct drm_client_dev * +drm_client_new_from_id(unsigned int dev_id, const struct drm_client_funcs *funcs); +void drm_client_remove(struct drm_client_dev *client); +int drm_client_remove_defer(struct drm_client_dev *client); +void drm_client_free(struct drm_client_dev *client); + +void drm_client_dev_unregister(struct drm_device *dev); +void drm_client_dev_hotplug(struct drm_device *dev); +void drm_client_dev_lastclose(struct drm_device *dev); + +void drm_client_init(void); +void drm_client_exit(void); + +int drm_client_debugfs_init(struct drm_minor *minor); + /** * struct drm_client_display - DRM client display */ @@ -76,4 +154,29 @@ drm_client_find_display(struct drm_device *dev, unsigned int width, unsigned int #define drm_client_display_for_each_mode(mode, display) \ list_for_each_entry(mode, &display->modes, head)

+int drm_client_display_commit(struct drm_client_display *display, + struct drm_framebuffer *fb, struct drm_display_mode *mode); +struct drm_framebuffer *drm_client_display_current_fb(struct drm_client_display *display); + +struct drm_client_buffer { + struct drm_client_dev *client; + u32 width; + u32 height; + u32 format; + u32 handle; + u32 pitch; + u64 size; + struct dma_buf *dma_buf; + void *vaddr; + struct drm_framebuffer *fb; +}; + +struct drm_client_buffer * +drm_client_framebuffer_create(struct drm_client_dev *client, + struct drm_display_mode *mode, u32 format); +void drm_client_framebuffer_delete(struct drm_client_buffer *buffer); + +int drm_client_framebuffer_flush(struct drm_client_buffer *buffer, + struct drm_clip_rect *rect); + #endif diff --git a/include/drm/drm_device.h b/include/drm/drm_device.h index 3a0eac2885b7..17edadf8b691 100644 --- a/include/drm/drm_device.h +++ b/include/drm/drm_device.h @@ -74,6 +74,10 @@ struct drm_device {

struct mutex filelist_mutex; struct list_head filelist; + struct list_head filelist_internal; + + struct mutex clientlist_mutex; + struct list_head clientlist;

/** \name Memory management */ /*@{ */

Avoid pinning the module when exporting a GEM object as a dmabuf. This makes it possible to unload drivers that has in-kernel clients using it. The client is removed on drm_dev_unregister() so no need to pin the driver.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/drm_prime.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)

diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c index e6052ab2bec4..f9dbe3b9db20 100644 --- a/drivers/gpu/drm/drm_prime.c +++ b/drivers/gpu/drm/drm_prime.c @@ -567,6 +567,30 @@ struct dma_buf *drm_gem_prime_export(struct drm_device *dev, .flags = flags, .priv = obj, }; + bool is_internal = false; + struct drm_file *file; + + mutex_lock(&dev->filelist_mutex); + list_for_each_entry(file, &dev->filelist_internal, lhead) { + struct drm_gem_object *iter; + int id; + + spin_lock(&file->table_lock); + idr_for_each_entry(&file->object_idr, iter, id) { + if (iter == obj) { + is_internal = true; + break; + } + } + spin_unlock(&file->table_lock); + + if (is_internal) + break; + } + mutex_unlock(&dev->filelist_mutex); + + if (is_internal) + exp_info.owner = NULL;

if (dev->driver->gem_prime_res_obj) exp_info.resv = dev->driver->gem_prime_res_obj(obj);

A hack to test the client API.

Signed-off-by: Noralf Trønnes noralf@tronnes.org --- drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/client/Kconfig | 5 + drivers/gpu/drm/client/Makefile | 3 + drivers/gpu/drm/client/drm_vtcon.c | 785 +++++++++++++++++++++++++++++++++++++ 4 files changed, 794 insertions(+) create mode 100644 drivers/gpu/drm/client/Makefile create mode 100644 drivers/gpu/drm/client/drm_vtcon.c

diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 388527093f80..ea63eb9e93ec 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -47,6 +47,7 @@ obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o obj-$(CONFIG_DRM_DEBUG_MM_SELFTEST) += selftests/

obj-$(CONFIG_DRM) += drm.o +obj-y += client/ obj-$(CONFIG_DRM_MIPI_DSI) += drm_mipi_dsi.o obj-$(CONFIG_DRM_PANEL_ORIENTATION_QUIRKS) += drm_panel_orientation_quirks.o obj-$(CONFIG_DRM_ARM) += arm/ diff --git a/drivers/gpu/drm/client/Kconfig b/drivers/gpu/drm/client/Kconfig index 6b01f2e51fb3..b03f3baf8b3f 100644 --- a/drivers/gpu/drm/client/Kconfig +++ b/drivers/gpu/drm/client/Kconfig @@ -6,4 +6,9 @@ config DRM_CLIENT_BOOTSPLASH help DRM Bootsplash

+config DRM_CLIENT_VTCON + tristate "DRM VT console" + help + DRM VT console + endmenu diff --git a/drivers/gpu/drm/client/Makefile b/drivers/gpu/drm/client/Makefile new file mode 100644 index 000000000000..7d39f1bc2b68 --- /dev/null +++ b/drivers/gpu/drm/client/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_DRM_CLIENT_VTCON) += drm_vtcon.o diff --git a/drivers/gpu/drm/client/drm_vtcon.c b/drivers/gpu/drm/client/drm_vtcon.c new file mode 100644 index 000000000000..910b4ec1a686 --- /dev/null +++ b/drivers/gpu/drm/client/drm_vtcon.c @@ -0,0 +1,785 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright 2018 Noralf Trønnes + +#include <linux/console.h> +#include <linux/font.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/slab.h> +#include <linux/vt_buffer.h> +#include <linux/vt_kern.h> +#include <linux/workqueue.h> + +#include <drm/drm_client.h> +#include <drm/drm_drv.h> +#include <drm/drm_fourcc.h> +#include <drm/drm_modes.h> +#include <drm/drm_print.h> + +/* TODO: Scrolling */ + +/* + * The code consists of 3 parts: + * + * 1. The DRM client + * Gets a display, uses the first mode to find a font, + * sets the max cols/rows and a matching text buffer. + * + * 2. The VT console + * Writes to the text buffer which consists of CGA colored characters. + * Schedules the worker when it needs rendering or blanking. + * + * 3. Worker + * Does modesetting, blanking and rendering. + * It takes a snapshot of the VT text buffer and renders the changes since + * last. + */ + +struct drm_vtcon_vc { + struct mutex lock; + + u16 *text_buf; + size_t buf_len; + + unsigned int rows; + unsigned int cols; + unsigned int max_rows; + unsigned int max_cols; + const struct font_desc *font; + bool blank; + unsigned long cursor_blink_jiffies; +}; + +static struct drm_vtcon_vc *drm_vtcon_vc; + +struct drm_vtcon { + struct drm_client_dev *client; + struct drm_client_display *display; + struct drm_client_buffer *buffer; + + unsigned int rows; + unsigned int cols; + + u16 *text_buf[2]; + size_t buf_len; + unsigned int buf_idx; + bool blank; +}; + +static struct drm_vtcon *vtcon_instance; + +static int drm_vtcon_dev_id; +module_param_named(dev, drm_vtcon_dev_id, int, 0600); +MODULE_PARM_DESC(drm_vtcon_dev_id, "DRM device id [default=0]"); + +#define drm_vtcon_debug(vc, fmt, ...) \ + pr_debug("%s[%u]: " fmt, __func__, vc->vc_num, ##__VA_ARGS__) + +/* CGA color palette: 4-bit RGBI: intense red green blue */ +static const u32 drm_vtcon_paletteX888[16] = { + 0x00000000, /* 0 black */ + 0x000000aa, /* 1 blue */ + 0x0000aa00, /* 2 green */ + 0x0000aaaa, /* 3 cyan */ + 0x00aa0000, /* 4 red */ + 0x00aa00aa, /* 5 magenta */ + 0x00aa5500, /* 6 brown */ + 0x00aaaaaa, /* 7 light gray */ + 0x00555555, /* 8 dark gray */ + 0x005555ff, /* 9 bright blue */ + 0x0055ff55, /* 10 bright green */ + 0x0055ffff, /* 11 bright cyan */ + 0x00ff5555, /* 12 bright red */ + 0x00ff55ff, /* 13 bright magenta */ + 0x00ffff55, /* 14 yellow */ + 0x00ffffff /* 15 white */ +}; + +static void +drm_vtcon_render_char(struct drm_vtcon *vtcon, unsigned int x, unsigned int y, + u16 cc, const struct font_desc *font) +{ + struct drm_client_buffer *buffer = vtcon->buffer; + unsigned int h, w; + const u8 *src; + void *dst; + u32 *pix; + u32 fg_col = drm_vtcon_paletteX888[(cc & 0x0f00) >> 8]; + u32 bg_col = drm_vtcon_paletteX888[cc >> 12]; + + src = font->data + (cc & 0xff) * font->height; + dst = vtcon->buffer->vaddr + y * buffer->pitch + x * sizeof(u32); + + for (h = 0; h < font->height; h++) { + u8 fontline = *(src + h); + + pix = dst; + for (w = 0; w < font->width; w++) + pix[w] = fontline & BIT(7 - w) ? fg_col : bg_col; + dst += buffer->pitch; + } +} + +static int drm_vtcon_modeset(struct drm_vtcon *vtcon, unsigned int cols, + unsigned int rows, const struct font_desc *font) +{ + struct drm_client_display *display = vtcon->display; + struct drm_client_dev *client = vtcon->client; + struct drm_display_mode *mode, *best_mode = NULL; + unsigned int best_cols = ~0, best_rows = ~0; + struct drm_client_buffer *buffer; + int ret; + + DRM_DEV_INFO(client->dev->dev, "IN %ux%u\n", cols, rows); + + /* Find the smallest mode that fits */ + drm_client_display_for_each_mode(mode, display) { + unsigned int mode_cols = mode->hdisplay / font->width; + unsigned int mode_rows = mode->vdisplay / font->height; + + DRM_DEV_INFO(client->dev->dev, + "try: %ux%u\n", mode_cols, mode_rows); + + if (mode_cols < cols || mode_rows < rows) + break; + + if (mode_cols >= best_cols || mode_rows >= best_rows) + continue; + + best_cols = mode_cols; + best_rows = mode_rows; + best_mode = mode; + } + + if (!best_mode) { + DRM_DEV_INFO(client->dev->dev, "Couldn't find mode for %ux%u\n", cols, rows); + return -EINVAL; + } + + DRM_DEV_INFO(client->dev->dev, "Chosen: %ux%u\n", best_cols, best_rows); + + buffer = drm_client_framebuffer_create(client, best_mode, DRM_FORMAT_XRGB8888); + if (IS_ERR(buffer)) { + ret = PTR_ERR(buffer); + DRM_DEV_ERROR(client->dev->dev, + "Failed to create framebuffer: %d\n", ret); + return ret; + } + + ret = drm_client_display_commit(display, buffer->fb, best_mode); + if (ret) { + DRM_DEV_ERROR(client->dev->dev, + "Failed to commit mode: %d\n", ret); + goto err_free_buffer; + } + + drm_client_framebuffer_delete(vtcon->buffer); + + vtcon->buffer = buffer; + vtcon->cols = cols; + vtcon->rows = rows; + + DRM_DEV_INFO(client->dev->dev, "OUT\n"); + + return 0; + +err_free_buffer: + drm_client_framebuffer_delete(buffer); + + DRM_DEV_INFO(client->dev->dev, "OUT ret=%d\n", ret); + + return ret; +} + +static void drm_vtcon_blank(struct drm_vtcon *vtcon, bool blank) +{ + int mode = blank ? DRM_MODE_DPMS_OFF : DRM_MODE_DPMS_ON; + + drm_client_display_dpms(vtcon->display, mode); + vtcon->blank = blank; +} + +static int drm_vtcon_resize_buf(struct drm_vtcon *vtcon, size_t len) +{ + u16 *text_buf[2]; + + text_buf[0] = kzalloc(len, GFP_KERNEL); + text_buf[1] = kzalloc(len, GFP_KERNEL); + if (!text_buf[0] || !text_buf[1]) { + kfree(text_buf[0]); + kfree(text_buf[1]); + return -ENOMEM; + } + + kfree(vtcon->text_buf[0]); + kfree(vtcon->text_buf[1]); + + vtcon->text_buf[0] = text_buf[0]; + vtcon->text_buf[1] = text_buf[1]; + vtcon->buf_len = len; + + return 0; +} + +static void drm_vtcon_work_fn(struct work_struct *work) +{ + struct drm_vtcon *vtcon = vtcon_instance; + unsigned int vc_cols, vc_rows, col, row, x, y; + const struct font_desc *font; + u16 prev, curr; + bool blank, render_all = false; + struct drm_clip_rect clip = { + .x1 = ~0, + .y1 = ~0, + .x2 = 0, + .y2 = 0, + }; + char *str; + int ret; + + if (!vtcon->display) + return; + + mutex_lock(&drm_vtcon_vc->lock); + + vc_cols = drm_vtcon_vc->cols; + vc_rows = drm_vtcon_vc->rows; + font = drm_vtcon_vc->font; + blank = drm_vtcon_vc->blank; + + if (vtcon->buf_len != drm_vtcon_vc->buf_len) { + ret = drm_vtcon_resize_buf(vtcon, drm_vtcon_vc->buf_len); + if (ret) { + mutex_unlock(&drm_vtcon_vc->lock); + return; + } + render_all = true; + } + + vtcon->buf_idx = !vtcon->buf_idx; + memcpy(vtcon->text_buf[vtcon->buf_idx], drm_vtcon_vc->text_buf, + vc_cols * vc_rows * sizeof(u16)); + + mutex_unlock(&drm_vtcon_vc->lock); + + if (vtcon->cols != vc_cols || vtcon->rows != vc_rows) { + ret = drm_vtcon_modeset(vtcon, vc_cols, vc_rows, font); + if (ret) + return; + render_all = true; + } else if (vtcon->blank != blank) { + drm_vtcon_blank(vtcon, blank); + } + + str = kmalloc(vc_cols + 1, GFP_KERNEL); + if (!str) + return; + + for (row = 0; row < vc_rows; row++) { + for (col = 0; col < vc_cols; col++) { + prev = vtcon->text_buf[!vtcon->buf_idx][col + (row * vc_cols)]; + curr = vtcon->text_buf[vtcon->buf_idx][col + (row * vc_cols)]; + + if (render_all || prev != curr) { + str[col] = curr; + x = col * font->width; + y = row * font->height; + + clip.x1 = min_t(u32, clip.x1, x); + clip.y1 = min_t(u32, clip.y1, y); + clip.x2 = max_t(u32, clip.x2, x + font->width); + clip.y2 = max_t(u32, clip.y2, y + font->height); + + drm_vtcon_render_char(vtcon, x, y, curr, font); + } else { + str[col] = ' '; + } + } + str[vc_cols] = '\0'; +// pr_info("%02u|%s\n", row, str); + } + + kfree(str); + + if (clip.x1 < clip.x2) + drm_client_framebuffer_flush(vtcon->buffer, &clip); +} + +static DECLARE_WORK(drm_vtcon_work, drm_vtcon_work_fn); + +static const char *drm_vtcon_con_startup(void) +{ + return "drm-vt"; +} + +static void drm_vtcon_con_init(struct vc_data *vc, int init) +{ + drm_vtcon_debug(vc, "(init=%d) drm_vtcon_vc=%p\n", init, drm_vtcon_vc); + + vc->vc_can_do_color = 1; + + if (init) { + vc->vc_cols = drm_vtcon_vc->cols; + vc->vc_rows = drm_vtcon_vc->rows; + } else { + vc_resize(vc, drm_vtcon_vc->cols, drm_vtcon_vc->rows); + } +} + +static void drm_vtcon_con_deinit(struct vc_data *vc) +{ + drm_vtcon_debug(vc, "\n"); +} + +static void drm_vtcon_con_putcs(struct vc_data *vc, const unsigned short *s, + int count, int y, int x) +{ + u16 *dest; + + dest = &drm_vtcon_vc->text_buf[x + (y * drm_vtcon_vc->cols)]; + + for (; count > 0; count--) + scr_writew(scr_readw(s++), dest++); + + schedule_work(&drm_vtcon_work); +} + +static void drm_vtcon_con_putc(struct vc_data *vc, int ch, int y, int x) +{ + unsigned short chr; + + scr_writew(ch, &chr); + drm_vtcon_con_putcs(vc, &chr, 1, y, x); +} + +/* TODO: How do I actually test this? */ +static void drm_vtcon_con_clear(struct vc_data *vc, int y, int x, + int height, int width) +{ + drm_vtcon_debug(vc, "\n"); + + scr_memcpyw(drm_vtcon_vc->text_buf, (unsigned short *)vc->vc_pos, + vc->vc_cols * vc->vc_rows); + schedule_work(&drm_vtcon_work); +} + +static int drm_vtcon_con_switch(struct vc_data *vc) +{ + drm_vtcon_debug(vc, "%ux%u\n", vc->vc_cols, vc->vc_rows); + + mutex_lock(&drm_vtcon_vc->lock); + drm_vtcon_vc->cols = vc->vc_cols; + drm_vtcon_vc->rows = vc->vc_rows; + mutex_unlock(&drm_vtcon_vc->lock); + + return 1; /* redraw */ +} + +static int drm_vtcon_con_resize(struct vc_data *vc, unsigned int width, + unsigned int height, unsigned int user) +{ + int ret = 0; + + drm_vtcon_debug(vc, "width=%u, height=%u, user=%u\n", width, height, user); + + mutex_lock(&drm_vtcon_vc->lock); + + if (width > drm_vtcon_vc->max_cols || height > drm_vtcon_vc->max_rows) + ret = -EINVAL; + + mutex_unlock(&drm_vtcon_vc->lock); + + drm_vtcon_debug(vc, "ret=%d\n", ret); + + return ret; +} + +static void drm_vtcon_con_set_palette(struct vc_data *vc, + const unsigned char *table) +{ + drm_vtcon_debug(vc, "\n"); +} + +static int drm_vtcon_con_blank(struct vc_data *vc, int blank, int mode_switch) +{ + drm_vtcon_debug(vc, "(blank=%d, mode_switch=%d)\n", blank, mode_switch); + + mutex_lock(&drm_vtcon_vc->lock); + drm_vtcon_vc->blank = blank; + mutex_unlock(&drm_vtcon_vc->lock); + + schedule_work(&drm_vtcon_work); + + return 0; +} + +static void drm_vtcon_con_scrolldelta(struct vc_data *vc, int lines) +{ + drm_vtcon_debug(vc, "(lines=%d)\n", lines); +} + +static void drm_vtcon_con_cursor_draw(bool show) +{ + static unsigned short set_chr, saved_chr; + static int prev_x, prev_y; + struct vc_data *vc = vc_cons[fg_console].d; + unsigned short *pos; + + if (saved_chr) { + pos = &drm_vtcon_vc->text_buf[prev_x + (prev_y * drm_vtcon_vc->cols)]; + if (*pos == set_chr) + *pos = saved_chr; + saved_chr = 0; + } + + if (show) { + pos = &drm_vtcon_vc->text_buf[vc->vc_x + (vc->vc_y * drm_vtcon_vc->cols)]; + *pos = scr_readw((u16 *)vc->vc_pos); + saved_chr = *pos; + set_chr = *pos & 0xff00; + set_chr |= '_'; + *pos = set_chr; + prev_x = vc->vc_x; + prev_y = vc->vc_y; + } + + schedule_work(&drm_vtcon_work); +} + +static void drm_vtcon_con_cursor_timer_handler(struct timer_list *t) +{ + static bool show; + + show = !show; + drm_vtcon_con_cursor_draw(show); + mod_timer(t, jiffies + drm_vtcon_vc->cursor_blink_jiffies); +} + +static DEFINE_TIMER(drm_vtcon_con_cursor_timer, drm_vtcon_con_cursor_timer_handler); + +static void drm_vtcon_con_cursor(struct vc_data *vc, int mode) +{ + //drm_vtcon_debug(vc, "(mode=%d)\n", mode); + + switch (mode) { + case CM_ERASE: + drm_vtcon_con_cursor_draw(false); + del_timer_sync(&drm_vtcon_con_cursor_timer); + break; + case CM_MOVE: + case CM_DRAW: + drm_vtcon_vc->cursor_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms); + mod_timer(&drm_vtcon_con_cursor_timer, + jiffies + drm_vtcon_vc->cursor_blink_jiffies); + break; + } +} + +static bool drm_vtcon_con_scroll(struct vc_data *vc, unsigned int top, + unsigned int bottom, enum con_scroll dir, + unsigned int lines) +{ + size_t count; + + switch (dir) { + case SM_UP: + count = vc->vc_cols * (vc->vc_rows - lines); + memmove(drm_vtcon_vc->text_buf, drm_vtcon_vc->text_buf + vc->vc_cols, count * sizeof(u16)); + memset(drm_vtcon_vc->text_buf + count, 0, vc->vc_cols * lines * sizeof(u16)); + break; + case SM_DOWN: + drm_vtcon_debug(vc, "TODO\n"); + break; + } + + return false; +} + +static const struct consw drm_vtcon_consw = { + /* owner is not set, it blocks module unload */ + .con_startup = drm_vtcon_con_startup, + .con_init = drm_vtcon_con_init, + .con_deinit = drm_vtcon_con_deinit, + .con_clear = drm_vtcon_con_clear, + .con_putc = drm_vtcon_con_putc, + .con_putcs = drm_vtcon_con_putcs, + .con_cursor = drm_vtcon_con_cursor, + .con_scroll = drm_vtcon_con_scroll, + .con_switch = drm_vtcon_con_switch, + .con_blank = drm_vtcon_con_blank, + .con_resize = drm_vtcon_con_resize, + .con_set_palette = drm_vtcon_con_set_palette, + .con_scrolldelta = drm_vtcon_con_scrolldelta, +}; + +static int drm_vtcon_vc_set_max(struct drm_display_mode *mode) +{ + u16 *new_buf = NULL, *old_buf = NULL; + const struct font_desc *font; + unsigned int cols, rows, i; + size_t buf_len; + + /* only 8 bit wide and 8 or 16-bit high */ + font = get_default_font(mode->hdisplay, mode->vdisplay, + BIT(8 - 1), BIT(8 - 1) | BIT(16 - 1)); + if (!font) + return -ENODEV; + + pr_info("%s: font: %s\n", __func__, font->name); + + cols = mode->hdisplay / font->width; + rows = mode->vdisplay / font->height; + + pr_info("%s: ASKED: cols=%u, rows=%u\n", __func__, cols, rows); + + if (drm_vtcon_vc->max_cols == cols && drm_vtcon_vc->max_rows == rows && + drm_vtcon_vc->font == font) + return 0; + + buf_len = cols * rows * sizeof(u16); + if (buf_len > drm_vtcon_vc->buf_len) { + new_buf = kzalloc(buf_len, GFP_KERNEL); + if (!new_buf) + return -ENOMEM; + } + + mutex_lock(&drm_vtcon_vc->lock); + + if (new_buf) { + DRM_INFO("Allocated new buf: buf_len=%zu\n", buf_len); + old_buf = drm_vtcon_vc->text_buf; + drm_vtcon_vc->text_buf = new_buf; + drm_vtcon_vc->buf_len = buf_len; + } + + drm_vtcon_vc->max_cols = cols; + drm_vtcon_vc->max_rows = rows; + drm_vtcon_vc->font = font; + + mutex_unlock(&drm_vtcon_vc->lock); + + pr_info("%s: max_cols=%u, max_rows=%u\n", __func__, drm_vtcon_vc->max_cols, + drm_vtcon_vc->max_rows); + + console_lock(); + for (i = 0; i < 2; i++) + vc_resize(vc_cons[i].d, drm_vtcon_vc->max_cols, + drm_vtcon_vc->max_rows); + console_unlock(); + + kfree(old_buf); + + return 0; +} + +static int drm_vtcon_setup_dev(struct drm_vtcon *vtcon) +{ + struct drm_client_dev *client = vtcon->client; + struct drm_client_display *display; + struct drm_display_mode *mode; + int ret; + + display = drm_client_find_display(client->dev, 0, 0); + if (IS_ERR(display)) + return PTR_ERR(display); + if (!display) + return -ENOENT; + + mode = display->mode; + if (!mode) { + ret = -EINVAL; + goto err_free_display; + } + + ret = drm_vtcon_vc_set_max(mode); + if (ret) + goto err_free_display; + + pr_info("%s: cols=%u, rows=%u\n", __func__, drm_vtcon_vc->cols, drm_vtcon_vc->rows); + + vtcon->display = display; + + schedule_work(&drm_vtcon_work); + + return 0; + +err_free_display: + drm_client_display_free(display); + + return ret; +} + +static int drm_vtcon_client_hotplug(struct drm_client_dev *client) +{ + struct drm_vtcon *vtcon = client->private; + int ret = 0; + + if (!vtcon->display) + ret = drm_vtcon_setup_dev(vtcon); + + return ret; +} + +static struct drm_client_dev *vtcon_client; +static DEFINE_MUTEX(vtcon_client_lock); + +static int drm_vtcon_client_remove(struct drm_client_dev *client) +{ + struct drm_vtcon *vtcon = client->private; + struct drm_client_display *display = vtcon->display; + + mutex_lock(&vtcon_client_lock); + + vtcon_client = NULL; + + if (!display) + goto out_unlock; + + vtcon->display = NULL; + flush_work(&drm_vtcon_work); + kfree(vtcon->text_buf[0]); + kfree(vtcon->text_buf[1]); + drm_client_framebuffer_delete(vtcon->buffer); + vtcon->buffer = NULL; + drm_client_display_free(display); + +out_unlock: + mutex_unlock(&vtcon_client_lock); + + return 0; +} + +static const struct drm_client_funcs drm_vtcon_client_funcs = { + .name = "vtcon", + .remove = drm_vtcon_client_remove, + .hotplug = drm_vtcon_client_hotplug, +}; + +static struct drm_client_dev *drm_vtcon_client_new(unsigned int dev_id) +{ + struct drm_vtcon *vtcon = vtcon_instance; + struct drm_client_dev *client; + + if (vtcon->client) + return ERR_PTR(-EBUSY); + + client = drm_client_new_from_id(dev_id, &drm_vtcon_client_funcs); + if (IS_ERR(client)) + return client; + + vtcon->client = client; + client->private = vtcon; + + /* + * vc4 isn't done with it's setup when drm_dev_register() is called. + * It should have shouldn't it? + * So to keep it from crashing defer setup to hotplug... + */ + if (client->dev->mode_config.max_width) + drm_vtcon_client_hotplug(client); + + return 0; +} + +static void drm_vtcon_teardown(void) +{ + struct drm_vtcon *vtcon = vtcon_instance; + + if (!drm_vtcon_vc) + return; + + kfree(drm_vtcon_vc->text_buf); + mutex_destroy(&drm_vtcon_vc->lock); + kfree(drm_vtcon_vc); + kfree(vtcon); +} + +static int __init drm_vtcon_setup(void) +{ + struct drm_vtcon *vtcon; + + drm_vtcon_vc = kzalloc(sizeof(*drm_vtcon_vc), GFP_KERNEL); + vtcon = kzalloc(sizeof(*vtcon), GFP_KERNEL); + if (!drm_vtcon_vc || !vtcon) + goto err_free; + + drm_vtcon_vc->max_cols = 80; + drm_vtcon_vc->max_rows = 25; + drm_vtcon_vc->cols = drm_vtcon_vc->max_cols; + drm_vtcon_vc->rows = drm_vtcon_vc->max_rows; + pr_info("%s: cols=%u, rows=%u\n", __func__, drm_vtcon_vc->cols, drm_vtcon_vc->rows); + + drm_vtcon_vc->buf_len = drm_vtcon_vc->max_cols * drm_vtcon_vc->max_rows * sizeof(u16); + drm_vtcon_vc->text_buf = kzalloc(drm_vtcon_vc->buf_len, GFP_KERNEL); + if (!drm_vtcon_vc->text_buf) + goto err_free; + + mutex_init(&drm_vtcon_vc->lock); + vtcon_instance = vtcon; + + return 0; + +err_free: + kfree(drm_vtcon_vc); + kfree(vtcon); + + return -ENOMEM; +} + +static int __init drm_vtcon_module_init(void) +{ + int ret; + + if (drm_vtcon_dev_id < 0) + return 0; + + ret = drm_vtcon_setup(); + if (ret) + return ret; + + vtcon_client = drm_vtcon_client_new(drm_vtcon_dev_id); + if (IS_ERR(vtcon_client)) { + ret = PTR_ERR(vtcon_client); + drm_vtcon_dev_id = ret; + goto err_free; + } + + console_lock(); + ret = do_take_over_console(&drm_vtcon_consw, 0, 1, 0); + console_unlock(); + if (ret) + goto err_remove; + + return 0; + +err_remove: + drm_client_remove(vtcon_client); +err_free: + drm_vtcon_teardown(); + + return ret; +} +module_init(drm_vtcon_module_init); + +static void __exit drm_vtcon_module_exit(void) +{ + if (drm_vtcon_dev_id < 0) + return; + + mutex_lock(&vtcon_client_lock); + drm_client_remove(vtcon_client); + mutex_unlock(&vtcon_client_lock); + + console_lock(); + do_unbind_con_driver(&drm_vtcon_consw, 0, 1, 0); + do_unregister_con_driver(&drm_vtcon_consw); + console_unlock(); + + del_timer_sync(&drm_vtcon_con_cursor_timer); + flush_work(&drm_vtcon_work); + drm_vtcon_teardown(); +} +module_exit(drm_vtcon_module_exit); + +MODULE_LICENSE("GPL");