Merge branch 'drm-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6 (cf41f8ac) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/char/drm/ati_pcigart.c

+7 −10

Original line number	Diff line number	Diff line
		@@ -59,17 +59,16 @@ static void *drm_ati_alloc_pcigart_table(void)
		int i;
		DRM_DEBUG("%s\n", __FUNCTION__);

		address = __get_free_pages(GFP_KERNEL, ATI_PCIGART_TABLE_ORDER);
		address = __get_free_pages(GFP_KERNEL \| __GFP_COMP,
		ATI_PCIGART_TABLE_ORDER);
		if (address == 0UL) {
		return 0;
		return NULL;
		}

		page = virt_to_page(address);

		for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++) {
		get_page(page);
		for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++)
		SetPageReserved(page);
		}

		DRM_DEBUG("%s: returning 0x%08lx\n", __FUNCTION__, address);
		return (void *)address;
		@@ -83,10 +82,8 @@ static void drm_ati_free_pcigart_table(void *address)

		page = virt_to_page((unsigned long)address);

		for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++) {
		__put_page(page);
		for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++)
		ClearPageReserved(page);
		}

		free_pages((unsigned long)address, ATI_PCIGART_TABLE_ORDER);
		}
		@@ -127,7 +124,7 @@ int drm_ati_pcigart_cleanup(drm_device_t dev, drm_ati_pcigart_info gart_info)
		if (gart_info->gart_table_location == DRM_ATI_GART_MAIN
		&& gart_info->addr) {
		drm_ati_free_pcigart_table(gart_info->addr);
		gart_info->addr = 0;
		gart_info->addr = NULL;
		}

		return 1;
		@@ -168,7 +165,7 @@ int drm_ati_pcigart_init(drm_device_t dev, drm_ati_pcigart_info gart_info)
		if (bus_address == 0) {
		DRM_ERROR("unable to map PCIGART pages!\n");
		drm_ati_free_pcigart_table(address);
		address = 0;
		address = NULL;
		goto done;
		}
		} else {

drivers/char/drm/drmP.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -57,6 +57,7 @@
		#include <linux/smp_lock.h> /* For (un)lock_kernel */
		#include <linux/mm.h>
		#include <linux/cdev.h>
		#include <linux/mutex.h>
		#if defined(__alpha__) \|\| defined(__powerpc__)
		#include <asm/pgtable.h> /* For pte_wrprotect */
		#endif
		@@ -623,7 +624,7 @@ typedef struct drm_device {
		/** \name Locks */
		/@{ /
		spinlock_t count_lock; /*< For inuse, drm_device::open_count, drm_device::buf_use /
		struct semaphore struct_sem; /*< For others /
		struct mutex struct_mutex; /*< For others /
		/@} /

		/** \name Usage Counters */
		@@ -658,7 +659,7 @@ typedef struct drm_device {
		/@{ /
		drm_ctx_list_t ctxlist; /< Linked list of context handles /
		int ctx_count; /*< Number of context handles /
		struct semaphore ctxlist_sem; /*< For ctxlist /
		struct mutex ctxlist_mutex; /*< For ctxlist /

		drm_map_t context_sareas; /< per-context SAREA's */
		int max_context;

drivers/char/drm/drm_auth.c

+10 −10

Original line number	Diff line number	Diff line
		@@ -56,7 +56,7 @@ static int drm_hash_magic(drm_magic_t magic)
		* \param magic magic number.
		*
		* Searches in drm_device::magiclist within all files with the same hash key
		* the one with matching magic number, while holding the drm_device::struct_sem
		* the one with matching magic number, while holding the drm_device::struct_mutex
		* lock.
		*/
		static drm_file_t drm_find_file(drm_device_t dev, drm_magic_t magic)
		@@ -65,14 +65,14 @@ static drm_file_t drm_find_file(drm_device_t dev, drm_magic_t magic)
		drm_magic_entry_t *pt;
		int hash = drm_hash_magic(magic);

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
		if (pt->magic == magic) {
		retval = pt->priv;
		break;
		}
		}
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return retval;
		}

		@@ -85,7 +85,7 @@ static drm_file_t drm_find_file(drm_device_t dev, drm_magic_t magic)
		*
		* Creates a drm_magic_entry structure and appends to the linked list
		* associated the magic number hash key in drm_device::magiclist, while holding
		* the drm_device::struct_sem lock.
		* the drm_device::struct_mutex lock.
		*/
		static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
		drm_magic_t magic)
		@@ -104,7 +104,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
		entry->priv = priv;
		entry->next = NULL;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		if (dev->magiclist[hash].tail) {
		dev->magiclist[hash].tail->next = entry;
		dev->magiclist[hash].tail = entry;
		@@ -112,7 +112,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
		dev->magiclist[hash].head = entry;
		dev->magiclist[hash].tail = entry;
		}
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		return 0;
		}
		@@ -124,7 +124,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
		* \param magic magic number.
		*
		* Searches and unlinks the entry in drm_device::magiclist with the magic
		* number hash key, while holding the drm_device::struct_sem lock.
		* number hash key, while holding the drm_device::struct_mutex lock.
		*/
		static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
		{
		@@ -135,7 +135,7 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
		DRM_DEBUG("%d\n", magic);
		hash = drm_hash_magic(magic);

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
		if (pt->magic == magic) {
		if (dev->magiclist[hash].head == pt) {
		@@ -147,11 +147,11 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
		if (prev) {
		prev->next = pt->next;
		}
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}
		}
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);

drivers/char/drm/drm_bufs.c

+40 −40

Original line number	Diff line number	Diff line
		@@ -255,14 +255,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
		memset(list, 0, sizeof(*list));
		list->map = map;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		list_add(&list->head, &dev->maplist->head);
		/* Assign a 32-bit handle */
		/* We do it here so that dev->struct_sem protects the increment */
		/* We do it here so that dev->struct_mutex protects the increment */
		list->user_token = HandleID(map->type == _DRM_SHM
		? (unsigned long)map->handle
		: map->offset, dev);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		*maplist = list;
		return 0;
		@@ -392,9 +392,9 @@ int drm_rmmap(drm_device_t dev, drm_local_map_t map)
		{
		int ret;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		ret = drm_rmmap_locked(dev, map);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		return ret;
		}
		@@ -423,7 +423,7 @@ int drm_rmmap_ioctl(struct inode inode, struct file filp,
		return -EFAULT;
		}

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		list_for_each(list, &dev->maplist->head) {
		drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);

		@@ -439,7 +439,7 @@ int drm_rmmap_ioctl(struct inode inode, struct file filp,
		* find anything.
		*/
		if (list == (&dev->maplist->head)) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -EINVAL;
		}

		@@ -448,13 +448,13 @@ int drm_rmmap_ioctl(struct inode inode, struct file filp,

		/* Register and framebuffer maps are permanent */
		if ((map->type == _DRM_REGISTERS) \|\| (map->type == _DRM_FRAME_BUFFER)) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		ret = drm_rmmap_locked(dev, map);

		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		return ret;
		}
		@@ -566,16 +566,16 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
		atomic_inc(&dev->buf_alloc);
		spin_unlock(&dev->count_lock);

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		entry = &dma->bufs[order];
		if (entry->buf_count) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM; /* May only call once for each order */
		}

		if (count < 0 \|\| count > 4096) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -EINVAL;
		}
		@@ -583,7 +583,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
		entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
		DRM_MEM_BUFS);
		if (!entry->buflist) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -616,7 +616,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
		/* Set count correctly so we free the proper amount. */
		entry->buf_count = count;
		drm_cleanup_buf_error(dev, entry);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -638,7 +638,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
		if (!temp_buflist) {
		/* Free the entry because it isn't valid */
		drm_cleanup_buf_error(dev, entry);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -656,7 +656,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
		DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
		DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);

		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		request->count = entry->buf_count;
		request->size = size;
		@@ -722,16 +722,16 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		atomic_inc(&dev->buf_alloc);
		spin_unlock(&dev->count_lock);

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		entry = &dma->bufs[order];
		if (entry->buf_count) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM; /* May only call once for each order */
		}

		if (count < 0 \|\| count > 4096) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -EINVAL;
		}
		@@ -739,7 +739,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
		DRM_MEM_BUFS);
		if (!entry->buflist) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -750,7 +750,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		if (!entry->seglist) {
		drm_free(entry->buflist,
		count * sizeof(*entry->buflist), DRM_MEM_BUFS);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -766,7 +766,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		count * sizeof(*entry->buflist), DRM_MEM_BUFS);
		drm_free(entry->seglist,
		count * sizeof(*entry->seglist), DRM_MEM_SEGS);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -790,7 +790,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		drm_free(temp_pagelist,
		(dma->page_count + (count << page_order))
		* sizeof(*dma->pagelist), DRM_MEM_PAGES);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -831,7 +831,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		(count << page_order))
		* sizeof(*dma->pagelist),
		DRM_MEM_PAGES);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -853,7 +853,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		drm_free(temp_pagelist,
		(dma->page_count + (count << page_order))
		* sizeof(*dma->pagelist), DRM_MEM_PAGES);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -878,7 +878,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
		dma->page_count += entry->seg_count << page_order;
		dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);

		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		request->count = entry->buf_count;
		request->size = size;
		@@ -948,16 +948,16 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
		atomic_inc(&dev->buf_alloc);
		spin_unlock(&dev->count_lock);

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		entry = &dma->bufs[order];
		if (entry->buf_count) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM; /* May only call once for each order */
		}

		if (count < 0 \|\| count > 4096) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -EINVAL;
		}
		@@ -965,7 +965,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
		entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
		DRM_MEM_BUFS);
		if (!entry->buflist) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -999,7 +999,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
		/* Set count correctly so we free the proper amount. */
		entry->buf_count = count;
		drm_cleanup_buf_error(dev, entry);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -1022,7 +1022,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
		if (!temp_buflist) {
		/* Free the entry because it isn't valid */
		drm_cleanup_buf_error(dev, entry);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -1040,7 +1040,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
		DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
		DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);

		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		request->count = entry->buf_count;
		request->size = size;
		@@ -1110,16 +1110,16 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
		atomic_inc(&dev->buf_alloc);
		spin_unlock(&dev->count_lock);

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		entry = &dma->bufs[order];
		if (entry->buf_count) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM; /* May only call once for each order */
		}

		if (count < 0 \|\| count > 4096) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -EINVAL;
		}
		@@ -1127,7 +1127,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
		entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
		DRM_MEM_BUFS);
		if (!entry->buflist) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -1160,7 +1160,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
		/* Set count correctly so we free the proper amount. */
		entry->buf_count = count;
		drm_cleanup_buf_error(dev, entry);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -1182,7 +1182,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
		if (!temp_buflist) {
		/* Free the entry because it isn't valid */
		drm_cleanup_buf_error(dev, entry);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		atomic_dec(&dev->buf_alloc);
		return -ENOMEM;
		}
		@@ -1200,7 +1200,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
		DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
		DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);

		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		request->count = entry->buf_count;
		request->size = size;

