Merge branch 'drm-patches' of master.kernel.org:/pub/scm/linux/kernel/git/airlied/drm-2.6 (ee2fae03) · Commits · e / devices / android_kernel_teracube_2e

drivers/char/drm/drmP.h

+1 −6

Original line number	Original line	Diff line number	Diff line
	@@ -561,8 +561,7 @@ struct drm_driver {
	int (context_dtor) (struct drm_device dev, int context);		int (context_dtor) (struct drm_device dev, int context);
	int (kernel_context_switch) (struct drm_device dev, int old,		int (kernel_context_switch) (struct drm_device dev, int old,
	int new);		int new);
	void (kernel_context_switch_unlock) (struct drm_device dev,		void (kernel_context_switch_unlock) (struct drm_device dev);
	drm_lock_t *lock);
	int (vblank_wait) (struct drm_device dev, unsigned int *sequence);		int (vblank_wait) (struct drm_device dev, unsigned int *sequence);
	int (vblank_wait2) (struct drm_device dev, unsigned int *sequence);		int (vblank_wait2) (struct drm_device dev, unsigned int *sequence);
	int (dri_library_name) (struct drm_device dev, char *buf);		int (dri_library_name) (struct drm_device dev, char *buf);
	@@ -1143,9 +1142,5 @@ extern void *drm_calloc(size_t nmemb, size_t size, int area);
	extern unsigned long drm_core_get_map_ofs(drm_map_t * map);		extern unsigned long drm_core_get_map_ofs(drm_map_t * map);
	extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev);		extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev);

	#ifndef pci_pretty_name
	#define pci_pretty_name(dev) ""
	#endif

	#endif /* __KERNEL__ */		#endif /* __KERNEL__ */
	#endif		#endif

