/shark/trunk/drivers/linuxc26/linuxcomp.c |
---|
7,8 → 7,39 |
#include <linux/time.h> |
#include <linux/sched.h> |
#include <linux/ioport.h> |
#include <linux/errno.h> |
#include <asm/io.h> |
#include <linux/ctype.h> |
#include <linux/device.h> |
unsigned char _ctype[] = { |
_C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */ |
_C,_C|_S,_C|_S,_C|_S,_C|_S,_C|_S,_C,_C, /* 8-15 */ |
_C,_C,_C,_C,_C,_C,_C,_C, /* 16-23 */ |
_C,_C,_C,_C,_C,_C,_C,_C, /* 24-31 */ |
_S|_SP,_P,_P,_P,_P,_P,_P,_P, /* 32-39 */ |
_P,_P,_P,_P,_P,_P,_P,_P, /* 40-47 */ |
_D,_D,_D,_D,_D,_D,_D,_D, /* 48-55 */ |
_D,_D,_P,_P,_P,_P,_P,_P, /* 56-63 */ |
_P,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U, /* 64-71 */ |
_U,_U,_U,_U,_U,_U,_U,_U, /* 72-79 */ |
_U,_U,_U,_U,_U,_U,_U,_U, /* 80-87 */ |
_U,_U,_U,_P,_P,_P,_P,_P, /* 88-95 */ |
_P,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L, /* 96-103 */ |
_L,_L,_L,_L,_L,_L,_L,_L, /* 104-111 */ |
_L,_L,_L,_L,_L,_L,_L,_L, /* 112-119 */ |
_L,_L,_L,_P,_P,_P,_P,_C, /* 120-127 */ |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 128-143 */ |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 144-159 */ |
_S|_SP,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 160-175 */ |
_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 176-191 */ |
_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U, /* 192-207 */ |
_U,_U,_U,_U,_U,_U,_U,_P,_U,_U,_U,_U,_U,_U,_U,_L, /* 208-223 */ |
_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L, /* 224-239 */ |
_L,_L,_L,_L,_L,_L,_L,_P,_L,_L,_L,_L,_L,_L,_L,_L}; /* 240-255 */ |
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); |
struct resource ioport_resource = { |
25,12 → 56,336 |
.flags = IORESOURCE_MEM, |
}; |
void __release_region(struct resource *parent, unsigned long start, unsigned long n) { } |
/* Return the conflict entry if you can't request it */ |
static struct resource * __request_resource(struct resource *root, struct resource *new) |
{ |
unsigned long start = new->start; |
unsigned long end = new->end; |
struct resource *tmp, **p; |
struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name) { |
return NULL; |
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; |
} |
int release_resource(struct resource *old) |
{ |
int retval; |
retval = __release_resource(old); |
return retval; |
} |
int request_resource(struct resource *root, struct resource *new) |
{ |
struct resource *conflict; |
conflict = __request_resource(root, new); |
return conflict ? -EBUSY : 0; |
} |
struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name) |
{ |
struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL); |
if (res) { |
memset(res, 0, sizeof(*res)); |
res->name = name; |
res->start = start; |
res->end = start + n - 1; |
res->flags = IORESOURCE_BUSY; |
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; |
} |
} |
return res; |
} |
void __release_region(struct resource *parent, unsigned long start, unsigned long n) |
{ |
struct resource **p; |
unsigned long end; |
p = &parent->child; |
end = start + n - 1; |
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; |
kfree(res); |
return; |
} |
p = &res->sibling; |
} |
printk(KERN_WARNING "Trying to free nonexistent resource <%08lx-%08lx>\n", start, end); |
} |
static int find_resource(struct resource *root, struct resource *new, |
unsigned long size, |
unsigned long min, unsigned long max, |
unsigned long align, |
void (*alignf)(void *, struct resource *, |
unsigned long, unsigned long), |
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 = (new->start + align - 1) & ~(align - 1); |
if (alignf) |
alignf(alignf_data, new, size, align); |
if (new->start < new->end && new->end - new->start + 1 >= size) { |
new->end = new->start + size - 1; |
return 0; |
} |
if (!this) |
break; |
new->start = this->end + 1; |
this = this->sibling; |
} |
return -EBUSY; |
} |
int allocate_resource(struct resource *root, struct resource *new, |
unsigned long size, |
unsigned long min, unsigned long max, |
unsigned long align, |
void (*alignf)(void *, struct resource *, |
unsigned long, unsigned long), |
void *alignf_data) |
{ |
int err; |
err = find_resource(root, new, size, min, max, align, alignf, alignf_data); |
if (err >= 0 && __request_resource(root, new)) |
err = -EBUSY; |
return err; |
} |
void device_initialize(struct device *dev) |
{ |
kobject_init(&dev->kobj); |
INIT_LIST_HEAD(&dev->node); |
INIT_LIST_HEAD(&dev->children); |
INIT_LIST_HEAD(&dev->driver_list); |
INIT_LIST_HEAD(&dev->bus_list); |
} |
int device_add(struct device *dev) |
{ |
struct device * parent; |
int error; |
dev = get_device(dev); |
if (!dev || !strlen(dev->bus_id)) |
return -EINVAL; |
parent = get_device(dev->parent); |
pr_debug("DEV: registering device: ID = '%s'\n", dev->bus_id); |
/* first, register with generic layer. */ |
kobject_set_name(&dev->kobj,dev->bus_id); |
if (parent) |
dev->kobj.parent = &parent->kobj; |
if ((error = kobject_add(&dev->kobj))) |
goto Error; |
if (parent) |
list_add_tail(&dev->node,&parent->children); |
Done: |
put_device(dev); |
return error; |
Error: |
if (parent) |
put_device(parent); |
goto Done; |
} |
void device_del(struct device * dev) |
{ |
struct device * parent = dev->parent; |
if (parent) |
list_del_init(&dev->node); |
kobject_del(&dev->kobj); |
if (parent) |
put_device(parent); |
} |
#define to_drv(obj) container_of(obj,struct device_driver,kobj) |
struct device_driver * get_driver(struct device_driver * drv) |
{ |
return drv ? to_drv(kobject_get(&drv->kobj)) : NULL; |
} |
void put_driver(struct device_driver * drv) |
{ |
kobject_put(&drv->kobj); |
} |
void driver_unregister(struct device_driver * drv) |
{ |
} |
int driver_register(struct device_driver * drv) |
{ |
INIT_LIST_HEAD(&drv->devices); |
return 0; |
} |
#define to_dev(obj) container_of(obj,struct device,kobj) |
struct device * get_device(struct device * dev) |
{ |
return dev ? to_dev(kobject_get(&dev->kobj)) : NULL; |
} |
void put_device(struct device * dev) |
{ |
kobject_put(&dev->kobj); |
} |
int device_register(struct device *dev) |
{ |
return device_add(dev); |
} |
void device_unregister(struct device * dev) |
{ |
pr_debug("DEV: Unregistering device. ID = '%s'\n", dev->bus_id); |
device_del(dev); |
put_device(dev); |
} |
int bus_register(struct bus_type * bus) |
{ |
return 0; |
} |
int remap_page_range(struct vm_area_struct *vma, unsigned long from, unsigned long phys_addr, unsigned long size, pgprot_t prot) |
{ return 0; } |
unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base) |
{ |
unsigned long result = 0,value; |
if (!base) { |
base = 10; |
if (*cp == '0') { |
base = 8; |
cp++; |
if ((*cp == 'x') && isxdigit(cp[1])) { |
cp++; |
base = 16; |
} |
} |
} |
while (isxdigit(*cp) && |
(value = isdigit(*cp) ? *cp-'0' : toupper(*cp)-'A'+10) < base) { |
result = result*base + value; |
cp++; |
} |
if (endp) |
*endp = (char *)cp; |
return result; |
} |
long simple_strtol(const char *cp,char **endp,unsigned int base) |
{ |
if(*cp=='-') |
return -simple_strtoul(cp+1,endp,base); |
return simple_strtoul(cp,endp,base); |
} |
void dump_stack(void) { } |
void panic(const char * fmt, ...) { |
53,8 → 408,6 |
free((void *)(ptr)); |
return 0; |
} |
unsigned long pci_mem_start = 0x10000000; |
/shark/trunk/drivers/linuxc26/kobject.c |
---|
0,0 → 1,622 |
/* |
* kobject.c - library routines for handling generic kernel objects |
* |
* Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org> |
* |
* This file is released under the GPLv2. |
* |
* |
* Please see the file Documentation/kobject.txt for critical information |
* about using the kobject interface. |
*/ |
#undef DEBUG |
#include <ll/stdarg.h> |
#include <linuxcomp.h> |
#include <linux/kobject.h> |
#include <linux/string.h> |
#include <linux/module.h> |
#include <linux/stat.h> |
/** |
* populate_dir - populate directory with attributes. |
* @kobj: object we're working on. |
* |
* Most subsystems have a set of default attributes that |
* are associated with an object that registers with them. |
* This is a helper called during object registration that |
* loops through the default attributes of the subsystem |
* and creates attributes files for them in sysfs. |
* |
*/ |
static int create_dir(struct kobject * kobj) |
{ |
int error = 0; |
if (kobject_name(kobj)) { |
} |
return error; |
} |
static inline struct kobject * to_kobj(struct list_head * entry) |
{ |
return container_of(entry,struct kobject,entry); |
} |
#ifdef CONFIG_HOTPLUG |
static int get_kobj_path_length(struct kset *kset, struct kobject *kobj) |
{ |
int length = 1; |
struct kobject * parent = kobj; |
/* walk up the ancestors until we hit the one pointing to the |
* root. |
* Add 1 to strlen for leading '/' of each level. |
*/ |
do { |
length += strlen(kobject_name(parent)) + 1; |
parent = parent->parent; |
} while (parent); |
return length; |
} |
static void fill_kobj_path(struct kset *kset, struct kobject *kobj, char *path, int length) |
{ |
struct kobject * parent; |
--length; |
for (parent = kobj; parent; parent = parent->parent) { |
int cur = strlen(kobject_name(parent)); |
/* back up enough to print this name with '/' */ |
length -= cur; |
strncpy (path + length, kobject_name(parent), cur); |
*(path + --length) = '/'; |
} |
pr_debug("%s: path = '%s'\n",__FUNCTION__,path); |
} |
#define BUFFER_SIZE 1024 /* should be enough memory for the env */ |
#define NUM_ENVP 32 /* number of env pointers */ |
static unsigned long sequence_num; |
static spinlock_t sequence_lock = SPIN_LOCK_UNLOCKED; |
static void kset_hotplug(const char *action, struct kset *kset, |
struct kobject *kobj) |
{ |
char *argv [3]; |
char **envp = NULL; |
char *buffer = NULL; |
char *scratch; |
int i = 0; |
int retval; |
int kobj_path_length; |
char *kobj_path = NULL; |
char *name = NULL; |
unsigned long seq; |
/* If the kset has a filter operation, call it. If it returns |
failure, no hotplug event is required. */ |
if (kset->hotplug_ops->filter) { |
if (!kset->hotplug_ops->filter(kset, kobj)) |
return; |
} |
pr_debug ("%s\n", __FUNCTION__); |
if (!hotplug_path[0]) |
return; |
envp = kmalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL); |
if (!envp) |
return; |
memset (envp, 0x00, NUM_ENVP * sizeof (char *)); |
buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); |
if (!buffer) |
goto exit; |
if (kset->hotplug_ops->name) |
name = kset->hotplug_ops->name(kset, kobj); |
if (name == NULL) |
name = kset->kobj.name; |
argv [0] = hotplug_path; |
argv [1] = name; |
argv [2] = 0; |
/* minimal command environment */ |
envp [i++] = "HOME=/"; |
envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; |
scratch = buffer; |
envp [i++] = scratch; |
scratch += sprintf(scratch, "ACTION=%s", action) + 1; |
spin_lock(&sequence_lock); |
seq = sequence_num++; |
spin_unlock(&sequence_lock); |
envp [i++] = scratch; |
scratch += sprintf(scratch, "SEQNUM=%ld", seq) + 1; |
kobj_path_length = get_kobj_path_length (kset, kobj); |
kobj_path = kmalloc (kobj_path_length, GFP_KERNEL); |
if (!kobj_path) |
goto exit; |
memset (kobj_path, 0x00, kobj_path_length); |
fill_kobj_path (kset, kobj, kobj_path, kobj_path_length); |
envp [i++] = scratch; |
scratch += sprintf (scratch, "DEVPATH=%s", kobj_path) + 1; |
if (kset->hotplug_ops->hotplug) { |
/* have the kset specific function add its stuff */ |
retval = kset->hotplug_ops->hotplug (kset, kobj, |
&envp[i], NUM_ENVP - i, scratch, |
BUFFER_SIZE - (scratch - buffer)); |
if (retval) { |
pr_debug ("%s - hotplug() returned %d\n", |
__FUNCTION__, retval); |
goto exit; |
} |
} |
pr_debug ("%s: %s %s %s %s %s %s\n", __FUNCTION__, argv[0], argv[1], |
envp[0], envp[1], envp[2], envp[3]); |
retval = call_usermodehelper (argv[0], argv, envp, 0); |
if (retval) |
pr_debug ("%s - call_usermodehelper returned %d\n", |
__FUNCTION__, retval); |
exit: |
kfree(kobj_path); |
kfree(buffer); |
kfree(envp); |
return; |
} |
#else |
static void kset_hotplug(const char *action, struct kset *kset, |
struct kobject *kobj) |
{ |
return; |
} |
#endif /* CONFIG_HOTPLUG */ |
/** |
* kobject_init - initialize object. |
* @kobj: object in question. |
*/ |
void kobject_init(struct kobject * kobj) |
{ |
atomic_set(&kobj->refcount,1); |
INIT_LIST_HEAD(&kobj->entry); |
kobj->kset = kset_get(kobj->kset); |
} |
/** |
* unlink - remove kobject from kset list. |
* @kobj: kobject. |
* |
* Remove the kobject from the kset list and decrement |
* its parent's refcount. |
* This is separated out, so we can use it in both |
* kobject_del() and kobject_add() on error. |
*/ |
static void unlink(struct kobject * kobj) |
{ |
if (kobj->kset) { |
list_del_init(&kobj->entry); |
} |
kobject_put(kobj); |
} |
/** |
* kobject_add - add an object to the hierarchy. |
* @kobj: object. |
*/ |
int kobject_add(struct kobject * kobj) |
{ |
int error = 0; |
struct kobject * parent; |
struct kobject * top_kobj; |
if (!(kobj = kobject_get(kobj))) |
return -ENOENT; |
if (!kobj->k_name) |
kobj->k_name = kobj->name; |
parent = kobject_get(kobj->parent); |
pr_debug("kobject %s: registering. parent: %s, set: %s\n", |
kobject_name(kobj), parent ? kobject_name(parent) : "<NULL>", |
kobj->kset ? kobj->kset->kobj.name : "<NULL>" ); |
if (kobj->kset) { |
if (!parent) |
parent = kobject_get(&kobj->kset->kobj); |
list_add_tail(&kobj->entry,&kobj->kset->list); |
} |
kobj->parent = parent; |
error = create_dir(kobj); |
if (error) { |
unlink(kobj); |
if (parent) |
kobject_put(parent); |
} else { |
/* If this kobj does not belong to a kset, |
try to find a parent that does. */ |
top_kobj = kobj; |
if (!top_kobj->kset && top_kobj->parent) { |
do { |
top_kobj = top_kobj->parent; |
} while (!top_kobj->kset && top_kobj->parent); |
} |
if (top_kobj->kset && top_kobj->kset->hotplug_ops) |
kset_hotplug("add", top_kobj->kset, kobj); |
} |
return error; |
} |
/** |
* kobject_register - initialize and add an object. |
* @kobj: object in question. |
*/ |
int kobject_register(struct kobject * kobj) |
{ |
int error = 0; |
if (kobj) { |
kobject_init(kobj); |
error = kobject_add(kobj); |
if (error) { |
printk("kobject_register failed for %s (%d)\n", |
kobject_name(kobj),error); |
dump_stack(); |
} |
} else |
error = -EINVAL; |
return error; |
} |
/** |
* kobject_set_name - Set the name of an object |
* @kobj: object. |
* @name: name. |
* |
* If strlen(name) < KOBJ_NAME_LEN, then use a dynamically allocated |
* string that @kobj->k_name points to. Otherwise, use the static |
* @kobj->name array. |
*/ |
int kobject_set_name(struct kobject * kobj, const char * fmt, ...) |
{ |
int error = 0; |
int limit = KOBJ_NAME_LEN; |
int need; |
va_list args; |
char * name; |
va_start(args,fmt); |
/* |
* First, try the static array |
*/ |
need = vsnprintf(kobj->name,limit,fmt,args); |
if (need < limit) |
name = kobj->name; |
else { |
/* |
* Need more space? Allocate it and try again |
*/ |
name = kmalloc(need,GFP_KERNEL); |
if (!name) { |
error = -ENOMEM; |
goto Done; |
} |
limit = need; |
need = vsnprintf(name,limit,fmt,args); |
/* Still? Give up. */ |
if (need > limit) { |
kfree(name); |
error = -EFAULT; |
goto Done; |
} |
} |
/* Free the old name, if necessary. */ |
if (kobj->k_name && kobj->k_name != kobj->name) |
kfree(kobj->k_name); |
/* Now, set the new name */ |
kobj->k_name = name; |
Done: |
va_end(args); |
return error; |
} |
EXPORT_SYMBOL(kobject_set_name); |
/** |
* kobject_rename - change the name of an object |
* @kobj: object in question. |
* @new_name: object's new name |
*/ |
void kobject_rename(struct kobject * kobj, char *new_name) |
{ |
kobj = kobject_get(kobj); |
if (!kobj) |
return; |
kobject_put(kobj); |
} |
/** |
* kobject_del - unlink kobject from hierarchy. |
* @kobj: object. |
*/ |
void kobject_del(struct kobject * kobj) |
{ |
struct kobject * top_kobj; |
/* If this kobj does not belong to a kset, |
try to find a parent that does. */ |
top_kobj = kobj; |
if (!top_kobj->kset && top_kobj->parent) { |
do { |
top_kobj = top_kobj->parent; |
} while (!top_kobj->kset && top_kobj->parent); |
} |
if (top_kobj->kset && top_kobj->kset->hotplug_ops) |
kset_hotplug("remove", top_kobj->kset, kobj); |
unlink(kobj); |
} |
/** |
* kobject_unregister - remove object from hierarchy and decrement refcount. |
* @kobj: object going away. |
*/ |
void kobject_unregister(struct kobject * kobj) |
{ |
pr_debug("kobject %s: unregistering\n",kobject_name(kobj)); |
kobject_del(kobj); |
kobject_put(kobj); |
} |
/** |
* kobject_get - increment refcount for object. |
* @kobj: object. |
*/ |
struct kobject * kobject_get(struct kobject * kobj) |
{ |
struct kobject * ret = kobj; |
if (kobj) { |
WARN_ON(!atomic_read(&kobj->refcount)); |
atomic_inc(&kobj->refcount); |
} else |
ret = NULL; |
return ret; |
} |
/** |
* kobject_cleanup - free kobject resources. |
* @kobj: object. |
*/ |
void kobject_cleanup(struct kobject * kobj) |
{ |
struct kobj_type * t = get_ktype(kobj); |
struct kset * s = kobj->kset; |
struct kobject * parent = kobj->parent; |
pr_debug("kobject %s: cleaning up\n",kobject_name(kobj)); |
if (kobj->k_name != kobj->name) |
kfree(kobj->k_name); |
kobj->k_name = NULL; |
if (t && t->release) |
t->release(kobj); |
if (s) |
kset_put(s); |
if (parent) |
kobject_put(parent); |
} |
/** |
* kobject_put - decrement refcount for object. |
* @kobj: object. |
* |
* Decrement the refcount, and if 0, call kobject_cleanup(). |
*/ |
void kobject_put(struct kobject * kobj) |
{ |
if (atomic_dec_and_test(&kobj->refcount)) |
kobject_cleanup(kobj); |
} |
/** |
* kset_init - initialize a kset for use |
* @k: kset |
*/ |
void kset_init(struct kset * k) |
{ |
kobject_init(&k->kobj); |
INIT_LIST_HEAD(&k->list); |
} |
/** |
* kset_add - add a kset object to the hierarchy. |
* @k: kset. |
* |
* Simply, this adds the kset's embedded kobject to the |
* hierarchy. |
* We also try to make sure that the kset's embedded kobject |
* has a parent before it is added. We only care if the embedded |
* kobject is not part of a kset itself, since kobject_add() |
* assigns a parent in that case. |
* If that is the case, and the kset has a controlling subsystem, |
* then we set the kset's parent to be said subsystem. |
*/ |
int kset_add(struct kset * k) |
{ |
if (!k->kobj.parent && !k->kobj.kset && k->subsys) |
k->kobj.parent = &k->subsys->kset.kobj; |
return kobject_add(&k->kobj); |
} |
/** |
* kset_register - initialize and add a kset. |
* @k: kset. |
*/ |
int kset_register(struct kset * k) |
{ |
kset_init(k); |
return kset_add(k); |
} |
/** |
* kset_unregister - remove a kset. |
* @k: kset. |
*/ |
void kset_unregister(struct kset * k) |
{ |
kobject_unregister(&k->kobj); |
} |
/** |
* kset_find_obj - search for object in kset. |
* @kset: kset we're looking in. |
* @name: object's name. |
* |
* Lock kset via @kset->subsys, and iterate over @kset->list, |
* looking for a matching kobject. Return object if found. |
*/ |
struct kobject * kset_find_obj(struct kset * kset, const char * name) |
{ |
struct list_head * entry; |
struct kobject * ret = NULL; |
list_for_each(entry,&kset->list) { |
struct kobject * k = to_kobj(entry); |
if (!strcmp(kobject_name(k),name)) { |
ret = k; |
break; |
} |
} |
return ret; |
} |
void subsystem_init(struct subsystem * s) |
{ |
kset_init(&s->kset); |
} |
/** |
* subsystem_register - register a subsystem. |
* @s: the subsystem we're registering. |
* |
* Once we register the subsystem, we want to make sure that |
* the kset points back to this subsystem for correct usage of |
* the rwsem. |
*/ |
int subsystem_register(struct subsystem * s) |
{ |
int error; |
subsystem_init(s); |
pr_debug("subsystem %s: registering\n",s->kset.kobj.name); |
if (!(error = kset_add(&s->kset))) { |
if (!s->kset.subsys) |
s->kset.subsys = s; |
} |
return error; |
} |
void subsystem_unregister(struct subsystem * s) |
{ |
pr_debug("subsystem %s: unregistering\n",s->kset.kobj.name); |
kset_unregister(&s->kset); |
} |
/** |
* subsystem_create_file - export sysfs attribute file. |
* @s: subsystem. |
* @a: subsystem attribute descriptor. |
*/ |
int subsys_create_file(struct subsystem * s, struct subsys_attribute * a) |
{ |
int error = 0; |
if (subsys_get(s)) { |
subsys_put(s); |
} |
return error; |
} |
/** |
* subsystem_remove_file - remove sysfs attribute file. |
* @s: subsystem. |
* @a: attribute desciptor. |
*/ |
void subsys_remove_file(struct subsystem * s, struct subsys_attribute * a) |
{ |
if (subsys_get(s)) { |
subsys_put(s); |
} |
} |
EXPORT_SYMBOL(kobject_init); |
EXPORT_SYMBOL(kobject_register); |
EXPORT_SYMBOL(kobject_unregister); |
EXPORT_SYMBOL(kobject_get); |
EXPORT_SYMBOL(kobject_put); |
EXPORT_SYMBOL(kset_register); |
EXPORT_SYMBOL(kset_unregister); |
EXPORT_SYMBOL(kset_find_obj); |
EXPORT_SYMBOL(subsystem_init); |
EXPORT_SYMBOL(subsystem_register); |
EXPORT_SYMBOL(subsystem_unregister); |
EXPORT_SYMBOL(subsys_create_file); |
EXPORT_SYMBOL(subsys_remove_file); |
/shark/trunk/drivers/linuxc26/makefile |
---|
10,7 → 10,7 |
OBJS_PATH = $(BASE)/drivers/linuxc26 |
OBJS = linuxcomp.o |
OBJS = linuxcomp.o kobject.o |
C_OPT += -I../linuxc26/include |