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

  *	Eric Anholt
  *      Dave Airlie
  *      Jesse Barnes
  */
 #include
+#include
 #include "drm.h"
 #include "drmP.h"
 #include "drm_crtc.h"
+#include "drm_edid.h"
 struct drm_prop_enum_list {
 	int type;
 	char *name;
 static struct drm_prop_enum_list drm_dithering_mode_enum_list[] =
+{
 	{ DRM_MODE_DITHERING_OFF, "Off" },
+	{ DRM_MODE_DITHERING_ON, "On" },
-	{ DRM_MODE_DITHERING_ON, "On" },
+	{ DRM_MODE_DITHERING_AUTO, "Automatic" },
 };
 /*
 	{ DRM_MODE_CONNECTOR_DVIA, "DVI-A", 0 },
 	{ DRM_MODE_CONNECTOR_Composite, "Composite", 0 },
 	{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO", 0 },
 	{ DRM_MODE_CONNECTOR_LVDS, "LVDS", 0 },
 	{ DRM_MODE_CONNECTOR_Component, "Component", 0 },
-	{ DRM_MODE_CONNECTOR_9PinDIN, "9-pin DIN", 0 },
+	{ DRM_MODE_CONNECTOR_9PinDIN, "DIN", 0 },
-	{ DRM_MODE_CONNECTOR_DisplayPort, "DisplayPort", 0 },
+	{ DRM_MODE_CONNECTOR_DisplayPort, "DP", 0 },
-	{ DRM_MODE_CONNECTOR_HDMIA, "HDMI Type A", 0 },
+	{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A", 0 },
-	{ DRM_MODE_CONNECTOR_HDMIB, "HDMI Type B", 0 },
+	{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B", 0 },
 	{ DRM_MODE_CONNECTOR_TV, "TV", 0 },
-	{ DRM_MODE_CONNECTOR_eDP, "Embedded DisplayPort", 0 },
+	{ DRM_MODE_CONNECTOR_eDP, "eDP", 0 },
 };
 static struct drm_prop_enum_list drm_encoder_enum_list[] =
 {	{ DRM_MODE_ENCODER_NONE, "None" },
 		drm_mode_remove(connector, mode);
 	list_for_each_entry_safe(mode, t, &connector->user_modes, head)
-		drm_mode_remove(connector, mode);
 		drm_mode_remove(connector, mode);
 	kfree(connector->fb_helper_private);
 	mutex_lock(&dev->mode_config.mutex);
 	drm_mode_object_put(dev, &connector->base);
 	list_del(&connector->head);
 void drm_mode_config_init(struct drm_device *dev)
+{
 	mutex_init(&dev->mode_config.mutex);
 	mutex_init(&dev->mode_config.idr_mutex);
 	INIT_LIST_HEAD(&dev->mode_config.fb_list);
-	INIT_LIST_HEAD(&dev->mode_config.fb_kernel_list);
 	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
 	INIT_LIST_HEAD(&dev->mode_config.connector_list);
 	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
 	INIT_LIST_HEAD(&dev->mode_config.property_list);
 	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
 	uint32_t __user *crtc_id;
 	uint32_t __user *connector_id;
 	uint32_t __user *encoder_id;
 	struct drm_mode_group *mode_group;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	/*
 	/* handle this in 4 parts */
 	/* FBs */
 	if (card_res->count_fbs >= fb_count) {
 		copied = 0;
 		fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
-		list_for_each_entry(fb, &file_priv->fbs, head) {
+		list_for_each_entry(fb, &file_priv->fbs, filp_head) {
 			if (put_user(fb->base.id, fb_id + copied)) {
 				ret = -EFAULT;
 				goto out;
+			}
 			copied++;
 		copied = 0;
 		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
 		if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
 			list_for_each_entry(crtc, &dev->mode_config.crtc_list,
 					    head) {
-				DRM_DEBUG_KMS("CRTC ID is %d\n", crtc->base.id);
+				DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 				if (put_user(crtc->base.id, crtc_id + copied)) {
 					ret = -EFAULT;
 					goto out;
+				}
 				copied++;
 		encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
 		if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
 			list_for_each_entry(encoder,
 					    &dev->mode_config.encoder_list,
 					    head) {
-				DRM_DEBUG_KMS("ENCODER ID is %d\n",
+				DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
-					  encoder->base.id);
+						drm_get_encoder_name(encoder));
 				if (put_user(encoder->base.id, encoder_id +
 					     copied)) {
 					ret = -EFAULT;
 					goto out;
+				}
 		connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
 		if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
 			list_for_each_entry(connector,
 					    &dev->mode_config.connector_list,
 					    head) {
-				DRM_DEBUG_KMS("CONNECTOR ID is %d\n",
+				DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
-					  connector->base.id);
+					connector->base.id,
+					drm_get_connector_name(connector));
 				if (put_user(connector->base.id,
 					     connector_id + copied)) {
 					ret = -EFAULT;
 					goto out;
+				}
+			}
+		}
+	}
 	card_res->count_connectors = connector_count;
-	DRM_DEBUG_KMS("Counted %d %d %d\n", card_res->count_crtcs,
+	DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
 		  card_res->count_connectors, card_res->count_encoders);
 out:
 	struct drm_mode_crtc *crtc_resp = data;
 	struct drm_crtc *crtc;
 	struct drm_mode_object *obj;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, crtc_resp->crtc_id,
 	struct drm_mode_modeinfo __user *mode_ptr;
 	uint32_t __user *prop_ptr;
 	uint64_t __user *prop_values;
 	uint32_t __user *encoder_ptr;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
-	DRM_DEBUG_KMS("connector id %d:\n", out_resp->connector_id);
+	DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
 	struct drm_mode_get_encoder *enc_resp = data;
 	struct drm_mode_object *obj;
 	struct drm_encoder *encoder;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, enc_resp->encoder_id,
 				   DRM_MODE_OBJECT_ENCODER);
 	if (!obj) {
 	struct drm_mode_set set;
 	uint32_t __user *set_connectors_ptr;
 	int ret = 0;
 	int i;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, crtc_req->crtc_id,
 				   DRM_MODE_OBJECT_CRTC);
 	if (!obj) {
 		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
 		ret = -EINVAL;
 		goto out;
+	}
+	crtc = obj_to_crtc(obj);
-	crtc = obj_to_crtc(obj);
+	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
 	if (crtc_req->mode_valid) {
 		/* If we have a mode we need a framebuffer. */
 						out_id);
 				ret = -EINVAL;
 				goto out;
+			}
 			connector = obj_to_connector(obj);
