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;
203 dev->hwrng.quality = 1024;
205 dev->hwrng_registered = (hwrng_register(&dev->hwrng) == 0);
206 if (!dev->hwrng_registered)
211 usb_dbg(interface, "chaoskey probe success, size %d", dev->size);
216 chaoskey_free(dev);
222 struct chaoskey *dev;
225 dev = usb_get_intfdata(interface);
226 if (!dev) {
227 usb_dbg(interface, "disconnect failed - no dev");
231 if (dev->hwrng_registered)
232 hwrng_unregister(&dev->hwrng);
237 mutex_lock(&dev->lock);
239 dev->present = false;
240 usb_poison_urb(dev->urb);
242 if (!dev->open) {
243 mutex_unlock(&dev->lock);
244 chaoskey_free(dev);
246 mutex_unlock(&dev->lock);
253 struct chaoskey *dev;
263 dev = usb_get_intfdata(interface);
264 if (!dev) {
265 usb_dbg(interface, "open (dev)");
269 file->private_data = dev;
270 mutex_lock(&dev->lock);
271 ++dev->open;
272 mutex_unlock(&dev->lock);
280 struct chaoskey *dev = file->private_data;
283 if (dev == NULL)
286 interface = dev->interface;
290 mutex_lock(&dev->lock);
292 usb_dbg(interface, "open count at release is %d", dev->open);
294 if (dev->open <= 0) {
295 usb_dbg(interface, "invalid open count (%d)", dev->open);
296 mutex_unlock(&dev->lock);
300 --dev->open;
302 if (!dev->present) {
303 if (dev->open == 0) {
304 mutex_unlock(&dev->lock);
305 chaoskey_free(dev);
307 mutex_unlock(&dev->lock);
309 mutex_unlock(&dev->lock);
317 struct chaoskey *dev = urb->context;
320 usb_dbg(dev->interface, "callback status (%d)", status);
323 dev->valid = urb->actual_length;
325 dev->valid = 0;
327 dev->used = 0;
332 dev->reading = false;
333 wake_up(&dev->wait_q);
336 /* Fill the buffer. Called with dev->lock held
338 static int _chaoskey_fill(struct chaoskey *dev)
344 usb_dbg(dev->interface, "fill");
348 if (dev->valid != dev->used) {
349 usb_dbg(dev->interface, "not empty yet (valid %d used %d)",
350 dev->valid, dev->used);
355 if (!dev->present) {
356 usb_dbg(dev->interface, "device not present");
361 result = usb_autopm_get_interface(dev->interface);
363 usb_dbg(dev->interface, "wakeup failed (result %d)", result);
367 dev->reading = true;
368 result = usb_submit_urb(dev->urb, GFP_KERNEL);
371 dev->reading = false;
380 started = dev->reads_started;
381 dev->reads_started = true;
383 dev->wait_q,
384 !dev->reading,
388 usb_kill_urb(dev->urb);
394 usb_kill_urb(dev->urb);
396 result = dev->valid;
400 usb_autopm_put_interface(dev->interface);
402 usb_dbg(dev->interface, "read %d bytes", dev->valid);
412 struct chaoskey *dev;
418 dev = file->private_data;
420 if (dev == NULL || !dev->present)
423 usb_dbg(dev->interface, "read %zu", count);
430 result = mutex_lock_interruptible(&dev->rng_lock);
433 mutex_unlock(&dev->rng_lock);
435 result = mutex_lock_interruptible(&dev->lock);
438 if (dev->valid == dev->used) {
439 result = _chaoskey_fill(dev);
441 mutex_unlock(&dev->lock);
446 this_time = dev->valid - dev->used;
450 remain = copy_to_user(buffer, dev->buf + dev->used, this_time);
457 dev->used += this_time - remain;
458 mutex_unlock(&dev->lock);
465 dev->used += this_time;
466 mutex_unlock(&dev->lock);
470 usb_dbg(dev->interface, "read %zu bytes", read_count);
473 usb_dbg(dev->interface, "empty read, result %d", result);
482 struct chaoskey *dev = container_of(rng, struct chaoskey, hwrng);
485 usb_dbg(dev->interface, "rng_read max %zu wait %d", max, wait);
487 if (!dev->present) {
488 usb_dbg(dev->interface, "device not present");
496 mutex_lock(&dev->rng_lock);
498 mutex_lock(&dev->lock);
500 mutex_unlock(&dev->rng_lock);
506 if (dev->valid == dev->used)
507 (void) _chaoskey_fill(dev);
509 this_time = dev->valid - dev->used;
513 memcpy(data, dev->buf + dev->used, this_time);
515 dev->used += this_time;
517 mutex_unlock(&dev->lock);
519 usb_dbg(dev->interface, "rng_read this_time %d\n", this_time);
533 struct chaoskey *dev;
537 dev = usb_get_intfdata(interface);
546 dev->reads_started = false;