pci/drm/drm_atomic_helper.c

108 	struct drm_connector *connector;
119 	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
120 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
127 			new_encoder = funcs->atomic_best_encoder(connector,
130 			new_encoder = funcs->best_encoder(connector);
132 			new_encoder = drm_connector_get_single_encoder(connector);
136 				drm_dbg_atomic(connector->dev,
139 					       connector->base.id, connector->name);
163 	drm_for_each_connector_iter(connector, &conn_iter) {
166 		if (drm_atomic_get_new_connector_state(state, connector))
169 		encoder = connector->state->best_encoder;
174 			drm_dbg_atomic(connector->dev,
177 				       connector->state->crtc->base.id,
178 				       connector->state->crtc->name,
179 				       connector->base.id, connector->name);
184 		new_conn_state = drm_atomic_get_connector_state(state, connector);
190 		drm_dbg_atomic(connector->dev,
194 			       connector->base.id, connector->name);
227 		crtc = conn_state->connector->state->crtc;
263 	struct drm_connector *connector;
267 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
291 			 struct drm_connector *connector,
300 	drm_dbg_atomic(connector->dev, "Updating routing for [CONNECTOR:%d:%s]\n",
301 		       connector->base.id, connector->name);
316 		drm_dbg_atomic(connector->dev, "Disabling [CONNECTOR:%d:%s]\n",
317 				connector->base.id, connector->name);
332 	 * Since the connector can be unregistered at any point during an
335 	 * display on a connector that was destroyed after it's been notified,
338 	 * Additionally, we also want to ignore connector registration when
340 	 * there's a chance the connector may have been destroyed during the
344 	 * Last, we want to ignore connector registration when the connector
348 	if (!state->duplicated && drm_connector_is_unregistered(connector) &&
350 		drm_dbg_atomic(connector->dev,
352 			       connector->base.id, connector->name);
356 	funcs = connector->helper_private;
359 		new_encoder = funcs->atomic_best_encoder(connector, state);
361 		new_encoder = funcs->best_encoder(connector);
363 		new_encoder = drm_connector_get_single_encoder(connector);
366 		drm_dbg_atomic(connector->dev,
368 			       connector->base.id, connector->name);
373 		drm_dbg_atomic(connector->dev,
385 		drm_dbg_atomic(connector->dev,
387 			       connector->base.id,
388 			       connector->name,
403 	drm_dbg_atomic(connector->dev,
405 		       connector->base.id,
406 		       connector->name,
420 	struct drm_connector *connector;
433 	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
447 		 * Each encoder has at most one connector (since we always steal
509 static enum drm_mode_status mode_valid_path(struct drm_connector *connector,
526 	ret = drm_bridge_chain_mode_valid(bridge, &connector->display_info,
547 	struct drm_connector *connector;
550 	for_each_new_connector_in_state(state, connector, conn_state, i) {
568 		mode_status = mode_valid_path(connector, encoder, crtc, mode);
582  * This does all the CRTC and connector related computations for an atomic
587  * 2. &drm_connector_helper_funcs.atomic_check to validate the connector state.
595  *    it must not be used for implementing connector property validation.
601  * &drm_crtc_state.connectors_changed is set when a connector is added or
625 	struct drm_connector *connector;
630 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i)
684 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
685 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
692 		 * connector properties need to be updated.
694 		ret = update_connector_routing(state, connector,
713 			ret = funcs->atomic_check(connector, state);
717 				       connector->base.id, connector->name);
726 	 * connector which is itself unchanged, but whose CRTC changes its
753 	for_each_oldnew_connector_in_state(state, connector, old_connector_state, new_connector_state, i) {
754 		const struct drm_connector_helper_funcs *funcs = connector->helper_private;
760 			ret = funcs->atomic_check(connector, state);
764 				       connector->base.id, connector->name);
773 	for_each_oldnew_connector_in_state(state, connector,
800  * @conn_state: connector state to check
802  * Checks if the writeback connector state is valid, and returns an error if it
824 	pixel_format_blob = wb_job->connector->pixel_formats_blob_ptr;
1130 	struct drm_connector *connector;
1136 	for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1175 		 * Each encoder has at most one connector (since we always steal
1263 	struct drm_connector *connector;
1270 	for_each_oldnew_connector_in_state(old_state, connector, old_conn_state, new_conn_state, i) {
1271 		if (connector->encoder) {
1272 			WARN_ON(!connector->encoder->crtc);
1274 			connector->encoder->crtc = NULL;
1275 			connector->encoder = NULL;
1286 			connector->dpms = mode;
1291 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1298 		connector->encoder = new_conn_state->best_encoder;
1299 		connector->encoder->crtc = new_conn_state->crtc;
1347 	struct drm_connector *connector;
1367 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1389 		 * Each encoder has at most one connector (since we always steal
1433 	struct drm_connector *connector;
1437 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1440 		funcs = connector->helper_private;
1445 			WARN_ON(connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK);
1446 			funcs->atomic_commit(connector, old_state);
1471 	struct drm_connector *connector;
1497 	for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
1516 		 * Each encoder has at most one connector (since we always steal
2448  * connector is leading to timeouts when calling
2583 	struct drm_connector *connector;
2589 	for_each_new_connector_in_state(state, connector, new_conn_state, i) {
3023 	struct drm_connector *connector;
3054 		for_each_old_connector_in_state(state, connector, old_conn_state, i) {
3077 	for_each_oldnew_connector_in_state(state, connector, old_conn_state, new_conn_state, i) {
3078 		WARN_ON(connector->state != old_conn_state);
3084 		connector->state = new_conn_state;
3560 	struct drm_connector *connector;
3573 	for_each_new_connector_in_state(state, connector, new_conn_state, i)
3574 		state->connectors[i].old_state = connector->state;
3760  * @conn_state: new connector state