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 <m@bues.ch>
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/miscdevice.h>
41#include <linux/kthread.h>
42#include <linux/delay.h>
43#include <linux/slab.h>
44#include <linux/random.h>
45#include <linux/err.h>
46#include <asm/uaccess.h>
47
48
49#define RNG_MODULE_NAME		"hw_random"
50#define PFX			RNG_MODULE_NAME ": "
51#define RNG_MISCDEV_MINOR	183 /* official */
52
53
54static struct hwrng *current_rng;
55static struct task_struct *hwrng_fill;
56static LIST_HEAD(rng_list);
57/* Protects rng_list and current_rng */
58static DEFINE_MUTEX(rng_mutex);
59/* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */
60static DEFINE_MUTEX(reading_mutex);
61static int data_avail;
62static u8 *rng_buffer, *rng_fillbuf;
63static unsigned short current_quality;
64static unsigned short default_quality; /* = 0; default to "off" */
65
66module_param(current_quality, ushort, 0644);
67MODULE_PARM_DESC(current_quality,
68		 "current hwrng entropy estimation per mill");
69module_param(default_quality, ushort, 0644);
70MODULE_PARM_DESC(default_quality,
71		 "default entropy content of hwrng per mill");
72
73static void drop_current_rng(void);
74static int hwrng_init(struct hwrng *rng);
75static void start_khwrngd(void);
76
77static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
78			       int wait);
79
80static size_t rng_buffer_size(void)
81{
82	return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
83}
84
85static void add_early_randomness(struct hwrng *rng)
86{
87	unsigned char bytes[16];
88	int bytes_read;
89
90	mutex_lock(&reading_mutex);
91	bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
92	mutex_unlock(&reading_mutex);
93	if (bytes_read > 0)
94		add_device_randomness(bytes, bytes_read);
95}
96
97static inline void cleanup_rng(struct kref *kref)
98{
99	struct hwrng *rng = container_of(kref, struct hwrng, ref);
100
101	if (rng->cleanup)
102		rng->cleanup(rng);
103
104	complete(&rng->cleanup_done);
105}
106
107static int set_current_rng(struct hwrng *rng)
108{
109	int err;
110
111	BUG_ON(!mutex_is_locked(&rng_mutex));
112
113	err = hwrng_init(rng);
114	if (err)
115		return err;
116
117	drop_current_rng();
118	current_rng = rng;
119
120	return 0;
121}
122
123static void drop_current_rng(void)
124{
125	BUG_ON(!mutex_is_locked(&rng_mutex));
126	if (!current_rng)
127		return;
128
129	/* decrease last reference for triggering the cleanup */
130	kref_put(&current_rng->ref, cleanup_rng);
131	current_rng = NULL;
132}
133
134/* Returns ERR_PTR(), NULL or refcounted hwrng */
135static struct hwrng *get_current_rng(void)
136{
137	struct hwrng *rng;
138
139	if (mutex_lock_interruptible(&rng_mutex))
140		return ERR_PTR(-ERESTARTSYS);
141
142	rng = current_rng;
143	if (rng)
144		kref_get(&rng->ref);
145
146	mutex_unlock(&rng_mutex);
147	return rng;
148}
149
150static void put_rng(struct hwrng *rng)
151{
152	/*
153	 * Hold rng_mutex here so we serialize in case they set_current_rng
154	 * on rng again immediately.
155	 */
156	mutex_lock(&rng_mutex);
157	if (rng)
158		kref_put(&rng->ref, cleanup_rng);
159	mutex_unlock(&rng_mutex);
160}
161
162static int hwrng_init(struct hwrng *rng)
163{
164	if (kref_get_unless_zero(&rng->ref))
165		goto skip_init;
166
167	if (rng->init) {
168		int ret;
169
170		ret =  rng->init(rng);
171		if (ret)
172			return ret;
173	}
174
175	kref_init(&rng->ref);
176	reinit_completion(&rng->cleanup_done);
177
178skip_init:
179	add_early_randomness(rng);
180
181	current_quality = rng->quality ? : default_quality;
182	if (current_quality > 1024)
183		current_quality = 1024;
184
185	if (current_quality == 0 && hwrng_fill)
186		kthread_stop(hwrng_fill);
187	if (current_quality > 0 && !hwrng_fill)
188		start_khwrngd();
189
190	return 0;
191}
192
193static int rng_dev_open(struct inode *inode, struct file *filp)
194{
195	/* enforce read-only access to this chrdev */
196	if ((filp->f_mode & FMODE_READ) == 0)
197		return -EINVAL;
198	if (filp->f_mode & FMODE_WRITE)
199		return -EINVAL;
200	return 0;
201}
202
203static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
204			int wait) {
205	int present;
206
207	BUG_ON(!mutex_is_locked(&reading_mutex));
208	if (rng->read)
209		return rng->read(rng, (void *)buffer, size, wait);
210
211	if (rng->data_present)
212		present = rng->data_present(rng, wait);
213	else
214		present = 1;
215
216	if (present)
217		return rng->data_read(rng, (u32 *)buffer);
218
219	return 0;
220}
221
222static ssize_t rng_dev_read(struct file *filp, char __user *buf,
223			    size_t size, loff_t *offp)
224{
225	ssize_t ret = 0;
226	int err = 0;
227	int bytes_read, len;
228	struct hwrng *rng;
229
230	while (size) {
231		rng = get_current_rng();
232		if (IS_ERR(rng)) {
233			err = PTR_ERR(rng);
234			goto out;
235		}
236		if (!rng) {
237			err = -ENODEV;
238			goto out;
239		}
240
241		mutex_lock(&reading_mutex);
242		if (!data_avail) {
243			bytes_read = rng_get_data(rng, rng_buffer,
244				rng_buffer_size(),
245				!(filp->f_flags & O_NONBLOCK));
246			if (bytes_read < 0) {
247				err = bytes_read;
248				goto out_unlock_reading;
249			}
250			data_avail = bytes_read;
251		}
252
253		if (!data_avail) {
254			if (filp->f_flags & O_NONBLOCK) {
255				err = -EAGAIN;
256				goto out_unlock_reading;
257			}
258		} else {
259			len = data_avail;
260			if (len > size)
261				len = size;
262
263			data_avail -= len;
264
265			if (copy_to_user(buf + ret, rng_buffer + data_avail,
266								len)) {
267				err = -EFAULT;
268				goto out_unlock_reading;
269			}
270
271			size -= len;
272			ret += len;
273		}
274
275		mutex_unlock(&reading_mutex);
276		put_rng(rng);
277
278		if (need_resched())
279			schedule_timeout_interruptible(1);
280
281		if (signal_pending(current)) {
282			err = -ERESTARTSYS;
283			goto out;
284		}
285	}
286out:
287	return ret ? : err;
288
289out_unlock_reading:
290	mutex_unlock(&reading_mutex);
291	put_rng(rng);
292	goto out;
293}
294
295
296static const struct file_operations rng_chrdev_ops = {
297	.owner		= THIS_MODULE,
298	.open		= rng_dev_open,
299	.read		= rng_dev_read,
300	.llseek		= noop_llseek,
301};
302
303static const struct attribute_group *rng_dev_groups[];
304
305static struct miscdevice rng_miscdev = {
306	.minor		= RNG_MISCDEV_MINOR,
307	.name		= RNG_MODULE_NAME,
308	.nodename	= "hwrng",
309	.fops		= &rng_chrdev_ops,
310	.groups		= rng_dev_groups,
311};
312
313
314static ssize_t hwrng_attr_current_store(struct device *dev,
315					struct device_attribute *attr,
316					const char *buf, size_t len)
317{
318	int err;
319	struct hwrng *rng;
320
321	err = mutex_lock_interruptible(&rng_mutex);
322	if (err)
323		return -ERESTARTSYS;
324	err = -ENODEV;
325	list_for_each_entry(rng, &rng_list, list) {
326		if (strcmp(rng->name, buf) == 0) {
327			err = 0;
328			if (rng != current_rng)
329				err = set_current_rng(rng);
330			break;
331		}
332	}
333	mutex_unlock(&rng_mutex);
334
335	return err ? : len;
336}
337
338static ssize_t hwrng_attr_current_show(struct device *dev,
339				       struct device_attribute *attr,
340				       char *buf)
341{
342	ssize_t ret;
343	struct hwrng *rng;
344
345	rng = get_current_rng();
346	if (IS_ERR(rng))
347		return PTR_ERR(rng);
348
349	ret = snprintf(buf, PAGE_SIZE, "%s\n", rng ? rng->name : "none");
350	put_rng(rng);
351
352	return ret;
353}
354
355static ssize_t hwrng_attr_available_show(struct device *dev,
356					 struct device_attribute *attr,
357					 char *buf)
358{
359	int err;
360	struct hwrng *rng;
361
362	err = mutex_lock_interruptible(&rng_mutex);
363	if (err)
364		return -ERESTARTSYS;
365	buf[0] = '\0';
366	list_for_each_entry(rng, &rng_list, list) {
367		strlcat(buf, rng->name, PAGE_SIZE);
368		strlcat(buf, " ", PAGE_SIZE);
369	}
370	strlcat(buf, "\n", PAGE_SIZE);
371	mutex_unlock(&rng_mutex);
372
373	return strlen(buf);
374}
375
376static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
377		   hwrng_attr_current_show,
378		   hwrng_attr_current_store);
379static DEVICE_ATTR(rng_available, S_IRUGO,
380		   hwrng_attr_available_show,
381		   NULL);
382
383static struct attribute *rng_dev_attrs[] = {
384	&dev_attr_rng_current.attr,
385	&dev_attr_rng_available.attr,
386	NULL
387};
388
389ATTRIBUTE_GROUPS(rng_dev);
390
391static void __exit unregister_miscdev(void)
392{
393	misc_deregister(&rng_miscdev);
394}
395
396static int __init register_miscdev(void)
397{
398	return misc_register(&rng_miscdev);
399}
400
401static int hwrng_fillfn(void *unused)
402{
403	long rc;
404
405	while (!kthread_should_stop()) {
406		struct hwrng *rng;
407
408		rng = get_current_rng();
409		if (IS_ERR(rng) || !rng)
410			break;
411		mutex_lock(&reading_mutex);
412		rc = rng_get_data(rng, rng_fillbuf,
413				  rng_buffer_size(), 1);
414		mutex_unlock(&reading_mutex);
415		put_rng(rng);
416		if (rc <= 0) {
417			pr_warn("hwrng: no data available\n");
418			msleep_interruptible(10000);
419			continue;
420		}
421		/* Outside lock, sure, but y'know: randomness. */
422		add_hwgenerator_randomness((void *)rng_fillbuf, rc,
423					   rc * current_quality * 8 >> 10);
424	}
425	hwrng_fill = NULL;
426	return 0;
427}
428
429static void start_khwrngd(void)
430{
431	hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
432	if (IS_ERR(hwrng_fill)) {
433		pr_err("hwrng_fill thread creation failed");
434		hwrng_fill = NULL;
435	}
436}
437
438int hwrng_register(struct hwrng *rng)
439{
440	int err = -EINVAL;
441	struct hwrng *old_rng, *tmp;
442
443	if (rng->name == NULL ||
444	    (rng->data_read == NULL && rng->read == NULL))
445		goto out;
446
447	mutex_lock(&rng_mutex);
448
449	/* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
450	err = -ENOMEM;
451	if (!rng_buffer) {
452		rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
453		if (!rng_buffer)
454			goto out_unlock;
455	}
456	if (!rng_fillbuf) {
457		rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
458		if (!rng_fillbuf) {
459			kfree(rng_buffer);
460			goto out_unlock;
461		}
462	}
463
464	/* Must not register two RNGs with the same name. */
465	err = -EEXIST;
466	list_for_each_entry(tmp, &rng_list, list) {
467		if (strcmp(tmp->name, rng->name) == 0)
468			goto out_unlock;
469	}
470
471	init_completion(&rng->cleanup_done);
472	complete(&rng->cleanup_done);
473
474	old_rng = current_rng;
475	err = 0;
476	if (!old_rng) {
477		err = set_current_rng(rng);
478		if (err)
479			goto out_unlock;
480	}
481	list_add_tail(&rng->list, &rng_list);
482
483	if (old_rng && !rng->init) {
484		/*
485		 * Use a new device's input to add some randomness to
486		 * the system.  If this rng device isn't going to be
487		 * used right away, its init function hasn't been
488		 * called yet; so only use the randomness from devices
489		 * that don't need an init callback.
490		 */
491		add_early_randomness(rng);
492	}
493
494out_unlock:
495	mutex_unlock(&rng_mutex);
496out:
497	return err;
498}
499EXPORT_SYMBOL_GPL(hwrng_register);
500
501void hwrng_unregister(struct hwrng *rng)
502{
503	mutex_lock(&rng_mutex);
504
505	list_del(&rng->list);
506	if (current_rng == rng) {
507		drop_current_rng();
508		if (!list_empty(&rng_list)) {
509			struct hwrng *tail;
510
511			tail = list_entry(rng_list.prev, struct hwrng, list);
512
513			set_current_rng(tail);
514		}
515	}
516
517	if (list_empty(&rng_list)) {
518		mutex_unlock(&rng_mutex);
519		if (hwrng_fill)
520			kthread_stop(hwrng_fill);
521	} else
522		mutex_unlock(&rng_mutex);
523
524	wait_for_completion(&rng->cleanup_done);
525}
526EXPORT_SYMBOL_GPL(hwrng_unregister);
527
528static void devm_hwrng_release(struct device *dev, void *res)
529{
530	hwrng_unregister(*(struct hwrng **)res);
531}
532
533static int devm_hwrng_match(struct device *dev, void *res, void *data)
534{
535	struct hwrng **r = res;
536
537	if (WARN_ON(!r || !*r))
538		return 0;
539
540	return *r == data;
541}
542
543int devm_hwrng_register(struct device *dev, struct hwrng *rng)
544{
545	struct hwrng **ptr;
546	int error;
547
548	ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL);
549	if (!ptr)
550		return -ENOMEM;
551
552	error = hwrng_register(rng);
553	if (error) {
554		devres_free(ptr);
555		return error;
556	}
557
558	*ptr = rng;
559	devres_add(dev, ptr);
560	return 0;
561}
562EXPORT_SYMBOL_GPL(devm_hwrng_register);
563
564void devm_hwrng_unregister(struct device *dev, struct hwrng *rng)
565{
566	devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng);
567}
568EXPORT_SYMBOL_GPL(devm_hwrng_unregister);
569
570static int __init hwrng_modinit(void)
571{
572	return register_miscdev();
573}
574
575static void __exit hwrng_modexit(void)
576{
577	mutex_lock(&rng_mutex);
578	BUG_ON(current_rng);
579	kfree(rng_buffer);
580	kfree(rng_fillbuf);
581	mutex_unlock(&rng_mutex);
582
583	unregister_miscdev();
584}
585
586module_init(hwrng_modinit);
587module_exit(hwrng_modexit);
588
589MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
590MODULE_LICENSE("GPL");
591