+			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+					connector->base.id,
+					drm_get_connector_name(connector));
 			connector_set[i] = connector;
+		}
 	struct drm_mode_cursor *req = data;
 	struct drm_mode_object *obj;
 	struct drm_crtc *crtc;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	if (!req->flags) {
 		DRM_ERROR("no operation set\n");
 		return -EINVAL;
 	struct drm_mode_fb_cmd *r = data;
 	struct drm_mode_config *config = &dev->mode_config;
 	struct drm_framebuffer *fb;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	if ((config->min_width > r->width) || (r->width > config->max_width)) {
 		DRM_ERROR("mode new framebuffer width not within limits\n");
 		return -EINVAL;
+	}
 		return -EINVAL;
+	}
 	mutex_lock(&dev->mode_config.mutex);
-	/* TODO check buffer is sufficently large */
+	/* TODO check buffer is sufficiently large */
 	/* TODO setup destructor callback */
 	fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
-	if (!fb) {
+	if (IS_ERR(fb)) {
 		DRM_ERROR("could not create framebuffer\n");
-		ret = -EINVAL;
+		ret = PTR_ERR(fb);
 		goto out;
+	}
 	r->fb_id = fb->base.id;
-	r->fb_id = fb->base.id;
+	list_add(&fb->filp_head, &file_priv->fbs);
-	list_add(&fb->filp_head, &file_priv->fbs);
+	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
 	struct drm_framebuffer *fbl = NULL;
 	uint32_t *id = data;
 	int ret = 0;
 	int found = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, *id, DRM_MODE_OBJECT_FB);
