xref: /openbmc/linux/drivers/usb/misc/chaoskey.c (revision 9cfc5c90) 
1 /*
2  * chaoskey - driver for ChaosKey device from Altus Metrum.
3  *
4  * This device provides true random numbers using a noise source based
5  * on a reverse-biased p-n junction in avalanche breakdown. More
6  * details can be found at http://chaoskey.org
7  *
8  * The driver connects to the kernel hardware RNG interface to provide
9  * entropy for /dev/random and other kernel activities. It also offers
10  * a separate /dev/ entry to allow for direct access to the random
11  * bit stream.
12  *
13  * Copyright © 2015 Keith Packard <keithp@keithp.com>
14  *
15  * This program is free software; you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation; version 2 of the License.
18  *
19  * This program is distributed in the hope that it will be useful, but
20  * WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
22  * General Public License for more details.
23  */
24 
25 #include <linux/module.h>
26 #include <linux/slab.h>
27 #include <linux/usb.h>
28 #include <linux/wait.h>
29 #include <linux/hw_random.h>
30 #include <linux/mutex.h>
31 #include <linux/uaccess.h>
32 
33 static struct usb_driver chaoskey_driver;
34 static struct usb_class_driver chaoskey_class;
35 static int chaoskey_rng_read(struct hwrng *rng, void *data,
36 			     size_t max, bool wait);
37 
38 #define usb_dbg(usb_if, format, arg...) \
39 	dev_dbg(&(usb_if)->dev, format, ## arg)
40 
41 #define usb_err(usb_if, format, arg...) \
42 	dev_err(&(usb_if)->dev, format, ## arg)
43 
44 /* Version Information */
45 #define DRIVER_VERSION	"v0.1"
46 #define DRIVER_AUTHOR	"Keith Packard, keithp@keithp.com"
47 #define DRIVER_DESC	"Altus Metrum ChaosKey driver"
48 #define DRIVER_SHORT	"chaoskey"
49 
50 MODULE_VERSION(DRIVER_VERSION);
51 MODULE_AUTHOR(DRIVER_AUTHOR);
52 MODULE_DESCRIPTION(DRIVER_DESC);
53 MODULE_LICENSE("GPL");
54 
55 #define CHAOSKEY_VENDOR_ID	0x1d50	/* OpenMoko */
56 #define CHAOSKEY_PRODUCT_ID	0x60c6	/* ChaosKey */
57 
58 #define CHAOSKEY_BUF_LEN	64	/* max size of USB full speed packet */
59 
60 #define NAK_TIMEOUT (HZ)		/* stall/wait timeout for device */
61 
62 #ifdef CONFIG_USB_DYNAMIC_MINORS
63 #define USB_CHAOSKEY_MINOR_BASE 0
64 #else
65 
66 /* IOWARRIOR_MINOR_BASE + 16, not official yet */
67 #define USB_CHAOSKEY_MINOR_BASE 224
68 #endif
69 
70 static const struct usb_device_id chaoskey_table[] = {
71 	{ USB_DEVICE(CHAOSKEY_VENDOR_ID, CHAOSKEY_PRODUCT_ID) },
72 	{ },
73 };
74 MODULE_DEVICE_TABLE(usb, chaoskey_table);
75 
76 /* Driver-local specific stuff */
77 struct chaoskey {
78 	struct usb_interface *interface;
79 	char in_ep;
80 	struct mutex lock;
81 	struct mutex rng_lock;
82 	int open;			/* open count */
83 	int present;			/* device not disconnected */
84 	int size;			/* size of buf */
85 	int valid;			/* bytes of buf read */
86 	int used;			/* bytes of buf consumed */
87 	char *name;			/* product + serial */
88 	struct hwrng hwrng;		/* Embedded struct for hwrng */
89 	int hwrng_registered;		/* registered with hwrng API */
90 	wait_queue_head_t wait_q;	/* for timeouts */
91 	char *buf;
92 };
93 
94 static void chaoskey_free(struct chaoskey *dev)
95 {
96 	usb_dbg(dev->interface, "free");
97 	kfree(dev->name);
98 	kfree(dev->buf);
99 	kfree(dev);
100 }
101 
102 static int chaoskey_probe(struct usb_interface *interface,
103 			  const struct usb_device_id *id)
104 {
105 	struct usb_device *udev = interface_to_usbdev(interface);
106 	struct usb_host_interface *altsetting = interface->cur_altsetting;
107 	int i;
108 	int in_ep = -1;
109 	struct chaoskey *dev;
110 	int result;
111 	int size;
112 
113 	usb_dbg(interface, "probe %s-%s", udev->product, udev->serial);
114 
115 	/* Find the first bulk IN endpoint and its packet size */
116 	for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
117 		if (usb_endpoint_is_bulk_in(&altsetting->endpoint[i].desc)) {
118 			in_ep = usb_endpoint_num(&altsetting->endpoint[i].desc);
119 			size = usb_endpoint_maxp(&altsetting->endpoint[i].desc);
120 			break;
121 		}
122 	}
123 
124 	/* Validate endpoint and size */
125 	if (in_ep == -1) {
126 		usb_dbg(interface, "no IN endpoint found");
127 		return -ENODEV;
128 	}
129 	if (size <= 0) {
130 		usb_dbg(interface, "invalid size (%d)", size);
131 		return -ENODEV;
132 	}
133 
134 	if (size > CHAOSKEY_BUF_LEN) {
135 		usb_dbg(interface, "size reduced from %d to %d\n",
136 			size, CHAOSKEY_BUF_LEN);
137 		size = CHAOSKEY_BUF_LEN;
138 	}
139 
140 	/* Looks good, allocate and initialize */
141 
142 	dev = kzalloc(sizeof(struct chaoskey), GFP_KERNEL);
143 
144 	if (dev == NULL)
145 		return -ENOMEM;
146 
147 	dev->buf = kmalloc(size, GFP_KERNEL);
148 
149 	if (dev->buf == NULL) {
150 		kfree(dev);
151 		return -ENOMEM;
152 	}
153 
154 	/* Construct a name using the product and serial values. Each
155 	 * device needs a unique name for the hwrng code
156 	 */
157 
158 	if (udev->product && udev->serial) {
159 		dev->name = kmalloc(strlen(udev->product) + 1 +
160 				    strlen(udev->serial) + 1, GFP_KERNEL);
161 		if (dev->name == NULL) {
162 			kfree(dev->buf);
163 			kfree(dev);
164 			return -ENOMEM;
165 		}
166 
167 		strcpy(dev->name, udev->product);
168 		strcat(dev->name, "-");
169 		strcat(dev->name, udev->serial);
170 	}
171 
172 	dev->interface = interface;
173 
174 	dev->in_ep = in_ep;
175 
176 	dev->size = size;
177 	dev->present = 1;
178 
179 	init_waitqueue_head(&dev->wait_q);
180 
181 	mutex_init(&dev->lock);
182 	mutex_init(&dev->rng_lock);
183 
184 	usb_set_intfdata(interface, dev);
185 
186 	result = usb_register_dev(interface, &chaoskey_class);
187 	if (result) {
188 		usb_err(interface, "Unable to allocate minor number.");
189 		usb_set_intfdata(interface, NULL);
190 		chaoskey_free(dev);
191 		return result;
192 	}
193 
194 	dev->hwrng.name = dev->name ? dev->name : chaoskey_driver.name;
195 	dev->hwrng.read = chaoskey_rng_read;
196 
197 	/* Set the 'quality' metric.  Quality is measured in units of
198 	 * 1/1024's of a bit ("mills"). This should be set to 1024,
199 	 * but there is a bug in the hwrng core which masks it with
200 	 * 1023.
201 	 *
202 	 * The patch that has been merged to the crypto development
203 	 * tree for that bug limits the value to 1024 at most, so by
204 	 * setting this to 1024 + 1023, we get 1023 before the fix is
205 	 * merged and 1024 afterwards. We'll patch this driver once
206 	 * both bits of code are in the same tree.
207 	 */
208 	dev->hwrng.quality = 1024 + 1023;
209 
210 	dev->hwrng_registered = (hwrng_register(&dev->hwrng) == 0);
211 	if (!dev->hwrng_registered)
212 		usb_err(interface, "Unable to register with hwrng");
213 
214 	usb_enable_autosuspend(udev);
215 
216 	usb_dbg(interface, "chaoskey probe success, size %d", dev->size);
217 	return 0;
218 }
219 
220 static void chaoskey_disconnect(struct usb_interface *interface)
221 {
222 	struct chaoskey	*dev;
223 
224 	usb_dbg(interface, "disconnect");
225 	dev = usb_get_intfdata(interface);
226 	if (!dev) {
227 		usb_dbg(interface, "disconnect failed - no dev");
228 		return;
229 	}
230 
231 	if (dev->hwrng_registered)
232 		hwrng_unregister(&dev->hwrng);
233 
234 	usb_deregister_dev(interface, &chaoskey_class);
235 
236 	usb_set_intfdata(interface, NULL);
237 	mutex_lock(&dev->lock);
238 
239 	dev->present = 0;
240 
241 	if (!dev->open) {
242 		mutex_unlock(&dev->lock);
243 		chaoskey_free(dev);
244 	} else
245 		mutex_unlock(&dev->lock);
246 
247 	usb_dbg(interface, "disconnect done");
248 }
249 
250 static int chaoskey_open(struct inode *inode, struct file *file)
251 {
252 	struct chaoskey *dev;
253 	struct usb_interface *interface;
254 
255 	/* get the interface from minor number and driver information */
256 	interface = usb_find_interface(&chaoskey_driver, iminor(inode));
257 	if (!interface)
258 		return -ENODEV;
259 
260 	usb_dbg(interface, "open");
261 
262 	dev = usb_get_intfdata(interface);
263 	if (!dev) {
264 		usb_dbg(interface, "open (dev)");
265 		return -ENODEV;
266 	}
267 
268 	file->private_data = dev;
269 	mutex_lock(&dev->lock);
270 	++dev->open;
271 	mutex_unlock(&dev->lock);
272 
273 	usb_dbg(interface, "open success");
274 	return 0;
275 }
276 
277 static int chaoskey_release(struct inode *inode, struct file *file)
278 {
279 	struct chaoskey *dev = file->private_data;
280 	struct usb_interface *interface;
281 
282 	if (dev == NULL)
283 		return -ENODEV;
284 
285 	interface = dev->interface;
286 
287 	usb_dbg(interface, "release");
288 
289 	mutex_lock(&dev->lock);
290 
291 	usb_dbg(interface, "open count at release is %d", dev->open);
292 
293 	if (dev->open <= 0) {
294 		usb_dbg(interface, "invalid open count (%d)", dev->open);
295 		mutex_unlock(&dev->lock);
296 		return -ENODEV;
297 	}
298 
299 	--dev->open;
300 
301 	if (!dev->present) {
302 		if (dev->open == 0) {
303 			mutex_unlock(&dev->lock);
304 			chaoskey_free(dev);
305 		} else
306 			mutex_unlock(&dev->lock);
307 	} else
308 		mutex_unlock(&dev->lock);
309 
310 	usb_dbg(interface, "release success");
311 	return 0;
312 }
313 
314 /* Fill the buffer. Called with dev->lock held
315  */
316 static int _chaoskey_fill(struct chaoskey *dev)
317 {
318 	DEFINE_WAIT(wait);
319 	int result;
320 	int this_read;
321 	struct usb_device *udev = interface_to_usbdev(dev->interface);
322 
323 	usb_dbg(dev->interface, "fill");
324 
325 	/* Return immediately if someone called before the buffer was
326 	 * empty */
327 	if (dev->valid != dev->used) {
328 		usb_dbg(dev->interface, "not empty yet (valid %d used %d)",
329 			dev->valid, dev->used);
330 		return 0;
331 	}
332 
333 	/* Bail if the device has been removed */
334 	if (!dev->present) {
335 		usb_dbg(dev->interface, "device not present");
336 		return -ENODEV;
337 	}
338 
339 	/* Make sure the device is awake */
340 	result = usb_autopm_get_interface(dev->interface);
341 	if (result) {
342 		usb_dbg(dev->interface, "wakeup failed (result %d)", result);
343 		return result;
344 	}
345 
346 	result = usb_bulk_msg(udev,
347 			      usb_rcvbulkpipe(udev, dev->in_ep),
348 			      dev->buf, dev->size, &this_read,
349 			      NAK_TIMEOUT);
350 
351 	/* Let the device go back to sleep eventually */
352 	usb_autopm_put_interface(dev->interface);
353 
354 	if (result == 0) {
355 		dev->valid = this_read;
356 		dev->used = 0;
357 	}
358 
359 	usb_dbg(dev->interface, "bulk_msg result %d this_read %d",
360 		result, this_read);
361 
362 	return result;
363 }
364 
365 static ssize_t chaoskey_read(struct file *file,
366 			     char __user *buffer,
367 			     size_t count,
368 			     loff_t *ppos)
369 {
370 	struct chaoskey *dev;
371 	ssize_t read_count = 0;
372 	int this_time;
373 	int result = 0;
374 	unsigned long remain;
375 
376 	dev = file->private_data;
377 
378 	if (dev == NULL || !dev->present)
379 		return -ENODEV;
380 
381 	usb_dbg(dev->interface, "read %zu", count);
382 
383 	while (count > 0) {
384 
385 		/* Grab the rng_lock briefly to ensure that the hwrng interface
386 		 * gets priority over other user access
387 		 */
388 		result = mutex_lock_interruptible(&dev->rng_lock);
389 		if (result)
390 			goto bail;
391 		mutex_unlock(&dev->rng_lock);
392 
393 		result = mutex_lock_interruptible(&dev->lock);
394 		if (result)
395 			goto bail;
396 		if (dev->valid == dev->used) {
397 			result = _chaoskey_fill(dev);
398 			if (result) {
399 				mutex_unlock(&dev->lock);
400 				goto bail;
401 			}
402 
403 			/* Read returned zero bytes */
404 			if (dev->used == dev->valid) {
405 				mutex_unlock(&dev->lock);
406 				goto bail;
407 			}
408 		}
409 
410 		this_time = dev->valid - dev->used;
411 		if (this_time > count)
412 			this_time = count;
413 
414 		remain = copy_to_user(buffer, dev->buf + dev->used, this_time);
415 		if (remain) {
416 			result = -EFAULT;
417 
418 			/* Consume the bytes that were copied so we don't leak
419 			 * data to user space
420 			 */
421 			dev->used += this_time - remain;
422 			mutex_unlock(&dev->lock);
423 			goto bail;
424 		}
425 
426 		count -= this_time;
427 		read_count += this_time;
428 		buffer += this_time;
429 		dev->used += this_time;
430 		mutex_unlock(&dev->lock);
431 	}
432 bail:
433 	if (read_count) {
434 		usb_dbg(dev->interface, "read %zu bytes", read_count);
435 		return read_count;
436 	}
437 	usb_dbg(dev->interface, "empty read, result %d", result);
438 	return result;
439 }
440 
441 static int chaoskey_rng_read(struct hwrng *rng, void *data,
442 			     size_t max, bool wait)
443 {
444 	struct chaoskey *dev = container_of(rng, struct chaoskey, hwrng);
445 	int this_time;
446 
447 	usb_dbg(dev->interface, "rng_read max %zu wait %d", max, wait);
448 
449 	if (!dev->present) {
450 		usb_dbg(dev->interface, "device not present");
451 		return 0;
452 	}
453 
454 	/* Hold the rng_lock until we acquire the device lock so that
455 	 * this operation gets priority over other user access to the
456 	 * device
457 	 */
458 	mutex_lock(&dev->rng_lock);
459 
460 	mutex_lock(&dev->lock);
461 
462 	mutex_unlock(&dev->rng_lock);
463 
464 	/* Try to fill the buffer if empty. It doesn't actually matter
465 	 * if _chaoskey_fill works; we'll just return zero bytes as
466 	 * the buffer will still be empty
467 	 */
468 	if (dev->valid == dev->used)
469 		(void) _chaoskey_fill(dev);
470 
471 	this_time = dev->valid - dev->used;
472 	if (this_time > max)
473 		this_time = max;
474 
475 	memcpy(data, dev->buf + dev->used, this_time);
476 
477 	dev->used += this_time;
478 
479 	mutex_unlock(&dev->lock);
480 
481 	usb_dbg(dev->interface, "rng_read this_time %d\n", this_time);
482 	return this_time;
483 }
484 
485 #ifdef CONFIG_PM
486 static int chaoskey_suspend(struct usb_interface *interface,
487 			    pm_message_t message)
488 {
489 	usb_dbg(interface, "suspend");
490 	return 0;
491 }
492 
493 static int chaoskey_resume(struct usb_interface *interface)
494 {
495 	usb_dbg(interface, "resume");
496 	return 0;
497 }
498 #else
499 #define chaoskey_suspend NULL
500 #define chaoskey_resume NULL
501 #endif
502 
503 /* file operation pointers */
504 static const struct file_operations chaoskey_fops = {
505 	.owner = THIS_MODULE,
506 	.read = chaoskey_read,
507 	.open = chaoskey_open,
508 	.release = chaoskey_release,
509 	.llseek = default_llseek,
510 };
511 
512 /* class driver information */
513 static struct usb_class_driver chaoskey_class = {
514 	.name = "chaoskey%d",
515 	.fops = &chaoskey_fops,
516 	.minor_base = USB_CHAOSKEY_MINOR_BASE,
517 };
518 
519 /* usb specific object needed to register this driver with the usb subsystem */
520 static struct usb_driver chaoskey_driver = {
521 	.name = DRIVER_SHORT,
522 	.probe = chaoskey_probe,
523 	.disconnect = chaoskey_disconnect,
524 	.suspend = chaoskey_suspend,
525 	.resume = chaoskey_resume,
526 	.reset_resume = chaoskey_resume,
527 	.id_table = chaoskey_table,
528 	.supports_autosuspend = 1,
529 };
530 
531 module_usb_driver(chaoskey_driver);
532 
533