mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Arjan van de Ven](/assets/img/avatar_default.png)
Device drivers that use pci_request_regions() (and similar APIs) have a reasonable expectation that they are the only ones accessing their device. As part of the e1000e hunt, we were afraid that some userland (X or some bootsplash stuff) was mapping the MMIO region that the driver thought it had exclusively via /dev/mem or via various sysfs resource mappings. This patch adds the option for device drivers to cause their reserved regions to the "banned from /dev/mem use" list, so now both kernel memory and device-exclusive MMIO regions are banned. NOTE: This is only active when CONFIG_STRICT_DEVMEM is set. In addition to the config option, a kernel parameter iomem=relaxed is provided for the cases where developers want to diagnose, in the field, drivers issues from userspace. Reviewed-by: Matthew Wilcox <willy@linux.intel.com> Signed-off-by: Arjan van de Ven <arjan@linux.intel.com> Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
933 lines
21 KiB
C
933 lines
21 KiB
C
/*
|
|
* linux/kernel/resource.c
|
|
*
|
|
* Copyright (C) 1999 Linus Torvalds
|
|
* Copyright (C) 1999 Martin Mares <mj@ucw.cz>
|
|
*
|
|
* Arbitrary resource management.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/device.h>
|
|
#include <linux/pfn.h>
|
|
#include <asm/io.h>
|
|
|
|
|
|
struct resource ioport_resource = {
|
|
.name = "PCI IO",
|
|
.start = 0,
|
|
.end = IO_SPACE_LIMIT,
|
|
.flags = IORESOURCE_IO,
|
|
};
|
|
EXPORT_SYMBOL(ioport_resource);
|
|
|
|
struct resource iomem_resource = {
|
|
.name = "PCI mem",
|
|
.start = 0,
|
|
.end = -1,
|
|
.flags = IORESOURCE_MEM,
|
|
};
|
|
EXPORT_SYMBOL(iomem_resource);
|
|
|
|
static DEFINE_RWLOCK(resource_lock);
|
|
|
|
static void *r_next(struct seq_file *m, void *v, loff_t *pos)
|
|
{
|
|
struct resource *p = v;
|
|
(*pos)++;
|
|
if (p->child)
|
|
return p->child;
|
|
while (!p->sibling && p->parent)
|
|
p = p->parent;
|
|
return p->sibling;
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
enum { MAX_IORES_LEVEL = 5 };
|
|
|
|
static void *r_start(struct seq_file *m, loff_t *pos)
|
|
__acquires(resource_lock)
|
|
{
|
|
struct resource *p = m->private;
|
|
loff_t l = 0;
|
|
read_lock(&resource_lock);
|
|
for (p = p->child; p && l < *pos; p = r_next(m, p, &l))
|
|
;
|
|
return p;
|
|
}
|
|
|
|
static void r_stop(struct seq_file *m, void *v)
|
|
__releases(resource_lock)
|
|
{
|
|
read_unlock(&resource_lock);
|
|
}
|
|
|
|
static int r_show(struct seq_file *m, void *v)
|
|
{
|
|
struct resource *root = m->private;
|
|
struct resource *r = v, *p;
|
|
int width = root->end < 0x10000 ? 4 : 8;
|
|
int depth;
|
|
|
|
for (depth = 0, p = r; depth < MAX_IORES_LEVEL; depth++, p = p->parent)
|
|
if (p->parent == root)
|
|
break;
|
|
seq_printf(m, "%*s%0*llx-%0*llx : %s\n",
|
|
depth * 2, "",
|
|
width, (unsigned long long) r->start,
|
|
width, (unsigned long long) r->end,
|
|
r->name ? r->name : "<BAD>");
|
|
return 0;
|
|
}
|
|
|
|
static const struct seq_operations resource_op = {
|
|
.start = r_start,
|
|
.next = r_next,
|
|
.stop = r_stop,
|
|
.show = r_show,
|
|
};
|
|
|
|
static int ioports_open(struct inode *inode, struct file *file)
|
|
{
|
|
int res = seq_open(file, &resource_op);
|
|
if (!res) {
|
|
struct seq_file *m = file->private_data;
|
|
m->private = &ioport_resource;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static int iomem_open(struct inode *inode, struct file *file)
|
|
{
|
|
int res = seq_open(file, &resource_op);
|
|
if (!res) {
|
|
struct seq_file *m = file->private_data;
|
|
m->private = &iomem_resource;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static const struct file_operations proc_ioports_operations = {
|
|
.open = ioports_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = seq_release,
|
|
};
|
|
|
|
static const struct file_operations proc_iomem_operations = {
|
|
.open = iomem_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = seq_release,
|
|
};
|
|
|
|
static int __init ioresources_init(void)
|
|
{
|
|
proc_create("ioports", 0, NULL, &proc_ioports_operations);
|
|
proc_create("iomem", 0, NULL, &proc_iomem_operations);
|
|
return 0;
|
|
}
|
|
__initcall(ioresources_init);
|
|
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
/* Return the conflict entry if you can't request it */
|
|
static struct resource * __request_resource(struct resource *root, struct resource *new)
|
|
{
|
|
resource_size_t start = new->start;
|
|
resource_size_t end = new->end;
|
|
struct resource *tmp, **p;
|
|
|
|
if (end < start)
|
|
return root;
|
|
if (start < root->start)
|
|
return root;
|
|
if (end > root->end)
|
|
return root;
|
|
p = &root->child;
|
|
for (;;) {
|
|
tmp = *p;
|
|
if (!tmp || tmp->start > end) {
|
|
new->sibling = tmp;
|
|
*p = new;
|
|
new->parent = root;
|
|
return NULL;
|
|
}
|
|
p = &tmp->sibling;
|
|
if (tmp->end < start)
|
|
continue;
|
|
return tmp;
|
|
}
|
|
}
|
|
|
|
static int __release_resource(struct resource *old)
|
|
{
|
|
struct resource *tmp, **p;
|
|
|
|
p = &old->parent->child;
|
|
for (;;) {
|
|
tmp = *p;
|
|
if (!tmp)
|
|
break;
|
|
if (tmp == old) {
|
|
*p = tmp->sibling;
|
|
old->parent = NULL;
|
|
return 0;
|
|
}
|
|
p = &tmp->sibling;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
/**
|
|
* request_resource - request and reserve an I/O or memory resource
|
|
* @root: root resource descriptor
|
|
* @new: resource descriptor desired by caller
|
|
*
|
|
* Returns 0 for success, negative error code on error.
|
|
*/
|
|
int request_resource(struct resource *root, struct resource *new)
|
|
{
|
|
struct resource *conflict;
|
|
|
|
write_lock(&resource_lock);
|
|
conflict = __request_resource(root, new);
|
|
write_unlock(&resource_lock);
|
|
return conflict ? -EBUSY : 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(request_resource);
|
|
|
|
/**
|
|
* release_resource - release a previously reserved resource
|
|
* @old: resource pointer
|
|
*/
|
|
int release_resource(struct resource *old)
|
|
{
|
|
int retval;
|
|
|
|
write_lock(&resource_lock);
|
|
retval = __release_resource(old);
|
|
write_unlock(&resource_lock);
|
|
return retval;
|
|
}
|
|
|
|
EXPORT_SYMBOL(release_resource);
|
|
|
|
#if defined(CONFIG_MEMORY_HOTPLUG) && !defined(CONFIG_ARCH_HAS_WALK_MEMORY)
|
|
/*
|
|
* Finds the lowest memory reosurce exists within [res->start.res->end)
|
|
* the caller must specify res->start, res->end, res->flags.
|
|
* If found, returns 0, res is overwritten, if not found, returns -1.
|
|
*/
|
|
static int find_next_system_ram(struct resource *res)
|
|
{
|
|
resource_size_t start, end;
|
|
struct resource *p;
|
|
|
|
BUG_ON(!res);
|
|
|
|
start = res->start;
|
|
end = res->end;
|
|
BUG_ON(start >= end);
|
|
|
|
read_lock(&resource_lock);
|
|
for (p = iomem_resource.child; p ; p = p->sibling) {
|
|
/* system ram is just marked as IORESOURCE_MEM */
|
|
if (p->flags != res->flags)
|
|
continue;
|
|
if (p->start > end) {
|
|
p = NULL;
|
|
break;
|
|
}
|
|
if ((p->end >= start) && (p->start < end))
|
|
break;
|
|
}
|
|
read_unlock(&resource_lock);
|
|
if (!p)
|
|
return -1;
|
|
/* copy data */
|
|
if (res->start < p->start)
|
|
res->start = p->start;
|
|
if (res->end > p->end)
|
|
res->end = p->end;
|
|
return 0;
|
|
}
|
|
int
|
|
walk_memory_resource(unsigned long start_pfn, unsigned long nr_pages, void *arg,
|
|
int (*func)(unsigned long, unsigned long, void *))
|
|
{
|
|
struct resource res;
|
|
unsigned long pfn, len;
|
|
u64 orig_end;
|
|
int ret = -1;
|
|
res.start = (u64) start_pfn << PAGE_SHIFT;
|
|
res.end = ((u64)(start_pfn + nr_pages) << PAGE_SHIFT) - 1;
|
|
res.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
|
|
orig_end = res.end;
|
|
while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {
|
|
pfn = (unsigned long)(res.start >> PAGE_SHIFT);
|
|
len = (unsigned long)((res.end + 1 - res.start) >> PAGE_SHIFT);
|
|
ret = (*func)(pfn, len, arg);
|
|
if (ret)
|
|
break;
|
|
res.start = res.end + 1;
|
|
res.end = orig_end;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
* Find empty slot in the resource tree given range and alignment.
|
|
*/
|
|
static int find_resource(struct resource *root, struct resource *new,
|
|
resource_size_t size, resource_size_t min,
|
|
resource_size_t max, resource_size_t align,
|
|
void (*alignf)(void *, struct resource *,
|
|
resource_size_t, resource_size_t),
|
|
void *alignf_data)
|
|
{
|
|
struct resource *this = root->child;
|
|
|
|
new->start = root->start;
|
|
/*
|
|
* Skip past an allocated resource that starts at 0, since the assignment
|
|
* of this->start - 1 to new->end below would cause an underflow.
|
|
*/
|
|
if (this && this->start == 0) {
|
|
new->start = this->end + 1;
|
|
this = this->sibling;
|
|
}
|
|
for(;;) {
|
|
if (this)
|
|
new->end = this->start - 1;
|
|
else
|
|
new->end = root->end;
|
|
if (new->start < min)
|
|
new->start = min;
|
|
if (new->end > max)
|
|
new->end = max;
|
|
new->start = ALIGN(new->start, align);
|
|
if (alignf)
|
|
alignf(alignf_data, new, size, align);
|
|
if (new->start < new->end && new->end - new->start >= size - 1) {
|
|
new->end = new->start + size - 1;
|
|
return 0;
|
|
}
|
|
if (!this)
|
|
break;
|
|
new->start = this->end + 1;
|
|
this = this->sibling;
|
|
}
|
|
return -EBUSY;
|
|
}
|
|
|
|
/**
|
|
* allocate_resource - allocate empty slot in the resource tree given range & alignment
|
|
* @root: root resource descriptor
|
|
* @new: resource descriptor desired by caller
|
|
* @size: requested resource region size
|
|
* @min: minimum size to allocate
|
|
* @max: maximum size to allocate
|
|
* @align: alignment requested, in bytes
|
|
* @alignf: alignment function, optional, called if not NULL
|
|
* @alignf_data: arbitrary data to pass to the @alignf function
|
|
*/
|
|
int allocate_resource(struct resource *root, struct resource *new,
|
|
resource_size_t size, resource_size_t min,
|
|
resource_size_t max, resource_size_t align,
|
|
void (*alignf)(void *, struct resource *,
|
|
resource_size_t, resource_size_t),
|
|
void *alignf_data)
|
|
{
|
|
int err;
|
|
|
|
write_lock(&resource_lock);
|
|
err = find_resource(root, new, size, min, max, align, alignf, alignf_data);
|
|
if (err >= 0 && __request_resource(root, new))
|
|
err = -EBUSY;
|
|
write_unlock(&resource_lock);
|
|
return err;
|
|
}
|
|
|
|
EXPORT_SYMBOL(allocate_resource);
|
|
|
|
/*
|
|
* Insert a resource into the resource tree. If successful, return NULL,
|
|
* otherwise return the conflicting resource (compare to __request_resource())
|
|
*/
|
|
static struct resource * __insert_resource(struct resource *parent, struct resource *new)
|
|
{
|
|
struct resource *first, *next;
|
|
|
|
for (;; parent = first) {
|
|
first = __request_resource(parent, new);
|
|
if (!first)
|
|
return first;
|
|
|
|
if (first == parent)
|
|
return first;
|
|
|
|
if ((first->start > new->start) || (first->end < new->end))
|
|
break;
|
|
if ((first->start == new->start) && (first->end == new->end))
|
|
break;
|
|
}
|
|
|
|
for (next = first; ; next = next->sibling) {
|
|
/* Partial overlap? Bad, and unfixable */
|
|
if (next->start < new->start || next->end > new->end)
|
|
return next;
|
|
if (!next->sibling)
|
|
break;
|
|
if (next->sibling->start > new->end)
|
|
break;
|
|
}
|
|
|
|
new->parent = parent;
|
|
new->sibling = next->sibling;
|
|
new->child = first;
|
|
|
|
next->sibling = NULL;
|
|
for (next = first; next; next = next->sibling)
|
|
next->parent = new;
|
|
|
|
if (parent->child == first) {
|
|
parent->child = new;
|
|
} else {
|
|
next = parent->child;
|
|
while (next->sibling != first)
|
|
next = next->sibling;
|
|
next->sibling = new;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* insert_resource - Inserts a resource in the resource tree
|
|
* @parent: parent of the new resource
|
|
* @new: new resource to insert
|
|
*
|
|
* Returns 0 on success, -EBUSY if the resource can't be inserted.
|
|
*
|
|
* This function is equivalent to request_resource when no conflict
|
|
* happens. If a conflict happens, and the conflicting resources
|
|
* entirely fit within the range of the new resource, then the new
|
|
* resource is inserted and the conflicting resources become children of
|
|
* the new resource.
|
|
*/
|
|
int insert_resource(struct resource *parent, struct resource *new)
|
|
{
|
|
struct resource *conflict;
|
|
|
|
write_lock(&resource_lock);
|
|
conflict = __insert_resource(parent, new);
|
|
write_unlock(&resource_lock);
|
|
return conflict ? -EBUSY : 0;
|
|
}
|
|
|
|
/**
|
|
* insert_resource_expand_to_fit - Insert a resource into the resource tree
|
|
* @root: root resource descriptor
|
|
* @new: new resource to insert
|
|
*
|
|
* Insert a resource into the resource tree, possibly expanding it in order
|
|
* to make it encompass any conflicting resources.
|
|
*/
|
|
void insert_resource_expand_to_fit(struct resource *root, struct resource *new)
|
|
{
|
|
if (new->parent)
|
|
return;
|
|
|
|
write_lock(&resource_lock);
|
|
for (;;) {
|
|
struct resource *conflict;
|
|
|
|
conflict = __insert_resource(root, new);
|
|
if (!conflict)
|
|
break;
|
|
if (conflict == root)
|
|
break;
|
|
|
|
/* Ok, expand resource to cover the conflict, then try again .. */
|
|
if (conflict->start < new->start)
|
|
new->start = conflict->start;
|
|
if (conflict->end > new->end)
|
|
new->end = conflict->end;
|
|
|
|
printk("Expanded resource %s due to conflict with %s\n", new->name, conflict->name);
|
|
}
|
|
write_unlock(&resource_lock);
|
|
}
|
|
|
|
/**
|
|
* adjust_resource - modify a resource's start and size
|
|
* @res: resource to modify
|
|
* @start: new start value
|
|
* @size: new size
|
|
*
|
|
* Given an existing resource, change its start and size to match the
|
|
* arguments. Returns 0 on success, -EBUSY if it can't fit.
|
|
* Existing children of the resource are assumed to be immutable.
|
|
*/
|
|
int adjust_resource(struct resource *res, resource_size_t start, resource_size_t size)
|
|
{
|
|
struct resource *tmp, *parent = res->parent;
|
|
resource_size_t end = start + size - 1;
|
|
int result = -EBUSY;
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
if ((start < parent->start) || (end > parent->end))
|
|
goto out;
|
|
|
|
for (tmp = res->child; tmp; tmp = tmp->sibling) {
|
|
if ((tmp->start < start) || (tmp->end > end))
|
|
goto out;
|
|
}
|
|
|
|
if (res->sibling && (res->sibling->start <= end))
|
|
goto out;
|
|
|
|
tmp = parent->child;
|
|
if (tmp != res) {
|
|
while (tmp->sibling != res)
|
|
tmp = tmp->sibling;
|
|
if (start <= tmp->end)
|
|
goto out;
|
|
}
|
|
|
|
res->start = start;
|
|
res->end = end;
|
|
result = 0;
|
|
|
|
out:
|
|
write_unlock(&resource_lock);
|
|
return result;
|
|
}
|
|
|
|
static void __init __reserve_region_with_split(struct resource *root,
|
|
resource_size_t start, resource_size_t end,
|
|
const char *name)
|
|
{
|
|
struct resource *parent = root;
|
|
struct resource *conflict;
|
|
struct resource *res = kzalloc(sizeof(*res), GFP_ATOMIC);
|
|
|
|
if (!res)
|
|
return;
|
|
|
|
res->name = name;
|
|
res->start = start;
|
|
res->end = end;
|
|
res->flags = IORESOURCE_BUSY;
|
|
|
|
for (;;) {
|
|
conflict = __request_resource(parent, res);
|
|
if (!conflict)
|
|
break;
|
|
if (conflict != parent) {
|
|
parent = conflict;
|
|
if (!(conflict->flags & IORESOURCE_BUSY))
|
|
continue;
|
|
}
|
|
|
|
/* Uhhuh, that didn't work out.. */
|
|
kfree(res);
|
|
res = NULL;
|
|
break;
|
|
}
|
|
|
|
if (!res) {
|
|
/* failed, split and try again */
|
|
|
|
/* conflict covered whole area */
|
|
if (conflict->start <= start && conflict->end >= end)
|
|
return;
|
|
|
|
if (conflict->start > start)
|
|
__reserve_region_with_split(root, start, conflict->start-1, name);
|
|
if (!(conflict->flags & IORESOURCE_BUSY)) {
|
|
resource_size_t common_start, common_end;
|
|
|
|
common_start = max(conflict->start, start);
|
|
common_end = min(conflict->end, end);
|
|
if (common_start < common_end)
|
|
__reserve_region_with_split(root, common_start, common_end, name);
|
|
}
|
|
if (conflict->end < end)
|
|
__reserve_region_with_split(root, conflict->end+1, end, name);
|
|
}
|
|
|
|
}
|
|
|
|
void __init reserve_region_with_split(struct resource *root,
|
|
resource_size_t start, resource_size_t end,
|
|
const char *name)
|
|
{
|
|
write_lock(&resource_lock);
|
|
__reserve_region_with_split(root, start, end, name);
|
|
write_unlock(&resource_lock);
|
|
}
|
|
|
|
EXPORT_SYMBOL(adjust_resource);
|
|
|
|
/**
|
|
* resource_alignment - calculate resource's alignment
|
|
* @res: resource pointer
|
|
*
|
|
* Returns alignment on success, 0 (invalid alignment) on failure.
|
|
*/
|
|
resource_size_t resource_alignment(struct resource *res)
|
|
{
|
|
switch (res->flags & (IORESOURCE_SIZEALIGN | IORESOURCE_STARTALIGN)) {
|
|
case IORESOURCE_SIZEALIGN:
|
|
return resource_size(res);
|
|
case IORESOURCE_STARTALIGN:
|
|
return res->start;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This is compatibility stuff for IO resources.
|
|
*
|
|
* Note how this, unlike the above, knows about
|
|
* the IO flag meanings (busy etc).
|
|
*
|
|
* request_region creates a new busy region.
|
|
*
|
|
* check_region returns non-zero if the area is already busy.
|
|
*
|
|
* release_region releases a matching busy region.
|
|
*/
|
|
|
|
/**
|
|
* __request_region - create a new busy resource region
|
|
* @parent: parent resource descriptor
|
|
* @start: resource start address
|
|
* @n: resource region size
|
|
* @name: reserving caller's ID string
|
|
*/
|
|
struct resource * __request_region(struct resource *parent,
|
|
resource_size_t start, resource_size_t n,
|
|
const char *name, int flags)
|
|
{
|
|
struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
|
|
|
|
if (!res)
|
|
return NULL;
|
|
|
|
res->name = name;
|
|
res->start = start;
|
|
res->end = start + n - 1;
|
|
res->flags = IORESOURCE_BUSY;
|
|
res->flags |= flags;
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
for (;;) {
|
|
struct resource *conflict;
|
|
|
|
conflict = __request_resource(parent, res);
|
|
if (!conflict)
|
|
break;
|
|
if (conflict != parent) {
|
|
parent = conflict;
|
|
if (!(conflict->flags & IORESOURCE_BUSY))
|
|
continue;
|
|
}
|
|
|
|
/* Uhhuh, that didn't work out.. */
|
|
kfree(res);
|
|
res = NULL;
|
|
break;
|
|
}
|
|
write_unlock(&resource_lock);
|
|
return res;
|
|
}
|
|
EXPORT_SYMBOL(__request_region);
|
|
|
|
/**
|
|
* __check_region - check if a resource region is busy or free
|
|
* @parent: parent resource descriptor
|
|
* @start: resource start address
|
|
* @n: resource region size
|
|
*
|
|
* Returns 0 if the region is free at the moment it is checked,
|
|
* returns %-EBUSY if the region is busy.
|
|
*
|
|
* NOTE:
|
|
* This function is deprecated because its use is racy.
|
|
* Even if it returns 0, a subsequent call to request_region()
|
|
* may fail because another driver etc. just allocated the region.
|
|
* Do NOT use it. It will be removed from the kernel.
|
|
*/
|
|
int __check_region(struct resource *parent, resource_size_t start,
|
|
resource_size_t n)
|
|
{
|
|
struct resource * res;
|
|
|
|
res = __request_region(parent, start, n, "check-region", 0);
|
|
if (!res)
|
|
return -EBUSY;
|
|
|
|
release_resource(res);
|
|
kfree(res);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(__check_region);
|
|
|
|
/**
|
|
* __release_region - release a previously reserved resource region
|
|
* @parent: parent resource descriptor
|
|
* @start: resource start address
|
|
* @n: resource region size
|
|
*
|
|
* The described resource region must match a currently busy region.
|
|
*/
|
|
void __release_region(struct resource *parent, resource_size_t start,
|
|
resource_size_t n)
|
|
{
|
|
struct resource **p;
|
|
resource_size_t end;
|
|
|
|
p = &parent->child;
|
|
end = start + n - 1;
|
|
|
|
write_lock(&resource_lock);
|
|
|
|
for (;;) {
|
|
struct resource *res = *p;
|
|
|
|
if (!res)
|
|
break;
|
|
if (res->start <= start && res->end >= end) {
|
|
if (!(res->flags & IORESOURCE_BUSY)) {
|
|
p = &res->child;
|
|
continue;
|
|
}
|
|
if (res->start != start || res->end != end)
|
|
break;
|
|
*p = res->sibling;
|
|
write_unlock(&resource_lock);
|
|
kfree(res);
|
|
return;
|
|
}
|
|
p = &res->sibling;
|
|
}
|
|
|
|
write_unlock(&resource_lock);
|
|
|
|
printk(KERN_WARNING "Trying to free nonexistent resource "
|
|
"<%016llx-%016llx>\n", (unsigned long long)start,
|
|
(unsigned long long)end);
|
|
}
|
|
EXPORT_SYMBOL(__release_region);
|
|
|
|
/*
|
|
* Managed region resource
|
|
*/
|
|
struct region_devres {
|
|
struct resource *parent;
|
|
resource_size_t start;
|
|
resource_size_t n;
|
|
};
|
|
|
|
static void devm_region_release(struct device *dev, void *res)
|
|
{
|
|
struct region_devres *this = res;
|
|
|
|
__release_region(this->parent, this->start, this->n);
|
|
}
|
|
|
|
static int devm_region_match(struct device *dev, void *res, void *match_data)
|
|
{
|
|
struct region_devres *this = res, *match = match_data;
|
|
|
|
return this->parent == match->parent &&
|
|
this->start == match->start && this->n == match->n;
|
|
}
|
|
|
|
struct resource * __devm_request_region(struct device *dev,
|
|
struct resource *parent, resource_size_t start,
|
|
resource_size_t n, const char *name)
|
|
{
|
|
struct region_devres *dr = NULL;
|
|
struct resource *res;
|
|
|
|
dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
|
|
GFP_KERNEL);
|
|
if (!dr)
|
|
return NULL;
|
|
|
|
dr->parent = parent;
|
|
dr->start = start;
|
|
dr->n = n;
|
|
|
|
res = __request_region(parent, start, n, name, 0);
|
|
if (res)
|
|
devres_add(dev, dr);
|
|
else
|
|
devres_free(dr);
|
|
|
|
return res;
|
|
}
|
|
EXPORT_SYMBOL(__devm_request_region);
|
|
|
|
void __devm_release_region(struct device *dev, struct resource *parent,
|
|
resource_size_t start, resource_size_t n)
|
|
{
|
|
struct region_devres match_data = { parent, start, n };
|
|
|
|
__release_region(parent, start, n);
|
|
WARN_ON(devres_destroy(dev, devm_region_release, devm_region_match,
|
|
&match_data));
|
|
}
|
|
EXPORT_SYMBOL(__devm_release_region);
|
|
|
|
/*
|
|
* Called from init/main.c to reserve IO ports.
|
|
*/
|
|
#define MAXRESERVE 4
|
|
static int __init reserve_setup(char *str)
|
|
{
|
|
static int reserved;
|
|
static struct resource reserve[MAXRESERVE];
|
|
|
|
for (;;) {
|
|
int io_start, io_num;
|
|
int x = reserved;
|
|
|
|
if (get_option (&str, &io_start) != 2)
|
|
break;
|
|
if (get_option (&str, &io_num) == 0)
|
|
break;
|
|
if (x < MAXRESERVE) {
|
|
struct resource *res = reserve + x;
|
|
res->name = "reserved";
|
|
res->start = io_start;
|
|
res->end = io_start + io_num - 1;
|
|
res->flags = IORESOURCE_BUSY;
|
|
res->child = NULL;
|
|
if (request_resource(res->start >= 0x10000 ? &iomem_resource : &ioport_resource, res) == 0)
|
|
reserved = x+1;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
__setup("reserve=", reserve_setup);
|
|
|
|
/*
|
|
* Check if the requested addr and size spans more than any slot in the
|
|
* iomem resource tree.
|
|
*/
|
|
int iomem_map_sanity_check(resource_size_t addr, unsigned long size)
|
|
{
|
|
struct resource *p = &iomem_resource;
|
|
int err = 0;
|
|
loff_t l;
|
|
|
|
read_lock(&resource_lock);
|
|
for (p = p->child; p ; p = r_next(NULL, p, &l)) {
|
|
/*
|
|
* We can probably skip the resources without
|
|
* IORESOURCE_IO attribute?
|
|
*/
|
|
if (p->start >= addr + size)
|
|
continue;
|
|
if (p->end < addr)
|
|
continue;
|
|
if (PFN_DOWN(p->start) <= PFN_DOWN(addr) &&
|
|
PFN_DOWN(p->end) >= PFN_DOWN(addr + size - 1))
|
|
continue;
|
|
/*
|
|
* if a resource is "BUSY", it's not a hardware resource
|
|
* but a driver mapping of such a resource; we don't want
|
|
* to warn for those; some drivers legitimately map only
|
|
* partial hardware resources. (example: vesafb)
|
|
*/
|
|
if (p->flags & IORESOURCE_BUSY)
|
|
continue;
|
|
|
|
printk(KERN_WARNING "resource map sanity check conflict: "
|
|
"0x%llx 0x%llx 0x%llx 0x%llx %s\n",
|
|
(unsigned long long)addr,
|
|
(unsigned long long)(addr + size - 1),
|
|
(unsigned long long)p->start,
|
|
(unsigned long long)p->end,
|
|
p->name);
|
|
err = -1;
|
|
break;
|
|
}
|
|
read_unlock(&resource_lock);
|
|
|
|
return err;
|
|
}
|
|
|
|
#ifdef CONFIG_STRICT_DEVMEM
|
|
static int strict_iomem_checks = 1;
|
|
#else
|
|
static int strict_iomem_checks;
|
|
#endif
|
|
|
|
/*
|
|
* check if an address is reserved in the iomem resource tree
|
|
* returns 1 if reserved, 0 if not reserved.
|
|
*/
|
|
int iomem_is_exclusive(u64 addr)
|
|
{
|
|
struct resource *p = &iomem_resource;
|
|
int err = 0;
|
|
loff_t l;
|
|
int size = PAGE_SIZE;
|
|
|
|
if (!strict_iomem_checks)
|
|
return 0;
|
|
|
|
addr = addr & PAGE_MASK;
|
|
|
|
read_lock(&resource_lock);
|
|
for (p = p->child; p ; p = r_next(NULL, p, &l)) {
|
|
/*
|
|
* We can probably skip the resources without
|
|
* IORESOURCE_IO attribute?
|
|
*/
|
|
if (p->start >= addr + size)
|
|
break;
|
|
if (p->end < addr)
|
|
continue;
|
|
if (p->flags & IORESOURCE_BUSY &&
|
|
p->flags & IORESOURCE_EXCLUSIVE) {
|
|
err = 1;
|
|
break;
|
|
}
|
|
}
|
|
read_unlock(&resource_lock);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int __init strict_iomem(char *str)
|
|
{
|
|
if (strstr(str, "relaxed"))
|
|
strict_iomem_checks = 0;
|
|
if (strstr(str, "strict"))
|
|
strict_iomem_checks = 1;
|
|
return 1;
|
|
}
|
|
|
|
__setup("iomem=", strict_iomem);
|