add vmx(1)
This commit is contained in:
aiju
parent
8029c3d8c4
commit
d5e55f5140
10 changed files with 3592 additions and 0 deletions
64
sys/src/cmd/vmx/dat.h
Normal file
64
sys/src/cmd/vmx/dat.h
Normal file
|
|
@ -0,0 +1,64 @@
|
||||||
|
typedef struct PCIDev PCIDev;
|
||||||
|
typedef struct PCICap PCICap;
|
||||||
|
typedef struct PCIBar PCIBar;
|
||||||
|
typedef struct Region Region;
|
||||||
|
|
||||||
|
extern int halt, irqactive;
|
||||||
|
|
||||||
|
enum {
|
||||||
|
BY2PG = 4096
|
||||||
|
};
|
||||||
|
|
||||||
|
#define RPC "pc"
|
||||||
|
#define RSP "sp"
|
||||||
|
#define RAX "ax"
|
||||||
|
#define RBX "bx"
|
||||||
|
#define RCX "cx"
|
||||||
|
#define RDX "dx"
|
||||||
|
|
||||||
|
enum {
|
||||||
|
MMIORD = 0,
|
||||||
|
MMIOWRP = 1,
|
||||||
|
MMIOWR = 2,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct Region {
|
||||||
|
uintptr start, end;
|
||||||
|
enum { REGNO, REGMEM, REGFB } type;
|
||||||
|
char *segname;
|
||||||
|
uvlong segoff;
|
||||||
|
void *v, *ve;
|
||||||
|
Region *next;
|
||||||
|
};
|
||||||
|
|
||||||
|
extern Region *mmap;
|
||||||
|
|
||||||
|
#define BDF(b,d,f) ((b)<<16&0xff0000|(d)<<11&0xf800|(f)<<8&0x700)
|
||||||
|
|
||||||
|
struct PCIBar {
|
||||||
|
PCIDev *d;
|
||||||
|
u8int type;
|
||||||
|
u32int addr, length;
|
||||||
|
PCIBar *busnext, *busprev;
|
||||||
|
u32int (*io)(int, u16int, u32int, int, void *);
|
||||||
|
void *aux;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct PCIDev {
|
||||||
|
u32int bdf, viddid, clrev, subid;
|
||||||
|
u16int ctrl;
|
||||||
|
u8int irqno, irqactive;
|
||||||
|
PCIBar bar[6];
|
||||||
|
PCIDev *next;
|
||||||
|
PCICap *cap;
|
||||||
|
u8int capalloc;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct PCICap {
|
||||||
|
PCIDev *dev;
|
||||||
|
u8int length;
|
||||||
|
u8int addr;
|
||||||
|
u32int (*read)(PCICap *, u8int);
|
||||||
|
void (*write)(PCICap *, u8int, u32int, u32int);
|
||||||
|
PCICap *next;
|
||||||
|
};
|
||||||
387
sys/src/cmd/vmx/exith.c
Normal file
387
sys/src/cmd/vmx/exith.c
Normal file
|
|
@ -0,0 +1,387 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include <thread.h>
|
||||||
|
#include <bio.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
typedef struct ExitInfo ExitInfo;
|
||||||
|
struct ExitInfo {
|
||||||
|
char *raw;
|
||||||
|
char *name;
|
||||||
|
uvlong qual;
|
||||||
|
uvlong pa, va;
|
||||||
|
u32int ilen, iinfo;
|
||||||
|
};
|
||||||
|
|
||||||
|
static void
|
||||||
|
skipinstr(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
rset(RPC, rget(RPC) + ei->ilen);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
stepmmio(uvlong pa, uvlong *val, int size, ExitInfo *ei)
|
||||||
|
{
|
||||||
|
extern uchar *tmp;
|
||||||
|
extern uvlong tmpoff;
|
||||||
|
void *targ;
|
||||||
|
uvlong pc, si;
|
||||||
|
char buf[ERRMAX];
|
||||||
|
extern int getexit;
|
||||||
|
|
||||||
|
memset(tmp, 0, BY2PG);
|
||||||
|
targ = tmp + (pa & 0xfff);
|
||||||
|
switch(size){
|
||||||
|
case 1: *(u8int*)targ = *val; break;
|
||||||
|
case 2: *(u16int*)targ = *val; break;
|
||||||
|
case 4: *(u32int*)targ = *val; break;
|
||||||
|
case 8: *(u64int*)targ = *val; break;
|
||||||
|
}
|
||||||
|
pc = rget(RPC);
|
||||||
|
si = rget("si");
|
||||||
|
rcflush(0);
|
||||||
|
if(ctl("step -map %#ullx vm %#ullx", pa & ~0xfff, tmpoff) < 0){
|
||||||
|
rerrstr(buf, sizeof(buf));
|
||||||
|
if(strcmp(buf, "step failed") == 0){
|
||||||
|
vmerror("vmx step failure (old pc=%#ullx, new pc=%#ullx, cause=%#q)", pc, rget(RPC), ei->raw);
|
||||||
|
getexit++;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
sysfatal("ctl(stepmmio): %r");
|
||||||
|
}
|
||||||
|
switch(size){
|
||||||
|
case 1: *val = *(u8int*)targ; break;
|
||||||
|
case 2: *val = *(u16int*)targ; break;
|
||||||
|
case 4: *val = *(u32int*)targ; break;
|
||||||
|
case 8: *val = *(u64int*)targ; break;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
extern u32int io(int, u16int, u32int, int);
|
||||||
|
|
||||||
|
static void
|
||||||
|
iohandler(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
int port, len, isin;
|
||||||
|
u32int val;
|
||||||
|
u64int ax;
|
||||||
|
|
||||||
|
port = ei->qual >> 16 & 0xffff;
|
||||||
|
len = (ei->qual & 7) + 1;
|
||||||
|
isin = (ei->qual & 8) != 0;
|
||||||
|
if((ei->qual & 1<<4) != 0){
|
||||||
|
vmerror("i/o string instruction not implemented");
|
||||||
|
postexc("#ud", 0);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if(isin){
|
||||||
|
val = io(1, port, 0, len);
|
||||||
|
ax = rget(RAX);
|
||||||
|
if(len == 1) ax = ax & ~0xff | val & 0xff;
|
||||||
|
else if(len == 2) ax = ax & ~0xffff | val & 0xffff;
|
||||||
|
else ax = val;
|
||||||
|
rset(RAX, ax);
|
||||||
|
}else{
|
||||||
|
ax = rget(RAX);
|
||||||
|
if(len == 1) ax = (u8int) ax;
|
||||||
|
else if(len == 2) ax = (u16int) ax;
|
||||||
|
io(0, port, ax, len);
|
||||||
|
}
|
||||||
|
skipinstr(ei);
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct MemHandler MemHandler;
|
||||||
|
struct MemHandler {
|
||||||
|
uvlong lo, hi;
|
||||||
|
uvlong (*f)(int, uvlong, uvlong);
|
||||||
|
};
|
||||||
|
|
||||||
|
MemHandler memh[32];
|
||||||
|
int nmemh;
|
||||||
|
|
||||||
|
static uvlong
|
||||||
|
defaultmmio(int op, uvlong addr, uvlong val)
|
||||||
|
{
|
||||||
|
switch(op){
|
||||||
|
case MMIORD:
|
||||||
|
vmerror("read from unmapped address %#ullx (pc=%#ullx)", addr, rget(RPC));
|
||||||
|
break;
|
||||||
|
case MMIOWR:
|
||||||
|
vmerror("write to unmapped address %#ullx (val=%#ullx,pc=%#ullx)", addr, val, rget(RPC));
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
eptfault(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
MemHandler *h;
|
||||||
|
static MemHandler def = {.f defaultmmio};
|
||||||
|
int size;
|
||||||
|
uvlong val;
|
||||||
|
|
||||||
|
for(h = memh; h < memh + nmemh; h++)
|
||||||
|
if(ei->pa >= h->lo && ei->pa <= h->hi)
|
||||||
|
break;
|
||||||
|
if(h == memh + nmemh)
|
||||||
|
h = &def;
|
||||||
|
size = 8;
|
||||||
|
if((ei->qual & 5) != 0){
|
||||||
|
val = h->f(MMIORD, ei->pa, 0);
|
||||||
|
stepmmio(ei->pa, &val, size, ei);
|
||||||
|
}else{
|
||||||
|
val = h->f(MMIOWRP, ei->pa, 0);
|
||||||
|
if(stepmmio(ei->pa, &val, size, ei) < 0)
|
||||||
|
return;
|
||||||
|
h->f(MMIOWR, ei->pa, val);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
registermmio(uvlong lo, uvlong hi, uvlong (*f)(int, uvlong, uvlong))
|
||||||
|
{
|
||||||
|
assert(nmemh < nelem(memh));
|
||||||
|
memh[nmemh].lo = lo;
|
||||||
|
memh[nmemh].hi = hi;
|
||||||
|
memh[nmemh].f = f;
|
||||||
|
nmemh++;
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct CPUID CPUID;
|
||||||
|
struct CPUID {
|
||||||
|
u32int idx;
|
||||||
|
u32int ax, bx, cx, dx;
|
||||||
|
};
|
||||||
|
static CPUID *cpuidf;
|
||||||
|
static int ncpuidf;
|
||||||
|
|
||||||
|
static void
|
||||||
|
auxcpuidproc(void *vpfd)
|
||||||
|
{
|
||||||
|
int *pfd;
|
||||||
|
|
||||||
|
pfd = vpfd;
|
||||||
|
close(pfd[1]);
|
||||||
|
close(0);
|
||||||
|
open("/dev/null", OREAD);
|
||||||
|
dup(pfd[0], 1);
|
||||||
|
close(pfd[0]);
|
||||||
|
procexecl(nil, "/bin/aux/cpuid", "cpuid", "-r", nil);
|
||||||
|
threadexits("exec: %r");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
cpuidinit(void)
|
||||||
|
{
|
||||||
|
int pfd[2];
|
||||||
|
Biobuf *bp;
|
||||||
|
char *l, *f[5];
|
||||||
|
CPUID *cp;
|
||||||
|
|
||||||
|
pipe(pfd);
|
||||||
|
procrfork(auxcpuidproc, pfd, 4096, RFFDG);
|
||||||
|
close(pfd[0]);
|
||||||
|
bp = Bfdopen(pfd[1], OREAD);
|
||||||
|
if(bp == nil) sysfatal("Bopenfd: %r");
|
||||||
|
for(; l = Brdstr(bp, '\n', 1), l != nil; free(l)){
|
||||||
|
if(tokenize(l, f, 5) < 5) continue;
|
||||||
|
cpuidf = realloc(cpuidf, (ncpuidf + 1) * sizeof(CPUID));
|
||||||
|
cp = cpuidf + ncpuidf++;
|
||||||
|
cp->idx = strtoul(f[0], nil, 16);
|
||||||
|
cp->ax = strtoul(f[1], nil, 16);
|
||||||
|
cp->bx = strtoul(f[2], nil, 16);
|
||||||
|
cp->cx = strtoul(f[3], nil, 16);
|
||||||
|
cp->dx = strtoul(f[4], nil, 16);
|
||||||
|
}
|
||||||
|
Bterm(bp);
|
||||||
|
close(pfd[1]);
|
||||||
|
}
|
||||||
|
|
||||||
|
CPUID *
|
||||||
|
getcpuid(ulong idx)
|
||||||
|
{
|
||||||
|
CPUID *cp;
|
||||||
|
|
||||||
|
for(cp = cpuidf; cp < cpuidf + ncpuidf; cp++)
|
||||||
|
if(cp->idx == idx)
|
||||||
|
return cp;
|
||||||
|
return nil;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
cpuid(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
u32int ax, bx, cx, dx;
|
||||||
|
CPUID *cp;
|
||||||
|
static CPUID def;
|
||||||
|
|
||||||
|
ax = rget(RAX);
|
||||||
|
cp = getcpuid(ax);
|
||||||
|
if(cp == nil) cp = &def;
|
||||||
|
switch(ax){
|
||||||
|
case 0: /* highest register & GenuineIntel */
|
||||||
|
ax = 7;
|
||||||
|
bx = cp->bx;
|
||||||
|
dx = cp->dx;
|
||||||
|
cx = cp->cx;
|
||||||
|
break;
|
||||||
|
case 1: /* features */
|
||||||
|
ax = cp->ax;
|
||||||
|
bx = cp->bx & 0xffff;
|
||||||
|
cx = cp->cx & 0x60de2203;
|
||||||
|
dx = cp->dx & 0x0682a179;
|
||||||
|
break;
|
||||||
|
case 2: goto literal; /* cache stuff */
|
||||||
|
case 3: goto zero; /* processor serial number */
|
||||||
|
case 4: goto literal; /* cache stuff */
|
||||||
|
case 5: goto zero; /* monitor/mwait */
|
||||||
|
case 6: goto zero; /* thermal management */
|
||||||
|
case 7: goto zero; /* more features */
|
||||||
|
case 0x80000000: /* highest register */
|
||||||
|
ax = 0x80000008;
|
||||||
|
bx = cx = dx = 0;
|
||||||
|
break;
|
||||||
|
case 0x80000001: /* signature & ext features */
|
||||||
|
ax = cp->ax;
|
||||||
|
bx = 0;
|
||||||
|
cx = cp->cx & 0x121;
|
||||||
|
dx = cp->dx & 0x04100000;
|
||||||
|
break;
|
||||||
|
case 0x80000002: goto literal; /* brand string */
|
||||||
|
case 0x80000003: goto literal; /* brand string */
|
||||||
|
case 0x80000004: goto literal; /* brand string */
|
||||||
|
case 0x80000005: goto zero; /* reserved */
|
||||||
|
case 0x80000006: goto literal; /* cache info */
|
||||||
|
case 0x80000007: goto zero; /* invariant tsc */
|
||||||
|
case 0x80000008: goto literal; /* address bits */
|
||||||
|
literal:
|
||||||
|
ax = cp->ax;
|
||||||
|
bx = cp->bx;
|
||||||
|
cx = cp->cx;
|
||||||
|
dx = cp->dx;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
vmerror("unknown cpuid field eax=%#ux", ax);
|
||||||
|
zero:
|
||||||
|
ax = 0;
|
||||||
|
bx = 0;
|
||||||
|
cx = 0;
|
||||||
|
dx = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
rset(RAX, ax);
|
||||||
|
rset(RBX, bx);
|
||||||
|
rset(RCX, cx);
|
||||||
|
rset(RDX, dx);
|
||||||
|
skipinstr(ei);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
rdwrmsr(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
u32int cx;
|
||||||
|
u64int val;
|
||||||
|
int rd;
|
||||||
|
|
||||||
|
rd = ei->name[1] == 'r';
|
||||||
|
cx = rget(RCX);
|
||||||
|
val = (uvlong)rget(RDX) << 32 | rget(RAX);
|
||||||
|
switch(cx){
|
||||||
|
default:
|
||||||
|
if(rd)
|
||||||
|
vmerror("read from unknown MSR %#x ignored", cx);
|
||||||
|
else
|
||||||
|
vmerror("write to unknown MSR %#x ignored (val=%#ullx)", cx, val);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if(rd){
|
||||||
|
rset(RAX, val);
|
||||||
|
rset(RDX, val >> 32);
|
||||||
|
}
|
||||||
|
skipinstr(ei);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
hlt(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
if(irqactive == 0)
|
||||||
|
halt = 1;
|
||||||
|
skipinstr(ei);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
irqackhand(ExitInfo *ei)
|
||||||
|
{
|
||||||
|
irqack(ei->qual);
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct ExitType ExitType;
|
||||||
|
struct ExitType {
|
||||||
|
char *name;
|
||||||
|
void (*f)(ExitInfo *);
|
||||||
|
};
|
||||||
|
static ExitType etypes[] = {
|
||||||
|
{"io", iohandler},
|
||||||
|
{".cpuid", cpuid},
|
||||||
|
{".hlt", hlt},
|
||||||
|
{"eptfault", eptfault},
|
||||||
|
{"*ack", irqackhand},
|
||||||
|
{".rdmsr", rdwrmsr},
|
||||||
|
{".wrmsr", rdwrmsr},
|
||||||
|
};
|
||||||
|
|
||||||
|
void
|
||||||
|
processexit(char *msg)
|
||||||
|
{
|
||||||
|
static char msgc[1024];
|
||||||
|
char *f[32];
|
||||||
|
int nf;
|
||||||
|
ExitType *et;
|
||||||
|
int i;
|
||||||
|
ExitInfo ei;
|
||||||
|
extern int getexit;
|
||||||
|
|
||||||
|
strcpy(msgc, msg);
|
||||||
|
nf = tokenize(msgc, f, nelem(f));
|
||||||
|
if(nf < 2) sysfatal("invalid wait message: %s", msg);
|
||||||
|
memset(&ei, 0, sizeof(ei));
|
||||||
|
ei.raw = msg;
|
||||||
|
ei.name = f[0];
|
||||||
|
if(strcmp(ei.name, "io") != 0 && strcmp(ei.name, "eptfault") != 0 && strcmp(ei.name, "*ack") != 0 && strcmp(ei.name, ".hlt") != 0) vmdebug("exit: %s", msg);
|
||||||
|
ei.qual = strtoull(f[1], nil, 0);
|
||||||
|
for(i = 2; i < nf; i += 2){
|
||||||
|
if(strcmp(f[i], "pc") == 0)
|
||||||
|
rpoke(RPC, strtoull(f[i+1], nil, 0), 1);
|
||||||
|
else if(strcmp(f[i], "sp") == 0)
|
||||||
|
rpoke(RSP, strtoull(f[i+1], nil, 0), 1);
|
||||||
|
else if(strcmp(f[i], "ax") == 0)
|
||||||
|
rpoke(RAX, strtoull(f[i+1], nil, 0), 1);
|
||||||
|
else if(strcmp(f[i], "ilen") == 0)
|
||||||
|
ei.ilen = strtoul(f[i+1], nil, 0);
|
||||||
|
else if(strcmp(f[i], "iinfo") == 0)
|
||||||
|
ei.iinfo = strtoul(f[i+1], nil, 0);
|
||||||
|
else if(strcmp(f[i], "pa") == 0)
|
||||||
|
ei.pa = strtoull(f[i+1], nil, 0);
|
||||||
|
else if(strcmp(f[i], "va") == 0)
|
||||||
|
ei.va = strtoull(f[i+1], nil, 0);
|
||||||
|
}
|
||||||
|
if(*f[0] == '*') getexit++;
|
||||||
|
for(et = etypes; et < etypes + nelem(etypes); et++)
|
||||||
|
if(strcmp(et->name, f[0]) == 0){
|
||||||
|
et->f(&ei);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if(*f[0] == '.'){
|
||||||
|
vmerror("vmx: unknown instruction %s", f[0]+1);
|
||||||
|
postexc("#ud", 0);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if(*f[0] == '*'){
|
||||||
|
vmerror("vmx: unknown notification %s", f[0]+1);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
sysfatal("vmx: unknown exit: %s", msg);
|
||||||
|
}
|
||||||
32
sys/src/cmd/vmx/fns.h
Normal file
32
sys/src/cmd/vmx/fns.h
Normal file
|
|
@ -0,0 +1,32 @@
|
||||||
|
void *emalloc(ulong);
|
||||||
|
void loadkernel(char *);
|
||||||
|
uvlong rget(char *);
|
||||||
|
void rpoke(char *, uvlong, int);
|
||||||
|
#define rset(a,b) rpoke(a,b,0)
|
||||||
|
void processexit(char *);
|
||||||
|
void pitadvance(void);
|
||||||
|
void vmerror(char *, ...);
|
||||||
|
#define vmdebug vmerror
|
||||||
|
int ctl(char *, ...);
|
||||||
|
void registermmio(uvlong, uvlong, uvlong (*)(int, uvlong, uvlong));
|
||||||
|
void irqline(int, int);
|
||||||
|
void irqack(int);
|
||||||
|
void postexc(char *, u32int);
|
||||||
|
void vgaresize(void);
|
||||||
|
void uartinit(int, char *);
|
||||||
|
void sendnotif(void (*)(void *), void *);
|
||||||
|
PCIDev *mkpcidev(u32int, u32int, u32int, int);
|
||||||
|
PCIBar *mkpcibar(PCIDev *, u8int, u32int, void *, void *);
|
||||||
|
PCICap *mkpcicap(PCIDev *, u8int, u32int (*)(PCICap *, u8int), void(*)(PCICap *, u8int, u32int, u32int));
|
||||||
|
u32int allocbdf(void);
|
||||||
|
void *gptr(u64int, u64int);
|
||||||
|
void *gend(void *);
|
||||||
|
uintptr gpa(void *);
|
||||||
|
uintptr gavail(void *);
|
||||||
|
void pciirq(PCIDev *, int);
|
||||||
|
u32int iowhine(int, u16int, u32int, int, void *);
|
||||||
|
void elcr(u16int);
|
||||||
|
int mkvionet(char *);
|
||||||
|
int mkvioblk(char *);
|
||||||
|
char* rcflush(int);
|
||||||
|
void i8042kick(void *);
|
||||||
981
sys/src/cmd/vmx/io.c
Normal file
981
sys/src/cmd/vmx/io.c
Normal file
|
|
@ -0,0 +1,981 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include <thread.h>
|
||||||
|
#include <draw.h>
|
||||||
|
#include <cursor.h>
|
||||||
|
#include <mouse.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
static uchar
|
||||||
|
bcd(uchar c)
|
||||||
|
{
|
||||||
|
return c / 10 << 4 | c % 10;
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
rtcio(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
static u8int addr;
|
||||||
|
uintptr basemem, extmem;
|
||||||
|
Tm *tm;
|
||||||
|
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x10070: return addr;
|
||||||
|
case 0x70: addr = val; return 0;
|
||||||
|
case 0x10071:
|
||||||
|
tm = gmtime(time(nil));
|
||||||
|
basemem = gavail(gptr(0, 0)) >> 10;
|
||||||
|
if(basemem > 640) basemem = 640;
|
||||||
|
extmem = gavail(gptr(1<<20, 0)) >> 10;
|
||||||
|
if(extmem >= 65535) extmem = 65535;
|
||||||
|
switch(addr){
|
||||||
|
case 0x00: return bcd(tm->sec);
|
||||||
|
case 0x02: return bcd(tm->min);
|
||||||
|
case 0x04: return bcd(tm->hour);
|
||||||
|
case 0x06: return bcd(tm->wday + 1);
|
||||||
|
case 0x07: return bcd(tm->mday);
|
||||||
|
case 0x08: return bcd(tm->mon + 1);
|
||||||
|
case 0x09: return bcd(tm->year % 100);
|
||||||
|
case 0x0a: return 0x26;
|
||||||
|
case 0x0b: return 1<<1 | 1<<2;
|
||||||
|
case 0x0d: return 1<<7; /* cmos valid */
|
||||||
|
case 0x0e: return 0; /* diagnostics ok */
|
||||||
|
case 0x10: return 0; /* no floppies */
|
||||||
|
case 0x15: return basemem;
|
||||||
|
case 0x16: return basemem >> 8;
|
||||||
|
case 0x17: return extmem;
|
||||||
|
case 0x18: return extmem >> 8;
|
||||||
|
case 0x32: return bcd(tm->year / 100 + 19);
|
||||||
|
default: vmerror("rtc read from unknown address %#x", addr); return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "rtc");
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct Pic Pic;
|
||||||
|
struct Pic {
|
||||||
|
enum {
|
||||||
|
AEOI = 1,
|
||||||
|
ROTAEOI = 2,
|
||||||
|
MASKMODE = 4,
|
||||||
|
POLL = 8,
|
||||||
|
READSR = 16,
|
||||||
|
} flags;
|
||||||
|
u8int lines;
|
||||||
|
u8int irr, isr;
|
||||||
|
u8int imr;
|
||||||
|
u8int elcr;
|
||||||
|
u8int init;
|
||||||
|
u8int prio;
|
||||||
|
u8int base;
|
||||||
|
} pic[2];
|
||||||
|
int irqactive = -1;
|
||||||
|
|
||||||
|
static u8int
|
||||||
|
picprio(u8int v, u8int p, u8int *n)
|
||||||
|
{
|
||||||
|
p++;
|
||||||
|
v = v >> p | v << 8 - p;
|
||||||
|
v &= -v;
|
||||||
|
v = v << p | v >> 8 - p;
|
||||||
|
if(n != nil)
|
||||||
|
*n = ((v & 0xf0) != 0) << 2 | ((v & 0xcc) != 0) << 1 | (v & 0xaa) != 0;
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
|
||||||
|
static u8int
|
||||||
|
piccheck(Pic *p, u8int *n)
|
||||||
|
{
|
||||||
|
u8int s;
|
||||||
|
|
||||||
|
s = p->isr;
|
||||||
|
if((p->flags & MASKMODE) != 0 && p->imr != 0)
|
||||||
|
s = 0;
|
||||||
|
return picprio(p->irr & ~p->imr | s, p->prio, n) & ~s;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
picaeoi(Pic *p, u8int b)
|
||||||
|
{
|
||||||
|
if((p->flags & AEOI) == 0)
|
||||||
|
return;
|
||||||
|
p->isr &= ~(1<<b);
|
||||||
|
if((p->flags & ROTAEOI) != 0)
|
||||||
|
p->prio = b;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
picupdate(Pic *p)
|
||||||
|
{
|
||||||
|
u8int m, n;
|
||||||
|
|
||||||
|
if(p->init != 4) return;
|
||||||
|
m = piccheck(p, &n);
|
||||||
|
if(p == &pic[1])
|
||||||
|
irqline(2, m != 0);
|
||||||
|
else{
|
||||||
|
if(m != 0 && n == 2){
|
||||||
|
m = piccheck(&pic[1], &n);
|
||||||
|
n |= pic[1].base;
|
||||||
|
}else
|
||||||
|
n |= p->base;
|
||||||
|
if(m != 0 && irqactive != n){
|
||||||
|
if(ctl("irq %d", n) < 0)
|
||||||
|
sysfatal("ctl: %r");
|
||||||
|
halt = 0;
|
||||||
|
irqactive = n;
|
||||||
|
}else if(m == 0 && irqactive >= 0){
|
||||||
|
if(ctl("irq") < 0)
|
||||||
|
sysfatal("ctl: %r");
|
||||||
|
irqactive = -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
irqline(int n, int s)
|
||||||
|
{
|
||||||
|
Pic *p;
|
||||||
|
u8int ol, m;
|
||||||
|
|
||||||
|
assert(n >= 0 && n <= 15);
|
||||||
|
p = &pic[n / 8];
|
||||||
|
n %= 8;
|
||||||
|
ol = p->lines;
|
||||||
|
m = 1<<n;
|
||||||
|
if(s == 1)
|
||||||
|
p->lines |= m;
|
||||||
|
else if(s == 0)
|
||||||
|
p->lines &= ~m;
|
||||||
|
else if(s == -1)
|
||||||
|
p->lines ^= m;
|
||||||
|
if((p->elcr & m) != 0)
|
||||||
|
p->irr = p->irr & ~m | ~p->lines & m;
|
||||||
|
else
|
||||||
|
p->irr |= p->lines & ~ol & m;
|
||||||
|
picupdate(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
irqack(int n)
|
||||||
|
{
|
||||||
|
Pic *p;
|
||||||
|
extern int nextexit;
|
||||||
|
|
||||||
|
irqactive = -1;
|
||||||
|
if((n & ~7) == pic[0].base)
|
||||||
|
p = &pic[0];
|
||||||
|
else if((n & ~7) == pic[1].base)
|
||||||
|
p = &pic[1];
|
||||||
|
else
|
||||||
|
return;
|
||||||
|
if(p == &pic[1]) irqack(pic[0].base + 2);
|
||||||
|
n &= 7;
|
||||||
|
p->irr &= ~(1<<n);
|
||||||
|
p->isr |= 1<<n;
|
||||||
|
picaeoi(p, n);
|
||||||
|
picupdate(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
elcr(u16int a)
|
||||||
|
{
|
||||||
|
pic[0].elcr = a;
|
||||||
|
pic[1].elcr = a >> 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
picio(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
Pic *p;
|
||||||
|
u8int m, b;
|
||||||
|
|
||||||
|
p = &pic[(port & 0x80) != 0];
|
||||||
|
val = (u8int)val;
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x20:
|
||||||
|
case 0xa0:
|
||||||
|
if((val & 1<<4) != 0){ /* ICW1 */
|
||||||
|
if(irqactive){
|
||||||
|
if(ctl("irq") < 0)
|
||||||
|
sysfatal("ctl: %r");
|
||||||
|
irqactive = -1;
|
||||||
|
}
|
||||||
|
p->irr = 0;
|
||||||
|
p->isr = 0;
|
||||||
|
p->imr = 0;
|
||||||
|
p->prio = 7;
|
||||||
|
p->flags = 0;
|
||||||
|
if((val & 0x0b) != 0x01) vmerror("PIC%ld ICW1 with unsupported value %#ux", p-pic, val);
|
||||||
|
p->init = 1;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if((val & 0x18) == 0){ /* OCW2 */
|
||||||
|
switch(val >> 5){
|
||||||
|
case 0: /* rotate in automatic eoi mode (clear) */
|
||||||
|
p->flags &= ~ROTAEOI;
|
||||||
|
break;
|
||||||
|
case 1: /* non-specific eoi command */
|
||||||
|
p->isr &= ~picprio(p->isr, p->prio, nil);
|
||||||
|
break;
|
||||||
|
case 2: /* no operation */
|
||||||
|
break;
|
||||||
|
case 3: /* specific eoi command */
|
||||||
|
p->isr &= 1<<(val & 7);
|
||||||
|
break;
|
||||||
|
case 4: /* rotate in automatic eoi mode (set) */
|
||||||
|
p->flags |= ROTAEOI;
|
||||||
|
break;
|
||||||
|
case 5: /* rotate on non-specific eoi command */
|
||||||
|
p->isr &= ~picprio(p->isr, p->prio, &p->prio);
|
||||||
|
break;
|
||||||
|
case 6: /* set priority */
|
||||||
|
p->prio = val & 7;
|
||||||
|
break;
|
||||||
|
case 7: /* rotate on specific eoi command */
|
||||||
|
p->isr &= 1<<(val & 7);
|
||||||
|
p->prio = val & 7;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
picupdate(p);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if((val & 0x98) == 8){ /* OCW3 */
|
||||||
|
if((val & 0x40) != 0)
|
||||||
|
if((val & 0x20) != 0)
|
||||||
|
p->flags |= MASKMODE;
|
||||||
|
else
|
||||||
|
p->flags &= ~MASKMODE;
|
||||||
|
if((val & 4) != 0)
|
||||||
|
p->flags |= POLL;
|
||||||
|
if((val & 2) != 0)
|
||||||
|
if((val & 10) != 0)
|
||||||
|
p->flags |= READSR;
|
||||||
|
else
|
||||||
|
p->flags &= ~READSR;
|
||||||
|
picupdate(p);
|
||||||
|
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
case 0x21:
|
||||||
|
case 0xa1:
|
||||||
|
switch(p->init){
|
||||||
|
default:
|
||||||
|
vmerror("write to PIC%ld in init=%d state", p-pic, p->init);
|
||||||
|
return 0;
|
||||||
|
case 1:
|
||||||
|
p->base = val;
|
||||||
|
p->init = 2;
|
||||||
|
return 0;
|
||||||
|
case 2:
|
||||||
|
if(p == &pic[0] && val != 4 || p == &pic[1] && val != 2)
|
||||||
|
vmerror("PIC%ld ICW3 with unsupported value %#ux", p-pic, val);
|
||||||
|
p->init = 3;
|
||||||
|
return 0;
|
||||||
|
case 3:
|
||||||
|
if((val & 0xfd) != 1) vmerror("PIC%ld ICW4 with unsupported value %#ux", p-pic, val);
|
||||||
|
if((val & 2) != 0) p->flags |= AEOI;
|
||||||
|
p->init = 4;
|
||||||
|
picupdate(p);
|
||||||
|
return 0;
|
||||||
|
case 4:
|
||||||
|
p->imr = val;
|
||||||
|
picupdate(p);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case 0x10020:
|
||||||
|
if((p->flags & READSR) != 0)
|
||||||
|
return p->isr;
|
||||||
|
if((p->flags & POLL) != 0){
|
||||||
|
p->flags &= ~POLL;
|
||||||
|
m = piccheck(p, &b);
|
||||||
|
if(m != 0){
|
||||||
|
p->irr &= ~m;
|
||||||
|
p->isr |= m;
|
||||||
|
picaeoi(p, b);
|
||||||
|
picupdate(p);
|
||||||
|
return 1<<7 | b;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
return p->irr;
|
||||||
|
case 0x100a0:
|
||||||
|
case 0x10021:
|
||||||
|
case 0x100a1:
|
||||||
|
return p->imr;
|
||||||
|
case 0x4d0:
|
||||||
|
case 0x4d1:
|
||||||
|
pic[port & 1].elcr = val;
|
||||||
|
return 0;
|
||||||
|
case 0x104d0:
|
||||||
|
case 0x104d1:
|
||||||
|
return pic[port & 1].elcr;
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "pic");
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct PITChannel PITChannel;
|
||||||
|
|
||||||
|
struct PITChannel {
|
||||||
|
u8int mode;
|
||||||
|
u8int bcd;
|
||||||
|
u8int access;
|
||||||
|
u8int state;
|
||||||
|
u16int count, reload;
|
||||||
|
int latch;
|
||||||
|
enum { READLO, READHI, READLATLO, READLATHI } readstate;
|
||||||
|
u8int writestate;
|
||||||
|
vlong lastnsec;
|
||||||
|
};
|
||||||
|
PITChannel pit[3];
|
||||||
|
enum { PERIOD = 838 };
|
||||||
|
|
||||||
|
void
|
||||||
|
settimer(vlong targ)
|
||||||
|
{
|
||||||
|
extern vlong timerevent;
|
||||||
|
extern Lock timerlock;
|
||||||
|
extern int timerid;
|
||||||
|
int sendint;
|
||||||
|
|
||||||
|
sendint = 0;
|
||||||
|
lock(&timerlock);
|
||||||
|
if(targ < timerevent){
|
||||||
|
timerevent = targ;
|
||||||
|
sendint = 1;
|
||||||
|
}
|
||||||
|
unlock(&timerlock);
|
||||||
|
if(sendint)
|
||||||
|
threadint(timerid);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
pitadvance(void)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
int nc;
|
||||||
|
PITChannel *p;
|
||||||
|
vlong nt, t;
|
||||||
|
int rel;
|
||||||
|
|
||||||
|
for(i = 0; i < 3; i++){
|
||||||
|
p = &pit[i];
|
||||||
|
nt = nsec();
|
||||||
|
t = nt - p->lastnsec;
|
||||||
|
p->lastnsec = nt;
|
||||||
|
switch(p->mode){
|
||||||
|
case 3:
|
||||||
|
if(p->state != 0){
|
||||||
|
nc = 2 * (t / PERIOD);
|
||||||
|
if(p->count > nc)
|
||||||
|
p->count -= nc;
|
||||||
|
else{
|
||||||
|
rel = p->reload;
|
||||||
|
if(rel <= 1) rel = 65536;
|
||||||
|
nc -= p->count;
|
||||||
|
nc %= rel;
|
||||||
|
p->count = rel - nc;
|
||||||
|
if(i == 0)
|
||||||
|
irqline(0, -1);
|
||||||
|
}
|
||||||
|
p->lastnsec -= t % PERIOD;
|
||||||
|
settimer(p->lastnsec + p->count / 2 * PERIOD);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
pitsetreload(int n, int hi, u8int v)
|
||||||
|
{
|
||||||
|
PITChannel *p;
|
||||||
|
|
||||||
|
p = &pit[n];
|
||||||
|
if(hi)
|
||||||
|
p->reload = p->reload >> 8 | v << 8;
|
||||||
|
else
|
||||||
|
p->reload = p->reload & 0xff00 | v;
|
||||||
|
switch(p->mode){
|
||||||
|
case 3:
|
||||||
|
if(p->state == 0 && (p->access != 3 || hi)){
|
||||||
|
p->count = p->reload;
|
||||||
|
p->state = 1;
|
||||||
|
p->lastnsec = nsec();
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
vmerror("PIT reload in mode %d not implemented", p->mode);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
pitio(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
int n;
|
||||||
|
|
||||||
|
val = (u8int) val;
|
||||||
|
pitadvance();
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x10040:
|
||||||
|
case 0x10041:
|
||||||
|
case 0x10042:
|
||||||
|
n = port & 3;
|
||||||
|
switch(pit[n].readstate){
|
||||||
|
case READLO:
|
||||||
|
if(pit[n].access == 3)
|
||||||
|
pit[n].readstate = READHI;
|
||||||
|
return pit[n].count;
|
||||||
|
case READHI:
|
||||||
|
if(pit[n].access == 3)
|
||||||
|
pit[n].readstate = READLO;
|
||||||
|
return pit[n].count >> 8;
|
||||||
|
case READLATLO:
|
||||||
|
pit[n].readstate = READLATHI;
|
||||||
|
return pit[n].latch;
|
||||||
|
case READLATHI:
|
||||||
|
pit[n].readstate = pit[n].access == 1 ? READHI : READLO;
|
||||||
|
return pit[n].latch >> 8;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
case 0x40:
|
||||||
|
case 0x41:
|
||||||
|
case 0x42:
|
||||||
|
n = port & 3;
|
||||||
|
switch(pit[n].writestate){
|
||||||
|
case READLO:
|
||||||
|
if(pit[n].access == 3)
|
||||||
|
pit[n].writestate = READHI;
|
||||||
|
pitsetreload(n, 0, val);
|
||||||
|
break;
|
||||||
|
case READHI:
|
||||||
|
if(pit[n].access == 3)
|
||||||
|
pit[n].writestate = READLO;
|
||||||
|
pitsetreload(n, 1, val);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
case 0x43:
|
||||||
|
n = val >> 6;
|
||||||
|
if(n == 3) return 0;
|
||||||
|
if((val & ~0xc0) == 0){
|
||||||
|
pit[n].latch = pit[n].count;
|
||||||
|
pit[n].readstate = READLATLO;
|
||||||
|
}else{
|
||||||
|
pit[n].mode = val >> 1 & 7;
|
||||||
|
pit[n].access = val >> 4 & 3;
|
||||||
|
pit[n].bcd = val & 1;
|
||||||
|
pit[n].state = 0;
|
||||||
|
pit[n].count = 0;
|
||||||
|
pit[n].reload = 0;
|
||||||
|
pit[n].readstate = pit[n].access == 1 ? READHI : READLO;
|
||||||
|
pit[n].writestate = pit[n].access == 1 ? READHI : READLO;
|
||||||
|
pit[n].lastnsec = nsec();
|
||||||
|
if(n == 0)
|
||||||
|
irqline(0, 1);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "pit");
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct I8042 I8042;
|
||||||
|
struct I8042 {
|
||||||
|
u8int cfg, stat, oport;
|
||||||
|
int cmd;
|
||||||
|
u16int buf; /* |0x100 == kbd, |0x200 == mouse, |0x400 == cmd */
|
||||||
|
} i8042 = {
|
||||||
|
.cfg 0x34,
|
||||||
|
.stat 0x10,
|
||||||
|
.oport 0x01,
|
||||||
|
.cmd -1,
|
||||||
|
};
|
||||||
|
Channel *kbdch, *mousech;
|
||||||
|
typedef struct PCMouse PCMouse;
|
||||||
|
struct PCMouse {
|
||||||
|
Mouse;
|
||||||
|
u8int gotmouse;
|
||||||
|
enum {
|
||||||
|
MOUSERESET,
|
||||||
|
MOUSESTREAM,
|
||||||
|
MOUSEREMOTE,
|
||||||
|
MOUSEREP = 0x10,
|
||||||
|
MOUSEWRAP = 0x20,
|
||||||
|
} state;
|
||||||
|
u8int buf[64];
|
||||||
|
u8int bufr, bufw;
|
||||||
|
u8int actcmd;
|
||||||
|
u8int scaling21, res, rate;
|
||||||
|
} mouse = {
|
||||||
|
.res = 2,
|
||||||
|
.rate = 100
|
||||||
|
};
|
||||||
|
#define mouseputc(c) mouse.buf[mouse.bufw++ & 63] = (c)
|
||||||
|
|
||||||
|
static void
|
||||||
|
i8042putbuf(u16int val)
|
||||||
|
{
|
||||||
|
i8042.buf = val;
|
||||||
|
i8042.stat = i8042.stat & ~0x20 | val >> 4 & 0x20;
|
||||||
|
if((i8042.cfg & 1) != 0 && (val & 0x100) != 0){
|
||||||
|
irqline(1, 1);
|
||||||
|
i8042.oport |= 0x10;
|
||||||
|
}
|
||||||
|
if((i8042.cfg & 2) != 0 && (val & 0x200) != 0){
|
||||||
|
irqline(12, 1);
|
||||||
|
i8042.oport |= 0x20;
|
||||||
|
}
|
||||||
|
if(val == 0){
|
||||||
|
irqline(1, 0);
|
||||||
|
irqline(12, 0);
|
||||||
|
i8042.oport &= ~0x30;
|
||||||
|
i8042.stat &= ~1;
|
||||||
|
i8042kick(nil);
|
||||||
|
}else
|
||||||
|
i8042.stat |= 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
kbdcmd(u8int val)
|
||||||
|
{
|
||||||
|
vmerror("unknown kbd command %#ux", val);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
updatemouse(void)
|
||||||
|
{
|
||||||
|
Mouse m;
|
||||||
|
|
||||||
|
while(nbrecv(mousech, &m) > 0){
|
||||||
|
mouse.xy = addpt(mouse.xy, m.xy);
|
||||||
|
mouse.buttons = m.buttons;
|
||||||
|
mouse.gotmouse = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
clearmouse(void)
|
||||||
|
{
|
||||||
|
updatemouse();
|
||||||
|
mouse.xy = Pt(0, 0);
|
||||||
|
mouse.gotmouse = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
mousepacket(int force)
|
||||||
|
{
|
||||||
|
int dx, dy;
|
||||||
|
u8int b0;
|
||||||
|
|
||||||
|
updatemouse();
|
||||||
|
if(!mouse.gotmouse && !force)
|
||||||
|
return;
|
||||||
|
dx = mouse.xy.x;
|
||||||
|
dy = -mouse.xy.y;
|
||||||
|
b0 = 8;
|
||||||
|
if((ulong)(dx + 256) > 511) dx = dx >> 31 & 0x1ff ^ 0xff;
|
||||||
|
if((ulong)(dy + 256) > 511) dy = dy >> 31 & 0x1ff ^ 0xff;
|
||||||
|
b0 |= dx >> 5 & 0x10 | dy >> 4 & 0x20;
|
||||||
|
b0 |= (mouse.buttons * 0x111 & 0x421) % 7;
|
||||||
|
mouseputc(b0);
|
||||||
|
mouseputc((u8int)dx);
|
||||||
|
mouseputc((u8int)dy);
|
||||||
|
mouse.xy.x -= dx;
|
||||||
|
mouse.xy.y += dy;
|
||||||
|
mouse.gotmouse = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
mousedefaults(void)
|
||||||
|
{
|
||||||
|
clearmouse();
|
||||||
|
mouse.res = 2;
|
||||||
|
mouse.rate = 100;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
mousecmd(u8int val)
|
||||||
|
{
|
||||||
|
if((mouse.state & MOUSEWRAP) != 0 && val != 0xec && val != 0xff){
|
||||||
|
mouseputc(val);
|
||||||
|
i8042kick(nil);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
switch(mouse.actcmd){
|
||||||
|
case 0xe8: /* set resolution */
|
||||||
|
mouse.res = val;
|
||||||
|
mouseputc(0xfa);
|
||||||
|
mouse.actcmd = 0;
|
||||||
|
break;
|
||||||
|
case 0xf3: /* set sampling rate */
|
||||||
|
mouse.rate = val;
|
||||||
|
mouseputc(0xfa);
|
||||||
|
mouse.actcmd = 0;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
switch(val){
|
||||||
|
case 0xf3: case 0xe8: mouseputc(0xfa); mouse.actcmd = val; break;
|
||||||
|
|
||||||
|
case 0xff: mouseputc(0xfa); mousedefaults(); mouse.state = MOUSERESET; break; /* reset */
|
||||||
|
case 0xf6: mouseputc(0xfa); mousedefaults(); mouse.state = mouse.state & ~0xf | MOUSESTREAM; break; /* set defaults */
|
||||||
|
case 0xf5: mouseputc(0xfa); clearmouse(); if((mouse.state&0xf) == MOUSESTREAM) mouse.state &= ~MOUSEREP; break; /* disable reporting */
|
||||||
|
case 0xf4: mouseputc(0xfa); clearmouse(); if((mouse.state&0xf) == MOUSESTREAM) mouse.state |= MOUSEREP; break; /* enable reporting */
|
||||||
|
case 0xf2: mouseputc(0xfa); mouseputc(0x00); clearmouse(); break; /* report device id */
|
||||||
|
case 0xf0: mouseputc(0xfa); clearmouse(); mouse.state = mouse.state & ~0xf | MOUSEREMOTE; break; /* set remote mode */
|
||||||
|
case 0xee: mouseputc(0xfa); clearmouse(); mouse.state |= MOUSEWRAP; break; /* set wrap mode */
|
||||||
|
case 0xec: mouseputc(0xfa); clearmouse(); mouse.state &= ~MOUSEWRAP; break; /* reset wrap mode */
|
||||||
|
case 0xeb: mouseputc(0xfa); mousepacket(1); break; /* read data */
|
||||||
|
case 0xea: mouseputc(0xfa); clearmouse(); mouse.state = mouse.state & ~0xf | MOUSESTREAM; break; /* set stream mode */
|
||||||
|
case 0xe9: /* status request */
|
||||||
|
mouseputc(0xfa);
|
||||||
|
mouseputc(((mouse.state & 0xf) == MOUSEREMOTE) << 6 | ((mouse.state & MOUSEREP) != 0) << 5 | mouse.scaling21 << 4 | (mouse.buttons * 0x111 & 0x142) % 7);
|
||||||
|
mouseputc(mouse.res);
|
||||||
|
mouseputc(mouse.rate);
|
||||||
|
break;
|
||||||
|
case 0xe7: mouseputc(0xfa); mouse.scaling21 = 1; break; /* set 2:1 scaling */
|
||||||
|
case 0xe6: mouseputc(0xfa); mouse.scaling21 = 0; break; /* set 1:1 scaling */
|
||||||
|
default: vmerror("unknown mouse command %#ux", val); mouseputc(0xfc);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
i8042kick(nil);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
mousekick(void)
|
||||||
|
{
|
||||||
|
switch(mouse.state){
|
||||||
|
case MOUSERESET:
|
||||||
|
mouseputc(0xaa);
|
||||||
|
mouseputc(0);
|
||||||
|
mouse.state = MOUSESTREAM;
|
||||||
|
break;
|
||||||
|
case MOUSESTREAM | MOUSEREP:
|
||||||
|
if(mouse.actcmd == 0)
|
||||||
|
mousepacket(0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
i8042kick(void *)
|
||||||
|
{
|
||||||
|
ulong ch;
|
||||||
|
|
||||||
|
if((i8042.cfg & 0x10) == 0 && i8042.buf == 0)
|
||||||
|
if(nbrecv(kbdch, &ch) > 0)
|
||||||
|
i8042putbuf(0x100 | (u8int)ch);
|
||||||
|
if((i8042.cfg & 0x20) == 0 && i8042.buf == 0){
|
||||||
|
if(mouse.bufr == mouse.bufw)
|
||||||
|
mousekick();
|
||||||
|
if(mouse.bufr != mouse.bufw)
|
||||||
|
i8042putbuf(0x200 | mouse.buf[mouse.bufr++ & 63]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
i8042io(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
val = (u8int)val;
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x60:
|
||||||
|
i8042.stat &= ~8;
|
||||||
|
switch(i8042.cmd){
|
||||||
|
case 0x60: i8042.cfg = val; break;
|
||||||
|
case 0xd1:
|
||||||
|
i8042.oport = val;
|
||||||
|
irqline(1, i8042.oport >> 4 & 1);
|
||||||
|
irqline(12, i8042.oport >> 5 & 1);
|
||||||
|
break;
|
||||||
|
case 0xd2: i8042putbuf(0x100 | val); break;
|
||||||
|
case 0xd3: i8042putbuf(0x200 | val); break;
|
||||||
|
case 0xd4: mousecmd(val); break;
|
||||||
|
case -1: kbdcmd(val); break;
|
||||||
|
}
|
||||||
|
i8042.cmd = -1;
|
||||||
|
return 0;
|
||||||
|
case 0x10060:
|
||||||
|
i8042kick(nil);
|
||||||
|
rc = i8042.buf;
|
||||||
|
i8042putbuf(0);
|
||||||
|
return rc;
|
||||||
|
case 0x64:
|
||||||
|
i8042.stat |= 8;
|
||||||
|
switch(val){
|
||||||
|
case 0x20: i8042putbuf(0x400 | i8042.cfg); return 0;
|
||||||
|
case 0xa1: i8042putbuf(0x4f1); return 0; /* no keyboard password */
|
||||||
|
case 0xa7: i8042.cfg |= 1<<5; return 0;
|
||||||
|
case 0xa8: i8042.cfg &= ~(1<<5); return 0;
|
||||||
|
case 0xa9: i8042putbuf(0x400); return 0; /* test second port */
|
||||||
|
case 0xaa: i8042putbuf(0x455); return 0; /* test controller */
|
||||||
|
case 0xab: i8042putbuf(0x400); return 0; /* test first port */
|
||||||
|
case 0xad: i8042.cfg |= 1<<4; return 0;
|
||||||
|
case 0xae: i8042.cfg &= ~(1<<4); return 0;
|
||||||
|
case 0xd0: i8042putbuf(0x400 | i8042.oport); return 0;
|
||||||
|
case 0x60: case 0xd1: case 0xd2: case 0xd3: case 0xd4:
|
||||||
|
i8042.cmd = val;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
vmerror("unknown i8042 command %#ux", val);
|
||||||
|
return 0;
|
||||||
|
case 0x10064:
|
||||||
|
i8042kick(nil);
|
||||||
|
return i8042.stat | i8042.cfg & 4;
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "i8042");
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct UART UART;
|
||||||
|
struct UART {
|
||||||
|
u8int ier, fcr, lcr, lsr, mcr, scr, dll, dlh;
|
||||||
|
u8int rbr, tbr;
|
||||||
|
enum {
|
||||||
|
UARTTXIRQ = 1,
|
||||||
|
UARTRXIRQ = 2,
|
||||||
|
} irq;
|
||||||
|
int infd, outfd;
|
||||||
|
Channel *inch, *outch;
|
||||||
|
} uart[2] = { { .lsr = 0x60 }, { .lsr = 0x60 } };
|
||||||
|
|
||||||
|
static void
|
||||||
|
uartkick(UART *p)
|
||||||
|
{
|
||||||
|
char c;
|
||||||
|
|
||||||
|
irqline(4 - (p - uart), (p->irq & p->ier) != 0);
|
||||||
|
if((p->irq & UARTRXIRQ) == 0 && p->inch != nil && nbrecv(p->inch, &c) > 0){
|
||||||
|
p->rbr = c;
|
||||||
|
p->irq |= UARTRXIRQ;
|
||||||
|
}
|
||||||
|
if((p->lsr & 1<<5) == 0){
|
||||||
|
if(p->outch == nil){
|
||||||
|
p->lsr |= 3<<5;
|
||||||
|
p->irq |= UARTTXIRQ;
|
||||||
|
}else if(nbsend(p->outch, &p->tbr) > 0){
|
||||||
|
p->tbr = 0;
|
||||||
|
p->lsr |= 3<<5;
|
||||||
|
p->irq |= UARTTXIRQ;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
irqline(4 - (p - uart), (p->irq & p->ier) != 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
uartio(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
UART *p;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
if((port & 0xff8) == 0x3f8) p = &uart[0];
|
||||||
|
else if((port & 0xff8) == 0x2f8) p = &uart[1];
|
||||||
|
else return 0;
|
||||||
|
|
||||||
|
val = (u8int) val;
|
||||||
|
switch(isin << 4 | port & 7){
|
||||||
|
case 0x00:
|
||||||
|
if((p->lcr & 1<<7) != 0)
|
||||||
|
p->dll = val;
|
||||||
|
else{ /* transmit byte */
|
||||||
|
if((p->mcr & 1<<4) != 0){
|
||||||
|
p->irq |= UARTRXIRQ;
|
||||||
|
p->rbr = val;
|
||||||
|
p->lsr |= 3<<5;
|
||||||
|
}else{
|
||||||
|
p->tbr = val;
|
||||||
|
p->lsr &= ~(3<<5);
|
||||||
|
p->irq &= ~UARTTXIRQ;
|
||||||
|
}
|
||||||
|
uartkick(p);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
case 0x01:
|
||||||
|
if((p->lcr & 1<<7) != 0)
|
||||||
|
p->dlh = val;
|
||||||
|
else
|
||||||
|
p->ier = val & 15;
|
||||||
|
return 0;
|
||||||
|
case 0x02: p->fcr = val; return 0;
|
||||||
|
case 0x03: p->lcr = val; return 0;
|
||||||
|
case 0x04: p->mcr = val & 0x1f; return 0;
|
||||||
|
case 0x07: p->scr = val; return 0;
|
||||||
|
case 0x10:
|
||||||
|
if((p->lcr & 1<<7) != 0) return p->dll;
|
||||||
|
p->irq &= ~UARTRXIRQ;
|
||||||
|
rc = p->rbr;
|
||||||
|
uartkick(p);
|
||||||
|
return rc;
|
||||||
|
case 0x11:
|
||||||
|
if((p->lcr & 1<<7) != 0) return p->dlh;
|
||||||
|
return p->ier;
|
||||||
|
case 0x12:
|
||||||
|
rc = (p->fcr & 1) != 0 ? 0x40 : 0;
|
||||||
|
uartkick(p);
|
||||||
|
if((p->irq & UARTRXIRQ) != 0)
|
||||||
|
return rc | 4;
|
||||||
|
else if((p->irq & UARTTXIRQ) != 0){
|
||||||
|
p->irq &= ~UARTTXIRQ;
|
||||||
|
uartkick(p);
|
||||||
|
return rc | 2;
|
||||||
|
}else
|
||||||
|
return rc | 1;
|
||||||
|
case 0x13: return p->lcr;
|
||||||
|
case 0x14: return p->mcr;
|
||||||
|
case 0x15:
|
||||||
|
uartkick(p);
|
||||||
|
rc = p->lsr; /* line status */
|
||||||
|
if((p->irq & UARTRXIRQ) != 0)
|
||||||
|
rc |= 1;
|
||||||
|
return rc;
|
||||||
|
case 0x16: /* modem status */
|
||||||
|
if((p->mcr & 0x10) != 0)
|
||||||
|
return p->mcr << 1 & 2 | p->mcr >> 1 & 1 | p->mcr & 0xc;
|
||||||
|
return 0;
|
||||||
|
case 0x17: return p->scr;
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "uart");
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
uartrxproc(void *uv)
|
||||||
|
{
|
||||||
|
UART *u;
|
||||||
|
char buf[128], *p;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
threadsetname("uart rx");
|
||||||
|
u = uv;
|
||||||
|
for(;;){
|
||||||
|
rc = read(u->infd, buf, sizeof(buf));
|
||||||
|
if(rc < 0){
|
||||||
|
vmerror("read(uartrx): %r");
|
||||||
|
threadexits("read: %r");
|
||||||
|
}
|
||||||
|
if(rc == 0){
|
||||||
|
vmerror("read(uartrx): eof");
|
||||||
|
threadexits("read: eof");
|
||||||
|
}
|
||||||
|
for(p = buf; p < buf + rc; p++){
|
||||||
|
send(u->inch, p);
|
||||||
|
sendnotif((void(*)(void*))uartkick, u);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
uarttxproc(void *uv)
|
||||||
|
{
|
||||||
|
UART *u;
|
||||||
|
char buf[128], *p;
|
||||||
|
|
||||||
|
threadsetname("uart tx");
|
||||||
|
u = uv;
|
||||||
|
for(;;){
|
||||||
|
p = buf;
|
||||||
|
recv(u->outch, p);
|
||||||
|
p++;
|
||||||
|
while(sendnotif((void(*)(void*))uartkick, u), p < buf+sizeof(buf) && nbrecv(u->outch, p) > 0)
|
||||||
|
p++;
|
||||||
|
if(write(u->outfd, buf, p - buf) < p - buf)
|
||||||
|
vmdebug("write(uarttx): %r");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
uartinit(int n, char *cfg)
|
||||||
|
{
|
||||||
|
char *p, *infn, *outfn;
|
||||||
|
|
||||||
|
p = strchr(cfg, ',');
|
||||||
|
if(p == nil){
|
||||||
|
infn = cfg;
|
||||||
|
outfn = cfg;
|
||||||
|
}else{
|
||||||
|
*p = 0;
|
||||||
|
infn = cfg;
|
||||||
|
outfn = p + 1;
|
||||||
|
}
|
||||||
|
if(infn != nil && *infn != 0){
|
||||||
|
uart[n].infd = open(infn, OREAD);
|
||||||
|
if(uart[n].infd < 0)
|
||||||
|
sysfatal("open: %r");
|
||||||
|
uart[n].inch = chancreate(sizeof(char), 256);
|
||||||
|
proccreate(uartrxproc, &uart[n], 4096);
|
||||||
|
}
|
||||||
|
if(outfn != nil && *outfn != 0){
|
||||||
|
uart[n].outfd = open(outfn, OWRITE);
|
||||||
|
if(uart[n].outfd < 0)
|
||||||
|
sysfatal("open: %r");
|
||||||
|
uart[n].outch = chancreate(sizeof(char), 256);
|
||||||
|
proccreate(uarttxproc, &uart[n], 4096);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
nopio(int, u16int, u32int, int, void *)
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
iowhine(int isin, u16int port, u32int val, int sz, void *mod)
|
||||||
|
{
|
||||||
|
if(isin)
|
||||||
|
vmerror("%s%sread from unknown i/o port %#ux ignored (sz=%d)", mod != nil ? mod : "", mod != nil ? ": " : "", port, sz);
|
||||||
|
else
|
||||||
|
vmerror("%s%swrite to unknown i/o port %#ux ignored (val=%#ux, sz=%d)", mod != nil ? mod : "", mod != nil ? ": " : "", port, val, sz);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct IOHandler IOHandler;
|
||||||
|
struct IOHandler {
|
||||||
|
u16int lo, hi;
|
||||||
|
u32int (*io)(int, u16int, u32int, int, void *);
|
||||||
|
void *aux;
|
||||||
|
};
|
||||||
|
|
||||||
|
u32int vgaio(int, u16int, u32int, int, void *);
|
||||||
|
u32int pciio(int, u16int, u32int, int, void *);
|
||||||
|
IOHandler handlers[] = {
|
||||||
|
0x20, 0x21, picio, nil,
|
||||||
|
0x40, 0x43, pitio, nil,
|
||||||
|
0x70, 0x71, rtcio, nil,
|
||||||
|
0xa0, 0xa1, picio, nil,
|
||||||
|
0x60, 0x60, i8042io, nil,
|
||||||
|
0x64, 0x64, i8042io, nil,
|
||||||
|
0x2f8, 0x2ff, uartio, nil,
|
||||||
|
0x3d4, 0x3d5, vgaio, nil,
|
||||||
|
0x3f8, 0x3ff, uartio, nil,
|
||||||
|
0x4d0, 0x4d1, picio, nil,
|
||||||
|
0xcf8, 0xcff, pciio, nil,
|
||||||
|
|
||||||
|
0x061, 0x061, nopio, nil, /* pc speaker */
|
||||||
|
0x110, 0x110, nopio, nil, /* elnk3 */
|
||||||
|
0x170, 0x177, nopio, nil, /* ide secondary */
|
||||||
|
0x1f0, 0x1f7, nopio, nil, /* ide primary */
|
||||||
|
0x280, 0x28f, nopio, nil, /* 8003 */
|
||||||
|
0x378, 0x37a, nopio, nil, /* LPT1 */
|
||||||
|
0x3e0, 0x3e3, nopio, nil, /* cardbus */
|
||||||
|
0x3f0, 0x3f5, nopio, nil, /* floppy */
|
||||||
|
0x778, 0x77a, nopio, nil, /* LPT1 (ECP) */
|
||||||
|
};
|
||||||
|
|
||||||
|
u32int
|
||||||
|
io(int dir, u16int port, u32int val, int size)
|
||||||
|
{
|
||||||
|
IOHandler *h;
|
||||||
|
extern PCIBar iobars;
|
||||||
|
PCIBar *p;
|
||||||
|
|
||||||
|
for(h = handlers; h < handlers + nelem(handlers); h++)
|
||||||
|
if(port >= h->lo && port <= h->hi)
|
||||||
|
return h->io(dir, port, val, size, h->aux);
|
||||||
|
for(p = iobars.busnext; p != &iobars; p = p->busnext)
|
||||||
|
if(port >= p->addr && port < p->addr + p->length)
|
||||||
|
return p->io(dir, port - p->addr, val, size, p->aux);
|
||||||
|
return iowhine(dir, port, val, size, nil);
|
||||||
|
}
|
||||||
168
sys/src/cmd/vmx/ksetup.c
Normal file
168
sys/src/cmd/vmx/ksetup.c
Normal file
|
|
@ -0,0 +1,168 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
static uchar hdr[8192];
|
||||||
|
static int fd;
|
||||||
|
|
||||||
|
extern int bootmodn;
|
||||||
|
extern char **bootmod;
|
||||||
|
|
||||||
|
static int
|
||||||
|
putmmap(uchar *p0)
|
||||||
|
{
|
||||||
|
u32int *p;
|
||||||
|
Region *r;
|
||||||
|
|
||||||
|
p = (u32int *) p0;
|
||||||
|
for(r = mmap; r != nil; r = r->next){
|
||||||
|
if(r->type != REGMEM) continue;
|
||||||
|
if(gavail(p) < 20) sysfatal("out of guest memory");
|
||||||
|
p[0] = 20;
|
||||||
|
p[1] = r->start;
|
||||||
|
p[2] = r->end - r->start;
|
||||||
|
p[3] = 1;
|
||||||
|
}
|
||||||
|
return (uchar *) p - p0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
putcmdline(uchar *p0)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
char *p, *e;
|
||||||
|
extern int cmdlinen;
|
||||||
|
extern char **cmdlinev;
|
||||||
|
|
||||||
|
if(cmdlinen == 0) return 0;
|
||||||
|
p = (char*)p0;
|
||||||
|
e = gend(p0);
|
||||||
|
if(p >= e) return 0;
|
||||||
|
for(i = 0; i < cmdlinen; i++){
|
||||||
|
p = strecpy(p, e, cmdlinev[i]);
|
||||||
|
if(i != cmdlinen - 1) *p++ = ' ';
|
||||||
|
}
|
||||||
|
return p - (char*)p0 + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
putmods(uchar *p0)
|
||||||
|
{
|
||||||
|
int i, fd, rc;
|
||||||
|
u32int *p;
|
||||||
|
uchar *q;
|
||||||
|
char dummy;
|
||||||
|
|
||||||
|
if(bootmodn == 0) return 0;
|
||||||
|
p = (u32int*)p0;
|
||||||
|
q = (uchar*)(p + 4 * bootmodn);
|
||||||
|
for(i = 0; i < bootmodn; i++){
|
||||||
|
q = gptr(-(-gpa(q) & -BY2PG), 1);
|
||||||
|
if(q == nil) sysfatal("out of guest memory");
|
||||||
|
fd = open(bootmod[i], OREAD);
|
||||||
|
if(fd == -1) sysfatal("module open: %r");
|
||||||
|
p[0] = gpa(q);
|
||||||
|
rc = readn(fd, q, gavail(q));
|
||||||
|
if(rc < 0) sysfatal("module read: %r");
|
||||||
|
if(read(fd, &dummy, 1) == 1) sysfatal("out of guest memory");
|
||||||
|
close(fd);
|
||||||
|
q += rc;
|
||||||
|
p[1] = gpa(q);
|
||||||
|
p[2] = 0;
|
||||||
|
p[3] = 0;
|
||||||
|
p += 4;
|
||||||
|
}
|
||||||
|
bootmodn = ((uchar*)p - p0) / 16;
|
||||||
|
return q - p0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
trymultiboot(void)
|
||||||
|
{
|
||||||
|
u32int *p, flags;
|
||||||
|
u32int header, load, loadend, bssend, entry;
|
||||||
|
u32int filestart;
|
||||||
|
uchar *gp;
|
||||||
|
uchar *modp;
|
||||||
|
int len;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
for(p = (u32int*)hdr; p < (u32int*)hdr + sizeof(hdr)/4; p++)
|
||||||
|
if(*p == 0x1badb002)
|
||||||
|
break;
|
||||||
|
if(p == (u32int*)hdr + sizeof(hdr)/4)
|
||||||
|
return 0;
|
||||||
|
if((u32int)(p[0] + p[1] + p[2]) != 0)
|
||||||
|
sysfatal("invalid multiboot checksum");
|
||||||
|
flags = p[1];
|
||||||
|
if((flags & 1<<16) == 0)
|
||||||
|
sysfatal("no size info in multiboot header");
|
||||||
|
header = p[3];
|
||||||
|
load = p[4];
|
||||||
|
loadend = p[5];
|
||||||
|
bssend = p[6];
|
||||||
|
entry = p[7];
|
||||||
|
filestart = (uchar*)p - hdr - (header - load);
|
||||||
|
gp = gptr(load, bssend != 0 ? bssend - load : loadend != 0 ? loadend - load : BY2PG);
|
||||||
|
if(gp == nil)
|
||||||
|
sysfatal("kernel image out of bounds");
|
||||||
|
seek(fd, filestart, 0);
|
||||||
|
if(loadend == 0){
|
||||||
|
rc = readn(fd, gp, gavail(gp));
|
||||||
|
if(rc <= 0) sysfatal("readn: %r");
|
||||||
|
loadend = load + rc;
|
||||||
|
}else{
|
||||||
|
rc = readn(fd, gp, loadend - load);
|
||||||
|
if(rc < 0) sysfatal("readn: %r");
|
||||||
|
if(rc < loadend - load) sysfatal("short kernel image");
|
||||||
|
}
|
||||||
|
if(bssend == 0) bssend = loadend;
|
||||||
|
bssend = -(-bssend & -BY2PG);
|
||||||
|
p = gptr(bssend, 128);
|
||||||
|
if(p == nil) sysfatal("no space for multiboot structure");
|
||||||
|
p[0] = 1<<0;
|
||||||
|
p[1] = gavail(gptr(0, 0)) >> 10;
|
||||||
|
if(p[1] > 640) p[1] = 640;
|
||||||
|
p[2] = gavail(gptr(1048576, 0)) >> 10;
|
||||||
|
modp = gptr(bssend + 128, 1);
|
||||||
|
if(modp == nil) sysfatal("out of guest memory");
|
||||||
|
len = putmmap(modp);
|
||||||
|
if(len != 0){
|
||||||
|
p[0] |= 1<<6;
|
||||||
|
p[11] = len;
|
||||||
|
p[12] = gpa(modp);
|
||||||
|
modp += len;
|
||||||
|
}
|
||||||
|
len = putcmdline(modp);
|
||||||
|
if(len != 0){
|
||||||
|
p[0] |= 1<<2;
|
||||||
|
p[4] = gpa(modp);
|
||||||
|
modp += len + 7 & -8;
|
||||||
|
}
|
||||||
|
len = putmods(modp);
|
||||||
|
if(len != 0){
|
||||||
|
p[0] |= 1<<3;
|
||||||
|
p[5] = bootmodn;
|
||||||
|
p[6] = gpa(modp);
|
||||||
|
modp += len + 7 & -8;
|
||||||
|
}
|
||||||
|
|
||||||
|
USED(modp);
|
||||||
|
rset(RPC, entry);
|
||||||
|
rset(RAX, 0x2badb002);
|
||||||
|
rset(RBX, bssend);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
loadkernel(char *fn)
|
||||||
|
{
|
||||||
|
fd = open(fn, OREAD);
|
||||||
|
if(fd < 0) sysfatal("open: %r");
|
||||||
|
if(readn(fd, hdr, sizeof(hdr)) <= 0)
|
||||||
|
sysfatal("readn: %r");
|
||||||
|
if(!trymultiboot())
|
||||||
|
sysfatal("%s: unknown format", fn);
|
||||||
|
close(fd);
|
||||||
|
}
|
||||||
15
sys/src/cmd/vmx/mkfile
Normal file
15
sys/src/cmd/vmx/mkfile
Normal file
|
|
@ -0,0 +1,15 @@
|
||||||
|
</$objtype/mkfile
|
||||||
|
|
||||||
|
BIN=/$objtype/bin
|
||||||
|
TARG=vmx
|
||||||
|
HFILES=dat.h fns.h
|
||||||
|
OFILES=\
|
||||||
|
vmx.$O \
|
||||||
|
ksetup.$O \
|
||||||
|
exith.$O \
|
||||||
|
io.$O \
|
||||||
|
vga.$O \
|
||||||
|
pci.$O \
|
||||||
|
virtio.$O \
|
||||||
|
|
||||||
|
</sys/src/cmd/mkone
|
||||||
304
sys/src/cmd/vmx/pci.c
Normal file
304
sys/src/cmd/vmx/pci.c
Normal file
|
|
@ -0,0 +1,304 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include <thread.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
PCIDev *pcidevs;
|
||||||
|
PCIBar membars, iobars;
|
||||||
|
|
||||||
|
PCIDev *
|
||||||
|
mkpcidev(u32int bdf, u32int viddid, u32int clrev, int needirq)
|
||||||
|
{
|
||||||
|
PCIDev *d;
|
||||||
|
int n;
|
||||||
|
|
||||||
|
d = emalloc(sizeof(PCIDev));
|
||||||
|
d->bdf = bdf;
|
||||||
|
d->viddid = viddid;
|
||||||
|
d->clrev = clrev;
|
||||||
|
d->next = pcidevs;
|
||||||
|
d->irqno = needirq ? 0 : 0xff;
|
||||||
|
for(n = 0; n < nelem(d->bar); n++){
|
||||||
|
d->bar[n].d = d;
|
||||||
|
d->bar[n].busnext = &d->bar[n];
|
||||||
|
d->bar[n].busprev = &d->bar[n];
|
||||||
|
}
|
||||||
|
d->capalloc = 64;
|
||||||
|
pcidevs = d;
|
||||||
|
return d;
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
allocbdf(void)
|
||||||
|
{
|
||||||
|
static int dev = 1;
|
||||||
|
|
||||||
|
return BDF(0, dev++, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
PCIBar *
|
||||||
|
mkpcibar(PCIDev *d, u8int t, u32int l, void *fn, void *aux)
|
||||||
|
{
|
||||||
|
PCIBar *b;
|
||||||
|
|
||||||
|
assert((t & 1) == 0 || (t & 2) == 0);
|
||||||
|
assert((t & 1) != 0 || (t & 6) == 0);
|
||||||
|
if((t & 1) != 0 && l < 4) l = 4;
|
||||||
|
if((t & 1) == 0 && l < 4096) l = 4096;
|
||||||
|
if((l & l-1) != 0){
|
||||||
|
do
|
||||||
|
l &= l-1;
|
||||||
|
while((l & l-1) == 0);
|
||||||
|
l <<= 1;
|
||||||
|
assert(l != 0);
|
||||||
|
}
|
||||||
|
for(b = d->bar; b < d->bar + nelem(d->bar); b++)
|
||||||
|
if(b->length == 0)
|
||||||
|
break;
|
||||||
|
b->type = t;
|
||||||
|
b->length = l;
|
||||||
|
b->busnext = b;
|
||||||
|
b->busprev = b;
|
||||||
|
b->d = d;
|
||||||
|
if((b->type & 1) != 0)
|
||||||
|
b->io = fn;
|
||||||
|
b->aux = aux;
|
||||||
|
return b;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
updatebar(PCIBar *b)
|
||||||
|
{
|
||||||
|
b->busnext->busprev = b->busprev;
|
||||||
|
b->busprev->busnext = b->busnext;
|
||||||
|
b->busnext = b;
|
||||||
|
b->busprev = b;
|
||||||
|
if(b->length == 0) return;
|
||||||
|
if((b->type & 1) == 0){
|
||||||
|
if((b->d->ctrl & 2) == 0) return;
|
||||||
|
b->busnext = &membars;
|
||||||
|
b->busprev = membars.busprev;
|
||||||
|
b->busnext->busprev = b;
|
||||||
|
b->busprev->busnext = b;
|
||||||
|
}else{
|
||||||
|
if((b->d->ctrl & 1) == 0 || b->addr == 0 || b->io == nil) return;
|
||||||
|
b->busnext = &iobars;
|
||||||
|
b->busprev = iobars.busprev;
|
||||||
|
b->busnext->busprev = b;
|
||||||
|
b->busprev->busnext = b;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
pciirqupdate(void)
|
||||||
|
{
|
||||||
|
PCIDev *d;
|
||||||
|
int irqs, act, i;
|
||||||
|
|
||||||
|
irqs = 0;
|
||||||
|
act = 0;
|
||||||
|
for(d = pcidevs; d != nil; d = d->next){
|
||||||
|
if(d->irqno < 16){
|
||||||
|
irqs |= 1<<d->irqno;
|
||||||
|
act |= d->irqactive<<d->irqno;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for(i = 0; i < 16; i++)
|
||||||
|
if((irqs & 1<<i) != 0)
|
||||||
|
irqline(i, ~act>>i & 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
PCICap *
|
||||||
|
mkpcicap(PCIDev *d, u8int length, u32int (*readf)(PCICap *, u8int), void (*writef)(PCICap *, u8int, u32int, u32int))
|
||||||
|
{
|
||||||
|
PCICap *c, **p;
|
||||||
|
|
||||||
|
assert(readf != nil);
|
||||||
|
if(d->capalloc + length > 256)
|
||||||
|
sysfatal("mkpcicap (dev %#ux): out of configuration space", d->bdf);
|
||||||
|
c = emalloc(sizeof(PCICap));
|
||||||
|
c->dev = d;
|
||||||
|
c->read = readf;
|
||||||
|
c->write = writef;
|
||||||
|
c->length = length;
|
||||||
|
|
||||||
|
c->addr = d->capalloc;
|
||||||
|
d->capalloc += length;
|
||||||
|
for(p = &d->cap; *p != nil; p = &(*p)->next)
|
||||||
|
;
|
||||||
|
*p = c;
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
static PCIDev *
|
||||||
|
findpcidev(u32int bdf)
|
||||||
|
{
|
||||||
|
PCIDev *d;
|
||||||
|
|
||||||
|
for(d = pcidevs; d != nil; d = d->next)
|
||||||
|
if(d->bdf == bdf)
|
||||||
|
return d;
|
||||||
|
return nil;
|
||||||
|
}
|
||||||
|
|
||||||
|
static PCICap *
|
||||||
|
findpcicap(PCIDev *d, u8int addr)
|
||||||
|
{
|
||||||
|
PCICap *c;
|
||||||
|
|
||||||
|
for(c = d->cap; c != nil; c = c->next)
|
||||||
|
if((uint)(addr - c->addr) < c->length)
|
||||||
|
return c;
|
||||||
|
return nil;
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32int
|
||||||
|
pciread(PCIDev *d, int addr)
|
||||||
|
{
|
||||||
|
u32int val;
|
||||||
|
PCICap *c;
|
||||||
|
int n;
|
||||||
|
|
||||||
|
switch(addr){
|
||||||
|
case 0x00: return d->viddid;
|
||||||
|
case 0x04: return 0xa00000 | (d->cap != nil ? 1<<20 : 0) | d->ctrl;
|
||||||
|
case 0x08: return d->clrev;
|
||||||
|
case 0x0c: return 0; /* BIST, Header Type, Latency Timer, Cache Size */
|
||||||
|
case 0x10: case 0x14: case 0x18: case 0x1c: case 0x20: case 0x24:
|
||||||
|
n = addr - 0x10 >> 2;
|
||||||
|
return d->bar[n].addr | d->bar[n].type;
|
||||||
|
case 0x28: return 0; /* Cardbus */
|
||||||
|
case 0x2c: return d->subid; /* Subsystem ID */
|
||||||
|
case 0x30: return 0; /* Expansion ROM */
|
||||||
|
case 0x34: return d->cap != nil ? d->cap->addr : 0; /* Capabilities */
|
||||||
|
case 0x38: return 0; /* Reserved */
|
||||||
|
case 0x3c: return 1 << 8 | d->irqno; /* Max_Lat, Min_Gnt, IRQ Pin, IRQ Line */
|
||||||
|
}
|
||||||
|
c = findpcicap(d, addr);
|
||||||
|
if(c != nil){
|
||||||
|
val = c->read(c, addr - c->addr);
|
||||||
|
if(addr == c->addr){
|
||||||
|
val &= ~0xff00;
|
||||||
|
if(c->next != nil)
|
||||||
|
val |= c->next->addr << 8;
|
||||||
|
}
|
||||||
|
return val;
|
||||||
|
}
|
||||||
|
vmdebug("pcidev %.6ux: ignoring read from addr %#ux", d->bdf, addr);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
pciwrite(PCIDev *d, int addr, u32int val, u32int mask)
|
||||||
|
{
|
||||||
|
int n;
|
||||||
|
PCICap *c;
|
||||||
|
|
||||||
|
switch(addr){
|
||||||
|
case 0x04:
|
||||||
|
d->ctrl = (d->ctrl & ~mask | val & mask) & 0x21f;
|
||||||
|
for(n = 0; n < nelem(d->bar); n++)
|
||||||
|
updatebar(&d->bar[n]);
|
||||||
|
return;
|
||||||
|
case 0x10: case 0x14: case 0x18: case 0x1c: case 0x20: case 0x24:
|
||||||
|
n = addr - 0x10 >> 2;
|
||||||
|
val &= (d->bar[n].type & 1) != 0 ? ~15 : ~3;
|
||||||
|
d->bar[n].addr = (d->bar[n].addr & ~mask | val & mask) & ~(d->bar[n].length - 1);
|
||||||
|
updatebar(&d->bar[n]);
|
||||||
|
return;
|
||||||
|
case 0x3c: d->irqno = (d->irqno & ~mask | val & mask) & 0xff; pciirqupdate(); return;
|
||||||
|
}
|
||||||
|
c = findpcicap(d, addr);
|
||||||
|
if(c != nil && c->write != nil){
|
||||||
|
c->write(c, addr - c->addr, val, mask);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
vmdebug("pcidev %.6ux: ignoring write to addr %#ux, val %#ux", d->bdf, addr, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
pciio(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
static u32int cfgaddr;
|
||||||
|
u32int mask;
|
||||||
|
PCIDev *d;
|
||||||
|
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x0cf8: cfgaddr = val; return 0;
|
||||||
|
case 0x10cf8: return cfgaddr;
|
||||||
|
case 0xcfc: case 0xcfd: case 0xcfe: case 0xcff:
|
||||||
|
val <<= 8 * (port & 3);
|
||||||
|
mask = -1UL >> 32 - 8 * sz << 8 * (port & 3);
|
||||||
|
if((cfgaddr & 1<<31) != 0 && (d = findpcidev(cfgaddr & 0xffff00), d != nil))
|
||||||
|
pciwrite(d, cfgaddr & 0xfc, val, mask);
|
||||||
|
return 0;
|
||||||
|
case 0x10cfc: case 0x10cfd: case 0x10cfe: case 0x10cff:
|
||||||
|
if((cfgaddr & 1<<31) == 0 || (d = findpcidev(cfgaddr & 0xffff00), d == nil))
|
||||||
|
return -1;
|
||||||
|
return pciread(d, cfgaddr & 0xfc) >> 8 * (port & 3);
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "pci");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
pciirq(PCIDev *d, int status)
|
||||||
|
{
|
||||||
|
d->irqactive = status != 0;
|
||||||
|
pciirqupdate();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
pciinit(void)
|
||||||
|
{
|
||||||
|
iobars.busnext = &iobars;
|
||||||
|
iobars.busprev = &iobars;
|
||||||
|
membars.busprev = &membars;
|
||||||
|
membars.busnext = &membars;
|
||||||
|
mkpcidev(BDF(0,0,0), 0x01008086, 0x06000000, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
pcibusmap(void)
|
||||||
|
{
|
||||||
|
u16int iop;
|
||||||
|
u16int irqs, uirqs;
|
||||||
|
PCIDev *d;
|
||||||
|
PCIBar *b;
|
||||||
|
int irq;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
iop = 0x1000;
|
||||||
|
irqs = 1<<5|1<<7|1<<9|1<<10|1<<11|1<<14|1<<15;
|
||||||
|
uirqs = 0;
|
||||||
|
irq = 0;
|
||||||
|
for(d = pcidevs; d != nil; d = d->next){
|
||||||
|
d->ctrl |= 3;
|
||||||
|
for(b = d->bar; b < d->bar + nelem(d->bar); b++){
|
||||||
|
if(b->length == 0)
|
||||||
|
continue;
|
||||||
|
if((b->type & 1) == 0){
|
||||||
|
vmerror("pci device %.6ux: memory bars unsupported", d->bdf);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if(iop + b->length >= 0x10000){
|
||||||
|
vmerror("pci device %.6ux: not enough I/O address space for BAR%d (len=%d)", d->bdf, (int)(b - d->bar), b->length);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
b->addr = iop;
|
||||||
|
iop += b->length;
|
||||||
|
updatebar(b);
|
||||||
|
}
|
||||||
|
if(d->irqno == 0){
|
||||||
|
do
|
||||||
|
irq = irq + 1 & 15;
|
||||||
|
while((irqs & 1<<irq) == 0);
|
||||||
|
d->irqno = irq;
|
||||||
|
uirqs |= 1<<irq;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
elcr(uirqs);
|
||||||
|
for(i = 0; i < 16; i++)
|
||||||
|
if((uirqs & 1<<i) != 0)
|
||||||
|
irqline(i, 1);
|
||||||
|
}
|
||||||
431
sys/src/cmd/vmx/vga.c
Normal file
431
sys/src/cmd/vmx/vga.c
Normal file
|
|
@ -0,0 +1,431 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include <bio.h>
|
||||||
|
#include <thread.h>
|
||||||
|
#include <draw.h>
|
||||||
|
#include <cursor.h>
|
||||||
|
#include <mouse.h>
|
||||||
|
#include <keyboard.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
static uchar *fb;
|
||||||
|
uintptr fbsz;
|
||||||
|
uintptr fbaddr;
|
||||||
|
int textmode;
|
||||||
|
static ulong screenchan;
|
||||||
|
|
||||||
|
static int picw, pich, hbytes;
|
||||||
|
static Image *img, *bg;
|
||||||
|
static Mousectl *mc;
|
||||||
|
static Rectangle picr;
|
||||||
|
Channel *kbdch, *mousech;
|
||||||
|
static u16int cursorpos;
|
||||||
|
u8int mousegrab;
|
||||||
|
static uchar *sfb;
|
||||||
|
|
||||||
|
static void
|
||||||
|
screeninit(void)
|
||||||
|
{
|
||||||
|
Point p;
|
||||||
|
|
||||||
|
p = divpt(addpt(screen->r.min, screen->r.max), 2);
|
||||||
|
picr = (Rectangle){subpt(p, Pt(picw/2, pich/2)), addpt(p, Pt((picw+1)/2, (pich+1)/2))};
|
||||||
|
bg = allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0xCCCCCCFF);
|
||||||
|
img = allocimage(display, Rect(0, 0, picw, pich), screenchan == 0 ? screen->chan : screenchan, 0, 0);
|
||||||
|
draw(screen, screen->r, bg, nil, ZP);
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
vgaio(int isin, u16int port, u32int val, int sz, void *)
|
||||||
|
{
|
||||||
|
static u8int cgaidx;
|
||||||
|
|
||||||
|
val = (u8int) val;
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x3d4:
|
||||||
|
cgaidx = val;
|
||||||
|
return 0;
|
||||||
|
case 0x103d4:
|
||||||
|
return cgaidx;
|
||||||
|
case 0x3d5:
|
||||||
|
switch(cgaidx){
|
||||||
|
case 14:
|
||||||
|
cursorpos = cursorpos >> 8 | val << 8;
|
||||||
|
break;
|
||||||
|
case 15:
|
||||||
|
cursorpos = cursorpos & 0xff00 | val;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
vmerror("write to unknown VGA register, 3d5/%#ux (val=%#ux)", cgaidx, val);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
case 0x103d5:
|
||||||
|
switch(cgaidx){
|
||||||
|
case 14:
|
||||||
|
return cursorpos >> 8;
|
||||||
|
case 15:
|
||||||
|
return (u8int)cursorpos;
|
||||||
|
default:
|
||||||
|
vmerror("read from unknown VGA register, 3d5/%#ux", cgaidx);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "vga");
|
||||||
|
}
|
||||||
|
|
||||||
|
typedef struct Key Key;
|
||||||
|
struct Key {
|
||||||
|
Rune r;
|
||||||
|
int code;
|
||||||
|
Key *next;
|
||||||
|
};
|
||||||
|
Key *kbdmap[128];
|
||||||
|
|
||||||
|
static void
|
||||||
|
defkey(Rune r, int code)
|
||||||
|
{
|
||||||
|
Key *k, **kp;
|
||||||
|
|
||||||
|
for(kp = &kbdmap[r % nelem(kbdmap)]; *kp != nil; kp = &(*kp)->next)
|
||||||
|
if((*kp)->r == r)
|
||||||
|
return;
|
||||||
|
k = emalloc(sizeof(Key));
|
||||||
|
k->r = r;
|
||||||
|
k->code = code;
|
||||||
|
*kp = k;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
kbdlayout(char *fn)
|
||||||
|
{
|
||||||
|
Biobuf *bp;
|
||||||
|
char *s, *p, *f[10];
|
||||||
|
int nf, x, y;
|
||||||
|
Rune z;
|
||||||
|
|
||||||
|
defkey(Kshift, 0x2a);
|
||||||
|
defkey(Kctl, 0x1d);
|
||||||
|
defkey(Kalt, 0x38);
|
||||||
|
defkey(Kctl, 0x11d);
|
||||||
|
defkey(Kprint, 0x137);
|
||||||
|
defkey(Kaltgr, 0x138);
|
||||||
|
defkey(Kbreak, 0x146);
|
||||||
|
defkey(Khome, 0x147);
|
||||||
|
defkey(Kup, 0x148);
|
||||||
|
defkey(Kpgup, 0x149);
|
||||||
|
defkey(Kleft, 0x14b);
|
||||||
|
defkey(Kright, 0x14d);
|
||||||
|
defkey(Kend, 0x14f);
|
||||||
|
defkey(Kdown, 0x150);
|
||||||
|
defkey(Kpgdown, 0x151);
|
||||||
|
defkey(Kins, 0x152);
|
||||||
|
defkey(Kdel, 0x153);
|
||||||
|
defkey(Kup, 0x179);
|
||||||
|
|
||||||
|
bp = Bopen(fn, OREAD);
|
||||||
|
if(bp == nil){
|
||||||
|
vmerror("kbdlayout: %r");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
for(;; free(s)){
|
||||||
|
s = Brdstr(bp, '\n', 1);
|
||||||
|
if(s == nil) break;
|
||||||
|
nf = getfields(s, f, nelem(f), 1, " \t");
|
||||||
|
if(nf < 3) continue;
|
||||||
|
x = strtol(f[0], &p, 0);
|
||||||
|
if(*p != 0) continue;
|
||||||
|
y = strtol(f[1], &p, 0);
|
||||||
|
if(*p != 0) continue;
|
||||||
|
if(*f[2] == '\'' || *f[2] == '^'){
|
||||||
|
chartorune(&z, f[2]+1);
|
||||||
|
if(*f[2] == '^') z -= '@';
|
||||||
|
}else{
|
||||||
|
z = strtol(f[2], &p, 0);
|
||||||
|
if(*p != 0) continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if(x != 0 || z == 0) continue;
|
||||||
|
defkey(z, y);
|
||||||
|
}
|
||||||
|
Bterm(bp);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
keyproc(void *)
|
||||||
|
{
|
||||||
|
int fd, n;
|
||||||
|
static char buf[256];
|
||||||
|
static uvlong kdown[8], nkdown[8];
|
||||||
|
uvlong set, rls;
|
||||||
|
int i, j;
|
||||||
|
char *s;
|
||||||
|
Rune r;
|
||||||
|
Key *k;
|
||||||
|
|
||||||
|
threadsetname("keyproc");
|
||||||
|
fd = open("/dev/kbd", OREAD);
|
||||||
|
if(fd < 0)
|
||||||
|
sysfatal("open: %r");
|
||||||
|
for(;;){
|
||||||
|
if(buf[0] != 0){
|
||||||
|
n = strlen(buf)+1;
|
||||||
|
memmove(buf, buf+n, sizeof(buf)-n);
|
||||||
|
}
|
||||||
|
if(buf[0] == 0){
|
||||||
|
n = read(fd, buf, sizeof(buf)-1);
|
||||||
|
if(n <= 0)
|
||||||
|
sysfatal("read /dev/kbd: %r");
|
||||||
|
buf[n-1] = 0;
|
||||||
|
buf[n] = 0;
|
||||||
|
}
|
||||||
|
if(buf[0] != 'k' && buf[0] != 'K')
|
||||||
|
continue;
|
||||||
|
s = buf + 1;
|
||||||
|
memset(nkdown, 0, sizeof(nkdown));
|
||||||
|
while(*s != 0){
|
||||||
|
s += chartorune(&r, s);
|
||||||
|
for(k = kbdmap[r % nelem(kbdmap)]; k != nil; k = k->next)
|
||||||
|
if(k->r == r){
|
||||||
|
nkdown[k->code >> 6] |= 1ULL<<(k->code&63);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if(k == nil) vmerror("unknown key %d", r);
|
||||||
|
}
|
||||||
|
if(mousegrab && (nkdown[0]>>29 & 1) != 0 && (nkdown[0]>>56 & 1) != 0){
|
||||||
|
mousegrab = 0;
|
||||||
|
setcursor(mc, nil);
|
||||||
|
}
|
||||||
|
for(i = 0; i < 8; i++){
|
||||||
|
if(nkdown[i] == kdown[i]) continue;
|
||||||
|
set = nkdown[i] & ~kdown[i];
|
||||||
|
rls = ~nkdown[i] & kdown[i];
|
||||||
|
for(j = 0; j < 64; j++, set>>=1, rls >>= 1)
|
||||||
|
if(((set|rls) & 1) != 0){
|
||||||
|
if(i >= 4)
|
||||||
|
sendul(kbdch, 0xe0);
|
||||||
|
sendul(kbdch, j | i<<6&0xff | ((rls&1) != 0 ? 0x80 : 0));
|
||||||
|
sendnotif(i8042kick, nil);
|
||||||
|
}
|
||||||
|
kdown[i] = nkdown[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
mousethread(void *)
|
||||||
|
{
|
||||||
|
Mouse m;
|
||||||
|
static Mouse mm, om;
|
||||||
|
int gotm;
|
||||||
|
Point mid;
|
||||||
|
Rectangle grabout;
|
||||||
|
int clicked;
|
||||||
|
static Cursor blank;
|
||||||
|
|
||||||
|
gotm = 0;
|
||||||
|
clicked = 0;
|
||||||
|
for(;;){
|
||||||
|
Alt a[] = {
|
||||||
|
{mc->c, &m, CHANRCV},
|
||||||
|
{mousech, &mm, gotm ? CHANSND : CHANNOP},
|
||||||
|
{nil, nil, CHANEND},
|
||||||
|
};
|
||||||
|
|
||||||
|
switch(alt(a)){
|
||||||
|
case 0:
|
||||||
|
mid = divpt(addpt(picr.max, picr.min), 2);
|
||||||
|
grabout = insetrect(Rpt(mid, mid), -50);
|
||||||
|
if(!ptinrect(m.xy, picr)){
|
||||||
|
clicked = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if(!mousegrab){
|
||||||
|
if(clicked && (m.buttons & 1) == 0 && !textmode){
|
||||||
|
mousegrab = 1;
|
||||||
|
setcursor(mc, &blank);
|
||||||
|
}
|
||||||
|
clicked = m.buttons & 1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
gotm = 1;
|
||||||
|
if(!ptinrect(m.xy, grabout)){
|
||||||
|
moveto(mc, mid);
|
||||||
|
m.xy = mid;
|
||||||
|
om.xy = mid;
|
||||||
|
}
|
||||||
|
mm.xy = addpt(mm.xy, subpt(m.xy, om.xy));
|
||||||
|
om = m;
|
||||||
|
mm.buttons = m.buttons;
|
||||||
|
break;
|
||||||
|
case 1:
|
||||||
|
sendnotif(i8042kick, nil);
|
||||||
|
mm.xy = Pt(0,0);
|
||||||
|
gotm = 0;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static Rune cp437[256] = {
|
||||||
|
0x0020, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c,
|
||||||
|
0x25ba, 0x25c4, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8, 0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc,
|
||||||
|
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
|
||||||
|
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
|
||||||
|
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
|
||||||
|
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
|
||||||
|
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
|
||||||
|
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302,
|
||||||
|
0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5,
|
||||||
|
0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192,
|
||||||
|
0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
|
||||||
|
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
|
||||||
|
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
|
||||||
|
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
|
||||||
|
0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, 0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229,
|
||||||
|
0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0,
|
||||||
|
};
|
||||||
|
|
||||||
|
static void
|
||||||
|
drawtext(void)
|
||||||
|
{
|
||||||
|
Rune buf[80];
|
||||||
|
uchar *p;
|
||||||
|
int y, x;
|
||||||
|
Point pt;
|
||||||
|
|
||||||
|
draw(img, img->r, display->black, nil, ZP);
|
||||||
|
for(y = 0; y < 25; y++){
|
||||||
|
p = &fb[y * 160];
|
||||||
|
for(x = 0; x < 80; x++)
|
||||||
|
buf[x] = cp437[p[2*x]];
|
||||||
|
runestringn(img, Pt(0, 16 * y), display->white, ZP, display->defaultfont, buf, 80);
|
||||||
|
}
|
||||||
|
if(cursorpos < 80*25){
|
||||||
|
buf[0] = cp437[fb[cursorpos*2]];
|
||||||
|
pt = Pt(cursorpos % 80 * 8, cursorpos / 80 * 16);
|
||||||
|
draw(img, Rect(pt.x, pt.y, pt.x + 8, pt.y + 16), display->white, nil, ZP);
|
||||||
|
runestringn(img, pt, display->black, ZP, display->defaultfont, buf, 1);
|
||||||
|
}
|
||||||
|
draw(screen, picr, img, nil, ZP);
|
||||||
|
flushimage(display, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
drawfb(void)
|
||||||
|
{
|
||||||
|
u32int *p, *q;
|
||||||
|
Rectangle upd;
|
||||||
|
int xb, y;
|
||||||
|
|
||||||
|
p = (u32int *) fb;
|
||||||
|
q = (u32int *) sfb;
|
||||||
|
upd.min.y = upd.max.y = -1;
|
||||||
|
xb = 0;
|
||||||
|
y = 0;
|
||||||
|
while(p < (u32int*)(fb + fbsz)){
|
||||||
|
if(*p != *q){
|
||||||
|
if(upd.min.y < 0) upd.min.y = y;
|
||||||
|
upd.max.y = y + 1 + (xb + 4 > hbytes);
|
||||||
|
*q = *p;
|
||||||
|
}
|
||||||
|
p++;
|
||||||
|
q++;
|
||||||
|
xb += 4;
|
||||||
|
if(xb >= hbytes){
|
||||||
|
xb -= hbytes;
|
||||||
|
y++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(upd.min.y == upd.max.y) return;
|
||||||
|
upd.min.x = 0;
|
||||||
|
upd.max.x = picw;
|
||||||
|
if(screenchan != screen->chan){
|
||||||
|
loadimage(img, upd, sfb + upd.min.y * hbytes, (upd.max.y - upd.min.y) * hbytes);
|
||||||
|
draw(screen, rectaddpt(upd, picr.min), img, nil, upd.min);
|
||||||
|
}else
|
||||||
|
loadimage(screen, rectaddpt(upd, picr.min), sfb + upd.min.y * hbytes, (upd.max.y - upd.min.y) * hbytes);
|
||||||
|
flushimage(display, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
drawproc(void *)
|
||||||
|
{
|
||||||
|
ulong ul;
|
||||||
|
|
||||||
|
threadsetname("draw");
|
||||||
|
sfb = emalloc(fbsz);
|
||||||
|
for(;; sleep(20)){
|
||||||
|
while(nbrecv(mc->resizec, &ul) > 0){
|
||||||
|
if(getwindow(display, Refnone) < 0)
|
||||||
|
sysfatal("resize failed: %r");
|
||||||
|
screeninit();
|
||||||
|
}
|
||||||
|
if(textmode)
|
||||||
|
drawtext();
|
||||||
|
else
|
||||||
|
drawfb();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vgafbparse(char *fbstring)
|
||||||
|
{
|
||||||
|
char buf[512];
|
||||||
|
char *p, *q;
|
||||||
|
uvlong addr;
|
||||||
|
|
||||||
|
if(picw != 0) sysfatal("vga specified twice");
|
||||||
|
if(strcmp(fbstring, "text") == 0){
|
||||||
|
picw = 640;
|
||||||
|
pich = 400;
|
||||||
|
fbsz = 80*25*2;
|
||||||
|
fbaddr = 0xb8000;
|
||||||
|
textmode++;
|
||||||
|
screenchan = 0;
|
||||||
|
}else{
|
||||||
|
strecpy(buf, buf + nelem(buf), fbstring);
|
||||||
|
picw = strtol(buf, &p, 10);
|
||||||
|
if(*p != 'x')
|
||||||
|
nope:
|
||||||
|
sysfatal("vgafbparse: invalid framebuffer specifier: %#q (should be WxHxCHAN@ADDR or 'text')", fbstring);
|
||||||
|
pich = strtol(p+1, &p, 10);
|
||||||
|
if(*p != 'x') goto nope;
|
||||||
|
q = strchr(p+1, '@');
|
||||||
|
if(q == nil) goto nope;
|
||||||
|
*q = 0;
|
||||||
|
screenchan = strtochan(p+1);
|
||||||
|
if(screenchan == 0) goto nope;
|
||||||
|
p = q + 1;
|
||||||
|
if(*p == 0) goto nope;
|
||||||
|
addr = strtoull(p, &p, 0);
|
||||||
|
fbaddr = addr;
|
||||||
|
if(fbaddr != addr) goto nope;
|
||||||
|
if(*p != 0) goto nope;
|
||||||
|
hbytes = chantodepth(screenchan) * picw + 7 >> 3;
|
||||||
|
fbsz = hbytes * pich;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vgainit(void)
|
||||||
|
{
|
||||||
|
char buf[512];
|
||||||
|
|
||||||
|
if(picw == 0) return;
|
||||||
|
fb = gptr(fbaddr, fbsz);
|
||||||
|
if(fb == nil)
|
||||||
|
sysfatal("got nil ptr for framebuffer");
|
||||||
|
snprint(buf, sizeof(buf), "-dx %d -dy %d", picw+50, pich+50);
|
||||||
|
newwindow(buf);
|
||||||
|
initdraw(nil, nil, "vmx");
|
||||||
|
screeninit();
|
||||||
|
flushimage(display, 1);
|
||||||
|
kbdlayout("/sys/lib/kbmap/us");
|
||||||
|
mc = initmouse(nil, screen);
|
||||||
|
kbdch = chancreate(sizeof(ulong), 128);
|
||||||
|
mousech = chancreate(sizeof(Mouse), 32);
|
||||||
|
proccreate(mousethread, nil, 4096);
|
||||||
|
proccreate(keyproc, nil, 4096);
|
||||||
|
proccreate(drawproc, nil, 4096);
|
||||||
|
}
|
||||||
655
sys/src/cmd/vmx/virtio.c
Normal file
655
sys/src/cmd/vmx/virtio.c
Normal file
|
|
@ -0,0 +1,655 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include <thread.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
typedef struct VIODev VIODev;
|
||||||
|
typedef struct VIOQueue VIOQueue;
|
||||||
|
typedef struct VIOBuf VIOBuf;
|
||||||
|
typedef struct VIONetDev VIONetDev;
|
||||||
|
typedef struct VIOBlkDev VIOBlkDev;
|
||||||
|
|
||||||
|
#define GET8(p,n) (*((u8int*)(p)+(n)))
|
||||||
|
#define GET16(p,n) (*(u16int*)((u8int*)(p)+(n)))
|
||||||
|
#define GET32(p,n) (*(u32int*)((u8int*)(p)+(n)))
|
||||||
|
#define GET64(p,n) (*(u64int*)((u8int*)(p)+(n)))
|
||||||
|
#define PUT8(p,n,v) (*((u8int*)(p)+(n)) = (v))
|
||||||
|
#define PUT16(p,n,v) (*(u16int*)((u8int*)(p)+(n)) = (v))
|
||||||
|
#define PUT32(p,n,v) (*(u32int*)((u8int*)(p)+(n)) = (v))
|
||||||
|
#define PUT64(p,n,v) (*(u64int*)((u8int*)(p)+(n)) = (v))
|
||||||
|
|
||||||
|
enum {
|
||||||
|
BUFCHAIN = 1,
|
||||||
|
BUFWR = 2,
|
||||||
|
|
||||||
|
USEDNOIRQ = 1,
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VIOBuf {
|
||||||
|
u32int flags;
|
||||||
|
VIOQueue *qu;
|
||||||
|
void *p;
|
||||||
|
u64int addr;
|
||||||
|
u32int len;
|
||||||
|
u32int idx;
|
||||||
|
VIOBuf *next, *head;
|
||||||
|
u32int rptr, wptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VIOQueue {
|
||||||
|
QLock;
|
||||||
|
Rendez;
|
||||||
|
VIODev *d;
|
||||||
|
u8int (*desc)[16], *avail, *used;
|
||||||
|
u16int size;
|
||||||
|
u32int addr;
|
||||||
|
u16int availidx, usedidx;
|
||||||
|
void (*notify)(VIOQueue*);
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VIONetDev {
|
||||||
|
int readfd, writefd;
|
||||||
|
u8int mac[6];
|
||||||
|
enum {
|
||||||
|
VNETPROMISC = 1,
|
||||||
|
VNETALLMULTI = 2,
|
||||||
|
VNETALLUNI = 4,
|
||||||
|
VNETNOMULTI = 8,
|
||||||
|
VNETNOUNI = 16,
|
||||||
|
VNETNOBCAST = 32,
|
||||||
|
} flags;
|
||||||
|
u64int macbloom, multibloom;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VIOBlkDev {
|
||||||
|
int fd;
|
||||||
|
uvlong size;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VIODev {
|
||||||
|
PCIDev *pci;
|
||||||
|
u32int devfeat, guestfeat;
|
||||||
|
u16int qsel;
|
||||||
|
u8int devstat, isrstat;
|
||||||
|
VIOQueue *qu;
|
||||||
|
int nqu;
|
||||||
|
u32int (*io)(int, u16int, u32int, int, VIODev *);
|
||||||
|
union {
|
||||||
|
VIONetDev net;
|
||||||
|
VIOBlkDev blk;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
static void
|
||||||
|
vioirq_(void *arg)
|
||||||
|
{
|
||||||
|
VIODev *d;
|
||||||
|
int val;
|
||||||
|
|
||||||
|
d = ((void**)arg)[0];
|
||||||
|
val = (int) ((void**)arg)[1];
|
||||||
|
if(val != 0)
|
||||||
|
d->isrstat |= val;
|
||||||
|
else
|
||||||
|
d->isrstat = 0;
|
||||||
|
pciirq(d->pci, d->isrstat);
|
||||||
|
free(arg);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
vioirq(VIODev *d, int val)
|
||||||
|
{
|
||||||
|
void **v;
|
||||||
|
|
||||||
|
assert(d != nil);
|
||||||
|
v = emalloc(sizeof(void*)*2);
|
||||||
|
v[0] = d;
|
||||||
|
v[1] = (void *) val;
|
||||||
|
sendnotif(vioirq_, v);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void *
|
||||||
|
checkdesc(VIOQueue *q, int i)
|
||||||
|
{
|
||||||
|
if(i >= q->size){
|
||||||
|
vmerror("virtio device %#x: invalid next pointer %d in queue (size %d), ignoring descriptor", q->d->pci->bdf, i, q->size);
|
||||||
|
return nil;
|
||||||
|
}
|
||||||
|
return q->desc[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
VIOBuf *
|
||||||
|
viogetbuf(VIOQueue *q, int wait)
|
||||||
|
{
|
||||||
|
u16int gidx;
|
||||||
|
VIOBuf *b, *rb, **bp;
|
||||||
|
void *dp;
|
||||||
|
|
||||||
|
qlock(q);
|
||||||
|
waitloop:
|
||||||
|
while(q->desc == nil || (gidx = GET16(q->avail, 2), gidx == q->availidx)){
|
||||||
|
if(!wait){
|
||||||
|
qunlock(q);
|
||||||
|
return nil;
|
||||||
|
}
|
||||||
|
rsleep(q);
|
||||||
|
}
|
||||||
|
dp = checkdesc(q, GET16(q->avail, 4 + 2 * (q->availidx % q->size)));
|
||||||
|
rb = nil;
|
||||||
|
bp = &rb;
|
||||||
|
for(;;){
|
||||||
|
b = emalloc(sizeof(VIOBuf));
|
||||||
|
b->qu = q;
|
||||||
|
b->idx = (u8int(*)[16])dp - q->desc;
|
||||||
|
b->addr = GET64(dp, 0);
|
||||||
|
b->len = GET32(dp, 8);
|
||||||
|
b->flags = GET16(dp, 12);
|
||||||
|
b->p = gptr(b->addr, b->len);
|
||||||
|
if(b->p == nil){
|
||||||
|
vmerror("virtio device %#x: invalid buffer pointer %p in queue, ignoring descriptor", q->d->pci->bdf, (void*)b->addr);
|
||||||
|
free(b);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
*bp = b;
|
||||||
|
b->head = rb;
|
||||||
|
bp = &b->next;
|
||||||
|
if((b->flags & BUFCHAIN) == 0) break;
|
||||||
|
dp = checkdesc(q, GET16(dp, 14));
|
||||||
|
if(dp == nil) break;
|
||||||
|
}
|
||||||
|
q->availidx++;
|
||||||
|
if(rb == nil) goto waitloop;
|
||||||
|
qunlock(q);
|
||||||
|
return rb;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vioputbuf(VIOBuf *b)
|
||||||
|
{
|
||||||
|
VIOBuf *bn;
|
||||||
|
VIOQueue *q;
|
||||||
|
u8int *p;
|
||||||
|
|
||||||
|
if(b == nil) return;
|
||||||
|
q = b->qu;
|
||||||
|
qlock(q);
|
||||||
|
if(q->used == nil)
|
||||||
|
vmerror("virtio device %#x: address was set to an invalid value while holding buffer", q->d->pci->bdf);
|
||||||
|
else{
|
||||||
|
p = q->used + 4 + 8 * (q->usedidx % q->size);
|
||||||
|
PUT32(p, 4, b->wptr);
|
||||||
|
PUT32(p, 0, b->idx);
|
||||||
|
PUT16(q->used, 2, ++q->usedidx);
|
||||||
|
}
|
||||||
|
qunlock(q);
|
||||||
|
if(q->avail != nil && (GET16(q->avail, 0) & USEDNOIRQ) == 0)
|
||||||
|
vioirq(q->d, 1);
|
||||||
|
while(b != nil){
|
||||||
|
bn = b->next;
|
||||||
|
free(b);
|
||||||
|
b = bn;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ulong
|
||||||
|
vioqread(VIOBuf *b, void *v, ulong n)
|
||||||
|
{
|
||||||
|
VIOBuf *c;
|
||||||
|
u32int p;
|
||||||
|
int rc;
|
||||||
|
ulong m;
|
||||||
|
|
||||||
|
p = b->rptr;
|
||||||
|
c = b;
|
||||||
|
rc = 0;
|
||||||
|
for(;;){
|
||||||
|
if(rc >= n) return rc;
|
||||||
|
for(;;){
|
||||||
|
if(c == nil) return rc;
|
||||||
|
if((c->flags & BUFWR) == 0){
|
||||||
|
if(p < c->len) break;
|
||||||
|
p -= c->len;
|
||||||
|
}
|
||||||
|
c = c->next;
|
||||||
|
}
|
||||||
|
m = c->len - p;
|
||||||
|
if(m > n - rc) m = n - rc;
|
||||||
|
memmove(v, (u8int*)c->p + p, m);
|
||||||
|
p += m, rc += m;
|
||||||
|
v = (u8int*)v + p;
|
||||||
|
b->rptr += m;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ulong
|
||||||
|
vioqwrite(VIOBuf *b, void *v, ulong n)
|
||||||
|
{
|
||||||
|
VIOBuf *c;
|
||||||
|
u32int p;
|
||||||
|
int rc;
|
||||||
|
ulong m;
|
||||||
|
|
||||||
|
p = b->wptr;
|
||||||
|
c = b;
|
||||||
|
rc = 0;
|
||||||
|
for(;;){
|
||||||
|
if(rc >= n) return rc;
|
||||||
|
for(;;){
|
||||||
|
if(c == nil) return rc;
|
||||||
|
if((c->flags & BUFWR) != 0){
|
||||||
|
if(p < c->len) break;
|
||||||
|
p -= c->len;
|
||||||
|
}
|
||||||
|
c = c->next;
|
||||||
|
}
|
||||||
|
m = c->len - p;
|
||||||
|
if(m > n - rc) m = n - rc;
|
||||||
|
memmove((u8int*)c->p + p, v, m);
|
||||||
|
p += m, rc += m;
|
||||||
|
v = (u8int*)v + p;
|
||||||
|
b->wptr += m;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
vioqaddrset(VIOQueue *q, u64int addr)
|
||||||
|
{
|
||||||
|
void *p;
|
||||||
|
int sz1, sz;
|
||||||
|
|
||||||
|
addr <<= 12;
|
||||||
|
sz1 = -(-(18 * q->size + 4) & -4096);
|
||||||
|
sz = sz1 + (-(-(8 * q->size + 6) & -4096));
|
||||||
|
p = gptr(addr, sz);
|
||||||
|
if(p == nil)
|
||||||
|
vmerror("virtio device %#x: attempt to set queue to invalid address %p", q->d->pci->bdf, (void *) addr);
|
||||||
|
qlock(q);
|
||||||
|
q->addr = addr;
|
||||||
|
if(p == nil){
|
||||||
|
q->desc = nil;
|
||||||
|
q->avail = nil;
|
||||||
|
q->used = nil;
|
||||||
|
}else{
|
||||||
|
q->desc = p;
|
||||||
|
q->avail = (u8int*)p + 16 * q->size;
|
||||||
|
q->used = (u8int*)p + sz1;
|
||||||
|
rwakeupall(q);
|
||||||
|
}
|
||||||
|
qunlock(q);
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
vioio(int isin, u16int port, u32int val, int sz, void *vp)
|
||||||
|
{
|
||||||
|
VIODev *v;
|
||||||
|
int rc;
|
||||||
|
static char whinebuf[32];
|
||||||
|
|
||||||
|
v = vp;
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x4: v->guestfeat = val; return 0;
|
||||||
|
case 0x8: if(v->qsel < v->nqu) vioqaddrset(&v->qu[v->qsel], val); return 0;
|
||||||
|
case 0xe: v->qsel = val; return 0;
|
||||||
|
case 0x10: if(val < v->nqu) v->qu[val].notify(&v->qu[val]); return 0;
|
||||||
|
case 0x12: v->devstat = val; return 0;
|
||||||
|
case 0x10000: return v->devfeat;
|
||||||
|
case 0x10004: return v->guestfeat;
|
||||||
|
case 0x10008: return v->qsel >= v->nqu ? 0 : v->qu[v->qsel].addr;
|
||||||
|
case 0x1000c: return v->qsel >= v->nqu ? 0 : v->qu[v->qsel].size;
|
||||||
|
case 0x1000e: return v->qsel;
|
||||||
|
case 0x10010: return 0;
|
||||||
|
case 0x10012: return v->devstat;
|
||||||
|
case 0x10013: rc = v->isrstat; vioirq(v, 0); return rc;
|
||||||
|
}
|
||||||
|
if(port >= 20 && v->io != nil)
|
||||||
|
return v->io(isin, port - 20, val, sz, v);
|
||||||
|
snprint(whinebuf, sizeof(whinebuf), "virtio device %6x", v->pci->bdf);
|
||||||
|
return iowhine(isin, port, val, sz, whinebuf);
|
||||||
|
}
|
||||||
|
|
||||||
|
VIODev *
|
||||||
|
mkviodev(u16int devid, u32int pciclass, u32int subid)
|
||||||
|
{
|
||||||
|
VIODev *d;
|
||||||
|
|
||||||
|
d = emalloc(sizeof(VIODev));
|
||||||
|
d->pci = mkpcidev(allocbdf(), devid << 16 | 0x1AF4, pciclass << 8, 1);
|
||||||
|
d->pci->subid = subid << 16;
|
||||||
|
mkpcibar(d->pci, 1, 256, vioio, d);
|
||||||
|
return d;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
viowakeup(VIOQueue *q)
|
||||||
|
{
|
||||||
|
qlock(q);
|
||||||
|
rwakeupall(q);
|
||||||
|
qunlock(q);
|
||||||
|
}
|
||||||
|
|
||||||
|
VIOQueue *
|
||||||
|
mkvioqueue(VIODev *d, int sz, void (*fn)(VIOQueue*))
|
||||||
|
{
|
||||||
|
VIOQueue *q;
|
||||||
|
|
||||||
|
assert(sz > 0 && sz <= 32768 && (sz & sz - 1) == 0 && fn != nil);
|
||||||
|
d->qu = realloc(d->qu, (d->nqu + 1) * sizeof(VIOQueue));
|
||||||
|
if(d->qu == nil)
|
||||||
|
sysfatal("realloc: %r");
|
||||||
|
q = d->qu + d->nqu++;
|
||||||
|
memset(q, 0, sizeof(VIOQueue));
|
||||||
|
q->Rendez.l = q;
|
||||||
|
q->size = sz;
|
||||||
|
q->d = d;
|
||||||
|
q->notify = fn;
|
||||||
|
return q;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
bloomhash(u8int *mac)
|
||||||
|
{
|
||||||
|
int x;
|
||||||
|
|
||||||
|
x = mac[0];
|
||||||
|
x ^= mac[0] >> 6 ^ mac[1] << 2;
|
||||||
|
x ^= mac[1] >> 4 ^ mac[2] << 4;
|
||||||
|
x ^= mac[2] >> 2;
|
||||||
|
x ^= mac[3];
|
||||||
|
x ^= mac[3] >> 6 ^ mac[4] << 2;
|
||||||
|
x ^= mac[4] >> 4 ^ mac[5] << 4;
|
||||||
|
x ^= mac[5] >> 2;
|
||||||
|
return x & 63;
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
viomacok(VIODev *d, u8int *mac)
|
||||||
|
{
|
||||||
|
static u8int bcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
||||||
|
|
||||||
|
if((d->net.flags & VNETPROMISC) != 0) return 1;
|
||||||
|
if((mac[0] & 1) == 0){
|
||||||
|
if((d->net.flags & (VNETNOUNI|VNETALLUNI)) != 0)
|
||||||
|
return (d->net.flags & VNETNOUNI) == 0;
|
||||||
|
if(memcmp(mac, d->net.mac, 6) == 0) return 1;
|
||||||
|
if(d->net.macbloom == 0) return 0;
|
||||||
|
return d->net.macbloom & 1ULL<<bloomhash(mac);
|
||||||
|
}else if(memcmp(mac, bcast, 6) == 0)
|
||||||
|
return (d->net.flags & VNETNOBCAST) == 0;
|
||||||
|
else{
|
||||||
|
if((d->net.flags & (VNETNOMULTI|VNETALLMULTI)) != 0)
|
||||||
|
return (d->net.flags & VNETNOMULTI) == 0;
|
||||||
|
if(d->net.multibloom == 0) return 0;
|
||||||
|
return d->net.multibloom & 1ULL<<bloomhash(mac);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vionetrproc(void *vp)
|
||||||
|
{
|
||||||
|
VIODev *v;
|
||||||
|
VIOQueue *q;
|
||||||
|
VIOBuf *vb;
|
||||||
|
uchar rxhead[10];
|
||||||
|
uchar rxbuf[1600];
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
threadsetname("vionetrproc");
|
||||||
|
v = vp;
|
||||||
|
q = &v->qu[0];
|
||||||
|
for(;;){
|
||||||
|
rc = read(v->net.readfd, rxbuf, sizeof(rxbuf));
|
||||||
|
if(rc == 0){
|
||||||
|
vmerror("read(vionetrproc): eof");
|
||||||
|
threadexits("read: eof");
|
||||||
|
}
|
||||||
|
if(rc < 0){
|
||||||
|
vmerror("read(vionetrproc): %r");
|
||||||
|
threadexits("read: %r");
|
||||||
|
}
|
||||||
|
if(rc < 14){
|
||||||
|
vmerror("vionetrproc: short packet received (len=%d)", rc);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if(!viomacok(v, rxbuf))
|
||||||
|
continue;
|
||||||
|
vb = viogetbuf(q, 1);
|
||||||
|
if(vb == nil){
|
||||||
|
vmerror("viogetbuf: %r");
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
vioqwrite(vb, rxhead, sizeof(rxhead));
|
||||||
|
vioqwrite(vb, rxbuf, rc);
|
||||||
|
vioputbuf(vb);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vionetwproc(void *vp)
|
||||||
|
{
|
||||||
|
VIODev *v;
|
||||||
|
VIOQueue *q;
|
||||||
|
VIOBuf *vb;
|
||||||
|
uchar txhead[10];
|
||||||
|
uchar txbuf[1600];
|
||||||
|
int rc, len;
|
||||||
|
|
||||||
|
threadsetname("vionetwproc");
|
||||||
|
v = vp;
|
||||||
|
q = &v->qu[1];
|
||||||
|
for(;;){
|
||||||
|
vb = viogetbuf(q, 1);
|
||||||
|
if(vb == nil){
|
||||||
|
vmerror("viogetbuf: %r");
|
||||||
|
threadexits("viogetbuf: %r");
|
||||||
|
}
|
||||||
|
vioqread(vb, txhead, sizeof(txhead));
|
||||||
|
len = vioqread(vb, txbuf, sizeof(txbuf));
|
||||||
|
if(len == sizeof(txbuf)){
|
||||||
|
vmerror("virtio net: ignoring excessively long packet");
|
||||||
|
vioputbuf(vb);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if(len < 14){
|
||||||
|
vmerror("virtio net: ignoring short packet (length=%d)", len);
|
||||||
|
vioputbuf(vb);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
rc = write(v->net.writefd, txbuf, len);
|
||||||
|
vioputbuf(vb);
|
||||||
|
if(rc < len){
|
||||||
|
vmerror("write(vionetwproc): incomplete write");
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if(rc < 0){
|
||||||
|
vmerror("write(vionetwproc): %r");
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
vionetio(int isin, u16int port, u32int val, int sz, VIODev *v)
|
||||||
|
{
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x10000: case 0x10001: case 0x10002: case 0x10003:
|
||||||
|
return GET32(v->net.mac, 0) >> (port & 3) * 8;
|
||||||
|
case 0x10004: case 0x10005: case 0x10006: case 0x10007:
|
||||||
|
return (GET16(v->net.mac, 4) | 1 << 16) >> (port & 3) * 8;
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "virtio net");
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
vionettables(VIODev *d, VIOBuf *b)
|
||||||
|
{
|
||||||
|
u8int buf[4];
|
||||||
|
u8int mac[6];
|
||||||
|
u64int bloom[2];
|
||||||
|
int i, l;
|
||||||
|
|
||||||
|
bloom[0] = 0;
|
||||||
|
bloom[1] = 0;
|
||||||
|
for(i = 0; i < 2; i++){
|
||||||
|
if(vioqread(b, buf, 4) < 4)
|
||||||
|
return 1;
|
||||||
|
l = GET32(buf, 0);
|
||||||
|
while(l--){
|
||||||
|
if(vioqread(b, mac, 6) < 6)
|
||||||
|
return 1;
|
||||||
|
bloom[i] |= 1ULL<<bloomhash(mac);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
d->net.macbloom = bloom[0];
|
||||||
|
d->net.multibloom = bloom[1];
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vionetcmd(VIOQueue *q)
|
||||||
|
{
|
||||||
|
VIODev *d;
|
||||||
|
VIOBuf *b;
|
||||||
|
u8int cmd[2], buf[6];
|
||||||
|
u8int ack;
|
||||||
|
int fl;
|
||||||
|
|
||||||
|
d = q->d;
|
||||||
|
for(; b = viogetbuf(q, 0), b != nil; vioputbuf(b)){
|
||||||
|
if(vioqread(b, cmd, 2) < 2){
|
||||||
|
ack = 1;
|
||||||
|
vioqwrite(b, &ack, 1);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
ack = 0;
|
||||||
|
switch(cmd[0] << 8 | cmd[1]){
|
||||||
|
case 0x0000: fl = VNETPROMISC; goto flag;
|
||||||
|
case 0x0001: fl = VNETALLMULTI; goto flag;
|
||||||
|
case 0x0002: fl = VNETALLUNI; goto flag;
|
||||||
|
case 0x0003: fl = VNETNOMULTI; goto flag;
|
||||||
|
case 0x0004: fl = VNETNOUNI; goto flag;
|
||||||
|
case 0x0005: fl = VNETNOBCAST; goto flag;
|
||||||
|
flag:
|
||||||
|
if(vioqread(b, buf, 1) < 1) ack = 1;
|
||||||
|
else if(buf[0] == 1) d->net.flags |= fl;
|
||||||
|
else if(buf[0] == 0) d->net.flags &= ~fl;
|
||||||
|
else ack = 1;
|
||||||
|
break;
|
||||||
|
case 0x0100: /* MAC_TABLE_SET */
|
||||||
|
ack = vionettables(d, b);
|
||||||
|
break;
|
||||||
|
case 0x0101: /* MAC_ADDR_SET */
|
||||||
|
if(vioqread(b, buf, 6) < 6) ack = 1;
|
||||||
|
else memmove(d->net.mac, buf, 6);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ack = 1;
|
||||||
|
}
|
||||||
|
vioqwrite(b, &ack, 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
mkvionet(char *net)
|
||||||
|
{
|
||||||
|
int fd, cfd;
|
||||||
|
VIODev *d;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
fd = dial(netmkaddr("-1", net, nil), nil, nil, &cfd);
|
||||||
|
if(fd < 0) return -1;
|
||||||
|
if(cfd >= 0) fprint(cfd, "promiscuous");
|
||||||
|
d = mkviodev(0x1000, 0x020000, 1);
|
||||||
|
mkvioqueue(d, 1024, viowakeup);
|
||||||
|
mkvioqueue(d, 1024, viowakeup);
|
||||||
|
mkvioqueue(d, 32, vionetcmd);
|
||||||
|
for(i = 0; i < 6; i++)
|
||||||
|
d->net.mac[i] = rand();
|
||||||
|
d->net.mac[0] = d->net.mac[0] & ~1 | 2;
|
||||||
|
d->devfeat = 1<<5|1<<16|1<<17|1<<18|1<<20;
|
||||||
|
d->io = vionetio;
|
||||||
|
d->net.readfd = d->net.writefd = fd;
|
||||||
|
proccreate(vionetrproc, d, 8192);
|
||||||
|
proccreate(vionetwproc, d, 8192);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
u32int
|
||||||
|
vioblkio(int isin, u16int port, u32int val, int sz, VIODev *v)
|
||||||
|
{
|
||||||
|
switch(isin << 16 | port){
|
||||||
|
case 0x10000: case 0x10001: case 0x10002: case 0x10003:
|
||||||
|
return (u32int)v->blk.size >> (port & 3) * 8;
|
||||||
|
case 0x10004: case 0x10005: case 0x10006: case 0x10007:
|
||||||
|
return (u32int)(v->blk.size >> 32) >> (port & 3) * 8;
|
||||||
|
}
|
||||||
|
return iowhine(isin, port, val, sz, "virtio blk");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vioblkproc(void *vp)
|
||||||
|
{
|
||||||
|
VIODev *v;
|
||||||
|
VIOQueue *q;
|
||||||
|
VIOBuf *b;
|
||||||
|
u8int cmd[16];
|
||||||
|
u8int ack;
|
||||||
|
char buf[512];
|
||||||
|
uvlong addr;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
threadsetname("vioblkproc");
|
||||||
|
v = vp;
|
||||||
|
q = &v->qu[0];
|
||||||
|
for(;;){
|
||||||
|
b = viogetbuf(q, 1);
|
||||||
|
if(b == nil){
|
||||||
|
vmerror("vioblkproc: viogetbuf: %r");
|
||||||
|
threadexits("vioblkproc: viogetbuf: %r");
|
||||||
|
}
|
||||||
|
ack = 0;
|
||||||
|
if(vioqread(b, cmd, sizeof(cmd)) < sizeof(cmd)) goto nope;
|
||||||
|
addr = GET64(cmd, 8);
|
||||||
|
switch(GET32(cmd, 0)){
|
||||||
|
case 0:
|
||||||
|
if(addr >> 55 != 0) rc = 0;
|
||||||
|
else rc = pread(v->blk.fd, buf, 512, addr << 9);
|
||||||
|
if(rc < 0) vmerror("pread(vioblkproc): %r");
|
||||||
|
if(rc < 512){
|
||||||
|
memset(buf, 0, 512);
|
||||||
|
ack = 1;
|
||||||
|
}
|
||||||
|
vioqwrite(b, buf, 512);
|
||||||
|
break;
|
||||||
|
case 1:
|
||||||
|
if(vioqread(b, buf, 512) < 512) rc = 0;
|
||||||
|
else if(addr >> 55 != 0) rc = 0;
|
||||||
|
else rc = pwrite(v->blk.fd, buf, 512, addr << 9);
|
||||||
|
if(rc < 0) vmerror("pwrite(vioblkproc): %r");
|
||||||
|
if(rc < 512) ack = 1;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
nope:
|
||||||
|
ack = 2;
|
||||||
|
}
|
||||||
|
vioqwrite(b, &ack, 1);
|
||||||
|
vioputbuf(b);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
mkvioblk(char *fn)
|
||||||
|
{
|
||||||
|
int fd;
|
||||||
|
VIODev *d;
|
||||||
|
|
||||||
|
fd = open(fn, ORDWR);
|
||||||
|
if(fd < 0) return -1;
|
||||||
|
d = mkviodev(0x1000, 0x018000, 2);
|
||||||
|
mkvioqueue(d, 32, viowakeup);
|
||||||
|
d->io = vioblkio;
|
||||||
|
d->blk.fd = fd;
|
||||||
|
d->blk.size = seek(fd, 0, 2) >> 9;
|
||||||
|
proccreate(vioblkproc, d, 8192);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
555
sys/src/cmd/vmx/vmx.c
Normal file
555
sys/src/cmd/vmx/vmx.c
Normal file
|
|
@ -0,0 +1,555 @@
|
||||||
|
#include <u.h>
|
||||||
|
#include <libc.h>
|
||||||
|
#include <thread.h>
|
||||||
|
#include <draw.h>
|
||||||
|
#include "dat.h"
|
||||||
|
#include "fns.h"
|
||||||
|
|
||||||
|
Region *mmap;
|
||||||
|
int ctlfd, regsfd, waitfd;
|
||||||
|
Channel *waitch, *sleepch, *notifch;
|
||||||
|
enum { MSEC = 1000*1000, MinSleep = MSEC, SleeperPoll = 2000*MSEC } ;
|
||||||
|
int getexit, halt;
|
||||||
|
typedef struct VmxNotif VmxNotif;
|
||||||
|
struct VmxNotif {
|
||||||
|
void (*f)(void *);
|
||||||
|
void *arg;
|
||||||
|
};
|
||||||
|
|
||||||
|
int mainstacksize = 65536;
|
||||||
|
|
||||||
|
void *
|
||||||
|
emalloc(ulong sz)
|
||||||
|
{
|
||||||
|
void *v;
|
||||||
|
|
||||||
|
v = malloc(sz);
|
||||||
|
if(v == nil)
|
||||||
|
sysfatal("malloc: %r");
|
||||||
|
memset(v, 0, sz);
|
||||||
|
setmalloctag(v, getcallerpc(&sz));
|
||||||
|
return v;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
vmerror(char *fmt, ...)
|
||||||
|
{
|
||||||
|
Fmt f;
|
||||||
|
char buf[256];
|
||||||
|
va_list arg;
|
||||||
|
|
||||||
|
fmtfdinit(&f, 2, buf, sizeof buf);
|
||||||
|
va_start(arg, fmt);
|
||||||
|
fmtvprint(&f, fmt, arg);
|
||||||
|
va_end(arg);
|
||||||
|
fmtprint(&f, "\n");
|
||||||
|
fmtfdflush(&f);
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
ctl(char *fmt, ...)
|
||||||
|
{
|
||||||
|
va_list va;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
va_start(va, fmt);
|
||||||
|
rc = vfprint(ctlfd, fmt, va);
|
||||||
|
va_end(va);
|
||||||
|
return rc;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
vmxsetup(void)
|
||||||
|
{
|
||||||
|
static int fd;
|
||||||
|
static char buf[128];
|
||||||
|
Region *r;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
fd = open("#X/status", OREAD);
|
||||||
|
if(fd < 0) sysfatal("open: %r");
|
||||||
|
rc = read(fd, buf, sizeof(buf)-1);
|
||||||
|
if(rc < 0) sysfatal("read: %r");
|
||||||
|
close(fd);
|
||||||
|
buf[rc] = 0;
|
||||||
|
|
||||||
|
ctlfd = open("#X/ctl", ORDWR);
|
||||||
|
if(ctlfd < 0) sysfatal("open: %r");
|
||||||
|
if(strcmp(buf, "inactive\n") != 0)
|
||||||
|
if(ctl("quit") < 0)
|
||||||
|
sysfatal("ctl: %r");
|
||||||
|
if(ctl("init") < 0)
|
||||||
|
sysfatal("ctl: %r");
|
||||||
|
regsfd = open("#X/regs", ORDWR);
|
||||||
|
if(regsfd < 0) sysfatal("open: %r");
|
||||||
|
|
||||||
|
fd = open("#X/map", OWRITE|OTRUNC);
|
||||||
|
if(fd < 0) sysfatal("open: %r");
|
||||||
|
for(r = mmap; r != nil; r = r->next)
|
||||||
|
if(r->segname != nil && fprint(fd, "rwx wb %#ullx %#ullx %s %#ullx\n", (uvlong)r->start, (uvlong)r->end, r->segname, r->segoff) < 0)
|
||||||
|
sysfatal("writing memory map: %r");
|
||||||
|
close(fd);
|
||||||
|
|
||||||
|
waitfd = open("#X/wait", OREAD);
|
||||||
|
if(waitfd < 0) sysfatal("open: %r");
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { RCENT = 256 };
|
||||||
|
char *rcname[RCENT];
|
||||||
|
uvlong rcval[RCENT];
|
||||||
|
uvlong rcvalid[(RCENT+63)/64], rcdirty[(RCENT+63)/64];
|
||||||
|
|
||||||
|
static int
|
||||||
|
rclookup(char *n)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for(i = 0; i < RCENT; i++)
|
||||||
|
if(rcname[i] != nil && strcmp(n, rcname[i]) == 0)
|
||||||
|
return i;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
char *
|
||||||
|
rcflush(int togo)
|
||||||
|
{
|
||||||
|
int i, j;
|
||||||
|
static char buf[4096];
|
||||||
|
char *p, *e;
|
||||||
|
uvlong v;
|
||||||
|
|
||||||
|
p = buf;
|
||||||
|
e = buf + sizeof(buf);
|
||||||
|
*p = 0;
|
||||||
|
for(i = 0; i < (RCENT+63)/64; i++){
|
||||||
|
if(v = rcdirty[i], v != 0){
|
||||||
|
for(j = 0; j < 64; j++)
|
||||||
|
if((v>>j & 1) != 0)
|
||||||
|
p = seprint(p, e, "%s%c%#ullx%c", rcname[i*64+j], togo?'=':' ', rcval[i*64+j], togo?';':'\n');
|
||||||
|
rcdirty[i] = 0;
|
||||||
|
}
|
||||||
|
rcvalid[i] = 0;
|
||||||
|
}
|
||||||
|
if(!togo && p != buf && write(regsfd, buf, p - buf) < p - buf)
|
||||||
|
sysfatal("rcflush: write: %r");
|
||||||
|
return p != buf ? buf : nil;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
rcload(void)
|
||||||
|
{
|
||||||
|
char buf[4096];
|
||||||
|
char *p, *q, *f[2];
|
||||||
|
int nf;
|
||||||
|
int i, rc;
|
||||||
|
|
||||||
|
rcflush(0);
|
||||||
|
rc = pread(regsfd, buf, sizeof(buf) - 1, 0);
|
||||||
|
if(rc < 0) sysfatal("rcload: pread: %r");
|
||||||
|
buf[rc] = 0;
|
||||||
|
p = buf;
|
||||||
|
for(i = 0; i < nelem(rcname); i++){
|
||||||
|
q = strchr(p, '\n');
|
||||||
|
if(q == nil) break;
|
||||||
|
*q = 0;
|
||||||
|
nf = tokenize(p, f, nelem(f));
|
||||||
|
p = q + 1;
|
||||||
|
if(nf < 2) break;
|
||||||
|
free(rcname[i]);
|
||||||
|
rcname[i] = strdup(f[0]);
|
||||||
|
rcval[i] = strtoull(f[1], nil, 0);
|
||||||
|
rcvalid[i>>6] |= 1ULL<<(i&63);
|
||||||
|
}
|
||||||
|
for(; i < nelem(rcname); i++){
|
||||||
|
free(rcname[i]);
|
||||||
|
rcname[i] = 0;
|
||||||
|
rcvalid[i>>6] &= ~(1ULL<<(i&63));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uvlong
|
||||||
|
rget(char *reg)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
i = rclookup(reg);
|
||||||
|
if(i < 0 || (rcvalid[i>>6]>>i&1) == 0){
|
||||||
|
rcload();
|
||||||
|
i = rclookup(reg);
|
||||||
|
if(i < 0) sysfatal("unknown register %s", reg);
|
||||||
|
}
|
||||||
|
return rcval[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
rpoke(char *reg, uvlong val, int clean)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
i = rclookup(reg);
|
||||||
|
if(i >= 0){
|
||||||
|
if((rcvalid[i>>6]>>(i&63)&1) != 0 && rcval[i] == val) return;
|
||||||
|
goto goti;
|
||||||
|
}
|
||||||
|
for(i = 0; i < nelem(rcname); i++)
|
||||||
|
if(rcname[i] == nil){
|
||||||
|
rcname[i] = strdup(reg);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
assert(i < nelem(rcname));
|
||||||
|
goti:
|
||||||
|
rcval[i] = val;
|
||||||
|
rcvalid[i>>6] |= 1ULL<<(i&63);
|
||||||
|
if(!clean)
|
||||||
|
rcdirty[i>>6] |= 1ULL<<(i&63);
|
||||||
|
}
|
||||||
|
|
||||||
|
Region *
|
||||||
|
mkregion(u64int pa, u64int len, int type)
|
||||||
|
{
|
||||||
|
Region *r, **rp;
|
||||||
|
|
||||||
|
assert(pa + len >= pa);
|
||||||
|
r = emalloc(sizeof(Region));
|
||||||
|
if((pa & BY2PG-1) != 0) sysfatal("address %p not page aligned", (void*)pa);
|
||||||
|
r->start = pa;
|
||||||
|
len = -(-len & -BY2PG);
|
||||||
|
r->end = pa + len;
|
||||||
|
r->type = type;
|
||||||
|
for(rp = &mmap; *rp != nil; rp = &(*rp)->next)
|
||||||
|
;
|
||||||
|
*rp = r;
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
gptr(u64int addr, u64int len)
|
||||||
|
{
|
||||||
|
Region *r;
|
||||||
|
|
||||||
|
if(addr + len < addr)
|
||||||
|
return nil;
|
||||||
|
for(r = mmap; r != nil; r = r->next)
|
||||||
|
if(addr >= r->start && addr < r->end){
|
||||||
|
if(addr + len > r->end)
|
||||||
|
return nil;
|
||||||
|
return (uchar *) r->v + (addr - r->start);
|
||||||
|
}
|
||||||
|
return nil;
|
||||||
|
}
|
||||||
|
|
||||||
|
uintptr
|
||||||
|
gpa(void *v)
|
||||||
|
{
|
||||||
|
Region *r;
|
||||||
|
|
||||||
|
for(r = mmap; r != nil; r = r->next)
|
||||||
|
if(v >= r->v && v < r->ve)
|
||||||
|
return (uchar *) v - (uchar *) r->v;
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
uintptr
|
||||||
|
gavail(void *v)
|
||||||
|
{
|
||||||
|
Region *r;
|
||||||
|
|
||||||
|
for(r = mmap; r != nil; r = r->next)
|
||||||
|
if(v >= r->v && v < r->ve)
|
||||||
|
return (uchar *) r->ve - (uchar *) v;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *
|
||||||
|
gend(void *v)
|
||||||
|
{
|
||||||
|
return (u8int *) v + gavail(v);
|
||||||
|
}
|
||||||
|
|
||||||
|
void *tmp;
|
||||||
|
uvlong tmpoff;
|
||||||
|
|
||||||
|
static void
|
||||||
|
mksegment(char *sn)
|
||||||
|
{
|
||||||
|
uintptr sz;
|
||||||
|
int fd;
|
||||||
|
Region *r;
|
||||||
|
char buf[256];
|
||||||
|
u8int *gmem, *p;
|
||||||
|
|
||||||
|
sz = BY2PG;
|
||||||
|
for(r = mmap; r != nil; r = r->next){
|
||||||
|
switch(r->type){
|
||||||
|
case REGMEM: case REGFB: break;
|
||||||
|
default: continue;
|
||||||
|
}
|
||||||
|
r->segname = sn;
|
||||||
|
if(sz + (r->end - r->start) < sz)
|
||||||
|
sysfatal("out of address space");
|
||||||
|
sz += r->end - r->start;
|
||||||
|
}
|
||||||
|
gmem = segattach(0, sn, nil, sz);
|
||||||
|
if(gmem == (void*)-1){
|
||||||
|
snprint(buf, sizeof(buf), "#g/%s", sn);
|
||||||
|
fd = create(buf, OREAD, DMDIR | 0777);
|
||||||
|
if(fd < 0) sysfatal("create: %r");
|
||||||
|
close(fd);
|
||||||
|
snprint(buf, sizeof(buf), "#g/%s/ctl", sn);
|
||||||
|
fd = open(buf, OWRITE|OTRUNC);
|
||||||
|
if(fd < 0) sysfatal("open: %r");
|
||||||
|
snprint(buf, sizeof(buf), "va %#ullx %#ullx fixed", 0x10000000ULL, (uvlong)sz);
|
||||||
|
if(write(fd, buf, strlen(buf)) < 0) sysfatal("write: %r");
|
||||||
|
close(fd);
|
||||||
|
gmem = segattach(0, sn, nil, sz);
|
||||||
|
if(gmem == (void*)-1) sysfatal("segattach: %r");
|
||||||
|
}
|
||||||
|
memset(gmem, 0, sz);
|
||||||
|
p = gmem;
|
||||||
|
for(r = mmap; r != nil; r = r->next){
|
||||||
|
if(r->segname == nil) continue;
|
||||||
|
r->segoff = p - gmem;
|
||||||
|
r->v = p;
|
||||||
|
p += r->end - r->start;
|
||||||
|
r->ve = p;
|
||||||
|
}
|
||||||
|
tmp = p;
|
||||||
|
tmpoff = p - gmem;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
postexc(char *name, u32int)
|
||||||
|
{
|
||||||
|
if(ctl("exc %s", name) < 0)
|
||||||
|
sysfatal("ctl(postexc): %r");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
launch(void)
|
||||||
|
{
|
||||||
|
char *s;
|
||||||
|
|
||||||
|
s = rcflush(1);
|
||||||
|
if(ctl("go %s", s == nil ? "" : s) < 0)
|
||||||
|
sysfatal("go: %r");
|
||||||
|
getexit++;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
waitproc(void *)
|
||||||
|
{
|
||||||
|
static char buf[512];
|
||||||
|
char *p;
|
||||||
|
int rc;
|
||||||
|
|
||||||
|
threadsetname("waitexit");
|
||||||
|
for(;;){
|
||||||
|
rc = read(waitfd, buf, sizeof(buf) - 1);
|
||||||
|
if(rc < 0)
|
||||||
|
sysfatal("read: %r");
|
||||||
|
buf[rc] = 0;
|
||||||
|
p = strchr(buf, '\n');
|
||||||
|
if(p != nil) *p = 0;
|
||||||
|
sendp(waitch, strdup(buf));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
vlong timerevent = -1;
|
||||||
|
Lock timerlock;
|
||||||
|
int timerid;
|
||||||
|
|
||||||
|
static void
|
||||||
|
sleeperproc(void *)
|
||||||
|
{
|
||||||
|
vlong then, now;
|
||||||
|
|
||||||
|
timerid = threadid();
|
||||||
|
timerevent = nsec() + SleeperPoll;
|
||||||
|
unlock(&timerlock);
|
||||||
|
threadsetname("sleeper");
|
||||||
|
for(;;){
|
||||||
|
lock(&timerlock);
|
||||||
|
then = timerevent;
|
||||||
|
now = nsec();
|
||||||
|
if(then <= now) timerevent = now + SleeperPoll;
|
||||||
|
unlock(&timerlock);
|
||||||
|
if(then - now >= MinSleep){
|
||||||
|
sleep((then - now) / MSEC);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
while(nsec() < then)
|
||||||
|
;
|
||||||
|
sendul(sleepch, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
runloop(void)
|
||||||
|
{
|
||||||
|
char *waitmsg;
|
||||||
|
ulong ul;
|
||||||
|
VmxNotif notif;
|
||||||
|
|
||||||
|
lock(&timerlock);
|
||||||
|
proccreate(waitproc, nil, 4096);
|
||||||
|
proccreate(sleeperproc, nil, 4096);
|
||||||
|
launch();
|
||||||
|
for(;;){
|
||||||
|
enum {
|
||||||
|
WAIT,
|
||||||
|
SLEEP,
|
||||||
|
NOTIF,
|
||||||
|
};
|
||||||
|
Alt a[] = {
|
||||||
|
[WAIT] {waitch, &waitmsg, CHANRCV},
|
||||||
|
[SLEEP] {sleepch, &ul, CHANRCV},
|
||||||
|
[NOTIF] {notifch, ¬if, CHANRCV},
|
||||||
|
{nil, nil, CHANEND}
|
||||||
|
};
|
||||||
|
switch(alt(a)){
|
||||||
|
case WAIT:
|
||||||
|
getexit--;
|
||||||
|
processexit(waitmsg);
|
||||||
|
free(waitmsg);
|
||||||
|
break;
|
||||||
|
case SLEEP:
|
||||||
|
pitadvance();
|
||||||
|
break;
|
||||||
|
case NOTIF:
|
||||||
|
notif.f(notif.arg);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
if(getexit == 0 && halt == 0)
|
||||||
|
launch();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int mainid;
|
||||||
|
|
||||||
|
void
|
||||||
|
sendnotif(void (*f)(void *), void *arg)
|
||||||
|
{
|
||||||
|
VmxNotif notif = {f, arg};
|
||||||
|
|
||||||
|
if(threadid() == mainid)
|
||||||
|
f(arg);
|
||||||
|
else
|
||||||
|
send(notifch, ¬if);
|
||||||
|
}
|
||||||
|
|
||||||
|
extern void vgainit(void);
|
||||||
|
extern void pciinit(void);
|
||||||
|
extern void pcibusmap(void);
|
||||||
|
extern void cpuidinit(void);
|
||||||
|
extern void vgafbparse(char *);
|
||||||
|
|
||||||
|
int cmdlinen;
|
||||||
|
char **cmdlinev;
|
||||||
|
int bootmodn;
|
||||||
|
char **bootmod;
|
||||||
|
|
||||||
|
static uvlong
|
||||||
|
siparse(char *s)
|
||||||
|
{
|
||||||
|
uvlong l;
|
||||||
|
char *p;
|
||||||
|
|
||||||
|
l = strtoull(s, &p, 0);
|
||||||
|
switch(*p){
|
||||||
|
case 'k': case 'K': p++; l *= 1<<10; break;
|
||||||
|
case 'm': case 'M': p++; l *= 1<<20; break;
|
||||||
|
case 'g': case 'G': p++; l *= 1<<30; break;
|
||||||
|
}
|
||||||
|
if(*p != 0) sysfatal("invalid argument: %s", s);
|
||||||
|
return l;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
usage(void)
|
||||||
|
{
|
||||||
|
char *blanks, *p;
|
||||||
|
|
||||||
|
blanks = strdup(argv0);
|
||||||
|
for(p = blanks; *p != 0; p++)
|
||||||
|
*p = ' ';
|
||||||
|
fprint(2, "usage: %s [ -M mem ] [ -c com1rd[,com1wr] ] [ -C com2rd[,com2r] ] [ -n nic ]\n", argv0);
|
||||||
|
fprint(2, " %s [ -d blockfile ] [ -m module ] [ -v vga ] kernel [ args ... ]\n", blanks);
|
||||||
|
threadexitsall("usage");
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
threadmain(int argc, char **argv)
|
||||||
|
{
|
||||||
|
static int (*edev[16])(char *);
|
||||||
|
static char *edevt[nelem(edev)];
|
||||||
|
static char *edevaux[nelem(edev)];
|
||||||
|
static int edevn;
|
||||||
|
static uvlong gmemsz = 64*1024*1024;
|
||||||
|
extern uintptr fbsz, fbaddr;
|
||||||
|
extern int textmode;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
quotefmtinstall();
|
||||||
|
mainid = threadid();
|
||||||
|
cpuidinit();
|
||||||
|
waitch = chancreate(sizeof(char *), 32);
|
||||||
|
sleepch = chancreate(sizeof(ulong), 32);
|
||||||
|
notifch = chancreate(sizeof(VmxNotif), 16);
|
||||||
|
|
||||||
|
ARGBEGIN {
|
||||||
|
case 'm':
|
||||||
|
bootmod = realloc(bootmod, (bootmodn + 1) * sizeof(char *));
|
||||||
|
bootmod[bootmodn++] = strdup(EARGF(usage()));
|
||||||
|
break;
|
||||||
|
case 'c':
|
||||||
|
uartinit(0, EARGF(usage()));
|
||||||
|
break;
|
||||||
|
case 'C':
|
||||||
|
uartinit(1, EARGF(usage()));
|
||||||
|
break;
|
||||||
|
case 'n':
|
||||||
|
assert(edevn < nelem(edev));
|
||||||
|
edev[edevn] = mkvionet;
|
||||||
|
edevt[edevn] = "virtio network";
|
||||||
|
edevaux[edevn++] = strdup(EARGF(usage()));
|
||||||
|
break;
|
||||||
|
case 'd':
|
||||||
|
assert(edevn < nelem(edev));
|
||||||
|
edev[edevn] = mkvioblk;
|
||||||
|
edevt[edevn] = "virtio block";
|
||||||
|
edevaux[edevn++] = strdup(EARGF(usage()));
|
||||||
|
break;
|
||||||
|
case 'M':
|
||||||
|
gmemsz = siparse(EARGF(usage()));
|
||||||
|
if(gmemsz != (uintptr) gmemsz) sysfatal("too much memory for address space");
|
||||||
|
break;
|
||||||
|
case 'v':
|
||||||
|
vgafbparse(EARGF(usage()));
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
usage();
|
||||||
|
} ARGEND;
|
||||||
|
if(argc < 1) usage();
|
||||||
|
cmdlinen = argc - 1;
|
||||||
|
cmdlinev = argv + 1;
|
||||||
|
|
||||||
|
mkregion(0, gmemsz, REGMEM);
|
||||||
|
if(fbsz != 0 && textmode == 0){
|
||||||
|
if(fbaddr + fbsz < fbaddr) sysfatal("invalid fb address");
|
||||||
|
if(fbaddr + fbsz < gmemsz) sysfatal("framebuffer overlaps with physical memory");
|
||||||
|
mkregion(fbaddr, fbsz, REGFB);
|
||||||
|
}
|
||||||
|
mksegment("vm");
|
||||||
|
vmxsetup();
|
||||||
|
loadkernel(argv[0]);
|
||||||
|
pciinit();
|
||||||
|
|
||||||
|
vgainit();
|
||||||
|
for(i = 0; i < edevn; i++)
|
||||||
|
if(edev[i](edevaux[i]) < 0)
|
||||||
|
sysfatal("%s: %r", edevt[i]);
|
||||||
|
|
||||||
|
pcibusmap();
|
||||||
|
runloop();
|
||||||
|
exits(nil);
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue