Lines Matching refs:dev
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
31 dev_dbg(&(usb_if)->dev, format, ## arg)
34 dev_err(&(usb_if)->dev, format, ## arg)
94 static void chaoskey_free(struct chaoskey *dev)
96 if (dev) {
97 usb_dbg(dev->interface, "free");
98 usb_free_urb(dev->urb);
99 kfree(dev->name);
100 kfree(dev->buf);
101 usb_put_intf(dev->interface);
102 kfree(dev);
113 struct chaoskey *dev;
144 dev = kzalloc(sizeof(struct chaoskey), GFP_KERNEL);
146 if (dev == NULL)
149 dev->interface = usb_get_intf(interface);
151 dev->buf = kmalloc(size, GFP_KERNEL);
153 if (dev->buf == NULL)
156 dev->urb = usb_alloc_urb(0, GFP_KERNEL);
158 if (!dev->urb)
161 usb_fill_bulk_urb(dev->urb,
164 dev->buf,
167 dev);
174 dev->name = kasprintf(GFP_KERNEL, "%s-%s", udev->product,
176 if (dev->name == NULL)
180 dev->in_ep = in_ep;
183 dev->reads_started = true;
185 dev->size = size;
186 dev->present = true;
188 init_waitqueue_head(&dev->wait_q);
190 mutex_init(&dev->lock);
191 mutex_init(&dev->rng_lock);
193 usb_set_intfdata(interface, dev);
201 dev->hwrng.name = dev->name ? dev->name : chaoskey_driver.name;
202 dev->hwrng.read = chaoskey_rng_read;
204 dev->hwrng_registered = (hwrng_register(&dev->hwrng) == 0);
205 if (!dev->hwrng_registered)
210 usb_dbg(interface, "chaoskey probe success, size %d", dev->size);
215 chaoskey_free(dev);
221 struct chaoskey *dev;
224 dev = usb_get_intfdata(interface);
225 if (!dev) {
226 usb_dbg(interface, "disconnect failed - no dev");
230 if (dev->hwrng_registered)
231 hwrng_unregister(&dev->hwrng);
236 mutex_lock(&dev->lock);
238 dev->present = false;
239 usb_poison_urb(dev->urb);
241 if (!dev->open) {
242 mutex_unlock(&dev->lock);
243 chaoskey_free(dev);
245 mutex_unlock(&dev->lock);
252 struct chaoskey *dev;
262 dev = usb_get_intfdata(interface);
263 if (!dev) {
264 usb_dbg(interface, "open (dev)");
268 file->private_data = dev;
269 mutex_lock(&dev->lock);
270 ++dev->open;
271 mutex_unlock(&dev->lock);
279 struct chaoskey *dev = file->private_data;
282 if (dev == NULL)
285 interface = dev->interface;
289 mutex_lock(&dev->lock);
291 usb_dbg(interface, "open count at release is %d", dev->open);
293 if (dev->open <= 0) {
294 usb_dbg(interface, "invalid open count (%d)", dev->open);
295 mutex_unlock(&dev->lock);
299 --dev->open;
301 if (!dev->present) {
302 if (dev->open == 0) {
303 mutex_unlock(&dev->lock);
304 chaoskey_free(dev);
306 mutex_unlock(&dev->lock);
308 mutex_unlock(&dev->lock);
316 struct chaoskey *dev = urb->context;
319 usb_dbg(dev->interface, "callback status (%d)", status);
322 dev->valid = urb->actual_length;
324 dev->valid = 0;
326 dev->used = 0;
331 dev->reading = false;
332 wake_up(&dev->wait_q);
335 /* Fill the buffer. Called with dev->lock held
337 static int _chaoskey_fill(struct chaoskey *dev)
343 usb_dbg(dev->interface, "fill");
347 if (dev->valid != dev->used) {
348 usb_dbg(dev->interface, "not empty yet (valid %d used %d)",
349 dev->valid, dev->used);
354 if (!dev->present) {
355 usb_dbg(dev->interface, "device not present");
360 result = usb_autopm_get_interface(dev->interface);
362 usb_dbg(dev->interface, "wakeup failed (result %d)", result);
366 dev->reading = true;
367 result = usb_submit_urb(dev->urb, GFP_KERNEL);
370 dev->reading = false;
379 started = dev->reads_started;
380 dev->reads_started = true;
382 dev->wait_q,
383 !dev->reading,
387 usb_kill_urb(dev->urb);
393 usb_kill_urb(dev->urb);
395 result = dev->valid;
399 usb_autopm_put_interface(dev->interface);
401 usb_dbg(dev->interface, "read %d bytes", dev->valid);
411 struct chaoskey *dev;
417 dev = file->private_data;
419 if (dev == NULL || !dev->present)
422 usb_dbg(dev->interface, "read %zu", count);
429 result = mutex_lock_interruptible(&dev->rng_lock);
432 mutex_unlock(&dev->rng_lock);
434 result = mutex_lock_interruptible(&dev->lock);
437 if (dev->valid == dev->used) {
438 result = _chaoskey_fill(dev);
440 mutex_unlock(&dev->lock);
445 this_time = dev->valid - dev->used;
449 remain = copy_to_user(buffer, dev->buf + dev->used, this_time);
456 dev->used += this_time - remain;
457 mutex_unlock(&dev->lock);
464 dev->used += this_time;
465 mutex_unlock(&dev->lock);
469 usb_dbg(dev->interface, "read %zu bytes", read_count);
472 usb_dbg(dev->interface, "empty read, result %d", result);
481 struct chaoskey *dev = container_of(rng, struct chaoskey, hwrng);
484 usb_dbg(dev->interface, "rng_read max %zu wait %d", max, wait);
486 if (!dev->present) {
487 usb_dbg(dev->interface, "device not present");
495 mutex_lock(&dev->rng_lock);
497 mutex_lock(&dev->lock);
499 mutex_unlock(&dev->rng_lock);
505 if (dev->valid == dev->used)
506 (void) _chaoskey_fill(dev);
508 this_time = dev->valid - dev->used;
512 memcpy(data, dev->buf + dev->used, this_time);
514 dev->used += this_time;
516 mutex_unlock(&dev->lock);
518 usb_dbg(dev->interface, "rng_read this_time %d\n", this_time);
532 struct chaoskey *dev;
536 dev = usb_get_intfdata(interface);
545 dev->reads_started = false;