/* * Copyright (C) 2014 Red Hat * Copyright (C) 2014 Intel Corp. * Copyright (c) 2020-2021, The Linux Foundation. All rights reserved. * * 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 <linux/sync_file.h> #include <drm/drm_atomic.h>#include <drm/drm_atomic_uapi.h>#include <drm/drm_blend.h>#include <drm/drm_bridge.h>#include <drm/drm_debugfs.h>#include <drm/drm_device.h>#include <drm/drm_drv.h>#include <drm/drm_file.h>#include <drm/drm_fourcc.h>#include <drm/drm_framebuffer.h>#include <drm/drm_mode.h>#include <drm/drm_print.h>#include <drm/drm_writeback.h> #include "drm_crtc_internal.h"#include "drm_internal.h" void __drm_crtc_commit_free(struct kref *kref){	struct drm_crtc_commit *commit =		container_of(kref, struct drm_crtc_commit, ref); 	kfree(commit);}EXPORT_SYMBOL(__drm_crtc_commit_free); /** * drm_crtc_commit_wait - Waits for a commit to complete * @commit: &drm_crtc_commit to wait for * * Waits for a given &drm_crtc_commit to be programmed into the * hardware and flipped to. * * Returns: * 0 on success, a negative error code otherwise. */int drm_crtc_commit_wait(struct drm_crtc_commit *commit){	unsigned long timeout = 10 * HZ;	int ret; 	if (!commit)		return 0; 	ret = wait_for_completion_timeout(&commit->hw_done, timeout);	if (!ret) {		drm_err(commit->crtc->dev, "hw_done timed out\n");		return -ETIMEDOUT;	} 	/*	 * Currently no support for overwriting flips, hence	 * stall for previous one to execute completely.	 */	ret = wait_for_completion_timeout(&commit->flip_done, timeout);	if (!ret) {		drm_err(commit->crtc->dev, "flip_done timed out\n");		return -ETIMEDOUT;	} 	return 0;}EXPORT_SYMBOL(drm_crtc_commit_wait); /** * 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 should only be used by drivers which are still subclassing * &drm_atomic_state and haven't switched to &drm_private_state yet. */void drm_atomic_state_default_release(struct drm_atomic_state *state){	kfree(state->connectors);	kfree(state->crtcs);	kfree(state->planes);	kfree(state->private_objs);}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 should only be used by drivers which are still subclassing * &drm_atomic_state and haven't switched to &drm_private_state yet. */intdrm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state){	kref_init(&state->ref); 	/* TODO legacy paths should maybe do a better job about	 * setting this appropriately?	 */	state->allow_modeset = true; 	state->crtcs = kcalloc(dev->mode_config.num_crtc,			       sizeof(*state->crtcs), GFP_KERNEL);	if (!state->crtcs)		goto fail;	state->planes = kcalloc(dev->mode_config.num_total_plane,				sizeof(*state->planes), GFP_KERNEL);	if (!state->planes)		goto fail; 	/*	 * Because drm_atomic_state can be committed asynchronously we need our	 * own reference and cannot rely on the on implied by drm_file in the	 * ioctl call.	 */	drm_dev_get(dev);	state->dev = dev; 	drm_dbg_atomic(dev, "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; 	if (!config->funcs->atomic_state_alloc) {		struct drm_atomic_state *state; 		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 should only be used by drivers which are still subclassing * &drm_atomic_state and haven't switched to &drm_private_state yet. */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_dbg_atomic(dev, "Clearing atomic state %p\n", state); 	for (i = 0; i < state->num_connector; i++) {		struct drm_connector *connector = state->connectors[i].ptr; 		if (!connector)			continue; 		connector->funcs->atomic_destroy_state(connector,						       state->connectors[i].state);		state->connectors[i].ptr = NULL;		state->connectors[i].state = NULL;		state->connectors[i].old_state = NULL;		state->connectors[i].new_state = NULL;		drm_connector_put(connector);	} 	for (i = 0; i < config->num_crtc; i++) {		struct drm_crtc *crtc = state->crtcs[i].ptr; 		if (!crtc)			continue; 		crtc->funcs->atomic_destroy_state(crtc,						  state->crtcs[i].state); 		state->crtcs[i].ptr = NULL;		state->crtcs[i].state = NULL;		state->crtcs[i].old_state = NULL;		state->crtcs[i].new_state = NULL; 		if (state->crtcs[i].commit) {			drm_crtc_commit_put(state->crtcs[i].commit);			state->crtcs[i].commit = NULL;		}	} 	for (i = 0; i < config->num_total_plane; i++) {		struct drm_plane *plane = state->planes[i].ptr; 		if (!plane)			continue; 		plane->funcs->atomic_destroy_state(plane,						   state->planes[i].state);		state->planes[i].ptr = NULL;		state->planes[i].state = NULL;		state->planes[i].old_state = NULL;		state->planes[i].new_state = NULL;	} 	for (i = 0; i < state->num_private_objs; i++) {		struct drm_private_obj *obj = state->private_objs[i].ptr; 		obj->funcs->atomic_destroy_state(obj,						 state->private_objs[i].state);		state->private_objs[i].ptr = NULL;		state->private_objs[i].state = NULL;		state->private_objs[i].old_state = NULL;		state->private_objs[i].new_state = NULL;	}	state->num_private_objs = 0; 	if (state->fake_commit) {		drm_crtc_commit_put(state->fake_commit);		state->fake_commit = 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 * &drm_mode_config_funcs.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 * @ref: This 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 kref *ref){	struct drm_atomic_state *state = container_of(ref, typeof(*state), ref);	struct drm_device *dev = state->dev;	struct drm_mode_config *config = &dev->mode_config; 	drm_atomic_state_clear(state); 	drm_dbg_atomic(state->dev, "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);	} 	drm_dev_put(dev);}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. * * WARNING: Drivers may only add new CRTC states to a @state if * drm_atomic_state.allow_modeset is set, or if it's a driver-internal commit * not created by userspace through an IOCTL call. * * 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; 	WARN_ON(!state->acquire_ctx); 	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->crtcs[index].state = crtc_state;	state->crtcs[index].old_state = crtc->state;	state->crtcs[index].new_state = crtc_state;	state->crtcs[index].ptr = crtc;	crtc_state->state = state; 	drm_dbg_atomic(state->dev, "Added [CRTC:%d:%s] %p state to %p\n",		       crtc->base.id, crtc->name, crtc_state, state); 	return crtc_state;}EXPORT_SYMBOL(drm_atomic_get_crtc_state); static int drm_atomic_crtc_check(const struct drm_crtc_state *old_crtc_state,				 const struct drm_crtc_state *new_crtc_state){	struct drm_crtc *crtc = new_crtc_state->crtc; 	/* 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 (new_crtc_state->active && !new_crtc_state->enable) {		drm_dbg_atomic(crtc->dev,			       "[CRTC:%d:%s] active without enabled\n",			       crtc->base.id, crtc->name);		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(new_crtc_state->enable && !new_crtc_state->mode_blob)) {		drm_dbg_atomic(crtc->dev,			       "[CRTC:%d:%s] enabled without mode blob\n",			       crtc->base.id, crtc->name);		return -EINVAL;	} 	if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&	    WARN_ON(!new_crtc_state->enable && new_crtc_state->mode_blob)) {		drm_dbg_atomic(crtc->dev,			       "[CRTC:%d:%s] disabled with mode blob\n",			       crtc->base.id, crtc->name);		return -EINVAL;	} 	/*	 * Reject event generation for when a CRTC is off and stays off.	 * It wouldn't be hard to implement this, but userspace has a track	 * record of happily burning through 100% cpu (or worse, crash) when the	 * display pipe is suspended. To avoid all that fun just reject updates	 * that ask for events since likely that indicates a bug in the	 * compositor's drawing loop. This is consistent with the vblank IOCTL	 * and legacy page_flip IOCTL which also reject service on a disabled	 * pipe.	 */	if (new_crtc_state->event &&	    !new_crtc_state->active && !old_crtc_state->active) {		drm_dbg_atomic(crtc->dev,			       "[CRTC:%d:%s] requesting event but off\n",			       crtc->base.id, crtc->name);		return -EINVAL;	} 	return 0;} static void drm_atomic_crtc_print_state(struct drm_printer *p,		const struct drm_crtc_state *state){	struct drm_crtc *crtc = state->crtc; 	drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name);	drm_printf(p, "\tenable=%d\n", state->enable);	drm_printf(p, "\tactive=%d\n", state->active);	drm_printf(p, "\tself_refresh_active=%d\n", state->self_refresh_active);	drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed);	drm_printf(p, "\tmode_changed=%d\n", state->mode_changed);	drm_printf(p, "\tactive_changed=%d\n", state->active_changed);	drm_printf(p, "\tconnectors_changed=%d\n", state->connectors_changed);	drm_printf(p, "\tcolor_mgmt_changed=%d\n", state->color_mgmt_changed);	drm_printf(p, "\tplane_mask=%x\n", state->plane_mask);	drm_printf(p, "\tconnector_mask=%x\n", state->connector_mask);	drm_printf(p, "\tencoder_mask=%x\n", state->encoder_mask);	drm_printf(p, "\tmode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(&state->mode)); 	if (crtc->funcs->atomic_print_state)		crtc->funcs->atomic_print_state(p, state);} static int drm_atomic_connector_check(struct drm_connector *connector,		struct drm_connector_state *state){	struct drm_crtc_state *crtc_state;	struct drm_writeback_job *writeback_job = state->writeback_job;	const struct drm_display_info *info = &connector->display_info; 	state->max_bpc = info->bpc ? info->bpc : 8;	if (connector->max_bpc_property)		state->max_bpc = min(state->max_bpc, state->max_requested_bpc); 	if ((connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK) || !writeback_job)		return 0; 	if (writeback_job->fb && !state->crtc) {		drm_dbg_atomic(connector->dev,			       "[CONNECTOR:%d:%s] framebuffer without CRTC\n",			       connector->base.id, connector->name);		return -EINVAL;	} 	if (state->crtc)		crtc_state = drm_atomic_get_existing_crtc_state(state->state,								state->crtc); 	if (writeback_job->fb && !crtc_state->active) {		drm_dbg_atomic(connector->dev,			       "[CONNECTOR:%d:%s] has framebuffer, but [CRTC:%d] is off\n",			       connector->base.id, connector->name,			       state->crtc->base.id);		return -EINVAL;	} 	if (!writeback_job->fb) {		if (writeback_job->out_fence) {			drm_dbg_atomic(connector->dev,				       "[CONNECTOR:%d:%s] requesting out-fence without framebuffer\n",				       connector->base.id, connector->name);			return -EINVAL;		}

Lines 1–500 of 1863. Load more