WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_crtc_helper.c

  */
 bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
+{
 	struct drm_connector *connector;
 	struct drm_device *dev = encoder->dev;
+	/*
+	 * We can expect this mutex to be locked if we are not panicking.
+	 * Locking is currently fubar in the panic handler.
+	 */
+	if (!oops_in_progress) {
+		WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+		WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
+	}
+	drm_for_each_connector(connector, dev)
 		if (connector->encoder == encoder)
 			return true;
 	return false;
+}
 EXPORT_SYMBOL(drm_helper_encoder_in_use);
  */
 bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
+{
 	struct drm_encoder *encoder;
 	struct drm_device *dev = crtc->dev;
+	/*
+	 * We can expect this mutex to be locked if we are not panicking.
-	/* FIXME: Locking around list access? */
+	 * Locking is currently fubar in the panic handler.
+	 */
+	if (!oops_in_progress)
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
+		WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
+	drm_for_each_encoder(encoder, dev)
 		if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
 			return true;
 	return false;
+}
 EXPORT_SYMBOL(drm_helper_crtc_in_use);
 static void
 drm_encoder_disable(struct drm_encoder *encoder)
 {
-	struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
+	const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
 	if (encoder->bridge)
-		encoder->bridge->funcs->disable(encoder->bridge);
+	drm_bridge_disable(encoder->bridge);
 	if (encoder_funcs->disable)
-		(*encoder_funcs->disable)(encoder);
-	else
+		(*encoder_funcs->disable)(encoder);
-		(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
+	else
 		(*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
 	if (encoder->bridge)
-		encoder->bridge->funcs->post_disable(encoder->bridge);
+	drm_bridge_post_disable(encoder->bridge);
+}
 static void __drm_helper_disable_unused_functions(struct drm_device *dev)
+{
 	struct drm_encoder *encoder;
 	struct drm_crtc *crtc;
 	drm_warn_on_modeset_not_all_locked(dev);
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
 		if (!drm_helper_encoder_in_use(encoder)) {
 			drm_encoder_disable(encoder);
 			/* disconnect encoder from any connector */
 			encoder->crtc = NULL;
+		}
+	}
  * since the driver will have to re-route things.
  */
 static void
 drm_crtc_prepare_encoders(struct drm_device *dev)
+{
-	struct drm_encoder_helper_funcs *encoder_funcs;
+	const struct drm_encoder_helper_funcs *encoder_funcs;
 	struct drm_encoder *encoder;
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
 		encoder_funcs = encoder->helper_private;
 		/* Disable unused encoders */
 		if (encoder->crtc == NULL)
 			drm_encoder_disable(encoder);
 			      struct drm_display_mode *mode,
 			      int x, int y,
 			      struct drm_framebuffer *old_fb)
+{
 	struct drm_device *dev = crtc->dev;
-	struct drm_display_mode *adjusted_mode, saved_mode;
+	struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
-	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
+	const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
-	struct drm_encoder_helper_funcs *encoder_funcs;
+	const struct drm_encoder_helper_funcs *encoder_funcs;
 	int saved_x, saved_y;
 	bool saved_enabled;
 	struct drm_encoder *encoder;
 	bool ret = true;
 		crtc->enabled = saved_enabled;
 		return false;
+	}
+	saved_mode = crtc->mode;
-	saved_mode = crtc->mode;
+	saved_hwmode = crtc->hwmode;
 	saved_x = crtc->x;
 	saved_y = crtc->y;
 	/* Pass our mode to the connectors and the CRTC to give them a chance to
 	 * adjust it according to limitations or connector properties, and also
 	 * a chance to reject the mode entirely.
 	 */
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
-		if (encoder->crtc != crtc)
-			continue;
+		if (encoder->crtc != crtc)
+			continue;
 		if (encoder->bridge && encoder->bridge->funcs->mode_fixup) {
-			ret = encoder->bridge->funcs->mode_fixup(
+		ret = drm_bridge_mode_fixup(encoder->bridge,
-					encoder->bridge, mode, adjusted_mode);
+			mode, adjusted_mode);
-			if (!ret) {
+		if (!ret) {
-				DRM_DEBUG_KMS("Bridge fixup failed\n");
-				goto done;
+			DRM_DEBUG_KMS("Bridge fixup failed\n");
 			goto done;
+		}
 		DRM_DEBUG_KMS("CRTC fixup failed\n");
 		goto done;
+	}
 	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
+	crtc->hwmode = *adjusted_mode;
 	/* Prepare the encoders and CRTCs before setting the mode. */
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
-		if (encoder->crtc != crtc)
-			continue;
+		if (encoder->crtc != crtc)
 			continue;
 		if (encoder->bridge)
-			encoder->bridge->funcs->disable(encoder->bridge);
+		drm_bridge_disable(encoder->bridge);
-		encoder_funcs = encoder->helper_private;
-		/* Disable the encoders as the first thing we do. */
+		encoder_funcs = encoder->helper_private;
-		encoder_funcs->prepare(encoder);
+		/* Disable the encoders as the first thing we do. */
 		encoder_funcs->prepare(encoder);
 	 */
 	ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
 	if (!ret)
 	    goto done;
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
 		if (encoder->crtc != crtc)
 			continue;
 		DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
 			encoder->base.id, encoder->name,
-			mode->base.id, mode->name);
-		encoder_funcs = encoder->helper_private;
+			mode->base.id, mode->name);
-		encoder_funcs->mode_set(encoder, mode, adjusted_mode);
 		encoder_funcs = encoder->helper_private;
-		if (encoder->bridge && encoder->bridge->funcs->mode_set)
+		encoder_funcs->mode_set(encoder, mode, adjusted_mode);
 			encoder->bridge->funcs->mode_set(encoder->bridge, mode,
-					adjusted_mode);
+		drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
+	}
-	/* Now enable the clocks, plane, pipe, and connectors that we set up. */
-	crtc_funcs->commit(crtc);
+	/* Now enable the clocks, plane, pipe, and connectors that we set up. */
 	crtc_funcs->commit(crtc);
 	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
