drm_atomic.h File Reference

#include <drm/drm_crtc.h>
#include <drm/drm_util.h>

Include dependency graph for drm_atomic.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	drm_crtc_commit
struct	__drm_colorops_state
struct	__drm_planes_state
struct	__drm_crtcs_state
struct	__drm_connnectors_state
struct	drm_private_state_funcs
struct	drm_private_obj
struct	drm_private_state
struct	__drm_private_objs_state
struct	drm_atomic_commit
struct	drm_bus_cfg
struct	drm_bridge_state

Macros
#define	drm_for_each_privobj(privobj, dev)    list_for_each_entry(privobj, &(dev)->mode_config.privobj_list, head)
#define	for_each_oldnew_connector_in_state(__state, connector, old_connector_state, new_connector_state, __i)
#define	for_each_old_connector_in_state(__state, connector, old_connector_state, __i)
#define	for_each_new_connector_in_state(__state, connector, new_connector_state, __i)
#define	for_each_oldnew_crtc_in_state(__state, crtc, old_crtc_state, new_crtc_state, __i)
#define	for_each_old_crtc_in_state(__state, crtc, old_crtc_state, __i)
#define	for_each_new_crtc_in_state(__state, crtc, new_crtc_state, __i)
#define	for_each_oldnew_colorop_in_state(__state, colorop, old_colorop_state, new_colorop_state, __i)
#define	for_each_new_colorop_in_state(__state, colorop, new_colorop_state, __i)
#define	for_each_oldnew_plane_in_state(__state, plane, old_plane_state, new_plane_state, __i)
#define	for_each_oldnew_plane_in_state_reverse(__state, plane, old_plane_state, new_plane_state, __i)
#define	for_each_new_plane_in_state_reverse(__state, plane, new_plane_state, __i)
#define	for_each_old_plane_in_state(__state, plane, old_plane_state, __i)
#define	for_each_new_plane_in_state(__state, plane, new_plane_state, __i)
#define	for_each_oldnew_private_obj_in_state(__state, obj, old_obj_state, new_obj_state, __i)
#define	for_each_old_private_obj_in_state(__state, obj, old_obj_state, __i)
#define	for_each_new_private_obj_in_state(__state, obj, new_obj_state, __i)

Functions
void	__drm_crtc_commit_free (struct kref *kref)
int	drm_crtc_commit_wait (struct drm_crtc_commit *commit)
struct drm_atomic_commit *__must_check	drm_atomic_commit_alloc (struct drm_device *dev)
void	drm_atomic_commit_clear (struct drm_atomic_commit *state)
void	__drm_atomic_commit_free (struct kref *ref)
int __must_check	drm_atomic_commit_init (struct drm_device *dev, struct drm_atomic_commit *state)
void	drm_atomic_commit_default_clear (struct drm_atomic_commit *state)
void	drm_atomic_commit_default_release (struct drm_atomic_commit *state)
struct drm_crtc_state *__must_check	drm_atomic_get_crtc_state (struct drm_atomic_commit *state, struct drm_crtc *crtc)
struct drm_plane_state *__must_check	drm_atomic_get_plane_state (struct drm_atomic_commit *state, struct drm_plane *plane)
struct drm_colorop_state *	drm_atomic_get_colorop_state (struct drm_atomic_commit *state, struct drm_colorop *colorop)
struct drm_colorop_state *	drm_atomic_get_old_colorop_state (struct drm_atomic_commit *state, struct drm_colorop *colorop)
struct drm_colorop_state *	drm_atomic_get_new_colorop_state (struct drm_atomic_commit *state, struct drm_colorop *colorop)
struct drm_connector_state *__must_check	drm_atomic_get_connector_state (struct drm_atomic_commit *state, struct drm_connector *connector)
int	drm_atomic_private_obj_init (struct drm_device *dev, struct drm_private_obj *obj, const struct drm_private_state_funcs *funcs)
void	drm_atomic_private_obj_fini (struct drm_private_obj *obj)
struct drm_private_state *__must_check	drm_atomic_get_private_obj_state (struct drm_atomic_commit *state, struct drm_private_obj *obj)
struct drm_private_state *	drm_atomic_get_old_private_obj_state (const struct drm_atomic_commit *state, struct drm_private_obj *obj)
struct drm_private_state *	drm_atomic_get_new_private_obj_state (const struct drm_atomic_commit *state, struct drm_private_obj *obj)
struct drm_connector *	drm_atomic_get_old_connector_for_encoder (const struct drm_atomic_commit *state, struct drm_encoder *encoder)
struct drm_connector *	drm_atomic_get_new_connector_for_encoder (const struct drm_atomic_commit *state, struct drm_encoder *encoder)
struct drm_connector *	drm_atomic_get_connector_for_encoder (const struct drm_encoder *encoder, struct drm_modeset_acquire_ctx *ctx)
struct drm_crtc *	drm_atomic_get_old_crtc_for_encoder (struct drm_atomic_commit *state, struct drm_encoder *encoder)
struct drm_crtc *	drm_atomic_get_new_crtc_for_encoder (struct drm_atomic_commit *state, struct drm_encoder *encoder)
int __must_check	drm_atomic_add_encoder_bridges (struct drm_atomic_commit *state, struct drm_encoder *encoder)
int __must_check	drm_atomic_add_affected_connectors (struct drm_atomic_commit *state, struct drm_crtc *crtc)
int __must_check	drm_atomic_add_affected_planes (struct drm_atomic_commit *state, struct drm_crtc *crtc)
int __must_check	drm_atomic_add_affected_colorops (struct drm_atomic_commit *state, struct drm_plane *plane)
int __must_check	drm_atomic_check_only (struct drm_atomic_commit *state)
int __must_check	drm_atomic_commit (struct drm_atomic_commit *state)
int __must_check	drm_atomic_nonblocking_commit (struct drm_atomic_commit *state)
void	drm_state_dump (struct drm_device *dev, struct drm_printer *p)
struct drm_bridge_state *	drm_atomic_get_bridge_state (struct drm_atomic_commit *state, struct drm_bridge *bridge)
struct drm_bridge_state *	drm_atomic_get_old_bridge_state (const struct drm_atomic_commit *state, struct drm_bridge *bridge)
struct drm_bridge_state *	drm_atomic_get_new_bridge_state (const struct drm_atomic_commit *state, struct drm_bridge *bridge)

