sgx: one build error down drm_sman.h: No such file

Signed-off-by: Robert Nelson <robertcnelson@gmail.com>

patch.sh

@@ -147,6 +147,11 @@ dsp () {
 	git am "${DIR}/patches/dsp/0003-staging-tidspbridge-use-scm-functions-to-set-boot-ad.patch"
 }
 
+sgx () {
+	echo "patches needed for external sgx bins"
+	git am "${DIR}/patches/sgx/0001-Revert-drm-kill-drm_sman.patch"
+}
+
 distro
 micrel_zippy2
 sakoman
@@ -156,6 +161,7 @@ panda
 omap_fixes
 omapdrm
 dsp
+sgx
 
 echo "patch.sh ran successful"
 

patches/sgx/0001-Revert-drm-kill-drm_sman.patch

+From ad4b9ecaa34902b9ca85d28ff346e12a9a50093f Mon Sep 17 00:00:00 2001
+From: Robert Nelson <robertcnelson@gmail.com>
+Date: Thu, 3 May 2012 19:27:52 -0500
+Subject: [PATCH] Revert "drm: kill drm_sman"
+
+This reverts commit 7a6e0daaf4058d1b7dd515bc470ec904454a798c.
+---
+ drivers/gpu/drm/Makefile   |    2 +-
+ drivers/gpu/drm/drm_sman.c |  211 ++++++++++++++++++++++++++++++++++++++++++++
+ include/drm/drm_sman.h     |  151 +++++++++++++++++++++++++++++++
+ 3 files changed, 363 insertions(+), 1 deletion(-)
+ create mode 100644 drivers/gpu/drm/drm_sman.c
+ create mode 100644 include/drm/drm_sman.h
+
+diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
+index c20da5b..cc89c0d 100644
+--- a/drivers/gpu/drm/Makefile
++++ b/drivers/gpu/drm/Makefile
+@@ -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_mm.o \
++		drm_platform.o drm_sysfs.o drm_hashtab.o drm_sman.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_prime.o
+diff --git a/drivers/gpu/drm/drm_sman.c b/drivers/gpu/drm/drm_sman.c
+new file mode 100644
+index 0000000..a8ff350
+--- /dev/null
++++ b/drivers/gpu/drm/drm_sman.c
+@@ -0,0 +1,211 @@
++/**************************************************************************
++ *
++ * 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);
+diff --git a/include/drm/drm_sman.h b/include/drm/drm_sman.h
+new file mode 100644
+index 0000000..031e521
+--- /dev/null
++++ b/include/drm/drm_sman.h
+@@ -0,0 +1,151 @@
++/**************************************************************************
++ *
++ * 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
+-- 
+1.7.10
+