drivers/char/drm/drm_lock.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -182,7 +182,7 @@ int drm_unlock(struct inode inode, struct file filp,
	* modules but is required by the Sparc driver.		* modules but is required by the Sparc driver.
	*/		*/
	if (dev->driver->kernel_context_switch_unlock)		if (dev->driver->kernel_context_switch_unlock)
	dev->driver->kernel_context_switch_unlock(dev, &lock);		dev->driver->kernel_context_switch_unlock(dev);
	else {		else {
	drm_lock_transfer(dev, &dev->lock.hw_lock->lock,		drm_lock_transfer(dev, &dev->lock.hw_lock->lock,
	DRM_KERNEL_CONTEXT);		DRM_KERNEL_CONTEXT);

drivers/char/drm/drm_stub.c

+8 −4

Original line number	Original line	Diff line number	Diff line
	@@ -211,14 +211,16 @@ int drm_get_dev(struct pci_dev pdev, const struct pci_device_id ent,
	if (!dev)		if (!dev)
	return -ENOMEM;		return -ENOMEM;

	pci_enable_device(pdev);		ret = pci_enable_device(pdev);
			if (ret)
			goto err_g1;

	if ((ret = drm_fill_in_dev(dev, pdev, ent, driver))) {		if ((ret = drm_fill_in_dev(dev, pdev, ent, driver))) {
	printk(KERN_ERR "DRM: Fill_in_dev failed.\n");		printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
	goto err_g1;		goto err_g2;
	}		}
	if ((ret = drm_get_head(dev, &dev->primary)))		if ((ret = drm_get_head(dev, &dev->primary)))
	goto err_g1;		goto err_g2;

	DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",		DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
	driver->name, driver->major, driver->minor, driver->patchlevel,		driver->name, driver->major, driver->minor, driver->patchlevel,
	@@ -226,6 +228,8 @@ int drm_get_dev(struct pci_dev pdev, const struct pci_device_id ent,

	return 0;		return 0;

			err_g2:
			pci_disable_device(pdev);
	err_g1:		err_g1:
	drm_free(dev, sizeof(*dev), DRM_MEM_STUB);		drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
	return ret;		return ret;

drivers/char/drm/drm_sysfs.c

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -45,8 +45,8 @@ struct class drm_sysfs_create(struct module owner, char *name)
	int err;		int err;

	class = class_create(owner, name);		class = class_create(owner, name);
	if (!class) {		if (IS_ERR(class)) {
	err = -ENOMEM;		err = PTR_ERR(class);
	goto err_out;		goto err_out;
	}		}

	@@ -113,8 +113,8 @@ struct class_device drm_sysfs_device_add(struct class cs, drm_head_t *head)
	MKDEV(DRM_MAJOR, head->minor),		MKDEV(DRM_MAJOR, head->minor),
	&(head->dev->pdev)->dev,		&(head->dev->pdev)->dev,
	"card%d", head->minor);		"card%d", head->minor);
	if (!class_dev) {		if (IS_ERR(class_dev)) {
	err = -ENOMEM;		err = PTR_ERR(class_dev);
	goto err_out;		goto err_out;
	}		}

drivers/char/drm/i915_irq.c

+139 −60

Original line number	Original line	Diff line number	Diff line
	@@ -46,41 +46,82 @@ static void i915_vblank_tasklet(drm_device_t *dev)
	{		{
	drm_i915_private_t dev_priv = (drm_i915_private_t ) dev->dev_private;		drm_i915_private_t dev_priv = (drm_i915_private_t ) dev->dev_private;
	unsigned long irqflags;		unsigned long irqflags;
	struct list_head list, tmp;		struct list_head list, tmp, hits, *hit;
			int nhits, nrects, slice[2], upper[2], lower[2], i;
			unsigned counter[2] = { atomic_read(&dev->vbl_received),
			atomic_read(&dev->vbl_received2) };
			drm_drawable_info_t *drw;
			drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
			u32 cpp = dev_priv->cpp;
			u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD \|
			XY_SRC_COPY_BLT_WRITE_ALPHA \|
			XY_SRC_COPY_BLT_WRITE_RGB)
			: XY_SRC_COPY_BLT_CMD;
			u32 pitchropcpp = (sarea_priv->pitch * cpp) \| (0xcc << 16) \|
			(cpp << 23) \| (1 << 24);
			RING_LOCALS;

	DRM_DEBUG("\n");		DRM_DEBUG("\n");

			INIT_LIST_HEAD(&hits);

			nhits = nrects = 0;

	spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);		spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);

			/* Find buffer swaps scheduled for this vertical blank */
	list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {		list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {
	drm_i915_vbl_swap_t *vbl_swap =		drm_i915_vbl_swap_t *vbl_swap =
	list_entry(list, drm_i915_vbl_swap_t, head);		list_entry(list, drm_i915_vbl_swap_t, head);
	atomic_t *counter = vbl_swap->pipe ? &dev->vbl_received2 :
	&dev->vbl_received;

	if ((atomic_read(counter) - vbl_swap->sequence) <= (1<<23)) {		if ((counter[vbl_swap->pipe] - vbl_swap->sequence) > (1<<23))
	drm_drawable_info_t *drw;		continue;

	spin_unlock(&dev_priv->swaps_lock);		list_del(list);
			dev_priv->swaps_pending--;

			spin_unlock(&dev_priv->swaps_lock);
	spin_lock(&dev->drw_lock);		spin_lock(&dev->drw_lock);

	drw = drm_get_drawable_info(dev, vbl_swap->drw_id);		drw = drm_get_drawable_info(dev, vbl_swap->drw_id);

	if (drw) {		if (!drw) {
	int i, num_rects = drw->num_rects;		spin_unlock(&dev->drw_lock);
	drm_clip_rect_t *rect = drw->rects;		drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
	drm_i915_sarea_t *sarea_priv =		spin_lock(&dev_priv->swaps_lock);
	dev_priv->sarea_priv;		continue;
	u32 cpp = dev_priv->cpp;		}
	u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD \|
	XY_SRC_COPY_BLT_WRITE_ALPHA \|		list_for_each(hit, &hits) {
	XY_SRC_COPY_BLT_WRITE_RGB)		drm_i915_vbl_swap_t *swap_cmp =
	: XY_SRC_COPY_BLT_CMD;		list_entry(hit, drm_i915_vbl_swap_t, head);
	u32 pitchropcpp = (sarea_priv->pitch * cpp) \|		drm_drawable_info_t *drw_cmp =
	(0xcc << 16) \| (cpp << 23) \|		drm_get_drawable_info(dev, swap_cmp->drw_id);
	(1 << 24);
	RING_LOCALS;		if (drw_cmp &&
			drw_cmp->rects[0].y1 > drw->rects[0].y1) {
			list_add_tail(list, hit);
			break;
			}
			}

			spin_unlock(&dev->drw_lock);

			/* List of hits was empty, or we reached the end of it */
			if (hit == &hits)
			list_add_tail(list, hits.prev);

			nhits++;

			spin_lock(&dev_priv->swaps_lock);
			}

			if (nhits == 0) {
			spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
			return;
			}

			spin_unlock(&dev_priv->swaps_lock);

	i915_kernel_lost_context(dev);		i915_kernel_lost_context(dev);

	@@ -89,47 +130,85 @@ static void i915_vblank_tasklet(drm_device_t *dev)
	OUT_RING(GFX_OP_DRAWRECT_INFO);		OUT_RING(GFX_OP_DRAWRECT_INFO);
	OUT_RING(0);		OUT_RING(0);
	OUT_RING(0);		OUT_RING(0);
	OUT_RING(sarea_priv->width \|		OUT_RING(sarea_priv->width \| sarea_priv->height << 16);
	sarea_priv->height << 16);		OUT_RING(sarea_priv->width \| sarea_priv->height << 16);
	OUT_RING(sarea_priv->width \|
	sarea_priv->height << 16);
	OUT_RING(0);		OUT_RING(0);

	ADVANCE_LP_RING();		ADVANCE_LP_RING();

	sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;		sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;

	for (i = 0; i < num_rects; i++, rect++) {		upper[0] = upper[1] = 0;
			slice[0] = max(sarea_priv->pipeA_h / nhits, 1);
			slice[1] = max(sarea_priv->pipeB_h / nhits, 1);
			lower[0] = sarea_priv->pipeA_y + slice[0];
			lower[1] = sarea_priv->pipeB_y + slice[0];

			spin_lock(&dev->drw_lock);

			/* Emit blits for buffer swaps, partitioning both outputs into as many
			* slices as there are buffer swaps scheduled in order to avoid tearing
			* (based on the assumption that a single buffer swap would always
			* complete before scanout starts).
			*/
			for (i = 0; i++ < nhits;
			upper[0] = lower[0], lower[0] += slice[0],
			upper[1] = lower[1], lower[1] += slice[1]) {
			if (i == nhits)
			lower[0] = lower[1] = sarea_priv->height;

			list_for_each(hit, &hits) {
			drm_i915_vbl_swap_t *swap_hit =
			list_entry(hit, drm_i915_vbl_swap_t, head);
			drm_clip_rect_t *rect;
			int num_rects, pipe;
			unsigned short top, bottom;

			drw = drm_get_drawable_info(dev, swap_hit->drw_id);

			if (!drw)
			continue;

			rect = drw->rects;
			pipe = swap_hit->pipe;
			top = upper[pipe];
			bottom = lower[pipe];

			for (num_rects = drw->num_rects; num_rects--; rect++) {
			int y1 = max(rect->y1, top);
			int y2 = min(rect->y2, bottom);

			if (y1 >= y2)
			continue;

	BEGIN_LP_RING(8);		BEGIN_LP_RING(8);

	OUT_RING(cmd);		OUT_RING(cmd);
	OUT_RING(pitchropcpp);		OUT_RING(pitchropcpp);
	OUT_RING((rect->y1 << 16) \| rect->x1);		OUT_RING((y1 << 16) \| rect->x1);
	OUT_RING((rect->y2 << 16) \| rect->x2);		OUT_RING((y2 << 16) \| rect->x2);
	OUT_RING(sarea_priv->front_offset);		OUT_RING(sarea_priv->front_offset);
	OUT_RING((rect->y1 << 16) \| rect->x1);		OUT_RING((y1 << 16) \| rect->x1);
	OUT_RING(pitchropcpp & 0xffff);		OUT_RING(pitchropcpp & 0xffff);
	OUT_RING(sarea_priv->back_offset);		OUT_RING(sarea_priv->back_offset);

	ADVANCE_LP_RING();		ADVANCE_LP_RING();
	}		}
	}		}
			}

	spin_unlock(&dev->drw_lock);		spin_unlock_irqrestore(&dev->drw_lock, irqflags);

	spin_lock(&dev_priv->swaps_lock);

	list_del(list);		list_for_each_safe(hit, tmp, &hits) {
			drm_i915_vbl_swap_t *swap_hit =
			list_entry(hit, drm_i915_vbl_swap_t, head);

	drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);		list_del(hit);

	dev_priv->swaps_pending--;		drm_free(swap_hit, sizeof(*swap_hit), DRM_MEM_DRIVER);
	}		}
	}		}

	spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
	}

	irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)		irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
	{		{
	drm_device_t dev = (drm_device_t ) arg;		drm_device_t dev = (drm_device_t ) arg;