Macro Definition Documentation

drm_for_each_privobj

#define drm_for_each_privobj	(		privobj,
			dev
	)		list_for_each_entry(privobj, &(dev)->mode_config.privobj_list, head)

drm_for_each_privobj() - private object iterator

@privobj: pointer to the current private object. Updated after each iteration @dev: the DRM device we want get private objects from

Allows one to iterate over all private objects attached to @dev

for_each_new_colorop_in_state

#define for_each_new_colorop_in_state	(		__state,
			colorop,
			new_colorop_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_colorop;       \
         (__i)++)                           \
        for_each_if ((__state)->colorops[__i].ptr &&        \
                 ((colorop) = (__state)->colorops[__i].ptr, \
                  (void)(colorop) /* Only to avoid unused-but-set-variable warning */, \
                  (new_colorop_state) = (__state)->colorops[__i].new_state,\
                  (void)(new_colorop_state) /* Only to avoid unused-but-set-variable warning */, 1))

for_each_new_colorop_in_state - iterate over all colorops in an atomic update @__state: &struct drm_atomic_commit pointer @colorop: &struct drm_colorop iteration cursor @new_colorop_state: &struct drm_colorop_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all colorops in an atomic update, tracking new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

for_each_new_connector_in_state

#define for_each_new_connector_in_state	(		__state,
			connector,
			new_connector_state,
			__i
	)

Value:

    for ((__i) = 0;                             \
         (__i) < (__state)->num_connector;                  \
         (__i)++)                               \
        for_each_if ((__state)->connectors[__i].ptr &&          \
                 ((connector) = (__state)->connectors[__i].ptr, \
                 (void)(connector) /* Only to avoid unused-but-set-variable warning */, \
                 (new_connector_state) = (__state)->connectors[__i].new_state, \
                 (void)(new_connector_state) /* Only to avoid unused-but-set-variable warning */, 1))

for_each_new_connector_in_state - iterate over all connectors in an atomic update @__state: &struct drm_atomic_commit pointer @connector: &struct drm_connector iteration cursor @new_connector_state: &struct drm_connector_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all connectors in an atomic update, tracking only the new state. This is useful in enable functions, where we need the new state the hardware should be in when the atomic commit operation has completed.

for_each_new_crtc_in_state

