1592 lines · 45.6 KB · C
RawDownload
/* * Copyright (C) 2014 Red Hat * Copyright (C) 2014 Intel Corp. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. * * Authors: * Rob Clark <robdclark@gmail.com> * Daniel Vetter <daniel.vetter@ffwll.ch> */  #include <drm/drmP.h>#include <drm/drm_atomic.h>#include <drm/drm_plane_helper.h> /** * drm_atomic_state_default_release - * release memory initialized by drm_atomic_state_init * @state: atomic state * * Free all the memory allocated by drm_atomic_state_init. * This is useful for drivers that subclass the atomic state. */void drm_atomic_state_default_release(struct drm_atomic_state *state){	kfree(state->connectors);	kfree(state->connector_states);	kfree(state->crtcs);	kfree(state->crtc_states);	kfree(state->planes);	kfree(state->plane_states);}EXPORT_SYMBOL(drm_atomic_state_default_release); /** * drm_atomic_state_init - init new atomic state * @dev: DRM device * @state: atomic state * * Default implementation for filling in a new atomic state. * This is useful for drivers that subclass the atomic state. */intdrm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state){	/* TODO legacy paths should maybe do a better job about	 * setting this appropriately?	 */	state->allow_modeset = true; 	state->num_connector = ACCESS_ONCE(dev->mode_config.num_connector); 	state->crtcs = kcalloc(dev->mode_config.num_crtc,			       sizeof(*state->crtcs), GFP_KERNEL);	if (!state->crtcs)		goto fail;	state->crtc_states = kcalloc(dev->mode_config.num_crtc,				     sizeof(*state->crtc_states), GFP_KERNEL);	if (!state->crtc_states)		goto fail;	state->planes = kcalloc(dev->mode_config.num_total_plane,				sizeof(*state->planes), GFP_KERNEL);	if (!state->planes)		goto fail;	state->plane_states = kcalloc(dev->mode_config.num_total_plane,				      sizeof(*state->plane_states), GFP_KERNEL);	if (!state->plane_states)		goto fail;	state->connectors = kcalloc(state->num_connector,				    sizeof(*state->connectors),				    GFP_KERNEL);	if (!state->connectors)		goto fail;	state->connector_states = kcalloc(state->num_connector,					  sizeof(*state->connector_states),					  GFP_KERNEL);	if (!state->connector_states)		goto fail; 	state->dev = dev; 	DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state); 	return 0;fail:	drm_atomic_state_default_release(state);	return -ENOMEM;}EXPORT_SYMBOL(drm_atomic_state_init); /** * drm_atomic_state_alloc - allocate atomic state * @dev: DRM device * * This allocates an empty atomic state to track updates. */struct drm_atomic_state *drm_atomic_state_alloc(struct drm_device *dev){	struct drm_mode_config *config = &dev->mode_config;	struct drm_atomic_state *state; 	if (!config->funcs->atomic_state_alloc) {		state = kzalloc(sizeof(*state), GFP_KERNEL);		if (!state)			return NULL;		if (drm_atomic_state_init(dev, state) < 0) {			kfree(state);			return NULL;		}		return state;	} 	return config->funcs->atomic_state_alloc(dev);}EXPORT_SYMBOL(drm_atomic_state_alloc); /** * drm_atomic_state_default_clear - clear base atomic state * @state: atomic state * * Default implementation for clearing atomic state. * This is useful for drivers that subclass the atomic state. */void drm_atomic_state_default_clear(struct drm_atomic_state *state){	struct drm_device *dev = state->dev;	struct drm_mode_config *config = &dev->mode_config;	int i; 	DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state); 	for (i = 0; i < state->num_connector; i++) {		struct drm_connector *connector = state->connectors[i]; 		if (!connector)			continue; 		WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 		connector->funcs->atomic_destroy_state(connector,						       state->connector_states[i]);		state->connectors[i] = NULL;		state->connector_states[i] = NULL;	} 	for (i = 0; i < config->num_crtc; i++) {		struct drm_crtc *crtc = state->crtcs[i]; 		if (!crtc)			continue; 		crtc->funcs->atomic_destroy_state(crtc,						  state->crtc_states[i]);		state->crtcs[i] = NULL;		state->crtc_states[i] = NULL;	} 	for (i = 0; i < config->num_total_plane; i++) {		struct drm_plane *plane = state->planes[i]; 		if (!plane)			continue; 		plane->funcs->atomic_destroy_state(plane,						   state->plane_states[i]);		state->planes[i] = NULL;		state->plane_states[i] = NULL;	}}EXPORT_SYMBOL(drm_atomic_state_default_clear); /** * drm_atomic_state_clear - clear state object * @state: atomic state * * When the w/w mutex algorithm detects a deadlock we need to back off and drop * all locks. So someone else could sneak in and change the current modeset * configuration. Which means that all the state assembled in @state is no * longer an atomic update to the current state, but to some arbitrary earlier * state. Which could break assumptions the driver's ->atomic_check likely * relies on. * * Hence we must clear all cached state and completely start over, using this * function. */void drm_atomic_state_clear(struct drm_atomic_state *state){	struct drm_device *dev = state->dev;	struct drm_mode_config *config = &dev->mode_config; 	if (config->funcs->atomic_state_clear)		config->funcs->atomic_state_clear(state);	else		drm_atomic_state_default_clear(state);}EXPORT_SYMBOL(drm_atomic_state_clear); /** * drm_atomic_state_free - free all memory for an atomic state * @state: atomic state to deallocate * * This frees all memory associated with an atomic state, including all the * per-object state for planes, crtcs and connectors. */void drm_atomic_state_free(struct drm_atomic_state *state){	struct drm_device *dev;	struct drm_mode_config *config; 	if (!state)		return; 	dev = state->dev;	config = &dev->mode_config; 	drm_atomic_state_clear(state); 	DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state); 	if (config->funcs->atomic_state_free) {		config->funcs->atomic_state_free(state);	} else {		drm_atomic_state_default_release(state);		kfree(state);	}}EXPORT_SYMBOL(drm_atomic_state_free); /** * drm_atomic_get_crtc_state - get crtc state * @state: global atomic state object * @crtc: crtc to get state object for * * This function returns the crtc state for the given crtc, allocating it if * needed. It will also grab the relevant crtc lock to make sure that the state * is consistent. * * Returns: * * Either the allocated state or the error code encoded into the pointer. When * the error is EDEADLK then the w/w mutex code has detected a deadlock and the * entire atomic sequence must be restarted. All other errors are fatal. */struct drm_crtc_state *drm_atomic_get_crtc_state(struct drm_atomic_state *state,			  struct drm_crtc *crtc){	int ret, index = drm_crtc_index(crtc);	struct drm_crtc_state *crtc_state; 	crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);	if (crtc_state)		return crtc_state; 	ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);	if (ret)		return ERR_PTR(ret); 	crtc_state = crtc->funcs->atomic_duplicate_state(crtc);	if (!crtc_state)		return ERR_PTR(-ENOMEM); 	state->crtc_states[index] = crtc_state;	state->crtcs[index] = crtc;	crtc_state->state = state; 	DRM_DEBUG_ATOMIC("Added [CRTC:%d] %p state to %p\n",			 crtc->base.id, crtc_state, state); 	return crtc_state;}EXPORT_SYMBOL(drm_atomic_get_crtc_state); /** * drm_atomic_set_mode_for_crtc - set mode for CRTC * @state: the CRTC whose incoming state to update * @mode: kernel-internal mode to use for the CRTC, or NULL to disable * * Set a mode (originating from the kernel) on the desired CRTC state. Does * not change any other state properties, including enable, active, or * mode_changed. * * RETURNS: * Zero on success, error code on failure. Cannot return -EDEADLK. */int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,				 struct drm_display_mode *mode){	struct drm_mode_modeinfo umode; 	/* Early return for no change. */	if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)		return 0; 	if (state->mode_blob)		drm_property_unreference_blob(state->mode_blob);	state->mode_blob = NULL; 	if (mode) {		drm_mode_convert_to_umode(&umode, mode);		state->mode_blob =			drm_property_create_blob(state->crtc->dev,		                                 sizeof(umode),		                                 &umode);		if (IS_ERR(state->mode_blob))			return PTR_ERR(state->mode_blob); 		drm_mode_copy(&state->mode, mode);		state->enable = true;		DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",				 mode->name, state);	} else {		memset(&state->mode, 0, sizeof(state->mode));		state->enable = false;		DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",				 state);	} 	return 0;}EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc); /** * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC * @state: the CRTC whose incoming state to update * @blob: pointer to blob property to use for mode * * Set a mode (originating from a blob property) on the desired CRTC state. * This function will take a reference on the blob property for the CRTC state, * and release the reference held on the state's existing mode property, if any * was set. * * RETURNS: * Zero on success, error code on failure. Cannot return -EDEADLK. */int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,                                      struct drm_property_blob *blob){	if (blob == state->mode_blob)		return 0; 	if (state->mode_blob)		drm_property_unreference_blob(state->mode_blob);	state->mode_blob = NULL; 	if (blob) {		if (blob->length != sizeof(struct drm_mode_modeinfo) ||		    drm_mode_convert_umode(&state->mode,		                           (const struct drm_mode_modeinfo *)		                            blob->data))			return -EINVAL; 		state->mode_blob = drm_property_reference_blob(blob);		state->enable = true;		DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",				 state->mode.name, state);	} else {		memset(&state->mode, 0, sizeof(state->mode));		state->enable = false;		DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",				 state);	} 	return 0;}EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc); /** * drm_atomic_crtc_set_property - set property on CRTC * @crtc: the drm CRTC to set a property on * @state: the state object to update with the new property value * @property: the property to set * @val: the new property value * * Use this instead of calling crtc->atomic_set_property directly. * This function handles generic/core properties and calls out to * driver's ->atomic_set_property() for driver properties.  To ensure * consistent behavior you must call this function rather than the * driver hook directly. * * RETURNS: * Zero on success, error code on failure */int drm_atomic_crtc_set_property(struct drm_crtc *crtc,		struct drm_crtc_state *state, struct drm_property *property,		uint64_t val){	struct drm_device *dev = crtc->dev;	struct drm_mode_config *config = &dev->mode_config;	int ret; 	if (property == config->prop_active)		state->active = val;	else if (property == config->prop_mode_id) {		struct drm_property_blob *mode =			drm_property_lookup_blob(dev, val);		ret = drm_atomic_set_mode_prop_for_crtc(state, mode);		if (mode)			drm_property_unreference_blob(mode);		return ret;	}	else if (crtc->funcs->atomic_set_property)		return crtc->funcs->atomic_set_property(crtc, state, property, val);	else		return -EINVAL; 	return 0;}EXPORT_SYMBOL(drm_atomic_crtc_set_property); /* * This function handles generic/core properties and calls out to * driver's ->atomic_get_property() for driver properties.  To ensure * consistent behavior you must call this function rather than the * driver hook directly. */int drm_atomic_crtc_get_property(struct drm_crtc *crtc,		const struct drm_crtc_state *state,		struct drm_property *property, uint64_t *val){	struct drm_device *dev = crtc->dev;	struct drm_mode_config *config = &dev->mode_config; 	if (property == config->prop_active)		*val = state->active;	else if (property == config->prop_mode_id)		*val = (state->mode_blob) ? state->mode_blob->base.id : 0;	else if (crtc->funcs->atomic_get_property)		return crtc->funcs->atomic_get_property(crtc, state, property, val);	else		return -EINVAL; 	return 0;} /** * drm_atomic_crtc_check - check crtc state * @crtc: crtc to check * @state: crtc state to check * * Provides core sanity checks for crtc state. * * RETURNS: * Zero on success, error code on failure */static int drm_atomic_crtc_check(struct drm_crtc *crtc,		struct drm_crtc_state *state){	/* NOTE: we explicitly don't enforce constraints such as primary	 * layer covering entire screen, since that is something we want	 * to allow (on hw that supports it).  For hw that does not, it	 * should be checked in driver's crtc->atomic_check() vfunc.	 *	 * TODO: Add generic modeset state checks once we support those.	 */ 	if (state->active && !state->enable) {		DRM_DEBUG_ATOMIC("[CRTC:%d] active without enabled\n",				 crtc->base.id);		return -EINVAL;	} 	/* The state->enable vs. state->mode_blob checks can be WARN_ON,	 * as this is a kernel-internal detail that userspace should never	 * be able to trigger. */	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&	    WARN_ON(state->enable && !state->mode_blob)) {		DRM_DEBUG_ATOMIC("[CRTC:%d] enabled without mode blob\n",				 crtc->base.id);		return -EINVAL;	} 	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&	    WARN_ON(!state->enable && state->mode_blob)) {		DRM_DEBUG_ATOMIC("[CRTC:%d] disabled with mode blob\n",				 crtc->base.id);		return -EINVAL;	} 	return 0;} 

Lines 1–500 of 1592.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t