Driver-Core: extend devnode callbacks to provide permissions
[linux-2.6.git] / drivers / char / hw_random / core.c
1 /*
2         Added support for the AMD Geode LX RNG
3         (c) Copyright 2004-2005 Advanced Micro Devices, Inc.
4
5         derived from
6
7         Hardware driver for the Intel/AMD/VIA Random Number Generators (RNG)
8         (c) Copyright 2003 Red Hat Inc <jgarzik@redhat.com>
9
10         derived from
11
12         Hardware driver for the AMD 768 Random Number Generator (RNG)
13         (c) Copyright 2001 Red Hat Inc <alan@redhat.com>
14
15         derived from
16
17         Hardware driver for Intel i810 Random Number Generator (RNG)
18         Copyright 2000,2001 Jeff Garzik <jgarzik@pobox.com>
19         Copyright 2000,2001 Philipp Rumpf <prumpf@mandrakesoft.com>
20
21         Added generic RNG API
22         Copyright 2006 Michael Buesch <mbuesch@freenet.de>
23         Copyright 2005 (c) MontaVista Software, Inc.
24
25         Please read Documentation/hw_random.txt for details on use.
26
27         ----------------------------------------------------------
28         This software may be used and distributed according to the terms
29         of the GNU General Public License, incorporated herein by reference.
30
31  */
32
33
34 #include <linux/device.h>
35 #include <linux/hw_random.h>
36 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/fs.h>
39 #include <linux/sched.h>
40 #include <linux/smp_lock.h>
41 #include <linux/init.h>
42 #include <linux/miscdevice.h>
43 #include <linux/delay.h>
44 #include <asm/uaccess.h>
45
46
47 #define RNG_MODULE_NAME         "hw_random"
48 #define PFX                     RNG_MODULE_NAME ": "
49 #define RNG_MISCDEV_MINOR       183 /* official */
50
51
52 static struct hwrng *current_rng;
53 static LIST_HEAD(rng_list);
54 static DEFINE_MUTEX(rng_mutex);
55
56
57 static inline int hwrng_init(struct hwrng *rng)
58 {
59         if (!rng->init)
60                 return 0;
61         return rng->init(rng);
62 }
63
64 static inline void hwrng_cleanup(struct hwrng *rng)
65 {
66         if (rng && rng->cleanup)
67                 rng->cleanup(rng);
68 }
69
70 static inline int hwrng_data_present(struct hwrng *rng, int wait)
71 {
72         if (!rng->data_present)
73                 return 1;
74         return rng->data_present(rng, wait);
75 }
76
77 static inline int hwrng_data_read(struct hwrng *rng, u32 *data)
78 {
79         return rng->data_read(rng, data);
80 }
81
82
83 static int rng_dev_open(struct inode *inode, struct file *filp)
84 {
85         /* enforce read-only access to this chrdev */
86         if ((filp->f_mode & FMODE_READ) == 0)
87                 return -EINVAL;
88         if (filp->f_mode & FMODE_WRITE)
89                 return -EINVAL;
90         cycle_kernel_lock();
91         return 0;
92 }
93
94 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
95                             size_t size, loff_t *offp)
96 {
97         u32 data;
98         ssize_t ret = 0;
99         int err = 0;
100         int bytes_read;
101
102         while (size) {
103                 err = -ERESTARTSYS;
104                 if (mutex_lock_interruptible(&rng_mutex))
105                         goto out;
106                 if (!current_rng) {
107                         mutex_unlock(&rng_mutex);
108                         err = -ENODEV;
109                         goto out;
110                 }
111
112                 bytes_read = 0;
113                 if (hwrng_data_present(current_rng,
114                                        !(filp->f_flags & O_NONBLOCK)))
115                         bytes_read = hwrng_data_read(current_rng, &data);
116                 mutex_unlock(&rng_mutex);
117
118                 err = -EAGAIN;
119                 if (!bytes_read && (filp->f_flags & O_NONBLOCK))
120                         goto out;
121                 if (bytes_read < 0) {
122                         err = bytes_read;
123                         goto out;
124                 }
125
126                 err = -EFAULT;
127                 while (bytes_read && size) {
128                         if (put_user((u8)data, buf++))
129                                 goto out;
130                         size--;
131                         ret++;
132                         bytes_read--;
133                         data >>= 8;
134                 }
135
136                 if (need_resched())
137                         schedule_timeout_interruptible(1);
138                 err = -ERESTARTSYS;
139                 if (signal_pending(current))
140                         goto out;
141         }
142 out:
143         return ret ? : err;
144 }
145
146
147 static const struct file_operations rng_chrdev_ops = {
148         .owner          = THIS_MODULE,
149         .open           = rng_dev_open,
150         .read           = rng_dev_read,
151 };
152
153 static struct miscdevice rng_miscdev = {
154         .minor          = RNG_MISCDEV_MINOR,
155         .name           = RNG_MODULE_NAME,
156         .nodename       = "hwrng",
157         .fops           = &rng_chrdev_ops,
158 };
159
160
161 static ssize_t hwrng_attr_current_store(struct device *dev,
162                                         struct device_attribute *attr,
163                                         const char *buf, size_t len)
164 {
165         int err;
166         struct hwrng *rng;
167
168         err = mutex_lock_interruptible(&rng_mutex);
169         if (err)
170                 return -ERESTARTSYS;
171         err = -ENODEV;
172         list_for_each_entry(rng, &rng_list, list) {
173                 if (strcmp(rng->name, buf) == 0) {
174                         if (rng == current_rng) {
175                                 err = 0;
176                                 break;
177                         }
178                         err = hwrng_init(rng);
179                         if (err)
180                                 break;
181                         hwrng_cleanup(current_rng);
182                         current_rng = rng;
183                         err = 0;
184                         break;
185                 }
186         }
187         mutex_unlock(&rng_mutex);
188
189         return err ? : len;
190 }
191
192 static ssize_t hwrng_attr_current_show(struct device *dev,
193                                        struct device_attribute *attr,
194                                        char *buf)
195 {
196         int err;
197         ssize_t ret;
198         const char *name = "none";
199
200         err = mutex_lock_interruptible(&rng_mutex);
201         if (err)
202                 return -ERESTARTSYS;
203         if (current_rng)
204                 name = current_rng->name;
205         ret = snprintf(buf, PAGE_SIZE, "%s\n", name);
206         mutex_unlock(&rng_mutex);
207
208         return ret;
209 }
210
211 static ssize_t hwrng_attr_available_show(struct device *dev,
212                                          struct device_attribute *attr,
213                                          char *buf)
214 {
215         int err;
216         ssize_t ret = 0;
217         struct hwrng *rng;
218
219         err = mutex_lock_interruptible(&rng_mutex);
220         if (err)
221                 return -ERESTARTSYS;
222         buf[0] = '\0';
223         list_for_each_entry(rng, &rng_list, list) {
224                 strncat(buf, rng->name, PAGE_SIZE - ret - 1);
225                 ret += strlen(rng->name);
226                 strncat(buf, " ", PAGE_SIZE - ret - 1);
227                 ret++;
228         }
229         strncat(buf, "\n", PAGE_SIZE - ret - 1);
230         ret++;
231         mutex_unlock(&rng_mutex);
232
233         return ret;
234 }
235
236 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
237                    hwrng_attr_current_show,
238                    hwrng_attr_current_store);
239 static DEVICE_ATTR(rng_available, S_IRUGO,
240                    hwrng_attr_available_show,
241                    NULL);
242
243
244 static void unregister_miscdev(void)
245 {
246         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
247         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
248         misc_deregister(&rng_miscdev);
249 }
250
251 static int register_miscdev(void)
252 {
253         int err;
254
255         err = misc_register(&rng_miscdev);
256         if (err)
257                 goto out;
258         err = device_create_file(rng_miscdev.this_device,
259                                  &dev_attr_rng_current);
260         if (err)
261                 goto err_misc_dereg;
262         err = device_create_file(rng_miscdev.this_device,
263                                  &dev_attr_rng_available);
264         if (err)
265                 goto err_remove_current;
266 out:
267         return err;
268
269 err_remove_current:
270         device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
271 err_misc_dereg:
272         misc_deregister(&rng_miscdev);
273         goto out;
274 }
275
276 int hwrng_register(struct hwrng *rng)
277 {
278         int must_register_misc;
279         int err = -EINVAL;
280         struct hwrng *old_rng, *tmp;
281
282         if (rng->name == NULL ||
283             rng->data_read == NULL)
284                 goto out;
285
286         mutex_lock(&rng_mutex);
287
288         /* Must not register two RNGs with the same name. */
289         err = -EEXIST;
290         list_for_each_entry(tmp, &rng_list, list) {
291                 if (strcmp(tmp->name, rng->name) == 0)
292                         goto out_unlock;
293         }
294
295         must_register_misc = (current_rng == NULL);
296         old_rng = current_rng;
297         if (!old_rng) {
298                 err = hwrng_init(rng);
299                 if (err)
300                         goto out_unlock;
301                 current_rng = rng;
302         }
303         err = 0;
304         if (must_register_misc) {
305                 err = register_miscdev();
306                 if (err) {
307                         if (!old_rng) {
308                                 hwrng_cleanup(rng);
309                                 current_rng = NULL;
310                         }
311                         goto out_unlock;
312                 }
313         }
314         INIT_LIST_HEAD(&rng->list);
315         list_add_tail(&rng->list, &rng_list);
316 out_unlock:
317         mutex_unlock(&rng_mutex);
318 out:
319         return err;
320 }
321 EXPORT_SYMBOL_GPL(hwrng_register);
322
323 void hwrng_unregister(struct hwrng *rng)
324 {
325         int err;
326
327         mutex_lock(&rng_mutex);
328
329         list_del(&rng->list);
330         if (current_rng == rng) {
331                 hwrng_cleanup(rng);
332                 if (list_empty(&rng_list)) {
333                         current_rng = NULL;
334                 } else {
335                         current_rng = list_entry(rng_list.prev, struct hwrng, list);
336                         err = hwrng_init(current_rng);
337                         if (err)
338                                 current_rng = NULL;
339                 }
340         }
341         if (list_empty(&rng_list))
342                 unregister_miscdev();
343
344         mutex_unlock(&rng_mutex);
345 }
346 EXPORT_SYMBOL_GPL(hwrng_unregister);
347
348
349 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
350 MODULE_LICENSE("GPL");