[PATCH 13/28] staging: memrar: remove driver from tree

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



It's no longer needed at all.

Cc: Ossama Othman <ossama.othman@xxxxxxxxx>
Cc: Eugene Epshteyn <eugene.epshteyn@xxxxxxxxx>
Cc: Alan Cox <alan@xxxxxxxxxxxxxxx>
Signed-off-by: Greg Kroah-Hartman <gregkh@xxxxxxx>
---
 drivers/staging/Kconfig                   |    2 -
 drivers/staging/Makefile                  |    1 -
 drivers/staging/memrar/Kconfig            |   15 -
 drivers/staging/memrar/Makefile           |    2 -
 drivers/staging/memrar/TODO               |   43 --
 drivers/staging/memrar/memrar-abi         |   89 ---
 drivers/staging/memrar/memrar.h           |  174 -----
 drivers/staging/memrar/memrar_allocator.c |  432 ------------
 drivers/staging/memrar/memrar_allocator.h |  149 -----
 drivers/staging/memrar/memrar_handler.c   | 1007 -----------------------------
 10 files changed, 0 insertions(+), 1914 deletions(-)
 delete mode 100644 drivers/staging/memrar/Kconfig
 delete mode 100644 drivers/staging/memrar/Makefile
 delete mode 100644 drivers/staging/memrar/TODO
 delete mode 100644 drivers/staging/memrar/memrar-abi
 delete mode 100644 drivers/staging/memrar/memrar.h
 delete mode 100644 drivers/staging/memrar/memrar_allocator.c
 delete mode 100644 drivers/staging/memrar/memrar_allocator.h
 delete mode 100644 drivers/staging/memrar/memrar_handler.c

diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index 18b43fc..dca4a0b 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -117,8 +117,6 @@ source "drivers/staging/hv/Kconfig"
 
 source "drivers/staging/vme/Kconfig"
 
-source "drivers/staging/memrar/Kconfig"
-
 source "drivers/staging/sep/Kconfig"
 
 source "drivers/staging/iio/Kconfig"
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index cfd13cd..eb93012 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -40,7 +40,6 @@ obj-$(CONFIG_VT6655)		+= vt6655/
 obj-$(CONFIG_VT6656)		+= vt6656/
 obj-$(CONFIG_HYPERV)		+= hv/
 obj-$(CONFIG_VME_BUS)		+= vme/
-obj-$(CONFIG_MRST_RAR_HANDLER)	+= memrar/
 obj-$(CONFIG_DX_SEP)            += sep/
 obj-$(CONFIG_IIO)		+= iio/
 obj-$(CONFIG_CS5535_GPIO)	+= cs5535_gpio/
