Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 436 → Rev 437

/shark/trunk/drivers/newpci/pci-sysfs.c
File deleted
/shark/trunk/drivers/newpci/common.c
139,7 → 139,6
 
static int __init pcibios_init(void)
{
struct cpuinfo_x86 *c = &boot_cpu_data;
 
if (!raw_pci_ops) {
printk("PCI: System does not support PCI\n");
152,10 → 151,6
* as quite a few PCI devices do not support smaller values.
*/
pci_cache_line_size = 32 >> 2;
if (c->x86 >= 6 && c->x86_vendor == X86_VENDOR_AMD)
pci_cache_line_size = 64 >> 2; /* K7 & K8 */
else if (c->x86 > 6 && c->x86_vendor == X86_VENDOR_INTEL)
pci_cache_line_size = 128 >> 2; /* P4 */
 
pcibios_resource_survey();
 
/shark/trunk/drivers/newpci/i386.c
286,8 → 286,7
vma->vm_flags |= (VM_SHM | VM_LOCKED | VM_IO);
 
prot = pgprot_val(vma->vm_page_prot);
if (boot_cpu_data.x86 > 3)
prot |= _PAGE_PCD | _PAGE_PWT;
prot |= _PAGE_PCD | _PAGE_PWT;
vma->vm_page_prot = __pgprot(prot);
 
/* Write-combine setting is ignored, it is changed via the mtrr
/shark/trunk/drivers/newpci/bus.c
101,7 → 101,6
spin_unlock(&pci_bus_lock);
 
pci_proc_attach_device(dev);
pci_create_sysfs_dev_files(dev);
 
}
 
/shark/trunk/drivers/newpci/makefile
10,7 → 10,7
 
OBJS_PATH = $(BASE)/drivers/newpci
 
OBJS = access.o bus.o names.o pci.o pci-driver.o pci-sysfs.o\
OBJS = access.o bus.o names.o pci.o pci-driver.o\
pool.o probe.o quirks.o remove.o search.o setup-res.o\
setup-irq.o setup-bus.o syscall.o i386.o common.o\
fixup.o irq.o legacy.o
/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