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, 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