d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Split struct resource in an external and internal part.

Browse Source 
The external part is still called 'struct resource' but the contents
is now visible to drivers etc.  This makes it part of the device
driver ABI so it not be changed lightly.  A comment to this effect
is in place.

The internal part is called 'struct resource_i' and contain its external
counterpart as one field.

Move the bus_space tag+handle into the external struct resource, this
removes the need for device drivers to even know about these fields
in order to use bus_space to access hardware. (More in following commit).
This commit is contained in:
Poul-Henning Kamp 2005-09-24 20:07:03 +00:00
parent a1a65496e6
commit ae7ff71f63
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=150523
2 changed files with 78 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
sys/kern/subr_rman.c
View File

@ -81,10 +81,22 @@ static MALLOC_DEFINE(M_RMAN, "rman", "Resource manager");
struct rman_head rman_head;
static struct mtx rman_mtx; /* mutex to protect rman_head */
static int int_rman_activate_resource(struct rman *rm, struct resource *r,
struct resource **whohas);
static int int_rman_deactivate_resource(struct resource *r);
static int int_rman_release_resource(struct rman *rm, struct resource *r);
static int int_rman_activate_resource(struct rman *rm, struct resource_i *r,
struct resource_i **whohas);
static int int_rman_deactivate_resource(struct resource_i *r);
static int int_rman_release_resource(struct rman *rm, struct resource_i *r);
static __inline struct resource_i *
int_alloc_resource(int malloc_flag)
{
struct resource_i *r;
r = malloc(sizeof *r, M_RMAN, malloc_flag | M_ZERO);
if (r != NULL) {
r->r_r.__r_i = r;
}
return (r);
}
int
rman_init(struct rman *rm)
@ -121,11 +133,11 @@ rman_init(struct rman *rm)
int
rman_manage_region(struct rman *rm, u_long start, u_long end)
{
struct resource *r, *s;
struct resource_i *r, *s;
DPRINTF(("rman_manage_region: <%s> request: start %#lx, end %#lx\n",
rm->rm_descr, start, end));
r = malloc(sizeof *r, M_RMAN, M_NOWAIT | M_ZERO);
r = int_alloc_resource(M_NOWAIT);
if (r == 0)
return ENOMEM;
r->r_start = start;
@ -151,7 +163,7 @@ rman_manage_region(struct rman *rm, u_long start, u_long end)
int
rman_fini(struct rman *rm)
{
struct resource *r;
struct resource_i *r;
mtx_lock(rm->rm_mtx);
TAILQ_FOREACH(r, &rm->rm_list, r_link) {
@ -186,7 +198,7 @@ rman_reserve_resource_bound(struct rman *rm, u_long start, u_long end,
struct device *dev)
{
u_int want_activate;
struct resource *r, *s, *rv;
struct resource_i *r, *s, *rv;
u_long rstart, rend, amask, bmask;
rv = 0;
@ -267,7 +279,7 @@ rman_reserve_resource_bound(struct rman *rm, u_long start, u_long end,
* split it in two. The first case requires
* two new allocations; the second requires but one.
*/
rv = malloc(sizeof *rv, M_RMAN, M_NOWAIT | M_ZERO);
rv = int_alloc_resource(M_NOWAIT);
if (rv == 0)
goto out;
rv->r_start = rstart;
@ -285,7 +297,7 @@ rman_reserve_resource_bound(struct rman *rm, u_long start, u_long end,
/*
* We are allocating in the middle.
*/
r = malloc(sizeof *r, M_RMAN, M_NOWAIT|M_ZERO);
r = int_alloc_resource(M_NOWAIT);
if (r == 0) {
free(rv, M_RMAN);
rv = 0;
@ -343,7 +355,7 @@ rman_reserve_resource_bound(struct rman *rm, u_long start, u_long end,
&& (s->r_end - s->r_start + 1) == count &&
(s->r_start & amask) == 0 &&
((s->r_start ^ s->r_end) & bmask) == 0) {
rv = malloc(sizeof *rv, M_RMAN, M_NOWAIT | M_ZERO);
rv = int_alloc_resource(M_NOWAIT);
if (rv == 0)
goto out;
rv->r_start = s->r_start;
@ -383,7 +395,7 @@ rman_reserve_resource_bound(struct rman *rm, u_long start, u_long end,
* make sense for RF_TIMESHARE-type resources.)
*/
if (rv && want_activate) {
struct resource *whohas;
struct resource_i *whohas;
if (int_rman_activate_resource(rm, rv, &whohas)) {
int_rman_release_resource(rm, rv);
rv = 0;
@ -391,7 +403,7 @@ rman_reserve_resource_bound(struct rman *rm, u_long start, u_long end,
}
mtx_unlock(rm->rm_mtx);
return (rv);
return (&rv->r_r);
}
struct resource *
@ -404,10 +416,10 @@ rman_reserve_resource(struct rman *rm, u_long start, u_long end, u_long count,
}
static int
int_rman_activate_resource(struct rman *rm, struct resource *r,
struct resource **whohas)
int_rman_activate_resource(struct rman *rm, struct resource_i *r,
struct resource_i **whohas)
{
struct resource *s;
struct resource_i *s;
int ok;
/*
@ -439,12 +451,13 @@ int_rman_activate_resource(struct rman *rm, struct resource *r,
}
int
rman_activate_resource(struct resource *r)
rman_activate_resource(struct resource *re)
{
int rv;
struct resource *whohas;
struct resource_i *r, *whohas;
struct rman *rm;
r = re->__r_i;
rm = r->r_rm;
mtx_lock(rm->rm_mtx);
rv = int_rman_activate_resource(rm, r, &whohas);
@ -453,12 +466,13 @@ rman_activate_resource(struct resource *r)
}
int
rman_await_resource(struct resource *r, int pri, int timo)
rman_await_resource(struct resource *re, int pri, int timo)
{
int rv;
struct resource *whohas;
struct resource_i *r, *whohas;
struct rman *rm;
r = re->__r_i;
rm = r->r_rm;
mtx_lock(rm->rm_mtx);
for (;;) {
@ -478,7 +492,7 @@ rman_await_resource(struct resource *r, int pri, int timo)
}
static int
int_rman_deactivate_resource(struct resource *r)
int_rman_deactivate_resource(struct resource_i *r)
{
r->r_flags &= ~RF_ACTIVE;
@ -494,17 +508,17 @@ rman_deactivate_resource(struct resource *r)
{
struct rman *rm;
rm = r->r_rm;
rm = r->__r_i->r_rm;
mtx_lock(rm->rm_mtx);
int_rman_deactivate_resource(r);
int_rman_deactivate_resource(r->__r_i);
mtx_unlock(rm->rm_mtx);
return 0;
}
static int
int_rman_release_resource(struct rman *rm, struct resource *r)
int_rman_release_resource(struct rman *rm, struct resource_i *r)
{
struct resource *s, *t;
struct resource_i *s, *t;
if (r->r_flags & RF_ACTIVE)
int_rman_deactivate_resource(r);
@ -595,11 +609,14 @@ int_rman_release_resource(struct rman *rm, struct resource *r)
}
int
rman_release_resource(struct resource *r)
rman_release_resource(struct resource *re)
{
int rv;
struct rman *rm = r->r_rm;
struct resource_i *r;
struct rman *rm;
r = re->__r_i;
rm = r->r_rm;
mtx_lock(rm->rm_mtx);
rv = int_rman_release_resource(rm, r);
mtx_unlock(rm->rm_mtx);
@ -627,37 +644,37 @@ rman_make_alignment_flags(uint32_t size)
u_long
rman_get_start(struct resource *r)
{
return (r->r_start);
return (r->__r_i->r_start);
}
u_long
rman_get_end(struct resource *r)
{
return (r->r_end);
return (r->__r_i->r_end);
}
u_long
rman_get_size(struct resource *r)
{
return (r->r_end - r->r_start + 1);
return (r->__r_i->r_end - r->__r_i->r_start + 1);
}
u_int
rman_get_flags(struct resource *r)
{
return (r->r_flags);
return (r->__r_i->r_flags);
}
void
rman_set_virtual(struct resource *r, void *v)
{
r->r_virtual = v;
r->__r_i->r_virtual = v;
}
void *
rman_get_virtual(struct resource *r)
{
return (r->r_virtual);
return (r->__r_i->r_virtual);
}
void
@ -687,37 +704,37 @@ rman_get_bushandle(struct resource *r)
void
rman_set_rid(struct resource *r, int rid)
{
r->r_rid = rid;
r->__r_i->r_rid = rid;
}
void
rman_set_start(struct resource *r, u_long start)
{
r->r_start = start;
r->__r_i->r_start = start;
}
void
rman_set_end(struct resource *r, u_long end)
{
r->r_end = end;
r->__r_i->r_end = end;
}
int
rman_get_rid(struct resource *r)
{
return (r->r_rid);
return (r->__r_i->r_rid);
}
struct device *
rman_get_device(struct resource *r)
{
return (r->r_dev);
return (r->__r_i->r_dev);
}
void
rman_set_device(struct resource *r, struct device *dev)
{
r->r_dev = dev;
r->__r_i->r_dev = dev;
}
/*
@ -733,7 +750,7 @@ sysctl_rman(SYSCTL_HANDLER_ARGS)
u_int namelen = arg2;
int rman_idx, res_idx;
struct rman *rm;
struct resource *res;
struct resource_i *res;
struct u_rman urm;
struct u_resource ures;
int error;

29
sys/sys/rman.h
View File

@ -85,6 +85,21 @@ struct u_rman {
};
#ifdef _KERNEL
/*
* The public (kernel) view of struct resource
*
* NB: Changing the offset/size/type of existing fields in struct resource
* NB: breaks the device driver ABI and is strongly FORBIDDEN.
* NB: Appending new fields is probably just misguided.
*/
struct resource {
struct resource_i *__r_i;
bus_space_tag_t r_bustag; /* bus_space tag */
bus_space_handle_t r_bushandle; /* bus_space handle */
};
/*
* We use a linked list rather than a bitmap because we need to be able to
* represent potentially huge objects (like all of a processor's physical
@ -94,18 +109,17 @@ struct u_rman {
* at some point in the future, particularly if we want to support 36-bit
* addresses on IA32 hardware.
*/
TAILQ_HEAD(resource_head, resource);
TAILQ_HEAD(resource_head, resource_i);
#ifdef __RMAN_RESOURCE_VISIBLE
struct resource {
TAILQ_ENTRY(resource) r_link;
LIST_ENTRY(resource) r_sharelink;
LIST_HEAD(, resource) *r_sharehead;
struct resource_i {
struct resource r_r;
TAILQ_ENTRY(resource_i) r_link;
LIST_ENTRY(resource_i) r_sharelink;
LIST_HEAD(, resource_i) *r_sharehead;
u_long r_start; /* index of the first entry in this resource */
u_long r_end; /* index of the last entry (inclusive) */
u_int r_flags;
void *r_virtual; /* virtual address of this resource */
bus_space_tag_t r_bustag; /* bus_space tag */
bus_space_handle_t r_bushandle; /* bus_space handle */
struct device *r_dev; /* device which has allocated this resource */
struct rman *r_rm; /* resource manager from whence this came */
void *r_spare1; /* Spare pointer 1 */
@ -113,7 +127,6 @@ struct resource {
int r_rid; /* optional rid for this resource. */
};
#else
struct resource;
struct device;
#endif