hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[OPENPROM]: Rewrite driver to use in-kernel device tree. 

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2006-06-25 23:19:30 -07:00
parent 3d824a46b7
commit 8e48aec714
1 changed files with 357 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

635
drivers/sbus/char/openprom.c
View File

@ -29,8 +29,6 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#define PROMLIB_INTERNAL
#include <linux/config.h> #include <linux/config.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/kernel.h> #include <linux/kernel.h>
@ -39,10 +37,10 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#include <linux/smp_lock.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <asm/oplib.h> #include <asm/oplib.h>
#include <asm/prom.h>
#include <asm/system.h> #include <asm/system.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/openpromio.h> #include <asm/openpromio.h>
@ -51,15 +49,20 @@
#include <asm/pbm.h> #include <asm/pbm.h>
#endif #endif
MODULE_AUTHOR("Thomas K. Dyas (tdyas@noc.rutgers.edu) and Eddie C. Dost (ecd@skynet.be)");
MODULE_DESCRIPTION("OPENPROM Configuration Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0");
/* Private data kept by the driver for each descriptor. */ /* Private data kept by the driver for each descriptor. */
typedef struct openprom_private_data typedef struct openprom_private_data
{ {
int current_node; /* Current node for SunOS ioctls. */ struct device_node *current_node; /* Current node for SunOS ioctls. */
int lastnode; /* Last valid node used by BSD ioctls. */ struct device_node *lastnode; /* Last valid node used by BSD ioctls. */
} DATA; } DATA;
/* ID of the PROM node containing all of the EEPROM options. */ /* ID of the PROM node containing all of the EEPROM options. */
static int options_node = 0; static struct device_node *options_node;
/* /*
* Copy an openpromio structure into kernel space from user space. * Copy an openpromio structure into kernel space from user space.
@ -87,9 +90,8 @@ static int copyin(struct openpromio __user *info, struct openpromio **opp_p)
if (bufsize > OPROMMAXPARAM) if (bufsize > OPROMMAXPARAM)
bufsize = OPROMMAXPARAM; bufsize = OPROMMAXPARAM;
if (!(*opp_p = kmalloc(sizeof(int) + bufsize + 1, GFP_KERNEL))) if (!(*opp_p = kzalloc(sizeof(int) + bufsize + 1, GFP_KERNEL)))
return -ENOMEM; return -ENOMEM;
memset(*opp_p, 0, sizeof(int) + bufsize + 1);
if (copy_from_user(&(*opp_p)->oprom_array, if (copy_from_user(&(*opp_p)->oprom_array,
&info->oprom_array, bufsize)) { &info->oprom_array, bufsize)) {
@ -107,10 +109,9 @@ static int getstrings(struct openpromio __user *info, struct openpromio **opp_p)
if (!info || !opp_p) if (!info || !opp_p)
return -EFAULT; return -EFAULT;
if (!(*opp_p = kmalloc(sizeof(int) + OPROMMAXPARAM + 1, GFP_KERNEL))) if (!(*opp_p = kzalloc(sizeof(int) + OPROMMAXPARAM + 1, GFP_KERNEL)))
return -ENOMEM; return -ENOMEM;
memset(*opp_p, 0, sizeof(int) + OPROMMAXPARAM + 1);
(*opp_p)->oprom_size = 0; (*opp_p)->oprom_size = 0;
n = bufsize = 0; n = bufsize = 0;
@ -140,16 +141,164 @@ static int copyout(void __user *info, struct openpromio *opp, int len)
return 0; return 0;
} }
static int opromgetprop(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize)
{
void *pval;
int len;
pval = of_get_property(dp, op->oprom_array, &len);
if (!pval || len <= 0 || len > bufsize)
return copyout(argp, op, sizeof(int));
memcpy(op->oprom_array, pval, len);
op->oprom_array[len] = '\0';
op->oprom_size = len;
return copyout(argp, op, sizeof(int) + bufsize);
}
static int opromnxtprop(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize)
{
struct property *prop;
int len;
if (op->oprom_array[0] == '\0') {
prop = dp->properties;
if (!prop)
return copyout(argp, op, sizeof(int));
len = strlen(prop->name);
} else {
prop = of_find_property(dp, op->oprom_array, NULL);
if (!prop ||
!prop->next ||
(len = strlen(prop->next->name)) + 1 > bufsize)
return copyout(argp, op, sizeof(int));
prop = prop->next;
}
memcpy(op->oprom_array, prop->name, len);
op->oprom_array[len] = '\0';
op->oprom_size = ++len;
return copyout(argp, op, sizeof(int) + bufsize);
}
static int opromsetopt(struct device_node *dp, struct openpromio *op, int bufsize)
{
char *buf = op->oprom_array + strlen(op->oprom_array) + 1;
int len = op->oprom_array + bufsize - buf;
return of_set_property(options_node, op->oprom_array, buf, len);
}
static int opromnext(void __user *argp, unsigned int cmd, struct device_node *dp, struct openpromio *op, int bufsize, DATA *data)
{
phandle ph;
BUILD_BUG_ON(sizeof(phandle) != sizeof(int));
if (bufsize < sizeof(phandle))
return -EINVAL;
ph = *((int *) op->oprom_array);
if (ph) {
dp = of_find_node_by_phandle(ph);
if (!dp)
return -EINVAL;
switch (cmd) {
case OPROMNEXT:
dp = dp->sibling;
break;
case OPROMCHILD:
dp = dp->child;
break;
case OPROMSETCUR:
default:
break;
};
} else {
/* Sibling of node zero is the root node. */
if (cmd != OPROMNEXT)
return -EINVAL;
dp = of_find_node_by_path("/");
}
ph = 0;
if (dp)
ph = dp->node;
data->current_node = dp;
*((int *) op->oprom_array) = ph;
op->oprom_size = sizeof(phandle);
return copyout(argp, op, bufsize + sizeof(int));
}
static int oprompci2node(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize, DATA *data)
{
int err = -EINVAL;
if (bufsize >= 2*sizeof(int)) {
#ifdef CONFIG_PCI
struct pci_dev *pdev;
struct pcidev_cookie *pcp;
pdev = pci_find_slot (((int *) op->oprom_array)[0],
((int *) op->oprom_array)[1]);
pcp = pdev->sysdata;
if (pcp != NULL) {
dp = pcp->prom_node;
data->current_node = dp;
*((int *)op->oprom_array) = dp->node;
op->oprom_size = sizeof(int);
err = copyout(argp, op, bufsize + sizeof(int));
}
#endif
}
return err;
}
static int oprompath2node(void __user *argp, struct device_node *dp, struct openpromio *op, int bufsize, DATA *data)
{
dp = of_find_node_by_path(op->oprom_array);
data->current_node = dp;
*((int *)op->oprom_array) = dp->node;
op->oprom_size = sizeof(int);
return copyout(argp, op, bufsize + sizeof(int));
}
static int opromgetbootargs(void __user *argp, struct openpromio *op, int bufsize)
{
char *buf = saved_command_line;
int len = strlen(buf);
if (len > bufsize)
return -EINVAL;
strcpy(op->oprom_array, buf);
op->oprom_size = len;
return copyout(argp, op, bufsize + sizeof(int));
}
/* /*
* SunOS and Solaris /dev/openprom ioctl calls. * SunOS and Solaris /dev/openprom ioctl calls.
*/ */
static int openprom_sunos_ioctl(struct inode * inode, struct file * file, static int openprom_sunos_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg, int node) unsigned int cmd, unsigned long arg,
struct device_node *dp)
{ {
DATA *data = (DATA *) file->private_data; DATA *data = file->private_data;
char buffer[OPROMMAXPARAM+1], *buf;
struct openpromio *opp; struct openpromio *opp;
int bufsize, len, error = 0; int bufsize, error = 0;
static int cnt; static int cnt;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
@ -164,119 +313,35 @@ static int openprom_sunos_ioctl(struct inode * inode, struct file * file,
switch (cmd) { switch (cmd) {
case OPROMGETOPT: case OPROMGETOPT:
case OPROMGETPROP: case OPROMGETPROP:
len = prom_getproplen(node, opp->oprom_array); error = opromgetprop(argp, dp, opp, bufsize);
if (len <= 0 || len > bufsize) {
error = copyout(argp, opp, sizeof(int));
break;
}
len = prom_getproperty(node, opp->oprom_array, buffer, bufsize);
memcpy(opp->oprom_array, buffer, len);
opp->oprom_array[len] = '\0';
opp->oprom_size = len;
error = copyout(argp, opp, sizeof(int) + bufsize);
break; break;
case OPROMNXTOPT: case OPROMNXTOPT:
case OPROMNXTPROP: case OPROMNXTPROP:
buf = prom_nextprop(node, opp->oprom_array, buffer); error = opromnxtprop(argp, dp, opp, bufsize);
len = strlen(buf);
if (len == 0 || len + 1 > bufsize) {
error = copyout(argp, opp, sizeof(int));
break;
}
memcpy(opp->oprom_array, buf, len);
opp->oprom_array[len] = '\0';
opp->oprom_size = ++len;
error = copyout(argp, opp, sizeof(int) + bufsize);
break; break;
case OPROMSETOPT: case OPROMSETOPT:
case OPROMSETOPT2: case OPROMSETOPT2:
buf = opp->oprom_array + strlen(opp->oprom_array) + 1; error = opromsetopt(dp, opp, bufsize);
len = opp->oprom_array + bufsize - buf;
error = prom_setprop(options_node, opp->oprom_array,
buf, len);
if (error < 0)
error = -EINVAL;
break; break;
case OPROMNEXT: case OPROMNEXT:
case OPROMCHILD: case OPROMCHILD:
case OPROMSETCUR: case OPROMSETCUR:
if (bufsize < sizeof(int)) { error = opromnext(argp, cmd, dp, opp, bufsize, data);
error = -EINVAL;
break;
}
node = *((int *) opp->oprom_array);
switch (cmd) {
case OPROMNEXT: node = __prom_getsibling(node); break;
case OPROMCHILD: node = __prom_getchild(node); break;
case OPROMSETCUR: break;
}
data->current_node = node;
*((int *)opp->oprom_array) = node;
opp->oprom_size = sizeof(int);
error = copyout(argp, opp, bufsize + sizeof(int));
break; break;
case OPROMPCI2NODE: case OPROMPCI2NODE:
error = -EINVAL; error = oprompci2node(argp, dp, opp, bufsize, data);
if (bufsize >= 2*sizeof(int)) {
#ifdef CONFIG_PCI
struct pci_dev *pdev;
struct pcidev_cookie *pcp;
pdev = pci_find_slot (((int *) opp->oprom_array)[0],
((int *) opp->oprom_array)[1]);
pcp = pdev->sysdata;
if (pcp != NULL) {
node = pcp->prom_node->node;
data->current_node = node;
*((int *)opp->oprom_array) = node;
opp->oprom_size = sizeof(int);
error = copyout(argp, opp, bufsize + sizeof(int));
}
#endif
}
break; break;
case OPROMPATH2NODE: case OPROMPATH2NODE:
node = prom_finddevice(opp->oprom_array); error = oprompath2node(argp, dp, opp, bufsize, data);
data->current_node = node;
*((int *)opp->oprom_array) = node;
opp->oprom_size = sizeof(int);
error = copyout(argp, opp, bufsize + sizeof(int));
break; break;
case OPROMGETBOOTARGS: case OPROMGETBOOTARGS:
buf = saved_command_line; error = opromgetbootargs(argp, opp, bufsize);
len = strlen(buf);
if (len > bufsize) {
error = -EINVAL;
break;
}
strcpy(opp->oprom_array, buf);
opp->oprom_size = len;
error = copyout(argp, opp, bufsize + sizeof(int));
break; break;
case OPROMU2P: case OPROMU2P:
@ -297,25 +362,14 @@ static int openprom_sunos_ioctl(struct inode * inode, struct file * file,
return error; return error;
} }
static struct device_node *get_node(phandle n, DATA *data)
/* Return nonzero if a specific node is in the PROM device tree. */
static int intree(int root, int node)
{ {
for (; root != 0; root = prom_getsibling(root)) struct device_node *dp = of_find_node_by_phandle(n);
if (root == node || intree(prom_getchild(root),node))
return 1;
return 0;
}
/* Return nonzero if a specific node is "valid". */ if (dp)
static int goodnode(int n, DATA *data) data->lastnode = dp;
{
if (n == data->lastnode || n == prom_root_node || n == options_node) return dp;
return 1;
if (n == 0 || n == -1 || !intree(prom_root_node,n))
return 0;
data->lastnode = n;
return 1;
} }
/* Copy in a whole string from userspace into kernelspace. */ /* Copy in a whole string from userspace into kernelspace. */
@ -330,7 +384,7 @@ static int copyin_string(char __user *user, size_t len, char **ptr)
if (!tmp) if (!tmp)
return -ENOMEM; return -ENOMEM;
if(copy_from_user(tmp, user, len)) { if (copy_from_user(tmp, user, len)) {
kfree(tmp); kfree(tmp);
return -EFAULT; return -EFAULT;
} }
@ -345,162 +399,187 @@ static int copyin_string(char __user *user, size_t len, char **ptr)
/* /*
* NetBSD /dev/openprom ioctl calls. * NetBSD /dev/openprom ioctl calls.
*/ */
static int opiocget(void __user *argp, DATA *data)
{
struct opiocdesc op;
struct device_node *dp;
char *str;
void *pval;
int err, len;
if (copy_from_user(&op, argp, sizeof(op)))
return -EFAULT;
dp = get_node(op.op_nodeid, data);
err = copyin_string(op.op_name, op.op_namelen, &str);
if (err)
return err;
pval = of_get_property(dp, str, &len);
err = 0;
if (!pval || len > op.op_buflen) {
err = -EINVAL;
} else {
op.op_buflen = len;
if (copy_to_user(argp, &op, sizeof(op)) ||
copy_to_user(op.op_buf, pval, len))
err = -EFAULT;
}
kfree(str);
return err;
}
static int opiocnextprop(void __user *argp, DATA *data)
{
struct opiocdesc op;
struct device_node *dp;
struct property *prop;
char *str;
int err, len;
if (copy_from_user(&op, argp, sizeof(op)))
return -EFAULT;
dp = get_node(op.op_nodeid, data);
if (!dp)
return -EINVAL;
err = copyin_string(op.op_name, op.op_namelen, &str);
if (err)
return err;
if (str[0] == '\0') {
prop = dp->properties;
} else {
prop = of_find_property(dp, str, NULL);
if (prop)
prop = prop->next;
}
kfree(str);
if (!prop)
len = 0;
else
len = prop->length;
if (len > op.op_buflen)
len = op.op_buflen;
if (copy_to_user(argp, &op, sizeof(op)))
return -EFAULT;
if (len &&
copy_to_user(op.op_buf, prop->value, len))
return -EFAULT;
return 0;
}
static int opiocset(void __user *argp, DATA *data)
{
struct opiocdesc op;
struct device_node *dp;
char *str, *tmp;
int err;
if (copy_from_user(&op, argp, sizeof(op)))
return -EFAULT;
dp = get_node(op.op_nodeid, data);
if (!dp)
return -EINVAL;
err = copyin_string(op.op_name, op.op_namelen, &str);
if (err)
return err;
err = copyin_string(op.op_buf, op.op_buflen, &tmp);
if (err) {
kfree(str);
return err;
}
err = of_set_property(dp, str, tmp, op.op_buflen);
kfree(str);
kfree(tmp);
return err;
}
static int opiocgetnext(unsigned int cmd, void __user *argp)
{
struct device_node *dp;
phandle nd;
BUILD_BUG_ON(sizeof(phandle) != sizeof(int));
if (copy_from_user(&nd, argp, sizeof(phandle)))
return -EFAULT;
if (nd == 0) {
if (cmd != OPIOCGETNEXT)
return -EINVAL;
dp = of_find_node_by_path("/");
} else {
dp = of_find_node_by_phandle(nd);
nd = 0;
if (dp) {
if (cmd == OPIOCGETNEXT)
dp = dp->sibling;
else
dp = dp->child;
}
}
if (dp)
nd = dp->node;
if (copy_to_user(argp, &nd, sizeof(phandle)))
return -EFAULT;
return 0;
}
static int openprom_bsd_ioctl(struct inode * inode, struct file * file, static int openprom_bsd_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
DATA *data = (DATA *) file->private_data; DATA *data = (DATA *) file->private_data;
void __user *argp = (void __user *)arg; void __user *argp = (void __user *)arg;
struct opiocdesc op; int err;
int error, node, len;
char *str, *tmp;
char buffer[64];
static int cnt;
switch (cmd) { switch (cmd) {
case OPIOCGET: case OPIOCGET:
if (copy_from_user(&op, argp, sizeof(op))) err = opiocget(argp, data);
return -EFAULT; break;
if (!goodnode(op.op_nodeid,data))
return -EINVAL;
error = copyin_string(op.op_name, op.op_namelen, &str);
if (error)
return error;
len = prom_getproplen(op.op_nodeid,str);
if (len > op.op_buflen) {
kfree(str);
return -ENOMEM;
}
op.op_buflen = len;
if (len <= 0) {
kfree(str);
/* Verified by the above copy_from_user */
if (__copy_to_user(argp, &op,
sizeof(op)))
return -EFAULT;
return 0;
}
tmp = kmalloc(len + 1, GFP_KERNEL);
if (!tmp) {
kfree(str);
return -ENOMEM;
}
cnt = prom_getproperty(op.op_nodeid, str, tmp, len);
if (cnt <= 0) {
error = -EINVAL;
} else {
tmp[len] = '\0';
if (__copy_to_user(argp, &op, sizeof(op)) != 0 ||
copy_to_user(op.op_buf, tmp, len) != 0)
error = -EFAULT;
}
kfree(tmp);
kfree(str);
return error;
case OPIOCNEXTPROP: case OPIOCNEXTPROP:
if (copy_from_user(&op, argp, sizeof(op))) err = opiocnextprop(argp, data);
return -EFAULT; break;
if (!goodnode(op.op_nodeid,data))
return -EINVAL;
error = copyin_string(op.op_name, op.op_namelen, &str);
if (error)
return error;
tmp = prom_nextprop(op.op_nodeid,str,buffer);
if (tmp) {
len = strlen(tmp);
if (len > op.op_buflen)
len = op.op_buflen;
else
op.op_buflen = len;
} else {
len = op.op_buflen = 0;
}
if (!access_ok(VERIFY_WRITE, argp, sizeof(op))) {
kfree(str);
return -EFAULT;
}
if (!access_ok(VERIFY_WRITE, op.op_buf, len)) {
kfree(str);
return -EFAULT;
}
error = __copy_to_user(argp, &op, sizeof(op));
if (!error) error = __copy_to_user(op.op_buf, tmp, len);
kfree(str);
return error;
case OPIOCSET: case OPIOCSET:
if (copy_from_user(&op, argp, sizeof(op))) err = opiocset(argp, data);
return -EFAULT; break;
if (!goodnode(op.op_nodeid,data))
return -EINVAL;
error = copyin_string(op.op_name, op.op_namelen, &str);
if (error)
return error;
error = copyin_string(op.op_buf, op.op_buflen, &tmp);
if (error) {
kfree(str);
return error;
}
len = prom_setprop(op.op_nodeid,str,tmp,op.op_buflen+1);
if (len != op.op_buflen)
return -EINVAL;
kfree(str);
kfree(tmp);
return 0;
case OPIOCGETOPTNODE: case OPIOCGETOPTNODE:
if (copy_to_user(argp, &options_node, sizeof(int))) BUILD_BUG_ON(sizeof(phandle) != sizeof(int));
if (copy_to_user(argp, &options_node->node, sizeof(phandle)))
return -EFAULT; return -EFAULT;
return 0; return 0;
case OPIOCGETNEXT: case OPIOCGETNEXT:
case OPIOCGETCHILD: case OPIOCGETCHILD:
if (copy_from_user(&node, argp, sizeof(int))) err = opiocgetnext(cmd, argp);
return -EFAULT; break;
if (cmd == OPIOCGETNEXT)
node = __prom_getsibling(node);
else
node = __prom_getchild(node);
if (__copy_to_user(argp, &node, sizeof(int)))
return -EFAULT;
return 0;
default: default:
if (cnt++ < 10)
printk(KERN_INFO "openprom_bsd_ioctl: cmd 0x%X\n", cmd);
return -EINVAL; return -EINVAL;
} };
return err;
} }
@ -511,7 +590,6 @@ static int openprom_ioctl(struct inode * inode, struct file * file,
unsigned int cmd, unsigned long arg) unsigned int cmd, unsigned long arg)
{ {
DATA *data = (DATA *) file->private_data; DATA *data = (DATA *) file->private_data;
static int cnt;
switch (cmd) { switch (cmd) {
case OPROMGETOPT: case OPROMGETOPT:
@ -563,10 +641,8 @@ static int openprom_ioctl(struct inode * inode, struct file * file,
return openprom_bsd_ioctl(inode,file,cmd,arg); return openprom_bsd_ioctl(inode,file,cmd,arg);
default: default:
if (cnt++ < 10)
printk("openprom_ioctl: cmd 0x%X, arg 0x%lX\n", cmd, arg);
return -EINVAL; return -EINVAL;
} };
} }
static long openprom_compat_ioctl(struct file *file, unsigned int cmd, static long openprom_compat_ioctl(struct file *file, unsigned int cmd,
@ -594,9 +670,7 @@ static long openprom_compat_ioctl(struct file *file, unsigned int cmd,
case OPROMSETCUR: case OPROMSETCUR:
case OPROMPCI2NODE: case OPROMPCI2NODE:
case OPROMPATH2NODE: case OPROMPATH2NODE:
lock_kernel();
rval = openprom_ioctl(file->f_dentry->d_inode, file, cmd, arg); rval = openprom_ioctl(file->f_dentry->d_inode, file, cmd, arg);
lock_kernel();
break; break;
} }
@ -607,13 +681,13 @@ static int openprom_open(struct inode * inode, struct file * file)
{ {
DATA *data; DATA *data;
data = (DATA *) kmalloc(sizeof(DATA), GFP_KERNEL); data = kmalloc(sizeof(DATA), GFP_KERNEL);
if (!data) if (!data)
return -ENOMEM; return -ENOMEM;
data->current_node = prom_root_node; data->current_node = of_find_node_by_path("/");
data->lastnode = prom_root_node; data->lastnode = data->current_node;
file->private_data = (void *)data; file->private_data = (void *) data;
return 0; return 0;
} }
@ -634,24 +708,30 @@ static struct file_operations openprom_fops = {
}; };
static struct miscdevice openprom_dev = { static struct miscdevice openprom_dev = {
SUN_OPENPROM_MINOR, "openprom", &openprom_fops .minor = SUN_OPENPROM_MINOR,
.name = "openprom",
.fops = &openprom_fops,
}; };
static int __init openprom_init(void) static int __init openprom_init(void)
{ {
int error; struct device_node *dp;
int err;
error = misc_register(&openprom_dev); err = misc_register(&openprom_dev);
if (error) { if (err)
printk(KERN_ERR "openprom: unable to get misc minor\n"); return err;
return error;
dp = of_find_node_by_path("/");
dp = dp->child;
while (dp) {
if (!strcmp(dp->name, "options"))
break;
dp = dp->sibling;
} }
options_node = dp;
options_node = prom_getchild(prom_root_node); if (!options_node) {
options_node = prom_searchsiblings(options_node,"options");
if (options_node == 0 || options_node == -1) {
printk(KERN_ERR "openprom: unable to find options node\n");
misc_deregister(&openprom_dev); misc_deregister(&openprom_dev);
return -EIO; return -EIO;
} }
@ -666,4 +746,3 @@ static void __exit openprom_cleanup(void)
module_init(openprom_init); module_init(openprom_init);
module_exit(openprom_cleanup); module_exit(openprom_cleanup);
MODULE_LICENSE("GPL");