#define for_each_new_crtc_in_state	(		__state,
			crtc,
			new_crtc_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_crtc;      \
         (__i)++)                           \
        for_each_if ((__state)->crtcs[__i].ptr &&       \
                 ((crtc) = (__state)->crtcs[__i].ptr,   \
                 (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
                 (new_crtc_state) = (__state)->crtcs[__i].new_state, \
                 (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1))

for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update @__state: &struct drm_atomic_commit pointer @crtc: &struct drm_crtc iteration cursor @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all CRTCs in an atomic update, tracking only the new state. This is useful in enable functions, where we need the new state the hardware should be in when the atomic commit operation has completed.

for_each_new_plane_in_state

#define for_each_new_plane_in_state	(		__state,
			plane,
			new_plane_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_total_plane;   \
         (__i)++)                           \
        for_each_if ((__state)->planes[__i].ptr &&      \
                 ((plane) = (__state)->planes[__i].ptr, \
                  (void)(plane) /* Only to avoid unused-but-set-variable warning */, \
                  (new_plane_state) = (__state)->planes[__i].new_state, \
                  (void)(new_plane_state) /* Only to avoid unused-but-set-variable warning */, 1))

for_each_new_plane_in_state - iterate over all planes in an atomic update @__state: &struct drm_atomic_commit pointer @plane: &struct drm_plane iteration cursor @new_plane_state: &struct drm_plane_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all planes in an atomic update, tracking only the new state. This is useful in enable functions, where we need the new state the hardware should be in when the atomic commit operation has completed.

for_each_new_plane_in_state_reverse

#define for_each_new_plane_in_state_reverse	(		__state,
			plane,
			new_plane_state,
			__i
	)

Value:

    for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \
         (__i) >= 0;                        \
         (__i)--)                           \
        for_each_if ((__state)->planes[__i].ptr &&      \
                 ((plane) = (__state)->planes[__i].ptr, \
                  (new_plane_state) = (__state)->planes[__i].new_state, 1))

for_each_new_plane_in_state_reverse - other than only tracking new state, it's the same as for_each_oldnew_plane_in_state_reverse @__state: &struct drm_atomic_commit pointer @plane: &struct drm_plane iteration cursor @new_plane_state: &struct drm_plane_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

for_each_new_private_obj_in_state

#define for_each_new_private_obj_in_state	(		__state,
			obj,
			new_obj_state,
			__i
	)

Value:

    for ((__i) = 0; \
         (__i) < (__state)->num_private_objs && \
             ((obj) = (__state)->private_objs[__i].ptr, \
              (void)(obj) /* Only to avoid unused-but-set-variable warning */, \
              (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \
         (__i)++)

for_each_new_private_obj_in_state - iterate over all private objects in an atomic update @__state: &struct drm_atomic_commit pointer @obj: &struct drm_private_obj iteration cursor @new_obj_state: &struct drm_private_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all private objects in an atomic update, tracking only the new state. This is useful in enable functions, where we need the new state the hardware should be in when the atomic commit operation has completed.

for_each_old_connector_in_state

#define for_each_old_connector_in_state	(		__state,
			connector,
			old_connector_state,
			__i
	)

Value:

    for ((__i) = 0;                             \
         (__i) < (__state)->num_connector;                  \
         (__i)++)                               \
        for_each_if ((__state)->connectors[__i].ptr &&          \
                 ((connector) = (__state)->connectors[__i].ptr, \
                 (void)(connector) /* Only to avoid unused-but-set-variable warning */, \
                 (old_connector_state) = (__state)->connectors[__i].old_state, 1))

for_each_old_connector_in_state - iterate over all connectors in an atomic update @__state: &struct drm_atomic_commit pointer @connector: &struct drm_connector iteration cursor @old_connector_state: &struct drm_connector_state iteration cursor for the old state @__i: int iteration cursor, for macro-internal use

This iterates over all connectors in an atomic update, tracking only the old state. This is useful in disable functions, where we need the old state the hardware is still in.

for_each_old_crtc_in_state

#define for_each_old_crtc_in_state	(		__state,
			crtc,
			old_crtc_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_crtc;      \
         (__i)++)                           \
        for_each_if ((__state)->crtcs[__i].ptr &&       \
                 ((crtc) = (__state)->crtcs[__i].ptr,   \
                 (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
                 (old_crtc_state) = (__state)->crtcs[__i].old_state, 1))

for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update @__state: &struct drm_atomic_commit pointer @crtc: &struct drm_crtc iteration cursor @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state @__i: int iteration cursor, for macro-internal use

This iterates over all CRTCs in an atomic update, tracking only the old state. This is useful in disable functions, where we need the old state the hardware is still in.

for_each_old_plane_in_state

#define for_each_old_plane_in_state	(		__state,
			plane,
			old_plane_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_total_plane;   \
         (__i)++)                           \
        for_each_if ((__state)->planes[__i].ptr &&      \
                 ((plane) = (__state)->planes[__i].ptr, \
                  (old_plane_state) = (__state)->planes[__i].old_state, 1))

