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/errno.h>
35 #include <linux/slab.h>
36 #include <linux/string.h>
37 #include <linux/miscdevice.h>
38 #include <linux/init.h>
40 #include <asm/oplib.h>
42 #include <asm/system.h>
43 #include <asm/uaccess.h>
44 #include <asm/openpromio.h>
46 #include <linux/pci.h>
50 MODULE_AUTHOR("Thomas K. Dyas (tdyas@noc.rutgers.edu) and Eddie C. Dost (ecd@skynet.be)");
51 MODULE_DESCRIPTION("OPENPROM Configuration Driver");
52 MODULE_LICENSE("GPL");
53 MODULE_VERSION("1.0");
55 /* Private data kept by the driver for each descriptor. */
56 typedef struct openprom_private_data
58 struct device_node
*current_node
; /* Current node for SunOS ioctls. */
59 struct device_node
*lastnode
; /* Last valid node used by BSD ioctls. */
62 /* ID of the PROM node containing all of the EEPROM options. */
63 static struct device_node
*options_node
;
66 * Copy an openpromio structure into kernel space from user space.
67 * This routine does error checking to make sure that all memory
68 * accesses are within bounds. A pointer to the allocated openpromio
69 * structure will be placed in "*opp_p". Return value is the length
70 * of the user supplied buffer.
72 static int copyin(struct openpromio __user
*info
, struct openpromio
**opp_p
)
79 if (get_user(bufsize
, &info
->oprom_size
))
85 /* If the bufsize is too large, just limit it.
86 * Fix from Jason Rappleye.
88 if (bufsize
> OPROMMAXPARAM
)
89 bufsize
= OPROMMAXPARAM
;
91 if (!(*opp_p
= kzalloc(sizeof(int) + bufsize
+ 1, GFP_KERNEL
)))
94 if (copy_from_user(&(*opp_p
)->oprom_array
,
95 &info
->oprom_array
, bufsize
)) {
102 static int getstrings(struct openpromio __user
*info
, struct openpromio
**opp_p
)
110 if (!(*opp_p
= kzalloc(sizeof(int) + OPROMMAXPARAM
+ 1, GFP_KERNEL
)))
113 (*opp_p
)->oprom_size
= 0;
116 while ((n
< 2) && (bufsize
< OPROMMAXPARAM
)) {
117 if (get_user(c
, &info
->oprom_array
[bufsize
])) {
123 (*opp_p
)->oprom_array
[bufsize
++] = c
;
133 * Copy an openpromio structure in kernel space back to user space.
135 static int copyout(void __user
*info
, struct openpromio
*opp
, int len
)
137 if (copy_to_user(info
, opp
, len
))
142 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 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
;
165 return copyout(argp
, op
, sizeof(int));
166 if (op
->oprom_array
[0] == '\0') {
167 prop
= dp
->properties
;
169 return copyout(argp
, op
, sizeof(int));
170 len
= strlen(prop
->name
);
172 prop
= of_find_property(dp
, op
->oprom_array
, NULL
);
176 (len
= strlen(prop
->next
->name
)) + 1 > bufsize
)
177 return copyout(argp
, op
, sizeof(int));
182 memcpy(op
->oprom_array
, prop
->name
, len
);
183 op
->oprom_array
[len
] = '\0';
184 op
->oprom_size
= ++len
;
186 return copyout(argp
, op
, sizeof(int) + bufsize
);
189 static int opromsetopt(struct device_node
*dp
, struct openpromio
*op
, int bufsize
)
191 char *buf
= op
->oprom_array
+ strlen(op
->oprom_array
) + 1;
192 int len
= op
->oprom_array
+ bufsize
- buf
;
194 return of_set_property(options_node
, op
->oprom_array
, buf
, len
);
197 static int opromnext(void __user
*argp
, unsigned int cmd
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
, DATA
*data
)
201 BUILD_BUG_ON(sizeof(phandle
) != sizeof(int));
203 if (bufsize
< sizeof(phandle
))
206 ph
= *((int *) op
->oprom_array
);
208 dp
= of_find_node_by_phandle(ph
);
226 /* Sibling of node zero is the root node. */
227 if (cmd
!= OPROMNEXT
)
230 dp
= of_find_node_by_path("/");
237 data
->current_node
= dp
;
238 *((int *) op
->oprom_array
) = ph
;
239 op
->oprom_size
= sizeof(phandle
);
241 return copyout(argp
, op
, bufsize
+ sizeof(int));
244 static int oprompci2node(void __user
*argp
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
, DATA
*data
)
248 if (bufsize
>= 2*sizeof(int)) {
250 struct pci_dev
*pdev
;
251 struct pcidev_cookie
*pcp
;
252 pdev
= pci_get_bus_and_slot (((int *) op
->oprom_array
)[0],
253 ((int *) op
->oprom_array
)[1]);
258 data
->current_node
= dp
;
259 *((int *)op
->oprom_array
) = dp
->node
;
260 op
->oprom_size
= sizeof(int);
261 err
= copyout(argp
, op
, bufsize
+ sizeof(int));
270 static int oprompath2node(void __user
*argp
, struct device_node
*dp
, struct openpromio
*op
, int bufsize
, DATA
*data
)
274 dp
= of_find_node_by_path(op
->oprom_array
);
277 data
->current_node
= dp
;
278 *((int *)op
->oprom_array
) = ph
;
279 op
->oprom_size
= sizeof(int);
281 return copyout(argp
, op
, bufsize
+ sizeof(int));
284 static int opromgetbootargs(void __user
*argp
, struct openpromio
*op
, int bufsize
)
286 char *buf
= saved_command_line
;
287 int len
= strlen(buf
);
292 strcpy(op
->oprom_array
, buf
);
293 op
->oprom_size
= len
;
295 return copyout(argp
, op
, bufsize
+ sizeof(int));
299 * SunOS and Solaris /dev/openprom ioctl calls.
301 static int openprom_sunos_ioctl(struct inode
* inode
, struct file
* file
,
302 unsigned int cmd
, unsigned long arg
,
303 struct device_node
*dp
)
305 DATA
*data
= file
->private_data
;
306 struct openpromio
*opp
;
307 int bufsize
, error
= 0;
309 void __user
*argp
= (void __user
*)arg
;
311 if (cmd
== OPROMSETOPT
)
312 bufsize
= getstrings(argp
, &opp
);
314 bufsize
= copyin(argp
, &opp
);
322 error
= opromgetprop(argp
, dp
, opp
, bufsize
);
327 error
= opromnxtprop(argp
, dp
, opp
, bufsize
);
332 error
= opromsetopt(dp
, opp
, bufsize
);
338 error
= opromnext(argp
, cmd
, dp
, opp
, bufsize
, data
);
342 error
= oprompci2node(argp
, dp
, opp
, bufsize
, data
);
346 error
= oprompath2node(argp
, dp
, opp
, bufsize
, data
);
349 case OPROMGETBOOTARGS
:
350 error
= opromgetbootargs(argp
, opp
, bufsize
);
357 printk(KERN_INFO
"openprom_sunos_ioctl: unimplemented ioctl\n");
362 printk(KERN_INFO
"openprom_sunos_ioctl: cmd 0x%X, arg 0x%lX\n", cmd
, arg
);
371 static struct device_node
*get_node(phandle n
, DATA
*data
)
373 struct device_node
*dp
= of_find_node_by_phandle(n
);
381 /* Copy in a whole string from userspace into kernelspace. */
382 static int copyin_string(char __user
*user
, size_t len
, char **ptr
)
386 if ((ssize_t
)len
< 0 || (ssize_t
)(len
+ 1) < 0)
389 tmp
= kmalloc(len
+ 1, GFP_KERNEL
);
393 if (copy_from_user(tmp
, user
, len
)) {
406 * NetBSD /dev/openprom ioctl calls.
408 static int opiocget(void __user
*argp
, DATA
*data
)
411 struct device_node
*dp
;
416 if (copy_from_user(&op
, argp
, sizeof(op
)))
419 dp
= get_node(op
.op_nodeid
, data
);
421 err
= copyin_string(op
.op_name
, op
.op_namelen
, &str
);
425 pval
= of_get_property(dp
, str
, &len
);
427 if (!pval
|| len
> op
.op_buflen
) {
431 if (copy_to_user(argp
, &op
, sizeof(op
)) ||
432 copy_to_user(op
.op_buf
, pval
, len
))
440 static int opiocnextprop(void __user
*argp
, DATA
*data
)
443 struct device_node
*dp
;
444 struct property
*prop
;
448 if (copy_from_user(&op
, argp
, sizeof(op
)))
451 dp
= get_node(op
.op_nodeid
, data
);
455 err
= copyin_string(op
.op_name
, op
.op_namelen
, &str
);
459 if (str
[0] == '\0') {
460 prop
= dp
->properties
;
462 prop
= of_find_property(dp
, str
, NULL
);
473 if (len
> op
.op_buflen
)
476 if (copy_to_user(argp
, &op
, sizeof(op
)))
480 copy_to_user(op
.op_buf
, prop
->value
, len
))
486 static int opiocset(void __user
*argp
, DATA
*data
)
489 struct device_node
*dp
;
493 if (copy_from_user(&op
, argp
, sizeof(op
)))
496 dp
= get_node(op
.op_nodeid
, data
);
500 err
= copyin_string(op
.op_name
, op
.op_namelen
, &str
);
504 err
= copyin_string(op
.op_buf
, op
.op_buflen
, &tmp
);
510 err
= of_set_property(dp
, str
, tmp
, op
.op_buflen
);
518 static int opiocgetnext(unsigned int cmd
, void __user
*argp
)
520 struct device_node
*dp
;
523 BUILD_BUG_ON(sizeof(phandle
) != sizeof(int));
525 if (copy_from_user(&nd
, argp
, sizeof(phandle
)))
529 if (cmd
!= OPIOCGETNEXT
)
531 dp
= of_find_node_by_path("/");
533 dp
= of_find_node_by_phandle(nd
);
536 if (cmd
== OPIOCGETNEXT
)
544 if (copy_to_user(argp
, &nd
, sizeof(phandle
)))
550 static int openprom_bsd_ioctl(struct inode
* inode
, struct file
* file
,
551 unsigned int cmd
, unsigned long arg
)
553 DATA
*data
= (DATA
*) file
->private_data
;
554 void __user
*argp
= (void __user
*)arg
;
559 err
= opiocget(argp
, data
);
563 err
= opiocnextprop(argp
, data
);
567 err
= opiocset(argp
, data
);
570 case OPIOCGETOPTNODE
:
571 BUILD_BUG_ON(sizeof(phandle
) != sizeof(int));
573 if (copy_to_user(argp
, &options_node
->node
, sizeof(phandle
)))
580 err
= opiocgetnext(cmd
, argp
);
593 * Handoff control to the correct ioctl handler.
595 static int openprom_ioctl(struct inode
* inode
, struct file
* file
,
596 unsigned int cmd
, unsigned long arg
)
598 DATA
*data
= (DATA
*) file
->private_data
;
603 if ((file
->f_mode
& FMODE_READ
) == 0)
605 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
,
610 if ((file
->f_mode
& FMODE_WRITE
) == 0)
612 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
,
619 if ((file
->f_mode
& FMODE_READ
) == 0)
621 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
,
627 case OPROMGETBOOTARGS
:
631 if ((file
->f_mode
& FMODE_READ
) == 0)
633 return openprom_sunos_ioctl(inode
, file
, cmd
, arg
, NULL
);
637 case OPIOCGETOPTNODE
:
640 if ((file
->f_mode
& FMODE_READ
) == 0)
642 return openprom_bsd_ioctl(inode
,file
,cmd
,arg
);
645 if ((file
->f_mode
& FMODE_WRITE
) == 0)
647 return openprom_bsd_ioctl(inode
,file
,cmd
,arg
);
654 static long openprom_compat_ioctl(struct file
*file
, unsigned int cmd
,
660 * SunOS/Solaris only, the NetBSD one's have embedded pointers in
661 * the arg which we'd need to clean up...
675 case OPROMGETBOOTARGS
:
679 rval
= openprom_ioctl(file
->f_path
.dentry
->d_inode
, file
, cmd
, arg
);
686 static int openprom_open(struct inode
* inode
, struct file
* file
)
690 data
= kmalloc(sizeof(DATA
), GFP_KERNEL
);
694 data
->current_node
= of_find_node_by_path("/");
695 data
->lastnode
= data
->current_node
;
696 file
->private_data
= (void *) data
;
701 static int openprom_release(struct inode
* inode
, struct file
* file
)
703 kfree(file
->private_data
);
707 static const struct file_operations openprom_fops
= {
708 .owner
= THIS_MODULE
,
710 .ioctl
= openprom_ioctl
,
711 .compat_ioctl
= openprom_compat_ioctl
,
712 .open
= openprom_open
,
713 .release
= openprom_release
,
716 static struct miscdevice openprom_dev
= {
717 .minor
= SUN_OPENPROM_MINOR
,
719 .fops
= &openprom_fops
,
722 static int __init
openprom_init(void)
724 struct device_node
*dp
;
727 err
= misc_register(&openprom_dev
);
731 dp
= of_find_node_by_path("/");
734 if (!strcmp(dp
->name
, "options"))
741 misc_deregister(&openprom_dev
);
748 static void __exit
openprom_cleanup(void)
750 misc_deregister(&openprom_dev
);
753 module_init(openprom_init
);
754 module_exit(openprom_cleanup
);