Merge remote branch 'airlied/drm-core-next' into HEAD (b970be7c) · Commits · e / devices / android_kernel_teracube_emerald

drivers/gpu/drm/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -5,7 +5,7 @@
		ccflags-y := -Iinclude/drm

		drm-y := drm_auth.o drm_buffer.o drm_bufs.o drm_cache.o \
		drm_context.o drm_dma.o drm_drawable.o \
		drm_context.o drm_dma.o \
		drm_drv.o drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
		drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
		drm_agpsupport.o drm_scatter.o ati_pcigart.o drm_pci.o \

drivers/gpu/drm/drm_agpsupport.c

+4 −36

Original line number	Diff line number	Diff line
		@@ -193,7 +193,7 @@ int drm_agp_enable_ioctl(struct drm_device dev, void data,
		* \return zero on success or a negative number on failure.
		*
		* Verifies the AGP device is present and has been acquired, allocates the
		* memory via alloc_agp() and creates a drm_agp_mem entry for it.
		* memory via agp_allocate_memory() and creates a drm_agp_mem entry for it.
		*/
		int drm_agp_alloc(struct drm_device dev, struct drm_agp_buffer request)
		{
		@@ -211,7 +211,7 @@ int drm_agp_alloc(struct drm_device dev, struct drm_agp_buffer request)

		pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
		type = (u32) request->type;
		if (!(memory = drm_alloc_agp(dev, pages, type))) {
		if (!(memory = agp_allocate_memory(dev->agp->bridge, pages, type))) {
		kfree(entry);
		return -ENOMEM;
		}
		@@ -423,38 +423,6 @@ struct drm_agp_head drm_agp_init(struct drm_device dev)
		return head;
		}

		/** Calls agp_allocate_memory() */
		DRM_AGP_MEM drm_agp_allocate_memory(struct agp_bridge_data bridge,
		size_t pages, u32 type)
		{
		return agp_allocate_memory(bridge, pages, type);
		}

		/** Calls agp_free_memory() */
		int drm_agp_free_memory(DRM_AGP_MEM * handle)
		{
		if (!handle)
		return 0;
		agp_free_memory(handle);
		return 1;
		}

		/** Calls agp_bind_memory() */
		int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start)
		{
		if (!handle)
		return -EINVAL;
		return agp_bind_memory(handle, start);
		}

		/** Calls agp_unbind_memory() */
		int drm_agp_unbind_memory(DRM_AGP_MEM * handle)
		{
		if (!handle)
		return -EINVAL;
		return agp_unbind_memory(handle);
		}

		/**
		* Binds a collection of pages into AGP memory at the given offset, returning
		* the AGP memory structure containing them.
		@@ -474,7 +442,7 @@ drm_agp_bind_pages(struct drm_device *dev,

		DRM_DEBUG("\n");

		mem = drm_agp_allocate_memory(dev->agp->bridge, num_pages,
		mem = agp_allocate_memory(dev->agp->bridge, num_pages,
		type);
		if (mem == NULL) {
		DRM_ERROR("Failed to allocate memory for %ld pages\n",
		@@ -487,7 +455,7 @@ drm_agp_bind_pages(struct drm_device *dev,
		mem->page_count = num_pages;

		mem->is_flushed = true;
		ret = drm_agp_bind_memory(mem, gtt_offset / PAGE_SIZE);
		ret = agp_bind_memory(mem, gtt_offset / PAGE_SIZE);
		if (ret != 0) {
		DRM_ERROR("Failed to bind AGP memory: %d\n", ret);
		agp_free_memory(mem);

drivers/gpu/drm/drm_context.c

+0 −8

Original line number	Diff line number	Diff line
		@@ -333,14 +333,6 @@ int drm_addctx(struct drm_device dev, void data,
		return -ENOMEM;
		}

		if (ctx->handle != DRM_KERNEL_CONTEXT) {
		if (dev->driver->context_ctor)
		if (!dev->driver->context_ctor(dev, ctx->handle)) {
		DRM_DEBUG("Running out of ctxs or memory.\n");
		return -ENOMEM;
		}
		}

		ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL);
		if (!ctx_entry) {
		DRM_DEBUG("out of memory\n");

drivers/gpu/drm/drm_drawable.c

deleted100644 → 0

+0 −198

Original line number	Diff line number	Diff line
		/**
		* \file drm_drawable.c
		* IOCTLs for drawables
		*
		* \author Rickard E. (Rik) Faith <faith@valinux.com>
		* \author Gareth Hughes <gareth@valinux.com>
		* \author Michel Dänzer <michel@tungstengraphics.com>
		*/

		/*
		* Created: Tue Feb 2 08:37:54 1999 by faith@valinux.com
		*
		* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
		* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
		* Copyright 2006 Tungsten Graphics, Inc., Bismarck, North Dakota.
		* All Rights Reserved.
		*
		* Permission is hereby granted, free of charge, to any person obtaining a
		* copy of this software and associated documentation files (the "Software"),
		* to deal in the Software without restriction, including without limitation
		* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		* and/or sell copies of the Software, and to permit persons to whom the
		* Software is furnished to do so, subject to the following conditions:
		*
		* The above copyright notice and this permission notice (including the next
		* paragraph) shall be included in all copies or substantial portions of the
		* Software.
		*
		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
		* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		* OTHER DEALINGS IN THE SOFTWARE.
		*/

		#include "drmP.h"

		/**
		* Allocate drawable ID and memory to store information about it.
		*/
		int drm_adddraw(struct drm_device dev, void data, struct drm_file *file_priv)
		{
		unsigned long irqflags;
		struct drm_draw *draw = data;
		int new_id = 0;
		int ret;

		again:
		if (idr_pre_get(&dev->drw_idr, GFP_KERNEL) == 0) {
		DRM_ERROR("Out of memory expanding drawable idr\n");
		return -ENOMEM;
		}

		spin_lock_irqsave(&dev->drw_lock, irqflags);
		ret = idr_get_new_above(&dev->drw_idr, NULL, 1, &new_id);
		if (ret == -EAGAIN) {
		spin_unlock_irqrestore(&dev->drw_lock, irqflags);
		goto again;
		}

		spin_unlock_irqrestore(&dev->drw_lock, irqflags);

		draw->handle = new_id;

		DRM_DEBUG("%d\n", draw->handle);

		return 0;
		}

		/**
		* Free drawable ID and memory to store information about it.
		*/
		int drm_rmdraw(struct drm_device dev, void data, struct drm_file *file_priv)
		{
		struct drm_draw *draw = data;
		unsigned long irqflags;
		struct drm_drawable_info *info;

		spin_lock_irqsave(&dev->drw_lock, irqflags);

		info = drm_get_drawable_info(dev, draw->handle);
		if (info == NULL) {
		spin_unlock_irqrestore(&dev->drw_lock, irqflags);
		return -EINVAL;
		}
		kfree(info->rects);
		kfree(info);

		idr_remove(&dev->drw_idr, draw->handle);

		spin_unlock_irqrestore(&dev->drw_lock, irqflags);
		DRM_DEBUG("%d\n", draw->handle);
		return 0;
		}

		int drm_update_drawable_info(struct drm_device dev, void data, struct drm_file *file_priv)
		{
		struct drm_update_draw *update = data;
		unsigned long irqflags;
		struct drm_clip_rect *rects;
		struct drm_drawable_info *info;
		int err;

		info = idr_find(&dev->drw_idr, update->handle);
		if (!info) {
		info = kzalloc(sizeof(*info), GFP_KERNEL);
		if (!info)
		return -ENOMEM;
		if (IS_ERR(idr_replace(&dev->drw_idr, info, update->handle))) {
		DRM_ERROR("No such drawable %d\n", update->handle);
		kfree(info);
		return -EINVAL;
		}
		}

		switch (update->type) {
		case DRM_DRAWABLE_CLIPRECTS:
		if (update->num == 0)
		rects = NULL;
		else if (update->num != info->num_rects) {
		rects = kmalloc(update->num *
		sizeof(struct drm_clip_rect),
		GFP_KERNEL);
		} else
		rects = info->rects;

		if (update->num && !rects) {
		DRM_ERROR("Failed to allocate cliprect memory\n");
		err = -ENOMEM;
		goto error;
		}

		if (update->num && DRM_COPY_FROM_USER(rects,
		(struct drm_clip_rect __user *)
		(unsigned long)update->data,
		update->num *
		sizeof(*rects))) {
		DRM_ERROR("Failed to copy cliprects from userspace\n");
		err = -EFAULT;
		goto error;
		}

		spin_lock_irqsave(&dev->drw_lock, irqflags);

		if (rects != info->rects) {
		kfree(info->rects);
		}

		info->rects = rects;
		info->num_rects = update->num;

		spin_unlock_irqrestore(&dev->drw_lock, irqflags);

		DRM_DEBUG("Updated %d cliprects for drawable %d\n",
		info->num_rects, update->handle);
		break;
		default:
		DRM_ERROR("Invalid update type %d\n", update->type);
		return -EINVAL;
		}

		return 0;

		error:
		if (rects != info->rects)
		kfree(rects);

		return err;
		}

		/**
		* Caller must hold the drawable spinlock!
		*/
		struct drm_drawable_info drm_get_drawable_info(struct drm_device dev, drm_drawable_t id)
		{
		return idr_find(&dev->drw_idr, id);
		}
		EXPORT_SYMBOL(drm_get_drawable_info);

		static int drm_drawable_free(int idr, void p, void data)
		{
		struct drm_drawable_info *info = p;

		if (info) {
		kfree(info->rects);
		kfree(info);
		}

		return 0;
		}

		void drm_drawable_free_all(struct drm_device *dev)
		{
		idr_for_each(&dev->drw_idr, drm_drawable_free, NULL);
		idr_remove_all(&dev->drw_idr);
		}

drivers/gpu/drm/drm_drv.c

+3 −7

Original line number	Diff line number	Diff line
		@@ -91,8 +91,8 @@ static struct drm_ioctl_desc drm_ioctls[] = {
		DRM_IOCTL_DEF(DRM_IOCTL_NEW_CTX, drm_newctx, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),
		DRM_IOCTL_DEF(DRM_IOCTL_RES_CTX, drm_resctx, DRM_AUTH),

		DRM_IOCTL_DEF(DRM_IOCTL_ADD_DRAW, drm_adddraw, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),
		DRM_IOCTL_DEF(DRM_IOCTL_RM_DRAW, drm_rmdraw, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),
		DRM_IOCTL_DEF(DRM_IOCTL_ADD_DRAW, drm_noop, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),
		DRM_IOCTL_DEF(DRM_IOCTL_RM_DRAW, drm_noop, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),

		DRM_IOCTL_DEF(DRM_IOCTL_LOCK, drm_lock, DRM_AUTH),
		DRM_IOCTL_DEF(DRM_IOCTL_UNLOCK, drm_unlock, DRM_AUTH),
		@@ -127,7 +127,7 @@ static struct drm_ioctl_desc drm_ioctls[] = {

		DRM_IOCTL_DEF(DRM_IOCTL_MODESET_CTL, drm_modeset_ctl, 0),

		DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_update_drawable_info, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),
		DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_noop, DRM_AUTH\|DRM_MASTER\|DRM_ROOT_ONLY),

		DRM_IOCTL_DEF(DRM_IOCTL_GEM_CLOSE, drm_gem_close_ioctl, DRM_UNLOCKED),
		DRM_IOCTL_DEF(DRM_IOCTL_GEM_FLINK, drm_gem_flink_ioctl, DRM_AUTH\|DRM_UNLOCKED),
		@@ -180,10 +180,6 @@ int drm_lastclose(struct drm_device * dev)

		mutex_lock(&dev->struct_mutex);

		/* Free drawable information memory */
		drm_drawable_free_all(dev);
		del_timer(&dev->timer);

		/* Clear AGP information */
		if (drm_core_has_AGP(dev) && dev->agp &&
		!drm_core_check_feature(dev, DRIVER_MODESET)) {