void __init empeg_proc_init(void)
{
#ifdef CONFIG_PROC_FS
proc_register(&proc_root, &id_proc_entry);
proc_register(&proc_root, &therm_proc_entry);
#endif
}
void
proc_osfmach3_init(void)
{
proc_register(&proc_osfmach3, &osfmach3_version_dir_entry);
proc_register(&proc_osfmach3, &osfmach3_vm_statistics_dir_entry);
proc_register(&proc_osfmach3, &osfmach3_host_sched_info_dir_entry);
proc_register(&proc_osfmach3, &osfmach3_host_basic_info_dir_entry);
}
__initfunc(int wanrouter_proc_init (void))
{
int err = proc_register(proc_net, &proc_router);
if (!err)
{
proc_register(&proc_router, &proc_router_conf);
proc_register(&proc_router, &proc_router_stat);
}
return err;
}
int init_module(void)
{
struct proc_dir_entry *dir, *dp;
int rc;
printk("installing /proc/net/ftp-proxy interface\n");
/*
** First, verify that /proc/net is available
*/
for (dir = proc_root.subdir; dir; dir = dir->next) {
if (mystrcmp(dir->name, "net") == 0)
break;
}
if (dir == NULL)
return -ENOENT;
/*
** Then, see if the file is already there
*/
for (dp = dir->subdir; dp; dp = dp->next) {
if (mystrcmp(dp->name, "ftp_proxy") == 0)
return 0;
}
/*
** Let's go and install the file
*/
if ((rc = proc_register(dir, &proc_ftp)) == 0)
return 0;
printk(KERN_ALERT "unable to install /proc/net/ftp-proxy\n");
return rc;
}
int
init_module (void)
{
int result;
/* register chrdev */
result = register_chrdev(perf_dev_major,
PERF_DEV_NAME , &perf_dev_fops);
if (result < 0) {
printk(KERN_WARNING
PERF_DEV_SAMPLE_NAME
": can't get major %d\n",perf_dev_major);
return result;
}
if (perf_dev_major == 0) perf_dev_major = result; /* dynamic */
/*
* register /proc entry, if you want.
*/
result=proc_register(&proc_root, &proc_sample);
if (result < 0) {
printk(KERN_WARNING
PERF_DEV_NAME ": can't get proc entry\n");
unregister_chrdev(perf_dev_major, PERF_DEV_NAME);
return result;
}
result=proc_register(&proc_root, &proc_counter);
if (result < 0) {
printk(KERN_WARNING
PERF_DEV_NAME ": can't get proc entry\n");
unregister_chrdev(perf_dev_major, PERF_DEV_NAME);
(void) proc_unregister(&proc_root, proc_sample.low_ino);
return result;
}
return 0;
}
void coda_sysctl_init()
{
memset(&coda_callstats, 0, sizeof(coda_callstats));
reset_coda_vfs_stats();
reset_coda_upcall_stats();
reset_coda_permission_stats();
reset_coda_cache_inv_stats();
#ifdef CONFIG_PROC_FS
proc_register(&proc_root_fs,&proc_fs_coda);
proc_register(&proc_fs_coda,&proc_coda_vfs);
proc_register(&proc_fs_coda,&proc_coda_upcall);
proc_register(&proc_fs_coda,&proc_coda_permission);
proc_register(&proc_fs_coda,&proc_coda_cache_inv);
#endif
#ifdef CONFIG_SYSCTL
if ( !fs_table_header )
fs_table_header = register_sysctl_table(fs_table, 0);
#endif
}
__initfunc(void perf_dev_init(void))
{
int result;
/* register chrdev */
result = register_chrdev (perf_dev_major,
PERF_DEV_NAME,&perf_dev_fops);
if (result < 0) {
printk(KERN_WARNING
PERF_DEV_NAME
": can't get major %d\n",perf_dev_major);
return;
}
if (perf_dev_major == 0) perf_dev_major = result; /* dynamic */
/* register /proc entry */
result=proc_register(&proc_root, &proc_sample);
if (result < 0) {
printk(KERN_WARNING
PERF_DEV_NAME ": can't get proc entry\n");
unregister_chrdev(perf_dev_major, PERF_DEV_NAME);
return;
}
result=proc_register(&proc_root, &proc_counter);
if (result < 0) {
printk(KERN_WARNING
PERF_DEV_COUNTER_NAME ": can't get proc entry\n");
unregister_chrdev(perf_dev_major, PERF_DEV_COUNTER_NAME);
(void) proc_unregister(&proc_root, proc_sample.low_ino);
return;
}
}
/* Inicializa el módulo - registra el fichero proc */
int init_module()
{
/* Tiene éxito si proc_register_dynamic tiene éxito,
* falla en otro caso */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
return proc_register(&proc_root, &Our_Proc_File);
#else
return proc_register_dynamic(&proc_root, &Our_Proc_File);
#endif
/* proc_root es el directorio raiz para el sistema de
* ficheros proc (/proc). Es decir, donde queremos que sea
* localizado nuestro fichero. */
}
int wanrouter_proc_add (wan_device_t* wandev)
{
if (wandev->magic != ROUTER_MAGIC)
return -EINVAL;
memset(&wandev->dent, 0, sizeof(wandev->dent));
wandev->dent.namelen = strlen(wandev->name);
wandev->dent.name = wandev->name;
wandev->dent.mode = 0444 | S_IFREG;
wandev->dent.nlink = 1;
wandev->dent.ops = &wandev_inode;
wandev->dent.get_info = &wandev_get_info;
wandev->dent.data = wandev;
return proc_register(&proc_router, &wandev->dent);
}
/*
* disk pure sync init
*/
static __init void disk_pure_sync_init(void)
{
/* register disk proc interface */
proc_register(&disk_proc);
}
/*
* Process a node, adding entries for its children and its properties.
*/
static void add_node(struct device_node *np, struct proc_dir_entry *de)
{
struct property *pp;
struct proc_dir_entry *ent;
struct device_node *child, *sib;
const char *p, *at;
int l;
struct proc_dir_entry *list, **lastp, *al;
lastp = &list;
for (pp = np->properties; pp != 0; pp = pp->next) {
/*
* Unfortunately proc_register puts each new entry
* at the beginning of the list. So we rearrange them.
*/
ent = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL);
if (ent == 0)
break;
memset(ent, 0, sizeof(struct proc_dir_entry));
ent->name = pp->name;
ent->namelen = strlen(pp->name);
ent->mode = S_IFREG | S_IRUGO;
ent->nlink = 1;
ent->data = pp;
ent->read_proc = property_read_proc;
ent->size = pp->length;
proc_register(de, ent);
*lastp = ent;
lastp = &ent->next;
}
for (child = np->child; child != 0; child = child->sibling) {
p = strrchr(child->full_name, '/');
if (p == 0)
p = child->full_name;
else
++p;
/* chop off '@0' if the name ends with that */
l = strlen(p);
if (l > 2 && p[l-2] == '@' && p[l-1] == '0')
l -= 2;
ent = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL);
if (ent == 0)
break;
memset(ent, 0, sizeof(struct proc_dir_entry));
ent->name = p;
ent->namelen = l;
ent->mode = S_IFDIR | S_IRUGO | S_IXUGO;
ent->nlink = 2;
proc_register(de, ent);
*lastp = ent;
lastp = &ent->next;
add_node(child, ent);
/*
* If we left the address part on the name, consider
* adding symlinks from the name and address parts.
*/
if (p[l] != 0 || (at = strchr(p, '@')) == 0)
continue;
/*
* If this is the first node with a given name property,
* add a symlink with the name property as its name.
*/
for (sib = np->child; sib != child; sib = sib->sibling)
if (strcmp(sib->name, child->name) == 0)
break;
if (sib == child && strncmp(p, child->name, l) != 0) {
al = kmalloc(sizeof(struct proc_dir_entry),
GFP_KERNEL);
if (al == 0)
break;
memset(al, 0, sizeof(struct proc_dir_entry));
al->name = child->name;
al->namelen = strlen(child->name);
al->mode = S_IFLNK | S_IRUGO | S_IXUGO;
al->nlink = 1;
al->data = (void *) ent->name;
al->ops = &devtree_symlink_inode_operations;
proc_register(de, al);
*lastp = al;
lastp = &al->next;
}
/*
* Add another directory with the @address part as its name.
*/
al = kmalloc(sizeof(struct proc_dir_entry), GFP_KERNEL);
if (al == 0)
break;
memset(al, 0, sizeof(struct proc_dir_entry));
al->name = at;
al->namelen = strlen(at);
al->mode = S_IFLNK | S_IRUGO | S_IXUGO;
al->nlink = 1;
al->data = (void *) ent->name;
al->ops = &devtree_symlink_inode_operations;
proc_register(de, al);
*lastp = al;
lastp = &al->next;
}
*lastp = 0;
de->subdir = list;
}
static __init void console_pure_sync_init(void)
{
proc_register(&console_proc);
}
/*
* Work-around some invalid code "optimizations":
* the proc_dir_entries below are stored in a read-only data section...
*/
static int __proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
{
return proc_register(dir, dp);
}
void __init empeg_state_init(void)
{
struct state_dev *dev = state_devices;
unsigned char *buffer = NULL;
extern unsigned char **empeg_state_writebuf;
int result;
/* First grab the memory buffer */
buffer = vmalloc(STATE_BLOCK_SIZE * 2);
if (!buffer) {
printk(KERN_WARNING "Could not allocate memory buffer for empeg state.\n");
return;
}
dev->buffers[0] = buffer;
dev->buffers[1] = buffer + STATE_BLOCK_SIZE;
dev->read_buffer = dev->buffers[0];
dev->write_buffer = dev->buffers[1];
empeg_state_writebuf = &dev->write_buffer;
/* Get the flash product ID to work out if it's a B3 or C3 flash */
state_getflashtype();
/* Fetch the last correct state from flash into buffer */
state_fetch(dev->buffers[0]);
/* Copy the current state to other buffer */
memcpy(dev->buffers[1],dev->buffers[0],STATE_BLOCK_SIZE);
save_current_volume();
/* Ensure the IRQ is disabled at source */
GRER&=~EMPEG_POWERFAIL;
GEDR=EMPEG_POWERFAIL;
#if DEBUG
printk("Powerfail is now %s (%d)\n", (powerfail_disable_count == 0) ? "enabled" : "disabled", powerfail_disable_count);
printk("Powerfail line current level is %d\n", GPLR & EMPEG_POWERFAIL);
#endif
result = request_irq(EMPEG_IRQ_POWERFAIL, powerfail_interrupt, SA_INTERRUPT,
"empeg_state", dev);
if (result) {
printk(KERN_ERR "Can't get empeg powerfail IRQ %d.\n", EMPEG_IRQ_POWERFAIL);
}
result = register_chrdev(EMPEG_STATE_MAJOR, "empeg_state", &state_fops);
if (result < 0) {
printk(KERN_WARNING "empeg state: Major number %d unavailable.\n",
EMPEG_STATE_MAJOR);
return;
}
#ifdef CONFIG_PROC_FS
proc_register(&proc_root, &state_proc_entry);
#endif
/* Initialise the timer for handling timeout of a powerfail. */
init_timer(&dev->powerfail_timer);
dev->powerfail_timer.data = 0;
printk("empeg state support initialised %04x/%04x (save to %p).\n",
flash_manufacturer,flash_product,savebase);
/* Enable powerfail interrupts if the voltage level isn't already too low */
if (GPLR & EMPEG_POWERFAIL) {
/* Pretend we've just received a powerfail interrupt */
powerfail_disable_count = 1;
dev->powerfail_timer.expires = jiffies + POWERFAIL_TIMEOUT * HZ;
dev->powerfail_timer.function = powerfail_disabled_timeout;
add_timer(&dev->powerfail_timer);
} else
powerfail_disable_count = 0;
#if DEBUG
printk("Powerfail is now %s (%d)\n", (powerfail_disable_count == 0) ? "enabled" : "disabled", powerfail_disable_count);
#endif
/* We want interrupts on rising only */
GRER|=EMPEG_POWERFAIL;
register_reboot_notifier(&empeg_state_notifier_block);
}
/*
* resource pure sync init
*/
static __init void resource_pure_sync_init(void)
{
/* register resource proc interface */
proc_register(&resource_proc);
}
void proc_base_init(void)
{
proc_register(&proc_pid, get_endstruct(PROC_PID_STATUS));
proc_register(&proc_pid, get_endstruct(PROC_PID_MEM));
proc_register(&proc_pid, get_endstruct(PROC_PID_CWD));
proc_register(&proc_pid, get_endstruct(PROC_PID_ROOT));
proc_register(&proc_pid, get_endstruct(PROC_PID_EXE));
proc_register(&proc_pid, get_endstruct(PROC_PID_FD));
proc_register(&proc_pid, get_endstruct(PROC_PID_ENVIRON));
proc_register(&proc_pid, get_endstruct(PROC_PID_CMDLINE));
proc_register(&proc_pid, get_endstruct(PROC_PID_STAT));
#ifndef NO_MM
proc_register(&proc_pid, get_endstruct(PROC_PID_STATM));
proc_register(&proc_pid, get_endstruct(PROC_PID_MAPS));
#endif /* !NO_MM */
};
/*
* device pure sync init
*/
static __init void device_pure_sync_init(void)
{
/* register device proc interface */
proc_register(&device_proc);
}
static int __init mwave_init(void)
{
int i;
int retval = 0;
int resultMiscRegister;
pMWAVE_DEVICE_DATA pDrvData = &mwave_s_mdd;
memset(&mwave_s_mdd, 0, sizeof(MWAVE_DEVICE_DATA));
PRINTK_1(TRACE_MWAVE, "mwavedd::mwave_init entry\n");
pDrvData->bBDInitialized = FALSE;
pDrvData->bResourcesClaimed = FALSE;
pDrvData->bDSPEnabled = FALSE;
pDrvData->bDSPReset = FALSE;
pDrvData->bMwaveDevRegistered = FALSE;
pDrvData->sLine = -1;
pDrvData->bProcEntryCreated = FALSE;
for (i = 0; i < 16; i++) {
pDrvData->IPCs[i].bIsEnabled = FALSE;
pDrvData->IPCs[i].bIsHere = FALSE;
pDrvData->IPCs[i].usIntCount = 0; /* no ints received yet */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
init_waitqueue_head(&pDrvData->IPCs[i].ipc_wait_queue);
#endif
}
retval = tp3780I_InitializeBoardData(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_InitializeBoardData retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to initialize board data\n");
goto cleanup_error;
}
pDrvData->bBDInitialized = TRUE;
retval = tp3780I_CalcResources(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_CalcResources retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to calculate resources\n");
goto cleanup_error;
}
retval = tp3780I_ClaimResources(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_ClaimResources retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to claim resources\n");
goto cleanup_error;
}
pDrvData->bResourcesClaimed = TRUE;
retval = tp3780I_EnableDSP(&pDrvData->rBDData);
PRINTK_2(TRACE_MWAVE,
"mwavedd::mwave_init, return from tp3780I_EnableDSP retval %x\n",
retval);
if (retval) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to enable DSP\n");
goto cleanup_error;
}
pDrvData->bDSPEnabled = TRUE;
resultMiscRegister = misc_register(&mwave_misc_dev);
if (resultMiscRegister < 0) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to register misc device\n");
goto cleanup_error;
}
pDrvData->bMwaveDevRegistered = TRUE;
pDrvData->sLine = register_serial_portandirq(
pDrvData->rBDData.rDspSettings.usUartBaseIO,
pDrvData->rBDData.rDspSettings.usUartIrq
);
if (pDrvData->sLine < 0) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd:mwave_init: Error: Failed to register serial driver\n");
goto cleanup_error;
}
/* uart is registered */
if (
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
!create_proc_info_entry("mwave", 0, NULL, mwave_get_info)
#else
proc_register(&proc_root, &mwave_proc)
#endif
) {
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to register /proc/mwave\n");
goto cleanup_error;
}
pDrvData->bProcEntryCreated = TRUE;
/* SUCCESS! */
return 0;
cleanup_error:
PRINTK_ERROR(KERN_ERR_MWAVE "mwavedd::mwave_init: Error: Failed to initialize\n");
mwave_exit(); /* clean up */
return -EIO;
}
int init_module(void)
{
proc_register(&proc_root, &SysProcFile);
return 0;
}
/*
* mmc card pure sync init
*/
static __init void mmc_card_pure_sync_init(void)
{
/* register mmc card proc interface */
proc_register(&mmc_card_proc);
}
/*
* filesystem pure sync init
*/
static __init void filesystem_pure_sync_init(void)
{
/* register filesystem proc interface */
proc_register(&filesystem_proc);
}
