2 * Linux/SPARC PROM Configuration Driver
3 * Copyright (C) 1996 Thomas K. Dyas (tdyas@noc.rutgers.edu)
4 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
6 * This character device driver allows user programs to access the
7 * PROM device tree. It is compatible with the SunOS /dev/openprom
8 * driver and the NetBSD /dev/openprom driver. The SunOS eeprom
9 * utility works without any modifications.
11 * The driver uses a minor number under the misc device major. The
12 * file read/write mode determines the type of access to the PROM.
13 * Interrupts are disabled whenever the driver calls into the PROM for
17 /* This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License as
19 * published by the Free Software Foundation; either version 2 of the
20 * License, or (at your option) any later version.
22 * This program is distributed in the hope that it will be useful, but
23 * WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 * General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/errno.h>
36 #include <linux/slab.h>
37 #include <linux/string.h>
38 #include <linux/miscdevice.h>
39 #include <linux/init.h>
41 #include <asm/oplib.h>
43 #include <asm/system.h>
44 #include <asm/uaccess.h>
45 #include <asm/openpromio.h>
47 #include <linux/pci.h>
51 MODULE_AUTHOR("Thomas K. Dyas (tdyas@noc.rutgers.edu) and Eddie C. Dost (ecd@skynet.be)");
52 MODULE_DESCRIPTION("OPENPROM Configuration Driver");
53 MODULE_LICENSE("GPL");
54 MODULE_VERSION("1.0");
56 /* Private data kept by the driver for each descriptor. */
57 typedef struct openprom_private_data
59 struct device_node
*current_node
; /* Current node for SunOS ioctls. */
60 struct device_node
*lastnode
; /* Last valid node used by BSD ioctls. */
63 /* ID of the PROM node containing all of the EEPROM options. */
64 static struct device_node
*options_node
;
67 * Copy an openpromio structure into kernel space from user space.
68 * This routine does error checking to make sure that all memory
69 * accesses are within bounds. A pointer to the allocated openpromio
70 * structure will be placed in "*opp_p". Return value is the length
71 * of the user supplied buffer.
73 static int copyin(struct openpromio __user
*info
, struct openpromio
**opp_p
)
80 if (get_user(bufsize
, &info
->oprom_size
))
86 /* If the bufsize is too large, just limit it.
87 * Fix from Jason Rappleye.
89 if (bufsize
> OPROMMAXPARAM
)
90 bufsize
= OPROMMAXPARAM
;
92 if (!(*opp_p
= kzalloc(sizeof(int) + bufsize
+ 1, GFP_KERNEL
)))
95 if (copy_from_user(&(*opp_p
)->oprom_array
,
96 &info
->oprom_array
, bufsize
)) {
103 static int getstrings(struct openpromio __user
*info
, struct openpromio
**opp_p
)
111 if (!(*opp_p
= kzalloc(sizeof(int) + OPROMMAXPARAM
+ 1, GFP_KERNEL
)))
114 (*opp_p
)->oprom_size
= 0;
117 while ((n
< 2) && (bufsize
< OPROMMAXPARAM
)) {
118 if (get_user(c
, &info
->oprom_array
[bufsize
])) {
124 (*opp_p
)->oprom_array
[bufsize
++] = c
;
134 * Copy an openpromio structure in kernel space back to user space.
136 static int copyout(void __user
*info
, struct openpromio
*opp
, int len
)
138 if (copy_to_user(info
, opp
, len
))
143 static int opromgetprop(void __user
*argp
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
)
148 pval
= of_get_property(dp
, op
->oprom_array
, &len
);
149 if (!pval
|| len
<= 0 || len
> bufsize
)
150 return copyout(argp
, op
, sizeof(int));
152 memcpy(op
->oprom_array
, pval
, len
);
153 op
->oprom_array
[len
] = '\0';
154 op
->oprom_size
= len
;
156 return copyout(argp
, op
, sizeof(int) + bufsize
);
159 static int opromnxtprop(void __user
*argp
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
)
161 struct property
*prop
;
164 if (op
->oprom_array
[0] == '\0') {
165 prop
= dp
->properties
;
167 return copyout(argp
, op
, sizeof(int));
168 len
= strlen(prop
->name
);
170 prop
= of_find_property(dp
, op
->oprom_array
, NULL
);
174 (len
= strlen(prop
->next
->name
)) + 1 > bufsize
)
175 return copyout(argp
, op
, sizeof(int));
180 memcpy(op
->oprom_array
, prop
->name
, len
);
181 op
->oprom_array
[len
] = '\0';
182 op
->oprom_size
= ++len
;
184 return copyout(argp
, op
, sizeof(int) + bufsize
);
187 static int opromsetopt(struct device_node
*dp
, struct openpromio
*op
, int bufsize
)
189 char *buf
= op
->oprom_array
+ strlen(op
->oprom_array
) + 1;
190 int len
= op
->oprom_array
+ bufsize
- buf
;
192 return of_set_property(options_node
, op
->oprom_array
, buf
, len
);
195 static int opromnext(void __user
*argp
, unsigned int cmd
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
, DATA
*data
)
199 BUILD_BUG_ON(sizeof(phandle
) != sizeof(int));
201 if (bufsize
< sizeof(phandle
))
204 ph
= *((int *) op
->oprom_array
);
206 dp
= of_find_node_by_phandle(ph
);
224 /* Sibling of node zero is the root node. */
225 if (cmd
!= OPROMNEXT
)
228 dp
= of_find_node_by_path("/");
235 data
->current_node
= dp
;
236 *((int *) op
->oprom_array
) = ph
;
237 op
->oprom_size
= sizeof(phandle
);
239 return copyout(argp
, op
, bufsize
+ sizeof(int));
242 static int oprompci2node(void __user
*argp
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
, DATA
*data
)
246 if (bufsize
>= 2*sizeof(int)) {
248 struct pci_dev
*pdev
;
249 struct pcidev_cookie
*pcp
;
250 pdev
= pci_find_slot (((int *) op
->oprom_array
)[0],
251 ((int *) op
->oprom_array
)[1]);
256 data
->current_node
= dp
;
257 *((int *)op
->oprom_array
) = dp
->node
;
258 op
->oprom_size
= sizeof(int);
259 err
= copyout(argp
, op
, bufsize
+ sizeof(int));
267 static int oprompath2node(void __user
*argp
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
, DATA
*data
)
269 dp
= of_find_node_by_path(op
->oprom_array
);
270 data
->current_node
= dp
;
271 *((int *)op
->oprom_array
) = dp
->node
;
272 op
->oprom_size
= sizeof(int);
274 return copyout(argp
, op
, bufsize
+ sizeof(int));
277 static int opromgetbootargs(void __user
*argp
, struct openpromio
*op
, int bufsize
)
279 char *buf
= saved_command_line
;
280 int len
= strlen(buf
);
285 strcpy(op
->oprom_array
, buf
);
286 op
->oprom_size
= len
;
288 return copyout(argp
, op
, bufsize
+ sizeof(int));
292 * SunOS and Solaris /dev/openprom ioctl calls.
294 static int openprom_sunos_ioctl(struct inode
* inode
, struct file
* file
,
295 unsigned int cmd
, unsigned long arg
,
296 struct device_node
*dp
)
298 DATA
*data
= file
->private_data
;
299 struct openpromio
*opp
;
300 int bufsize
, error
= 0;
302 void __user
*argp
= (void __user
*)arg
;
304 if (cmd
== OPROMSETOPT
)
305 bufsize
= getstrings(argp
, &opp
);
307 bufsize
= copyin(argp
, &opp
);
315 error
= opromgetprop(argp
, dp
, opp
, bufsize
);
320 error
= opromnxtprop(argp
, dp
, opp
, bufsize
);
325 error
= opromsetopt(dp
, opp
, bufsize
);
331 error
= opromnext(argp
, cmd
, dp
, opp
, bufsize
, data
);
335 error
= oprompci2node(argp
, dp
, opp
, bufsize
, data
);
339 error
= oprompath2node(argp
, dp
, opp
, bufsize
, data
);
342 case OPROMGETBOOTARGS
:
343 error
= opromgetbootargs(argp
, opp
, bufsize
);
350 printk(KERN_INFO
"openprom_sunos_ioctl: unimplemented ioctl\n");
355 printk(KERN_INFO
"openprom_sunos_ioctl: cmd 0x%X, arg 0x%lX\n", cmd
, arg
);
364 static struct device_node
*get_node(phandle n
, DATA
*data
)
366 struct device_node
*dp
= of_find_node_by_phandle(n
);
374 /* Copy in a whole string from userspace into kernelspace. */
375 static int copyin_string(char __user
*user
, size_t len
, char **ptr
)
379 if ((ssize_t
)len
< 0 || (ssize_t
)(len
+ 1) < 0)
382 tmp
= kmalloc(len
+ 1, GFP_KERNEL
);
386 if (copy_from_user(tmp
, user
, len
)) {
399 * NetBSD /dev/openprom ioctl calls.
401 static int opiocget(void __user
*argp
, DATA
*data
)
404 struct device_node
*dp
;
409 if (copy_from_user(&op
, argp
, sizeof(op
)))
412 dp
= get_node(op
.op_nodeid
, data
);
414 err
= copyin_string(op
.op_name
, op
.op_namelen
, &str
);
418 pval
= of_get_property(dp
, str
, &len
);
420 if (!pval
|| len
> op
.op_buflen
) {
424 if (copy_to_user(argp
, &op
, sizeof(op
)) ||
425 copy_to_user(op
.op_buf
, pval
, len
))
433 static int opiocnextprop(void __user
*argp
, DATA
*data
)
436 struct device_node
*dp
;
437 struct property
*prop
;
441 if (copy_from_user(&op
, argp
, sizeof(op
)))
444 dp
= get_node(op
.op_nodeid
, data
);
448 err
= copyin_string(op
.op_name
, op
.op_namelen
, &str
);
452 if (str
[0] == '\0') {
453 prop
= dp
->properties
;
455 prop
= of_find_property(dp
, str
, NULL
);
466 if (len
> op
.op_buflen
)
469 if (copy_to_user(argp
, &op
, sizeof(op
)))
473 copy_to_user(op
.op_buf
, prop
->value
, len
))
479 static int opiocset(void __user
*argp
, DATA
*data
)
482 struct device_node
*dp
;
486 if (copy_from_user(&op
, argp
, sizeof(op
)))
489 dp
= get_node(op
.op_nodeid
, data
);
493 err
= copyin_string(op
.op_name
, op
.op_namelen
, &str
);
497 err
= copyin_string(op
.op_buf
, op
.op_buflen
, &tmp
);
503 err
= of_set_property(dp
, str
, tmp
, op
.op_buflen
);
511 static int opiocgetnext(unsigned int cmd
, void __user
*argp
)
513 struct device_node
*dp
;
516 BUILD_BUG_ON(sizeof(phandle
) != sizeof(int));
518 if (copy_from_user(&nd
, argp
, sizeof(phandle
)))
522 if (cmd
!= OPIOCGETNEXT
)
524 dp
= of_find_node_by_path("/");
526 dp
= of_find_node_by_phandle(nd
);
529 if (cmd
== OPIOCGETNEXT
)
537 if (copy_to_user(argp
, &nd
, sizeof(phandle
)))
543 static int openprom_bsd_ioctl(struct inode
* inode
, struct file
* file
,
544 unsigned int cmd
, unsigned long arg
)
546 DATA
*data
= (DATA
*) file
->private_data
;
547 void __user
*argp
= (void __user
*)arg
;
552 err
= opiocget(argp
, data
);
556 err
= opiocnextprop(argp
, data
);
560 err
= opiocset(argp
, data
);
563 case OPIOCGETOPTNODE
:
564 BUILD_BUG_ON(sizeof(phandle
) != sizeof(int));
566 if (copy_to_user(argp
, &options_node
->node
, sizeof(phandle
)))
573 err
= opiocgetnext(cmd
, argp
);
586 * Handoff control to the correct ioctl handler.
588 static int openprom_ioctl(struct inode
* inode
, struct file
* file
,
589 unsigned int cmd
, unsigned long arg
)
591 DATA
*data
= (DATA
*) file
->private_data
;
596 if ((file
->f_mode
& FMODE_READ
) == 0)
598 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
,
603 if ((file
->f_mode
& FMODE_WRITE
) == 0)
605 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
,
612 if ((file
->f_mode
& FMODE_READ
) == 0)
614 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
,
620 case OPROMGETBOOTARGS
:
624 if ((file
->f_mode
& FMODE_READ
) == 0)
626 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
, 0);
630 case OPIOCGETOPTNODE
:
633 if ((file
->f_mode
& FMODE_READ
) == 0)
635 return openprom_bsd_ioctl(inode
,file
,cmd
,arg
);
638 if ((file
->f_mode
& FMODE_WRITE
) == 0)
640 return openprom_bsd_ioctl(inode
,file
,cmd
,arg
);
647 static long openprom_compat_ioctl(struct file
*file
, unsigned int cmd
,
653 * SunOS/Solaris only, the NetBSD one's have embedded pointers in
654 * the arg which we'd need to clean up...
668 case OPROMGETBOOTARGS
:
672 rval
= openprom_ioctl(file
->f_dentry
->d_inode
, file
, cmd
, arg
);
679 static int openprom_open(struct inode
* inode
, struct file
* file
)
683 data
= kmalloc(sizeof(DATA
), GFP_KERNEL
);
687 data
->current_node
= of_find_node_by_path("/");
688 data
->lastnode
= data
->current_node
;
689 file
->private_data
= (void *) data
;
694 static int openprom_release(struct inode
* inode
, struct file
* file
)
696 kfree(file
->private_data
);
700 static struct file_operations openprom_fops
= {
701 .owner
= THIS_MODULE
,
703 .ioctl
= openprom_ioctl
,
704 .compat_ioctl
= openprom_compat_ioctl
,
705 .open
= openprom_open
,
706 .release
= openprom_release
,
709 static struct miscdevice openprom_dev
= {
710 .minor
= SUN_OPENPROM_MINOR
,
712 .fops
= &openprom_fops
,
715 static int __init
openprom_init(void)
717 struct device_node
*dp
;
720 err
= misc_register(&openprom_dev
);
724 dp
= of_find_node_by_path("/");
727 if (!strcmp(dp
->name
, "options"))
734 misc_deregister(&openprom_dev
);
741 static void __exit
openprom_cleanup(void)
743 misc_deregister(&openprom_dev
);
746 module_init(openprom_init
);
747 module_exit(openprom_cleanup
);