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

  *	Eric Anholt
  *      Dave Airlie
  *      Jesse Barnes
  */
+#include
+#include
-#include "drmP.h"
+#include
+#include
-#include "drm_crtc.h"
+#include
-#include "drm_crtc_helper.h"
+#include
+#include
-#include "drm_fb_helper.h"
+#include
 static bool drm_kms_helper_poll = true;
 static void drm_mode_validate_flag(struct drm_connector *connector,
 				   int flags)
+{
-	struct drm_display_mode *mode, *t;
+	struct drm_display_mode *mode;
 	if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
 		return;
-	list_for_each_entry_safe(mode, t, &connector->modes, head) {
+	list_for_each_entry(mode, &connector->modes, head) {
  */
 int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
 					    uint32_t maxX, uint32_t maxY)
+{
 	struct drm_device *dev = connector->dev;
-	struct drm_display_mode *mode, *t;
+	struct drm_display_mode *mode;
 	struct drm_connector_helper_funcs *connector_funcs =
 		connector->helper_private;
 	int count = 0;
 	int mode_flags = 0;
 	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
 			drm_get_connector_name(connector));
 	/* set all modes to the unverified state */
-	list_for_each_entry_safe(mode, t, &connector->modes, head)
+	list_for_each_entry(mode, &connector->modes, head)
 		mode->status = MODE_UNVERIFIED;
 	if (connector->force) {
 			connector->base.id, drm_get_connector_name(connector));
 		drm_mode_connector_update_edid_property(connector, NULL);
 		goto prune;
+	}
+#ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
+	count = drm_load_edid_firmware(connector);
+	if (count == 0)
 #endif
+	count = (*connector_funcs->get_modes)(connector);
 	count = (*connector_funcs->get_modes)(connector);
 	if (count == 0 && connector->status == connector_status_connected)
 		count = drm_add_modes_noedid(connector, 1024, 768);
 	if (count == 0)
 		mode_flags |= DRM_MODE_FLAG_INTERLACE;
 	if (connector->doublescan_allowed)
 		mode_flags |= DRM_MODE_FLAG_DBLSCAN;
 	drm_mode_validate_flag(connector, mode_flags);
-	list_for_each_entry_safe(mode, t, &connector->modes, head) {
+	list_for_each_entry(mode, &connector->modes, head) {
 		if (mode->status == MODE_OK)
 			mode->status = connector_funcs->mode_valid(connector,
 								   mode);
 	drm_mode_sort(&connector->modes);
 	DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
 				drm_get_connector_name(connector));
-	list_for_each_entry_safe(mode, t, &connector->modes, head) {
+	list_for_each_entry(mode, &connector->modes, head) {
 		mode->vrefresh = drm_mode_vrefresh(mode);
 			else
 				(*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
 			crtc->fb = NULL;
+		}
+	}
+}
 EXPORT_SYMBOL(drm_helper_disable_unused_functions);
 /**
 	struct drm_encoder_helper_funcs *encoder_funcs;
 	int saved_x, saved_y;
 	struct drm_encoder *encoder;
 	bool ret = true;
+    ENTER();
 	crtc->enabled = drm_helper_crtc_in_use(crtc);
 	if (!crtc->enabled)
+		return true;
-		return true;
+    printf("crtc->enabled\n");
+	adjusted_mode = drm_mode_duplicate(dev, mode);
+	if (!adjusted_mode)
+		return false;
-	adjusted_mode = drm_mode_duplicate(dev, mode);
+    printf("adjusted_mode\n");
 	saved_hwmode = crtc->hwmode;
 		if (encoder->crtc != crtc)
 			continue;
 		encoder_funcs = encoder->helper_private;
 		if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
 						      adjusted_mode))) {
+			DRM_DEBUG_KMS("Encoder fixup failed\n");
 			goto done;
+		}
+	}
+    printf("list_for_each_entry\n");
+    printf("mode_fixup %x\n", crtc_funcs->mode_fixup);
+	if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
-	if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
+		DRM_DEBUG_KMS("CRTC fixup failed\n");
 		goto done;
+	}
 	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 		crtc->mode = saved_mode;
 		crtc->x = saved_x;
 		crtc->y = saved_y;
+	}
+    LEAVE();
 	return ret;
+}
+EXPORT_SYMBOL(drm_crtc_helper_set_mode);
+static int
+drm_crtc_helper_disable(struct drm_crtc *crtc)
+{
+	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) {
+		if (encoder->crtc != crtc)
+			continue;
+		list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
+			if (connector->encoder != encoder)
+				continue;
+			connector->encoder = NULL;
+		}
+	}
+	drm_helper_disable_unused_functions(dev);
-EXPORT_SYMBOL(drm_crtc_helper_set_mode);
+	return 0;
+}
 /**
  * drm_crtc_helper_set_config - set a new config from userspace
 	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;
+	struct drm_mode_set save_set;
-	int ret = 0;
+	int ret;
 	int i;
 	DRM_DEBUG_KMS("\n");
 		DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
 				set->crtc->base.id, set->fb->base.id,
 		  (int)set->num_connectors, set->x, set->y);
 	} else {
 		DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
-		set->mode = NULL;
-		set->num_connectors = 0;
+		return drm_crtc_helper_disable(set->crtc);
+	}
 	dev = set->crtc->dev;
 	count = 0;
 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 		save_connectors[count++] = *connector;
+	}
+	save_set.crtc = set->crtc;
+	save_set.mode = &set->crtc->mode;
+	save_set.x = set->crtc->x;
+	save_set.y = set->crtc->y;
+	save_set.fb = set->crtc->fb;
 	/* We should be able to check here if the fb has the same properties
 	 * and then just flip_or_move it */
 	if (set->crtc->fb != set->fb) {
 		/* If we have no fb then treat it as a full mode set */
+			}
 			DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
 			for (i = 0; i < set->num_connectors; i++) {
 				DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
 					      drm_get_connector_name(set->connectors[i]));
-				set->connectors[i]->dpms = DRM_MODE_DPMS_ON;
+				set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
+			}
+		}
 		drm_helper_disable_unused_functions(dev);
 	} else if (fb_changed) {
 		set->crtc->x = set->x;
 	count = 0;
 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 		*connector = save_connectors[count++];
+	}
+	/* Try to restore the config */
+	if (mode_changed &&
+	    !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
+				      save_set.y, save_set.fb))
+		DRM_ERROR("failed to restore config after modeset failure\n");
 	kfree(save_connectors);
 	kfree(save_encoders);
 	kfree(save_crtcs);
 	return ret;
 	return;