-	/* TODO check that we realy get a framebuffer back. */
+	/* TODO check that we really get a framebuffer back. */
 	if (!obj) {
 		DRM_ERROR("mode invalid framebuffer id\n");
 		ret = -EINVAL;
 		goto out;
 	struct drm_mode_fb_cmd *r = data;
 	struct drm_mode_object *obj;
 	struct drm_framebuffer *fb;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
 	if (!obj) {
 		DRM_ERROR("invalid framebuffer id\n");
 	struct drm_framebuffer *fb;
 	unsigned flags;
 	int num_clips;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB);
 	if (!obj) {
 		DRM_ERROR("invalid framebuffer id\n");
 			goto out_err1;
+		}
 		ret = copy_from_user(clips, clips_ptr,
 				     num_clips * sizeof(*clips));
+		if (ret) {
-		if (ret)
+			ret = -EFAULT;
 			goto out_err2;
+	}
+	}
+	if (fb->funcs->dirty) {
-	if (fb->funcs->dirty) {
+		ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
-		ret = fb->funcs->dirty(fb, flags, r->color, clips, num_clips);
+				       clips, num_clips);
 	} else {
 		ret = -ENOSYS;
 	struct drm_display_mode *mode;
 	struct drm_mode_object *obj;
 	struct drm_mode_modeinfo *umode = &mode_cmd->mode;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR);
 	struct drm_connector *connector;
 	struct drm_display_mode mode;
 	struct drm_mode_modeinfo *umode = &mode_cmd->mode;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR);
 	struct drm_property_blob *prop_blob;
 	uint32_t *blob_id_ptr;
 	uint64_t __user *values_ptr;
 	uint32_t __user *blob_length_ptr;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
 	if (!obj) {
 		ret = -EINVAL;
 	struct drm_mode_get_blob *out_resp = data;
 	struct drm_property_blob *blob;
 	int ret = 0;
 	void *blob_ptr;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB);
 	if (!obj) {
 		ret = -EINVAL;
 int drm_mode_connector_update_edid_property(struct drm_connector *connector,
 					    struct edid *edid)
+{
 	struct drm_device *dev = connector->dev;
-	int ret = 0;
+	int ret = 0, size;
 	if (connector->edid_blob_ptr)
 		connector->edid_blob_ptr = NULL;
 		ret = drm_connector_property_set_value(connector, dev->mode_config.edid_property, 0);
 		return ret;
+	}
+	size = EDID_LENGTH * (1 + edid->extensions);
+	connector->edid_blob_ptr = drm_property_create_blob(connector->dev,
-	connector->edid_blob_ptr = drm_property_create_blob(connector->dev, 128, edid);
+							    size, edid);
 	ret = drm_connector_property_set_value(connector,
 	struct drm_property *property;
 	struct drm_connector *connector;
 	int ret = -EINVAL;
 	int i;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, out_resp->connector_id, DRM_MODE_OBJECT_CONNECTOR);
 	struct drm_crtc *crtc;
 	void *r_base, *g_base, *b_base;
 	int size;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
 	if (!obj) {
 		ret = -EINVAL;
 	if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
 		ret = -EFAULT;
 		goto out;
+	}
-	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);
+	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
 out:
 	struct drm_crtc *crtc;
 	void *r_base, *g_base, *b_base;
 	int size;
 	int ret = 0;
+	if (!drm_core_check_feature(dev, DRIVER_MODESET))
+		return -EINVAL;
 	mutex_lock(&dev->mode_config.mutex);
 	obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
 	if (!obj) {
 		ret = -EINVAL;
+}
+#endif
+void drm_mode_config_reset(struct drm_device *dev)
+{
+	struct drm_crtc *crtc;
+	struct drm_encoder *encoder;
+	struct drm_connector *connector;
+	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
+		if (crtc->funcs->reset)
+			crtc->funcs->reset(crtc);
+	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
+		if (encoder->funcs->reset)
+			encoder->funcs->reset(encoder);
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+		if (connector->funcs->reset)

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_crtc.c – Rev 1630 → 1963