/*
* See http://pastehtml.com/view/crkxyohmp.rtxt
*
*/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "../port/error.h"
#include "io.h"
typedef struct RndNumGen RndNumGen;
struct RndNumGen
{
u32int ctl;
u32int stat;
u32int data;
u32int threshold;
u32int int_mask;
};
enum {
RNGBASE = VIRTIO+0x104000,
RngCtl = RNGBASE,
RngCtlG2x = 2, // double speed generation
RngCtlEna = 1, // enable
RngStat = RNGBASE + 4,
RngCnt = 0xff000000, // valid word count
RngCntShift = 24, // valid word count shift
RngWrmCnt = 0x000fffff, // warm up count
RngData = RNGBASE + 8,
RngFFthresh = RNGBASE + 12,
RngFFTmsk = 0xff, // number of words before intr
RngIntMask = RNGBASE + 16,
RngIntdis = 1, // write 1 to disable intr
};
struct Rb
{
QLock;
Rendez producer;
Rendez consumer;
ulong randomcount;
uchar buf[1024];
uchar *ep;
uchar *rp;
uchar *wp;
uchar next;
uchar wakeme;
ushort bits;
ulong randn;
} rb;
static ulong (*rndread)(void *xp, ulong n);
static int
rbnotfull(void*)
{
int i;
i = rb.rp - rb.wp;
return i != 1 && i != (1 - sizeof(rb.buf));
}
static int
rbnotempty(void*)
{
return rb.wp != rb.rp;
}
static void
genrandom(void*)
{
up->basepri = PriNormal;
up->priority = up->basepri;
for(;;){
for(;;)
if(++rb.randomcount > 100000)
break;
if(anyhigher())
sched();
if(!rbnotfull(0))
sleep(&rb.producer, rbnotfull, 0);
}
}
/*
* produce random bits in a circular buffer
*/
static void
randomclock(void)
{
if(rb.randomcount == 0 || !rbnotfull(0))
return;
rb.bits = (rb.bits<<2) ^ rb.randomcount;
rb.randomcount = 0;
rb.next++;
if(rb.next != 8/2)
return;
rb.next = 0;
*rb.wp ^= rb.bits;
if(rb.wp+1 == rb.ep)
rb.wp = rb.buf;
else
rb.wp = rb.wp+1;
if(rb.wakeme)
wakeup(&rb.consumer);
}
static ulong
hwrandomread(void *xp, ulong n)
{
RndNumGen* rng = (RndNumGen*)RNGBASE;
uchar *e, *p;
p = xp;
if (waserror()) {
qunlock(&rb);
nexterror();
}
qlock(&rb);
for(e = p + n; p < e; ){
int cnt;
u32int stat = rng->stat;
cnt = stat >> RngCntShift;
while (cnt > 0) {
union { u32int i; uchar c[4];} data;
data.i = rng->data;
coherence();
cnt--;
*p++ = data.c[0]; if (p >= e) break;
*p++ = data.c[1]; if (p >= e) break;
*p++ = data.c[2]; if (p >= e) break;
*p++ = data.c[3]; if (p >= e) break;
}
}
qunlock(&rb);
poperror();
return n;
}
/*
* consume random bytes from a circular buffer
*/
static ulong
swrandomread(void *xp, ulong n)
{
uchar *e, *p;
ulong x;
p = xp;
if(waserror()){
qunlock(&rb);
nexterror();
}
qlock(&rb);
for(e = p + n; p < e; ){
if(rb.wp == rb.rp){
rb.wakeme = 1;
wakeup(&rb.producer);
sleep(&rb.consumer, rbnotempty, 0);
rb.wakeme = 0;
continue;
}
/*
* beating clocks will be predictable if
* they are synchronized. Use a cheap pseudo-
* random number generator to obscure any cycles.
*/
x = rb.randn*1103515245 ^ *rb.rp;
*p++ = rb.randn = x;
if(rb.rp+1 == rb.ep)
rb.rp = rb.buf;
else
rb.rp = rb.rp+1;
}
qunlock(&rb);
poperror();
wakeup(&rb.producer);
return n;
}
ulong
randomread(void *xp, ulong n)
{
return rndread(xp,n);
}
static void
hwrandominit(void)
{
RndNumGen* rng = (RndNumGen*)RNGBASE;
u32int ctl;
// as per Broadcom the first 0x40000 numbers are less random. Dicard.
rng->stat = 0x40000;
ctl = rng->ctl;
coherence();
rng->ctl = ctl|RngCtlEna;
}
void
randominit(void)
{
/* firmware support added on Wed Jan 30 13:30:14 2013 GMT */
if (getfirmware() >= 366104) {
rndread = hwrandomread;
hwrandominit();
} else {
rndread = swrandomread;
/* Frequency close but not equal to HZ */
addclock0link(randomclock, 13);
rb.ep = rb.buf + sizeof(rb.buf);
rb.rp = rb.wp = rb.buf;
kproc("genrandom", genrandom, 0);
}
}