for_each_old_plane_in_state - iterate over all planes in an atomic update @__state: &struct drm_atomic_commit pointer @plane: &struct drm_plane iteration cursor @old_plane_state: &struct drm_plane_state iteration cursor for the old state @__i: int iteration cursor, for macro-internal use

This iterates over all planes in an atomic update, tracking only the old state. This is useful in disable functions, where we need the old state the hardware is still in.

for_each_old_private_obj_in_state

#define for_each_old_private_obj_in_state	(		__state,
			obj,
			old_obj_state,
			__i
	)

Value:

    for ((__i) = 0; \
         (__i) < (__state)->num_private_objs && \
             ((obj) = (__state)->private_objs[__i].ptr, \
              (old_obj_state) = (__state)->private_objs[__i].old_state, 1); \
         (__i)++)

for_each_old_private_obj_in_state - iterate over all private objects in an atomic update @__state: &struct drm_atomic_commit pointer @obj: &struct drm_private_obj iteration cursor @old_obj_state: &struct drm_private_state iteration cursor for the old state @__i: int iteration cursor, for macro-internal use

This iterates over all private objects in an atomic update, tracking only the old state. This is useful in disable functions, where we need the old state the hardware is still in.

for_each_oldnew_colorop_in_state

#define for_each_oldnew_colorop_in_state	(		__state,
			colorop,
			old_colorop_state,
			new_colorop_state,
			__i
	)

Value:

    for ((__i) = 0;                             \
         (__i) < (__state)->dev->mode_config.num_colorop;           \
         (__i)++)                               \
        for_each_if ((__state)->colorops[__i].ptr &&            \
                 ((colorop) = (__state)->colorops[__i].ptr,     \
                  (void)(colorop) /* Only to avoid unused-but-set-variable warning */, \
                  (old_colorop_state) = (__state)->colorops[__i].old_state,\
                  (new_colorop_state) = (__state)->colorops[__i].new_state, 1))

for_each_oldnew_colorop_in_state - iterate over all colorops in an atomic update @__state: &struct drm_atomic_commit pointer @colorop: &struct drm_colorop iteration cursor @old_colorop_state: &struct drm_colorop_state iteration cursor for the old state @new_colorop_state: &struct drm_colorop_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all colorops in an atomic update, tracking both old and new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

for_each_oldnew_connector_in_state

#define for_each_oldnew_connector_in_state	(		__state,
			connector,
			old_connector_state,
			new_connector_state,
			__i
	)

Value:

    for ((__i) = 0;                             \
         (__i) < (__state)->num_connector;                  \
         (__i)++)                               \
        for_each_if ((__state)->connectors[__i].ptr &&          \
                 ((connector) = (__state)->connectors[__i].ptr, \
                 (void)(connector) /* Only to avoid unused-but-set-variable warning */, \
                 (old_connector_state) = (__state)->connectors[__i].old_state,  \
                 (new_connector_state) = (__state)->connectors[__i].new_state, 1))

for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update @__state: &struct drm_atomic_commit pointer @connector: &struct drm_connector iteration cursor @old_connector_state: &struct drm_connector_state iteration cursor for the old state @new_connector_state: &struct drm_connector_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all connectors in an atomic update, tracking both old and new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

for_each_oldnew_crtc_in_state

#define for_each_oldnew_crtc_in_state	(		__state,
			crtc,
			old_crtc_state,
			new_crtc_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_crtc;      \
         (__i)++)                           \
        for_each_if ((__state)->crtcs[__i].ptr &&       \
                 ((crtc) = (__state)->crtcs[__i].ptr,   \
                  (void)(crtc) /* Only to avoid unused-but-set-variable warning */, \
                 (old_crtc_state) = (__state)->crtcs[__i].old_state, \
                 (void)(old_crtc_state) /* Only to avoid unused-but-set-variable warning */, \
                 (new_crtc_state) = (__state)->crtcs[__i].new_state, \
                 (void)(new_crtc_state) /* Only to avoid unused-but-set-variable warning */, 1))

for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update @__state: &struct drm_atomic_commit pointer @crtc: &struct drm_crtc iteration cursor @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all CRTCs in an atomic update, tracking both old and new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

for_each_oldnew_plane_in_state

