blob: cfcaa8e5b8e619a8a1bfb4baa131c1a0fad49a7e [file] [log] [blame]
/*
* 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@intel.com>");
MODULE_DESCRIPTION("Intel Restricted Access Region Handler");
MODULE_LICENSE("GPL");
MODULE_VERSION(MEMRAR_VER);
/*
Local Variables:
c-file-style: "linux"
End:
*/