+}
 EXPORT_SYMBOL(drm_helper_connector_dpms);
 int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
-				   struct drm_mode_fb_cmd *mode_cmd)
+				   struct drm_mode_fb_cmd2 *mode_cmd)
+{
+	int i;
 	fb->width = mode_cmd->width;
+	fb->height = mode_cmd->height;
-	fb->height = mode_cmd->height;
+	for (i = 0; i < 4; i++) {
-	fb->pitch = mode_cmd->pitch;
+		fb->pitches[i] = mode_cmd->pitches[i];
+		fb->offsets[i] = mode_cmd->offsets[i];
+	}
+	drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
-	fb->bits_per_pixel = mode_cmd->bpp;
+				    &fb->bits_per_pixel);
-	fb->depth = mode_cmd->depth;
+	fb->pixel_format = mode_cmd->pixel_format;
 	return 0;
 		if (dev->mode_config.funcs->output_poll_changed)
 			dev->mode_config.funcs->output_poll_changed(dev);
+	}
 	if (repoll)
-		queue_delayed_work(system_nrt_wq, delayed_work, DRM_OUTPUT_POLL_PERIOD);
+		schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
+}
 void drm_kms_helper_poll_disable(struct drm_device *dev)
 		if (connector->polled)
 			poll = true;
+	}
 	if (poll)
-		queue_delayed_work(system_nrt_wq, &dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
+		schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
+}
 EXPORT_SYMBOL(drm_kms_helper_poll_enable);
 		return;
 	/* kill timer and schedule immediate execution, this doesn't block */
 	cancel_delayed_work(&dev->mode_config.output_poll_work);
 	if (drm_kms_helper_poll)
-	queue_delayed_work(system_nrt_wq, &dev->mode_config.output_poll_work, 0);
+		schedule_delayed_work(&dev->mode_config.output_poll_work, 0);
+}
-EXPORT_SYMBOL(drm_helper_hpd_irq_event);
 EXPORT_SYMBOL(drm_helper_hpd_irq_event);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc_helper.c – Rev 2160 → 3031