src/add-ons/kernel/busses/random/VirtioRNGDevice.cpp

   1 /*
   2  * Copyright 2013, Jérôme Duval, korli@users.berlios.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "VirtioRNGPrivate.h"
   8
   9 #include <new>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include <util/AutoLock.h>
  14
  15
  16 const char *
  17 get_feature_name(uint32 feature)
  18 {
  19         switch (feature) {
  20         }
  21         return NULL;
  22 }
  23
  24
  25 VirtioRNGDevice::VirtioRNGDevice(device_node *node)
  26         :
  27         fNode(node),
  28         fVirtio(NULL),
  29         fVirtioDevice(NULL),
  30         fStatus(B_NO_INIT),
  31         fOffset(BUFFER_SIZE),
  32         fExpectsInterrupt(false)
  33 {
  34         CALLED();
  35
  36         B_INITIALIZE_SPINLOCK(&fInterruptLock);
  37         fInterruptCondition.Init(this, "virtio rng transfer");
  38
  39         get_memory_map(fBuffer, BUFFER_SIZE, &fEntry, 1);
  40
  41         // get the Virtio device from our parent's parent
  42         device_node *parent = gDeviceManager->get_parent_node(node);
  43         device_node *virtioParent = gDeviceManager->get_parent_node(parent);
  44         gDeviceManager->put_node(parent);
  45
  46         gDeviceManager->get_driver(virtioParent, (driver_module_info **)&fVirtio,
  47                 (void **)&fVirtioDevice);
  48         gDeviceManager->put_node(virtioParent);
  49
  50         fVirtio->negociate_features(fVirtioDevice,
  51                 0, &fFeatures, &get_feature_name);
  52
  53         fStatus = fVirtio->alloc_queues(fVirtioDevice, 1, &fVirtioQueue);
  54         if (fStatus != B_OK) {
  55                 ERROR("queue allocation failed (%s)\n", strerror(fStatus));
  56                 return;
  57         }
  58
  59         fStatus = fVirtio->setup_interrupt(fVirtioDevice, NULL, this);
  60         if (fStatus != B_OK) {
  61                 ERROR("interrupt setup failed (%s)\n", strerror(fStatus));
  62                 return;
  63         }
  64 }
  65
  66
  67 VirtioRNGDevice::~VirtioRNGDevice()
  68 {
  69 }
  70
  71
  72 status_t
  73 VirtioRNGDevice::InitCheck()
  74 {
  75         return fStatus;
  76 }
  77
  78
  79 status_t
  80 VirtioRNGDevice::Read(void* _buffer, size_t* _numBytes)
  81 {
  82         CALLED();
  83
  84         if (fOffset >= BUFFER_SIZE) {
  85                 {
  86                         InterruptsSpinLocker locker(fInterruptLock);
  87                         fExpectsInterrupt = true;
  88                         fInterruptCondition.Add(&fInterruptConditionEntry);
  89                 }
  90                 status_t result = fVirtio->queue_request(fVirtioQueue, NULL, &fEntry,
  91                         _RequestCallback, this);
  92                 if (result != B_OK) {
  93                         ERROR("queueing failed (%s)\n", strerror(result));
  94                         return result;
  95                 }
  96
  97                 result = fInterruptConditionEntry.Wait(B_CAN_INTERRUPT);
  98
  99                 {
 100                         InterruptsSpinLocker locker(fInterruptLock);
 101                         fExpectsInterrupt = false;
 102                 }
 103
 104                 if (result == B_OK) {
 105                         fOffset = 0;
 106                 } else if (result != B_INTERRUPTED) {
 107                         ERROR("request failed (%s)\n", strerror(result));
 108                 }
 109         }
 110
 111         if (fOffset < BUFFER_SIZE) {
 112                 size_t size = min_c(BUFFER_SIZE - fOffset, *_numBytes);
 113                 memcpy(_buffer, fBuffer + fOffset, size);
 114                 fOffset += size;
 115                 *_numBytes = size;
 116         } else
 117                 *_numBytes = 0;
 118         return B_OK;
 119 }
 120
 121
 122 void
 123 VirtioRNGDevice::_RequestCallback(void* driverCookie, void* cookie)
 124 {
 125         VirtioRNGDevice* device = (VirtioRNGDevice*)driverCookie;
 126         device->_RequestInterrupt();
 127 }
 128
 129
 130 void
 131 VirtioRNGDevice::_RequestInterrupt()
 132 {
 133         SpinLocker locker(fInterruptLock);
 134         fInterruptCondition.NotifyAll();
 135 }