forked from Minki/linux
906dde0f35
-----BEGIN PGP SIGNATURE----- iQIcBAABAgAGBQJZpRPIAAoJEAx081l5xIa+kCIP/2m2q0jBmCATvXXwrMBH0zNk 4lm9yIfl9pmluJP97aklvkeKF77chhost76+hv+0sQ9ZsJD8koHWv5WyTHEs7Cfn NpmtGPqYlIZsWNSwW0OFF/XzllgLCVEWa+W/7ryYzPZrSEZr6Ge4HE0qS3LfuLJv K89amZWHkP5ysPZ1uxRBzHtZfNAhdyjYVTUntCR7gj3DYv3yNdeZu+/epfcWK2w/ Q+ggoy644vX/yzy5L5zCGL/J1BjStDuec7sgAKTlNx4TwBUmp2wsfhEdovQBGFiu t5PHMajvrBRqSJWDIAZSUfjQzIMSz517J9LWeChU7KtAClNJQJEabbu4CoX4aEmG UbSzEe0IxnxQ4842jcqQXZ+mevlNIEIBVSNR7dXi17jL3Ts+APQgrYjRJYVk2ipg uQ9TwkeVVu2WRGyU8iRQrXAZI7+O3p4UnbNPjeG2qACD2Ur7Z3n7b0mhNFPOLzO4 gbIv4D6CcUB/vltl+vhZTW3P50oMCVSq8ScCpY8CGo29mZ5vypj5PTS+W8FsyY3Z ypyMqWg/DyxKlOoO+aK8EmXuZmgtDR4kb8asltH/S1A0NZkzjrFkKgs10Cp6EjJy Zz1BWa1KKEpdN6yp+jrbJKjf9MJ7K2RPGv3bxWnCCdNv4j49rk4t3IHqvcihddsd XXFQB5zE7Pz0ROi/VkXR =5fxW -----END PGP SIGNATURE----- Merge tag 'drm-for-v4.14' of git://people.freedesktop.org/~airlied/linux Pull drm updates from Dave Airlie: "This is the main drm pull request for 4.14 merge window. I'm sending this early, as my continuing journey into fatherhood is occurring really soon now, I'm going to be mostly useless for the next couple of weeks, though I may be able to read email, I doubt I'll be doing much patch applications or git sending. If anything urgent pops up I've asked Daniel/Jani/Alex/Sean to try and direct stuff towards you. Outside drm changes: Some rcar-du updates that touch the V4L tree, all acks should be in place. It adds one export to the radix tree code for new i915 use case. There are some minor AGP cleanups (don't see that too often). Changes to the vbox driver in staging to avoid breaking compilation. Summary: core: - Atomic helper fixes - Atomic UAPI fixes - Add YCBCR 4:2:0 support - Drop set_busid hook - Refactor fb_helper locking - Remove a bunch of internal APIs - Add a bunch of better default handlers - Format modifier/blob plane property added - More internal header refactoring - Make more internal API names consistent - Enhanced syncobj APIs (wait/signal/reset/create signalled) bridge: - Add Synopsys Designware MIPI DSI host bridge driver tiny: - Add Pervasive Displays RePaper displays - Add support for LEGO MINDSTORMS EV3 LCD i915: - Lots of GEN10/CNL support patches - drm syncobj support - Skylake+ watermark refactoring - GVT vGPU 48-bit ppgtt support - GVT performance improvements - NOA change ioctl - CCS (color compression) scanout support - GPU reset improvements amdgpu: - Initial hugepage support - BO migration logic rework - Vega10 improvements - Powerplay fixes - Stop reprogramming the MC - Fixes for ACP audio on stoney - SR-IOV fixes/improvements - Command submission overhead improvements amdkfd: - Non-dGPU upstreaming patches - Scratch VA ioctl - Image tiling modes - Update PM4 headers for new firmware - Drop all BUG_ONs. nouveau: - GP108 modesetting support. - Disable MSI on big endian. vmwgfx: - Add fence fd support. msm: - Runtime PM improvements exynos: - NV12MT support - Refactor KMS drivers imx-drm: - Lock scanout channel to improve memory bw - Cleanups etnaviv: - GEM object population fixes tegra: - Prep work for Tegra186 support - PRIME mmap support sunxi: - HDMI support improvements - HDMI CEC support omapdrm: - HDMI hotplug IRQ support - Big driver cleanup - OMAP5 DSI support rcar-du: - vblank fixes - VSP1 updates arcgpu: - Minor fixes stm: - Add STM32 DSI controller driver dw_hdmi: - Add support for Rockchip RK3399 - HDMI CEC support atmel-hlcdc: - Add 8-bit color support vc4: - Atomic fixes - New ioctl to attach a label to a buffer object - HDMI CEC support - Allow userspace to dictate rendering order on submit ioctl" * tag 'drm-for-v4.14' of git://people.freedesktop.org/~airlied/linux: (1074 commits) drm/syncobj: Add a signal ioctl (v3) drm/syncobj: Add a reset ioctl (v3) drm/syncobj: Add a syncobj_array_find helper drm/syncobj: Allow wait for submit and signal behavior (v5) drm/syncobj: Add a CREATE_SIGNALED flag drm/syncobj: Add a callback mechanism for replace_fence (v3) drm/syncobj: add sync obj wait interface. (v8) i915: Use drm_syncobj_fence_get drm/syncobj: Add a race-free drm_syncobj_fence_get helper (v2) drm/syncobj: Rename fence_get to find_fence drm: kirin: Add mode_valid logic to avoid mode clocks we can't generate drm/vmwgfx: Bump the version for fence FD support drm/vmwgfx: Add export fence to file descriptor support drm/vmwgfx: Add support for imported Fence File Descriptor drm/vmwgfx: Prepare to support fence fd drm/vmwgfx: Fix incorrect command header offset at restart drm/vmwgfx: Support the NOP_ERROR command drm/vmwgfx: Restart command buffers after errors drm/vmwgfx: Move irq bottom half processing to threads drm/vmwgfx: Don't use drm_irq_[un]install ...
1089 lines
30 KiB
C
1089 lines
30 KiB
C
/*
|
|
* Copyright (c) 2016 Intel Corporation
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
* that the name of the copyright holders not be used in advertising or
|
|
* publicity pertaining to distribution of the software without specific,
|
|
* written prior permission. The copyright holders make no representations
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
* is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
* OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <drm/drmP.h>
|
|
#include <drm/drm_plane.h>
|
|
|
|
#include "drm_crtc_internal.h"
|
|
|
|
/**
|
|
* DOC: overview
|
|
*
|
|
* A plane represents an image source that can be blended with or overlayed on
|
|
* top of a CRTC during the scanout process. Planes take their input data from a
|
|
* &drm_framebuffer object. The plane itself specifies the cropping and scaling
|
|
* of that image, and where it is placed on the visible are of a display
|
|
* pipeline, represented by &drm_crtc. A plane can also have additional
|
|
* properties that specify how the pixels are positioned and blended, like
|
|
* rotation or Z-position. All these properties are stored in &drm_plane_state.
|
|
*
|
|
* To create a plane, a KMS drivers allocates and zeroes an instances of
|
|
* &struct drm_plane (possibly as part of a larger structure) and registers it
|
|
* with a call to drm_universal_plane_init().
|
|
*
|
|
* Cursor and overlay planes are optional. All drivers should provide one
|
|
* primary plane per CRTC to avoid surprising userspace too much. See enum
|
|
* drm_plane_type for a more in-depth discussion of these special uapi-relevant
|
|
* plane types. Special planes are associated with their CRTC by calling
|
|
* drm_crtc_init_with_planes().
|
|
*
|
|
* The type of a plane is exposed in the immutable "type" enumeration property,
|
|
* which has one of the following values: "Overlay", "Primary", "Cursor".
|
|
*/
|
|
|
|
static unsigned int drm_num_planes(struct drm_device *dev)
|
|
{
|
|
unsigned int num = 0;
|
|
struct drm_plane *tmp;
|
|
|
|
drm_for_each_plane(tmp, dev) {
|
|
num++;
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
static inline u32 *
|
|
formats_ptr(struct drm_format_modifier_blob *blob)
|
|
{
|
|
return (u32 *)(((char *)blob) + blob->formats_offset);
|
|
}
|
|
|
|
static inline struct drm_format_modifier *
|
|
modifiers_ptr(struct drm_format_modifier_blob *blob)
|
|
{
|
|
return (struct drm_format_modifier *)(((char *)blob) + blob->modifiers_offset);
|
|
}
|
|
|
|
static int create_in_format_blob(struct drm_device *dev, struct drm_plane *plane)
|
|
{
|
|
const struct drm_mode_config *config = &dev->mode_config;
|
|
struct drm_property_blob *blob;
|
|
struct drm_format_modifier *mod;
|
|
size_t blob_size, formats_size, modifiers_size;
|
|
struct drm_format_modifier_blob *blob_data;
|
|
unsigned int i, j;
|
|
|
|
formats_size = sizeof(__u32) * plane->format_count;
|
|
if (WARN_ON(!formats_size)) {
|
|
/* 0 formats are never expected */
|
|
return 0;
|
|
}
|
|
|
|
modifiers_size =
|
|
sizeof(struct drm_format_modifier) * plane->modifier_count;
|
|
|
|
blob_size = sizeof(struct drm_format_modifier_blob);
|
|
/* Modifiers offset is a pointer to a struct with a 64 bit field so it
|
|
* should be naturally aligned to 8B.
|
|
*/
|
|
BUILD_BUG_ON(sizeof(struct drm_format_modifier_blob) % 8);
|
|
blob_size += ALIGN(formats_size, 8);
|
|
blob_size += modifiers_size;
|
|
|
|
blob = drm_property_create_blob(dev, blob_size, NULL);
|
|
if (IS_ERR(blob))
|
|
return -1;
|
|
|
|
blob_data = (struct drm_format_modifier_blob *)blob->data;
|
|
blob_data->version = FORMAT_BLOB_CURRENT;
|
|
blob_data->count_formats = plane->format_count;
|
|
blob_data->formats_offset = sizeof(struct drm_format_modifier_blob);
|
|
blob_data->count_modifiers = plane->modifier_count;
|
|
|
|
blob_data->modifiers_offset =
|
|
ALIGN(blob_data->formats_offset + formats_size, 8);
|
|
|
|
memcpy(formats_ptr(blob_data), plane->format_types, formats_size);
|
|
|
|
/* If we can't determine support, just bail */
|
|
if (!plane->funcs->format_mod_supported)
|
|
goto done;
|
|
|
|
mod = modifiers_ptr(blob_data);
|
|
for (i = 0; i < plane->modifier_count; i++) {
|
|
for (j = 0; j < plane->format_count; j++) {
|
|
if (plane->funcs->format_mod_supported(plane,
|
|
plane->format_types[j],
|
|
plane->modifiers[i])) {
|
|
|
|
mod->formats |= 1ULL << j;
|
|
}
|
|
}
|
|
|
|
mod->modifier = plane->modifiers[i];
|
|
mod->offset = 0;
|
|
mod->pad = 0;
|
|
mod++;
|
|
}
|
|
|
|
done:
|
|
drm_object_attach_property(&plane->base, config->modifiers_property,
|
|
blob->base.id);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* drm_universal_plane_init - Initialize a new universal plane object
|
|
* @dev: DRM device
|
|
* @plane: plane object to init
|
|
* @possible_crtcs: bitmask of possible CRTCs
|
|
* @funcs: callbacks for the new plane
|
|
* @formats: array of supported formats (DRM_FORMAT\_\*)
|
|
* @format_count: number of elements in @formats
|
|
* @format_modifiers: array of struct drm_format modifiers terminated by
|
|
* DRM_FORMAT_MOD_INVALID
|
|
* @type: type of plane (overlay, primary, cursor)
|
|
* @name: printf style format string for the plane name, or NULL for default name
|
|
*
|
|
* Initializes a plane object of type @type.
|
|
*
|
|
* Returns:
|
|
* Zero on success, error code on failure.
|
|
*/
|
|
int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
|
|
uint32_t possible_crtcs,
|
|
const struct drm_plane_funcs *funcs,
|
|
const uint32_t *formats, unsigned int format_count,
|
|
const uint64_t *format_modifiers,
|
|
enum drm_plane_type type,
|
|
const char *name, ...)
|
|
{
|
|
struct drm_mode_config *config = &dev->mode_config;
|
|
unsigned int format_modifier_count = 0;
|
|
int ret;
|
|
|
|
ret = drm_mode_object_add(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
|
|
if (ret)
|
|
return ret;
|
|
|
|
drm_modeset_lock_init(&plane->mutex);
|
|
|
|
plane->base.properties = &plane->properties;
|
|
plane->dev = dev;
|
|
plane->funcs = funcs;
|
|
plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
|
|
GFP_KERNEL);
|
|
if (!plane->format_types) {
|
|
DRM_DEBUG_KMS("out of memory when allocating plane\n");
|
|
drm_mode_object_unregister(dev, &plane->base);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/*
|
|
* First driver to need more than 64 formats needs to fix this. Each
|
|
* format is encoded as a bit and the current code only supports a u64.
|
|
*/
|
|
if (WARN_ON(format_count > 64))
|
|
return -EINVAL;
|
|
|
|
if (format_modifiers) {
|
|
const uint64_t *temp_modifiers = format_modifiers;
|
|
while (*temp_modifiers++ != DRM_FORMAT_MOD_INVALID)
|
|
format_modifier_count++;
|
|
}
|
|
|
|
plane->modifier_count = format_modifier_count;
|
|
plane->modifiers = kmalloc_array(format_modifier_count,
|
|
sizeof(format_modifiers[0]),
|
|
GFP_KERNEL);
|
|
|
|
if (format_modifier_count && !plane->modifiers) {
|
|
DRM_DEBUG_KMS("out of memory when allocating plane\n");
|
|
kfree(plane->format_types);
|
|
drm_mode_object_unregister(dev, &plane->base);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (name) {
|
|
va_list ap;
|
|
|
|
va_start(ap, name);
|
|
plane->name = kvasprintf(GFP_KERNEL, name, ap);
|
|
va_end(ap);
|
|
} else {
|
|
plane->name = kasprintf(GFP_KERNEL, "plane-%d",
|
|
drm_num_planes(dev));
|
|
}
|
|
if (!plane->name) {
|
|
kfree(plane->format_types);
|
|
kfree(plane->modifiers);
|
|
drm_mode_object_unregister(dev, &plane->base);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
|
|
plane->format_count = format_count;
|
|
memcpy(plane->modifiers, format_modifiers,
|
|
format_modifier_count * sizeof(format_modifiers[0]));
|
|
plane->possible_crtcs = possible_crtcs;
|
|
plane->type = type;
|
|
|
|
list_add_tail(&plane->head, &config->plane_list);
|
|
plane->index = config->num_total_plane++;
|
|
if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
|
config->num_overlay_plane++;
|
|
|
|
drm_object_attach_property(&plane->base,
|
|
config->plane_type_property,
|
|
plane->type);
|
|
|
|
if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
|
|
drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_in_fence_fd, -1);
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_src_x, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_src_y, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_src_w, 0);
|
|
drm_object_attach_property(&plane->base, config->prop_src_h, 0);
|
|
}
|
|
|
|
if (config->allow_fb_modifiers)
|
|
create_in_format_blob(dev, plane);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(drm_universal_plane_init);
|
|
|
|
int drm_plane_register_all(struct drm_device *dev)
|
|
{
|
|
struct drm_plane *plane;
|
|
int ret = 0;
|
|
|
|
drm_for_each_plane(plane, dev) {
|
|
if (plane->funcs->late_register)
|
|
ret = plane->funcs->late_register(plane);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void drm_plane_unregister_all(struct drm_device *dev)
|
|
{
|
|
struct drm_plane *plane;
|
|
|
|
drm_for_each_plane(plane, dev) {
|
|
if (plane->funcs->early_unregister)
|
|
plane->funcs->early_unregister(plane);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* drm_plane_init - Initialize a legacy plane
|
|
* @dev: DRM device
|
|
* @plane: plane object to init
|
|
* @possible_crtcs: bitmask of possible CRTCs
|
|
* @funcs: callbacks for the new plane
|
|
* @formats: array of supported formats (DRM_FORMAT\_\*)
|
|
* @format_count: number of elements in @formats
|
|
* @is_primary: plane type (primary vs overlay)
|
|
*
|
|
* Legacy API to initialize a DRM plane.
|
|
*
|
|
* New drivers should call drm_universal_plane_init() instead.
|
|
*
|
|
* Returns:
|
|
* Zero on success, error code on failure.
|
|
*/
|
|
int drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
|
|
uint32_t possible_crtcs,
|
|
const struct drm_plane_funcs *funcs,
|
|
const uint32_t *formats, unsigned int format_count,
|
|
bool is_primary)
|
|
{
|
|
enum drm_plane_type type;
|
|
|
|
type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
|
|
return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
|
|
formats, format_count,
|
|
NULL, type, NULL);
|
|
}
|
|
EXPORT_SYMBOL(drm_plane_init);
|
|
|
|
/**
|
|
* drm_plane_cleanup - Clean up the core plane usage
|
|
* @plane: plane to cleanup
|
|
*
|
|
* This function cleans up @plane and removes it from the DRM mode setting
|
|
* core. Note that the function does *not* free the plane structure itself,
|
|
* this is the responsibility of the caller.
|
|
*/
|
|
void drm_plane_cleanup(struct drm_plane *plane)
|
|
{
|
|
struct drm_device *dev = plane->dev;
|
|
|
|
drm_modeset_lock_fini(&plane->mutex);
|
|
|
|
kfree(plane->format_types);
|
|
kfree(plane->modifiers);
|
|
drm_mode_object_unregister(dev, &plane->base);
|
|
|
|
BUG_ON(list_empty(&plane->head));
|
|
|
|
/* Note that the plane_list is considered to be static; should we
|
|
* remove the drm_plane at runtime we would have to decrement all
|
|
* the indices on the drm_plane after us in the plane_list.
|
|
*/
|
|
|
|
list_del(&plane->head);
|
|
dev->mode_config.num_total_plane--;
|
|
if (plane->type == DRM_PLANE_TYPE_OVERLAY)
|
|
dev->mode_config.num_overlay_plane--;
|
|
|
|
WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
|
|
if (plane->state && plane->funcs->atomic_destroy_state)
|
|
plane->funcs->atomic_destroy_state(plane, plane->state);
|
|
|
|
kfree(plane->name);
|
|
|
|
memset(plane, 0, sizeof(*plane));
|
|
}
|
|
EXPORT_SYMBOL(drm_plane_cleanup);
|
|
|
|
/**
|
|
* drm_plane_from_index - find the registered plane at an index
|
|
* @dev: DRM device
|
|
* @idx: index of registered plane to find for
|
|
*
|
|
* Given a plane index, return the registered plane from DRM device's
|
|
* list of planes with matching index. This is the inverse of drm_plane_index().
|
|
*/
|
|
struct drm_plane *
|
|
drm_plane_from_index(struct drm_device *dev, int idx)
|
|
{
|
|
struct drm_plane *plane;
|
|
|
|
drm_for_each_plane(plane, dev)
|
|
if (idx == plane->index)
|
|
return plane;
|
|
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL(drm_plane_from_index);
|
|
|
|
/**
|
|
* drm_plane_force_disable - Forcibly disable a plane
|
|
* @plane: plane to disable
|
|
*
|
|
* Forces the plane to be disabled.
|
|
*
|
|
* Used when the plane's current framebuffer is destroyed,
|
|
* and when restoring fbdev mode.
|
|
*
|
|
* Note that this function is not suitable for atomic drivers, since it doesn't
|
|
* wire through the lock acquisition context properly and hence can't handle
|
|
* retries or driver private locks. You probably want to use
|
|
* drm_atomic_helper_disable_plane() or
|
|
* drm_atomic_helper_disable_planes_on_crtc() instead.
|
|
*/
|
|
void drm_plane_force_disable(struct drm_plane *plane)
|
|
{
|
|
int ret;
|
|
|
|
if (!plane->fb)
|
|
return;
|
|
|
|
WARN_ON(drm_drv_uses_atomic_modeset(plane->dev));
|
|
|
|
plane->old_fb = plane->fb;
|
|
ret = plane->funcs->disable_plane(plane, NULL);
|
|
if (ret) {
|
|
DRM_ERROR("failed to disable plane with busy fb\n");
|
|
plane->old_fb = NULL;
|
|
return;
|
|
}
|
|
/* disconnect the plane from the fb and crtc: */
|
|
drm_framebuffer_put(plane->old_fb);
|
|
plane->old_fb = NULL;
|
|
plane->fb = NULL;
|
|
plane->crtc = NULL;
|
|
}
|
|
EXPORT_SYMBOL(drm_plane_force_disable);
|
|
|
|
/**
|
|
* drm_mode_plane_set_obj_prop - set the value of a property
|
|
* @plane: drm plane object to set property value for
|
|
* @property: property to set
|
|
* @value: value the property should be set to
|
|
*
|
|
* This functions sets a given property on a given plane object. This function
|
|
* calls the driver's ->set_property callback and changes the software state of
|
|
* the property if the callback succeeds.
|
|
*
|
|
* Returns:
|
|
* Zero on success, error code on failure.
|
|
*/
|
|
int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
|
|
struct drm_property *property,
|
|
uint64_t value)
|
|
{
|
|
int ret = -EINVAL;
|
|
struct drm_mode_object *obj = &plane->base;
|
|
|
|
if (plane->funcs->set_property)
|
|
ret = plane->funcs->set_property(plane, property, value);
|
|
if (!ret)
|
|
drm_object_property_set_value(obj, property, value);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);
|
|
|
|
int drm_mode_getplane_res(struct drm_device *dev, void *data,
|
|
struct drm_file *file_priv)
|
|
{
|
|
struct drm_mode_get_plane_res *plane_resp = data;
|
|
struct drm_mode_config *config;
|
|
struct drm_plane *plane;
|
|
uint32_t __user *plane_ptr;
|
|
int copied = 0;
|
|
unsigned num_planes;
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
return -EINVAL;
|
|
|
|
config = &dev->mode_config;
|
|
|
|
if (file_priv->universal_planes)
|
|
num_planes = config->num_total_plane;
|
|
else
|
|
num_planes = config->num_overlay_plane;
|
|
|
|
/*
|
|
* This ioctl is called twice, once to determine how much space is
|
|
* needed, and the 2nd time to fill it.
|
|
*/
|
|
if (num_planes &&
|
|
(plane_resp->count_planes >= num_planes)) {
|
|
plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
|
|
|
|
/* Plane lists are invariant, no locking needed. */
|
|
drm_for_each_plane(plane, dev) {
|
|
/*
|
|
* Unless userspace set the 'universal planes'
|
|
* capability bit, only advertise overlays.
|
|
*/
|
|
if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
|
|
!file_priv->universal_planes)
|
|
continue;
|
|
|
|
if (put_user(plane->base.id, plane_ptr + copied))
|
|
return -EFAULT;
|
|
copied++;
|
|
}
|
|
}
|
|
plane_resp->count_planes = num_planes;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int drm_mode_getplane(struct drm_device *dev, void *data,
|
|
struct drm_file *file_priv)
|
|
{
|
|
struct drm_mode_get_plane *plane_resp = data;
|
|
struct drm_plane *plane;
|
|
uint32_t __user *format_ptr;
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
return -EINVAL;
|
|
|
|
plane = drm_plane_find(dev, plane_resp->plane_id);
|
|
if (!plane)
|
|
return -ENOENT;
|
|
|
|
drm_modeset_lock(&plane->mutex, NULL);
|
|
if (plane->state && plane->state->crtc)
|
|
plane_resp->crtc_id = plane->state->crtc->base.id;
|
|
else if (!plane->state && plane->crtc)
|
|
plane_resp->crtc_id = plane->crtc->base.id;
|
|
else
|
|
plane_resp->crtc_id = 0;
|
|
|
|
if (plane->state && plane->state->fb)
|
|
plane_resp->fb_id = plane->state->fb->base.id;
|
|
else if (!plane->state && plane->fb)
|
|
plane_resp->fb_id = plane->fb->base.id;
|
|
else
|
|
plane_resp->fb_id = 0;
|
|
drm_modeset_unlock(&plane->mutex);
|
|
|
|
plane_resp->plane_id = plane->base.id;
|
|
plane_resp->possible_crtcs = plane->possible_crtcs;
|
|
plane_resp->gamma_size = 0;
|
|
|
|
/*
|
|
* This ioctl is called twice, once to determine how much space is
|
|
* needed, and the 2nd time to fill it.
|
|
*/
|
|
if (plane->format_count &&
|
|
(plane_resp->count_format_types >= plane->format_count)) {
|
|
format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
|
|
if (copy_to_user(format_ptr,
|
|
plane->format_types,
|
|
sizeof(uint32_t) * plane->format_count)) {
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
plane_resp->count_format_types = plane->format_count;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < plane->format_count; i++) {
|
|
if (format == plane->format_types[i])
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* setplane_internal - setplane handler for internal callers
|
|
*
|
|
* Note that we assume an extra reference has already been taken on fb. If the
|
|
* update fails, this reference will be dropped before return; if it succeeds,
|
|
* the previous framebuffer (if any) will be unreferenced instead.
|
|
*
|
|
* src_{x,y,w,h} are provided in 16.16 fixed point format
|
|
*/
|
|
static int __setplane_internal(struct drm_plane *plane,
|
|
struct drm_crtc *crtc,
|
|
struct drm_framebuffer *fb,
|
|
int32_t crtc_x, int32_t crtc_y,
|
|
uint32_t crtc_w, uint32_t crtc_h,
|
|
/* src_{x,y,w,h} values are 16.16 fixed point */
|
|
uint32_t src_x, uint32_t src_y,
|
|
uint32_t src_w, uint32_t src_h,
|
|
struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
int ret = 0;
|
|
|
|
/* No fb means shut it down */
|
|
if (!fb) {
|
|
plane->old_fb = plane->fb;
|
|
ret = plane->funcs->disable_plane(plane, ctx);
|
|
if (!ret) {
|
|
plane->crtc = NULL;
|
|
plane->fb = NULL;
|
|
} else {
|
|
plane->old_fb = NULL;
|
|
}
|
|
goto out;
|
|
}
|
|
|
|
/* Check whether this plane is usable on this CRTC */
|
|
if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
|
|
DRM_DEBUG_KMS("Invalid crtc for plane\n");
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
/* Check whether this plane supports the fb pixel format. */
|
|
ret = drm_plane_check_pixel_format(plane, fb->format->format);
|
|
if (ret) {
|
|
struct drm_format_name_buf format_name;
|
|
DRM_DEBUG_KMS("Invalid pixel format %s\n",
|
|
drm_get_format_name(fb->format->format,
|
|
&format_name));
|
|
goto out;
|
|
}
|
|
|
|
/* Give drivers some help against integer overflows */
|
|
if (crtc_w > INT_MAX ||
|
|
crtc_x > INT_MAX - (int32_t) crtc_w ||
|
|
crtc_h > INT_MAX ||
|
|
crtc_y > INT_MAX - (int32_t) crtc_h) {
|
|
DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
|
|
crtc_w, crtc_h, crtc_x, crtc_y);
|
|
ret = -ERANGE;
|
|
goto out;
|
|
}
|
|
|
|
ret = drm_framebuffer_check_src_coords(src_x, src_y, src_w, src_h, fb);
|
|
if (ret)
|
|
goto out;
|
|
|
|
plane->old_fb = plane->fb;
|
|
ret = plane->funcs->update_plane(plane, crtc, fb,
|
|
crtc_x, crtc_y, crtc_w, crtc_h,
|
|
src_x, src_y, src_w, src_h, ctx);
|
|
if (!ret) {
|
|
plane->crtc = crtc;
|
|
plane->fb = fb;
|
|
fb = NULL;
|
|
} else {
|
|
plane->old_fb = NULL;
|
|
}
|
|
|
|
out:
|
|
if (fb)
|
|
drm_framebuffer_put(fb);
|
|
if (plane->old_fb)
|
|
drm_framebuffer_put(plane->old_fb);
|
|
plane->old_fb = NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int setplane_internal(struct drm_plane *plane,
|
|
struct drm_crtc *crtc,
|
|
struct drm_framebuffer *fb,
|
|
int32_t crtc_x, int32_t crtc_y,
|
|
uint32_t crtc_w, uint32_t crtc_h,
|
|
/* src_{x,y,w,h} values are 16.16 fixed point */
|
|
uint32_t src_x, uint32_t src_y,
|
|
uint32_t src_w, uint32_t src_h)
|
|
{
|
|
struct drm_modeset_acquire_ctx ctx;
|
|
int ret;
|
|
|
|
drm_modeset_acquire_init(&ctx, 0);
|
|
retry:
|
|
ret = drm_modeset_lock_all_ctx(plane->dev, &ctx);
|
|
if (ret)
|
|
goto fail;
|
|
ret = __setplane_internal(plane, crtc, fb,
|
|
crtc_x, crtc_y, crtc_w, crtc_h,
|
|
src_x, src_y, src_w, src_h, &ctx);
|
|
|
|
fail:
|
|
if (ret == -EDEADLK) {
|
|
drm_modeset_backoff(&ctx);
|
|
goto retry;
|
|
}
|
|
drm_modeset_drop_locks(&ctx);
|
|
drm_modeset_acquire_fini(&ctx);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int drm_mode_setplane(struct drm_device *dev, void *data,
|
|
struct drm_file *file_priv)
|
|
{
|
|
struct drm_mode_set_plane *plane_req = data;
|
|
struct drm_plane *plane;
|
|
struct drm_crtc *crtc = NULL;
|
|
struct drm_framebuffer *fb = NULL;
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* First, find the plane, crtc, and fb objects. If not available,
|
|
* we don't bother to call the driver.
|
|
*/
|
|
plane = drm_plane_find(dev, plane_req->plane_id);
|
|
if (!plane) {
|
|
DRM_DEBUG_KMS("Unknown plane ID %d\n",
|
|
plane_req->plane_id);
|
|
return -ENOENT;
|
|
}
|
|
|
|
if (plane_req->fb_id) {
|
|
fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
|
|
if (!fb) {
|
|
DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
|
|
plane_req->fb_id);
|
|
return -ENOENT;
|
|
}
|
|
|
|
crtc = drm_crtc_find(dev, plane_req->crtc_id);
|
|
if (!crtc) {
|
|
drm_framebuffer_put(fb);
|
|
DRM_DEBUG_KMS("Unknown crtc ID %d\n",
|
|
plane_req->crtc_id);
|
|
return -ENOENT;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* setplane_internal will take care of deref'ing either the old or new
|
|
* framebuffer depending on success.
|
|
*/
|
|
return setplane_internal(plane, crtc, fb,
|
|
plane_req->crtc_x, plane_req->crtc_y,
|
|
plane_req->crtc_w, plane_req->crtc_h,
|
|
plane_req->src_x, plane_req->src_y,
|
|
plane_req->src_w, plane_req->src_h);
|
|
}
|
|
|
|
static int drm_mode_cursor_universal(struct drm_crtc *crtc,
|
|
struct drm_mode_cursor2 *req,
|
|
struct drm_file *file_priv,
|
|
struct drm_modeset_acquire_ctx *ctx)
|
|
{
|
|
struct drm_device *dev = crtc->dev;
|
|
struct drm_framebuffer *fb = NULL;
|
|
struct drm_mode_fb_cmd2 fbreq = {
|
|
.width = req->width,
|
|
.height = req->height,
|
|
.pixel_format = DRM_FORMAT_ARGB8888,
|
|
.pitches = { req->width * 4 },
|
|
.handles = { req->handle },
|
|
};
|
|
int32_t crtc_x, crtc_y;
|
|
uint32_t crtc_w = 0, crtc_h = 0;
|
|
uint32_t src_w = 0, src_h = 0;
|
|
int ret = 0;
|
|
|
|
BUG_ON(!crtc->cursor);
|
|
WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL);
|
|
|
|
/*
|
|
* Obtain fb we'll be using (either new or existing) and take an extra
|
|
* reference to it if fb != null. setplane will take care of dropping
|
|
* the reference if the plane update fails.
|
|
*/
|
|
if (req->flags & DRM_MODE_CURSOR_BO) {
|
|
if (req->handle) {
|
|
fb = drm_internal_framebuffer_create(dev, &fbreq, file_priv);
|
|
if (IS_ERR(fb)) {
|
|
DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
|
|
return PTR_ERR(fb);
|
|
}
|
|
fb->hot_x = req->hot_x;
|
|
fb->hot_y = req->hot_y;
|
|
} else {
|
|
fb = NULL;
|
|
}
|
|
} else {
|
|
fb = crtc->cursor->fb;
|
|
if (fb)
|
|
drm_framebuffer_get(fb);
|
|
}
|
|
|
|
if (req->flags & DRM_MODE_CURSOR_MOVE) {
|
|
crtc_x = req->x;
|
|
crtc_y = req->y;
|
|
} else {
|
|
crtc_x = crtc->cursor_x;
|
|
crtc_y = crtc->cursor_y;
|
|
}
|
|
|
|
if (fb) {
|
|
crtc_w = fb->width;
|
|
crtc_h = fb->height;
|
|
src_w = fb->width << 16;
|
|
src_h = fb->height << 16;
|
|
}
|
|
|
|
/*
|
|
* setplane_internal will take care of deref'ing either the old or new
|
|
* framebuffer depending on success.
|
|
*/
|
|
ret = __setplane_internal(crtc->cursor, crtc, fb,
|
|
crtc_x, crtc_y, crtc_w, crtc_h,
|
|
0, 0, src_w, src_h, ctx);
|
|
|
|
/* Update successful; save new cursor position, if necessary */
|
|
if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) {
|
|
crtc->cursor_x = req->x;
|
|
crtc->cursor_y = req->y;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int drm_mode_cursor_common(struct drm_device *dev,
|
|
struct drm_mode_cursor2 *req,
|
|
struct drm_file *file_priv)
|
|
{
|
|
struct drm_crtc *crtc;
|
|
struct drm_modeset_acquire_ctx ctx;
|
|
int ret = 0;
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
return -EINVAL;
|
|
|
|
if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
|
|
return -EINVAL;
|
|
|
|
crtc = drm_crtc_find(dev, req->crtc_id);
|
|
if (!crtc) {
|
|
DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
|
|
return -ENOENT;
|
|
}
|
|
|
|
drm_modeset_acquire_init(&ctx, 0);
|
|
retry:
|
|
ret = drm_modeset_lock(&crtc->mutex, &ctx);
|
|
if (ret)
|
|
goto out;
|
|
/*
|
|
* If this crtc has a universal cursor plane, call that plane's update
|
|
* handler rather than using legacy cursor handlers.
|
|
*/
|
|
if (crtc->cursor) {
|
|
ret = drm_modeset_lock(&crtc->cursor->mutex, &ctx);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = drm_mode_cursor_universal(crtc, req, file_priv, &ctx);
|
|
goto out;
|
|
}
|
|
|
|
if (req->flags & DRM_MODE_CURSOR_BO) {
|
|
if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
|
|
ret = -ENXIO;
|
|
goto out;
|
|
}
|
|
/* Turns off the cursor if handle is 0 */
|
|
if (crtc->funcs->cursor_set2)
|
|
ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle,
|
|
req->width, req->height, req->hot_x, req->hot_y);
|
|
else
|
|
ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle,
|
|
req->width, req->height);
|
|
}
|
|
|
|
if (req->flags & DRM_MODE_CURSOR_MOVE) {
|
|
if (crtc->funcs->cursor_move) {
|
|
ret = crtc->funcs->cursor_move(crtc, req->x, req->y);
|
|
} else {
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
if (ret == -EDEADLK) {
|
|
drm_modeset_backoff(&ctx);
|
|
goto retry;
|
|
}
|
|
|
|
drm_modeset_drop_locks(&ctx);
|
|
drm_modeset_acquire_fini(&ctx);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
int drm_mode_cursor_ioctl(struct drm_device *dev,
|
|
void *data, struct drm_file *file_priv)
|
|
{
|
|
struct drm_mode_cursor *req = data;
|
|
struct drm_mode_cursor2 new_req;
|
|
|
|
memcpy(&new_req, req, sizeof(struct drm_mode_cursor));
|
|
new_req.hot_x = new_req.hot_y = 0;
|
|
|
|
return drm_mode_cursor_common(dev, &new_req, file_priv);
|
|
}
|
|
|
|
/*
|
|
* Set the cursor configuration based on user request. This implements the 2nd
|
|
* version of the cursor ioctl, which allows userspace to additionally specify
|
|
* the hotspot of the pointer.
|
|
*/
|
|
int drm_mode_cursor2_ioctl(struct drm_device *dev,
|
|
void *data, struct drm_file *file_priv)
|
|
{
|
|
struct drm_mode_cursor2 *req = data;
|
|
|
|
return drm_mode_cursor_common(dev, req, file_priv);
|
|
}
|
|
|
|
int drm_mode_page_flip_ioctl(struct drm_device *dev,
|
|
void *data, struct drm_file *file_priv)
|
|
{
|
|
struct drm_mode_crtc_page_flip_target *page_flip = data;
|
|
struct drm_crtc *crtc;
|
|
struct drm_framebuffer *fb = NULL;
|
|
struct drm_pending_vblank_event *e = NULL;
|
|
u32 target_vblank = page_flip->sequence;
|
|
struct drm_modeset_acquire_ctx ctx;
|
|
int ret = -EINVAL;
|
|
|
|
if (!drm_core_check_feature(dev, DRIVER_MODESET))
|
|
return -EINVAL;
|
|
|
|
if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS)
|
|
return -EINVAL;
|
|
|
|
if (page_flip->sequence != 0 && !(page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET))
|
|
return -EINVAL;
|
|
|
|
/* Only one of the DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags
|
|
* can be specified
|
|
*/
|
|
if ((page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET) == DRM_MODE_PAGE_FLIP_TARGET)
|
|
return -EINVAL;
|
|
|
|
if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
|
|
return -EINVAL;
|
|
|
|
crtc = drm_crtc_find(dev, page_flip->crtc_id);
|
|
if (!crtc)
|
|
return -ENOENT;
|
|
|
|
if (crtc->funcs->page_flip_target) {
|
|
u32 current_vblank;
|
|
int r;
|
|
|
|
r = drm_crtc_vblank_get(crtc);
|
|
if (r)
|
|
return r;
|
|
|
|
current_vblank = drm_crtc_vblank_count(crtc);
|
|
|
|
switch (page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET) {
|
|
case DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE:
|
|
if ((int)(target_vblank - current_vblank) > 1) {
|
|
DRM_DEBUG("Invalid absolute flip target %u, "
|
|
"must be <= %u\n", target_vblank,
|
|
current_vblank + 1);
|
|
drm_crtc_vblank_put(crtc);
|
|
return -EINVAL;
|
|
}
|
|
break;
|
|
case DRM_MODE_PAGE_FLIP_TARGET_RELATIVE:
|
|
if (target_vblank != 0 && target_vblank != 1) {
|
|
DRM_DEBUG("Invalid relative flip target %u, "
|
|
"must be 0 or 1\n", target_vblank);
|
|
drm_crtc_vblank_put(crtc);
|
|
return -EINVAL;
|
|
}
|
|
target_vblank += current_vblank;
|
|
break;
|
|
default:
|
|
target_vblank = current_vblank +
|
|
!(page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC);
|
|
break;
|
|
}
|
|
} else if (crtc->funcs->page_flip == NULL ||
|
|
(page_flip->flags & DRM_MODE_PAGE_FLIP_TARGET)) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
drm_modeset_acquire_init(&ctx, 0);
|
|
retry:
|
|
ret = drm_modeset_lock(&crtc->mutex, &ctx);
|
|
if (ret)
|
|
goto out;
|
|
ret = drm_modeset_lock(&crtc->primary->mutex, &ctx);
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (crtc->primary->fb == NULL) {
|
|
/* The framebuffer is currently unbound, presumably
|
|
* due to a hotplug event, that userspace has not
|
|
* yet discovered.
|
|
*/
|
|
ret = -EBUSY;
|
|
goto out;
|
|
}
|
|
|
|
fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
|
|
if (!fb) {
|
|
ret = -ENOENT;
|
|
goto out;
|
|
}
|
|
|
|
if (crtc->state) {
|
|
const struct drm_plane_state *state = crtc->primary->state;
|
|
|
|
ret = drm_framebuffer_check_src_coords(state->src_x,
|
|
state->src_y,
|
|
state->src_w,
|
|
state->src_h,
|
|
fb);
|
|
} else {
|
|
ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb);
|
|
}
|
|
if (ret)
|
|
goto out;
|
|
|
|
if (crtc->primary->fb->format != fb->format) {
|
|
DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
|
|
if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
|
|
e = kzalloc(sizeof *e, GFP_KERNEL);
|
|
if (!e) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
|
|
e->event.base.length = sizeof(e->event);
|
|
e->event.user_data = page_flip->user_data;
|
|
ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
|
|
if (ret) {
|
|
kfree(e);
|
|
e = NULL;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
crtc->primary->old_fb = crtc->primary->fb;
|
|
if (crtc->funcs->page_flip_target)
|
|
ret = crtc->funcs->page_flip_target(crtc, fb, e,
|
|
page_flip->flags,
|
|
target_vblank,
|
|
&ctx);
|
|
else
|
|
ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags,
|
|
&ctx);
|
|
if (ret) {
|
|
if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT)
|
|
drm_event_cancel_free(dev, &e->base);
|
|
/* Keep the old fb, don't unref it. */
|
|
crtc->primary->old_fb = NULL;
|
|
} else {
|
|
crtc->primary->fb = fb;
|
|
/* Unref only the old framebuffer. */
|
|
fb = NULL;
|
|
}
|
|
|
|
out:
|
|
if (fb)
|
|
drm_framebuffer_put(fb);
|
|
if (crtc->primary->old_fb)
|
|
drm_framebuffer_put(crtc->primary->old_fb);
|
|
crtc->primary->old_fb = NULL;
|
|
|
|
if (ret == -EDEADLK) {
|
|
drm_modeset_backoff(&ctx);
|
|
goto retry;
|
|
}
|
|
|
|
drm_modeset_drop_locks(&ctx);
|
|
drm_modeset_acquire_fini(&ctx);
|
|
|
|
if (ret && crtc->funcs->page_flip_target)
|
|
drm_crtc_vblank_put(crtc);
|
|
|
|
return ret;
|
|
}
|