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

drivers/char/drm/drmP.h

+10 −26

Original line number	Original line	Diff line number	Diff line
	@@ -532,11 +532,13 @@ typedef struct drm_mm_node {
	int free;		int free;
	unsigned long start;		unsigned long start;
	unsigned long size;		unsigned long size;
			struct drm_mm *mm;
	void *private;		void *private;
	} drm_mm_node_t;		} drm_mm_node_t;

	typedef struct drm_mm {		typedef struct drm_mm {
	drm_mm_node_t root_node;		struct list_head fl_entry;
			struct list_head ml_entry;
	} drm_mm_t;		} drm_mm_t;

	/**		/**
	@@ -843,9 +845,6 @@ extern void drm_mem_init(void);
	extern int drm_mem_info(char buf, char *start, off_t offset,		extern int drm_mem_info(char buf, char *start, off_t offset,
	int request, int eof, void data);		int request, int eof, void data);
	extern void drm_realloc(void oldpt, size_t oldsize, size_t size, int area);		extern void drm_realloc(void oldpt, size_t oldsize, size_t size, int area);
	extern void *drm_ioremap(unsigned long offset, unsigned long size,
	drm_device_t * dev);
	extern void drm_ioremapfree(void pt, unsigned long size, drm_device_t dev);

	extern DRM_AGP_MEM drm_alloc_agp(drm_device_t dev, int pages, u32 type);		extern DRM_AGP_MEM drm_alloc_agp(drm_device_t dev, int pages, u32 type);
	extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);		extern int drm_free_agp(DRM_AGP_MEM * handle, int pages);
	@@ -1053,33 +1052,18 @@ extern void drm_sysfs_device_remove(struct class_device *class_dev);
	extern drm_mm_node_t drm_mm_get_block(drm_mm_node_t parent,		extern drm_mm_node_t drm_mm_get_block(drm_mm_node_t parent,
	unsigned long size,		unsigned long size,
	unsigned alignment);		unsigned alignment);
	extern void drm_mm_put_block(drm_mm_t mm, drm_mm_node_t cur);		void drm_mm_put_block(drm_mm_node_t * cur);
	extern drm_mm_node_t drm_mm_search_free(const drm_mm_t mm, unsigned long size,		extern drm_mm_node_t drm_mm_search_free(const drm_mm_t mm, unsigned long size,
	unsigned alignment, int best_match);		unsigned alignment, int best_match);
	extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size);		extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size);
	extern void drm_mm_takedown(drm_mm_t *mm);		extern void drm_mm_takedown(drm_mm_t *mm);
			extern int drm_mm_clean(drm_mm_t *mm);
			extern unsigned long drm_mm_tail_space(drm_mm_t *mm);
			extern int drm_mm_remove_space_from_tail(drm_mm_t *mm, unsigned long size);
			extern int drm_mm_add_space_to_tail(drm_mm_t *mm, unsigned long size);

	/* Inline replacements for DRM_IOREMAP macros */		extern void drm_core_ioremap(struct drm_map map, struct drm_device dev);
	static __inline__ void drm_core_ioremap(struct drm_map *map,		extern void drm_core_ioremapfree(struct drm_map map, struct drm_device dev);
	struct drm_device *dev)
	{
	map->handle = drm_ioremap(map->offset, map->size, dev);
	}

	#if 0
	static __inline__ void drm_core_ioremap_nocache(struct drm_map *map,
	struct drm_device *dev)
	{
	map->handle = drm_ioremap_nocache(map->offset, map->size, dev);
	}
	#endif /* 0 */

	static __inline__ void drm_core_ioremapfree(struct drm_map *map,
	struct drm_device *dev)
	{
	if (map->handle && map->size)
	drm_ioremapfree(map->handle, map->size, dev);
	}

	static __inline__ struct drm_map drm_core_findmap(struct drm_device dev,		static __inline__ struct drm_map drm_core_findmap(struct drm_device dev,
	unsigned int token)		unsigned int token)

drivers/char/drm/drm_bufs.c

+10 −9