drivers/char/drm/drm_context.c

+26 −26

Original line number	Diff line number	Diff line
		@@ -53,7 +53,7 @@
		* \param ctx_handle context handle.
		*
		* Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry
		* in drm_device::context_sareas, while holding the drm_device::struct_sem
		* in drm_device::context_sareas, while holding the drm_device::struct_mutex
		* lock.
		*/
		void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
		@@ -64,10 +64,10 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
		goto failed;

		if (ctx_handle < DRM_MAX_CTXBITMAP) {
		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		clear_bit(ctx_handle, dev->ctx_bitmap);
		dev->context_sareas[ctx_handle] = NULL;
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return;
		}
		failed:
		@@ -83,7 +83,7 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
		*
		* Find the first zero bit in drm_device::ctx_bitmap and (re)allocates
		* drm_device::context_sareas to accommodate the new entry while holding the
		* drm_device::struct_sem lock.
		* drm_device::struct_mutex lock.
		*/
		static int drm_ctxbitmap_next(drm_device_t * dev)
		{
		@@ -92,7 +92,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
		if (!dev->ctx_bitmap)
		return -1;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
		if (bit < DRM_MAX_CTXBITMAP) {
		set_bit(bit, dev->ctx_bitmap);
		@@ -113,7 +113,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
		DRM_MEM_MAPS);
		if (!ctx_sareas) {
		clear_bit(bit, dev->ctx_bitmap);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -1;
		}
		dev->context_sareas = ctx_sareas;
		@@ -126,16 +126,16 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
		DRM_MEM_MAPS);
		if (!dev->context_sareas) {
		clear_bit(bit, dev->ctx_bitmap);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -1;
		}
		dev->context_sareas[bit] = NULL;
		}
		}
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return bit;
		}
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -1;
		}

		@@ -145,24 +145,24 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
		* \param dev DRM device.
		*
		* Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding
		* the drm_device::struct_sem lock.
		* the drm_device::struct_mutex lock.
		*/
		int drm_ctxbitmap_init(drm_device_t * dev)
		{
		int i;
		int temp;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		dev->ctx_bitmap = (unsigned long *)drm_alloc(PAGE_SIZE,
		DRM_MEM_CTXBITMAP);
		if (dev->ctx_bitmap == NULL) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -ENOMEM;
		}
		memset((void *)dev->ctx_bitmap, 0, PAGE_SIZE);
		dev->context_sareas = NULL;
		dev->max_context = -1;
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
		temp = drm_ctxbitmap_next(dev);
		@@ -178,17 +178,17 @@ int drm_ctxbitmap_init(drm_device_t * dev)
		* \param dev DRM device.
		*
		* Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding
		* the drm_device::struct_sem lock.
		* the drm_device::struct_mutex lock.
		*/
		void drm_ctxbitmap_cleanup(drm_device_t * dev)
		{
		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		if (dev->context_sareas)
		drm_free(dev->context_sareas,
		sizeof(dev->context_sareas)
		dev->max_context, DRM_MEM_MAPS);
		drm_free((void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP);
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		}

		/@}/
		@@ -222,15 +222,15 @@ int drm_getsareactx(struct inode inode, struct file filp,
		if (copy_from_user(&request, argp, sizeof(request)))
		return -EFAULT;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		if (dev->max_context < 0
		\|\| request.ctx_id >= (unsigned)dev->max_context) {
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -EINVAL;
		}

		map = dev->context_sareas[request.ctx_id];
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);

		request.handle = NULL;
		list_for_each_entry(_entry, &dev->maplist->head, head) {
		@@ -274,7 +274,7 @@ int drm_setsareactx(struct inode inode, struct file filp,
		(drm_ctx_priv_map_t __user *) arg, sizeof(request)))
		return -EFAULT;

		down(&dev->struct_sem);
		mutex_lock(&dev->struct_mutex);
		list_for_each(list, &dev->maplist->head) {
		r_list = list_entry(list, drm_map_list_t, head);
		if (r_list->map
		@@ -282,7 +282,7 @@ int drm_setsareactx(struct inode inode, struct file filp,
		goto found;
		}
		bad:
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return -EINVAL;

		found:
		@@ -294,7 +294,7 @@ int drm_setsareactx(struct inode inode, struct file filp,
		if (request.ctx_id >= (unsigned)dev->max_context)
		goto bad;
		dev->context_sareas[request.ctx_id] = map;
		up(&dev->struct_sem);
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		@@ -448,10 +448,10 @@ int drm_addctx(struct inode inode, struct file filp,
		ctx_entry->handle = ctx.handle;
		ctx_entry->tag = priv;

		down(&dev->ctxlist_sem);
		mutex_lock(&dev->ctxlist_mutex);
		list_add(&ctx_entry->head, &dev->ctxlist->head);
		++dev->ctx_count;
		up(&dev->ctxlist_sem);
		mutex_unlock(&dev->ctxlist_mutex);

		if (copy_to_user(argp, &ctx, sizeof(ctx)))
		return -EFAULT;
		@@ -574,7 +574,7 @@ int drm_rmctx(struct inode inode, struct file filp,
		drm_ctxbitmap_free(dev, ctx.handle);
		}

		down(&dev->ctxlist_sem);
		mutex_lock(&dev->ctxlist_mutex);
		if (!list_empty(&dev->ctxlist->head)) {
		drm_ctx_list_t pos, n;

		@@ -586,7 +586,7 @@ int drm_rmctx(struct inode inode, struct file filp,
		}
		}
		}
		up(&dev->ctxlist_sem);
		mutex_unlock(&dev->ctxlist_mutex);

		return 0;
		}