Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 88a48e29 authored by Rob Clark's avatar Rob Clark Committed by Daniel Vetter
Browse files

drm: add atomic properties 



Once a driver is using atomic helpers for modeset, the next step is to
switch over to atomic properties.  To do this, make sure that any
modeset objects have their ->atomic_{get,set}_property() vfuncs suitably
populated if they have custom properties (you did already remember to
plug in atomic-helper func for the legacy ->set_property() vfuncs,
right?), and then set DRIVER_ATOMIC bit in driver_features flag.

A new cap is introduced, DRM_CLIENT_CAP_ATOMIC, for the purposes of
shielding legacy userspace from atomic properties.  Mostly for the
benefit of legacy DDX drivers that do silly things like getting/setting
each property at startup (since some of the new atomic properties will
be able to trigger modeset).

Signed-off-by: default avatarRob Clark <robdclark@gmail.com>
[danvet: Squash in fixup patch to check for DRM_MODE_PROP_ATOMIC
instaed of the CAP define when filtering properties. Reported by
Tvrtko Uruslin, acked by Rob.]
Signed-off-by: default avatarDaniel Vetter <daniel.vetter@ffwll.ch>
parent 95cbf110

Documentation/DocBook/drm.tmpl

+8 −0
Original line number Diff line number Diff line
@@ -239,6 +239,14 @@ 
              Driver supports dedicated render nodes.

            </para></listitem>

          </varlistentry>

          <varlistentry>

            <term>DRIVER_ATOMIC</term>

            <listitem><para>

              Driver supports atomic properties.  In this case the driver

              must implement appropriate obj->atomic_get_property() vfuncs

              for any modeset objects with driver specific properties.

            </para></listitem>

          </varlistentry>

        </variablelist>

      </sect3>

      <sect3>

drivers/gpu/drm/drm_atomic.c

+45 −0
Original line number Diff line number Diff line
@@ -520,6 +520,51 @@ int drm_atomic_connector_get_property(struct drm_connector *connector, 
}

EXPORT_SYMBOL(drm_atomic_connector_get_property);



/**

 * drm_atomic_get_property - helper to read atomic property

 * @obj: drm mode object whose property to read

 * @property: the property to read

 * @val: the read value, returned by reference

 *

 * RETURNS:

 * Zero on success, error code on failure

 */

int drm_atomic_get_property(struct drm_mode_object *obj,

		struct drm_property *property, uint64_t *val)

{

	struct drm_device *dev = property->dev;

	int ret;



	switch (obj->type) {

	case DRM_MODE_OBJECT_CONNECTOR: {

		struct drm_connector *connector = obj_to_connector(obj);

		WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));

		ret = drm_atomic_connector_get_property(connector,

				connector->state, property, val);

		break;

	}

	case DRM_MODE_OBJECT_CRTC: {

		struct drm_crtc *crtc = obj_to_crtc(obj);

		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));

		ret = drm_atomic_crtc_get_property(crtc,

				crtc->state, property, val);

		break;

	}

	case DRM_MODE_OBJECT_PLANE: {

		struct drm_plane *plane = obj_to_plane(obj);

		WARN_ON(!drm_modeset_is_locked(&plane->mutex));

		ret = drm_atomic_plane_get_property(plane,

				plane->state, property, val);

		break;

	}

	default:

		ret = -EINVAL;

		break;

	}



	return ret;

}



/**

 * drm_atomic_set_crtc_for_plane - set crtc for plane

 * @plane_state: the plane whose incoming state to update

drivers/gpu/drm/drm_crtc.c

+24 −7
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ 
#include <drm/drm_edid.h>

#include <drm/drm_fourcc.h>

#include <drm/drm_modeset_lock.h>

#include <drm/drm_atomic.h>



#include "drm_crtc_internal.h"

#include "drm_internal.h"
@@ -1992,19 +1993,25 @@ static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *conne 
}



/* helper for getconnector and getproperties ioctls */