#define for_each_oldnew_plane_in_state	(		__state,
			plane,
			old_plane_state,
			new_plane_state,
			__i
	)

Value:

    for ((__i) = 0;                         \
         (__i) < (__state)->dev->mode_config.num_total_plane;   \
         (__i)++)                           \
        for_each_if ((__state)->planes[__i].ptr &&      \
                 ((plane) = (__state)->planes[__i].ptr, \
                  (void)(plane) /* Only to avoid unused-but-set-variable warning */, \
                  (old_plane_state) = (__state)->planes[__i].old_state,\
                  (new_plane_state) = (__state)->planes[__i].new_state, 1))

for_each_oldnew_plane_in_state - iterate over all planes in an atomic update @__state: &struct drm_atomic_commit pointer @plane: &struct drm_plane iteration cursor @old_plane_state: &struct drm_plane_state iteration cursor for the old state @new_plane_state: &struct drm_plane_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all planes in an atomic update, tracking both old and new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

for_each_oldnew_plane_in_state_reverse

#define for_each_oldnew_plane_in_state_reverse	(		__state,
			plane,
			old_plane_state,
			new_plane_state,
			__i
	)

Value:

    for ((__i) = ((__state)->dev->mode_config.num_total_plane - 1); \
         (__i) >= 0;                        \
         (__i)--)                           \
        for_each_if ((__state)->planes[__i].ptr &&      \
                 ((plane) = (__state)->planes[__i].ptr, \
                  (old_plane_state) = (__state)->planes[__i].old_state,\
                  (new_plane_state) = (__state)->planes[__i].new_state, 1))

for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic update in reverse order @__state: &struct drm_atomic_commit pointer @plane: &struct drm_plane iteration cursor @old_plane_state: &struct drm_plane_state iteration cursor for the old state @new_plane_state: &struct drm_plane_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all planes in an atomic update in reverse order, tracking both old and new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

for_each_oldnew_private_obj_in_state

#define for_each_oldnew_private_obj_in_state	(		__state,
			obj,
			old_obj_state,
			new_obj_state,
			__i
	)

Value:

    for ((__i) = 0; \
         (__i) < (__state)->num_private_objs && \
             ((obj) = (__state)->private_objs[__i].ptr, \
              (old_obj_state) = (__state)->private_objs[__i].old_state, \
              (new_obj_state) = (__state)->private_objs[__i].new_state, 1); \
         (__i)++)

for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update @__state: &struct drm_atomic_commit pointer @obj: &struct drm_private_obj iteration cursor @old_obj_state: &struct drm_private_state iteration cursor for the old state @new_obj_state: &struct drm_private_state iteration cursor for the new state @__i: int iteration cursor, for macro-internal use

This iterates over all private objects in an atomic update, tracking both old and new state. This is useful in places where the state delta needs to be considered, for example in atomic check functions.

Function Documentation

__drm_atomic_commit_free()

void __drm_atomic_commit_free

(

struct kref *

ref

)

__drm_crtc_commit_free()

void __drm_crtc_commit_free

(

struct kref *

kref

)

drm_atomic_add_affected_colorops()

int __must_check drm_atomic_add_affected_colorops	(	struct drm_atomic_commit *	state,
		struct drm_plane *	plane
	)

drm_atomic_add_affected_connectors()

int __must_check drm_atomic_add_affected_connectors	(	struct drm_atomic_commit *	state,
		struct drm_crtc *	crtc
	)

drm_atomic_add_affected_planes()

int __must_check drm_atomic_add_affected_planes	(	struct drm_atomic_commit *	state,
		struct drm_crtc *	crtc
	)

drm_atomic_add_encoder_bridges()

int __must_check drm_atomic_add_encoder_bridges	(	struct drm_atomic_commit *	state,
		struct drm_encoder *	encoder
	)

drm_atomic_check_only()

int __must_check drm_atomic_check_only

(

struct drm_atomic_commit *

state

)

drm_atomic_commit()

int __must_check drm_atomic_commit

(

struct drm_atomic_commit *

state

)

drm_atomic_commit_alloc()

struct drm_atomic_commit *__must_check drm_atomic_commit_alloc

(

struct drm_device *

dev

)

drm_atomic_commit_clear()

void drm_atomic_commit_clear

(

struct drm_atomic_commit *

state

)

drm_atomic_commit_default_clear()

void drm_atomic_commit_default_clear

(

struct drm_atomic_commit *

state

)

drm_atomic_commit_default_release()

