drm: kill drm_sman (7a6e0daa) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/gpu/drm/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -9,7 +9,7 @@ drm-y := drm_auth.o drm_buffer.o drm_bufs.o drm_cache.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 \
		drm_platform.o drm_sysfs.o drm_hashtab.o drm_sman.o drm_mm.o \
		drm_platform.o drm_sysfs.o drm_hashtab.o drm_mm.o \
		drm_crtc.o drm_modes.o drm_edid.o \
		drm_info.o drm_debugfs.o drm_encoder_slave.o \
		drm_trace_points.o drm_global.o drm_usb.o

drivers/gpu/drm/drm_sman.c

deleted100644 → 0

+0 −211

Original line number	Diff line number	Diff line
		/**************************************************************************
		*
		* Copyright 2006 Tungsten Graphics, Inc., Bismarck., ND., USA.
		* 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, sub license, 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 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 NON-INFRINGEMENT. IN NO EVENT SHALL
		* THE COPYRIGHT HOLDERS, AUTHORS 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.
		*
		* The above copyright notice and this permission notice (including the
		* next paragraph) shall be included in all copies or substantial portions
		* of the Software.
		*
		*
		**************************************************************************/
		/*
		* Simple memory manager interface that keeps track on allocate regions on a
		* per "owner" basis. All regions associated with an "owner" can be released
		* with a simple call. Typically if the "owner" exists. The owner is any
		* "unsigned long" identifier. Can typically be a pointer to a file private
		* struct or a context identifier.
		*
		* Authors:
		* Thomas Hellström <thomas-at-tungstengraphics-dot-com>
		*/

		#include <linux/export.h>
		#include "drm_sman.h"

		struct drm_owner_item {
		struct drm_hash_item owner_hash;
		struct list_head sman_list;
		struct list_head mem_blocks;
		};

		void drm_sman_takedown(struct drm_sman * sman)
		{
		kfree(sman->mm);
		}

		EXPORT_SYMBOL(drm_sman_takedown);

		int
		drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
		unsigned int user_order, unsigned int owner_order)
		{
		int ret = 0;

		sman->mm = kcalloc(num_managers, sizeof(*sman->mm), GFP_KERNEL);
		if (!sman->mm) {
		ret = -ENOMEM;
		return ret;
		}
		sman->num_managers = num_managers;

		return 0;
		}

		EXPORT_SYMBOL(drm_sman_init);

		static void drm_sman_mm_allocate(void private, unsigned long size,
		unsigned alignment)
		{
		struct drm_mm mm = (struct drm_mm ) private;
		struct drm_mm_node *tmp;

		tmp = drm_mm_search_free(mm, size, alignment, 1);
		if (!tmp) {
		return NULL;
		}
		tmp = drm_mm_get_block(tmp, size, alignment);
		return tmp;
		}

		static void drm_sman_mm_free(void private, void ref)
		{
		struct drm_mm_node node = (struct drm_mm_node ) ref;

		drm_mm_put_block(node);
		}

		static void drm_sman_mm_destroy(void *private)
		{
		struct drm_mm mm = (struct drm_mm ) private;
		drm_mm_takedown(mm);
		kfree(mm);
		}

		static unsigned long drm_sman_mm_offset(void private, void ref)
		{
		struct drm_mm_node node = (struct drm_mm_node ) ref;
		return node->start;
		}

		int
		drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
		unsigned long start, unsigned long size)
		{
		struct drm_sman_mm *sman_mm;
		struct drm_mm *mm;
		int ret;

		BUG_ON(manager >= sman->num_managers);

		sman_mm = &sman->mm[manager];
		mm = kzalloc(sizeof(*mm), GFP_KERNEL);
		if (!mm) {
		return -ENOMEM;
		}
		sman_mm->private = mm;
		ret = drm_mm_init(mm, start, size);

		if (ret) {
		kfree(mm);
		return ret;
		}

		sman_mm->allocate = drm_sman_mm_allocate;
		sman_mm->free = drm_sman_mm_free;
		sman_mm->destroy = drm_sman_mm_destroy;
		sman_mm->offset = drm_sman_mm_offset;

		return 0;
		}

		EXPORT_SYMBOL(drm_sman_set_range);

		int
		drm_sman_set_manager(struct drm_sman * sman, unsigned int manager,
		struct drm_sman_mm * allocator)
		{
		BUG_ON(manager >= sman->num_managers);
		sman->mm[manager] = *allocator;

		return 0;
		}
		EXPORT_SYMBOL(drm_sman_set_manager);

		struct drm_memblock_item drm_sman_alloc(struct drm_sman sman, unsigned int manager,
		unsigned long size, unsigned alignment,
		unsigned long owner)
		{
		void *tmp;
		struct drm_sman_mm *sman_mm;
		struct drm_memblock_item *memblock;

		BUG_ON(manager >= sman->num_managers);

		sman_mm = &sman->mm[manager];
		tmp = sman_mm->allocate(sman_mm->private, size, alignment);

		if (!tmp) {
		return NULL;
		}

		memblock = kzalloc(sizeof(*memblock), GFP_KERNEL);

		if (!memblock)
		goto out;

		memblock->mm_info = tmp;
		memblock->mm = sman_mm;
		memblock->sman = sman;

		return memblock;

		out:
		sman_mm->free(sman_mm->private, tmp);

		return NULL;
		}

		EXPORT_SYMBOL(drm_sman_alloc);

		void drm_sman_free(struct drm_memblock_item *item)
		{
		list_del(&item->owner_list);
		item->mm->free(item->mm->private, item->mm_info);
		kfree(item);
		}
		EXPORT_SYMBOL(drm_sman_free);

		void drm_sman_cleanup(struct drm_sman *sman)
		{
		unsigned int i;
		struct drm_sman_mm *sman_mm;

		if (sman->mm) {
		for (i = 0; i < sman->num_managers; ++i) {
		sman_mm = &sman->mm[i];
		if (sman_mm->private) {
		sman_mm->destroy(sman_mm->private);
		sman_mm->private = NULL;
		}
		}
		}
		}

		EXPORT_SYMBOL(drm_sman_cleanup);