static int get_properties(struct drm_mode_object *obj,

static int get_properties(struct drm_mode_object *obj, bool atomic,

		uint32_t __user *prop_ptr, uint64_t __user *prop_values,

		uint32_t *arg_count_props)

{

	int props_count = obj->properties->count;

	int i, ret, copied = 0;

	int props_count;

	int i, ret, copied;



	props_count = obj->properties->count;

	if (!atomic)

		props_count -= obj->properties->atomic_count;



	if ((*arg_count_props >= props_count) && props_count) {

		copied = 0;

		for (i = 0; i < props_count; i++) {

		for (i = 0, copied = 0; copied < props_count; i++) {

			struct drm_property *prop = obj->properties->properties[i];

			uint64_t val;



			if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)

				continue;



			ret = drm_object_property_get_value(obj, prop, &val);

			if (ret)

				return ret;
@@ -2118,7 +2125,7 @@ int drm_mode_getconnector(struct drm_device *dev, void *data, 
	}

	out_resp->count_modes = mode_count;



	ret = get_properties(&connector->base,

	ret = get_properties(&connector->base, file_priv->atomic,

			(uint32_t __user *)(unsigned long)(out_resp->props_ptr),

			(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),

			&out_resp->count_props);
@@ -3832,6 +3839,8 @@ void drm_object_attach_property(struct drm_mode_object *obj, 
	obj->properties->properties[count] = property;

	obj->properties->values[count] = init_val;

	obj->properties->count++;

	if (property->flags & DRM_MODE_PROP_ATOMIC)

		obj->properties->atomic_count++;

}

EXPORT_SYMBOL(drm_object_attach_property);
@@ -3883,6 +3892,14 @@ int drm_object_property_get_value(struct drm_mode_object *obj, 
{

	int i;



	/* read-only properties bypass atomic mechanism and still store

	 * their value in obj->properties->values[].. mostly to avoid

	 * having to deal w/ EDID and similar props in atomic paths:

	 */

	if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&

			!(property->flags & DRM_MODE_PROP_IMMUTABLE))

		return drm_atomic_get_property(obj, property, val);



	for (i = 0; i < obj->properties->count; i++) {

		if (obj->properties->properties[i] == property) {

			*val = obj->properties->values[i];
@@ -4413,7 +4430,7 @@ int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data, 
		goto out;

	}



	ret = get_properties(obj,

	ret = get_properties(obj, file_priv->atomic,

			(uint32_t __user *)(unsigned long)(arg->props_ptr),

			(uint64_t __user *)(unsigned long)(arg->prop_values_ptr),

			&arg->count_props);

drivers/gpu/drm/drm_drv.c

+4 −0
Original line number Diff line number Diff line
@@ -40,15 +40,19 @@ 
unsigned int drm_debug = 0;	/* 1 to enable debug output */

EXPORT_SYMBOL(drm_debug);



bool drm_atomic = 0;



MODULE_AUTHOR(CORE_AUTHOR);

MODULE_DESCRIPTION(CORE_DESC);

MODULE_LICENSE("GPL and additional rights");

MODULE_PARM_DESC(debug, "Enable debug output");

MODULE_PARM_DESC(atomic, "Enable experimental atomic KMS API");

MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");

MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");

MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");



module_param_named(debug, drm_debug, int, 0600);

module_param_named_unsafe(atomic, drm_atomic, bool, 0600);



static DEFINE_SPINLOCK(drm_minor_lock);

static struct idr drm_minors_idr;

drivers/gpu/drm/drm_ioctl.c

+10 −0
Original line number Diff line number Diff line
@@ -345,6 +345,16 @@ drm_setclientcap(struct drm_device *dev, void *data, struct drm_file *file_priv) 
			return -EINVAL;

		file_priv->universal_planes = req->value;

		break;

	case DRM_CLIENT_CAP_ATOMIC:

		/* for now, hide behind experimental drm.atomic moduleparam */

		if (!drm_atomic)

			return -EINVAL;

		if (!drm_core_check_feature(dev, DRIVER_ATOMIC))

			return -EINVAL;

		if (req->value > 1)

			return -EINVAL;

		file_priv->atomic = req->value;

		break;

	default:

		return -EINVAL;

	}