void drm_atomic_commit_default_release

(

struct drm_atomic_commit *

state

)

drm_atomic_commit_init()

int __must_check drm_atomic_commit_init	(	struct drm_device *	dev,
		struct drm_atomic_commit *	state
	)

drm_atomic_get_bridge_state()

struct drm_bridge_state * drm_atomic_get_bridge_state	(	struct drm_atomic_commit *	state,
		struct drm_bridge *	bridge
	)

drm_atomic_get_colorop_state()

struct drm_colorop_state * drm_atomic_get_colorop_state	(	struct drm_atomic_commit *	state,
		struct drm_colorop *	colorop
	)

drm_atomic_get_connector_for_encoder()

struct drm_connector * drm_atomic_get_connector_for_encoder	(	const struct drm_encoder *	encoder,
		struct drm_modeset_acquire_ctx *	ctx
	)

drm_atomic_get_connector_state()

struct drm_connector_state *__must_check drm_atomic_get_connector_state	(	struct drm_atomic_commit *	state,
		struct drm_connector *	connector
	)

drm_atomic_get_crtc_state()

struct drm_crtc_state *__must_check drm_atomic_get_crtc_state	(	struct drm_atomic_commit *	state,
		struct drm_crtc *	crtc
	)

drm_atomic_get_new_bridge_state()

struct drm_bridge_state * drm_atomic_get_new_bridge_state	(	const struct drm_atomic_commit *	state,
		struct drm_bridge *	bridge
	)

drm_atomic_get_new_colorop_state()

struct drm_colorop_state * drm_atomic_get_new_colorop_state	(	struct drm_atomic_commit *	state,
		struct drm_colorop *	colorop
	)

drm_atomic_get_new_connector_for_encoder()

struct drm_connector * drm_atomic_get_new_connector_for_encoder	(	const struct drm_atomic_commit *	state,
		struct drm_encoder *	encoder
	)

drm_atomic_get_new_crtc_for_encoder()

struct drm_crtc * drm_atomic_get_new_crtc_for_encoder	(	struct drm_atomic_commit *	state,
		struct drm_encoder *	encoder
	)

drm_atomic_get_new_private_obj_state()

struct drm_private_state * drm_atomic_get_new_private_obj_state	(	const struct drm_atomic_commit *	state,
		struct drm_private_obj *	obj
	)

drm_atomic_get_old_bridge_state()

struct drm_bridge_state * drm_atomic_get_old_bridge_state	(	const struct drm_atomic_commit *	state,
		struct drm_bridge *	bridge
	)

drm_atomic_get_old_colorop_state()

struct drm_colorop_state * drm_atomic_get_old_colorop_state	(	struct drm_atomic_commit *	state,
		struct drm_colorop *	colorop
	)

drm_atomic_get_old_connector_for_encoder()

struct drm_connector * drm_atomic_get_old_connector_for_encoder	(	const struct drm_atomic_commit *	state,
		struct drm_encoder *	encoder
	)

drm_atomic_get_old_crtc_for_encoder()

struct drm_crtc * drm_atomic_get_old_crtc_for_encoder	(	struct drm_atomic_commit *	state,
		struct drm_encoder *	encoder
	)

drm_atomic_get_old_private_obj_state()

struct drm_private_state * drm_atomic_get_old_private_obj_state	(	const struct drm_atomic_commit *	state,
		struct drm_private_obj *	obj
	)

drm_atomic_get_plane_state()

struct drm_plane_state *__must_check drm_atomic_get_plane_state	(	struct drm_atomic_commit *	state,
		struct drm_plane *	plane
	)

drm_atomic_get_private_obj_state()

struct drm_private_state *__must_check drm_atomic_get_private_obj_state	(	struct drm_atomic_commit *	state,
		struct drm_private_obj *	obj
	)

drm_atomic_nonblocking_commit()

int __must_check drm_atomic_nonblocking_commit

(

struct drm_atomic_commit *

state

)

drm_atomic_private_obj_fini()

void drm_atomic_private_obj_fini

(

struct drm_private_obj *

obj

)

drm_atomic_private_obj_init()

int drm_atomic_private_obj_init	(	struct drm_device *	dev,
		struct drm_private_obj *	obj,
		const struct drm_private_state_funcs *	funcs
	)

drm_crtc_commit_wait()

int drm_crtc_commit_wait

(

struct drm_crtc_commit *

commit

)

drm_state_dump()

void drm_state_dump	(	struct drm_device *	dev,
		struct drm_printer *	p
	)