drivers/usb/misc/chaoskey.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * chaoskey - driver for ChaosKey device from Altus Metrum.
   4  *
   5  * This device provides true random numbers using a noise source based
   6  * on a reverse-biased p-n junction in avalanche breakdown. More
   7  * details can be found at http://chaoskey.org
   8  *
   9  * The driver connects to the kernel hardware RNG interface to provide
  10  * entropy for /dev/random and other kernel activities. It also offers
  11  * a separate /dev/ entry to allow for direct access to the random
  12  * bit stream.
  13  *
  14  * Copyright © 2015 Keith Packard <keithp@keithp.com>
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/usb.h>
  20 #include <linux/wait.h>
  21 #include <linux/hw_random.h>
  22 #include <linux/mutex.h>
  23 #include <linux/uaccess.h>
  24
  25 static struct usb_driver chaoskey_driver;
  26 static struct usb_class_driver chaoskey_class;
  27 static int chaoskey_rng_read(struct hwrng *rng, void *data,
  28                              size_t max, bool wait);
  29
  30 static DEFINE_MUTEX(chaoskey_list_lock);
  31
  32 #define usb_dbg(usb_if, format, arg...) \
  33         dev_dbg(&(usb_if)->dev, format, ## arg)
  34
  35 #define usb_err(usb_if, format, arg...) \
  36         dev_err(&(usb_if)->dev, format, ## arg)
  37
  38 /* Version Information */
  39 #define DRIVER_AUTHOR   "Keith Packard, keithp@keithp.com"
  40 #define DRIVER_DESC     "Altus Metrum ChaosKey driver"
  41 #define DRIVER_SHORT    "chaoskey"
  42
  43 MODULE_AUTHOR(DRIVER_AUTHOR);
  44 MODULE_DESCRIPTION(DRIVER_DESC);
  45 MODULE_LICENSE("GPL");
  46
  47 #define CHAOSKEY_VENDOR_ID      0x1d50  /* OpenMoko */
  48 #define CHAOSKEY_PRODUCT_ID     0x60c6  /* ChaosKey */
  49
  50 #define ALEA_VENDOR_ID          0x12d8  /* Araneus */
  51 #define ALEA_PRODUCT_ID         0x0001  /* Alea I */
  52
  53 #define CHAOSKEY_BUF_LEN        64      /* max size of USB full speed packet */
  54
  55 #define NAK_TIMEOUT (HZ)                /* normal stall/wait timeout */
  56 #define ALEA_FIRST_TIMEOUT (HZ*3)       /* first stall/wait timeout for Alea */
  57
  58 #ifdef CONFIG_USB_DYNAMIC_MINORS
  59 #define USB_CHAOSKEY_MINOR_BASE 0
  60 #else
  61
  62 /* IOWARRIOR_MINOR_BASE + 16, not official yet */
  63 #define USB_CHAOSKEY_MINOR_BASE 224
  64 #endif
  65
  66 static const struct usb_device_id chaoskey_table[] = {
  67         { USB_DEVICE(CHAOSKEY_VENDOR_ID, CHAOSKEY_PRODUCT_ID) },
  68         { USB_DEVICE(ALEA_VENDOR_ID, ALEA_PRODUCT_ID) },
  69         { },
  70 };
  71 MODULE_DEVICE_TABLE(usb, chaoskey_table);
  72
  73 static void chaos_read_callback(struct urb *urb);
  74
  75 /* Driver-local specific stuff */
  76 struct chaoskey {
  77         struct usb_interface *interface;
  78         char in_ep;
  79         struct mutex lock;
  80         struct mutex rng_lock;
  81         int open;                       /* open count */
  82         bool present;                   /* device not disconnected */
  83         bool reading;                   /* ongoing IO */
  84         bool reads_started;             /* track first read for Alea */
  85         int size;                       /* size of buf */
  86         int valid;                      /* bytes of buf read */
  87         int used;                       /* bytes of buf consumed */
  88         char *name;                     /* product + serial */
  89         struct hwrng hwrng;             /* Embedded struct for hwrng */
  90         int hwrng_registered;           /* registered with hwrng API */
  91         wait_queue_head_t wait_q;       /* for timeouts */
  92         struct urb *urb;                /* for performing IO */
  93         char *buf;
  94 };
  95
  96 static void chaoskey_free(struct chaoskey *dev)
  97 {
  98         if (dev) {
  99                 usb_dbg(dev->interface, "free");
 100                 usb_free_urb(dev->urb);
 101                 kfree(dev->name);
 102                 kfree(dev->buf);
 103                 usb_put_intf(dev->interface);
 104                 kfree(dev);
 105         }
 106 }
 107
 108 static int chaoskey_probe(struct usb_interface *interface,
 109                           const struct usb_device_id *id)
 110 {
 111         struct usb_device *udev = interface_to_usbdev(interface);
 112         struct usb_host_interface *altsetting = interface->cur_altsetting;
 113         struct usb_endpoint_descriptor *epd;
 114         int in_ep;
 115         struct chaoskey *dev;
 116         int result = -ENOMEM;
 117         int size;
 118         int res;
 119
 120         usb_dbg(interface, "probe %s-%s", udev->product, udev->serial);
 121
 122         /* Find the first bulk IN endpoint and its packet size */
 123         res = usb_find_bulk_in_endpoint(altsetting, &epd);
 124         if (res) {
 125                 usb_dbg(interface, "no IN endpoint found");
 126                 return res;
 127         }
 128
 129         in_ep = usb_endpoint_num(epd);
 130         size = usb_endpoint_maxp(epd);
 131
 132         /* Validate endpoint and size */
 133         if (size <= 0) {
 134                 usb_dbg(interface, "invalid size (%d)", size);
 135                 return -ENODEV;
 136         }
 137
 138         if (size > CHAOSKEY_BUF_LEN) {
 139                 usb_dbg(interface, "size reduced from %d to %d\n",
 140                         size, CHAOSKEY_BUF_LEN);
 141                 size = CHAOSKEY_BUF_LEN;
 142         }
 143
 144         /* Looks good, allocate and initialize */
 145
 146         dev = kzalloc(sizeof(struct chaoskey), GFP_KERNEL);
 147
 148         if (dev == NULL)
 149                 goto out;
 150
 151         dev->interface = usb_get_intf(interface);
 152
 153         dev->buf = kmalloc(size, GFP_KERNEL);
 154
 155         if (dev->buf == NULL)
 156                 goto out;
 157
 158         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
 159
 160         if (!dev->urb)
 161                 goto out;
 162
 163         usb_fill_bulk_urb(dev->urb,
 164                 udev,
 165                 usb_rcvbulkpipe(udev, in_ep),
 166                 dev->buf,
 167                 size,
 168                 chaos_read_callback,
 169                 dev);
 170
 171         /* Construct a name using the product and serial values. Each
 172          * device needs a unique name for the hwrng code
 173          */
 174
 175         if (udev->product && udev->serial) {
 176                 dev->name = kasprintf(GFP_KERNEL, "%s-%s", udev->product,
 177                                       udev->serial);
 178                 if (dev->name == NULL)
 179                         goto out;
 180         }
 181
 182         dev->in_ep = in_ep;
 183
 184         if (le16_to_cpu(udev->descriptor.idVendor) != ALEA_VENDOR_ID)
 185                 dev->reads_started = true;
 186
 187         dev->size = size;
 188         dev->present = true;
 189
 190         init_waitqueue_head(&dev->wait_q);
 191
 192         mutex_init(&dev->lock);
 193         mutex_init(&dev->rng_lock);
 194
 195         usb_set_intfdata(interface, dev);
 196
 197         result = usb_register_dev(interface, &chaoskey_class);
 198         if (result) {
 199                 usb_err(interface, "Unable to allocate minor number.");
 200                 goto out;
 201         }
 202
 203         dev->hwrng.name = dev->name ? dev->name : chaoskey_driver.name;
 204         dev->hwrng.read = chaoskey_rng_read;
 205
 206         dev->hwrng_registered = (hwrng_register(&dev->hwrng) == 0);
 207         if (!dev->hwrng_registered)
 208                 usb_err(interface, "Unable to register with hwrng");
 209
 210         usb_enable_autosuspend(udev);
 211
 212         usb_dbg(interface, "chaoskey probe success, size %d", dev->size);
 213         return 0;
 214
 215 out:
 216         usb_set_intfdata(interface, NULL);
 217         chaoskey_free(dev);
 218         return result;
 219 }
 220
 221 static void chaoskey_disconnect(struct usb_interface *interface)
 222 {
 223         struct chaoskey *dev;
 224
 225         usb_dbg(interface, "disconnect");
 226         dev = usb_get_intfdata(interface);
 227         if (!dev) {
 228                 usb_dbg(interface, "disconnect failed - no dev");
 229                 return;
 230         }
 231
 232         if (dev->hwrng_registered)
 233                 hwrng_unregister(&dev->hwrng);
 234
 235         usb_deregister_dev(interface, &chaoskey_class);
 236
 237         usb_set_intfdata(interface, NULL);
 238         mutex_lock(&chaoskey_list_lock);
 239         mutex_lock(&dev->lock);
 240
 241         dev->present = false;
 242         usb_poison_urb(dev->urb);
 243
 244         if (!dev->open) {
 245                 mutex_unlock(&dev->lock);
 246                 chaoskey_free(dev);
 247         } else
 248                 mutex_unlock(&dev->lock);
 249
 250         mutex_unlock(&chaoskey_list_lock);
 251         usb_dbg(interface, "disconnect done");
 252 }
 253
 254 static int chaoskey_open(struct inode *inode, struct file *file)
 255 {
 256         struct chaoskey *dev;
 257         struct usb_interface *interface;
 258         int rv = 0;
 259
 260         /* get the interface from minor number and driver information */
 261         interface = usb_find_interface(&chaoskey_driver, iminor(inode));
 262         if (!interface)
 263                 return -ENODEV;
 264
 265         usb_dbg(interface, "open");
 266
 267         dev = usb_get_intfdata(interface);
 268         if (!dev) {
 269                 usb_dbg(interface, "open (dev)");
 270                 return -ENODEV;
 271         }
 272
 273         file->private_data = dev;
 274         mutex_lock(&chaoskey_list_lock);
 275         mutex_lock(&dev->lock);
 276         if (dev->present)
 277                 ++dev->open;
 278         else
 279                 rv = -ENODEV;
 280         mutex_unlock(&dev->lock);
 281         mutex_unlock(&chaoskey_list_lock);
 282
 283         return rv;
 284 }
 285
 286 static int chaoskey_release(struct inode *inode, struct file *file)
 287 {
 288         struct chaoskey *dev = file->private_data;
 289         struct usb_interface *interface;
 290         int rv = 0;
 291
 292         if (dev == NULL)
 293                 return -ENODEV;
 294
 295         interface = dev->interface;
 296
 297         usb_dbg(interface, "release");
 298
 299         mutex_lock(&chaoskey_list_lock);
 300         mutex_lock(&dev->lock);
 301
 302         usb_dbg(interface, "open count at release is %d", dev->open);
 303
 304         if (dev->open <= 0) {
 305                 usb_dbg(interface, "invalid open count (%d)", dev->open);
 306                 rv = -ENODEV;
 307                 goto bail;
 308         }
 309
 310         --dev->open;
 311
 312         if (!dev->present) {
 313                 if (dev->open == 0) {
 314                         mutex_unlock(&dev->lock);
 315                         chaoskey_free(dev);
 316                         goto destruction;
 317                 }
 318         }
 319 bail:
 320         mutex_unlock(&dev->lock);
 321 destruction:
 322         mutex_unlock(&chaoskey_list_lock);
 323         usb_dbg(interface, "release success");
 324         return rv;
 325 }
 326
 327 static void chaos_read_callback(struct urb *urb)
 328 {
 329         struct chaoskey *dev = urb->context;
 330         int status = urb->status;
 331
 332         usb_dbg(dev->interface, "callback status (%d)", status);
 333
 334         if (status == 0)
 335                 dev->valid = urb->actual_length;
 336         else
 337                 dev->valid = 0;
 338
 339         dev->used = 0;
 340
 341         /* must be seen first before validity is announced */
 342         smp_wmb();
 343
 344         dev->reading = false;
 345         wake_up(&dev->wait_q);
 346 }
 347
 348 /* Fill the buffer. Called with dev->lock held
 349  */
 350 static int _chaoskey_fill(struct chaoskey *dev)
 351 {
 352         DEFINE_WAIT(wait);
 353         int result;
 354         bool started;
 355
 356         usb_dbg(dev->interface, "fill");
 357
 358         /* Return immediately if someone called before the buffer was
 359          * empty */
 360         if (dev->valid != dev->used) {
 361                 usb_dbg(dev->interface, "not empty yet (valid %d used %d)",
 362                         dev->valid, dev->used);
 363                 return 0;
 364         }
 365
 366         /* Bail if the device has been removed */
 367         if (!dev->present) {
 368                 usb_dbg(dev->interface, "device not present");
 369                 return -ENODEV;
 370         }
 371
 372         /* Make sure the device is awake */
 373         result = usb_autopm_get_interface(dev->interface);
 374         if (result) {
 375                 usb_dbg(dev->interface, "wakeup failed (result %d)", result);
 376                 return result;
 377         }
 378
 379         dev->reading = true;
 380         result = usb_submit_urb(dev->urb, GFP_KERNEL);
 381         if (result < 0) {
 382                 result = usb_translate_errors(result);
 383                 dev->reading = false;
 384                 goto out;
 385         }
 386
 387         /* The first read on the Alea takes a little under 2 seconds.
 388          * Reads after the first read take only a few microseconds
 389          * though.  Presumably the entropy-generating circuit needs
 390          * time to ramp up.  So, we wait longer on the first read.
 391          */
 392         started = dev->reads_started;
 393         dev->reads_started = true;
 394         result = wait_event_interruptible_timeout(
 395                 dev->wait_q,
 396                 !dev->reading,
 397                 (started ? NAK_TIMEOUT : ALEA_FIRST_TIMEOUT) );
 398
 399         if (result < 0) {
 400                 usb_kill_urb(dev->urb);
 401                 goto out;
 402         }
 403
 404         if (result == 0) {
 405                 result = -ETIMEDOUT;
 406                 usb_kill_urb(dev->urb);
 407         } else {
 408                 result = dev->valid;
 409         }
 410 out:
 411         /* Let the device go back to sleep eventually */
 412         usb_autopm_put_interface(dev->interface);
 413
 414         usb_dbg(dev->interface, "read %d bytes", dev->valid);
 415
 416         return result;
 417 }
 418
 419 static ssize_t chaoskey_read(struct file *file,
 420                              char __user *buffer,
 421                              size_t count,
 422                              loff_t *ppos)
 423 {
 424         struct chaoskey *dev;
 425         ssize_t read_count = 0;
 426         int this_time;
 427         int result = 0;
 428         unsigned long remain;
 429
 430         dev = file->private_data;
 431
 432         if (dev == NULL || !dev->present)
 433                 return -ENODEV;
 434
 435         usb_dbg(dev->interface, "read %zu", count);
 436
 437         while (count > 0) {
 438
 439                 /* Grab the rng_lock briefly to ensure that the hwrng interface
 440                  * gets priority over other user access
 441                  */
 442                 result = mutex_lock_interruptible(&dev->rng_lock);
 443                 if (result)
 444                         goto bail;
 445                 mutex_unlock(&dev->rng_lock);
 446
 447                 result = mutex_lock_interruptible(&dev->lock);
 448                 if (result)
 449                         goto bail;
 450                 if (dev->valid == dev->used) {
 451                         result = _chaoskey_fill(dev);
 452                         if (result < 0) {
 453                                 mutex_unlock(&dev->lock);
 454                                 goto bail;
 455                         }
 456                 }
 457
 458                 this_time = dev->valid - dev->used;
 459                 if (this_time > count)
 460                         this_time = count;
 461
 462                 remain = copy_to_user(buffer, dev->buf + dev->used, this_time);
 463                 if (remain) {
 464                         result = -EFAULT;
 465
 466                         /* Consume the bytes that were copied so we don't leak
 467                          * data to user space
 468                          */
 469                         dev->used += this_time - remain;
 470                         mutex_unlock(&dev->lock);
 471                         goto bail;
 472                 }
 473
 474                 count -= this_time;
 475                 read_count += this_time;
 476                 buffer += this_time;
 477                 dev->used += this_time;
 478                 mutex_unlock(&dev->lock);
 479         }
 480 bail:
 481         if (read_count) {
 482                 usb_dbg(dev->interface, "read %zu bytes", read_count);
 483                 return read_count;
 484         }
 485         usb_dbg(dev->interface, "empty read, result %d", result);
 486         if (result == -ETIMEDOUT)
 487                 result = -EAGAIN;
 488         return result;
 489 }
 490
 491 static int chaoskey_rng_read(struct hwrng *rng, void *data,
 492                              size_t max, bool wait)
 493 {
 494         struct chaoskey *dev = container_of(rng, struct chaoskey, hwrng);
 495         int this_time;
 496
 497         usb_dbg(dev->interface, "rng_read max %zu wait %d", max, wait);
 498
 499         if (!dev->present) {
 500                 usb_dbg(dev->interface, "device not present");
 501                 return 0;
 502         }
 503
 504         /* Hold the rng_lock until we acquire the device lock so that
 505          * this operation gets priority over other user access to the
 506          * device
 507          */
 508         mutex_lock(&dev->rng_lock);
 509
 510         mutex_lock(&dev->lock);
 511
 512         mutex_unlock(&dev->rng_lock);
 513
 514         /* Try to fill the buffer if empty. It doesn't actually matter
 515          * if _chaoskey_fill works; we'll just return zero bytes as
 516          * the buffer will still be empty
 517          */
 518         if (dev->valid == dev->used)
 519                 (void) _chaoskey_fill(dev);
 520
 521         this_time = dev->valid - dev->used;
 522         if (this_time > max)
 523                 this_time = max;
 524
 525         memcpy(data, dev->buf + dev->used, this_time);
 526
 527         dev->used += this_time;
 528
 529         mutex_unlock(&dev->lock);
 530
 531         usb_dbg(dev->interface, "rng_read this_time %d\n", this_time);
 532         return this_time;
 533 }
 534
 535 #ifdef CONFIG_PM
 536 static int chaoskey_suspend(struct usb_interface *interface,
 537                             pm_message_t message)
 538 {
 539         usb_dbg(interface, "suspend");
 540         return 0;
 541 }
 542
 543 static int chaoskey_resume(struct usb_interface *interface)
 544 {
 545         struct chaoskey *dev;
 546         struct usb_device *udev = interface_to_usbdev(interface);
 547
 548         usb_dbg(interface, "resume");
 549         dev = usb_get_intfdata(interface);
 550
 551         /*
 552          * We may have lost power.
 553          * In that case the device that needs a long time
 554          * for the first requests needs an extended timeout
 555          * again
 556          */
 557         if (le16_to_cpu(udev->descriptor.idVendor) == ALEA_VENDOR_ID)
 558                 dev->reads_started = false;
 559
 560         return 0;
 561 }
 562 #else
 563 #define chaoskey_suspend NULL
 564 #define chaoskey_resume NULL
 565 #endif
 566
 567 /* file operation pointers */
 568 static const struct file_operations chaoskey_fops = {
 569         .owner = THIS_MODULE,
 570         .read = chaoskey_read,
 571         .open = chaoskey_open,
 572         .release = chaoskey_release,
 573         .llseek = default_llseek,
 574 };
 575
 576 /* class driver information */
 577 static struct usb_class_driver chaoskey_class = {
 578         .name = "chaoskey%d",
 579         .fops = &chaoskey_fops,
 580         .minor_base = USB_CHAOSKEY_MINOR_BASE,
 581 };
 582
 583 /* usb specific object needed to register this driver with the usb subsystem */
 584 static struct usb_driver chaoskey_driver = {
 585         .name = DRIVER_SHORT,
 586         .probe = chaoskey_probe,
 587         .disconnect = chaoskey_disconnect,
 588         .suspend = chaoskey_suspend,
 589         .resume = chaoskey_resume,
 590         .reset_resume = chaoskey_resume,
 591         .id_table = chaoskey_table,
 592         .supports_autosuspend = 1,
 593 };
 594
 595 module_usb_driver(chaoskey_driver);
 596