include/drm/drm_sman.h

deleted100644 → 0

+0 −151

Original line number	Diff line number	Diff line
		/**************************************************************************
		*
		* Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
		* 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, sub license, 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 NON-INFRINGEMENT. IN NO EVENT SHALL
		* THE COPYRIGHT HOLDERS, AUTHORS 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.
		*
		*
		**************************************************************************/
		/*
		* Simple memory MANager interface that keeps track on allocate regions on a
		* per "owner" basis. All regions associated with an "owner" can be released
		* with a simple call. Typically if the "owner" exists. The owner is any
		* "unsigned long" identifier. Can typically be a pointer to a file private
		* struct or a context identifier.
		*
		* Authors:
		* Thomas Hellström <thomas-at-tungstengraphics-dot-com>
		*/

		#ifndef DRM_SMAN_H
		#define DRM_SMAN_H

		#include "drmP.h"
		#include "drm_hashtab.h"

		/*
		* A class that is an abstration of a simple memory allocator.
		* The sman implementation provides a default such allocator
		* using the drm_mm.c implementation. But the user can replace it.
		* See the SiS implementation, which may use the SiS FB kernel module
		* for memory management.
		*/

		struct drm_sman_mm {
		/* private info. If allocated, needs to be destroyed by the destroy
		function */
		void *private;

		/* Allocate a memory block with given size and alignment.
		Return an opaque reference to the memory block */

		void (allocate) (void *private, unsigned long size,
		unsigned alignment);

		/* Free a memory block. "ref" is the opaque reference that we got from
		the "alloc" function */

		void (free) (void private, void *ref);

		/* Free all resources associated with this allocator */

		void (destroy) (void private);

		/* Return a memory offset from the opaque reference returned from the
		"alloc" function */

		unsigned long (offset) (void private, void *ref);
		};

		struct drm_memblock_item {
		struct list_head owner_list;
		struct drm_hash_item user_hash;
		void *mm_info;
		struct drm_sman_mm *mm;
		struct drm_sman *sman;
		};

		struct drm_sman {
		struct drm_sman_mm *mm;
		int num_managers;
		};

		/*
		* Take down a memory manager. This function should only be called after a
		* successful init and after a call to drm_sman_cleanup.
		*/

		extern void drm_sman_takedown(struct drm_sman * sman);

		/*
		* Allocate structures for a manager.
		* num_managers are the number of memory pools to manage. (VRAM, AGP, ....)
		* user_order is the log2 of the number of buckets in the user hash table.
		* set this to approximately log2 of the max number of memory regions
		* that will be allocated for _all_ pools together.
		* owner_order is the log2 of the number of buckets in the owner hash table.
		* set this to approximately log2 of
		* the number of client file connections that will
		* be using the manager.
		*
		*/

		extern int drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
		unsigned int user_order, unsigned int owner_order);

		/*
		* Initialize a drm_mm.c allocator. Should be called only once for each
		* manager unless a customized allogator is used.
		*/

		extern int drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
		unsigned long start, unsigned long size);

		/*
		* Initialize a customized allocator for one of the managers.
		* (See the SiS module). The object pointed to by "allocator" is copied,
		* so it can be destroyed after this call.
		*/

		extern int drm_sman_set_manager(struct drm_sman * sman, unsigned int mananger,
		struct drm_sman_mm * allocator);

		/*
		* Allocate a memory block. Aligment is not implemented yet.
		*/

		extern struct drm_memblock_item drm_sman_alloc(struct drm_sman sman,
		unsigned int manager,
		unsigned long size,
		unsigned alignment,
		unsigned long owner);

		extern void drm_sman_free(struct drm_memblock_item *item);

		/*
		* Frees all stale memory blocks associated with the memory manager.
		* See idling above.
		*/

		extern void drm_sman_cleanup(struct drm_sman * sman);

		#endif