Merge master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6 into next
[linux-2.6] / arch / um / drivers / random.c
1 /* Copyright (C) 2005 - 2008 Jeff Dike <jdike@{linux.intel,addtoit}.com> */
2
3 /* Much of this ripped from drivers/char/hw_random.c, see there for other
4  * copyright.
5  *
6  * This software may be used and distributed according to the terms
7  * of the GNU General Public License, incorporated herein by reference.
8  */
9 #include <linux/sched.h>
10 #include <linux/smp_lock.h>
11 #include <linux/module.h>
12 #include <linux/fs.h>
13 #include <linux/interrupt.h>
14 #include <linux/miscdevice.h>
15 #include <linux/delay.h>
16 #include <asm/uaccess.h>
17 #include "irq_kern.h"
18 #include "os.h"
19
20 /*
21  * core module and version information
22  */
23 #define RNG_VERSION "1.0.0"
24 #define RNG_MODULE_NAME "hw_random"
25
26 #define RNG_MISCDEV_MINOR               183 /* official */
27
28 /* Changed at init time, in the non-modular case, and at module load
29  * time, in the module case.  Presumably, the module subsystem
30  * protects against a module being loaded twice at the same time.
31  */
32 static int random_fd = -1;
33 static DECLARE_WAIT_QUEUE_HEAD(host_read_wait);
34
35 static int rng_dev_open (struct inode *inode, struct file *filp)
36 {
37         cycle_kernel_lock();
38
39         /* enforce read-only access to this chrdev */
40         if ((filp->f_mode & FMODE_READ) == 0)
41                 return -EINVAL;
42         if ((filp->f_mode & FMODE_WRITE) != 0)
43                 return -EINVAL;
44
45         return 0;
46 }
47
48 static atomic_t host_sleep_count = ATOMIC_INIT(0);
49
50 static ssize_t rng_dev_read (struct file *filp, char __user *buf, size_t size,
51                              loff_t *offp)
52 {
53         u32 data;
54         int n, ret = 0, have_data;
55
56         while (size) {
57                 n = os_read_file(random_fd, &data, sizeof(data));
58                 if (n > 0) {
59                         have_data = n;
60                         while (have_data && size) {
61                                 if (put_user((u8) data, buf++)) {
62                                         ret = ret ? : -EFAULT;
63                                         break;
64                                 }
65                                 size--;
66                                 ret++;
67                                 have_data--;
68                                 data >>= 8;
69                         }
70                 }
71                 else if (n == -EAGAIN) {
72                         DECLARE_WAITQUEUE(wait, current);
73
74                         if (filp->f_flags & O_NONBLOCK)
75                                 return ret ? : -EAGAIN;
76
77                         atomic_inc(&host_sleep_count);
78                         reactivate_fd(random_fd, RANDOM_IRQ);
79                         add_sigio_fd(random_fd);
80
81                         add_wait_queue(&host_read_wait, &wait);
82                         set_task_state(current, TASK_INTERRUPTIBLE);
83
84                         schedule();
85                         set_task_state(current, TASK_RUNNING);
86                         remove_wait_queue(&host_read_wait, &wait);
87
88                         if (atomic_dec_and_test(&host_sleep_count)) {
89                                 ignore_sigio_fd(random_fd);
90                                 deactivate_fd(random_fd, RANDOM_IRQ);
91                         }
92                 }
93                 else
94                         return n;
95
96                 if (signal_pending (current))
97                         return ret ? : -ERESTARTSYS;
98         }
99         return ret;
100 }
101
102 static const struct file_operations rng_chrdev_ops = {
103         .owner          = THIS_MODULE,
104         .open           = rng_dev_open,
105         .read           = rng_dev_read,
106 };
107
108 /* rng_init shouldn't be called more than once at boot time */
109 static struct miscdevice rng_miscdev = {
110         RNG_MISCDEV_MINOR,
111         RNG_MODULE_NAME,
112         &rng_chrdev_ops,
113 };
114
115 static irqreturn_t random_interrupt(int irq, void *data)
116 {
117         wake_up(&host_read_wait);
118
119         return IRQ_HANDLED;
120 }
121
122 /*
123  * rng_init - initialize RNG module
124  */
125 static int __init rng_init (void)
126 {
127         int err;
128
129         err = os_open_file("/dev/random", of_read(OPENFLAGS()), 0);
130         if (err < 0)
131                 goto out;
132
133         random_fd = err;
134
135         err = um_request_irq(RANDOM_IRQ, random_fd, IRQ_READ, random_interrupt,
136                              IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "random",
137                              NULL);
138         if (err)
139                 goto err_out_cleanup_hw;
140
141         sigio_broken(random_fd, 1);
142
143         err = misc_register (&rng_miscdev);
144         if (err) {
145                 printk (KERN_ERR RNG_MODULE_NAME ": misc device register "
146                         "failed\n");
147                 goto err_out_cleanup_hw;
148         }
149 out:
150         return err;
151
152 err_out_cleanup_hw:
153         os_close_file(random_fd);
154         random_fd = -1;
155         goto out;
156 }
157
158 /*
159  * rng_cleanup - shutdown RNG module
160  */
161 static void __exit rng_cleanup (void)
162 {
163         os_close_file(random_fd);
164         misc_deregister (&rng_miscdev);
165 }
166
167 module_init (rng_init);
168 module_exit (rng_cleanup);
169
170 MODULE_DESCRIPTION("UML Host Random Number Generator (RNG) driver");
171 MODULE_LICENSE("GPL");