diff --git a/drivers/staging/memrar/Kconfig b/drivers/staging/memrar/Kconfig
deleted file mode 100644
index cbeebc5..0000000
--- a/drivers/staging/memrar/Kconfig
+++ /dev/null
@@ -1,15 +0,0 @@
-config MRST_RAR_HANDLER
-	tristate "RAR handler driver for Intel Moorestown platform"
-	depends on RAR_REGISTER
-	---help---
-	  This driver provides a memory management interface to
-	  restricted access regions (RAR) available on the Intel
-	  Moorestown platform.
-
-	  Once locked down, restricted access regions are only
-	  accessible by specific hardware on the platform.  The x86
-	  CPU is typically not one of those platforms.  As such this
-	  driver does not access RAR, and only provides a buffer
-	  allocation/bookkeeping mechanism.
-
-	  If unsure, say N.
diff --git a/drivers/staging/memrar/Makefile b/drivers/staging/memrar/Makefile
deleted file mode 100644
index a3336c0..0000000
--- a/drivers/staging/memrar/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-obj-$(CONFIG_MRST_RAR_HANDLER)	+= memrar.o
-memrar-y			:= memrar_allocator.o memrar_handler.o
diff --git a/drivers/staging/memrar/TODO b/drivers/staging/memrar/TODO
deleted file mode 100644
index 435e09b..0000000
--- a/drivers/staging/memrar/TODO
+++ /dev/null
@@ -1,43 +0,0 @@
-RAR Handler (memrar) Driver TODO Items
-======================================
-
-Maintainer: Eugene Epshteyn <eugene.epshteyn@xxxxxxxxx>
-
-memrar.h
---------
-1. This header exposes the driver's user space and kernel space
-   interfaces.  It should be moved to <linux/rar/memrar.h>, or
-   something along those lines, when this memrar driver is moved out
-   of `staging'.
-     a. It would be ideal if staging/rar_register/rar_register.h was
-        moved to the same directory.
-
-memrar_allocator.[ch]
----------------------
-1. Address potential fragmentation issues with the memrar_allocator.
-
-2. Hide struct memrar_allocator details/fields.  They need not be
-   exposed to the user.
-     a. Forward declare struct memrar_allocator.
-     b. Move all three struct definitions to `memrar_allocator.c'
-        source file.
-     c. Add a memrar_allocator_largest_free_area() function, or
-        something like that to get access to the value of the struct
-        memrar_allocator "largest_free_area" field.  This allows the
-        struct memrar_allocator fields to be completely hidden from
-        the user.  The memrar_handler code really only needs this for
-        statistic gathering on-demand.
-     d. Do the same for the "capacity" field as the
-        "largest_free_area" field.
-
-3. Move memrar_allocator.* to kernel `lib' directory since it is HW
-   neutral.
-     a. Alternatively, use lib/genalloc.c instead.
-     b. A kernel port of Doug Lea's malloc() implementation may also
-        be an option.
-
-memrar_handler.c
-----------------
-1. Split user space interface (ioctl code) from core/kernel code,
-   e.g.:
-     memrar_handler.c -> memrar_core.c, memrar_user.c
diff --git a/drivers/staging/memrar/memrar-abi b/drivers/staging/memrar/memrar-abi
deleted file mode 100644
index c23fc99..0000000
--- a/drivers/staging/memrar/memrar-abi
+++ /dev/null
@@ -1,89 +0,0 @@
-What:		/dev/memrar
-Date:		March 2010
-KernelVersion:	2.6.34
-Contact:	Eugene Epshteyn <eugene.epshteyn@xxxxxxxxx>
-Description:	The Intel Moorestown Restricted Access Region (RAR)
-		Handler driver exposes an ioctl() based interface that
-		allows a user to reserve and release blocks of RAR
-		memory.
-
-		Note:  A sysfs based one was not appropriate for the
-		RAR handler's usage model.
-
-		=========================================================
-				ioctl() Requests
-		=========================================================
-		RAR_HANDLER_RESERVE
-		-------------------
-		Description:	Reserve RAR block.
-		Type:		struct RAR_block_info
-		Direction:	in/out
-		Errors:		EINVAL (invalid RAR type or size)
-				ENOMEM (not enough RAR memory)
-
-		RAR_HANDLER_STAT
-		----------------
-		Description:	Get RAR statistics.
-		Type:		struct RAR_stat
-		Direction:	in/out
-		Errors:		EINVAL (invalid RAR type)
-
-		RAR_HANDLER_RELEASE
-		-------------------
-		Description:	Release previously reserved RAR block.
-		Type:		32 bit unsigned integer
-				(e.g. uint32_t), i.e the RAR "handle".
-		Direction:	in
-		Errors:		EINVAL (invalid RAR handle)
-
-
-		=========================================================
-			ioctl() Request Parameter Types
-		=========================================================
-		The structures referred to above are defined as
-		follows:
-
-		/**
-		 * struct RAR_block_info - user space struct that
-		 *			   describes RAR buffer
-		 * @type:	Type of RAR memory (e.g.,
-		 *		RAR_TYPE_VIDEO or RAR_TYPE_AUDIO) [in]
-		 * @size:	Requested size of a block in bytes to
-		 *		be reserved in RAR. [in]
-		 * @handle:	Handle that can be used to refer to
-		 *		reserved block. [out]
-		 *
-		 * This is the basic structure exposed to the user
-		 * space that describes a given RAR buffer.  It used
-		 * as the parameter for the RAR_HANDLER_RESERVE ioctl.
-		 * The buffer's underlying bus address is not exposed
-		 * to the user.  User space code refers to the buffer
-		 * entirely by "handle".
-		 */
-		struct RAR_block_info {
-			__u32 type;
-			__u32 size;
-			__u32 handle;
-		};
-
-		/**
-		 * struct RAR_stat - RAR statistics structure
-		 * @type:		Type of RAR memory (e.g.,
-		 *			RAR_TYPE_VIDEO or
-		 *			RAR_TYPE_AUDIO) [in]
-		 * @capacity:		Total size of RAR memory
-		 *			region. [out]
-		 * @largest_block_size:	Size of the largest reservable
-		 *			block. [out]
-		 *
-		 * This structure is used for RAR_HANDLER_STAT ioctl.
-		 */
-		struct RAR_stat {
-			__u32 type;
-			__u32 capacity;
-			__u32 largest_block_size;
-		};
-
-		Lastly, the RAR_HANDLER_RELEASE ioctl expects a
-		"handle" to the RAR block of memory.  It is a 32 bit
-		unsigned integer.
diff --git a/drivers/staging/memrar/memrar.h b/drivers/staging/memrar/memrar.h
deleted file mode 100644
index 0feb73b..0000000
--- a/drivers/staging/memrar/memrar.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- *      RAR Handler (/dev/memrar) internal driver API.
- *      Copyright (C) 2010 Intel Corporation. All rights reserved.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of version 2 of the GNU General
- *      Public License as published by the Free Software Foundation.
- *
- *      This program is distributed in the hope that it will be
- *      useful, but WITHOUT ANY WARRANTY; without even the implied
- *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *      PURPOSE.  See the GNU General Public License for more details.
- *      You should have received a copy of the GNU General Public
- *      License along with this program; if not, write to the Free
- *      Software Foundation, Inc., 59 Temple Place - Suite 330,
- *      Boston, MA  02111-1307, USA.
- *      The full GNU General Public License is included in this
- *      distribution in the file called COPYING.
- */
-
-
-#ifndef _MEMRAR_H
-#define _MEMRAR_H
-
-#include <linux/ioctl.h>
-#include <linux/types.h>
-
-
-/**
- * struct RAR_stat - RAR statistics structure
- * @type:		Type of RAR memory (e.g., audio vs. video)
- * @capacity:		Total size of RAR memory region.
- * @largest_block_size:	Size of the largest reservable block.
- *
- * This structure is used for RAR_HANDLER_STAT ioctl and for the
- * RAR_get_stat() user space wrapper function.
- */
-struct RAR_stat {
-	__u32 type;
-	__u32 capacity;
-	__u32 largest_block_size;
-};
-
-
-/**
- * struct RAR_block_info - user space struct that describes RAR buffer
- * @type:	Type of RAR memory (e.g., audio vs. video)
- * @size:	Requested size of a block to be reserved in RAR.
- * @handle:	Handle that can be used to refer to reserved block.
- *
- * This is the basic structure exposed to the user space that
- * describes a given RAR buffer.  The buffer's underlying bus address
- * is not exposed to the user.  User space code refers to the buffer
- * entirely by "handle".
- */
-struct RAR_block_info {
-	__u32 type;
-	__u32 size;
-	__u32 handle;
-};
-
-
-#define RAR_IOCTL_BASE 0xE0
-
-/* Reserve RAR block. */
-#define RAR_HANDLER_RESERVE _IOWR(RAR_IOCTL_BASE, 0x00, struct RAR_block_info)
-
-/* Release previously reserved RAR block. */
-#define RAR_HANDLER_RELEASE _IOW(RAR_IOCTL_BASE, 0x01, __u32)
-
-/* Get RAR stats. */
-#define RAR_HANDLER_STAT    _IOWR(RAR_IOCTL_BASE, 0x02, struct RAR_stat)
-
-
-#ifdef __KERNEL__
-
-/* -------------------------------------------------------------- */
-/*               Kernel Side RAR Handler Interface                */
-/* -------------------------------------------------------------- */
-
-/**
- * struct RAR_buffer - kernel space struct that describes RAR buffer
- * @info:		structure containing base RAR buffer information
- * @bus_address:	buffer bus address
- *
- * Structure that contains all information related to a given block of
- * memory in RAR.  It is generally only used when retrieving RAR
- * related bus addresses.
- *
- * Note: This structure is used only by RAR-enabled drivers, and is
- *       not intended to be exposed to the user space.
- */
-struct RAR_buffer {
-	struct RAR_block_info info;
-	dma_addr_t bus_address;
-};
-
-#if defined(CONFIG_MRST_RAR_HANDLER)
-/**
- * rar_reserve() - reserve RAR buffers
- * @buffers:	array of RAR_buffers where type and size of buffers to
- *		reserve are passed in, handle and bus address are
- *		passed out
- * @count:	number of RAR_buffers in the "buffers" array
- *
- * This function will reserve buffers in the restricted access regions
- * of given types.
- *
- * It returns the number of successfully reserved buffers.  Successful
- * buffer reservations will have the corresponding bus_address field
- * set to a non-zero value in the given buffers vector.
- */
-extern size_t rar_reserve(struct RAR_buffer *buffers,
-			  size_t count);
-
-/**
- * rar_release() - release RAR buffers
- * @buffers:	array of RAR_buffers where handles to buffers to be
- *		released are passed in
- * @count:	number of RAR_buffers in the "buffers" array
- *
- * This function will release RAR buffers that were retrieved through
- * a call to rar_reserve() or rar_handle_to_bus() by decrementing the
- * reference count.  The RAR buffer will be reclaimed when the
- * reference count drops to zero.
- *
- * It returns the number of successfully released buffers.  Successful
- * releases will have their handle field set to zero in the given
- * buffers vector.
- */
-extern size_t rar_release(struct RAR_buffer *buffers,
-			  size_t count);
-
-/**
- * rar_handle_to_bus() - convert a vector of RAR handles to bus addresses
- * @buffers:	array of RAR_buffers containing handles to be
- *		converted to bus_addresses
- * @count:	number of RAR_buffers in the "buffers" array
-
- * This function will retrieve the RAR buffer bus addresses, type and
- * size corresponding to the RAR handles provided in the buffers
- * vector.
- *
- * It returns the number of successfully converted buffers.  The bus
- * address will be set to 0 for unrecognized handles.
- *
- * The reference count for each corresponding buffer in RAR will be
- * incremented.  Call rar_release() when done with the buffers.
- */
-extern size_t rar_handle_to_bus(struct RAR_buffer *buffers,
-				size_t count);
-
-#else
-
-extern inline size_t rar_reserve(struct RAR_buffer *buffers, size_t count)
-{
-	return 0;
-}
-
-extern inline size_t rar_release(struct RAR_buffer *buffers, size_t count)
-{
-	return 0;
-}
-
-extern inline size_t rar_handle_to_bus(struct RAR_buffer *buffers,
-				size_t count)
-{
-	return 0;
-}
-
-#endif  /* MRST_RAR_HANDLER */
-#endif  /* __KERNEL__ */
-
-#endif  /* _MEMRAR_H */
diff --git a/drivers/staging/memrar/memrar_allocator.c b/drivers/staging/memrar/memrar_allocator.c
deleted file mode 100644
index a4f8c58..0000000
--- a/drivers/staging/memrar/memrar_allocator.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- *      memrar_allocator 1.0:  An allocator for Intel RAR.
- *
- *      Copyright (C) 2010 Intel Corporation. All rights reserved.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of version 2 of the GNU General
- *      Public License as published by the Free Software Foundation.
- *
- *      This program is distributed in the hope that it will be
- *      useful, but WITHOUT ANY WARRANTY; without even the implied
- *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *      PURPOSE.  See the GNU General Public License for more details.
- *      You should have received a copy of the GNU General Public
- *      License along with this program; if not, write to the Free
- *      Software Foundation, Inc., 59 Temple Place - Suite 330,
- *      Boston, MA  02111-1307, USA.
- *      The full GNU General Public License is included in this
- *      distribution in the file called COPYING.
- *
- *
- *  ------------------------------------------------------------------
- *
- *      This simple allocator implementation provides a
- *      malloc()/free()-like interface for reserving space within a
- *      previously reserved block of memory.  It is not specific to
- *      any hardware, nor is it coupled with the lower level paging
- *      mechanism.
- *
- *      The primary goal of this implementation is to provide a means
- *      to partition an arbitrary block of memory without actually
- *      accessing the memory or incurring any hardware side-effects
- *      (e.g. paging).  It is, in effect, a bookkeeping mechanism for
- *      buffers.
- */
-
-
-#include "memrar_allocator.h"
-#include <linux/slab.h>
-#include <linux/bug.h>
-#include <linux/kernel.h>
-
-
-struct memrar_allocator *memrar_create_allocator(unsigned long base,
-						 size_t capacity,
-						 size_t block_size)
-{
-	struct memrar_allocator *allocator  = NULL;
-	struct memrar_address_ranges *first_node = NULL;
-
-	/*
-	 * Make sure the base address is aligned on a block_size
-	 * boundary.
-	 *
-	 * @todo Is this necessary?
-	 */
-	/* base = ALIGN(base, block_size); */
-
-	/* Validate parameters.
-	 *
-	 * Make sure we can allocate the entire memory space.  Zero
-	 * capacity or block size are obviously invalid.
-	 */
-	if (base == 0
-	    || capacity == 0
-	    || block_size == 0
-	    || ULONG_MAX - capacity < base
-	    || capacity < block_size)
-		return allocator;
-
-	/*
-	 * There isn't much point in creating a memory allocator that
-	 * is only capable of holding one block but we'll allow it,
-	 * and issue a diagnostic.
-	 */
-	WARN(capacity < block_size * 2,
-	     "memrar: Only one block available to allocator.\n");
-
-	allocator = kmalloc(sizeof(*allocator), GFP_KERNEL);
-
-	if (allocator == NULL)
-		return allocator;
-
-	mutex_init(&allocator->lock);
-	allocator->base = base;
-
-	/* Round the capacity down to a multiple of block_size. */
-	allocator->capacity = (capacity / block_size) * block_size;
-
-	allocator->block_size = block_size;
-
-	allocator->largest_free_area = allocator->capacity;
-
-	/* Initialize the handle and free lists. */
-	INIT_LIST_HEAD(&allocator->allocated_list.list);
-	INIT_LIST_HEAD(&allocator->free_list.list);
-
-	first_node = kmalloc(sizeof(*first_node), GFP_KERNEL);
-	if (first_node == NULL)	{
-		kfree(allocator);
-		allocator = NULL;
-	} else {
-		/* Full range of blocks is available. */
-		first_node->range.begin = base;
-		first_node->range.end   = base + allocator->capacity;
-		list_add(&first_node->list,
-			 &allocator->free_list.list);
-	}
-
-	return allocator;
-}
-
-void memrar_destroy_allocator(struct memrar_allocator *allocator)
-{
-	/*
-	 * Assume that the memory allocator lock isn't held at this
-	 * point in time.  Caller must ensure that.
-	 */
-
-	struct memrar_address_ranges *pos = NULL;
-	struct memrar_address_ranges *n   = NULL;
-
-	if (allocator == NULL)
-		return;
-
-	mutex_lock(&allocator->lock);
-
-	/* Reclaim free list resources. */
-	list_for_each_entry_safe(pos,
-				 n,
-				 &allocator->free_list.list,
-				 list) {
-		list_del(&pos->list);
-		kfree(pos);
-	}
-
-	mutex_unlock(&allocator->lock);
-
-	kfree(allocator);
-}
-
-unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator,
-				     size_t size)
-{
-	struct memrar_address_ranges *pos = NULL;
-
-	size_t num_blocks;
-	unsigned long reserved_bytes;
-
-	/*
-	 * Address of allocated buffer.  We assume that zero is not a
-	 * valid address.
-	 */
-	unsigned long addr = 0;
-
-	if (allocator == NULL || size == 0)
-		return addr;
-
-	/* Reserve enough blocks to hold the amount of bytes requested. */
-	num_blocks = DIV_ROUND_UP(size, allocator->block_size);
-
-	reserved_bytes = num_blocks * allocator->block_size;
-
-	mutex_lock(&allocator->lock);
-
-	if (reserved_bytes > allocator->largest_free_area) {
-		mutex_unlock(&allocator->lock);
-		return addr;
-	}
-
-	/*
-	 * Iterate through the free list to find a suitably sized
-	 * range of free contiguous memory blocks.
-	 *
-	 * We also take the opportunity to reset the size of the
-	 * largest free area size statistic.
-	 */
-	list_for_each_entry(pos, &allocator->free_list.list, list) {
-		struct memrar_address_range * const fr = &pos->range;
-		size_t const curr_size = fr->end - fr->begin;
-
-		if (curr_size >= reserved_bytes && addr == 0) {
-			struct memrar_address_range *range = NULL;
-			struct memrar_address_ranges * const new_node =
-				kmalloc(sizeof(*new_node), GFP_KERNEL);
-
-			if (new_node == NULL)
-				break;
-
-			list_add(&new_node->list,
-				 &allocator->allocated_list.list);
-
-			/*
-			 * Carve out area of memory from end of free
-			 * range.
-			 */
-			range        = &new_node->range;
-			range->end   = fr->end;
-			fr->end     -= reserved_bytes;
-			range->begin = fr->end;
-			addr         = range->begin;
-
-			/*
-			 * Check if largest area has decreased in
-			 * size.  We'll need to continue scanning for
-			 * the next largest area if it has.
-			 */
-			if (curr_size == allocator->largest_free_area)
-				allocator->largest_free_area -=
-					reserved_bytes;
-			else
-				break;
-		}
-
-		/*
-		 * Reset largest free area size statistic as needed,
-		 * but only if we've actually allocated memory.
-		 */
-		if (addr != 0
-		    && curr_size > allocator->largest_free_area) {
-			allocator->largest_free_area = curr_size;
-			break;
-		}
-	}
-
-	mutex_unlock(&allocator->lock);
-
-	return addr;
-}
-
-long memrar_allocator_free(struct memrar_allocator *allocator,
-			   unsigned long addr)
-{
-	struct list_head *pos = NULL;
-	struct list_head *tmp = NULL;
-	struct list_head *dst = NULL;
-
-	struct memrar_address_ranges      *allocated = NULL;
-	struct memrar_address_range const *handle    = NULL;
-
-	unsigned long old_end        = 0;
-	unsigned long new_chunk_size = 0;
-
-	if (allocator == NULL)
-		return -EINVAL;
-
-	if (addr == 0)
-		return 0;  /* Ignore "free(0)". */
-
-	mutex_lock(&allocator->lock);
-
-	/* Find the corresponding handle. */
-	list_for_each_entry(allocated,
-			    &allocator->allocated_list.list,
-			    list) {
-		if (allocated->range.begin == addr) {
-			handle = &allocated->range;
-			break;
-		}
-	}
-
-	/* No such buffer created by this allocator. */
-	if (handle == NULL) {
-		mutex_unlock(&allocator->lock);
-		return -EFAULT;
-	}
-
-	/*
-	 * Coalesce adjacent chunks of memory if possible.
-	 *
-	 * @note This isn't full blown coalescing since we're only
-	 *       coalescing at most three chunks of memory.
-	 */
-	list_for_each_safe(pos, tmp, &allocator->free_list.list) {
-		/* @todo O(n) performance.  Optimize. */
-
-		struct memrar_address_range * const chunk =
-			&list_entry(pos,
-				    struct memrar_address_ranges,
-				    list)->range;
-
-		/* Extend size of existing free adjacent chunk. */
-		if (chunk->end == handle->begin) {
-			/*
-			 * Chunk "less than" than the one we're
-			 * freeing is adjacent.
-			 *
-			 * Before:
-			 *
-			 *   +-----+------+
-			 *   |chunk|handle|
-			 *   +-----+------+
-			 *
-			 * After:
-			 *
-			 *   +------------+
-			 *   |   chunk    |
-			 *   +------------+
-			 */
-
-			struct memrar_address_ranges const * const next =
-				list_entry(pos->next,
-					   struct memrar_address_ranges,
-					   list);
-
-			chunk->end = handle->end;
-
-			/*
-			 * Now check if next free chunk is adjacent to
-			 * the current extended free chunk.
-			 *
-			 * Before:
-			 *
-			 *   +------------+----+
-			 *   |   chunk    |next|
-			 *   +------------+----+
-			 *
-			 * After:
-			 *
-			 *   +-----------------+
-			 *   |      chunk      |
-			 *   +-----------------+
-			 */
-			if (!list_is_singular(pos)
-			    && chunk->end == next->range.begin) {
-				chunk->end = next->range.end;
-				list_del(pos->next);
-				kfree(next);
-			}
-
-			list_del(&allocated->list);
-
-			new_chunk_size = chunk->end - chunk->begin;
-
-			goto exit_memrar_free;
-
-		} else if (handle->end == chunk->begin) {
-			/*
-			 * Chunk "greater than" than the one we're
-			 * freeing is adjacent.
-			 *
-			 *   +------+-----+
-			 *   |handle|chunk|
-			 *   +------+-----+
-			 *
-			 * After:
-			 *
-			 *   +------------+
-			 *   |   chunk    |
-			 *   +------------+
-			 */
-
-			struct memrar_address_ranges const * const prev =
-				list_entry(pos->prev,
-					   struct memrar_address_ranges,
-					   list);
-
-			chunk->begin = handle->begin;
-
-			/*
-			 * Now check if previous free chunk is
-			 * adjacent to the current extended free
-			 * chunk.
-			 *
-			 *
-			 * Before:
-			 *
-			 *   +----+------------+
-			 *   |prev|   chunk    |
-			 *   +----+------------+
-			 *
-			 * After:
-			 *
-			 *   +-----------------+
-			 *   |      chunk      |
-			 *   +-----------------+
-			 */
-			if (!list_is_singular(pos)
-			    && prev->range.end == chunk->begin) {
-				chunk->begin = prev->range.begin;
-				list_del(pos->prev);
-				kfree(prev);
-			}
-
-			list_del(&allocated->list);
-
-			new_chunk_size = chunk->end - chunk->begin;
-
-			goto exit_memrar_free;
-
-		} else if (chunk->end < handle->begin
-			   && chunk->end > old_end) {
-			/* Keep track of where the entry could be
-			 * potentially moved from the "allocated" list
-			 * to the "free" list if coalescing doesn't
-			 * occur, making sure the "free" list remains
-			 * sorted.
-			 */
-			old_end = chunk->end;
-			dst = pos;
-		}
-	}
-
-	/*
-	 * Nothing to coalesce.
-	 *
-	 * Move the entry from the "allocated" list to the "free"
-	 * list.
-	 */
-	list_move(&allocated->list, dst);
-	new_chunk_size = handle->end - handle->begin;
-	allocated = NULL;
-
-exit_memrar_free:
-
-	if (new_chunk_size > allocator->largest_free_area)
-		allocator->largest_free_area = new_chunk_size;
-
-	mutex_unlock(&allocator->lock);
-
-	kfree(allocated);
-
-	return 0;
-}
-
-
-
-/*
-  Local Variables:
-    c-file-style: "linux"
-  End:
-*/
diff --git a/drivers/staging/memrar/memrar_allocator.h b/drivers/staging/memrar/memrar_allocator.h
deleted file mode 100644
index 0b80dea..0000000
--- a/drivers/staging/memrar/memrar_allocator.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- *      Copyright (C) 2010 Intel Corporation. All rights reserved.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of version 2 of the GNU General
- *      Public License as published by the Free Software Foundation.
- *
- *      This program is distributed in the hope that it will be
- *      useful, but WITHOUT ANY WARRANTY; without even the implied
- *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *      PURPOSE.  See the GNU General Public License for more details.
- *      You should have received a copy of the GNU General Public
- *      License along with this program; if not, write to the Free
- *      Software Foundation, Inc., 59 Temple Place - Suite 330,
- *      Boston, MA  02111-1307, USA.
- *      The full GNU General Public License is included in this
- *      distribution in the file called COPYING.
- */
-
-#ifndef MEMRAR_ALLOCATOR_H
-#define MEMRAR_ALLOCATOR_H
-
-
-#include <linux/mutex.h>
-#include <linux/list.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-
-
-/**
- * struct memrar_address_range - struct that describes a memory range
- * @begin:	Beginning of available address range.
- * @end:	End of available address range, one past the end,
- *		i.e. [begin, end).
- */
-struct memrar_address_range {
-/* private: internal use only */
-	unsigned long begin;
-	unsigned long end;
-};
-
-/**
- * struct memrar_address_ranges - list of areas of memory.
- * @list:	Linked list of address ranges.
- * @range:	Memory address range corresponding to given list node.
- */
-struct memrar_address_ranges {
-/* private: internal use only */
-	struct list_head list;
-	struct memrar_address_range range;
-};
-
-/**
- * struct memrar_allocator - encapsulation of the memory allocator state
- * @lock:		Lock used to synchronize access to the memory
- *			allocator state.
- * @base:		Base (start) address of the allocator memory
- *			space.
- * @capacity:		Size of the allocator memory space in bytes.
- * @block_size:		The size in bytes of individual blocks within
- *			the allocator memory space.
- * @largest_free_area:	Largest free area of memory in the allocator
- *			in bytes.
- * @allocated_list:	List of allocated memory block address
- *			ranges.
- * @free_list:		List of free address ranges.
- *
- * This structure contains all memory allocator state, including the
- * base address, capacity, free list, lock, etc.
- */
-struct memrar_allocator {
-/* private: internal use only */
-	struct mutex lock;
-	unsigned long base;
-	size_t capacity;
-	size_t block_size;
-	size_t largest_free_area;
-	struct memrar_address_ranges allocated_list;
-	struct memrar_address_ranges free_list;
-};
-
-/**
- * memrar_create_allocator() - create a memory allocator
- * @base:	Address at which the memory allocator begins.
- * @capacity:	Desired size of the memory allocator.  This value must
- *		be larger than the block_size, ideally more than twice
- *		as large since there wouldn't be much point in using a
- *		memory allocator otherwise.
- * @block_size:	The size of individual blocks within the memory
- *		allocator.  This value must smaller than the
- *		capacity.
- *
- * Create a memory allocator with the given capacity and block size.
- * The capacity will be reduced to be a multiple of the block size, if
- * necessary.
- *
- * Returns an instance of the memory allocator, if creation succeeds,
- * otherwise zero if creation fails.  Failure may occur if not enough
- * kernel memory exists to create the memrar_allocator instance
- * itself, or if the capacity and block_size arguments are not
- * compatible or make sense.
- */
-struct memrar_allocator *memrar_create_allocator(unsigned long base,
-						 size_t capacity,
-						 size_t block_size);
-
-/**
- * memrar_destroy_allocator() - destroy allocator
- * @allocator:	The allocator being destroyed.
- *
- * Reclaim resources held by the memory allocator.  The caller must
- * explicitly free all memory reserved by memrar_allocator_alloc()
- * prior to calling this function.  Otherwise leaks will occur.
- */
-void memrar_destroy_allocator(struct memrar_allocator *allocator);
-
-/**
- * memrar_allocator_alloc() - reserve an area of memory of given size
- * @allocator:	The allocator instance being used to reserve buffer.
- * @size:	The size in bytes of the buffer to allocate.
- *
- * This functions reserves an area of memory managed by the given
- * allocator.  It returns zero if allocation was not possible.
- * Failure may occur if the allocator no longer has space available.
- */
-unsigned long memrar_allocator_alloc(struct memrar_allocator *allocator,
-				     size_t size);
-
-/**
- * memrar_allocator_free() - release buffer starting at given address
- * @allocator:	The allocator instance being used to release the buffer.
- * @address:	The address of the buffer being released.
- *
- * Release an area of memory starting at the given address.  Failure
- * could occur if the given address is not in the address space
- * managed by the allocator.  Returns zero on success or an errno
- * (negative value) on failure.
- */
-long memrar_allocator_free(struct memrar_allocator *allocator,
-			   unsigned long address);
-
-#endif  /* MEMRAR_ALLOCATOR_H */
-
-
-/*
-  Local Variables:
-    c-file-style: "linux"
-  End:
-*/
diff --git a/drivers/staging/memrar/memrar_handler.c b/drivers/staging/memrar/memrar_handler.c
deleted file mode 100644
index cfcaa8e..0000000
--- a/drivers/staging/memrar/memrar_handler.c
+++ /dev/null
@@ -1,1007 +0,0 @@
-/*
- *      memrar_handler 1.0:  An Intel restricted access region handler device
- *
- *      Copyright (C) 2010 Intel Corporation. All rights reserved.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of version 2 of the GNU General
- *      Public License as published by the Free Software Foundation.
- *
- *      This program is distributed in the hope that it will be
- *      useful, but WITHOUT ANY WARRANTY; without even the implied
- *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *      PURPOSE.  See the GNU General Public License for more details.
- *      You should have received a copy of the GNU General Public
- *      License along with this program; if not, write to the Free
- *      Software Foundation, Inc., 59 Temple Place - Suite 330,
- *      Boston, MA  02111-1307, USA.
- *      The full GNU General Public License is included in this
- *      distribution in the file called COPYING.
- *
- * -------------------------------------------------------------------
- *
- *      Moorestown restricted access regions (RAR) provide isolated
- *      areas of main memory that are only acceessible by authorized
- *      devices.
- *
- *      The Intel Moorestown RAR handler module exposes a kernel space
- *      RAR memory management mechanism.  It is essentially a
- *      RAR-specific allocator.
- *
- *      Besides providing RAR buffer management, the RAR handler also
- *      behaves in many ways like an OS virtual memory manager.  For
- *      example, the RAR "handles" created by the RAR handler are
- *      analogous to user space virtual addresses.
- *
- *      RAR memory itself is never accessed directly by the RAR
- *      handler.
- */
-
-#include <linux/miscdevice.h>
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/kref.h>
-#include <linux/mutex.h>
-#include <linux/kernel.h>
-#include <linux/uaccess.h>
-#include <linux/mm.h>
-#include <linux/ioport.h>
-#include <linux/io.h>
-#include <linux/rar_register.h>
-
-#include "memrar.h"
-#include "memrar_allocator.h"
-
-
-#define MEMRAR_VER "1.0"
-
-/*
- * Moorestown supports three restricted access regions.
- *
- * We only care about the first two, video and audio.  The third,
- * reserved for Chaabi and the P-unit, will be handled by their
- * respective drivers.
- */
-#define MRST_NUM_RAR 2
-
-/* ---------------- -------------------- ------------------- */
-
-/**
- * struct memrar_buffer_info - struct that keeps track of all RAR buffers
- * @list:	Linked list of memrar_buffer_info objects.
- * @buffer:	Core RAR buffer information.
- * @refcount:	Reference count.
- * @owner:	File handle corresponding to process that reserved the
- *		block of memory in RAR.  This will be zero for buffers
- *		allocated by other drivers instead of by a user space
- *		process.
- *
- * This structure encapsulates a link list of RAR buffers, as well as
- * other characteristics specific to a given list node, such as the
- * reference count on the corresponding RAR buffer.
- */
-struct memrar_buffer_info {
-	struct list_head list;
-	struct RAR_buffer buffer;
-	struct kref refcount;
-	struct file *owner;
-};
-
-/**
- * struct memrar_rar_info - characteristics of a given RAR
- * @base:	Base bus address of the RAR.
- * @length:	Length of the RAR.
- * @iobase:	Virtual address of RAR mapped into kernel.
- * @allocator:	Allocator associated with the RAR.  Note the allocator
- *		"capacity" may be smaller than the RAR length if the
- *		length is not a multiple of the configured allocator
- *		block size.
- * @buffers:	Table that keeps track of all reserved RAR buffers.
- * @lock:	Lock used to synchronize access to RAR-specific data
- *		structures.
- *
- * Each RAR has an associated memrar_rar_info structure that describes
- * where in memory the RAR is located, how large it is, and a list of
- * reserved RAR buffers inside that RAR.  Each RAR also has a mutex
- * associated with it to reduce lock contention when operations on
- * multiple RARs are performed in parallel.
- */
-struct memrar_rar_info {
-	dma_addr_t base;
-	unsigned long length;
-	void __iomem *iobase;
-	struct memrar_allocator *allocator;
-	struct memrar_buffer_info buffers;
-	struct mutex lock;
-	int allocated;	/* True if we own this RAR */
-};
-
-/*
- * Array of RAR characteristics.
- */
-static struct memrar_rar_info memrars[MRST_NUM_RAR];
-
-/* ---------------- -------------------- ------------------- */
-
-/* Validate RAR type. */
-static inline int memrar_is_valid_rar_type(u32 type)
-{
-	return type == RAR_TYPE_VIDEO || type == RAR_TYPE_AUDIO;
-}
-
-/* Check if an address/handle falls with the given RAR memory range. */
-static inline int memrar_handle_in_range(struct memrar_rar_info *rar,
-					 u32 vaddr)
-{
-	unsigned long const iobase = (unsigned long) (rar->iobase);
-	return (vaddr >= iobase && vaddr < iobase + rar->length);
-}
-
-/* Retrieve RAR information associated with the given handle. */
-static struct memrar_rar_info *memrar_get_rar_info(u32 vaddr)
-{
-	int i;
-	for (i = 0; i < MRST_NUM_RAR; ++i) {
-		struct memrar_rar_info * const rar = &memrars[i];
-		if (memrar_handle_in_range(rar, vaddr))
-			return rar;
-	}
-
-	return NULL;
-}
-
-/**
- *	memrar_get_bus address		-	handle to bus address
- *
- *	Retrieve bus address from given handle.
- *
- *	Returns address corresponding to given handle.  Zero if handle is
- *	invalid.
- */
-static dma_addr_t memrar_get_bus_address(
-	struct memrar_rar_info *rar,
-	u32 vaddr)
-{
-	unsigned long const iobase = (unsigned long) (rar->iobase);
-
-	if (!memrar_handle_in_range(rar, vaddr))
-		return 0;
-
-	/*
-	 * An assumption is made that the virtual address offset is
-	 * the same as the bus address offset, at least based on the
-	 * way this driver is implemented.  For example, vaddr + 2 ==
-	 * baddr + 2.
-	 *
-	 * @todo Is that a valid assumption?
-	 */
-	return rar->base + (vaddr - iobase);
-}
-
-/**
- *	memrar_get_physical_address	-	handle to physical address
- *
- *	Retrieve physical address from given handle.
- *
- *	Returns address corresponding to given handle.  Zero if handle is
- *	invalid.
- */
-static dma_addr_t memrar_get_physical_address(
-	struct memrar_rar_info *rar,
-	u32 vaddr)
-{
-	/*
-	 * @todo This assumes that the bus address and physical
-	 *       address are the same.  That is true for Moorestown
-	 *       but not necessarily on other platforms.  This
-	 *       deficiency should be addressed at some point.
-	 */
-	return memrar_get_bus_address(rar, vaddr);
-}
-
-/**
- *	memrar_release_block	-	release a block to the pool
- *	@kref: kref of block
- *
- *	Core block release code. A node has hit zero references so can
- *	be released and the lists must be updated.
- *
- *	Note: This code removes the node from a list.  Make sure any list
- *	iteration is performed using list_for_each_safe().
- */
-static void memrar_release_block_i(struct kref *ref)
-{
-	/*
-	 * Last reference is being released.  Remove from the table,
-	 * and reclaim resources.
-	 */
-
-	struct memrar_buffer_info * const node =
-		container_of(ref, struct memrar_buffer_info, refcount);
-
-	struct RAR_block_info * const user_info =
-		&node->buffer.info;
-
-	struct memrar_allocator * const allocator =
-		memrars[user_info->type].allocator;
-
-	list_del(&node->list);
-
-	memrar_allocator_free(allocator, user_info->handle);
-
-	kfree(node);
-}
-
-/**
- *	memrar_init_rar_resources	-	configure a RAR
- *	@rarnum: rar that has been allocated
- *	@devname: name of our device
- *
- *	Initialize RAR parameters, such as bus addresses, etc and make
- *	the resource accessible.
- */
-static int memrar_init_rar_resources(int rarnum, char const *devname)
-{
-	/* ---- Sanity Checks ----
-	 * 1. RAR bus addresses in both Lincroft and Langwell RAR
-	 *    registers should be the same.
-	 *    a. There's no way we can do this through IA.
-	 *
-	 * 2. Secure device ID in Langwell RAR registers should be set
-	 *    appropriately, e.g. only LPE DMA for the audio RAR, and
-	 *    security for the other Langwell based RAR registers.
-	 *    a. There's no way we can do this through IA.
-	 *
-	 * 3. Audio and video RAR registers and RAR access should be
-	 *    locked down.  If not, enable RAR access control.  Except
-	 *    for debugging purposes, there is no reason for them to
-	 *    be unlocked.
-	 *    a.  We can only do this for the Lincroft (IA) side.
-	 *
-	 * @todo Should the RAR handler driver even be aware of audio
-	 *       and video RAR settings?
-	 */
-
-	/*
-	 * RAR buffer block size.
-	 *
-	 * We choose it to be the size of a page to simplify the
-	 * /dev/memrar mmap() implementation and usage.  Otherwise
-	 * paging is not involved once an RAR is locked down.
-	 */
-	static size_t const RAR_BLOCK_SIZE = PAGE_SIZE;
-
-	dma_addr_t low, high;
-	struct memrar_rar_info * const rar = &memrars[rarnum];
-
-	BUG_ON(MRST_NUM_RAR != ARRAY_SIZE(memrars));
-	BUG_ON(!memrar_is_valid_rar_type(rarnum));
-	BUG_ON(rar->allocated);
-
-	if (rar_get_address(rarnum, &low, &high) != 0)
-		/* No RAR is available. */
-		return -ENODEV;
-
-	if (low == 0 || high == 0) {
-		rar->base      = 0;
-		rar->length    = 0;
-		rar->iobase    = NULL;
-		rar->allocator = NULL;
-		return -ENOSPC;
-	}
-
-	/*
-	 * @todo Verify that LNC and LNW RAR register contents
-	 *       addresses, security, etc are compatible and
-	 *       consistent).
-	 */
-
-	rar->length = high - low + 1;
-
-	/* Claim RAR memory as our own. */
-	if (request_mem_region(low, rar->length, devname) == NULL) {
-		rar->length = 0;
-		pr_err("%s: Unable to claim RAR[%d] memory.\n",
-		       devname, rarnum);
-		pr_err("%s: RAR[%d] disabled.\n", devname, rarnum);
-		return -EBUSY;
-	}
-
-	rar->base = low;
-
-	/*
-	 * Now map it into the kernel address space.
-	 *
-	 * Note that the RAR memory may only be accessed by IA
-	 * when debugging.  Otherwise attempts to access the
-	 * RAR memory when it is locked down will result in
-	 * behavior similar to writing to /dev/null and
-	 * reading from /dev/zero.  This behavior is enforced
-	 * by the hardware.  Even if we don't access the
-	 * memory, mapping it into the kernel provides us with
-	 * a convenient RAR handle to bus address mapping.
-	 */
-	rar->iobase = ioremap_nocache(rar->base, rar->length);
-	if (rar->iobase == NULL) {
-		pr_err("%s: Unable to map RAR memory.\n", devname);
-		release_mem_region(low, rar->length);
-		return -ENOMEM;
-	}
-
-	/* Initialize corresponding memory allocator. */
-	rar->allocator = memrar_create_allocator((unsigned long) rar->iobase,
-						rar->length, RAR_BLOCK_SIZE);
-	if (rar->allocator == NULL) {
-		iounmap(rar->iobase);
-		release_mem_region(low, rar->length);
-		return -ENOMEM;
-	}
-
-	pr_info("%s: BRAR[%d] bus address range = [0x%lx, 0x%lx]\n",
-		devname, rarnum, (unsigned long) low, (unsigned long) high);
-
-	pr_info("%s: BRAR[%d] size = %zu KiB\n",
-			devname, rarnum, rar->allocator->capacity / 1024);
-
-	rar->allocated = 1;
-	return 0;
-}
-
-/**
- *	memrar_fini_rar_resources	-	free up RAR resources
- *
- *	Finalize RAR resources. Free up the resource tables, hand the memory
- *	back to the kernel, unmap the device and release the address space.
- */
-static void memrar_fini_rar_resources(void)
-{
-	int z;
-	struct memrar_buffer_info *pos;
-	struct memrar_buffer_info *tmp;
-
-	/*
-	 * @todo Do we need to hold a lock at this point in time?
-	 *       (module initialization failure or exit?)
-	 */
-
-	for (z = MRST_NUM_RAR; z-- != 0; ) {
-		struct memrar_rar_info * const rar = &memrars[z];
-
-		if (!rar->allocated)
-			continue;
-
-		/* Clean up remaining resources. */
-
-		list_for_each_entry_safe(pos,
-					 tmp,
-					 &rar->buffers.list,
-					 list) {
-			kref_put(&pos->refcount, memrar_release_block_i);
-		}
-
-		memrar_destroy_allocator(rar->allocator);
-		rar->allocator = NULL;
-
-		iounmap(rar->iobase);
-		release_mem_region(rar->base, rar->length);
-
-		rar->iobase = NULL;
-		rar->base = 0;
-		rar->length = 0;
-
-		unregister_rar(z);
-	}
-}
-
-/**
- *	memrar_reserve_block	-	handle an allocation request
- *	@request: block being requested
- *	@filp: owner it is tied to
- *
- *	Allocate a block of the requested RAR. If successful return the
- *	request object filled in and zero, if not report an error code
- */
-
-static long memrar_reserve_block(struct RAR_buffer *request,
-				 struct file *filp)
-{
-	struct RAR_block_info * const rinfo = &request->info;
-	struct RAR_buffer *buffer;
-	struct memrar_buffer_info *buffer_info;
-	u32 handle;
-	struct memrar_rar_info *rar = NULL;
-
-	/* Prevent array overflow. */
-	if (!memrar_is_valid_rar_type(rinfo->type))
-		return -EINVAL;
-
-	rar = &memrars[rinfo->type];
-	if (!rar->allocated)
-		return -ENODEV;
-
-	/* Reserve memory in RAR. */
-	handle = memrar_allocator_alloc(rar->allocator, rinfo->size);
-	if (handle == 0)
-		return -ENOMEM;
-
-	buffer_info = kmalloc(sizeof(*buffer_info), GFP_KERNEL);
-
-	if (buffer_info == NULL) {
-		memrar_allocator_free(rar->allocator, handle);
-		return -ENOMEM;
-	}
-
-	buffer = &buffer_info->buffer;
-	buffer->info.type = rinfo->type;
-	buffer->info.size = rinfo->size;
-
-	/* Memory handle corresponding to the bus address. */
-	buffer->info.handle = handle;
-	buffer->bus_address = memrar_get_bus_address(rar, handle);
-
-	/*
-	 * Keep track of owner so that we can later cleanup if
-	 * necessary.
-	 */
-	buffer_info->owner = filp;
-
-	kref_init(&buffer_info->refcount);
-
-	mutex_lock(&rar->lock);
-	list_add(&buffer_info->list, &rar->buffers.list);
-	mutex_unlock(&rar->lock);
-
-	rinfo->handle = buffer->info.handle;
-	request->bus_address = buffer->bus_address;
-
-	return 0;
-}
-
-/**
- *	memrar_release_block		-	release a RAR block
- *	@addr: address in RAR space
- *
- *	Release a previously allocated block. Releases act on complete
- *	blocks, partially freeing a block is not supported
- */
-
-static long memrar_release_block(u32 addr)
-{
-	struct memrar_buffer_info *pos;
-	struct memrar_buffer_info *tmp;
-	struct memrar_rar_info * const rar = memrar_get_rar_info(addr);
-	long result = -EINVAL;
-
-	if (rar == NULL)
-		return -ENOENT;
-
-	mutex_lock(&rar->lock);
-
-	/*
-	 * Iterate through the buffer list to find the corresponding
-	 * buffer to be released.
-	 */
-	list_for_each_entry_safe(pos,
-				 tmp,
-				 &rar->buffers.list,
-				 list) {
-		struct RAR_block_info * const info =
-			&pos->buffer.info;
-
-		/*
-		 * Take into account handle offsets that may have been
-		 * added to the base handle, such as in the following
-		 * scenario:
-		 *
-		 *     u32 handle = base + offset;
-		 *     rar_handle_to_bus(handle);
-		 *     rar_release(handle);
-		 */
-		if (addr >= info->handle
-		    && addr < (info->handle + info->size)
-		    && memrar_is_valid_rar_type(info->type)) {
-			kref_put(&pos->refcount, memrar_release_block_i);
-			result = 0;
-			break;
-		}
-	}
-
-	mutex_unlock(&rar->lock);
-
-	return result;
-}
-
-/**
- *	memrar_get_stats	-	read statistics for a RAR
- *	@r: statistics to be filled in
- *
- *	Returns the statistics data for the RAR, or an error code if
- *	the request cannot be completed
- */
-static long memrar_get_stat(struct RAR_stat *r)
-{
-	struct memrar_allocator *allocator;
-
-	if (!memrar_is_valid_rar_type(r->type))
-		return -EINVAL;
-
-	if (!memrars[r->type].allocated)
-		return -ENODEV;
-
-	allocator = memrars[r->type].allocator;
-
-	BUG_ON(allocator == NULL);
-
-	/*
-	 * Allocator capacity doesn't change over time.  No
-	 * need to synchronize.
-	 */
-	r->capacity = allocator->capacity;
-
-	mutex_lock(&allocator->lock);
-	r->largest_block_size = allocator->largest_free_area;
-	mutex_unlock(&allocator->lock);
-	return 0;
-}
-
-/**
- *	memrar_ioctl		-	ioctl callback
- *	@filp: file issuing the request
- *	@cmd: command
- *	@arg: pointer to control information
- *
- *	Perform one of the ioctls supported by the memrar device
- */
-
-static long memrar_ioctl(struct file *filp,
-			 unsigned int cmd,
-			 unsigned long arg)
-{
-	void __user *argp = (void __user *)arg;
-	long result = 0;
-
-	struct RAR_buffer buffer;
-	struct RAR_block_info * const request = &buffer.info;
-	struct RAR_stat rar_info;
-	u32 rar_handle;
-
-	switch (cmd) {
-	case RAR_HANDLER_RESERVE:
-		if (copy_from_user(request,
-				   argp,
-				   sizeof(*request)))
-			return -EFAULT;
-
-		result = memrar_reserve_block(&buffer, filp);
-		if (result != 0)
-			return result;
-
-		return copy_to_user(argp, request, sizeof(*request));
-
-	case RAR_HANDLER_RELEASE:
-		if (copy_from_user(&rar_handle,
-				   argp,
-				   sizeof(rar_handle)))
-			return -EFAULT;
-
-		return memrar_release_block(rar_handle);
-
-	case RAR_HANDLER_STAT:
-		if (copy_from_user(&rar_info,
-				   argp,
-				   sizeof(rar_info)))
-			return -EFAULT;
-
-		/*
-		 * Populate the RAR_stat structure based on the RAR
-		 * type given by the user
-		 */
-		if (memrar_get_stat(&rar_info) != 0)
-			return -EINVAL;
-
-		/*
-		 * @todo Do we need to verify destination pointer
-		 *       "argp" is non-zero?  Is that already done by
-		 *       copy_to_user()?
-		 */
-		return copy_to_user(argp,
-				    &rar_info,
-				    sizeof(rar_info)) ? -EFAULT : 0;
-
-	default:
-		return -ENOTTY;
-	}
-
-	return 0;
-}
-
-/**
- *	memrar_mmap		-	mmap helper for deubgging
- *	@filp: handle doing the mapping
- *	@vma: memory area
- *
- *	Support the mmap operation on the RAR space for debugging systems
- *	when the memory is not locked down.
- */
-
-static int memrar_mmap(struct file *filp, struct vm_area_struct *vma)
-{
-	/*
-	 * This mmap() implementation is predominantly useful for
-	 * debugging since the CPU will be prevented from accessing
-	 * RAR memory by the hardware when RAR is properly locked
-	 * down.
-	 *
-	 * In order for this implementation to be useful RAR memory
-	 * must be not be locked down.  However, we only want to do
-	 * that when debugging.  DO NOT leave RAR memory unlocked in a
-	 * deployed device that utilizes RAR.
-	 */
-
-	size_t const size = vma->vm_end - vma->vm_start;
-
-	/* Users pass the RAR handle as the mmap() offset parameter. */
-	unsigned long const handle = vma->vm_pgoff << PAGE_SHIFT;
-
-	struct memrar_rar_info * const rar = memrar_get_rar_info(handle);
-	unsigned long pfn;
-
-	/* Only allow priviledged apps to go poking around this way */
-	if (!capable(CAP_SYS_RAWIO))
-		return -EPERM;
-
-	/* Invalid RAR handle or size passed to mmap(). */
-	if (rar == NULL
-	    || handle == 0
-	    || size > (handle - (unsigned long) rar->iobase))
-		return -EINVAL;
-
-	/*
-	 * Retrieve physical address corresponding to the RAR handle,
-	 * and convert it to a page frame.
-	 */
-	pfn = memrar_get_physical_address(rar, handle) >> PAGE_SHIFT;
-
-
-	pr_debug("memrar: mapping RAR range [0x%lx, 0x%lx) into user space.\n",
-		 handle,
-		 handle + size);
-
-	/*
-	 * Map RAR memory into user space.  This is really only useful
-	 * for debugging purposes since the memory won't be
-	 * accessible, i.e. reads return zero and writes are ignored,
-	 * when RAR access control is enabled.
-	 */
-	if (remap_pfn_range(vma,
-			    vma->vm_start,
-			    pfn,
-			    size,
-			    vma->vm_page_prot))
-		return -EAGAIN;
-
-	/* vma->vm_ops = &memrar_mem_ops; */
-
-	return 0;
-}
-
-/**
- *	memrar_open		-	device open method
- *	@inode: inode to open
- *	@filp: file handle
- *
- *	As we support multiple arbitary opens there is no work to be done
- *	really.
- */
-
-static int memrar_open(struct inode *inode, struct file *filp)
-{
-	nonseekable_open(inode, filp);
-	return 0;
-}
-
-/**
- *	memrar_release		-	close method for miscev
- *	@inode: inode of device
- *	@filp: handle that is going away
- *
- *	Free up all the regions that belong to this file handle. We use
- *	the handle as a natural Linux style 'lifetime' indicator and to
- *	ensure resources are not leaked when their owner explodes in an
- *	unplanned fashion.
- */
-
-static int memrar_release(struct inode *inode, struct file *filp)
-{
-	/* Free all regions associated with the given file handle. */
-
-	struct memrar_buffer_info *pos;
-	struct memrar_buffer_info *tmp;
-	int z;
-
-	for (z = 0; z != MRST_NUM_RAR; ++z) {
-		struct memrar_rar_info * const rar = &memrars[z];
-
-		mutex_lock(&rar->lock);
-
-		list_for_each_entry_safe(pos,
-					 tmp,
-					 &rar->buffers.list,
-					 list) {
-			if (filp == pos->owner)
-				kref_put(&pos->refcount,
-					 memrar_release_block_i);
-		}
-
-		mutex_unlock(&rar->lock);
-	}
-
-	return 0;
-}
-
-/**
- *	rar_reserve		-	reserve RAR memory
- *	@buffers: buffers to reserve
- *	@count: number wanted
- *
- *	Reserve a series of buffers in the RAR space. Returns the number of
- *	buffers successfully allocated
- */
-
-size_t rar_reserve(struct RAR_buffer *buffers, size_t count)
-{
-	struct RAR_buffer * const end =
-		(buffers == NULL ? buffers : buffers + count);
-	struct RAR_buffer *i;
-
-	size_t reserve_count = 0;
-
-	for (i = buffers; i != end; ++i) {
-		if (memrar_reserve_block(i, NULL) == 0)
-			++reserve_count;
-		else
-			i->bus_address = 0;
-	}
-
-	return reserve_count;
-}
-EXPORT_SYMBOL(rar_reserve);
-
-/**
- *	rar_release		-	return RAR buffers
- *	@buffers: buffers to release
- *	@size: size of released block
- *
- *	Return a set of buffers to the RAR pool
- */
-
-size_t rar_release(struct RAR_buffer *buffers, size_t count)
-{
-	struct RAR_buffer * const end =
-		(buffers == NULL ? buffers : buffers + count);
-	struct RAR_buffer *i;
-
-	size_t release_count = 0;
-
-	for (i = buffers; i != end; ++i) {
-		u32 * const handle = &i->info.handle;
-		if (memrar_release_block(*handle) == 0) {
-			/*
-			 * @todo We assume we should do this each time
-			 *       the ref count is decremented.  Should
-			 *       we instead only do this when the ref
-			 *       count has dropped to zero, and the
-			 *       buffer has been completely
-			 *       released/unmapped?
-			 */
-			*handle = 0;
-			++release_count;
-		}
-	}
-
-	return release_count;
-}
-EXPORT_SYMBOL(rar_release);
-
-/**
- *	rar_handle_to_bus	-	RAR to bus address
- *	@buffers: RAR buffer structure
- *	@count: number of buffers to convert
- *
- *	Turn a list of RAR handle mappings into actual bus addresses. Note
- *	that when the device is locked down the bus addresses in question
- *	are not CPU accessible.
- */
-
-size_t rar_handle_to_bus(struct RAR_buffer *buffers, size_t count)
-{
-	struct RAR_buffer * const end =
-		(buffers == NULL ? buffers : buffers + count);
-	struct RAR_buffer *i;
-	struct memrar_buffer_info *pos;
-
-	size_t conversion_count = 0;
-
-	/*
-	 * Find all bus addresses corresponding to the given handles.
-	 *
-	 * @todo Not liking this nested loop.  Optimize.
-	 */
-	for (i = buffers; i != end; ++i) {
-		struct memrar_rar_info * const rar =
-			memrar_get_rar_info(i->info.handle);
-
-		/*
-		 * Check if we have a bogus handle, and then continue
-		 * with remaining buffers.
-		 */
-		if (rar == NULL) {
-			i->bus_address = 0;
-			continue;
-		}
-
-		mutex_lock(&rar->lock);
-
-		list_for_each_entry(pos, &rar->buffers.list, list) {
-			struct RAR_block_info * const user_info =
-				&pos->buffer.info;
-
-			/*
-			 * Take into account handle offsets that may
-			 * have been added to the base handle, such as
-			 * in the following scenario:
-			 *
-			 *     u32 handle = base + offset;
-			 *     rar_handle_to_bus(handle);
-			 */
-
-			if (i->info.handle >= user_info->handle
-			    && i->info.handle < (user_info->handle
-						 + user_info->size)) {
-				u32 const offset =
-					i->info.handle - user_info->handle;
-
-				i->info.type = user_info->type;
-				i->info.size = user_info->size - offset;
-				i->bus_address =
-					pos->buffer.bus_address
-					+ offset;
-
-				/* Increment the reference count. */
-				kref_get(&pos->refcount);
-
-				++conversion_count;
-				break;
-			} else {
-				i->bus_address = 0;
-			}
-		}
-
-		mutex_unlock(&rar->lock);
-	}
-
-	return conversion_count;
-}
-EXPORT_SYMBOL(rar_handle_to_bus);
-
-static const struct file_operations memrar_fops = {
-	.owner = THIS_MODULE,
-	.unlocked_ioctl = memrar_ioctl,
-	.mmap           = memrar_mmap,
-	.open           = memrar_open,
-	.release        = memrar_release,
-	.llseek		= no_llseek,
-};
-
-static struct miscdevice memrar_miscdev = {
-	.minor = MISC_DYNAMIC_MINOR,    /* dynamic allocation */
-	.name = "memrar",               /* /dev/memrar */
-	.fops = &memrar_fops
-};
-
-static char const banner[] __initdata =
-	KERN_INFO
-	"Intel RAR Handler: " MEMRAR_VER " initialized.\n";
-
-/**
- *	memrar_registration_callback	-	RAR obtained
- *	@rar: RAR number
- *
- *	We have been granted ownership of the RAR. Add it to our memory
- *	management tables
- */
-
-static int memrar_registration_callback(unsigned long rar)
-{
-	/*
-	 * We initialize the RAR parameters early on so that we can
-	 * discontinue memrar device initialization and registration
-	 * if suitably configured RARs are not available.
-	 */
-	return memrar_init_rar_resources(rar, memrar_miscdev.name);
-}
-
-/**
- *	memrar_init	-	initialise RAR support
- *
- *	Initialise support for RAR handlers. This may get loaded before
- *	the RAR support is activated, but the callbacks on the registration
- *	will handle that situation for us anyway.
- */
-
-static int __init memrar_init(void)
-{
-	int err;
-	int i;
-
-	printk(banner);
-
-	/*
-	 * Some delayed initialization is performed in this driver.
-	 * Make sure resources that are used during driver clean-up
-	 * (e.g. during driver's release() function) are fully
-	 * initialized before first use.  This is particularly
-	 * important for the case when the delayed initialization
-	 * isn't completed, leaving behind a partially initialized
-	 * driver.
-	 *
-	 * Such a scenario can occur when RAR is not available on the
-	 * platform, and the driver is release()d.
-	 */
-	for (i = 0; i != ARRAY_SIZE(memrars); ++i) {
-		struct memrar_rar_info * const rar = &memrars[i];
-		mutex_init(&rar->lock);
-		INIT_LIST_HEAD(&rar->buffers.list);
-	}
-
-	err = misc_register(&memrar_miscdev);
-	if (err)
-		return err;
-
-	/* Now claim the two RARs we want */
-	err = register_rar(0, memrar_registration_callback, 0);
-	if (err)
-		goto fail;
-
-	err = register_rar(1, memrar_registration_callback, 1);
-	if (err == 0)
-		return 0;
-
-	/* It is possible rar 0 registered and allocated resources then rar 1
-	   failed so do a full resource free */
-	memrar_fini_rar_resources();
-fail:
-	misc_deregister(&memrar_miscdev);
-	return err;
-}
-
-/**
- *	memrar_exit	-	unregister and unload
- *
- *	Unregister the device and then unload any mappings and release
- *	the RAR resources
- */
-
-static void __exit memrar_exit(void)
-{
-	misc_deregister(&memrar_miscdev);
-	memrar_fini_rar_resources();
-}
-
-
-module_init(memrar_init);
-module_exit(memrar_exit);
-
-
-MODULE_AUTHOR("Ossama Othman <ossama.othman@xxxxxxxxx>");
-MODULE_DESCRIPTION("Intel Restricted Access Region Handler");
-MODULE_LICENSE("GPL");
-MODULE_VERSION(MEMRAR_VER);
-
-
-
-/*
-  Local Variables:
-    c-file-style: "linux"
-  End:
-*/
-- 
1.7.4.2

_______________________________________________
devel mailing list
devel@xxxxxxxxxxxxxxxxxxxxxx
http://driverdev.linuxdriverproject.org/mailman/listinfo/devel


[Index of Archives]     [Linux Driver Backports]     [DMA Engine]     [Linux GPIO]     [Linux SPI]     [Video for Linux]     [Linux USB Devel]     [Linux Coverity]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux