Merge branch 'modesetting-101' of git+ssh://git.freedesktop.org/git/mesa/drm into modesetting-101

1 files changed, 392 insertions, 12 deletions

diff --git a/linux-core/drm_crtc.c b/linux-core/drm_crtc.c
index a52d82bc..8e03dd5f 100644
--- a/linux-core/drm_crtc.c
+++ b/linux-core/drm_crtc.c
@@ -3,6 +3,33 @@
 #include "drm.h"
 #include "drm_crtc.h"
 
+int drm_mode_idr_get(struct drm_device *dev, void *ptr)
+{
+	int new_id = 0;
+	int ret;
+again:
+	if (idr_pre_get(&dev->crtc_config.crtc_idr, GFP_KERNEL) == 0) {
+		DRM_ERROR("Ran out memory getting a mode number\n");
+		return 0;
+	}
+
+	spin_lock(&dev->crtc_config.config_lock);
+
+	ret = idr_get_new_above(&dev->crtc_config.crtc_idr, ptr, 1, &new_id);
+	if (ret == -EAGAIN) {
+		spin_unlock(&dev->crtc_config.config_lock);
+		goto again;
+	}	
+
+	spin_unlock(&dev->crtc_config.config_lock);
+	return new_id;
+}
+
+void drm_mode_idr_put(struct drm_device *dev, int id)
+{
+	idr_remove(&dev->crtc_config.crtc_idr, id);
+}
+
 struct drm_framebuffer *drm_framebuffer_create(drm_device_t *dev)
 {
 	struct drm_framebuffer *fb;
@@ -20,7 +47,8 @@ struct drm_framebuffer *drm_framebuffer_create(drm_device_t *dev)
 
 		return NULL;
 	}
-
+	
+	fb->id = drm_mode_idr_get(dev, fb);
 	fb->dev = dev;
 	spin_lock(&dev->crtc_config.config_lock);
 	dev->crtc_config.num_fb++;
@@ -35,6 +63,7 @@ void drm_framebuffer_destroy(struct drm_framebuffer *fb)
 	drm_device_t *dev = fb->dev;
 
 	spin_lock(&dev->crtc_config.config_lock);
+	drm_mode_idr_put(dev, fb->id);
 	list_del(&fb->head);
 	dev->crtc_config.num_fb--;
 	spin_unlock(&dev->crtc_config.config_lock);
@@ -45,19 +74,21 @@ void drm_framebuffer_destroy(struct drm_framebuffer *fb)
 struct drm_crtc *drm_crtc_create(drm_device_t *dev,
 				 const struct drm_crtc_funcs *funcs)
 {
-	struct drm_crtc *crtc = NULL;
-	crtc = kmalloc(sizeof(struct drm_crtc), GFP_KERNEL);
+	struct drm_crtc *crtc;
+
+	crtc = kzalloc(sizeof(struct drm_crtc), GFP_KERNEL);
 	if (!crtc)
 		return NULL;
 
 	crtc->dev = dev;
 	crtc->funcs = funcs;
 
-	spin_lock(&dev->crtc_config.config_lock);
+	crtc->id = drm_mode_idr_get(dev, crtc);
+	DRM_DEBUG("crtc %p got id %d\n", crtc, crtc->id);
 
+	spin_lock(&dev->crtc_config.config_lock);
 	list_add_tail(&crtc->head, &dev->crtc_config.crtc_list);
 	dev->crtc_config.num_crtc++;
-
 	spin_unlock(&dev->crtc_config.config_lock);
 
 	return crtc;
@@ -71,7 +102,9 @@ void drm_crtc_destroy(struct drm_crtc *crtc)
 	if (crtc->funcs->cleanup)
 		(*crtc->funcs->cleanup)(crtc);
 
+
 	spin_lock(&dev->crtc_config.config_lock);
+	drm_mode_idr_put(dev, crtc->id);
 	list_del(&crtc->head);
 	dev->crtc_config.num_crtc--;
 	spin_unlock(&dev->crtc_config.config_lock);
@@ -154,7 +187,7 @@ bool drm_crtc_set_mode(struct drm_crtc *crtc, struct drm_display_mode *mode,
 	bool ret = false;
 	struct drm_output *output;
 
-	adjusted_mode = drm_mode_duplicate(mode);
+	adjusted_mode = drm_mode_duplicate(dev, mode);
 
 	crtc->enabled = drm_crtc_in_use(crtc);
 
@@ -230,6 +263,7 @@ bool drm_crtc_set_mode(struct drm_crtc *crtc, struct drm_display_mode *mode,
 	}
 	
 	/* XXX free adjustedmode */
+	drm_crtc_mode_destroy(dev, adjusted_mode);
 	ret = TRUE;
 	/* TODO */
 //	if (scrn->pScreen)
@@ -256,6 +290,7 @@ bool drm_set_desired_modes(struct drm_device *dev)
 	list_for_each_entry(crtc, &dev->crtc_config.crtc_list, head) {
 		output = NULL;
 
+		DRM_DEBUG("crtc is %d\n", crtc->id);
 		list_for_each_entry(list_output, &dev->crtc_config.output_list, head) {
 			if (list_output->crtc == crtc) {
 				output = list_output;
@@ -267,10 +302,10 @@ bool drm_set_desired_modes(struct drm_device *dev)
 			continue;
 
 		memset(&crtc->mode, 0, sizeof(crtc->mode));
-		if (!crtc->desired_mode.crtc_hdisplay) {
+		if (!crtc->desired_mode->crtc_hdisplay) {
 			
 		}
-		if (!drm_crtc_set_mode(crtc, &crtc->desired_mode,
+		if (!drm_crtc_set_mode(crtc, crtc->desired_mode,
 				       crtc->desired_x, crtc->desired_y))
 			return false;
 	}
@@ -344,6 +379,7 @@ struct drm_output *drm_output_create(drm_device_t *dev,
 		
 	output->dev = dev;
 	output->funcs = funcs;
+	output->id = drm_mode_idr_get(dev, output);
 	if (name)
 		strncpy(output->name, name, DRM_OUTPUT_LEN);
 	output->name[DRM_OUTPUT_LEN - 1] = 0;
@@ -381,6 +417,7 @@ void drm_output_destroy(struct drm_output *output)
 		drm_mode_remove(output, mode);
 
 	spin_lock(&dev->crtc_config.config_lock);
+	drm_mode_idr_put(dev, output->id);
 	list_del(&output->head);
 	spin_unlock(&dev->crtc_config.config_lock);
 	kfree(output);
@@ -401,12 +438,33 @@ bool drm_output_rename(struct drm_output *output, const char *name)
 }
 EXPORT_SYMBOL(drm_output_rename);
 
+struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev)
+{
+	int ret;
+	struct drm_display_mode *nmode;
+
+	nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);
+	if (!nmode)
+		return NULL;
+
+	nmode->mode_id = drm_mode_idr_get(dev, nmode);
+	return nmode;
+}
+
+void drm_crtc_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
+{
+	drm_mode_idr_put(dev, mode->mode_id);
+
+	kfree(mode);
+}
+
 void drm_crtc_config_init(drm_device_t *dev)
 {
 	spin_lock_init(&dev->crtc_config.config_lock);
 	INIT_LIST_HEAD(&dev->crtc_config.fb_list);
 	INIT_LIST_HEAD(&dev->crtc_config.crtc_list);
 	INIT_LIST_HEAD(&dev->crtc_config.output_list);
+	idr_init(&dev->crtc_config.crtc_idr);
 }
 EXPORT_SYMBOL(drm_crtc_config_init);
 
@@ -441,7 +499,7 @@ void drm_framebuffer_set_object(drm_device_t *dev, unsigned long handle)
 	ret = 0;
 out_err:
 	mutex_unlock(&dev->struct_mutex);
-	return ret;
+	return;
 }
 EXPORT_SYMBOL(drm_framebuffer_set_object);
 
@@ -465,6 +523,7 @@ bool drm_initial_config(drm_device_t *dev, bool can_grow)
 	/* bind both CRTCs to this fb */
 	/* only initialise one crtc to enabled state */
 	list_for_each_entry(crtc, &dev->crtc_config.crtc_list, head) {
+		DRM_DEBUG("crtc is %d\n", crtc->id);
 		crtc->fb = fb;
 		if (!vga_crtc) {
 			vga_crtc = crtc;
@@ -497,7 +556,7 @@ bool drm_initial_config(drm_device_t *dev, bool can_grow)
 				break;
 			DRM_DEBUG("Setting desired mode for output %s\n", output->name);
 			drm_mode_debug_printmodeline(dev, des_mode);
-			output->crtc->desired_mode = *des_mode;
+			output->crtc->desired_mode = des_mode;
 			output->initial_x = 0;
 			output->initial_y = 0;
 			use_output = output;
@@ -509,7 +568,7 @@ bool drm_initial_config(drm_device_t *dev, bool can_grow)
 				break;
 			DRM_DEBUG("Setting desired mode for output %s\n", output->name);
 			drm_mode_debug_printmodeline(dev, des_mode);
-			output->crtc->desired_mode = *des_mode;
+			output->crtc->desired_mode = des_mode;
 #endif
 			output->initial_x = 0;
 			output->initial_y = 0;
@@ -531,10 +590,331 @@ void drm_crtc_config_cleanup(drm_device_t *dev)
 		drm_output_destroy(output);
 	}
 
-	
 	list_for_each_entry_safe(crtc, ct, &dev->crtc_config.crtc_list, head) {
 		drm_crtc_destroy(crtc);
 	}
 }
 EXPORT_SYMBOL(drm_crtc_config_cleanup);
 
+int drm_crtc_set_config(struct drm_crtc *crtc, struct drm_mode_crtc *crtc_info, struct drm_display_mode *new_mode, struct drm_output **output_set)
+{
+	drm_device_t *dev = crtc->dev;
+	struct drm_crtc **save_crtcs, *new_crtc;
+	bool save_enabled = crtc->enabled;
+	bool changed;
+	struct drm_output *output;
+	int count = 0, ro;
+
+	save_crtcs = kzalloc(dev->crtc_config.num_crtc * sizeof(struct drm_crtc *), GFP_KERNEL);
+	if (!save_crtcs)
+		return -ENOMEM;
+
+	if (crtc_info->x != crtc->x || crtc_info->y != crtc->y)
+		changed = true;
+
+	if (crtc->mode.mode_id != new_mode->mode_id)
+		changed = true;
+
+	list_for_each_entry(output, &dev->crtc_config.output_list, head) {
+		save_crtcs[count++] = output->crtc;
+
+		if (output->crtc == crtc)
+			new_crtc = NULL;
+		else
+			new_crtc = output->crtc;
+
+		for (ro = 0; ro < crtc_info->count_outputs; ro++)
+		{
+			if (output_set[ro] == output)
+				new_crtc = crtc;
+		}
+		if (new_crtc != output->crtc) {
+			changed = true;
+			output->crtc = new_crtc;
+		}
+	}
+
+	if (changed) {
+		crtc->enabled = new_mode != NULL;
+		if (new_mode) {
+			DRM_DEBUG("attempting to set mode from userspace\n");
+			drm_mode_debug_printmodeline(dev, new_mode);
+			if (!drm_crtc_set_mode(crtc, new_mode, crtc_info->x,
+					       crtc_info->y)) {
+				crtc->enabled = save_enabled;
+				count = 0;
+				list_for_each_entry(output, &dev->crtc_config.output_list, head)
+					output->crtc = save_crtcs[count++];
+				kfree(save_crtcs);
+				return -EINVAL;
+			}
+			crtc->desired_x = crtc_info->x;
+			crtc->desired_y = crtc_info->y;
+			crtc->desired_mode =  new_mode;
+		}
+		drm_disable_unused_functions(dev);
+	}
+	kfree(save_crtcs);
+	return 0;
+}
+
+void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, struct drm_display_mode *in)
+{
+
+	out->id = in->mode_id;
+	out->clock = in->clock;
+	out->hdisplay = in->hdisplay;
+	out->hsync_start = in->hsync_start;
+	out->hsync_end = in->hsync_end;
+	out->htotal = in->htotal;
+	out->hskew = in->hskew;
+	out->vdisplay = in->vdisplay;
+	out->vsync_start = in->vsync_start;
+	out->vsync_end = in->vsync_end;
+	out->vtotal = in->vtotal;
+	out->vscan = in->vscan;
+	
+	out->flags = in->flags;
+	strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
+	out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
+}
+
+	
+/* IOCTL code from userspace */
+int drm_mode_getresources(struct inode *inode, struct file *filp,
+			  unsigned int cmd, unsigned long arg)
+{
+	drm_file_t *priv = filp->private_data;
+	drm_device_t *dev = priv->head->dev;
+	struct drm_mode_card_res __user *argp = (void __user *)arg;
+	struct drm_mode_card_res card_res;
+	struct list_head *lh;
+	struct drm_output *output;
+	struct drm_crtc *crtc;
+	struct drm_mode_modeinfo u_mode;
+	struct drm_display_mode *mode;
+	int retcode = 0;
+	int mode_count= 0;
+	int output_count = 0;
+	int crtc_count = 0;
+	int copied = 0;
+
+	memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
+
+	list_for_each(lh, &dev->crtc_config.crtc_list)
+		crtc_count++;
+
+	list_for_each_entry(output, &dev->crtc_config.output_list,
+			    head)
+	{
+		output_count++;
+		list_for_each(lh, &output->modes)
+			mode_count++;
+	}
+
+	if (copy_from_user(&card_res, argp, sizeof(card_res)))
+		return -EFAULT;
+
+	/* handle this in 3 parts */
+	/* CRTCs */
+	if (card_res.count_crtcs >= crtc_count) {
+		copied = 0;
+		list_for_each_entry(crtc, &dev->crtc_config.crtc_list, head){
+			DRM_DEBUG("CRTC ID is %d\n", crtc->id);
+			if (put_user(crtc->id, &card_res.crtc_id[copied++])) {
+				retcode = -EFAULT;
+				goto done;
+			}
+		}
+	}
+	card_res.count_crtcs = crtc_count;
+
+
+	/* Outputs */
+	if (card_res.count_outputs >= output_count) {
+		copied = 0;
+		list_for_each_entry(output, &dev->crtc_config.output_list,
+				    head) {
+ 			DRM_DEBUG("OUTPUT ID is %d\n", output->id);
+			if (put_user(output->id, &card_res.output_id[copied++])) {
+				retcode = -EFAULT;
+				goto done;
+			}
+		}
+	}
+	card_res.count_outputs = output_count;
+	
+	/* Modes */
+	if (card_res.count_modes >= mode_count) {
+		copied = 0;
+		list_for_each_entry(output, &dev->crtc_config.output_list,
+				    head) {
+			list_for_each_entry(mode, &output->modes, head) {
+				drm_crtc_convert_to_umode(&u_mode, mode);
+				if (copy_to_user(&card_res.modes[copied++], &u_mode, sizeof(struct drm_mode_modeinfo))) {
+					retcode = -EFAULT;
+					goto done;
+				}
+			}
+		}
+	}
+	card_res.count_modes = mode_count;
+
+done:
+	DRM_DEBUG("Counted %d %d %d\n", card_res.count_crtcs,
+		  card_res.count_outputs,
+		  card_res.count_modes);
+	
+	if (copy_to_user(argp, &card_res, sizeof(card_res)))
+		return -EFAULT;
+
+	return retcode;
+}
+
+int drm_mode_getcrtc(struct inode *inode, struct file *filp,
+		     unsigned int cmd, unsigned long arg)
+{
+	drm_file_t *priv = filp->private_data;
+	drm_device_t *dev = priv->head->dev;
+	struct drm_mode_crtc __user *argp = (void __user *)arg;
+	struct drm_mode_crtc crtc_resp;
+	struct drm_crtc *crtc;
+	struct drm_output *output;
+	int ocount;
+	int retcode = 0;
+
+	if (copy_from_user(&crtc_resp, argp, sizeof(crtc_resp)))
+		return -EFAULT;
+
+	crtc = idr_find(&dev->crtc_config.crtc_idr, crtc_resp.crtc_id);
+	if (!crtc || (crtc->id != crtc_resp.crtc_id))
+		return -EINVAL;
+	crtc_resp.x = crtc->x;
+	crtc_resp.y = crtc->y;
+	crtc_resp.fb_id = 1;
+
+	crtc_resp.outputs = 0;
+	if (crtc->enabled) {
+
+		crtc_resp.mode = crtc->mode.mode_id;
+		ocount = 0;
+		list_for_each_entry(output, &dev->crtc_config.output_list, head) {
+			if (output->crtc == crtc)
+				crtc_resp.outputs |= 1 << (ocount++);
+		}
+	} else {
+		crtc_resp.mode = 0;
+	}
+
+	if (copy_to_user(argp, &crtc_resp, sizeof(crtc_resp)))
+		return -EFAULT;
+
+	return retcode;
+}
+
+int drm_mode_getoutput(struct inode *inode, struct file *filp,
+		       unsigned int cmd, unsigned long arg)
+{
+	drm_file_t *priv = filp->private_data;
+	drm_device_t *dev = priv->head->dev;
+	struct drm_mode_get_output __user *argp = (void __user *)arg;
+	struct drm_mode_get_output out_resp;
+	struct drm_output *output;
+	struct drm_display_mode *mode;
+	int mode_count = 0;
+	int retcode = 0;
+	int copied = 0;
+
+	if (copy_from_user(&out_resp, argp, sizeof(out_resp)))
+		return -EFAULT;	
+
+	output= idr_find(&dev->crtc_config.crtc_idr, out_resp.output);
+	if (!output || (output->id != out_resp.output))
+		return -EINVAL;
+
+	list_for_each_entry(mode, &output->modes, head)
+		mode_count++;
+
+	out_resp.mm_width = output->mm_width;
+	out_resp.mm_height = output->mm_height;
+	out_resp.subpixel = output->subpixel_order;
+	out_resp.connection = output->status;
+	if (output->crtc)
+		out_resp.crtc = output->crtc->id;
+	else
+		out_resp.crtc = 0;
+
+	if (out_resp.count_modes >= mode_count) {
+		copied = 0;
+		list_for_each_entry(mode, &output->modes, head) {
+			if (put_user(mode->mode_id, &out_resp.modes[copied++])) {
+				retcode = -EFAULT;
+				goto done;
+			}
+		}
+	}
+	out_resp.count_modes = mode_count;
+
+done:
+	if (copy_to_user(argp, &out_resp, sizeof(out_resp)))
+		return -EFAULT;
+
+	return retcode;
+}
+
+
+int drm_mode_setcrtc(struct inode *inode, struct file *filp,
+		     unsigned int cmd, unsigned long arg)
+{
+	drm_file_t *priv = filp->private_data;
+	drm_device_t *dev = priv->head->dev;
+	struct drm_mode_crtc __user *argp = (void __user *)arg;
+	struct drm_mode_crtc crtc_req;
+	struct drm_crtc *crtc;
+	struct drm_output **output_set = NULL, *output;
+	struct drm_display_mode *mode;
+	int retcode = 0;
+	int i;
+
+	if (copy_from_user(&crtc_req, argp, sizeof(crtc_req)))
+		return -EFAULT;
+
+	crtc = idr_find(&dev->crtc_config.crtc_idr, crtc_req.crtc_id);
+	if (!crtc || (crtc->id != crtc_req.crtc_id))
+		return -EINVAL;
+
+	if (crtc_req.mode) {
+		mode = idr_find(&dev->crtc_config.crtc_idr, crtc_req.mode);
+		if (!mode || (mode->mode_id != crtc_req.mode))
+			return -EINVAL;
+	} else
+		mode = NULL;
+
+	if (crtc_req.count_outputs == 0 && mode)
+		return -EINVAL;
+
+	if (crtc_req.count_outputs > 0 && !mode)
+		return -EINVAL;
+
+	if (crtc_req.count_outputs > 0) {
+		u32 out_id;
+		output_set = kmalloc(crtc_req.count_outputs * sizeof(struct drm_output *), GFP_KERNEL);
+		if (!output_set)
+			return -ENOMEM;
+
+		for (i = 0; i < crtc_req.count_outputs; i++)
+		{
+			if (get_user(out_id, &crtc_req.set_outputs[i]))
+				return -EFAULT;
+
+			output = idr_find(&dev->crtc_config.crtc_idr, out_id);
+			if (!output || (out_id != output->id))
+				return -EINVAL;
+
+			output_set[i] = output;
+		}
+	}
+		
+	retcode = drm_crtc_set_config(crtc, &crtc_req, mode, output_set);
+	return retcode;
+}