-		if (encoder->crtc != crtc)
+	drm_for_each_encoder(encoder, dev) {
 			continue;
-		if (encoder->bridge)
-			encoder->bridge->funcs->pre_enable(encoder->bridge);
 		if (encoder->crtc != crtc)
-		encoder_funcs = encoder->helper_private;
+			continue;
 		encoder_funcs->commit(encoder);
 		drm_bridge_pre_enable(encoder->bridge);
 		if (encoder->bridge)
 done:
 	drm_mode_destroy(dev, adjusted_mode);
 	if (!ret) {
 		crtc->enabled = saved_enabled;
 		crtc->mode = saved_mode;
+		crtc->hwmode = saved_hwmode;
 		crtc->x = saved_x;
 		crtc->y = saved_y;
+	}
 	struct drm_device *dev = crtc->dev;
 	struct drm_connector *connector;
 	struct drm_encoder *encoder;
 	/* Decouple all encoders and their attached connectors from this crtc */
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
 		if (encoder->crtc != crtc)
 			continue;
-		list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+		drm_for_each_connector(connector, dev) {
 			if (connector->encoder != encoder)
 	struct drm_encoder *save_encoders, *new_encoder, *encoder;
 	bool mode_changed = false; /* if true do a full mode set */
 	bool fb_changed = false; /* if true and !mode_changed just do a flip */
 	struct drm_connector *save_connectors, *connector;
 	int count = 0, ro, fail = 0;
-	struct drm_crtc_helper_funcs *crtc_funcs;
+	const struct drm_crtc_helper_funcs *crtc_funcs;
 	struct drm_mode_set save_set;
 	int ret;
 	int i;
 	 * Copy data. Note that driver private data is not affected.
 	 * Should anything bad happen only the expected state is
 	 * restored, not the drivers personal bookkeeping.
 	 */
 	count = 0;
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
 		save_encoders[count++] = *encoder;
+	}
 	count = 0;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+	drm_for_each_connector(connector, dev) {
 		save_connectors[count++] = *connector;
+	}
 		mode_changed = true;
+	}
 	/* a) traverse passed in connector list and get encoders for them */
 	count = 0;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+	drm_for_each_connector(connector, dev) {
-		struct drm_connector_helper_funcs *connector_funcs =
+		const struct drm_connector_helper_funcs *connector_funcs =
 			connector->helper_private;
 		new_encoder = connector->encoder;
 		for (ro = 0; ro < set->num_connectors; ro++) {
 			if (set->connectors[ro] == connector) {
 		ret = -EINVAL;
 		goto fail;
+	}
 	count = 0;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+	drm_for_each_connector(connector, dev) {
 		if (!connector->encoder)
 			continue;
 	return 0;
 fail:
 	/* Restore all previous data. */
 	count = 0;
-	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+	drm_for_each_encoder(encoder, dev) {
 		*encoder = save_encoders[count++];
+	}
 	count = 0;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+	drm_for_each_connector(connector, dev) {
 		*connector = save_connectors[count++];
+	}
+{
 	int dpms = DRM_MODE_DPMS_OFF;
 	struct drm_connector *connector;
 	struct drm_device *dev = encoder->dev;
-	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+	drm_for_each_connector(connector, dev)
 		if (connector->encoder == encoder)
 			if (connector->dpms < dpms)
 				dpms = connector->dpms;
 	return dpms;
+}
 /* Helper which handles bridge ordering around encoder dpms */
 static void drm_helper_encoder_dpms(struct drm_encoder *encoder, int mode)
 {
-	struct drm_bridge *bridge = encoder->bridge;
-	struct drm_encoder_helper_funcs *encoder_funcs;
+	struct drm_bridge *bridge = encoder->bridge;
+	const struct drm_encoder_helper_funcs *encoder_funcs;
 	if (bridge) {
-		if (mode == DRM_MODE_DPMS_ON)
+	if (mode == DRM_MODE_DPMS_ON)
-			bridge->funcs->pre_enable(bridge);
-		else
+		drm_bridge_pre_enable(bridge);
-			bridge->funcs->disable(bridge);
+	else
 		drm_bridge_disable(bridge);
 	encoder_funcs = encoder->helper_private;
-	if (encoder_funcs->dpms)
+	encoder_funcs = encoder->helper_private;
-		encoder_funcs->dpms(encoder, mode);
+	if (encoder_funcs->dpms)
+		encoder_funcs->dpms(encoder, mode);
-	if (bridge) {
 		if (mode == DRM_MODE_DPMS_ON)
-			bridge->funcs->enable(bridge);
+	if (mode == DRM_MODE_DPMS_ON)
-		else
+		drm_bridge_enable(bridge);
-			bridge->funcs->post_disable(bridge);
+	else
 		drm_bridge_post_disable(bridge);
+}
 static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
+{
 	int dpms = DRM_MODE_DPMS_OFF;
 	struct drm_connector *connector;
 	struct drm_device *dev = crtc->dev;
+ *
  * This is the main helper function provided by the crtc helper framework for
  * implementing the DPMS connector attribute. It computes the new desired DPMS
  * state for all encoders and crtcs in the output mesh and calls the ->dpms()
  * callback provided by the driver appropriately.
+ *
+ * Returns:
+ * Always returns 0.
  */
-void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
+int drm_helper_connector_dpms(struct drm_connector *connector, int mode)
+{
 	struct drm_encoder *encoder = connector->encoder;
 	struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
 	int old_dpms, encoder_dpms = DRM_MODE_DPMS_OFF;
 	if (mode == connector->dpms)
-		return;
+		return 0;
 	old_dpms = connector->dpms;
 	connector->dpms = mode;
 	if (encoder)
 		encoder_dpms = drm_helper_choose_encoder_dpms(encoder);
 	/* from off to on, do crtc then encoder */
 	if (mode < old_dpms) {
 		if (crtc) {
-			struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
+			const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 			if (crtc_funcs->dpms)
 	/* from on to off, do encoder then crtc */
 	if (mode > old_dpms) {
 		if (encoder)
 			drm_helper_encoder_dpms(encoder, encoder_dpms);
 		if (crtc) {
-			struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
+			const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 			if (crtc_funcs->dpms)
 				(*crtc_funcs->dpms) (crtc,
 						     drm_helper_choose_crtc_dpms(crtc));
+		}
+	}
-	return;
+	return 0;
+}
 EXPORT_SYMBOL(drm_helper_connector_dpms);
 	fb->width = mode_cmd->width;
 	fb->height = mode_cmd->height;
 	for (i = 0; i < 4; i++) {
 		fb->pitches[i] = mode_cmd->pitches[i];
 		fb->offsets[i] = mode_cmd->offsets[i];
+		fb->modifier[i] = mode_cmd->modifier[i];
+	}
 	drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
 				    &fb->bits_per_pixel);
 	fb->pixel_format = mode_cmd->pixel_format;
 	fb->flags = mode_cmd->flags;
  */
 void drm_helper_resume_force_mode(struct drm_device *dev)
+{
 	struct drm_crtc *crtc;
 	struct drm_encoder *encoder;
-	struct drm_crtc_helper_funcs *crtc_funcs;
+	const struct drm_crtc_helper_funcs *crtc_funcs;
 	int encoder_dpms;
 	bool ret;
 	drm_modeset_lock_all(dev);
-	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+	drm_for_each_crtc(crtc, dev) {
-       if (!crtc->enabled)
+		if (!crtc->enabled)
 		if (ret == false)
 			DRM_ERROR("failed to set mode on crtc %p\n", crtc);
 		/* Turn off outputs that were already powered off */
 		if (drm_helper_choose_crtc_dpms(crtc)) {
-			list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
+			drm_for_each_encoder(encoder, dev) {
 				if(encoder->crtc != crtc)
 int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
 			     struct drm_display_mode *adjusted_mode, int x, int y,
 			     struct drm_framebuffer *old_fb)
+{
 	struct drm_crtc_state *crtc_state;
-	struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
+	const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
 	int ret;
 	if (crtc->funcs->atomic_duplicate_state)
+		crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
-		crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
+	else {
-	else if (crtc->state)
+		if (!crtc->state)
-		crtc_state = kmemdup(crtc->state, sizeof(*crtc_state),
-				     GFP_KERNEL);
+			drm_atomic_helper_crtc_reset(crtc);
-	else
+		crtc_state = drm_atomic_helper_crtc_duplicate_state(crtc);
+	}
 		crtc_state = kzalloc(sizeof(*crtc_state), GFP_KERNEL);
 	if (!crtc_state)
-		return -ENOMEM;
 		return -ENOMEM;
 	crtc_state->enable = true;
 	crtc_state->planes_changed = true;
+	crtc_state->mode_changed = true;
+	ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
-	crtc_state->mode_changed = true;
+	if (ret)
-	drm_mode_copy(&crtc_state->mode, mode);
+		goto out;
 	drm_mode_copy(&crtc_state->adjusted_mode, adjusted_mode);
-	if (crtc_funcs->atomic_check) {
-		ret = crtc_funcs->atomic_check(crtc, crtc_state);
-		if (ret) {
+	if (crtc_funcs->atomic_check) {
-			kfree(crtc_state);
 		ret = crtc_funcs->atomic_check(crtc, crtc_state);
-			return ret;
+		if (ret)
 			goto out;
+	}
+	swap(crtc->state, crtc_state);
 	crtc_funcs->mode_set_nofb(crtc);
 	swap(crtc->state, crtc_state);
 	ret = drm_helper_crtc_mode_set_base(crtc, x, y, old_fb);
-	crtc_funcs->mode_set_nofb(crtc);
 out:
 	if (crtc_state) {
 		if (crtc->funcs->atomic_destroy_state)
 			crtc->funcs->atomic_destroy_state(crtc, crtc_state);
 		else
-			kfree(crtc_state);
+			drm_atomic_helper_crtc_destroy_state(crtc, crtc_state);
 		plane_state = drm_atomic_helper_plane_duplicate_state(plane);
 	else
 		plane_state = kzalloc(sizeof(*plane_state), GFP_KERNEL);
 	if (!plane_state)
 		return -ENOMEM;
+	plane_state->plane = plane;
 	plane_state->crtc = crtc;
 	drm_atomic_set_fb_for_plane(plane_state, crtc->primary->fb);
 	plane_state->crtc_x = 0;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc_helper.c – Rev 5271 → 6084