Original line number	Original line	Diff line number	Diff line
	@@ -79,14 +79,14 @@ static int drm_map_handle(drm_device_t dev, drm_hash_item_t hash,

	if (!use_hashed_handle) {		if (!use_hashed_handle) {
	int ret;		int ret;
	hash->key = user_token;		hash->key = user_token >> PAGE_SHIFT;
	ret = drm_ht_insert_item(&dev->map_hash, hash);		ret = drm_ht_insert_item(&dev->map_hash, hash);
	if (ret != -EINVAL)		if (ret != -EINVAL)
	return ret;		return ret;
	}		}
	return drm_ht_just_insert_please(&dev->map_hash, hash,		return drm_ht_just_insert_please(&dev->map_hash, hash,
	user_token, 32 - PAGE_SHIFT - 3,		user_token, 32 - PAGE_SHIFT - 3,
	PAGE_SHIFT, DRM_MAP_HASH_OFFSET);		0, DRM_MAP_HASH_OFFSET >> PAGE_SHIFT);
	}		}

	/**		/**
	@@ -178,11 +178,11 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
	}		}
	}		}
	if (map->type == _DRM_REGISTERS)		if (map->type == _DRM_REGISTERS)
	map->handle = drm_ioremap(map->offset, map->size, dev);		map->handle = ioremap(map->offset, map->size);
	break;		break;

	case _DRM_SHM:		case _DRM_SHM:
	map->handle = vmalloc_32(map->size);		map->handle = vmalloc_user(map->size);
	DRM_DEBUG("%lu %d %p\n",		DRM_DEBUG("%lu %d %p\n",
	map->size, drm_order(map->size), map->handle);		map->size, drm_order(map->size), map->handle);
	if (!map->handle) {		if (!map->handle) {
	@@ -238,7 +238,7 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
	list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);		list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);
	if (!list) {		if (!list) {
	if (map->type == _DRM_REGISTERS)		if (map->type == _DRM_REGISTERS)
	drm_ioremapfree(map->handle, map->size, dev);		iounmap(map->handle);
	drm_free(map, sizeof(*map), DRM_MEM_MAPS);		drm_free(map, sizeof(*map), DRM_MEM_MAPS);
	return -EINVAL;		return -EINVAL;
	}		}
	@@ -255,14 +255,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
	ret = drm_map_handle(dev, &list->hash, user_token, 0);		ret = drm_map_handle(dev, &list->hash, user_token, 0);
	if (ret) {		if (ret) {
	if (map->type == _DRM_REGISTERS)		if (map->type == _DRM_REGISTERS)
	drm_ioremapfree(map->handle, map->size, dev);		iounmap(map->handle);
	drm_free(map, sizeof(*map), DRM_MEM_MAPS);		drm_free(map, sizeof(*map), DRM_MEM_MAPS);
	drm_free(list, sizeof(*list), DRM_MEM_MAPS);		drm_free(list, sizeof(*list), DRM_MEM_MAPS);
	mutex_unlock(&dev->struct_mutex);		mutex_unlock(&dev->struct_mutex);
	return ret;		return ret;
	}		}

	list->user_token = list->hash.key;		list->user_token = list->hash.key << PAGE_SHIFT;
	mutex_unlock(&dev->struct_mutex);		mutex_unlock(&dev->struct_mutex);

	*maplist = list;		*maplist = list;
	@@ -347,7 +347,8 @@ int drm_rmmap_locked(drm_device_t dev, drm_local_map_t map)

	if (r_list->map == map) {		if (r_list->map == map) {
	list_del(list);		list_del(list);
	drm_ht_remove_key(&dev->map_hash, r_list->user_token);		drm_ht_remove_key(&dev->map_hash,
			r_list->user_token >> PAGE_SHIFT);
	drm_free(list, sizeof(*list), DRM_MEM_MAPS);		drm_free(list, sizeof(*list), DRM_MEM_MAPS);
	break;		break;
	}		}
	@@ -362,7 +363,7 @@ int drm_rmmap_locked(drm_device_t dev, drm_local_map_t map)

	switch (map->type) {		switch (map->type) {
	case _DRM_REGISTERS:		case _DRM_REGISTERS:
	drm_ioremapfree(map->handle, map->size, dev);		iounmap(map->handle);
	/* FALLTHROUGH */		/* FALLTHROUGH */
	case _DRM_FRAME_BUFFER:		case _DRM_FRAME_BUFFER:
	if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {		if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {

drivers/char/drm/drm_memory.c

+18 −76

Original line number	Original line	Diff line number	Diff line
	@@ -79,28 +79,6 @@ void drm_realloc(void oldpt, size_t oldsize, size_t size, int area)
	}		}

	#if __OS_HAS_AGP		#if __OS_HAS_AGP
	/*
	* Find the drm_map that covers the range [offset, offset+size).
	*/
	static drm_map_t *drm_lookup_map(unsigned long offset,
	unsigned long size, drm_device_t * dev)
	{
	struct list_head *list;
	drm_map_list_t *r_list;
	drm_map_t *map;

	list_for_each(list, &dev->maplist->head) {
	r_list = (drm_map_list_t *) list;
	map = r_list->map;
	if (!map)
	continue;
	if (map->offset <= offset
	&& (offset + size) <= (map->offset + map->size))
	return map;
	}
	return NULL;
	}

	static void *agp_remap(unsigned long offset, unsigned long size,		static void *agp_remap(unsigned long offset, unsigned long size,
	drm_device_t * dev)		drm_device_t * dev)
	{		{
	@@ -169,13 +147,6 @@ int drm_unbind_agp(DRM_AGP_MEM * handle)
	}		}

	#else /* __OS_HAS_AGP */		#else /* __OS_HAS_AGP */

	static inline drm_map_t *drm_lookup_map(unsigned long offset,
	unsigned long size, drm_device_t * dev)
	{
	return NULL;
	}

	static inline void *agp_remap(unsigned long offset, unsigned long size,		static inline void *agp_remap(unsigned long offset, unsigned long size,
	drm_device_t * dev)		drm_device_t * dev)
	{		{
	@@ -184,57 +155,28 @@ static inline void *agp_remap(unsigned long offset, unsigned long size,

	#endif /* agp */		#endif /* agp */

	void *drm_ioremap(unsigned long offset, unsigned long size,		#endif /* debug_memory */
	drm_device_t * dev)
	{
	if (drm_core_has_AGP(dev) && dev->agp && dev->agp->cant_use_aperture) {
	drm_map_t *map = drm_lookup_map(offset, size, dev);

	if (map && map->type == _DRM_AGP)
	return agp_remap(offset, size, dev);
	}
	return ioremap(offset, size);
	}
	EXPORT_SYMBOL(drm_ioremap);

	#if 0		void drm_core_ioremap(struct drm_map map, struct drm_device dev)
	void *drm_ioremap_nocache(unsigned long offset,
	unsigned long size, drm_device_t * dev)
	{		{
	if (drm_core_has_AGP(dev) && dev->agp && dev->agp->cant_use_aperture) {		if (drm_core_has_AGP(dev) &&
	drm_map_t *map = drm_lookup_map(offset, size, dev);		dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
			map->handle = agp_remap(map->offset, map->size, dev);
	if (map && map->type == _DRM_AGP)		else
	return agp_remap(offset, size, dev);		map->handle = ioremap(map->offset, map->size);
	}
	return ioremap_nocache(offset, size);
	}		}
	#endif /* 0 */		EXPORT_SYMBOL(drm_core_ioremap);

	void drm_ioremapfree(void *pt, unsigned long size,		void drm_core_ioremapfree(struct drm_map map, struct drm_device dev)
	drm_device_t * dev)
	{		{
	/*		if (!map->handle \|\| !map->size)
	* This is a bit ugly. It would be much cleaner if the DRM API would use separate
	* routines for handling mappings in the AGP space. Hopefully this can be done in
	* a future revision of the interface...
	*/
	if (drm_core_has_AGP(dev) && dev->agp && dev->agp->cant_use_aperture
	&& ((unsigned long)pt >= VMALLOC_START
	&& (unsigned long)pt < VMALLOC_END)) {
	unsigned long offset;
	drm_map_t *map;

	offset = drm_follow_page(pt) \| ((unsigned long)pt & ~PAGE_MASK);
	map = drm_lookup_map(offset, size, dev);
	if (map && map->type == _DRM_AGP) {
	vunmap(pt);
	return;		return;
	}
	}

	iounmap(pt);		if (drm_core_has_AGP(dev) &&
			dev->agp && dev->agp->cant_use_aperture && map->type == _DRM_AGP)
			vunmap(map->handle);
			else
			iounmap(map->handle);
	}		}
	EXPORT_SYMBOL(drm_ioremapfree);		EXPORT_SYMBOL(drm_core_ioremapfree);

	#endif /* debug_memory */

drivers/char/drm/drm_memory.h

+0 −20

Original line number	Original line	Diff line number	Diff line
	@@ -56,26 +56,6 @@
	# endif		# endif
	#endif		#endif

	static inline unsigned long drm_follow_page(void *vaddr)
	{
	pgd_t *pgd = pgd_offset_k((unsigned long)vaddr);
	pud_t *pud = pud_offset(pgd, (unsigned long)vaddr);
	pmd_t *pmd = pmd_offset(pud, (unsigned long)vaddr);
	pte_t *ptep = pte_offset_kernel(pmd, (unsigned long)vaddr);
	return pte_pfn(*ptep) << PAGE_SHIFT;
	}

	#else /* __OS_HAS_AGP */		#else /* __OS_HAS_AGP */

	static inline unsigned long drm_follow_page(void *vaddr)
	{
	return 0;
	}

	#endif		#endif

	void *drm_ioremap(unsigned long offset, unsigned long size,
	drm_device_t * dev);

	void drm_ioremapfree(void *pt, unsigned long size,
	drm_device_t * dev);

drivers/char/drm/drm_memory_debug.h

+0 −70

Original line number	Original line	Diff line number	Diff line
	@@ -205,76 +205,6 @@ void drm_free (void *pt, size_t size, int area) {
	}		}
	}		}

	void *drm_ioremap (unsigned long offset, unsigned long size,
	drm_device_t * dev) {
	void *pt;

	if (!size) {
	DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
	"Mapping 0 bytes at 0x%08lx\n", offset);
	return NULL;
	}

	if (!(pt = drm_ioremap(offset, size, dev))) {
	spin_lock(&drm_mem_lock);
	++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count;
	spin_unlock(&drm_mem_lock);
	return NULL;
	}
	spin_lock(&drm_mem_lock);
	++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
	drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size;
	spin_unlock(&drm_mem_lock);
	return pt;
	}

	#if 0
	void *drm_ioremap_nocache (unsigned long offset, unsigned long size,
	drm_device_t * dev) {
	void *pt;

	if (!size) {
	DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
	"Mapping 0 bytes at 0x%08lx\n", offset);
	return NULL;
	}

	if (!(pt = drm_ioremap_nocache(offset, size, dev))) {
	spin_lock(&drm_mem_lock);
	++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count;
	spin_unlock(&drm_mem_lock);
	return NULL;
	}
	spin_lock(&drm_mem_lock);
	++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
	drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size;
	spin_unlock(&drm_mem_lock);
	return pt;
	}
	#endif /* 0 */

	void drm_ioremapfree (void pt, unsigned long size, drm_device_t dev) {
	int alloc_count;
	int free_count;

	if (!pt)
	DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
	"Attempt to free NULL pointer\n");
	else
	drm_ioremapfree(pt, size, dev);

	spin_lock(&drm_mem_lock);
	drm_mem_stats[DRM_MEM_MAPPINGS].bytes_freed += size;
	free_count = ++drm_mem_stats[DRM_MEM_MAPPINGS].free_count;
	alloc_count = drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
	spin_unlock(&drm_mem_lock);
	if (free_count > alloc_count) {
	DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
	"Excess frees: %d frees, %d allocs\n",
	free_count, alloc_count);
	}
	}

	#if __OS_HAS_AGP		#if __OS_HAS_AGP

	DRM_AGP_MEM drm_alloc_agp (drm_device_t dev, int pages, u32 type) {		DRM_AGP_MEM drm_alloc_agp (drm_device_t dev, int pages, u32 type) {